commit 9c06d70b3cc6f60ae906fbcace8510ac38d186de
Author: wehub-resource-sync <resource-sync@wehub.local>
Date:   Mon Jul 13 12:52:40 2026 +0800

    chore: import upstream snapshot with attribution

diff --git a/.agents/skills/cline-sdk/SKILL.md b/.agents/skills/cline-sdk/SKILL.md
new file mode 100644
index 0000000..7f7b061
--- /dev/null
+++ b/.agents/skills/cline-sdk/SKILL.md
@@ -0,0 +1,208 @@
+---
+name: cline-sdk
+description: Comprehensive Cline SDK skill for building AI agents. Covers the Agent runtime, ClineCore sessions, custom tools, plugins, events, LLM providers, scheduling, multi-agent teams, and production deployment. Use for any task involving @cline/sdk or its sub-packages.
+metadata:
+   references: agent, clinecore
+---
+
+# Cline SDK Skill
+
+Consolidated skill for building AI agents with the Cline SDK. Use the decision trees below to find the right entry point and API surface, then load detailed references.
+
+## Critical Rules
+
+Follow these rules in all Cline SDK code:
+
+1. Install with `npm install @cline/sdk`. The `@cline/sdk` package re-exports everything from `@cline/core`, `@cline/agents`, `@cline/llms`, and `@cline/shared`.
+2. Requires Node.js 22 or later.
+3. Use `createTool()` from `@cline/sdk` (or `@cline/shared`) to define tools. Tool names must be `snake_case`.
+4. Return errors as structured data from tool `execute` functions. Throwing counts as a "mistake" against the agent's mistake limit.
+5. Use `lifecycle: { completesRun: true }` on tools that should end the agent loop (e.g. a "submit answer" tool).
+6. When using `ClineCore`, always call `dispose()` when done to clean up resources.
+7. The standalone `Agent` and `ClineCore` have different event systems. For `Agent`: use `agent.subscribe()` to get `AgentRuntimeEvent` types (text streaming is `"assistant-text-delta"`, result text is `result.outputText`). For `ClineCore`: use `cline.subscribe()` to get `CoreSessionEvent` types (text streaming is `"chunk"` with `payload.type === "text"`, result text is `result.text`). There is no top-level `onEvent` field on `AgentRuntimeConfig` -- use `agent.subscribe()` or `hooks.onEvent` instead. Do not use event types like `"content_update"` or `"content_start"` with `agent.subscribe()` -- those are internal legacy types from the ClineCore adapter layer.
+
+## How to Use This Skill
+
+### Reference File Structure
+
+The two main API surfaces (`Agent` and `ClineCore`) follow a 4-file pattern. Cross-cutting concepts are single-file guides.
+
+Each main API surface in `./references/<api>/` contains:
+
+| File | Purpose | When to Read |
+|------|---------|--------------|
+| `REFERENCE.md` | Overview, when to use, quick start | Always read first |
+| `api.md` | Full API: classes, methods, config, types | Writing code |
+| `patterns.md` | Common patterns, best practices | Implementation guidance |
+| `gotchas.md` | Pitfalls, limitations, debugging | Troubleshooting |
+
+Cross-cutting concepts in `./references/<concept>/` have `REFERENCE.md` as the entry point.
+
+### Reading Order
+
+1. Start with `REFERENCE.md` for your chosen API surface
+2. Then read additional files relevant to your task:
+   - Writing agent code -> `api.md`
+   - Common patterns -> `patterns.md`
+   - Creating tools -> `tools/REFERENCE.md`
+   - Adding plugins/hooks -> `plugins/REFERENCE.md`
+   - Configuring LLM providers -> `providers/REFERENCE.md`
+   - Streaming events -> `events/REFERENCE.md`
+   - Deploying to production -> `production/REFERENCE.md`
+   - Scheduling agents -> `scheduling/REFERENCE.md`
+   - Multi-agent orchestration -> `multi-agent/REFERENCE.md`
+   - Debugging -> `gotchas.md`
+
+### Example Paths
+
+```
+./references/agent/REFERENCE.md           # Start here for lightweight agents
+./references/clinecore/REFERENCE.md       # Start here for full runtime
+./references/agent/api.md                 # Agent class, config, methods
+./references/tools/REFERENCE.md           # Creating and using tools
+./references/plugins/REFERENCE.md         # Plugin system
+./references/providers/REFERENCE.md       # LLM provider configuration
+```
+
+## Quick Decision Trees
+
+### "Which API surface should I use?"
+
+```
+Which API?
++-- I want a simple, stateless agent with custom tools
+|   +-- agent/ (Agent class from @cline/agents)
++-- I need session persistence, built-in tools, config discovery
+|   +-- clinecore/ (ClineCore from @cline/core)
++-- I want built-in file/shell/search/web tools
+|   +-- clinecore/ (has built-in tools; Agent does not)
++-- I want scheduled or recurring agents
+|   +-- clinecore/ (automation API)
++-- I need multi-process or multi-client session sharing
+|   +-- clinecore/ (hub-backed runtime)
++-- I'm building a browser-compatible agent
+|   +-- agent/ (no Node.js dependencies)
+```
+
+### "I need to create tools"
+
+```
+Tools?
++-- Define a custom tool with schema -> tools/REFERENCE.md
++-- Use built-in tools (bash, editor, read_files) -> tools/REFERENCE.md (built-in section)
++-- Control tool approval/policies -> tools/REFERENCE.md (policies section)
++-- Tool that ends the agent loop -> tools/REFERENCE.md (completion tools)
++-- Package tools as a reusable plugin -> plugins/REFERENCE.md
+```
+
+### "I need to handle events"
+
+```
+Events?
++-- Stream text/reasoning in real time -> events/REFERENCE.md
++-- Track token usage and costs -> events/REFERENCE.md
++-- Watch tool calls -> events/REFERENCE.md
++-- Detect completion/errors -> events/REFERENCE.md
++-- Hook into lifecycle stages -> plugins/REFERENCE.md
+```
+
+### "I need to configure a model provider"
+
+```
+Providers?
++-- Anthropic (Claude) -> providers/REFERENCE.md
++-- OpenAI (GPT) -> providers/REFERENCE.md
++-- Google (Gemini/Vertex) -> providers/REFERENCE.md
++-- AWS Bedrock -> providers/REFERENCE.md
++-- Mistral -> providers/REFERENCE.md
++-- OpenAI-compatible (vLLM, Together, etc.) -> providers/REFERENCE.md
++-- Custom/self-hosted provider -> providers/REFERENCE.md
+```
+
+### "I need plugins or hooks"
+
+```
+Plugins?
++-- Package tools + hooks together -> plugins/REFERENCE.md
++-- Observe tool calls (logging, metrics) -> plugins/REFERENCE.md
++-- Intercept lifecycle events -> plugins/REFERENCE.md
++-- Add system prompt rules -> plugins/REFERENCE.md
++-- Distribute via npm/git -> plugins/REFERENCE.md
+```
+
+### "I need multi-agent coordination"
+
+```
+Multi-agent?
++-- Spawn one-off background agents -> multi-agent/REFERENCE.md (sub-agents)
++-- Persistent cross-session teams -> multi-agent/REFERENCE.md (teams)
++-- Parent-child delegation -> multi-agent/REFERENCE.md (sub-agents)
++-- Peer-to-peer task board -> multi-agent/REFERENCE.md (teams)
+```
+
+### "I need scheduling or automation"
+
+```
+Scheduling?
++-- Recurring cron jobs -> scheduling/REFERENCE.md
++-- One-off scheduled tasks -> scheduling/REFERENCE.md
++-- Event-driven triggers -> scheduling/REFERENCE.md
++-- CLI schedule management -> scheduling/REFERENCE.md
+```
+
+### "I need to go to production"
+
+```
+Production?
++-- Error handling and status checks -> production/REFERENCE.md
++-- Cost control and token limits -> production/REFERENCE.md
++-- Observability (OpenTelemetry) -> production/REFERENCE.md
++-- Security and sandboxing -> production/REFERENCE.md
++-- Deployment patterns -> production/REFERENCE.md
+```
+
+### Troubleshooting Index
+
+- Agent loop not stopping -> `tools/REFERENCE.md` (completion tools)
+- Tool errors crashing the agent -> `agent/gotchas.md` or `clinecore/gotchas.md`
+- Provider auth failures -> `providers/REFERENCE.md`
+- Session not persisting -> `clinecore/gotchas.md`
+- Token usage too high -> `production/REFERENCE.md` (cost control)
+- Hub connection issues -> `clinecore/gotchas.md`
+- Plugin not loading -> `plugins/REFERENCE.md`
+- Events not firing -> `events/REFERENCE.md`
+
+## Product Index
+
+### API Surfaces
+| API | Entry File | Description |
+|-----|------------|-------------|
+| Agent | `./references/agent/REFERENCE.md` | Lightweight stateless agent loop |
+| ClineCore | `./references/clinecore/REFERENCE.md` | Full runtime with sessions, persistence, built-in tools |
+
+### Cross-Cutting Concepts
+| Concept | Entry File | Description |
+|---------|------------|-------------|
+| Tools | `./references/tools/REFERENCE.md` | Built-in and custom tool creation |
+| Plugins | `./references/plugins/REFERENCE.md` | Extension system with hooks |
+| Events | `./references/events/REFERENCE.md` | Real-time streaming events |
+| Providers | `./references/providers/REFERENCE.md` | LLM provider configuration |
+| Production | `./references/production/REFERENCE.md` | Deployment, security, observability |
+| Scheduling | `./references/scheduling/REFERENCE.md` | Cron jobs and automation |
+| Multi-Agent | `./references/multi-agent/REFERENCE.md` | Teams and sub-agents |
+
+### Package Map
+| Package | Purpose |
+|---------|---------|
+| `@cline/sdk` | Everything you need, install this one |
+| `@cline/core` | Sessions, persistence, built-in tools, config, hub |
+| `@cline/agents` | Stateless agent loop, tool orchestration, streaming |
+| `@cline/llms` | LLM provider gateway |
+| `@cline/shared` | Types, tool helpers, hook engine |
+
+## Resources
+
+Repository: https://github.com/cline/cline
+SDK Source: https://github.com/cline/cline/tree/main/sdk
+Documentation: https://docs.cline.bot/sdk/overview
+Discord: https://discord.gg/cline
diff --git a/.agents/skills/cline-sdk/references/agent/REFERENCE.md b/.agents/skills/cline-sdk/references/agent/REFERENCE.md
new file mode 100644
index 0000000..4fa40a7
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/agent/REFERENCE.md
@@ -0,0 +1,107 @@
+# Agent Runtime
+
+The `Agent` class (also exported as `AgentRuntime`) is the lightweight, stateless agent loop from `@cline/agents`. It handles the core iteration cycle: send messages to an LLM, execute tool calls, collect results, and repeat until the task is done.
+
+## When to Use Agent
+
+| Use Agent when... | Use ClineCore instead when... |
+|---|---|
+| You want a simple agent with custom tools | You need built-in tools (bash, editor, etc.) |
+| You want minimal dependencies | You need session persistence |
+| You need browser compatibility | You need config discovery from `.cline/` |
+| You're building a stateless worker | You need multi-process session sharing |
+| You want full control over the runtime | You want batteries-included setup |
+
+## Quick Start
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  systemPrompt: "You are a helpful assistant.",
+  tools: [],
+})
+
+const result = await agent.run("What is the capital of France?")
+console.log(result.outputText)
+```
+
+## Core Concepts
+
+The Agent operates in a loop:
+1. Accept user input (string, message, or array of messages)
+2. Build turn context (system prompt, messages, tools)
+3. Call the LLM provider
+4. If the model returns tool calls, execute them and loop back to step 3
+5. If the model returns text without tool calls, the run completes
+6. Emit events throughout for streaming
+
+The agent is stateless in the sense that it does not persist anything to disk. Conversation history is held in memory and can be accessed via `snapshot()`.
+
+## Key APIs
+
+- `new Agent(config)` or `createAgent(config)` - Create an agent
+- `agent.run(input)` - Start a run with user input
+- `agent.continue(input?)` - Continue an existing conversation
+- `agent.abort(reason?)` - Cancel an active run
+- `agent.subscribe(listener)` - Listen to streaming events
+- `agent.snapshot()` - Get current runtime state
+- `agent.restore(messages)` - Replace message history
+
+See `api.md` for full API details.
+
+## Multi-Turn Conversations
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  systemPrompt: "You are a helpful assistant.",
+  tools: [],
+})
+
+const first = await agent.run("What is 2 + 2?")
+console.log(first.outputText)
+
+const second = await agent.continue("Now multiply that by 3")
+console.log(second.outputText)
+```
+
+Use `agent.hasRun` to check if a run has already been executed, which determines whether to call `run()` or `continue()`.
+
+## Event Streaming
+
+Use `agent.subscribe()` to stream events in real time. Register the listener before calling `run()` to avoid missing early events.
+
+There is no top-level `onEvent` field on the Agent config. For an async alternative, use `hooks.onEvent` (see `api.md` and `gotchas.md`).
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  systemPrompt: "You are a helpful assistant.",
+  tools: [],
+})
+
+agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text)
+  }
+})
+
+const result = await agent.run("What is the capital of France?")
+```
+
+See `events/REFERENCE.md` for the full event type catalog.
+
+## Next Steps
+
+- `api.md` - Full Agent API reference
+- `patterns.md` - Common patterns and best practices
+- `gotchas.md` - Pitfalls and debugging
+- `../tools/REFERENCE.md` - Creating custom tools
+- `../events/REFERENCE.md` - Event system details
+- `../providers/REFERENCE.md` - Provider configuration
diff --git a/.agents/skills/cline-sdk/references/agent/api.md b/.agents/skills/cline-sdk/references/agent/api.md
new file mode 100644
index 0000000..76a008c
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/agent/api.md
@@ -0,0 +1,231 @@
+# Agent API Reference
+
+## Constructor
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agent = new Agent(config: AgentRuntimeConfig)
+```
+
+Also available via factory function:
+
+```typescript
+import { createAgent } from "@cline/sdk"
+
+const agent = createAgent(config)
+```
+
+## AgentRuntimeConfig
+
+Two config forms exist as a discriminated union:
+
+### With Provider ID (recommended)
+
+```typescript
+interface AgentRuntimeConfigWithProvider {
+  providerId: string          // e.g. "anthropic", "openai", "gemini"
+  modelId: string             // e.g. "claude-sonnet-4-6", "gpt-5.5"
+  apiKey?: string             // provider API key
+  baseUrl?: string            // custom endpoint
+  headers?: Record<string, string>
+
+  systemPrompt?: string
+  tools?: AgentTool[]
+  initialMessages?: AgentMessage[]
+  toolPolicies?: Record<string, ToolPolicy>
+  hooks?: Partial<AgentRuntimeHooks>
+  plugins?: AgentPlugin[]
+}
+```
+
+### With Pre-built Model
+
+```typescript
+interface AgentRuntimeConfigWithModel {
+  model: AgentModel            // pre-built model from gateway
+
+  systemPrompt?: string
+  tools?: AgentTool[]
+  initialMessages?: AgentMessage[]
+  toolPolicies?: Record<string, ToolPolicy>
+  hooks?: Partial<AgentRuntimeHooks>
+  plugins?: AgentPlugin[]
+}
+```
+
+Note: there is no top-level `onEvent` field on `AgentRuntimeConfig`. For event streaming, use `agent.subscribe()` or `hooks.onEvent` (see AgentRuntimeHooks below).
+
+## Methods
+
+### run(input)
+
+Start the agent with user input. Returns when the agent loop completes.
+
+```typescript
+const result: AgentRunResult = await agent.run("Build a REST API")
+```
+
+Input can be a string, an `AgentMessage`, or an array of `AgentMessage[]`.
+
+### continue(input?)
+
+Continue an existing conversation with optional new input.
+
+```typescript
+const result = await agent.continue("Now add authentication")
+```
+
+### abort(reason?)
+
+Cancel the currently active run.
+
+```typescript
+agent.abort("User cancelled")
+```
+
+### subscribe(listener)
+
+Register a listener for streaming events.
+
+```typescript
+const unsubscribe = agent.subscribe((event: AgentRuntimeEvent) => {
+  // handle event
+})
+
+// Later: stop listening
+unsubscribe()
+```
+
+### snapshot()
+
+Get the current runtime state including message history.
+
+```typescript
+const state: AgentRuntimeStateSnapshot = agent.snapshot()
+```
+
+### restore(messages)
+
+Replace the agent's message history.
+
+```typescript
+agent.restore(previousMessages)
+```
+
+### hasRun
+
+Boolean property indicating whether `run()` has been called at least once.
+
+```typescript
+if (agent.hasRun) {
+  await agent.continue(input)
+} else {
+  await agent.run(input)
+}
+```
+
+## AgentRunResult
+
+Returned by `run()` and `continue()`.
+
+```typescript
+interface AgentRunResult {
+  agentId: string
+  agentRole?: string
+  runId: string
+  status: "completed" | "aborted" | "failed"
+  iterations: number
+  outputText: string
+  messages: readonly AgentMessage[]
+  usage: AgentUsage
+  error?: Error
+}
+```
+
+### Status Values
+
+- `"completed"` - Agent finished normally
+- `"aborted"` - Cancelled via `abort()`
+- `"failed"` - Unrecoverable error
+
+## AgentMessage
+
+```typescript
+interface AgentMessage {
+  id: string
+  role: "user" | "assistant" | "tool"
+  content: AgentMessagePart[]
+  createdAt: number
+  metadata?: Record<string, unknown>
+  modelInfo?: { id: string; provider: string; family?: string }
+  metrics?: {
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens?: number
+    cacheWriteTokens?: number
+    cost?: number
+  }
+}
+```
+
+## AgentUsage
+
+```typescript
+interface AgentUsage {
+  inputTokens: number
+  outputTokens: number
+  cacheReadTokens: number
+  cacheWriteTokens: number
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalCost?: number
+}
+```
+
+## AgentRuntimeHooks
+
+```typescript
+interface AgentRuntimeHooks {
+  beforeRun?(context): AgentStopControl | undefined
+  afterRun?(context): void
+  beforeModel?(context): AgentBeforeModelResult | undefined
+  afterModel?(context): AgentStopControl | undefined
+  beforeTool?(context): AgentBeforeToolResult | undefined
+  afterTool?(context): AgentAfterToolResult | undefined
+  onEvent?(event: AgentRuntimeEvent): void | Promise<void>
+}
+```
+
+Hooks can intercept and modify behavior at each stage. Return a stop control from `beforeRun`, `afterModel`, or `beforeTool` to halt the agent loop.
+
+`hooks.onEvent` receives the same `AgentRuntimeEvent` types as `agent.subscribe()`, but hook callbacks are awaited (can be async), while `subscribe()` listeners are called synchronously. Use `subscribe()` for UI streaming and `hooks.onEvent` for async side effects like logging to an external service.
+
+## AgentRuntimeStateSnapshot
+
+```typescript
+interface AgentRuntimeStateSnapshot {
+  messages: readonly AgentMessage[]
+  usage: AgentUsage
+  iterations: number
+  status: string
+}
+```
+
+## Factory: createAgentRuntime
+
+Lower-level factory that returns the same `Agent` class:
+
+```typescript
+import { createAgentRuntime } from "@cline/sdk"
+
+const runtime = createAgentRuntime(config)
+```
+
+## See Also
+
+- `REFERENCE.md` - Overview and quick start
+- `patterns.md` - Common patterns
+- `../tools/REFERENCE.md` - Tool creation
+- `../events/REFERENCE.md` - Event types
+- `../providers/REFERENCE.md` - Provider setup
diff --git a/.agents/skills/cline-sdk/references/agent/gotchas.md b/.agents/skills/cline-sdk/references/agent/gotchas.md
new file mode 100644
index 0000000..8b4b945
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/agent/gotchas.md
@@ -0,0 +1,134 @@
+# Agent Gotchas
+
+## Agent Loop Never Stops
+
+If the agent keeps iterating without completing:
+
+- Make sure at least one tool has `lifecycle: { completesRun: true }` if you want the agent to explicitly finish.
+- Without any tools, the agent will complete after the model returns text without tool calls.
+- If using tools, ensure the system prompt guides the model toward calling the completion tool when done.
+- Check that `completesRun` tools return successfully (not throwing errors).
+
+## Tool Errors Count as Mistakes
+
+When a tool's `execute` function throws an exception, the SDK counts it as a "mistake." After too many mistakes, the agent stops with a `mistake_limit` finish reason.
+
+Instead, return errors as structured data:
+
+```typescript
+// Bad: throwing
+execute: async (input) => {
+  throw new Error("File not found")
+}
+
+// Good: returning error data
+execute: async (input) => {
+  return { error: "File not found", path: input.path }
+}
+```
+
+## run() vs continue()
+
+- Call `run()` for the first interaction. It sets up the conversation.
+- Call `continue()` for subsequent messages. It appends to the existing conversation.
+- Calling `run()` a second time resets the conversation history.
+- Use `agent.hasRun` to check which method to call.
+
+## Browser Compatibility
+
+`@cline/agents` (and by extension, the `Agent` class) is browser-safe with no Node.js dependencies. However, `@cline/core` and `ClineCore` require Node.js 22+. If you import from `@cline/sdk`, you get everything including the Node-only code. For browser usage, import directly from `@cline/agents`:
+
+```typescript
+import { Agent } from "@cline/agents"
+```
+
+## No Top-Level onEvent on Agent Config
+
+`AgentRuntimeConfig` does not have a top-level `onEvent` field. Passing `onEvent` to `new Agent({ onEvent: ... })` has no effect. There are two ways to receive events:
+
+```typescript
+// Option 1: subscribe() - synchronous, best for UI streaming
+const agent = new Agent({ ...config })
+agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text)
+  }
+})
+
+// Option 2: hooks.onEvent - awaited, best for async side effects
+const agent = new Agent({
+  ...config,
+  hooks: {
+    onEvent: async (event) => {
+      if (event.type === "assistant-text-delta") {
+        await logToService(event.text)
+      }
+    },
+  },
+})
+```
+
+Both receive the same `AgentRuntimeEvent` types. Prefer `subscribe()` for streaming UI.
+
+## Event Listener Timing
+
+Register event listeners via `subscribe()` before calling `run()`:
+
+```typescript
+// Good: subscribe before run
+agent.subscribe(handler)
+const result = await agent.run(input)
+
+// Bad: subscribing after run starts loses early events
+const promise = agent.run(input)
+agent.subscribe(handler)  // may miss events
+```
+
+## Tool Input Schema Matters
+
+The model uses the tool's `inputSchema` to decide what arguments to pass. A vague or missing schema leads to incorrect tool calls.
+
+- Use `z.enum()` for fixed value sets, not free-form strings
+- Describe every property with `.describe()` in Zod or `description` in JSON Schema
+- Include constraints (rate limits, max values) in the tool description
+
+## Memory and Long Conversations
+
+The Agent holds all messages in memory. For long-running conversations, memory usage grows with each turn. Consider:
+
+- Using `ClineCore` with compaction for long sessions
+- Periodically creating a new agent with a summary of the conversation
+- Monitoring `result.usage.totalInputTokens` to track context growth
+
+## Abort Signal Handling in Tools
+
+Long-running tools should respect the abort signal:
+
+```typescript
+execute: async (input, context) => {
+  for (const item of items) {
+    if (context.abortSignal?.aborted) {
+      return { partial: results, aborted: true }
+    }
+    results.push(await process(item))
+  }
+  return { results }
+}
+```
+
+## Provider API Key
+
+If you get authentication errors, check:
+
+- `apiKey` is set in the config or via environment variables
+- The key matches the `providerId` (e.g., Anthropic key for `providerId: "anthropic"`)
+- For OpenAI-compatible providers, both `apiKey` and `baseUrl` are set
+
+See `../providers/REFERENCE.md` for provider-specific setup.
+
+## See Also
+
+- `api.md` - Full API reference
+- `patterns.md` - Common patterns
+- `../tools/REFERENCE.md` - Tool creation
+- `../clinecore/REFERENCE.md` - Use ClineCore for persistence
diff --git a/.agents/skills/cline-sdk/references/agent/patterns.md b/.agents/skills/cline-sdk/references/agent/patterns.md
new file mode 100644
index 0000000..c0e43e2
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/agent/patterns.md
@@ -0,0 +1,258 @@
+# Agent Patterns
+
+## Interactive CLI Agent
+
+A multi-turn conversational agent in the terminal with streaming output:
+
+```typescript
+import { Agent } from "@cline/sdk"
+import * as readline from "node:readline"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  systemPrompt: "You are a helpful assistant. Keep responses concise.",
+  tools: [],
+})
+
+agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text)
+  }
+})
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+})
+
+function prompt(): void {
+  rl.question("\nYou: ", async (input) => {
+    const trimmed = input.trim()
+    if (!trimmed || trimmed === "exit") {
+      rl.close()
+      return
+    }
+
+    process.stdout.write("\nAssistant: ")
+
+    if (agent.hasRun) {
+      await agent.continue(trimmed)
+    } else {
+      await agent.run(trimmed)
+    }
+
+    process.stdout.write("\n")
+    prompt()
+  })
+}
+
+prompt()
+```
+
+## Conversational Agent (Slack Bot, Chat App)
+
+Maintain per-thread agents with conversation memory:
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agents = new Map<string, Agent>()
+
+async function handleMessage(threadId: string, message: string) {
+  let agent = agents.get(threadId)
+  if (!agent) {
+    agent = new Agent({
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4-6",
+      systemPrompt: "You are a concise assistant.",
+      tools: [],
+    })
+    agents.set(threadId, agent)
+  }
+
+  const result = agent.hasRun
+    ? await agent.continue(message)
+    : await agent.run(message)
+
+  return result.outputText
+}
+```
+
+## Streaming UI
+
+Build a real-time UI by handling events via `subscribe()`:
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  systemPrompt: "You are a helpful assistant.",
+  tools: [myTool],
+})
+
+agent.subscribe((event) => {
+  switch (event.type) {
+    case "assistant-text-delta":
+      ui.appendText(event.text)
+      break
+    case "assistant-message":
+      ui.endText()
+      break
+    case "turn-started":
+      ui.startTurn(event.iteration)
+      break
+    case "turn-finished":
+      if (event.toolCallCount > 0) ui.showToolCount(event.toolCallCount)
+      break
+    case "usage-updated":
+      ui.updateUsage(event.usage.inputTokens, event.usage.outputTokens)
+      break
+  }
+})
+
+const result = await agent.run("Hello!")
+```
+
+## Structured Output via Completion Tool
+
+Use a tool with `completesRun: true` to extract structured data:
+
+```typescript
+import { Agent, createTool } from "@cline/sdk"
+import { z } from "zod"
+
+const submitReview = createTool({
+  name: "submit_review",
+  description: "Submit the final code review with structured feedback.",
+  inputSchema: z.object({
+    summary: z.string(),
+    issues: z.array(z.object({
+      file: z.string(),
+      line: z.number(),
+      severity: z.enum(["error", "warning", "info"]),
+      message: z.string(),
+    })),
+    approved: z.boolean(),
+  }),
+  lifecycle: { completesRun: true },
+  execute: async (input) => input,
+})
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  systemPrompt: "Review the code diff and submit structured feedback.",
+  tools: [submitReview],
+})
+
+const result = await agent.run(diffContent)
+const review = result.toolCalls.find(tc => tc.name === "submit_review")
+console.log(review?.output)
+```
+
+## Agent with Abort/Timeout
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  systemPrompt: "Analyze this data.",
+  tools: [],
+})
+
+const timeout = setTimeout(() => agent.abort("Timeout"), 30_000)
+
+try {
+  const result = await agent.run(data)
+  if (result.status === "aborted") {
+    console.log("Agent was aborted")
+  } else {
+    console.log(result.outputText)
+  }
+} finally {
+  clearTimeout(timeout)
+}
+```
+
+## Agent with Plugins
+
+```typescript
+import { Agent } from "@cline/sdk"
+import type { AgentPlugin } from "@cline/sdk"
+
+const loggingPlugin: AgentPlugin = {
+  name: "logging",
+  manifest: { capabilities: ["hooks"] },
+  setup() {},
+  hooks: {
+    beforeTool({ toolCall }) {
+      console.log(`Calling tool: ${toolCall.toolName}`)
+    },
+    afterRun({ result }) {
+      console.log(`Completed in ${result.iterations} iterations`)
+    },
+  },
+}
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  systemPrompt: "You are a helpful assistant.",
+  tools: [myTool],
+  plugins: [loggingPlugin],
+})
+```
+
+## Restoring State Across Sessions
+
+Save and restore agent state manually:
+
+```typescript
+// Save state
+const snapshot = agent.snapshot()
+const serialized = JSON.stringify(snapshot.messages)
+
+// Later: restore
+const agent2 = new Agent({ ...config })
+const messages = JSON.parse(serialized)
+agent2.restore(messages)
+const result = await agent2.continue("Continue where we left off")
+```
+
+For automatic persistence, use `ClineCore` instead.
+
+## Pre-Built Model via Gateway
+
+For advanced provider configuration:
+
+```typescript
+import { Agent } from "@cline/sdk"
+import { createGateway } from "@cline/llms"
+
+const gateway = createGateway({
+  providerConfigs: [
+    { providerId: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY },
+    { providerId: "openai", apiKey: process.env.OPENAI_API_KEY },
+  ],
+})
+
+const model = gateway.createAgentModel({
+  providerId: "anthropic",
+  modelId: "claude-opus-4-7",
+})
+
+const agent = new Agent({
+  model,
+  systemPrompt: "You are a helpful assistant.",
+  tools: [],
+})
+```
+
+## See Also
+
+- `api.md` - Full API reference
+- `gotchas.md` - Common pitfalls
+- `../tools/REFERENCE.md` - Creating tools
+- `../plugins/REFERENCE.md` - Plugin system
diff --git a/.agents/skills/cline-sdk/references/clinecore/REFERENCE.md b/.agents/skills/cline-sdk/references/clinecore/REFERENCE.md
new file mode 100644
index 0000000..d1b9e01
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/clinecore/REFERENCE.md
@@ -0,0 +1,131 @@
+# ClineCore Runtime
+
+`ClineCore` is the full-featured runtime from `@cline/core`. It wraps the `Agent` loop with session persistence, built-in tools (bash, editor, file reading, search, web fetch), config discovery, plugin loading, and optional hub-backed multi-process support.
+
+## When to Use ClineCore
+
+| Use ClineCore when... | Use Agent instead when... |
+|---|---|
+| You need built-in tools (bash, editor, etc.) | You only need custom tools |
+| You want session persistence to disk | Stateless is fine |
+| You need config discovery from `.cline/` dirs | You handle config yourself |
+| You want scheduled/automated agents | You don't need scheduling |
+| You need multi-client session sharing | Single-process is fine |
+| You're building a full application | You want minimal dependencies |
+
+## Quick Start
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+const session = await cline.start({
+  prompt: "Set up CI with GitHub Actions",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    cwd: "/path/to/project",
+    enableTools: true,
+  },
+})
+
+console.log(session.result?.text)
+await cline.dispose()
+```
+
+## Core Concepts
+
+### Sessions
+
+Every `cline.start()` call creates a session with a unique ID. Sessions persist their messages and metadata to SQLite. You can list, read, resume, and delete sessions.
+
+### Built-in Tools
+
+ClineCore provides these tools automatically when `enableTools: true`:
+
+| Tool | Description |
+|------|-------------|
+| `bash` | Execute shell commands |
+| `editor` | Edit files |
+| `read_files` | Read file contents |
+| `apply_patch` | Apply unified diffs |
+| `search` | Search file contents and structure |
+| `fetch_web` | HTTP requests and web content |
+
+### Config Discovery
+
+ClineCore watches `.cline/` directories for:
+- Rules (system prompt additions)
+- Skills (domain knowledge)
+- Workflows (multi-step procedures)
+- Hooks (lifecycle logic)
+- Plugins (tool + hook bundles)
+- MCP servers (external tool providers)
+
+### Backend Modes
+
+| Mode | Description |
+|------|-------------|
+| `"auto"` (default) | Tries to connect to a local hub; falls back to in-process if unavailable |
+| `"local"` | In-process execution, local SQLite storage, no hub |
+| `"hub"` | Requires a compatible local WebSocket hub; fails if unavailable |
+| `"remote"` | Connects to an explicit remote hub endpoint |
+
+The default mode is `"auto"`. For simple scripts and CLI tools, `"local"` avoids hub discovery overhead. Hub mode enables multi-client session sharing (e.g., a dashboard watching a running session from another process).
+
+## Key APIs
+
+- `ClineCore.create(options)` - Create and initialize
+- `cline.start(input)` - Start a new session
+- `cline.send({ sessionId, prompt })` - Send follow-up message
+- `cline.subscribe(listener)` - Listen to session events
+- `cline.list()` - List sessions
+- `cline.get(sessionId)` - Get session metadata
+- `cline.readMessages(sessionId)` - Read persisted messages
+- `cline.getAccumulatedUsage(sessionId)` - Token/cost totals
+- `cline.abort(sessionId)` - Abort a session
+- `cline.delete(sessionId)` - Delete a session
+- `cline.dispose()` - Clean up resources
+
+See `api.md` for full API details.
+
+## Event Streaming
+
+`cline.subscribe()` emits `CoreSessionEvent` types. These are different from the `AgentRuntimeEvent` types emitted by the standalone `Agent` class -- see `../events/REFERENCE.md` for the full comparison.
+
+```typescript
+cline.subscribe((event) => {
+  switch (event.type) {
+    case "chunk":
+      if (event.payload.type === "text") {
+        process.stdout.write(event.payload.text)
+      }
+      break
+    case "ended":
+      console.log(`Session ended: ${event.payload.finishReason}`)
+      break
+  }
+})
+```
+
+ClineCore results use `AgentResult` with `.text` (not `.outputText` like the standalone Agent's `AgentRunResult`).
+
+## Session Persistence
+
+Sessions are stored at:
+```
+~/.cline/data/sessions/
+  sessions.db       # SQLite database
+  [session-id].json # Message history
+```
+
+## Next Steps
+
+- `api.md` - Full ClineCore API reference
+- `patterns.md` - Common patterns and best practices
+- `gotchas.md` - Pitfalls and debugging
+- `../tools/REFERENCE.md` - Custom tool creation
+- `../plugins/REFERENCE.md` - Plugin system
+- `../scheduling/REFERENCE.md` - Scheduled agents
diff --git a/.agents/skills/cline-sdk/references/clinecore/api.md b/.agents/skills/cline-sdk/references/clinecore/api.md
new file mode 100644
index 0000000..8abfce9
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/clinecore/api.md
@@ -0,0 +1,304 @@
+# ClineCore API Reference
+
+## Creating ClineCore
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create(options: ClineCoreOptions)
+```
+
+### ClineCoreOptions
+
+```typescript
+interface ClineCoreOptions {
+  clientName: string                     // identifies your app
+  distinctId?: string                    // user/instance identifier
+  backendMode?: "auto" | "local" | "hub" | "remote"
+  hub?: HubOptions
+  remote?: RemoteOptions
+  capabilities?: RuntimeCapabilities
+  toolPolicies?: Record<string, ToolPolicy>
+  automation?: boolean | ClineCoreAutomationOptions
+  fetch?: typeof fetch
+}
+```
+
+### RuntimeCapabilities
+
+```typescript
+interface RuntimeCapabilities {
+  requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>
+  // ... other capability callbacks
+}
+```
+
+## Starting Sessions
+
+### start(input)
+
+```typescript
+const session = await cline.start(input: ClineCoreStartInput)
+```
+
+Returns a `StartSessionResult`:
+
+```typescript
+interface StartSessionResult {
+  sessionId: string
+  manifest: SessionManifest
+  manifestPath: string
+  messagesPath: string
+  result?: AgentResult
+}
+```
+
+### ClineCoreStartInput
+
+```typescript
+interface ClineCoreStartInput {
+  prompt: string
+  config: CoreSessionConfig
+  source?: string
+  interactive?: boolean
+  sessionMetadata?: Record<string, unknown>
+  initialMessages?: AgentMessage[]
+  toolPolicies?: Record<string, ToolPolicy>
+  capabilities?: RuntimeCapabilities
+}
+```
+
+### CoreSessionConfig
+
+```typescript
+interface CoreSessionConfig {
+  cwd?: string                          // working directory
+  providerId: string                    // LLM provider
+  modelId: string                       // model identifier
+  apiKey?: string                       // provider API key
+  systemPrompt?: string                 // custom system prompt
+  tools?: readonly AgentTool[]          // additional custom tools
+  enableTools?: boolean                 // enable built-in tools
+  hooks?: Partial<AgentRuntimeHooks>    // runtime hooks
+  extensions?: AgentPlugin[]            // plugins loaded inline
+  pluginPaths?: string[]                // paths to plugin packages
+  extensionLoading?: "isolated" | "direct"
+  extensionContext?: {                  // context passed to plugin setup()
+    workspace?: { rootPath: string; cwd: string }
+  }
+  checkpointConfig?: CoreCheckpointConfig
+  compactionConfig?: CoreCompactionConfig
+  telemetry?: ITelemetryService
+  logger?: BasicLogger
+  enableSpawnAgent?: boolean            // enable sub-agent spawning
+  enableAgentTeams?: boolean            // enable team coordination
+  teamName?: string                     // team identifier
+}
+```
+
+`extensions` passes plugin objects directly. `pluginPaths` points to directories with `package.json` containing a `cline.plugins` field. Set `extensionContext.workspace` so plugins receive `ctx.workspaceInfo` in their `setup()` call -- without it, `ctx.workspaceInfo` is undefined.
+
+## Follow-Up Messages
+
+### send({ sessionId, prompt })
+
+Send a follow-up message to an existing session:
+
+```typescript
+const result = await cline.send({
+  sessionId: session.sessionId,
+  prompt: "Now add authentication",
+})
+```
+
+Returns `AgentResult | undefined`.
+
+## Event Subscription
+
+### subscribe(listener, options?)
+
+```typescript
+const unsubscribe = cline.subscribe(
+  (event: CoreSessionEvent) => {
+    // handle events
+  },
+  { sessionId: "optional-filter" }
+)
+```
+
+### CoreSessionEvent
+
+```typescript
+type CoreSessionEvent =
+  | { type: "chunk"; payload: SessionChunkEvent }
+  | { type: "agent_event"; payload: { sessionId: string, event: AgentEvent } }
+  | { type: "ended"; payload: SessionEndedEvent }
+  | { type: "team_progress"; payload: SessionTeamProgressEvent }
+  | { type: "status"; payload: { sessionId: string, status: string } }
+  | { type: "hook"; payload: SessionToolEvent }
+```
+
+## Session Management
+
+### list(limit?, options?)
+
+```typescript
+const sessions: SessionRecord[] = await cline.list(50)
+```
+
+### get(sessionId)
+
+```typescript
+const session: SessionRecord = await cline.get(sessionId)
+```
+
+### readMessages(sessionId)
+
+```typescript
+const messages: AgentMessage[] = await cline.readMessages(sessionId)
+```
+
+### getAccumulatedUsage(sessionId)
+
+```typescript
+const usage = await cline.getAccumulatedUsage(sessionId)
+// usage.usage - root agent only
+// usage.aggregateUsage - root + subagents/teammates
+```
+
+### update(sessionId, updates)
+
+```typescript
+await cline.update(sessionId, { title: "New title" })
+```
+
+### abort(sessionId, reason?)
+
+```typescript
+await cline.abort(sessionId, "User cancelled")
+```
+
+### stop(sessionId)
+
+```typescript
+await cline.stop(sessionId)
+```
+
+### delete(sessionId)
+
+```typescript
+await cline.delete(sessionId)
+```
+
+### restore(input)
+
+Restore a session from a checkpoint:
+
+```typescript
+await cline.restore({ sessionId, checkpointId })
+```
+
+### dispose(reason?)
+
+Clean up all resources. Always call this when done:
+
+```typescript
+await cline.dispose("Shutting down")
+```
+
+## AgentResult
+
+Returned by session operations:
+
+```typescript
+interface AgentResult {
+  text: string
+  usage: LegacyAgentUsage
+  messages: MessageWithMetadata[]
+  toolCalls: ToolCallRecord[]
+  iterations: number
+  finishReason: "completed" | "max_iterations" | "aborted" | "mistake_limit" | "error"
+  model: { id: string; provider: string; info?: ModelInfo }
+  startedAt: Date
+  endedAt: Date
+  durationMs: number
+}
+```
+
+## Tool Policies
+
+Control tool access at the session level:
+
+```typescript
+const session = await cline.start({
+  prompt: "Review the code",
+  config: { ... },
+  toolPolicies: {
+    read_files: { autoApprove: true },
+    bash: { autoApprove: false },
+    editor: { enabled: false },
+  },
+})
+```
+
+### ToolPolicy
+
+```typescript
+interface ToolPolicy {
+  enabled?: boolean       // false = tool is hidden from the model
+  autoApprove?: boolean   // false = requires approval callback
+}
+```
+
+## Interactive Approval
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  capabilities: {
+    requestToolApproval: async (request) => {
+      console.log(`Tool: ${request.toolName}, Input: ${JSON.stringify(request.input)}`)
+      const approved = await askUser(`Allow ${request.toolName}?`)
+      return { approved }
+    },
+  },
+})
+```
+
+## Automation API
+
+When `automation` is enabled in `ClineCore.create()`:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  automation: true,
+})
+
+// Access automation methods
+cline.automation.start()
+cline.automation.stop()
+cline.automation.reconcile(specs)
+cline.automation.ingestEvent(event)
+cline.automation.listEvents()
+cline.automation.listSpecs()
+cline.automation.listRuns()
+```
+
+## Settings API
+
+```typescript
+// Read settings
+const settings = await cline.settings.list()
+
+// Toggle tools, plugins, MCP servers
+await cline.settings.toggle({ type: "tool", name: "bash", enabled: true })
+```
+
+## See Also
+
+- `REFERENCE.md` - Overview and quick start
+- `patterns.md` - Common patterns
+- `gotchas.md` - Pitfalls
+- `../tools/REFERENCE.md` - Tool creation
+- `../plugins/REFERENCE.md` - Plugin system
diff --git a/.agents/skills/cline-sdk/references/clinecore/gotchas.md b/.agents/skills/cline-sdk/references/clinecore/gotchas.md
new file mode 100644
index 0000000..240aab8
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/clinecore/gotchas.md
@@ -0,0 +1,148 @@
+# ClineCore Gotchas
+
+## Always Call dispose()
+
+`ClineCore` holds resources (file watchers, database connections, hub connections). Failing to call `dispose()` can leave orphan processes and file locks.
+
+```typescript
+const cline = await ClineCore.create({ clientName: "my-app" })
+try {
+  // ... use cline
+} finally {
+  await cline.dispose()
+}
+```
+
+## Node.js 22 Required
+
+ClineCore and `@cline/core` require Node.js 22 or later. If you're on an older version, you'll get runtime errors. Check with `node --version`.
+
+## Session Config vs Global Config
+
+Tool policies can be set at two levels:
+- Global: in `ClineCore.create({ toolPolicies })` -- applies to all sessions
+- Per-session: in `cline.start({ toolPolicies })` -- overrides global for that session
+
+Per-session policies take precedence.
+
+## enableTools Must Be Explicit
+
+Built-in tools (bash, editor, read_files, etc.) are not available unless you set `enableTools: true` in the session config:
+
+```typescript
+await cline.start({
+  prompt: "Read package.json",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    enableTools: true,  // required for built-in tools
+  },
+})
+```
+
+Without this, the agent only has access to custom tools you provide via `config.tools`.
+
+## cwd Matters for Built-in Tools
+
+Built-in tools like `bash`, `editor`, and `read_files` operate relative to `config.cwd`. If not set, they use the process working directory. Always set it explicitly for predictable behavior:
+
+```typescript
+config: {
+  cwd: "/absolute/path/to/project",
+  // ...
+}
+```
+
+## Hub Startup Latency
+
+With `backendMode: "auto"`, the first session may be slow if a hub daemon needs to be spawned. For immediate responsiveness:
+- Use `backendMode: "local"` for in-process execution (fastest startup)
+- Pre-warm the hub with `cline hub ensure` CLI command
+- Accept the one-time startup cost and let subsequent sessions reuse the hub
+
+## Session Storage Location
+
+Sessions are stored at `~/.cline/data/sessions/`. This includes:
+- `sessions.db` - SQLite database with session metadata
+- `[session-id].json` - Individual message history files
+
+If you're running in a container or ephemeral environment, these paths may not persist across restarts.
+
+## requestToolApproval Blocks Execution
+
+When a tool policy has `autoApprove: false` and you provide a `requestToolApproval` callback, the agent loop blocks until your callback resolves. If your callback never resolves (e.g., waiting for user input that never comes), the session hangs.
+
+For automated pipelines, either:
+- Set all tools to `autoApprove: true`
+- Implement a timeout in your approval callback
+
+## Plugin Discovery Paths
+
+ClineCore discovers plugins from:
+- Global: `~/.cline/plugins/`
+- Workspace: `.cline/plugins/`
+
+For SDK consumers, pass plugins via `extensions: [plugin]` or `pluginPaths: ["./path"]` in the session config.
+
+If a plugin isn't loading, verify:
+- The file is in one of the discovery directories, or passed via `extensions`/`pluginPaths`
+- The file exports a default plugin object with a non-empty `manifest.capabilities` array
+- Every `api.register*` call in `setup()` has a matching capability declared
+- If `hooks` is present on the plugin, `"hooks"` is in `capabilities`
+
+## extensionContext.workspace Is Required for Plugins
+
+If your plugins use `ctx.workspaceInfo` (e.g., to resolve workspace paths), you must set `extensionContext.workspace` in the session config. Without it, `ctx.workspaceInfo` is undefined:
+
+```typescript
+await cline.start({
+  config: {
+    extensions: [myPlugin],
+    extensionContext: {
+      workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+    },
+  },
+})
+```
+
+The CLI sets this automatically, but SDK consumers must set it explicitly.
+
+## send() Requires an Active Session
+
+`cline.send()` only works on sessions that are still active. If a session has already completed, `send()` may return `undefined` or fail. Check session status with `cline.get(sessionId)` first.
+
+## Result May Be Undefined
+
+`session.result` can be `undefined` if the session was started but hasn't completed yet (e.g., in a non-blocking hub mode). Check for this:
+
+```typescript
+const session = await cline.start({ ... })
+if (session.result) {
+  console.log(session.result.text)
+} else {
+  console.log("Session started but not yet complete")
+}
+```
+
+## Compaction and Long Sessions
+
+For long-running sessions, message history grows and eventually exceeds the model's context window. ClineCore handles this via compaction, which summarizes older messages. Configure it via `compactionConfig`:
+
+```typescript
+config: {
+  compactionConfig: {
+    strategy: "summarize",
+    // ...
+  },
+}
+```
+
+The default strategy works for most cases, but extremely long sessions may benefit from tuning.
+
+## See Also
+
+- `api.md` - Full API reference
+- `patterns.md` - Common patterns
+- `../agent/gotchas.md` - Agent-level gotchas
+- `../tools/REFERENCE.md` - Tool troubleshooting
+- `../providers/REFERENCE.md` - Provider troubleshooting
diff --git a/.agents/skills/cline-sdk/references/clinecore/patterns.md b/.agents/skills/cline-sdk/references/clinecore/patterns.md
new file mode 100644
index 0000000..379eff6
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/clinecore/patterns.md
@@ -0,0 +1,279 @@
+# ClineCore Patterns
+
+## Basic Session with Built-in Tools
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+const session = await cline.start({
+  prompt: "Read package.json and summarize the dependencies",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    cwd: process.cwd(),
+    enableTools: true,
+  },
+})
+
+console.log(session.result?.text)
+await cline.dispose()
+```
+
+## Streaming Session with UI Updates
+
+```typescript
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+cline.subscribe((event) => {
+  switch (event.type) {
+    case "chunk":
+      if (event.payload.type === "text") {
+        ui.appendText(event.payload.text)
+      }
+      break
+    case "ended":
+      ui.showComplete(event.payload.finishReason)
+      break
+  }
+})
+
+await cline.start({
+  prompt: "Refactor the auth module",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    cwd: "/path/to/project",
+    enableTools: true,
+  },
+})
+```
+
+## Multi-Turn Session
+
+```typescript
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+const session = await cline.start({
+  prompt: "Create a new Express server",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    cwd: "/path/to/project",
+    enableTools: true,
+  },
+})
+
+// Follow-up
+const result = await cline.send({
+  sessionId: session.sessionId,
+  prompt: "Now add a health check endpoint",
+})
+
+console.log(result?.text)
+await cline.dispose()
+```
+
+## Tiered Permission Model
+
+Auto-approve reads, require approval for writes:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  toolPolicies: {
+    read_files: { autoApprove: true },
+    search: { autoApprove: true },
+    fetch_web: { autoApprove: true },
+    bash: { autoApprove: false },
+    editor: { autoApprove: false },
+    apply_patch: { autoApprove: false },
+  },
+  capabilities: {
+    requestToolApproval: async (request) => {
+      const approved = await promptUser(
+        `Allow ${request.toolName}?\n${JSON.stringify(request.input, null, 2)}`
+      )
+      return { approved }
+    },
+  },
+})
+```
+
+## Custom Tools Alongside Built-ins
+
+```typescript
+import { ClineCore, createTool } from "@cline/sdk"
+import { z } from "zod"
+
+const deployTool = createTool({
+  name: "deploy",
+  description: "Deploy the application to the specified environment.",
+  inputSchema: z.object({
+    environment: z.enum(["staging", "production"]),
+  }),
+  execute: async (input) => {
+    const result = await runDeployment(input.environment)
+    return { url: result.url, status: "deployed" }
+  },
+})
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+await cline.start({
+  prompt: "Deploy the app to staging",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    cwd: process.cwd(),
+    enableTools: true,
+    tools: [deployTool],
+  },
+})
+```
+
+## Session with Plugins
+
+Load plugins inline with `extensions` and provide workspace context so plugins can access `ctx.workspaceInfo`:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+import myPlugin from "./my-plugin"
+
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  backendMode: "local",
+})
+
+await cline.start({
+  prompt: "Do the thing my plugin enables",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    cwd: process.cwd(),
+    enableTools: true,
+    extensions: [myPlugin],
+    extensionContext: {
+      workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+    },
+  },
+})
+
+await cline.dispose()
+```
+
+For directory-based plugin packages, use `pluginPaths` instead:
+
+```typescript
+config: {
+  pluginPaths: ["./my-cline-plugin"],
+  extensionContext: {
+    workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+  },
+}
+```
+
+See `../plugins/REFERENCE.md` for the full plugin authoring guide.
+
+## Session Listing and Replay
+
+```typescript
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+// List recent sessions
+const sessions = await cline.list(10)
+for (const session of sessions) {
+  console.log(`${session.id}: ${session.title}`)
+}
+
+// Read messages from a past session
+const messages = await cline.readMessages(sessions[0].id)
+for (const msg of messages) {
+  console.log(`[${msg.role}] ${msg.content}`)
+}
+
+// Check usage
+const usage = await cline.getAccumulatedUsage(sessions[0].id)
+console.log(`Total tokens: ${usage.aggregateUsage.totalInputTokens + usage.aggregateUsage.totalOutputTokens}`)
+```
+
+## Graceful Shutdown
+
+```typescript
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+process.on("SIGTERM", async () => {
+  await cline.dispose("SIGTERM received")
+  process.exit(0)
+})
+
+// Run sessions...
+```
+
+## Stateless Worker Pattern
+
+For request/response workloads (API endpoints, queue consumers):
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({
+  clientName: "worker",
+  backendMode: "local",
+})
+
+async function handleRequest(prompt: string, workspace: string) {
+  const session = await cline.start({
+    prompt,
+    config: {
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4-6",
+      cwd: workspace,
+      enableTools: true,
+    },
+  })
+
+  return {
+    text: session.result?.text,
+    usage: session.result?.usage,
+    sessionId: session.sessionId,
+  }
+}
+```
+
+## Hub-Backed Multi-Client
+
+Multiple clients can attach to the same session:
+
+```typescript
+// Process 1: start session
+const cline = await ClineCore.create({
+  clientName: "backend",
+  backendMode: "hub",
+})
+
+const session = await cline.start({
+  prompt: "Long running refactor task",
+  config: { ... },
+})
+
+// Process 2: attach and stream events
+const viewer = await ClineCore.create({
+  clientName: "dashboard",
+  backendMode: "hub",
+})
+
+viewer.subscribe((event) => {
+  dashboard.render(event)
+}, { sessionId: session.sessionId })
+```
+
+## See Also
+
+- `api.md` - Full API reference
+- `gotchas.md` - Common pitfalls
+- `../tools/REFERENCE.md` - Tool creation
+- `../plugins/REFERENCE.md` - Plugin system
+- `../scheduling/REFERENCE.md` - Scheduled agents
diff --git a/.agents/skills/cline-sdk/references/events/REFERENCE.md b/.agents/skills/cline-sdk/references/events/REFERENCE.md
new file mode 100644
index 0000000..76f273a
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/events/REFERENCE.md
@@ -0,0 +1,269 @@
+# Events
+
+The Cline SDK has three event layers. Which one you use depends on whether you're working with the standalone `Agent` class or `ClineCore`.
+
+## Which Events Do I Get?
+
+| If you use... | You subscribe with... | You receive... | Text streaming event |
+|---|---|---|---|
+| Standalone `Agent` | `agent.subscribe()` | `AgentRuntimeEvent` | `assistant-text-delta` |
+| `ClineCore` | `cline.subscribe()` | `CoreSessionEvent` | `chunk` (with `payload.type === "text"`) |
+
+These are different event types with different shapes. Do not mix them up.
+
+## Layer 1: AgentRuntimeEvent (Standalone Agent)
+
+Emitted by the `Agent` class via `agent.subscribe()`. This is what you get when using `new Agent(...)` directly. Every event includes a `snapshot` field with the current `AgentRuntimeStateSnapshot`.
+
+### Run Lifecycle
+
+```typescript
+{ type: "run-started", snapshot }
+{ type: "run-finished", snapshot, result: AgentRunResult }
+{ type: "run-failed", snapshot, error: Error }
+```
+
+### Turns
+
+```typescript
+{ type: "turn-started", snapshot, iteration: number }
+{ type: "turn-finished", snapshot, iteration: number, toolCallCount: number }
+```
+
+### Text Streaming
+
+```typescript
+// Streaming text delta (arrives as chunks during generation)
+{ type: "assistant-text-delta", snapshot, iteration: number, text: string, accumulatedText: string }
+
+// Streaming reasoning delta (when model uses extended thinking)
+{ type: "assistant-reasoning-delta", snapshot, iteration: number, text: string }
+
+// Complete assistant message after model finishes
+{ type: "assistant-message", snapshot, iteration: number, message: AgentMessage, finishReason: string }
+```
+
+### Messages
+
+```typescript
+// Fired when any message (user or assistant) is added to conversation history
+{ type: "message-added", snapshot, message: AgentMessage }
+```
+
+### Tool Events
+
+```typescript
+{ type: "tool-started", snapshot, toolCall: { toolName: string, toolCallId: string, input: unknown } }
+{ type: "tool-updated", snapshot, toolCall: { toolName: string, toolCallId: string }, update: string }
+{ type: "tool-finished", snapshot, toolCall: { toolName: string, toolCallId: string }, message: AgentMessage }
+```
+
+### Usage
+
+```typescript
+{
+  type: "usage-updated",
+  snapshot,
+  usage: {
+    inputTokens: number,
+    outputTokens: number,
+    cacheReadTokens?: number,
+    cacheWriteTokens?: number,
+    totalCost?: number,
+  },
+}
+```
+
+### Notices
+
+```typescript
+{ type: "status-notice", snapshot, message: string, metadata?: Record<string, unknown> }
+```
+
+### Subscribing
+
+Use `agent.subscribe()`. Register the listener before calling `run()` to avoid missing early events.
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  systemPrompt: "You are a helpful assistant.",
+  tools: [],
+})
+
+agent.subscribe((event) => {
+  switch (event.type) {
+    case "assistant-text-delta":
+      process.stdout.write(event.text)
+      break
+    case "tool-started":
+      console.log(`\nUsing tool: ${event.toolCall.toolName}`)
+      break
+    case "usage-updated":
+      console.log(`Cost: $${event.usage.totalCost?.toFixed(4)}`)
+      break
+    case "run-finished":
+      console.log(`\nDone: ${event.result.status}`)
+      break
+  }
+})
+
+const result = await agent.run("Hello!")
+```
+
+You can also receive events through hooks (these are awaited, so they can be async):
+
+```typescript
+const agent = new Agent({
+  ...config,
+  hooks: {
+    onEvent: async (event) => {
+      // Same AgentRuntimeEvent types as subscribe()
+    },
+  },
+})
+```
+
+## Layer 2: AgentEvent (ClineCore Internal)
+
+When using `ClineCore`, a `RuntimeEventAdapter` translates Layer 1 events into a legacy format called `AgentEvent`. You do not interact with this layer directly -- it is projected into `CoreSessionEvent` for subscribers. The key mappings:
+
+| AgentRuntimeEvent (Layer 1) | AgentEvent (Layer 2) |
+|---|---|
+| `turn-started` | `iteration_start` |
+| `turn-finished` | `iteration_end` |
+| `assistant-text-delta` | `content_start` (text) |
+| `assistant-message` | `content_end` (text) |
+| `tool-started` | `content_start` (tool) |
+| `tool-updated` | `content_update` (tool) |
+| `tool-finished` | `content_end` (tool) |
+| `usage-updated` | `usage` (with computed deltas) |
+| `run-finished` | `done` |
+| `run-failed` | `error` |
+| `run-started`, `message-added` | (suppressed, not emitted) |
+
+This layer exists for backwards compatibility. If you see event types like `content_update` or `iteration_start` in other documentation, they refer to this layer, not to what `agent.subscribe()` emits.
+
+## Layer 3: CoreSessionEvent (ClineCore Subscriber)
+
+Emitted by `ClineCore` via `cline.subscribe()`. These are higher-level session events.
+
+```typescript
+type CoreSessionEvent =
+  | { type: "chunk"; payload: SessionChunkEvent }
+  | { type: "agent_event"; payload: { sessionId: string, event: AgentEvent } }
+  | { type: "ended"; payload: SessionEndedEvent }
+  | { type: "team_progress"; payload: SessionTeamProgressEvent }
+  | { type: "status"; payload: { sessionId: string, status: string } }
+  | { type: "hook"; payload: SessionToolEvent }
+```
+
+### SessionChunkEvent
+
+```typescript
+interface SessionChunkEvent {
+  type: "text" | "reasoning"
+  text: string
+  sessionId: string
+}
+```
+
+### SessionEndedEvent
+
+```typescript
+interface SessionEndedEvent {
+  sessionId: string
+  finishReason: "completed" | "max_iterations" | "aborted" | "mistake_limit" | "error"
+  result?: AgentResult
+}
+```
+
+### Subscribing
+
+```typescript
+cline.subscribe((event) => {
+  switch (event.type) {
+    case "chunk":
+      if (event.payload.type === "text") {
+        process.stdout.write(event.payload.text)
+      }
+      break
+    case "ended":
+      console.log(`Finished: ${event.payload.finishReason}`)
+      break
+  }
+})
+```
+
+Filter by session:
+
+```typescript
+cline.subscribe(handler, { sessionId: "specific-session-id" })
+```
+
+## Hub Events (Layer 3b)
+
+When ClineCore runs in hub mode (via `backendMode: "hub"` or `"auto"` when a hub is available), events are projected over WebSocket using `HubEventName` types like `assistant.delta`, `iteration.started`, `tool.started`, etc. You do not interact with these directly -- `cline.subscribe()` still gives you `CoreSessionEvent` regardless of backend mode.
+
+## Result Type Differences
+
+The standalone Agent and ClineCore return different result types:
+
+| API | Result type | Text property |
+|---|---|---|
+| `agent.run()` | `AgentRunResult` | `result.outputText` |
+| `cline.start()` / `cline.send()` | `AgentResult` | `result.text` |
+
+## Common Patterns
+
+### Streaming Text (Standalone Agent)
+
+```typescript
+agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text)
+  }
+})
+```
+
+### Streaming Text (ClineCore)
+
+```typescript
+cline.subscribe((event) => {
+  if (event.type === "chunk" && event.payload.type === "text") {
+    process.stdout.write(event.payload.text)
+  }
+})
+```
+
+### Usage Tracking (Standalone Agent)
+
+```typescript
+agent.subscribe((event) => {
+  if (event.type === "usage-updated" && event.usage.totalCost) {
+    console.log(`Running cost: $${event.usage.totalCost.toFixed(4)}`)
+  }
+})
+```
+
+### Tool Call Logging (Standalone Agent)
+
+```typescript
+agent.subscribe((event) => {
+  if (event.type === "tool-started") {
+    console.log(`Tool started: ${event.toolCall.toolName}`)
+  }
+  if (event.type === "tool-finished") {
+    console.log(`Tool finished: ${event.toolCall.toolName}`)
+  }
+})
+```
+
+## See Also
+
+- `../agent/REFERENCE.md` - Agent runtime overview
+- `../clinecore/REFERENCE.md` - ClineCore session management
+- `../plugins/REFERENCE.md` - Plugin hooks for lifecycle events
+- `../production/REFERENCE.md` - Observability in production
diff --git a/.agents/skills/cline-sdk/references/multi-agent/REFERENCE.md b/.agents/skills/cline-sdk/references/multi-agent/REFERENCE.md
new file mode 100644
index 0000000..173cb1b
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/multi-agent/REFERENCE.md
@@ -0,0 +1,157 @@
+# Multi-Agent Coordination
+
+The Cline SDK supports two models for multi-agent work: sub-agents (parent-child) and teams (peer-to-peer).
+
+## Sub-Agents vs Teams
+
+| Feature | Sub-Agents | Teams |
+|---------|-----------|-------|
+| Enable with | `enableSpawnAgent: true` | `enableAgentTeams: true` |
+| Persistence | Session-scoped only | Across sessions |
+| Coordination | Parent-child hierarchy | Peer-to-peer |
+| Shared state | None | Task board, mailbox, mission log |
+| Best for | One-off delegation | Complex multi-session projects |
+
+## Sub-Agents
+
+Sub-agents are spawned by a parent agent during a run. They execute independently and report results back.
+
+### Enabling Sub-Agents
+
+```typescript
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+await cline.start({
+  prompt: "Refactor the auth module and update tests",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    enableSpawnAgent: true,
+    enableTools: true,
+  },
+})
+```
+
+When `enableSpawnAgent` is true, the agent gets access to sub-agent tools:
+
+| Tool | Description |
+|------|-------------|
+| `start_subagent` | Spawn a background agent with a task |
+| `message_subagent` | Send a message to a running sub-agent |
+| `handoff_to_agent` | Delegate the current task entirely |
+| `submit_and_exit` | Signal completion |
+
+### How Sub-Agents Work
+
+1. The parent agent decides a subtask can be delegated
+2. It calls `start_subagent` with a role, task description, and optionally a preset
+3. The sub-agent runs independently in the background
+4. The parent can check status or send follow-up messages
+5. Sub-agent results are available to the parent when complete
+
+## Teams
+
+Teams provide persistent, cross-session coordination between agents.
+
+### Enabling Teams
+
+```typescript
+await cline.start({
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    enableAgentTeams: true,
+    teamName: "auth-sprint",
+    enableTools: true,
+  },
+})
+```
+
+### Team Tools
+
+When `enableAgentTeams` is true, the coordinator agent gets:
+
+| Tool | Description |
+|------|-------------|
+| `team_spawn_teammate` | Create a new agent with a role and task |
+| `team_delegate_task` | Assign a task to an existing teammate |
+| `team_check_status` | Check on a delegated task's progress |
+| `team_get_result` | Get the completed result from a teammate |
+
+### Team Persistence
+
+Teams store shared state in:
+
+```
+~/.cline/data/teams/[team-name]/
+  task-board.json    # task assignments and status
+  mailbox.json       # inter-agent messages
+  mission-log.json   # coordination log
+```
+
+This state persists across sessions, so team members can pick up where they left off.
+
+### CLI Team Access
+
+```bash
+cline --team-name auth-sprint "Continue the auth refactor"
+```
+
+## Choosing Between Sub-Agents and Teams
+
+Use sub-agents when:
+- You need one-off parallel execution within a single session
+- Tasks are independent and don't need to communicate with each other
+- Results only matter to the parent agent
+
+Use teams when:
+- Work spans multiple sessions over time
+- Agents need to coordinate and share progress
+- Tasks have dependencies between them
+- You want a persistent record of multi-agent collaboration
+
+## Patterns
+
+### Parallel Research with Sub-Agents
+
+A parent agent spawns multiple sub-agents to research different topics simultaneously:
+
+```typescript
+await cline.start({
+  prompt: `Research these three topics in parallel:
+    1. Current best practices for JWT auth
+    2. OAuth 2.0 provider comparison
+    3. Session management patterns
+    Spawn a sub-agent for each topic, then synthesize the results.`,
+  config: {
+    enableSpawnAgent: true,
+    enableTools: true,
+    // ...
+  },
+})
+```
+
+### Team Sprint
+
+A coordinator manages a multi-session project:
+
+```typescript
+await cline.start({
+  prompt: `You are the coordinator for the auth-sprint team.
+    Review the task board and delegate the next highest-priority task
+    to a teammate. Check status on any in-progress tasks.`,
+  config: {
+    enableAgentTeams: true,
+    teamName: "auth-sprint",
+    enableTools: true,
+    // ...
+  },
+})
+```
+
+## See Also
+
+- `../clinecore/REFERENCE.md` - ClineCore runtime
+- `../clinecore/api.md` - Session config for teams
+- `../tools/REFERENCE.md` - Tool system
+- `../plugins/REFERENCE.md` - Plugin system
diff --git a/.agents/skills/cline-sdk/references/plugins/REFERENCE.md b/.agents/skills/cline-sdk/references/plugins/REFERENCE.md
new file mode 100644
index 0000000..6bcc4bf
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/plugins/REFERENCE.md
@@ -0,0 +1,649 @@
+# Plugins
+
+A Cline plugin is a TypeScript module that extends any agent built on the Cline SDK. The same plugin runs in the Cline CLI, VS Code and JetBrains extensions, and any custom app built on `@cline/core`.
+
+A plugin can:
+
+- Register tools the model can call.
+- Hook into the agent loop before/after runs, model calls, and tool calls.
+- Rewrite provider messages before they hit the model (custom compaction, redaction, context shaping).
+- Register slash commands, prompt rules, providers, and automation event types.
+
+A plugin ships in one of two shapes:
+
+1. Single-file plugin -- one `.ts` file that exports a default plugin object. Drop it in a discovery folder and it loads.
+2. Plugin package -- a directory with `package.json`, npm dependencies, and optionally bundled assets. Installable via `cline plugin install`.
+
+Both shapes use the same plugin API.
+
+## The Mental Model
+
+When the host starts a session, it builds a registry of plugins and runs four phases:
+
+1. resolve -- collect the plugin objects.
+2. validate -- check each plugin's `manifest`. Capabilities must be non-empty; declared hook stages must have matching handlers; if `hooks` is present, `"hooks"` must be in `capabilities`.
+3. setup -- call each plugin's `setup(api, ctx)` once. This is where you `registerTool`, `registerCommand`, etc.
+4. activate -- registry is frozen, the agent loop starts, and your hooks/tools are live.
+
+Two invariants the registry enforces:
+
+- Every contribution requires a matching capability. Calling `api.registerRule(...)` without `"rules"` in `manifest.capabilities` throws.
+- Capabilities and handlers must agree. Declaring `"hooks"` without a `hooks` object, or vice versa, fails validation.
+
+After validation, registration is one-shot -- no dynamic register/unregister during the session.
+
+## The Smallest Working Plugin
+
+```typescript
+import type { AgentPlugin } from "@cline/core"
+import { createTool } from "@cline/core"
+
+const plugin: AgentPlugin = {
+  name: "hello-plugin",
+  manifest: {
+    capabilities: ["tools"],
+  },
+  setup(api, ctx) {
+    api.registerTool(
+      createTool({
+        name: "say_hello",
+        description: "Greet a person by name.",
+        inputSchema: {
+          type: "object",
+          properties: { name: { type: "string" } },
+          required: ["name"],
+        },
+        async execute({ name }: { name: string }) {
+          return { greeting: `Hello, ${name}!` }
+        },
+      }),
+    )
+  },
+}
+
+export default plugin
+```
+
+The agent will see `say_hello` as a callable tool.
+
+## The Manifest
+
+```typescript
+manifest: {
+  capabilities: ["tools", "hooks"],   // required, non-empty array
+  paths?: string[],                   // optional, multi-entry packages
+  providerIds?: string[],             // optional, provider plugins
+  modelIds?: string[],                // optional, model plugins
+}
+```
+
+### The Complete Capability List
+
+| Capability | What It Unlocks in `api` |
+|-----------|--------------------------|
+| `"tools"` | `api.registerTool()` |
+| `"commands"` | `api.registerCommand()` (slash commands in chat surfaces) |
+| `"rules"` | `api.registerRule()` (string injected into the system prompt) |
+| `"messageBuilders"` | `api.registerMessageBuilder()` (rewrites provider-bound messages) |
+| `"providers"` | `api.registerProvider()` (custom model provider) |
+| `"automationEvents"` | `api.registerAutomationEventType()` and `ctx.automation?.ingestEvent()` |
+| `"hooks"` | The runtime `hooks` object on the plugin (lifecycle callbacks) |
+
+You declare any combination -- most real plugins need 1-3 capabilities.
+
+## setup(api, ctx) -- The Registration Phase
+
+`setup()` runs once per session before the agent loop starts. Everything you register here is frozen for the lifetime of the session.
+
+### The api Object
+
+Each `register*` method requires the matching capability in your manifest:
+
+```typescript
+api.registerTool(tool)                              // requires "tools"
+api.registerCommand({ name, description, handler }) // requires "commands"
+api.registerRule({ id, content, source })            // requires "rules"
+api.registerMessageBuilder({ name, build })          // requires "messageBuilders"
+api.registerProvider({ name, description })          // requires "providers"
+api.registerAutomationEventType({ eventType, source }) // requires "automationEvents"
+```
+
+### The ctx Object -- Host-Provided Session Context
+
+The second argument carries everything the host knows about the current session. All fields are optional, so feature-detect before using them -- the same plugin must work in hosts that supply less context (unit tests, sandboxed plugin processes).
+
+```typescript
+ctx.session?.sessionId       // string, stable core session id
+ctx.client?.name             // host: "cline-cli", "cline-vscode", etc.
+ctx.user                     // authenticated user/org info, when available
+ctx.workspaceInfo            // { rootPath, hint, latestGitBranchName,
+                             //   latestGitCommitHash, associatedRemoteUrls }
+ctx.automation?.ingestEvent  // emit normalized automation events
+ctx.logger?.log              // structured logger scoped to this plugin
+ctx.telemetry                // ITelemetryService, only present in-process
+```
+
+Two rules about `ctx.workspaceInfo`:
+
+1. Always prefer `ctx.workspaceInfo?.rootPath` over `process.cwd()`. The CLI may have been launched with `--cwd` without calling `chdir`, and VS Code workspaces don't share a single CWD. `workspaceInfo` is sourced from the session config and is always correct.
+2. Don't use `import.meta.url` tricks to find "the workspace". That gives you the plugin's own location, not the user's project.
+
+### Persisting State Across Hooks
+
+`setup()` runs first; hooks fire later. The simplest way to share state is module-level variables:
+
+```typescript
+let sessionWorkspaceRoot: string | undefined
+let sessionBranch: string | undefined
+
+const plugin: AgentPlugin = {
+  name: "metrics",
+  manifest: { capabilities: ["hooks"] },
+  setup(api, ctx) {
+    sessionWorkspaceRoot = ctx.workspaceInfo?.rootPath
+    sessionBranch = ctx.workspaceInfo?.latestGitBranchName
+  },
+  hooks: {
+    beforeTool({ toolCall, input }) {
+      if (sessionBranch === "main" && toolCall.toolName === "run_commands") {
+        // inspect input, optionally block
+      }
+      return undefined
+    },
+  },
+}
+```
+
+A single Node process may host multiple sessions concurrently. If your plugin will run in a multi-session host, key your state by `ctx.session?.sessionId`:
+
+```typescript
+const stateBySession = new Map<string, MyState>()
+setup(api, ctx) {
+  const id = ctx.session?.sessionId
+  if (id) stateBySession.set(id, /* ... */)
+}
+```
+
+## Runtime Hooks
+
+Runtime hooks are typed in-process callbacks on the same hook layer the runtime uses internally. They run inside the agent loop with full type information -- no IPC, no JSON marshaling.
+
+Declare `"hooks"` in `manifest.capabilities`, then add a `hooks` property:
+
+```typescript
+const plugin: AgentPlugin = {
+  name: "metrics",
+  manifest: { capabilities: ["hooks"] },
+  hooks: {
+    beforeRun(ctx) { /* ... */ },
+    beforeTool({ toolCall, input }) { /* ... */ },
+    afterTool({ toolCall, result }) { /* ... */ },
+    afterRun({ result }) { /* ... */ },
+    onEvent(event) { /* ... */ },
+  },
+}
+```
+
+### The Seven Hooks
+
+| Hook | Fires | Can Stop the Loop? | Common Uses |
+|------|-------|--------------------|-------------|
+| `beforeRun` | Before the runtime loop starts | Yes | Greet, log, attach session metadata |
+| `afterRun` | After the runtime loop finishes (success, abort, or fail) | No | Notifications, metrics, persistent logs |
+| `beforeModel` | Before each model request | Yes (mutate req) | Inject context, last-mile prompt edits |
+| `afterModel` | After each model response, before tool execution | Yes | Block based on model output |
+| `beforeTool` | Before each tool execution | Yes (`{ stop }`) | Audit, redact, block dangerous tools |
+| `afterTool` | After each tool execution | Can replace result | Post-process, redact secrets in tool output |
+| `onEvent` | On every `AgentRuntimeEvent` emitted by the runtime | No | Streaming UIs, telemetry pipes |
+
+### Stopping the Loop from a Hook
+
+Several hooks return an optional control object. The most common pattern is `beforeTool` blocking a destructive tool call:
+
+```typescript
+beforeTool({ toolCall, input }) {
+  if (toolCall.toolName === "run_commands") {
+    const { commands } = input as { commands?: string[] }
+    if (sessionBranch === "main" && commands?.some(c => c.startsWith("git push"))) {
+      return { stop: true, reason: "Blocked git push on protected branch" }
+    }
+  }
+  return undefined  // explicit "continue"
+}
+```
+
+Returning `undefined` (or omitting `return`) lets execution continue normally.
+
+### afterRun Semantics
+
+`afterRun` fires for every terminal status -- `completed`, `aborted`, `failed`. If you only want to act on success:
+
+```typescript
+afterRun({ result }) {
+  if (result.status !== "completed") return
+  // notify, log success metrics, etc.
+}
+```
+
+### Plugin Hooks vs File Hooks
+
+The runtime supports two hook systems:
+
+- File hooks -- external scripts in `.cline/hooks/` invoked with serialized JSON. Right for user/workspace-specific scripts that don't ship with code.
+- Plugin runtime hooks -- typed in-process callbacks. Right when the behavior belongs to a reusable extension and needs typed access to the runtime.
+
+Core adapts file hooks onto the runtime hook layer, so you don't need both. If you're shipping a plugin, write it as runtime hooks.
+
+## Message Builders
+
+Message builders rewrite the provider-bound message list before the model call. They run after runtime messages are converted into SDK message blocks but before core's built-in safety builder.
+
+Use them for:
+
+- Custom compaction policies (replace middle history with a summary).
+- Redacting PII or secrets before they reach the provider.
+- Reshaping context for a specific model's strengths.
+
+```typescript
+api.registerMessageBuilder({
+  name: "summarize-middle-history",
+  build(messages) {
+    if (estimateTokens(messages) < THRESHOLD) return messages
+    return [...prefix, summary, ...recent]
+  },
+})
+```
+
+Multiple builders run in registration order; the output of one is the input of the next.
+
+When to use `beforeModel` instead: reach for the `beforeModel` hook only if you need the runtime snapshot or want to mutate the request object itself. Pure message rewrites belong in a builder.
+
+## Automation Events
+
+Plugins can declare normalized event types and emit them into Cline automation. Hosts that don't have automation enabled simply ignore both -- feature-detect `ctx.automation`.
+
+```typescript
+manifest: { capabilities: ["automationEvents"] },
+
+setup(api, ctx) {
+  api.registerAutomationEventType({
+    eventType: "github.pull_request.opened",
+    source: "github",
+    description: "A new GitHub PR was opened",
+    attributesSchema: { /* JSON Schema for envelope.attributes */ },
+  })
+
+  if (!ctx.automation) return  // host has no automation
+  ctx.automation.ingestEvent({
+    eventId: "pr-1234",
+    eventType: "github.pull_request.opened",
+    source: "github",
+    subject: "owner/repo#1234",
+    occurredAt: new Date().toISOString(),
+    attributes: { /* ... */ },
+  })
+}
+```
+
+## Loading a Plugin
+
+There are three ways a plugin gets into a session:
+
+### Auto-Discovery (CLI)
+
+The CLI scans these directories on startup:
+
+- `<workspace>/.cline/plugins/` -- project-scoped plugins.
+- `~/.cline/plugins/` -- user-scoped plugins.
+
+Drop a `.ts` or `.js` file in, run `cline`, done:
+
+```bash
+mkdir -p .cline/plugins
+cp my-plugin.ts .cline/plugins/
+cline -i "do the thing my plugin enables"
+```
+
+### Explicit extensions in SDK Config
+
+When you build your own host with `ClineCore`, pass the plugin object directly:
+
+```typescript
+import plugin from "./my-plugin"
+import { ClineCore } from "@cline/core"
+
+const host = await ClineCore.create({ backendMode: "local" })
+await host.start({
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+    cwd: process.cwd(),
+    enableTools: true,
+    systemPrompt: "You are a helpful assistant.",
+    extensions: [plugin],
+    extensionContext: {
+      workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+    },
+  },
+  prompt: "...",
+  interactive: false,
+})
+```
+
+### pluginPaths for Directory-Based Plugins
+
+When the plugin is a directory with `package.json`, point `pluginPaths` at the directory:
+
+```typescript
+config: {
+  pluginPaths: ["./path/to/my-plugin-package"],
+}
+```
+
+Or install with the CLI:
+
+```bash
+cline plugin install ./path/to/my-plugin-package
+cline plugin install @scope/my-cline-plugin       # from npm
+cline plugin install --git github.com/owner/repo  # from git
+```
+
+## Single-File Plugin Template
+
+Save as `my-plugin.ts`, drop in `.cline/plugins/`:
+
+```typescript
+import { type AgentPlugin, ClineCore, createTool } from "@cline/core"
+
+let sessionRoot: string | undefined
+
+const plugin: AgentPlugin = {
+  name: "my-plugin",
+  manifest: {
+    capabilities: ["tools", "hooks"],
+  },
+
+  setup(api, ctx) {
+    sessionRoot = ctx.workspaceInfo?.rootPath
+
+    api.registerTool(
+      createTool({
+        name: "do_thing",
+        description: "Do the thing this plugin exists for.",
+        inputSchema: {
+          type: "object",
+          properties: { target: { type: "string" } },
+          required: ["target"],
+        },
+        async execute(input) {
+          const { target } = input as { target: string }
+          return { ok: true, target, root: sessionRoot }
+        },
+      }),
+    )
+  },
+
+  hooks: {
+    beforeRun() {
+      console.log("[my-plugin] run started")
+    },
+    afterRun({ result }) {
+      if (result.status !== "completed") return
+      console.log(`[my-plugin] done in ${result.iterations} iteration(s)`)
+    },
+  },
+}
+
+async function runDemo(): Promise<void> {
+  const host = await ClineCore.create({ backendMode: "local" })
+  try {
+    const result = await host.start({
+      config: {
+        providerId: "anthropic",
+        modelId: "claude-sonnet-4-6",
+        apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+        cwd: process.cwd(),
+        enableTools: true,
+        systemPrompt: "You are a helpful assistant. Use tools when needed.",
+        extensions: [plugin],
+        extensionContext: {
+          workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+        },
+      },
+      prompt: "Use do_thing on the target 'world'.",
+      interactive: false,
+    })
+    console.log(result.result?.text ?? "")
+  } finally {
+    await host.dispose()
+  }
+}
+
+if (import.meta.main) {
+  await runDemo()
+}
+
+export { plugin, runDemo }
+export default plugin
+```
+
+Copy it, rename the tool, swap in your logic. The `runDemo()` function lets you test with `ANTHROPIC_API_KEY=sk-... bun run my-plugin.ts`.
+
+## Plugin Package
+
+Use a plugin package when you need npm dependencies, multiple entry points, bundled assets, or npm/git distribution.
+
+### Layout
+
+```
+my-cline-plugin/
++-- package.json
++-- tsconfig.json          (optional, for local typechecking)
++-- index.ts               (the plugin entry point)
++-- README.md
++-- assets/                (optional, bundled content)
+    +-- templates/
+    +-- schemas/
+```
+
+### package.json -- The Discovery Contract
+
+```json
+{
+  "name": "my-cline-plugin",
+  "version": "0.1.0",
+  "private": true,
+  "description": "What this plugin does, in one sentence.",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "cline": {
+    "plugins": [
+      {
+        "paths": ["./index.ts"],
+        "capabilities": ["tools", "hooks"]
+      }
+    ]
+  },
+  "peerDependencies": {
+    "@cline/core": "*"
+  },
+  "peerDependenciesMeta": {
+    "@cline/core": { "optional": true }
+  },
+  "dependencies": {
+    "zod": "^4.1.5"
+  }
+}
+```
+
+Key fields:
+
+- `type: "module"` -- required. Cline plugins are ES modules.
+- `cline.plugins` -- the discovery contract. Array of entries, each with `paths` (entry files) and `capabilities` (pre-declared, validated before importing).
+- `peerDependencies` for `@cline/core` -- the host already provides it. Marking it optional lets you typecheck in isolation.
+
+### Bundling Assets
+
+Resolve asset paths with `import.meta.url`, not `process.cwd()`:
+
+```typescript
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { readFileSync, existsSync } from "node:fs"
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url))
+const TEMPLATES_DIR = join(MODULE_DIR, "assets", "templates")
+
+function loadTemplate(name: string): string | undefined {
+  const path = join(TEMPLATES_DIR, `${name}.md`)
+  return existsSync(path) ? readFileSync(path, "utf8") : undefined
+}
+```
+
+This is the only place `import.meta.url` is appropriate in a plugin -- locating files inside the plugin package. For workspace paths, always use `ctx.workspaceInfo?.rootPath`.
+
+### The Override Pattern (Bundled / Global / Project)
+
+A package can ship default assets and let users override them. The convention is a three-tier lookup, last write wins by `name`:
+
+1. bundled -- files inside the plugin package (defaults shipped with the plugin).
+2. global -- files under `~/.cline/data/settings/<kind>/` (user overrides).
+3. project -- files under `<workspace>/.cline/<kind>/` (project overrides).
+
+### Multiple Plugin Entries
+
+If your package exposes more than one plugin, list each in `cline.plugins`:
+
+```json
+"cline": {
+  "plugins": [
+    { "paths": ["./tools-plugin.ts"], "capabilities": ["tools"] },
+    { "paths": ["./hooks-plugin.ts"], "capabilities": ["hooks"] }
+  ]
+}
+```
+
+Each entry file should `export default` its own plugin object.
+
+## Testing Your Plugin
+
+### Unit Tests
+
+The plugin object is plain data. Drive `setup()` against a minimal context and exercise tools directly:
+
+```typescript
+import plugin from "../my-plugin"
+
+const tools: unknown[] = []
+const api = {
+  registerTool: (t: unknown) => tools.push(t),
+  registerCommand: () => {},
+  registerRule: () => {},
+  registerMessageBuilder: () => {},
+  registerProvider: () => {},
+  registerAutomationEventType: () => {},
+}
+await plugin.setup?.(api as never, {
+  workspaceInfo: { rootPath: "/tmp/fake-workspace" },
+})
+
+// Now `tools` contains the registered tools -- call tool.execute(input, ctx)
+```
+
+### End-to-End with runDemo()
+
+Add a `runDemo()` in your plugin file (see the single-file template above) that boots a real `ClineCore` session:
+
+```bash
+ANTHROPIC_API_KEY=sk-... bun run my-plugin.ts
+```
+
+### CLI Smoke Test
+
+```bash
+mkdir -p .cline/plugins
+cp my-plugin.ts .cline/plugins/
+cline -i "trigger something that exercises the plugin"
+```
+
+For packages:
+
+```bash
+cline plugin install ./my-cline-plugin
+cline -i "..."
+```
+
+If the plugin fails validation or setup, the CLI prints a clear error and continues without it.
+
+## Common Gotchas
+
+- "capabilities must be a non-empty array" -- you forgot `manifest.capabilities`, or it's `[]`.
+- "registerRule requires the 'rules' capability" -- capability/handler drift. Add `"rules"` to capabilities, or stop calling `registerRule`.
+- Tool not visible to the model -- check `enableTools: true` on the session config, and that you're declaring `"tools"` in capabilities.
+- `ctx.workspaceInfo` is undefined in SDK tests -- the host didn't pass `extensionContext.workspace`. In SDK code, set it explicitly (see the ClineCore loading example above).
+- State leaking across sessions -- module-level variables are shared across sessions in the same process. Key by `ctx.session?.sessionId` if your host runs multiple sessions concurrently.
+- `afterRun` firing on aborts -- guard with `if (result.status !== "completed") return`.
+- Heavy work in `setup()` -- `setup()` blocks session start. Defer expensive work into the first tool call or `beforeRun`.
+- Importing host internals -- only import from `@cline/core`. Reaching into host-specific packages (e.g. CLI internals) will break in non-CLI hosts.
+- Sandboxed plugins and `telemetry` -- telemetry is process-local. Feature-detect `ctx.telemetry` and expect it to be undefined in sandboxed plugin processes.
+- Resolving bundled assets -- use `import.meta.url` + `fileURLToPath` to find files inside your package; never `process.cwd()`. For workspace paths, do the opposite: use `ctx.workspaceInfo?.rootPath`, never `import.meta.url`.
+- Plugin name collisions -- `name` must be unique within a session. If two plugins share a name, validation fails. Namespace by package (`my-org-redactor`, not `redactor`).
+
+## Decision Guide -- Which Extension Point?
+
+| You want to... | Use |
+|----------------|-----|
+| Give the model a new capability | `registerTool` |
+| Add a slash command in chat surfaces | `registerCommand` |
+| Inject text into the system prompt | `registerRule` |
+| Rewrite messages before they hit the provider | `registerMessageBuilder` |
+| Add a custom model provider | `registerProvider` |
+| Emit normalized cron/webhook events | `registerAutomationEventType` + `ctx.automation` |
+| Observe or steer the agent loop | `hooks.*` |
+| Block a dangerous tool call | `hooks.beforeTool` returning `{ stop: true }` |
+| Notify on completion | `hooks.afterRun` (gate on `status === "completed"`) |
+| Tweak each model request | `hooks.beforeModel` |
+| Stream events to a UI | `hooks.onEvent` |
+| Ship reusable templates with the plugin | Bundle assets next to `index.ts`, resolve via `import.meta.url` |
+| Let users override defaults globally or per-project | Three-tier lookup: bundled / global / project |
+
+## Pre-Ship Checklist
+
+- `manifest.capabilities` is a non-empty array.
+- Every `api.register*` call has a matching capability declared.
+- If `hooks` is present, `"hooks"` is in `capabilities`.
+- `ctx.workspaceInfo?.rootPath` is used for workspace paths (not `process.cwd()`).
+- Optional `ctx` fields are feature-detected.
+- Tool names are snake_case verbs; descriptions are written for the model.
+- Tool inputs have JSON Schema with `required` set.
+- `afterRun` handlers gate on `result.status === "completed"` if they only want successes.
+- State that must not leak between concurrent sessions is keyed by `ctx.session?.sessionId`.
+- (Package) `package.json` has `type: "module"`, `cline.plugins`, and `@cline/core` as an optional peer dep.
+- (Package) Bundled assets resolved via `import.meta.url`, not `process.cwd()`.
+- Smoke test: drop the plugin into `.cline/plugins/` (or `cline plugin install`), run `cline -i "..."`, watch it work.
+
+## Plugin Examples from SDK
+
+The SDK repo includes these example plugins:
+
+| Plugin | Description |
+|--------|-------------|
+| `weather-metrics.ts` | Tool registration + lifecycle metrics |
+| `mac-notify.ts` | macOS Notification Center alerts |
+| `custom-compaction.ts` | Custom message compaction via message builders |
+| `background-terminal.ts` | Detached shell job management |
+| `automation-events.ts` | Plugin-emitted automation events |
+| `gitignore-read-files-guard.ts` | File access policy enforcement via beforeTool |
+| `web-search.ts` | Web search via Exa API |
+| `typescript-lsp/` | TypeScript Language Service tools (plugin package) |
+| `agents-squad/` | Multi-agent team orchestration (plugin package) |
+
+## See Also
+
+- `../tools/REFERENCE.md` - Tool creation
+- `../events/REFERENCE.md` - Event system
+- `../agent/REFERENCE.md` - Using plugins with Agent
+- `../clinecore/REFERENCE.md` - Using plugins with ClineCore
diff --git a/.agents/skills/cline-sdk/references/production/REFERENCE.md b/.agents/skills/cline-sdk/references/production/REFERENCE.md
new file mode 100644
index 0000000..5be32e6
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/production/REFERENCE.md
@@ -0,0 +1,253 @@
+# Going to Production
+
+Guidelines for deploying Cline SDK agents in production environments.
+
+## Error Handling
+
+Always check the result status:
+
+```typescript
+const result = await agent.run(input)
+
+switch (result.status) {
+  case "completed":
+    console.log("Success:", result.outputText)
+    break
+  case "aborted":
+    console.log("Cancelled:", result.error?.message)
+    break
+  case "failed":
+    console.error("Failed:", result.error)
+    break
+}
+```
+
+For ClineCore, check `finishReason`:
+
+```typescript
+const session = await cline.start({ ... })
+
+switch (session.result?.finishReason) {
+  case "completed":
+    // normal completion
+    break
+  case "max_iterations":
+    // agent hit iteration limit
+    break
+  case "aborted":
+    // manually cancelled
+    break
+  case "mistake_limit":
+    // too many tool errors
+    break
+  case "error":
+    // unrecoverable error
+    break
+}
+```
+
+## Cost Control
+
+### Token Limits
+
+Set maximum tokens per turn and iteration limits:
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  maxTokensPerTurn: 4096,
+  maxIterations: 10,
+  tools: [...],
+})
+```
+
+### Model Selection
+
+Use cheaper models for simple tasks:
+
+```typescript
+// Simple classification or formatting
+{ providerId: "anthropic", modelId: "claude-haiku-4-5" }
+
+// Complex reasoning and code generation
+{ providerId: "anthropic", modelId: "claude-sonnet-4-6" }
+
+// Hardest tasks requiring deep reasoning
+{ providerId: "anthropic", modelId: "claude-opus-4-7" }
+```
+
+### Usage Tracking
+
+Monitor spending in real time:
+
+```typescript
+agent.subscribe((event) => {
+  if (event.type === "usage-updated" && event.usage.totalCost) {
+    if (event.usage.totalCost > MAX_BUDGET) {
+      agent.abort("Budget exceeded")
+    }
+  }
+})
+```
+
+## Observability
+
+### OpenTelemetry Integration
+
+The SDK supports OpenTelemetry for traces, metrics, and logs:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  // OpenTelemetry config is picked up from environment
+  // OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_SERVICE_NAME, etc.
+})
+```
+
+### Structured Logging
+
+Use the `BasicLogger` interface for injectable logging:
+
+```typescript
+import type { BasicLogger } from "@cline/sdk"
+
+const logger: BasicLogger = {
+  debug: (msg, meta) => console.debug(msg, meta),
+  log: (msg, meta) => console.log(msg, meta),
+  error: (msg, meta) => console.error(msg, meta),
+}
+
+await cline.start({
+  config: {
+    logger,
+    // ...
+  },
+})
+```
+
+### Custom Metrics via Plugins
+
+```typescript
+const metricsPlugin: AgentPlugin = {
+  name: "metrics",
+  manifest: { capabilities: ["hooks"] },
+  setup() {},
+  hooks: {
+    beforeRun() {
+      metrics.increment("agent.runs.started")
+    },
+    afterRun({ result }) {
+      metrics.increment("agent.runs.completed")
+      metrics.histogram("agent.iterations", result.iterations)
+      metrics.histogram("agent.tokens.output", result.usage.outputTokens)
+    },
+    beforeTool({ toolCall }) {
+      metrics.increment(`agent.tools.${toolCall.toolName}`)
+    },
+  },
+}
+```
+
+## Security
+
+### Sandbox Tool Execution
+
+Validate tool inputs to prevent path traversal and injection:
+
+```typescript
+execute: async (input) => {
+  const safePath = path.resolve(WORKSPACE_ROOT, input.path)
+  if (!safePath.startsWith(WORKSPACE_ROOT)) {
+    return { error: "Path traversal attempt blocked" }
+  }
+  return await readFile(safePath, "utf-8")
+}
+```
+
+### API Key Management
+
+- Use environment variables, never hardcode keys
+- Rotate keys regularly
+- Use different keys for development and production
+
+```typescript
+{
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY, // never a literal string
+}
+```
+
+### Tool Policy Hardening
+
+Disable tools you don't need and require approval for dangerous ones:
+
+```typescript
+toolPolicies: {
+  read_files: { autoApprove: true },
+  search: { autoApprove: true },
+  bash: { autoApprove: false },     // require approval
+  editor: { autoApprove: false },
+  apply_patch: { autoApprove: false },
+  fetch_web: { enabled: false },    // disable entirely
+}
+```
+
+## Deployment Patterns
+
+### Stateless Worker
+
+For request/response workloads (API endpoints, queue consumers):
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "worker",
+  backendMode: "local",
+})
+
+app.post("/agent", async (req, res) => {
+  const session = await cline.start({
+    prompt: req.body.prompt,
+    config: { ... },
+  })
+  res.json({ text: session.result?.text, usage: session.result?.usage })
+})
+```
+
+### Persistent Service
+
+For long-running services with session management:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "service",
+  backendMode: "hub",
+})
+
+process.on("SIGTERM", async () => {
+  await cline.dispose("SIGTERM")
+  process.exit(0)
+})
+```
+
+### Scheduled Automation
+
+See `../scheduling/REFERENCE.md` for recurring agent tasks.
+
+## Retry and Resilience
+
+- Tool `execute` functions support `retryable: true` (default) and `maxRetries: 3` (default)
+- Provider API calls are retried automatically on transient failures
+- Use `timeoutMs` on tools to prevent hanging
+- Monitor `mistake_limit` finish reason to detect systematic tool failures
+
+## See Also
+
+- `../agent/REFERENCE.md` - Agent overview
+- `../clinecore/REFERENCE.md` - ClineCore overview
+- `../tools/REFERENCE.md` - Tool configuration
+- `../plugins/REFERENCE.md` - Metrics plugins
+- `../scheduling/REFERENCE.md` - Scheduled agents
diff --git a/.agents/skills/cline-sdk/references/providers/REFERENCE.md b/.agents/skills/cline-sdk/references/providers/REFERENCE.md
new file mode 100644
index 0000000..1ad2dc7
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/providers/REFERENCE.md
@@ -0,0 +1,257 @@
+# Model Providers
+
+The Cline SDK supports every major LLM provider out of the box via `@cline/llms`.
+
+## Supported Providers
+
+| Provider ID | Models |
+|-------------|--------|
+| `"anthropic"` | Claude Opus 4.7, Sonnet 4.6, Haiku 4.5 |
+| `"openai"` | GPT-5.5, GPT-5.3 Codex |
+| `"gemini"` | Gemini 3.1 Pro Preview, Gemini 3 Flash Preview |
+| `"vertex"` | Google models via Vertex AI |
+| `"bedrock"` | Claude, Llama via AWS Bedrock |
+| `"mistral"` | Mistral Large, Codestral |
+| `"openai-compatible"` | vLLM, Together, Fireworks, Groq, etc. |
+
+## Basic Configuration
+
+### With Agent
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  systemPrompt: "You are a helpful assistant.",
+  tools: [],
+})
+```
+
+### With ClineCore
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+await cline.start({
+  prompt: "Hello",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+  },
+})
+```
+
+## Provider-Specific Configuration
+
+### Anthropic
+
+```typescript
+{
+  providerId: "anthropic",
+  modelId: "claude-opus-4-7",  // or "claude-sonnet-4-6", "claude-haiku-4-5"
+  apiKey: process.env.ANTHROPIC_API_KEY,
+}
+```
+
+### OpenAI
+
+```typescript
+{
+  providerId: "openai",
+  modelId: "gpt-5.5",
+  apiKey: process.env.OPENAI_API_KEY,
+}
+```
+
+### Google (Gemini)
+
+```typescript
+{
+  providerId: "gemini",
+  modelId: "gemini-3.1-pro-preview",
+  apiKey: process.env.GOOGLE_API_KEY,
+}
+```
+
+### Google (Vertex AI)
+
+```typescript
+{
+  providerId: "vertex",
+  modelId: "gemini-3.1-pro-preview",
+  // Uses application default credentials or service account
+}
+```
+
+### AWS Bedrock
+
+```typescript
+{
+  providerId: "bedrock",
+  modelId: "anthropic.claude-sonnet-4-6",
+  // Uses AWS credential chain (env vars, config file, IAM role)
+  // Set AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
+}
+```
+
+### Mistral
+
+```typescript
+{
+  providerId: "mistral",
+  modelId: "mistral-large-latest",
+  apiKey: process.env.MISTRAL_API_KEY,
+}
+```
+
+### OpenAI-Compatible
+
+For any provider with an OpenAI-compatible API:
+
+```typescript
+{
+  providerId: "openai-compatible",
+  modelId: "my-model",
+  apiKey: process.env.API_KEY,
+  baseUrl: "https://api.together.xyz/v1",
+}
+```
+
+Works with: vLLM, Together AI, Fireworks, Groq, Ollama, LiteLLM, etc.
+
+## Custom Base URL
+
+Override the API endpoint for any provider:
+
+```typescript
+{
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.API_KEY,
+  baseUrl: "https://my-proxy.example.com/v1",
+}
+```
+
+## Custom Headers
+
+Pass additional headers to API requests:
+
+```typescript
+{
+  providerId: "openai",
+  modelId: "gpt-5.5",
+  apiKey: process.env.API_KEY,
+  headers: {
+    "X-Custom-Header": "value",
+  },
+}
+```
+
+## Gateway API
+
+For advanced multi-provider setups, use the Gateway directly:
+
+```typescript
+import { createGateway, DefaultGateway } from "@cline/llms"
+
+const gateway = createGateway({
+  providerConfigs: [
+    { providerId: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY },
+    { providerId: "openai", apiKey: process.env.OPENAI_API_KEY },
+  ],
+})
+
+// Create a model for a specific provider
+const model = gateway.createAgentModel({
+  providerId: "anthropic",
+  modelId: "claude-opus-4-7",
+})
+
+// Use with Agent
+const agent = new Agent({ model, systemPrompt: "...", tools: [] })
+```
+
+### Gateway Methods
+
+```typescript
+gateway.registerProvider(registration)   // add a custom provider
+gateway.configureProvider(config)        // update provider settings
+gateway.listProviders()                  // list available providers
+gateway.listModels(providerId?)          // list available models
+gateway.createAgentModel(selection)      // create model for agent
+gateway.stream(request)                  // raw streaming (AsyncIterable)
+```
+
+## Provider Registry
+
+Query and register providers programmatically:
+
+```typescript
+import {
+  getAllProviders,
+  getProviderIds,
+  getProvider,
+  getModelsForProvider,
+  registerProvider,
+  registerModel,
+  createHandler,
+} from "@cline/llms"
+
+// List all registered providers
+const providers = getAllProviders()
+
+// Get models for a provider
+const models = getModelsForProvider("anthropic")
+
+// Register a custom provider
+registerProvider({
+  id: "my-provider",
+  name: "My Custom Provider",
+  handler: createHandler({ ... }),
+})
+```
+
+## Model Metadata
+
+Access model info (context window, pricing, capabilities):
+
+```typescript
+import { getModelsForProvider } from "@cline/llms"
+
+const models = getModelsForProvider("anthropic")
+for (const model of models) {
+  console.log(`${model.id}: context=${model.contextWindow}, input=$${model.inputPrice}/MTok`)
+}
+```
+
+## Cost Tracking
+
+Track per-request and cumulative costs:
+
+```typescript
+// Via events
+agent.subscribe((event) => {
+  if (event.type === "usage-updated") {
+    console.log(`Cost: $${event.usage.totalCost?.toFixed(4)}`)
+  }
+})
+
+// Via result
+const result = await agent.run("...")
+console.log(`Total cost: $${result.usage.totalCost?.toFixed(4)}`)
+
+// Via ClineCore accumulated usage
+const usage = await cline.getAccumulatedUsage(sessionId)
+```
+
+## See Also
+
+- `../agent/REFERENCE.md` - Using providers with Agent
+- `../clinecore/REFERENCE.md` - Using providers with ClineCore
+- `../production/REFERENCE.md` - Cost control in production
diff --git a/.agents/skills/cline-sdk/references/scheduling/REFERENCE.md b/.agents/skills/cline-sdk/references/scheduling/REFERENCE.md
new file mode 100644
index 0000000..295e884
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/scheduling/REFERENCE.md
@@ -0,0 +1,227 @@
+# Scheduling and Automation
+
+The Cline SDK supports scheduled, one-off, and event-driven agent execution through the automation subsystem in `@cline/core`.
+
+## Overview
+
+Three trigger types:
+
+| Trigger | Description |
+|---------|-------------|
+| `schedule` | Recurring jobs via cron expressions |
+| `one_off` | Single execution tasks |
+| `event` | Triggered by external events (GitHub, Linear, custom) |
+
+## CLI Schedule Management
+
+```bash
+# Create a recurring schedule
+cline schedule create "Daily standup" \
+  --cron "0 9 * * MON-FRI" \
+  --prompt "Summarize open PRs and blockers" \
+  --workspace /path/to/project \
+  --model anthropic/claude-sonnet-4-6
+
+# List schedules
+cline schedule list
+
+# Trigger a schedule immediately
+cline schedule trigger <schedule-id>
+
+# Pause/resume
+cline schedule pause <schedule-id>
+cline schedule resume <schedule-id>
+
+# Delete
+cline schedule delete <schedule-id>
+
+# View past executions
+cline schedule executions <schedule-id>
+```
+
+## Cron Expressions
+
+| Expression | Meaning |
+|-----------|---------|
+| `0 9 * * MON-FRI` | 9 AM weekdays |
+| `0 */6 * * *` | Every 6 hours |
+| `0 8 * * MON` | Mondays at 8 AM |
+| `*/30 * * * *` | Every 30 minutes |
+| `0 0 1 * *` | First of every month |
+
+## File-Based Specs
+
+Create Markdown files in `~/.cline/cron/` (global) or `.cline/cron/` (workspace):
+
+### Recurring Schedule
+
+```markdown
+---
+trigger: schedule
+schedule: "0 9 * * MON-FRI"
+timezone: America/New_York
+mode: exclusive
+prompt: "Check for dependency updates and create PRs for any outdated packages."
+modelSelection:
+  providerId: anthropic
+  modelId: claude-sonnet-4-6
+tools:
+  enabled: true
+---
+
+Additional context or instructions for the agent go in the body.
+```
+
+### One-Off Task
+
+```markdown
+---
+trigger: one_off
+prompt: "Generate a comprehensive test coverage report."
+modelSelection:
+  providerId: anthropic
+  modelId: claude-sonnet-4-6
+---
+```
+
+### Event-Driven
+
+```markdown
+---
+trigger: event
+eventType: github.pull_request.opened
+filters:
+  repository: myorg/myrepo
+debounceMs: 5000
+cooldownMs: 60000
+prompt: "Review the PR for security issues and code quality."
+modelSelection:
+  providerId: anthropic
+  modelId: claude-sonnet-4-6
+---
+```
+
+## CronSpec Types
+
+```typescript
+interface CronScheduleSpec {
+  trigger: "schedule"
+  schedule: string              // cron expression
+  timezone?: string
+  mode?: "exclusive" | "concurrent"
+  prompt: string
+  modelSelection?: { providerId: string; modelId?: string }
+  extensionLoading?: "isolated" | "direct"
+  configExtensions?: RuntimeConfigExtensionKind[]
+  tools?: { enabled?: boolean; names?: string[] }
+}
+
+interface CronOneOffSpec {
+  trigger: "one_off"
+  prompt: string
+  modelSelection?: { providerId: string; modelId?: string }
+}
+
+interface CronEventSpec {
+  trigger: "event"
+  eventType: string             // e.g., "github.pull_request.opened"
+  filters?: Record<string, unknown>
+  debounceMs?: number
+  cooldownMs?: number
+  prompt: string
+  modelSelection?: { providerId: string; modelId?: string }
+}
+```
+
+## Programmatic Automation API
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  automation: true,
+})
+
+// Start automation service
+cline.automation.start()
+
+// Ingest an external event
+cline.automation.ingestEvent({
+  eventId: "evt-123",
+  eventType: "github.pull_request.opened",
+  source: "github",
+  timestamp: Date.now(),
+  payload: { pr: { number: 42, title: "..." } },
+})
+
+// List specs, runs, events
+const specs = await cline.automation.listSpecs()
+const runs = await cline.automation.listRuns()
+const events = await cline.automation.listEvents()
+
+// Reconcile specs from directory
+await cline.automation.reconcile(specDirectory)
+
+// Stop automation
+cline.automation.stop()
+```
+
+## Event Ingestion from Plugins
+
+Plugins can declare and emit automation events:
+
+```typescript
+const webhookPlugin: AgentPlugin = {
+  name: "webhook-events",
+  manifest: { capabilities: ["automationEvents"] },
+  setup(api) {
+    api.registerAutomationEventType({
+      type: "webhook.received",
+      description: "External webhook received",
+    })
+  },
+}
+```
+
+Submit events via the plugin context:
+
+```typescript
+ctx.automation.ingestEvent({
+  eventId: "evt-456",
+  eventType: "webhook.received",
+  source: "custom",
+  timestamp: Date.now(),
+  payload: { ... },
+})
+```
+
+## Concurrency Control
+
+| Mode | Behavior |
+|------|----------|
+| `"exclusive"` | Skip if previous run still active |
+| `"concurrent"` | Allow overlapping runs |
+
+## Run Reports
+
+Each completed run writes a Markdown report to `.cline/cron/reports/<run-id>.md` with:
+- Run metadata (spec, trigger, timing)
+- Summary of agent output
+- Usage (tokens, cost)
+- Tool calls made
+- Trigger event context (for event-driven runs)
+
+## Use Cases
+
+- Daily standup summaries
+- Automated dependency update checks
+- PR review on open
+- Codebase health reports
+- Scheduled security scans
+- Event-driven CI/CD workflows
+
+## See Also
+
+- `../clinecore/REFERENCE.md` - ClineCore runtime
+- `../clinecore/api.md` - Automation API details
+- `../plugins/REFERENCE.md` - Plugin events
+- `../production/REFERENCE.md` - Production deployment
diff --git a/.agents/skills/cline-sdk/references/tools/REFERENCE.md b/.agents/skills/cline-sdk/references/tools/REFERENCE.md
new file mode 100644
index 0000000..3e3ac56
--- /dev/null
+++ b/.agents/skills/cline-sdk/references/tools/REFERENCE.md
@@ -0,0 +1,259 @@
+# Tools
+
+Tools are how agents interact with the world. The Cline SDK supports both built-in tools (via ClineCore) and custom tools you define yourself.
+
+## Creating Custom Tools
+
+Use `createTool()` from `@cline/sdk` (or `@cline/shared`):
+
+```typescript
+import { createTool } from "@cline/sdk"
+
+const myTool = createTool({
+  name: "search_issues",
+  description: "Search GitHub issues by query. Returns up to 10 results.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Search query" },
+      state: { type: "string", enum: ["open", "closed", "all"] },
+    },
+    required: ["query"],
+  },
+  execute: async (input) => {
+    const issues = await github.searchIssues(input.query, input.state)
+    return { issues, count: issues.length }
+  },
+})
+```
+
+### With Zod Schema
+
+```typescript
+import { createTool } from "@cline/sdk"
+import { z } from "zod"
+
+const deployTool = createTool({
+  name: "deploy",
+  description: "Deploy the app to the specified environment.",
+  inputSchema: z.object({
+    environment: z.enum(["staging", "production"]).describe("Target environment"),
+    version: z.string().optional().describe("Version tag, defaults to latest"),
+  }),
+  execute: async (input) => {
+    const result = await deploy(input.environment, input.version)
+    return { url: result.url, status: "deployed" }
+  },
+})
+```
+
+### Tool Config Options
+
+```typescript
+createTool({
+  name: string,                         // snake_case, unique per agent
+  description: string,                  // what the tool does (model reads this)
+  inputSchema: JSONSchema | ZodSchema,  // input validation
+  execute: async (input, context, onChange?) => output,
+  timeoutMs?: number,                   // default: 30000
+  retryable?: boolean,                  // default: true
+  maxRetries?: number,                  // default: 3
+  lifecycle?: {
+    completesRun?: boolean              // true = ends agent loop on success
+  },
+})
+```
+
+### AgentToolContext
+
+The second argument to `execute` provides runtime context:
+
+```typescript
+interface AgentToolContext {
+  agentId: string
+  conversationId: string
+  iteration: number
+  abortSignal?: AbortSignal
+  metadata?: Record<string, unknown>
+}
+```
+
+## Tool Naming Rules
+
+- Names must be `snake_case` (e.g., `search_issues`, `deploy_app`)
+- Names must be unique within a single agent's tool set
+- Choose descriptive names since the model uses them to decide which tool to call
+
+## Tool Descriptions Matter
+
+The model reads the tool description to decide when and how to use it. Write clear, specific descriptions:
+
+```typescript
+// Bad: vague
+description: "Does deployment stuff"
+
+// Good: specific with constraints
+description: "Deploy the application to staging or production. " +
+  "Staging deployments are immediate. Production requires a passing CI build. " +
+  "Returns the deployment URL and status."
+```
+
+Include constraints, rate limits, and expected behavior in the description.
+
+## Error Handling in Tools
+
+Return errors as structured data instead of throwing:
+
+```typescript
+// Good: return error data
+execute: async (input) => {
+  const file = await readFile(input.path).catch(() => null)
+  if (!file) {
+    return { error: "File not found", path: input.path }
+  }
+  return { content: file }
+}
+```
+
+Thrown exceptions count as "mistakes" against the agent's mistake limit. Returned error data lets the agent adjust its approach.
+
+## Completion Tools
+
+Tools with `lifecycle: { completesRun: true }` end the agent loop when they execute successfully:
+
+```typescript
+const submitAnswer = createTool({
+  name: "submit_answer",
+  description: "Submit the final answer and end the task.",
+  inputSchema: z.object({
+    answer: z.string(),
+    confidence: z.number().min(0).max(1),
+  }),
+  lifecycle: { completesRun: true },
+  execute: async (input) => input,
+})
+```
+
+The model sees the tool result and the run ends. Access the output via `result.toolCalls`.
+
+## Built-in Tools (ClineCore Only)
+
+When using `ClineCore` with `enableTools: true`, these tools are available automatically:
+
+| Tool | Name | What It Does |
+|------|------|-------------|
+| Shell | `bash` | Execute shell commands in the session workspace |
+| Editor | `editor` | Create and edit files |
+| Read | `read_files` | Read file contents |
+| Patch | `apply_patch` | Apply unified diffs to files |
+| Search | `search` | Search file contents and directory structure |
+| Web | `fetch_web` | Fetch web content via HTTP |
+
+Built-in tools respect the `cwd` setting in `CoreSessionConfig`.
+
+## Tool Policies
+
+Control which tools are available and whether they require approval:
+
+```typescript
+// In Agent config
+const agent = new Agent({
+  tools: [toolA, toolB, toolC],
+  toolPolicies: {
+    tool_a: { autoApprove: true },    // runs without asking
+    tool_b: { autoApprove: false },   // requires approval
+    tool_c: { enabled: false },       // hidden from model
+  },
+})
+
+// In ClineCore session
+await cline.start({
+  prompt: "...",
+  config: { ... },
+  toolPolicies: {
+    bash: { autoApprove: true },
+    editor: { autoApprove: false },
+  },
+})
+```
+
+### Policy Options
+
+| Policy | Effect |
+|--------|--------|
+| `{ autoApprove: true }` | Tool runs without approval |
+| `{ autoApprove: false }` | Triggers approval callback before running |
+| `{ enabled: false }` | Tool is hidden from the model entirely |
+| No policy set | Defaults to enabled and auto-approved |
+
+## Abort Signal in Long-Running Tools
+
+Respect the abort signal for tools that take a long time:
+
+```typescript
+execute: async (input, context) => {
+  const results = []
+  for (const item of input.items) {
+    if (context.abortSignal?.aborted) {
+      return { results, aborted: true, processed: results.length }
+    }
+    results.push(await processItem(item))
+  }
+  return { results, processed: results.length }
+}
+```
+
+## Streaming Tool Output
+
+Use the `onChange` callback (third argument) to stream partial results:
+
+```typescript
+execute: async (input, context, onChange) => {
+  let progress = 0
+  for (const step of steps) {
+    progress++
+    onChange?.(`Processing step ${progress}/${steps.length}...`)
+    await processStep(step)
+  }
+  return { completed: true }
+}
+```
+
+## Testing Tools
+
+Tools are plain async functions, so they're straightforward to test:
+
+```typescript
+import { describe, it, expect } from "vitest"
+
+describe("deploy tool", () => {
+  it("deploys to staging", async () => {
+    const context = { agentId: "test", conversationId: "test", iteration: 1 }
+    const result = await deployTool.execute({ environment: "staging" }, context)
+    expect(result.status).toBe("deployed")
+  })
+})
+```
+
+## MCP Tool Integration
+
+ClineCore can connect to MCP (Model Context Protocol) servers for additional tools. Configure in `.cline/mcp-servers.json`:
+
+```json
+{
+  "servers": {
+    "my-server": {
+      "command": "node",
+      "args": ["./mcp-server.js"]
+    }
+  }
+}
+```
+
+MCP tools appear alongside built-in and custom tools automatically.
+
+## See Also
+
+- `../agent/REFERENCE.md` - Using tools with Agent
+- `../clinecore/REFERENCE.md` - Using tools with ClineCore
+- `../plugins/REFERENCE.md` - Packaging tools as plugins
diff --git a/.agents/skills/create-pull-request/SKILL.md b/.agents/skills/create-pull-request/SKILL.md
new file mode 100644
index 0000000..9aa5add
--- /dev/null
+++ b/.agents/skills/create-pull-request/SKILL.md
@@ -0,0 +1,211 @@
+---
+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, PR template usage, and PR creation using the gh CLI tool.
+---
+
+# Create Pull Request
+
+This skill guides you through creating a well-structured GitHub pull request that follows project conventions and best practices.
+
+## Prerequisites Check
+
+Before proceeding, verify the following:
+
+### 1. Check if `gh` CLI is installed
+
+```bash
+gh --version
+```
+
+If not installed, inform the user:
+> The GitHub CLI (`gh`) is required but not installed. Please install it:
+> - macOS: `brew install gh`
+> - Other: https://cli.github.com/
+
+### 2. Check if authenticated with GitHub
+
+```bash
+gh auth status
+```
+
+If not authenticated, guide the user to run `gh auth login`.
+
+### 3. Verify clean working directory
+
+```bash
+git status
+```
+
+If there are uncommitted changes, ask the user whether to:
+- Commit them as part of this PR
+- Stash them temporarily
+- Discard them (with caution)
+
+## Gather Context
+
+### 1. Identify the current branch
+
+```bash
+git branch --show-current
+```
+
+Ensure you're not on `main` or `master`. If so, ask the user to create or switch to a feature branch.
+
+### 2. Find the base branch
+
+```bash
+git remote show origin | grep "HEAD branch"
+```
+
+This is typically `main` or `master`.
+
+### 3. Analyze recent commits relevant to this PR
+
+```bash
+git log origin/main..HEAD --oneline --no-decorate
+```
+
+Review these commits to understand:
+- What changes are being introduced
+- The scope of the PR (single feature/fix or multiple changes)
+- Whether commits should be squashed or reorganized
+
+### 4. Review the diff
+
+```bash
+git diff origin/main..HEAD --stat
+```
+
+This shows which files changed and helps identify the type of change.
+
+## Information Gathering
+
+Before creating the PR, you need the following information. Check if it can be inferred from:
+- Commit messages
+- Branch name (e.g., `fix/issue-123`, `feature/new-login`)
+- Changed files and their content
+
+If any critical information is missing, use `ask_followup_question` to ask the user:
+
+### Required Information
+
+1. **Related Issue Number**: Look for patterns like `#123`, `fixes #123`, or `closes #123` in commit messages
+2. **Description**: What problem does this solve? Why were these changes made?
+3. **Type of Change**: Bug fix, new feature, breaking change, refactor, cosmetic, documentation, or workflow
+4. **Test Procedure**: How was this tested? What could break?
+
+### Example clarifying question
+
+If the issue number is not found:
+> I couldn't find a related issue number in the commit messages or branch name. What GitHub issue does this PR address? (Enter the issue number, e.g., "123" or "N/A" for small fixes)
+
+## Git Best Practices
+
+Before creating the PR, consider these best practices:
+
+### Commit Hygiene
+
+1. **Atomic commits**: Each commit should represent a single logical change
+2. **Clear commit messages**: Follow conventional commit format when possible
+3. **No merge commits**: Prefer rebasing over merging to keep history clean
+
+### Branch Management
+
+1. **Rebase on latest main** (if needed):
+   ```bash
+   git fetch origin
+   git rebase origin/main
+   ```
+
+2. **Squash if appropriate**: If there are many small "WIP" commits, consider interactive rebase:
+   ```bash
+   git rebase -i origin/main
+   ```
+   Only suggest this if commits appear messy and the user is comfortable with rebasing.
+
+### Push Changes
+
+Ensure all commits are pushed:
+```bash
+git push origin HEAD
+```
+
+If the branch was rebased, you may need:
+```bash
+git push origin HEAD --force-with-lease
+```
+
+## Create the Pull Request
+
+**IMPORTANT**: Read and use the PR template at `.github/pull_request_template.md`. The PR body format must **strictly match** the template structure. Do not deviate from the template format.
+
+When filling out the template:
+- Replace `#XXXX` with the actual issue number, or keep as `#XXXX` if no issue exists (for small fixes)
+- Fill in all sections with relevant information gathered from commits and context
+- Mark the appropriate "Type of Change" checkbox(es)
+- Complete the "Pre-flight Checklist" items that apply
+
+### Create PR with gh CLI
+
+**Use a temporary file for the PR body** to avoid shell escaping issues, newline problems, and other command-line flakiness:
+
+1. Write the PR body to a temporary file:
+   ```
+   /tmp/pr-body.md
+   ```
+
+2. Create the PR using the file:
+   ```bash
+   gh pr create --title "PR_TITLE" --body-file /tmp/pr-body.md --base main
+   ```
+
+3. Clean up the temporary file:
+   ```bash
+   rm /tmp/pr-body.md
+   ```
+
+For draft PRs:
+```bash
+gh pr create --title "PR_TITLE" --body-file /tmp/pr-body.md --base main --draft
+```
+
+**Why use a file?** Passing complex markdown with newlines, special characters, and checkboxes directly via `--body` is error-prone. The `--body-file` flag handles all content reliably.
+
+## Post-Creation
+
+After creating the PR:
+
+1. **Display the PR URL** so the user can review it
+2. **Remind about CI checks**: Tests and linting will run automatically
+3. **Suggest next steps**:
+   - Add reviewers if needed: `gh pr edit --add-reviewer USERNAME`
+   - Add labels if needed: `gh pr edit --add-label "bug"`
+
+## Error Handling
+
+### Common Issues
+
+1. **No commits ahead of main**: The branch has no changes to submit
+   - Ask if the user meant to work on a different branch
+
+2. **Branch not pushed**: Remote doesn't have the branch
+   - Push the branch first: `git push -u origin HEAD`
+
+3. **PR already exists**: A PR for this branch already exists
+   - Show the existing PR: `gh pr view`
+   - Ask if they want to update it instead
+
+4. **Merge conflicts**: Branch conflicts with base
+   - Guide user through resolving conflicts or rebasing
+
+## Summary Checklist
+
+Before finalizing, ensure:
+- [ ] `gh` CLI is installed and authenticated
+- [ ] Working directory is clean
+- [ ] All commits are pushed
+- [ ] Branch is up-to-date with base branch
+- [ ] Related issue number is identified, or placeholder is used
+- [ ] PR description follows the template exactly
+- [ ] Appropriate type of change is selected
+- [ ] Pre-flight checklist items are addressed
\ No newline at end of file
diff --git a/.agents/skills/opentui/SKILL.md b/.agents/skills/opentui/SKILL.md
new file mode 100644
index 0000000..ada49f5
--- /dev/null
+++ b/.agents/skills/opentui/SKILL.md
@@ -0,0 +1,200 @@
+---
+name: opentui
+description: Comprehensive OpenTUI skill for building terminal user interfaces. Covers the core imperative API, React reconciler, and Solid reconciler. Use for any TUI development task including components, layout, keyboard handling, animations, and testing.
+metadata:
+   references: core, react, solid
+---
+
+# OpenTUI Platform Skill
+
+Consolidated skill for building terminal user interfaces with OpenTUI. Use decision trees below to find the right framework and components, then load detailed references.
+
+## Critical Rules
+
+**Follow these rules in all OpenTUI code:**
+
+1. **Use `create-tui` for new projects.** See framework `REFERENCE.md` quick starts.
+2. **`create-tui` options must come before arguments.** `bunx create-tui -t react my-app` works, `bunx create-tui my-app -t react` does NOT.
+3. **Never call `process.exit()` directly.** Use `renderer.destroy()` (see `core/gotchas.md`).
+4. **Text styling requires nested tags in React/Solid.** Use modifier elements, not props (see `components/text-display.md`).
+
+## How to Use This Skill
+
+### Reference File Structure
+
+Framework references follow a 5-file pattern. Cross-cutting concepts are single-file guides.
+
+Each framework in `./references/<framework>/` contains:
+
+| File | Purpose | When to Read |
+|------|---------|--------------|
+| `REFERENCE.md` | Overview, when to use, quick start | **Always read first** |
+| `api.md` | Runtime API, components, hooks | Writing code |
+| `configuration.md` | Setup, tsconfig, bundling | Configuring a project |
+| `patterns.md` | Common patterns, best practices | Implementation guidance |
+| `gotchas.md` | Pitfalls, limitations, debugging | Troubleshooting |
+
+Cross-cutting concepts in `./references/<concept>/` have `REFERENCE.md` as the entry point.
+
+### Reading Order
+
+1. Start with `REFERENCE.md` for your chosen framework
+2. Then read additional files relevant to your task:
+   - Building components -> `api.md` + `components/<category>.md`
+   - Setting up project -> `configuration.md`
+   - Layout/positioning -> `layout/REFERENCE.md`
+   - Keyboard/input handling -> `keyboard/REFERENCE.md`
+   - Animations -> `animation/REFERENCE.md`
+   - Troubleshooting -> `gotchas.md` + `testing/REFERENCE.md`
+
+### Example Paths
+
+```
+./references/react/REFERENCE.md           # Start here for React
+./references/react/api.md              # React components and hooks
+./references/solid/configuration.md    # Solid project setup
+./references/components/inputs.md      # Input, Textarea, Select docs
+./references/core/gotchas.md           # Core debugging tips
+```
+
+### Runtime Notes
+
+OpenTUI runs on Bun and uses Zig for native builds. Read `./references/core/gotchas.md` for runtime requirements and build guidance.
+
+## Quick Decision Trees
+
+### "Which framework should I use?"
+
+```
+Which framework?
+├─ I want full control, maximum performance, no framework overhead
+│  └─ core/ (imperative API)
+├─ I know React, want familiar component patterns
+│  └─ react/ (React reconciler)
+├─ I want fine-grained reactivity, optimal re-renders
+│  └─ solid/ (Solid reconciler)
+└─ I'm building a library/framework on top of OpenTUI
+   └─ core/ (imperative API)
+```
+
+### "I need to display content"
+
+```
+Display content?
+├─ Plain or styled text -> components/text-display.md
+├─ Container with borders/background -> components/containers.md
+├─ Scrollable content area -> components/containers.md (scrollbox)
+├─ ASCII art banner/title -> components/text-display.md (ascii-font)
+├─ Data table with borders/wrapping -> components/code-diff.md (TextTable)
+├─ Code with syntax highlighting -> components/code-diff.md
+├─ Diff viewer (unified/split) -> components/code-diff.md
+├─ Line numbers with diagnostics -> components/code-diff.md
+└─ Markdown content (streaming) -> components/code-diff.md (markdown)
+```
+
+### "I need user input"
+
+```
+User input?
+├─ Single-line text field -> components/inputs.md (input)
+├─ Multi-line text editor -> components/inputs.md (textarea)
+├─ Select from a list (vertical) -> components/inputs.md (select)
+├─ Tab-based selection (horizontal) -> components/inputs.md (tab-select)
+└─ Custom keyboard shortcuts -> keyboard/REFERENCE.md
+```
+
+### "I need layout/positioning"
+
+```
+Layout?
+├─ Flexbox-style layouts (row, column, wrap) -> layout/REFERENCE.md
+├─ Absolute positioning -> layout/patterns.md
+├─ Responsive to terminal size -> layout/patterns.md
+├─ Centering content -> layout/patterns.md
+└─ Complex nested layouts -> layout/patterns.md
+```
+
+### "I need animations"
+
+```
+Animations?
+├─ Timeline-based animations -> animation/REFERENCE.md
+├─ Easing functions -> animation/REFERENCE.md
+├─ Property transitions -> animation/REFERENCE.md
+└─ Looping animations -> animation/REFERENCE.md
+```
+
+### "I need to handle input"
+
+```
+Input handling?
+├─ Keyboard events (keypress, release) -> keyboard/REFERENCE.md
+├─ Focus management -> keyboard/REFERENCE.md
+├─ Paste events -> keyboard/REFERENCE.md
+├─ Mouse events -> components/containers.md
+├─ Text selection & copy-on-select -> keyboard/REFERENCE.md (selection)
+└─ Clipboard (OSC 52) -> keyboard/REFERENCE.md (clipboard)
+```
+
+### "I need to test my TUI"
+
+```
+Testing?
+├─ Snapshot testing -> testing/REFERENCE.md
+├─ Interaction testing -> testing/REFERENCE.md
+├─ Test renderer setup -> testing/REFERENCE.md
+└─ Debugging tests -> testing/REFERENCE.md
+```
+
+### "I need to debug/troubleshoot"
+
+```
+Troubleshooting?
+├─ Runtime errors, crashes -> <framework>/gotchas.md
+├─ Layout issues -> layout/REFERENCE.md + layout/patterns.md
+├─ Input/focus issues -> keyboard/REFERENCE.md
+└─ Repro + regression tests -> testing/REFERENCE.md
+```
+
+### Troubleshooting Index
+
+- Terminal cleanup, crashes -> `core/gotchas.md`
+- Text styling not applying -> `components/text-display.md`
+- Input focus/shortcuts -> `keyboard/REFERENCE.md`
+- Layout misalignment -> `layout/REFERENCE.md`
+- Flaky snapshots -> `testing/REFERENCE.md`
+
+For component naming differences and text modifiers, see `components/REFERENCE.md`.
+
+## Product Index
+
+### Frameworks
+| Framework | Entry File | Description |
+|-----------|------------|-------------|
+| Core | `./references/core/REFERENCE.md` | Imperative API, all primitives |
+| React | `./references/react/REFERENCE.md` | React reconciler for declarative TUI |
+| Solid | `./references/solid/REFERENCE.md` | SolidJS reconciler for declarative TUI |
+
+### Cross-Cutting Concepts
+| Concept | Entry File | Description |
+|---------|------------|-------------|
+| Layout | `./references/layout/REFERENCE.md` | Yoga/Flexbox layout system |
+| Components | `./references/components/REFERENCE.md` | Component reference by category |
+| Keyboard | `./references/keyboard/REFERENCE.md` | Keyboard input handling |
+| Animation | `./references/animation/REFERENCE.md` | Timeline-based animations |
+| Testing | `./references/testing/REFERENCE.md` | Test renderer and snapshots |
+
+### Component Categories
+| Category | Entry File | Components |
+|----------|------------|------------|
+| Text & Display | `./references/components/text-display.md` | text, ascii-font, styled text |
+| Containers | `./references/components/containers.md` | box, scrollbox, borders |
+| Inputs | `./references/components/inputs.md` | input, textarea, select, tab-select |
+| Code & Diff | `./references/components/code-diff.md` | code, line-number, diff, markdown, text-table |
+
+## Resources
+
+**Repository**: https://github.com/anomalyco/opentui
+**Core Docs**: https://github.com/anomalyco/opentui/tree/main/packages/core/docs
+**Examples**: https://github.com/anomalyco/opentui/tree/main/packages/core/src/examples
+**Awesome List**: https://github.com/msmps/awesome-opentui
diff --git a/.agents/skills/opentui/references/animation/REFERENCE.md b/.agents/skills/opentui/references/animation/REFERENCE.md
new file mode 100644
index 0000000..ff76b99
--- /dev/null
+++ b/.agents/skills/opentui/references/animation/REFERENCE.md
@@ -0,0 +1,431 @@
+# Animation System
+
+OpenTUI provides a timeline-based animation system for smooth property transitions.
+
+## Overview
+
+Animations in OpenTUI use:
+- **Timeline**: Orchestrates multiple animations
+- **Animation Engine**: Manages timelines and rendering
+- **Easing Functions**: Control animation curves
+
+## When to Use
+
+Use this reference when you need timeline-driven animations, easing curves, or progressive transitions.
+
+## Basic Usage
+
+### React
+
+```tsx
+import { useTimeline } from "@opentui/react"
+import { useEffect, useState } from "react"
+
+function AnimatedBox() {
+  const [width, setWidth] = useState(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+  })
+
+  useEffect(() => {
+    timeline.add(
+      { width: 0 },
+      {
+        width: 50,
+        duration: 2000,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setWidth(Math.round(anim.targets[0].width))
+        },
+      }
+    )
+  }, [])
+
+  return (
+    <box
+      width={width}
+      height={3}
+      backgroundColor="#6a5acd"
+    />
+  )
+}
+```
+
+### Solid
+
+```tsx
+import { useTimeline } from "@opentui/solid"
+import { createSignal, onMount } from "solid-js"
+
+function AnimatedBox() {
+  const [width, setWidth] = createSignal(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+  })
+
+  onMount(() => {
+    timeline.add(
+      { width: 0 },
+      {
+        width: 50,
+        duration: 2000,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setWidth(Math.round(anim.targets[0].width))
+        },
+      }
+    )
+  })
+
+  return (
+    <box
+      width={width()}
+      height={3}
+      backgroundColor="#6a5acd"
+    />
+  )
+}
+```
+
+### Core
+
+```typescript
+import { createCliRenderer, Timeline, engine } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+engine.attach(renderer)
+
+const timeline = new Timeline({
+  duration: 2000,
+  autoplay: true,
+})
+
+timeline.add(
+  { x: 0 },
+  {
+    x: 50,
+    duration: 2000,
+    ease: "easeOutQuad",
+    onUpdate: (anim) => {
+      box.setLeft(Math.round(anim.targets[0].x))
+    },
+  }
+)
+
+engine.addTimeline(timeline)
+```
+
+## Timeline Options
+
+```typescript
+const timeline = useTimeline({
+  duration: 2000,         // Total duration in ms
+  loop: false,            // Loop the timeline
+  autoplay: true,         // Start automatically
+  onComplete: () => {},   // Called when timeline completes
+  onPause: () => {},      // Called when timeline pauses
+})
+```
+
+## Timeline Methods
+
+```typescript
+// Add animation
+timeline.add(target, properties, startTime?)
+
+// Control playback
+timeline.play()           // Start/resume
+timeline.pause()          // Pause
+timeline.restart()        // Restart from beginning
+
+// State
+timeline.progress         // Current progress (0-1)
+timeline.duration         // Total duration
+```
+
+## Animation Properties
+
+```typescript
+timeline.add(
+  { value: 0 },           // Target object with initial values
+  {
+    value: 100,           // Final value
+    duration: 1000,       // Animation duration in ms
+    ease: "linear",       // Easing function
+    delay: 0,             // Delay before starting
+    onUpdate: (anim) => {
+      // Called each frame
+      const current = anim.targets[0].value
+    },
+    onComplete: () => {
+      // Called when this animation completes
+    },
+  },
+  0                       // Start time in timeline (optional)
+)
+```
+
+## Easing Functions
+
+Available easing functions:
+
+### Linear
+
+| Name | Description |
+|------|-------------|
+| `linear` | Constant speed |
+
+### Quad (Power of 2)
+
+| Name | Description |
+|------|-------------|
+| `easeInQuad` | Slow start |
+| `easeOutQuad` | Slow end |
+| `easeInOutQuad` | Slow start and end |
+
+### Cubic (Power of 3)
+
+| Name | Description |
+|------|-------------|
+| `easeInCubic` | Slower start |
+| `easeOutCubic` | Slower end |
+| `easeInOutCubic` | Slower start and end |
+
+### Quart (Power of 4)
+
+| Name | Description |
+|------|-------------|
+| `easeInQuart` | Even slower start |
+| `easeOutQuart` | Even slower end |
+| `easeInOutQuart` | Even slower start and end |
+
+### Expo (Exponential)
+
+| Name | Description |
+|------|-------------|
+| `easeInExpo` | Exponential start |
+| `easeOutExpo` | Exponential end |
+| `easeInOutExpo` | Exponential start and end |
+
+### Back (Overshoot)
+
+| Name | Description |
+|------|-------------|
+| `easeInBack` | Pull back, then forward |
+| `easeOutBack` | Overshoot, then settle |
+| `easeInOutBack` | Both |
+
+### Elastic
+
+| Name | Description |
+|------|-------------|
+| `easeInElastic` | Elastic start |
+| `easeOutElastic` | Elastic end (bouncy) |
+| `easeInOutElastic` | Both |
+
+### Bounce
+
+| Name | Description |
+|------|-------------|
+| `easeInBounce` | Bounce at start |
+| `easeOutBounce` | Bounce at end |
+| `easeInOutBounce` | Both |
+
+## Patterns
+
+### Progress Bar
+
+```tsx
+function ProgressBar({ progress }: { progress: number }) {
+  const [width, setWidth] = useState(0)
+  const maxWidth = 50
+
+  const timeline = useTimeline()
+
+  useEffect(() => {
+    timeline.add(
+      { value: width },
+      {
+        value: (progress / 100) * maxWidth,
+        duration: 300,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setWidth(Math.round(anim.targets[0].value))
+        },
+      }
+    )
+  }, [progress])
+
+  return (
+    <box flexDirection="column" gap={1}>
+      <text>Progress: {progress}%</text>
+      <box width={maxWidth} height={1} backgroundColor="#333">
+        <box width={width} height={1} backgroundColor="#00FF00" />
+      </box>
+    </box>
+  )
+}
+```
+
+### Fade In
+
+```tsx
+function FadeIn({ children }) {
+  const [opacity, setOpacity] = useState(0)
+
+  const timeline = useTimeline()
+
+  useEffect(() => {
+    timeline.add(
+      { opacity: 0 },
+      {
+        opacity: 1,
+        duration: 500,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setOpacity(anim.targets[0].opacity)
+        },
+      }
+    )
+  }, [])
+
+  return (
+    <box style={{ opacity }}>
+      {children}
+    </box>
+  )
+}
+```
+
+### Looping Animation
+
+```tsx
+function Spinner() {
+  const [frame, setFrame] = useState(0)
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setFrame(f => (f + 1) % frames.length)
+    }, 80)
+
+    return () => clearInterval(interval)
+  }, [])
+
+  return <text>{frames[frame]} Loading...</text>
+}
+```
+
+### Staggered Animation
+
+```tsx
+function StaggeredList({ items }) {
+  const [visibleCount, setVisibleCount] = useState(0)
+
+  useEffect(() => {
+    let count = 0
+    const interval = setInterval(() => {
+      count++
+      setVisibleCount(count)
+      if (count >= items.length) {
+        clearInterval(interval)
+      }
+    }, 100)
+
+    return () => clearInterval(interval)
+  }, [items.length])
+
+  return (
+    <box flexDirection="column">
+      {items.slice(0, visibleCount).map((item, i) => (
+        <text key={i}>{item}</text>
+      ))}
+    </box>
+  )
+}
+```
+
+### Slide In
+
+```tsx
+function SlideIn({ children, from = "left" }) {
+  const [offset, setOffset] = useState(from === "left" ? -20 : 20)
+
+  const timeline = useTimeline()
+
+  useEffect(() => {
+    timeline.add(
+      { offset: from === "left" ? -20 : 20 },
+      {
+        offset: 0,
+        duration: 300,
+        ease: "easeOutCubic",
+        onUpdate: (anim) => {
+          setOffset(Math.round(anim.targets[0].offset))
+        },
+      }
+    )
+  }, [])
+
+  return (
+    <box position="relative" left={offset}>
+      {children}
+    </box>
+  )
+}
+```
+
+## Performance Tips
+
+### Batch Updates
+
+Timeline automatically batches updates within the render loop.
+
+### Use Integer Values
+
+Round animated values for character-based positioning:
+
+```typescript
+onUpdate: (anim) => {
+  setX(Math.round(anim.targets[0].x))
+}
+```
+
+### Clean Up Timelines
+
+Hooks automatically clean up, but for core:
+
+```typescript
+// When done with timeline
+engine.removeTimeline(timeline)
+```
+
+## Gotchas
+
+### Terminal Refresh Rate
+
+Terminal UIs typically refresh at 60 FPS max. Very fast animations may appear choppy.
+
+### Character Grid
+
+Animations are constrained to character cells. Sub-pixel positioning isn't possible.
+
+### Cleanup in Effects
+
+Always clean up intervals and timelines:
+
+```tsx
+useEffect(() => {
+  const interval = setInterval(...)
+  return () => clearInterval(interval)
+}, [])
+```
+
+## See Also
+
+- [React API](../react/api.md) - `useTimeline` hook reference
+- [Solid API](../solid/api.md) - `useTimeline` hook reference
+- [Core API](../core/api.md) - `AnimationEngine` and `Timeline` classes
+- [Layout Patterns](../layout/patterns.md) - Animated positioning and transitions
diff --git a/.agents/skills/opentui/references/components/REFERENCE.md b/.agents/skills/opentui/references/components/REFERENCE.md
new file mode 100644
index 0000000..a28ce8d
--- /dev/null
+++ b/.agents/skills/opentui/references/components/REFERENCE.md
@@ -0,0 +1,144 @@
+# OpenTUI Components
+
+Reference for all OpenTUI components, organized by category. Components are available in all three frameworks (Core, React, Solid) with slight API differences.
+
+## When to Use
+
+Use this reference when you need to find the right component category or compare naming across Core, React, and Solid.
+
+## Component Categories
+
+| Category | Components | File |
+|----------|------------|------|
+| Text & Display | text, ascii-font, styled text | [text-display.md](./text-display.md) |
+| Containers | box, scrollbox, borders | [containers.md](./containers.md) |
+| Inputs | input, textarea, select, tab-select | [inputs.md](./inputs.md) |
+| Code & Diff | code, line-number, diff, markdown, text-table | [code-diff.md](./code-diff.md) |
+
+## Component Chooser
+
+```
+Need a component?
+├─ Styled text or ASCII art -> text-display.md
+├─ Containers, borders, scrolling -> containers.md
+├─ Forms or input controls -> inputs.md
+└─ Code blocks, diffs, line numbers, markdown -> code-diff.md
+```
+
+## Component Naming
+
+Components have different names across frameworks:
+
+| Concept | Core (Class) | React (JSX) | Solid (JSX) |
+|---------|--------------|-------------|-------------|
+| Text | `TextRenderable` | `<text>` | `<text>` |
+| Box | `BoxRenderable` | `<box>` | `<box>` |
+| ScrollBox | `ScrollBoxRenderable` | `<scrollbox>` | `<scrollbox>` |
+| Input | `InputRenderable` | `<input>` | `<input>` |
+| Textarea | `TextareaRenderable` | `<textarea>` | `<textarea>` |
+| Select | `SelectRenderable` | `<select>` | `<select>` |
+| Tab Select | `TabSelectRenderable` | `<tab-select>` | `<tab_select>` |
+| ASCII Font | `ASCIIFontRenderable` | `<ascii-font>` | `<ascii_font>` |
+| Code | `CodeRenderable` | `<code>` | `<code>` |
+| Line Number | `LineNumberRenderable` | `<line-number>` | `<line_number>` |
+| Diff | `DiffRenderable` | `<diff>` | `<diff>` |
+| Markdown | `MarkdownRenderable` | `<markdown>` | `<markdown>` |
+| TextTable | `TextTableRenderable` | N/A (Core only) | N/A (Core only) |
+
+**Note**: Solid uses underscores (`tab_select`) while React uses hyphens (`tab-select`). `TextTableRenderable` is used internally by `MarkdownRenderable` for table rendering and is also available as a standalone Core component.
+
+## Common Properties
+
+All components share these layout properties (see [Layout](../layout/REFERENCE.md)):
+
+```tsx
+// Positioning
+position="relative" | "absolute"
+left, top, right, bottom
+
+// Dimensions
+width, height
+minWidth, maxWidth, minHeight, maxHeight
+
+// Flexbox
+flexDirection, flexGrow, flexShrink, flexBasis
+justifyContent, alignItems, alignSelf
+flexWrap, gap
+
+// Spacing
+padding, paddingTop, paddingRight, paddingBottom, paddingLeft
+paddingX, paddingY              // Axis shorthand (horizontal/vertical)
+margin, marginTop, marginRight, marginBottom, marginLeft
+marginX, marginY                // Axis shorthand (horizontal/vertical)
+
+// Display
+display="flex" | "none"
+overflow="visible" | "hidden" | "scroll"
+zIndex
+```
+
+## Quick Examples
+
+### Core (Imperative)
+
+```typescript
+import { createCliRenderer, TextRenderable, BoxRenderable } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const box = new BoxRenderable(renderer, {
+  id: "container",
+  border: true,
+  padding: 2,
+})
+
+const text = new TextRenderable(renderer, {
+  id: "greeting",
+  content: "Hello!",
+  fg: "#00FF00",
+})
+
+box.add(text)
+renderer.root.add(box)
+```
+
+### React
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+
+function App() {
+  return (
+    <box border padding={2}>
+      <text fg="#00FF00">Hello!</text>
+    </box>
+  )
+}
+
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+### Solid
+
+```tsx
+import { render } from "@opentui/solid"
+
+function App() {
+  return (
+    <box border padding={2}>
+      <text fg="#00FF00">Hello!</text>
+    </box>
+  )
+}
+
+render(() => <App />)
+```
+
+## See Also
+
+- [Core API](../core/api.md) - Imperative component classes
+- [React API](../react/api.md) - React component props
+- [Solid API](../solid/api.md) - Solid component props
+- [Layout](../layout/REFERENCE.md) - Layout system details
diff --git a/.agents/skills/opentui/references/components/code-diff.md b/.agents/skills/opentui/references/components/code-diff.md
new file mode 100644
index 0000000..a5e2eaf
--- /dev/null
+++ b/.agents/skills/opentui/references/components/code-diff.md
@@ -0,0 +1,672 @@
+# Code & Diff Components
+
+Components for displaying code with syntax highlighting and diffs in OpenTUI.
+
+## Code Component
+
+Display syntax-highlighted code blocks.
+
+### Basic Usage
+
+```tsx
+// React
+<code
+  code={`function hello() {
+  console.log("Hello, World!");
+}`}
+  language="typescript"
+/>
+
+// Solid
+<code
+  code={sourceCode}
+  language="javascript"
+/>
+
+// Core
+const codeBlock = new CodeRenderable(renderer, {
+  id: "code",
+  code: sourceCode,
+  language: "typescript",
+})
+```
+
+### Supported Languages
+
+OpenTUI uses Tree-sitter for syntax highlighting. Common languages:
+- `typescript`, `javascript`
+- `python`
+- `rust`
+- `go`
+- `json`
+- `html`, `css`
+- `markdown`
+- `bash`, `shell`
+
+### Styling
+
+```tsx
+<code
+  code={sourceCode}
+  language="typescript"
+  backgroundColor="#1a1a2e"
+  showLineNumbers
+/>
+```
+
+### onHighlight Callback
+
+Intercept and modify syntax highlights before rendering:
+
+```tsx
+// Core
+const codeBlock = new CodeRenderable(renderer, {
+  id: "code",
+  code: sourceCode,
+  language: "typescript",
+  onHighlight: (highlights, context) => {
+    // Add custom highlights
+    highlights.push([10, 20, "custom.error", {}])
+    return highlights
+  },
+})
+
+// React/Solid
+<code
+  code={sourceCode}
+  language="typescript"
+  onHighlight={(highlights, context) => {
+    // context: { content, filetype, syntaxStyle }
+    // Modify and return highlights array
+    return highlights.filter(h => h[2] !== "comment")
+  }}
+/>
+```
+
+**Callback signature:**
+- `highlights: SimpleHighlight[]` - Array of `[start, end, scope, metadata]`
+- `context: { content, filetype, syntaxStyle }` - Highlighting context
+- Return modified highlights array or `undefined` to use original
+
+Supports async callbacks for fetching additional highlight data.
+
+### onChunks Callback
+
+Post-process rendered text chunks after syntax highlighting. Runs after `onHighlight` and receives fully resolved chunks:
+
+```tsx
+// Core
+const codeBlock = new CodeRenderable(renderer, {
+  id: "code",
+  code: sourceCode,
+  language: "typescript",
+  onChunks: (chunks, context) => {
+    // Transform chunks (e.g., add link detection)
+    return chunks
+  },
+})
+
+// React/Solid
+<code
+  code={sourceCode}
+  language="typescript"
+  onChunks={(chunks, context) => {
+    // context: { content, filetype, syntaxStyle, highlights }
+    return chunks
+  }}
+/>
+```
+
+### Link Detection Utility
+
+Auto-detect URLs in code and add clickable hyperlinks:
+
+```typescript
+import { detectLinks } from "@opentui/core"
+
+<code
+  code={sourceCode}
+  language="typescript"
+  onChunks={(chunks, context) => detectLinks(chunks, context)}
+/>
+```
+
+`detectLinks` examines Tree-sitter highlights to find URL tokens and sets `chunk.link` on matching chunks. Supports async usage.
+
+## TextTable Component
+
+Render data tables with borders, word wrapping, and selection support.
+
+### Basic Usage
+
+```typescript
+// Core
+import { TextTableRenderable, type TextTableContent } from "@opentui/core"
+
+const content: TextTableContent = [
+  [[ { text: "Name" } ], [ { text: "Age" } ], [ { text: "Role" } ]],
+  [[ { text: "Alice" } ], [ { text: "30" } ], [ { text: "Engineer" } ]],
+  [[ { text: "Bob" } ], [ { text: "25" } ], [ { text: "Designer" } ]],
+]
+
+const table = new TextTableRenderable(renderer, {
+  id: "table",
+  content,
+  wrapMode: "word",           // "none" | "char" | "word"
+  columnWidthMode: "content", // "content" | "fill"
+  cellPadding: 0,
+  border: true,
+  outerBorder: true,
+  borderStyle: "single",      // single | double | rounded | bold
+  selectable: true,           // Allow text selection
+  columnFitter: "balanced",   // "proportional" | "balanced"
+})
+```
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `content` | `TextTableContent` | - | 2D array of cell content |
+| `wrapMode` | `"none" \| "char" \| "word"` | `"none"` | Text wrapping in cells |
+| `columnWidthMode` | `"content" \| "fill"` | `"content"` | Column sizing strategy |
+| `cellPadding` | `number` | `0` | Padding inside cells |
+| `border` | `boolean` | `true` | Show inner borders |
+| `outerBorder` | `boolean` | `true` | Show outer borders |
+| `borderStyle` | `string` | `"single"` | Border style |
+| `borderColor` | `string \| RGBA` | - | Border color |
+| `selectable` | `boolean` | `false` | Allow text selection |
+| `columnFitter` | `"proportional" \| "balanced"` | `"proportional"` | Column width distribution |
+
+### Cell Content Format
+
+Each cell is an array of styled text chunks:
+
+```typescript
+type TextTableCellContent = { text: string; fg?: RGBA; bg?: RGBA }[]
+type TextTableContent = TextTableCellContent[][]  // rows -> cells -> chunks
+```
+
+### Selection
+
+```typescript
+table.getSelectedText()  // Get selected text
+table.hasSelection()     // Check if text is selected
+```
+
+Columnar selection is supported: dragging vertically within a single column selects only that column's content.
+
+## Line Number Component
+
+Code display with line numbers, highlighting, and diagnostics.
+
+### Basic Usage
+
+```tsx
+// React
+<line-number
+  code={sourceCode}
+  language="typescript"
+/>
+
+// Solid (note underscore)
+<line_number
+  code={sourceCode}
+  language="typescript"
+/>
+
+// Core
+const codeView = new LineNumberRenderable(renderer, {
+  id: "code-view",
+  code: sourceCode,
+  language: "typescript",
+})
+```
+
+### Line Number Options
+
+```tsx
+// React
+<line-number
+  code={sourceCode}
+  language="typescript"
+  startLine={1}              // Starting line number
+  showLineNumbers={true}     // Display line numbers
+/>
+
+// Solid
+<line_number
+  code={sourceCode}
+  language="typescript"
+  startLine={1}
+  showLineNumbers={true}
+/>
+```
+
+### Line Highlighting
+
+Highlight specific lines:
+
+```tsx
+// React
+<line-number
+  code={sourceCode}
+  language="typescript"
+  highlightedLines={[5, 10, 15]}  // Highlight these lines
+/>
+
+// Solid
+<line_number
+  code={sourceCode}
+  language="typescript"
+  highlightedLines={[5, 10, 15]}
+/>
+```
+
+### Diagnostics
+
+Show errors, warnings, and info on specific lines:
+
+```tsx
+// React
+<line-number
+  code={sourceCode}
+  language="typescript"
+  diagnostics={[
+    { line: 3, severity: "error", message: "Unexpected token" },
+    { line: 7, severity: "warning", message: "Unused variable" },
+    { line: 12, severity: "info", message: "Consider using const" },
+  ]}
+/>
+
+// Solid
+<line_number
+  code={sourceCode}
+  language="typescript"
+  diagnostics={[
+    { line: 3, severity: "error", message: "Unexpected token" },
+  ]}
+/>
+```
+
+**Diagnostic severity levels:**
+- `error` - Red indicator
+- `warning` - Yellow indicator
+- `info` - Blue indicator
+- `hint` - Gray indicator
+
+### Diff Highlighting
+
+Show added/removed lines:
+
+```tsx
+<line-number
+  code={sourceCode}
+  language="typescript"
+  addedLines={[5, 6, 7]}      // Green background
+  removedLines={[10, 11]}     // Red background
+/>
+```
+
+## Diff Component
+
+Unified or split diff viewer with syntax highlighting.
+
+### Basic Usage
+
+```tsx
+// React
+<diff
+  oldCode={originalCode}
+  newCode={modifiedCode}
+  language="typescript"
+/>
+
+// Solid
+<diff
+  oldCode={originalCode}
+  newCode={modifiedCode}
+  language="typescript"
+/>
+
+// Core
+const diffView = new DiffRenderable(renderer, {
+  id: "diff",
+  oldCode: originalCode,
+  newCode: modifiedCode,
+  language: "typescript",
+})
+```
+
+### Display Modes
+
+```tsx
+// Unified diff (default)
+<diff
+  oldCode={old}
+  newCode={new}
+  mode="unified"
+/>
+
+// Split/side-by-side diff
+<diff
+  oldCode={old}
+  newCode={new}
+  mode="split"
+/>
+```
+
+### Synchronized Scrolling (Split View)
+
+In split view, enable synchronized scrolling between left and right panes:
+
+```tsx
+// React/Solid
+<diff
+  oldCode={old}
+  newCode={new}
+  mode="split"
+  syncScroll              // Scrolling one pane syncs the other
+/>
+
+// Core
+const diffView = new DiffRenderable(renderer, {
+  id: "diff",
+  diff: unifiedDiff,
+  view: "split",
+  syncScroll: true,
+})
+
+// Toggle at runtime
+diffView.syncScroll = true
+diffView.syncScroll = false
+```
+
+### Options
+
+```tsx
+<diff
+  oldCode={originalCode}
+  newCode={modifiedCode}
+  language="typescript"
+  mode="unified"
+  showLineNumbers
+  context={3}                // Lines of context around changes
+/>
+```
+
+### Styling
+
+```tsx
+<diff
+  oldCode={old}
+  newCode={new}
+  addedLineColor="#2d4f2d"   // Background for added lines
+  removedLineColor="#4f2d2d" // Background for removed lines
+  unchangedLineColor="transparent"
+/>
+```
+
+### Line Highlighting API (Core)
+
+Programmatically highlight specific lines in a diff:
+
+```typescript
+// Set a single line's color
+diffView.setLineColor(5, "#2d4f2d")
+diffView.setLineColor(5, { gutter: "#333", content: "#2d4f2d" })
+
+// Clear a single line's color
+diffView.clearLineColor(5)
+
+// Set multiple lines at once
+diffView.setLineColors(new Map([
+  [1, "#2d4f2d"],
+  [2, "#4f2d2d"],
+]))
+
+// Highlight a range
+diffView.highlightLines(10, 20, "#2d4f2d")
+diffView.clearHighlightLines(10, 20)
+
+// Clear all line colors
+diffView.clearAllLineColors()
+```
+
+The `LineNumberRenderable` also supports programmatic highlighting:
+
+```typescript
+lineNumberView.highlightLines(5, 10, "#2d4f2d")
+lineNumberView.clearHighlightLines(5, 10)
+```
+```
+
+## Markdown Component
+
+Render markdown content with syntax highlighting for code blocks.
+
+### Basic Usage
+
+```tsx
+// React
+<markdown
+  content={markdownText}
+  syntaxStyle={mySyntaxStyle}
+/>
+
+// Solid
+<markdown
+  content={markdownText}
+  syntaxStyle={mySyntaxStyle}
+/>
+
+// Core
+import { MarkdownRenderable } from "@opentui/core"
+
+const md = new MarkdownRenderable(renderer, {
+  id: "markdown",
+  content: "# Hello\n\nThis is **markdown**.",
+  syntaxStyle: mySyntaxStyle,
+})
+```
+
+### Options
+
+```tsx
+<markdown
+  content={markdownText}
+  syntaxStyle={syntaxStyle}
+  treeSitterClient={client}  // Optional: custom tree-sitter client
+  conceal={true}             // Hide markdown syntax characters
+  streaming={true}           // Enable streaming mode for incremental updates
+  tableOptions={{            // Customize markdown table rendering
+    widthMode: "full",       // "content" | "full"
+    wrapMode: "word",        // "none" | "char" | "word"
+    cellPadding: 0,
+    borders: true,
+    outerBorder: true,
+    borderStyle: "single",
+    borderColor: "#555",
+    selectable: true,        // Tables are selectable by default
+  }}
+/>
+```
+
+### Custom Node Rendering
+
+```tsx
+// Core
+const md = new MarkdownRenderable(renderer, {
+  id: "markdown",
+  content: "# Custom Heading",
+  syntaxStyle,
+  renderNode: (node, ctx, defaultRender) => {
+    if (node.type === "heading") {
+      // Return custom renderable for headings
+      return new TextRenderable(ctx, {
+        content: `>> ${node.content} <<`,
+      })
+    }
+    return null // Use default rendering
+  },
+})
+```
+
+### Streaming Mode
+
+For real-time content like LLM output:
+
+```tsx
+const [content, setContent] = useState("")
+
+// Append text as it arrives
+useEffect(() => {
+  llmStream.on("token", (token) => {
+    setContent(c => c + token)
+  })
+}, [])
+
+<markdown
+  content={content}
+  syntaxStyle={syntaxStyle}
+  streaming={true}  // Optimizes for incremental updates
+/>
+```
+
+## Use Cases
+
+### Code Editor
+
+```tsx
+function CodeEditor() {
+  const [code, setCode] = useState(`function hello() {
+  console.log("Hello!");
+}`)
+
+  return (
+    <box flexDirection="column" height="100%">
+      <box height={1}>
+        <text>editor.ts</text>
+      </box>
+      <textarea
+        value={code}
+        onChange={setCode}
+        language="typescript"
+        showLineNumbers
+        flexGrow={1}
+        focused
+      />
+    </box>
+  )
+}
+```
+
+### Code Review
+
+```tsx
+function CodeReview({ oldCode, newCode }) {
+  return (
+    <box flexDirection="column" height="100%">
+      <box height={1} backgroundColor="#333">
+        <text>Changes in src/utils.ts</text>
+      </box>
+      <diff
+        oldCode={oldCode}
+        newCode={newCode}
+        language="typescript"
+        mode="split"
+        showLineNumbers
+      />
+    </box>
+  )
+}
+```
+
+### Syntax-Highlighted Preview
+
+```tsx
+function MarkdownPreview({ content }) {
+  // Extract code blocks from markdown
+  const codeBlocks = extractCodeBlocks(content)
+
+  return (
+    <scrollbox height={20}>
+      {codeBlocks.map((block, i) => (
+        <box key={i} marginBottom={1}>
+          <code
+            code={block.code}
+            language={block.language}
+          />
+        </box>
+      ))}
+    </scrollbox>
+  )
+}
+```
+
+### Error Display
+
+```tsx
+function ErrorView({ errors, code }) {
+  const diagnostics = errors.map(err => ({
+    line: err.line,
+    severity: "error",
+    message: err.message,
+  }))
+
+  return (
+    <line-number
+      code={code}
+      language="typescript"
+      diagnostics={diagnostics}
+      highlightedLines={errors.map(e => e.line)}
+    />
+  )
+}
+```
+
+## Gotchas
+
+### Solid Uses Underscores
+
+```tsx
+// React
+<line-number />
+
+// Solid
+<line_number />
+```
+
+### Language Required for Highlighting
+
+```tsx
+// No highlighting (plain text)
+<code code={text} />
+
+// With highlighting
+<code code={text} language="typescript" />
+```
+
+### Large Files
+
+For very large files, consider:
+- Pagination or virtual scrolling
+- Loading only visible portion
+- Using `scrollbox` wrapper
+
+```tsx
+<scrollbox height={30}>
+  <line-number
+    code={largeFile}
+    language="typescript"
+  />
+</scrollbox>
+```
+
+### Tree-sitter Loading
+
+Syntax highlighting requires Tree-sitter grammars. If highlighting isn't working:
+
+1. Check the language is supported
+2. Verify grammars are installed
+3. Check `OTUI_TREE_SITTER_WORKER_PATH` if using custom path
diff --git a/.agents/skills/opentui/references/components/containers.md b/.agents/skills/opentui/references/components/containers.md
new file mode 100644
index 0000000..4583e6d
--- /dev/null
+++ b/.agents/skills/opentui/references/components/containers.md
@@ -0,0 +1,417 @@
+# Container Components
+
+Components for grouping and organizing content in OpenTUI.
+
+## Box Component
+
+The primary container component with borders, backgrounds, and layout capabilities.
+
+### Basic Usage
+
+```tsx
+// React/Solid
+<box>
+  <text>Content inside box</text>
+</box>
+
+// Core
+const box = new BoxRenderable(renderer, {
+  id: "container",
+})
+box.add(child)
+```
+
+### Borders
+
+```tsx
+<box border>
+  Simple border
+</box>
+
+<box
+  border
+  borderStyle="single"    // single | double | rounded | bold | none
+  borderColor="#FFFFFF"
+>
+  Styled border
+</box>
+
+// Individual borders
+<box
+  borderTop
+  borderBottom
+  borderLeft={false}
+  borderRight={false}
+>
+  Top and bottom only
+</box>
+```
+
+**Border Styles:**
+
+| Style | Appearance |
+|-------|------------|
+| `single` | `┌─┐│ │└─┘` |
+| `double` | `╔═╗║ ║╚═╝` |
+| `rounded` | `╭─╮│ │╰─╯` |
+| `bold` | `┏━┓┃ ┃┗━┛` |
+
+### Title
+
+```tsx
+<box
+  border
+  title="Settings"
+  titleAlignment="center"   // left | center | right
+>
+  Panel content
+</box>
+```
+
+### Background
+
+```tsx
+<box backgroundColor="#1a1a2e">
+  Dark background
+</box>
+
+<box backgroundColor="transparent">
+  No background
+</box>
+```
+
+### Layout
+
+Boxes are flex containers by default:
+
+```tsx
+<box
+  flexDirection="row"       // row | column | row-reverse | column-reverse
+  justifyContent="center"   // flex-start | flex-end | center | space-between | space-around
+  alignItems="center"       // flex-start | flex-end | center | stretch | baseline
+  gap={2}                   // Space between children
+>
+  <text>Item 1</text>
+  <text>Item 2</text>
+</box>
+```
+
+### Spacing
+
+```tsx
+<box
+  padding={2}               // All sides
+  paddingTop={1}
+  paddingRight={2}
+  paddingBottom={1}
+  paddingLeft={2}
+  paddingX={2}              // Horizontal (left + right)
+  paddingY={1}              // Vertical (top + bottom)
+  margin={1}
+  marginTop={1}
+  marginX={2}               // Horizontal (left + right)
+  marginY={1}               // Vertical (top + bottom)
+>
+  Spaced content
+</box>
+```
+
+### Dimensions
+
+```tsx
+<box
+  width={40}                // Fixed width
+  height={10}               // Fixed height
+  width="50%"               // Percentage of parent
+  minWidth={20}             // Minimum width
+  maxWidth={80}             // Maximum width
+  flexGrow={1}              // Grow to fill space
+>
+  Sized box
+</box>
+```
+
+### Mouse Events
+
+```tsx
+<box
+  onMouseDown={(event) => {
+    console.log("Clicked at:", event.x, event.y)
+  }}
+  onMouseUp={(event) => {}}
+  onMouseMove={(event) => {}}
+>
+  Clickable box
+</box>
+```
+
+### Focusable Boxes
+
+By default, Box elements are not focusable. Set the `focusable` prop to enable focus behavior:
+
+```tsx
+// Make a box focusable - it can receive focus via mouse click
+<box focusable border>
+  <text>Click to focus</text>
+</box>
+
+// Controlled focus state
+const [focused, setFocused] = useState(false)
+
+<box
+  focusable
+  focused={focused}
+  border
+  borderColor={focused ? "#00ff00" : "#888"}
+>
+  <text>{focused ? "Focused!" : "Not focused"}</text>
+</box>
+```
+
+When a focusable Box is clicked, focus bubbles up from the click target to the nearest focusable parent. Use `event.preventDefault()` in `onMouseDown` to prevent auto-focus.
+
+## ScrollBox Component
+
+A scrollable container for content that exceeds the viewport.
+
+### Basic Usage
+
+```tsx
+// React
+<scrollbox height={10}>
+  {items.map((item, i) => (
+    <text key={i}>{item}</text>
+  ))}
+</scrollbox>
+
+// Solid
+<scrollbox height={10}>
+  <For each={items()}>
+    {(item) => <text>{item}</text>}
+  </For>
+</scrollbox>
+
+// Core
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "list",
+  height: 10,
+})
+items.forEach(item => {
+  scrollbox.add(new TextRenderable(renderer, { content: item }))
+})
+```
+
+### Focus for Keyboard Scrolling
+
+```tsx
+<scrollbox focused height={20}>
+  {/* Use arrow keys to scroll */}
+</scrollbox>
+```
+
+### Scrollbar Styling
+
+```tsx
+// React
+<scrollbox
+  style={{
+    rootOptions: {
+      backgroundColor: "#24283b",
+    },
+    wrapperOptions: {
+      backgroundColor: "#1f2335",
+    },
+    viewportOptions: {
+      backgroundColor: "#1a1b26",
+    },
+    contentOptions: {
+      backgroundColor: "#16161e",
+    },
+    scrollbarOptions: {
+      showArrows: true,
+      trackOptions: {
+        foregroundColor: "#7aa2f7",
+        backgroundColor: "#414868",
+      },
+    },
+  }}
+>
+  {content}
+</scrollbox>
+```
+
+### Scroll Position (Core)
+
+```typescript
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "list",
+  height: 20,
+})
+
+// Scroll programmatically
+scrollbox.scrollTo(0)           // Scroll to top
+scrollbox.scrollTo(100)         // Scroll to position
+scrollbox.scrollBy(10)          // Scroll relative
+scrollbox.scrollToBottom()      // Scroll to end
+
+// Scroll a child into view (nearest alignment)
+scrollbox.scrollChildIntoView("child-id")  // Searches descendants by ID
+```
+
+`scrollChildIntoView(childId)` scrolls the minimum amount needed to make the identified descendant visible. It mirrors `Element.scrollIntoView({ block: "nearest" })` from the CSSOM View spec. Works with nested descendants and handles both horizontal and vertical scrolling.
+
+## Composition Patterns
+
+### Card Component
+
+```tsx
+function Card({ title, children }) {
+  return (
+    <box
+      border
+      borderStyle="rounded"
+      padding={2}
+      marginBottom={1}
+    >
+      {title && (
+        <text fg="#00FFFF" bold>
+          {title}
+        </text>
+      )}
+      <box marginTop={title ? 1 : 0}>
+        {children}
+      </box>
+    </box>
+  )
+}
+```
+
+### Panel Component
+
+```tsx
+function Panel({ title, children, width = 40 }) {
+  return (
+    <box
+      border
+      borderStyle="double"
+      width={width}
+      backgroundColor="#1a1a2e"
+    >
+      {title && (
+        <box
+          borderBottom
+          padding={1}
+          backgroundColor="#2a2a4e"
+        >
+          <text bold>{title}</text>
+        </box>
+      )}
+      <box padding={2}>
+        {children}
+      </box>
+    </box>
+  )
+}
+```
+
+### List Container
+
+```tsx
+function List({ items, renderItem }) {
+  return (
+    <scrollbox height={15} focused>
+      {items.map((item, i) => (
+        <box
+          key={i}
+          padding={1}
+          backgroundColor={i % 2 === 0 ? "#222" : "#333"}
+        >
+          {renderItem(item, i)}
+        </box>
+      ))}
+    </scrollbox>
+  )
+}
+```
+
+## Nesting Containers
+
+```tsx
+<box flexDirection="column" height="100%">
+  {/* Header */}
+  <box height={3} border>
+    <text>Header</text>
+  </box>
+
+  {/* Main area with sidebar */}
+  <box flexDirection="row" flexGrow={1}>
+    <box width={20} border>
+      <text>Sidebar</text>
+    </box>
+    <box flexGrow={1}>
+      <scrollbox height="100%">
+        {/* Scrollable content */}
+      </scrollbox>
+    </box>
+  </box>
+
+  {/* Footer */}
+  <box height={1}>
+    <text>Footer</text>
+  </box>
+</box>
+```
+
+## Gotchas
+
+### Percentage Dimensions Need Parent Size
+
+```tsx
+// WRONG - parent has no explicit size
+<box>
+  <box width="50%">Won't work</box>
+</box>
+
+// CORRECT
+<box width="100%">
+  <box width="50%">Works</box>
+</box>
+```
+
+### FlexGrow Needs Sized Parent
+
+```tsx
+// WRONG
+<box>
+  <box flexGrow={1}>Won't grow</box>
+</box>
+
+// CORRECT
+<box height="100%">
+  <box flexGrow={1}>Will grow</box>
+</box>
+```
+
+### ScrollBox Needs Height
+
+```tsx
+// WRONG - no height constraint
+<scrollbox>
+  {items}
+</scrollbox>
+
+// CORRECT
+<scrollbox height={20}>
+  {items}
+</scrollbox>
+```
+
+### Borders Add to Size
+
+Borders take up space inside the box:
+
+```tsx
+<box width={10} border>
+  {/* Inner content area is 8 chars (10 - 2 for borders) */}
+</box>
+```
diff --git a/.agents/skills/opentui/references/components/inputs.md b/.agents/skills/opentui/references/components/inputs.md
new file mode 100644
index 0000000..a92edfa
--- /dev/null
+++ b/.agents/skills/opentui/references/components/inputs.md
@@ -0,0 +1,531 @@
+# Input Components
+
+Components for user input in OpenTUI.
+
+## Input Component
+
+Single-line text input field.
+
+### Basic Usage
+
+```tsx
+// React
+<input
+  value={value}
+  onChange={(newValue) => setValue(newValue)}
+  placeholder="Enter text..."
+  focused
+/>
+
+// Solid
+<input
+  value={value()}
+  onInput={(newValue) => setValue(newValue)}
+  placeholder="Enter text..."
+  focused
+/>
+
+// Core
+const input = new InputRenderable(renderer, {
+  id: "name",
+  placeholder: "Enter text...",
+})
+input.on(InputRenderableEvents.CHANGE, (value) => {
+  console.log("Value:", value)
+})
+input.focus()
+```
+
+### Styling
+
+```tsx
+<input
+  width={30}
+  backgroundColor="#1a1a1a"
+  textColor="#FFFFFF"
+  cursorColor="#00FF00"
+  focusedBackgroundColor="#2a2a2a"
+  placeholderColor="#666666"
+/>
+```
+
+### Events
+
+```tsx
+// React
+<input
+  onChange={(value) => console.log("Changed:", value)}
+  onFocus={() => console.log("Focused")}
+  onBlur={() => console.log("Blurred")}
+/>
+
+// Core
+input.on(InputRenderableEvents.CHANGE, (value) => {})
+input.on(InputRenderableEvents.FOCUS, () => {})
+input.on(InputRenderableEvents.BLUR, () => {})
+```
+
+### Controlled Input
+
+```tsx
+// React
+function ControlledInput() {
+  const [value, setValue] = useState("")
+
+  return (
+    <input
+      value={value}
+      onChange={setValue}
+      focused
+    />
+  )
+}
+
+// Solid
+function ControlledInput() {
+  const [value, setValue] = createSignal("")
+
+  return (
+    <input
+      value={value()}
+      onInput={setValue}
+      focused
+    />
+  )
+}
+```
+
+## Textarea Component
+
+Multi-line text input field.
+
+### Basic Usage
+
+```tsx
+// React
+<textarea
+  value={text}
+  onChange={(newText) => setText(newText)}
+  placeholder="Enter multiple lines..."
+  width={40}
+  height={10}
+  focused
+/>
+
+// Solid
+<textarea
+  value={text()}
+  onInput={(newText) => setText(newText)}
+  placeholder="Enter multiple lines..."
+  width={40}
+  height={10}
+  focused
+/>
+
+// Core
+const textarea = new TextareaRenderable(renderer, {
+  id: "editor",
+  width: 40,
+  height: 10,
+  placeholder: "Enter text...",
+})
+```
+
+### Features
+
+```tsx
+<textarea
+  showLineNumbers        // Display line numbers
+  wrapText              // Wrap long lines
+  readOnly              // Disable editing
+  tabSize={2}           // Tab character width
+/>
+```
+
+### Syntax Highlighting
+
+```tsx
+<textarea
+  language="typescript"
+  value={code}
+  onChange={setCode}
+/>
+```
+
+## Select Component
+
+List selection for choosing from options.
+
+### Basic Usage
+
+```tsx
+// React
+<select
+  options={[
+    { name: "Option 1", description: "First option", value: "1" },
+    { name: "Option 2", description: "Second option", value: "2" },
+    { name: "Option 3", description: "Third option", value: "3" },
+  ]}
+  onSelect={(index, option) => {
+    console.log("Selected:", option.name)  // Called when Enter is pressed
+  }}
+  focused
+/>
+
+// Solid
+<select
+  options={[
+    { name: "Option 1", description: "First option", value: "1" },
+    { name: "Option 2", description: "Second option", value: "2" },
+  ]}
+  onSelect={(index, option) => {
+    console.log("Selected:", option.name)  // Called when Enter is pressed
+  }}
+  focused
+/>
+
+// Core
+const select = new SelectRenderable(renderer, {
+  id: "menu",
+  options: [
+    { name: "Option 1", description: "First option", value: "1" },
+    { name: "Option 2", description: "Second option", value: "2" },
+  ],
+})
+select.on(SelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  console.log("Selected:", option.name)  // Called when Enter is pressed
+})
+select.focus()
+```
+
+### Option Format
+
+```typescript
+interface SelectOption {
+  name: string          // Display text
+  description?: string  // Optional description shown below
+  value?: any          // Associated value
+}
+```
+
+### Styling
+
+```tsx
+<select
+  height={8}                    // Visible height
+  selectedIndex={0}             // Initially selected
+  showScrollIndicator           // Show scroll arrows
+  selectedBackgroundColor="#333"
+  selectedTextColor="#fff"
+  highlightBackgroundColor="#444"
+/>
+```
+
+### Navigation
+
+Default keybindings:
+- `Up` / `k` - Move up
+- `Down` / `j` - Move down
+- `Enter` - Select item
+
+### Events
+
+**Important**: `onSelect` and `onChange` serve different purposes:
+
+| Event | Trigger | Use Case |
+|-------|---------|----------|
+| `onSelect` | **Enter key pressed** - user confirms selection | Perform action with selected item |
+| `onChange` | **Arrow keys** - user navigates list | Preview, update UI as user browses |
+
+```tsx
+// React/Solid
+<select
+  onSelect={(index, option) => {
+    // Called when Enter is pressed - selection confirmed
+    console.log("User selected:", option.name)
+    performAction(option)
+  }}
+  onChange={(index, option) => {
+    // Called when navigating with arrow keys
+    console.log("Browsing:", option.name)
+    showPreview(option)
+  }}
+/>
+
+// Core
+select.on(SelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  // Called when Enter is pressed
+})
+select.on(SelectRenderableEvents.SELECTION_CHANGED, (index, option) => {
+  // Called when navigating with arrow keys
+})
+```
+
+## Tab Select Component
+
+Horizontal tab-based selection.
+
+### Basic Usage
+
+```tsx
+// React
+<tab-select
+  options={[
+    { name: "Home", description: "Dashboard view" },
+    { name: "Settings", description: "Configuration" },
+    { name: "Help", description: "Documentation" },
+  ]}
+  onSelect={(index, option) => {
+    console.log("Tab selected:", option.name)  // Called when Enter is pressed
+  }}
+  focused
+/>
+
+// Solid (note underscore)
+<tab_select
+  options={[
+    { name: "Home", description: "Dashboard view" },
+    { name: "Settings", description: "Configuration" },
+  ]}
+  onSelect={(index, option) => {
+    console.log("Tab selected:", option.name)  // Called when Enter is pressed
+  }}
+  focused
+/>
+
+// Core
+const tabs = new TabSelectRenderable(renderer, {
+  id: "tabs",
+  options: [...],
+  tabWidth: 20,
+})
+tabs.on(TabSelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  console.log("Tab selected:", option.name)  // Called when Enter is pressed
+})
+tabs.focus()
+```
+
+### Events
+
+Same pattern as Select - `onSelect` for Enter key, `onChange` for navigation:
+
+```tsx
+<tab-select
+  onSelect={(index, option) => {
+    // Called when Enter is pressed - switch to tab
+    setActiveTab(index)
+  }}
+  onChange={(index, option) => {
+    // Called when navigating with arrow keys
+    showTabPreview(option)
+  }}
+/>
+```
+
+### Styling
+
+```tsx
+// React
+<tab-select
+  tabWidth={20}                // Width of each tab
+  selectedIndex={0}            // Initially selected tab
+/>
+
+// Solid
+<tab_select
+  tabWidth={20}
+  selectedIndex={0}
+/>
+```
+
+### Navigation
+
+Default keybindings:
+- `Left` / `[` - Previous tab
+- `Right` / `]` - Next tab
+- `Enter` - Select tab
+
+## Focus Management
+
+### Single Focused Input
+
+```tsx
+function SingleInput() {
+  return <input placeholder="I'm focused" focused />
+}
+```
+
+### Multiple Inputs with Focus State
+
+```tsx
+// React
+function Form() {
+  const [focusIndex, setFocusIndex] = useState(0)
+  const fields = ["name", "email", "message"]
+
+  useKeyboard((key) => {
+    if (key.name === "tab") {
+      setFocusIndex(i => (i + 1) % fields.length)
+    }
+  })
+
+  return (
+    <box flexDirection="column" gap={1}>
+      {fields.map((field, i) => (
+        <input
+          key={field}
+          placeholder={`Enter ${field}`}
+          focused={i === focusIndex}
+        />
+      ))}
+    </box>
+  )
+}
+```
+
+### Focus Methods (Core)
+
+```typescript
+input.focus()      // Give focus
+input.blur()       // Remove focus
+input.isFocused()  // Check focus state
+```
+
+## Form Patterns
+
+### Login Form
+
+```tsx
+function LoginForm() {
+  const [username, setUsername] = useState("")
+  const [password, setPassword] = useState("")
+  const [focusField, setFocusField] = useState<"username" | "password">("username")
+
+  useKeyboard((key) => {
+    if (key.name === "tab") {
+      setFocusField(f => f === "username" ? "password" : "username")
+    }
+    if (key.name === "enter") {
+      handleLogin()
+    }
+  })
+
+  return (
+    <box flexDirection="column" gap={1} border padding={2}>
+      <box flexDirection="row" gap={1}>
+        <text>Username:</text>
+        <input
+          value={username}
+          onChange={setUsername}
+          focused={focusField === "username"}
+          width={20}
+        />
+      </box>
+      <box flexDirection="row" gap={1}>
+        <text>Password:</text>
+        <input
+          value={password}
+          onChange={setPassword}
+          focused={focusField === "password"}
+          width={20}
+        />
+      </box>
+    </box>
+  )
+}
+```
+
+### Search with Results
+
+```tsx
+function SearchableList({ items, onItemSelected }) {
+  const [query, setQuery] = useState("")
+  const [focusSearch, setFocusSearch] = useState(true)
+  const [preview, setPreview] = useState(null)
+
+  const filtered = items.filter(item =>
+    item.toLowerCase().includes(query.toLowerCase())
+  )
+
+  useKeyboard((key) => {
+    if (key.name === "tab") {
+      setFocusSearch(f => !f)
+    }
+  })
+
+  return (
+    <box flexDirection="column">
+      <input
+        value={query}
+        onChange={setQuery}
+        placeholder="Search..."
+        focused={focusSearch}
+      />
+      <select
+        options={filtered.map(item => ({ name: item }))}
+        focused={!focusSearch}
+        height={10}
+        onSelect={(index, option) => {
+          // Enter pressed - confirm selection
+          onItemSelected(option)
+        }}
+        onChange={(index, option) => {
+          // Navigating - show preview
+          setPreview(option)
+        }}
+      />
+    </box>
+  )
+}
+```
+
+## Gotchas
+
+### Focus Required
+
+Inputs must be focused to receive keyboard input:
+
+```tsx
+// WRONG - won't receive input
+<input placeholder="Type here" />
+
+// CORRECT
+<input placeholder="Type here" focused />
+```
+
+### Select Options Format
+
+Options must be objects with `name` property:
+
+```tsx
+// WRONG
+<select options={["a", "b", "c"]} />
+
+// CORRECT
+<select options={[
+  { name: "A", description: "Option A" },
+  { name: "B", description: "Option B" },
+]} />
+```
+
+### Solid Uses Underscores
+
+```tsx
+// React
+<tab-select />
+
+// Solid
+<tab_select />
+```
+
+### Value vs onInput (Solid)
+
+Solid uses `onInput` instead of `onChange`:
+
+```tsx
+// React
+<input value={value} onChange={setValue} />
+
+// Solid
+<input value={value()} onInput={setValue} />
+```
diff --git a/.agents/skills/opentui/references/components/text-display.md b/.agents/skills/opentui/references/components/text-display.md
new file mode 100644
index 0000000..796752e
--- /dev/null
+++ b/.agents/skills/opentui/references/components/text-display.md
@@ -0,0 +1,386 @@
+# Text & Display Components
+
+Components for displaying text content in OpenTUI.
+
+## Text Component
+
+The primary component for displaying styled text.
+
+### Basic Usage
+
+```tsx
+// React/Solid
+<text>Hello, World!</text>
+
+// With content prop
+<text content="Hello, World!" />
+
+// Core
+const text = new TextRenderable(renderer, {
+  id: "greeting",
+  content: "Hello, World!",
+})
+```
+
+### Styling (React/Solid)
+
+For React and Solid, use **nested modifier tags** for text styling:
+
+```tsx
+<text fg="#FFFFFF" bg="#000000">
+  <strong>Bold</strong>, <em>italic</em>, and <u>underlined</u>
+</text>
+```
+
+> **Important**: Do NOT use `bold`, `italic`, `underline`, `dim`, `strikethrough` as props on `<text>` — they don't work. Always use nested tags like `<strong>`, `<em>`, `<u>`, or `<span>` with styling.
+
+### Styling (Core) - Text Attributes
+
+```typescript
+import { TextRenderable, TextAttributes } from "@opentui/core"
+
+const text = new TextRenderable(renderer, {
+  content: "Styled",
+  attributes: TextAttributes.BOLD | TextAttributes.UNDERLINE,
+})
+```
+
+**Available attributes:**
+- `TextAttributes.BOLD`
+- `TextAttributes.DIM`
+- `TextAttributes.ITALIC`
+- `TextAttributes.UNDERLINE`
+- `TextAttributes.BLINK`
+- `TextAttributes.INVERSE`
+- `TextAttributes.HIDDEN`
+- `TextAttributes.STRIKETHROUGH`
+
+### Text Selection
+
+```tsx
+<text selectable>
+  This text can be selected by the user
+</text>
+
+<text selectable={false}>
+  This text cannot be selected
+</text>
+```
+
+For copy-on-selection and the full selection API, see `keyboard/REFERENCE.md` (selection).
+
+## Text Modifiers
+
+Inline styling elements that must be used inside `<text>`:
+
+### Span
+
+Inline styled text:
+
+```tsx
+<text>
+  Normal text with <span fg="red">red text</span> inline
+</text>
+```
+
+### Bold/Strong
+
+```tsx
+<text>
+  <strong>Bold text</strong>
+  <b>Also bold</b>
+</text>
+```
+
+### Italic/Emphasis
+
+```tsx
+<text>
+  <em>Italic text</em>
+  <i>Also italic</i>
+</text>
+```
+
+### Underline
+
+```tsx
+<text>
+  <u>Underlined text</u>
+</text>
+```
+
+### Line Break
+
+```tsx
+<text>
+  Line one
+  <br />
+  Line two
+</text>
+```
+
+### Link
+
+```tsx
+<text>
+  Visit <a href="https://example.com">our website</a>
+</text>
+```
+
+### Combined Modifiers
+
+```tsx
+<text>
+  <span fg="#00FF00">
+    <strong>Bold green</strong>
+  </span>
+  and
+  <span fg="#FF0000">
+    <em><u>italic underlined red</u></em>
+  </span>
+</text>
+```
+
+## Styled Text Template (Core)
+
+The `t` template literal for complex styling:
+
+```typescript
+import { t, bold, italic, underline, fg, bg, dim } from "@opentui/core"
+
+const styled = t`
+  ${bold("Bold")} and ${italic("italic")} text.
+  ${fg("#FF0000")("Red text")} with ${bg("#0000FF")("blue background")}.
+  ${dim("Dimmed")} and ${underline("underlined")}.
+`
+
+const text = new TextRenderable(renderer, {
+  content: styled,
+})
+```
+
+### Style Functions
+
+| Function | Description |
+|----------|-------------|
+| `bold(text)` | Bold text |
+| `italic(text)` | Italic text |
+| `underline(text)` | Underlined text |
+| `dim(text)` | Dimmed text |
+| `strikethrough(text)` | Strikethrough text |
+| `fg(color)(text)` | Set foreground color |
+| `bg(color)(text)` | Set background color |
+
+## ASCII Font Component
+
+Display large ASCII art text banners.
+
+### Basic Usage
+
+```tsx
+// React
+<ascii-font text="TITLE" font="tiny" />
+
+// Solid
+<ascii_font text="TITLE" font="tiny" />
+
+// Core
+const title = new ASCIIFontRenderable(renderer, {
+  id: "title",
+  text: "TITLE",
+  font: "tiny",
+})
+```
+
+### Available Fonts
+
+| Font | Description |
+|------|-------------|
+| `tiny` | Compact ASCII font |
+| `block` | Block-style letters |
+| `slick` | Sleek modern style |
+| `shade` | Shaded 3D effect |
+
+### Styling
+
+```tsx
+// React
+<ascii-font
+  text="HELLO"
+  font="block"
+  color="#00FF00"
+/>
+
+// Core
+import { RGBA } from "@opentui/core"
+
+const title = new ASCIIFontRenderable(renderer, {
+  text: "HELLO",
+  font: "block",
+  color: RGBA.fromHex("#00FF00"),
+})
+```
+
+### Example Output
+
+```
+Font: tiny
+╭─╮╭─╮╭─╮╭╮╭╮╭─╮╶╮╶ ╶╮
+│ ││─┘├┤ │╰╯││  │  │
+╰─╯╵  ╰─╯╵  ╵╰─╯╶╯╶╰─╯
+
+Font: block
+█▀▀█ █▀▀█ █▀▀ █▀▀▄
+█  █ █▀▀▀ █▀▀ █  █
+▀▀▀▀ ▀    ▀▀▀ ▀  ▀
+```
+
+## Colors
+
+### Color Formats
+
+```tsx
+// Hex colors
+<text fg="#FF0000">Red</text>
+<text fg="#F00">Short hex</text>
+
+// Named colors
+<text fg="red">Red</text>
+<text fg="blue">Blue</text>
+
+// Transparent
+<text bg="transparent">No background</text>
+```
+
+### RGBA Class
+
+The `RGBA` class from `@opentui/core` can be used in **all frameworks** (Core, React, Solid) for programmatic color manipulation:
+
+```typescript
+import { RGBA } from "@opentui/core"
+
+// From hex string (most common)
+const red = RGBA.fromHex("#FF0000")
+const shortHex = RGBA.fromHex("#F00")       // Short form supported
+
+// From integers (0-255 range for each channel)
+const green = RGBA.fromInts(0, 255, 0, 255)   // r, g, b, a
+const semiGreen = RGBA.fromInts(0, 255, 0, 128) // 50% transparent
+
+// From normalized floats (0.0-1.0 range)
+const blue = RGBA.fromValues(0.0, 0.0, 1.0, 1.0)  // r, g, b, a
+const overlay = RGBA.fromValues(0.1, 0.1, 0.1, 0.7) // Dark semi-transparent
+
+// Common use cases
+const backgroundColor = RGBA.fromHex("#1a1a2e")
+const textColor = RGBA.fromHex("#FFFFFF")
+const borderColor = RGBA.fromInts(122, 162, 247, 255) // Tokyo Night blue
+const shadowColor = RGBA.fromValues(0.0, 0.0, 0.0, 0.5) // 50% black
+```
+
+**When to use each method:**
+- `fromHex()` - When working with design specs or CSS colors
+- `fromInts()` - When you have 8-bit color values (0-255)
+- `fromValues()` - When doing color math or interpolation (normalized 0.0-1.0)
+
+### Using RGBA in React/Solid
+
+```tsx
+// React or Solid - RGBA works with color props
+import { RGBA } from "@opentui/core"
+
+const primaryColor = RGBA.fromHex("#7aa2f7")
+
+function MyComponent() {
+  return (
+    <box backgroundColor={primaryColor} borderColor={primaryColor}>
+      <text fg={RGBA.fromHex("#c0caf5")}>Styled with RGBA</text>
+    </box>
+  )
+}
+```
+
+Most props that accept color strings (`"#FF0000"`, `"red"`) also accept `RGBA` objects directly.
+
+## Text Wrapping
+
+Text wraps based on parent container:
+
+```tsx
+<box width={40}>
+  <text>
+    This long text will wrap when it reaches the edge of the
+    40-character wide parent container.
+  </text>
+</box>
+```
+
+## Dynamic Content
+
+### React
+
+```tsx
+function Counter() {
+  const [count, setCount] = useState(0)
+  return <text>Count: {count}</text>
+}
+```
+
+### Solid
+
+```tsx
+function Counter() {
+  const [count, setCount] = createSignal(0)
+  return <text>Count: {count()}</text>
+}
+```
+
+### Core
+
+```typescript
+const text = new TextRenderable(renderer, {
+  id: "counter",
+  content: "Count: 0",
+})
+
+// Update later
+text.setContent("Count: 1")
+```
+
+## Gotchas
+
+### Text Modifiers Outside Text
+
+```tsx
+// WRONG - modifiers only work inside <text>
+<box>
+  <strong>Won't work</strong>
+</box>
+
+// CORRECT
+<box>
+  <text>
+    <strong>This works</strong>
+  </text>
+</box>
+```
+
+### Empty Text
+
+```tsx
+// May cause layout issues
+<text></text>
+
+// Better - use space or conditional
+<text>{content || " "}</text>
+```
+
+### Color Format
+
+```tsx
+// WRONG
+<text fg="FF0000">Missing #</text>
+
+// CORRECT
+<text fg="#FF0000">With #</text>
+```
diff --git a/.agents/skills/opentui/references/core/REFERENCE.md b/.agents/skills/opentui/references/core/REFERENCE.md
new file mode 100644
index 0000000..2b86481
--- /dev/null
+++ b/.agents/skills/opentui/references/core/REFERENCE.md
@@ -0,0 +1,145 @@
+# OpenTUI Core (@opentui/core)
+
+The foundational library for building terminal user interfaces. Provides an imperative API with all primitives, giving you maximum control over rendering, state, and behavior.
+
+## Overview
+
+OpenTUI Core runs on Bun with native Zig bindings for performance-critical operations:
+- **Renderer**: Manages terminal output, input events, and the rendering loop
+- **Renderables**: Hierarchical UI building blocks with Yoga layout
+- **Constructs**: Declarative wrappers for composing Renderables
+- **FrameBuffer**: Low-level 2D rendering surface for custom graphics
+
+## When to Use Core
+
+Use the core imperative API when:
+- Building a library or framework on top of OpenTUI
+- Need maximum control over rendering and state
+- Want smallest possible bundle size (no React/Solid runtime)
+- Building performance-critical applications
+- Integrating with existing imperative codebases
+
+## When NOT to Use Core
+
+| Scenario | Use Instead |
+|----------|-------------|
+| Familiar with React patterns | `@opentui/react` |
+| Want fine-grained reactivity | `@opentui/solid` |
+| Building typical applications | React or Solid reconciler |
+| Rapid prototyping | React or Solid reconciler |
+
+## Quick Start
+
+### Using create-tui (Recommended)
+
+```bash
+bunx create-tui@latest -t core my-app
+cd my-app
+bun run src/index.ts
+```
+
+The CLI creates the `my-app` directory for you - it must **not already exist**.
+
+**Agent guidance**: Always use autonomous mode with `-t <template>` flag. Never use interactive mode (`bunx create-tui@latest my-app` without `-t`) as it requires user prompts that agents cannot respond to.
+
+### Manual Setup
+
+```bash
+mkdir my-tui && cd my-tui
+bun init
+bun install @opentui/core
+```
+
+```typescript
+import { createCliRenderer, TextRenderable, BoxRenderable } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+// Create a box container
+const container = new BoxRenderable(renderer, {
+  id: "container",
+  width: 40,
+  height: 10,
+  border: true,
+  borderStyle: "rounded",
+  padding: 1,
+})
+
+// Create text inside the box
+const greeting = new TextRenderable(renderer, {
+  id: "greeting",
+  content: "Hello, OpenTUI!",
+  fg: "#00FF00",
+})
+
+// Compose the tree
+container.add(greeting)
+renderer.root.add(container)
+```
+
+## Core Concepts
+
+### Renderer
+
+The `CliRenderer` orchestrates everything:
+- Manages the terminal viewport and alternate screen
+- Handles input events (keyboard, mouse, paste)
+- Runs the rendering loop (configurable FPS)
+- Provides the root node for the renderable tree
+
+### Renderables vs Constructs
+
+| Renderables (Imperative) | Constructs (Declarative) |
+|--------------------------|--------------------------|
+| `new TextRenderable(renderer, {...})` | `Text({...})` |
+| Requires renderer at creation | Creates VNode, instantiated later |
+| Direct mutation via methods | Chained calls recorded, replayed on instantiation |
+| Full control | Cleaner composition |
+
+### Storage Options
+
+Renderables can be composed in two ways:
+1. **Imperative**: Create instances, call `.add()` to compose
+2. **Declarative (Constructs)**: Create VNodes, pass children as arguments
+
+## Essential Commands
+
+```bash
+bun install @opentui/core     # Install
+bun run src/index.ts          # Run directly (no build needed)
+bun test                      # Run tests
+```
+
+## Runtime Requirements
+
+OpenTUI runs on Bun and uses Zig for native builds.
+
+```bash
+# Package management
+bun install @opentui/core
+
+# Running
+bun run src/index.ts
+bun test
+
+# Building (only needed for native code changes)
+bun run build
+```
+
+**Zig** is required for building native components.
+
+## In This Reference
+
+- [Configuration](./configuration.md) - Renderer options, environment variables
+- [API](./api.md) - Renderer, Renderables, types, utilities
+- [Patterns](./patterns.md) - Composition, events, state management
+- [Gotchas](./gotchas.md) - Common issues, debugging, limitations
+
+## See Also
+
+- [React](../react/REFERENCE.md) - React reconciler for declarative TUI
+- [Solid](../solid/REFERENCE.md) - Solid reconciler for declarative TUI
+- [Layout](../layout/REFERENCE.md) - Yoga/Flexbox layout system
+- [Components](../components/REFERENCE.md) - Component reference by category
+- [Keyboard](../keyboard/REFERENCE.md) - Input handling and shortcuts
+- [Testing](../testing/REFERENCE.md) - Test renderer and snapshots
diff --git a/.agents/skills/opentui/references/core/api.md b/.agents/skills/opentui/references/core/api.md
new file mode 100644
index 0000000..cfd8a55
--- /dev/null
+++ b/.agents/skills/opentui/references/core/api.md
@@ -0,0 +1,543 @@
+# Core API Reference
+
+## Renderer
+
+### createCliRenderer(config?)
+
+Creates and initializes the CLI renderer.
+
+```typescript
+import { createCliRenderer, type CliRendererConfig } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  targetFPS: 60,              // Target frames per second
+  exitOnCtrlC: true,          // Exit process on Ctrl+C
+  consoleOptions: {           // Debug console overlay
+    position: ConsolePosition.BOTTOM,
+    sizePercent: 30,
+    startInDebugMode: false,
+  },
+  onDestroy: () => {},        // Cleanup callback
+})
+```
+
+### CliRenderer Instance
+
+```typescript
+renderer.root              // Root renderable node
+renderer.width             // Terminal width in columns
+renderer.height            // Terminal height in rows
+renderer.keyInput          // Keyboard event emitter
+renderer.console           // Console overlay controller
+
+renderer.start()           // Start render loop
+renderer.stop()            // Stop render loop
+renderer.destroy()         // Cleanup and exit alternate screen
+renderer.requestRender()   // Request a re-render
+
+renderer.setCursorStyle(options)  // Set cursor style
+renderer.setCursorColor(color)    // Set cursor color
+renderer.setMousePointer(style)   // Set mouse pointer shape
+```
+
+### Cursor & Mouse Pointer
+
+```typescript
+import { type CursorStyleOptions, type MousePointerStyle } from "@opentui/core"
+
+// Set cursor style (options object)
+renderer.setCursorStyle({
+  style: "block",           // "block" | "line" | "underline" | "default"
+  blinking: true,           // Cursor blink
+  color: RGBA.fromHex("#FF0000"),  // Cursor color
+  cursor: "pointer",        // Mouse pointer shape
+})
+
+// Set mouse pointer shape (OSC 22)
+renderer.setMousePointer("pointer")
+// Available: "default" | "pointer" | "text" | "crosshair" | "move" | "not-allowed"
+```
+
+### Renderer Events
+
+```typescript
+renderer.on("resize", (width, height) => {})     // Terminal resized
+renderer.on("focus", () => {})                    // Terminal window gained focus
+renderer.on("blur", () => {})                     // Terminal window lost focus
+renderer.on("theme_mode", (mode) => {})           // "dark" | "light"
+renderer.on("capabilities", (caps) => {})         // Terminal capabilities detected
+renderer.on("selection", (selection) => {})       // Text selection finished (mouse-up)
+renderer.on("destroy", () => {})                  // Renderer destroyed
+renderer.on("memory:snapshot", (snapshot) => {})  // Memory snapshot
+renderer.on("debugOverlay:toggle", () => {})      // Debug overlay toggled
+```
+
+### Console Overlay
+
+```typescript
+renderer.console.show()    // Show console overlay
+renderer.console.hide()    // Hide console overlay
+renderer.console.toggle()  // Toggle visibility/focus
+renderer.console.clear()   // Clear console contents
+```
+
+## Renderables
+
+All renderables extend the base `Renderable` class and share common properties.
+
+### Common Properties
+
+```typescript
+interface CommonProps {
+  id?: string                    // Unique identifier
+
+  // Positioning
+  position?: "relative" | "absolute"
+  left?: number | string
+  top?: number | string
+  right?: number | string
+  bottom?: number | string
+
+  // Dimensions
+  width?: number | string | "auto"
+  height?: number | string | "auto"
+  minWidth?: number
+  minHeight?: number
+  maxWidth?: number
+  maxHeight?: number
+
+  // Flexbox
+  flexDirection?: "row" | "column" | "row-reverse" | "column-reverse"
+  flexGrow?: number
+  flexShrink?: number
+  flexBasis?: number | string
+  flexWrap?: "nowrap" | "wrap" | "wrap-reverse"
+  justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly"
+  alignItems?: "flex-start" | "flex-end" | "center" | "stretch" | "baseline"
+  alignSelf?: "auto" | "flex-start" | "flex-end" | "center" | "stretch" | "baseline"
+  alignContent?: "flex-start" | "flex-end" | "center" | "stretch" | "space-between" | "space-around"
+
+  // Spacing
+  padding?: number
+  paddingTop?: number
+  paddingRight?: number
+  paddingBottom?: number
+  paddingLeft?: number
+  margin?: number
+  marginTop?: number
+  marginRight?: number
+  marginBottom?: number
+  marginLeft?: number
+  gap?: number
+
+  // Display
+  display?: "flex" | "none"
+  overflow?: "visible" | "hidden" | "scroll"
+  zIndex?: number
+}
+```
+
+### Renderable Methods
+
+```typescript
+renderable.add(child)              // Add child renderable
+renderable.remove(child)           // Remove child renderable
+renderable.getRenderable(id)       // Find child by ID
+renderable.focus()                 // Focus this renderable
+renderable.blur()                  // Remove focus
+renderable.destroy()               // Destroy and cleanup
+
+renderable.on(event, handler)      // Add event listener
+renderable.off(event, handler)     // Remove event listener
+renderable.emit(event, ...args)    // Emit event
+```
+
+### TextRenderable
+
+Display styled text content.
+
+```typescript
+import { TextRenderable, TextAttributes, t, bold, fg, underline } from "@opentui/core"
+
+const text = new TextRenderable(renderer, {
+  id: "text",
+  content: "Hello World",
+  fg: "#FFFFFF",                   // Foreground color
+  bg: "#000000",                   // Background color
+  attributes: TextAttributes.BOLD | TextAttributes.UNDERLINE,
+  selectable: true,                // Allow text selection
+})
+
+// Styled text with template literals
+const styled = new TextRenderable(renderer, {
+  content: t`${bold("Bold")} and ${fg("#FF0000")(underline("red underlined"))}`,
+})
+```
+
+**TextAttributes flags:**
+- `TextAttributes.BOLD`
+- `TextAttributes.DIM`
+- `TextAttributes.ITALIC`
+- `TextAttributes.UNDERLINE`
+- `TextAttributes.BLINK`
+- `TextAttributes.INVERSE`
+- `TextAttributes.HIDDEN`
+- `TextAttributes.STRIKETHROUGH`
+
+### BoxRenderable
+
+Container with borders and layout.
+
+```typescript
+import { BoxRenderable } from "@opentui/core"
+
+const box = new BoxRenderable(renderer, {
+  id: "box",
+  width: 40,
+  height: 10,
+  backgroundColor: "#1a1a2e",
+  border: true,
+  borderStyle: "single" | "double" | "rounded" | "bold" | "none",
+  borderColor: "#FFFFFF",
+  title: "Panel Title",
+  titleAlignment: "left" | "center" | "right",
+  onMouseDown: (event) => {},
+  onMouseUp: (event) => {},
+  onMouseMove: (event) => {},
+})
+```
+
+### InputRenderable
+
+Single-line text input.
+
+```typescript
+import { InputRenderable, InputRenderableEvents } from "@opentui/core"
+
+const input = new InputRenderable(renderer, {
+  id: "input",
+  width: 30,
+  placeholder: "Enter text...",
+  value: "",                       // Initial value
+  backgroundColor: "#1a1a1a",
+  textColor: "#FFFFFF",
+  cursorColor: "#00FF00",
+  focusedBackgroundColor: "#2a2a2a",
+})
+
+input.on(InputRenderableEvents.CHANGE, (value: string) => {
+  console.log("Value:", value)
+})
+
+input.focus()  // Must be focused to receive input
+```
+
+### SelectRenderable
+
+List selection component.
+
+```typescript
+import { SelectRenderable, SelectRenderableEvents } from "@opentui/core"
+
+const select = new SelectRenderable(renderer, {
+  id: "select",
+  width: 30,
+  height: 10,
+  options: [
+    { name: "Option 1", description: "First option", value: "1" },
+    { name: "Option 2", description: "Second option", value: "2" },
+  ],
+  selectedIndex: 0,
+})
+
+// Called when Enter is pressed - selection confirmed
+select.on(SelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  console.log("Selected:", option.name)
+  performAction(option)
+})
+
+// Called when navigating with arrow keys
+select.on(SelectRenderableEvents.SELECTION_CHANGED, (index, option) => {
+  console.log("Browsing:", option.name)
+  showPreview(option)
+})
+
+select.focus()  // Navigate with up/down/j/k, select with enter
+```
+
+**Event distinction:**
+- `ITEM_SELECTED` - Enter key pressed, user confirms selection
+- `SELECTION_CHANGED` - Arrow keys, user navigating/browsing options
+
+### TabSelectRenderable
+
+Horizontal tab selection.
+
+```typescript
+import { TabSelectRenderable, TabSelectRenderableEvents } from "@opentui/core"
+
+const tabs = new TabSelectRenderable(renderer, {
+  id: "tabs",
+  width: 60,
+  options: [
+    { name: "Home", description: "Dashboard" },
+    { name: "Settings", description: "Configuration" },
+  ],
+  tabWidth: 20,
+})
+
+// Called when Enter is pressed - tab selected
+tabs.on(TabSelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  console.log("Tab selected:", option.name)
+  switchToTab(index)
+})
+
+// Called when navigating with arrow keys
+tabs.on(TabSelectRenderableEvents.SELECTION_CHANGED, (index, option) => {
+  console.log("Browsing tab:", option.name)
+})
+
+tabs.focus()  // Navigate with left/right/[/], select with enter
+```
+
+**Event distinction** (same as SelectRenderable):
+- `ITEM_SELECTED` - Enter key pressed, user confirms tab
+- `SELECTION_CHANGED` - Arrow keys, user navigating tabs
+
+### ScrollBoxRenderable
+
+Scrollable container.
+
+```typescript
+import { ScrollBoxRenderable } from "@opentui/core"
+
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "scrollbox",
+  width: 40,
+  height: 20,
+  showScrollbar: true,
+  scrollbarOptions: {
+    showArrows: true,
+    trackOptions: {
+      foregroundColor: "#7aa2f7",
+      backgroundColor: "#414868",
+    },
+  },
+})
+
+// Add content that exceeds viewport
+for (let i = 0; i < 100; i++) {
+  scrollbox.add(new TextRenderable(renderer, {
+    id: `line-${i}`,
+    content: `Line ${i}`,
+  }))
+}
+
+scrollbox.focus()  // Scroll with arrow keys
+```
+
+### ASCIIFontRenderable
+
+ASCII art text.
+
+```typescript
+import { ASCIIFontRenderable, RGBA } from "@opentui/core"
+
+const title = new ASCIIFontRenderable(renderer, {
+  id: "title",
+  text: "OPENTUI",
+  font: "tiny" | "block" | "slick" | "shade",
+  color: RGBA.fromHex("#FFFFFF"),
+})
+```
+
+### FrameBufferRenderable
+
+Low-level 2D rendering surface.
+
+```typescript
+import { FrameBufferRenderable, RGBA } from "@opentui/core"
+
+const canvas = new FrameBufferRenderable(renderer, {
+  id: "canvas",
+  width: 50,
+  height: 20,
+})
+
+// Direct pixel manipulation
+canvas.frameBuffer.fillRect(10, 5, 20, 8, RGBA.fromHex("#FF0000"))
+canvas.frameBuffer.drawText("Custom", 12, 7, RGBA.fromHex("#FFFFFF"))
+canvas.frameBuffer.setCell(x, y, char, fg, bg)
+```
+
+## Constructs (VNode API)
+
+Declarative wrappers that create VNodes instead of direct instances.
+
+```typescript
+import { Text, Box, Input, Select, instantiate, delegate } from "@opentui/core"
+
+// Create VNode tree
+const ui = Box(
+  { border: true, padding: 1 },
+  Text({ content: "Hello" }),
+  Input({ placeholder: "Type here..." }),
+)
+
+// Instantiate onto renderer
+renderer.root.add(ui)
+
+// Delegate focus to nested element
+const form = delegate(
+  { focus: "email-input" },
+  Box(
+    {},
+    Text({ content: "Email:" }),
+    Input({ id: "email-input", placeholder: "you@example.com" }),
+  ),
+)
+form.focus()  // Focuses the input, not the box
+```
+
+## Colors (RGBA)
+
+The `RGBA` class is exported from `@opentui/core` but works across **all frameworks** (Core, React, Solid). Use it for programmatic color manipulation.
+
+### Creating Colors
+
+```typescript
+import { RGBA, parseColor } from "@opentui/core"
+
+// From hex string (most common)
+RGBA.fromHex("#FF0000")           // Full hex
+RGBA.fromHex("#F00")              // Short hex
+
+// From integers (0-255 range)
+RGBA.fromInts(255, 0, 0, 255)     // r, g, b, a - fully opaque red
+RGBA.fromInts(255, 0, 0, 128)     // 50% transparent red
+RGBA.fromInts(0, 0, 0, 0)         // Fully transparent
+
+// From normalized floats (0.0-1.0 range)
+RGBA.fromValues(1.0, 0.0, 0.0, 1.0)   // Fully opaque red
+RGBA.fromValues(0.1, 0.1, 0.1, 0.7)   // Dark gray, 70% opaque
+RGBA.fromValues(0.0, 0.5, 1.0, 1.0)   // Light blue
+```
+
+### Common Color Patterns
+
+```typescript
+// Theme colors
+const primary = RGBA.fromHex("#7aa2f7")      // Tokyo Night blue
+const background = RGBA.fromHex("#1a1a2e")
+const foreground = RGBA.fromHex("#c0caf5")
+const error = RGBA.fromHex("#f7768e")
+
+// Overlays and shadows
+const modalOverlay = RGBA.fromValues(0.0, 0.0, 0.0, 0.5)  // 50% black
+const shadow = RGBA.fromInts(0, 0, 0, 77)                  // 30% black
+
+// Borders
+const activeBorder = RGBA.fromHex("#7aa2f7")
+const inactiveBorder = RGBA.fromInts(65, 72, 104, 255)
+```
+
+### parseColor Utility
+
+```typescript
+// Accepts multiple formats
+parseColor("#FF0000")             // Hex string
+parseColor("red")                 // CSS color name
+parseColor("transparent")         // Special values
+parseColor(RGBA.fromHex("#F00"))  // Pass-through RGBA objects
+```
+
+### When to Use Each Method
+
+| Method | Use When |
+|--------|----------|
+| `fromHex()` | Working with design specs, CSS colors, config files |
+| `fromInts()` | You have 8-bit values (0-255), common in graphics |
+| `fromValues()` | Doing color interpolation, animations, math |
+| `parseColor()` | Accepting user input or config that could be any format |
+
+### Using RGBA in React/Solid
+
+```tsx
+// Import from @opentui/core, use in any framework
+import { RGBA } from "@opentui/core"
+
+// React or Solid component
+function ThemedBox() {
+  const bg = RGBA.fromHex("#1a1a2e")
+  const border = RGBA.fromInts(122, 162, 247, 255)
+
+  return (
+    <box backgroundColor={bg} borderColor={border} border>
+      <text fg={RGBA.fromHex("#c0caf5")}>Works everywhere!</text>
+    </box>
+  )
+}
+```
+
+Color props in React/Solid accept both string formats (`"#FF0000"`, `"red"`) and `RGBA` objects.
+
+## Keyboard Input
+
+```typescript
+import { type KeyEvent } from "@opentui/core"
+
+renderer.keyInput.on("keypress", (key: KeyEvent) => {
+  console.log(key.name)           // "a", "escape", "f1", etc.
+  console.log(key.sequence)       // Raw escape sequence
+  console.log(key.ctrl)           // Ctrl held
+  console.log(key.shift)          // Shift held
+  console.log(key.meta)           // Alt held
+  console.log(key.option)         // Option held (macOS)
+  console.log(key.eventType)      // "press" | "release" | "repeat"
+})
+
+renderer.keyInput.on("paste", (event: PasteEvent) => {
+  const text = decodePasteBytes(event.bytes)
+  console.log("Pasted:", text)
+})
+```
+
+## Animation Timeline
+
+```typescript
+import { Timeline, engine } from "@opentui/core"
+
+const timeline = new Timeline({
+  duration: 2000,
+  loop: false,
+  autoplay: true,
+})
+
+timeline.add(
+  { width: 0 },
+  {
+    width: 50,
+    duration: 1000,
+    ease: "easeOutQuad",
+    onUpdate: (anim) => {
+      box.setWidth(anim.targets[0].width)
+    },
+  },
+)
+
+engine.attach(renderer)
+engine.addTimeline(timeline)
+```
+
+## Type Exports
+
+```typescript
+import type {
+  CliRenderer,
+  CliRendererConfig,
+  RenderContext,
+  KeyEvent,
+  Renderable,
+  // ... and more
+} from "@opentui/core"
+```
diff --git a/.agents/skills/opentui/references/core/configuration.md b/.agents/skills/opentui/references/core/configuration.md
new file mode 100644
index 0000000..cc17ad1
--- /dev/null
+++ b/.agents/skills/opentui/references/core/configuration.md
@@ -0,0 +1,168 @@
+# Core Configuration
+
+## Renderer Configuration
+
+### createCliRenderer Options
+
+```typescript
+import { createCliRenderer, ConsolePosition } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  // Rendering
+  targetFPS: 60,                    // Target frames per second (default: 60)
+
+  // Behavior
+  exitOnCtrlC: true,                // Exit on Ctrl+C (default: true)
+
+  // Console overlay
+  consoleOptions: {
+    position: ConsolePosition.BOTTOM,  // BOTTOM | TOP | LEFT | RIGHT
+    sizePercent: 30,                   // Percentage of screen
+    colorInfo: "#00FFFF",
+    colorWarn: "#FFFF00",
+    colorError: "#FF0000",
+    colorDebug: "#888888",
+    startInDebugMode: false,
+  },
+
+  // Lifecycle
+  onDestroy: () => {
+    // Cleanup callback
+  },
+})
+```
+
+## Environment Variables
+
+OpenTUI respects several environment variables for configuration and debugging.
+
+### Debug & Development
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `OTUI_DEBUG` | boolean | false | Enable debug mode, capture raw input |
+| `OTUI_DEBUG_FFI` | boolean | false | Debug logging for FFI bindings |
+| `OTUI_TRACE_FFI` | boolean | false | Tracing for FFI bindings |
+| `OTUI_SHOW_STATS` | boolean | false | Show debug overlay at startup |
+| `OTUI_DUMP_CAPTURES` | boolean | false | Dump captured output on exit |
+
+### Console
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `OTUI_USE_CONSOLE` | boolean | true | Enable console capture |
+| `SHOW_CONSOLE` | boolean | false | Show console at startup |
+
+### Rendering
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `OTUI_NO_NATIVE_RENDER` | boolean | false | Disable ANSI output (for debugging) |
+| `OTUI_USE_ALTERNATE_SCREEN` | boolean | true | Use alternate screen buffer |
+| `OTUI_OVERRIDE_STDOUT` | boolean | true | Override stdout stream |
+
+### Terminal Capabilities
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `OPENTUI_NO_GRAPHICS` | boolean | false | Disable Kitty graphics protocol |
+| `OPENTUI_FORCE_UNICODE` | boolean | false | Force Mode 2026 Unicode support |
+| `OPENTUI_FORCE_WCWIDTH` | boolean | false | Use wcwidth for character width |
+| `OPENTUI_FORCE_NOZWJ` | boolean | false | Disable ZWJ emoji joining |
+| `OPENTUI_FORCE_EXPLICIT_WIDTH` | string | - | Force explicit width ("true"/"false") |
+
+### Tree-sitter (Syntax Highlighting)
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `OTUI_TS_STYLE_WARN` | boolean | false | Warn on missing syntax styles |
+| `OTUI_TREE_SITTER_WORKER_PATH` | string | "" | Custom tree-sitter worker path |
+
+### XDG Paths
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `XDG_CONFIG_HOME` | string | "" | User config directory |
+| `XDG_DATA_HOME` | string | "" | User data directory |
+
+## Usage Examples
+
+### Development Mode
+
+```bash
+# Show debug overlay and console
+OTUI_SHOW_STATS=true SHOW_CONSOLE=true bun run src/index.ts
+
+# Debug FFI issues
+OTUI_DEBUG_FFI=true OTUI_TRACE_FFI=true bun run src/index.ts
+
+# Disable native rendering for testing
+OTUI_NO_NATIVE_RENDER=true bun run src/index.ts
+```
+
+### Terminal Compatibility
+
+```bash
+# Force wcwidth for problematic terminals
+OPENTUI_FORCE_WCWIDTH=true bun run src/index.ts
+
+# Disable graphics for SSH sessions
+OPENTUI_NO_GRAPHICS=true bun run src/index.ts
+```
+
+## Project Setup
+
+### package.json
+
+```json
+{
+  "name": "my-tui-app",
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun --watch run src/index.ts",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@opentui/core": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "latest"
+  }
+}
+```
+
+### tsconfig.json
+
+```json
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"]
+}
+```
+
+> **Note**: OpenTUI uses `NodeNext` module resolution. All internal imports use `.js` extensions. If you use `bundler` resolution, imports still work but `NodeNext` is recommended for compatibility.
+
+## Building Native Code
+
+Native code changes require rebuilding:
+
+```bash
+# From repo root (if developing OpenTUI itself)
+bun run build
+
+# Zig is required for native compilation
+# Install: https://ziglang.org/learn/getting-started/
+```
+
+**Note**: TypeScript changes do NOT require building. Bun runs TypeScript directly.
diff --git a/.agents/skills/opentui/references/core/gotchas.md b/.agents/skills/opentui/references/core/gotchas.md
new file mode 100644
index 0000000..9cdc022
--- /dev/null
+++ b/.agents/skills/opentui/references/core/gotchas.md
@@ -0,0 +1,393 @@
+# Core Gotchas
+
+## Runtime Environment
+
+### Use Bun, Not Node.js
+
+OpenTUI is built for Bun. Always use Bun commands:
+
+```bash
+# CORRECT
+bun install @opentui/core
+bun run src/index.ts
+bun test
+
+# WRONG
+npm install @opentui/core
+node src/index.ts
+npx jest
+```
+
+### Bun APIs to Use
+
+Prefer Bun's built-in APIs for your application code:
+
+```typescript
+// CORRECT - Bun APIs
+Bun.serve({ ... })                // Instead of express
+Bun.$`ls -la`                     // Instead of execa
+import { Database } from "bun:sqlite"  // Instead of better-sqlite3
+
+// WRONG - Node.js patterns
+import express from "express"
+```
+
+> **Note**: OpenTUI itself uses `node:fs` internally for file I/O (for broader compatibility), but your application code should still prefer Bun APIs where available.
+
+### Avoid process.exit()
+
+**Never use `process.exit()` directly** - it prevents proper terminal cleanup and can leave the terminal in a broken state (alternate screen mode, raw input mode, etc.).
+
+```typescript
+// WRONG - Terminal may be left in broken state
+if (error) {
+  console.error("Fatal error")
+  process.exit(1)
+}
+
+// CORRECT - Use renderer.destroy() for cleanup
+if (error) {
+  console.error("Fatal error")
+  await renderer.destroy()
+  process.exit(1)  // Only after destroy
+}
+
+// BETTER - Let destroy handle exit
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true,  // Handles Ctrl+C properly
+})
+
+// For programmatic exit
+renderer.destroy()  // Cleans up and exits
+```
+
+`renderer.destroy()` restores the terminal to its original state before exiting.
+
+### Environment Variables
+
+Bun auto-loads `.env` files. Don't use dotenv:
+
+```typescript
+// CORRECT
+const apiKey = process.env.API_KEY
+
+// WRONG
+import dotenv from "dotenv"
+dotenv.config()
+```
+
+## Debugging TUIs
+
+### Cannot See console.log Output
+
+OpenTUI captures console output for the debug overlay. You can't see logs in the terminal while the TUI is running.
+
+**Solutions:**
+
+1. **Use the console overlay:**
+   ```typescript
+   const renderer = await createCliRenderer()
+   renderer.console.show()
+   console.log("This appears in the overlay")
+   ```
+
+2. **Toggle with keyboard:**
+   ```typescript
+   renderer.keyInput.on("keypress", (key) => {
+     if (key.name === "f12") {
+       renderer.console.toggle()
+     }
+   })
+   ```
+
+3. **Write to a file:**
+   ```typescript
+   import { appendFileSync } from "node:fs"
+   function debugLog(msg: string) {
+     appendFileSync("debug.log", `${new Date().toISOString()} ${msg}\n`)
+   }
+   ```
+
+4. **Disable console capture:**
+   ```bash
+   OTUI_USE_CONSOLE=false bun run src/index.ts
+   ```
+
+### Reproduce Issues in Tests
+
+Don't guess at bugs. Create a reproducible test:
+
+```typescript
+import { test, expect } from "bun:test"
+import { createTestRenderer } from "@opentui/core/testing"
+
+test("reproduces the issue", async () => {
+  const { renderer, snapshot } = await createTestRenderer({
+    width: 40,
+    height: 10,
+  })
+
+  // Setup that reproduces the bug
+  const box = new BoxRenderable(renderer, { ... })
+  renderer.root.add(box)
+
+  // Verify with snapshot
+  expect(snapshot()).toMatchSnapshot()
+})
+```
+
+## Focus Management
+
+### Components Must Be Focused
+
+Input components only receive keyboard input when focused:
+
+```typescript
+const input = new InputRenderable(renderer, {
+  id: "input",
+  placeholder: "Type here...",
+})
+
+renderer.root.add(input)
+
+// WRONG - input won't receive keystrokes
+// (no focus call)
+
+// CORRECT
+input.focus()
+```
+
+### Focus in Nested Components
+
+When a component is inside a container, focus the component directly:
+
+```typescript
+const container = new BoxRenderable(renderer, { id: "container" })
+const input = new InputRenderable(renderer, { id: "input" })
+container.add(input)
+renderer.root.add(container)
+
+// WRONG
+container.focus()
+
+// CORRECT
+input.focus()
+
+// Or use getRenderable
+container.getRenderable("input")?.focus()
+
+// Or use delegate (constructs)
+const form = delegate(
+  { focus: "input" },
+  Box({}, Input({ id: "input" })),
+)
+form.focus()  // Routes to the input
+```
+
+## Build Requirements
+
+### Zig is Required
+
+Native code compilation requires Zig:
+
+```bash
+# Install Zig first
+# macOS
+brew install zig
+
+# Linux
+# Download from https://ziglang.org/download/
+
+# Then build
+bun run build
+```
+
+### When to Build
+
+- **TypeScript changes**: NO build needed (Bun runs TS directly)
+- **Native code changes**: Build required
+
+```bash
+# Only needed when changing native (Zig) code
+cd packages/core
+bun run build
+```
+
+## Common Errors
+
+### "Cannot read properties of undefined"
+
+Usually means a renderable wasn't added to the tree:
+
+```typescript
+// WRONG - not added to tree
+const text = new TextRenderable(renderer, { content: "Hello" })
+// text.someMethod() // May fail
+
+// CORRECT
+const text = new TextRenderable(renderer, { content: "Hello" })
+renderer.root.add(text)
+text.someMethod()
+```
+
+### Layout Not Updating
+
+Yoga layout is calculated lazily. Force a recalculation:
+
+```typescript
+// After changing layout properties
+box.setWidth(newWidth)
+renderer.requestRender()
+```
+
+### Text Overflow/Clipping
+
+Text doesn't wrap by default. Set explicit width:
+
+```typescript
+// May overflow
+const text = new TextRenderable(renderer, {
+  content: "Very long text that might overflow the terminal...",
+})
+
+// Contained within width
+const text = new TextRenderable(renderer, {
+  content: "Very long text that might overflow the terminal...",
+  width: 40,  // Will clip or wrap based on parent
+})
+```
+
+### Colors Not Showing
+
+Check terminal capability and color format:
+
+```typescript
+// CORRECT formats
+fg: "#FF0000"           // Hex
+fg: "red"               // CSS color name
+fg: RGBA.fromHex("#FF0000")
+
+// WRONG
+fg: "FF0000"            // Missing #
+fg: 0xFF0000            // Number (not supported)
+```
+
+## Performance
+
+### Avoid Frequent Re-renders
+
+Batch updates when possible:
+
+```typescript
+// WRONG - multiple render calls
+item1.setContent("...")
+item2.setContent("...")
+item3.setContent("...")
+
+// BETTER - single render after all updates
+// (OpenTUI batches automatically, but be mindful)
+items.forEach((item, i) => {
+  item.setContent(data[i])
+})
+```
+
+### Minimize Tree Depth
+
+Deep nesting impacts layout calculation:
+
+```typescript
+// Avoid unnecessary wrappers
+// WRONG
+Box({}, Box({}, Box({}, Text({ content: "Hello" }))))
+
+// CORRECT
+Box({}, Text({ content: "Hello" }))
+```
+
+### Use display: none
+
+Hide elements instead of removing/re-adding:
+
+```typescript
+// For toggling visibility
+element.setDisplay("none")   // Hidden
+element.setDisplay("flex")   // Visible
+
+// Instead of
+parent.remove(element)
+parent.add(element)
+```
+
+## Testing
+
+### Test Runner
+
+Use Bun's test runner:
+
+```typescript
+import { test, expect, beforeEach, afterEach } from "bun:test"
+
+test("my test", () => {
+  expect(1 + 1).toBe(2)
+})
+```
+
+### Test from Package Directories
+
+Run tests from the specific package directory:
+
+```bash
+# CORRECT
+cd packages/core
+bun test
+
+# For native tests
+cd packages/core
+bun run test:native
+```
+
+### Filter Tests
+
+```bash
+# Bun test filter
+bun test --filter "component name"
+
+# Native test filter
+bun run test:native -Dtest-filter="test name"
+```
+
+## Keyboard Handling
+
+### Key Names
+
+Common key names for `KeyEvent.name`:
+
+```typescript
+// Letters/numbers
+"a", "b", ..., "z"
+"1", "2", ..., "0"
+
+// Special keys
+"escape", "enter", "return", "tab", "backspace", "delete"
+"up", "down", "left", "right"
+"home", "end", "pageup", "pagedown"
+"f1", "f2", ..., "f12"
+"space"
+
+// Modifiers (check boolean properties)
+key.ctrl   // Ctrl held
+key.shift  // Shift held
+key.meta   // Alt held
+key.option // Option held (macOS)
+```
+
+### Key Event Types
+
+```typescript
+renderer.keyInput.on("keypress", (key) => {
+  // eventType: "press" | "release" | "repeat"
+  if (key.eventType === "repeat") {
+    // Key being held down
+  }
+})
+```
diff --git a/.agents/skills/opentui/references/core/patterns.md b/.agents/skills/opentui/references/core/patterns.md
new file mode 100644
index 0000000..5186a9d
--- /dev/null
+++ b/.agents/skills/opentui/references/core/patterns.md
@@ -0,0 +1,449 @@
+# Core Patterns
+
+## Composition Patterns
+
+### Imperative Composition
+
+Create renderables and compose with `.add()`:
+
+```typescript
+import { createCliRenderer, BoxRenderable, TextRenderable } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+// Create parent
+const container = new BoxRenderable(renderer, {
+  id: "container",
+  flexDirection: "column",
+  padding: 1,
+})
+
+// Create children
+const header = new TextRenderable(renderer, {
+  id: "header",
+  content: "Header",
+  fg: "#00FF00",
+})
+
+const body = new TextRenderable(renderer, {
+  id: "body",
+  content: "Body content",
+})
+
+// Compose tree
+container.add(header)
+container.add(body)
+renderer.root.add(container)
+```
+
+### Declarative Composition (Constructs)
+
+Use VNode functions for cleaner composition:
+
+```typescript
+import { createCliRenderer, Box, Text, Input, delegate } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+// Compose as function calls
+const ui = Box(
+  { flexDirection: "column", padding: 1 },
+  Text({ content: "Header", fg: "#00FF00" }),
+  Box(
+    { flexDirection: "row", gap: 2 },
+    Text({ content: "Name:" }),
+    Input({ id: "name", placeholder: "Enter name..." }),
+  ),
+)
+
+renderer.root.add(ui)
+```
+
+### Reusable Components
+
+Create factory functions for reusable UI pieces:
+
+```typescript
+// Imperative factory
+function createLabeledInput(
+  renderer: RenderContext,
+  props: { id: string; label: string; placeholder: string }
+) {
+  const container = new BoxRenderable(renderer, {
+    id: `${props.id}-container`,
+    flexDirection: "row",
+    gap: 1,
+  })
+
+  container.add(new TextRenderable(renderer, {
+    id: `${props.id}-label`,
+    content: props.label,
+  }))
+
+  container.add(new InputRenderable(renderer, {
+    id: `${props.id}-input`,
+    placeholder: props.placeholder,
+    width: 20,
+  }))
+
+  return container
+}
+
+// Declarative factory
+function LabeledInput(props: { id: string; label: string; placeholder: string }) {
+  return delegate(
+    { focus: `${props.id}-input` },
+    Box(
+      { flexDirection: "row", gap: 1 },
+      Text({ content: props.label }),
+      Input({
+        id: `${props.id}-input`,
+        placeholder: props.placeholder,
+        width: 20,
+      }),
+    ),
+  )
+}
+```
+
+### Focus Delegation
+
+Route focus calls to nested elements:
+
+```typescript
+import { delegate, Box, Input, Text } from "@opentui/core"
+
+const form = delegate(
+  {
+    focus: "email-input",     // Route .focus() to this child
+    blur: "email-input",      // Route .blur() to this child
+  },
+  Box(
+    { border: true, padding: 1 },
+    Text({ content: "Email:" }),
+    Input({ id: "email-input", placeholder: "you@example.com" }),
+  ),
+)
+
+// This focuses the input inside, not the box
+form.focus()
+```
+
+## Event Handling
+
+### Keyboard Events
+
+```typescript
+const renderer = await createCliRenderer()
+
+// Global keyboard handler
+renderer.keyInput.on("keypress", (key) => {
+  if (key.name === "escape") {
+    renderer.destroy()
+    process.exit(0)
+  }
+
+  if (key.ctrl && key.name === "c") {
+    // Ctrl+C handling (if exitOnCtrlC is false)
+  }
+
+  if (key.name === "tab") {
+    // Tab navigation
+    focusNext()
+  }
+})
+
+// Paste events
+renderer.keyInput.on("paste", (event) => {
+  const text = decodePasteBytes(event.bytes)
+  currentInput?.setValue(currentInput.value + text)
+})
+```
+
+### Component Events
+
+```typescript
+import { InputRenderable, InputRenderableEvents } from "@opentui/core"
+
+const input = new InputRenderable(renderer, {
+  id: "search",
+  placeholder: "Search...",
+})
+
+input.on(InputRenderableEvents.CHANGE, (value) => {
+  performSearch(value)
+})
+
+// Select events
+const select = new SelectRenderable(renderer, {
+  id: "menu",
+  options: [...],
+})
+
+select.on(SelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  handleSelection(option)
+})
+
+select.on(SelectRenderableEvents.SELECTION_CHANGED, (index, option) => {
+  showPreview(option)
+})
+```
+
+### Mouse Events
+
+```typescript
+const button = new BoxRenderable(renderer, {
+  id: "button",
+  border: true,
+  onMouseDown: (event) => {
+    button.setBackgroundColor("#444444")
+  },
+  onMouseUp: (event) => {
+    button.setBackgroundColor("#222222")
+    handleClick()
+  },
+  onMouseMove: (event) => {
+    // Hover effect
+  },
+})
+```
+
+## State Management
+
+### Local State
+
+Manage state in closures or objects:
+
+```typescript
+// Closure-based state
+function createCounter(renderer: RenderContext) {
+  let count = 0
+
+  const display = new TextRenderable(renderer, {
+    id: "count",
+    content: `Count: ${count}`,
+  })
+
+  const increment = () => {
+    count++
+    display.setContent(`Count: ${count}`)
+  }
+
+  return { display, increment }
+}
+
+// Class-based state
+class CounterWidget {
+  private count = 0
+  private display: TextRenderable
+
+  constructor(renderer: RenderContext) {
+    this.display = new TextRenderable(renderer, {
+      id: "count",
+      content: this.formatCount(),
+    })
+  }
+
+  private formatCount() {
+    return `Count: ${this.count}`
+  }
+
+  increment() {
+    this.count++
+    this.display.setContent(this.formatCount())
+  }
+
+  getRenderable() {
+    return this.display
+  }
+}
+```
+
+### Focus Management
+
+Track and manage focus across components:
+
+```typescript
+class FocusManager {
+  private focusables: Renderable[] = []
+  private currentIndex = 0
+
+  register(renderable: Renderable) {
+    this.focusables.push(renderable)
+  }
+
+  focusNext() {
+    this.focusables[this.currentIndex]?.blur()
+    this.currentIndex = (this.currentIndex + 1) % this.focusables.length
+    this.focusables[this.currentIndex]?.focus()
+  }
+
+  focusPrevious() {
+    this.focusables[this.currentIndex]?.blur()
+    this.currentIndex = (this.currentIndex - 1 + this.focusables.length) % this.focusables.length
+    this.focusables[this.currentIndex]?.focus()
+  }
+}
+
+// Usage
+const focusManager = new FocusManager()
+focusManager.register(input1)
+focusManager.register(input2)
+focusManager.register(select1)
+
+renderer.keyInput.on("keypress", (key) => {
+  if (key.name === "tab") {
+    key.shift ? focusManager.focusPrevious() : focusManager.focusNext()
+  }
+})
+```
+
+## Lifecycle Patterns
+
+### Cleanup
+
+Always clean up resources:
+
+```typescript
+const renderer = await createCliRenderer()
+
+// Track intervals/timeouts
+const intervals: Timer[] = []
+
+intervals.push(setInterval(() => {
+  updateClock()
+}, 1000))
+
+// Cleanup on exit
+process.on("SIGINT", () => {
+  intervals.forEach(clearInterval)
+  renderer.destroy()
+  process.exit(0)
+})
+
+// Or use onDestroy callback
+const renderer = await createCliRenderer({
+  onDestroy: () => {
+    intervals.forEach(clearInterval)
+  },
+})
+```
+
+### Dynamic Updates
+
+Update UI based on external data:
+
+```typescript
+async function createDashboard(renderer: RenderContext) {
+  const statsText = new TextRenderable(renderer, {
+    id: "stats",
+    content: "Loading...",
+  })
+
+  // Poll for updates
+  const updateStats = async () => {
+    const data = await fetchStats()
+    statsText.setContent(`CPU: ${data.cpu}% | Memory: ${data.memory}%`)
+  }
+
+  // Initial load
+  await updateStats()
+
+  // Periodic updates
+  setInterval(updateStats, 5000)
+
+  return statsText
+}
+```
+
+## Layout Patterns
+
+### Responsive Layout
+
+Adapt to terminal size:
+
+```typescript
+const renderer = await createCliRenderer()
+
+const mainPanel = new BoxRenderable(renderer, {
+  id: "main",
+  width: "100%",
+  height: "100%",
+  flexDirection: renderer.width > 80 ? "row" : "column",
+})
+
+// Listen for resize
+process.stdout.on("resize", () => {
+  mainPanel.setFlexDirection(renderer.width > 80 ? "row" : "column")
+})
+```
+
+### Split Panels
+
+```typescript
+function createSplitView(renderer: RenderContext, ratio = 0.3) {
+  const container = new BoxRenderable(renderer, {
+    id: "split",
+    flexDirection: "row",
+    width: "100%",
+    height: "100%",
+  })
+
+  const left = new BoxRenderable(renderer, {
+    id: "left",
+    width: `${ratio * 100}%`,
+    border: true,
+  })
+
+  const right = new BoxRenderable(renderer, {
+    id: "right",
+    flexGrow: 1,
+    border: true,
+  })
+
+  container.add(left)
+  container.add(right)
+
+  return { container, left, right }
+}
+```
+
+## Debugging Patterns
+
+### Console Overlay
+
+Use the built-in console for debugging:
+
+```typescript
+const renderer = await createCliRenderer({
+  consoleOptions: {
+    startInDebugMode: true,
+  },
+})
+
+// Show console
+renderer.console.show()
+
+// All console methods work
+console.log("Debug info")
+console.warn("Warning")
+console.error("Error")
+
+// Toggle with keyboard
+renderer.keyInput.on("keypress", (key) => {
+  if (key.name === "f12") {
+    renderer.console.toggle()
+  }
+})
+```
+
+### State Inspection
+
+```typescript
+function debugState(label: string, state: unknown) {
+  console.log(`[${label}]`, JSON.stringify(state, null, 2))
+}
+
+// In your update logic
+debugState("form", { name: nameInput.value, email: emailInput.value })
+```
diff --git a/.agents/skills/opentui/references/keyboard/REFERENCE.md b/.agents/skills/opentui/references/keyboard/REFERENCE.md
new file mode 100644
index 0000000..afad64b
--- /dev/null
+++ b/.agents/skills/opentui/references/keyboard/REFERENCE.md
@@ -0,0 +1,617 @@
+# Keyboard Input Handling
+
+How to handle keyboard input in OpenTUI applications.
+
+## Overview
+
+OpenTUI provides keyboard input handling through:
+- **Core**: `renderer.keyInput` EventEmitter
+- **React**: `useKeyboard()` hook
+- **Solid**: `useKeyboard()` hook
+
+## When to Use
+
+Use this reference when you need keyboard shortcuts, focus-aware input handling, or custom keybindings.
+
+## KeyEvent Object
+
+All keyboard handlers receive a `KeyEvent` object:
+
+```typescript
+interface KeyEvent {
+  name: string          // Key name: "a", "escape", "f1", etc.
+  sequence: string      // Raw escape sequence
+  ctrl: boolean         // Ctrl modifier held
+  shift: boolean        // Shift modifier held
+  meta: boolean         // Alt modifier held
+  option: boolean       // Option modifier held (macOS)
+  eventType: "press" | "release" | "repeat"
+  repeated: boolean     // Key is being held (repeat event)
+}
+```
+
+## Basic Usage
+
+### Core
+
+```typescript
+import { createCliRenderer, type KeyEvent } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.keyInput.on("keypress", (key: KeyEvent) => {
+  if (key.name === "escape") {
+    renderer.destroy()
+    return
+  }
+
+  if (key.ctrl && key.name === "s") {
+    saveDocument()
+  }
+})
+```
+
+### React
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/react"
+
+function App() {
+  const renderer = useRenderer()
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()
+    }
+  })
+
+  return <text>Press ESC to exit</text>
+}
+```
+
+
+### Solid
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/solid"
+
+function App() {
+  const renderer = useRenderer()
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()
+    }
+  })
+
+  return <text>Press ESC to exit</text>
+}
+```
+
+## Key Names
+
+### Alphabetic Keys
+
+Lowercase: `a`, `b`, `c`, ... `z`
+
+With Shift: Check `key.shift && key.name === "a"` for uppercase
+
+### Numeric Keys
+
+`0`, `1`, `2`, ... `9`
+
+### Function Keys
+
+`f1`, `f2`, `f3`, ... `f12`
+
+### Special Keys
+
+| Key Name | Description |
+|----------|-------------|
+| `escape` | Escape key |
+| `enter` | Enter/Return |
+| `return` | Enter/Return (alias) |
+| `tab` | Tab key |
+| `backspace` | Backspace |
+| `delete` | Delete key |
+| `space` | Spacebar |
+
+### Arrow Keys
+
+| Key Name | Description |
+|----------|-------------|
+| `up` | Up arrow |
+| `down` | Down arrow |
+| `left` | Left arrow |
+| `right` | Right arrow |
+
+### Navigation Keys
+
+| Key Name | Description |
+|----------|-------------|
+| `home` | Home key |
+| `end` | End key |
+| `pageup` | Page Up |
+| `pagedown` | Page Down |
+| `insert` | Insert key |
+
+## Modifier Keys
+
+Check modifier properties on `KeyEvent`:
+
+```typescript
+renderer.keyInput.on("keypress", (key) => {
+  if (key.ctrl && key.name === "c") {
+    // Ctrl+C
+  }
+
+  if (key.shift && key.name === "tab") {
+    // Shift+Tab
+  }
+
+  if (key.meta && key.name === "s") {
+    // Alt+S (meta = Alt on most systems)
+  }
+
+  if (key.option && key.name === "a") {
+    // Option+A (macOS)
+  }
+})
+```
+
+### Modifier Combinations
+
+```typescript
+// Ctrl+Shift+S
+if (key.ctrl && key.shift && key.name === "s") {
+  saveAs()
+}
+
+// Ctrl+Alt+Delete (careful with system shortcuts!)
+if (key.ctrl && key.meta && key.name === "delete") {
+  // ...
+}
+```
+
+## Event Types
+
+### Press Events (Default)
+
+Normal key press:
+
+```typescript
+renderer.keyInput.on("keypress", (key) => {
+  if (key.eventType === "press") {
+    // Initial key press
+  }
+})
+```
+
+### Repeat Events
+
+Key held down:
+
+```typescript
+renderer.keyInput.on("keypress", (key) => {
+  if (key.eventType === "repeat" || key.repeated) {
+    // Key is being held
+  }
+})
+```
+
+### Release Events
+
+Key released (opt-in):
+
+```tsx
+// React
+useKeyboard(
+  (key) => {
+    if (key.eventType === "release") {
+      // Key released
+    }
+  },
+  { release: true }  // Enable release events
+)
+
+// Solid
+useKeyboard(
+  (key) => {
+    if (key.eventType === "release") {
+      // Key released
+    }
+  },
+  { release: true }
+)
+```
+
+## Patterns
+
+### Navigation Menu
+
+```tsx
+function Menu() {
+  const [selectedIndex, setSelectedIndex] = useState(0)
+  const items = ["Home", "Settings", "Help", "Quit"]
+
+  useKeyboard((key) => {
+    switch (key.name) {
+      case "up":
+      case "k":
+        setSelectedIndex(i => Math.max(0, i - 1))
+        break
+      case "down":
+      case "j":
+        setSelectedIndex(i => Math.min(items.length - 1, i + 1))
+        break
+      case "enter":
+        handleSelect(items[selectedIndex])
+        break
+    }
+  })
+
+  return (
+    <box flexDirection="column">
+      {items.map((item, i) => (
+        <text
+          key={item}
+          fg={i === selectedIndex ? "#00FF00" : "#FFFFFF"}
+        >
+          {i === selectedIndex ? "> " : "  "}{item}
+        </text>
+      ))}
+    </box>
+  )
+}
+```
+
+### Modal Escape
+
+```tsx
+function Modal({ onClose, children }) {
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      onClose()
+    }
+  })
+
+  return (
+    <box border padding={2}>
+      {children}
+    </box>
+  )
+}
+```
+
+### Vim-style Modes
+
+```tsx
+function Editor() {
+  const [mode, setMode] = useState<"normal" | "insert">("normal")
+  const [content, setContent] = useState("")
+
+  useKeyboard((key) => {
+    if (mode === "normal") {
+      switch (key.name) {
+        case "i":
+          setMode("insert")
+          break
+        case "escape":
+          // Already in normal mode
+          break
+        case "j":
+          moveCursorDown()
+          break
+        case "k":
+          moveCursorUp()
+          break
+      }
+    } else if (mode === "insert") {
+      if (key.name === "escape") {
+        setMode("normal")
+      }
+      // Input component handles text in insert mode
+    }
+  })
+
+  return (
+    <box flexDirection="column">
+      <text>Mode: {mode}</text>
+      <textarea
+        value={content}
+        onChange={setContent}
+        focused={mode === "insert"}
+      />
+    </box>
+  )
+}
+```
+
+### Game Controls
+
+```tsx
+function Game() {
+  const [pressed, setPressed] = useState(new Set<string>())
+
+  useKeyboard(
+    (key) => {
+      setPressed(keys => {
+        const newKeys = new Set(keys)
+        if (key.eventType === "release") {
+          newKeys.delete(key.name)
+        } else {
+          newKeys.add(key.name)
+        }
+        return newKeys
+      })
+    },
+    { release: true }
+  )
+
+  // Game logic uses pressed set
+  useEffect(() => {
+    if (pressed.has("up") || pressed.has("w")) {
+      moveUp()
+    }
+    if (pressed.has("down") || pressed.has("s")) {
+      moveDown()
+    }
+  }, [pressed])
+
+  return <text>WASD or arrows to move</text>
+}
+```
+
+### Keyboard Shortcuts Help
+
+```tsx
+function ShortcutsHelp() {
+  const shortcuts = [
+    { keys: "Ctrl+S", action: "Save" },
+    { keys: "Ctrl+Q", action: "Quit" },
+    { keys: "Ctrl+F", action: "Find" },
+    { keys: "Tab", action: "Next field" },
+    { keys: "Shift+Tab", action: "Previous field" },
+  ]
+
+  return (
+    <box border title="Keyboard Shortcuts" padding={1}>
+      {shortcuts.map(({ keys, action }) => (
+        <box key={keys} flexDirection="row">
+          <text width={15} fg="#00FFFF">{keys}</text>
+          <text>{action}</text>
+        </box>
+      ))}
+    </box>
+  )
+}
+```
+
+## Paste Events
+
+Handle pasted content. Paste events deliver raw bytes, not decoded text.
+
+### PasteEvent Object
+
+```typescript
+import { type PasteEvent } from "@opentui/core"
+
+interface PasteEvent {
+  type: "paste"              // Always "paste"
+  bytes: Uint8Array          // Raw pasted bytes
+  metadata?: PasteMetadata   // Optional metadata
+  preventDefault(): void     // Prevent default paste handling
+  defaultPrevented: boolean  // Whether preventDefault was called
+}
+
+interface PasteMetadata {
+  mimeType?: string          // MIME type if available
+  kind?: PasteKind           // Paste kind
+}
+```
+
+### Decoding Paste Bytes
+
+Use `decodePasteBytes` to convert raw bytes to a string, and `stripAnsiSequences` to remove ANSI escape codes:
+
+```typescript
+import { decodePasteBytes, stripAnsiSequences } from "@opentui/core"
+
+const text = decodePasteBytes(event.bytes)          // Decode UTF-8
+const clean = stripAnsiSequences(decodePasteBytes(event.bytes))  // Decode + strip ANSI
+```
+
+### Core
+
+```typescript
+import { type PasteEvent, decodePasteBytes } from "@opentui/core"
+
+renderer.keyInput.on("paste", (event: PasteEvent) => {
+  const text = decodePasteBytes(event.bytes)
+  console.log("Pasted:", text)
+})
+```
+
+### Solid
+
+Solid provides a dedicated `usePaste` hook:
+
+```tsx
+import { usePaste } from "@opentui/solid"
+import { decodePasteBytes } from "@opentui/core"
+
+function App() {
+  usePaste((event) => {
+    const text = decodePasteBytes(event.bytes)
+    console.log("Pasted:", text)
+  })
+
+  return <text>Paste something</text>
+}
+```
+
+> **Note**: `usePaste` is **Solid-only**. React does not have this hook - handle paste via the Core event emitter or input component's `onChange`.
+
+## Text Selection
+
+Text selection is renderer-managed. The renderer owns a single `Selection` object, walks the renderable tree to find selectable children, and emits a `"selection"` event when the user finishes selecting (mouse-up). The `Selection` object aggregates text from all selected renderables automatically.
+
+### Making Renderables Selectable
+
+A renderable must have `selectable` set to `true` to participate in selection. Text-based renderables (`TextRenderable`, `TextareaRenderable`, `ASCIIFontRenderable`, `TextTableRenderable`) support this:
+
+```tsx
+// React / Solid
+<text selectable>This text can be selected</text>
+
+// Core
+const text = new TextRenderable(renderer, {
+  id: "label",
+  content: "This text can be selected",
+  selectable: true,
+})
+```
+
+### Copy-on-Selection (Core)
+
+Listen to the renderer's `"selection"` event. The `Selection` object's `getSelectedText()` returns text aggregated from all selected renderables in reading order:
+
+```typescript
+import type { Selection } from "@opentui/core"
+
+renderer.on("selection", (selection: Selection) => {
+  const text = selection.getSelectedText()
+  if (text) {
+    renderer.copyToClipboardOSC52(text)
+  }
+})
+```
+
+> **Important**: Call `selection.getSelectedText()` on the `Selection` object from the event -- not `renderer.root.getSelectedText()`. Individual renderables only return their own selected text. The `Selection` object aggregates across the tree.
+
+### Copy-on-Selection (Solid)
+
+```tsx
+import { useSelectionHandler } from "@opentui/solid"
+
+function App() {
+  useSelectionHandler((selection) => {
+    const text = selection.getSelectedText()
+    if (text) {
+      renderer.copyToClipboardOSC52(text)
+    }
+  })
+
+  return <text selectable>Select this text</text>
+}
+```
+
+> **Note**: `useSelectionHandler` is **Solid-only**. React does not have this hook -- use the Core `renderer.on("selection", ...)` event.
+
+### Selection Object
+
+The `Selection` object passed to the event callback:
+
+```typescript
+selection.getSelectedText()       // Aggregated text from all selected renderables
+selection.bounds                  // { startX, startY, endX, endY } bounding rect
+selection.selectedRenderables     // Renderable[] with active selections
+selection.isActive                // Whether selection is still active
+```
+
+Individual renderables also expose:
+
+```typescript
+renderable.hasSelection()         // Does this renderable have selected text?
+renderable.getSelectedText()      // Selected text in this renderable only
+```
+
+### How Selection Traversal Works
+
+When the user drags to select, the renderer:
+1. Identifies the selection container (common ancestor of start and end points)
+2. Walks all `selectable` descendants within the selection bounds
+3. Calls `onSelectionChanged(selection)` on each, which computes local selection
+4. Tracks which renderables have active selections in `selection.selectedRenderables`
+
+This means selection works across multiple renderables. Dragging across two `<text selectable>` elements selects text in both, and `selection.getSelectedText()` joins them with newlines.
+
+## Clipboard API (OSC 52)
+
+Copy text to the system clipboard using OSC 52 escape sequences. Works over SSH and in most modern terminal emulators.
+
+```typescript
+// Copy to clipboard
+const success = renderer.copyToClipboardOSC52("text to copy")
+
+// Check if OSC 52 is supported
+if (renderer.isOsc52Supported()) {
+  renderer.copyToClipboardOSC52("Hello!")
+}
+
+// Clear clipboard
+renderer.clearClipboardOSC52()
+
+// Target specific clipboard (X11)
+import { ClipboardTarget } from "@opentui/core"
+renderer.copyToClipboardOSC52("text", ClipboardTarget.Primary)   // X11 primary
+renderer.copyToClipboardOSC52("text", ClipboardTarget.Clipboard) // System clipboard (default)
+```
+
+## Focus and Input Components
+
+Input components (`<input>`, `<textarea>`, `<select>`) capture keyboard events when focused:
+
+```tsx
+<input focused />  // Receives keyboard input
+
+// Global useKeyboard still fires, but input consumes characters
+```
+
+To prevent conflicts, check if an input is focused before handling global shortcuts:
+
+```tsx
+function App() {
+  const renderer = useRenderer()
+  const [inputFocused, setInputFocused] = useState(false)
+
+  useKeyboard((key) => {
+    if (inputFocused) return  // Let input handle it
+
+    // Global shortcuts
+    if (key.name === "escape") {
+      renderer.destroy()
+    }
+  })
+
+  return (
+    <input
+      focused={inputFocused}
+      onFocus={() => setInputFocused(true)}
+      onBlur={() => setInputFocused(false)}
+    />
+  )
+}
+```
+
+## Gotchas
+
+### Terminal Limitations
+
+Some key combinations are captured by the terminal or OS:
+- `Ctrl+C` often sends SIGINT (use `exitOnCtrlC: false` to handle)
+- `Ctrl+Z` suspends the process
+- Some function keys may be intercepted
+
+### SSH and Remote Sessions
+
+Key detection may vary over SSH. Test on target environments.
+
+### Multiple Handlers
+
+Multiple `useKeyboard` calls all receive events. Coordinate handlers to prevent conflicts.
+
+## See Also
+
+- [React API](../react/api.md) - `useKeyboard` hook reference
+- [Solid API](../solid/api.md) - `useKeyboard` hook reference
+- [Input Components](../components/inputs.md) - Focus management with input, textarea, select
+- [Testing](../testing/REFERENCE.md) - Simulating key presses in tests
diff --git a/.agents/skills/opentui/references/layout/REFERENCE.md b/.agents/skills/opentui/references/layout/REFERENCE.md
new file mode 100644
index 0000000..c84255f
--- /dev/null
+++ b/.agents/skills/opentui/references/layout/REFERENCE.md
@@ -0,0 +1,337 @@
+# OpenTUI Layout System
+
+OpenTUI uses the Yoga layout engine, providing CSS Flexbox-like capabilities for positioning and sizing components in the terminal.
+
+## Overview
+
+Key concepts:
+- **Flexbox model**: Familiar CSS Flexbox properties
+- **Yoga engine**: Facebook's cross-platform layout engine
+- **Terminal units**: Dimensions are in character cells (columns x rows)
+- **Percentage support**: Relative sizing based on parent
+
+## Flex Container Properties
+
+### flexDirection
+
+Controls the main axis direction:
+
+```tsx
+// Row (default) - children flow horizontally
+<box flexDirection="row">
+  <text>1</text>
+  <text>2</text>
+  <text>3</text>
+</box>
+// Output: 1 2 3
+
+// Column - children flow vertically
+<box flexDirection="column">
+  <text>1</text>
+  <text>2</text>
+  <text>3</text>
+</box>
+// Output:
+// 1
+// 2
+// 3
+
+// Reverse variants
+<box flexDirection="row-reverse">...</box>     // 3 2 1
+<box flexDirection="column-reverse">...</box>  // Bottom to top
+```
+
+### justifyContent
+
+Aligns children along the main axis:
+
+```tsx
+<box flexDirection="row" width={40} justifyContent="flex-start">
+  {/* Children at start (left for row) */}
+</box>
+
+<box flexDirection="row" width={40} justifyContent="flex-end">
+  {/* Children at end (right for row) */}
+</box>
+
+<box flexDirection="row" width={40} justifyContent="center">
+  {/* Children centered */}
+</box>
+
+<box flexDirection="row" width={40} justifyContent="space-between">
+  {/* First at start, last at end, rest evenly distributed */}
+</box>
+
+<box flexDirection="row" width={40} justifyContent="space-around">
+  {/* Equal space around each child */}
+</box>
+
+<box flexDirection="row" width={40} justifyContent="space-evenly">
+  {/* Equal space between all children and edges */}
+</box>
+```
+
+### alignItems
+
+Aligns children along the cross axis:
+
+```tsx
+<box flexDirection="row" height={10} alignItems="flex-start">
+  {/* Children at top */}
+</box>
+
+<box flexDirection="row" height={10} alignItems="flex-end">
+  {/* Children at bottom */}
+</box>
+
+<box flexDirection="row" height={10} alignItems="center">
+  {/* Children vertically centered */}
+</box>
+
+<box flexDirection="row" height={10} alignItems="stretch">
+  {/* Children stretch to fill height */}
+</box>
+
+<box flexDirection="row" height={10} alignItems="baseline">
+  {/* Children aligned by text baseline */}
+</box>
+```
+
+### flexWrap
+
+Controls whether children wrap to new lines:
+
+```tsx
+<box flexDirection="row" flexWrap="nowrap" width={20}>
+  {/* Children overflow (default) */}
+</box>
+
+<box flexDirection="row" flexWrap="wrap" width={20}>
+  {/* Children wrap to next row */}
+</box>
+
+<box flexDirection="row" flexWrap="wrap-reverse" width={20}>
+  {/* Children wrap upward */}
+</box>
+```
+
+### gap
+
+Space between children:
+
+```tsx
+<box flexDirection="row" gap={2}>
+  <text>A</text>
+  <text>B</text>
+  <text>C</text>
+</box>
+// Output: A  B  C (2 spaces between)
+```
+
+## Flex Item Properties
+
+### flexGrow
+
+How much a child should grow relative to siblings:
+
+```tsx
+<box flexDirection="row" width={30}>
+  <box flexGrow={1}><text>1</text></box>
+  <box flexGrow={2}><text>2</text></box>
+  <box flexGrow={1}><text>1</text></box>
+</box>
+// Widths: 7.5 | 15 | 7.5 (1:2:1 ratio)
+```
+
+### flexShrink
+
+How much a child should shrink when space is limited:
+
+```tsx
+<box flexDirection="row" width={20}>
+  <box width={15} flexShrink={1}><text>Shrinks</text></box>
+  <box width={15} flexShrink={0}><text>Fixed</text></box>
+</box>
+```
+
+### flexBasis
+
+Initial size before growing/shrinking:
+
+```tsx
+<box flexDirection="row">
+  <box flexBasis={20} flexGrow={1}>Starts at 20, can grow</box>
+  <box flexBasis="50%">Half of parent</box>
+</box>
+```
+
+### alignSelf
+
+Override parent's alignItems for this child:
+
+```tsx
+<box flexDirection="row" height={10} alignItems="center">
+  <text>Centered</text>
+  <text alignSelf="flex-start">Top</text>
+  <text alignSelf="flex-end">Bottom</text>
+</box>
+```
+
+## Dimensions
+
+### Fixed Dimensions
+
+```tsx
+<box width={40} height={10}>
+  {/* Exactly 40 columns by 10 rows */}
+</box>
+```
+
+### Percentage Dimensions
+
+Parent must have explicit size:
+
+```tsx
+<box width="100%" height="100%">
+  <box width="50%" height="50%">
+    {/* Half of parent */}
+  </box>
+</box>
+```
+
+### Min/Max Constraints
+
+```tsx
+<box
+  minWidth={20}
+  maxWidth={60}
+  minHeight={5}
+  maxHeight={20}
+>
+  {/* Constrained sizing */}
+</box>
+```
+
+## Spacing
+
+### Padding (inside)
+
+```tsx
+// All sides
+<box padding={2}>Content</box>
+
+// Individual sides
+<box
+  paddingTop={1}
+  paddingRight={2}
+  paddingBottom={1}
+  paddingLeft={2}
+>
+  Content
+</box>
+```
+
+### Margin (outside)
+
+```tsx
+// All sides
+<box margin={1}>Content</box>
+
+// Individual sides
+<box
+  marginTop={1}
+  marginRight={2}
+  marginBottom={1}
+  marginLeft={2}
+>
+  Content
+</box>
+```
+
+## Positioning
+
+### Relative (default)
+
+Element flows in normal document order:
+
+```tsx
+<box position="relative">
+  {/* Normal flow */}
+</box>
+```
+
+### Absolute
+
+Element positioned relative to nearest positioned ancestor:
+
+```tsx
+<box position="relative" width="100%" height="100%">
+  <box
+    position="absolute"
+    left={10}
+    top={5}
+    width={20}
+    height={5}
+  >
+    Positioned at (10, 5)
+  </box>
+</box>
+```
+
+### Position Properties
+
+```tsx
+<box
+  position="absolute"
+  left={10}      // From left edge
+  top={5}        // From top edge
+  right={10}     // From right edge
+  bottom={5}     // From bottom edge
+>
+  Content
+</box>
+```
+
+## Display
+
+### Visibility Control
+
+```tsx
+// Visible (default)
+<box display="flex">Visible</box>
+
+// Hidden (removed from layout)
+<box display="none">Hidden</box>
+```
+
+## Overflow
+
+```tsx
+<box overflow="visible">
+  {/* Content can extend beyond bounds (default) */}
+</box>
+
+<box overflow="hidden">
+  {/* Content clipped at bounds */}
+</box>
+
+<box overflow="scroll">
+  {/* Scrollable when content exceeds bounds */}
+</box>
+```
+
+## Z-Index
+
+Control stacking order for overlapping elements:
+
+```tsx
+<box position="relative">
+  <box position="absolute" zIndex={1}>Behind</box>
+  <box position="absolute" zIndex={2}>In front</box>
+</box>
+```
+
+## See Also
+
+- [Layout Patterns](./patterns.md) - Common layout recipes
+- [Components/Containers](../components/containers.md) - Box and ScrollBox details
diff --git a/.agents/skills/opentui/references/layout/patterns.md b/.agents/skills/opentui/references/layout/patterns.md
new file mode 100644
index 0000000..69bdc54
--- /dev/null
+++ b/.agents/skills/opentui/references/layout/patterns.md
@@ -0,0 +1,444 @@
+# Layout Patterns
+
+Common layout recipes for terminal user interfaces.
+
+## Full-Screen App
+
+Fill the entire terminal:
+
+```tsx
+function App() {
+  return (
+    <box width="100%" height="100%">
+      {/* Content fills terminal */}
+    </box>
+  )
+}
+```
+
+## Header/Content/Footer
+
+Classic app layout:
+
+```tsx
+function AppLayout() {
+  return (
+    <box flexDirection="column" width="100%" height="100%">
+      {/* Header - fixed height */}
+      <box height={3} borderStyle="single" borderBottom>
+        <text>Header</text>
+      </box>
+
+      {/* Content - fills remaining space */}
+      <box flexGrow={1}>
+        <text>Main Content</text>
+      </box>
+
+      {/* Footer - fixed height */}
+      <box height={1}>
+        <text>Status: Ready</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Sidebar Layout
+
+```tsx
+function SidebarLayout() {
+  return (
+    <box flexDirection="row" width="100%" height="100%">
+      {/* Sidebar - fixed width */}
+      <box width={25} borderStyle="single" borderRight>
+        <text>Sidebar</text>
+      </box>
+
+      {/* Main - fills remaining space */}
+      <box flexGrow={1}>
+        <text>Main Content</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Resizable Sidebar
+
+Responsive based on terminal width:
+
+```tsx
+function ResponsiveSidebar() {
+  const dims = useTerminalDimensions()  // React: useTerminalDimensions()
+  const showSidebar = dims.width > 60
+  const sidebarWidth = Math.min(30, Math.floor(dims.width * 0.3))
+
+  return (
+    <box flexDirection="row" width="100%" height="100%">
+      {showSidebar && (
+        <box width={sidebarWidth} border>
+          <text>Sidebar</text>
+        </box>
+      )}
+      <box flexGrow={1}>
+        <text>Main</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Centered Content
+
+### Horizontally Centered
+
+```tsx
+<box width="100%" justifyContent="center">
+  <box width={40}>
+    <text>Centered horizontally</text>
+  </box>
+</box>
+```
+
+### Vertically Centered
+
+```tsx
+<box height="100%" alignItems="center">
+  <text>Centered vertically</text>
+</box>
+```
+
+### Both Axes
+
+```tsx
+<box
+  width="100%"
+  height="100%"
+  justifyContent="center"
+  alignItems="center"
+>
+  <box width={40} height={10} border>
+    <text>Centered both ways</text>
+  </box>
+</box>
+```
+
+## Modal/Dialog
+
+Centered overlay:
+
+```tsx
+function Modal({ children, visible }) {
+  if (!visible) return null
+
+  return (
+    <box
+      position="absolute"
+      left={0}
+      top={0}
+      width="100%"
+      height="100%"
+      justifyContent="center"
+      alignItems="center"
+      backgroundColor="rgba(0,0,0,0.5)"
+    >
+      <box
+        width={50}
+        height={15}
+        border
+        borderStyle="double"
+        backgroundColor="#1a1a2e"
+        padding={2}
+      >
+        {children}
+      </box>
+    </box>
+  )
+}
+```
+
+## Grid Layout
+
+Using flexWrap:
+
+```tsx
+function Grid({ items, columns = 3 }) {
+  const itemWidth = `${Math.floor(100 / columns)}%`
+
+  return (
+    <box flexDirection="row" flexWrap="wrap" width="100%">
+      {items.map((item, i) => (
+        <box key={i} width={itemWidth} padding={1}>
+          <text>{item}</text>
+        </box>
+      ))}
+    </box>
+  )
+}
+```
+
+## Split Panels
+
+### Horizontal Split
+
+```tsx
+function HorizontalSplit({ ratio = 0.5 }) {
+  return (
+    <box flexDirection="row" width="100%" height="100%">
+      <box width={`${ratio * 100}%`} border>
+        <text>Left Panel</text>
+      </box>
+      <box flexGrow={1} border>
+        <text>Right Panel</text>
+      </box>
+    </box>
+  )
+}
+```
+
+### Vertical Split
+
+```tsx
+function VerticalSplit({ ratio = 0.5 }) {
+  return (
+    <box flexDirection="column" width="100%" height="100%">
+      <box height={`${ratio * 100}%`} border>
+        <text>Top Panel</text>
+      </box>
+      <box flexGrow={1} border>
+        <text>Bottom Panel</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Form Layout
+
+Label + Input pairs:
+
+```tsx
+function FormField({ label, children }) {
+  return (
+    <box flexDirection="row" marginBottom={1}>
+      <box width={15}>
+        <text>{label}:</text>
+      </box>
+      <box flexGrow={1}>
+        {children}
+      </box>
+    </box>
+  )
+}
+
+function LoginForm() {
+  return (
+    <box flexDirection="column" padding={2} border width={50}>
+      <FormField label="Username">
+        <input placeholder="Enter username" />
+      </FormField>
+      <FormField label="Password">
+        <input placeholder="Enter password" />
+      </FormField>
+      <box marginTop={2} justifyContent="flex-end">
+        <box border padding={1}>
+          <text>Login</text>
+        </box>
+      </box>
+    </box>
+  )
+}
+```
+
+## Navigation Tabs
+
+```tsx
+function TabBar({ tabs, activeIndex, onSelect }) {
+  return (
+    <box flexDirection="row" borderBottom>
+      {tabs.map((tab, i) => (
+        <box
+          key={i}
+          padding={1}
+          backgroundColor={i === activeIndex ? "#333" : "transparent"}
+          onMouseDown={() => onSelect(i)}
+        >
+          <text fg={i === activeIndex ? "#fff" : "#888"}>
+            {tab}
+          </text>
+        </box>
+      ))}
+    </box>
+  )
+}
+```
+
+## Sticky Footer
+
+Footer always at bottom:
+
+```tsx
+function StickyFooterLayout() {
+  return (
+    <box flexDirection="column" width="100%" height="100%">
+      {/* Content area */}
+      <box flexGrow={1} flexDirection="column">
+        {/* Your content here */}
+        <text>Content that might be short</text>
+      </box>
+
+      {/* Footer pushed to bottom */}
+      <box height={1}>
+        <text fg="#888">Press ? for help | q to quit</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Absolute Positioning Overlay
+
+Tooltip or popup:
+
+```tsx
+function Tooltip({ x, y, children }) {
+  return (
+    <box
+      position="absolute"
+      left={x}
+      top={y}
+      border
+      backgroundColor="#333"
+      padding={1}
+      zIndex={100}
+    >
+      {children}
+    </box>
+  )
+}
+```
+
+## Responsive Breakpoints
+
+Different layouts based on terminal size:
+
+```tsx
+function ResponsiveApp() {
+  const { width, height } = useTerminalDimensions()
+
+  // Define breakpoints
+  const isSmall = width < 60
+  const isMedium = width >= 60 && width < 100
+  const isLarge = width >= 100
+
+  if (isSmall) {
+    // Mobile-like: stacked layout
+    return (
+      <box flexDirection="column">
+        <Navigation />
+        <Content />
+      </box>
+    )
+  }
+
+  if (isMedium) {
+    // Tablet-like: sidebar + content
+    return (
+      <box flexDirection="row">
+        <box width={20}><Navigation /></box>
+        <box flexGrow={1}><Content /></box>
+      </box>
+    )
+  }
+
+  // Large: full layout
+  return (
+    <box flexDirection="row">
+      <box width={25}><Navigation /></box>
+      <box flexGrow={1}><Content /></box>
+      <box width={30}><Sidebar /></box>
+    </box>
+  )
+}
+```
+
+## Equal Height Columns
+
+```tsx
+function EqualColumns() {
+  return (
+    <box flexDirection="row" alignItems="stretch" height={20}>
+      <box flexGrow={1} border>
+        <text>Short content</text>
+      </box>
+      <box flexGrow={1} border>
+        <text>
+          Longer content that
+          spans multiple lines
+          and takes up space
+        </text>
+      </box>
+      <box flexGrow={1} border>
+        <text>Medium content</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Spacing Utilities
+
+Consistent spacing patterns:
+
+```tsx
+// Spacer component
+function Spacer({ size = 1 }) {
+  return <box height={size} width={size} />
+}
+
+// Divider component
+function Divider() {
+  return <box height={1} width="100%" backgroundColor="#333" />
+}
+
+// Usage
+<box flexDirection="column">
+  <text>Section 1</text>
+  <Spacer size={2} />
+  <Divider />
+  <Spacer size={2} />
+  <text>Section 2</text>
+</box>
+```
+
+### Axis Shorthand Props
+
+Use `paddingX`/`paddingY` and `marginX`/`marginY` for horizontal/vertical spacing:
+
+```tsx
+// Horizontal padding (left + right)
+<box paddingX={4}>
+  <text>4 chars padding left and right</text>
+</box>
+
+// Vertical padding (top + bottom)
+<box paddingY={2}>
+  <text>2 lines padding top and bottom</text>
+</box>
+
+// Horizontal margin for centering-like effect
+<box marginX={10}>
+  <text>Indented content</text>
+</box>
+
+// Combined for card-like spacing
+<box paddingX={3} paddingY={1} marginY={1} border>
+  <text>Nicely spaced card</text>
+</box>
+```
+
+These are shorthand for:
+- `paddingX={n}` = `paddingLeft={n}` + `paddingRight={n}`
+- `paddingY={n}` = `paddingTop={n}` + `paddingBottom={n}`
+- `marginX={n}` = `marginLeft={n}` + `marginRight={n}`
+- `marginY={n}` = `marginTop={n}` + `marginBottom={n}`
diff --git a/.agents/skills/opentui/references/react/REFERENCE.md b/.agents/skills/opentui/references/react/REFERENCE.md
new file mode 100644
index 0000000..cc6eda9
--- /dev/null
+++ b/.agents/skills/opentui/references/react/REFERENCE.md
@@ -0,0 +1,174 @@
+# OpenTUI React (@opentui/react)
+
+A React reconciler for building terminal user interfaces with familiar React patterns. Write TUIs using JSX, hooks, and component composition.
+
+## Overview
+
+OpenTUI React provides:
+- **Custom reconciler**: React components render to OpenTUI renderables
+- **JSX intrinsics**: `<text>`, `<box>`, `<input>`, etc.
+- **Hooks**: `useKeyboard`, `useRenderer`, `useTimeline`, etc.
+- **Full React compatibility**: useState, useEffect, context, and more
+
+## When to Use React
+
+Use the React reconciler when:
+- You're familiar with React patterns
+- You want declarative UI composition
+- You need React's ecosystem (context, state management libraries)
+- Building applications with complex state
+- Team knows React already
+
+## When NOT to Use React
+
+| Scenario | Use Instead |
+|----------|-------------|
+| Maximum performance critical | `@opentui/core` (imperative) |
+| Fine-grained reactivity | `@opentui/solid` |
+| Smallest bundle size | `@opentui/core` |
+| Building a framework/library | `@opentui/core` |
+
+## Quick Start
+
+```bash
+bunx create-tui@latest -t react my-app
+cd my-app
+bun run src/index.tsx
+```
+
+The CLI creates the `my-app` directory for you - it must **not already exist**.
+
+**Agent guidance**: Always use autonomous mode with `-t <template>` flag. Never use interactive mode (`bunx create-tui@latest my-app` without `-t`) as it requires user prompts that agents cannot respond to.
+
+Or manual setup:
+
+```bash
+mkdir my-tui && cd my-tui
+bun init
+bun install @opentui/react @opentui/core react
+```
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { useState } from "react"
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <box border padding={2}>
+      <text>Count: {count}</text>
+      <box
+        border
+        onMouseDown={() => setCount(c => c + 1)}
+      >
+        <text>Click me!</text>
+      </box>
+    </box>
+  )
+}
+
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+## Core Concepts
+
+### JSX Elements
+
+React maps JSX intrinsic elements to OpenTUI renderables:
+
+```tsx
+// These are not HTML elements!
+<text>Hello</text>           // TextRenderable
+<box border>Content</box>    // BoxRenderable
+<input placeholder="..." />  // InputRenderable
+<select options={[...]} />   // SelectRenderable
+```
+
+### Text Modifiers
+
+Inside `<text>`, use modifier elements:
+
+```tsx
+<text>
+  <strong>Bold</strong>, <em>italic</em>, and <u>underlined</u>
+  <span fg="red">Colored text</span>
+  <br />
+  New line with <a href="https://example.com">link</a>
+</text>
+```
+
+### Styling
+
+Two approaches to styling:
+
+```tsx
+// Direct props
+<box backgroundColor="blue" padding={2} border>
+  <text fg="#00FF00">Green text</text>
+</box>
+
+// Style prop
+<box style={{ backgroundColor: "blue", padding: 2, border: true }}>
+  <text style={{ fg: "#00FF00" }}>Green text</text>
+</box>
+```
+
+## Available Components
+
+### Layout & Display
+- `<text>` - Styled text content
+- `<box>` - Container with borders and layout
+- `<scrollbox>` - Scrollable container
+- `<ascii-font>` - ASCII art text
+
+### Input
+- `<input>` - Single-line text input
+- `<textarea>` - Multi-line text input
+- `<select>` - List selection
+- `<tab-select>` - Tab-based selection
+
+### Code & Diff
+- `<code>` - Syntax-highlighted code
+- `<line-number>` - Code with line numbers
+- `<diff>` - Unified or split diff viewer
+
+### Text Modifiers (inside `<text>`)
+- `<span>` - Inline styled text
+- `<strong>`, `<b>` - Bold
+- `<em>`, `<i>` - Italic
+- `<u>` - Underline
+- `<br>` - Line break
+- `<a>` - Link
+
+## Essential Hooks
+
+```tsx
+import {
+  useRenderer,
+  useKeyboard,
+  useOnResize,
+  useTerminalDimensions,
+  useTimeline,
+} from "@opentui/react"
+```
+
+See [API Reference](./api.md) for detailed hook documentation.
+
+## In This Reference
+
+- [Configuration](./configuration.md) - Project setup, tsconfig, bundling
+- [API](./api.md) - Components, hooks, createRoot
+- [Patterns](./patterns.md) - State management, keyboard handling, forms
+- [Gotchas](./gotchas.md) - Common issues, debugging, limitations
+
+## See Also
+
+- [Core](../core/REFERENCE.md) - Underlying imperative API
+- [Solid](../solid/REFERENCE.md) - Alternative declarative approach
+- [Components](../components/REFERENCE.md) - Component reference by category
+- [Layout](../layout/REFERENCE.md) - Flexbox layout system
+- [Keyboard](../keyboard/REFERENCE.md) - Input handling and shortcuts
+- [Testing](../testing/REFERENCE.md) - Test renderer and snapshots
diff --git a/.agents/skills/opentui/references/react/api.md b/.agents/skills/opentui/references/react/api.md
new file mode 100644
index 0000000..a26cd71
--- /dev/null
+++ b/.agents/skills/opentui/references/react/api.md
@@ -0,0 +1,436 @@
+# React API Reference
+
+## Rendering
+
+### createRoot(renderer)
+
+Creates a React root for rendering.
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,  // Handle Ctrl+C yourself
+})
+
+const root = createRoot(renderer)
+root.render(<App />)
+```
+
+## Hooks
+
+### useRenderer()
+
+Access the OpenTUI renderer instance.
+
+```tsx
+import { useRenderer } from "@opentui/react"
+import { useEffect } from "react"
+
+function App() {
+  const renderer = useRenderer()
+
+  useEffect(() => {
+    // Access renderer properties
+    console.log(`Terminal: ${renderer.width}x${renderer.height}`)
+
+    // Show debug console
+    renderer.console.show()
+
+    // Access theme mode (dark/light based on terminal settings)
+    console.log(`Theme: ${renderer.themeMode}`)  // "dark" | "light" | null
+  }, [renderer])
+
+  return <text>Hello</text>
+}
+
+// Listen for theme mode changes
+function ThemedApp() {
+  const renderer = useRenderer()
+  const [theme, setTheme] = useState(renderer.themeMode ?? "dark")
+
+  useEffect(() => {
+    const handler = (mode: "dark" | "light") => setTheme(mode)
+    renderer.on("theme_mode", handler)
+    return () => renderer.off("theme_mode", handler)
+  }, [renderer])
+
+  return (
+    <box backgroundColor={theme === "dark" ? "#1a1a2e" : "#ffffff"}>
+      <text fg={theme === "dark" ? "#fff" : "#000"}>
+        Current theme: {theme}
+      </text>
+    </box>
+  )
+}
+```
+
+### useKeyboard(handler, options?)
+
+Handle keyboard events.
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/react"
+
+function App() {
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()  // Never use process.exit() directly!
+    }
+    if (key.ctrl && key.name === "s") {
+      saveDocument()
+    }
+  })
+
+  return <text>Press ESC to exit</text>
+}
+
+// With release events
+function GameControls() {
+  const [pressed, setPressed] = useState(new Set<string>())
+
+  useKeyboard(
+    (event) => {
+      setPressed(keys => {
+        const newKeys = new Set(keys)
+        if (event.eventType === "release") {
+          newKeys.delete(event.name)
+        } else {
+          newKeys.add(event.name)
+        }
+        return newKeys
+      })
+    },
+    { release: true }  // Include release events
+  )
+
+  return <text>Pressed: {Array.from(pressed).join(", ")}</text>
+}
+```
+
+**Options:**
+- `release?: boolean` - Include key release events (default: false)
+
+**KeyEvent properties:**
+- `name: string` - Key name ("a", "escape", "f1", etc.)
+- `sequence: string` - Raw escape sequence
+- `ctrl: boolean` - Ctrl modifier
+- `shift: boolean` - Shift modifier
+- `meta: boolean` - Alt modifier
+- `option: boolean` - Option modifier (macOS)
+- `eventType: "press" | "release" | "repeat"`
+- `repeated: boolean` - Key is being held
+
+### useOnResize(callback)
+
+Handle terminal resize events.
+
+```tsx
+import { useOnResize } from "@opentui/react"
+
+function App() {
+  useOnResize((width, height) => {
+    console.log(`Resized to ${width}x${height}`)
+  })
+
+  return <text>Resize the terminal</text>
+}
+```
+
+### useTerminalDimensions()
+
+Get reactive terminal dimensions.
+
+```tsx
+import { useTerminalDimensions } from "@opentui/react"
+
+function ResponsiveLayout() {
+  const { width, height } = useTerminalDimensions()
+
+  return (
+    <box flexDirection={width > 80 ? "row" : "column"}>
+      <box flexGrow={1}>
+        <text>Width: {width}</text>
+      </box>
+      <box flexGrow={1}>
+        <text>Height: {height}</text>
+      </box>
+    </box>
+  )
+}
+```
+
+### useTimeline(options?)
+
+Create animations with the timeline system.
+
+```tsx
+import { useTimeline } from "@opentui/react"
+import { useEffect, useState } from "react"
+
+function AnimatedBox() {
+  const [width, setWidth] = useState(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+    loop: false,
+  })
+
+  useEffect(() => {
+    timeline.add(
+      { width: 0 },
+      {
+        width: 50,
+        duration: 2000,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setWidth(Math.round(anim.targets[0].width))
+        },
+      }
+    )
+  }, [timeline])
+
+  return <box style={{ width, height: 3, backgroundColor: "#6a5acd" }} />
+}
+```
+
+**Options:**
+- `duration?: number` - Default duration (ms)
+- `loop?: boolean` - Loop the timeline
+- `autoplay?: boolean` - Auto-start (default: true)
+- `onComplete?: () => void` - Completion callback
+- `onPause?: () => void` - Pause callback
+
+**Timeline methods:**
+- `add(target, properties, startTime?)` - Add animation
+- `play()` - Start playback
+- `pause()` - Pause playback
+- `restart()` - Restart from beginning
+
+## Components
+
+### Text Component
+
+```tsx
+<text
+  content="Hello"           // Or use children
+  fg="#FFFFFF"              // Foreground color
+  bg="#000000"              // Background color
+  selectable={true}         // Allow text selection
+>
+  {/* Use nested modifier tags for styling */}
+  <span fg="red">Red</span>
+  <strong>Bold</strong>
+  <em>Italic</em>
+  <u>Underline</u>
+  <br />
+  <a href="https://...">Link</a>
+</text>
+```
+
+> **Note**: Do NOT use `bold`, `italic`, `underline` as props on `<text>`. Use nested modifier tags like `<strong>`, `<em>`, `<u>` instead.
+
+### Box Component
+
+```tsx
+<box
+  // Borders
+  border                    // Enable border
+  borderStyle="single"      // single | double | rounded | bold
+  borderColor="#FFFFFF"
+  title="Title"
+  titleAlignment="center"   // left | center | right
+
+  // Colors
+  backgroundColor="#1a1a2e"
+
+  // Layout (see layout/REFERENCE.md)
+  flexDirection="row"
+  justifyContent="center"
+  alignItems="center"
+  gap={2}
+
+  // Spacing
+  padding={2}
+  paddingTop={1}
+  paddingX={2}              // Horizontal (left + right)
+  paddingY={1}              // Vertical (top + bottom)
+  margin={1}
+  marginX={2}               // Horizontal (left + right)
+  marginY={1}               // Vertical (top + bottom)
+
+  // Dimensions
+  width={40}
+  height={10}
+  flexGrow={1}
+
+  // Focus
+  focusable                 // Allow box to receive focus
+  focused={isFocused}       // Controlled focus state
+
+  // Events
+  onMouseDown={(e) => {}}
+  onMouseUp={(e) => {}}
+  onMouseMove={(e) => {}}
+>
+  {children}
+</box>
+```
+
+### Scrollbox Component
+
+```tsx
+<scrollbox
+  focused                   // Enable keyboard scrolling
+  style={{
+    rootOptions: { backgroundColor: "#24283b" },
+    wrapperOptions: { backgroundColor: "#1f2335" },
+    viewportOptions: { backgroundColor: "#1a1b26" },
+    contentOptions: { backgroundColor: "#16161e" },
+    scrollbarOptions: {
+      showArrows: true,
+      trackOptions: {
+        foregroundColor: "#7aa2f7",
+        backgroundColor: "#414868",
+      },
+    },
+  }}
+>
+  {/* Scrollable content */}
+  {items.map((item, i) => (
+    <box key={i}>
+      <text>{item}</text>
+    </box>
+  ))}
+</scrollbox>
+```
+
+### Input Component
+
+```tsx
+<input
+  value={value}
+  onChange={(newValue) => setValue(newValue)}
+  placeholder="Enter text..."
+  focused                   // Start focused
+  width={30}
+  backgroundColor="#1a1a1a"
+  textColor="#FFFFFF"
+  cursorColor="#00FF00"
+  focusedBackgroundColor="#2a2a2a"
+/>
+```
+
+### Textarea Component
+
+```tsx
+<textarea
+  value={text}
+  onChange={(newValue) => setText(newValue)}
+  placeholder="Enter multiple lines..."
+  focused
+  width={40}
+  height={10}
+  showLineNumbers
+  wrapText
+/>
+```
+
+### Select Component
+
+```tsx
+<select
+  options={[
+    { name: "Option 1", description: "First option", value: "1" },
+    { name: "Option 2", description: "Second option", value: "2" },
+  ]}
+  onChange={(index, option) => setSelected(option)}
+  selectedIndex={0}
+  focused
+  showScrollIndicator
+  height={8}
+/>
+```
+
+### Tab Select Component
+
+```tsx
+<tab-select
+  options={[
+    { name: "Home", description: "Dashboard" },
+    { name: "Settings", description: "Configuration" },
+  ]}
+  onChange={(index, option) => setTab(option)}
+  tabWidth={20}
+  focused
+/>
+```
+
+### ASCII Font Component
+
+```tsx
+<ascii-font
+  text="TITLE"
+  font="tiny"               // tiny | block | slick | shade
+  color="#FFFFFF"
+/>
+```
+
+### Code Component
+
+```tsx
+<code
+  code={sourceCode}
+  language="typescript"
+  showLineNumbers
+  highlightLines={[1, 5, 10]}
+/>
+```
+
+### Line Number Component
+
+```tsx
+<line-number
+  code={sourceCode}
+  language="typescript"
+  startLine={1}
+  highlightedLines={[5]}
+  diagnostics={[
+    { line: 3, severity: "error", message: "Syntax error" }
+  ]}
+/>
+```
+
+### Diff Component
+
+```tsx
+<diff
+  oldCode={originalCode}
+  newCode={modifiedCode}
+  language="typescript"
+  mode="unified"            // unified | split
+  syncScroll                // Sync scroll between split view panes
+  showLineNumbers
+/>
+```
+
+## Type Exports
+
+```tsx
+import type {
+  // Component props
+  TextProps,
+  BoxProps,
+  InputProps,
+  SelectProps,
+
+  // Hook types
+  KeyEvent,
+
+  // From core
+  CliRenderer,
+} from "@opentui/react"
+```
diff --git a/.agents/skills/opentui/references/react/configuration.md b/.agents/skills/opentui/references/react/configuration.md
new file mode 100644
index 0000000..f78f55d
--- /dev/null
+++ b/.agents/skills/opentui/references/react/configuration.md
@@ -0,0 +1,302 @@
+# React Configuration
+
+## Project Setup
+
+### Quick Start
+
+```bash
+bunx create-tui@latest -t react my-app
+cd my-app && bun install
+```
+
+The CLI creates the `my-app` directory for you - it must **not already exist**.
+
+Options: `--no-git` (skip git init), `--no-install` (skip bun install)
+
+### Manual Setup
+
+```bash
+mkdir my-tui && cd my-tui
+bun init
+bun install @opentui/react @opentui/core react
+```
+
+## TypeScript Configuration
+
+### tsconfig.json
+
+```json
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"]
+}
+```
+
+**Critical settings:**
+- `jsx: "react-jsx"` - Use the new JSX transform
+- `jsxImportSource: "@opentui/react"` - Import JSX runtime from OpenTUI
+- `module` / `moduleResolution: "NodeNext"` - Recommended for OpenTUI compatibility
+
+### Why DOM lib?
+
+The `DOM` lib is needed for React types. OpenTUI's JSX types extend React's.
+
+## Package Configuration
+
+### package.json
+
+```json
+{
+  "name": "my-tui-app",
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/index.tsx",
+    "dev": "bun --watch run src/index.tsx",
+    "test": "bun test",
+    "build": "bun build src/index.tsx --outdir=dist --target=bun"
+  },
+  "dependencies": {
+    "@opentui/core": "latest",
+    "@opentui/react": "latest",
+    "react": ">=19.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": ">=19.0.0",
+    "typescript": "latest"
+  }
+}
+```
+
+## Project Structure
+
+Recommended structure:
+
+```
+my-tui-app/
+├── src/
+│   ├── components/
+│   │   ├── Header.tsx
+│   │   ├── Sidebar.tsx
+│   │   └── MainContent.tsx
+│   ├── hooks/
+│   │   └── useAppState.ts
+│   ├── App.tsx
+│   └── index.tsx
+├── package.json
+└── tsconfig.json
+```
+
+### Entry Point (src/index.tsx)
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { App } from "./App"
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true,
+})
+
+createRoot(renderer).render(<App />)
+```
+
+### App Component (src/App.tsx)
+
+```tsx
+import { Header } from "./components/Header"
+import { Sidebar } from "./components/Sidebar"
+import { MainContent } from "./components/MainContent"
+
+export function App() {
+  return (
+    <box flexDirection="column" width="100%" height="100%">
+      <Header />
+      <box flexDirection="row" flexGrow={1}>
+        <Sidebar />
+        <MainContent />
+      </box>
+    </box>
+  )
+}
+```
+
+## Renderer Configuration
+
+### createCliRenderer Options
+
+```tsx
+import { createCliRenderer, ConsolePosition } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  // Rendering
+  targetFPS: 60,
+
+  // Behavior
+  exitOnCtrlC: true,        // Set false to handle Ctrl+C yourself
+  autoFocus: true,          // Auto-focus elements on click (default: true)
+  useMouse: true,           // Enable mouse support (default: true)
+
+  // Debug console
+  consoleOptions: {
+    position: ConsolePosition.BOTTOM,
+    sizePercent: 30,
+    startInDebugMode: false,
+  },
+
+  // Cleanup
+  onDestroy: () => {
+    // Cleanup code
+  },
+})
+```
+
+## Building for Distribution
+
+### Bundling with Bun
+
+```typescript
+// build.ts
+await Bun.build({
+  entrypoints: ["./src/index.tsx"],
+  outdir: "./dist",
+  target: "bun",
+  minify: true,
+})
+```
+
+Run: `bun run build.ts`
+
+### Creating Executables
+
+```typescript
+// build.ts
+await Bun.build({
+  entrypoints: ["./src/index.tsx"],
+  outdir: "./dist",
+  target: "bun",
+  compile: {
+    target: "bun-darwin-arm64",  // or bun-linux-x64, etc.
+    outfile: "my-app",
+  },
+})
+```
+
+## Environment Variables
+
+Create `.env` for development:
+
+```env
+# Debug settings
+OTUI_SHOW_STATS=false
+SHOW_CONSOLE=false
+
+# App settings
+API_URL=https://api.example.com
+```
+
+Bun auto-loads `.env` files. Access via `process.env`:
+
+```tsx
+const apiUrl = process.env.API_URL
+```
+
+## React DevTools
+
+OpenTUI React supports React DevTools for debugging.
+
+### Setup
+
+1. Install DevTools as a dev dependency (must use version 7):
+   ```bash
+   bun add react-devtools-core@7 -d
+   ```
+
+2. Run DevTools standalone app:
+   ```bash
+   npx react-devtools@7
+   ```
+
+3. Start your app with `DEV=true` environment variable:
+   ```bash
+   DEV=true bun run src/index.tsx
+   ```
+
+**Important**: Auto-connect to DevTools ONLY happens when `DEV=true` is set. Without this environment variable, the DevTools connection code is not loaded.
+
+### How It Works
+
+OpenTUI checks for `process.env["DEV"] === "true"` at startup. When true, it dynamically imports `react-devtools-core` and connects to the standalone DevTools app.
+
+## Testing Configuration
+
+### Test Setup
+
+```typescript
+// src/test-utils.tsx
+import { createTestRenderer } from "@opentui/core/testing"
+import { createRoot } from "@opentui/react"
+
+export async function renderForTest(
+  element: React.ReactElement,
+  options = { width: 80, height: 24 }
+) {
+  const testSetup = await createTestRenderer(options)
+  createRoot(testSetup.renderer).render(element)
+  return testSetup
+}
+```
+
+### Test Example
+
+```typescript
+// src/components/Counter.test.tsx
+import { test, expect } from "bun:test"
+import { renderForTest } from "../test-utils"
+import { Counter } from "./Counter"
+
+test("Counter renders initial value", async () => {
+  const { snapshot } = await renderForTest(<Counter initialValue={5} />)
+  expect(snapshot()).toContain("Count: 5")
+})
+```
+
+## Common Issues
+
+### JSX Types Not Working
+
+Ensure `jsxImportSource` is set:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react"
+  }
+}
+```
+
+### React Version Mismatch
+
+Ensure React 19+:
+
+```bash
+bun install react@19 @types/react@19
+```
+
+### Module Resolution Errors
+
+Use `moduleResolution: "bundler"` for Bun compatibility.
diff --git a/.agents/skills/opentui/references/react/gotchas.md b/.agents/skills/opentui/references/react/gotchas.md
new file mode 100644
index 0000000..0cd554c
--- /dev/null
+++ b/.agents/skills/opentui/references/react/gotchas.md
@@ -0,0 +1,443 @@
+# React Gotchas
+
+## Critical
+
+### Never use `process.exit()` directly
+
+**This is the most common mistake.** Using `process.exit()` leaves the terminal in a broken state (cursor hidden, raw mode, alternate screen).
+
+```tsx
+// WRONG - Terminal left in broken state
+process.exit(0)
+
+// CORRECT - Use renderer.destroy()
+import { useRenderer } from "@opentui/react"
+
+function App() {
+  const renderer = useRenderer()
+
+  const handleExit = () => {
+    renderer.destroy()  // Cleans up and exits properly
+  }
+}
+```
+
+`renderer.destroy()` restores the terminal (exits alternate screen, restores cursor, etc.) before exiting.
+
+### Signal Handling
+
+OpenTUI automatically handles cleanup for these signals:
+- `SIGINT` (Ctrl+C), `SIGTERM`, `SIGQUIT` - Standard termination
+- `SIGHUP` - Terminal closed/hangup
+- `SIGBREAK` - Ctrl+Break (Windows)
+- `SIGPIPE` - Broken pipe (output closed)
+- `SIGBUS`, `SIGFPE` - Hardware errors
+
+This ensures terminal state is restored even on unexpected termination. If you need custom signal handling, use `exitOnCtrlC: false` and handle signals yourself while still calling `renderer.destroy()`.
+
+## JSX Configuration
+
+### Missing jsxImportSource
+
+**Symptom**: JSX elements have wrong types, components don't render
+
+```
+// Error: Property 'text' does not exist on type 'JSX.IntrinsicElements'
+```
+
+**Fix**: Configure tsconfig.json:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react"
+  }
+}
+```
+
+### HTML Elements vs TUI Elements
+
+OpenTUI's JSX elements are **not** HTML elements:
+
+```tsx
+// WRONG - These are HTML concepts
+<div>Not supported</div>
+<button>Not supported</button>
+<span>Only works inside <text></span>
+
+// CORRECT - OpenTUI elements
+<box>Container</box>
+<text>Display text</text>
+<text><span>Inline styled</span></text>
+```
+
+## Component Issues
+
+### Text Modifiers Outside Text
+
+Text modifiers only work inside `<text>`:
+
+```tsx
+// WRONG
+<box>
+  <strong>This won't work</strong>
+</box>
+
+// CORRECT
+<box>
+  <text>
+    <strong>This works</strong>
+  </text>
+</box>
+```
+
+### Focus Not Working
+
+Components must be explicitly focused:
+
+```tsx
+// WRONG - Won't receive keyboard input
+<input placeholder="Type here..." />
+
+// CORRECT
+<input placeholder="Type here..." focused />
+
+// Or manage focus state
+const [isFocused, setIsFocused] = useState(true)
+<input placeholder="Type here..." focused={isFocused} />
+```
+
+### Select Not Responding
+
+Select requires focus and proper options format:
+
+```tsx
+// WRONG - Missing required properties
+<select options={["a", "b", "c"]} />
+
+// CORRECT
+<select
+  options={[
+    { name: "Option A", description: "First option", value: "a" },
+    { name: "Option B", description: "Second option", value: "b" },
+  ]}
+  onSelect={(index, option) => {
+    // Called when Enter is pressed
+    console.log("Selected:", option.name)
+  }}
+  focused
+/>
+```
+
+### Select Events Confusion
+
+Remember: `onSelect` fires on Enter (selection confirmed), `onChange` fires on navigation:
+
+```tsx
+// WRONG - expecting onChange to fire on Enter
+<select
+  options={options}
+  onChange={(i, opt) => submitForm(opt)}  // This fires on arrow keys!
+/>
+
+// CORRECT
+<select
+  options={options}
+  onSelect={(i, opt) => submitForm(opt)}   // Enter pressed - submit
+  onChange={(i, opt) => showPreview(opt)}  // Arrow keys - preview
+/>
+```
+
+## Hook Issues
+
+### useKeyboard Not Firing
+
+Multiple `useKeyboard` hooks can conflict:
+
+```tsx
+// Both handlers fire - may cause issues
+function App() {
+  useKeyboard((key) => { /* parent handler */ })
+  return <ChildWithKeyboard />
+}
+
+function ChildWithKeyboard() {
+  useKeyboard((key) => { /* child handler */ })
+  return <text>Child</text>
+}
+```
+
+**Solution**: Use a single keyboard handler or implement event stopping:
+
+```tsx
+function App() {
+  const [handled, setHandled] = useState(false)
+
+  useKeyboard((key) => {
+    if (handled) {
+      setHandled(false)
+      return
+    }
+    // Handle at app level
+  })
+
+  return <Child onKeyHandled={() => setHandled(true)} />
+}
+```
+
+### useEffect Cleanup
+
+Always clean up intervals and listeners:
+
+```tsx
+// WRONG - Memory leak
+useEffect(() => {
+  setInterval(() => updateData(), 1000)
+}, [])
+
+// CORRECT
+useEffect(() => {
+  const interval = setInterval(() => updateData(), 1000)
+  return () => clearInterval(interval)  // Cleanup!
+}, [])
+```
+
+## Styling Issues
+
+### Colors Not Applying
+
+Check color format:
+
+```tsx
+// CORRECT formats
+<text fg="#FF0000">Red</text>
+<text fg="red">Red</text>
+<box backgroundColor="#1a1a2e">Box</box>
+
+// WRONG
+<text fg="FF0000">Missing #</text>
+<text color="#FF0000">Wrong prop name (use fg)</text>
+```
+
+### Layout Not Working
+
+Ensure parent has dimensions:
+
+```tsx
+// WRONG - Parent has no height
+<box flexDirection="column">
+  <box flexGrow={1}>Won't grow</box>
+</box>
+
+// CORRECT
+<box flexDirection="column" height="100%">
+  <box flexGrow={1}>Will grow</box>
+</box>
+```
+
+### Percentage Widths Not Working
+
+Parent must have explicit dimensions:
+
+```tsx
+// WRONG
+<box>
+  <box width="50%">Won't work</box>
+</box>
+
+// CORRECT
+<box width="100%">
+  <box width="50%">Works</box>
+</box>
+```
+
+## Performance Issues
+
+### Too Many Re-renders
+
+Avoid inline objects/functions in props:
+
+```tsx
+// WRONG - New object every render
+<box style={{ padding: 2 }}>Content</box>
+
+// BETTER - Use direct props
+<box padding={2}>Content</box>
+
+// OR memoize style objects
+const style = useMemo(() => ({ padding: 2 }), [])
+<box style={style}>Content</box>
+```
+
+### Heavy Components
+
+Use React.memo for expensive components:
+
+```tsx
+const ExpensiveList = React.memo(function ExpensiveList({
+  items
+}: {
+  items: Item[]
+}) {
+  return (
+    <box flexDirection="column">
+      {items.map(item => (
+        <text key={item.id}>{item.name}</text>
+      ))}
+    </box>
+  )
+})
+```
+
+### State Updates During Render
+
+Don't update state during render:
+
+```tsx
+// WRONG
+function Component({ value }: { value: number }) {
+  const [count, setCount] = useState(0)
+
+  // This causes infinite loop!
+  if (value > 10) {
+    setCount(value)
+  }
+
+  return <text>{count}</text>
+}
+
+// CORRECT
+function Component({ value }: { value: number }) {
+  const [count, setCount] = useState(0)
+
+  useEffect(() => {
+    if (value > 10) {
+      setCount(value)
+    }
+  }, [value])
+
+  return <text>{count}</text>
+}
+```
+
+## Debugging
+
+### Console Not Visible
+
+OpenTUI captures console output. Show the overlay:
+
+```tsx
+import { useRenderer } from "@opentui/react"
+import { useEffect } from "react"
+
+function App() {
+  const renderer = useRenderer()
+
+  useEffect(() => {
+    renderer.console.show()
+    console.log("Now you can see this!")
+  }, [renderer])
+
+  return <box>{/* ... */}</box>
+}
+```
+
+### Component Not Rendering
+
+Check if component is in the tree:
+
+```tsx
+// WRONG - Conditional returns nothing
+function MaybeComponent({ show }: { show: boolean }) {
+  if (!show) return  // Returns undefined!
+  return <text>Visible</text>
+}
+
+// CORRECT
+function MaybeComponent({ show }: { show: boolean }) {
+  if (!show) return null  // Explicit null
+  return <text>Visible</text>
+}
+```
+
+### Events Not Firing
+
+Check event handler names:
+
+```tsx
+// WRONG
+<box onClick={() => {}}>Click</box>  // No onClick in TUI
+
+// CORRECT
+<box onMouseDown={() => {}}>Click</box>
+<box onMouseUp={() => {}}>Click</box>
+```
+
+## Runtime Issues
+
+### Use Bun, Not Node
+
+```bash
+# WRONG
+node src/index.tsx
+npm run start
+
+# CORRECT
+bun run src/index.tsx
+bun run start
+```
+
+### Async Top-level
+
+Bun supports top-level await, but be careful:
+
+```tsx
+// index.tsx - This works in Bun
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+
+// If you need to handle errors
+try {
+  const renderer = await createCliRenderer()
+  createRoot(renderer).render(<App />)
+} catch (error) {
+  console.error("Failed to initialize:", error)
+  process.exit(1)
+}
+```
+
+## Common Error Messages
+
+### "Cannot read properties of undefined (reading 'root')"
+
+Renderer not initialized:
+
+```tsx
+// WRONG
+const renderer = createCliRenderer()  // Missing await!
+createRoot(renderer).render(<App />)
+
+// CORRECT
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+### "Invalid hook call"
+
+Hooks called outside component:
+
+```tsx
+// WRONG
+const dimensions = useTerminalDimensions()  // Outside component!
+
+function App() {
+  return <text>{dimensions.width}</text>
+}
+
+// CORRECT
+function App() {
+  const dimensions = useTerminalDimensions()
+  return <text>{dimensions.width}</text>
+}
+```
diff --git a/.agents/skills/opentui/references/react/patterns.md b/.agents/skills/opentui/references/react/patterns.md
new file mode 100644
index 0000000..eb71578
--- /dev/null
+++ b/.agents/skills/opentui/references/react/patterns.md
@@ -0,0 +1,501 @@
+# React Patterns
+
+## State Management
+
+### Local State with useState
+
+```tsx
+import { useState } from "react"
+
+function Counter() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <box flexDirection="row" gap={2}>
+      <text>Count: {count}</text>
+      <box border onMouseDown={() => setCount(c => c - 1)}>
+        <text>-</text>
+      </box>
+      <box border onMouseDown={() => setCount(c => c + 1)}>
+        <text>+</text>
+      </box>
+    </box>
+  )
+}
+```
+
+### Complex State with useReducer
+
+```tsx
+import { useReducer } from "react"
+
+type State = {
+  items: string[]
+  selectedIndex: number
+}
+
+type Action =
+  | { type: "ADD_ITEM"; item: string }
+  | { type: "REMOVE_ITEM"; index: number }
+  | { type: "SELECT"; index: number }
+
+function reducer(state: State, action: Action): State {
+  switch (action.type) {
+    case "ADD_ITEM":
+      return { ...state, items: [...state.items, action.item] }
+    case "REMOVE_ITEM":
+      return {
+        ...state,
+        items: state.items.filter((_, i) => i !== action.index),
+      }
+    case "SELECT":
+      return { ...state, selectedIndex: action.index }
+  }
+}
+
+function ItemList() {
+  const [state, dispatch] = useReducer(reducer, {
+    items: [],
+    selectedIndex: 0,
+  })
+
+  // Use state and dispatch...
+}
+```
+
+### Context for Global State
+
+```tsx
+import { createContext, useContext, useState, ReactNode } from "react"
+
+type Theme = "dark" | "light"
+
+const ThemeContext = createContext<{
+  theme: Theme
+  setTheme: (theme: Theme) => void
+} | null>(null)
+
+function ThemeProvider({ children }: { children: ReactNode }) {
+  const [theme, setTheme] = useState<Theme>("dark")
+
+  return (
+    <ThemeContext.Provider value={{ theme, setTheme }}>
+      {children}
+    </ThemeContext.Provider>
+  )
+}
+
+function useTheme() {
+  const context = useContext(ThemeContext)
+  if (!context) throw new Error("useTheme must be used within ThemeProvider")
+  return context
+}
+
+// Usage
+function App() {
+  return (
+    <ThemeProvider>
+      <ThemedBox />
+    </ThemeProvider>
+  )
+}
+
+function ThemedBox() {
+  const { theme } = useTheme()
+  return (
+    <box backgroundColor={theme === "dark" ? "#1a1a2e" : "#f0f0f0"}>
+      <text fg={theme === "dark" ? "#fff" : "#000"}>
+        Current theme: {theme}
+      </text>
+    </box>
+  )
+}
+```
+
+## Focus Management
+
+### Focus State
+
+```tsx
+import { useState } from "react"
+import { useKeyboard } from "@opentui/react"
+
+function FocusableForm() {
+  const [focusIndex, setFocusIndex] = useState(0)
+  const fields = ["name", "email", "message"]
+
+  useKeyboard((key) => {
+    if (key.name === "tab") {
+      setFocusIndex(i => (i + 1) % fields.length)
+    }
+    if (key.shift && key.name === "tab") {
+      setFocusIndex(i => (i - 1 + fields.length) % fields.length)
+    }
+  })
+
+  return (
+    <box flexDirection="column" gap={1}>
+      {fields.map((field, i) => (
+        <input
+          key={field}
+          placeholder={`Enter ${field}...`}
+          focused={i === focusIndex}
+        />
+      ))}
+    </box>
+  )
+}
+```
+
+### Ref-based Focus
+
+```tsx
+import { useRef, useEffect } from "react"
+
+function AutoFocusInput() {
+  const inputRef = useRef<any>(null)
+
+  useEffect(() => {
+    // Focus on mount
+    inputRef.current?.focus()
+  }, [])
+
+  return <input ref={inputRef} placeholder="Auto-focused" />
+}
+```
+
+## Keyboard Navigation
+
+### Global Shortcuts
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/react"
+
+function App() {
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    // Quit on Escape or Ctrl+C - use renderer.destroy(), never process.exit()
+    if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+      renderer.destroy()
+      return
+    }
+
+    // Toggle help on ?
+    if (key.name === "?" || (key.shift && key.name === "/")) {
+      setShowHelp(h => !h)
+    }
+
+    // Vim-style navigation
+    if (key.name === "j") moveDown()
+    if (key.name === "k") moveUp()
+  })
+
+  return <box>{/* ... */}</box>
+}
+```
+
+### Component-level Shortcuts
+
+```tsx
+function Editor() {
+  const [mode, setMode] = useState<"normal" | "insert">("normal")
+
+  useKeyboard((key) => {
+    if (mode === "normal") {
+      if (key.name === "i") setMode("insert")
+      if (key.name === "escape") setMode("normal")
+    } else {
+      if (key.name === "escape") setMode("normal")
+      // Handle text input in insert mode
+    }
+  })
+
+  return (
+    <box>
+      <text>Mode: {mode}</text>
+      <textarea focused={mode === "insert"} />
+    </box>
+  )
+}
+```
+
+## Form Handling
+
+### Controlled Inputs
+
+```tsx
+import { useState } from "react"
+
+function LoginForm() {
+  const [username, setUsername] = useState("")
+  const [password, setPassword] = useState("")
+
+  const handleSubmit = () => {
+    console.log("Login:", { username, password })
+  }
+
+  return (
+    <box flexDirection="column" gap={1} padding={2} border>
+      <text>Login</text>
+
+      <box flexDirection="row" gap={1}>
+        <text>Username:</text>
+        <input
+          value={username}
+          onChange={setUsername}
+          width={20}
+        />
+      </box>
+
+      <box flexDirection="row" gap={1}>
+        <text>Password:</text>
+        <input
+          value={password}
+          onChange={setPassword}
+          width={20}
+        />
+      </box>
+
+      <box border onMouseDown={handleSubmit}>
+        <text>Submit</text>
+      </box>
+    </box>
+  )
+}
+```
+
+### Form Validation
+
+```tsx
+function ValidatedForm() {
+  const [email, setEmail] = useState("")
+  const [error, setError] = useState("")
+
+  const validateEmail = (value: string) => {
+    if (!value.includes("@")) {
+      setError("Invalid email address")
+    } else {
+      setError("")
+    }
+    setEmail(value)
+  }
+
+  return (
+    <box flexDirection="column" gap={1}>
+      <input
+        value={email}
+        onChange={validateEmail}
+        placeholder="Email"
+      />
+      {error && <text fg="red">{error}</text>}
+    </box>
+  )
+}
+```
+
+## Responsive Design
+
+### Terminal-size Responsive
+
+```tsx
+import { useTerminalDimensions } from "@opentui/react"
+
+function ResponsiveLayout() {
+  const { width } = useTerminalDimensions()
+
+  // Stack vertically on narrow terminals
+  const isNarrow = width < 80
+
+  return (
+    <box flexDirection={isNarrow ? "column" : "row"}>
+      <box flexGrow={isNarrow ? 0 : 1} height={isNarrow ? 10 : "100%"}>
+        <text>Sidebar</text>
+      </box>
+      <box flexGrow={1}>
+        <text>Main Content</text>
+      </box>
+    </box>
+  )
+}
+```
+
+### Dynamic Layouts
+
+```tsx
+function DynamicGrid({ items }: { items: string[] }) {
+  const { width } = useTerminalDimensions()
+  const columns = Math.max(1, Math.floor(width / 20))
+
+  return (
+    <box flexDirection="row" flexWrap="wrap">
+      {items.map((item, i) => (
+        <box key={i} width={`${100 / columns}%`} padding={1}>
+          <text>{item}</text>
+        </box>
+      ))}
+    </box>
+  )
+}
+```
+
+## Async Data Loading
+
+### Loading States
+
+```tsx
+import { useState, useEffect } from "react"
+
+function DataDisplay() {
+  const [data, setData] = useState<string[] | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    async function load() {
+      try {
+        const response = await fetch("https://api.example.com/data")
+        const json = await response.json()
+        setData(json.items)
+      } catch (e) {
+        setError(e instanceof Error ? e.message : "Unknown error")
+      } finally {
+        setLoading(false)
+      }
+    }
+    load()
+  }, [])
+
+  if (loading) {
+    return <text>Loading...</text>
+  }
+
+  if (error) {
+    return <text fg="red">Error: {error}</text>
+  }
+
+  return (
+    <box flexDirection="column">
+      {data?.map((item, i) => (
+        <text key={i}>{item}</text>
+      ))}
+    </box>
+  )
+}
+```
+
+## Animation Patterns
+
+### Simple Animations
+
+```tsx
+import { useState, useEffect } from "react"
+import { useTimeline } from "@opentui/react"
+
+function ProgressBar() {
+  const [progress, setProgress] = useState(0)
+
+  const timeline = useTimeline({ duration: 3000 })
+
+  useEffect(() => {
+    timeline.add(
+      { value: 0 },
+      {
+        value: 100,
+        duration: 3000,
+        ease: "linear",
+        onUpdate: (anim) => {
+          setProgress(Math.round(anim.targets[0].value))
+        },
+      }
+    )
+  }, [])
+
+  return (
+    <box flexDirection="column" gap={1}>
+      <text>Progress: {progress}%</text>
+      <box width={50} height={1} backgroundColor="#333">
+        <box
+          width={`${progress}%`}
+          height={1}
+          backgroundColor="#00ff00"
+        />
+      </box>
+    </box>
+  )
+}
+```
+
+### Interval-based Updates
+
+```tsx
+function Clock() {
+  const [time, setTime] = useState(new Date())
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setTime(new Date())
+    }, 1000)
+
+    return () => clearInterval(interval)
+  }, [])
+
+  return <text>{time.toLocaleTimeString()}</text>
+}
+```
+
+## Component Composition
+
+### Render Props
+
+```tsx
+function Focusable({
+  children
+}: {
+  children: (focused: boolean) => React.ReactNode
+}) {
+  const [focused, setFocused] = useState(false)
+
+  return (
+    <box
+      onMouseDown={() => setFocused(true)}
+      onMouseUp={() => setFocused(false)}
+    >
+      {children(focused)}
+    </box>
+  )
+}
+
+// Usage
+<Focusable>
+  {(focused) => (
+    <text fg={focused ? "#00ff00" : "#ffffff"}>
+      {focused ? "Focused!" : "Click me"}
+    </text>
+  )}
+</Focusable>
+```
+
+### Higher-Order Components
+
+```tsx
+function withBorder<P extends object>(
+  Component: React.ComponentType<P>,
+  borderStyle: string = "single"
+) {
+  return function BorderedComponent(props: P) {
+    return (
+      <box border borderStyle={borderStyle} padding={1}>
+        <Component {...props} />
+      </box>
+    )
+  }
+}
+
+// Usage
+const BorderedText = withBorder(({ content }: { content: string }) => (
+  <text>{content}</text>
+))
+
+<BorderedText content="Hello!" />
+```
diff --git a/.agents/skills/opentui/references/solid/REFERENCE.md b/.agents/skills/opentui/references/solid/REFERENCE.md
new file mode 100644
index 0000000..3f4763e
--- /dev/null
+++ b/.agents/skills/opentui/references/solid/REFERENCE.md
@@ -0,0 +1,201 @@
+# OpenTUI Solid (@opentui/solid)
+
+A SolidJS reconciler for building terminal user interfaces with fine-grained reactivity. Get optimal performance with Solid's signal-based approach.
+
+## Overview
+
+OpenTUI Solid provides:
+- **Custom reconciler**: Solid components render to OpenTUI renderables
+- **JSX intrinsics**: `<text>`, `<box>`, `<input>`, etc.
+- **Hooks**: `useKeyboard`, `useRenderer`, `useTimeline`, etc.
+- **Fine-grained reactivity**: Only what changes re-renders
+- **Portal & Dynamic**: Advanced composition primitives
+
+## When to Use Solid
+
+Use the Solid reconciler when:
+- You want optimal re-rendering performance
+- You prefer signal-based reactivity
+- You need fine-grained control over updates
+- Building performance-critical applications
+- You already know SolidJS
+
+## When NOT to Use Solid
+
+| Scenario | Use Instead |
+|----------|-------------|
+| Team knows React, not Solid | `@opentui/react` |
+| Maximum control needed | `@opentui/core` |
+| Smallest bundle size | `@opentui/core` |
+| Building a framework/library | `@opentui/core` |
+
+## Quick Start
+
+```bash
+bunx create-tui@latest -t solid my-app
+cd my-app && bun install
+```
+
+The CLI creates the `my-app` directory for you - it must **not already exist**.
+
+Options: `--no-git` (skip git init), `--no-install` (skip bun install)
+
+**Agent guidance**: Always use autonomous mode with `-t <template>` flag. Never use interactive mode (`bunx create-tui@latest my-app` without `-t`) as it requires user prompts that agents cannot respond to.
+
+Or manually:
+
+```bash
+bun install @opentui/solid @opentui/core solid-js
+```
+
+```tsx
+import { render } from "@opentui/solid"
+import { createSignal } from "solid-js"
+
+function App() {
+  const [count, setCount] = createSignal(0)
+
+  return (
+    <box border padding={2}>
+      <text>Count: {count()}</text>
+      <box
+        border
+        onMouseDown={() => setCount(c => c + 1)}
+      >
+        <text>Click me!</text>
+      </box>
+    </box>
+  )
+}
+
+render(() => <App />)
+```
+
+## Core Concepts
+
+### Signals
+
+Solid uses signals for reactive state:
+
+```tsx
+import { createSignal, createEffect } from "solid-js"
+
+function Counter() {
+  const [count, setCount] = createSignal(0)
+
+  // Effect runs when count changes
+  createEffect(() => {
+    console.log("Count is now:", count())
+  })
+
+  return <text>Count: {count()}</text>
+}
+```
+
+### JSX Elements
+
+Solid maps JSX intrinsic elements to OpenTUI renderables:
+
+```tsx
+// Note: Some use underscores (Solid convention)
+<text>Hello</text>           // TextRenderable
+<box border>Content</box>    // BoxRenderable
+<input placeholder="..." />  // InputRenderable
+<select options={[...]} />   // SelectRenderable
+<tab_select />               // TabSelectRenderable (underscore!)
+<ascii_font />               // ASCIIFontRenderable (underscore!)
+<line_number />              // LineNumberRenderable (underscore!)
+```
+
+### Text Modifiers
+
+Inside `<text>`, use modifier elements:
+
+```tsx
+<text>
+  <strong>Bold</strong>, <em>italic</em>, and <u>underlined</u>
+  <span fg="red">Colored text</span>
+  <br />
+  New line with <a href="https://example.com">link</a>
+</text>
+```
+
+## Available Components
+
+### Layout & Display
+- `<text>` - Styled text content
+- `<box>` - Container with borders and layout
+- `<scrollbox>` - Scrollable container
+- `<ascii_font>` - ASCII art text (note underscore)
+
+### Input
+- `<input>` - Single-line text input
+- `<textarea>` - Multi-line text input
+- `<select>` - List selection
+- `<tab_select>` - Tab-based selection (note underscore)
+
+### Code & Diff
+- `<code>` - Syntax-highlighted code
+- `<line_number>` - Code with line numbers (note underscore)
+- `<diff>` - Unified or split diff viewer
+
+### Text Modifiers (inside `<text>`)
+- `<span>` - Inline styled text
+- `<strong>`, `<b>` - Bold
+- `<em>`, `<i>` - Italic
+- `<u>` - Underline
+- `<br>` - Line break
+- `<a>` - Link
+
+## Special Components
+
+### Portal
+
+Render children to a different mount node:
+
+```tsx
+import { Portal } from "@opentui/solid"
+
+function Overlay() {
+  return (
+    <Portal mount={renderer.root}>
+      <box position="absolute" left={10} top={5} border>
+        <text>Overlay content</text>
+      </box>
+    </Portal>
+  )
+}
+```
+
+### Dynamic
+
+Render components dynamically:
+
+```tsx
+import { Dynamic } from "@opentui/solid"
+
+function DynamicInput(props: { multiline: boolean }) {
+  return (
+    <Dynamic
+      component={props.multiline ? "textarea" : "input"}
+      placeholder="Enter text..."
+    />
+  )
+}
+```
+
+## In This Reference
+
+- [Configuration](./configuration.md) - Project setup, tsconfig, bunfig, building
+- [API](./api.md) - Components, hooks, render function
+- [Patterns](./patterns.md) - Signals, stores, control flow, composition
+- [Gotchas](./gotchas.md) - Common issues, debugging, limitations
+
+## See Also
+
+- [Core](../core/REFERENCE.md) - Underlying imperative API
+- [React](../react/REFERENCE.md) - Alternative declarative approach
+- [Components](../components/REFERENCE.md) - Component reference by category
+- [Layout](../layout/REFERENCE.md) - Flexbox layout system
+- [Keyboard](../keyboard/REFERENCE.md) - Input handling and shortcuts
+- [Testing](../testing/REFERENCE.md) - Test renderer and snapshots
diff --git a/.agents/skills/opentui/references/solid/api.md b/.agents/skills/opentui/references/solid/api.md
new file mode 100644
index 0000000..9ad55cc
--- /dev/null
+++ b/.agents/skills/opentui/references/solid/api.md
@@ -0,0 +1,564 @@
+# Solid API Reference
+
+## Rendering
+
+### render(node, rendererOrConfig?)
+
+Renders a Solid component tree into a CLI renderer.
+
+```tsx
+import { render } from "@opentui/solid"
+
+// Simple usage - creates renderer automatically
+render(() => <App />)
+
+// With config
+render(() => <App />, {
+  exitOnCtrlC: false,
+  targetFPS: 60,
+})
+
+// With existing renderer
+import { createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+render(() => <App />, renderer)
+```
+
+### testRender(node, options?)
+
+Create a test renderer for snapshots and tests.
+
+```tsx
+import { testRender } from "@opentui/solid"
+
+const testSetup = await testRender(() => <App />, {
+  width: 40,
+  height: 10,
+})
+
+// Access test utilities
+testSetup.snapshot()  // Get current render
+testSetup.renderer    // Access renderer
+```
+
+### extend(components)
+
+Register custom renderables as JSX intrinsic elements.
+
+```tsx
+import { extend } from "@opentui/solid"
+import { CustomRenderable } from "./custom"
+
+extend({
+  custom: CustomRenderable,
+})
+
+// Now usable in JSX
+<custom prop="value" />
+```
+
+### getComponentCatalogue()
+
+Returns the current component catalogue.
+
+```tsx
+import { getComponentCatalogue } from "@opentui/solid"
+
+const catalogue = getComponentCatalogue()
+console.log(Object.keys(catalogue))
+```
+
+## Hooks
+
+### useRenderer()
+
+Access the OpenTUI renderer instance.
+
+```tsx
+import { useRenderer } from "@opentui/solid"
+import { onMount } from "solid-js"
+
+function App() {
+  const renderer = useRenderer()
+
+  onMount(() => {
+    console.log(`Terminal: ${renderer.width}x${renderer.height}`)
+    renderer.console.show()
+
+    // Access theme mode (dark/light based on terminal settings)
+    console.log(`Theme: ${renderer.themeMode}`)  // "dark" | "light" | null
+  })
+
+  return <text>Hello</text>
+}
+
+// Listen for theme mode changes
+function ThemedApp() {
+  const renderer = useRenderer()
+  const [theme, setTheme] = createSignal(renderer.themeMode ?? "dark")
+
+  onMount(() => {
+    renderer.on("theme_mode", (mode: "dark" | "light") => setTheme(mode))
+  })
+
+  return (
+    <box backgroundColor={theme() === "dark" ? "#1a1a2e" : "#ffffff"}>
+      <text fg={theme() === "dark" ? "#fff" : "#000"}>
+        Current theme: {theme()}
+      </text>
+    </box>
+  )
+}
+```
+
+### useKeyboard(handler, options?)
+
+Handle keyboard events.
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/solid"
+
+function App() {
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()  // Never use process.exit() directly!
+    }
+    if (key.ctrl && key.name === "s") {
+      saveDocument()
+    }
+  })
+
+  return <text>Press ESC to exit</text>
+}
+
+// With release events
+function GameControls() {
+  const [pressed, setPressed] = createSignal(new Set<string>())
+
+  useKeyboard(
+    (event) => {
+      setPressed(keys => {
+        const newKeys = new Set(keys)
+        if (event.eventType === "release") {
+          newKeys.delete(event.name)
+        } else {
+          newKeys.add(event.name)
+        }
+        return newKeys
+      })
+    },
+    { release: true }
+  )
+
+  return <text>Pressed: {Array.from(pressed()).join(", ")}</text>
+}
+```
+
+### usePaste(handler)
+
+Handle paste events. Receives a `PasteEvent` with raw bytes.
+
+```tsx
+import { usePaste } from "@opentui/solid"
+import { decodePasteBytes } from "@opentui/core"
+
+function PasteHandler() {
+  usePaste((event) => {
+    const text = decodePasteBytes(event.bytes)
+    console.log("Pasted:", text)
+  })
+
+  return <text>Paste something</text>
+}
+```
+
+### onResize(callback)
+
+Handle terminal resize events.
+
+```tsx
+import { onResize } from "@opentui/solid"
+
+function App() {
+  onResize((width, height) => {
+    console.log(`Resized to ${width}x${height}`)
+  })
+
+  return <text>Resize the terminal</text>
+}
+```
+
+### useTerminalDimensions()
+
+Get reactive terminal dimensions.
+
+```tsx
+import { useTerminalDimensions } from "@opentui/solid"
+
+function ResponsiveLayout() {
+  const dimensions = useTerminalDimensions()
+
+  return (
+    <box flexDirection={dimensions().width > 80 ? "row" : "column"}>
+      <text>Width: {dimensions().width}</text>
+      <text>Height: {dimensions().height}</text>
+    </box>
+  )
+}
+```
+
+### onFocus(callback) / onBlur(callback)
+
+Handle terminal window focus and blur events. Solid-only hooks.
+
+```tsx
+import { onFocus, onBlur } from "@opentui/solid"
+
+function App() {
+  onFocus(() => {
+    console.log("Terminal window gained focus")
+  })
+
+  onBlur(() => {
+    console.log("Terminal window lost focus")
+  })
+
+  return <text>Focus/blur tracking</text>
+}
+```
+
+These hooks fire when the terminal emulator window gains or loses operating system focus. The renderer deduplicates events (won't re-emit the same focus state).
+
+### useSelectionHandler(handler)
+
+Handle text selection events. Fires when the user finishes a mouse selection (mouse-up). Solid-only hook - React does not have this.
+
+```tsx
+import { useSelectionHandler } from "@opentui/solid"
+import type { Selection } from "@opentui/core"
+
+function SelectableText() {
+  const [selected, setSelected] = createSignal("")
+  const renderer = useRenderer()
+
+  useSelectionHandler((selection: Selection) => {
+    const text = selection.getSelectedText()
+    if (text) {
+      setSelected(text)
+      renderer.copyToClipboardOSC52(text)
+    }
+  })
+
+  return (
+    <box flexDirection="column">
+      <text selectable>Select this text with your mouse</text>
+      <text fg="#888">Selected: {selected()}</text>
+    </box>
+  )
+}
+```
+
+The `Selection` object aggregates selected text from all selectable renderables in the tree. See `keyboard/REFERENCE.md` (selection) for full details on the selection API and traversal model.
+
+### useTimeline(options?)
+
+Create animations with the timeline system.
+
+```tsx
+import { useTimeline } from "@opentui/solid"
+import { createSignal, onMount } from "solid-js"
+
+function AnimatedBox() {
+  const [width, setWidth] = createSignal(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+    loop: false,
+  })
+
+  onMount(() => {
+    timeline.add(
+      { width: 0 },
+      {
+        width: 50,
+        duration: 2000,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setWidth(Math.round(anim.targets[0].width))
+        },
+      }
+    )
+  })
+
+  return <box style={{ width: width(), height: 3, backgroundColor: "#6a5acd" }} />
+}
+```
+
+## Components
+
+### Text Component
+
+```tsx
+<text
+  content="Hello"           // Or use children
+  fg="#FFFFFF"              // Foreground color
+  bg="#000000"              // Background color
+  selectable={true}         // Allow text selection
+>
+  {/* Use nested modifier tags for styling */}
+  <span fg="red">Red</span>
+  <strong>Bold</strong>
+  <em>Italic</em>
+  <u>Underline</u>
+  <br />
+  <a href="https://...">Link</a>
+</text>
+```
+
+> **Note**: Do NOT use `bold`, `italic`, `underline` as props on `<text>`. Use nested modifier tags like `<strong>`, `<em>`, `<u>` instead.
+
+### Box Component
+
+```tsx
+<box
+  // Borders
+  border                    // Enable border
+  borderStyle="single"      // single | double | rounded | bold
+  borderColor="#FFFFFF"
+  title="Title"
+  titleAlignment="center"   // left | center | right
+
+  // Colors
+  backgroundColor="#1a1a2e"
+
+  // Layout
+  flexDirection="row"
+  justifyContent="center"
+  alignItems="center"
+  gap={2}
+
+  // Spacing
+  padding={2}
+  paddingX={2}              // Horizontal (left + right)
+  paddingY={1}              // Vertical (top + bottom)
+  margin={1}
+  marginX={2}               // Horizontal (left + right)
+  marginY={1}               // Vertical (top + bottom)
+
+  // Dimensions
+  width={40}
+  height={10}
+  flexGrow={1}
+
+  // Focus
+  focusable                 // Allow box to receive focus
+  focused={isFocused()}     // Controlled focus state
+
+  // Events
+  onMouseDown={(e) => {}}
+  onMouseUp={(e) => {}}
+>
+  {children}
+</box>
+```
+
+### Scrollbox Component
+
+```tsx
+<scrollbox
+  focused                   // Enable keyboard scrolling
+  style={{
+    scrollbarOptions: {
+      showArrows: true,
+      trackOptions: {
+        foregroundColor: "#7aa2f7",
+        backgroundColor: "#414868",
+      },
+    },
+  }}
+>
+  <For each={items()}>
+    {(item) => <text>{item}</text>}
+  </For>
+</scrollbox>
+```
+
+### Input Component
+
+```tsx
+<input
+  value={value()}
+  onInput={(newValue) => setValue(newValue)}
+  placeholder="Enter text..."
+  focused
+  width={30}
+/>
+```
+
+### Textarea Component
+
+```tsx
+<textarea
+  value={text()}
+  onInput={(newValue) => setText(newValue)}
+  placeholder="Enter multiple lines..."
+  focused
+  width={40}
+  height={10}
+/>
+```
+
+### Select Component
+
+```tsx
+<select
+  options={[
+    { name: "Option 1", description: "First", value: "1" },
+    { name: "Option 2", description: "Second", value: "2" },
+  ]}
+  onChange={(index, option) => setSelected(option)}
+  selectedIndex={0}
+  focused
+/>
+```
+
+### Tab Select Component (Note: underscore)
+
+```tsx
+<tab_select
+  options={[
+    { name: "Home", description: "Dashboard" },
+    { name: "Settings", description: "Configuration" },
+  ]}
+  onChange={(index, option) => setTab(option)}
+  tabWidth={20}
+  focused
+/>
+```
+
+### ASCII Font Component (Note: underscore)
+
+```tsx
+<ascii_font
+  text="TITLE"
+  font="tiny"               // tiny | block | slick | shade
+  color="#FFFFFF"
+/>
+```
+
+### Code Component
+
+```tsx
+<code
+  code={sourceCode}
+  language="typescript"
+/>
+```
+
+### Line Number Component (Note: underscore)
+
+```tsx
+<line_number
+  code={sourceCode}
+  language="typescript"
+  startLine={1}
+  highlightedLines={[5]}
+/>
+```
+
+### Diff Component
+
+```tsx
+<diff
+  oldCode={originalCode}
+  newCode={modifiedCode}
+  language="typescript"
+  mode="unified"            // unified | split
+  syncScroll                // Sync scroll between split view panes
+/>
+```
+
+## Control Flow
+
+Solid's control flow components work with OpenTUI:
+
+### For
+
+```tsx
+import { For } from "solid-js"
+
+<For each={items()}>
+  {(item, index) => (
+    <box key={index()}>
+      <text>{item.name}</text>
+    </box>
+  )}
+</For>
+```
+
+### Show
+
+```tsx
+import { Show } from "solid-js"
+
+<Show when={isVisible()} fallback={<text>Hidden</text>}>
+  <text>Visible content</text>
+</Show>
+```
+
+### Switch/Match
+
+```tsx
+import { Switch, Match } from "solid-js"
+
+<Switch>
+  <Match when={status() === "loading"}>
+    <text>Loading...</text>
+  </Match>
+  <Match when={status() === "error"}>
+    <text fg="red">Error!</text>
+  </Match>
+  <Match when={status() === "success"}>
+    <text fg="green">Success!</text>
+  </Match>
+</Switch>
+```
+
+### Index
+
+```tsx
+import { Index } from "solid-js"
+
+<Index each={items()}>
+  {(item, index) => (
+    <text>{index}: {item().name}</text>
+  )}
+</Index>
+```
+
+## Special Components
+
+### Portal
+
+```tsx
+import { Portal } from "@opentui/solid"
+
+<Portal mount={targetNode}>
+  <box>Portal content</box>
+</Portal>
+```
+
+### Dynamic
+
+```tsx
+import { Dynamic } from "@opentui/solid"
+
+<Dynamic
+  component={isMultiline() ? "textarea" : "input"}
+  placeholder="Enter text..."
+  focused
+/>
+```
diff --git a/.agents/skills/opentui/references/solid/configuration.md b/.agents/skills/opentui/references/solid/configuration.md
new file mode 100644
index 0000000..ec0412a
--- /dev/null
+++ b/.agents/skills/opentui/references/solid/configuration.md
@@ -0,0 +1,316 @@
+# Solid Configuration
+
+## Project Setup
+
+### Quick Start
+
+```bash
+bunx create-tui@latest -t solid my-app
+cd my-app && bun install
+```
+
+The CLI creates the `my-app` directory for you - it must **not already exist**.
+
+Options: `--no-git` (skip git init), `--no-install` (skip bun install)
+
+### Manual Setup
+
+```bash
+mkdir my-tui && cd my-tui
+bun init
+bun install @opentui/solid @opentui/core solid-js
+```
+
+## TypeScript Configuration
+
+### tsconfig.json
+
+```json
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"]
+}
+```
+
+**Critical settings:**
+- `jsx: "preserve"` - Let Solid's compiler handle JSX
+- `jsxImportSource: "@opentui/solid"` - Import JSX runtime from OpenTUI Solid
+- `module` / `moduleResolution: "NodeNext"` - Recommended for OpenTUI compatibility
+
+## Bun Configuration
+
+### bunfig.toml
+
+**Required** for the Solid compiler:
+
+```toml
+preload = ["@opentui/solid/preload"]
+```
+
+This loads the Solid JSX transform before your code runs.
+
+## Package Configuration
+
+### package.json
+
+```json
+{
+  "name": "my-tui-app",
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/index.tsx",
+    "dev": "bun --watch run src/index.tsx",
+    "test": "bun test",
+    "build": "bun run build.ts"
+  },
+  "dependencies": {
+    "@opentui/core": "latest",
+    "@opentui/solid": "latest",
+    "solid-js": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "latest"
+  }
+}
+```
+
+## Project Structure
+
+Recommended structure:
+
+```
+my-tui-app/
+├── src/
+│   ├── components/
+│   │   ├── Header.tsx
+│   │   ├── Sidebar.tsx
+│   │   └── MainContent.tsx
+│   ├── stores/
+│   │   └── appStore.ts
+│   ├── App.tsx
+│   └── index.tsx
+├── bunfig.toml           # Required!
+├── package.json
+└── tsconfig.json
+```
+
+### Entry Point (src/index.tsx)
+
+```tsx
+import { render } from "@opentui/solid"
+import { App } from "./App"
+
+render(() => <App />)
+```
+
+### App Component (src/App.tsx)
+
+```tsx
+import { Header } from "./components/Header"
+import { Sidebar } from "./components/Sidebar"
+import { MainContent } from "./components/MainContent"
+
+export function App() {
+  return (
+    <box flexDirection="column" width="100%" height="100%">
+      <Header />
+      <box flexDirection="row" flexGrow={1}>
+        <Sidebar />
+        <MainContent />
+      </box>
+    </box>
+  )
+}
+```
+
+## Renderer Configuration
+
+### render() Options
+
+```tsx
+import { render } from "@opentui/solid"
+import { ConsolePosition } from "@opentui/core"
+
+render(() => <App />, {
+  // Rendering
+  targetFPS: 60,
+
+  // Behavior
+  exitOnCtrlC: true,
+  autoFocus: true,          // Auto-focus elements on click (default: true)
+  useMouse: true,           // Enable mouse support (default: true)
+
+  // Debug console
+  consoleOptions: {
+    position: ConsolePosition.BOTTOM,
+    sizePercent: 30,
+    startInDebugMode: false,
+  },
+
+  // Cleanup
+  onDestroy: () => {
+    // Cleanup code
+  },
+})
+```
+
+### Using Existing Renderer
+
+```tsx
+import { render } from "@opentui/solid"
+import { createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+})
+
+render(() => <App />, renderer)
+```
+
+## Building for Distribution
+
+### Build Script (build.ts)
+
+```typescript
+import solidPlugin from "@opentui/solid/bun-plugin"
+
+await Bun.build({
+  entrypoints: ["./src/index.tsx"],
+  outdir: "./dist",
+  target: "bun",
+  minify: true,
+  plugins: [solidPlugin],
+})
+
+console.log("Build complete!")
+```
+
+Run: `bun run build.ts`
+
+### Creating Executables
+
+```typescript
+import solidPlugin from "@opentui/solid/bun-plugin"
+
+await Bun.build({
+  entrypoints: ["./src/index.tsx"],
+  target: "bun",
+  plugins: [solidPlugin],
+  compile: {
+    target: "bun-darwin-arm64",  // or bun-linux-x64, etc.
+    outfile: "my-app",
+  },
+})
+```
+
+**Available targets:**
+- `bun-darwin-arm64` - macOS Apple Silicon
+- `bun-darwin-x64` - macOS Intel
+- `bun-linux-x64` - Linux x64
+- `bun-linux-arm64` - Linux ARM64
+- `bun-windows-x64` - Windows x64
+
+## Environment Variables
+
+Create `.env` for development:
+
+```env
+# Debug settings
+OTUI_SHOW_STATS=false
+SHOW_CONSOLE=false
+
+# App settings
+API_URL=https://api.example.com
+```
+
+Bun auto-loads `.env` files:
+
+```tsx
+const apiUrl = process.env.API_URL
+```
+
+## Testing Configuration
+
+### Test Setup
+
+```typescript
+// src/test-utils.tsx
+import { testRender } from "@opentui/solid"
+
+export async function renderForTest(
+  Component: () => JSX.Element,
+  options = { width: 80, height: 24 }
+) {
+  return await testRender(Component, options)
+}
+```
+
+### Test Example
+
+```typescript
+// src/components/Counter.test.tsx
+import { test, expect } from "bun:test"
+import { renderForTest } from "../test-utils"
+import { Counter } from "./Counter"
+
+test("Counter renders initial value", async () => {
+  const { snapshot } = await renderForTest(() => <Counter initialValue={5} />)
+  expect(snapshot()).toContain("Count: 5")
+})
+```
+
+## Common Configuration Issues
+
+### Missing bunfig.toml
+
+**Symptom**: JSX not transformed, syntax errors
+
+**Fix**: Create `bunfig.toml` with preload:
+
+```toml
+preload = ["@opentui/solid/preload"]
+```
+
+### Wrong JSX Settings
+
+**Symptom**: JSX compiles to React calls
+
+**Fix**: Ensure tsconfig has:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid"
+  }
+}
+```
+
+### Build Missing Plugin
+
+**Symptom**: Built output has untransformed JSX
+
+**Fix**: Add Solid plugin to build:
+
+```typescript
+import solidPlugin from "@opentui/solid/bun-plugin"
+
+await Bun.build({
+  // ...
+  plugins: [solidPlugin],
+})
+```
diff --git a/.agents/skills/opentui/references/solid/gotchas.md b/.agents/skills/opentui/references/solid/gotchas.md
new file mode 100644
index 0000000..7ff579a
--- /dev/null
+++ b/.agents/skills/opentui/references/solid/gotchas.md
@@ -0,0 +1,427 @@
+# Solid Gotchas
+
+## Critical
+
+### Never use `process.exit()` directly
+
+**This is the most common mistake.** Using `process.exit()` leaves the terminal in a broken state (cursor hidden, raw mode, alternate screen).
+
+```tsx
+// WRONG - Terminal left in broken state
+process.exit(0)
+
+// CORRECT - Use renderer.destroy()
+import { useRenderer } from "@opentui/solid"
+
+function App() {
+  const renderer = useRenderer()
+
+  const handleExit = () => {
+    renderer.destroy()  // Cleans up and exits properly
+  }
+}
+```
+
+`renderer.destroy()` restores the terminal (exits alternate screen, restores cursor, etc.) before exiting.
+
+## Configuration Issues
+
+### Missing bunfig.toml
+
+**Symptom**: JSX syntax errors, components not rendering
+
+```
+SyntaxError: Unexpected token '<'
+```
+
+**Fix**: Create `bunfig.toml` in project root:
+
+```toml
+preload = ["@opentui/solid/preload"]
+```
+
+### Wrong JSX Settings
+
+**Symptom**: JSX compiles to React, errors about React not found
+
+**Fix**: Ensure tsconfig.json has:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid"
+  }
+}
+```
+
+### Build Without Plugin
+
+**Symptom**: Built bundle has raw JSX
+
+**Fix**: Add Solid plugin to build:
+
+```typescript
+import solidPlugin from "@opentui/solid/bun-plugin"
+
+await Bun.build({
+  // ...
+  plugins: [solidPlugin],
+})
+```
+
+## Reactivity Issues
+
+### Accessing Signals Without Calling
+
+**Symptom**: Value never updates, shows `[Function]`
+
+```tsx
+// WRONG - Missing ()
+const [count, setCount] = createSignal(0)
+<text>Count: {count}</text>  // Shows [Function]
+
+// CORRECT
+<text>Count: {count()}</text>
+```
+
+### Breaking Reactivity with Destructuring
+
+**Symptom**: Props stop being reactive
+
+```tsx
+// WRONG - Breaks reactivity
+function Component(props: { value: number }) {
+  const { value } = props  // Destructured once, never updates!
+  return <text>{value}</text>
+}
+
+// CORRECT - Keep props reactive
+function Component(props: { value: number }) {
+  return <text>{props.value}</text>
+}
+
+// OR use splitProps
+function Component(props: { value: number; other: string }) {
+  const [local, rest] = splitProps(props, ["value"])
+  return <text>{local.value}</text>
+}
+```
+
+### Effects Not Running
+
+**Symptom**: createEffect doesn't trigger
+
+```tsx
+// WRONG - Signal not accessed in effect
+const [count, setCount] = createSignal(0)
+
+createEffect(() => {
+  console.log("Count changed")  // Never runs after initial!
+})
+
+// CORRECT - Access the signal
+createEffect(() => {
+  console.log("Count:", count())  // Runs when count changes
+})
+```
+
+## HTML Entity Decoding
+
+Solid's reconciler automatically decodes HTML entities in JSX text content. This means `&lt;`, `&gt;`, `&amp;`, etc. render as their literal characters:
+
+```tsx
+// These render correctly in Solid
+<text>Use &lt;box&gt; for containers</text>  // Displays: Use <box> for containers
+<text>A &amp; B</text>                        // Displays: A & B
+```
+
+This applies to text nodes, the `content` prop, and the `text` prop.
+
+## Component Naming
+
+### Underscore vs Hyphen
+
+Solid uses underscores for multi-word component names:
+
+```tsx
+// WRONG - React-style naming
+<tab-select />    // Error!
+<ascii-font />    // Error!
+<line-number />   // Error!
+
+// CORRECT - Solid naming
+<tab_select />
+<ascii_font />
+<line_number />
+```
+
+**Component mapping:**
+| Concept | React | Solid |
+|---------|-------|-------|
+| Tab Select | `<tab-select>` | `<tab_select>` |
+| ASCII Font | `<ascii-font>` | `<ascii_font>` |
+| Line Number | `<line-number>` | `<line_number>` |
+
+## Focus Issues
+
+### Focus Not Working
+
+Components need explicit focus:
+
+```tsx
+// WRONG
+<input placeholder="Type here..." />
+
+// CORRECT
+<input placeholder="Type here..." focused />
+```
+
+### Select Not Responding
+
+```tsx
+// WRONG
+<select options={["a", "b"]} />
+
+// CORRECT
+<select
+  options={[
+    { name: "A", description: "Option A", value: "a" },
+    { name: "B", description: "Option B", value: "b" },
+  ]}
+  onSelect={(index, option) => {
+    // Called when Enter is pressed
+    console.log("Selected:", option.name)
+  }}
+  focused
+/>
+```
+
+### Select Events Confusion
+
+Remember: `onSelect` fires on Enter (selection confirmed), `onChange` fires on navigation:
+
+```tsx
+// WRONG - expecting onChange to fire on Enter
+<select
+  options={options()}
+  onChange={(i, opt) => submitForm(opt)}  // This fires on arrow keys!
+/>
+
+// CORRECT
+<select
+  options={options()}
+  onSelect={(i, opt) => submitForm(opt)}   // Enter pressed - submit
+  onChange={(i, opt) => showPreview(opt)}  // Arrow keys - preview
+/>
+```
+
+## Control Flow Issues
+
+### For vs Index
+
+Use `For` for arrays of objects, `Index` for primitives:
+
+```tsx
+// For objects - item is reactive
+<For each={objects()}>
+  {(obj) => <text>{obj.name}</text>}
+</For>
+
+// For primitives - use Index, item() is reactive
+<Index each={strings()}>
+  {(str, index) => <text>{index}: {str()}</text>}
+</Index>
+```
+
+### Missing Fallback
+
+Show requires fallback for proper rendering:
+
+```tsx
+// May cause issues
+<Show when={data()}>
+  <Component />
+</Show>
+
+// Better - explicit fallback
+<Show when={data()} fallback={<text>Loading...</text>}>
+  <Component />
+</Show>
+```
+
+## Cleanup Issues
+
+### Forgetting onCleanup
+
+**Symptom**: Memory leaks, multiple intervals running
+
+```tsx
+// WRONG - Interval never cleared
+function Timer() {
+  const [time, setTime] = createSignal(0)
+
+  setInterval(() => setTime(t => t + 1), 1000)
+
+  return <text>{time()}</text>
+}
+
+// CORRECT
+function Timer() {
+  const [time, setTime] = createSignal(0)
+
+  const interval = setInterval(() => setTime(t => t + 1), 1000)
+  onCleanup(() => clearInterval(interval))
+
+  return <text>{time()}</text>
+}
+```
+
+### Effect Cleanup
+
+```tsx
+createEffect(() => {
+  const subscription = subscribe(data())
+
+  // WRONG - No cleanup
+  // subscription stays active
+
+  // CORRECT
+  onCleanup(() => subscription.unsubscribe())
+})
+```
+
+## Store Issues
+
+### Mutating Store Directly
+
+**Symptom**: Changes don't trigger updates
+
+```tsx
+const [state, setState] = createStore({ items: [] })
+
+// WRONG - Direct mutation
+state.items.push(newItem)  // Won't trigger updates!
+
+// CORRECT - Use setState
+setState("items", items => [...items, newItem])
+```
+
+### Nested Updates
+
+```tsx
+const [state, setState] = createStore({
+  user: { profile: { name: "John" } }
+})
+
+// WRONG
+state.user.profile.name = "Jane"
+
+// CORRECT
+setState("user", "profile", "name", "Jane")
+```
+
+## Debugging
+
+### Console Not Visible
+
+OpenTUI captures console output:
+
+```tsx
+import { useRenderer } from "@opentui/solid"
+import { onMount } from "solid-js"
+
+function App() {
+  const renderer = useRenderer()
+
+  onMount(() => {
+    renderer.console.show()
+    console.log("Now visible!")
+  })
+
+  return <box>{/* ... */}</box>
+}
+```
+
+### Tracking Reactivity
+
+Use `createEffect` to debug:
+
+```tsx
+createEffect(() => {
+  console.log("State:", {
+    count: count(),
+    items: items(),
+  })
+})
+```
+
+## Runtime Issues
+
+### Use Bun
+
+```bash
+# WRONG
+node src/index.tsx
+npm run start
+
+# CORRECT
+bun run src/index.tsx
+bun run start
+```
+
+### Async render()
+
+The render function is async when creating a renderer:
+
+```tsx
+// This is fine - Bun supports top-level await
+render(() => <App />)
+
+// If you need the renderer
+import { createCliRenderer } from "@opentui/core"
+import { render } from "@opentui/solid"
+
+const renderer = await createCliRenderer()
+render(() => <App />, renderer)
+```
+
+## Common Error Messages
+
+### "Cannot read properties of undefined"
+
+Usually a missing reactive access:
+
+```tsx
+// Check if signal is being called
+<text>{count()}</text>  // Note the ()
+
+// Check if props are being accessed correctly
+<text>{props.value}</text>  // Not destructured
+```
+
+### "JSX element has no corresponding closing tag"
+
+Check component naming:
+
+```tsx
+// Wrong
+<tab-select></tab-select>
+
+// Correct
+<tab_select></tab_select>
+```
+
+### "store is not a function"
+
+Stores aren't called like signals:
+
+```tsx
+const [store, setStore] = createStore({ count: 0 })
+
+// WRONG
+<text>{store().count}</text>
+
+// CORRECT
+<text>{store.count}</text>
+```
diff --git a/.agents/skills/opentui/references/solid/patterns.md b/.agents/skills/opentui/references/solid/patterns.md
new file mode 100644
index 0000000..ceb4996
--- /dev/null
+++ b/.agents/skills/opentui/references/solid/patterns.md
@@ -0,0 +1,560 @@
+# Solid Patterns
+
+## Reactive State
+
+### Signals
+
+Basic reactive state with signals:
+
+```tsx
+import { createSignal } from "solid-js"
+
+function Counter() {
+  const [count, setCount] = createSignal(0)
+
+  return (
+    <box flexDirection="row" gap={2}>
+      <text>Count: {count()}</text>
+      <box border onMouseDown={() => setCount(c => c - 1)}>
+        <text>-</text>
+      </box>
+      <box border onMouseDown={() => setCount(c => c + 1)}>
+        <text>+</text>
+      </box>
+    </box>
+  )
+}
+```
+
+### Derived State
+
+Compute values from signals:
+
+```tsx
+import { createSignal, createMemo } from "solid-js"
+
+function PriceCalculator() {
+  const [quantity, setQuantity] = createSignal(1)
+  const [price, setPrice] = createSignal(9.99)
+
+  // Derived value - only recalculates when dependencies change
+  const total = createMemo(() => quantity() * price())
+  const formatted = createMemo(() => `$${total().toFixed(2)}`)
+
+  return (
+    <box flexDirection="column">
+      <text>Quantity: {quantity()}</text>
+      <text>Price: ${price()}</text>
+      <text>Total: {formatted()}</text>
+    </box>
+  )
+}
+```
+
+### Effects
+
+React to state changes:
+
+```tsx
+import { createSignal, createEffect, onCleanup } from "solid-js"
+
+function AutoSave() {
+  const [content, setContent] = createSignal("")
+
+  createEffect(() => {
+    const text = content()
+
+    // Debounced save
+    const timeout = setTimeout(() => {
+      saveToFile(text)
+    }, 1000)
+
+    // Cleanup on next run or disposal
+    onCleanup(() => clearTimeout(timeout))
+  })
+
+  return (
+    <textarea
+      value={content()}
+      onInput={setContent}
+      placeholder="Auto-saves after 1 second..."
+    />
+  )
+}
+```
+
+## Stores
+
+### createStore for Complex State
+
+```tsx
+import { createStore } from "solid-js/store"
+
+interface AppState {
+  user: { name: string; email: string } | null
+  items: Array<{ id: number; name: string; done: boolean }>
+  settings: { theme: "dark" | "light" }
+}
+
+function App() {
+  const [state, setState] = createStore<AppState>({
+    user: null,
+    items: [],
+    settings: { theme: "dark" },
+  })
+
+  const addItem = (name: string) => {
+    setState("items", items => [
+      ...items,
+      { id: Date.now(), name, done: false }
+    ])
+  }
+
+  const toggleItem = (id: number) => {
+    setState("items", item => item.id === id, "done", done => !done)
+  }
+
+  const setTheme = (theme: "dark" | "light") => {
+    setState("settings", "theme", theme)
+  }
+
+  return (
+    <box backgroundColor={state.settings.theme === "dark" ? "#1a1a2e" : "#f0f0f0"}>
+      <For each={state.items}>
+        {(item) => (
+          <text
+            fg={item.done ? "#888" : "#fff"}
+            onMouseDown={() => toggleItem(item.id)}
+          >
+            {item.done ? "[x]" : "[ ]"} {item.name}
+          </text>
+        )}
+      </For>
+    </box>
+  )
+}
+```
+
+### Store with Context
+
+Share state across components:
+
+```tsx
+import { createStore } from "solid-js/store"
+import { createContext, useContext, ParentComponent } from "solid-js"
+
+interface Store {
+  count: number
+  items: string[]
+}
+
+type StoreContextValue = [
+  Store,
+  {
+    increment: () => void
+    addItem: (item: string) => void
+  }
+]
+
+const StoreContext = createContext<StoreContextValue>()
+
+const StoreProvider: ParentComponent = (props) => {
+  const [state, setState] = createStore<Store>({
+    count: 0,
+    items: [],
+  })
+
+  const actions = {
+    increment: () => setState("count", c => c + 1),
+    addItem: (item: string) => setState("items", i => [...i, item]),
+  }
+
+  return (
+    <StoreContext.Provider value={[state, actions]}>
+      {props.children}
+    </StoreContext.Provider>
+  )
+}
+
+function useStore() {
+  const context = useContext(StoreContext)
+  if (!context) throw new Error("useStore must be used within StoreProvider")
+  return context
+}
+
+// Usage
+function Counter() {
+  const [state, { increment }] = useStore()
+  return (
+    <box onMouseDown={increment}>
+      <text>Count: {state.count}</text>
+    </box>
+  )
+}
+```
+
+## Control Flow
+
+### Conditional Rendering with Show
+
+```tsx
+import { Show, createSignal } from "solid-js"
+
+function ToggleableContent() {
+  const [visible, setVisible] = createSignal(false)
+
+  return (
+    <box flexDirection="column">
+      <box border onMouseDown={() => setVisible(v => !v)}>
+        <text>Toggle</text>
+      </box>
+
+      <Show
+        when={visible()}
+        fallback={<text fg="#888">Content is hidden</text>}
+      >
+        <text fg="#0f0">Content is visible!</text>
+      </Show>
+    </box>
+  )
+}
+```
+
+### Lists with For
+
+```tsx
+import { For, createSignal } from "solid-js"
+
+function TodoList() {
+  const [todos, setTodos] = createSignal([
+    { id: 1, text: "Learn Solid", done: false },
+    { id: 2, text: "Build TUI", done: false },
+  ])
+
+  const toggle = (id: number) => {
+    setTodos(todos =>
+      todos.map(t =>
+        t.id === id ? { ...t, done: !t.done } : t
+      )
+    )
+  }
+
+  return (
+    <box flexDirection="column">
+      <For each={todos()}>
+        {(todo) => (
+          <box onMouseDown={() => toggle(todo.id)}>
+            <text fg={todo.done ? "#888" : "#fff"}>
+              {todo.done ? "[x]" : "[ ]"} {todo.text}
+            </text>
+          </box>
+        )}
+      </For>
+    </box>
+  )
+}
+```
+
+### Index for Primitive Arrays
+
+Use `Index` when array items are primitives:
+
+```tsx
+import { Index, createSignal } from "solid-js"
+
+function StringList() {
+  const [items, setItems] = createSignal(["apple", "banana", "cherry"])
+
+  return (
+    <box flexDirection="column">
+      <Index each={items()}>
+        {(item, index) => (
+          <text>{index}: {item()}</text>
+        )}
+      </Index>
+    </box>
+  )
+}
+```
+
+### Switch/Match for Multiple Conditions
+
+```tsx
+import { Switch, Match, createSignal } from "solid-js"
+
+type Status = "idle" | "loading" | "success" | "error"
+
+function StatusDisplay() {
+  const [status, setStatus] = createSignal<Status>("idle")
+
+  return (
+    <Switch>
+      <Match when={status() === "idle"}>
+        <text>Ready</text>
+      </Match>
+      <Match when={status() === "loading"}>
+        <text fg="#ff0">Loading...</text>
+      </Match>
+      <Match when={status() === "success"}>
+        <text fg="#0f0">Success!</text>
+      </Match>
+      <Match when={status() === "error"}>
+        <text fg="#f00">Error occurred</text>
+      </Match>
+    </Switch>
+  )
+}
+```
+
+## Focus Management
+
+### Focus State
+
+```tsx
+import { createSignal } from "solid-js"
+import { useKeyboard } from "@opentui/solid"
+
+function FocusableForm() {
+  const [focusIndex, setFocusIndex] = createSignal(0)
+  const fields = ["name", "email", "message"]
+
+  useKeyboard((key) => {
+    if (key.name === "tab") {
+      setFocusIndex(i => (i + 1) % fields.length)
+    }
+    if (key.shift && key.name === "tab") {
+      setFocusIndex(i => (i - 1 + fields.length) % fields.length)
+    }
+  })
+
+  return (
+    <box flexDirection="column" gap={1}>
+      <Index each={fields}>
+        {(field, i) => (
+          <input
+            placeholder={`Enter ${field()}...`}
+            focused={i === focusIndex()}
+          />
+        )}
+      </Index>
+    </box>
+  )
+}
+```
+
+## Keyboard Navigation
+
+### Global Shortcuts
+
+```tsx
+import { useKeyboard } from "@opentui/solid"
+
+function App() {
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()  // Never use process.exit() directly!
+    }
+
+    if (key.ctrl && key.name === "s") {
+      save()
+    }
+
+    // Vim-style
+    if (key.name === "j") moveDown()
+    if (key.name === "k") moveUp()
+  })
+
+  return <box>{/* ... */}</box>
+}
+```
+
+## Responsive Design
+
+### Terminal-size Responsive
+
+```tsx
+import { useTerminalDimensions } from "@opentui/solid"
+
+function ResponsiveLayout() {
+  const dims = useTerminalDimensions()
+
+  return (
+    <box flexDirection={dims().width > 80 ? "row" : "column"}>
+      <box flexGrow={1}>
+        <text>Panel 1</text>
+      </box>
+      <box flexGrow={1}>
+        <text>Panel 2</text>
+      </box>
+    </box>
+  )
+}
+```
+
+## Async Data
+
+### Resources
+
+```tsx
+import { createResource, Suspense } from "solid-js"
+
+async function fetchData() {
+  const response = await fetch("https://api.example.com/data")
+  return response.json()
+}
+
+function DataDisplay() {
+  const [data] = createResource(fetchData)
+
+  return (
+    <Suspense fallback={<text>Loading...</text>}>
+      <Show when={data()}>
+        {(items) => (
+          <For each={items()}>
+            {(item) => <text>{item.name}</text>}
+          </For>
+        )}
+      </Show>
+    </Suspense>
+  )
+}
+```
+
+### Error Handling
+
+```tsx
+import { createResource, Show, ErrorBoundary } from "solid-js"
+
+function SafeDataDisplay() {
+  const [data] = createResource(fetchData)
+
+  return (
+    <ErrorBoundary fallback={(err) => <text fg="red">Error: {err.message}</text>}>
+      <Show
+        when={!data.loading}
+        fallback={<text>Loading...</text>}
+      >
+        <Show
+          when={!data.error}
+          fallback={<text fg="red">Failed to load</text>}
+        >
+          <For each={data()}>
+            {(item) => <text>{item.name}</text>}
+          </For>
+        </Show>
+      </Show>
+    </ErrorBoundary>
+  )
+}
+```
+
+## Component Composition
+
+### Props and Children
+
+```tsx
+import { ParentComponent, JSX } from "solid-js"
+
+interface PanelProps {
+  title: string
+  children: JSX.Element
+}
+
+const Panel: ParentComponent<{ title: string }> = (props) => {
+  return (
+    <box border padding={1} flexDirection="column">
+      <text fg="#0ff">{props.title}</text>
+      <box marginTop={1}>
+        {props.children}
+      </box>
+    </box>
+  )
+}
+
+// Usage
+<Panel title="Settings">
+  <text>Panel content here</text>
+</Panel>
+```
+
+### Spread Props
+
+```tsx
+import { splitProps } from "solid-js"
+
+interface ButtonProps {
+  label: string
+  onClick: () => void
+  // ...rest goes to box
+}
+
+function Button(props: ButtonProps) {
+  const [local, rest] = splitProps(props, ["label", "onClick"])
+
+  return (
+    <box border onMouseDown={local.onClick} {...rest}>
+      <text>{local.label}</text>
+    </box>
+  )
+}
+```
+
+## Animation
+
+### With Timeline
+
+```tsx
+import { createSignal, onMount } from "solid-js"
+import { useTimeline } from "@opentui/solid"
+
+function AnimatedProgress() {
+  const [width, setWidth] = createSignal(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+  })
+
+  onMount(() => {
+    timeline.add(
+      { value: 0 },
+      {
+        value: 50,
+        duration: 2000,
+        ease: "easeOutQuad",
+        onUpdate: (anim) => {
+          setWidth(Math.round(anim.targets[0].value))
+        },
+      }
+    )
+  })
+
+  return (
+    <box flexDirection="column" gap={1}>
+      <text>Progress: {width()}%</text>
+      <box width={50} height={1} backgroundColor="#333">
+        <box width={width()} height={1} backgroundColor="#0f0" />
+      </box>
+    </box>
+  )
+}
+```
+
+### Interval-based
+
+```tsx
+import { createSignal, onCleanup } from "solid-js"
+
+function Clock() {
+  const [time, setTime] = createSignal(new Date())
+
+  const interval = setInterval(() => {
+    setTime(new Date())
+  }, 1000)
+
+  onCleanup(() => clearInterval(interval))
+
+  return <text>{time().toLocaleTimeString()}</text>
+}
+```
diff --git a/.agents/skills/opentui/references/testing/REFERENCE.md b/.agents/skills/opentui/references/testing/REFERENCE.md
new file mode 100644
index 0000000..c025fb5
--- /dev/null
+++ b/.agents/skills/opentui/references/testing/REFERENCE.md
@@ -0,0 +1,614 @@
+# Testing OpenTUI Applications
+
+How to test terminal user interfaces built with OpenTUI.
+
+## Overview
+
+OpenTUI provides:
+- **Test Renderer**: Headless renderer for testing
+- **Snapshot Testing**: Verify visual output
+- **Interaction Testing**: Simulate user input
+
+## When to Use
+
+Use this reference when you need snapshot tests, interaction testing, or renderer-based regression checks.
+
+## Test Setup
+
+### Bun Test Runner
+
+OpenTUI uses Bun's built-in test runner:
+
+```typescript
+import { test, expect, beforeEach, afterEach } from "bun:test"
+```
+
+### Test Renderer
+
+Create a test renderer for headless testing:
+
+```typescript
+import { createTestRenderer } from "@opentui/core/testing"
+
+const testSetup = await createTestRenderer({
+  width: 80,     // Terminal width
+  height: 24,    // Terminal height
+})
+```
+
+## Core Testing
+
+### Basic Test
+
+```typescript
+import { test, expect } from "bun:test"
+import { createTestRenderer } from "@opentui/core/testing"
+import { TextRenderable } from "@opentui/core"
+
+test("renders text", async () => {
+  const testSetup = await createTestRenderer({
+    width: 40,
+    height: 10,
+  })
+
+  const text = new TextRenderable(testSetup.renderer, {
+    id: "greeting",
+    content: "Hello, World!",
+  })
+
+  testSetup.renderer.root.add(text)
+  await testSetup.renderOnce()
+
+  expect(testSetup.captureCharFrame()).toContain("Hello, World!")
+})
+```
+
+### Snapshot Testing
+
+```typescript
+import { test, expect, afterEach } from "bun:test"
+import { createTestRenderer } from "@opentui/core/testing"
+import { BoxRenderable, TextRenderable } from "@opentui/core"
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("component matches snapshot", async () => {
+  testSetup = await createTestRenderer({
+    width: 40,
+    height: 10,
+  })
+
+  const box = new BoxRenderable(testSetup.renderer, {
+    id: "box",
+    border: true,
+    width: 20,
+    height: 5,
+  })
+  box.add(new TextRenderable(testSetup.renderer, {
+    content: "Content",
+  }))
+
+  testSetup.renderer.root.add(box)
+  await testSetup.renderOnce()
+
+  expect(testSetup.captureCharFrame()).toMatchSnapshot()
+})
+```
+
+## React Testing
+
+### Test Utilities
+
+React provides a built-in `testRender` utility via the `@opentui/react/test-utils` subpath export:
+
+```tsx
+import { testRender } from "@opentui/react/test-utils"
+```
+
+This utility:
+- Creates a headless test renderer
+- Sets up the React Act environment automatically
+- Handles proper unmounting on destroy
+- Returns the standard test setup object
+
+### Basic Component Test
+
+```tsx
+import { test, expect } from "bun:test"
+import { testRender } from "@opentui/react/test-utils"
+
+function Greeting({ name }: { name: string }) {
+  return <text>Hello, {name}!</text>
+}
+
+test("Greeting renders name", async () => {
+  const testSetup = await testRender(
+    <Greeting name="World" />,
+    { width: 80, height: 24 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  expect(frame).toContain("Hello, World!")
+})
+```
+
+### Snapshot Testing
+
+```tsx
+import { test, expect, afterEach } from "bun:test"
+import { testRender } from "@opentui/react/test-utils"
+
+let testSetup: Awaited<ReturnType<typeof testRender>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("component matches snapshot", async () => {
+  testSetup = await testRender(
+    <box style={{ width: 20, height: 5, border: true }}>
+      <text>Content</text>
+    </box>,
+    { width: 25, height: 8 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  expect(frame).toMatchSnapshot()
+})
+```
+
+### State Testing
+
+```tsx
+import { test, expect, afterEach } from "bun:test"
+import { useState } from "react"
+import { testRender } from "@opentui/react/test-utils"
+
+let testSetup: Awaited<ReturnType<typeof testRender>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+function Counter() {
+  const [count, setCount] = useState(0)
+  return (
+    <box>
+      <text>Count: {count}</text>
+    </box>
+  )
+}
+
+test("Counter shows initial value", async () => {
+  testSetup = await testRender(
+    <Counter />,
+    { width: 20, height: 5 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  expect(frame).toContain("Count: 0")
+})
+```
+
+### Test Setup/Teardown Pattern
+
+For multiple tests, use beforeEach/afterEach to manage the renderer lifecycle:
+
+```tsx
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { testRender } from "@opentui/react/test-utils"
+
+let testSetup: Awaited<ReturnType<typeof testRender>>
+
+describe("MyComponent", () => {
+  beforeEach(async () => {
+    if (testSetup) {
+      testSetup.renderer.destroy()
+    }
+  })
+
+  afterEach(() => {
+    if (testSetup) {
+      testSetup.renderer.destroy()
+    }
+  })
+
+  test("renders correctly", async () => {
+    testSetup = await testRender(<MyComponent />, {
+      width: 40,
+      height: 10,
+    })
+
+    await testSetup.renderOnce()
+    const frame = testSetup.captureCharFrame()
+    expect(frame).toMatchSnapshot()
+  })
+})
+```
+
+### Test Setup Return Object
+
+The `testRender` function returns a test setup object with these properties:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `renderer` | `Renderer` | The headless renderer instance |
+| `renderOnce` | `() => Promise<void>` | Triggers a single render cycle |
+| `captureCharFrame` | `() => string` | Captures current output as text |
+| `resize` | `(width, height) => void` | Resize the virtual terminal |
+
+## Solid Testing
+
+### Test Utilities
+
+Solid exports `testRender` directly from the main package:
+
+```tsx
+import { testRender } from "@opentui/solid"
+```
+
+Note: Unlike React, Solid's `testRender` takes a **function component** (not a JSX element).
+
+### Basic Component Test
+
+```tsx
+import { test, expect } from "bun:test"
+import { testRender } from "@opentui/solid"
+
+function Greeting(props: { name: string }) {
+  return <text>Hello, {props.name}!</text>
+}
+
+test("Greeting renders name", async () => {
+  const testSetup = await testRender(
+    () => <Greeting name="World" />,
+    { width: 80, height: 24 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  expect(frame).toContain("Hello, World!")
+})
+```
+
+### Snapshot Testing
+
+```tsx
+import { test, expect, afterEach } from "bun:test"
+import { testRender } from "@opentui/solid"
+
+let testSetup: Awaited<ReturnType<typeof testRender>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("component matches snapshot", async () => {
+  testSetup = await testRender(
+    () => (
+      <box style={{ width: 20, height: 5, border: true }}>
+        <text>Content</text>
+      </box>
+    ),
+    { width: 25, height: 8 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  expect(frame).toMatchSnapshot()
+})
+```
+
+## Snapshot Format
+
+Snapshots capture the rendered terminal output as text:
+
+```
+┌──────────────────┐
+│ Hello, World!    │
+│                  │
+└──────────────────┘
+```
+
+### Updating Snapshots
+
+```bash
+bun test --update-snapshots
+```
+
+## Interaction Testing
+
+### Simulating Key Presses
+
+```typescript
+import { test, expect, afterEach } from "bun:test"
+import { createTestRenderer } from "@opentui/core/testing"
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("responds to keyboard", async () => {
+  testSetup = await createTestRenderer({
+    width: 40,
+    height: 10,
+  })
+
+  // Create component that responds to keys
+  // ...
+
+  // Simulate keypress
+  testSetup.renderer.keyInput.emit("keypress", {
+    name: "enter",
+    sequence: "\r",
+    ctrl: false,
+    shift: false,
+    meta: false,
+    option: false,
+    eventType: "press",
+    repeated: false,
+  })
+
+  // Render after the keypress
+  await testSetup.renderOnce()
+
+  expect(testSetup.captureCharFrame()).toContain("Selected")
+})
+```
+
+### Testing Focus
+
+```typescript
+import { test, expect, afterEach } from "bun:test"
+import { createTestRenderer } from "@opentui/core/testing"
+import { InputRenderable } from "@opentui/core"
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("input receives focus", async () => {
+  testSetup = await createTestRenderer({
+    width: 40,
+    height: 10,
+  })
+
+  const input = new InputRenderable(testSetup.renderer, {
+    id: "test-input",
+    placeholder: "Type here",
+  })
+  testSetup.renderer.root.add(input)
+
+  input.focus()
+
+  expect(input.isFocused()).toBe(true)
+})
+```
+
+## Test Organization
+
+### File Structure
+
+```
+src/
+├── components/
+│   ├── Button.tsx
+│   └── Button.test.tsx
+├── hooks/
+│   ├── useCounter.ts
+│   └── useCounter.test.ts
+└── test-utils.tsx
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+bun test
+
+# Run specific test file
+bun test src/components/Button.test.tsx
+
+# Run with filter
+bun test --filter "Button"
+
+# Watch mode
+bun test --watch
+```
+
+## Patterns
+
+### Testing Conditional Rendering (React)
+
+```tsx
+import { test, expect, afterEach } from "bun:test"
+import { testRender } from "@opentui/react/test-utils"
+
+let testSetup: Awaited<ReturnType<typeof testRender>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("shows loading state", async () => {
+  testSetup = await testRender(
+    <DataLoader loading={true} />,
+    { width: 40, height: 10 }
+  )
+
+  await testSetup.renderOnce()
+  expect(testSetup.captureCharFrame()).toContain("Loading...")
+})
+
+test("shows data when loaded", async () => {
+  testSetup = await testRender(
+    <DataLoader loading={false} data={["Item 1", "Item 2"]} />,
+    { width: 40, height: 10 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+  expect(frame).toContain("Item 1")
+  expect(frame).toContain("Item 2")
+})
+```
+
+### Testing Lists
+
+```tsx
+test("renders all items", async () => {
+  const items = ["Apple", "Banana", "Cherry"]
+
+  testSetup = await testRender(
+    <ItemList items={items} />,
+    { width: 40, height: 10 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  items.forEach(item => {
+    expect(frame).toContain(item)
+  })
+})
+```
+
+### Testing Layouts
+
+```tsx
+test("matches layout snapshot", async () => {
+  testSetup = await testRender(
+    <AppLayout />,
+    { width: 120, height: 40 }  // Larger viewport
+  )
+
+  await testSetup.renderOnce()
+  expect(testSetup.captureCharFrame()).toMatchSnapshot()
+})
+```
+
+## Debugging Tests
+
+### Print Frame Output
+
+```tsx
+import { testRender } from "@opentui/react/test-utils"
+
+test("debug output", async () => {
+  const testSetup = await testRender(
+    <MyComponent />,
+    { width: 40, height: 10 }
+  )
+
+  await testSetup.renderOnce()
+  const frame = testSetup.captureCharFrame()
+
+  // Print to see what's rendered
+  console.log(frame)
+
+  expect(frame).toContain("expected")
+})
+```
+
+### Verbose Mode
+
+```bash
+bun test --verbose
+```
+
+## Gotchas
+
+### Async Rendering
+
+Always call `renderOnce()` after setting up your component to ensure rendering is complete:
+
+```typescript
+const testSetup = await testRender(<MyComponent />, { width: 40, height: 10 })
+await testSetup.renderOnce()  // Required before capturing frame
+const frame = testSetup.captureCharFrame()
+```
+
+### Test Isolation and Cleanup
+
+Always destroy the renderer after each test to avoid resource leaks:
+
+```typescript
+import { afterEach } from "bun:test"
+
+let testSetup: Awaited<ReturnType<typeof testRender>>
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy()
+  }
+})
+
+test("test 1", async () => {
+  testSetup = await testRender(<Component1 />, { width: 40, height: 10 })
+  // ...
+})
+
+test("test 2", async () => {
+  testSetup = await testRender(<Component2 />, { width: 40, height: 10 })
+  // ...
+})
+```
+
+### Snapshot Dimensions
+
+Be consistent with test dimensions for stable snapshots:
+
+```typescript
+const testSetup = await createTestRenderer({
+  width: 80,   // Standard width
+  height: 24,  // Standard height
+})
+```
+
+### Running from Package Directory
+
+Run tests from the package directory:
+
+```bash
+cd packages/core
+bun test
+
+# Not from repo root for package-specific tests
+```
+
+## See Also
+
+- [Core API](../core/api.md) - `createTestRenderer` and renderable classes
+- [React Configuration](../react/configuration.md) - React test setup
+- [Solid Configuration](../solid/configuration.md) - Solid test setup
+- [Keyboard](../keyboard/REFERENCE.md) - Simulating key events in tests
diff --git a/.agents/skills/publish-cli b/.agents/skills/publish-cli
new file mode 120000
index 0000000..7606c27
--- /dev/null
+++ b/.agents/skills/publish-cli
@@ -0,0 +1 @@
+../../.cline/skills/publish-cli
\ No newline at end of file
diff --git a/.changeset/pink-ants-glow.md b/.changeset/pink-ants-glow.md
new file mode 100644
index 0000000..4c97237
--- /dev/null
+++ b/.changeset/pink-ants-glow.md
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+fix: use correct base URL for Vertex AI global endpoint with Claude models
diff --git a/.claude/commands/hotfix-release.md b/.claude/commands/hotfix-release.md
new file mode 120000
index 0000000..354a69e
--- /dev/null
+++ b/.claude/commands/hotfix-release.md
@@ -0,0 +1 @@
+../../.clinerules/workflows/hotfix-release.md
\ No newline at end of file
diff --git a/.claude/commands/release.md b/.claude/commands/release.md
new file mode 120000
index 0000000..98c6c3b
--- /dev/null
+++ b/.claude/commands/release.md
@@ -0,0 +1 @@
+../../.clinerules/workflows/release.md
\ No newline at end of file
diff --git a/.claude/hooks/claude-code-for-web-setup.sh b/.claude/hooks/claude-code-for-web-setup.sh
new file mode 100755
index 0000000..66750f5
--- /dev/null
+++ b/.claude/hooks/claude-code-for-web-setup.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+set -euo pipefail
+
+# Only run in Claude Code remote environments
+if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
+  exit 0
+fi
+
+cd "$CLAUDE_PROJECT_DIR"
+
+echo "=== Claude Code for Web Setup ==="
+echo ""
+
+# Install latest gh CLI tool
+echo "Installing GitHub CLI..."
+GH_VERSION=$(curl -s https://api.github.com/repos/cli/cli/releases/latest | grep '"tag_name"' | cut -d'"' -f4 | sed 's/^v//')
+curl -sL "https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_linux_amd64.tar.gz" -o /tmp/gh.tar.gz
+tar -xzf /tmp/gh.tar.gz -C /tmp
+sudo mv "/tmp/gh_${GH_VERSION}_linux_amd64/bin/gh" /usr/local/bin/gh
+rm -rf /tmp/gh.tar.gz /tmp/gh_${GH_VERSION}_linux_amd64
+echo "Installed gh version: $(gh --version | head -1)"
+echo ""
+
+# Check if GITHUB_TOKEN is set and configure gh
+if [ -n "${GITHUB_TOKEN:-}" ]; then
+  echo "GITHUB_TOKEN is configured - gh CLI is ready to use"
+  echo ""
+  echo "You can use gh commands directly, for example:"
+  echo "  gh issue list --repo cline/cline --limit 5"
+  echo "  gh pr list --repo cline/cline --state open"
+  echo "  gh issue view 123 --repo cline/cline"
+  echo ""
+else
+  echo "GITHUB_TOKEN is not set - gh CLI will have limited functionality"
+  echo ""
+  echo "To enable full GitHub API access:"
+  echo "1. Create a Fine-grained Personal Access Token at https://github.com/settings/tokens?type=beta"
+  echo "2. Add it as GITHUB_TOKEN in your Claude Code environment settings"
+  echo ""
+fi
+
+# Install project dependencies
+echo "Installing dependencies..."
+bun run install:all
+
+# Generate gRPC/protobuf types (required for TypeScript)
+echo "Generating proto types..."
+bun run protos
+
+echo ""
+echo "Session setup complete!"
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 0000000..2e612c9
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,14 @@
+{
+	"hooks": {
+		"SessionStart": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "$CLAUDE_PROJECT_DIR/.claude/hooks/claude-code-for-web-setup.sh"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/.claude/skills/cline-sdk b/.claude/skills/cline-sdk
new file mode 120000
index 0000000..d6fa6e5
--- /dev/null
+++ b/.claude/skills/cline-sdk
@@ -0,0 +1 @@
+../../.agents/skills/cline-sdk
\ No newline at end of file
diff --git a/.claude/skills/opentui b/.claude/skills/opentui
new file mode 120000
index 0000000..dc17f58
--- /dev/null
+++ b/.claude/skills/opentui
@@ -0,0 +1 @@
+../../.agents/skills/opentui
\ No newline at end of file
diff --git a/.claude/skills/publish-cli b/.claude/skills/publish-cli
new file mode 120000
index 0000000..7606c27
--- /dev/null
+++ b/.claude/skills/publish-cli
@@ -0,0 +1 @@
+../../.cline/skills/publish-cli
\ No newline at end of file
diff --git a/.cline/skills/publish-cli/SKILL.md b/.cline/skills/publish-cli/SKILL.md
new file mode 100644
index 0000000..182fc81
--- /dev/null
+++ b/.cline/skills/publish-cli/SKILL.md
@@ -0,0 +1,266 @@
+---
+name: publish-cli
+description: Use when preparing, tagging, and publishing an apps/cli npm release. Guides changelog drafting, apps/cli/package.json version bumps, cli-vX.Y.Z tags, local npm publishing, and the publish-cli GitHub workflow.
+---
+
+# CLI Release
+
+Use this skill when the user asks to release the CLI, publish `cline`, bump the CLI version, draft release notes, create a `cli-vX.Y.Z` tag, or trigger the CLI publish workflow.
+
+The CLI is npm-only. Do not add alternate distribution or signing steps.
+
+> Working directory: run every command below from the repository root. Paths and scripts (e.g. `apps/cli/package.json`, `sdk/packages/`, `bun release cli`, `bun run version`) are written relative to the repo root.
+
+The skill should guide the user through one release preparation flow, then offer the publish path options. The two normal publish paths are GitHub Actions and local publishing from an authenticated machine.
+
+## Release contract
+
+- SDK prerequisite: the CLI depends on the SDK via `workspace:*` (`@cline/core`, `@cline/shared`, and friends). If the SDK changed since its last release, release the SDK first and wait for it to finish publishing before releasing the CLI. See "Step 0: Release the SDK first if it changed" below.
+- Version source: `apps/cli/package.json`.
+- Main release tag: `cli-vX.Y.Z`, where `X.Y.Z` matches `apps/cli/package.json`.
+- Nightly release version: `X.Y.Z-nightly.TIMESTAMP`.
+- Release prep includes approved release notes, a version bump, and an `apps/cli/CHANGELOG.md` update.
+- Publish paths:
+  - GitHub workflow: `.github/workflows/cli-publish.yml`.
+  - Local publish helper: `bun release cli`.
+- npm dist-tags and git tags are separate. `--tag latest` and `--tag nightly` are npm registry channels. `cli-vX.Y.Z` is a git tag for source history and GitHub releases.
+- The GitHub main release workflow runs from `main`, requires an existing `cli-vX.Y.Z` tag, checks out that tag, and publishes from it.
+- The GitHub nightly workflow publishes to npm with the `nightly` dist-tag and does not create a tag.
+- The local release helper requires a clean checkout and `cli-vX.Y.Z` to point at `HEAD` locally and on `origin` before publishing.
+- Local GitHub release creation requires `gh` to be authenticated with release permissions for the repo.
+- Always ask before pushing commits or tags.
+- Do not amend commits unless explicitly requested.
+
+## Step 0: Release the SDK first if it changed
+
+Do this before anything else in the Workflow below.
+
+The CLI builds and ships against the SDK source in the monorepo (`workspace:*` for `@cline/core`, `@cline/shared`, and the rest), so a CLI release always contains the latest SDK code whether or not the SDK was released. The build and tests use that source too, not anything from npm. Releasing the SDK alongside the CLI is still worth doing for two reasons:
+
+- Hub freshness. The hub daemon lives in `@cline/core` and stamps a `buildId` that defaults to the `@cline/core` package version (`resolveHubBuildId` in `sdk/packages/core/src/hub/discovery/index.ts`). A running hub is only retired and respawned when that `buildId` changes (`isCompatibleHubRecord` / `retireIncompatibleHub` in `sdk/packages/core/src/hub/daemon/index.ts`). So if the SDK code changed but the version did not, a user who upgrades the CLI keeps talking to their already-running hub, which is still executing the old SDK code. Bumping the SDK version makes the new CLI's `buildId` differ, so the stale hub is detected as incompatible and respawned with the fresh code.
+- Release hygiene. We want regular SDK releases; cutting one whenever we cut a CLI release keeps the published SDK in step with what the CLI ships.
+
+So when the SDK has changed, release it first (which bumps the `@cline/core` version), then cut the CLI release on top of that bump. Leave the CLI's SDK dependency as `workspace:*` — the fix is to release the SDK, not to pin the CLI.
+
+1. Check for unreleased SDK changes.
+
+```sh
+git fetch origin --tags
+git tag --list 'sdk/sdk/v*' 'sdk-v*' --sort=-v:refname | head -1
+git log <last-sdk-tag>..origin/main --oneline --no-merges -- sdk/packages
+```
+
+`sdk/<pkg>/v*` tags are created by the `sdk-publish.yml` workflow; `sdk-v*` tags are created by the local `bun release sdk` helper. Use whichever is newest as the baseline.
+
+If `git log` prints no commits, the SDK is already up to date. Skip the rest of Step 0 and continue with the Workflow below.
+
+If it prints commits, sanity-check the diff (ignore entries that are only the previous version-bump commit's lockfile or generated files), then release the SDK.
+
+2. Decide the SDK version bump.
+
+All SDK packages share one version, read from `sdk/packages/llms/package.json`. Ask whether this is patch, minor, major, or an explicit version. Patch is the default. Do not guess if the user has not made it clear.
+
+3. Draft the SDK release notes and update the changelog.
+
+Draft user-facing notes from the SDK commits found in step 1, translating commit messages into user-facing language (same approach as the CLI release notes below). Prepend a new `## <version>` section with those notes to the top of `sdk/CHANGELOG.md`, using the header format `## <version>` with no date — the same flat, newest-on-top format as `apps/cli/CHANGELOG.md`. This is the SDK changelog (all SDK packages share one version) and it is maintained by hand; the `sdk-publish.yml` workflow does not read it.
+
+4. Bump versions and regenerate.
+
+```sh
+bun run version <version>
+```
+
+This bumps every SDK `package.json` to the new version, regenerates the lockfile and the generated model catalog, formats, and builds. Review the result.
+
+5. Commit and push the bump to `main`.
+
+The `sdk-publish.yml` workflow publishes the version that is committed on `main` and tags that commit, so the bump must land on `main` before the workflow runs.
+
+```sh
+git add -A
+git commit -m "chore(sdk): release v<version>"
+```
+
+Ask before pushing:
+
+```sh
+git push origin HEAD
+```
+
+6. Trigger the SDK publish workflow on the `latest` channel.
+
+```sh
+gh workflow run sdk-publish.yml -f channel=latest -f confirm_publish=publish
+gh run list --workflow=sdk-publish.yml --limit=1 --json databaseId,url,status,createdAt --jq '.[0]'
+```
+
+The workflow runs the SDK tests, publishes `@cline/shared`, `@cline/llms`, `@cline/agents`, `@cline/core`, and `@cline/sdk` to npm with the `latest` dist-tag in dependency order, and pushes `sdk/<pkg>/v<version>` git tags.
+
+7. Wait for the SDK workflow to succeed before starting the CLI release.
+
+```sh
+gh run watch <run-id> --exit-status
+```
+
+Do not start the CLI release until this run has finished successfully. The CLI does not install the SDK from npm, but cutting the CLI release on top of a clean, completed SDK release keeps the two in step: the CLI release commit then sits on top of the `@cline/core` version bump, so the shipped CLI carries the new version that forces a running hub to respawn with the new code, and you are not building a CLI release on top of an SDK release that failed midway.
+
+After the SDK release succeeds, pull `main` so the CLI release is prepared on top of the SDK version bump:
+
+```sh
+git checkout main && git pull --ff-only
+```
+
+Then continue with the Workflow below.
+
+For a local SDK publish from an authenticated machine instead of the workflow, `bun release sdk <version>` exists, but prefer the `sdk-publish.yml` workflow for normal releases so the CLI release can gate on a single GitHub Actions run.
+
+## Workflow
+
+Complete Step 0 first. Only proceed once the SDK is released (or you confirmed no SDK release was needed).
+
+1. Gather context.
+
+```sh
+git status --short --branch
+git fetch origin --tags
+git tag --list 'cli-v*' --sort=-v:refname | head -10
+node -p "require('./apps/cli/package.json').version"
+```
+
+Find the latest CLI tag. If there is no `cli-v*` tag, use the first relevant CLI release commit as the baseline and say that the baseline is inferred.
+
+2. Collect release commits.
+
+```sh
+git log <last-cli-tag>..HEAD --oneline --no-merges -- apps/cli sdk/packages sdk/scripts .github/workflows/cli-publish.yml
+```
+
+The `sdk/packages` commits matter here even though the SDK was released separately in Step 0: the CLI bundles the SDK, so SDK changes ship in this CLI release too. Read those commits and fold anything user-relevant to the CLI into the release notes (provider/model updates, behavior changes, fixes the CLI inherits). Skip SDK changes that are purely internal or have no CLI-visible effect.
+
+3. Draft user-facing release notes.
+
+Include user-facing features, fixes, behavior changes, compatibility changes, and notable install or release changes. Exclude pure refactors, tests, style, chores, and internal file moves unless they matter to users.
+
+Write a flat bullet list. Translate commit messages into user-facing language. If a commit is unclear, read the full commit before summarizing it.
+
+Present the draft and wait for approval before editing files.
+
+4. Decide the version bump.
+
+Ask whether this should be patch, minor, major, or an explicit version. Do not guess if the user has not made it clear.
+
+5. Update release files.
+
+Update `apps/cli/package.json` to the approved version.
+
+Prepend a section to `apps/cli/CHANGELOG.md` for the approved version using the approved release notes. Use the header format `## X.Y.Z` with no date. The publish workflow extracts the top section of the changelog by matching `^## [0-9]` and pastes it verbatim into the GitHub release body and the Slack release announcement, so the section content is the release notes that get shipped.
+
+6. Verify before committing.
+
+Run focused checks first:
+
+```sh
+bun -F @cline/cli typecheck
+bun -F @cline/cli test:unit
+```
+
+For higher confidence, run:
+
+```sh
+bun run types
+bun --cwd apps/cli run build:platforms:single
+```
+
+If the user wants full release confidence before tagging, run:
+
+```sh
+bun run test
+bun --cwd apps/cli run build:platforms
+```
+
+Known local-only test failure: `src/commands/distribution-package.test.ts > rejects direct source package packing by default` will fail on machines that have `ignore-scripts=true` in `~/.npmrc` (set by the npm supply-chain hardening guide). Bun reads npm's `ignore-scripts` from `~/.npmrc`, so `bun pm pack --dry-run` skips the source-publish `prepack` guard and exits 0, which the test reads as a failure. CI does not set `ignore-scripts`, so the test passes there. Confirm by running `bun pm pack --dry-run` directly: with `~/.npmrc` in place it exits 0 with no guard output; with `~/.npmrc` moved aside it exits 1 and prints the guard message. This is not a release blocker by itself, but it does mean the local-publish path (`bun release cli`) will also bypass the source-publish guard on this machine; prefer the GitHub Actions publish path on machines with `ignore-scripts=true` set globally, or temporarily unset it (`npm config delete ignore-scripts` or `mv ~/.npmrc ~/.npmrc.bak`) for the duration of a local publish.
+
+7. Commit release changes.
+
+Only after the user approves the notes and version:
+
+```sh
+git add apps/cli/package.json apps/cli/CHANGELOG.md
+git commit -m "chore(cli): release vX.Y.Z"
+```
+
+Ask before pushing the release commit:
+
+```sh
+git push origin HEAD
+```
+
+For the GitHub main release path, ask before creating and pushing the release tag:
+
+```sh
+git tag -a cli-vX.Y.Z -m "CLI vX.Y.Z"
+git push origin refs/tags/cli-vX.Y.Z
+```
+
+8. Publish.
+
+Ask the user which path to use:
+
+- GitHub main release. Use this after the release commit is on `main` and the matching `cli-vX.Y.Z` tag has been pushed. The workflow publishes to npm from that tag, creates the GitHub release, and posts to Slack.
+- Local release. Use this when the user wants to publish from this machine. The local machine must be authenticated to npm and GitHub.
+- GitHub nightly release.
+- Stop after the version commit.
+
+For GitHub main release:
+
+```sh
+gh workflow run cli-publish.yml -f publish_target=main -f git_tag=cli-vX.Y.Z -f confirm_publish=publish
+gh run list --workflow=cli-publish.yml --limit=1 --json url,status,conclusion,createdAt --jq '.[0]'
+```
+
+For GitHub nightly release:
+
+```sh
+gh workflow run cli-publish.yml -f publish_target=nightly
+```
+
+For forced GitHub nightly release:
+
+```sh
+gh workflow run cli-publish.yml -f publish_target=nightly -f force_nightly_publish=true
+```
+
+For local publish:
+
+```sh
+gh auth status
+npm whoami
+git tag -a cli-vX.Y.Z -m "CLI vX.Y.Z"
+git push origin refs/tags/cli-vX.Y.Z
+bun release cli
+```
+
+After a successful local publish, ask before running:
+
+```sh
+gh release create cli-vX.Y.Z --verify-tag --title "CLI vX.Y.Z" --notes "Paste the approved release notes here."
+```
+
+If publishing with another npm dist-tag:
+
+```sh
+bun release cli --tag next
+```
+
+9. Final response.
+
+Report:
+
+- version
+- tag
+- changelog file updated
+- commit hash
+- whether anything was pushed
+- publish path selected
+- workflow URL or local publish result
+- tests and builds run
diff --git a/.clinerules/bun-and-node.md b/.clinerules/bun-and-node.md
new file mode 100644
index 0000000..0cb8a13
--- /dev/null
+++ b/.clinerules/bun-and-node.md
@@ -0,0 +1,55 @@
+# Bun (tooling) and Node (runtime)
+
+This repo uses **bun** for package management and task running, and **Node** as
+the execution runtime. Both are correct at the same time; the distinction is the
+source of most confusion, so keep it straight before editing scripts, configs,
+docs, or comments.
+
+## Use bun for tooling
+
+- `bun install` (never `npm install` / `npm ci`)
+- `bun run <script>` (never `npm run <script>`)
+- `bunx <bin>` (never `npx <bin>`)
+- `bun <file>.ts` to run a TS entrypoint directly (no `ts-node` / `tsx`)
+- `bun esbuild.mjs` to drive the build (esbuild/vite are still the bundlers)
+- `bun run --parallel ...` for parallel tasks
+
+The root `bun.lock` is the single lockfile for the whole workspace, including
+`apps/vscode`, `webview-ui`, and `testing-platform`. There are no per-package npm
+lockfiles.
+
+## Node is the runtime — do NOT rewrite these to bun
+
+The build product runs on Node: the VS Code extension host loads
+`dist/extension.js` as CommonJS under Node, and the standalone `cline-core` is a
+Node process. The following are Node runtime/ABI references and are correct as-is:
+
+| Reference | Why it is Node |
+|-----------|----------------|
+| esbuild `platform: "node"` / `target: "node..."` | The bundle targets the Node runtime (extension host, standalone core). |
+| `TARGET_NODE_VERSION` (`scripts/package-standalone.mjs`) | Pins the Node ABI of the bundled standalone runtime (matches the JetBrains-packaged Node). |
+| `prebuild-install --target=<node version>` | Downloads native `.node` binaries for that Node ABI. |
+| `NODE_PATH=... node cline-core.js` | The standalone core is launched by Node, not bun. |
+| `node:` import specifiers (e.g. `node:fs`) | Node builtin module scheme; unrelated to tooling. |
+| `process.versions.node`, `engines.node`, `@types/node` | Runtime version probe / declared runtime / its types. |
+| `ELECTRON_RUN_AS_NODE` | VS Code/Electron runs the extension host as Node. |
+
+When a file legitimately uses both bun and node (e.g. `package-standalone.mjs`
+does `bun install` but `prebuild-install --target=<node>`), the `node` token is
+the runtime/ABI target, not tooling. If unsure, leave it.
+
+## Tests: bun vs the VS Code host
+
+A test file's runner is decided by its import:
+
+- **`import ... from "bun:test"`** → runs under `bun test` (the node-side unit
+  suites + the SDK/model-catalog suites). `scripts/run-bun-unit-tests.ts`
+  discovers these by the `bun:test` import and runs one isolated bun process per
+  file. `build-tests.js` excludes them from the integration compile so the
+  `bun:test` builtin never reaches Node.
+- **`import ... from "mocha"`** → runs under `@vscode/test-cli` in a real VS Code
+  extension host (Node). These exercise the live `vscode` API and cannot run
+  under bun.
+
+So a file imports `bun:test` XOR `mocha`. Don't add `bun:test` to a test that
+needs the real extension host.
diff --git a/.clinerules/cline-overview.md b/.clinerules/cline-overview.md
new file mode 100644
index 0000000..c84d505
--- /dev/null
+++ b/.clinerules/cline-overview.md
@@ -0,0 +1,764 @@
+# Cline Extension Architecture & Development Guide
+
+## Project Overview
+
+Cline is a VSCode extension that provides AI assistance through a combination of a core extension backend and a React-based webview frontend. The extension is built with TypeScript and follows a modular architecture pattern.
+
+## Architecture Overview
+
+```mermaid
+graph TB
+    subgraph VSCodeExtensionHost[VSCode Extension Host]
+        subgraph CoreExtension[Core Extension]
+            ExtensionEntry[Extension Entry<br/>src/extension.ts]
+            WebviewProvider[WebviewProvider<br/>src/core/webview/index.ts]
+            Controller[Controller<br/>src/core/controller/index.ts]
+            Task[Task<br/>src/core/task/index.ts]
+            GlobalState[VSCode Global State]
+            SecretsStorage[VSCode Secrets Storage]
+            McpHub[McpHub<br/>src/services/mcp/McpHub.ts]
+        end
+
+        subgraph WebviewUI[Webview UI]
+            WebviewApp[React App<br/>webview-ui/src/App.tsx]
+            ExtStateContext[ExtensionStateContext<br/>webview-ui/src/context/ExtensionStateContext.tsx]
+            ReactComponents[React Components]
+        end
+
+        subgraph Storage
+            TaskStorage[Task Storage<br/>Per-Task Files & History]
+            CheckpointSystem[Git-based Checkpoints]
+        end
+
+        subgraph apiProviders[API Providers]
+            AnthropicAPI[Anthropic]
+            OpenRouterAPI[OpenRouter]
+            BedrockAPI[AWS Bedrock]
+            OtherAPIs[Other Providers]
+        end
+
+        subgraph MCPServers[MCP Servers]
+            ExternalMcpServers[External MCP Servers]
+        end
+    end
+
+    %% Core Extension Data Flow
+    ExtensionEntry --> WebviewProvider
+    WebviewProvider --> Controller
+    Controller --> Task
+    Controller --> McpHub
+    Task --> GlobalState
+    Task --> SecretsStorage
+    Task --> TaskStorage
+    Task --> CheckpointSystem
+    Task --> |API Requests| apiProviders
+    McpHub --> |Connects to| ExternalMcpServers
+    Task --> |Uses| McpHub
+
+    %% Webview Data Flow
+    WebviewApp --> ExtStateContext
+    ExtStateContext --> ReactComponents
+
+    %% Bidirectional Communication
+    WebviewProvider <-->|postMessage| ExtStateContext
+
+    style GlobalState fill:#f9f,stroke:#333,stroke-width:2px
+    style SecretsStorage fill:#f9f,stroke:#333,stroke-width:2px
+    style ExtStateContext fill:#bbf,stroke:#333,stroke-width:2px
+    style WebviewProvider fill:#bfb,stroke:#333,stroke-width:2px
+    style McpHub fill:#bfb,stroke:#333,stroke-width:2px
+    style apiProviders fill:#fdb,stroke:#333,stroke-width:2px
+```
+
+## Definitions 
+
+- **Core Extension**: Anything inside the src folder, organized into modular components
+- **Core Extension State**: Managed by the Controller class in src/core/controller/index.ts, which serves as the single source of truth for the extension's state. It manages multiple types of persistent storage (global state, workspace state, and secrets), handles state distribution to both the core extension and webview components, and coordinates state across multiple extension instances. This includes managing API configurations, task history, settings, and MCP configurations.
+- **Webview**: Anything inside the webview-ui. All the react or view's seen by the user and user interaction components
+- **Webview State**: Managed by ExtensionStateContext in webview-ui/src/context/ExtensionStateContext.tsx, which provides React components with access to the extension's state through a context provider pattern. It maintains local state for UI components, handles real-time updates through message events, manages partial message updates, and provides methods for state modifications. The context includes extension version, messages, task history, theme, API configurations, MCP servers, marketplace catalog, and workspace file paths. It synchronizes with the core extension through VSCode's message passing system and provides type-safe access to state through a custom hook (useExtensionState).
+
+### Core Extension Architecture
+
+The core extension follows a clear hierarchical structure:
+
+1. **WebviewProvider** (src/core/webview/index.ts): Manages the webview lifecycle and communication
+2. **Controller** (src/core/controller/index.ts): Handles webview messages and task management
+3. **Task** (src/core/task/index.ts): Executes API requests and tool operations
+
+This architecture provides clear separation of concerns:
+- WebviewProvider focuses on VSCode webview integration
+- Controller manages state and coordinates tasks
+- Task handles the execution of AI requests and tool operations
+
+### WebviewProvider Implementation
+
+The WebviewProvider class in `src/core/webview/index.ts` is responsible for:
+
+- Managing multiple active instances through a static set (`activeInstances`)
+- Handling webview lifecycle events (creation, visibility changes, disposal)
+- Implementing HTML content generation with proper CSP headers
+- Supporting Hot Module Replacement (HMR) for development
+- Setting up message listeners between the webview and extension
+
+The WebviewProvider maintains a reference to the Controller and delegates message handling to it. It also handles the creation of both sidebar and tab panel webviews, allowing Cline to be used in different contexts within VSCode.
+
+### Core Extension State
+
+The `Controller` class manages multiple types of persistent storage:
+
+- **Global State:** Stored across all VSCode instances. Used for settings and data that should persist globally.
+- **Workspace State:** Specific to the current workspace. Used for task-specific data and settings.
+- **Secrets:** Secure storage for sensitive information like API keys.
+
+The `Controller` handles the distribution of state to both the core extension and webview components. It also coordinates state across multiple extension instances, ensuring consistency.
+
+State synchronization between instances is handled through:
+- File-based storage for task history and conversation data
+- VSCode's global state API for settings and configuration
+- Secrets storage for sensitive information
+- Event listeners for file changes and configuration updates
+
+The Controller implements methods for:
+- Saving and loading task state
+- Managing API configurations
+- Handling user authentication
+- Coordinating MCP server connections
+- Managing task history and checkpoints
+
+### Webview State
+
+The `ExtensionStateContext` in `webview-ui/src/context/ExtensionStateContext.tsx` provides React components with access to the extension's state. It uses a context provider pattern and maintains local state for UI components. The context includes:
+
+- Extension version
+- Messages
+- Task history
+- Theme
+- API configurations
+- MCP servers
+- Marketplace catalog
+- Workspace file paths
+
+It synchronizes with the core extension through VSCode's message passing system and provides type-safe access to the state via a custom hook (`useExtensionState`).
+
+The ExtensionStateContext handles:
+- Real-time updates through message events
+- Partial message updates for streaming content
+- State modifications through setter methods
+- Type-safe access to state through a custom hook
+
+## API Provider System
+
+Cline supports multiple AI providers through a modular API provider system. Each provider is implemented as a separate module in the `src/api/providers/` directory and follows a common interface.
+
+### API Provider Architecture
+
+The API system consists of:
+
+1. **API Handlers**: Provider-specific implementations in `src/api/providers/`
+2. **API Transformers**: Stream transformation utilities in `src/api/transform/`
+3. **API Configuration**: User settings for API keys and endpoints
+4. **API Factory**: Builder function to create the appropriate handler
+
+Key providers include:
+- **Anthropic**: Direct integration with Claude models
+- **OpenRouter**: Meta-provider supporting multiple model providers
+- **AWS Bedrock**: Integration with Amazon's AI services
+- **Gemini**: Google's AI models
+- **Cerebras**: High-performance inference with Llama, Qwen, and DeepSeek models
+- **Ollama**: Local model hosting
+- **LM Studio**: Local model hosting
+- **VSCode LM**: VSCode's built-in language models
+
+### API Configuration Management
+
+API configurations are stored securely:
+- API keys are stored in VSCode's secrets storage
+- Model selections and non-sensitive settings are stored in global state
+- The Controller manages switching between providers and updating configurations
+
+The system supports:
+- Secure storage of API keys
+- Model selection and configuration
+- Automatic retry and error handling
+- Token usage tracking and cost calculation
+- Context window management
+
+### Plan/Act Mode API Configuration
+
+Cline supports separate model configurations for Plan and Act modes:
+- Different models can be used for planning vs. execution
+- The system preserves model selections when switching modes
+- The Controller handles the transition between modes and updates the API configuration accordingly
+
+## Task Execution System
+
+The Task class is responsible for executing AI requests and tool operations. Each task runs in its own instance of the Task class, ensuring isolation and proper state management.
+
+### Task Execution Loop
+
+The core task execution loop follows this pattern:
+
+```typescript
+class Task {
+  async initiateTaskLoop(userContent: UserContent, isNewTask: boolean) {
+    while (!this.abort) {
+      // 1. Make API request and stream response
+      const stream = this.attemptApiRequest()
+      
+      // 2. Parse and present content blocks
+      for await (const chunk of stream) {
+        switch (chunk.type) {
+          case "text":
+            // Parse into content blocks
+            this.assistantMessageContent = parseAssistantMessageV2(chunk.text)
+            // Present blocks to user
+            await this.presentAssistantMessage()
+            break
+        }
+      }
+      
+      // 3. Wait for tool execution to complete
+      await pWaitFor(() => this.userMessageContentReady)
+      
+      // 4. Continue loop with tool result
+      const recDidEndLoop = await this.recursivelyMakeClineRequests(
+        this.userMessageContent
+      )
+    }
+  }
+}
+```
+
+### Message Streaming System
+
+The streaming system handles real-time updates and partial content:
+
+```typescript
+class Task {
+  async presentAssistantMessage() {
+    // Handle streaming locks to prevent race conditions
+    if (this.presentAssistantMessageLocked) {
+      this.presentAssistantMessageHasPendingUpdates = true
+      return
+    }
+    this.presentAssistantMessageLocked = true
+
+    // Present current content block
+    const block = this.assistantMessageContent[this.currentStreamingContentIndex]
+    
+    // Handle different types of content
+    switch (block.type) {
+      case "text":
+        await this.say("text", content, undefined, block.partial)
+        break
+      case "tool_use":
+        // Handle tool execution
+        break
+    }
+
+    // Move to next block if complete
+    if (!block.partial) {
+      this.currentStreamingContentIndex++
+    }
+  }
+}
+```
+
+### Tool Execution Flow
+
+Tools follow a strict execution pattern:
+
+```typescript
+class Task {
+  async executeToolWithApproval(block: ToolBlock) {
+    // 1. Check auto-approval settings
+    if (this.shouldAutoApproveTool(block.name)) {
+      await this.say("tool", message)
+      this.consecutiveAutoApprovedRequestsCount++
+    } else {
+      // 2. Request user approval
+      const didApprove = await askApproval("tool", message)
+      if (!didApprove) {
+        this.didRejectTool = true
+        return
+      }
+    }
+
+    // 3. Execute tool
+    const result = await this.executeTool(block)
+
+    // 4. Save checkpoint
+    await this.saveCheckpoint()
+
+    // 5. Return result to API
+    return result
+  }
+}
+```
+
+### Error Handling & Recovery
+
+The system includes robust error handling:
+
+```typescript
+class Task {
+  async handleError(action: string, error: Error) {
+    // 1. Check if task was abandoned
+    if (this.abandoned) return
+    
+    // 2. Format error message
+    const errorString = `Error ${action}: ${error.message}`
+    
+    // 3. Present error to user
+    await this.say("error", errorString)
+    
+    // 4. Add error to tool results
+    pushToolResult(formatResponse.toolError(errorString))
+    
+    // 5. Cleanup resources
+    await this.diffViewProvider.revertChanges()
+    await this.browserSession.closeBrowser()
+  }
+}
+```
+
+### API Request & Token Management
+
+The Task class handles API requests with built-in retry, streaming, and token management:
+
+```typescript
+class Task {
+  async *attemptApiRequest(previousApiReqIndex: number): ApiStream {
+    // 1. Wait for MCP servers to connect
+    await pWaitFor(() => this.controllerRef.deref()?.mcpHub?.isConnecting !== true)
+
+    // 2. Manage context window
+    const previousRequest = this.clineMessages[previousApiReqIndex]
+    if (previousRequest?.text) {
+      const { tokensIn, tokensOut } = JSON.parse(previousRequest.text || "{}")
+      const totalTokens = (tokensIn || 0) + (tokensOut || 0)
+      
+      // Truncate conversation if approaching context limit
+      if (totalTokens >= maxAllowedSize) {
+        this.conversationHistoryDeletedRange = this.contextManager.getNextTruncationRange(
+          this.apiConversationHistory,
+          this.conversationHistoryDeletedRange,
+          totalTokens / 2 > maxAllowedSize ? "quarter" : "half"
+        )
+      }
+    }
+
+    // 3. Handle streaming with automatic retry
+    try {
+      this.isWaitingForFirstChunk = true
+      const firstChunk = await iterator.next()
+      yield firstChunk.value
+      this.isWaitingForFirstChunk = false
+      
+      // Stream remaining chunks
+      yield* iterator
+    } catch (error) {
+      // 4. Error handling with retry
+      if (isOpenRouter && !this.didAutomaticallyRetryFailedApiRequest) {
+        await setTimeoutPromise(1000)
+        this.didAutomaticallyRetryFailedApiRequest = true
+        yield* this.attemptApiRequest(previousApiReqIndex)
+        return
+      }
+      
+      // 5. Ask user to retry if automatic retry failed
+      const { response } = await this.ask(
+        "api_req_failed",
+        this.formatErrorWithStatusCode(error)
+      )
+      if (response === "yesButtonClicked") {
+        await this.say("api_req_retried")
+        yield* this.attemptApiRequest(previousApiReqIndex)
+        return
+      }
+    }
+  }
+}
+```
+
+Key features:
+
+1. **Context Window Management**
+   - Tracks token usage across requests
+   - Automatically truncates conversation when needed
+   - Preserves important context while freeing space
+   - Handles different model context sizes
+
+2. **Streaming Architecture**
+   - Real-time chunk processing
+   - Partial content handling
+   - Race condition prevention
+   - Error recovery during streaming
+
+3. **Error Handling**
+   - Automatic retry for transient failures
+   - User-prompted retry for persistent issues
+   - Detailed error reporting
+   - State cleanup on failure
+
+4. **Token Tracking**
+   - Per-request token counting
+   - Cumulative usage tracking
+   - Cost calculation
+   - Cache hit monitoring
+
+### Context Management System
+
+The Context Management System handles conversation history truncation to prevent context window overflow errors. Implemented in the `ContextManager` class, it ensures long-running conversations remain within model context limits while preserving critical context.
+
+Key features:
+
+1. **Model-Aware Sizing**: Dynamically adjusts based on different model context windows (64K for DeepSeek, 128K for most models, 200K for Claude).
+
+2. **Proactive Truncation**: Monitors token usage and preemptively truncates conversations when approaching limits, maintaining buffers of 27K-40K tokens depending on the model.
+
+3. **Intelligent Preservation**: Always preserves the original task message and maintains the user-assistant conversation structure when truncating.
+
+4. **Adaptive Strategies**: Uses different truncation strategies based on context pressure - removing half of the conversation for moderate pressure or three-quarters for severe pressure.
+
+5. **Error Recovery**: Includes specialized detection for context window errors from different providers with automatic retry and more aggressive truncation when needed.
+
+### Task State & Resumption
+
+The Task class provides robust task state management and resumption capabilities:
+
+```typescript
+class Task {
+  async resumeTaskFromHistory() {
+    // 1. Load saved state
+    this.clineMessages = await getSavedClineMessages(this.getContext(), this.taskId)
+    this.apiConversationHistory = await getSavedApiConversationHistory(this.getContext(), this.taskId)
+
+    // 2. Handle interrupted tool executions
+    const lastMessage = this.apiConversationHistory[this.apiConversationHistory.length - 1]
+    if (lastMessage.role === "assistant") {
+      const toolUseBlocks = content.filter(block => block.type === "tool_use")
+      if (toolUseBlocks.length > 0) {
+        // Add interrupted tool responses
+        const toolResponses = toolUseBlocks.map(block => ({
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: "Task was interrupted before this tool call could be completed."
+        }))
+        modifiedOldUserContent = [...toolResponses]
+      }
+    }
+
+    // 3. Notify about interruption
+    const agoText = this.getTimeAgoText(lastMessage?.ts)
+    newUserContent.push({
+      type: "text",
+      text: `[TASK RESUMPTION] This task was interrupted ${agoText}. It may or may not be complete, so please reassess the task context.`
+    })
+
+    // 4. Resume task execution
+    await this.initiateTaskLoop(newUserContent, false)
+  }
+
+  private async saveTaskState() {
+    // Save conversation history
+    await saveApiConversationHistory(this.getContext(), this.taskId, this.apiConversationHistory)
+    await saveClineMessages(this.getContext(), this.taskId, this.clineMessages)
+    
+    // Create checkpoint
+    const commitHash = await this.checkpointTracker?.commit()
+    
+    // Update task history
+    await this.controllerRef.deref()?.updateTaskHistory({
+      id: this.taskId,
+      ts: lastMessage.ts,
+      task: taskMessage.text,
+      // ... other metadata
+    })
+  }
+}
+```
+
+Key aspects of task state management:
+
+1. **Task Persistence**
+   - Each task has a unique ID and dedicated storage directory
+   - Conversation history is saved after each message
+   - File changes are tracked through Git-based checkpoints
+   - Terminal output and browser state are preserved
+
+2. **State Recovery**
+   - Tasks can be resumed from any point
+   - Interrupted tool executions are handled gracefully
+   - File changes can be restored from checkpoints
+   - Context is preserved across VSCode sessions
+
+3. **Workspace Synchronization**
+   - File changes are tracked through Git
+   - Checkpoints are created after tool executions
+   - State can be restored to any checkpoint
+   - Changes can be compared between checkpoints
+
+4. **Error Recovery**
+   - Failed API requests can be retried
+   - Interrupted tool executions are marked
+   - Resources are cleaned up properly
+   - User is notified of state changes
+
+## Plan/Act Mode System
+
+Cline implements a dual-mode system that separates planning from execution:
+
+### Mode Architecture
+
+The Plan/Act mode system consists of:
+
+1. **Mode State**: Stored in `chatSettings.mode` in the Controller's state
+2. **Mode Switching**: Handled by `togglePlanActModeWithChatSettings` in the Controller
+3. **Mode-specific Models**: Optional configuration to use different models for each mode
+4. **Mode-specific Prompting**: Different system prompts for planning vs. execution
+
+### Mode Switching Process
+
+When switching between modes:
+
+1. The current model configuration is saved to mode-specific state
+2. The previous mode's model configuration is restored
+3. The Task instance is updated with the new mode
+4. The webview is notified of the mode change
+5. Telemetry events are captured for analytics
+
+### Plan Mode
+
+Plan mode is designed for:
+- Information gathering and context building
+- Asking clarifying questions
+- Creating detailed execution plans
+- Discussing approaches with the user
+
+In Plan mode, the AI uses the `plan_mode_respond` tool to engage in conversational planning without executing actions.
+
+### Act Mode
+
+Act mode is designed for:
+- Executing the planned actions
+- Using tools to modify files, run commands, etc.
+- Implementing the solution
+- Providing results and completion feedback
+
+In Act mode, the AI has access to all tools except `plan_mode_respond` and focuses on implementation rather than discussion.
+
+## Data Flow & State Management
+
+### Core Extension Role
+
+The Controller acts as the single source of truth for all persistent state. It:
+- Manages VSCode global state and secrets storage
+- Coordinates state updates between components
+- Ensures state consistency across webview reloads
+- Handles task-specific state persistence
+- Manages checkpoint creation and restoration
+
+### Terminal Management
+
+The Task class manages terminal instances and command execution:
+
+```typescript
+class Task {
+  async executeCommandTool(command: string): Promise<[boolean, ToolResponse]> {
+    // 1. Get or create terminal
+    const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd)
+    terminalInfo.terminal.show()
+
+    // 2. Execute command with output streaming
+    const process = this.terminalManager.runCommand(terminalInfo, command)
+    
+    // 3. Handle real-time output
+    let result = ""
+    process.on("line", (line) => {
+      result += line + "\n"
+      if (!didContinue) {
+        sendCommandOutput(line)
+      } else {
+        this.say("command_output", line)
+      }
+    })
+
+    // 4. Wait for completion or user feedback
+    let completed = false
+    process.once("completed", () => {
+      completed = true
+    })
+
+    await process
+
+    // 5. Return result
+    if (completed) {
+      return [false, `Command executed.\n${result}`]
+    } else {
+      return [
+        false,
+        `Command is still running in the user's terminal.\n${result}\n\nYou will be updated on the terminal status and new output in the future.`
+      ]
+    }
+  }
+}
+```
+
+Key features:
+1. **Terminal Instance Management**
+   - Multiple terminal support
+   - Terminal state tracking (busy/inactive)
+   - Process cooldown monitoring
+   - Output history per terminal
+
+2. **Command Execution**
+   - Real-time output streaming
+   - User feedback handling
+   - Process state monitoring
+   - Error recovery
+
+### Browser Session Management
+
+The Task class handles browser automation through Puppeteer:
+
+```typescript
+class Task {
+  async executeBrowserAction(action: BrowserAction): Promise<BrowserActionResult> {
+    switch (action) {
+      case "launch":
+        // 1. Launch browser with fixed resolution
+        await this.browserSession.launchBrowser()
+        return await this.browserSession.navigateToUrl(url)
+
+      case "click":
+        // 2. Handle click actions with coordinates
+        return await this.browserSession.click(coordinate)
+
+      case "type":
+        // 3. Handle keyboard input
+        return await this.browserSession.type(text)
+
+      case "close":
+        // 4. Clean up resources
+        return await this.browserSession.closeBrowser()
+    }
+  }
+}
+```
+
+Key aspects:
+1. **Browser Control**
+   - Fixed 900x600 resolution window
+   - Single instance per task lifecycle
+   - Automatic cleanup on task completion
+   - Console log capture
+
+2. **Interaction Handling**
+   - Coordinate-based clicking
+   - Keyboard input simulation
+   - Screenshot capture
+   - Error recovery
+
+## MCP (Model Context Protocol) Integration
+
+### MCP Architecture
+
+The MCP system consists of:
+
+1. **McpHub Class**: Central manager in `src/services/mcp/McpHub.ts`
+2. **MCP Connections**: Manages connections to external MCP servers
+3. **MCP Settings**: Configuration stored in a JSON file
+4. **MCP Marketplace**: Online catalog of available MCP servers
+5. **MCP Tools & Resources**: Capabilities exposed by connected servers
+
+The McpHub class:
+- Manages the lifecycle of MCP server connections
+- Handles server configuration through a settings file
+- Provides methods for calling tools and accessing resources
+- Implements auto-approval settings for MCP tools
+- Monitors server health and handles reconnection
+
+### MCP Server Types
+
+Cline supports two types of MCP server connections:
+- **Stdio**: Command-line based servers that communicate via standard I/O
+- **SSE**: HTTP-based servers that communicate via Server-Sent Events
+
+### MCP Server Management
+
+The McpHub class provides methods for:
+- Discovering and connecting to MCP servers
+- Monitoring server health and status
+- Restarting servers when needed
+- Managing server configurations
+- Setting timeouts and auto-approval rules
+
+### MCP Tool Integration
+
+MCP tools are integrated into the Task execution system:
+- Tools are discovered and registered at connection time
+- The Task class can call MCP tools through the McpHub
+- Tool results are streamed back to the AI
+- Auto-approval settings can be configured per tool
+
+### MCP Marketplace
+
+The MCP Marketplace provides:
+- A catalog of available MCP servers
+- One-click installation
+- README previews
+- Server status monitoring
+
+The Controller class manages MCP servers through the McpHub service:
+
+```typescript
+class Controller {
+  mcpHub?: McpHub
+
+  constructor(context: vscode.ExtensionContext, webviewProvider: WebviewProvider) {
+    this.mcpHub = new McpHub(this)
+  }
+
+  async downloadMcp(mcpId: string) {
+    // Fetch server details from marketplace
+    const response = await axios.post<McpDownloadResponse>(
+      "https://api.cline.bot/v1/mcp/download",
+      { mcpId },
+      {
+        headers: { "Content-Type": "application/json" },
+        timeout: 10000,
+      }
+    )
+
+    // Create task with context from README
+    const task = `Set up the MCP server from ${mcpDetails.githubUrl}...`
+
+    // Initialize task and show chat view
+    await this.initClineWithTask(task)
+  }
+}
+```
+
+## Conclusion
+
+This guide provides a comprehensive overview of the Cline extension architecture, with special focus on state management, data persistence, and code organization. Following these patterns ensures robust feature implementation with proper state handling across the extension's components.
+
+Remember:
+- Always persist important state in the extension
+- The core extension follows a WebviewProvider -> Controller -> Task flow
+- Use proper typing for all state and messages
+- Handle errors and edge cases
+- Test state persistence across webview reloads
+- Follow the established patterns for consistency
+- Place new code in appropriate directories
+- Maintain clear separation of concerns
+- Install dependencies in correct package.json
+
+## Contributing
+
+Contributions to the Cline extension are welcome! Please follow these guidelines:
+
+When adding new tools or API providers, follow the existing patterns in the `src/integrations/` and `src/api/providers/` directories, respectively. Ensure that your code is well-documented and includes appropriate error handling.
+
+The `.clineignore` file allows users to specify files and directories that Cline should not access. When implementing new features, respect the `.clineignore` rules and ensure that your code does not attempt to read or modify ignored files.
diff --git a/.clinerules/debug-harness.md b/.clinerules/debug-harness.md
new file mode 100644
index 0000000..daa064f
--- /dev/null
+++ b/.clinerules/debug-harness.md
@@ -0,0 +1,128 @@
+# Debug Harness
+
+HTTP-controlled debugger for the VSCode extension at `src/dev/debug-harness/server.ts`.
+
+## Quick start
+
+```bash
+# Build extension first if needed (protos + esbuild):
+bun run protos && IS_DEV=true bun esbuild.mjs
+
+# Launch (skip-build if already built):
+bun src/dev/debug-harness/server.ts --skip-build --auto-launch
+
+# In another terminal:
+curl localhost:19229/api -d '{"method":"status"}'
+```
+
+## Data Isolation
+
+The debugee runs with `CLINE_DIR=~/.cline2` by default, separate from your real `~/.cline`.
+This prevents the debugee's logout from logging out the debugger, and vice versa.
+Override with `--cline-dir /tmp/test-dir`. Check with `status()` → `clineDir`.
+
+## Browser Capture & OAuth
+
+The debugee runs with `CLINE_CAPTURE_BROWSER=1`, which intercepts `openExternal()` in
+`src/utils/env.ts`. URLs are captured instead of opening a real browser:
+
+- Logged to `$CLINE_DIR/data/debug-captured-urls.jsonl`
+- POSTed in real-time to `/captured-url` on the harness server
+- Queryable via `oauth.captured_urls`
+
+### OAuth API
+
+- **`oauth.captured_urls`** `{clear?}` — URLs the debugee tried to open
+- **`oauth.read_stored_token`** — Check auth token presence in secrets.json
+- **`oauth.simulate_callback`** `{path, code?, state?, provider?, token?}` — Build vscode:// callback URI
+- **`oauth.read_captured_urls_file`** — Read on-disk JSONL of captured URLs
+
+### OAuth testing flow
+
+For **Cline OAuth** (SDK local callback): The SDK starts a local HTTP server, the auth URL
+is captured. To complete: open the captured URL in a real browser (it redirects back to the
+SDK's callback server), OR extract the callback port and `curl http://127.0.0.1:PORT/callback?code=...`.
+
+For **MCP/Provider OAuth** (vscode:// URI): The redirect goes to a vscode:// URI.
+`oauth.simulate_callback` only *builds* the URI — it does not deliver it, and the ESM
+extension host can't `require()` the handler. To actually deliver the callback, call the
+debug-only hook via `ext.evaluate` (with `awaitPromise: true`):
+`globalThis.__clineHandleUri("vscode://saoudrizwan.claude-dev/...?code=...&state=...")`.
+It runs the same `SharedUriHandler.handleUri` as VSCode's real URI handler and exists only
+when `CLINE_CAPTURE_BROWSER` is set (the harness always sets it; never ships in prod).
+For end-to-end MCP OAuth, get a real `code` from the local MCP OAuth test server
+(`bun run dev:mcp-oauth-test-server`).
+
+## Navigating Views — Use Commands, Not Clicks
+
+Don't try to find/click small sidebar icons. Use VSCode commands via command palette.
+Registered in `src/registry.ts`:
+
+| Command | View |
+|---------|------|
+| `cline.accountButtonClicked` | Account / sign-in |
+| `cline.historyButtonClicked` | Task history |
+| `cline.settingsButtonClicked` | Settings |
+| `cline.mcpButtonClicked` | MCP servers |
+| `cline.plusButtonClicked` | New task (chat) |
+| `cline.worktreesButtonClicked` | Worktrees |
+
+```bash
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+```
+
+## Key commands
+
+All via `POST localhost:19229/api` with `{"method":"...", "params":{...}}`:
+
+- **`launch`** / **`shutdown`** — lifecycle
+- **`ui.screenshot`** — screenshot to `/tmp/cline-debug/`; returns `{path}` — **use `read_file` on the path to examine, do NOT `open` the file** (Preview.app covers the VSCode window)
+- **`ui.open_sidebar`** — open the Cline sidebar
+- **`ext.set_breakpoint`** `{file, line, condition?}` — breakpoint by source file (sourcemap-resolved)
+- **`ext.evaluate`** `{expression, callFrameId?}` — eval in extension host
+- **`ext.resume`** / **`ext.step_over`** / **`ext.step_into`** — stepping
+- **`ext.call_stack`** — inspect when paused
+- **`web.evaluate`** `{expression}` — eval in webview
+- **`web.post_message`** `{message}` — send postMessage to extension host via exposed vsCodeApi
+- **`wait_for_pause`** `{timeout?}` — block until breakpoint hit
+- **`ui.locator`** `{role?, testId?, text?, frame?}` — Playwright locator (auto-retries on stale sidebar frame)
+- **`ui.react_input`** `{text, selector?, clear?, submit?}` — set React textarea value via `execCommand('insertText')`; works reliably across multiple tasks
+- **`ui.send_message`** `{text, images?, files?, responseType?}` — send chat message bypassing the textarea entirely (via gRPC postMessage)
+- **`ui.command_palette`** `{command}` — run VSCode command
+
+## Typical Session
+
+```bash
+# 1. Launch
+curl localhost:19229/api -d '{"method":"launch","params":{"skipBuild":true}}'
+
+# 2. Open sidebar + dismiss overlays (ALWAYS do this first)
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+
+# 3. Navigate to view
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+
+# 4. Check captured OAuth URLs if testing auth
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+
+# 5. Verify
+curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+```
+
+## Caveats
+
+- **⚠️ Dismiss promotional overlays FIRST**: On fresh launches, full-screen promo overlays block the sidebar. **Dismiss immediately after `ui.open_sidebar`**, before any other interaction or screenshot. May need to run twice:
+  ```bash
+  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
+  curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+  ```
+- **Screenshots — don't open the file**: `ui.screenshot` and `ui.sidebar_screenshot` save PNGs to `/tmp/cline-debug/` and return the `{path}`. Use `read_file` on that path to examine screenshots. Running `open <path>` launches Preview.app on macOS which covers the VSCode window.
+- **Scripts count = 0 after launch**: CDP connects after extension host starts, so scripts parsed during startup aren't tracked. Breakpoints still work via sourcemap resolution.
+- **Port 9230**: Extension host inspector. If another VSCode instance uses this port, the harness will fail to connect. Kill other debug instances first.
+- **macOS only** for now (Playwright Electron launch behavior).
+- **Webview CDP**: `connect_webview` may fail depending on Electron version. `web.evaluate` still works via Playwright's `frame.evaluate()` fallback.
+- **Sourcemap paths**: esbuild outputs relative paths like `../src/extension.ts` in the sourcemap. The resolver handles this, but if a file isn't found, use `ext.source_files` to see exact paths.
+- **OAuth with fake codes**: Browser capture intercepts the URL but doesn't provide a valid auth code. For real OAuth testing, open the captured URL in a browser. For unit testing, mock the token exchange.
+
+See `src/dev/debug-harness/README.md` for full API reference.
diff --git a/.clinerules/general.md b/.clinerules/general.md
new file mode 100644
index 0000000..32daac1
--- /dev/null
+++ b/.clinerules/general.md
@@ -0,0 +1,204 @@
+This file is the secret sauce for working effectively in this codebase. It captures tribal knowledge—the nuanced, non-obvious patterns that make the difference between a quick fix and hours of back-and-forth & human intervention.
+
+**When to add to this file:**
+- User had to intervene, correct, or hand-hold
+- Multiple back-and-forth attempts were needed to get something working
+- You discovered something that required reading many files to understand
+- A change touched files you wouldn't have guessed
+- Something worked differently than you expected
+- User explicitly asks to "add this to CLAUDE.md"
+
+**Proactively suggest additions** when any of the above happen—don't wait to be asked.
+
+**What NOT to add:** Stuff you can figure out from reading a few files, obvious patterns, or standard practices. This file should be high-signal, not comprehensive.
+
+## Miscellaneous
+- The whole repo (including `apps/vscode`) uses **bun** for package management and task running. Emit `bun run X` / `bun install` / `bunx <bin>` / `bun file.ts`, never npm/npx. Node remains the *runtime* (VS Code's extension host and the standalone cline-core are Node), so Node-runtime tokens are legitimate and must not be "fixed" to bun — see @.clinerules/bun-and-node.md for the keep-list vs rewrite-list.
+- Avoid provider-specific string matching / hardcoded provider branches when fixing provider/config plumbing. Prefer provider metadata, shared catalog/defaults, explicit protocol/client capabilities, or centralized normalization utilities that apply by data shape rather than `providerId === "..."`. If a provider exception seems necessary, stop and explain why instead of adding ad-hoc string matching.
+- This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `bun run compile`, not `bun run build`).
+- 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
+
+## Searching the Codebase — Avoiding Build Output
+
+Several directories contain build output or generated code that produces
+noisy or unusable results with `search_files` / `grep`:
+
+| Directory | What it is | Why it's a problem |
+|-----------|-----------|-------------------|
+| `out/` | esbuild bundle output | Mirrors `src/` structure as minified JS — every search gets duplicate hits on single-line files |
+| `dist/` | Packaged extension | Entire extension bundled into one minified `extension.js` (~1 long line) |
+| `dist-standalone/` | Standalone build output | Same minification issue |
+| `src/generated/` | Generated protobuf code | Auto-generated from `proto/`; not the source of truth |
+| `src/shared/proto/` | Generated proto type defs | Auto-generated from `proto/`; not the source of truth |
+| `node_modules/` | Dependencies | Huge, not project source |
+
+### How to skip build output
+
+**`search_files`** — Point at `src/` (not the project root) and use `file_pattern`:
+```
+search_files(path="src/core", regex="myFunction", file_pattern="*.ts")
+```
+The `file_pattern` parameter is the most effective filter — e.g. `"*.ts"`,
+`"*.tsx"`, `"*.proto"`.
+
+**`grep` directly** — Exclude build dirs and restrict to source extensions:
+```bash
+grep -rn "myFunction" src/ --include="*.ts" --exclude-dir={out,dist,node_modules,generated}
+```
+
+### When you must search minified files
+
+Sometimes you need to verify what got bundled (e.g., checking if a change
+made it into the build). Minified files are typically one long line, so
+normal `grep` shows the entire file as context. Use these approaches:
+
+- **`grep -oP`** to extract just the match with limited surrounding context:
+  ```bash
+  grep -oP '.{0,40}myFunction.{0,40}' dist/extension.js
+  ```
+- **`read_file`** on files in `out/src/` — these have source maps and are
+  more readable than `dist/extension.js` (which is the fully bundled output).
+- **Source maps** — `out/src/*.js.map` and `dist/extension.js.map` can be
+  used to trace minified output back to original source locations.
+
+## gRPC/Protobuf Communication
+The extension and webview communicate via gRPC-like protocol over VS Code message passing.
+
+**Proto files live in `proto/`** (e.g., `proto/cline/task.proto`, `proto/cline/ui.proto`)
+- Each feature domain has its own `.proto` file
+- For simple data, use shared types in `proto/cline/common.proto` (`StringRequest`, `Empty`, `Int64Request`)
+- For complex data, define custom messages in the feature's `.proto` file
+- Naming: Services `PascalCaseService`, RPCs `camelCase`, Messages `PascalCase`
+- For streaming responses, use `stream` keyword (see `subscribeToAuthCallback` in `account.proto`)
+
+**Run `bun run protos`** after any proto changes—generates types in:
+- `src/shared/proto/` - Shared type definitions
+- `src/generated/grpc-js/` - Service implementations
+- `src/generated/nice-grpc/` - Promise-based clients
+- `src/generated/hosts/` - Generated handlers
+
+**Adding new enum values** (like a new `ClineSay` type) requires updating conversion mappings in `src/shared/proto-conversions/cline-message.ts`
+
+**Adding new RPC methods** requires:
+- Handler in `src/core/controller/<domain>/`
+- Call from webview via generated client: `UiServiceClient.scrollToSettings(StringRequest.create({ value: "browser" }))`
+
+**Example—the `explain-changes` feature touched:**
+- `proto/cline/task.proto` - Added `ExplainChangesRequest` message and `explainChanges` RPC
+- `proto/cline/ui.proto` - Added `GENERATE_EXPLANATION = 29` to `ClineSay` enum
+- `src/shared/ExtensionMessage.ts` - Added `ClineSayGenerateExplanation` type
+- `src/shared/proto-conversions/cline-message.ts` - Added mapping for new say type
+- `src/core/controller/task/explainChanges.ts` - Handler implementation
+- `webview-ui/src/components/chat/ChatRow.tsx` - UI rendering
+
+## Adding New Global State Keys
+Adding a new key to global state requires updates in multiple places. Missing any step causes silent failures.
+
+Required steps:
+1. Type definition in `src/shared/storage/state-keys.ts` - Add to `GlobalState` or `Settings` interface
+2. Add any default value or transform in `src/shared/storage/state-keys.ts` if the key needs one
+3. Read and write the value through `StateManager` (`setGlobalState()` / `getGlobalStateKey()`) after initialization
+
+Persistent state is file-backed through `StateManager`; do not add new runtime reads or writes against VS Code `ExtensionContext` storage. That storage is only a legacy migration source.
+
+Settings plumbing gotcha: if a key is user-toggleable from settings, wire both controller update paths:
+- `src/core/controller/state/updateSettings.ts` for webview `updateSetting(...)`
+- `src/core/controller/state/updateSettingsCli.ts` for CLI/ACP settings updates
+Missing one path causes a toggle to appear to change in one surface while the backend state stays unchanged.
+
+Webview toggle gotcha: settings changes must also round-trip back in state payloads.
+- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `bun run protos`
+- Include the key in `Controller.getStateToPostToWebview()` (`src/core/controller/index.ts`)
+- Ensure `ExtensionState` and webview defaults include the key (`src/shared/ExtensionMessage.ts`, `webview-ui/src/context/ExtensionStateContext.tsx`)
+If this round-trip wiring is missing, the backend value can update but the toggle in webview appears stuck or reverts.
+
+## StateManager Cache vs Direct globalState Access
+StateManager uses an in-memory cache populated during `StateManager.initialize()` from file-backed storage. For most state, use `controller.stateManager.setGlobalState()`/`getGlobalStateKey()`.
+
+Exception: host migration code may read legacy VS Code storage before file-backed storage is initialized.
+
+Example pattern:
+```typescript
+// Writing (normal pattern)
+controller.stateManager.setGlobalState("myKey", value)
+
+// Reading after initialization
+const value = controller.stateManager.getGlobalStateKey("myKey")
+```
+
+Use `context.globalState` only in VS Code migration code that copies legacy ExtensionContext values into the shared file-backed stores.
+
+## ChatRow Cancelled/Interrupted States
+When a ChatRow displays a loading/in-progress state (spinner), you must handle what happens when the task is cancelled. This is non-obvious because cancellation doesn't update the message content—you have to infer it from context.
+
+**The pattern:**
+1. A message has a `status` field (e.g., `"generating"`, `"complete"`, `"error"`) stored in `message.text` as JSON
+2. When cancelled mid-operation, the status stays `"generating"` forever—no one updates it
+3. To detect cancellation, check TWO conditions:
+   - `!isLast` — if this message is no longer the last message, something else happened after it (interrupted)
+   - `lastModifiedMessage?.ask === "resume_task" || "resume_completed_task"` — task was just cancelled and is waiting to resume
+
+**Example from `generate_explanation`:**
+```tsx
+const wasCancelled =
+    explanationInfo.status === "generating" &&
+    (!isLast ||
+        lastModifiedMessage?.ask === "resume_task" ||
+        lastModifiedMessage?.ask === "resume_completed_task")
+const isGenerating = explanationInfo.status === "generating" && !wasCancelled
+```
+
+**Why both checks?**
+- `!isLast` catches: cancelled → resumed → did other stuff → this old message is stale
+- `lastModifiedMessage?.ask === "resume_task"` catches: just cancelled, hasn't resumed yet, this message is still technically "last"
+
+**See also:** `BrowserSessionRow.tsx` uses similar pattern with `isLastApiReqInterrupted` and `isLastMessageResume`.
+
+**Backend side:** When streaming is cancelled, clean up properly (close tabs, clear comments, etc.) by checking `taskState.abort` after the streaming function returns.
+
+## Debug Harness: clear inherited VSCode/Electron env vars before launching
+
+The debug harness (`apps/vscode/src/dev/debug-harness/server.ts`) launches a child
+VSCode via Playwright's `_electron.launch({ env: { ...process.env, ... } })`. If you
+run the harness from a process that was itself spawned by VSCode (e.g. the Cline
+extension host, an integrated terminal, or an agent running inside VSCode), the
+parent's VSCode/Electron env vars leak into the child and break the launch.
+
+The fatal one is **`ELECTRON_RUN_AS_NODE=1`**: it makes the child VSCode binary run
+as plain Node, so it rejects every VSCode CLI flag. Symptom:
+
+```
+.../Visual Studio Code.app/Contents/MacOS/Code: bad option: --extensionDevelopmentPath=...
+Error: Process failed to launch!   (Playwright _electron.launch)
+```
+
+This is NOT the macOS Playwright flakiness mentioned in the harness README — it's
+env inheritance. Fix: strip the inherited vars before starting the harness:
+
+```bash
+env -u ELECTRON_RUN_AS_NODE -u ELECTRON_NO_ATTACH_CONSOLE \
+    -u VSCODE_CLI -u VSCODE_CODE_CACHE_PATH -u VSCODE_CRASH_REPORTER_PROCESS_TYPE \
+    -u VSCODE_CWD -u VSCODE_ESM_ENTRYPOINT -u VSCODE_HANDLES_UNCAUGHT_ERRORS \
+    -u VSCODE_IPC_HOOK -u VSCODE_NLS_CONFIG -u VSCODE_PID -u VSCODE_L10N_BUNDLE_LOCATION \
+    bun src/dev/debug-harness/server.ts --auto-launch --skip-build
+```
+
+Check your own env with `env | grep -iE 'electron|vscode_'` first; `ELECTRON_RUN_AS_NODE=1`
+present means you must scrub before launching.
+
+Other harness notes confirmed in practice:
+- The extension host is **ESM** (`VSCODE_ESM_ENTRYPOINT`), so `ext.evaluate` has no
+  `require` and module-internal functions aren't reachable as globals. To inspect
+  internal builders (e.g. `buildBedrockProviderConfig`), set a breakpoint with
+  `ext.set_breakpoint` and read locals via `ext.evaluate` with the paused `callFrameId`
+  — don't try to `require()` the bundle.
+- `web.evaluate` wraps the expression as a single returned expression; multi-statement
+  snippets must be an IIFE `(() => { ...; return x; })()`, otherwise you get
+  `SyntaxError: Unexpected token ';'`.
+- Webview settings inputs are `vscode-text-field` web components with debounced React
+  onChange. Setting `.value` + dispatching events via `web.evaluate` is unreliable for
+  some fields; focus the inner shadow `input` then use real keystrokes (`ui.type` +
+  `ui.press Tab`, or click the dropdown option) to make the value persist.
+
diff --git a/.clinerules/hooks/README.md b/.clinerules/hooks/README.md
new file mode 100644
index 0000000..db950fd
--- /dev/null
+++ b/.clinerules/hooks/README.md
@@ -0,0 +1,423 @@
+# Cline Hooks Documentation
+
+## Overview
+
+Cline hooks allow you to execute custom scripts at specific points in the agentic workflow. Hooks can be placed in either:
+- **Global hooks directory**: `~/Documents/Cline/Hooks/` (applies to all workspaces)
+- **Workspace hooks directory**: `.clinerules/hooks/` (applies to the workspace the repo is part of)
+
+Hooks run automatically when enabled.
+
+## Enabling Hooks
+
+1. Open Cline settings in VSCode
+2. Navigate to the Feature Settings section
+3. Check the "Enable Hooks" checkbox
+4. Hooks must be executable files (on Unix/Linux/macOS use `chmod +x hookname`)
+
+## Available Hooks
+
+### TaskStart Hook
+- **When**: Runs when a NEW task is started (not when resuming)
+- **Purpose**: Initialize task context, validate task requirements, set up environment
+- **Global Location**: `~/Documents/Cline/Hooks/TaskStart`
+- **Workspace Location**: `.clinerules/hooks/TaskStart`
+
+### TaskResume Hook
+- **When**: Runs when an EXISTING task is resumed (after user clicks resume button)
+- **Purpose**: Validate resumed task state, restore context, check for changes since last run
+- **Global Location**: `~/Documents/Cline/Hooks/TaskResume`
+- **Workspace Location**: `.clinerules/hooks/TaskResume`
+
+### TaskCancel Hook
+- **When**: Runs when a task is cancelled or a hook is aborted by the user (only if there's actual active work or work was started)
+- **Purpose**: Clean up resources, log cancellation, save state
+- **Global Location**: `~/Documents/Cline/Hooks/TaskCancel`
+- **Workspace Location**: `.clinerules/hooks/TaskCancel`
+- **Note**: This hook is NOT cancellable
+
+### TaskComplete Hook (coming soon!)
+- **When**: Runs when a task is marked as complete
+- **Purpose**: Log completion status, perform final cleanup, generate reports
+- **Global Location**: `~/Documents/Cline/Hooks/TaskComplete`
+- **Workspace Location**: `.clinerules/hooks/TaskComplete`
+
+### UserPromptSubmit Hook
+- **When**: Runs when the user submits a prompt/message (initial task, resume, or feedback)
+- **Purpose**: Validate user input, preprocess prompts, add context to user messages
+- **Global Location**: `~/Documents/Cline/Hooks/UserPromptSubmit`
+- **Workspace Location**: `.clinerules/hooks/UserPromptSubmit`
+
+### PreToolUse Hook
+- **When**: Runs BEFORE a tool is executed
+- **Purpose**: Validate parameters, block execution, or add context
+- **Global Location**: `~/Documents/Cline/Hooks/PreToolUse`
+- **Workspace Location**: `.clinerules/hooks/PreToolUse`
+
+### PostToolUse Hook
+- **When**: Runs AFTER a tool completes
+- **Purpose**: Observe results, track patterns, or add context
+- **Global Location**: `~/Documents/Cline/Hooks/PostToolUse`
+- **Workspace Location**: `.clinerules/hooks/PostToolUse`
+
+### PreCompact Hook (coming soon!)
+- **When**: Runs BEFORE the conversation context is compacted/truncated
+- **Purpose**: Observe compaction events, log context management, track token usage
+- **Global Location**: `~/Documents/Cline/Hooks/PreCompact`
+- **Workspace Location**: `.clinerules/hooks/PreCompact`
+
+## Cross-Platform Hook Format
+
+Cline uses a git-style approach for hooks that works consistently across all platforms:
+
+### Hook Files (All Platforms)
+- **No file extensions**: Hooks are named exactly `PreToolUse` or `PostToolUse` (no `.bat`, `.cmd`, `.sh` etc.)
+- **Shebang required**: First line must be a shebang (e.g., `#!/usr/bin/env bash` or `#!/usr/bin/env node`)
+- **Executable on Unix**: On Unix/Linux/macOS, hooks must be executable: `chmod +x PreToolUse`
+- **Windows**: Not currently supported.
+
+### How It Works
+
+Like git hooks, Cline executes hook files through a shell that interprets the shebang line:
+- On Unix/Linux/macOS: Native shell execution with shebang support
+
+This means:
+- ✅ Same hook script works on all platforms
+- ✅ Write once, run anywhere
+- ✅ Use any scripting language (bash, node, python, etc.)
+
+### Creating Hooks
+
+**On Unix/Linux/macOS:**
+```bash
+# Create hook file
+nano ~/Documents/Cline/Hooks/PreToolUse
+
+# Make executable
+chmod +x ~/Documents/Cline/Hooks/PreToolUse
+```
+
+## Context Injection Timing
+
+**IMPORTANT**: Context injected by hooks affects **FUTURE AI decisions**, not the current tool execution.
+
+### Why This Matters
+
+When a hook runs:
+1. The AI has already decided what tool to use and with what parameters
+2. The hook cannot modify those parameters
+3. Context from the hook is added to the conversation
+4. The AI sees this context in the **NEXT API request** and can adjust future decisions
+
+### PreToolUse Hook Flow
+```
+1. AI decides: "I'll use write_to_file with these parameters"
+2. PreToolUse hook runs → can block or add context
+3. If allowed, tool executes with original parameters
+4. Context is added to conversation
+5. Next API request includes this context
+6. AI adjusts future decisions based on context
+```
+
+### PostToolUse Hook Flow
+```
+1. Tool completes execution
+2. PostToolUse hook runs → observes results
+3. Hook adds context about the outcome
+4. Context is added to conversation
+5. Next API request includes this context
+6. AI can learn from the results
+```
+
+## Hook Input/Output
+
+### Input (via stdin as JSON)
+
+All hooks receive:
+```json
+{
+  "clineVersion": "string",
+  "hookName": "TaskStart" | "TaskResume" | "TaskCancel" | "TaskComplete" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PreCompact",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "taskStart": {  // Only for TaskStart
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string",
+      "initialTask": "string"
+    }
+  },
+  "taskResume": {  // Only for TaskResume
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    },
+    "previousState": {
+      "lastMessageTs": "string",
+      "messageCount": "string",
+      "conversationHistoryDeleted": "string"
+    }
+  },
+  "taskCancel": {  // Only for TaskCancel
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string",
+      "completionStatus": "string"
+    }
+  },
+  "taskComplete": {  // Only for TaskComplete
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    }
+  },
+  "userPromptSubmit": {  // Only for UserPromptSubmit
+    "prompt": "string",
+    "attachments": ["string"]
+  },
+  "preToolUse": {  // Only for PreToolUse
+    "toolName": "string",
+    "parameters": {}
+  },
+  "postToolUse": {  // Only for PostToolUse
+    "toolName": "string",
+    "parameters": {},
+    "result": "string",
+    "success": boolean,
+    "executionTimeMs": number
+  },
+  "preCompact": {  // Only for PreCompact
+    "contextSize": number,
+    "messagesToCompact": number,
+    "compactionStrategy": "string"
+  }
+}
+```
+
+### Output (via stdout as JSON)
+
+All hooks must return:
+```json
+{
+  "cancel": boolean,                   // Required: false to continue, true to block execution
+  "contextModification": "string",     // Optional: Context for future AI decisions
+  "errorMessage": "string"             // Optional: Error details if blocking
+}
+```
+
+**Note**: The `cancel` field works as follows:
+- `false` (or omitted): Allow execution to continue
+- `true`: Block execution and show error message to user
+
+## Hook Execution Limits
+
+- **Timeout**: Hooks must complete within 30 seconds (configurable via `HOOK_EXECUTION_TIMEOUT_MS`)
+- **Context Size**: Context modifications are limited to 50KB (configurable via `MAX_CONTEXT_MODIFICATION_SIZE`)
+- **Error Handling**: Expected errors (file not found, permission denied, not a directory) are handled silently; unexpected file system errors are propagated
+
+## Common Use Cases
+
+### 1. Validation - Block Invalid Operations
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
+  cat <<EOF
+{
+  "cancel": true,
+  "errorMessage": "Cannot create .js files in TypeScript project",
+  "contextModification": "Use .ts/.tsx extensions only"
+}
+EOF
+  exit 0
+fi
+
+echo '{"cancel": false}'
+```
+
+### 2. Context Building - Learn from Operations
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+success=$(echo "$input" | jq -r '.postToolUse.success')
+path=$(echo "$input" | jq -r '.postToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$success" == "true" ]]; then
+  cat <<EOF
+{
+  "cancel": false,
+  "contextModification": "Created '$path'. Maintain consistency with this file's patterns in future operations."
+}
+EOF
+else
+  echo '{"cancel": false}'
+fi
+```
+
+### 3. Performance Monitoring
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs')
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+
+if [[ "$execution_time" -gt 5000 ]]; then
+  cat <<EOF
+{
+  "cancel": false,
+  "contextModification": "Tool '$tool_name' took ${execution_time}ms. Consider optimizing future similar operations."
+}
+EOF
+else
+  echo '{"cancel": false}'
+fi
+```
+
+### 4. Logging and Telemetry
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Log to file
+echo "$input" >> ~/.cline/hook-logs/tool-usage.jsonl
+
+# Allow execution
+echo '{"cancel": false}'
+```
+
+## Global vs Workspace Hooks
+
+Cline supports two levels of hooks:
+
+### Global Hooks
+- **Location**: `~/Documents/Cline/Hooks/` (macOS/Linux)
+- **Scope**: Apply to ALL workspaces and projects
+- **Use Case**: Organization-wide policies, personal preferences, universal validations
+- **Priority**: Order not guaranteed when combined with workspace hooks
+
+### Workspace Hooks
+- **Location**: `.clinerules/hooks/` in each workspace root
+- **Scope**: Apply only to the specific workspace
+- **Use Case**: Project-specific rules, team conventions, repository requirements
+- **Priority**: Order not guaranteed when combined with global hooks
+
+### Hook Execution
+
+When multiple hooks exist (global and/or workspace):
+- All hooks for a given step are executed **concurrently** using `Promise.all`
+- **Execution order is not guaranteed** - hooks run in parallel
+- If ALL hooks allow execution (`cancel: false`), the tool proceeds
+- If ANY hook blocks (`cancel: true`), execution is blocked
+
+**Result Combination:**
+- `cancel`: If ANY hook returns `true`, execution is blocked
+- `contextModification`: All context strings are concatenated with double newlines (`\n\n`)
+- `errorMessage`: All error messages are concatenated with single newlines (`\n`)
+
+### Setting Up Global Hooks
+
+1. The global hooks directory is automatically created at:
+   - macOS/Linux: `~/Documents/Cline/Hooks/`
+
+2. Add your hook script:
+   ```bash
+   # Unix/Linux/macOS
+   nano ~/Documents/Cline/Hooks/PreToolUse
+   chmod +x ~/Documents/Cline/Hooks/PreToolUse
+   ```
+
+3. Enable hooks in Cline settings
+
+### Example: Global + Workspace Hooks
+
+**Global Hook** (applies to all projects):
+```bash
+#!/usr/bin/env bash
+# ~/Documents/Cline/Hooks/PreToolUse
+# Universal rule: Never delete package.json
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *"package.json"* ]]; then
+  echo '{"cancel": true, "errorMessage": "Global policy: Cannot modify package.json"}'
+  exit 0
+fi
+
+echo '{"cancel": false}'
+```
+
+**Workspace Hook** (applies to specific project):
+```bash
+#!/usr/bin/env bash
+# .clinerules/hooks/PreToolUse
+# Project rule: Only TypeScript files
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
+  echo '{"cancel": true, "errorMessage": "Project rule: Use .ts files only"}'
+  exit 0
+fi
+
+echo '{"cancel": false}'
+```
+
+**All hooks must allow execution for the tool to proceed.** Hooks may execute concurrently.
+
+## Multi-Root Workspaces
+
+If you have multiple workspace roots, you can place hooks in each root's `.clinerules/hooks/` directory. All hooks (global and workspace) may execute concurrently. Their results will be combined:
+
+- **cancel**: If ANY hook returns `true`, execution is blocked
+- **contextModification**: All context modifications are concatenated
+- **errorMessage**: All error messages are concatenated
+
+**Note:** No execution order is guaranteed between hooks from different directories.
+
+## Troubleshooting
+
+### Hook Not Running
+- Ensure the "Enable Hooks" setting is checked
+- Verify the hook file is executable (`chmod +x hookname`)
+- Check the hook file has no syntax errors
+- Look for errors in VSCode's Output panel (Cline channel)
+
+### Hook Timing Out
+- Reduce complexity of the hook script
+- Avoid expensive operations (network calls, heavy computations)
+- Consider moving complex logic to a background process
+
+### Context Not Affecting Behavior
+- Remember: context affects FUTURE decisions, not the current tool
+- Ensure context modifications are clear and actionable
+- Check that context isn't being truncated (50KB limit)
+
+## Security Considerations
+
+- Hooks run with the same permissions as VSCode
+- Be cautious with hooks from untrusted sources
+- Review hook scripts before enabling them
+- Consider using `.gitignore` to avoid committing sensitive hook logic
+- Hooks can access all workspace files and environment variables
+
+## Best Practices
+
+1. **Keep hooks fast** - Aim for <100ms execution time
+2. **Make context actionable** - Be specific about what the AI should do
+3. **Use structured prefixes** - Help the AI categorize context
+4. **Handle errors gracefully** - Always return valid JSON
+5. **Log for debugging** - Keep logs of hook executions for troubleshooting
+6. **Test incrementally** - Start with simple hooks and add complexity
+7. **Document your hooks** - Add comments explaining the purpose and logic
diff --git a/.clinerules/network.md b/.clinerules/network.md
new file mode 100644
index 0000000..e004a46
--- /dev/null
+++ b/.clinerules/network.md
@@ -0,0 +1,90 @@
+# Networking & Proxy Support
+
+To ensure Cline works correctly in all environments (VSCode, JetBrains, CLI) and with various network configurations (especially corporate proxies), strictly follow these guidelines for all network activity.
+
+In extension code, do NOT use the global `fetch` or a default `axios` instance. (Note, `shared/net.ts` is exempt from these rules because it sets up the fetch wrappers.) In Webview code, you SHOULD use global `fetch`.
+
+Global `fetch` and default `axios` do not automatically pick up proxy configurations in all environments (specifically JetBrains and CLI). You MUST use the provided utilities in `@/shared/net` which handle proxy agent configuration. In the webview, the browser/embedder handles proxies.
+
+## Guidelines
+
+### 1. Using `fetch`
+
+Instead of `fetch(...)`, import the proxy-aware wrapper:
+
+```typescript
+import { fetch } from '@/shared/net'
+
+// Usage is identical to global fetch
+const response = await fetch('https://api.example.com/data')
+```
+
+### 2. Using `axios`
+
+When using `axios`, you must apply the settings from `getAxiosSettings()`:
+
+```typescript
+import axios from 'axios'
+import { getAxiosSettings } from '@/shared/net'
+
+const response = await axios.get('https://api.example.com/data', {
+  headers: { 'Authorization': '...' },
+  ...getAxiosSettings() // <--- CRITICAL: Injects the proxy agent if needed
+})
+```
+
+### 3. Third-Party Clients (OpenAI, Ollama, etc.)
+
+Most API client libraries allow you to customize the `fetch` implementation. You **MUST** pass the proxy-aware `fetch` to these clients.
+
+**Example (OpenAI):**
+```typescript
+import OpenAI from "openai"
+import { fetch } from "@/shared/net"
+
+this.client = new OpenAI({
+  apiKey: '...',
+  fetch, // <--- CRITICAL: Pass our fetch wrapper
+})
+```
+
+### 4. Tests
+
+Use `mockFetchForTesting` to mock the underlying fetch implementation.
+
+**Example (callback):**
+
+```
+import { mockFetchForTesting } from "@/shared/net"
+
+...
+  let mockFetch = ...
+  mockFetchForTesting(mockFetch, () => {
+    // This calls mockFetch
+    fetch('https://foo.example').then(...)
+  })
+  // Original fetch is restored immediately when the call returns.
+```
+
+**Example (Promise):**
+
+```
+import { mockFetchForTesting } from "@/shared/net"
+
+...
+  let mockFetch = ...
+  await mockFetchForTesting(mockFetch, async () => {
+    await ...
+    // This calls mockFetch
+    await fetch('https://foo.example')
+    ...
+  })
+  // Original fetch is restored when the Promise from the callback settles
+```
+
+## Verification
+
+If you are adding a new network call or integration:
+1.  Check `@/shared/net.ts` is imported.
+2.  Ensure `fetch` or `getAxiosSettings` is being used.
+3.  Verify that third-party clients are configured to use the custom fetch.
diff --git a/.clinerules/protobuf-development.md b/.clinerules/protobuf-development.md
new file mode 100644
index 0000000..35f1dd2
--- /dev/null
+++ b/.clinerules/protobuf-development.md
@@ -0,0 +1,89 @@
+# Cline Protobuf Development Guide
+
+This guide outlines how to add new gRPC endpoints for communication between the webview (frontend) and the extension host (backend).
+
+## Overview
+
+Cline uses [Protobuf](https://protobuf.dev/) to define a strongly-typed API, ensuring efficient and type-safe communication. All definitions are in the `/proto` directory. The compiler and plugins are included as project dependencies, so no manual installation is needed.
+
+## Key Concepts & Best Practices
+
+-   **File Structure**: Each feature domain should have its own `.proto` file (e.g., `account.proto`, `task.proto`).
+-   **Message Design**:
+    -   For simple, single-value data, use the shared types in `proto/common.proto` (e.g., `StringRequest`, `Empty`, `Int64Request`). This promotes consistency.
+    -   For complex data structures, define custom messages within the feature's `.proto` file (see `task.proto` for examples like `NewTaskRequest`).
+-   **Naming Conventions**:
+    -   Services: `PascalCaseService` (e.g., `AccountService`).
+    -   RPCs: `camelCase` (e.g., `accountEmailIdentified`).
+    -   Messages: `PascalCase` (e.g., `StringRequest`).
+-   **Streaming**: For server-to-client streaming, use the `stream` keyword on the response type. See `subscribeToAuthCallback` in `account.proto` for an example.
+
+---
+
+## 4-Step Development Workflow
+
+Here’s how to add a new RPC, using `scrollToSettings` as an example.
+
+### 1. Define the RPC in a `.proto` File
+
+Add your service method to the appropriate file in the `proto/` directory.
+
+**File: `proto/ui.proto`**
+```proto
+service UiService {
+  // ... other RPCs
+  // Scrolls to a specific settings section in the settings view
+  rpc scrollToSettings(StringRequest) returns (KeyValuePair);
+}
+```
+Here, we use the common `StringRequest` and `KeyValuePair` types.
+
+### 2. Compile Definitions
+
+After editing a `.proto` file, regenerate the TypeScript code. From the project root, run:
+```bash
+bun run protos
+```
+This command compiles all `.proto` files and outputs the generated code to `src/generated/` and `src/shared/`. Do not edit these generated files manually.
+
+### 3. Implement the Backend Handler
+
+Create the RPC implementation in the backend. Handlers are located in `src/core/controller/[service-name]/`.
+
+**File: `src/core/controller/ui/scrollToSettings.ts`**
+```typescript
+import { Controller } from ".."
+import { StringRequest, KeyValuePair } from "../../../shared/proto/common"
+
+/**
+ * Executes a scroll to settings action
+ * @param controller The controller instance
+ * @param request The request containing the ID of the settings section to scroll to
+ * @returns KeyValuePair with action and value fields for the UI to process
+ */
+export async function scrollToSettings(controller: Controller, request: StringRequest): Promise<KeyValuePair> {
+	return KeyValuePair.create({
+		key: "scrollToSettings",
+		value: request.value || "",
+	})
+}
+```
+
+### 4. Call the RPC from the Webview
+
+Call the new RPC from a React component in `webview-ui/`. The generated client makes this simple.
+
+**File: `webview-ui/src/components/browser/BrowserSettingsMenu.tsx`** (Example)
+```tsx
+import { UiServiceClient } from "../../../services/grpc"
+import { StringRequest } from "../../../../shared/proto/common"
+
+// ... inside a React component
+const handleMenuClick = async () => {
+    try {
+        await UiServiceClient.scrollToSettings(StringRequest.create({ value: "browser" }))
+    } catch (error) {
+        console.error("Error scrolling to browser settings:", error)
+    }
+}
+```
diff --git a/.clinerules/sdk-migration.md b/.clinerules/sdk-migration.md
new file mode 100644
index 0000000..558b54c
--- /dev/null
+++ b/.clinerules/sdk-migration.md
@@ -0,0 +1,26 @@
+# SDK Adapter
+
+The VSCode extension runs on the Cline SDK (`@cline/core`, `@cline/llms`,
+`@cline/shared`) through an adapter layer in `apps/vscode/src/sdk/`. The
+webview still talks gRPC; the adapter translates between gRPC handlers and SDK
+calls. See `apps/vscode/src/dev/debug-harness/README.md` for the debug harness.
+
+## Conventions
+
+1. **Look up SDK APIs, don't guess.** Use `kb_search(name="sdk", query="...")`
+   before implementing against an SDK surface.
+2. **Reference the pre-SDK implementation when replacing a module.** Add a
+   `// Replaces classic src/core/... (see origin/main)` header and use
+   `kb_search(name="cline", commit="origin/main")` or
+   `git show origin/main:path` to consult the prior implementation.
+3. **Single entry point.** There is one codepath — the SDK adapter. No
+   `CLINE_SDK` env flag.
+4. **Use `{appBaseUrl}`**, never hardcode `app.cline.bot`.
+5. **Avoid `as` casts.** Use explicit conversion functions with tests. The
+   branded types in `apps/vscode/src/sdk/model-catalog/contracts.ts` exist so
+   casts are unnecessary outside parse/compute boundaries.
+
+## Debug harness
+
+- **Dismiss the Kanban/promo overlay** before any debug harness interaction.
+- **Use the command palette** to navigate tabs in the debug harness.
diff --git a/.clinerules/storage.md b/.clinerules/storage.md
new file mode 100644
index 0000000..6e1bc94
--- /dev/null
+++ b/.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
+```
diff --git a/.clinerules/workflows/address-pr-comments.md b/.clinerules/workflows/address-pr-comments.md
new file mode 100644
index 0000000..f7db2b6
--- /dev/null
+++ b/.clinerules/workflows/address-pr-comments.md
@@ -0,0 +1,29 @@
+# Address PR Comments
+
+Review and address all comments on the current branch's PR.
+
+## Steps
+
+1. Get the current branch name and find the associated PR:
+   ```bash
+   gh pr view --json number,title,body
+   ```
+
+2. Understand the PR context:
+   - Get the full diff: `git diff origin/main...HEAD`
+   - Read the changed files to understand what the PR is doing
+   - Read related files if needed to understand the broader context
+   - Understand the intent and spirit of the changes, not just the code
+
+3. Fetch all PR comments:
+   - 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 (release automation, CI status, etc.).
+
+5. **Wait for my approval** before proceeding.
+
+6. After approval:
+   - Apply code changes and commit
+   - Reply to comments that were addressed or intentionally skipped
+   - Push commits
diff --git a/.clinerules/workflows/find-pr-reviewers.md b/.clinerules/workflows/find-pr-reviewers.md
new file mode 100644
index 0000000..8809df5
--- /dev/null
+++ b/.clinerules/workflows/find-pr-reviewers.md
@@ -0,0 +1,49 @@
+# Find Best Reviewers for Current Branch
+
+Analyze my current branch to find the best people to review my PR based on **domain expertise** and git history.
+
+## Steps
+
+1. Get the current branch name and verify it's not `main`
+2. Get the diff between the current branch and `origin/main`:
+   - Use `git diff origin/main...HEAD --name-only` to get changed files
+   - Use `git diff origin/main...HEAD` to understand the nature/spirit of the changes
+3. **Identify the domain/feature area** being changed:
+   - Read the diff carefully to understand WHAT is being changed conceptually (e.g., "slash commands", "authentication", "API client", "UI components")
+   - This semantic understanding is crucial for finding the right reviewers
+4. Find domain experts by searching for related files and their contributors:
+   - Identify all files related to the feature/domain (not just the ones changed)
+   - Example: if changing slash commands, find ALL slash-command related files across the codebase
+   - Use `git log --format="%an <%ae>" -- <related-files-pattern>` to find who has expertise in that domain
+5. For additional context, also gather:
+   - `git blame -L <start>,<end> origin/main -- <file-path>` for exact lines changed
+   - Recent commit activity on related files
+6. Score and rank contributors by:
+   - **Highest weight: Domain expertise** - who has the most commits to files in this feature area (even files not touched by this PR)
+   - **Medium weight: Direct file expertise** - commits to the specific files being changed
+   - **Lower weight: Line-level ownership** - authored the exact lines being modified
+7. Exclude myself (check against my git config user.email)
+8. Present the top 5 reviewers as an ordered list
+
+## Output Format
+
+Output an ordered list:
+
+1. **Name** - Domain expert: 15 commits to slash-command related files, authored core parsing logic
+2. **Name** - 8 commits to affected files, recently added the feature being modified
+3. ...
+
+## Commands Reference
+```bash
+git config user.email
+git diff origin/main...HEAD --name-only
+git diff origin/main...HEAD
+# Find related files for a domain (adjust pattern based on what you learn from the diff)
+find . -type f \( -name "*slash-command*" -o -name "*SlashCommand*" \) | head -20
+# Get contributors for related files
+find . -type f \( -name "*slash-command*" -o -name "*SlashCommand*" \) -print0 | xargs -0 git log --format="%an <%ae>" -- | sort | uniq -c | sort -rn
+git log --format="%an <%ae>" -- <file> | sort | uniq -c | sort -rn
+git blame -L 10,20 origin/main -- <file>
+```
+
+Do NOT ask questions - analyze the changes, identify the domain, and output the reviewer list.
diff --git a/.clinerules/workflows/git-branch-analysis.md b/.clinerules/workflows/git-branch-analysis.md
new file mode 100644
index 0000000..dd2d26c
--- /dev/null
+++ b/.clinerules/workflows/git-branch-analysis.md
@@ -0,0 +1,61 @@
+# Git Diff Analysis Workflow
+
+## Objective
+Analyze the current branch's changes against main to provide informed insights and context for development decisions.
+
+## Step 1: Gather Git Information
+<important>Do not return any text or conversation other than what is necessary to run these commands</important>
+
+**Run the following command to get the latest changes (bash):**
+```bash
+B=$(for c in main master origin/main origin/master; do git rev-parse --verify -q "$c" >/dev/null && echo "$c" && break; done); B=${B:-HEAD}; r(){ git branch --show-current; printf "=== STATUS ===\n"; git status --porcelain | cat; printf "=== COMMIT MESSAGES ===\n"; git log "$B"..HEAD --oneline | cat; printf "=== CHANGED FILES ===\n"; git diff "$B" --name-only | cat; printf "=== FULL DIFF ===\n"; git diff "$B" | cat; }; L=$(r | wc -l); if [ "$L" -gt 500 ]; then r > cline-git-analysis.temp && echo "::OUTPUT_FILE=cline-git-analysis.temp"; else r; fi
+```
+
+```powershell
+$B=$null;foreach($c in 'main','master','origin/main','origin/master'){git rev-parse --verify -q $c *> $null;if($LASTEXITCODE -eq 0){$B=$c;break}};if(-not $B){$B='HEAD'};function r([string]$b){git rev-parse --abbrev-ref HEAD; '=== STATUS ==='; git status --porcelain | cat; '=== COMMIT MESSAGES ==='; git log "$b"..HEAD --oneline | cat; '=== CHANGED FILES ==='; git diff "$b" --name-only | cat; '=== FULL DIFF ==='; git diff "$b" | cat};$out=r $B|Out-String;$lines=($out -split "`r?`n").Count;if($lines -gt 500){$out|Set-Content -NoNewline cline-git-analysis.temp; '::OUTPUT_FILE=cline-git-analysis.temp'}else{$out}
+```
+
+## Step 2: Silent, Structured Analysis Phase
+- Analyze all git output without providing commentary or narration
+- Read the full diff to understand the scope and nature of changes
+- Identify patterns, architectural modifications, or potential impacts
+- Use `read_file` to examine any related files providing additional context on the changes you have observed
+
+## Step 3: Context Gathering
+- Analyze related code without providing commentary or narration
+- Read relevant related source files if needed for complete understanding
+- Check dependencies, imports, or cross-references spanning the changes
+- Understand the broader codebase context around modifications
+- This additional context gathering should include related backend code, as well as related ui/frontend code
+- You will typically need to analyze at least several files, potentially many, in order to fully complete this step
+- You should not continue reading additional context if you have exhausted more than 60% of your available context window
+- If you have exhausted less than 40% of your context window, you should continue reviewing additional context
+
+## Step 4: Ready for User Interaction
+**Only after completing the full analysis:**
+- Engage with the user based on comprehensive understanding
+- Provide insights about specific modifications and their impacts
+- If you are certain they exist, note potential breaking changes or compatibility issues
+- Answer questions with informed context from the complete change set and context gathering
+- If the user has not provided a question, or the question is insufficient to provide a quality response, ask brief (one sentence) clarifying questions.
+- Only offer recommendations if they are applicable to the user's request and relevant to the changes that you have observed 
+
+## Key Rules
+- **No prose or conversation during git research phase**
+- **No prose or conversation during context gathering phase**
+- **Complete all analysis before any user interaction**
+- **Use gathered information for all subsequent questions and insights**
+- **Focus on understanding the complete picture before discussing**
+
+## Optional: Additional Analysis Commands
+For deeper investigation when needed:
+
+```shell
+# Detailed commit history with author info
+git log main..HEAD --format="%h %s (%an)" | cat
+
+# Change statistics
+git diff main --stat | cat
+
+# Specific file type changes
+git diff main --name-only | grep -E '\.(ts|js|tsx|jsx|py|md)$' | cat
diff --git a/.clinerules/workflows/hotfix-release.md b/.clinerules/workflows/hotfix-release.md
new file mode 100644
index 0000000..cf30a33
--- /dev/null
+++ b/.clinerules/workflows/hotfix-release.md
@@ -0,0 +1,187 @@
+# Hotfix Release
+
+Create a hotfix release by cherry-picking specific commits from main onto the latest release tag.
+
+## Overview
+
+This workflow helps you:
+1. Select specific commits from main to include in a hotfix
+2. Create a release notes commit on main (changelog + version bump)
+3. Cherry-pick everything onto the latest release tag
+4. Tag and push the new release
+
+## Step 1: Setup and Gather Information
+
+First, ensure we're on main and up to date:
+
+```bash
+git checkout main && git pull origin main
+```
+
+Get the latest release tag:
+
+```bash
+git tag --sort=-v:refname | head -1
+```
+
+## Step 2: Present Commits Since Last Release
+
+Show all commits on main since the last release tag:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+git log ${LAST_TAG}..HEAD --oneline --format="%h %s (%an)"
+```
+
+Also get the commit messages already on the tag (to identify previously cherry-picked commits). Note: Run these as separate commands to avoid shell parsing issues with parentheses in author names:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+PREV_TAG=$(git tag --sort=-v:refname | head -2 | tail -1)
+```
+
+```bash
+git log $PREV_TAG..$LAST_TAG --oneline --format="%s"
+```
+
+**Present the list** to the user in a numbered format with commit hash, subject, and author. For any commits whose subject line already appears in the tag's history (previously cherry-picked in an earlier hotfix) or are "Release Notes" commits, add `(already in previous hotfix)` or `(release notes - skip)` after them so the user knows to skip those.
+
+Ask which commits to include in the hotfix.
+
+Use the ask_followup_question tool to let the user specify which commits they want (by number or hash).
+
+## Step 3: Analyze Selected Commits
+
+For each selected commit:
+1. Get the full commit message: `git show --no-patch --format="%B" <hash>`
+2. Get the diff to understand the change: `git show <hash> --stat`
+3. Find the associated PR if any: `gh pr list --search "<hash>" --state merged --json number,title --jq '.[0]'`
+
+Build a mental model of what these changes do for the changelog.
+
+## Step 4: Determine New Version Number
+
+Parse the current version from package.json and the last tag:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+echo "Last release: $LAST_TAG"
+cat package.json | grep '"version"'
+```
+
+Hotfixes always increment the patch version (e.g., 3.40.0 -> 3.40.1, or 3.40.1 -> 3.40.2).
+
+**Ask the user to confirm the new version number.**
+
+## Step 5: Create Release Notes Commit on Main
+
+On the main branch, create a commit that updates:
+
+1. **CHANGELOG.md** - Add a new section for the hotfix version at the top:
+   ```markdown
+   ## [3.40.1]
+
+   - Description of fix 1
+   - Description of fix 2
+   ```
+
+   Write clear, user-friendly descriptions based on your analysis of the commits.
+
+2. **package.json** - Update the version field to the new version
+
+3. No changelog-entry file cleanup is needed. Contributors do not create changelog-entry files in this repo.
+
+**No dependency install is needed.** A CHANGELOG + `version` bump does not change any dependency, and `bun.lock` does not pin workspace-package versions, so the lockfile stays consistent. The publish workflow runs `bun install --frozen-lockfile`, which would *fail* on an out-of-sync lock — so only run `bun install` here if you actually change dependencies (then commit the updated `bun.lock`).
+
+Commit with message format: `v{VERSION} Release Notes (hotfix)`
+
+In the commit body, mention:
+- This is for a hotfix release
+- List the cherry-picked commits that will be included
+
+```bash
+git add CHANGELOG.md package.json
+git commit -m "v3.40.1 Release Notes (hotfix)
+
+Hotfix release including:
+- <commit1-hash>: <description>
+- <commit2-hash>: <description>
+"
+```
+
+Push to main:
+
+```bash
+git push origin main
+```
+
+## Step 6: Build the Hotfix on the Tag
+
+Checkout the last release tag (detached HEAD):
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+git checkout $LAST_TAG
+```
+
+Cherry-pick the selected commits in order:
+
+```bash
+git cherry-pick <commit1-hash>
+git cherry-pick <commit2-hash>
+# ... etc
+```
+
+Finally, cherry-pick the release notes commit you just pushed to main:
+
+```bash
+# Get the hash of the release notes commit (should be HEAD of main)
+RELEASE_NOTES_COMMIT=$(git rev-parse main)
+git cherry-pick $RELEASE_NOTES_COMMIT
+```
+
+## Step 7: Tag and Push
+
+After all cherry-picks are applied successfully:
+
+```bash
+# Tag the new release
+git tag v{VERSION}
+
+# Push the tag to remote
+git push origin v{VERSION}
+```
+
+## Step 8: Return to Main and Summary
+
+Return to main branch:
+
+```bash
+git checkout main
+```
+
+**Copy a Slack announcement message to clipboard** with the version and PR links for each included fix:
+
+```
+VS Code Hotfix v{VERSION} Published
+
+- Description of fix 1 https://github.com/cline/cline/pull/{PR_NUMBER}
+- Description of fix 2 https://github.com/cline/cline/pull/{PR_NUMBER}
+```
+
+Present a final summary:
+- New version: v{VERSION}
+- Tag pushed: yes
+- Commits included: (list them)
+- Slack message copied to clipboard: yes
+
+Remind the user to:
+1. Manually trigger the publish release GitHub Action at: https://github.com/cline/cline/actions/workflows/ext-vscode-publish-stable.yml (paste `v{VERSION}` as the tag)
+2. Post the Slack message to announce the hotfix
+
+## Important Notes
+
+- This workflow does NOT create a release branch - only tags
+- The release notes commit goes to main first, then gets cherry-picked to the tag
+- This keeps main's history accurate while allowing hotfix releases from tags
+- If cherry-pick conflicts occur, resolve them before continuing
diff --git a/.clinerules/workflows/pr-review.md b/.clinerules/workflows/pr-review.md
new file mode 100644
index 0000000..60ecf15
--- /dev/null
+++ b/.clinerules/workflows/pr-review.md
@@ -0,0 +1,352 @@
+You have access to the `gh` terminal command. I already authenticated it for you. Please review it to use the PR that I asked you to review. You're already in the `cline` repo.
+
+<detailed_sequence_of_steps>
+# GitHub PR Review Process - Detailed Sequence of Steps
+
+## 1. Gather PR Information
+1. Get the PR title, description, and comments:
+   ```bash
+   gh pr view <PR-number> --json title,body,comments
+   ```
+
+2. Get the full diff of the PR:
+   ```bash
+   gh pr diff <PR-number>
+   ```
+
+## 2. Understand the Context
+1. Identify which files were modified in the PR:
+   ```bash
+   gh pr view <PR-number> --json files
+   ```
+
+2. Examine the original files in the main branch to understand the context:
+   ```xml
+   <read_file>
+   <path>path/to/file</path>
+   </read_file>
+   ```
+
+3. For specific sections of a file, you can use search_files:
+   ```xml
+   <search_files>
+   <path>path/to/directory</path>
+   <regex>search term</regex>
+   <file_pattern>*.ts</file_pattern>
+   </search_files>
+   ```
+
+## 3. Analyze the Changes
+1. For each modified file, understand:
+   - What was changed
+   - Why it was changed (based on PR description)
+   - How it affects the codebase
+   - Potential side effects
+
+2. Look for:
+   - Code quality issues
+   - Potential bugs
+   - Performance implications
+   - Security concerns
+   - Test coverage
+
+## 4. Ask for User Confirmation
+1. Before making a decision, ask the user if you should approve the PR, providing your assessment and justification:
+   ```xml
+   <ask_followup_question>
+   <question>Based on my review of PR #<PR-number>, I recommend [approving/requesting changes]. Here's my justification:
+   
+   [Detailed justification with key points about the PR quality, implementation, and any concerns]
+   
+   Would you like me to proceed with this recommendation?</question>
+   <options>["Yes, approve the PR", "Yes, request changes", "No, I'd like to discuss further"]</options>
+   </ask_followup_question>
+   ```
+
+## 5. Ask if User Wants a Comment Drafted
+1. After the user decides on approval/rejection, ask if they would like a comment drafted:
+   ```xml
+   <ask_followup_question>
+   <question>Would you like me to draft a comment for this PR that you can copy and paste?</question>
+   <options>["Yes, please draft a comment", "No, I'll handle the comment myself"]</options>
+   </ask_followup_question>
+   ```
+
+2. If the user wants a comment drafted, provide a well-structured comment they can copy:
+   ```
+   Thank you for this PR! Here's my assessment:
+
+   [Detailed assessment with key points about the PR quality, implementation, and any suggestions]
+
+   [Include specific feedback on code quality, functionality, and testing]
+   ```
+
+## 6. Make a Decision
+1. Approve the PR if it meets quality standards:
+   ```bash
+   # For single-line comments:
+   gh pr review <PR-number> --approve --body "Your approval message"
+   
+   # For multi-line comments with proper whitespace formatting:
+   cat << EOF | gh pr review <PR-number> --approve --body-file -
+   Thanks @username for this PR! The implementation looks good.
+
+   I particularly like how you've handled X and Y.
+
+   Great work!
+   EOF
+   ```
+
+2. Request changes if improvements are needed:
+   ```bash
+   # For single-line comments:
+   gh pr review <PR-number> --request-changes --body "Your feedback message"
+   
+   # For multi-line comments with proper whitespace formatting:
+   cat << EOF | gh pr review <PR-number> --request-changes --body-file -
+   Thanks @username for this PR!
+
+   The implementation looks promising, but there are a few things to address:
+
+   1. Issue one
+   2. Issue two
+
+   Please make these changes and we can merge this.
+   EOF
+   ```
+
+   Note: The `cat << EOF | ... --body-file -` approach preserves all whitespace and formatting without requiring temporary files. The `-` parameter tells the command to read from standard input.
+</detailed_sequence_of_steps>
+
+<example_review_process>
+# Example PR Review Process
+
+Let's walk through a real example of reviewing PR #3627 which fixes the thinking mode calculation for Claude 3.7 models.
+
+## Step 1: Gather PR Information
+
+```bash
+# Get PR details
+gh pr view 3627 --json title,body,comments
+
+# Get the full diff
+gh pr diff 3627
+```
+
+## Step 2: Understand the Context
+
+```xml
+# Examine the original files to understand what's being changed
+<read_file>
+<path>src/shared/api.ts</path>
+</read_file>
+
+# Look at the ThinkingBudgetSlider component implementation
+<read_file>
+<path>webview-ui/src/components/settings/ThinkingBudgetSlider.tsx</path>
+</read_file>
+
+# Check how thinking mode is currently handled in API providers
+<search_files>
+<path>src/api/providers</path>
+<regex>reasoningOn</regex>
+<file_pattern>*.ts</file_pattern>
+</search_files>
+```
+
+## Step 3: Analyze the Changes
+
+From the PR information and code examination, we can see that:
+
+1. The PR fixes an issue with the thinking mode budget calculation for Claude 3.7 models
+2. Currently, the thinking budget is incorrectly calculated as 80% of maxTokens (8192), resulting in 6553 tokens
+3. Claude 3.7 actually supports a much larger thinking budget (up to 64000 tokens)
+4. The PR adds a `thinkingConfig` property with `maxBudget: 64000` to model definitions
+5. It updates API handlers to use this value when reasoning mode is enabled
+6. It enhances the slider component to calculate max values based on model-specific percentages
+7. Comprehensive tests were added to verify the calculations
+
+## Step 4: Ask for User Confirmation
+
+```xml
+<ask_followup_question>
+<question>Based on my review of PR #3627, I recommend approving this PR. Here's my justification:
+
+1. The PR correctly fixes the thinking mode budget calculation for Claude 3.7 models
+2. It properly implements the thinkingConfig.maxBudget property (64000) for Claude 3.7 models
+3. It applies the appropriate percentage (50%) for the slider calculation
+4. The changes are well-tested with comprehensive unit tests
+5. The implementation is clean and follows the project's coding standards
+6. The PR includes helpful screenshots demonstrating the fix
+
+Would you like me to proceed with approving this PR?</question>
+<options>["Yes, approve the PR", "No, I'd like to discuss further", "Let me review it myself first"]</options>
+</ask_followup_question>
+```
+
+## Step 5: Ask if User Wants a Comment Drafted
+
+```xml
+<ask_followup_question>
+<question>Would you like me to draft a comment for this PR that you can copy and paste?</question>
+<options>["Yes, please draft a comment", "No, I'll handle the comment myself"]</options>
+</ask_followup_question>
+```
+
+## Step 6: Make a Decision
+
+```bash
+# Option 1: Simple one-line comment
+gh pr review 3627 --approve --body "This PR looks good! It correctly fixes the thinking mode budget calculation for Claude 3.7 models."
+
+# Option 2: Multi-line comment with proper whitespace formatting
+cat << EOF | gh pr review 3627 --approve --body-file -
+This PR looks good! It correctly fixes the thinking mode budget calculation for Claude 3.7 models.
+
+I particularly like:
+1. The proper implementation of thinkingConfig.maxBudget property (64000)
+2. The appropriate percentage (50%) for the slider calculation
+3. The comprehensive unit tests
+4. The clean implementation that follows project coding standards
+
+Great work!
+EOF
+```
+</example_review_process>
+
+<common_gh_commands>
+# Common GitHub CLI Commands for PR Review
+
+## Basic PR Commands
+```bash
+# Get current PR number
+gh pr view --json number -q .number
+
+# List open PRs
+gh pr list
+
+# View a specific PR
+gh pr view <PR-number>
+
+# View PR with specific fields
+gh pr view <PR-number> --json title,body,comments,files,commits
+
+# Check PR status
+gh pr status
+```
+
+## Diff and File Commands
+```bash
+# Get the full diff of a PR
+gh pr diff <PR-number>
+
+# List files changed in a PR
+gh pr view <PR-number> --json files
+
+# Check out a PR locally
+gh pr checkout <PR-number>
+```
+
+## Review Commands
+```bash
+# Approve a PR (single-line comment)
+gh pr review <PR-number> --approve --body "Your approval message"
+
+# Approve a PR (multi-line comment with proper whitespace)
+cat << EOF | gh pr review <PR-number> --approve --body-file -
+Your multi-line
+approval message with
+
+proper whitespace formatting
+EOF
+
+# Request changes on a PR (single-line comment)
+gh pr review <PR-number> --request-changes --body "Your feedback message"
+
+# Request changes on a PR (multi-line comment with proper whitespace)
+cat << EOF | gh pr review <PR-number> --request-changes --body-file -
+Your multi-line
+change request with
+
+proper whitespace formatting
+EOF
+
+# Add a comment review (without approval/rejection)
+gh pr review <PR-number> --comment --body "Your comment message"
+
+# Add a comment review with proper whitespace
+cat << EOF | gh pr review <PR-number> --comment --body-file -
+Your multi-line
+comment with
+
+proper whitespace formatting
+EOF
+```
+
+## Additional Commands
+```bash
+# View PR checks status
+gh pr checks <PR-number>
+
+# View PR commits
+gh pr view <PR-number> --json commits
+
+# Merge a PR (if you have permission)
+gh pr merge <PR-number> --merge
+```
+</common_gh_commands>
+
+<general_guidelines_for_commenting>
+When reviewing a PR, please talk normally and like a friendly reviwer. You should keep it short, and start out by thanking the author of the pr and @ mentioning them. 
+
+Whether or not you approve the PR, you should then give a quick summary of the changes without being too verbose or definitive, staying humble like that this is your understanding of the changes. Kind of how I'm talking to you right now.
+
+If you have any suggestions, or things that need to be changed, request changes instead of approving the PR.
+
+Leaving inline comments in code is good, but only do so if you have something specific to say about the code. And make sure you leave those comments first, and then request changes in the PR with a short comment explaining the overall theme of what you're asking them to change.
+</general_guidelines_for_commenting>
+
+<example_comments_that_i_have_written_before>
+<brief_approve_comment>
+Looks good, though we should make this generic for all providers & models at some point
+</brief_approve_comment>
+<brief_approve_comment>
+Will this work for models that may not match across OR/Gemini? Like the thinking models?
+</brief_approve_comment>
+<approve_comment>
+This looks great! I like how you've handled the global endpoint support - adding it to the ModelInfo interface makes total sense since it's just another capability flag, similar to how we handle other model features.
+
+The filtered model list approach is clean and will be easier to maintain than hardcoding which models work with global endpoints. And bumping the genai library was obviously needed for this to work.
+
+Thanks for adding the docs about the limitations too - good for users to know they can't use context caches with global endpoints but might get fewer 429 errors.
+</approve_comment>
+<requesst_changes_comment>
+This is awesome. Thanks @scottsus.
+
+My main concern though - does this work for all the possible VS Code themes? We struggled with this initially which is why it's not super styled currently. Please test and share screenshots with the different themes to make sure before we can merge
+</request_changes_comment>
+<request_changes_comment>
+Hey, the PR looks good overall but I'm concerned about removing those timeouts. Those were probably there for a reason - VSCode's UI can be finicky with timing.
+
+Could you add back the timeouts after focusing the sidebar? Something like:
+
+```typescript
+await vscode.commands.executeCommand("claude-dev.SidebarProvider.focus")
+await setTimeoutPromise(100)  // Give UI time to update
+visibleWebview = WebviewProvider.getSidebarInstance()
+```
+</request_changes_comment>
+<request_changes_comment>
+Heya @alejandropta thanks for working on this! 
+
+A few notes:
+1 - Adding additional info to the environment variables is fairly problematic because env variables get appended to **every single message**. I don't think this is justifiable for a somewhat niche use case. 
+2 - Adding this option to settings to include that could be an option, but we want our options to be simple and straightforward for new users
+3 - We're working on revisualizing the way our settings page is displayed/organized, and this could potentially be reconciled once that is in and our settings page is more clearly delineated. 
+
+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>
+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>
diff --git a/.clinerules/workflows/release.md b/.clinerules/workflows/release.md
new file mode 100644
index 0000000..c30f307
--- /dev/null
+++ b/.clinerules/workflows/release.md
@@ -0,0 +1,64 @@
+# Release
+
+Prepare and publish a release directly from `main`.
+
+## Overview
+
+This workflow helps you:
+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
+
+## Process
+
+### 1) Sync and determine version
+
+```bash
+git checkout main
+git pull origin main
+cat package.json | grep '"version"'
+```
+
+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 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>
+```
+
+### 4) Trigger publish workflow
+
+Tell the maintainer to run:
+https://github.com/cline/cline/actions/workflows/ext-vscode-publish-stable.yml
+
+Use `v<version>` as the release tag.
+
+### 5) Update GitHub release notes
+
+After publish completes:
+
+```bash
+gh release view v<version> --json body --jq '.body'
+gh release edit v<version> --notes "<final curated release notes>"
+```
+
+### 6) Final summary
+
+Provide:
+- Released version/tag
+- Link to release page
+- Summary of top end-user changes
diff --git a/.clinerules/workflows/writing-documentation.md b/.clinerules/workflows/writing-documentation.md
new file mode 100644
index 0000000..61cf6cc
--- /dev/null
+++ b/.clinerules/workflows/writing-documentation.md
@@ -0,0 +1,392 @@
+# General writing guide
+
+# How I want you to write 
+
+I'm gonna write something technical.
+
+It's often less about the nitty-gritty details of the tech stuff and more about learning something new or getting a solution handed to me on a silver platter.
+
+Look, when I read, I want something out of it. So when I write, I gotta remember that my readers want something too. This whole piece? It's about cluing in anyone who writes for me, or wants me to write for them, on how I see this whole writing product thing.
+
+I'm gonna lay out a checklist of stuff I'd like to have. It'll make the whole writing gig a bit smoother, you know?
+
+## Crafting Compelling Titles
+
+I often come across titles like "How to do X with Y,Z technology." These don't excite me because X or Y are usually unfamiliar unless they're already well-known. Its rarely the dream to use X unless X is the dream. 
+
+My dream isn’t to use instructor, its to do something valueble with the data it extracts
+
+An effective title should:
+
+- Evoke an emotional response
+- Highlight someone's goal
+- Offer a dream or aspiration
+- Challenge or comment on a belief
+- Address someone's problems
+
+I believe it's more impactful to write about specific problems. If this approach works, you can replicate it across various scenarios rather than staying too general.
+
+- Time management for everyone can be a 15$ ebook
+- Time management for executives is a 2000$ workshop
+
+Aim for titles that answer questions you think everyone is asking, or address thoughts people have but can't quite articulate.
+
+Instead of "How I do something" or "How to do something," frame it from the reader's perspective with "How you can do something." This makes the title more engaging. Just make sure the difference is advisory if the content is subjective. “How I made a million dollars” might be more reasonable than “How to make a million dollars” since you are the subject and the goal might be to share your story in hopes of helping others.
+
+This approach ultimately trains the reader to have a stronger emotional connection to your content.
+
+- "How I do X"
+- "How You Can do X"
+
+Between these two titles, it's obvious which one resonates more emotionally.
+
+You can take it further by adding specific conditions. For instance, you could target a particular audience or set a timeframe:
+
+- How to set up Braintrust
+- How to set up Braintrust in 5 minutes
+
+## NO adjectiives
+
+I want you to almost always avoid adjectives and try to use evidence instead. Instead of saying "production ready," you can write something like "scaling this to 100 servers or 1 million documents per second." Numbers like that will tell you exactly what the specificity of your product is. If you have to use adjectives rather than evidence, you are probably making something up. 
+
+There's no reason to say something like "blazingly fast" unless those things are already known phrases.
+
+Instead, say "200 times faster" or "30% faster." A 30% improvement in recommendation system speed is insane.
+
+There's a 200 times performance improvement because we went from one programming language to another. It's just something that's a little bit more expected and understandable.
+
+Another test that I really like using recently is tracking whether or not the statements you make can be:
+
+- Visualized
+- Proven false
+- Said only by you
+
+If you can nail all three, the claim you make will be more likely to resonate with an audience because only you can say it.
+
+Earlier this year, I had an example where I embedded all of Wikipedia in 17 minutes with 20 bucks, and it got half a million views. All we posted was a video of me kicking off the job, and then you can see all the log lines go through. You see the number of containers go from 1 out of 50 to 50 out of 50.
+
+It was easy to visualize and could have been proven false by being unreproducible. Lastly, Modal is the only company that could do that in such an effortless way, which made it unique.
+
+## Keep It Digestible 
+    - Aim for 5-minute reads
+    - Write at a Grade 10 reading level
+    - Break up long paragraphs
+    - Use headers and bullet points
+
+## Make It Scannable
+    - Bold key points
+    - Use subheadings every 3-4 paragraphs
+    - Include plenty of white space
+    - Add relevant examples
+
+This structure works whether you're writing a tweet thread or a full blog post. The key is making complex ideas accessible.
+
+# Guide to Writing Cline Documentation
+
+## Some general principles for explaining features
+
+If you're talking about a feature, it's helpful to start with a human-readable explanations that cover what the feature is in simple terms. Skip jargon and explain it like you're talking to someone who's never seen it before. This sets the foundation for everything that follows.
+
+Combine location and usage into one flowing section. Tell users exactly where to find the feature and how to use it, but weave the instructions into natural prose with a good balance of bullet points, numbered lists, code examples (if applicable), mintlify components, and headers/subheaders. Users shouldn't have to jump between separate "where is it" and "how do I use it" sections.
+
+Show the feature in action with real examples like actual files, workflows, or code. Users need to see concrete implementations, not just abstract descriptions. This is where understanding turns into practical knowledge.
+
+When talking about a feature, include an inspiration section that sparks imagination. This section pushes people from understanding to action by showing them what becomes possible when they use this feature creatively. It's what separates good documentation from great documentation.
+
+## Writing Principles That Actually Work
+
+### Write for Action, Not Just Understanding
+
+Documentation should motivate users to try things. Instead of just explaining how something works, focus on what users can accomplish with it. The inspiration section is crucial - it's what transforms passive readers into active users.
+
+### Create a Natural Story Flow
+
+It should feel like a conversation that naturally progresses from "what is this?" to "how do I use it?" to "here's a real example" to "imagine what you could do with this." 
+
+### Show Real Examples, Not Toy Demos
+
+Provide actual workflow files, real code snippets, and concrete implementations that users can copy and adapt. Abstract examples don't help anyone - users want to see exactly what they'll be working with.
+
+### Keep It Scannable But Not Fragmented
+
+Write in prose that flows naturally when read completely, but structure it so users can quickly find specific information when they're troubleshooting. Avoid dense walls of text, but also avoid over-formatting with excessive bullet points and bold headers. There should be a nice visual heirarchy of balance between all elements, so you can quickly scan the page and find what you're looking for.
+
+## Language and Tone Guidelines
+
+Write clearly without dumbing things down. Use simple language when possible, but don't avoid technical terms that users need to know. Explain concepts in terms of what users can achieve rather than how the software works internally.
+
+Make your writing conversational and encouraging. Phrases like "you can also try" or "when that works" feel more natural than rigid instructional language. Help users feel confident about trying new things.
+
+Keep content concise and purposeful. Every sentence should either help users understand something or help them do something. If it doesn't serve one of those purposes, cut it.
+
+Build in context and reasoning. Users want to understand why they're doing something, not just what to do. This builds confidence and helps them troubleshoot when things don't work exactly as expected.
+
+## Practical Implementation
+
+Structure each feature page consistently with the four-section approach, but let the content flow naturally within that structure. Use visual assets like videos and screenshots to complement the written content - they often communicate more effectively than paragraphs of description.
+
+Link generously to related resources, examples, and deeper documentation. Users should never feel stuck or wonder where to go next. Maintain a repository of real examples that users can reference and adapt to their own needs.
+
+The goal is documentation that feels more like helpful guidance from an experienced colleague than a technical manual. Users should finish reading feeling excited about what they can accomplish, not just informed about what the feature does.
+
+## Balance Structure with Flexibility
+
+While they discuss having consistent documentation structure, there's also mention of making content feel less rigid and more natural. The writing should follow guidelines while still feeling conversational and engaging. 
+
+## Bad examples
+
+I personally hate this pattern of bullet point **Bold Text** colon and then more text:
+<bad_example_of_writing>
+#### macOS
+
+1. **Switch to bash**: Go to Cline Settings → Terminal → Default Terminal Profile → Select "bash"
+2. **Disable Oh-My-Zsh temporarily**: If using zsh, try `mv ~/.zshrc ~/.zshrc.backup` and restart VSCode
+3. **Set environment**: Add to your shell config: `export TERM=xterm-256color`
+
+#### Windows
+
+1. **Use PowerShell 7**: Install from Microsoft Store, then select it in Cline settings
+2. **Disable Windows ConPTY**: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → Uncheck
+3. **Try Command Prompt**: Sometimes simpler is better - switch to cmd.exe
+
+#### Linux
+
+1. **Use bash**: Most reliable option - select in Cline settings
+2. **Check permissions**: Ensure VSCode has terminal access permissions
+3. **Disable custom prompts**: Comment out prompt customizations in `.bashrc`
+
+</bad_example_of_writing>
+
+We should instead strive to write beautiful docs that read well. We can use bullet points and numbered lists but it should read naturally and be delightful to look at hierachally when scanning through the doc. There should be a good balance between blocks of text, code snippets, paragraphs, numbered lists, and bullet points. When scanning the documentation visually, you should feel like you're adminiring a tasteful art piece.
+
+<good_example_of_writing>
+#### macOS
+
+The most common fix is switching to bash. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown.
+
+If you're still having issues, Oh-My-Zsh might be interfering with terminal integration. Try temporarily disabling it:
+- Run `mv ~/.zshrc ~/.zshrc.backup` 
+- Restart VSCode
+
+You can also add `export TERM=xterm-256color` to your shell configuration file to improve compatibility.
+
+#### Windows
+
+PowerShell 7 provides the most reliable experience. Install it from the Microsoft Store, then select it in your Cline settings.
+
+Still seeing problems? Try these solutions:
+- Disable Windows ConPTY: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → uncheck
+- Switch to Command Prompt (cmd.exe) - sometimes simpler shells work better
+
+#### Linux
+
+Bash is your most dependable option. Select it in Cline settings if you haven't already.
+
+Check these common issues:
+- Ensure VSCode has terminal access permissions
+- Temporarily comment out custom prompt configurations in your `.bashrc`
+</good_example_of_writing>
+
+This is much more natural to read. Writing this way creates a conversational flow, and bullet points are used idiomatically.
+
+# Using Mintlify Components Idiomatically
+
+Mintlify's custom components can transform basic documentation into engaging, scannable content that users actually want to read. Here's how to use them effectively.
+
+## Visual Content with Frames
+
+Videos and images should be wrapped in `<Frame>` components rather than using raw HTML or markdown. This creates consistent styling and proper responsive behavior.
+
+For videos, embed them directly rather than linking externally. Users are much more likely to watch a 30-second demonstration than click through to another platform:
+
+```jsx
+<Frame>
+	<iframe
+		style={{ width: "100%", aspectRatio: "16/9" }}
+		src="https://www.youtube.com/embed/your-video-id"
+		title="Feature demonstration"
+		frameBorder="0"
+		allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+		allowFullScreen
+	/>
+</Frame>
+```
+
+Screenshots work similarly - the frame provides visual polish and consistency:
+
+```jsx
+<Frame>
+	<img src="/path/to/screenshot.png" alt="Descriptive alt text" />
+</Frame>
+```
+
+## Cards for Navigation and Overview
+
+Cards excel at creating scannable overviews that link to detailed documentation. They're perfect for feature listings, getting started guides, or any section where users need to choose their path.
+
+Use the two-column layout for related features:
+
+```jsx
+<Columns cols={2}>
+  <Card title="Feature Name" icon="relevant-icon" href="/link/to/docs">
+    Brief description that explains what this feature does and why someone would use it.
+  </Card>
+  
+  <Card title="Related Feature" icon="another-icon" href="/another/link">
+    Another concise explanation that helps users understand the value proposition.
+  </Card>
+</Columns>
+```
+
+The key is writing card descriptions that are informative enough to help users decide whether to click through, but concise enough to scan quickly. Each card should answer "what does this do?" and "why would I need this?"
+
+## Tips and Notes for Context
+
+Use `<Tip>` components for helpful information that enhances the main content without cluttering it:
+
+```jsx
+<Tip>
+	Pro tip: You can combine multiple @ mentions in a single message to give Cline 
+	comprehensive context about your issue.
+</Tip>
+```
+
+`<Note>` components work well for important caveats or technical limitations:
+
+```jsx
+<Note>
+	Due to VS Code limitations, some features require specific settings to work properly.
+</Note>
+```
+
+`<Info>` is also cool:
+
+<Info>
+	**Quick Fix**: If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings.
+	This resolves 90% of terminal integration problems.
+</Info>
+
+**Never** fall into that awful **Bold Text** - description pattern that we specifically identified as bad writing. The content should flow naturally as connected thoughts rather than feeling like a templated AI response with forced formatting.
+
+
+## When to Use Bullet Points and Numbered Lists Strategically
+
+Bullet points serve functional purposes - use them for:
+
+**Sequential actions or troubleshooting steps** where users need to follow a specific order:
+1. Install the extension
+2. Restart VSCode  
+3. Check the settings panel
+
+**Lists of related options** where users need to choose one approach:
+- Try PowerShell 7 for the most reliable experience
+- Switch to Command Prompt if you're still having issues
+- Use WSL Bash for Linux compatibility
+
+**Quick reference items** that users might need to scan quickly when problem-solving.
+
+**Improving Visual Hierarchy** when there's a wall of text - that's a good time to introduce bullet points or numbered lists.
+
+Each bulleted item or numbered list should be a discrete action or piece of information that benefits from being visually separated. This is a key weapon you can employ when going for that artwork experience I mentioned earlier. 
+
+<good_example_of_bullet_points>
+## Finding and Configuring Terminal Settings
+
+You can access Cline's terminal settings by clicking the settings icon in the Cline sidebar, then navigating to the Terminal section. These settings control how Cline interacts with your system's terminal.
+
+- The **Default Terminal Profile** setting determines which shell Cline uses for executing commands. If you're experiencing issues, this is usually the first thing to change. I personally keep this set to `bash` on all my systems because it's the most reliable option, even though I use `zsh` for my regular terminal work.
+
+- **Shell Integration Timeout** controls how long Cline waits for the terminal to become ready. The default is 4 seconds, but if you have a heavy shell configuration (lots of plugins, slow startup scripts), you might need to increase this to 10 or even 15 seconds. I've found that WSL environments and SSH connections often need longer timeouts.
+
+- The **Enable Aggressive Terminal Reuse** setting determines whether Cline tries to reuse existing terminals even when they're not in the correct directory. When this causes problems (commands running in the wrong directory, virtual environment issues), disabling it creates more terminal instances but ensures each command runs in a clean state.
+
+- **Terminal Output Line Limit** sets how many lines of output Cline will read from commands. The default of 500 lines works for most cases, but you might need to adjust it. For verbose build outputs, increase it. For commands with progress bars that spam thousands of lines, decrease it to around 100 to avoid consuming too many tokens.
+</good_example_of_bullet_points>
+
+## Write Like a Human, Not an AI
+
+Keep it short and direct. If you can say something in fewer words, do it. Long explanations often confuse more than they help.
+
+Use normal sentence lengths. Mix short and long sentences naturally, like you would when talking to someone. Avoid those meandering compound sentences that go on forever.
+
+Cut the corporate speak. Instead of "utilize," say "use." Instead of "in order to," just say "to." Write like you're explaining something to a colleague, not drafting a press release.
+
+Don't over-explain obvious things. If users are reading documentation, they probably understand basic concepts. Respect their intelligence.
+
+## Never use em dashes or emojis
+
+That's pretty much it. Never use them. Only AI writes with em dashes or emojis.
+
+# Anthropomorphizing Cline
+
+When referring to Cline, always call him a "him" not an "it". 
+
+Bad example:
+- When Cline can’t execute commands or read their output, you lose access to one of its most powerful capabilities.
+
+Good Example:
+
+- When Cline can’t execute commands or read their output, you lose access to one of his most powerful capabilities.
+
+# Using "I" when sharing your workflow
+
+Adding a personal touch goes a long way. There are great examples in the docs currently where I use "I" to share how I personally use cline, from dev to dev. It's a great technique.
+
+# Crosslinking relevant documentation pages
+
+Make sure you crosslink when you're done writing the docs. If there are relevant docs, just link to them.
+
+# Brevity is the soul of wit
+
+Don't ramble if you don't need to. Use bullet points and numbered lists. Keep things easy to read.
+
+<bad_example>
+
+When Cline can't execute commands or read their output, you lose access to one of his most powerful capabilities. Terminal integration problems are frustrating, but they're usually fixable with a few simple changes.
+
+## The Most Common Problem: Shell Integration Issues
+
+If you're seeing "Shell integration unavailable" or Cline isn't getting command output, the issue is almost always your shell configuration. Complex shell setups with custom prompts, plugins, and fancy configurations can interfere with VSCode's terminal integration.
+
+**Switch to bash first.** This fixes the problem 90% of the time. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown. Restart VSCode after making this change.
+
+Still having issues? Try increasing the shell integration timeout. Go to Cline Settings → Terminal → Shell Integration Timeout and change it from 4 seconds to 10 seconds. Heavy shell configurations need more time to initialize properly.
+
+If commands are running in the wrong directories or you're seeing weird behavior, disable aggressive terminal reuse. In Cline Settings → Terminal, uncheck "Enable aggressive terminal reuse." This creates more terminal instances but ensures each command runs in a clean environment.
+
+
+</bad_exaxmple>
+
+The first part is total filler, useless to any serious developer. You can tell it's written by a non technical person that doesn't value clean, straightforward information. 
+
+<good_example>
+## Shell Integration Issues
+
+If you're seeing "Shell integration unavailable" or Cline can't read command output, your shell configuration is interfering with VSCode's terminal integration.
+
+**Switch to bash first.** Go to Cline Settings → Terminal → Default Terminal Profile and select "bash." This fixes 90% of problems.
+
+Still broken? Try these:
+- Increase shell integration timeout to 10 seconds in Cline Settings → Terminal
+- Disable "aggressive terminal reuse" if commands run in wrong directories
+- Restart VSCode after making changes
+</good_example>
+
+The good version cuts straight to the problem and solution. No hand-holding, no emotional language about frustration, just the facts: what's wrong, how to fix it, what to try next. Respects that developers want information, not sympathy.RetryClaude can make mistakes. Please double-check responses.
+
+ALWAYS consider your audience. And your audience is devs who don't want their time wasted. Give them the info. I cannot stress this enough. Use bullet points and numbered lists. Prose is good, but every word should actually mean something to the dev reading it.
+
+# Lastly, before you start writing docs
+
+1. Internalize these guidelines. I mean it. 
+
+2. Read `docs/docs.json` and get an understanding of the structure of the docs. This will come in handly at the end when you're doing a final pass so you can cross link to docs where relevant.
+
+3. Read some good examples that I personally wrote and am proud of:
+
+- docs/features/slash-commands/workflows.mdx
+- docs/features/slash-commands/new-task.mdx
+- docs/features/at-mentions/overview.mdx
+- docs/features/drag-and-drop.mdx
+
+4. If the user specifies any other instructions make sure you follow them.
diff --git a/.codex/environments/environment.toml b/.codex/environments/environment.toml
new file mode 100644
index 0000000..337cb1d
--- /dev/null
+++ b/.codex/environments/environment.toml
@@ -0,0 +1,50 @@
+# THIS IS AUTOGENERATED. DO NOT EDIT MANUALLY
+version = 1
+name = "cline"
+
+[setup]
+script = '''
+if [ ! -d "node_modules" ]; then
+  MAIN_WORKTREE="$(git worktree list | head -n1 | awk '{print $1}')"
+  ln -s "$MAIN_WORKTREE/node_modules" node_modules
+  ln -s "$MAIN_WORKTREE/webview-ui/node_modules" webview-ui/node_modules
+fi
+'''
+
+[[actions]]
+name = "VS Code"
+icon = "run"
+command = "chmod +x ./scripts/run-extension-host.sh && ./scripts/run-extension-host.sh production"
+
+[[actions]]
+name = "CLI"
+icon = "run"
+command = '''
+cd sdk
+bun install
+bun run cli
+'''
+
+[[actions]]
+name = "npm install"
+icon = "tool"
+command = '''
+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)"
+'''
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..9f1ff5f
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,4 @@
+demo.gif filter=lfs diff=lfs merge=lfs -text
+assets/docs/demo.gif filter=lfs diff=lfs merge=lfs -text
+
+* text=auto eol=lf
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..aad3c09
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,2 @@
+/.github/   @saoudrizwan @arafatkatze @maxpaulus43 @dominiccooney
+/README.md  @saoudrizwan @juanpflores
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 0000000..b4db8f1
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,88 @@
+name: 🐛 Bug Report
+description: File a bug report
+labels: ['bug']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Important:** All bug reports must be reproducible using Claude Sonnet 4.5. Cline uses complex prompts so less capable models may not work as expected.
+  - type: dropdown
+    id: cline-surface
+    attributes:
+      label: Cline Surface
+      description: Which Cline surface are you reporting a bug for?
+      options:
+        - VSCode Extension
+        - JetBrains Plugin
+        - CLI
+      default: 0
+    validations:
+      required: true
+  - type: input
+    id: cline-version
+    attributes:
+      label: Cline Version
+      description: What version of Cline are you using? (You can find this at the bottom of the Settings view)
+      placeholder: 'e.g., 1.2.3'
+    validations:
+      required: true
+  - type: checkboxes
+    id: beta
+    attributes:
+      label: Beta version
+      options:
+        - label: I am using a beta version of Cline
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: How do you trigger this bug? Please walk us through it step by step.
+      value: |
+        1.
+        2.
+        3.
+    validations:
+      required: false
+  - type: input
+    id: provider-model
+    attributes:
+      label: Provider/Model
+      description: What provider and model were you using when the issue occurred?
+      placeholder: 'e.g., cline:anthropic/claude-sonnet-4.5, gemini:gemini-2.5-pro-exp-03-25'
+    validations:
+      required: false
+  - type: textarea
+    id: ide-diagnostics
+    attributes:
+      label: IDE / CLI Diagnostics
+      description: |
+        Paste the "About" diagnostics for your Cline surface. This captures the IDE build, runtime, and host details we need.
+        - VSCode Extension: open `Help → About` (Windows/Linux) or `Code → About Visual Studio Code` (macOS), then copy the info.
+        - JetBrains Plugin: open `Help → About` (Windows/Linux) or `<IDE name> → About` (macOS), then click `Copy` to grab build, runtime, OS, memory, and cores.
+        - CLI: there is no About dialog. Run `cline --version` and paste the output.
+      placeholder: Paste the copied About info or `cline --version` output here.
+    validations:
+      required: false
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System Information
+      description: What operating system and hardware are you using?
+      placeholder: |
+        Operating System: Windows 11, macOS Sonoma, Ubuntu 22.04, etc.
+        Hardware: CPU, GPU, RAM specifications if relevant
+        e.g.,
+        OS: Windows 11
+        CPU: Intel Core i7-11700K
+        GPU: NVIDIA GeForce RTX 3070
+        RAM: 32GB DDR4
+    validations:
+      required: false
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..81fc744
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+    - name: ✨ Feature Request
+      url: https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop
+      about: Share and vote on feature requests for Cline
+    - name: 👋 Cline Discord
+      url: https://discord.gg/cline
+      about: Join our Discord community for discussions and support
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..0bd72a5
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,57 @@
+# Copilot Instructions for Cline
+
+This is a VS Code extension. Read `.clinerules/general.md` for tribal knowledge and nuanced patterns.
+
+## Architecture
+- **Core** (`src/`): `extension.ts` → `WebviewProvider` → `Controller` (single source of truth) → `Task` (agent loop).
+- **Webview** (`webview-ui/`): React/Vite app. State via `ExtensionStateContext.tsx`, synced through message passing.
+- **Communication**: Protobuf-defined gRPC-like protocol over VS Code message passing. Schemas in `proto/`.
+- **MCP**: `src/services/mcp/McpHub.ts`.
+
+## Build & Test (Critical — non-obvious commands)
+- **Build**: `bun run compile` — NOT `bun run build`.
+- **Watch**: `bun run watch` (extension + webview).
+- **Protos**: `bun run protos` — run **immediately** after any `.proto` change. Generates into `src/shared/proto/`, `src/generated/`.
+- **Tests**: `bun run test:unit`. After prompt/tool changes: `UPDATE_SNAPSHOTS=true bun run test:unit`.
+
+## Protobuf RPC Workflow (4 steps)
+1. **Define** in `proto/cline/*.proto`. Naming: `PascalCaseService`, `camelCase` RPCs, `PascalCase` Messages. Use `common.proto` shared types for simple data.
+2. **Generate**: `bun run protos`.
+3. **Backend handler**: `src/core/controller/<domain>/`. 
+4. **Frontend call**: `UiServiceClient.myMethod(Request.create({...}))`.
+- Adding enums (e.g. `ClineSay`) → also update `src/shared/proto-conversions/cline-message.ts`.
+
+## Adding API Providers (silent failure risk)
+Three proto conversion updates are **required** or the provider silently resets to Anthropic:
+1. `proto/cline/models.proto` — add to `ApiProvider` enum.
+2. `convertApiProviderToProto()` in `src/shared/proto-conversions/models/api-configuration-conversion.ts`.
+3. `convertProtoToApiProvider()` in the same file.
+
+Also update: `src/shared/api.ts`, `src/shared/providers/providers.json`, `src/core/api/index.ts`, `webview-ui/.../providerUtils.ts`, `webview-ui/.../validate.ts`, `webview-ui/.../ApiOptions.tsx`.
+
+For Responses API providers: add to `isNextGenModelProvider()` in `src/utils/model-utils.ts` and set `apiFormat: ApiFormat.OPENAI_RESPONSES` on models.
+
+## Adding Tools to System Prompt (5+ file chain)
+1. Add enum to `ClineDefaultTool` in `src/shared/tools.ts`.
+2. Create definition in `src/core/prompts/system-prompt/tools/` (export `[GENERIC]` minimum).
+3. Register in `src/core/prompts/system-prompt/tools/init.ts`.
+4. Whitelist in `src/core/prompts/system-prompt/variants/*/config.ts` for each model family.
+5. Handler in `src/core/task/tools/handlers/`, wire in `ToolExecutor.ts`.
+6. If tool has UI: add `ClineSay` enum in proto → `ExtensionMessage.ts` → `cline-message.ts` → `ChatRow.tsx`.
+7. Regenerate snapshots: `UPDATE_SNAPSHOTS=true bun run test:unit`.
+
+## Modifying System Prompt
+Modular: `components/` (shared) + `variants/` (model-specific) + `templates/` (`{{PLACEHOLDER}}`). Variants override components via `componentOverrides` in `config.ts` or custom `template.ts`. XS variant is heavily condensed inline. Always regenerate snapshots after changes.
+
+## Global State Keys (silent failure risk)
+Adding a key requires updating the typed storage definitions in `src/shared/storage/state-keys.ts`; runtime reads and writes should go through `StateManager`, not VS Code `ExtensionContext` storage. Persistent state is file-backed so it works across VS Code, CLI, and JetBrains hosts.
+
+## Slash Commands (3 places)
+- `src/core/slash-commands/index.ts` — definitions.
+- `src/core/prompts/commands.ts` — system prompt integration.
+- `webview-ui/src/utils/slash-commands.ts` — webview autocomplete.
+
+## Conventions
+- **Paths**: Always use `src/utils/path` helpers (`toPosixString`) for cross-platform compatibility.
+- **Logging**: `src/shared/services/Logger.ts`.
+- **Feature flags**: See PR #7566 as reference pattern.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..dbd3674
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,36 @@
+version: 2
+updates:
+    # Main extension dependencies
+    - package-ecosystem: "npm"
+      directory: "/apps/vscode"
+      schedule:
+          interval: "weekly"
+      # Group all updates into a single PR
+      groups:
+          all-dependencies:
+              patterns:
+                  - "*"
+      ignore:
+          # Ignore all non-security updates (security vulnerabilities bypass these ignore rules)
+          - dependency-name: "*"
+            update-types:
+                - "version-update:semver-major"
+                - "version-update:semver-minor"
+                - "version-update:semver-patch"
+
+    # Webview UI dependencies
+    - package-ecosystem: "npm"
+      directory: "/apps/vscode/webview-ui"
+      schedule:
+          interval: "weekly"
+      groups:
+          all-dependencies:
+              patterns:
+                  - "*"
+      ignore:
+          - dependency-name: "@testing-library/*"
+          - dependency-name: "*"
+            update-types:
+                - "version-update:semver-major"
+                - "version-update:semver-minor"
+                - "version-update:semver-patch"
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 0000000..73c151a
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,79 @@
+<!--
+Thank you for contributing to Cline!
+
+⚠️ Important: Before submitting this PR, please ensure you have:
+- For feature requests: Created a discussion in our Feature Requests discussions board https://github.com/cline/cline/discussions/categories/feature-requests and received approval from core maintainers before implementation
+- For all changes: Link the associated issue/discussion in the "Related Issue" section below
+
+Limited exceptions:
+Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly without prior discussion.
+
+Why this requirement?
+We deeply appreciate all community contributions - they are essential to Cline's success! To ensure the best use of everyone's time and maintain project direction, we use our Feature Requests discussions board to gauge community interest and validate feature ideas before implementation begins. This helps us focus development efforts on features that will benefit the most users.
+-->
+
+### Related Issue
+
+<!-- Replace XXXX with the issue number that this PR addresses -->
+**Issue:** #XXXX
+
+### Description
+
+<!-- 
+Help reviewers understand your changes by making this PR readable and well-organized:
+
+- What problem does this PR solve?
+- Why were these changes introduced and what purpose do they serve?
+- For larger changes, provide context about your approach and reasoning
+
+Small PRs may need minimal description, but larger changes benefit from explaining where you're coming from. Much of this context can be in the linked issue above, so feel free to reference it rather than repeating everything here.
+-->
+
+### Test Procedure
+
+<!-- 
+Please walk us through your testing approach and thought process. This helps reviewers understand that you've thoroughly considered the impact of your changes:
+
+- How did you test this change?
+- What could potentially break and how did you verify it doesn't?
+- What existing functionality might be affected and how did you check it still works?
+- Why are you confident this is ready for merge?
+
+We're not looking for exhaustive documentation - just evidence that you've thought through the implications of your changes and tested accordingly.
+-->
+
+### Type of Change
+
+<!-- Put an 'x' in all boxes that apply -->
+
+-   [ ] 🐛 Bug fix (non-breaking change which fixes an issue)
+-   [ ] ✨ New feature (non-breaking change which adds functionality)
+-   [ ] 💥 Breaking change (fix or feature that would cause existing functionality to not work as expected)
+-   [ ] ♻️ Refactor Changes
+-   [ ] 💅 Cosmetic Changes
+-   [ ] 📚 Documentation update
+-   [ ] 🏃 Workflow Changes
+
+### Pre-flight Checklist
+
+<!-- Put an 'x' in all boxes that apply -->
+
+-   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
+-   [ ] Tests are passing (`bun test`) and code is formatted and linted (`bun run format && bun run lint`)
+-   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
+
+### Screenshots
+
+<!-- 
+Help reviewers quickly understand your changes:
+
+- **UI Changes**: Please include screenshots showing before/after states
+- **Complex Workflows**: Consider uploading a screen recording (video) if your changes involve multiple steps or state transitions
+- **Backend Changes**: Not required, but feel free to include terminal output or other evidence that demonstrates functionality
+
+This helps reviewers see what you've built without having to pull down and test your branch first.
+-->
+
+### Additional Notes
+
+<!-- Add any additional notes for reviewers -->
diff --git a/.github/scripts/coverage_check/__init__.py b/.github/scripts/coverage_check/__init__.py
new file mode 100644
index 0000000..581cf61
--- /dev/null
+++ b/.github/scripts/coverage_check/__init__.py
@@ -0,0 +1,19 @@
+"""
+Coverage utility package for GitHub Actions workflows.
+This package handles extracting coverage percentages, comparing them, and generating PR comments.
+"""
+
+# Import external dependencies
+import requests
+
+# Import main function for CLI usage
+from .__main__ import main
+
+# Import functions from extraction module
+from .extraction import extract_coverage, compare_coverage, run_coverage, set_verbose
+
+# Import functions from github_api module
+from .github_api import generate_comment, post_comment, set_github_output
+
+# Import functions from workflow module
+from .workflow import process_coverage_workflow
diff --git a/.github/scripts/coverage_check/__main__.py b/.github/scripts/coverage_check/__main__.py
new file mode 100644
index 0000000..7e9f918
--- /dev/null
+++ b/.github/scripts/coverage_check/__main__.py
@@ -0,0 +1,154 @@
+"""
+Main module.
+This module provides the CLI interface for the coverage utility script.
+"""
+
+import sys
+import argparse
+
+from .extraction import extract_coverage, compare_coverage, run_coverage, set_verbose
+from .github_api import generate_comment, post_comment, set_github_output
+from .workflow import process_coverage_workflow
+from .util import log
+
+def setup_verbose_mode(args):
+    """
+    Set up verbose mode based on command line arguments.
+    
+    Args:
+        args: Parsed command line arguments
+    """
+    if getattr(args, 'verbose', False):
+        set_verbose(True)
+        log("Verbose mode enabled")
+
+def main():
+    # Create parent parser with common arguments
+    parent_parser = argparse.ArgumentParser(add_help=False)
+    parent_parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output')
+
+    # Create main parser that inherits common arguments
+    parser = argparse.ArgumentParser(description='Coverage utility script for GitHub Actions workflows', parents=[parent_parser])
+    subparsers = parser.add_subparsers(dest='command', help='Command to run')
+    
+    # extract-coverage command - used directly in workflow
+    extract_parser = subparsers.add_parser('extract-coverage', help='Extract coverage percentage from a file', parents=[parent_parser])
+    extract_parser.add_argument('file_path', help='Path to the coverage report file')
+    extract_parser.add_argument('--type', choices=['extension', 'webview'], default='extension',
+                               help='Type of coverage report')
+    extract_parser.add_argument('--github-output', action='store_true', help='Output in GitHub Actions format')
+    
+    # compare-coverage command - used by process-workflow
+    compare_parser = subparsers.add_parser('compare-coverage', help='Compare coverage percentages', parents=[parent_parser])
+    compare_parser.add_argument('base_cov', help='Base branch coverage percentage')
+    compare_parser.add_argument('pr_cov', help='PR branch coverage percentage')
+    compare_parser.add_argument('--output-prefix', default='', help='Prefix for GitHub Actions output variables')
+    compare_parser.add_argument('--github-output', action='store_true', help='Output in GitHub Actions format')
+    
+    # generate-comment command - used by process-workflow
+    comment_parser = subparsers.add_parser('generate-comment', help='Generate PR comment with coverage comparison', parents=[parent_parser])
+    comment_parser.add_argument('base_ext_cov', help='Base branch extension coverage')
+    comment_parser.add_argument('pr_ext_cov', help='PR branch extension coverage')
+    comment_parser.add_argument('ext_decreased', help='Whether extension coverage decreased (true/false)')
+    comment_parser.add_argument('ext_diff', help='Extension coverage difference')
+    comment_parser.add_argument('base_web_cov', help='Base branch webview coverage')
+    comment_parser.add_argument('pr_web_cov', help='PR branch webview coverage')
+    comment_parser.add_argument('web_decreased', help='Whether webview coverage decreased (true/false)')
+    comment_parser.add_argument('web_diff', help='Webview coverage difference')
+    
+    # post-comment command - used by process-workflow
+    post_parser = subparsers.add_parser('post-comment', help='Post a comment to a GitHub PR', parents=[parent_parser])
+    post_parser.add_argument('comment_path', help='Path to the file containing the comment text')
+    post_parser.add_argument('pr_number', help='PR number')
+    post_parser.add_argument('repo', help='Repository in the format "owner/repo"')
+    post_parser.add_argument('--token', help='GitHub token')
+    
+    # run-coverage command - used by process-workflow
+    run_parser = subparsers.add_parser('run-coverage', help='Run a coverage command and extract the coverage percentage', parents=[parent_parser])
+    run_parser.add_argument('coverage_cmd', help='Command to run')
+    run_parser.add_argument('output_file', help='File to save the output to')
+    run_parser.add_argument('--type', choices=['extension', 'webview'], default='extension',
+                           help='Type of coverage report')
+    run_parser.add_argument('--github-output', action='store_true', help='Output in GitHub Actions format')
+    
+    # process-workflow command - used directly in workflow
+    workflow_parser = subparsers.add_parser('process-workflow', help='Process the entire coverage workflow', parents=[parent_parser])
+    workflow_parser.add_argument('--base-branch', required=True, help='Base branch name')
+    workflow_parser.add_argument('--pr-number', help='PR number')
+    workflow_parser.add_argument('--repo', help='Repository in the format "owner/repo"')
+    workflow_parser.add_argument('--token', help='GitHub token')
+    
+    # set-github-output command - used by process-workflow
+    output_parser = subparsers.add_parser('set-github-output', help='Set GitHub Actions output variable', parents=[parent_parser])
+    output_parser.add_argument('name', help='Output variable name')
+    output_parser.add_argument('value', help='Output variable value')
+    
+    args = parser.parse_args()
+    
+    # Set up verbose mode
+    setup_verbose_mode(args)
+    
+    if args.command == 'extract-coverage':
+        log(f"Extracting coverage from file: {args.file_path} (type: {args.type})")
+        coverage_pct = extract_coverage(args.file_path, args.type)
+        if args.github_output:
+            set_github_output(f"{args.type}_coverage", coverage_pct)
+        else:
+            log(f"Coverage: {coverage_pct}%")
+        
+    elif args.command == 'compare-coverage':
+        log(f"Comparing coverage: base={args.base_cov}%, PR={args.pr_cov}%")
+        decreased, diff = compare_coverage(args.base_cov, args.pr_cov)
+        if args.github_output:
+            prefix = args.output_prefix
+            set_github_output(f"{prefix}decreased", str(decreased).lower())
+            set_github_output(f"{prefix}diff", diff)
+            log(f"Coverage difference: {diff}%")
+            log(f"Coverage decreased: {decreased}")
+        else:
+            log(f"decreased={str(decreased).lower()}")
+            log(f"diff={diff}")
+        
+    elif args.command == 'generate-comment':
+        log("Generating coverage comparison comment")
+        comment = generate_comment(
+            args.base_ext_cov, args.pr_ext_cov, args.ext_decreased, args.ext_diff,
+            args.base_web_cov, args.pr_web_cov, args.web_decreased, args.web_diff
+        )
+        # Output the comment to stdout
+        log(comment)
+        
+    elif args.command == 'post-comment':
+        log(f"Posting comment from {args.comment_path} to PR #{args.pr_number} in {args.repo}")
+        post_comment(args.comment_path, args.pr_number, args.repo, args.token)
+        
+    elif args.command == 'run-coverage':
+        log(f"Running coverage command: {args.coverage_cmd}")
+        log(f"Output file: {args.output_file}")
+        log(f"Coverage type: {args.type}")
+        coverage_pct = run_coverage(args.coverage_cmd, args.output_file, args.type)
+        if args.github_output:
+            set_github_output(f"{args.type}_coverage", coverage_pct)
+        else:
+            log(f"Coverage: {coverage_pct}%")
+        
+    elif args.command == 'process-workflow':
+        log("Processing coverage workflow")
+        log(f"Base branch: {args.base_branch}")
+        if args.pr_number:
+            log(f"PR number: {args.pr_number}")
+        if args.repo:
+            log(f"Repository: {args.repo}")
+        process_coverage_workflow(args)
+        
+    elif args.command == 'set-github-output':
+        log(f"Setting GitHub output: {args.name}={args.value}")
+        set_github_output(args.name, args.value)
+    
+    else:
+        log("No command specified")
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/coverage_check/extraction.py b/.github/scripts/coverage_check/extraction.py
new file mode 100644
index 0000000..ec9b732
--- /dev/null
+++ b/.github/scripts/coverage_check/extraction.py
@@ -0,0 +1,265 @@
+"""
+Coverage extraction module.
+This module handles extracting coverage percentages from coverage report files.
+"""
+
+import os
+import re
+import sys
+import shlex
+import subprocess
+import traceback
+from .util import log, file_exists, get_file_size, list_directory, is_safe_command, run_command
+
+# Global verbose flag
+verbose = False
+
+def set_verbose(value):
+    """Set the global verbose flag."""
+    global verbose
+    verbose = value
+
+def print_debug_output(content, coverage_type):
+    """
+    Print debug information about the coverage output.
+    
+    Args:
+        content: The content of the coverage file
+        coverage_type: Type of coverage report (extension or webview)
+    """
+    if not verbose:
+        return
+
+    # Extract and print only the coverage summary section
+    if coverage_type == "extension":
+        # Look for the coverage summary section
+        summary_match = re.search(r'=============================== Coverage summary ===============================\n(.*?)\n=+', content, re.DOTALL)
+        if summary_match:
+            sys.stdout.write("\n##[group]EXTENSION COVERAGE SUMMARY\n")
+            sys.stdout.write("=============================== Coverage summary ===============================\n")
+            sys.stdout.write(summary_match.group(1) + "\n")
+            sys.stdout.write("================================================================================\n")
+            sys.stdout.write("##[endgroup]\n")
+            sys.stdout.flush()
+        else:
+            sys.stdout.write("\n##[warning]No coverage summary found in extension coverage file\n")
+            sys.stdout.flush()
+    else:  # webview
+        # Look for the coverage table - specifically the "All files" row
+        table_match = re.search(r'% Coverage report from v8.*?-+\|.*?\n.*?\n(All files.*?)(?:\n[^\n]*\|)', content, re.DOTALL)
+        if table_match:
+            sys.stdout.write("\n##[group]WEBVIEW COVERAGE SUMMARY\n")
+            sys.stdout.write("% Coverage report from v8\n")
+            sys.stdout.write("-------------------|---------|----------|---------|---------|-------------------\n")
+            sys.stdout.write("File               | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s \n")
+            sys.stdout.write("-------------------|---------|----------|---------|---------|-------------------\n")
+            sys.stdout.write(table_match.group(1) + "\n")
+            sys.stdout.write("-------------------|---------|----------|---------|---------|-------------------\n")
+            sys.stdout.write("##[endgroup]\n")
+            sys.stdout.flush()
+        else:
+            sys.stdout.write("\n##[warning]No coverage table found in webview coverage file\n")
+            sys.stdout.flush()
+
+def extract_coverage(file_path, coverage_type="extension"):
+    """
+    Extract coverage percentage from a coverage report file.
+    
+    Args:
+        file_path: Path to the coverage report file
+        coverage_type: Type of coverage report (extension or webview)
+        
+    Returns:
+        Coverage percentage as a float
+    """
+    
+    # Always print file path for debugging
+    log(f"Checking coverage file: {file_path}")
+    
+    # Check if file exists and get its size
+    if not file_exists(file_path):
+        sys.stdout.write(f"\n##[error]File {file_path} does not exist\n")
+        sys.stdout.flush()
+        log(f"Error: File {file_path} does not exist")
+        
+        # Check if the directory exists
+        dir_path = os.path.dirname(file_path)
+        if not os.path.exists(dir_path):
+            sys.stdout.write(f"\n##[error]Directory {dir_path} does not exist\n")
+            sys.stdout.flush()
+            log(f"Error: Directory {dir_path} does not exist")
+        else:
+            # List directory contents for debugging
+            log(f"Directory {dir_path} exists, listing contents:")
+            try:
+                dir_contents = list_directory(dir_path)
+                for name, size in dir_contents:
+                    log(f"  {name} - {size}")
+                    sys.stdout.write(f"  {name} - {size}\n")
+                sys.stdout.flush()
+            except Exception as e:
+                log(f"Error listing directory: {e}")
+        
+        return 0.0
+    
+    file_size = get_file_size(file_path)
+    log(f"File size: {file_size} bytes")
+    sys.stdout.write(f"\n##[info]Coverage file {file_path} exists, size: {file_size} bytes\n")
+    sys.stdout.flush()
+    
+    if file_size == 0:
+        sys.stdout.write(f"\n##[warning]File {file_path} is empty\n")
+        sys.stdout.flush()
+        log(f"Warning: File {file_path} is empty")
+        return 0.0
+    
+    # List directory contents for debugging
+    dir_path = os.path.dirname(file_path)
+    log(f"Directory contents of {dir_path}:")
+    try:
+        dir_contents = list_directory(dir_path)
+        for name, size in dir_contents:
+            log(f"  {name} - {size}")
+    except Exception as e:
+        log(f"Error listing directory: {e}")
+    
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # Print debug information if verbose
+    print_debug_output(content, coverage_type)
+    
+    # Extract coverage percentage based on coverage type
+    if coverage_type == "extension":
+        # Extract the percentage from the "Lines" row in the coverage summary
+        # Pattern: Lines : xx.xx% ( xxxxxxx/xxxxxxx )
+        lines_match = re.search(r'Lines\s*:\s*(\d+\.\d+)%', content)
+        if lines_match:
+            coverage_pct = float(lines_match.group(1))
+            if verbose:
+                sys.stdout.write(f"Pattern matched (Lines percentage): {coverage_pct}\n")
+                sys.stdout.flush()
+            return coverage_pct
+        else:
+            # No coverage data found, log full content for debugging
+            log("No coverage data found. Full file content:")
+            log("=== Full file content ===")
+            log(content)
+            log("=== End file content ===")
+    else:  # webview
+        # Extract the percentage from the "% Lines" column in the "All files" row
+        # Pattern: All files | xx.xx | xx.xx | xx.xx | xx.xx |
+        all_files_match = re.search(r'All files\s+\|\s+\d+\.\d+\s+\|\s+\d+\.\d+\s+\|\s+\d+\.\d+\s+\|\s+(\d+\.\d+)', content)
+        if all_files_match:
+            coverage_pct = float(all_files_match.group(1))
+            if verbose:
+                sys.stdout.write(f"Pattern matched (All files % Lines): {coverage_pct}\n")
+                sys.stdout.flush()
+            return coverage_pct
+        else:
+            # No coverage data found, log full content for debugging
+            log("No coverage data found. Full file content:")
+            log("=== Full file content ===")
+            log(content)
+            log("=== End file content ===")
+    
+    # If no match found, return 0.0
+    return 0.0
+
+def compare_coverage(base_cov, pr_cov):
+    """
+    Compare coverage percentages between base and PR branches.
+    
+    Args:
+        base_cov: Base branch coverage percentage
+        pr_cov: PR branch coverage percentage
+        
+    Returns:
+        Tuple of (decreased, diff)
+    """
+    try:
+        base_cov = float(base_cov)
+        pr_cov = float(pr_cov)
+    except ValueError:
+        sys.stdout.write(f"Error: Invalid coverage values - base: {base_cov}, PR: {pr_cov}\n")
+        sys.stdout.flush()
+        return False, 0
+    
+    diff = pr_cov - base_cov
+    decreased = diff < 0
+    
+    return decreased, abs(diff)
+
+def run_coverage(command, output_file, coverage_type="extension"):
+    """
+    Run a coverage command and extract the coverage percentage.
+    
+    Args:
+        command: Command to run
+        output_file: File to save the output to
+        coverage_type: Type of coverage report (extension or webview)
+        
+    Returns:
+        Coverage percentage as a float
+    
+    Raises:
+        SystemExit: If the output file is not created or is empty
+    """
+    
+    try:
+        # Run the command and capture output
+        if not is_safe_command(command):
+            error_msg = f"ERROR: Unsafe command detected: {command}"
+            log(error_msg)
+            sys.stdout.write(f"\n##[error]{error_msg}\n")
+            sys.stdout.flush()
+            sys.exit(1)
+
+        # Run command using safe execution from util
+        returncode, stdout, stderr = run_command(command)
+        
+        # Log command result
+        log(f"Command exit code: {returncode}")
+        log(f"Command stdout length: {len(stdout)} bytes")
+        log(f"Command stderr length: {len(stderr)} bytes")
+        
+        # Save output to file
+        log(f"Saving command output to {output_file}")
+        with open(output_file, 'w') as f:
+            f.write(stdout)
+            if stderr:
+                f.write("\n\n=== STDERR ===\n")
+                f.write(stderr)
+        
+        # Verify file was created and has content
+        if not file_exists(output_file):
+            error_msg = f"ERROR: Output file {output_file} was not created"
+            log(error_msg)
+            sys.stdout.write(f"\n##[error]{error_msg}\n")
+            sys.stdout.flush()
+            sys.exit(1)  # Exit with error code to fail the workflow
+            
+        file_size = get_file_size(output_file)
+        if file_size == 0:
+            error_msg = f"ERROR: Output file {output_file} is empty"
+            log(error_msg)
+            sys.stdout.write(f"\n##[error]{error_msg}\n")
+            sys.stdout.flush()
+            sys.exit(1)  # Exit with error code to fail the workflow
+            
+        log(f"Output file size: {file_size} bytes")
+        
+        # Extract coverage percentage
+        coverage_pct = extract_coverage(output_file, coverage_type)
+        
+        log(f"{coverage_type.capitalize()} coverage: {coverage_pct}%")
+        return coverage_pct
+    
+    except Exception as e:
+        error_msg = f"Error running coverage command: {e}"
+        log(error_msg)
+        sys.stdout.write(f"\n##[error]{error_msg}\n")
+        sys.stdout.flush()
+        # Print stack trace for debugging
+        log(traceback.format_exc())
+        sys.exit(1)  # Exit with error code to fail the workflow
diff --git a/.github/scripts/coverage_check/github_api.py b/.github/scripts/coverage_check/github_api.py
new file mode 100644
index 0000000..6251c70
--- /dev/null
+++ b/.github/scripts/coverage_check/github_api.py
@@ -0,0 +1,177 @@
+"""
+GitHub API module.
+This module handles interactions with the GitHub API for posting comments to PRs.
+"""
+
+import os
+import requests
+from .util import log, file_exists
+
+def generate_comment(base_ext_cov, pr_ext_cov, ext_decreased, ext_diff, 
+                    base_web_cov, pr_web_cov, web_decreased, web_diff):
+    """
+    Generate a PR comment with coverage comparison.
+    
+    Args:
+        base_ext_cov: Base branch extension coverage
+        pr_ext_cov: PR branch extension coverage
+        ext_decreased: Whether extension coverage decreased
+        ext_diff: Extension coverage difference
+        base_web_cov: Base branch webview coverage
+        pr_web_cov: PR branch webview coverage
+        web_decreased: Whether webview coverage decreased
+        web_diff: Webview coverage difference
+        
+    Returns:
+        Comment text
+    """
+    from datetime import datetime
+    
+    # Convert string inputs to appropriate types
+    try:
+        base_ext_cov = float(base_ext_cov)
+        pr_ext_cov = float(pr_ext_cov)
+        # Handle ext_decreased as either string or boolean
+        if isinstance(ext_decreased, str):
+            ext_decreased = ext_decreased.lower() == 'true'
+        else:
+            ext_decreased = bool(ext_decreased)
+        ext_diff = float(ext_diff)
+        base_web_cov = float(base_web_cov)
+        pr_web_cov = float(pr_web_cov)
+        # Handle web_decreased as either string or boolean
+        if isinstance(web_decreased, str):
+            web_decreased = web_decreased.lower() == 'true'
+        else:
+            web_decreased = bool(web_decreased)
+        web_diff = float(web_diff)
+    except ValueError as e:
+        log(f"Error converting input values: {e}")
+        return ""
+    
+    # Add a unique identifier to find this comment later
+    comment = '<!-- COVERAGE_REPORT -->\n'
+    comment += '## Coverage Report\n\n'
+
+    # Extension coverage
+    comment += '### Extension Coverage\n\n'
+    comment += f'Base branch: {base_ext_cov:.0f}%\n\n'
+    comment += f'PR branch: {pr_ext_cov:.0f}%\n\n'
+
+    if ext_decreased:
+        comment += f'⚠️ **Warning: Coverage decreased by {ext_diff:.2f}%**\n\n'
+        comment += 'Consider adding tests to cover your changes.\n\n'
+    else:
+        comment += '✅ Coverage increased or remained the same\n\n'
+
+    # Webview coverage
+    comment += '### Webview Coverage\n\n'
+    comment += f'Base branch: {base_web_cov:.0f}%\n\n'
+    comment += f'PR branch: {pr_web_cov:.0f}%\n\n'
+
+    if web_decreased:
+        comment += f'⚠️ **Warning: Coverage decreased by {web_diff:.2f}%**\n\n'
+        comment += 'Consider adding tests to cover your changes.\n\n'
+    else:
+        comment += '✅ Coverage increased or remained the same\n\n'
+
+    # Overall assessment
+    comment += '### Overall Assessment\n\n'
+    if ext_decreased or web_decreased:
+        comment += '⚠️ **Test coverage has decreased in this PR**\n\n'
+        comment += 'Please consider adding tests to maintain or improve coverage.\n\n'
+    else:
+        comment += '✅ **Test coverage has been maintained or improved**\n\n'
+
+    # Add timestamp
+    comment += f'\n\n<sub>Last updated: {datetime.now().isoformat()}</sub>'
+    
+    return comment
+
+def post_comment(comment_path, pr_number, repo, token=None):
+    """
+    Post a comment to a GitHub PR.
+    
+    Args:
+        comment_path: Path to the file containing the comment text
+        pr_number: PR number
+        repo: Repository in the format "owner/repo"
+        token: GitHub token
+    """
+    if not file_exists(comment_path):
+        log(f"Error: Comment file {comment_path} does not exist")
+        return
+    
+    with open(comment_path, 'r') as f:
+        comment_body = f.read()
+    
+    if not token:
+        token = os.environ.get('GITHUB_TOKEN')
+        if not token:
+            log("Error: GitHub token not provided")
+            return
+    
+    # Find existing comment
+    headers = {
+        'Authorization': f'token {token}',
+        'Accept': 'application/vnd.github.v3+json'
+    }
+    
+    # Get all comments
+    comments_url = f'https://api.github.com/repos/{repo}/issues/{pr_number}/comments'
+    log(f"Getting comments from: {comments_url}")
+    response = requests.get(comments_url, headers=headers)
+    
+    if response.status_code != 200:
+        log(f"Error getting comments: {response.status_code} - {response.text}")
+        return
+    
+    comments = response.json()
+    log(f"Found {len(comments)} existing comments")
+    
+    # Find comment with our identifier
+    comment_id = None
+    for comment in comments:
+        if '<!-- COVERAGE_REPORT -->' in comment['body']:
+            comment_id = comment['id']
+            log(f"Found existing coverage report comment with ID: {comment_id}")
+            break
+    
+    if comment_id:
+        # Update existing comment
+        update_url = f'https://api.github.com/repos/{repo}/issues/comments/{comment_id}'
+        log(f"Updating existing comment at: {update_url}")
+        response = requests.patch(update_url, headers=headers, json={'body': comment_body})
+        
+        if response.status_code == 200:
+            log(f"Successfully updated existing comment: {comment_id}")
+        else:
+            log(f"Error updating comment: {response.status_code} - {response.text}")
+    else:
+        # Create new comment
+        log(f"Creating new comment at: {comments_url}")
+        response = requests.post(comments_url, headers=headers, json={'body': comment_body})
+        
+        if response.status_code == 201:
+            log("Successfully created new comment")
+        else:
+            log(f"Error creating comment: {response.status_code} - {response.text}")
+
+def set_github_output(name, value):
+    """
+    Set GitHub Actions output variable.
+    
+    Args:
+        name: Output variable name
+        value: Output variable value
+    """
+    # Write to the GitHub output file if available
+    if 'GITHUB_OUTPUT' in os.environ:
+        with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
+            f.write(f"{name}={value}\n")
+    else:
+        # Fallback to the deprecated method for backward compatibility
+        log(f"::set-output name={name}::{value}")
+    
+    # Also print for human readability
+    log(f"{name}: {value}")
diff --git a/.github/scripts/coverage_check/util.py b/.github/scripts/coverage_check/util.py
new file mode 100644
index 0000000..b5f0b18
--- /dev/null
+++ b/.github/scripts/coverage_check/util.py
@@ -0,0 +1,245 @@
+"""
+Utility module.
+This module provides utility functions used across the coverage check scripts.
+"""
+
+import os
+import sys
+import re
+import shlex
+import subprocess
+import traceback
+from typing import List, Tuple, Dict, Any, Optional, Union
+
+# List of allowed commands and their arguments
+ALLOWED_COMMANDS = {
+    'xvfb-run': ['-a'],
+    'npm': ['run', 'test:coverage', 'ci', 'install', '--no-save', '@vitest/coverage-v8', 'check-types', 'lint', 'format', 'compile'],
+    'cd': ['webview-ui'],
+    'python': ['-m', 'coverage_check'],
+    'git': ['fetch', 'checkout', 'origin'],
+}
+
+def is_safe_command(command: Union[str, List[str]]) -> bool:
+    """
+    Check if a command is safe to execute.
+    
+    Args:
+        command: Command to check (string or list)
+        
+    Returns:
+        True if command is safe, False otherwise
+    """
+    # Convert string command to list
+    if isinstance(command, str):
+        try:
+            cmd_parts = shlex.split(command)
+        except ValueError:
+            return False
+    else:
+        cmd_parts = command
+
+    if not cmd_parts:
+        return False
+
+    # Get base command
+    base_cmd = os.path.basename(cmd_parts[0])
+    
+    # Check if command is in allowed list
+    if base_cmd not in ALLOWED_COMMANDS:
+        return False
+        
+    # For each argument, check for suspicious patterns
+    for arg in cmd_parts[1:]:
+        # Check for shell metacharacters
+        if re.search(r'[;&|`$]', arg):
+            return False
+        # Check for path traversal
+        if '..' in arg and not (base_cmd == 'npm' and arg.startswith('@')):
+            return False
+            
+    return True
+
+def log(message: str) -> None:
+    """
+    Write a message to stdout and flush.
+    
+    Args:
+        message: The message to write
+    """
+    sys.stdout.write(f"{message}\n")
+    sys.stdout.flush()
+
+def file_exists(file_path: str) -> bool:
+    """
+    Check if a file exists.
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        True if the file exists, False otherwise
+    """
+    return os.path.exists(file_path) and os.path.isfile(file_path)
+
+def get_file_size(file_path: str) -> int:
+    """
+    Get the size of a file in bytes.
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        Size of the file in bytes, or 0 if the file doesn't exist
+    """
+    if file_exists(file_path):
+        return os.path.getsize(file_path)
+    return 0
+
+def list_directory(dir_path: str) -> List[Tuple[str, Union[int, str]]]:
+    """
+    List the contents of a directory.
+    
+    Args:
+        dir_path: Path to the directory
+        
+    Returns:
+        List of (name, size) tuples for each file/directory in the directory
+    """
+    if not os.path.exists(dir_path) or not os.path.isdir(dir_path):
+        return []
+    
+    contents = []
+    for item in os.listdir(dir_path):
+        item_path = os.path.join(dir_path, item)
+        if os.path.isfile(item_path):
+            contents.append((item, os.path.getsize(item_path)))
+        else:
+            contents.append((item, "DIR"))
+    
+    return contents
+
+def read_file_content(file_path: str, default: str = "") -> str:
+    """
+    Read file content with error handling.
+    
+    Args:
+        file_path: Path to the file
+        default: Default value to return if file cannot be read
+        
+    Returns:
+        File content or default value
+    """
+    if not file_exists(file_path):
+        log(f"File does not exist: {file_path}")
+        return default
+    
+    try:
+        with open(file_path, 'r') as f:
+            return f.read()
+    except Exception as e:
+        log(f"Error reading file {file_path}: {e}")
+        return default
+
+def write_file_content(file_path: str, content: str) -> bool:
+    """
+    Write content to file with error handling.
+    
+    Args:
+        file_path: Path to the file
+        content: Content to write
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        with open(file_path, 'w') as f:
+            f.write(content)
+        return True
+    except Exception as e:
+        log(f"Error writing to file {file_path}: {e}")
+        return False
+
+def run_command(command: Union[str, List[str]], capture_output: bool = True) -> Tuple[int, str, str]:
+    """
+    Run a command and return the result.
+    
+    Args:
+        command: Command to run (string or list)
+        capture_output: Whether to capture stdout/stderr
+        
+    Returns:
+        Tuple of (returncode, stdout, stderr)
+    """
+    if not is_safe_command(command):
+        error_msg = f"Unsafe command detected: {command}"
+        log(error_msg)
+        return 1, "", error_msg
+        
+    log(f"Running command: {command}")
+    try:
+        # Convert string command to list
+        if isinstance(command, str):
+            cmd_list = shlex.split(command)
+        else:
+            cmd_list = command
+            
+        result = subprocess.run(
+            cmd_list,
+            shell=False,  # Never use shell=True for security
+            capture_output=capture_output,
+            text=True
+        )
+        log(f"Command exit code: {result.returncode}")
+        return result.returncode, result.stdout, result.stderr
+    except Exception as e:
+        log(f"Error running command: {e}")
+        log(traceback.format_exc())
+        return 1, "", str(e)
+
+def find_pattern(content: str, pattern: str, group: int = 0, 
+                default: Optional[str] = None) -> Optional[str]:
+    """
+    Find a pattern in content and return the specified group.
+    
+    Args:
+        content: Text content to search
+        pattern: Regex pattern to search for
+        group: Group number to return (default: 0 for entire match)
+        default: Default value to return if pattern not found
+        
+    Returns:
+        Matched text or default value
+    """
+    match = re.search(pattern, content, re.DOTALL)
+    if match:
+        return match.group(group)
+    return default
+
+def get_env_var(name: str, default: Optional[str] = None) -> Optional[str]:
+    """
+    Get environment variable with default value.
+    
+    Args:
+        name: Environment variable name
+        default: Default value if not set
+        
+    Returns:
+        Environment variable value or default
+    """
+    return os.environ.get(name, default)
+
+def format_exception(e: Exception) -> str:
+    """
+    Format an exception with traceback for logging.
+    
+    Args:
+        e: Exception to format
+        
+    Returns:
+        Formatted exception string
+    """
+    return f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
diff --git a/.github/scripts/coverage_check/workflow.py b/.github/scripts/coverage_check/workflow.py
new file mode 100644
index 0000000..8288143
--- /dev/null
+++ b/.github/scripts/coverage_check/workflow.py
@@ -0,0 +1,432 @@
+"""
+Workflow module.
+This module handles the main workflow logic for running coverage tests and processing results.
+"""
+
+import os
+import re
+import sys
+import subprocess
+import traceback
+
+from .extraction import run_coverage, compare_coverage, extract_coverage
+from .github_api import generate_comment, post_comment, set_github_output
+from .util import log, file_exists, get_file_size, list_directory, run_command
+
+def is_valid_branch_name(branch_name: str) -> bool:
+    """
+    Validate a git branch name.
+    
+    Args:
+        branch_name: Branch name to validate
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    # Check for common branch name patterns
+    if not re.match(r'^[a-zA-Z0-9_\-./]+$', branch_name):
+        return False
+    
+    # Check for path traversal
+    if '..' in branch_name:
+        return False
+        
+    # Check for shell metacharacters
+    if re.search(r'[;&|`$]', branch_name):
+        return False
+        
+    return True
+
+def checkout_branch(branch_name: str) -> None:
+    """
+    Checkout a branch for testing.
+    
+    Args:
+        branch_name: Branch name to checkout
+        
+    Raises:
+        RuntimeError: If branch checkout fails
+        ValueError: If branch name is invalid
+    """
+    if not is_valid_branch_name(branch_name):
+        raise ValueError(f"Invalid branch name: {branch_name}")
+        
+    log(f"=== Checking out branch: {branch_name} ===")
+    
+    # Fetch the branch
+    returncode, stdout, stderr = run_command(['git', 'fetch', 'origin', branch_name])
+    if returncode != 0:
+        log(f"ERROR: Failed to fetch branch {branch_name}")
+        log(f"Error details: {stderr}")
+        raise RuntimeError(f"Git fetch failed: {stderr}")
+    
+    # Checkout the branch
+    returncode, stdout, stderr = run_command(['git', 'checkout', branch_name])
+    if returncode != 0:
+        log(f"ERROR: Failed to checkout branch {branch_name}")
+        log(f"Error details: {stderr}")
+        raise RuntimeError(f"Git checkout failed: {stderr}")
+    
+    log(f"Successfully checked out branch: {branch_name}")
+
+def extract_extension_coverage_from_file(file_path):
+    """Extract extension coverage from file when run_coverage returns 0."""
+    if not file_exists(file_path):
+        log(f"File {file_path} does not exist, cannot extract extension coverage")
+        return 0.0
+    
+    file_size = get_file_size(file_path)
+    if file_size == 0:
+        log(f"File {file_path} is empty, cannot extract extension coverage")
+        return 0.0
+        
+    log(f"Extension coverage is 0.0, trying to read from file directly: {file_path} (size: {file_size} bytes)")
+    with open(file_path, 'r') as f:
+        content = f.read()
+        # Extract the percentage from the "Lines" row in the coverage summary
+        # Pattern: Lines : xx.xx% ( xxxxxxx/xxxxxxx )
+        lines_match = re.search(r'Lines\s*:\s*(\d+\.\d+)%', content)
+        if lines_match:
+            coverage = float(lines_match.group(1))
+            log(f"Found extension coverage in file: {coverage}%")
+            return coverage
+    return 0.0
+
+def extract_webview_coverage_from_file(file_path):
+    """Extract webview coverage from file when run_coverage returns 0."""
+    if not file_exists(file_path):
+        log(f"File {file_path} does not exist, cannot extract webview coverage")
+        return 0.0
+    
+    file_size = get_file_size(file_path)
+    if file_size == 0:
+        log(f"File {file_path} is empty, cannot extract webview coverage")
+        return 0.0
+        
+    log(f"Webview coverage is 0.0, trying to read from file directly: {file_path} (size: {file_size} bytes)")
+    with open(file_path, 'r') as f:
+        content = f.read()
+        # Extract the percentage from the "% Lines" column in the "All files" row
+        # Pattern: All files | xx.xx | xx.xx | xx.xx | xx.xx |
+        all_files_match = re.search(r'All files\s+\|\s+\d+\.\d+\s+\|\s+\d+\.\d+\s+\|\s+\d+\.\d+\s+\|\s+(\d+\.\d+)', content)
+        if all_files_match:
+            coverage = float(all_files_match.group(1))
+            log(f"Found webview coverage in file: {coverage}%")
+            return coverage
+    return 0.0
+
+def run_extension_coverage(branch_name=None):
+    """Run extension coverage tests and extract results."""
+    prefix = 'base_' if branch_name else ''
+    file_path = f"{prefix}extension_coverage.txt"
+    
+    # Run coverage tests
+    ext_cov = run_coverage(
+        ["xvfb-run", "-a", "npm", "run", "test:coverage"], 
+        file_path, 
+        "extension"
+    )
+    
+    # If coverage is 0.0, try to extract from file directly
+    if ext_cov == 0.0:
+        ext_cov = extract_extension_coverage_from_file(file_path)
+        
+    return ext_cov
+
+def run_webview_coverage(branch_name=None):
+    """Run webview coverage tests and extract results."""
+    prefix = 'base_' if branch_name else ''
+    file_path = f"{prefix}webview_coverage.txt"
+    
+    # Save current directory
+    original_dir = os.getcwd()
+    
+    try:
+        # Change to webview-ui directory
+        os.chdir('webview-ui')
+        
+        # Install coverage dependency
+        returncode, stdout, stderr = run_command(["npm", "install", "--no-save", "@vitest/coverage-v8"])
+        if returncode != 0:
+            log(f"Failed to install coverage dependency: {stderr}")
+            return 0.0
+        
+        # Run coverage tests from webview-ui directory
+        web_cov = run_coverage(
+            ["npm", "run", "test:coverage"],
+            os.path.join('..', file_path),
+            "webview"
+        )
+    finally:
+        # Always change back to original directory
+        os.chdir(original_dir)
+    
+    # If coverage is 0.0, try to extract from file directly
+    if web_cov == 0.0:
+        web_cov = extract_webview_coverage_from_file(file_path)
+        
+    return web_cov
+
+def run_branch_coverage(branch_name=None):
+    """
+    Run coverage tests for a branch.
+    
+    Args:
+        branch_name: Name of the branch to checkout before running tests (optional)
+        
+    Returns:
+        Tuple of (extension_coverage, webview_coverage)
+    """
+    # Checkout branch if specified
+    if branch_name:
+        checkout_branch(branch_name)
+    
+    # Run coverage tests
+    log(f"=== Running coverage tests{' for ' + branch_name if branch_name else ''} ===")
+    
+    # Run extension and webview coverage
+    ext_cov = run_extension_coverage(branch_name)
+    web_cov = run_webview_coverage(branch_name)
+    
+    return ext_cov, web_cov
+
+def find_potential_coverage_files():
+    """Find potential coverage files in the current directory and webview-ui."""
+    log("Searching for potential coverage files...")
+    
+    # Find files in current directory
+    current_dir_files = list_directory('.')
+    for name, size in current_dir_files:
+        if 'coverage' in name.lower() and size != "DIR":
+            log(f"Found potential coverage file: {name} (size: {size} bytes)")
+    
+    # Find files in webview-ui directory
+    if os.path.exists('webview-ui') and os.path.isdir('webview-ui'):
+        webview_files = list_directory('webview-ui')
+        for name, size in webview_files:
+            if 'coverage' in name.lower() and size != "DIR":
+                log(f"Found potential webview coverage file: webview-ui/{name} (size: {size} bytes)")
+    else:
+        log("webview-ui directory not found")
+
+def generate_warnings(base_ext_cov, pr_ext_cov, ext_decreased, ext_diff, 
+                     base_web_cov, pr_web_cov, web_decreased, web_diff):
+    """Generate warnings for coverage decreases."""
+    if not (ext_decreased or web_decreased):
+        return []
+        
+    warnings = [
+        "Test coverage has decreased in this PR",
+        f"Extension coverage: {base_ext_cov}% -> {pr_ext_cov}% (Diff: {ext_diff}%)",
+        f"Webview coverage: {base_web_cov}% -> {pr_web_cov}% (Diff: {web_diff}%)"
+    ]
+    
+    # Additional warning for significant decrease (more than 1%)
+    if ext_decreased and ext_diff > 1.0:
+        warnings.append(f"Extension coverage decreased by more than 1% ({ext_diff}%). Consider adding tests to cover your changes.")
+    
+    if web_decreased and web_diff > 1.0:
+        warnings.append(f"Webview coverage decreased by more than 1% ({web_diff}%). Consider adding tests to cover your changes.")
+        
+    return warnings
+
+def output_warnings(warnings):
+    """Output warnings to GitHub step summary and console."""
+    if not warnings:
+        return
+        
+    # Get the GitHub step summary file path from environment variable
+    github_step_summary = os.environ.get('GITHUB_STEP_SUMMARY')
+    
+    # Write to GitHub step summary if available
+    if github_step_summary:
+        with open(github_step_summary, 'a') as f:
+            f.write("## Coverage Warnings\n\n")
+            for warning in warnings:
+                f.write(f"⚠️ {warning}\n\n")
+    
+    # Also output to console with ::warning:: syntax for backward compatibility
+    for warning in warnings:
+        log(f"::warning::{warning}")
+
+def output_github_results(pr_ext_cov, pr_web_cov, base_ext_cov, base_web_cov, 
+                         ext_decreased, ext_diff, web_decreased, web_diff):
+    """Output results for GitHub Actions."""
+    set_github_output("pr_extension_coverage", pr_ext_cov)
+    set_github_output("pr_webview_coverage", pr_web_cov)
+    set_github_output("base_extension_coverage", base_ext_cov)
+    set_github_output("base_webview_coverage", base_web_cov)
+    set_github_output("extension_decreased", str(ext_decreased).lower())
+    set_github_output("extension_diff", ext_diff)
+    set_github_output("webview_decreased", str(web_decreased).lower())
+    set_github_output("webview_diff", web_diff)
+
+def extract_pr_coverage_from_artifacts():
+    """
+    Extract PR branch coverage from artifact files.
+    
+    Returns:
+        Tuple of (extension_coverage, webview_coverage)
+        
+    Raises:
+        SystemExit: If the coverage files don't exist
+    """
+    log("=== Extracting PR branch coverage from artifacts ===")
+    
+    # Check if the coverage files exist
+    ext_file_path = "extension_coverage.txt"
+    web_file_path = "webview-ui/webview_coverage.txt"
+    
+    # Extract extension coverage
+    log(f"Extracting extension coverage from {ext_file_path}")
+    if not file_exists(ext_file_path):
+        error_msg = f"ERROR: PR extension coverage file {ext_file_path} not found"
+        log(error_msg)
+        
+        # List directory contents for debugging
+        log("Current directory contents:")
+        try:
+            dir_contents = list_directory('.')
+            for name, size in dir_contents:
+                log(f"  {name} - {size}\n")
+        except Exception as e:
+            log(f"Error listing directory: {e}")
+        
+        sys.exit(1)  # Exit with error code to fail the workflow
+    
+    ext_cov = extract_extension_coverage_from_file(ext_file_path)
+    log(f"PR extension coverage from artifact: {ext_cov}%")
+    
+    # Extract webview coverage
+    log(f"Extracting webview coverage from {web_file_path}")
+    if not file_exists(web_file_path):
+        error_msg = f"ERROR: PR webview coverage file {web_file_path} not found"
+        log(error_msg)
+        
+        # Check if the webview-ui directory exists
+        if not os.path.exists('webview-ui'):
+            log("ERROR: webview-ui directory not found")
+        else:
+            # List webview-ui directory contents for debugging
+            log("webview-ui directory contents:")
+            try:
+                dir_contents = list_directory('webview-ui')
+                for name, size in dir_contents:
+                    log(f"  {name} - {size}")
+            except Exception as e:
+                log(f"Error listing directory: {e}")
+        
+        sys.exit(1)  # Exit with error code to fail the workflow
+    
+    web_cov = extract_webview_coverage_from_file(web_file_path)
+    log(f"PR webview coverage from artifact: {web_cov}%")
+    
+    return ext_cov, web_cov
+
+def process_coverage_workflow(args):
+    """
+    Process the entire coverage workflow.
+    
+    Args:
+        args: Command line arguments
+    """
+    # Initialize all variables at the start
+    pr_ext_cov = 0.0
+    pr_web_cov = 0.0
+    base_ext_cov = 0.0
+    base_web_cov = 0.0
+    ext_decreased = False
+    ext_diff = 0.0
+    web_decreased = False
+    web_diff = 0.0
+    
+    try:
+        # Validate branch name
+        if not is_valid_branch_name(args.base_branch):
+            raise ValueError(f"Invalid base branch name: {args.base_branch}")
+        
+        # Check if we're running in GitHub Actions
+        is_github_actions = 'GITHUB_ACTIONS' in os.environ
+        if is_github_actions:
+            log("Running in GitHub Actions environment")
+        
+        # Extract PR branch coverage from artifacts (from test job)
+        pr_ext_cov, pr_web_cov = extract_pr_coverage_from_artifacts()
+        
+        # Verify PR coverage values
+        if pr_ext_cov == 0.0:
+            log("WARNING: PR extension coverage is 0.0, this may indicate an issue with the coverage report")
+            find_potential_coverage_files()
+        
+        if pr_web_cov == 0.0:
+            log("WARNING: PR webview coverage is 0.0, this may indicate an issue with the coverage report")
+            find_potential_coverage_files()
+        
+        # Run base branch coverage
+        log(f"=== Running base branch coverage for {args.base_branch} ===")
+        base_ext_cov, base_web_cov = run_branch_coverage(args.base_branch)
+        
+        # Verify base coverage values
+        if base_ext_cov == 0.0:
+            log("WARNING: Base extension coverage is 0.0, this may indicate an issue with the coverage report")
+        
+        if base_web_cov == 0.0:
+            log("WARNING: Base webview coverage is 0.0, this may indicate an issue with the coverage report")
+        
+        # Compare coverage
+        log("=== Comparing extension coverage ===")
+        ext_decreased, ext_diff = compare_coverage(base_ext_cov, pr_ext_cov)
+        
+        log("=== Comparing webview coverage ===")
+        web_decreased, web_diff = compare_coverage(base_web_cov, pr_web_cov)
+        
+        # Print summary of coverage values
+        log("\n=== Coverage Summary ===")
+        log(f"PR extension coverage: {pr_ext_cov}%")
+        log(f"Base extension coverage: {base_ext_cov}%")
+        log(f"Extension coverage change: {'+' if not ext_decreased else '-'}{ext_diff}%")
+        log(f"PR webview coverage: {pr_web_cov}%")
+        log(f"Base webview coverage: {base_web_cov}%")
+        log(f"Webview coverage change: {'+' if not web_decreased else '-'}{web_diff}%")
+        
+        # Generate and output warnings
+        warnings = generate_warnings(
+            base_ext_cov, pr_ext_cov, ext_decreased, ext_diff,
+            base_web_cov, pr_web_cov, web_decreased, web_diff
+        )
+        output_warnings(warnings)
+        
+        # Generate comment
+        log("=== Generating comment ===")
+        comment = generate_comment(
+            base_ext_cov, pr_ext_cov, str(ext_decreased).lower(), ext_diff,
+            base_web_cov, pr_web_cov, str(web_decreased).lower(), web_diff
+        )
+        
+        # Save comment to file
+        with open("coverage_comment.md", "w") as f:
+            f.write(comment)
+        
+        # Post comment if PR number is provided
+        if args.pr_number:
+            log(f"=== Posting comment to PR #{args.pr_number} ===")
+            post_comment("coverage_comment.md", args.pr_number, args.repo, args.token)
+        
+        # Output results for GitHub Actions
+        output_github_results(
+            pr_ext_cov, pr_web_cov, base_ext_cov, base_web_cov,
+            ext_decreased, ext_diff, web_decreased, web_diff
+        )
+        
+    except Exception as e:
+        log(f"ERROR in process_coverage_workflow: {e}")
+        traceback.print_exc()
+        
+        # Try to output results even if there was an error
+        try:
+            output_github_results(
+                pr_ext_cov, pr_web_cov, base_ext_cov, base_web_cov,
+                ext_decreased, ext_diff, web_decreased, web_diff
+            )
+        except Exception as e2:
+            log(f"ERROR outputting GitHub results: {e2}")
diff --git a/.github/scripts/tests/coverage_check_test.py b/.github/scripts/tests/coverage_check_test.py
new file mode 100644
index 0000000..9325fad
--- /dev/null
+++ b/.github/scripts/tests/coverage_check_test.py
@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""
+Tests for coverage_check script.
+"""
+
+import os
+import sys
+import unittest
+import subprocess
+import tempfile
+from unittest.mock import patch, MagicMock, call, mock_open
+
+# Add parent directory to path so we can import coverage modules
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from coverage_check import extract_coverage, compare_coverage, set_verbose, generate_comment, post_comment, set_github_output
+from coverage_check.util import log, file_exists, get_file_size, list_directory
+
+
+class TestCoverage(unittest.TestCase):
+    # Class variables to store coverage files
+    temp_dir = None
+    extension_coverage_file = None
+    webview_coverage_file = None
+    
+    @classmethod
+    def setUpClass(cls):
+        """Set up test environment once for all tests."""
+        # Create temporary directory for test files
+        cls.temp_dir = tempfile.TemporaryDirectory()
+        cls.extension_coverage_file = os.path.join(cls.temp_dir.name, 'extension_coverage.txt')
+        cls.webview_coverage_file = os.path.join(cls.temp_dir.name, 'webview_coverage.txt')
+        
+        # Run actual tests to generate coverage reports
+        cls.generate_coverage_reports()
+        
+        # Verify files exist and are not empty
+        assert os.path.exists(cls.extension_coverage_file), \
+            f"Extension coverage file {cls.extension_coverage_file} does not exist"
+        assert os.path.getsize(cls.extension_coverage_file) > 0, \
+            f"Extension coverage file {cls.extension_coverage_file} is empty"
+        assert os.path.exists(cls.webview_coverage_file), \
+            f"Webview coverage file {cls.webview_coverage_file} does not exist"
+        assert os.path.getsize(cls.webview_coverage_file) > 0, \
+            f"Webview coverage file {cls.webview_coverage_file} is empty"
+
+    @classmethod
+    def tearDownClass(cls):
+        """Clean up test environment after all tests."""
+        if cls.temp_dir:
+            cls.temp_dir.cleanup()
+
+    @classmethod
+    def generate_coverage_reports(cls):
+        """Generate real coverage reports by running tests."""
+        log("Generating coverage reports (this may take a while)...")
+        
+        # Run extension tests with coverage
+        try:
+            # Get absolute paths
+            root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..'))
+            webview_dir = os.path.join(root_dir, 'webview-ui')
+            
+            # Use xvfb-run on Linux
+            if sys.platform.startswith('linux'):
+                cmd = f"cd {root_dir} && xvfb-run -a npm run test:coverage > {cls.extension_coverage_file} 2>&1"
+            else:
+                cmd = f"cd {root_dir} && npm run test:coverage > {cls.extension_coverage_file} 2>&1"
+            
+            log("Running extension tests...")
+            log(f"Command: {cmd}")
+            result = subprocess.run(cmd, shell=True, check=False, capture_output=True, text=True)
+            log(f"Extension tests exit code: {result.returncode}")
+            
+            # Run webview tests with coverage
+            log("Running webview tests...")
+            cmd = f"cd {webview_dir} && npm run test:coverage > {cls.webview_coverage_file} 2>&1"
+            log(f"Command: {cmd}")
+            result = subprocess.run(cmd, shell=True, check=False, capture_output=True, text=True)
+            log(f"Webview tests exit code: {result.returncode}")
+            
+            # Verify files were created
+            if file_exists(cls.extension_coverage_file):
+                ext_size = get_file_size(cls.extension_coverage_file)
+                log(f"Extension coverage file created: {cls.extension_coverage_file} (size: {ext_size} bytes)")
+            else:
+                log(f"WARNING: Extension coverage file was not created: {cls.extension_coverage_file}")
+                
+            if file_exists(cls.webview_coverage_file):
+                web_size = get_file_size(cls.webview_coverage_file)
+                log(f"Webview coverage file created: {cls.webview_coverage_file} (size: {web_size} bytes)")
+            else:
+                log(f"WARNING: Webview coverage file was not created: {cls.webview_coverage_file}")
+            
+            log("Coverage reports generation completed.")
+        except Exception as e:
+            log(f"Error generating coverage reports: {e}")
+            import traceback
+            log(traceback.format_exc())
+            
+            # Create empty files if tests fail
+            log("Creating fallback coverage files...")
+            with open(cls.extension_coverage_file, 'w') as f:
+                f.write("No coverage data available")
+            with open(cls.webview_coverage_file, 'w') as f:
+                f.write("No coverage data available")
+
+    def test_extract_coverage(self):
+        """Test extract_coverage function with both extension and webview coverage."""
+        # Check if verbose mode is enabled
+        if '-v' in sys.argv or '--verbose' in sys.argv:
+            set_verbose(True)
+        
+        # Verify files exist before testing
+        self.assertTrue(file_exists(self.extension_coverage_file), 
+                       f"Extension coverage file does not exist: {self.extension_coverage_file}")
+        self.assertTrue(file_exists(self.webview_coverage_file), 
+                       f"Webview coverage file does not exist: {self.webview_coverage_file}")
+        
+        # Log file sizes
+        ext_size = get_file_size(self.extension_coverage_file)
+        web_size = get_file_size(self.webview_coverage_file)
+        log(f"Extension coverage file size: {ext_size} bytes")
+        log(f"Webview coverage file size: {web_size} bytes")
+        
+        # Test extension coverage
+        log("Testing extension coverage extraction...")
+        ext_coverage_pct = extract_coverage(self.extension_coverage_file, 'extension')
+        
+        # Check that coverage percentage is a float
+        self.assertIsInstance(ext_coverage_pct, float)
+        
+        # Check that coverage percentage is between 0 and 100
+        self.assertGreaterEqual(ext_coverage_pct, 0)
+        self.assertLessEqual(ext_coverage_pct, 100)
+        
+        # Log coverage percentage for debugging
+        log(f"Extension coverage: {ext_coverage_pct}%")
+        
+        # Test webview coverage
+        log("Testing webview coverage extraction...")
+        web_coverage_pct = extract_coverage(self.webview_coverage_file, 'webview')
+        
+        # Convert to float if it's an integer
+        if isinstance(web_coverage_pct, int):
+            web_coverage_pct = float(web_coverage_pct)
+        
+        # Check that coverage percentage is a float
+        self.assertIsInstance(web_coverage_pct, float)
+        
+        # Check that coverage percentage is between 0 and 100
+        self.assertGreaterEqual(web_coverage_pct, 0)
+        self.assertLessEqual(web_coverage_pct, 100)
+        
+        # Log coverage percentage for debugging
+        log(f"Webview coverage: {web_coverage_pct}%")
+
+    def test_compare_coverage(self):
+        """Test compare_coverage function."""
+        # Test with coverage increase
+        decreased, diff = compare_coverage(80, 90)
+        self.assertFalse(decreased)
+        self.assertEqual(diff, 10)
+        
+        # Test with coverage decrease
+        decreased, diff = compare_coverage(90, 80)
+        self.assertTrue(decreased)
+        self.assertEqual(diff, 10)
+        
+        # Test with no change
+        decreased, diff = compare_coverage(80, 80)
+        self.assertFalse(decreased)
+        self.assertEqual(diff, 0)
+
+    def test_generate_comment(self):
+        """Test generate_comment function."""
+        comment = generate_comment(
+            80, 90, 'false', 10,
+            70, 75, 'false', 5
+        )
+        
+        # Check that comment contains expected sections
+        self.assertIn('Coverage Report', comment)
+        self.assertIn('Extension Coverage', comment)
+        self.assertIn('Webview Coverage', comment)
+        self.assertIn('Overall Assessment', comment)
+        
+        # Check that comment contains coverage percentages
+        self.assertIn('Base branch: 80%', comment)
+        self.assertIn('PR branch: 90%', comment)
+        self.assertIn('Base branch: 70%', comment)
+        self.assertIn('PR branch: 75%', comment)
+        
+        # Check that comment contains correct assessment
+        self.assertIn('Coverage increased or remained the same', comment)
+        self.assertIn('Test coverage has been maintained or improved', comment)
+
+    @patch('coverage_check.requests.get')
+    @patch('coverage_check.requests.post')
+    @patch('coverage_check.requests.patch')
+    def test_post_comment_new(self, mock_patch, mock_post, mock_get):
+        """Test post_comment function when creating a new comment."""
+        # Create a temporary comment file
+        comment_file = os.path.join(self.temp_dir.name, 'comment.md')
+        with open(comment_file, 'w') as f:
+            f.write('<!-- COVERAGE_REPORT -->\nTest comment')
+        
+        # Mock the API responses
+        mock_get.return_value = MagicMock(status_code=200, json=lambda: [])
+        mock_post.return_value = MagicMock(status_code=201)
+        
+        # Test post_comment function
+        post_comment(comment_file, '123', 'owner/repo', 'token')
+        
+        # Check that the correct API calls were made
+        mock_get.assert_called_once()
+        mock_post.assert_called_once()
+        mock_patch.assert_not_called()
+
+    @patch('coverage_check.requests.get')
+    @patch('coverage_check.requests.post')
+    @patch('coverage_check.requests.patch')
+    def test_post_comment_update(self, mock_patch, mock_post, mock_get):
+        """Test post_comment function when updating an existing comment."""
+        # Create a temporary comment file
+        comment_file = os.path.join(self.temp_dir.name, 'comment.md')
+        with open(comment_file, 'w') as f:
+            f.write('<!-- COVERAGE_REPORT -->\nTest comment')
+        
+        # Mock the API responses
+        mock_get.return_value = MagicMock(
+            status_code=200, 
+            json=lambda: [{'id': 456, 'body': '<!-- COVERAGE_REPORT -->\nOld comment'}]
+        )
+        mock_patch.return_value = MagicMock(status_code=200)
+        
+        # Test post_comment function
+        post_comment(comment_file, '123', 'owner/repo', 'token')
+        
+        # Check that the correct API calls were made
+        mock_get.assert_called_once()
+        mock_patch.assert_called_once()
+        mock_post.assert_not_called()
+
+    def test_set_github_output(self):
+        """Test set_github_output function."""
+        # Capture stdout
+        with patch('sys.stdout', new=MagicMock()) as mock_stdout:
+            # Mock environment without GITHUB_OUTPUT
+            with patch.dict('os.environ', {}, clear=True):
+                set_github_output('test_name', 'test_value')
+                
+                # Check that the correct output was printed to stdout
+                mock_stdout.assert_has_calls([
+                    # GitHub Actions output format (deprecated method)
+                    call.write('::set-output name=test_name::test_value\n'),
+                    call.flush(),
+                    # Human readable format
+                    call.write('test_name: test_value\n'),
+                    call.flush()
+                ], any_order=False)
+                
+                # Reset mock for next test
+                mock_stdout.reset_mock()
+            
+            # Test with GITHUB_OUTPUT environment variable
+            with patch.dict('os.environ', {'GITHUB_OUTPUT': '/tmp/github_output'}), \
+                 patch('builtins.open', mock_open()) as mock_file:
+                set_github_output('test_name', 'test_value')
+                
+                # Check that file was written to
+                mock_file.assert_called_once_with('/tmp/github_output', 'a')
+                mock_file().write.assert_called_once_with('test_name=test_value\n')
+                
+                # Check that human readable output was printed
+                mock_stdout.assert_has_calls([
+                    call.write('test_name: test_value\n'),
+                    call.flush()
+                ], any_order=False)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/.github/workflows/cli-publish.yml b/.github/workflows/cli-publish.yml
new file mode 100644
index 0000000..024910d
--- /dev/null
+++ b/.github/workflows/cli-publish.yml
@@ -0,0 +1,435 @@
+name: cli-publish
+
+on:
+  schedule:
+    - cron: "0 12 * * *"
+  workflow_dispatch:
+    inputs:
+      publish_target:
+        description: "Which publish flow to run"
+        required: true
+        default: "main"
+        type: choice
+        options:
+          - main
+          - nightly
+      git_tag:
+        description: "Existing release tag to publish when publish_target=main, for example cli-v0.1.0"
+        required: false
+        type: string
+      confirm_publish:
+        description: 'Required when publish_target=main. Type "publish" to confirm release publish.'
+        required: false
+        type: string
+      force_nightly_publish:
+        description: "Force nightly publish even with no commits in last 24h"
+        required: false
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+  id-token: write
+
+defaults:
+  run:
+    working-directory: .
+
+jobs:
+  publish-main:
+    name: Publish cline
+    permissions:
+      contents: write
+      id-token: write
+    if: |
+      github.repository == 'cline/cline' &&
+      github.ref == 'refs/heads/main' &&
+      github.event_name == 'workflow_dispatch' &&
+      github.event.inputs.publish_target == 'main' &&
+      github.event.inputs.confirm_publish == 'publish' &&
+      !endsWith(github.actor, '[bot]')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.git_tag }}
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24.x"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Verify publish tooling
+        run: |
+          NPM_VERSION=$(npm --version)
+          echo "npm ${NPM_VERSION}"
+          IFS=. read -r major minor patch <<EOF
+          ${NPM_VERSION}
+          EOF
+          if [ "$major" -lt 11 ] || { [ "$major" -eq 11 ] && [ "$minor" -lt 5 ]; } || { [ "$major" -eq 11 ] && [ "$minor" -eq 5 ] && [ "$patch" -lt 1 ]; }; then
+            echo "npm 11.5.1 or newer is required for trusted publishing"
+            exit 1
+          fi
+
+      - name: Install dependencies
+        run: bun install
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Validate release tag
+        id: version
+        env:
+          TAG: ${{ github.event.inputs.git_tag }}
+        run: |
+          if [ -z "$TAG" ]; then
+            echo "git_tag is required when publish_target=main"
+            exit 1
+          fi
+
+          if ! printf "%s\n" "$TAG" | grep -Eq '^cli-v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$'; then
+            echo "git_tag must look like cli-vX.Y.Z, got: ${TAG}"
+            exit 1
+          fi
+
+          VERSION="${TAG#cli-v}"
+          PACKAGE_VERSION=$(node -p "require('./apps/cli/package.json').version")
+
+          if [ "$PACKAGE_VERSION" != "$VERSION" ]; then
+            echo "apps/cli/package.json version ${PACKAGE_VERSION} does not match ${TAG}"
+            exit 1
+          fi
+
+          if ! printf "%s\n" "$VERSION" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$'; then
+            echo "apps/cli/package.json has invalid version: ${VERSION}"
+            exit 1
+          fi
+
+          TAG_COMMIT=$(git rev-parse "${TAG}^{commit}")
+          HEAD_COMMIT=$(git rev-parse HEAD)
+          if [ "$TAG_COMMIT" != "$HEAD_COMMIT" ]; then
+            echo "${TAG} does not point at the checked out commit"
+            exit 1
+          fi
+
+          git fetch origin +main:refs/remotes/origin/main
+          if ! git merge-base --is-ancestor "$HEAD_COMMIT" origin/main; then
+            echo "${TAG} is not reachable from origin/main"
+            exit 1
+          fi
+
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+
+      - name: Build SDK packages
+        run: bun run build:sdk
+        env:
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+
+      - name: Run tests
+        run: bun run test
+
+      - name: Build platform binaries
+        run: bun script/build.ts --install-native-variants --skip-sdk-build
+        working-directory: apps/cli
+        env:
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+
+      - name: Verify build output
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          EXPECTED=(
+            "@cline/cli-darwin-arm64"
+            "@cline/cli-darwin-x64"
+            "@cline/cli-linux-arm64"
+            "@cline/cli-linux-x64"
+            "@cline/cli-windows-arm64"
+            "@cline/cli-windows-x64"
+          )
+
+          for package_name in "${EXPECTED[@]}"; do
+            dir="apps/cli/dist/${package_name#@cline/}"
+            if [ ! -f "$dir/package.json" ]; then
+              echo "Missing package manifest: $dir/package.json"
+              exit 1
+            fi
+            actual_name=$(node -p "require('./$dir/package.json').name")
+            actual_version=$(node -p "require('./$dir/package.json').version")
+            if [ "$actual_name" != "$package_name" ]; then
+              echo "Expected $package_name, got $actual_name"
+              exit 1
+            fi
+            if [ "$actual_version" != "$VERSION" ]; then
+              echo "Expected $package_name@$VERSION, got $actual_version"
+              exit 1
+            fi
+            ls -lh "$dir/bin/"
+          done
+
+      - name: Publish to NPM with latest tag
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+        run: bun script/publish-npm.ts --tag latest
+        working-directory: apps/cli
+
+      - name: Get Previous CLI Tag
+        id: prev_tag
+        env:
+          CURRENT_TAG: ${{ steps.version.outputs.tag }}
+        run: |
+          PREV_TAG=$(git describe --tags --abbrev=0 --match 'cli-v*' "$CURRENT_TAG^" 2>/dev/null || echo "")
+          echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
+
+      - name: Get Changelog Entry
+        id: changelog
+        run: |
+          # Grab content between the first "## " header and the next one in apps/cli/CHANGELOG.md
+          CONTENT=$(awk '/^## [0-9]/{if(found) exit; found=1; next} found{print}' apps/cli/CHANGELOG.md)
+          echo "content<<EOF" >> $GITHUB_OUTPUT
+          echo "$CONTENT" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ steps.version.outputs.tag }}
+          name: "CLI v${{ steps.version.outputs.version }}"
+          body: |
+            ${{ steps.changelog.outputs.content }}
+
+            ${{ steps.prev_tag.outputs.prev_tag != '' && format('**Full Changelog**: https://github.com/{0}/compare/{1}...{2}', github.repository, steps.prev_tag.outputs.prev_tag, steps.version.outputs.tag) || '' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Summary
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Published cline@${VERSION} to npm with dist-tag 'latest'"
+          echo "Install with: npm install -g cline"
+
+      - name: Post release to Slack
+        uses: slackapi/slack-github-action@v3.0.1
+        with:
+          method: chat.postMessage
+          token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
+          payload: |
+            channel: "C0APVKGGZFC"
+            text: "Cline CLI v${{ steps.version.outputs.version }}"
+            blocks:
+              - type: "section"
+                text:
+                  type: "mrkdwn"
+                  text: "Cline CLI v${{ steps.version.outputs.version }}"
+              - type: "section"
+                text:
+                  type: "mrkdwn"
+                  text: ${{ toJSON(steps.changelog.outputs.content) }}
+              - type: "context"
+                elements:
+                  - type: "mrkdwn"
+                    text: "<https://www.npmjs.com/package/cline/v/${{ steps.version.outputs.version }}|View on npm>${{ steps.prev_tag.outputs.prev_tag != '' && format(' | Full Changelog: https://github.com/{0}/compare/{1}...{2}', github.repository, steps.prev_tag.outputs.prev_tag, steps.version.outputs.tag) || '' }}"
+
+  publish-nightly:
+    name: Publish cline nightly
+    permissions:
+      contents: read
+      id-token: write
+    if: |
+      github.repository == 'cline/cline' &&
+      github.ref == 'refs/heads/main' &&
+      (
+        github.event_name == 'schedule' ||
+        (
+          github.event_name == 'workflow_dispatch' &&
+          github.event.inputs.publish_target == 'nightly'
+        )
+      )
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for recent commits
+        id: check_commits
+        env:
+          FORCE_PUBLISH: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.force_nightly_publish == 'true' }}
+        run: |
+          if [ "$FORCE_PUBLISH" = "true" ]; then
+            echo "force_nightly_publish enabled, proceeding with publish"
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          if [ "$(git rev-list --count HEAD --since='24 hours ago')" -eq 0 ]; then
+            echo "No commits in last 24 hours, skipping publish"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "Found recent commits, proceeding with publish"
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Setup Bun
+        if: steps.check_commits.outputs.skip != 'true'
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Setup Node.js
+        if: steps.check_commits.outputs.skip != 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24.x"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Verify publish tooling
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          NPM_VERSION=$(npm --version)
+          echo "npm ${NPM_VERSION}"
+          IFS=. read -r major minor patch <<EOF
+          ${NPM_VERSION}
+          EOF
+          if [ "$major" -lt 11 ] || { [ "$major" -eq 11 ] && [ "$minor" -lt 5 ]; } || { [ "$major" -eq 11 ] && [ "$minor" -eq 5 ] && [ "$patch" -lt 1 ]; }; then
+            echo "npm 11.5.1 or newer is required for trusted publishing"
+            exit 1
+          fi
+
+      - name: Install dependencies
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun install
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build SDK packages
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun run build:sdk
+        env:
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+
+      - name: Run tests
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun run test
+
+      - name: Generate nightly version
+        if: steps.check_commits.outputs.skip != 'true'
+        id: version
+        run: |
+          BASE_VERSION=$(node -p "require('./apps/cli/package.json').version")
+          TIMESTAMP=$(date +%s)
+          VERSION="${BASE_VERSION}-nightly.${TIMESTAMP}"
+
+          echo "Base version: ${BASE_VERSION}"
+          echo "Generated nightly version: ${VERSION}"
+          echo "base_version=${BASE_VERSION}" >> "$GITHUB_OUTPUT"
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+
+      - name: Update nightly package version
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          node -e '
+            const fs = require("node:fs");
+            const path = "apps/cli/package.json";
+            const pkg = JSON.parse(fs.readFileSync(path, "utf8"));
+            pkg.version = process.env.VERSION;
+            fs.writeFileSync(path, `${JSON.stringify(pkg, null, "\t")}\n`);
+          '
+          cat apps/cli/package.json | grep '"version"'
+
+      - name: Build platform binaries
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun script/build.ts --install-native-variants --skip-sdk-build
+        working-directory: apps/cli
+        env:
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+
+      - name: Verify build output
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          EXPECTED=(
+            "@cline/cli-darwin-arm64"
+            "@cline/cli-darwin-x64"
+            "@cline/cli-linux-arm64"
+            "@cline/cli-linux-x64"
+            "@cline/cli-windows-arm64"
+            "@cline/cli-windows-x64"
+          )
+
+          for package_name in "${EXPECTED[@]}"; do
+            dir="apps/cli/dist/${package_name#@cline/}"
+            if [ ! -f "$dir/package.json" ]; then
+              echo "Missing package manifest: $dir/package.json"
+              exit 1
+            fi
+            actual_name=$(node -p "require('./$dir/package.json').name")
+            actual_version=$(node -p "require('./$dir/package.json').version")
+            if [ "$actual_name" != "$package_name" ]; then
+              echo "Expected $package_name, got $actual_name"
+              exit 1
+            fi
+            if [ "$actual_version" != "$VERSION" ]; then
+              echo "Expected $package_name@$VERSION, got $actual_version"
+              exit 1
+            fi
+            ls -lh "$dir/bin/"
+          done
+
+      - name: Publish to NPM with nightly tag
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+        run: bun script/publish-npm.ts --tag nightly
+        working-directory: apps/cli
+
+      - name: Summary
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Published cline@${VERSION} to npm with dist-tag 'nightly'"
+          echo "Install with: npm install -g cline@nightly"
diff --git a/.github/workflows/ext-jb-test-integration.yml b/.github/workflows/ext-jb-test-integration.yml
new file mode 100644
index 0000000..3cadd5f
--- /dev/null
+++ b/.github/workflows/ext-jb-test-integration.yml
@@ -0,0 +1,100 @@
+name: ext-jb-test-integration
+on:
+  pull_request_target:
+    types: [opened, reopened]
+  issue_comment:
+    types: [created]
+permissions:
+  contents: read
+  pull-requests: read
+concurrency:
+  group: jetbrains-trigger-${{ github.event.pull_request.number || github.event.issue.number }}
+  cancel-in-progress: true
+
+jobs:
+  trigger-integration-test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    # Auto-run only for trusted PR authors. Anyone else needs a maintainer
+    # to opt their PR in by commenting /test-jetbrains.
+    if: |
+      (github.event_name == 'pull_request_target' &&
+       contains(fromJSON('["MEMBER","OWNER","COLLABORATOR"]'), github.event.pull_request.author_association)) ||
+      (github.event_name == 'issue_comment' &&
+       github.event.issue.pull_request &&
+       contains(github.event.comment.body, '/test-jetbrains') &&
+       contains(fromJSON('["MEMBER","OWNER","COLLABORATOR"]'), github.event.comment.author_association))
+    steps:
+      - name: Generate GitHub App Token
+        id: app-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ vars.CLINE_JETBRAINS_APP_ID }}
+          private-key: ${{ secrets.CLINE_JETBRAINS_APP_KEY }}
+          owner: cline
+          repositories: intellij-plugin
+
+      - name: Get PR details (for issue_comment trigger)
+        id: pr-details
+        if: github.event_name == 'issue_comment'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          PR_DATA=$(gh api repos/${{ github.repository }}/pulls/${{ github.event.issue.number }})
+          echo "head_ref=$(echo "$PR_DATA" | jq -r '.head.ref')" >> $GITHUB_OUTPUT
+          echo "head_sha=$(echo "$PR_DATA" | jq -r '.head.sha')" >> $GITHUB_OUTPUT
+          echo "title=$(echo "$PR_DATA" | jq -r '.title')" >> $GITHUB_OUTPUT
+          echo "html_url=$(echo "$PR_DATA" | jq -r '.html_url')" >> $GITHUB_OUTPUT
+
+      - name: Sanitize untrusted inputs
+        id: sanitize
+        env:
+          RAW_BRANCH_NAME: ${{ github.event_name == 'pull_request_target' && github.head_ref || steps.pr-details.outputs.head_ref }}
+          RAW_PR_TITLE: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.title || steps.pr-details.outputs.title }}
+        run: |
+          # Sanitize branch name for JSON
+          BRANCH_NAME_JSON=$(jq -n --arg b "$RAW_BRANCH_NAME" '$b')
+          echo "branch_name=$BRANCH_NAME_JSON" >> $GITHUB_OUTPUT
+
+          # Sanitize PR title for JSON
+          PR_TITLE_JSON=$(jq -n --arg t "$RAW_PR_TITLE" '$t')
+          echo "pr_title=$PR_TITLE_JSON" >> $GITHUB_OUTPUT
+
+      - name: Trigger IntelliJ Plugin Integration Test
+        env:
+          BRANCH_NAME: ${{ steps.sanitize.outputs.branch_name }}
+          PR_TITLE: ${{ steps.sanitize.outputs.pr_title }}
+          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
+          PR_SHA: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || steps.pr-details.outputs.head_sha }}
+          PR_URL: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.html_url || steps.pr-details.outputs.html_url }}
+        run: |
+          curl -X POST \
+            -H "Authorization: Bearer ${{ steps.app-token.outputs.token }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            -H "User-Agent: cline-pr-trigger" \
+            -H "Content-Type: application/json" \
+            https://api.github.com/repos/cline/intellij-plugin/dispatches \
+            -d @- <<EOF
+          {
+            "event_type": "cline-pr-check",
+            "client_payload": {
+              "pr_number": "$PR_NUMBER",
+              "branch_name": $BRANCH_NAME,
+              "action": "${{ github.event.action }}",
+              "sha": "$PR_SHA",
+              "pr_title": $PR_TITLE,
+              "pr_url": "$PR_URL"
+            }
+          }
+          EOF
+
+      - name: Log trigger details
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
+          PR_SHA: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || steps.pr-details.outputs.head_sha }}
+        run: |
+          echo "Triggered IntelliJ Plugin integration test for:"
+          echo "  PR #$PR_NUMBER"
+          echo "  Trigger: ${{ github.event_name }}"
+          echo "  Action: ${{ github.event.action }}"
+          echo "  SHA: $PR_SHA"
diff --git a/.github/workflows/ext-vscode-publish-legacy.yml b/.github/workflows/ext-vscode-publish-legacy.yml
new file mode 100644
index 0000000..c7d7cd5
--- /dev/null
+++ b/.github/workflows/ext-vscode-publish-legacy.yml
@@ -0,0 +1,294 @@
+name: ext-vscode-publish-legacy
+
+# Publishes the legacy (pre-SDK-migration) VS Code extension from the
+# `legacy-extension` branch. This branch holds the npm-based 3.89.x codebase,
+# rolled forward under a 4.0.x version so existing 4.0.0 users still receive
+# the update. The main `ext-vscode-publish-stable.yml` workflow (bun-based)
+# stays the path for releasing main once the SDK migration is solid.
+#
+# This workflow lives on and is dispatched from `main` (so it satisfies the
+# default-branch dispatch requirement), but it checks out and builds the
+# `legacy-extension` branch.
+
+on:
+    workflow_dispatch:
+        inputs:
+            release-type:
+                description: "Choose release type (release or pre-release)"
+                required: true
+                default: "release"
+                type: choice
+                options:
+                    - pre-release
+                    - release
+            branch:
+                description: "Branch holding the legacy extension code"
+                required: true
+                default: "legacy-extension"
+                type: string
+
+permissions:
+    contents: write
+    packages: write
+    checks: write
+    pull-requests: write
+
+concurrency:
+    group: ext-vscode-publish-legacy-${{ github.event.inputs.branch }}
+    cancel-in-progress: false
+
+jobs:
+    # Gate the publish on the legacy branch's own npm-based test suite. We can't
+    # reuse ./.github/workflows/ext-vscode-test.yml here — on main that's the
+    # bun-based suite and it would test main, not the legacy branch — so the
+    # essential quality + test steps are inlined against the checked-out legacy
+    # branch.
+    test:
+        name: Test Legacy Extension
+        runs-on: ubuntu-latest
+        defaults:
+          run:
+            working-directory: apps/vscode
+        steps:
+            - uses: actions/checkout@v4
+              with:
+                  ref: ${{ github.event.inputs.branch }}
+
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
+
+            - name: Install extension dependencies
+              working-directory: ${{ github.workspace }}
+              run: npm --prefix apps/vscode ci
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Install webview-ui dependencies
+              working-directory: ${{ github.workspace }}
+              run: npm --prefix apps/vscode/webview-ui ci
+
+            - name: Run Quality Checks (lint + typecheck)
+              run: npm run ci:check-all
+
+            - name: Build Tests and Extension
+              id: build_step
+              run: npm run ci:build
+
+            - name: Unit Tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              run: npm run test:unit
+
+            - name: Extension Integration Tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              run: xvfb-run -a npm run test:coverage
+
+            - name: Webview Tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              run: |
+                  cd webview-ui
+                  npm run test:coverage
+
+    publish:
+        needs: test
+        name: Publish Legacy Extension
+        runs-on: ubuntu-latest
+        environment: publish
+        defaults:
+          run:
+            working-directory: apps/vscode
+
+        steps:
+            # Check out the legacy branch (NOT main). fetch-depth: 0 + tags so we
+            # can create/push the release tag and compute the previous tag.
+            - uses: actions/checkout@v4
+              with:
+                  ref: ${{ github.event.inputs.branch }}
+                  fetch-depth: 0
+                  fetch-tags: true
+                  lfs: true
+
+            - name: Resolve Release Tag
+              id: resolve_tag
+              working-directory: ${{ github.workspace }}
+              env:
+                  BRANCH: ${{ github.event.inputs.branch }}
+              run: |
+                  # Tag is derived from the package version on the legacy branch.
+                  VERSION=$(node -p "require('./apps/vscode/package.json').version")
+                  TAG="v$VERSION"
+
+                  if [[ ! "$TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$ ]]; then
+                    echo "Error: derived tag '$TAG' does not match vX.Y.Z"
+                    exit 1
+                  fi
+                  TAG_REF="refs/tags/$TAG"
+                  HEAD_SHA=$(git rev-parse HEAD)
+
+                  if git show-ref --verify --quiet "$TAG_REF"; then
+                    TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
+                    if [[ "$TAG_SHA" != "$HEAD_SHA" ]]; then
+                      echo "Error: tag '$TAG' already exists at $TAG_SHA, not at branch head ($HEAD_SHA)"
+                      exit 1
+                    fi
+                    echo "Tag '$TAG' already exists at branch head. Continuing."
+                  else
+                    git config user.name "github-actions[bot]"
+                    git config user.email "github-actions[bot]@users.noreply.github.com"
+                    git tag "$TAG" "$HEAD_SHA"
+                    git push origin "$TAG_REF"
+                    echo "Created and pushed tag '$TAG' from $BRANCH head $HEAD_SHA."
+                  fi
+
+                  echo "tag=$TAG" >> $GITHUB_OUTPUT
+
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+
+            - name: Install extension dependencies
+              working-directory: ${{ github.workspace }}
+              run: npm --prefix apps/vscode install --include=optional
+
+            - name: Install webview-ui dependencies
+              working-directory: ${{ github.workspace }}
+              run: npm --prefix apps/vscode/webview-ui install --include=optional
+
+            - name: Install Publishing Tools
+              run: npm install -g @vscode/vsce ovsx
+
+            - name: Get Version
+              id: get_version
+              run: |
+                  VERSION=$(node -p "require('./package.json').version")
+                  echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+            - name: Verify Tag Matches Package Version
+              run: |
+                  TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  VERSION="v${{ steps.get_version.outputs.version }}"
+                  if [[ "$TAG" != "$VERSION" ]]; then
+                    echo "Error: tag '$TAG' does not match package version '$VERSION'"
+                    exit 1
+                  fi
+                  echo "Tag and package version match: $TAG"
+
+            - name: Verify Changelog Entry
+              working-directory: ${{ github.workspace }}
+              run: |
+                  EXPECTED_HEADING="## [${{ steps.get_version.outputs.version }}]"
+                  FIRST_HEADING=$(grep -m 1 '^## \[' CHANGELOG.md || true)
+                  if [[ "$FIRST_HEADING" != "$EXPECTED_HEADING" ]]; then
+                    echo "Error: CHANGELOG.md must start with '$EXPECTED_HEADING' before publishing."
+                    echo "Current first release heading: ${FIRST_HEADING:-<none>}"
+                    exit 1
+                  fi
+                  echo "Found changelog entry for ${{ steps.get_version.outputs.version }}"
+
+            - name: Verify Marketplace Tokens
+              env:
+                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
+                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
+              run: |
+                  if [[ -z "$VSCE_PAT" ]]; then
+                    echo "Error: VSCE_PAT is required to publish the stable VS Code extension."
+                    exit 1
+                  fi
+                  if [[ -z "$OVSX_PAT" ]]; then
+                    echo "Error: OVSX_PAT is required to publish the stable Open VSX extension."
+                    exit 1
+                  fi
+                  echo "Marketplace publish tokens are configured."
+
+            - name: Package and Publish Extension
+              env:
+                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
+                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
+                  CLINE_ENVIRONMENT: production
+                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+                  # OpenTelemetry production defaults (can be overridden at runtime)
+                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+                  OTEL_LOGS_EXPORTER: otlp
+                  OTEL_METRICS_EXPORTER: otlp
+                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+                  RELEASE_TYPE: ${{ github.event.inputs.release-type }}
+              run: |
+                  # Swap README.marketplace.md into README.md so both the GitHub
+                  # release artifact (vsce package below) and the marketplace
+                  # publish (npm run publish:marketplace below, which swaps
+                  # internally as an idempotent no-op) ship the same README.
+                  node scripts/marketplace-readme.mjs swap-in
+                  trap 'node scripts/marketplace-readme.mjs restore' EXIT
+
+                  # Required to generate the .vsix
+                  vsce package --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+
+                  if [ "$RELEASE_TYPE" = "pre-release" ]; then
+                    npm run publish:marketplace:prerelease
+                    echo "Successfully published pre-release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
+                  else
+                    npm run publish:marketplace
+                    echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
+                  fi
+
+            - name: Get Previous Tag
+              id: prev_tag
+              working-directory: ${{ github.workspace }}
+              run: |
+                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  PREV_TAG=$(git describe --tags --abbrev=0 "$CURRENT_TAG^" 2>/dev/null || echo "")
+                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
+
+            - name: Get Changelog Entry
+              id: changelog
+              working-directory: ${{ github.workspace }}
+              run: |
+                  # Get content between first ## [ and second ## [
+                  CONTENT=$(awk '/^## \[/{if(found) exit; found=1; next} found{print}' CHANGELOG.md)
+                  echo "content<<EOF" >> $GITHUB_OUTPUT
+                  echo "$CONTENT" >> $GITHUB_OUTPUT
+                  echo "EOF" >> $GITHUB_OUTPUT
+
+            - name: Create GitHub Release
+              uses: softprops/action-gh-release@v1
+              with:
+                  tag_name: ${{ steps.resolve_tag.outputs.tag }}
+                  files: "apps/vscode/*.vsix"
+                  body: |
+                      ${{ steps.changelog.outputs.content }}
+
+                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}
+                  prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Post release to Slack
+              uses: slackapi/slack-github-action@v3.0.1
+              with:
+                  method: chat.postMessage
+                  token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
+                  payload: |
+                    channel: "C0APVKGGZFC"
+                    text: "Cline ${{ steps.resolve_tag.outputs.tag }} (legacy)"
+                    blocks:
+                      - type: "section"
+                        text:
+                          type: "mrkdwn"
+                          text: "*Cline ${{ steps.resolve_tag.outputs.tag }} (legacy)*"
+                      - type: "section"
+                        text:
+                          type: "mrkdwn"
+                          text: ${{ toJSON(steps.changelog.outputs.content) }}
+                      - type: "context"
+                        elements:
+                          - type: "mrkdwn"
+                            text: "Full Changelog: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}"
diff --git a/.github/workflows/ext-vscode-publish-nightly.yml b/.github/workflows/ext-vscode-publish-nightly.yml
new file mode 100644
index 0000000..d2ad737
--- /dev/null
+++ b/.github/workflows/ext-vscode-publish-nightly.yml
@@ -0,0 +1,138 @@
+name: ext-vscode-publish-nightly
+
+on:
+  schedule:
+    # Every day at 4:00 AM PST (12:00 UTC)
+    - cron: "0 12 * * *"
+  workflow_dispatch:
+
+run-name: "Publish Nightly from ${{ github.ref_name }} @ ${{ github.sha }}"
+
+# Prevent concurrent publish runs on the same branch. The nightly publish script
+# generates the extension version from a seconds-resolution timestamp, so parallel
+# runs on the same ref can collide on the same version and cause publish failures
+# or inconsistent tagging. Runs on different branches proceed independently.
+concurrency:
+  group: ext-vscode-publish-nightly-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions: {}
+
+jobs:
+  test:
+    if: github.repository == 'cline/cline' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/dpc/sdk-migration-simpler-login')
+    permissions:
+      contents: read
+      pull-requests: read
+    uses: ./.github/workflows/ext-vscode-test.yml
+
+  publish:
+    needs: test
+    permissions:
+      contents: write
+    name: Publish Cline (Nightly) Extension
+    if: github.repository == 'cline/cline' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/dpc/sdk-migration-simpler-login')
+    runs-on: ubuntu-latest
+    environment: PublishNightly
+    # The VS Code extension's package.json and lockfiles live under apps/vscode/
+    # (the repo root has no package.json). Mirror ext-vscode-test.yml so install
+    # and publish steps run in the correct workspace.
+    defaults:
+      run:
+        working-directory: apps/vscode
+
+    steps:
+      - name: Checkout selected branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.sha }}
+          lfs: true
+          persist-credentials: false
+
+      - name: Show build source
+        working-directory: ${{ github.workspace }}
+        run: |
+          echo "Building ref: $GITHUB_REF"
+          echo "Building sha: $GITHUB_SHA"
+          git --no-pager log -1 --oneline
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.3.14
+
+      # Node is still REQUIRED in the publish job (not just for install): the publish
+      # scripts run as `node ./scripts/publish-*.mjs` and shell out to `npx ovsx`.
+      # setup-bun does not provide a Node runtime, so keep setup-node here.
+      # Pinned to Node 22 because newer LTS (Node 24 / npm 11) can make vsce's
+      # `npm list` dependency detection fail with ELSPROBLEMS during packaging.
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      # Single root install resolves the whole bun workspace at once (replaces the
+      # per-package `npm ci` steps for apps/vscode + webview-ui).
+      - name: Install workspace dependencies
+        working-directory: ${{ github.workspace }}
+        run: bun install --frozen-lockfile
+
+      # @cline/* are local workspace symlinks to source packages; build dist/ before
+      # packaging/publishing the extension.
+      - name: Build SDK packages
+        working-directory: ${{ github.workspace }}
+        run: bun run build:sdk
+
+      - name: Assert better-sqlite3 native binary present
+        run: |
+          NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+          if [ ! -f "$NODE_FILE" ]; then
+            echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
+            echo "(bun trustedDependencies postinstall likely did not run)"
+            exit 1
+          fi
+          echo "Found better-sqlite3 native binary: $NODE_FILE"
+
+      # vsce is now a workspace devDependency (on node_modules/.bin), but ovsx is not
+      # vendored and the publish script invokes it via `npx ovsx`, so install ovsx
+      # globally here (npm is available via setup-node). vsce is installed globally
+      # too to preserve the script's existing PATH expectations.
+      - name: Install Publishing Tools
+        run: npm install -g @vscode/vsce ovsx
+
+      - name: Publish Nightly Extension
+        env:
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          OVSX_PAT: ${{ secrets.OVSX_PAT }}
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          CLINE_ENVIRONMENT: production
+          # OpenTelemetry production defaults (can be overridden at runtime)
+          OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+        # The script itself runs under `node ./scripts/publish-nightly.mjs`; bun run
+        # just launches it. Node + npm (for `npx ovsx`) are provided by setup-node above.
+        run: bun run publish:marketplace:nightly
+
+      - name: Tag published commit
+        working-directory: ${{ github.workspace }}
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          SAFE_REF=$(echo "$GITHUB_REF_NAME" | tr '/[:upper:]' '-[:lower:]' | tr -cd 'a-z0-9._-')
+          SHORT_SHA=$(git rev-parse --short=12 HEAD)
+          TIMESTAMP=$(date -u +"%Y%m%d%H%M%S")
+          TAG="nightly-${SAFE_REF}-${TIMESTAMP}-${SHORT_SHA}"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "$TAG" -m "Cline Nightly published from ${GITHUB_REF_NAME} at ${GITHUB_SHA}"
+          # Use an explicit HTTPS remote with GH_TOKEN because checkout was run with
+          # persist-credentials: false, so actions/checkout did not persist a git credential helper.
+          git push "https://x-access-token:${GH_TOKEN}@github.com/${GITHUB_REPOSITORY}.git" "refs/tags/${TAG}"
+
+          echo "Tagged published commit: $TAG"
diff --git a/.github/workflows/ext-vscode-publish-stable.yml b/.github/workflows/ext-vscode-publish-stable.yml
new file mode 100644
index 0000000..0dc22b1
--- /dev/null
+++ b/.github/workflows/ext-vscode-publish-stable.yml
@@ -0,0 +1,310 @@
+name: ext-vscode-publish-stable
+
+on:
+    workflow_dispatch:
+        inputs:
+            release-type:
+                description: "Choose release type (release or pre-release)"
+                required: true
+                default: "release"
+                type: choice
+                options:
+                    - pre-release
+                    - release
+            auto_create_tag_from_main:
+                description: "Auto-create and push the provided tag from the tested main commit (recommended)"
+                required: true
+                default: true
+                type: boolean
+            tag:
+                description: "Tag to publish (required in both modes, e.g., v3.1.2)"
+                required: true
+                type: string
+
+permissions:
+    contents: write
+    packages: write
+    checks: write
+    pull-requests: write
+
+concurrency:
+    group: ext-vscode-publish-stable-${{ github.event.inputs.tag }}
+    cancel-in-progress: false
+
+jobs:
+    test:
+        uses: ./.github/workflows/ext-vscode-test.yml
+
+    publish:
+        needs: test
+        name: Publish Extension
+        runs-on: ubuntu-latest
+        environment: publish
+        defaults:
+          run:
+            working-directory: apps/vscode
+
+        steps:
+            - uses: actions/checkout@v4
+              with:
+                  ref: main
+                  fetch-depth: 0
+                  fetch-tags: true
+                  lfs: true
+
+            - name: Resolve Release Tag
+              id: resolve_tag
+              working-directory: ${{ github.workspace }}
+              env:
+                  TAG: ${{ github.event.inputs.tag }}
+                  AUTO_CREATE: ${{ github.event.inputs.auto_create_tag_from_main }}
+              run: |
+                  TESTED_SHA="${{ github.sha }}"
+                  WORKFLOW_REF="${{ github.ref }}"
+
+                  if [[ -z "$TAG" ]]; then
+                    echo "Error: tag input is required"
+                    exit 1
+                  fi
+
+                  if [[ ! "$TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$ ]]; then
+                    echo "Error: tag must match vX.Y.Z (optionally with -suffix or .suffix)"
+                    exit 1
+                  fi
+                  TAG_REF="refs/tags/$TAG"
+
+                  git fetch origin main --tags
+
+                  if [[ "$AUTO_CREATE" == "true" ]]; then
+                    if [[ "$WORKFLOW_REF" != "refs/heads/main" ]]; then
+                      echo "Error: auto-create mode requires dispatching from main (current ref: $WORKFLOW_REF)"
+                      exit 1
+                    fi
+                    echo "Auto-create enabled. Using tested workflow SHA: $TESTED_SHA"
+
+                    if ! git merge-base --is-ancestor "$TESTED_SHA" origin/main; then
+                      echo "Error: tested SHA $TESTED_SHA is not on origin/main"
+                      exit 1
+                    fi
+
+                    if git show-ref --verify --quiet "$TAG_REF"; then
+                      TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
+                      if [[ "$TAG_SHA" != "$TESTED_SHA" ]]; then
+                        echo "Error: tag '$TAG' already exists at $TAG_SHA, not at tested SHA ($TESTED_SHA)"
+                        exit 1
+                      fi
+                      echo "Tag '$TAG' already exists at tested SHA. Continuing."
+                    else
+                      git config user.name "github-actions[bot]"
+                      git config user.email "github-actions[bot]@users.noreply.github.com"
+                      git tag "$TAG" "$TESTED_SHA"
+                      git push origin "$TAG_REF"
+                      echo "Created and pushed tag '$TAG' from tested SHA $TESTED_SHA."
+                    fi
+                  else
+                    if ! git show-ref --verify --quiet "$TAG_REF"; then
+                      echo "Error: tag '$TAG' does not exist in the repository"
+                      exit 1
+                    fi
+                    TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
+                    if [[ "$TAG_SHA" != "$TESTED_SHA" ]]; then
+                      echo "Error: existing tag '$TAG' points to $TAG_SHA, but this workflow tested $TESTED_SHA"
+                      echo "Dispatch from the tag ref, or from the exact main commit the tag points to."
+                      exit 1
+                    fi
+                    echo "Using existing tag '$TAG' at tested SHA $TESTED_SHA."
+                  fi
+
+                  git checkout --detach "$TAG_REF^{commit}"
+                  echo "tag=$TAG" >> $GITHUB_OUTPUT
+                  echo "resolved_sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: 1.3.14
+
+            # Node is still REQUIRED in the publish job (not just for install): the
+            # publish scripts run as `node scripts/publish-*.mjs`, the version step uses
+            # `node -p`, and `npx ovsx` needs npm. setup-bun does not provide a Node
+            # runtime, so keep setup-node. Pinned to Node 22 because newer LTS
+            # (Node 24 / npm 11) can make vsce's `npm list` detection fail with
+            # ELSPROBLEMS during packaging.
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+
+            # Single root install resolves the whole bun workspace at once (replaces the
+            # per-package `npm install` steps for apps/vscode + webview-ui).
+            - name: Install workspace dependencies
+              working-directory: ${{ github.workspace }}
+              run: bun install --frozen-lockfile
+
+            # @cline/* are local workspace symlinks to source packages; build dist/ before
+            # packaging/publishing the extension.
+            - name: Build SDK packages
+              working-directory: ${{ github.workspace }}
+              run: bun run build:sdk
+
+            - name: Assert better-sqlite3 native binary present
+              run: |
+                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+                  if [ ! -f "$NODE_FILE" ]; then
+                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
+                    echo "(bun trustedDependencies postinstall likely did not run)"
+                    exit 1
+                  fi
+                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+
+            # vsce is a workspace devDependency (on node_modules/.bin), but ovsx is not
+            # vendored and the publish script invokes it via `npx ovsx`, so install ovsx
+            # globally (npm is available via setup-node). vsce is installed globally too
+            # to preserve the script's existing PATH expectations.
+            - name: Install Publishing Tools
+              run: npm install -g @vscode/vsce ovsx
+
+            - name: Get Version
+              id: get_version
+              run: |
+                  VERSION=$(node -p "require('./package.json').version")
+                  echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+            - name: Verify Tag Matches Package Version
+              run: |
+                  TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  VERSION="v${{ steps.get_version.outputs.version }}"
+                  if [[ "$TAG" != "$VERSION" ]]; then
+                    echo "Error: tag '$TAG' does not match package version '$VERSION'"
+                    exit 1
+                  fi
+                  echo "Tag and package version match: $TAG"
+
+            - name: Verify Changelog Entry
+              working-directory: ${{ github.workspace }}
+              run: |
+                  EXPECTED_HEADING="## [${{ steps.get_version.outputs.version }}]"
+                  FIRST_HEADING=$(grep -m 1 '^## \[' CHANGELOG.md || true)
+                  if [[ "$FIRST_HEADING" != "$EXPECTED_HEADING" ]]; then
+                    echo "Error: CHANGELOG.md must start with '$EXPECTED_HEADING' before publishing."
+                    echo "Current first release heading: ${FIRST_HEADING:-<none>}"
+                    exit 1
+                  fi
+                  echo "Found changelog entry for ${{ steps.get_version.outputs.version }}"
+
+            - name: Verify Marketplace Tokens
+              env:
+                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
+                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
+              run: |
+                  if [[ -z "$VSCE_PAT" ]]; then
+                    echo "Error: VSCE_PAT is required to publish the stable VS Code extension."
+                    exit 1
+                  fi
+                  if [[ -z "$OVSX_PAT" ]]; then
+                    echo "Error: OVSX_PAT is required to publish the stable Open VSX extension."
+                    exit 1
+                  fi
+                  echo "Marketplace publish tokens are configured."
+
+            - name: Get Previous Tag
+              id: prev_tag
+              working-directory: ${{ github.workspace }}
+              run: |
+                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  PREV_TAG=$(
+                    git tag --merged "$CURRENT_TAG^" --list 'v[0-9]*.[0-9]*.[0-9]*' --sort=-v:refname \
+                      | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$' \
+                      | head -n 1 || true
+                  )
+                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
+
+            - name: Get Changelog Entry
+              id: changelog
+              working-directory: ${{ github.workspace }}
+              run: |
+                  # Get content between the matching version heading and the next release heading.
+                  CONTENT=$(awk -v version="${{ steps.get_version.outputs.version }}" '
+                    $0 == "## [" version "]" { found=1; next }
+                    found && /^## \[/ { exit }
+                    found { print }
+                    END { if (!found) exit 1 }
+                  ' CHANGELOG.md)
+                  echo "content<<EOF" >> $GITHUB_OUTPUT
+                  echo "$CONTENT" >> $GITHUB_OUTPUT
+                  echo "EOF" >> $GITHUB_OUTPUT
+
+            - name: Package and Publish Extension
+              env:
+                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
+                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
+                  CLINE_ENVIRONMENT: production
+                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+                  # OpenTelemetry production defaults (can be overridden at runtime)
+                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+                  OTEL_LOGS_EXPORTER: otlp
+                  OTEL_METRICS_EXPORTER: otlp
+                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+                  RELEASE_TYPE: ${{ github.event.inputs.release-type }}
+              run: |
+                  # Swap README.marketplace.md into README.md so both the GitHub
+                  # release artifact (vsce package below) and the marketplace
+                  # publish (npm run publish:marketplace below, which swaps
+                  # internally as an idempotent no-op) ship the same README.
+                  node scripts/marketplace-readme.mjs swap-in
+                  trap 'node scripts/marketplace-readme.mjs restore' EXIT
+
+                  # Required to generate the .vsix. --no-dependencies: the extension
+                  # is fully esbuild-bundled, and under the bun workspace the @cline/*
+                  # deps are symlinks pointing outside the package, so without this vsce
+                  # would walk them and pull the whole monorepo into the .vsix.
+                  vsce package --no-dependencies --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+
+                  # These scripts run under `node scripts/publish-marketplace.mjs`;
+                  # bun run just launches them. Node + npm (for `npx ovsx`) come from
+                  # setup-node above.
+                  if [ "$RELEASE_TYPE" = "pre-release" ]; then
+                    bun run publish:marketplace:prerelease
+                    echo "Successfully published pre-release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
+                  else
+                    bun run publish:marketplace
+                    echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
+                  fi
+
+            - name: Create GitHub Release
+              uses: softprops/action-gh-release@v1
+              with:
+                  tag_name: ${{ steps.resolve_tag.outputs.tag }}
+                  files: "apps/vscode/*.vsix"
+                  body: |
+                      ${{ steps.changelog.outputs.content }}
+
+                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}
+                  prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Post release to Slack
+              uses: slackapi/slack-github-action@v3.0.1
+              with:
+                  method: chat.postMessage
+                  token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
+                  payload: |
+                    channel: "C0APVKGGZFC"
+                    text: "Cline ${{ steps.resolve_tag.outputs.tag }}"
+                    blocks:
+                      - type: "section"
+                        text:
+                          type: "mrkdwn"
+                          text: "*Cline ${{ steps.resolve_tag.outputs.tag }}*"
+                      - type: "section"
+                        text:
+                          type: "mrkdwn"
+                          text: ${{ toJSON(steps.changelog.outputs.content) }}
+                      - type: "context"
+                        elements:
+                          - type: "mrkdwn"
+                            text: "Full Changelog: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}"
diff --git a/.github/workflows/ext-vscode-test-e2e.yml b/.github/workflows/ext-vscode-test-e2e.yml
new file mode 100644
index 0000000..971afe8
--- /dev/null
+++ b/.github/workflows/ext-vscode-test-e2e.yml
@@ -0,0 +1,179 @@
+name: ext-vscode-test-e2e
+
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        types: [opened, reopened, synchronize, ready_for_review]
+    workflow_dispatch:
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+    cancel-in-progress: true
+
+permissions:
+    contents: read
+    pull-requests: read
+
+jobs:
+    detect-changes:
+        runs-on: ubuntu-latest
+        name: Detect Changes
+        outputs:
+            e2e: ${{ steps.force.outputs.run_all == 'true' || steps.filter.outputs.e2e == 'true' }}
+        steps:
+            - id: force
+              if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+              run: echo "run_all=true" >> "$GITHUB_OUTPUT"
+
+            - uses: actions/checkout@v4
+              if: steps.force.outputs.run_all != 'true'
+
+            - uses: dorny/paths-filter@v3
+              if: steps.force.outputs.run_all != 'true'
+              id: filter
+              with:
+                  filters: |
+                      e2e:
+                          - 'apps/vscode/src/**'
+                          - 'apps/vscode/webview-ui/**'
+                          - 'apps/vscode/proto/**'
+                          - 'apps/vscode/tests/**'
+                          - 'apps/vscode/scripts/**'
+                          - 'apps/vscode/standalone/**'
+                          - 'apps/vscode/assets/**'
+                          - 'apps/vscode/walkthrough/**'
+                          - 'apps/vscode/package.json'
+                          - 'apps/vscode/webview-ui/package.json'
+                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
+                          - 'bun.lock'
+                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
+                          - 'sdk/packages/**'
+                          - 'apps/vscode/buf.yaml'
+                          - 'apps/vscode/tsconfig*.json'
+                          - 'apps/vscode/biome.jsonc'
+                          - 'apps/vscode/esbuild.mjs'
+                          - 'apps/vscode/bunfig.toml'
+                          - 'apps/vscode/.vscode-test.mjs'
+                          - 'apps/vscode/.vscodeignore'
+                          - 'apps/vscode/playwright*.ts'
+                          - '.github/workflows/ext-vscode-test-e2e.yml'
+
+    matrix_prep:
+        needs: detect-changes
+        if: needs.detect-changes.outputs.e2e == 'true'
+        runs-on: ubuntu-latest
+        outputs:
+            matrix: ${{ steps.set-matrix.outputs.matrix }}
+        steps:
+            - id: set-matrix
+              run: |
+                  echo 'matrix=[{"runner":"ubuntu"},{"runner":"windows"},{"runner":"macos"}]' >> $GITHUB_OUTPUT
+
+    e2e:
+        needs: [detect-changes, matrix_prep]
+        if: needs.detect-changes.outputs.e2e == 'true'
+        strategy:
+            fail-fast: false
+            matrix:
+                include: ${{ fromJson(needs.matrix_prep.outputs.matrix) }}
+        runs-on: ${{ matrix.runner }}-latest
+        timeout-minutes: 20
+        permissions:
+            id-token: write
+            contents: read
+        defaults:
+            run:
+                working-directory: apps/vscode
+        steps:
+            - uses: actions/checkout@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: 1.3.14
+
+            # Cache Bun's global install cache - keyed on the authoritative root bun.lock.
+            - name: Cache Bun install cache
+              uses: actions/cache@v4
+              id: bun-cache
+              with:
+                  path: ~/.bun/install/cache
+                  key: ${{ runner.os }}-bun-${{ hashFiles('bun.lock') }}
+                  restore-keys: |
+                      ${{ runner.os }}-bun-
+
+            # Cache VS Code installation
+            - name: Cache VS Code
+              uses: actions/cache@v4
+              id: vscode-cache
+              with:
+                  path: apps/vscode/.vscode-test
+                  key: vscode-${{ runner.os }}-stable-${{ hashFiles('apps/vscode/.vscode-test.mjs', 'apps/vscode/package.json') }}
+                  restore-keys: |
+                      vscode-${{ runner.os }}-stable-
+
+            # Cache Playwright browsers
+            - name: Cache Playwright browsers
+              uses: actions/cache@v4
+              id: playwright-cache
+              with:
+                  path: |
+                      ~/.cache/ms-playwright
+                      ~/Library/Caches/ms-playwright
+                      ~/AppData/Local/ms-playwright
+                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('bun.lock') }}
+                  restore-keys: |
+                      playwright-browsers-${{ runner.os }}-
+
+            # Single root install resolves the entire bun workspace at once (replaces
+            # the per-package `npm ci` steps for apps/vscode + webview-ui).
+            - name: Install workspace dependencies
+              working-directory: ${{ github.workspace }}
+              run: bun install --frozen-lockfile
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            # @cline/* are local workspace symlinks to source packages; build dist/
+            # before building/packaging the extension for E2E.
+            - name: Build SDK packages
+              working-directory: ${{ github.workspace }}
+              run: bun run build:sdk
+
+            - name: Assert better-sqlite3 native binary present
+              # Force bash: the Windows runner defaults to pwsh, which can't parse this
+              # POSIX test. Git Bash ships on GitHub's windows-latest images.
+              shell: bash
+              run: |
+                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+                  if [ ! -f "$NODE_FILE" ]; then
+                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
+                    echo "(bun trustedDependencies postinstall likely did not run)"
+                    exit 1
+                  fi
+                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+
+            # NOTE: vsce is no longer installed globally. @vscode/vsce is a workspace
+            # devDependency of apps/vscode (resolved into node_modules/.bin), and the
+            # `test:e2e:build` script invokes `vsce` via `bun run`, which puts the local
+            # .bin on PATH. No global install needed.
+
+            - name: Install xvfb on Linux
+              if: matrix.runner == 'ubuntu'
+              run: sudo apt-get update && sudo apt-get install -y xvfb
+
+            # Run optimized E2E tests (eliminates redundant builds)
+            - name: Run E2E tests - Linux
+              if: matrix.runner == 'ubuntu'
+              run: xvfb-run -a bun run test:e2e:optimal
+
+            - name: Run E2E tests - Non-Linux
+              if: matrix.runner != 'ubuntu'
+              run: bun run test:e2e:optimal
+
+            - uses: actions/upload-artifact@v4
+              if: ${{ failure() }}
+              with:
+                  name: playwright-recordings-${{ matrix.runner }}
+                  path: |
+                      test-results/playwright/
diff --git a/.github/workflows/ext-vscode-test.yml b/.github/workflows/ext-vscode-test.yml
new file mode 100644
index 0000000..2ad0ba5
--- /dev/null
+++ b/.github/workflows/ext-vscode-test.yml
@@ -0,0 +1,428 @@
+name: ext-vscode-test
+
+on:
+    push:
+        branches:
+            - main
+    workflow_dispatch:
+    pull_request:
+        branches:
+            - main
+    workflow_call:
+
+# Set default permissions for all jobs
+permissions:
+    contents: read # Needed to check out code
+    pull-requests: read # Needed for changed-file detection on pull requests
+
+jobs:
+    detect-changes:
+        runs-on: ubuntu-latest
+        name: Detect Changes
+        outputs:
+            vscode: ${{ steps.force.outputs.run_all == 'true' || steps.filter.outputs.vscode == 'true' }}
+            testing_platform: ${{ steps.force.outputs.run_all == 'true' || steps.filter.outputs.testing_platform == 'true' }}
+        steps:
+            - id: force
+              if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || github.event_name == 'workflow_call'
+              run: echo "run_all=true" >> "$GITHUB_OUTPUT"
+
+            - uses: actions/checkout@v4
+              if: steps.force.outputs.run_all != 'true'
+
+            - uses: dorny/paths-filter@v3
+              if: steps.force.outputs.run_all != 'true'
+              id: filter
+              with:
+                  filters: |
+                      vscode:
+                          - 'apps/vscode/src/**'
+                          - 'apps/vscode/webview-ui/**'
+                          - 'apps/vscode/proto/**'
+                          - 'apps/vscode/tests/**'
+                          - 'apps/vscode/scripts/**'
+                          - 'apps/vscode/standalone/**'
+                          - 'apps/vscode/assets/**'
+                          - 'apps/vscode/walkthrough/**'
+                          - 'apps/vscode/package.json'
+                          - 'apps/vscode/webview-ui/package.json'
+                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
+                          - 'bun.lock'
+                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
+                          - 'sdk/packages/**'
+                          - 'apps/vscode/buf.yaml'
+                          - 'apps/vscode/tsconfig*.json'
+                          - 'apps/vscode/biome.jsonc'
+                          - 'apps/vscode/esbuild.mjs'
+                          - 'apps/vscode/bunfig.toml'
+                          - 'apps/vscode/.vscode-test.mjs'
+                          - 'apps/vscode/test-setup.js'
+                          - '.github/workflows/ext-vscode-test.yml'
+                      testing_platform:
+                          - 'apps/vscode/src/**'
+                          - 'apps/vscode/proto/**'
+                          - 'apps/vscode/standalone/**'
+                          - 'apps/vscode/testing-platform/**'
+                          - 'apps/vscode/testing-platform/package.json'
+                          - 'apps/vscode/tests/specs/**'
+                          - 'apps/vscode/package.json'
+                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
+                          - 'bun.lock'
+                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
+                          - 'sdk/packages/**'
+                          - 'apps/vscode/buf.yaml'
+                          - 'apps/vscode/tsconfig*.json'
+                          - 'apps/vscode/esbuild.mjs'
+                          - 'apps/vscode/.vscodeignore'
+                          - 'apps/vscode/scripts/**'
+                          - '.github/workflows/ext-vscode-test.yml'
+
+    quality-checks:
+        needs: detect-changes
+        if: needs.detect-changes.outputs.vscode == 'true' || needs.detect-changes.outputs.testing_platform == 'true'
+        runs-on: ubuntu-latest
+        name: Quality Checks
+        defaults:
+          run:
+            working-directory: apps/vscode
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: 1.3.14
+
+            # Single root install resolves the entire bun workspace (apps/vscode,
+            # webview-ui, testing-platform and the @cline/* SDK symlinks) at once,
+            # so the previous per-package `npm ci` steps collapse into one.
+            - name: Install workspace dependencies
+              working-directory: ${{ github.workspace }}
+              run: bun install --frozen-lockfile
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            # @cline/* are local workspace symlinks to source packages; their dist/
+            # output must be built before the extension can type-check/compile.
+            - name: Build SDK packages
+              working-directory: ${{ github.workspace }}
+              run: bun run build:sdk
+
+            - name: Assert better-sqlite3 native binary present
+              run: |
+                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+                  if [ ! -f "$NODE_FILE" ]; then
+                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
+                    echo "(bun trustedDependencies postinstall likely did not run)"
+                    exit 1
+                  fi
+                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+
+            - name: Run Quality Checks (Parallel)
+              run: bun run ci:check-all
+
+    vscode-test:
+        needs: [detect-changes, quality-checks]
+        if: needs.detect-changes.outputs.vscode == 'true'
+        env:
+            VSCODE_TEST_VERSION: 1.103.0
+        strategy:
+            fail-fast: false
+            matrix:
+                os: [ubuntu-latest, windows-latest]
+        runs-on: ${{ matrix.os }}
+        name: ${{ matrix.os == 'ubuntu-latest' && 'vscode test' || format('vscode test ({0})', matrix.os) }}
+        defaults:
+            run:
+                shell: bash
+                working-directory: apps/vscode
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: 1.3.14
+
+            # Single root install resolves the entire bun workspace at once (replaces
+            # the per-package `npm ci` steps for apps/vscode + webview-ui).
+            - name: Install workspace dependencies
+              working-directory: ${{ github.workspace }}
+              run: bun install --frozen-lockfile
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            # @cline/* are local workspace symlinks to source packages; build dist/
+            # before compiling/testing the extension.
+            - name: Build SDK packages
+              working-directory: ${{ github.workspace }}
+              run: bun run build:sdk
+
+            - name: Assert better-sqlite3 native binary present
+              run: |
+                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+                  if [ ! -f "$NODE_FILE" ]; then
+                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
+                    echo "(bun trustedDependencies postinstall likely did not run)"
+                    exit 1
+                  fi
+                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+
+            # NOTE: The old `npm config set script-shell bash` step is intentionally
+            # removed. Scripts are now launched with `bun run`, which uses Bun's own
+            # built-in cross-platform shell rather than npm's configured script-shell,
+            # so that npm-specific Windows workaround no longer applies. Bash-dependent
+            # scripts (e.g. scripts/proto-lint.sh, standalone/runclinecore.sh) are
+            # invoked explicitly via `bash ...` from within the package scripts, and
+            # this job's `defaults.run.shell: bash` (Git Bash on Windows) still covers
+            # the workflow `run:` blocks below.
+
+            - name: Cache VS Code test runtime
+              if: runner.os == 'Windows'
+              uses: actions/cache@v4
+              with:
+                  path: .vscode-test
+                  key: vscode-test-runtime-${{ runner.os }}-${{ env.VSCODE_TEST_VERSION }}
+
+            # Build the extension and tests (without redundant checks)
+            - name: Build Tests and Extension
+              id: build_step
+              run: bun run ci:build
+
+            - name: Vitest Suites (SDK adapter + model catalog)
+              id: vitest_tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              # The vitest config sets passWithNoTests: true, so a broken glob/alias
+              # would "pass" with zero tests. Capture output and assert a non-zero
+              # test count to guard against silent skips.
+              run: |
+                  set -o pipefail
+                  bun run test:vitest 2>&1 | tee vitest-output.log
+                  # Strip ANSI color codes before matching — vitest colorizes the
+                  # "Tests  N passed" summary, so the count is not adjacent to the
+                  # "Tests" label in the raw bytes.
+                  if ! sed -r 's/\x1b\[[0-9;]*m//g' vitest-output.log | grep -Eq 'Tests[[:space:]]+[0-9]*[1-9][0-9]* (passed|failed)'; then
+                    echo "ERROR: vitest reported zero tests (possible silent skip)."
+                    exit 1
+                  fi
+
+            - name: Unit Tests (bun) - Linux
+              id: unit_tests_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
+              # The node-side unit suite (.mocharc spec set) now runs under `bun test`
+              # via scripts/run-bun-unit-tests.ts (one isolated bun process per file).
+              # The runner exits non-zero on any failure and prints a final
+              # "Files: N  Pass: P  Fail: F" summary; assert a non-zero pass count to
+              # guard against an empty glob silently "passing".
+              run: |
+                  set -o pipefail
+                  bun run test:unit 2>&1 | tee unit-output.log
+                  if ! grep -Eq 'Pass:[[:space:]]+[0-9]*[1-9][0-9]*' unit-output.log; then
+                    echo "ERROR: bun unit runner reported zero passing tests (possible silent skip)."
+                    exit 1
+                  fi
+
+            - name: Unit Tests (bun) - Non-Linux
+              id: unit_tests_non_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
+              run: |
+                  bun run test:unit
+
+            - name: Extension Integration Tests - Linux
+              id: integration_tests_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
+              run: xvfb-run -a bun run test:coverage
+
+            - name: Extension Integration Tests - Non-Linux
+              id: integration_tests_non_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
+              run: |
+                  for attempt in 1 2 3; do
+                    echo "Running extension integration tests (attempt ${attempt}/3)"
+                    if bun run test:integration; then
+                      exit 0
+                    fi
+
+                    if [ "$attempt" -eq 3 ]; then
+                      echo "Extension integration tests failed after 3 attempts"
+                      exit 1
+                    fi
+
+                    echo "Extension integration tests failed; retrying after short delay"
+                    sleep 5
+                  done
+
+            - name: Webview Tests with Coverage
+              id: webview_tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              run: |
+                  cd webview-ui
+                  bun run test:coverage
+
+            - name: Save Coverage Reports
+              uses: actions/upload-artifact@v4
+              # Only upload artifacts on Linux - We only need coverage from one OS
+              if: runner.os == 'Linux'
+              with:
+                  name: pr-coverage-reports
+                  path: |
+                      apps/vscode/webview-ui/coverage/lcov.info
+
+    test-platform-integration:
+        needs: [detect-changes, quality-checks]
+        if: needs.detect-changes.outputs.testing_platform == 'true'
+        runs-on: ubuntu-latest
+        defaults:
+          run:
+            working-directory: apps/vscode
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: 1.3.14
+
+            # Single root install resolves the whole bun workspace, including the
+            # testing-platform package, so the separate per-package `npm ci` steps
+            # (extension + webview-ui + testing-platform) collapse into one.
+            - name: Install workspace dependencies
+              working-directory: ${{ github.workspace }}
+              run: bun install --frozen-lockfile
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            # @cline/* are local workspace symlinks to source packages; build dist/
+            # before compiling the standalone core.
+            - name: Build SDK packages
+              working-directory: ${{ github.workspace }}
+              run: bun run build:sdk
+
+            - name: Assert better-sqlite3 native binary present
+              run: |
+                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+                  if [ ! -f "$NODE_FILE" ]; then
+                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
+                    echo "(bun trustedDependencies postinstall likely did not run)"
+                    exit 1
+                  fi
+                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+
+            - name: Download ripgrep binaries
+              run: bun run download-ripgrep
+
+            - name: Compile Standalone
+              run: bun run compile-standalone
+
+            - name: Running testing platform integration spec tests
+              timeout-minutes: 7
+              run: bun run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
+
+            - name: Save Coverage Reports
+              uses: actions/upload-artifact@v4
+              with:
+                name: test-platform-integration-core-coverage
+                path: apps/vscode/coverage/**/lcov.info
+
+    # Keep the required "test" check as a tiny aggregate gate instead of the conditional
+    # VS Code matrix. GitHub treats conditionally skipped jobs as successful required
+    # checks, so the gate below preserves the old required check name while making sure
+    # whichever filtered test jobs were selected actually passed.
+    test:
+        needs: [detect-changes, quality-checks, vscode-test, test-platform-integration]
+        if: ${{ !cancelled() }}
+        runs-on: ubuntu-latest
+        name: test
+        steps:
+            - name: Verify selected test jobs
+              env:
+                  DETECT_CHANGES_RESULT: ${{ needs.detect-changes.result }}
+                  QUALITY_CHECKS_RESULT: ${{ needs.quality-checks.result }}
+                  VSCODE_CHANGED: ${{ needs.detect-changes.outputs.vscode }}
+                  TESTING_PLATFORM_CHANGED: ${{ needs.detect-changes.outputs.testing_platform }}
+                  VSCODE_TEST_RESULT: ${{ needs.vscode-test.result }}
+                  TEST_PLATFORM_RESULT: ${{ needs.test-platform-integration.result }}
+              run: |
+                  if [ "$DETECT_CHANGES_RESULT" != "success" ]; then
+                    echo "detect-changes did not succeed: $DETECT_CHANGES_RESULT"
+                    exit 1
+                  fi
+
+                  if [ "$VSCODE_CHANGED" != "true" ] && [ "$TESTING_PLATFORM_CHANGED" != "true" ]; then
+                    echo "No root test paths changed; skipping root test requirements."
+                    exit 0
+                  fi
+
+                  if [ "$QUALITY_CHECKS_RESULT" != "success" ]; then
+                    echo "quality-checks did not succeed: $QUALITY_CHECKS_RESULT"
+                    exit 1
+                  fi
+
+                  if [ "$VSCODE_CHANGED" = "true" ] && [ "$VSCODE_TEST_RESULT" != "success" ]; then
+                    echo "vscode-test did not succeed: $VSCODE_TEST_RESULT"
+                    exit 1
+                  fi
+
+                  if [ "$TESTING_PLATFORM_CHANGED" = "true" ] && [ "$TEST_PLATFORM_RESULT" != "success" ]; then
+                    echo "test-platform-integration did not succeed: $TEST_PLATFORM_RESULT"
+                    exit 1
+                  fi
+
+                  echo "Selected root test jobs passed."
+
+    qlty:
+        needs: [detect-changes, quality-checks, vscode-test, test-platform-integration]
+        if: ${{ !cancelled() && needs.quality-checks.result == 'success' && (needs.vscode-test.result == 'success' || needs.vscode-test.result == 'skipped') && (needs.test-platform-integration.result == 'success' || needs.test-platform-integration.result == 'skipped') && (needs.detect-changes.outputs.vscode == 'true' || needs.detect-changes.outputs.testing_platform == 'true') }}
+        runs-on: ubuntu-latest
+        # Run on PRs to main, pushes to main, and manual dispatches
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Download unit tests coverage reports
+              if: needs.detect-changes.outputs.vscode == 'true'
+              uses: actions/download-artifact@v4
+              with:
+                  name: pr-coverage-reports
+                  path: apps/vscode
+
+            - name: Upload core unit tests coverage to Qlty
+              if: needs.detect-changes.outputs.vscode == 'true'
+              uses: qltysh/qlty-action/coverage@v2
+              with:
+                  token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
+                  # we can merge multiple files if necessary
+                  files: |
+                    apps/vscode/coverage-unit/lcov.info
+                  tag: unit:core
+
+            - name: Upload webview-ui unit tests coverage to Qlty
+              if: needs.detect-changes.outputs.vscode == 'true'
+              uses: qltysh/qlty-action/coverage@v2
+              with:
+                  token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
+                  # we can merge multiple files if necessary
+                  files: |
+                    apps/vscode/webview-ui/coverage/lcov.info
+                  tag: unit:webview-ui
+                  add-prefix: webview-ui/
+
+            - name: Download test platform integration core coverage artifact
+              if: needs.detect-changes.outputs.testing_platform == 'true'
+              uses: actions/download-artifact@v4
+              continue-on-error: true
+              id: download-integration-coverage
+              with:
+                name: test-platform-integration-core-coverage
+                path: apps/vscode/integration-core-coverage-reports
+
+            - name: Upload core integration tests coverage to Qlty
+              if: needs.detect-changes.outputs.testing_platform == 'true' && steps.download-integration-coverage.outcome == 'success'
+              uses: qltysh/qlty-action/coverage@v2
+              with:
+                token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
+                files: apps/vscode/integration-core-coverage-reports/**/lcov.info
+                tag: integration:core
diff --git a/.github/workflows/repo-label-issues.yml b/.github/workflows/repo-label-issues.yml
new file mode 100644
index 0000000..7c7994d
--- /dev/null
+++ b/.github/workflows/repo-label-issues.yml
@@ -0,0 +1,65 @@
+name: repo-label-issues
+
+on:
+  issues:
+    types: [opened, edited]
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const body = context.payload.issue.body || '';
+            const labels = context.payload.issue.labels.map(l => l.name);
+
+            // Check if JetBrains Plugin is selected
+            if (body.match(/###\s*Cline Surface\s*\n+JetBrains Plugin/i)) {
+              if (!labels.includes('JetBrains')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['JetBrains']
+                });
+              }
+            }
+
+            // Check if VSCode Extension is selected
+            if (body.match(/###\s*Cline Surface\s*\n+VSCode Extension/i)) {
+              if (!labels.includes('VS Code')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['VS Code']
+                });
+              }
+            }
+
+            // Check if CLI is selected
+            if (body.match(/###\s*Cline Surface\s*\n+CLI/i)) {
+              if (!labels.includes('CLI')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['CLI']
+                });
+              }
+            }
+
+            // Check if beta version checkbox is checked
+            if (body.includes('- [X] I am using a beta version of Cline') || body.includes('- [x] I am using a beta version of Cline')) {
+              if (!labels.includes('beta')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['beta']
+                });
+              }
+            }
diff --git a/.github/workflows/repo-stale-issues.yml b/.github/workflows/repo-stale-issues.yml
new file mode 100644
index 0000000..f0a33a8
--- /dev/null
+++ b/.github/workflows/repo-stale-issues.yml
@@ -0,0 +1,25 @@
+# This workflow will only label and/or close 30 issues at a time in order to avoid exceeding a rate limit.
+# More info: https://docs.github.com/en/actions/use-cases-and-examples/project-management/closing-inactive-issues
+name: repo-stale-issues
+on:
+    schedule:
+        - cron: "30 1 * * *"
+
+jobs:
+    close-issues:
+        runs-on: ubuntu-latest
+        permissions:
+            issues: write
+            pull-requests: write
+        steps:
+            - uses: actions/stale@v9
+              with:
+                  days-before-issue-stale: 60
+                  days-before-issue-close: 14
+                  stale-issue-label: "stale"
+                  stale-issue-message: "This issue is stale because it has been open for 60 days with no activity."
+                  close-issue-message: "This issue was closed because it has been inactive for 14 days since being marked as stale."
+                  days-before-pr-stale: -1
+                  days-before-pr-close: -1
+                  exempt-issue-labels: "pinned,security"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/sdk-publish.yml b/.github/workflows/sdk-publish.yml
new file mode 100644
index 0000000..cd33462
--- /dev/null
+++ b/.github/workflows/sdk-publish.yml
@@ -0,0 +1,282 @@
+name: sdk-publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      channel:
+        description: "Publish channel"
+        required: true
+        type: choice
+        options:
+          - nightly
+          - latest
+        default: nightly
+      force_publish:
+        description: "Force publish even if there are no commits in the last 24 hours"
+        required: false
+        type: boolean
+        default: false
+      confirm_publish:
+        description: 'Required when channel=latest. Type "publish" to confirm release publish.'
+        required: false
+        type: string
+  schedule:
+    # Run nightly at 2:00 AM UTC
+    - cron: "0 2 * * *"
+
+defaults:
+  run:
+    working-directory: .
+
+jobs:
+  test:
+    permissions:
+      contents: read
+    uses: ./.github/workflows/sdk-test.yml
+
+  publish-sdk:
+    needs: test
+    name: Publish SDK Packages
+    permissions:
+      contents: write
+      id-token: write
+    if: |
+      github.repository == 'cline/cline' &&
+      github.ref == 'refs/heads/main' &&
+      (
+        github.event_name != 'workflow_dispatch' ||
+        inputs.channel != 'latest' ||
+        (
+          inputs.confirm_publish == 'publish' &&
+          !endsWith(github.actor, '[bot]')
+        )
+      )
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Determine publish channel
+        id: channel
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          INPUT_CHANNEL: ${{ inputs.channel }}
+        run: |
+          # Default to nightly for scheduled runs
+          if [ "$EVENT_NAME" = "schedule" ]; then
+            echo "channel=nightly" >> $GITHUB_OUTPUT
+          else
+            echo "channel=$INPUT_CHANNEL" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Check for recent commits
+        id: check_commits
+        env:
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+          FORCE_PUBLISH: ${{ inputs.force_publish }}
+        run: |
+          # Always publish for latest (production) releases
+          if [ "$CHANNEL" = "latest" ]; then
+            echo "Production release requested, proceeding with publish"
+            echo "skip=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          if [ "$FORCE_PUBLISH" = "true" ]; then
+            echo "force_publish enabled, proceeding with publish"
+            echo "skip=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          if [ "$(git rev-list --count HEAD --since="24 hours ago")" -eq 0 ]; then
+            echo "No commits in last 24 hours, skipping publish"
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "Found recent commits, proceeding with publish"
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Verify trusted publishing context
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          if [ -z "${ACTIONS_ID_TOKEN_REQUEST_TOKEN:-}" ] || [ -z "${ACTIONS_ID_TOKEN_REQUEST_URL:-}" ]; then
+            echo "GitHub OIDC request environment is unavailable. Ensure this job has id-token: write for npm trusted publishing."
+            exit 1
+          fi
+          echo "GitHub OIDC request environment is available for npm trusted publishing."
+
+      - name: Setup Bun
+        if: steps.check_commits.outputs.skip != 'true'
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Setup Node.js
+        if: steps.check_commits.outputs.skip != 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24.x"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Verify publish tooling
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          NPM_VERSION=$(npm --version)
+          echo "npm ${NPM_VERSION}"
+          IFS=. read -r major minor patch <<EOF
+          ${NPM_VERSION}
+          EOF
+          if [ "$major" -lt 11 ] || { [ "$major" -eq 11 ] && [ "$minor" -lt 5 ]; } || { [ "$major" -eq 11 ] && [ "$minor" -eq 5 ] && [ "$patch" -lt 1 ]; }; then
+            echo "npm 11.5.1 or newer is required for trusted publishing"
+            exit 1
+          fi
+
+      - name: Install dependencies
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun install
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build SDK
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun run build:sdk
+
+      - name: Generate shared version
+        if: steps.check_commits.outputs.skip != 'true'
+        id: version
+        env:
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+        run: |
+          BASE_VERSION=$(node -p "require('./sdk/packages/llms/package.json').version")
+
+          if [ "$CHANNEL" = "nightly" ]; then
+            TIMESTAMP=$(date +%s)
+            VERSION="${BASE_VERSION}-nightly.${TIMESTAMP}"
+          else
+            VERSION="$BASE_VERSION"
+          fi
+
+          echo "Base version: $BASE_VERSION"
+          echo "Channel: $CHANNEL"
+          echo "Publish version: $VERSION"
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Update all package versions and lockfile
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: bun sdk/scripts/version.ts "$VERSION"
+
+      - name: Verify publishability
+        if: steps.check_commits.outputs.skip != 'true'
+        run: bun sdk/scripts/check-publish.ts
+
+      - name: Prepare package tarball directory
+        if: steps.check_commits.outputs.skip != 'true'
+        run: mkdir -p "$RUNNER_TEMP/sdk-npm-packs"
+
+      # Pack with Bun so workspace/catalog protocols are resolved in the tarball,
+      # then publish that tarball with npm so npm trusted publishing can use GitHub OIDC.
+      # Publish sequentially in dependency order: shared → llms → agents → core → sdk
+      - name: Publish @cline/shared
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Publishing @cline/shared@${VERSION} with tag '${CHANNEL}'..."
+          cd sdk/packages/shared
+          TARBALL=$(bun pm pack --destination "$RUNNER_TEMP/sdk-npm-packs" --quiet)
+          npm publish "$RUNNER_TEMP/sdk-npm-packs/$(basename "$TARBALL")" --tag "$CHANNEL" --access public
+
+      - name: Publish @cline/llms
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Publishing @cline/llms@${VERSION} with tag '${CHANNEL}'..."
+          cd sdk/packages/llms
+          TARBALL=$(bun pm pack --destination "$RUNNER_TEMP/sdk-npm-packs" --quiet)
+          npm publish "$RUNNER_TEMP/sdk-npm-packs/$(basename "$TARBALL")" --tag "$CHANNEL" --access public
+
+      - name: Publish @cline/agents
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Publishing @cline/agents@${VERSION} with tag '${CHANNEL}'..."
+          cd sdk/packages/agents
+          TARBALL=$(bun pm pack --destination "$RUNNER_TEMP/sdk-npm-packs" --quiet)
+          npm publish "$RUNNER_TEMP/sdk-npm-packs/$(basename "$TARBALL")" --tag "$CHANNEL" --access public
+
+      - name: Publish @cline/core
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Publishing @cline/core@${VERSION} with tag '${CHANNEL}'..."
+          cd sdk/packages/core
+          TARBALL=$(bun pm pack --destination "$RUNNER_TEMP/sdk-npm-packs" --quiet)
+          npm publish "$RUNNER_TEMP/sdk-npm-packs/$(basename "$TARBALL")" --tag "$CHANNEL" --access public
+
+      - name: Publish @cline/sdk
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NPM_CONFIG_PROVENANCE: "true"
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          echo "Publishing @cline/sdk@${VERSION} with tag '${CHANNEL}'..."
+          cd sdk/packages/sdk
+          TARBALL=$(bun pm pack --destination "$RUNNER_TEMP/sdk-npm-packs" --quiet)
+          npm publish "$RUNNER_TEMP/sdk-npm-packs/$(basename "$TARBALL")" --tag "$CHANNEL" --access public
+
+      - name: Create package tags for production publish
+        if: steps.check_commits.outputs.skip != 'true' && steps.channel.outputs.channel == 'latest'
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          for PKG in shared llms agents core sdk; do
+            TAG="sdk/${PKG}/v${VERSION}"
+            if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null; then
+              echo "Tag already exists locally: ${TAG}"
+            else
+              git tag -a "${TAG}" -m "@cline/${PKG}@${VERSION}"
+              echo "Created tag: ${TAG}"
+            fi
+
+            # Ensure remote has the tag; this is idempotent if tag already exists remotely.
+            git push origin "refs/tags/${TAG}"
+          done
+
+      - name: Summary
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+          CHANNEL: ${{ steps.channel.outputs.channel }}
+        run: |
+          echo "Published SDK packages with tag '${CHANNEL}':"
+          echo "  - @cline/shared@${VERSION}"
+          echo "  - @cline/llms@${VERSION}"
+          echo "  - @cline/agents@${VERSION}"
+          echo "  - @cline/core@${VERSION}"
+          echo "  - @cline/sdk@${VERSION}"
+          if [ "$CHANNEL" = "latest" ]; then
+            echo "Created git tags:"
+            echo "  - sdk/shared/v${VERSION}"
+            echo "  - sdk/llms/v${VERSION}"
+            echo "  - sdk/agents/v${VERSION}"
+            echo "  - sdk/core/v${VERSION}"
+            echo "  - sdk/sdk/v${VERSION}"
+          fi
diff --git a/.github/workflows/sdk-test.yml b/.github/workflows/sdk-test.yml
new file mode 100644
index 0000000..17f24a2
--- /dev/null
+++ b/.github/workflows/sdk-test.yml
@@ -0,0 +1,112 @@
+name: sdk-test
+
+on:
+    push:
+        branches:
+            - main
+        paths:
+            - "sdk/**"
+            - ".github/workflows/sdk-test.yml"
+    workflow_dispatch:
+    pull_request:
+        branches:
+            - main
+        paths:
+            - "sdk/**"
+            - ".github/workflows/sdk-test.yml"
+    workflow_call:
+
+permissions:
+    contents: read
+
+defaults:
+    run:
+        working-directory: .
+
+jobs:
+    quality-checks:
+        runs-on: ubuntu-latest
+        name: Quality Checks
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: "1.3.13"
+
+            - name: Install dependencies
+              run: bun install
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Typecheck
+              run: |
+                  bun run build:sdk
+                  bun run -F @cline/cli build
+                  bun run types
+
+            - name: Lint & Format
+              run: bun run lint
+
+    test:
+        needs: quality-checks
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                    - os: ubuntu-latest
+                      node-version: "24.x"
+                    - os: windows-latest
+                      node-version: "24.x"
+        runs-on: ${{ matrix.os }}
+        name: Test (${{ matrix.os }}, Node ${{ matrix.node-version }})
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: "1.3.13"
+
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: ${{ matrix.node-version }}
+
+            - name: Install dependencies
+              run: bun install
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Build SDK
+              id: build_sdk_step
+              run: bun run build:sdk
+
+            - name: Build CLI
+              id: build_cli_step
+              if: ${{ !cancelled() && steps.build_sdk_step.outcome == 'success' }}
+              run: bun -F @cline/cli build
+
+            - name: Run Tests
+              if: ${{ !cancelled() && steps.build_sdk_step.outcome == 'success' && steps.build_cli_step.outcome == 'success' && matrix.os != 'windows-latest' }}
+              run: bun run test
+
+            - name: Run SDK Tests (Windows)
+              if: ${{ !cancelled() && steps.build_sdk_step.outcome == 'success' && steps.build_cli_step.outcome == 'success' && matrix.os == 'windows-latest' }}
+              run: bun -F './sdk/packages/**' test
+
+            - name: Smoke test SQLite under Node
+              if: ${{ !cancelled() && steps.build_sdk_step.outcome == 'success' && matrix.os != 'windows-latest' }}
+              timeout-minutes: 10
+              run: bun sdk/scripts/ci-node-smoke.ts
+
+            - name: Run TUI e2e tests
+              if: ${{ !cancelled() && steps.build_sdk_step.outcome == 'success' && steps.build_cli_step.outcome == 'success' && matrix.os == 'ubuntu-latest' && matrix.node-version == '24.x' }}
+              run: bun -F @cline/cli test:e2e:cli:tui
+
+            - name: Verify packages are publishable
+              if: ${{ !cancelled() && steps.build_sdk_step.outcome == 'success' && steps.build_cli_step.outcome == 'success' && matrix.os == 'ubuntu-latest' && matrix.node-version == '24.x' }}
+              run: bun sdk/scripts/check-publish.ts
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ce1a878
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,94 @@
+out
+dist
+dist-standalone
+node_modules
+tmp
+.vscode-test/
+*.vsix
+
+.DS_Store
+.idea
+.husky/_/
+
+pnpm-lock.yaml
+
+.clineignore
+.cline/enterprise
+.cline/remote-config
+**/.cline/remote-config
+.venv
+.actrc
+CLAUDE.local.md
+
+apps/vscode/webview-ui/src/**/*.js
+apps/vscode/webview-ui/src/**/*.js.map
+
+# Ignore coverage directories and files
+coverage
+coverage-unit
+.nyc_output
+# But don't ignore the coverage scripts in .github/scripts/
+!.github/scripts/coverage/
+
+*evals.env
+.env
+.secrets
+.github/act/.secrets
+
+.worktrees
+
+## Generated files ##
+apps/vscode/src/generated/
+apps/vscode/src/shared/proto/
+apps/vscode/webview-ui/src/services/grpc-client.ts
+*.tsbuildinfo
+
+# E2E Tests
+test-results
+
+/.github/act
+/pkg
+.secrets
+
+*.tsbuildinfo
+
+# Smoke test results (generated)
+evals/smoke-tests/results/
+
+.tui-test
+secrets.json
+tui-traces
+tests/**/cache
+
+# Backup created by scripts/marketplace-readme.mjs while publishing.
+# Should never be committed: only exists if a publish aborts mid-swap.
+.README.github.bak
+
+# Tauri generated code
+apps/*/src-tauri/gen
+apps/*/src-tauri/bin
+apps/examples/*/src-tauri/gen
+apps/examples/*/src-tauri/bin
+# Tauri UI test snapshots
+apps/*/src/tests/.tui-test
+apps/*/src/tests/tui-traces
+apps/vscode/webview-ui/src/**/*.js
+apps/vscode/webview-ui/src/**/*.js.map
+
+
+# SDK Session files / User data
+.cline/data
+.cline/tmp
+*.db
+*.db-shm
+*.db-wal
+.cline/**/managed.json
+.cline/**/bundle.json
+apps/vscode/tsconfig.test.generated.json
+.next/dev/static
+**/src-tauri/target/debug/.fingerprint
+apps/examples/desktop-app/src-tauri/target
+apps/examples/desktop-app/webview/.next
+
+# Next.js generated type shim (churns between dev and build)
+apps/examples/desktop-app/webview/next-env.d.ts
diff --git a/.gitleaks.toml b/.gitleaks.toml
new file mode 100644
index 0000000..c0626f5
--- /dev/null
+++ b/.gitleaks.toml
@@ -0,0 +1,4 @@
+title = "Cline SDK secret scanning"
+
+[extend]
+useDefault = true
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..929ec96
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "evals/cline-bench"]
+	path = evals/cline-bench
+	url = https://github.com/cline/cline-bench.git
diff --git a/.greptile/config.json b/.greptile/config.json
new file mode 100644
index 0000000..3a28fab
--- /dev/null
+++ b/.greptile/config.json
@@ -0,0 +1,44 @@
+{
+	"strictness": 2,
+	"triggerOnUpdates": true,
+	"statusCheck": true,
+	"rules": [
+		{
+			"id": "sdk-tool-handler-telemetry",
+			"rule": "Any new tool handler added to packages/agents/src or packages/core/src that performs a user-visible action (writes files, executes commands, modifies state, calls external APIs) must include a call to captureToolUsage() from packages/core/src/services/telemetry/core-events.ts, or emit a task.tool_used event via telemetry.capture(). Pure read-only helpers and getters are exempt. When in doubt, prefer instrumentation.",
+			"scope": [
+				"sdk/packages/agents/src/**",
+				"sdk/packages/core/src/**"
+			],
+			"severity": "high"
+		},
+		{
+			"id": "sdk-session-lifecycle-telemetry",
+			"rule": "New session start, end, or state-transition code paths in packages/core/src must call the appropriate typed helper from packages/core/src/services/telemetry/core-events.ts (captureTaskCreated, captureTaskCompleted, captureConversationTurnEvent, captureTokenUsage, etc.). Do not inline raw telemetry.capture() calls for session lifecycle events — always use the typed helper, which guarantees a consistent payload shape.",
+			"scope": [
+				"sdk/packages/core/src/cline-core/**",
+				"sdk/packages/core/src/runtime/**"
+			],
+			"severity": "high"
+		},
+		{
+			"id": "sdk-no-raw-event-strings",
+			"rule": "All telemetry event name strings must be sourced from CORE_TELEMETRY_EVENTS in packages/core/src/services/telemetry/core-events.ts. If a PR introduces a string literal in a telemetry.capture(), telemetry.captureRequired(), or recordCounter()/recordHistogram()/recordGauge() call that does not reference CORE_TELEMETRY_EVENTS, flag it. New events must be added to CORE_TELEMETRY_EVENTS first, with a typed capture helper created alongside them.",
+			"scope": [
+				"sdk/packages/core/src/**",
+				"sdk/packages/agents/src/**",
+				"apps/cli/src/**",
+				"apps/vscode/src/**"
+			],
+			"severity": "medium"
+		},
+		{
+			"id": "sdk-auth-telemetry-completeness",
+			"rule": "Any new OAuth or authentication provider added under packages/core/src/auth must emit all four lifecycle events using the typed helpers from core-events.ts: captureAuthStarted (at flow entry), captureAuthSucceeded + identifyAccount (on token success), captureAuthFailed (on error), and captureAuthLoggedOut (on token invalidation or explicit logout). Flag PRs that introduce a new auth flow file without all four. Cross-reference packages/core/src/auth/cline.ts and packages/core/src/auth/codex.ts as canonical examples.",
+			"scope": [
+				"sdk/packages/core/src/auth/**"
+			],
+			"severity": "high"
+		}
+	]
+}
diff --git a/.greptile/files.json b/.greptile/files.json
new file mode 100644
index 0000000..02a4692
--- /dev/null
+++ b/.greptile/files.json
@@ -0,0 +1,28 @@
+{
+	"files": [
+		{
+			"path": "sdk/packages/core/src/services/telemetry/core-events.ts",
+			"description": "Single source of truth for all telemetry event names (CORE_TELEMETRY_EVENTS) and their typed capture helper functions. Every PR touching telemetry must be evaluated against this catalog. New events must be defined here first."
+		},
+		{
+			"path": "sdk/packages/shared/src/services/telemetry.ts",
+			"description": "ITelemetryService interface definition. Defines the contract all telemetry implementations must satisfy (capture, captureRequired, recordCounter, recordHistogram, recordGauge, flush, dispose)."
+		},
+		{
+			"path": "sdk/packages/core/src/services/telemetry/TelemetryService.ts",
+			"description": "Reference implementation of ITelemetryService used by all hosts. Multi-adapter fan-out service that forwards events to OpenTelemetry."
+		},
+		{
+			"path": "sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.ts",
+			"description": "OpenTelemetry-backed provider that wires logs/metrics/traces exporters. Contains createConfiguredTelemetryService and createConfiguredTelemetryHandle, the canonical factories every host should use."
+		},
+		{
+			"path": "sdk/ARCHITECTURE.md",
+			"description": "Architecture reference. Telemetry design decisions and completion semantics (submit_and_exit anchoring) are documented here. Use as ground truth for design intent."
+		},
+		{
+			"path": "sdk/AGENTS.md",
+			"description": "Package boundary rules. Telemetry runtime services live in @cline/core; @cline/agents must not own stateful telemetry. Use to evaluate whether a telemetry change is being made in the correct package."
+		}
+	]
+}
diff --git a/.greptile/rules.md b/.greptile/rules.md
new file mode 100644
index 0000000..51c98ab
--- /dev/null
+++ b/.greptile/rules.md
@@ -0,0 +1,145 @@
+# SDK Telemetry Standards
+
+These rules supplement `config.json`. The structured rules describe **what** to enforce; this
+document explains **why**, so Greptile has the context to avoid false positives.
+
+## Telemetry Stack
+
+The SDK uses OpenTelemetry (OTEL) as its sole telemetry transport. Events flow through:
+
+```
+core-events.ts (event catalog + typed helpers)
+       ↓
+ITelemetryService (sdk/packages/shared)             ← interface contract
+       ↓
+TelemetryService (sdk/packages/core)                ← multi-adapter fan-out
+       ↓
+OpenTelemetryAdapter → OpenTelemetryProvider    ← OTLP transport
+       ↓
+OTLP endpoint (collector or vendor)
+```
+
+The SDK does **not** depend on the original `cline/cline` repo for telemetry. The two have
+parallel-but-independent stacks; this `.greptile/` config covers only the SDK.
+
+## The Single Source of Truth
+
+`sdk/packages/core/src/services/telemetry/core-events.ts` is the single source of truth for all
+event names. It exports:
+
+- `CORE_TELEMETRY_EVENTS` — a frozen const object grouped by family
+  (`CLIENT`, `SESSION`, `USER`, `TASK`, `HOOKS`, `WORKSPACE`)
+- A typed `capture*()` helper for every event family
+  (`captureExtensionActivated`, `captureTaskCreated`, `captureToolUsage`, etc.)
+
+**Never use raw string literals for event names at call sites.** A new event always means:
+
+1. Add the constant to `CORE_TELEMETRY_EVENTS`
+2. Add a typed `capture*()` helper alongside it (with a typed `properties` parameter)
+3. Add a unit test in `core-events.test.ts` asserting the event flows through the
+   opt-out-respecting `capture` path and never `captureRequired` (opt-out is enforced by
+   `OptedOutTelemetryService`, whose `capture` is a no-op — the test convention is
+   "emits X as a normal opt-out-respecting event"). Events that intentionally bypass
+   opt-out must use `captureRequired` and assert that explicitly.
+
+## The Activation Funnel
+
+The canonical funnel that downstream analytics depends on:
+
+```
+user.extension_activated
+  → workspace.initialized
+  → workspace.path_resolved (gated on multi-root)
+  → task.created
+  → task.conversation_turn (one per turn, source: "user" | "assistant")
+  → task.completed (source: "submit_and_exit" | "shutdown")
+```
+
+Emission ownership:
+
+- `user.extension_activated`: emitted **once per host process** by host-specific helpers
+  (`captureCliExtensionActivated` for the CLI, `captureExtensionActivated` for VS Code).
+- `workspace.initialized` / `workspace.init_error`: emitted by a per-process de-duplicated
+  emitter in `prepareLocalRuntimeBootstrap`. Hosts must NOT re-emit these.
+- `workspace.path_resolved`: emitted from default tool executors **only when**
+  `WorkspaceManager` exposes more than one root.
+- `task.*`: emitted by core session lifecycle code in `sdk/packages/core/src/cline-core/` and
+  `sdk/packages/core/src/runtime/`. Hosts must not duplicate this emission.
+
+## `task.completed` Semantics
+
+`task.completed` marks the moment the **assistant declared the task done**, not the moment
+the SDK session record was finalized. The local runtime emits it when it observes a successful
+`submit_and_exit` tool call (the SDK analog of original Cline's `attempt_completion`). For
+non-interactive runs that finish without invoking the explicit completion tool,
+`shutdownSession` emits it as a fallback with `source: "shutdown"`.
+
+Each session is guaranteed at most one `task.completed` emission. The `source` field
+(`"submit_and_exit" | "shutdown"`) is required for analytics attribution.
+
+## CLI Directory-Ordering Rule
+
+The CLI accepts `--config <dir>`. The CLI **must** apply `setClineDir(...)` and
+`setHomeDir(...)` from `@cline/shared/storage` **before** calling
+`captureCliExtensionActivated()`. Otherwise the telemetry singleton's persisted distinct-id
+and any other on-disk telemetry state lands under `~/.cline` instead of the user's chosen
+config dir.
+
+The canonical pattern is in `apps/cli/src/main.ts`:
+
+```ts
+if (configDir) setClineDir(configDir);
+setHomeDir(homedir());
+captureCliExtensionActivated();   // <-- after dir overrides
+```
+
+## Hub Daemon Telemetry
+
+The detached hub daemon (`sdk/packages/core/src/hub/daemon/entry.ts`) hosts the
+`LocalRuntimeHost` that emits `task.conversation_turn` and `task.tokens` for every
+hub-backed session, so the daemon must own its own `ITelemetryService`. It builds one via
+`createHubDaemonTelemetry()` (`sdk/packages/core/src/hub/daemon/telemetry.ts`), which
+identifies from the cached cline account (re-resolved periodically, since the daemon often
+starts before login) and flushes on every shutdown path, including startup failure.
+
+Flag changes that remove this wiring, construct runtime hosts inside the daemon without
+passing its telemetry handle, or add daemon exit paths that skip the flush — hub-backed
+sessions would silently drop their lifecycle telemetry (this exact bug shipped once).
+
+## Auth Lifecycle Completeness
+
+Every authentication provider in `sdk/packages/core/src/auth/` must emit all four auth lifecycle
+events using the typed helpers:
+
+| Phase | Helper | Where it fires |
+|---|---|---|
+| Flow entry | `captureAuthStarted(provider)` | Top of the OAuth flow function |
+| Token success | `captureAuthSucceeded(provider)` + `identifyAccount(...)` | After successful token exchange |
+| Token error | `captureAuthFailed(provider, errorMessage)` | In the catch block |
+| Token invalidation | `captureAuthLoggedOut(provider, reason)` | On invalid_grant or explicit logout |
+
+Cross-reference `sdk/packages/core/src/auth/cline.ts` and `sdk/packages/core/src/auth/codex.ts` as
+canonical examples of all four phases.
+
+## Single Telemetry Service Per Host
+
+On VS Code, all callers go through the lazy `telemetryService` proxy in
+`apps/vscode/src/services/telemetry/index.ts`, which constructs the service once on first
+use. Do not let individual controllers construct their own `ITelemetryService` — that
+fragments distinct-id state, opt-out tracking, and flush ownership.
+
+The CLI follows the same pattern via the `getCliTelemetryService()` singleton in
+`apps/cli/src/utils/telemetry.ts`, which is memoized by the activation gate in
+`telemetry.activation-gate.ts`.
+
+## Common False-Positive Adjustments
+
+If Greptile flags one of the following, the rule is **not** violated:
+
+- A telemetry call that is wrapped in a host-specific helper (e.g.
+  `captureCliExtensionActivated` wrapping `captureExtensionActivated`) — the inner helper
+  is the typed call.
+- `enterprise.*` events emitted from `apps/cli/src/utils/enterprise.ts` — these are
+  enterprise-side events not yet in `CORE_TELEMETRY_EVENTS`; they are tracked separately.
+- A new test file that uses raw event name strings inside `expect(...)` assertions — tests
+  may reference event names as strings to assert what was emitted.
diff --git a/.husky/pre-commit b/.husky/pre-commit
new file mode 100644
index 0000000..e9727ed
--- /dev/null
+++ b/.husky/pre-commit
@@ -0,0 +1,11 @@
+if ! command -v gitleaks >/dev/null 2>&1; then
+	echo "gitleaks is required for the pre-commit secret scan."
+	echo "Install it with: brew install gitleaks"
+	echo "Other install options: https://github.com/gitleaks/gitleaks#installing"
+	exit 1
+fi
+
+gitleaks git --pre-commit --redact --staged --verbose || exit 1
+
+cd apps/vscode && bunx lint-staged
+
diff --git a/.kanban/config.json b/.kanban/config.json
new file mode 100644
index 0000000..c31573d
--- /dev/null
+++ b/.kanban/config.json
@@ -0,0 +1,9 @@
+{
+	"shortcuts": [
+		{
+			"label": "Build & Link CLI",
+			"command": "bun -F @cline/cli build && bun -F @cline/cli link",
+			"icon": "play"
+		}
+	]
+}
diff --git a/.nvmrc b/.nvmrc
new file mode 100644
index 0000000..8fdd954
--- /dev/null
+++ b/.nvmrc
@@ -0,0 +1 @@
+22
\ No newline at end of file
diff --git a/.tool-versions b/.tool-versions
new file mode 100644
index 0000000..05b561a
--- /dev/null
+++ b/.tool-versions
@@ -0,0 +1,3 @@
+
+bun 1.3.13
+node 22
\ No newline at end of file
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 0000000..54205ad
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,11 @@
+{
+	// See http://go.microsoft.com/fwlink/?LinkId=827846
+	// for the documentation about the extensions.json format
+	"recommendations": [
+		"connor4312.esbuild-problem-matchers",
+		"ms-vscode.extension-test-runner",
+		"bradlc.vscode-tailwindcss",
+		"biomejs.biome",
+		"oven.bun-vscode"
+	]
+}
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..0e5f7cf
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,314 @@
+// A launch configuration that compiles the extension and then opens it inside a new window
+// Use IntelliSense to learn about possible attributes.
+// Hover to view descriptions of existing attributes.
+// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Run Extension (production)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}/apps/vscode",
+				"--disable-workspace-trust",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"${workspaceFolder}/apps/vscode",
+				"--disable-extensions"
+			],
+			"outFiles": [
+				"${workspaceFolder}/apps/vscode/dist/**/*.js"
+			],
+			"preLaunchTask": "${defaultBuildTask}",
+			"envFile": "${workspaceFolder}/apps/vscode/.env",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}/apps/vscode",
+				"CLINE_ENVIRONMENT": "production"
+			}
+		},
+		{
+			"name": "Run Extension (staging)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}/apps/vscode",
+				"--disable-workspace-trust",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"${workspaceFolder}/apps/vscode"
+			],
+			"outFiles": [
+				"${workspaceFolder}/apps/vscode/dist/**/*.js"
+			],
+			"preLaunchTask": "${defaultBuildTask}",
+			"envFile": "${workspaceFolder}/apps/vscode/.env",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}/apps/vscode",
+				"CLINE_ENVIRONMENT": "staging"
+			}
+		},
+		{
+			"name": "Run Extension (local)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}/apps/vscode",
+				"--disable-workspace-trust",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"${workspaceFolder}/apps/vscode"
+			],
+			"outFiles": [
+				"${workspaceFolder}/apps/vscode/dist/**/*.js"
+			],
+			"preLaunchTask": "${defaultBuildTask}",
+			"envFile": "${workspaceFolder}/apps/vscode/.env",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}/apps/vscode",
+				"CLINE_ENVIRONMENT": "local"
+			}
+		},
+		{
+			"name": "Run Extension (Fresh Install Mode)",
+			"type": "extensionHost",
+			"request": "launch",
+			"runtimeExecutable": "${execPath}",
+			"args": [
+				"--user-data-dir=${workspaceFolder}/apps/vscode/dist/tmp/user",
+				"--profile-temp",
+				"--sync=off",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"--extensionDevelopmentPath=${workspaceFolder}/apps/vscode",
+				"${workspaceFolder}/apps/vscode"
+			],
+			"outFiles": [
+				"${workspaceFolder}/apps/vscode/dist/**/*.js"
+			],
+			"preLaunchTask": "clean-tmp-user",
+			"internalConsoleOptions": "openOnSessionStart",
+			"postDebugTask": "stop",
+			"envFile": "${workspaceFolder}/apps/vscode/.env",
+			"env": {
+				"IS_DEV": "true",
+				"TEMP_PROFILE": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}/apps/vscode",
+				"CLINE_ENVIRONMENT": "production"
+			}
+		},
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Debug Test Standalone Core Api Server (test:sca-server)",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
+			"sourceMaps": true,
+			"resolveSourceMapLocations": [
+				"${workspaceFolder}/apps/vscode/**",
+				"!**/node_modules/**"
+			],
+			"cwd": "${workspaceFolder}/apps/vscode",
+			"outFiles": [
+				"${workspaceFolder}/apps/vscode/dist/**/*.js",
+				"${workspaceFolder}/apps/vscode/dist-standalone/**/*.js"
+			],
+			"preLaunchTask": "compile-standalone",
+			"runtimeExecutable": "bun",
+			"program": "scripts/test-standalone-core-api-server.ts",
+			"envFile": "${workspaceFolder}/apps/vscode/.env",
+			"env": {
+				"PROTOBUS_PORT": "26040",
+				"HOSTBRIDGE_PORT": "26041",
+				"WORKSPACE_DIR": "${workspaceFolder}/apps/vscode",
+				"E2E_TEST": "true",
+				"CLINE_ENVIRONMENT": "local"
+			},
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "neverOpen"
+		},
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Debug Current Test File",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
+			"sourceMaps": true,
+			"resolveSourceMapLocations": [
+				"${workspaceFolder}/apps/vscode/**",
+				"!**/node_modules/**"
+			],
+			"cwd": "${workspaceFolder}/apps/vscode",
+			"runtimeExecutable": "npx",
+			"runtimeArgs": [
+				"mocha"
+			],
+			"args": [
+				"--require",
+				"ts-node/register",
+				"--require",
+				"source-map-support/register",
+				"--require",
+				"./src/test/requires.ts",
+				"--exit",
+				"${file}"
+			],
+			"envFile": "${workspaceFolder}/apps/vscode/.env",
+			"env": {
+				"TS_NODE_PROJECT": "./tsconfig.unit-test.json",
+				"NODE_ENV": "test",
+				"IS_DEV": "true",
+				"CLINE_ENVIRONMENT": "local"
+			},
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "openOnSessionStart"
+		},
+		{
+			"name": "Open Storybook",
+			"type": "node",
+			"request": "launch",
+			"runtimeExecutable": "bun",
+			"runtimeArgs": [
+				"run",
+				"storybook"
+			],
+			"cwd": "${workspaceFolder}/apps/vscode/webview-ui",
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "neverOpen",
+			"serverReadyAction": {
+				"pattern": "Local:.*http://localhost:([0-9]+)",
+				"uriFormat": "http://localhost:%s",
+				"action": "openExternally"
+			},
+			"env": {
+				"IS_DEV": "true"
+			}
+		},
+		{
+			"name": "Launch Bun CLI (Prompt)",
+			"type": "bun",
+			"request": "launch",
+			"cwd": "${workspaceFolder}/sdk/apps/cli",
+			"runtime": "bun",
+			"runtimeArgs": [
+				"--conditions=development"
+			],
+			"program": "${workspaceFolder}/sdk/apps/cli/src/index.ts",
+			"args": [
+				"${input:cliPrompt}"
+			],
+			"env": {
+				"CLINE_BUILD_ENV": "development"
+			},
+			"presentation": {
+				"hidden": true
+			}
+		},
+		{
+			"name": "Launch RPC Server",
+			"type": "bun",
+			"request": "launch",
+			"cwd": "${workspaceFolder}/sdk/apps/cli",
+			"runtime": "bun",
+			"runtimeArgs": [
+				"--conditions=development"
+			],
+			"program": "${workspaceFolder}/sdk/apps/cli/src/index.ts",
+			"args": [
+				"rpc",
+				"start"
+			],
+			"env": {
+				"CLINE_BUILD_ENV": "development",
+				"CLINE_DEBUG_PORT_BASE": "9230"
+			},
+			"presentation": {
+				"hidden": true
+			}
+		},
+		{
+			"name": "Attach RPC Runtime (9230)",
+			"type": "bun",
+			"request": "attach",
+			"url": "ws://127.0.0.1:9230",
+			"localRoot": "${workspaceFolder}/sdk",
+			"remoteRoot": "${workspaceFolder}/sdk",
+			"presentation": {
+				"hidden": true
+			}
+		},
+		{
+			"name": "Attach Hook Worker (9231)",
+			"type": "bun",
+			"request": "attach",
+			"url": "ws://127.0.0.1:9231",
+			"localRoot": "${workspaceFolder}/sdk",
+			"remoteRoot": "${workspaceFolder}/sdk",
+			"presentation": {
+				"hidden": true
+			}
+		},
+		{
+			"name": "Attach Plugin Sandbox (9232)",
+			"type": "bun",
+			"request": "attach",
+			"url": "ws://127.0.0.1:9232",
+			"localRoot": "${workspaceFolder}/sdk",
+			"remoteRoot": "${workspaceFolder}/sdk",
+			"presentation": {
+				"hidden": true
+			}
+		},
+		{
+			"name": "Attach Connector Child (9233)",
+			"type": "bun",
+			"request": "attach",
+			"url": "ws://127.0.0.1:9233",
+			"localRoot": "${workspaceFolder}/sdk",
+			"remoteRoot": "${workspaceFolder}/sdk",
+			"presentation": {
+				"hidden": true
+			}
+		}
+	],
+	"compounds": [
+		{
+			"name": "Launch RPC Server Debugger",
+			"configurations": [
+				"Launch RPC Server",
+				"Attach RPC Runtime (9230)"
+			]
+		},
+		{
+			"name": "Launch CLI Debugger",
+			"configurations": [
+				"Launch Bun CLI (Prompt)",
+				"Attach RPC Runtime (9230)",
+				"Attach Hook Worker (9231)",
+				"Attach Plugin Sandbox (9232)",
+				"Attach Connector Child (9233)"
+			]
+		}
+	],
+	"inputs": [
+		{
+			"id": "cliPrompt",
+			"type": "promptString",
+			"description": "Prompt to send to the CLI",
+			"default": "hey"
+		}
+	]
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..69f81f4
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,47 @@
+// Place your settings in this file to overwrite default and user settings.
+{
+	"files.insertFinalNewline": true,
+	"files.exclude": {
+		"out": false, // set this to true to hide the "out" folder with the compiled JS files
+		"dist": false // set this to true to hide the "dist" folder with the compiled JS files
+	},
+	"search.exclude": {
+		"out": true, // set this to false to include "out" folder in search results
+		"dist": true, // set this to false to include "dist" folder in search results,
+		"node_modules": true,
+		"dist-standalone": true
+	},
+	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
+	"typescript.tsc.autoDetect": "off",
+	"typescript.preferences.quoteStyle": "double",
+	// Protobuf settings
+	"protoc": {
+		"options": [
+			"--proto_path=apps/vscode/proto"
+		]
+	},
+	// Enable Lint and format using Biome
+	"biome.enabled": true,
+	"biome.requireConfiguration": true,
+	"prettier.enable": false,
+	"editor.defaultFormatter": "biomejs.biome",
+	"[javascript]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[javascriptreact]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[typescript]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[typescriptreact]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"editor.codeActionsOnSave": {
+		"source.fixAll.biome": "explicit",
+		"source.removeUnused.biome": "always",
+		"source.organizeImports.biome": "always"
+	},
+	// Disable auto-forwarding ports to prevent Simple Browser from opening the Vite dev server
+	"remote.autoForwardPorts": false
+}
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000..fa931c4
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,344 @@
+// See https://go.microsoft.com/fwlink/?LinkId=733558
+// for the documentation about the tasks.json format
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "compile-standalone",
+			"type": "shell",
+			"command": "bun run compile-standalone",
+			"group": "build",
+			"problemMatcher": [],
+			"presentation": {
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode"
+			}
+		},
+		{
+			"label": "npm: protos",
+			"type": "shell",
+			"command": "bun run protos",
+			"problemMatcher": [],
+			"isBackground": false,
+			"presentation": {
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true"
+				}
+			}
+		},
+		{
+			"label": "watch",
+			"dependsOn": [
+				"npm: protos",
+				"npm: build:webview",
+				"npm: dev:webview",
+				"npm: watch:tsc",
+				"npm: watch:esbuild"
+			],
+			"presentation": {
+				"reveal": "always"
+			},
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			}
+		},
+		{
+			"label": "watch:test",
+			"dependsOn": [
+				"npm: protos",
+				"npm: build:webview:test",
+				"npm: dev:webview",
+				"npm: watch:tsc",
+				"npm: watch:esbuild:test"
+			],
+			"presentation": {
+				"reveal": "always"
+			},
+			"group": "build"
+		},
+		{
+			"type": "shell",
+			"command": "bun run build:webview",
+			"group": "build",
+			"problemMatcher": [],
+			"isBackground": false,
+			"label": "npm: build:webview",
+			"dependsOn": [
+				"npm: protos"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true"
+				}
+			}
+		},
+		{
+			"type": "shell",
+			"command": "bun run build:webview:test",
+			"group": "build",
+			"problemMatcher": [],
+			"isBackground": false,
+			"label": "npm: build:webview:test",
+			"dependsOn": [
+				"npm: protos"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true",
+					"IS_TEST": "true"
+				}
+			}
+		},
+		{
+			"type": "shell",
+			"command": "bun run dev:webview",
+			"group": "build",
+			"problemMatcher": [
+				{
+					"pattern": [
+						{
+							"regexp": "^(?!)((?:.*))$",
+							"kind": "file",
+							"file": 1,
+							"message": 1
+						}
+					],
+					"background": {
+						"activeOnStart": true,
+						"beginsPattern": "^Building webview for|^\\s*VITE",
+						"endsPattern": "^.*Local:\\s+http://127\\.0\\.0\\.1:[0-9]+/"
+					}
+				}
+			],
+			"isBackground": true,
+			"label": "npm: dev:webview",
+			"dependsOn": [
+				"npm: protos"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true"
+				}
+			}
+		},
+		{
+			"type": "shell",
+			"command": "bun run watch:esbuild",
+			"group": "build",
+			"problemMatcher": {
+				"pattern": [
+					{
+						"regexp": "^✘ \\[ERROR\\] (.*)$",
+						"message": 1
+					},
+					{
+						"regexp": "^\\s+(.*):(\\d+):(\\d+):$",
+						"file": 1,
+						"line": 2,
+						"column": 3
+					}
+				],
+				"background": {
+					"activeOnStart": true,
+					"beginsPattern": "^\\[watch\\] build started$",
+					"endsPattern": "^\\[watch\\] build finished$"
+				}
+			},
+			"isBackground": true,
+			"label": "npm: watch:esbuild",
+			"dependsOn": [
+				"npm: protos",
+				"build-sdk:debug"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true"
+				}
+			}
+		},
+		{
+			"type": "shell",
+			"command": "bun run watch:esbuild:test",
+			"group": "build",
+			"problemMatcher": {
+				"pattern": [
+					{
+						"regexp": "^✘ \\[ERROR\\] (.*)$",
+						"message": 1
+					},
+					{
+						"regexp": "^\\s+(.*):(\\d+):(\\d+):$",
+						"file": 1,
+						"line": 2,
+						"column": 3
+					}
+				],
+				"background": {
+					"activeOnStart": true,
+					"beginsPattern": "^\\[watch\\] build started$",
+					"endsPattern": "^\\[watch\\] build finished$"
+				}
+			},
+			"isBackground": true,
+			"label": "npm: watch:esbuild:test",
+			"dependsOn": [
+				"npm: protos",
+				"build-sdk:debug"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true",
+					"IS_TEST": "true"
+				}
+			}
+		},
+		{
+			"type": "shell",
+			"command": "bun run watch:tsc",
+			"group": "build",
+			"problemMatcher": "$tsc-watch",
+			"isBackground": true,
+			"label": "npm: watch:tsc",
+			"dependsOn": [
+				"npm: protos"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode"
+			}
+		},
+		{
+			"type": "shell",
+			"command": "bun run watch-tests",
+			"label": "npm: watch-tests",
+			"problemMatcher": "$tsc-watch",
+			"isBackground": true,
+			"dependsOn": [
+				"npm: protos"
+			],
+			"presentation": {
+				"reveal": "always",
+				"group": "watchers"
+			},
+			"group": "build",
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode"
+			}
+		},
+		{
+			"label": "tasks: watch-tests",
+			"dependsOn": [
+				"npm: protos",
+				"npm: watch",
+				"npm: watch-tests"
+			],
+			"problemMatcher": []
+		},
+		{
+			"label": "stop",
+			"command": "echo ${input:terminate}",
+			"type": "shell"
+		},
+		{
+			"label": "clean-tmp-user",
+			"type": "shell",
+			"dependsOn": [
+				"watch"
+			],
+			"command": "rm -rf ${workspaceFolder}/apps/vscode/dist/tmp/user && mkdir -p ${workspaceFolder}/apps/vscode/dist/tmp/user"
+		},
+		{
+			"type": "shell",
+			"command": "bun run storybook",
+			"group": "build",
+			"problemMatcher": [],
+			"isBackground": false,
+			"label": "npm: storybook",
+			"dependsOn": [
+				"npm: protos",
+				"npm: build:webview"
+			],
+			"presentation": {
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}/apps/vscode",
+				"env": {
+					"IS_DEV": "true"
+				}
+			}
+		},
+		{
+			"label": "build-sdk",
+			"type": "shell",
+			"command": "bun run build:sdk",
+			"problemMatcher": [
+				"$tsc"
+			],
+			"options": {
+				"cwd": "${workspaceFolder}"
+			}
+		},
+		{
+			"label": "build-sdk:debug",
+			"type": "shell",
+			"command": "bun run build:sdk",
+			"problemMatcher": [
+				"$tsc"
+			],
+			"presentation": {
+				"group": "watch",
+				"reveal": "always"
+			},
+			"options": {
+				"cwd": "${workspaceFolder}",
+				"env": {
+					"CLINE_SOURCEMAPS": "1"
+				}
+			}
+		}
+	],
+	"inputs": [
+		{
+			"id": "terminate",
+			"type": "command",
+			"command": "workbench.action.tasks.terminate",
+			"args": "terminateAll"
+		}
+	]
+}
diff --git a/.worktreeinclude b/.worktreeinclude
new file mode 120000
index 0000000..3e4e48b
--- /dev/null
+++ b/.worktreeinclude
@@ -0,0 +1 @@
+.gitignore
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..ef03a66
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,2395 @@
+# Changelog
+
+## [4.0.0]
+
+### Added
+
+- Add the SDK-backed VS Code extension runtime. Cline now runs tasks through the shared Cline SDK session layer for agent turns, tools, Plan/Act mode coordination, MCP, checkpoints, telemetry, provider changes, compaction, mistake limits, and task history.
+- Add ClinePass to the VS Code extension, including onboarding, provider selection, signup and subscription handoff, live model lists, entitlement and organization error states, out-of-credit prompts, and clearer ClinePass auth/error handling.
+- Add the Customize marketplace for discovering and managing Skills, MCP servers, and Plugins from the extension, including installed/marketplace tabs, search and filtering, install/uninstall flows, enable/disable controls, and support for plugin-bundled skills.
+- Cline Plugins: Plugins let you extend Cline with custom tools, workflows, skills, and MCP-powered capabilities tailored to your team or project. Install them from the new Customize marketplace to add specialized behavior, connect external services, and package reusable automations—so Cline can do more than code: it can adapt to the way you work.
+- Add queued prompts in chat. Messages submitted while Cline is already working are now queued, shown while the current turn streams, and can be cancelled before they run.
+- Add edit-and-regenerate support for previous user messages, with clearer Reset Chat and Reset Code actions.
+- Add generic SDK provider settings and model-catalog support so more providers can share the same model picker, reasoning controls, dynamic model IDs, provider config persistence, and custom model handling.
+- Add additional SDK-backed provider exposure and model/provider updates, including ClinePass models, refreshed Cline catalog data, Fireworks GLM 5.2, Kimi K2.6 Fast, Kimi K2.7 Code, Qwen 3.7 Plus, MiniMax M3 updates, SAP AI Core wiring, LiteLLM model fetching, Codex OAuth credentials, and OpenAI-compatible model settings.
+- Add MCP support for plugins and shared marketplace install/uninstall plumbing used by the VS Code extension.
+
+### Changed
+
+- Migrate the VS Code extension from the legacy task implementation to the shared Cline SDK and move the extension build/package workflow to Bun.
+- Rework Plan/Act mode handling through SDK coordinators, including closer CLI parity and automatic continuation when switching from Plan to Act.
+- Rework provider and model configuration around `providers.json`, the model catalog, and SDK session config so settings are preserved consistently across provider switches and active sessions can restart when the selected provider changes.
+- Simplify provider settings UI by replacing many provider-specific views with shared generic settings components and consistent reasoning selectors.
+- Simplify terminal execution through the SDK run-commands path, including clearer non-interactive command guidance and safer structured command formatting.
+- Migrate legacy MCP files and formats into the shared settings file and protect MCP settings writes with safer locking/atomic updates.
+- Refresh the MCP hub automatically after marketplace installs so newly installed servers are available without a manual restart.
+- Reorganize MCP/Skills/Plugins entry points under Customize, hide workflows from the Customize menu, wrap Customize tabs on narrow screens, and allow the MCP Marketplace tab to be disabled remotely while installed MCP servers remain accessible.
+- Simplify auto-approval settings. Command auto-approval is now disabled by default for safer new and reset configurations, and the auto-approval UI has been streamlined.
+- Update task history handling for the SDK migration, including legacy task history visibility, metadata preservation on resume, and corrected deletion behavior.
+- Route compacting and mistake-limit behavior through the SDK so the Compact button and mistake tracking affect the active SDK session.
+- Remove the legacy Explain Changes feature as part of the SDK migration cleanup.
+- Temporarily disable subagents in the VS Code extension while the SDK-backed experience is stabilized.
+
+### Fixed
+
+- Fix marketplace edge cases, including refreshing MCP servers after marketplace installs, disabling the MCP Marketplace tab from remote config, hiding workflows from Customize, surfacing plugin-bundled skills, and uninstalling shared marketplace entries.
+- Fix chat submission during active turns by queuing user messages instead of dropping or racing them, showing pending/queued states promptly, rendering direct user messages immediately, and removing delayed send behavior.
+- Fix editing previous user messages so Escape cancels editing locally and reset action labels are clearer.
+- Fix terminal reliability, including standalone Windows output capture, hardened PowerShell command handling, running-state display for in-progress commands, raw structured command preservation, single-quote handling, cwd setup timeouts, failing-command stdout capture, heredoc coalescing, and removal of duplicated command echoes in tool results.
+- Fix SDK tool-result and provider-message budgeting by truncating large tool outputs by default, capping assistant text, limiting bash/file-read/search output ingestion, bounding media budgets, batching outdated-read rewrites to preserve provider prefix caches, and normalizing JSON-like tool inputs by schema.
+- Fix login and feature-flag resolution by using the correct user/account identity on startup and simplifying the login UX.
+
+## [3.89.2]
+
+### Fixed
+
+- Complete the fix for the Anthropic provider on VS Code 1.123 and later by upgrading the bundled Anthropic SDK to a release compatible with the Node 24 runtime.
+- Update the Vertex AI provider to a compatible Anthropic Vertex SDK release so it works with the upgraded Anthropic SDK.
+
+## [3.89.1]
+
+### Fixed
+
+- Restore the Anthropic provider on VS Code 1.123 and later, where the updated Node 24 runtime broke the bundled Anthropic SDK.
+- Handle the DeepSeek V4 reasoning format.
+
+## [3.89.0]
+
+### Added
+
+- Add Claude Fable 5 model support.
+
+### Fixed
+
+- Fix MiniMax M3 thinking controls across gateways.
+
+### Changed
+
+- Clean up the Codex model list.
+
+## [3.88.1]
+
+### Added
+
+- Add a debug section in settings for Cline testers.
+
+### Fixed
+
+- Include the walkthrough markdown files in the VS Code extension package so the first-run walkthrough steps load correctly.
+
+## [3.88.0]
+
+### Added
+
+- Add the latest Fireworks AI serverless models and update the default Fireworks model to Kimi K2.6.
+
+### Fixed
+
+- Fix MCP server delete/add flows so settings writes do not cause the MCP server list to be emptied by the file watcher.
+- Remove stale Fireworks AI models and correct Fireworks model metadata and cache pricing.
+
+### Changed
+
+- Always use the upstream Cline recommended models endpoint instead of gating it behind a feature flag.
+
+## [3.87.0]
+
+### Added
+
+- Add MiniMax M3 model support.
+
+### Fixed
+
+- Update VS Code extension dependencies to resolve security issues in `@xmldom/xmldom`, `basic-ftp`, `axios`, `undici`, and other direct/transitive packages.
+
+## [3.86.2]
+
+### Fixed
+
+- Fix `@` file mentions and workspace file search on VS Code 1.122+ by resolving the new bundled `@vscode/ripgrep-universal` per-platform binary layout before falling back to legacy ripgrep paths.
+
+## [3.86.1]
+
+### Fixed
+
+- Fix `@` file mentions failing to find files in some environments (notably VS Code Remote SSH, and after certain VS Code updates) by keeping the file-search fallback alive when the workspace index or bundled ripgrep binary is unavailable.
+
+## [3.86.0]
+
+### Added
+
+- Add Claude Opus 4.8 provider support, including 1M-context variants where available.
+- Add Moonshot Kimi K2.6 model support.
+
+### Fixed
+
+- Show prompt-cache support for Qwen 3.7 Max in the Cline provider.
+- Fix the VS Code nightly publish workflow startup permissions.
+
+### Changed
+
+- Move the VS Code extension project into `apps/vscode`.
+
+## [3.85.0]
+
+### Added
+
+- Add GPT-5.5 support to SAP AI Core.
+- Add DeepSeek V4 Flash and Pro models.
+- Add Gemini 3.5 Flash to Gemini and Vertex providers.
+- Add `/lg-task` URI webhook integration for LG dashboard flows.
+
+### Fixed
+
+- Fix Vertex AI global endpoint handling for Claude models.
+- Route Poolside Laguna models through next-gen prompts and native tool calling.
+
+### Changed
+
+- Update `diff` and `protobufjs` dependencies.
+
+## [3.84.0]
+
+### Added
+
+- Add SAP AI Core support for additional hosted models
+
+### Fixed
+
+- Disable the MCP "Restart Server" button when a server is toggled off.
+
+### Changed
+
+- Remove the Cline Kanban launch modal and bundled demo media from the VS Code extension startup flow.
+
+## [3.83.0]
+
+### Fixed
+
+- Show a clear "Searching..." state in the @-mention file picker
+- Improve @-mention file search performance
+- Allow `write_to_file` to create or overwrite files with empty content.
+- Fix validation failures for MCP servers that require an object.
+- Enable OpenRouter prompt cache control for Qwen models.
+- Update Axios and SAP Connectivity dependencies
+
+### Changed
+
+- Use the VS Code-specific `README.marketplace.md` when packaging and publishing the VS Code extension
+- Add telemetry to @-mention search to help diagnose local, remote, and multi-root workspace search behavior.
+
+## [3.82.0]
+
+### Added
+
+- Restore VS Code foreground terminal support and settings.
+- Add latest OpenAI, SAP AI Core, and Z AI models.
+
+### Fixed
+
+- Fix hook template JSON escaping.
+- Improve ripgrep file search error handling.
+
+### Changed
+
+- Remove hardcoded model lists from docs.
+
+## [3.81.0]
+
+### Added
+
+- Add GPT-5.5 model support for OpenAI Codex subscription users.
+
+### Fixed
+
+- Remove hardcoded "What’s New" fallback items in webview; only remote-configured welcome banners are shown.
+
+### Changed
+
+- Improve cline-core memory diagnostics used by the extension runtime:
+  - enable near-heap-limit heap snapshots
+  - add periodic memory usage logging
+  - log discovered heap snapshots on abnormal exits for easier OOM debugging
+
+## [3.80.0]
+
+### Added
+
+- Wire up remote `globalSkills` from enterprise remote config with full UI, toggle support, and system prompt integration — enterprise-managed skills now appear under a dedicated "Enterprise Skills" section and support `alwaysEnabled` enforcement
+- Onboarding flow now uses dynamically fetched recommended models instead of a hardcoded list, with a fallback to the welcome view on failure
+- Add dedicated "Quota Exceeded" error message in the chat error UI when Cline account spend caps are hit
+
+### Fixed
+
+- Fix OOM crashes during long conversations by setting `--max-old-space-size=8192` for the cline-core Node.js process (was defaulting to ~2 GB)
+- Show detailed error information in the chat error row instead of a generic caught error message
+- Update `axios` to 1.15.0 across all packages
+
+### Changed
+
+- Remove foreground terminal mode — all task command execution now defaults to background mode, removing the VS Code integrated terminal dependency and related settings UI
+- Remove old hardcoded announcement banners
+
+## [3.79.0]
+
+### Added
+
+- Add Claude Opus 4.7 model support
+- Add Azure Blob Storage as a storage provider
+- Add `globalSkills` to remote config
+- Inline value reuse in user-level remote-config discovery
+
+### Fixed
+
+- Fix cache reflection for Cline and Vercel API handlers
+- Fix stuck `command_output` ask when terminal command ends unexpectedly
+- Add `use_subagents` to system prompt for GLM, Hermes, and XS models
+- Fix action injection security risk
+
+### Changed
+
+- Remove deprecated evals tool
+
+## [3.78.0]
+
+### Added
+
+- Add a dedicated "Spend Limit Reached" error UI when spend caps are hit
+- Docs updates
+
+### Fixed
+
+- Show actual `read_file` line ranges in chat UI
+
+## [3.77.0]
+
+### Added
+
+- Add "Lazy Teammate Mode" experimental toggle
+- `read_file` tool now supports chunked reading for targeted file access
+
+### Fixed
+
+- Exclude `new_task` tool from system prompt in yolo/headless mode
+- Fix Kanban demo video formatting
+
+### Changed
+
+- Polish `Notification` hook functionality
+
+## [3.76.0]
+
+### Added
+
+- Add Cline Kanban launch modal in webview; CLI now launches Kanban by default with a migration view
+- Add toggle to disable feature tips in chat
+- Add repeated tool call loop detection to prevent infinite loops wasting tokens
+
+### Fixed
+
+- Fix CLI Kanban spawn on Windows by enabling shell mode for `npx.cmd`
+
+## [3.75.0]
+
+### Added
+
+- Latency improvements for remote workspaces
+
+### Fixed
+
+- Stabilize flaky hooks tests
+
+### Changed
+
+- Remove example hooks in favor of reading the docs
+
+## [3.74.0]
+
+### Added
+- Implement dynamic free model detection for Cline API
+- Add file read deduplication cache to prevent repeated reads
+- Add feature tips tooltip during thinking state
+
+### Fixed
+- Replace error message when not logged in to Cline
+- Align ClineRulesToggleModal padding with ServersToggleModal
+- Skip WebP for GLM and Devstral models running through llama.cpp
+- Respect user-configured context window in LiteLLM getModel()
+- Honor explicit model IDs outside static catalog in W&B provider
+- Add missing Fireworks serverless models and pricing
+
+## [3.73.0]
+
+### Added
+
+- Added W&B Inference by CoreWeave as a new API provider with 17 models
+- Improved parallel tool calling support for OpenRouter and Cline providers
+
+### Fixed
+
+- Claude Code Provider: handle rate limit events, empty content arrays, error results, and unknown content types without crashing
+- Tool handlers (`read_file`, `list_files`, `list_code_definition_names`, `search_files`) now return graceful errors instead of crashing
+
+## [3.72.0]
+
+### Added
+
+- Added Anthropic Opus 4.6 fast mode variants
+
+### Fixed
+
+- Resolved native tool placeholder interpolation in prompts
+- Gemini: capped Flash output tokens to 8192 across providers
+- Fixed Windows unit test path normalization
+- Fixed flaky hooks tests on Windows
+- Bedrock: handle thinking and redacted_thinking blocks correctly in message conversion and streaming
+- Prevent crash when `list_files` or `list_code_definition_names` receives a file path
+
+### Changed
+
+- Updated Jupyter Notebook GIFs
+- Markdown image loading now requires user consent
+- Added `.github/copilot-instructions.md` for coding agents
+- Hooks: reintroduced feature toggle
+
+## [3.71.0]
+
+### Added
+
+- Added GPT-5.4 models for ChatGPT subscription users
+- Hooks: Added a `Notification` hook for attention and completion boundaries
+
+### Fixed
+
+- Handle streamable HTTP MCP reconnects more reliably after disconnects
+
+## [3.70.0]
+
+### Added
+
+- New Cline API docs: Getting Started, Auth, Chat Completions, Models, Errors, and SDK Examples
+- Hook payloads now include `model.provider` and `model.slug` 
+- Token/cost updates now happen immediately as usage chunks arrive, not after tool execution
+
+### Fixed
+
+- Improve subagent context compaction logic
+- Subagent stream retry delay increased to reduce noise from transient failures
+- State serialization errors are now caught and logged instead of crashing
+- Removed incorrect `max_tokens` from OpenRouter requests
+
+### Changed
+
+- Windows test cleanup now retries on locked files and applies per-test timeouts
+- Updated hooks docs 
+
+
+## [3.69.0]
+
+### Added
+
+- Add `User-Agent` header to requests sent to the Cline backend
+- Add default auto-tag workflow for publish release flow
+- Show Cline SDK docs on the Cline page
+
+### Fixed
+
+- Retry nested git restore and prevent silent `.git_disabled` leftovers in checkpoints
+- Prevent Chinese filename escaping in diff view
+- Trigger auto-compaction on OpenRouter context overflow errors
+- Restore GPT-OSS native file editing on OpenAI-compatible models
+
+### Changed
+
+- Update Cline SDK docs
+- Improve hooks support for Windows PowerShell
+
+## [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
+
+## [3.59.0]
+
+- Added Minimax 2.5 Free Promo
+- 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
+- New "double-check completion" experimental feature to verify work before marking tasks complete
+- CLI: new task controls/flags including custom `--thinking` token budget and `--max-consecutive-mistakes` for yolo runs
+- Remote config: new UI/options (including connection/test buttons) and support for syncing deletion of remotely configured MCP servers
+- Vertex / Claude Code: add 1M context model options for Claude Opus 4.6
+- 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)
+- Terminal: surface command exit codes in results and improve long-running `execute_command` timeout behavior
+- UI: add loading indicator and fix `api_req_started` rendering
+- Task streaming: prevent duplicate streamed text rows after completion
+- API: preserve selected Vercel model when model metadata is missing
+- Telemetry: route PostHog networking through proxy-aware shared fetch and ensure telemetry flushes on shutdown
+- 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
+- Tools: add auto-approval support for `attempt_completion` commands
+- Remotely configured MCP server schema now supports custom headers
+
+## [3.57.1]
+
+### Fixed
+
+- Fixed Opus 4.6 for bedrock provider
+
+## [3.57.0]
+
+### Added
+
+- Cline CLI 2.0 now available. Install with `npm install -g cline`
+- 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
+
+### Fixed
+
+- Fix read file tool to support reading large files
+- Fix decimal input crash in OpenAI Compatible price fields (#8129)
+- Fix build complete handlers when updating the api config
+- Fixed missing provider from list
+- Fixed Favorite Icon / Star from getting clipped in the task history view
+
+### Changed
+
+- Make skills always enabled and remove feature toggle setting
+
+## [3.56.0]
+
+### 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
+
+### 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
+
+### 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
+
+## [3.55.0]
+
+- Add new model: Arcee Trinity Large Preview
+- Add new model: Moonshot Kimi K2.5
+- Add MCP prompts support - prompts from connected MCP servers now appear in slash command autocomplete as `/mcp:<server>:<prompt>`
+
+## [3.54.0]
+
+### Added
+
+- Native tool calls support for Ollama provider
+- Sonnet 4.5 is now the default Amazon Bedrock model id
+
+### Fixed
+
+- Prevent infinite retry loops when replace_in_file fails repeatedly. The system now detects repeated failures and provides better guidance to break out of retry cycles.
+- Skip diff error UI handling during streaming to prevent flickering. Error handling is deferred until streaming completes.
+- Strip notebook cell outputs when extracting text content from Jupyter notebooks, significantly reducing context size sent to the LLM.
+- Throttle diff view updates during streaming to reduce UI flickering and improve performance.
+
+### Changed
+
+- Removed Mistral's Devstral-2512 free from the free models list
+- Removed deprecated zai-glm-4.6 model from Cerebras provider
+
+## [3.53.1]
+
+### Fixed
+
+- Bug in responses API
+
+## [3.53.0]
+
+### Fixed
+
+- Removed grok model from free tier
+
+## [3.52.0]
+
+### Added
+
+- Users with ChatGPT Plus or Pro subscriptions can now use GPT-5 models directly through Cline without needing an API key. Authentication is handled via OAuth through OpenAI's authentication system.
+- Grok models are now moving out of free tier and into paid plans.
+- Introduces comprehensive Jupyter Notebook support for Cline, enabling AI-assisted editing of `.ipynb` files with full cell-level context awareness.
+
+### Fixed
+
+- Bugs in DiffViewProvider for file editing
+- Ollama's recommended models to use correct identifiers
+
+## [3.51.0]
+
+### Added
+
+- Adding OpenAI gpt-5.2-codex model to the model picker
+
+## [3.50.0]
+
+### Added
+
+- Add gpt-5.2-codex OpenAI model support
+- Add create-pull-request skill
+
+### Fixed
+
+- Fix the selection of remotely configured providers
+- Fix act_mode_respond to prevent consecutive calls
+- Fix invalid tool call IDs when switching between model formats
+
+## [3.49.1]
+
+### Added
+
+- Add telemetry to track usage of skills feature
+- Add version headers to Cline backend requests
+- Phase in Responses API usage instead of defaulting for every supported model
+
+### Fixed
+
+- Fix workflow slash command search to be case-insensitive
+- Fix model display in ModelPickerModal when using LiteLLM
+- Fix LiteLLM model fetching with default base URL
+- Fix crash when OpenAI-compatible APIs send usage chunks with empty or null choices arrays at end of streaming
+- Fix model ID for Kat Coder Pro Free model
+
+## [3.49.0]
+
+- Enable configuring an OTEL collector at runtime
+- Removing Minimax-2.1 from free model list as the free trial has ended
+- Improved image display in MCP responses
+- Auto-sync remote MCP servers from remote config to local settings
+
+## [3.48.0]
+
+### Added
+
+- Add Skills system for reusable, on-demand agent instructions
+- Add new websearch tooling in Cline provider
+- Add zai-glm-4.7 to Cerebras model list
+- Add model refresh and improve reasoning support for Vercel AI Gateway
+
+### Fixed
+
+- Revert #8341 due to regressions in diff view/document truncation (see #8423, #8429)
+- Fixed extension crash when using context menu selector
+
+## [3.47.0]
+
+### Added
+
+- Added experimental support for Background Edits (allows editing files in background without opening the diff view)
+- Updated free model to MiniMax M2.1 (replacing MiniMax M2)
+- Added support for Azure based identity authentication in OpenAI Compatible provider and Azure OpenAI
+- Add `supportsReasoning` property to Baseten models
+
+### Fixed
+
+- Prevent expired token usage in authenticated requests
+- Exclude binary files without extensions from diffs
+- Preserve file endings and trailing newlines
+- Fix Cerebras rate limiting
+- Fix Auto Compact for Claude Code provider
+- Make Workspace and Favorites history filters independent
+- Fix remote MCP server connection failures (404 response handling)
+- Disable native tool calling for Deepseek 3.2 speciale
+- Show notification instead of opening sidebar on update
+- Fix Baseten model selector
+
+### Refactored
+
+- Modify prompts for parallel tool usage in Claude and Gemini 3 models
+
+## [3.46.1]
+
+### Fixed
+
+- Remove GLM 4.6 from free models
+
+## [3.46.0]
+
+### Added
+
+- Added GLM 4.7 model
+- Enhanced background terminal execution with command tracking, log file output, zombie process prevention (10-minute timeout), and clickable log paths in UI
+- Apply Patch tool for GPT-5+ models (replacing current diff edit tools)
+
+### Fixed
+
+- Duplicate error messages during streaming for Diff Edit tool when Parallel Tool Calling is not enabled
+- Banner carousel styling and dismiss functionality
+- Typos in Gemini system prompt overrides
+- Model picker favorites ordering, star toggle, and keyboard navigation for OpenRouter and Vercel AI Gateway providers
+- Fetch remote config values from the cache
+
+### Refactored
+
+- Anthropic handler to use metadata for reasoning support
+- Bedrock provider to use metadata for reasoning support
+
+## [3.45.1]
+
+- Fixed MCP settings race condition where toggling auto-approve or changing timeout settings would cause the UI to flash and revert
+
+## [3.45.0]
+
+- Added Gemini 3 Flash Preview model
+
+## [3.44.2]
+
+- Polished the model picker UI with checkmarks for selected models, tooltips on Plan/Act tabs, and consistent arrow pointers across all popup modals
+- Improved WhatsNew modal responsiveness and cleaned up redundant UI elements
+- Fixed GLM models outputting garbled text in thinking tags—reasoning is now properly disabled for these models
+
+## [3.44.1]
+
+- Fixed a critical bug where local MCP servers stopped connecting after v3.42.0—all user-configured stdio-based MCP servers should now work again
+- Fixed remotely configured API keys not being extracted correctly for enterprise users
+- Added support for dynamic tool instructions that adapt based on runtime context, laying groundwork for future context-aware features
+
+## [3.44.0]
+
+## Added
+
+- Updating minor version to show a proper banner for the release
+
+## [3.43.1]
+
+### Patch Changes
+
+- Fix GLM-4.6 Model reference id
+
+## [3.43.0]
+
+### Added
+
+- GLM-4.6
+- kat-coder-pro
+- Add parsing of env variable patterns to the mcpconfig.json
+
+### Fixed
+
+- TLS Proxy support issues for VSCode
+- Add supportsReasoning flag to OpenAI reasoning models
+- Fix thinking not available for some models in the OpenAI provider
+- Fix invalid signature field issues when switching between Gemini and Anthropic providers
+- Extract OpenRouter model filtering into reusable utility and use it in different model pickers
+- Fix a11y for auto approve checkbox
+- Improve ModelPickerModal provider list layout
+
+### Refactored
+
+- Migrate WhatsNewModal to new shared dialogue component
+
+## [3.42.0]
+
+### Added
+
+- Expose `getAvailableSlashCommands` rpc endpoint to UI clients
+- Made slash command menu and context menu accessible and screenreader-friendly
+- Made expanding/collapsing UI components accessible
+
+### Fixed
+
+- Devstral OpenRouter model ID and routing issues
+- Incorrect pricing display for Devstral model in the extension
+
+## [3.41.0]
+
+### Added
+
+- OpenAI GPT-5.2
+- Devstral-2512 (formerly stealth model "Microwave")
+- Improvements to chat modal model picker
+- Amazon Nova 2 Lite
+- DeepSeek 3.2 to native tool calling allow list
+- Responses API support for Codex models in OpenAI provider (requires native tool calling)
+- Xmas Special Santa Cline
+- Welcome screen UI enhancements
+
+### Fixed
+
+- Initial checkpoint commit now non-blocking for improved responsiveness in large repositories
+- Gemini Vertex models erroring when thinking parameters are not supported
+- Restrictive file permissions for secrets.json
+- Ollama streaming requests not aborting when task is cancelled
+
+### Refactored
+
+- OpenAI provider to centralize temperature configuration and include missing GPT-5 model settings
+- OpenAI native handler to use metadata for model capabilities
+- Vertex provider to use metadata for model capabilities
+
+## [3.40.2]
+
+- Fix logout on network errors during token refresh (e.g., opening laptop while offline)
+
+## [3.40.1]
+
+- Fix cost calculation display for Anthropic API requests
+
+## [3.40.0]
+
+- Fix highlighted text flashing when task header is collapsed
+- Add X-Cerebras-3rd-Party-Integration header to Cerebras API requests
+- Add microwave family system prompt configuration
+- Remove tooltips from auto approve menu
+- Fix Standalone, ensure cwd is the install dir to find resources reliably
+- Fix a bug where terminal commands with double quotes are broken when "Terminal Execution Mode" is set to "Background Exec"
+- Add support for slash commands anywhere in a message, not just at the beginning. This matches the behavior of @ mentions for a more flexible input experience.
+- Add bottom padding to the last message to fix last response text getting cut off by auto approve settings bar.
+- Add default thinking level for Gemini 3 Pro models in Gemini provider
+
+## [3.39.2]
+
+- Fix for microwave model and thinking settings
+
+## [3.39.1]
+
+- Fix Openrouter and Cline Provider model info
+
+## [3.39.0]
+
+- Add Explain Changes feature
+- Add microwave Stealth model
+- Add Tabbed Model Picker with Recommended and Free tabs
+- Add support to View remote rules and workflows in the editor
+- Enable NTC (Native Tool Calling) by default
+- Bug fixes and improvements for LiteLLM provider
+
+## [3.38.3]
+
+- Task export feature now opens the task directory, allowing easy access to the full task files
+- Add Grok 4.1 and Grok Code to XAI provider
+- Enabled native tool calling for Baseten and Kimi K2 models
+- Add thinking level to Gemini 3.0 Pro preview
+- Expanded Hooks functionality
+- Removed Task Timeline from Task Header
+- Bug fix for slash commands
+- Bug fixes for Vertex provider
+- Bug fixes for thinking/reasoning issues across multiple providers when using native tool calling
+- Bug fixes for terminal usage on Windows devices
+
+## [3.38.2]
+
+- Add Claude Opus 4.5
+
+## [3.38.1]
+
+### Fixed
+
+- Fixed handling of 'signature' field in sanitizeAnthropicContentBlock to properly preserve it when thinking is enabled, as required by Anthropic's API.
+
+## [3.38.0]
+
+### Added
+
+- Gemini 3 Pro Preview model
+- AquaVoice Avalon model for voice-to-text dictation
+
+### Fixed
+
+- Automatic context truncation when AWS Bedrock token usage rate limits are exceeded
+- Removed new_task tool from system prompts, updated slash command prompts, and added helper function for native tool calling validation
+
+## [3.37.1]
+
+- Comprehensive changes to better support GPT 5.1 - System prompt, tools, deep-planning, focus chain, etc.
+- Add AGENTS.md support
+- feat(models): Add free minimax/mimax-m2 model to the model picker
+
+## [3.37.0]
+
+### Added
+
+- GPT-5.1 with model-specific prompting: tailored system prompts, tool usage, focus chain, and deep-planning optimizations
+- Nous Research provider with Hermes 4 model family and custom system prompts
+- Switched to Aqua Voice's Avalon model in speech to text transcription
+- Added Linux support for speech to text
+- Model-family breakouts for deep-planning prompting, laying groundwork for enhanced slash commands
+- Expanded HTTP proxy support throughout the codebase
+- Improved focus chain prompting for frontier models (Anthropic, OpenAI, Gemini, xAI)
+
+### Fixed
+
+- Duplicate tool results prevention through existence checking
+- XML entity escaping in model content processor
+- Commit message generation in command palette
+- OpenAI Compatible provider temperature parameter type conversion
+
+## Documentation
+
+- Added missing proto generation step in CONTRIBUTING.md
+- New `npm run dev` script for streamlined terminal workflow (fixes #7335)
+
+## [3.36.1]
+
+- fix: remove native tool calling support from Gemini and XAI provider due to invalid tool names issues
+- fix: disable native tool callings for grok code models
+- Add MCP tool usage to GLM
+- Removes reasoning_details content field from Anthropic providers
+
+## [3.36.0]
+
+- Add: Hooks allow you to inject custom logic into Cline's workflow
+- Add: new provider AIhubmix
+- Add: Use http_proxy, https_proxy and no_proxy in JetBrains
+- Fix: Oca Token Refresh logic
+- Fix: issues where assistant message with empty content is added to conversation history
+- Fix: bug where the checkbox shows in the model selector dropdown
+- Fix: Switch from defaultUserAgentProvider to customUserAgent for Bedrock
+- Fix: support for `<think>` tags for better compatibility with open-source models
+- Fix: refinements to the GLM-4.6 system prompt
+
+## [3.35.1]
+
+- Add: Hicap API integration as provider
+- Fix: enable Add Header button in OpenAICompatibleProvider UI
+- Fix: Remove orphaned tool_results after truncation and empty content field issues in native tool call
+- Fix: render model description in markdown
+
+## [3.35.0]
+
+- Add native tool calling support with configurable setting.
+- Auto-approve is now always-on with a redesigned expanding menu. Settings simplified and notifications moved to General Settings.
+- added zai-glm-4.6 as a Cerebras model
+- Created GPT5 family specific system prompt template
+- Fix: show reasoning budget slider to models with valid thinking config
+- Requesty base URL, and API key fixes
+- Delete all Auth Tokens when logging out
+- Support for <think> tags for models that prefer that over <thinking>
+
+## [3.34.1]
+
+- Added support for MiniMax provider with MiniMax-M2 model
+- Remove Cline/code-supernova-1-million model
+- Changes to allow users to manually enter model names (eg. presets) when using OpenRouter
+
+## [3.34.0]
+
+- Cline Teams is now free through 2025 for unlimited users. Includes Jetbrains, RBAC, centralized billing and more.
+- Use the “exacto” versions of GLM-4.6, Kimi-K2, and Qwen3-Coder in the Cline provider for the best balance of cost, speed, accuracy and tool-calling.
+
+## [3.33.1]
+
+- Fix CLI installation copy text
+
+## [3.33.0]
+
+- Added Cline CLI (Preview)
+- Added Subagent support (Experimental)
+- Added Multi-Root Workspaces support (Enable in feature settings)
+- Add auto-retry with exponential backof for failed API requests
+
+## [3.32.8]
+
+- Add Claude Haiku 4.5 support
+
+## [3.32.7]
+
+- Add JP and Global inference profile options to AWS Bedrock
+- Adding Improvements to VSCode multi root workspaces
+- Added markdown support to focus chain text, allowing the model to display more interesting focus chains
+
+## [3.32.6]
+
+- Add experimental support for VSCode multi root workspaces
+- Add Claude Sonnet 4.5 to Claude Code provider
+- Add Glm 4.6 to Z AI provider
+
+## [3.32.5]
+
+- Improve thinking budget slider UI to take up less space
+- Fix Vercel provider cost note and sign-up url
+- Fix repeated API error 400 in SAP AI Core provider
+- Add us-west-1 to Amazon Bedrock regions
+- Fix OCA provider refresh logic
+
+## [3.32.4]
+
+- Add 1m context window support to Claude Sonnet 4.5
+- Add Claude Sonnet 4.5 to GCP Vertex
+- Add prompt caching support for OpenRouter accidental `anthropic/claude-4.5-sonnet` model ID
+
+## [3.32.3]
+
+- Add Claude Sonnet 4.5 to Bedrock provider
+- Add Alert banner for new Claude Sonnet 4.5 model
+
+## [3.32.2]
+
+- Add Claude Sonnet 4.5 to Cline/OpenRouter/Anthropic providers
+- Add /task deep link handler
+
+## [3.32.1]
+
+- Preserve reasoning traces for Cline/OpenRouter/Anthropic providers to maintain conversation integrity
+- Add automatically retry on rate limit errors with SAP AI Core provider
+- Fix Cline accounts using stale id token at refresh response
+- Minor UI improvements to Settings and Task Header
+
+## [3.32.0]
+
+- Added the new code-supernova-1-million stealth model, available for free and delivering a 1 million token context window
+- Changes to inform Cline about commands that are available on your system
+
+## [3.31.1]
+
+- Version bump
+
+## [3.31.0]
+
+- UI Improvements: New task header and focus chain design to take up less space for a cleaner experience
+- Voice Mode: Experimental feature that must be enabled in settings for hands-free coding
+- YOLO Mode: Enable in settings to let Cline approve all actions and automatically switch between plan/act mode
+- Fix Oracle Code Assist provider issues
+
+## [3.30.3]
+
+- Add Oracle Code Assist provider
+
+## [3.30.2]
+
+- Fix UI tests
+
+## [3.30.1]
+
+- Fix model list not being updated in time for user to use shortcut button to update model to stealth model
+- Fix flicker issue when switching modes
+- Fix Sticky header in settings view overlaping with content on scroll
+- Add experimental yolo mode feature that disables all user approvals and automatically executes a task and navigates through plan to act mode until the task is complete
+
+## [3.30.0]
+
+- Add code-supernova stealth model
+
+## [3.29.2]
+
+- Fix: Reverted change that caused formatting issues
+- Fix: Moonshot - Pass max_tokens value to provider
+
+## [3.29.1]
+
+- Changeset bump + Announcement banner update
+
+## [3.29.0]
+
+- Updated Baseten provider to fetch models from server
+- Fix: Updated insufficient balance URL for easy Cline balance top-ups
+- Accessibility: Improvements to screen readers in MCP, Cline Rules, workflows, and history views.
+
+## [3.28.4]
+
+- Fix bug where some Windows machines had API request hanging
+- Fix bug where 'Proceed while running' action button would be disabled after running an interactive command
+- Fix prompt cache info not being displayed in History
+
+## [3.28.3]
+
+- Fixed issue with start new task button
+- Feature to generate commit message for staged changes, with unstaged as fallback
+
+## [3.28.2]
+
+- Fix for focus chain settings
+
+## [3.28.1]
+
+- Requesty: use base URL to get models and API keys
+- Removed focus chain feature flag
+
+## [3.28.0]
+
+- Synchronized Task History: Real-time task history synchronization across all Cline instances
+- Optimized GPT-5 Integration: Fine-tuned system prompts for improved performance with GPT-5 model family
+- Deep Planning Improvements: Optimized prompts for Windows/PowerShell environments and dependency exclusion
+- Streamlined UI Experience: ESC key navigation, cleaner approve/reject buttons, and improved editor panel focus
+- Smart Provider Search: Improved search functionality in API provider dropdown for faster model selection
+- Added per-provider thinking tokens configurability
+- Added Ollama custom prompt options
+- Enhanced SAP AI Core Provider: Orchestration mode support and improved model visibility
+- Added Dify.ai API Integration
+- SambaNova Updates: Added DeepSeek-V3.1 model
+- Better Gemini rate limit handling
+- OpenAI Reasoning Effort: Minimal reasoning effort configuration for OpenAI models
+- Fixed LiteLLM Caching: Anthropic caching compatibility when using LiteLLM
+- Fixed Ollama default endpoint connections
+- Fixed AutoApprove menu overflow
+- Fixed extended thinking token issue with Anthropic models
+- Fixed issue with slash commands removing text from prompt
+
+## [3.27.2]
+
+- Remove `grok-code-fast-1` promotion deadline
+
+## [3.27.1]
+
+- Add new Kimi K2 model to groq and moonshot providers
+
+## [3.27.0]
+
+- Fix `grok-code-fast-1` model information
+- Add call to action for trying free `grok-code-fast-1` in Announcement banner
+
+## [3.26.7]
+
+- Add 200k context window variant for Claude Sonnet 4 to OpenRouter and Cline providers
+
+## [3.26.6]
+
+- Add free Grok Coder model to Cline provider for users looking for a fast, free coding model option
+- Fix GPT-5 models not respecting auto-compact setting when enabled, improving context window management
+- Fix provider retry attempts not showing proper user feedback during rate limiting scenarios
+- Improve markdown and code block styling to automatically adapt when switching VS Code themes
+
+## [3.26.5]
+
+- fix (provider/vercel-ai-gateway): reduce model list load frequency in settings view
+- Fix OVSX publish command to resolve deployment failure
+
+## [3.26.4]
+
+- Update nebius ai studio models
+- Update sap provider - support reasoning effort for open ai models
+- Fix Claude 4 image input in SAP AI Core Provider
+
+## [3.26.3]
+
+- Add compact system prompt option for LM Studio and Ollama models, optimized for smaller context windows (8k or less)
+- Add token usage tracking for LM Studio models to better monitor API consumption
+- Add "Use compact prompt" checkbox in LM Studio provider settings
+- Fix "Unexpected API Response" bug with gpt-5
+
+## [3.26.2]
+
+- Improve OpenRouter model parsing to show reasoning budget sliders for all models that support thinking, not just Claude models
+- Fix OpenRouter context window error handling to properly extract error codes from error messages, resolving "Unexpected API Response" errors with GPT-5 on Cline provider
+- Fix GPT-5 context window configuration for OpenAI/OpenRouter/Cline providers to use correct 272K limit
+- Remove max tokens configuration from Sonic Alpha model
+- Add Go language support to deep-planning feature (Thanks @yuvalman!)
+- Fix typo in Focus Chain settings page (Thanks @joyceerhl!)
+
+## [3.26.1]
+
+- Add Vercel AI Gateway as a new API provider option (Thanks @joshualipman123!)
+- Improve SAP AI Core provider to show deployed and undeployed models in the UI (Thanks @yuvalman!)
+- Fix Fireworks provider configuration and functionality (Thanks @ershang-fireworks!)
+- Add telemetry tracking for MCP tool usage to help improve the extension
+- Improve telemetry tracking for rules and workflow usage analytics
+- Set Plan mode to use strict mode by default for better planning results
+
+## [3.26.0]
+
+- Add Z AI as a new API provider with GLM-4.5 and GLM-4.5 Air models, offering competitive performance with cost-effective pricing especially for Chinese language tasks (Thanks @jues!)
+- Add Cline Sonic Alpha model - experimental advanced model with 262K context window for complex coding tasks
+- Add support for LM Studio local models from v0 API endpoint with configurable max tokens
+- Fix Ollama context window configuration not being used in requests
+
+## [3.25.3]
+
+- Fix bug where 'Enable checkpoints' and 'Disable MCP Marketplace' settings would be reset to default on reload
+- Move the position of the focus chain edit button when a scrollbar is present. Make the pencil icon bigger and better centered.
+
+## [3.25.2]
+
+- Fix attempt_completion showing twice in chat due to partial logic not being handled correctly
+- Fix OpenRouter showing cline credits error after 402 response
+
+## [3.25.1]
+
+- Fix attempt_completion command showing twice in chat view when updating progress checklist
+- Fix bug where announcement banner could not be dismissed
+- Add GPT-OSS models to AWS Bedrock
+
+## [3.25.0]
+
+- **Focus Chain:** Automatically creates and maintains todo lists as you work with Cline, breaking down complex tasks into manageable steps with real-time progress tracking
+- **Auto Compact:** Intelligently manages conversation context to prevent token limit errors by automatically compacting older messages while preserving important context
+- **Deep Planning:** New `/deep-planning` slash command for structured 4-step implementation planning that integrates with Focus Chain for automatic progress tracking
+- Add support for 200k context window for Claude Sonnet 4 in OpenRouter and Cline providers
+- Add option to configure custom base URL for Requesty provider
+
+## [3.24.0]
+
+- Add OpenAI GPT-5 Chat(gpt-5-chat-latest)
+- Add custom browser arguments setting to allow passing flags to the Chrome executable for better headless compatibility.
+- Add 1m context window model support for claude sonnet 4
+- Fis the API Keys URL for Requesty
+- Set gpt5 max tokens to 8_192 to fix 'context window exceeded' error
+- Fix issue where fallback request to retrieve cost was not using correct auth token
+- Add OpenAI context window exceeded error handling
+- Calibrate input token counts when using anthropic models of sap ai core provider
+
+## [3.23.0]
+
+- Add caching support for Bedrock inferences using SAP AI Core and minor refactor
+- Improve visibility for mode switch background color on different themes
+- Fix terminal commands putting webview in blocked state
+
+## [3.22.0]
+
+- Implemented a retry strategy for Cerebras to handle rate limit issues due to its generation speed
+- Add support for GPT-5 models to SAP AI Core Provider
+- Support sending context to active webview when editor panels are opened.
+- Fix bug where running out of credits on Cline accounts would show '402 empty body' response instead of 'buy credits' component
+- Fix LiteLLM Proxy Provider Cost Tracking
+
+## [3.21.0]
+
+- Add support for GPT-5 model family including GPT-5, GPT-5 Mini, and GPT-5 Nano with prompt caching support and set GPT-5 as the new default model
+- Add "Take a Tour" button for new users to easily access the VSCode walkthrough and improve onboarding experience
+- Enhance plan mode response handling with better exploration parameter support
+
+## [3.20.13]
+
+- Fix prompt caching support for Opus 4.1 on OpenRouter/Cline
+
+## [3.20.12]
+
+- Add Claude Opus 4.1 model support to AWS Bedrock provider (Thanks @omercelik!)
+- Fix prompt caching and extended thinking support for Claude Opus 4.1 in Anthropic provider
+
+## [3.20.11]
+
+Add gpt-oss-120b as a Cerebras model
+Add Opus 4.1 through Claude Code
+
+## [3.20.10]
+
+- Add OpenAI's new open-source models (GPT-OSS-120B and GPT-OSS-20B) to Hugging Face and Groq providers
+
+## [3.20.9]
+
+- Add support for Claude Opus 4.1 model in Anthropic provider
+- Add Baseten as a new API provider with support for DeepSeek, Llama, and Kimi K2 models (Thanks @AlexKer!)
+- Fix error messages not clearing from UI when retrying failed tasks
+- Fix chat input box positioning issues
+
+## [3.20.8]
+
+- Add navbar tooltips on hover
+
+## [3.20.7]
+
+- Fix circular dependency that affect the github workflow Tests / test (pull_request)
+
+## [3.20.6]
+
+- Fix login check on extension restart
+
+## [3.20.5]
+
+- Fix authentication persistence issues that could cause users to be logged out unexpectedly
+
+## [3.20.4]
+
+- Add new Cerebras models
+- Update rate limits for existing Cerebras models
+- Fix for delete task dialog
+
+## [3.20.3]
+
+- Add Huawei Cloud MaaS Provider (Thanks @ddling!)
+- Add Cerebras Qwen 3 235B instruct model (Thanks @kevint-cerebras!)
+- Add DeepSeek R1 0528 support under Hugging Face (Thanks @0ne0rZer0!)
+- Fix Global Rules directory documentation for Linux/WSL systems
+- Fix token counting when using VSCode LM API provider
+- Fix input field stealing focus issue by only focusing on visible and active editor panels
+- Fix duplicate tool registration for claude4-experimental
+- Trim input value for URL fields
+
+## [3.20.2]
+
+- Fixed issue with sap ai core client credentials storage
+- Fix Qwen Api option inconsistency between UI and API layer
+- Fix credit balance out of sync issue on account switching
+- Fix Claude Code CLAUDE_CODE_MAX_OUTPUT_TOKENS
+- Fix cursor state after restoring files to be disabled after checked out
+- Fix issue where checkpointing blocked UI
+
+## [3.20.1]
+
+- Fix for files being deleted when switching modes or closing tasks
+
+## [3.20.0]
+
+- Add account balance display for all organization members, allowing non-admin users to view their organization's credit balance and add credits
+
+## [3.19.8]
+
+- Add Claude Code support on Windows with improved system prompt handling to fix E2BIG errors (Thanks @BarreiroT!)
+- Improve Cerebras provider with updated model selection (Qwen and Llama 3.3 70B only) and increased context window for Qwen 3 32B from 16K to 64K tokens
+- Improve Cerebras Qwen model performance by removing thinking tokens from model input
+- Add robust checkpoint timeout handling with early warning at 7 seconds and timeout at 15 seconds to prevent hanging on large repositories
+- Fix MCP servers incorrectly starting when disabled in configuration (Thanks @mohanraj-r!)
+- Refactor Git commit message generation with streaming support and improved module organization
+- Fix settings navigation to open correct tab when accessing from checkpoint warnings
+
+## [3.19.7]
+
+- Add Hugging Face as a new API provider with support for their inference API models
+- Improve Claude Code error messages with better guidance for common setup issues (Thanks @BarreiroT!)
+- Fix authentication sync issues when using multiple VSCode windows
+
+## [3.19.6]
+
+- Improve Kimi K2 model provider routing with additional provider options for better availability and performance
+- Fixed terminal bug where Cline failed to capture output of certain fast-running commands
+- Fixed bug with increasing auto approved number of requests not resetting the counter mid-task
+
+## [3.19.5]
+
+- Add Groq as a new API provider with support for all Groq models including Kimi-K2
+- Add user role display in organization UI for Cline account users
+- Fix message dialogs not showing option buttons properly
+- Fix authentication issues when using multiple VSCode windows
+
+## [3.19.4]
+
+- Add ability to choose Chinese endpoint for Moonshot provider
+
+## [3.19.3]
+
+- Add Moonshot AI provider
+
+## [3.19.2]
+
+- Show request ID in error messages returned by Cline Accounts API to help debug user reported issues
+
+## [3.19.1]
+
+- Fix documentation
+
+## [3.19.0]
+
+- Add Kimi-K2 as a recommended model in the Cline Provider, and route to Together/Groq for 131k context window and high throughput
+- Added API Key support for Bedrock integration
+
+## [3.18.14]
+
+- Fix bug where Cline account users logged in with invalid token would not be shown as logged out in webview presentation layer
+
+## [3.18.13]
+
+- Fix authentication issue where Cline accounts users would keep getting logged out or seeing 'Unexpected API response' errors
+
+## [3.18.12]
+
+- Fix flaky organization switching behavior in Cline provider that caused UI inconsistencies and double loading
+- Fix insufficient credits error display to properly show error messages when account balance is too low
+- Improve credit balance validation and error handling for Cline provider requests
+
+## [3.18.11]
+
+- Fix authentication issues with Cline provider by ensuring the client always uses the latest auth token
+
+## [3.18.10]
+
+- Update recommended fast & cheap model to Grok 4 in OpenRouter model picker
+- Fix Gemini 2.5 Pro thinking budget slider and add support for Gemini 2.5 Flash Lite Preview model (Thanks @arafatkatze!)
+
+## [3.18.9]
+
+- Fix streaming reliability issues with Cline provider that could cause connection problems during long conversations
+- Fix authentication error handling for Cline provider to show clearer error messages when not signed in and prevent recursive failed requests
+- Remove incorrect pricing display for SAP AI Core provider since it uses non-USD "Capacity Units" that cannot be directly converted (Thanks @ncryptedV1!)
+
+## [3.18.8]
+
+- Update pricing for Grok 3 model because the promotion ended
+
+## [3.18.7]
+
+- Remove promotional "free" messaging for Grok 3 model in UI
+
+## [3.18.6]
+
+- Update request header to include `"ai-client-type": "Cline"` to SAP Api Provider
+- Add organization accounts
+
+## [3.18.5]
+
+- Fix Plan/Act mode persistence across sessions and multi-workspace conflicts
+- Improve provider switching performance by 18x (from 550ms to 30ms) with batched storage operations
+- Improve SAP AI Core provider model organization and fix exception handling (Thanks @schardosin!)
+
+## [3.18.4]
+
+- Add support for Gemini 2.5 Pro and Flash to SAP AI Core Provider
+- Fix logging in with Cline account not getting past welcome screen
+
+## [3.18.3]
+
+- Improve Cerebras Qwen model performance by removing thinking tokens from model input (Thanks @kevint-cerebras!)
+- Improve Claude Code provider with better error handling and performance optimizations (Thanks @BarreiroT!)
+
+## [3.18.2]
+
+- Fix issue where terminal output would not be captured if shell integration fails by falling back to capturing the terminal content.
+- Add confirmation popup when deleting tasks
+- Add support for Claude Sonnet 4 and Opus 4 model in SAP AI Core provider (Thanks @lizzzcai!)
+- Add support for `litellm_session_id` to group requests in a single session (Thanks @jorgegarciarey!)
+- Add "Thinking Budget" customization for Claude Code (Thanks @BarreiroT!)
+- Fix issue where the extension would use the user's environment variables for authentication when using Claude Code (Thanks @BarreiroT!)
+
+## [3.18.1]
+
+- Add support for Claude 4 Sonnet in SAP AI Core provider (Thanks @GTxx!)
+- Fix ENAMETOOLONG error when using Claude Code provider with long conversation histories (Thanks @BarreiroT!)
+- Remove Gemini CLI provider because Google asked us to
+- Fix bug with "Delete All Tasks" functionality
+
+## [3.18.0]
+
+- Optimized Cline to work with the Claude 4 family of models, resulting in improved performance, reliability, and new capabilities
+- Added a new Gemini CLI provider that allows you to use your local Gemini CLI authentication to access Gemini models for free (Thanks @google-gemini!)
+- Optimized Cline to work with the Gemini 2.5 family of models
+- Updated the default and recommended model to Claude 4 Sonnet for the best performance
+- Fix race condition in Plan/Act mode switching
+- Improve robustness of search and replace parsing
+
+## [3.17.16]
+
+- Fix Claude Code provider error handling for incomplete messages during long-running tasks (Thanks @BarreiroT!)
+- Add taskId as metadata to LiteLLM API requests for better request tracing (Thanks @jorgegarciarey!)
+
+## [3.17.15]
+
+- Fix LiteLLM provider to properly respect selected model IDs when switching between Plan and Act modes (Thanks @sammcj!)
+- Fix chat input being cleared when switching between Plan/Act modes without sending a message (Thanks @BarreiroT!)
+- Fix MCP server name display to avoid showing "undefined" for SSE servers, preventing tool/resource invocation failures (Thanks @ramybenaroya!)
+- Fix AWS Bedrock provider by removing deprecated custom model encoding (Thanks @watany-dev!)
+- Fix timeline tooltips for followup messages and improve color retrieval code (Thanks @char8x!)
+- Improve accessibility by making task header buttons properly announced by screen readers (Thanks @yncat!)
+- Improve accessibility by adding proper state reporting for Plan/Act mode switch for screen readers (Thanks @yncat!)
+- Prevent reading development environment variables from user's environment (Thanks @BarreiroT!)
+
+## [3.17.14]
+
+- Add Claude Code as a new API provider, allowing integration with Anthropic's Claude Code CLI tool and Claude Max Plan (Thanks @BarreiroT!)
+- Add SAP AI Core as a new API provider with support for Claude and GPT models (Thanks @schardosin!)
+- Add configurable default terminal profile setting, allowing users to specify which terminal Cline should use (Thanks @valinha!)
+- Add terminal output size constraint setting to limit how much terminal output is processed
+- Add MCP Rich Display settings to the settings page for persistent configuration (Thanks @Vl4diC0de!)
+- Improve copy button functionality with refactored reusable components (Thanks @shouhanzen!)
+- Improve AWS Bedrock provider by removing deprecated dependency and using standard AWS SDK (Thanks @watany-dev!)
+- Fix list_files tool to properly return files when targeting hidden directories
+- Fix search and replace edge case that could cause file deletion, making the algorithm more lenient for models using different diff formats
+- Fix task restoration issues that could occur when resuming interrupted tasks
+- Fix checkpoint saving to properly track all file changes
+- Improve file context warnings to reduce diff edit errors when resuming restored tasks
+- Clear chat input when switching between Plan/Act modes within a task
+- Exclude .clinerules files from checkpoint tracking
+
+## [3.17.13]
+
+- Add Thinking UX for Gemini models, providing visual feedback during model reasoning
+- Add support for Notifications MCP integration with Cline
+- Add prompt caching indicator for Grok 3 models
+- Sort MCP marketplace by newest listings by default for easier discovery of recent servers
+- Update O3 model family pricing to reflect latest OpenAI rates
+- Remove '-beta' suffix from Grok model identifiers
+- Fix AWS Bedrock provider by removing deprecated Anthropic-Bedrock SDK (Thanks @watany-dev!)
+- Fix menu display issue for terminal timeout settings
+- Improve chat input field styling and behavior
+
+## [3.17.12]
+
+- **Free Grok Model Available!** Access Grok 3 completely free through the Cline provider
+- Add collapsible MCP response panels to keep conversations focused on the main AI responses while still allowing access to detailed MCP output (Thanks @valinha!)
+- Prioritize active files (open tabs) at the top of the file context menu when using @ mentions (Thanks @abeatrix!)
+- Fix context menu to properly default to "File" option instead of incorrectly selecting "Git Commits"
+- Fix diff editing to handle out-of-order SEARCH/REPLACE blocks, improving reliability with models that don't follow strict ordering
+- Fix telemetry warning popup appearing repeatedly for users who have telemetry disabled
+
+## [3.17.11]
+
+- Add support for Gemini 2.5 Pro Preview 06-05 model to Vertex AI and Google Gemini providers
+
+## [3.17.10]
+
+- Add support for Qwen 3 series models with thinking mode options (Thanks @Jonny-china!)
+- Add new AskSage models: Claude 4 Sonnet, Claude 4 Opus, GPT 4.1, Gemini 2.5 Pro (Thanks @swhite24!)
+- Add VSCode walkthrough to help new users get started with Cline
+- Add support for streamable MCP servers
+- Improve Ollama model selection with filterable dropdown instead of radio buttons (Thanks @paulgear!)
+- Add setting to disable aggressive terminal reuse to help users experiencing task lockout issues
+- Fix settings dialog applying changes even when cancel button is clicked
+
+## [3.17.9]
+
+- Aligning Cline to work with Claude 4 model family (Experimental)
+- Add task timeline scrolling feature
+- Add support for uploading CSV and XLSX files for data analysis and processing
+- Add stable Grok-3 models to xAI provider (grok-3, grok-3-fast, grok-3-mini, grok-3-mini-fast) and update default model from grok-3-beta to grok-3 (Thanks @PeterDaveHello!)
+- Add new models to Vertex AI provider
+- Add new model to Nebius AI Studio
+- Remove hard-coded temperature from LM Studio API requests and add support for reasoning_content in LM Studio responses
+- Display delay information when retrying API calls for better user feedback
+- Fix AWS Bedrock credential caching issue where externally updated credentials (e.g., by AWS Identity Manager) were not detected, requiring extension restart (Thanks @DaveFres!)
+- Fix search tool overloading conversation with massive outputs by setting maximum byte limit for responses
+- Fix checkpoints functionality
+- Fix token counting for xAI provider
+- Fix Ollama provider issues
+- Fix window title display for Windows users
+- Improve chat box UI
+
+## [3.17.8]
+
+- Fix bug where terminal would get stuck and output "capture failure"
+
+## [3.17.7]
+
+- Fix diff editing reliability for Claude 4 family models by adding constraints to prevent errors with large replacements
+
+## [3.17.6]
+
+- Add Cerebras as a new API provider with 5 high-performance models including reasoning-capable models (Thanks @kevint-cerebras!)
+- Add support for uploading various file types (XML, JSON, TXT, LOG, MD, DOCX, IPYNB, PDF) alongside images
+- Add improved onboarding experience for new users with guided setup
+- Add prompt cache indicator for Gemini 2.5 Flash models
+- Update SambaNova provider with new model list and documentation links (Thanks @luisfucros!)
+- Fix diff editing support for Claude 4 family of models
+- Improve telemetry and analytics for better user experience insights
+
+## [3.17.5]
+
+- Fix issue with Claude 4 models where after several conversation turns, it would start making invalid diff edits
+
+## [3.17.4]
+
+- Fix thinking budget slider for Claude 4
+
+## [3.17.3]
+
+- Fix diff edit errors with Claude 4 models
+
+## [3.17.2]
+
+- Add support for Claude 4 models (Sonnet 4 and Opus 4) in AWS Bedrock and Vertex AI providers
+- Add support for global workflows, allowing workflows to be shared across workspaces with local workflows taking precedence
+- Fix settings page z-index UI issues that caused display problems
+- Fix AWS Bedrock environment variable handling to properly restore process.env after API calls (Thanks @DaveFres!)
+
+## [3.17.1]
+
+- Add prompt caching for Claude 4 models on Cline and OpenRouter providers
+- Increase max tokens for Claude Opus 4 from 4096 to 8192
+
+## [3.17.0]
+
+- Add support for Anthropic Claude Sonnet 4 and Claude Opus 4 in both Anthropic and Vertex providers
+- Add integration with Nebius AI Studio as a new provider (Thanks @Aktsvigun!)
+- Add custom highlight and hotkey suggestion when the assistant prompts to switch to Act mode
+- Update settings page design, now split into tabs for easier navigation (Thanks Yellow Bat @dlab-anton, and Roo Team!)
+- Fix MCP Server configuration bug
+- Fix model listing for Requesty provider
+- Move all advanced settings to settings page
+
+## [3.16.3]
+
+- Add devstral-small-2505 to the Mistral model list, a new specialized coding model from Mistral AI (Thanks @BarreiroT!)
+- Add documentation links to rules & workflows UI
+- Add support for Streameable HTTP Transport for MCPs (Thanks @alejandropta!)
+- Improve error handling for Mistral SDK API
+
+## [3.16.2]
+
+- Add support for Gemini 2.5 Flash Preview 05-20 model to Vertex AI provider with massive 1M token context window (Thanks @omercelik!)
+- Add keyboard shortcut (Cmd+') to quickly focus Cline from anywhere in VS Code
+- Add lightbulb actions for selected text with options to "Add to Cline", "Explain with Cline", and "Improve with Cline"
+- Automatically focus Cline window after extension updates
+
+## [3.16.1]
+
+- Add Enable auto approve toggle switch, allowing users to easily turn auto-approve functionality on or off without losing their action settings
+- Improve Gemini retry handling with better UI feedback, showing retry progress during API request attempts
+- Fix memory leak issue that could occur during long sessions with multiple tasks
+- Improve UI for Gemini model retry attempts with clearer status updates
+- Fix quick actions functionality in auto-approve settings
+- Update UI styling for auto-approve menu items to conserve space
+
+## [3.16.0]
+
+- Add new workflow feature allowing users to create and manage workflow files that can be injected into conversations via slash commands
+- Add collapsible recent task list, allowing users to hide their task history when sharing their screen (Thanks @cosmix!)
+- Add global endpoint option for Vertex AI users, providing higher availability and reducing 429 errors (Thanks @soniqua!)
+- Add detection for new users to display special components and guidance
+- Add Tailwind CSS IntelliSense to the recommended extensions list
+- Fix eternal loading states when the last message is a checkpoint (Thanks @BarreiroT!)
+- Improve settings organization by migrating VSCode Advanced settings to Settings Webview
+
+## [3.15.5]
+
+- Fix inefficient memory management in the task timeline
+- Fix Gemini rate limitation response not being handled properly (Thanks @BarreiroT!)
+
+## [3.15.4]
+
+- Add gemini model back to vertex provider
+- Add gemini telemetry
+- Add filtering for tasks tied to the current workspace
+
+## [3.15.3]
+
+- Add Fireworks API Provider
+- Fix minor visual issues with auto-approve menu
+- Fix one instance of terminal not getting output
+- Fix 'Chrome was launched but debug port is not responding' error
+
+## [3.15.2]
+
+- Added details to auto approve menu and more sensible default controls
+- Add detailed configuration options for LiteLLM provider
+- Add webview telemetry for users who have opted in to telemetry
+- Update Gemini in OpenRouter/Cline providers to use implicit caching
+- Fix freezing issues during rendering of large streaming text
+- Fix grey screen webview crashes by releasing memory after every diff edit
+- Fix breaking out of diff auto-scroll
+- Fix IME composition Enter auto‑sending edited message
+
+## [3.15.1]
+
+- Fix bug where PowerShell commands weren't given enough time before giving up and showing an error
+
+## [3.15.0]
+
+- Add Task Timeline visualization to tasks (Thanks eomcaleb!)
+- Add cache to ui for OpenAi provider
+- Add FeatureFlagProvider service for the Node.js extension side
+- Add copy buttons to task header and assistant messages
+- Add a more simplified home header was added
+- Add ability to favorite a task, allowing it to be kept when clearing all tasks
+- Add npm script for issue creation (Thanks DaveFres!)
+- Add confirmation dialog to Delete All History button
+- Add ability to allow the user to type their next message into the chat while Cline is taking action
+- Add ability to generate commit message via cline (Thanks zapp88!)
+- Add improvements to caching for gemini models on OpenRouter and Cline providers
+- Add improvements to allow scrolling the file being edited.
+- Add ui for windsurf and cursor rules
+- Add mistral medium-3 model
+- Add option to collect events to send them in a bundle to avoid sending too many events
+- Add support to quote a previous message in chat
+- Add support for Gemini Implicit Caching
+- Add support for batch selection and deletion of tasks in history (Thanks danix800!)
+- Update change suggested models
+- Update fetch cache details from generation endpoint
+- Update converted docs to Mintlify
+- Update the isOminiModel to include o4-mini model (Thanks PeterDaveHello!)
+- Update file size that can be read by Cline, allowing larger files
+- Update defaults for bedrock API models (Thanks Watany!)
+- Update to extend ReasoningEffort to non-o3-mini reasoning models for all providers (Thanks PeterDaveHello!)
+- Update to give error when a user tries to upload an image larger than 7500x7500 pixels
+- Update announcement so that previous updates are in a dropdown
+- Update UI for auto approve with favorited settings
+- Fix bug where certain terminal commands would lock you out of a task
+- Fix only initialize posthog in the webview if the user has opted into telemetry
+- Fix bug where autocapture was on for front-end telemetry
+- Fix for markdown copy excessively escaping characters (Thanks weshoke!)
+- Fix an issue where loading never finished when using an application inference profile for the model ID (Thanks WinterYukky!)
+
+## [3.14.1]
+
+- Disables autocaptures when initializing feature flags
+
+## [3.14.0]
+
+- 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 when 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!)
+
+## [3.13.3]
+
+- Add download counts to MCP marketplace items
+- Add `/compact` command
+- Add prompt caching to gemini models in cline / openrouter providers
+- Add tooltips to bottom row menu
+
+## [3.13.2]
+
+- Add Gemini 2.5 Flash model to Vertex and Gemini Providers (Thanks monotykamary!)
+- Add Caching to gemini provider (Thanks arafatkatze!)
+- Add thinking budget support to Gemini Models (Thanks monotykamary!)
+- Add !include .file directive support for .clineignore (Thanks watany-dev!)
+- Improve slash command functionality
+- Improve prompting for new task tool
+- Fix o1 temperature being passed to the azure api (Thanks treeleaves30760!)
+- Fix to make "add new rule file" button functional
+- Fix Ollama provider timeout, allowing for a larger loading time (Thanks suvarchal!)
+- Fix Non-UTF-8 File Handling: Improve Encoding Detection to Prevent Garbled Text and Binary Misclassification (Thanks yt3trees!)
+- Fix settings to not reset by changing providers
+- Fix terminal outputs missing commas
+- Fix terminal errors caused by starting non-alphanumeric outputs
+- Fix auto approve settings becoming unset
+- Fix Mermaid syntax error in documentation (Thanks tuki0918!)
+- Remove supportsComputerUse restriction and support browser use through any model that supports images (Thanks arafatkatze!)
+
+## [3.13.1]
+
+- Fix bug where task cancellation during thinking stream would result in error state
+
+## [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!)
+
+## [3.12.3]
+
+- Add copy button to MermaidBlock component (Thanks @cacosub7!)
+- Add the ability to fetch from global cline rules files
+- Add icon to indicate when a file outside of the users workspace is edited
+
+## [3.12.2]
+
+- Add gpt-4.1
+
+## [3.12.1]
+
+- Use visual checkpoint indicator to make it clear when checkpoints are created
+- Big shoutout to @samuel871211 for numerous code quality improvements, refactoring contributions, and webview performance improvements!
+- Use improved context manager
+
+## [3.12.0]
+
+- Add favorite toggles for models when using the Cline & OpenRouter providers
+- Add auto-approve options for edits/reads outside of the workspace
+- Improve diff editing animation for large files
+- Add indicator showing number of diff edits when Cline edits a file
+- Add streaming support and reasoning effort option to xAI's Grok 3 Mini
+- Add settings button to MCP popover to easily modify installed servers
+- Fix bug where browser tool actions would show unparsed results in the chat view
+- Fix issue with new checkpoints popover hiding too quickly
+- Fix duplicate checkpoints bug
+- Improve Ollama provider with retry mechanism, timeout handling, and improved error handling (thanks suvarchal!)
+
+## [3.11.0]
+
+- Redesign checkpoint UI to declutter chat view by using a subtle indicator line that expands to a popover on hover, with a new date indicator for when it was created
+- Add support for xAI's provider's Grok 3 models
+- Add more robust error tracking for users opted in to telemetry (thank you for helping us make Cline better!)
+
+## [3.10.1]
+
+- Add CMD+' keyboard shortcut to add selected text to Cline
+- Cline now auto focuses the text field when using 'Add to Cline' shortcut
+- Add new 'Create New Task' tool to let Cline start a new task autonomously!
+- Fix Mermaid diagram issues
+- Fix Gemini provider cost calculation to take new tiered pricing structure into account
+
+## [3.10.0]
+
+- Add setting to let browser tool use local Chrome via remote debugging, enabling session-based browsing. Replaces sessionless Chromium, unlocking debugging and productivity workflows tied to your real browser state.
+- Add new auto-approve option to approve _ALL_ commands (use at your own risk!)
+- Add modal in the chat area to more easily enable or disable MCP servers
+- Add drag and drop of file/folders into cline chat (Thanks eljapi!)
+- Add prompt caching for LiteLLM + Claude (Thanks sammcj!)
+- Add Improved context management
+- Fix MCP auto approve toggle issues being out of sync with settings
+
+## [3.9.2]
+
+- Add recommended models for Cline provider
+- Add ability to detect when user edits files manually so Cline knows to re-read, leading to reduced diff edit errors
+- Add improvements to file mention searching for faster searching
+- Add scoring logic to file mentions to sort and exclude results based on relevance
+- Add Support for Bytedance Doubao (Thanks Tunixer!)
+- Fix to prevent duplicate BOM (Thanks bamps53!)
+
+## [3.9.1]
+
+- Add Gemini 2.5 Pro Preview 03-25 to Google Provider
+
+## [3.9.0]
+
+- Add Enable extended thinking for LiteLLM provider (Thanks @jorgegarciarey!)
+- Add a tab for configuring local MCP Servers
+- Fix issue with DeepSeek API provider token counting + context management
+- Fix issues with checkpoints hanging under certain conditions
+
+## [3.8.6]
+
+- Add UI for adding remote servers
+- Add Mentions Feature Guide and update related documentation
+- Fix bug where menu would open in sidebar and open tab
+- Fix issue with Cline accounts not showing user info in popout tabs
+- Fix bug where menu buttons wouldn't open view in sidebar
+
+## [3.8.5]
+
+- Add support for remote MCP Servers using SSE
+- Add gemini-2.5-pro-exp-03-25 to Vertex AI (thanks @arri-cc!)
+- Add access to history, mcp, and new task buttons in popout view
+- Add task feedback telemetry (thumbs up/down on task completion)
+- Add toggle disabled for remote servers
+- Move the MCP Restart and Delete buttons and add an auto-approve all toggle
+- Update Requestly UX for model selection (thanks @arafatkatze!)
+- Add escape for html content for gemini when running commands
+- Improve search and replace edit failure behaviors
+
+## [3.8.4]
+
+- Add Sambanova Deepseek-V3-0324
+- Add cost calculation support for LiteLLM provider
+- Fix bug where Cline would use plan_mode_response bug without response parameter
+
+## [3.8.3]
+
+- Add support for SambaNova QwQ-32B model
+- Add OpenAI "dynamic" model chatgpt-4o-latest
+- Add Amazon Nova models to AWS Bedrock
+- Improve file handling for NextJS folder naming (fixes issues with parentheses in folder names)
+- Add Gemini 2.5 Pro to Google AI Studio available models
+- Handle "input too large" errors for Anthropic
+- Fix "See more" not showing up for tasks after task un-fold
+- Fix gpt-4.5-preview's supportsPromptCache value to true
+
+## [3.8.2]
+
+- Fix bug where switching to plan/act would result in VS Code LM/OpenRouter model being reset
+
+## [3.8.0]
+
+- Add 'Add to Cline' as an option when you right-click in a file or the terminal, making it easier to add context to your current task
+- Add 'Fix with Cline' code action - when you see a lightbulb icon in your editor, you can now select 'Fix with Cline' to send the code and associated errors for Cline to fix. (Cursor users can also use the 'Quick Fix (CMD + .)' menu to see this option)
+- Add Account view to display billing and usage history for Cline account users. You can now keep track of credits used and transaction history right in the extension!
+- Add 'Sort underling provider routing' setting to Cline/OpenRouter allowing you to sort provider used by throughput, price, latency, or the default (combination of price and uptime)
+- Improve rich MCP display with dynamic image loading and support for GIFs
+- Add 'Documentation' menu item to easily access Cline's docs
+- Add OpenRouter's new usage_details feature for more reliable cost reporting
+- Display total space Cline takes on disk next to 'Delete all Tasks' button in History view
+- Fix 'Context Window Exceeded' error for OpenRouter/Cline Accounts (additional support coming soon)
+- Fix bug where OpenRouter model ID would be set to invalid value
+- Add button to delete MCP servers in a failure state
+
+## [3.7.1]
+
+- Fix issue with 'See more' button in task header not showing when starting new tasks
+- Fix issue with checkpoints using local git commit hooks
+
+## [3.7.0]
+
+- Cline now displays selectable options when asking questions or presenting a plan, saving you from having to type out responses!
+- Add support for a `.clinerules/` directory to load multiple files at once (thanks @ryo-ma!)
+- Prevent Cline from reading extremely large files into context that would overload context window
+- Improve checkpoints loading performance and display warning for large projects not suited for checkpoints
+- Add SambaNova API provider (thanks @saad-noodleseed!)
+- Add VPC endpoint option for AWS Bedrock profiles (thanks @minorunara!)
+- Add DeepSeek-R1 to AWS Bedrock (thanks @watany-dev!)
+
+## [3.6.5]
+
+- Add 'Delete all Task History' button to History view
+- Add toggle to disable model switching between Plan/Act modes in Settings (new users default to disabled)
+- Add temperature option to OpenAI Compatible
+- Add Kotlin support to tree-sitter parser (thanks @fumiya-kume!)
+
+## [3.6.3]
+
+- Improve QwQ support for Alibaba (thanks @meglinge!) and OpenRouter
+- Improve diff edit prompting to prevent immediately reverting to write_to_file when a model uses search patterns that don't match anything in the file
+- Fix bug where new checkpoints system would revert file changes when switching between tasks
+- Fix issue with incorrect token count for some OpenAI compatible providers
+
+## [3.6.0]
+
+- Add Cline API as a provider option, allowing new users to sign up and get started with Cline for free
+- Optimize checkpoints with branch-per-task strategy, reducing storage required and first task load times
+- Fix problem with Plan/Act toggle keyboard shortcut not working in Windows (thanks @yt3trees!)
+- Add new Gemini models to GCP Vertex (thanks @shohei-ihaya!) and Claude models AskSage (thanks @swhite24!)
+- Improve OpenRouter/Cline error reporting
+
+## [3.5.1]
+
+- Add timeout option to MCP servers
+- Add Gemini Flash models to Vertex provider (thanks @jpaodev!)
+- Add prompt caching support for AWS Bedrock provider (thanks @buger!)
+- Add AskSage provider (thanks @swhite24!)
+
+## [3.5.0]
+
+- Add 'Enable extended thinking' option for Claude 3.7 Sonnet, with ability to set different budgets for Plan and Act modes
+- Add support for rich MCP responses with automatic image previews, website thumbnails, and WolframAlpha visualizations
+- Add language preference option in Advanced Settings
+- Add xAI Provider Integration with support for all Grok models (thanks @andrewmonostate!)
+- Fix issue with Linux XDG pointing to incorrect path for Document folder (thanks @jonatkinson!)
+
+## [3.4.10]
+
+- Add support for GPT-4.5 preview model
+
+## [3.4.9]
+
+- Add toggle to let users opt-in to anonymous telemetry and error reporting
+
+## [3.4.6]
+
+- Add support for Claude 3.7 Sonnet
+
+## [3.4.0]
+
+- Introducing MCP Marketplace! You can now discover and install the best MCP servers right from within the extension, with new servers added regularly
+- Add mermaid diagram support in Plan mode! You can now see visual representations of mermaid code blocks in chat, and click on them to see an expanded view
+- Use more visual checkpoints indicators after editing files & running commands
+- Create a checkpoint at the beginning of each task to easily revert to the initial state
+- Add 'Terminal' context mention to reference the active terminal's contents
+- Add 'Git Commits' context mention to reference current working changes or specific commits (thanks @mrubens!)
+- Send current textfield contents as additional feedback when toggling from Plan to Act Mode, or when hitting 'Approve' button
+- Add advanced configuration options for OpenAI Compatible (context window, max output, pricing, etc.)
+- Add Alibaba Qwen 2.5 coder models, VL models, and DeepSeek-R1/V3 support
+- Improve support for AWS Bedrock Profiles
+- Fix Mistral provider support for non-codestral models
+- Add advanced setting to disable browser tool
+- Add advanced setting to set chromium executable path for browser tool
+
+## [3.3.2]
+
+- Fix bug where OpenRouter requests would periodically not return cost/token stats, leading to context window limit errors
+- Make checkpoints more visible and keep track of restored checkpoints
+
+## [3.3.0]
+
+- Add .clineignore to block Cline from accessing specified file patterns
+- Add keyboard shortcut + tooltips for Plan/Act toggle
+- Fix bug where new files won't show up in files dropdown
+- Add automatic retry for rate limited requests (thanks @ViezeVingertjes!)
+- Adding reasoning_effort support for o3-mini in Advanced Settings
+- Added support for AWS provider profiles using the AWS CLI to make the profile, enabling long lived connections to AWS bedrock
+- Adding Requesty API provider
+- Add Together API provider
+- Add Alibaba Qwen API provider (thanks @aicccode!)
+
+## [3.2.13]
+
+- Add new gemini models gemini-2.0-flash-lite-preview-02-05 and gemini-2.0-flash-001
+- Add all available Mistral API models (thanks @ViezeVingertjes!)
+- Add LiteLLM API provider support (thanks @him0!)
+
+## [3.2.12]
+
+- Fix command chaining for Windows users
+- Fix reasoning_content error for OpenAI providers
+
+## [3.2.11]
+
+- Add OpenAI o3-mini model
+
+## [3.2.10]
+
+- Improve support for DeepSeek-R1 (deepseek-reasoner) model for OpenRouter, OpenAI-compatible, and DeepSeek direct (thanks @Szpadel!)
+- Show Reasoning tokens for models that support it
+- Fix issues with switching models between Plan/Act modes
+
+## [3.2.6]
+
+- Save last used API/model when switching between Plan and Act, for users that like to use different models for each mode
+- New Context Window progress bar in the task header to understand increased cost/generation degradation as the context increases
+- Localize READMEs and add language selector for English, Spanish, German, Chinese, and Japanese
+- Add Advanced Settings to remove MCP prompts from requests to save tokens, enable/disable checkpoints for users that don't use git (more coming soon!)
+- Add Gemini 2.0 Flash Thinking experimental model
+- Allow new users to subscribe to mailing list to get notified when new Accounts option is available
+
+## [3.2.5]
+
+- Use yellow textfield outline in Plan mode to better distinguish from Act mode
+
+## [3.2.3]
+
+- Add DeepSeek-R1 (deepseek-reasoner) model support with proper parameter handling (thanks @slavakurilyak!)
+
+## [3.2.0]
+
+- Add Plan/Act mode toggle to let you plan tasks with Cline before letting him get to work
+- Easily switch between API providers and models using a new popup menu under the chat field
+- Add VS Code LM API provider to run models provided by other VS Code extensions (e.g. GitHub Copilot). Shoutout to @julesmons, @RaySinner, and @MrUbens for putting this together!
+- Add on/off toggle for MCP servers to disable them when not in use. Thanks @MrUbens!
+- Add Auto-approve option for individual tools in MCP servers. Thanks @MrUbens!
+
+## [3.1.10]
+
+- New icon!
+
+## [3.1.9]
+
+- Add Mistral API provider with codestral-latest model
+
+## [3.1.7]
+
+- Add ability to change viewport size and headless mode when Cline asks to launch the browser
+
+## [3.1.6]
+
+- Fix bug where filepaths with Chinese characters would not show up in context mention menu (thanks @chi-chat!)
+- Update Anthropic model prices (thanks @timoteostewart!)
+
+## [3.1.5]
+
+- Fix bug where Cline couldn't read "@/" import path aliases from tool results
+
+## [3.1.4]
+
+- Fix issue where checkpoints would not work for users with git commit signing enabled globally
+
+## [3.1.2]
+
+- Fix issue where LFS files would be not be ignored when creating checkpoints
+
+## [3.1.0]
+
+- Added checkpoints: Snapshots of workspace are automatically created whenever Cline uses a tool
+- Compare changes: Hover over any tool use to see a diff between the snapshot and current workspace state
+- Restore options: Choose to restore just the task state, just the workspace files, or both
+- New 'See new changes' button appears after task completion, providing an overview of all workspace changes
+- Task header now shows disk space usage with a delete button to help manage snapshot storage
+
+## [3.0.12]
+
+- Fix DeepSeek API cost reporting (input price is 0 since it's all either a cache read or write, different than how Anthropic reports cache usage)
+
+## [3.0.11]
+
+- Emphasize auto-formatting done by the editor in file edit responses for more reliable diff editing
+
+## [3.0.10]
+
+- Add DeepSeek provider to API Provider options
+- Fix context window limit errors for DeepSeek v3
+
+## [3.0.9]
+
+- Fix bug where DeepSeek v3 would incorrectly escape HTML entities in diff edits
+
+## [3.0.8]
+
+- Mitigate DeepSeek v3 diff edit errors by adding 'auto-formatting considerations' to system prompt, encouraging model to use updated file contents as reference point for SEARCH blocks
+
+## [3.0.7]
+
+- Revert to using batched file watcher to fix crash when many files would be created at once
+
+## [3.0.6]
+
+- Fix bug where some files would be missing in the `@` context mention menu
+- Add Bedrock support in additional regions
+- Diff edit improvements
+- Add OpenRouter's middle-out transform for models that don't use prompt caching (prevents context window limit errors, but cannot be applied to models like Claude since it would continuously break the cache)
+
+## [3.0.4]
+
+- Fix bug where gemini models would add code block artifacts to the end of text content
+- Fix context mention menu visual issues on light themes
+
+## [3.0.2]
+
+- Adds block anchor matching for more reliable diff edits (if 3+ lines, first and last line are used as anchors to search for)
+- Add instruction to system prompt to use complete lines in diff edits to work properly with fallback strategies
+- Improves diff edit error handling
+- Adds new Gemini models
+
+## [3.0.0]
+
+- Cline now uses a search & replace diff based approach when editing large files to prevent code deletion issues.
+- Adds support for a more comprehensive auto-approve configuration, allowing you to specify which tools require approval and which don't.
+- Adds ability to enable system notifications for when Cline needs approval or completes a task.
+- Adds support for a root-level `.clinerules` file that can be used to specify custom instructions for the project.
+
+## [2.2.0]
+
+- Add support for Model Context Protocol (MCP), enabling Cline to use custom tools like web-search tool or GitHub tool
+- Add MCP server management tab accessible via the server icon in the menu bar
+- Add ability for Cline to dynamically create new MCP servers based on user requests (e.g., "add a tool that gets the latest npm docs")
+
+## [2.1.6]
+
+- Add LM Studio as an API provider option (make sure to start the LM Studio server to use it with the extension!)
+
+## [2.1.5]
+
+- Add support for prompt caching for new Claude model IDs on OpenRouter (e.g. `anthropic/claude-3.5-sonnet-20240620`)
+
+## [2.1.4]
+
+- AWS Bedrock fixes (add missing regions, support for cross-region inference, and older Sonnet model for regions where new model is not available)
+
+## [2.1.3]
+
+- Add support for Claude 3.5 Haiku, 66% cheaper than Sonnet with similar intelligence
+
+## [2.1.2]
+
+- Misc. bug fixes
+- Update README with new browser feature
+
+## [2.1.1]
+
+- Add stricter prompt to prevent Cline from editing files during a browser session without first closing the browser
+
+## [2.1.0]
+
+- Cline now uses Anthropic's new "Computer Use" feature to launch a browser, click, type, and scroll. This gives him more autonomy in runtime debugging, end-to-end testing, and even general web use. Try asking "Look up the weather in Colorado" to see it in action! (Available with Claude 3.5 Sonnet v2)
+
+## [2.0.19]
+
+- Fix model info for Claude 3.5 Sonnet v1 on OpenRouter
+
+## [2.0.18]
+
+- Add support for both v1 and v2 of Claude 3.5 Sonnet for GCP Vertex and AWS Bedrock (for cases where the new model is not enabled yet or unavailable in your region)
+
+## [2.0.17]
+
+- Update Anthropic model IDs
+
+## [2.0.16]
+
+- Adjustments to system prompt
+
+## [2.0.15]
+
+- Fix bug where modifying Cline's edits would lead him to try to re-apply the edits
+- Fix bug where weaker models would display file contents before using the write_to_file tool
+- Fix o1-mini and o1-preview errors when using OpenAI native
+
+## [2.0.14]
+
+- Gracefully cancel requests while stream could be hanging
+
+## [2.0.13]
+
+- Detect code omission and show warning with troubleshooting link
+
+## [2.0.12]
+
+- Keep cursor out of the way during file edit streaming animation
+
+## [2.0.11]
+
+- Adjust prompts around read_file to prevent re-reading files unnecessarily
+
+## [2.0.10]
+
+- More adjustments to system prompt to prevent lazy coding
+
+## [2.0.9]
+
+- Update system prompt to try to prevent Cline from lazy coding (`// rest of code here...`)
+
+## [2.0.8]
+
+- Fix o1-mini and o1-preview for OpenAI
+- Fix diff editor not opening sometimes in slow environments like project idx
+
+## [2.0.7]
+
+- Misc. bug fixes
+
+## [2.0.6]
+
+- Update URLs to https://github.com/cline/cline
+
+## [2.0.5]
+
+- Fixed bug where Cline's edits would stream into the active tab when switching tabs during a write_to_file
+- Added explanation in task continuation prompt that an interrupted write_to_file reverts the file to its original contents, preventing unnecessary re-reads
+- Fixed non-first chunk error handling in case stream fails mid-way through
+
+## [2.0.0]
+
+- New name! Meet Cline, an AI assistant that can use your CLI and Editor
+- Responses are now streamed with a yellow text decoration animation to keep track of Cline's progress as he edits files
+- New Cancel button to give Cline feedback if he goes off in the wrong direction, giving you more control over tasks
+- Re-imagined tool calling prompt resulting in ~40% fewer requests to accomplish tasks + better performance with other models
+- Search and use any model with OpenRouter
+
+## [1.9.7]
+
+- Only auto-include error diagnostics after file edits, removed warnings to keep Claude from getting distracted in projects with strict linting rules
+
+## [1.9.6]
+
+- Added support for new Google Gemini models `gemini-1.5-flash-002` and `gemini-1.5-pro-002`
+- Updated system prompt to be more lenient when terminal output doesn't stream back properly
+- Adjusted system prompt to prevent overuse of the inspect_site tool
+- Increased global line height for improved readability
+
+## [1.9.0]
+
+- Claude can now use a browser! This update adds a new `inspect_site` tool that captures screenshots and console logs from websites (including localhost), making it easier for Claude to troubleshoot issues on his own.
+- Improved automatic linter/compiler debugging by only sending Claude new errors that result from his edits, rather than reporting all workspace problems.
+
+## [1.8.0]
+
+- You can now use '@' in the textarea to add context!
+- @url: Paste in a URL for the extension to fetch and convert to markdown, useful when you want to give Claude the latest docs!
+- @problems: Add workspace errors and warnings for Claude to fix, no more back-and-forth about debugging
+- @file: Adds a file's contents so you don't have to waste API requests approving read file (+ type to search files)
+- @folder: Adds folder's files all at once to speed up your workflow even more
+
+## [1.7.0]
+
+- Adds problems monitoring to keep Claude updated on linter/compiler/build issues, letting him proactively fix errors on his own! (adding missing imports, fixing type errors, etc.)
+
+## [1.6.5]
+
+- Adds support for OpenAI o1, Azure OpenAI, and Google Gemini (free for up to 15 requests per minute!)
+- Task header can now be collapsed to provide more space for viewing conversations
+- Adds fuzzy search and sorting to Task History, making it easier to find specific tasks
+
+## [1.6.0]
+
+- Commands now run directly in your terminal thanks to VSCode 1.93's new shell integration updates! Plus a new 'Proceed While Running' button to let Claude continue working while commands run, sending him new output along the way (i.e. letting him react to server errors as he edits files)
+
+## [1.5.27]
+
+- Claude's changes now appear in your file's Timeline, allowing you to easily view a diff of each edit. This is especially helpful if you want to revert to a previous version. No need for git—everything is tracked by VSCode's local history!
+- Updated system prompt to keep Claude from re-reading files unnecessarily
+
+## [1.5.19]
+
+- Adds support for OpenAI compatible API providers (e.g. Ollama!)
+
+## [1.5.13]
+
+- New terminal emulator! When Claude runs commands, you can now type directly in the terminal (+ support for Python environments)
+- Adds search to Task History
+
+## [1.5.6]
+
+- You can now edit Claude's changes before accepting! When he edits or creates 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 `// rest of code here` shenanigans)
+
+## [1.5.4]
+
+- Adds support for reading .pdf and .docx files (try "turn my business_plan.docx into a company website")
+
+## [1.5.0]
+
+- Adds new `search_files` tool that lets Claude perform regex searches in your project, making it easy for him to refactor code, address TODOs and FIXMEs, remove dead code, and more!
+
+## [1.4.0]
+
+- Adds "Always allow read-only operations" setting to let Claude read files and view directories without needing approval (off by default)
+- Implement sliding window context management to keep tasks going past 200k tokens
+- Adds Google Cloud Vertex AI support and updates Claude 3.5 Sonnet max output to 8192 tokens for all providers.
+- Improves system prompt to guard against lazy edits (less "//rest of code here")
+
+## [1.3.0]
+
+- Adds task history
+
+## [1.2.0]
+
+- Adds support for Prompt Caching to significantly reduce costs and response times (currently only available through Anthropic API for Claude 3.5 Sonnet and Claude 3.0 Haiku)
+
+## [1.1.1]
+
+- Adds option to choose other Claude models (+ GPT-4o, DeepSeek, and Mistral if you use OpenRouter)
+- Adds option to add custom instructions to the end of the system prompt
+
+## [1.1.0]
+
+- Paste images in chat to use Claude's vision capabilities and turn mockups into fully functional applications or fix bugs with screenshots
+
+## [1.0.9]
+
+- Add support for OpenRouter and AWS Bedrock
+
+## [1.0.8]
+
+- Shows diff view of new or edited files right in the editor
+
+## [1.0.7]
+
+- Replace `list_files` and `analyze_project` with more explicit `list_files_top_level`, `list_files_recursive`, and `view_source_code_definitions_top_level` to get source code definitions only for files relevant to the task
+
+## [1.0.6]
+
+- Interact with CLI commands by sending messages to stdin and terminating long-running processes like servers
+- Export tasks to markdown files (useful as context for future tasks)
+
+## [1.0.5]
+
+- Claude now has context about vscode's visible editors and opened tabs
+
+## [1.0.4]
+
+- Open in the editor (using menu bar or `Claude Dev: Open In New Tab` in command palette) to see how Claude updates your workspace more clearly
+- New `analyze_project` tool to help Claude get a comprehensive overview of your project's source code definitions and file structure
+- Provide feedback to tool use like terminal commands and file edits
+- Updated max output tokens to 8192 so less lazy coding (`// rest of code here...`)
+- Added ability to retry failed API requests (helpful for rate limits)
+- Quality of life improvements like markdown rendering, memory optimizations, better theme support
+
+## [0.0.6]
+
+- Initial release
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..3547e46
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+-   Using welcoming and inclusive language
+-   Being respectful of differing viewpoints and experiences
+-   Gracefully accepting constructive criticism
+-   Focusing on what is best for the community
+-   Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+-   The use of sexualized language or imagery and unwelcome sexual attention or
+    advances
+-   Trolling, insulting/derogatory comments, and personal or political attacks
+-   Public or private harassment
+-   Publishing others' private information, such as a physical or electronic
+    address, without explicit permission
+-   Other conduct which could reasonably be considered inappropriate in a
+    professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at hi@cline.bot. All complaints
+will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..f823b68
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,209 @@
+# Contributing to Cline
+
+We're thrilled you're interested in contributing to Cline. Whether you're fixing a bug, adding a feature, or improving our docs, every contribution makes Cline smarter! To keep our community vibrant and welcoming, all members must adhere to our [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## Reporting Bugs or Issues
+
+Bug reports help make Cline better for everyone! Before creating a new issue, please [search existing ones](https://github.com/cline/cline/issues) to avoid duplicates. When you're ready to report a bug, head over to our [issues page](https://github.com/cline/cline/issues/new/choose) where you'll find a template to help you with filling out the relevant information.
+
+<blockquote class='warning-note'>
+     🔐 <b>Important:</b> If you discover a security vulnerability, please use the <a href="https://github.com/cline/cline/security/advisories/new">Github security tool to report it privately</a>.
+</blockquote>
+
+
+## Before Contributing
+
+All contributions must begin with a GitHub Issue, unless the change is for small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality.
+**For features and contributions**:
+- First check the [Feature Requests discussions board](https://github.com/cline/cline/discussions/categories/feature-requests) for similar ideas
+- If your idea is new, create a new feature request  
+- Wait for approval from core maintainers before starting implementation
+- Once approved, feel free to begin working on a PR with the help of our community!
+
+**PRs without approved issues may be closed.**
+
+
+## Deciding What to Work On
+
+Looking for a good first contribution? Check out issues labeled ["good first issue"](https://github.com/cline/cline/labels/good%20first%20issue) or ["help wanted"](https://github.com/cline/cline/labels/help%20wanted). These are specifically curated for new contributors and areas where we'd love some help!
+
+We also welcome contributions to our [documentation](https://github.com/cline/cline/tree/main/docs)! Whether it's fixing typos, improving existing guides, or creating new educational content - we'd love to build a community-driven repository of resources that helps everyone get the most out of Cline. You can start by diving into `/docs` and looking for areas that need improvement.
+
+## Development Setup
+
+
+### Local Development Instructions
+
+1. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
+    ```bash
+    git clone https://github.com/cline/cline.git
+    ```
+2. Open the project in VSCode:
+    ```bash
+    code cline
+    ```
+3. Install [bun](https://bun.com)
+4. Install the necessary dependencies for the extension and webview-gui:
+    ```bash
+    cd apps/vscode && bun run install:all && cd ../..
+    cd sdk && bun run build && cd ..
+    ```
+5. Generate Protocol Buffer files (required before first build):
+6. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
+
+
+
+
+### Creating a Pull Request
+
+1. Commit your changes.
+
+2. Push your branch and create a PR on GitHub. Our CI will:
+   - Run tests and checks
+3. Testing
+    - Run `cd apps/vscode && bun run test` to run tests locally. 
+    - Before submitting PR, run `bun run format:fix` to format your code
+
+### Extension
+
+1. **VS Code Extensions**
+
+    - When opening the project, VS Code will prompt you to install recommended extensions
+    - These extensions are required for development - please accept all installation prompts
+    - If you dismissed the prompts, you can install them manually from the Extensions panel
+
+2. **Local Development**
+    - cd into the vscode extension, `cd apps/vscode`
+    - Run `bun run install:all` to install dependencies
+    - Run `bun run protos` to generate Protocol Buffer files (required before first build)
+    - Run `bun run test` to run tests locally
+    - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
+    - **Terminal Workflow**: Use `bun run dev` (generates protos + runs watch mode) or `bun run watch` (if protos already generated)
+    - Before submitting PR, run `bun run format:fix` to format your code
+
+3. **Linux-specific Setup**
+    VS Code extension tests on Linux require the following system libraries:
+
+    - `dbus`
+    - `libasound2`
+    - `libatk-bridge2.0-0`
+    - `libatk1.0-0`
+    - `libdrm2`
+    - `libgbm1`
+    - `libgtk-3-0`
+    - `libnss3`
+    - `libx11-xcb1`
+    - `libxcomposite1`
+    - `libxdamage1`
+    - `libxfixes3`
+    - `libxkbfile1`
+    - `libxrandr2`
+    - `xvfb`
+
+    These libraries provide necessary GUI components and system services for the test environment.
+
+    For example, on Debian-based distributions (e.g., Ubuntu), you can install these libraries using apt:
+    ```bash
+    sudo apt update
+    sudo apt install -y \
+      dbus \
+      libasound2 \
+      libatk-bridge2.0-0 \
+      libatk1.0-0 \
+      libdrm2 \
+      libgbm1 \
+      libgtk-3-0 \
+      libnss3 \
+      libx11-xcb1 \
+      libxcomposite1 \
+      libxdamage1 \
+      libxfixes3 \
+      libxkbfile1 \
+      libxrandr2 \
+      xvfb
+    ```
+
+## Writing and Submitting Code
+
+Anyone can contribute code to Cline, but we ask that you follow these guidelines to ensure your contributions can be smoothly integrated:
+
+1. **Keep Pull Requests Focused**
+
+    - Limit PRs to a single feature or bug fix
+    - Split larger changes into smaller, related PRs
+    - Break changes into logical commits that can be reviewed independently
+
+2. **Code Quality**
+
+    - Run `bun run lint` to check code style
+    - Run `bun run format` to automatically format code
+    - All PRs must pass CI checks which include both linting and formatting
+    - Address any warnings or errors from linter before submitting
+    - Follow TypeScript best practices and maintain type safety
+
+3. **Testing**
+
+    - Add tests for new features
+    - Run `bun test` to ensure all tests pass
+    - Update existing tests if your changes affect them
+    - Include both unit tests and integration tests where appropriate
+
+    **End-to-End (E2E) Testing**
+    
+    Cline includes comprehensive E2E tests using Playwright that simulate real user interactions with the extension in VS Code:
+    
+    - **Running E2E tests:**
+      ```bash
+      bun run test:e2e        # Build and run all E2E tests
+      bun run e2e             # Run tests without rebuilding
+      bun run test:e2e -- --debug  # Run with interactive debugger
+      ```
+    
+    - **Writing E2E tests:**
+      - Tests are located in `src/test/e2e/`
+      - Use the `e2e` fixture for single-root workspace tests
+      - Use `e2eMultiRoot` fixture for multi-root workspace tests
+      - Follow existing patterns in `auth.test.ts`, `chat.test.ts`, `diff.test.ts`, and `editor.test.ts`
+      - See `src/test/e2e/README.md` for detailed documentation
+    
+    - **Debug mode features:**
+      - Interactive Playwright Inspector for step-by-step debugging
+      - Record new interactions and generate test code automatically
+      - Visual VS Code instance for manual testing
+      - Element inspection and selector validation
+    
+    - **Test environment:**
+      - Automated VS Code setup with Cline extension loaded
+      - Mock API server for backend testing
+      - Temporary workspaces with test fixtures
+      - Video recording for failed tests
+
+4. **Versioning & Changelog Notes**
+
+    - 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**
+
+    - Write clear, descriptive commit messages
+    - Use conventional commit format (e.g., "feat:", "fix:", "docs:")
+    - Reference relevant issues in commits using #issue-number
+
+6. **Before Submitting**
+
+    - Rebase your branch on the latest main
+    - Ensure your branch builds successfully
+    - Double-check all tests are passing
+    - Review your changes for any debugging code or console logs
+
+7. **Pull Request Description**
+    - Clearly describe what your changes do
+    - Include steps to test the changes
+    - List any breaking changes
+    - Add screenshots for UI changes
+
+## Contribution Agreement
+
+By submitting a pull request, you agree that your contributions will be licensed under the same license as the project ([Apache 2.0](LICENSE)).
+
+Remember: Contributing to Cline isn't just about writing code - it's about being part of a community that's shaping the future of AI-assisted development. Let's build something amazing together! 🚀
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..05ae14a
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Cline Bot Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..055918f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,239 @@
+<p align="center">
+  <img src="assets/icons/icon.png" width="80" alt="Cline" />
+</p>
+
+<h1 align="center">Cline</h1>
+
+<p align="center">
+The open source coding agent in your IDE and terminal.
+</p>
+
+<div align="center">
+
+<div align="center">
+<table>
+<tbody>
+<td align="center">
+<a href="https://docs.cline.bot" target="_blank"><strong>Docs</strong></a>
+</td>
+<td align="center">
+<a href="https://discord.gg/cline" target="_blank"><strong>Discord</strong></a>
+</td>
+<td align="center">
+<a href="https://www.reddit.com/r/cline/" target="_blank"><strong>r/cline</strong></a>
+</td>
+<td align="center">
+<a href="https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop" target="_blank"><strong>Feature Requests</strong></a>
+</td>
+<td align="center">
+<a href="https://cline.bot/join-us" target="_blank"><strong>Join us!</strong></a>
+</td>
+</tbody>
+</table>
+</div>
+
+</div>
+
+<br>
+
+<div align="center">
+<table>
+<tr>
+<td align="center" width="50%">
+
+### CLI
+
+Run Cline in your terminal.
+Interactive chat or fully headless
+for CI/CD and scripting.
+
+```
+npm i -g cline
+```
+
+<a href="./apps/cli/README.md">Learn more</a>
+<br><br>
+
+</td>
+<td align="center" width="50%">
+
+### Kanban
+
+Run many agents in parallel from a
+web-based task board. Each card gets its own
+worktree, auto-commit, and dependency chains.
+
+```
+npm i -g kanban
+```
+
+<a href="https://github.com/cline/kanban">Learn more</a>
+<br><br>
+
+</td>
+</tr>
+<tr>
+<td align="center" width="50%">
+
+### VS Code Extension
+
+AI coding assistant in your editor.
+Create files, run commands, browse the web,
+and use tools with human-in-the-loop approval.
+
+<a href="https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev">Install from VS Marketplace</a>
+<br><br>
+
+</td>
+<td align="center" width="50%">
+
+### JetBrains Plugin
+
+The same Cline experience in IntelliJ IDEA,
+PyCharm, WebStorm, GoLand, and the rest of
+the JetBrains family.
+
+<a href="https://plugins.jetbrains.com/plugin/28247-cline">Install from JetBrains Marketplace</a>
+<br><br>
+
+</td>
+</tr>
+</table>
+</div>
+
+<div align="center">
+<table>
+<tr>
+<td align="center">
+
+### SDK
+
+Build your own AI agents and integrations powered by the same engine that runs the CLI, Kanban, VS Code extension, and JetBrains plugin. Custom tools, multi-agent teams, connectors, scheduled automations, and more.
+
+```
+npm install @cline/sdk
+```
+
+<a href="https://docs.cline.bot/cline-sdk/overview">Documentation</a>
+<br><br>
+
+</td>
+</tr>
+</table>
+</div>
+
+---
+
+## Index
+
+| Product | Description | Location | CHANGELOG |
+|---------|------------|--------------|--------------|
+| **SDK** | Node.js programmatic agent API and extension exports. | [`sdk/`](https://github.com/cline/cline/tree/main/sdk) | [CHANGELOG.md](https://github.com/cline/cline/blob/main/sdk/CHANGELOG.md) |
+| **CLI** | Terminal UI, headless mode, shell commands, and CLI-specific flows. | [`apps/cli/`](https://github.com/cline/cline/tree/main/apps/cli) | [CHANGELOG.md](https://github.com/cline/cline/blob/main/apps/cli/CHANGELOG.md) |
+| **VS Code Extension** | The Marketplace extension and extension host integration. | [`/`](https://github.com/cline/cline/tree/main) (WIP migrating) | [CHANGELOG.md](https://github.com/cline/cline/blob/main/CHANGELOG.md) |
+| **JetBrains Plugin** | JetBrains-hosted client that talks to the shared agent core. | Currently we are not open-sourcing JetBrains plugins | - |
+| **Kanban** | Web-based multi-agent task board. | [`cline/kanban`](https://github.com/cline/kanban) | [CHANGELOG.md](https://github.com/cline/kanban/blob/main/CHANGELOG.md) |
+| **Docs site** | Public documentation pages. | [`docs/`](https://docs.cline.bot/) | - |
+
+## Edits Code Across Your Project
+
+Cline reads your project structure, understands the relationships between files, and makes coordinated changes across your codebase. It monitors linter and compiler errors as it works, fixing issues like missing imports, type mismatches, and syntax errors before you even see them. In VS Code and JetBrains, every edit shows up as a diff you can review, modify, or revert. All changes are tracked with checkpoints, so you can easily undo the agent's work.
+
+## Runs Bash Commands
+
+Cline executes commands directly in your terminal and watches the output in real time. Install packages, run build scripts, execute tests, deploy applications, manage databases. For long-running processes like dev servers, Cline continues working in the background and reacts to new output as it appears, catching compile errors, test failures, and server crashes as they happen.
+
+## Plan and Act
+
+Toggle between Plan mode and Act mode. In Plan mode, Cline explores your codebase, asks clarifying questions, and lays out a strategy. Once you're aligned, switch to Act mode and Cline executes the plan. Every file edit and terminal command requires your approval, so you stay in control of what actually changes. Or toggle auto-approve and let Cline run autonomously.
+
+## Rules and Skills
+
+Define project-specific rules in `.clinerules` files that guide how Cline works in your codebase: coding standards, architecture conventions, deployment procedures, testing requirements. Rules are picked up automatically by the CLI, VS Code extension, and JetBrains plugin. Use skills to let the model load specific rules when needed.
+
+## Works With Every Model
+
+Cline is not locked to a single AI provider. Use whichever model fits your workflow:
+
+| Provider | Models |
+|----------|--------|
+| Anthropic | Claude Opus, Sonnet, Haiku |
+| OpenAI | GPT series models |
+| Google | Gemini series models |
+| OpenRouter | 200+ models from any provider |
+| Vercel AI Gateway | Route to many providers through one gateway |
+| AWS Bedrock | Claude, Llama, and more |
+| Azure / GCP Vertex | All hosted models |
+| Cerebras / Groq | Fast inference models |
+| Ollama / LM Studio | Run local models on your machine |
+| Any OpenAI-compatible API | Self-hosted or third-party endpoints |
+
+## Extend With Plugins or MCP Servers
+
+Extend Cline's capabilities with plugins. Using the SDK, register tools and lifecycle hooks programmatically through the plugin system for logging, auditing, policy enforcement, or adding domain-specific capabilities. Simple plugin example below.
+
+```typescript
+import { Agent, createTool } from "@cline/sdk"
+
+const deployTool = createTool({
+  name: "deploy",
+  description: "Deploy the current branch to staging.",
+  inputSchema: { type: "object", properties: { env: { type: "string" } }, required: ["env"] },
+  execute: async (input) => {
+    // your deployment logic
+  },
+})
+
+const agent = new Agent({ tools: [deployTool], /* ... */ })
+```
+...or use [MCP servers](https://github.com/modelcontextprotocol) to connect to databases, query APIs, manage cloud infrastructure, and interact with external systems. Use [community-built servers](https://github.com/modelcontextprotocol/servers) or ask Cline to create custom tools on the fly. In the CLI, manage servers with `cline mcp`.
+
+## Multi-Agent Teams
+
+Coordinate multiple agents working together on complex tasks. A coordinator agent breaks the work into subtasks and delegates to specialist agents, each with their own tools and context. Team state persists across sessions so you can pick up where you left off.
+
+```bash
+cline --team-name auth-sprint "Plan and implement user authentication with tests"
+```
+
+## Scheduled Agents
+
+Run agents on cron schedules for recurring automations. Daily PR summaries, weekly dependency checks, codebase health reports. Schedules persist across restarts and run independently of any terminal session.
+
+```bash
+cline schedule create "PR summary" \
+  --cron "0 9 * * MON-FRI" \
+  --prompt "List all open PRs and their review status" \
+  --workspace /path/to/repo
+```
+
+## Connect to Slack, Telegram, Discord, and More
+
+Chat with your agent from any messaging platform: Telegram, Slack, Discord, Google Chat, WhatsApp, and Linear. Each conversation thread maps to an agent session with full context. Set up access control to restrict who can interact with your agent.
+
+```bash
+# Connect to Telegram
+cline connect telegram -k $BOT_TOKEN
+# Connect to Slack through webhook
+cline connect slack --bot-token $SLACK_TOKEN --signing-secret $SECRET --base-url $URL
+# Connect to Slack using socket mode
+cline connect slack --bot-token $SLACK_TOKEN --app-token $SLACK_APP_TOKEN
+```
+
+## Headless CLI for CI/CD
+
+Run Cline with zero interaction for scripting and automation. Pipe input, get JSON output, chain commands, integrate into CI/CD pipelines.
+
+```bash
+cline "Run tests and fix any failures"
+git diff origin/main | cline  "Review these changes for issues"
+cline --json "List all TODO comments" | jq -r 'select(.type == "agent_event" and .event.text) | .event.text'
+```
+
+## Contributing
+
+Start with the [Contributing Guide](CONTRIBUTING.md). Join our [Discord](https://discord.gg/cline) and head to the `#contributors` channel to connect with other contributors. Check our [careers page](https://cline.bot/join-us) for full-time roles.
+
+## License
+
+[Apache 2.0 © 2026 Cline Bot Inc.](./LICENSE)
diff --git a/README.wehub.md b/README.wehub.md
new file mode 100644
index 0000000..996d2e2
--- /dev/null
+++ b/README.wehub.md
@@ -0,0 +1,7 @@
+# WeHub 来源说明
+
+- 原始项目：`cline/cline`
+- 原始仓库：https://github.com/cline/cline
+- 导入方式：上游默认分支的最新快照
+- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准
+- 本文件仅用于记录来源，不代表 WeHub 是原项目作者
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..4807686
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,25 @@
+# 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 submit your report through our [Bugcrowd Vulnerability Disclosure Program](https://bugcrowd.com/engagements/clinebot-vdp-ess). Bugcrowd will manage communication and triage on our behalf.
+
+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
+
+Please keep the details private until a resolution has been reached.
+
+## Escalation
+
+If you are unable to submit through Bugcrowd, you may send an email to security@cline.bot.
+
+Thank you for helping us keep Cline users safe.
diff --git a/apps/biome.json b/apps/biome.json
new file mode 100644
index 0000000..54c3ae1
--- /dev/null
+++ b/apps/biome.json
@@ -0,0 +1,14 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.5/schema.json",
+	"root": false,
+	"extends": [
+		"../sdk/biome.json"
+	],
+	"linter": {
+		"rules": {
+			"a11y": {
+				"noStaticElementInteractions": "warn"
+			}
+		}
+	}
+}
diff --git a/apps/cli/.gitignore b/apps/cli/.gitignore
new file mode 100644
index 0000000..259ab83
--- /dev/null
+++ b/apps/cli/.gitignore
@@ -0,0 +1,5 @@
+# Cached binary created by postinstall
+bin/.cline
+
+# Bun compile temp files
+*.bun-build
diff --git a/apps/cli/CHANGELOG.md b/apps/cli/CHANGELOG.md
new file mode 100644
index 0000000..ac4a229
--- /dev/null
+++ b/apps/cli/CHANGELOG.md
@@ -0,0 +1,448 @@
+# Cline CLI Changelog
+
+## 3.0.39
+
+- You can now select Cline free models on the ClinePass provider in the model picker
+- Removed the retired ClinePass GLM 5.1 model
+- Fixed OpenAI Codex model metadata under the GPT Subscription provider
+- `str_replace` edits now report accurate diffs
+- Fixed context compaction so canonical session history is preserved
+- The detached hub daemon now emits telemetry, and telemetry identity now includes `user_id`
+- Cline provider requests now send versioned client-identity headers
+
+## 3.0.38
+
+- New plan/act accent palette: act mode is now blue (`#79b8ff`) and plan mode amber, replacing the old cyan/yellow — applied across dialogs, the model selector, config, onboarding, markdown, and syntax highlighting, with light-theme variants tuned for contrast
+- Restyled chat input: a minimal frame with full-width horizontal rules and a bold accent prompt glyph instead of the tinted background, plus slimmer user-message bubbles
+- Assistant markdown accents are now tinted by the mode (plan/act) they were produced in
+- Polished the status bar usage display and ClinePass model name
+- Harmonized the success/diff green and dark syntax-highlighting colors with the new brand palette
+- The thinking-level picker now defaults its cursor to Medium instead of Off
+- `read_files` now tolerates malformed input from weaker models: line-range entries (`start_line`/`end_line`) sent as separate array items are coalesced back onto the preceding file path instead of being rejected (from SDK v0.0.58)
+- Models in the live catalog that don't report a context window now default to a 128K input-token limit, so under-specified models get a usable context budget (from SDK v0.0.57)
+
+## 3.0.37
+
+- Weaker models (e.g. DeepSeek) that emit malformed tool calls — wrong argument types or truncated JSON — are now handled gracefully and run instead of erroring out
+- Plan/act mode switches are now visible to the model, so it knows when you change modes mid-session
+- Fixed plan/act mode notices being dropped from prompts sent to the model
+- Fixed a race where switching modes in an empty session could trigger an unexpected restart
+
+## 3.0.36
+
+- Fixed plan mode's `switch_to_act_mode` tool not taking effect until the end of the turn: the model would keep running with plan-mode tools (no file editor) and fall back to editing files through shell commands. Switching to act mode now ends the plan-mode run and automatically continues with the approved plan using the full act-mode toolset. A Tab mode toggle racing a completing turn can no longer auto-start plan execution you didn't approve.
+
+## 3.0.35
+
+- ClinePass is now enabled for all CLI users
+- Recover missing interactive sessions when reading messages
+- Format structured commands in history export
+- Add the subscription promo code when linking to the dashboard subscription page
+- Add Tencent TokenHub as a provider (from SDK v0.0.55)
+- Fix first-prompt truncation on high-output models (e.g. MiniMax M3) that could immediately auto-compact and cut the initial task down to just the input wrapper (from SDK v0.0.55)
+- Use a curated default when migrating legacy provider settings (from SDK v0.0.55)
+- Advertise run commands as shell strings (from SDK v0.0.55)
+- Refresh the bundled model catalog with the latest provider models (from SDK v0.0.55)
+
+## 3.0.34
+
+- Fixed the ClinePass upgrade notice appearing immediately after completing onboarding.
+- Improved the wording of the ClinePass onboarding step.
+- Streamlined the Cline provider picker by merging the subscription and usage/billing options into one and removing the credits link.
+
+## 3.0.33
+
+- Show a ClinePass subscription URL as a fallback during onboarding so you can still subscribe if the subscription screen can't open automatically
+- Hide the ClinePass promo for users who already have a ClinePass subscription
+- Use an adaptive plan accent color for ClinePass prompts so they fit the active theme
+
+## 3.0.32
+
+- Improved the ClinePass onboarding experience
+- Added an intermediate step before going to ClinePass model selection
+- Made the ClinePass subscription screen selectable
+- Promoted ClinePass in the startup notice
+- Used "ClinePass" as one word consistently and refined the provider UI copy
+- More accurate context compaction and clearer error messages (from SDK v0.0.54)
+
+## 3.0.31
+
+- Show when request cost is covered by your Cline subscription
+- Prompt to switch to ClinePass when you run out of credits, and list ClinePass features in the not-subscribed message
+- Added an option to open the subscription page from the ClinePass options
+- Added marketplace uninstall support and surfaced plugin-bundled skills
+- Require quoted prompts for one-shot mode
+- Capped MCP tool names at 64 characters for OpenAI-compatible providers
+- Updated coupon code
+
+## 3.0.30
+
+- Added a token count to the status bar, shown alongside cost
+- Added organization-specific error messages
+- Added SAP AI Core provider support
+- Refreshed the model catalog with the latest provider models
+- Preserved OpenRouter reasoning-disable behavior and improved OpenRouter prompt caching
+- Routed LiteLLM model fetches through the SDK and stopped unrelated models from appearing in the LiteLLM model list
+- Updated ClinePass models live, restored ClinePass models in onboarding, and improved ClinePass error messages
+- Threaded proxy/CA-aware networking into the inference path
+- Persisted Bedrock settings to providers.json
+- Normalized JSON-like tool inputs by schema for more reliable tool calls
+- Fixed an "ERROR: EMPTY CONTENT" message that could appear when an error occurred
+- Fixed a packaging issue (createRequire) that could break the CLI at runtime
+
+## 3.0.29
+
+- Costs are now hidden for Cline free models
+- Fixed Z.ai model metadata resolution for Z.ai models accessed through the Cline provider
+- Reverted the model-name-only display change from v3.0.28; the model picker, selector, and status bar return to their previous display behavior
+
+## 3.0.28
+
+- Added a ClinePass onboarding flow with selectable ClinePass models, plus improved ClinePass error handling
+- Added hub primitive catalogs and refreshed the hub dashboard design with a dedicated customizations breakout
+- Auto-approve toggles now apply immediately when changed
+- Feature flags now resolve using your user ID on startup
+- Fixed Cline model display names so they resolve by model name
+- Truncate large tool results by default (including MCP and custom tool output) to keep requests within context budget
+- Hardened parallel tool-call guidance for faster, more reliable multi-tool execution
+
+## 3.0.27
+
+- Added a `cline skill` command to install and manage skills, matching `cline plugin install` and `cline mcp` (installs default to the Cline agent directory)
+- Added a prefilled MCP install wizard command for quicker MCP server setup
+- Improved error handling and messaging when plugin MCP OAuth authorization fails
+- The CLI now rejects unknown commands and unquoted multi-word input with a clear error instead of silently treating bad arguments as a prompt
+
+## 3.0.26
+
+- Reverted the expandable model picker sections and ClinePass models, restoring the previous model-selection UI
+
+## 3.0.25
+
+- Added ClinePass support, with selectable ClinePass models in the model picker
+- Made model picker sections expandable
+- Added MCP server support to plugins, including authorizing plugin MCP OAuth during install
+- Encouraged parallel tool calls for faster task execution
+- Capped tool output for bash commands and file reads to keep large output within context limits
+- Allowed ranged reads on large files
+- Fixed apply_patch to fail when a hunk is skipped
+- Fixed run_commands to return captured stdout on failure and handle split heredocs
+- Fixed search tools to treat zero results as success
+- Fixed disabled-reasoning handling for StepFun flash
+- Fixed history resume rendering isolation
+- Fixed the Hugging Face URL
+- Fixed Cline OAuth token formatting in provider config
+
+## 3.0.24
+
+- Plugin commands can now submit prompts to the agent
+- Added support for overriding the API base URL
+- Open the verification URL automatically when starting device authentication
+- Enforced a single shared Cline Hub, so a stale hub is respawned after an upgrade
+- Suppressed flickering console windows on Windows
+- Fixed truncation of structured tool operation result strings so oversized tool output stays within limits
+- Stopped echoing the full command text in run_commands tool results
+
+## 3.0.23
+
+- Fixed Vertex AI GCP settings configuration
+- Fixed the Azure Foundry API version
+- Added support for configured agents as subagent tools
+- Centralized OAuth management into the SDK
+- Fixed an error caused by disabled reasoning on Fable 5
+
+## 3.0.22
+
+- Added support for the Claude Fable 5 model
+- Fixed MiniMax M3 thinking controls so they route correctly across gateways
+
+## 3.0.21
+
+- Added a global auto-update setting that controls automatic updates on CLI startup
+- Added a Cline credits refill link
+- Fixed scrolling for inline ask-question responses
+- Fixed connector thread session routing and stale hub session handling
+- Added support for Vertex AI Application Default Credentials (ADC) with tool use
+- Fixed empty message content replay for Bedrock
+- Cleaned up the OpenAI Codex model list
+
+## 3.0.20
+
+- Installed plugin wrappers are now named from their source (npm package name, git repo, remote filename, official slug, or local directory) instead of an opaque hash, making installed plugins easier to identify.
+
+## 3.0.19
+
+- Fixed CLI auto-update to use `npm update` so updates apply reliably, while preserving the installed release channel (e.g. nightly).
+
+## 3.0.18
+
+- Fix Slack channel mentions so replies post in the original message's thread.
+- Fix the abort indicator to clear immediately when a task is cancelled.
+- Sync the Fireworks AI model registry and refresh the bundled model catalog with current platform offerings.
+- Bump the bundled SDK to v0.0.43, which forces a running Cline Hub to restart so it picks up the latest SDK code.
+
+## 3.0.17
+
+- Fix a regression introduced in 3.0.15 where the interactive CLI could get stuck after stopping and restarting Cline Hub and then pressing Escape to cancel a request. The CLI now detects stale or missing sessions, recovers any pending messages, and starts a fresh session instead of failing with "session not found".
+- Fix Ctrl+C and Hub shutdown races that surfaced as "hook dispatch failed" and WebSocket connection errors from late hook events racing against Hub shutdown.
+- Fix the Hub daemon being shut down prematurely when a runtime request was aborted, so the daemon now stays alive.
+- Improve the Telegram connector with a new `--allowed-user-id` flag to restrict which Telegram users are authorized to interact with the agent.
+
+## 3.0.16
+
+- Install official Cline plugins by slug off the new github.com/cline/plugins collection.
+- Uninstall plugins using `cline plugin uninstall <plugin>` or in the TUI.
+- Plugins can now bundle skills, and plugin skills are grouped together in settings.
+- Add Slack socket mode support.
+- Allow a custom base URL for Anthropic vendor-type providers.
+- Fix OAuth token migration for users signed in through the old extension.
+- Use a union schema for read-files tool input validation.
+- Add a `CLINE_PLUGIN_IMPORT_TIMEOUT_MS` env override to control the plugin import timeout.
+
+## 3.0.15
+
+- Add Cline Hub, a web app for monitoring connected clients, viewing and driving sessions, streaming assistant output, and restarting the local hub, with local, LAN, and tunnel usage gated by a room secret.
+- Support global AGENTS rules so agent rules can be applied across all sessions, not just per-project.
+- Let plugins contribute static or dynamic rule content when installed in the sandbox.
+- Bind Discord sessions to individual message authors so different Discord users no longer share chat state in a thread.
+- Support participant mute targets in Discord: resolve `/mute` and `/unmute` from user mentions or raw user IDs to mute a specific participant in a thread.
+- Make OAuth URLs clickable in the TUI.
+- Refresh the bundled model catalog, adding Claude Opus 4.8, Moonshot Kimi K2.6, and Qwen3.7 Max (with cache support).
+- Discover SDK skill directories that are symlinked, including handling circular symlinks.
+- Steer active connector sessions across turn keys by matching on session ID, so replies continue the existing session instead of starting a duplicate.
+- Stop the Discord connector after repeated identical errors (per thread, within a time window) to prevent error messages from flooding a channel.
+- Fix Discord connector registration and reply fallback handling.
+- Fix SAP AI Core to use the AI SDK community provider.
+- Log ACP output as diagnostics instead of errors so normal output no longer appears as errors.
+
+## 3.0.14
+
+- Fix OTEL telemetry variable bundling so telemetry is correctly enabled in compiled CLI builds: guard against environments where `process.env` is undefined and remove optional chaining so bundlers can inline the values at build time.
+
+## 3.0.13
+
+- Show a loading dialog while resuming a session from history so the TUI no longer appears frozen during the load.
+- Speed up the `/clear` command by deferring new session creation until you send the next prompt, so clearing no longer blocks on spinning up an empty session.
+
+## 3.0.12
+
+- Show a loading dialog while the config screen switches provider or model so the transition no longer looks frozen.
+- Render the ask question tool prompt inline with the conversation so the question and suggested answers stay attached to the assistant turn that asked them, instead of appearing in a separate modal.
+- Allow manual `cline update` runs to install the latest published version immediately, bypassing the release age gate that delays automatic updates.
+- Refresh the bundled SDK to 0.0.42, updating the model catalog.
+
+## 3.0.11
+
+- Fix a regression in the ChatGPT OAuth provider where requests failed with `max_output_tokens not supported`, by restoring the full output token budget instead of applying an implicit cap.
+- Hide the `Space toggle` hint in the config footer when the highlighted row is not toggleable (rules, agents, hooks).
+- Authenticate Vertex Gemini through Google auth when `gcp.projectId` is configured, and surface the full Vertex model list instead of only Claude models.
+- Include tool names in tool result content blocks so message logs and session history consistently track which tool produced each result.
+
+## 3.0.10
+
+- Install plugins from `file://` URLs in addition to npm and git sources.
+- Show Ollama API key note in TUI settings so users know when to provide an API key.
+- Keep interactive sessions alive when idle or awaiting approval instead of treating them as ended, and stop reading message files for every session when `hydrate: false`.
+- Add Poolside as a provider.
+- Add Gemini 3.5 Flash to the Gemini provider model list.
+- Auto-detect Telegram bot username from the bot token so the Telegram connector no longer requires it to be configured separately.
+- Notify connectors when a scheduled execution fails, not just when it succeeds.
+- Bake OTEL telemetry variables into the CLI at build time so telemetry works in nightly and production builds.
+- Preserve model output token limits from the SDK model catalog so context window math matches the upstream provider.
+- Soften the visual treatment of rejected tool calls in the TUI.
+- Hide the skills tool from the system prompt when skills are disabled, and refresh slash commands after toggling a skill.
+- Restore AWS Bedrock profile-based auth during legacy config migration so profiles set via `awsAuthentication: "profile"` are preserved without `awsUseProfile`.
+- Cache global settings reads keyed by file mtime so repeated reads skip the JSON parse and zod validation on the hot path.
+
+## 3.0.9
+
+- Speed up CLI startup with plugins by loading sandboxed plugins concurrently and caching plugin tool descriptors per plugin, provider, and model.
+- Speed up plugin and tool config toggles by updating the TUI optimistically and persisting changes without reloading the full config or reimporting plugins.
+- Restore fuzzy ranking for the @-mention file picker so the most relevant files appear first.
+- Keep the interactive CLI session alive after cancelling a task instead of tearing the session down.
+- Accept dash-prefixed prompts when passed after `--`, so prompts starting with `-` are no longer parsed as flags.
+- Recover from hub abort cleanup failures so a cancel that hits an error no longer crashes the runtime host.
+- Route GLM thinking through provider metadata so thinking-enabled GLM models behave correctly through the gateway.
+
+## 3.0.8
+
+- Use Telegram numeric participant ids so renamed users stay linked to the same participant in the Telegram connector.
+- Keep failed plugins visible in the config UI with their load/setup phase and error details so broken plugin definitions are easier to diagnose.
+- Move the Create Session Fork shortcut from Opt+F to Opt+R so terminal word-right navigation works again.
+- Fix AWS Bedrock region and profile detection in the CLI onboarding, and surface bearer-token and additional Bedrock config fields in the provider config screens.
+- Fix inflated token usage counts caused by AgentRuntime.execute() not resetting usage between calls, which the local runtime host was then double-counting on top of the session baseline.
+
+## 3.0.7
+
+- Skip the ChatGPT OAuth model refresh on session startup so the CLI launches without the extra network round-trip.
+- Align the ChatGPT OAuth model catalog with the Codex provider list so the available models match the subscription tier.
+
+## 3.0.6
+
+- Fix ChatGPT provider model list to include the codex variants and the gpt-5.2, gpt-5.4, and gpt-5.4-mini subscription models.
+
+## 3.0.5
+
+- Show plugin-provided tools and slash commands in the CLI settings dialog by hydrating them through the sandbox.
+- Preserve hydrated plugin tools and config reload options when toggling settings, so they no longer disappear after a toggle.
+
+## 3.0.4
+
+- Improve light theme TUI colors so chat, status bar, tool output, and syntax highlighting render with better contrast on light terminals.
+- Fix plugin tools failing in the production npm build by bundling the SDK deps plugins import at runtime.
+
+## 3.0.3
+
+- Add `--worktree` flag that auto-creates a fresh git worktree under `~/.cline/worktrees/` and runs the task there. Works with `--taskId` and `--continue` so you can resume a task in an isolated worktree to try a different approach.
+- Show session status in the CLI history view and refresh status rows in place while the standalone history TUI is open.
+- Restore the OpenAI compatible provider in the auth flow and preserve stored model metadata when configuring or migrating OpenAI-compatible providers.
+- Fix dropped macOS screenshots when pasting them into the TUI or asking the agent to read them: paths containing U+202F (narrow no-break space) and other Unicode variants now resolve to the real file instead of failing with ENOENT.
+- Accept bearer token auth for AWS Bedrock and map AWS profiles correctly when configuring the Bedrock gateway.
+- Honor `--thinking none` for Ollama models that ship with reasoning enabled by default.
+- Recover from detached hub event errors instead of crashing the session.
+- Refine the shared system prompt with clearer guidance on tool output formatting, unsupported file reads, long-running shell commands, and final verification before completing a task.
+
+## 3.0.2
+
+- Fix token count display showing inflated numbers in the TUI.
+
+## 3.0.1
+
+- Fix CLI release cleanup scripts so they work correctly on Windows.
+- Fix the kanban migration notice wording in the TUI.
+
+## 3.0.0
+
+Introducing our new Cline CLI built on our new SDK and comes with a snappy new TUI.
+
+Install:
+
+```sh
+npm install -g cline
+```
+
+For nightly builds:
+
+```sh
+npm install -g cline@nightly
+```
+
+## 0.0.13
+
+- Detect prompt-cache support from cache write pricing so providers with write-only caching are represented correctly in the model catalog
+- Dual-publish `@clinebot/cli` mirror wrapper so existing users who installed via `npm i -g @clinebot/cli` continue receiving updates
+- Fix response truncation for OpenAI Codex model responses
+
+## 0.0.12
+
+- Fix markdown rendering in the published binary: headers, inline code, blockquotes, bold, italic, and lists now render with proper syntax highlighting (tables were the only element working before)
+- Add keyboard shortcuts for scrolling through the chat transcript (Page Up/Down, Home/End)
+- Preserve typed input when selecting slash command skills instead of clearing the prompt
+- Fix `--thinking none` being ignored when persisted reasoning settings existed, which caused DeepSeek API errors
+- Fix terminal cleanup on exit so the summary prints cleanly
+- Fix onboarding provider model resolution
+- Hide ChatGPT subscription provider usage costs
+- Handle file index prewarm timeouts gracefully instead of hanging
+
+## 0.0.11
+
+- Add `/skills` slash command for browsing and toggling available skills interactively
+- System prompts from AI SDK are now passed via the dedicated `system` option instead of being embedded in message history
+- Context compaction can now be triggered manually and runs more reliably
+- Disable the search tool in yolo mode so the model uses bash for searching instead
+- Fix `submit_and_exit` completion policy not being wired through to the runtime
+- Fix resumed sessions losing tool results when an abort interrupted tool execution mid-turn
+- Fix interactive sessions becoming unusable after aborting a running turn
+- Fix strict JSON schema mode rejecting valid tool schemas with unions, optional fields, and nullable types
+- Fix stray log output appearing over the TUI when the log file fallback wrote directly to the stderr file descriptor, bypassing the TUI's stdio capture
+- Refresh the built-in model catalog with the latest available models and pricing
+
+## 0.0.10
+
+- Improve local provider onboarding: setting up Ollama, LM Studio, or other local providers now prompts for the endpoint URL directly, supports typing a model ID manually when the provider returns no models, and correctly discovers models from your saved endpoint
+- Ctrl+C no longer cancels a running turn -- it now clears the input field or exits the CLI, matching standard terminal behavior. Use Escape to cancel a running turn instead
+- Thinking level chosen in the model picker now persists across CLI restarts instead of resetting to off
+- The context bar now shows visible progress as tokens are used, instead of appearing empty on some terminal themes
+- The status bar token count now shows actual context window usage instead of over-counting across multiple model calls in a turn
+- Resuming a saved session now correctly displays the accumulated cost
+- Sessions are now saved to disk after each assistant response, so conversation progress survives crashes or unexpected exits
+- Auto-compaction now runs inline during model requests, keeping long conversations within the context window automatically
+- The home screen robot now follows the cursor while you type
+- Hub websocket connections now automatically reconnect after going idle, so sessions no longer silently lose their connection to the hub daemon
+- MCP stdio servers on Windows no longer spawn visible console windows
+- Tool input schemas containing `allOf` clauses are now handled correctly instead of being rejected
+- Login now uses device auth exclusively
+- Fix chat input and chat view text losing its indent on wrapped lines
+
+## 0.0.9
+
+- Fix stray text appearing over the TUI when background operations (like hub restart messages) write directly to stdout/stderr during interactive sessions
+- Fix hub connection recovery: when a newer CLI instance restarts the shared hub daemon, already-running CLI sessions now automatically reconnect to the new hub endpoint instead of failing with transport errors
+
+## 0.0.8
+
+- Fix crash when pressing Escape to cancel a running turn
+- Add plugin and SDK tool toggles to the settings panel
+- Add `@cline/sdk` as a user-facing alias for `@cline/core`
+- Improve hub recovery with better error handling, logging, and recovery timeouts
+- Show session summary (ID, model, cost, resume command) on exit
+- Fix OAuth browser-launch failure
+- Fix compact no-op being reported indistinctly
+- Fix CLI history resume being non-transactional (could leave blank UI or corrupt session on disk)
+- Fix cross-client session history not loading Code/VS Code sessions, and fix interactive turn status showing stale state
+- Fix configuration file paths for hooks and rules (now resolve from `~/.cline/hooks` and `~/.cline/rules`)
+- Fix Telegram connector: honor `--no-tools` flag, lock tool-disabled mode across state changes, post replies as raw text to avoid markdown parse failures, add `/help` and `/start` commands
+- Clean up CLI program description and compact slash command descriptions
+- Clean up CLI flags
+
+## 0.0.7
+
+- Fix graceful recovery when the model returns malformed tool call inputs, preventing crashes mid-conversation
+- Add settings toggles for core skills (enable/disable individual skills from the settings panel)
+- Secure the local hub daemon with a discovery auth token, preventing unauthorized local access
+- Fix auto-approve tool policies being incorrectly reset after session restore
+- Fix npm wrapper detection for auto updates, so self-update works when the CLI is invoked through npm/npx shims
+- Improve fork session UX with clearer prompts and smoother flow
+- Fix manual thinking budget not being applied when using Anthropic models directly
+- Improve account onboarding flow with better error messages and step sequencing
+- Add enable/disable controls for individual tools and plugins
+- Fix abort handling so the public run promise resolves correctly when a run is cancelled
+- Fix markdown token styling in chat output
+- Fix chat auto-scrolling to bottom on message submit
+- Fix hub tool capabilities being routed to the wrong session
+- Revert loading extension-created sessions from history (was causing issues)
+
+## 0.0.6
+
+- Add checkpoint restore: press Esc twice or type `/undo` to rewind to a previous checkpoint, with options to restore chat only or chat + workspace
+- Fix clipboard: fall back to system clipboard (pbcopy, PowerShell, wl-copy, xclip) when OSC 52 fails, fixing copy for longer text selections
+- Fix prompt focus: restore focus to the prompt input after dialogs close, preventing the input from becoming unresponsive after using `/settings`
+
+## 0.0.5
+
+- The input field has been completely redesigned -- the old bordered box is replaced with a clean chevron-prompt style that adapts its background color to any terminal theme using perceptual OKLAB color math. Light terminals are fully supported now.
+- Pasting 5+ lines into the input shows a compact preview marker instead of flooding the textarea. The full content is still submitted.
+- Arrow-key history navigation respects cursor position so you don't lose your place when scrolling through previous prompts.
+- The TUI renders immediately instead of blocking while the hub daemon boots. Hub readiness and session hydration happen in the background.
+- Listing previous sessions no longer hydrates every full session, making `cline history` and the history picker snappy even with hundreds of sessions.
+- Updating the CLI no longer leaves you connected to a stale hub daemon. Incompatible versions are detected and replaced automatically, eliminating the "Unsupported hub schedule command" class of errors.
+- Schedules can now trigger on external events (webhooks, GitHub events, plugin-emitted signals) in addition to cron intervals, with deduplication, filtering, and retry policies.
+- Plugins can register automation event types that feed into the scheduling system, enabling custom triggers from any source.
+- Resuming a session automatically picks up any in-flight team runs without needing to remember or pass `--team-name`.
+- `providers.json` (which stores API keys and OAuth tokens) is now written with 0600 permissions, preventing other processes on the machine from reading it.
+- Models that emit `command` or `cmd` instead of `commands` (or `paths` instead of `path`) no longer fail. Common aliases are normalized before execution.
+
+## 0.0.4
+
+- Fix compiled binary spawning infinite hub daemon recursion loop
+
+## 0.0.3
+
+- Rewritten TUI from Ink to OpenTUI with streaming markdown, syntax-highlighted diffs, scrollable chat, and mouse support
+- Dialog system for model picker, tool approval, settings browser, session history, and onboarding
+- Interactive setup wizards: `cline connect`, `cline schedule`, `cline mcp`
+- Plan/Act mode toggle with system prompt and tool rebuilding on switch
+- Input autocomplete for slash commands and file mentions
+- Message queuing and steer messages during running turns
+- Platform-specific compiled binaries for macOS, Linux, and Windows (arm64 and x64)
+- npm trusted publishing via GitHub Actions OIDC
diff --git a/apps/cli/DEVELOPMENT.md b/apps/cli/DEVELOPMENT.md
new file mode 100644
index 0000000..4fde2d9
--- /dev/null
+++ b/apps/cli/DEVELOPMENT.md
@@ -0,0 +1,476 @@
+# CLI Development Guide
+
+This guide covers everything you need to build and run the Cline CLI locally after cloning the repository. It includes setup instructions, a tech stack overview, and a walkthrough of the TUI architecture.
+
+For CLI command reference and usage, see [DOC.md](./DOC.md) and [README.md](./README.md).
+
+## Prerequisites
+
+Install these before starting:
+
+1. [Bun](https://bun.sh) (v1.0.0+) - Package manager, runtime, and bundler
+2. [Zig](https://ziglang.org/download/) - Required by OpenTUI's native core. The `@opentui/core` package includes a Zig-compiled native binary that builds from source on install. Without Zig, `bun install` will fail for OpenTUI packages.
+3. Node.js 22+ - Required for some build tooling and test infrastructure
+
+Verify your setup:
+
+```bash
+bun --version    # should be >= 1.0.0
+zig version      # any recent stable release
+node --version   # should be >= 22
+```
+
+## First-Time Setup
+
+From the repository root:
+
+```bash
+# Install all workspace dependencies (including native OpenTUI build)
+bun install
+
+# Build the SDK packages and CLI
+bun run build
+
+# Run the CLI in dev mode (interactive)
+bun run cli
+```
+
+That last command is a shortcut for `cd apps/cli && bun run dev`, which runs:
+
+```bash
+CLINE_BUILD_ENV=development bun --conditions=development ./src/index.ts
+```
+
+### Linking for Global Access
+
+To use the CLI from anywhere on your system, first build the SDK packages, then link:
+
+```bash
+# From the repo root -- build all workspace packages
+bun run build:sdk
+
+# Then link the CLI binary
+cd apps/cli
+bun link
+```
+
+The `build:sdk` step is required because `bun link` runs without the `--conditions=development` flag, so Bun resolves workspace packages (`@cline/llms`, `@cline/core`, etc.) via their `package.json` exports which point to `dist/`. Without the build, those dist files don't exist and you'll get "Cannot find module" errors.
+
+After linking, you can run `cline` from any directory:
+
+```bash
+cline              # interactive mode
+cline "prompt"     # single-prompt mode
+cline auth         # authenticate a provider
+```
+
+If you prefer to skip the build step, use `bun run dev` from `apps/cli/` instead -- it passes `--conditions=development` which resolves packages directly from source.
+
+### Rebuilding After SDK Changes
+
+If you modify any package in `packages/` (shared, llms, agents, core, etc.), rebuild the SDK:
+
+```bash
+bun run build:sdk
+```
+
+If you're using `bun run dev`, you don't need to rebuild after every SDK change -- dev mode resolves packages from source. But if you're using the linked `cline` binary, you do need to rebuild for changes to take effect.
+
+## Monorepo Structure
+
+```
+cline-sdk/
+  packages/           # SDK packages (published to npm)
+    shared/           # Contracts, schemas, path helpers, runtime utilities
+    llms/             # Provider settings, model catalogs, AI SDK handlers
+    agents/           # Stateless agent loop, tool orchestration, hooks
+    scheduler/        # Scheduled execution, concurrency control
+    core/             # Stateful orchestration, sessions, hub, storage, config
+    enterprise/       # Internal enterprise integrations (not published)
+  apps/
+    cli/              # This package - CLI host and TUI
+    code/             # Tauri + Next.js desktop app
+    vscode/           # VS Code extension
+    desktop/          # Desktop application
+    examples/         # Sample integrations
+  biome.json          # Linter and formatter config (Biome)
+```
+
+## Tech Stack
+
+| Layer | Technology | Purpose |
+|-------|-----------|---------|
+| Runtime | Bun | Package management, script execution, bundling |
+| Language | TypeScript (strict) | All source code |
+| CLI Framework | Commander.js | Argument parsing, subcommands |
+| TUI Renderer | OpenTUI (`@opentui/core`) | Native terminal rendering engine (Zig + C ABI) |
+| TUI Components | OpenTUI React (`@opentui/react`) | React 19 reconciler for declarative terminal UI |
+| TUI Dialogs | `@opentui-ui/dialog` | Modal dialog system (model picker, tool approval, etc.) |
+| Linter/Formatter | Biome | Code quality and formatting |
+| Testing | Vitest | Unit and E2E tests |
+| Logging | Pino | Runtime file logging |
+
+### Why OpenTUI?
+
+OpenTUI is a native terminal UI core written in Zig with TypeScript bindings. Compared to the previous terminal renderer, OpenTUI provides:
+
+- Native diff rendering with syntax highlighting
+- Streaming markdown rendering
+- Scrollable content areas
+- Mouse interaction (click, hover, drag-to-select, scroll)
+- Built-in clipboard support (OSC52)
+- Higher performance through native rendering
+
+OpenTUI exposes a C ABI from its Zig core. The `@opentui/core` package provides TypeScript bindings, and `@opentui/react` provides a React reconciler so you can write terminal UIs with JSX.
+
+## CLI Source Structure
+
+```
+apps/cli/src/
+  index.ts              # Entry point (shebang, signal handling)
+  main.ts               # CLI command definitions, argument parsing
+
+  runtime/
+    run-interactive.ts   # Interactive mode runtime (session lifecycle, event wiring)
+    run-agent.ts         # Single-prompt runtime
+    session-events.ts    # Event bridge types and pub/sub
+    active-runtime.ts    # Abort registry
+    tool-policies.ts     # Auto-approve toggle logic
+    prompt.ts            # System prompt and user input assembly
+    defaults.ts          # Default config values
+
+  tui/                   # Terminal UI (OpenTUI + React)
+    index.tsx            # Renderer entry point
+    root.tsx             # Provider tree, view routing, global keyboard
+    types.ts             # ChatEntry union, TuiProps, shared constants
+    interactive-config.ts  # Config data loading
+    interactive-welcome.ts # Welcome line, slash command resolution
+    components/          # Reusable UI components
+    contexts/            # React context providers
+    hooks/               # Custom React hooks
+    views/               # Full-screen view components
+    utils/               # TUI-specific utilities
+
+  session/               # Session state management
+  commands/              # CLI subcommands (auth, config, history, etc.)
+  connectors/            # Chat adapter bridges (Telegram, Slack, etc.)
+  utils/                 # Shared utilities
+  wizards/               # Interactive setup flows
+  logging/               # Pino logger adapter
+```
+
+## TUI Architecture
+
+The TUI lives at `src/tui/` and uses React with OpenTUI's reconciler. Every `.tsx` file in this directory uses a per-file JSX pragma:
+
+```tsx
+// @jsxImportSource @opentui/react
+```
+
+This tells TypeScript to use OpenTUI's JSX runtime instead of React DOM. The `tsconfig.json` sets `jsxImportSource: "@opentui/react"` globally, but the per-file pragma makes the intent explicit and avoids conflicts with any non-TUI React code.
+
+### Entry Point: `index.tsx`
+
+The TUI boots through `renderOpenTui()`:
+
+```tsx
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,    // We handle Ctrl+C ourselves
+  autoFocus: false,      // Prevents click-anywhere from stealing focus
+  enableMouseMovement: true,
+});
+
+const root = createRoot(renderer);
+root.render(<Root {...props} />);
+```
+
+The renderer returns `destroy()` and `waitUntilExit()` methods. The runtime calls `destroy()` on exit and awaits `waitUntilExit()` for cleanup.
+
+### Runtime Bridge: `run-interactive.ts`
+
+This file is the bridge between the SDK and the TUI. It:
+
+1. Creates a `SessionManager` via `createCliCore()`
+2. Sets up event subscriptions (agent events, pending prompts, team events)
+3. Passes callbacks to the TUI as props (`onSubmit`, `onAbort`, `onModelChange`, etc.)
+4. Manages session lifecycle (start, stop, restart, resume, compact)
+
+The TUI never talks to the SDK directly. All communication flows through the callback props defined in `TuiProps` (see `types.ts`).
+
+### Component Tree
+
+```
+Root (root.tsx)
+  DialogProvider                    # Modal dialog system
+    SessionProvider                 # Chat entries, running state, mode
+      EventBridgeProvider           # Subscribes to SDK events
+        View Router
+          HomeView                  # Welcome screen (before first prompt)
+          ChatView                  # Message list + input bar + status
+          OnboardingView            # First-run provider setup
+          ConfigView (dialog)       # Settings browser
+          HistoryView (dialog)      # Session history
+```
+
+### Context Providers
+
+Each context owns a slice of state. Components subscribe only to what they need.
+
+`SessionContext` - Core chat state:
+- `entries: ChatEntry[]` - All messages in the conversation
+- `isRunning` / `abortRequested` - Agent execution state
+- `mode` (plan/act), `autoApproveAll`, `hasSubmitted`
+- `lastTotalTokens`, `lastTotalCost`, `turnStartTime`
+
+`EventBridgeContext` - SDK event subscription:
+- Subscribes to `subscribeToEvents` prop once via useEffect
+- Forwards agent events to session context handlers via stable refs
+- Handles pending prompts, team events
+
+### Event Flow
+
+```
+SDK (AgentLoop)
+  --> AgentEvent emitted
+  --> subscribeToAgentEvents() fires
+  --> UIEventEmitter.emit("agent", event)
+  --> EventBridgeProvider receives event
+  --> useAgentEventHandlers processes event
+  --> SessionContext.entries updated
+  --> React re-renders affected components
+```
+
+### ChatEntry Type
+
+All messages in the conversation are represented as a discriminated union:
+
+```typescript
+type ChatEntry =
+  | { kind: "user"; text: string }
+  | { kind: "assistant_text"; text: string; streaming: boolean }
+  | { kind: "reasoning"; text: string; streaming: boolean }
+  | { kind: "tool_call"; toolName: string; inputSummary: string; ... }
+  | { kind: "error"; text: string }
+  | { kind: "status"; text: string }
+  | { kind: "team"; text: string }
+  | { kind: "user_submitted"; text: string; delivery?: "queue" | "steer" }
+  | { kind: "done"; tokens: number; cost: number; elapsed: string; iterations: number }
+```
+
+### Dialog System
+
+Dialogs use `@opentui-ui/dialog`. The pattern:
+
+```tsx
+import { useDialog } from "@opentui-ui/dialog/react";
+
+const dialog = useDialog();
+const result = await dialog.choice<string>({
+  style: { maxHeight: termHeight - 2 },
+  content: (ctx) => <MyDialogContent {...ctx} />,
+});
+```
+
+Dialog content components receive `resolve` and `dismiss` callbacks through the context. They use `useDialogKeyboard` for keyboard handling scoped to the dialog.
+
+Important gotcha: async data loading inside a dialog (via useEffect/useState) causes layout gaps between flex children in OpenTUI. Always fetch data before opening the dialog and pass it as props.
+
+### Key Components
+
+`components/input-bar.tsx` - Text input with submit handling:
+- Uncontrolled `<textarea>` with `key={inputKey}` for reset
+- `ref` callback wires `node.onSubmit` (React reconciler pattern)
+- Supports newlines (Shift+Enter) and autocomplete integration
+
+`components/chat-entry.tsx` - Renders a single ChatEntry based on its `kind`:
+- Markdown rendering for assistant text (`<markdown>`)
+- Diff rendering for file edits (`<diff>`)
+- Code highlighting for file reads (`<code>`)
+- Spinner for streaming states
+
+`components/status-bar.tsx` - Bottom status display:
+- Model name, context bar, token/cost
+- Plan/Act mode indicator
+- Workspace, branch, auto-approve state
+
+`components/tool-output.tsx` - Rich tool result rendering:
+- Unified diffs with syntax highlighting
+- Expandable/collapsible output sections
+- File read with line numbers
+
+`views/home-view.tsx` - Welcome screen with animated robot and centered input
+`views/chat-view.tsx` - Main conversation view (scrollbox + input + status)
+`views/onboarding-view.tsx` - First-run provider/model setup wizard
+
+### OpenTUI Elements
+
+OpenTUI provides these built-in elements (used like HTML tags in JSX):
+
+- `<box>` - Flexbox container (like `<div>`)
+- `<text>` - Text display (like `<span>`)
+- `<span>` - Inline text modifier (for coloring nested text)
+- `<scrollbox>` - Scrollable container
+- `<textarea>` - Multi-line text input
+- `<input>` - Single-line text input
+- `<select>` - List selection
+- `<code>` - Syntax-highlighted code block
+- `<diff>` - Unified/split diff viewer
+- `<markdown>` - Streaming markdown renderer
+
+Styling uses named terminal colors as props:
+
+```tsx
+<text fg="cyan">colored text</text>
+<box backgroundColor="gray" paddingX={1}>padded box</box>
+```
+
+Layout follows flexbox conventions: `flexDirection`, `flexGrow`, `flexShrink`, `gap`, `padding`, `margin`, etc.
+
+## Testing
+
+```bash
+# Unit tests
+bun run test:unit
+
+# E2E tests
+bun run test:e2e
+bun run test:e2e:interactive
+
+# TUI-specific E2E tests (uses @microsoft/tui-test)
+bun run test:e2e:cli:tui
+
+# Type checking
+bun run typecheck
+
+# Lint and format
+cd ../.. && bun run fix   # auto-fix from repo root
+```
+
+## Common Development Tasks
+
+### Running in interactive mode
+
+```bash
+bun run dev
+```
+
+### Testing onboarding flow
+
+Use a temporary config directory to simulate a fresh install:
+
+```bash
+bun run dev -- --interactive --config /tmp/cline-test
+```
+
+Or set `CLINE_FORCE_ONBOARDING=1` to force the onboarding view regardless of existing config.
+
+### Adding a new TUI component
+
+1. Create a `.tsx` file in `src/tui/components/`
+2. Add the JSX pragma at the top: `// @jsxImportSource @opentui/react`
+3. Use OpenTUI elements (`<box>`, `<text>`, etc.) for layout
+4. Import and use in the parent view or root
+
+### Adding a new dialog
+
+1. Create a content component that receives `ChoiceContext<T>` props
+2. Use `useDialogKeyboard` for keyboard handling
+3. Call `resolve(value)` to return a result, `dismiss()` to cancel
+4. Open it from a hook or view: `const result = await dialog.choice<T>({ content: ... })`
+5. Fetch any async data before calling `dialog.choice()`, not inside the dialog
+
+### Adding a new slash command
+
+1. Define the command handler in `root.tsx` (in the slash command processing section)
+2. Add the command to the help dialog in `components/dialogs/help-dialog.tsx`
+3. Add autocomplete entry in `hooks/use-autocomplete.ts`
+
+### Debugging the TUI
+
+```bash
+# Run with React DevTools (requires react-devtools-core@7)
+DEV=true bun run dev
+
+# In another terminal
+npx react-devtools@7
+```
+
+### Debugging the CLI process
+
+```bash
+cd apps/cli
+CLINE_BUILD_ENV=development bun --conditions=development --inspect-brk=6499 ./src/index.ts
+```
+
+Then attach VS Code or Chrome DevTools to `ws://127.0.0.1:6499`.
+
+## OpenTUI Resources
+
+- OpenTUI docs: https://opentui.com/docs/getting-started
+- Repository: https://github.com/anomalyco/opentui
+- Packages used by CLI:
+  - `@opentui/core` - Native renderer and built-in elements
+  - `@opentui/react` - React reconciler (`createRoot`, hooks)
+  - `@opentui-ui/dialog` - Dialog/modal system
+  - `opentui-spinner` - Spinner component
+
+## Publishing
+
+The CLI is published as the `cline` wrapper package on npm with platform-specific binaries under `@cline/cli-*`. The release flow lives in the `publish-cli` skill (`.cline/skills/publish-cli/SKILL.md` at the repo root).
+
+From the `apps/cli` workspace:
+
+```bash
+# Dry run for checking package size and build output
+bun publish --dry-run
+
+# Publish to npm (version bump required first)
+bun run release
+```
+
+See [DISTRIBUTION.md](./DISTRIBUTION.md) for details on how the CLI is packaged.
+
+## Runtime ownership
+
+- CLI renders runtime events and handles terminal UX.
+- Core owns agent creation, runtime composition, and session message persistence.
+- CLI does not directly instantiate `Agent` for chat/task execution.
+- CLI does not perform direct file/db message persistence in run/interactive paths.
+- CLI owns the user-instruction watcher (rules/workflows/skills) because prompt assembly uses rule context before session start; the watcher is disposed on all exit paths.
+- RPC runtime uses the same prompt resolver and accepts optional `rules` in runtime config (or `systemPrompt` when fully prebuilt by the caller).
+
+### Connector runtime behavior
+
+- Telegram final assistant replies are sent through Telegram entity payloads with raw-text fallback; Google Chat and WhatsApp use the shared connector runtime formatting path.
+- Assistant text streams incrementally into chat surfaces that use the shared runtime streaming path; Telegram sends final assistant replies after the turn completes.
+- Tool activity is summarized as compact start/error messages with short argument previews.
+- Required tool approvals are posted back into the chat thread and accept `Y` / `N` replies.
+- Google Chat serves its webhook at `/api/webhooks/gchat`; configure the Google Chat App URL as `<base-url>/api/webhooks/gchat`.
+- Webhook-based connectors are hosted through a shared CLI `node:http` server helper rather than `Bun.serve`.
+- WhatsApp serves its webhook at `/api/webhooks/whatsapp`; configure the Meta callback URL as `<base-url>/api/webhooks/whatsapp`.
+
+## Logging adapter
+
+`cline` uses a `pino`-backed adapter that targets the core `BasicLogger` contract:
+
+- CLI runtime passes `logger` directly into local `@cline/core` sessions.
+- Hub-backed sessions include a serialized logger payload in `ChatStartSessionRequest.logger`; the runtime reconstructs the same `pino` settings and injects them into core.
+- Hosts can attach stable runtime logger bindings (for example `clientId`, `clientType`, `clientApp`) through `RuntimeLoggerConfig.bindings`.
+
+After login, OAuth credentials are persisted with `auth.expiresAt`, and `@cline/core` refreshes these tokens automatically during session turns. Provider auth and model settings should be changed through `cline auth`, the interactive config UI, or core provider-settings APIs rather than editing provider settings files directly.
+
+On startup, `cline` also attempts a legacy settings import:
+
+- Source files: `<CLINE_DATA_DIR>/globalState.json` and `<CLINE_DATA_DIR>/secrets.json`
+- Target file: `<CLINE_DATA_DIR>/settings/providers.json` (or `CLINE_PROVIDER_SETTINGS_PATH`)
+- Existing providers in `providers.json` are never overwritten
+- Missing providers discovered in legacy files are merged into `providers.json`
+- Migrated provider entries are annotated with `tokenSource: "migration"`
+
+Custom provider registry notes:
+
+- Provider runtime settings continue to persist in `<CLINE_DATA_DIR>/settings/providers.json`.
+- Providers in `providers.json` can opt into the OpenAI Responses API with `"protocol": "openai-responses"`; this routes the runtime through the OpenAI client while keeping the user-defined provider ID, base URL, and model catalog.
+- User-added OpenAI-compatible provider model catalogs are persisted in `<CLINE_DATA_DIR>/settings/models.json` (or alongside `CLINE_PROVIDER_SETTINGS_PATH`).
+- `models.json` stores model lists by provider ID and is loaded by the runtime provider actions.
+- Entries with only `models` extend an existing provider; entries with `provider` metadata register or override a custom provider.
diff --git a/apps/cli/DISTRIBUTION.md b/apps/cli/DISTRIBUTION.md
new file mode 100644
index 0000000..f643617
--- /dev/null
+++ b/apps/cli/DISTRIBUTION.md
@@ -0,0 +1,277 @@
+# CLI Distribution
+
+The Cline CLI (`cline`) is distributed as compiled binaries via npm. Users run `npm i -g cline` and get a working `cline` command without needing Bun, Zig, or any other runtime installed.
+
+## Why Compiled Binaries?
+
+The CLI depends on OpenTUI (`@opentui/core`), which uses `bun:ffi` to call into a native Zig binary for terminal rendering. This means:
+
+- The CLI cannot run on Node.js (Node doesn't support `bun:ffi`)
+- If shipped as a JS bundle (`dist/index.js`), users must have Bun installed
+- Compiled binaries (`bun build --compile`) embed the Bun runtime, so users need nothing pre-installed
+
+Bun's `--compile` flag produces a single self-contained executable that includes the Bun runtime, all JS/TS code, and native addons.
+
+## What Gets Published
+
+Publishing the CLI publishes 7 packages to npm:
+
+| Package | Description |
+|---|---|
+| `@cline/cli-darwin-arm64` | macOS Apple Silicon binary |
+| `@cline/cli-darwin-x64` | macOS Intel binary |
+| `@cline/cli-linux-arm64` | Linux ARM binary |
+| `@cline/cli-linux-x64` | Linux x64 binary |
+| `@cline/cli-windows-x64` | Windows x64 binary |
+| `@cline/cli-windows-arm64` | Windows ARM binary |
+| `cline` | Wrapper package (pulls the right binary via `optionalDependencies`) |
+
+Each platform package contains a compiled binary and a minimal `package.json` with `os` and `cpu` fields:
+
+```json
+{
+  "name": "@cline/cli-darwin-arm64",
+  "version": "0.1.0",
+  "os": ["darwin"],
+  "cpu": ["arm64"],
+  "bin": {
+    "cline": "bin/cline"
+  }
+}
+```
+
+The `os` and `cpu` fields tell npm to skip this package on non-matching platforms. A macOS ARM user gets ~30-60MB, not ~200MB of binaries for every platform.
+
+The `cline` wrapper package contains no binary -- just the resolver script, postinstall script, and `optionalDependencies` pointing to all platform packages:
+
+```json
+{
+  "name": "cline",
+  "version": "0.1.0",
+  "bin": {
+    "cline": "./bin/cline"
+  },
+  "scripts": {
+    "postinstall": "node ./postinstall.mjs || true"
+  },
+  "optionalDependencies": {
+    "@cline/cli-darwin-arm64": "0.1.0",
+    "@cline/cli-darwin-x64": "0.1.0",
+    "@cline/cli-linux-arm64": "0.1.0",
+    "@cline/cli-linux-x64": "0.1.0",
+    "@cline/cli-windows-x64": "0.1.0",
+    "@cline/cli-windows-arm64": "0.1.0"
+  }
+}
+```
+
+After installing, users run `cline`:
+
+```bash
+npm i -g cline
+
+cline              # interactive mode
+cline "prompt"     # single-prompt mode
+cline auth         # authenticate a provider
+```
+
+## How to Publish
+
+Every release starts by preparing one release commit from the code you want to publish:
+
+1. Draft user-facing release notes from the commits since the last `cli-vX.Y.Z` tag.
+2. Choose the release version. Because this publishes over the existing `cline` package, the version must be greater than the current published `cline` version. The handoff release is `3.0.0`.
+3. Update `apps/cli/package.json`.
+4. Add the approved notes to `apps/cli/CHANGELOG.md`.
+5. Run checks.
+6. Commit the release changes.
+
+Then publish that release commit with one of these paths.
+
+### Publish From GitHub Actions
+
+Use this path for normal releases.
+
+```bash
+git tag -a cli-vX.Y.Z -m "CLI vX.Y.Z"
+git push origin refs/tags/cli-vX.Y.Z
+gh workflow run cli-publish.yml -f publish_target=main -f git_tag=cli-vX.Y.Z -f confirm_publish=publish
+```
+
+This path requires the release commit to be on `main` and the matching `cli-vX.Y.Z` tag to exist before the workflow runs. The workflow checks out the tag, publishes to npm with the `latest` dist-tag, creates the GitHub release, and posts to Slack.
+
+### Publish Locally
+
+Use this path when publishing from an authenticated local machine.
+
+Start from a clean checkout at the release commit:
+
+```bash
+gh auth status
+npm whoami
+git tag -a cli-vX.Y.Z -m "CLI vX.Y.Z"
+git push origin refs/tags/cli-vX.Y.Z
+bun release cli
+gh release create cli-vX.Y.Z --verify-tag --title "CLI vX.Y.Z" --notes "Paste the approved release notes here."
+```
+
+The release helper checks the working tree, verifies the tag points at `HEAD` locally and on `origin`, runs tests, builds all platform packages, and publishes the platform packages plus the generated `cline` wrapper package to npm. The package version and tag must match.
+
+By default, `bun release cli` publishes with the npm dist-tag `latest` (what users get with `npm i -g cline`). To publish under a different dist-tag like `next`, pass `--tag`:
+
+```bash
+bun release cli --tag next
+```
+
+## CI Workflow
+
+The GitHub workflow at `.github/workflows/cli-publish.yml` automates publishing:
+
+- Main releases are manual. Select `publish_target=main` and set `confirm_publish=publish`.
+- Main releases require `git_tag=cli-vX.Y.Z`, check out that tag, verify it matches `apps/cli/package.json`, run tests, build all platform packages, publish to npm with the `latest` dist-tag using trusted publishing, create a GitHub release, and post to Slack.
+- Nightly releases run on a schedule or manually with `publish_target=nightly`.
+- Nightly releases publish `X.Y.Z-nightly.TIMESTAMP` to npm with the `nightly` dist-tag and skip if there were no commits in the last 24 hours unless forced.
+
+CI publishing uses npm trusted publishing. Configure npm trusted publishers for the `cline` wrapper package and every platform package before relying on the workflow.
+
+## How It Works Under the Hood
+
+```
+User runs: npm i -g cline
+  |
+  v
+npm installs cline (wrapper package)
+  + optionalDependencies (only the matching platform gets installed):
+    - @cline/cli-darwin-arm64
+    - @cline/cli-darwin-x64
+    - @cline/cli-linux-arm64
+    - @cline/cli-linux-x64
+    - @cline/cli-windows-x64
+    - @cline/cli-windows-arm64
+  |
+  v
+postinstall script runs:
+  - Detects platform/arch
+  - Finds the installed platform package
+  - Creates a cached hard link for fast startup
+  |
+  v
+User runs: cline
+  |
+  v
+bin/cline (Node.js resolver) executes:
+  1. Check CLINE_BIN_PATH env var override
+  2. Check cached binary at bin/.cline
+  3. Walk up node_modules for the platform package
+  4. Execute the compiled binary
+```
+
+## File Layout
+
+```
+apps/cli/
+  bin/
+    cline                   # Node.js resolver script (npm entry point)
+  script/
+    build.ts                # Cross-compile for all platforms
+    publish-npm.ts          # npm publish orchestration
+    postinstall.mjs         # Post-install binary caching
+```
+
+## Scripts Reference
+
+From `apps/cli/`:
+
+```bash
+bun run build:platforms:single  # build only current platform
+bun run build:platforms         # build all 6 platform binaries
+bun run publish:npm:dry         # preview generated npm package publishing
+```
+
+Direct `bun pm pack` and `bun pm pack --dry-run` from `apps/cli` are blocked because the source package is not the npm release package. Build platform packages first, then use `bun run publish:npm:dry` to preview the generated packages under `dist/`.
+
+## Build Script (`script/build.ts`)
+
+Cross-compiles the CLI for all target platforms:
+
+1. When `--install-native-variants` is passed, pre-installs all platform variants of `@opentui/core` using `bun install --os="*" --cpu="*"` so Bun can resolve native FFI binaries for cross-compilation. Without this, Bun only has the host platform's native binary and cross-compiled builds fail.
+2. Builds SDK packages (`bun run build:sdk`) and the CLI JS bundle (`bun -F @cline/cli build`)
+3. For each target platform:
+   - Runs `bun build --compile --target bun-{os}-{arch}` to create a standalone executable
+   - Generates a `package.json` with `os` and `cpu` fields for npm platform filtering
+   - Runs a smoke test on the current platform's binary (`cline --version`)
+   - Copies the plugin sandbox bootstrap file if present
+
+Flags:
+- `--single` -- build only for the current platform (faster for local testing)
+- `--install-native-variants` -- allow the script to download all OpenTUI native packages required for cross-platform builds
+- `--skip-install` -- skip re-downloading platform-specific native packages if they're already installed
+- `--skip-sdk-build` -- skip rebuilding SDK packages (if already built)
+
+## Publish Script (`script/publish-npm.ts`)
+
+Orchestrates publishing all packages to npm:
+
+1. Reads built packages from `dist/`
+2. Publishes all 6 platform packages in parallel (`@cline/cli-darwin-arm64`, etc.)
+3. Generates a clean main package (`cline`) with:
+   - `bin.cline` pointing to the resolver script
+   - `postinstall` running the binary caching script
+   - `optionalDependencies` listing all platform packages
+4. Publishes the generated `cline` wrapper package
+
+Platform packages must be published before the generated `cline` wrapper package because npm validates that `optionalDependencies` exist.
+
+The publish script generates a separate `package.json` for the published `cline` wrapper package. The development `package.json` (with `bin` pointing to `src/index.ts` for `bun link`) is never published directly.
+
+## Binary Resolver (`bin/cline`)
+
+A Node.js script that serves as the entry point when users run `cline`. It finds and executes the correct platform-specific binary.
+
+The shebang is `#!/usr/bin/env node` because Node.js is guaranteed to be available wherever npm is. The resolver uses only CommonJS (`require`) and Node.js APIs -- no `bun:` imports or Bun-specific APIs. It then spawns the compiled binary which has Bun embedded.
+
+Resolution chain:
+1. `CLINE_BIN_PATH` env var (for development or custom deployments)
+2. `bin/.cline` cached hard link (created by postinstall for fast startup)
+3. Walk up `node_modules` from the script directory to find the platform package
+
+## Postinstall (`script/postinstall.mjs`)
+
+Runs after `npm install cline`. Creates a hard link from the platform binary to `bin/.cline` for fast startup on subsequent runs. Falls back to file copy if hard linking fails (NFS, cross-device, network-mounted filesystems).
+
+The postinstall is defensive: it wraps everything in try/catch and always exits 0 (the `|| true` in the npm script). If postinstall fails, the resolver script has its own fallback logic to find the binary at runtime, so the cached binary is just an optimization.
+
+On Windows, the postinstall is a no-op because npm handles `.cmd` shim generation from the `bin` field.
+
+## Development vs Distribution
+
+During development, `bin` in package.json points to `src/index.ts` for `bun link` to work. The publish script generates a separate package.json for the published package that points to the resolver script. The development package.json is never modified during publish.
+
+| Mode | bin target | Runtime | Needs Bun? |
+|---|---|---|---|
+| `bun run dev` | src/index.ts | Bun (source) | Yes |
+| `bun link` + `cline` | src/index.ts | Bun (source) | Yes |
+| `npm i -g cline` | bin/cline resolver | Compiled binary | No |
+
+## Gotchas
+
+### Native addon cross-compilation
+When building for a different platform (e.g., compiling for Linux on a Mac), Bun needs the target platform's native binaries for `@opentui/core`. The build script handles this by pre-downloading all platform variants with `bun install --os="*" --cpu="*"`.
+
+### Version synchronization
+All 7 packages (6 platform + 1 wrapper) must have the same version. The build script reads the version from `apps/cli/package.json`. The publish script verifies that the built package versions match each other and `apps/cli/package.json`.
+
+### Package naming and scoping
+Platform packages are published under the `@cline` scope. The generated wrapper package is published as `cline`, so npm trusted publishing must be configured for all 7 package names.
+
+### postinstall reliability
+The postinstall script runs in diverse environments (CI, Docker, restricted permissions, network-mounted filesystems where hard links fail). It always wraps operations in try/catch and exits 0. The resolver script is the ultimate fallback.
+
+### Windows
+Windows binaries are `.exe` files. The build script appends `.exe` to the output filename on Windows targets. The resolver handles this. npm on Windows generates `.cmd` shims for bin entries automatically.
+
+### File permissions
+Compiled binaries need to be executable (`chmod 755`). The build script sets this after copying. The postinstall also sets permissions on the cached binary. Some npm packaging steps can strip permissions, so both handle this defensively.
+
+### Package size
+Each compiled binary is ~30-60MB (Bun runtime + all bundled code + native addons). This is normal for compiled CLI tools. Users only download their platform's variant thanks to `optionalDependencies`.
diff --git a/apps/cli/README.md b/apps/cli/README.md
new file mode 100644
index 0000000..d98c7f9
--- /dev/null
+++ b/apps/cli/README.md
@@ -0,0 +1,358 @@
+# Cline CLI
+
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/7123f9d1-afeb-48d5-93fa-e750dec0ebba" width="70%" />
+</p>
+
+<div align="center">
+<table>
+<tbody>
+<td align="center">
+<a href="https://www.npmjs.com/package/cline" target="_blank">NPM</a>
+</td>
+<td align="center">
+<a href="https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev" target="_blank">VS Code Extension</a>
+</td>
+<td align="center">
+<a href="https://discord.gg/cline" target="_blank">Discord</a>
+</td>
+<td align="center">
+<a href="https://www.reddit.com/r/cline/" target="_blank">r/cline</a>
+</td>
+<td align="center">
+<a href="https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop" target="_blank">Feature Requests</a>
+</td>
+<td align="center">
+<a href="https://docs.cline.bot" target="_blank">Docs</a>
+</td>
+</tbody>
+</table>
+</div>
+
+Run Cline in your terminal. Interactive chat for paired sessions, or fully headless for CI/CD and scripting. The CLI shares its agent core with the [Cline VS Code extension](https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev), JetBrains plugin, and SDK, so plan/act modes, MCP servers, checkpoints, rules, skills, and provider configuration all behave the same across surfaces.
+
+## Install
+
+```sh
+npm install -g cline
+```
+
+For nightly builds:
+
+```sh
+npm install -g cline@nightly
+```
+
+Platform binaries are published for macOS, Linux, and Windows on `arm64` and `x64`. The `cline` package resolves the correct binary for your platform via optional dependencies, so no Node, Bun, or Zig runtime is required at install time.
+
+## Quick start
+
+Run interactively:
+
+```sh
+cline
+```
+
+Run a single prompt:
+
+```sh
+cline "Audit this package and propose fixes"
+```
+
+Pipe input:
+
+```sh
+cat file.txt | cline "Summarize this"
+```
+
+See `cline --help` for the full flag reference.
+
+## Use any provider
+
+Cline supports the same providers as the VS Code extension. You can sign in to Cline directly, use your ChatGPT Subscription through `openai-codex`, or bring an API key from Anthropic, OpenAI, Google Gemini, OpenRouter, AWS Bedrock, GCP Vertex, Cerebras, Groq, and any OpenAI-compatible endpoint.
+
+```sh
+cline auth                              # interactive sign-in
+cline auth cline                        # OAuth sign-in
+cline auth --provider anthropic --apikey sk-... --modelid claude-sonnet-4-6
+```
+
+`cline auth` without a provider opens the interactive auth setup TUI with the same options as the old CLI flow (Sign in with Cline, Sign in with ChatGPT Subscription, Sign in with OCA, or use your own API key).
+
+OAuth-supported providers (`cline`, `openai-codex`, `oca`) do not auto-launch a browser on normal startup. Authenticate explicitly first with `cline auth <provider>`. For non-interactive runs, if an OAuth provider is selected and no saved credentials are available, `cline` fails fast with an authentication message instead of launching a hidden browser flow.
+
+## Modes
+
+Cline CLI runs in a few different shapes depending on what you need:
+
+- Interactive TUI: `cline` or `cline -i` opens a full terminal UI with plan/act toggle, slash commands, file mentions, and live tool approvals
+- One-shot: `cline "your prompt"` runs a single turn and exits
+- JSON: `cline --json "..."` streams NDJSON events for piping into other tools
+- Yolo: `cline --yolo "..."` skips approval prompts and exits when the turn finishes
+- Zen: `cline --zen "..."` fires the task to the background hub daemon and exits immediately (see below)
+
+## Headless mode for CI/CD
+
+Run Cline with zero interaction for scripting and automation. Pipe input, get JSON output, chain commands, integrate into CI/CD pipelines.
+
+```sh
+# One-shot prompt, auto-approve all tools
+cline --yolo "Run tests and fix any failures"
+
+# Pipe a diff in for review
+git diff origin/main | cline "Review these changes for issues"
+
+# NDJSON output for downstream tooling
+cline --json "List all TODO comments" | jq -r 'select(.type == "agent_event" and .event.text) | .event.text'
+```
+
+## Features
+
+- Streaming TUI built on [OpenTUI](https://github.com/sst/opentui) with markdown rendering, syntax-highlighted diffs, scrollable chat, and mouse support
+- Plan/Act mode toggle for switching between planning and execution
+- Native MCP support for connecting custom tools
+- Checkpoints with `/undo` to rewind workspace state
+- Sub-agent spawning and agent teams for parallel work
+- OAuth login for Cline, ChatGPT Subscription (`openai-codex`), and OCA
+- Configurable thinking budgets per run
+- Cron and event-driven schedules for recurring agent work
+- Chat connectors for Telegram, Google Chat, and WhatsApp
+
+## Usage
+
+```sh
+# Start Cline CLI without a prompt to enter interactive mode
+cline
+
+# Single prompt (one-shot) - includes tools, spawn, and teams
+cline "Audit this package and propose fixes"
+
+# Interactive mode with a starting prompt
+cline -i "Let's work on this together. First, analyze the current state."
+
+# With a custom system prompt
+cline -i -s "You are a pirate" "Tell me about the sea"
+
+# Require approval before each tool call
+cline --auto-approve false "Inspect and modify this repository"
+
+# Explicit yolo: enables submit_and_exit and disables spawn/team tools by default
+cline --yolo --retries 5 "Refactor this package"
+
+# Override consecutive internal mistake (retry) limit (default: 3)
+cline --retries 5 "Fix failing tests"
+
+# Team workflow with persistent name
+cline --team-name my-team "Plan, implement, and verify release checklist"
+cline --team-name my-team "Continue yesterday's team workflow"
+
+# Show verbose run stats (elapsed time, tokens, estimated cost when available)
+cline -v "Explain quantum computing"
+
+# Use a specific provider, model, and access token for a single prompt
+cline -P openrouter -m google/gemini-3-pro -k sk-... "Set up a storybook"
+
+# Use a different model with the last used provider
+cline -m anthropic/claude-opus-4-6 "Explain string theory"
+
+# Stream structured NDJSON output
+cline --json "Summarize this repository"
+
+# Quick provider setup
+cline auth --provider anthropic --apikey sk-... --modelid claude-sonnet-4-6
+cline auth --provider openai-native --apikey sk-... --modelid gpt-5 --baseurl https://api.example.com/v1
+```
+
+### MCP servers
+
+Manage MCP servers with the interactive wizard:
+
+```sh
+cline mcp
+cline config mcp
+```
+
+Open the add-server wizard with the name, transport, and command or URL already filled in with `cline mcp install` (`cline mcp add` also works). Stdio servers use everything after `--` as the command and arguments:
+
+```sh
+cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp
+```
+
+Remote HTTP and SSE servers take a name, transport, and URL. The wizard still asks for auth details before saving:
+
+```sh
+cline mcp install ctx7 --transport http https://mcp.context7.com/mcp
+cline mcp install events --transport sse https://example.com/sse
+```
+
+Because this command opens the wizard, it requires a TTY.
+
+### Connectors
+
+Bridge a chat surface into RPC-backed Cline sessions. Each conversation thread maps to a session with full context. Supported platforms: Telegram, Slack, Google Chat, WhatsApp, and Linear.
+
+```sh
+# Telegram (polling mode)
+cline connect telegram -k 123456:ABCDEF...
+
+# Slack (webhook mode)
+cline connect slack --bot-token $SLACK_BOT_TOKEN --signing-secret $SLACK_SIGNING_SECRET --base-url https://your-domain.com
+
+# Slack (socket mode)
+cline connect slack --bot-token $SLACK_BOT_TOKEN --app-token $SLACK_APP_TOKEN
+
+# Google Chat (webhook mode)
+cline connect gchat --base-url https://your-domain.com
+
+# WhatsApp (webhook mode)
+cline connect whatsapp --base-url https://your-domain.com
+
+# Linear (webhook mode)
+cline connect linear --api-key $LINEAR_API_KEY --base-url https://your-domain.com
+
+# Stop connector bridges and delete their sessions
+cline connect --stop
+cline connect --stop telegram
+```
+
+In chat surfaces, connector slash commands include `/help`, `/start`, `/new`, `/clear`, `/whereami`, `/tools`, `/yolo`, `/cwd <path>`, `/schedule`, `/abort`, and `/exit`. Run `cline connect <adapter> --help` to see the full flag list for any adapter.
+
+### Schedules
+
+Schedule agents on cron-like intervals or external events.
+
+```sh
+cline schedule create "Daily code review" \
+  --cron "0 9 * * MON-FRI" \
+  --prompt "Review PRs opened yesterday and summarize issues." \
+  --workspace /path/to/repo \
+  --provider cline \
+  --model openai/gpt-5.3-codex \
+  --timeout 3600 \
+  --tags automation,review
+
+cline schedule list
+cline schedule get <schedule-id>
+cline schedule trigger <schedule-id>
+cline schedule history <schedule-id> --limit 20
+cline schedule export <schedule-id> > daily-review.yaml
+cline schedule import ./daily-review.yaml
+```
+
+Schedules can route results back to chat surfaces with `--delivery-adapter`, `--delivery-bot`, and `--delivery-thread`.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-s, --system <prompt>` | Override the system prompt |
+| `-P, --provider <id>` | Provider id (default: `cline`) |
+| `-m, --model <id>` | Model id (default: `anthropic/claude-sonnet-4.6`) |
+| `-k, --key <api-key>` | API key override for this run |
+| `-p, --plan` | Run in plan mode (default is act mode) |
+| `-i, --tui` | Interactive TUI multi-turn mode |
+| `-t, --timeout <seconds>` | Optional run timeout in seconds |
+| `-c, --cwd <path>` | Working directory for tools |
+| `--config <path>` | Configuration directory (used for CLI home resolution) |
+| `--hooks-dir <path>` | Additional hooks directory hint for runtime hook injection |
+| `--acp` | ACP (Agent Client Protocol) mode |
+| `--thinking [none\|low\|medium\|high\|xhigh]` | Model thinking level when supported. Defaults to `medium` when the flag is provided without a level; thinking is off when the flag is omitted. |
+| `--compaction <agentic\|basic\|off>` | Context compaction mode. Defaults to `basic`; use `agentic` for LLM compaction or `off` to disable. |
+| `--retries <count>` | Maximum consecutive mistakes (retries) before halting (default: `3`) |
+| `--json` | Output NDJSON instead of styled text |
+| `--data-dir <path>` | Use isolated local state at `<path>` instead of `~/.cline` (enables sandbox mode automatically) |
+| `--auto-approve [true\|false]` | Set tool auto-approval for all tools |
+| `--kanban` | Run the external `kanban` app |
+| `-y, --yolo` | Skip tool approval prompts, enable `submit_and_exit`, and disable spawn/team tools by default |
+| `-z, --zen` | Dispatch the task to the background hub and exit the CLI immediately |
+| `--team-name <name>` | Override the runtime team state name |
+| `-h, --help` | Show help and exit |
+| `-v, --verbose` | Show verbose runtime diagnostics |
+| `-V, --version` | Show version and exit |
+
+`--json` is non-interactive and requires either a prompt argument or piped stdin. `--key` takes precedence over environment variables.
+
+## Top-level commands
+
+- `cline config` - Open the interactive config view
+- `cline history|h [options]` - List session history or manage saved sessions
+- `cline version` - Show CLI version
+- `cline update [options]` - Check for CLI and kanban updates
+- `cline auth <provider>` - Authenticate or seed provider credentials
+- `cline connect <adapter>` - Run a chat connector bridge (`telegram`, `gchat`, `whatsapp`)
+- `cline connect --stop [adapter]` - Stop connector bridge processes and their sessions
+- `cline schedule <command>` - Create and manage scheduled runs
+- `cline doctor` - Inspect local CLI health and stale processes
+- `cline doctor fix` - Kill stale local RPC listeners and old CLI processes
+- `cline doctor log` - Open the CLI runtime log file
+- `cline hook` - Handle a hook payload from stdin
+- `cline hub` - Manage the local hub daemon
+- `cline kanban` - Run the external `kanban` app, installing it first when needed
+
+## Zen mode
+
+`--zen` (alias `-z`) runs a task in the background hub daemon and exits the CLI immediately. It is intended for long-running tasks you want to fire off and walk away from.
+
+```sh
+cline --zen "Refactor the authentication module and add unit tests"
+```
+
+Behavior:
+
+- The CLI starts (or reuses) the local hub daemon, submits the task, then exits. It does not stream output or stay attached to the session.
+- Because there is no human in the loop once the CLI exits, zen sessions run with full tool auto-approval (same semantics as `--yolo`). `spawn`/`team` tools are disabled by default for safety, consistent with yolo-mode defaults.
+- If the Cline menubar app is running, it subscribes to hub `ui.notify` events and will surface a system notification when the task completes.
+- If the menubar app is not running, there is no live UI for the task. Use `cline history` later to find the session and inspect the result.
+- `--zen` is incompatible with `--data-dir` (the implicit sandbox requires a local backend that exits with the CLI) and with `--tui` (there is no terminal UI to render into).
+
+## Tool approval
+
+Tool calls are auto-approved by default. Use `--auto-approve false` to require review before tool execution.
+
+```sh
+cline --auto-approve false "Inspect and modify this repository"
+```
+
+When approval is required, the CLI prompts in TTY mode:
+
+```text
+Approve tool "<tool_name>" with input <preview>? [y/N]
+```
+
+- Enter `y` or `yes` to approve.
+- Enter anything else (or press Enter) to reject.
+- If stdin/stdout is not a TTY, required-approval calls are denied in terminal mode.
+
+Desktop-integrated approval mode is also supported via env wiring (`CLINE_TOOL_APPROVAL_MODE=desktop` and `CLINE_TOOL_APPROVAL_DIR=<path>`). In desktop mode, CLI writes a request JSON file and waits for a matching decision JSON file.
+
+## Environment variables
+
+- `ANTHROPIC_API_KEY` - API key for Anthropic
+- `CLINE_API_KEY` - API key for Cline (when using `-P cline`)
+- `OPENAI_API_KEY` - API key for OpenAI (when using `-P openai`)
+- `OPENROUTER_API_KEY` - API key for OpenRouter (when using `-P openrouter`)
+- `AI_GATEWAY_API_KEY` - API key for Vercel AI Gateway (when using `-P vercel-ai-gateway`)
+- `V0_API_KEY` - API key for v0 (when using `-P v0`)
+- `CLINE_DATA_DIR` - Base data directory for sessions/settings/teams/hooks
+- `CLINE_SANDBOX` - Set to `1` to force sandbox mode
+- `CLINE_SANDBOX_DATA_DIR` - Override sandbox state directory
+- `CLINE_TEAM_DATA_DIR` - Override team persistence directory
+- `CLINE_BUILD_ENV` - Runtime build mode for SDK-owned subprocess launches
+- `CLINE_DEBUG_HOST` - Host for development inspector listeners (default `127.0.0.1`)
+- `CLINE_DEBUG_PORT_BASE` - Base inspector port for development child processes
+- `CLINE_TOOL_APPROVAL_MODE` - Approval mode (`desktop` uses file IPC; unset uses terminal prompt)
+- `CLINE_TOOL_APPROVAL_DIR` - Directory for desktop approval request/decision files
+- `CLINE_LOG_ENABLED` - Set to `0`/`false` to disable runtime file logging
+- `CLINE_LOG_LEVEL` - Runtime log level (`trace|debug|info|warn|error|fatal|silent`, default `info`)
+- `CLINE_LOG_PATH` - Runtime log file path (default `<CLINE_DATA_DIR>/logs/cline.log`)
+- `CLINE_LOG_NAME` - Logger name embedded in runtime log records
+
+`--key` takes precedence over environment variables.
+
+## Contributing
+
+See [DEVELOPMENT.md](./DEVELOPMENT.md) for local development setup, monorepo structure, and TUI architecture. See [DISTRIBUTION.md](./DISTRIBUTION.md) for how the CLI is packaged and distributed.
+
+## License
+
+[Apache 2.0 © Cline Bot Inc.](https://github.com/cline/cline/blob/main/LICENSE)
diff --git a/apps/cli/bin/cline b/apps/cli/bin/cline
new file mode 100755
index 0000000..10f48e0
--- /dev/null
+++ b/apps/cli/bin/cline
@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+// Binary resolver for Cline CLI.
+//
+// This script runs with Node.js (available everywhere npm is) and finds the
+// correct platform-specific compiled binary to execute. The compiled binary
+// has Bun embedded, so users don't need Bun installed.
+//
+// Resolution order:
+// 1. CLINE_BIN_PATH env var override
+// 2. Cached binary at bin/.cline (created by postinstall)
+// 3. Walk up node_modules to find the platform-specific package
+
+const childProcess = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const scriptPath = fs.realpathSync(__filename);
+const scriptDir = path.dirname(scriptPath);
+const childEnv = {
+	...process.env,
+	CLINE_WRAPPER_PATH: scriptPath,
+};
+
+function run(target) {
+	const result = childProcess.spawnSync(target, process.argv.slice(2), {
+		stdio: "inherit",
+		env: childEnv,
+	});
+	if (result.error) {
+		console.error(result.error.message);
+		process.exit(1);
+	}
+	if (typeof result.status === "number") {
+		process.exit(result.status);
+	}
+	if (result.signal) {
+		process.kill(process.pid, result.signal);
+		process.exit(128);
+	}
+	process.exit(1);
+}
+
+// 1. Check env var override
+const envPath = process.env.CLINE_BIN_PATH;
+if (envPath) {
+	run(envPath);
+}
+
+// 2. Check cached binary
+const cached = path.join(scriptDir, ".cline");
+if (fs.existsSync(cached)) {
+	run(cached);
+}
+
+// 3. Detect platform and architecture
+const platformMap = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "windows",
+};
+const archMap = {
+	x64: "x64",
+	arm64: "arm64",
+};
+
+let platform = platformMap[os.platform()];
+if (!platform) {
+	platform = os.platform();
+}
+let arch = archMap[os.arch()];
+if (!arch) {
+	arch = os.arch();
+}
+
+const base = "@cline/cli-" + platform + "-" + arch;
+const binary = platform === "windows" ? "cline.exe" : "cline";
+
+// Build fallback chain of package names to try
+const names = [base];
+
+function findBinary(startDir) {
+	let current = startDir;
+	for (;;) {
+		const modules = path.join(current, "node_modules");
+		if (fs.existsSync(modules)) {
+			for (const name of names) {
+				// Scoped package: @cline/cli-darwin-arm64 lives at
+				// node_modules/@cline/cli-darwin-arm64
+				const candidate = path.join(modules, name, "bin", binary);
+				if (fs.existsSync(candidate)) return candidate;
+			}
+		}
+		const parent = path.dirname(current);
+		if (parent === current) {
+			return undefined;
+		}
+		current = parent;
+	}
+}
+
+const resolved = findBinary(scriptDir);
+if (!resolved) {
+	console.error(
+		"Could not find the Cline CLI binary for your platform.\n" +
+			"Your platform: " +
+			os.platform() +
+			" " +
+			os.arch() +
+			"\n" +
+			"Looked for: " +
+			names.map(function (n) {
+				return '"' + n + '"';
+			}).join(" or ") +
+			"\n\n" +
+			"Try reinstalling: npm install -g cline",
+	);
+	process.exit(1);
+}
+
+run(resolved);
diff --git a/apps/cli/bun.mts b/apps/cli/bun.mts
new file mode 100644
index 0000000..548a877
--- /dev/null
+++ b/apps/cli/bun.mts
@@ -0,0 +1,147 @@
+import {
+	copyFileSync,
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	statSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { $ } from "bun";
+
+function defineProcessEnv(name: string): string {
+	return JSON.stringify(process.env[name] ?? "");
+}
+
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+const rootDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(rootDir, "../../");
+const hubWebviewSourcePath = join(repoRoot, "apps/cline-hub/src/webview");
+const hubWebviewDistPath = join(repoRoot, "apps/cline-hub/dist/webview");
+const hubWebviewIndexPath = join(hubWebviewDistPath, "index.html");
+const cliHubWebviewDistPath = join(rootDir, "dist/cline-hub/webview");
+
+function newestFileMtimeMs(dir: string): number {
+	let newest = 0;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (
+			entry.name === "node_modules" ||
+			entry.name === "dist" ||
+			entry.name === ".turbo"
+		) {
+			continue;
+		}
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			newest = Math.max(newest, newestFileMtimeMs(path));
+		} else if (entry.isFile()) {
+			newest = Math.max(newest, statSync(path).mtimeMs);
+		}
+	}
+	return newest;
+}
+
+function shouldBuildHubWebview(): boolean {
+	if (!existsSync(hubWebviewIndexPath)) {
+		return true;
+	}
+	try {
+		return (
+			newestFileMtimeMs(hubWebviewSourcePath) >
+			statSync(hubWebviewIndexPath).mtimeMs
+		);
+	} catch {
+		return true;
+	}
+}
+
+if (shouldBuildHubWebview()) {
+	console.log("Building Cline Hub webview...");
+	await $`bun -F @cline/cline-hub build:webview`.cwd(repoRoot);
+}
+
+const result = await Bun.build({
+	entrypoints: ["./src/index.ts"],
+	outdir: "./dist",
+	target: "node",
+	format: "esm",
+	sourcemap,
+	packages: "bundle", // Keep private workspace packages bundled so npm consumers do not need @cline/* at runtime.
+	external: [
+		// OpenTUI resolves a platform-specific native package at runtime.
+		// Bundling through that resolution path rewrites the import in a way that
+		// breaks Linux e2e runs from dist/. Keep React external too so OpenTUI and
+		// the CLI share one React runtime instead of ending up with duplicate hook
+		// dispatchers in the bundle.
+		"@opentui/core",
+		"@opentui/react",
+		"@opentui-ui/dialog",
+		"opentui-spinner",
+		"react",
+		"react/jsx-runtime",
+		"react/jsx-dev-runtime",
+		"react-devtools-core",
+	],
+	define: {
+		"process.env.NODE_ENV": '"production"',
+		...(process.env.TELEMETRY_SERVICE_API_KEY
+			? {
+					"process.env.TELEMETRY_SERVICE_API_KEY": defineProcessEnv(
+						"TELEMETRY_SERVICE_API_KEY",
+					),
+				}
+			: {}),
+		...(process.env.ERROR_SERVICE_API_KEY
+			? {
+					"process.env.ERROR_SERVICE_API_KEY": defineProcessEnv(
+						"ERROR_SERVICE_API_KEY",
+					),
+				}
+			: {}),
+		"process.env.OTEL_TELEMETRY_ENABLED": defineProcessEnv(
+			"OTEL_TELEMETRY_ENABLED",
+		),
+		"process.env.OTEL_EXPORTER_OTLP_ENDPOINT": defineProcessEnv(
+			"OTEL_EXPORTER_OTLP_ENDPOINT",
+		),
+		"process.env.OTEL_METRICS_EXPORTER": defineProcessEnv(
+			"OTEL_METRICS_EXPORTER",
+		),
+		"process.env.OTEL_LOGS_EXPORTER": defineProcessEnv("OTEL_LOGS_EXPORTER"),
+		"process.env.OTEL_EXPORTER_OTLP_PROTOCOL": defineProcessEnv(
+			"OTEL_EXPORTER_OTLP_PROTOCOL",
+		),
+		"process.env.OTEL_METRIC_EXPORT_INTERVAL": defineProcessEnv(
+			"OTEL_METRIC_EXPORT_INTERVAL",
+		),
+		"process.env.OTEL_EXPORTER_OTLP_HEADERS": defineProcessEnv(
+			"OTEL_EXPORTER_OTLP_HEADERS",
+		),
+	},
+	env: "OTEL_*",
+	banner:
+		'import { createRequire as __clineCreateRequire } from "node:module"; const require = __clineCreateRequire(import.meta.url);',
+});
+
+if (result.logs.length > 0) {
+	for (const log of result.logs) {
+		console.warn(log);
+	}
+}
+
+const coreBootstrapPath = join(
+	rootDir,
+	"../../sdk/packages/core/dist/extensions/plugin-sandbox-bootstrap.js",
+);
+const cliBootstrapPath = join(
+	rootDir,
+	"./dist/extensions/plugin-sandbox-bootstrap.js",
+);
+mkdirSync(dirname(cliBootstrapPath), { recursive: true });
+copyFileSync(coreBootstrapPath, cliBootstrapPath);
+
+if (existsSync(hubWebviewDistPath)) {
+	mkdirSync(dirname(cliHubWebviewDistPath), { recursive: true });
+	cpSync(hubWebviewDistPath, cliHubWebviewDistPath, { recursive: true });
+}
diff --git a/apps/cli/package.json b/apps/cli/package.json
new file mode 100644
index 0000000..22bde91
--- /dev/null
+++ b/apps/cli/package.json
@@ -0,0 +1,106 @@
+{
+	"name": "@cline/cli",
+	"displayName": "cline",
+	"version": "3.0.39",
+	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
+	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/cline/cline.git",
+		"directory": "apps/cli"
+	},
+	"keywords": [
+		"cline",
+		"claude",
+		"dev",
+		"mcp",
+		"openrouter",
+		"coding",
+		"agent",
+		"autonomous",
+		"chatgpt",
+		"sonnet",
+		"ai",
+		"llama",
+		"cli"
+	],
+	"author": {
+		"name": "Cline Bot Inc."
+	},
+	"license": "Apache-2.0",
+	"homepage": "https://cline.bot",
+	"bugs": {
+		"url": "https://github.com/cline/cline/issues"
+	},
+	"bin": {
+		"cline": "src/index.ts"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"main": "dist/index.js",
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "bun run bun.mts",
+		"build:platforms": "bun script/build.ts --install-native-variants",
+		"build:platforms:single": "bun script/build.ts --single",
+		"prepack": "bun script/guard-direct-publish.ts",
+		"prepublishOnly": "bun script/guard-direct-publish.ts",
+		"publish:npm": "bun script/publish-npm.ts",
+		"publish:npm:dry": "bun script/publish-npm.ts --dry-run",
+		"dev": "CLINE_BUILD_ENV=development bun --conditions=development ./src/index.ts",
+		"typecheck": "tsc --noEmit",
+		"test": "bun run test:unit",
+		"test:unit": "vitest run --config vitest.config.ts",
+		"test:e2e": "vitest run --config vitest.e2e.config.ts",
+		"test:e2e:interactive": "vitest run --config vitest.interactive.e2e.config.ts",
+		"test:watch": "vitest --config vitest.config.ts",
+		"test:e2e:cli:tui": "cd src/tests && tui-test",
+		"link": "bun unlink && bun link"
+	},
+	"dependencies": {
+		"@agentclientprotocol/sdk": "^0.16.1",
+		"@chat-adapter/discord": "^4.23.0",
+		"@chat-adapter/gchat": "^4.23.0",
+		"@chat-adapter/linear": "^4.23.0",
+		"@chat-adapter/slack": "^4.23.0",
+		"@chat-adapter/telegram": "^4.23.0",
+		"@chat-adapter/whatsapp": "^4.23.0",
+		"@clack/prompts": "^1.2.0",
+		"@cline/cline-hub": "workspace:*",
+		"@gramio/format": "^0.7.0",
+		"@opentui-ui/dialog": "^0.1.2",
+		"@opentui/core": "0.1.102",
+		"@opentui/react": "0.1.102",
+		"chat": "^4.23.0",
+		"commander": "^14.0.3",
+		"fzf": "^0.5.2",
+		"marked": "^15.0.12",
+		"open": "^10.2.0",
+		"opentui-spinner": "^0.0.6",
+		"pino": "^10.3.1",
+		"posthog-node": "^5.8.0",
+		"react": "19.2.4",
+		"react-devtools-core": "^7.0.1",
+		"react-reconciler": "0.32.0",
+		"yaml": "^2.8.2",
+		"nanoid": "^5.1.7",
+		"zod": "^4.1.11"
+	},
+	"devDependencies": {
+		"@cline/core": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"@microsoft/tui-test": "^0.0.2",
+		"@types/react": "19.2.14",
+		"vitest": "^4.0.18",
+		"@types/bun": "^1.3.10"
+	}
+}
diff --git a/apps/cli/script/build-options.ts b/apps/cli/script/build-options.ts
new file mode 100644
index 0000000..6377c86
--- /dev/null
+++ b/apps/cli/script/build-options.ts
@@ -0,0 +1,49 @@
+export interface BuildOptions {
+	single: boolean;
+	skipInstall: boolean;
+	skipSdkBuild: boolean;
+	installNativeVariants: boolean;
+}
+
+export function parseBuildOptions(args: readonly string[]): BuildOptions {
+	return {
+		single: args.includes("--single"),
+		skipInstall: args.includes("--skip-install"),
+		skipSdkBuild: args.includes("--skip-sdk-build"),
+		installNativeVariants: args.includes("--install-native-variants"),
+	};
+}
+
+export function shouldInstallNativeVariants(input: {
+	options: BuildOptions;
+	opentuiVersion: string | undefined;
+}): boolean {
+	return Boolean(
+		input.opentuiVersion &&
+			input.options.installNativeVariants &&
+			!input.options.skipInstall,
+	);
+}
+
+export function validateBuildOptions(input: {
+	options: BuildOptions;
+	opentuiVersion: string | undefined;
+	targetCount: number;
+}): string | undefined {
+	if (input.targetCount === 0) {
+		return "No matching targets for this platform.";
+	}
+	if (
+		input.opentuiVersion &&
+		!input.options.single &&
+		!input.options.skipInstall &&
+		!input.options.installNativeVariants
+	) {
+		return [
+			"Cross-platform OpenTUI builds require native package variants.",
+			"Pass --install-native-variants to allow the build script to run bun install for all OpenTUI native packages.",
+			"Pass --skip-install only when those packages are already installed.",
+		].join("\n");
+	}
+	return undefined;
+}
diff --git a/apps/cli/script/build.ts b/apps/cli/script/build.ts
new file mode 100644
index 0000000..1e6d222
--- /dev/null
+++ b/apps/cli/script/build.ts
@@ -0,0 +1,309 @@
+#!/usr/bin/env bun
+
+import {
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	realpathSync,
+	statSync,
+} from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { $ } from "bun";
+import {
+	parseBuildOptions,
+	shouldInstallNativeVariants,
+	validateBuildOptions,
+} from "./build-options";
+
+const cliDir = resolve(import.meta.dir, "..");
+const rootDir = resolve(cliDir, "../..");
+process.chdir(cliDir);
+
+// Telemetry / OTEL environment variables that should be baked into the
+// compiled binary at build time. Mirrors the list of secrets injected by the
+// `cli-publish` GitHub Actions workflow. These are inlined via Bun's `define`
+// so the CLI ships with the production telemetry configuration without
+// requiring the end user to set any env vars.
+const BUILD_TIME_INLINED_ENV_VARS = [
+	"TELEMETRY_SERVICE_API_KEY",
+	"ERROR_SERVICE_API_KEY",
+	"OTEL_TELEMETRY_ENABLED",
+	"OTEL_LOGS_EXPORTER",
+	"OTEL_METRICS_EXPORTER",
+	"OTEL_EXPORTER_OTLP_PROTOCOL",
+	"OTEL_EXPORTER_OTLP_ENDPOINT",
+	"OTEL_EXPORTER_OTLP_HEADERS",
+] as const;
+
+function buildInlinedEnvDefines(): Record<string, string> {
+	const defines: Record<string, string> = {};
+	for (const name of BUILD_TIME_INLINED_ENV_VARS) {
+		defines[`process.env.${name}`] = JSON.stringify(process.env[name] ?? "");
+	}
+	return defines;
+}
+
+const pkg = JSON.parse(readFileSync(join(cliDir, "package.json"), "utf-8"));
+const version: string = pkg.version;
+const repository: unknown = pkg.repository;
+
+console.log(`Building @cline/cli v${version}`);
+
+const buildOptions = parseBuildOptions(process.argv.slice(2));
+
+const allTargets: {
+	os: string;
+	arch: "arm64" | "x64";
+}[] = [
+	{ os: "linux", arch: "arm64" },
+	{ os: "linux", arch: "x64" },
+	{ os: "darwin", arch: "arm64" },
+	{ os: "darwin", arch: "x64" },
+	{ os: "win32", arch: "x64" },
+	{ os: "win32", arch: "arm64" },
+];
+
+const targets = buildOptions.single
+	? allTargets.filter(
+			(item) => item.os === process.platform && item.arch === process.arch,
+		)
+	: allTargets;
+
+const opentuiVersion = pkg.dependencies["@opentui/core"];
+const optionsError = validateBuildOptions({
+	options: buildOptions,
+	opentuiVersion,
+	targetCount: targets.length,
+});
+if (optionsError) {
+	console.error(optionsError);
+	process.exit(1);
+}
+
+await $`rm -rf dist`;
+
+// Pre-install all platform variants of native packages so cross-compilation
+// can resolve them. Without this, Bun only has the host platform's native
+// binary and cross-compiled builds fail to resolve @opentui/core's FFI layer.
+if (shouldInstallNativeVariants({ options: buildOptions, opentuiVersion })) {
+	console.log(
+		`Installing all platform variants of @opentui/core@${opentuiVersion}...`,
+	);
+	await $`bun install --os="*" --cpu="*" @opentui/core@${opentuiVersion}`;
+}
+
+// Build the SDK first (the CLI bundles workspace packages)
+if (!buildOptions.skipSdkBuild) {
+	console.log("Building SDK packages...");
+	await $`bun run build:sdk`.cwd(rootDir);
+
+	console.log("Building CLI bundle...");
+	await $`bun -F @cline/cli build`.cwd(rootDir);
+}
+
+const hubWebviewSource = join(cliDir, "../cline-hub/src/webview");
+const hubWebviewDist = join(cliDir, "../cline-hub/dist/webview");
+const hubWebviewIndex = join(hubWebviewDist, "index.html");
+
+function newestFileMtimeMs(dir: string): number {
+	let newest = 0;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (
+			entry.name === "node_modules" ||
+			entry.name === "dist" ||
+			entry.name === ".turbo"
+		) {
+			continue;
+		}
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			newest = Math.max(newest, newestFileMtimeMs(path));
+		} else if (entry.isFile()) {
+			newest = Math.max(newest, statSync(path).mtimeMs);
+		}
+	}
+	return newest;
+}
+
+function shouldBuildHubWebview(): boolean {
+	if (!existsSync(hubWebviewIndex)) {
+		return true;
+	}
+	try {
+		return (
+			newestFileMtimeMs(hubWebviewSource) > statSync(hubWebviewIndex).mtimeMs
+		);
+	} catch {
+		return true;
+	}
+}
+
+if (shouldBuildHubWebview()) {
+	console.log("Building Cline Hub webview...");
+	await $`bun -F @cline/cline-hub build:webview`.cwd(rootDir);
+}
+
+const binaries: Record<string, string> = {};
+
+function findOpenTuiParserWorker(): string {
+	const localPath = resolve(
+		cliDir,
+		"node_modules/@opentui/core/parser.worker.js",
+	);
+	const rootPath = resolve(
+		rootDir,
+		"node_modules/@opentui/core/parser.worker.js",
+	);
+	const parserWorkerPath = existsSync(localPath) ? localPath : rootPath;
+	return realpathSync(parserWorkerPath);
+}
+
+function getBunTarget(
+	item: (typeof allTargets)[number],
+): Bun.Build.CompileTarget {
+	const targetOs = item.os === "win32" ? "windows" : item.os;
+	return `bun-${targetOs}-${item.arch}` as Bun.Build.CompileTarget;
+}
+
+async function buildCompiledBinary(input: {
+	bunTarget: Bun.Build.CompileTarget;
+	dirName: string;
+	outfile: string;
+}): Promise<void> {
+	const parserWorker = findOpenTuiParserWorker();
+	const targetOs = input.bunTarget.includes("windows") ? "windows" : "posix";
+	const bunfsRoot = targetOs === "windows" ? "B:/~BUN/root/" : "/$bunfs/root/";
+	const parserWorkerPath = relative(rootDir, parserWorker).replaceAll(
+		"\\",
+		"/",
+	);
+
+	// Build to /tmp first so Bun's temp-file rename stays on one filesystem
+	// layer in containerized environments (virtiofs, overlayfs).
+	const entrypoint = join(cliDir, "src/index.ts");
+	const tmpDir = join("/tmp", `cline-build-${input.dirName}`);
+	const tmpOutfile = join(
+		tmpDir,
+		input.outfile.endsWith(".exe") ? "cline.exe" : "cline",
+	);
+	mkdirSync(tmpDir, { recursive: true });
+
+	process.chdir("/tmp");
+	const result = await Bun.build({
+		entrypoints: [entrypoint, parserWorker],
+		splitting: true,
+		compile: {
+			target: input.bunTarget,
+			outfile: tmpOutfile,
+		},
+		minify: true,
+		external: ["@anthropic-ai/vertex-sdk"],
+		define: {
+			OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + parserWorkerPath,
+			// Inline telemetry/OTEL env vars at build time so the compiled
+			// binary ships with production telemetry configuration baked in.
+			...buildInlinedEnvDefines(),
+		},
+		throw: false,
+	});
+	process.chdir(cliDir);
+
+	if (!result.success) {
+		console.error(`Build failed for ${input.dirName}:`);
+		for (const log of result.logs) {
+			console.error(log);
+		}
+		process.exit(1);
+	}
+
+	await $`cp ${tmpOutfile} ${input.outfile} && chmod 755 ${input.outfile}`;
+	await $`rm -rf ${tmpDir}`;
+}
+
+for (const item of targets) {
+	// npm treats "win32" specially in os field, but for package naming use "windows"
+	const displayOs = item.os === "win32" ? "windows" : item.os;
+	const name = `@cline/cli-${displayOs}-${item.arch}`;
+	const dirName = `cli-${displayOs}-${item.arch}`;
+	const binaryName = item.os === "win32" ? "cline.exe" : "cline";
+	const bunTarget = getBunTarget(item);
+
+	console.log(`\nBuilding ${name} (target: ${bunTarget})...`);
+	const outDir = join(cliDir, `dist/${dirName}/bin`);
+	mkdirSync(outDir, { recursive: true });
+
+	const outfile = join(outDir, binaryName);
+
+	await buildCompiledBinary({ bunTarget, dirName, outfile });
+
+	// Smoke test: only run on current platform
+	if (item.os === process.platform && item.arch === process.arch) {
+		console.log(`  Smoke test: ${outfile} --version`);
+		try {
+			const output = await $`${outfile} --version`.text();
+			const actualVersion = output.trim();
+			if (actualVersion !== version) {
+				throw new Error(
+					`Expected --version to print ${version}, got ${actualVersion}`,
+				);
+			}
+			console.log(`  Passed: ${actualVersion}`);
+		} catch (e) {
+			console.error(`  Smoke test FAILED for ${name}:`, e);
+			process.exit(1);
+		}
+	}
+
+	// Copy plugin sandbox bootstrap if it exists
+	const bootstrapSrc = join(
+		rootDir,
+		"sdk/packages/core/dist/extensions/plugin-sandbox-bootstrap.js",
+	);
+	if (existsSync(bootstrapSrc)) {
+		const bootstrapDir = join(cliDir, `dist/${dirName}/extensions`);
+		mkdirSync(bootstrapDir, { recursive: true });
+		const content = readFileSync(bootstrapSrc);
+		await Bun.write(join(bootstrapDir, "plugin-sandbox-bootstrap.js"), content);
+	}
+
+	if (existsSync(hubWebviewDist)) {
+		const hubWebviewDest = join(cliDir, `dist/${dirName}/cline-hub/webview`);
+		mkdirSync(join(cliDir, `dist/${dirName}/cline-hub`), {
+			recursive: true,
+		});
+		cpSync(hubWebviewDist, hubWebviewDest, { recursive: true });
+	}
+
+	// Generate platform package.json
+	await Bun.write(
+		join(cliDir, `dist/${dirName}/package.json`),
+		`${JSON.stringify(
+			{
+				name,
+				version,
+				description: `Cline CLI binary for ${displayOs} ${item.arch}`,
+				os: [item.os],
+				cpu: [item.arch],
+				...(repository ? { repository } : {}),
+				bin: {
+					cline: `bin/${binaryName}`,
+				},
+			},
+			null,
+			2,
+		)}\n`,
+	);
+
+	binaries[name] = version;
+	console.log(`  Built ${name}`);
+}
+
+console.log(`\nBuild complete. ${Object.keys(binaries).length} targets built.`);
+console.log("Packages:");
+for (const [name, ver] of Object.entries(binaries)) {
+	console.log(`  ${name}@${ver}`);
+}
+
+export { binaries, version };
diff --git a/apps/cli/script/guard-direct-publish.ts b/apps/cli/script/guard-direct-publish.ts
new file mode 100644
index 0000000..c12ef51
--- /dev/null
+++ b/apps/cli/script/guard-direct-publish.ts
@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+
+export const DIRECT_PUBLISH_GUARD_MESSAGE = [
+	"Direct packaging or publishing from apps/cli is disabled.",
+	"The source package points its development bin at src/index.ts, while the npm package is generated under dist/cli.",
+	"Run `bun run build:platforms` first, then `bun run publish:npm:dry` to preview the generated npm packages.",
+	"Use `bun run publish:npm` to publish those generated packages.",
+].join("\n");
+
+export function shouldAllowDirectPublish(env: NodeJS.ProcessEnv): boolean {
+	return env.CLINE_ALLOW_DIRECT_PUBLISH === "1";
+}
+
+if (import.meta.main && !shouldAllowDirectPublish(process.env)) {
+	console.error(DIRECT_PUBLISH_GUARD_MESSAGE);
+	process.exit(1);
+}
diff --git a/apps/cli/script/postinstall.mjs b/apps/cli/script/postinstall.mjs
new file mode 100644
index 0000000..cca04cb
--- /dev/null
+++ b/apps/cli/script/postinstall.mjs
@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+// Post-install script for Cline CLI.
+//
+// Creates a hard link (or copy fallback) from the platform-specific binary
+// to bin/.cline for fast startup on subsequent runs.
+//
+// This script must use only Node.js APIs (no Bun) since it runs via
+// "node script/postinstall.mjs" in the npm lifecycle.
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+function main() {
+	if (os.platform() === "win32") {
+		// On Windows, npm creates .cmd shims from the bin field.
+		// The resolver script handles binary lookup at runtime.
+		console.log("Windows detected: skipping binary cache setup");
+		return;
+	}
+
+	const platformMap = {
+		darwin: "darwin",
+		linux: "linux",
+	};
+	const platform = platformMap[os.platform()] || os.platform();
+	const arch = os.arch();
+	const packageName = `@cline/cli-${platform}-${arch}`;
+	const binaryName = "cline";
+
+	let binaryPath;
+	try {
+		const packageJsonPath = require.resolve(`${packageName}/package.json`);
+		const packageDir = path.dirname(packageJsonPath);
+		binaryPath = path.join(packageDir, "bin", binaryName);
+
+		if (!fs.existsSync(binaryPath)) {
+			throw new Error(`Binary not found at ${binaryPath}`);
+		}
+	} catch (_error) {
+		// Platform package not available. The resolver script will find
+		// it at runtime by walking node_modules. This is expected on
+		// platforms we don't ship binaries for.
+		console.log(`Note: ${packageName} not found, skipping binary cache`);
+		return;
+	}
+
+	const binDir =
+		path.basename(__dirname) === "script"
+			? path.join(__dirname, "..", "bin")
+			: path.join(__dirname, "bin");
+	const target = path.join(binDir, ".cline");
+
+	// Ensure bin directory exists
+	if (!fs.existsSync(binDir)) {
+		fs.mkdirSync(binDir, { recursive: true });
+	}
+
+	// Remove existing cached binary
+	if (fs.existsSync(target)) {
+		fs.unlinkSync(target);
+	}
+
+	// Hard link preferred (shares disk space), copy as fallback
+	// (hard links fail on some filesystems like NFS or cross-device)
+	try {
+		fs.linkSync(binaryPath, target);
+	} catch {
+		fs.copyFileSync(binaryPath, target);
+	}
+
+	fs.chmodSync(target, 0o755);
+	console.log(`Cached cline binary at ${target}`);
+}
+
+try {
+	main();
+} catch (error) {
+	// postinstall failures should never block npm install.
+	// The resolver script will find the binary at runtime.
+	console.error(`postinstall: ${error.message}`);
+	process.exit(0);
+}
diff --git a/apps/cli/script/publish-npm.ts b/apps/cli/script/publish-npm.ts
new file mode 100644
index 0000000..62a1b63
--- /dev/null
+++ b/apps/cli/script/publish-npm.ts
@@ -0,0 +1,356 @@
+#!/usr/bin/env bun
+
+// Publishes cline and all platform-specific binary packages to npm.
+//
+// Usage:
+//   bun script/publish-npm.ts                 # publish with "latest" tag
+//   bun script/publish-npm.ts --tag next     # publish with "next" tag
+//   bun script/publish-npm.ts --dry-run      # preview without publishing
+//
+// Prerequisites:
+//   - Run script/build.ts first to generate dist/ packages
+//   - GitHub trusted publishing or `npm login` for authentication
+
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { $ } from "bun";
+
+const cliDir = join(import.meta.dir, "..");
+process.chdir(cliDir);
+
+const { values } = parseArgs({
+	args: Bun.argv.slice(2),
+	options: {
+		"dry-run": { type: "boolean", default: false },
+		tag: { type: "string", default: "latest" },
+	},
+	strict: true,
+});
+
+const dryRun = values["dry-run"] ?? false;
+const npmTag = values.tag ?? "latest";
+const wrapperPackageName = "cline";
+
+const expectedPlatformPackages = [
+	"@cline/cli-darwin-arm64",
+	"@cline/cli-darwin-x64",
+	"@cline/cli-linux-arm64",
+	"@cline/cli-linux-x64",
+	"@cline/cli-windows-arm64",
+	"@cline/cli-windows-x64",
+] as const;
+
+const hostSdkPackages = [
+	{ name: "@cline/sdk", directory: "sdk" },
+	{ name: "@cline/core", directory: "core" },
+	{ name: "@cline/agents", directory: "agents" },
+	{ name: "@cline/llms", directory: "llms" },
+	{ name: "@cline/shared", directory: "shared" },
+] as const;
+
+interface PlatformPackageManifest {
+	name: string;
+	version: string;
+	os: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return (
+		Array.isArray(value) && value.every((item) => typeof item === "string")
+	);
+}
+
+function isPlatformPackageManifest(
+	value: unknown,
+): value is PlatformPackageManifest {
+	return (
+		isRecord(value) &&
+		typeof value.name === "string" &&
+		typeof value.version === "string" &&
+		isStringArray(value.os)
+	);
+}
+
+function readPackageVersion(name: string, packageJsonPath: string): string {
+	const pkg: unknown = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	if (!isRecord(pkg) || pkg.name !== name || typeof pkg.version !== "string") {
+		console.error(`Invalid package manifest for ${name}: ${packageJsonPath}`);
+		process.exit(1);
+	}
+	return pkg.version;
+}
+
+function buildHostSdkDependencies(): Record<string, string> {
+	const dependencies: Record<string, string> = {};
+	for (const pkg of hostSdkPackages) {
+		dependencies[pkg.name] = readPackageVersion(
+			pkg.name,
+			join(cliDir, "../../sdk/packages", pkg.directory, "package.json"),
+		);
+	}
+	return dependencies;
+}
+
+function removePackedTarballs(dir: string): void {
+	for (const entry of readdirSync(dir)) {
+		if (entry.endsWith(".tgz")) {
+			rmSync(join(dir, entry), { force: true });
+		}
+	}
+}
+
+async function npmPackageVersionExists(
+	name: string,
+	version: string,
+): Promise<boolean> {
+	const result = Bun.spawnSync(
+		["npm", "view", `${name}@${version}`, "version"],
+		{
+			cwd: cliDir,
+			stdout: "ignore",
+			stderr: "ignore",
+		},
+	);
+	return result.exitCode === 0;
+}
+
+async function verifyPublishedDependencies(
+	dependencies: Record<string, string>,
+): Promise<void> {
+	const missingDependencies: string[] = [];
+	for (const [name, version] of Object.entries(dependencies).sort()) {
+		if (!(await npmPackageVersionExists(name, version))) {
+			missingDependencies.push(`${name}@${version}`);
+		}
+	}
+
+	if (missingDependencies.length === 0) {
+		return;
+	}
+
+	console.error("Wrapper package dependencies are not published:");
+	for (const dependency of missingDependencies) {
+		console.error(`  ${dependency}`);
+	}
+	console.error("Publish the SDK packages before publishing the CLI wrapper.");
+	process.exit(1);
+}
+
+async function publishPackage(input: {
+	name: string;
+	version: string;
+	dir: string;
+	tag: string;
+	dryRun: boolean;
+}): Promise<void> {
+	if (process.platform !== "win32") {
+		await $`chmod -R 755 .`.cwd(input.dir);
+	}
+
+	if (input.dryRun) {
+		console.log(`  [dry-run] Would publish ${input.name}@${input.version}`);
+		return;
+	}
+
+	if (await npmPackageVersionExists(input.name, input.version)) {
+		console.log(`  ${input.name}@${input.version} already exists, skipping`);
+		return;
+	}
+
+	console.log(`  Publishing ${input.name}@${input.version}...`);
+	removePackedTarballs(input.dir);
+	await $`bun pm pack`.cwd(input.dir);
+	await $`npm publish *.tgz --access public --tag ${input.tag}`.cwd(input.dir);
+	console.log(`  Published ${input.name}@${input.version}`);
+}
+
+// Discover built platform packages from dist/
+const binaries: Record<string, string> = {};
+for await (const filepath of new Bun.Glob("*/package.json").scan({
+	cwd: join(cliDir, "dist"),
+})) {
+	const pkg: unknown = JSON.parse(
+		readFileSync(join(cliDir, "dist", filepath), "utf-8"),
+	);
+	if (isPlatformPackageManifest(pkg)) {
+		binaries[pkg.name] = pkg.version;
+	}
+}
+
+if (Object.keys(binaries).length === 0) {
+	console.error("No platform packages found in dist/.");
+	console.error("Run `bun script/build.ts` first.");
+	process.exit(1);
+}
+
+const missingPackages = expectedPlatformPackages.filter(
+	(name) => !(name in binaries),
+);
+if (missingPackages.length > 0) {
+	console.error("Missing platform packages in dist/:");
+	for (const name of missingPackages) {
+		console.error(`  ${name}`);
+	}
+	process.exit(1);
+}
+
+const versions = new Set(Object.values(binaries));
+if (versions.size !== 1) {
+	console.error("Platform package versions do not match:");
+	for (const [name, packageVersion] of Object.entries(binaries).sort()) {
+		console.error(`  ${name}@${packageVersion}`);
+	}
+	process.exit(1);
+}
+
+const version = Object.values(binaries)[0];
+const sourcePkg: unknown = JSON.parse(
+	readFileSync(join(cliDir, "package.json"), "utf-8"),
+);
+const sourcePkgRecord = isRecord(sourcePkg) ? sourcePkg : {};
+const sourceVersion =
+	"version" in sourcePkgRecord && typeof sourcePkgRecord.version === "string"
+		? sourcePkgRecord.version
+		: undefined;
+if (sourceVersion !== version) {
+	console.error(
+		`Built package version ${version} does not match apps/cli/package.json version ${sourceVersion ?? "(missing)"}.`,
+	);
+	process.exit(1);
+}
+const sourceRepository =
+	"repository" in sourcePkgRecord ? sourcePkgRecord.repository : undefined;
+const hostSdkDependencies = buildHostSdkDependencies();
+
+console.log(`Publishing ${wrapperPackageName} v${version}`);
+console.log(`  Tag: ${npmTag}`);
+console.log(`  Dry run: ${dryRun}`);
+console.log(`  Platform packages: ${Object.keys(binaries).length}`);
+for (const name of Object.keys(binaries)) {
+	console.log(`    ${name}`);
+}
+
+if (!dryRun) {
+	await verifyPublishedDependencies(hostSdkDependencies);
+}
+
+// Step 1: Publish platform-specific packages (in parallel)
+console.log("\nPublishing platform packages...");
+const platformTasks = Object.keys(binaries)
+	.sort()
+	.map(async (name) => {
+		const dirName = name.replace("@cline/", "");
+		const pkgDir = join(cliDir, "dist", dirName);
+
+		await publishPackage({
+			name,
+			version,
+			dir: pkgDir,
+			tag: npmTag,
+			dryRun,
+		});
+	});
+await Promise.all(platformTasks);
+
+// Step 2: Generate and publish the main wrapper package
+console.log("\nPreparing main package...");
+const mainPkgDir = join(cliDir, "dist", "cli");
+
+await $`rm -rf ${mainPkgDir}`;
+await $`mkdir -p ${mainPkgDir}`;
+await $`cp -r ${join(cliDir, "bin")} ${join(mainPkgDir, "bin")}`;
+await $`cp ${join(cliDir, "script/postinstall.mjs")} ${join(mainPkgDir, "postinstall.mjs")}`;
+
+// Copy LICENSE from repo root if it exists
+const licenseFrom = join(cliDir, "../../LICENSE");
+if (existsSync(licenseFrom)) {
+	await $`cp ${licenseFrom} ${join(mainPkgDir, "LICENSE")}`;
+}
+
+// Copy README.md so the npm registry listing has the same landing page
+// as the repo. The published wrapper package is generated fresh in
+// dist/cli/ each release, so the source README is not picked up
+// automatically.
+const readmeFrom = join(cliDir, "README.md");
+if (existsSync(readmeFrom)) {
+	await $`cp ${readmeFrom} ${join(mainPkgDir, "README.md")}`;
+} else {
+	console.error(
+		`Missing ${readmeFrom}. The CLI README must exist before publishing.`,
+	);
+	process.exit(1);
+}
+
+const mainPkg: unknown = JSON.parse(
+	readFileSync(join(cliDir, "package.json"), "utf-8"),
+);
+const mainPkgRecord = isRecord(mainPkg) ? mainPkg : {};
+const description =
+	"description" in mainPkgRecord &&
+	typeof mainPkgRecord.description === "string"
+		? mainPkgRecord.description
+		: undefined;
+const license =
+	"license" in mainPkgRecord && typeof mainPkgRecord.license === "string"
+		? mainPkgRecord.license
+		: undefined;
+const keywords =
+	"keywords" in mainPkgRecord && isStringArray(mainPkgRecord.keywords)
+		? mainPkgRecord.keywords
+		: undefined;
+const author = "author" in mainPkgRecord ? mainPkgRecord.author : undefined;
+const homepage =
+	"homepage" in mainPkgRecord && typeof mainPkgRecord.homepage === "string"
+		? mainPkgRecord.homepage
+		: undefined;
+const bugs = "bugs" in mainPkgRecord ? mainPkgRecord.bugs : undefined;
+const wrapperPackageJson = {
+	name: wrapperPackageName,
+	version,
+	description: description || "Cline CLI",
+	license: license || "Apache-2.0",
+	...(keywords ? { keywords } : {}),
+	...(author ? { author } : {}),
+	...(homepage ? { homepage } : {}),
+	...(bugs ? { bugs } : {}),
+	...(sourceRepository ? { repository: sourceRepository } : {}),
+	bin: {
+		cline: "./bin/cline",
+	},
+	scripts: {
+		postinstall: "node ./postinstall.mjs || true",
+	},
+	dependencies: hostSdkDependencies,
+	optionalDependencies: binaries,
+};
+
+await Bun.write(
+	join(mainPkgDir, "package.json"),
+	`${JSON.stringify(wrapperPackageJson, null, 2)}\n`,
+);
+
+if (dryRun) {
+	console.log(
+		`  [dry-run] Would publish ${wrapperPackageName}@${version} with tag ${npmTag}`,
+	);
+	console.log("\nDry run complete. No packages were published.");
+} else {
+	await publishPackage({
+		name: wrapperPackageName,
+		version,
+		dir: mainPkgDir,
+		tag: npmTag,
+		dryRun: false,
+	});
+	console.log(
+		`\nPublished ${wrapperPackageName}@${version} with tag ${npmTag}`,
+	);
+
+	console.log("\nInstall with:");
+	console.log(`  npm install -g ${wrapperPackageName}`);
+}
diff --git a/apps/cli/skills-lock.json b/apps/cli/skills-lock.json
new file mode 100644
index 0000000..23e600f
--- /dev/null
+++ b/apps/cli/skills-lock.json
@@ -0,0 +1,10 @@
+{
+	"version": 1,
+	"skills": {
+		"opentui": {
+			"source": "msmps/opentui-skill",
+			"sourceType": "github",
+			"computedHash": "2915038bb3297e759f740f9e6bfa885ed80a4a7fe945825f5874b48db9ce0fd2"
+		}
+	}
+}
diff --git a/apps/cli/src/acp/acpAgent.ts b/apps/cli/src/acp/acpAgent.ts
new file mode 100644
index 0000000..e8a9fa7
--- /dev/null
+++ b/apps/cli/src/acp/acpAgent.ts
@@ -0,0 +1,662 @@
+import type {
+	Agent,
+	AgentSideConnection,
+	AuthenticateRequest,
+	AuthenticateResponse,
+	CancelNotification,
+	ContentBlock,
+	InitializeRequest,
+	InitializeResponse,
+	NewSessionRequest,
+	NewSessionResponse,
+	PromptRequest,
+	PromptResponse,
+	SessionConfigOption,
+	SetSessionConfigOptionRequest,
+	SetSessionConfigOptionResponse,
+	SetSessionModelRequest,
+	SetSessionModelResponse,
+	SetSessionModeRequest,
+	SetSessionModeResponse,
+	StopReason,
+} from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION, RequestError } from "@agentclientprotocol/sdk";
+import {
+	type AgentEvent,
+	type ClineCore,
+	Llms,
+	ProviderSettingsManager,
+	SessionSource,
+} from "@cline/core";
+import type { Message } from "@cline/shared";
+import { getPersistedProviderApiKey } from "../commands/auth";
+import { resolveSystemPrompt } from "../runtime/prompt";
+import { subscribeToAgentEvents } from "../runtime/session-events";
+import { createCliCore } from "../session/session";
+import { getCliBuildInfo } from "../utils/common";
+import { randomSessionId, resolveWorkspaceRoot } from "../utils/helpers";
+import type { Config } from "../utils/types";
+import {
+	ACP_AUTH_METHODS,
+	type AcpAuthMethodId,
+	type AcpAuthResult,
+	authenticateAcpProvider,
+	isAcpAuthMethodId,
+} from "./auth";
+import { requestAcpToolApproval } from "./permissions";
+import {
+	forwardAgentEvent,
+	sendConfigOptionUpdate,
+	sendCurrentModeUpdate,
+	sendSessionInfoUpdate,
+} from "./session-updates";
+
+interface SessionState {
+	id: string;
+	cwd: string;
+	mcpServers: NewSessionRequest["mcpServers"];
+	/** Current agent mode — "plan" (read-only) or "act" (full). */
+	currentMode: "plan" | "act";
+	/** Current provider id for the session. */
+	currentProviderId: string;
+	/** Current model id for the session. */
+	currentModelId: string;
+	/** Active session manager for the running agent, if any. */
+	sessionManager?: ClineCore;
+	/** Internal session id within the session manager. */
+	activeSessionId?: string;
+	/** Abort controller for the current prompt, if running. */
+	abortController?: AbortController;
+	/** Unsubscribe function for the agent event listener. */
+	unsubscribe?: () => void;
+	/** Messages to inject into the next session manager for conversation continuity. */
+	pendingInitialMessages?: Message[];
+}
+
+export class AcpAgent implements Agent {
+	private sessions = new Map<string, SessionState>();
+	private readonly conn: AgentSideConnection;
+	private readonly providerSettingsManager = new ProviderSettingsManager();
+
+	/** Set after a successful `authenticate` call. */
+	private authResult?: AcpAuthResult;
+
+	constructor(conn: AgentSideConnection) {
+		this.conn = conn;
+	}
+
+	async initialize(_params: InitializeRequest): Promise<InitializeResponse> {
+		const { version, name } = getCliBuildInfo();
+
+		return {
+			protocolVersion: PROTOCOL_VERSION,
+			agentCapabilities: {
+				loadSession: true,
+				promptCapabilities: {
+					image: true,
+					audio: false,
+					embeddedContext: false,
+				},
+			},
+			agentInfo: {
+				name,
+				version,
+			},
+			authMethods: ACP_AUTH_METHODS.map((m) => ({
+				id: m.id,
+				name: m.name,
+			})),
+		};
+	}
+
+	async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
+		// Require authentication unless an API key is provided via env var.
+		if (!this.authResult && !process.env.CLINE_API_KEY) {
+			// Check for valid persisted credentials from a previous session
+			// before forcing the client to re-authenticate.
+			this.authResult = this.tryRestoreAuth();
+
+			if (!this.authResult) {
+				throw RequestError.authRequired(
+					undefined,
+					"Call authenticate before creating a session",
+				);
+			}
+		}
+
+		const sessionId = randomSessionId();
+
+		const defaultMode = "act";
+		const providerId =
+			process.env.CLINE_PROVIDER ?? this.authResult?.providerId ?? "cline";
+		const defaultModelId =
+			process.env.CLINE_MODEL ?? "anthropic/claude-sonnet-4.6";
+
+		this.sessions.set(sessionId, {
+			id: sessionId,
+			cwd: params.cwd,
+			mcpServers: params.mcpServers,
+			currentMode: defaultMode,
+			currentProviderId: providerId,
+			currentModelId: defaultModelId,
+		});
+
+		const providerModels = await Llms.getModelsForProvider(providerId);
+		const availableModels = Object.entries(providerModels).map(
+			([modelId, info]) => ({
+				modelId,
+				name: info.name ?? modelId,
+				description: info.description,
+			}),
+		);
+
+		return {
+			sessionId,
+			modes: {
+				availableModes: [
+					{
+						id: "plan",
+						name: "Plan",
+						description:
+							"Explore the codebase and plan changes without modifying files",
+					},
+					{
+						id: "act",
+						name: "Act",
+						description: "Make changes to the codebase",
+					},
+				],
+				currentModeId: defaultMode,
+			},
+			models: {
+				availableModels,
+				currentModelId: defaultModelId,
+			},
+			configOptions: [
+				await buildProviderConfigOption(providerId),
+				buildModelConfigOption(defaultModelId, providerModels),
+				buildModeConfigOption(defaultMode),
+			],
+		};
+	}
+
+	async prompt(params: PromptRequest): Promise<PromptResponse> {
+		const session = this.sessions.get(params.sessionId);
+		if (!session) {
+			throw new Error(`unknown session: ${params.sessionId}`);
+		}
+
+		const promptText = extractTextFromContentBlocks(params.prompt);
+		if (!promptText) {
+			return { stopReason: "end_turn" };
+		}
+
+		const abortController = new AbortController();
+		session.abortController = abortController;
+
+		// If cancel() was already called before prompt() started, bail early.
+		if (abortController.signal.aborted) {
+			session.abortController = undefined;
+			return { stopReason: "cancelled" };
+		}
+
+		await this.ensureSessionManager(session, params.sessionId);
+
+		// Re-check after async initialization.
+		if (abortController.signal.aborted) {
+			session.abortController = undefined;
+			return { stopReason: "cancelled" };
+		}
+
+		let stopReason: StopReason = "end_turn";
+		try {
+			const onAbort = () => {
+				if (session.activeSessionId && session.sessionManager) {
+					session.sessionManager
+						.abort(session.activeSessionId, abortController.signal.reason)
+						.catch(() => {});
+				}
+			};
+			abortController.signal.addEventListener("abort", onAbort, {
+				once: true,
+			});
+
+			const activeSessionId = session.activeSessionId;
+			const sessionManager = session.sessionManager;
+			if (!activeSessionId || !sessionManager) {
+				throw new Error("Session manager was not initialized");
+			}
+			const result = await sessionManager.send({
+				sessionId: activeSessionId,
+				prompt: promptText,
+			});
+
+			if (result) {
+				stopReason = mapFinishReason(result.finishReason);
+			}
+		} finally {
+			session.abortController = undefined;
+		}
+
+		sendSessionInfoUpdate(this.conn, params.sessionId, {
+			updatedAt: new Date().toISOString(),
+		});
+
+		return { stopReason };
+	}
+
+	async cancel(params: CancelNotification): Promise<void> {
+		const session = this.sessions.get(params.sessionId);
+		if (!session) {
+			return;
+		}
+
+		// Abort the controller — this handles all stages of prompt():
+		// - If prompt() hasn't started the agent yet, the signal check will
+		//   short-circuit and resolve with stopReason: 'cancelled'.
+		// - If the agent is running, the "abort" event listener on the signal
+		//   will call sessionManager.abort() to stop it.
+		if (session.abortController) {
+			session.abortController.abort();
+		}
+	}
+
+	async setSessionMode(
+		params: SetSessionModeRequest,
+	): Promise<SetSessionModeResponse> {
+		if (params.modeId !== "plan" && params.modeId !== "act") {
+			throw new Error(
+				`invalid modeId: ${params.modeId} (must be "plan" or "act")`,
+			);
+		}
+		const session = this.sessions.get(params.sessionId);
+		if (!session) {
+			throw new Error(`unknown session: ${params.sessionId}`);
+		}
+		session.currentMode = params.modeId;
+		sendCurrentModeUpdate(this.conn, params.sessionId, params.modeId);
+		return {};
+	}
+
+	async unstable_setSessionModel(
+		params: SetSessionModelRequest,
+	): Promise<SetSessionModelResponse> {
+		const session = this.sessions.get(params.sessionId);
+		if (!session) {
+			throw new Error(`unknown session: ${params.sessionId}`);
+		}
+		session.currentModelId = params.modelId;
+		if (session.sessionManager && session.activeSessionId) {
+			await session.sessionManager.updateSessionModel?.(
+				session.activeSessionId,
+				params.modelId,
+			);
+		}
+		return {};
+	}
+
+	async setSessionConfigOption(
+		params: SetSessionConfigOptionRequest,
+	): Promise<SetSessionConfigOptionResponse> {
+		const session = this.sessions.get(params.sessionId);
+		if (!session) {
+			throw new Error(`unknown session: ${params.sessionId}`);
+		}
+
+		const value = params.value as string;
+
+		switch (params.configId) {
+			case "provider": {
+				if (process.env.CLINE_PROVIDER) {
+					throw RequestError.invalidParams(
+						undefined,
+						"Cannot change provider: CLINE_PROVIDER environment variable is set",
+					);
+				}
+				if (!isAcpAuthMethodId(value)) {
+					throw RequestError.invalidParams(
+						undefined,
+						`Unknown provider: ${value}`,
+					);
+				}
+
+				session.currentProviderId = value;
+
+				// Tear down the old session manager so ensureSessionManager()
+				// creates a fresh one with the new provider on the next prompt().
+				await this.teardownSessionManager(session);
+
+				// If current model doesn't exist in new provider, reset to first available
+				const providerModels = await Llms.getModelsForProvider(value);
+				const modelIds = Object.keys(providerModels);
+				const fallbackModelId = modelIds[0];
+				if (
+					!modelIds.includes(session.currentModelId) &&
+					fallbackModelId !== undefined
+				) {
+					session.currentModelId = fallbackModelId;
+				}
+				break;
+			}
+
+			case "model": {
+				session.currentModelId = value;
+				if (session.sessionManager && session.activeSessionId) {
+					await session.sessionManager.updateSessionModel?.(
+						session.activeSessionId,
+						value,
+					);
+				}
+				break;
+			}
+
+			case "mode": {
+				if (value !== "plan" && value !== "act") {
+					throw RequestError.invalidParams(
+						undefined,
+						`Invalid mode: ${value} (must be "plan" or "act")`,
+					);
+				}
+				session.currentMode = value;
+				sendCurrentModeUpdate(this.conn, params.sessionId, value);
+				break;
+			}
+
+			default:
+				throw RequestError.invalidParams(
+					undefined,
+					`Unknown config option: ${params.configId}`,
+				);
+		}
+
+		const configOptions = await buildAllConfigOptions(session);
+		sendConfigOptionUpdate(this.conn, params.sessionId, configOptions);
+		return { configOptions };
+	}
+
+	async authenticate(
+		params: AuthenticateRequest,
+	): Promise<AuthenticateResponse | undefined> {
+		if (!isAcpAuthMethodId(params.methodId)) {
+			throw RequestError.invalidParams(
+				undefined,
+				`Unsupported auth method: ${params.methodId}`,
+			);
+		}
+
+		this.authResult = await authenticateAcpProvider(
+			params.methodId,
+			this.providerSettingsManager,
+		);
+
+		return {};
+	}
+
+	async shutdown(): Promise<void> {
+		for (const session of this.sessions.values()) {
+			if (session.abortController) {
+				session.abortController.abort();
+			}
+			if (session.unsubscribe) {
+				session.unsubscribe();
+			}
+			if (session.sessionManager && session.activeSessionId) {
+				await session.sessionManager
+					.abort(session.activeSessionId)
+					.catch(() => {});
+				await session.sessionManager.dispose("acp_shutdown").catch(() => {});
+			}
+		}
+		this.sessions.clear();
+	}
+
+	/**
+	 * Attempt to restore authentication from persisted provider settings.
+	 *
+	 * When a previous session already completed an OAuth login the credentials
+	 * are saved to disk via `ProviderSettingsManager`.  On a fresh ACP
+	 * connection we check each known auth method for a persisted API key so
+	 * the client doesn't have to re-authenticate every time.
+	 */
+	private tryRestoreAuth(): AcpAuthResult | undefined {
+		for (const method of ACP_AUTH_METHODS) {
+			const settings = this.providerSettingsManager.getProviderSettings(
+				method.id,
+			);
+			const apiKey = getPersistedProviderApiKey(method.id, settings);
+			if (apiKey) {
+				return { providerId: method.id as AcpAuthMethodId, apiKey };
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * Tear down the current session manager, preserving conversation messages
+	 * so they can be replayed into a new session manager.
+	 */
+	private async teardownSessionManager(session: SessionState): Promise<void> {
+		if (!session.sessionManager) {
+			return;
+		}
+
+		// Save conversation history before teardown.
+		if (session.activeSessionId) {
+			session.pendingInitialMessages =
+				await session.sessionManager.readMessages(session.activeSessionId);
+		}
+
+		if (session.abortController) {
+			session.abortController.abort();
+		}
+		if (session.unsubscribe) {
+			session.unsubscribe();
+			session.unsubscribe = undefined;
+		}
+		if (session.activeSessionId) {
+			await session.sessionManager
+				.abort(session.activeSessionId)
+				.catch(() => {});
+		}
+		await session.sessionManager.dispose("provider_change").catch(() => {});
+		session.sessionManager = undefined;
+		session.activeSessionId = undefined;
+	}
+
+	/**
+	 * Lazily create and start the session manager for this ACP session.
+	 * After the first call the manager persists across prompt() calls so that
+	 * conversation history is maintained.
+	 */
+	private async ensureSessionManager(
+		session: SessionState,
+		acpSessionId: string,
+	): Promise<void> {
+		if (session.sessionManager) {
+			return;
+		}
+
+		const config = await this.buildConfig(session);
+
+		const sessionManager = await createCliCore({
+			toolPolicies: config.toolPolicies,
+			capabilities: {
+				requestToolApproval: (request) =>
+					requestAcpToolApproval(this.conn, acpSessionId, request),
+			},
+			cwd: config.cwd,
+			workspaceRoot: config.workspaceRoot,
+		});
+
+		session.unsubscribe = subscribeToAgentEvents(
+			sessionManager,
+			(event: AgentEvent) => {
+				forwardAgentEvent(this.conn, acpSessionId, event);
+			},
+		);
+
+		const initialMessages = session.pendingInitialMessages;
+		session.pendingInitialMessages = undefined;
+
+		const started = await sessionManager.start({
+			source: SessionSource.CLI,
+			config,
+			interactive: true,
+			initialMessages,
+		});
+
+		session.sessionManager = sessionManager;
+		session.activeSessionId = started.sessionId;
+	}
+
+	private async buildConfig(session: SessionState): Promise<Config> {
+		const cwd = session.cwd || process.cwd();
+		const workspaceRoot = resolveWorkspaceRoot(cwd);
+		// Resolve credentials: env vars take precedence, then session provider.
+		const providerId = process.env.CLINE_PROVIDER ?? session.currentProviderId;
+		const apiKey = process.env.CLINE_API_KEY ?? this.authResult?.apiKey ?? "";
+		const systemPrompt = await resolveSystemPrompt({
+			cwd,
+			providerId,
+			mode: session.currentMode,
+		});
+		const cliBuildInfo = getCliBuildInfo();
+
+		return {
+			providerId,
+			modelId: session.currentModelId,
+			apiKey,
+			systemPrompt,
+			execution: undefined,
+			verbose: false,
+			sandbox: false,
+			thinking: false,
+			outputMode: "text",
+			mode: session.currentMode,
+			defaultToolAutoApprove: false,
+			toolPolicies: { "*": { autoApprove: false } },
+			enableSpawnAgent: true,
+			enableAgentTeams: false,
+			enableTools: true,
+			cwd,
+			workspaceRoot,
+			extensionContext: {
+				client: {
+					name: "cline-acp",
+					version: cliBuildInfo.version,
+					platform: "cli",
+					platformVersion: cliBuildInfo.version,
+					isMultiRoot: false,
+				},
+				workspace: {
+					rootPath: workspaceRoot,
+					cwd,
+					workspaceName: cwd,
+					ide: "Terminal Shell",
+					platform: process.platform,
+				},
+			},
+		};
+	}
+}
+
+async function buildProviderConfigOption(
+	currentProviderId: string,
+): Promise<SessionConfigOption> {
+	const options = await Promise.all(
+		ACP_AUTH_METHODS.map(async (m) => {
+			const provider = await Llms.getProvider(m.id);
+			return {
+				value: m.id,
+				name: provider?.name ?? m.id,
+			};
+		}),
+	);
+	return {
+		type: "select",
+		id: "provider",
+		name: "Provider",
+		description: "The authentication provider to use",
+		category: "model",
+		currentValue: currentProviderId,
+		options,
+	};
+}
+
+function buildModelConfigOption(
+	currentModelId: string,
+	providerModels: Record<string, { name?: string; description?: string }>,
+): SessionConfigOption {
+	return {
+		type: "select",
+		id: "model",
+		name: "Model",
+		category: "model",
+		currentValue: currentModelId,
+		options: Object.entries(providerModels).map(([modelId, info]) => ({
+			value: modelId,
+			name: info.name ?? modelId,
+			description: info.description,
+		})),
+	};
+}
+
+function buildModeConfigOption(currentMode: string): SessionConfigOption {
+	return {
+		type: "select",
+		id: "mode",
+		name: "Session Mode",
+		description: "Controls whether the agent can modify files",
+		category: "mode",
+		currentValue: currentMode,
+		options: [
+			{
+				value: "plan",
+				name: "Plan",
+				description:
+					"Explore the codebase and plan changes without modifying files",
+			},
+			{
+				value: "act",
+				name: "Act",
+				description: "Make changes to the codebase",
+			},
+		],
+	};
+}
+
+async function buildAllConfigOptions(
+	session: SessionState,
+): Promise<SessionConfigOption[]> {
+	const [providerOption, providerModels] = await Promise.all([
+		buildProviderConfigOption(session.currentProviderId),
+		Llms.getModelsForProvider(session.currentProviderId),
+	]);
+	return [
+		providerOption,
+		buildModelConfigOption(session.currentModelId, providerModels),
+		buildModeConfigOption(session.currentMode),
+	];
+}
+
+function extractTextFromContentBlocks(blocks: ContentBlock[]): string {
+	return blocks
+		.filter((b): b is ContentBlock & { type: "text" } => b.type === "text")
+		.map((b) => b.text)
+		.join("\n");
+}
+
+function mapFinishReason(reason: string): StopReason {
+	switch (reason) {
+		case "completed":
+			return "end_turn";
+		case "aborted":
+			return "cancelled";
+		case "max_iterations":
+			return "max_turn_requests";
+		case "mistake_limit":
+			return "end_turn";
+		default:
+			return "end_turn";
+	}
+}
diff --git a/apps/cli/src/acp/auth.ts b/apps/cli/src/acp/auth.ts
new file mode 100644
index 0000000..0790828
--- /dev/null
+++ b/apps/cli/src/acp/auth.ts
@@ -0,0 +1,102 @@
+import type { ProviderSettingsManager } from "@cline/core";
+import { loginAndSaveProviderOAuthCredentials } from "@cline/core";
+import { getPersistedProviderApiKey } from "../commands/auth";
+import { writeDiagnostic } from "../utils/output";
+
+/**
+ * Supported ACP OAuth provider IDs.
+ */
+export const ACP_AUTH_METHODS = [
+	{ id: "cline", name: "Sign in with Cline" },
+	{ id: "openai-codex", name: "Sign in with ChatGPT Subscription" },
+] as const;
+
+export type AcpAuthMethodId = (typeof ACP_AUTH_METHODS)[number]["id"];
+
+export function isAcpAuthMethodId(id: string): id is AcpAuthMethodId {
+	return ACP_AUTH_METHODS.some((m) => m.id === id);
+}
+
+/**
+ * Perform an OAuth login for the given provider in ACP mode.
+ *
+ * Since stdin/stdout are used for the JSON-RPC transport, all user-facing
+ * output is written to stderr and URLs are opened via the `open` package.
+ * If the OAuth flow requires interactive prompts (rare), defaults are used
+ * when available; otherwise an error is thrown.
+ */
+async function performOAuthLogin(input: {
+	providerId: AcpAuthMethodId;
+	providerSettingsManager: ProviderSettingsManager;
+}): Promise<string> {
+	const [{ createOAuthClientCallbacks }, { default: open }] = await Promise.all(
+		[import("@cline/core"), import("open")],
+	);
+
+	const callbacks = createOAuthClientCallbacks({
+		onPrompt: ({ defaultValue }) => {
+			if (defaultValue) {
+				return Promise.resolve(defaultValue);
+			}
+			return Promise.reject(
+				new Error(
+					"OAuth flow requires interactive input which is unavailable in ACP mode",
+				),
+			);
+		},
+		onOutput: (message) => writeDiagnostic(`[acp/auth] ${message}`),
+		openUrl: (url) => open(url, { wait: false }).then(() => undefined),
+		onOpenUrlError: ({ url }) => {
+			writeDiagnostic(
+				`[acp/auth] Could not open browser automatically. Open this URL manually:\n${url}`,
+			);
+		},
+	});
+
+	const settings = await loginAndSaveProviderOAuthCredentials(
+		input.providerSettingsManager,
+		input.providerId,
+		{ callbacks },
+	);
+	const apiKey = getPersistedProviderApiKey(input.providerId, settings);
+	if (!apiKey) {
+		throw new Error(
+			`OAuth login did not persist credentials for ${input.providerId}`,
+		);
+	}
+	return apiKey;
+}
+
+export interface AcpAuthResult {
+	providerId: AcpAuthMethodId;
+	apiKey: string;
+}
+
+/**
+ * Authenticate via OAuth for the given ACP auth method.
+ *
+ * Uses `ProviderSettingsManager` to check for existing credentials first,
+ * falling back to a fresh OAuth login if needed.
+ */
+export async function authenticateAcpProvider(
+	methodId: AcpAuthMethodId,
+	providerSettingsManager: ProviderSettingsManager,
+): Promise<AcpAuthResult> {
+	const existing = providerSettingsManager.getProviderSettings(methodId);
+
+	// Check for already-stored credentials.
+	const existingKey = getPersistedProviderApiKey(methodId, existing);
+	if (existingKey) {
+		writeDiagnostic(`[acp/auth] Using existing credentials for ${methodId}`);
+		return { providerId: methodId, apiKey: existingKey };
+	}
+
+	// Perform a fresh OAuth login.
+	writeDiagnostic(`[acp/auth] Starting OAuth login for ${methodId}…`);
+	const apiKey = await performOAuthLogin({
+		providerId: methodId,
+		providerSettingsManager,
+	});
+	writeDiagnostic(`[acp/auth] Successfully authenticated with ${methodId}`);
+	return { providerId: methodId, apiKey };
+}
diff --git a/apps/cli/src/acp/index.test.ts b/apps/cli/src/acp/index.test.ts
new file mode 100644
index 0000000..77e7818
--- /dev/null
+++ b/apps/cli/src/acp/index.test.ts
@@ -0,0 +1,36 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+describe("runAcpMode", () => {
+	afterEach(() => {
+		vi.doUnmock("@agentclientprotocol/sdk");
+		vi.doUnmock("./acpAgent");
+		vi.restoreAllMocks();
+	});
+
+	it("writes the startup diagnostic without labeling it as an error", async () => {
+		const stderrWrite = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+
+		vi.doMock("@agentclientprotocol/sdk", () => ({
+			ndJsonStream: vi.fn(() => ({})),
+			AgentSideConnection: class {
+				closed = Promise.resolve();
+			},
+		}));
+		vi.doMock("./acpAgent", () => ({
+			AcpAgent: class {},
+		}));
+
+		const { runAcpMode } = await import("./index");
+
+		await runAcpMode();
+
+		expect(stderrWrite).toHaveBeenCalledWith(
+			"[acp] starting ACP mode over stdio…\n",
+		);
+		expect(stderrWrite).not.toHaveBeenCalledWith(
+			expect.stringContaining("error:"),
+		);
+	});
+});
diff --git a/apps/cli/src/acp/index.ts b/apps/cli/src/acp/index.ts
new file mode 100644
index 0000000..b5b6a0e
--- /dev/null
+++ b/apps/cli/src/acp/index.ts
@@ -0,0 +1,23 @@
+import { Readable, Writable } from "node:stream";
+import { writeDiagnostic } from "../utils/output";
+
+export async function runAcpMode(): Promise<void> {
+	const { AgentSideConnection, ndJsonStream } = await import(
+		"@agentclientprotocol/sdk"
+	);
+	const { AcpAgent } = await import("./acpAgent");
+
+	writeDiagnostic("[acp] starting ACP mode over stdio…");
+
+	const stream = ndJsonStream(
+		Writable.toWeb(process.stdout) as WritableStream<Uint8Array>,
+		Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>,
+	);
+
+	const connection = new AgentSideConnection((conn) => {
+		return new AcpAgent(conn);
+	}, stream);
+
+	// Keep the process alive until the connection closes
+	await connection.closed;
+}
diff --git a/apps/cli/src/acp/permissions.ts b/apps/cli/src/acp/permissions.ts
new file mode 100644
index 0000000..b1e109a
--- /dev/null
+++ b/apps/cli/src/acp/permissions.ts
@@ -0,0 +1,133 @@
+import type {
+	AgentSideConnection,
+	PermissionOption,
+	PermissionOptionKind,
+	RequestPermissionRequest,
+	ToolCallUpdate,
+} from "@agentclientprotocol/sdk";
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import { buildToolTitle, mapToolKind } from "./tool-utils";
+
+// ---------------------------------------------------------------------------
+// Standard permission options presented to the user
+// ---------------------------------------------------------------------------
+
+const PERMISSION_OPTIONS: PermissionOption[] = [
+	{
+		optionId: "allow_once",
+		name: "Allow once",
+		kind: "allow_once" as PermissionOptionKind,
+	},
+	{
+		optionId: "allow_always",
+		name: "Allow always",
+		kind: "allow_always" as PermissionOptionKind,
+	},
+	{
+		optionId: "reject_once",
+		name: "Reject",
+		kind: "reject_once" as PermissionOptionKind,
+	},
+];
+
+// ---------------------------------------------------------------------------
+// Translate a CLI tool approval request into an ACP permission request
+// ---------------------------------------------------------------------------
+
+export function translateToolToPermissionRequest(
+	request: ToolApprovalRequest,
+	sessionId: string,
+): RequestPermissionRequest {
+	const toolCall: ToolCallUpdate = {
+		toolCallId: request.toolCallId,
+		title: buildToolTitle(request.toolName, request.input),
+		kind: mapToolKind(request.toolName),
+		status: "pending",
+		rawInput: request.input,
+	};
+
+	return {
+		sessionId,
+		toolCall,
+		options: PERMISSION_OPTIONS,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Interpret the ACP permission response
+// ---------------------------------------------------------------------------
+
+export function handlePermissionResponse(
+	outcome:
+		| {
+				outcome: "cancelled";
+		  }
+		| {
+				outcome: "selected";
+				optionId: string;
+		  },
+): ToolApprovalResult {
+	if (outcome.outcome === "cancelled") {
+		return { approved: false, reason: "Permission request was cancelled" };
+	}
+
+	const optionId = outcome.optionId;
+	switch (optionId) {
+		case "allow_once":
+		case "allow_always":
+			return { approved: true };
+		case "reject_once":
+		case "reject_always":
+			return { approved: false, reason: "User rejected the tool call" };
+		default:
+			return {
+				approved: false,
+				reason: `Unknown permission option: ${optionId}`,
+			};
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Combined: request permission from the ACP client and return CLI result
+// ---------------------------------------------------------------------------
+
+export async function requestAcpToolApproval(
+	conn: AgentSideConnection,
+	sessionId: string,
+	request: ToolApprovalRequest,
+): Promise<ToolApprovalResult> {
+	const permissionRequest = translateToolToPermissionRequest(
+		request,
+		sessionId,
+	);
+
+	// Emit a tool_call update with "pending" status before requesting permission
+	void conn.sessionUpdate({
+		sessionId,
+		update: {
+			...permissionRequest.toolCall,
+			sessionUpdate: "tool_call_update",
+		},
+	});
+
+	let response: Awaited<ReturnType<AgentSideConnection["requestPermission"]>>;
+	try {
+		response = await conn.requestPermission(permissionRequest);
+	} catch {
+		return { approved: false, reason: "Permission request failed" };
+	}
+
+	const result = handlePermissionResponse(response.outcome);
+
+	// Emit a tool_call_update reflecting the decision
+	void conn.sessionUpdate({
+		sessionId,
+		update: {
+			sessionUpdate: "tool_call_update",
+			toolCallId: request.toolCallId,
+			status: result.approved ? "in_progress" : "failed",
+		},
+	});
+
+	return result;
+}
diff --git a/apps/cli/src/acp/session-updates.ts b/apps/cli/src/acp/session-updates.ts
new file mode 100644
index 0000000..fac5a41
--- /dev/null
+++ b/apps/cli/src/acp/session-updates.ts
@@ -0,0 +1,163 @@
+import type {
+	AgentSideConnection,
+	SessionConfigOption,
+	SessionUpdate,
+} from "@agentclientprotocol/sdk";
+import type { AgentEvent } from "@cline/core";
+import { buildToolTitle, mapToolKind } from "./tool-utils";
+
+/**
+ * Maps an AgentEvent to zero or more ACP SessionUpdate notifications,
+ * sending each via the connection's sessionUpdate method.
+ */
+export function forwardAgentEvent(
+	conn: AgentSideConnection,
+	sessionId: string,
+	event: AgentEvent,
+): void {
+	const updates = translateEvent(event);
+	for (const update of updates) {
+		void conn.sessionUpdate({ sessionId, update });
+	}
+}
+
+function translateEvent(event: AgentEvent): SessionUpdate[] {
+	switch (event.type) {
+		case "content_start":
+			return translateContentStart(event);
+		case "content_end":
+			return translateContentEnd(event);
+		case "done":
+			return [];
+		case "error":
+			return [];
+		case "iteration_start":
+		case "iteration_end":
+		case "usage":
+			return [];
+		default:
+			return [];
+	}
+}
+
+function translateContentStart(
+	event: AgentEvent & { type: "content_start" },
+): SessionUpdate[] {
+	switch (event.contentType) {
+		case "text": {
+			if (!event.text) return [];
+			return [
+				{
+					sessionUpdate: "agent_message_chunk",
+					content: { type: "text", text: event.text },
+				},
+			];
+		}
+		case "reasoning": {
+			if (!event.reasoning) return [];
+			return [
+				{
+					sessionUpdate: "agent_thought_chunk",
+					content: { type: "text", text: event.reasoning },
+				},
+			];
+		}
+		case "tool": {
+			const toolCallId = event.toolCallId ?? "unknown";
+			const toolName = event.toolName ?? "unknown";
+			return [
+				{
+					sessionUpdate: "tool_call",
+					toolCallId,
+					title: buildToolTitle(toolName, event.input),
+					kind: mapToolKind(toolName),
+					status: "pending",
+					rawInput: event.input,
+				},
+			];
+		}
+		default:
+			return [];
+	}
+}
+
+function translateContentEnd(
+	event: AgentEvent & { type: "content_end" },
+): SessionUpdate[] {
+	const e = event as {
+		type: "content_end";
+		contentType: string;
+		text?: string;
+		reasoning?: string;
+		toolName?: string;
+		toolCallId?: string;
+		output?: unknown;
+		error?: string;
+		durationMs?: number;
+	};
+
+	switch (e.contentType) {
+		case "text":
+			// Text was already streamed via content_start chunks; don't re-send.
+			return [];
+		case "reasoning":
+			// Reasoning was already streamed via content_start chunks; don't re-send.
+			return [];
+		case "tool": {
+			const toolCallId = e.toolCallId ?? "unknown";
+			const failed = !!e.error;
+			return [
+				{
+					sessionUpdate: "tool_call_update",
+					toolCallId,
+					status: failed ? "failed" : "completed",
+					rawOutput: e.error ?? e.output,
+				},
+			];
+		}
+		default:
+			return [];
+	}
+}
+
+/**
+ * Send a current_mode_update notification to the client.
+ */
+export function sendCurrentModeUpdate(
+	conn: AgentSideConnection,
+	sessionId: string,
+	modeId: string,
+): void {
+	void conn.sessionUpdate({
+		sessionId,
+		update: { sessionUpdate: "current_mode_update", currentModeId: modeId },
+	});
+}
+
+/**
+ * Send a config_option_update notification to the client.
+ */
+export function sendConfigOptionUpdate(
+	conn: AgentSideConnection,
+	sessionId: string,
+	configOptions: Array<SessionConfigOption>,
+): void {
+	void conn.sessionUpdate({
+		sessionId,
+		update: { sessionUpdate: "config_option_update", configOptions },
+	});
+}
+
+/**
+ * Send a session_info_update notification to the client.
+ */
+export function sendSessionInfoUpdate(
+	conn: AgentSideConnection,
+	sessionId: string,
+	info: { title?: string | null; updatedAt?: string | null },
+): void {
+	void conn.sessionUpdate({
+		sessionId,
+		update: { sessionUpdate: "session_info_update", ...info },
+	});
+}
diff --git a/apps/cli/src/acp/tool-utils.ts b/apps/cli/src/acp/tool-utils.ts
new file mode 100644
index 0000000..fc1c7ee
--- /dev/null
+++ b/apps/cli/src/acp/tool-utils.ts
@@ -0,0 +1,41 @@
+import type { ToolKind } from "@agentclientprotocol/sdk";
+import { formatToolInput } from "../utils/helpers";
+
+const TOOL_KIND_MAP: Record<string, ToolKind> = {
+	Read: "read",
+	read_files: "read",
+	Glob: "search",
+	Grep: "search",
+	search_codebase: "search",
+	Edit: "edit",
+	Write: "edit",
+	editor: "edit",
+	Delete: "delete",
+	Move: "move",
+	Bash: "execute",
+	run_commands: "execute",
+	WebFetch: "fetch",
+	fetch_web_content: "fetch",
+	WebSearch: "search",
+	Agent: "think",
+	spawn_agent: "think",
+	NotebookEdit: "edit",
+	skills: "other",
+};
+
+export function mapToolKind(toolName: string): ToolKind {
+	return TOOL_KIND_MAP[toolName] ?? "other";
+}
+
+/**
+ * Build a human-readable title for a tool call so that IDE UIs show
+ * something more useful than just the raw tool name.
+ *
+ * Delegates to {@link formatToolInput} for the input summary and
+ * prefixes with the tool name when a summary is available.
+ */
+export function buildToolTitle(toolName: string, input: unknown): string {
+	const summary = formatToolInput(toolName, input);
+	if (!summary) return toolName;
+	return `${toolName}: ${summary}`;
+}
diff --git a/apps/cli/src/cli.e2e.test.ts b/apps/cli/src/cli.e2e.test.ts
new file mode 100644
index 0000000..e340168
--- /dev/null
+++ b/apps/cli/src/cli.e2e.test.ts
@@ -0,0 +1,935 @@
+import { spawnSync } from "node:child_process";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+const cliRoot = path.resolve(__dirname, "..");
+const cliEntry = path.join(cliRoot, "src", "index.ts");
+const cliPackage = JSON.parse(
+	readFileSync(path.join(cliRoot, "package.json"), "utf8"),
+) as { version: string };
+const bunExec = process.env.BUN_EXEC_PATH ?? "bun";
+
+type CliResult = ReturnType<typeof spawnSync>;
+
+function asText(value: string | Buffer): string {
+	return typeof value === "string" ? value : value.toString("utf8");
+}
+
+function parseJsonArrayFromOutput(output: string): unknown[] {
+	const trimmed = output.trim();
+	if (trimmed.length > 0) {
+		try {
+			const parsed = JSON.parse(trimmed) as unknown;
+			if (Array.isArray(parsed)) {
+				return parsed;
+			}
+		} catch {
+			// Fall through.
+		}
+	}
+
+	const lines = output
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+	for (let index = lines.length - 1; index >= 0; index -= 1) {
+		try {
+			const parsed = JSON.parse(lines[index] ?? "") as unknown;
+			if (Array.isArray(parsed)) {
+				return parsed;
+			}
+		} catch {
+			// Ignore non-JSON lines.
+		}
+	}
+
+	const start = output.indexOf("[");
+	const end = output.lastIndexOf("]");
+	if (start >= 0 && end > start) {
+		const parsed = JSON.parse(output.slice(start, end + 1)) as unknown;
+		if (Array.isArray(parsed)) {
+			return parsed;
+		}
+	}
+
+	throw new Error("expected a JSON array in CLI output");
+}
+
+function runCli(
+	args: string[],
+	options?: {
+		cwd?: string;
+		env?: NodeJS.ProcessEnv;
+		stdin?: string;
+		timeout?: number;
+	},
+): CliResult {
+	return spawnSync(bunExec, [cliEntry, ...args], {
+		cwd: options?.cwd ?? cliRoot,
+		encoding: "utf8",
+		input: options?.stdin,
+		env: options?.env,
+		timeout: options?.timeout ?? 90_000,
+		maxBuffer: 10 * 1024 * 1024,
+	});
+}
+
+describe("cli e2e", () => {
+	const tempDirs: string[] = [];
+	const createIsolatedEnv = (
+		overrides: NodeJS.ProcessEnv = {},
+	): NodeJS.ProcessEnv => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));
+		const sessionDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-sessions-"));
+		const teamDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-teams-"));
+		tempDirs.push(homeDir, dataDir, sessionDir, teamDir);
+		return {
+			...process.env,
+			HOME: homeDir,
+			CLINE_DIR: path.join(homeDir, ".cline"),
+			CLINE_DATA_DIR: dataDir,
+			CLINE_DB_DATA_DIR: path.join(dataDir, "db"),
+			CLINE_SESSION_DATA_DIR: sessionDir,
+			CLINE_TEAM_DATA_DIR: teamDir,
+			CLINE_SESSION_BACKEND_MODE: "local",
+			CLINE_PROVIDER_SETTINGS_PATH: path.join(
+				dataDir,
+				"settings",
+				"providers.json",
+			),
+			CLINE_HOOKS_LOG_PATH: path.join(dataDir, "logs", "hooks.jsonl"),
+			...overrides,
+		};
+	};
+
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("prints help output", () => {
+		const result = runCli(["--help"], { env: createIsolatedEnv() });
+		expect(result.status).toBe(0);
+		expect(asText(result.stderr)).toBe("");
+		expect(asText(result.stdout)).toContain("Usage:");
+		expect(asText(result.stdout)).toContain("--auto-approve [value]");
+		expect(asText(result.stdout)).toContain("--data-dir");
+		expect(asText(result.stdout)).toContain("--thinking [level]");
+		expect(asText(result.stdout)).not.toContain("--reasoning-effort");
+		expect(asText(result.stdout)).not.toContain("--act");
+		expect(asText(result.stdout)).toContain("Show current configuration");
+	});
+
+	it("prints version output", () => {
+		const result = runCli(["--version"], { env: createIsolatedEnv() });
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout).trim()).toBe(cliPackage.version);
+	});
+
+	it("prints version output via version command", () => {
+		const result = runCli(["version"], { env: createIsolatedEnv() });
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout).trim()).toBe(cliPackage.version);
+	});
+
+	it("exits promptly on success path without hanging", () => {
+		const result = runCli(["version"], {
+			env: createIsolatedEnv(),
+			timeout: 10_000,
+		});
+		expect(result.signal).toBeNull();
+		expect(result.status).toBe(0);
+	});
+
+	it("exits promptly on error path without hanging", () => {
+		const result = runCli(["--timeout", "xml", "hello"], {
+			env: createIsolatedEnv(),
+			timeout: 10_000,
+		});
+		expect(result.signal).toBeNull();
+		expect(result.status).toBe(1);
+	});
+
+	it("propagates subcommand exit codes through process.exit", () => {
+		const result = runCli(["history", "--json"], {
+			env: createIsolatedEnv(),
+			timeout: 10_000,
+		});
+		expect(result.signal).toBeNull();
+		expect(result.status).toBe(0);
+	});
+
+	it("rejects invalid timeout values", () => {
+		const result = runCli(["--timeout", "xml", "hello"], {
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain("invalid timeout");
+	});
+
+	it("rejects json mode without prompt or piped input", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		tempDirs.push(homeDir);
+		const result = runCli(["--json"], {
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+			},
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain(
+			"JSON output mode requires a prompt argument or piped stdin",
+		);
+	});
+
+	it("rejects interactive mode with json output", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		tempDirs.push(homeDir);
+		const result = runCli(["--json", "--tui"], {
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+			},
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain(
+			"JSON output mode requires a prompt argument or piped stdin",
+		);
+	});
+
+	it("rejects zen mode without a prompt using a prompt-specific error", () => {
+		const result = runCli(["--zen"], {
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain("--zen requires a prompt.");
+		expect(asText(result.stderr)).not.toContain("interactive mode");
+	});
+
+	it("returns an error for unknown config targets", () => {
+		const result = runCli(["config", "unknown-target"], {
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain(
+			'config requires one of: workflows, rules, skills, agents, plugins, hooks, mcp, tools (got "unknown-target")',
+		);
+	});
+
+	it("returns an error for unknown hub subcommands", () => {
+		const result = runCli(["hub", "nonesuch"], { env: createIsolatedEnv() });
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain('unknown command "nonesuch"');
+	});
+
+	it("returns an error for interactive auth when no TTY is available", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));
+		tempDirs.push(homeDir, dataDir);
+		const result = runCli(["auth"], {
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DATA_DIR: dataDir,
+			},
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain(
+			"interactive auth setup requires a TTY",
+		);
+	});
+
+	it("lists sessions from isolated storage", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const sessionDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-sessions-"));
+		tempDirs.push(homeDir, sessionDir);
+		const result = runCli(["history", "--json", "--limit", "1"], {
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_SESSION_DATA_DIR: sessionDir,
+			},
+		});
+
+		expect(result.status).toBe(0);
+		const parsed = parseJsonArrayFromOutput(asText(result.stdout));
+		expect(Array.isArray(parsed)).toBe(true);
+	});
+
+	it("prints empty history state from isolated storage", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const sessionDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-sessions-"));
+		tempDirs.push(homeDir, sessionDir);
+		const result = runCli(["history", "--limit", "5"], {
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_SESSION_DATA_DIR: sessionDir,
+			},
+		});
+
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout)).toContain("No history found.");
+	});
+
+	it("returns an error when deleting a session without --session-id", () => {
+		const result = runCli(["history", "delete"], {
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain(
+			"history delete requires --session-id <id>",
+		);
+	});
+
+	it("lists enabled workflows in text mode", () => {
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workflows-"));
+		tempDirs.push(workspace);
+		const workflowsDir = path.join(workspace, ".clinerules", "workflows");
+		mkdirSync(workflowsDir, { recursive: true });
+		writeFileSync(
+			path.join(workflowsDir, "release.md"),
+			`---
+name: release
+---
+Release checklist.`,
+			"utf8",
+		);
+		writeFileSync(
+			path.join(workflowsDir, "disabled.md"),
+			`---
+name: disabled
+disabled: true
+---
+Do not list this.`,
+			"utf8",
+		);
+
+		const result = runCli(["config", "workflows"], {
+			cwd: workspace,
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout)).toContain("Available workflows:");
+		expect(asText(result.stdout)).toContain("/release");
+		expect(asText(result.stdout)).toContain(
+			path.join(workflowsDir, "release.md"),
+		);
+		expect(asText(result.stdout)).not.toContain("/disabled");
+	});
+
+	it("lists workflows from workspace root when run in a subdirectory", () => {
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workflows-"));
+		tempDirs.push(workspace);
+		const workflowsDir = path.join(workspace, ".clinerules", "workflows");
+		const nestedDir = path.join(workspace, "packages", "app");
+		mkdirSync(workflowsDir, { recursive: true });
+		mkdirSync(nestedDir, { recursive: true });
+		writeFileSync(
+			path.join(workflowsDir, "release.md"),
+			`---
+name: release
+---
+Release checklist.`,
+			"utf8",
+		);
+		spawnSync("git", ["init"], {
+			cwd: workspace,
+			encoding: "utf8",
+		});
+
+		const result = runCli(["config", "workflows"], {
+			cwd: nestedDir,
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout)).toContain("/release");
+	});
+
+	it("lists enabled workflows in json mode", () => {
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workflows-"));
+		tempDirs.push(workspace);
+		const workflowsDir = path.join(workspace, ".clinerules", "workflows");
+		mkdirSync(workflowsDir, { recursive: true });
+		writeFileSync(
+			path.join(workflowsDir, "review.md"),
+			`---
+name: review
+---
+Review checklist.`,
+			"utf8",
+		);
+
+		const result = runCli(["config", "workflows", "--json"], {
+			cwd: workspace,
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(0);
+		const parsed = JSON.parse(asText(result.stdout)) as Array<{
+			name: string;
+		}>;
+		expect(parsed.some((workflow) => workflow.name === "review")).toBe(true);
+	});
+
+	it("includes Documents/Cline workflows", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workspace-"));
+		tempDirs.push(homeDir, workspace);
+		const docsWorkflowsDir = path.join(
+			homeDir,
+			"Documents",
+			"Cline",
+			"Workflows",
+		);
+		mkdirSync(docsWorkflowsDir, { recursive: true });
+		writeFileSync(
+			path.join(docsWorkflowsDir, "docs-release.md"),
+			`---
+name: docs-release
+---
+Release from docs path.`,
+			"utf8",
+		);
+
+		const result = runCli(["config", "workflows"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+			},
+		});
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout)).toContain("/docs-release");
+	});
+
+	it("lists enabled rules", () => {
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-rules-"));
+		tempDirs.push(workspace);
+		const rulesDir = path.join(workspace, ".clinerules");
+		mkdirSync(rulesDir, { recursive: true });
+		writeFileSync(
+			path.join(rulesDir, "rule.md"),
+			`---
+name: no-force-push
+---
+Do not force push.`,
+			"utf8",
+		);
+
+		const result = runCli(["config", "rules"], {
+			cwd: workspace,
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout)).toContain("Enabled rules:");
+		expect(asText(result.stdout)).toContain("no-force-push");
+		expect(asText(result.stdout)).toContain(path.join(rulesDir, "rule.md"));
+	});
+
+	it("lists enabled skills", () => {
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-skills-"));
+		tempDirs.push(workspace);
+		const skillsDir = path.join(workspace, ".clinerules", "skills", "commit");
+		mkdirSync(skillsDir, { recursive: true });
+		writeFileSync(
+			path.join(skillsDir, "SKILL.md"),
+			`---
+name: commit
+---
+Create a concise commit message.`,
+			"utf8",
+		);
+
+		const result = runCli(["config", "skills"], {
+			cwd: workspace,
+			env: createIsolatedEnv(),
+		});
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout)).toContain("Enabled skills:");
+		expect(asText(result.stdout)).toContain("commit");
+		expect(asText(result.stdout)).toContain(path.join(skillsDir, "SKILL.md"));
+	});
+
+	it("includes Documents/Cline rules and skills", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workspace-"));
+		tempDirs.push(homeDir, workspace);
+		const docsRulesDir = path.join(homeDir, "Documents", "Cline", "Rules");
+		const docsSkillsDir = path.join(
+			homeDir,
+			"Documents",
+			"Cline",
+			"Skills",
+			"review",
+		);
+		mkdirSync(docsRulesDir, { recursive: true });
+		mkdirSync(docsSkillsDir, { recursive: true });
+		writeFileSync(
+			path.join(docsRulesDir, "docs-rule.md"),
+			`---
+name: docs-rule
+---
+Rule from docs path.`,
+			"utf8",
+		);
+		writeFileSync(
+			path.join(docsSkillsDir, "SKILL.md"),
+			`---
+name: docs-skill
+---
+Skill from docs path.`,
+			"utf8",
+		);
+
+		const rulesResult = runCli(["config", "rules"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+			},
+		});
+		expect(rulesResult.status).toBe(0);
+		expect(asText(rulesResult.stdout)).toContain("docs-rule");
+
+		const skillsResult = runCli(["config", "skills"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+			},
+		});
+		expect(skillsResult.status).toBe(0);
+		expect(asText(skillsResult.stdout)).toContain("docs-skill");
+	});
+
+	it("lists configured agents with source paths", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workspace-"));
+		tempDirs.push(homeDir, workspace);
+		const globalAgentsDir = path.join(homeDir, ".cline", "agents");
+		const workspaceAgentsDir = path.join(workspace, ".cline", "agents");
+		mkdirSync(globalAgentsDir, { recursive: true });
+		mkdirSync(workspaceAgentsDir, { recursive: true });
+		writeFileSync(
+			path.join(globalAgentsDir, "reviewer.yaml"),
+			`---
+name: Reviewer
+description: Reviews code changes
+---
+Review diffs thoroughly.`,
+			"utf8",
+		);
+		writeFileSync(
+			path.join(workspaceAgentsDir, "planner.yaml"),
+			`---
+name: Planner
+description: Plans implementation tasks
+---
+Break work into clear steps.`,
+			"utf8",
+		);
+
+		const textResult = runCli(["config", "agents"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DIR: path.join(homeDir, ".cline"),
+			},
+		});
+		expect(textResult.status).toBe(0);
+		expect(asText(textResult.stdout)).toContain("Configured agents:");
+		expect(asText(textResult.stdout)).toContain("Reviewer");
+		expect(asText(textResult.stdout)).toContain("Planner");
+		expect(asText(textResult.stdout)).toContain(
+			path.join(globalAgentsDir, "reviewer.yaml"),
+		);
+		expect(asText(textResult.stdout)).toContain(
+			path.join(workspaceAgentsDir, "planner.yaml"),
+		);
+
+		const jsonResult = runCli(["config", "agents", "--json"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DIR: path.join(homeDir, ".cline"),
+			},
+		});
+		expect(jsonResult.status).toBe(0);
+		const parsed = JSON.parse(asText(jsonResult.stdout)) as Array<{
+			name: string;
+			path: string;
+		}>;
+		expect(parsed.some((agent) => agent.name === "Reviewer")).toBe(true);
+		expect(parsed.some((agent) => agent.name === "Planner")).toBe(true);
+		expect(
+			parsed.some(
+				(agent) => agent.path === path.join(globalAgentsDir, "reviewer.yaml"),
+			),
+		).toBe(true);
+	});
+
+	it("lists discovered plugins", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workspace-"));
+		tempDirs.push(homeDir, dataDir, workspace);
+		const workspacePluginsDir = path.join(workspace, ".cline", "plugins");
+		const userPluginsDir = path.join(homeDir, ".cline", "plugins");
+		const documentsPluginsDir = path.join(
+			homeDir,
+			"Documents",
+			"Cline",
+			"Plugins",
+		);
+		mkdirSync(workspacePluginsDir, { recursive: true });
+		mkdirSync(userPluginsDir, { recursive: true });
+		mkdirSync(documentsPluginsDir, { recursive: true });
+		writeFileSync(
+			path.join(workspacePluginsDir, "workspace-plugin.ts"),
+			"export default { name: 'workspace-plugin', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		writeFileSync(
+			path.join(userPluginsDir, "user-plugin.js"),
+			"export default { name: 'user-plugin', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		writeFileSync(
+			path.join(documentsPluginsDir, "docs-plugin.ts"),
+			"export default { name: 'docs-plugin', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const textResult = runCli(["config", "plugins"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DIR: path.join(homeDir, ".cline"),
+				CLINE_DATA_DIR: dataDir,
+			},
+		});
+		expect(textResult.status).toBe(0);
+		expect(asText(textResult.stdout)).toContain("Discovered plugins:");
+		expect(asText(textResult.stdout)).toContain("workspace-plugin");
+		expect(asText(textResult.stdout)).toContain("user-plugin");
+		expect(asText(textResult.stdout)).toContain("docs-plugin");
+		expect(asText(textResult.stdout)).toContain(
+			path.join(workspacePluginsDir, "workspace-plugin.ts"),
+		);
+		expect(asText(textResult.stdout)).toContain(
+			path.join(userPluginsDir, "user-plugin.js"),
+		);
+		expect(asText(textResult.stdout)).toContain(
+			path.join(documentsPluginsDir, "docs-plugin.ts"),
+		);
+
+		const jsonResult = runCli(["config", "plugins", "--json"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DIR: path.join(homeDir, ".cline"),
+				CLINE_DATA_DIR: dataDir,
+			},
+		});
+		expect(jsonResult.status).toBe(0);
+		const parsed = JSON.parse(asText(jsonResult.stdout)) as Array<{
+			name: string;
+			path: string;
+		}>;
+		expect(parsed.some((plugin) => plugin.name === "workspace-plugin")).toBe(
+			true,
+		);
+		expect(parsed.some((plugin) => plugin.name === "user-plugin")).toBe(true);
+		expect(parsed.some((plugin) => plugin.name === "docs-plugin")).toBe(true);
+		expect(
+			parsed.some((plugin) =>
+				plugin.path.endsWith(
+					path.join(".cline", "plugins", "workspace-plugin.ts"),
+				),
+			),
+		).toBe(true);
+		expect(
+			parsed.some((plugin) =>
+				plugin.path.endsWith(path.join(".cline", "plugins", "user-plugin.js")),
+			),
+		).toBe(true);
+		expect(
+			parsed.some((plugin) =>
+				plugin.path.endsWith(
+					path.join("Documents", "Cline", "Plugins", "docs-plugin.ts"),
+				),
+			),
+		).toBe(true);
+	});
+
+	it("lists configured mcp servers", () => {
+		const tempRoot = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-mcp-"));
+		tempDirs.push(tempRoot);
+		const settingsPath = path.join(tempRoot, "cline_mcp_settings.json");
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "stdio",
+								command: "node",
+							},
+						},
+						remote: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.example.com",
+							},
+							disabled: true,
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const textResult = runCli(["config", "mcp"], {
+			env: {
+				...createIsolatedEnv(),
+				CLINE_MCP_SETTINGS_PATH: settingsPath,
+			},
+		});
+		expect(textResult.status).toBe(0);
+		expect(asText(textResult.stdout)).toContain("Configured MCP servers");
+		expect(asText(textResult.stdout)).toContain("docs [stdio]");
+		expect(asText(textResult.stdout)).toContain(
+			"remote [streamableHttp] (disabled)",
+		);
+
+		const jsonResult = runCli(["config", "mcp", "--json"], {
+			env: {
+				...createIsolatedEnv(),
+				CLINE_MCP_SETTINGS_PATH: settingsPath,
+			},
+		});
+		expect(jsonResult.status).toBe(0);
+		const parsed = JSON.parse(asText(jsonResult.stdout)) as Array<{
+			name: string;
+			transportType: string;
+			disabled: boolean;
+			path: string;
+		}>;
+		expect(parsed.some((server) => server.name === "docs")).toBe(true);
+		expect(parsed.some((server) => server.name === "remote")).toBe(true);
+		expect(
+			parsed.some(
+				(server) =>
+					server.name === "remote" &&
+					server.transportType === "streamableHttp" &&
+					server.disabled === true &&
+					server.path === settingsPath,
+			),
+		).toBe(true);
+	});
+
+	it("routes mcp install and requires a TTY for the prefilled wizard", () => {
+		const result = runCli(
+			[
+				"mcp",
+				"install",
+				"fs",
+				"--",
+				"npx",
+				"-y",
+				"@modelcontextprotocol/server-filesystem",
+				"/tmp",
+			],
+			{ env: createIsolatedEnv() },
+		);
+
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain(
+			"cline mcp install opens the MCP wizard and requires a TTY.",
+		);
+	});
+
+	it("lists available tools", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));
+		const workspace = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-workspace-"));
+		tempDirs.push(homeDir, dataDir, workspace);
+		const workspacePluginsDir = path.join(workspace, ".cline", "plugins");
+		const globalSettingsPath = path.join(
+			dataDir,
+			"settings",
+			"global-settings.json",
+		);
+		mkdirSync(workspacePluginsDir, { recursive: true });
+		mkdirSync(path.dirname(globalSettingsPath), { recursive: true });
+		writeFileSync(
+			path.join(workspacePluginsDir, "workspace-plugin.ts"),
+			[
+				"export default {",
+				"  name: 'workspace-plugin',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup(api) {",
+				"    api.registerTool({",
+				"      name: 'plugin_echo',",
+				"      description: 'Echo from plugin',",
+				"      inputSchema: { type: 'object', properties: {}, required: [] },",
+				"      execute: async () => ({ ok: true }),",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+		writeFileSync(
+			globalSettingsPath,
+			JSON.stringify({ disabledTools: ["plugin_echo"] }, null, 2),
+			"utf8",
+		);
+
+		const textResult = runCli(["config", "tools"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DATA_DIR: dataDir,
+				CLINE_GLOBAL_SETTINGS_PATH: globalSettingsPath,
+			},
+		});
+		expect(textResult.status).toBe(0);
+		expect(asText(textResult.stdout)).toContain("Available tools:");
+		expect(asText(textResult.stdout)).toContain(
+			"read_files [default: enabled]",
+		);
+		expect(asText(textResult.stdout)).toContain(
+			"spawn_agent [default: enabled]",
+		);
+		expect(asText(textResult.stdout)).toContain("teams [default: enabled]");
+		expect(asText(textResult.stdout)).not.toContain("submit_and_exit");
+		expect(asText(textResult.stdout)).not.toContain("apply_patch");
+		expect(asText(textResult.stdout)).toContain("Plugin tools:");
+		expect(asText(textResult.stdout)).toContain("plugin_echo");
+		expect(asText(textResult.stdout)).toContain("[disabled]");
+
+		const jsonResult = runCli(["config", "tools", "--json"], {
+			cwd: workspace,
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_DATA_DIR: dataDir,
+				CLINE_GLOBAL_SETTINGS_PATH: globalSettingsPath,
+			},
+		});
+		expect(jsonResult.status).toBe(0);
+		const parsed = JSON.parse(asText(jsonResult.stdout)) as Array<{
+			id?: string;
+			name: string;
+			type: string;
+			enabled?: boolean;
+			defaultEnabled?: boolean;
+			headlessToolNames?: string[];
+		}>;
+		expect(
+			parsed.some(
+				(tool) => tool.id === "run_commands" && tool.defaultEnabled === true,
+			),
+		).toBe(true);
+		expect(
+			parsed.some(
+				(tool) =>
+					tool.id === "editor" &&
+					tool.headlessToolNames?.includes("editor") &&
+					!tool.headlessToolNames?.includes("apply_patch"),
+			),
+		).toBe(true);
+		expect(
+			parsed.some(
+				(tool) =>
+					tool.id === "teams" &&
+					tool.defaultEnabled === true &&
+					tool.headlessToolNames?.includes("team_status"),
+			),
+		).toBe(true);
+		expect(parsed.some((tool) => tool.id === "apply_patch")).toBe(false);
+		expect(parsed.some((tool) => tool.id === "submit_and_exit")).toBe(false);
+		expect(
+			parsed.some(
+				(tool) =>
+					tool.name === "plugin_echo" &&
+					tool.type === "plugin" &&
+					tool.enabled === false,
+			),
+		).toBe(true);
+	});
+
+	it("rejects invalid hook payloads", () => {
+		const result = runCli(["hook"], {
+			env: createIsolatedEnv(),
+			stdin: JSON.stringify({ bad: "payload" }),
+		});
+		expect(result.status).toBe(1);
+		expect(asText(result.stderr)).toContain("invalid hook payload");
+	});
+
+	it("accepts valid hook payloads and writes audit log", () => {
+		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
+		const sessionDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-sessions-"));
+		const logDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-hooks-"));
+		tempDirs.push(homeDir, sessionDir, logDir);
+		const hookPath = path.join(logDir, "hook-events.jsonl");
+		const defaultHookPath = path.join(
+			homeDir,
+			".cline",
+			"data",
+			"logs",
+			"hooks.jsonl",
+		);
+		const result = runCli(["hook"], {
+			env: {
+				...createIsolatedEnv(),
+				HOME: homeDir,
+				CLINE_SESSION_DATA_DIR: sessionDir,
+				CLINE_HOOKS_LOG_PATH: hookPath,
+			},
+			stdin: JSON.stringify({
+				hookName: "tool_call",
+				taskId: "conversation_1",
+				clineVersion: "",
+				timestamp: new Date().toISOString(),
+				workspaceRoots: [],
+				userId: "agent_1",
+				agent_id: "agent_1",
+				parent_agent_id: null,
+				tool_call: {
+					id: "call_1",
+					name: "read_files",
+					input: { file_paths: ["README.md"] },
+				},
+			}),
+		});
+
+		expect(result.status).toBe(0);
+		expect(asText(result.stdout).trim()).toBe("{}");
+		const logPath = existsSync(hookPath) ? hookPath : defaultHookPath;
+		const log = readFileSync(logPath, "utf8");
+		expect(log).toContain('"hookName":"tool_call"');
+		expect(log).toContain('"agent_id":"agent_1"');
+	});
+});
diff --git a/apps/cli/src/cli.interactive.e2e.test.ts b/apps/cli/src/cli.interactive.e2e.test.ts
new file mode 100644
index 0000000..8b1b853
--- /dev/null
+++ b/apps/cli/src/cli.interactive.e2e.test.ts
@@ -0,0 +1,274 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+const cliRoot = path.resolve(__dirname, "..");
+const cliEntry = path.join(cliRoot, "src", "index.ts");
+const bunExec = process.env.BUN_EXEC_PATH ?? "bun";
+
+type CliResult = ReturnType<typeof spawnSync>;
+
+interface KeyStep {
+	delaySeconds: number;
+	input: string;
+}
+
+const INITIAL_RENDER_DELAY_SECONDS = 2.5;
+const POST_ACTION_SETTLE_SECONDS = 1.0;
+const INTERACTIVE_TEST_TIMEOUT_MS = 40_000;
+const HISTORY_PICKER_READY_DELAY_SECONDS = 8.0;
+const HISTORY_RESUME_READY_DELAY_SECONDS = 15.0;
+
+function normalizeTerminalOutput(output: string): string {
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: this regex intentionally strips ANSI escape sequences
+	const ansiCsiRegex = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: this regex intentionally strips OSC sequences
+	const ansiOscRegex = /\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g;
+	const carriageReturnRegex = /\r/g;
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: this regex intentionally strips backspace control bytes
+	const backspaceRegex = /\u0008/g;
+	return (
+		output
+			// Strip ANSI CSI/OSC escapes.
+			.replace(ansiCsiRegex, "")
+			.replace(ansiOscRegex, "")
+			// Remove CR + backspace artifacts from `script`.
+			.replace(carriageReturnRegex, "")
+			.replace(backspaceRegex, "")
+	);
+}
+
+function toShellSingleQuotedLiteral(value: string): string {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+function buildScriptCommand(scriptedInput: string, launchArgs: string): string {
+	const quietFlag = "-q";
+	if (process.platform === "linux") {
+		return `(${scriptedInput}) | script ${quietFlag} /dev/null -- ${toShellSingleQuotedLiteral(bunExec)} ${launchArgs}`;
+	}
+
+	return `(${scriptedInput}) | script ${quietFlag} /dev/null ${toShellSingleQuotedLiteral(bunExec)} ${launchArgs}`;
+}
+
+function createCliEnv(): NodeJS.ProcessEnv {
+	const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-home-"));
+	const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-data-"));
+	const sessionDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-sessions-"));
+	const teamDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-teams-"));
+	tempDirs.push(homeDir, dataDir, sessionDir, teamDir);
+
+	return {
+		...process.env,
+		HOME: homeDir,
+		CLINE_DATA_DIR: dataDir,
+		CLINE_DB_DATA_DIR: path.join(dataDir, "db"),
+		CLINE_SESSION_DATA_DIR: sessionDir,
+		CLINE_TEAM_DATA_DIR: teamDir,
+		CLINE_SESSION_BACKEND_MODE: "local",
+		CLINE_PROVIDER_SETTINGS_PATH: path.join(
+			dataDir,
+			"settings",
+			"providers.json",
+		),
+		CLINE_HOOKS_LOG_PATH: path.join(dataDir, "logs", "hooks.jsonl"),
+	};
+}
+
+function runInteractiveCli(
+	steps: KeyStep[],
+	options?: {
+		launchConfigView?: boolean;
+		launchArgs?: string[];
+		env?: NodeJS.ProcessEnv;
+	},
+): CliResult {
+	const env = options?.env ?? createCliEnv();
+
+	const scriptedInput = [
+		...steps,
+		// Exit each interactive run explicitly so tests do not idle until timeout.
+		{ delaySeconds: 0.2, input: "\u0003" },
+	]
+		.map(
+			(step) =>
+				`sleep ${step.delaySeconds}; printf ${toShellSingleQuotedLiteral(step.input)}`,
+		)
+		.join("; ");
+	const baseArgs = [
+		cliEntry,
+		"--provider",
+		"anthropic",
+		"-m",
+		"claude-sonnet-4-6",
+		"-k",
+		"test-key",
+	];
+	const launchArgs = (
+		options?.launchArgs
+			? [cliEntry, ...options.launchArgs]
+			: options?.launchConfigView
+				? [...baseArgs, "config"]
+				: baseArgs
+	)
+		.map((arg) => toShellSingleQuotedLiteral(arg))
+		.join(" ");
+	const command = buildScriptCommand(scriptedInput, launchArgs);
+
+	return spawnSync("bash", ["-lc", command], {
+		cwd: cliRoot,
+		encoding: "utf8",
+		env,
+		timeout: INTERACTIVE_TEST_TIMEOUT_MS,
+		maxBuffer: 10 * 1024 * 1024,
+	});
+}
+
+function outputOf(result: CliResult): string {
+	return normalizeTerminalOutput(
+		`${typeof result.stdout === "string" ? result.stdout : result.stdout.toString("utf8")}\n${
+			typeof result.stderr === "string"
+				? result.stderr
+				: result.stderr.toString("utf8")
+		}`,
+	);
+}
+
+const tempDirs: string[] = [];
+
+describe("cli interactive e2e", () => {
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("shows the interactive chat view on launch", () => {
+		const result = runInteractiveCli([
+			{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "" },
+		]);
+		const output = outputOf(result);
+		expect(output).toContain("What can I do for you?");
+		expect(output).toContain("○ Plan ● Act (Tab)");
+		expect(output).toContain("Auto-approve all enabled (Shift+Tab)");
+	});
+
+	it("toggles plan/act mode with Tab", () => {
+		const result = runInteractiveCli([
+			{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "\t" },
+			{ delaySeconds: POST_ACTION_SETTLE_SECONDS, input: "" },
+		]);
+		const output = outputOf(result);
+		expect(output).toContain("○ Plan ● Act (Tab)");
+		expect(output).toContain("● Plan ○ Act (Tab)");
+	});
+
+	it("toggles auto-approve-all with Shift+Tab", () => {
+		const result = runInteractiveCli([
+			{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "\u001b[Z" },
+			{ delaySeconds: POST_ACTION_SETTLE_SECONDS, input: "" },
+		]);
+		const output = outputOf(result);
+		expect(output).toContain("Auto-approve all enabled (Shift+Tab)");
+		expect(output).toContain("Auto-approve all disabled (Shift+Tab)");
+	});
+
+	it("opens /settings and navigates tabs with Tab", () => {
+		const result = runInteractiveCli([
+			{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "/settings" },
+			{ delaySeconds: 0.25, input: "\r" }, // accept slash completion
+			{ delaySeconds: 0.25, input: "\r" }, // submit command
+			{ delaySeconds: 0.7, input: "\t" },
+			{ delaySeconds: POST_ACTION_SETTLE_SECONDS, input: "" },
+		]);
+		const output = outputOf(result);
+		expect(output).toContain("Configuration");
+		expect(output).toContain("[Tools] Plugins Agents Hooks Skills Rules MCP");
+		expect(output).toContain("Tools [Plugins] Agents Hooks Skills Rules MCP");
+	});
+
+	it("closes /settings with Escape", () => {
+		const result = runInteractiveCli([
+			{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "/settings" },
+			{ delaySeconds: 0.25, input: "\r" },
+			{ delaySeconds: 0.25, input: "\r" },
+			{ delaySeconds: POST_ACTION_SETTLE_SECONDS, input: "\u001b" },
+			{ delaySeconds: POST_ACTION_SETTLE_SECONDS, input: "" },
+		]);
+		const output = outputOf(result);
+		expect(output).toContain(
+			"Config mode: Tab tabs · ↑/↓ navigate · Esc close",
+		);
+		expect(output).toContain("/ for commands · @ for files");
+	});
+
+	it("resumes a history-picked session and survives Ctrl+C without a native crash", {
+		timeout: 120_000,
+	}, () => {
+		const env = createCliEnv();
+		// Seed one session; the invalid key makes the run fail fast while
+		// still persisting a resumable session record.
+		const seed = spawnSync(
+			bunExec,
+			[
+				cliEntry,
+				"--provider",
+				"anthropic",
+				"-m",
+				"claude-sonnet-4-6",
+				"-k",
+				"test-key",
+				"hello",
+			],
+			{ cwd: cliRoot, encoding: "utf8", env, timeout: 60_000 },
+		);
+		expect(seed.error).toBeUndefined();
+		const history = spawnSync(bunExec, [cliEntry, "history", "--json"], {
+			cwd: cliRoot,
+			encoding: "utf8",
+			env,
+			timeout: 60_000,
+		});
+		expect(history.error).toBeUndefined();
+		expect(history.status).toBe(0);
+		const historyRows = JSON.parse(history.stdout) as unknown[];
+		expect(historyRows.length).toBeGreaterThan(0);
+
+		// history picker -> Enter resumes the seeded session in the
+		// interactive TUI -> double Ctrl+C exits it. Regression guard for
+		// the Bun "panic(main thread): Segmentation fault" that occurred
+		// when the resumed TUI shared the picker's process (a second
+		// OpenTUI renderer in one process crashes natively on teardown).
+		const result = runInteractiveCli(
+			[
+				// Select the seeded session in the picker.
+				{ delaySeconds: HISTORY_PICKER_READY_DELAY_SECONDS, input: "\r" },
+				// Give the resumed TUI time to start, then double-press
+				// Ctrl+C; the harness appends the final press 0.2s later.
+				{ delaySeconds: HISTORY_RESUME_READY_DELAY_SECONDS, input: "\u0003" },
+			],
+			{ launchArgs: ["history"], env },
+		);
+		const output = outputOf(result);
+		// The exit summary only prints after the resumed interactive TUI ran
+		// and shut down cleanly; the history picker alone never prints it.
+		expect(output).toContain("Session Summary");
+		expect(output).not.toContain("panic(");
+		expect(output).not.toContain("Segmentation fault");
+		expect(result.status).toBe(0);
+	});
+
+	it("launches config view directly with `cline config`", () => {
+		const result = runInteractiveCli(
+			[{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "" }],
+			{
+				launchConfigView: true,
+			},
+		);
+		const output = outputOf(result);
+		expect(output).toContain("Configuration");
+		expect(output).toContain("[Tools] Plugins Agents Hooks Skills Rules MCP");
+	});
+});
diff --git a/apps/cli/src/commands/auth.test.ts b/apps/cli/src/commands/auth.test.ts
new file mode 100644
index 0000000..feab4f2
--- /dev/null
+++ b/apps/cli/src/commands/auth.test.ts
@@ -0,0 +1,134 @@
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import type { ProviderSettingsManager } from "@cline/core";
+import { describe, expect, it, vi } from "vitest";
+import {
+	getPersistedProviderApiKey,
+	normalizeAuthProviderId,
+	parseAuthCommandArgs,
+	saveOAuthProviderSettings,
+} from "./auth";
+
+describe("parseAuthCommandArgs", () => {
+	it("parses Azure API version quick setup option", () => {
+		expect(
+			parseAuthCommandArgs([
+				"--provider",
+				"openai-compatible",
+				"--apikey",
+				"key",
+				"--modelid",
+				"gpt-4.1",
+				"--baseurl",
+				"https://example.openai.azure.com/openai/deployments/gpt-4.1",
+				"--azure-api-version",
+				"2025-01-01-preview",
+			]),
+		).toMatchObject({
+			explicitProvider: "openai-compatible",
+			apikey: "key",
+			modelid: "gpt-4.1",
+			baseurl: "https://example.openai.azure.com/openai/deployments/gpt-4.1",
+			azureApiVersion: "2025-01-01-preview",
+		});
+	});
+});
+
+describe("saveOAuthProviderSettings", () => {
+	it("preserves existing manual apiKey while updating OAuth tokens", () => {
+		const save = vi.fn();
+		const manager = {
+			saveProviderSettings: save,
+		} as unknown as ProviderSettingsManager;
+
+		const merged = saveOAuthProviderSettings(
+			manager,
+			"cline",
+			{
+				provider: "cline",
+				apiKey: "manual-key",
+				auth: {
+					accessToken: "workos:old-access",
+					refreshToken: "old-refresh",
+					accountId: "acct-old",
+				},
+			},
+			{
+				access: "new-access",
+				refresh: "new-refresh",
+				expires: 4_000_000_000_000,
+				accountId: "acct-new",
+			},
+		);
+
+		expect(merged).toMatchObject({
+			provider: "cline",
+			apiKey: "manual-key",
+			auth: {
+				accessToken: "workos:new-access",
+				refreshToken: "new-refresh",
+				accountId: "acct-new",
+				expiresAt: 4_000_000_000_000,
+			},
+		});
+		expect(save).toHaveBeenCalledWith(
+			expect.objectContaining({
+				provider: "cline",
+				apiKey: "manual-key",
+				auth: expect.objectContaining({
+					accessToken: "workos:new-access",
+				}),
+			}),
+			{ tokenSource: "oauth" },
+		);
+	});
+});
+
+describe("getPersistedProviderApiKey", () => {
+	it("does not double-prefix persisted Cline OAuth tokens", () => {
+		expect(
+			getPersistedProviderApiKey("cline", {
+				provider: "cline",
+				auth: {
+					accessToken: "workos:oauth-access",
+				},
+			}),
+		).toBe("workos:oauth-access");
+	});
+});
+
+describe("normalizeAuthProviderId", () => {
+	it("keeps CLI-only codex shorthand in CLI parsing", () => {
+		expect(normalizeAuthProviderId("codex")).toBe("openai-codex");
+	});
+});
+
+describe("loadAuthTuiRuntime", () => {
+	it("loads OpenTUI React after provider catalog initialization", async () => {
+		const cliRoot = fileURLToPath(new URL("../..", import.meta.url));
+		const script = `
+import { ProviderSettingsManager, ensureCustomProvidersLoaded, listLocalProviders } from "@cline/core";
+import { loadAuthTuiRuntime } from "./src/commands/auth.ts";
+const manager = new ProviderSettingsManager();
+await ensureCustomProvidersLoaded(manager);
+await listLocalProviders(manager);
+const runtime = await loadAuthTuiRuntime();
+if (typeof runtime.createCliRenderer !== "function") throw new Error("missing createCliRenderer");
+if (typeof runtime.createRoot !== "function") throw new Error("missing createRoot");
+if (typeof runtime.OnboardingView !== "function") throw new Error("missing OnboardingView");
+`;
+
+		const result = spawnSync(
+			"bun",
+			["--conditions=development", "-e", script],
+			{
+				cwd: cliRoot,
+				encoding: "utf8",
+			},
+		);
+
+		expect(result.error).toBeUndefined();
+		expect(result.stderr).toBe("");
+		expect(result.status).toBe(0);
+	});
+});
diff --git a/apps/cli/src/commands/auth.ts b/apps/cli/src/commands/auth.ts
new file mode 100644
index 0000000..3eef240
--- /dev/null
+++ b/apps/cli/src/commands/auth.ts
@@ -0,0 +1,455 @@
+import { createInterface } from "node:readline";
+import {
+	BUILT_IN_PROVIDER,
+	createOAuthClientCallbacks,
+	ensureCustomProvidersLoaded,
+	getProviderAuthHandler,
+	loginAndSaveProviderOAuthCredentials,
+	type ProviderSettings,
+	type ProviderSettingsManager,
+	saveProviderOAuthCredentials,
+} from "@cline/core";
+import { Command } from "commander";
+import open from "open";
+import React from "react";
+import { disableOpenTuiGraphicsProbe } from "../tui/opentui-env";
+import {
+	getPersistedProviderApiKey,
+	isOAuthProvider,
+	normalizeAuthProviderId,
+	normalizeProviderId,
+	type OAuthCredentials,
+	toProviderApiKey,
+} from "../utils/provider-auth";
+import { listLocalProviders } from "../utils/provider-catalog";
+import { identifyTelemetryAccount } from "../utils/telemetry";
+
+export {
+	getPersistedProviderApiKey,
+	isOAuthProvider,
+	normalizeAuthProviderId,
+	normalizeProviderId,
+	toProviderApiKey,
+};
+export type { OAuthCredentials };
+
+const c = {
+	reset: "\x1b[0m",
+	dim: "\x1b[2m",
+	cyan: "\x1b[36m",
+	green: "\x1b[32m",
+};
+
+type AuthIo = {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+};
+
+type AuthQuickSetupInput = {
+	provider: string;
+	apikey: string;
+	modelid: string;
+	baseurl?: string;
+	azureApiVersion?: string;
+};
+
+type AuthCommandInput = {
+	providerSettingsManager: ProviderSettingsManager;
+	io: AuthIo;
+	explicitProvider?: string;
+	apikey?: string;
+	modelid?: string;
+	baseurl?: string;
+	azureApiVersion?: string;
+};
+
+type ParsedAuthCommandArgs = {
+	explicitProvider?: string;
+	apikey?: string;
+	modelid?: string;
+	baseurl?: string;
+	azureApiVersion?: string;
+	parseError?: string;
+};
+
+/**
+ * Create the `auth` subcommand for Commander.
+ *
+ * In the auth context, `-p` means `--provider` and `-m` means `--modelid`,
+ * which intentionally shadows the global `-p` (--plan) and `-m` (--model)
+ * short flags. Commander scopes options per-command, so there is no conflict.
+ */
+export function createAuthCommand(): Command {
+	const cmd = new Command("auth")
+		.description("Authenticate with an LLM provider")
+		.exitOverride()
+		.configureOutput({ writeOut: () => {}, writeErr: () => {} })
+		.argument("[provider]", "provider id (positional shorthand for -p)")
+		.option("-p, --provider <id>", "provider id")
+		.option("-k, --apikey <key>", "API key")
+		.option("-m, --modelid <id>", "model id")
+		.option("-b, --baseurl <url>", "base URL")
+		.option("--azure-api-version <version>", "Azure API version");
+	return cmd;
+}
+
+export function parseAuthCommandArgs(args: string[]): ParsedAuthCommandArgs {
+	const cmd = createAuthCommand();
+	try {
+		cmd.parse(args, { from: "user" });
+	} catch {
+		// Commander throws on --help / --version / unknown flags via exitOverride
+		return { parseError: `unknown auth option in: ${args.join(" ")}` };
+	}
+	const opts = cmd.opts<{
+		provider?: string;
+		apikey?: string;
+		modelid?: string;
+		baseurl?: string;
+		azureApiVersion?: string;
+	}>();
+	const positionalProvider = cmd.args[0];
+	return {
+		explicitProvider: opts.provider ?? positionalProvider,
+		apikey: opts.apikey,
+		modelid: opts.modelid,
+		baseurl: opts.baseurl,
+		azureApiVersion: opts.azureApiVersion,
+	};
+}
+
+async function loadProviderCatalog(
+	providerSettingsManager: ProviderSettingsManager,
+): Promise<Array<{ id: string; name: string }>> {
+	await ensureCustomProvidersLoaded(providerSettingsManager);
+	const catalog = await listLocalProviders(providerSettingsManager);
+	return catalog.providers
+		.map((provider) => ({
+			id: provider.id.trim(),
+			name: provider.name.trim() || provider.id.trim(),
+		}))
+		.filter((provider) => provider.id.length > 0)
+		.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+async function ensureQuickSetupInputValid(
+	input: AuthQuickSetupInput,
+	providerSettingsManager: ProviderSettingsManager,
+): Promise<string | undefined> {
+	const normalizedProvider = normalizeProviderId(input.provider);
+	const providerCatalog = await loadProviderCatalog(providerSettingsManager);
+	if (!providerCatalog.some((provider) => provider.id === normalizedProvider)) {
+		return `invalid provider "${input.provider}"`;
+	}
+	if (!input.apikey.trim()) {
+		return "auth quick setup requires --apikey <key>";
+	}
+	if (!input.modelid.trim()) {
+		return "auth quick setup requires --modelid <id>";
+	}
+	if (
+		input.baseurl?.trim() &&
+		normalizedProvider !== BUILT_IN_PROVIDER.OPENAI_COMPATIBLE &&
+		normalizedProvider !== BUILT_IN_PROVIDER.OPENAI_NATIVE
+	) {
+		return "base URL is only supported for OpenAI and OpenAI-compatible providers";
+	}
+	if (
+		input.azureApiVersion?.trim() &&
+		normalizedProvider !== BUILT_IN_PROVIDER.OPENAI_COMPATIBLE
+	) {
+		return "Azure API version is only supported for OpenAI-compatible providers";
+	}
+	return undefined;
+}
+
+function saveQuickAuthProviderSettings(input: {
+	providerSettingsManager: ProviderSettingsManager;
+	providerId: string;
+	apikey: string;
+	modelid: string;
+	baseurl?: string;
+	azureApiVersion?: string;
+}): void {
+	const existing = input.providerSettingsManager.getProviderSettings(
+		input.providerId,
+	);
+	const nextSettings: ProviderSettings = {
+		...(existing ?? {
+			provider: input.providerId as ProviderSettings["provider"],
+		}),
+		provider: input.providerId as ProviderSettings["provider"],
+		apiKey: input.apikey,
+		model: input.modelid,
+	};
+	if (input.baseurl?.trim()) {
+		nextSettings.baseUrl = input.baseurl.trim();
+	}
+	if (input.azureApiVersion?.trim()) {
+		nextSettings.azure = {
+			...(nextSettings.azure ?? {}),
+			apiVersion: input.azureApiVersion.trim(),
+		};
+	}
+	input.providerSettingsManager.saveProviderSettings(nextSettings);
+}
+
+async function askForInputInTerminal(question: string): Promise<string> {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		throw new Error("OAuth login requires an interactive terminal session");
+	}
+
+	return new Promise<string>((resolve) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout,
+		});
+		rl.question(`${question} `, (value) => {
+			rl.close();
+			resolve(value);
+		});
+	});
+}
+
+function createOAuthCallbacks(io: AuthIo): {
+	onAuth: (info: { url: string; instructions?: string }) => void;
+	onPrompt: (prompt: {
+		message: string;
+		defaultValue?: string;
+	}) => Promise<string>;
+} {
+	return createOAuthClientCallbacks({
+		onPrompt: ({ message, defaultValue }) =>
+			askForInputInTerminal(message).then((value) => {
+				const trimmed = value.trim();
+				return trimmed || defaultValue || "";
+			}),
+		onOutput: (message) => {
+			io.writeln(`${c.dim}[auth] ${message}${c.reset}`);
+		},
+		openUrl: (url) => open(url, { wait: false }).then(() => undefined),
+		onOpenUrlError: ({ error }) => {
+			io.writeln(
+				`${c.dim}[auth] Could not open browser automatically; open the URL above manually.${c.reset}`,
+			);
+			io.writeln(
+				`${c.dim}[auth] Browser open failed: ${error instanceof Error ? error.message : String(error)}${c.reset}`,
+			);
+		},
+	});
+}
+
+export function saveOAuthProviderSettings(
+	providerSettingsManager: ProviderSettingsManager,
+	providerId: string,
+	existing: ProviderSettings | undefined,
+	credentials: OAuthCredentials,
+): ProviderSettings {
+	return saveProviderOAuthCredentials({
+		manager: providerSettingsManager,
+		providerId,
+		settings: existing,
+		credentials,
+	});
+}
+
+export async function ensureOAuthProviderApiKey(input: {
+	providerId: string;
+	currentApiKey?: string;
+	existingSettings?: ProviderSettings;
+	providerSettingsManager: ProviderSettingsManager;
+	io: AuthIo;
+}): Promise<{
+	apiKey?: string;
+	selectedProviderSettings?: ProviderSettings;
+}> {
+	if (input.currentApiKey || !isOAuthProvider(input.providerId)) {
+		return {
+			apiKey: input.currentApiKey,
+			selectedProviderSettings: input.existingSettings,
+		};
+	}
+	const selectedProviderSettings = await loginAndSaveProviderOAuthCredentials(
+		input.providerSettingsManager,
+		input.providerId,
+		{ callbacks: createOAuthCallbacks(input.io) },
+	);
+	const handler = getProviderAuthHandler(input.providerId);
+	return {
+		apiKey: handler?.getApiKey(selectedProviderSettings),
+		selectedProviderSettings,
+	};
+}
+
+async function runQuickAuthSetup(input: AuthCommandInput): Promise<number> {
+	const providerId = normalizeProviderId((input.explicitProvider ?? "").trim());
+	const apikey = input.apikey?.trim() ?? "";
+	const modelid = input.modelid?.trim() ?? "";
+	const baseurl = input.baseurl?.trim();
+	const azureApiVersion = input.azureApiVersion?.trim();
+	const validationError = await ensureQuickSetupInputValid(
+		{
+			provider: providerId,
+			apikey,
+			modelid,
+			baseurl,
+			azureApiVersion,
+		},
+		input.providerSettingsManager,
+	);
+	if (validationError) {
+		input.io.writeErr(validationError);
+		return 1;
+	}
+	saveQuickAuthProviderSettings({
+		providerSettingsManager: input.providerSettingsManager,
+		providerId,
+		apikey,
+		modelid,
+		baseurl,
+		azureApiVersion,
+	});
+	input.io.writeln(
+		`${c.green}Provider configured:${c.reset} ${c.cyan}${providerId}${c.reset} (${modelid})`,
+	);
+	return 0;
+}
+
+export async function loadAuthTuiRuntime() {
+	disableOpenTuiGraphicsProbe();
+	const { createCliRenderer } = await import("@opentui/core");
+	const { createRoot } = await import("@opentui/react");
+	const { OnboardingView } = await import("../tui/views/onboarding");
+	return { createCliRenderer, createRoot, OnboardingView };
+}
+
+async function runInteractiveAuthTui(input: AuthCommandInput): Promise<number> {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		input.io.writeErr(
+			"interactive auth setup requires a TTY (use --provider/--apikey/--modelid for non-interactive setup)",
+		);
+		return 1;
+	}
+	const { createCliRenderer, createRoot, OnboardingView } =
+		await loadAuthTuiRuntime();
+	const renderer = await createCliRenderer({
+		exitOnCtrlC: false,
+		autoFocus: false,
+		enableMouseMovement: true,
+	});
+
+	return await new Promise<number>((resolve, reject) => {
+		let root: ReturnType<typeof createRoot>;
+		try {
+			root = createRoot(renderer);
+		} catch (error) {
+			renderer.destroy();
+			reject(error);
+			return;
+		}
+		let settled = false;
+		let unmounted = false;
+		const unmountRoot = () => {
+			if (unmounted) {
+				return;
+			}
+			unmounted = true;
+			root.unmount();
+		};
+		const settle = (code: number) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			unmountRoot();
+			renderer.destroy();
+			resolve(code);
+		};
+		renderer.on("destroy", () => {
+			unmountRoot();
+			if (!settled) {
+				settled = true;
+				resolve(1);
+			}
+		});
+		try {
+			root.render(
+				React.createElement(OnboardingView, {
+					providerSettingsManager: input.providerSettingsManager,
+					onComplete: () => settle(0),
+					onExit: () => settle(1),
+				}),
+			);
+		} catch (error) {
+			unmountRoot();
+			renderer.destroy();
+			reject(error);
+		}
+	});
+}
+
+export async function runAuthCommand(input: AuthCommandInput): Promise<number> {
+	const hasQuickSetupFlags =
+		typeof input.apikey === "string" ||
+		typeof input.modelid === "string" ||
+		typeof input.baseurl === "string" ||
+		typeof input.azureApiVersion === "string";
+
+	if (hasQuickSetupFlags) {
+		if (!input.explicitProvider?.trim()) {
+			input.io.writeErr(
+				"auth quick setup requires --provider <id> when using --apikey/--modelid/--baseurl/--azure-api-version",
+			);
+			return 1;
+		}
+		return runQuickAuthSetup(input);
+	}
+
+	if (input.explicitProvider?.trim()) {
+		const providerId = normalizeAuthProviderId(input.explicitProvider);
+		if (isOAuthProvider(providerId)) {
+			return runAuthProviderCommand(
+				input.providerSettingsManager,
+				providerId,
+				input.io,
+			);
+		}
+		input.io.writeErr(
+			`provider "${providerId}" requires API key setup (use subcommand: auth --provider ${providerId} --apikey <key> --modelid <id>)`,
+		);
+		return 1;
+	}
+
+	return runInteractiveAuthTui(input);
+}
+
+export async function runAuthProviderCommand(
+	providerSettingsManager: ProviderSettingsManager,
+	providerId: string,
+	io: AuthIo,
+): Promise<number> {
+	if (!isOAuthProvider(providerId)) {
+		io.writeErr(
+			`provider "${providerId}" does not support OAuth login (supported: cline, openai-codex, oca)`,
+		);
+		return 1;
+	}
+	try {
+		const settings = await loginAndSaveProviderOAuthCredentials(
+			providerSettingsManager,
+			providerId,
+			{ callbacks: createOAuthCallbacks(io) },
+		);
+		identifyTelemetryAccount({
+			id: settings.auth?.accountId,
+			provider: providerId,
+		});
+		io.writeln(
+			`${c.green}You are now logged in to ${c.cyan}${providerId}${c.reset}`,
+		);
+		return 0;
+	} catch (error) {
+		io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
diff --git a/apps/cli/src/commands/bin-wrapper.test.ts b/apps/cli/src/commands/bin-wrapper.test.ts
new file mode 100644
index 0000000..530424a
--- /dev/null
+++ b/apps/cli/src/commands/bin-wrapper.test.ts
@@ -0,0 +1,87 @@
+import { spawnSync } from "node:child_process";
+import {
+	chmodSync,
+	copyFileSync,
+	mkdirSync,
+	mkdtempSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const sourceWrapperPath = fileURLToPath(
+	new URL("../../bin/cline", import.meta.url),
+);
+
+function createWrapperCopy(): string {
+	const dir = mkdtempSync(join(tmpdir(), "cline-bin-package-"));
+	const binDir = join(dir, "bin");
+	mkdirSync(binDir, { recursive: true });
+	const wrapperPath = join(binDir, "cline");
+	copyFileSync(sourceWrapperPath, wrapperPath);
+	chmodSync(wrapperPath, 0o755);
+	return wrapperPath;
+}
+
+function createExecutableScript(contents: string): string {
+	const dir = mkdtempSync(join(tmpdir(), "cline-bin-wrapper-"));
+	const scriptPath = join(dir, "child.js");
+	writeFileSync(scriptPath, `#!/usr/bin/env node\n${contents}`);
+	chmodSync(scriptPath, 0o755);
+	return scriptPath;
+}
+
+function runWrapper(target: string, args: string[] = []) {
+	const wrapperPath = createWrapperCopy();
+	return spawnSync(process.execPath, [wrapperPath, ...args], {
+		env: {
+			...process.env,
+			CLINE_BIN_PATH: target,
+		},
+		encoding: "utf8",
+	});
+}
+
+describe("bin/cline wrapper", () => {
+	it("preserves the child process exit status", () => {
+		const target = createExecutableScript(`
+process.exit(Number(process.argv[2] ?? "0"));
+`);
+
+		const result = runWrapper(target, ["7"]);
+
+		expect(result.error).toBeUndefined();
+		expect(result.status).toBe(7);
+		expect(result.signal).toBeNull();
+	});
+
+	it("passes the wrapper path to the compiled binary", () => {
+		const target = createExecutableScript(`
+console.log(process.env.CLINE_WRAPPER_PATH ?? "");
+`);
+
+		const result = runWrapper(target);
+
+		expect(result.error).toBeUndefined();
+		expect(result.status).toBe(0);
+		expect(result.stdout.trim()).toMatch(/bin[/\\]cline$/);
+	});
+
+	it.skipIf(process.platform === "win32")(
+		"propagates child process signal termination on POSIX",
+		() => {
+			const target = createExecutableScript(`
+process.kill(process.pid, "SIGTERM");
+setTimeout(() => {}, 1000);
+`);
+
+			const result = runWrapper(target);
+
+			expect(result.error).toBeUndefined();
+			expect(result.status).toBeNull();
+			expect(result.signal).toBe("SIGTERM");
+		},
+	);
+});
diff --git a/apps/cli/src/commands/build-options.test.ts b/apps/cli/src/commands/build-options.test.ts
new file mode 100644
index 0000000..785b405
--- /dev/null
+++ b/apps/cli/src/commands/build-options.test.ts
@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import {
+	parseBuildOptions,
+	shouldInstallNativeVariants,
+	validateBuildOptions,
+} from "../../script/build-options";
+
+describe("CLI build options", () => {
+	it("does not install native variants during single-platform builds by default", () => {
+		const options = parseBuildOptions(["--single"]);
+
+		expect(options.single).toBe(true);
+		expect(
+			shouldInstallNativeVariants({
+				options,
+				opentuiVersion: "0.1.102",
+			}),
+		).toBe(false);
+		expect(
+			validateBuildOptions({
+				options,
+				opentuiVersion: "0.1.102",
+				targetCount: 1,
+			}),
+		).toBeUndefined();
+	});
+
+	it("requires explicit native variant install for cross-platform OpenTUI builds", () => {
+		const options = parseBuildOptions([]);
+
+		expect(
+			validateBuildOptions({
+				options,
+				opentuiVersion: "0.1.102",
+				targetCount: 6,
+			}),
+		).toContain("--install-native-variants");
+	});
+
+	it("allows cross-platform builds to opt into native variant installation", () => {
+		const options = parseBuildOptions(["--install-native-variants"]);
+
+		expect(
+			shouldInstallNativeVariants({
+				options,
+				opentuiVersion: "0.1.102",
+			}),
+		).toBe(true);
+		expect(
+			validateBuildOptions({
+				options,
+				opentuiVersion: "0.1.102",
+				targetCount: 6,
+			}),
+		).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/commands/config.ts b/apps/cli/src/commands/config.ts
new file mode 100644
index 0000000..e8b74b9
--- /dev/null
+++ b/apps/cli/src/commands/config.ts
@@ -0,0 +1,536 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, extname, join } from "node:path";
+import {
+	type BuiltinToolAvailabilityContext,
+	createUserInstructionConfigService,
+	discoverPluginModulePaths,
+	hasMcpSettingsFile,
+	listHookConfigFiles,
+	listPluginTools,
+	type RuleConfig,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+	resolvePluginConfigSearchPaths,
+	type SkillConfig,
+	type WorkflowConfig,
+} from "@cline/core";
+import { Command } from "commander";
+import { getToolCatalog } from "../runtime/tools";
+import { loadInteractiveConfigData } from "../tui/interactive-config";
+import type { CliOutputMode } from "../utils/types";
+
+type ConfigIo = {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+};
+
+function resolveCliAgentConfigSearchPaths(cwd: string): string[] {
+	const clineDir = process.env.CLINE_DIR?.trim() || join(homedir(), ".cline");
+	return [join(cwd, ".cline", "agents"), join(clineDir, "agents")];
+}
+
+function createConfigUserInstructionService(cwd: string) {
+	return createUserInstructionConfigService({
+		skills: {
+			workspacePath: cwd,
+			includePluginSkills: true,
+			cwd,
+		},
+		rules: { workspacePath: cwd },
+		workflows: { workspacePath: cwd },
+	});
+}
+
+async function runWorkflowsConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const workflowsById = new Map<
+		string,
+		{ id: string; name: string; instructions: string; path: string }
+	>();
+	const service = createConfigUserInstructionService(cwd);
+	try {
+		await service.start();
+		for (const record of service.listRecords<WorkflowConfig>("workflow")) {
+			const workflow = record.item;
+			if (workflow.disabled === true || workflowsById.has(record.id)) {
+				continue;
+			}
+			workflowsById.set(record.id, {
+				id: record.id,
+				name: workflow.name,
+				instructions: workflow.instructions,
+				path: record.filePath,
+			});
+		}
+	} catch {
+		// Best-effort listing across config roots.
+	} finally {
+		service.stop();
+	}
+	const workflows = [...workflowsById.values()].sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
+	if (outputMode === "json") {
+		process.stdout.write(JSON.stringify(workflows));
+		return 0;
+	}
+	if (workflows.length === 0) {
+		io.writeln("No enabled workflows found.");
+		return 0;
+	}
+	io.writeln("Available workflows:");
+	for (const workflow of workflows) {
+		io.writeln(`  /${workflow.name} (${workflow.path})`);
+	}
+	return 0;
+}
+
+async function runRulesConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const rulesByName = new Map<
+		string,
+		{ name: string; instructions: string; path: string }
+	>();
+	const service = createConfigUserInstructionService(cwd);
+	try {
+		await service.start();
+		for (const record of service.listRecords<RuleConfig>("rule")) {
+			const rule = record.item;
+			if (rule.disabled === true || rulesByName.has(rule.name)) {
+				continue;
+			}
+			rulesByName.set(rule.name, {
+				name: rule.name,
+				instructions: rule.instructions,
+				path: record.filePath,
+			});
+		}
+	} catch {
+		// Best-effort listing across config roots.
+	} finally {
+		service.stop();
+	}
+	const rules = [...rulesByName.values()].sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
+	if (outputMode === "json") {
+		process.stdout.write(JSON.stringify(rules));
+		return 0;
+	}
+	if (rules.length === 0) {
+		io.writeln("No enabled rules found.");
+		return 0;
+	}
+	io.writeln("Enabled rules:");
+	for (const rule of rules) {
+		io.writeln(`  ${rule.name} (${rule.path})`);
+	}
+	return 0;
+}
+
+async function runSkillsConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const skillsByName = new Map<
+		string,
+		SkillConfig & {
+			path: string;
+		}
+	>();
+	const service = createConfigUserInstructionService(cwd);
+	try {
+		await service.start();
+		for (const record of service.listRecords<SkillConfig>("skill")) {
+			const skill = record.item;
+			if (skill.disabled === true || skillsByName.has(skill.name)) {
+				continue;
+			}
+			skillsByName.set(skill.name, {
+				...skill,
+				path: record.filePath,
+			});
+		}
+	} catch {
+		// Best-effort listing across config roots.
+	} finally {
+		service.stop();
+	}
+	const skills = [...skillsByName.values()].sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
+	if (outputMode === "json") {
+		process.stdout.write(JSON.stringify(skills));
+		return 0;
+	}
+	if (skills.length === 0) {
+		io.writeln("No enabled skills found.");
+		return 0;
+	}
+	io.writeln("Enabled skills:");
+	for (const skill of skills) {
+		io.writeln(`  ${skill.name} (${skill.path})`);
+	}
+	return 0;
+}
+
+async function runAgentsConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const agentsById = new Map<
+		string,
+		{
+			name: string;
+			path: string;
+		}
+	>();
+	const directories = resolveCliAgentConfigSearchPaths(cwd).filter(
+		(directory) => existsSync(directory),
+	);
+	for (const directory of directories) {
+		try {
+			const entries = readdirSync(directory, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isFile()) {
+					continue;
+				}
+				const extension = extname(entry.name).toLowerCase();
+				if (extension !== ".yml" && extension !== ".yaml") {
+					continue;
+				}
+				const filePath = join(directory, entry.name);
+				const raw = readFileSync(filePath, "utf8");
+				const frontmatterMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+				const frontmatter = frontmatterMatch?.[1] ?? "";
+				const nameMatch = frontmatter.match(/^\s*name:\s*(.+?)\s*$/m);
+				const parsedName = nameMatch?.[1]?.replace(/^["']|["']$/g, "").trim();
+				const name =
+					parsedName && parsedName.length > 0
+						? parsedName
+						: basename(entry.name, extension);
+				const id = name.toLowerCase();
+				if (agentsById.has(id)) {
+					continue;
+				}
+				agentsById.set(id, { name, path: filePath });
+			}
+		} catch {
+			// Best-effort listing across config roots.
+		}
+	}
+
+	const agents = [...agentsById.values()].sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
+	if (outputMode === "json") {
+		process.stdout.write(JSON.stringify(agents));
+		return 0;
+	}
+	if (agents.length === 0) {
+		io.writeln("No configured agents found.");
+		return 0;
+	}
+	io.writeln("Configured agents:");
+	for (const agent of agents) {
+		io.writeln(`  ${agent.name} (${agent.path})`);
+	}
+	return 0;
+}
+
+async function runPluginsConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const pluginsByPath = new Map<
+		string,
+		{
+			name: string;
+			path: string;
+		}
+	>();
+	const directories = resolvePluginConfigSearchPaths(cwd).filter((directory) =>
+		existsSync(directory),
+	);
+	for (const directory of directories) {
+		try {
+			for (const filePath of discoverPluginModulePaths(directory)) {
+				if (pluginsByPath.has(filePath)) {
+					continue;
+				}
+				pluginsByPath.set(filePath, {
+					name: basename(filePath, extname(filePath)),
+					path: filePath,
+				});
+			}
+		} catch {
+			// Best-effort listing across config roots.
+		}
+	}
+
+	const plugins = [...pluginsByPath.values()].sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
+	if (outputMode === "json") {
+		process.stdout.write(JSON.stringify(plugins));
+		return 0;
+	}
+	if (plugins.length === 0) {
+		io.writeln("No plugins found.");
+		return 0;
+	}
+	io.writeln("Discovered plugins:");
+	for (const plugin of plugins) {
+		io.writeln(`  ${plugin.name} (${plugin.path})`);
+	}
+	return 0;
+}
+
+async function runHooksConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const hooks = listHookConfigFiles(cwd);
+	if (outputMode === "json") {
+		process.stdout.write(JSON.stringify(hooks));
+		return 0;
+	}
+	if (hooks.length === 0) {
+		io.writeln("No hook files found.");
+		return 0;
+	}
+	io.writeln("Hook files:");
+	for (const item of hooks) {
+		const mapped = item.hookEventName ? ` -> ${item.hookEventName}` : "";
+		io.writeln(`  ${item.fileName}${mapped} (${item.path})`);
+	}
+	return 0;
+}
+
+async function runMcpConfigCommand(
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+): Promise<number> {
+	const settingsPath = resolveDefaultMcpSettingsPath();
+	if (!hasMcpSettingsFile({ filePath: settingsPath })) {
+		if (outputMode === "json") {
+			process.stdout.write(JSON.stringify([]));
+			return 0;
+		}
+		io.writeln(`No MCP settings file found at ${settingsPath}`);
+		return 0;
+	}
+
+	try {
+		const servers = resolveMcpServerRegistrations({ filePath: settingsPath })
+			.map((registration) => ({
+				name: registration.name,
+				transportType: registration.transport.type,
+				disabled: registration.disabled === true,
+				path: settingsPath,
+			}))
+			.sort((a, b) => a.name.localeCompare(b.name));
+
+		if (outputMode === "json") {
+			process.stdout.write(JSON.stringify(servers));
+			return 0;
+		}
+		if (servers.length === 0) {
+			io.writeln(`No MCP servers configured in ${settingsPath}`);
+			return 0;
+		}
+		io.writeln(`Configured MCP servers (${settingsPath}):`);
+		for (const server of servers) {
+			const disabledSuffix = server.disabled ? " (disabled)" : "";
+			io.writeln(`  ${server.name} [${server.transportType}]${disabledSuffix}`);
+		}
+		return 0;
+	} catch (error) {
+		io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+
+async function runToolsConfigCommand(
+	cwd: string,
+	outputMode: CliOutputMode,
+	io: ConfigIo,
+	availabilityContext?: BuiltinToolAvailabilityContext,
+): Promise<number> {
+	const tools = getToolCatalog(availabilityContext);
+	const pluginTools = await listPluginTools({
+		workspacePath: cwd,
+		cwd,
+	});
+
+	if (outputMode === "json") {
+		process.stdout.write(
+			JSON.stringify([
+				...tools,
+				...pluginTools.map((tool) => ({
+					name: tool.name,
+					type: "plugin" as const,
+					pluginName: tool.pluginName,
+					path: tool.path,
+					source: tool.source,
+					enabled: tool.enabled,
+					description: tool.description,
+				})),
+			]),
+		);
+		return 0;
+	}
+	if (tools.length === 0 && pluginTools.length === 0) {
+		io.writeln("No tools found.");
+		return 0;
+	}
+	io.writeln("Available tools:");
+	for (const tool of tools) {
+		const state = tool.defaultEnabled ? "enabled" : "disabled";
+		const names =
+			tool.headlessToolNames.length === 1 &&
+			tool.headlessToolNames[0] === tool.id
+				? ""
+				: ` -> ${tool.headlessToolNames.join(", ")}`;
+		io.writeln(`  ${tool.id} [${state}]${names}`);
+	}
+	if (pluginTools.length > 0) {
+		io.writeln();
+		io.writeln("Plugin tools:");
+		for (const tool of pluginTools) {
+			io.writeln(
+				`  ${tool.name} [plugin: ${tool.pluginName}] [${tool.enabled ? "enabled" : "disabled"}] (${tool.path})`,
+			);
+		}
+	}
+	return 0;
+}
+
+async function loadInteractiveConfigDataForCommand(
+	cwd: string,
+): Promise<Awaited<ReturnType<typeof loadInteractiveConfigData>>> {
+	const userInstructionService = createConfigUserInstructionService(cwd);
+	try {
+		await userInstructionService.start();
+		return await loadInteractiveConfigData({
+			userInstructionService,
+			cwd,
+			workspaceRoot: cwd,
+			availabilityContext: {
+				mode: "act",
+			},
+		});
+	} finally {
+		userInstructionService.stop();
+	}
+}
+
+export function createConfigCommand(
+	getCwd: () => string,
+	getOutputMode: () => CliOutputMode,
+	io: ConfigIo,
+	setExitCode: (code: number) => void,
+	launchInteractiveConfigView: () => void,
+): Command {
+	let actionExitCode: number | undefined;
+
+	const config = new Command("config")
+		.description("Show current configuration")
+		.argument("[target]")
+		.option("--json", "Output as JSON")
+		.option("--config <dir>", "configuration directory")
+		.exitOverride()
+		.action(async (target?: string) => {
+			if (!target) {
+				if (getOutputMode() === "json") {
+					process.stdout.write(
+						`${JSON.stringify(await loadInteractiveConfigDataForCommand(getCwd()))}\n`,
+					);
+					actionExitCode = 0;
+					return;
+				}
+				actionExitCode = undefined;
+				launchInteractiveConfigView();
+				return;
+			}
+
+			switch (target) {
+				case "workflows":
+					actionExitCode = await runWorkflowsConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+					);
+					break;
+				case "rules":
+					actionExitCode = await runRulesConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+					);
+					break;
+				case "skills":
+					actionExitCode = await runSkillsConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+					);
+					break;
+				case "agents":
+					actionExitCode = await runAgentsConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+					);
+					break;
+				case "plugins":
+					actionExitCode = await runPluginsConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+					);
+					break;
+				case "hooks":
+					actionExitCode = await runHooksConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+					);
+					break;
+				case "mcp":
+					actionExitCode = await runMcpConfigCommand(getOutputMode(), io);
+					break;
+				case "tools":
+					actionExitCode = await runToolsConfigCommand(
+						getCwd(),
+						getOutputMode(),
+						io,
+						{ mode: "act" },
+					);
+					break;
+				default:
+					io.writeErr(
+						`config requires one of: workflows, rules, skills, agents, plugins, hooks, mcp, tools (got "${target}")`,
+					);
+					actionExitCode = 1;
+			}
+		})
+		.hook("postAction", () => {
+			if (typeof actionExitCode === "number") {
+				setExitCode(actionExitCode);
+			}
+		});
+
+	return config;
+}
diff --git a/apps/cli/src/commands/connect.ts b/apps/cli/src/commands/connect.ts
new file mode 100644
index 0000000..d88725f
--- /dev/null
+++ b/apps/cli/src/commands/connect.ts
@@ -0,0 +1,78 @@
+import { getConnector, listConnectors } from "../connectors/registry";
+import type { ConnectIo, ConnectStopResult } from "../connectors/types";
+
+export async function stopAllConnectors(
+	io: ConnectIo,
+): Promise<ConnectStopResult & { executed: number }> {
+	let stoppedProcesses = 0;
+	let stoppedSessions = 0;
+	let executed = 0;
+	for (const entry of listConnectors()) {
+		const connector = await getConnector(entry.name);
+		if (!connector) {
+			continue;
+		}
+		if (!connector.stopAll) {
+			continue;
+		}
+		executed += 1;
+		const result = await connector.stopAll(io);
+		stoppedProcesses += result.stoppedProcesses;
+		stoppedSessions += result.stoppedSessions;
+	}
+	return { stoppedProcesses, stoppedSessions, executed };
+}
+
+export async function runStopAllConnectors(io: ConnectIo): Promise<number> {
+	const { stoppedProcesses, stoppedSessions, executed } =
+		await stopAllConnectors(io);
+	if (executed === 0) {
+		io.writeln("[connect] no adapters support stop yet");
+		return 0;
+	}
+	io.writeln(
+		`[connect] stopped processes=${stoppedProcesses} sessions=${stoppedSessions}`,
+	);
+	return 0;
+}
+
+export async function runStopConnector(
+	adapterName: string,
+	io: ConnectIo,
+): Promise<number> {
+	const connector = await getConnector(adapterName);
+	if (!connector) {
+		io.writeErr(`unknown connect adapter "${adapterName}"`);
+		return 1;
+	}
+	if (!connector.stopAll) {
+		io.writeErr(`connect adapter "${adapterName}" does not support stop`);
+		return 1;
+	}
+	const result: ConnectStopResult = await connector.stopAll(io);
+	io.writeln(
+		`[connect] ${connector.name} stopped processes=${result.stoppedProcesses} sessions=${result.stoppedSessions}`,
+	);
+	return 0;
+}
+
+export async function runConnectAdapter(
+	adapterName: string,
+	passthroughArgs: string[],
+	io: ConnectIo,
+): Promise<number> {
+	const connector = await getConnector(adapterName);
+	if (!connector) {
+		io.writeErr(`unknown connect adapter "${adapterName}"`);
+		return 1;
+	}
+	return connector.run(passthroughArgs, io);
+}
+
+export function formatAdapterList(): string {
+	const lines: string[] = [];
+	for (const connector of listConnectors()) {
+		lines.push(`  ${connector.name.padEnd(12)} ${connector.description}`);
+	}
+	return lines.join("\n");
+}
diff --git a/apps/cli/src/commands/dashboard.test.ts b/apps/cli/src/commands/dashboard.test.ts
new file mode 100644
index 0000000..387fc33
--- /dev/null
+++ b/apps/cli/src/commands/dashboard.test.ts
@@ -0,0 +1,208 @@
+import { mkdirSync, mkdtempSync } from "node:fs";
+import { arch, platform, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { runDashboardCommand, waitForProcessShutdown } from "./dashboard";
+
+const ENV_KEYS = [
+	"WORKSPACE_ROOT",
+	"CLINE_DIR",
+	"CLINE_SANDBOX",
+	"CLINE_SANDBOX_DATA_DIR",
+	"CLINE_DATA_DIR",
+	"CLINE_DB_DATA_DIR",
+	"CLINE_SESSION_DATA_DIR",
+	"CLINE_TEAM_DATA_DIR",
+	"CLINE_PROVIDER_SETTINGS_PATH",
+	"CLINE_HOOKS_LOG_PATH",
+	"HOST",
+	"CLINE_HUB_DASHBOARD_PORT",
+	"PUBLIC_URL",
+	"ROOM_SECRET",
+	"CLINE_HUB_WEBVIEW_DIST_DIR",
+	"CLINE_WRAPPER_PATH",
+] as const;
+
+const originalEnv = Object.fromEntries(
+	ENV_KEYS.map((key) => [key, process.env[key]]),
+);
+
+afterEach(() => {
+	for (const key of ENV_KEYS) {
+		const value = originalEnv[key];
+		if (value === undefined) {
+			delete process.env[key];
+		} else {
+			process.env[key] = value;
+		}
+	}
+});
+
+describe("runDashboardCommand", () => {
+	it("starts the dashboard server, opens the invite URL, and waits for shutdown", async () => {
+		const output: string[] = [];
+		const errors: string[] = [];
+		const opened: string[] = [];
+		const stop = vi.fn();
+		let observedEnv:
+			| {
+					workspaceRoot: string | undefined;
+					clineDir: string | undefined;
+					clineDataDir: string | undefined;
+					providerSettingsPath: string | undefined;
+					host: string | undefined;
+					port: string | undefined;
+					publicUrl: string | undefined;
+					roomSecret: string | undefined;
+					webviewDistDir: string | undefined;
+			  }
+			| undefined;
+		const webviewDistDir = mkdtempSync(join(tmpdir(), "cline-webview-dist-"));
+		mkdirSync(webviewDistDir, { recursive: true });
+		process.env.CLINE_HUB_WEBVIEW_DIST_DIR = webviewDistDir;
+
+		const exitCode = await runDashboardCommand({
+			configDir: "/tmp/cline-config",
+			cwd: "sdk",
+			dataDir: ".cline-dashboard-data",
+			host: "127.0.0.1",
+			port: "9090",
+			publicUrl: "http://127.0.0.1:9090",
+			roomSecret: "secret",
+			io: {
+				writeln: (text) => output.push(text ?? ""),
+				writeErr: (text) => errors.push(text),
+			},
+			startServer: async () => {
+				observedEnv = {
+					workspaceRoot: process.env.WORKSPACE_ROOT,
+					clineDir: process.env.CLINE_DIR,
+					clineDataDir: process.env.CLINE_DATA_DIR,
+					providerSettingsPath: process.env.CLINE_PROVIDER_SETTINGS_PATH,
+					host: process.env.HOST,
+					port: process.env.CLINE_HUB_DASHBOARD_PORT,
+					publicUrl: process.env.PUBLIC_URL,
+					roomSecret: process.env.ROOM_SECRET,
+					webviewDistDir: process.env.CLINE_HUB_WEBVIEW_DIST_DIR,
+				};
+				return {
+					listenUrl: "http://127.0.0.1:9090/",
+					publicUrl: "http://127.0.0.1:9090",
+					inviteUrl: "http://127.0.0.1:9090/?roomSecret=secret",
+					hubUrl: "ws://127.0.0.1:25463/hub",
+					stop,
+				};
+			},
+			openUrl: async (url) => {
+				opened.push(url);
+			},
+			waitForShutdown: async (server) => {
+				await server.stop();
+			},
+		});
+
+		expect(exitCode).toBe(0);
+		expect(observedEnv).toEqual({
+			workspaceRoot: resolve("sdk"),
+			clineDir: "/tmp/cline-config",
+			clineDataDir: resolve("sdk", ".cline-dashboard-data"),
+			providerSettingsPath: join(
+				resolve("sdk", ".cline-dashboard-data"),
+				"settings",
+				"providers.json",
+			),
+			host: "127.0.0.1",
+			port: "9090",
+			publicUrl: "http://127.0.0.1:9090",
+			roomSecret: "secret",
+			webviewDistDir,
+		});
+		expect(opened).toEqual(["http://127.0.0.1:9090/?roomSecret=secret"]);
+		expect(stop).toHaveBeenCalledTimes(1);
+		expect(output.join("\n")).toContain("Cline dashboard listening at");
+		expect(output.join("\n")).toContain("ws://127.0.0.1:25463/hub");
+		expect(errors).toEqual([]);
+		expect(process.env.WORKSPACE_ROOT).toBe(originalEnv.WORKSPACE_ROOT);
+		expect(process.env.CLINE_HUB_WEBVIEW_DIST_DIR).toBe(webviewDistDir);
+	});
+
+	it("honors --no-open behavior", async () => {
+		const openUrl = vi.fn();
+
+		const exitCode = await runDashboardCommand({
+			openBrowser: false,
+			io: {
+				writeln: () => {},
+				writeErr: () => {},
+			},
+			startServer: async () => ({
+				listenUrl: "http://127.0.0.1:8787/",
+				publicUrl: "http://127.0.0.1:8787",
+				inviteUrl: "http://127.0.0.1:8787",
+				stop: vi.fn(),
+			}),
+			openUrl,
+			waitForShutdown: async () => {},
+		});
+
+		expect(exitCode).toBe(0);
+		expect(openUrl).not.toHaveBeenCalled();
+	});
+
+	it("finds webview assets from the published wrapper package layout", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-wrapper-layout-"));
+		const wrapperPath = join(root, "node_modules", "cline", "bin", "cline");
+		const platformName = platform() === "win32" ? "windows" : platform();
+		const webviewDistDir = join(
+			root,
+			"node_modules",
+			"cline",
+			"node_modules",
+			"@cline",
+			`cli-${platformName}-${arch()}`,
+			"cline-hub",
+			"webview",
+		);
+		mkdirSync(join(wrapperPath, ".."), { recursive: true });
+		mkdirSync(webviewDistDir, { recursive: true });
+		process.env.CLINE_WRAPPER_PATH = wrapperPath;
+		delete process.env.CLINE_HUB_WEBVIEW_DIST_DIR;
+		let observedWebviewDistDir: string | undefined;
+
+		const exitCode = await runDashboardCommand({
+			openBrowser: false,
+			io: {
+				writeln: () => {},
+				writeErr: () => {},
+			},
+			startServer: async () => {
+				observedWebviewDistDir = process.env.CLINE_HUB_WEBVIEW_DIST_DIR;
+				return {
+					listenUrl: "http://127.0.0.1:8787/",
+					publicUrl: "http://127.0.0.1:8787",
+					inviteUrl: "http://127.0.0.1:8787",
+					stop: vi.fn(),
+				};
+			},
+			waitForShutdown: async () => {},
+		});
+
+		expect(exitCode).toBe(0);
+		expect(observedWebviewDistDir).toBe(webviewDistDir);
+	});
+
+	it("settles shutdown when server stop rejects", async () => {
+		const shutdown = waitForProcessShutdown({
+			listenUrl: "http://127.0.0.1:8787/",
+			publicUrl: "http://127.0.0.1:8787",
+			inviteUrl: "http://127.0.0.1:8787",
+			stop: vi.fn(async () => {
+				throw new Error("stop failed");
+			}),
+		});
+
+		process.emit("SIGINT", "SIGINT");
+
+		await expect(shutdown).rejects.toThrow("stop failed");
+	});
+});
diff --git a/apps/cli/src/commands/dashboard.ts b/apps/cli/src/commands/dashboard.ts
new file mode 100644
index 0000000..c85ec53
--- /dev/null
+++ b/apps/cli/src/commands/dashboard.ts
@@ -0,0 +1,215 @@
+import { existsSync } from "node:fs";
+import { arch, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import open from "open";
+import { configureSandboxEnvironment } from "../utils/helpers";
+import { c } from "../utils/output";
+
+export interface DashboardServerHandle {
+	listenUrl: string;
+	publicUrl: string;
+	inviteUrl: string;
+	hubUrl?: string;
+	stop: () => void | Promise<void>;
+}
+
+interface DashboardCommandIo {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+}
+
+export interface RunDashboardCommandOptions {
+	configDir?: string;
+	cwd?: string;
+	dataDir?: string;
+	host?: string;
+	port?: string;
+	publicUrl?: string;
+	roomSecret?: string;
+	openBrowser?: boolean;
+	io: DashboardCommandIo;
+	startServer?: () => Promise<DashboardServerHandle>;
+	openUrl?: (url: string) => Promise<void>;
+	waitForShutdown?: (server: DashboardServerHandle) => Promise<void>;
+}
+
+const DASHBOARD_PORT_ENV = "CLINE_HUB_DASHBOARD_PORT";
+const WEBVIEW_DIST_ENV = "CLINE_HUB_WEBVIEW_DIST_DIR";
+
+function setEnvValue(name: string, value: string | undefined): () => void {
+	const previous = process.env[name];
+	if (value !== undefined) {
+		process.env[name] = value;
+	}
+	return () => {
+		if (previous === undefined) {
+			delete process.env[name];
+		} else {
+			process.env[name] = previous;
+		}
+	};
+}
+
+const SANDBOX_ENV_KEYS = [
+	"CLINE_SANDBOX",
+	"CLINE_SANDBOX_DATA_DIR",
+	"CLINE_DATA_DIR",
+	"CLINE_DB_DATA_DIR",
+	"CLINE_SESSION_DATA_DIR",
+	"CLINE_TEAM_DATA_DIR",
+	"CLINE_PROVIDER_SETTINGS_PATH",
+	"CLINE_HOOKS_LOG_PATH",
+] as const;
+
+async function withDashboardEnvironment<T>(
+	options: RunDashboardCommandOptions,
+	fn: () => Promise<T>,
+): Promise<T> {
+	const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
+	const restore = [
+		setEnvValue("WORKSPACE_ROOT", options.cwd ? cwd : undefined),
+		setEnvValue("CLINE_DIR", options.configDir?.trim() || undefined),
+		setEnvValue("HOST", options.host),
+		setEnvValue(DASHBOARD_PORT_ENV, options.port),
+		setEnvValue("PUBLIC_URL", options.publicUrl),
+		setEnvValue("ROOM_SECRET", options.roomSecret),
+		setEnvValue(WEBVIEW_DIST_ENV, resolveDefaultWebviewDistDir()),
+		...SANDBOX_ENV_KEYS.map((key) => setEnvValue(key, undefined)),
+	];
+	if (options.dataDir || process.env.CLINE_SANDBOX?.trim() === "1") {
+		configureSandboxEnvironment({
+			enabled: true,
+			cwd,
+			explicitDir: options.dataDir,
+		});
+	}
+	try {
+		return await fn();
+	} finally {
+		for (let i = restore.length - 1; i >= 0; i--) {
+			restore[i]?.();
+		}
+	}
+}
+
+function resolveDefaultWebviewDistDir(): string | undefined {
+	if (process.env[WEBVIEW_DIST_ENV]?.trim()) {
+		return undefined;
+	}
+
+	const moduleDir = dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		...resolveInstalledPlatformPackageWebviewCandidates(),
+		// Source checkout: apps/cli/src/commands/dashboard.ts
+		join(moduleDir, "../../../cline-hub/dist/webview"),
+		// Node bundle: apps/cli/dist/index.js
+		join(moduleDir, "cline-hub/webview"),
+		// Compiled platform package: apps/cli/dist/<platform>/bin/cline
+		join(dirname(process.execPath), "../cline-hub/webview"),
+	];
+
+	return candidates.find((candidate) => existsSync(candidate));
+}
+
+function resolveInstalledPlatformPackageWebviewCandidates(): string[] {
+	const packageName = resolvePlatformPackageName();
+	const starts = [
+		process.env.CLINE_WRAPPER_PATH
+			? dirname(process.env.CLINE_WRAPPER_PATH)
+			: undefined,
+		dirname(process.execPath),
+	].filter((value): value is string => !!value?.trim());
+	const candidates: string[] = [];
+	for (const start of starts) {
+		let current = start;
+		for (;;) {
+			candidates.push(
+				join(current, "node_modules", packageName, "cline-hub/webview"),
+			);
+			const parent = dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+	return candidates;
+}
+
+function resolvePlatformPackageName(): string {
+	const platformName = platform() === "win32" ? "windows" : platform();
+	return `@cline/cli-${platformName}-${arch()}`;
+}
+
+async function startDefaultDashboardServer(): Promise<DashboardServerHandle> {
+	const { startClineHubDashboardServer } = await import("@cline/cline-hub");
+	return await startClineHubDashboardServer();
+}
+
+async function openDefaultUrl(url: string): Promise<void> {
+	await open(url, { wait: false });
+}
+
+export function waitForProcessShutdown(
+	server: DashboardServerHandle,
+): Promise<void> {
+	return new Promise<void>((resolveShutdown, rejectShutdown) => {
+		let settled = false;
+
+		const cleanup = () => {
+			process.off("SIGINT", handleSignal);
+			process.off("SIGTERM", handleSignal);
+		};
+
+		const stop = async () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			try {
+				await server.stop();
+				resolveShutdown();
+			} catch (error) {
+				rejectShutdown(error);
+			}
+		};
+
+		function handleSignal() {
+			void stop();
+		}
+
+		process.on("SIGINT", handleSignal);
+		process.on("SIGTERM", handleSignal);
+	});
+}
+
+export async function runDashboardCommand(
+	options: RunDashboardCommandOptions,
+): Promise<number> {
+	try {
+		const server = await withDashboardEnvironment(options, () =>
+			(options.startServer ?? startDefaultDashboardServer)(),
+		);
+		const dashboardUrl =
+			server.inviteUrl || server.publicUrl || server.listenUrl;
+		options.io.writeln(
+			`${c.green}Cline dashboard listening at${c.reset} ${dashboardUrl}`,
+		);
+		if (server.hubUrl) {
+			options.io.writeln(`${c.dim}Hub endpoint: ${server.hubUrl}${c.reset}`);
+		}
+
+		if (options.openBrowser !== false) {
+			try {
+				await (options.openUrl ?? openDefaultUrl)(dashboardUrl);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				options.io.writeErr(`Failed to open browser: ${message}`);
+			}
+		}
+
+		await (options.waitForShutdown ?? waitForProcessShutdown)(server);
+		return 0;
+	} catch (error) {
+		options.io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
diff --git a/apps/cli/src/commands/distribution-package.test.ts b/apps/cli/src/commands/distribution-package.test.ts
new file mode 100644
index 0000000..b5c825e
--- /dev/null
+++ b/apps/cli/src/commands/distribution-package.test.ts
@@ -0,0 +1,94 @@
+import { spawnSync } from "node:child_process";
+import {
+	chmod,
+	mkdir,
+	mkdtemp,
+	readdir,
+	rm,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+	DIRECT_PUBLISH_GUARD_MESSAGE,
+	shouldAllowDirectPublish,
+} from "../../script/guard-direct-publish";
+
+describe("CLI distribution package shape", () => {
+	it("rejects direct source package publishing by default", () => {
+		expect(shouldAllowDirectPublish({})).toBe(false);
+		expect(shouldAllowDirectPublish({ CLINE_ALLOW_DIRECT_PUBLISH: "1" })).toBe(
+			true,
+		);
+		expect(DIRECT_PUBLISH_GUARD_MESSAGE).toContain(
+			"Direct packaging or publishing from apps/cli is disabled.",
+		);
+	});
+
+	it("rejects direct source package packing by default", () => {
+		const cliRoot = fileURLToPath(new URL("../..", import.meta.url));
+
+		const result = spawnSync("bun", ["pm", "pack", "--dry-run"], {
+			cwd: cliRoot,
+			encoding: "utf8",
+		});
+
+		expect(result.status).not.toBe(0);
+		expect(result.stderr).toContain(DIRECT_PUBLISH_GUARD_MESSAGE);
+	});
+
+	it("packs the generated npm wrapper package", async () => {
+		const packageDir = await mkdtemp(join(tmpdir(), "cline-cli-pack-"));
+		try {
+			await mkdir(join(packageDir, "bin"), { recursive: true });
+			await writeFile(
+				join(packageDir, "package.json"),
+				`${JSON.stringify(
+					{
+						name: "cline",
+						version: "1.2.3",
+						description: "CLI test package",
+						license: "Apache-2.0",
+						bin: {
+							cline: "./bin/cline",
+						},
+						scripts: {
+							postinstall: "node ./postinstall.mjs || true",
+						},
+						optionalDependencies: {
+							"@cline/cli-linux-x64": "1.2.3",
+						},
+					},
+					null,
+					2,
+				)}\n`,
+			);
+			await writeFile(
+				join(packageDir, "bin", "cline"),
+				[
+					"#!/usr/bin/env node",
+					'console.log("cline wrapper smoke test");',
+					"",
+				].join("\n"),
+			);
+			await chmod(join(packageDir, "bin", "cline"), 0o755);
+			await writeFile(
+				join(packageDir, "postinstall.mjs"),
+				"process.exit(0);\n",
+			);
+
+			const result = spawnSync("bun", ["pm", "pack"], {
+				cwd: packageDir,
+				encoding: "utf8",
+			});
+
+			expect(result.status).toBe(0);
+			const files = await readdir(packageDir);
+			expect(files.some((file) => file.endsWith(".tgz"))).toBe(true);
+		} finally {
+			await rm(packageDir, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/apps/cli/src/commands/doctor.test.ts b/apps/cli/src/commands/doctor.test.ts
new file mode 100644
index 0000000..dd47c9e
--- /dev/null
+++ b/apps/cli/src/commands/doctor.test.ts
@@ -0,0 +1,411 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getCliBuildInfo } from "../utils/common";
+
+const {
+	mockSpawnSync,
+	mockResolveClineDataDir,
+	mockResolveProductionHubOwnerContext,
+	mockResolveSharedHubOwnerContext,
+	mockReadHubDiscovery,
+	mockProbeHubServer,
+	mockClearHubDiscovery,
+	mockStopLocalHubServerGracefully,
+	mockEnsureFileExists,
+	mockStopAllConnectors,
+} = vi.hoisted(() => ({
+	mockSpawnSync: vi.fn(),
+	mockResolveClineDataDir: vi.fn(() => "/tmp/cline-data"),
+	mockResolveProductionHubOwnerContext: vi.fn(() => ({
+		ownerId: "hub-production",
+		discoveryPath: path.join(
+			"/tmp/cline-data",
+			"locks",
+			"hub",
+			"production.json",
+		),
+	})),
+	mockResolveSharedHubOwnerContext: vi.fn(() => ({
+		ownerId: "hub-owner",
+		discoveryPath: path.join(
+			"/tmp/cline-data",
+			"locks",
+			"hub",
+			"owners",
+			"hub-owner.json",
+		),
+	})),
+	mockReadHubDiscovery: vi.fn(),
+	mockProbeHubServer: vi.fn(),
+	mockClearHubDiscovery: vi.fn(),
+	mockStopLocalHubServerGracefully: vi.fn(async () => false),
+	mockEnsureFileExists: vi.fn(),
+	mockStopAllConnectors: vi.fn(async () => ({
+		stoppedProcesses: 0,
+		stoppedSessions: 0,
+		executed: 0,
+	})),
+}));
+
+vi.mock("node:child_process", () => ({
+	spawnSync: mockSpawnSync,
+}));
+
+vi.mock("@cline/core", () => ({
+	resolveClineDataDir: mockResolveClineDataDir,
+	resolveProductionHubOwnerContext: mockResolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext: mockResolveSharedHubOwnerContext,
+	clearHubDiscovery: mockClearHubDiscovery,
+	probeHubServer: mockProbeHubServer,
+	readHubDiscovery: mockReadHubDiscovery,
+	stopLocalHubServerGracefully: mockStopLocalHubServerGracefully,
+	ensureFileExists: mockEnsureFileExists,
+}));
+
+vi.mock("../connectors/common", () => ({
+	isProcessRunning: vi.fn(() => false),
+}));
+
+vi.mock("./connect", () => ({
+	stopAllConnectors: mockStopAllConnectors,
+}));
+
+import { createDoctorCommand, runDoctorCommand } from "./doctor";
+
+describe("runDoctorCommand", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		vi.clearAllMocks();
+		mockResolveClineDataDir.mockReturnValue("/tmp/cline-data");
+		mockResolveProductionHubOwnerContext.mockReturnValue({
+			ownerId: "hub-production",
+			discoveryPath: path.join(
+				"/tmp/cline-data",
+				"locks",
+				"hub",
+				"production.json",
+			),
+		});
+		mockStopLocalHubServerGracefully.mockResolvedValue(false);
+		mockStopAllConnectors.mockResolvedValue({
+			stoppedProcesses: 0,
+			stoppedSessions: 0,
+			executed: 0,
+		});
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not report hub processes as stale cli processes", async () => {
+		const cwd = "/workspace";
+		mockReadHubDiscovery.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			port: 25463,
+			pid: 50174,
+		});
+		mockProbeHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			port: 25463,
+			pid: 50174,
+		});
+		mockSpawnSync.mockImplementation((command: string, args?: string[]) => {
+			if (command === "lsof") {
+				return {
+					status: 0,
+					stdout: "50174\n",
+				};
+			}
+			if (
+				command === "pgrep" &&
+				Array.isArray(args) &&
+				args[0] === "-fal" &&
+				args[1] === "--" &&
+				args[2] === "/apps/cli/src/index.ts"
+			) {
+				return {
+					status: 0,
+					stdout: [
+						"50174 /Users/example/.bun/bin/bun /Users/example/dev/apps/cli/src/index.ts hub start --cwd /workspace",
+						"50190 /Users/example/.bun/bin/bun /Users/example/dev/apps/cli/src/index.ts hey",
+					].join("\n"),
+				};
+			}
+			return { status: 1, stdout: "" };
+		});
+
+		const output: string[] = [];
+		const code = await runDoctorCommand(
+			{ cwd, json: true },
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(output).toHaveLength(1);
+		expect(JSON.parse(output[0] || "")).toMatchObject(
+			process.platform === "win32"
+				? {
+						listeningPids: [],
+						hubStartupLocks: [],
+						staleCliPids: [],
+						staleSidecarPids: [],
+					}
+				: {
+						listeningPids: [50174],
+						hubStartupLocks: [],
+						staleCliPids: [50190],
+						staleSidecarPids: [],
+					},
+		);
+	});
+
+	it("doctor --fix clears wedged hub startup artifacts when no server is actually running", async () => {
+		const cwd = mkdtempSync(path.join(os.tmpdir(), "doctor-hub-fix-"));
+		tempDirs.push(cwd);
+		const discoveryPath = path.join(cwd, ".hub-discovery.json");
+		mockResolveSharedHubOwnerContext.mockReturnValue({
+			ownerId: "hub-owner",
+			discoveryPath,
+		});
+		mockReadHubDiscovery.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			port: 25463,
+			pid: 50000,
+		});
+		mockProbeHubServer.mockResolvedValue(undefined);
+		mockSpawnSync.mockReturnValue({ status: 1, stdout: "" });
+
+		const startupLockDir = `${discoveryPath}.lock`;
+		writeFileSync(
+			discoveryPath,
+			JSON.stringify({
+				url: "ws://127.0.0.1:25463/hub",
+				port: 25463,
+				pid: 50000,
+			}),
+			"utf8",
+		);
+		mkdirSync(startupLockDir, { recursive: true });
+		writeFileSync(
+			path.join(startupLockDir, "owner.json"),
+			JSON.stringify({
+				pid: process.pid,
+				acquiredAt: new Date().toISOString(),
+			}),
+			"utf8",
+		);
+
+		const output: string[] = [];
+		const code = await runDoctorCommand(
+			{ cwd, json: true, fix: true },
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(output).toHaveLength(1);
+		expect(JSON.parse(output[0] || "")).toMatchObject({
+			killed: {
+				hubListeners: 0,
+				cliProcesses: 0,
+				sidecarProcesses: 0,
+				hubStartupLocks: 1,
+				hubDiscovery: 1,
+			},
+			after: {
+				hubHealthy: false,
+				listeningPids: [],
+				hubStartupLocks: [],
+				staleSidecarPids: [],
+			},
+		});
+		expect(mockClearHubDiscovery).toHaveBeenCalledWith(discoveryPath);
+	});
+
+	it("doctor --fix stops connector adapters and reports counts in JSON", async () => {
+		const cwd = "/workspace";
+		mockReadHubDiscovery.mockResolvedValue(undefined);
+		mockProbeHubServer.mockResolvedValue(undefined);
+		mockSpawnSync.mockReturnValue({ status: 1, stdout: "" });
+		mockStopAllConnectors.mockResolvedValue({
+			stoppedProcesses: 2,
+			stoppedSessions: 5,
+			executed: 3,
+		});
+
+		const output: string[] = [];
+		const code = await runDoctorCommand(
+			{ cwd, json: true, fix: true },
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(mockStopAllConnectors).toHaveBeenCalledTimes(1);
+		expect(JSON.parse(output[0] || "")).toMatchObject({
+			killed: {
+				connectorProcesses: 2,
+				connectorSessions: 5,
+			},
+		});
+	});
+
+	it("doctor --fix kills stale code sidecar processes", async () => {
+		const cwd = "/workspace";
+		mockReadHubDiscovery.mockResolvedValue(undefined);
+		mockProbeHubServer.mockResolvedValue(undefined);
+		mockSpawnSync.mockImplementation((command: string, args?: string[]) => {
+			if (
+				command === "pgrep" &&
+				Array.isArray(args) &&
+				args[0] === "-fal" &&
+				args[1] === "--" &&
+				args[2] === "/src-tauri/bin/code-sidecar"
+			) {
+				return {
+					status: 0,
+					stdout:
+						"60123 /Users/example/dev/apps/examples/desktop-app/src-tauri/bin/code-sidecar\n",
+				};
+			}
+			return { status: 1, stdout: "" };
+		});
+		const killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
+
+		const output: string[] = [];
+		const code = await runDoctorCommand(
+			{ cwd, json: true, fix: true },
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(killSpy).toHaveBeenCalledWith(60123, "SIGKILL");
+		expect(JSON.parse(output[0] || "")).toMatchObject({
+			before: {
+				staleSidecarPids: [60123],
+			},
+			killed: {
+				sidecarProcesses: 1,
+			},
+		});
+		killSpy.mockRestore();
+	});
+});
+
+describe("createDoctorCommand log subcommand", () => {
+	const tempDirs: string[] = [];
+	const commandName = getCliBuildInfo().name;
+
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("opens the log file for doctor log", async () => {
+		const dataDir = mkdtempSync(
+			path.join(os.tmpdir(), `${commandName}-doctor-log-test-`),
+		);
+		tempDirs.push(dataDir);
+		mockResolveClineDataDir.mockReturnValue(dataDir);
+		mockEnsureFileExists.mockImplementation((filePath: string) => {
+			mkdirSync(path.dirname(filePath), { recursive: true });
+			appendFileSync(filePath, "");
+		});
+
+		const opened: string[] = [];
+		const output: string[] = [];
+		const errors: string[] = [];
+		let exitCode = 0;
+
+		const cmd = createDoctorCommand(
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: (text) => {
+					errors.push(text);
+				},
+			},
+			(code) => {
+				exitCode = code;
+			},
+			{
+				openPath: async (target) => {
+					opened.push(target);
+				},
+			},
+		);
+
+		await cmd.parseAsync(["log"], { from: "user" });
+
+		const expectedPath = path.join(dataDir, "logs", `${commandName}.log`);
+		expect(exitCode).toBe(0);
+		expect(errors).toHaveLength(0);
+		expect(opened).toEqual([expectedPath]);
+		expect(output).toEqual([`Opening logs stored at ${expectedPath}`]);
+		expect(existsSync(expectedPath)).toBe(true);
+	});
+
+	it("returns an error if opening log file fails", async () => {
+		const dataDir = mkdtempSync(
+			path.join(os.tmpdir(), `${commandName}-doctor-log-test-`),
+		);
+		tempDirs.push(dataDir);
+		mockResolveClineDataDir.mockReturnValue(dataDir);
+
+		const errors: string[] = [];
+		let exitCode = 0;
+
+		const cmd = createDoctorCommand(
+			{
+				writeln: () => {},
+				writeErr: (text) => {
+					errors.push(text);
+				},
+			},
+			(code) => {
+				exitCode = code;
+			},
+			{
+				openPath: async () => {
+					throw new Error("open failed");
+				},
+			},
+		);
+
+		await cmd.parseAsync(["log"], { from: "user" });
+
+		expect(exitCode).toBe(1);
+		expect(errors[0]).toContain("failed to open log file");
+		expect(errors[0]).toContain("open failed");
+	});
+});
diff --git a/apps/cli/src/commands/doctor.ts b/apps/cli/src/commands/doctor.ts
new file mode 100644
index 0000000..56b17ac
--- /dev/null
+++ b/apps/cli/src/commands/doctor.ts
@@ -0,0 +1,606 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	clearHubDiscovery,
+	ensureFileExists,
+	probeHubServer,
+	readHubDiscovery,
+	resolveClineDataDir,
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+	stopLocalHubServerGracefully,
+} from "@cline/core";
+import { formatUptime, resolveClineBuildEnv } from "@cline/shared";
+import { Command } from "commander";
+import open from "open";
+import { isProcessRunning } from "../connectors/common";
+import {
+	type ActiveConnectorRecord,
+	listActiveConnectors,
+} from "../connectors/status";
+import { getCliBuildInfo } from "../utils/common";
+import { c, writeln } from "../utils/output";
+import { stopAllConnectors } from "./connect";
+
+type DoctorIo = {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+};
+
+export type DoctorCommandDeps = {
+	openPath?: (target: string) => Promise<void> | void;
+};
+
+type StartupArtifact = {
+	path: string;
+	pid?: number;
+	acquiredAt?: string;
+	stale: boolean;
+};
+
+type SpawnedProcessRecord = {
+	timestamp?: string;
+	pid?: number;
+	command?: string;
+	component?: string;
+	detached?: boolean;
+};
+
+type DoctorStatus = {
+	cwd: string;
+	hubUrl?: string;
+	hubHealthy: boolean;
+	hubPid?: number;
+	hubStartedAt?: string;
+	hubUptime?: string;
+	listeningPids: number[];
+	staleHubPids: number[];
+	hubStartupLocks: StartupArtifact[];
+	staleCliPids: number[];
+	staleSidecarPids: number[];
+	activeConnectors: ActiveConnectorRecord[];
+	recentSpawnedProcesses: SpawnedProcessRecord[];
+};
+
+type ProcessRecord = {
+	pid: number;
+	command: string;
+};
+
+function parsePids(raw: string): number[] {
+	return raw
+		.split(/\r?\n/)
+		.map((line) => Number.parseInt(line.trim(), 10))
+		.filter((pid) => Number.isInteger(pid) && pid > 0);
+}
+
+function listMatchingProcesses(pattern: string): ProcessRecord[] {
+	if (process.platform === "win32") {
+		return [];
+	}
+	// "--" stops pgrep's option parsing so patterns that start with dashes
+	// (e.g. the "--cline-hub-daemon" marker) are treated as patterns.
+	const result = spawnSync("pgrep", ["-fal", "--", pattern], {
+		encoding: "utf8",
+	});
+	if (result.status !== 0 && result.status !== 1) {
+		return [];
+	}
+	const records = new Map<number, ProcessRecord>();
+	for (const line of (result.stdout || "").split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			continue;
+		}
+		const match = trimmed.match(/^(\d+)\s+(.*)$/);
+		if (!match) {
+			continue;
+		}
+		const pid = Number.parseInt(match[1] || "", 10);
+		const command = match[2]?.trim();
+		if (
+			!Number.isInteger(pid) ||
+			pid <= 0 ||
+			!command ||
+			pid === process.pid ||
+			pid === process.ppid
+		) {
+			continue;
+		}
+		records.set(pid, { pid, command });
+	}
+	return [...records.values()].sort((a, b) => a.pid - b.pid);
+}
+
+function resolveCliLogPath(): string {
+	const { name } = getCliBuildInfo();
+	return join(resolveClineDataDir(), "logs", `${name}.log`);
+}
+
+async function defaultOpenPath(target: string): Promise<void> {
+	await open(target, { wait: false });
+}
+
+function listListeningPids(port: number | undefined): number[] {
+	if (!port || process.platform === "win32") {
+		return [];
+	}
+	const result = spawnSync("lsof", ["-nP", `-tiTCP:${port}`, "-sTCP:LISTEN"], {
+		encoding: "utf8",
+	});
+	if (result.status !== 0) {
+		return [];
+	}
+	return parsePids(result.stdout);
+}
+
+function listStaleCliPids(): number[] {
+	const patterns = [
+		"/apps/cli/src/index.ts",
+		"/apps/cli/dist/index.js",
+		"/dist/cline",
+	];
+	const records = new Map<number, ProcessRecord>();
+	for (const pattern of patterns) {
+		for (const record of listMatchingProcesses(pattern)) {
+			records.set(record.pid, record);
+		}
+	}
+	return [...records.values()]
+		.filter(
+			(record) => !/(?:^|\s)(?:hub|rpc|connect)(?:\s|$)/.test(record.command),
+		)
+		.map((record) => record.pid);
+}
+
+function listStaleHubPids(currentHubPids: number[]): number[] {
+	const current = new Set(currentHubPids.filter((pid) => pid > 0));
+	const patterns = [
+		"/sdk/packages/core/src/hub/daemon/entry.ts",
+		"/sdk/packages/core/dist/hub/daemon/entry.js",
+		"--cline-hub-daemon",
+	];
+	const records = new Map<number, ProcessRecord>();
+	for (const pattern of patterns) {
+		for (const record of listMatchingProcesses(pattern)) {
+			if (current.has(record.pid) || /\bpgrep\s+-fal\b/.test(record.command)) {
+				continue;
+			}
+			records.set(record.pid, record);
+		}
+	}
+	return [...records.values()].map((record) => record.pid);
+}
+
+function listStaleSidecarPids(): number[] {
+	const patterns = [
+		"/apps/examples/desktop-app/sidecar/index.ts",
+		"/apps/examples/desktop-app/dist/sidecar/index.js",
+		// Keep the pre-example-reorg paths so `doctor --fix` can still clean up
+		// stale sidecars that were launched from older checkouts.
+		"/apps/code/sidecar/index.ts",
+		"/apps/code/dist/sidecar/index.js",
+		"/src-tauri/bin/code-sidecar",
+		"/Resources/code-sidecar",
+		" code-sidecar",
+	];
+	const records = new Map<number, ProcessRecord>();
+	for (const pattern of patterns) {
+		for (const record of listMatchingProcesses(pattern)) {
+			records.set(record.pid, record);
+		}
+	}
+	return [...records.values()].map((record) => record.pid);
+}
+
+function readRecentSpawnedProcesses(limit = 20): SpawnedProcessRecord[] {
+	const logPath = resolveCliLogPath();
+	if (!existsSync(logPath)) {
+		return [];
+	}
+	try {
+		const raw = readFileSync(logPath, "utf8");
+		const lines = raw
+			.split(/\r?\n/)
+			.map((line) => line.trim())
+			.filter(Boolean);
+		const records: SpawnedProcessRecord[] = [];
+		for (let index = lines.length - 1; index >= 0; index -= 1) {
+			try {
+				const parsed = JSON.parse(lines[index]) as Record<string, unknown>;
+				if (parsed.msg !== "Process spawned") {
+					continue;
+				}
+				records.push({
+					timestamp: typeof parsed.time === "string" ? parsed.time : undefined,
+					pid:
+						typeof parsed.childPid === "number" ? parsed.childPid : undefined,
+					command:
+						typeof parsed.command === "string" ? parsed.command : undefined,
+					component:
+						typeof parsed.component === "string" ? parsed.component : undefined,
+					detached:
+						typeof parsed.detached === "boolean" ? parsed.detached : undefined,
+				});
+			} catch {
+				// Ignore malformed lines.
+			}
+			if (records.length >= limit) {
+				break;
+			}
+		}
+		return records.reverse();
+	} catch {
+		return [];
+	}
+}
+
+function readStartupArtifact(path: string): StartupArtifact | undefined {
+	try {
+		const raw = JSON.parse(readFileSync(path, "utf8")) as Record<
+			string,
+			unknown
+		>;
+		const pid = typeof raw.pid === "number" ? raw.pid : undefined;
+		const acquiredAt =
+			typeof raw.acquiredAt === "string" ? raw.acquiredAt : undefined;
+		return {
+			path,
+			pid,
+			acquiredAt,
+			stale: !isProcessRunning(pid ?? -1),
+		};
+	} catch {
+		return {
+			path,
+			stale: true,
+		};
+	}
+}
+
+function listHubStartupLocks(_cwd: string): StartupArtifact[] {
+	const owner = resolveCliHubOwnerContext();
+	const ownerPath = join(`${owner.discoveryPath}.lock`, "owner.json");
+	if (!existsSync(ownerPath)) {
+		return [];
+	}
+	return [readStartupArtifact(ownerPath) ?? { path: ownerPath, stale: true }];
+}
+
+function clearPathIfExists(path: string): boolean {
+	if (!existsSync(path)) {
+		return false;
+	}
+	try {
+		rmSync(path, { recursive: true, force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function clearHubStartupArtifacts(
+	_cwd: string,
+	options?: { clearDiscovery?: boolean },
+): Promise<{ startupLocks: number; discovery: number }> {
+	const owner = resolveCliHubOwnerContext();
+	const startupLocks = listHubStartupLocks(_cwd);
+	let clearedStartupLocks = 0;
+	for (const artifact of startupLocks) {
+		if (artifact.stale && clearPathIfExists(dirname(artifact.path))) {
+			clearedStartupLocks += 1;
+		}
+	}
+	let clearedDiscovery = 0;
+	if (options?.clearDiscovery && existsSync(owner.discoveryPath)) {
+		await clearHubDiscovery(owner.discoveryPath);
+		clearedDiscovery = 1;
+	}
+	return {
+		startupLocks: clearedStartupLocks,
+		discovery: clearedDiscovery,
+	};
+}
+
+function formatHubUptimeFromStartedAt(
+	startedAt: string | undefined,
+): string | undefined {
+	if (!startedAt) {
+		return undefined;
+	}
+	const timestamp = Date.parse(startedAt);
+	if (Number.isNaN(timestamp)) {
+		return undefined;
+	}
+	return formatUptime(Date.now() - timestamp);
+}
+
+function resolveCliHubOwnerContext() {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+async function collectDoctorStatus(cwd: string): Promise<DoctorStatus> {
+	const owner = resolveCliHubOwnerContext();
+	const discovery = await readHubDiscovery(owner.discoveryPath);
+	const health = discovery?.url
+		? await probeHubServer(discovery.url, { authToken: discovery.authToken })
+		: undefined;
+	const current = health ?? discovery;
+	const hubUptime = formatHubUptimeFromStartedAt(health?.startedAt);
+	const listeningPids = listListeningPids(current?.port);
+	const currentHubPids = [
+		...(current?.pid ? [current.pid] : []),
+		...listeningPids,
+	];
+	return {
+		cwd,
+		hubUrl: current?.url,
+		hubHealthy: !!health?.url,
+		hubPid: current?.pid,
+		hubStartedAt: health?.startedAt,
+		hubUptime,
+		listeningPids,
+		staleHubPids: listStaleHubPids(currentHubPids),
+		hubStartupLocks: listHubStartupLocks(cwd),
+		staleCliPids: listStaleCliPids(),
+		staleSidecarPids: listStaleSidecarPids(),
+		activeConnectors: listActiveConnectors(),
+		recentSpawnedProcesses: readRecentSpawnedProcesses(),
+	};
+}
+
+function formatPidList(label: string, pids: number[]): string {
+	if (pids.length === 0) {
+		return `${label} ${c.dim}0${c.reset}`;
+	}
+	return `${label} ${c.dim}${pids.join(", ")}${c.reset}`;
+}
+
+function formatRecentSpawnedProcess(record: SpawnedProcessRecord): string {
+	const pieces = [
+		record.timestamp ?? "unknown-time",
+		record.component ?? "unknown-component",
+		record.pid ? `pid=${record.pid}` : undefined,
+		record.detached === undefined
+			? undefined
+			: `detached=${record.detached ? "yes" : "no"}`,
+		record.command,
+	].filter(Boolean);
+	return pieces.join(" | ");
+}
+
+function formatActiveConnector(record: ActiveConnectorRecord): string {
+	const identity =
+		record.type === "telegram"
+			? `bot=@${record.botUsername ?? "unknown"}`
+			: record.type === "discord"
+				? `user=${record.userName ?? "unknown"} app=${record.applicationId ?? "unknown"}`
+				: `user=${record.userName ?? "unknown"}`;
+	const pieces = [
+		record.type,
+		identity,
+		`pid=${record.pid}`,
+		`hub=${record.hubUrl}`,
+		record.phoneNumberId ? `phone=${record.phoneNumberId}` : undefined,
+		record.port ? `port=${record.port}` : undefined,
+		record.baseUrl ? `url=${record.baseUrl}` : undefined,
+		record.startedAt ? `started=${record.startedAt}` : undefined,
+	].filter(Boolean);
+	return pieces.join(" | ");
+}
+
+function killPids(pids: number[]): number {
+	let killed = 0;
+	for (const pid of pids) {
+		try {
+			process.kill(pid, "SIGKILL");
+			killed += 1;
+		} catch {
+			// Best-effort cleanup.
+		}
+	}
+	return killed;
+}
+
+export async function runDoctorCommand(
+	opts: { cwd: string; json?: boolean; fix?: boolean; verbose?: boolean },
+	io: DoctorIo,
+): Promise<number> {
+	const jsonOutput = opts.json === true;
+	const fix = opts.fix === true;
+	const verbose = opts.verbose === true;
+	const before = await collectDoctorStatus(opts.cwd);
+
+	if (!fix) {
+		if (jsonOutput) {
+			io.writeln(JSON.stringify(before));
+			return 0;
+		}
+		writeln(`hub url ${c.dim}${before.hubUrl ?? "none"}${c.reset}`);
+		writeln(
+			`hub healthy ${c.dim}${before.hubHealthy ? "yes" : "no"}${before.hubPid ? ` (pid=${before.hubPid})` : ""}${c.reset}`,
+		);
+		writeln(`hub uptime ${c.dim}${before.hubUptime ?? "n/a"}${c.reset}`);
+		writeln(formatPidList("hub listeners", before.listeningPids));
+		writeln(formatPidList("stale hub daemons", before.staleHubPids));
+		writeln(
+			formatPidList(
+				"hub startup locks",
+				before.hubStartupLocks.map((a) => a.pid ?? -1).filter((pid) => pid > 0),
+			),
+		);
+		writeln(formatPidList("cli processes", before.staleCliPids));
+		writeln(formatPidList("sidecar processes", before.staleSidecarPids));
+		if (before.activeConnectors.length === 0) {
+			writeln(`active connectors ${c.dim}0${c.reset}`);
+		} else {
+			writeln("active connectors:");
+			for (const record of before.activeConnectors) {
+				writeln(`- ${c.dim}${formatActiveConnector(record)}${c.reset}`);
+			}
+		}
+		if (verbose && before.recentSpawnedProcesses.length > 0) {
+			writeln("recent spawned processes:");
+			for (const record of before.recentSpawnedProcesses) {
+				writeln(`- ${c.dim}${formatRecentSpawnedProcess(record)}${c.reset}`);
+			}
+		}
+		if (
+			before.listeningPids.length > 0 ||
+			before.staleHubPids.length > 0 ||
+			before.staleCliPids.length > 0 ||
+			before.staleSidecarPids.length > 0
+		) {
+			io.writeln(
+				"\nRun `cline doctor fix` to kill all stale local processes, including stale sidecars.",
+			);
+		}
+		return 0;
+	}
+
+	const gracefullyStoppedHub = before.hubHealthy
+		? await stopLocalHubServerGracefully(resolveCliHubOwnerContext()).catch(
+				() => false,
+			)
+		: false;
+	const refreshedAfterGracefulStop = gracefullyStoppedHub
+		? await collectDoctorStatus(opts.cwd)
+		: before;
+	const killedHub = gracefullyStoppedHub
+		? 0
+		: killPids(refreshedAfterGracefulStop.listeningPids);
+	const staleHubTargets = before.staleHubPids.filter(
+		(pid) => !refreshedAfterGracefulStop.listeningPids.includes(pid),
+	);
+	const killedStaleHubs = killPids(staleHubTargets);
+	const staleCliTargets = before.staleCliPids.filter(
+		(pid) =>
+			!refreshedAfterGracefulStop.listeningPids.includes(pid) &&
+			!staleHubTargets.includes(pid),
+	);
+	const killedCli = killPids(staleCliTargets);
+	const staleSidecarTargets = before.staleSidecarPids.filter(
+		(pid) =>
+			!refreshedAfterGracefulStop.listeningPids.includes(pid) &&
+			!staleHubTargets.includes(pid) &&
+			!staleCliTargets.includes(pid),
+	);
+	const killedSidecars = killPids(staleSidecarTargets);
+	const stoppedConnectors = await stopAllConnectors({
+		writeln: () => {},
+		writeErr: () => {},
+	});
+	const postKillStatus = await collectDoctorStatus(opts.cwd);
+	const clearedArtifacts = await clearHubStartupArtifacts(opts.cwd, {
+		clearDiscovery:
+			!postKillStatus.hubHealthy && postKillStatus.listeningPids.length === 0,
+	});
+	const after = await collectDoctorStatus(opts.cwd);
+
+	if (jsonOutput) {
+		io.writeln(
+			JSON.stringify({
+				before,
+				after,
+				killed: {
+					hubListeners: killedHub,
+					staleHubDaemons: killedStaleHubs,
+					cliProcesses: killedCli,
+					sidecarProcesses: killedSidecars,
+					connectorProcesses: stoppedConnectors.stoppedProcesses,
+					connectorSessions: stoppedConnectors.stoppedSessions,
+					hubStartupLocks: clearedArtifacts.startupLocks,
+					hubDiscovery: clearedArtifacts.discovery,
+				},
+			}),
+		);
+		return 0;
+	}
+	writeln(`killed hub listeners ${c.dim}${killedHub}${c.reset}`);
+	writeln(`killed stale hub daemons ${c.dim}${killedStaleHubs}${c.reset}`);
+	writeln(`killed cli processes ${c.dim}${killedCli}${c.reset}`);
+	writeln(`killed sidecar processes ${c.dim}${killedSidecars}${c.reset}`);
+	writeln(
+		`stopped connector processes ${c.dim}${stoppedConnectors.stoppedProcesses}${c.reset}`,
+	);
+	writeln(
+		`stopped connector sessions ${c.dim}${stoppedConnectors.stoppedSessions}${c.reset}`,
+	);
+	writeln(
+		`cleared hub startup locks ${c.dim}${clearedArtifacts.startupLocks}${c.reset}`,
+	);
+	writeln(
+		`cleared hub discovery records ${c.dim}${clearedArtifacts.discovery}${c.reset}`,
+	);
+	writeln(`hub healthy after fix: ${after.hubHealthy ? "yes" : "no"}`);
+	writeln(formatPidList("remaining hub listeners", after.listeningPids));
+	writeln(formatPidList("remaining stale hub daemons", after.staleHubPids));
+	writeln(
+		formatPidList(
+			"remaining hub startup locks",
+			after.hubStartupLocks.map((a) => a.pid ?? -1).filter((pid) => pid > 0),
+		),
+	);
+	writeln(formatPidList("remaining cli processes", after.staleCliPids));
+	writeln(formatPidList("remaining sidecar processes", after.staleSidecarPids));
+	return 0;
+}
+
+export function createDoctorCommand(
+	io: DoctorIo,
+	setExitCode: (code: number) => void,
+	deps: DoctorCommandDeps = {},
+): Command {
+	const doctor = new Command("doctor")
+		.description("Diagnose and fix local process issues")
+		.exitOverride()
+		.option("--cwd <path>", "Workspace root", process.cwd())
+		.option("--json", "Output as JSON")
+		.option("-v, --verbose", "Show additional diagnostic details")
+		.action(async function (this: Command) {
+			const opts = this.opts<{
+				cwd: string;
+				json?: boolean;
+				verbose?: boolean;
+			}>();
+			setExitCode(await runDoctorCommand(opts, io));
+		});
+
+	doctor
+		.command("fix")
+		.description("Kill all running processes")
+		.option("--cwd <path>", "Workspace root", process.cwd())
+		.option("--json", "Output as JSON")
+		.option("-v, --verbose", "Show additional diagnostic details")
+		.action(async function (this: Command) {
+			const opts = this.opts<{
+				cwd: string;
+				json?: boolean;
+				verbose?: boolean;
+			}>();
+			setExitCode(await runDoctorCommand({ ...opts, fix: true }, io));
+		});
+
+	doctor
+		.command("log")
+		.description("Open the CLI log file")
+		.action(async () => {
+			const logPath = resolveCliLogPath();
+			const openPath = deps.openPath ?? defaultOpenPath;
+			try {
+				ensureFileExists(logPath);
+				await openPath(logPath);
+				io.writeln(`Opening logs stored at ${logPath}`);
+				setExitCode(0);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				io.writeErr(`failed to open log file "${logPath}": ${message}`);
+				setExitCode(1);
+			}
+		});
+
+	return doctor;
+}
diff --git a/apps/cli/src/commands/help.ts b/apps/cli/src/commands/help.ts
new file mode 100644
index 0000000..61c4427
--- /dev/null
+++ b/apps/cli/src/commands/help.ts
@@ -0,0 +1,6 @@
+import { getCliBuildInfo } from "../utils/common";
+import { writeln } from "../utils/output";
+
+export function showVersion(): void {
+	writeln(getCliBuildInfo().version);
+}
diff --git a/apps/cli/src/commands/history.test.ts b/apps/cli/src/commands/history.test.ts
new file mode 100644
index 0000000..d81665c
--- /dev/null
+++ b/apps/cli/src/commands/history.test.ts
@@ -0,0 +1,369 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { SessionHistoryRecord } from "@cline/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	formatCheckpointDetail,
+	formatHistoryListLine,
+	mergeHistoryStatusRows,
+	runHistoryExport,
+	runHistoryList,
+} from "./history";
+
+vi.mock("../session/session", () => ({
+	listSessions: vi.fn(),
+	readSessionMessagesArtifact: vi.fn(),
+}));
+
+vi.mock("../tui/history-standalone", () => ({
+	renderHistoryStandalone: vi.fn(async () => 0),
+}));
+
+import { listSessions, readSessionMessagesArtifact } from "../session/session";
+import { renderHistoryStandalone } from "../tui/history-standalone";
+
+const mockedReadSessionMessagesArtifact = vi.mocked(
+	readSessionMessagesArtifact,
+);
+const mockedListSessions = vi.mocked(listSessions);
+const mockedRenderHistoryStandalone = vi.mocked(renderHistoryStandalone);
+
+function createHistoryRow(
+	overrides: Partial<SessionHistoryRecord> = {},
+): SessionHistoryRecord {
+	return {
+		sessionId: "sess_1",
+		source: "cli",
+		pid: 1,
+		startedAt: "2026-01-01T00:00:00.000Z",
+		status: "completed",
+		interactive: false,
+		provider: "mock-provider",
+		model: "mock-model",
+		cwd: "/tmp/workspace",
+		workspaceRoot: "/tmp/workspace",
+		enableTools: true,
+		enableSpawn: false,
+		enableTeams: false,
+		isSubagent: false,
+		prompt: "hello world",
+		updatedAt: "2026-01-01T00:00:00.000Z",
+		...overrides,
+	};
+}
+
+describe("formatHistoryListLine", () => {
+	it("includes checkpoint metadata when present", () => {
+		const line = formatHistoryListLine(
+			createHistoryRow({
+				metadata: {
+					title: "hello world",
+					totalCost: 0.25,
+					checkpoint: {
+						latest: {
+							ref: "abc123",
+							createdAt: 1767196800000,
+							runCount: 3,
+						},
+						history: [
+							{ ref: "a", createdAt: 1, runCount: 1 },
+							{ ref: "b", createdAt: 2, runCount: 2 },
+							{ ref: "c", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			}),
+		);
+
+		expect(line).toContain(
+			"12/31/2025 16:00 mock-provider:mock-model [completed] | $0.25 | hello world",
+		);
+	});
+
+	it("formats a compact checkpoint badge summary in the line", () => {
+		const line = formatHistoryListLine(
+			createHistoryRow({
+				metadata: {
+					title: "hello world",
+					totalCost: 0.25,
+					checkpoint: {
+						latest: {
+							ref: "abc123",
+							createdAt: 1767196800000,
+							runCount: 3,
+						},
+						history: [
+							{ ref: "a", createdAt: 1, runCount: 1 },
+							{ ref: "b", createdAt: 2, runCount: 2 },
+							{ ref: "c", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			}),
+		);
+
+		expect(line).toContain(
+			"12/31/2025 16:00 mock-provider:mock-model [completed] | $0.25 | hello world",
+		);
+		expect(line).toMatch(/^\d{2}\/\d{2}\/\d{4} \d{2}:\d{2}/);
+	});
+
+	it("formats checkpoint detail text for the selected row footer", () => {
+		const detail = formatCheckpointDetail(
+			createHistoryRow({
+				metadata: {
+					title: "hello world",
+					totalCost: 0.25,
+					checkpoint: {
+						latest: {
+							ref: "abc123def4567890",
+							createdAt: 1767196800000,
+							runCount: 3,
+						},
+						history: [
+							{ ref: "a", createdAt: 1, runCount: 1 },
+							{ ref: "b", createdAt: 2, runCount: 2 },
+							{ ref: "c", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			}),
+		);
+
+		expect(detail).toContain("Checkpoint");
+		expect(detail).toContain("run 3");
+		expect(detail).toContain("3 total");
+	});
+
+	it("omits checkpoint summary when absent", () => {
+		const line = formatHistoryListLine(
+			createHistoryRow({
+				metadata: {
+					title: "hello world",
+					totalCost: 0.25,
+				},
+			}),
+		);
+
+		expect(line).not.toContain("checkpoints:");
+	});
+
+	it("omits cost for subscription-backed providers", () => {
+		const line = formatHistoryListLine(
+			createHistoryRow({
+				provider: "openai-codex",
+				model: "gpt-5.4",
+				metadata: {
+					title: "hello world",
+					totalCost: 0.25,
+				},
+			}),
+		);
+
+		expect(line).toContain("openai-codex:gpt-5.4 [completed] | hello world");
+		expect(line).not.toContain("$0.25");
+	});
+
+	it("merges refreshed session status without dropping hydrated display metadata", () => {
+		const current = createHistoryRow({
+			metadata: { title: "hydrated title", totalCost: 0.25 },
+			status: "running",
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const [merged] = mergeHistoryStatusRows(
+			[current],
+			[
+				createHistoryRow({
+					sessionId: current.sessionId,
+					metadata: undefined,
+					prompt: undefined,
+					status: "completed",
+					endedAt: "2026-01-01T00:02:00.000Z",
+					updatedAt: "2026-01-01T00:02:00.000Z",
+				}),
+			],
+		);
+
+		expect(merged).toMatchObject({
+			sessionId: current.sessionId,
+			status: "completed",
+			endedAt: "2026-01-01T00:02:00.000Z",
+			updatedAt: "2026-01-01T00:02:00.000Z",
+			metadata: { title: "hydrated title", totalCost: 0.25 },
+		});
+	});
+});
+
+describe("runHistoryList", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("hydrates interactive history rows so titles can be inferred from messages", async () => {
+		const row = createHistoryRow({ prompt: undefined, metadata: undefined });
+		mockedListSessions.mockResolvedValue([row]);
+		const io = {
+			writeln: vi.fn(),
+			writeErr: vi.fn(),
+		};
+
+		const code = await runHistoryList({
+			limit: 25,
+			outputMode: "text",
+			io,
+		});
+
+		expect(code).toBe(0);
+		expect(mockedListSessions).toHaveBeenCalledWith(25, {
+			hydrate: true,
+		});
+		expect(mockedRenderHistoryStandalone).toHaveBeenCalledWith(
+			expect.objectContaining({ rows: [row] }),
+		);
+	});
+
+	it("keeps json history listing unhydrated", async () => {
+		const row = createHistoryRow({ prompt: undefined, metadata: undefined });
+		mockedListSessions.mockResolvedValue([row]);
+		const writeSpy = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+
+		const code = await runHistoryList({
+			limit: 25,
+			outputMode: "json",
+		});
+
+		expect(code).toBe(0);
+		expect(mockedListSessions).toHaveBeenCalledWith(25, {
+			hydrate: false,
+		});
+		expect(writeSpy).toHaveBeenCalledWith(JSON.stringify([row]));
+		writeSpy.mockRestore();
+	});
+
+	it("defaults history listing to 50 rows", async () => {
+		mockedListSessions.mockResolvedValue([]);
+		const io = {
+			writeln: vi.fn(),
+			writeErr: vi.fn(),
+		};
+
+		const code = await runHistoryList({
+			limit: Number.NaN,
+			outputMode: "text",
+			io,
+		});
+
+		expect(code).toBe(0);
+		expect(mockedListSessions).toHaveBeenCalledWith(50, {
+			hydrate: true,
+		});
+		expect(io.writeln).toHaveBeenCalledWith("No history found.");
+	});
+});
+
+describe("runHistoryExport", () => {
+	let tempDir = "";
+
+	afterEach(async () => {
+		vi.clearAllMocks();
+		if (tempDir) {
+			await rm(tempDir, { recursive: true, force: true });
+			tempDir = "";
+		}
+	});
+
+	it("writes standalone html from a persisted messages artifact", async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "cline-history-export-"));
+		const outputPath = join(tempDir, "export.html");
+		const artifact = {
+			version: 1,
+			updated_at: "2026-04-22T17:42:10.123Z",
+			sessionId: "sess_1",
+			messages: [
+				{
+					id: "m1",
+					role: "user",
+					content: [{ type: "text", text: "hello" }],
+				},
+				{
+					id: "m2",
+					role: "assistant",
+					content: [{ type: "text", text: "world" }],
+				},
+			],
+		} satisfies NonNullable<
+			Awaited<ReturnType<typeof readSessionMessagesArtifact>>
+		>;
+		mockedReadSessionMessagesArtifact.mockResolvedValue(artifact);
+		const io = {
+			writeln: vi.fn(),
+			writeErr: vi.fn(),
+		};
+
+		const code = await runHistoryExport("sess_1", outputPath, "text", io);
+
+		expect(code).toBe(0);
+		expect(io.writeErr).not.toHaveBeenCalled();
+		expect(io.writeln).toHaveBeenCalledWith(
+			expect.stringContaining(outputPath),
+		);
+		await expect(readFile(outputPath, "utf8")).resolves.toContain("world");
+	});
+
+	it("exports run_commands history with structured command objects", async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "cline-history-export-"));
+		const outputPath = join(tempDir, "export.html");
+		const artifact = {
+			version: 1,
+			updated_at: "2026-04-22T17:42:10.123Z",
+			sessionId: "sess_1",
+			messages: [
+				{
+					id: "m1",
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool_1",
+							name: "run_commands",
+							input: {
+								commands: [{ command: "cmd", args: ["/c", "dir"] }],
+							},
+						},
+					],
+				},
+			],
+		} satisfies NonNullable<
+			Awaited<ReturnType<typeof readSessionMessagesArtifact>>
+		>;
+		mockedReadSessionMessagesArtifact.mockResolvedValue(artifact);
+		const io = {
+			writeln: vi.fn(),
+			writeErr: vi.fn(),
+		};
+
+		const code = await runHistoryExport("sess_1", outputPath, "text", io);
+
+		expect(code).toBe(0);
+		expect(io.writeErr).not.toHaveBeenCalled();
+		await expect(readFile(outputPath, "utf8")).resolves.toContain("cmd /c dir");
+	});
+
+	it("fails when the session artifact is missing", async () => {
+		mockedReadSessionMessagesArtifact.mockResolvedValue(undefined);
+		const io = {
+			writeln: vi.fn(),
+			writeErr: vi.fn(),
+		};
+
+		const code = await runHistoryExport("sess_missing", undefined, "text", io);
+
+		expect(code).toBe(1);
+		expect(io.writeErr).toHaveBeenCalledWith(
+			"Session sess_missing not found or has no messages.json",
+		);
+	});
+});
diff --git a/apps/cli/src/commands/history.ts b/apps/cli/src/commands/history.ts
new file mode 100644
index 0000000..81df597
--- /dev/null
+++ b/apps/cli/src/commands/history.ts
@@ -0,0 +1,208 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { generateConversationHTML } from "../session/export";
+import {
+	deleteSession,
+	listSessions,
+	readSessionMessagesArtifact,
+	updateSession,
+} from "../session/session";
+import { disableOpenTuiGraphicsProbe } from "../tui/opentui-env";
+import { writeln } from "../utils/output";
+import type { CliOutputMode } from "../utils/types";
+
+export {
+	formatCheckpointDetail,
+	formatHistoryListLine,
+	mergeHistoryStatusRows,
+} from "../utils/history-format";
+
+type HistoryIo = {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+};
+
+async function exportHistorySession(
+	sessionId: string,
+	outputPath?: string,
+): Promise<string> {
+	const data = await readSessionMessagesArtifact(sessionId);
+	if (!data) {
+		throw new Error(`Session ${sessionId} not found or has no messages.json`);
+	}
+
+	const targetPath = resolve(outputPath?.trim() || `${sessionId}.html`);
+	const html = generateConversationHTML(data, sessionId);
+	await mkdir(dirname(targetPath), { recursive: true });
+	await writeFile(targetPath, html, "utf8");
+	return targetPath;
+}
+
+async function runHistoryDelete(
+	sessionId: string | undefined,
+	outputMode: CliOutputMode,
+	io: HistoryIo,
+): Promise<number> {
+	if (!sessionId) {
+		io.writeErr("history delete requires --session-id <id>");
+		return 1;
+	}
+
+	try {
+		const result = await deleteSession(sessionId);
+		if (outputMode === "json") {
+			process.stdout.write(JSON.stringify(result));
+			return result.deleted ? 0 : 1;
+		}
+		if (result.deleted) {
+			io.writeln(`Deleted session ${sessionId}`);
+			return 0;
+		}
+		io.writeErr(`Session ${sessionId} not found`);
+		return 1;
+	} catch (error) {
+		io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+
+async function runHistoryUpdate(
+	sessionId: string | undefined,
+	prompt: string | undefined,
+	title: string | undefined,
+	metadataStr: string | undefined,
+	outputMode: CliOutputMode,
+	io: HistoryIo,
+): Promise<number> {
+	if (!sessionId) {
+		io.writeErr("history update requires --session-id <id>");
+		return 1;
+	}
+
+	let metadata: Record<string, unknown> | undefined;
+	if (metadataStr) {
+		try {
+			metadata = JSON.parse(metadataStr);
+		} catch (error) {
+			io.writeErr(
+				`Invalid metadata JSON: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return 1;
+		}
+	}
+	if (title !== undefined) {
+		if (metadata) {
+			delete metadata.title;
+		}
+	}
+	if (metadata && Object.keys(metadata).length === 0) {
+		metadata = undefined;
+	}
+
+	if (prompt === undefined && metadata === undefined && title === undefined) {
+		io.writeErr(
+			"history update requires --prompt <text>, --title <text>, or --metadata <json>",
+		);
+		return 1;
+	}
+
+	try {
+		const result = await updateSession(sessionId, { prompt, metadata, title });
+		if (outputMode === "json") {
+			process.stdout.write(JSON.stringify(result));
+			return result.updated ? 0 : 1;
+		}
+		if (result.updated) {
+			io.writeln(`Updated session ${sessionId}`);
+			return 0;
+		}
+		io.writeErr(`Session ${sessionId} not found`);
+		return 1;
+	} catch (error) {
+		io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+
+async function runHistoryExport(
+	sessionId: string | undefined,
+	outputPath: string | undefined,
+	outputMode: CliOutputMode,
+	io: HistoryIo,
+): Promise<number> {
+	if (!sessionId) {
+		io.writeErr("history export requires <session-id>");
+		return 1;
+	}
+
+	try {
+		const targetPath = await exportHistorySession(sessionId, outputPath);
+
+		if (outputMode === "json") {
+			process.stdout.write(
+				JSON.stringify({
+					sessionId,
+					outputPath: targetPath,
+				}),
+			);
+			return 0;
+		}
+
+		io.writeln(`Exported to ${targetPath}`);
+		return 0;
+	} catch (error) {
+		io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+
+export async function runHistoryList(input: {
+	limit: number;
+	outputMode: CliOutputMode;
+	workspaceRoot?: string;
+	io?: HistoryIo;
+}): Promise<number | string> {
+	const io = input.io ?? {
+		writeln,
+		writeErr: (text: string) => process.stderr.write(`${text}\n`),
+	};
+	const limit = Number.isFinite(input.limit) ? input.limit : 50;
+
+	const rows = await listSessions(limit, {
+		workspaceRoot: input.workspaceRoot,
+		hydrate: input.outputMode !== "json",
+	});
+	if (rows.length === 0) {
+		if (input.outputMode === "json") {
+			process.stdout.write(JSON.stringify([]));
+		} else {
+			io.writeln("No history found.");
+		}
+		return 0;
+	}
+
+	if (input.outputMode === "json") {
+		process.stdout.write(JSON.stringify(rows));
+		return 0;
+	}
+
+	disableOpenTuiGraphicsProbe();
+	const { renderHistoryStandalone } = await import("../tui/history-standalone");
+	return await renderHistoryStandalone({
+		rows,
+		refreshRows: async () =>
+			await listSessions(limit, {
+				workspaceRoot: input.workspaceRoot,
+				hydrate: false,
+			}),
+		onExport: async (sessionId: string) =>
+			await exportHistorySession(sessionId, undefined),
+	});
+}
+
+export {
+	exportHistorySession,
+	runHistoryDelete,
+	runHistoryExport,
+	runHistoryUpdate,
+};
diff --git a/apps/cli/src/commands/hook.ts b/apps/cli/src/commands/hook.ts
new file mode 100644
index 0000000..4ae88e3
--- /dev/null
+++ b/apps/cli/src/commands/hook.ts
@@ -0,0 +1,58 @@
+import type { HookEventPayload } from "@cline/core";
+import { handleSessionHookEvent } from "../session/session";
+import {
+	appendHookAudit,
+	parseCliHookPayload,
+	readStdinUtf8,
+	writeHookJson,
+} from "../utils/helpers";
+
+async function handleHookPayload(payload: HookEventPayload): Promise<unknown> {
+	await appendHookAudit(payload);
+	await handleSessionHookEvent(payload);
+
+	switch (payload.hookName) {
+		case "tool_call":
+		case "tool_result":
+		case "agent_end":
+		case "agent_start":
+		case "agent_resume":
+		case "agent_abort":
+		case "prompt_submit":
+		case "pre_compact":
+		case "session_shutdown":
+			return {};
+		default:
+			throw new Error(
+				`unsupported hookName: ${(payload as { hookName: string }).hookName}`,
+			);
+	}
+}
+
+type HookIo = {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+};
+
+export async function runHookCommand(io: HookIo) {
+	try {
+		const raw = (await readStdinUtf8()).trim();
+		if (!raw) {
+			io.writeErr("hook command expects JSON payload on stdin");
+			return 1;
+		}
+
+		const parsed = JSON.parse(raw) as unknown;
+		const payload = await parseCliHookPayload(parsed);
+		if (!payload) {
+			io.writeErr("invalid hook payload");
+			return 1;
+		}
+
+		writeHookJson(await handleHookPayload(payload));
+		return 0;
+	} catch (error) {
+		io.writeErr(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
diff --git a/apps/cli/src/commands/hub.test.ts b/apps/cli/src/commands/hub.test.ts
new file mode 100644
index 0000000..e05ba61
--- /dev/null
+++ b/apps/cli/src/commands/hub.test.ts
@@ -0,0 +1,126 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const {
+	mockClearHubDiscovery,
+	mockEnsureDetachedHubServer,
+	mockProbeHubServer,
+	mockReadHubDiscovery,
+	mockResolveProductionHubOwnerContext,
+	mockResolveSharedHubOwnerContext,
+	mockStopLocalHubServerGracefully,
+} = vi.hoisted(() => ({
+	mockClearHubDiscovery: vi.fn(),
+	mockEnsureDetachedHubServer: vi.fn(),
+	mockProbeHubServer: vi.fn(),
+	mockReadHubDiscovery: vi.fn(),
+	mockResolveProductionHubOwnerContext: vi.fn(() => ({
+		ownerId: "hub-production",
+		discoveryPath: "/tmp/cline-data/locks/hub/production.json",
+	})),
+	mockResolveSharedHubOwnerContext: vi.fn(() => ({
+		ownerId: "hub-owner",
+		discoveryPath: "/tmp/cline-data/locks/hub/owners/hub-owner.json",
+	})),
+	mockStopLocalHubServerGracefully: vi.fn(),
+}));
+
+vi.mock("@cline/core", () => ({
+	clearHubDiscovery: mockClearHubDiscovery,
+	ensureDetachedHubServer: mockEnsureDetachedHubServer,
+	probeHubServer: mockProbeHubServer,
+	readHubDiscovery: mockReadHubDiscovery,
+	resolveProductionHubOwnerContext: mockResolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext: mockResolveSharedHubOwnerContext,
+	stopLocalHubServerGracefully: mockStopLocalHubServerGracefully,
+}));
+
+import { createHubCommand } from "./hub";
+
+const originalBuildEnv = process.env.CLINE_BUILD_ENV;
+
+describe("createHubCommand", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+		if (originalBuildEnv === undefined) {
+			delete process.env.CLINE_BUILD_ENV;
+		} else {
+			process.env.CLINE_BUILD_ENV = originalBuildEnv;
+		}
+	});
+
+	it("includes uptime in hub status output", async () => {
+		vi.spyOn(Date, "now").mockReturnValue(
+			new Date("2026-01-01T00:01:05.000Z").getTime(),
+		);
+		mockReadHubDiscovery.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			port: 25463,
+			pid: 50174,
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+		mockProbeHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			port: 25463,
+			pid: 50174,
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		const output: string[] = [];
+		let exitCode = 0;
+		const cmd = createHubCommand(
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+			(code) => {
+				exitCode = code;
+			},
+		);
+
+		await cmd.parseAsync(["status"], { from: "user" });
+
+		expect(exitCode).toBe(0);
+		expect(JSON.parse(output[0] || "")).toMatchObject({
+			running: true,
+			url: "ws://127.0.0.1:25463/hub",
+			pid: 50174,
+			startedAt: "2026-01-01T00:00:00.000Z",
+			uptime: "1m 5s",
+		});
+	});
+
+	it("passes the selected owner to graceful stop", async () => {
+		process.env.CLINE_BUILD_ENV = "development";
+		mockReadHubDiscovery.mockResolvedValue({
+			url: "ws://127.0.0.1:25466/hub",
+			port: 25466,
+			pid: 50174,
+		});
+		mockStopLocalHubServerGracefully.mockResolvedValue(true);
+
+		const output: string[] = [];
+		let exitCode = 0;
+		const cmd = createHubCommand(
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+			(code) => {
+				exitCode = code;
+			},
+		);
+
+		await cmd.parseAsync(["stop"], { from: "user" });
+
+		expect(exitCode).toBe(0);
+		expect(mockStopLocalHubServerGracefully).toHaveBeenCalledWith({
+			ownerId: "hub-owner",
+			discoveryPath: "/tmp/cline-data/locks/hub/owners/hub-owner.json",
+		});
+		expect(JSON.parse(output[0] || "")).toEqual({ stopped: true });
+	});
+});
diff --git a/apps/cli/src/commands/hub.ts b/apps/cli/src/commands/hub.ts
new file mode 100644
index 0000000..12fcc1a
--- /dev/null
+++ b/apps/cli/src/commands/hub.ts
@@ -0,0 +1,151 @@
+import {
+	clearHubDiscovery,
+	ensureDetachedHubServer,
+	probeHubServer,
+	readHubDiscovery,
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+	stopLocalHubServerGracefully,
+} from "@cline/core";
+import { formatUptime, resolveClineBuildEnv } from "@cline/shared";
+import { Command } from "commander";
+
+interface HubCommandIo {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+}
+
+async function stopHubServer(_workspaceRoot: string): Promise<boolean> {
+	const owner = resolveCliHubOwnerContext();
+	const discovery = await readHubDiscovery(owner.discoveryPath);
+	if (await stopLocalHubServerGracefully(owner)) {
+		await clearHubDiscovery(owner.discoveryPath);
+		return true;
+	}
+	const pid = discovery?.pid;
+	if (pid) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {
+			// best effort
+		}
+	}
+	await clearHubDiscovery(owner.discoveryPath);
+	return !!pid;
+}
+
+function formatHubUptimeFromStartedAt(
+	startedAt: string | undefined,
+): string | undefined {
+	if (!startedAt) {
+		return undefined;
+	}
+	const timestamp = Date.parse(startedAt);
+	if (Number.isNaN(timestamp)) {
+		return undefined;
+	}
+	return formatUptime(Date.now() - timestamp);
+}
+
+function resolveCliHubOwnerContext() {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+export function createHubCommand(
+	io: HubCommandIo,
+	setExitCode: (code: number) => void,
+): Command {
+	let actionExitCode = 0;
+	const fail = () => {
+		actionExitCode = 1;
+	};
+	const action =
+		<T extends unknown[]>(fn: (...args: T) => Promise<void>) =>
+		async (...args: T) => {
+			try {
+				await fn(...args);
+			} catch (error) {
+				io.writeErr(error instanceof Error ? error.message : String(error));
+				fail();
+			}
+		};
+
+	const hub = new Command("hub")
+		.description("Manage the local hub daemon")
+		.exitOverride()
+		.hook("postAction", () => {
+			setExitCode(actionExitCode);
+		})
+		.option("--cwd <path>", "Workspace root", process.cwd())
+		.option("--host <host>", "Hub host")
+		.option("--port <port>", "Hub port", (value) => Number.parseInt(value, 10))
+		.option("--pathname <path>", "Hub websocket path");
+
+	hub.command("ensure").action(
+		action(async () => {
+			const opts = hub.opts<{
+				cwd: string;
+				host?: string;
+				port?: number;
+				pathname?: string;
+			}>();
+			const { url } = await ensureDetachedHubServer(opts.cwd, {
+				host: opts.host,
+				port: opts.port,
+				pathname: opts.pathname,
+			});
+			io.writeln(url);
+		}),
+	);
+
+	hub.command("start").action(
+		action(async () => {
+			const opts = hub.opts<{
+				cwd: string;
+				host?: string;
+				port?: number;
+				pathname?: string;
+			}>();
+			const { url } = await ensureDetachedHubServer(opts.cwd, {
+				host: opts.host,
+				port: opts.port,
+				pathname: opts.pathname,
+			});
+			io.writeln(url);
+		}),
+	);
+
+	hub.command("status").action(
+		action(async () => {
+			const owner = resolveCliHubOwnerContext();
+			const discovery = await readHubDiscovery(owner.discoveryPath);
+			const health = discovery?.url
+				? await probeHubServer(discovery.url, {
+						authToken: discovery.authToken,
+					})
+				: undefined;
+			const uptime = formatHubUptimeFromStartedAt(health?.startedAt);
+			io.writeln(
+				JSON.stringify({
+					running: !!health?.url,
+					url: health?.url,
+					pid: health?.pid,
+					startedAt: health?.startedAt,
+					uptime,
+				}),
+			);
+		}),
+	);
+
+	hub.command("stop").action(
+		action(async () => {
+			const opts = hub.opts<{ cwd: string }>();
+			const stopped = await stopHubServer(opts.cwd);
+			io.writeln(JSON.stringify({ stopped }));
+		}),
+	);
+
+	return hub;
+}
diff --git a/apps/cli/src/commands/kanban.test.ts b/apps/cli/src/commands/kanban.test.ts
new file mode 100644
index 0000000..46828ec
--- /dev/null
+++ b/apps/cli/src/commands/kanban.test.ts
@@ -0,0 +1,214 @@
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	buildKanbanSpawnOptions,
+	forwardSignalToKanbanProcess,
+	isCommandAvailable,
+	launchKanban,
+	resolveKanbanInstallCommand,
+	shouldDetachKanbanProcess,
+} from "./kanban";
+
+const tempDirs: string[] = [];
+const originalPath = process.env.PATH;
+
+function createTempDir(): string {
+	const dir = mkdtempSync(join(tmpdir(), "cline-kanban-test-"));
+	tempDirs.push(dir);
+	return dir;
+}
+
+function writeExecutable(dir: string, name: string): void {
+	writeExecutableScript(dir, name, "#!/bin/sh\necho ok\n");
+}
+
+function writeExecutableScript(
+	dir: string,
+	name: string,
+	content: string,
+): void {
+	const filePath = join(dir, name);
+	writeFileSync(filePath, content, "utf8");
+	chmodSync(filePath, 0o755);
+}
+
+describe("kanban command helpers", () => {
+	afterEach(() => {
+		if (originalPath === undefined) {
+			delete process.env.PATH;
+		} else {
+			process.env.PATH = originalPath;
+		}
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("detects commands in PATH", () => {
+		const dir = createTempDir();
+		writeExecutable(dir, "kanban");
+
+		expect(isCommandAvailable("kanban", { PATH: dir }, "linux")).toBe(true);
+		expect(isCommandAvailable("missing", { PATH: dir }, "linux")).toBe(false);
+	});
+
+	it("detaches kanban into a process group on unix-like platforms", () => {
+		expect(shouldDetachKanbanProcess("darwin")).toBe(true);
+		expect(shouldDetachKanbanProcess("linux")).toBe(true);
+		expect(buildKanbanSpawnOptions({}, "darwin")).toMatchObject({
+			stdio: "inherit",
+			detached: true,
+		});
+	});
+
+	it("keeps kanban attached on windows", () => {
+		expect(shouldDetachKanbanProcess("win32")).toBe(false);
+		expect(buildKanbanSpawnOptions({}, "win32")).toMatchObject({
+			stdio: "inherit",
+			detached: false,
+			shell: true,
+		});
+	});
+
+	it("prefers npm for kanban installs", () => {
+		const dir = createTempDir();
+		writeExecutable(dir, "npm");
+		writeExecutable(dir, "pnpm");
+		writeExecutable(dir, "bun");
+
+		expect(resolveKanbanInstallCommand({ PATH: dir }, "linux")).toEqual({
+			packageManager: "npm",
+			command: "npm",
+			args: ["install", "-g", "kanban@latest"],
+			displayCommand: "npm install -g kanban@latest",
+		});
+	});
+
+	it("uses the preferred package manager when available", () => {
+		const dir = createTempDir();
+		writeExecutable(dir, "npm");
+		writeExecutable(dir, "pnpm");
+		writeExecutable(dir, "bun");
+
+		expect(resolveKanbanInstallCommand({ PATH: dir }, "linux", "pnpm")).toEqual(
+			{
+				packageManager: "pnpm",
+				command: "pnpm",
+				args: ["add", "-g", "kanban@latest"],
+				displayCommand: "pnpm add -g kanban@latest",
+			},
+		);
+		expect(resolveKanbanInstallCommand({ PATH: dir }, "linux", "bun")).toEqual({
+			packageManager: "bun",
+			command: "bun",
+			args: ["add", "-g", "kanban@latest"],
+			displayCommand: "bun add -g kanban@latest",
+		});
+	});
+
+	it("falls back when the preferred package manager is unavailable", () => {
+		const dir = createTempDir();
+		writeExecutable(dir, "npm");
+
+		expect(resolveKanbanInstallCommand({ PATH: dir }, "linux", "pnpm")).toEqual(
+			{
+				packageManager: "npm",
+				command: "npm",
+				args: ["install", "-g", "kanban@latest"],
+				displayCommand: "npm install -g kanban@latest",
+			},
+		);
+	});
+
+	it("falls back to pnpm and bun for kanban installs", () => {
+		const pnpmDir = createTempDir();
+		writeExecutable(pnpmDir, "pnpm");
+		expect(
+			resolveKanbanInstallCommand({ PATH: pnpmDir }, "linux")?.displayCommand,
+		).toBe("pnpm add -g kanban@latest");
+
+		const bunDir = createTempDir();
+		writeExecutable(bunDir, "bun");
+		expect(
+			resolveKanbanInstallCommand({ PATH: bunDir }, "linux")?.displayCommand,
+		).toBe("bun add -g kanban@latest");
+	});
+
+	it("fails when kanban is missing and no installer is available", async () => {
+		process.env.PATH = "";
+
+		await expect(launchKanban()).resolves.toBe(1);
+	});
+
+	it("returns the kanban process exit code", async () => {
+		const dir = createTempDir();
+		writeExecutableScript(dir, "kanban", "#!/bin/sh\nexit 7\n");
+		process.env.PATH = dir;
+
+		await expect(launchKanban()).resolves.toBe(7);
+	});
+
+	it("installs kanban before launch when missing", async () => {
+		const dir = createTempDir();
+		writeExecutableScript(
+			dir,
+			"npm",
+			`#!/bin/sh
+/bin/cat > "${dir}/kanban" <<'EOF'
+#!/bin/sh
+exit 6
+EOF
+/bin/chmod +x "${dir}/kanban"
+exit 0
+`,
+		);
+		process.env.PATH = dir;
+
+		const stdoutWrite = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+		try {
+			await expect(launchKanban()).resolves.toBe(6);
+		} finally {
+			stdoutWrite.mockRestore();
+		}
+	});
+
+	it("signals the detached kanban process group on unix-like platforms", () => {
+		const killProcess = vi.fn();
+		const child = {
+			pid: 4321,
+			kill: vi.fn(),
+		};
+
+		forwardSignalToKanbanProcess({
+			child,
+			signal: "SIGINT",
+			platform: "darwin",
+			killProcess,
+		});
+
+		expect(killProcess).toHaveBeenCalledWith(-4321, "SIGINT");
+		expect(child.kill).not.toHaveBeenCalled();
+	});
+
+	it("signals the child process directly on windows", () => {
+		const killProcess = vi.fn();
+		const child = {
+			pid: 4321,
+			kill: vi.fn(),
+		};
+
+		forwardSignalToKanbanProcess({
+			child,
+			signal: "SIGTERM",
+			platform: "win32",
+			killProcess,
+		});
+
+		expect(killProcess).not.toHaveBeenCalled();
+		expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+	});
+});
diff --git a/apps/cli/src/commands/kanban.ts b/apps/cli/src/commands/kanban.ts
new file mode 100644
index 0000000..f89ce24
--- /dev/null
+++ b/apps/cli/src/commands/kanban.ts
@@ -0,0 +1,405 @@
+import {
+	type ChildProcess,
+	type SpawnOptions,
+	spawn,
+	spawnSync,
+} from "node:child_process";
+import { accessSync, constants as fsConstants } from "node:fs";
+import { delimiter, extname, join } from "node:path";
+import { c, writeErr, writeln } from "../utils/output";
+
+export type KanbanInstaller = "npm" | "pnpm" | "bun";
+
+export interface KanbanInstallCommand {
+	packageManager: KanbanInstaller;
+	command: string;
+	args: readonly string[];
+	displayCommand: string;
+}
+
+export interface LaunchKanbanOptions {
+	preferredInstaller?: KanbanInstaller;
+}
+
+const KANBAN_SHUTDOWN_TIMEOUT_MS = 10_000;
+
+interface SignalableKanbanProcess {
+	pid?: number;
+	kill: (signal?: NodeJS.Signals | number) => boolean;
+}
+
+const KANBAN_INSTALL_COMMANDS: ReadonlyArray<
+	Omit<KanbanInstallCommand, "displayCommand">
+> = [
+	{
+		packageManager: "npm",
+		command: "npm",
+		args: ["install", "-g", "kanban@latest"],
+	},
+	{
+		packageManager: "pnpm",
+		command: "pnpm",
+		args: ["add", "-g", "kanban@latest"],
+	},
+	{
+		packageManager: "bun",
+		command: "bun",
+		args: ["add", "-g", "kanban@latest"],
+	},
+];
+
+function getKanbanCommand(
+	platform: NodeJS.Platform = process.platform,
+): string {
+	return platform === "win32" ? "kanban.cmd" : "kanban";
+}
+
+function getPackageManagerCommand(
+	packageManager: KanbanInstaller,
+	platform: NodeJS.Platform = process.platform,
+): string {
+	if (platform !== "win32") {
+		return packageManager;
+	}
+
+	return packageManager === "bun" ? "bun" : `${packageManager}.cmd`;
+}
+
+function getPathEntries(env: NodeJS.ProcessEnv): string[] {
+	const pathValue = env.PATH ?? env.Path ?? env.path;
+	if (!pathValue) {
+		return [];
+	}
+
+	return pathValue
+		.split(delimiter)
+		.map((entry) => entry.trim().replace(/^"(.*)"$/u, "$1"))
+		.filter((entry) => entry.length > 0);
+}
+
+function pathExists(candidatePath: string, platform: NodeJS.Platform): boolean {
+	try {
+		if (platform === "win32") {
+			accessSync(candidatePath, fsConstants.F_OK);
+		} else {
+			accessSync(candidatePath, fsConstants.X_OK);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function isCommandAvailable(
+	command: string,
+	env: NodeJS.ProcessEnv = process.env,
+	platform: NodeJS.Platform = process.platform,
+): boolean {
+	const commandHasExtension = extname(command).length > 0;
+	const pathExtensions =
+		platform === "win32"
+			? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM")
+					.split(";")
+					.filter((extension) => extension.length > 0)
+			: [];
+
+	for (const pathEntry of getPathEntries(env)) {
+		const commandPath = join(pathEntry, command);
+		if (pathExists(commandPath, platform)) {
+			return true;
+		}
+
+		if (!commandHasExtension && platform === "win32") {
+			for (const extension of pathExtensions) {
+				if (pathExists(`${commandPath}${extension}`, platform)) {
+					return true;
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+export function resolveKanbanInstallCommand(
+	env: NodeJS.ProcessEnv = process.env,
+	platform: NodeJS.Platform = process.platform,
+	preferredInstaller?: KanbanInstaller,
+): KanbanInstallCommand | null {
+	if (preferredInstaller) {
+		const preferredCommand = KANBAN_INSTALL_COMMANDS.find(
+			(installCommand) => installCommand.packageManager === preferredInstaller,
+		);
+		if (
+			preferredCommand &&
+			isCommandAvailable(preferredCommand.command, env, platform)
+		) {
+			return {
+				...preferredCommand,
+				displayCommand: `${preferredCommand.command} ${preferredCommand.args.join(" ")}`,
+			};
+		}
+	}
+
+	for (const installCommand of KANBAN_INSTALL_COMMANDS) {
+		if (isCommandAvailable(installCommand.command, env, platform)) {
+			return {
+				...installCommand,
+				displayCommand: `${installCommand.command} ${installCommand.args.join(" ")}`,
+			};
+		}
+	}
+
+	return null;
+}
+
+export function shouldDetachKanbanProcess(
+	platform: NodeJS.Platform = process.platform,
+): boolean {
+	return platform !== "win32";
+}
+
+export function buildKanbanSpawnOptions(
+	options: SpawnOptions = {},
+	platform: NodeJS.Platform = process.platform,
+): SpawnOptions {
+	return {
+		stdio: "inherit",
+		detached: shouldDetachKanbanProcess(platform),
+		...(platform === "win32" ? { shell: true } : {}),
+		...options,
+		// Prevent a console window from flashing on Windows.
+		windowsHide: true,
+	};
+}
+
+function buildKanbanInstallSpawnOptions(
+	options: SpawnOptions = {},
+	platform: NodeJS.Platform = process.platform,
+): SpawnOptions {
+	return {
+		detached: false,
+		stdio: "inherit",
+		// Prevent a console window from flashing on Windows.
+		windowsHide: true,
+		...(platform === "win32" ? { shell: true } : {}),
+		...options,
+	};
+}
+
+export function spawnKanbanProcess(options: SpawnOptions = {}): ChildProcess {
+	return spawn(getKanbanCommand(), [], buildKanbanSpawnOptions(options));
+}
+
+export function spawnKanbanInstallProcess(
+	installCommand: KanbanInstallCommand,
+	options: SpawnOptions = {},
+): ChildProcess {
+	return spawn(
+		getPackageManagerCommand(installCommand.packageManager),
+		[...installCommand.args],
+		buildKanbanInstallSpawnOptions(options),
+	);
+}
+
+export function getInstalledKanbanVersion(): string | null {
+	try {
+		const result = spawnSync(getKanbanCommand(), ["--version"], {
+			encoding: "utf8",
+			shell: process.platform === "win32",
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		});
+		if (result.status !== 0) {
+			return null;
+		}
+
+		const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
+		const versionMatch = output.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+		return versionMatch?.[0] ?? null;
+	} catch {
+		return null;
+	}
+}
+
+export function forwardSignalToKanbanProcess(options: {
+	child: SignalableKanbanProcess;
+	signal: NodeJS.Signals;
+	platform?: NodeJS.Platform;
+	killProcess?: (pid: number, signal: NodeJS.Signals | number) => boolean;
+}): void {
+	if (options.child.pid == null) {
+		return;
+	}
+
+	if (shouldDetachKanbanProcess(options.platform)) {
+		try {
+			(options.killProcess ?? process.kill)(-options.child.pid, options.signal);
+			return;
+		} catch (error) {
+			if (
+				error &&
+				typeof error === "object" &&
+				"code" in error &&
+				error.code === "ESRCH"
+			) {
+				return;
+			}
+		}
+	}
+
+	options.child.kill(options.signal);
+}
+
+function resolveProcessExitCode(
+	code: number | null,
+	signal: NodeJS.Signals | null,
+): number {
+	if (code !== null) {
+		return code;
+	}
+
+	switch (signal) {
+		case "SIGINT":
+			return 130;
+		case "SIGTERM":
+			return 143;
+		default:
+			return 1;
+	}
+}
+
+function waitForProcessExit(child: ChildProcess): Promise<number> {
+	return new Promise<number>((resolve, reject) => {
+		child.once("close", (code, signal) => {
+			resolve(resolveProcessExitCode(code, signal));
+		});
+		child.once("error", reject);
+	});
+}
+
+async function ensureKanbanInstalled(
+	command: string,
+	options: LaunchKanbanOptions = {},
+): Promise<boolean> {
+	if (isCommandAvailable(command)) {
+		return true;
+	}
+
+	const installCommand = resolveKanbanInstallCommand(
+		process.env,
+		process.platform,
+		options.preferredInstaller,
+	);
+	if (!installCommand) {
+		writeErr('kanban is not installed. Install it with "npm i -g kanban"');
+		return false;
+	}
+
+	writeln(`${c.cyan}Installing kanban@latest…${c.reset}`);
+	const installProcess = spawnKanbanInstallProcess(installCommand, {
+		env: process.env,
+		windowsHide: true,
+	});
+	const installExitCode = await waitForProcessExit(installProcess).catch(
+		(error: unknown) => {
+			const message = error instanceof Error ? error.message : String(error);
+			writeErr(`Failed to run ${installCommand.displayCommand}: ${message}`);
+			return 1;
+		},
+	);
+	if (installExitCode !== 0) {
+		writeErr(
+			`Failed to install kanban. Try running: ${installCommand.displayCommand}`,
+		);
+		return false;
+	}
+
+	if (!isCommandAvailable(command)) {
+		writeErr(
+			`Installed kanban, but ${command} was not found in PATH. Try opening a new terminal.`,
+		);
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Launch the external `kanban` app as a foreground child process.
+ *
+ * Returns a Promise that resolves with the exit code:
+ *   kanban's exit code after the foreground process exits
+ *   1 if kanban cannot be installed or spawned
+ */
+export async function launchKanban(
+	options: LaunchKanbanOptions = {},
+): Promise<number> {
+	const command = getKanbanCommand();
+	if (!(await ensureKanbanInstalled(command, options))) {
+		return 1;
+	}
+
+	return new Promise<number>((resolve) => {
+		const child = spawnKanbanProcess();
+		let shutdownTimer: NodeJS.Timeout | null = null;
+		let settled = false;
+
+		const clearShutdownTimer = () => {
+			if (!shutdownTimer) {
+				return;
+			}
+			clearTimeout(shutdownTimer);
+			shutdownTimer = null;
+		};
+
+		const cleanup = () => {
+			clearShutdownTimer();
+			process.off("SIGINT", handleSigint);
+			process.off("SIGTERM", handleSigterm);
+		};
+
+		const settle = (code: number) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			cleanup();
+			resolve(code);
+		};
+
+		const requestShutdown = (signal: NodeJS.Signals) => {
+			forwardSignalToKanbanProcess({ child, signal });
+
+			clearShutdownTimer();
+			if (signal === "SIGKILL") {
+				return;
+			}
+
+			shutdownTimer = setTimeout(() => {
+				forwardSignalToKanbanProcess({ child, signal: "SIGKILL" });
+			}, KANBAN_SHUTDOWN_TIMEOUT_MS);
+			shutdownTimer.unref?.();
+		};
+
+		function handleSigint() {
+			requestShutdown("SIGINT");
+		}
+
+		function handleSigterm() {
+			requestShutdown("SIGTERM");
+		}
+
+		process.on("SIGINT", handleSigint);
+		process.on("SIGTERM", handleSigterm);
+
+		child.once("error", (error) => {
+			const message = error instanceof Error ? error.message : String(error);
+			writeErr(`Failed to run kanban: ${message}`);
+			settle(1);
+		});
+		child.once("close", (code, signal) => {
+			settle(resolveProcessExitCode(code, signal));
+		});
+	});
+}
diff --git a/apps/cli/src/commands/mcp.test.ts b/apps/cli/src/commands/mcp.test.ts
new file mode 100644
index 0000000..882db7d
--- /dev/null
+++ b/apps/cli/src/commands/mcp.test.ts
@@ -0,0 +1,271 @@
+import { installMcpServer } from "@cline/core";
+import { describe, expect, it, vi } from "vitest";
+import {
+	buildMcpInstallDefaults,
+	buildMcpInstallTransport,
+	runMcpInstallCommand,
+} from "./mcp";
+
+vi.mock("@cline/core", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@cline/core")>();
+	return {
+		...actual,
+		installMcpServer: vi.fn((options) => {
+			const { name, transport, warnings } =
+				actual.buildMcpInstallTransport(options);
+			return {
+				name,
+				status: "installed",
+				transport,
+				warnings,
+			};
+		}),
+	};
+});
+
+describe("mcp install command", () => {
+	it("builds stdio wizard defaults from command args", () => {
+		expect(
+			buildMcpInstallDefaults({
+				name: "fs",
+				targetArgs: [
+					"npx",
+					"-y",
+					"@modelcontextprotocol/server-filesystem",
+					"/tmp/my dir",
+				],
+			}),
+		).toEqual({
+			name: "fs",
+			type: "stdio",
+			command: 'npx -y @modelcontextprotocol/server-filesystem "/tmp/my dir"',
+		});
+	});
+
+	it("builds remote wizard defaults and normalizes http transport", () => {
+		expect(
+			buildMcpInstallDefaults({
+				name: "ctx7",
+				transport: "http",
+				targetArgs: ["https://mcp.context7.com/mcp"],
+			}),
+		).toEqual({
+			name: "ctx7",
+			type: "streamableHttp",
+			url: "https://mcp.context7.com/mcp",
+		});
+	});
+
+	it("normalizes streamable-http transport", () => {
+		expect(
+			buildMcpInstallDefaults({
+				name: "docs",
+				transport: "streamable-http",
+				targetArgs: ["https://example.com/mcp"],
+			}),
+		).toEqual({
+			name: "docs",
+			type: "streamableHttp",
+			url: "https://example.com/mcp",
+		});
+	});
+
+	it("builds SSE wizard defaults", () => {
+		expect(
+			buildMcpInstallDefaults({
+				name: "events",
+				transport: "sse",
+				targetArgs: ["https://example.com/sse"],
+			}),
+		).toEqual({
+			name: "events",
+			type: "sse",
+			url: "https://example.com/sse",
+		});
+	});
+
+	it("rejects missing stdio command and invalid remote URL", () => {
+		expect(() =>
+			buildMcpInstallDefaults({
+				name: "fs",
+			}),
+		).toThrow(/requires a command/);
+
+		expect(() =>
+			buildMcpInstallDefaults({
+				name: "bad",
+				transport: "http",
+				targetArgs: ["not-a-url"],
+			}),
+		).toThrow(/Invalid MCP server URL/);
+	});
+
+	it("rejects remote URL schemes other than http and https", () => {
+		expect(() =>
+			buildMcpInstallDefaults({
+				name: "bad",
+				transport: "http",
+				targetArgs: ["file:///etc/passwd"],
+			}),
+		).toThrow(/only http and https are supported/);
+	});
+
+	it("builds direct stdio installs without shell-joining args", () => {
+		expect(
+			buildMcpInstallTransport({
+				name: "fs",
+				targetArgs: [
+					"npx",
+					"-y",
+					"@modelcontextprotocol/server-filesystem",
+					"/tmp/my dir",
+				],
+			}),
+		).toEqual({
+			name: "fs",
+			transport: {
+				type: "stdio",
+				command: "npx",
+				args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/my dir"],
+			},
+			warnings: [],
+		});
+	});
+
+	it("builds direct remote installs with headers and placeholder warnings", () => {
+		expect(
+			buildMcpInstallTransport({
+				name: "docs",
+				transport: "http",
+				headers: ["Authorization: Bearer <token>"],
+				targetArgs: ["https://example.com/mcp", "--header=X-Extra: yes"],
+			}),
+		).toEqual({
+			name: "docs",
+			transport: {
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+				headers: {
+					Authorization: "Bearer <token>",
+					"X-Extra": "yes",
+				},
+			},
+			warnings: [
+				'Header "Authorization" looks like it contains a placeholder. Update it in MCP settings before using this server.',
+			],
+		});
+	});
+
+	it("opens the add wizard with prefilled defaults", async () => {
+		const runWizard = vi.fn(async () => 0);
+
+		const code = await runMcpInstallCommand({
+			name: "ctx7",
+			transport: "http",
+			targetArgs: ["https://mcp.context7.com/mcp"],
+			isTty: true,
+			runWizard,
+			io: { writeErr: vi.fn() },
+		});
+
+		expect(code).toBe(0);
+		expect(runWizard).toHaveBeenCalledWith({
+			name: "ctx7",
+			type: "streamableHttp",
+			url: "https://mcp.context7.com/mcp",
+		});
+	});
+
+	it("requires a TTY because it opens the wizard", async () => {
+		const writeErr = vi.fn();
+		const runWizard = vi.fn(async () => 0);
+
+		const code = await runMcpInstallCommand({
+			name: "ctx7",
+			transport: "http",
+			targetArgs: ["https://mcp.context7.com/mcp"],
+			isTty: false,
+			runWizard,
+			io: { writeErr },
+		});
+
+		expect(code).toBe(1);
+		expect(runWizard).not.toHaveBeenCalled();
+		expect(writeErr).toHaveBeenCalledWith(
+			"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+		);
+	});
+
+	it("checks for TTY before validating wizard install arguments", async () => {
+		const writeErr = vi.fn();
+
+		const code = await runMcpInstallCommand({
+			name: "fs",
+			isTty: false,
+			io: { writeErr },
+		});
+
+		expect(code).toBe(1);
+		expect(writeErr).toHaveBeenCalledWith(
+			"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+		);
+	});
+
+	it("installs directly with --yes without requiring a TTY", async () => {
+		const writeln = vi.fn();
+		const writeErr = vi.fn();
+
+		const code = await runMcpInstallCommand({
+			name: "docs",
+			transport: "http",
+			targetArgs: [
+				"https://example.com/mcp",
+				"--header",
+				"Authorization: Bearer token",
+			],
+			isTty: false,
+			yes: true,
+			io: { writeln, writeErr },
+		});
+
+		expect(code).toBe(0);
+		expect(installMcpServer).toHaveBeenCalledWith({
+			name: "docs",
+			transport: "http",
+			targetArgs: [
+				"https://example.com/mcp",
+				"--header",
+				"Authorization: Bearer token",
+			],
+			isTty: false,
+			yes: true,
+			io: { writeln, writeErr },
+		});
+		expect(writeln).toHaveBeenCalledWith("Installed MCP server docs.");
+		expect(writeErr).not.toHaveBeenCalled();
+	});
+
+	it("prints direct install JSON with --yes --json", async () => {
+		const writeln = vi.fn();
+
+		const code = await runMcpInstallCommand({
+			name: "fs",
+			targetArgs: ["node", "server.js"],
+			isTty: false,
+			yes: true,
+			json: true,
+			io: { writeln, writeErr: vi.fn() },
+		});
+
+		expect(code).toBe(0);
+		expect(JSON.parse(writeln.mock.calls[0]?.[0])).toMatchObject({
+			name: "fs",
+			status: "installed",
+			transport: {
+				type: "stdio",
+				command: "node",
+				args: ["server.js"],
+			},
+		});
+	});
+});
diff --git a/apps/cli/src/commands/mcp.ts b/apps/cli/src/commands/mcp.ts
new file mode 100644
index 0000000..f18e8a5
--- /dev/null
+++ b/apps/cli/src/commands/mcp.ts
@@ -0,0 +1,160 @@
+import {
+	type McpInstallOptions as CoreMcpInstallOptions,
+	installMcpServer,
+	type McpInstallResult,
+	type McpServerTransportConfig,
+} from "@cline/core";
+import type { McpAddDefaults } from "../wizards/mcp";
+
+export { buildMcpInstallTransport } from "@cline/core";
+
+export interface McpCommandIo {
+	writeln?: (text: string) => void;
+	writeErr: (text: string) => void;
+}
+
+export interface McpInstallOptions extends CoreMcpInstallOptions {
+	io?: McpCommandIo;
+	isTty?: boolean;
+	json?: boolean;
+	runWizard?: (defaults: McpAddDefaults) => Promise<number>;
+	yes?: boolean;
+}
+
+export interface McpInstallDirectResult {
+	name: string;
+	status: "installed";
+	transport: McpServerTransportConfig;
+	warnings: string[];
+}
+
+function normalizeTransportType(
+	value: string | undefined,
+): McpServerTransportConfig["type"] {
+	const normalized = (value ?? "stdio").trim();
+	if (normalized === "http" || normalized === "streamable-http") {
+		return "streamableHttp";
+	}
+	if (
+		normalized === "stdio" ||
+		normalized === "sse" ||
+		normalized === "streamableHttp"
+	) {
+		return normalized;
+	}
+	throw new Error(
+		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
+	);
+}
+
+function assertValidUrl(url: string): void {
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error(`Invalid MCP server URL: ${url}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error(
+			`Invalid MCP server URL: ${url} (only http and https are supported)`,
+		);
+	}
+}
+
+function quoteCommandArg(arg: string): string {
+	if (/^[^\s"'\\]+$/.test(arg)) {
+		return arg;
+	}
+	return `"${arg.replace(/(["\\])/g, "\\$1")}"`;
+}
+
+export function buildMcpInstallDefaults(options: {
+	name: string;
+	targetArgs?: string[];
+	transport?: string;
+}): McpAddDefaults {
+	const name = options.name.trim();
+	if (!name) {
+		throw new Error("MCP server name is required");
+	}
+	const type = normalizeTransportType(options.transport);
+	const targetArgs = options.targetArgs ?? [];
+	if (type === "stdio") {
+		if (targetArgs.length === 0) {
+			throw new Error(
+				"Stdio MCP install requires a command after the server name, for example: cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp",
+			);
+		}
+		return {
+			name,
+			type,
+			command: targetArgs.map(quoteCommandArg).join(" "),
+		};
+	}
+
+	if (targetArgs.length !== 1) {
+		throw new Error(
+			"Remote MCP install requires exactly one URL argument after the server name.",
+		);
+	}
+	const url = targetArgs[0]?.trim() ?? "";
+	assertValidUrl(url);
+	return {
+		name,
+		type,
+		url,
+	};
+}
+
+export function installMcpServerDirect(
+	options: McpInstallOptions,
+): McpInstallDirectResult {
+	const result: McpInstallResult = installMcpServer(options);
+	return {
+		name: result.name,
+		status: result.status,
+		transport: result.transport,
+		warnings: result.warnings,
+	};
+}
+
+async function runPrefilledWizard(defaults: McpAddDefaults): Promise<number> {
+	const { runMcpWizard } = await import("../wizards/mcp");
+	return runMcpWizard({
+		initialAction: "add",
+		addDefaults: defaults,
+		exitAfterInitialAction: true,
+	});
+}
+
+export async function runMcpInstallCommand(
+	options: McpInstallOptions,
+): Promise<number> {
+	try {
+		if (options.yes) {
+			const result = installMcpServerDirect(options);
+			if (options.json) {
+				options.io?.writeln?.(JSON.stringify(result));
+			} else {
+				options.io?.writeln?.(`Installed MCP server ${result.name}.`);
+				for (const warning of result.warnings) {
+					options.io?.writeErr(warning);
+				}
+			}
+			return 0;
+		}
+		const isTty =
+			options.isTty ?? (process.stdin.isTTY && process.stdout.isTTY);
+		if (!isTty) {
+			throw new Error(
+				"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+			);
+		}
+		const defaults = buildMcpInstallDefaults(options);
+		return await (options.runWizard ?? runPrefilledWizard)(defaults);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		options.io?.writeErr(message);
+		return 1;
+	}
+}
diff --git a/apps/cli/src/commands/plugin.test.ts b/apps/cli/src/commands/plugin.test.ts
new file mode 100644
index 0000000..da6665d
--- /dev/null
+++ b/apps/cli/src/commands/plugin.test.ts
@@ -0,0 +1,1076 @@
+import { execFileSync } from "node:child_process";
+import {
+	existsSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	discoverPluginModulePaths,
+	resolvePluginConfigSearchPaths,
+	setClineDir,
+	setHomeDir,
+} from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	collectPluginMcpOAuthCandidates,
+	installPlugin,
+	isOfficialPluginSlug,
+	parsePluginSource,
+	runPluginInstallCommand,
+	runPluginUninstallCommand,
+} from "./plugin";
+
+type FetchCall = (
+	...args: Parameters<typeof fetch>
+) => ReturnType<typeof fetch>;
+
+describe("plugin install command", () => {
+	let root = "";
+	let home = "";
+	let workspace = "";
+	let originalHome: string | undefined;
+	let originalClineDir: string | undefined;
+	let originalClineDataDir: string | undefined;
+	let originalMcpSettingsPath: string | undefined;
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "cli-plugin-install-"));
+		home = join(root, "home");
+		workspace = join(root, "workspace");
+		originalHome = process.env.HOME;
+		originalClineDir = process.env.CLINE_DIR;
+		originalClineDataDir = process.env.CLINE_DATA_DIR;
+		originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+		process.env.HOME = home;
+		process.env.CLINE_DIR = join(home, ".cline");
+		process.env.CLINE_DATA_DIR = join(home, ".cline", "data");
+		setHomeDir(home);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	function runGitCommand(cwd: string, args: string[]): void {
+		execFileSync("git", args, { cwd, stdio: "ignore" });
+	}
+
+	async function createOfficialPluginsRepo(
+		plugins: Record<string, Record<string, string>>,
+	): Promise<string> {
+		const repo = mkdtempSync(join(root, "official-plugins-"));
+		for (const [slug, files] of Object.entries(plugins)) {
+			const pluginRoot = join(repo, "plugins", slug);
+			await mkdir(pluginRoot, { recursive: true });
+			for (const [filename, content] of Object.entries(files)) {
+				await writeFile(join(pluginRoot, filename), content, "utf8");
+			}
+		}
+		runGitCommand(repo, ["init"]);
+		runGitCommand(repo, ["config", "user.email", "test@example.com"]);
+		runGitCommand(repo, ["config", "user.name", "Cline Test"]);
+		runGitCommand(repo, ["add", "."]);
+		runGitCommand(repo, ["commit", "-m", "seed plugins"]);
+		return repo;
+	}
+
+	afterEach(() => {
+		vi.useRealTimers();
+		vi.unstubAllGlobals();
+		if (originalHome === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = originalHome;
+		}
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR;
+		} else {
+			process.env.CLINE_DIR = originalClineDir;
+		}
+		if (originalClineDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalClineDataDir;
+		}
+		if (originalMcpSettingsPath === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
+		}
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	it("parses explicit npm source type without the npm prefix", () => {
+		expect(parsePluginSource("@scope/plugin@1.2.3", "npm")).toEqual({
+			type: "npm",
+			spec: "@scope/plugin@1.2.3",
+			name: "@scope/plugin",
+		});
+	});
+
+	it("parses explicit git source type without the git prefix", () => {
+		expect(parsePluginSource("github.com/acme/plugin", "git")).toMatchObject({
+			type: "git",
+			repo: "https://github.com/acme/plugin",
+			host: "github.com",
+			path: "acme/plugin",
+		});
+	});
+
+	it("parses bare official keywords as official plugin slugs", () => {
+		expect(isOfficialPluginSlug("clickhouse")).toBe(true);
+		expect(isOfficialPluginSlug("web-search")).toBe(true);
+		expect(isOfficialPluginSlug("WebSearch")).toBe(false);
+		expect(parsePluginSource("clickhouse")).toEqual({
+			type: "official",
+			slug: "clickhouse",
+		});
+		expect(parsePluginSource("web-search")).toEqual({
+			type: "official",
+			slug: "web-search",
+		});
+		expect(parsePluginSource("web-search", "npm")).toEqual({
+			type: "npm",
+			spec: "web-search",
+			name: "web-search",
+		});
+	});
+
+	it("rejects hostname-style sources without --git guidance", () => {
+		expect(() => parsePluginSource("github.com/acme/plugin")).toThrow(
+			/Use --git/,
+		);
+	});
+
+	it("parses GitHub plugin file URLs as remote sources", () => {
+		expect(
+			parsePluginSource(
+				"https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts",
+			),
+		).toEqual({
+			type: "remote",
+			url: "https://raw.githubusercontent.com/cline/cline/main/sdk/examples/plugins/weather-metrics.ts",
+			filename: "weather-metrics.ts",
+		});
+	});
+
+	it("parses raw plugin file URLs as remote sources", () => {
+		expect(
+			parsePluginSource(
+				"https://raw.githubusercontent.com/cline/cline/main/sdk/examples/plugins/weather-metrics.ts",
+			),
+		).toEqual({
+			type: "remote",
+			url: "https://raw.githubusercontent.com/cline/cline/main/sdk/examples/plugins/weather-metrics.ts",
+			filename: "weather-metrics.ts",
+		});
+	});
+
+	it("rejects HTTP plugin file URLs", () => {
+		expect(() =>
+			parsePluginSource("http://example.com/plugins/weather-metrics.ts"),
+		).toThrow(/must use https/);
+	});
+
+	it("installs a local plugin file into the global plugin root", async () => {
+		const source = join(root, "weather.ts");
+		writeFileSync(
+			source,
+			"export const plugin = { name: 'weather', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const result = await installPlugin({ source });
+
+		expect(result.installPath).toContain(join(home, ".cline", "plugins"));
+		expect(result.entryPaths).toHaveLength(1);
+		expect(existsSync(result.entryPaths[0] ?? "")).toBe(true);
+		const discovered = discoverPluginModulePaths(
+			join(home, ".cline", "plugins"),
+		);
+		expect(discovered).toEqual(result.entryPaths);
+	});
+
+	it("installs a remote plugin file into the workspace plugin root", async () => {
+		const source =
+			"https://github.com/acme/plugins/blob/main/weather-metrics.ts";
+		const fetchMock = vi.fn<FetchCall>(async (input) => {
+			expect(String(input)).toBe(
+				"https://raw.githubusercontent.com/acme/plugins/main/weather-metrics.ts",
+			);
+			return new Response(
+				"export default { name: 'remote-weather', manifest: { capabilities: ['tools'] } };",
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const result = await installPlugin({ source, cwd: workspace });
+
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+		expect(result.installPath).toContain(
+			join(workspace, ".cline", "plugins", "_installed", "remote"),
+		);
+		expect(result.entryPaths).toHaveLength(1);
+		expect(existsSync(result.entryPaths[0] ?? "")).toBe(true);
+		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
+			"remote-weather",
+		);
+		expect(
+			discoverPluginModulePaths(join(workspace, ".cline", "plugins")),
+		).toEqual(result.entryPaths);
+	});
+
+	it("installs an official plugin slug from the configured collection repo", async () => {
+		const officialPluginsRepo = await createOfficialPluginsRepo({
+			"web-search": {
+				"index.ts":
+					"export default { name: 'official-web-search', manifest: { capabilities: ['tools'] } };",
+			},
+			"other-plugin": {
+				"index.ts":
+					"export default { name: 'other-plugin', manifest: { capabilities: ['tools'] } };",
+			},
+		});
+
+		const result = await installPlugin({
+			source: "web-search",
+			cwd: workspace,
+			officialPluginsRepo,
+		});
+
+		expect(result.installPath).toContain(
+			join(workspace, ".cline", "plugins", "_installed", "official"),
+		);
+		expect(result.entryPaths).toHaveLength(1);
+		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
+			"official-web-search",
+		);
+		const wrapperManifest = JSON.parse(
+			readFileSync(join(result.installPath, "package.json"), "utf8"),
+		) as { name?: string };
+		expect(wrapperManifest.name).toBe("web-search");
+		expect(existsSync(join(result.installPath, "repo"))).toBe(false);
+		expect(
+			existsSync(join(result.installPath, "package", "other-plugin")),
+		).toBe(false);
+		expect(
+			discoverPluginModulePaths(join(workspace, ".cline", "plugins")),
+		).toEqual(result.entryPaths);
+	});
+
+	it("installs an official package plugin and runs package dependency install", async () => {
+		const officialPluginsRepo = await createOfficialPluginsRepo({
+			"package-plugin": {
+				"package.json": JSON.stringify(
+					{
+						name: "package-plugin",
+						type: "module",
+						cline: {
+							plugins: [{ paths: ["./index.ts"] }],
+						},
+						dependencies: {
+							yaml: "^2.8.1",
+						},
+					},
+					null,
+					2,
+				),
+				"index.ts":
+					"export default { name: 'package-plugin', manifest: { capabilities: ['tools'] } };",
+			},
+		});
+		const npmLogPath = join(root, "official-npm-install.log");
+		const npmCommandPath = join(root, "official-fake-npm.sh");
+		writeFileSync(
+			npmCommandPath,
+			`#!/bin/sh\nprintf '%s\\n' "$PWD $*" >> "${npmLogPath}"\nexit 0\n`,
+			{ encoding: "utf8", mode: 0o755 },
+		);
+
+		const result = await installPlugin({
+			source: "package-plugin",
+			cwd: workspace,
+			officialPluginsRepo,
+			npmCommand: npmCommandPath,
+		});
+
+		const npmLog = readFileSync(npmLogPath, "utf8");
+		expect(npmLog).toContain("package install --omit=dev --omit=peer");
+		expect(result.entryPaths).toHaveLength(1);
+		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
+			"package-plugin",
+		);
+	});
+
+	it("reports a clear error when an official plugin slug is missing", async () => {
+		const officialPluginsRepo = await createOfficialPluginsRepo({
+			"known-plugin": {
+				"index.ts":
+					"export default { name: 'known-plugin', manifest: { capabilities: ['tools'] } };",
+			},
+		});
+
+		await expect(
+			installPlugin({
+				source: "missing-plugin",
+				cwd: workspace,
+				officialPluginsRepo,
+			}),
+		).rejects.toThrow(
+			/Official Cline plugin "missing-plugin" was not found at plugins\/missing-plugin/,
+		);
+	});
+
+	it("keeps explicit relative paths as local plugin installs", async () => {
+		const localPluginRoot = join(workspace, "web-search");
+		await mkdir(localPluginRoot, { recursive: true });
+		await writeFile(
+			join(localPluginRoot, "index.ts"),
+			"export default { name: 'local-web-search', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const result = await installPlugin({
+			source: "./web-search",
+			cwd: workspace,
+		});
+
+		expect(result.installPath).toContain(
+			join(workspace, ".cline", "plugins", "_installed", "local"),
+		);
+		const wrapperManifest = JSON.parse(
+			readFileSync(join(result.installPath, "package.json"), "utf8"),
+		) as { name?: string };
+		expect(wrapperManifest.name).toBe("web-search");
+		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
+			"local-web-search",
+		);
+	});
+
+	it("times out stalled remote plugin downloads", async () => {
+		vi.useFakeTimers();
+		const source =
+			"https://github.com/acme/plugins/blob/main/weather-metrics.ts";
+		const fetchMock = vi.fn<FetchCall>((_input, init) => {
+			return new Promise<Response>((_resolve, reject) => {
+				init?.signal?.addEventListener("abort", () => {
+					const error = new Error("Aborted");
+					error.name = "AbortError";
+					reject(error);
+				});
+			});
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const install = installPlugin({ source, cwd: workspace });
+		const rejection = expect(install).rejects.toThrow(/Timed out downloading/);
+		await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
+		await vi.advanceTimersByTimeAsync(30_000);
+
+		await rejection;
+	});
+
+	it("rejects remote plugin files with oversized content length", async () => {
+		const source =
+			"https://github.com/acme/plugins/blob/main/weather-metrics.ts";
+		const fetchMock = vi.fn<FetchCall>(async () => {
+			return new Response(
+				"export default { name: 'remote-weather', manifest: { capabilities: ['tools'] } };",
+				{
+					headers: {
+						"content-length": String(10 * 1024 * 1024 + 1),
+					},
+				},
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(installPlugin({ source, cwd: workspace })).rejects.toThrow(
+			/exceeds the 10485760 byte limit/,
+		);
+	});
+
+	it("rejects remote plugin files that stream past the size limit", async () => {
+		const source =
+			"https://github.com/acme/plugins/blob/main/weather-metrics.ts";
+		const fetchMock = vi.fn<FetchCall>(async () => {
+			return new Response(
+				new ReadableStream<Uint8Array>({
+					start(controller) {
+						controller.enqueue(new Uint8Array(10 * 1024 * 1024 + 1));
+						controller.close();
+					},
+				}),
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(installPlugin({ source, cwd: workspace })).rejects.toThrow(
+			/exceeds the 10485760 byte limit/,
+		);
+	});
+
+	it("installs into cwd plugin root when cwd is provided", async () => {
+		const source = join(root, "plugin-package");
+		const npmLogPath = join(root, "npm-install.log");
+		const npmCommandPath = join(root, "fake-npm.sh");
+		writeFileSync(
+			npmCommandPath,
+			`#!/bin/sh\nprintf '%s\\n' "$PWD $*" >> "${npmLogPath}"\nexit 0\n`,
+			{ encoding: "utf8", mode: 0o755 },
+		);
+		await mkdir(join(source, "node_modules", "dependency"), {
+			recursive: true,
+		});
+		await writeFile(
+			join(source, "package.json"),
+			JSON.stringify(
+				{
+					name: "plugin-package",
+					cline: {
+						plugins: [{ paths: ["./index.ts"], capabilities: ["tools"] }],
+					},
+					dependencies: {
+						"@cline/core": "latest",
+						yaml: "^2.8.1",
+					},
+					peerDependencies: {
+						"@cline/shared": "*",
+						bun: ">=1.0.0",
+					},
+					peerDependenciesMeta: {
+						"@cline/shared": {
+							optional: true,
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		await writeFile(
+			join(source, "index.ts"),
+			"export default { name: 'plugin-package', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(source, "node_modules", "dependency", "noise.ts"),
+			"export default { name: 'noise', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		await mkdir(join(source, ".git", "objects"), { recursive: true });
+		await writeFile(join(source, ".git", "HEAD"), "ref: refs/heads/main\n");
+
+		const result = await installPlugin({
+			source,
+			cwd: workspace,
+			npmCommand: npmCommandPath,
+		});
+
+		const wrapperManifest = JSON.parse(
+			readFileSync(join(result.installPath, "package.json"), "utf8"),
+		) as { name?: string; cline?: { plugins?: Array<{ paths?: string[] }> } };
+		expect(wrapperManifest.name).toBe("plugin-package");
+		expect(wrapperManifest.cline?.plugins?.[0]?.paths).toHaveLength(1);
+		expect(wrapperManifest.cline?.plugins?.[0]?.paths?.[0]).toContain(
+			"package/index.ts",
+		);
+		const packageManifest = JSON.parse(
+			readFileSync(join(result.installPath, "package", "package.json"), "utf8"),
+		) as {
+			dependencies?: Record<string, string>;
+			peerDependencies?: Record<string, string>;
+			peerDependenciesMeta?: Record<string, unknown>;
+		};
+		expect(packageManifest.dependencies).toEqual({ yaml: "^2.8.1" });
+		expect(packageManifest.peerDependencies).toEqual({ bun: ">=1.0.0" });
+		expect(packageManifest.peerDependenciesMeta).toBeUndefined();
+		const npmLog = readFileSync(npmLogPath, "utf8");
+		expect(npmLog).toContain(`${join(".tmp")}/`);
+		expect(npmLog).toContain(
+			"package install --omit=dev --omit=peer --legacy-peer-deps --no-audit --no-fund --package-lock=false",
+		);
+		expect(existsSync(join(result.installPath, "package", ".git"))).toBe(false);
+		expect(
+			existsSync(join(result.installPath, "package", "node_modules")),
+		).toBe(false);
+		const discovered = discoverPluginModulePaths(
+			join(workspace, ".cline", "plugins"),
+		);
+		expect(discovered).toEqual(result.entryPaths);
+		expect(discovered.some((path) => path.includes("noise.ts"))).toBe(false);
+	});
+
+	it("omits and removes host SDK packages from npm-sourced installs", async () => {
+		const npmLogPath = join(root, "npm-source-install.log");
+		const npmCommandPath = join(root, "fake-npm-source.sh");
+		writeFileSync(
+			npmCommandPath,
+			[
+				"#!/bin/sh",
+				`printf '%s\\n' "$*" >> "${npmLogPath}"`,
+				"prefix=''",
+				"while [ $# -gt 0 ]; do",
+				"  if [ \"$1\" = '--prefix' ]; then",
+				"    shift",
+				'    prefix="$1"',
+				"  fi",
+				"  shift",
+				"done",
+				'mkdir -p "$prefix/node_modules/published-plugin"',
+				'mkdir -p "$prefix/node_modules/@cline/core"',
+				'printf \'%s\\n\' \'{"name":"published-plugin","type":"module","cline":{"plugins":["index.ts"]}}\' > "$prefix/node_modules/published-plugin/package.json"',
+				"printf '%s\\n' \"export default { name: 'published-plugin', manifest: { capabilities: ['tools'] } };\" > \"$prefix/node_modules/published-plugin/index.ts\"",
+				'printf \'%s\\n\' \'{"name":"@cline/core"}\' > "$prefix/node_modules/@cline/core/package.json"',
+				"exit 0",
+			].join("\n"),
+			{ encoding: "utf8", mode: 0o755 },
+		);
+
+		const result = await installPlugin({
+			source: "npm:published-plugin@1.0.0",
+			npmCommand: npmCommandPath,
+		});
+
+		const npmLog = readFileSync(npmLogPath, "utf8");
+		expect(npmLog).toContain("install published-plugin@1.0.0");
+		expect(npmLog).toContain("--omit=peer");
+		expect(npmLog).toContain("--legacy-peer-deps");
+		expect(
+			existsSync(
+				join(result.installPath, "package", "node_modules", "@cline", "core"),
+			),
+		).toBe(false);
+		expect(existsSync(result.entryPaths[0] ?? "")).toBe(true);
+	});
+
+	it("requires --force before replacing an existing install", async () => {
+		const source = join(root, "replace.ts");
+		writeFileSync(
+			source,
+			"export default { name: 'replace', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const first = await installPlugin({ source });
+		await expect(installPlugin({ source })).rejects.toThrow(/Use --force/);
+		const second = await installPlugin({ source, force: true });
+
+		expect(second.installPath).toBe(first.installPath);
+	});
+
+	it("keeps an existing install when a forced replacement fails during staging", async () => {
+		const source = join(root, "replace-package");
+		const npmCommandPath = join(root, "fake-npm.sh");
+		await mkdir(source, { recursive: true });
+		await writeFile(
+			join(source, "package.json"),
+			JSON.stringify(
+				{
+					name: "replace-package",
+					cline: {
+						plugins: [{ paths: ["./index.ts"], capabilities: ["tools"] }],
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		await writeFile(
+			join(source, "index.ts"),
+			"export default { name: 'installed-v1', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		writeFileSync(npmCommandPath, "#!/bin/sh\nexit 0\n", {
+			encoding: "utf8",
+			mode: 0o755,
+		});
+
+		const first = await installPlugin({ source, npmCommand: npmCommandPath });
+		await writeFile(
+			join(source, "index.ts"),
+			"export default { name: 'installed-v2', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		writeFileSync(npmCommandPath, "#!/bin/sh\nprintf 'offline' >&2\nexit 1\n", {
+			encoding: "utf8",
+			mode: 0o755,
+		});
+
+		await expect(
+			installPlugin({ source, force: true, npmCommand: npmCommandPath }),
+		).rejects.toThrow(/offline/);
+
+		expect(existsSync(first.installPath)).toBe(true);
+		expect(
+			readFileSync(join(first.installPath, "package", "index.ts"), "utf8"),
+		).toContain("installed-v1");
+	});
+
+	it("uninstalls a package plugin by package name", async () => {
+		const source = join(root, "uninstall-package");
+		const npmCommandPath = join(root, "fake-npm.sh");
+		await mkdir(source, { recursive: true });
+		await writeFile(
+			join(source, "package.json"),
+			JSON.stringify(
+				{
+					name: "cli-uninstall-plugin",
+					cline: {
+						plugins: [{ paths: ["./index.ts"], capabilities: ["tools"] }],
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		await writeFile(
+			join(source, "index.ts"),
+			"export default { name: 'cli-uninstall-plugin', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		writeFileSync(npmCommandPath, "#!/bin/sh\nexit 0\n", {
+			encoding: "utf8",
+			mode: 0o755,
+		});
+
+		const installed = await installPlugin({
+			source,
+			npmCommand: npmCommandPath,
+		});
+		const output: string[] = [];
+		const code = await runPluginUninstallCommand({
+			name: "cli-uninstall-plugin",
+			io: {
+				writeln: (text = "") => output.push(text),
+				writeErr: (text) => output.push(text),
+			},
+		});
+
+		expect(code).toBe(0);
+		expect(existsSync(installed.installPath)).toBe(false);
+		expect(output.join("\n")).toContain(
+			"Uninstalled plugin cli-uninstall-plugin",
+		);
+	});
+
+	it("prints JSON output for command callers", async () => {
+		const source = join(root, "json.ts");
+		writeFileSync(
+			source,
+			"export default { name: 'json', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		const stdout: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			stdout.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			const code = await runPluginInstallCommand({
+				source,
+				json: true,
+				io: {
+					writeln: () => {},
+					writeErr: () => {},
+				},
+			});
+			expect(code).toBe(0);
+			const parsed = JSON.parse(stdout.join("")) as { installPath: string };
+			expect(parsed.installPath).toContain(join(home, ".cline", "plugins"));
+			expect("mcpOAuthCandidates" in parsed).toBe(false);
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	it("does not run MCP OAuth follow-up for JSON plugin installs", async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
+		const source = join(root, "json-oauth-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "json-oauth-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "json-oauth-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		const stdout: string[] = [];
+		const originalWrite = process.stdout.write;
+		const authorize = vi.fn();
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			stdout.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			const code = await runPluginInstallCommand({
+				source,
+				json: true,
+				io: {
+					writeln: () => {},
+					writeErr: () => {},
+				},
+				mcpOAuth: {
+					interactive: true,
+					selectCandidates: async (candidates) => candidates,
+					authorize,
+				},
+			});
+			expect(code).toBe(0);
+			expect(authorize).not.toHaveBeenCalled();
+			const parsed = JSON.parse(stdout.join("")) as {
+				installPath: string;
+				mcpOAuthCandidates?: unknown;
+			};
+			expect(parsed.installPath).toContain(join(home, ".cline", "plugins"));
+			expect(parsed.mcpOAuthCandidates).toBeUndefined();
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	it("warns when plugin MCP settings sync fails after install", async () => {
+		const source = join(root, "mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "mcp-plugin",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		const blockedDirectory = join(root, "not-a-directory");
+		writeFileSync(blockedDirectory, "file", "utf8");
+		const originalSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+		process.env.CLINE_MCP_SETTINGS_PATH = join(
+			blockedDirectory,
+			"cline_mcp_settings.json",
+		);
+		const output: string[] = [];
+		try {
+			const code = await runPluginInstallCommand({
+				source,
+				io: {
+					writeln: (text = "") => output.push(text),
+					writeErr: (text) => output.push(text),
+				},
+			});
+
+			expect(code).toBe(0);
+			expect(output.join("\n")).toContain("Installed plugin from");
+			expect(output.join("\n")).toContain(
+				"Warning: failed to sync plugin MCP servers",
+			);
+			expect(output.join("\n")).toContain("mcp-plugin");
+		} finally {
+			if (originalSettingsPath === undefined) {
+				delete process.env.CLINE_MCP_SETTINGS_PATH;
+			} else {
+				process.env.CLINE_MCP_SETTINGS_PATH = originalSettingsPath;
+			}
+		}
+	});
+
+	it("detects plugin-owned remote MCP servers as OAuth candidates", async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
+		const source = join(root, "oauth-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "oauth-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "oauth-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+
+		const result = await installPlugin({ source });
+
+		expect(result.mcpOAuthCandidates).toEqual([
+			expect.objectContaining({
+				name: "oauth-docs",
+				pluginName: "oauth-mcp-plugin",
+				transportType: "streamableHttp",
+			}),
+		]);
+	});
+
+	it("does not treat remote MCP servers with static headers as OAuth candidates", async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
+		const source = join(root, "headers-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "headers-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "headers-docs",
+      transport: {
+        type: "streamableHttp",
+        url: "https://example.com/mcp",
+        headers: { Authorization: "Bearer token" },
+      },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+
+		const result = await installPlugin({ source });
+
+		expect(result.mcpOAuthCandidates).toEqual([]);
+	});
+
+	it("skips plugin MCP OAuth candidates that already have tokens", async () => {
+		const settingsPath = join(root, "mcp-settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		const source = join(root, "authorized-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "authorized-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "authorized-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		const result = await installPlugin({ source });
+		const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { oauth?: unknown }>;
+		};
+		const server = settings.mcpServers?.["authorized-docs"];
+		if (!server) {
+			throw new Error("Expected authorized-docs MCP server to be written");
+		}
+		server.oauth = { tokens: { access_token: "oauth-token" } };
+		writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+
+		expect(
+			collectPluginMcpOAuthCandidates({
+				pluginPaths: result.entryPaths,
+				settingsPath,
+			}),
+		).toEqual([]);
+	});
+
+	it("authorizes selected plugin MCP OAuth candidates during interactive installs", async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
+		const source = join(root, "interactive-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "interactive-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "interactive-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		const authorized: string[] = [];
+		const output: string[] = [];
+
+		const code = await runPluginInstallCommand({
+			source,
+			io: {
+				writeln: (text = "") => output.push(text),
+				writeErr: (text) => output.push(text),
+			},
+			mcpOAuth: {
+				interactive: true,
+				selectCandidates: async (candidates) => candidates,
+				authorize: async (candidate) => {
+					authorized.push(candidate.name);
+				},
+			},
+		});
+
+		expect(code).toBe(0);
+		expect(authorized).toEqual(["interactive-docs"]);
+		expect(output.join("\n")).toContain("Installed plugin from");
+	});
+
+	it("keeps plugin install successful when MCP OAuth authorization fails", async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
+		const source = join(root, "failing-oauth-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "failing-oauth-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "failing-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		const output: string[] = [];
+
+		const code = await runPluginInstallCommand({
+			source,
+			io: {
+				writeln: (text = "") => output.push(text),
+				writeErr: (text) => output.push(text),
+			},
+			mcpOAuth: {
+				interactive: true,
+				selectCandidates: async (candidates) => candidates,
+				authorize: async () => {
+					throw new Error("oauth unavailable");
+				},
+			},
+		});
+
+		expect(code).toBe(0);
+		expect(output.join("\n")).toContain(
+			"Warning: failed to authorize MCP server failing-docs: oauth unavailable",
+		);
+	});
+
+	it("prints guidance for plugin MCP OAuth candidates in non-interactive installs", async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
+		const source = join(root, "non-interactive-mcp-plugin.js");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "non-interactive-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "non-interactive-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		const output: string[] = [];
+		const authorize = vi.fn();
+
+		const code = await runPluginInstallCommand({
+			source,
+			io: {
+				writeln: (text = "") => output.push(text),
+				writeErr: (text) => output.push(text),
+			},
+			mcpOAuth: {
+				interactive: false,
+				authorize,
+			},
+		});
+
+		expect(code).toBe(0);
+		expect(authorize).not.toHaveBeenCalled();
+		expect(output.join("\n")).toContain(
+			"Plugin MCP servers may require OAuth authorization",
+		);
+		expect(output.join("\n")).toContain("non-interactive-docs");
+		expect(output.join("\n")).toContain('Run "cline mcp"');
+	});
+
+	it("prints JSON output for official plugin installs", async () => {
+		const officialPluginsRepo = await createOfficialPluginsRepo({
+			"json-plugin": {
+				"index.ts":
+					"export default { name: 'json-plugin', manifest: { capabilities: ['tools'] } };",
+			},
+		});
+		const stdout: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			stdout.push(String(chunk));
+			return true;
+		}) as typeof process.stdout.write;
+		try {
+			const code = await runPluginInstallCommand({
+				source: "json-plugin",
+				cwd: workspace,
+				officialPluginsRepo,
+				json: true,
+				io: {
+					writeln: () => {},
+					writeErr: () => {},
+				},
+			});
+			expect(code).toBe(0);
+			const parsed = JSON.parse(stdout.join("")) as { installPath: string };
+			expect(parsed.installPath).toContain(
+				join(workspace, ".cline", "plugins", "_installed", "official"),
+			);
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+	});
+
+	it("uses shared search paths for cwd installs", async () => {
+		const source = join(root, "workspace.ts");
+		writeFileSync(
+			source,
+			"export default { name: 'workspace', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		await installPlugin({
+			source,
+			cwd: workspace,
+		});
+
+		expect(resolvePluginConfigSearchPaths(workspace)[0]).toBe(
+			join(workspace, ".cline", "plugins"),
+		);
+		expect(
+			discoverPluginModulePaths(join(workspace, ".cline", "plugins")),
+		).toHaveLength(1);
+	});
+});
diff --git a/apps/cli/src/commands/plugin.ts b/apps/cli/src/commands/plugin.ts
new file mode 100644
index 0000000..1fc74cb
--- /dev/null
+++ b/apps/cli/src/commands/plugin.ts
@@ -0,0 +1,200 @@
+import {
+	installPlugin,
+	type PluginInstallOptions,
+	type PluginInstallResult,
+	type PluginMcpOAuthCandidate,
+	type PluginUninstallOptions,
+	uninstallPlugin,
+} from "@cline/core";
+
+export type {
+	PluginInstallOptions,
+	PluginInstallResult,
+	PluginMcpOAuthCandidate,
+} from "@cline/core";
+export {
+	collectPluginMcpOAuthCandidates,
+	installPlugin,
+	isOfficialPluginSlug,
+	parsePluginSource,
+} from "@cline/core";
+
+export interface PluginInstallMcpOAuthOptions {
+	interactive?: boolean;
+	selectCandidates?: (
+		candidates: PluginMcpOAuthCandidate[],
+	) => Promise<PluginMcpOAuthCandidate[]>;
+	authorize?: (candidate: PluginMcpOAuthCandidate) => Promise<void>;
+}
+
+export interface PluginInstallIo {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+}
+
+type PluginInstallCommandOptions = PluginInstallOptions & {
+	json?: boolean;
+	io?: PluginInstallIo;
+	mcpOAuth?: PluginInstallMcpOAuthOptions;
+};
+
+function serializePluginInstallResult(
+	result: PluginInstallResult,
+): Omit<PluginInstallResult, "mcpOAuthCandidates"> {
+	return {
+		source: result.source,
+		installPath: result.installPath,
+		entryPaths: result.entryPaths,
+		mcpSyncFailures: result.mcpSyncFailures,
+	};
+}
+
+function isInteractivePluginInstall(
+	options: PluginInstallCommandOptions,
+): boolean {
+	return (
+		options.mcpOAuth?.interactive ??
+		(process.stdin.isTTY && process.stdout.isTTY)
+	);
+}
+
+async function selectMcpOAuthCandidatesWithClack(
+	candidates: PluginMcpOAuthCandidate[],
+): Promise<PluginMcpOAuthCandidate[]> {
+	const p = await import("@clack/prompts");
+	const action = await p.select({
+		message: "Authorize plugin MCP servers now?",
+		options: [
+			{
+				value: "all",
+				label: "Authorize all",
+				hint: "open browser authorization for each server",
+			},
+			{
+				value: "choose",
+				label: "Choose servers",
+				hint: "select which servers to authorize",
+			},
+			{
+				value: "skip",
+				label: "Skip",
+			},
+		],
+	});
+	if (p.isCancel(action) || action === "skip") {
+		return [];
+	}
+	if (action === "all") {
+		return candidates;
+	}
+
+	const selectedNames = await p.multiselect({
+		message: "Select MCP servers to authorize",
+		options: candidates.map((candidate) => ({
+			value: candidate.name,
+			label: candidate.name,
+			hint: `${candidate.transportType} [${candidate.pluginName}]`,
+		})),
+		required: false,
+	});
+	if (p.isCancel(selectedNames) || !Array.isArray(selectedNames)) {
+		return [];
+	}
+	const selected = new Set(selectedNames);
+	return candidates.filter((candidate) => selected.has(candidate.name));
+}
+
+async function authorizeMcpOAuthCandidate(
+	candidate: PluginMcpOAuthCandidate,
+): Promise<void> {
+	const { authorizeMcpServerOAuthWithBrowser } = await import(
+		"../wizards/mcp/oauth"
+	);
+	await authorizeMcpServerOAuthWithBrowser(candidate.name, {
+		throwOnError: true,
+	});
+}
+
+async function runPluginMcpOAuthFollowup(
+	candidates: PluginMcpOAuthCandidate[],
+	options: PluginInstallCommandOptions,
+): Promise<void> {
+	if (candidates.length === 0) {
+		return;
+	}
+
+	if (!isInteractivePluginInstall(options)) {
+		options.io?.writeln("Plugin MCP servers may require OAuth authorization:");
+		for (const candidate of candidates) {
+			options.io?.writeln(
+				`  ${candidate.name} (${candidate.transportType}, plugin: ${candidate.pluginName})`,
+			);
+		}
+		options.io?.writeln(
+			'Run "cline mcp" and choose "Authorize OAuth" to authorize them.',
+		);
+		return;
+	}
+
+	const selected =
+		options.mcpOAuth?.selectCandidates !== undefined
+			? await options.mcpOAuth.selectCandidates(candidates)
+			: await selectMcpOAuthCandidatesWithClack(candidates);
+	const authorize = options.mcpOAuth?.authorize ?? authorizeMcpOAuthCandidate;
+	for (const candidate of selected) {
+		try {
+			await authorize(candidate);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			options.io?.writeErr(
+				`Warning: failed to authorize MCP server ${candidate.name}: ${message}. Run "cline mcp" and choose "Authorize OAuth" to retry.`,
+			);
+		}
+	}
+}
+
+export async function runPluginInstallCommand(
+	options: PluginInstallCommandOptions,
+): Promise<number> {
+	try {
+		const result = await installPlugin(options);
+		if (options.json) {
+			process.stdout.write(
+				JSON.stringify(serializePluginInstallResult(result)),
+			);
+			return 0;
+		}
+		options.io?.writeln(`Installed plugin from ${result.source}`);
+		options.io?.writeln(`  Path: ${result.installPath}`);
+		for (const failure of result.mcpSyncFailures) {
+			options.io?.writeErr(
+				`Warning: failed to sync plugin MCP servers for ${failure.pluginName ?? failure.pluginPath}: ${failure.message}`,
+			);
+		}
+		await runPluginMcpOAuthFollowup(result.mcpOAuthCandidates, options);
+		return 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		options.io?.writeErr(message);
+		return 1;
+	}
+}
+
+export async function runPluginUninstallCommand(
+	options: PluginUninstallOptions & { json?: boolean; io?: PluginInstallIo },
+): Promise<number> {
+	try {
+		const result = await uninstallPlugin(options);
+		if (options.json) {
+			process.stdout.write(JSON.stringify(result));
+			return 0;
+		}
+		options.io?.writeln(`Uninstalled plugin ${result.name}`);
+		options.io?.writeln(`  Removed: ${result.installPath}`);
+		return 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		options.io?.writeErr(message);
+		return 1;
+	}
+}
diff --git a/apps/cli/src/commands/program.ts b/apps/cli/src/commands/program.ts
new file mode 100644
index 0000000..11fe2d8
--- /dev/null
+++ b/apps/cli/src/commands/program.ts
@@ -0,0 +1,240 @@
+import { Command, CommanderError, Option } from "commander";
+import { version } from "../../package.json";
+import {
+	CLI_COMPACTION_MODE_OPTION_DESCRIPTION,
+	parseCliCompactionMode,
+} from "../utils/compaction-mode";
+import type { ParsedArgs } from "../utils/types";
+
+export { CommanderError };
+
+function normalizeAutoApproveValue(
+	value: string | boolean | undefined,
+): string {
+	if (value === undefined || value === true) {
+		return "true";
+	}
+	return String(value);
+}
+
+/**
+ * Add the shared root-level options to any command.
+ */
+export function addRootOptions(cmd: Command): Command {
+	return (
+		cmd
+			.option("-p, --plan", "Run in plan mode")
+			.option("--json", "Output messages as JSON instead of styled text")
+			.option(
+				"--auto-approve <boolean>",
+				"Set tool auto-approval for all tools (default: true)",
+				normalizeAutoApproveValue,
+			)
+			.option("-c, --cwd <path>", "Working directory")
+			.option(
+				"--thinking <level>",
+				"Set reasoning effort: none|low|medium|high|xhigh. Bare --thinking uses medium; omitted leaves provider default.",
+			)
+			.option("--compaction <mode>", CLI_COMPACTION_MODE_OPTION_DESCRIPTION)
+			.option(
+				"-i, --tui",
+				"Open the terminal user interface (TUI) for interactive sessions",
+			)
+			.option("--id <session-id>", "Resume an existing session by ID")
+			.option("-P, --provider <id>", "Provider id (default: cline)")
+			.option("-k, --key <api-key>", "API key override for this run")
+			.option(
+				"-m, --model <model-id>",
+				"Model to use for the session with the selected provider",
+			)
+			.option(
+				"-s, --system <system-prompt>",
+				"Override the default system prompt",
+			)
+			.option("-z, --zen", "Start a session that runs in the background hub")
+			.option(
+				"--retries [value]",
+				"Number of maximum consecutive mistakes (retries) before exiting (default: 6)",
+			)
+			.option(
+				"-t, --timeout <seconds>",
+				"Optional timeout in seconds (default: 0 for no timeout)",
+			)
+			.option(
+				"--acp",
+				"Run in Agent Client Protocol (ACP) mode for editor integration",
+			)
+			.option(
+				"--config <path>",
+				"Configuration directory (default: ~/.cline/data/settings)",
+			)
+			.option(
+				"--data-dir <path>",
+				"Use isolated local state at this directory path (default: ~/.cline)",
+			)
+			.option(
+				"--hooks-dir <path>",
+				"Directory path to additional hooks for runtime hook injection (default: ~/.cline/hooks)",
+			)
+			.option(
+				"--worktree",
+				"Auto-create a detached git worktree under ~/.cline/worktrees/ and run the task there",
+			)
+			.option("--update", "Check for updates and install if available")
+			.option("--kanban", "Run the kanban app")
+			.option("-v, --verbose", "Show verbose output")
+			// HIDDEN/LEGACY OPTIONS BELOW
+			.addOption(
+				// Act mode is the default. Keep the legacy flags accepted for users who
+				// still pass them, but do not advertise them in help output.
+				new Option("-a, --act", "Run in act mode").hideHelp(),
+			)
+			.addOption(
+				// `-y, --yolo` is still accepted (and behaves the same as before) but
+				// hidden from `--help` output.
+				new Option(
+					"-y, --yolo",
+					"Enable yolo mode where agents can use tools without approval with only a small set of tools available.",
+				).hideHelp(),
+			)
+			.addOption(
+				// TODO: Refactor teams to resume session without team name
+				new Option(
+					"--team-name <name>",
+					"Override the runtime team state name",
+				).hideHelp(),
+			)
+	);
+}
+
+export function createProgram(): Command {
+	const program = new Command("cline")
+		.description("Cline CLI - AI coding assistant in your terminal")
+		.version(version, "-V, --version", "Output the version number")
+		.exitOverride() // don't call process.exit
+		.configureOutput({
+			writeOut: () => {}, // suppress by default; main.ts re-enables for routing
+			writeErr: () => {},
+		})
+		.allowExcessArguments()
+		.enablePositionalOptions()
+		.argument(
+			"[prompt]",
+			"Your prompt. Default to start in act mode with auto-approve enabled.",
+		);
+
+	addRootOptions(program);
+
+	return program;
+}
+
+export function commanderToParsedArgs(program: Command): ParsedArgs {
+	const opts = program.opts();
+
+	const result: ParsedArgs = {
+		verbose: !!opts.verbose,
+		interactive: !!opts.tui,
+		outputMode: opts.json ? "json" : "text",
+		mode: opts.plan ? "plan" : opts.yolo ? "yolo" : opts.zen ? "zen" : "act",
+		sandbox: !!opts.dataDir,
+		acpMode: !!opts.acp,
+		thinking: false,
+		reasoningEffort: undefined,
+		defaultToolAutoApprove: true,
+		id: opts.id,
+	};
+
+	// Approval: last-wins semantics
+	if (opts.autoApprove !== undefined) {
+		const raw = String(opts.autoApprove).trim().toLowerCase();
+		if (raw === "true") {
+			result.defaultToolAutoApprove = true;
+			result.autoApproveOverride = true;
+		} else if (raw === "false") {
+			result.defaultToolAutoApprove = false;
+			result.autoApproveOverride = false;
+		} else if (raw) {
+			result.invalidAutoApprove = raw;
+		}
+	}
+	if (opts.yolo) {
+		result.defaultToolAutoApprove = true;
+		result.autoApproveOverride = true;
+	}
+
+	// Timeout validation
+	if (opts.timeout !== undefined) {
+		const raw = opts.timeout.trim();
+		const parsed = Number.parseInt(raw, 10);
+		if (raw && Number.isInteger(parsed) && parsed >= 1) {
+			result.timeoutSeconds = parsed;
+		} else if (raw) {
+			result.invalidTimeoutSeconds = raw;
+		}
+	}
+
+	if (opts.thinking !== undefined) {
+		const effort = String(opts.thinking).trim().toLowerCase();
+		if (
+			effort === "none" ||
+			effort === "low" ||
+			effort === "medium" ||
+			effort === "high" ||
+			effort === "xhigh"
+		) {
+			result.thinkingExplicitlySet = true;
+			if (effort === "none") {
+				result.thinking = false;
+				result.reasoningEffort = undefined;
+			} else {
+				result.thinking = true;
+				result.reasoningEffort = effort;
+			}
+		} else if (effort) {
+			result.invalidThinkingLevel = effort;
+		}
+	}
+
+	if (opts.compaction !== undefined) {
+		const mode = String(opts.compaction).trim().toLowerCase();
+		const compactionMode = parseCliCompactionMode(mode);
+		if (compactionMode) {
+			result.compactionMode = compactionMode;
+		} else if (mode) {
+			result.invalidCompactionMode = mode;
+		}
+	}
+
+	// Retries (max consecutive mistakes) validation
+	if (opts.retries !== undefined) {
+		const raw = opts.retries.trim();
+		const parsed = Number.parseInt(raw, 10);
+		if (raw && Number.isInteger(parsed) && parsed >= 1) {
+			result.retries = parsed;
+		} else if (raw) {
+			result.invalidRetries = raw;
+		}
+	}
+
+	// Simple string/number options
+	if (opts.dataDir !== undefined) result.dataDir = opts.dataDir;
+	if (opts.config !== undefined) result.configDir = opts.config;
+	if (opts.hooksDir !== undefined) result.hooksDir = opts.hooksDir;
+	if (opts.worktree !== undefined) result.worktree = !!opts.worktree;
+	if (opts.cwd !== undefined) result.cwd = opts.cwd;
+	if (opts.teamName !== undefined) result.teamName = opts.teamName;
+	if (opts.system !== undefined) result.systemPrompt = opts.system;
+	if (opts.model !== undefined) result.model = opts.model;
+	if (opts.provider !== undefined) result.provider = opts.provider;
+	if (opts.key !== undefined) result.key = opts.key;
+	else if (opts.apiKey !== undefined) result.key = opts.apiKey;
+	if (opts.id !== undefined) result.id = opts.id;
+
+	// Positional args → prompt
+	const positional = program.args;
+	if (positional.length > 0) {
+		result.prompt = positional.join(" ");
+	}
+
+	return result;
+}
diff --git a/apps/cli/src/commands/rpc-runtime/provider-registry.test.ts b/apps/cli/src/commands/rpc-runtime/provider-registry.test.ts
new file mode 100644
index 0000000..8961ae2
--- /dev/null
+++ b/apps/cli/src/commands/rpc-runtime/provider-registry.test.ts
@@ -0,0 +1,192 @@
+import type { SaveProviderSettingsActionRequest } from "@cline/core";
+import {
+	type ProviderSettingsManager,
+	saveLocalProviderSettings,
+} from "@cline/core";
+import { describe, expect, it, vi } from "vitest";
+
+describe("saveLocalProviderSettings", () => {
+	it("ignores null apiKey/baseUrl updates", () => {
+		const save = vi.fn();
+		const manager = {
+			read: vi.fn().mockReturnValue({
+				providers: {},
+			}),
+			write: vi.fn(),
+			getFilePath: vi.fn().mockReturnValue("/tmp/providers.json"),
+			getProviderSettings: vi.fn().mockReturnValue({
+				provider: "openai",
+				apiKey: "existing-key",
+				baseUrl: "https://api.example.com",
+			}),
+			saveProviderSettings: save,
+		};
+
+		saveLocalProviderSettings(
+			manager as unknown as ProviderSettingsManager,
+			{
+				action: "saveProviderSettings",
+				providerId: "openai",
+				apiKey: null,
+				baseUrl: null,
+			} as unknown as SaveProviderSettingsActionRequest,
+		);
+
+		expect(save).toHaveBeenCalledTimes(1);
+		expect(save).toHaveBeenCalledWith(
+			{
+				provider: "openai",
+				apiKey: "existing-key",
+				baseUrl: "https://api.example.com",
+			},
+			{ setLastUsed: false },
+		);
+	});
+
+	it("clears apiKey/baseUrl when explicit blank strings are provided", () => {
+		const save = vi.fn();
+		const manager = {
+			read: vi.fn().mockReturnValue({
+				providers: {},
+			}),
+			write: vi.fn(),
+			getFilePath: vi.fn().mockReturnValue("/tmp/providers.json"),
+			getProviderSettings: vi.fn().mockReturnValue({
+				provider: "openai",
+				apiKey: "existing-key",
+				baseUrl: "https://api.example.com",
+			}),
+			saveProviderSettings: save,
+		};
+
+		saveLocalProviderSettings(
+			manager as unknown as ProviderSettingsManager,
+			{
+				action: "saveProviderSettings",
+				providerId: "openai",
+				apiKey: "   ",
+				baseUrl: "",
+			} as SaveProviderSettingsActionRequest,
+		);
+
+		expect(save).toHaveBeenCalledTimes(1);
+		expect(save).toHaveBeenCalledWith(
+			{
+				provider: "openai",
+			},
+			{ setLastUsed: false },
+		);
+	});
+
+	it("merges and clears Azure provider settings", () => {
+		const save = vi.fn();
+		const manager = {
+			read: vi.fn().mockReturnValue({
+				providers: {},
+			}),
+			write: vi.fn(),
+			getFilePath: vi.fn().mockReturnValue("/tmp/providers.json"),
+			getProviderSettings: vi.fn().mockReturnValue({
+				provider: "openai-compatible",
+				azure: {
+					apiVersion: "2024-10-21",
+					useIdentity: true,
+				},
+			}),
+			saveProviderSettings: save,
+		};
+
+		saveLocalProviderSettings(
+			manager as unknown as ProviderSettingsManager,
+			{
+				action: "saveProviderSettings",
+				providerId: "openai-compatible",
+				azure: {
+					apiVersion: "2025-01-01-preview",
+				},
+			} as SaveProviderSettingsActionRequest,
+		);
+
+		expect(save).toHaveBeenCalledTimes(1);
+		expect(save).toHaveBeenCalledWith(
+			{
+				provider: "openai-compatible",
+				azure: {
+					apiVersion: "2025-01-01-preview",
+					useIdentity: true,
+				},
+			},
+			{ setLastUsed: false },
+		);
+
+		save.mockClear();
+		manager.getProviderSettings.mockReturnValue({
+			provider: "openai-compatible",
+			azure: {
+				apiVersion: "2025-01-01-preview",
+			},
+		});
+
+		saveLocalProviderSettings(
+			manager as unknown as ProviderSettingsManager,
+			{
+				action: "saveProviderSettings",
+				providerId: "openai-compatible",
+				azure: {
+					apiVersion: "",
+				},
+			} as SaveProviderSettingsActionRequest,
+		);
+
+		expect(save).toHaveBeenCalledWith(
+			{
+				provider: "openai-compatible",
+			},
+			{ setLastUsed: false },
+		);
+	});
+
+	it("keeps OAuth auth fields when updating manual apiKey", () => {
+		const save = vi.fn();
+		const manager = {
+			read: vi.fn().mockReturnValue({
+				providers: {},
+			}),
+			write: vi.fn(),
+			getFilePath: vi.fn().mockReturnValue("/tmp/providers.json"),
+			getProviderSettings: vi.fn().mockReturnValue({
+				provider: "cline",
+				apiKey: "manual-old",
+				auth: {
+					accessToken: "workos:oauth-access",
+					refreshToken: "oauth-refresh",
+					accountId: "acct-1",
+				},
+			}),
+			saveProviderSettings: save,
+		};
+
+		saveLocalProviderSettings(
+			manager as unknown as ProviderSettingsManager,
+			{
+				action: "saveProviderSettings",
+				providerId: "cline",
+				apiKey: "manual-new",
+			} as SaveProviderSettingsActionRequest,
+		);
+
+		expect(save).toHaveBeenCalledTimes(1);
+		expect(save).toHaveBeenCalledWith(
+			{
+				provider: "cline",
+				apiKey: "manual-new",
+				auth: {
+					accessToken: "workos:oauth-access",
+					refreshToken: "oauth-refresh",
+					accountId: "acct-1",
+				},
+			},
+			{ setLastUsed: false },
+		);
+	});
+});
diff --git a/apps/cli/src/commands/schedule.test.ts b/apps/cli/src/commands/schedule.test.ts
new file mode 100644
index 0000000..080e1b5
--- /dev/null
+++ b/apps/cli/src/commands/schedule.test.ts
@@ -0,0 +1,382 @@
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createScheduleCommand } from "./schedule";
+
+const mockSendHubCommand = vi.hoisted(() => vi.fn());
+const mockEnsureCliHubServer = vi.hoisted(() => vi.fn());
+
+vi.mock("@cline/core", () => ({
+	sendHubCommand: mockSendHubCommand,
+}));
+
+vi.mock("../utils/hub-runtime", () => ({
+	ensureCliHubServer: mockEnsureCliHubServer,
+	parseHubEndpointOverride: (rawAddress: string | undefined) => {
+		const trimmed = rawAddress?.trim();
+		if (!trimmed) {
+			return {};
+		}
+		const parsed = new URL(
+			trimmed.includes("://") ? trimmed : `ws://${trimmed}`,
+		);
+		return {
+			host: parsed.hostname || undefined,
+			port: parsed.port ? Number(parsed.port) : undefined,
+			pathname:
+				parsed.pathname && parsed.pathname !== "/"
+					? parsed.pathname
+					: undefined,
+		};
+	},
+}));
+
+async function runScheduleCommand(
+	args: string[],
+	io: { writeln: (text?: string) => void; writeErr: (text: string) => void },
+): Promise<number> {
+	let exitCode = 0;
+	const cmd = createScheduleCommand(io, (code) => {
+		exitCode = code;
+	});
+	await cmd.parseAsync(args, { from: "user" });
+	return exitCode;
+}
+
+describe("runScheduleCommand list output", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('prints "No schedules found." for empty non-json list output', async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedules: [] },
+		});
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			["list", "--address", "127.0.0.1:25463"],
+			{
+				writeln: (text?: string) => {
+					output.push(text ?? "");
+				},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(errors).toEqual([]);
+		expect(output).toEqual(["No schedules found."]);
+		expect(mockSendHubCommand).toHaveBeenCalledWith(
+			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+			{
+				clientId: "cline-schedule",
+				command: "schedule.list",
+				payload: {
+					limit: 100,
+					enabled: undefined,
+					tags: undefined,
+				},
+			},
+		);
+	});
+
+	it("keeps JSON list output unchanged when --json is provided", async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedules: [] },
+		});
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			["list", "--json", "--address", "127.0.0.1:25463"],
+			{
+				writeln: (text?: string) => {
+					output.push(text ?? "");
+				},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(errors).toEqual([]);
+		expect(output).toEqual(["[]"]);
+		expect(mockSendHubCommand).toHaveBeenCalled();
+	});
+});
+
+describe("runScheduleCommand create delivery metadata", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("maps --delivery-bot to delivery.userName", async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedule: { scheduleId: "sched_delivery" } },
+		});
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			[
+				"create",
+				"Daily summary",
+				"--cron",
+				"0 9 * * *",
+				"--prompt",
+				"Summarize yesterday",
+				"--workspace",
+				"/tmp/workspace",
+				"--delivery-adapter",
+				"telegram",
+				"--delivery-bot",
+				"my_bot",
+				"--delivery-thread",
+				"telegram:123456789",
+				"--address",
+				"127.0.0.1:25463",
+			],
+			{
+				writeln: (text?: string) => {
+					output.push(text ?? "");
+				},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(errors).toEqual([]);
+		expect(output).toEqual(['{\n  "scheduleId": "sched_delivery"\n}']);
+		expect(mockSendHubCommand).toHaveBeenCalledWith(
+			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+			{
+				clientId: "cline-schedule",
+				command: "schedule.create",
+				payload: expect.objectContaining({
+					metadata: {
+						delivery: {
+							adapter: "telegram",
+							threadId: "telegram:123456789",
+							userName: "my_bot",
+						},
+					},
+				}),
+			},
+		);
+	});
+});
+
+describe("runScheduleCommand import", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("preserves exported modelSelection providerId/modelId values", async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedule: { scheduleId: "sched_123" } },
+		});
+
+		const sourcePath = join(
+			tmpdir(),
+			`cline-schedule-import-${Date.now()}.json`,
+		);
+		await writeFile(
+			sourcePath,
+			JSON.stringify({
+				name: "Daily Review",
+				cronPattern: "0 9 * * *",
+				prompt: "review status",
+				workspaceRoot: "/tmp/workspace",
+				modelSelection: {
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-6",
+				},
+			}),
+			"utf8",
+		);
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			["import", sourcePath, "--address", "127.0.0.1:25463"],
+			{
+				writeln: (text?: string) => {
+					output.push(text ?? "");
+				},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(errors).toEqual([]);
+		expect(output).toEqual(['{\n  "scheduleId": "sched_123"\n}']);
+		expect(mockSendHubCommand).toHaveBeenCalledWith(
+			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+			{
+				clientId: "cline-schedule",
+				command: "schedule.create",
+				payload: expect.objectContaining({
+					provider: "anthropic",
+					model: "claude-sonnet-4-6",
+				}),
+			},
+		);
+	});
+});
+
+describe("runScheduleCommand export", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("writes JSON content to the --to file path", async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		const scheduleRecord = {
+			scheduleId: "sched_abc",
+			name: "Daily Review",
+			cronPattern: "0 9 * * *",
+			prompt: "review status",
+			workspaceRoot: "/tmp/workspace",
+		};
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedule: scheduleRecord },
+		});
+
+		const targetPath = join(
+			tmpdir(),
+			`cline-schedule-export-${Date.now()}-${Math.random()
+				.toString(36)
+				.slice(2)}.json`,
+		);
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		try {
+			const code = await runScheduleCommand(
+				[
+					"export",
+					"sched_abc",
+					"--to",
+					targetPath,
+					"--address",
+					"127.0.0.1:25463",
+				],
+				{
+					writeln: (text?: string) => {
+						output.push(text ?? "");
+					},
+					writeErr: (text: string) => {
+						errors.push(text);
+					},
+				},
+			);
+
+			expect(code).toBe(0);
+			expect(errors).toEqual([]);
+			expect(output).toEqual([`Exported schedule sched_abc to ${targetPath}`]);
+
+			const written = await readFile(targetPath, "utf8");
+			expect(written).toBe(JSON.stringify(scheduleRecord, null, 2));
+			expect(mockSendHubCommand).toHaveBeenCalledWith(
+				{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+				{
+					clientId: "cline-schedule",
+					command: "schedule.get",
+					payload: { scheduleId: "sched_abc" },
+				},
+			);
+		} finally {
+			await rm(targetPath, { force: true });
+		}
+	});
+
+	it("writes YAML content when --to has a non-json extension", async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		const scheduleRecord = {
+			scheduleId: "sched_yaml",
+			name: "Weekly Sync",
+			cronPattern: "0 9 * * 1",
+		};
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedule: scheduleRecord },
+		});
+
+		const targetPath = join(
+			tmpdir(),
+			`cline-schedule-export-${Date.now()}-${Math.random()
+				.toString(36)
+				.slice(2)}.yaml`,
+		);
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		try {
+			const code = await runScheduleCommand(
+				[
+					"export",
+					"sched_yaml",
+					"--to",
+					targetPath,
+					"--address",
+					"127.0.0.1:25463",
+				],
+				{
+					writeln: (text?: string) => {
+						output.push(text ?? "");
+					},
+					writeErr: (text: string) => {
+						errors.push(text);
+					},
+				},
+			);
+
+			expect(code).toBe(0);
+			expect(errors).toEqual([]);
+			expect(output).toEqual([`Exported schedule sched_yaml to ${targetPath}`]);
+
+			const yaml = await import("yaml");
+			const written = await readFile(targetPath, "utf8");
+			expect(written).toBe(yaml.stringify(scheduleRecord));
+		} finally {
+			await rm(targetPath, { force: true });
+		}
+	});
+});
diff --git a/apps/cli/src/commands/schedule.ts b/apps/cli/src/commands/schedule.ts
new file mode 100644
index 0000000..643fb7b
--- /dev/null
+++ b/apps/cli/src/commands/schedule.ts
@@ -0,0 +1,36 @@
+import { Command } from "commander";
+import { registerScheduleCommands } from "./schedule/handlers";
+import type { CommandIo } from "./schedule/types";
+
+export function createScheduleCommand(
+	io: CommandIo,
+	setExitCode: (code: number) => void,
+): Command {
+	let actionExitCode = 0;
+	const fail = () => {
+		actionExitCode = 1;
+	};
+
+	function action<T extends unknown[]>(
+		fn: (...args: T) => Promise<void>,
+	): (...args: T) => Promise<void> {
+		return async (...args: T) => {
+			try {
+				await fn(...args);
+			} catch (error) {
+				io.writeErr(error instanceof Error ? error.message : String(error));
+				fail();
+			}
+		};
+	}
+
+	const schedule = new Command("schedule")
+		.description("Create and manage scheduled runs")
+		.exitOverride()
+		.hook("postAction", () => {
+			setExitCode(actionExitCode);
+		});
+
+	registerScheduleCommands(schedule, io, fail, action);
+	return schedule;
+}
diff --git a/apps/cli/src/commands/schedule/client.ts b/apps/cli/src/commands/schedule/client.ts
new file mode 100644
index 0000000..23da54e
--- /dev/null
+++ b/apps/cli/src/commands/schedule/client.ts
@@ -0,0 +1,208 @@
+import {
+	createLocalHubScheduleRuntimeHandlers,
+	HubScheduleCommandService,
+	HubScheduleService,
+	sendHubCommand,
+} from "@cline/core";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+} from "../../utils/hub-runtime";
+import type { CommandIo } from "./types";
+
+export class HubScheduleClient {
+	constructor(
+		private readonly endpoint: {
+			host?: string;
+			port?: number;
+			pathname?: string;
+		},
+	) {}
+
+	close(): void {}
+
+	private async command(
+		command: string,
+		payload?: Record<string, unknown>,
+	): Promise<Record<string, unknown>> {
+		const reply = await sendHubCommand(this.endpoint, {
+			clientId: "cline-schedule",
+			command: command as never,
+			payload,
+		});
+		if (!reply.ok) {
+			throw new Error(reply.error?.message ?? `hub command failed: ${command}`);
+		}
+		return (reply.payload ?? {}) as Record<string, unknown>;
+	}
+
+	async getActiveScheduledExecutions() {
+		return (await this.command("schedule.active")).executions;
+	}
+
+	async createSchedule(payload: Record<string, unknown>) {
+		return (await this.command("schedule.create", payload)).schedule;
+	}
+
+	async deleteSchedule(scheduleId: string) {
+		return (
+			(await this.command("schedule.delete", { scheduleId })).deleted === true
+		);
+	}
+
+	async getSchedule(scheduleId: string) {
+		return (await this.command("schedule.get", { scheduleId })).schedule;
+	}
+
+	async listScheduleExecutions(payload: Record<string, unknown>) {
+		return (await this.command("schedule.list_executions", payload)).executions;
+	}
+
+	async listSchedules(payload: Record<string, unknown>) {
+		return (await this.command("schedule.list", payload)).schedules;
+	}
+
+	async pauseSchedule(scheduleId: string) {
+		return (await this.command("schedule.disable", { scheduleId })).schedule;
+	}
+
+	async resumeSchedule(scheduleId: string) {
+		return (await this.command("schedule.enable", { scheduleId })).schedule;
+	}
+
+	async getScheduleStats(scheduleId: string) {
+		return (await this.command("schedule.stats", { scheduleId })).stats;
+	}
+
+	async triggerScheduleNow(scheduleId: string) {
+		return (await this.command("schedule.trigger", { scheduleId })).execution;
+	}
+
+	async getUpcomingScheduledRuns(limit: number) {
+		return (await this.command("schedule.upcoming", { limit })).runs;
+	}
+
+	async updateSchedule(scheduleId: string, payload: Record<string, unknown>) {
+		return (
+			await this.command("schedule.update", {
+				scheduleId,
+				...payload,
+			})
+		).schedule;
+	}
+}
+
+export class LocalScheduleClient {
+	private readonly service = new HubScheduleService({
+		runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+	});
+	private readonly commands = new HubScheduleCommandService(this.service);
+
+	close(): void {
+		void this.service.dispose();
+	}
+
+	private async command(
+		command: string,
+		payload?: Record<string, unknown>,
+	): Promise<Record<string, unknown>> {
+		const reply = await this.commands.handleCommand({
+			version: "v1",
+			clientId: "cline-schedule-local",
+			command: command as never,
+			payload,
+		});
+		if (!reply.ok) {
+			throw new Error(reply.error?.message ?? `hub command failed: ${command}`);
+		}
+		return (reply.payload ?? {}) as Record<string, unknown>;
+	}
+
+	async getActiveScheduledExecutions() {
+		return (await this.command("schedule.active")).executions;
+	}
+
+	async createSchedule(payload: Record<string, unknown>) {
+		return (await this.command("schedule.create", payload)).schedule;
+	}
+
+	async deleteSchedule(scheduleId: string) {
+		return (
+			(await this.command("schedule.delete", { scheduleId })).deleted === true
+		);
+	}
+
+	async getSchedule(scheduleId: string) {
+		return (await this.command("schedule.get", { scheduleId })).schedule;
+	}
+
+	async listScheduleExecutions(payload: Record<string, unknown>) {
+		return (await this.command("schedule.list_executions", payload)).executions;
+	}
+
+	async listSchedules(payload: Record<string, unknown>) {
+		return (await this.command("schedule.list", payload)).schedules;
+	}
+
+	async pauseSchedule(scheduleId: string) {
+		return (await this.command("schedule.disable", { scheduleId })).schedule;
+	}
+
+	async resumeSchedule(scheduleId: string) {
+		return (await this.command("schedule.enable", { scheduleId })).schedule;
+	}
+
+	async getScheduleStats(scheduleId: string) {
+		return (await this.command("schedule.stats", { scheduleId })).stats;
+	}
+
+	async triggerScheduleNow(scheduleId: string) {
+		return (await this.command("schedule.trigger", { scheduleId })).execution;
+	}
+
+	async getUpcomingScheduledRuns(limit: number) {
+		return (await this.command("schedule.upcoming", { limit })).runs;
+	}
+
+	async updateSchedule(scheduleId: string, payload: Record<string, unknown>) {
+		return (
+			await this.command("schedule.update", {
+				scheduleId,
+				...payload,
+			})
+		).schedule;
+	}
+}
+
+export async function ensureSchedulerHub(
+	address: string | undefined,
+	workspaceRoot: string,
+	_io: CommandIo,
+): Promise<{
+	ok: boolean;
+	client: HubScheduleClient;
+}> {
+	if (!address?.trim()) {
+		return {
+			ok: true,
+			client: new LocalScheduleClient() as unknown as HubScheduleClient,
+		};
+	}
+	try {
+		const requestedEndpoint = parseHubEndpointOverride(address);
+		const { url: hubUrl } = await ensureCliHubServer(
+			workspaceRoot,
+			requestedEndpoint,
+		);
+		const endpoint = parseHubEndpointOverride(hubUrl);
+		return {
+			ok: true,
+			client: new HubScheduleClient(endpoint),
+		};
+	} catch (_error) {
+		return {
+			ok: true,
+			client: new LocalScheduleClient() as unknown as HubScheduleClient,
+		};
+	}
+}
diff --git a/apps/cli/src/commands/schedule/common.ts b/apps/cli/src/commands/schedule/common.ts
new file mode 100644
index 0000000..4cf1c16
--- /dev/null
+++ b/apps/cli/src/commands/schedule/common.ts
@@ -0,0 +1,208 @@
+import type { Command } from "commander";
+import type { CommandIo } from "./types";
+
+export function parseList(raw: string | undefined): string[] | undefined {
+	if (!raw) {
+		return undefined;
+	}
+	const out = raw
+		.split(",")
+		.map((value) => value.trim())
+		.filter((value) => value.length > 0);
+	return out.length > 0 ? out : undefined;
+}
+
+export function parseJsonObjectFlag(
+	raw: string | undefined,
+): Record<string, unknown> | undefined {
+	if (!raw?.trim()) {
+		return undefined;
+	}
+	const parsed = JSON.parse(raw) as unknown;
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new Error("metadata JSON must be an object");
+	}
+	return parsed as Record<string, unknown>;
+}
+
+export function toPositiveInt(
+	value: string | undefined,
+	fallback: number,
+): number {
+	const parsed = Number.parseInt(value ?? "", 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		return fallback;
+	}
+	return parsed;
+}
+
+export function mergeScheduleDeliveryMetadata(
+	base: Record<string, unknown> | undefined,
+	delivery: {
+		deliveryAdapter?: string;
+		deliveryThread?: string;
+		deliveryChannel?: string;
+		deliveryBot?: string;
+	},
+): Record<string, unknown> | undefined {
+	const adapter = delivery.deliveryAdapter?.trim();
+	const threadId = delivery.deliveryThread?.trim();
+	const channelId = delivery.deliveryChannel?.trim();
+	const userName = delivery.deliveryBot?.trim();
+	if (!adapter && !threadId && !channelId && !userName) {
+		return base;
+	}
+	const next = { ...(base ?? {}) };
+	const existingDelivery =
+		next.delivery &&
+		typeof next.delivery === "object" &&
+		!Array.isArray(next.delivery)
+			? (next.delivery as Record<string, unknown>)
+			: {};
+	next.delivery = {
+		...existingDelivery,
+		...(adapter ? { adapter } : {}),
+		...(threadId ? { threadId } : {}),
+		...(channelId ? { channelId } : {}),
+		...(userName ? { userName } : {}),
+	};
+	return next;
+}
+
+export function mergeScheduleAutonomousMetadata(
+	base: Record<string, unknown> | undefined,
+	autonomous: {
+		autonomous?: true;
+		noAutonomous?: true;
+		idleTimeout?: string;
+		pollInterval?: string;
+	},
+): Record<string, unknown> | undefined {
+	const autonomousEnabled = !!autonomous.autonomous;
+	const autonomousDisabled = !!autonomous.noAutonomous;
+	const idleTimeoutSeconds = autonomous.idleTimeout;
+	const pollIntervalSeconds = autonomous.pollInterval;
+	if (
+		!autonomousEnabled &&
+		!autonomousDisabled &&
+		!idleTimeoutSeconds &&
+		!pollIntervalSeconds
+	) {
+		return base;
+	}
+	const next = { ...(base ?? {}) };
+	const existingAutonomous =
+		next.autonomous &&
+		typeof next.autonomous === "object" &&
+		!Array.isArray(next.autonomous)
+			? (next.autonomous as Record<string, unknown>)
+			: {};
+	next.autonomous = {
+		...existingAutonomous,
+		...(autonomousEnabled ? { enabled: true } : {}),
+		...(autonomousDisabled ? { enabled: false } : {}),
+		...(idleTimeoutSeconds
+			? { idleTimeoutSeconds: toPositiveInt(idleTimeoutSeconds, 60) }
+			: {}),
+		...(pollIntervalSeconds
+			? { pollIntervalSeconds: toPositiveInt(pollIntervalSeconds, 5) }
+			: {}),
+	};
+	return next;
+}
+
+export function hasMetadataPatchOpts(opts: Record<string, unknown>): boolean {
+	return (
+		!!opts.metadataJson ||
+		!!opts.deliveryAdapter ||
+		!!opts.deliveryThread ||
+		!!opts.deliveryChannel ||
+		!!opts.deliveryBot ||
+		!!opts.autonomous ||
+		!!opts.noAutonomous ||
+		!!opts.idleTimeout ||
+		!!opts.pollInterval
+	);
+}
+
+export function mergeScheduleMetadata(
+	base: Record<string, unknown> | undefined,
+	opts: {
+		deliveryAdapter?: string;
+		deliveryThread?: string;
+		deliveryChannel?: string;
+		deliveryBot?: string;
+		autonomous?: true;
+		noAutonomous?: true;
+		idleTimeout?: string;
+		pollInterval?: string;
+	},
+): Record<string, unknown> | undefined {
+	return mergeScheduleAutonomousMetadata(
+		mergeScheduleDeliveryMetadata(base, opts),
+		opts,
+	);
+}
+
+export function isJsonPath(path: string): boolean {
+	return path.toLowerCase().endsWith(".json");
+}
+
+export function parseMode(raw: string | undefined): "act" | "plan" | undefined {
+	if (raw === "act" || raw === "plan") {
+		return raw;
+	}
+	return undefined;
+}
+
+export function emitJsonOrText(
+	json: boolean,
+	io: CommandIo,
+	value: unknown,
+): void {
+	if (json) {
+		io.writeln(JSON.stringify(value));
+		return;
+	}
+	if (typeof value === "string") {
+		io.writeln(value);
+		return;
+	}
+	io.writeln(JSON.stringify(value, null, 2));
+}
+
+export function resolveAddress(
+	address: string | undefined,
+): string | undefined {
+	const resolved = address ?? process.env.CLINE_HUB_ADDRESS;
+	const trimmed = resolved?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function formatResolvedAddressLabel(
+	address: string | undefined,
+): string {
+	return address ? ` at ${address}` : "";
+}
+
+export function addSharedOptions(cmd: Command): Command {
+	return cmd
+		.option("--address <host:port>", "Hub server address")
+		.option("--json", "Output as JSON");
+}
+
+export function addDeliveryOptions(cmd: Command): Command {
+	return cmd
+		.option("--delivery-adapter <name>", "Delivery adapter name")
+		.option("--delivery-bot <name>", "Delivery bot user name")
+		.option("--delivery-channel <id>", "Delivery channel ID")
+		.option("--delivery-thread <id>", "Delivery thread ID");
+}
+
+export function addAutonomousOptions(cmd: Command): Command {
+	return cmd
+		.option("--autonomous", "Enable autonomous mode")
+		.option("--no-autonomous", "Disable autonomous mode")
+		.option("--idle-timeout <seconds>", "Autonomous idle timeout in seconds")
+		.option("--poll-interval <seconds>", "Autonomous poll interval in seconds");
+}
diff --git a/apps/cli/src/commands/schedule/handlers.ts b/apps/cli/src/commands/schedule/handlers.ts
new file mode 100644
index 0000000..ed13e04
--- /dev/null
+++ b/apps/cli/src/commands/schedule/handlers.ts
@@ -0,0 +1,411 @@
+import type { Command } from "commander";
+import { ensureSchedulerHub } from "./client";
+import {
+	addAutonomousOptions,
+	addDeliveryOptions,
+	addSharedOptions,
+	emitJsonOrText,
+	formatResolvedAddressLabel,
+	mergeScheduleMetadata,
+	parseJsonObjectFlag,
+	parseList,
+	resolveAddress,
+	toPositiveInt,
+} from "./common";
+import {
+	registerScheduleExportCommand,
+	registerScheduleImportCommand,
+	registerScheduleUpdateCommand,
+} from "./import-export";
+import type { CommandIo, ScheduleActionWrapper } from "./types";
+
+export function registerScheduleCommands(
+	schedule: Command,
+	io: CommandIo,
+	fail: () => void,
+	action: ScheduleActionWrapper,
+): void {
+	const activeCmd = schedule
+		.command("active")
+		.description("Show currently active executions");
+	addSharedOptions(activeCmd);
+	activeCmd.action(
+		action(async () => {
+			const opts = activeCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const active = await client.getActiveScheduledExecutions();
+				emitJsonOrText(!!opts.json, io, active);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const createCmd = schedule
+		.command("create")
+		.description("Create a new schedule")
+		.argument("<name>", "Schedule name")
+		.requiredOption("--cron <pattern>", "Cron pattern")
+		.requiredOption("--prompt <text>", "Task prompt")
+		.requiredOption("--workspace <path>", "Workspace root path")
+		.option("--created-by <name>", "Creator name")
+		.option("--cwd <path>", "Working directory")
+		.option("--disabled", "Create in disabled state")
+		.option("--max-parallel <n>", "Max parallel executions", "1")
+		.option("--metadata-json <json>", "Metadata as JSON object")
+		.option("--mode <act|plan>", "Execution mode")
+		.option("--model <model>", "Model to use", "openai/gpt-5.3-codex")
+		.option("--provider <id>", "Provider ID", "cline")
+		.option("--system-prompt <text>", "System prompt override")
+		.option("--tags <list>", "Comma-separated tags")
+		.option("--timeout <seconds>", "Timeout in seconds");
+	addDeliveryOptions(createCmd);
+	addAutonomousOptions(createCmd);
+	addSharedOptions(createCmd);
+	createCmd.action(
+		action(async (name: string) => {
+			const opts = createCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, opts.workspace, io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const metadata = mergeScheduleMetadata(
+					parseJsonObjectFlag(opts.metadataJson),
+					opts,
+				);
+				const created = await client.createSchedule({
+					name,
+					cronPattern: opts.cron,
+					prompt: opts.prompt,
+					provider: opts.provider,
+					model: opts.model,
+					mode: opts.mode === "plan" ? "plan" : "act",
+					workspaceRoot: opts.workspace,
+					cwd: opts.cwd,
+					systemPrompt: opts.systemPrompt,
+					timeoutSeconds: opts.timeout
+						? toPositiveInt(opts.timeout, 1)
+						: undefined,
+					maxParallel: toPositiveInt(opts.maxParallel, 1),
+					enabled: !opts.disabled,
+					createdBy: opts.createdBy,
+					tags: parseList(opts.tags),
+					metadata,
+				});
+				if (!created) {
+					io.writeErr("failed to create schedule");
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, created);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const deleteCmd = schedule
+		.command("delete")
+		.description("Delete a schedule")
+		.argument("<schedule-id>", "Schedule ID");
+	addSharedOptions(deleteCmd);
+	deleteCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = deleteCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const deleted = await client.deleteSchedule(scheduleId);
+				emitJsonOrText(!!opts.json, io, { deleted });
+				if (!deleted) fail();
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const getCmd = schedule
+		.command("get")
+		.description("Get a schedule by ID")
+		.argument("<schedule-id>", "Schedule ID");
+	addSharedOptions(getCmd);
+	getCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = getCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const result = await client.getSchedule(scheduleId);
+				if (!result) {
+					io.writeErr(`schedule not found: ${scheduleId}`);
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, result);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const historyCmd = schedule
+		.command("history")
+		.description("Show execution history for a schedule")
+		.argument("<schedule-id>", "Schedule ID")
+		.option("--limit <n>", "Maximum number of results", "20")
+		.option("--status <status>", "Filter by execution status");
+	addSharedOptions(historyCmd);
+	historyCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = historyCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const executions = await client.listScheduleExecutions({
+					scheduleId,
+					status: opts.status,
+					limit: toPositiveInt(opts.limit, 20),
+				});
+				emitJsonOrText(!!opts.json, io, executions);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const listCmd = schedule
+		.command("list")
+		.description("List schedules")
+		.option("--disabled", "Show only disabled schedules")
+		.option("--enabled", "Show only enabled schedules")
+		.option("--limit <n>", "Maximum number of results", "100")
+		.option("--tags <list>", "Filter by comma-separated tags");
+	addSharedOptions(listCmd);
+	listCmd.action(
+		action(async () => {
+			const opts = listCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const enabled = opts.enabled ? true : opts.disabled ? false : undefined;
+				const schedules = await client.listSchedules({
+					limit: toPositiveInt(opts.limit, 100),
+					enabled,
+					tags: parseList(opts.tags),
+				});
+				if (!opts.json && Array.isArray(schedules) && schedules.length === 0) {
+					io.writeln("No schedules found.");
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, schedules);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const pauseCmd = schedule
+		.command("pause")
+		.description("Pause a schedule")
+		.argument("<schedule-id>", "Schedule ID");
+	addSharedOptions(pauseCmd);
+	pauseCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = pauseCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const result = await client.pauseSchedule(scheduleId);
+				if (!result) {
+					io.writeErr(`schedule not found: ${scheduleId}`);
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, result);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const resumeCmd = schedule
+		.command("resume")
+		.description("Resume a schedule")
+		.argument("<schedule-id>", "Schedule ID");
+	addSharedOptions(resumeCmd);
+	resumeCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = resumeCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const result = await client.resumeSchedule(scheduleId);
+				if (!result) {
+					io.writeErr(`schedule not found: ${scheduleId}`);
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, result);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const statsCmd = schedule
+		.command("stats")
+		.description("Show statistics for a schedule")
+		.argument("<schedule-id>", "Schedule ID");
+	addSharedOptions(statsCmd);
+	statsCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = statsCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const stats = await client.getScheduleStats(scheduleId);
+				emitJsonOrText(!!opts.json, io, stats);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const triggerCmd = schedule
+		.command("trigger")
+		.description("Trigger a schedule immediately")
+		.argument("<schedule-id>", "Schedule ID");
+	addSharedOptions(triggerCmd);
+	triggerCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = triggerCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const execution = await client.triggerScheduleNow(scheduleId);
+				if (!execution) {
+					io.writeErr(`schedule not found: ${scheduleId}`);
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, execution);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	const upcomingCmd = schedule
+		.command("upcoming")
+		.description("Show upcoming scheduled runs")
+		.option("--limit <n>", "Maximum number of results", "20");
+	addSharedOptions(upcomingCmd);
+	upcomingCmd.action(
+		action(async () => {
+			const opts = upcomingCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const runs = await client.getUpcomingScheduledRuns(
+					toPositiveInt(opts.limit, 20),
+				);
+				emitJsonOrText(!!opts.json, io, runs);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+
+	registerScheduleExportCommand(schedule, io, fail, action);
+	registerScheduleImportCommand(schedule, io, fail, action);
+	registerScheduleUpdateCommand(schedule, io, fail, action);
+}
diff --git a/apps/cli/src/commands/schedule/import-export.ts b/apps/cli/src/commands/schedule/import-export.ts
new file mode 100644
index 0000000..e26750e
--- /dev/null
+++ b/apps/cli/src/commands/schedule/import-export.ts
@@ -0,0 +1,321 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import type { Command } from "commander";
+import { ensureSchedulerHub } from "./client";
+import {
+	addAutonomousOptions,
+	addDeliveryOptions,
+	addSharedOptions,
+	emitJsonOrText,
+	formatResolvedAddressLabel,
+	hasMetadataPatchOpts,
+	isJsonPath,
+	mergeScheduleMetadata,
+	parseJsonObjectFlag,
+	parseList,
+	parseMode,
+	resolveAddress,
+	toPositiveInt,
+} from "./common";
+import type { CommandIo, ScheduleActionWrapper } from "./types";
+
+function resolveImportedModelSelection(parsed: Record<string, unknown>): {
+	provider: string;
+	model: string;
+} {
+	const modelSelection =
+		parsed.modelSelection &&
+		typeof parsed.modelSelection === "object" &&
+		!Array.isArray(parsed.modelSelection)
+			? (parsed.modelSelection as Record<string, unknown>)
+			: undefined;
+	const provider = String(
+		modelSelection?.providerId ??
+			parsed.providerId ??
+			parsed.provider ??
+			"cline",
+	).trim();
+	const model = String(
+		modelSelection?.modelId ??
+			parsed.modelId ??
+			parsed.model ??
+			"openai/gpt-5.3-codex",
+	).trim();
+	return { provider, model };
+}
+
+export function registerScheduleExportCommand(
+	schedule: Command,
+	io: CommandIo,
+	fail: () => void,
+	action: ScheduleActionWrapper,
+): void {
+	const exportCmd = schedule
+		.command("export")
+		.description("Export a schedule")
+		.argument("<schedule-id>", "Schedule ID")
+		.option("--to <path>", "Output file path");
+	addSharedOptions(exportCmd);
+	exportCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = exportCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const result = await client.getSchedule(scheduleId);
+				if (!result) {
+					io.writeErr(`schedule not found: ${scheduleId}`);
+					fail();
+					return;
+				}
+				const toPath =
+					typeof opts.to === "string" && opts.to.length > 0
+						? opts.to
+						: undefined;
+				if (toPath) {
+					try {
+						const resolvedPath = isAbsolute(toPath)
+							? toPath
+							: resolve(process.cwd(), toPath);
+						await mkdir(dirname(resolvedPath), { recursive: true });
+						const useJson = !!opts.json || isJsonPath(resolvedPath);
+						let serialized: string;
+						if (useJson) {
+							serialized = JSON.stringify(result, null, 2);
+						} else {
+							const yaml = await import("yaml");
+							serialized = yaml.stringify(result);
+						}
+						await writeFile(resolvedPath, serialized, "utf8");
+						io.writeln(`Exported schedule ${scheduleId} to ${resolvedPath}`);
+					} catch (error) {
+						io.writeErr(error instanceof Error ? error.message : String(error));
+						fail();
+					}
+					return;
+				}
+				if (opts.json) {
+					io.writeln(JSON.stringify(result, null, 2));
+					return;
+				}
+				const yaml = await import("yaml");
+				io.writeln(yaml.stringify(result));
+			} finally {
+				client.close();
+			}
+		}),
+	);
+}
+
+export function registerScheduleImportCommand(
+	schedule: Command,
+	io: CommandIo,
+	fail: () => void,
+	action: ScheduleActionWrapper,
+): void {
+	const importCmd = schedule
+		.command("import")
+		.description("Import a schedule from file")
+		.argument("<path>", "Source file path");
+	addSharedOptions(importCmd);
+	importCmd.action(
+		action(async (sourcePath: string) => {
+			const opts = importCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				const sourceRaw = await readFile(sourcePath, "utf8");
+				let parsed: Record<string, unknown>;
+				if (isJsonPath(sourcePath)) {
+					parsed = JSON.parse(sourceRaw) as Record<string, unknown>;
+				} else {
+					const yaml = await import("yaml");
+					parsed = yaml.parse(sourceRaw) as Record<string, unknown>;
+				}
+				const workspaceRoot = String(
+					parsed.workspaceRoot ?? parsed.workspace_root ?? "",
+				).trim();
+				if (!workspaceRoot) {
+					io.writeErr(
+						"schedule import requires workspaceRoot/workspace_root in the source file",
+					);
+					fail();
+					return;
+				}
+				const { provider, model } = resolveImportedModelSelection(parsed);
+				const created = await client.createSchedule({
+					name: String(parsed.name ?? "").trim(),
+					cronPattern: String(parsed.cronPattern ?? parsed.cron ?? "").trim(),
+					prompt: String(parsed.prompt ?? "").trim(),
+					provider,
+					model,
+					mode: parsed.mode === "plan" ? "plan" : "act",
+					workspaceRoot,
+					cwd: String(parsed.cwd ?? "").trim() || undefined,
+					systemPrompt:
+						String(parsed.systemPrompt ?? parsed.system_prompt ?? "").trim() ||
+						undefined,
+					timeoutSeconds:
+						typeof parsed.timeoutSeconds === "number"
+							? parsed.timeoutSeconds
+							: typeof parsed.timeout_seconds === "number"
+								? parsed.timeout_seconds
+								: undefined,
+					maxParallel:
+						typeof parsed.maxParallel === "number"
+							? parsed.maxParallel
+							: typeof parsed.max_parallel === "number"
+								? parsed.max_parallel
+								: 1,
+					enabled: parsed.enabled !== false,
+					createdBy:
+						String(parsed.createdBy ?? parsed.created_by ?? "").trim() ||
+						undefined,
+					tags: Array.isArray(parsed.tags)
+						? parsed.tags
+								.map((item) => (typeof item === "string" ? item.trim() : ""))
+								.filter((item) => item.length > 0)
+						: undefined,
+					metadata: mergeScheduleMetadata(
+						parsed.metadata && typeof parsed.metadata === "object"
+							? (parsed.metadata as Record<string, unknown>)
+							: undefined,
+						opts,
+					),
+				});
+				if (!created) {
+					io.writeErr("failed to import schedule");
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, created);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+}
+
+export function registerScheduleUpdateCommand(
+	schedule: Command,
+	io: CommandIo,
+	fail: () => void,
+	action: ScheduleActionWrapper,
+): void {
+	const updateCmd = schedule
+		.command("update")
+		.description("Update a schedule")
+		.argument("<schedule-id>", "Schedule ID")
+		.option("--clear-timeout", "Clear timeout")
+		.option("--cron <pattern>", "New cron pattern")
+		.option("--cwd <path>", "New working directory")
+		.option("--disabled", "Disable the schedule")
+		.option("--enabled", "Enable the schedule")
+		.option("--max-parallel <n>", "New max parallel executions")
+		.option("--metadata-json <json>", "New metadata as JSON object")
+		.option("--mode <act|plan>", "New execution mode")
+		.option("--model <model>", "New model")
+		.option("--name <name>", "New name")
+		.option("--pause", "Pause the schedule")
+		.option("--prompt <text>", "New prompt")
+		.option("--provider <id>", "New provider ID")
+		.option("--resume", "Resume the schedule")
+		.option("--system-prompt <text>", "New system prompt")
+		.option("--tags <list>", "New comma-separated tags")
+		.option("--timeout <n>", "New timeout in seconds")
+		.option("--workspace <path>", "New workspace root");
+	addDeliveryOptions(updateCmd);
+	addAutonomousOptions(updateCmd);
+	addSharedOptions(updateCmd);
+	updateCmd.action(
+		action(async (scheduleId: string) => {
+			const opts = updateCmd.opts();
+			const address = resolveAddress(opts.address);
+			const ensured = await ensureSchedulerHub(address, process.cwd(), io);
+			if (!ensured.ok) {
+				io.writeErr(
+					`failed to ensure hub server${formatResolvedAddressLabel(address)}`,
+				);
+				fail();
+				return;
+			}
+			const client = ensured.client;
+			try {
+				if (opts.pause) {
+					const result = await client.pauseSchedule(scheduleId);
+					emitJsonOrText(!!opts.json, io, result ?? { updated: false });
+					if (!result) fail();
+					return;
+				}
+				if (opts.resume) {
+					const result = await client.resumeSchedule(scheduleId);
+					emitJsonOrText(!!opts.json, io, result ?? { updated: false });
+					if (!result) fail();
+					return;
+				}
+				let metadata: Record<string, unknown> | undefined;
+				if (hasMetadataPatchOpts(opts)) {
+					const current = (await client.getSchedule(scheduleId)) as
+						| { metadata?: Record<string, unknown> }
+						| undefined;
+					if (!current) {
+						io.writeErr(`schedule not found: ${scheduleId}`);
+						fail();
+						return;
+					}
+					const metadataBase = {
+						...(current.metadata ?? {}),
+						...(parseJsonObjectFlag(opts.metadataJson) ?? {}),
+					};
+					metadata = mergeScheduleMetadata(metadataBase, opts);
+				}
+				const updated = await client.updateSchedule(scheduleId, {
+					name: opts.name,
+					cronPattern: opts.cron,
+					prompt: opts.prompt,
+					provider: opts.provider,
+					model: opts.model,
+					mode: parseMode(opts.mode),
+					workspaceRoot: opts.workspace,
+					cwd: opts.cwd,
+					systemPrompt: opts.systemPrompt,
+					timeoutSeconds: opts.timeout
+						? toPositiveInt(opts.timeout, 1)
+						: opts.clearTimeout
+							? null
+							: undefined,
+					maxParallel: opts.maxParallel
+						? toPositiveInt(opts.maxParallel, 1)
+						: undefined,
+					enabled: opts.enabled ? true : opts.disabled ? false : undefined,
+					tags: opts.tags ? parseList(opts.tags) : undefined,
+					metadata,
+				});
+				if (!updated) {
+					io.writeErr(`schedule not found: ${scheduleId}`);
+					fail();
+					return;
+				}
+				emitJsonOrText(!!opts.json, io, updated);
+			} finally {
+				client.close();
+			}
+		}),
+	);
+}
diff --git a/apps/cli/src/commands/schedule/types.ts b/apps/cli/src/commands/schedule/types.ts
new file mode 100644
index 0000000..60fac44
--- /dev/null
+++ b/apps/cli/src/commands/schedule/types.ts
@@ -0,0 +1,8 @@
+export interface CommandIo {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+}
+
+export type ScheduleActionWrapper = <T extends unknown[]>(
+	fn: (...args: T) => Promise<void>,
+) => (...args: T) => Promise<void>;
diff --git a/apps/cli/src/commands/skill.test.ts b/apps/cli/src/commands/skill.test.ts
new file mode 100644
index 0000000..1213748
--- /dev/null
+++ b/apps/cli/src/commands/skill.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { buildSkillsArgs } from "./skill";
+
+describe("buildSkillsArgs", () => {
+	it("runs the skills package through npx with -y", () => {
+		expect(buildSkillsArgs(["list"])).toEqual(["-y", "skills@latest", "list"]);
+	});
+
+	it("injects --agent cline for install-style subcommands", () => {
+		expect(buildSkillsArgs(["install", "owner/repo"])).toEqual([
+			"-y",
+			"skills@latest",
+			"add",
+			"owner/repo",
+			"--agent",
+			"cline",
+		]);
+		expect(buildSkillsArgs(["add", "owner/repo"])).toContain("cline");
+		expect(buildSkillsArgs(["i", "owner/repo"])).toContain("cline");
+		expect(buildSkillsArgs(["update", "owner/repo"])).toContain("cline");
+	});
+
+	it("aliases uninstall to the skills remove subcommand", () => {
+		expect(buildSkillsArgs(["uninstall", "my-skill"])).toEqual([
+			"-y",
+			"skills@latest",
+			"remove",
+			"my-skill",
+			"--agent",
+			"cline",
+		]);
+	});
+
+	it("does not inject when the user already targeted an agent", () => {
+		expect(
+			buildSkillsArgs(["install", "owner/repo", "--agent", "cursor"]),
+		).not.toContain("cline");
+		expect(
+			buildSkillsArgs(["install", "owner/repo", "-a", "cursor"]),
+		).not.toContain("cline");
+		expect(
+			buildSkillsArgs(["install", "owner/repo", "--agent=cursor"]),
+		).not.toContain("cline");
+	});
+
+	it("aliases install and uninstall when agent options come before the subcommand", () => {
+		expect(
+			buildSkillsArgs(["--agent", "cursor", "install", "owner/repo"]),
+		).toEqual([
+			"-y",
+			"skills@latest",
+			"--agent",
+			"cursor",
+			"add",
+			"owner/repo",
+		]);
+		expect(
+			buildSkillsArgs(["--agent=cursor", "uninstall", "my-skill"]),
+		).toEqual(["-y", "skills@latest", "--agent=cursor", "remove", "my-skill"]);
+	});
+
+	it("does not scope non-install subcommands to cline", () => {
+		expect(buildSkillsArgs(["use", "owner/repo"])).not.toContain("--agent");
+		expect(buildSkillsArgs(["list"])).not.toContain("--agent");
+	});
+
+	it("scopes remove-style subcommands to cline", () => {
+		expect(buildSkillsArgs(["remove"])).toEqual([
+			"-y",
+			"skills@latest",
+			"remove",
+			"--agent",
+			"cline",
+		]);
+		expect(buildSkillsArgs(["rm", "my-skill"])).toContain("cline");
+		expect(buildSkillsArgs(["r", "my-skill"])).toContain("cline");
+	});
+
+	it("ignores leading flags when detecting the subcommand", () => {
+		expect(buildSkillsArgs(["--global", "install", "owner/repo"])).toContain(
+			"cline",
+		);
+	});
+
+	it("forwards an empty arg list unchanged", () => {
+		expect(buildSkillsArgs([])).toEqual(["-y", "skills@latest"]);
+	});
+});
diff --git a/apps/cli/src/commands/skill.ts b/apps/cli/src/commands/skill.ts
new file mode 100644
index 0000000..934fc87
--- /dev/null
+++ b/apps/cli/src/commands/skill.ts
@@ -0,0 +1,160 @@
+import { type SpawnOptions, spawn } from "node:child_process";
+
+export interface SkillCommandIo {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+}
+
+// `cline skill` is a thin wrapper around the open skills CLI
+// (https://www.npmjs.com/package/skills). We run it through `npx` so users
+// don't need a separate global install. Pin the version here if we ever need to
+// lock behavior to a known-good release.
+const SKILLS_PACKAGE = "skills@latest";
+
+// Subcommands that write skill files into an agent's skills directory. For a
+// `cline skill` command we default these to Cline unless the user picked their
+// own agent. `use` is intentionally excluded: without --agent it prints the
+// generated prompt to stdout, whereas adding --agent would launch that agent
+// interactively instead — not what someone scoping to Cline would expect.
+const CLINE_SCOPED_SUBCOMMANDS = new Set([
+	"add",
+	"install",
+	"i",
+	"update",
+	"remove",
+	"rm",
+	"r",
+	"uninstall",
+]);
+
+const SKILLS_SUBCOMMAND_ALIASES = new Map([
+	["install", "add"],
+	["uninstall", "remove"],
+]);
+
+function hasAgentFlag(args: readonly string[]): boolean {
+	return args.some(
+		(arg) => arg === "-a" || arg === "--agent" || arg.startsWith("--agent="),
+	);
+}
+
+function optionConsumesNextValue(arg: string): boolean {
+	return arg === "-a" || arg === "--agent";
+}
+
+function findSubcommandIndex(args: readonly string[]): number {
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg.startsWith("-")) {
+			if (optionConsumesNextValue(arg)) {
+				index++;
+			}
+			continue;
+		}
+		return index;
+	}
+	return -1;
+}
+
+function findSubcommand(args: readonly string[]): string | undefined {
+	const index = findSubcommandIndex(args);
+	return index >= 0 ? args[index] : undefined;
+}
+
+function normalizeSkillsSubcommandAliases(args: string[]): void {
+	const index = findSubcommandIndex(args);
+	if (index < 0) return;
+	const alias = SKILLS_SUBCOMMAND_ALIASES.get(args[index]);
+	if (alias) {
+		args[index] = alias;
+	}
+}
+
+/**
+ * Build the argument list passed to `npx`, injecting `--agent cline` for
+ * install-style subcommands unless the user already targeted an agent.
+ */
+export function buildSkillsArgs(userArgs: readonly string[]): string[] {
+	const args = [...userArgs];
+	const subcommand = findSubcommand(args);
+	normalizeSkillsSubcommandAliases(args);
+	if (
+		subcommand &&
+		CLINE_SCOPED_SUBCOMMANDS.has(subcommand) &&
+		!hasAgentFlag(args)
+	) {
+		args.push("--agent", "cline");
+	}
+	return ["-y", SKILLS_PACKAGE, ...args];
+}
+
+function resolveExitCode(
+	code: number | null,
+	signal: NodeJS.Signals | null,
+): number {
+	if (code !== null) {
+		return code;
+	}
+	switch (signal) {
+		case "SIGINT":
+			return 130;
+		case "SIGTERM":
+			return 143;
+		default:
+			return 1;
+	}
+}
+
+/**
+ * Forward all arguments to the open skills CLI via `npx skills`.
+ *
+ * Returns the child process exit code, or 1 if npx is unavailable or fails to
+ * spawn. stdio is inherited so the skills CLI's interactive prompts and output
+ * pass straight through to the user's terminal.
+ */
+export async function runSkillCommand(
+	userArgs: readonly string[],
+	io: SkillCommandIo,
+): Promise<number> {
+	const args = buildSkillsArgs(userArgs);
+	const isWindows = process.platform === "win32";
+	const options: SpawnOptions = {
+		stdio: "inherit",
+		env: process.env,
+		// Prevent a console window from flashing on Windows.
+		windowsHide: true,
+		...(isWindows ? { shell: true } : {}),
+	};
+
+	return new Promise<number>((resolve) => {
+		const child = spawn("npx", args, options);
+
+		const forward = (signal: NodeJS.Signals) => {
+			child.kill(signal);
+		};
+		const handleSigint = () => forward("SIGINT");
+		const handleSigterm = () => forward("SIGTERM");
+		process.on("SIGINT", handleSigint);
+		process.on("SIGTERM", handleSigterm);
+		const cleanup = () => {
+			process.off("SIGINT", handleSigint);
+			process.off("SIGTERM", handleSigterm);
+		};
+
+		child.once("error", (error: NodeJS.ErrnoException) => {
+			cleanup();
+			if (error.code === "ENOENT") {
+				io.writeErr(
+					'npx was not found. Install Node.js (which includes npx) to use "cline skill".',
+				);
+			} else {
+				io.writeErr(`Failed to run npx ${SKILLS_PACKAGE}: ${error.message}`);
+			}
+			resolve(1);
+		});
+		child.once("close", (code, signal) => {
+			cleanup();
+			resolve(resolveExitCode(code, signal));
+		});
+	});
+}
diff --git a/apps/cli/src/commands/update.test.ts b/apps/cli/src/commands/update.test.ts
new file mode 100644
index 0000000..34024d8
--- /dev/null
+++ b/apps/cli/src/commands/update.test.ts
@@ -0,0 +1,271 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	autoUpdateOnStartup,
+	checkForUpdates,
+	getInstallationInfo,
+	PackageManager,
+	resolveCliHubOwnerContext,
+	withMinimumReleaseAgeBypass,
+} from "./update";
+
+const originalArgv = [...process.argv];
+const originalBuildEnv = process.env.CLINE_BUILD_ENV;
+const originalDataDir = process.env.CLINE_DATA_DIR;
+const originalHubDiscoveryPath = process.env.CLINE_HUB_DISCOVERY_PATH;
+const originalWrapperPath = process.env.CLINE_WRAPPER_PATH;
+const originalGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+const originalIsDev = process.env.IS_DEV;
+const originalNoAutoUpdate = process.env.CLINE_NO_AUTO_UPDATE;
+const tempDirs: string[] = [];
+
+function createFile(path: string): string {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, "");
+	return path;
+}
+
+function createTempFile(pathSuffix: string): string {
+	const root = mkdtempSync(join(tmpdir(), "cline-update-test-"));
+	tempDirs.push(root);
+	return createFile(join(root, pathSuffix));
+}
+
+describe("getInstallationInfo", () => {
+	afterEach(() => {
+		process.argv = [...originalArgv];
+		if (originalBuildEnv === undefined) {
+			delete process.env.CLINE_BUILD_ENV;
+		} else {
+			process.env.CLINE_BUILD_ENV = originalBuildEnv;
+		}
+		if (originalDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalDataDir;
+		}
+		if (originalHubDiscoveryPath === undefined) {
+			delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		} else {
+			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
+		}
+		if (originalWrapperPath === undefined) {
+			delete process.env.CLINE_WRAPPER_PATH;
+		} else {
+			process.env.CLINE_WRAPPER_PATH = originalWrapperPath;
+		}
+		if (originalGlobalSettingsPath === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = originalGlobalSettingsPath;
+		}
+		if (originalIsDev === undefined) {
+			delete process.env.IS_DEV;
+		} else {
+			process.env.IS_DEV = originalIsDev;
+		}
+		if (originalNoAutoUpdate === undefined) {
+			delete process.env.CLINE_NO_AUTO_UPDATE;
+		} else {
+			process.env.CLINE_NO_AUTO_UPDATE = originalNoAutoUpdate;
+		}
+		vi.restoreAllMocks();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("detects npm installs from the wrapper path passed to the compiled binary", () => {
+		const wrapperPath = createTempFile("lib/node_modules/cline/bin/cline");
+		process.env.CLINE_WRAPPER_PATH = wrapperPath;
+		process.argv = ["bun", "/$bunfs/root/cline", "update", "--verbose"];
+
+		expect(getInstallationInfo("1.2.3")).toEqual({
+			packageManager: PackageManager.NPM,
+			packageName: "cline",
+			updateCommand: "npm update -g cline --tag latest",
+		});
+	});
+
+	it("uses the nightly tag when the current CLI version is nightly", () => {
+		const wrapperPath = createTempFile("lib/node_modules/cline/bin/cline");
+		process.env.CLINE_WRAPPER_PATH = wrapperPath;
+		process.argv = ["bun", "/$bunfs/root/cline", "update", "--verbose"];
+
+		expect(getInstallationInfo("1.2.3-nightly.456")).toEqual({
+			packageManager: PackageManager.NPM,
+			packageName: "cline",
+			updateCommand: "npm update -g cline --tag nightly",
+		});
+	});
+
+	it("detects bun global installs from the resolved install path", () => {
+		// bun symlinks ~/.bun/bin/cline -> ~/.bun/install/global/node_modules/...,
+		// and realpathSync resolves through the symlink before detection runs.
+		const wrapperPath = createTempFile(
+			".bun/install/global/node_modules/cline/bin/cline",
+		);
+		process.env.CLINE_WRAPPER_PATH = wrapperPath;
+		process.argv = ["bun", "/$bunfs/root/cline", "update", "--verbose"];
+
+		expect(getInstallationInfo("1.2.3")).toEqual({
+			packageManager: PackageManager.BUN,
+			packageName: "cline",
+			updateCommand: "bun add -g cline@latest",
+		});
+	});
+
+	it("falls back to unknown when only Bun's virtual compiled path is available", () => {
+		delete process.env.CLINE_WRAPPER_PATH;
+		process.argv = ["bun", "/$bunfs/root/cline", "update", "--verbose"];
+
+		expect(getInstallationInfo("1.2.3")).toEqual({
+			packageManager: PackageManager.UNKNOWN,
+			packageName: "cline",
+		});
+	});
+});
+
+describe("auto update settings", () => {
+	afterEach(() => {
+		process.argv = [...originalArgv];
+		if (originalBuildEnv === undefined) {
+			delete process.env.CLINE_BUILD_ENV;
+		} else {
+			process.env.CLINE_BUILD_ENV = originalBuildEnv;
+		}
+		if (originalDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalDataDir;
+		}
+		if (originalHubDiscoveryPath === undefined) {
+			delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		} else {
+			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
+		}
+		if (originalWrapperPath === undefined) {
+			delete process.env.CLINE_WRAPPER_PATH;
+		} else {
+			process.env.CLINE_WRAPPER_PATH = originalWrapperPath;
+		}
+		if (originalGlobalSettingsPath === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = originalGlobalSettingsPath;
+		}
+		if (originalIsDev === undefined) {
+			delete process.env.IS_DEV;
+		} else {
+			process.env.IS_DEV = originalIsDev;
+		}
+		if (originalNoAutoUpdate === undefined) {
+			delete process.env.CLINE_NO_AUTO_UPDATE;
+		} else {
+			process.env.CLINE_NO_AUTO_UPDATE = originalNoAutoUpdate;
+		}
+		vi.restoreAllMocks();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("skips startup auto update when disabled globally", () => {
+		const settingsPath = createTempFile("data/global-settings.json");
+		writeFileSync(settingsPath, JSON.stringify({ autoUpdateEnabled: false }));
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+		delete process.env.IS_DEV;
+		delete process.env.CLINE_NO_AUTO_UPDATE;
+		const fetchSpy = vi
+			.spyOn(globalThis, "fetch")
+			.mockRejectedValue(new Error("should not fetch"));
+
+		autoUpdateOnStartup();
+
+		expect(fetchSpy).not.toHaveBeenCalled();
+	});
+
+	it("still lets manual update checks run when startup auto update is disabled", async () => {
+		const settingsPath = createTempFile("data/global-settings.json");
+		writeFileSync(settingsPath, JSON.stringify({ autoUpdateEnabled: false }));
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+		delete process.env.CLINE_NO_AUTO_UPDATE;
+		const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue({
+			ok: true,
+			json: async () => ({ version: "0.0.0" }),
+		} as Response);
+
+		await checkForUpdates({ includeKanban: false });
+
+		expect(fetchSpy).toHaveBeenCalled();
+	});
+});
+
+describe("hub restart owner selection", () => {
+	afterEach(() => {
+		if (originalBuildEnv === undefined) {
+			delete process.env.CLINE_BUILD_ENV;
+		} else {
+			process.env.CLINE_BUILD_ENV = originalBuildEnv;
+		}
+		if (originalDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalDataDir;
+		}
+		if (originalHubDiscoveryPath === undefined) {
+			delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		} else {
+			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
+		}
+	});
+
+	it("uses the shared hub owner outside production builds", () => {
+		process.env.CLINE_BUILD_ENV = "development";
+		process.env.CLINE_DATA_DIR = "/tmp/cline-update-test-data";
+		delete process.env.CLINE_HUB_DISCOVERY_PATH;
+
+		const owner = resolveCliHubOwnerContext();
+
+		expect(owner.discoveryPath).toContain("/locks/hub/owners/");
+		expect(owner.discoveryPath).not.toBe(
+			"/tmp/cline-update-test-data/locks/hub/production.json",
+		);
+	});
+});
+
+describe("withMinimumReleaseAgeBypass", () => {
+	it("adds the package-manager-specific cooldown bypass", () => {
+		expect(
+			withMinimumReleaseAgeBypass(
+				"npm update -g cline --tag latest",
+				PackageManager.NPM,
+			).command,
+		).toBe("npm update -g cline --tag latest --min-release-age=0");
+		expect(
+			withMinimumReleaseAgeBypass("bun add -g cline@latest", PackageManager.BUN)
+				.command,
+		).toBe("bun add -g cline@latest --minimum-release-age=0");
+		expect(
+			withMinimumReleaseAgeBypass(
+				"yarn global add cline@latest",
+				PackageManager.YARN,
+			).command,
+		).toBe("yarn global add cline@latest");
+		expect(
+			withMinimumReleaseAgeBypass(
+				"yarn global add cline@latest",
+				PackageManager.YARN,
+			).env?.YARN_NPM_MINIMAL_AGE_GATE,
+		).toBe("0");
+
+		expect(
+			withMinimumReleaseAgeBypass(
+				"pnpm add -g cline@latest",
+				PackageManager.PNPM,
+			).env?.pnpm_config_minimum_release_age,
+		).toBe("0");
+	});
+});
diff --git a/apps/cli/src/commands/update.ts b/apps/cli/src/commands/update.ts
new file mode 100644
index 0000000..2bb7be0
--- /dev/null
+++ b/apps/cli/src/commands/update.ts
@@ -0,0 +1,568 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import {
+	clearHubDiscovery,
+	isAutoUpdateEnabledGlobally,
+	probeHubServer,
+	readHubDiscovery,
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+	stopLocalHubServerGracefully,
+} from "@cline/core";
+import { resolveClineBuildEnv } from "@cline/shared";
+import { version } from "../../package.json";
+import { ensureCliHubServer } from "../utils/hub-runtime";
+import { c, writeErr, writeln } from "../utils/output";
+import {
+	getInstalledKanbanVersion,
+	type KanbanInstaller,
+	resolveKanbanInstallCommand,
+	spawnKanbanInstallProcess,
+} from "./kanban";
+
+const DEFAULT_PACKAGE_NAME = "cline";
+
+type CliPackageName = typeof DEFAULT_PACKAGE_NAME;
+
+export enum PackageManager {
+	NPM = "npm",
+	PNPM = "pnpm",
+	YARN = "yarn",
+	BUN = "bun",
+	NPX = "npx",
+	UNKNOWN = "unknown",
+}
+
+interface InstallationInfo {
+	packageManager: PackageManager;
+	packageName: CliPackageName;
+	updateCommand?: string;
+}
+
+interface ManualUpdateCommand {
+	command: string;
+	env?: Readonly<Record<string, string>>;
+}
+
+function isNightlyVersion(v: string): boolean {
+	return v.includes("-nightly.");
+}
+
+function getNpmTag(v: string): string {
+	return isNightlyVersion(v) ? "nightly" : "latest";
+}
+
+interface ParsedVersion {
+	base: number[];
+	isNightly: boolean;
+	timestamp: number;
+}
+
+function parseVersion(v: string): ParsedVersion {
+	const m = v.match(/^(\d+\.\d+\.\d+)-nightly\.(\d+)$/);
+	if (m) {
+		return {
+			base: m[1].split(".").map(Number),
+			isNightly: true,
+			timestamp: Number.parseInt(m[2], 10),
+		};
+	}
+	return { base: v.split(".").map(Number), isNightly: false, timestamp: 0 };
+}
+
+function compareVersions(v1: string, v2: string): number {
+	const p1 = parseVersion(v1);
+	const p2 = parseVersion(v2);
+	for (let i = 0; i < Math.max(p1.base.length, p2.base.length); i++) {
+		const a = p1.base[i] || 0;
+		const b = p2.base[i] || 0;
+		if (a > b) return 1;
+		if (a < b) return -1;
+	}
+	if (p1.isNightly && !p2.isNightly) return -1;
+	if (!p1.isNightly && p2.isNightly) return 1;
+	if (p1.isNightly && p2.isNightly) {
+		if (p1.timestamp > p2.timestamp) return 1;
+		if (p1.timestamp < p2.timestamp) return -1;
+	}
+	return 0;
+}
+
+export function getInstallationInfo(currentVersion: string): InstallationInfo {
+	const tag = getNpmTag(currentVersion);
+	try {
+		const scriptPath = realpathSync(
+			process.env.CLINE_WRAPPER_PATH || process.argv[1] || "",
+		).replace(/\\/g, "/");
+
+		if (scriptPath.includes("/.npm/_npx") || scriptPath.includes("/npm/_npx")) {
+			return {
+				packageManager: PackageManager.NPX,
+				packageName: DEFAULT_PACKAGE_NAME,
+			};
+		}
+		if (
+			scriptPath.includes("/.pnpm/global") ||
+			scriptPath.includes("/pnpm/global")
+		) {
+			return {
+				packageManager: PackageManager.PNPM,
+				packageName: DEFAULT_PACKAGE_NAME,
+				updateCommand: `pnpm add -g ${DEFAULT_PACKAGE_NAME}@${tag}`,
+			};
+		}
+		if (scriptPath.includes("/.yarn/") || scriptPath.includes("/yarn/global")) {
+			return {
+				packageManager: PackageManager.YARN,
+				packageName: DEFAULT_PACKAGE_NAME,
+				updateCommand: `yarn global add ${DEFAULT_PACKAGE_NAME}@${tag}`,
+			};
+		}
+		// `bun add -g` symlinks bins into ~/.bun/bin, but realpathSync resolves
+		// them to ~/.bun/install/global/node_modules/..., so match both.
+		if (
+			scriptPath.includes("/.bun/bin") ||
+			scriptPath.includes("/.bun/install/global/")
+		) {
+			return {
+				packageManager: PackageManager.BUN,
+				packageName: DEFAULT_PACKAGE_NAME,
+				updateCommand: `bun add -g ${DEFAULT_PACKAGE_NAME}@${tag}`,
+			};
+		}
+		if (scriptPath.includes("/node_modules/")) {
+			return {
+				packageManager: PackageManager.NPM,
+				packageName: DEFAULT_PACKAGE_NAME,
+				updateCommand: `npm update -g ${DEFAULT_PACKAGE_NAME} --tag ${tag}`,
+			};
+		}
+	} catch {
+		// Fall through to unknown
+	}
+	return {
+		packageManager: PackageManager.UNKNOWN,
+		packageName: DEFAULT_PACKAGE_NAME,
+	};
+}
+
+export function withMinimumReleaseAgeBypass(
+	updateCommand: string,
+	packageManager: PackageManager,
+): ManualUpdateCommand {
+	switch (packageManager) {
+		case PackageManager.NPM:
+			return { command: `${updateCommand} --min-release-age=0` };
+		case PackageManager.PNPM:
+			return {
+				command: updateCommand,
+				env: {
+					PNPM_CONFIG_MINIMUM_RELEASE_AGE: "0",
+					pnpm_config_minimum_release_age: "0",
+					npm_config_minimum_release_age: "0",
+				},
+			};
+		case PackageManager.YARN:
+			return {
+				command: updateCommand,
+				env: { YARN_NPM_MINIMAL_AGE_GATE: "0" },
+			};
+		case PackageManager.BUN:
+			return { command: `${updateCommand} --minimum-release-age=0` };
+		default:
+			return { command: updateCommand };
+	}
+}
+
+async function getLatestVersion(
+	packageName: CliPackageName,
+	currentVersion: string,
+): Promise<string | null> {
+	const tag = getNpmTag(currentVersion);
+	return getLatestPackageVersion(packageName, tag);
+}
+
+async function getLatestPackageVersion(
+	packageName: string,
+	tag = "latest",
+): Promise<string | null> {
+	try {
+		const res = await fetch(
+			`https://registry.npmjs.org/${encodeURIComponent(packageName)}/${tag}`,
+		);
+		if (!res.ok) return null;
+		const data = (await res.json()) as { version: string };
+		return data.version || null;
+	} catch {
+		return null;
+	}
+}
+
+async function getLatestKanbanVersion(): Promise<string | null> {
+	return getLatestPackageVersion("kanban");
+}
+
+function waitForProcessExit(child: ChildProcess): Promise<number> {
+	return new Promise<number>((resolve, reject) => {
+		child.once("close", (code) => resolve(code ?? 1));
+		child.once("error", reject);
+	});
+}
+
+async function runCliUpdate(
+	updateCommand: ManualUpdateCommand,
+): Promise<number> {
+	const updateProcess = spawn(updateCommand.command, {
+		stdio: "inherit",
+		shell: true,
+		env: updateCommand.env
+			? { ...process.env, ...updateCommand.env }
+			: process.env,
+		windowsHide: true,
+	});
+	return waitForProcessExit(updateProcess);
+}
+
+type KanbanInstallCommand = NonNullable<
+	ReturnType<typeof resolveKanbanInstallCommand>
+>;
+
+async function runKanbanUpdate(
+	installCommand: KanbanInstallCommand,
+): Promise<number> {
+	const updateProcess = spawnKanbanInstallProcess(installCommand, {
+		env: process.env,
+		windowsHide: true,
+	});
+	return waitForProcessExit(updateProcess);
+}
+
+function formatUpdateSummaryTargets(targets: string[]): string {
+	if (targets.length === 0) {
+		return "";
+	}
+	if (targets.length === 1) {
+		return targets[0] ?? "";
+	}
+	if (targets.length === 2) {
+		return `${targets[0]} and ${targets[1]}`;
+	}
+	const lastTarget = targets[targets.length - 1];
+	return `${targets.slice(0, -1).join(", ")}, and ${lastTarget}`;
+}
+
+function packageManagerToKanbanInstaller(
+	packageManager: PackageManager,
+): KanbanInstaller | undefined {
+	switch (packageManager) {
+		case PackageManager.NPM:
+			return "npm";
+		case PackageManager.PNPM:
+			return "pnpm";
+		case PackageManager.BUN:
+			return "bun";
+		default:
+			return undefined;
+	}
+}
+
+export function getPreferredKanbanInstaller(
+	currentVersion = version,
+): KanbanInstaller | undefined {
+	return packageManagerToKanbanInstaller(
+		getInstallationInfo(currentVersion).packageManager,
+	);
+}
+
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
+
+export function resolveCliHubOwnerContext() {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+async function waitForHubToStop(
+	url: string,
+	authToken: string | undefined,
+	timeoutMs: number,
+): Promise<boolean> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const check = await probeHubServer(url, { authToken }).catch(
+			() => undefined,
+		);
+		if (!check?.url) return true;
+		await sleep(100);
+	}
+	return false;
+}
+
+/**
+ * Restart the hub server if one is currently running.
+ * Gracefully asks the running hub process to stop, falls back to process signals,
+ * clears stale discovery, then re-ensures a fresh instance is spawned.
+ */
+async function restartHubServerIfRunning(): Promise<void> {
+	const owner = resolveCliHubOwnerContext();
+	const discovery = await readHubDiscovery(owner.discoveryPath).catch(
+		() => undefined,
+	);
+
+	const health = discovery?.url
+		? await probeHubServer(discovery.url, {
+				authToken: discovery.authToken,
+			}).catch(() => undefined)
+		: undefined;
+	if (!discovery || !health?.url) return;
+
+	const pid = discovery?.pid;
+	writeln(`${c.dim}[hub] restarting server…${c.reset}`);
+
+	let stopped = await stopLocalHubServerGracefully(owner).catch(() => false);
+	if (!stopped && pid) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {
+			// best-effort
+		}
+	}
+
+	stopped = await waitForHubToStop(health.url, discovery.authToken, 3_000);
+	if (!stopped && pid) {
+		try {
+			process.kill(pid, "SIGKILL");
+		} catch {
+			// best-effort
+		}
+		stopped = await waitForHubToStop(health.url, discovery.authToken, 2_000);
+	}
+
+	await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+
+	// Re-ensure a fresh hub instance is spawned.
+	try {
+		await ensureCliHubServer(process.cwd()); // return value intentionally unused here
+		writeln(`${c.green}✓${c.reset} ${c.dim}[hub] server restarted${c.reset}`);
+	} catch (err) {
+		writeErr(
+			`[hub] failed to restart server: ${err instanceof Error ? err.message : String(err)}`,
+		);
+	}
+}
+
+/**
+ * Non-blocking auto-update check for CLI startup.
+ * Spawns a detached install process if a newer version is available.
+ * Skipped for npx, dev, unknown installs. Disable with CLINE_NO_AUTO_UPDATE=1.
+ */
+export function autoUpdateOnStartup(): void {
+	if (process.env.IS_DEV === "true") return;
+	if (process.env.CLINE_NO_AUTO_UPDATE === "1") return;
+	if (!isAutoUpdateEnabledGlobally()) return;
+
+	const { packageName, packageManager, updateCommand } =
+		getInstallationInfo(version);
+	if (!updateCommand) return;
+
+	void (async () => {
+		try {
+			const latest = await getLatestVersion(packageName, version);
+			if (!latest || compareVersions(version, latest) >= 0) return;
+			const autoUpdateCommand = withMinimumReleaseAgeBypass(
+				updateCommand,
+				packageManager,
+			);
+			const child = spawn(autoUpdateCommand.command, {
+				shell: true,
+				detached: true,
+				stdio: "ignore",
+				env: autoUpdateCommand.env
+					? { ...process.env, ...autoUpdateCommand.env }
+					: process.env,
+				// Prevent a console window from flashing on Windows; detached
+				// processes otherwise allocate a new visible console.
+				windowsHide: true,
+			});
+			const exitCode = await waitForProcessExit(child);
+			if (exitCode === 0) {
+				await restartHubServerIfRunning();
+			}
+		} catch {
+			// Best-effort, silently ignore
+		}
+	})();
+}
+
+export interface CheckForUpdatesOptions {
+	verbose?: boolean;
+	includeKanban?: boolean;
+}
+
+/**
+ * Manual update: fetch latest version, print status, run the install command.
+ * Returns an exit code.
+ */
+export async function checkForUpdates(
+	options: CheckForUpdatesOptions = {},
+): Promise<number> {
+	const currentVersion = version;
+	const includeKanban = options.includeKanban ?? true;
+	writeln(
+		`${c.cyan}Checking for updates${includeKanban ? " to Cline CLI and kanban" : ""}…${c.reset}`,
+	);
+
+	const { packageName, updateCommand, packageManager } =
+		getInstallationInfo(currentVersion);
+
+	try {
+		const latestVersion = await getLatestVersion(packageName, currentVersion);
+		const kanbanInstallCommand = includeKanban
+			? resolveKanbanInstallCommand(
+					process.env,
+					process.platform,
+					packageManagerToKanbanInstaller(packageManager),
+				)
+			: null;
+		const latestKanbanVersion = kanbanInstallCommand
+			? await getLatestKanbanVersion()
+			: null;
+		const installedKanbanVersion = includeKanban
+			? getInstalledKanbanVersion()
+			: null;
+		const shouldUpdateKanban =
+			kanbanInstallCommand !== null &&
+			latestKanbanVersion !== null &&
+			(installedKanbanVersion === null ||
+				compareVersions(installedKanbanVersion, latestKanbanVersion) < 0);
+
+		if (options.verbose) {
+			writeln(`${c.dim}Current version: ${currentVersion}${c.reset}`);
+			writeln(`${c.dim}Package manager: ${packageManager}${c.reset}`);
+			writeln(`${c.dim}Package name:    ${packageName}${c.reset}`);
+			if (latestVersion) {
+				writeln(`${c.dim}Latest version:  ${latestVersion}${c.reset}`);
+			}
+			if (includeKanban) {
+				writeln(
+					`${c.dim}Kanban version:  ${installedKanbanVersion ?? "(not installed)"}${c.reset}`,
+				);
+				if (latestKanbanVersion) {
+					writeln(`${c.dim}Latest kanban:   ${latestKanbanVersion}${c.reset}`);
+				}
+				if (!kanbanInstallCommand) {
+					writeln(
+						`${c.dim}Kanban installer: unavailable (npm, pnpm, or bun not found)${c.reset}`,
+					);
+				}
+			}
+		}
+
+		if (!latestVersion && !shouldUpdateKanban) {
+			writeErr("Failed to check for updates: could not fetch latest version");
+			return 1;
+		}
+
+		const cliUpdateAvailable =
+			latestVersion !== null &&
+			compareVersions(currentVersion, latestVersion) < 0;
+		const cliIsUpToDate =
+			latestVersion !== null &&
+			compareVersions(currentVersion, latestVersion) >= 0;
+
+		if (!cliUpdateAvailable && !shouldUpdateKanban) {
+			if (cliIsUpToDate && installedKanbanVersion && latestKanbanVersion) {
+				writeln(
+					`${c.green}✓${c.reset} Already on the latest versions ${c.bold}${packageName}@${currentVersion}${c.reset} and ${c.bold}kanban@${installedKanbanVersion}${c.reset}`,
+				);
+			} else if (cliIsUpToDate) {
+				writeln(
+					`${c.green}✓${c.reset} Already on the latest version ${c.bold}${currentVersion}${c.reset}`,
+				);
+			}
+			return 0;
+		}
+
+		if (cliUpdateAvailable && latestVersion) {
+			writeln(
+				`${c.yellow}New version available:${c.reset} ${c.bold}${latestVersion}${c.reset} (current: ${currentVersion})`,
+			);
+		}
+
+		let hadFailure = false;
+		const installedUpdates: string[] = [];
+
+		if (cliUpdateAvailable && latestVersion) {
+			if (!updateCommand) {
+				writeln(
+					`${c.dim}Unable to determine Cline update command. Please update manually with your package manager.${c.reset}`,
+				);
+				hadFailure = true;
+			} else {
+				const manualUpdateCommand = withMinimumReleaseAgeBypass(
+					updateCommand,
+					packageManager,
+				);
+				writeln(
+					`${c.cyan}Installing ${packageName}@${latestVersion}…${c.reset}`,
+				);
+				try {
+					const exitCode = await runCliUpdate(manualUpdateCommand);
+					if (exitCode === 0) {
+						installedUpdates.push(`${packageName}@${latestVersion}`);
+						await restartHubServerIfRunning();
+					} else {
+						writeErr(
+							`Cline update failed (exit code ${exitCode}). Try running: ${manualUpdateCommand.command}`,
+						);
+						hadFailure = true;
+					}
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					writeErr(
+						`Failed to run Cline update command ${manualUpdateCommand.command}: ${message}`,
+					);
+					hadFailure = true;
+				}
+			}
+		}
+
+		if (shouldUpdateKanban && kanbanInstallCommand && latestKanbanVersion) {
+			writeln(`${c.cyan}Installing kanban@${latestKanbanVersion}…${c.reset}`);
+			try {
+				const exitCode = await runKanbanUpdate(kanbanInstallCommand);
+				if (exitCode === 0) {
+					installedUpdates.push(`kanban@${latestKanbanVersion}`);
+				} else {
+					writeErr(
+						`Kanban update failed (exit code ${exitCode}). Try running: ${kanbanInstallCommand.displayCommand}`,
+					);
+					hadFailure = true;
+				}
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				writeErr(
+					`Failed to run Kanban update command ${kanbanInstallCommand.displayCommand}: ${message}`,
+				);
+				hadFailure = true;
+			}
+		}
+
+		if (installedUpdates.length > 0) {
+			const label =
+				installedUpdates.length === 1
+					? "Installed update for"
+					: "Installed updates for";
+			writeln(
+				`${c.green}✓${c.reset} ${label} ${formatUpdateSummaryTargets(installedUpdates)}`,
+			);
+		}
+
+		return hadFailure ? 1 : 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		writeErr(`Error checking for updates: ${message}`);
+		return 1;
+	}
+}
diff --git a/apps/cli/src/connectors/adapters/discord.test.ts b/apps/cli/src/connectors/adapters/discord.test.ts
new file mode 100644
index 0000000..ebf44de
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/discord.test.ts
@@ -0,0 +1,628 @@
+import { writeFileSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ConnectDiscordOptions } from "@cline/shared";
+import type { Thread } from "chat";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { readBindings, writeBindings } from "../thread-bindings";
+import { __test__, discordConnector } from "./discord";
+
+const parseDiscordArgs = (rawArgs: string[]): ConnectDiscordOptions =>
+	(
+		discordConnector as unknown as {
+			parseArgs(rawArgs: string[]): ConnectDiscordOptions;
+		}
+	).parseArgs(rawArgs);
+
+type TestDiscordState = {
+	sessionId?: string;
+	enableTools?: boolean;
+	autoApproveTools?: boolean;
+	cwd?: string;
+	workspaceRoot?: string;
+	systemPrompt?: string;
+	participantKey?: string;
+	participantLabel?: string;
+	welcomeSentAt?: string;
+};
+
+function createThread(
+	initialState: TestDiscordState,
+): Thread<TestDiscordState> {
+	let state = { ...initialState };
+	return {
+		id: "discord:guild:channel:thread",
+		channelId: "discord:guild:channel",
+		isDM: false,
+		get state() {
+			return Promise.resolve(state);
+		},
+		async setState(nextState: TestDiscordState) {
+			state = { ...nextState };
+		},
+		toJSON() {
+			return {
+				id: "discord:guild:channel:thread",
+				channelId: "discord:guild:channel",
+				isDM: false,
+				state,
+			};
+		},
+	} as unknown as Thread<TestDiscordState>;
+}
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+});
+
+describe("discordConnector", () => {
+	it("accepts the documented app id and token aliases", () => {
+		const options = parseDiscordArgs([
+			"--app-id",
+			"app-123",
+			"--token",
+			"bot-token",
+			"--public-key",
+			"public-key",
+			"--base-url",
+			"https://example.test",
+		]);
+
+		expect(options.applicationId).toBe("app-123");
+		expect(options.botToken).toBe("bot-token");
+		expect(options.publicKey).toBe("public-key");
+		expect(options.baseUrl).toBe("https://example.test");
+	});
+
+	it("keeps accepting the explicit application id and bot token options", () => {
+		const options = parseDiscordArgs([
+			"--application-id",
+			"app-456",
+			"--bot-token",
+			"other-token",
+			"--public-key",
+			"public-key",
+			"--owner-user-id",
+			"owner-123",
+		]);
+
+		expect(options.applicationId).toBe("app-456");
+		expect(options.botToken).toBe("other-token");
+		expect(options.ownerUserId).toBe("owner-123");
+		expect(options.allowBotAuthors).toBe(true);
+	});
+
+	it("can explicitly ignore bot-authored Discord messages", () => {
+		const options = parseDiscordArgs([
+			"--application-id",
+			"app-456",
+			"--bot-token",
+			"other-token",
+			"--public-key",
+			"public-key",
+			"--ignore-bot-authors",
+		]);
+
+		expect(options.allowBotAuthors).toBe(false);
+	});
+
+	it("builds empty-runtime fallback replies from the current Discord turn", async () => {
+		const priorMessages = [
+			{
+				role: "user",
+				content: [{ type: "text", text: "previous question" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "Previous reply." }],
+			},
+		];
+		const currentMessages = [
+			...priorMessages,
+			{
+				role: "user",
+				content: [{ type: "text", text: "read README.md" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "Summary from saved session." }],
+			},
+		];
+		const client = {
+			readMessages: vi
+				.fn()
+				.mockResolvedValueOnce(priorMessages)
+				.mockResolvedValueOnce(currentMessages),
+		};
+
+		const resolveFallbackText =
+			await __test__.createDiscordEmptyRuntimeReplyResolver({
+				client: client as never,
+				sessionId: "session-1",
+			});
+
+		await expect(resolveFallbackText?.()).resolves.toBe(
+			"Summary from saved session.",
+		);
+		expect(client.readMessages).toHaveBeenCalledTimes(2);
+	});
+
+	it("does not reuse prior Discord replies as empty-runtime fallback text", async () => {
+		const priorMessages = [
+			{
+				role: "user",
+				content: [{ type: "text", text: "previous question" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "Previous reply." }],
+			},
+		];
+		const currentMessages = [
+			...priorMessages,
+			{
+				role: "user",
+				content: [{ type: "text", text: "run ls /tmp" }],
+			},
+			{
+				role: "tool",
+				content: [{ type: "text", text: "tool output" }],
+			},
+		];
+		const client = {
+			readMessages: vi
+				.fn()
+				.mockResolvedValueOnce(priorMessages)
+				.mockResolvedValueOnce(currentMessages),
+		};
+
+		const resolveFallbackText =
+			await __test__.createDiscordEmptyRuntimeReplyResolver({
+				client: client as never,
+				sessionId: "session-1",
+			});
+
+		await expect(resolveFallbackText?.()).resolves.toBeUndefined();
+		expect(client.readMessages).toHaveBeenCalledTimes(2);
+	});
+
+	it("resolves Discord participants from normalized gateway message authors", () => {
+		expect(
+			__test__.resolveDiscordParticipant(
+				{
+					content: "<@1509620637721821224> Heyo",
+					author: {
+						id: "bot-message-author-should-not-win",
+						username: "beebot",
+					},
+				},
+				{
+					userId: "850213762576810065",
+					userName: "alice",
+					fullName: "Alice Example",
+				},
+			),
+		).toEqual({
+			key: "discord:user:850213762576810065",
+			label: "Alice Example",
+		});
+	});
+
+	it("resolves Discord interaction users even when raw.data is command data", () => {
+		expect(
+			__test__.resolveDiscordParticipant({
+				id: "interaction-1",
+				data: { name: "ask" },
+				member: {
+					user: {
+						id: "488220547356950529",
+						username: "bob",
+						global_name: "Bob Example",
+					},
+				},
+			}),
+		).toEqual({
+			key: "discord:user:488220547356950529",
+			label: "Bob Example",
+		});
+	});
+
+	it("updates Discord participant metadata without changing the thread session", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "discord-participants-"));
+		const bindingsPath = join(dir, "threads.json");
+		const thread = createThread({
+			sessionId: "session-alice",
+			participantKey: "discord:user:alice",
+			participantLabel: "Alice",
+		});
+		writeBindings<TestDiscordState>(bindingsPath, {
+			"discord:user:alice": {
+				channelId: thread.channelId,
+				isDM: thread.isDM,
+				participantKey: "discord:user:alice",
+				participantLabel: "Alice",
+				serializedThread: JSON.stringify(thread.toJSON()),
+				sessionId: "session-alice",
+				state: {
+					sessionId: "session-alice",
+					participantKey: "discord:user:alice",
+					participantLabel: "Alice",
+				},
+				updatedAt: "2026-05-26T00:00:00.000Z",
+			},
+		});
+
+		await __test__.persistDiscordThreadContext({
+			thread,
+			bindingsPath,
+			baseStartRequest: {
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				systemPrompt: "system",
+				provider: "cline",
+				model: "test-model",
+				mode: "act",
+			},
+			message: {
+				raw: {
+					author: {
+						id: "bob",
+						username: "bob",
+						global_name: "Bob",
+					},
+				},
+			},
+			errorLabel: "Discord",
+		});
+
+		const binding =
+			readBindings<TestDiscordState>(bindingsPath)[
+				"discord:guild:channel:thread"
+			];
+		expect(binding?.state?.participantKey).toBe("discord:user:bob");
+		expect(binding?.state?.participantLabel).toBe("Bob");
+		expect(binding?.state?.sessionId).toBe("session-alice");
+		expect(
+			readBindings<TestDiscordState>(bindingsPath)["discord:user:alice"]?.state
+				?.sessionId,
+		).toBe("session-alice");
+	});
+
+	it("adds Discord author context to runtime turns", () => {
+		expect(
+			__test__.formatDiscordRuntimeText(
+				"Heyo",
+				{
+					key: "discord:user:850213762576810065",
+					label: "Alice Example",
+				},
+				{
+					ownerUserId: "850213762576810065",
+					isDirectMention: false,
+					isSubscribedThreadMessage: true,
+				},
+			),
+		).toContain("authorId: 850213762576810065");
+		expect(
+			__test__.formatDiscordRuntimeText(
+				"Heyo",
+				{
+					key: "discord:user:850213762576810065",
+					label: "Alice Example",
+				},
+				{ ownerUserId: "850213762576810065" },
+			),
+		).toContain("isOwner: true");
+		expect(
+			__test__.formatDiscordRuntimeText(
+				"Heyo",
+				{
+					key: "discord:user:850213762576810065",
+					label: "Alice Example",
+				},
+				{
+					isDirectMention: false,
+					isSubscribedThreadMessage: true,
+				},
+			),
+		).toContain("isDirectMention: false");
+		expect(
+			__test__.formatDiscordRuntimeText(
+				"Heyo",
+				{
+					key: "discord:user:850213762576810065",
+					label: "Alice Example",
+				},
+				{
+					isDirectMention: false,
+					isSubscribedThreadMessage: true,
+				},
+			),
+		).toContain("isSubscribedThreadMessage: true");
+	});
+
+	it("instructs Discord agents to use /idle for unrelated subscribed thread messages", () => {
+		expect(__test__.DISCORD_SYSTEM_RULES).toContain("reply exactly /idle");
+		expect(__test__.DISCORD_SYSTEM_RULES).toContain("isDirectMention is false");
+		expect(__test__.DISCORD_SYSTEM_RULES).toContain("send /mute@BotName");
+		expect(__test__.DISCORD_SYSTEM_RULES).toContain("send /unmute@BotName");
+		expect(__test__.DISCORD_SYSTEM_RULES).toContain(
+			"/mute@BotName @user-or-bot",
+		);
+		expect(__test__.DISCORD_SYSTEM_RULES).toContain(
+			"/unmute@BotName @user-or-bot",
+		);
+	});
+
+	it("resolves Discord mute targets from user mentions and ids", () => {
+		expect(__test__.resolveDiscordMuteTarget("<@123456789012345678>")).toEqual({
+			participantKey: "discord:user:123456789012345678",
+			participantLabel: "<@123456789012345678>",
+		});
+		expect(__test__.resolveDiscordMuteTarget("<@!123456789012345678>")).toEqual(
+			{
+				participantKey: "discord:user:123456789012345678",
+				participantLabel: "<@123456789012345678>",
+			},
+		);
+		expect(__test__.resolveDiscordMuteTarget("@123456789012345678")).toEqual({
+			participantKey: "discord:user:123456789012345678",
+			participantLabel: "<@123456789012345678>",
+		});
+		expect(__test__.resolveDiscordMuteTarget("@not-a-user-id")).toBeUndefined();
+	});
+
+	it("resolves outbound Discord mention names to user mention ids", async () => {
+		const fetchMock = vi.fn(async (url: string | URL) => {
+			expect(String(url)).toContain(
+				"/guilds/guild-123/members/search?query=cline-test-bot&limit=10",
+			);
+			return new Response(
+				JSON.stringify([
+					{
+						nick: "cline-test-bot",
+						user: {
+							id: "1509620637721821224",
+							username: "clinetestbot",
+							bot: true,
+						},
+					},
+				]),
+				{ status: 200 },
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			__test__.resolveDiscordOutboundMentions({
+				botToken: "token",
+				threadId: "discord:guild-123:channel-123:thread-123",
+				text: "@cline-test-bot how is your day?",
+			}),
+		).resolves.toBe("<@1509620637721821224> how is your day?");
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("repairs adapter-split hyphenated Discord mention names before resolving", async () => {
+		const fetchMock = vi.fn(async (url: string | URL) => {
+			expect(String(url)).toContain("query=cline-test-bot");
+			return new Response(
+				JSON.stringify([
+					{
+						nick: "cline-test-bot",
+						user: {
+							id: "1509620637721821224",
+							username: "clinetestbot",
+							bot: true,
+						},
+					},
+				]),
+				{ status: 200 },
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			__test__.resolveDiscordOutboundMentions({
+				botToken: "token",
+				threadId: "discord:guild-123:channel-123:thread-123",
+				text: "<@cline>-test-bot how is your day?",
+			}),
+		).resolves.toBe("<@1509620637721821224> how is your day?");
+	});
+
+	it("does not resolve outbound mentions from non-exact Discord member search results", async () => {
+		const fetchMock = vi.fn(async () => {
+			return new Response(
+				JSON.stringify([
+					{
+						nick: "team-alice-bot",
+						user: {
+							id: "wrong-user",
+							username: "team-alice-bot",
+							bot: true,
+						},
+					},
+				]),
+				{ status: 200 },
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			__test__.resolveDiscordOutboundMentions({
+				botToken: "token",
+				threadId: "discord:guild-123:channel-123:thread-123",
+				text: "@alice can you check this?",
+			}),
+		).resolves.toBe("@alice can you check this?");
+	});
+
+	it("normalizes forwarded bot-role mentions as Discord mentions", async () => {
+		const fetchMock = vi.fn(async (url: string | URL) => {
+			expect(String(url)).toContain("/guilds/guild-role-test/members/app-123");
+			return new Response(JSON.stringify({ roles: ["role-123"] }), {
+				status: 200,
+			});
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const request = new Request("https://example.test/api/webhooks/discord", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				type: "GATEWAY_MESSAGE_CREATE",
+				data: {
+					id: "message-1",
+					guild_id: "guild-role-test",
+					channel_id: "channel-1",
+					content: "<@&role-123> hello",
+					mention_roles: ["role-123"],
+					mentions: [],
+					author: {
+						id: "user-1",
+						username: "alice",
+						bot: false,
+					},
+				},
+			}),
+		});
+
+		const normalized = await __test__.normalizeDiscordForwardedGatewayRequest({
+			request,
+			botToken: "token",
+			applicationId: "app-123",
+		});
+		const event = (await normalized.json()) as {
+			data: { is_mention?: boolean };
+		};
+
+		expect(event.data.is_mention).toBe(true);
+	});
+
+	it("retries bot role lookups after transient Discord API failures", async () => {
+		const fetchMock = vi
+			.fn()
+			.mockResolvedValueOnce(new Response("temporary", { status: 500 }))
+			.mockResolvedValueOnce(
+				new Response(JSON.stringify({ roles: ["role-123"] }), {
+					status: 200,
+				}),
+			);
+		vi.stubGlobal("fetch", fetchMock);
+
+		const buildRequest = () =>
+			new Request("https://example.test/api/webhooks/discord", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					type: "GATEWAY_MESSAGE_CREATE",
+					data: {
+						id: "message-1",
+						guild_id: "guild-retry-test",
+						channel_id: "channel-1",
+						content: "<@&role-123> hello",
+						mention_roles: ["role-123"],
+						mentions: [],
+						author: {
+							id: "user-1",
+							username: "alice",
+							bot: false,
+						},
+					},
+				}),
+			});
+
+		const failed = await __test__.normalizeDiscordForwardedGatewayRequest({
+			request: buildRequest(),
+			botToken: "token",
+			applicationId: "app-retry",
+		});
+		const failedEvent = (await failed.json()) as {
+			data: { is_mention?: boolean };
+		};
+		expect(failedEvent.data.is_mention).toBeUndefined();
+
+		const retried = await __test__.normalizeDiscordForwardedGatewayRequest({
+			request: buildRequest(),
+			botToken: "token",
+			applicationId: "app-retry",
+		});
+		const retriedEvent = (await retried.json()) as {
+			data: { is_mention?: boolean };
+		};
+
+		expect(retriedEvent.data.is_mention).toBe(true);
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+	});
+
+	it("restores persisted thread subscriptions once on startup", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "discord-bindings-"));
+		const bindingsPath = join(dir, "threads.json");
+		const subscribe = vi.fn(async () => undefined);
+		const threads = new Map([
+			[
+				"thread-1",
+				{
+					id: "thread-1",
+					subscribe,
+				},
+			],
+		]);
+		const bot = {
+			reviver: () => (_key: string, value: unknown) => {
+				if (
+					value &&
+					typeof value === "object" &&
+					(value as { _type?: string })._type === "chat:Thread"
+				) {
+					return threads.get((value as { id: string }).id) ?? value;
+				}
+				return value;
+			},
+		};
+		const logger = {
+			core: { log: vi.fn() },
+		} as unknown as Parameters<
+			typeof __test__.restoreDiscordThreadSubscriptions
+		>[0]["logger"];
+
+		writeFileSync(
+			bindingsPath,
+			JSON.stringify({
+				"discord:user:1": {
+					channelId: "discord:g:c",
+					isDM: false,
+					participantKey: "discord:user:1",
+					serializedThread: JSON.stringify({
+						_type: "chat:Thread",
+						id: "thread-1",
+					}),
+					updatedAt: "2026-05-26T00:00:00.000Z",
+				},
+				duplicate: {
+					channelId: "discord:g:c",
+					isDM: false,
+					serializedThread: JSON.stringify({
+						_type: "chat:Thread",
+						id: "thread-1",
+					}),
+					updatedAt: "2026-05-26T00:00:00.000Z",
+				},
+			}),
+		);
+
+		const restored = await __test__.restoreDiscordThreadSubscriptions({
+			bot,
+			bindingsPath,
+			logger,
+		});
+
+		expect(restored).toBe(1);
+		expect(subscribe).toHaveBeenCalledTimes(1);
+		expect(logger.core.log).not.toHaveBeenCalled();
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/discord.ts b/apps/cli/src/connectors/adapters/discord.ts
new file mode 100644
index 0000000..718c70f
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/discord.ts
@@ -0,0 +1,1567 @@
+import {
+	createDiscordAdapter,
+	type DiscordAdapter,
+} from "@chat-adapter/discord";
+import type { ChatStartSessionRequest } from "@cline/core";
+import {
+	createUserInstructionConfigService,
+	HubSessionClient,
+} from "@cline/core";
+import type {
+	ConnectDiscordOptions,
+	DiscordConnectorState,
+} from "@cline/shared";
+import { Chat, ConsoleLogger, type Thread, ThreadImpl } from "chat";
+import type { Command } from "commander";
+import { createCliLoggerAdapter } from "../../logging/adapter";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+	resolveDefaultCliRpcAddress,
+} from "../../utils/hub-runtime";
+import { createWorkspaceChatCommandHost } from "../../utils/plugin-chat-commands";
+import { ConnectorBase } from "../base";
+import {
+	createChatSdkLogger,
+	enqueueThreadTurn,
+	startConnectorWebhookServer,
+} from "../chat-runtime";
+import { isProcessRunning } from "../common";
+import {
+	type ActiveConnectorTurn,
+	handleConnectorUserTurn,
+	maybeHandleConnectorApprovalReply,
+} from "../connector-host";
+import { dispatchConnectorHook } from "../hooks";
+import {
+	type PendingConnectorApproval,
+	truncateConnectorText,
+} from "../runtime-turn";
+import {
+	buildConnectorStartRequest,
+	readSessionMessageCount,
+	readSessionReplyText,
+	stopConnectorSessions,
+} from "../session-runtime";
+import { InMemoryStateAdapter } from "../stores/memory-state";
+import { startConnectorTaskUpdateRelay } from "../task-updates";
+import {
+	type ConnectorBindingStore,
+	type ConnectorMuteTarget,
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	findBindingForThread,
+	loadThreadState,
+	persistMergedThreadState,
+	readBindings,
+} from "../thread-bindings";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "../types";
+import {
+	getConnectorFirstContactMessage,
+	getConnectorSystemPrompt,
+	getConnectorSystemRules,
+} from "./prompts";
+
+const DISCORD_SYSTEM_RULES = getConnectorSystemRules(
+	"Discord",
+	[
+		"You can respond in Discord threads, channels, and DMs, and you can use tools according to the user's requests and your capabilities.",
+		"When asked to mention a Discord user or bot by name, write the mention as @display-name or @username. The connector resolves unique guild names to Discord mention IDs before sending. Do not ask the user for a Discord ID unless the name cannot be resolved.",
+		"Discord subscribed thread messages may arrive even when they are not addressed to you. Check <discord_message_context>: when isDirectMention is false and the message is part of another user or bot conversation that does not require your action, reply exactly /idle and nothing else. The connector treats /idle as a private no-op and will not post it to Discord.",
+		"If this Discord thread is caught in a bot loop or the user wants the connector to stop processing this thread, tell them to send /mute@BotName in shared channels or /mute in DMs. Tell them to send /unmute@BotName in shared channels or /unmute in DMs when they want this connector to resume processing the thread.",
+		"If the user wants to mute only one Discord user or bot in the current thread, tell them to send /mute@BotName @user-or-bot in shared channels or /mute @user-or-bot in DMs. Tell them to send /unmute@BotName @user-or-bot in shared channels or /unmute @user-or-bot in DMs to resume processing that participant.",
+	].join("\n"),
+);
+
+const DISCORD_FIRST_CONTACT_MESSAGE = getConnectorFirstContactMessage();
+const DISCORD_GATEWAY_DURATION_MS = 1_800_000_000;
+
+type DiscordThreadState = ConnectorThreadState;
+type DiscordParticipant = { key: string; label?: string };
+type DiscordMessageIdentity = { author?: unknown; raw?: unknown };
+type DiscordThreadIdParts = {
+	guildId?: string;
+	channelId?: string;
+	threadId?: string;
+};
+type DiscordForwardedGatewayEvent = {
+	type?: string;
+	data?: unknown;
+};
+type DiscordGuildMemberResponse = {
+	roles?: unknown;
+};
+type DiscordGuildMember = {
+	nick?: string;
+	user?: {
+		id?: string;
+		username?: string;
+		global_name?: string | null;
+		bot?: boolean;
+	};
+};
+
+const botGuildRoleCache = new Map<string, Promise<Set<string>>>();
+
+function truncateText(value: string, maxLength = 160): string {
+	return truncateConnectorText(value, maxLength);
+}
+
+async function stopSessionsForApplication(
+	state: DiscordConnectorState,
+): Promise<number> {
+	return stopConnectorSessions({
+		rpcAddress: state.rpcAddress,
+		rpcMatcher: (metadata) =>
+			metadata?.transport === "discord" &&
+			metadata?.applicationId === state.applicationId,
+		localMatcher: (metadata) =>
+			metadata?.transport === "discord" &&
+			metadata?.applicationId === state.applicationId,
+	});
+}
+
+async function buildDiscordStartRequest(
+	options: ConnectDiscordOptions,
+	io: ConnectIo,
+	loggerConfig: Parameters<
+		typeof buildConnectorStartRequest
+	>[0]["loggerConfig"],
+): Promise<ChatStartSessionRequest> {
+	return buildConnectorStartRequest({
+		options,
+		io,
+		loggerConfig,
+		systemRules: DISCORD_SYSTEM_RULES,
+	});
+}
+
+async function createDiscordEmptyRuntimeReplyResolver(input: {
+	client: HubSessionClient;
+	sessionId: string;
+}): Promise<(() => Promise<string | undefined>) | undefined> {
+	const minMessageIndex = await readSessionMessageCount(
+		input.client,
+		input.sessionId,
+	);
+	if (minMessageIndex === undefined) {
+		return async () => undefined;
+	}
+	return () =>
+		readSessionReplyText(input.client, input.sessionId, {
+			minMessageIndex,
+		});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function readString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function readIdentifier(value: unknown): string | undefined {
+	if (typeof value === "string" && value.trim()) {
+		return value.trim();
+	}
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return String(value);
+	}
+	return undefined;
+}
+
+function readStringArray(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+function normalizeDiscordLookupName(value: string | undefined): string {
+	return (value ?? "").trim().replace(/^@+/, "").toLowerCase();
+}
+
+function resolveDiscordParticipantFromAuthor(
+	author: unknown,
+): DiscordParticipant | undefined {
+	const record = asRecord(author);
+	const userId =
+		readIdentifier(record?.userId) ||
+		readIdentifier(record?.id) ||
+		readIdentifier(record?.user_id);
+	const username =
+		readString(record?.userName) ||
+		readString(record?.username) ||
+		readString(record?.name);
+	const label =
+		readString(record?.fullName) ||
+		readString(record?.global_name) ||
+		readString(record?.displayName) ||
+		readString(record?.display_name) ||
+		username ||
+		userId;
+	if (!userId) {
+		return undefined;
+	}
+	return { key: `discord:user:${userId}`, label };
+}
+
+function resolveDiscordParticipant(
+	rawMessage: unknown,
+	messageAuthor?: unknown,
+): DiscordParticipant | undefined {
+	const normalized = resolveDiscordParticipantFromAuthor(messageAuthor);
+	if (normalized) {
+		return normalized;
+	}
+	const raw = asRecord(rawMessage);
+	const data = asRecord(raw?.data) ?? raw;
+	const candidates = [
+		asRecord(raw?.author),
+		asRecord(asRecord(raw?.member)?.user),
+		asRecord(raw?.user),
+		asRecord(data?.author),
+		asRecord(asRecord(data?.member)?.user),
+		asRecord(data?.user),
+		asRecord(asRecord(raw?.message)?.author),
+		asRecord(asRecord(data?.message)?.author),
+	];
+	for (const candidate of candidates) {
+		const participant = resolveDiscordParticipantFromAuthor(candidate);
+		if (participant) {
+			return participant;
+		}
+	}
+	return undefined;
+}
+
+function formatDiscordRuntimeText(
+	text: string,
+	participant: DiscordParticipant | undefined,
+	options?: {
+		ownerUserId?: string;
+		isDirectMention?: boolean;
+		isSubscribedThreadMessage?: boolean;
+	},
+): string {
+	if (!participant) {
+		return text;
+	}
+	const authorId = participant.key.replace(/^discord:user:/, "");
+	return [
+		"<discord_message_context>",
+		`authorId: ${authorId}`,
+		...(participant.label ? [`authorLabel: ${participant.label}`] : []),
+		`participantKey: ${participant.key}`,
+		...(options?.isDirectMention === undefined
+			? []
+			: [`isDirectMention: ${options.isDirectMention ? "true" : "false"}`]),
+		...(options?.isSubscribedThreadMessage === undefined
+			? []
+			: [
+					`isSubscribedThreadMessage: ${options.isSubscribedThreadMessage ? "true" : "false"}`,
+				]),
+		...(options?.ownerUserId && options.ownerUserId === authorId
+			? ["isOwner: true"]
+			: []),
+		"</discord_message_context>",
+		"",
+		text,
+	].join("\n");
+}
+
+function resolveDiscordMuteTarget(
+	rawTarget: string,
+): ConnectorMuteTarget | undefined {
+	const trimmed = rawTarget.trim();
+	const userId =
+		trimmed.match(/^<@!?(\d{15,25})>$/)?.[1] ??
+		trimmed.match(/^@?(\d{15,25})$/)?.[1];
+	if (!userId) {
+		return undefined;
+	}
+	return {
+		participantKey: `discord:user:${userId}`,
+		participantLabel: `<@${userId}>`,
+	};
+}
+
+function decodeDiscordThreadId(threadId: string): DiscordThreadIdParts {
+	const parts = threadId.split(":");
+	if (parts.length < 3 || parts[0] !== "discord") {
+		return {};
+	}
+	return {
+		guildId: parts[1],
+		channelId: parts[2],
+		threadId: parts[3],
+	};
+}
+
+async function readDiscordBotGuildRoleIds(input: {
+	botToken: string;
+	guildId: string;
+	applicationId: string;
+}): Promise<Set<string>> {
+	const cacheKey = `${input.guildId}:${input.applicationId}`;
+	const cached = botGuildRoleCache.get(cacheKey);
+	if (cached) {
+		return cached;
+	}
+	const pending = fetchDiscordJson({
+		botToken: input.botToken,
+		path: `/guilds/${encodeURIComponent(input.guildId)}/members/${encodeURIComponent(input.applicationId)}`,
+	}).then(
+		(value) => {
+			const member = value as DiscordGuildMemberResponse;
+			return new Set(readStringArray(member.roles));
+		},
+		() => {
+			botGuildRoleCache.delete(cacheKey);
+			return new Set<string>();
+		},
+	);
+	botGuildRoleCache.set(cacheKey, pending);
+	return pending;
+}
+
+async function normalizeDiscordForwardedGatewayRequest(input: {
+	request: Request;
+	botToken: string;
+	applicationId: string;
+}): Promise<Request> {
+	let event: DiscordForwardedGatewayEvent | undefined;
+	try {
+		event = (await input.request
+			.clone()
+			.json()) as DiscordForwardedGatewayEvent;
+	} catch {
+		return input.request;
+	}
+	if (event?.type !== "GATEWAY_MESSAGE_CREATE") {
+		return input.request;
+	}
+	const data = asRecord(event.data);
+	const guildId = readIdentifier(data?.guild_id);
+	const mentionRoleIds = readStringArray(data?.mention_roles);
+	if (!guildId || mentionRoleIds.length === 0 || data?.is_mention === true) {
+		return input.request;
+	}
+	const botRoleIds = await readDiscordBotGuildRoleIds({
+		botToken: input.botToken,
+		guildId,
+		applicationId: input.applicationId,
+	});
+	const mentionsBotRole = mentionRoleIds.some((roleId) =>
+		botRoleIds.has(roleId),
+	);
+	if (!mentionsBotRole) {
+		return input.request;
+	}
+	const headers = new Headers(input.request.headers);
+	headers.set("Content-Type", "application/json");
+	return new Request(input.request.url, {
+		method: input.request.method,
+		headers,
+		body: JSON.stringify({
+			...event,
+			data: {
+				...data,
+				is_mention: true,
+			},
+		}),
+	});
+}
+
+async function logDiscordForwardedGatewayMessage(input: {
+	request: Request;
+	logger: ConsoleLogger;
+	applicationId: string;
+}): Promise<void> {
+	let event: DiscordForwardedGatewayEvent | undefined;
+	try {
+		event = (await input.request
+			.clone()
+			.json()) as DiscordForwardedGatewayEvent;
+	} catch {
+		return;
+	}
+	if (event?.type !== "GATEWAY_MESSAGE_CREATE") {
+		return;
+	}
+	const data = asRecord(event.data);
+	const author = asRecord(data?.author);
+	const mentions = Array.isArray(data?.mentions)
+		? data.mentions
+				.map((mention) => readIdentifier(asRecord(mention)?.id))
+				.filter(Boolean)
+		: [];
+	const mentionRoleIds = readStringArray(data?.mention_roles);
+	input.logger.info("Discord forwarded Gateway message received", {
+		channelId: readIdentifier(data?.channel_id),
+		guildId: readIdentifier(data?.guild_id) ?? null,
+		authorId: readIdentifier(author?.id),
+		authorName: readString(author?.username),
+		authorIsBot: author?.bot === true,
+		isMe: readIdentifier(author?.id) === input.applicationId,
+		isMentioned: mentions.includes(input.applicationId),
+		isRoleMentioned: data?.is_mention === true,
+		mentionIds: mentions,
+		mentionRoleIds,
+		content: readString(data?.content)?.slice(0, 100) ?? "",
+	});
+}
+
+async function fetchDiscordJson(input: {
+	botToken: string;
+	path: string;
+	method?: "GET" | "POST";
+	body?: unknown;
+}): Promise<unknown> {
+	const response = await fetch(`https://discord.com/api/v10${input.path}`, {
+		method: input.method ?? "GET",
+		headers: {
+			Authorization: `Bot ${input.botToken}`,
+			...(input.body ? { "Content-Type": "application/json" } : {}),
+			"User-Agent": "Cline Discord Connector",
+		},
+		...(input.body ? { body: JSON.stringify(input.body) } : {}),
+	});
+	if (!response.ok) {
+		throw new Error(`Discord API ${response.status}: ${await response.text()}`);
+	}
+	return response.json();
+}
+
+async function searchDiscordGuildMembers(input: {
+	botToken: string;
+	guildId: string;
+	query: string;
+}): Promise<DiscordGuildMember[]> {
+	const query = normalizeDiscordLookupName(input.query);
+	if (!query || input.guildId === "@me") {
+		return [];
+	}
+	const parsed = await fetchDiscordJson({
+		botToken: input.botToken,
+		path: `/guilds/${encodeURIComponent(input.guildId)}/members/search?query=${encodeURIComponent(query)}&limit=10`,
+	});
+	return Array.isArray(parsed) ? (parsed as DiscordGuildMember[]) : [];
+}
+
+function pickDiscordMemberByName(
+	members: DiscordGuildMember[],
+	query: string,
+): DiscordGuildMember | undefined {
+	const normalizedQuery = normalizeDiscordLookupName(query);
+	const exact = members.filter((member) => {
+		const user = member.user;
+		return [member.nick, user?.username, user?.global_name ?? undefined].some(
+			(name) => normalizeDiscordLookupName(name) === normalizedQuery,
+		);
+	});
+	if (exact.length === 1) {
+		return exact[0];
+	}
+	return undefined;
+}
+
+async function resolveDiscordMentionName(input: {
+	botToken: string;
+	guildId: string | undefined;
+	name: string;
+}): Promise<string | undefined> {
+	if (!input.guildId || input.guildId === "@me") {
+		return undefined;
+	}
+	const members = await searchDiscordGuildMembers({
+		botToken: input.botToken,
+		guildId: input.guildId,
+		query: input.name,
+	}).catch(() => []);
+	const match = pickDiscordMemberByName(members, input.name);
+	const id = readIdentifier(match?.user?.id);
+	return id ? `<@${id}>` : undefined;
+}
+
+async function resolveDiscordOutboundMentions(input: {
+	botToken: string;
+	threadId: string;
+	text: string;
+}): Promise<string> {
+	const { guildId } = decodeDiscordThreadId(input.threadId);
+	if (!guildId || guildId === "@me" || !input.text.includes("@")) {
+		return input.text;
+	}
+	const mentionPattern =
+		/(^|[\s([{])(?:@([A-Za-z0-9_.-]{2,64})|<@([A-Za-z0-9_]{2,64})>((?:-[A-Za-z0-9_.]+)+))(?=$|[\s,.;:!?}\])])/g;
+	const replacements = new Map<string, string>();
+	for (const match of input.text.matchAll(mentionPattern)) {
+		const name = match[2] ?? `${match[3] ?? ""}${match[4] ?? ""}`;
+		if (!name || /^\d{15,25}$/.test(name) || replacements.has(name)) {
+			continue;
+		}
+		const mention = await resolveDiscordMentionName({
+			botToken: input.botToken,
+			guildId,
+			name,
+		});
+		if (mention) {
+			replacements.set(name, mention);
+		}
+	}
+	if (replacements.size === 0) {
+		return input.text.replace(
+			mentionPattern,
+			(full, prefix, rawName, base, suffix) => {
+				const name = rawName ?? `${base ?? ""}${suffix ?? ""}`;
+				return name ? `${prefix}@${name}` : full;
+			},
+		);
+	}
+	return input.text.replace(
+		mentionPattern,
+		(_full, prefix, rawName, base, suffix) => {
+			const name = rawName ?? `${base ?? ""}${suffix ?? ""}`;
+			const replacement = replacements.get(name);
+			return replacement ? `${prefix}${replacement}` : `${prefix}@${name}`;
+		},
+	);
+}
+
+async function postDiscordResolvedText(input: {
+	botToken: string;
+	thread: Thread<DiscordThreadState>;
+	text: string;
+}): Promise<void> {
+	const resolvedText = await resolveDiscordOutboundMentions({
+		botToken: input.botToken,
+		threadId: input.thread.id,
+		text: input.text,
+	});
+	const { channelId, threadId } = decodeDiscordThreadId(input.thread.id);
+	const targetChannelId = threadId || channelId;
+	if (!targetChannelId) {
+		await input.thread.post(resolvedText);
+		return;
+	}
+	await fetchDiscordJson({
+		botToken: input.botToken,
+		path: `/channels/${encodeURIComponent(targetChannelId)}/messages`,
+		method: "POST",
+		body: {
+			content: resolvedText.slice(0, 2000),
+			allowed_mentions: { parse: ["users"] },
+		},
+	});
+}
+
+function resolveCurrentStateWithParticipant(input: {
+	currentState: DiscordThreadState;
+	participant: DiscordParticipant;
+}): DiscordThreadState {
+	return {
+		...input.currentState,
+		participantKey: input.participant.key,
+		participantLabel: input.participant.label,
+	};
+}
+
+async function persistDiscordThreadContext(input: {
+	thread: Thread<DiscordThreadState>;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	message: DiscordMessageIdentity;
+	errorLabel: string;
+}): Promise<DiscordParticipant | undefined> {
+	const participant = resolveDiscordParticipant(
+		input.message.raw,
+		input.message.author,
+	);
+	if (!participant) {
+		return undefined;
+	}
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	const nextState = resolveCurrentStateWithParticipant({
+		currentState,
+		participant,
+	});
+	if (
+		currentState.participantKey === nextState.participantKey &&
+		currentState.participantLabel === nextState.participantLabel &&
+		currentState.sessionId === nextState.sessionId
+	) {
+		return participant;
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		nextState,
+		input.errorLabel,
+	);
+	return participant;
+}
+
+async function deliverScheduledResult(input: {
+	bot: Chat;
+	client: HubSessionClient;
+	bindingsPath: string;
+	userName: string;
+	scheduleId: string;
+	sessionId?: string;
+	status: string;
+	errorMessage?: string;
+}): Promise<void> {
+	const schedule = await input.client.getSchedule(input.scheduleId);
+	const delivery = schedule?.metadata?.delivery as
+		| Record<string, unknown>
+		| undefined;
+	if (!delivery || delivery.adapter !== "discord") {
+		return;
+	}
+	const targetUser =
+		typeof delivery.userName === "string" ? delivery.userName.trim() : "";
+	if (targetUser && targetUser !== input.userName) {
+		return;
+	}
+	const threadId =
+		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
+	const bindingKey =
+		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
+	const participantKey =
+		typeof delivery.participantKey === "string"
+			? delivery.participantKey.trim()
+			: "";
+	if (!threadId && !bindingKey && !participantKey) {
+		return;
+	}
+	const bindings = readBindings<DiscordThreadState>(input.bindingsPath);
+	const match = findBindingForDeliveryTarget(bindings, {
+		bindingKey,
+		threadId,
+		participantKey,
+	});
+	const binding = match?.binding;
+	if (!binding?.serializedThread) {
+		return;
+	}
+	const thread = JSON.parse(
+		binding.serializedThread,
+		input.bot.reviver(),
+	) as Thread<DiscordThreadState>;
+	let body = "";
+	if (input.status === "success" && input.sessionId) {
+		const text = await readSessionReplyText(input.client, input.sessionId);
+		body = text?.trim()
+			? text
+			: `Schedule "${schedule?.name ?? input.scheduleId}" completed, but no assistant reply text was found.`;
+	} else {
+		body = `Schedule "${schedule?.name ?? input.scheduleId}" ${input.status}.${input.errorMessage ? `\n\n${input.errorMessage}` : ""}`;
+	}
+	await thread.post(body);
+}
+
+function isRestorableThread(
+	value: unknown,
+): value is Thread<DiscordThreadState> & { subscribe(): Promise<void> } {
+	return (
+		Boolean(value) &&
+		typeof value === "object" &&
+		typeof (value as Thread<DiscordThreadState>).id === "string" &&
+		typeof (value as Thread<DiscordThreadState>).subscribe === "function"
+	);
+}
+
+async function restoreDiscordThreadSubscriptions(input: {
+	bot: Pick<Chat, "reviver">;
+	bindingsPath: string;
+	logger: ReturnType<typeof createCliLoggerAdapter>;
+}): Promise<number> {
+	const bindings = readBindings<DiscordThreadState>(input.bindingsPath);
+	const restoredThreadIds = new Set<string>();
+	for (const binding of Object.values(bindings)) {
+		if (!binding.serializedThread?.trim()) {
+			continue;
+		}
+		try {
+			const thread = JSON.parse(
+				binding.serializedThread,
+				input.bot.reviver(),
+			) as unknown;
+			if (!isRestorableThread(thread) || restoredThreadIds.has(thread.id)) {
+				continue;
+			}
+			await thread.subscribe();
+			restoredThreadIds.add(thread.id);
+		} catch (error) {
+			input.logger.core.log("Failed to restore Discord thread subscription", {
+				severity: "warn",
+				error: error instanceof Error ? error.message : String(error),
+				channelId: binding.channelId,
+				participantKey: binding.participantKey,
+			});
+		}
+	}
+	return restoredThreadIds.size;
+}
+
+class DiscordConnector extends ConnectorBase<
+	ConnectDiscordOptions,
+	DiscordConnectorState
+> {
+	constructor() {
+		super(
+			"discord",
+			"Discord interactions and gateway bridge backed by RPC runtime sessions",
+		);
+	}
+
+	protected override createCommand(): Command {
+		return super
+			.createCommand()
+			.usage("--base-url <PUBLIC_BASE_URL> [options]")
+			.option("--user-name <name>", "Discord bot username label")
+			.option("--application-id <id>", "Discord application id")
+			.option("--app-id <id>", "Alias for --application-id")
+			.option("--bot-token <token>", "Discord bot token")
+			.option("--token <token>", "Alias for --bot-token")
+			.option("--public-key <key>", "Discord application public key")
+			.option(
+				"--owner-user-id <id>",
+				"Discord user id that should be marked as connector owner",
+			)
+			.option("--ignore-bot-authors", "Ignore messages from other Discord bots")
+			.option(
+				"--mention-role-ids <ids>",
+				"Comma-separated role IDs that should trigger mention handlers",
+			)
+			.option("--provider <id>", "Provider override")
+			.option("--model <id>", "Model override")
+			.option("--api-key <key>", "Provider API key override")
+			.option("--system <prompt>", "System prompt override")
+			.option("--cwd <path>", "Workspace / cwd for runtime")
+			.option("--mode <act|plan>", "Agent mode", "act")
+			.option("-i, --interactive", "Keep connector in foreground")
+			.option("--enable-tools", "Enable tools for Discord sessions")
+			.option(
+				"--hook-command <command>",
+				"Run a shell command for connector events",
+			)
+			.option(
+				"--rpc-address <host:port>",
+				"RPC address",
+				process.env.CLINE_RPC_ADDRESS?.trim() || resolveDefaultCliRpcAddress(),
+			)
+			.option("--host <host>", "Webhook listen host")
+			.option("--port <port>", "Webhook listen port")
+			.option(
+				"--base-url <url>",
+				"Public base URL for Discord interactions webhook",
+			)
+			.addHelpText(
+				"after",
+				[
+					"",
+					"Environment:",
+					"  DISCORD_APPLICATION_ID      Discord application id",
+					"  DISCORD_BOT_TOKEN           Discord bot token",
+					"  DISCORD_PUBLIC_KEY          Discord application public key",
+					"  DISCORD_OWNER_USER_ID       Optional connector owner user id",
+					"  DISCORD_IGNORE_BOT_AUTHORS  Set to 1 to ignore messages from other bots",
+					"  DISCORD_MENTION_ROLE_IDS    Optional comma-separated role ids",
+				].join("\n"),
+			);
+	}
+
+	protected override readOptions(command: Command): ConnectDiscordOptions {
+		const opts = command.opts<{
+			userName?: string;
+			applicationId?: string;
+			appId?: string;
+			botToken?: string;
+			token?: string;
+			publicKey?: string;
+			ownerUserId?: string;
+			ignoreBotAuthors?: boolean;
+			mentionRoleIds?: string;
+			cwd?: string;
+			model?: string;
+			provider?: string;
+			apiKey?: string;
+			system?: string;
+			mode?: string;
+			interactive?: boolean;
+			enableTools?: boolean;
+			rpcAddress?: string;
+			hookCommand?: string;
+			port?: string;
+			host?: string;
+			baseUrl?: string;
+		}>();
+		const parsedPort =
+			this.parseOptionalInteger(opts.port, "port") ??
+			Number.parseInt(process.env.PORT ?? "8787", 10);
+		const port = Number.isFinite(parsedPort) ? parsedPort : 8787;
+		const mentionRoleIds = (
+			opts.mentionRoleIds?.trim() ||
+			process.env.DISCORD_MENTION_ROLE_IDS?.trim() ||
+			""
+		)
+			.split(",")
+			.map((value) => value.trim())
+			.filter(Boolean);
+		return {
+			userName:
+				opts.userName?.trim() ||
+				process.env.DISCORD_BOT_USERNAME?.trim() ||
+				"cline-discord",
+			applicationId:
+				opts.applicationId?.trim() ||
+				opts.appId?.trim() ||
+				process.env.DISCORD_APPLICATION_ID?.trim() ||
+				"",
+			botToken:
+				opts.botToken?.trim() ||
+				opts.token?.trim() ||
+				process.env.DISCORD_BOT_TOKEN?.trim() ||
+				"",
+			publicKey:
+				opts.publicKey?.trim() || process.env.DISCORD_PUBLIC_KEY?.trim() || "",
+			ownerUserId:
+				opts.ownerUserId?.trim() ||
+				process.env.DISCORD_OWNER_USER_ID?.trim() ||
+				undefined,
+			allowBotAuthors:
+				!opts.ignoreBotAuthors &&
+				!/^(1|true|yes)$/i.test(
+					process.env.DISCORD_IGNORE_BOT_AUTHORS?.trim() ?? "",
+				),
+			mentionRoleIds: mentionRoleIds.length > 0 ? mentionRoleIds : undefined,
+			cwd: opts.cwd || process.cwd(),
+			model: opts.model,
+			provider: opts.provider,
+			apiKey: opts.apiKey,
+			systemPrompt: opts.system,
+			mode: this.parseMode(opts.mode),
+			interactive: Boolean(opts.interactive),
+			enableTools: Boolean(opts.enableTools),
+			rpcAddress:
+				opts.rpcAddress?.trim() ||
+				process.env.CLINE_RPC_ADDRESS?.trim() ||
+				resolveDefaultCliRpcAddress(),
+			hookCommand:
+				opts.hookCommand?.trim() ||
+				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
+			port,
+			host: opts.host?.trim() || process.env.HOST?.trim() || "0.0.0.0",
+			baseUrl:
+				opts.baseUrl?.trim() ||
+				process.env.BASE_URL?.trim() ||
+				`http://127.0.0.1:${port}`,
+		};
+	}
+
+	private resolveConnectorStatePath(applicationId: string): string {
+		return this.resolveConnectorPath(`${this.sanitizeKey(applicationId)}.json`);
+	}
+
+	private resolveBindingsPath(applicationId: string): string {
+		return this.resolveConnectorPath(
+			`${this.sanitizeKey(applicationId)}.threads.json`,
+		);
+	}
+
+	private listConnectorStatePaths(): string[] {
+		return this.listJsonStatePaths([".threads.json"]);
+	}
+
+	private readConnectorState(
+		statePath: string,
+	): DiscordConnectorState | undefined {
+		return this.readStateFile(
+			statePath,
+			(value): value is DiscordConnectorState =>
+				Boolean(
+					value &&
+						typeof value === "object" &&
+						typeof (value as DiscordConnectorState).pid === "number" &&
+						typeof (value as DiscordConnectorState).applicationId === "string",
+				),
+		);
+	}
+
+	private writeConnectorState(
+		statePath: string,
+		state: DiscordConnectorState,
+	): void {
+		this.writeStateFile(statePath, state);
+	}
+
+	private async stopDiscordConnectorInstance(
+		statePath: string,
+		io: ConnectIo,
+	): Promise<ConnectStopResult> {
+		return this.stopManagedProcess({
+			io,
+			statePath,
+			readState: (path) => this.readConnectorState(path),
+			describeStoppedProcess: (state) =>
+				`[discord] stopped pid=${state.pid} application=${state.applicationId}`,
+			getPid: (state) => state.pid,
+			stopSessions: stopSessionsForApplication,
+			clearBindings: (state) => {
+				clearBindingSessionIds<DiscordThreadState>(
+					this.resolveBindingsPath(state.applicationId),
+				);
+			},
+		});
+	}
+
+	override async stopAll(io: ConnectIo): Promise<ConnectStopResult> {
+		return this.stopAllFromStatePaths(
+			io,
+			this.listConnectorStatePaths(),
+			(statePath, stopIo) =>
+				this.stopDiscordConnectorInstance(statePath, stopIo),
+		);
+	}
+
+	protected override async runWithOptions(
+		options: ConnectDiscordOptions,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number> {
+		if (!options.applicationId) {
+			io.writeErr(
+				"connect discord requires --application-id <id> or DISCORD_APPLICATION_ID",
+			);
+			return 1;
+		}
+		if (!options.botToken) {
+			io.writeErr(
+				"connect discord requires --bot-token <token> or DISCORD_BOT_TOKEN",
+			);
+			return 1;
+		}
+		if (!options.publicKey) {
+			io.writeErr(
+				"connect discord requires --public-key <key> or DISCORD_PUBLIC_KEY",
+			);
+			return 1;
+		}
+
+		const statePath = this.resolveConnectorStatePath(options.applicationId);
+		const bindingsPath = this.resolveBindingsPath(options.applicationId);
+		const staleState = this.removeStaleState(
+			statePath,
+			(path) => this.readConnectorState(path),
+			(state) => state.pid,
+		);
+		if (staleState) {
+			clearBindingSessionIds<DiscordThreadState>(bindingsPath);
+		}
+		if (
+			await this.maybeRunInBackground({
+				rawArgs,
+				io,
+				interactive: options.interactive,
+				childEnvVar: "CLINE_DISCORD_CONNECT_CHILD",
+				statePath,
+				readState: (path) => this.readConnectorState(path),
+				isRunning: (state) => isProcessRunning(state.pid),
+				formatAlreadyRunningMessage: (state) =>
+					`[discord] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
+				formatBackgroundStartMessage: (pid) =>
+					`[discord] starting background connector pid=${pid} application=${options.applicationId}`,
+				foregroundHint:
+					"[discord] use `cline connect discord -i ...` to run in the foreground",
+				launchFailureMessage:
+					"failed to launch Discord connector in background",
+			})
+		) {
+			return 0;
+		}
+
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "discord-connect",
+		});
+		const logger = createChatSdkLogger(loggerAdapter);
+		const consoleLogger = new ConsoleLogger("info", "discord-connect");
+		const discord = createDiscordAdapter({
+			userName: options.userName,
+			applicationId: options.applicationId,
+			botToken: options.botToken,
+			publicKey: options.publicKey,
+			mentionRoleIds: options.mentionRoleIds,
+			logger: consoleLogger,
+		}) as DiscordAdapter;
+		const bot = new Chat({
+			userName: options.userName,
+			adapters: { discord },
+			state: new InMemoryStateAdapter(),
+			logger,
+			fallbackStreamingPlaceholderText: null,
+			streamingUpdateIntervalMs: 500,
+		}).registerSingleton();
+		const threadQueues = new Map<string, Promise<void>>();
+		const activeTurns = new Map<string, ActiveConnectorTurn>();
+		const pendingApprovals = new Map<string, PendingConnectorApproval>();
+		const startRequest = await buildDiscordStartRequest(options, io, {
+			enabled: loggerAdapter.runtimeConfig.enabled,
+			level: loggerAdapter.runtimeConfig.level,
+			destination: loggerAdapter.runtimeConfig.destination,
+			bindings: {
+				transport: "discord",
+				applicationId: options.applicationId,
+				userName: options.userName,
+			},
+		});
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { workspacePath: startRequest.cwd },
+			rules: { workspacePath: startRequest.cwd },
+			workflows: { workspacePath: startRequest.cwd },
+		});
+		await userInstructionService.start().catch(() => undefined);
+		const commandCwd = startRequest.cwd || process.cwd();
+		const { host: chatCommandHost } = await createWorkspaceChatCommandHost({
+			cwd: commandCwd,
+			workspaceRoot: startRequest.workspaceRoot || commandCwd,
+		});
+		const { url: rpcAddress, authToken: rpcAuthToken } =
+			await ensureCliHubServer(
+				startRequest.workspaceRoot || startRequest.cwd || process.cwd(),
+				parseHubEndpointOverride(options.rpcAddress),
+			);
+
+		const clientId = `discord-${process.pid}-${Date.now()}`;
+		const client = new HubSessionClient({
+			address: rpcAddress,
+			authToken: rpcAuthToken,
+			clientId,
+			clientType: "cli",
+			displayName: "discord connector",
+			workspaceRoot: startRequest.workspaceRoot || startRequest.cwd,
+			cwd: startRequest.cwd,
+			metadata: {
+				transport: "discord",
+				applicationId: options.applicationId,
+				userName: options.userName,
+			},
+		});
+		await client.connect();
+		this.writeConnectorState(statePath, {
+			userName: options.userName,
+			applicationId: options.applicationId,
+			pid: process.pid,
+			rpcAddress,
+			port: options.port,
+			baseUrl: options.baseUrl,
+			startedAt: new Date().toISOString(),
+		});
+
+		let stopping = false;
+		let resolveStop: (() => void) | undefined;
+		const stopPromise = new Promise<void>((resolve) => {
+			resolveStop = resolve;
+		});
+		const requestStop = (_reason: string) => {
+			if (stopping) {
+				return;
+			}
+			stopping = true;
+			resolveStop?.();
+		};
+
+		type ErrorTrackerEntry = {
+			count: number;
+			firstSeen: number;
+			lastSeen: number;
+		};
+		const errorTracker = new Map<string, ErrorTrackerEntry>();
+		const MAX_REPEATED_ERRORS = 3;
+		const ERROR_WINDOW_MS = 60_000; // 1 minute
+
+		const handleTurn = async (
+			thread: Thread<DiscordThreadState>,
+			text: string,
+			context?: {
+				participant?: DiscordParticipant;
+				isDirectMention?: boolean;
+				isSubscribedThreadMessage?: boolean;
+			},
+		) => {
+			const queueKey = thread.id;
+			const runTurn = async () => {
+				try {
+					await handleConnectorUserTurn({
+						thread,
+						text,
+						runtimeText: formatDiscordRuntimeText(text, context?.participant, {
+							ownerUserId: options.ownerUserId,
+							isDirectMention: context?.isDirectMention,
+							isSubscribedThreadMessage: context?.isSubscribedThreadMessage,
+						}),
+						client,
+						pendingApprovals,
+						baseStartRequest: startRequest,
+						explicitSystemPrompt:
+							options.systemPrompt?.trim() ||
+							getConnectorSystemPrompt("discord"),
+						clientId,
+						logger: loggerAdapter,
+						transport: "discord",
+						botUserName: options.userName,
+						ownerParticipantKeys: options.ownerUserId
+							? [`discord:user:${options.ownerUserId}`]
+							: undefined,
+						requestStop,
+						bindingsPath,
+						hookCommand: options.hookCommand,
+						systemRules: DISCORD_SYSTEM_RULES,
+						errorLabel: "Discord",
+						firstContactMessage: DISCORD_FIRST_CONTACT_MESSAGE,
+						userInstructionService,
+						chatCommandHost,
+						activeTurns,
+						turnKey: queueKey,
+						resolveMuteTarget: ({ target }) => resolveDiscordMuteTarget(target),
+						createEmptyRuntimeReplyResolver:
+							createDiscordEmptyRuntimeReplyResolver,
+						getSessionMetadata: (currentThread, _clientId, currentState) => ({
+							userName: options.userName,
+							applicationId: options.applicationId,
+							...(options.ownerUserId
+								? { discordOwnerUserId: options.ownerUserId }
+								: {}),
+							discordThreadId: currentThread.id,
+							discordChannelId: currentThread.channelId,
+							...(currentState.participantKey
+								? { discordParticipantKey: currentState.participantKey }
+								: {}),
+							...(currentState.participantLabel
+								? { discordParticipantLabel: currentState.participantLabel }
+								: {}),
+						}),
+						reusedLogMessage: "Discord thread reusing RPC session",
+						startedLogMessage: "Discord thread started RPC session",
+						postFinalReply: async ({
+							thread: replyThread,
+							text: replyText,
+						}) => {
+							await postDiscordResolvedText({
+								botToken: options.botToken,
+								thread: replyThread,
+								text: replyText,
+							});
+						},
+						onMessageReceived: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "discord",
+									botUserName: options.userName,
+									event: "message.received",
+									payload: details,
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyCompleted: async (result) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "discord",
+									botUserName: options.userName,
+									event: "message.completed",
+									payload: {
+										threadId: result.threadId,
+										sessionId: result.sessionId,
+										finishReason: result.finishReason,
+										iterations: result.iterations,
+										outputPreview: truncateText(result.text),
+										outputLength: result.text.length,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyFailed: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "discord",
+									botUserName: options.userName,
+									event: "message.failed",
+									payload: {
+										threadId: details.threadId,
+										sessionId: details.sessionId,
+										error: details.error.message,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+					});
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+
+					// Track repeated errors per-thread with fixed time window
+					const now = Date.now();
+					const errorKey = `${thread.id}:${message.slice(0, 200)}`; // Per-thread error tracking
+					const tracked = errorTracker.get(errorKey);
+
+					if (!tracked) {
+						// First occurrence, start tracking
+						errorTracker.set(errorKey, {
+							count: 1,
+							firstSeen: now,
+							lastSeen: now,
+						});
+						await thread.post(`Discord bridge error: ${message}`);
+					} else if (now - tracked.firstSeen > ERROR_WINDOW_MS) {
+						// Outside fixed window, reset counter
+						errorTracker.set(errorKey, {
+							count: 1,
+							firstSeen: now,
+							lastSeen: now,
+						});
+						await thread.post(`Discord bridge error: ${message}`);
+					} else {
+						// Within fixed window, increment counter
+						tracked.count++;
+						tracked.lastSeen = now;
+
+						if (tracked.count >= MAX_REPEATED_ERRORS) {
+							// Too many repeated errors in this thread, kill the connector
+							loggerAdapter.core.error?.(
+								"Discord connector stopping due to repeated errors",
+								{
+									transport: "discord",
+									threadId: thread.id,
+									errorMessage: message,
+									count: tracked.count,
+									windowMs: now - tracked.firstSeen,
+								},
+							);
+							await thread.post(
+								`Discord bridge error (repeated ${tracked.count} times in ${Math.round((now - tracked.firstSeen) / 1000)}s): ${message}\n\nConnector shutting down due to repeated errors.`,
+							);
+							requestStop("repeated_discord_errors");
+						} else {
+							// Still within threshold, post error
+							await thread.post(`Discord bridge error: ${message}`);
+						}
+					}
+				}
+			};
+			if (activeTurns.has(queueKey)) {
+				await runTurn();
+				return;
+			}
+			await enqueueThreadTurn(threadQueues, queueKey, async () => {
+				await runTurn();
+			});
+		};
+
+		bot.onNewMention(async (thread, message) => {
+			loggerAdapter.core.log("Discord mention handler invoked", {
+				transport: "discord",
+				threadId: thread.id,
+				channelId: thread.channelId,
+				authorId: message.author.userId,
+				authorName: message.author.userName,
+				authorIsBot: message.author.isBot,
+				isMention: message.isMention,
+				textPreview: truncateText(message.text),
+			});
+			await thread.subscribe();
+			const participant = await persistDiscordThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				message,
+				errorLabel: "Discord",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Discord user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text, {
+				participant,
+				isDirectMention: message.isMention,
+				isSubscribedThreadMessage: false,
+			});
+		});
+
+		bot.onSubscribedMessage(async (thread, message) => {
+			loggerAdapter.core.log("Discord subscribed message handler invoked", {
+				transport: "discord",
+				threadId: thread.id,
+				channelId: thread.channelId,
+				authorId: message.author.userId,
+				authorName: message.author.userName,
+				authorIsBot: message.author.isBot,
+				isMention: message.isMention,
+				textPreview: truncateText(message.text),
+			});
+			const participant = await persistDiscordThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				message,
+				errorLabel: "Discord",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Discord user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text, {
+				participant,
+				isDirectMention: message.isMention,
+				isSubscribedThreadMessage: true,
+			});
+		});
+
+		bot.onSlashCommand(async (event) => {
+			const commandText = [event.command.trim(), event.text.trim()]
+				.filter(Boolean)
+				.join(" ");
+			const displayName =
+				event.user.fullName || event.user.userName || event.user.userId;
+			const rootMessage = await event.channel.post(
+				`${displayName} invoked ${commandText}`,
+			);
+			const thread = new ThreadImpl<DiscordThreadState>({
+				adapterName: "discord",
+				channelId: event.channel.id,
+				id: rootMessage.threadId,
+				isDM: event.channel.isDM,
+				isSubscribedContext: true,
+			});
+			await thread.subscribe();
+			const participant = await persistDiscordThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				message: {
+					raw: event.raw,
+					author: event.user,
+				},
+				errorLabel: "Discord",
+			});
+			await handleTurn(thread, commandText, {
+				participant,
+				isDirectMention: true,
+				isSubscribedThreadMessage: false,
+			});
+		});
+
+		await bot.initialize();
+		const restoredSubscriptionCount = await restoreDiscordThreadSubscriptions({
+			bot,
+			bindingsPath,
+			logger: loggerAdapter,
+		});
+		const stopTaskUpdateStream =
+			startConnectorTaskUpdateRelay<DiscordThreadState>({
+				client,
+				clientId,
+				bot,
+				logger: loggerAdapter,
+				bindingsPath,
+				transport: "discord",
+			});
+
+		const webhookUrl = `${options.baseUrl.replace(/\/$/, "")}/api/webhooks/discord`;
+		const server = await startConnectorWebhookServer({
+			host: options.host,
+			port: options.port,
+			routes: {
+				"/api/webhooks/discord": async (request) => {
+					const normalizedRequest =
+						await normalizeDiscordForwardedGatewayRequest({
+							request,
+							botToken: options.botToken,
+							applicationId: options.applicationId,
+						});
+					await logDiscordForwardedGatewayMessage({
+						request: normalizedRequest,
+						logger: consoleLogger,
+						applicationId: options.applicationId,
+					});
+					return discord.handleWebhook(normalizedRequest);
+				},
+				"/health": () => new Response("ok"),
+				"/": () =>
+					new Response(
+						[
+							"Discord connector is running.",
+							`Interactions endpoint: ${webhookUrl}`,
+							`Gateway mode: ${options.allowBotAuthors ? "forwarded WebSocket listener" : "direct WebSocket listener"}`,
+						].join("\n"),
+					),
+			},
+		});
+
+		let gatewayTask: Promise<unknown> | undefined;
+		const gatewayAbortController = new AbortController();
+		const gatewayStartResponse = await discord.startGatewayListener(
+			{
+				waitUntil: (task) => {
+					gatewayTask = Promise.resolve(task).catch((error) => {
+						loggerAdapter.core.error?.("Discord gateway listener failed", {
+							transport: "discord",
+							error: error instanceof Error ? error.message : String(error),
+						});
+						requestStop("discord_gateway_failed");
+					});
+				},
+			},
+			DISCORD_GATEWAY_DURATION_MS,
+			gatewayAbortController.signal,
+			options.allowBotAuthors ? webhookUrl : undefined,
+		);
+		if (!gatewayStartResponse.ok) {
+			await server.close();
+			stopTaskUpdateStream();
+			userInstructionService.stop();
+			client.close();
+			this.removeStateFile(statePath);
+			io.writeErr(
+				`failed to start Discord gateway listener: ${await gatewayStartResponse.text()}`,
+			);
+			return 1;
+		}
+
+		const stopEventStream = client.streamEvents(
+			{ clientId: `${clientId}-server-events` },
+			{
+				onEvent: (event) => {
+					if (event.eventType === "rpc.server.shutting_down") {
+						requestStop("rpc_server_shutting_down");
+						return;
+					}
+					if (
+						event.eventType !== "schedule.execution.completed" &&
+						event.eventType !== "schedule.execution.failed"
+					) {
+						return;
+					}
+					const scheduleId =
+						typeof event.payload.scheduleId === "string"
+							? event.payload.scheduleId.trim()
+							: "";
+					const sessionId =
+						typeof event.payload.sessionId === "string"
+							? event.payload.sessionId.trim()
+							: undefined;
+					const status =
+						typeof event.payload.status === "string"
+							? event.payload.status.trim()
+							: "";
+					const errorMessage =
+						typeof event.payload.errorMessage === "string"
+							? event.payload.errorMessage
+							: undefined;
+					if (!scheduleId || !status) {
+						return;
+					}
+					void deliverScheduledResult({
+						bot,
+						client,
+						bindingsPath,
+						userName: options.userName,
+						scheduleId,
+						sessionId,
+						status,
+						errorMessage,
+					});
+				},
+				onError: () => {
+					requestStop("rpc_server_event_stream_failed");
+				},
+			},
+		);
+
+		process.once("SIGINT", () => requestStop("sigint"));
+		process.once("SIGTERM", () => requestStop("sigterm"));
+
+		io.writeln(`[discord] listening on ${options.host}:${options.port}`);
+		io.writeln(
+			`[discord] configure Discord interactions endpoint: ${webhookUrl}`,
+		);
+		io.writeln(
+			`[discord] gateway listener started for mentions, replies, reactions, and DMs${options.allowBotAuthors ? " (bot authors allowed)" : ""}`,
+		);
+		if (restoredSubscriptionCount > 0) {
+			io.writeln(
+				`[discord] restored ${restoredSubscriptionCount} thread subscription${restoredSubscriptionCount === 1 ? "" : "s"}`,
+			);
+		}
+
+		await stopPromise;
+		clearBindingSessionIds<DiscordThreadState>(bindingsPath);
+		gatewayAbortController.abort();
+		stopTaskUpdateStream();
+		stopEventStream();
+		await gatewayTask?.catch(() => undefined);
+		await server.close();
+		userInstructionService.stop();
+		client.close();
+		this.removeStateFile(statePath);
+		return 0;
+	}
+}
+
+export const discordConnector: ConnectCommandDefinition =
+	new DiscordConnector();
+
+export const __test__ = {
+	DISCORD_SYSTEM_RULES,
+	createDiscordEmptyRuntimeReplyResolver,
+	formatDiscordRuntimeText,
+	resolveDiscordMuteTarget,
+	findBindingForThread: (
+		bindings: ConnectorBindingStore<DiscordThreadState>,
+		thread: Pick<Thread<DiscordThreadState>, "id" | "channelId" | "isDM"> & {
+			participantKey?: string;
+		},
+	) => findBindingForThread(bindings, thread),
+	persistDiscordThreadContext,
+	normalizeDiscordForwardedGatewayRequest,
+	resolveDiscordOutboundMentions,
+	resolveDiscordParticipant,
+	restoreDiscordThreadSubscriptions,
+};
diff --git a/apps/cli/src/connectors/adapters/gchat.test.ts b/apps/cli/src/connectors/adapters/gchat.test.ts
new file mode 100644
index 0000000..6e90710
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/gchat.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { __test__ } from "./gchat";
+
+describe("gchat binding lookup", () => {
+	it("does not fall back to channel identity for a different space thread id", () => {
+		const result = __test__.findBindingForThread(
+			{
+				legacy_thread_id: {
+					channelId: "space-123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1", cwd: "/tmp/work" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "new_thread_id",
+				channelId: "space-123",
+				isDM: false,
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+
+	it("prefers an exact thread id match over a channel fallback", () => {
+		const result = __test__.findBindingForThread(
+			{
+				current_thread_id: {
+					channelId: "space-123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-2",
+					state: { sessionId: "sess-2" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+				legacy_thread_id: {
+					channelId: "space-123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "current_thread_id",
+				channelId: "space-123",
+				isDM: false,
+			},
+		);
+
+		expect(result?.key).toBe("current_thread_id");
+		expect(result?.binding.sessionId).toBe("sess-2");
+	});
+
+	it("does not reuse a binding by participant key across different spaces", () => {
+		const result = __test__.findBindingForThread(
+			{
+				"gchat:email:alice@example.com": {
+					channelId: "space-123",
+					isDM: false,
+					participantKey: "gchat:email:alice@example.com",
+					participantLabel: "alice@example.com",
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: {
+						sessionId: "sess-1",
+						participantKey: "gchat:email:alice@example.com",
+						participantLabel: "alice@example.com",
+					},
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "other_thread_id",
+				channelId: "space-999",
+				isDM: false,
+				participantKey: "gchat:email:alice@example.com",
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/gchat.ts b/apps/cli/src/connectors/adapters/gchat.ts
new file mode 100644
index 0000000..258c70f
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/gchat.ts
@@ -0,0 +1,841 @@
+import { createGoogleChatAdapter } from "@chat-adapter/gchat";
+import type { ChatStartSessionRequest } from "@cline/core";
+import {
+	createUserInstructionConfigService,
+	HubSessionClient,
+} from "@cline/core";
+import type {
+	ConnectGoogleChatOptions,
+	GoogleChatConnectorState,
+} from "@cline/shared";
+import { Chat, ConsoleLogger, type Thread } from "chat";
+import type { Command } from "commander";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import { createCliLoggerAdapter } from "../../logging/adapter";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+	resolveDefaultCliRpcAddress,
+} from "../../utils/hub-runtime";
+import { createWorkspaceChatCommandHost } from "../../utils/plugin-chat-commands";
+import { ConnectorBase } from "../base";
+import {
+	createChatSdkLogger,
+	enqueueThreadTurn,
+	startConnectorWebhookServer,
+} from "../chat-runtime";
+import { isProcessRunning } from "../common";
+import {
+	type ActiveConnectorTurn,
+	handleConnectorUserTurn,
+	maybeHandleConnectorApprovalReply,
+} from "../connector-host";
+import { dispatchConnectorHook } from "../hooks";
+import {
+	type PendingConnectorApproval,
+	truncateConnectorText,
+} from "../runtime-turn";
+import {
+	buildConnectorStartRequest,
+	readSessionReplyText,
+	stopConnectorSessions,
+} from "../session-runtime";
+import { InMemoryStateAdapter } from "../stores/memory-state";
+import { startConnectorTaskUpdateRelay } from "../task-updates";
+import {
+	type ConnectorBindingStore,
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	findBindingForThread,
+	loadThreadState,
+	persistMergedThreadState,
+	readBindings,
+} from "../thread-bindings";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "../types";
+import {
+	getConnectorFirstContactMessage,
+	getConnectorSystemRules,
+} from "./prompts";
+
+const GCHAT_SYSTEM_RULES = getConnectorSystemRules("Google Chat");
+
+const GCHAT_FIRST_CONTACT_MESSAGE = getConnectorFirstContactMessage();
+
+type GoogleChatThreadState = ConnectorThreadState;
+
+function truncateText(value: string, maxLength = 160): string {
+	return truncateConnectorText(value, maxLength);
+}
+
+async function stopSessionsForUser(
+	state: GoogleChatConnectorState,
+): Promise<number> {
+	return stopConnectorSessions({
+		rpcAddress: state.rpcAddress,
+		rpcMatcher: (metadata) =>
+			metadata?.transport === "gchat" && metadata?.userName === state.userName,
+		localMatcher: (metadata) =>
+			metadata?.transport === "gchat" && metadata?.userName === state.userName,
+	});
+}
+
+async function buildGoogleChatStartRequest(
+	options: ConnectGoogleChatOptions,
+	io: ConnectIo,
+	loggerConfig: Parameters<
+		typeof buildConnectorStartRequest
+	>[0]["loggerConfig"],
+): Promise<ChatStartSessionRequest> {
+	return buildConnectorStartRequest({
+		options,
+		io,
+		loggerConfig,
+		systemRules: GCHAT_SYSTEM_RULES,
+	});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function readString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function resolveGoogleChatParticipant(
+	rawMessage: unknown,
+): { key: string; label?: string } | undefined {
+	const raw = asRecord(rawMessage);
+	const message = asRecord(raw?.message) ?? raw;
+	const sender = asRecord(message?.sender);
+	const email = readString(sender?.email);
+	const name = readString(sender?.name);
+	const displayName =
+		readString(sender?.displayName) || readString(sender?.display_name);
+	const label = displayName || email || name;
+	if (email) {
+		return { key: `gchat:email:${email.toLowerCase()}`, label };
+	}
+	if (name) {
+		return { key: `gchat:sender:${name}`, label };
+	}
+	return undefined;
+}
+
+async function persistGoogleChatThreadContext(input: {
+	thread: Thread<GoogleChatThreadState>;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	rawMessage: unknown;
+	errorLabel: string;
+}): Promise<void> {
+	const participant = resolveGoogleChatParticipant(input.rawMessage);
+	if (!participant) {
+		return;
+	}
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	if (
+		currentState.participantKey === participant.key &&
+		currentState.participantLabel === participant.label
+	) {
+		return;
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...currentState,
+			participantKey: participant.key,
+			participantLabel: participant.label,
+		},
+		input.errorLabel,
+	);
+}
+
+async function deliverScheduledResult(input: {
+	bot: Chat;
+	client: HubSessionClient;
+	logger: CliLoggerAdapter;
+	bindingsPath: string;
+	userName: string;
+	scheduleId: string;
+	executionId: string;
+	sessionId?: string;
+	status: string;
+	errorMessage?: string;
+	hookCommand?: string;
+}): Promise<void> {
+	const schedule = await input.client.getSchedule(input.scheduleId);
+	const delivery = schedule?.metadata?.delivery as
+		| Record<string, unknown>
+		| undefined;
+	if (!delivery || delivery.adapter !== "gchat") {
+		return;
+	}
+	const targetUser =
+		typeof delivery.userName === "string" ? delivery.userName.trim() : "";
+	if (targetUser && targetUser !== input.userName) {
+		return;
+	}
+	const threadId =
+		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
+	const bindingKey =
+		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
+	const participantKey =
+		typeof delivery.participantKey === "string"
+			? delivery.participantKey.trim()
+			: "";
+	if (!threadId && !bindingKey && !participantKey) {
+		return;
+	}
+	const bindings = readBindings<GoogleChatThreadState>(input.bindingsPath);
+	const match = findBindingForDeliveryTarget(bindings, {
+		bindingKey,
+		threadId,
+		participantKey,
+	});
+	const binding = match?.binding;
+	if (!binding?.serializedThread) {
+		return;
+	}
+	const thread = JSON.parse(
+		binding.serializedThread,
+		input.bot.reviver(),
+	) as Thread<GoogleChatThreadState>;
+	let body = "";
+	if (input.status === "success" && input.sessionId) {
+		const text = await readSessionReplyText(input.client, input.sessionId);
+		body = text?.trim()
+			? text
+			: `Schedule "${schedule?.name ?? input.scheduleId}" completed, but no assistant reply text was found.`;
+	} else {
+		body = `Schedule "${schedule?.name ?? input.scheduleId}" ${input.status}.${input.errorMessage ? `\n\n${input.errorMessage}` : ""}`;
+	}
+	await thread.post(body);
+}
+
+class GoogleChatConnector extends ConnectorBase<
+	ConnectGoogleChatOptions,
+	GoogleChatConnectorState
+> {
+	constructor() {
+		super("gchat", "Google Chat webhook bridge backed by RPC runtime sessions");
+	}
+
+	protected override createCommand(): Command {
+		return super
+			.createCommand()
+			.usage("--base-url <PUBLIC_BASE_URL> [options]")
+			.option("--user-name <name>", "Google Chat bot username label")
+			.option("--provider <id>", "Provider override")
+			.option("--model <id>", "Model override")
+			.option("--api-key <key>", "Provider API key override")
+			.option("--system <prompt>", "System prompt override")
+			.option("--cwd <path>", "Workspace / cwd for runtime")
+			.option("--mode <act|plan>", "Agent mode", "act")
+			.option("-i, --interactive", "Keep connector in foreground")
+			.option("--enable-tools", "Enable tools for Google Chat sessions")
+			.option(
+				"--hook-command <command>",
+				"Run a shell command for connector events",
+			)
+			.option(
+				"--rpc-address <host:port>",
+				"RPC address",
+				process.env.CLINE_RPC_ADDRESS?.trim() || resolveDefaultCliRpcAddress(),
+			)
+			.option("--host <host>", "Webhook listen host")
+			.option("--port <port>", "Webhook listen port")
+			.option("--base-url <url>", "Public base URL for webhook configuration")
+			.option(
+				"--pubsub-topic <topic>",
+				"Optional Pub/Sub topic for all-message events",
+			)
+			.option("--impersonate-user <email>", "Optional delegation user email")
+			.option("--use-adc", "Use Google Application Default Credentials")
+			.option("--credentials-json <json>", "Service account credentials JSON")
+			.addHelpText(
+				"after",
+				[
+					"",
+					"Environment:",
+					"  GOOGLE_CHAT_CREDENTIALS      Service account JSON",
+					"  GOOGLE_CHAT_USE_ADC=true     Use Application Default Credentials",
+					"  GOOGLE_CHAT_PUBSUB_TOPIC     Optional Pub/Sub topic",
+					"  GOOGLE_CHAT_IMPERSONATE_USER Optional delegation user",
+				].join("\n"),
+			);
+	}
+
+	protected override readOptions(command: Command): ConnectGoogleChatOptions {
+		const opts = command.opts<{
+			userName?: string;
+			cwd?: string;
+			model?: string;
+			provider?: string;
+			apiKey?: string;
+			system?: string;
+			mode?: string;
+			interactive?: boolean;
+			enableTools?: boolean;
+			rpcAddress?: string;
+			hookCommand?: string;
+			port?: string;
+			host?: string;
+			baseUrl?: string;
+			pubsubTopic?: string;
+			impersonateUser?: string;
+			useAdc?: boolean;
+			credentialsJson?: string;
+		}>();
+		const parsedPort =
+			this.parseOptionalInteger(opts.port, "port") ??
+			Number.parseInt(process.env.PORT ?? "8787", 10);
+		const port = Number.isFinite(parsedPort) ? parsedPort : 8787;
+		return {
+			userName:
+				opts.userName?.trim() ||
+				process.env.GOOGLE_CHAT_BOT_USERNAME?.trim() ||
+				"cline-gchat",
+			cwd: opts.cwd || process.cwd(),
+			model: opts.model,
+			provider: opts.provider,
+			apiKey: opts.apiKey,
+			systemPrompt: opts.system,
+			mode: this.parseMode(opts.mode),
+			interactive: Boolean(opts.interactive),
+			enableTools: Boolean(opts.enableTools),
+			rpcAddress:
+				opts.rpcAddress?.trim() ||
+				process.env.CLINE_RPC_ADDRESS?.trim() ||
+				resolveDefaultCliRpcAddress(),
+			hookCommand:
+				opts.hookCommand?.trim() ||
+				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
+			port,
+			host: opts.host?.trim() || process.env.HOST?.trim() || "0.0.0.0",
+			baseUrl:
+				opts.baseUrl?.trim() ||
+				process.env.BASE_URL?.trim() ||
+				`http://127.0.0.1:${port}`,
+			pubsubTopic:
+				opts.pubsubTopic?.trim() ||
+				process.env.GOOGLE_CHAT_PUBSUB_TOPIC?.trim(),
+			impersonateUser:
+				opts.impersonateUser?.trim() ||
+				process.env.GOOGLE_CHAT_IMPERSONATE_USER?.trim(),
+			useApplicationDefaultCredentials:
+				Boolean(opts.useAdc) ||
+				process.env.GOOGLE_CHAT_USE_ADC?.trim().toLowerCase() === "true",
+			credentialsJson:
+				opts.credentialsJson?.trim() ||
+				process.env.GOOGLE_CHAT_CREDENTIALS?.trim(),
+		};
+	}
+
+	private resolveConnectorStatePath(userName: string): string {
+		return this.resolveConnectorPath(`${this.sanitizeKey(userName)}.json`);
+	}
+
+	private resolveBindingsPath(userName: string): string {
+		return this.resolveConnectorPath(
+			`${this.sanitizeKey(userName)}.threads.json`,
+		);
+	}
+
+	private listConnectorStatePaths(): string[] {
+		return this.listJsonStatePaths([".threads.json"]);
+	}
+
+	private readConnectorState(
+		statePath: string,
+	): GoogleChatConnectorState | undefined {
+		return this.readStateFile(
+			statePath,
+			(value): value is GoogleChatConnectorState =>
+				Boolean(
+					value &&
+						typeof value === "object" &&
+						typeof (value as GoogleChatConnectorState).pid === "number" &&
+						typeof (value as GoogleChatConnectorState).userName === "string",
+				),
+		);
+	}
+
+	private writeConnectorState(
+		statePath: string,
+		state: GoogleChatConnectorState,
+	): void {
+		this.writeStateFile(statePath, state);
+	}
+
+	private async stopGoogleChatConnectorInstance(
+		statePath: string,
+		io: ConnectIo,
+	): Promise<ConnectStopResult> {
+		return this.stopManagedProcess({
+			io,
+			statePath,
+			readState: (path) => this.readConnectorState(path),
+			describeStoppedProcess: (state) =>
+				`[gchat] stopped pid=${state.pid} user=${state.userName}`,
+			getPid: (state) => state.pid,
+			stopSessions: stopSessionsForUser,
+			clearBindings: (state) => {
+				clearBindingSessionIds<GoogleChatThreadState>(
+					this.resolveBindingsPath(state.userName),
+				);
+			},
+		});
+	}
+
+	override async stopAll(io: ConnectIo): Promise<ConnectStopResult> {
+		return this.stopAllFromStatePaths(
+			io,
+			this.listConnectorStatePaths(),
+			(statePath, stopIo) =>
+				this.stopGoogleChatConnectorInstance(statePath, stopIo),
+		);
+	}
+
+	protected override async runWithOptions(
+		options: ConnectGoogleChatOptions,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number> {
+		const statePath = this.resolveConnectorStatePath(options.userName);
+		const bindingsPath = this.resolveBindingsPath(options.userName);
+		const staleState = this.removeStaleState(
+			statePath,
+			(path) => this.readConnectorState(path),
+			(state) => state.pid,
+		);
+		if (staleState) {
+			clearBindingSessionIds<GoogleChatThreadState>(bindingsPath);
+		}
+		if (
+			await this.maybeRunInBackground({
+				rawArgs,
+				io,
+				interactive: options.interactive,
+				childEnvVar: "CLINE_GCHAT_CONNECT_CHILD",
+				statePath,
+				readState: (path) => this.readConnectorState(path),
+				isRunning: (state) => isProcessRunning(state.pid),
+				formatAlreadyRunningMessage: (state) =>
+					`[gchat] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
+				formatBackgroundStartMessage: (pid) =>
+					`[gchat] starting background connector pid=${pid} user=${options.userName}`,
+				foregroundHint:
+					"[gchat] use `cline connect gchat -i ...` to run in the foreground",
+				launchFailureMessage:
+					"failed to launch Google Chat connector in background",
+			})
+		) {
+			return 0;
+		}
+
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "gchat-connect",
+		});
+		const logger = createChatSdkLogger(loggerAdapter);
+		const consoleLogger = new ConsoleLogger("info", "gchat-connect");
+		let parsedCredentials:
+			| { client_email: string; private_key: string; project_id?: string }
+			| undefined;
+		if (options.credentialsJson) {
+			try {
+				const parsed = JSON.parse(options.credentialsJson) as Record<
+					string,
+					unknown
+				>;
+				if (
+					typeof parsed.client_email !== "string" ||
+					typeof parsed.private_key !== "string"
+				) {
+					throw new Error(
+						"credentials JSON must include string client_email and private_key fields",
+					);
+				}
+				parsedCredentials = {
+					client_email: parsed.client_email,
+					private_key: parsed.private_key,
+					project_id:
+						typeof parsed.project_id === "string"
+							? parsed.project_id
+							: undefined,
+				};
+			} catch (error) {
+				io.writeErr(
+					`invalid GOOGLE_CHAT_CREDENTIALS JSON: ${error instanceof Error ? error.message : String(error)}`,
+				);
+				return 1;
+			}
+		}
+		const endpointUrl = `${options.baseUrl.replace(/\/$/, "")}/api/webhooks/gchat`;
+		const gchat = createGoogleChatAdapter(
+			parsedCredentials
+				? {
+						credentials: parsedCredentials,
+						endpointUrl,
+						pubsubTopic: options.pubsubTopic,
+						impersonateUser: options.impersonateUser,
+						logger: consoleLogger,
+						userName: options.userName,
+					}
+				: options.useApplicationDefaultCredentials
+					? {
+							useApplicationDefaultCredentials: true as const,
+							endpointUrl,
+							pubsubTopic: options.pubsubTopic,
+							impersonateUser: options.impersonateUser,
+							logger: consoleLogger,
+							userName: options.userName,
+						}
+					: {
+							endpointUrl,
+							pubsubTopic: options.pubsubTopic,
+							impersonateUser: options.impersonateUser,
+							logger: consoleLogger,
+							userName: options.userName,
+						},
+		);
+		const bot = new Chat({
+			userName: options.userName,
+			adapters: { gchat },
+			state: new InMemoryStateAdapter(),
+			logger,
+			fallbackStreamingPlaceholderText: null,
+			streamingUpdateIntervalMs: 500,
+		}).registerSingleton();
+		const threadQueues = new Map<string, Promise<void>>();
+		const activeTurns = new Map<string, ActiveConnectorTurn>();
+		const pendingApprovals = new Map<string, PendingConnectorApproval>();
+		const startRequest = await buildGoogleChatStartRequest(options, io, {
+			enabled: loggerAdapter.runtimeConfig.enabled,
+			level: loggerAdapter.runtimeConfig.level,
+			destination: loggerAdapter.runtimeConfig.destination,
+			bindings: {
+				transport: "gchat",
+				userName: options.userName,
+			},
+		});
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { workspacePath: startRequest.cwd },
+			rules: { workspacePath: startRequest.cwd },
+			workflows: { workspacePath: startRequest.cwd },
+		});
+		await userInstructionService.start().catch(() => undefined);
+		const commandCwd = startRequest.cwd || process.cwd();
+		const { host: chatCommandHost } = await createWorkspaceChatCommandHost({
+			cwd: commandCwd,
+			workspaceRoot: startRequest.workspaceRoot || commandCwd,
+		});
+		const { url: rpcAddress, authToken: rpcAuthToken } =
+			await ensureCliHubServer(
+				startRequest.workspaceRoot || startRequest.cwd || process.cwd(),
+				parseHubEndpointOverride(options.rpcAddress),
+			);
+
+		const clientId = `gchat-${process.pid}-${Date.now()}`;
+		const client = new HubSessionClient({
+			address: rpcAddress,
+			authToken: rpcAuthToken,
+			clientId,
+			clientType: "cli",
+			displayName: "gchat connector",
+			workspaceRoot: startRequest.workspaceRoot || startRequest.cwd,
+			cwd: startRequest.cwd,
+			metadata: {
+				transport: "gchat",
+				userName: options.userName,
+			},
+		});
+		await client.connect();
+		this.writeConnectorState(statePath, {
+			userName: options.userName,
+			pid: process.pid,
+			rpcAddress,
+			port: options.port,
+			baseUrl: options.baseUrl,
+			startedAt: new Date().toISOString(),
+		});
+
+		let stopping = false;
+		let resolveStop: (() => void) | undefined;
+		const stopPromise = new Promise<void>((resolve) => {
+			resolveStop = resolve;
+		});
+		const requestStop = (_reason: string) => {
+			if (stopping) {
+				return;
+			}
+			stopping = true;
+			resolveStop?.();
+		};
+
+		const handleTurn = async (
+			thread: Thread<GoogleChatThreadState>,
+			text: string,
+		) => {
+			const queueKey = thread.id;
+			const runTurn = async () => {
+				try {
+					await handleConnectorUserTurn({
+						thread,
+						text,
+						client,
+						pendingApprovals,
+						baseStartRequest: startRequest,
+						explicitSystemPrompt: options.systemPrompt?.trim() || undefined,
+						clientId,
+						logger: loggerAdapter,
+						transport: "gchat",
+						botUserName: options.userName,
+						requestStop,
+						bindingsPath,
+						hookCommand: options.hookCommand,
+						systemRules: GCHAT_SYSTEM_RULES,
+						errorLabel: "Google Chat",
+						firstContactMessage: GCHAT_FIRST_CONTACT_MESSAGE,
+						userInstructionService,
+						chatCommandHost,
+						activeTurns,
+						turnKey: queueKey,
+						getSessionMetadata: (currentThread, _clientId, currentState) => ({
+							userName: options.userName,
+							gchatThreadId: currentThread.id,
+							gchatChannelId: currentThread.channelId,
+							...(currentState.participantKey
+								? { gchatParticipantKey: currentState.participantKey }
+								: {}),
+							...(currentState.participantLabel
+								? { gchatParticipantLabel: currentState.participantLabel }
+								: {}),
+						}),
+						reusedLogMessage: "Google Chat thread reusing RPC session",
+						onReplyCompleted: async (result) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "gchat",
+									botUserName: options.userName,
+									event: "message.completed",
+									payload: {
+										threadId: result.threadId,
+										sessionId: result.sessionId,
+										finishReason: result.finishReason,
+										iterations: result.iterations,
+										outputPreview: truncateText(result.text),
+										outputLength: result.text.length,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyFailed: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "gchat",
+									botUserName: options.userName,
+									event: "message.failed",
+									payload: {
+										threadId: details.threadId,
+										sessionId: details.sessionId,
+										error: details.error.message,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+					});
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					await thread.post(`Google Chat bridge error: ${message}`);
+				}
+			};
+			if (activeTurns.has(queueKey)) {
+				await runTurn();
+				return;
+			}
+			await enqueueThreadTurn(threadQueues, queueKey, async () => {
+				await runTurn();
+			});
+		};
+
+		bot.onNewMention(async (thread, message) => {
+			await thread.subscribe();
+			await persistGoogleChatThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Google Chat",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Google Chat user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		bot.onSubscribedMessage(async (thread, message) => {
+			await persistGoogleChatThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Google Chat",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Google Chat user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		await bot.initialize();
+		const stopTaskUpdateStream =
+			startConnectorTaskUpdateRelay<GoogleChatThreadState>({
+				client,
+				clientId,
+				bot,
+				logger: loggerAdapter,
+				bindingsPath,
+				transport: "gchat",
+			});
+
+		const server = await startConnectorWebhookServer({
+			host: options.host,
+			port: options.port,
+			routes: {
+				"/api/webhooks/gchat": async (request) => bot.webhooks.gchat(request),
+				"/health": () => new Response("ok"),
+				"/": () =>
+					new Response(
+						[
+							"Google Chat connector is running.",
+							`Webhook URL: ${endpointUrl}`,
+						].join("\n"),
+					),
+			},
+		});
+
+		const stopEventStream = client.streamEvents(
+			{ clientId: `${clientId}-server-events` },
+			{
+				onEvent: (event) => {
+					if (event.eventType === "rpc.server.shutting_down") {
+						requestStop("rpc_server_shutting_down");
+						return;
+					}
+					if (
+						event.eventType !== "schedule.execution.completed" &&
+						event.eventType !== "schedule.execution.failed"
+					) {
+						return;
+					}
+					const scheduleId =
+						typeof event.payload.scheduleId === "string"
+							? event.payload.scheduleId.trim()
+							: "";
+					const executionId =
+						typeof event.payload.executionId === "string"
+							? event.payload.executionId.trim()
+							: "";
+					const sessionId =
+						typeof event.payload.sessionId === "string"
+							? event.payload.sessionId.trim()
+							: undefined;
+					const status =
+						typeof event.payload.status === "string"
+							? event.payload.status.trim()
+							: "";
+					const errorMessage =
+						typeof event.payload.errorMessage === "string"
+							? event.payload.errorMessage
+							: undefined;
+					if (!scheduleId || !executionId || !status) {
+						return;
+					}
+					void deliverScheduledResult({
+						bot,
+						client,
+						logger: loggerAdapter,
+						bindingsPath,
+						userName: options.userName,
+						scheduleId,
+						executionId,
+						sessionId,
+						status,
+						errorMessage,
+						hookCommand: options.hookCommand,
+					});
+				},
+				onError: () => {
+					requestStop("rpc_server_event_stream_failed");
+				},
+			},
+		);
+
+		process.once("SIGINT", () => requestStop("sigint"));
+		process.once("SIGTERM", () => requestStop("sigterm"));
+
+		io.writeln(`[gchat] listening on ${options.host}:${options.port}`);
+		io.writeln(`[gchat] configure Google Chat App URL: ${endpointUrl}`);
+
+		await stopPromise;
+		clearBindingSessionIds<GoogleChatThreadState>(bindingsPath);
+		stopTaskUpdateStream();
+		stopEventStream();
+		await server.close();
+		userInstructionService.stop();
+		client.close();
+		this.removeStateFile(statePath);
+		return 0;
+	}
+}
+
+export const gchatConnector: ConnectCommandDefinition =
+	new GoogleChatConnector();
+
+export const __test__ = {
+	findBindingForThread: (
+		bindings: ConnectorBindingStore<GoogleChatThreadState>,
+		thread: Pick<Thread<GoogleChatThreadState>, "id" | "channelId" | "isDM"> & {
+			participantKey?: string;
+		},
+	) => findBindingForThread(bindings, thread),
+};
diff --git a/apps/cli/src/connectors/adapters/linear.test.ts b/apps/cli/src/connectors/adapters/linear.test.ts
new file mode 100644
index 0000000..e59113b
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/linear.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { __test__ } from "./linear";
+
+describe("linear binding lookup", () => {
+	it("does not fall back to channel identity for a different issue thread id", () => {
+		const result = __test__.findBindingForThread(
+			{
+				legacy_thread_id: {
+					channelId: "linear:issue:ISS-123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1", cwd: "/tmp/work" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "new_thread_id",
+				channelId: "linear:issue:ISS-123",
+				isDM: false,
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+
+	it("prefers an exact thread id match over a channel fallback", () => {
+		const result = __test__.findBindingForThread(
+			{
+				current_thread_id: {
+					channelId: "linear:issue:ISS-123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-2",
+					state: { sessionId: "sess-2" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+				legacy_thread_id: {
+					channelId: "linear:issue:ISS-123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "current_thread_id",
+				channelId: "linear:issue:ISS-123",
+				isDM: false,
+			},
+		);
+
+		expect(result?.key).toBe("current_thread_id");
+		expect(result?.binding.sessionId).toBe("sess-2");
+	});
+
+	it("does not reuse a binding by participant key across different issue threads", () => {
+		const result = __test__.findBindingForThread(
+			{
+				"linear:user:user_123": {
+					channelId: "linear:issue:ISS-123",
+					isDM: false,
+					participantKey: "linear:user:user_123",
+					participantLabel: "alice",
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: {
+						sessionId: "sess-1",
+						participantKey: "linear:user:user_123",
+						participantLabel: "alice",
+					},
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "other_thread_id",
+				channelId: "linear:issue:ISS-999",
+				isDM: false,
+				participantKey: "linear:user:user_123",
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/linear.ts b/apps/cli/src/connectors/adapters/linear.ts
new file mode 100644
index 0000000..1c2b666
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/linear.ts
@@ -0,0 +1,878 @@
+import type { ChatStartSessionRequest } from "@cline/core";
+import {
+	createUserInstructionConfigService,
+	HubSessionClient,
+} from "@cline/core";
+import type { ConnectLinearOptions, LinearConnectorState } from "@cline/shared";
+import { type Adapter, Chat, ConsoleLogger, type Thread } from "chat";
+import type { Command } from "commander";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import { createCliLoggerAdapter } from "../../logging/adapter";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+	resolveDefaultCliRpcAddress,
+} from "../../utils/hub-runtime";
+import { createWorkspaceChatCommandHost } from "../../utils/plugin-chat-commands";
+import { ConnectorBase } from "../base";
+import {
+	createChatSdkLogger,
+	enqueueThreadTurn,
+	startConnectorWebhookServer,
+} from "../chat-runtime";
+import { isProcessRunning } from "../common";
+import {
+	type ActiveConnectorTurn,
+	handleConnectorUserTurn,
+	maybeHandleConnectorApprovalReply,
+} from "../connector-host";
+import { dispatchConnectorHook } from "../hooks";
+import {
+	type PendingConnectorApproval,
+	truncateConnectorText,
+} from "../runtime-turn";
+import {
+	buildConnectorStartRequest,
+	readSessionReplyText,
+	stopConnectorSessions,
+} from "../session-runtime";
+import { InMemoryStateAdapter } from "../stores/memory-state";
+import { startConnectorTaskUpdateRelay } from "../task-updates";
+import {
+	type ConnectorBindingStore,
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	findBindingForThread,
+	loadThreadState,
+	persistMergedThreadState,
+	readBindings,
+} from "../thread-bindings";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "../types";
+import { getConnectorSystemPrompt } from "./prompts";
+
+const LINEAR_SYSTEM_RULES = [
+	"Keep answers compact and optimized for Linear issue comments unless the user asks for detail.",
+	"Prefer short paragraphs and concise lists suitable for issue threads.",
+	"When tools are disabled, explain limits briefly and ask the user to enable tools if required.",
+].join("\n");
+
+const LINEAR_FIRST_CONTACT_MESSAGE = [
+	"Connected.",
+	"Your chat history is isolated to this Linear identity.",
+	"Ask for /whereami if you need the delivery thread details.",
+].join("\n");
+
+type LinearThreadState = ConnectorThreadState;
+
+type LinearAdapterModule = {
+	createLinearAdapter: (config?: Record<string, unknown>) => unknown;
+};
+
+function truncateText(value: string, maxLength = 160): string {
+	return truncateConnectorText(value, maxLength);
+}
+
+async function importLinearAdapterModule(): Promise<LinearAdapterModule> {
+	const dynamicImport = Function("specifier", "return import(specifier);") as (
+		specifier: string,
+	) => Promise<unknown>;
+	const mod = (await dynamicImport(
+		"@chat-adapter/linear",
+	)) as Partial<LinearAdapterModule>;
+	if (typeof mod.createLinearAdapter !== "function") {
+		throw new Error(
+			"@chat-adapter/linear does not export createLinearAdapter()",
+		);
+	}
+	return { createLinearAdapter: mod.createLinearAdapter };
+}
+
+async function stopSessionsForUser(
+	state: LinearConnectorState,
+): Promise<number> {
+	return stopConnectorSessions({
+		rpcAddress: state.rpcAddress,
+		rpcMatcher: (metadata) =>
+			metadata?.transport === "linear" && metadata?.userName === state.userName,
+		localMatcher: (metadata) =>
+			metadata?.transport === "linear" && metadata?.userName === state.userName,
+	});
+}
+
+async function buildLinearStartRequest(
+	options: ConnectLinearOptions,
+	io: ConnectIo,
+	loggerConfig: Parameters<
+		typeof buildConnectorStartRequest
+	>[0]["loggerConfig"],
+): Promise<ChatStartSessionRequest> {
+	return buildConnectorStartRequest({
+		options: {
+			...options,
+			apiKey: options.apiProviderKey,
+		},
+		io,
+		loggerConfig,
+		systemRules: LINEAR_SYSTEM_RULES,
+	});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function readString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function resolveLinearParticipant(
+	rawMessage: unknown,
+): { key: string; label?: string } | undefined {
+	const raw = asRecord(rawMessage);
+	const data = asRecord(raw?.data);
+	const actor =
+		asRecord(raw?.actor) ??
+		asRecord(data?.actor) ??
+		asRecord(data?.user) ??
+		asRecord(asRecord(data?.comment)?.user);
+	const userId =
+		readString(actor?.id) ||
+		readString(data?.userId) ||
+		readString(asRecord(data?.comment)?.userId);
+	const email = readString(actor?.email)?.toLowerCase();
+	const name =
+		readString(actor?.displayName) ||
+		readString(actor?.name) ||
+		readString(actor?.label);
+	const label = name || email || userId;
+	if (userId) {
+		return {
+			key: `linear:user:${userId}`,
+			label,
+		};
+	}
+	if (email) {
+		return {
+			key: `linear:email:${email}`,
+			label,
+		};
+	}
+	return undefined;
+}
+
+async function persistLinearThreadContext(input: {
+	thread: Thread<LinearThreadState>;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	rawMessage: unknown;
+	errorLabel: string;
+}): Promise<void> {
+	const participant = resolveLinearParticipant(input.rawMessage);
+	if (!participant) {
+		return;
+	}
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	if (
+		currentState.participantKey === participant.key &&
+		currentState.participantLabel === participant.label
+	) {
+		return;
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...currentState,
+			participantKey: participant.key,
+			participantLabel: participant.label,
+		},
+		input.errorLabel,
+	);
+}
+
+async function deliverScheduledResult(input: {
+	bot: Chat;
+	client: HubSessionClient;
+	logger: CliLoggerAdapter;
+	bindingsPath: string;
+	userName: string;
+	scheduleId: string;
+	executionId: string;
+	sessionId?: string;
+	status: string;
+	errorMessage?: string;
+	hookCommand?: string;
+}): Promise<void> {
+	const schedule = await input.client.getSchedule(input.scheduleId);
+	const delivery = schedule?.metadata?.delivery as
+		| Record<string, unknown>
+		| undefined;
+	if (!delivery || delivery.adapter !== "linear") {
+		return;
+	}
+	const targetUser =
+		typeof delivery.userName === "string" ? delivery.userName.trim() : "";
+	if (targetUser && targetUser !== input.userName) {
+		return;
+	}
+	const threadId =
+		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
+	const bindingKey =
+		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
+	const participantKey =
+		typeof delivery.participantKey === "string"
+			? delivery.participantKey.trim()
+			: "";
+	if (!threadId && !bindingKey && !participantKey) {
+		return;
+	}
+	const bindings = readBindings<LinearThreadState>(input.bindingsPath);
+	const match = findBindingForDeliveryTarget(bindings, {
+		bindingKey,
+		threadId,
+		participantKey,
+	});
+	const binding = match?.binding;
+	if (!binding?.serializedThread) {
+		return;
+	}
+	await dispatchConnectorHook(
+		input.hookCommand,
+		{
+			adapter: "linear",
+			botUserName: input.userName,
+			event: "schedule.delivery.started",
+			payload: {
+				threadId: match?.key || threadId,
+				scheduleId: input.scheduleId,
+				executionId: input.executionId,
+				sessionId: input.sessionId,
+				status: input.status,
+			},
+			ts: new Date().toISOString(),
+		},
+		input.logger,
+	);
+	const thread = JSON.parse(
+		binding.serializedThread,
+		input.bot.reviver(),
+	) as Thread<LinearThreadState>;
+	let body = "";
+	if (input.status === "success" && input.sessionId) {
+		const text = await readSessionReplyText(input.client, input.sessionId);
+		body = text?.trim()
+			? text
+			: `Schedule "${schedule?.name ?? input.scheduleId}" completed, but no assistant reply text was found.`;
+	} else {
+		body = `Schedule "${schedule?.name ?? input.scheduleId}" ${input.status}.${input.errorMessage ? `\n\n${input.errorMessage}` : ""}`;
+	}
+	await thread.post(body);
+}
+
+class LinearConnector extends ConnectorBase<
+	ConnectLinearOptions,
+	LinearConnectorState
+> {
+	constructor() {
+		super("linear", "Linear webhook bridge backed by RPC runtime sessions");
+	}
+
+	protected override createCommand(): Command {
+		return super
+			.createCommand()
+			.usage("--base-url <PUBLIC_BASE_URL> [options]")
+			.option("--user-name <name>", "Linear bot display name")
+			.option("--api-key <key>", "Linear personal API key")
+			.option("--client-id <id>", "Linear OAuth client id")
+			.option("--client-secret <secret>", "Linear OAuth client secret")
+			.option("--access-token <token>", "Pre-obtained Linear access token")
+			.option("--webhook-secret <secret>", "Linear webhook signing secret")
+			.option("--provider <id>", "Provider override")
+			.option("--model <id>", "Model override")
+			.option("--provider-api-key <key>", "Provider API key override")
+			.option("--system <prompt>", "System prompt override")
+			.option("--cwd <path>", "Workspace / cwd for runtime")
+			.option("--mode <act|plan>", "Agent mode", "act")
+			.option("-i, --interactive", "Keep connector in foreground")
+			.option("--enable-tools", "Enable tools for Linear sessions")
+			.option(
+				"--hook-command <command>",
+				"Run a shell command for connector events",
+			)
+			.option(
+				"--rpc-address <host:port>",
+				"RPC address",
+				process.env.CLINE_RPC_ADDRESS?.trim() || resolveDefaultCliRpcAddress(),
+			)
+			.option("--host <host>", "Webhook listen host")
+			.option("--port <port>", "Webhook listen port")
+			.option("--base-url <url>", "Public base URL for webhook configuration")
+			.addHelpText(
+				"after",
+				[
+					"",
+					"Environment:",
+					"  LINEAR_API_KEY             Personal API key",
+					"  LINEAR_CLIENT_ID           OAuth client id",
+					"  LINEAR_CLIENT_SECRET       OAuth client secret",
+					"  LINEAR_ACCESS_TOKEN        Pre-obtained access token",
+					"  LINEAR_WEBHOOK_SECRET      Webhook signing secret",
+					"  LINEAR_BOT_USERNAME        Bot display name (default: linear-bot)",
+				].join("\n"),
+			);
+	}
+
+	protected override readOptions(command: Command): ConnectLinearOptions {
+		const opts = command.opts<{
+			userName?: string;
+			apiKey?: string;
+			clientId?: string;
+			clientSecret?: string;
+			accessToken?: string;
+			webhookSecret?: string;
+			cwd?: string;
+			model?: string;
+			provider?: string;
+			providerApiKey?: string;
+			system?: string;
+			mode?: string;
+			interactive?: boolean;
+			enableTools?: boolean;
+			rpcAddress?: string;
+			hookCommand?: string;
+			port?: string;
+			host?: string;
+			baseUrl?: string;
+		}>();
+		const apiKey = opts.apiKey?.trim() || process.env.LINEAR_API_KEY?.trim();
+		const clientId =
+			opts.clientId?.trim() || process.env.LINEAR_CLIENT_ID?.trim();
+		const clientSecret =
+			opts.clientSecret?.trim() || process.env.LINEAR_CLIENT_SECRET?.trim();
+		const accessToken =
+			opts.accessToken?.trim() || process.env.LINEAR_ACCESS_TOKEN?.trim();
+		const webhookSecret =
+			opts.webhookSecret?.trim() || process.env.LINEAR_WEBHOOK_SECRET?.trim();
+		if (!webhookSecret) {
+			throw new Error(
+				"connect linear requires --webhook-secret <secret> or LINEAR_WEBHOOK_SECRET",
+			);
+		}
+		if (!apiKey && !accessToken && !(clientId && clientSecret)) {
+			throw new Error(
+				"connect linear requires LINEAR_API_KEY, LINEAR_ACCESS_TOKEN, or both LINEAR_CLIENT_ID and LINEAR_CLIENT_SECRET",
+			);
+		}
+		const parsedPort =
+			this.parseOptionalInteger(opts.port, "port") ??
+			Number.parseInt(process.env.PORT ?? "8787", 10);
+		const port = Number.isFinite(parsedPort) ? parsedPort : 8787;
+		return {
+			userName:
+				opts.userName?.trim() ||
+				process.env.LINEAR_BOT_USERNAME?.trim() ||
+				"linear-bot",
+			apiKey,
+			clientId,
+			clientSecret,
+			accessToken,
+			webhookSecret,
+			cwd: opts.cwd || process.cwd(),
+			model: opts.model,
+			provider: opts.provider,
+			apiProviderKey: opts.providerApiKey,
+			systemPrompt: opts.system,
+			mode: this.parseMode(opts.mode),
+			interactive: Boolean(opts.interactive),
+			enableTools: Boolean(opts.enableTools),
+			rpcAddress:
+				opts.rpcAddress?.trim() ||
+				process.env.CLINE_RPC_ADDRESS?.trim() ||
+				resolveDefaultCliRpcAddress(),
+			hookCommand:
+				opts.hookCommand?.trim() ||
+				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
+			port,
+			host: opts.host?.trim() || process.env.HOST?.trim() || "0.0.0.0",
+			baseUrl:
+				opts.baseUrl?.trim() ||
+				process.env.BASE_URL?.trim() ||
+				`http://127.0.0.1:${port}`,
+		};
+	}
+
+	private resolveConnectorStatePath(userName: string): string {
+		return this.resolveConnectorPath(`${this.sanitizeKey(userName)}.json`);
+	}
+
+	private resolveBindingsPath(userName: string): string {
+		return this.resolveConnectorPath(
+			`${this.sanitizeKey(userName)}.threads.json`,
+		);
+	}
+
+	private listConnectorStatePaths(): string[] {
+		return this.listJsonStatePaths([".threads.json"]);
+	}
+
+	private readConnectorState(
+		statePath: string,
+	): LinearConnectorState | undefined {
+		return this.readStateFile(
+			statePath,
+			(value): value is LinearConnectorState =>
+				Boolean(
+					value &&
+						typeof value === "object" &&
+						typeof (value as LinearConnectorState).pid === "number" &&
+						typeof (value as LinearConnectorState).userName === "string",
+				),
+		);
+	}
+
+	private writeConnectorState(
+		statePath: string,
+		state: LinearConnectorState,
+	): void {
+		this.writeStateFile(statePath, state);
+	}
+
+	private async stopLinearConnectorInstance(
+		statePath: string,
+		io: ConnectIo,
+	): Promise<ConnectStopResult> {
+		return this.stopManagedProcess({
+			io,
+			statePath,
+			readState: (path) => this.readConnectorState(path),
+			describeStoppedProcess: (state) =>
+				`[linear] stopped pid=${state.pid} user=${state.userName}`,
+			getPid: (state) => state.pid,
+			stopSessions: stopSessionsForUser,
+			clearBindings: (state) => {
+				clearBindingSessionIds<LinearThreadState>(
+					this.resolveBindingsPath(state.userName),
+				);
+			},
+		});
+	}
+
+	override async stopAll(io: ConnectIo): Promise<ConnectStopResult> {
+		return this.stopAllFromStatePaths(
+			io,
+			this.listConnectorStatePaths(),
+			(statePath, stopIo) =>
+				this.stopLinearConnectorInstance(statePath, stopIo),
+		);
+	}
+
+	protected override async runWithOptions(
+		options: ConnectLinearOptions,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number> {
+		const statePath = this.resolveConnectorStatePath(options.userName);
+		const bindingsPath = this.resolveBindingsPath(options.userName);
+		const staleState = this.removeStaleState(
+			statePath,
+			(path) => this.readConnectorState(path),
+			(state) => state.pid,
+		);
+		if (staleState) {
+			clearBindingSessionIds<LinearThreadState>(bindingsPath);
+		}
+		if (
+			await this.maybeRunInBackground({
+				rawArgs,
+				io,
+				interactive: options.interactive,
+				childEnvVar: "CLINE_LINEAR_CONNECT_CHILD",
+				statePath,
+				readState: (path) => this.readConnectorState(path),
+				isRunning: (state) => isProcessRunning(state.pid),
+				formatAlreadyRunningMessage: (state) =>
+					`[linear] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
+				formatBackgroundStartMessage: (pid) =>
+					`[linear] starting background connector pid=${pid} user=${options.userName}`,
+				foregroundHint:
+					"[linear] use `cline connect linear -i ...` to run in the foreground",
+				launchFailureMessage: "failed to launch Linear connector in background",
+			})
+		) {
+			return 0;
+		}
+
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "linear-connect",
+		});
+		const logger = createChatSdkLogger(loggerAdapter);
+		const consoleLogger = new ConsoleLogger("info", "linear-connect");
+		let linearAdapter: unknown;
+		try {
+			const { createLinearAdapter } = await importLinearAdapterModule();
+			const linearConfig: Record<string, unknown> = {
+				webhookSecret: options.webhookSecret,
+				userName: options.userName,
+				logger: consoleLogger,
+			};
+			if (options.apiKey) {
+				linearConfig.apiKey = options.apiKey;
+			}
+			if (options.clientId) {
+				linearConfig.clientId = options.clientId;
+			}
+			if (options.clientSecret) {
+				linearConfig.clientSecret = options.clientSecret;
+			}
+			if (options.accessToken) {
+				linearConfig.accessToken = options.accessToken;
+			}
+			linearAdapter = createLinearAdapter(linearConfig);
+		} catch (error) {
+			io.writeErr(
+				`failed to load @chat-adapter/linear: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return 1;
+		}
+
+		const bot = new Chat({
+			userName: options.userName,
+			adapters: { linear: linearAdapter as Adapter },
+			state: new InMemoryStateAdapter(),
+			logger,
+			fallbackStreamingPlaceholderText: null,
+			streamingUpdateIntervalMs: 500,
+		}).registerSingleton();
+		const threadQueues = new Map<string, Promise<void>>();
+		const activeTurns = new Map<string, ActiveConnectorTurn>();
+		const pendingApprovals = new Map<string, PendingConnectorApproval>();
+		const startRequest = await buildLinearStartRequest(options, io, {
+			enabled: loggerAdapter.runtimeConfig.enabled,
+			level: loggerAdapter.runtimeConfig.level,
+			destination: loggerAdapter.runtimeConfig.destination,
+			bindings: {
+				transport: "linear",
+				userName: options.userName,
+			},
+		});
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { workspacePath: startRequest.cwd },
+			rules: { workspacePath: startRequest.cwd },
+			workflows: { workspacePath: startRequest.cwd },
+		});
+		await userInstructionService.start().catch(() => undefined);
+		const commandCwd = startRequest.cwd || process.cwd();
+		const { host: chatCommandHost } = await createWorkspaceChatCommandHost({
+			cwd: commandCwd,
+			workspaceRoot: startRequest.workspaceRoot || commandCwd,
+		});
+		const { url: rpcAddress, authToken: rpcAuthToken } =
+			await ensureCliHubServer(
+				startRequest.workspaceRoot || startRequest.cwd || process.cwd(),
+				parseHubEndpointOverride(options.rpcAddress),
+			);
+
+		const clientId = `linear-${process.pid}-${Date.now()}`;
+		const client = new HubSessionClient({
+			address: rpcAddress,
+			authToken: rpcAuthToken,
+			clientId,
+			clientType: "cli",
+			displayName: "linear connector",
+			workspaceRoot: startRequest.workspaceRoot || startRequest.cwd,
+			cwd: startRequest.cwd,
+			metadata: {
+				transport: "linear",
+				userName: options.userName,
+			},
+		});
+		await client.connect();
+		this.writeConnectorState(statePath, {
+			userName: options.userName,
+			pid: process.pid,
+			rpcAddress,
+			port: options.port,
+			baseUrl: options.baseUrl,
+			startedAt: new Date().toISOString(),
+		});
+
+		let stopping = false;
+		let resolveStop: (() => void) | undefined;
+		const stopPromise = new Promise<void>((resolve) => {
+			resolveStop = resolve;
+		});
+		const requestStop = (_reason: string) => {
+			if (stopping) {
+				return;
+			}
+			stopping = true;
+			resolveStop?.();
+		};
+
+		const handleTurn = async (
+			thread: Thread<LinearThreadState>,
+			text: string,
+		) => {
+			const queueKey = thread.id;
+			const runTurn = async () => {
+				try {
+					await handleConnectorUserTurn({
+						thread,
+						text,
+						client,
+						pendingApprovals,
+						baseStartRequest: startRequest,
+						explicitSystemPrompt:
+							options.systemPrompt?.trim() ||
+							getConnectorSystemPrompt("Linear"),
+						clientId,
+						logger: loggerAdapter,
+						transport: "linear",
+						botUserName: options.userName,
+						requestStop,
+						bindingsPath,
+						hookCommand: options.hookCommand,
+						systemRules: LINEAR_SYSTEM_RULES,
+						errorLabel: "Linear",
+						firstContactMessage: LINEAR_FIRST_CONTACT_MESSAGE,
+						userInstructionService,
+						chatCommandHost,
+						activeTurns,
+						turnKey: queueKey,
+						getSessionMetadata: (currentThread, _clientId, currentState) => ({
+							userName: options.userName,
+							linearThreadId: currentThread.id,
+							linearChannelId: currentThread.channelId,
+							...(currentState.participantKey
+								? { linearParticipantKey: currentState.participantKey }
+								: {}),
+							...(currentState.participantLabel
+								? { linearParticipantLabel: currentState.participantLabel }
+								: {}),
+						}),
+						reusedLogMessage: "Linear thread reusing RPC session",
+						onReplyCompleted: async (result) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "linear",
+									botUserName: options.userName,
+									event: "message.completed",
+									payload: {
+										threadId: result.threadId,
+										sessionId: result.sessionId,
+										finishReason: result.finishReason,
+										iterations: result.iterations,
+										outputPreview: truncateText(result.text),
+										outputLength: result.text.length,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyFailed: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "linear",
+									botUserName: options.userName,
+									event: "message.failed",
+									payload: {
+										threadId: details.threadId,
+										sessionId: details.sessionId,
+										error: details.error.message,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+					});
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					await thread.post(`Linear bridge error: ${message}`);
+				}
+			};
+			if (activeTurns.has(queueKey)) {
+				await runTurn();
+				return;
+			}
+			await enqueueThreadTurn(threadQueues, queueKey, async () => {
+				await runTurn();
+			});
+		};
+
+		bot.onNewMention(async (thread, message) => {
+			await thread.subscribe();
+			await persistLinearThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Linear",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Linear user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		bot.onSubscribedMessage(async (thread, message) => {
+			await persistLinearThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Linear",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Linear user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		await bot.initialize();
+		const stopTaskUpdateStream =
+			startConnectorTaskUpdateRelay<LinearThreadState>({
+				client,
+				clientId,
+				bot,
+				logger: loggerAdapter,
+				bindingsPath,
+				transport: "linear",
+			});
+
+		const webhookUrl = `${options.baseUrl.replace(/\/$/, "")}/api/webhooks/linear`;
+		const server = await startConnectorWebhookServer({
+			host: options.host,
+			port: options.port,
+			routes: {
+				"/api/webhooks/linear": async (request) => bot.webhooks.linear(request),
+				"/health": () => new Response("ok"),
+				"/": () =>
+					new Response(
+						["Linear connector is running.", `Webhook URL: ${webhookUrl}`].join(
+							"\n",
+						),
+					),
+			},
+		});
+
+		const stopEventStream = client.streamEvents(
+			{ clientId: `${clientId}-server-events` },
+			{
+				onEvent: (event) => {
+					if (event.eventType === "rpc.server.shutting_down") {
+						requestStop("rpc_server_shutting_down");
+						return;
+					}
+					if (
+						event.eventType !== "schedule.execution.completed" &&
+						event.eventType !== "schedule.execution.failed"
+					) {
+						return;
+					}
+					const scheduleId =
+						typeof event.payload.scheduleId === "string"
+							? event.payload.scheduleId.trim()
+							: "";
+					const executionId =
+						typeof event.payload.executionId === "string"
+							? event.payload.executionId.trim()
+							: "";
+					const sessionId =
+						typeof event.payload.sessionId === "string"
+							? event.payload.sessionId.trim()
+							: undefined;
+					const status =
+						typeof event.payload.status === "string"
+							? event.payload.status.trim()
+							: "";
+					const errorMessage =
+						typeof event.payload.errorMessage === "string"
+							? event.payload.errorMessage
+							: undefined;
+					if (!scheduleId || !executionId || !status) {
+						return;
+					}
+					void deliverScheduledResult({
+						bot,
+						client,
+						logger: loggerAdapter,
+						bindingsPath,
+						userName: options.userName,
+						scheduleId,
+						executionId,
+						sessionId,
+						status,
+						errorMessage,
+						hookCommand: options.hookCommand,
+					});
+				},
+				onError: () => {
+					requestStop("rpc_server_event_stream_failed");
+				},
+			},
+		);
+
+		process.once("SIGINT", () => requestStop("sigint"));
+		process.once("SIGTERM", () => requestStop("sigterm"));
+
+		io.writeln(`[linear] listening on ${options.host}:${options.port}`);
+		io.writeln(`[linear] configure Linear webhook URL: ${webhookUrl}`);
+
+		await stopPromise;
+		clearBindingSessionIds<LinearThreadState>(bindingsPath);
+		stopTaskUpdateStream();
+		stopEventStream();
+		await server.close();
+		userInstructionService.stop();
+		await bot.shutdown().catch(() => undefined);
+		client.close();
+		this.removeStateFile(statePath);
+		return 0;
+	}
+}
+
+export const linearConnector: ConnectCommandDefinition = new LinearConnector();
+
+export const __test__ = {
+	findBindingForThread: (
+		bindings: ConnectorBindingStore<LinearThreadState>,
+		thread: Pick<Thread<LinearThreadState>, "id" | "channelId" | "isDM"> & {
+			participantKey?: string;
+		},
+	) => findBindingForThread(bindings, thread),
+};
diff --git a/apps/cli/src/connectors/adapters/prompts.ts b/apps/cli/src/connectors/adapters/prompts.ts
new file mode 100644
index 0000000..16c09e2
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/prompts.ts
@@ -0,0 +1,39 @@
+const CONNECTOR_SYSTEM_PROMPT = `You are a helpful assistant running in a secure environment, connected and integrated into a {{CONNECTOR_ID}} session while running in the environment that the user has set you up in. You have access to tools that are integrated into this {{CONNECTOR_ID}} session and can use them to help you answer user's questions. Always try to use the tools when necessary instead of making assumptions or fabricating information.
+
+Environment you are running in:
+<env>
+1. Platform: {{PLATFORM_NAME}}
+2. Date: {{CURRENT_DATE}}
+3. IDE: {{IDE_NAME}}
+4. Working Directory: {{CWD}}
+</env>`;
+
+export function getConnectorSystemPrompt(connectorId: string) {
+	return CONNECTOR_SYSTEM_PROMPT.replace(/{{CONNECTOR_ID}}/g, connectorId);
+}
+
+const CONNECTOR_SYSTEM_RULES = [
+	"Keep answers compact and optimized for this {{CONNECTOR_ID}} integration unless the user asks for detail.",
+	"{{CONNECTOR_RULES}}",
+	"When tools are disabled, explain limits briefly and ask for /tools if tool usage is required.",
+].join("\n");
+
+export function getConnectorSystemRules(
+	connectorId: string,
+	additionalRules?: string,
+) {
+	return CONNECTOR_SYSTEM_RULES.replace(
+		/{{CONNECTOR_ID}}/g,
+		connectorId,
+	).replace(/{{CONNECTOR_RULES}}/g, additionalRules || "");
+}
+
+const CONNECTOR_FIRST_CONTACT_MESSAGE = [
+	"Connected to Cline.",
+	"Your chat history is kept separately for your account.",
+	"Send /new to start a fresh session or /whereami for thread details.",
+].join("\n");
+
+export function getConnectorFirstContactMessage(_participantId?: string) {
+	return CONNECTOR_FIRST_CONTACT_MESSAGE;
+}
diff --git a/apps/cli/src/connectors/adapters/slack.test.ts b/apps/cli/src/connectors/adapters/slack.test.ts
new file mode 100644
index 0000000..ce9a640
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/slack.test.ts
@@ -0,0 +1,353 @@
+import type { ConnectSlackOptions } from "@cline/shared";
+import { type Message, ThreadImpl } from "chat";
+import { describe, expect, it } from "vitest";
+import { __test__, slackConnector } from "./slack";
+
+const parseSlackArgs = (rawArgs: string[]): ConnectSlackOptions =>
+	(
+		slackConnector as unknown as {
+			parseArgs(rawArgs: string[]): ConnectSlackOptions;
+		}
+	).parseArgs(rawArgs);
+
+describe("slack binding lookup", () => {
+	const participantKey = __test__.buildSlackParticipantKey("T123", "U123");
+
+	it("infers Slack webhook mode from a base URL", () => {
+		expect(__test__.inferSlackConnectionMode("https://example.test")).toBe(
+			"webhook",
+		);
+		expect(__test__.inferSlackConnectionMode("  ")).toBe("socket");
+		expect(__test__.inferSlackConnectionMode(undefined)).toBe("socket");
+	});
+
+	it("uses webhook mode when Slack args include a base URL", () => {
+		const options = parseSlackArgs([
+			"--bot-token",
+			"xoxb-token",
+			"--signing-secret",
+			"secret",
+			"--app-token",
+			"xapp-ignored",
+			"--base-url",
+			"https://example.test",
+		]);
+
+		expect(options.connectionMode).toBe("webhook");
+		expect(options.baseUrl).toBe("https://example.test");
+		expect(options.signingSecret).toBe("secret");
+		expect(options.appToken).toBeUndefined();
+	});
+
+	it("uses socket mode when Slack args omit a base URL", () => {
+		const previousBaseUrl = process.env.BASE_URL;
+		delete process.env.BASE_URL;
+		let options: ConnectSlackOptions;
+		try {
+			options = parseSlackArgs([
+				"--bot-token",
+				"xoxb-token",
+				"--app-token",
+				"xapp-token",
+			]);
+		} finally {
+			if (previousBaseUrl === undefined) {
+				delete process.env.BASE_URL;
+			} else {
+				process.env.BASE_URL = previousBaseUrl;
+			}
+		}
+
+		expect(options.connectionMode).toBe("socket");
+		expect(options.baseUrl).toBeUndefined();
+		expect(options.appToken).toBe("xapp-token");
+	});
+
+	it("falls back to DM channel identity when a restarted connector gets a new thread id", () => {
+		const result = __test__.findBindingForThread(
+			{
+				legacy_thread_id: {
+					channelId: "slack:C123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1", cwd: "/tmp/work", teamId: "T123" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "new_thread_id",
+				channelId: "slack:C123",
+				isDM: true,
+			},
+		);
+
+		expect(result).toEqual({
+			key: "legacy_thread_id",
+			binding: {
+				channelId: "slack:C123",
+				isDM: true,
+				serializedThread: "{}",
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", cwd: "/tmp/work", teamId: "T123" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+	});
+
+	it("prefers an exact thread id match over a channel fallback", () => {
+		const result = __test__.findBindingForThread(
+			{
+				current_thread_id: {
+					channelId: "slack:C123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-2",
+					state: { sessionId: "sess-2", teamId: "T123" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+				legacy_thread_id: {
+					channelId: "slack:C123",
+					isDM: false,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1", teamId: "T123" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "current_thread_id",
+				channelId: "slack:C123",
+				isDM: false,
+			},
+		);
+
+		expect(result?.key).toBe("current_thread_id");
+		expect(result?.binding.sessionId).toBe("sess-2");
+	});
+
+	it("does not reuse a binding by participant key across different threads", () => {
+		const result = __test__.findBindingForThread(
+			{
+				[participantKey]: {
+					channelId: "slack:C123",
+					isDM: false,
+					participantKey,
+					participantLabel: "alice",
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: {
+						sessionId: "sess-1",
+						teamId: "T123",
+						participantKey,
+						participantLabel: "alice",
+					},
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "other_thread_id",
+				channelId: "slack:C999",
+				isDM: false,
+				participantKey,
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+
+	it("builds Slack participant keys with a team scope", () => {
+		expect(__test__.buildSlackParticipantKey("T123", "U123")).toBe(
+			"slack:team:T123:user:U123",
+		);
+	});
+
+	it("requires team context before resolving a Slack participant key", () => {
+		expect(
+			__test__.resolveSlackParticipant(
+				{ user: "U123", username: "alice" },
+				undefined,
+			),
+		).toBeUndefined();
+		expect(
+			__test__.resolveSlackParticipant(
+				{ team_id: "T123", user: "U123", username: "alice" },
+				"T123",
+			),
+		).toEqual({
+			key: "slack:team:T123:user:U123",
+			label: "alice",
+		});
+	});
+
+	it("normalizes direct-message channels even when Slack omits im channel_type", () => {
+		expect(
+			__test__.normalizeSlackMessageEventChannelType({
+				channel: "D123",
+				channel_type: "app_home",
+				ts: "123.456",
+			}),
+		).toEqual({
+			channel: "D123",
+			channel_type: "im",
+			ts: "123.456",
+		});
+		expect(
+			__test__.normalizeSlackMessageEventChannelType({
+				channel: "D123",
+				ts: "123.456",
+			}),
+		).toEqual({
+			channel: "D123",
+			channel_type: "im",
+			ts: "123.456",
+		});
+	});
+
+	it("leaves non-DM Slack message events unchanged", () => {
+		const channelEvent = {
+			channel: "C123",
+			channel_type: "channel",
+			ts: "123.456",
+		};
+		expect(__test__.normalizeSlackMessageEventChannelType(channelEvent)).toBe(
+			channelEvent,
+		);
+	});
+
+	it("normalizes top-level channel mentions to the original Slack post thread", () => {
+		const original = new ThreadImpl({
+			adapterName: "slack",
+			channelId: "slack:C123",
+			id: "slack:C123:",
+			isDM: false,
+		});
+		const message = {
+			raw: {
+				channel: "C123",
+				text: "<@U999> help",
+				ts: "1710000000.123456",
+				type: "app_mention",
+				user: "U123",
+			},
+		} as Message;
+
+		const normalized = __test__.resolveSlackChannelMentionThread(
+			original,
+			message,
+		);
+
+		expect(normalized.id).toBe("slack:C123:1710000000.123456");
+		expect(normalized.channelId).toBe("slack:C123");
+		expect(normalized.isDM).toBe(false);
+	});
+
+	it("uses Slack thread_ts instead of reply ts for in-thread mentions", () => {
+		const original = new ThreadImpl({
+			adapterName: "slack",
+			channelId: "slack:C123",
+			id: "slack:C123:1710000001.654321",
+			isDM: false,
+		});
+		const message = {
+			raw: {
+				channel: "C123",
+				text: "<@U999> follow up",
+				thread_ts: "1710000000.123456",
+				ts: "1710000001.654321",
+				type: "app_mention",
+				user: "U123",
+			},
+		} as Message;
+
+		const normalized = __test__.resolveSlackChannelMentionThread(
+			original,
+			message,
+		);
+
+		expect(normalized.id).toBe("slack:C123:1710000000.123456");
+		expect(normalized.channelId).toBe("slack:C123");
+		expect(normalized.isDM).toBe(false);
+	});
+
+	it("keeps Slack mention threads that already target the original post", () => {
+		const original = new ThreadImpl({
+			adapterName: "slack",
+			channelId: "slack:C123",
+			id: "slack:C123:1710000000.123456",
+			isDM: false,
+		});
+		const message = {
+			raw: {
+				channel: "C123",
+				text: "<@U999> help",
+				ts: "1710000000.123456",
+				type: "app_mention",
+				user: "U123",
+			},
+		} as Message;
+
+		expect(__test__.resolveSlackChannelMentionThread(original, message)).toBe(
+			original,
+		);
+	});
+
+	it("does not rewrite Slack DM mention threads", () => {
+		const original = new ThreadImpl({
+			adapterName: "slack",
+			channelId: "slack:D123",
+			id: "slack:D123:",
+			isDM: true,
+		});
+		const message = {
+			raw: {
+				channel: "D123",
+				text: "help",
+				ts: "1710000000.123456",
+				type: "message",
+				user: "U123",
+			},
+		} as Message;
+
+		expect(__test__.resolveSlackChannelMentionThread(original, message)).toBe(
+			original,
+		);
+	});
+
+	it("routes Slack posts through the installation bot token for a team", async () => {
+		const calls: string[] = [];
+		const result = await __test__.withSlackTeamBotToken({
+			slack: {
+				getInstallation: async (teamId: string) => {
+					calls.push(`get:${teamId}`);
+					return { botToken: "xoxb-team-token" };
+				},
+				withBotToken: <T>(token: string, work: () => T): T => {
+					calls.push(`token:${token}`);
+					return work();
+				},
+			},
+			teamId: "T123",
+			work: async () => {
+				calls.push("work");
+				return "ok";
+			},
+		});
+
+		expect(result).toBe("ok");
+		expect(calls).toEqual(["get:T123", "token:xoxb-team-token", "work"]);
+	});
+
+	it("detects Slack invalid_thread_ts errors", () => {
+		expect(
+			__test__.isSlackInvalidThreadTsError(
+				new Error("An API error occurred: invalid_thread_ts"),
+			),
+		).toBe(true);
+		expect(
+			__test__.isSlackInvalidThreadTsError(
+				new Error("An API error occurred: channel_not_found"),
+			),
+		).toBe(false);
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/slack.ts b/apps/cli/src/connectors/adapters/slack.ts
new file mode 100644
index 0000000..8a53c36
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/slack.ts
@@ -0,0 +1,1214 @@
+import { createSlackAdapter, type SlackAdapter } from "@chat-adapter/slack";
+import type { ChatStartSessionRequest } from "@cline/core";
+import {
+	createUserInstructionConfigService,
+	HubSessionClient,
+} from "@cline/core";
+import type { ConnectSlackOptions, SlackConnectorState } from "@cline/shared";
+import {
+	type Adapter,
+	Chat,
+	ConsoleLogger,
+	type Message,
+	type Thread,
+	ThreadImpl,
+} from "chat";
+import type { Command } from "commander";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import { createCliLoggerAdapter } from "../../logging/adapter";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+	resolveDefaultCliRpcAddress,
+} from "../../utils/hub-runtime";
+import { createWorkspaceChatCommandHost } from "../../utils/plugin-chat-commands";
+import { ConnectorBase } from "../base";
+import {
+	createChatSdkLogger,
+	enqueueThreadTurn,
+	startConnectorWebhookServer,
+} from "../chat-runtime";
+import { isProcessRunning } from "../common";
+import {
+	type ActiveConnectorTurn,
+	handleConnectorUserTurn,
+	maybeHandleConnectorApprovalReply,
+} from "../connector-host";
+import { dispatchConnectorHook } from "../hooks";
+import {
+	type PendingConnectorApproval,
+	truncateConnectorText,
+} from "../runtime-turn";
+import {
+	buildConnectorStartRequest,
+	readSessionReplyText,
+	stopConnectorSessions,
+} from "../session-runtime";
+import { FileStateAdapter } from "../stores/file-state";
+import { startConnectorTaskUpdateRelay } from "../task-updates";
+import {
+	type ConnectorBindingStore,
+	type ConnectorThreadBinding,
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	findBindingForThread,
+	loadThreadState,
+	persistMergedThreadState,
+	readBindings,
+	writeBindings,
+} from "../thread-bindings";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "../types";
+import {
+	getConnectorFirstContactMessage,
+	getConnectorSystemPrompt,
+	getConnectorSystemRules,
+} from "./prompts";
+
+const SLACK_SYSTEM_RULES = getConnectorSystemRules(
+	"Slack",
+	"You can respond to user messages in threads and DMs, and you can use tools according to user's requests and your capabilities.",
+);
+
+const SLACK_FIRST_CONTACT_MESSAGE = getConnectorFirstContactMessage();
+
+type SlackThreadState = ConnectorThreadState & {
+	teamId?: string;
+};
+
+type SlackConnectionMode = ConnectSlackOptions["connectionMode"];
+
+function inferSlackConnectionMode(
+	baseUrl: string | undefined,
+): SlackConnectionMode {
+	return baseUrl?.trim() ? "webhook" : "socket";
+}
+
+function truncateText(value: string, maxLength = 160): string {
+	return truncateConnectorText(value, maxLength);
+}
+
+function sanitizeKey(value: string): string {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+async function stopSessionsForUser(
+	state: SlackConnectorState,
+): Promise<number> {
+	return stopConnectorSessions({
+		rpcAddress: state.rpcAddress,
+		rpcMatcher: (metadata) =>
+			metadata?.transport === "slack" && metadata?.userName === state.userName,
+		localMatcher: (metadata) =>
+			metadata?.transport === "slack" && metadata?.userName === state.userName,
+	});
+}
+
+async function buildSlackStartRequest(
+	options: ConnectSlackOptions,
+	io: ConnectIo,
+	loggerConfig: Parameters<
+		typeof buildConnectorStartRequest
+	>[0]["loggerConfig"],
+): Promise<ChatStartSessionRequest> {
+	return buildConnectorStartRequest({
+		options,
+		io,
+		loggerConfig,
+		systemRules: SLACK_SYSTEM_RULES,
+	});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function firstRecord(value: unknown): Record<string, unknown> | undefined {
+	return Array.isArray(value) ? asRecord(value[0]) : undefined;
+}
+
+function readString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function normalizeSlackMessageEventChannelType<T>(event: T): T {
+	const record = asRecord(event);
+	const channel = readString(record?.channel);
+	if (!channel?.startsWith("D") || record?.channel_type === "im") {
+		return event;
+	}
+	return {
+		...record,
+		channel_type: "im",
+	} as T;
+}
+
+function buildSlackParticipantKey(teamId: string, userId: string): string {
+	return `slack:team:${teamId}:user:${userId}`;
+}
+
+function resolveSlackParticipant(
+	rawMessage: unknown,
+	teamId?: string,
+): { key: string; label?: string } | undefined {
+	const raw = asRecord(rawMessage);
+	const event = asRecord(raw?.event);
+	const message = asRecord(raw?.message);
+	const user =
+		readString(raw?.user) ||
+		readString(event?.user) ||
+		readString(message?.user) ||
+		readString(firstRecord(raw?.authorizations)?.user_id);
+	const username =
+		readString(raw?.username) ||
+		readString(event?.username) ||
+		readString(message?.username);
+	const label = username || user;
+	if (!user || !teamId?.trim()) {
+		return undefined;
+	}
+	return {
+		key: buildSlackParticipantKey(teamId.trim(), user),
+		label,
+	};
+}
+
+function extractSlackTeamId(raw: unknown): string | undefined {
+	if (!raw || typeof raw !== "object") {
+		return undefined;
+	}
+	const record = raw as Record<string, unknown>;
+	const value =
+		typeof record.team_id === "string"
+			? record.team_id
+			: typeof record.team === "string"
+				? record.team
+				: undefined;
+	return value?.trim() || undefined;
+}
+
+function extractSlackMessageRecord(
+	raw: unknown,
+): Record<string, unknown> | undefined {
+	const record = asRecord(raw);
+	return asRecord(record?.event) ?? asRecord(record?.message) ?? record;
+}
+
+function extractSlackChannelFromId(id: string): string | undefined {
+	const parts = id.split(":");
+	return parts[0] === "slack" ? readString(parts[1]) : undefined;
+}
+
+function resolveSlackChannelMentionThread(
+	thread: Thread<SlackThreadState>,
+	message: Message,
+): Thread<SlackThreadState> {
+	if (thread.isDM) {
+		return thread;
+	}
+	const event = extractSlackMessageRecord(message.raw);
+	const threadTs = readString(event?.thread_ts) ?? readString(event?.ts);
+	if (!threadTs) {
+		return thread;
+	}
+	const channel =
+		readString(event?.channel) ??
+		extractSlackChannelFromId(thread.id) ??
+		extractSlackChannelFromId(thread.channelId);
+	if (!channel) {
+		return thread;
+	}
+	const threadId = `slack:${channel}:${threadTs}`;
+	const channelId = `slack:${channel}`;
+	if (thread.id === threadId && thread.channelId === channelId) {
+		return thread;
+	}
+	return new ThreadImpl<SlackThreadState>({
+		adapterName: "slack",
+		channelId,
+		channelVisibility: thread.channelVisibility,
+		currentMessage: message,
+		fallbackStreamingPlaceholderText: null,
+		id: threadId,
+		initialMessage: message,
+		isDM: false,
+		isSubscribedContext: false,
+		streamingUpdateIntervalMs: 500,
+	});
+}
+
+async function withSlackBindingBotToken<T>(input: {
+	slack: Pick<SlackAdapter, "getInstallation" | "withBotToken">;
+	binding: ConnectorThreadBinding<SlackThreadState>;
+	work: () => Promise<T>;
+}): Promise<T> {
+	return withSlackTeamBotToken({
+		slack: input.slack,
+		teamId: input.binding.state?.teamId,
+		work: input.work,
+	});
+}
+
+async function withSlackTeamBotToken<T>(input: {
+	slack: Pick<SlackAdapter, "getInstallation" | "withBotToken">;
+	teamId?: string;
+	work: () => Promise<T>;
+}): Promise<T> {
+	const teamId = input.teamId?.trim();
+	if (!teamId) {
+		return input.work();
+	}
+	const installation = await input.slack.getInstallation(teamId);
+	if (!installation?.botToken) {
+		return input.work();
+	}
+	return input.slack.withBotToken(installation.botToken, input.work);
+}
+
+function patchSlackMessageEventHandling(slack: SlackAdapter): void {
+	const adapter = slack as unknown as {
+		handleMessageEvent?: (event: unknown, options?: unknown) => unknown;
+	};
+	if (typeof adapter.handleMessageEvent !== "function") {
+		return;
+	}
+	const original = adapter.handleMessageEvent.bind(slack);
+	adapter.handleMessageEvent = (event, options) =>
+		original(normalizeSlackMessageEventChannelType(event), options);
+}
+
+function isSlackInvalidThreadTsError(error: unknown): boolean {
+	const message =
+		error instanceof Error
+			? error.message
+			: typeof error === "string"
+				? error
+				: "";
+	return /\binvalid_thread_ts\b/i.test(message);
+}
+
+function clearSlackBinding(
+	bindingsPath: string,
+	bindingKey: string | undefined,
+): boolean {
+	const key = bindingKey?.trim();
+	if (!key) {
+		return false;
+	}
+	const bindings = readBindings<SlackThreadState>(bindingsPath);
+	if (!bindings[key]) {
+		return false;
+	}
+	delete bindings[key];
+	writeBindings(bindingsPath, bindings);
+	return true;
+}
+
+async function persistSlackThreadContext(input: {
+	thread: Thread<SlackThreadState>;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	rawMessage: unknown;
+	errorLabel: string;
+}): Promise<void> {
+	const teamId = extractSlackTeamId(input.rawMessage);
+	const participant = resolveSlackParticipant(input.rawMessage, teamId);
+	if (!teamId) {
+		return;
+	}
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	if (
+		currentState.teamId === teamId &&
+		currentState.participantKey === participant?.key &&
+		currentState.participantLabel === participant?.label
+	) {
+		return;
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...currentState,
+			teamId: teamId ?? currentState.teamId,
+			participantKey: participant?.key ?? currentState.participantKey,
+			participantLabel: participant?.label ?? currentState.participantLabel,
+		},
+		input.errorLabel,
+	);
+}
+
+async function deliverScheduledResult(input: {
+	bot: Chat;
+	slack: SlackAdapter;
+	client: HubSessionClient;
+	logger: CliLoggerAdapter;
+	bindingsPath: string;
+	userName: string;
+	scheduleId: string;
+	executionId: string;
+	sessionId?: string;
+	status: string;
+	errorMessage?: string;
+	hookCommand?: string;
+}): Promise<void> {
+	const schedule = await input.client.getSchedule(input.scheduleId);
+	const delivery = schedule?.metadata?.delivery as
+		| Record<string, unknown>
+		| undefined;
+	if (!delivery || delivery.adapter !== "slack") {
+		return;
+	}
+	const targetUser =
+		typeof delivery.userName === "string" ? delivery.userName.trim() : "";
+	if (targetUser && targetUser !== input.userName) {
+		return;
+	}
+	const threadId =
+		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
+	const bindingKey =
+		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
+	const participantKey =
+		typeof delivery.participantKey === "string"
+			? delivery.participantKey.trim()
+			: "";
+	if (!threadId && !bindingKey && !participantKey) {
+		return;
+	}
+	const bindings = readBindings<SlackThreadState>(input.bindingsPath);
+	const match = findBindingForDeliveryTarget(bindings, {
+		bindingKey,
+		threadId,
+		participantKey,
+	});
+	const binding = match?.binding;
+	const deliveryThreadId = match?.key || threadId || bindingKey;
+	if (!binding?.serializedThread) {
+		return;
+	}
+	const thread = JSON.parse(
+		binding.serializedThread,
+		input.bot.reviver(),
+	) as Thread<SlackThreadState>;
+	let body = "";
+	if (input.status === "success" && input.sessionId) {
+		const text = await readSessionReplyText(input.client, input.sessionId);
+		body = text?.trim()
+			? text
+			: `Schedule "${schedule?.name ?? input.scheduleId}" completed, but no assistant reply text was found.`;
+	} else {
+		body = `Schedule "${schedule?.name ?? input.scheduleId}" ${input.status}.${input.errorMessage ? `\n\n${input.errorMessage}` : ""}`;
+	}
+	try {
+		await withSlackBindingBotToken({
+			slack: input.slack,
+			binding,
+			work: () => thread.post(body).then(() => undefined),
+		});
+	} catch (error) {
+		if (
+			isSlackInvalidThreadTsError(error) &&
+			clearSlackBinding(input.bindingsPath, deliveryThreadId)
+		) {
+			input.logger.core.log(
+				"Cleared stale Slack binding after invalid_thread_ts",
+				{
+					severity: "warn",
+					transport: "slack",
+					threadId: deliveryThreadId,
+					scheduleId: input.scheduleId,
+					executionId: input.executionId,
+				},
+			);
+		}
+		throw error;
+	}
+}
+
+class SlackConnector extends ConnectorBase<
+	ConnectSlackOptions,
+	SlackConnectorState
+> {
+	constructor() {
+		super(
+			"slack",
+			"Slack webhook/socket bridge backed by RPC runtime sessions",
+		);
+	}
+
+	protected override createCommand(): Command {
+		return super
+			.createCommand()
+			.usage("--base-url <PUBLIC_BASE_URL> [options]")
+			.option("--user-name <name>", "Slack bot username label")
+			.option(
+				"--bot-token <token>",
+				"Slack bot token for single-workspace mode",
+			)
+			.option("--signing-secret <secret>", "Slack signing secret")
+			.option("--app-token <token>", "Slack app-level token for socket mode")
+			.option("--client-id <id>", "Slack OAuth client id")
+			.option("--client-secret <secret>", "Slack OAuth client secret")
+			.option(
+				"--encryption-key <key>",
+				"Base64 32-byte key for encrypted installations",
+			)
+			.option(
+				"--installation-key-prefix <prefix>",
+				"Override stored installation key prefix",
+			)
+			.option("--provider <id>", "Provider override")
+			.option("--model <id>", "Model override")
+			.option("--api-key <key>", "Provider API key override")
+			.option("--system <prompt>", "System prompt override")
+			.option("--cwd <path>", "Workspace / cwd for runtime")
+			.option("--mode <act|plan>", "Agent mode", "act")
+			.option("-i, --interactive", "Keep connector in foreground")
+			.option("--enable-tools", "Enable tools for Slack sessions")
+			.option(
+				"--hook-command <command>",
+				"Run a shell command for connector events",
+			)
+			.option(
+				"--rpc-address <host:port>",
+				"RPC address",
+				process.env.CLINE_RPC_ADDRESS?.trim() || resolveDefaultCliRpcAddress(),
+			)
+			.option("--host <host>", "Webhook listen host")
+			.option("--port <port>", "Webhook listen port")
+			.option(
+				"--base-url <url>",
+				"Public base URL for webhooks and OAuth callback",
+			)
+			.addHelpText(
+				"after",
+				[
+					"",
+					"Environment:",
+					"  SLACK_BOT_TOKEN             Single-workspace bot token",
+					"  SLACK_SIGNING_SECRET        Slack signing secret",
+					"  SLACK_APP_TOKEN             App-level token for socket mode",
+					"  SLACK_CLIENT_ID             OAuth client id",
+					"  SLACK_CLIENT_SECRET         OAuth client secret",
+					"  SLACK_ENCRYPTION_KEY        Optional installation encryption key",
+				].join("\n"),
+			);
+	}
+
+	protected override readOptions(command: Command): ConnectSlackOptions {
+		const opts = command.opts<{
+			userName?: string;
+			botToken?: string;
+			signingSecret?: string;
+			appToken?: string;
+			clientId?: string;
+			clientSecret?: string;
+			encryptionKey?: string;
+			installationKeyPrefix?: string;
+			cwd?: string;
+			model?: string;
+			provider?: string;
+			apiKey?: string;
+			system?: string;
+			mode?: string;
+			interactive?: boolean;
+			enableTools?: boolean;
+			rpcAddress?: string;
+			hookCommand?: string;
+			port?: string;
+			host?: string;
+			baseUrl?: string;
+		}>();
+		const parsedPort =
+			this.parseOptionalInteger(opts.port, "port") ??
+			Number.parseInt(process.env.PORT ?? "8787", 10);
+		const port = Number.isFinite(parsedPort) ? parsedPort : 8787;
+		const baseUrl = opts.baseUrl?.trim() || process.env.BASE_URL?.trim();
+		const connectionMode = inferSlackConnectionMode(baseUrl);
+		const isSocketMode = connectionMode === "socket";
+		if (isSocketMode && (opts.clientId?.trim() || opts.clientSecret?.trim())) {
+			throw new Error(
+				"Slack socket mode does not support --client-id or --client-secret",
+			);
+		}
+		const botToken =
+			opts.botToken?.trim() || process.env.SLACK_BOT_TOKEN?.trim();
+		const appToken = isSocketMode
+			? opts.appToken?.trim() || process.env.SLACK_APP_TOKEN?.trim()
+			: undefined;
+		if (isSocketMode && !appToken) {
+			throw new Error(
+				"Slack socket mode requires --app-token or SLACK_APP_TOKEN",
+			);
+		}
+		if (isSocketMode && !botToken) {
+			throw new Error(
+				"Slack socket mode requires --bot-token or SLACK_BOT_TOKEN",
+			);
+		}
+		return {
+			userName:
+				opts.userName?.trim() ||
+				process.env.SLACK_BOT_USERNAME?.trim() ||
+				"cline-slack",
+			connectionMode,
+			botToken,
+			signingSecret:
+				connectionMode === "webhook"
+					? opts.signingSecret?.trim() ||
+						process.env.SLACK_SIGNING_SECRET?.trim()
+					: opts.signingSecret?.trim(),
+			appToken,
+			clientId:
+				connectionMode === "webhook"
+					? opts.clientId?.trim() || process.env.SLACK_CLIENT_ID?.trim()
+					: undefined,
+			clientSecret:
+				connectionMode === "webhook"
+					? opts.clientSecret?.trim() || process.env.SLACK_CLIENT_SECRET?.trim()
+					: undefined,
+			encryptionKey:
+				opts.encryptionKey?.trim() || process.env.SLACK_ENCRYPTION_KEY?.trim(),
+			installationKeyPrefix:
+				opts.installationKeyPrefix?.trim() ||
+				process.env.SLACK_INSTALLATION_KEY_PREFIX?.trim(),
+			cwd: opts.cwd || process.cwd(),
+			model: opts.model,
+			provider: opts.provider,
+			apiKey: opts.apiKey,
+			systemPrompt: opts.system,
+			mode: this.parseMode(opts.mode),
+			interactive: Boolean(opts.interactive),
+			enableTools: Boolean(opts.enableTools),
+			rpcAddress:
+				opts.rpcAddress?.trim() ||
+				process.env.CLINE_RPC_ADDRESS?.trim() ||
+				resolveDefaultCliRpcAddress(),
+			hookCommand:
+				opts.hookCommand?.trim() ||
+				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
+			port,
+			host: opts.host?.trim() || process.env.HOST?.trim() || "0.0.0.0",
+			baseUrl,
+		};
+	}
+
+	private resolveConnectorStatePath(userName: string): string {
+		return this.resolveConnectorPath(`${sanitizeKey(userName)}.json`);
+	}
+
+	private resolveBindingsPath(userName: string): string {
+		return this.resolveConnectorPath(`${sanitizeKey(userName)}.threads.json`);
+	}
+
+	private resolveStateStorePath(userName: string): string {
+		return this.resolveConnectorPath(`${sanitizeKey(userName)}.state.json`);
+	}
+
+	private listConnectorStatePaths(): string[] {
+		return this.listJsonStatePaths([".threads.json", ".state.json"]);
+	}
+
+	private readConnectorState(
+		statePath: string,
+	): SlackConnectorState | undefined {
+		return this.readStateFile(
+			statePath,
+			(value): value is SlackConnectorState =>
+				Boolean(
+					value &&
+						typeof value === "object" &&
+						typeof (value as SlackConnectorState).pid === "number" &&
+						typeof (value as SlackConnectorState).userName === "string",
+				),
+		);
+	}
+
+	private writeConnectorState(
+		statePath: string,
+		state: SlackConnectorState,
+	): void {
+		this.writeStateFile(statePath, state);
+	}
+
+	private async stopSlackConnectorInstance(
+		statePath: string,
+		io: ConnectIo,
+	): Promise<ConnectStopResult> {
+		return this.stopManagedProcess({
+			io,
+			statePath,
+			readState: (path) => this.readConnectorState(path),
+			describeStoppedProcess: (state) =>
+				`[slack] stopped pid=${state.pid} user=${state.userName}`,
+			getPid: (state) => state.pid,
+			stopSessions: stopSessionsForUser,
+			clearBindings: (state) => {
+				clearBindingSessionIds<SlackThreadState>(
+					this.resolveBindingsPath(state.userName),
+				);
+			},
+		});
+	}
+
+	override async stopAll(io: ConnectIo): Promise<ConnectStopResult> {
+		return this.stopAllFromStatePaths(
+			io,
+			this.listConnectorStatePaths(),
+			(statePath, stopIo) => this.stopSlackConnectorInstance(statePath, stopIo),
+		);
+	}
+
+	protected override async runWithOptions(
+		options: ConnectSlackOptions,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number> {
+		const statePath = this.resolveConnectorStatePath(options.userName);
+		const bindingsPath = this.resolveBindingsPath(options.userName);
+		const stateStorePath = this.resolveStateStorePath(options.userName);
+		const staleState = this.removeStaleState(
+			statePath,
+			(path) => this.readConnectorState(path),
+			(state) => state.pid,
+		);
+		if (staleState) {
+			clearBindingSessionIds<SlackThreadState>(bindingsPath);
+		}
+		if (
+			await this.maybeRunInBackground({
+				rawArgs,
+				io,
+				interactive: options.interactive,
+				childEnvVar: "CLINE_SLACK_CONNECT_CHILD",
+				statePath,
+				readState: (path) => this.readConnectorState(path),
+				isRunning: (state) => isProcessRunning(state.pid),
+				formatAlreadyRunningMessage: (state) =>
+					state.connectionMode === "socket"
+						? `[slack] connector already running pid=${state.pid} rpc=${state.rpcAddress} mode=socket`
+						: `[slack] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
+				formatBackgroundStartMessage: (pid) =>
+					`[slack] starting background connector pid=${pid} user=${options.userName} mode=${options.connectionMode}`,
+				foregroundHint:
+					"[slack] use `cline connect slack -i ...` to run in the foreground",
+				launchFailureMessage: "failed to launch Slack connector in background",
+			})
+		) {
+			return 0;
+		}
+
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "slack-connect",
+		});
+		const logger = createChatSdkLogger(loggerAdapter);
+		const consoleLogger = new ConsoleLogger("info", "slack-connect");
+		const slackConfig: Record<string, unknown> = {
+			logger: consoleLogger,
+			mode: options.connectionMode,
+			userName: options.userName,
+		};
+		if (options.botToken?.trim()) {
+			slackConfig.botToken = options.botToken.trim();
+		}
+		if (options.signingSecret?.trim()) {
+			slackConfig.signingSecret = options.signingSecret.trim();
+		}
+		if (options.appToken?.trim()) {
+			slackConfig.appToken = options.appToken.trim();
+		}
+		if (options.clientId?.trim()) {
+			slackConfig.clientId = options.clientId.trim();
+		}
+		if (options.clientSecret?.trim()) {
+			slackConfig.clientSecret = options.clientSecret.trim();
+		}
+		if (options.encryptionKey?.trim()) {
+			slackConfig.encryptionKey = options.encryptionKey.trim();
+		}
+		if (options.installationKeyPrefix?.trim()) {
+			slackConfig.installationKeyPrefix = options.installationKeyPrefix.trim();
+		}
+		const slack = createSlackAdapter(slackConfig) as SlackAdapter;
+		patchSlackMessageEventHandling(slack);
+		const bot = new Chat({
+			userName: options.userName,
+			adapters: { slack: slack as unknown as Adapter },
+			state: new FileStateAdapter(stateStorePath),
+			logger,
+			fallbackStreamingPlaceholderText: null,
+			streamingUpdateIntervalMs: 500,
+		}).registerSingleton();
+		const threadQueues = new Map<string, Promise<void>>();
+		const activeTurns = new Map<string, ActiveConnectorTurn>();
+		const pendingApprovals = new Map<string, PendingConnectorApproval>();
+		const startRequest = await buildSlackStartRequest(options, io, {
+			enabled: loggerAdapter.runtimeConfig.enabled,
+			level: loggerAdapter.runtimeConfig.level,
+			destination: loggerAdapter.runtimeConfig.destination,
+			bindings: {
+				transport: "slack",
+				userName: options.userName,
+			},
+		});
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { workspacePath: startRequest.cwd },
+			rules: { workspacePath: startRequest.cwd },
+			workflows: { workspacePath: startRequest.cwd },
+		});
+		await userInstructionService.start().catch(() => undefined);
+		const commandCwd = startRequest.cwd || process.cwd();
+		const { host: chatCommandHost } = await createWorkspaceChatCommandHost({
+			cwd: commandCwd,
+			workspaceRoot: startRequest.workspaceRoot || commandCwd,
+		});
+		const { url: rpcAddress, authToken: rpcAuthToken } =
+			await ensureCliHubServer(
+				startRequest.workspaceRoot || startRequest.cwd || process.cwd(),
+				parseHubEndpointOverride(options.rpcAddress),
+			);
+
+		const clientId = `slack-${process.pid}-${Date.now()}`;
+		const client = new HubSessionClient({
+			address: rpcAddress,
+			authToken: rpcAuthToken,
+			clientId,
+			clientType: "cli",
+			displayName: "slack connector",
+			workspaceRoot: startRequest.workspaceRoot || startRequest.cwd,
+			cwd: startRequest.cwd,
+			metadata: {
+				transport: "slack",
+				userName: options.userName,
+			},
+		});
+		await client.connect();
+		this.writeConnectorState(statePath, {
+			userName: options.userName,
+			connectionMode: options.connectionMode,
+			pid: process.pid,
+			rpcAddress,
+			...(options.connectionMode === "webhook"
+				? { port: options.port, baseUrl: options.baseUrl }
+				: {}),
+			startedAt: new Date().toISOString(),
+		});
+
+		let stopping = false;
+		let resolveStop: (() => void) | undefined;
+		const stopPromise = new Promise<void>((resolve) => {
+			resolveStop = resolve;
+		});
+		const requestStop = (_reason: string) => {
+			if (stopping) {
+				return;
+			}
+			stopping = true;
+			resolveStop?.();
+		};
+
+		const handleTurn = async (
+			thread: Thread<SlackThreadState>,
+			text: string,
+		) => {
+			const currentState = await loadThreadState(
+				thread,
+				bindingsPath,
+				startRequest,
+			);
+			const queueKey = thread.id;
+			const runTurn = async () => {
+				try {
+					await withSlackTeamBotToken({
+						slack,
+						teamId: currentState.teamId,
+						work: async () =>
+							handleConnectorUserTurn({
+								thread,
+								text,
+								client,
+								pendingApprovals,
+								baseStartRequest: startRequest,
+								explicitSystemPrompt:
+									options.systemPrompt?.trim() ||
+									getConnectorSystemPrompt("slack"),
+								clientId,
+								logger: loggerAdapter,
+								transport: "slack",
+								botUserName: options.userName,
+								requestStop,
+								bindingsPath,
+								hookCommand: options.hookCommand,
+								systemRules: SLACK_SYSTEM_RULES,
+								errorLabel: "Slack",
+								firstContactMessage: SLACK_FIRST_CONTACT_MESSAGE,
+								userInstructionService,
+								chatCommandHost,
+								activeTurns,
+								turnKey: queueKey,
+								getSessionMetadata: (
+									currentThread,
+									_clientId,
+									currentState,
+								) => ({
+									userName: options.userName,
+									slackThreadId: currentThread.id,
+									slackChannelId: currentThread.channelId,
+									...(currentState.participantKey
+										? { slackParticipantKey: currentState.participantKey }
+										: {}),
+									...(currentState.participantLabel
+										? { slackParticipantLabel: currentState.participantLabel }
+										: {}),
+								}),
+								reusedLogMessage: "Slack thread reusing RPC session",
+								startedLogMessage: "Slack thread started RPC session",
+								onMessageReceived: async (details) => {
+									await dispatchConnectorHook(
+										options.hookCommand,
+										{
+											adapter: "slack",
+											botUserName: options.userName,
+											event: "message.received",
+											payload: details,
+											ts: new Date().toISOString(),
+										},
+										loggerAdapter,
+									);
+								},
+								onReplyCompleted: async (result) => {
+									await dispatchConnectorHook(
+										options.hookCommand,
+										{
+											adapter: "slack",
+											botUserName: options.userName,
+											event: "message.completed",
+											payload: {
+												threadId: result.threadId,
+												sessionId: result.sessionId,
+												finishReason: result.finishReason,
+												iterations: result.iterations,
+												outputPreview: truncateText(result.text),
+												outputLength: result.text.length,
+											},
+											ts: new Date().toISOString(),
+										},
+										loggerAdapter,
+									);
+								},
+								onReplyFailed: async (details) => {
+									await dispatchConnectorHook(
+										options.hookCommand,
+										{
+											adapter: "slack",
+											botUserName: options.userName,
+											event: "message.failed",
+											payload: {
+												threadId: details.threadId,
+												sessionId: details.sessionId,
+												error: details.error.message,
+											},
+											ts: new Date().toISOString(),
+										},
+										loggerAdapter,
+									);
+								},
+							}),
+					});
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					await withSlackTeamBotToken({
+						slack,
+						teamId: currentState.teamId,
+						work: () => thread.post(`Slack bridge error: ${message}`),
+					});
+				}
+			};
+			if (activeTurns.has(queueKey)) {
+				await runTurn();
+				return;
+			}
+			await enqueueThreadTurn(threadQueues, queueKey, async () => {
+				await runTurn();
+			});
+		};
+
+		bot.onNewMention(async (thread, message) => {
+			const mentionThread = resolveSlackChannelMentionThread(thread, message);
+			await mentionThread.subscribe();
+			await persistSlackThreadContext({
+				thread: mentionThread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Slack",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread: mentionThread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Slack user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(mentionThread, message.text);
+		});
+
+		bot.onSubscribedMessage(async (thread, message) => {
+			await persistSlackThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Slack",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Slack user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		bot.onSlashCommand(async (event) => {
+			const commandText = [event.command.trim(), event.text.trim()]
+				.filter(Boolean)
+				.join(" ");
+			const rootMessage = await event.channel.post(
+				`${event.user.fullName} invoked ${commandText}`,
+			);
+			const thread = new ThreadImpl<SlackThreadState>({
+				adapterName: "slack",
+				channelId: event.channel.id,
+				id: rootMessage.threadId,
+				isDM: event.channel.isDM,
+				isSubscribedContext: true,
+			});
+			await thread.subscribe();
+			await persistSlackThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: event.raw,
+				errorLabel: "Slack",
+			});
+			await handleTurn(thread, commandText);
+		});
+
+		await bot.initialize();
+		const stopTaskUpdateStream =
+			startConnectorTaskUpdateRelay<SlackThreadState>({
+				client,
+				clientId,
+				bot,
+				logger: loggerAdapter,
+				bindingsPath,
+				transport: "slack",
+				postToThread: async ({ thread, binding, body, threadId }) => {
+					try {
+						await withSlackBindingBotToken({
+							slack,
+							binding,
+							work: () => thread.post(body).then(() => undefined),
+						});
+					} catch (error) {
+						if (
+							isSlackInvalidThreadTsError(error) &&
+							clearSlackBinding(bindingsPath, threadId)
+						) {
+							loggerAdapter.core.log(
+								"Cleared stale Slack binding after invalid_thread_ts",
+								{
+									severity: "warn",
+									transport: "slack",
+									threadId,
+								},
+							);
+						}
+						throw error;
+					}
+				},
+			});
+
+		let webhookUrl: string | undefined;
+		let oauthCallbackUrl: string | undefined;
+		const server =
+			options.connectionMode === "webhook"
+				? await (async () => {
+						const baseUrl = options.baseUrl?.trim();
+						if (!baseUrl) {
+							throw new Error(
+								"Slack webhook mode requires --base-url or BASE_URL",
+							);
+						}
+						webhookUrl = `${baseUrl.replace(/\/$/, "")}/api/webhooks/slack`;
+						oauthCallbackUrl = `${baseUrl.replace(/\/$/, "")}/api/oauth/slack/callback`;
+						return startConnectorWebhookServer({
+							host: options.host,
+							port: options.port,
+							routes: {
+								"/api/webhooks/slack": async (request) =>
+									bot.webhooks.slack(request),
+								"/api/oauth/slack/callback": async (request) => {
+									try {
+										const result = await slack.handleOAuthCallback(request);
+										return new Response(
+											`Slack installation stored for team ${result.teamId}. You can return to Slack.`,
+										);
+									} catch (error) {
+										const message =
+											error instanceof Error ? error.message : String(error);
+										loggerAdapter.core.log("Slack OAuth callback failed", {
+											severity: "warn",
+											transport: "slack",
+											error: message,
+										});
+										return new Response(`Slack OAuth error: ${message}`, {
+											status: 500,
+										});
+									}
+								},
+								"/health": () => new Response("ok"),
+								"/": () =>
+									new Response(
+										[
+											"Slack connector is running.",
+											"Connection mode: webhook",
+											`Webhook URL: ${webhookUrl}`,
+											`OAuth callback URL: ${oauthCallbackUrl}`,
+											options.botToken?.trim()
+												? "Auth mode: single workspace"
+												: options.clientId?.trim() &&
+														options.clientSecret?.trim()
+													? "Auth mode: multi-workspace OAuth"
+													: "Auth mode: incomplete (set bot token or OAuth credentials)",
+										].join("\n"),
+									),
+							},
+						});
+					})()
+				: undefined;
+
+		const stopEventStream = client.streamEvents(
+			{ clientId: `${clientId}-server-events` },
+			{
+				onEvent: (event) => {
+					if (event.eventType === "rpc.server.shutting_down") {
+						requestStop("rpc_server_shutting_down");
+						return;
+					}
+					if (
+						event.eventType !== "schedule.execution.completed" &&
+						event.eventType !== "schedule.execution.failed"
+					) {
+						return;
+					}
+					const scheduleId =
+						typeof event.payload.scheduleId === "string"
+							? event.payload.scheduleId.trim()
+							: "";
+					const executionId =
+						typeof event.payload.executionId === "string"
+							? event.payload.executionId.trim()
+							: "";
+					const sessionId =
+						typeof event.payload.sessionId === "string"
+							? event.payload.sessionId.trim()
+							: undefined;
+					const status =
+						typeof event.payload.status === "string"
+							? event.payload.status.trim()
+							: "";
+					const errorMessage =
+						typeof event.payload.errorMessage === "string"
+							? event.payload.errorMessage
+							: undefined;
+					if (!scheduleId || !executionId || !status) {
+						return;
+					}
+					void deliverScheduledResult({
+						bot,
+						slack,
+						client,
+						logger: loggerAdapter,
+						bindingsPath,
+						userName: options.userName,
+						scheduleId,
+						executionId,
+						sessionId,
+						status,
+						errorMessage,
+						hookCommand: options.hookCommand,
+					});
+				},
+				onError: () => {
+					requestStop("rpc_server_event_stream_failed");
+				},
+			},
+		);
+
+		process.once("SIGINT", () => requestStop("sigint"));
+		process.once("SIGTERM", () => requestStop("sigterm"));
+
+		if (options.connectionMode === "webhook") {
+			io.writeln(`[slack] listening on ${options.host}:${options.port}`);
+			io.writeln(`[slack] configure Slack webhook URL: ${webhookUrl}`);
+			io.writeln(
+				`[slack] configure Slack OAuth callback URL: ${oauthCallbackUrl}`,
+			);
+		} else {
+			io.writeln("[slack] socket mode connected");
+		}
+
+		await stopPromise;
+		clearBindingSessionIds<SlackThreadState>(bindingsPath);
+		stopTaskUpdateStream();
+		stopEventStream();
+		await server?.close();
+		await bot.shutdown();
+		userInstructionService.stop();
+		client.close();
+		this.removeStateFile(statePath);
+		return 0;
+	}
+}
+
+export const slackConnector: ConnectCommandDefinition = new SlackConnector();
+
+export const __test__ = {
+	inferSlackConnectionMode,
+	buildSlackParticipantKey,
+	resolveSlackParticipant,
+	normalizeSlackMessageEventChannelType,
+	resolveSlackChannelMentionThread,
+	withSlackTeamBotToken,
+	isSlackInvalidThreadTsError,
+	findBindingForThread: (
+		bindings: ConnectorBindingStore<SlackThreadState>,
+		thread: Pick<Thread<SlackThreadState>, "id" | "channelId" | "isDM"> & {
+			participantKey?: string;
+		},
+	) => findBindingForThread(bindings, thread),
+};
diff --git a/apps/cli/src/connectors/adapters/telegram-format.test.ts b/apps/cli/src/connectors/adapters/telegram-format.test.ts
new file mode 100644
index 0000000..3896735
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/telegram-format.test.ts
@@ -0,0 +1,236 @@
+import type { SentMessage, Thread } from "chat";
+import { describe, expect, it, vi } from "vitest";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import type { ConnectorThreadState } from "../thread-bindings";
+import {
+	buildTelegramFormattedPayload,
+	buildTelegramFormattedPayloads,
+	parseTelegramThreadId,
+	postTelegramFormattedReply,
+} from "./telegram-format";
+
+function createLogger() {
+	return {
+		core: {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		},
+	} as unknown as CliLoggerAdapter;
+}
+
+function createThread(id = "telegram:123") {
+	const posts: unknown[] = [];
+	const thread = {
+		id,
+		post: vi.fn(async (message: unknown) => {
+			posts.push(message);
+			return {} as SentMessage;
+		}),
+	} as unknown as Thread<ConnectorThreadState>;
+	return { thread, posts };
+}
+
+describe("telegram formatted replies", () => {
+	it("parses Telegram thread IDs with optional topic IDs", () => {
+		expect(parseTelegramThreadId("telegram:123")).toEqual({ chatId: "123" });
+		expect(parseTelegramThreadId("telegram:-100123:7")).toEqual({
+			chatId: "-100123",
+			messageThreadId: 7,
+		});
+		expect(parseTelegramThreadId("123")).toEqual({ chatId: "123" });
+	});
+
+	it("builds entity payloads without Telegram parse_mode", () => {
+		const payload = buildTelegramFormattedPayload(
+			"telegram:123:9",
+			"**Bold** and `code` plus [link](https://example.com)",
+		);
+
+		expect(payload).toEqual({
+			chat_id: "123",
+			message_thread_id: 9,
+			text: "Bold and code plus link",
+			link_preview_options: { is_disabled: true },
+			entities: [
+				{ type: "bold", offset: 0, length: 4 },
+				{ type: "code", offset: 9, length: 4 },
+				{
+					type: "text_link",
+					offset: 19,
+					length: 4,
+					url: "https://example.com",
+				},
+			],
+		});
+		expect(payload).not.toHaveProperty("parse_mode");
+	});
+
+	it("leaves malformed markdown as plain text instead of throwing", () => {
+		const payload = buildTelegramFormattedPayload(
+			"telegram:123",
+			"Your repo is called **`",
+		);
+
+		expect(payload).toEqual({
+			chat_id: "123",
+			text: "Your repo is called **`",
+			link_preview_options: { is_disabled: true },
+		});
+	});
+
+	it("preserves fenced code as Telegram pre entities", () => {
+		const payload = buildTelegramFormattedPayload(
+			"telegram:123",
+			"```ts\nconst x = 1\n```",
+		);
+
+		expect(payload).toEqual({
+			chat_id: "123",
+			text: "const x = 1",
+			link_preview_options: { is_disabled: true },
+			entities: [{ type: "pre", offset: 0, length: 11, language: "ts" }],
+		});
+	});
+
+	it("chunks long formatted replies without dropping text", () => {
+		const longText = `${"a".repeat(4096)}${"b".repeat(10)}`;
+		const payloads = buildTelegramFormattedPayloads("telegram:123", longText);
+
+		expect(payloads).toHaveLength(2);
+		expect(payloads[0]?.text).toHaveLength(4096);
+		expect(payloads[1]?.text).toBe("b".repeat(10));
+		expect(payloads.map((payload) => payload.text).join("")).toBe(longText);
+	});
+
+	it("splits formatting entities across long reply chunks", () => {
+		const payloads = buildTelegramFormattedPayloads(
+			"telegram:123",
+			`**${"a".repeat(4096)}${"b".repeat(10)}**`,
+		);
+
+		expect(payloads).toHaveLength(2);
+		expect(payloads[0]?.entities).toEqual([
+			{ type: "bold", offset: 0, length: 4096 },
+		]);
+		expect(payloads[1]?.entities).toEqual([
+			{ type: "bold", offset: 0, length: 10 },
+		]);
+		expect(payloads.map((payload) => payload.text).join("")).toBe(
+			`${"a".repeat(4096)}${"b".repeat(10)}`,
+		);
+	});
+
+	it("sends formatted replies directly through Telegram entities", async () => {
+		const { thread } = createThread("telegram:123");
+		const fetchImpl = vi.fn(async (_url: string | URL, init?: RequestInit) => {
+			expect(JSON.parse(String(init?.body))).toEqual({
+				chat_id: "123",
+				text: "Bold",
+				link_preview_options: { is_disabled: true },
+				entities: [{ type: "bold", offset: 0, length: 4 }],
+			});
+			return new Response(JSON.stringify({ ok: true, result: {} }), {
+				status: 200,
+			});
+		});
+
+		await postTelegramFormattedReply({
+			thread,
+			text: "**Bold**",
+			botToken: "token",
+			logger: createLogger(),
+			fetchImpl,
+		});
+
+		expect(fetchImpl).toHaveBeenCalledWith(
+			"https://api.telegram.org/bottoken/sendMessage",
+			expect.objectContaining({
+				method: "POST",
+				headers: { "content-type": "application/json" },
+			}),
+		);
+		expect(thread.post).not.toHaveBeenCalled();
+	});
+
+	it("sends long formatted replies as multiple Telegram messages", async () => {
+		const { thread } = createThread("telegram:123");
+		const text = `${"a".repeat(4096)}tail`;
+		const fetchImpl = vi.fn(async (_url: string | URL, _init?: RequestInit) => {
+			return new Response(JSON.stringify({ ok: true, result: {} }), {
+				status: 200,
+			});
+		});
+
+		await postTelegramFormattedReply({
+			thread,
+			text,
+			botToken: "token",
+			logger: createLogger(),
+			fetchImpl,
+		});
+
+		const bodies = fetchImpl.mock.calls.map(([, init]) =>
+			JSON.parse(String((init as RequestInit | undefined)?.body)),
+		);
+		expect(bodies.map((body) => body.text).join("")).toBe(text);
+		expect(bodies).toHaveLength(2);
+		expect(thread.post).not.toHaveBeenCalled();
+	});
+
+	it("falls back to raw text when formatted send fails", async () => {
+		const { thread, posts } = createThread("telegram:123");
+		const logger = createLogger();
+
+		await postTelegramFormattedReply({
+			thread,
+			text: "Bad **` markdown",
+			botToken: "token",
+			logger,
+			fetchImpl: vi.fn(
+				async () =>
+					new Response(
+						JSON.stringify({
+							ok: false,
+							description: "Bad Request: can't parse entities",
+						}),
+						{ status: 400, statusText: "Bad Request" },
+					),
+			),
+		});
+
+		expect(posts).toEqual([{ raw: "Bad **` markdown" }]);
+		expect(logger.core.log).toHaveBeenCalledWith(
+			"Telegram formatted reply failed; falling back",
+			expect.objectContaining({
+				severity: "warn",
+				transport: "telegram",
+				threadId: "telegram:123",
+			}),
+		);
+	});
+
+	it("chunks raw fallback text when formatted send fails", async () => {
+		const { thread, posts } = createThread("telegram:123");
+		const longText = `${"x".repeat(4096)}tail`;
+
+		await postTelegramFormattedReply({
+			thread,
+			text: longText,
+			botToken: "token",
+			logger: createLogger(),
+			fetchImpl: vi.fn(
+				async () =>
+					new Response(
+						JSON.stringify({
+							ok: false,
+							description: "Bad Request: can't parse entities",
+						}),
+						{ status: 400, statusText: "Bad Request" },
+					),
+			),
+		});
+
+		expect(posts).toEqual([{ raw: "x".repeat(4096) }, { raw: "tail" }]);
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/telegram-format.ts b/apps/cli/src/connectors/adapters/telegram-format.ts
new file mode 100644
index 0000000..0748b28
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/telegram-format.ts
@@ -0,0 +1,265 @@
+import { markdownToFormattable } from "@gramio/format/markdown";
+import type { Thread } from "chat";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import type { ConnectorThreadState } from "../thread-bindings";
+
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+
+type TelegramMessageEntity = {
+	type: string;
+	offset: number;
+	length: number;
+	url?: string;
+	language?: string;
+	custom_emoji_id?: string;
+};
+
+type TelegramThreadId = {
+	chatId: string;
+	messageThreadId?: number;
+};
+
+type TelegramSendMessagePayload = {
+	chat_id: string;
+	message_thread_id?: number;
+	text: string;
+	entities?: TelegramMessageEntity[];
+	link_preview_options: {
+		is_disabled: true;
+	};
+};
+
+type TelegramApiResponse = {
+	ok?: boolean;
+	description?: string;
+	result?: unknown;
+};
+
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+
+function trimTrailingSlashes(value: string): string {
+	let end = value.length;
+	while (end > 0 && value[end - 1] === "/") {
+		end -= 1;
+	}
+	return value.slice(0, end);
+}
+
+function normalizeTelegramText(text: string): string {
+	return text.trim() ? text : " ";
+}
+
+export function parseTelegramThreadId(threadId: string): TelegramThreadId {
+	if (!threadId.startsWith("telegram:")) {
+		return { chatId: threadId };
+	}
+	const parts = threadId.split(":");
+	if (parts.length < 2 || parts.length > 3 || !parts[1]) {
+		throw new Error(`Invalid Telegram thread ID: ${threadId}`);
+	}
+	const messageThreadPart = parts[2];
+	if (!messageThreadPart) {
+		return { chatId: parts[1] };
+	}
+	const messageThreadId = Number.parseInt(messageThreadPart, 10);
+	if (!Number.isFinite(messageThreadId)) {
+		throw new Error(`Invalid Telegram thread topic ID: ${threadId}`);
+	}
+	return { chatId: parts[1], messageThreadId };
+}
+
+function validEntityForText(
+	entity: TelegramMessageEntity,
+	maxTextLength: number,
+): boolean {
+	return (
+		typeof entity.type === "string" &&
+		Number.isFinite(entity.offset) &&
+		Number.isFinite(entity.length) &&
+		entity.offset >= 0 &&
+		entity.length > 0 &&
+		entity.offset + entity.length <= maxTextLength
+	);
+}
+
+function chunkFormattedMessage(
+	text: string,
+	entities: TelegramMessageEntity[],
+): Array<{ text: string; entities: TelegramMessageEntity[] }> {
+	if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
+		return [
+			{
+				text,
+				entities: entities.filter((entity) =>
+					validEntityForText(entity, text.length),
+				),
+			},
+		];
+	}
+	const chunks: Array<{ text: string; entities: TelegramMessageEntity[] }> = [];
+	for (
+		let startOffset = 0;
+		startOffset < text.length;
+		startOffset += TELEGRAM_MESSAGE_LIMIT
+	) {
+		const endOffset = Math.min(
+			startOffset + TELEGRAM_MESSAGE_LIMIT,
+			text.length,
+		);
+		const chunkText = text.slice(startOffset, endOffset);
+		const chunkEntities = entities
+			.map((entity) => {
+				const entityStart = entity.offset;
+				const entityEnd = entity.offset + entity.length;
+				const overlapStart = Math.max(entityStart, startOffset);
+				const overlapEnd = Math.min(entityEnd, endOffset);
+				if (overlapStart >= overlapEnd) {
+					return undefined;
+				}
+				return {
+					...entity,
+					offset: overlapStart - startOffset,
+					length: overlapEnd - overlapStart,
+				};
+			})
+			.filter((entity): entity is TelegramMessageEntity =>
+				Boolean(entity && validEntityForText(entity, chunkText.length)),
+			);
+		chunks.push({ text: chunkText, entities: chunkEntities });
+	}
+	return chunks;
+}
+
+function buildTelegramSendPayload(
+	threadId: string,
+	text: string,
+	entities: TelegramMessageEntity[],
+): TelegramSendMessagePayload {
+	const parsedThread = parseTelegramThreadId(threadId);
+	const body = normalizeTelegramText(text);
+	return {
+		chat_id: parsedThread.chatId,
+		...(parsedThread.messageThreadId !== undefined
+			? { message_thread_id: parsedThread.messageThreadId }
+			: {}),
+		text: body,
+		...(entities.length > 0 ? { entities } : {}),
+		link_preview_options: { is_disabled: true },
+	};
+}
+
+export function buildTelegramFormattedPayloads(
+	threadId: string,
+	text: string,
+): TelegramSendMessagePayload[] {
+	const formatted = markdownToFormattable(normalizeTelegramText(text));
+	const chunks = chunkFormattedMessage(
+		formatted.text,
+		formatted.entities as TelegramMessageEntity[],
+	);
+	return chunks.map((chunk) =>
+		buildTelegramSendPayload(threadId, chunk.text, chunk.entities),
+	);
+}
+
+export function buildTelegramFormattedPayload(
+	threadId: string,
+	text: string,
+): TelegramSendMessagePayload {
+	return (
+		buildTelegramFormattedPayloads(threadId, text)[0] ?? {
+			chat_id: parseTelegramThreadId(threadId).chatId,
+			text: " ",
+			link_preview_options: { is_disabled: true },
+		}
+	);
+}
+
+function describeTelegramApiFailure(
+	response: Response,
+	body: string,
+	parsed: TelegramApiResponse | undefined,
+): string {
+	const detail = parsed?.description || body.trim().slice(0, 240);
+	return detail
+		? `Telegram sendMessage failed (${response.status} ${response.statusText}): ${detail}`
+		: `Telegram sendMessage failed (${response.status} ${response.statusText})`;
+}
+
+async function readTelegramApiResponse(
+	response: Response,
+): Promise<TelegramApiResponse | undefined> {
+	const text = await response.text();
+	try {
+		const parsed = JSON.parse(text) as TelegramApiResponse;
+		if (!response.ok || parsed.ok !== true) {
+			throw new Error(describeTelegramApiFailure(response, text, parsed));
+		}
+		return parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) {
+			throw new Error(describeTelegramApiFailure(response, text, undefined));
+		}
+		throw error;
+	}
+}
+
+export async function postTelegramFormattedReply<
+	TState extends ConnectorThreadState,
+>(input: {
+	thread: Thread<TState>;
+	text: string;
+	botToken: string;
+	logger: CliLoggerAdapter;
+	apiBaseUrl?: string;
+	fetchImpl?: FetchLike;
+}): Promise<void> {
+	const fetchImpl = input.fetchImpl ?? fetch;
+	let payloads: TelegramSendMessagePayload[] = [];
+	let sentPayloadCount = 0;
+	try {
+		payloads = buildTelegramFormattedPayloads(input.thread.id, input.text);
+		const apiBaseUrl = trimTrailingSlashes(
+			input.apiBaseUrl?.trim() || TELEGRAM_API_BASE,
+		);
+		for (const payload of payloads) {
+			const response = await fetchImpl(
+				`${apiBaseUrl}/bot${input.botToken}/sendMessage`,
+				{
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify(payload),
+				},
+			);
+			await readTelegramApiResponse(response);
+			sentPayloadCount += 1;
+		}
+	} catch (error) {
+		input.logger.core.log("Telegram formatted reply failed; falling back", {
+			severity: "warn",
+			transport: "telegram",
+			threadId: input.thread.id,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		const remainingText =
+			sentPayloadCount > 0
+				? payloads
+						.slice(sentPayloadCount)
+						.map((payload) => payload.text)
+						.join("")
+				: input.text;
+		for (const chunk of chunkTelegramRawText(remainingText)) {
+			await input.thread.post({ raw: chunk });
+		}
+	}
+}
+
+function chunkTelegramRawText(text: string): string[] {
+	const body = normalizeTelegramText(text);
+	const chunks: string[] = [];
+	for (let index = 0; index < body.length; index += TELEGRAM_MESSAGE_LIMIT) {
+		chunks.push(body.slice(index, index + TELEGRAM_MESSAGE_LIMIT));
+	}
+	return chunks.length > 0 ? chunks : [" "];
+}
diff --git a/apps/cli/src/connectors/adapters/telegram.md b/apps/cli/src/connectors/adapters/telegram.md
new file mode 100644
index 0000000..fcaa285
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/telegram.md
@@ -0,0 +1,133 @@
+# Telegram Connector
+
+The Telegram connector bridges a Telegram Bot API bot into Cline CLI sessions. It is a polling connector, so it does not need a public webhook URL. The connector process must stay running while Telegram access is active.
+
+## Setup
+
+Create a bot with `@BotFather`:
+
+1. Open Telegram and start a chat with `@BotFather`.
+2. Send `/newbot` and follow the prompts.
+3. Copy the bot token. Treat it like a password.
+
+Start the connector:
+
+```bash
+cline connect telegram -k "$TELEGRAM_BOT_TOKEN"
+```
+
+The connector discovers the bot username from the token. Use `--bot-username`
+only if you need to override it.
+
+Useful variants:
+
+```bash
+# Keep logs in the active terminal while debugging.
+cline connect telegram -i -k "$TELEGRAM_BOT_TOKEN"
+
+# Read credentials from env vars.
+TELEGRAM_BOT_TOKEN=123456:ABCDEF... cline connect telegram
+
+# Override the workspace and model used for Telegram sessions.
+cline connect telegram -k "$TELEGRAM_BOT_TOKEN" --cwd /path/to/repo --provider cline --model openai/gpt-5.3-codex
+
+# Disable tools for untrusted Telegram surfaces.
+cline connect telegram -k "$TELEGRAM_BOT_TOKEN" --no-tools
+
+# Stop Telegram connector processes and sessions.
+cline connect --stop telegram
+```
+
+After the connector starts, send `/help` or `/start` to the bot in Telegram.
+
+## What It Does
+
+- Starts or reuses a Cline RPC-backed session for each Telegram thread.
+- Keeps chat history and working-directory state separately per Telegram thread.
+- Lets Telegram users ask questions, assign coding tasks, and, when tools are enabled, inspect files, edit files, run commands, and prepare PRs.
+- Supports required tool approvals from Telegram with `Y` and `N` replies.
+- Can deliver scheduled run results back to a Telegram thread when the connector is running.
+
+## Chat Commands
+
+The Telegram connector uses the shared connector command parser:
+
+- `/help` or `/start` - show connector help
+- `/new` or `/clear` - start a fresh session for the current thread
+- `/whereami` - show thread, cwd, tools, and yolo state
+- `/tools [on|off|toggle]` - allow or block repo/file/shell tools
+- `/yolo [on|off|toggle]` - auto-approve tool use
+- `/cwd <path>` - change working directory
+- `/schedule create/list/trigger/delete` - manage scheduled workflows
+- `/abort` - stop the current task
+- `/exit` - stop the connector
+
+In Telegram groups, bot-addressed commands such as `/help@my_bot` are normalized only when the suffix matches the configured bot username. Commands addressed to another bot are left unmatched.
+
+## Tools And Access
+
+Tools are enabled by default for Telegram sessions. That means anyone who can successfully message the bot may be able to ask it to inspect or change the configured workspace.
+
+Use `--no-tools` when the Telegram surface is not trusted:
+
+```bash
+cline connect telegram -k "$TELEGRAM_BOT_TOKEN" --no-tools
+```
+
+When the connector starts with `--no-tools`, chat commands such as `/tools on` and `/yolo on` cannot re-enable tools for that connector run.
+
+For participant restrictions, run the interactive connector wizard with `cline connect`. The Telegram wizard asks whether to restrict access, points you to `@userinfobot`, and configures your numeric Telegram user ID.
+
+You can also pass the user ID directly:
+
+```bash
+cline connect telegram -k "$TELEGRAM_BOT_TOKEN" --allowed-user-id 12345
+```
+
+You can also pass a manual `--hook-command` that returns `{"action":"deny"}` for unauthorized `session.authorize` events. If neither access option is configured, messages are allowed.
+
+## Message Delivery
+
+Telegram final assistant replies are sent directly through Telegram `sendMessage` payloads with message entities. This avoids Telegram markdown parse failures for raw model text. If entity sending fails, the connector falls back to raw text.
+
+Long final assistant replies are split across Telegram messages. Tool/status updates and scheduled delivery messages use the adapter's raw thread posting path.
+
+Telegram final assistant replies are sent after the runtime turn completes. Google Chat and WhatsApp use the shared connector runtime streaming path for incremental assistant text.
+
+## Scheduled Delivery
+
+To deliver a scheduled run result back to Telegram, create the schedule from the Telegram chat when possible:
+
+1. Start the Telegram connector.
+2. Send a schedule command in Telegram:
+
+```text
+/schedule create "Daily summary" --cron "0 9 * * *" --prompt "Summarize yesterday's activity in this workspace."
+```
+
+Schedules created this way automatically target the current Telegram thread for delivery. You can also use `/schedule list`, `/schedule trigger <schedule-id>`, and `/schedule delete <schedule-id>` from Telegram.
+
+If you are creating the schedule outside Telegram, first send `/whereami` in Telegram to get the thread id, then pass the delivery metadata to the CLI:
+
+```bash
+cline schedule create "Daily summary" \
+  --cron "0 9 * * *" \
+  --prompt "Summarize yesterday's activity in this workspace." \
+  --workspace /path/to/repo \
+  --delivery-adapter telegram \
+  --delivery-bot my_bot \
+  --delivery-thread telegram:123456789
+```
+
+`--delivery-bot` is still supported after token-only connector setup. Use
+the Telegram bot username shown by `/whereami` as `deliveryUserName` when you
+need to target one specific Telegram connector, or omit the flag when the
+schedule does not need to be restricted to a specific bot.
+
+The connector must be running when the scheduled result is delivered, and the target thread must have an existing thread binding.
+
+## Limitations
+
+- The connector is not hosted by Telegram. It is a local CLI process polling Telegram, so it stops working if the machine or connector process is offline.
+- The current documented surface is text prompts and command replies. Media-specific Telegram workflows are not part of this connector contract.
+- Telegram group message delivery still depends on Telegram bot settings and which events the Bot API delivers to the adapter.
diff --git a/apps/cli/src/connectors/adapters/telegram.test.ts b/apps/cli/src/connectors/adapters/telegram.test.ts
new file mode 100644
index 0000000..e9f601c
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/telegram.test.ts
@@ -0,0 +1,394 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ConnectTelegramOptions } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { __test__, telegramConnector } from "./telegram";
+
+const parseTelegramArgs = (rawArgs: string[]): ConnectTelegramOptions =>
+	(
+		telegramConnector as unknown as {
+			parseArgs(rawArgs: string[]): ConnectTelegramOptions;
+		}
+	).parseArgs(rawArgs);
+
+const originalClineDataDir = process.env.CLINE_DATA_DIR;
+const tempDataDirs: string[] = [];
+
+function useTempClineDataDir(): string {
+	const dataDir = mkdtempSync(join(tmpdir(), "cline-telegram-test-"));
+	tempDataDirs.push(dataDir);
+	process.env.CLINE_DATA_DIR = dataDir;
+	return dataDir;
+}
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+	if (originalClineDataDir === undefined) {
+		delete process.env.CLINE_DATA_DIR;
+	} else {
+		process.env.CLINE_DATA_DIR = originalClineDataDir;
+	}
+	for (const dir of tempDataDirs.splice(0)) {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+describe("telegramConnector", () => {
+	it("honors --no-tools", () => {
+		const options = parseTelegramArgs([
+			"--bot-username",
+			"test_bot",
+			"--bot-token",
+			"123:test",
+			"--cwd",
+			"/tmp/work",
+			"--no-tools",
+		]);
+
+		expect(options.enableTools).toBe(false);
+	});
+
+	it("enables tools by default", () => {
+		const options = parseTelegramArgs([
+			"--bot-username",
+			"test_bot",
+			"--bot-token",
+			"123:test",
+			"--cwd",
+			"/tmp/work",
+		]);
+
+		expect(options.enableTools).toBe(true);
+	});
+
+	it("builds an authorization hook from --allowed-user-id", () => {
+		const options = parseTelegramArgs([
+			"--bot-token",
+			"123:test",
+			"--cwd",
+			"/tmp/work",
+			"--allowed-user-id",
+			"1201547643",
+		]);
+
+		expect(options.hookCommand).toBe(
+			`jq -r ".payload.actor.participantKey" | grep -qx "telegram:id:1201547643" && echo '{"action":"allow"}' || echo '{"action":"deny","message":"unauthorized","reason":"not_on_allowlist"}'`,
+		);
+	});
+
+	it("rejects unsafe --allowed-user-id values", () => {
+		expect(() =>
+			parseTelegramArgs([
+				"--bot-token",
+				"123:test",
+				"--cwd",
+				"/tmp/work",
+				"--allowed-user-id",
+				"123; rm -rf /",
+			]),
+		).toThrow("digits only");
+	});
+
+	it("rejects mixing --allowed-user-id with --hook-command", () => {
+		expect(() =>
+			parseTelegramArgs([
+				"--bot-token",
+				"123:test",
+				"--cwd",
+				"/tmp/work",
+				"--allowed-user-id",
+				"1201547643",
+				"--hook-command",
+				"echo noop",
+			]),
+		).toThrow("either --allowed-user-id or --hook-command");
+	});
+
+	it("rejects mixing --allowed-user-id with the hook command env var", () => {
+		const originalHookCommand = process.env.CLINE_CONNECT_HOOK_COMMAND;
+		process.env.CLINE_CONNECT_HOOK_COMMAND = "echo noop";
+		try {
+			expect(() =>
+				parseTelegramArgs([
+					"--bot-token",
+					"123:test",
+					"--cwd",
+					"/tmp/work",
+					"--allowed-user-id",
+					"1201547643",
+				]),
+			).toThrow("either --allowed-user-id or --hook-command");
+		} finally {
+			if (originalHookCommand === undefined) {
+				delete process.env.CLINE_CONNECT_HOOK_COMMAND;
+			} else {
+				process.env.CLINE_CONNECT_HOOK_COMMAND = originalHookCommand;
+			}
+		}
+	});
+
+	it("does not require the bot username", () => {
+		const options = parseTelegramArgs([
+			"--bot-token",
+			"123:test",
+			"--cwd",
+			"/tmp/work",
+		]);
+
+		expect(options.botUsername).toBeUndefined();
+		expect(options.botToken).toBe("123:test");
+	});
+
+	it("normalizes an explicit bot username", () => {
+		const options = parseTelegramArgs([
+			"--bot-username",
+			"  @test_bot  ",
+			"--bot-token",
+			"123:test",
+			"--cwd",
+			"/tmp/work",
+		]);
+
+		expect(options.botUsername).toBe("test_bot");
+	});
+
+	it("does not call getMe when the token-only connector is already running", async () => {
+		const dataDir = useTempClineDataDir();
+		const connectorDir = join(dataDir, "connectors", "telegram");
+		mkdirSync(connectorDir, { recursive: true });
+		writeFileSync(
+			join(connectorDir, "resolved_bot.json"),
+			JSON.stringify({
+				botUsername: "resolved_bot",
+				botId: "123",
+				pid: process.pid,
+				rpcAddress: "127.0.0.1:54321",
+				startedAt: new Date().toISOString(),
+			}),
+		);
+		const fetchImpl = vi.fn(async () => {
+			throw new Error("unexpected getMe call");
+		});
+		vi.stubGlobal("fetch", fetchImpl);
+		const output: string[] = [];
+		const errors: string[] = [];
+
+		await expect(
+			telegramConnector.run(["--bot-token", "123:test", "--cwd", "/tmp/work"], {
+				writeln: (text = "") => output.push(text),
+				writeErr: (text) => errors.push(text),
+			}),
+		).resolves.toBe(0);
+
+		expect(fetchImpl).not.toHaveBeenCalled();
+		expect(errors).toEqual([]);
+		expect(output).toEqual([
+			`[telegram] connector already running pid=${process.pid} rpc=127.0.0.1:54321`,
+		]);
+	});
+});
+
+describe("telegram bot username resolution", () => {
+	it("reads the public Telegram bot id from a token", () => {
+		expect(__test__.readTelegramBotId("123456:secret")).toBe("123456");
+		expect(__test__.readTelegramBotId("not-a-token")).toBeUndefined();
+	});
+
+	it("uses the configured username without calling Telegram", async () => {
+		const fetchImpl = vi.fn(async () => {
+			throw new Error("unexpected fetch");
+		});
+
+		await expect(
+			__test__.resolveTelegramBotUsername(
+				{
+					botToken: "123:test",
+					botUsername: "@configured_bot",
+					cwd: "/tmp/work",
+					mode: "act",
+					interactive: true,
+					enableTools: true,
+					rpcAddress: "127.0.0.1:0",
+				},
+				fetchImpl,
+			),
+		).resolves.toBe("configured_bot");
+		expect(fetchImpl).not.toHaveBeenCalled();
+	});
+
+	it("fetches the username from Telegram getMe when omitted", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response(
+				JSON.stringify({
+					ok: true,
+					result: { username: "resolved_bot" },
+				}),
+			);
+		});
+
+		await expect(
+			__test__.fetchTelegramBotUsername("123:test", fetchImpl),
+		).resolves.toBe("resolved_bot");
+		expect(fetchImpl).toHaveBeenCalledWith(
+			"https://api.telegram.org/bot123:test/getMe",
+		);
+	});
+
+	it("surfaces Telegram getMe failures", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response(
+				JSON.stringify({
+					ok: false,
+					description: "Unauthorized",
+				}),
+				{ status: 401, statusText: "Unauthorized" },
+			);
+		});
+
+		await expect(
+			__test__.fetchTelegramBotUsername("bad-token", fetchImpl),
+		).rejects.toThrow("Telegram getMe failed");
+	});
+});
+
+describe("telegram participant resolution", () => {
+	it("uses the stable numeric Telegram user id when username is also present", () => {
+		const result = __test__.resolveTelegramParticipant({
+			message: {
+				from: {
+					id: 1201547643,
+					username: "AraFatKatze",
+					first_name: "Ara",
+				},
+			},
+		});
+
+		expect(result).toEqual({
+			key: "telegram:id:1201547643",
+			label: "arafatkatze",
+		});
+	});
+
+	it("falls back to username when Telegram does not provide a numeric user id", () => {
+		const result = __test__.resolveTelegramParticipant({
+			message: {
+				from: {
+					username: "Alice",
+				},
+			},
+		});
+
+		expect(result).toEqual({
+			key: "telegram:user:alice",
+			label: "alice",
+		});
+	});
+
+	it("accepts string numeric user ids from raw Telegram payloads", () => {
+		const result = __test__.resolveTelegramParticipant({
+			message: {
+				from: {
+					id: "1201547643",
+					username: "arafatkatze",
+				},
+			},
+		});
+
+		expect(result?.key).toBe("telegram:id:1201547643");
+	});
+});
+
+describe("telegram binding lookup", () => {
+	it("falls back to channel identity when a restarted connector gets a new thread id", () => {
+		const result = __test__.findBindingForThread(
+			{
+				legacy_thread_id: {
+					channelId: "chat-123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1", cwd: "/tmp/work" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "new_thread_id",
+				channelId: "chat-123",
+				isDM: true,
+			},
+		);
+
+		expect(result).toEqual({
+			key: "legacy_thread_id",
+			binding: {
+				channelId: "chat-123",
+				isDM: true,
+				serializedThread: "{}",
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", cwd: "/tmp/work" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+	});
+
+	it("prefers an exact thread id match over a channel fallback", () => {
+		const result = __test__.findBindingForThread(
+			{
+				current_thread_id: {
+					channelId: "chat-123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-2",
+					state: { sessionId: "sess-2" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+				legacy_thread_id: {
+					channelId: "chat-123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "current_thread_id",
+				channelId: "chat-123",
+				isDM: true,
+			},
+		);
+
+		expect(result?.key).toBe("current_thread_id");
+		expect(result?.binding.sessionId).toBe("sess-2");
+	});
+
+	it("does not reuse a binding by participant key across different chats", () => {
+		const result = __test__.findBindingForThread(
+			{
+				"telegram:user:alice": {
+					channelId: "chat-123",
+					isDM: true,
+					participantKey: "telegram:user:alice",
+					participantLabel: "alice",
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: {
+						sessionId: "sess-1",
+						participantKey: "telegram:user:alice",
+						participantLabel: "alice",
+					},
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "new_thread_id",
+				channelId: "chat-999",
+				isDM: true,
+				participantKey: "telegram:user:alice",
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/telegram.ts b/apps/cli/src/connectors/adapters/telegram.ts
new file mode 100644
index 0000000..b243714
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/telegram.ts
@@ -0,0 +1,1135 @@
+import { createTelegramAdapter } from "@chat-adapter/telegram";
+import type { ChatStartSessionRequest } from "@cline/core";
+import {
+	createUserInstructionConfigService,
+	HubSessionClient,
+} from "@cline/core";
+import type {
+	ConnectTelegramOptions,
+	TelegramConnectorState,
+} from "@cline/shared";
+import { Chat, ConsoleLogger, type Thread } from "chat";
+import type { Command } from "commander";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import { createCliLoggerAdapter } from "../../logging/adapter";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+	resolveDefaultCliRpcAddress,
+} from "../../utils/hub-runtime";
+import { createWorkspaceChatCommandHost } from "../../utils/plugin-chat-commands";
+import { ConnectorBase } from "../base";
+import { createChatSdkLogger, enqueueThreadTurn } from "../chat-runtime";
+import { isProcessRunning } from "../common";
+import {
+	type ActiveConnectorTurn,
+	handleConnectorUserTurn,
+	maybeHandleConnectorApprovalReply,
+} from "../connector-host";
+import { dispatchConnectorHook } from "../hooks";
+import {
+	type PendingConnectorApproval,
+	truncateConnectorText,
+} from "../runtime-turn";
+import {
+	buildConnectorStartRequest,
+	readSessionReplyText,
+	stopConnectorSessions,
+} from "../session-runtime";
+import { InMemoryStateAdapter } from "../stores/memory-state";
+import { startConnectorTaskUpdateRelay } from "../task-updates";
+import {
+	type ConnectorBindingStore,
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	findBindingForThread,
+	loadThreadState,
+	persistMergedThreadState,
+	readBindings,
+} from "../thread-bindings";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "../types";
+import {
+	getConnectorFirstContactMessage,
+	getConnectorSystemPrompt,
+	getConnectorSystemRules,
+} from "./prompts";
+import { postTelegramFormattedReply } from "./telegram-format";
+
+const TELEGRAM_SYSTEM_RULES = getConnectorSystemRules("Telegram");
+
+const TELEGRAM_FIRST_CONTACT_MESSAGE = getConnectorFirstContactMessage();
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+
+type TelegramThreadState = ConnectorThreadState;
+type ResolvedTelegramOptions = ConnectTelegramOptions & { botUsername: string };
+type TelegramGetMeResponse = {
+	ok?: boolean;
+	description?: string;
+	result?: {
+		username?: string;
+	};
+};
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+
+function truncateText(value: string, maxLength = 160): string {
+	return truncateConnectorText(value, maxLength);
+}
+
+function normalizeTelegramBotUsername(value: string): string {
+	return value.trim().replace(/^@+/, "");
+}
+
+function readTelegramBotId(botToken: string): string | undefined {
+	const [botId] = botToken.trim().split(":", 1);
+	return /^\d+$/.test(botId) ? botId : undefined;
+}
+
+function normalizeAllowedTelegramUserId(value: string): string {
+	const userId = value.trim();
+	if (!/^\d+$/.test(userId)) {
+		throw new Error(
+			"connect telegram --allowed-user-id must contain digits only",
+		);
+	}
+	return userId;
+}
+
+function buildTelegramAllowedUserHookCommand(userId: string): string {
+	return `jq -r ".payload.actor.participantKey" | grep -qx "telegram:id:${userId}" && echo '{"action":"allow"}' || echo '{"action":"deny","message":"unauthorized","reason":"not_on_allowlist"}'`;
+}
+
+function describeTelegramGetMeFailure(
+	response: Response,
+	body: string,
+	parsed: TelegramGetMeResponse | undefined,
+): string {
+	const detail = parsed?.description || body.trim().slice(0, 240);
+	return detail
+		? `Telegram getMe failed (${response.status} ${response.statusText}): ${detail}`
+		: `Telegram getMe failed (${response.status} ${response.statusText})`;
+}
+
+async function readTelegramGetMeResponse(
+	response: Response,
+): Promise<TelegramGetMeResponse> {
+	const text = await response.text();
+	let parsed: TelegramGetMeResponse;
+	try {
+		parsed = JSON.parse(text) as TelegramGetMeResponse;
+	} catch {
+		throw new Error(describeTelegramGetMeFailure(response, text, undefined));
+	}
+	if (!response.ok || parsed.ok !== true) {
+		throw new Error(describeTelegramGetMeFailure(response, text, parsed));
+	}
+	return parsed;
+}
+
+async function fetchTelegramBotUsername(
+	botToken: string,
+	fetchImpl: FetchLike = fetch,
+	apiBaseUrl = TELEGRAM_API_BASE,
+): Promise<string> {
+	const response = await fetchImpl(`${apiBaseUrl}/bot${botToken}/getMe`);
+	const payload = await readTelegramGetMeResponse(response);
+	const username = normalizeTelegramBotUsername(payload.result?.username ?? "");
+	if (!username) {
+		throw new Error(
+			"Telegram getMe did not return a bot username; pass --bot-username explicitly",
+		);
+	}
+	return username;
+}
+
+async function resolveTelegramBotUsername(
+	options: ConnectTelegramOptions,
+	fetchImpl?: FetchLike,
+): Promise<string> {
+	const configured = normalizeTelegramBotUsername(options.botUsername ?? "");
+	if (configured) {
+		return configured;
+	}
+	return fetchTelegramBotUsername(options.botToken, fetchImpl);
+}
+
+async function stopSessionsForBot(
+	state: TelegramConnectorState,
+): Promise<number> {
+	return stopConnectorSessions({
+		rpcAddress: state.rpcAddress,
+		rpcMatcher: (metadata) =>
+			metadata?.transport === "telegram" &&
+			metadata?.botUserName === state.botUsername,
+		localMatcher: (metadata) =>
+			metadata?.transport === "telegram" &&
+			metadata?.botUserName === state.botUsername,
+	});
+}
+
+async function buildTelegramStartRequest(
+	options: ConnectTelegramOptions,
+	io: ConnectIo,
+	loggerConfig: Parameters<
+		typeof buildConnectorStartRequest
+	>[0]["loggerConfig"],
+): Promise<ChatStartSessionRequest> {
+	return buildConnectorStartRequest({
+		options,
+		io,
+		loggerConfig,
+		systemRules: TELEGRAM_SYSTEM_RULES,
+	});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function readString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function readIdentifier(value: unknown): string | undefined {
+	if (typeof value === "string" && value.trim()) {
+		return value.trim();
+	}
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return String(value);
+	}
+	return undefined;
+}
+
+function resolveTelegramParticipant(
+	rawMessage: unknown,
+): { key: string; label?: string } | undefined {
+	const raw = asRecord(rawMessage);
+	const message =
+		asRecord(raw?.message) ??
+		asRecord(raw?.edited_message) ??
+		asRecord(raw?.channel_post) ??
+		raw;
+	const from = asRecord(message?.from);
+	const username = readString(from?.username)?.toLowerCase();
+	const userId = readIdentifier(from?.id);
+	const firstName = readString(from?.first_name);
+	const lastName = readString(from?.last_name);
+	const label =
+		username || [firstName, lastName].filter(Boolean).join(" ") || userId;
+	if (userId) {
+		return { key: `telegram:id:${userId}`, label };
+	}
+	if (username) {
+		return { key: `telegram:user:${username}`, label };
+	}
+	return undefined;
+}
+
+async function persistTelegramThreadContext(input: {
+	thread: Thread<TelegramThreadState>;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	rawMessage: unknown;
+	errorLabel: string;
+}): Promise<void> {
+	const participant = resolveTelegramParticipant(input.rawMessage);
+	if (!participant) {
+		return;
+	}
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	if (
+		currentState.participantKey === participant.key &&
+		currentState.participantLabel === participant.label
+	) {
+		return;
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...currentState,
+			participantKey: participant.key,
+			participantLabel: participant.label,
+		},
+		input.errorLabel,
+	);
+}
+
+async function deliverScheduledResult(input: {
+	bot: Chat;
+	client: HubSessionClient;
+	logger: CliLoggerAdapter;
+	bindingsPath: string;
+	botUsername: string;
+	scheduleId: string;
+	executionId: string;
+	sessionId?: string;
+	status: string;
+	errorMessage?: string;
+	hookCommand?: string;
+}): Promise<void> {
+	const schedule = await input.client.getSchedule(input.scheduleId);
+	const delivery = schedule?.metadata?.delivery as
+		| Record<string, unknown>
+		| undefined;
+	if (!delivery || delivery.adapter !== "telegram") {
+		return;
+	}
+	const targetBot =
+		typeof delivery.userName === "string" ? delivery.userName.trim() : "";
+	if (targetBot && targetBot !== input.botUsername) {
+		return;
+	}
+	const threadId =
+		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
+	const bindingKey =
+		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
+	const participantKey =
+		typeof delivery.participantKey === "string"
+			? delivery.participantKey.trim()
+			: "";
+	if (!threadId && !bindingKey && !participantKey) {
+		return;
+	}
+	const bindings = readBindings<TelegramThreadState>(input.bindingsPath);
+	const match = findBindingForDeliveryTarget(bindings, {
+		bindingKey,
+		threadId,
+		participantKey,
+	});
+	const binding = match?.binding;
+	const deliveryThreadId = match?.key || threadId;
+	if (!binding?.serializedThread) {
+		input.logger.core.log(
+			"Scheduled Telegram delivery skipped: missing thread binding",
+			{
+				severity: "warn",
+				transport: "telegram",
+				scheduleId: input.scheduleId,
+				executionId: input.executionId,
+				threadId: deliveryThreadId,
+				bindingKey: bindingKey || undefined,
+			},
+		);
+		return;
+	}
+	await dispatchConnectorHook(
+		input.hookCommand,
+		{
+			adapter: "telegram",
+			botUserName: input.botUsername,
+			event: "schedule.delivery.started",
+			payload: {
+				threadId: deliveryThreadId,
+				scheduleId: input.scheduleId,
+				executionId: input.executionId,
+				sessionId: input.sessionId,
+				status: input.status,
+			},
+			ts: new Date().toISOString(),
+		},
+		input.logger,
+	);
+	const thread = JSON.parse(
+		binding.serializedThread,
+		input.bot.reviver(),
+	) as Thread<TelegramThreadState>;
+	let body = "";
+	if (input.status === "success" && input.sessionId) {
+		const text = await readSessionReplyText(input.client, input.sessionId);
+		body = text?.trim()
+			? text
+			: `Schedule "${schedule?.name ?? input.scheduleId}" completed, but no assistant reply text was found.`;
+	} else {
+		body = `Schedule "${schedule?.name ?? input.scheduleId}" ${input.status}.${input.errorMessage ? `\n\n${input.errorMessage}` : ""}`;
+	}
+	try {
+		await thread.post({ raw: body.trim() ? body : " " });
+		input.logger.core.log("Scheduled Telegram delivery sent", {
+			transport: "telegram",
+			threadId: deliveryThreadId,
+			scheduleId: input.scheduleId,
+			executionId: input.executionId,
+			status: input.status,
+			outputPreview: truncateText(body),
+		});
+		await dispatchConnectorHook(
+			input.hookCommand,
+			{
+				adapter: "telegram",
+				botUserName: input.botUsername,
+				event: "schedule.delivery.sent",
+				payload: {
+					threadId: deliveryThreadId,
+					scheduleId: input.scheduleId,
+					executionId: input.executionId,
+					status: input.status,
+					outputPreview: truncateText(body),
+				},
+				ts: new Date().toISOString(),
+			},
+			input.logger,
+		);
+	} catch (error) {
+		input.logger.core.error?.("Scheduled Telegram delivery failed", {
+			transport: "telegram",
+			threadId: deliveryThreadId,
+			scheduleId: input.scheduleId,
+			executionId: input.executionId,
+			error,
+		});
+		await dispatchConnectorHook(
+			input.hookCommand,
+			{
+				adapter: "telegram",
+				botUserName: input.botUsername,
+				event: "schedule.delivery.failed",
+				payload: {
+					threadId: deliveryThreadId,
+					scheduleId: input.scheduleId,
+					executionId: input.executionId,
+					error: error instanceof Error ? error.message : String(error),
+				},
+				ts: new Date().toISOString(),
+			},
+			input.logger,
+		);
+	}
+}
+
+class TelegramConnector extends ConnectorBase<
+	ConnectTelegramOptions,
+	TelegramConnectorState
+> {
+	constructor() {
+		super("telegram", "Bridge Telegram bot messages into RPC chat sessions");
+	}
+
+	protected override createCommand(): Command {
+		return super
+			.createCommand()
+			.usage("-k <TELEGRAM_BOT_TOKEN> [options]")
+			.option(
+				"-m, --bot-username <name>",
+				"Telegram bot username; fetched from token if omitted",
+			)
+			.option("-k, --bot-token <token>", "Telegram bot token")
+			.option("--provider <id>", "Provider override")
+			.option("--model <id>", "Model override")
+			.option("--api-key <key>", "Provider API key override")
+			.option("--system <prompt>", "System prompt override")
+			.option("--cwd <path>", "Workspace / cwd for runtime")
+			.option("--mode <act|plan>", "Agent mode", "act")
+			.option("-i, --interactive", "Keep connector in foreground")
+			.option("--no-tools", "Disable tools for Telegram sessions")
+			.option(
+				"--allowed-user-id <id>",
+				"Only allow this Telegram user ID to use the bot",
+			)
+			.option(
+				"--hook-command <command>",
+				"Run a shell command for connector events",
+			)
+			.option(
+				"--rpc-address <host:port>",
+				"RPC address",
+				process.env.CLINE_RPC_ADDRESS?.trim() || resolveDefaultCliRpcAddress(),
+			)
+			.addHelpText(
+				"after",
+				[
+					"",
+					"Notes:",
+					"  - Without -i, the connector is launched in the background.",
+					"  - Tools are enabled by default for Telegram sessions.",
+					"  - Use --allowed-user-id or `cline connect` to restrict Telegram access.",
+					"  - Bot username is discovered from the Telegram bot token when omitted.",
+					"  - Provider/model default to the CLI's last-used provider settings.",
+				].join("\n"),
+			);
+	}
+
+	protected override readOptions(command: Command): ConnectTelegramOptions {
+		const opts = command.opts<{
+			botUsername?: string;
+			botToken?: string;
+			cwd?: string;
+			model?: string;
+			provider?: string;
+			apiKey?: string;
+			system?: string;
+			mode?: string;
+			interactive?: boolean;
+			tools?: boolean;
+			rpcAddress?: string;
+			hookCommand?: string;
+			allowedUserId?: string;
+		}>();
+		const botUsername =
+			normalizeTelegramBotUsername(opts.botUsername ?? "") ||
+			normalizeTelegramBotUsername(
+				process.env.TELEGRAM_BOT_USERNAME?.trim() ?? "",
+			);
+		const botToken =
+			opts.botToken?.trim() || process.env.TELEGRAM_BOT_TOKEN?.trim();
+		if (!botToken) {
+			throw new Error("connect telegram requires -k/--bot-token <token>");
+		}
+		const hookCommand =
+			opts.hookCommand?.trim() ||
+			process.env.CLINE_CONNECT_HOOK_COMMAND?.trim();
+		const allowedUserId = opts.allowedUserId?.trim();
+		if (hookCommand && allowedUserId) {
+			throw new Error(
+				"connect telegram accepts either --allowed-user-id or --hook-command, not both",
+			);
+		}
+		return {
+			botToken,
+			...(botUsername ? { botUsername } : {}),
+			cwd: opts.cwd || process.cwd(),
+			model: opts.model,
+			provider: opts.provider,
+			apiKey: opts.apiKey,
+			systemPrompt: opts.system,
+			mode: this.parseMode(opts.mode),
+			interactive: Boolean(opts.interactive),
+			enableTools: opts.tools !== false,
+			rpcAddress:
+				opts.rpcAddress?.trim() ||
+				process.env.CLINE_RPC_ADDRESS?.trim() ||
+				resolveDefaultCliRpcAddress(),
+			hookCommand: allowedUserId
+				? buildTelegramAllowedUserHookCommand(
+						normalizeAllowedTelegramUserId(allowedUserId),
+					)
+				: hookCommand,
+		};
+	}
+
+	private resolveConnectorStatePath(botUsername: string): string {
+		return this.resolveConnectorPath(`${this.sanitizeKey(botUsername)}.json`);
+	}
+
+	private resolveBindingsPath(botUsername: string): string {
+		return this.resolveConnectorPath(
+			`${this.sanitizeKey(botUsername)}.threads.json`,
+		);
+	}
+
+	private listConnectorStatePaths(): string[] {
+		return this.listJsonStatePaths([".threads.json"]);
+	}
+
+	private readConnectorState(
+		statePath: string,
+	): TelegramConnectorState | undefined {
+		return this.readStateFile(
+			statePath,
+			(value): value is TelegramConnectorState =>
+				Boolean(
+					value &&
+						typeof value === "object" &&
+						typeof (value as TelegramConnectorState).pid === "number" &&
+						typeof (value as TelegramConnectorState).botUsername === "string",
+				),
+		);
+	}
+
+	private writeConnectorState(
+		statePath: string,
+		state: TelegramConnectorState,
+	): void {
+		this.writeStateFile(statePath, state);
+	}
+
+	private findRunningConnectorStateByBotId(
+		botId: string | undefined,
+	): TelegramConnectorState | undefined {
+		if (!botId) {
+			return undefined;
+		}
+		for (const statePath of this.listConnectorStatePaths()) {
+			const state = this.readConnectorState(statePath);
+			if (!state) {
+				continue;
+			}
+			if (!isProcessRunning(state.pid)) {
+				this.removeStateFile(statePath);
+				continue;
+			}
+			if (state.botId === botId) {
+				return state;
+			}
+		}
+		return undefined;
+	}
+
+	private async stopTelegramConnectorInstance(
+		statePath: string,
+		io: ConnectIo,
+	): Promise<ConnectStopResult> {
+		return this.stopManagedProcess({
+			io,
+			statePath,
+			readState: (path) => this.readConnectorState(path),
+			describeStoppedProcess: (state) =>
+				`[telegram] stopped pid=${state.pid} bot=@${state.botUsername}`,
+			getPid: (state) => state.pid,
+			stopSessions: stopSessionsForBot,
+			clearBindings: (state) => {
+				clearBindingSessionIds<TelegramThreadState>(
+					this.resolveBindingsPath(state.botUsername),
+				);
+			},
+		});
+	}
+
+	override async stopAll(io: ConnectIo): Promise<ConnectStopResult> {
+		return this.stopAllFromStatePaths(
+			io,
+			this.listConnectorStatePaths(),
+			(statePath, stopIo) =>
+				this.stopTelegramConnectorInstance(statePath, stopIo),
+		);
+	}
+
+	protected override async runWithOptions(
+		inputOptions: ConnectTelegramOptions,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number> {
+		if (
+			!inputOptions.botUsername &&
+			!inputOptions.interactive &&
+			process.env.CLINE_TELEGRAM_CONNECT_CHILD !== "1"
+		) {
+			const runningState = this.findRunningConnectorStateByBotId(
+				readTelegramBotId(inputOptions.botToken),
+			);
+			if (runningState) {
+				io.writeln(
+					`[telegram] connector already running pid=${runningState.pid} rpc=${runningState.rpcAddress}`,
+				);
+				return 0;
+			}
+		}
+		let resolvedBotUsername: string;
+		try {
+			resolvedBotUsername = await resolveTelegramBotUsername(inputOptions);
+		} catch (error) {
+			io.writeErr(error instanceof Error ? error.message : String(error));
+			return 1;
+		}
+		const options: ResolvedTelegramOptions = {
+			...inputOptions,
+			botUsername: resolvedBotUsername,
+		};
+		const backgroundArgs = inputOptions.botUsername
+			? rawArgs
+			: [...rawArgs, "--bot-username", resolvedBotUsername];
+		const statePath = this.resolveConnectorStatePath(options.botUsername);
+		const bindingsPath = this.resolveBindingsPath(options.botUsername);
+		const staleState = this.removeStaleState(
+			statePath,
+			(path) => this.readConnectorState(path),
+			(state) => state.pid,
+		);
+		if (staleState) {
+			clearBindingSessionIds<TelegramThreadState>(bindingsPath);
+		}
+		if (
+			await this.maybeRunInBackground({
+				rawArgs: backgroundArgs,
+				io,
+				interactive: options.interactive,
+				childEnvVar: "CLINE_TELEGRAM_CONNECT_CHILD",
+				statePath,
+				readState: (path) => this.readConnectorState(path),
+				isRunning: (state) => isProcessRunning(state.pid),
+				formatAlreadyRunningMessage: (state) =>
+					`[telegram] connector already running pid=${state.pid} rpc=${state.rpcAddress}`,
+				formatBackgroundStartMessage: (pid) =>
+					`[telegram] starting background connector pid=${pid} bot=@${options.botUsername}`,
+				foregroundHint:
+					"[telegram] use `cline connect telegram -i ...` to run in the foreground",
+				launchFailureMessage:
+					"failed to launch Telegram connector in background",
+			})
+		) {
+			return 0;
+		}
+
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "telegram-connect",
+		});
+		const logger = createChatSdkLogger(loggerAdapter);
+		const consoleLogger = new ConsoleLogger("info", "telegram-connect");
+		const telegram = createTelegramAdapter({
+			mode: "polling",
+			botToken: options.botToken,
+			userName: options.botUsername,
+			logger,
+		});
+		const bot = new Chat({
+			userName: options.botUsername,
+			adapters: { telegram },
+			state: new InMemoryStateAdapter(),
+			logger,
+			fallbackStreamingPlaceholderText: null,
+			streamingUpdateIntervalMs: 500,
+		}).registerSingleton();
+		const threadQueues = new Map<string, Promise<void>>();
+		const activeTurns = new Map<string, ActiveConnectorTurn>();
+		const pendingApprovals = new Map<string, PendingConnectorApproval>();
+		const startRequest = await buildTelegramStartRequest(options, io, {
+			enabled: loggerAdapter.runtimeConfig.enabled,
+			level: loggerAdapter.runtimeConfig.level,
+			destination: loggerAdapter.runtimeConfig.destination,
+			bindings: {
+				transport: "telegram",
+				botUserName: options.botUsername,
+			},
+		});
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { workspacePath: startRequest.cwd },
+			rules: { workspacePath: startRequest.cwd },
+			workflows: { workspacePath: startRequest.cwd },
+		});
+		await userInstructionService.start().catch(() => undefined);
+		const commandCwd = startRequest.cwd || process.cwd();
+		const { host: chatCommandHost } = await createWorkspaceChatCommandHost({
+			cwd: commandCwd,
+			workspaceRoot: startRequest.workspaceRoot || commandCwd,
+		});
+		const { url: rpcAddress, authToken: rpcAuthToken } =
+			await ensureCliHubServer(
+				startRequest.workspaceRoot || startRequest.cwd || process.cwd(),
+				parseHubEndpointOverride(options.rpcAddress),
+			);
+
+		const clientId = `telegram-${process.pid}-${Date.now()}`;
+		const client = new HubSessionClient({
+			address: rpcAddress,
+			authToken: rpcAuthToken,
+			clientId,
+			clientType: "cli",
+			displayName: "telegram connector",
+			workspaceRoot: startRequest.workspaceRoot || startRequest.cwd,
+			cwd: startRequest.cwd,
+			metadata: {
+				transport: "telegram",
+				botUserName: options.botUsername,
+			},
+		});
+		await client.connect();
+		this.writeConnectorState(statePath, {
+			botUsername: options.botUsername,
+			botId: readTelegramBotId(options.botToken),
+			pid: process.pid,
+			rpcAddress,
+			startedAt: new Date().toISOString(),
+		});
+		loggerAdapter.core.log("Telegram connector started", {
+			transport: "telegram",
+			botUserName: options.botUsername,
+			pid: process.pid,
+			rpcAddress,
+			mode: telegram.runtimeMode,
+			interactive: options.interactive,
+		});
+		await dispatchConnectorHook(
+			options.hookCommand,
+			{
+				adapter: "telegram",
+				botUserName: options.botUsername,
+				event: "connector.started",
+				payload: {
+					pid: process.pid,
+					rpcAddress,
+					mode: telegram.runtimeMode,
+				},
+				ts: new Date().toISOString(),
+			},
+			loggerAdapter,
+		);
+
+		let stopping = false;
+		let resolveStop: (() => void) | undefined;
+		const stopPromise = new Promise<void>((resolve) => {
+			resolveStop = resolve;
+		});
+		const requestStop = (reason: string) => {
+			if (stopping) {
+				return;
+			}
+			stopping = true;
+			loggerAdapter.core.log("Telegram connector stopping", {
+				severity: "warn",
+				transport: "telegram",
+				reason,
+				pid: process.pid,
+			});
+			resolveStop?.();
+		};
+
+		const handleTurn = async (
+			thread: Thread<TelegramThreadState>,
+			text: string,
+		) => {
+			const queueKey = thread.id;
+			const runTurn = async () => {
+				try {
+					await handleConnectorUserTurn({
+						thread,
+						text,
+						client,
+						pendingApprovals,
+						baseStartRequest: startRequest,
+						explicitSystemPrompt:
+							options.systemPrompt?.trim() ||
+							getConnectorSystemPrompt("Telegram"),
+						clientId,
+						logger: loggerAdapter,
+						transport: "telegram",
+						botUserName: options.botUsername,
+						requestStop,
+						bindingsPath,
+						hookCommand: options.hookCommand,
+						systemRules: TELEGRAM_SYSTEM_RULES,
+						errorLabel: "Telegram",
+						firstContactMessage: TELEGRAM_FIRST_CONTACT_MESSAGE,
+						userInstructionService,
+						chatCommandHost,
+						activeTurns,
+						turnKey: queueKey,
+						forceDisableTools: !options.enableTools,
+						postFinalReply: async ({
+							thread: currentThread,
+							text: replyText,
+						}) => {
+							await postTelegramFormattedReply({
+								thread: currentThread,
+								text: replyText,
+								botToken: options.botToken,
+								logger: loggerAdapter,
+							});
+						},
+						getSessionMetadata: (currentThread, _clientId, currentState) => ({
+							botUserName: options.botUsername,
+							telegramThreadId: currentThread.id,
+							telegramChannelId: currentThread.channelId,
+							...(currentState.participantKey
+								? { telegramParticipantKey: currentState.participantKey }
+								: {}),
+							...(currentState.participantLabel
+								? { telegramParticipantLabel: currentState.participantLabel }
+								: {}),
+						}),
+						reusedLogMessage: "Telegram thread reusing RPC session",
+						startedLogMessage: "Telegram thread started RPC session",
+						messageReceivedLogMessage: "Telegram message received",
+						threadResetLogMessage: "Telegram thread reset",
+						connectorStopLogMessage:
+							"Telegram connector stop requested from chat",
+						onMessageReceived: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "telegram",
+									botUserName: options.botUsername,
+									event: "message.received",
+									payload: details,
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyCompleted: async (result) => {
+							loggerAdapter.core.log("Telegram reply completed", {
+								transport: "telegram",
+								threadId: result.threadId,
+								sessionId: result.sessionId,
+								outputLength: result.text.length,
+								outputPreview: truncateText(result.text),
+								finishReason: result.finishReason,
+								iterations: result.iterations,
+							});
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "telegram",
+									botUserName: options.botUsername,
+									event: "message.completed",
+									payload: {
+										threadId: result.threadId,
+										sessionId: result.sessionId,
+										finishReason: result.finishReason,
+										iterations: result.iterations,
+										outputPreview: truncateText(result.text),
+										outputLength: result.text.length,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyFailed: async (details) => {
+							loggerAdapter.core.error?.("Telegram reply failed", {
+								transport: "telegram",
+								threadId: details.threadId,
+								sessionId: details.sessionId,
+								error: details.error,
+							});
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "telegram",
+									botUserName: options.botUsername,
+									event: "message.failed",
+									payload: {
+										threadId: details.threadId,
+										sessionId: details.sessionId,
+										error: details.error.message,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+					});
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					loggerAdapter.core.error?.("Telegram turn handling failed", {
+						transport: "telegram",
+						threadId: thread.id,
+						error,
+					});
+					await thread.post({ raw: `Telegram bridge error: ${message}` });
+				}
+			};
+			if (activeTurns.has(queueKey)) {
+				await runTurn();
+				return;
+			}
+			await enqueueThreadTurn(threadQueues, queueKey, async () => {
+				await runTurn();
+			});
+		};
+
+		bot.onNewMention(async (thread, message) => {
+			await thread.subscribe();
+			await persistTelegramThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Telegram",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Telegram user",
+					transport: "telegram",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		bot.onSubscribedMessage(async (thread, message) => {
+			await persistTelegramThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "Telegram",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by Telegram user",
+					transport: "telegram",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		await bot.initialize();
+		const stopTaskUpdateStream =
+			startConnectorTaskUpdateRelay<TelegramThreadState>({
+				client,
+				clientId,
+				bot,
+				logger: loggerAdapter,
+				bindingsPath,
+				transport: "telegram",
+				postToThread: async ({ thread, body }) => {
+					await thread.post({ raw: body.trim() ? body : " " });
+				},
+			});
+
+		const stopEventStream = client.streamEvents(
+			{ clientId: `${clientId}-server-events` },
+			{
+				onEvent: (event) => {
+					if (event.eventType === "rpc.server.shutting_down") {
+						loggerAdapter.core.log(
+							"Telegram connector stopping because the RPC server is shutting down",
+							{
+								severity: "warn",
+								transport: "telegram",
+								eventType: event.eventType,
+							},
+						);
+						requestStop("rpc_server_shutting_down");
+						return;
+					}
+					if (
+						event.eventType !== "schedule.execution.completed" &&
+						event.eventType !== "schedule.execution.failed"
+					) {
+						return;
+					}
+					const scheduleId =
+						typeof event.payload.scheduleId === "string"
+							? event.payload.scheduleId.trim()
+							: "";
+					const executionId =
+						typeof event.payload.executionId === "string"
+							? event.payload.executionId.trim()
+							: "";
+					const sessionId =
+						typeof event.payload.sessionId === "string"
+							? event.payload.sessionId.trim()
+							: undefined;
+					const status =
+						typeof event.payload.status === "string"
+							? event.payload.status.trim()
+							: "";
+					const errorMessage =
+						typeof event.payload.errorMessage === "string"
+							? event.payload.errorMessage
+							: undefined;
+					if (!scheduleId || !executionId || !status) {
+						return;
+					}
+					void deliverScheduledResult({
+						bot,
+						client,
+						logger: loggerAdapter,
+						bindingsPath,
+						botUsername: options.botUsername,
+						scheduleId,
+						executionId,
+						sessionId,
+						status,
+						errorMessage,
+						hookCommand: options.hookCommand,
+					});
+				},
+				onError: (error) => {
+					loggerAdapter.core.log(
+						"Telegram connector server event stream failed",
+						{
+							severity: "warn",
+							transport: "telegram",
+							error,
+						},
+					);
+					requestStop("rpc_server_event_stream_failed");
+				},
+			},
+		);
+
+		consoleLogger.info("Telegram connector ready", {
+			rpcAddress,
+			mode: telegram.runtimeMode,
+		});
+		io.writeln(
+			`[telegram] connected as @${options.botUsername} mode=${telegram.runtimeMode} rpc=${rpcAddress} provider=${startRequest.provider} model=${startRequest.model} tools=${startRequest.enableTools ? "on" : "off"}`,
+		);
+		io.writeln("[telegram] send /clear in a chat to start a fresh RPC session");
+		io.writeln(
+			"[telegram] send /whereami in a chat to get its delivery thread id",
+		);
+		io.writeln(
+			"[telegram] use /tools, /yolo, or /cwd <path> to update runtime settings",
+		);
+		io.writeln("[telegram] send /exit in a chat or press Ctrl+C to stop");
+
+		const shutdown = () => {
+			process.off("SIGINT", shutdown);
+			process.off("SIGTERM", shutdown);
+			requestStop("signal");
+		};
+		process.on("SIGINT", shutdown);
+		process.on("SIGTERM", shutdown);
+
+		await stopPromise;
+		clearBindingSessionIds<TelegramThreadState>(bindingsPath);
+
+		stopTaskUpdateStream();
+		stopEventStream();
+		userInstructionService.stop();
+		await dispatchConnectorHook(
+			options.hookCommand,
+			{
+				adapter: "telegram",
+				botUserName: options.botUsername,
+				event: "connector.stopping",
+				payload: { pid: process.pid },
+				ts: new Date().toISOString(),
+			},
+			loggerAdapter,
+		);
+		await telegram.stopPolling().catch(() => undefined);
+		await bot.shutdown().catch(() => undefined);
+		client.close();
+		this.removeStateFile(statePath);
+		loggerAdapter.core.log("Telegram connector stopped", {
+			transport: "telegram",
+			pid: process.pid,
+		});
+		return 0;
+	}
+}
+
+export const telegramConnector: ConnectCommandDefinition =
+	new TelegramConnector();
+
+export const __test__ = {
+	fetchTelegramBotUsername,
+	readTelegramBotId,
+	resolveTelegramBotUsername,
+	resolveTelegramParticipant,
+	findBindingForThread: (
+		bindings: ConnectorBindingStore<TelegramThreadState>,
+		thread: Pick<Thread<TelegramThreadState>, "id" | "channelId" | "isDM"> & {
+			participantKey?: string;
+		},
+	) => findBindingForThread(bindings, thread),
+};
diff --git a/apps/cli/src/connectors/adapters/whatsapp.test.ts b/apps/cli/src/connectors/adapters/whatsapp.test.ts
new file mode 100644
index 0000000..bd659d1
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/whatsapp.test.ts
@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { __test__ } from "./whatsapp";
+
+describe("whatsapp binding lookup", () => {
+	it("falls back to channel identity when a restarted connector gets a new thread id", () => {
+		const result = __test__.findBindingForThread(
+			{
+				legacy_thread_id: {
+					channelId: "phone-123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1", cwd: "/tmp/work" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "new_thread_id",
+				channelId: "phone-123",
+				isDM: true,
+			},
+		);
+
+		expect(result).toEqual({
+			key: "legacy_thread_id",
+			binding: {
+				channelId: "phone-123",
+				isDM: true,
+				serializedThread: "{}",
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", cwd: "/tmp/work" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+	});
+
+	it("prefers an exact thread id match over a channel fallback", () => {
+		const result = __test__.findBindingForThread(
+			{
+				current_thread_id: {
+					channelId: "phone-123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-2",
+					state: { sessionId: "sess-2" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+				legacy_thread_id: {
+					channelId: "phone-123",
+					isDM: true,
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: { sessionId: "sess-1" },
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "current_thread_id",
+				channelId: "phone-123",
+				isDM: true,
+			},
+		);
+
+		expect(result?.key).toBe("current_thread_id");
+		expect(result?.binding.sessionId).toBe("sess-2");
+	});
+
+	it("does not reuse a binding by participant key across different threads", () => {
+		const result = __test__.findBindingForThread(
+			{
+				"whatsapp:user:15551234567": {
+					channelId: "phone-123",
+					isDM: true,
+					participantKey: "whatsapp:user:15551234567",
+					participantLabel: "Alice",
+					serializedThread: "{}",
+					sessionId: "sess-1",
+					state: {
+						sessionId: "sess-1",
+						participantKey: "whatsapp:user:15551234567",
+						participantLabel: "Alice",
+					},
+					updatedAt: "2026-03-17T00:00:00.000Z",
+				},
+			},
+			{
+				id: "other_thread_id",
+				channelId: "phone-999",
+				isDM: true,
+				participantKey: "whatsapp:user:15551234567",
+			},
+		);
+
+		expect(result).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/connectors/adapters/whatsapp.ts b/apps/cli/src/connectors/adapters/whatsapp.ts
new file mode 100644
index 0000000..4271e69
--- /dev/null
+++ b/apps/cli/src/connectors/adapters/whatsapp.ts
@@ -0,0 +1,867 @@
+import { createWhatsAppAdapter } from "@chat-adapter/whatsapp";
+import type { ChatStartSessionRequest } from "@cline/core";
+import {
+	createUserInstructionConfigService,
+	HubSessionClient,
+} from "@cline/core";
+import type {
+	ConnectWhatsAppOptions,
+	WhatsAppConnectorState,
+} from "@cline/shared";
+import { Chat, ConsoleLogger, type Thread } from "chat";
+import type { Command } from "commander";
+import type { CliLoggerAdapter } from "../../logging/adapter";
+import { createCliLoggerAdapter } from "../../logging/adapter";
+import {
+	ensureCliHubServer,
+	parseHubEndpointOverride,
+	resolveDefaultCliRpcAddress,
+} from "../../utils/hub-runtime";
+import { createWorkspaceChatCommandHost } from "../../utils/plugin-chat-commands";
+import { ConnectorBase } from "../base";
+import {
+	createChatSdkLogger,
+	enqueueThreadTurn,
+	startConnectorWebhookServer,
+} from "../chat-runtime";
+import { isProcessRunning } from "../common";
+import {
+	type ActiveConnectorTurn,
+	handleConnectorUserTurn,
+	maybeHandleConnectorApprovalReply,
+} from "../connector-host";
+import { dispatchConnectorHook } from "../hooks";
+import {
+	type PendingConnectorApproval,
+	truncateConnectorText,
+} from "../runtime-turn";
+import {
+	buildConnectorStartRequest,
+	readSessionReplyText,
+	stopConnectorSessions,
+} from "../session-runtime";
+import { InMemoryStateAdapter } from "../stores/memory-state";
+import { startConnectorTaskUpdateRelay } from "../task-updates";
+import {
+	type ConnectorBindingStore,
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	findBindingForThread,
+	loadThreadState,
+	persistMergedThreadState,
+	readBindings,
+} from "../thread-bindings";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "../types";
+import {
+	getConnectorFirstContactMessage,
+	getConnectorSystemPrompt,
+	getConnectorSystemRules,
+} from "./prompts";
+
+const WHATSAPP_SYSTEM_RULES = getConnectorSystemRules(
+	"WhatsApp",
+	"You can respond to user messages in threads and DMs, and you can use tools according to user's requests and your capabilities.",
+);
+
+const WHATSAPP_FIRST_CONTACT_MESSAGE = getConnectorFirstContactMessage();
+
+type WhatsAppThreadState = ConnectorThreadState;
+
+function truncateText(value: string, maxLength = 160): string {
+	return truncateConnectorText(value, maxLength);
+}
+
+function resolveInstanceKey(input: {
+	phoneNumberId?: string;
+	userName: string;
+}): string {
+	return (input.phoneNumberId?.trim() || input.userName).replace(
+		/[^a-zA-Z0-9._-]+/g,
+		"_",
+	);
+}
+
+async function stopSessionsForConnector(
+	state: WhatsAppConnectorState,
+): Promise<number> {
+	return stopConnectorSessions({
+		rpcAddress: state.rpcAddress,
+		rpcMatcher: (metadata) =>
+			metadata?.transport === "whatsapp" &&
+			(state.phoneNumberId?.trim()
+				? metadata?.phoneNumberId === state.phoneNumberId.trim()
+				: metadata?.userName === state.userName),
+		localMatcher: (metadata) =>
+			metadata?.transport === "whatsapp" &&
+			(state.phoneNumberId?.trim()
+				? metadata?.phoneNumberId === state.phoneNumberId.trim()
+				: metadata?.userName === state.userName),
+	});
+}
+
+async function buildWhatsAppStartRequest(
+	options: ConnectWhatsAppOptions,
+	io: ConnectIo,
+	loggerConfig: Parameters<
+		typeof buildConnectorStartRequest
+	>[0]["loggerConfig"],
+): Promise<ChatStartSessionRequest> {
+	return buildConnectorStartRequest({
+		options,
+		io,
+		loggerConfig,
+		systemRules: WHATSAPP_SYSTEM_RULES,
+	});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function firstRecord(value: unknown): Record<string, unknown> | undefined {
+	return Array.isArray(value) ? asRecord(value[0]) : undefined;
+}
+
+function readString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function resolveWhatsAppParticipant(
+	rawMessage: unknown,
+): { key: string; label?: string } | undefined {
+	const raw = asRecord(rawMessage);
+	const contact = asRecord(raw?.contact) ?? firstRecord(raw?.contacts);
+	const profile = asRecord(contact?.profile);
+	const phone =
+		readString(raw?.from) ||
+		readString(raw?.wa_id) ||
+		readString(contact?.wa_id);
+	const label = readString(profile?.name) || phone;
+	if (!phone) {
+		return undefined;
+	}
+	return {
+		key: `whatsapp:user:${phone}`,
+		label,
+	};
+}
+
+async function persistWhatsAppThreadContext(input: {
+	thread: Thread<WhatsAppThreadState>;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	rawMessage: unknown;
+	errorLabel: string;
+}): Promise<void> {
+	const participant = resolveWhatsAppParticipant(input.rawMessage);
+	if (!participant) {
+		return;
+	}
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	if (
+		currentState.participantKey === participant.key &&
+		currentState.participantLabel === participant.label
+	) {
+		return;
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...currentState,
+			participantKey: participant.key,
+			participantLabel: participant.label,
+		},
+		input.errorLabel,
+	);
+}
+
+async function deliverScheduledResult(input: {
+	bot: Chat;
+	client: HubSessionClient;
+	logger: CliLoggerAdapter;
+	bindingsPath: string;
+	options: ConnectWhatsAppOptions;
+	scheduleId: string;
+	executionId: string;
+	sessionId?: string;
+	status: string;
+	errorMessage?: string;
+	hookCommand?: string;
+}): Promise<void> {
+	const schedule = await input.client.getSchedule(input.scheduleId);
+	const delivery = schedule?.metadata?.delivery as
+		| Record<string, unknown>
+		| undefined;
+	if (!delivery || delivery.adapter !== "whatsapp") {
+		return;
+	}
+	const targetPhoneNumberId =
+		typeof delivery.phoneNumberId === "string"
+			? delivery.phoneNumberId.trim()
+			: "";
+	if (
+		targetPhoneNumberId &&
+		input.options.phoneNumberId?.trim() &&
+		targetPhoneNumberId !== input.options.phoneNumberId.trim()
+	) {
+		return;
+	}
+	const targetUserName =
+		typeof delivery.userName === "string" ? delivery.userName.trim() : "";
+	if (targetUserName && targetUserName !== input.options.userName) {
+		return;
+	}
+	const threadId =
+		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
+	const bindingKey =
+		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
+	const participantKey =
+		typeof delivery.participantKey === "string"
+			? delivery.participantKey.trim()
+			: "";
+	if (!threadId && !bindingKey && !participantKey) {
+		return;
+	}
+	const bindings = readBindings<WhatsAppThreadState>(input.bindingsPath);
+	const match = findBindingForDeliveryTarget(bindings, {
+		bindingKey,
+		threadId,
+		participantKey,
+	});
+	const binding = match?.binding;
+	if (!binding?.serializedThread) {
+		return;
+	}
+	const thread = JSON.parse(
+		binding.serializedThread,
+		input.bot.reviver(),
+	) as Thread<WhatsAppThreadState>;
+	let body = "";
+	if (input.status === "success" && input.sessionId) {
+		const text = await readSessionReplyText(input.client, input.sessionId);
+		body = text?.trim()
+			? text
+			: `Schedule "${schedule?.name ?? input.scheduleId}" completed, but no assistant reply text was found.`;
+	} else {
+		body = `Schedule "${schedule?.name ?? input.scheduleId}" ${input.status}.${input.errorMessage ? `\n\n${input.errorMessage}` : ""}`;
+	}
+	await thread.post(body);
+}
+
+class WhatsAppConnector extends ConnectorBase<
+	ConnectWhatsAppOptions,
+	WhatsAppConnectorState
+> {
+	constructor() {
+		super(
+			"whatsapp",
+			"WhatsApp Business webhook bridge backed by RPC runtime sessions",
+		);
+	}
+
+	protected override createCommand(): Command {
+		return super
+			.createCommand()
+			.usage("--base-url <PUBLIC_BASE_URL> [options]")
+			.option("--user-name <name>", "WhatsApp bot username label")
+			.option("--phone-number-id <id>", "WhatsApp Business phone number id")
+			.option("--access-token <token>", "Meta access token")
+			.option("--app-secret <secret>", "Meta app secret")
+			.option("--verify-token <token>", "Webhook verify token")
+			.option("--api-version <version>", "Graph API version", "v21.0")
+			.option("--provider <id>", "Provider override")
+			.option("--model <id>", "Model override")
+			.option("--api-key <key>", "Provider API key override")
+			.option("--system <prompt>", "System prompt override")
+			.option("--cwd <path>", "Workspace / cwd for runtime")
+			.option("--mode <act|plan>", "Agent mode", "act")
+			.option("-i, --interactive", "Keep connector in foreground")
+			.option("--enable-tools", "Enable tools for WhatsApp sessions")
+			.option(
+				"--hook-command <command>",
+				"Run a shell command for connector events",
+			)
+			.option(
+				"--rpc-address <host:port>",
+				"RPC address",
+				process.env.CLINE_RPC_ADDRESS?.trim() || resolveDefaultCliRpcAddress(),
+			)
+			.option("--host <host>", "Webhook listen host")
+			.option("--port <port>", "Webhook listen port")
+			.option("--base-url <url>", "Public base URL for webhook configuration")
+			.addHelpText(
+				"after",
+				[
+					"",
+					"Environment:",
+					"  WHATSAPP_ACCESS_TOKEN       Meta access token",
+					"  WHATSAPP_APP_SECRET         Meta app secret",
+					"  WHATSAPP_PHONE_NUMBER_ID    WhatsApp Business phone number id",
+					"  WHATSAPP_VERIFY_TOKEN       Webhook verification token",
+					"  WHATSAPP_BOT_USERNAME       Bot username label",
+				].join("\n"),
+			);
+	}
+
+	protected override readOptions(command: Command): ConnectWhatsAppOptions {
+		const opts = command.opts<{
+			userName?: string;
+			phoneNumberId?: string;
+			accessToken?: string;
+			appSecret?: string;
+			verifyToken?: string;
+			apiVersion?: string;
+			cwd?: string;
+			model?: string;
+			provider?: string;
+			apiKey?: string;
+			system?: string;
+			mode?: string;
+			interactive?: boolean;
+			enableTools?: boolean;
+			rpcAddress?: string;
+			hookCommand?: string;
+			port?: string;
+			host?: string;
+			baseUrl?: string;
+		}>();
+		const parsedPort =
+			this.parseOptionalInteger(opts.port, "port") ??
+			Number.parseInt(process.env.PORT ?? "8787", 10);
+		const port = Number.isFinite(parsedPort) ? parsedPort : 8787;
+		return {
+			userName:
+				opts.userName?.trim() ||
+				process.env.WHATSAPP_BOT_USERNAME?.trim() ||
+				"whatsapp-bot",
+			phoneNumberId:
+				opts.phoneNumberId?.trim() ||
+				process.env.WHATSAPP_PHONE_NUMBER_ID?.trim(),
+			accessToken:
+				opts.accessToken?.trim() || process.env.WHATSAPP_ACCESS_TOKEN?.trim(),
+			appSecret:
+				opts.appSecret?.trim() || process.env.WHATSAPP_APP_SECRET?.trim(),
+			verifyToken:
+				opts.verifyToken?.trim() || process.env.WHATSAPP_VERIFY_TOKEN?.trim(),
+			apiVersion: opts.apiVersion?.trim() || "v21.0",
+			cwd: opts.cwd || process.cwd(),
+			model: opts.model,
+			provider: opts.provider,
+			apiKey: opts.apiKey,
+			systemPrompt: opts.system,
+			mode: this.parseMode(opts.mode),
+			interactive: Boolean(opts.interactive),
+			enableTools: Boolean(opts.enableTools),
+			rpcAddress:
+				opts.rpcAddress?.trim() ||
+				process.env.CLINE_RPC_ADDRESS?.trim() ||
+				resolveDefaultCliRpcAddress(),
+			hookCommand:
+				opts.hookCommand?.trim() ||
+				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
+			port,
+			host: opts.host?.trim() || process.env.HOST?.trim() || "0.0.0.0",
+			baseUrl:
+				opts.baseUrl?.trim() ||
+				process.env.BASE_URL?.trim() ||
+				`http://127.0.0.1:${port}`,
+		};
+	}
+
+	private resolveConnectorStatePath(instanceKey: string): string {
+		return this.resolveConnectorPath(`${instanceKey}.json`);
+	}
+
+	private resolveBindingsPath(instanceKey: string): string {
+		return this.resolveConnectorPath(`${instanceKey}.threads.json`);
+	}
+
+	private listConnectorStatePaths(): string[] {
+		return this.listJsonStatePaths([".threads.json"]);
+	}
+
+	private readConnectorState(
+		statePath: string,
+	): WhatsAppConnectorState | undefined {
+		return this.readStateFile(
+			statePath,
+			(value): value is WhatsAppConnectorState =>
+				Boolean(
+					value &&
+						typeof value === "object" &&
+						typeof (value as WhatsAppConnectorState).pid === "number" &&
+						typeof (value as WhatsAppConnectorState).instanceKey === "string" &&
+						typeof (value as WhatsAppConnectorState).userName === "string",
+				),
+		);
+	}
+
+	private writeConnectorState(
+		statePath: string,
+		state: WhatsAppConnectorState,
+	): void {
+		this.writeStateFile(statePath, state);
+	}
+
+	private async stopWhatsAppConnectorInstance(
+		statePath: string,
+		io: ConnectIo,
+	): Promise<ConnectStopResult> {
+		return this.stopManagedProcess({
+			io,
+			statePath,
+			readState: (path) => this.readConnectorState(path),
+			describeStoppedProcess: (state) =>
+				`[whatsapp] stopped pid=${state.pid} user=${state.userName}${state.phoneNumberId ? ` phone=${state.phoneNumberId}` : ""}`,
+			getPid: (state) => state.pid,
+			stopSessions: stopSessionsForConnector,
+			clearBindings: (state) => {
+				clearBindingSessionIds<WhatsAppThreadState>(
+					this.resolveBindingsPath(state.instanceKey),
+				);
+			},
+		});
+	}
+
+	override async stopAll(io: ConnectIo): Promise<ConnectStopResult> {
+		return this.stopAllFromStatePaths(
+			io,
+			this.listConnectorStatePaths(),
+			(statePath, stopIo) =>
+				this.stopWhatsAppConnectorInstance(statePath, stopIo),
+		);
+	}
+
+	protected override async runWithOptions(
+		options: ConnectWhatsAppOptions,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number> {
+		const instanceKey = resolveInstanceKey({
+			phoneNumberId: options.phoneNumberId,
+			userName: options.userName,
+		});
+		const statePath = this.resolveConnectorStatePath(instanceKey);
+		const bindingsPath = this.resolveBindingsPath(instanceKey);
+		const staleState = this.removeStaleState(
+			statePath,
+			(path) => this.readConnectorState(path),
+			(state) => state.pid,
+		);
+		if (staleState) {
+			clearBindingSessionIds<WhatsAppThreadState>(bindingsPath);
+		}
+		if (
+			await this.maybeRunInBackground({
+				rawArgs,
+				io,
+				interactive: options.interactive,
+				childEnvVar: "CLINE_WHATSAPP_CONNECT_CHILD",
+				statePath,
+				readState: (path) => this.readConnectorState(path),
+				isRunning: (state) => isProcessRunning(state.pid),
+				formatAlreadyRunningMessage: (state) =>
+					`[whatsapp] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
+				formatBackgroundStartMessage: (pid) =>
+					`[whatsapp] starting background connector pid=${pid} user=${options.userName}`,
+				foregroundHint:
+					"[whatsapp] use `cline connect whatsapp -i ...` to run in the foreground",
+				launchFailureMessage:
+					"failed to launch WhatsApp connector in background",
+			})
+		) {
+			return 0;
+		}
+
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "whatsapp-connect",
+		});
+		const logger = createChatSdkLogger(loggerAdapter);
+		const consoleLogger = new ConsoleLogger("info", "whatsapp-connect");
+		const whatsappConfig: Record<string, unknown> = {
+			logger: consoleLogger,
+			userName: options.userName,
+		};
+		if (options.accessToken?.trim()) {
+			whatsappConfig.accessToken = options.accessToken.trim();
+		}
+		if (options.appSecret?.trim()) {
+			whatsappConfig.appSecret = options.appSecret.trim();
+		}
+		if (options.phoneNumberId?.trim()) {
+			whatsappConfig.phoneNumberId = options.phoneNumberId.trim();
+		}
+		if (options.verifyToken?.trim()) {
+			whatsappConfig.verifyToken = options.verifyToken.trim();
+		}
+		if (options.apiVersion?.trim()) {
+			whatsappConfig.apiVersion = options.apiVersion.trim();
+		}
+		const whatsapp = createWhatsAppAdapter(whatsappConfig);
+		const bot = new Chat({
+			userName: options.userName,
+			adapters: { whatsapp },
+			state: new InMemoryStateAdapter(),
+			logger,
+			fallbackStreamingPlaceholderText: null,
+			streamingUpdateIntervalMs: 500,
+		}).registerSingleton();
+		const threadQueues = new Map<string, Promise<void>>();
+		const activeTurns = new Map<string, ActiveConnectorTurn>();
+		const pendingApprovals = new Map<string, PendingConnectorApproval>();
+		const startRequest = await buildWhatsAppStartRequest(options, io, {
+			enabled: loggerAdapter.runtimeConfig.enabled,
+			level: loggerAdapter.runtimeConfig.level,
+			destination: loggerAdapter.runtimeConfig.destination,
+			bindings: {
+				transport: "whatsapp",
+				userName: options.userName,
+				...(options.phoneNumberId
+					? { phoneNumberId: options.phoneNumberId }
+					: {}),
+			},
+		});
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { workspacePath: startRequest.cwd },
+			rules: { workspacePath: startRequest.cwd },
+			workflows: { workspacePath: startRequest.cwd },
+		});
+		await userInstructionService.start().catch(() => undefined);
+		const commandCwd = startRequest.cwd || process.cwd();
+		const { host: chatCommandHost } = await createWorkspaceChatCommandHost({
+			cwd: commandCwd,
+			workspaceRoot: startRequest.workspaceRoot || commandCwd,
+		});
+		const { url: rpcAddress, authToken: rpcAuthToken } =
+			await ensureCliHubServer(
+				startRequest.workspaceRoot || startRequest.cwd || process.cwd(),
+				parseHubEndpointOverride(options.rpcAddress),
+			);
+
+		const clientId = `whatsapp-${process.pid}-${Date.now()}`;
+		const client = new HubSessionClient({
+			address: rpcAddress,
+			authToken: rpcAuthToken,
+			clientId,
+			clientType: "cli",
+			displayName: "whatsapp connector",
+			workspaceRoot: startRequest.workspaceRoot || startRequest.cwd,
+			cwd: startRequest.cwd,
+			metadata: {
+				transport: "whatsapp",
+				userName: options.userName,
+				...(options.phoneNumberId
+					? { phoneNumberId: options.phoneNumberId }
+					: {}),
+			},
+		});
+		await client.connect();
+		this.writeConnectorState(statePath, {
+			instanceKey,
+			userName: options.userName,
+			phoneNumberId: options.phoneNumberId,
+			pid: process.pid,
+			rpcAddress,
+			port: options.port,
+			baseUrl: options.baseUrl,
+			startedAt: new Date().toISOString(),
+		});
+
+		let stopping = false;
+		let resolveStop: (() => void) | undefined;
+		const stopPromise = new Promise<void>((resolve) => {
+			resolveStop = resolve;
+		});
+		const requestStop = (_reason: string) => {
+			if (stopping) {
+				return;
+			}
+			stopping = true;
+			resolveStop?.();
+		};
+
+		const handleTurn = async (
+			thread: Thread<WhatsAppThreadState>,
+			text: string,
+		) => {
+			const queueKey = thread.id;
+			const runTurn = async () => {
+				try {
+					await handleConnectorUserTurn({
+						thread,
+						text,
+						client,
+						pendingApprovals,
+						baseStartRequest: startRequest,
+						explicitSystemPrompt:
+							options.systemPrompt?.trim() ||
+							getConnectorSystemPrompt("WhatsApp"),
+						clientId,
+						logger: loggerAdapter,
+						transport: "whatsapp",
+						botUserName: options.userName,
+						requestStop,
+						bindingsPath,
+						hookCommand: options.hookCommand,
+						systemRules: WHATSAPP_SYSTEM_RULES,
+						errorLabel: "WhatsApp",
+						firstContactMessage: WHATSAPP_FIRST_CONTACT_MESSAGE,
+						userInstructionService,
+						chatCommandHost,
+						activeTurns,
+						turnKey: queueKey,
+						getSessionMetadata: (currentThread, _clientId, currentState) => ({
+							userName: options.userName,
+							phoneNumberId: options.phoneNumberId,
+							whatsappThreadId: currentThread.id,
+							whatsappChannelId: currentThread.channelId,
+							...(currentState.participantKey
+								? { whatsappParticipantKey: currentState.participantKey }
+								: {}),
+							...(currentState.participantLabel
+								? { whatsappParticipantLabel: currentState.participantLabel }
+								: {}),
+						}),
+						reusedLogMessage: "WhatsApp thread reusing RPC session",
+						startedLogMessage: "WhatsApp thread started RPC session",
+						onMessageReceived: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "whatsapp",
+									botUserName: options.userName,
+									event: "message.received",
+									payload: details,
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyCompleted: async (result) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "whatsapp",
+									botUserName: options.userName,
+									event: "message.completed",
+									payload: {
+										threadId: result.threadId,
+										sessionId: result.sessionId,
+										finishReason: result.finishReason,
+										iterations: result.iterations,
+										outputPreview: truncateText(result.text),
+										outputLength: result.text.length,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+						onReplyFailed: async (details) => {
+							await dispatchConnectorHook(
+								options.hookCommand,
+								{
+									adapter: "whatsapp",
+									botUserName: options.userName,
+									event: "message.failed",
+									payload: {
+										threadId: details.threadId,
+										sessionId: details.sessionId,
+										error: details.error.message,
+									},
+									ts: new Date().toISOString(),
+								},
+								loggerAdapter,
+							);
+						},
+					});
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					await thread.post(`WhatsApp bridge error: ${message}`);
+				}
+			};
+			if (activeTurns.has(queueKey)) {
+				await runTurn();
+				return;
+			}
+			await enqueueThreadTurn(threadQueues, queueKey, async () => {
+				await runTurn();
+			});
+		};
+
+		bot.onNewMention(async (thread, message) => {
+			await thread.subscribe();
+			await persistWhatsAppThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "WhatsApp",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by WhatsApp user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		bot.onSubscribedMessage(async (thread, message) => {
+			await persistWhatsAppThreadContext({
+				thread,
+				bindingsPath,
+				baseStartRequest: startRequest,
+				rawMessage: message.raw,
+				errorLabel: "WhatsApp",
+			});
+			if (
+				await maybeHandleConnectorApprovalReply({
+					thread,
+					text: message.text,
+					client,
+					clientId,
+					pendingApprovals,
+					deniedReason: "Denied by WhatsApp user",
+				})
+			) {
+				return;
+			}
+			await handleTurn(thread, message.text);
+		});
+
+		await bot.initialize();
+		const stopTaskUpdateStream =
+			startConnectorTaskUpdateRelay<WhatsAppThreadState>({
+				client,
+				clientId,
+				bot,
+				logger: loggerAdapter,
+				bindingsPath,
+				transport: "whatsapp",
+			});
+
+		const endpointUrl = `${options.baseUrl.replace(/\/$/, "")}/api/webhooks/whatsapp`;
+		const server = await startConnectorWebhookServer({
+			host: options.host,
+			port: options.port,
+			routes: {
+				"/api/webhooks/whatsapp": async (request) =>
+					whatsapp.handleWebhook(request),
+				"/health": () => new Response("ok"),
+				"/": () =>
+					new Response(
+						[
+							"WhatsApp connector is running.",
+							`Webhook URL: ${endpointUrl}`,
+						].join("\n"),
+					),
+			},
+		});
+
+		const stopEventStream = client.streamEvents(
+			{ clientId: `${clientId}-server-events` },
+			{
+				onEvent: (event) => {
+					if (event.eventType === "rpc.server.shutting_down") {
+						requestStop("rpc_server_shutting_down");
+						return;
+					}
+					if (
+						event.eventType !== "schedule.execution.completed" &&
+						event.eventType !== "schedule.execution.failed"
+					) {
+						return;
+					}
+					const scheduleId =
+						typeof event.payload.scheduleId === "string"
+							? event.payload.scheduleId.trim()
+							: "";
+					const executionId =
+						typeof event.payload.executionId === "string"
+							? event.payload.executionId.trim()
+							: "";
+					const sessionId =
+						typeof event.payload.sessionId === "string"
+							? event.payload.sessionId.trim()
+							: undefined;
+					const status =
+						typeof event.payload.status === "string"
+							? event.payload.status.trim()
+							: "";
+					const errorMessage =
+						typeof event.payload.errorMessage === "string"
+							? event.payload.errorMessage
+							: undefined;
+					if (!scheduleId || !executionId || !status) {
+						return;
+					}
+					void deliverScheduledResult({
+						bot,
+						client,
+						logger: loggerAdapter,
+						bindingsPath,
+						options,
+						scheduleId,
+						executionId,
+						sessionId,
+						status,
+						errorMessage,
+						hookCommand: options.hookCommand,
+					});
+				},
+				onError: () => {
+					requestStop("rpc_server_event_stream_failed");
+				},
+			},
+		);
+
+		process.once("SIGINT", () => requestStop("sigint"));
+		process.once("SIGTERM", () => requestStop("sigterm"));
+
+		io.writeln(`[whatsapp] listening on ${options.host}:${options.port}`);
+		io.writeln(`[whatsapp] configure WhatsApp webhook URL: ${endpointUrl}`);
+
+		await stopPromise;
+		clearBindingSessionIds<WhatsAppThreadState>(bindingsPath);
+		stopTaskUpdateStream();
+		stopEventStream();
+		await server.close();
+		userInstructionService.stop();
+		client.close();
+		this.removeStateFile(statePath);
+		return 0;
+	}
+}
+
+export const whatsappConnector: ConnectCommandDefinition =
+	new WhatsAppConnector();
+
+export const __test__ = {
+	findBindingForThread: (
+		bindings: ConnectorBindingStore<WhatsAppThreadState>,
+		thread: Pick<Thread<WhatsAppThreadState>, "id" | "channelId" | "isDM"> & {
+			participantKey?: string;
+		},
+	) => findBindingForThread(bindings, thread),
+};
diff --git a/apps/cli/src/connectors/base.ts b/apps/cli/src/connectors/base.ts
new file mode 100644
index 0000000..aef5a4a
--- /dev/null
+++ b/apps/cli/src/connectors/base.ts
@@ -0,0 +1,235 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { resolveClineDataDir } from "@cline/core";
+import { Command, CommanderError } from "commander";
+import {
+	isProcessRunning,
+	readJsonFile,
+	removeFile,
+	spawnDetachedConnector,
+	terminateProcess,
+	writeJsonFile,
+} from "./common";
+import type {
+	ConnectCommandDefinition,
+	ConnectIo,
+	ConnectStopResult,
+} from "./types";
+
+const SHOW_HELP_ERROR = "__SHOW_HELP__";
+
+export abstract class ConnectorBase<Options, State>
+	implements ConnectCommandDefinition
+{
+	stopAll?(io: ConnectIo): Promise<ConnectStopResult>;
+
+	constructor(
+		public readonly name: string,
+		public readonly description: string,
+	) {}
+
+	protected createCommand(): Command {
+		return new Command(this.name)
+			.description(this.description)
+			.exitOverride()
+			.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+	}
+
+	protected abstract readOptions(command: Command): Options;
+
+	protected abstract runWithOptions(
+		options: Options,
+		rawArgs: string[],
+		io: ConnectIo,
+	): Promise<number>;
+
+	showHelp(io: ConnectIo): void {
+		const output = this.createCommand().helpInformation().trimEnd();
+		for (const line of output.split("\n")) {
+			io.writeln(line);
+		}
+	}
+
+	async run(rawArgs: string[], io: ConnectIo): Promise<number> {
+		let options: Options;
+		try {
+			options = this.parseArgs(rawArgs);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message === SHOW_HELP_ERROR) {
+				this.showHelp(io);
+				return 0;
+			}
+			io.writeErr(message);
+			return 1;
+		}
+		return this.runWithOptions(options, rawArgs, io);
+	}
+
+	protected parseArgs(rawArgs: string[]): Options {
+		const command = this.createCommand();
+		try {
+			command.parse(rawArgs, { from: "user" });
+		} catch (error) {
+			if (
+				error instanceof CommanderError &&
+				error.code === "commander.helpDisplayed"
+			) {
+				throw new Error(SHOW_HELP_ERROR);
+			}
+			throw error;
+		}
+		return this.readOptions(command);
+	}
+
+	protected sanitizeKey(value: string): string {
+		return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	}
+
+	protected resolveConnectorPath(...segments: string[]): string {
+		return join(resolveClineDataDir(), "connectors", this.name, ...segments);
+	}
+
+	protected listJsonStatePaths(excludedSuffixes: string[] = []): string[] {
+		const dir = this.resolveConnectorPath();
+		if (!existsSync(dir)) {
+			return [];
+		}
+		return readdirSync(dir)
+			.filter(
+				(name) =>
+					name.endsWith(".json") &&
+					!excludedSuffixes.some((suffix) => name.endsWith(suffix)),
+			)
+			.map((name) => join(dir, name));
+	}
+
+	protected readStateFile<T>(
+		statePath: string,
+		isValid: (value: unknown) => value is T,
+	): T | undefined {
+		const parsed = readJsonFile<unknown>(statePath, undefined);
+		return isValid(parsed) ? parsed : undefined;
+	}
+
+	protected writeStateFile(statePath: string, state: unknown): void {
+		writeJsonFile(statePath, state);
+	}
+
+	protected removeStateFile(statePath: string): void {
+		removeFile(statePath);
+	}
+
+	protected removeStaleState(
+		statePath: string,
+		readState: (path: string) => State | undefined,
+		getPid: (state: State) => number,
+	): State | undefined {
+		const state = readState(statePath);
+		if (state && !isProcessRunning(getPid(state))) {
+			this.removeStateFile(statePath);
+			return state;
+		}
+		return undefined;
+	}
+
+	protected async maybeRunInBackground(input: {
+		rawArgs: string[];
+		io: ConnectIo;
+		interactive: boolean;
+		childEnvVar: string;
+		statePath: string;
+		readState: (path: string) => State | undefined;
+		isRunning: (state: State) => boolean;
+		formatAlreadyRunningMessage: (state: State) => string;
+		formatBackgroundStartMessage: (pid: number) => string;
+		foregroundHint: string;
+		launchFailureMessage: string;
+	}): Promise<boolean> {
+		if (input.interactive || process.env[input.childEnvVar] === "1") {
+			return false;
+		}
+		const runningState = input.readState(input.statePath);
+		if (runningState && input.isRunning(runningState)) {
+			input.io.writeln(input.formatAlreadyRunningMessage(runningState));
+			return true;
+		}
+		const pid = spawnDetachedConnector(
+			["connect", this.name],
+			input.rawArgs,
+			input.childEnvVar,
+		);
+		if (!pid) {
+			input.io.writeErr(input.launchFailureMessage);
+			return true;
+		}
+		input.io.writeln(input.formatBackgroundStartMessage(pid));
+		input.io.writeln(input.foregroundHint);
+		return true;
+	}
+
+	protected async stopAllFromStatePaths(
+		io: ConnectIo,
+		statePaths: string[],
+		stopInstance: (
+			statePath: string,
+			io: ConnectIo,
+		) => Promise<ConnectStopResult>,
+	): Promise<ConnectStopResult> {
+		let stoppedProcesses = 0;
+		let stoppedSessions = 0;
+		for (const statePath of statePaths) {
+			const result = await stopInstance(statePath, io);
+			stoppedProcesses += result.stoppedProcesses;
+			stoppedSessions += result.stoppedSessions;
+		}
+		return { stoppedProcesses, stoppedSessions };
+	}
+
+	protected async stopManagedProcess(input: {
+		io: ConnectIo;
+		statePath: string;
+		readState: (path: string) => State | undefined;
+		describeStoppedProcess: (state: State) => string;
+		getPid: (state: State) => number;
+		stopSessions: (state: State) => Promise<number>;
+		clearBindings?: (state: State) => void;
+	}): Promise<ConnectStopResult> {
+		const state = input.readState(input.statePath);
+		if (!state) {
+			this.removeStateFile(input.statePath);
+			return { stoppedProcesses: 0, stoppedSessions: 0 };
+		}
+		let stoppedProcesses = 0;
+		if (await terminateProcess(input.getPid(state))) {
+			stoppedProcesses = 1;
+			input.io.writeln(input.describeStoppedProcess(state));
+		}
+		const stoppedSessions = await input.stopSessions(state);
+		input.clearBindings?.(state);
+		this.removeStateFile(input.statePath);
+		return { stoppedProcesses, stoppedSessions };
+	}
+
+	protected parseOptionalInteger(
+		value: string | undefined,
+		label: string,
+	): number | undefined {
+		if (value === undefined) {
+			return undefined;
+		}
+		const parsed = Number.parseInt(value, 10);
+		if (!Number.isFinite(parsed)) {
+			throw new Error(`invalid ${label} "${value}"`);
+		}
+		return parsed;
+	}
+
+	protected parseMode(value: string | undefined): "act" | "plan" {
+		const mode = value?.trim().toLowerCase() || "act";
+		if (mode !== "act" && mode !== "plan") {
+			throw new Error(`invalid mode "${mode}" (expected "act" or "plan")`);
+		}
+		return mode;
+	}
+}
diff --git a/apps/cli/src/connectors/catalog.ts b/apps/cli/src/connectors/catalog.ts
new file mode 100644
index 0000000..1981fee
--- /dev/null
+++ b/apps/cli/src/connectors/catalog.ts
@@ -0,0 +1,2 @@
+export type { ConnectorCatalogEntry } from "@cline/shared";
+export { CONNECTOR_CATALOG, listConnectorCatalog } from "@cline/shared";
diff --git a/apps/cli/src/connectors/chat-runtime.ts b/apps/cli/src/connectors/chat-runtime.ts
new file mode 100644
index 0000000..0af9ee7
--- /dev/null
+++ b/apps/cli/src/connectors/chat-runtime.ts
@@ -0,0 +1,134 @@
+import type { CliLoggerAdapter } from "../logging/adapter";
+
+export function createChatSdkLogger(adapter: CliLoggerAdapter) {
+	return {
+		child(prefix: string) {
+			return createChatSdkLogger(adapter.child({ chatLogger: prefix }));
+		},
+		debug(message: string, ...args: unknown[]) {
+			adapter.core.debug(message, args.length > 0 ? { args } : undefined);
+		},
+		info(message: string, ...args: unknown[]) {
+			adapter.core.log(message, args.length > 0 ? { args } : undefined);
+		},
+		warn(message: string, ...args: unknown[]) {
+			adapter.core.log(message, {
+				severity: "warn",
+				...(args.length > 0 ? { args } : {}),
+			});
+		},
+		error(message: string, ...args: unknown[]) {
+			adapter.core.error?.(message, args.length > 0 ? { args } : undefined);
+		},
+	};
+}
+
+export async function enqueueThreadTurn(
+	threadQueues: Map<string, Promise<void>>,
+	threadId: string,
+	work: () => Promise<void>,
+): Promise<void> {
+	const previous = threadQueues.get(threadId) ?? Promise.resolve();
+	const current = previous
+		.catch(() => {})
+		.then(work)
+		.finally(() => {
+			if (threadQueues.get(threadId) === current) {
+				threadQueues.delete(threadId);
+			}
+		});
+	threadQueues.set(threadId, current);
+	return current;
+}
+
+export type ConnectorWebhookHandler = (
+	request: Request,
+) => Response | Promise<Response>;
+
+export type ConnectorWebhookServer = {
+	close: () => Promise<void>;
+};
+
+async function readRequestBody(
+	request: import("node:http").IncomingMessage,
+): Promise<Uint8Array | undefined> {
+	if (
+		request.method === "GET" ||
+		request.method === "HEAD" ||
+		request.method === undefined
+	) {
+		return undefined;
+	}
+	const chunks: Buffer[] = [];
+	for await (const chunk of request) {
+		chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	}
+	const body = Buffer.concat(chunks);
+	return body.length > 0 ? body : undefined;
+}
+
+export async function startConnectorWebhookServer(input: {
+	host: string;
+	port: number;
+	routes: Record<string, ConnectorWebhookHandler>;
+	notFound?: ConnectorWebhookHandler;
+}): Promise<ConnectorWebhookServer> {
+	const http = await import("node:http");
+
+	const server = http.createServer(async (req, res) => {
+		try {
+			const hostHeader = req.headers.host || `${input.host}:${input.port}`;
+			const requestUrl = new URL(req.url || "/", `http://${hostHeader}`);
+			const body = await readRequestBody(req);
+			const request = new Request(requestUrl.toString(), {
+				method: req.method,
+				headers: new Headers(
+					Object.entries(req.headers).flatMap(([key, value]) => {
+						if (Array.isArray(value)) {
+							return value.map((entry) => [key, entry] as [string, string]);
+						}
+						return typeof value === "string" ? [[key, value]] : [];
+					}),
+				),
+				body,
+				duplex: body ? "half" : undefined,
+			});
+			const handler =
+				input.routes[requestUrl.pathname] ??
+				input.notFound ??
+				(() => new Response("Not Found", { status: 404 }));
+			const response = await handler(request);
+			res.statusCode = response.status;
+			response.headers.forEach((value, key) => {
+				res.setHeader(key, value);
+			});
+			const buffer = Buffer.from(await response.arrayBuffer());
+			res.end(buffer);
+		} catch (error) {
+			res.statusCode = 500;
+			res.end(error instanceof Error ? error.message : "Internal Server Error");
+		}
+	});
+
+	await new Promise<void>((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(input.port, input.host, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+
+	return {
+		close: async () => {
+			await new Promise<void>((resolve, reject) => {
+				server.close((error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve();
+				});
+			});
+		},
+	};
+}
diff --git a/apps/cli/src/connectors/common.test.ts b/apps/cli/src/connectors/common.test.ts
new file mode 100644
index 0000000..5c7e224
--- /dev/null
+++ b/apps/cli/src/connectors/common.test.ts
@@ -0,0 +1,173 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+	__test__,
+	readSessionMessageCount,
+	readSessionReplyText,
+} from "./common";
+
+describe("spawnDetachedConnector", () => {
+	it("preserves the connect subcommand when building detached connector args", () => {
+		expect(
+			__test__.buildDetachedConnectorArgs(
+				["connect", "telegram"],
+				["-m", "ClineAdapterBot", "-k", "token-123"],
+			),
+		).toEqual([
+			"connect",
+			"telegram",
+			"-m",
+			"ClineAdapterBot",
+			"-k",
+			"token-123",
+			"-i",
+		]);
+	});
+
+	it("preserves bun conditions and resolves the cli entrypoint for detached launches", () => {
+		const connectorsDir = dirname(fileURLToPath(import.meta.url));
+		const repoRoot = resolve(connectorsDir, "../../../../");
+		expect(
+			__test__.buildDetachedConnectorCommand(
+				["connect", "telegram"],
+				["-m", "ClineAdapterBot", "-k", "token-123"],
+				"/Users/test/.bun/bin/bun",
+				"./apps/cli/src/index.ts",
+				["--conditions=development"],
+				repoRoot,
+				{},
+			),
+		).toEqual({
+			launcher: "/Users/test/.bun/bin/bun",
+			childArgs: [
+				"--inspect=127.0.0.1:0",
+				"--enable-source-maps",
+				"--conditions=development",
+				resolve(repoRoot, "apps/cli/src/index.ts"),
+				"connect",
+				"telegram",
+				"-m",
+				"ClineAdapterBot",
+				"-k",
+				"token-123",
+				"-i",
+			],
+		});
+	});
+
+	it("uses a dynamic connector inspector port for development node launches", () => {
+		const connectorsDir = dirname(fileURLToPath(import.meta.url));
+		const repoRoot = resolve(connectorsDir, "../../../../");
+		expect(
+			__test__.buildDetachedConnectorCommand(
+				["connect", "telegram"],
+				["-m", "ClineAdapterBot"],
+				"/usr/local/bin/node",
+				"./apps/cli/src/index.ts",
+				[],
+				repoRoot,
+				{ CLINE_BUILD_ENV: "development" },
+			),
+		).toEqual({
+			launcher: "/usr/local/bin/node",
+			childArgs: [
+				"--inspect=127.0.0.1:0",
+				"--enable-source-maps",
+				resolve(repoRoot, "apps/cli/src/index.ts"),
+				"connect",
+				"telegram",
+				"-m",
+				"ClineAdapterBot",
+				"-i",
+			],
+		});
+	});
+});
+
+describe("readSessionReplyText", () => {
+	it("reads messages through the hub session client", async () => {
+		const client = {
+			readMessages: async () => [
+				{
+					role: "user",
+					content: [{ type: "text", text: "question" }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "first" }],
+				},
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "latest " },
+						{ type: "text", text: "reply" },
+					],
+				},
+			],
+		};
+
+		await expect(
+			readSessionReplyText(client as never, "session-1"),
+		).resolves.toBe("latest reply");
+	});
+
+	it("can restrict fallback replies to messages after a known boundary", async () => {
+		const client = {
+			readMessages: async () => [
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "previous reply" }],
+				},
+				{
+					role: "user",
+					content: [{ type: "text", text: "next question" }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "current reply" }],
+				},
+			],
+		};
+
+		await expect(
+			readSessionReplyText(client as never, "session-1", {
+				minMessageIndex: 1,
+			}),
+		).resolves.toBe("current reply");
+	});
+
+	it("does not read prior assistant replies before the boundary", async () => {
+		const client = {
+			readMessages: async () => [
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "previous reply" }],
+				},
+				{
+					role: "user",
+					content: [{ type: "text", text: "next question" }],
+				},
+			],
+		};
+
+		await expect(
+			readSessionReplyText(client as never, "session-1", {
+				minMessageIndex: 1,
+			}),
+		).resolves.toBeUndefined();
+	});
+
+	it("reads the session message count through the hub session client", async () => {
+		const client = {
+			readMessages: async () => [
+				{ role: "user", content: "one" },
+				{ role: "assistant", content: "two" },
+			],
+		};
+
+		await expect(
+			readSessionMessageCount(client as never, "session-1"),
+		).resolves.toBe(2);
+	});
+});
diff --git a/apps/cli/src/connectors/common.ts b/apps/cli/src/connectors/common.ts
new file mode 100644
index 0000000..5b25f41
--- /dev/null
+++ b/apps/cli/src/connectors/common.ts
@@ -0,0 +1,360 @@
+import { spawn } from "node:child_process";
+import {
+	closeSync,
+	existsSync,
+	openSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { HubSessionClient, HubSessionRow } from "@cline/core";
+import { ensureParentDir, resolveClineDataDir } from "@cline/core";
+import { withResolvedClineBuildEnv } from "@cline/shared";
+import { createCliLoggerAdapter } from "../logging/adapter";
+import { logSpawnedProcess } from "../logging/process";
+import { resolveCliLaunchSpec } from "../utils/internal-launch";
+
+export function parseBooleanFlag(rawArgs: string[], flag: string): boolean {
+	return rawArgs.includes(flag);
+}
+
+export function parseStringFlag(
+	rawArgs: string[],
+	shortFlag: string,
+	longFlag: string,
+): string | undefined {
+	for (let index = 0; index < rawArgs.length; index += 1) {
+		const value = rawArgs[index];
+		if (value !== shortFlag && value !== longFlag) {
+			continue;
+		}
+		const next = rawArgs[index + 1]?.trim();
+		return next ? next : undefined;
+	}
+	return undefined;
+}
+
+export function parseIntegerFlag(
+	rawArgs: string[],
+	shortFlag: string,
+	longFlag: string,
+): number | undefined {
+	const raw = parseStringFlag(rawArgs, shortFlag, longFlag);
+	if (!raw) {
+		return undefined;
+	}
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function isProcessRunning(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function terminateProcess(pid: number): Promise<boolean> {
+	if (!isProcessRunning(pid)) {
+		return false;
+	}
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		return false;
+	}
+	for (let attempt = 0; attempt < 20; attempt += 1) {
+		if (!isProcessRunning(pid)) {
+			return true;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	try {
+		process.kill(pid, "SIGKILL");
+	} catch {
+		return false;
+	}
+	for (let attempt = 0; attempt < 10; attempt += 1) {
+		if (!isProcessRunning(pid)) {
+			return true;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	return !isProcessRunning(pid);
+}
+
+function buildDetachedConnectorArgs(
+	commandPrefixArgs: string[],
+	rawArgs: string[],
+): string[] {
+	return [...commandPrefixArgs, ...rawArgs, "-i"];
+}
+
+function buildDetachedConnectorCommand(
+	commandPrefixArgs: string[],
+	rawArgs: string[],
+	execPath = process.execPath,
+	entryArg = process.argv[1],
+	execArgv = process.execArgv,
+	cwd = process.cwd(),
+	env = process.env,
+): { launcher: string; childArgs: string[] } | undefined {
+	const spec = resolveCliLaunchSpec({
+		execPath,
+		argv: [process.argv[0] || "node", entryArg ?? ""],
+		execArgv,
+		cwd,
+		env,
+		debugRole: "connector",
+	});
+	if (!spec) {
+		return undefined;
+	}
+	const commandArgs = buildDetachedConnectorArgs(commandPrefixArgs, rawArgs);
+	return {
+		launcher: spec.launcher,
+		childArgs: [...spec.childArgsPrefix, ...commandArgs],
+	};
+}
+
+export function resolveConnectorDebugLogPath(
+	adapterName: string,
+	instanceKey: string,
+): string {
+	const safeAdapter = adapterName.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	const safeKey = instanceKey.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	return join(
+		resolveClineDataDir(),
+		"logs",
+		"connectors",
+		safeAdapter,
+		`${safeKey}.log`,
+	);
+}
+
+function tryOpenDetachedLogFd(path: string | undefined): number | undefined {
+	if (!path?.trim()) {
+		return undefined;
+	}
+	try {
+		ensureParentDir(path);
+		return openSync(path, "a");
+	} catch {
+		return undefined;
+	}
+}
+
+export function spawnDetachedConnector(
+	commandPrefixArgs: string[],
+	rawArgs: string[],
+	childEnvKey: string,
+	options?: {
+		logPath?: string;
+		component?: string;
+		metadata?: Record<string, unknown>;
+	},
+): number {
+	const command = buildDetachedConnectorCommand(commandPrefixArgs, rawArgs);
+	if (!command) {
+		try {
+			const logger = createCliLoggerAdapter({
+				runtime: "cli",
+				component: options?.component ?? "connectors",
+			});
+			logger.core.error?.("Unable to resolve detached connector command", {
+				commandPrefixArgs,
+				rawArgs,
+				childEnvKey,
+				entryArg: process.argv[1],
+				cwd: process.cwd(),
+				logPath: options?.logPath,
+				...options?.metadata,
+			});
+		} catch {
+			// Best-effort logging only.
+		}
+		return 0;
+	}
+	const detachedLogFd = tryOpenDetachedLogFd(options?.logPath);
+	try {
+		const child = spawn(command.launcher, command.childArgs, {
+			cwd: process.cwd(),
+			detached: true,
+			stdio:
+				detachedLogFd === undefined
+					? "ignore"
+					: ["ignore", detachedLogFd, detachedLogFd],
+			env: {
+				...withResolvedClineBuildEnv(process.env),
+				[childEnvKey]: "1",
+			},
+			// Prevent a console window from appearing on Windows; detached
+			// processes otherwise allocate a new visible console.
+			windowsHide: true,
+		});
+		logSpawnedProcess({
+			component: options?.component ?? "connectors",
+			command: [command.launcher, ...command.childArgs],
+			childPid: child.pid ?? undefined,
+			cwd: process.cwd(),
+			detached: true,
+			metadata: {
+				childEnvKey,
+				purpose: "connector.detached",
+				logPath: options?.logPath,
+				...options?.metadata,
+			},
+		});
+		child.unref();
+		return child.pid ?? 0;
+	} catch (error) {
+		try {
+			const logger = createCliLoggerAdapter({
+				runtime: "cli",
+				component: options?.component ?? "connectors",
+			});
+			logger.core.error?.("Failed to spawn detached connector", {
+				error,
+				command: [command.launcher, ...command.childArgs].join(" "),
+				commandArgs: command.childArgs,
+				childEnvKey,
+				logPath: options?.logPath,
+				...options?.metadata,
+			});
+		} catch {
+			// Best-effort logging only.
+		}
+		return 0;
+	} finally {
+		if (detachedLogFd !== undefined) {
+			try {
+				closeSync(detachedLogFd);
+			} catch {
+				// Best-effort cleanup only.
+			}
+		}
+	}
+}
+
+export const __test__ = {
+	buildDetachedConnectorArgs,
+	buildDetachedConnectorCommand,
+};
+
+export function readJsonFile<T>(path: string, fallback: T): T {
+	if (!existsSync(path)) {
+		return fallback;
+	}
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed = JSON.parse(raw) as T;
+		return parsed ?? fallback;
+	} catch {
+		return fallback;
+	}
+}
+
+export function writeJsonFile(path: string, value: unknown): void {
+	ensureParentDir(path);
+	writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
+}
+
+export function removeFile(path: string): void {
+	try {
+		rmSync(path, { force: true });
+	} catch {}
+}
+
+export function parseRowMetadata(
+	row:
+		| HubSessionRow
+		| {
+				metadata?: Record<string, unknown>;
+				parentSessionId?: string | null;
+				sessionId: string;
+		  },
+): { metadata?: Record<string, unknown>; parentSessionId?: string } {
+	const metadata =
+		row.metadata && typeof row.metadata === "object" ? row.metadata : undefined;
+	return {
+		metadata,
+		parentSessionId: row.parentSessionId?.trim() || undefined,
+	};
+}
+
+export function parseLocalRowMetadata(row: {
+	metadata?: Record<string, unknown> | null;
+}): Record<string, unknown> | undefined {
+	return row.metadata && typeof row.metadata === "object"
+		? row.metadata
+		: undefined;
+}
+
+function extractMessageReplyText(message: unknown): string | undefined {
+	if (!message || typeof message !== "object") {
+		return undefined;
+	}
+	const record = message as { role?: unknown; content?: unknown };
+	if (record.role !== "assistant") {
+		return undefined;
+	}
+	const content = record.content;
+	if (typeof content === "string" && content.trim()) {
+		return content.trim();
+	}
+	if (!Array.isArray(content)) {
+		return undefined;
+	}
+	const joined = content
+		.map((part) => {
+			if (typeof part === "string") {
+				return part;
+			}
+			if (!part || typeof part !== "object") {
+				return "";
+			}
+			const record = part as { text?: unknown };
+			return typeof record.text === "string" ? record.text : "";
+		})
+		.join("")
+		.trim();
+	return joined || undefined;
+}
+
+export async function readSessionReplyText(
+	client: HubSessionClient,
+	sessionId: string,
+	options: { minMessageIndex?: number } = {},
+): Promise<string | undefined> {
+	try {
+		const messages = await client.readMessages(sessionId);
+		const minMessageIndex = Math.max(0, options.minMessageIndex ?? 0);
+		for (
+			let index = messages.length - 1;
+			index >= minMessageIndex;
+			index -= 1
+		) {
+			const text = extractMessageReplyText(messages[index]);
+			if (text) {
+				return text;
+			}
+		}
+	} catch {}
+	return undefined;
+}
+
+export async function readSessionMessageCount(
+	client: HubSessionClient,
+	sessionId: string,
+): Promise<number | undefined> {
+	try {
+		return (await client.readMessages(sessionId)).length;
+	} catch {}
+	return undefined;
+}
diff --git a/apps/cli/src/connectors/connector-host.test.ts b/apps/cli/src/connectors/connector-host.test.ts
new file mode 100644
index 0000000..982ea63
--- /dev/null
+++ b/apps/cli/src/connectors/connector-host.test.ts
@@ -0,0 +1,1593 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { SentMessage } from "chat";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { handleConnectorUserTurn } from "./connector-host";
+
+vi.mock("./hooks", () => ({
+	authorizeConnectorEvent: vi.fn(async () => ({ action: "allow" })),
+	dispatchConnectorHook: vi.fn(async () => undefined),
+}));
+
+// Get references to the mocked functions after the mock is set up
+import { authorizeConnectorEvent, dispatchConnectorHook } from "./hooks";
+
+const authorizeConnectorEventMock = vi.mocked(authorizeConnectorEvent);
+const dispatchConnectorHookMock = vi.mocked(dispatchConnectorHook);
+
+type TestState = {
+	sessionId?: string;
+	enableTools?: boolean;
+	autoApproveTools?: boolean;
+	cwd?: string;
+	workspaceRoot?: string;
+	systemPrompt?: string;
+	participantKey?: string;
+	participantLabel?: string;
+	welcomeSentAt?: string;
+};
+
+function createThread(initialState: TestState = {}, isDM = true) {
+	let state = { ...initialState };
+	const posts: unknown[] = [];
+	return {
+		thread: {
+			id: "thread-1",
+			channelId: "channel-1",
+			isDM,
+			get state() {
+				return Promise.resolve(state);
+			},
+			async setState(nextState: TestState) {
+				state = { ...nextState };
+			},
+			async post(message: unknown) {
+				posts.push(message);
+				const sentMessage = {
+					edit: async (nextMessage: unknown) => {
+						posts.push(nextMessage);
+						return sentMessage as unknown as SentMessage;
+					},
+					delete: async () => undefined,
+				};
+				return sentMessage as unknown as SentMessage;
+			},
+			async startTyping() {},
+			toJSON() {
+				return {
+					id: "thread-1",
+					channelId: "channel-1",
+					isDM,
+					state,
+				};
+			},
+		},
+		posts,
+		getState: () => state,
+	};
+}
+
+function baseStartRequest(overrides: Partial<TestState> = {}) {
+	return {
+		enableTools: overrides.enableTools ?? false,
+		autoApproveTools: overrides.autoApproveTools ?? false,
+		cwd: overrides.cwd ?? "/tmp/work",
+		workspaceRoot: overrides.workspaceRoot ?? "/tmp/work",
+		systemPrompt: overrides.systemPrompt ?? "system",
+		provider: "cline",
+		model: "test-model",
+		mode: "act",
+	};
+}
+
+function createRuntimeClient(
+	responseText: string,
+	messages: unknown[] = [
+		{
+			role: "assistant",
+			content: [{ type: "text", text: responseText }],
+		},
+	],
+) {
+	const startRuntimeSession = vi.fn(async () => ({ sessionId: "session-1" }));
+	const updateSession = vi.fn(async () => undefined);
+	const getSession = vi.fn(
+		async (sessionId: string): Promise<{ sessionId: string } | undefined> => ({
+			sessionId,
+		}),
+	);
+	const abortRuntimeSession = vi.fn(async () => undefined);
+	const deleteSession = vi.fn(async () => undefined);
+	const sendRuntimeSession = vi.fn(async () => ({
+		result: {
+			text: responseText,
+			finishReason: "stop",
+			iterations: 1,
+		},
+	}));
+	const readMessages = vi.fn(async () => messages);
+	return {
+		client: {
+			startRuntimeSession,
+			updateSession,
+			getSession,
+			abortRuntimeSession,
+			stopRuntimeSession: abortRuntimeSession,
+			deleteSession,
+			sendRuntimeSession,
+			readMessages,
+			streamEvents: vi.fn(() => () => undefined),
+		},
+		startRuntimeSession,
+		updateSession,
+		getSession,
+		sendRuntimeSession,
+		readMessages,
+	};
+}
+
+function messageText(message: unknown): string {
+	if (typeof message === "string") {
+		return message;
+	}
+	if (message && typeof message === "object" && "raw" in message) {
+		const raw = (message as { raw: unknown }).raw;
+		return typeof raw === "string" ? raw : String(raw);
+	}
+	return String(message);
+}
+
+describe("handleConnectorUserTurn", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		authorizeConnectorEventMock.mockReset();
+		authorizeConnectorEventMock.mockResolvedValue({ action: "allow" });
+		dispatchConnectorHookMock.mockReset();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("sends a first-contact message only once per persisted thread state", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread({
+			enableTools: false,
+			autoApproveTools: false,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			participantKey: "telegram:user:alice",
+			participantLabel: "alice",
+		});
+
+		const commonInput = {
+			thread: thread as never,
+			client: {} as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			firstContactMessage: "Connected.\nWelcome.",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		};
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/whereami",
+		});
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/whereami",
+		});
+
+		expect(posts[0]).toEqual({ raw: "Connected.\nWelcome." });
+		expect(
+			posts.filter(
+				(message) => messageText(message) === "Connected.\nWelcome.",
+			),
+		).toHaveLength(1);
+		expect(messageText(posts.at(-1))).toContain(
+			"participantKey=telegram:user:alice",
+		);
+		expect(getState().welcomeSentAt).toBeTruthy();
+	});
+
+	it("blocks unauthorized inbound messages through the shared authorization hook", async () => {
+		authorizeConnectorEventMock.mockResolvedValue({
+			action: "deny",
+			message: "Access denied.",
+			reason: "not_on_allowlist",
+		});
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread({
+			enableTools: false,
+			autoApproveTools: false,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			participantKey: "slack:team:T123:user:U123",
+			participantLabel: "alice",
+		});
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "hello",
+			client: {} as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "slack",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			hookCommand: "echo noop",
+			systemRules: "rules",
+			errorLabel: "Slack",
+			firstContactMessage: "Connected.\nWelcome.",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		});
+
+		expect(posts).toEqual(["Access denied."]);
+		expect(dispatchConnectorHookMock).toHaveBeenCalledWith(
+			"echo noop",
+			expect.objectContaining({
+				event: "message.denied",
+				payload: expect.objectContaining({
+					participantKey: "slack:team:T123:user:U123",
+					reason: "not_on_allowlist",
+				}),
+			}),
+			expect.anything(),
+		);
+		expect(getState().welcomeSentAt).toBeUndefined();
+	});
+
+	it("ignores bare connector slash commands in shared threads", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread(
+			{
+				sessionId: "session-1",
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:owner",
+				participantLabel: "owner",
+			},
+			false,
+		);
+		const runtime = createRuntimeClient("unused");
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "/new",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			ownerParticipantKeys: ["discord:user:owner"],
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		});
+
+		expect(posts).toEqual([]);
+		expect(getState().sessionId).toBe("session-1");
+		expect(runtime.client.abortRuntimeSession).not.toHaveBeenCalled();
+		expect(runtime.sendRuntimeSession).not.toHaveBeenCalled();
+	});
+
+	it("allows owner-addressed connector slash commands in shared threads", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread(
+			{
+				sessionId: "session-1",
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:owner",
+				participantLabel: "owner",
+			},
+			false,
+		);
+		const runtime = createRuntimeClient("unused");
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "/new@ClineAdapterBot",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			ownerParticipantKeys: ["discord:user:owner"],
+			requestStop: vi.fn(),
+			bindingsPath,
+			hookCommand: "echo noop",
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		});
+
+		expect(posts).toEqual(["Started a fresh session."]);
+		expect(getState().sessionId).toBeUndefined();
+		expect(runtime.client.abortRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+		);
+		expect(dispatchConnectorHookMock).toHaveBeenCalledWith(
+			"echo noop",
+			expect.objectContaining({ event: "session.reset" }),
+			expect.anything(),
+		);
+	});
+
+	it("denies non-owner connector slash commands", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread(
+			{
+				sessionId: "session-1",
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:not-owner",
+				participantLabel: "not-owner",
+			},
+			false,
+		);
+		const runtime = createRuntimeClient("unused");
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "/new@ClineAdapterBot",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			ownerParticipantKeys: ["discord:user:owner"],
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		});
+
+		expect(posts).toEqual(["Only the connector owner can use slash commands."]);
+		expect(getState().sessionId).toBe("session-1");
+		expect(runtime.client.abortRuntimeSession).not.toHaveBeenCalled();
+	});
+
+	it("keeps bare connector slash commands available in DMs", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread({
+			sessionId: "session-1",
+			enableTools: false,
+			autoApproveTools: false,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			participantKey: "discord:user:owner",
+			participantLabel: "owner",
+		});
+		const runtime = createRuntimeClient("unused");
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "/new",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			ownerParticipantKeys: ["discord:user:owner"],
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		});
+
+		expect(posts).toEqual(["Started a fresh session."]);
+		expect(getState().sessionId).toBeUndefined();
+		expect(runtime.client.abortRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+		);
+	});
+
+	it("keeps tools disabled when connector startup forced no-tools", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+
+		const commonInput = {
+			thread: thread as never,
+			client: {} as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest({
+				enableTools: false,
+				autoApproveTools: false,
+			}) as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			forceDisableTools: true,
+		};
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/whereami",
+		});
+
+		expect(messageText(posts.at(-1))).toContain("tools=off");
+		expect(messageText(posts.at(-1))).toContain("yolo=off");
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/tools on",
+		});
+
+		expect(posts.at(-1)).toEqual({
+			raw: "tools=off (disabled by connector startup)",
+		});
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/tools@ClineAdapterBot on",
+		});
+
+		expect(posts.at(-1)).toEqual({
+			raw: "tools=off (disabled by connector startup)",
+		});
+
+		const runtime = createRuntimeClient("not a local tools command");
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/tools@OtherBot on",
+			client: runtime.client as never,
+			startedLogMessage: "started",
+		});
+
+		expect(posts.at(-1)).toEqual({ raw: "not a local tools command" });
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+			expect.objectContaining({
+				prompt: expect.stringContaining("/tools@OtherBot on"),
+				config: expect.objectContaining({
+					enableTools: false,
+					autoApproveTools: false,
+				}),
+			}),
+			{ timeoutMs: null },
+		);
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/yolo@ClineAdapterBot on",
+		});
+
+		expect(posts.at(-1)).toEqual({
+			raw: "yolo=off (disabled by connector startup)",
+		});
+	});
+
+	it("creates schedules with forced-disabled runtime options", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			participantKey: "telegram:user:alice",
+			participantLabel: "alice",
+		});
+		const createSchedule = vi.fn(async () => ({
+			name: "nightly",
+			scheduleId: "schedule-1",
+			cronPattern: "0 * * * *",
+			nextRunAt: "2026-05-01T20:00:00.000Z",
+		}));
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: '/schedule create "nightly" --cron "0 * * * *" --prompt "check repo"',
+			client: { createSchedule } as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest({
+				enableTools: false,
+				autoApproveTools: false,
+			}) as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			forceDisableTools: true,
+		});
+
+		expect(createSchedule).toHaveBeenCalledWith(
+			expect.objectContaining({
+				name: "nightly",
+				cronPattern: "0 * * * *",
+				prompt: "check repo",
+				runtimeOptions: {
+					enableTools: false,
+					enableSpawn: false,
+					enableTeams: false,
+					autoApproveTools: false,
+				},
+				metadata: expect.objectContaining({
+					delivery: expect.objectContaining({
+						adapter: "telegram",
+						bindingKey: "thread-1",
+						participantKey: "telegram:user:alice",
+					}),
+				}),
+			}),
+		);
+		expect(messageText(posts.at(-1))).toContain('Scheduled "nightly".');
+	});
+
+	it("handles schedule commands directly in connector chats", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			participantKey: "telegram:user:alice",
+			participantLabel: "alice",
+		});
+		const createSchedule = vi.fn(async () => ({
+			name: "nightly",
+			scheduleId: "schedule-1",
+			cronPattern: "0 * * * *",
+			nextRunAt: "2026-05-01T20:00:00.000Z",
+		}));
+		const listSchedules = vi.fn(async () => [
+			{
+				name: "nightly",
+				scheduleId: "schedule-1",
+				cronPattern: "0 * * * *",
+				nextRunAt: "2026-05-01T20:00:00.000Z",
+				enabled: true,
+				metadata: {
+					delivery: {
+						adapter: "telegram",
+						bindingKey: "thread-1",
+						participantKey: "telegram:user:alice",
+						threadId: "thread-1",
+					},
+				},
+			},
+			{
+				name: "other",
+				scheduleId: "schedule-2",
+				cronPattern: "0 9 * * *",
+				enabled: true,
+				metadata: {
+					delivery: {
+						adapter: "telegram",
+						bindingKey: "thread-2",
+						participantKey: "telegram:user:bob",
+						threadId: "thread-2",
+					},
+				},
+			},
+		]);
+		const triggerScheduleNow = vi.fn(async () => ({
+			executionId: "execution-1",
+			status: "queued",
+		}));
+		const deleteSchedule = vi.fn(async () => true);
+		const commonInput = {
+			thread: thread as never,
+			client: {
+				createSchedule,
+				listSchedules,
+				triggerScheduleNow,
+				deleteSchedule,
+			} as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+		};
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: '/schedule create "nightly" --cron "0 * * * *" --prompt "check repo"',
+		});
+		await handleConnectorUserTurn({ ...commonInput, text: "/schedule list" });
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/schedule trigger schedule-1",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/schedule delete schedule-1",
+		});
+
+		expect(createSchedule).toHaveBeenCalledWith(
+			expect.objectContaining({
+				name: "nightly",
+				cronPattern: "0 * * * *",
+				prompt: "check repo",
+				metadata: expect.objectContaining({
+					delivery: expect.objectContaining({
+						adapter: "telegram",
+						threadId: "thread-1",
+						bindingKey: "thread-1",
+						participantKey: "telegram:user:alice",
+						userName: "ClineAdapterBot",
+					}),
+				}),
+			}),
+		);
+		expect(messageText(posts.at(-4))).toContain('Scheduled "nightly".');
+		expect(messageText(posts.at(-3))).toContain("schedule-1 [enabled]");
+		expect(messageText(posts.at(-3))).not.toContain("schedule-2");
+		expect(messageText(posts.at(-2))).toContain(
+			"Triggered schedule schedule-1.",
+		);
+		expect(triggerScheduleNow).toHaveBeenCalledWith("schedule-1");
+		expect(messageText(posts.at(-1))).toBe("Deleted schedule schedule-1.");
+		expect(deleteSchedule).toHaveBeenCalledWith("schedule-1");
+	});
+
+	it("posts Telegram runtime replies as raw text and disables tools in runtime config", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+		const runtime = createRuntimeClient(
+			"Here is dangling markdown: **repo `sdk",
+		);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "hello",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest({
+				enableTools: false,
+				autoApproveTools: false,
+			}) as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			forceDisableTools: true,
+		});
+
+		expect(runtime.startRuntimeSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				enableTools: false,
+				enableSpawn: false,
+				enableTeams: false,
+				autoApproveTools: false,
+			}),
+		);
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+			expect.objectContaining({
+				config: expect.objectContaining({
+					enableTools: false,
+					enableSpawn: false,
+					enableTeams: false,
+					autoApproveTools: false,
+				}),
+			}),
+			{ timeoutMs: null },
+		);
+		expect(posts.at(-1)).toEqual({
+			raw: "Here is dangling markdown: **repo `sdk",
+		});
+	});
+
+	it("lets Telegram adapters override final runtime reply delivery", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+		const runtime = createRuntimeClient("**Formatted** reply");
+		const postFinalReply = vi.fn(async () => undefined);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "hello",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			postFinalReply,
+		});
+
+		expect(postFinalReply).toHaveBeenCalledWith({
+			thread,
+			text: "**Formatted** reply",
+		});
+		expect(posts).not.toContainEqual({ raw: "**Formatted** reply" });
+	});
+
+	it("suppresses connector /idle control replies", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+		const runtime = createRuntimeClient(" /idle\n");
+		const postFinalReply = vi.fn(async () => undefined);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "other bot replied in the thread",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			postFinalReply,
+		});
+
+		expect(postFinalReply).not.toHaveBeenCalled();
+		expect(posts).toEqual([]);
+	});
+
+	it("mutes a connector thread until /unmute", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("runtime reply");
+		const commonInput = {
+			thread: thread as never,
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			postFinalReply: async ({ text }: { text: string }) => {
+				posts.push(text);
+			},
+		};
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/mute",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "a bot keeps talking",
+		});
+
+		expect(posts).toEqual([
+			"Thread muted. I will ignore messages here until /unmute.",
+		]);
+		expect(runtime.startRuntimeSession).not.toHaveBeenCalled();
+		expect(runtime.sendRuntimeSession).not.toHaveBeenCalled();
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "/unmute",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			text: "hello again",
+		});
+
+		expect(posts.at(-2)).toBe("Thread unmuted.");
+		expect(posts.at(-1)).toBe("runtime reply");
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledTimes(1);
+	});
+
+	it("aborts active turns when muting a connector thread", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("unused");
+		const activeTurns = new Map([
+			["other-participant", { sessionId: "session-1", threadId: "thread-1" }],
+		]);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "/mute",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			activeTurns,
+			turnKey: "current-participant",
+		});
+
+		expect(runtime.client.abortRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+		);
+		expect(posts).toEqual([
+			"Thread muted. I will ignore messages here until /unmute.",
+		]);
+	});
+
+	it("mutes a specific participant in the current connector thread", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const alice = createThread(
+			{
+				enableTools: true,
+				autoApproveTools: true,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:alice",
+				participantLabel: "Alice",
+				welcomeSentAt: new Date().toISOString(),
+			},
+			false,
+		);
+		const bob = createThread(
+			{
+				enableTools: true,
+				autoApproveTools: true,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:bob",
+				participantLabel: "Bob",
+				welcomeSentAt: new Date().toISOString(),
+			},
+			false,
+		);
+		const runtime = createRuntimeClient("runtime reply");
+		const commonInput = {
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			resolveMuteTarget: ({ target }: { target: string }) =>
+				target === "<@bob>"
+					? {
+							participantKey: "discord:user:bob",
+							participantLabel: "<@bob>",
+						}
+					: undefined,
+		};
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: alice.thread as never,
+			text: "/mute@ClineAdapterBot <@bob>",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: bob.thread as never,
+			text: "bob keeps talking",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: alice.thread as never,
+			text: "alice is still allowed",
+			postFinalReply: async ({ text }: { text: string }) => {
+				alice.posts.push(text);
+			},
+		});
+
+		expect(alice.posts[0]).toBe(
+			"Muted <@bob> in this thread. I will ignore their messages until /unmute <@bob>.",
+		);
+		expect(bob.posts).toEqual([]);
+		expect(alice.posts.at(-1)).toBe("runtime reply");
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledTimes(1);
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: alice.thread as never,
+			text: "/unmute@ClineAdapterBot <@bob>",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: bob.thread as never,
+			text: "bob is back",
+			postFinalReply: async ({ text }: { text: string }) => {
+				bob.posts.push(text);
+			},
+		});
+
+		expect(alice.posts.at(-1)).toBe("Unmuted <@bob> in this thread.");
+		expect(bob.posts.at(-1)).toBe("runtime reply");
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledTimes(2);
+	});
+
+	it("does not report thread unmuted when only participant-specific mutes are active", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const alice = createThread(
+			{
+				enableTools: true,
+				autoApproveTools: true,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:alice",
+				participantLabel: "Alice",
+				welcomeSentAt: new Date().toISOString(),
+			},
+			false,
+		);
+		const bob = createThread(
+			{
+				enableTools: true,
+				autoApproveTools: true,
+				cwd: "/tmp/work",
+				workspaceRoot: "/tmp/work",
+				participantKey: "discord:user:bob",
+				participantLabel: "Bob",
+				welcomeSentAt: new Date().toISOString(),
+			},
+			false,
+		);
+		const runtime = createRuntimeClient("runtime reply");
+		const commonInput = {
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			resolveMuteTarget: ({ target }: { target: string }) =>
+				target === "<@bob>"
+					? {
+							participantKey: "discord:user:bob",
+							participantLabel: "<@bob>",
+						}
+					: undefined,
+		};
+
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: alice.thread as never,
+			text: "/mute@ClineAdapterBot <@bob>",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: alice.thread as never,
+			text: "/unmute@ClineAdapterBot",
+		});
+		await handleConnectorUserTurn({
+			...commonInput,
+			thread: bob.thread as never,
+			text: "bob is still muted",
+			postFinalReply: async ({ text }: { text: string }) => {
+				bob.posts.push(text);
+			},
+		});
+
+		expect(alice.posts).toEqual([
+			"Muted <@bob> in this thread. I will ignore their messages until /unmute <@bob>.",
+			"No thread-level mute is active. Participant-specific mutes are still active for <@bob>. Use /unmute <target> to clear one.",
+		]);
+		expect(bob.posts).toEqual([]);
+		expect(runtime.sendRuntimeSession).not.toHaveBeenCalled();
+	});
+
+	it("aborts active turns for a participant-specific mute", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			participantKey: "discord:user:alice",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("unused");
+		const activeTurns = new Map([
+			[
+				"discord:user:bob",
+				{
+					sessionId: "session-bob",
+					threadId: "thread-1",
+					participantKey: "discord:user:bob",
+				},
+			],
+			[
+				"discord:user:alice",
+				{
+					sessionId: "session-alice",
+					threadId: "thread-1",
+					participantKey: "discord:user:alice",
+				},
+			],
+		]);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "/mute <@bob>",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			activeTurns,
+			resolveMuteTarget: () => ({
+				participantKey: "discord:user:bob",
+				participantLabel: "<@bob>",
+			}),
+		});
+
+		expect(runtime.client.abortRuntimeSession).toHaveBeenCalledTimes(1);
+		expect(runtime.client.abortRuntimeSession).toHaveBeenCalledWith(
+			"session-bob",
+		);
+		expect(posts).toEqual([
+			"Muted <@bob> in this thread. I will ignore their messages until /unmute <@bob>.",
+		]);
+	});
+
+	it("posts adapter fallback replies when the runtime stream is empty", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+		const runtime = createRuntimeClient("");
+		const resolveFallbackText = vi.fn(
+			async () => "Summary from adapter fallback.",
+		);
+		const createEmptyRuntimeReplyResolver = vi.fn(
+			async () => resolveFallbackText,
+		);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "read README.md",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest({
+				enableTools: true,
+				autoApproveTools: true,
+			}) as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "discord",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Discord",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			createEmptyRuntimeReplyResolver,
+		});
+
+		expect(createEmptyRuntimeReplyResolver).toHaveBeenCalledWith({
+			client: runtime.client,
+			sessionId: "session-1",
+		});
+		expect(resolveFallbackText).toHaveBeenCalledTimes(1);
+		expect(runtime.readMessages).not.toHaveBeenCalled();
+		expect(posts.at(-1)).toBe("Summary from adapter fallback.");
+	});
+
+	it("does not post stale fallback replies when no current-turn reply exists", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+		const runtime = createRuntimeClient("");
+		const resolveFallbackText = vi.fn(async () => undefined);
+		const createEmptyRuntimeReplyResolver = vi.fn(
+			async () => resolveFallbackText,
+		);
+
+		await expect(
+			handleConnectorUserTurn({
+				thread: thread as never,
+				text: "run ls /tmp",
+				client: runtime.client as never,
+				pendingApprovals: new Map(),
+				baseStartRequest: baseStartRequest({
+					enableTools: true,
+					autoApproveTools: true,
+				}) as never,
+				explicitSystemPrompt: undefined,
+				clientId: "client-1",
+				logger: {
+					core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+				} as never,
+				transport: "discord",
+				botUserName: "ClineAdapterBot",
+				requestStop: vi.fn(),
+				bindingsPath,
+				systemRules: "rules",
+				errorLabel: "Discord",
+				getSessionMetadata: () => ({}),
+				reusedLogMessage: "reused",
+				startedLogMessage: "started",
+				createEmptyRuntimeReplyResolver,
+			}),
+		).rejects.toThrow("Runtime completed without assistant reply text.");
+
+		expect(createEmptyRuntimeReplyResolver).toHaveBeenCalledWith({
+			client: runtime.client,
+			sessionId: "session-1",
+		});
+		expect(resolveFallbackText).toHaveBeenCalledTimes(1);
+		expect(runtime.readMessages).not.toHaveBeenCalled();
+		expect(posts).not.toContain("Previous reply.");
+	});
+
+	it("keeps Telegram empty-stream behavior from reading session history", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+		});
+		const runtime = createRuntimeClient("", [
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "Previous reply." }],
+			},
+		]);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "run ls /tmp",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest({
+				enableTools: true,
+				autoApproveTools: true,
+			}) as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+		});
+
+		expect(runtime.readMessages).not.toHaveBeenCalled();
+		expect(posts.at(-1)).toEqual({ raw: " " });
+	});
+
+	it("steers active Telegram turns without the hub command timeout", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("unused");
+		const activeTurns = new Map([["thread-1", { sessionId: "session-1" }]]);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "add this detail while you are working",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			activeTurns,
+		});
+
+		expect(runtime.startRuntimeSession).not.toHaveBeenCalled();
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+			expect.objectContaining({
+				delivery: "steer",
+			}),
+			{ timeoutMs: null },
+		);
+		expect(posts.at(-1)).toEqual({ raw: "Steering current task." });
+	});
+
+	it("steers when the same session is active under a different turn key", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			sessionId: "session-1",
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("unused");
+		const activeTurns = new Map([
+			["other-turn-key", { sessionId: "session-1", threadId: "thread-1" }],
+		]);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "reply while another participant key is active",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			activeTurns,
+			turnKey: "thread-1",
+		});
+
+		expect(runtime.startRuntimeSession).not.toHaveBeenCalled();
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+			expect.objectContaining({
+				delivery: "steer",
+			}),
+			{ timeoutMs: null },
+		);
+		expect(posts.at(-1)).toEqual({ raw: "Steering current task." });
+	});
+
+	it("starts a normal turn when the active session is in a different thread", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts } = createThread({
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("normal reply");
+		const activeTurns = new Map([
+			["other-thread", { sessionId: "session-1", threadId: "other-thread" }],
+		]);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "start work in this thread",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			activeTurns,
+			turnKey: "thread-1",
+		});
+
+		expect(runtime.startRuntimeSession).toHaveBeenCalled();
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+			expect.not.objectContaining({
+				delivery: "steer",
+			}),
+			{ timeoutMs: null },
+		);
+		expect(posts.at(-1)).toEqual({ raw: "normal reply" });
+	});
+
+	it("starts a fresh session when persisted thread session is missing from the hub", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
+		tempDirs.push(dir);
+		const bindingsPath = join(dir, "threads.json");
+		const { thread, posts, getState } = createThread({
+			sessionId: "stale-session",
+			enableTools: true,
+			autoApproveTools: true,
+			cwd: "/tmp/work",
+			workspaceRoot: "/tmp/work",
+			welcomeSentAt: new Date().toISOString(),
+		});
+		const runtime = createRuntimeClient("fresh reply");
+		runtime.getSession.mockResolvedValueOnce(undefined);
+
+		await handleConnectorUserTurn({
+			thread: thread as never,
+			text: "continue after hub restart",
+			client: runtime.client as never,
+			pendingApprovals: new Map(),
+			baseStartRequest: baseStartRequest() as never,
+			explicitSystemPrompt: undefined,
+			clientId: "client-1",
+			logger: {
+				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
+			} as never,
+			transport: "telegram",
+			botUserName: "ClineAdapterBot",
+			requestStop: vi.fn(),
+			bindingsPath,
+			systemRules: "rules",
+			errorLabel: "Telegram",
+			getSessionMetadata: () => ({}),
+			reusedLogMessage: "reused",
+			startedLogMessage: "started",
+			turnKey: "thread-1",
+		});
+
+		expect(runtime.getSession).toHaveBeenCalledWith("stale-session");
+		expect(runtime.startRuntimeSession).toHaveBeenCalled();
+		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
+			"session-1",
+			expect.not.objectContaining({
+				delivery: "steer",
+			}),
+			{ timeoutMs: null },
+		);
+		expect(getState().sessionId).toBe("session-1");
+		expect(posts.at(-1)).toEqual({ raw: "fresh reply" });
+	});
+});
diff --git a/apps/cli/src/connectors/connector-host.ts b/apps/cli/src/connectors/connector-host.ts
new file mode 100644
index 0000000..cd100eb
--- /dev/null
+++ b/apps/cli/src/connectors/connector-host.ts
@@ -0,0 +1,1087 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import type {
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+	HubSessionClient,
+	UserInstructionConfigService,
+} from "@cline/core";
+import type { SentMessage, Thread } from "chat";
+import type { CliLoggerAdapter } from "../logging/adapter";
+import { buildUserInputMessage, resolveSystemPrompt } from "../runtime/prompt";
+import {
+	type ChatCommandHost,
+	type ChatCommandState,
+	isCommandAddressedToBot,
+	type MuteCommandInput,
+	maybeHandleChatCommand,
+	normalizeCommandName,
+} from "../utils/chat-commands";
+import { authorizeConnectorEvent, dispatchConnectorHook } from "./hooks";
+import {
+	createConnectorRuntimeTurnStream,
+	formatConnectorApprovalPrompt,
+	type PendingConnectorApproval,
+	parseConnectorApprovalDecision,
+	truncateConnectorText,
+} from "./runtime-turn";
+import {
+	buildThreadStartRequest,
+	clearSession,
+	getOrCreateSessionId,
+} from "./session-runtime";
+import {
+	type ConnectorMuteTarget,
+	type ConnectorThreadState,
+	findMutedParticipantsForThread,
+	isParticipantMutedInBindings,
+	isThreadMutedInBindings,
+	loadThreadState,
+	persistMergedThreadState,
+	persistThreadBinding,
+	readBindings,
+	resolveThreadBindingKey,
+	setParticipantMuted,
+	setThreadMuted,
+} from "./thread-bindings";
+
+export type ActiveConnectorTurn = {
+	sessionId: string;
+	threadId?: string;
+	participantKey?: string;
+};
+
+type EmptyRuntimeReplyResolver = () => Promise<string | undefined>;
+
+type EmptyRuntimeReplyResolverFactory = (input: {
+	client: HubSessionClient;
+	sessionId: string;
+}) =>
+	| Promise<EmptyRuntimeReplyResolver | undefined>
+	| EmptyRuntimeReplyResolver
+	| undefined;
+
+function connectorTextPayload(
+	transport: string,
+	text: string,
+): string | { raw: string } {
+	const body = text.trim() ? text : " ";
+	return transport === "telegram" ? { raw: body } : body;
+}
+
+async function postConnectorText<TState extends ConnectorThreadState>(
+	thread: Thread<TState>,
+	transport: string,
+	text: string,
+): Promise<SentMessage> {
+	return await thread.post(connectorTextPayload(transport, text));
+}
+
+async function editConnectorText(
+	message: SentMessage,
+	transport: string,
+	text: string,
+): Promise<SentMessage> {
+	return await message.edit(connectorTextPayload(transport, text));
+}
+
+function buildAttachments(input: {
+	userImages: string[];
+	userFiles: string[];
+}): ChatRunTurnRequest["attachments"] | undefined {
+	const userImages = input.userImages.length > 0 ? input.userImages : undefined;
+	const userFiles =
+		input.userFiles.length > 0
+			? input.userFiles.map((filePath) => ({
+					name: basename(filePath),
+					content: readFileSync(filePath, "utf8"),
+				}))
+			: undefined;
+	if (!userImages && !userFiles) {
+		return undefined;
+	}
+	return { userImages, userFiles };
+}
+
+async function postConnectorRuntimeReply<TState extends ConnectorThreadState>(
+	thread: Thread<TState>,
+	transport: string,
+	stream: AsyncIterable<string>,
+	postFinalReply?: (text: string) => Promise<void>,
+	resolveFallbackText?: () => Promise<string | undefined>,
+): Promise<void> {
+	if (transport !== "telegram" && !postFinalReply && !resolveFallbackText) {
+		await thread.post(stream);
+		return;
+	}
+
+	let text = "";
+	for await (const chunk of stream) {
+		text += chunk;
+	}
+	if (!text.trim()) {
+		text = (await resolveFallbackText?.())?.trim() || "";
+	}
+	if (isConnectorIdleReply(text)) {
+		return;
+	}
+	if (resolveFallbackText && !text.trim()) {
+		throw new Error("Runtime completed without assistant reply text.");
+	}
+	if (postFinalReply) {
+		await postFinalReply(text);
+		return;
+	}
+	await postConnectorText(thread, transport, text);
+}
+
+function applyForcedToolDisable<TState extends ConnectorThreadState>(
+	state: TState,
+	forceDisableTools: boolean | undefined,
+): TState {
+	if (!forceDisableTools) {
+		return state;
+	}
+	return {
+		...state,
+		enableTools: false,
+		autoApproveTools: false,
+	};
+}
+
+export function isConnectorIdleReply(text: string): boolean {
+	return text.trim().toLowerCase() === "/idle";
+}
+
+function resolveConnectorCommandName(
+	text: string,
+	botUserName: string | undefined,
+): string | undefined {
+	const [commandToken = ""] = text.trim().split(/\s+/);
+	if (!commandToken.startsWith("/")) {
+		return undefined;
+	}
+	return normalizeCommandName(commandToken.toLowerCase(), botUserName);
+}
+
+function getConnectorCommandToken(text: string): string | undefined {
+	const [commandToken = ""] = text.trim().split(/\s+/);
+	return commandToken.startsWith("/") ? commandToken : undefined;
+}
+
+function isConnectorCommandAddressedToThisBot(
+	text: string,
+	botUserName: string | undefined,
+): boolean {
+	const commandToken = getConnectorCommandToken(text);
+	return commandToken
+		? isCommandAddressedToBot(commandToken, botUserName)
+		: false;
+}
+
+function participantMatchesOwner(
+	participantKey: string | undefined,
+	ownerParticipantKeys: readonly string[] | undefined,
+): boolean {
+	const normalizedParticipantKey = participantKey?.trim().toLowerCase();
+	if (!normalizedParticipantKey) {
+		return false;
+	}
+	return (ownerParticipantKeys ?? []).some(
+		(key) => key.trim().toLowerCase() === normalizedParticipantKey,
+	);
+}
+
+function formatMuteTargetLabel(target: ConnectorMuteTarget): string {
+	return target.participantLabel?.trim() || target.participantKey;
+}
+
+function formatMuteTargetList(targets: ConnectorMuteTarget[]): string {
+	return targets.map(formatMuteTargetLabel).join(", ");
+}
+
+export async function handleConnectorUserTurn<
+	TState extends ConnectorThreadState,
+>(input: {
+	thread: Thread<TState>;
+	text: string;
+	runtimeText?: string;
+	client: HubSessionClient;
+	pendingApprovals: Map<string, PendingConnectorApproval>;
+	baseStartRequest: ChatStartSessionRequest;
+	explicitSystemPrompt: string | undefined;
+	clientId: string;
+	logger: CliLoggerAdapter;
+	transport: string;
+	botUserName?: string;
+	ownerParticipantKeys?: string[];
+	requestStop: (reason: string) => void;
+	bindingsPath: string;
+	hookCommand?: string;
+	systemRules: string;
+	errorLabel: string;
+	getSessionMetadata: (
+		thread: Thread<TState>,
+		clientId: string,
+		currentState: TState,
+	) => Record<string, unknown>;
+	getScheduleDeliveryMetadata?: (
+		thread: Thread<TState>,
+	) => Record<string, unknown>;
+	firstContactMessage?: string | ((currentState: TState) => string | undefined);
+	chatCommandHost?: ChatCommandHost;
+	userInstructionService?: UserInstructionConfigService;
+	activeTurns?: Map<string, ActiveConnectorTurn>;
+	turnKey?: string;
+	resolveMuteTarget?: (input: {
+		target: string;
+		thread: Thread<TState>;
+		currentState: TState;
+	}) =>
+		| Promise<ConnectorMuteTarget | undefined>
+		| ConnectorMuteTarget
+		| undefined;
+	forceDisableTools?: boolean;
+	reusedLogMessage: string;
+	startedLogMessage?: string;
+	messageReceivedLogMessage?: string;
+	threadResetLogMessage?: string;
+	connectorStopLogMessage?: string;
+	onMessageReceived?: (details: {
+		threadId: string;
+		channelId: string;
+		isDM: boolean;
+		textLength: number;
+		textPreview: string;
+	}) => Promise<void>;
+	onDescribe?: (
+		currentState: TState,
+		baseStartRequest: ChatStartSessionRequest,
+		thread: Thread<TState>,
+	) => Promise<string> | string;
+	postFinalReply?: (input: {
+		thread: Thread<TState>;
+		text: string;
+	}) => Promise<void>;
+	createEmptyRuntimeReplyResolver?: EmptyRuntimeReplyResolverFactory;
+	onReplyCompleted?: (result: {
+		sessionId: string;
+		threadId: string;
+		text: string;
+		finishReason?: string;
+		iterations?: number;
+	}) => Promise<void>;
+	onReplyFailed?: (details: {
+		sessionId: string;
+		threadId: string;
+		error: Error;
+	}) => Promise<void>;
+}): Promise<void> {
+	const resolvedInput = input.text.trim();
+	if (!resolvedInput) {
+		return;
+	}
+	const runtimeInput = input.runtimeText?.trim() || resolvedInput;
+
+	const initialState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	const authorization = await authorizeConnectorEvent(
+		input.hookCommand,
+		{
+			adapter: input.transport,
+			botUserName: input.botUserName,
+			request: {
+				actor: {
+					id: initialState.participantKey || undefined,
+					label: initialState.participantLabel || undefined,
+					participantKey: initialState.participantKey || undefined,
+					participantLabel: initialState.participantLabel || undefined,
+				},
+				context: {
+					source: input.transport,
+					sourceEvent: "message.received",
+					threadId: input.thread.id,
+					channelId: input.thread.channelId,
+					isDM: input.thread.isDM,
+					sessionId: initialState.sessionId || undefined,
+					workspaceRoot:
+						initialState.workspaceRoot || input.baseStartRequest.workspaceRoot,
+					metadata: {
+						botUserName: input.botUserName,
+					},
+				},
+				payload: {
+					text: resolvedInput,
+					textLength: resolvedInput.length,
+					textPreview: truncateConnectorText(resolvedInput),
+				},
+			},
+		},
+		input.logger,
+	);
+	if (authorization.action === "deny") {
+		const denialMessage =
+			authorization.message?.trim() ||
+			"You are not authorized to use this bot.";
+		await postConnectorText(input.thread, input.transport, denialMessage);
+		await dispatchConnectorHook(
+			input.hookCommand,
+			{
+				adapter: input.transport,
+				botUserName: input.botUserName,
+				event: "message.denied",
+				payload: {
+					threadId: input.thread.id,
+					channelId: input.thread.channelId,
+					isDM: input.thread.isDM,
+					participantKey: initialState.participantKey,
+					participantLabel: initialState.participantLabel,
+					reason: authorization.reason,
+					message: denialMessage,
+				},
+				ts: new Date().toISOString(),
+			},
+			input.logger,
+		);
+		input.logger.core.log(
+			"Inbound connector event denied by authorization hook",
+			{
+				transport: input.transport,
+				threadId: input.thread.id,
+				channelId: input.thread.channelId,
+				participantKey: initialState.participantKey,
+				reason: authorization.reason,
+			},
+		);
+		return;
+	}
+	const commandName = resolveConnectorCommandName(
+		resolvedInput,
+		input.botUserName,
+	);
+	const isConnectorCommand = commandName !== undefined;
+	if (
+		isConnectorCommand &&
+		!input.thread.isDM &&
+		!isConnectorCommandAddressedToThisBot(resolvedInput, input.botUserName)
+	) {
+		input.logger.core.log("Unaddressed connector chat command ignored", {
+			transport: input.transport,
+			threadId: input.thread.id,
+			channelId: input.thread.channelId,
+			participantKey: initialState.participantKey,
+			textPreview: truncateConnectorText(resolvedInput),
+		});
+		return;
+	}
+	if (
+		isConnectorCommand &&
+		input.ownerParticipantKeys?.length &&
+		!participantMatchesOwner(
+			initialState.participantKey,
+			input.ownerParticipantKeys,
+		)
+	) {
+		await postConnectorText(
+			input.thread,
+			input.transport,
+			"Only the connector owner can use slash commands.",
+		);
+		input.logger.core.log("Non-owner connector chat command denied", {
+			transport: input.transport,
+			threadId: input.thread.id,
+			channelId: input.thread.channelId,
+			participantKey: initialState.participantKey,
+			ownerParticipantKeys: input.ownerParticipantKeys,
+			textPreview: truncateConnectorText(resolvedInput),
+		});
+		return;
+	}
+	const turnBindings = readBindings<TState>(input.bindingsPath);
+	const threadMuted = isThreadMutedInBindings(turnBindings, input.thread);
+	const participantMuted = isParticipantMutedInBindings(
+		turnBindings,
+		input.thread,
+		initialState.participantKey,
+	);
+	if (
+		(threadMuted || participantMuted) &&
+		commandName !== "/unmute" &&
+		commandName !== "/mute"
+	) {
+		input.logger.core.log("Muted connector thread message ignored", {
+			transport: input.transport,
+			threadId: input.thread.id,
+			channelId: input.thread.channelId,
+			participantKey: initialState.participantKey,
+			muteScope: threadMuted ? "thread" : "participant",
+			textPreview: truncateConnectorText(resolvedInput),
+		});
+		return;
+	}
+	const turnKey =
+		input.turnKey ||
+		resolveThreadBindingKey(
+			{
+				id: input.thread.id,
+				channelId: input.thread.channelId,
+				isDM: input.thread.isDM,
+				participantKey: initialState.participantKey,
+			},
+			initialState,
+		);
+	const firstContactMessage =
+		typeof input.firstContactMessage === "function"
+			? input.firstContactMessage(initialState)
+			: input.firstContactMessage;
+	let initialStateChanged = false;
+	if (!initialState.welcomeSentAt && firstContactMessage?.trim()) {
+		await postConnectorText(
+			input.thread,
+			input.transport,
+			firstContactMessage.trim(),
+		);
+		initialState.welcomeSentAt = new Date().toISOString();
+		initialStateChanged = true;
+	}
+	if (initialStateChanged) {
+		await persistMergedThreadState(
+			input.thread,
+			input.bindingsPath,
+			initialState,
+			input.errorLabel,
+		);
+	} else {
+		persistThreadBinding(
+			input.bindingsPath,
+			input.thread,
+			initialState,
+			input.errorLabel,
+		);
+	}
+
+	const textPreview = truncateConnectorText(resolvedInput);
+	const receivedDetails = {
+		threadId: input.thread.id,
+		channelId: input.thread.channelId,
+		isDM: input.thread.isDM,
+		textLength: resolvedInput.length,
+		textPreview,
+	};
+	if (input.messageReceivedLogMessage) {
+		input.logger.core.log(input.messageReceivedLogMessage, {
+			transport: input.transport,
+			...receivedDetails,
+		});
+	}
+	await input.onMessageReceived?.(receivedDetails);
+
+	const toolLockCommand = commandName?.match(/^\/(tools|yolo)$/i);
+	if (input.forceDisableTools && toolLockCommand) {
+		const settingName = toolLockCommand[1]?.toLowerCase();
+		await postConnectorText(
+			input.thread,
+			input.transport,
+			`${settingName}=off (disabled by connector startup)`,
+		);
+		return;
+	}
+
+	if (
+		await maybeHandleChatCommand(resolvedInput, {
+			enabled: true,
+			botUserName: input.botUserName,
+			requireBotMention: !input.thread.isDM,
+			host: input.chatCommandHost,
+			getState: async () => {
+				const current = await loadThreadState(
+					input.thread,
+					input.bindingsPath,
+					input.baseStartRequest,
+				);
+				const effectiveCurrent = applyForcedToolDisable(
+					current,
+					input.forceDisableTools,
+				);
+				return {
+					enableTools:
+						effectiveCurrent.enableTools ?? input.baseStartRequest.enableTools,
+					autoApproveTools:
+						effectiveCurrent.autoApproveTools ??
+						input.baseStartRequest.autoApproveTools === true,
+					cwd:
+						effectiveCurrent.cwd ||
+						input.baseStartRequest.cwd ||
+						input.baseStartRequest.workspaceRoot,
+					workspaceRoot:
+						effectiveCurrent.workspaceRoot ||
+						input.baseStartRequest.workspaceRoot,
+					toolsLocked: input.forceDisableTools,
+					threadMuted: isThreadMutedInBindings(turnBindings, input.thread),
+				};
+			},
+			setState: async (next: ChatCommandState) => {
+				const currentState = await loadThreadState(
+					input.thread,
+					input.bindingsPath,
+					input.baseStartRequest,
+				);
+				const systemPrompt = await resolveSystemPrompt({
+					cwd: next.cwd,
+					explicitSystemPrompt: input.explicitSystemPrompt,
+					providerId: input.baseStartRequest.provider,
+					rules: input.systemRules,
+				});
+				const nextState = {
+					...currentState,
+					enableTools: input.forceDisableTools ? false : next.enableTools,
+					autoApproveTools: input.forceDisableTools
+						? false
+						: next.autoApproveTools,
+					cwd: next.cwd,
+					workspaceRoot: next.workspaceRoot,
+					systemPrompt,
+				};
+				const effectiveCurrent = applyForcedToolDisable(
+					currentState,
+					input.forceDisableTools,
+				);
+				const runtimeConfigChanged =
+					(effectiveCurrent.enableTools ??
+						input.baseStartRequest.enableTools) !== nextState.enableTools ||
+					(effectiveCurrent.autoApproveTools ??
+						input.baseStartRequest.autoApproveTools === true) !==
+						nextState.autoApproveTools ||
+					(effectiveCurrent.cwd || input.baseStartRequest.cwd) !== next.cwd ||
+					(effectiveCurrent.workspaceRoot ||
+						input.baseStartRequest.workspaceRoot) !== next.workspaceRoot ||
+					(effectiveCurrent.systemPrompt ||
+						input.baseStartRequest.systemPrompt) !== systemPrompt;
+				if (runtimeConfigChanged && currentState.sessionId?.trim()) {
+					await clearSession({
+						thread: input.thread,
+						client: input.client,
+						bindingsPath: input.bindingsPath,
+						baseStartRequest: input.baseStartRequest,
+						errorLabel: input.errorLabel,
+					});
+					nextState.sessionId = undefined;
+				}
+				await persistMergedThreadState(
+					input.thread,
+					input.bindingsPath,
+					nextState as TState,
+					input.errorLabel,
+				);
+			},
+			reply: async (message) => {
+				await postConnectorText(input.thread, input.transport, message);
+			},
+			reset: async () => {
+				await clearSession({
+					thread: input.thread,
+					client: input.client,
+					bindingsPath: input.bindingsPath,
+					baseStartRequest: input.baseStartRequest,
+					errorLabel: input.errorLabel,
+				});
+				if (input.threadResetLogMessage) {
+					input.logger.core.log(input.threadResetLogMessage, {
+						transport: input.transport,
+						threadId: input.thread.id,
+					});
+				}
+				await dispatchConnectorHook(
+					input.hookCommand,
+					{
+						adapter: input.transport,
+						botUserName: input.botUserName,
+						event: "session.reset",
+						payload: {
+							threadId: input.thread.id,
+							channelId: input.thread.channelId,
+						},
+						ts: new Date().toISOString(),
+					},
+					input.logger,
+				);
+			},
+			abort: async () => {
+				const activeTurn = input.activeTurns?.get(turnKey);
+				if (!activeTurn?.sessionId?.trim()) {
+					await postConnectorText(
+						input.thread,
+						input.transport,
+						"No active task to abort.",
+					);
+					return;
+				}
+				await input.client.abortRuntimeSession(activeTurn.sessionId);
+				await postConnectorText(
+					input.thread,
+					input.transport,
+					"Aborting current task.",
+				);
+			},
+			mute: async (commandInput: MuteCommandInput) => {
+				const target = commandInput.target?.trim()
+					? await input.resolveMuteTarget?.({
+							target: commandInput.target,
+							thread: input.thread,
+							currentState: initialState,
+						})
+					: undefined;
+				if (commandInput.target?.trim() && !target) {
+					return `Could not resolve mute target: ${commandInput.target.trim()}`;
+				}
+				const activeTurns = input.activeTurns
+					? Array.from(input.activeTurns.entries()).filter(([key, turn]) =>
+							target
+								? key === target.participantKey ||
+									turn.participantKey === target.participantKey
+								: key === turnKey ||
+									turn.threadId === input.thread.id ||
+									(initialState.sessionId?.trim() &&
+										turn.sessionId === initialState.sessionId.trim()),
+						)
+					: [];
+				await Promise.allSettled(
+					activeTurns.map(([, turn]) =>
+						input.client.abortRuntimeSession(turn.sessionId),
+					),
+				);
+				if (target) {
+					setParticipantMuted(
+						input.bindingsPath,
+						input.thread,
+						target,
+						true,
+						input.errorLabel,
+					);
+					return `Muted ${formatMuteTargetLabel(target)} in this thread. I will ignore their messages until /unmute ${formatMuteTargetLabel(target)}.`;
+				}
+				setThreadMuted(
+					input.bindingsPath,
+					input.thread,
+					true,
+					input.errorLabel,
+				);
+				return undefined;
+			},
+			unmute: async (commandInput: MuteCommandInput) => {
+				const target = commandInput.target?.trim()
+					? await input.resolveMuteTarget?.({
+							target: commandInput.target,
+							thread: input.thread,
+							currentState: initialState,
+						})
+					: undefined;
+				if (commandInput.target?.trim() && !target) {
+					return `Could not resolve unmute target: ${commandInput.target.trim()}`;
+				}
+				if (target) {
+					setParticipantMuted(
+						input.bindingsPath,
+						input.thread,
+						target,
+						false,
+						input.errorLabel,
+					);
+					return `Unmuted ${formatMuteTargetLabel(target)} in this thread.`;
+				}
+				if (!threadMuted) {
+					const mutedParticipants = findMutedParticipantsForThread(
+						turnBindings,
+						input.thread,
+					);
+					if (mutedParticipants.length > 0) {
+						return `No thread-level mute is active. Participant-specific mutes are still active for ${formatMuteTargetList(mutedParticipants)}. Use /unmute <target> to clear one.`;
+					}
+					return "Thread is not muted.";
+				}
+				setThreadMuted(
+					input.bindingsPath,
+					input.thread,
+					false,
+					input.errorLabel,
+				);
+				return undefined;
+			},
+			stop: async () => {
+				await clearSession({
+					thread: input.thread,
+					client: input.client,
+					bindingsPath: input.bindingsPath,
+					baseStartRequest: input.baseStartRequest,
+					errorLabel: input.errorLabel,
+				});
+				if (input.connectorStopLogMessage) {
+					input.logger.core.log(input.connectorStopLogMessage, {
+						severity: "warn",
+						transport: input.transport,
+						threadId: input.thread.id,
+					});
+				}
+				input.requestStop(`${input.transport}_stop_command`);
+			},
+			describe: async () => {
+				const current = await loadThreadState(
+					input.thread,
+					input.bindingsPath,
+					input.baseStartRequest,
+				);
+				const effectiveCurrent = applyForcedToolDisable(
+					current,
+					input.forceDisableTools,
+				);
+				if (input.onDescribe) {
+					return input.onDescribe(
+						effectiveCurrent,
+						input.baseStartRequest,
+						input.thread,
+					);
+				}
+				return [
+					`threadId=${input.thread.id}`,
+					`channelId=${input.thread.channelId}`,
+					`deliveryAdapter=${input.transport}`,
+					`deliveryThread=${input.thread.id}`,
+					`deliveryBindingKey=${input.thread.id}`,
+					`deliveryChannel=${input.thread.channelId}`,
+					...(input.botUserName
+						? [`deliveryUserName=${input.botUserName}`]
+						: []),
+					...(effectiveCurrent.participantLabel
+						? [`participant=${effectiveCurrent.participantLabel}`]
+						: []),
+					...(effectiveCurrent.participantKey
+						? [`participantKey=${effectiveCurrent.participantKey}`]
+						: []),
+					`isDM=${input.thread.isDM ? "true" : "false"}`,
+					`tools=${effectiveCurrent.enableTools ? "on" : "off"}`,
+					`yolo=${effectiveCurrent.autoApproveTools ? "on" : "off"}`,
+					`muted=${threadMuted ? "true" : "false"}`,
+					`cwd=${effectiveCurrent.cwd || input.baseStartRequest.cwd}`,
+					`workspaceRoot=${effectiveCurrent.workspaceRoot || input.baseStartRequest.workspaceRoot}`,
+				].join("\n");
+			},
+			schedule: {
+				create: async ({ name, cronPattern, prompt }) => {
+					const current = await loadThreadState(
+						input.thread,
+						input.bindingsPath,
+						input.baseStartRequest,
+					);
+					const effectiveCurrent = applyForcedToolDisable(
+						current,
+						input.forceDisableTools,
+					);
+					const config = buildThreadStartRequest(
+						input.baseStartRequest,
+						effectiveCurrent,
+					);
+					const metadata = {
+						delivery: {
+							adapter: input.transport,
+							threadId: input.thread.id,
+							bindingKey: input.thread.id,
+							...(current.participantKey
+								? { participantKey: current.participantKey }
+								: {}),
+							...(current.participantLabel
+								? { participantLabel: current.participantLabel }
+								: {}),
+							channelId: input.thread.channelId,
+							...(input.botUserName ? { userName: input.botUserName } : {}),
+							...(input.getScheduleDeliveryMetadata?.(input.thread) ?? {}),
+						},
+					};
+					const created = await input.client.createSchedule({
+						name,
+						cronPattern,
+						prompt,
+						provider: config.provider,
+						model: config.model,
+						mode: config.mode,
+						workspaceRoot: config.workspaceRoot,
+						cwd: config.cwd,
+						systemPrompt: config.systemPrompt,
+						metadata,
+						runtimeOptions: {
+							enableTools: config.enableTools,
+							enableSpawn: config.enableSpawn,
+							enableTeams: config.enableTeams,
+							autoApproveTools: config.autoApproveTools,
+						},
+					});
+					if (!created) {
+						return "Failed to create schedule.";
+					}
+					return [
+						`Scheduled "${created.name}".`,
+						`id=${created.scheduleId}`,
+						`cron=${created.cronPattern}`,
+						`nextRunAt=${created.nextRunAt || "pending"}`,
+					].join("\n");
+				},
+				list: async () => {
+					const schedules = await input.client.listSchedules({ limit: 200 });
+					const matching = schedules.filter((schedule) => {
+						const delivery = schedule.metadata?.delivery;
+						const deliveryRecord =
+							delivery &&
+							typeof delivery === "object" &&
+							!Array.isArray(delivery)
+								? (delivery as Record<string, unknown>)
+								: undefined;
+						return (
+							deliveryRecord?.adapter === input.transport &&
+							deliveryRecord.threadId === input.thread.id
+						);
+					});
+					if (matching.length === 0) {
+						return "No schedules are targeting this thread.";
+					}
+					return matching
+						.map((schedule) =>
+							[
+								`${schedule.scheduleId} ${schedule.enabled ? "[enabled]" : "[disabled]"}`,
+								`name=${schedule.name}`,
+								`cron=${schedule.cronPattern}`,
+								`nextRunAt=${schedule.nextRunAt || "pending"}`,
+							].join("\n"),
+						)
+						.join("\n\n");
+				},
+				trigger: async (scheduleId) => {
+					const execution = await input.client.triggerScheduleNow(scheduleId);
+					if (!execution) {
+						return `Schedule not found: ${scheduleId}`;
+					}
+					return [
+						`Triggered schedule ${scheduleId}.`,
+						`executionId=${execution.executionId}`,
+						`status=${execution.status}`,
+					].join("\n");
+				},
+				delete: async (scheduleId) => {
+					const deleted = await input.client.deleteSchedule(scheduleId);
+					return deleted
+						? `Deleted schedule ${scheduleId}.`
+						: `Schedule not found: ${scheduleId}`;
+				},
+			},
+		})
+	) {
+		return;
+	}
+
+	const currentState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	const effectiveCurrentState = applyForcedToolDisable(
+		currentState,
+		input.forceDisableTools,
+	);
+	const startRequest = buildThreadStartRequest(
+		input.baseStartRequest,
+		effectiveCurrentState,
+	);
+	const activeTurn =
+		input.activeTurns?.get(turnKey) ??
+		(input.activeTurns && currentState.sessionId?.trim()
+			? Array.from(input.activeTurns.values()).find(
+					(turn) =>
+						turn.sessionId === currentState.sessionId?.trim() &&
+						turn.threadId === input.thread.id,
+				)
+			: undefined);
+	if (activeTurn?.sessionId?.trim()) {
+		const { prompt, userImages, userFiles } = await buildUserInputMessage(
+			runtimeInput,
+			input.userInstructionService,
+		);
+		await input.client.sendRuntimeSession(
+			activeTurn.sessionId,
+			{
+				config: startRequest,
+				prompt,
+				attachments: buildAttachments({ userImages, userFiles }),
+				delivery: "steer",
+			},
+			{ timeoutMs: null },
+		);
+		await postConnectorText(
+			input.thread,
+			input.transport,
+			"Steering current task.",
+		);
+		return;
+	}
+	const sessionId = await getOrCreateSessionId({
+		thread: input.thread,
+		client: input.client,
+		startRequest,
+		logger: input.logger,
+		clientId: input.clientId,
+		transport: input.transport,
+		bindingsPath: input.bindingsPath,
+		errorLabel: input.errorLabel,
+		hookCommand: input.hookCommand,
+		hookBotUserName: input.botUserName,
+		sessionMetadata: input.getSessionMetadata(
+			input.thread,
+			input.clientId,
+			currentState,
+		),
+		reusedLogMessage: input.reusedLogMessage,
+		startedLogMessage: input.startedLogMessage,
+	});
+	const { prompt, userImages, userFiles } = await buildUserInputMessage(
+		runtimeInput,
+		input.userInstructionService,
+	);
+	const request: ChatRunTurnRequest = {
+		config: startRequest,
+		prompt,
+		attachments: buildAttachments({ userImages, userFiles }),
+	};
+	const resolveFallbackText = await input.createEmptyRuntimeReplyResolver?.({
+		client: input.client,
+		sessionId,
+	});
+
+	input.activeTurns?.set(turnKey, {
+		sessionId,
+		threadId: input.thread.id,
+		participantKey: currentState.participantKey,
+	});
+	await input.thread.startTyping();
+	let toolStatusMessage: SentMessage | undefined;
+	const postFinalReply = input.postFinalReply
+		? async (text: string) => {
+				await input.postFinalReply?.({ thread: input.thread, text });
+			}
+		: undefined;
+	try {
+		await postConnectorRuntimeReply(
+			input.thread,
+			input.transport,
+			createConnectorRuntimeTurnStream({
+				client: input.client,
+				sessionId,
+				request,
+				clientId: input.clientId,
+				logger: input.logger,
+				transport: input.transport,
+				conversationId: input.thread.id,
+				onToolStatus: async (message) => {
+					if (toolStatusMessage) {
+						toolStatusMessage = await editConnectorText(
+							toolStatusMessage,
+							input.transport,
+							message,
+						);
+						return;
+					}
+					toolStatusMessage = await postConnectorText(
+						input.thread,
+						input.transport,
+						message,
+					);
+				},
+				onApprovalRequested: async (approval) => {
+					input.pendingApprovals.set(input.thread.id, approval);
+					await postConnectorText(
+						input.thread,
+						input.transport,
+						formatConnectorApprovalPrompt(approval),
+					);
+				},
+				onCompleted: async (result) => {
+					await input.onReplyCompleted?.({
+						sessionId,
+						threadId: input.thread.id,
+						text: result.text,
+						finishReason: result.finishReason,
+						iterations: result.iterations,
+					});
+				},
+				onFailed: async (error) => {
+					await input.onReplyFailed?.({
+						sessionId,
+						threadId: input.thread.id,
+						error,
+					});
+				},
+			}),
+			postFinalReply,
+			resolveFallbackText,
+		);
+	} finally {
+		input.pendingApprovals.delete(input.thread.id);
+		input.activeTurns?.delete(turnKey);
+		if (toolStatusMessage) {
+			await toolStatusMessage.delete().catch(() => undefined);
+		}
+	}
+
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...currentState,
+			sessionId,
+		},
+		input.errorLabel,
+	);
+}
+
+export async function maybeHandleConnectorApprovalReply<
+	TState extends ConnectorThreadState,
+>(input: {
+	thread: Thread<TState>;
+	text: string;
+	client: HubSessionClient;
+	clientId: string;
+	pendingApprovals: Map<string, PendingConnectorApproval>;
+	deniedReason: string;
+	transport?: string;
+}): Promise<boolean> {
+	const pending = input.pendingApprovals.get(input.thread.id);
+	if (!pending) {
+		return false;
+	}
+	const decision = parseConnectorApprovalDecision(
+		input.text,
+		input.deniedReason,
+	);
+	if (!decision) {
+		await postConnectorText(
+			input.thread,
+			input.transport ?? "",
+			`Approval pending for "${pending.toolName}". Reply "Y" to approve or "N" to deny.`,
+		);
+		return true;
+	}
+	input.pendingApprovals.delete(input.thread.id);
+	await input.client.respondToolApproval({
+		approvalId: pending.approvalId,
+		approved: decision.approved,
+		reason: decision.reason,
+		responderClientId: input.clientId,
+	});
+	await postConnectorText(
+		input.thread,
+		input.transport ?? "",
+		decision.approved
+			? `Approved "${pending.toolName}".`
+			: `Denied "${pending.toolName}".`,
+	);
+	return true;
+}
diff --git a/apps/cli/src/connectors/hooks.ts b/apps/cli/src/connectors/hooks.ts
new file mode 100644
index 0000000..9de5252
--- /dev/null
+++ b/apps/cli/src/connectors/hooks.ts
@@ -0,0 +1,143 @@
+import { runSubprocessEvent } from "@cline/core";
+import type {
+	ConnectorAuthorizationDecision,
+	ConnectorAuthorizationRequest,
+	ConnectorHookEvent,
+} from "@cline/shared";
+import { z } from "zod";
+import type { CliLoggerAdapter } from "../logging/adapter";
+
+const ConnectorAuthorizationDecisionSchema = z.object({
+	action: z.enum(["allow", "deny"]).default("allow"),
+	message: z.string().optional(),
+	reason: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export async function dispatchConnectorHook(
+	command: string | undefined,
+	hookPayload: ConnectorHookEvent,
+	logger: CliLoggerAdapter,
+): Promise<void> {
+	const trimmed = command?.trim();
+	if (!trimmed) {
+		return;
+	}
+
+	try {
+		const shell = process.env.SHELL?.trim() || "sh";
+		const result = await runSubprocessEvent(hookPayload, {
+			command: [shell, "-lc", trimmed],
+			cwd: process.cwd(),
+			env: process.env,
+			onSpawn: ({ command, pid, detached }) => {
+				logger.core.log("Process spawned", {
+					component: "connector-hooks",
+					command: command.join(" "),
+					commandArgs: command.slice(1),
+					executable: command[0],
+					childPid: pid,
+					cwd: process.cwd(),
+					detached,
+					adapter: hookPayload.adapter,
+					event: hookPayload.event,
+				});
+			},
+		});
+		if ((result?.exitCode ?? 0) !== 0) {
+			logger.core.log("Connector hook exited non-zero", {
+				severity: "warn",
+				adapter: hookPayload.adapter,
+				event: hookPayload.event,
+				code: result?.exitCode,
+				stderr: result?.stderr.trim() || undefined,
+			});
+		}
+	} catch (error) {
+		logger.core.log("Connector hook dispatch failed", {
+			severity: "warn",
+			adapter: hookPayload.adapter,
+			event: hookPayload.event,
+			error,
+		});
+	}
+}
+
+export async function authorizeConnectorEvent(
+	command: string | undefined,
+	input: {
+		adapter: string;
+		botUserName?: string;
+		request: ConnectorAuthorizationRequest;
+	},
+	logger: CliLoggerAdapter,
+): Promise<ConnectorAuthorizationDecision> {
+	const trimmed = command?.trim();
+	if (!trimmed) {
+		return { action: "allow" };
+	}
+
+	try {
+		const shell = process.env.SHELL?.trim() || "sh";
+		const result = await runSubprocessEvent(
+			{
+				adapter: input.adapter,
+				botUserName: input.botUserName,
+				event: "session.authorize",
+				payload: input.request,
+				ts: new Date().toISOString(),
+			} satisfies ConnectorHookEvent,
+			{
+				command: [shell, "-lc", trimmed],
+				cwd: process.cwd(),
+				env: process.env,
+				onSpawn: ({ command, pid, detached }) => {
+					logger.core.log("Process spawned", {
+						component: "connector-hooks",
+						command: command.join(" "),
+						commandArgs: command.slice(1),
+						executable: command[0],
+						childPid: pid,
+						cwd: process.cwd(),
+						detached,
+						adapter: input.adapter,
+						event: "session.authorize",
+					});
+				},
+			},
+		);
+
+		const parsed = ConnectorAuthorizationDecisionSchema.safeParse(
+			result?.parsedJson,
+		);
+		if (parsed.success) {
+			return parsed.data;
+		}
+		if ((result?.exitCode ?? 0) !== 0) {
+			logger.core.log("Connector authorization hook exited non-zero", {
+				severity: "warn",
+				adapter: input.adapter,
+				event: "session.authorize",
+				code: result?.exitCode,
+				stderr: result?.stderr.trim() || undefined,
+			});
+		}
+		if (result?.parseError || result?.stdout.trim()) {
+			logger.core.log("Connector authorization hook returned invalid control", {
+				severity: "warn",
+				adapter: input.adapter,
+				event: "session.authorize",
+				parseError: result?.parseError,
+				stdout: result?.stdout.trim() || undefined,
+			});
+		}
+	} catch (error) {
+		logger.core.log("Connector authorization hook dispatch failed", {
+			severity: "warn",
+			adapter: input.adapter,
+			event: "session.authorize",
+			error,
+		});
+	}
+	return { action: "allow" };
+}
diff --git a/apps/cli/src/connectors/registry.test.ts b/apps/cli/src/connectors/registry.test.ts
new file mode 100644
index 0000000..2f9bdb4
--- /dev/null
+++ b/apps/cli/src/connectors/registry.test.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { getConnector, listConnectors } from "./registry";
+
+describe("connector registry", () => {
+	it("registers the Discord connector", async () => {
+		expect(listConnectors().map((connector) => connector.name)).toContain(
+			"discord",
+		);
+
+		await expect(getConnector("discord")).resolves.toMatchObject({
+			name: "discord",
+		});
+	});
+});
diff --git a/apps/cli/src/connectors/registry.ts b/apps/cli/src/connectors/registry.ts
new file mode 100644
index 0000000..039ee49
--- /dev/null
+++ b/apps/cli/src/connectors/registry.ts
@@ -0,0 +1,77 @@
+import { CONNECTOR_CATALOG, listConnectorCatalog } from "./catalog";
+import type { ConnectCommandDefinition } from "./types";
+
+type ConnectorRegistryEntry = {
+	name: string;
+	description: string;
+	load: () => Promise<ConnectCommandDefinition>;
+};
+
+const connectorDescriptions = new Map(
+	CONNECTOR_CATALOG.map((entry) => [entry.name, entry.description]),
+);
+
+const registry = new Map<string, ConnectorRegistryEntry>([
+	[
+		"discord",
+		{
+			name: "discord",
+			description:
+				"Discord interactions and gateway bridge backed by RPC runtime sessions",
+			load: async () => (await import("./adapters/discord")).discordConnector,
+		},
+	],
+	[
+		"gchat",
+		{
+			name: "gchat",
+			description: connectorDescriptions.get("gchat") ?? "Google Chat",
+			load: async () => (await import("./adapters/gchat")).gchatConnector,
+		},
+	],
+	[
+		"linear",
+		{
+			name: "linear",
+			description: connectorDescriptions.get("linear") ?? "Linear",
+			load: async () => (await import("./adapters/linear")).linearConnector,
+		},
+	],
+	[
+		"slack",
+		{
+			name: "slack",
+			description: connectorDescriptions.get("slack") ?? "Slack",
+			load: async () => (await import("./adapters/slack")).slackConnector,
+		},
+	],
+	[
+		"telegram",
+		{
+			name: "telegram",
+			description: connectorDescriptions.get("telegram") ?? "Telegram",
+			load: async () => (await import("./adapters/telegram")).telegramConnector,
+		},
+	],
+	[
+		"whatsapp",
+		{
+			name: "whatsapp",
+			description: connectorDescriptions.get("whatsapp") ?? "WhatsApp",
+			load: async () => (await import("./adapters/whatsapp")).whatsappConnector,
+		},
+	],
+]);
+
+export function listConnectors(): Array<
+	Pick<ConnectorRegistryEntry, "name" | "description">
+> {
+	return listConnectorCatalog();
+}
+
+export async function getConnector(
+	name: string,
+): Promise<ConnectCommandDefinition | undefined> {
+	const entry = registry.get(name.trim().toLowerCase());
+	return entry ? entry.load() : undefined;
+}
diff --git a/apps/cli/src/connectors/runtime-turn.test.ts b/apps/cli/src/connectors/runtime-turn.test.ts
new file mode 100644
index 0000000..c2dc1b1
--- /dev/null
+++ b/apps/cli/src/connectors/runtime-turn.test.ts
@@ -0,0 +1,195 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CliLoggerAdapter } from "../logging/adapter";
+import { createConnectorRuntimeTurnStream } from "./runtime-turn";
+
+type StreamHandlers = {
+	onEvent: (event: {
+		eventType: string;
+		payload: Record<string, unknown>;
+	}) => void;
+	onError: (error: Error) => void;
+};
+
+describe("createConnectorRuntimeTurnStream", () => {
+	it("delivers tool status via callbacks instead of appending it to streamed text", async () => {
+		let handlers: StreamHandlers | undefined;
+
+		const sendRuntimeSession = vi.fn(async () => {
+			handlers?.onEvent({
+				eventType: "runtime.chat.tool_call_start",
+				payload: {
+					toolName: "read_file",
+					input: { path: "/tmp/demo.txt" },
+				},
+			});
+			handlers?.onEvent({
+				eventType: "runtime.chat.text_delta",
+				payload: { text: "Here is the result." },
+			});
+			return {
+				result: {
+					text: "Here is the result.",
+					finishReason: "stop",
+					iterations: 1,
+				},
+			};
+		});
+		const client = {
+			streamEvents: (_request: unknown, callbacks: StreamHandlers) => {
+				handlers = callbacks;
+				return () => {};
+			},
+			sendRuntimeSession,
+		};
+		const request = { config: {} as never, prompt: "hi" };
+
+		const chunks: string[] = [];
+		const toolStatuses: string[] = [];
+		for await (const chunk of createConnectorRuntimeTurnStream({
+			client: client as never,
+			sessionId: "session-1",
+			request,
+			clientId: "client-1",
+			logger: { core: {} } as unknown as CliLoggerAdapter,
+			transport: "telegram",
+			conversationId: "thread-1",
+			onToolStatus: async (message) => {
+				toolStatuses.push(message);
+			},
+		})) {
+			chunks.push(chunk);
+		}
+
+		expect(toolStatuses).toEqual(["Executing read_file..."]);
+		expect(chunks.join("")).toBe("Here is the result.");
+		expect(sendRuntimeSession).toHaveBeenCalledWith("session-1", request, {
+			timeoutMs: null,
+		});
+	});
+
+	it("treats queued runtime turns as non-error completion", async () => {
+		const log = vi.fn();
+		const client = {
+			streamEvents: (_request: unknown, _callbacks: StreamHandlers) => {
+				return () => {};
+			},
+			sendRuntimeSession: vi.fn(async () => ({})),
+		};
+
+		const chunks: string[] = [];
+		for await (const chunk of createConnectorRuntimeTurnStream({
+			client: client as never,
+			sessionId: "session-1",
+			request: { config: {} as never, prompt: "hi" },
+			clientId: "client-1",
+			logger: { core: { log } } as unknown as CliLoggerAdapter,
+			transport: "discord",
+			conversationId: "thread-1",
+		})) {
+			chunks.push(chunk);
+		}
+
+		expect(chunks).toEqual([]);
+		expect(log).toHaveBeenCalledWith(
+			"Connector runtime turn queued",
+			expect.objectContaining({
+				transport: "discord",
+				sessionId: "session-1",
+			}),
+		);
+	});
+
+	it("surfaces normalized runtime failed errors", async () => {
+		let handlers: StreamHandlers | undefined;
+
+		const client = {
+			streamEvents: (_request: unknown, callbacks: StreamHandlers) => {
+				handlers = callbacks;
+				return () => {};
+			},
+			sendRuntimeSession: async () => {
+				handlers?.onEvent({
+					eventType: "runtime.chat.failed",
+					payload: {
+						reason: "error",
+						error: "Invalid API key",
+					},
+				});
+				return {
+					result: {
+						text: "Invalid API key",
+						finishReason: "error",
+						iterations: 1,
+					},
+				};
+			},
+		};
+
+		const failures: string[] = [];
+		await expect(async () => {
+			for await (const _chunk of createConnectorRuntimeTurnStream({
+				client: client as never,
+				sessionId: "session-1",
+				request: { config: {} as never, prompt: "hi" },
+				clientId: "client-1",
+				logger: { core: {} } as unknown as CliLoggerAdapter,
+				transport: "telegram",
+				conversationId: "thread-1",
+				onFailed: async (error) => {
+					failures.push(error.message);
+				},
+			})) {
+				// consume stream
+			}
+		}).rejects.toThrow("Invalid API key");
+
+		expect(failures).toEqual(["Invalid API key"]);
+	});
+
+	it("surfaces normalized runtime failed errors", async () => {
+		let handlers: StreamHandlers | undefined;
+
+		const client = {
+			streamEvents: (_request: unknown, callbacks: StreamHandlers) => {
+				handlers = callbacks;
+				return () => {};
+			},
+			sendRuntimeSession: async () => {
+				handlers?.onEvent({
+					eventType: "runtime.chat.failed",
+					payload: {
+						reason: "error",
+						error: "Invalid API key",
+					},
+				});
+				return {
+					result: {
+						text: "Invalid API key",
+						finishReason: "error",
+						iterations: 1,
+					},
+				};
+			},
+		};
+
+		const failures: string[] = [];
+		await expect(async () => {
+			for await (const _chunk of createConnectorRuntimeTurnStream({
+				client: client as never,
+				sessionId: "session-1",
+				request: { config: {} as never, prompt: "hi" },
+				clientId: "client-1",
+				logger: { core: {} } as unknown as CliLoggerAdapter,
+				transport: "telegram",
+				conversationId: "thread-1",
+				onFailed: async (error) => {
+					failures.push(error.message);
+				},
+			})) {
+				// consume stream
+			}
+		}).rejects.toThrow("Invalid API key");
+
+		expect(failures).toEqual(["Invalid API key"]);
+	});
+});
diff --git a/apps/cli/src/connectors/runtime-turn.ts b/apps/cli/src/connectors/runtime-turn.ts
new file mode 100644
index 0000000..de0c20c
--- /dev/null
+++ b/apps/cli/src/connectors/runtime-turn.ts
@@ -0,0 +1,341 @@
+import type { ChatRunTurnRequest, HubSessionClient } from "@cline/core";
+import type { CliLoggerAdapter } from "../logging/adapter";
+
+export type PendingConnectorApproval = {
+	approvalId: string;
+	sessionId: string;
+	toolCallId: string;
+	toolName: string;
+	input?: unknown;
+};
+
+type QueueItem =
+	| { type: "chunk"; value: string }
+	| { type: "error"; error: Error }
+	| { type: "end" };
+
+export function truncateConnectorText(value: string, maxLength = 160): string {
+	const singleLine = value.replace(/\s+/g, " ").trim();
+	if (singleLine.length <= maxLength) {
+		return singleLine;
+	}
+	return `${singleLine.slice(0, maxLength - 3)}...`;
+}
+
+export function parseToolApprovalInput(inputJson: unknown): unknown {
+	if (typeof inputJson !== "string" || !inputJson.trim()) {
+		return undefined;
+	}
+	try {
+		return JSON.parse(inputJson);
+	} catch {
+		return undefined;
+	}
+}
+
+function formatToolInput(toolName: string | undefined, input: unknown): string {
+	if (input === undefined) {
+		return toolName?.trim() || "";
+	}
+	try {
+		const serialized = JSON.stringify(input);
+		if (!serialized) {
+			return toolName?.trim() || "";
+		}
+		return toolName?.trim() ? `${toolName.trim()} ${serialized}` : serialized;
+	} catch {
+		return toolName?.trim() || "";
+	}
+}
+
+export function formatConnectorToolStatus(input: {
+	toolName: string | undefined;
+	status: "start" | "error";
+	toolInput?: unknown;
+	errorMessage?: string;
+}): string {
+	const resolvedName = input.toolName?.trim() || "unknown_tool";
+	if (input.status === "start") {
+		return `Executing ${resolvedName}...`;
+	}
+	const detail = input.errorMessage?.trim();
+	return detail
+		? `${resolvedName} failed: ${truncateConnectorText(detail, 240)}`
+		: `${resolvedName} failed`;
+}
+
+export function formatConnectorApprovalPrompt(
+	input: PendingConnectorApproval,
+): string {
+	const summary = formatToolInput(input.toolName, input.input);
+	return summary
+		? [
+				`Approval required for "${input.toolName}"`,
+				`Request: ${truncateConnectorText(summary, 220)}`,
+				'Reply "Y" to approve or "N" to deny.',
+			].join("\n")
+		: [
+				`Approval required for "${input.toolName}"`,
+				'Reply "Y" to approve or "N" to deny.',
+			].join("\n");
+}
+
+export function parseConnectorApprovalDecision(
+	text: string,
+	deniedReason = "Denied by user",
+): { approved: boolean; reason?: string } | undefined {
+	const normalized = text.trim().toLowerCase();
+	if (
+		normalized === "y" ||
+		normalized === "yes" ||
+		normalized === "approve" ||
+		normalized === "approved"
+	) {
+		return { approved: true };
+	}
+	if (
+		normalized === "n" ||
+		normalized === "no" ||
+		normalized === "deny" ||
+		normalized === "denied"
+	) {
+		return { approved: false, reason: deniedReason };
+	}
+	return undefined;
+}
+
+function resolveTextDelta(
+	payload: Record<string, unknown>,
+	previous: string,
+): { delta: string; nextText: string } {
+	const accumulated =
+		typeof payload.accumulated === "string" ? payload.accumulated : undefined;
+	if (typeof accumulated === "string") {
+		if (accumulated.startsWith(previous)) {
+			return {
+				delta: accumulated.slice(previous.length),
+				nextText: accumulated,
+			};
+		}
+		if (previous.startsWith(accumulated)) {
+			return {
+				delta: "",
+				nextText: previous,
+			};
+		}
+	}
+	const text = typeof payload.text === "string" ? payload.text : "";
+	return {
+		delta: text,
+		nextText: `${previous}${text}`,
+	};
+}
+
+export function createConnectorRuntimeTurnStream(input: {
+	client: HubSessionClient;
+	sessionId: string;
+	request: ChatRunTurnRequest;
+	clientId: string;
+	logger: CliLoggerAdapter;
+	transport: string;
+	conversationId: string;
+	onToolStatus?: (message: string) => Promise<void>;
+	onApprovalRequested?: (approval: PendingConnectorApproval) => Promise<void>;
+	onCompleted?: (result: {
+		text: string;
+		finishReason?: string;
+		iterations?: number;
+	}) => Promise<void>;
+	onFailed?: (error: Error) => Promise<void>;
+}): AsyncIterable<string> {
+	let lastStatusMessage = "";
+
+	return {
+		[Symbol.asyncIterator]: async function* () {
+			const queue: QueueItem[] = [];
+			let notify: (() => void) | undefined;
+			let streamedText = "";
+			let closed = false;
+			let failed = false;
+
+			const push = (item: QueueItem) => {
+				queue.push(item);
+				notify?.();
+				notify = undefined;
+			};
+
+			const postStatus = async (message: string): Promise<void> => {
+				if (!message || message === lastStatusMessage) {
+					return;
+				}
+				lastStatusMessage = message;
+				await input.onToolStatus?.(message);
+			};
+
+			const stopStreaming = input.client.streamEvents(
+				{
+					clientId: input.clientId,
+					sessionIds: [input.sessionId],
+				},
+				{
+					onEvent: (event) => {
+						if (event.eventType === "approval.requested") {
+							const approvalId =
+								typeof event.payload.approvalId === "string"
+									? event.payload.approvalId.trim()
+									: "";
+							const toolCallId =
+								typeof event.payload.toolCallId === "string"
+									? event.payload.toolCallId.trim()
+									: "";
+							const toolName =
+								typeof event.payload.toolName === "string"
+									? event.payload.toolName.trim()
+									: "";
+							if (!approvalId || !toolCallId || !toolName) {
+								return;
+							}
+							void input.onApprovalRequested?.({
+								approvalId,
+								sessionId: input.sessionId,
+								toolCallId,
+								toolName,
+								input: parseToolApprovalInput(event.payload.inputJson),
+							});
+							return;
+						}
+						if (event.eventType === "runtime.chat.tool_call_start") {
+							void postStatus(
+								formatConnectorToolStatus({
+									toolName:
+										typeof event.payload.toolName === "string"
+											? event.payload.toolName
+											: undefined,
+									status: "start",
+									toolInput: event.payload.input,
+								}),
+							);
+							return;
+						}
+						if (event.eventType === "runtime.chat.tool_call_end") {
+							if (
+								typeof event.payload.error === "string" &&
+								event.payload.error.trim()
+							) {
+								void postStatus(
+									formatConnectorToolStatus({
+										toolName:
+											typeof event.payload.toolName === "string"
+												? event.payload.toolName
+												: undefined,
+										status: "error",
+										errorMessage: event.payload.error,
+									}),
+								);
+							}
+							return;
+						}
+						if (event.eventType !== "runtime.chat.text_delta") {
+							if (event.eventType === "runtime.chat.failed") {
+								failed = true;
+								const message =
+									typeof event.payload.error === "string" &&
+									event.payload.error.trim()
+										? event.payload.error.trim()
+										: "Runtime turn failed";
+								const error = new Error(message);
+								void input.onFailed?.(error);
+								push({ type: "error", error });
+							}
+							return;
+						}
+						const resolved = resolveTextDelta(event.payload, streamedText);
+						streamedText = resolved.nextText;
+						if (resolved.delta) {
+							push({ type: "chunk", value: resolved.delta });
+						}
+					},
+					onError: (error) => {
+						input.logger.core.log(
+							"Connector runtime event stream failed mid-turn",
+							{
+								severity: "warn",
+								transport: input.transport,
+								conversationId: input.conversationId,
+								sessionId: input.sessionId,
+								error,
+							},
+						);
+						push({ type: "error", error });
+					},
+				},
+			);
+
+			const runTurn = input.client
+				.sendRuntimeSession(input.sessionId, input.request, { timeoutMs: null })
+				.then(async (response) => {
+					if (!response.result) {
+						input.logger.core.log("Connector runtime turn queued", {
+							transport: input.transport,
+							conversationId: input.conversationId,
+							sessionId: input.sessionId,
+						});
+						return;
+					}
+					if (failed) {
+						return;
+					}
+					const finalText = response.result.text ?? "";
+					await input.onCompleted?.({
+						text: finalText,
+						finishReason: response.result.finishReason,
+						iterations: response.result.iterations,
+					});
+					if (finalText?.startsWith(streamedText)) {
+						const remainder = finalText.slice(streamedText.length);
+						if (remainder) {
+							push({ type: "chunk", value: remainder });
+						}
+					}
+				})
+				.catch(async (error) => {
+					if (failed) {
+						return;
+					}
+					const resolved =
+						error instanceof Error ? error : new Error(String(error));
+					await input.onFailed?.(resolved);
+					push({ type: "error", error: resolved });
+				})
+				.finally(() => {
+					stopStreaming();
+					push({ type: "end" });
+				});
+
+			try {
+				while (!closed) {
+					if (queue.length === 0) {
+						await new Promise<void>((resolve) => {
+							notify = resolve;
+						});
+					}
+					const item = queue.shift();
+					if (!item) {
+						continue;
+					}
+					if (item.type === "chunk") {
+						yield item.value;
+						continue;
+					}
+					if (item.type === "error") {
+						throw item.error;
+					}
+					closed = true;
+				}
+			} finally {
+				stopStreaming();
+				await runTurn.catch(() => {});
+			}
+		},
+	};
+}
diff --git a/apps/cli/src/connectors/session-runtime.test.ts b/apps/cli/src/connectors/session-runtime.test.ts
new file mode 100644
index 0000000..8b732eb
--- /dev/null
+++ b/apps/cli/src/connectors/session-runtime.test.ts
@@ -0,0 +1,163 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+	mockGetLastUsedProviderSettings,
+	mockGetProviderSettings,
+	mockResolveSystemPrompt,
+	mockGetProviderCollection,
+	mockGetBooleanFlagEnabled,
+} = vi.hoisted(() => ({
+	mockGetLastUsedProviderSettings: vi.fn(),
+	mockGetProviderSettings: vi.fn(),
+	mockResolveSystemPrompt: vi.fn(),
+	mockGetProviderCollection: vi.fn(),
+	mockGetBooleanFlagEnabled: vi.fn(),
+}));
+
+vi.mock("@cline/core", async () => {
+	const actual =
+		await vi.importActual<typeof import("@cline/core")>("@cline/core");
+	return {
+		...actual,
+		ProviderSettingsManager: class {
+			getLastUsedProviderSettings(options?: unknown) {
+				return mockGetLastUsedProviderSettings(options);
+			}
+
+			getProviderSettings(providerId: string) {
+				return mockGetProviderSettings(providerId);
+			}
+		},
+		CoreSessionService: class {},
+		SqliteSessionStore: class {},
+		Llms: {
+			...actual.Llms,
+			getProviderCollection: mockGetProviderCollection,
+		},
+	};
+});
+
+vi.mock("../runtime/prompt", () => ({
+	resolveSystemPrompt: mockResolveSystemPrompt,
+}));
+
+vi.mock("../utils/helpers", () => ({
+	resolveWorkspaceRoot: vi.fn((cwd: string) => cwd),
+}));
+
+vi.mock("../utils/feature-flags", () => ({
+	getCliFeatureFlagsService: () => ({
+		getBooleanFlagEnabled: mockGetBooleanFlagEnabled,
+	}),
+}));
+
+vi.mock("../commands/auth", async () => {
+	const actual =
+		await vi.importActual<typeof import("../commands/auth")>(
+			"../commands/auth",
+		);
+	return {
+		...actual,
+		ensureOAuthProviderApiKey: vi.fn(),
+	};
+});
+
+import { buildConnectorStartRequest } from "./session-runtime";
+
+describe("buildConnectorStartRequest", () => {
+	beforeEach(() => {
+		mockGetBooleanFlagEnabled.mockReturnValue(false);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+		delete process.env.OPENROUTER_API_KEY;
+	});
+
+	it("falls back to provider env vars when persisted settings have no api key", async () => {
+		mockGetLastUsedProviderSettings.mockReturnValue({ provider: "openrouter" });
+		mockGetProviderSettings.mockReturnValue({
+			provider: "openrouter",
+			model: "anthropic/claude-sonnet-4.6",
+		});
+		mockGetProviderCollection.mockReturnValue({
+			provider: { env: ["OPENROUTER_API_KEY"] },
+		});
+		mockResolveSystemPrompt.mockResolvedValue("system");
+		process.env.OPENROUTER_API_KEY = "env-openrouter-key";
+
+		const request = await buildConnectorStartRequest({
+			options: {
+				cwd: "/tmp/work",
+				mode: "act",
+				enableTools: false,
+			},
+			io: { writeln: vi.fn(), writeErr: vi.fn() },
+			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
+			systemRules: "Rules",
+		});
+
+		expect(request.provider).toBe("openrouter");
+		expect(request.apiKey).toBe("env-openrouter-key");
+		expect(request.model).toBe("anthropic/claude-sonnet-4.6");
+		expect(mockGetLastUsedProviderSettings).toHaveBeenCalledWith({
+			isClinePassEnabled: true,
+		});
+	});
+
+	it("uses auth material resolved by provider settings manager", async () => {
+		mockGetLastUsedProviderSettings.mockReturnValue({ provider: "cline-pass" });
+		mockGetProviderSettings.mockReturnValue({
+			provider: "cline-pass",
+			auth: { accessToken: "workos:resolved-token" },
+		});
+		mockGetProviderCollection.mockReturnValue({
+			provider: { env: ["CLINE_API_KEY"] },
+		});
+		mockResolveSystemPrompt.mockResolvedValue("system");
+
+		const request = await buildConnectorStartRequest({
+			options: {
+				cwd: "/tmp/work",
+				mode: "act",
+				enableTools: false,
+			},
+			io: { writeln: vi.fn(), writeErr: vi.fn() },
+			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
+			systemRules: "Rules",
+			defaultModel: "cline-pass/glm-5.2",
+		});
+
+		expect(request.provider).toBe("cline-pass");
+		expect(request.apiKey).toBe("workos:resolved-token");
+		expect(request.model).toBe("cline-pass/glm-5.2");
+	});
+
+	it("uses auth material resolved by provider settings manager", async () => {
+		mockGetLastUsedProviderSettings.mockReturnValue({ provider: "cline-pass" });
+		mockGetProviderSettings.mockReturnValue({
+			provider: "cline-pass",
+			auth: { accessToken: "workos:resolved-token" },
+		});
+		mockGetProviderCollection.mockReturnValue({
+			provider: { env: ["CLINE_API_KEY"] },
+		});
+		mockResolveSystemPrompt.mockResolvedValue("system");
+
+		const request = await buildConnectorStartRequest({
+			options: {
+				cwd: "/tmp/work",
+				mode: "act",
+				enableTools: false,
+			},
+			io: { writeln: vi.fn(), writeErr: vi.fn() },
+			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
+			systemRules: "Rules",
+			defaultModel: "cline-pass/glm-5.2",
+		});
+
+		expect(request.provider).toBe("cline-pass");
+		expect(request.apiKey).toBe("workos:resolved-token");
+		expect(request.model).toBe("cline-pass/glm-5.2");
+	});
+});
diff --git a/apps/cli/src/connectors/session-runtime.ts b/apps/cli/src/connectors/session-runtime.ts
new file mode 100644
index 0000000..4a9ff04
--- /dev/null
+++ b/apps/cli/src/connectors/session-runtime.ts
@@ -0,0 +1,363 @@
+import type { ChatStartSessionRequest, RuntimeLoggerConfig } from "@cline/core";
+import {
+	CoreSessionService,
+	HubSessionClient,
+	Llms,
+	ProviderSettingsManager,
+	SqliteSessionStore,
+} from "@cline/core";
+import type { Thread } from "chat";
+import {
+	ensureOAuthProviderApiKey,
+	getPersistedProviderApiKey,
+	isOAuthProvider,
+	normalizeProviderId,
+} from "../commands/auth";
+import type { CliLoggerAdapter } from "../logging/adapter";
+import { resolveSystemPrompt } from "../runtime/prompt";
+import { resolveCliSessionMetadata } from "../utils/enterprise";
+import { resolveWorkspaceRoot } from "../utils/helpers";
+import {
+	parseLocalRowMetadata,
+	parseRowMetadata,
+	readSessionMessageCount,
+	readSessionReplyText,
+} from "./common";
+import { dispatchConnectorHook } from "./hooks";
+import {
+	type ConnectorThreadState,
+	loadThreadState,
+	persistMergedThreadState,
+} from "./thread-bindings";
+import type { ConnectIo } from "./types";
+
+async function resolveProviderApiKeyFromEnv(
+	provider: string,
+): Promise<string | undefined> {
+	const envKeys =
+		(await Llms.getProviderCollection(provider))?.provider?.env ?? [];
+	for (const envKey of envKeys) {
+		const value = process.env[envKey]?.trim();
+		if (value) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+export async function buildConnectorStartRequest(input: {
+	options: {
+		cwd: string;
+		model?: string;
+		provider?: string;
+		apiKey?: string;
+		systemPrompt?: string;
+		mode: "act" | "plan";
+		enableTools: boolean;
+	};
+	io: ConnectIo;
+	loggerConfig: RuntimeLoggerConfig;
+	systemRules: string;
+	defaultModel?: string;
+}): Promise<ChatStartSessionRequest> {
+	const providerSettingsManager = new ProviderSettingsManager();
+	const lastUsedProviderSettings =
+		providerSettingsManager.getLastUsedProviderSettings({
+			isClinePassEnabled: true,
+		});
+	const provider = normalizeProviderId(
+		input.options.provider?.trim() ||
+			lastUsedProviderSettings?.provider ||
+			"cline",
+	);
+	let selectedProviderSettings =
+		providerSettingsManager.getProviderSettings(provider);
+	const persistedApiKey = getPersistedProviderApiKey(
+		provider,
+		selectedProviderSettings,
+	);
+	let apiKey =
+		input.options.apiKey?.trim() ||
+		persistedApiKey ||
+		(await resolveProviderApiKeyFromEnv(provider)) ||
+		"";
+
+	if (!apiKey && isOAuthProvider(provider)) {
+		const oauthResult = await ensureOAuthProviderApiKey({
+			providerId: provider,
+			currentApiKey: apiKey,
+			existingSettings: selectedProviderSettings,
+			providerSettingsManager,
+			io: input.io,
+		});
+		selectedProviderSettings = oauthResult.selectedProviderSettings;
+		apiKey = oauthResult.apiKey ?? "";
+	}
+
+	const cwd = input.options.cwd;
+	const systemPrompt = await resolveSystemPrompt({
+		cwd,
+		explicitSystemPrompt: input.options.systemPrompt,
+		providerId: provider,
+		rules: input.systemRules,
+	});
+
+	return {
+		workspaceRoot: resolveWorkspaceRoot(cwd),
+		cwd,
+		provider,
+		model:
+			input.options.model?.trim() ||
+			selectedProviderSettings?.model ||
+			input.defaultModel ||
+			"anthropic/claude-sonnet-4.6",
+		mode: input.options.mode,
+		apiKey,
+		systemPrompt,
+		logger: input.loggerConfig,
+		enableTools: input.options.enableTools,
+		autoApproveTools: false,
+	};
+}
+
+export function buildThreadStartRequest<TState extends ConnectorThreadState>(
+	base: ChatStartSessionRequest,
+	state: TState,
+): ChatStartSessionRequest {
+	const enableTools = state.enableTools ?? base.enableTools;
+	return {
+		...base,
+		enableTools,
+		enableSpawn: enableTools,
+		enableTeams: enableTools,
+		autoApproveTools: state.autoApproveTools ?? base.autoApproveTools,
+		cwd: state.cwd || base.cwd,
+		workspaceRoot: state.workspaceRoot || base.workspaceRoot,
+		systemPrompt: state.systemPrompt || base.systemPrompt,
+	};
+}
+
+export async function getOrCreateSessionId<
+	TState extends ConnectorThreadState,
+>(input: {
+	thread: Thread<TState>;
+	client: HubSessionClient;
+	startRequest: ChatStartSessionRequest;
+	logger: CliLoggerAdapter;
+	clientId: string;
+	transport: string;
+	bindingsPath: string;
+	errorLabel: string;
+	hookCommand?: string;
+	hookBotUserName?: string;
+	sessionMetadata: Record<string, unknown>;
+	reusedLogMessage: string;
+	startedLogMessage?: string;
+}): Promise<string> {
+	const threadState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.startRequest,
+	);
+	const existing = threadState.sessionId?.trim();
+	if (existing) {
+		const existingSession = await input.client.getSession(existing);
+		if (existingSession) {
+			await persistMergedThreadState(
+				input.thread,
+				input.bindingsPath,
+				{
+					...threadState,
+					sessionId: existing,
+				},
+				input.errorLabel,
+			);
+			input.logger.core.log(input.reusedLogMessage, {
+				transport: input.transport,
+				threadId: input.thread.id,
+				sessionId: existing,
+			});
+			await dispatchConnectorHook(
+				input.hookCommand,
+				{
+					adapter: input.transport,
+					botUserName: input.hookBotUserName,
+					event: "session.reused",
+					payload: {
+						threadId: input.thread.id,
+						channelId: input.thread.channelId,
+						sessionId: existing,
+					},
+					ts: new Date().toISOString(),
+				},
+				input.logger,
+			);
+			return existing;
+		}
+		await persistMergedThreadState(
+			input.thread,
+			input.bindingsPath,
+			{
+				...threadState,
+				sessionId: undefined,
+			},
+			input.errorLabel,
+		);
+		input.logger.core.log(
+			"Connector thread session missing; starting a new session",
+			{
+				severity: "warn",
+				transport: input.transport,
+				threadId: input.thread.id,
+				sessionId: existing,
+			},
+		);
+	}
+
+	const started = await input.client.startRuntimeSession(input.startRequest);
+	const sessionId = started.sessionId.trim();
+	if (!sessionId) {
+		throw new Error("runtime start returned an empty session id");
+	}
+	const remoteConfigMetadata = await resolveCliSessionMetadata(sessionId).catch(
+		() => undefined,
+	);
+
+	await input.client
+		.updateSession({
+			sessionId,
+			metadata: {
+				transport: input.transport,
+				...input.sessionMetadata,
+				...(remoteConfigMetadata ?? {}),
+				...(threadState.participantKey
+					? { participantKey: threadState.participantKey }
+					: {}),
+				...(threadState.participantLabel
+					? { participantLabel: threadState.participantLabel }
+					: {}),
+				isDM: input.thread.isDM,
+				rpcClientId: input.clientId,
+				connectorPid: process.pid,
+			},
+		})
+		.catch(() => undefined);
+
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...threadState,
+			sessionId,
+		},
+		input.errorLabel,
+	);
+
+	if (input.startedLogMessage) {
+		input.logger.core.log(input.startedLogMessage, {
+			transport: input.transport,
+			threadId: input.thread.id,
+			channelId: input.thread.channelId,
+			isDM: input.thread.isDM,
+			sessionId,
+		});
+	}
+
+	await dispatchConnectorHook(
+		input.hookCommand,
+		{
+			adapter: input.transport,
+			botUserName: input.hookBotUserName,
+			event: "session.started",
+			payload: {
+				threadId: input.thread.id,
+				channelId: input.thread.channelId,
+				isDM: input.thread.isDM,
+				sessionId,
+			},
+			ts: new Date().toISOString(),
+		},
+		input.logger,
+	);
+
+	return sessionId;
+}
+
+export async function clearSession<TState extends ConnectorThreadState>(input: {
+	thread: Thread<TState>;
+	client: HubSessionClient;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	errorLabel: string;
+}): Promise<void> {
+	const threadState = await loadThreadState(
+		input.thread,
+		input.bindingsPath,
+		input.baseStartRequest,
+	);
+	const sessionId = threadState.sessionId?.trim();
+	if (sessionId) {
+		try {
+			await input.client.stopRuntimeSession(sessionId);
+		} catch {}
+		try {
+			await input.client.deleteSession(sessionId, true);
+		} catch {}
+	}
+	await persistMergedThreadState(
+		input.thread,
+		input.bindingsPath,
+		{
+			...threadState,
+			sessionId: undefined,
+		},
+		input.errorLabel,
+	);
+}
+
+export async function stopConnectorSessions(input: {
+	rpcAddress: string;
+	localMatcher: (metadata: Record<string, unknown> | undefined) => boolean;
+	rpcMatcher: (metadata: Record<string, unknown> | undefined) => boolean;
+}): Promise<number> {
+	const client = new HubSessionClient({ address: input.rpcAddress });
+	try {
+		const rows = await client.listSessions({ limit: 5000 });
+		const filtered = rows.filter((row) => {
+			const { metadata, parentSessionId } = parseRowMetadata(row);
+			return !parentSessionId && input.rpcMatcher(metadata);
+		});
+		await Promise.allSettled(
+			filtered.map(async (row) => {
+				try {
+					await client.stopRuntimeSession(row.sessionId);
+				} catch {}
+				try {
+					await client.deleteSession(row.sessionId, true);
+				} catch {}
+			}),
+		);
+		return filtered.length;
+	} catch {
+		// Fall back to local storage when the RPC server is unavailable.
+	} finally {
+		client.close();
+	}
+
+	const service = new CoreSessionService(new SqliteSessionStore());
+	const rows = await service.listSessions(5000);
+	const filtered = rows.filter((row) => {
+		if (row.parentSessionId?.trim()) {
+			return false;
+		}
+		return input.localMatcher(parseLocalRowMetadata(row));
+	});
+	await Promise.allSettled(
+		filtered.map(async (row) => {
+			await service.deleteSession(row.sessionId);
+		}),
+	);
+	return filtered.length;
+}
+
+export { readSessionMessageCount, readSessionReplyText };
diff --git a/apps/cli/src/connectors/status.ts b/apps/cli/src/connectors/status.ts
new file mode 100644
index 0000000..065347b
--- /dev/null
+++ b/apps/cli/src/connectors/status.ts
@@ -0,0 +1,196 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveClineDataDir } from "@cline/core";
+
+function isProcessRunning(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export type ActiveConnectorRecord = {
+	id: string;
+	type: string;
+	pid: number;
+	hubUrl: string;
+	startedAt?: string;
+	applicationId?: string;
+	botUsername?: string;
+	userName?: string;
+	phoneNumberId?: string;
+	port?: number;
+	baseUrl?: string;
+	connectionMode?: string;
+};
+
+function listConnectorStatePaths(
+	type: ActiveConnectorRecord["type"],
+): string[] {
+	const dir = join(resolveClineDataDir(), "connectors", type);
+	if (!existsSync(dir)) {
+		return [];
+	}
+	return readdirSync(dir)
+		.filter((name) => name.endsWith(".json") && !name.endsWith(".threads.json"))
+		.map((name) => join(dir, name));
+}
+
+function readJsonRecord(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) {
+		return undefined;
+	}
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed = JSON.parse(raw) as unknown;
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as Record<string, unknown>;
+		}
+	} catch {
+		// Ignore malformed connector state.
+	}
+	return undefined;
+}
+
+type ConnectorFieldKey = keyof Omit<
+	ActiveConnectorRecord,
+	"id" | "type" | "pid" | "hubUrl"
+>;
+
+const connectorFieldExtractors: Record<
+	ConnectorFieldKey,
+	(p: Record<string, unknown>) => string | number | undefined
+> = {
+	startedAt: (p) => (typeof p.startedAt === "string" ? p.startedAt : undefined),
+	port: (p) => (typeof p.port === "number" ? p.port : undefined),
+	baseUrl: (p) => (typeof p.baseUrl === "string" ? p.baseUrl : undefined),
+	connectionMode: (p) =>
+		typeof p.connectionMode === "string" ? p.connectionMode : undefined,
+	userName: (p) => (typeof p.userName === "string" ? p.userName : undefined),
+	botUsername: (p) =>
+		typeof p.botUsername === "string" ? p.botUsername : undefined,
+	applicationId: (p) =>
+		typeof p.applicationId === "string" ? p.applicationId : undefined,
+	phoneNumberId: (p) =>
+		typeof p.phoneNumberId === "string" ? p.phoneNumberId : undefined,
+};
+
+const connectorConfigs: Record<
+	string,
+	{ required: ConnectorFieldKey[]; optional: ConnectorFieldKey[] }
+> = {
+	discord: {
+		required: ["userName", "applicationId"],
+		optional: ["startedAt", "port", "baseUrl"],
+	},
+	telegram: { required: ["botUsername"], optional: ["startedAt"] },
+	gchat: { required: ["userName"], optional: ["startedAt", "port", "baseUrl"] },
+	linear: {
+		required: ["userName"],
+		optional: ["startedAt", "port", "baseUrl"],
+	},
+	slack: {
+		required: ["userName"],
+		optional: ["startedAt", "connectionMode", "port", "baseUrl"],
+	},
+	whatsapp: {
+		required: ["userName"],
+		optional: ["startedAt", "phoneNumberId", "port", "baseUrl"],
+	},
+};
+
+function connectorRecordId(
+	type: ActiveConnectorRecord["type"],
+	fields: Partial<
+		Omit<ActiveConnectorRecord, "id" | "type" | "pid" | "hubUrl">
+	>,
+	pid: number,
+): string {
+	const identity =
+		fields.botUsername ??
+		fields.userName ??
+		fields.applicationId ??
+		fields.phoneNumberId ??
+		String(pid);
+	return `${type}:${identity}`;
+}
+
+function readActiveConnectorRecord(
+	type: ActiveConnectorRecord["type"],
+	statePath: string,
+): ActiveConnectorRecord | undefined {
+	const parsed = readJsonRecord(statePath);
+	if (!parsed) {
+		return undefined;
+	}
+	const pid = typeof parsed.pid === "number" ? parsed.pid : undefined;
+	const hubUrl =
+		typeof parsed.hubUrl === "string"
+			? parsed.hubUrl
+			: typeof parsed.rpcAddress === "string"
+				? parsed.rpcAddress
+				: undefined;
+	if (!pid || !hubUrl || !isProcessRunning(pid)) {
+		return undefined;
+	}
+	const config = connectorConfigs[type];
+	if (!config) {
+		return undefined;
+	}
+	const fields: Partial<
+		Omit<ActiveConnectorRecord, "id" | "type" | "pid" | "hubUrl">
+	> = {};
+	for (const key of config.required) {
+		const value = connectorFieldExtractors[key](parsed);
+		if (!value || (typeof value === "string" && !value.trim())) {
+			return undefined;
+		}
+		(fields as Record<string, unknown>)[key] = value;
+	}
+	for (const key of config.optional) {
+		const value = connectorFieldExtractors[key](parsed);
+		if (value !== undefined) {
+			(fields as Record<string, unknown>)[key] = value;
+		}
+	}
+	return {
+		id: connectorRecordId(type, fields, pid),
+		type,
+		pid,
+		hubUrl,
+		...fields,
+	} as ActiveConnectorRecord;
+}
+
+export function listActiveConnectors(): ActiveConnectorRecord[] {
+	const connectorTypes: ActiveConnectorRecord["type"][] = [
+		"discord",
+		"telegram",
+		"gchat",
+		"linear",
+		"slack",
+		"whatsapp",
+	];
+	const records: ActiveConnectorRecord[] = [];
+	for (const type of connectorTypes) {
+		for (const statePath of listConnectorStatePaths(type)) {
+			const record = readActiveConnectorRecord(type, statePath);
+			if (record) {
+				records.push(record);
+			}
+		}
+	}
+	return records.sort((left, right) => {
+		if (left.type !== right.type) {
+			return left.type.localeCompare(right.type);
+		}
+		const leftName = left.botUsername ?? left.userName ?? "";
+		const rightName = right.botUsername ?? right.userName ?? "";
+		return leftName.localeCompare(rightName);
+	});
+}
diff --git a/apps/cli/src/connectors/stores/file-state.ts b/apps/cli/src/connectors/stores/file-state.ts
new file mode 100644
index 0000000..c49a406
--- /dev/null
+++ b/apps/cli/src/connectors/stores/file-state.ts
@@ -0,0 +1,296 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { ensureParentDir } from "@cline/core";
+import type { Lock, QueueEntry, StateAdapter } from "chat";
+
+type PersistedStateSnapshot = {
+	values?: Record<string, { expiresAt?: number; value: unknown }>;
+	lists?: Record<string, { expiresAt?: number; value: unknown[] }>;
+	queues?: Record<string, QueueEntry[]>;
+	subscriptions?: string[];
+};
+
+export class FileStateAdapter implements StateAdapter {
+	private readonly values = new Map<
+		string,
+		{ expiresAt?: number; value: unknown }
+	>();
+	private readonly lists = new Map<
+		string,
+		{ expiresAt?: number; value: unknown[] }
+	>();
+	private readonly queues = new Map<string, QueueEntry[]>();
+	private readonly subscriptions = new Set<string>();
+	private readonly locks = new Map<string, Lock>();
+	private loaded = false;
+
+	constructor(private readonly path: string) {}
+
+	private pruneExpiredValues(): void {
+		const now = Date.now();
+		for (const [key, entry] of this.values.entries()) {
+			if (entry.expiresAt && entry.expiresAt <= now) {
+				this.values.delete(key);
+			}
+		}
+		for (const [key, entry] of this.lists.entries()) {
+			if (entry.expiresAt && entry.expiresAt <= now) {
+				this.lists.delete(key);
+			}
+		}
+		for (const [threadId, queue] of this.queues.entries()) {
+			const activeQueue = queue.filter((entry) => entry.expiresAt > now);
+			if (activeQueue.length > 0) {
+				this.queues.set(threadId, activeQueue);
+			} else {
+				this.queues.delete(threadId);
+			}
+		}
+	}
+
+	private loadFromDisk(): void {
+		if (this.loaded) {
+			return;
+		}
+		this.loaded = true;
+		try {
+			const raw = readFileSync(this.path, "utf8");
+			const snapshot = JSON.parse(raw) as PersistedStateSnapshot;
+			for (const [key, entry] of Object.entries(snapshot.values ?? {})) {
+				if (!entry || typeof entry !== "object" || !("value" in entry)) {
+					continue;
+				}
+				this.values.set(key, {
+					value: entry.value,
+					expiresAt:
+						typeof entry.expiresAt === "number" ? entry.expiresAt : undefined,
+				});
+			}
+			for (const [key, entry] of Object.entries(snapshot.lists ?? {})) {
+				if (
+					!entry ||
+					typeof entry !== "object" ||
+					!Array.isArray(entry.value)
+				) {
+					continue;
+				}
+				this.lists.set(key, {
+					value: entry.value,
+					expiresAt:
+						typeof entry.expiresAt === "number" ? entry.expiresAt : undefined,
+				});
+			}
+			for (const [threadId, entries] of Object.entries(snapshot.queues ?? {})) {
+				if (!Array.isArray(entries)) {
+					continue;
+				}
+				this.queues.set(
+					threadId,
+					entries.filter(
+						(entry): entry is QueueEntry =>
+							Boolean(entry) &&
+							typeof entry === "object" &&
+							typeof entry.enqueuedAt === "number" &&
+							typeof entry.expiresAt === "number" &&
+							"message" in entry,
+					),
+				);
+			}
+			for (const threadId of snapshot.subscriptions ?? []) {
+				if (typeof threadId === "string" && threadId.trim()) {
+					this.subscriptions.add(threadId);
+				}
+			}
+			this.pruneExpiredValues();
+		} catch {}
+	}
+
+	private persist(): void {
+		this.pruneExpiredValues();
+		ensureParentDir(this.path);
+		const snapshot: PersistedStateSnapshot = {
+			values: Object.fromEntries(this.values.entries()),
+			lists: Object.fromEntries(this.lists.entries()),
+			queues: Object.fromEntries(this.queues.entries()),
+			subscriptions: [...this.subscriptions],
+		};
+		writeFileSync(this.path, JSON.stringify(snapshot, null, 2), "utf8");
+	}
+
+	async connect(): Promise<void> {
+		this.loadFromDisk();
+	}
+
+	async disconnect(): Promise<void> {}
+
+	async get<T = unknown>(key: string): Promise<T | null> {
+		this.loadFromDisk();
+		const entry = this.values.get(key);
+		if (!entry) {
+			return null;
+		}
+		if (entry.expiresAt && entry.expiresAt <= Date.now()) {
+			this.values.delete(key);
+			this.persist();
+			return null;
+		}
+		return entry.value as T;
+	}
+
+	async set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void> {
+		this.loadFromDisk();
+		this.values.set(key, {
+			value,
+			expiresAt: ttlMs ? Date.now() + ttlMs : undefined,
+		});
+		this.persist();
+	}
+
+	async delete(key: string): Promise<void> {
+		this.loadFromDisk();
+		this.values.delete(key);
+		this.lists.delete(key);
+		this.persist();
+	}
+
+	async dequeue(threadId: string): Promise<QueueEntry | null> {
+		this.loadFromDisk();
+		this.pruneExpiredValues();
+		const queue = this.queues.get(threadId) ?? [];
+		const next = queue.shift() ?? null;
+		if (queue.length > 0) {
+			this.queues.set(threadId, queue);
+		} else {
+			this.queues.delete(threadId);
+		}
+		this.persist();
+		return next;
+	}
+
+	async enqueue(
+		threadId: string,
+		entry: QueueEntry,
+		maxSize: number,
+	): Promise<number> {
+		this.loadFromDisk();
+		this.pruneExpiredValues();
+		const queue = [...(this.queues.get(threadId) ?? []), entry];
+		const trimmed =
+			maxSize > 0 && queue.length > maxSize
+				? queue.slice(queue.length - maxSize)
+				: queue;
+		this.queues.set(threadId, trimmed);
+		this.persist();
+		return trimmed.length;
+	}
+
+	async subscribe(threadId: string): Promise<void> {
+		this.loadFromDisk();
+		this.subscriptions.add(threadId);
+		this.persist();
+	}
+
+	async unsubscribe(threadId: string): Promise<void> {
+		this.loadFromDisk();
+		this.subscriptions.delete(threadId);
+		this.persist();
+	}
+
+	async isSubscribed(threadId: string): Promise<boolean> {
+		this.loadFromDisk();
+		return this.subscriptions.has(threadId);
+	}
+
+	async queueDepth(threadId: string): Promise<number> {
+		this.loadFromDisk();
+		this.pruneExpiredValues();
+		const depth = this.queues.get(threadId)?.length ?? 0;
+		this.persist();
+		return depth;
+	}
+
+	async acquireLock(threadId: string, ttlMs: number): Promise<Lock | null> {
+		this.loadFromDisk();
+		const existing = this.locks.get(threadId);
+		if (existing && existing.expiresAt > Date.now()) {
+			return null;
+		}
+		const lock: Lock = {
+			threadId,
+			token: crypto.randomUUID(),
+			expiresAt: Date.now() + ttlMs,
+		};
+		this.locks.set(threadId, lock);
+		return lock;
+	}
+
+	async extendLock(lock: Lock, ttlMs: number): Promise<boolean> {
+		this.loadFromDisk();
+		const existing = this.locks.get(lock.threadId);
+		if (!existing || existing.token !== lock.token) {
+			return false;
+		}
+		existing.expiresAt = Date.now() + ttlMs;
+		return true;
+	}
+
+	async releaseLock(lock: Lock): Promise<void> {
+		this.loadFromDisk();
+		const existing = this.locks.get(lock.threadId);
+		if (existing?.token === lock.token) {
+			this.locks.delete(lock.threadId);
+		}
+	}
+
+	async appendToList(
+		key: string,
+		value: unknown,
+		options?: { maxLength?: number; ttlMs?: number },
+	): Promise<void> {
+		this.loadFromDisk();
+		const existing = this.lists.get(key);
+		const next = existing ? [...existing.value, value] : [value];
+		const maxLength = options?.maxLength;
+		const trimmed =
+			typeof maxLength === "number" && maxLength > 0 && next.length > maxLength
+				? next.slice(next.length - maxLength)
+				: next;
+		this.lists.set(key, {
+			value: trimmed,
+			expiresAt: options?.ttlMs ? Date.now() + options.ttlMs : undefined,
+		});
+		this.persist();
+	}
+
+	async forceReleaseLock(threadId: string): Promise<void> {
+		this.loadFromDisk();
+		this.locks.delete(threadId);
+	}
+
+	async getList<T = unknown>(key: string): Promise<T[]> {
+		this.loadFromDisk();
+		const entry = this.lists.get(key);
+		if (!entry) {
+			return [];
+		}
+		if (entry.expiresAt && entry.expiresAt <= Date.now()) {
+			this.lists.delete(key);
+			this.persist();
+			return [];
+		}
+		return entry.value as T[];
+	}
+
+	async setIfNotExists(
+		key: string,
+		value: unknown,
+		ttlMs?: number,
+	): Promise<boolean> {
+		this.loadFromDisk();
+		const existing = await this.get(key);
+		if (existing !== null) {
+			return false;
+		}
+		await this.set(key, value, ttlMs);
+		return true;
+	}
+}
diff --git a/apps/cli/src/connectors/stores/memory-state.ts b/apps/cli/src/connectors/stores/memory-state.ts
new file mode 100644
index 0000000..842c956
--- /dev/null
+++ b/apps/cli/src/connectors/stores/memory-state.ts
@@ -0,0 +1,173 @@
+import type { Lock, QueueEntry, StateAdapter } from "chat";
+
+export class InMemoryStateAdapter implements StateAdapter {
+	private readonly values = new Map<
+		string,
+		{ expiresAt?: number; value: unknown }
+	>();
+	private readonly lists = new Map<
+		string,
+		{ expiresAt?: number; value: unknown[] }
+	>();
+	private readonly queues = new Map<string, QueueEntry[]>();
+	private readonly subscriptions = new Set<string>();
+	private readonly locks = new Map<string, Lock>();
+
+	private getActiveQueue(threadId: string): QueueEntry[] {
+		const queue = this.queues.get(threadId) ?? [];
+		const now = Date.now();
+		const activeQueue = queue.filter((entry) => entry.expiresAt > now);
+		if (activeQueue.length > 0) {
+			this.queues.set(threadId, activeQueue);
+		} else {
+			this.queues.delete(threadId);
+		}
+		return activeQueue;
+	}
+
+	async connect(): Promise<void> {}
+
+	async disconnect(): Promise<void> {}
+
+	async get<T = unknown>(key: string): Promise<T | null> {
+		const entry = this.values.get(key);
+		if (!entry) {
+			return null;
+		}
+		if (entry.expiresAt && entry.expiresAt <= Date.now()) {
+			this.values.delete(key);
+			return null;
+		}
+		return entry.value as T;
+	}
+
+	async set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void> {
+		this.values.set(key, {
+			value,
+			expiresAt: ttlMs ? Date.now() + ttlMs : undefined,
+		});
+	}
+
+	async delete(key: string): Promise<void> {
+		this.values.delete(key);
+		this.lists.delete(key);
+	}
+
+	async dequeue(threadId: string): Promise<QueueEntry | null> {
+		const queue = this.getActiveQueue(threadId);
+		const next = queue.shift() ?? null;
+		if (queue.length > 0) {
+			this.queues.set(threadId, queue);
+		} else {
+			this.queues.delete(threadId);
+		}
+		return next;
+	}
+
+	async enqueue(
+		threadId: string,
+		entry: QueueEntry,
+		maxSize: number,
+	): Promise<number> {
+		const queue = [...this.getActiveQueue(threadId), entry];
+		const trimmed =
+			maxSize > 0 && queue.length > maxSize
+				? queue.slice(queue.length - maxSize)
+				: queue;
+		this.queues.set(threadId, trimmed);
+		return trimmed.length;
+	}
+
+	async subscribe(threadId: string): Promise<void> {
+		this.subscriptions.add(threadId);
+	}
+
+	async unsubscribe(threadId: string): Promise<void> {
+		this.subscriptions.delete(threadId);
+	}
+
+	async isSubscribed(threadId: string): Promise<boolean> {
+		return this.subscriptions.has(threadId);
+	}
+
+	async queueDepth(threadId: string): Promise<number> {
+		return this.getActiveQueue(threadId).length;
+	}
+
+	async acquireLock(threadId: string, ttlMs: number): Promise<Lock | null> {
+		const existing = this.locks.get(threadId);
+		if (existing && existing.expiresAt > Date.now()) {
+			return null;
+		}
+		const lock: Lock = {
+			threadId,
+			token: crypto.randomUUID(),
+			expiresAt: Date.now() + ttlMs,
+		};
+		this.locks.set(threadId, lock);
+		return lock;
+	}
+
+	async extendLock(lock: Lock, ttlMs: number): Promise<boolean> {
+		const existing = this.locks.get(lock.threadId);
+		if (!existing || existing.token !== lock.token) {
+			return false;
+		}
+		existing.expiresAt = Date.now() + ttlMs;
+		return true;
+	}
+
+	async releaseLock(lock: Lock): Promise<void> {
+		const existing = this.locks.get(lock.threadId);
+		if (existing?.token === lock.token) {
+			this.locks.delete(lock.threadId);
+		}
+	}
+
+	async appendToList(
+		key: string,
+		value: unknown,
+		options?: { maxLength?: number; ttlMs?: number },
+	): Promise<void> {
+		const existing = this.lists.get(key);
+		const next = existing ? [...existing.value, value] : [value];
+		const maxLength = options?.maxLength;
+		const trimmed =
+			typeof maxLength === "number" && maxLength > 0 && next.length > maxLength
+				? next.slice(next.length - maxLength)
+				: next;
+		this.lists.set(key, {
+			value: trimmed,
+			expiresAt: options?.ttlMs ? Date.now() + options.ttlMs : undefined,
+		});
+	}
+
+	async forceReleaseLock(threadId: string): Promise<void> {
+		this.locks.delete(threadId);
+	}
+
+	async getList<T = unknown>(key: string): Promise<T[]> {
+		const entry = this.lists.get(key);
+		if (!entry) {
+			return [];
+		}
+		if (entry.expiresAt && entry.expiresAt <= Date.now()) {
+			this.lists.delete(key);
+			return [];
+		}
+		return entry.value as T[];
+	}
+
+	async setIfNotExists(
+		key: string,
+		value: unknown,
+		ttlMs?: number,
+	): Promise<boolean> {
+		const existing = await this.get(key);
+		if (existing !== null) {
+			return false;
+		}
+		await this.set(key, value, ttlMs);
+		return true;
+	}
+}
diff --git a/apps/cli/src/connectors/task-updates.test.ts b/apps/cli/src/connectors/task-updates.test.ts
new file mode 100644
index 0000000..8113a3f
--- /dev/null
+++ b/apps/cli/src/connectors/task-updates.test.ts
@@ -0,0 +1,132 @@
+import type { TeamProgressProjectionEvent } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	createTaskUpdateFingerprint,
+	findBindingForSessionId,
+	formatConnectorTaskUpdate,
+} from "./task-updates";
+
+function createProjection(
+	overrides: Partial<TeamProgressProjectionEvent["lastEvent"]> = {},
+): TeamProgressProjectionEvent {
+	return {
+		type: "team_progress_projection",
+		version: 1,
+		sessionId: "session-1",
+		summary: {
+			teamName: "telegram-team",
+			updatedAt: "2026-03-18T00:00:00.000Z",
+			members: {
+				total: 2,
+				byStatus: { idle: 0, running: 2, stopped: 0 },
+				leadCount: 1,
+				teammateCount: 1,
+			},
+			tasks: {
+				total: 3,
+				byStatus: {
+					pending: 0,
+					in_progress: 1,
+					blocked: 0,
+					completed: 2,
+				},
+				blockedTaskIds: [],
+				readyTaskIds: [],
+				completionPct: 67,
+			},
+			runs: {
+				total: 1,
+				byStatus: {
+					queued: 0,
+					running: 1,
+					completed: 0,
+					failed: 0,
+					cancelled: 0,
+					interrupted: 0,
+				},
+				activeRunIds: ["run-1"],
+				latestRunId: "run-1",
+			},
+			outcomes: {
+				total: 0,
+				byStatus: { draft: 0, in_review: 0, finalized: 0 },
+				finalizedPct: 0,
+				missingRequiredSections: [],
+			},
+			fragments: {
+				total: 0,
+				byStatus: { draft: 0, reviewed: 0, rejected: 0 },
+			},
+		},
+		lastEvent: {
+			teamName: "telegram-team",
+			sessionId: "session-1",
+			eventType: "run_progress",
+			ts: "2026-03-18T00:00:00.000Z",
+			runId: "run-1",
+			taskId: "task-1",
+			agentId: "agent-1",
+			message: "Investigating failing test and patching the connector relay.",
+			...overrides,
+		},
+	};
+}
+
+describe("connector task updates", () => {
+	it("finds a binding by session id in either binding slot", () => {
+		const bindings = {
+			thread_a: {
+				channelId: "channel-a",
+				isDM: true,
+				serializedThread: "{}",
+				sessionId: "session-a",
+				updatedAt: "2026-03-18T00:00:00.000Z",
+			},
+			thread_b: {
+				channelId: "channel-b",
+				isDM: false,
+				serializedThread: "{}",
+				state: { sessionId: "session-b" },
+				updatedAt: "2026-03-18T00:00:00.000Z",
+			},
+		};
+
+		expect(findBindingForSessionId(bindings, "session-a")?.threadId).toBe(
+			"thread_a",
+		);
+		expect(findBindingForSessionId(bindings, "session-b")?.threadId).toBe(
+			"thread_b",
+		);
+	});
+
+	it("formats run progress updates for chat delivery", () => {
+		expect(formatConnectorTaskUpdate(createProjection())).toBe(
+			[
+				"[telegram-team] Task update",
+				"Investigating failing test and patching the connector relay.",
+				"1 run active | 1 task in progress | 2/3 tasks complete",
+			].join("\n"),
+		);
+	});
+
+	it("suppresses generic task update noise when nothing is in progress", () => {
+		const projection = createProjection({
+			eventType: "team_task_updated",
+			message: undefined,
+		});
+		projection.summary.tasks.byStatus.in_progress = 0;
+
+		expect(formatConnectorTaskUpdate(projection)).toBeUndefined();
+	});
+
+	it("changes the fingerprint when the progress payload changes", () => {
+		const first = createProjection();
+		const second = createProjection({
+			message: "Finished the patch and validating the CLI adapters now.",
+		});
+
+		expect(createTaskUpdateFingerprint(first)).not.toBe(
+			createTaskUpdateFingerprint(second),
+		);
+	});
+});
diff --git a/apps/cli/src/connectors/task-updates.ts b/apps/cli/src/connectors/task-updates.ts
new file mode 100644
index 0000000..0cb22dc
--- /dev/null
+++ b/apps/cli/src/connectors/task-updates.ts
@@ -0,0 +1,223 @@
+import type { HubSessionClient } from "@cline/core";
+import type { TeamProgressProjectionEvent } from "@cline/shared";
+import type { Chat, Thread } from "chat";
+import type { CliLoggerAdapter } from "../logging/adapter";
+import { truncateConnectorText } from "./runtime-turn";
+import {
+	type ConnectorThreadBinding,
+	type ConnectorThreadState,
+	readBindings,
+} from "./thread-bindings";
+
+function formatCountLabel(input: {
+	count: number;
+	singular: string;
+	plural: string;
+}): string {
+	return `${input.count} ${input.count === 1 ? input.singular : input.plural}`;
+}
+
+function buildProgressSummary(event: TeamProgressProjectionEvent): string {
+	const activeRuns = event.summary.runs.byStatus.running;
+	const activeTasks = event.summary.tasks.byStatus.in_progress;
+	const blockedTasks = event.summary.tasks.byStatus.blocked;
+	const completedTasks = event.summary.tasks.byStatus.completed;
+	const totalTasks = event.summary.tasks.total;
+	const parts = [
+		formatCountLabel({
+			count: activeRuns,
+			singular: "run active",
+			plural: "runs active",
+		}),
+		formatCountLabel({
+			count: activeTasks,
+			singular: "task in progress",
+			plural: "tasks in progress",
+		}),
+	];
+	if (blockedTasks > 0) {
+		parts.push(
+			formatCountLabel({
+				count: blockedTasks,
+				singular: "blocked task",
+				plural: "blocked tasks",
+			}),
+		);
+	}
+	if (totalTasks > 0) {
+		parts.push(`${completedTasks}/${totalTasks} tasks complete`);
+	}
+	return parts.join(" | ");
+}
+
+export function formatConnectorTaskUpdate(
+	event: TeamProgressProjectionEvent,
+): string | undefined {
+	const message = event.lastEvent.message
+		? truncateConnectorText(event.lastEvent.message, 220)
+		: undefined;
+	const teamName = event.summary.teamName;
+	switch (event.lastEvent.eventType) {
+		case "run_started":
+			return [
+				`[${teamName}] Task started`,
+				buildProgressSummary(event),
+				message,
+			]
+				.filter(Boolean)
+				.join("\n");
+		case "run_progress":
+			return [
+				`[${teamName}] Task update`,
+				message ?? buildProgressSummary(event),
+				message ? buildProgressSummary(event) : undefined,
+			]
+				.filter(Boolean)
+				.join("\n");
+		case "run_completed":
+			return [`[${teamName}] Task completed`, buildProgressSummary(event)]
+				.filter(Boolean)
+				.join("\n");
+		case "run_failed":
+			return [`[${teamName}] Task failed`, message, buildProgressSummary(event)]
+				.filter(Boolean)
+				.join("\n");
+		case "run_cancelled":
+			return [`[${teamName}] Task cancelled`, buildProgressSummary(event)]
+				.filter(Boolean)
+				.join("\n");
+		case "run_interrupted":
+			return [`[${teamName}] Task interrupted`, buildProgressSummary(event)]
+				.filter(Boolean)
+				.join("\n");
+		case "team_task_updated":
+			if (event.summary.tasks.byStatus.in_progress <= 0) {
+				return undefined;
+			}
+			return [`[${teamName}] Task queue updated`, buildProgressSummary(event)]
+				.filter(Boolean)
+				.join("\n");
+		default:
+			return undefined;
+	}
+}
+
+export function findBindingForSessionId<TState extends ConnectorThreadState>(
+	bindings: Record<string, ConnectorThreadBinding<TState>>,
+	sessionId: string,
+): { threadId: string; binding: ConnectorThreadBinding<TState> } | undefined {
+	const trimmedSessionId = sessionId.trim();
+	if (!trimmedSessionId) {
+		return undefined;
+	}
+	for (const [threadId, binding] of Object.entries(bindings)) {
+		if (
+			binding.sessionId?.trim() === trimmedSessionId ||
+			binding.state?.sessionId?.trim() === trimmedSessionId
+		) {
+			return { threadId, binding };
+		}
+	}
+	return undefined;
+}
+
+export function createTaskUpdateFingerprint(
+	event: TeamProgressProjectionEvent,
+): string {
+	return JSON.stringify({
+		eventType: event.lastEvent.eventType,
+		runId: event.lastEvent.runId ?? "",
+		taskId: event.lastEvent.taskId ?? "",
+		message: event.lastEvent.message ?? "",
+		updatedAt: event.summary.updatedAt,
+	});
+}
+
+export function startConnectorTaskUpdateRelay<
+	TState extends ConnectorThreadState,
+>(input: {
+	client: HubSessionClient;
+	clientId: string;
+	bot: Chat;
+	logger: CliLoggerAdapter;
+	bindingsPath: string;
+	transport: string;
+	postToThread?: (input: {
+		thread: Thread<TState>;
+		binding: ConnectorThreadBinding<TState>;
+		threadId: string;
+		body: string;
+	}) => Promise<void>;
+}): () => void {
+	const lastSentBySession = new Map<string, string>();
+
+	const handleProjection = async (
+		event: TeamProgressProjectionEvent,
+	): Promise<void> => {
+		const body = formatConnectorTaskUpdate(event);
+		if (!body) {
+			return;
+		}
+		const fingerprint = createTaskUpdateFingerprint(event);
+		if (lastSentBySession.get(event.sessionId) === fingerprint) {
+			return;
+		}
+		const match = findBindingForSessionId(
+			readBindings<TState>(input.bindingsPath),
+			event.sessionId,
+		);
+		if (!match?.binding.serializedThread) {
+			return;
+		}
+		lastSentBySession.set(event.sessionId, fingerprint);
+		try {
+			const thread = JSON.parse(
+				match.binding.serializedThread,
+				input.bot.reviver(),
+			) as Thread<TState>;
+			if (input.postToThread) {
+				await input.postToThread({
+					thread,
+					binding: match.binding,
+					threadId: match.threadId,
+					body,
+				});
+			} else {
+				await thread.post(body);
+			}
+			input.logger.core.log("Connector task update sent", {
+				transport: input.transport,
+				threadId: match.threadId,
+				sessionId: event.sessionId,
+				eventType: event.lastEvent.eventType,
+				runId: event.lastEvent.runId,
+				taskId: event.lastEvent.taskId,
+			});
+		} catch (error) {
+			input.logger.core.log("Connector task update delivery failed", {
+				severity: "warn",
+				transport: input.transport,
+				threadId: match.threadId,
+				sessionId: event.sessionId,
+				eventType: event.lastEvent.eventType,
+				error,
+			});
+		}
+	};
+
+	return input.client.streamTeamProgress(
+		{ clientId: `${input.clientId}-task-updates` },
+		{
+			onProjection: (event) => {
+				void handleProjection(event);
+			},
+			onError: (error) => {
+				input.logger.core.log("Connector task update stream failed", {
+					severity: "warn",
+					transport: input.transport,
+					error,
+				});
+			},
+		},
+	);
+}
diff --git a/apps/cli/src/connectors/thread-bindings.test.ts b/apps/cli/src/connectors/thread-bindings.test.ts
new file mode 100644
index 0000000..25e7ac9
--- /dev/null
+++ b/apps/cli/src/connectors/thread-bindings.test.ts
@@ -0,0 +1,312 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Thread } from "chat";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	type ConnectorThreadState,
+	clearBindingSessionIds,
+	findBindingForDeliveryTarget,
+	isParticipantMuted,
+	isThreadMuted,
+	readBindingForThread,
+	readBindings,
+	setParticipantMuted,
+	setThreadMuted,
+	writeBindings,
+} from "./thread-bindings";
+
+type TestState = ConnectorThreadState & {
+	teamId?: string;
+};
+
+const tempDirs: string[] = [];
+
+function createBindingsPath(): string {
+	const dir = mkdtempSync(join(tmpdir(), "thread-bindings-"));
+	tempDirs.push(dir);
+	return join(dir, "bindings.json");
+}
+
+function createThread(input: {
+	id: string;
+	channelId: string;
+	isDM: boolean;
+	participantKey?: string;
+}): Thread<TestState> {
+	return {
+		id: input.id,
+		channelId: input.channelId,
+		isDM: input.isDM,
+		toJSON: () => ({
+			id: input.id,
+			channelId: input.channelId,
+			isDM: input.isDM,
+		}),
+	} as unknown as Thread<TestState>;
+}
+
+afterEach(() => {
+	for (const dir of tempDirs.splice(0)) {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+describe("thread binding refresh", () => {
+	it("refreshes the serialized thread immediately when DM channel fallback rebinds a thread id", () => {
+		const path = createBindingsPath();
+		writeBindings<TestState>(path, {
+			legacy_thread_id: {
+				channelId: "slack:C123",
+				isDM: true,
+				serializedThread: JSON.stringify({
+					id: "legacy_thread_id",
+					channelId: "slack:C123",
+					isDM: true,
+				}),
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", teamId: "T123" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+
+		const binding = readBindingForThread<TestState>(
+			path,
+			createThread({
+				id: "new_thread_id",
+				channelId: "slack:C123",
+				isDM: true,
+			}),
+			"Slack",
+		);
+
+		expect(binding?.serializedThread).toContain("new_thread_id");
+		const bindings = readBindings<TestState>(path);
+		expect(bindings.legacy_thread_id).toBeUndefined();
+		expect(bindings.new_thread_id?.serializedThread).toContain("new_thread_id");
+	});
+
+	it("does not rebind a different thread by participant key", () => {
+		const path = createBindingsPath();
+		const participantKey = "slack:team:T123:user:U123";
+		writeBindings<TestState>(path, {
+			[participantKey]: {
+				channelId: "slack:C123",
+				isDM: false,
+				participantKey,
+				serializedThread: JSON.stringify({
+					id: "legacy_thread_id",
+					channelId: "slack:C123",
+					isDM: false,
+				}),
+				sessionId: "sess-1",
+				state: {
+					sessionId: "sess-1",
+					teamId: "T123",
+					participantKey,
+				},
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+
+		const binding = readBindingForThread<TestState>(
+			path,
+			createThread({
+				id: "new_thread_id",
+				channelId: "slack:C123",
+				isDM: false,
+			}),
+			"Slack",
+			participantKey,
+		);
+
+		expect(binding).toBeUndefined();
+		expect(
+			readBindings<TestState>(path)[participantKey]?.serializedThread,
+		).toContain("legacy_thread_id");
+	});
+
+	it("resolves schedule delivery targets by exact binding key before participant metadata", () => {
+		const path = createBindingsPath();
+		writeBindings<TestState>(path, {
+			"slack:C123:111.222": {
+				kind: "conversation",
+				channelId: "slack:C123",
+				isDM: false,
+				participantKey: "slack:team:T123:user:U123",
+				serializedThread: "{}",
+				sessionId: "sess-thread",
+				state: {
+					sessionId: "sess-thread",
+					participantKey: "slack:team:T123:user:U123",
+				},
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+
+		const match = findBindingForDeliveryTarget<TestState>(
+			readBindings<TestState>(path),
+			{
+				bindingKey: "slack:C123:111.222",
+				threadId: "slack:C123:111.222",
+				participantKey: "slack:team:T123:user:U123",
+			},
+		);
+
+		expect(match?.key).toBe("slack:C123:111.222");
+		expect(match?.binding.sessionId).toBe("sess-thread");
+	});
+
+	it("resolves schedule delivery targets by participant key when no exact thread binding exists", () => {
+		const path = createBindingsPath();
+		writeBindings<TestState>(path, {
+			"slack:team:T123:user:U123": {
+				channelId: "slack:C123",
+				isDM: true,
+				participantKey: "slack:team:T123:user:U123",
+				serializedThread: "{}",
+				sessionId: "sess-participant",
+				state: {
+					sessionId: "sess-participant",
+					participantKey: "slack:team:T123:user:U123",
+				},
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+
+		const match = findBindingForDeliveryTarget<TestState>(
+			readBindings<TestState>(path),
+			{
+				participantKey: "slack:team:T123:user:U123",
+			},
+		);
+
+		expect(match?.key).toBe("slack:team:T123:user:U123");
+		expect(match?.binding.sessionId).toBe("sess-participant");
+	});
+
+	it("stores mute state at thread scope instead of participant scope", () => {
+		const path = createBindingsPath();
+		const thread = createThread({
+			id: "thread-1",
+			channelId: "discord:guild:channel",
+			isDM: false,
+			participantKey: "discord:user:alice",
+		});
+
+		setThreadMuted(path, thread, true, "Discord");
+
+		expect(
+			isThreadMuted(
+				path,
+				createThread({
+					id: "thread-1",
+					channelId: "discord:guild:channel",
+					isDM: false,
+					participantKey: "discord:user:bob",
+				}),
+			),
+		).toBe(true);
+
+		const binding = readBindingForThread<TestState>(
+			path,
+			thread,
+			"Discord",
+			"discord:user:alice",
+		);
+		expect(binding).toBeUndefined();
+
+		setThreadMuted(path, thread, false, "Discord");
+
+		expect(isThreadMuted(path, thread)).toBe(false);
+	});
+
+	it("stores participant mute state scoped to the current thread", () => {
+		const path = createBindingsPath();
+		const thread = createThread({
+			id: "thread-1",
+			channelId: "discord:guild:channel",
+			isDM: false,
+		});
+		const otherThread = createThread({
+			id: "thread-2",
+			channelId: "discord:guild:channel",
+			isDM: false,
+		});
+
+		setParticipantMuted(
+			path,
+			thread,
+			{
+				participantKey: "discord:user:bob",
+				participantLabel: "Bob",
+			},
+			true,
+			"Discord",
+		);
+
+		expect(isParticipantMuted(path, thread, "discord:user:bob")).toBe(true);
+		expect(isParticipantMuted(path, thread, "discord:user:alice")).toBe(false);
+		expect(isParticipantMuted(path, otherThread, "discord:user:bob")).toBe(
+			false,
+		);
+		expect(
+			readBindingForThread<TestState>(
+				path,
+				thread,
+				"Discord",
+				"discord:user:bob",
+			),
+		).toBeUndefined();
+
+		setParticipantMuted(
+			path,
+			thread,
+			{ participantKey: "discord:user:bob" },
+			false,
+			"Discord",
+		);
+
+		expect(isParticipantMuted(path, thread, "discord:user:bob")).toBe(false);
+	});
+});
+
+describe("clearBindingSessionIds", () => {
+	it("clears session ids from bindings and serialized thread state", () => {
+		const path = createBindingsPath();
+		writeBindings<TestState>(path, {
+			thread_1: {
+				channelId: "discord:C123",
+				isDM: false,
+				serializedThread: JSON.stringify({
+					id: "thread_1",
+					channelId: "discord:C123",
+					isDM: false,
+					sessionId: "legacy-root-session",
+					state: {
+						sessionId: "sess-1",
+						cwd: "/tmp/work",
+						teamId: "T123",
+					},
+				}),
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", cwd: "/tmp/work", teamId: "T123" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
+
+		clearBindingSessionIds<TestState>(path);
+
+		const binding = readBindings<TestState>(path).thread_1;
+		expect(binding?.sessionId).toBeUndefined();
+		expect(binding?.state?.sessionId).toBeUndefined();
+		expect(binding?.state?.cwd).toBe("/tmp/work");
+		const serializedThread = JSON.parse(binding?.serializedThread ?? "{}") as {
+			sessionId?: string;
+			state?: TestState;
+		};
+		expect(serializedThread.sessionId).toBeUndefined();
+		expect(serializedThread.state?.sessionId).toBeUndefined();
+		expect(serializedThread.state?.cwd).toBe("/tmp/work");
+	});
+});
diff --git a/apps/cli/src/connectors/thread-bindings.ts b/apps/cli/src/connectors/thread-bindings.ts
new file mode 100644
index 0000000..cf05f89
--- /dev/null
+++ b/apps/cli/src/connectors/thread-bindings.ts
@@ -0,0 +1,549 @@
+import type { SerializedThread, Thread } from "chat";
+import { readJsonFile, writeJsonFile } from "./common";
+
+export type ConnectorThreadState = {
+	sessionId?: string;
+	enableTools?: boolean;
+	autoApproveTools?: boolean;
+	cwd?: string;
+	workspaceRoot?: string;
+	systemPrompt?: string;
+	participantKey?: string;
+	participantLabel?: string;
+	welcomeSentAt?: string;
+};
+
+export type ConnectorThreadBinding<TState extends ConnectorThreadState> = {
+	kind?: "conversation" | "participant" | "thread" | "thread-participant-mute";
+	channelId: string;
+	isDM: boolean;
+	participantKey?: string;
+	participantLabel?: string;
+	threadMutedAt?: string;
+	mutedParticipantKey?: string;
+	mutedParticipantLabel?: string;
+	participantMutedAt?: string;
+	serializedThread: string;
+	sessionId?: string;
+	state?: TState;
+	updatedAt: string;
+};
+
+export type ConnectorBindingStore<TState extends ConnectorThreadState> = Record<
+	string,
+	ConnectorThreadBinding<TState>
+>;
+
+export type SerializableConnectorThread<TState extends ConnectorThreadState> =
+	Thread<TState> & {
+		toJSON(): SerializedThread;
+	};
+
+export type ConnectorBindingThreadIdentity = Pick<
+	Thread<ConnectorThreadState>,
+	"id" | "channelId" | "isDM"
+> & {
+	participantKey?: string;
+};
+
+export type ConnectorMuteTarget = {
+	participantKey: string;
+	participantLabel?: string;
+};
+
+function normalizeParticipantKey(
+	value: string | undefined,
+): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function readSerializedThreadIdentity(
+	serializedThread: string | undefined,
+): Partial<ConnectorBindingThreadIdentity> | undefined {
+	if (!serializedThread?.trim()) {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(
+			serializedThread,
+		) as Partial<ConnectorBindingThreadIdentity>;
+		return parsed && typeof parsed === "object" ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveThreadControlKey(
+	thread: ConnectorBindingThreadIdentity,
+): string {
+	return `thread:${thread.id}`;
+}
+
+function resolveParticipantMuteControlKey(
+	thread: ConnectorBindingThreadIdentity,
+	participantKey: string | undefined,
+): string | undefined {
+	const normalized = normalizeParticipantKey(participantKey);
+	return normalized
+		? `thread:${thread.id}:participant:${normalized}`
+		: undefined;
+}
+
+function isControlBinding(
+	binding: ConnectorThreadBinding<ConnectorThreadState> | undefined,
+): boolean {
+	return (
+		binding?.kind === "thread" || binding?.kind === "thread-participant-mute"
+	);
+}
+
+function clearSerializedThreadSessionId(serializedThread: string | undefined): {
+	serializedThread: string | undefined;
+	updated: boolean;
+} {
+	if (!serializedThread?.trim()) {
+		return { serializedThread, updated: false };
+	}
+	try {
+		const parsed = JSON.parse(serializedThread) as unknown;
+		if (!parsed || typeof parsed !== "object") {
+			return { serializedThread, updated: false };
+		}
+		const record = parsed as Record<string, unknown>;
+		let updated = false;
+		if ("sessionId" in record) {
+			delete record.sessionId;
+			updated = true;
+		}
+		if (record.state && typeof record.state === "object") {
+			const state = record.state as Record<string, unknown>;
+			if ("sessionId" in state) {
+				delete state.sessionId;
+				updated = true;
+			}
+		}
+		return {
+			serializedThread: updated ? JSON.stringify(parsed) : serializedThread,
+			updated,
+		};
+	} catch {
+		return { serializedThread, updated: false };
+	}
+}
+
+export function resolveThreadBindingKey(
+	thread: ConnectorBindingThreadIdentity,
+	_state?: ConnectorThreadState | null,
+): string {
+	return thread.id;
+}
+
+export function readBindings<TState extends ConnectorThreadState>(
+	path: string,
+): ConnectorBindingStore<TState> {
+	const parsed = readJsonFile<ConnectorBindingStore<TState>>(path, {});
+	return parsed && typeof parsed === "object" ? parsed : {};
+}
+
+export function writeBindings<TState extends ConnectorThreadState>(
+	path: string,
+	bindings: ConnectorBindingStore<TState>,
+): void {
+	writeJsonFile(path, bindings);
+}
+
+export function findBindingForThread<TState extends ConnectorThreadState>(
+	bindings: ConnectorBindingStore<TState>,
+	thread: ConnectorBindingThreadIdentity,
+): { binding: ConnectorThreadBinding<TState>; key: string } | undefined {
+	const exact = bindings[thread.id];
+	if (exact && !isControlBinding(exact)) {
+		return { key: thread.id, binding: exact };
+	}
+	if (!thread.isDM) {
+		return undefined;
+	}
+	for (const [key, binding] of Object.entries(bindings)) {
+		if (isControlBinding(binding)) {
+			continue;
+		}
+		if (
+			binding.channelId === thread.channelId &&
+			binding.isDM === thread.isDM
+		) {
+			return { key, binding };
+		}
+	}
+	return undefined;
+}
+
+export function readBindingForThread<TState extends ConnectorThreadState>(
+	path: string,
+	thread: Thread<TState>,
+	errorLabel: string,
+	participantKey?: string,
+): ConnectorThreadBinding<TState> | undefined {
+	const bindings = readBindings<TState>(path);
+	const threadIdentity: ConnectorBindingThreadIdentity = {
+		id: thread.id,
+		channelId: thread.channelId,
+		isDM: thread.isDM,
+		participantKey,
+	};
+	const match = findBindingForThread(bindings, threadIdentity);
+	if (!match) {
+		return undefined;
+	}
+	const targetKey = resolveThreadBindingKey(
+		threadIdentity,
+		match.binding.state,
+	);
+	const normalizedParticipantKey = normalizeParticipantKey(participantKey);
+	const storedThread = readSerializedThreadIdentity(
+		match.binding.serializedThread,
+	);
+	const storedParticipantKey = normalizeParticipantKey(
+		match.binding.participantKey ?? match.binding.state?.participantKey,
+	);
+	const needsRefresh =
+		match.key !== targetKey ||
+		storedThread?.id !== thread.id ||
+		storedThread?.channelId !== thread.channelId ||
+		storedThread?.isDM !== thread.isDM ||
+		storedParticipantKey !== normalizedParticipantKey;
+	if (needsRefresh) {
+		bindings[targetKey] = {
+			...match.binding,
+			channelId: thread.channelId,
+			isDM: thread.isDM,
+			participantKey: normalizedParticipantKey ?? match.binding.participantKey,
+			serializedThread: serializeThread(thread, errorLabel),
+			updatedAt: new Date().toISOString(),
+		};
+		if (match.key !== targetKey) {
+			delete bindings[match.key];
+		}
+		writeBindings(path, bindings);
+	}
+	return bindings[targetKey];
+}
+
+export function serializeThread<TState extends ConnectorThreadState>(
+	thread: Thread<TState>,
+	errorLabel: string,
+): string {
+	const candidate = thread as Partial<SerializableConnectorThread<TState>>;
+	if (typeof candidate.toJSON !== "function") {
+		throw new Error(`${errorLabel} thread cannot be serialized`);
+	}
+	return JSON.stringify(candidate.toJSON.call(thread));
+}
+
+export function persistThreadBinding<TState extends ConnectorThreadState>(
+	path: string,
+	thread: Thread<TState>,
+	state: TState,
+	errorLabel: string,
+): void {
+	const bindings = readBindings<TState>(path);
+	const participantKey = normalizeParticipantKey(state.participantKey);
+	const bindingKey = resolveThreadBindingKey(
+		thread as ConnectorBindingThreadIdentity,
+		state,
+	);
+	bindings[bindingKey] = {
+		kind: "conversation",
+		channelId: thread.channelId,
+		isDM: thread.isDM,
+		participantKey,
+		participantLabel: state.participantLabel?.trim() || undefined,
+		serializedThread: serializeThread(thread, errorLabel),
+		sessionId: state.sessionId,
+		state,
+		updatedAt: new Date().toISOString(),
+	};
+	writeBindings(path, bindings);
+}
+
+export function isThreadMuted<TState extends ConnectorThreadState>(
+	path: string,
+	thread: ConnectorBindingThreadIdentity,
+): boolean {
+	const bindings = readBindings<TState>(path);
+	return isThreadMutedInBindings(bindings, thread);
+}
+
+export function isThreadMutedInBindings<TState extends ConnectorThreadState>(
+	bindings: ConnectorBindingStore<TState>,
+	thread: ConnectorBindingThreadIdentity,
+): boolean {
+	const binding = bindings[resolveThreadControlKey(thread)];
+	return Boolean(binding?.threadMutedAt);
+}
+
+export function isParticipantMuted<TState extends ConnectorThreadState>(
+	path: string,
+	thread: ConnectorBindingThreadIdentity,
+	participantKey: string | undefined,
+): boolean {
+	const key = resolveParticipantMuteControlKey(thread, participantKey);
+	if (!key) {
+		return false;
+	}
+	const bindings = readBindings<TState>(path);
+	return isParticipantMutedInBindings(bindings, thread, participantKey);
+}
+
+export function isParticipantMutedInBindings<
+	TState extends ConnectorThreadState,
+>(
+	bindings: ConnectorBindingStore<TState>,
+	thread: ConnectorBindingThreadIdentity,
+	participantKey: string | undefined,
+): boolean {
+	const key = resolveParticipantMuteControlKey(thread, participantKey);
+	if (!key) {
+		return false;
+	}
+	const binding = bindings[key];
+	return Boolean(binding?.participantMutedAt);
+}
+
+export function findMutedParticipantsForThread<
+	TState extends ConnectorThreadState,
+>(
+	bindings: ConnectorBindingStore<TState>,
+	thread: ConnectorBindingThreadIdentity,
+): ConnectorMuteTarget[] {
+	const prefix = `thread:${thread.id}:participant:`;
+	return Object.entries(bindings)
+		.filter(
+			([key, binding]) =>
+				key.startsWith(prefix) &&
+				binding.kind === "thread-participant-mute" &&
+				Boolean(binding.participantMutedAt) &&
+				Boolean(normalizeParticipantKey(binding.mutedParticipantKey)),
+		)
+		.map(([, binding]) => ({
+			participantKey:
+				normalizeParticipantKey(binding.mutedParticipantKey) ?? "",
+			participantLabel: binding.mutedParticipantLabel,
+		}))
+		.filter((target) => target.participantKey.length > 0);
+}
+
+export function setThreadMuted<TState extends ConnectorThreadState>(
+	path: string,
+	thread: Thread<TState>,
+	muted: boolean,
+	errorLabel: string,
+): string | undefined {
+	const bindings = readBindings<TState>(path);
+	const key = resolveThreadControlKey(thread as ConnectorBindingThreadIdentity);
+	if (!muted) {
+		if (bindings[key]) {
+			delete bindings[key];
+			writeBindings(path, bindings);
+		}
+		return undefined;
+	}
+	const mutedAt = new Date().toISOString();
+	bindings[key] = {
+		kind: "thread",
+		channelId: thread.channelId,
+		isDM: thread.isDM,
+		threadMutedAt: mutedAt,
+		serializedThread: serializeThread(thread, errorLabel),
+		updatedAt: mutedAt,
+	};
+	writeBindings(path, bindings);
+	return mutedAt;
+}
+
+export function setParticipantMuted<TState extends ConnectorThreadState>(
+	path: string,
+	thread: Thread<TState>,
+	target: ConnectorMuteTarget,
+	muted: boolean,
+	errorLabel: string,
+): string | undefined {
+	const normalized = normalizeParticipantKey(target.participantKey);
+	const key = resolveParticipantMuteControlKey(
+		thread as ConnectorBindingThreadIdentity,
+		normalized,
+	);
+	if (!normalized || !key) {
+		return undefined;
+	}
+	const bindings = readBindings<TState>(path);
+	if (!muted) {
+		if (bindings[key]) {
+			delete bindings[key];
+			writeBindings(path, bindings);
+		}
+		return undefined;
+	}
+	const mutedAt = new Date().toISOString();
+	bindings[key] = {
+		kind: "thread-participant-mute",
+		channelId: thread.channelId,
+		isDM: thread.isDM,
+		mutedParticipantKey: normalized,
+		mutedParticipantLabel: target.participantLabel?.trim() || undefined,
+		participantMutedAt: mutedAt,
+		serializedThread: serializeThread(thread, errorLabel),
+		updatedAt: mutedAt,
+	};
+	writeBindings(path, bindings);
+	return mutedAt;
+}
+
+export function mergeThreadState<TState extends ConnectorThreadState>(
+	threadState: TState | null | undefined,
+	bindingState: TState | undefined,
+	base: ConnectorThreadState,
+): TState {
+	return {
+		...(threadState ?? bindingState ?? {}),
+		sessionId:
+			threadState?.sessionId?.trim() ||
+			bindingState?.sessionId?.trim() ||
+			undefined,
+		enableTools:
+			threadState?.enableTools ?? bindingState?.enableTools ?? base.enableTools,
+		autoApproveTools:
+			threadState?.autoApproveTools ??
+			bindingState?.autoApproveTools ??
+			base.autoApproveTools,
+		cwd: threadState?.cwd || bindingState?.cwd || base.cwd,
+		workspaceRoot:
+			threadState?.workspaceRoot ||
+			bindingState?.workspaceRoot ||
+			base.workspaceRoot,
+		systemPrompt:
+			threadState?.systemPrompt ||
+			bindingState?.systemPrompt ||
+			base.systemPrompt,
+		participantKey:
+			threadState?.participantKey ||
+			bindingState?.participantKey ||
+			base.participantKey,
+		participantLabel:
+			threadState?.participantLabel ||
+			bindingState?.participantLabel ||
+			base.participantLabel,
+		welcomeSentAt:
+			threadState?.welcomeSentAt ||
+			bindingState?.welcomeSentAt ||
+			base.welcomeSentAt,
+	} as TState;
+}
+
+export async function loadThreadState<TState extends ConnectorThreadState>(
+	thread: Thread<TState>,
+	bindingsPath: string,
+	base: ConnectorThreadState,
+): Promise<TState> {
+	const threadState = await thread.state;
+	const binding = readBindingForThread<TState>(
+		bindingsPath,
+		thread,
+		"Connector",
+		threadState?.participantKey,
+	);
+	return mergeThreadState(threadState, binding?.state, base);
+}
+
+export function findBindingForParticipantKey<
+	TState extends ConnectorThreadState,
+>(
+	bindings: ConnectorBindingStore<TState>,
+	participantKey: string | undefined,
+): { binding: ConnectorThreadBinding<TState>; key: string } | undefined {
+	const normalized = normalizeParticipantKey(participantKey);
+	if (!normalized) {
+		return undefined;
+	}
+	const exact = bindings[normalized];
+	if (exact) {
+		return { key: normalized, binding: exact };
+	}
+	for (const [key, binding] of Object.entries(bindings)) {
+		const bindingParticipantKey = normalizeParticipantKey(
+			binding.participantKey ?? binding.state?.participantKey,
+		);
+		if (bindingParticipantKey === normalized) {
+			return { key, binding };
+		}
+	}
+	return undefined;
+}
+
+export function findBindingForDeliveryTarget<
+	TState extends ConnectorThreadState,
+>(
+	bindings: ConnectorBindingStore<TState>,
+	input: {
+		bindingKey?: string;
+		threadId?: string;
+		participantKey?: string;
+	},
+): { binding: ConnectorThreadBinding<TState>; key: string } | undefined {
+	const bindingKey = normalizeParticipantKey(input.bindingKey);
+	if (bindingKey) {
+		const exact = bindings[bindingKey];
+		if (exact && !isControlBinding(exact)) {
+			return { key: bindingKey, binding: exact };
+		}
+		const participantMatch = findBindingForParticipantKey(bindings, bindingKey);
+		if (participantMatch) {
+			return participantMatch;
+		}
+	}
+	const threadId = input.threadId?.trim();
+	if (threadId) {
+		const exact = bindings[threadId];
+		if (exact && !isControlBinding(exact)) {
+			return { key: threadId, binding: exact };
+		}
+	}
+	return findBindingForParticipantKey(bindings, input.participantKey);
+}
+
+export async function persistMergedThreadState<
+	TState extends ConnectorThreadState,
+>(
+	thread: Thread<TState>,
+	bindingsPath: string,
+	nextState: TState,
+	errorLabel: string,
+): Promise<void> {
+	await thread.setState(nextState, { replace: true });
+	persistThreadBinding(bindingsPath, thread, nextState, errorLabel);
+}
+
+export function clearBindingSessionIds<TState extends ConnectorThreadState>(
+	path: string,
+): void {
+	const bindings = readBindings<TState>(path);
+	let updated = false;
+	for (const binding of Object.values(bindings)) {
+		if ("sessionId" in binding) {
+			delete binding.sessionId;
+			updated = true;
+		}
+		if (binding.state && "sessionId" in binding.state) {
+			delete binding.state.sessionId;
+			updated = true;
+		}
+		const serialized = clearSerializedThreadSessionId(binding.serializedThread);
+		if (serialized.updated) {
+			binding.serializedThread = serialized.serializedThread ?? "";
+			updated = true;
+		}
+	}
+	if (updated) {
+		writeBindings(path, bindings);
+	}
+}
diff --git a/apps/cli/src/connectors/types.ts b/apps/cli/src/connectors/types.ts
new file mode 100644
index 0000000..fe2abbc
--- /dev/null
+++ b/apps/cli/src/connectors/types.ts
@@ -0,0 +1,17 @@
+export type ConnectIo = {
+	writeln: (text?: string) => void;
+	writeErr: (text: string) => void;
+};
+
+export type ConnectStopResult = {
+	stoppedProcesses: number;
+	stoppedSessions: number;
+};
+
+export interface ConnectCommandDefinition {
+	name: string;
+	description: string;
+	run(args: string[], io: ConnectIo): Promise<number>;
+	showHelp(io: ConnectIo): void;
+	stopAll?(io: ConnectIo): Promise<ConnectStopResult>;
+}
diff --git a/apps/cli/src/index.ts b/apps/cli/src/index.ts
new file mode 100755
index 0000000..b1ed199
--- /dev/null
+++ b/apps/cli/src/index.ts
@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+
+import { isMainThread } from "node:worker_threads";
+import { disposeAll, initVcr, isHubDaemonProcess } from "@cline/shared";
+import { logCliProcessError } from "./logging/errors";
+import {
+	abortActiveRuntime,
+	cleanupActiveRuntime,
+	isAbortInProgress,
+} from "./runtime/active-runtime";
+import { writeErr } from "./utils/output";
+
+// Initialize VCR before any HTTP requests are made.
+// Set CLINE_VCR=record|playback and CLINE_VCR_CASSETTE=<path> to enable.
+initVcr(process.env.CLINE_VCR);
+
+if (!isMainThread) {
+	// Worker imports of the bundled CLI entrypoint should not start the CLI.
+} else {
+	let shuttingDown = false;
+	let handlingFatalProcessError = false;
+	const forwardSignalToRuntime = () => {
+		if (shuttingDown) {
+			process.exit(1);
+		}
+		shuttingDown = true;
+		abortActiveRuntime();
+	};
+	process.on("SIGINT", forwardSignalToRuntime);
+	process.on("SIGTERM", forwardSignalToRuntime);
+	const handleFatalProcessError = (kind: string, error: unknown) => {
+		if (handlingFatalProcessError) {
+			process.exit(1);
+		}
+		handlingFatalProcessError = true;
+		logCliProcessError(kind, error);
+		writeErr(
+			error instanceof Error ? (error.stack ?? error.message) : String(error),
+		);
+		cleanupActiveRuntime();
+		abortActiveRuntime();
+		void disposeAll().finally(() => {
+			process.exit(1);
+		});
+	};
+	process.on("uncaughtException", (error) => {
+		handleFatalProcessError("uncaughtException", error);
+	});
+	process.on("unhandledRejection", (reason, promise) => {
+		if (isAbortInProgress()) {
+			// Mark the promise as handled so OpenTUI's error overlay
+			// does not surface expected abort-related rejections.
+			promise.catch(() => {});
+			return;
+		}
+		handleFatalProcessError("unhandledRejection", reason);
+	});
+
+	void (async () => {
+		if (isHubDaemonProcess()) {
+			await import("@cline/core/hub/daemon-entry");
+			return;
+		}
+
+		let exitCode = 0;
+		try {
+			const { runCli } = await import("./main");
+			await runCli();
+		} catch (err) {
+			logCliProcessError("runCli", err);
+			writeErr(err instanceof Error ? err.message : String(err));
+			cleanupActiveRuntime();
+			abortActiveRuntime();
+			exitCode = 1;
+		} finally {
+			await disposeAll();
+		}
+		process.exit(exitCode || (process.exitCode as number) || 0);
+	})();
+}
diff --git a/apps/cli/src/kanban-migration/notice-dialog.tsx b/apps/cli/src/kanban-migration/notice-dialog.tsx
new file mode 100644
index 0000000..8e3bdd9
--- /dev/null
+++ b/apps/cli/src/kanban-migration/notice-dialog.tsx
@@ -0,0 +1,67 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import open from "open";
+import { useCallback, useMemo, useState } from "react";
+import { palette } from "../tui/palette";
+import { getCliSubscriptionUrl } from "../utils/cline-pass-errors";
+import type { CliMigrationNotice } from "./notice";
+
+export function MigrationNoticeContent(
+	props: ChoiceContext<boolean> & {
+		notice: CliMigrationNotice;
+	},
+) {
+	const { dialogId, notice, resolve } = props;
+	const subscriptionUrl = useMemo(() => getCliSubscriptionUrl(), []);
+	const [status, setStatus] = useState<string | undefined>();
+
+	const openSubscriptionPage = useCallback(() => {
+		setStatus("Opening ClinePass in your browser...");
+		void open(subscriptionUrl, { wait: false })
+			.then(() => {
+				setStatus("Opened ClinePass in your browser.");
+			})
+			.catch(() => {
+				setStatus(
+					"Could not open the browser automatically. Use the URL below.",
+				);
+			});
+	}, [subscriptionUrl]);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			resolve(true);
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			openSubscriptionPage();
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg={palette.act}>{notice.title}</text>
+			<box flexDirection="column">
+				<text selectable>
+					ClinePass is a $9.99/month subscription plan to get access to the
+					latest open-weight coding models with enough quota for day-to-day
+					work, at a much lower cost than paying API costs directly.
+				</text>
+				<text selectable>Try it now with a limited-time promo for $1.99.</text>
+			</box>
+			<box flexDirection="row">
+				<text fg={palette.act} selectable>
+					<a href={subscriptionUrl}>{subscriptionUrl}</a>
+				</text>
+			</box>
+			<box flexDirection="row">
+				<box paddingX={1} backgroundColor={palette.act}>
+					<text fg={palette.textOnSelection}>Open ClinePass</text>
+				</box>
+			</box>
+			{status && <text fg={palette.muted}>{status}</text>}
+			<text fg={palette.muted}>Press Enter to open, Esc to close</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/kanban-migration/notice.test.ts b/apps/cli/src/kanban-migration/notice.test.ts
new file mode 100644
index 0000000..4d85933
--- /dev/null
+++ b/apps/cli/src/kanban-migration/notice.test.ts
@@ -0,0 +1,146 @@
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	getClineCliMigrationNotice,
+	markClineCliMigrationNoticeShown,
+	resolveCliNoticeStatePath,
+	shouldSuppressClineCliMigrationNoticeForActiveProvider,
+} from "./notice";
+
+const tempDirs: string[] = [];
+
+function createTempDataDir(): string {
+	const dir = mkdtempSync(join(tmpdir(), "cline-cli-notice-"));
+	tempDirs.push(dir);
+	return dir;
+}
+
+describe("migration notice", () => {
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("returns the notice for a fresh data dir", () => {
+		const dataDir = createTempDataDir();
+
+		expect(getClineCliMigrationNotice(dataDir)?.title).toBe("Try ClinePass");
+	});
+
+	it("shows when only the old Kanban notice was marked as shown", () => {
+		const dataDir = createTempDataDir();
+		const noticePath = resolveCliNoticeStatePath(dataDir);
+		mkdirSync(dirname(noticePath), { recursive: true, mode: 0o700 });
+		writeFileSync(
+			noticePath,
+			`${JSON.stringify(
+				{ shown: { "cline-cli-tui-default": true } },
+				null,
+				2,
+			)}\n`,
+			"utf8",
+		);
+
+		expect(getClineCliMigrationNotice(dataDir)?.id).toBe(
+			"cline-cli-cline-pass-intro",
+		);
+	});
+
+	it("does not show after the notice is marked as shown", () => {
+		const dataDir = createTempDataDir();
+
+		markClineCliMigrationNoticeShown(dataDir);
+
+		expect(getClineCliMigrationNotice(dataDir)).toBeUndefined();
+	});
+
+	it("shows after the notice is marked as shown when forced", () => {
+		const dataDir = createTempDataDir();
+
+		markClineCliMigrationNoticeShown(dataDir);
+
+		expect(
+			getClineCliMigrationNotice(dataDir, {
+				CLINE_FORCE_CLINE_PASS_NOTICE: "1",
+			}),
+		).toBeDefined();
+	});
+
+	it("does not show when disabled through the environment", () => {
+		const dataDir = createTempDataDir();
+
+		expect(
+			getClineCliMigrationNotice(dataDir, {
+				CLINE_DISABLE_CLINE_PASS_NOTICE: "1",
+			}),
+		).toBeUndefined();
+	});
+
+	it("does not show when ClinePass is already the active provider", () => {
+		const dataDir = createTempDataDir();
+
+		expect(
+			getClineCliMigrationNotice(
+				dataDir,
+				{},
+				{ activeProviderId: "cline-pass" },
+			),
+		).toBeUndefined();
+	});
+
+	it("suppresses the active ClinePass provider even when the provider id has surrounding whitespace", () => {
+		expect(
+			shouldSuppressClineCliMigrationNoticeForActiveProvider(" cline-pass "),
+		).toBe(true);
+	});
+
+	it("does not suppress the active ClinePass provider when forced", () => {
+		expect(
+			shouldSuppressClineCliMigrationNoticeForActiveProvider("cline-pass", {
+				CLINE_FORCE_CLINE_PASS_NOTICE: "1",
+			}),
+		).toBe(false);
+	});
+
+	it("shows for the active ClinePass provider when forced", () => {
+		const dataDir = createTempDataDir();
+
+		expect(
+			getClineCliMigrationNotice(
+				dataDir,
+				{ CLINE_FORCE_CLINE_PASS_NOTICE: "1" },
+				{ activeProviderId: "cline-pass" },
+			),
+		).toBeDefined();
+	});
+
+	it("shows when forced even if disabled through the environment", () => {
+		const dataDir = createTempDataDir();
+
+		expect(
+			getClineCliMigrationNotice(dataDir, {
+				CLINE_DISABLE_CLINE_PASS_NOTICE: "1",
+				CLINE_FORCE_CLINE_PASS_NOTICE: "1",
+			}),
+		).toBeDefined();
+	});
+
+	it("marks the notice as shown", () => {
+		const dataDir = createTempDataDir();
+
+		markClineCliMigrationNoticeShown(dataDir);
+
+		const rawState = readFileSync(resolveCliNoticeStatePath(dataDir), "utf8");
+		expect(rawState).toContain("cline-cli-cline-pass-intro");
+		expect(getClineCliMigrationNotice(dataDir)).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/kanban-migration/notice.ts b/apps/cli/src/kanban-migration/notice.ts
new file mode 100644
index 0000000..d8e8cf2
--- /dev/null
+++ b/apps/cli/src/kanban-migration/notice.ts
@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveClineDataDir } from "@cline/shared/storage";
+
+const NOTICE_ID = "cline-cli-cline-pass-intro";
+const FORCE_NOTICE_ENV = "CLINE_FORCE_CLINE_PASS_NOTICE";
+const DISABLE_NOTICE_ENV = "CLINE_DISABLE_CLINE_PASS_NOTICE";
+
+export interface CliMigrationNotice {
+	id: string;
+	title: string;
+}
+
+export interface CliMigrationNoticeOptions {
+	activeProviderId?: string;
+}
+
+interface CliNoticeState {
+	shown: Record<string, boolean>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function readJsonRecord(filePath: string): Record<string, unknown> | undefined {
+	if (!existsSync(filePath)) {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, "utf8")) as unknown;
+		return isRecord(parsed) ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function readNoticeState(filePath: string): CliNoticeState {
+	const parsed = readJsonRecord(filePath);
+	const shown: Record<string, boolean> = {};
+	if (!parsed) {
+		return { shown };
+	}
+	const rawShown = parsed.shown;
+	if (!isRecord(rawShown)) {
+		return { shown };
+	}
+	for (const [key, value] of Object.entries(rawShown)) {
+		if (typeof value === "boolean") {
+			shown[key] = value;
+		}
+	}
+	return { shown };
+}
+
+function isForceNoticeEnabled(env: NodeJS.ProcessEnv): boolean {
+	return env[FORCE_NOTICE_ENV]?.trim() === "1";
+}
+
+export function shouldSuppressClineCliMigrationNoticeForActiveProvider(
+	activeProviderId: string | undefined,
+	env: NodeJS.ProcessEnv = process.env,
+): boolean {
+	return (
+		activeProviderId?.trim() === "cline-pass" && !isForceNoticeEnabled(env)
+	);
+}
+
+export function resolveCliNoticeStatePath(
+	dataDir = resolveClineDataDir(),
+): string {
+	return join(dataDir, "settings", "cli-notices.json");
+}
+
+export function getClineCliMigrationNotice(
+	dataDir = resolveClineDataDir(),
+	env: NodeJS.ProcessEnv = process.env,
+	options: CliMigrationNoticeOptions = {},
+): CliMigrationNotice | undefined {
+	const noticePath = resolveCliNoticeStatePath(dataDir);
+	const noticeState = readNoticeState(noticePath);
+	const forceNotice = isForceNoticeEnabled(env);
+	const disableNotice = env[DISABLE_NOTICE_ENV]?.trim() === "1";
+	if (disableNotice && !forceNotice) {
+		return undefined;
+	}
+	if (
+		shouldSuppressClineCliMigrationNoticeForActiveProvider(
+			options.activeProviderId,
+			env,
+		)
+	) {
+		return undefined;
+	}
+	if (noticeState.shown[NOTICE_ID] && !forceNotice) {
+		return undefined;
+	}
+	return {
+		id: NOTICE_ID,
+		title: "Try ClinePass",
+	};
+}
+
+export function markClineCliMigrationNoticeShown(
+	dataDir = resolveClineDataDir(),
+): void {
+	const noticePath = resolveCliNoticeStatePath(dataDir);
+	const noticeState = readNoticeState(noticePath);
+	const nextState: CliNoticeState = {
+		shown: {
+			...noticeState.shown,
+			[NOTICE_ID]: true,
+		},
+	};
+	mkdirSync(dirname(noticePath), { recursive: true, mode: 0o700 });
+	writeFileSync(noticePath, `${JSON.stringify(nextState, null, 2)}\n`, "utf8");
+}
diff --git a/apps/cli/src/logging/adapter.test.ts b/apps/cli/src/logging/adapter.test.ts
new file mode 100644
index 0000000..3747ecc
--- /dev/null
+++ b/apps/cli/src/logging/adapter.test.ts
@@ -0,0 +1,346 @@
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	utimesSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import pino from "pino";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getCliBuildInfo } from "../utils/common";
+import {
+	createCliLoggerAdapter,
+	flushCliLoggerAdapters,
+	shutdownCliLoggerAdapters,
+} from "./adapter";
+import { logCliProcessError } from "./errors";
+
+const envKeys = [
+	"CLINE_DATA_DIR",
+	"CLINE_LOG_PATH",
+	"CLINE_LOG_LEVEL",
+	"CLINE_LOG_NAME",
+	"CLINE_LOG_ENABLED",
+] as const;
+
+function withEnvSnapshot(): Record<
+	(typeof envKeys)[number],
+	string | undefined
+> {
+	return {
+		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+		CLINE_LOG_PATH: process.env.CLINE_LOG_PATH,
+		CLINE_LOG_LEVEL: process.env.CLINE_LOG_LEVEL,
+		CLINE_LOG_NAME: process.env.CLINE_LOG_NAME,
+		CLINE_LOG_ENABLED: process.env.CLINE_LOG_ENABLED,
+	};
+}
+
+function restoreEnv(
+	snapshot: Record<(typeof envKeys)[number], string | undefined>,
+): void {
+	for (const key of envKeys) {
+		const value = snapshot[key];
+		if (value === undefined) {
+			delete process.env[key];
+			continue;
+		}
+		process.env[key] = value;
+	}
+}
+
+const commandName = getCliBuildInfo().name;
+
+describe("createCliLoggerAdapter", () => {
+	afterEach(() => {
+		shutdownCliLoggerAdapters();
+		vi.restoreAllMocks();
+	});
+
+	it("resolves default runtime config from data dir", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-log-test-`));
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		try {
+			const adapter = createCliLoggerAdapter({ runtime: "cli" });
+			expect(adapter.runtimeConfig.destination).toBe(
+				join(dataDir, "logs", `${commandName}.log`),
+			);
+			expect(adapter.runtimeConfig.level).toBe("info");
+			expect(adapter.runtimeConfig.name).toBe(`${commandName}.cli`);
+			expect(adapter.runtimeConfig.enabled).toBe(true);
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("uses provided runtime config in rpc runtime", () => {
+		const adapter = createCliLoggerAdapter({
+			runtime: "rpc-runtime",
+			runtimeConfig: {
+				destination: "/tmp/custom-runtime.log",
+				level: "warn",
+				name: "custom-runtime",
+				enabled: false,
+			},
+		});
+
+		expect(adapter.runtimeConfig.destination).toBe("/tmp/custom-runtime.log");
+		expect(adapter.runtimeConfig.level).toBe("warn");
+		expect(adapter.runtimeConfig.name).toBe("custom-runtime");
+		expect(adapter.runtimeConfig.enabled).toBe(false);
+	});
+
+	it("maps core logger metadata with error payload", () => {
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-log-test-`));
+		const snapshot = withEnvSnapshot();
+		process.env.CLINE_DATA_DIR = dataDir;
+		process.env.CLINE_LOG_ENABLED = "0";
+		try {
+			const adapter = createCliLoggerAdapter({ runtime: "cli" });
+			expect(() => {
+				adapter.core.error?.("runtime error", {
+					error: new Error("boom"),
+					sessionId: "s1",
+				});
+			}).not.toThrow();
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("writes process-level errors to the CLI log", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-process-log-`));
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		try {
+			logCliProcessError(
+				"unhandledRejection",
+				new Error("message schema validation failed"),
+			);
+
+			const logPath = join(dataDir, "logs", `${commandName}.log`);
+			const log = readFileSync(logPath, "utf8");
+			expect(log).toContain("CLI process error");
+			expect(log).toContain("unhandledRejection");
+			expect(log).toContain("message schema validation failed");
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("truncates stale log files older than two days on startup", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-log-test-`));
+		const logPath = join(dataDir, "logs", `${commandName}.log`);
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		try {
+			mkdirSync(dirname(logPath), { recursive: true });
+			writeFileSync(logPath, "old log contents", "utf8");
+			const staleDate = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000);
+			utimesSync(logPath, staleDate, staleDate);
+
+			createCliLoggerAdapter({ runtime: "cli" });
+			expect(readFileSync(logPath, "utf8")).toBe("");
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("falls back when log destination path is not writable", () => {
+		const snapshot = withEnvSnapshot();
+		const unwritablePath = mkdtempSync(
+			join(tmpdir(), `${commandName}-log-dir-as-file-`),
+		);
+		delete process.env.CLINE_DATA_DIR;
+		process.env.CLINE_LOG_PATH = unwritablePath;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		const stderrWriteSpy = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+		try {
+			expect(() => {
+				const adapter = createCliLoggerAdapter({ runtime: "cli" });
+				adapter.core.log("fallback path test");
+			}).not.toThrow();
+		} finally {
+			stderrWriteSpy.mockRestore();
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("uses process stderr fallback for cli runtime", () => {
+		const snapshot = withEnvSnapshot();
+		const unwritablePath = mkdtempSync(
+			join(tmpdir(), `${commandName}-log-dir-as-file-`),
+		);
+		delete process.env.CLINE_DATA_DIR;
+		process.env.CLINE_LOG_PATH = unwritablePath;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		const destinationSpy = vi.spyOn(pino, "destination");
+		const stderrWriteSpy = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+		try {
+			const adapter = createCliLoggerAdapter({ runtime: "cli" });
+			adapter.core.log("fallback process stderr");
+
+			expect(destinationSpy).not.toHaveBeenCalledWith(
+				expect.objectContaining({ dest: 2 }),
+			);
+			expect(stderrWriteSpy).toHaveBeenCalledWith(
+				expect.stringContaining("fallback process stderr"),
+			);
+		} finally {
+			stderrWriteSpy.mockRestore();
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("uses sync pino destination for cli runtime", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-log-test-`));
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		const destinationSpy = vi.spyOn(pino, "destination");
+		try {
+			createCliLoggerAdapter({ runtime: "cli" });
+			expect(destinationSpy).toHaveBeenCalledWith(
+				expect.objectContaining({
+					sync: true,
+				}),
+			);
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("flushes immediate-shutdown logs without sonic-boom readiness errors", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(
+			join(tmpdir(), `${commandName}-shutdown-test-`),
+		);
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		try {
+			const adapter = createCliLoggerAdapter({
+				runtime: "cli",
+				component: "shutdown-test",
+			});
+			expect(() => {
+				adapter.core.log("immediate shutdown");
+				flushCliLoggerAdapters();
+			}).not.toThrowError(/sonic boom is not ready yet/);
+
+			const logPath = join(dataDir, "logs", `${commandName}.log`);
+			expect(readFileSync(logPath, "utf8")).toContain("immediate shutdown");
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("keeps normal logging behavior with explicit flush", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-flush-test-`));
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		try {
+			const adapter = createCliLoggerAdapter({
+				runtime: "cli",
+				component: "flush-test",
+			});
+			adapter.core.log("normal logging");
+			expect(() => flushCliLoggerAdapters()).not.toThrow();
+
+			const logPath = join(dataDir, "logs", `${commandName}.log`);
+			expect(readFileSync(logPath, "utf8")).toContain("normal logging");
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("closes cli loggers cleanly during shutdown", async () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-close-test-`));
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		try {
+			const adapter = createCliLoggerAdapter({
+				runtime: "cli",
+				component: "close-test",
+			});
+			adapter.core.log("shutdown logging");
+
+			expect(() => shutdownCliLoggerAdapters()).not.toThrow();
+
+			const logPath = join(dataDir, "logs", `${commandName}.log`);
+			expect(readFileSync(logPath, "utf8")).toContain("shutdown logging");
+		} finally {
+			restoreEnv(snapshot);
+		}
+	});
+
+	it("clears log cleanup timers during shutdown", () => {
+		const snapshot = withEnvSnapshot();
+		const dataDir = mkdtempSync(join(tmpdir(), `${commandName}-timer-test-`));
+		process.env.CLINE_DATA_DIR = dataDir;
+		delete process.env.CLINE_LOG_PATH;
+		delete process.env.CLINE_LOG_LEVEL;
+		delete process.env.CLINE_LOG_NAME;
+		delete process.env.CLINE_LOG_ENABLED;
+
+		const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+		try {
+			createCliLoggerAdapter({
+				runtime: "cli",
+				component: "timer-test",
+			});
+
+			shutdownCliLoggerAdapters();
+
+			expect(clearIntervalSpy).toHaveBeenCalled();
+		} finally {
+			clearIntervalSpy.mockRestore();
+			restoreEnv(snapshot);
+		}
+	});
+});
diff --git a/apps/cli/src/logging/adapter.ts b/apps/cli/src/logging/adapter.ts
new file mode 100644
index 0000000..d3c7d81
--- /dev/null
+++ b/apps/cli/src/logging/adapter.ts
@@ -0,0 +1,359 @@
+import {
+	closeSync,
+	existsSync,
+	mkdirSync,
+	openSync,
+	statSync,
+	truncateSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import type { BasicLogger, RuntimeLoggerConfig } from "@cline/core";
+import { resolveClineDataDir } from "@cline/core";
+import { registerDisposable } from "@cline/shared";
+import pino, {
+	type DestinationStream,
+	type LevelWithSilent,
+	type Logger as PinoLogger,
+} from "pino";
+import { getCliBuildInfo } from "../utils/common";
+
+const loggerCache = new Map<
+	string,
+	{ logger: PinoLogger; destination?: DestinationStream }
+>();
+const cleanupTimersByDestination = new Map<string, NodeJS.Timeout>();
+const LOG_CLEANUP_INTERVAL_MS = 2 * 24 * 60 * 60 * 1000;
+
+export interface CliLoggerAdapter {
+	readonly pino: PinoLogger;
+	readonly core: BasicLogger;
+	readonly runtimeConfig: RuntimeLoggerConfig;
+	child(bindings: Record<string, unknown>): CliLoggerAdapter;
+}
+
+interface CreateCliLoggerAdapterInput {
+	runtime: "cli" | "rpc-runtime";
+	component?: string;
+	runtimeConfig?: RuntimeLoggerConfig;
+}
+
+const LOG_LEVELS: ReadonlySet<LevelWithSilent> = new Set([
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal",
+	"silent",
+]);
+
+function normalizeLogLevel(value: string | undefined): LevelWithSilent {
+	const candidate = value?.trim().toLowerCase() as LevelWithSilent | undefined;
+	if (!candidate || !LOG_LEVELS.has(candidate)) {
+		return "info";
+	}
+	return candidate;
+}
+
+function normalizeRuntimeConfig(input: {
+	runtime: "cli" | "rpc-runtime";
+	runtimeConfig?: RuntimeLoggerConfig;
+}): Required<RuntimeLoggerConfig> {
+	const base = input.runtimeConfig;
+	const defaultDestination = join(
+		resolveClineDataDir(),
+		"logs",
+		`${getCliBuildInfo().name}.log`,
+	);
+	const enabledEnv = process.env.CLINE_LOG_ENABLED?.trim();
+	const enabled =
+		base?.enabled ??
+		!(enabledEnv === "0" || enabledEnv?.toLowerCase() === "false");
+	const level = normalizeLogLevel(base?.level ?? process.env.CLINE_LOG_LEVEL);
+	const destination =
+		base?.destination?.trim() ||
+		process.env.CLINE_LOG_PATH?.trim() ||
+		defaultDestination;
+	const name =
+		base?.name?.trim() ||
+		process.env.CLINE_LOG_NAME?.trim() ||
+		`${getCliBuildInfo().name}.${input.runtime}`;
+	const bindings = base?.bindings ?? {};
+
+	return {
+		enabled,
+		level,
+		destination,
+		name,
+		bindings,
+	};
+}
+
+function getOrCreatePinoLogger(
+	config: Required<RuntimeLoggerConfig>,
+	runtime: "cli" | "rpc-runtime",
+): PinoLogger {
+	if (!config.enabled) {
+		return pino({
+			name: config.name,
+			level: "silent",
+			enabled: false,
+			timestamp: pino.stdTimeFunctions.isoTime,
+		});
+	}
+	const key = `${runtime}|${config.enabled}|${config.level}|${config.destination}|${config.name}`;
+	const cached = loggerCache.get(key);
+	if (cached) {
+		return cached.logger;
+	}
+
+	if (loggerCache.size === 0) {
+		registerDisposable(shutdownCliLoggerAdapters);
+	}
+
+	const destination = createWritableDestination(config.destination, runtime);
+	if (destination) {
+		cleanupStaleLogFile(config.destination);
+		startLogCleanupTimer(config.destination);
+	}
+	const created = pino(
+		{
+			name: config.name,
+			level: config.level,
+			timestamp: pino.stdTimeFunctions.isoTime,
+			enabled: config.enabled,
+		},
+		destination ?? createFallbackDestination(runtime),
+	);
+	loggerCache.set(key, { logger: created, destination });
+	return created;
+}
+
+function createWritableDestination(
+	destinationPath: string,
+	_runtime: "cli" | "rpc-runtime",
+): DestinationStream | undefined {
+	try {
+		mkdirSync(dirname(destinationPath), { recursive: true });
+		const fd = openSync(destinationPath, "a");
+		closeSync(fd);
+		const dest = pino.destination({
+			dest: destinationPath,
+			mkdir: true,
+			sync: true,
+		});
+		// SonicBoom registers its own process 'exit' handler that calls
+		// flushSync().  When the process exits before the async stream is
+		// ready (e.g. --help, --version) that handler throws
+		// "sonic boom is not ready yet".  Wrap flushSync so it silently
+		// no-ops instead of throwing.
+		const origFlushSync = dest.flushSync.bind(dest);
+		dest.flushSync = () => {
+			try {
+				origFlushSync();
+			} catch {
+				// Best-effort: stream not ready or already closed.
+			}
+		};
+		return dest;
+	} catch {
+		return undefined;
+	}
+}
+
+function createFallbackDestination(
+	runtime: "cli" | "rpc-runtime",
+): DestinationStream {
+	if (runtime === "cli") {
+		return {
+			write: (msg) => {
+				process.stderr.write(msg);
+			},
+		};
+	}
+	return pino.destination({ dest: 2, sync: false });
+}
+
+function cleanupStaleLogFile(destination: string): void {
+	if (!existsSync(destination)) {
+		return;
+	}
+	try {
+		const stats = statSync(destination);
+		const ageMs = Date.now() - stats.mtimeMs;
+		if (ageMs >= LOG_CLEANUP_INTERVAL_MS) {
+			truncateSync(destination, 0);
+		}
+	} catch {
+		// no-op: cleanup is best-effort.
+	}
+}
+
+function startLogCleanupTimer(destination: string): void {
+	if (cleanupTimersByDestination.has(destination)) {
+		return;
+	}
+	const timer = setInterval(() => {
+		try {
+			truncateSync(destination, 0);
+		} catch {
+			// no-op: cleanup is best-effort.
+		}
+	}, LOG_CLEANUP_INTERVAL_MS);
+	timer.unref();
+	cleanupTimersByDestination.set(destination, timer);
+}
+
+function stopLogCleanupTimers(): void {
+	for (const timer of cleanupTimersByDestination.values()) {
+		clearInterval(timer);
+	}
+	cleanupTimersByDestination.clear();
+}
+
+function toPinoFields(
+	metadata?: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+	if (!metadata) {
+		return undefined;
+	}
+	const { error, ...rest } = metadata;
+	if (error === undefined) {
+		return Object.keys(rest).length > 0 ? rest : undefined;
+	}
+	const fields: Record<string, unknown> = { ...rest, err: error };
+	return fields;
+}
+
+function createCoreLogger(logger: PinoLogger): BasicLogger {
+	return {
+		debug: (message, metadata) => {
+			const fields = toPinoFields(metadata);
+			if (fields) {
+				logger.debug(fields, message);
+				return;
+			}
+			logger.debug(message);
+		},
+		log: (message, metadata) => {
+			const severity = metadata?.severity;
+			const rest =
+				metadata === undefined
+					? undefined
+					: (() => {
+							const { severity: _ignored, ...r } = metadata;
+							return Object.keys(r).length > 0 ? r : undefined;
+						})();
+			const fields = toPinoFields(rest);
+			const levelFn =
+				severity === "warn"
+					? logger.warn
+					: severity === "error"
+						? logger.error
+						: logger.info;
+			if (fields) {
+				levelFn.call(logger, fields, message);
+				return;
+			}
+			levelFn.call(logger, message);
+		},
+		error: (message, metadata) => {
+			const fields = toPinoFields(metadata);
+			if (fields) {
+				logger.error(fields, message);
+				return;
+			}
+			logger.error(message);
+		},
+	};
+}
+
+function createAdapterFromPino(
+	logger: PinoLogger,
+	runtimeConfig: Required<RuntimeLoggerConfig>,
+): CliLoggerAdapter {
+	return {
+		pino: logger,
+		core: createCoreLogger(logger),
+		runtimeConfig,
+		child: (bindings) =>
+			createAdapterFromPino(logger.child(bindings), runtimeConfig),
+	};
+}
+
+export function createCliLoggerAdapter(
+	input: CreateCliLoggerAdapterInput,
+): CliLoggerAdapter {
+	const runtimeConfig = normalizeRuntimeConfig({
+		runtime: input.runtime,
+		runtimeConfig: input.runtimeConfig,
+	});
+	const baseLogger = getOrCreatePinoLogger(runtimeConfig, input.runtime);
+	const logger = baseLogger.child({
+		...runtimeConfig.bindings,
+		...(input.component ? { component: input.component } : {}),
+	});
+	return createAdapterFromPino(logger, runtimeConfig);
+}
+
+function isIgnorableLoggerShutdownError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return (
+		message.includes("sonic boom is not ready yet") ||
+		message.includes("SonicBoom destroyed")
+	);
+}
+
+function flushLoggerEntry(entry: {
+	logger: PinoLogger;
+	destination?: DestinationStream;
+}): void {
+	try {
+		const syncFlusher = entry.destination as DestinationStream & {
+			flushSync?: () => void;
+		};
+		if (syncFlusher && typeof syncFlusher.flushSync === "function") {
+			syncFlusher.flushSync();
+			return;
+		}
+		if (typeof entry.logger.flush === "function") {
+			entry.logger.flush();
+		}
+	} catch (error) {
+		if (!isIgnorableLoggerShutdownError(error)) {
+			throw error;
+		}
+	}
+}
+
+export function flushCliLoggerAdapters(): void {
+	for (const entry of loggerCache.values()) {
+		try {
+			flushLoggerEntry(entry);
+		} catch {
+			// no-op: shutdown flush is best-effort.
+		}
+	}
+}
+
+export function shutdownCliLoggerAdapters(): void {
+	for (const entry of loggerCache.values()) {
+		try {
+			flushLoggerEntry(entry);
+		} catch {
+			// no-op: shutdown flush is best-effort.
+		}
+		try {
+			const closableDestination = entry.destination as DestinationStream & {
+				end?: () => void;
+			};
+			closableDestination.end?.();
+		} catch (error) {
+			if (!isIgnorableLoggerShutdownError(error)) {
+				// no-op: shutdown close is best-effort.
+			}
+		}
+	}
+	loggerCache.clear();
+	stopLogCleanupTimers();
+}
diff --git a/apps/cli/src/logging/errors.ts b/apps/cli/src/logging/errors.ts
new file mode 100644
index 0000000..6939f58
--- /dev/null
+++ b/apps/cli/src/logging/errors.ts
@@ -0,0 +1,30 @@
+import type { BasicLogger } from "@cline/core";
+import { createCliLoggerAdapter, flushCliLoggerAdapters } from "./adapter";
+
+export function logCliError(
+	logger: BasicLogger | undefined,
+	message: string,
+	metadata: Record<string, unknown> & { error?: unknown } = {},
+): void {
+	if (logger?.error) {
+		logger.error(message, metadata);
+		return;
+	}
+	logger?.log(message, {
+		...metadata,
+		severity: "error",
+	});
+}
+
+export function logCliProcessError(kind: string, error: unknown): void {
+	try {
+		const logger = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "process",
+		});
+		logCliError(logger.core, "CLI process error", { kind, error });
+		flushCliLoggerAdapters();
+	} catch {
+		// Process-level logging is best-effort; stderr still gets the error.
+	}
+}
diff --git a/apps/cli/src/logging/process.ts b/apps/cli/src/logging/process.ts
new file mode 100644
index 0000000..def5100
--- /dev/null
+++ b/apps/cli/src/logging/process.ts
@@ -0,0 +1,30 @@
+import { createCliLoggerAdapter } from "./adapter";
+
+interface LogSpawnedProcessInput {
+	component: string;
+	command: string[];
+	childPid?: number;
+	cwd?: string;
+	detached?: boolean;
+	metadata?: Record<string, unknown>;
+}
+
+export function logSpawnedProcess(input: LogSpawnedProcessInput): void {
+	try {
+		const logger = createCliLoggerAdapter({
+			runtime: "cli",
+			component: input.component,
+		});
+		logger.core.log("Process spawned", {
+			command: input.command.join(" "),
+			commandArgs: input.command.slice(1),
+			executable: input.command[0],
+			childPid: input.childPid,
+			cwd: input.cwd,
+			detached: input.detached,
+			...input.metadata,
+		});
+	} catch {
+		// Best-effort logging only.
+	}
+}
diff --git a/apps/cli/src/main.test.ts b/apps/cli/src/main.test.ts
new file mode 100644
index 0000000..467cbee
--- /dev/null
+++ b/apps/cli/src/main.test.ts
@@ -0,0 +1,1738 @@
+import { fstatSync } from "node:fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type {
+	CliMigrationNotice,
+	CliMigrationNoticeOptions,
+} from "./kanban-migration/notice";
+
+/** Real `fstatSync`: used when tests stub only stdin (fd 0); throwing for every fd breaks imports and session I/O. */
+const fsActual = vi.hoisted(() => ({
+	realFstatSync: null as null | typeof import("node:fs").fstatSync,
+}));
+vi.mock("node:fs", async () => {
+	const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
+	fsActual.realFstatSync = actual.fstatSync;
+	return { ...actual, fstatSync: vi.fn(actual.fstatSync) };
+});
+
+const originalArgv = [...process.argv];
+const originalStdinIsTTY = process.stdin.isTTY;
+const originalStdoutIsTTY = process.stdout.isTTY;
+const mockState = vi.hoisted(() => ({
+	runAgentImports: 0,
+	runInteractiveImports: 0,
+	runAgentCalls: 0,
+}));
+const authMocks = vi.hoisted(() => ({
+	ensureOAuthProviderApiKey: vi.fn(),
+	getPersistedProviderApiKey: vi.fn(() => undefined),
+	isOAuthProvider: vi.fn(() => false),
+	normalizeProviderId: vi.fn((providerId?: string) => providerId ?? "cline"),
+	parseAuthCommandArgs: vi.fn(),
+	runAuthCommand: vi.fn(),
+}));
+const providerSettingsMocks = vi.hoisted(() => ({
+	getLastUsedProviderSettings: vi.fn<(options?: unknown) => unknown>(
+		() => undefined,
+	),
+	getProviderConfig: vi.fn<(providerId: string, options?: unknown) => unknown>(
+		() => undefined,
+	),
+	getProviderSettings: vi.fn<(providerId: string) => unknown>(() => undefined),
+	saveProviderSettings: vi.fn<(settings: unknown, options?: unknown) => void>(
+		() => {},
+	),
+}));
+const sessionMocks = vi.hoisted(() => ({
+	deleteSession: vi.fn(),
+	getSessionRow: vi.fn(),
+	listSessions: vi.fn(async () => []),
+	updateSession: vi.fn(),
+}));
+const llmMocks = vi.hoisted(() => ({
+	resolveProviderConfig: vi.fn(async (): Promise<unknown> => undefined),
+}));
+const promptMocks = vi.hoisted(() => ({
+	resolveSystemPrompt: vi.fn(async () => "system prompt"),
+}));
+const kanbanMocks = vi.hoisted(() => ({
+	launchKanban: vi.fn(),
+}));
+const dashboardMocks = vi.hoisted(() => ({
+	runDashboardCommand: vi.fn(),
+}));
+const migrationNoticeMocks = vi.hoisted(() => ({
+	getClineCliMigrationNotice: vi.fn<
+		(
+			dataDir?: string,
+			env?: NodeJS.ProcessEnv,
+			options?: CliMigrationNoticeOptions,
+		) => CliMigrationNotice | undefined
+	>(() => undefined),
+	markClineCliMigrationNoticeShown: vi.fn(),
+}));
+const updateMocks = vi.hoisted(() => ({
+	autoUpdateOnStartup: vi.fn(),
+	checkForUpdates: vi.fn(async () => 0),
+	getPreferredKanbanInstaller: vi.fn(() => undefined),
+}));
+const runtimeMocks = vi.hoisted(() => ({
+	runAgent: vi.fn(async () => {
+		mockState.runAgentCalls += 1;
+	}),
+	runInteractive: vi.fn(),
+}));
+const worktreeMocks = vi.hoisted(() => ({
+	createTaskWorktree: vi.fn(),
+}));
+const historyMocks = vi.hoisted(() => ({
+	runHistoryList: vi.fn<() => Promise<number | string>>(async () => 0),
+	runHistoryDelete: vi.fn(async () => 0),
+	runHistoryExport: vi.fn(async () => 0),
+	runHistoryUpdate: vi.fn(async () => 0),
+}));
+const historyResumeMocks = vi.hoisted(() => ({
+	spawnHistoryResume: vi.fn<() => Promise<number | undefined>>(
+		async () => undefined,
+	),
+}));
+const loggingMocks = vi.hoisted(() => ({
+	createCliLoggerAdapter: vi.fn(() => ({
+		core: {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		},
+		runtimeConfig: undefined,
+	})),
+	flushCliLoggerAdapters: vi.fn(),
+}));
+const hubRuntimeMocks = vi.hoisted(() => ({
+	ensureCliHubServer: vi.fn(async () => ({
+		url: "ws://127.0.0.1:25463",
+		authToken: "test-token",
+	})),
+}));
+const telemetryMocks = vi.hoisted(() => ({
+	captureCliExtensionActivated: vi.fn(),
+	identifyTelemetryAccount: vi.fn(),
+	getCliTelemetryService: vi.fn(),
+	disposeCliTelemetryService: vi.fn(async () => {}),
+}));
+const featureFlagMocks = vi.hoisted(() => ({
+	getBooleanFlagEnabled: vi.fn(() => false),
+	setCliFeatureFlagsAccountContext: vi.fn(),
+	refreshCliFeatureFlagsInBackground: vi.fn(),
+}));
+
+function forcePromptModeInput() {
+	Object.defineProperty(process.stdin, "isTTY", {
+		value: true,
+		configurable: true,
+	});
+	vi.mocked(fstatSync).mockImplementation((fd, ...rest) => {
+		if (fd === 0) {
+			throw new Error("stdin not piped");
+		}
+		const real = fsActual.realFstatSync;
+		if (!real) {
+			throw new Error("node:fs fstatSync mock not initialized");
+		}
+		return real(fd, ...rest) as
+			| import("node:fs").Stats
+			| import("node:fs").BigIntStats;
+	});
+}
+
+vi.mock("./runtime/run-agent", () => {
+	mockState.runAgentImports += 1;
+	return {
+		runAgent: runtimeMocks.runAgent,
+	};
+});
+vi.mock("./runtime/run-interactive", () => {
+	mockState.runInteractiveImports += 1;
+	return {
+		runInteractive: runtimeMocks.runInteractive,
+	};
+});
+vi.mock("./utils/session", () => sessionMocks);
+vi.mock("./session/session", () => sessionMocks);
+vi.mock("@cline/core", async () => {
+	return {
+		...(await vi.importActual("@cline/core")),
+		resolveProviderConfig: llmMocks.resolveProviderConfig,
+		createTeamName: vi.fn(() => "team-test"),
+		createUserInstructionConfigService: vi.fn(() => ({
+			start: vi.fn(async () => {}),
+			stop: vi.fn(),
+		})),
+		ProviderSettingsManager: class {
+			getLastUsedProviderSettings(options?: unknown) {
+				return providerSettingsMocks.getLastUsedProviderSettings(options);
+			}
+			getProviderSettings(providerId: string) {
+				return providerSettingsMocks.getProviderSettings(providerId);
+			}
+			getProviderConfig(providerId: string, options?: unknown) {
+				return providerSettingsMocks.getProviderConfig(providerId, options);
+			}
+			saveProviderSettings(settings: unknown, options?: unknown) {
+				providerSettingsMocks.saveProviderSettings(settings, options);
+			}
+		},
+	};
+});
+vi.mock("./utils/provider-auth", () => authMocks);
+vi.mock("./utils/feature-flags", () => ({
+	getCliFeatureFlagsService: () => ({
+		getBooleanFlagEnabled: featureFlagMocks.getBooleanFlagEnabled,
+	}),
+	refreshCliFeatureFlagsInBackground:
+		featureFlagMocks.refreshCliFeatureFlagsInBackground,
+	setCliFeatureFlagsAccountContext:
+		featureFlagMocks.setCliFeatureFlagsAccountContext,
+}));
+vi.mock("./runtime/prompt", () => ({
+	resolveSystemPrompt: promptMocks.resolveSystemPrompt,
+}));
+vi.mock("./commands/kanban", () => kanbanMocks);
+vi.mock("./commands/dashboard", () => dashboardMocks);
+vi.mock("./kanban-migration/notice", () => migrationNoticeMocks);
+vi.mock("./commands/update", () => updateMocks);
+vi.mock("./commands/history", () => historyMocks);
+vi.mock("./utils/history-resume", () => historyResumeMocks);
+vi.mock("./logging/adapter", () => loggingMocks);
+vi.mock("./utils/hub-runtime", () => hubRuntimeMocks);
+vi.mock("./utils/telemetry", () => telemetryMocks);
+vi.mock("./utils/worktree", () => worktreeMocks);
+
+describe("runCli lightweight command dispatch", () => {
+	beforeEach(() => {
+		process.exitCode = undefined;
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+		mockState.runAgentCalls = 0;
+		historyMocks.runHistoryList.mockReset();
+		historyMocks.runHistoryList.mockResolvedValue(0);
+		historyMocks.runHistoryDelete.mockReset();
+		historyMocks.runHistoryDelete.mockResolvedValue(0);
+		historyMocks.runHistoryExport.mockReset();
+		historyMocks.runHistoryExport.mockResolvedValue(0);
+		historyMocks.runHistoryUpdate.mockReset();
+		historyMocks.runHistoryUpdate.mockResolvedValue(0);
+		historyResumeMocks.spawnHistoryResume.mockReset();
+		historyResumeMocks.spawnHistoryResume.mockResolvedValue(undefined);
+		sessionMocks.getSessionRow.mockReset();
+		sessionMocks.getSessionRow.mockResolvedValue({
+			sessionId: "sess_123",
+		});
+		runtimeMocks.runAgent.mockReset();
+		runtimeMocks.runAgent.mockImplementation(async () => {
+			mockState.runAgentCalls += 1;
+		});
+		runtimeMocks.runInteractive.mockReset();
+		worktreeMocks.createTaskWorktree.mockReset();
+		worktreeMocks.createTaskWorktree.mockResolvedValue({
+			success: true,
+			message: "Worktree created",
+			path: "/tmp/cline-worktree",
+			taskId: "task-1",
+			repoRoot: "/tmp/source",
+		});
+		hubRuntimeMocks.ensureCliHubServer.mockReset();
+		hubRuntimeMocks.ensureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463",
+			authToken: "test-token",
+		});
+		llmMocks.resolveProviderConfig.mockReset();
+		llmMocks.resolveProviderConfig.mockResolvedValue(undefined);
+		authMocks.ensureOAuthProviderApiKey.mockReset();
+		authMocks.getPersistedProviderApiKey.mockReset();
+		authMocks.getPersistedProviderApiKey.mockReturnValue(undefined);
+		authMocks.isOAuthProvider.mockReset();
+		authMocks.isOAuthProvider.mockReturnValue(false);
+		authMocks.normalizeProviderId.mockReset();
+		authMocks.normalizeProviderId.mockImplementation(
+			(providerId?: string) => providerId ?? "cline",
+		);
+		authMocks.parseAuthCommandArgs.mockReset();
+		authMocks.runAuthCommand.mockReset();
+		providerSettingsMocks.getLastUsedProviderSettings.mockReset();
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue(
+			undefined,
+		);
+		providerSettingsMocks.getProviderSettings.mockReset();
+		providerSettingsMocks.getProviderSettings.mockReturnValue(undefined);
+		providerSettingsMocks.saveProviderSettings.mockReset();
+		featureFlagMocks.getBooleanFlagEnabled.mockReset();
+		featureFlagMocks.getBooleanFlagEnabled.mockReturnValue(false);
+		featureFlagMocks.setCliFeatureFlagsAccountContext.mockReset();
+		featureFlagMocks.refreshCliFeatureFlagsInBackground.mockReset();
+		kanbanMocks.launchKanban.mockReset();
+		kanbanMocks.launchKanban.mockResolvedValue(0);
+		dashboardMocks.runDashboardCommand.mockReset();
+		dashboardMocks.runDashboardCommand.mockResolvedValue(0);
+		migrationNoticeMocks.getClineCliMigrationNotice.mockReset();
+		migrationNoticeMocks.getClineCliMigrationNotice.mockReturnValue(undefined);
+		migrationNoticeMocks.markClineCliMigrationNoticeShown.mockReset();
+		updateMocks.autoUpdateOnStartup.mockReset();
+		updateMocks.checkForUpdates.mockReset();
+		updateMocks.checkForUpdates.mockResolvedValue(0);
+		updateMocks.getPreferredKanbanInstaller.mockReset();
+		updateMocks.getPreferredKanbanInstaller.mockReturnValue(undefined);
+		telemetryMocks.captureCliExtensionActivated.mockReset();
+		telemetryMocks.identifyTelemetryAccount.mockReset();
+		telemetryMocks.getCliTelemetryService.mockReset();
+		telemetryMocks.disposeCliTelemetryService.mockReset();
+		telemetryMocks.disposeCliTelemetryService.mockResolvedValue(undefined);
+		// CI: fd 0 is often a pipe with no EOF. If routing ever falls through to agent bootstrap,
+		// `main` can block forever in `for await (process.stdin)` (see `!process.stdin.isTTY && …`).
+		// Mark stdin as a TTY so that path is skipped in unit tests (real piped-input behavior is
+		// covered elsewhere). `forcePromptModeInput()` in agent tests still tightens fstat on fd 0.
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: true,
+			configurable: true,
+		});
+	});
+
+	afterEach(() => {
+		process.exitCode = undefined;
+
+		process.argv = [...originalArgv];
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: originalStdinIsTTY,
+			configurable: true,
+		});
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: originalStdoutIsTTY,
+			configurable: true,
+		});
+		vi.restoreAllMocks();
+		vi.resetModules();
+	});
+
+	it("does not load runtime modules for history json listing", async () => {
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+
+		process.argv = ["bun", "src/index.ts", "history", "--json"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(0);
+		expect(historyMocks.runHistoryList).toHaveBeenCalledWith(
+			expect.objectContaining({
+				limit: 50,
+				outputMode: "json",
+			}),
+		);
+		const historyListCalls = historyMocks.runHistoryList.mock
+			.calls as unknown as Array<[Record<string, unknown>]>;
+		expect(historyListCalls[0]?.[0]).not.toHaveProperty("workspaceRoot");
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("does not load runtime modules for root update", async () => {
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+
+		process.argv = ["bun", "src/index.ts", "--update", "--verbose"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(0);
+		expect(updateMocks.checkForUpdates).toHaveBeenCalledWith({
+			verbose: true,
+		});
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("does not load runtime modules for root kanban flag", async () => {
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+
+		process.argv = ["bun", "src/index.ts", "--kanban"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(0);
+		expect(kanbanMocks.launchKanban).toHaveBeenCalledTimes(1);
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("rejects root kanban with a prompt", async () => {
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+
+		process.argv = ["bun", "src/index.ts", "--kanban", "hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(kanbanMocks.launchKanban).not.toHaveBeenCalled();
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("exits gracefully for handled command errors", async () => {
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+
+		process.argv = ["bun", "src/index.ts", "history", "delete"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(0);
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("does not load runtime modules for history export", async () => {
+		mockState.runAgentImports = 0;
+		mockState.runInteractiveImports = 0;
+
+		process.argv = ["bun", "src/index.ts", "history", "export", "sess_1"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(0);
+		expect(historyMocks.runHistoryExport).toHaveBeenCalledWith(
+			"sess_1",
+			undefined,
+			"text",
+			expect.any(Object),
+		);
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("does not load interactive runtime for single-prompt mode", async () => {
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
+		expect(mockState.runAgentImports).toBe(1);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("rejects a single bare positional prompt token", async () => {
+		const consoleError = vi
+			.spyOn(console, "error")
+			.mockImplementation(() => undefined);
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "nonexistent-command"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(consoleError).toHaveBeenCalledWith(
+			expect.stringContaining(
+				"Unknown command or unquoted prompt: nonexistent-command",
+			),
+		);
+		expect(consoleError).toHaveBeenCalledWith(
+			expect.stringContaining('Use "cline --help"'),
+		);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("rejects multiple bare positional prompt tokens", async () => {
+		const consoleError = vi
+			.spyOn(console, "error")
+			.mockImplementation(() => undefined);
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "hello", "world"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(consoleError).toHaveBeenCalledWith(
+			expect.stringContaining(
+				"Unknown command or unquoted prompt: hello world",
+			),
+		);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("runs quoted positional prompt text", async () => {
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "hello world"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"hello world",
+			expect.any(Object),
+			expect.anything(),
+		);
+	});
+
+	it("rejects unknown root flags before loading runtime modules", async () => {
+		const consoleError = vi
+			.spyOn(console, "error")
+			.mockImplementation(() => undefined);
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--made-up-flag"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(consoleError).toHaveBeenCalledWith(
+			expect.stringContaining("unknown option '--made-up-flag'"),
+		);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+	});
+
+	it("creates a worktree and runs prompt sessions from it", async () => {
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--worktree", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(worktreeMocks.createTaskWorktree).toHaveBeenCalledWith({
+			cwd: process.cwd(),
+		});
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				cwd: "/tmp/cline-worktree",
+				workspaceRoot: "/tmp/cline-worktree",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("creates a worktree for default interactive mode", async () => {
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: true,
+			configurable: true,
+		});
+		process.argv = ["bun", "src/index.ts", "--worktree"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(worktreeMocks.createTaskWorktree).toHaveBeenCalledWith({
+			cwd: process.cwd(),
+		});
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.objectContaining({
+				cwd: "/tmp/cline-worktree",
+				workspaceRoot: "/tmp/cline-worktree",
+			}),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				initialPrompt: undefined,
+			}),
+		);
+	});
+
+	it("rejects interactive --worktree when no terminal is attached", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: false,
+			configurable: true,
+		});
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: false,
+			configurable: true,
+		});
+		process.argv = ["bun", "src/index.ts", "--worktree"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(worktreeMocks.createTaskWorktree).not.toHaveBeenCalled();
+	});
+
+	it("allows --worktree with piped stdin", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: false,
+			configurable: true,
+		});
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: false,
+			configurable: true,
+		});
+		vi.mocked(fstatSync).mockReturnValue({
+			isFIFO: () => true,
+			isFile: () => false,
+		} as unknown as ReturnType<typeof fstatSync>);
+		vi.spyOn(process.stdin, Symbol.asyncIterator).mockImplementation(
+			async function* (): AsyncGenerator<Buffer, undefined> {
+				yield Buffer.from("from pipe");
+				return undefined;
+			},
+		);
+		process.argv = ["bun", "src/index.ts", "--worktree"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(worktreeMocks.createTaskWorktree).toHaveBeenCalledWith({
+			cwd: process.cwd(),
+		});
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"from pipe",
+			expect.objectContaining({
+				cwd: "/tmp/cline-worktree",
+				workspaceRoot: "/tmp/cline-worktree",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("validates resumed sessions before creating a worktree", async () => {
+		sessionMocks.getSessionRow.mockResolvedValueOnce(undefined);
+		process.argv = ["bun", "src/index.ts", "--worktree", "--id", "missing"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(sessionMocks.getSessionRow).toHaveBeenCalledWith("missing");
+		expect(worktreeMocks.createTaskWorktree).not.toHaveBeenCalled();
+		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
+	});
+
+	it("does not force chat view for default interactive mode", async () => {
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				initialView: undefined,
+			}),
+		);
+	});
+
+	it("passes the migration notice marker into interactive mode", async () => {
+		const notice = {
+			id: "cline-cli-cline-pass-intro",
+			title: "Try ClinePass",
+		};
+		migrationNoticeMocks.getClineCliMigrationNotice.mockReturnValue(notice);
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: true,
+			configurable: true,
+		});
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				initialNotice: notice,
+				onInitialNoticeShown: expect.any(Function),
+			}),
+		);
+		expect(
+			migrationNoticeMocks.markClineCliMigrationNoticeShown,
+		).not.toHaveBeenCalled();
+		const options = runtimeMocks.runInteractive.mock.calls[0]?.[3];
+		await options?.onInitialNoticeShown?.(notice);
+		expect(
+			migrationNoticeMocks.markClineCliMigrationNoticeShown,
+		).toHaveBeenCalledTimes(1);
+	});
+
+	it("passes the active ClinePass provider into the migration notice gate", async () => {
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue({
+			provider: "cline-pass",
+			model: "cline-pass/test-model",
+		});
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: true,
+			configurable: true,
+		});
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(
+			migrationNoticeMocks.getClineCliMigrationNotice,
+		).toHaveBeenCalledWith(undefined, process.env, {
+			activeProviderId: "cline-pass",
+		});
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "cline-pass",
+			}),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				initialNotice: undefined,
+			}),
+		);
+	});
+
+	it("does not start OAuth before onboarding in interactive mode", async () => {
+		authMocks.isOAuthProvider.mockReturnValue(true);
+		authMocks.normalizeProviderId.mockReturnValue("cline");
+		authMocks.getPersistedProviderApiKey.mockReturnValue(undefined);
+		authMocks.ensureOAuthProviderApiKey.mockClear();
+		process.argv = ["bun", "src/index.ts", "-i"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(authMocks.ensureOAuthProviderApiKey).not.toHaveBeenCalled();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "cline",
+				apiKey: "",
+			}),
+			expect.anything(),
+			undefined,
+			expect.any(Object),
+		);
+	});
+
+	it("loads live catalog models for default interactive model selection", async () => {
+		llmMocks.resolveProviderConfig.mockResolvedValue({
+			knownModels: {
+				"live-only-model": {
+					id: "live-only-model",
+					name: "Live Only Model",
+				},
+			},
+		});
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(llmMocks.resolveProviderConfig).toHaveBeenCalledWith(
+			"cline",
+			{
+				loadLatestOnInit: true,
+				loadPrivateOnAuth: true,
+				failOnError: false,
+			},
+			undefined,
+		);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.objectContaining({
+				knownModels: expect.objectContaining({
+					"live-only-model": expect.objectContaining({
+						name: "Live Only Model",
+					}),
+				}),
+			}),
+			expect.anything(),
+			undefined,
+			expect.any(Object),
+		);
+	});
+
+	it("passes a positional prompt into TUI mode for startup submission", async () => {
+		process.argv = ["bun", "src/index.ts", "sup", "-i"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(llmMocks.resolveProviderConfig).toHaveBeenCalledWith(
+			"cline",
+			{
+				loadLatestOnInit: true,
+				loadPrivateOnAuth: true,
+				failOnError: false,
+			},
+			undefined,
+		);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				initialPrompt: "sup",
+				initialView: undefined,
+			}),
+		);
+	});
+
+	it("uses the bundled catalog path for single-prompt runs", async () => {
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(llmMocks.resolveProviderConfig).toHaveBeenCalledWith(
+			"cline",
+			undefined,
+			undefined,
+		);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
+	});
+
+	it("treats dash-prefixed positional text after -- as a prompt", async () => {
+		forcePromptModeInput();
+		process.argv = [
+			"bun",
+			"src/index.ts",
+			"--",
+			"- You are given a PyTorch state dictionary.",
+		];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"- You are given a PyTorch state dictionary.",
+			expect.any(Object),
+			expect.anything(),
+		);
+		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
+	});
+
+	it("applies --auto-approve as a runtime policy without changing the config default", async () => {
+		process.argv = ["bun", "src/index.ts", "--auto-approve", "false"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.objectContaining({
+				defaultToolAutoApprove: true,
+				toolPolicies: {
+					"*": { autoApprove: false },
+				},
+			}),
+			expect.anything(),
+			undefined,
+			expect.any(Object),
+		);
+	});
+
+	it("forces chat view when resuming a session", async () => {
+		process.argv = ["bun", "src/index.ts", "--id", "sess_123"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			"sess_123",
+			expect.objectContaining({
+				initialView: "chat",
+			}),
+		);
+	});
+
+	it("resumes a history-picked session in a child process", async () => {
+		historyMocks.runHistoryList.mockImplementationOnce(
+			async () => "sess_from_history",
+		);
+		historyResumeMocks.spawnHistoryResume.mockResolvedValueOnce(0);
+		process.argv = ["bun", "src/index.ts", "history"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(historyResumeMocks.spawnHistoryResume).toHaveBeenCalledTimes(1);
+		expect(historyResumeMocks.spawnHistoryResume).toHaveBeenCalledWith(
+			expect.objectContaining({
+				sessionId: "sess_from_history",
+				normalizedArgs: ["history"],
+				remainingArgs: ["history"],
+			}),
+		);
+		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("propagates the child exit code when resuming from history picker", async () => {
+		historyMocks.runHistoryList.mockImplementationOnce(
+			async () => "sess_from_history",
+		);
+		historyResumeMocks.spawnHistoryResume.mockResolvedValueOnce(3);
+		process.argv = ["bun", "src/index.ts", "history"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(3);
+		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
+	});
+
+	it("forces chat view when the history-picker child cannot launch", async () => {
+		historyMocks.runHistoryList.mockImplementationOnce(
+			async () => "sess_from_history",
+		);
+		historyResumeMocks.spawnHistoryResume.mockResolvedValueOnce(undefined);
+		process.argv = ["bun", "src/index.ts", "history"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			"sess_from_history",
+			expect.objectContaining({
+				initialPrompt: undefined,
+				initialView: "chat",
+			}),
+		);
+	});
+
+	it("does not pass non-Cline provider settings as Cline account options", async () => {
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue({
+			provider: "openrouter",
+			baseUrl: "https://openrouter.ai/api/v1",
+			model: "openai/gpt-5",
+		});
+		providerSettingsMocks.getProviderSettings.mockReturnValue({
+			provider: "openrouter",
+			baseUrl: "https://openrouter.ai/api/v1",
+			model: "openai/gpt-5",
+		});
+		authMocks.normalizeProviderId.mockImplementation(
+			(providerId?: string) => providerId ?? "openrouter",
+		);
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				clineApiBaseUrl: undefined,
+				clineProviderSettings: undefined,
+			}),
+		);
+	});
+
+	it("passes Cline provider settings as Cline account options", async () => {
+		const clineSettings = {
+			provider: "cline",
+			baseUrl: "https://api.example.test",
+			model: "anthropic/claude-sonnet-4.6",
+		};
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue(
+			clineSettings,
+		);
+		providerSettingsMocks.getProviderSettings.mockReturnValue(clineSettings);
+		authMocks.normalizeProviderId.mockImplementation(
+			(providerId?: string) => providerId ?? "cline",
+		);
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.anything(),
+			undefined,
+			expect.objectContaining({
+				clineApiBaseUrl: "https://api.example.test",
+				clineProviderSettings: clineSettings,
+			}),
+		);
+	});
+
+	it("seeds feature flag identity from persisted Cline account id before refreshing flags", async () => {
+		const clineSettings = {
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			auth: {
+				accountId: "acct-startup",
+				accessToken: "workos:token",
+				refreshToken: "refresh-token",
+			},
+		};
+		providerSettingsMocks.getProviderSettings.mockReturnValue(clineSettings);
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(
+			featureFlagMocks.setCliFeatureFlagsAccountContext,
+		).toHaveBeenCalledWith({ id: "acct-startup" });
+		// The account identity must be seeded before flags are refreshed/used so
+		// the background refresh resolves flags for the correct account.
+		expect(
+			featureFlagMocks.setCliFeatureFlagsAccountContext.mock
+				.invocationCallOrder[0],
+		).toBeLessThan(
+			featureFlagMocks.refreshCliFeatureFlagsInBackground.mock
+				.invocationCallOrder[0],
+		);
+	});
+
+	it("identifies saved Cline accountId for telemetry before runtime events", async () => {
+		// CLINE-2406: when persisted Cline auth includes an accountId, the
+		// runtime path must call identifyTelemetryAccount(accountContext) so
+		// subsequent task.* and workspace.* events carry user_id.
+		const clineSettings = {
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			auth: { accountId: "usr-abc-123", refreshToken: "rt-token" },
+		};
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue(
+			clineSettings,
+		);
+		providerSettingsMocks.getProviderSettings.mockReturnValue(clineSettings);
+		authMocks.normalizeProviderId.mockImplementation(
+			(providerId?: string) => providerId ?? "cline",
+		);
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(telemetryMocks.identifyTelemetryAccount).toHaveBeenCalledWith(
+			expect.objectContaining({
+				id: "usr-abc-123",
+				provider: "cline",
+			}),
+		);
+	});
+
+	it("does not call identifyTelemetryAccount in runtime path when no saved Cline accountId", async () => {
+		// CLINE-2406: when no persisted accountId is found (anonymous/unauthenticated),
+		// identifyTelemetryAccount should not be called from the runtime path.
+		const clineSettings = {
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			// no auth / no accountId
+		};
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue(
+			clineSettings,
+		);
+		providerSettingsMocks.getProviderSettings.mockReturnValue(clineSettings);
+		authMocks.normalizeProviderId.mockImplementation(
+			(providerId?: string) => providerId ?? "cline",
+		);
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(telemetryMocks.identifyTelemetryAccount).not.toHaveBeenCalled();
+	});
+
+	it("does not call identifyTelemetryAccount from runtime path when provider is not cline", async () => {
+		// CLINE-2406: identity identification from saved settings only applies
+		// to Cline-provider sessions; other providers use different auth flows.
+		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue({
+			provider: "openrouter",
+			model: "openai/gpt-5",
+		});
+		providerSettingsMocks.getProviderSettings.mockReturnValue({
+			provider: "openrouter",
+			model: "openai/gpt-5",
+		});
+		authMocks.normalizeProviderId.mockImplementation(
+			(providerId?: string) => providerId ?? "openrouter",
+		);
+		process.argv = ["bun", "src/index.ts"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(telemetryMocks.identifyTelemetryAccount).not.toHaveBeenCalled();
+	});
+
+	it("runs kanban before loading runtime modules", async () => {
+		process.argv = ["bun", "src/index.ts", "kanban"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(kanbanMocks.launchKanban).toHaveBeenCalledTimes(1);
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("runs dashboard before loading runtime modules", async () => {
+		process.argv = [
+			"bun",
+			"src/index.ts",
+			"dashboard",
+			"--config",
+			"/tmp/cline-config",
+			"--data-dir",
+			".cline-dashboard-data",
+			"--port",
+			"9090",
+			"--no-open",
+		];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(dashboardMocks.runDashboardCommand).toHaveBeenCalledWith(
+			expect.objectContaining({
+				configDir: "/tmp/cline-config",
+				dataDir: ".cline-dashboard-data",
+				port: "9090",
+				openBrowser: false,
+				io: expect.any(Object),
+			}),
+		);
+		expect(mockState.runAgentImports).toBe(0);
+		expect(mockState.runInteractiveImports).toBe(0);
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("prints an install hint when kanban is missing", async () => {
+		const stderrWrite = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+		kanbanMocks.launchKanban.mockImplementation(async () => {
+			process.stderr.write(
+				'kanban is not installed. Install it with "npm i -g kanban"\n',
+			);
+			return 1;
+		});
+		process.argv = ["bun", "src/index.ts", "kanban"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(stderrWrite).toHaveBeenCalledWith(
+			expect.stringContaining(
+				'kanban is not installed. Install it with "npm i -g kanban"',
+			),
+		);
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("skips hub prewarm for yolo runs", async () => {
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--yolo", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
+		expect(hubRuntimeMocks.ensureCliHubServer).not.toHaveBeenCalled();
+	});
+
+	it("rejects yolo runs with a single bare prompt token", async () => {
+		const consoleError = vi
+			.spyOn(console, "error")
+			.mockImplementation(() => undefined);
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--yolo", "hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(consoleError).toHaveBeenCalledWith(
+			expect.stringContaining("Unknown command or unquoted prompt: hello"),
+		);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+		expect(hubRuntimeMocks.ensureCliHubServer).not.toHaveBeenCalled();
+	});
+
+	it("rewrites /team prompts and enables teams in single-prompt mode", async () => {
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "/team find the bug"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			'<user_command slash="team">spawn a team of agents for the following task: find the bug</user_command>',
+			expect.objectContaining({
+				enableAgentTeams: true,
+				teamName: undefined,
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("rejects /team without quoted task text", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+		const consoleError = vi
+			.spyOn(console, "error")
+			.mockImplementation(() => undefined);
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "/team"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(mockState.runAgentCalls).toBe(0);
+		expect(consoleError).toHaveBeenCalledWith(
+			expect.stringContaining("Unknown command or unquoted prompt: /team"),
+		);
+	});
+
+	it("enables thinking when explicit thinking level is provided", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--thinking", "high", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				thinking: true,
+				reasoningEffort: "high",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("leaves thinking unset when --thinking is not provided", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				thinking: undefined,
+				reasoningEffort: undefined,
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("disables thinking when --thinking none is explicitly provided", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--thinking", "none", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				thinking: false,
+				reasoningEffort: undefined,
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("maps --thinking to medium effort", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--thinking", "--", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				compaction: {
+					enabled: true,
+					strategy: "basic",
+				},
+				thinking: true,
+				reasoningEffort: "medium",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("uses persisted reasoning effort when --thinking is not provided", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+		providerSettingsMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			model: "openai/gpt-5",
+			reasoning: { enabled: true, effort: "high" },
+		});
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				thinking: true,
+				reasoningEffort: "high",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("uses persisted disabled reasoning when --thinking is not provided", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+		providerSettingsMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			model: "openai/gpt-5",
+			reasoning: { enabled: false },
+		});
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				thinking: false,
+				reasoningEffort: undefined,
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("prefers explicit --thinking over persisted reasoning effort", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+		providerSettingsMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			model: "openai/gpt-5",
+			reasoning: { enabled: true, effort: "high" },
+		});
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--thinking", "low", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				thinking: true,
+				reasoningEffort: "low",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("enables truncation compaction by default for prompt runs", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				compaction: {
+					enabled: true,
+					strategy: "basic",
+				},
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("supports basic truncation compaction for prompt runs", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = [
+			"bun",
+			"src/index.ts",
+			"--compaction",
+			"basic",
+			"say hello",
+		];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				compaction: {
+					enabled: true,
+					strategy: "basic",
+				},
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("supports agentic compaction for prompt runs", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = [
+			"bun",
+			"src/index.ts",
+			"--compaction",
+			"agentic",
+			"say hello",
+		];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				compaction: {
+					enabled: true,
+					strategy: "agentic",
+				},
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("rejects the removed llm compaction alias", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--compaction", "llm", "hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+	});
+
+	it("rejects the removed truncation compaction alias", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = [
+			"bun",
+			"src/index.ts",
+			"--compaction",
+			"truncation",
+			"hello",
+		];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+	});
+
+	it("supports disabling compaction for prompt runs", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--compaction", "off", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				compaction: {
+					enabled: false,
+				},
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("rejects invalid compaction modes", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+
+		forcePromptModeInput();
+		process.argv = [
+			"bun",
+			"src/index.ts",
+			"--compaction",
+			"aggressive",
+			"hello",
+		];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(process.exitCode).toBe(1);
+		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+	});
+
+	it("does not fail fast for headless json mode with an OAuth provider", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+		authMocks.isOAuthProvider.mockReturnValue(true);
+		authMocks.normalizeProviderId.mockReturnValue("cline");
+		authMocks.getPersistedProviderApiKey.mockReturnValue(undefined);
+		authMocks.ensureOAuthProviderApiKey.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--json", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(authMocks.ensureOAuthProviderApiKey).not.toHaveBeenCalled();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				outputMode: "json",
+				apiKey: "",
+				providerId: "cline",
+			}),
+			expect.anything(),
+		);
+	});
+
+	it("does not fail fast for headless json mode with a non-OAuth provider", async () => {
+		mockState.runAgentCalls = 0;
+		runtimeMocks.runAgent.mockClear();
+		authMocks.isOAuthProvider.mockReturnValue(false);
+		authMocks.normalizeProviderId.mockReturnValue("anthropic");
+		authMocks.getPersistedProviderApiKey.mockReturnValue(undefined);
+		authMocks.ensureOAuthProviderApiKey.mockClear();
+
+		forcePromptModeInput();
+		process.argv = ["bun", "src/index.ts", "--json", "say hello"];
+
+		const { runCli } = await import("./main");
+
+		await expect(runCli()).resolves.toBeUndefined();
+		expect(mockState.runAgentCalls).toBe(1);
+		expect(authMocks.ensureOAuthProviderApiKey).not.toHaveBeenCalled();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
+			"say hello",
+			expect.objectContaining({
+				outputMode: "json",
+				apiKey: "",
+				providerId: "anthropic",
+			}),
+			expect.anything(),
+		);
+	});
+});
+
+describe("stdinHasPipedInput", () => {
+	const originalIsTTY = process.stdin.isTTY;
+
+	afterEach(() => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: originalIsTTY,
+			configurable: true,
+		});
+		vi.mocked(fstatSync).mockRestore();
+	});
+
+	it("returns false when stdin is a TTY", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: true,
+			configurable: true,
+		});
+		const { stdinHasPipedInput } = await import("./main");
+		expect(stdinHasPipedInput()).toBe(false);
+	});
+
+	it("returns true when stdin is a FIFO (pipe)", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: undefined,
+			configurable: true,
+		});
+		vi.mocked(fstatSync).mockReturnValue({
+			isFIFO: () => true,
+			isFile: () => false,
+		} as unknown as ReturnType<typeof fstatSync>);
+		const { stdinHasPipedInput } = await import("./main");
+		expect(stdinHasPipedInput()).toBe(true);
+	});
+
+	it("returns true when stdin is a file", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: undefined,
+			configurable: true,
+		});
+		vi.mocked(fstatSync).mockReturnValue({
+			isFIFO: () => false,
+			isFile: () => true,
+		} as unknown as ReturnType<typeof fstatSync>);
+		const { stdinHasPipedInput } = await import("./main");
+		expect(stdinHasPipedInput()).toBe(true);
+	});
+
+	it("returns false in headless/CI (not TTY, not pipe, not file)", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: undefined,
+			configurable: true,
+		});
+		vi.mocked(fstatSync).mockReturnValue({
+			isFIFO: () => false,
+			isFile: () => false,
+		} as unknown as ReturnType<typeof fstatSync>);
+		const { stdinHasPipedInput } = await import("./main");
+		expect(stdinHasPipedInput()).toBe(false);
+	});
+
+	it("returns false when fstatSync throws", async () => {
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: undefined,
+			configurable: true,
+		});
+		vi.mocked(fstatSync).mockImplementation(() => {
+			throw new Error("EBADF");
+		});
+		const { stdinHasPipedInput } = await import("./main");
+		expect(stdinHasPipedInput()).toBe(false);
+	});
+});
+
+describe("resolveConfigDirArg", () => {
+	it("returns undefined when --config is not present", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(resolveConfigDirArg([])).toBeUndefined();
+		expect(
+			resolveConfigDirArg(["auth", "--provider", "openai"]),
+		).toBeUndefined();
+	});
+
+	it("parses the space-separated form: --config <dir>", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(resolveConfigDirArg(["--config", "./mycfg"])).toBe("./mycfg");
+		expect(
+			resolveConfigDirArg([
+				"auth",
+				"--config",
+				"./mycfg",
+				"--provider",
+				"openai",
+			]),
+		).toBe("./mycfg");
+	});
+
+	it("parses the equals form: --config=<dir>", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(resolveConfigDirArg(["--config=./mycfg"])).toBe("./mycfg");
+		expect(
+			resolveConfigDirArg(["auth", "--config=./mycfg", "--provider", "openai"]),
+		).toBe("./mycfg");
+	});
+
+	it("trims surrounding whitespace from the value", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(resolveConfigDirArg(["--config", "  ./mycfg  "])).toBe("./mycfg");
+		expect(resolveConfigDirArg(["--config=  ./mycfg  "])).toBe("./mycfg");
+	});
+
+	it("returns undefined for empty or whitespace-only values", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(resolveConfigDirArg(["--config", ""])).toBeUndefined();
+		expect(resolveConfigDirArg(["--config", "   "])).toBeUndefined();
+		expect(resolveConfigDirArg(["--config="])).toBeUndefined();
+		expect(resolveConfigDirArg(["--config=   "])).toBeUndefined();
+	});
+
+	it("returns undefined when --config has no following value (space form)", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(resolveConfigDirArg(["--config"])).toBeUndefined();
+	});
+
+	it("returns the first occurrence when --config appears multiple times", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		expect(
+			resolveConfigDirArg(["--config", "./first", "--config", "./second"]),
+		).toBe("./first");
+		expect(resolveConfigDirArg(["--config=./first", "--config=./second"])).toBe(
+			"./first",
+		);
+	});
+
+	it("does not match unrelated flags that share a prefix", async () => {
+		const { resolveConfigDirArg } = await import("./main");
+		// e.g. a hypothetical --configure flag must not be picked up.
+		expect(resolveConfigDirArg(["--configure", "./foo"])).toBeUndefined();
+		expect(resolveConfigDirArg(["--configure=./foo"])).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/main.ts b/apps/cli/src/main.ts
new file mode 100644
index 0000000..9a48f3f
--- /dev/null
+++ b/apps/cli/src/main.ts
@@ -0,0 +1,1263 @@
+import { fstatSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename } from "node:path";
+import type { ToolPolicy } from "@cline/core";
+
+import { registerDisposable } from "@cline/shared";
+import type { Command } from "commander";
+import {
+	CommanderError,
+	commanderToParsedArgs,
+	createProgram,
+} from "./commands/program";
+import {
+	autoUpdateOnStartup,
+	getPreferredKanbanInstaller,
+} from "./commands/update";
+import { CLI_DEFAULT_CHECKPOINT_CONFIG } from "./runtime/defaults";
+import { getCliBuildInfo } from "./utils/common";
+import {
+	buildCliCompactionConfig,
+	CLI_COMPACTION_MODE_EXPECTED_TEXT,
+} from "./utils/compaction-mode";
+import {
+	refreshCliFeatureFlagsInBackground,
+	setCliFeatureFlagsAccountContext,
+} from "./utils/feature-flags";
+import {
+	configureSandboxEnvironment,
+	normalizeAutoApproveArgs,
+	resolveWorkspaceRoot,
+} from "./utils/helpers";
+import {
+	c,
+	installStreamErrorGuards,
+	setCurrentOutputMode,
+	writeErr,
+	writeln,
+} from "./utils/output";
+import {
+	ensureOAuthProviderApiKey,
+	getPersistedProviderApiKey,
+	isOAuthProvider,
+	normalizeProviderId,
+} from "./utils/provider-auth";
+import { resolveCliReasoning } from "./utils/reasoning";
+import { rewriteTeamPrompt, TEAM_COMMAND_USAGE } from "./utils/team-command";
+import {
+	captureCliExtensionActivated,
+	getCliTelemetryService,
+	identifyTelemetryAccount,
+} from "./utils/telemetry";
+import type { Config } from "./utils/types";
+import { runConnectWizard } from "./wizards/connect";
+import { runMcpWizard } from "./wizards/mcp";
+import { runScheduleWizard } from "./wizards/schedule";
+
+export function stdinHasPipedInput(): boolean {
+	if (process.stdin.isTTY) return false;
+	try {
+		const stats = fstatSync(0);
+		return stats.isFIFO() || stats.isFile();
+	} catch {
+		return false;
+	}
+}
+
+async function createProviderSettingsManager() {
+	const { ProviderSettingsManager } = await import("@cline/core");
+	return new ProviderSettingsManager();
+}
+
+async function loadCliRuntimeModules() {
+	const [coreServer, prompt, runAgentModule] = await Promise.all([
+		import("@cline/core"),
+		import("./runtime/prompt"),
+		import("./runtime/run-agent"),
+	]);
+	return {
+		coreServer,
+		resolveSystemPrompt: prompt.resolveSystemPrompt,
+		runAgent: runAgentModule.runAgent,
+	};
+}
+
+async function loadInteractiveRuntimeModule() {
+	const { runInteractive } = await import("./runtime/run-interactive");
+	return runInteractive;
+}
+
+/**
+ * Two-pass approach for --config: a quick scan of process.argv extracts the
+ * config directory before commander parses, because setClineDir() must run
+ * before any code that reads the home/config directory.
+ *
+ * Recognizes both Commander spellings:
+ *   --config <dir>
+ *   --config=<dir>
+ *
+ * Exported for unit testing; callers in this file should use this rather
+ * than reimplementing the scan.
+ */
+export function resolveConfigDirArg(argv: string[]): string | undefined {
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--config") {
+			const value = argv[i + 1]?.trim();
+			return value ? value : undefined;
+		}
+		if (arg?.startsWith("--config=")) {
+			const value = arg.slice("--config=".length).trim();
+			return value ? value : undefined;
+		}
+	}
+	return undefined;
+}
+
+function collectOption(value: string, previous: string[] = []): string[] {
+	return [...previous, value];
+}
+
+// Shells strip quote characters before argv reaches us, so a prompt that was
+// typed in quotes is only observable when it remains one argv token with spaces.
+function promptArgLooksQuoted(arg: string | undefined): boolean {
+	return !!arg && /\s/.test(arg);
+}
+
+function writePromptArgError(args: string[]): void {
+	const renderedArgs = args.join(" ");
+	writeErr(
+		`Unknown command or unquoted prompt: ${renderedArgs}\nPrompt text must be passed as a single quoted argument, for example: cline "fix the tests". Use "cline --help" to see available commands and flags.`,
+	);
+}
+
+export async function runCli(): Promise<void> {
+	installStreamErrorGuards();
+	autoUpdateOnStartup();
+
+	const cliArgs = process.argv.slice(2);
+	const configDir = resolveConfigDirArg(cliArgs);
+	const { setClineDir, setHomeDir } = await import("@cline/shared/storage");
+	if (configDir) {
+		setClineDir(configDir);
+	}
+	setHomeDir(homedir());
+
+	// Capture activation telemetry only after config/home directory selection
+	// has been applied, so the telemetry singleton's persisted distinct-id
+	// (and any other storage it touches) lands under the user-selected
+	// `--config <dir>` rather than the default home/config location.
+	captureCliExtensionActivated();
+
+	let launchConfigView = false;
+	const normalizedArgs = normalizeAutoApproveArgs(cliArgs);
+
+	// Subcommand routing via Commander
+	const ctx: { exitCode?: number; resumeSessionId?: string } = {};
+	const io = { writeln, writeErr };
+	const program = createProgram();
+	// Re-enable built-in help/version output for the routing program
+	program.configureOutput({
+		writeOut: (str: string) => process.stdout.write(str),
+		writeErr: () => {},
+	});
+	// Default action handles non-subcommand args (e.g. prompt text)
+	program.action(() => {});
+
+	// Auth subcommand: defines its own options so commander parses them
+	// directly. The short flags -p/-m intentionally shadow the root's -p (plan)
+	// and -m (model); commander scopes options per-command so there is no
+	// conflict.
+	const authCmd = program
+		.command("auth")
+		.description("Authenticate a provider and configure what model is used")
+		.argument("[provider]", "Provider id (positional shorthand for -p)")
+		.option("-p, --provider <id>", "Provider ID")
+		.option("-k, --apikey <key>", "API key")
+		.option("-m, --modelid <id>", "Model ID")
+		.option("-b, --baseurl <url>", "Base URL")
+		.option("--azure-api-version <version>", "Azure API version")
+		.option("--config <dir>", "configuration directory")
+		.option("-c, --cwd <path>", "Working directory")
+		.option(
+			"--data-dir <dir>",
+			"Use isolated local state at <dir> instead of ~/.cline (enables sandbox mode)",
+		)
+		.option("-v, --verbose", "Show verbose output")
+		.action(async (positionalProvider: string | undefined) => {
+			const opts = authCmd.opts<{
+				provider?: string;
+				apikey?: string;
+				modelid?: string;
+				baseurl?: string;
+				azureApiVersion?: string;
+				config?: string;
+				cwd?: string;
+				dataDir?: string;
+				verbose?: boolean;
+			}>();
+			// Honor --config inside the action as a defense-in-depth measure.
+			// The early pre-pass in runCli() also calls setClineDir(), but only
+			// for argv tokens it can spot before commander runs. Reapplying
+			// here ensures opts.config (parsed by commander, including the
+			// --config=<dir> form) is always respected before any provider
+			// settings manager is constructed against ~/.cline.
+			if (opts.config?.trim()) {
+				const { setClineDir } = await import("@cline/shared/storage");
+				setClineDir(opts.config.trim());
+			}
+			// Honor --data-dir before constructing the provider settings manager
+			// so writes land under the chosen data dir instead of ~/.cline.
+			configureSandboxEnvironment({
+				enabled: !!opts.dataDir || process.env.CLINE_SANDBOX?.trim() === "1",
+				cwd: opts.cwd ?? process.cwd(),
+				explicitDir: opts.dataDir,
+			});
+			const { runAuthCommand } = await import("./commands/auth");
+			const providerSettingsManager = await createProviderSettingsManager();
+			ctx.exitCode = await runAuthCommand({
+				providerSettingsManager,
+				explicitProvider: opts.provider ?? positionalProvider,
+				apikey: opts.apikey,
+				modelid: opts.modelid,
+				baseurl: opts.baseurl,
+				azureApiVersion: opts.azureApiVersion,
+				io,
+			});
+		});
+
+	const createConfigRuntimeCommand = async () => {
+		const { createConfigCommand } = await import("./commands/config");
+		let configCmd: Command;
+		configCmd = createConfigCommand(
+			() => resolveWorkspaceRoot(program.opts().cwd ?? process.cwd()),
+			() => {
+				const outputMode =
+					program.opts().json || configCmd.opts().json
+						? ("json" as const)
+						: ("text" as const);
+				setCurrentOutputMode(outputMode);
+				return outputMode;
+			},
+			io,
+			(code) => {
+				ctx.exitCode = code;
+			},
+			() => {
+				launchConfigView = true;
+			},
+		);
+		return configCmd;
+	};
+
+	program
+		.command("config")
+		.description("Show current configuration")
+		.option("--json", "Output as JSON")
+		.option("--config <dir>", "configuration directory")
+		.allowUnknownOption()
+		.allowExcessArguments()
+		.passThroughOptions()
+		.action(async (_opts: unknown, cmd: Command) => {
+			const realCmd = await createConfigRuntimeCommand();
+			await realCmd.parseAsync(cmd.args, { from: "user" });
+		});
+
+	const pluginCmd = program
+		.command("plugin")
+		.description("Manage Cline Plugins")
+		.action(() => {
+			pluginCmd.help();
+		});
+	const pluginInstallCmd = pluginCmd
+		.command("install")
+		.alias("i")
+		.description(
+			"Install a Cline Plugin from an official keyword, npm, git, URL, or a local path",
+		)
+		.argument(
+			"<source>",
+			"official keyword, npm package, git URL, plugin file URL, or local plugin path",
+		)
+		.option("--npm", "Treat source as an npm package")
+		.option("--git", "Treat source as a git repository")
+		.option("--force", "Replace an existing install for the same source")
+		.option("--json", "Output as JSON")
+		.option("--cwd <path>", "Install to <path>/.cline/plugins")
+		.action(async (source: string) => {
+			const opts = pluginInstallCmd.opts<{
+				npm?: boolean;
+				git?: boolean;
+				force?: boolean;
+				json?: boolean;
+				cwd?: string;
+			}>();
+			const sourceTypes = [
+				opts.npm ? ("npm" as const) : undefined,
+				opts.git ? ("git" as const) : undefined,
+			].filter((sourceType) => sourceType !== undefined);
+			if (sourceTypes.length > 1) {
+				writeErr("plugin install accepts only one source type flag");
+				ctx.exitCode = 1;
+				return;
+			}
+			const { runPluginInstallCommand } = await import("./commands/plugin");
+			ctx.exitCode = await runPluginInstallCommand({
+				source,
+				sourceType: sourceTypes[0],
+				cwd: opts.cwd,
+				force: opts.force === true,
+				json: opts.json === true || program.opts().json === true,
+				io,
+			});
+		});
+	const pluginUninstallCmd = pluginCmd
+		.command("uninstall")
+		.alias("remove")
+		.alias("rm")
+		.description("Uninstall a Cline Plugin by name or path")
+		.argument("<name>", "plugin package name, installed slug, or plugin path")
+		.option("--json", "Output as JSON")
+		.option(
+			"--cwd <path>",
+			"Search <path>/.cline/plugins before global plugins",
+		)
+		.action(async (name: string) => {
+			const opts = pluginUninstallCmd.opts<{
+				json?: boolean;
+				cwd?: string;
+			}>();
+			const { runPluginUninstallCommand } = await import("./commands/plugin");
+			ctx.exitCode = await runPluginUninstallCommand({
+				name,
+				cwd: opts.cwd,
+				json: opts.json === true || program.opts().json === true,
+				io,
+			});
+		});
+	const skillCmd = program
+		.command("skill")
+		.description("Manage Cline Skills via the open skills CLI (npx skills)")
+		.allowUnknownOption()
+		.passThroughOptions()
+		.argument("[args...]", "arguments forwarded to the skills CLI")
+		.addHelpText(
+			"after",
+			"\nForwards to the open skills CLI via npx. Examples:\n" +
+				"  cline skill add <owner/repo>       Add a skill into Cline\n" +
+				"  cline skill install <owner/repo>   Alias for add\n" +
+				"  cline skill list                   List installed skills\n" +
+				"  cline skill remove                 Remove installed skills\n" +
+				"  cline skill uninstall              Alias for remove\n" +
+				"\nadd/install and remove/uninstall default to '--agent cline' unless you pass your own --agent.\n" +
+				"Run 'npx skills --help' for the full command reference.",
+		)
+		.action(async () => {
+			const { runSkillCommand } = await import("./commands/skill");
+			ctx.exitCode = await runSkillCommand(skillCmd.args, io);
+		});
+
+	const connectCmd = program
+		.command("connect")
+		.description("Connect to an external channel")
+		.argument("[channel]", "Channel to connect Cline CLI to")
+		.option("--stop", "Kill all current channel connections")
+		.allowUnknownOption()
+		.passThroughOptions()
+		.addHelpText(
+			"after",
+			"\nRun 'connect <channel> --help' for channel-specific options.",
+		)
+		.action(async (adapter: string | undefined) => {
+			const {
+				formatAdapterList,
+				runConnectAdapter,
+				runStopAllConnectors,
+				runStopConnector,
+			} = await import("./commands/connect");
+			const opts = connectCmd.opts();
+			if (opts.stop) {
+				if (adapter) {
+					ctx.exitCode = await runStopConnector(adapter, io);
+				} else {
+					ctx.exitCode = await runStopAllConnectors(io);
+				}
+			} else if (adapter) {
+				// connectCmd.args = [adapter, ...passthroughFlags]. Pass only the
+				// connector-specific flags (everything after the adapter name).
+				ctx.exitCode = await runConnectAdapter(
+					adapter,
+					connectCmd.args.slice(1),
+					io,
+				);
+			} else if (process.stdin.isTTY && process.stdout.isTTY) {
+				ctx.exitCode = await runConnectWizard();
+			} else {
+				writeln(`\nAdapters:\n${formatAdapterList()}`);
+				connectCmd.help();
+			}
+		});
+
+	const mcpCmd = program
+		.command("mcp")
+		.description("Manage MCP servers")
+		.action(async () => {
+			if (process.stdin.isTTY && process.stdout.isTTY) {
+				ctx.exitCode = await runMcpWizard();
+			} else {
+				writeln(
+					"MCP wizard requires a TTY. Use cline config mcp to list servers.",
+				);
+			}
+		});
+	const mcpInstallCmd = mcpCmd
+		.command("install")
+		.alias("add")
+		.description("Open the MCP add wizard with server fields prefilled")
+		.argument("<name>", "MCP server name")
+		.argument(
+			"[targetArgs...]",
+			"URL for remote transports, or command and args after -- for stdio",
+		)
+		.option(
+			"--transport <transport>",
+			"stdio, sse, http, streamable-http, or streamableHttp (default: stdio)",
+		)
+		.option("--header <header>", "Remote MCP request header", collectOption, [])
+		.option("--yes", "Install noninteractively without opening the wizard")
+		.option("--json", "Output as JSON")
+		.action(async (name: string, targetArgs: string[]) => {
+			const opts = mcpInstallCmd.opts<{
+				header?: string[];
+				json?: boolean;
+				transport?: string;
+				yes?: boolean;
+			}>();
+			const { runMcpInstallCommand } = await import("./commands/mcp");
+			ctx.exitCode = await runMcpInstallCommand({
+				name,
+				headers: opts.header,
+				targetArgs,
+				transport: opts.transport,
+				json: opts.json === true || program.opts().json === true,
+				yes: opts.yes === true,
+				io,
+			});
+		});
+
+	const createDoctorRuntimeCommand = async () => {
+		const { createDoctorCommand } = await import("./commands/doctor");
+		return createDoctorCommand(io, (code) => {
+			ctx.exitCode = code;
+		});
+	};
+
+	program
+		.command("doctor")
+		.description("Diagnose and fix configuration issues")
+		.allowUnknownOption()
+		.allowExcessArguments()
+		.passThroughOptions()
+		.addHelpText(
+			"after",
+			"\nCommands:\n  fix  Kill all running processes\n  log  Open the CLI log file\n",
+		)
+		.action(async (_opts: unknown, cmd: Command) => {
+			const doctorCmd = await createDoctorRuntimeCommand();
+			await doctorCmd.parseAsync(cmd.args, { from: "user" });
+		});
+
+	const historyCmd = program
+		.command("history")
+		.alias("h")
+		.description("List session history or manage saved sessions")
+		.option("--json", "Output as JSON")
+		.option("--limit <count>", "Maximum number of sessions to show", "50")
+		.option("--page <number>", "Page number for paginated results")
+		.option("--config <dir>", "configuration directory")
+		.action(async () => {
+			const opts = historyCmd.opts();
+			const limit = Number.parseInt(opts.limit, 10);
+			const outputMode =
+				program.opts().json || opts.json
+					? ("json" as const)
+					: ("text" as const);
+			const { runHistoryList } = await import("./commands/history");
+			const result = await runHistoryList({
+				limit,
+				outputMode,
+				io,
+			});
+			if (typeof result === "string") {
+				ctx.resumeSessionId = result;
+				// JSON listing should never return a session id; if it does, still exit here so
+				// we never fall through to agent bootstrap (which can block on stdin in CI).
+				if (outputMode === "json") {
+					ctx.exitCode = 0;
+				}
+			} else {
+				// Always set exit code for numeric results so `ctx.exitCode` is never left
+				// undefined (that would fall through and load the full CLI runtime).
+				ctx.exitCode = result ?? 0;
+			}
+		});
+
+	const historyDeleteCmd = historyCmd
+		.command("delete")
+		.description("Delete a session from history")
+		.option("--session-id <id>", "Session ID to delete")
+		.action(async () => {
+			const opts = historyDeleteCmd.opts();
+			if (!opts.sessionId) {
+				writeErr("history delete requires --session-id <id>");
+				ctx.exitCode = 0;
+				return;
+			}
+			const outputMode =
+				program.opts().json || historyCmd.opts().json
+					? ("json" as const)
+					: ("text" as const);
+			const { runHistoryDelete } = await import("./commands/history");
+			ctx.exitCode = await runHistoryDelete(opts.sessionId, outputMode, io);
+		});
+
+	const historyUpdateCmd = historyCmd
+		.command("update")
+		.description("Update a session in history")
+		.option("--metadata <json>", "Metadata as JSON string")
+		.option("--prompt <text>", "New prompt text")
+		.option("--session-id <id>", "Session ID to update")
+		.option("--title <text>", "New title")
+		.action(async () => {
+			const opts = historyUpdateCmd.opts();
+			if (!opts.sessionId) {
+				writeErr("history update requires --session-id <id>");
+				ctx.exitCode = 1;
+				return;
+			}
+			const outputMode =
+				program.opts().json || historyCmd.opts().json
+					? ("json" as const)
+					: ("text" as const);
+			const { runHistoryUpdate } = await import("./commands/history");
+			ctx.exitCode = await runHistoryUpdate(
+				opts.sessionId,
+				opts.prompt,
+				opts.title,
+				opts.metadata,
+				outputMode,
+				io,
+			);
+		});
+
+	const historyExportCmd = historyCmd
+		.command("export <sessionId>")
+		.description("Export a session as a standalone HTML file")
+		.option("-o, --output <path>", "Output HTML file path")
+		.action(async (sessionId: string) => {
+			const opts = historyExportCmd.opts();
+			const outputMode =
+				program.opts().json || historyCmd.opts().json
+					? ("json" as const)
+					: ("text" as const);
+			const { runHistoryExport } = await import("./commands/history");
+			ctx.exitCode = await runHistoryExport(
+				sessionId,
+				opts.output,
+				outputMode,
+				io,
+			);
+		});
+
+	program
+		.command("hook")
+		.description("Handle a hook payload from stdin")
+		.allowUnknownOption()
+		.allowExcessArguments()
+		.action(async () => {
+			const { runHookCommand } = await import("./commands/hook");
+			ctx.exitCode = await runHookCommand(io);
+		});
+
+	const createScheduleRuntimeCommand = async () => {
+		const { createScheduleCommand } = await import("./commands/schedule");
+		return createScheduleCommand(io, (code) => {
+			ctx.exitCode = code;
+		});
+	};
+	const createHubRuntimeCommand = async () => {
+		const { createHubCommand } = await import("./commands/hub");
+		return createHubCommand(io, (code) => {
+			ctx.exitCode = code;
+		});
+	};
+
+	program
+		.command("schedule")
+		.description("Manage scheduled tasks")
+		.allowUnknownOption()
+		.allowExcessArguments()
+		.passThroughOptions()
+		.action(async (_opts: unknown, cmd: Command) => {
+			if (
+				cmd.args.length === 0 &&
+				process.stdin.isTTY &&
+				process.stdout.isTTY
+			) {
+				ctx.exitCode = await runScheduleWizard();
+				return;
+			}
+			const scheduleCmd = await createScheduleRuntimeCommand();
+			await scheduleCmd.parseAsync(cmd.args, { from: "user" });
+		});
+	program
+		.command("hub")
+		.description("Manage the local hub daemon")
+		.allowUnknownOption()
+		.allowExcessArguments()
+		.passThroughOptions()
+		.action(async (_opts: unknown, cmd: Command) => {
+			const hubCmd = await createHubRuntimeCommand();
+			await hubCmd.parseAsync(cmd.args, { from: "user" });
+		});
+
+	const dashboardCmd = program
+		.command("dashboard")
+		.description("Start the Cline Hub dashboard and open it in a browser")
+		.option("--config <dir>", "configuration directory")
+		.option("-c, --cwd <path>", "Workspace root", process.cwd())
+		.option(
+			"--data-dir <dir>",
+			"Use isolated local state at <dir> instead of ~/.cline (enables sandbox mode)",
+		)
+		.option("--host <host>", "Dashboard bind host")
+		.option("--port <port>", "Dashboard HTTP/WebSocket port")
+		.option("--public-url <url>", "Public dashboard URL")
+		.option("--room-secret <secret>", "Invite secret for browser access")
+		.option("--no-open", "Start the dashboard without opening a browser")
+		.action(async () => {
+			const opts = dashboardCmd.opts<{
+				config?: string;
+				cwd?: string;
+				dataDir?: string;
+				host?: string;
+				port?: string;
+				publicUrl?: string;
+				roomSecret?: string;
+				open?: boolean;
+			}>();
+			const { runDashboardCommand } = await import("./commands/dashboard");
+			ctx.exitCode = await runDashboardCommand({
+				configDir: opts.config,
+				cwd: opts.cwd,
+				dataDir: opts.dataDir,
+				host: opts.host,
+				port: opts.port,
+				publicUrl: opts.publicUrl,
+				roomSecret: opts.roomSecret,
+				openBrowser: opts.open !== false,
+				io,
+			});
+		});
+
+	const updateCmd = program
+		.command("update")
+		.description("Check for updates and install if available")
+		.allowUnknownOption()
+		.allowExcessArguments()
+		.option("-v, --verbose", "Show verbose output")
+		.option("--config <dir>", "configuration directory")
+		.action(async () => {
+			const { checkForUpdates } = await import("./commands/update");
+			ctx.exitCode = await checkForUpdates({
+				verbose: updateCmd.opts().verbose === true,
+			});
+		});
+
+	program
+		.command("version")
+		.description("Show Cline CLI version number")
+		.action(async () => {
+			const { showVersion } = await import("./commands/help");
+			showVersion();
+			ctx.exitCode = 0;
+		});
+
+	program
+		.command("kanban")
+		.description("Run the kanban app")
+		.action(async () => {
+			const { launchKanban } = await import("./commands/kanban");
+			ctx.exitCode = await launchKanban({
+				preferredInstaller: getPreferredKanbanInstaller(),
+			});
+		});
+
+	try {
+		await program.parseAsync(normalizedArgs, { from: "user" });
+	} catch (err: unknown) {
+		if (err instanceof CommanderError) {
+			if (err.exitCode !== 0) {
+				writeErr(err.message);
+				process.exitCode = err.exitCode;
+				return;
+			}
+			return;
+		}
+		throw err;
+	}
+
+	if (ctx.exitCode !== undefined) {
+		process.exitCode = ctx.exitCode;
+		return;
+	}
+
+	const rootOpts = program.opts<{
+		kanban?: boolean;
+		tui?: boolean;
+		update?: boolean;
+		verbose?: boolean;
+	}>();
+	if (rootOpts.update) {
+		if (rootOpts.kanban || rootOpts.tui || program.args.length > 0) {
+			writeErr("Use --update without a prompt or task flags.");
+			process.exitCode = 1;
+			return;
+		}
+		const { checkForUpdates } = await import("./commands/update");
+		process.exitCode = await checkForUpdates({
+			verbose: rootOpts.verbose === true,
+		});
+		return;
+	}
+	if (rootOpts.kanban) {
+		if (rootOpts.tui) {
+			writeErr("Use either --kanban or --tui, not both.");
+			process.exitCode = 1;
+			return;
+		}
+		if (program.args.length > 0) {
+			writeErr("Use --kanban without a prompt.");
+			process.exitCode = 1;
+			return;
+		}
+		const { launchKanban } = await import("./commands/kanban");
+		process.exitCode = await launchKanban({
+			preferredInstaller: getPreferredKanbanInstaller(),
+		});
+		return;
+	}
+
+	// Default flow: no subcommand matched, or fall-through from config/history.
+	let args = commanderToParsedArgs(program);
+
+	let resumeSessionId: string | undefined = ctx.resumeSessionId;
+	if (resumeSessionId) {
+		// The history picker already created (and tore down) an OpenTUI renderer
+		// in this process; starting the interactive TUI here would create a
+		// second one, which can crash natively during teardown. Resume in a
+		// fresh `cline --id <session-id>` child process instead.
+		const { spawnHistoryResume } = await import("./utils/history-resume");
+		const childExitCode = await spawnHistoryResume({
+			sessionId: resumeSessionId,
+			normalizedArgs,
+			remainingArgs: program.args,
+			configDir,
+		});
+		if (childExitCode !== undefined) {
+			process.exitCode = childExitCode;
+			return;
+		}
+		args = {
+			...args,
+			interactive: true,
+			prompt: undefined,
+		};
+	}
+
+	if (args.id !== undefined) {
+		const sessionId = args.id.trim();
+		if (!sessionId) {
+			writeErr("--id requires <session-id>");
+			process.exitCode = 1;
+			return;
+		}
+		resumeSessionId = sessionId;
+		process.env.CLINE_HOOK_AGENT_RESUME = "1";
+		args = {
+			...args,
+			interactive: true,
+			prompt: undefined,
+		};
+	} else {
+		delete process.env.CLINE_HOOK_AGENT_RESUME;
+	}
+	if (launchConfigView) {
+		args = {
+			...args,
+			interactive: true,
+			prompt: undefined,
+		};
+	}
+
+	if (args.invalidThinkingLevel) {
+		writeErr(
+			`invalid thinking level "${args.invalidThinkingLevel}" (expected "none", "low", "medium", "high", or "xhigh")`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+	if (args.invalidCompactionMode) {
+		writeErr(
+			`invalid compaction mode "${args.invalidCompactionMode}" (expected ${CLI_COMPACTION_MODE_EXPECTED_TEXT})`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+	if (args.invalidAutoApprove) {
+		writeErr(
+			`invalid auto-approve value "${args.invalidAutoApprove}" (expected "true" or "false")`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+	if (args.invalidTimeoutSeconds) {
+		writeErr(
+			`invalid timeout "${args.invalidTimeoutSeconds}" (expected integer >= 1)`,
+		);
+		process.exitCode = 1;
+		return;
+	}
+	if (args.invalidRetries) {
+		writeln(
+			`${c.dim}[warn] ignoring invalid --retries value "${args.invalidRetries}" (expected integer >= 1)${c.reset}`,
+		);
+	}
+	if (args.hooksDir?.trim()) {
+		process.env.CLINE_HOOKS_DIR = args.hooksDir.trim();
+	}
+	if (args.prompt && !args.interactive) {
+		if (program.args.length > 1 || !promptArgLooksQuoted(program.args[0])) {
+			writePromptArgError(program.args);
+			process.exitCode = 1;
+			return;
+		}
+	}
+	setCurrentOutputMode(args.outputMode);
+	const defaultToolAutoApprove = true;
+	const effectiveToolAutoApprove =
+		args.autoApproveOverride ?? defaultToolAutoApprove;
+	const toolPolicies: Record<string, ToolPolicy> = {
+		"*": {
+			autoApprove: effectiveToolAutoApprove,
+		},
+	};
+
+	if (args.outputMode === "json" && (args.interactive || !args.prompt)) {
+		writeErr(
+			"JSON output mode requires a prompt argument or piped stdin (interactive mode is unsupported)",
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	// ACP mode: mutually exclusive with interactive/piped modes.
+	// Enters the Agent Client Protocol stdio transport and never falls through.
+	if (args.acpMode) {
+		const { runAcpMode } = await import("./acp/index");
+		await runAcpMode();
+		return;
+	}
+
+	if (args.worktree) {
+		if (
+			!args.prompt &&
+			!resumeSessionId &&
+			!stdinHasPipedInput() &&
+			(!process.stdin.isTTY || !process.stdout.isTTY)
+		) {
+			writeErr("--worktree without a prompt requires an interactive terminal.");
+			process.exitCode = 1;
+			return;
+		}
+		if (resumeSessionId) {
+			const { getSessionRow } = await import("./session/session");
+			const session = await getSessionRow(resumeSessionId);
+			if (!session) {
+				writeErr(`Session not found: ${resumeSessionId}`);
+				process.exitCode = 1;
+				return;
+			}
+		}
+		const { createTaskWorktree } = await import("./utils/worktree");
+		const sourceCwd = args.cwd ?? process.cwd();
+		const result = await createTaskWorktree({ cwd: sourceCwd });
+		if (!result.success || !result.path) {
+			writeErr(`--worktree failed: ${result.message}`);
+			process.exitCode = 1;
+			return;
+		}
+		writeln(`Created worktree at ${result.path}`);
+		args = {
+			...args,
+			cwd: result.path,
+		};
+	}
+
+	const cwd = args.cwd ?? process.cwd();
+	const workspaceRoot = resolveWorkspaceRoot(cwd);
+	// Sandbox mode is enabled implicitly whenever --data-dir is provided, or
+	// when CLINE_SANDBOX=1 is set in the environment (in which case the data
+	// dir falls back to $CLINE_SANDBOX_DATA_DIR or /tmp/cline-sandbox).
+	const sandboxEnabled =
+		!!args.dataDir || process.env.CLINE_SANDBOX?.trim() === "1";
+	const sandboxDataDir = configureSandboxEnvironment({
+		enabled: sandboxEnabled,
+		cwd,
+		explicitDir: args.dataDir,
+	});
+
+	// Keep command-style subcommands on a narrow path. Runtime-only imports pull
+	// in provider resolution, config services, and session startup wiring that
+	// should only load when the CLI is actually starting an agent session.
+	const providerSettingsManager = await createProviderSettingsManager();
+	const {
+		coreServer,
+		coreServer: { createUserInstructionConfigService },
+		resolveSystemPrompt,
+		runAgent,
+		} = await loadCliRuntimeModules();
+
+	// Register the SDK early logger as early as possible — before any
+	// provider settings reads — so the full startup sequence is captured.
+	// These components operate before/outside ClineCore sessions, so the
+	// session-scoped logger can't reach them.
+	const { createCliLoggerAdapter } = await import("./logging/adapter");
+	const loggerAdapter = createCliLoggerAdapter({
+		runtime: "cli",
+		component: "main",
+	});
+	coreServer.setSdkLogger(loggerAdapter.core);
+
+	const userInstructionService = createUserInstructionConfigService({
+		skills: {
+			workspacePath: workspaceRoot,
+			includePluginSkills: true,
+			cwd,
+		},
+		rules: { workspacePath: workspaceRoot },
+		workflows: { workspacePath: workspaceRoot },
+	});
+	await userInstructionService.start().catch(() => {});
+	let userInstructionServiceDisposed = false;
+	const stopUserInstructionService = () => {
+		if (userInstructionServiceDisposed) {
+			return;
+		}
+		userInstructionServiceDisposed = true;
+		userInstructionService.stop();
+	};
+	registerDisposable(stopUserInstructionService);
+	try {
+		const persistedClineAccountId = providerSettingsManager
+			.getProviderSettings("cline")
+			?.auth?.accountId?.trim();
+		if (persistedClineAccountId) {
+			setCliFeatureFlagsAccountContext({ id: persistedClineAccountId });
+		}
+		refreshCliFeatureFlagsInBackground();
+		const lastUsedProviderSettings =
+			providerSettingsManager.getLastUsedProviderSettings({
+				isClinePassEnabled: true,
+			});
+		const provider = normalizeProviderId(
+			args.provider?.trim() || lastUsedProviderSettings?.provider || "cline",
+		);
+		let selectedProviderSettings =
+			providerSettingsManager.getProviderSettings(provider);
+
+		// Apply locally persisted Cline account identity so subsequent events
+		// (task.*, workspace.initialized) carry user_id when available.
+		// Note: user.extension_activated fires anonymously earlier in startup
+		// and cannot be retroactively updated; this is by design for
+		// lightweight subcommand and pre-auth CLI flows. See CLINE-2406.
+		if (provider === "cline") {
+			const savedAccountId = selectedProviderSettings?.auth?.accountId;
+			if (savedAccountId) {
+				identifyTelemetryAccount({ id: savedAccountId, provider: "cline" });
+			}
+		}
+
+		const persistedApiKey = getPersistedProviderApiKey(
+			provider,
+			selectedProviderSettings,
+		);
+		const providedApiKey = args.key?.trim() || undefined;
+		let apiKey = providedApiKey || persistedApiKey || undefined;
+
+		const isYoloMode = args.mode === "yolo";
+		const isZenMode = args.mode === "zen";
+
+		// In headless mode (yolo / json / piped stdin without --tui),
+		// don't attempt browser-based OAuth. Authentication may still resolve at
+		// runtime from environment-based provider auth or persisted OAuth tokens.
+		const isHeadless =
+			isYoloMode ||
+			isZenMode ||
+			args.outputMode === "json" ||
+			(!process.stdin.isTTY && !args.interactive);
+		const isInteractive = (args.interactive || !args.prompt) && !isHeadless;
+
+		if (!apiKey && isOAuthProvider(provider) && !isHeadless && !isInteractive) {
+			const oauthResult = await ensureOAuthProviderApiKey({
+				providerId: provider,
+				currentApiKey: apiKey,
+				existingSettings: selectedProviderSettings,
+				providerSettingsManager,
+				io: { writeln, writeErr },
+			});
+			selectedProviderSettings =
+				oauthResult?.selectedProviderSettings ?? selectedProviderSettings;
+			apiKey = oauthResult?.apiKey ?? apiKey;
+		}
+
+		let knownModels: Config["knownModels"];
+		try {
+			const persistedProviderConfig = providerSettingsManager.getProviderConfig(
+				provider,
+				{
+					includeKnownModels: false,
+				},
+			);
+			const catalogOptions = isInteractive
+				? {
+						loadLatestOnInit: true,
+						loadPrivateOnAuth: true,
+						failOnError: false,
+					}
+				: undefined;
+			const resolvedProviderConfig = await coreServer.resolveProviderConfig(
+				provider,
+				catalogOptions,
+				persistedProviderConfig,
+			);
+			knownModels = resolvedProviderConfig?.knownModels;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			writeln(
+				`${c.dim}[model-catalog] catalog resolution failed (${message})${c.reset}`,
+			);
+		}
+		const knownModelIds = knownModels ? Object.keys(knownModels) : [];
+		const resolvedReasoning = resolveCliReasoning({
+			thinking: args.thinking,
+			thinkingExplicitlySet: args.thinkingExplicitlySet,
+			reasoningEffort: args.reasoningEffort,
+			persistedReasoning: selectedProviderSettings?.reasoning,
+		});
+		const cliBuildInfo = getCliBuildInfo();
+		const { createCliLoggerAdapter } = await import("./logging/adapter");
+		const loggerAdapter = createCliLoggerAdapter({
+			runtime: "cli",
+			component: "main",
+		});
+		loggerAdapter.core.log("CLI run started", {
+			interactive: args.interactive === true,
+			hasPrompt: !!args.prompt?.trim(),
+			cwd,
+			});
+
+		const config: Config = {
+			providerId: provider,
+			modelId:
+				args.model ??
+				selectedProviderSettings?.model ??
+				knownModelIds[0] ??
+				"anthropic/claude-sonnet-4.6",
+			apiKey: apiKey ?? "",
+			knownModels,
+			systemPrompt: await resolveSystemPrompt({
+				cwd,
+				explicitSystemPrompt: args.systemPrompt,
+				providerId: provider,
+				mode: args.mode ?? "act",
+			}),
+			execution: {
+				maxConsecutiveMistakes: args.retries ?? 3,
+			},
+			checkpoint: CLI_DEFAULT_CHECKPOINT_CONFIG,
+			compaction: buildCliCompactionConfig(args.compactionMode),
+			timeoutSeconds: args.timeoutSeconds,
+			sandbox: sandboxEnabled,
+			sandboxDataDir,
+			verbose: args.verbose,
+			thinking: resolvedReasoning.thinking,
+			reasoningEffort: resolvedReasoning.reasoningEffort,
+			outputMode: args.outputMode,
+			mode: args.mode,
+			logger: loggerAdapter.core,
+			loggerConfig: loggerAdapter.runtimeConfig,
+			telemetry: getCliTelemetryService(loggerAdapter.core),
+			defaultToolAutoApprove,
+			toolPolicies,
+			enableSpawnAgent: !isYoloMode,
+			enableAgentTeams: !isYoloMode,
+			enableTools: true,
+			cwd,
+			workspaceRoot,
+			extensionContext: {
+				client: {
+					name: "cline-cli",
+					version: cliBuildInfo.version,
+					platform: "cli",
+					platformVersion: cliBuildInfo.version,
+					isMultiRoot: false,
+				},
+				workspace: {
+					rootPath: workspaceRoot,
+					cwd,
+					workspaceName: basename(cwd),
+					ide: "Terminal Shell",
+					platform: process.platform,
+				},
+				logger: loggerAdapter.core,
+			},
+			teamName: !isYoloMode ? args.teamName?.trim() || undefined : undefined,
+		};
+		try {
+			// For OAuth providers, don't write the resolved key into apiKey;
+			// the token lives in auth.accessToken and apiKey is reserved for
+			// migrated/manual keys.
+			const persistApiKey =
+				// Persist explicit `-k/--key` even for OAuth-capable providers.
+				providedApiKey
+					? { apiKey: providedApiKey }
+					: apiKey && !isOAuthProvider(provider)
+						? { apiKey }
+						: {};
+			providerSettingsManager.saveProviderSettings({
+				...(selectedProviderSettings ?? {}),
+				provider,
+				model: config.modelId,
+				...persistApiKey,
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			writeln(
+				`${c.dim}[provider-settings] failed to persist selection (${message})${c.reset}`,
+			);
+		}
+		// Check for piped input (skip when stdin is not a real pipe/file, e.g. headless CI).
+		// Guard `isTTY` first so we never block on fd 0 when stdin is a terminal (and avoid
+		// redundant fstat work). `stdinHasPipedInput` also checks `isTTY`, but callers may hit
+		// inconsistent state in tests or embedded hosts.
+		if (!process.stdin.isTTY && stdinHasPipedInput() && !args.interactive) {
+			const chunks: Buffer[] = [];
+			for await (const chunk of process.stdin) {
+				chunks.push(chunk as Buffer);
+			}
+			const pipedInput = Buffer.concat(chunks).toString("utf-8").trim();
+
+			if (pipedInput) {
+				const prompt = args.prompt
+					? `${args.prompt}\n\n${pipedInput}`
+					: pipedInput;
+				const rewrittenTeamPrompt = rewriteTeamPrompt(prompt);
+				if (rewrittenTeamPrompt.kind === "usage") {
+					writeln(TEAM_COMMAND_USAGE);
+					return;
+				}
+				const pipedEffectivePrompt =
+					rewrittenTeamPrompt.kind === "rewritten"
+						? rewrittenTeamPrompt.prompt
+						: prompt;
+				if (isZenMode) {
+					const { runZen } = await import("./runtime/run-zen");
+					await runZen(pipedEffectivePrompt, config, userInstructionService);
+					return;
+				}
+				await runAgent(pipedEffectivePrompt, config, userInstructionService);
+				return;
+			}
+		}
+
+		// Interactive mode: zen is incompatible because there is no terminal UI
+		// to surface results and nothing waits for the background task.
+		if (args.interactive || !args.prompt) {
+			if (isZenMode) {
+				writeErr(
+					args.interactive
+						? "--zen is not compatible with interactive mode."
+						: "--zen requires a prompt.",
+				);
+				process.exitCode = 1;
+				return;
+			}
+			const runInteractive = await loadInteractiveRuntimeModule();
+			let initialView: "chat" | "config" | undefined;
+			if (launchConfigView) {
+				initialView = "config";
+			} else if (resumeSessionId) {
+				initialView = "chat";
+			}
+			const initialClineProviderSettings =
+				provider === "cline" ? selectedProviderSettings : undefined;
+			let initialNotice:
+				| import("./kanban-migration/notice").CliMigrationNotice
+				| undefined;
+			let markInitialNoticeShown:
+				| ((
+						notice: import("./kanban-migration/notice").CliMigrationNotice,
+				  ) => void)
+				| undefined;
+			if (!launchConfigView && process.stdin.isTTY && process.stdout.isTTY) {
+				const { getClineCliMigrationNotice, markClineCliMigrationNoticeShown } =
+					await import("./kanban-migration/notice");
+				initialNotice = getClineCliMigrationNotice(undefined, process.env, {
+					activeProviderId: provider,
+				});
+				if (initialNotice) {
+					markInitialNoticeShown = () => {
+						markClineCliMigrationNoticeShown();
+					};
+				}
+			}
+			await runInteractive(config, userInstructionService, resumeSessionId, {
+				initialPrompt: args.prompt,
+				clineApiBaseUrl: initialClineProviderSettings?.baseUrl,
+				clineProviderSettings: initialClineProviderSettings,
+				initialView,
+				initialNotice,
+				onInitialNoticeShown: markInitialNoticeShown,
+			});
+			return;
+		}
+
+		// Single prompt mode
+		const rewrittenTeamPrompt = rewriteTeamPrompt(args.prompt);
+		if (rewrittenTeamPrompt.kind === "usage") {
+			writeln(TEAM_COMMAND_USAGE);
+			return;
+		}
+		const effectivePrompt =
+			rewrittenTeamPrompt.kind === "rewritten"
+				? rewrittenTeamPrompt.prompt
+				: args.prompt;
+
+		// Zen mode: dispatch the task to the background hub and exit. The CLI
+		// does not stay connected to stream output; completion is delivered via
+		// the hub's existing ui.notify broadcast (picked up by the menubar app
+		// when installed).
+		if (isZenMode) {
+			const { runZen } = await import("./runtime/run-zen");
+			await runZen(effectivePrompt, config, userInstructionService);
+			return;
+		}
+
+		await runAgent(effectivePrompt, config, userInstructionService);
+		// Exit once agent is done in non-interactive mode
+		return;
+	} finally {
+		stopUserInstructionService();
+	}
+}
diff --git a/apps/cli/src/runtime/active-runtime.test.ts b/apps/cli/src/runtime/active-runtime.test.ts
new file mode 100644
index 0000000..506f010
--- /dev/null
+++ b/apps/cli/src/runtime/active-runtime.test.ts
@@ -0,0 +1,39 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	abortActiveRuntime,
+	cleanupActiveRuntime,
+	setActiveRuntimeAbort,
+	setActiveRuntimeCleanup,
+} from "./active-runtime";
+
+describe("active runtime hooks", () => {
+	afterEach(() => {
+		setActiveRuntimeAbort(undefined);
+		setActiveRuntimeCleanup(undefined);
+	});
+
+	it("keeps abort and cleanup hooks independent", () => {
+		const abort = vi.fn();
+		const cleanup = vi.fn();
+
+		setActiveRuntimeAbort(abort);
+		setActiveRuntimeCleanup(cleanup);
+
+		abortActiveRuntime();
+
+		expect(abort).toHaveBeenCalledTimes(1);
+		expect(cleanup).not.toHaveBeenCalled();
+
+		cleanupActiveRuntime();
+
+		expect(cleanup).toHaveBeenCalledTimes(1);
+	});
+
+	it("swallows cleanup hook failures", () => {
+		setActiveRuntimeCleanup(() => {
+			throw new Error("cleanup failed");
+		});
+
+		expect(() => cleanupActiveRuntime()).not.toThrow();
+	});
+});
diff --git a/apps/cli/src/runtime/active-runtime.ts b/apps/cli/src/runtime/active-runtime.ts
new file mode 100644
index 0000000..ffbd213
--- /dev/null
+++ b/apps/cli/src/runtime/active-runtime.ts
@@ -0,0 +1,83 @@
+let activeRuntimeAbort: (() => void) | undefined;
+let activeRuntimeCleanup: (() => void) | undefined;
+let abortGraceTimer: ReturnType<typeof setTimeout> | undefined;
+let abortInProgress = false;
+let savedRejectionListeners: Function[] | undefined;
+
+export function setActiveRuntimeAbort(abortFn: (() => void) | undefined): void {
+	activeRuntimeAbort = abortFn;
+}
+
+export function setActiveRuntimeCleanup(
+	cleanupFn: (() => void) | undefined,
+): void {
+	activeRuntimeCleanup = cleanupFn;
+}
+
+export function abortActiveRuntime(): void {
+	try {
+		activeRuntimeAbort?.();
+	} catch {
+		// Best-effort abort path.
+	}
+}
+
+export function cleanupActiveRuntime(): void {
+	try {
+		activeRuntimeCleanup?.();
+	} catch {
+		// Best-effort cleanup path.
+	}
+}
+
+// AbortController.abort() can cause internal LLM streaming promises to
+// reject outside the main run promise chain. The main run handles abort
+// correctly (returns finishReason:"aborted"), but orphan rejections from
+// the streaming layer or hub capability teardown surface as
+// unhandledRejections and would otherwise crash the CLI.
+export function markAbortInProgress(): void {
+	if (abortInProgress) {
+		return;
+	}
+	abortInProgress = true;
+	if (abortGraceTimer) {
+		clearTimeout(abortGraceTimer);
+		abortGraceTimer = undefined;
+	}
+	// Temporarily replace all unhandledRejection listeners with a
+	// suppressing handler. AbortController.abort() causes orphan promise
+	// rejections in the LLM streaming layer that reach every registered
+	// listener (including OpenTUI's error overlay). Swapping the listeners
+	// is the only way to prevent them from surfacing to the user.
+	savedRejectionListeners = process.rawListeners(
+		"unhandledRejection",
+	) as Function[];
+	process.removeAllListeners("unhandledRejection");
+	process.on("unhandledRejection", (_reason, promise) => {
+		promise.catch(() => {});
+	});
+}
+
+export function clearAbortInProgress(): void {
+	if (abortGraceTimer) {
+		clearTimeout(abortGraceTimer);
+	}
+	abortGraceTimer = setTimeout(() => {
+		abortInProgress = false;
+		abortGraceTimer = undefined;
+		if (savedRejectionListeners) {
+			process.removeAllListeners("unhandledRejection");
+			for (const listener of savedRejectionListeners) {
+				process.on(
+					"unhandledRejection",
+					listener as (...args: unknown[]) => void,
+				);
+			}
+			savedRejectionListeners = undefined;
+		}
+	}, 2000);
+}
+
+export function isAbortInProgress(): boolean {
+	return abortInProgress;
+}
diff --git a/apps/cli/src/runtime/defaults.ts b/apps/cli/src/runtime/defaults.ts
new file mode 100644
index 0000000..7de9828
--- /dev/null
+++ b/apps/cli/src/runtime/defaults.ts
@@ -0,0 +1,18 @@
+/**
+ * Default loop detection thresholds for the CLI.
+ * The agent core leaves loop detection off by default;
+ * the CLI enables it with these settings.
+ */
+export const CLI_DEFAULT_LOOP_DETECTION = {
+	softThreshold: 3,
+	hardThreshold: 5,
+} as const;
+
+/**
+ * Default checkpoint configuration for the CLI.
+ * Core leaves checkpoints disabled by default (opt-in);
+ * the CLI enables them so every run gets a restorable git snapshot.
+ */
+export const CLI_DEFAULT_CHECKPOINT_CONFIG = {
+	enabled: true,
+} as const;
diff --git a/apps/cli/src/runtime/format.ts b/apps/cli/src/runtime/format.ts
new file mode 100644
index 0000000..5bd054a
--- /dev/null
+++ b/apps/cli/src/runtime/format.ts
@@ -0,0 +1,79 @@
+import { askQuestionInTerminal } from "../utils/approval";
+import type { Config } from "../utils/types";
+
+export function describeAbortSource(input: {
+	abortRequested: boolean;
+	timedOut: boolean;
+}): string {
+	if (input.timedOut) {
+		return "aborted after timeout";
+	}
+	if (input.abortRequested) {
+		return "aborted";
+	}
+	return "aborted by another client";
+}
+
+export async function resolveMistakeLimitDecision(
+	config: Config,
+	context: {
+		iteration: number;
+		consecutiveMistakes: number;
+		maxConsecutiveMistakes: number;
+		reason: "api_error" | "invalid_tool_call" | "tool_execution_failed";
+		details?: string;
+	},
+): Promise<
+	| { action: "continue"; guidance?: string }
+	| { action: "stop"; reason?: string }
+> {
+	const yoloEnabled = config.toolPolicies["*"]?.autoApprove !== false;
+	if (yoloEnabled) {
+		return {
+			action: "stop",
+			reason: `max consecutive mistakes reached (${context.maxConsecutiveMistakes}) in yolo mode`,
+		};
+	}
+	const detail = context.details?.trim();
+	const summary = detail
+		? `${context.reason}: ${detail}`
+		: `${context.reason} at iteration ${context.iteration}`;
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		return {
+			action: "stop",
+			reason: `mistake_limit_reached: ${summary}`,
+		};
+	}
+	const answer = await askQuestionInTerminal(
+		`mistake_limit_reached (${context.consecutiveMistakes}/${context.maxConsecutiveMistakes})\nLatest: ${summary}\nHow should Cline continue?`,
+		["Try a different approach", "Stop this run"],
+	);
+	const normalized = answer.trim().toLowerCase();
+	if (
+		normalized === "2" ||
+		normalized === "stop this run" ||
+		normalized === "stop" ||
+		normalized === "n" ||
+		normalized === "no"
+	) {
+		return {
+			action: "stop",
+			reason: "stopped after mistake_limit_reached prompt",
+		};
+	}
+	if (
+		normalized === "1" ||
+		normalized === "try a different approach" ||
+		normalized.length === 0
+	) {
+		return {
+			action: "continue",
+			guidance:
+				"mistake_limit_reached: retry with a different approach, validate tool parameters before calls, and avoid repeating failed steps.",
+		};
+	}
+	return {
+		action: "continue",
+		guidance: `mistake_limit_reached: ${answer.trim()}`,
+	};
+}
diff --git a/apps/cli/src/runtime/interactive/approvals.test.ts b/apps/cli/src/runtime/interactive/approvals.test.ts
new file mode 100644
index 0000000..4a60232
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/approvals.test.ts
@@ -0,0 +1,97 @@
+import type { ToolApprovalRequest } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import type { Config } from "../../utils/types";
+import { createInteractiveApprovalController } from "./approvals";
+
+function makeConfig(autoApprove = true): Config {
+	return {
+		apiKey: "",
+		providerId: "cline",
+		modelId: "openai/gpt-5.3-codex",
+		verbose: false,
+		sandbox: false,
+		thinking: false,
+		outputMode: "text",
+		mode: "act",
+		systemPrompt: "",
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+		defaultToolAutoApprove: autoApprove,
+		toolPolicies: {
+			"*": { autoApprove },
+		},
+		cwd: process.cwd(),
+	};
+}
+
+function makeRequest(
+	policy: ToolApprovalRequest["policy"],
+): ToolApprovalRequest {
+	return {
+		sessionId: "session-1",
+		agentId: "agent-1",
+		conversationId: "conversation-1",
+		iteration: 1,
+		toolCallId: "tool-1",
+		toolName: "read_file",
+		input: {},
+		policy,
+	};
+}
+
+describe("createInteractiveApprovalController", () => {
+	it("approves requests when global auto-approve is enabled", async () => {
+		const controller = createInteractiveApprovalController(makeConfig(true));
+
+		await expect(
+			controller.requestToolApproval(makeRequest({ autoApprove: undefined })),
+		).resolves.toEqual({ approved: true });
+	});
+
+	it("uses the TUI approver when global auto-approve is disabled", async () => {
+		const controller = createInteractiveApprovalController(makeConfig(false));
+		controller.tuiToolApprover.current = async () => ({
+			approved: false,
+			reason: "no",
+		});
+
+		await expect(
+			controller.requestToolApproval(makeRequest({ autoApprove: false })),
+		).resolves.toEqual({ approved: false, reason: "no" });
+	});
+
+	it("approves stale required-approval requests after auto-approve is enabled", async () => {
+		const controller = createInteractiveApprovalController(makeConfig(false));
+		controller.tuiToolApprover.current = async () => ({
+			approved: false,
+			reason: "stale prompt",
+		});
+
+		controller.setInteractiveAutoApprove(true);
+
+		await expect(
+			controller.requestToolApproval(makeRequest({ autoApprove: false })),
+		).resolves.toEqual({ approved: true });
+	});
+
+	it("denies approval-required requests when no TUI approver is available", async () => {
+		const controller = createInteractiveApprovalController(makeConfig(false));
+
+		await expect(
+			controller.requestToolApproval(makeRequest({ autoApprove: false })),
+		).resolves.toMatchObject({ approved: false });
+	});
+
+	it("updates live tool policies when interactive auto-approve changes", () => {
+		const config = makeConfig(false);
+		const controller = createInteractiveApprovalController(config);
+
+		controller.setInteractiveAutoApprove(true);
+
+		expect(controller.autoApproveAllRef.current).toBe(true);
+		expect(config.defaultToolAutoApprove).toBe(false);
+		expect(config.toolPolicies["*"]?.autoApprove).toBe(true);
+		expect(controller.resolveToolPolicy("run_commands").autoApprove).toBe(true);
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/approvals.ts b/apps/cli/src/runtime/interactive/approvals.ts
new file mode 100644
index 0000000..bd8e56b
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/approvals.ts
@@ -0,0 +1,66 @@
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import type { Config } from "../../utils/types";
+import {
+	applyInteractiveAutoApproveOverride,
+	cloneToolPolicies,
+	resolveInteractiveAutoApprovePolicy,
+} from "../tool-policies";
+
+export interface InteractiveRuntimeRefs {
+	tuiToolApprover: {
+		current:
+			| ((request: ToolApprovalRequest) => Promise<ToolApprovalResult>)
+			| null;
+	};
+	tuiAskQuestion: {
+		current: ((question: string, options: string[]) => Promise<string>) | null;
+	};
+}
+
+export function createInteractiveApprovalController(config: Config) {
+	const autoApproveAllRef = {
+		current: config.toolPolicies["*"]?.autoApprove !== false,
+	};
+	const baselineToolPolicies = cloneToolPolicies(config.toolPolicies);
+	const refs: InteractiveRuntimeRefs = {
+		tuiToolApprover: { current: null },
+		tuiAskQuestion: { current: null },
+	};
+
+	const setInteractiveAutoApprove = (enabled: boolean) => {
+		autoApproveAllRef.current = enabled;
+		applyInteractiveAutoApproveOverride({
+			targetPolicies: config.toolPolicies,
+			baselinePolicies: baselineToolPolicies,
+			enabled,
+		});
+	};
+
+	const requestToolApproval = async (
+		request: ToolApprovalRequest,
+	): Promise<ToolApprovalResult> => {
+		if (autoApproveAllRef.current) {
+			return { approved: true };
+		}
+		if (request.policy?.autoApprove === true) {
+			return { approved: true };
+		}
+		if (refs.tuiToolApprover.current) {
+			return refs.tuiToolApprover.current(request);
+		}
+		return { approved: false };
+	};
+
+	return {
+		autoApproveAllRef,
+		setInteractiveAutoApprove,
+		requestToolApproval,
+		resolveToolPolicy: (toolName: string) =>
+			resolveInteractiveAutoApprovePolicy({
+				toolName,
+				baselinePolicies: baselineToolPolicies,
+				enabled: autoApproveAllRef.current,
+			}),
+		...refs,
+	};
+}
diff --git a/apps/cli/src/runtime/interactive/chat-command-runner.test.ts b/apps/cli/src/runtime/interactive/chat-command-runner.test.ts
new file mode 100644
index 0000000..486f9ab
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/chat-command-runner.test.ts
@@ -0,0 +1,199 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	type ChatCommandState,
+	chatCommandHost,
+	createChatCommandHost,
+} from "../../utils/chat-commands";
+import type { Config } from "../../utils/types";
+import {
+	type InteractiveChatCommandRuntime,
+	runInteractiveChatCommand,
+} from "./chat-command-runner";
+
+function makeConfig(): Config {
+	return {
+		apiKey: "",
+		providerId: "cline",
+		modelId: "openai/gpt-5.3-codex",
+		verbose: false,
+		sandbox: false,
+		thinking: false,
+		outputMode: "text",
+		mode: "act",
+		systemPrompt: "",
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: false,
+		defaultToolAutoApprove: false,
+		toolPolicies: {},
+		cwd: process.cwd(),
+	};
+}
+
+function makeState(config: Config): ChatCommandState {
+	return {
+		enableTools: config.enableTools,
+		autoApproveTools: config.defaultToolAutoApprove,
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot?.trim() || config.cwd,
+	};
+}
+
+function makeRuntime(): InteractiveChatCommandRuntime {
+	return {
+		forkCurrentSession: vi.fn(async () => undefined),
+		getActiveSessionId: vi.fn(() => "session-1"),
+		resetForNewSession: vi.fn(async () => {}),
+		restartEmpty: vi.fn(async () => {}),
+	};
+}
+
+describe("runInteractiveChatCommand", () => {
+	it("handles missing team prompt body as command usage", async () => {
+		const config = makeConfig();
+		const runtime = makeRuntime();
+
+		const result = await runInteractiveChatCommand({
+			prompt: "/team",
+			enabled: true,
+			config,
+			host: chatCommandHost,
+			chatCommandState: makeState(config),
+			autoApproveAllRef: { current: false },
+			setInteractiveAutoApprove: () => {},
+			sessionRuntime: runtime,
+			stop: () => {},
+		});
+
+		expect(result).toEqual({
+			handled: true,
+			turnResult: {
+				usage: { inputTokens: 0, outputTokens: 0 },
+				iterations: 0,
+				commandOutput:
+					"Usage: /team <task description>\nStarts a team of agents for the given task.",
+			},
+		});
+		expect(runtime.restartEmpty).not.toHaveBeenCalled();
+	});
+
+	it("rewrites team prompts and enables teams before model submission", async () => {
+		const config = makeConfig();
+		const runtime = makeRuntime();
+
+		const result = await runInteractiveChatCommand({
+			prompt: "/team inspect the TUI",
+			enabled: true,
+			config,
+			host: chatCommandHost,
+			chatCommandState: makeState(config),
+			autoApproveAllRef: { current: false },
+			setInteractiveAutoApprove: () => {},
+			sessionRuntime: runtime,
+			stop: () => {},
+		});
+
+		expect(result.handled).toBe(false);
+		if (!result.handled) {
+			expect(result.input).toContain("spawn a team of agents");
+			expect(result.input).toContain("inspect the TUI");
+		}
+		expect(config.enableAgentTeams).toBe(true);
+		expect(config.teamName).toBeTruthy();
+		expect(runtime.restartEmpty).toHaveBeenCalledOnce();
+	});
+
+	it("resets slash new without eagerly restarting the runtime", async () => {
+		const config = makeConfig();
+		const runtime = makeRuntime();
+
+		const result = await runInteractiveChatCommand({
+			prompt: "/new",
+			enabled: true,
+			config,
+			host: chatCommandHost,
+			chatCommandState: makeState(config),
+			autoApproveAllRef: { current: false },
+			setInteractiveAutoApprove: () => {},
+			sessionRuntime: runtime,
+			stop: () => {},
+		});
+
+		expect(result).toEqual({
+			handled: true,
+			turnResult: {
+				usage: { inputTokens: 0, outputTokens: 0 },
+				iterations: 0,
+				commandOutput: "Started a fresh session.",
+			},
+		});
+		expect(runtime.resetForNewSession).toHaveBeenCalledOnce();
+		expect(runtime.restartEmpty).not.toHaveBeenCalled();
+	});
+
+	it("applies chat command state updates and returns command output", async () => {
+		const config = makeConfig();
+		const runtime = makeRuntime();
+		const state = makeState(config);
+		const autoApproveAllRef = { current: false };
+		const setInteractiveAutoApprove = vi.fn((enabled: boolean) => {
+			autoApproveAllRef.current = enabled;
+		});
+
+		const result = await runInteractiveChatCommand({
+			prompt: "/yolo on",
+			enabled: true,
+			config,
+			host: chatCommandHost,
+			chatCommandState: state,
+			autoApproveAllRef,
+			setInteractiveAutoApprove,
+			sessionRuntime: runtime,
+			stop: () => {},
+		});
+
+		expect(result).toEqual({
+			handled: true,
+			turnResult: {
+				usage: { inputTokens: 0, outputTokens: 0 },
+				iterations: 0,
+				commandOutput: "yolo=on",
+			},
+		});
+		expect(state.autoApproveTools).toBe(true);
+		expect(setInteractiveAutoApprove).toHaveBeenCalledWith(true);
+	});
+
+	it("returns plugin command submit prompts as model input", async () => {
+		const config = makeConfig();
+		const runtime = makeRuntime();
+		const onCommandOutput = vi.fn();
+		const host = createChatCommandHost().register("command", {
+			names: ["/goal"],
+			run: async ({ args }, context) => {
+				await context.reply(`Goal guard set: ${args.join(" ")}`);
+				await context.submitPrompt?.(args.join(" "));
+			},
+		});
+
+		const result = await runInteractiveChatCommand({
+			prompt: "/goal fix tests",
+			enabled: true,
+			config,
+			host,
+			chatCommandState: makeState(config),
+			autoApproveAllRef: { current: false },
+			setInteractiveAutoApprove: () => {},
+			sessionRuntime: runtime,
+			stop: () => {},
+			onCommandOutput,
+		});
+
+		expect(result).toEqual({
+			handled: false,
+			input: "fix tests",
+			commandOutput: "Goal guard set: fix tests",
+		});
+		expect(onCommandOutput).toHaveBeenCalledWith("Goal guard set: fix tests");
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/chat-command-runner.ts b/apps/cli/src/runtime/interactive/chat-command-runner.ts
new file mode 100644
index 0000000..f923b08
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/chat-command-runner.ts
@@ -0,0 +1,123 @@
+import type { InteractiveTurnResult } from "../../tui/types";
+import type { ChatCommandHost } from "../../utils/chat-commands";
+import {
+	type ChatCommandState,
+	maybeHandleChatCommand,
+} from "../../utils/chat-commands";
+import {
+	enableTeamsForPrompt,
+	rewriteTeamPrompt,
+	TEAM_COMMAND_USAGE,
+} from "../../utils/team-command";
+import type { Config } from "../../utils/types";
+import type { createInteractiveSessionRuntime } from "./session-runtime";
+
+type AutoApproveRef = {
+	current: boolean;
+};
+
+export type InteractiveChatCommandRuntime = Pick<
+	ReturnType<typeof createInteractiveSessionRuntime>,
+	| "forkCurrentSession"
+	| "getActiveSessionId"
+	| "resetForNewSession"
+	| "restartEmpty"
+>;
+
+export type InteractiveChatCommandResult =
+	| { handled: true; turnResult: InteractiveTurnResult }
+	| { handled: false; input: string; commandOutput?: string };
+
+function commandTurnResult(commandOutput?: string): InteractiveTurnResult {
+	return {
+		usage: { inputTokens: 0, outputTokens: 0 },
+		iterations: 0,
+		commandOutput,
+	};
+}
+
+export async function runInteractiveChatCommand(input: {
+	prompt: string;
+	enabled: boolean;
+	config: Config;
+	host: ChatCommandHost;
+	chatCommandState: ChatCommandState;
+	autoApproveAllRef: AutoApproveRef;
+	setInteractiveAutoApprove: (enabled: boolean) => void;
+	sessionRuntime: InteractiveChatCommandRuntime;
+	stop: () => void;
+	onCommandOutput?: (text: string) => void;
+}): Promise<InteractiveChatCommandResult> {
+	let prompt = input.prompt;
+	const rewrittenTeamPrompt = rewriteTeamPrompt(prompt);
+	if (rewrittenTeamPrompt.kind !== "none") {
+		if (rewrittenTeamPrompt.kind === "usage") {
+			return {
+				handled: true,
+				turnResult: commandTurnResult(TEAM_COMMAND_USAGE),
+			};
+		}
+		if (!input.config.enableAgentTeams) {
+			await enableTeamsForPrompt(input.config);
+			await input.sessionRuntime.restartEmpty();
+		}
+		prompt = rewrittenTeamPrompt.prompt;
+	}
+
+	let commandOutput: string | undefined;
+	let submitPrompt: string | undefined;
+	const handled = await maybeHandleChatCommand(prompt, {
+		enabled: input.enabled,
+		host: input.host,
+		getState: () => ({
+			...input.chatCommandState,
+			autoApproveTools: input.autoApproveAllRef.current,
+		}),
+		setState: async (next) => {
+			input.chatCommandState.enableTools = next.enableTools;
+			input.chatCommandState.autoApproveTools = next.autoApproveTools;
+			input.chatCommandState.cwd = next.cwd;
+			input.chatCommandState.workspaceRoot = next.workspaceRoot;
+			input.setInteractiveAutoApprove(next.autoApproveTools);
+		},
+		reply: async (text) => {
+			commandOutput = text;
+			input.onCommandOutput?.(text);
+		},
+		submitPrompt: async (text) => {
+			const trimmed = text.trim();
+			if (trimmed) {
+				submitPrompt = trimmed;
+			}
+		},
+		reset: async () => {
+			await input.sessionRuntime.resetForNewSession();
+		},
+		stop: async () => {
+			input.stop();
+		},
+		describe: () =>
+			[
+				`sessionId=${input.sessionRuntime.getActiveSessionId()}`,
+				`tools=${input.chatCommandState.enableTools ? "on" : "off"}`,
+				`yolo=${input.autoApproveAllRef.current ? "on" : "off"}`,
+				`cwd=${input.chatCommandState.cwd}`,
+				`workspaceRoot=${input.chatCommandState.workspaceRoot}`,
+			].join("\n"),
+		fork: input.sessionRuntime.forkCurrentSession,
+	});
+	if (handled) {
+		if (submitPrompt) {
+			return {
+				handled: false,
+				input: submitPrompt,
+				...(commandOutput ? { commandOutput } : {}),
+			};
+		}
+		return {
+			handled: true,
+			turnResult: commandTurnResult(commandOutput),
+		};
+	}
+	return { handled: false, input: prompt };
+}
diff --git a/apps/cli/src/runtime/interactive/compaction.test.ts b/apps/cli/src/runtime/interactive/compaction.test.ts
new file mode 100644
index 0000000..4adef65
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/compaction.test.ts
@@ -0,0 +1,227 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	type CoreCompactionContext,
+	ProviderSettingsManager,
+} from "@cline/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Config } from "../../utils/types";
+import {
+	compactInteractiveMessages,
+	resolveCompactionProviderConfig,
+} from "./compaction";
+
+function createConfig(): Config {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-test",
+		apiKey: "",
+		cwd: "/tmp/project",
+		workspaceRoot: "/tmp/project",
+		systemPrompt: "system",
+		mode: "act",
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+		verbose: false,
+		thinking: false,
+		outputMode: "text",
+		sandbox: false,
+		defaultToolAutoApprove: true,
+		toolPolicies: {
+			"*": { autoApprove: true },
+		},
+	};
+}
+
+const providerSettingsTempDirs: string[] = [];
+
+function createProviderSettingsManager(): ProviderSettingsManager {
+	const tempDir = mkdtempSync(join(tmpdir(), "cline-cli-compact-"));
+	providerSettingsTempDirs.push(tempDir);
+	return new ProviderSettingsManager({
+		filePath: join(tempDir, "providers.json"),
+	});
+}
+
+afterEach(() => {
+	for (const tempDir of providerSettingsTempDirs.splice(0)) {
+		rmSync(tempDir, { force: true, recursive: true });
+	}
+});
+
+describe("compactInteractiveMessages", () => {
+	it("resolves manual compaction provider config from persisted OAuth settings", () => {
+		const manager = createProviderSettingsManager();
+		manager.saveProviderSettings({
+			provider: "openai-native",
+			model: "old-model",
+			auth: {
+				accessToken: "stored-access-token",
+				refreshToken: "stored-refresh-token",
+				accountId: "acct-1",
+			},
+			baseUrl: "https://stored.example.com/v1",
+			headers: {
+				"x-stored": "yes",
+			},
+		});
+		const config = createConfig();
+		config.providerId = "openai-native";
+		config.modelId = "gpt-test";
+
+		const providerConfig = resolveCompactionProviderConfig(config, manager);
+
+		expect(providerConfig.providerId).toBe("openai-native");
+		expect(providerConfig.modelId).toBe("gpt-test");
+		expect(providerConfig.apiKey).toBe("stored-access-token");
+		expect(providerConfig.accessToken).toBe("stored-access-token");
+		expect(providerConfig.refreshToken).toBe("stored-refresh-token");
+		expect(providerConfig.accountId).toBe("acct-1");
+		expect(providerConfig.baseUrl).toBe("https://stored.example.com/v1");
+		expect(providerConfig.headers).toEqual({ "x-stored": "yes" });
+	});
+
+	it("prefers active CLI reasoning effort over persisted provider reasoning settings", () => {
+		const manager = createProviderSettingsManager();
+		manager.saveProviderSettings({
+			provider: "anthropic",
+			model: "old-model",
+			reasoning: { enabled: true, effort: "low" },
+		});
+		const config = createConfig();
+		config.reasoningEffort = "high";
+
+		const providerConfig = resolveCompactionProviderConfig(config, manager);
+
+		expect(providerConfig.reasoningEffort).toBe("high");
+	});
+
+	it("passes the selected model context window to manual compaction", async () => {
+		const longText = "x".repeat(16_000);
+		const messages = Array.from({ length: 10 }, (_, index) => ({
+			role: index % 2 === 0 ? ("user" as const) : ("assistant" as const),
+			content: `message ${index} ${longText}`,
+		}));
+		const config = createConfig();
+		const compact = vi.fn((context: CoreCompactionContext) => {
+			expect(context.maxInputTokens).toBe(400_000);
+			return { messages: [messages[0]] };
+		});
+		config.knownModels = {
+			"claude-test": {
+				id: "claude-test",
+				maxInputTokens: 400_000,
+			},
+		};
+		config.compaction = { compact };
+
+		const result = await compactInteractiveMessages({
+			config,
+			providerSettingsManager: createProviderSettingsManager(),
+			sessionId: "sess-compact",
+			messages,
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		expect(result.compacted).toBe(true);
+		expect(result.canonicalMessages).toEqual(messages);
+		expect(result.compactionState?.messages).toEqual([messages[0]]);
+	});
+
+	it("falls back to legacy contextWindow for manual compaction", async () => {
+		const longText = "x".repeat(16_000);
+		const messages = Array.from({ length: 10 }, (_, index) => ({
+			role: index % 2 === 0 ? ("user" as const) : ("assistant" as const),
+			content: `message ${index} ${longText}`,
+		}));
+		const config = createConfig();
+		const compact = vi.fn((context: CoreCompactionContext) => {
+			expect(context.maxInputTokens).toBe(400_000);
+			return { messages: [messages[0]] };
+		});
+		config.knownModels = {
+			"claude-test": {
+				id: "claude-test",
+				contextWindow: 400_000,
+			},
+		};
+		config.compaction = { compact };
+
+		const result = await compactInteractiveMessages({
+			config,
+			providerSettingsManager: createProviderSettingsManager(),
+			sessionId: "sess-compact",
+			messages,
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		expect(result.compacted).toBe(true);
+		expect(result.canonicalMessages).toEqual(messages);
+		expect(result.compactionState?.messages).toEqual([messages[0]]);
+	});
+
+	it("uses a useful target budget for manual compaction", async () => {
+		const longText = "x".repeat(16_000);
+		const messages = Array.from({ length: 10 }, (_, index) => ({
+			role: index % 2 === 0 ? ("user" as const) : ("assistant" as const),
+			content: `message ${index} ${longText}`,
+		}));
+
+		const result = await compactInteractiveMessages({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			sessionId: "sess-compact",
+			messages,
+		});
+
+		const compactedMessages = result.compactionState?.messages ?? [];
+		const compactedTextLength = compactedMessages.reduce(
+			(total, message) =>
+				total +
+				(typeof message.content === "string" ? message.content.length : 0),
+			0,
+		);
+
+		expect(result.compacted).toBe(true);
+		expect(result.canonicalMessages).toEqual(messages);
+		expect(compactedMessages.length).toBeGreaterThan(1);
+		expect(compactedMessages.length).toBeLessThan(messages.length);
+		expect(compactedTextLength).toBeGreaterThan(1_000);
+	});
+
+	it("reports compaction when core returns changed messages with the same count", async () => {
+		const messages = [
+			{
+				role: "user" as const,
+				content: `${" ".repeat(80)}same count but content should be trimmed${" ".repeat(80)}`,
+			},
+		];
+		const config = createConfig();
+		config.compaction = {
+			compact: () => ({
+				messages: [
+					{
+						role: "user",
+						content: "same count but content should be trimmed",
+					},
+				],
+			}),
+		};
+
+		const result = await compactInteractiveMessages({
+			config,
+			providerSettingsManager: createProviderSettingsManager(),
+			sessionId: "sess-compact",
+			messages,
+		});
+
+		expect(result.compacted).toBe(true);
+		expect(result.canonicalMessages).toEqual(messages);
+		expect(result.compactionState?.messages).toHaveLength(messages.length);
+		expect(result.compactionState?.messages[0]?.content).toBe(
+			"same count but content should be trimmed",
+		);
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/compaction.ts b/apps/cli/src/runtime/interactive/compaction.ts
new file mode 100644
index 0000000..9279181
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/compaction.ts
@@ -0,0 +1,129 @@
+import {
+	createContextCompactionPrepareTurn,
+	createSessionCompactionState,
+	type ProviderConfig,
+	type ProviderSettings,
+	type ProviderSettingsManager,
+	type ReasoningSettings,
+	type SessionCompactionState,
+	toProviderConfig,
+} from "@cline/core";
+import type { Message } from "@cline/shared";
+import type { Config } from "../../utils/types";
+
+const FALLBACK_MANUAL_COMPACTION_MAX_INPUT_TOKENS = 64_000;
+
+function resolveCompactionReasoningSettings(
+	config: Config,
+	stored: ProviderSettings | undefined,
+): ReasoningSettings | undefined {
+	if (config.reasoningEffort) {
+		return { enabled: true, effort: config.reasoningEffort };
+	}
+	return stored?.reasoning;
+}
+
+export function resolveCompactionProviderConfig(
+	config: Config,
+	providerSettingsManager: ProviderSettingsManager,
+): ProviderConfig {
+	const stored = providerSettingsManager.getProviderSettings(config.providerId);
+	const providerConfig = toProviderConfig({
+		...(stored ?? {}),
+		provider: config.providerId,
+		model: config.modelId,
+		apiKey: config.apiKey || stored?.apiKey,
+		baseUrl: config.baseUrl ?? stored?.baseUrl,
+		headers: config.headers ?? stored?.headers,
+		reasoning: resolveCompactionReasoningSettings(config, stored),
+	} satisfies ProviderSettings);
+	const base = {
+		...providerConfig,
+		...(config.providerConfig ?? {}),
+	};
+	return {
+		...base,
+		providerId: base.providerId ?? config.providerId,
+		modelId: base.modelId ?? config.modelId,
+		knownModels: base.knownModels ?? config.knownModels,
+	};
+}
+
+export async function compactInteractiveMessages(input: {
+	config: Config;
+	providerSettingsManager: ProviderSettingsManager;
+	sessionId: string;
+	messages: Message[];
+	abortSignal?: AbortSignal;
+}): Promise<{
+	compacted: boolean;
+	canonicalMessages: Message[];
+	compactionState?: SessionCompactionState;
+}> {
+	const modelInfo = input.config.knownModels?.[input.config.modelId];
+	const maxInputTokens =
+		input.config.compaction?.maxInputTokens ??
+		modelInfo?.maxInputTokens ??
+		modelInfo?.contextWindow ??
+		FALLBACK_MANUAL_COMPACTION_MAX_INPUT_TOKENS;
+	const compact = createContextCompactionPrepareTurn(
+		{
+			providerConfig: resolveCompactionProviderConfig(
+				input.config,
+				input.providerSettingsManager,
+			),
+			providerId: input.config.providerId,
+			modelId: input.config.modelId,
+			compaction: {
+				...input.config.compaction,
+				enabled: true,
+			},
+			logger: input.config.logger,
+			// Forward telemetry + sessionId so manual compactions emit
+			// `task.compaction_executed` / `task.compaction_skipped` events
+			// alongside auto compactions.
+			telemetry: input.config.telemetry,
+			sessionId: input.sessionId,
+		},
+		{ mode: "manual" },
+	);
+	if (!compact) {
+		return { compacted: false, canonicalMessages: input.messages };
+	}
+	// Manual compaction intentionally summarizes the full canonical transcript
+	// instead of reusing a prior sidecar summary, which avoids summary-of-summary
+	// drift across repeated `/compact` calls.
+	const result = await compact({
+		agentId: "cli",
+		conversationId: input.sessionId,
+		parentAgentId: null,
+		iteration: 0,
+		messages: input.messages,
+		apiMessages: input.messages,
+		abortSignal: input.abortSignal ?? new AbortController().signal,
+		systemPrompt: "",
+		tools: [],
+		model: {
+			id: input.config.modelId,
+			provider: input.config.providerId,
+			info: {
+				...(modelInfo ?? {}),
+				id: modelInfo?.id ?? input.config.modelId,
+				maxInputTokens: maxInputTokens,
+			},
+		},
+	});
+	if (!result?.messages) {
+		return { compacted: false, canonicalMessages: input.messages };
+	}
+	return {
+		compacted: true,
+		canonicalMessages: input.messages,
+		compactionState: createSessionCompactionState({
+			sourceMessages: input.messages,
+			compactedMessages: result.messages,
+			conversationId: input.sessionId,
+			systemPrompt: result.systemPrompt,
+		}),
+	};
+}
diff --git a/apps/cli/src/runtime/interactive/config-data.test.ts b/apps/cli/src/runtime/interactive/config-data.test.ts
new file mode 100644
index 0000000..e46f774
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/config-data.test.ts
@@ -0,0 +1,1062 @@
+import {
+	chmod,
+	mkdir,
+	mkdtemp,
+	readFile,
+	rm,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { UserInstructionConfigService } from "@cline/core";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	buildSlashCommandRegistry,
+	expandUserCommandPrompt,
+} from "../../tui/commands/slash-command-registry";
+import {
+	applyPluginFailures,
+	type InteractiveConfigItem,
+} from "../../tui/interactive-config";
+import type { Config } from "../../utils/types";
+import { createInteractiveConfigDataLoader } from "./config-data";
+
+function createConfig(cwd: string): Config {
+	return {
+		apiKey: "test-key",
+		cwd,
+		workspaceRoot: cwd,
+		systemPrompt: "",
+		modelId: "test-model",
+		providerId: "test-provider",
+		mode: "act",
+		verbose: false,
+		sandbox: false,
+		thinking: false,
+		outputMode: "text",
+		defaultToolAutoApprove: false,
+		toolPolicies: { "*": { autoApprove: false } },
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+	};
+}
+
+describe("interactive config data loader", () => {
+	const tempRoots: string[] = [];
+	const envSnapshot = {
+		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
+		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
+	};
+
+	afterEach(async () => {
+		if (envSnapshot.CLINE_GLOBAL_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH =
+				envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
+		}
+		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
+		}
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	async function writeSettingsPlugin(tempRoot: string): Promise<string> {
+		const pluginsDir = join(tempRoot, ".cline", "plugins");
+		await mkdir(pluginsDir, { recursive: true });
+		const pluginPath = join(pluginsDir, "settings-plugin.js");
+		await writeFile(
+			pluginPath,
+			[
+				"export default {",
+				"  name: 'settings-plugin',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup(api) {",
+				"    api.registerTool({",
+				"      name: 'settings_plugin_tool',",
+				"      description: 'Settings plugin tool',",
+				"      inputSchema: { type: 'object', properties: {} },",
+				"      execute: async () => 'ok',",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+		);
+		return pluginPath;
+	}
+
+	async function writeMcpSettingsPlugin(tempRoot: string): Promise<string> {
+		const pluginsDir = join(tempRoot, ".cline", "plugins");
+		await mkdir(pluginsDir, { recursive: true });
+		const pluginPath = join(pluginsDir, "settings-mcp-plugin.js");
+		await writeFile(
+			pluginPath,
+			[
+				"export default {",
+				"  name: 'settings-mcp-plugin',",
+				"  manifest: { capabilities: ['mcp'] },",
+				"  setup(api) {",
+				"    api.registerMcpServer({",
+				"      name: 'smoke',",
+				"      transport: { type: 'stdio', command: process.execPath, args: ['-e', 'process.exit(0)'] },",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+		);
+		return pluginPath;
+	}
+
+	it("toggles a skill item to the opposite enabled state and refreshes before reload", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const skillPath = join(tempRoot, "SKILL.md");
+		await writeFile(
+			skillPath,
+			`---
+name: skill-one
+---
+Use this skill.`,
+		);
+
+		const calls: string[] = [];
+		let refreshed = false;
+		const userInstructionService = {
+			async refreshType(type: string) {
+				calls.push(`refreshType:${type}`);
+				refreshed = true;
+			},
+			listRuntimeCommands() {
+				calls.push("listRuntimeCommands");
+				return refreshed
+					? []
+					: [
+							{
+								name: "skill-one",
+								instructions: "Use this skill.",
+								description: "Skill one",
+								kind: "skill",
+							},
+						];
+			},
+			listRecords(type: string) {
+				calls.push(`listRecords:${type}`);
+				if (type !== "skill") {
+					return [];
+				}
+				return [
+					{
+						id: "skill-one",
+						type: "skill",
+						filePath: skillPath,
+						item: {
+							name: "skill-one",
+							disabled: refreshed,
+							description: "Skill one",
+							instructions: "Use this skill.",
+							frontmatter: {},
+						},
+					},
+				];
+			},
+		} as unknown as UserInstructionConfigService;
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+			userInstructionService,
+		});
+		const item: InteractiveConfigItem = {
+			id: "skill-one",
+			name: "skill-one",
+			path: skillPath,
+			enabled: true,
+			source: "workspace",
+			kind: "skill",
+		};
+
+		const data = await loader.onToggleConfigItem(item);
+		const written = await readFile(skillPath, "utf8");
+
+		expect(written).toContain("disabled: true");
+		expect(data?.skills[0]?.enabled).toBe(false);
+		expect(
+			data?.workflowSlashCommands.map((command) => command.name),
+		).not.toContain("skill-one");
+		expect(calls).toContain("refreshType:skill");
+		expect(calls.lastIndexOf("listRecords:skill")).toBeGreaterThan(
+			calls.indexOf("refreshType:skill"),
+		);
+	});
+
+	it("returns refreshed slash commands so disabled skills stop expanding before submit", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const skillPath = join(tempRoot, "SKILL.md");
+		await writeFile(
+			skillPath,
+			`---
+name: find-skills
+---
+Find installable skills.`,
+		);
+
+		let refreshed = false;
+		const userInstructionService = {
+			async refreshType() {
+				refreshed = true;
+			},
+			listRuntimeCommands() {
+				return refreshed
+					? []
+					: [
+							{
+								name: "find-skills",
+								instructions: "Find installable skills.",
+								description: "Find skills",
+								kind: "skill",
+							},
+						];
+			},
+			listRecords(type: string) {
+				if (type !== "skill") {
+					return [];
+				}
+				return [
+					{
+						id: "find-skills",
+						type: "skill",
+						filePath: skillPath,
+						item: {
+							name: "find-skills",
+							disabled: refreshed,
+							description: "Find skills",
+							instructions: "Find installable skills.",
+							frontmatter: {},
+						},
+					},
+				];
+			},
+		} as unknown as UserInstructionConfigService;
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+			userInstructionService,
+		});
+		const initialData = await loader.loadConfigData();
+		const initialRegistry = buildSlashCommandRegistry({
+			workflowSlashCommands: initialData.workflowSlashCommands,
+		});
+
+		expect(
+			expandUserCommandPrompt("/find-skills what can u do?", initialRegistry),
+		).toContain("<user_command");
+
+		const nextData = await loader.onToggleConfigItem({
+			id: "find-skills",
+			name: "find-skills",
+			path: skillPath,
+			enabled: true,
+			source: "workspace",
+			kind: "skill",
+		});
+		const refreshedRegistry = buildSlashCommandRegistry({
+			workflowSlashCommands: nextData?.workflowSlashCommands,
+		});
+
+		expect(
+			nextData?.workflowSlashCommands.map((command) => command.name),
+		).not.toContain("find-skills");
+		expect(
+			expandUserCommandPrompt("/find-skills what can u do?", refreshedRegistry),
+		).toBe("/find-skills what can u do?");
+	});
+
+	it("keeps plugin tool toggle behavior", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const pluginToolPath = join(tempRoot, "plugin-tool.js");
+		await writeFile(pluginToolPath, "export {};\n");
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+		const item: InteractiveConfigItem = {
+			id: "plugin:tool:path",
+			name: "plugin-tool",
+			path: pluginToolPath,
+			enabled: true,
+			source: "workspace-plugin",
+			kind: "tool",
+		};
+
+		const data = await loader.onToggleConfigItem(item);
+		const settings = JSON.parse(
+			await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
+		) as { disabledTools?: string[] };
+
+		expect(settings.disabledTools).toEqual(["plugin-tool"]);
+		expect(data).toBeUndefined();
+	});
+
+	it("can skip plugin tool imports for fast settings open", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const pluginPath = await writeSettingsPlugin(tempRoot);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData({ includePluginTools: false });
+
+		expect(data.plugins.some((item) => item.path === pluginPath)).toBe(true);
+		expect(
+			data.tools.some((item) => item.pluginName === "settings-plugin"),
+		).toBe(false);
+	});
+
+	it("loads plugin tools when requested", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		await writeSettingsPlugin(tempRoot);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData({ includePluginTools: true });
+
+		expect(
+			data.tools.some(
+				(item) =>
+					item.pluginName === "settings-plugin" &&
+					item.name === "settings_plugin_tool",
+			),
+		).toBe(true);
+	});
+
+	it("loads plugin-owned MCP servers from settings", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					mcpServers: {
+						smoke: {
+							transport: {
+								type: "stdio",
+								command: process.execPath,
+								args: ["-e", "process.exit(0)"],
+							},
+							metadata: {
+								source: "plugin",
+								pluginName: "settings-mcp-plugin",
+								pluginPath,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData({ includePluginTools: true });
+
+		expect(
+			data.mcp.some(
+				(item) =>
+					item.name === "smoke" &&
+					item.pluginName === "settings-mcp-plugin" &&
+					item.pluginPath === pluginPath &&
+					item.kind === "mcp",
+			),
+		).toBe(true);
+	});
+
+	it("does not load plugin MCP rows directly from plugin diagnostics", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData({ includePluginTools: true });
+
+		expect(data.plugins.some((item) => item.path === pluginPath)).toBe(true);
+		expect(data.mcp.some((item) => item.pluginPath === pluginPath)).toBe(false);
+	});
+
+	it("keeps failed plugins visible with their load error", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const pluginsDir = join(tempRoot, ".cline", "plugins");
+		await mkdir(pluginsDir, { recursive: true });
+		const pluginPath = join(pluginsDir, "broken-plugin.js");
+		const invalidPluginPath = join(pluginsDir, "invalid-plugin.js");
+		await writeFile(
+			pluginPath,
+			[
+				"export default {",
+				"  name: 'broken-plugin',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup() {",
+				"    throw new Error('setup exploded');",
+				"  },",
+				"};",
+			].join("\n"),
+		);
+		await writeFile(invalidPluginPath, "export default {};\n", "utf8");
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData({ includePluginTools: true });
+		const plugin = data.plugins.find((item) => item.path === pluginPath);
+
+		expect(plugin?.name).toBe("broken-plugin");
+		expect(plugin?.loadErrorPhase).toBe("setup");
+		expect(plugin?.loadError).toContain("setup failed: setup exploded");
+
+		const invalidPlugin = data.plugins.find(
+			(item) => item.path === invalidPluginPath,
+		);
+		expect(invalidPlugin?.name).toBe("invalid-plugin");
+		expect(invalidPlugin?.loadErrorPhase).toBe("load");
+		expect(invalidPlugin?.loadError).toContain("load failed:");
+	});
+
+	it("preserves multiple load failures for the same plugin path", () => {
+		const plugin: InteractiveConfigItem = {
+			id: "/tmp/plugin.js",
+			name: "plugin",
+			path: "/tmp/plugin.js",
+			enabled: true,
+			kind: "plugin",
+			source: "workspace-plugin",
+		};
+
+		applyPluginFailures(
+			[plugin],
+			[
+				{
+					pluginPath: "/tmp/plugin.js",
+					pluginName: "plugin",
+					phase: "setup",
+					message: "first failure",
+				},
+				{
+					pluginPath: "/tmp/plugin.js",
+					phase: "setup",
+					message: "second failure",
+				},
+			],
+		);
+
+		expect(plugin.loadError).toBe(
+			"setup failed: first failure\nsetup failed: second failure",
+		);
+		expect(plugin.loadErrorPhase).toBeUndefined();
+	});
+
+	it("toggles every SDK tool name for a displayed built-in tool", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+		const item: InteractiveConfigItem = {
+			id: "editor",
+			name: "editor",
+			path: "editor, apply_patch",
+			enabled: true,
+			source: "builtin",
+			kind: "tool",
+			configKind: "tool",
+			toolNames: ["editor", "apply_patch"],
+		};
+
+		await loader.onToggleConfigItem(item);
+		const settings = JSON.parse(
+			await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
+		) as { disabledTools?: string[] };
+
+		expect(settings.disabledTools).toEqual(["apply_patch", "editor"]);
+	});
+
+	it("loads and toggles plugin enabled state from global settings", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const pluginsDir = join(tempRoot, ".cline", "plugins");
+		await mkdir(pluginsDir, { recursive: true });
+		const pluginPath = join(pluginsDir, "workspace-plugin.js");
+		await writeFile(pluginPath, "export default {};\n");
+		await writeFile(
+			process.env.CLINE_GLOBAL_SETTINGS_PATH,
+			JSON.stringify({ disabledPlugins: [pluginPath] }, null, 2),
+		);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData();
+		const plugin = data.plugins.find((item) => item.path === pluginPath);
+		expect(plugin?.enabled).toBe(false);
+		if (!plugin) {
+			throw new Error("Expected workspace plugin to be listed");
+		}
+
+		const nextData = await loader.onToggleConfigItem(plugin);
+		const refreshedData = await loader.loadConfigData();
+		const settings = JSON.parse(
+			await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
+		) as { disabledPlugins?: string[] };
+
+		expect(settings.disabledPlugins).toBeUndefined();
+		expect(nextData).toBeUndefined();
+		expect(
+			refreshedData.plugins.find((item) => item.path === pluginPath)?.enabled,
+		).toBe(true);
+	});
+
+	it("deletes a package-backed plugin and refreshes bundled slash commands", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const packageDir = join(tempRoot, ".cline", "plugins", "delete-plugin");
+		const pluginPath = join(packageDir, "index.ts");
+		const skillPath = join(packageDir, "skills", "erase", "SKILL.md");
+		await mkdir(join(packageDir, "skills", "erase"), { recursive: true });
+		await writeFile(
+			join(packageDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "delete-plugin",
+					cline: {
+						plugins: [{ paths: ["./index.ts"] }],
+					},
+				},
+				null,
+				2,
+			),
+		);
+		await writeFile(pluginPath, "export default {};\n");
+		await writeFile(
+			skillPath,
+			`---
+name: erase
+---
+Erase stale plugin commands.`,
+		);
+		await writeFile(
+			process.env.CLINE_GLOBAL_SETTINGS_PATH,
+			JSON.stringify({ disabledPlugins: [pluginPath] }, null, 2),
+		);
+		const refreshCalls: string[] = [];
+		let refreshed = false;
+		const userInstructionService = {
+			async refreshType(type: string) {
+				refreshCalls.push(type);
+				refreshed = true;
+			},
+			listRuntimeCommands() {
+				return refreshed
+					? []
+					: [
+							{
+								name: "erase",
+								instructions: "Erase stale plugin commands.",
+								description: "Erase",
+								kind: "skill",
+							},
+						];
+			},
+			listRecords(type: string) {
+				if (type !== "skill") {
+					return [];
+				}
+				return [
+					{
+						id: "erase",
+						type: "skill",
+						filePath: skillPath,
+						item: {
+							name: "erase",
+							disabled: false,
+							description: "Erase",
+							instructions: "Erase stale plugin commands.",
+							frontmatter: {},
+						},
+					},
+				];
+			},
+		} as unknown as UserInstructionConfigService;
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+			userInstructionService,
+		});
+		const data = await loader.loadConfigData({ includePluginTools: false });
+		const plugin = data.plugins.find((item) => item.path === pluginPath);
+		if (!plugin) {
+			throw new Error("Expected package plugin to be listed");
+		}
+
+		const nextData = await loader.onDeleteConfigItem(plugin, {
+			includePluginTools: false,
+		});
+		const settings = JSON.parse(
+			await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
+		) as { disabledPlugins?: string[] };
+
+		await expect(readFile(pluginPath, "utf8")).rejects.toThrow();
+		await expect(readFile(skillPath, "utf8")).rejects.toThrow();
+		expect(settings.disabledPlugins).toBeUndefined();
+		expect(refreshCalls).toEqual(
+			expect.arrayContaining(["workflow", "rule", "skill"]),
+		);
+		expect(nextData?.plugins.some((item) => item.path === pluginPath)).toBe(
+			false,
+		);
+		expect(
+			nextData?.workflowSlashCommands.map((command) => command.name),
+		).not.toContain("erase");
+	});
+
+	it("uses the package name for package-backed plugin entries", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const packageDir = join(
+			tempRoot,
+			".cline",
+			"plugins",
+			"_installed",
+			"git",
+			"github.com",
+			"demo",
+			"package",
+		);
+		await mkdir(packageDir, { recursive: true });
+		const pluginPath = join(packageDir, "index.ts");
+		await writeFile(
+			join(packageDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "cline-sdk-portable-agents",
+					cline: {
+						plugins: [{ paths: ["./index.ts"] }],
+					},
+				},
+				null,
+				2,
+			),
+		);
+		await writeFile(pluginPath, "export default {};\n");
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData();
+		const plugin = data.plugins.find((item) => item.path === pluginPath);
+
+		expect(plugin?.name).toBe("cline-sdk-portable-agents");
+	});
+
+	it("marks bundled package skills with their plugin owner", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const installRoot = join(
+			tempRoot,
+			".cline",
+			"plugins",
+			"_installed",
+			"git",
+			"github.com",
+			"demo",
+		);
+		const packageDir = join(installRoot, "package");
+		const skillPath = join(packageDir, "skills", "review", "SKILL.md");
+		const pluginPath = join(packageDir, "index.ts");
+		await mkdir(join(packageDir, "skills", "review"), { recursive: true });
+		await writeFile(
+			join(installRoot, "package.json"),
+			JSON.stringify(
+				{
+					name: "cline-installed-plugin-demo",
+					cline: {
+						plugins: [{ paths: ["./package/index.ts"] }],
+					},
+				},
+				null,
+				2,
+			),
+		);
+		await writeFile(
+			join(packageDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "cline-sdk-portable-agents",
+				},
+				null,
+				2,
+			),
+		);
+		await writeFile(pluginPath, "export default {};\n");
+		await writeFile(
+			skillPath,
+			`---
+name: review
+---
+Review with the bundled skill.`,
+		);
+		const userInstructionService = {
+			listRuntimeCommands() {
+				return [];
+			},
+			listRecords(type: string) {
+				if (type !== "skill") {
+					return [];
+				}
+				return [
+					{
+						id: "review",
+						type: "skill",
+						filePath: skillPath,
+						item: {
+							name: "review",
+							disabled: false,
+							description: "Review code",
+							instructions: "Review with the bundled skill.",
+							frontmatter: {},
+						},
+					},
+				];
+			},
+		} as unknown as UserInstructionConfigService;
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+			userInstructionService,
+		});
+
+		const data = await loader.loadConfigData({ includePluginTools: false });
+		const skill = data.skills.find((item) => item.path === skillPath);
+
+		expect(skill).toMatchObject({
+			name: "review",
+			pluginName: "cline-sdk-portable-agents",
+			pluginPath,
+			source: "workspace-plugin",
+		});
+	});
+
+	it("toggles MCP server enabled state through core settings", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					otherSetting: true,
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "stdio",
+								command: "node",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData();
+		const item = data.mcp.find((candidate) => candidate.name === "docs");
+		expect(item?.enabled).toBe(true);
+
+		const nextData = item ? await loader.onToggleConfigItem(item) : undefined;
+		const settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			otherSetting?: boolean;
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+
+		expect(settings.otherSetting).toBe(true);
+		expect(settings.mcpServers?.docs?.disabled).toBe(true);
+		expect(
+			nextData?.mcp.find((candidate) => candidate.name === "docs")?.enabled,
+		).toBe(false);
+	});
+
+	it("disables and re-syncs plugin-owned MCP servers when toggling plugins", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					mcpServers: {
+						smoke: {
+							transport: {
+								type: "stdio",
+								command: process.execPath,
+								args: ["-e", "process.exit(0)"],
+							},
+							oauth: {
+								tokens: {
+									access_token: "token",
+								},
+							},
+							metadata: {
+								source: "plugin",
+								pluginName: "settings-mcp-plugin",
+								pluginPath,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+		const item: InteractiveConfigItem = {
+			id: pluginPath,
+			name: "settings-mcp-plugin",
+			path: pluginPath,
+			enabled: true,
+			source: "workspace-plugin",
+			kind: "plugin",
+		};
+
+		await loader.onToggleConfigItem(item);
+		let settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<
+				string,
+				{ disabled?: boolean; oauth?: { tokens?: Record<string, string> } }
+			>;
+		};
+		expect(settings.mcpServers?.smoke?.disabled).toBe(true);
+		expect(settings.mcpServers?.smoke?.oauth?.tokens?.access_token).toBe(
+			"token",
+		);
+
+		await loader.onToggleConfigItem({ ...item, enabled: false });
+		settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<
+				string,
+				{ disabled?: boolean; oauth?: { tokens?: Record<string, string> } }
+			>;
+		};
+		expect(settings.mcpServers?.smoke?.disabled).toBeUndefined();
+		expect(settings.mcpServers?.smoke?.oauth?.tokens?.access_token).toBe(
+			"token",
+		);
+	});
+
+	it.skipIf(process.platform === "win32")(
+		"does not mark plugin disabled when MCP disable write fails",
+		async () => {
+			const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+			tempRoots.push(tempRoot);
+			const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+			const globalSettingsPath = join(tempRoot, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = globalSettingsPath;
+			process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+			const pluginPath = await writeMcpSettingsPlugin(tempRoot);
+			await writeFile(
+				settingsPath,
+				`${JSON.stringify(
+					{
+						mcpServers: {
+							smoke: {
+								transport: {
+									type: "stdio",
+									command: process.execPath,
+									args: ["-e", "process.exit(0)"],
+								},
+								metadata: {
+									source: "plugin",
+									pluginName: "settings-mcp-plugin",
+									pluginPath,
+								},
+							},
+						},
+					},
+					null,
+					2,
+				)}\n`,
+			);
+			await chmod(settingsPath, 0o444);
+			const loader = createInteractiveConfigDataLoader({
+				config: createConfig(tempRoot),
+			});
+
+			try {
+				await expect(
+					loader.onToggleConfigItem({
+						id: pluginPath,
+						name: "settings-mcp-plugin",
+						path: pluginPath,
+						enabled: true,
+						source: "workspace-plugin",
+						kind: "plugin",
+					}),
+				).rejects.toThrow();
+			} finally {
+				await chmod(settingsPath, 0o644);
+			}
+
+			await expect(readFile(globalSettingsPath, "utf8")).rejects.toThrow();
+			const settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
+				mcpServers?: Record<string, { disabled?: boolean }>;
+			};
+			expect(settings.mcpServers?.smoke?.disabled).toBeUndefined();
+		},
+	);
+
+	it("surfaces MCP OAuth status and errors", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					mcpServers: {
+						linear: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.linear.app/mcp",
+							},
+							oauth: {
+								lastError: "OAuth authorization failed",
+							},
+						},
+						docs: {
+							transport: {
+								type: "sse",
+								url: "https://mcp.example.com/sse",
+							},
+							oauth: {
+								tokens: {
+									access_token: "token",
+								},
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+
+		const data = await loader.loadConfigData();
+		const linear = data.mcp.find((item) => item.name === "linear");
+		const docs = data.mcp.find((item) => item.name === "docs");
+
+		expect(linear?.description).toBe("streamableHttp, oauth error");
+		expect(linear?.loadError).toBe("OAuth authorization failed");
+		expect(docs?.description).toBe("sse, oauth authorized");
+		expect(docs?.loadError).toBeUndefined();
+	});
+
+	it("does not toggle workflow items", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		const workflowPath = join(tempRoot, "workflow.md");
+		await writeFile(workflowPath, "Run this workflow.");
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+		const item: InteractiveConfigItem = {
+			id: "workflow-one",
+			name: "workflow-one",
+			path: workflowPath,
+			enabled: true,
+			source: "workspace",
+			kind: "workflow",
+		};
+
+		await expect(loader.onToggleConfigItem(item)).resolves.toBeUndefined();
+		expect(await readFile(workflowPath, "utf8")).toBe("Run this workflow.");
+	});
+
+	it("returns undefined for non-toggleable items", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
+		tempRoots.push(tempRoot);
+		await mkdir(join(tempRoot, "hooks"));
+		const hookPath = join(tempRoot, "hooks", "hook.json");
+		await writeFile(hookPath, "{}");
+		const loader = createInteractiveConfigDataLoader({
+			config: createConfig(tempRoot),
+		});
+		const item: InteractiveConfigItem = {
+			id: hookPath,
+			name: "hook.json",
+			path: hookPath,
+			enabled: true,
+			source: "workspace",
+			kind: "hook",
+		};
+
+		await expect(loader.onToggleConfigItem(item)).resolves.toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/config-data.ts b/apps/cli/src/runtime/interactive/config-data.ts
new file mode 100644
index 0000000..7d05961
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/config-data.ts
@@ -0,0 +1,171 @@
+import {
+	createCoreSettingsService,
+	disablePluginMcpServersInSettings,
+	setDisabledPlugin,
+	setDisabledTools,
+	syncPluginMcpServersToSettings,
+	type UserInstructionConfigService,
+	uninstallPlugin,
+} from "@cline/core";
+import {
+	type InteractiveConfigData,
+	type InteractiveConfigItem,
+	type LoadInteractiveConfigDataOptions,
+	loadInteractiveConfigData,
+} from "../../tui/interactive-config";
+import type { Config } from "../../utils/types";
+
+export function createInteractiveConfigDataLoader(input: {
+	config: Config;
+	userInstructionService?: UserInstructionConfigService;
+}) {
+	const workspaceRoot = () =>
+		input.config.workspaceRoot?.trim() || input.config.cwd;
+	const availabilityContext = () => ({
+		mode: input.config.mode,
+		modelId: input.config.modelId,
+		providerId: input.config.providerId,
+		enableSpawnAgent: input.config.enableSpawnAgent,
+		enableAgentTeams: input.config.enableAgentTeams,
+	});
+	const loadConfigData = async (
+		options: LoadInteractiveConfigDataOptions = {},
+	): Promise<InteractiveConfigData> =>
+		await loadInteractiveConfigData({
+			userInstructionService: input.userInstructionService,
+			cwd: input.config.cwd,
+			workspaceRoot: workspaceRoot(),
+			availabilityContext: availabilityContext(),
+			includePluginTools: options.includePluginTools,
+		});
+
+	const refreshUserInstructionConfigs = async (): Promise<void> => {
+		const service = input.userInstructionService;
+		if (!service) {
+			return;
+		}
+		await Promise.all([
+			service.refreshType("workflow"),
+			service.refreshType("rule"),
+			service.refreshType("skill"),
+		]);
+	};
+
+	const onToggleConfigItem = async (
+		item: InteractiveConfigItem,
+		options: LoadInteractiveConfigDataOptions = {},
+	): Promise<InteractiveConfigData | undefined> => {
+		const settings = createCoreSettingsService();
+		if (item.kind === "skill" && typeof item.enabled === "boolean") {
+			await settings.toggle({
+				type: "skills",
+				id: item.id,
+				path: item.path,
+				name: item.name,
+				enabled: !item.enabled,
+				cwd: input.config.cwd,
+				workspaceRoot: workspaceRoot(),
+				userInstructionService: input.userInstructionService,
+				availabilityContext: availabilityContext(),
+			});
+			return await loadConfigData(options);
+		}
+
+		if (item.kind === "plugin" && typeof item.enabled === "boolean") {
+			if (item.enabled) {
+				disablePluginMcpServersInSettings({ pluginPaths: [item.path] });
+				setDisabledPlugin(item.path, true);
+			} else {
+				const ownedMcpMutations = disablePluginMcpServersInSettings({
+					pluginPaths: [item.path],
+				});
+				const result = await syncPluginMcpServersToSettings({
+					pluginPaths: [item.path],
+					cwd: input.config.cwd,
+					workspacePath: workspaceRoot(),
+					providerId: input.config.providerId,
+					modelId: input.config.modelId,
+				});
+				if (ownedMcpMutations.length > 0 && result.failures.length > 0) {
+					throw new Error(
+						`Failed to sync plugin MCP servers: ${result.failures
+							.map((failure) => {
+								const plugin = failure.pluginName ?? failure.pluginPath;
+								return `${plugin}: ${failure.message}`;
+							})
+							.join("; ")}`,
+					);
+				}
+				setDisabledPlugin(item.path, false);
+			}
+			return undefined;
+		}
+
+		if (item.kind === "mcp" && typeof item.enabled === "boolean") {
+			await settings.toggle({
+				type: "mcp",
+				id: item.id,
+				path: item.path,
+				name: item.name,
+				enabled: !item.enabled,
+				cwd: input.config.cwd,
+				workspaceRoot: workspaceRoot(),
+				availabilityContext: availabilityContext(),
+			});
+			return await loadConfigData(options);
+		}
+
+		if (
+			item.kind !== "tool" ||
+			(item.source !== "builtin" &&
+				item.source !== "workspace-plugin" &&
+				item.source !== "global-plugin")
+		) {
+			return undefined;
+		}
+		const rawToolNames =
+			item.toolNames && item.toolNames.length > 0
+				? item.toolNames
+				: [item.name];
+		const toolNames = [...new Set(rawToolNames.filter(Boolean))];
+		if (typeof item.enabled === "boolean") {
+			setDisabledTools(toolNames, item.enabled);
+			return undefined;
+		}
+
+		for (const name of toolNames) {
+			await settings.toggle({
+				type: "tools",
+				name,
+				cwd: input.config.cwd,
+				workspaceRoot: workspaceRoot(),
+				userInstructionService: input.userInstructionService,
+				availabilityContext: availabilityContext(),
+			});
+		}
+		return undefined;
+	};
+
+	const onDeleteConfigItem = async (
+		item: InteractiveConfigItem,
+		options: LoadInteractiveConfigDataOptions = {},
+	): Promise<InteractiveConfigData | undefined> => {
+		if (item.kind !== "plugin") {
+			return undefined;
+		}
+		await uninstallPlugin({
+			path: item.path,
+			name: item.name,
+			cwd: input.config.cwd,
+			workspaceRoot: workspaceRoot(),
+		});
+		await refreshUserInstructionConfigs();
+		return await loadConfigData(options);
+	};
+
+	return {
+		loadConfigData,
+		onToggleConfigItem,
+		onDeleteConfigItem,
+	};
+}
diff --git a/apps/cli/src/runtime/interactive/exit-summary.test.ts b/apps/cli/src/runtime/interactive/exit-summary.test.ts
new file mode 100644
index 0000000..75e91f3
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/exit-summary.test.ts
@@ -0,0 +1,118 @@
+import type { SessionRecord } from "@cline/core";
+import { describe, expect, it } from "vitest";
+import {
+	createInteractiveExitSummary,
+	formatInteractiveExitSummary,
+} from "./exit-summary";
+
+function makeSessionRecord(
+	overrides: Partial<SessionRecord> = {},
+): SessionRecord {
+	return {
+		sessionId: "sess_123",
+		source: "cli",
+		pid: 123,
+		startedAt: "2026-04-29T10:00:00.000Z",
+		endedAt: null,
+		exitCode: null,
+		status: "running",
+		interactive: true,
+		provider: "cline",
+		model: "openai/gpt-5.3-codex",
+		cwd: "/tmp/project",
+		workspaceRoot: "/tmp/project",
+		enableTools: true,
+		enableSpawn: true,
+		enableTeams: false,
+		isSubagent: false,
+		metadata: { totalCost: 0.125 },
+		messagesPath: "/tmp/project/sess_123.messages.json",
+		updatedAt: "2026-04-29T10:01:00.000Z",
+		...overrides,
+	};
+}
+
+describe("interactive exit summary", () => {
+	it("skips sessions that were never persisted and have no messages", () => {
+		const summary = createInteractiveExitSummary({
+			sessionId: "sess_empty",
+			row: makeSessionRecord({ messagesPath: undefined }),
+			messages: [],
+		});
+
+		expect(summary).toBeUndefined();
+	});
+
+	it("creates a summary from persisted session information", () => {
+		const summary = createInteractiveExitSummary({
+			sessionId: "sess_123",
+			row: makeSessionRecord(),
+			messages: [
+				{ role: "user", content: "hello" },
+				{ role: "assistant", content: "hi" },
+			],
+			usage: {
+				inputTokens: 100,
+				outputTokens: 50,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				totalCost: 0.25,
+			},
+		});
+
+		expect(summary).toEqual({
+			sessionId: "sess_123",
+			startedAt: "2026-04-29T10:00:00.000Z",
+			provider: "cline",
+			model: "openai/gpt-5.3-codex",
+			cwd: "/tmp/project",
+			messageCount: 2,
+			totalCost: 0.25,
+		});
+	});
+
+	it("formats the continue command for graceful TUI shutdown", () => {
+		const output = formatInteractiveExitSummary({
+			sessionId: "sess_123",
+			startedAt: "2026-04-29T10:00:00.000Z",
+			provider: "cline",
+			model: "openai/gpt-5.3-codex",
+			cwd: "/tmp/project",
+			messageCount: 2,
+			totalCost: 0.25,
+		});
+
+		expect(output).toContain("Session Summary");
+		expect(output).toContain("  ID        sess_123");
+		expect(output).toContain("  Model     cline:openai/gpt-5.3-codex");
+		expect(output).toContain("  Messages  2");
+		expect(output).toContain("  Cost      $0.250000");
+		expect(output).toContain("  Continue  ");
+		expect(output).toContain("cline --id sess_123");
+	});
+
+	it("formats an invalid start time without leaking NaN", () => {
+		const output = formatInteractiveExitSummary({
+			sessionId: "sess_123",
+			startedAt: "not-a-date",
+			messageCount: 1,
+		});
+
+		expect(output).toContain("  Duration  0s");
+		expect(output).not.toContain("NaN");
+	});
+
+	it("omits cost for subscription-backed providers", () => {
+		const output = formatInteractiveExitSummary({
+			sessionId: "sess_123",
+			startedAt: "2026-04-29T10:00:00.000Z",
+			provider: "openai-codex",
+			model: "gpt-5.4",
+			messageCount: 2,
+			totalCost: 0.25,
+		});
+
+		expect(output).not.toContain("  Cost");
+		expect(output).not.toContain("$0.250000");
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/exit-summary.ts b/apps/cli/src/runtime/interactive/exit-summary.ts
new file mode 100644
index 0000000..814c7fc
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/exit-summary.ts
@@ -0,0 +1,100 @@
+import type { SessionAccumulatedUsage, SessionRecord } from "@cline/core";
+import type { Message } from "@cline/shared";
+import { c, formatUsd } from "../../utils/output";
+import { shouldShowCliUsageCost } from "../../utils/usage-cost-display";
+
+export interface InteractiveExitSummary {
+	sessionId: string;
+	startedAt?: string;
+	provider?: string;
+	model?: string;
+	cwd?: string;
+	messageCount: number;
+	totalCost?: number;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function trim(value: string | null | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function providerModel(summary: InteractiveExitSummary): string | undefined {
+	const provider = trim(summary.provider);
+	const model = trim(summary.model);
+	if (provider && model) return `${provider}:${model}`;
+	return provider ?? model;
+}
+
+function formatDuration(startedAt: string | undefined): string {
+	if (!startedAt) {
+		return "0s";
+	}
+	const startedAtMs = new Date(startedAt).getTime();
+	if (!Number.isFinite(startedAtMs)) {
+		return "0s";
+	}
+	return `${Math.max(0, Math.round((Date.now() - startedAtMs) / 1000))}s`;
+}
+
+export function createInteractiveExitSummary(input: {
+	sessionId: string;
+	row?: SessionRecord;
+	messages?: Message[];
+	usage?: SessionAccumulatedUsage;
+}): InteractiveExitSummary | undefined {
+	const sessionId = trim(input.sessionId);
+	if (!sessionId) {
+		return undefined;
+	}
+
+	const messageCount = input.messages?.length ?? 0;
+	const messagesPath = trim(input.row?.messagesPath);
+	if (!messagesPath && messageCount === 0) {
+		return undefined;
+	}
+
+	const totalCost =
+		asFiniteNumber(input.usage?.totalCost) ??
+		asFiniteNumber(input.row?.metadata?.aggregatedAgentsCost) ??
+		asFiniteNumber(input.row?.metadata?.totalCost);
+
+	return {
+		sessionId,
+		startedAt: trim(input.row?.startedAt),
+		provider: trim(input.row?.provider),
+		model: trim(input.row?.model),
+		cwd: trim(input.row?.cwd),
+		messageCount,
+		...(totalCost !== undefined ? { totalCost } : {}),
+	};
+}
+
+export function formatInteractiveExitSummary(
+	summary: InteractiveExitSummary,
+): string {
+	const model = providerModel(summary);
+	const showUsageCost = summary.provider
+		? shouldShowCliUsageCost(summary.provider)
+		: true;
+	const lines = [
+		"",
+		"Session Summary",
+		`  ID        ${summary.sessionId}`,
+		`  Duration  ${formatDuration(summary.startedAt)}`,
+		model ? `  Model     ${model}` : undefined,
+		summary.cwd ? `  CWD       ${summary.cwd}` : undefined,
+		`  Messages  ${summary.messageCount.toLocaleString()}`,
+		showUsageCost && typeof summary.totalCost === "number"
+			? `  Cost      ${formatUsd(summary.totalCost)}`
+			: undefined,
+		`  Continue  ${c.cyan}cline --id ${summary.sessionId}${c.reset}`,
+		"",
+	];
+	return lines.filter((line): line is string => line !== undefined).join("\n");
+}
diff --git a/apps/cli/src/runtime/interactive/fork/metadata.test.ts b/apps/cli/src/runtime/interactive/fork/metadata.test.ts
new file mode 100644
index 0000000..4361ee5
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/fork/metadata.test.ts
@@ -0,0 +1,52 @@
+import { SessionSource } from "@cline/core";
+import type { Message } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { buildForkSessionMetadata } from "./metadata";
+
+describe("buildForkSessionMetadata", () => {
+	it("copies source metadata, replaces fork lineage, and writes a fork title", () => {
+		const messages = [
+			{
+				role: "user",
+				content: "Fallback title",
+			},
+		] satisfies Message[];
+
+		const metadata = buildForkSessionMetadata({
+			forkedFromSessionId: "sess_source",
+			forkedAt: "2026-04-29T16:00:00.000Z",
+			sourceSession: {
+				source: SessionSource.CLI,
+				prompt: "Prompt title",
+				metadata: {
+					title: "Source title",
+					totalCost: 1.25,
+					checkpoint: {
+						latest: {
+							ref: "abc123",
+							runCount: 2,
+						},
+					},
+					fork: {
+						forkedFromSessionId: "older_source",
+					},
+				},
+			},
+			messages,
+		});
+
+		expect(metadata.title).toBe("Source title (fork)");
+		expect(metadata.totalCost).toBe(1.25);
+		expect(metadata.fork).toEqual({
+			forkedFromSessionId: "sess_source",
+			forkedAt: "2026-04-29T16:00:00.000Z",
+			source: SessionSource.CLI,
+			checkpoints: {
+				latest: {
+					ref: "abc123",
+					runCount: 2,
+				},
+			},
+		});
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/fork/metadata.ts b/apps/cli/src/runtime/interactive/fork/metadata.ts
new file mode 100644
index 0000000..9b77468
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/fork/metadata.ts
@@ -0,0 +1,47 @@
+import { SessionSource } from "@cline/core";
+import type { Message } from "@cline/shared";
+import { deriveForkSessionTitle } from "./title";
+
+type SourceSession = {
+	source?: SessionSource;
+	prompt?: string | null;
+	metadata?: Record<string, unknown> | null;
+};
+
+export function buildForkSessionMetadata(input: {
+	forkedFromSessionId: string;
+	forkedAt: string;
+	sourceSession?: SourceSession;
+	messages: Message[];
+}): Record<string, unknown> {
+	const forkMetadata: Record<string, unknown> = {};
+	const sourceMetadata = input.sourceSession?.metadata ?? undefined;
+
+	if (sourceMetadata) {
+		for (const [key, value] of Object.entries(sourceMetadata)) {
+			if (key !== "fork") {
+				forkMetadata[key] = value;
+			}
+		}
+	}
+
+	const checkpointMetadata = sourceMetadata?.checkpoint;
+	forkMetadata.fork = {
+		forkedFromSessionId: input.forkedFromSessionId,
+		forkedAt: input.forkedAt,
+		source: input.sourceSession?.source ?? SessionSource.CLI,
+		...(checkpointMetadata !== undefined
+			? { checkpoints: checkpointMetadata }
+			: {}),
+	};
+	forkMetadata.title = deriveForkSessionTitle({
+		sourceTitle:
+			typeof sourceMetadata?.title === "string"
+				? sourceMetadata.title
+				: undefined,
+		sourcePrompt: input.sourceSession?.prompt,
+		messages: input.messages,
+	});
+
+	return forkMetadata;
+}
diff --git a/apps/cli/src/runtime/interactive/fork/title.test.ts b/apps/cli/src/runtime/interactive/fork/title.test.ts
new file mode 100644
index 0000000..dcdd110
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/fork/title.test.ts
@@ -0,0 +1,52 @@
+import type { Message } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { deriveForkSessionTitle } from "./title";
+
+describe("deriveForkSessionTitle", () => {
+	it("appends a fork suffix to the source title", () => {
+		expect(
+			deriveForkSessionTitle({
+				sourceTitle: "Investigate history picker",
+				messages: [],
+			}),
+		).toBe("Investigate history picker (fork)");
+	});
+
+	it("keeps appending fork suffixes for repeated forks", () => {
+		expect(
+			deriveForkSessionTitle({
+				sourceTitle: "Investigate history picker (fork)",
+				messages: [],
+			}),
+		).toBe("Investigate history picker (fork) (fork)");
+	});
+
+	it("derives the fork title from the first user message when needed", () => {
+		const messages = [
+			{
+				role: "user",
+				content: '<user_input mode="act">Fix the CLI history UX</user_input>',
+			},
+			{
+				role: "assistant",
+				content: "Working on it.",
+			},
+		] satisfies Message[];
+
+		expect(
+			deriveForkSessionTitle({
+				messages,
+			}),
+		).toBe("Fix the CLI history UX (fork)");
+	});
+
+	it("preserves the fork suffix when truncating long titles", () => {
+		const title = deriveForkSessionTitle({
+			sourceTitle: "a".repeat(200),
+			messages: [],
+		});
+
+		expect(title).toHaveLength(120);
+		expect(title.endsWith(" (fork)")).toBe(true);
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/fork/title.ts b/apps/cli/src/runtime/interactive/fork/title.ts
new file mode 100644
index 0000000..507e0e3
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/fork/title.ts
@@ -0,0 +1,65 @@
+import {
+	formatDisplayUserInput,
+	type Message,
+	normalizeUserInput,
+} from "@cline/shared";
+
+const FORK_TITLE_SUFFIX = " (fork)";
+const MAX_FORK_TITLE_LENGTH = 120;
+
+function normalizeForkTitleText(value: string | undefined): string | undefined {
+	const normalized = normalizeUserInput(formatDisplayUserInput(value))
+		.replace(/\s+/g, " ")
+		.trim();
+	return normalized || undefined;
+}
+
+function truncateForForkSuffix(base: string): string {
+	const maxBaseLength = MAX_FORK_TITLE_LENGTH - FORK_TITLE_SUFFIX.length;
+	if (base.length <= maxBaseLength) {
+		return base;
+	}
+	return base.slice(0, maxBaseLength).trimEnd();
+}
+
+function extractMessageText(message: Message): string | undefined {
+	if (typeof message.content === "string") {
+		return message.content;
+	}
+	const parts: string[] = [];
+	for (const block of message.content) {
+		if (block.type === "text") {
+			parts.push(block.text);
+		}
+	}
+	return parts.join("\n").trim() || undefined;
+}
+
+function inferForkTitleFromMessages(messages: Message[]): string | undefined {
+	for (const role of ["user", "assistant"] as const) {
+		for (const message of messages) {
+			if (message.role !== role) {
+				continue;
+			}
+			const text = extractMessageText(message);
+			const normalized = normalizeForkTitleText(text);
+			if (normalized) {
+				return normalized;
+			}
+		}
+	}
+	return undefined;
+}
+
+export function deriveForkSessionTitle(input: {
+	sourceTitle?: string | null;
+	sourcePrompt?: string | null;
+	messages: Message[];
+}): string {
+	const base =
+		normalizeForkTitleText(input.sourceTitle ?? undefined) ??
+		normalizeForkTitleText(input.sourcePrompt ?? undefined) ??
+		inferForkTitleFromMessages(input.messages) ??
+		"Untitled";
+	return `${truncateForForkSuffix(base)}${FORK_TITLE_SUFFIX}`;
+}
diff --git a/apps/cli/src/runtime/interactive/mistakes.test.ts b/apps/cli/src/runtime/interactive/mistakes.test.ts
new file mode 100644
index 0000000..e2821ba
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/mistakes.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { createMistakeLimitDecisionResolver } from "./mistakes";
+
+describe("createMistakeLimitDecisionResolver", () => {
+	it("stops immediately when auto-approve is enabled", async () => {
+		const decide = createMistakeLimitDecisionResolver({
+			autoApproveAllRef: { current: true },
+			askQuestionRef: { current: null },
+		});
+
+		await expect(
+			decide({
+				iteration: 1,
+				consecutiveMistakes: 3,
+				maxConsecutiveMistakes: 3,
+				reason: "api_error",
+			}),
+		).resolves.toMatchObject({
+			action: "stop",
+		});
+	});
+
+	it("continues with retry guidance for the default answer", async () => {
+		const decide = createMistakeLimitDecisionResolver({
+			autoApproveAllRef: { current: false },
+			askQuestionRef: { current: null },
+		});
+
+		await expect(
+			decide({
+				iteration: 4,
+				consecutiveMistakes: 2,
+				maxConsecutiveMistakes: 3,
+				reason: "tool_execution_failed",
+				details: "bad args",
+			}),
+		).resolves.toMatchObject({
+			action: "continue",
+			guidance: expect.stringContaining("retry with a different approach"),
+		});
+	});
+
+	it("honors an explicit stop answer", async () => {
+		const decide = createMistakeLimitDecisionResolver({
+			autoApproveAllRef: { current: false },
+			askQuestionRef: { current: async () => "Stop this run" },
+		});
+
+		await expect(
+			decide({
+				iteration: 4,
+				consecutiveMistakes: 2,
+				maxConsecutiveMistakes: 3,
+				reason: "invalid_tool_call",
+			}),
+		).resolves.toMatchObject({
+			action: "stop",
+		});
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/mistakes.ts b/apps/cli/src/runtime/interactive/mistakes.ts
new file mode 100644
index 0000000..27faa93
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/mistakes.ts
@@ -0,0 +1,60 @@
+export interface MistakeLimitContext {
+	iteration: number;
+	consecutiveMistakes: number;
+	maxConsecutiveMistakes: number;
+	reason: "api_error" | "invalid_tool_call" | "tool_execution_failed";
+	details?: string;
+}
+
+export function createMistakeLimitDecisionResolver(input: {
+	autoApproveAllRef: { current: boolean };
+	askQuestionRef: {
+		current: ((question: string, options: string[]) => Promise<string>) | null;
+	};
+}) {
+	return async (context: MistakeLimitContext) => {
+		if (input.autoApproveAllRef.current) {
+			return {
+				action: "stop" as const,
+				reason: `max consecutive mistakes reached (${context.maxConsecutiveMistakes}) in yolo mode`,
+			};
+		}
+		const detail = context.details?.trim();
+		const summary = detail
+			? `${context.reason}: ${detail}`
+			: `${context.reason} at iteration ${context.iteration}`;
+		const questionText = `mistake_limit_reached (${context.consecutiveMistakes}/${context.maxConsecutiveMistakes})\nLatest: ${summary}\nHow should Cline continue?`;
+		const questionOptions = ["Try a different approach", "Stop this run"];
+		const answer = input.askQuestionRef.current
+			? await input.askQuestionRef.current(questionText, questionOptions)
+			: (questionOptions[0] ?? "");
+		const normalized = answer.trim().toLowerCase();
+		if (
+			normalized === "2" ||
+			normalized === "stop this run" ||
+			normalized === "stop" ||
+			normalized === "n" ||
+			normalized === "no"
+		) {
+			return {
+				action: "stop" as const,
+				reason: "stopped after mistake_limit_reached prompt",
+			};
+		}
+		if (
+			normalized === "1" ||
+			normalized === "try a different approach" ||
+			normalized.length === 0
+		) {
+			return {
+				action: "continue" as const,
+				guidance:
+					"mistake_limit_reached: retry with a different approach, validate tool parameters before calls, and avoid repeating failed steps.",
+			};
+		}
+		return {
+			action: "continue" as const,
+			guidance: `mistake_limit_reached: ${answer.trim()}`,
+		};
+	};
+}
diff --git a/apps/cli/src/runtime/interactive/mode.test.ts b/apps/cli/src/runtime/interactive/mode.test.ts
new file mode 100644
index 0000000..18d4c0d
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/mode.test.ts
@@ -0,0 +1,273 @@
+import { createTool } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { Config } from "../../utils/types";
+import { resolveSystemPrompt } from "../prompt";
+import {
+	ACT_MODE_CONTINUATION_PROMPT,
+	type AppliedModeChange,
+	applyInteractiveModeConfig,
+	createInteractiveModeSwitchTool,
+	createModeSwitchNoticeTracker,
+	type PendingModeChange,
+	sendTurnWithActModeContinuation,
+} from "./mode";
+
+vi.mock("../prompt", () => ({
+	resolveSystemPrompt: vi.fn(async (input: { mode?: string }) => {
+		return `system prompt for ${input.mode ?? "unknown"}`;
+	}),
+}));
+
+function makeConfig(): Config {
+	return {
+		apiKey: "",
+		providerId: "cline",
+		modelId: "openai/gpt-5.3-codex",
+		verbose: false,
+		sandbox: false,
+		thinking: false,
+		outputMode: "text",
+		mode: "act",
+		systemPrompt: "",
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+		defaultToolAutoApprove: false,
+		toolPolicies: {},
+		cwd: process.cwd(),
+	};
+}
+
+const switchToActModeTool = createTool({
+	name: "switch_to_act_mode",
+	description: "Switch to act mode",
+	inputSchema: {
+		type: "object",
+		properties: {},
+	},
+	execute: async () => "ok",
+});
+
+describe("createInteractiveModeSwitchTool", () => {
+	function makeSwitchTool(config: Config) {
+		const pendingModeChange: PendingModeChange = {
+			current: null,
+			source: null,
+		};
+		const tuiModeChanged: {
+			current: ((mode: "plan" | "act") => void) | null;
+		} = { current: vi.fn() };
+		const tool = createInteractiveModeSwitchTool({
+			config,
+			pendingModeChange,
+			tuiModeChanged,
+		});
+		return { tool, pendingModeChange, tuiModeChanged };
+	}
+
+	const toolContext = {
+		agentId: "agent-1",
+		iteration: 0,
+	} as const;
+
+	it("completes the run so the model never continues with plan-mode tools", () => {
+		const config = makeConfig();
+		config.mode = "plan";
+		const { tool } = makeSwitchTool(config);
+
+		// The act-mode tool set only exists after the session rebuild, which
+		// happens between runs; without completesRun the model keeps working
+		// with stale plan-mode tools after being told the switch succeeded.
+		expect(tool.lifecycle?.completesRun).toBe(true);
+	});
+
+	it("queues a tool-sourced mode change and notifies the TUI", async () => {
+		const config = makeConfig();
+		config.mode = "plan";
+		const { tool, pendingModeChange, tuiModeChanged } = makeSwitchTool(config);
+
+		const result = await tool.execute({}, toolContext);
+
+		expect(pendingModeChange).toEqual({ current: "act", source: "tool" });
+		expect(tuiModeChanged.current).toHaveBeenCalledWith("act");
+		expect(result).toContain("successfully switched to act mode");
+	});
+
+	it("errors instead of completing the run when already in act mode", async () => {
+		const config = makeConfig();
+		config.mode = "act";
+		const { tool, pendingModeChange } = makeSwitchTool(config);
+
+		// A successful result would end the run via completesRun even though
+		// nothing changed, so the no-op case must surface as a tool error.
+		await expect(tool.execute({}, toolContext)).rejects.toThrow(
+			"Already in act mode.",
+		);
+		expect(pendingModeChange.current).toBeNull();
+	});
+});
+
+describe("sendTurnWithActModeContinuation", () => {
+	type TurnResult = { finishReason: string; iterations: number };
+
+	function makeHarness(input: {
+		initial: TurnResult | undefined;
+		continuation?: TurnResult | undefined;
+		modeChanges: Array<AppliedModeChange | undefined>;
+	}) {
+		const applied = [...input.modeChanges];
+		const sendContinuationTurn = vi.fn(async () => input.continuation);
+		return {
+			sendContinuationTurn,
+			run: () =>
+				sendTurnWithActModeContinuation<TurnResult>({
+					sendInitialTurn: async () => input.initial,
+					sendContinuationTurn,
+					applyPendingModeChange: async () => applied.shift(),
+				}),
+		};
+	}
+
+	it("continues the plan after a tool-initiated switch completes the run", async () => {
+		const { run, sendContinuationTurn } = makeHarness({
+			initial: { finishReason: "completed", iterations: 2 },
+			continuation: { finishReason: "completed", iterations: 3 },
+			modeChanges: [{ mode: "act", source: "tool" }, undefined],
+		});
+
+		const result = await run();
+
+		expect(sendContinuationTurn).toHaveBeenCalledWith(
+			ACT_MODE_CONTINUATION_PROMPT,
+		);
+		expect(result).toEqual({ finishReason: "completed", iterations: 5 });
+	});
+
+	it("does not continue after a UI-initiated mode change", async () => {
+		// A Tab toggle can race a natural turn completion; a "ui" source must
+		// never start executing a plan the user did not approve.
+		const { run, sendContinuationTurn } = makeHarness({
+			initial: { finishReason: "completed", iterations: 2 },
+			modeChanges: [{ mode: "act", source: "ui" }],
+		});
+
+		const result = await run();
+
+		expect(sendContinuationTurn).not.toHaveBeenCalled();
+		expect(result).toEqual({ finishReason: "completed", iterations: 2 });
+	});
+
+	it("does not continue when the switch turn was aborted", async () => {
+		const { run, sendContinuationTurn } = makeHarness({
+			initial: { finishReason: "aborted", iterations: 1 },
+			modeChanges: [{ mode: "act", source: "tool" }],
+		});
+
+		const result = await run();
+
+		expect(sendContinuationTurn).not.toHaveBeenCalled();
+		expect(result).toEqual({ finishReason: "aborted", iterations: 1 });
+	});
+
+	it("does not continue when no mode change was pending", async () => {
+		const { run, sendContinuationTurn } = makeHarness({
+			initial: { finishReason: "completed", iterations: 2 },
+			modeChanges: [undefined],
+		});
+
+		const result = await run();
+
+		expect(sendContinuationTurn).not.toHaveBeenCalled();
+		expect(result).toEqual({ finishReason: "completed", iterations: 2 });
+	});
+
+	it("returns the switch turn result when the continuation yields nothing", async () => {
+		const { run } = makeHarness({
+			initial: { finishReason: "completed", iterations: 2 },
+			continuation: undefined,
+			modeChanges: [{ mode: "act", source: "tool" }, undefined],
+		});
+
+		const result = await run();
+
+		expect(result).toEqual({ finishReason: "completed", iterations: 2 });
+	});
+});
+
+describe("createModeSwitchNoticeTracker", () => {
+	it("records a switch and clears it on consume", () => {
+		const tracker = createModeSwitchNoticeTracker();
+
+		tracker.record("act", "plan");
+
+		expect(tracker.consume()).toEqual({ from: "act", to: "plan" });
+		expect(tracker.consume()).toBeNull();
+	});
+
+	it("cancels a round trip that returns to the mode the model last saw", () => {
+		const tracker = createModeSwitchNoticeTracker();
+
+		tracker.record("act", "plan");
+		tracker.record("plan", "act");
+
+		expect(tracker.consume()).toBeNull();
+	});
+
+	it("keeps the original starting mode across chained switches", () => {
+		const tracker = createModeSwitchNoticeTracker();
+
+		tracker.record("act", "plan");
+		tracker.record("plan", "act");
+		tracker.record("act", "plan");
+
+		expect(tracker.consume()).toEqual({ from: "act", to: "plan" });
+	});
+
+	it("ignores a no-op switch", () => {
+		const tracker = createModeSwitchNoticeTracker();
+
+		tracker.record("plan", "plan");
+
+		expect(tracker.consume()).toBeNull();
+	});
+});
+
+describe("applyInteractiveModeConfig", () => {
+	beforeEach(() => {
+		vi.mocked(resolveSystemPrompt).mockClear();
+	});
+
+	it("adds the mode switch tool when entering plan mode", async () => {
+		const config = makeConfig();
+
+		await applyInteractiveModeConfig({
+			config,
+			mode: "plan",
+			switchToActModeTool,
+		});
+
+		expect(config.mode).toBe("plan");
+		expect(config.extraTools).toEqual([switchToActModeTool]);
+		expect(config.systemPrompt).toBe("system prompt for plan");
+		expect(resolveSystemPrompt).toHaveBeenCalledWith({
+			cwd: config.cwd,
+			providerId: config.providerId,
+			mode: "plan",
+		});
+	});
+
+	it("removes the mode switch tool when entering act mode", async () => {
+		const config = makeConfig();
+		config.extraTools = [switchToActModeTool];
+
+		await applyInteractiveModeConfig({
+			config,
+			mode: "act",
+			switchToActModeTool,
+		});
+
+		expect(config.mode).toBe("act");
+		expect(config.extraTools).toEqual([]);
+		expect(config.systemPrompt).toBe("system prompt for act");
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/mode.ts b/apps/cli/src/runtime/interactive/mode.ts
new file mode 100644
index 0000000..0eedea6
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/mode.ts
@@ -0,0 +1,156 @@
+import { createTool } from "@cline/shared";
+import type { Config } from "../../utils/types";
+import { resolveSystemPrompt } from "../prompt";
+
+export type InteractiveUiMode = "plan" | "act";
+
+/**
+ * Pending mode change plus who requested it. The switch_to_act_mode tool and
+ * the TUI mode toggle share this slot, but only a tool-initiated switch means
+ * "the user approved the plan" -- a UI toggle that lands as a turn finishes
+ * must not trigger plan execution.
+ */
+export type PendingModeChange = {
+	current: InteractiveUiMode | null;
+	source: "tool" | "ui" | null;
+};
+
+export type AppliedModeChange = {
+	mode: InteractiveUiMode;
+	source: "tool" | "ui";
+};
+
+/**
+ * Canned prompt that drives the auto-continue turn after the model calls
+ * switch_to_act_mode. It is a synthetic user message, so transcript hydration
+ * filters it out of the chat display.
+ */
+export const ACT_MODE_CONTINUATION_PROMPT =
+	"The user approved switching to act mode. Continue with the approved plan now.";
+
+export function createInteractiveModeSwitchTool(input: {
+	config: Config;
+	pendingModeChange: PendingModeChange;
+	tuiModeChanged: { current: ((mode: InteractiveUiMode) => void) | null };
+}) {
+	return createTool({
+		name: "switch_to_act_mode",
+		description:
+			"Switch from plan mode to act mode. Switching to act mode immediately starts executing the plan, so only call this after the user has explicitly approved the plan in a message sent AFTER you presented it (e.g. 'looks good', 'go ahead', 'switch to act mode'). " +
+			"Never call this in the same turn you present a plan, never call it proactively, and never treat the original task request as approval.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+		},
+		timeoutMs: 5000,
+		retryable: false,
+		maxRetries: 0,
+		// The act-mode tools only exist after the session is rebuilt with the
+		// new mode config, which can't happen mid-run. End the run right after
+		// the tool result so the model never keeps working with plan-mode tools
+		// it was just told it no longer has; run-interactive applies the pending
+		// change and auto-continues on the rebuilt session.
+		lifecycle: {
+			completesRun: true,
+		},
+		execute: async () => {
+			if (input.config.mode === "act") {
+				// Throw instead of returning: a successful result would end the
+				// run via completesRun even though nothing changed.
+				throw new Error("Already in act mode.");
+			}
+			input.pendingModeChange.current = "act";
+			input.pendingModeChange.source = "tool";
+			input.tuiModeChanged.current?.("act");
+			return "You successfully switched to act mode, proceed with the plan. You now have access to editing files and running commands. (The switch_to_act_mode tool is only available in plan mode.)";
+		},
+	});
+}
+
+/**
+ * Runs one interactive turn, and when the model ended it by calling
+ * switch_to_act_mode, continues the approved plan on the rebuilt act-mode
+ * session instead of waiting for the user to prompt again.
+ *
+ * The continuation only fires for a tool-initiated switch on a turn that
+ * finished "completed": a UI toggle mid-run aborts the turn, and even if the
+ * toggle races a natural completion its source is "ui", so the user's Tab
+ * press can never start executing a plan they did not approve.
+ */
+export async function sendTurnWithActModeContinuation<
+	T extends { finishReason: string; iterations: number },
+>(input: {
+	sendInitialTurn: () => Promise<T | undefined>;
+	sendContinuationTurn: (prompt: string) => Promise<T | undefined>;
+	applyPendingModeChange: () => Promise<AppliedModeChange | undefined>;
+}): Promise<T | undefined> {
+	const result = await input.sendInitialTurn();
+	const switched = await input.applyPendingModeChange();
+	if (
+		switched?.mode !== "act" ||
+		switched.source !== "tool" ||
+		result?.finishReason !== "completed"
+	) {
+		return result;
+	}
+	const continuation = await input.sendContinuationTurn(
+		ACT_MODE_CONTINUATION_PROMPT,
+	);
+	// Honor a mode toggle made while the continuation was running.
+	await input.applyPendingModeChange();
+	if (!continuation) {
+		return result;
+	}
+	return {
+		...continuation,
+		iterations: result.iterations + continuation.iterations,
+	};
+}
+
+export type ModeSwitchNotice = {
+	from: InteractiveUiMode;
+	to: InteractiveUiMode;
+};
+
+/**
+ * Tracks a user-initiated mode switch so the next user message can carry a
+ * <mode_notice> marking it. Only UI toggles are recorded: the model-initiated
+ * switch_to_act_mode path already announces itself via the continuation
+ * prompt. A round trip (plan -> act -> plan before sending anything) cancels
+ * out, since the mode the model last saw never effectively changed.
+ */
+export function createModeSwitchNoticeTracker() {
+	let pending: ModeSwitchNotice | null = null;
+	return {
+		record(from: InteractiveUiMode, to: InteractiveUiMode): void {
+			if (from === to) {
+				return;
+			}
+			if (pending) {
+				pending = pending.from === to ? null : { from: pending.from, to };
+				return;
+			}
+			pending = { from, to };
+		},
+		consume(): ModeSwitchNotice | null {
+			const notice = pending;
+			pending = null;
+			return notice;
+		},
+	};
+}
+
+export async function applyInteractiveModeConfig(input: {
+	config: Config;
+	mode: InteractiveUiMode;
+	switchToActModeTool: NonNullable<Config["extraTools"]>[number];
+}): Promise<void> {
+	input.config.mode = input.mode;
+	input.config.extraTools =
+		input.mode === "plan" ? [input.switchToActModeTool] : [];
+	input.config.systemPrompt = await resolveSystemPrompt({
+		cwd: input.config.cwd,
+		providerId: input.config.providerId,
+		mode: input.mode,
+	});
+}
diff --git a/apps/cli/src/runtime/interactive/preflight.ts b/apps/cli/src/runtime/interactive/preflight.ts
new file mode 100644
index 0000000..2904eea
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/preflight.ts
@@ -0,0 +1,15 @@
+import { writeErr } from "../../utils/output";
+import type { Config } from "../../utils/types";
+
+export function assertInteractivePreflight(config: Config): void {
+	if (config.outputMode === "json") {
+		writeErr("interactive mode is not supported with --json");
+		process.exit(1);
+	}
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		writeErr(
+			"interactive mode requires a TTY (stdin/stdout must both be terminals)",
+		);
+		process.exit(1);
+	}
+}
diff --git a/apps/cli/src/runtime/interactive/session-config.ts b/apps/cli/src/runtime/interactive/session-config.ts
new file mode 100644
index 0000000..51f6e6b
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/session-config.ts
@@ -0,0 +1,31 @@
+import type { TeamEvent } from "@cline/core";
+import type { ChatCommandState } from "../../utils/chat-commands";
+import type { Config } from "../../utils/types";
+import {
+	CLI_DEFAULT_CHECKPOINT_CONFIG,
+	CLI_DEFAULT_LOOP_DETECTION,
+} from "../defaults";
+
+export function buildInteractiveSessionConfig(input: {
+	config: Config;
+	chatCommandState: ChatCommandState;
+	runtimeHooks: { hooks?: Config["hooks"] };
+	onTeamEvent: (event: TeamEvent) => void;
+	resolveMistakeLimitDecision: Config["onConsecutiveMistakeLimitReached"];
+}): Config {
+	return {
+		...input.config,
+		execution: {
+			...input.config.execution,
+			loopDetection:
+				input.config.execution?.loopDetection ?? CLI_DEFAULT_LOOP_DETECTION,
+		},
+		checkpoint: input.config.checkpoint ?? CLI_DEFAULT_CHECKPOINT_CONFIG,
+		enableTools: input.chatCommandState.enableTools,
+		cwd: input.chatCommandState.cwd,
+		workspaceRoot: input.chatCommandState.workspaceRoot,
+		hooks: input.runtimeHooks.hooks,
+		onTeamEvent: input.onTeamEvent,
+		onConsecutiveMistakeLimitReached: input.resolveMistakeLimitDecision,
+	};
+}
diff --git a/apps/cli/src/runtime/interactive/session-runtime.test.ts b/apps/cli/src/runtime/interactive/session-runtime.test.ts
new file mode 100644
index 0000000..d494491
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/session-runtime.test.ts
@@ -0,0 +1,976 @@
+import {
+	createSessionCompactionState,
+	type ProviderSettingsManager,
+	type SessionManifest,
+	SessionNotFoundError,
+	SessionSource,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+} from "@cline/core";
+import type { AgentTool, Message } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ChatCommandState } from "../../utils/chat-commands";
+import type { Config } from "../../utils/types";
+
+const createCliCoreMock = vi.hoisted(() => vi.fn());
+const compactInteractiveMessagesMock = vi.hoisted(() => vi.fn());
+const createRuntimeHooksMock = vi.hoisted(() => vi.fn());
+const setActiveCliSessionMock = vi.hoisted(() => vi.fn());
+const loadInteractiveResumeMessagesMock = vi.hoisted(() => vi.fn());
+const subscribeToAgentEventsMock = vi.hoisted(() => vi.fn());
+const subscribeToPendingPromptEventsMock = vi.hoisted(() => vi.fn());
+const markAbortInProgressMock = vi.hoisted(() => vi.fn());
+const submitAndExitInTerminalMock = vi.hoisted(() => vi.fn());
+const createInteractiveExitSummaryMock = vi.hoisted(() => vi.fn());
+
+vi.mock("../../session/session", () => ({
+	createCliCore: createCliCoreMock,
+}));
+
+vi.mock("../../utils/approval", () => ({
+	submitAndExitInTerminal: submitAndExitInTerminalMock,
+}));
+
+vi.mock("../../utils/hooks", () => ({
+	createRuntimeHooks: createRuntimeHooksMock,
+}));
+
+vi.mock("../../utils/output", () => ({
+	setActiveCliSession: setActiveCliSessionMock,
+}));
+
+vi.mock("../../utils/resume", () => ({
+	loadInteractiveResumeMessages: loadInteractiveResumeMessagesMock,
+}));
+
+vi.mock("../active-runtime", () => ({
+	markAbortInProgress: markAbortInProgressMock,
+}));
+
+vi.mock("../session-events", () => ({
+	subscribeToAgentEvents: subscribeToAgentEventsMock,
+	subscribeToPendingPromptEvents: subscribeToPendingPromptEventsMock,
+}));
+
+vi.mock("./compaction", () => ({
+	compactInteractiveMessages: compactInteractiveMessagesMock,
+}));
+
+vi.mock("./exit-summary", () => ({
+	createInteractiveExitSummary: createInteractiveExitSummaryMock,
+}));
+
+function createConfig(): Config {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-test",
+		apiKey: "",
+		cwd: "/tmp/project",
+		workspaceRoot: "/tmp/project",
+		systemPrompt: "system",
+		mode: "act",
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+		verbose: false,
+		thinking: false,
+		outputMode: "text",
+		sandbox: false,
+		defaultToolAutoApprove: true,
+		toolPolicies: {
+			"*": { autoApprove: true },
+		},
+	};
+}
+
+function createChatCommandState(config = createConfig()): ChatCommandState {
+	return {
+		enableTools: config.enableTools,
+		autoApproveTools: config.defaultToolAutoApprove,
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot?.trim() || config.cwd,
+	};
+}
+
+function createProviderSettingsManager(): ProviderSettingsManager {
+	return {
+		getProviderSettings: vi.fn().mockReturnValue(undefined),
+	} as unknown as ProviderSettingsManager;
+}
+
+function createManifest(sessionId: string): SessionManifest {
+	return {
+		version: 1,
+		session_id: sessionId,
+		source: SessionSource.CLI,
+		pid: 1,
+		started_at: "2026-01-01T00:00:00.000Z",
+		status: "running",
+		interactive: true,
+		provider: "anthropic",
+		model: "claude-test",
+		cwd: "/tmp/project",
+		workspace_root: "/tmp/project",
+		enable_tools: true,
+		enable_spawn: true,
+		enable_teams: true,
+	};
+}
+
+async function importRuntime() {
+	return await import("./session-runtime");
+}
+
+function makeSwitchToActModeTool(): AgentTool {
+	return {
+		name: "switch_to_act_mode",
+		description: "Switch to act mode",
+		inputSchema: { type: "object", properties: {} },
+		execute: () => ({ ok: true }),
+	};
+}
+
+function makeManager() {
+	let startCount = 0;
+	const start = vi.fn(async (_input?: unknown) => {
+		startCount += 1;
+		const sessionId = `session-${startCount}`;
+		return {
+			sessionId,
+			manifest: createManifest(sessionId),
+			manifestPath: `/tmp/${sessionId}.json`,
+			messagesPath: `/tmp/${sessionId}.messages.json`,
+		};
+	});
+	return {
+		start,
+		stop: vi.fn(async () => {}),
+		send: vi.fn(),
+		getAccumulatedUsage: vi.fn(),
+		abort: vi.fn(),
+		dispose: vi.fn(),
+		get: vi.fn(),
+		readMessages: vi.fn(async (): Promise<Message[]> => []),
+		readSessionCompactionState: vi.fn().mockResolvedValue(undefined),
+		updateSessionCompactionState: vi.fn(),
+		readTranscript: vi.fn(),
+		ingestHookEvent: vi.fn(),
+		subscribe: vi.fn(),
+		updateSessionModel: vi.fn(),
+		updateSessionConnection: vi.fn(async () => {}),
+		pendingPrompts: {
+			update: vi.fn(),
+		},
+		restore: vi.fn(),
+	};
+}
+
+function makeTurnResult() {
+	return {
+		text: "ok",
+		usage: { inputTokens: 0, outputTokens: 0 },
+		messages: [],
+		toolCalls: [],
+		iterations: 1,
+		finishReason: "completed" as const,
+		model: { id: "claude-test", provider: "anthropic" },
+		startedAt: new Date("2026-01-01T00:00:00.000Z"),
+		endedAt: new Date("2026-01-01T00:00:00.100Z"),
+		durationMs: 100,
+	};
+}
+
+function deferred<T>() {
+	let resolve!: (value: T) => void;
+	let reject!: (error?: unknown) => void;
+	const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+		resolve = resolvePromise;
+		reject = rejectPromise;
+	});
+	return { promise, resolve, reject };
+}
+
+async function makeRuntime(
+	manager: ReturnType<typeof makeManager>,
+	options: {
+		config?: Config;
+		resumeSessionId?: string;
+		resolveToolPolicy?: (toolName: string) => Config["toolPolicies"][string];
+	} = {},
+) {
+	createCliCoreMock.mockResolvedValue(manager);
+	const config = options.config ?? createConfig();
+	const { createInteractiveSessionRuntime } = await importRuntime();
+	return createInteractiveSessionRuntime({
+		config,
+		providerSettingsManager: createProviderSettingsManager(),
+		resumeSessionId: options.resumeSessionId,
+		chatCommandState: createChatCommandState(config),
+		requestToolApproval: async (
+			_request: ToolApprovalRequest,
+		): Promise<ToolApprovalResult> => ({ approved: true }),
+		resolveToolPolicy:
+			options.resolveToolPolicy ?? (() => ({ autoApprove: true })),
+		askQuestionRef: { current: null },
+		resolveMistakeLimitDecision: undefined,
+		switchToActModeTool: makeSwitchToActModeTool(),
+		onAgentEvent: vi.fn(),
+		onTeamEvent: vi.fn(),
+		onPendingPrompts: vi.fn(),
+		onPendingPromptSubmitted: vi.fn(),
+	});
+}
+
+describe("createInteractiveSessionRuntime", () => {
+	beforeEach(() => {
+		createCliCoreMock.mockReset();
+		compactInteractiveMessagesMock.mockReset();
+		createRuntimeHooksMock.mockReset();
+		setActiveCliSessionMock.mockReset();
+		loadInteractiveResumeMessagesMock.mockReset();
+		subscribeToAgentEventsMock.mockReset();
+		subscribeToPendingPromptEventsMock.mockReset();
+		markAbortInProgressMock.mockReset();
+		submitAndExitInTerminalMock.mockReset();
+		createInteractiveExitSummaryMock.mockReset();
+		createRuntimeHooksMock.mockReturnValue({
+			hooks: undefined,
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		});
+		loadInteractiveResumeMessagesMock.mockResolvedValue([]);
+		subscribeToAgentEventsMock.mockReturnValue(() => {});
+		subscribeToPendingPromptEventsMock.mockReturnValue(() => {});
+	});
+
+	it("manual compact updates the active session sidecar without restarting", async () => {
+		const sessionId = "sess-active";
+		const messages = [
+			{ id: "u1", role: "user" as const, content: "hello" },
+			{ id: "a1", role: "assistant" as const, content: "world" },
+		];
+		const compactionState = createSessionCompactionState({
+			sourceMessages: messages,
+			compactedMessages: [
+				{ id: "summary", role: "user" as const, content: "summary" },
+			],
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const manager = {
+			start: vi.fn().mockResolvedValue({
+				sessionId,
+				manifest: createManifest(sessionId),
+				manifestPath: "/tmp/session.json",
+				messagesPath: "/tmp/session.messages.json",
+			}),
+			readMessages: vi.fn().mockResolvedValue(messages),
+			updateSessionCompactionState: vi
+				.fn()
+				.mockResolvedValue({ updated: true }),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+			ingestHookEvent: vi.fn().mockResolvedValue(undefined),
+			get: vi.fn(),
+			list: vi.fn(),
+			delete: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+		};
+		createCliCoreMock.mockResolvedValue(manager);
+		compactInteractiveMessagesMock.mockResolvedValue({
+			compacted: true,
+			canonicalMessages: messages,
+			compactionState,
+		});
+		const { createInteractiveSessionRuntime } = await importRuntime();
+		const runtime = createInteractiveSessionRuntime({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			chatCommandState: createChatCommandState(),
+			requestToolApproval: vi.fn(),
+			resolveToolPolicy: () => ({ autoApprove: true }),
+			askQuestionRef: { current: null },
+			resolveMistakeLimitDecision: undefined,
+			switchToActModeTool: {} as never,
+			onAgentEvent: vi.fn(),
+			onTeamEvent: vi.fn(),
+			onPendingPrompts: vi.fn(),
+			onPendingPromptSubmitted: vi.fn(),
+		});
+
+		await runtime.ensureReady();
+		const result = await runtime.compactCurrentSession();
+
+		expect(result).toEqual({
+			messagesBefore: messages.length,
+			messagesAfter: messages.length,
+			workingContextMessagesAfter: compactionState.messages.length,
+			compacted: true,
+		});
+		expect(manager.start).toHaveBeenCalledTimes(1);
+		expect(manager.stop).not.toHaveBeenCalled();
+		expect(manager.readMessages).toHaveBeenCalledWith(sessionId);
+		expect(compactInteractiveMessagesMock).toHaveBeenCalledWith({
+			config: expect.objectContaining({
+				providerId: "anthropic",
+				modelId: "claude-test",
+			}),
+			providerSettingsManager: expect.objectContaining({
+				getProviderSettings: expect.any(Function),
+			}),
+			sessionId,
+			messages,
+			abortSignal: expect.any(AbortSignal),
+		});
+		expect(manager.updateSessionCompactionState).toHaveBeenCalledWith(
+			sessionId,
+			compactionState,
+		);
+		expect(runtime.getActiveSessionId()).toBe(sessionId);
+	});
+
+	it("rejects manual compact while the active session is running", async () => {
+		const sessionId = "sess-running";
+		const messages = [{ role: "user" as const, content: "hello" }];
+		const manager = {
+			start: vi.fn().mockResolvedValue({
+				sessionId,
+				manifest: createManifest(sessionId),
+				manifestPath: "/tmp/session.json",
+				messagesPath: "/tmp/session.messages.json",
+			}),
+			readMessages: vi.fn().mockResolvedValue(messages),
+			updateSessionCompactionState: vi
+				.fn()
+				.mockResolvedValue({ updated: true }),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+			ingestHookEvent: vi.fn().mockResolvedValue(undefined),
+			get: vi.fn().mockResolvedValue({
+				sessionId,
+				status: "running",
+			}),
+			list: vi.fn(),
+			delete: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+		};
+		createCliCoreMock.mockResolvedValue(manager);
+		const { createInteractiveSessionRuntime } = await importRuntime();
+		const runtime = createInteractiveSessionRuntime({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			chatCommandState: createChatCommandState(),
+			requestToolApproval: vi.fn(),
+			resolveToolPolicy: () => ({ autoApprove: true }),
+			askQuestionRef: { current: null },
+			resolveMistakeLimitDecision: undefined,
+			switchToActModeTool: {} as never,
+			onAgentEvent: vi.fn(),
+			onTeamEvent: vi.fn(),
+			onPendingPrompts: vi.fn(),
+			onPendingPromptSubmitted: vi.fn(),
+		});
+
+		await runtime.ensureReady();
+
+		await expect(runtime.compactCurrentSession()).rejects.toThrow(
+			"Cannot compact while the current turn is running",
+		);
+		expect(manager.readMessages).toHaveBeenCalledWith(sessionId);
+		expect(compactInteractiveMessagesMock).not.toHaveBeenCalled();
+		expect(manager.updateSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("rejects manual compact when compaction is disabled", async () => {
+		const manager = makeManager();
+		const config = createConfig();
+		config.compaction = { enabled: false };
+		const runtime = await makeRuntime(manager, { config });
+
+		await runtime.ensureReady();
+
+		await expect(runtime.compactCurrentSession()).rejects.toThrow(
+			"compaction is off",
+		);
+		expect(compactInteractiveMessagesMock).not.toHaveBeenCalled();
+		expect(manager.updateSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("carries compacted working context across mode-switch restarts", async () => {
+		const firstSessionId = "sess-mode-before";
+		const secondSessionId = "sess-mode-after";
+		const prefixMessage = {
+			id: "u1",
+			role: "user" as const,
+			content: "large original",
+		};
+		const tailMessage = {
+			id: "u2",
+			role: "user" as const,
+			content: "new canonical tail",
+		};
+		const messages = [prefixMessage, tailMessage];
+		const summaryMessage = {
+			id: "summary",
+			role: "user" as const,
+			content: "summary",
+		};
+		const compactionState = createSessionCompactionState({
+			sourceMessages: [prefixMessage],
+			compactedMessages: [summaryMessage],
+			conversationId: firstSessionId,
+			systemPrompt: "compacted system",
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const manager = {
+			start: vi
+				.fn()
+				.mockResolvedValueOnce({
+					sessionId: firstSessionId,
+					manifest: createManifest(firstSessionId),
+					manifestPath: "/tmp/session-before.json",
+					messagesPath: "/tmp/session-before.messages.json",
+				})
+				.mockResolvedValueOnce({
+					sessionId: secondSessionId,
+					manifest: createManifest(secondSessionId),
+					manifestPath: "/tmp/session-after.json",
+					messagesPath: "/tmp/session-after.messages.json",
+				}),
+			readMessages: vi.fn().mockResolvedValue(messages),
+			readSessionCompactionState: vi.fn().mockResolvedValue(compactionState),
+			updateSessionCompactionState: vi
+				.fn()
+				.mockResolvedValue({ updated: true }),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+			ingestHookEvent: vi.fn().mockResolvedValue(undefined),
+			get: vi.fn(),
+			list: vi.fn(),
+			delete: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+		};
+		createCliCoreMock.mockResolvedValue(manager);
+		const { createInteractiveSessionRuntime } = await importRuntime();
+		const runtime = createInteractiveSessionRuntime({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			chatCommandState: createChatCommandState(),
+			requestToolApproval: vi.fn(),
+			resolveToolPolicy: () => ({ autoApprove: true }),
+			askQuestionRef: { current: null },
+			resolveMistakeLimitDecision: undefined,
+			switchToActModeTool: {} as never,
+			onAgentEvent: vi.fn(),
+			onTeamEvent: vi.fn(),
+			onPendingPrompts: vi.fn(),
+			onPendingPromptSubmitted: vi.fn(),
+		});
+
+		await runtime.ensureReady();
+		await runtime.applyMode("plan");
+
+		expect(manager.readMessages).toHaveBeenCalledWith(firstSessionId);
+		expect(manager.readSessionCompactionState).toHaveBeenCalledWith(
+			firstSessionId,
+		);
+		expect(manager.stop).toHaveBeenCalledWith(firstSessionId);
+		const restartInput = manager.start.mock.calls[1]?.[0];
+		expect(restartInput).toMatchObject({
+			initialMessages: messages,
+			initialCompactionState: expect.objectContaining({
+				source_message_count: messages.length,
+				messages: [summaryMessage, tailMessage],
+				system_prompt: "compacted system",
+			}),
+		});
+		expect(restartInput.initialCompactionState).not.toHaveProperty(
+			"conversation_id",
+		);
+		expect(manager.updateSessionCompactionState).not.toHaveBeenCalled();
+		expect(runtime.getActiveSessionId()).toBe(secondSessionId);
+	});
+
+	it("defers creating the replacement session after a new-session reset", async () => {
+		let startCount = 0;
+		const manager = {
+			start: vi.fn().mockImplementation(async () => {
+				startCount += 1;
+				const sessionId = `session-${startCount}`;
+				return {
+					sessionId,
+					manifest: createManifest(sessionId),
+					manifestPath: `/tmp/${sessionId}.json`,
+					messagesPath: `/tmp/${sessionId}.messages.json`,
+				};
+			}),
+			readMessages: vi.fn().mockResolvedValue([]),
+			readSessionCompactionState: vi.fn().mockResolvedValue(undefined),
+			updateSessionCompactionState: vi.fn(),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+			ingestHookEvent: vi.fn().mockResolvedValue(undefined),
+			get: vi.fn(),
+			list: vi.fn(),
+			delete: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+		};
+		createCliCoreMock.mockResolvedValue(manager);
+		const { createInteractiveSessionRuntime } = await importRuntime();
+		const runtime = createInteractiveSessionRuntime({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			chatCommandState: createChatCommandState(),
+			requestToolApproval: vi.fn(),
+			resolveToolPolicy: () => ({ autoApprove: true }),
+			askQuestionRef: { current: null },
+			resolveMistakeLimitDecision: undefined,
+			switchToActModeTool: {} as never,
+			onAgentEvent: vi.fn(),
+			onTeamEvent: vi.fn(),
+			onPendingPrompts: vi.fn(),
+			onPendingPromptSubmitted: vi.fn(),
+		});
+
+		await runtime.ensureReady();
+		expect(manager.start).toHaveBeenCalledOnce();
+		expect(runtime.getActiveSessionId()).toBe("session-1");
+
+		await runtime.resetForNewSession();
+
+		expect(manager.stop).toHaveBeenCalledWith("session-1");
+		expect(manager.start).toHaveBeenCalledOnce();
+		expect(runtime.getActiveSessionId()).toBe("");
+		expect(setActiveCliSessionMock).toHaveBeenLastCalledWith(undefined);
+
+		await runtime.ensureReady();
+
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(runtime.getActiveSessionId()).toBe("session-2");
+	});
+
+	it("holds concurrent ensureReady during a restart instead of booting an empty session", async () => {
+		const manager = makeManager();
+		const runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		expect(runtime.getActiveSessionId()).toBe("session-1");
+
+		// Keep the replacement session's start in flight so the restart window
+		// (old session stopped, no active session yet) stays open.
+		const gate = deferred<void>();
+		manager.start.mockImplementationOnce(async () => {
+			await gate.promise;
+			return {
+				sessionId: "session-restarted",
+				manifest: createManifest("session-restarted"),
+				manifestPath: "/tmp/session-restarted.json",
+				messagesPath: "/tmp/session-restarted.messages.json",
+			};
+		});
+
+		const restart = runtime.restartWithCurrentMessages();
+		await vi.waitFor(() => {
+			expect(manager.start).toHaveBeenCalledTimes(2);
+		});
+
+		// A message submitted mid-restart (e.g. right after a plan/act toggle)
+		// calls ensureReady; it must wait for the restart instead of booting a
+		// blank session that races the replacement for the active slot.
+		const ready = runtime.ensureReady();
+		gate.resolve();
+		await Promise.all([restart, ready]);
+
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(runtime.getActiveSessionId()).toBe("session-restarted");
+	});
+
+	it("adds a live interactive approval policy hook to started sessions", async () => {
+		const manager = makeManager();
+		const upstreamBeforeTool = vi.fn(async () => ({
+			input: { text: "updated" },
+		}));
+		createRuntimeHooksMock.mockReturnValueOnce({
+			hooks: {
+				beforeTool: upstreamBeforeTool,
+			},
+			shutdown: vi.fn(async () => {}),
+		});
+		const runtime = await makeRuntime(manager, {
+			resolveToolPolicy: (toolName) => ({
+				autoApprove: toolName === "echo",
+			}),
+		});
+
+		await runtime.ensureReady();
+
+		const startInput = manager.start.mock.calls[0]?.[0] as
+			| { config?: Config }
+			| undefined;
+		const beforeTool = startInput?.config?.hooks?.beforeTool;
+		expect(beforeTool).toBeTypeOf("function");
+
+		const result = await beforeTool?.({
+			snapshot: {
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				status: "running",
+				iteration: 1,
+				messages: [],
+				pendingToolCalls: [],
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+				},
+			},
+			tool: {
+				name: "echo",
+				description: "",
+				inputSchema: {},
+				execute: async () => "ok",
+			},
+			toolCall: {
+				type: "tool-call",
+				toolCallId: "call-1",
+				toolName: "echo",
+				input: { text: "original" },
+			},
+			input: { text: "original" },
+		});
+
+		expect(upstreamBeforeTool).toHaveBeenCalledOnce();
+		expect(result).toEqual({
+			input: { text: "updated" },
+			policy: { autoApprove: true },
+		});
+	});
+
+	it("starts fresh after resetting an initially resumed session", async () => {
+		let startCount = 0;
+		const manager = {
+			start: vi.fn().mockImplementation(async () => {
+				startCount += 1;
+				const sessionId = `session-${startCount}`;
+				return {
+					sessionId,
+					manifest: createManifest(sessionId),
+					manifestPath: `/tmp/${sessionId}.json`,
+					messagesPath: `/tmp/${sessionId}.messages.json`,
+				};
+			}),
+			readMessages: vi.fn().mockResolvedValue([]),
+			readSessionCompactionState: vi.fn().mockResolvedValue(undefined),
+			updateSessionCompactionState: vi.fn(),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+			ingestHookEvent: vi.fn().mockResolvedValue(undefined),
+			get: vi.fn(),
+			list: vi.fn(),
+			delete: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+		};
+		createCliCoreMock.mockResolvedValue(manager);
+		const { createInteractiveSessionRuntime } = await importRuntime();
+		const runtime = createInteractiveSessionRuntime({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			resumeSessionId: "resumed-session",
+			chatCommandState: createChatCommandState(),
+			requestToolApproval: vi.fn(),
+			resolveToolPolicy: () => ({ autoApprove: true }),
+			askQuestionRef: { current: null },
+			resolveMistakeLimitDecision: undefined,
+			switchToActModeTool: {} as never,
+			onAgentEvent: vi.fn(),
+			onTeamEvent: vi.fn(),
+			onPendingPrompts: vi.fn(),
+			onPendingPromptSubmitted: vi.fn(),
+		});
+
+		await runtime.ensureReady();
+
+		expect(loadInteractiveResumeMessagesMock).toHaveBeenNthCalledWith(
+			1,
+			manager,
+			"resumed-session",
+		);
+		expect(manager.start).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({
+				config: expect.objectContaining({ sessionId: "resumed-session" }),
+			}),
+		);
+
+		await runtime.resetForNewSession();
+		await runtime.ensureReady();
+
+		expect(loadInteractiveResumeMessagesMock).toHaveBeenNthCalledWith(
+			2,
+			manager,
+			undefined,
+		);
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(manager.start).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				config: expect.not.objectContaining({
+					sessionId: "resumed-session",
+				}),
+			}),
+		);
+	});
+
+	it("keeps explicit empty restarts eager for config-driven restarts", async () => {
+		let startCount = 0;
+		const manager = {
+			start: vi.fn().mockImplementation(async () => {
+				startCount += 1;
+				const sessionId = `session-${startCount}`;
+				return {
+					sessionId,
+					manifest: createManifest(sessionId),
+					manifestPath: `/tmp/${sessionId}.json`,
+					messagesPath: `/tmp/${sessionId}.messages.json`,
+				};
+			}),
+			readMessages: vi.fn().mockResolvedValue([]),
+			readSessionCompactionState: vi.fn().mockResolvedValue(undefined),
+			updateSessionCompactionState: vi.fn(),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+			ingestHookEvent: vi.fn().mockResolvedValue(undefined),
+			get: vi.fn(),
+			list: vi.fn(),
+			delete: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+		};
+		createCliCoreMock.mockResolvedValue(manager);
+		const { createInteractiveSessionRuntime } = await importRuntime();
+		const runtime = createInteractiveSessionRuntime({
+			config: createConfig(),
+			providerSettingsManager: createProviderSettingsManager(),
+			chatCommandState: createChatCommandState(),
+			requestToolApproval: vi.fn(),
+			resolveToolPolicy: () => ({ autoApprove: true }),
+			askQuestionRef: { current: null },
+			resolveMistakeLimitDecision: undefined,
+			switchToActModeTool: {} as never,
+			onAgentEvent: vi.fn(),
+			onTeamEvent: vi.fn(),
+			onPendingPrompts: vi.fn(),
+			onPendingPromptSubmitted: vi.fn(),
+		});
+
+		await runtime.ensureReady();
+		await runtime.restartEmpty();
+
+		expect(manager.stop).toHaveBeenCalledWith("session-1");
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(runtime.getActiveSessionId()).toBe("session-2");
+	});
+
+	it("recovers and retries when the active interactive session disappeared", async () => {
+		const manager = makeManager();
+		const messages = [
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "hi" }],
+			},
+		];
+		manager.readMessages.mockResolvedValue(messages);
+		manager.send
+			.mockRejectedValueOnce(new SessionNotFoundError("session-1"))
+			.mockResolvedValueOnce(makeTurnResult());
+		const runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		const result = await runtime.sendCurrentTurn({
+			prompt: "second hi",
+			mode: "act",
+		});
+
+		expect(result?.finishReason).toBe("completed");
+		expect(manager.readMessages).toHaveBeenCalledWith("session-1");
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(manager.start).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				initialMessages: messages,
+			}),
+		);
+		expect(manager.send).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({ sessionId: "session-1" }),
+		);
+		expect(manager.send).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({ sessionId: "session-2" }),
+		);
+		expect(runtime.getActiveSessionId()).toBe("session-2");
+	});
+
+	it("preserves the session id and applies changed provider config when restarting with the current messages", async () => {
+		const manager = makeManager();
+		const config = {
+			...createConfig(),
+			providerId: "cline",
+			modelId: "anthropic/claude-sonnet-4.6",
+			apiKey: "cline-key",
+		};
+		const messages: Message[] = [
+			{ role: "user", content: [{ type: "text", text: "hello" }] },
+		];
+		manager.readMessages.mockResolvedValue(messages);
+		const runtime = await makeRuntime(manager, { config });
+
+		await runtime.ensureReady();
+		expect(manager.start).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({
+				config: expect.objectContaining({
+					providerId: "cline",
+					modelId: "anthropic/claude-sonnet-4.6",
+					apiKey: "cline-key",
+				}),
+			}),
+		);
+		config.providerId = "openai-compatible";
+		config.modelId = "custom-model";
+		config.apiKey = "new-key";
+		await runtime.restartWithCurrentMessages();
+
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(manager.start).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				config: expect.objectContaining({
+					sessionId: "session-1",
+					providerId: "openai-compatible",
+					modelId: "custom-model",
+					apiKey: "new-key",
+				}),
+				initialMessages: messages,
+			}),
+		);
+	});
+
+	it("updates the active session connection in place without restarting", async () => {
+		const manager = makeManager();
+		const runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		await runtime.updateCurrentSessionConnection({
+			providerId: "openai",
+			modelId: "codex-test",
+		});
+
+		expect(manager.updateSessionConnection).toHaveBeenCalledWith("session-1", {
+			providerId: "openai",
+			modelId: "codex-test",
+		});
+		expect(manager.start).toHaveBeenCalledTimes(1);
+		expect(runtime.getActiveSessionId()).toBe("session-1");
+	});
+
+	it("does not reuse the session id when restarting empty", async () => {
+		const manager = makeManager();
+		const runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		await runtime.restartEmpty();
+
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		const secondStart = manager.start.mock.calls[1]?.[0] as {
+			config?: { sessionId?: string };
+		};
+		expect(secondStart?.config?.sessionId).toBeUndefined();
+	});
+
+	it("recovers empty read-driven restarts when the active interactive session disappeared", async () => {
+		const manager = makeManager();
+		manager.readMessages.mockRejectedValueOnce(
+			new SessionNotFoundError("session-1"),
+		);
+		const runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		await runtime.restartWithCurrentMessages();
+
+		expect(manager.readMessages).toHaveBeenCalledWith("session-1");
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(manager.start).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				initialMessages: [],
+			}),
+		);
+		expect(runtime.getActiveSessionId()).toBe("session-2");
+	});
+
+	it("does not restart with stale messages when another operation changes the active session during a read", async () => {
+		const manager = makeManager();
+		let runtime!: Awaited<ReturnType<typeof makeRuntime>>;
+		manager.readMessages.mockImplementationOnce(async () => {
+			await runtime.restartEmpty();
+			return [
+				{
+					role: "user" as const,
+					content: [{ type: "text" as const, text: "stale" }],
+				},
+			];
+		});
+		runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		await runtime.restartWithCurrentMessages();
+
+		expect(manager.start).toHaveBeenCalledTimes(2);
+		expect(runtime.getActiveSessionId()).toBe("session-2");
+	});
+
+	it("waits for missing-session recovery before cleanup disposes the manager", async () => {
+		const manager = makeManager();
+		const recoveryRead = deferred<Message[]>();
+		manager.readMessages
+			.mockImplementationOnce(() => recoveryRead.promise)
+			.mockResolvedValue([]);
+		manager.get.mockResolvedValue(undefined);
+		manager.getAccumulatedUsage.mockResolvedValue(undefined);
+		manager.send.mockRejectedValueOnce(new SessionNotFoundError("session-1"));
+		const runtime = await makeRuntime(manager);
+
+		await runtime.ensureReady();
+		const sendPromise = runtime
+			.sendCurrentTurn({
+				prompt: "second hi",
+				mode: "act",
+			})
+			.catch((error) => error);
+		await vi.waitFor(() => {
+			expect(manager.readMessages).toHaveBeenCalledWith("session-1");
+		});
+
+		let cleanupSettled = false;
+		const cleanupPromise = runtime.cleanup().finally(() => {
+			cleanupSettled = true;
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(cleanupSettled).toBe(false);
+		expect(manager.get).not.toHaveBeenCalled();
+		expect(manager.dispose).not.toHaveBeenCalled();
+
+		recoveryRead.resolve([]);
+		await cleanupPromise;
+		const sendError = await sendPromise;
+
+		expect(sendError).toBeInstanceOf(SessionNotFoundError);
+		expect(manager.dispose).toHaveBeenCalledWith("cli_interactive_shutdown");
+	});
+});
diff --git a/apps/cli/src/runtime/interactive/session-runtime.ts b/apps/cli/src/runtime/interactive/session-runtime.ts
new file mode 100644
index 0000000..a52dfa3
--- /dev/null
+++ b/apps/cli/src/runtime/interactive/session-runtime.ts
@@ -0,0 +1,888 @@
+import {
+	type AgentEvent,
+	type AgentHooks,
+	type CheckpointEntry,
+	createSessionCompactionState,
+	isSessionNotFoundError,
+	type PendingPromptMutationResult,
+	type ProviderSettingsManager,
+	projectSessionCompactionState,
+	readSessionCheckpointHistory,
+	type SessionCompactionState,
+	SessionSource,
+	type TeamEvent,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+	type UserInstructionConfigService,
+} from "@cline/core";
+import type { Message } from "@cline/shared";
+import { createCliCore } from "../../session/session";
+import { submitAndExitInTerminal } from "../../utils/approval";
+import type {
+	ChatCommandState,
+	ForkSessionResult,
+} from "../../utils/chat-commands";
+import { createRuntimeHooks } from "../../utils/hooks";
+import { setActiveCliSession } from "../../utils/output";
+import { loadInteractiveResumeMessages } from "../../utils/resume";
+import type { Config } from "../../utils/types";
+import { markAbortInProgress } from "../active-runtime";
+import type {
+	PendingPromptSnapshot,
+	PendingPromptSubmittedEvent,
+} from "../session-events";
+import {
+	subscribeToAgentEvents,
+	subscribeToPendingPromptEvents,
+} from "../session-events";
+import { compactInteractiveMessages } from "./compaction";
+import {
+	createInteractiveExitSummary,
+	type InteractiveExitSummary,
+} from "./exit-summary";
+import { buildForkSessionMetadata } from "./fork/metadata";
+import { applyInteractiveModeConfig } from "./mode";
+import { buildInteractiveSessionConfig } from "./session-config";
+
+type CliCore = Awaited<ReturnType<typeof createCliCore>>;
+type RuntimeHooks = ReturnType<typeof createRuntimeHooks>;
+type StartedSession = Awaited<ReturnType<CliCore["start"]>>;
+type CurrentTurnInput = Omit<Parameters<CliCore["send"]>[0], "sessionId">;
+type CurrentTurnResult = Awaited<ReturnType<CliCore["send"]>>;
+export type SessionConnectionUpdate = Parameters<
+	CliCore["updateSessionConnection"]
+>[1];
+type AskQuestionRef = {
+	current: ((question: string, options: string[]) => Promise<string>) | null;
+};
+type CurrentMessagesRead =
+	| { messages: Message[]; status: "read" }
+	| { messages: Message[]; status: "recovered" }
+	| { messages: Message[]; status: "stale" };
+type MissingSessionRecovery = {
+	messages: Message[];
+};
+type ToolPolicyResolver = (
+	toolName: string,
+) => NonNullable<Config["toolPolicies"]>[string];
+
+function withInteractiveApprovalPolicyHook(
+	hooks: AgentHooks | undefined,
+	resolveToolPolicy: ToolPolicyResolver,
+): AgentHooks {
+	return {
+		...hooks,
+		beforeTool: async (ctx) => {
+			const result = await hooks?.beforeTool?.(ctx);
+			if (result?.stop || result?.skip) {
+				return result;
+			}
+			const policy = resolveToolPolicy(ctx.toolCall.toolName);
+			return {
+				...result,
+				policy: {
+					...result?.policy,
+					autoApprove: policy.autoApprove,
+				},
+			};
+		},
+	};
+}
+
+export function createInteractiveSessionRuntime(input: {
+	config: Config;
+	providerSettingsManager: ProviderSettingsManager;
+	userInstructionService?: UserInstructionConfigService;
+	resumeSessionId?: string;
+	chatCommandState: ChatCommandState;
+	requestToolApproval: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+	resolveToolPolicy: ToolPolicyResolver;
+	askQuestionRef: AskQuestionRef;
+	resolveMistakeLimitDecision: Config["onConsecutiveMistakeLimitReached"];
+	switchToActModeTool: NonNullable<Config["extraTools"]>[number];
+	onAgentEvent: (event: AgentEvent) => void;
+	onTeamEvent: (event: TeamEvent) => void;
+	onPendingPrompts: (event: PendingPromptSnapshot) => void;
+	onPendingPromptSubmitted: (event: PendingPromptSubmittedEvent) => void;
+}) {
+	let sessionManager: CliCore | undefined;
+	let runtimeHooks: RuntimeHooks | undefined;
+	let unsubscribeAgent = () => {};
+	let unsubscribePendingPrompts = () => {};
+	let startupPromise: Promise<void> | undefined;
+	let startupError: unknown;
+	let shutdownRequested = false;
+	let activeSessionId = "";
+	let abortRequested = false;
+	let missingSessionRecoveryPromise:
+		| Promise<MissingSessionRecovery>
+		| undefined;
+	// A reset can happen while an earlier manager.start() is still in flight.
+	// Bump this before resets and restarts so stale starts cannot become active.
+	let sessionStartGeneration = 0;
+	let manualCompactionAbortController: AbortController | undefined;
+
+	let pendingResumeSessionId = input.resumeSessionId?.trim() || undefined;
+
+	const clearActiveSession = (): void => {
+		activeSessionId = "";
+		setActiveCliSession(undefined);
+	};
+
+	const applyStartedSession = (started: StartedSession): void => {
+		setActiveCliSession({
+			manifest: started.manifest,
+		});
+		activeSessionId = started.sessionId;
+	};
+
+	const ensureSessionManager = async (): Promise<CliCore> => {
+		if (sessionManager) {
+			return sessionManager;
+		}
+		const manager = await createCliCore({
+			// Interactive startup must never wait for a detached hub daemon to boot.
+			// `auto` uses an already-compatible hub when one is immediately available,
+			// but falls back to the local runtime while the hub is prewarmed in the
+			// background. Forcing `hub` here routes through `ensureCompatibleLocalHubUrl`,
+			// which can poll for up to the hub startup timeout before the TUI is usable.
+			// Yolo and sandbox modes must stay fully local and must not prewarm or reuse
+			// the shared daemon hub.
+			backendMode: "auto",
+			forceLocalBackend:
+				input.config.mode === "yolo" || input.config.sandbox === true,
+			capabilities: {
+				toolExecutors: {
+					askQuestion: (question, options) => {
+						if (input.askQuestionRef.current) {
+							return input.askQuestionRef.current(question, options);
+						}
+						return Promise.resolve(options[0] ?? "");
+					},
+					submit: submitAndExitInTerminal,
+				},
+				requestToolApproval: input.requestToolApproval,
+			},
+			logger: input.config.logger,
+			cwd: input.config.cwd,
+			workspaceRoot: input.config.workspaceRoot,
+			toolPolicies: input.config.toolPolicies,
+		});
+		if (shutdownRequested) {
+			await manager.dispose("cli_interactive_startup_cancelled");
+			throw new Error("interactive runtime shutdown requested");
+		}
+		sessionManager = manager;
+		runtimeHooks = createRuntimeHooks({
+			verbose: input.config.verbose,
+			yolo: input.config.mode === "yolo",
+			cwd: input.config.cwd,
+			workspaceRoot: input.config.workspaceRoot,
+			dispatchHookEvent: async (payload) => {
+				await manager.ingestHookEvent(payload);
+			},
+		});
+		unsubscribeAgent = subscribeToAgentEvents(manager, input.onAgentEvent);
+		unsubscribePendingPrompts = subscribeToPendingPromptEvents(manager, {
+			onPendingPrompts: input.onPendingPrompts,
+			onPendingPromptSubmitted: input.onPendingPromptSubmitted,
+		});
+		return manager;
+	};
+
+	const buildSessionConfig = (): Config => {
+		if (!runtimeHooks) {
+			throw new Error("interactive runtime hooks are unavailable");
+		}
+		const hooks = withInteractiveApprovalPolicyHook(
+			runtimeHooks.hooks,
+			input.resolveToolPolicy,
+		);
+		return buildInteractiveSessionConfig({
+			config: input.config,
+			chatCommandState: input.chatCommandState,
+			runtimeHooks: { hooks },
+			onTeamEvent: input.onTeamEvent,
+			resolveMistakeLimitDecision: input.resolveMistakeLimitDecision,
+		});
+	};
+
+	const startFreshSession = async (
+		initial: Message[] = [],
+		sessionMetadata?: Record<string, unknown>,
+		initialCompactionState?: SessionCompactionState,
+		// Restarting an old session associate with this ID,
+		// For continuing the same conversation, e.g. after a config change.
+		sessionId?: string,
+	): Promise<void> => {
+		const generation = sessionStartGeneration;
+		const manager = await ensureSessionManager();
+		const started = await manager.start({
+			source: SessionSource.CLI,
+			config: {
+				...buildSessionConfig(),
+				...(sessionId ? { sessionId } : {}),
+			},
+			toolPolicies: input.config.toolPolicies,
+			interactive: true,
+			initialMessages: initial,
+			...(initialCompactionState ? { initialCompactionState } : {}),
+			...(sessionMetadata ? { sessionMetadata } : {}),
+			localRuntime: {
+				onTeamRestored: () => {},
+			},
+		});
+		if (generation !== sessionStartGeneration) {
+			await manager.stop(started.sessionId).catch(() => {});
+			return;
+		}
+		applyStartedSession(started);
+	};
+
+	const startResumedSession = async (
+		resumeId: string,
+		initial: Message[] | undefined,
+	): Promise<void> => {
+		const generation = sessionStartGeneration;
+		const manager = await ensureSessionManager();
+		const started = await manager.start({
+			source: SessionSource.CLI,
+			config: {
+				...buildSessionConfig(),
+				sessionId: resumeId,
+			},
+			toolPolicies: input.config.toolPolicies,
+			interactive: true,
+			initialMessages: initial,
+			localRuntime: {
+				onTeamRestored: () => {},
+			},
+		});
+		if (generation !== sessionStartGeneration) {
+			await manager.stop(started.sessionId).catch(() => {});
+			return;
+		}
+		applyStartedSession(started);
+	};
+
+	const ensureReady = async (): Promise<void> => {
+		if (activeSessionId) {
+			return;
+		}
+		if (startupPromise) {
+			return await startupPromise;
+		}
+		startupPromise = (async () => {
+			const manager = await ensureSessionManager();
+			const resumeSessionId = pendingResumeSessionId;
+			const initialMessages = await loadInteractiveResumeMessages(
+				manager,
+				resumeSessionId,
+			);
+			if (shutdownRequested) {
+				return;
+			}
+			if (resumeSessionId) {
+				await startResumedSession(resumeSessionId, initialMessages);
+				if (pendingResumeSessionId === resumeSessionId) {
+					pendingResumeSessionId = undefined;
+				}
+			} else {
+				await startFreshSession(initialMessages);
+			}
+		})().catch((error) => {
+			startupError = error;
+			throw error;
+		});
+		return await startupPromise;
+	};
+
+	const readCurrentMessages = async (): Promise<CurrentMessagesRead> => {
+		const manager = sessionManager;
+		const sessionId = activeSessionId;
+		if (!manager || !sessionId) {
+			return { messages: [], status: "read" };
+		}
+		try {
+			const messages = (await manager.readMessages(sessionId)) ?? [];
+			return {
+				messages,
+				status: activeSessionId === sessionId ? "read" : "stale",
+			};
+		} catch (error) {
+			if (
+				abortRequested ||
+				shutdownRequested ||
+				!isSessionNotFoundError(error)
+			) {
+				throw error;
+			}
+			const recovery = await recoverMissingActiveSession(error);
+			return { messages: recovery.messages, status: "recovered" };
+		}
+	};
+
+	const readCompactionState = async (
+		sessionId: string,
+	): Promise<SessionCompactionState | undefined> => {
+		const manager = sessionManager;
+		if (!manager) {
+			return undefined;
+		}
+		try {
+			return await manager.readSessionCompactionState(sessionId);
+		} catch (error) {
+			input.config.logger?.log?.("Failed to read session compaction state", {
+				sessionId,
+				error,
+				severity: "warn",
+			});
+			return undefined;
+		}
+	};
+
+	const recoverMissingActiveSession = async (
+		error: unknown,
+	): Promise<MissingSessionRecovery> => {
+		if (missingSessionRecoveryPromise) {
+			return await missingSessionRecoveryPromise;
+		}
+		missingSessionRecoveryPromise = (async () => {
+			const manager = sessionManager;
+			const missingSessionId = activeSessionId;
+			if (!manager || !missingSessionId || shutdownRequested) {
+				return { messages: [] };
+			}
+			const messages = await manager
+				.readMessages(missingSessionId)
+				.catch(() => []);
+			input.config.logger?.log("Recovering missing interactive session", {
+				sessionId: missingSessionId,
+				messageCount: messages.length,
+				error,
+				severity: "warn",
+			});
+			sessionStartGeneration += 1;
+			pendingResumeSessionId = undefined;
+			startupPromise = undefined;
+			startupError = undefined;
+			clearActiveSession();
+			await startFreshSession(messages);
+			return { messages };
+		})().finally(() => {
+			missingSessionRecoveryPromise = undefined;
+		});
+		return await missingSessionRecoveryPromise;
+	};
+
+	const readCurrentCompactionState = async (): Promise<
+		SessionCompactionState | undefined
+	> => {
+		if (!activeSessionId) {
+			return undefined;
+		}
+		return await readCompactionState(activeSessionId);
+	};
+
+	const stopCurrentSession = async (): Promise<void> => {
+		const sessionId = activeSessionId;
+		if (sessionManager && sessionId) {
+			await sessionManager.stop(sessionId);
+		}
+	};
+
+	const getExitSummary = async (): Promise<
+		InteractiveExitSummary | undefined
+	> => {
+		const manager = sessionManager;
+		const sessionId = activeSessionId.trim();
+		if (!manager || !sessionId) {
+			return undefined;
+		}
+		const readUsage = async () => {
+			const usageSummary = await manager
+				.getAccumulatedUsage(sessionId)
+				.catch(() => undefined);
+			return usageSummary?.aggregateUsage ?? usageSummary?.usage;
+		};
+		const [row, messages, usage] = await Promise.all([
+			manager.get(sessionId).catch(() => undefined),
+			manager.readMessages(sessionId).catch(() => []),
+			readUsage(),
+		]);
+		return createInteractiveExitSummary({
+			sessionId,
+			row,
+			messages,
+			usage,
+		});
+	};
+
+	const restartWithMessages = async (
+		messages: Message[],
+		sessionMetadata?: Record<string, unknown>,
+		initialCompactionState?: SessionCompactionState,
+		options?: { preserveSessionId?: boolean },
+	): Promise<void> => {
+		// Config-only restarts (model/mode/account changes) continue the same
+		// conversation, so they must keep the session id — otherwise each
+		// restart mints a new session history entry for the same conversation.
+		const reuseSessionId = options?.preserveSessionId
+			? activeSessionId || undefined
+			: undefined;
+		sessionStartGeneration += 1;
+		pendingResumeSessionId = undefined;
+		startupError = undefined;
+		// Publish the restart as the in-flight startup. Teardown leaves a window
+		// with no active session, and without this barrier a concurrent
+		// ensureReady() (e.g. a message submitted right after a plan/act toggle)
+		// reads that window as "no session" and boots an empty session that then
+		// races the restarted one for the active slot.
+		const restart = (async () => {
+			await stopCurrentSession();
+			clearActiveSession();
+			await startFreshSession(
+				messages,
+				sessionMetadata,
+				initialCompactionState,
+				reuseSessionId,
+			);
+		})().catch((error) => {
+			startupError = error;
+			throw error;
+		});
+		startupPromise = restart;
+		try {
+			await restart;
+		} finally {
+			// Restore the pre-restart steady state (startupPromise unset) so a
+			// failed restart stays retryable by the next ensureReady(). A newer
+			// startup that already replaced the barrier is left alone.
+			if (startupPromise === restart) {
+				startupPromise = undefined;
+			}
+		}
+	};
+
+	const restartWithCurrentMessages = async (): Promise<void> => {
+		const [{ messages, status }, compactionState] = await Promise.all([
+			readCurrentMessages(),
+			readCurrentCompactionState(),
+		]);
+		if (status !== "read") {
+			// If reading recovered a missing hub session, the current messages are
+			// already in the replacement session. If the read is stale, another async
+			// operation changed the active session while this read was in flight.
+			return;
+		}
+		const projectedMessages = compactionState
+			? projectSessionCompactionState(compactionState, messages)
+			: undefined;
+		await restartWithMessages(
+			messages,
+			undefined,
+			projectedMessages
+				? createSessionCompactionState({
+						sourceMessages: messages,
+						compactedMessages: projectedMessages,
+						systemPrompt: compactionState?.system_prompt,
+					})
+				: undefined,
+			{ preserveSessionId: true },
+		);
+	};
+
+	const updateCurrentSessionConnection = async (
+		update: SessionConnectionUpdate,
+	): Promise<void> => {
+		await ensureReady();
+		const manager = sessionManager;
+		const sessionId = activeSessionId;
+		if (!manager || !sessionId) {
+			// No live session to update; the next startup builds its config from
+			// the already-mutated CLI config, so nothing else is needed.
+			return;
+		}
+		await manager.updateSessionConnection(sessionId, update);
+	};
+
+	const restartEmpty = async (): Promise<void> => {
+		await restartWithMessages([]);
+	};
+
+	const resetForNewSession = async (): Promise<void> => {
+		sessionStartGeneration += 1;
+		pendingResumeSessionId = undefined;
+		startupPromise = undefined;
+		startupError = undefined;
+		const manager = sessionManager;
+		const sessionId = activeSessionId;
+		clearActiveSession();
+		if (manager && sessionId) {
+			await manager.stop(sessionId);
+		}
+	};
+
+	const applyMode = async (mode: "plan" | "act"): Promise<void> => {
+		await applyInteractiveModeConfig({
+			config: input.config,
+			mode,
+			switchToActModeTool: input.switchToActModeTool,
+		});
+		await restartWithCurrentMessages();
+	};
+
+	const sendCurrentTurn = async (
+		turnInput: CurrentTurnInput,
+	): Promise<CurrentTurnResult> => {
+		if (!sessionManager) {
+			throw startupError instanceof Error
+				? startupError
+				: new Error("interactive session manager is unavailable");
+		}
+		const manager = sessionManager;
+		try {
+			return await manager.send({
+				sessionId: activeSessionId,
+				...turnInput,
+			});
+		} catch (error) {
+			if (
+				abortRequested ||
+				shutdownRequested ||
+				!isSessionNotFoundError(error)
+			) {
+				throw error;
+			}
+			await recoverMissingActiveSession(error);
+			if (!activeSessionId || abortRequested || shutdownRequested) {
+				throw error;
+			}
+			return await manager.send({
+				sessionId: activeSessionId,
+				...turnInput,
+			});
+		}
+	};
+
+	const updatePendingPrompt = async (input: {
+		promptId: string;
+		prompt?: string;
+		delivery?: "queue" | "steer";
+	}): Promise<PendingPromptMutationResult> => {
+		if (!sessionManager) {
+			throw startupError instanceof Error
+				? startupError
+				: new Error("interactive session manager is unavailable");
+		}
+		const result = await sessionManager.pendingPrompts.update({
+			sessionId: activeSessionId,
+			...input,
+		});
+		return {
+			sessionId: result.sessionId,
+			prompts: result.prompts,
+			prompt: result.prompt,
+			updated: result.updated,
+			removed: result.removed,
+		};
+	};
+
+	const getAccumulatedUsage = async (
+		fallback: NonNullable<CurrentTurnResult>["usage"],
+	) => {
+		if (!sessionManager) {
+			return fallback;
+		}
+		const usageSummary =
+			await sessionManager.getAccumulatedUsage(activeSessionId);
+		return usageSummary?.aggregateUsage ?? usageSummary?.usage ?? fallback;
+	};
+
+	const forkCurrentSession = async (): Promise<
+		ForkSessionResult | undefined
+	> => {
+		const manager = sessionManager;
+		if (!manager || !activeSessionId) {
+			return undefined;
+		}
+		const forkedFromSessionId = activeSessionId;
+		const sessionRecord = await manager.get(forkedFromSessionId);
+		const messages = await manager
+			.readMessages(forkedFromSessionId)
+			.catch(() => undefined);
+		if (!messages) {
+			return undefined;
+		}
+		if (messages.length === 0) {
+			throw new Error("Cannot fork an empty session.");
+		}
+		const compactionState = await readCompactionState(forkedFromSessionId);
+		const projectedMessages = compactionState
+			? projectSessionCompactionState(compactionState, messages)
+			: undefined;
+		await manager.stop(forkedFromSessionId);
+		const forkMetadata = buildForkSessionMetadata({
+			forkedFromSessionId,
+			forkedAt: new Date().toISOString(),
+			sourceSession: sessionRecord,
+			messages,
+		});
+		await startFreshSession(
+			messages,
+			forkMetadata,
+			projectedMessages
+				? createSessionCompactionState({
+						sourceMessages: messages,
+						compactedMessages: projectedMessages,
+						systemPrompt: compactionState?.system_prompt,
+					})
+				: undefined,
+		);
+		return { forkedFromSessionId, newSessionId: activeSessionId };
+	};
+
+	const resumeSession = async (sessionId: string): Promise<Message[]> => {
+		const manager = await ensureSessionManager();
+		const sessionRecord = await manager.get(sessionId);
+		if (!sessionRecord) {
+			throw new Error(`Session ${sessionId} was not found.`);
+		}
+		const messages = await loadInteractiveResumeMessages(manager, sessionId);
+		if (!messages || messages.length === 0) {
+			throw new Error(`Session ${sessionId} has no messages to resume.`);
+		}
+		await stopCurrentSession();
+		await startResumedSession(sessionId, messages);
+		return messages;
+	};
+
+	const compactCurrentSession = async (): Promise<{
+		messagesBefore: number;
+		messagesAfter: number;
+		workingContextMessagesAfter?: number;
+		compacted: boolean;
+	}> => {
+		if (input.config.compaction?.enabled === false) {
+			throw new Error(
+				"Cannot compact because compaction is off for this session.",
+			);
+		}
+		const manager = sessionManager;
+		const sourceSessionId = activeSessionId;
+		if (!manager || !sourceSessionId) {
+			return { messagesBefore: 0, messagesAfter: 0, compacted: false };
+		}
+		const { messages, status } = await readCurrentMessages();
+		if (status === "stale" || (status === "recovered" && !activeSessionId)) {
+			return { messagesBefore: 0, messagesAfter: 0, compacted: false };
+		}
+		// If reading messages recovered the session, `messages` are the same messages
+		// used to seed the replacement session, so it is safe to compact the current
+		// active session with them.
+		const messagesBefore = messages.length;
+		if (messagesBefore === 0) {
+			return { messagesBefore: 0, messagesAfter: 0, compacted: false };
+		}
+		const sessionRecord = await manager.get(sourceSessionId);
+		if (sessionRecord?.status === "running") {
+			throw new Error(
+				"Cannot compact while the current turn is running. Wait for it to finish or abort it first.",
+			);
+		}
+		let result: Awaited<ReturnType<typeof compactInteractiveMessages>>;
+		const abortController = new AbortController();
+		manualCompactionAbortController = abortController;
+		try {
+			result = await compactInteractiveMessages({
+				config: input.config,
+				providerSettingsManager: input.providerSettingsManager,
+				sessionId: sourceSessionId,
+				messages,
+				abortSignal: abortController.signal,
+			});
+		} finally {
+			if (manualCompactionAbortController === abortController) {
+				manualCompactionAbortController = undefined;
+			}
+		}
+		if (!result.compacted) {
+			return {
+				messagesBefore,
+				messagesAfter: messagesBefore,
+				compacted: false,
+			};
+		}
+		if (!result.compactionState) {
+			return {
+				messagesBefore,
+				messagesAfter: messagesBefore,
+				compacted: false,
+			};
+		}
+		const updated = await manager.updateSessionCompactionState(
+			sourceSessionId,
+			result.compactionState,
+		);
+		if (!updated.updated) {
+			throw new Error("Compaction could not be saved. Try again.");
+		}
+		return {
+			messagesBefore,
+			messagesAfter: result.canonicalMessages.length,
+			workingContextMessagesAfter: result.compactionState?.messages.length,
+			compacted: true,
+		};
+	};
+
+	const getCheckpointData = async (): Promise<
+		| {
+				messages: Message[];
+				checkpointHistory: CheckpointEntry[];
+		  }
+		| undefined
+	> => {
+		if (!sessionManager || !activeSessionId) {
+			return undefined;
+		}
+		const sessionRecord = await sessionManager.get(activeSessionId);
+		if (!sessionRecord) {
+			return undefined;
+		}
+		const checkpointHistory = readSessionCheckpointHistory(sessionRecord);
+		const { messages, status } = await readCurrentMessages();
+		if (status !== "read") {
+			return undefined;
+		}
+		return { messages, checkpointHistory };
+	};
+
+	const restoreCheckpoint = async (
+		runCount: number,
+		restoreWorkspace: boolean,
+	): Promise<{ newSessionId: string; messages: Message[] } | undefined> => {
+		const manager = sessionManager;
+		if (!manager || !activeSessionId) {
+			return undefined;
+		}
+		const sourceSessionId = activeSessionId;
+		const restored = await manager.restore({
+			sessionId: sourceSessionId,
+			checkpointRunCount: runCount,
+			cwd: input.config.cwd,
+			restore: {
+				messages: true,
+				workspace: restoreWorkspace,
+				omitCheckpointMessageFromSession: true,
+			},
+			start: {
+				source: SessionSource.CLI,
+				config: buildSessionConfig(),
+				toolPolicies: input.config.toolPolicies,
+				interactive: true,
+				localRuntime: {
+					onTeamRestored: () => {},
+				},
+			},
+		});
+		if (!restored.startResult || !restored.sessionId) {
+			throw new Error("Checkpoint restore did not return a new session");
+		}
+		applyStartedSession(restored.startResult);
+		if (restored.sessionId !== sourceSessionId) {
+			try {
+				await manager.stop(sourceSessionId);
+			} catch (error) {
+				input.config.logger?.log(
+					"Failed to stop source session after restore",
+					{
+						sessionId: sourceSessionId,
+						error,
+						severity: "warn",
+					},
+				);
+			}
+		}
+		const restoredMessages = restored.messages ?? [];
+		return {
+			newSessionId: restored.sessionId,
+			messages: restoredMessages,
+		};
+	};
+
+	const resetAbortRequest = (): void => {
+		abortRequested = false;
+	};
+
+	const abortAll = (): boolean => {
+		if (abortRequested || !sessionManager || !activeSessionId) {
+			return false;
+		}
+		abortRequested = true;
+		markAbortInProgress();
+		manualCompactionAbortController?.abort(
+			new Error("Interactive runtime abort requested"),
+		);
+		sessionManager
+			.abort(activeSessionId, new Error("Interactive runtime abort requested"))
+			.catch(() => {});
+		return true;
+	};
+
+	let cleanupPromise: Promise<InteractiveExitSummary | undefined> | undefined;
+	const cleanup = async (): Promise<InteractiveExitSummary | undefined> => {
+		if (cleanupPromise) {
+			return await cleanupPromise;
+		}
+		cleanupPromise = (async () => {
+			shutdownRequested = true;
+			let exitSummary: InteractiveExitSummary | undefined;
+			try {
+				await startupPromise?.catch(() => {});
+				await missingSessionRecoveryPromise?.catch(() => {});
+			} finally {
+				unsubscribeAgent();
+				unsubscribePendingPrompts();
+			}
+			try {
+				exitSummary = await getExitSummary();
+				// Mark hooks shut down before session disposal so late abort/stop
+				// emissions cannot dispatch over a closing hub transport.
+				await runtimeHooks?.shutdown();
+				await stopCurrentSession();
+			} finally {
+				if (sessionManager) {
+					await sessionManager.dispose("cli_interactive_shutdown");
+				}
+			}
+			return exitSummary;
+		})();
+		return await cleanupPromise;
+	};
+
+	return {
+		ensureReady,
+		sendCurrentTurn,
+		updatePendingPrompt,
+		getAccumulatedUsage,
+		readCurrentMessages,
+		restartEmpty,
+		resetForNewSession,
+		restartWithMessages,
+		restartWithCurrentMessages,
+		updateCurrentSessionConnection,
+		resumeSession,
+		forkCurrentSession,
+		compactCurrentSession,
+		getCheckpointData,
+		restoreCheckpoint,
+		applyMode,
+		resetAbortRequest,
+		abortAll,
+		cleanup,
+		getActiveSessionId: () => activeSessionId,
+		isShutdownRequested: () => shutdownRequested,
+	};
+}
diff --git a/apps/cli/src/runtime/prompt.test.ts b/apps/cli/src/runtime/prompt.test.ts
new file mode 100644
index 0000000..9cd3c19
--- /dev/null
+++ b/apps/cli/src/runtime/prompt.test.ts
@@ -0,0 +1,45 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { buildUserInputMessage } from "./prompt";
+
+describe("buildUserInputMessage", () => {
+	it("extracts image mentions into userImages", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "cli-prompt-"));
+		const imagePath = join(dir, "hero.png");
+		writeFileSync(imagePath, Buffer.from("hello"));
+
+		const result = await buildUserInputMessage(
+			`@${imagePath} describe this image`,
+		);
+
+		expect(result.prompt).toBe("[image: hero.png] describe this image");
+		expect(result.userImages).toEqual(["data:image/png;base64,aGVsbG8="]);
+		expect(result.userFiles).toEqual([]);
+	});
+
+	it("extracts text file mentions into userFiles", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "cli-prompt-"));
+		const filePath = join(dir, "notes.md");
+		writeFileSync(filePath, "# Notes\n");
+
+		const result = await buildUserInputMessage(`summarize @${filePath}`);
+
+		expect(result.prompt).toBe("summarize [file: notes.md]");
+		expect(result.userImages).toEqual([]);
+		expect(result.userFiles).toEqual([filePath]);
+	});
+
+	it("extracts quoted text file mentions with spaces into userFiles", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "cli prompt "));
+		const filePath = join(dir, "notes with spaces.md");
+		writeFileSync(filePath, "# Notes\n");
+
+		const result = await buildUserInputMessage(`summarize @"${filePath}"`);
+
+		expect(result.prompt).toBe("summarize [file: notes with spaces.md]");
+		expect(result.userImages).toEqual([]);
+		expect(result.userFiles).toEqual([filePath]);
+	});
+});
diff --git a/apps/cli/src/runtime/prompt.ts b/apps/cli/src/runtime/prompt.ts
new file mode 100644
index 0000000..cff0245
--- /dev/null
+++ b/apps/cli/src/runtime/prompt.ts
@@ -0,0 +1,202 @@
+import { statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, resolve } from "node:path";
+import {
+	buildWorkspaceMetadata,
+	mergeRulesForSystemPrompt,
+	type UserInstructionConfigService,
+} from "@cline/core";
+import { type AgentMode, buildClineSystemPrompt } from "@cline/shared";
+import { isImagePath, loadImageAsDataUrl } from "../utils/image-attachments";
+
+const MODE_TAG_INSTRUCTIONS = `# Plan / Act Modes
+
+User messages arrive wrapped in a <user_input mode="..."> tag. The mode attribute is the interaction mode the user was in when they sent that message: "plan" means plan-mode constraints applied (explore, analyze, and align on a plan -- no edits or state-changing commands), while "act" (or "yolo") means implementation was allowed. If the mode attribute changes between messages, the user switched modes -- the newest message's mode is what governs right now, regardless of what earlier messages allowed. A <mode_notice> block inside a message marks exactly when such a switch happened.`;
+
+const PLAN_MODE_INSTRUCTIONS = `# Plan Mode
+
+You are in Plan mode. Your role is to explore, analyze, and plan -- not to execute.
+
+- Read files, search the codebase, and gather context to understand the problem
+- Ask clarifying questions when requirements are ambiguous
+- Present your plan as a structured outline with clear steps
+- Explain tradeoffs between different approaches when they exist
+- Do NOT edit files, write code, run destructive commands, or make any changes
+- Do NOT implement anything -- focus on understanding and alignment first
+
+Once the user has reviewed your plan and explicitly approved it in a follow-up message, use the switch_to_act_mode tool to switch to act mode and begin implementation. Calling switch_to_act_mode immediately starts execution, so never call it in the same turn you present a plan and never treat the original task request as approval -- end your turn after presenting the plan and wait for the user's response.`;
+
+export async function resolveSystemPrompt(input: {
+	cwd: string;
+	explicitSystemPrompt?: string;
+	providerId?: string;
+	rules?: string;
+	mode?: AgentMode;
+}): Promise<string> {
+	const metadata = await buildWorkspaceMetadata(input.cwd);
+	let rules = mergeRulesForSystemPrompt(undefined, input.rules);
+	// Both modes get the mode-tag explanation: after a switch, the transcript
+	// still contains messages tagged with the other mode.
+	rules = rules
+		? `${rules}\n\n${MODE_TAG_INSTRUCTIONS}`
+		: MODE_TAG_INSTRUCTIONS;
+	if (input.mode === "plan") {
+		rules = `${rules}\n\n${PLAN_MODE_INSTRUCTIONS}`;
+	}
+	return buildClineSystemPrompt({
+		ide: "Terminal Shell",
+		workspaceRoot: input.cwd,
+		workspaceName: basename(input.cwd),
+		metadata,
+		rules,
+		mode: input.mode,
+		providerId: input.providerId,
+		overridePrompt: input.explicitSystemPrompt,
+		platform:
+			(typeof process !== "undefined" && process?.platform) || "unknown",
+	});
+}
+
+const FILE_MENTION_PREFIX = String.raw`(?:\/|~\/|\.{1,2}\/)`;
+const FILE_MENTION_PATTERN_TEST = new RegExp(
+	String.raw`@(?:"${FILE_MENTION_PREFIX}[^"\r\n]+"|${FILE_MENTION_PREFIX}\S+)`,
+	"i",
+);
+const FILE_MENTION_PATTERN_EXEC = new RegExp(
+	String.raw`@(?:"(${FILE_MENTION_PREFIX}[^"\r\n]+)"|(${FILE_MENTION_PREFIX}\S+))`,
+	"g",
+);
+function hasFileMentions(prompt: string): boolean {
+	return FILE_MENTION_PATTERN_TEST.test(prompt);
+}
+
+function extractFileMentions(
+	prompt: string,
+): Array<{ path: string; index: number; raw: string }> {
+	const matches: Array<{ path: string; index: number; raw: string }> = [];
+	let match: RegExpExecArray | null;
+	const pattern = new RegExp(
+		FILE_MENTION_PATTERN_EXEC.source,
+		FILE_MENTION_PATTERN_EXEC.flags,
+	);
+
+	for (;;) {
+		match = pattern.exec(prompt);
+		if (!match) break;
+		const path = match[1] ?? match[2];
+		if (!path) continue;
+		matches.push({
+			path,
+			index: match.index,
+			raw: match[0],
+		});
+	}
+	return matches;
+}
+
+function resolveMentionPath(filePath: string): string {
+	if (filePath.startsWith("~/")) {
+		return resolve(homedir(), filePath.slice(2));
+	}
+	return resolve(filePath);
+}
+
+export async function buildUserInputMessage(
+	rawPrompt: string,
+	userInstructionService?: UserInstructionConfigService,
+): Promise<{
+	prompt: string;
+	userImages: string[];
+	userFiles: string[];
+}> {
+	// First, resolve slash commands if the core config service is available.
+	let prompt = rawPrompt;
+	if (userInstructionService) {
+		prompt = userInstructionService.resolveRuntimeSlashCommand(rawPrompt);
+	}
+
+	if (!hasFileMentions(prompt)) {
+		return {
+			prompt,
+			userImages: [],
+			userFiles: [],
+		};
+	}
+
+	const fileMentions = extractFileMentions(prompt);
+
+	if (fileMentions.length === 0) {
+		return {
+			prompt,
+			userImages: [],
+			userFiles: [],
+		};
+	}
+
+	fileMentions.sort((a, b) => b.index - a.index);
+
+	let processedPrompt = prompt;
+	const userImages: string[] = [];
+	const userFiles: string[] = [];
+	const loadedImages: Array<{
+		index: number;
+		dataUrl: string;
+		fileName: string;
+	}> = [];
+	const loadedFiles: Array<{
+		index: number;
+		path: string;
+		fileName: string;
+	}> = [];
+
+	for (const mention of fileMentions) {
+		try {
+			const resolvedPath = resolveMentionPath(mention.path);
+			const stats = statSync(resolvedPath);
+			if (!stats.isFile()) {
+				throw new Error(`Path is not a file: ${resolvedPath}`);
+			}
+			const fileName = basename(resolvedPath);
+
+			if (isImagePath(resolvedPath)) {
+				const dataUrl = loadImageAsDataUrl(resolvedPath);
+				loadedImages.push({
+					index: mention.index,
+					dataUrl,
+					fileName,
+				});
+				processedPrompt = processedPrompt.replace(
+					mention.raw,
+					`[image: ${fileName}]`,
+				);
+				continue;
+			}
+
+			loadedFiles.push({
+				index: mention.index,
+				path: resolvedPath,
+				fileName,
+			});
+			processedPrompt = processedPrompt.replace(
+				mention.raw,
+				`[file: ${fileName}]`,
+			);
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			console.error(`[warning] ${errorMsg}`);
+		}
+	}
+
+	for (const image of loadedImages.reverse()) {
+		userImages.push(image.dataUrl);
+	}
+	for (const file of loadedFiles.reverse()) {
+		userFiles.push(file.path);
+	}
+
+	return {
+		prompt: processedPrompt,
+		userImages,
+		userFiles,
+	};
+}
diff --git a/apps/cli/src/runtime/run-agent.test.ts b/apps/cli/src/runtime/run-agent.test.ts
new file mode 100644
index 0000000..706e0cd
--- /dev/null
+++ b/apps/cli/src/runtime/run-agent.test.ts
@@ -0,0 +1,1303 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const sessionManagerMocks = vi.hoisted(() => ({
+	start: vi.fn(),
+	send: vi.fn(),
+	stop: vi.fn(),
+	dispose: vi.fn(),
+	abort: vi.fn(),
+	getAccumulatedUsage: vi.fn(),
+}));
+
+const hookMocks = vi.hoisted(() => ({
+	createRuntimeHooks: vi.fn(),
+	runtimeHooks: {
+		hooks: undefined,
+		shutdown: vi.fn(),
+	},
+}));
+
+const outputMocks = vi.hoisted(() => ({
+	writeln: vi.fn(),
+	writeErr: vi.fn(),
+	emitJsonLine: vi.fn(),
+	getActiveCliSession: vi.fn(() => undefined),
+	setActiveCliSession: vi.fn(),
+	formatUsd: vi.fn(() => "$0"),
+	c: { dim: "", reset: "" },
+}));
+
+const sessionEventsMocks = vi.hoisted(() => ({
+	listener: undefined as ((event: unknown) => void) | undefined,
+	subscribeToAgentEvents: vi.fn(
+		(_: unknown, listener: (event: unknown) => void) => {
+			sessionEventsMocks.listener = listener;
+			return () => {};
+		},
+	),
+}));
+
+const CLINE_PASS_SUBSCRIPTION_URL =
+	"https://app.cline.bot/dashboard/subscription?personal=true";
+const CLI_SUBSCRIPTION_URL =
+	"https://app.cline.bot/promo?code=CLI-8OFF&personal=true";
+const SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLINE_PASS_SUBSCRIPTION_URL}`;
+const CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLI_SUBSCRIPTION_URL}`;
+const CLINE_PASS_LIMIT_DETAIL_MESSAGE =
+	"You have reached your 5-hour Clinepass limit. The limit resets in 5h, please try again later.";
+const CLI_CLINE_PASS_LIMIT_MESSAGE = [
+	"ClinePass limit reached",
+	CLINE_PASS_LIMIT_DETAIL_MESSAGE,
+	"Switch to Cline usage-based billing and retry with the Cline provider.",
+	"Interactive CLI: open the model selector with /model, choose Cline, then retry.",
+	"Headless CLI: rerun with --provider cline.",
+].join("\n");
+const CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE =
+	"Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass";
+
+vi.mock("@cline/core", () => ({
+	getClineOrgIndividualInferenceSubscriptionMessage: () =>
+		CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE,
+	getClinePassSubscriptionUrl: () => CLINE_PASS_SUBSCRIPTION_URL,
+	isClineNotSubscribedError: (error: unknown) =>
+		error instanceof Error && error.name === "ClineNotSubscribedError",
+	isClineNotSubscribedMessage: (text: string) =>
+		text
+			.toLowerCase()
+			.includes("the user is not subscribed to required model plan"),
+	isClineOrgIndividualInferenceSubscriptionError: (error: unknown) =>
+		error instanceof Error &&
+		error.name === "ClineOrgIndividualInferenceSubscriptionError",
+	isClineOrgIndividualInferenceSubscriptionMessage: (text: string) =>
+		text
+			.toLowerCase()
+			.includes(
+				"organization accounts cannot use individual model inference subscriptions",
+			),
+	isClinePassLimitError: (error: unknown) =>
+		error instanceof Error && error.name === "ClinePassLimitError",
+	extractClinePassLimitMessage: (text: string) => {
+		const normalized = text.toLowerCase();
+		const prefix = "you have reached your";
+		const suffix = "please try again later.";
+		const start = normalized.indexOf(prefix);
+		if (start === -1) return undefined;
+		const suffixStart = normalized.indexOf(suffix, start);
+		if (suffixStart === -1) return undefined;
+		const end = suffixStart + suffix.length;
+		if (!normalized.slice(start, end).includes("clinepass limit")) {
+			return undefined;
+		}
+		return text.slice(start, end);
+	},
+	isClinePassLimitMessage: (text: string) => {
+		const normalized = text.toLowerCase();
+		return (
+			normalized.includes("you have reached your") &&
+			normalized.includes("clinepass limit") &&
+			normalized.includes("please try again later.")
+		);
+	},
+	prewarmFileIndex: vi.fn(async () => undefined),
+	SessionSource: {
+		CLI: "cli",
+	},
+}));
+
+vi.mock("../utils/approval", () => ({
+	askQuestionInTerminal: vi.fn(),
+	requestToolApproval: vi.fn(),
+	submitAndExitInTerminal: vi.fn(),
+}));
+
+vi.mock("../utils/events", () => ({
+	handleEvent: vi.fn(),
+	handleTeamEvent: vi.fn(),
+}));
+
+vi.mock("../utils/hooks", () => ({
+	createRuntimeHooks: hookMocks.createRuntimeHooks,
+}));
+
+vi.mock("../utils/output", () => outputMocks);
+
+vi.mock("../session/session", () => ({
+	createCliCore: vi.fn(async () => sessionManagerMocks),
+}));
+
+vi.mock("./active-runtime", () => ({
+	setActiveRuntimeAbort: vi.fn(),
+}));
+
+vi.mock("./format", () => ({
+	describeAbortSource: vi.fn(() => "aborted"),
+	resolveMistakeLimitDecision: vi.fn(),
+}));
+
+vi.mock("./interactive-welcome", () => ({
+	resolveClineWelcomeLine: vi.fn(async () => undefined),
+}));
+
+vi.mock("./prompt", () => ({
+	buildUserInputMessage: vi.fn(async () => ({
+		prompt: "prompt",
+		userImages: [],
+		userFiles: [],
+	})),
+}));
+
+vi.mock("./session-events", () => ({
+	subscribeToAgentEvents: sessionEventsMocks.subscribeToAgentEvents,
+}));
+
+describe("runAgent", () => {
+	const originalExitCode = process.exitCode;
+
+	beforeEach(() => {
+		process.exitCode = undefined;
+		sessionManagerMocks.start.mockReset();
+		sessionManagerMocks.send.mockReset();
+		sessionManagerMocks.stop.mockReset();
+		sessionManagerMocks.stop.mockResolvedValue(undefined);
+		sessionManagerMocks.dispose.mockReset();
+		sessionManagerMocks.dispose.mockResolvedValue(undefined);
+		sessionManagerMocks.abort.mockReset();
+		sessionManagerMocks.abort.mockResolvedValue(undefined);
+		sessionManagerMocks.getAccumulatedUsage.mockReset();
+		hookMocks.runtimeHooks.shutdown.mockReset();
+		hookMocks.runtimeHooks.shutdown.mockResolvedValue(undefined);
+		hookMocks.createRuntimeHooks.mockReturnValue(hookMocks.runtimeHooks);
+		outputMocks.writeErr.mockReset();
+		outputMocks.writeln.mockReset();
+		outputMocks.emitJsonLine.mockReset();
+		outputMocks.setActiveCliSession.mockReset();
+		sessionEventsMocks.listener = undefined;
+		sessionEventsMocks.subscribeToAgentEvents.mockClear();
+		vi.unstubAllGlobals();
+	});
+
+	afterEach(() => {
+		process.exitCode = originalExitCode;
+		vi.clearAllMocks();
+	});
+
+	it("starts the session with normalized user input", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "ok",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent(
+				'<user_command slash="team">spawn a team of agents for the following task: how is rpc server started?</user_command>',
+				{
+					cwd: process.cwd(),
+					enableAgentTeams: true,
+					enableSpawnAgent: false,
+					enableTools: [],
+					execution: {
+						maxConsecutiveMistakes: 3,
+					},
+					logger: undefined,
+					mode: "act",
+					modelId: "google/gemini-3-flash-preview",
+					outputMode: "text",
+					providerId: "openrouter",
+					systemPrompt: "system",
+					thinking: false,
+					toolPolicies: { "*": { autoApprove: true } },
+					verbose: false,
+					workspaceRoot: process.cwd(),
+				} as never,
+			),
+		).resolves.toBeUndefined();
+
+		expect(sessionManagerMocks.start).toHaveBeenCalledWith(
+			expect.objectContaining({
+				prompt: "prompt",
+			}),
+		);
+		const startInput = sessionManagerMocks.start.mock.calls[0]?.[0] as
+			| { localRuntime?: Record<string, unknown> }
+			| undefined;
+		expect(startInput?.localRuntime).toEqual(
+			expect.objectContaining({
+				onTeamRestored: expect.any(Function),
+			}),
+		);
+		expect(startInput?.localRuntime).not.toHaveProperty(
+			"userInstructionService",
+		);
+	});
+
+	it("registers CLI capability factory through the CLI core facade", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "ok",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+		const { createCliCore } = await import("../session/session");
+		const {
+			askQuestionInTerminal,
+			requestToolApproval,
+			submitAndExitInTerminal,
+		} = await import("../utils/approval");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "act",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(createCliCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				capabilities: {
+					toolExecutors: {
+						askQuestion: askQuestionInTerminal,
+						submit: submitAndExitInTerminal,
+					},
+					requestToolApproval,
+				},
+			}),
+		);
+	});
+
+	it("provides submit_and_exit for one-shot yolo runs", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "ok",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+		const { createCliCore } = await import("../session/session");
+		const {
+			askQuestionInTerminal,
+			requestToolApproval,
+			submitAndExitInTerminal,
+		} = await import("../utils/approval");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(createCliCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				capabilities: {
+					toolExecutors: {
+						askQuestion: askQuestionInTerminal,
+						submit: submitAndExitInTerminal,
+					},
+					requestToolApproval,
+				},
+			}),
+		);
+	});
+
+	it("clears a stale failing exit code after a successful run", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		process.exitCode = 1;
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "ok",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "act",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("does not fail an aborted run when teardown hooks throw", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "aborted",
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 0,
+				finishReason: "aborted",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.stop.mockRejectedValue(new Error("stop failed"));
+		sessionManagerMocks.dispose.mockRejectedValue(new Error("dispose failed"));
+		hookMocks.runtimeHooks.shutdown.mockRejectedValue(
+			new Error("hook shutdown failed"),
+		);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).not.toBe(1);
+		expect(outputMocks.writeErr).not.toHaveBeenCalledWith(
+			"hook shutdown failed",
+		);
+	});
+
+	it("sets a failing exit code when session startup throws", async () => {
+		sessionManagerMocks.start.mockRejectedValue(new Error("Missing API key"));
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger,
+				mode: "yolo",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(logger.error).toHaveBeenCalledWith("CLI task run failed", {
+			error: expect.any(Error),
+		});
+		expect(outputMocks.writeErr).toHaveBeenCalledWith("Missing API key");
+	});
+
+	it("renders ClinePass subscription errors with friendly copy when startup throws", async () => {
+		const error = new Error(SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE);
+		error.name = "ClineNotSubscribedError";
+		sessionManagerMocks.start.mockRejectedValue(error);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: { maxConsecutiveMistakes: 3 },
+				logger: undefined,
+				mode: "yolo",
+				modelId: "premium-model",
+				outputMode: "text",
+				providerId: "cline-pass",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).toHaveBeenCalledWith(
+			CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+		);
+	});
+
+	it("emits JSON error lines for non-completed results", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: 'Missing API key for provider "cline".',
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "error",
+				model: {
+					id: "anthropic/claude-sonnet-4.6",
+					provider: "cline",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "anthropic/claude-sonnet-4.6",
+				outputMode: "json",
+				providerId: "cline",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).toHaveBeenCalledWith(
+			'Missing API key for provider "cline".',
+		);
+	});
+
+	it("renders ClinePass subscription errors with friendly copy for failed results", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: { session_id: "session-1" },
+			result: {
+				text: SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "error",
+				model: { id: "premium-model", provider: "cline-pass", info: {} },
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: { maxConsecutiveMistakes: 3 },
+				logger: undefined,
+				mode: "yolo",
+				modelId: "premium-model",
+				outputMode: "text",
+				providerId: "cline-pass",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).toHaveBeenCalledWith(
+			CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+		);
+	});
+
+	it("does not duplicate ClinePass subscription errors already displayed by agent events", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockImplementation(async () => {
+			sessionEventsMocks.listener?.({
+				type: "error",
+				error: new Error(SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE),
+				recoverable: false,
+			});
+
+			return {
+				sessionId: "session-1",
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest: { session_id: "session-1" },
+				result: {
+					text: SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+					messages: [],
+					toolCalls: [],
+					iterations: 1,
+					finishReason: "error",
+					model: { id: "premium-model", provider: "cline-pass", info: {} },
+					startedAt,
+					endedAt,
+					durationMs: 1000,
+				},
+			};
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: { maxConsecutiveMistakes: 3 },
+				logger: undefined,
+				mode: "yolo",
+				modelId: "premium-model",
+				outputMode: "text",
+				providerId: "cline-pass",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).not.toHaveBeenCalled();
+	});
+
+	it("formats ClinePass limit errors with usage-based billing guidance", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: { session_id: "session-1" },
+			result: {
+				text: `Error: ${CLINE_PASS_LIMIT_DETAIL_MESSAGE}`,
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "error",
+				model: { id: "premium-model", provider: "cline-pass", info: {} },
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: { maxConsecutiveMistakes: 3 },
+				logger: undefined,
+				mode: "yolo",
+				modelId: "premium-model",
+				outputMode: "text",
+				providerId: "cline-pass",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).toHaveBeenCalledWith(
+			CLI_CLINE_PASS_LIMIT_MESSAGE,
+		);
+	});
+
+	it("does not duplicate ClinePass limit errors already displayed by agent events", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockImplementation(async () => {
+			sessionEventsMocks.listener?.({
+				type: "error",
+				error: new Error(`Error: ${CLINE_PASS_LIMIT_DETAIL_MESSAGE}`),
+				recoverable: false,
+			});
+
+			return {
+				sessionId: "session-1",
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest: { session_id: "session-1" },
+				result: {
+					text: `Error: ${CLINE_PASS_LIMIT_DETAIL_MESSAGE}`,
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+					messages: [],
+					toolCalls: [],
+					iterations: 1,
+					finishReason: "error",
+					model: { id: "premium-model", provider: "cline-pass", info: {} },
+					startedAt,
+					endedAt,
+					durationMs: 1000,
+				},
+			};
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: { maxConsecutiveMistakes: 3 },
+				logger: undefined,
+				mode: "yolo",
+				modelId: "premium-model",
+				outputMode: "text",
+				providerId: "cline-pass",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).not.toHaveBeenCalled();
+	});
+
+	it("surfaces post-run bookkeeping failures after a completed result", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "completed text",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockRejectedValue(
+			new Error("usage lookup failed"),
+		);
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: {
+					log: vi.fn(),
+				},
+				mode: "yolo",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+		expect(outputMocks.writeErr).toHaveBeenCalledWith("usage lookup failed");
+	});
+
+	it("sets a failing exit code when the run result finishes with an error", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "error",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("does not append thinking stats to non-verbose text output", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "completed text",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: undefined,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gemini",
+					provider: "openrouter",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "google/gemini-3-flash-preview",
+				outputMode: "text",
+				providerId: "openrouter",
+				systemPrompt: "system",
+				thinking: true,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(process.exitCode).toBe(0);
+		expect(outputMocks.writeln).not.toHaveBeenCalledWith(
+			expect.stringContaining("[thinking]"),
+		);
+	});
+
+	it("omits verbose estimated cost for subscription-backed providers", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "completed text",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0.25,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "gpt-5.4",
+					provider: "openai-codex",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue({
+			inputTokens: 1,
+			outputTokens: 1,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0.25,
+		});
+
+		const { runAgent } = await import("./run-agent");
+
+		await expect(
+			runAgent("test prompt", {
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "gpt-5.4",
+				outputMode: "text",
+				providerId: "openai-codex",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: true,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		expect(outputMocks.writeln).not.toHaveBeenCalledWith(
+			expect.stringContaining("est. cost"),
+		);
+	});
+
+	it("zeros Cline free model costs in JSON results and agent events", async () => {
+		const startedAt = new Date("2026-03-22T00:00:00.000Z");
+		const endedAt = new Date("2026-03-22T00:00:01.000Z");
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(async () => {
+				return new Response(
+					JSON.stringify({
+						free: [{ id: "deepseek/deepseek-v4-flash" }],
+					}),
+					{ status: 200, headers: { "content-type": "application/json" } },
+				);
+			}),
+		);
+		sessionManagerMocks.start.mockResolvedValue({
+			sessionId: "session-1",
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest: {
+				session_id: "session-1",
+			},
+			result: {
+				text: "completed text",
+				usage: {
+					inputTokens: 1,
+					outputTokens: 1,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0.25,
+				},
+				messages: [],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "deepseek/deepseek-v4-flash",
+					provider: "cline",
+					info: {},
+				},
+				startedAt,
+				endedAt,
+				durationMs: 1000,
+			},
+		});
+		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue({
+			usage: {
+				inputTokens: 1,
+				outputTokens: 1,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				totalCost: 0.25,
+			},
+			aggregateUsage: {
+				inputTokens: 1,
+				outputTokens: 1,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				totalCost: 0.25,
+			},
+		});
+
+		const { runAgent } = await import("./run-agent");
+		const { handleEvent } = await import("../utils/events");
+
+		await expect(
+			runAgent("test prompt", {
+				baseUrl: "https://cline.test/api/v1",
+				cwd: process.cwd(),
+				enableAgentTeams: false,
+				enableSpawnAgent: false,
+				enableTools: [],
+				execution: {
+					maxConsecutiveMistakes: 3,
+				},
+				logger: undefined,
+				mode: "yolo",
+				modelId: "deepseek/deepseek-v4-flash",
+				outputMode: "json",
+				providerId: "cline",
+				systemPrompt: "system",
+				thinking: false,
+				toolPolicies: { "*": { autoApprove: true } },
+				verbose: false,
+				workspaceRoot: process.cwd(),
+			} as never),
+		).resolves.toBeUndefined();
+
+		const runResult = outputMocks.emitJsonLine.mock.calls.find(
+			([, payload]) =>
+				(payload as { type?: string } | undefined)?.type === "run_result",
+		)?.[1] as
+			| {
+					usage?: { totalCost?: number };
+					aggregateUsage?: { totalCost?: number };
+			  }
+			| undefined;
+		expect(runResult?.usage?.totalCost).toBe(0);
+		expect(runResult?.aggregateUsage?.totalCost).toBe(0);
+
+		sessionEventsMocks.listener?.({
+			type: "usage",
+			inputTokens: 1,
+			outputTokens: 1,
+			cost: 0.25,
+			totalCost: 0.25,
+		});
+
+		expect(handleEvent).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				type: "usage",
+				cost: 0,
+				totalCost: 0,
+			}),
+			expect.any(Object),
+		);
+	});
+});
diff --git a/apps/cli/src/runtime/run-agent.ts b/apps/cli/src/runtime/run-agent.ts
new file mode 100644
index 0000000..ef039d4
--- /dev/null
+++ b/apps/cli/src/runtime/run-agent.ts
@@ -0,0 +1,421 @@
+import {
+	type AgentEvent,
+	type AgentResult,
+	type ProviderSettings,
+	prewarmFileIndex,
+	SessionSource,
+	type UserInstructionConfigService,
+} from "@cline/core";
+import type { ConsecutiveMistakeLimitContext } from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import { logCliError } from "../logging/errors";
+import { createCliCore } from "../session/session";
+import { resolveClineWelcomeLine } from "../tui/interactive-welcome";
+import {
+	askQuestionInTerminal,
+	requestToolApproval,
+	submitAndExitInTerminal,
+} from "../utils/approval";
+import { formatCliErrorMessage } from "../utils/cline-pass-errors";
+import { handleEvent, handleTeamEvent } from "../utils/events";
+import {
+	shouldZeroClineFreeModelCost,
+	zeroCliAgentEventCost,
+	zeroCliUsageCost,
+} from "../utils/free-model-cost";
+import { createRuntimeHooks } from "../utils/hooks";
+import {
+	c,
+	emitJsonLine,
+	formatUsd,
+	getActiveCliSession,
+	setActiveCliSession,
+	writeErr,
+	writeln,
+} from "../utils/output";
+import type { Config } from "../utils/types";
+import { shouldShowCliUsageCost } from "../utils/usage-cost-display";
+import { setActiveRuntimeAbort } from "./active-runtime";
+import {
+	CLI_DEFAULT_CHECKPOINT_CONFIG,
+	CLI_DEFAULT_LOOP_DETECTION,
+} from "./defaults";
+import { describeAbortSource, resolveMistakeLimitDecision } from "./format";
+import { buildUserInputMessage } from "./prompt";
+import { subscribeToAgentEvents } from "./session-events";
+
+function printModelProviderInfo(config: Config): void {
+	const catalog = config.knownModels ? "live" : "bundled";
+	const thinking = config.thinking ? "on" : "off";
+	const { mode, providerId, modelId } = config;
+	if (config.outputMode === "json") {
+		emitJsonLine("stdout", {
+			type: "run_start",
+			providerId,
+			modelId,
+			catalog,
+			thinking,
+			mode,
+			sessionId: getActiveCliSession()?.manifest.session_id,
+		});
+		return;
+	}
+	writeln(
+		`${c.dim}[model] provider=${providerId} model=${modelId} catalog=${catalog} thinking=${thinking} mode=${mode}${c.reset}\n`,
+	);
+}
+
+function emitAbortRequested(
+	config: Config,
+	reason: "sigint" | "sigterm",
+): void {
+	if (config.outputMode === "json") {
+		emitJsonLine("stdout", { type: "run_abort_requested", reason });
+	} else if (reason === "sigint") {
+		writeln(`\n${c.dim}[abort] requested${c.reset}`);
+	}
+}
+
+function emitTeamRestored(config: Config): void {
+	const teamName = config.teamName ?? "(unknown team)";
+	if (config.outputMode === "json") {
+		emitJsonLine("stdout", { type: "team_restored", teamName });
+		return;
+	}
+	writeln(
+		`${c.dim}[team] restored persisted team state for "${teamName}"${c.reset}`,
+	);
+}
+
+function printRunStats(
+	config: Config,
+	result: AgentResult,
+	usage: AgentResult["usage"],
+	startTime: number,
+	reasoningChunkCount: number,
+	redactedReasoningChunkCount: number,
+): void {
+	if (config.outputMode !== "text") {
+		return;
+	}
+	if (config.verbose) {
+		writeln();
+		const parts: string[] = [];
+		parts.push(`${((performance.now() - startTime) / 1000).toFixed(2)}s`);
+		const tokenParts: string[] = [
+			`${usage.inputTokens} in`,
+			`${usage.outputTokens} out`,
+		];
+		if (usage.cacheReadTokens) {
+			tokenParts.push(`${usage.cacheReadTokens} cache read`);
+		}
+		if (usage.cacheWriteTokens) {
+			tokenParts.push(`${usage.cacheWriteTokens} cache write`);
+		}
+		parts.push(tokenParts.join(", "));
+		if (
+			shouldShowCliUsageCost(config.providerId) &&
+			typeof usage.totalCost === "number"
+		) {
+			parts.push(`${formatUsd(usage.totalCost)} est. cost`);
+		}
+		if (result.iterations > 1) {
+			parts.push(`${result.iterations} iterations`);
+		}
+		writeln(`${c.dim}[${parts.join(" | ")}]${c.reset}`);
+		if (config.thinking) {
+			writeln(
+				`${c.dim}[thinking] chunks=${reasoningChunkCount} redacted=${redactedReasoningChunkCount}${c.reset}`,
+			);
+		}
+	}
+}
+
+export async function runAgent(
+	prompt: string,
+	config: Config,
+	userInstructionService?: UserInstructionConfigService,
+	options?: {
+		clineApiBaseUrl?: string;
+		clineProviderSettings?: ProviderSettings;
+	},
+): Promise<void> {
+	// A clean one-shot run should not inherit a stale nonzero process exit code
+	// from lower layers or prior bookkeeping inside the same process.
+	process.exitCode = 0;
+
+	if (config.verbose) {
+		const clineWelcomeLine = await resolveClineWelcomeLine({
+			config,
+			clineApiBaseUrl: options?.clineApiBaseUrl,
+			clineProviderSettings: options?.clineProviderSettings,
+		});
+		if (clineWelcomeLine && config.outputMode !== "json") {
+			writeln(clineWelcomeLine);
+		}
+	}
+
+	const startTime = performance.now();
+	void prewarmFileIndex(config.cwd).catch((error: unknown) => {
+		logCliError(config.logger, "File index prewarm failed", { error });
+	});
+
+	const isYoloMode = config.mode === "yolo";
+	const toolExecutors = {
+		askQuestion: askQuestionInTerminal,
+		submit: submitAndExitInTerminal,
+	};
+	const sessionManager = await createCliCore({
+		capabilities: {
+			toolExecutors,
+			requestToolApproval,
+		},
+		forceLocalBackend: isYoloMode || config.sandbox === true,
+		logger: config.logger,
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot,
+		toolPolicies: config.toolPolicies,
+	});
+	const runtimeHooks = createRuntimeHooks({
+		verbose: config.verbose,
+		yolo: isYoloMode,
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot,
+		dispatchHookEvent: async (payload) => {
+			await sessionManager.ingestHookEvent(payload);
+		},
+	});
+
+	let reasoningChunkCount = 0;
+	let redactedReasoningChunkCount = 0;
+	const displayedErrorMessages = new Set<string>();
+	const shouldZeroCost = await shouldZeroClineFreeModelCost(config);
+
+	const onAgentEvent = (rawEvent: AgentEvent): void => {
+		const event = zeroCliAgentEventCost(rawEvent, shouldZeroCost);
+		if (event.type === "content_start" && event.contentType === "reasoning") {
+			reasoningChunkCount += 1;
+			if (event.redacted) {
+				redactedReasoningChunkCount += 1;
+			}
+		}
+		if (
+			event.type === "error" &&
+			(!event.recoverable || config.verbose) &&
+			event.error.message.trim()
+		) {
+			displayedErrorMessages.add(
+				formatCliErrorMessage(event.error.message).trim(),
+			);
+		}
+		handleEvent(event, config);
+	};
+	const plannedSessionId = createSessionId();
+	const unsubscribe = subscribeToAgentEvents(sessionManager, onAgentEvent, {
+		sessionId: plannedSessionId,
+	});
+
+	// --- Abort & signal handling ---
+	let abortRequested = false;
+	let timedOut = false;
+	let activeSessionId: string | undefined;
+
+	const abortAll = () => {
+		if (abortRequested) return false;
+		abortRequested = true;
+		if (activeSessionId) {
+			sessionManager
+				.abort(activeSessionId, new Error("Run-agent runtime abort requested"))
+				.catch(() => {});
+		}
+		return true;
+	};
+	setActiveRuntimeAbort(abortAll);
+
+	let cleanupDone: Promise<void> | undefined;
+	const cleanupRuntime = () => {
+		cleanupDone ??= (async () => {
+			process.off("SIGINT", handleSigint);
+			process.off("SIGTERM", handleSigterm);
+			unsubscribe();
+			await runtimeHooks.shutdown().catch(() => {});
+			if (activeSessionId) {
+				await sessionManager.stop(activeSessionId).catch(() => {});
+			}
+			await sessionManager.dispose("cli_run_shutdown").catch(() => {});
+			setActiveRuntimeAbort(undefined);
+		})();
+		return cleanupDone;
+	};
+
+	const handleSigint = () => {
+		if (abortAll()) {
+			emitAbortRequested(config, "sigint");
+			return;
+		}
+		void cleanupRuntime().finally(() => {
+			process.exitCode = 0;
+			process.exit(0);
+		});
+	};
+	const handleSigterm = () => {
+		if (abortAll()) {
+			emitAbortRequested(config, "sigterm");
+		}
+	};
+	process.on("SIGINT", handleSigint);
+	process.on("SIGTERM", handleSigterm);
+
+	// --- Main execution ---
+	try {
+		if (config.verbose) {
+			printModelProviderInfo(config);
+		}
+		const {
+			prompt: userInput,
+			userImages,
+			userFiles,
+		} = await buildUserInputMessage(prompt, userInstructionService);
+		const started = await sessionManager.start({
+			source: SessionSource.CLI,
+			config: {
+				...config,
+				sessionId: plannedSessionId,
+				execution: {
+					...config.execution,
+					loopDetection:
+						config.execution?.loopDetection ?? CLI_DEFAULT_LOOP_DETECTION,
+				},
+				checkpoint: config.checkpoint ?? CLI_DEFAULT_CHECKPOINT_CONFIG,
+				hooks: runtimeHooks.hooks,
+				onTeamEvent: handleTeamEvent,
+				onConsecutiveMistakeLimitReached: async (
+					context: ConsecutiveMistakeLimitContext,
+				) => resolveMistakeLimitDecision(config, context),
+			},
+			prompt: userInput,
+			userImages: userImages.length > 0 ? userImages : undefined,
+			userFiles: userFiles.length > 0 ? userFiles : undefined,
+			interactive: false,
+			localRuntime: {
+				onTeamRestored: () => emitTeamRestored(config),
+			},
+		});
+
+		activeSessionId = started.sessionId;
+		setActiveCliSession({
+			manifest: started.manifest,
+		});
+
+		// Schedule timeout abort if configured.
+		const timeoutMs =
+			typeof config.timeoutSeconds === "number" &&
+			Number.isFinite(config.timeoutSeconds) &&
+			config.timeoutSeconds > 0
+				? config.timeoutSeconds * 1000
+				: undefined;
+		const timeoutId = timeoutMs
+			? setTimeout(() => {
+					timedOut = true;
+					abortAll();
+				}, timeoutMs)
+			: undefined;
+		const clearRunTimeout = () => {
+			if (timeoutId) clearTimeout(timeoutId);
+		};
+
+		// When start() already ran the first turn (non-interactive with prompt),
+		// the session is finalized before start() returns. Use that result
+		// directly; calling send() would fail with "session not found".
+		let result: AgentResult | undefined;
+		if (started.result) {
+			clearRunTimeout();
+			result = started.result;
+		} else {
+			result = await sessionManager
+				.send({
+					sessionId: started.sessionId,
+					prompt: userInput,
+					userImages: userImages.length > 0 ? userImages : undefined,
+					userFiles: userFiles.length > 0 ? userFiles : undefined,
+				})
+				.finally(clearRunTimeout);
+		}
+		if (!result) {
+			throw new Error("session manager did not return a result");
+		}
+
+		const usageSummary = await sessionManager.getAccumulatedUsage(
+			started.sessionId,
+		);
+		const aggregateUsage = zeroCliUsageCost(
+			usageSummary?.aggregateUsage,
+			shouldZeroCost,
+		);
+		const usage = zeroCliUsageCost(
+			aggregateUsage ?? usageSummary?.usage ?? result.usage,
+			shouldZeroCost,
+		);
+
+		if (config.outputMode === "json") {
+			emitJsonLine("stdout", {
+				type: "run_result",
+				finishReason: result.finishReason,
+				iterations: result.iterations,
+				usage,
+				...(aggregateUsage ? { aggregateUsage } : {}),
+				durationMs: result.durationMs,
+				text: result.text,
+				model: result.model,
+			});
+		}
+
+		if (abortRequested || result.finishReason === "aborted") {
+			if (timedOut) {
+				writeErr(`run timed out after ${config.timeoutSeconds}s`);
+				process.exitCode = 1;
+			} else if (config.outputMode === "json") {
+				emitJsonLine("stdout", {
+					type: "run_aborted",
+					reason: abortRequested ? "local_abort" : "external_abort",
+					message: describeAbortSource({ abortRequested, timedOut }),
+				});
+			} else {
+				writeln(
+					`${c.dim}[abort] ${describeAbortSource({ abortRequested, timedOut })}${c.reset}`,
+				);
+			}
+			writeln();
+			return;
+		}
+
+		if (result.finishReason !== "completed") {
+			const errorText = formatCliErrorMessage(result.text).trim();
+			if (
+				errorText &&
+				(config.outputMode === "json" || !displayedErrorMessages.has(errorText))
+			) {
+				writeErr(errorText);
+			}
+			process.exitCode = 1;
+			return;
+		}
+
+		printRunStats(
+			config,
+			result,
+			usage,
+			startTime,
+			reasoningChunkCount,
+			redactedReasoningChunkCount,
+		);
+		process.exitCode = 0;
+	} catch (err) {
+		const message = formatCliErrorMessage(err);
+		logCliError(config.logger, "CLI task run failed", { error: err });
+		writeErr(message);
+		process.exitCode = 1;
+	} finally {
+		await cleanupRuntime();
+	}
+}
diff --git a/apps/cli/src/runtime/run-interactive.test.ts b/apps/cli/src/runtime/run-interactive.test.ts
new file mode 100644
index 0000000..8fcee1e
--- /dev/null
+++ b/apps/cli/src/runtime/run-interactive.test.ts
@@ -0,0 +1,110 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Config } from "../utils/types";
+import {
+	applyInteractiveModelChange,
+	resolveReasoningForModelChange,
+} from "./run-interactive";
+
+describe("resolveReasoningForModelChange", () => {
+	it("persists disabled reasoning only when thinking is explicitly false", () => {
+		expect(
+			resolveReasoningForModelChange(
+				{ thinking: false, reasoningEffort: undefined },
+				{ reasoning: { enabled: true, effort: "high" } },
+			),
+		).toEqual({ enabled: false });
+	});
+
+	it("persists enabled reasoning with the selected effort", () => {
+		expect(
+			resolveReasoningForModelChange(
+				{ thinking: true, reasoningEffort: "low" },
+				{ reasoning: { enabled: false } },
+			),
+		).toEqual({ enabled: true, effort: "low" });
+	});
+
+	it("persists enabled reasoning when thinking is explicitly true without effort", () => {
+		expect(
+			resolveReasoningForModelChange(
+				{ thinking: true, reasoningEffort: undefined },
+				{ reasoning: { enabled: false } },
+			),
+		).toEqual({ enabled: true });
+	});
+
+	it("preserves existing reasoning when thinking is unset", () => {
+		expect(
+			resolveReasoningForModelChange(
+				{ thinking: undefined, reasoningEffort: undefined },
+				{ reasoning: { enabled: true, effort: "medium" } },
+			),
+		).toEqual({ enabled: true, effort: "medium" });
+	});
+});
+
+describe("applyInteractiveModelChange", () => {
+	it("restarts with the current transcript so a provider switch reloads its complete configuration", async () => {
+		const config = {
+			providerId: "openai-compatible",
+			modelId: "custom-model",
+			apiKey: "new-key",
+			thinking: undefined,
+			reasoningEffort: undefined,
+		} as Config;
+		const getProviderSettings = vi.fn(() => ({
+			provider: "openai-compatible",
+			apiKey: "new-key",
+			baseUrl: "https://example.com/v1",
+			headers: { "X-Custom-Header": "custom-value" },
+			client: "openai-compatible" as const,
+			protocol: "openai-chat" as const,
+			model: "old-model",
+		}));
+		const saveProviderSettings = vi.fn(() => ({
+			version: 1 as const,
+			providers: {},
+		}));
+		const ensureReady = vi.fn(async () => {});
+		const restartWithCurrentMessages = vi.fn(async () => {});
+		const updateCurrentSessionConnection = vi.fn(async () => {});
+
+		await applyInteractiveModelChange({
+			config,
+			providerSettingsManager: {
+				getProviderSettings,
+				saveProviderSettings,
+			},
+			sessionRuntime: {
+				ensureReady,
+				restartWithCurrentMessages,
+				updateCurrentSessionConnection,
+			},
+		});
+
+		expect(saveProviderSettings).toHaveBeenCalledWith({
+			provider: "openai-compatible",
+			apiKey: "new-key",
+			baseUrl: "https://example.com/v1",
+			headers: { "X-Custom-Header": "custom-value" },
+			client: "openai-compatible",
+			protocol: "openai-chat",
+			model: "custom-model",
+		});
+		expect(ensureReady).toHaveBeenCalledOnce();
+		expect(restartWithCurrentMessages).toHaveBeenCalledOnce();
+		expect(updateCurrentSessionConnection).toHaveBeenCalledWith({
+			providerId: "openai-compatible",
+			modelId: "custom-model",
+		});
+		expect(ensureReady.mock.invocationCallOrder[0]).toBeLessThan(
+			restartWithCurrentMessages.mock.invocationCallOrder[0] ?? 0,
+		);
+		expect(saveProviderSettings.mock.invocationCallOrder[0]).toBeLessThan(
+			restartWithCurrentMessages.mock.invocationCallOrder[0] ?? 0,
+		);
+		expect(restartWithCurrentMessages.mock.invocationCallOrder[0]).toBeLessThan(
+			updateCurrentSessionConnection.mock.invocationCallOrder[0] ?? 0,
+		);
+	});
+});
diff --git a/apps/cli/src/runtime/run-interactive.ts b/apps/cli/src/runtime/run-interactive.ts
new file mode 100644
index 0000000..e2b8221
--- /dev/null
+++ b/apps/cli/src/runtime/run-interactive.ts
@@ -0,0 +1,823 @@
+import {
+	getCurrentContextSize,
+	type ProviderSettings,
+	ProviderSettingsManager,
+	type UserInstructionConfigService,
+} from "@cline/core";
+import { formatModeSwitchNotice } from "@cline/shared";
+import type { CliMigrationNotice } from "../kanban-migration/notice";
+import { logCliError } from "../logging/errors";
+import {
+	loadClineAccountSnapshot,
+	loadIndividualSubscriptionPlans,
+	onProviderChange,
+	switchClineAccount,
+} from "../tui/cline-account";
+import type {
+	InteractiveConfigItem,
+	LoadInteractiveConfigDataOptions,
+} from "../tui/interactive-config";
+import {
+	type InteractiveSlashCommand,
+	listInteractiveSlashCommands,
+	resolveClineWelcomeLine,
+} from "../tui/interactive-welcome";
+import { disableOpenTuiGraphicsProbe } from "../tui/opentui-env";
+import type { QueuedPromptItem } from "../tui/types";
+import { type ChatCommandState, chatCommandHost } from "../utils/chat-commands";
+import { applyCliCompactionMode } from "../utils/compaction-mode";
+import {
+	shouldZeroClineFreeModelCost,
+	zeroCliAgentEventCost,
+	zeroCliUsageCost,
+} from "../utils/free-model-cost";
+import {
+	prepareTerminalForPostTuiOutput,
+	writeErr,
+	writeln,
+} from "../utils/output";
+import { createWorkspaceChatCommandHost } from "../utils/plugin-chat-commands";
+import { readRepoStatus } from "../utils/repo-status";
+import type { Config } from "../utils/types";
+import {
+	clearAbortInProgress,
+	isAbortInProgress,
+	setActiveRuntimeAbort,
+	setActiveRuntimeCleanup,
+} from "./active-runtime";
+import { createInteractiveApprovalController } from "./interactive/approvals";
+import { runInteractiveChatCommand } from "./interactive/chat-command-runner";
+import { createInteractiveConfigDataLoader } from "./interactive/config-data";
+import {
+	formatInteractiveExitSummary,
+	type InteractiveExitSummary,
+} from "./interactive/exit-summary";
+import { createMistakeLimitDecisionResolver } from "./interactive/mistakes";
+import {
+	type AppliedModeChange,
+	createInteractiveModeSwitchTool,
+	createModeSwitchNoticeTracker,
+	type PendingModeChange,
+	sendTurnWithActModeContinuation,
+} from "./interactive/mode";
+import { assertInteractivePreflight } from "./interactive/preflight";
+import { createInteractiveSessionRuntime } from "./interactive/session-runtime";
+import { buildUserInputMessage } from "./prompt";
+import { getUIEventEmitter } from "./session-events";
+
+type ModelChangeReasoningConfig = {
+	thinking?: boolean;
+	reasoningEffort?: Config["reasoningEffort"];
+};
+
+export function resolveReasoningForModelChange(
+	config: ModelChangeReasoningConfig,
+	existing: Pick<ProviderSettings, "reasoning">,
+): ProviderSettings["reasoning"] {
+	if (config.thinking === false) return { enabled: false };
+	if (config.reasoningEffort) {
+		return { enabled: true, effort: config.reasoningEffort };
+	}
+	if (config.thinking === true) return { enabled: true };
+	return existing.reasoning;
+}
+
+export async function applyInteractiveModelChange(input: {
+	config: Config;
+	providerSettingsManager: Pick<
+		ProviderSettingsManager,
+		"getProviderSettings" | "saveProviderSettings"
+	>;
+	sessionRuntime: Pick<
+		ReturnType<typeof createInteractiveSessionRuntime>,
+		| "ensureReady"
+		| "restartWithCurrentMessages"
+		| "updateCurrentSessionConnection"
+	>;
+}): Promise<void> {
+	const { config, providerSettingsManager, sessionRuntime } = input;
+	await sessionRuntime.ensureReady();
+	await onProviderChange({
+		config,
+		providerId: config.providerId,
+	});
+	const existing = providerSettingsManager.getProviderSettings(
+		config.providerId,
+	) ?? {
+		provider: config.providerId,
+	};
+	const reasoning = resolveReasoningForModelChange(config, existing);
+	providerSettingsManager.saveProviderSettings({
+		...existing,
+		model: config.modelId,
+		...(reasoning === undefined ? {} : { reasoning }),
+	});
+
+	// Provider changes affect more than the model connection: startup resolves
+	// the endpoint, headers, provider-specific options, tools, and plugins. Rebuild
+	// the runtime with the existing transcript so all of that state changes
+	// together. restartWithCurrentMessages preserves the session ID.
+	await sessionRuntime.restartWithCurrentMessages();
+	// A same-ID restart reuses the existing manifest. Sync its connection label
+	// after the fully configured runtime is live so session history reflects the
+	// provider/model that will handle subsequent turns.
+	await sessionRuntime.updateCurrentSessionConnection({
+		providerId: config.providerId,
+		modelId: config.modelId,
+	});
+}
+
+export async function runInteractive(
+	config: Config,
+	userInstructionService?: UserInstructionConfigService,
+	resumeSessionId?: string,
+	options?: {
+		clineApiBaseUrl?: string;
+		clineProviderSettings?: ProviderSettings;
+		initialView?: "chat" | "config";
+		initialPrompt?: string;
+		initialNotice?: CliMigrationNotice;
+		onInitialNoticeShown?: (notice: CliMigrationNotice) => void | Promise<void>;
+	},
+): Promise<void> {
+	assertInteractivePreflight(config);
+
+	const initialRepoStatus = await readRepoStatus(config.cwd);
+	const workflowSlashCommands = listInteractiveSlashCommands(
+		userInstructionService,
+	);
+	let interactiveChatCommandHost = chatCommandHost;
+	let pluginChatCommandHostLoaded = false;
+	let pluginChatSlashCommands: InteractiveSlashCommand[] = [];
+	let pluginChatCommandHostShutdown: (() => Promise<void>) | undefined;
+	let pluginChatCommandHostPromise:
+		| Promise<InteractiveSlashCommand[]>
+		| undefined;
+	const configDataLoader = createInteractiveConfigDataLoader({
+		config,
+		userInstructionService,
+	});
+	const ensurePluginChatCommandHost = async (): Promise<
+		InteractiveSlashCommand[]
+	> => {
+		if (pluginChatCommandHostLoaded) {
+			return pluginChatSlashCommands;
+		}
+		pluginChatCommandHostPromise ??= createWorkspaceChatCommandHost({
+			cwd: config.cwd,
+			workspaceRoot: config.workspaceRoot,
+			logger: config.logger,
+		})
+			.then(({ host, pluginSlashCommands, shutdown }) => {
+				interactiveChatCommandHost = host;
+				pluginChatCommandHostShutdown = shutdown;
+				pluginChatSlashCommands = pluginSlashCommands.map((cmd) => ({
+					name: cmd.name,
+					instructions: "",
+					description: cmd.description ?? "Plugin command",
+				}));
+				return pluginChatSlashCommands;
+			})
+			.finally(() => {
+				pluginChatCommandHostLoaded = true;
+				pluginChatCommandHostPromise = undefined;
+			});
+		return await pluginChatCommandHostPromise;
+	};
+	const loadAdditionalSlashCommands = async (): Promise<
+		InteractiveSlashCommand[]
+	> => await ensurePluginChatCommandHost();
+	const shouldTryPluginChatCommands = (prompt: string): boolean => {
+		return prompt.trimStart().startsWith("/");
+	};
+
+	const enableChatCommands = true;
+	const {
+		autoApproveAllRef,
+		setInteractiveAutoApprove,
+		requestToolApproval,
+		resolveToolPolicy,
+		tuiToolApprover,
+		tuiAskQuestion,
+	} = createInteractiveApprovalController(config);
+
+	const pendingModeChange: PendingModeChange = {
+		current: null,
+		source: null,
+	};
+	const tuiModeChanged: {
+		current: ((mode: "plan" | "act") => void) | null;
+	} = { current: null };
+
+	const switchToActModeTool = createInteractiveModeSwitchTool({
+		config,
+		pendingModeChange,
+		tuiModeChanged,
+	});
+
+	config.extraTools = config.mode === "plan" ? [switchToActModeTool] : [];
+
+	const uiEvents = getUIEventEmitter();
+	const chatCommandState: ChatCommandState = {
+		enableTools: config.enableTools,
+		autoApproveTools: autoApproveAllRef.current,
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot?.trim() || config.cwd,
+	};
+	const resolveMistakeLimitDecision = createMistakeLimitDecisionResolver({
+		autoApproveAllRef,
+		askQuestionRef: tuiAskQuestion,
+	});
+	const providerSettingsManager = new ProviderSettingsManager();
+	let zeroCurrentTurnCost = false;
+
+	const sessionRuntime = createInteractiveSessionRuntime({
+		config,
+		providerSettingsManager,
+		userInstructionService,
+		resumeSessionId,
+		chatCommandState,
+		requestToolApproval,
+		resolveToolPolicy,
+		askQuestionRef: tuiAskQuestion,
+		resolveMistakeLimitDecision,
+		switchToActModeTool,
+		onAgentEvent: (event) => {
+			uiEvents.emit("agent", zeroCliAgentEventCost(event, zeroCurrentTurnCost));
+		},
+		onTeamEvent: (event) => {
+			uiEvents.emit("team", event);
+		},
+		onPendingPrompts: (event) => {
+			uiEvents.emit("pending-prompts", event);
+		},
+		onPendingPromptSubmitted: (event) => {
+			uiEvents.emit("pending-prompt-submitted", event);
+		},
+	});
+	let modeChangePromise: Promise<void> | undefined;
+	let modeChangeTarget: "plan" | "act" | undefined;
+	const modeSwitchNotice = createModeSwitchNoticeTracker();
+
+	const isInteractiveMode = (mode: unknown): mode is "plan" | "act" =>
+		mode === "plan" || mode === "act";
+
+	const applyModeChange = (mode: "plan" | "act"): Promise<void> => {
+		if (modeChangePromise && modeChangeTarget === mode) {
+			return modeChangePromise;
+		}
+		let next: Promise<void>;
+		next = (async () => {
+			if (modeChangePromise) {
+				await modeChangePromise;
+			}
+			await sessionRuntime.ensureReady();
+			const from = config.mode;
+			await sessionRuntime.applyMode(mode);
+			if (isInteractiveMode(from)) {
+				modeSwitchNotice.record(from, mode);
+			}
+		})().finally(() => {
+			if (modeChangePromise === next) {
+				modeChangePromise = undefined;
+				modeChangeTarget = undefined;
+			}
+		});
+		modeChangePromise = next;
+		modeChangeTarget = mode;
+		return next;
+	};
+
+	const waitForSubmittedMode = async (mode: unknown): Promise<void> => {
+		if (!isInteractiveMode(mode)) return;
+		if (modeChangePromise) {
+			await modeChangePromise;
+		}
+		if (config.mode !== mode) {
+			await applyModeChange(mode);
+		}
+	};
+
+	let isRunning = false;
+	setActiveRuntimeAbort(sessionRuntime.abortAll);
+
+	let cleanupPromise: Promise<InteractiveExitSummary | undefined> | undefined;
+
+	const handleSigint = () => {
+		if (isRunning) {
+			if (sessionRuntime.abortAll()) {
+				return;
+			}
+			void cleanupRuntime().finally(() => {
+				process.exitCode = 0;
+				tuiApp?.destroy();
+			});
+			return;
+		}
+		tuiApp?.destroy();
+	};
+	const handleSigterm = () => {
+		if (isRunning) {
+			sessionRuntime.abortAll();
+			return;
+		}
+		tuiApp?.destroy();
+	};
+	const cleanupRuntime = async (): Promise<
+		InteractiveExitSummary | undefined
+	> => {
+		if (cleanupPromise) {
+			return await cleanupPromise;
+		}
+		cleanupPromise = (async () => {
+			process.off("SIGINT", handleSigint);
+			process.off("SIGTERM", handleSigterm);
+			let exitSummary: InteractiveExitSummary | undefined;
+			try {
+				exitSummary = await sessionRuntime.cleanup();
+			} finally {
+				await pluginChatCommandHostPromise?.catch(() => []);
+				await pluginChatCommandHostShutdown?.().catch(() => {
+					// Best effort cleanup for plugin command discovery sandbox.
+				});
+				pluginChatCommandHostShutdown = undefined;
+				setActiveRuntimeAbort(undefined);
+				setActiveRuntimeCleanup(undefined);
+			}
+			return exitSummary;
+		})();
+		return await cleanupPromise;
+	};
+	let sessionPolicyRefresh: Promise<void> | undefined;
+	let pendingSessionPolicyRefresh = false;
+	const refreshInteractiveSessionPolicies = async (): Promise<void> => {
+		if (sessionRuntime.isShutdownRequested()) {
+			return;
+		}
+		if (isRunning) {
+			pendingSessionPolicyRefresh = true;
+			return;
+		}
+		if (sessionPolicyRefresh) {
+			return await sessionPolicyRefresh;
+		}
+		pendingSessionPolicyRefresh = false;
+		sessionPolicyRefresh = (async () => {
+			await sessionRuntime.ensureReady();
+			if (isRunning || sessionRuntime.isShutdownRequested()) {
+				pendingSessionPolicyRefresh = isRunning;
+				return;
+			}
+			await sessionRuntime.restartWithCurrentMessages();
+		})()
+			.catch((error) => {
+				logCliError(config.logger, "Interactive policy refresh failed", {
+					error,
+				});
+				writeErr(error instanceof Error ? error.message : String(error));
+			})
+			.finally(() => {
+				sessionPolicyRefresh = undefined;
+			});
+		return await sessionPolicyRefresh;
+	};
+	const refreshInteractiveSessionPoliciesIfPending = (): void => {
+		if (pendingSessionPolicyRefresh) {
+			void refreshInteractiveSessionPolicies();
+		}
+	};
+
+	const shouldRefreshInteractiveSessionForConfigItem = (
+		item: InteractiveConfigItem,
+	): boolean =>
+		item.kind === "tool" ||
+		item.kind === "plugin" ||
+		item.kind === "skill" ||
+		item.kind === "mcp";
+
+	const onToggleConfigItem = async (
+		item: InteractiveConfigItem,
+		options: LoadInteractiveConfigDataOptions = {},
+	): Promise<
+		Awaited<ReturnType<typeof configDataLoader.onToggleConfigItem>>
+	> => {
+		const data = await configDataLoader.onToggleConfigItem(item, options);
+		if (data && shouldRefreshInteractiveSessionForConfigItem(item)) {
+			await refreshInteractiveSessionPolicies();
+		}
+		return data;
+	};
+	const onDeleteConfigItem = async (
+		item: InteractiveConfigItem,
+		options: LoadInteractiveConfigDataOptions = {},
+	): Promise<
+		Awaited<ReturnType<typeof configDataLoader.onDeleteConfigItem>>
+	> => {
+		const data = await configDataLoader.onDeleteConfigItem(item, options);
+		if (data && shouldRefreshInteractiveSessionForConfigItem(item)) {
+			await refreshInteractiveSessionPolicies();
+		}
+		return data;
+	};
+	const toQueuedPromptItem = (prompt: {
+		id: string;
+		prompt: string;
+		delivery: "queue" | "steer";
+		attachmentCount: number;
+	}): QueuedPromptItem => ({
+		id: prompt.id,
+		prompt: prompt.prompt,
+		steer: prompt.delivery === "steer",
+		attachmentCount: prompt.attachmentCount,
+	});
+
+	process.on("SIGINT", handleSigint);
+	process.on("SIGTERM", handleSigterm);
+
+	disableOpenTuiGraphicsProbe();
+	const { renderOpenTui } = await import("../tui/index");
+
+	// eslint-disable-next-line prefer-const
+	let tuiApp: Awaited<ReturnType<typeof renderOpenTui>> | undefined;
+	setActiveRuntimeCleanup(() => {
+		tuiApp?.destroy();
+	});
+	let startupErrorReported = false;
+	const loadDeferredInitialMessages = resumeSessionId?.trim()
+		? async () => {
+				try {
+					await sessionRuntime.ensureReady();
+					const { messages } = await sessionRuntime.readCurrentMessages();
+					const usage = await sessionRuntime.getAccumulatedUsage({
+						inputTokens: 0,
+						outputTokens: 0,
+					});
+					return {
+						messages,
+						totalCost: usage.totalCost,
+						currentContextSize: getCurrentContextSize(messages),
+					};
+				} catch (error) {
+					startupErrorReported = true;
+					logCliError(config.logger, "Interactive startup failed", { error });
+					throw error;
+				}
+			}
+		: undefined;
+
+	tuiApp = await renderOpenTui({
+		config,
+		initialView: options?.initialView,
+		initialPrompt: options?.initialPrompt,
+		initialNotice: options?.initialNotice,
+		onInitialNoticeShown: options?.onInitialNoticeShown,
+		loadDeferredInitialMessages,
+		initialRepoStatus,
+		workflowSlashCommands,
+		loadAdditionalSlashCommands,
+		loadWelcomeLine: async () =>
+			await resolveClineWelcomeLine({
+				config,
+				clineApiBaseUrl: options?.clineApiBaseUrl,
+				clineProviderSettings: options?.clineProviderSettings,
+			}),
+		loadClineAccount: async () =>
+			await loadClineAccountSnapshot({
+				config,
+				clineApiBaseUrl: options?.clineApiBaseUrl,
+			}),
+		loadIndividualSubscriptionPlans: async () =>
+			await loadIndividualSubscriptionPlans({
+				config,
+				clineApiBaseUrl: options?.clineApiBaseUrl,
+				clineProviderSettings: options?.clineProviderSettings,
+			}),
+		switchClineAccount: async (organizationId) =>
+			await switchClineAccount({
+				config,
+				organizationId,
+				clineApiBaseUrl: options?.clineApiBaseUrl,
+			}),
+		loadConfigData: configDataLoader.loadConfigData,
+		onToggleConfigItem,
+		onDeleteConfigItem,
+		subscribeToEvents: ({
+			onAgentEvent: onAgent,
+			onTeamEvent: onTeam,
+			onPendingPrompts,
+			onPendingPromptSubmitted,
+		}) => {
+			uiEvents.on("agent", onAgent);
+			uiEvents.on("team", onTeam);
+			uiEvents.on("pending-prompts", onPendingPrompts);
+			uiEvents.on("pending-prompt-submitted", onPendingPromptSubmitted);
+			return () => {
+				uiEvents.off("agent", onAgent);
+				uiEvents.off("team", onTeam);
+				uiEvents.off("pending-prompts", onPendingPrompts);
+				uiEvents.off("pending-prompt-submitted", onPendingPromptSubmitted);
+			};
+		},
+		onSubmit: async (input, mode, delivery, attachments, onCommandOutput) => {
+			let commandOutput: string | undefined;
+			let zeroTurnCost = false;
+			try {
+				await sessionRuntime.ensureReady();
+				await waitForSubmittedMode(mode);
+				sessionRuntime.resetAbortRequest();
+				if (!delivery) {
+					isRunning = true;
+				}
+
+				let chatCommandResult = await runInteractiveChatCommand({
+					prompt: input,
+					enabled: enableChatCommands,
+					config,
+					host: interactiveChatCommandHost,
+					chatCommandState,
+					autoApproveAllRef,
+					setInteractiveAutoApprove,
+					sessionRuntime,
+					stop: () => tuiApp?.destroy(),
+					onCommandOutput,
+				});
+				if (chatCommandResult.handled) {
+					return chatCommandResult.turnResult;
+				}
+				if (
+					shouldTryPluginChatCommands(input) &&
+					!pluginChatCommandHostLoaded
+				) {
+					await ensurePluginChatCommandHost();
+					chatCommandResult = await runInteractiveChatCommand({
+						prompt: input,
+						enabled: enableChatCommands,
+						config,
+						host: interactiveChatCommandHost,
+						chatCommandState,
+						autoApproveAllRef,
+						setInteractiveAutoApprove,
+						sessionRuntime,
+						stop: () => tuiApp?.destroy(),
+						onCommandOutput,
+					});
+					if (chatCommandResult.handled) {
+						return chatCommandResult.turnResult;
+					}
+				}
+				input = chatCommandResult.input;
+				commandOutput = chatCommandResult.commandOutput;
+				zeroTurnCost = await shouldZeroClineFreeModelCost(config);
+				zeroCurrentTurnCost = zeroTurnCost;
+				const {
+					prompt: userInput,
+					userImages,
+					userFiles,
+				} = await buildUserInputMessage(input, userInstructionService);
+				const mergedUserImages = [
+					...(attachments?.userImages ?? []),
+					...userImages,
+				];
+				// Mark a preceding user-initiated mode switch on this message so
+				// the model sees exactly when the rules changed, instead of only
+				// inferring it from the user_input mode attribute flipping.
+				const switchNotice = modeSwitchNotice.consume();
+				const noticedUserInput = switchNotice
+					? `${formatModeSwitchNotice(switchNotice.from, switchNotice.to)}\n${userInput}`
+					: userInput;
+
+				const applyPendingModeChange = async (): Promise<
+					AppliedModeChange | undefined
+				> => {
+					if (!pendingModeChange.current) return undefined;
+					const applied: AppliedModeChange = {
+						mode: pendingModeChange.current,
+						source: pendingModeChange.source ?? "ui",
+					};
+					pendingModeChange.current = null;
+					pendingModeChange.source = null;
+					const from = config.mode;
+					await sessionRuntime.applyMode(applied.mode);
+					tuiModeChanged.current?.(applied.mode);
+					// The switch_to_act_mode path announces itself through the
+					// continuation prompt; only UI toggles need a notice.
+					if (applied.source === "ui" && isInteractiveMode(from)) {
+						modeSwitchNotice.record(from, applied.mode);
+					}
+					return applied;
+				};
+
+				const result = await sendTurnWithActModeContinuation({
+					sendInitialTurn: () =>
+						sessionRuntime.sendCurrentTurn({
+							prompt: noticedUserInput,
+							mode,
+							userImages:
+								mergedUserImages.length > 0 ? mergedUserImages : undefined,
+							userFiles: userFiles.length > 0 ? userFiles : undefined,
+							delivery,
+						}),
+					sendContinuationTurn: (prompt) =>
+						sessionRuntime.sendCurrentTurn({ prompt, mode: "act" }),
+					applyPendingModeChange,
+				});
+
+				if (!result) {
+					return {
+						usage: { inputTokens: 0, outputTokens: 0 },
+						iterations: 0,
+						finishReason: "queued",
+						queued: delivery === "queue" || delivery === "steer",
+						commandOutput,
+					};
+				}
+				if (result.finishReason !== "completed") {
+					if (result.finishReason === "aborted" || isAbortInProgress()) {
+						const usage = zeroCliUsageCost(
+							await sessionRuntime.getAccumulatedUsage(result.usage),
+							zeroTurnCost,
+						);
+						return {
+							usage,
+							currentContextSize: getCurrentContextSize(result.messages),
+							iterations: result.iterations,
+							finishReason: "aborted",
+							commandOutput,
+						};
+					}
+					const errorText = result.text.trim();
+					throw new Error(
+						errorText || `Turn finished with ${result.finishReason}`,
+					);
+				}
+				const usage = zeroCliUsageCost(
+					await sessionRuntime.getAccumulatedUsage(result.usage),
+					zeroTurnCost,
+				);
+				return {
+					usage,
+					currentContextSize: getCurrentContextSize(result.messages),
+					iterations: result.iterations,
+					finishReason: result.finishReason,
+					commandOutput,
+				};
+			} catch (error) {
+				if (isAbortInProgress()) {
+					return {
+						usage: { inputTokens: 0, outputTokens: 0 },
+						iterations: 0,
+						finishReason: "aborted",
+						commandOutput,
+					};
+				}
+				logCliError(config.logger, "Interactive turn failed", {
+					error,
+					sessionId: sessionRuntime.getActiveSessionId() || undefined,
+					delivery,
+				});
+				throw error;
+			} finally {
+				zeroCurrentTurnCost = false;
+				if (!delivery) {
+					isRunning = false;
+					clearAbortInProgress();
+					refreshInteractiveSessionPoliciesIfPending();
+				}
+			}
+		},
+		onUpdatePendingPrompt: async (update) => {
+			await sessionRuntime.ensureReady();
+			const result = await sessionRuntime.updatePendingPrompt(update);
+			return {
+				sessionId: result.sessionId,
+				prompts: result.prompts.map(toQueuedPromptItem),
+				prompt: result.prompt ? toQueuedPromptItem(result.prompt) : undefined,
+				updated: result.updated,
+				removed: result.removed,
+			};
+		},
+		onAbort: () => {
+			return sessionRuntime.abortAll();
+		},
+		onExit: () => {
+			tuiApp?.destroy();
+		},
+		onRunningChange: (running) => {
+			isRunning = running;
+			if (!running) {
+				sessionRuntime.resetAbortRequest();
+				refreshInteractiveSessionPoliciesIfPending();
+			}
+		},
+		onTurnErrorReported: () => {},
+		onAutoApproveChange: (enabled) => {
+			setInteractiveAutoApprove(enabled);
+			void refreshInteractiveSessionPolicies();
+		},
+		onCompactionModeChange: async (mode) => {
+			await sessionRuntime.ensureReady();
+			applyCliCompactionMode(config, mode);
+			await sessionRuntime.restartWithCurrentMessages();
+		},
+		onModeChange: async (mode) => {
+			if (!isInteractiveMode(mode)) return;
+			if (isRunning) {
+				pendingModeChange.current = mode;
+				pendingModeChange.source = "ui";
+				sessionRuntime.abortAll();
+				return;
+			}
+			await applyModeChange(mode);
+		},
+		onNewSession: async () => {
+			await sessionRuntime.resetForNewSession();
+		},
+		onModelChange: () =>
+			applyInteractiveModelChange({
+				config,
+				providerSettingsManager,
+				sessionRuntime,
+			}),
+		onSessionRestart: async () => {
+			await sessionRuntime.ensureReady();
+			await sessionRuntime.restartEmpty();
+		},
+		onAccountChange: async () => {
+			await sessionRuntime.ensureReady();
+			await loadClineAccountSnapshot({
+				config,
+				clineApiBaseUrl: options?.clineApiBaseUrl,
+			}).catch((error) => {
+				logCliError(
+					config.logger,
+					"Cline account refresh after account change failed",
+					{ error },
+				);
+			});
+			await sessionRuntime.restartWithCurrentMessages();
+		},
+		onResumeSession: async (sessionId: string) => {
+			await sessionRuntime.ensureReady();
+			const messages = await sessionRuntime.resumeSession(sessionId);
+			const usage = await sessionRuntime.getAccumulatedUsage({
+				inputTokens: 0,
+				outputTokens: 0,
+			});
+			return {
+				messages,
+				totalCost: usage.totalCost,
+				currentContextSize: getCurrentContextSize(messages),
+			};
+		},
+		onCompact: async () => {
+			await sessionRuntime.ensureReady();
+			return await sessionRuntime.compactCurrentSession();
+		},
+		onFork: async () => {
+			await sessionRuntime.ensureReady();
+			return await sessionRuntime.forkCurrentSession();
+		},
+		getCheckpointData: async () => {
+			await sessionRuntime.ensureReady();
+			return await sessionRuntime.getCheckpointData();
+		},
+		onRestoreCheckpoint: async (runCount, restoreWorkspace) => {
+			await sessionRuntime.ensureReady();
+			return await sessionRuntime.restoreCheckpoint(runCount, restoreWorkspace);
+		},
+		setToolApprover: (fn) => {
+			tuiToolApprover.current = fn;
+		},
+		setAskQuestion: (fn) => {
+			tuiAskQuestion.current = fn;
+		},
+		setModeChangeNotifier: (fn) => {
+			tuiModeChanged.current = fn;
+		},
+	});
+
+	if (!loadDeferredInitialMessages) {
+		setTimeout(() => {
+			void sessionRuntime.ensureReady().catch((error) => {
+				if (sessionRuntime.isShutdownRequested() || startupErrorReported) {
+					return;
+				}
+				startupErrorReported = true;
+				logCliError(config.logger, "Interactive startup failed", { error });
+				writeErr(error instanceof Error ? error.message : String(error));
+				tuiApp?.destroy();
+			});
+		}, 0);
+	}
+
+	let exitSummary: InteractiveExitSummary | undefined;
+	try {
+		await tuiApp.waitUntilExit();
+	} finally {
+		exitSummary = await cleanupRuntime();
+	}
+	if (exitSummary) {
+		prepareTerminalForPostTuiOutput();
+		writeln(formatInteractiveExitSummary(exitSummary));
+	}
+}
diff --git a/apps/cli/src/runtime/run-zen.test.ts b/apps/cli/src/runtime/run-zen.test.ts
new file mode 100644
index 0000000..385700b
--- /dev/null
+++ b/apps/cli/src/runtime/run-zen.test.ts
@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const {
+	connect,
+	close,
+	startRuntimeSession,
+	sendRuntimeSession,
+	buildUserInputMessage,
+	ensureCliHubServer,
+	emitJsonLine,
+	writeErr,
+	writeln,
+} = vi.hoisted(() => ({
+	connect: vi.fn<() => Promise<void>>(),
+	close: vi.fn(),
+	startRuntimeSession: vi.fn(),
+	sendRuntimeSession: vi.fn(),
+	buildUserInputMessage: vi.fn(),
+	ensureCliHubServer: vi.fn(),
+	emitJsonLine: vi.fn(),
+	writeErr: vi.fn(),
+	writeln: vi.fn(),
+}));
+
+vi.mock("@cline/core", () => ({
+	HubSessionClient: class {
+		connect = connect;
+		close = close;
+		startRuntimeSession = startRuntimeSession;
+		sendRuntimeSession = sendRuntimeSession;
+	},
+}));
+
+vi.mock("./prompt", () => ({
+	buildUserInputMessage,
+}));
+
+vi.mock("../utils/hub-runtime", () => ({
+	ensureCliHubServer,
+}));
+
+vi.mock("../utils/output", () => ({
+	c: { dim: "", reset: "" },
+	emitJsonLine,
+	writeErr,
+	writeln,
+}));
+
+import { runZen } from "./run-zen";
+
+describe("runZen", () => {
+	afterEach(() => {
+		delete process.env.CLINE_SESSION_BACKEND_MODE;
+		vi.clearAllMocks();
+	});
+
+	it("waits for hub acknowledgement before closing the session client", async () => {
+		let resolveDispatch: (() => void) | undefined;
+		sendRuntimeSession.mockImplementation(
+			() =>
+				new Promise((resolve) => {
+					resolveDispatch = () => resolve({ result: undefined });
+				}),
+		);
+		connect.mockResolvedValue(undefined);
+		startRuntimeSession.mockResolvedValue({ sessionId: "session-123" });
+		buildUserInputMessage.mockResolvedValue({
+			prompt: "ship it",
+			userImages: [],
+			userFiles: [],
+		});
+		ensureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+
+		const run = runZen("ship it", {
+			sandbox: false,
+			workspaceRoot: "/workspace",
+			cwd: "/workspace",
+			providerId: "cline",
+			modelId: "test-model",
+			apiKey: "",
+			systemPrompt: "",
+			loggerConfig: undefined,
+			outputMode: "text",
+		} as never);
+
+		await vi.waitFor(() => {
+			expect(sendRuntimeSession).toHaveBeenCalledOnce();
+		});
+		expect(close).not.toHaveBeenCalled();
+
+		resolveDispatch?.();
+		await run;
+
+		expect(startRuntimeSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				mode: "yolo",
+				toolExecutors: ["submit"],
+			}),
+		);
+		expect(sendRuntimeSession).toHaveBeenCalledOnce();
+		expect(close).toHaveBeenCalledOnce();
+		expect(writeErr).not.toHaveBeenCalled();
+	});
+});
diff --git a/apps/cli/src/runtime/run-zen.ts b/apps/cli/src/runtime/run-zen.ts
new file mode 100644
index 0000000..8dd683a
--- /dev/null
+++ b/apps/cli/src/runtime/run-zen.ts
@@ -0,0 +1,181 @@
+import type { UserInstructionConfigService } from "@cline/core";
+import { HubSessionClient } from "@cline/core";
+import type { ChatStartSessionRequest } from "@cline/shared";
+import { resolveCliSessionMetadata } from "../utils/enterprise";
+import { ensureCliHubServer } from "../utils/hub-runtime";
+import { c, emitJsonLine, writeErr, writeln } from "../utils/output";
+import type { Config } from "../utils/types";
+import { buildUserInputMessage } from "./prompt";
+
+const ZEN_DISPATCH_ACK_TIMEOUT_MS = 5_000;
+
+/**
+ * Zen mode: fire-and-forget dispatch of a task to the background hub.
+ *
+ * Unlike a normal CLI run, zen mode does not stay connected to watch the
+ * session stream. It submits the turn to the hub and exits immediately. The
+ * hub continues to execute the agent loop in the background and, on
+ * completion, already publishes a `ui.notify` event which the menubar app
+ * (if installed) surfaces as a system notification. If the menubar app is not
+ * running, users can still find the result later via `cline history`.
+ *
+ * Because no human is available to approve tool calls once the CLI exits,
+ * zen mode forces full tool auto-approval (same semantics as yolo) and only
+ * works with a hub-backed session. Sandbox mode (enabled via --data-dir) is
+ * incompatible with zen because sandbox requires a local backend that
+ * terminates with the CLI.
+ */
+export async function runZen(
+	prompt: string,
+	config: Config,
+	userInstructionService?: UserInstructionConfigService,
+): Promise<void> {
+	if (config.sandbox) {
+		writeErr(
+			"--zen cannot be combined with --data-dir (sandbox requires a local backend).",
+		);
+		process.exitCode = 1;
+		return;
+	}
+	if (
+		process.env.CLINE_SESSION_BACKEND_MODE?.trim().toLowerCase() === "local"
+	) {
+		writeErr(
+			"--zen requires the hub backend but CLINE_SESSION_BACKEND_MODE=local is set.",
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	const workspaceRoot = config.workspaceRoot ?? config.cwd;
+	let hubUrl: string;
+	let hubAuthToken: string;
+	try {
+		const hub = await ensureCliHubServer(workspaceRoot);
+		hubUrl = hub.url;
+		hubAuthToken = hub.authToken;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		writeErr(`failed to start background hub: ${message}`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const sessionClient = new HubSessionClient({
+		address: hubUrl,
+		authToken: hubAuthToken,
+		clientType: "cli-zen",
+		displayName: "Cline CLI (zen)",
+		workspaceRoot,
+		cwd: config.cwd,
+	});
+
+	let sessionId: string | undefined;
+	try {
+		await sessionClient.connect();
+
+		const {
+			prompt: userInput,
+			userImages,
+			userFiles,
+		} = await buildUserInputMessage(prompt, userInstructionService);
+
+		const startRequest: ChatStartSessionRequest = {
+			workspaceRoot,
+			cwd: config.cwd,
+			provider: config.providerId,
+			model: config.modelId,
+			apiKey: config.apiKey || undefined,
+			systemPrompt: config.systemPrompt,
+			// Zen runs unattended: use yolo-style tool behavior so tool calls are
+			// auto-approved without a human in the loop.
+			mode: "yolo",
+			rules: undefined,
+			enableTools: true,
+			enableSpawn: false,
+			enableTeams: false,
+			autoApproveTools: true,
+			toolExecutors: ["submit"],
+			source: "cline-cli-zen",
+			interactive: false,
+			logger: config.loggerConfig,
+		};
+
+		const started = await sessionClient.startRuntimeSession(startRequest);
+		sessionId = started.sessionId;
+		const remoteConfigMetadata = await resolveCliSessionMetadata(
+			sessionId,
+		).catch(() => undefined);
+		if (remoteConfigMetadata && sessionClient.updateSession) {
+			await sessionClient
+				.updateSession({
+					sessionId,
+					metadata: remoteConfigMetadata,
+				})
+				.catch(() => undefined);
+		}
+
+		// Wait for the hub to acknowledge `session.send_input` before closing the
+		// socket. That confirms the prompt frame reached the hub and was accepted
+		// for execution, avoiding silent drops on slow or loaded systems.
+		await Promise.race([
+			sessionClient.sendRuntimeSession(started.sessionId, {
+				config: startRequest,
+				prompt: userInput,
+				attachments:
+					userImages.length > 0 || userFiles.length > 0
+						? {
+								userImages: userImages.length > 0 ? userImages : undefined,
+								userFiles:
+									userFiles.length > 0
+										? userFiles.map((content, index) => ({
+												name: `attachment-${index + 1}`,
+												content,
+											}))
+										: undefined,
+							}
+						: undefined,
+			}),
+			new Promise<never>((_, reject) => {
+				setTimeout(() => {
+					reject(
+						new Error(
+							`timed out waiting for hub to acknowledge zen dispatch after ${ZEN_DISPATCH_ACK_TIMEOUT_MS} ms`,
+						),
+					);
+				}, ZEN_DISPATCH_ACK_TIMEOUT_MS);
+			}),
+		]);
+
+		if (config.outputMode === "json") {
+			emitJsonLine("stdout", {
+				type: "zen_dispatched",
+				sessionId,
+				hubUrl,
+				workspaceRoot,
+			});
+		} else {
+			writeln(
+				`${c.dim}[zen]${c.reset} the CLI is exiting; the session ${sessionId} will continue running in the background.`,
+			);
+			writeln(
+				`${c.dim}[zen]${c.reset} check ${c.dim} history${c.reset} later to see the result.`,
+			);
+		}
+		process.exitCode = 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (config.outputMode === "json") {
+			emitJsonLine("stderr", {
+				type: "zen_error",
+				sessionId,
+				message,
+			});
+		} else {
+			writeErr(`zen dispatch failed: ${message}`);
+		}
+		process.exitCode = 1;
+	} finally {
+		sessionClient.close();
+	}
+}
diff --git a/apps/cli/src/runtime/session-events.test.ts b/apps/cli/src/runtime/session-events.test.ts
new file mode 100644
index 0000000..987ed35
--- /dev/null
+++ b/apps/cli/src/runtime/session-events.test.ts
@@ -0,0 +1,239 @@
+import type { AgentEvent } from "@cline/core";
+import { describe, expect, it, vi } from "vitest";
+import { subscribeToAgentEvents } from "./session-events";
+
+type AgentDoneEvent = Extract<AgentEvent, { type: "done" }>;
+
+describe("subscribeToAgentEvents", () => {
+	const done = ({
+		iterations,
+		text = "ok",
+		usage,
+	}: {
+		iterations: number;
+		text?: string;
+		usage?: AgentDoneEvent["usage"];
+	}): AgentDoneEvent => ({
+		type: "done",
+		reason: "completed",
+		iterations,
+		text,
+		...(usage ? { usage } : {}),
+	});
+
+	it("suppresses duplicate structured done events", () => {
+		const sessionManager = {
+			subscribe: vi.fn((listener: (event: unknown) => void) => {
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({ iterations: 5 }),
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({ iterations: 0, text: "" }),
+					},
+				});
+				return () => {};
+			}),
+		};
+		const onAgentEvent = vi.fn();
+
+		subscribeToAgentEvents(sessionManager, onAgentEvent);
+
+		expect(onAgentEvent).toHaveBeenCalledTimes(1);
+		expect(onAgentEvent).toHaveBeenCalledWith(
+			expect.objectContaining({ iterations: 5 }),
+		);
+	});
+
+	it("suppresses duplicate chunk-parsed done events", () => {
+		const sessionManager = {
+			subscribe: vi.fn((listener: (event: unknown) => void) => {
+				listener({
+					type: "chunk",
+					payload: {
+						stream: "agent",
+						chunk: JSON.stringify(done({ iterations: 5 })),
+					},
+				});
+				listener({
+					type: "chunk",
+					payload: {
+						stream: "agent",
+						chunk: JSON.stringify(done({ iterations: 0 })),
+					},
+				});
+				return () => {};
+			}),
+		};
+		const onAgentEvent = vi.fn();
+
+		subscribeToAgentEvents(sessionManager, onAgentEvent);
+
+		expect(onAgentEvent).toHaveBeenCalledTimes(1);
+		expect(onAgentEvent).toHaveBeenCalledWith(
+			expect.objectContaining({ iterations: 5 }),
+		);
+	});
+
+	it("emits a later richer structured done event", () => {
+		const richUsage: AgentDoneEvent["usage"] = {
+			inputTokens: 10,
+			outputTokens: 20,
+		};
+		const sessionManager = {
+			subscribe: vi.fn((listener: (event: unknown) => void) => {
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({ iterations: 0, text: "" }),
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({
+							iterations: 5,
+							text: "final answer",
+							usage: richUsage,
+						}),
+					},
+				});
+				return () => {};
+			}),
+		};
+		const onAgentEvent = vi.fn();
+
+		subscribeToAgentEvents(sessionManager, onAgentEvent);
+
+		expect(onAgentEvent).toHaveBeenCalledTimes(2);
+		expect(onAgentEvent).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				iterations: 5,
+				text: "final answer",
+				usage: richUsage,
+			}),
+		);
+	});
+
+	it("emits a richer structured done after a chunk fallback done", () => {
+		const sessionManager = {
+			subscribe: vi.fn((listener: (event: unknown) => void) => {
+				listener({
+					type: "chunk",
+					payload: {
+						stream: "agent",
+						chunk: JSON.stringify(done({ iterations: 0, text: "" })),
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({ iterations: 5, text: "final answer" }),
+					},
+				});
+				return () => {};
+			}),
+		};
+		const onAgentEvent = vi.fn();
+
+		subscribeToAgentEvents(sessionManager, onAgentEvent);
+
+		expect(onAgentEvent).toHaveBeenCalledTimes(2);
+		expect(onAgentEvent).toHaveBeenLastCalledWith(
+			expect.objectContaining({ iterations: 5, text: "final answer" }),
+		);
+	});
+
+	it("emits done events for separate turns", () => {
+		const sessionManager = {
+			subscribe: vi.fn((listener: (event: unknown) => void) => {
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({ iterations: 5 }),
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						event: { type: "iteration_start", iteration: 1 },
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						event: done({ iterations: 1 }),
+					},
+				});
+				return () => {};
+			}),
+		};
+		const onAgentEvent = vi.fn();
+
+		subscribeToAgentEvents(sessionManager, onAgentEvent);
+
+		expect(onAgentEvent).toHaveBeenCalledTimes(3);
+		expect(onAgentEvent).toHaveBeenLastCalledWith(
+			expect.objectContaining({ type: "done", iterations: 1 }),
+		);
+	});
+
+	it("keeps teammate usage while suppressing teammate output", () => {
+		const teammateText: AgentEvent = {
+			type: "content_start",
+			contentType: "text",
+			text: "hidden teammate output",
+		};
+		const teammateUsage: AgentEvent = {
+			type: "usage",
+			inputTokens: 7,
+			outputTokens: 5,
+			cost: 0.12,
+			totalInputTokens: 7,
+			totalOutputTokens: 5,
+			totalCost: 0.12,
+		};
+		const leadText: AgentEvent = {
+			type: "content_start",
+			contentType: "text",
+			text: "lead output",
+		};
+		const sessionManager = {
+			subscribe: vi.fn((listener: (event: unknown) => void) => {
+				listener({
+					type: "agent_event",
+					payload: {
+						teamRole: "teammate",
+						event: teammateText,
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						teamRole: "teammate",
+						event: teammateUsage,
+					},
+				});
+				listener({
+					type: "agent_event",
+					payload: {
+						teamRole: "lead",
+						event: leadText,
+					},
+				});
+				return () => {};
+			}),
+		};
+		const onAgentEvent = vi.fn();
+
+		subscribeToAgentEvents(sessionManager, onAgentEvent);
+
+		expect(onAgentEvent).toHaveBeenCalledTimes(2);
+		expect(onAgentEvent).toHaveBeenNthCalledWith(1, teammateUsage);
+		expect(onAgentEvent).toHaveBeenNthCalledWith(2, leadText);
+	});
+});
diff --git a/apps/cli/src/runtime/session-events.ts b/apps/cli/src/runtime/session-events.ts
new file mode 100644
index 0000000..34fa965
--- /dev/null
+++ b/apps/cli/src/runtime/session-events.ts
@@ -0,0 +1,172 @@
+import { EventEmitter } from "node:events";
+import type {
+	AgentEvent,
+	CoreSessionEvent,
+	RuntimeHostSubscribeOptions,
+	TeamEvent,
+} from "@cline/core";
+
+export const getUIEventEmitter = () =>
+	new EventEmitter() as InteractiveEventBridge;
+
+export interface PendingPromptSnapshot {
+	sessionId: string;
+	prompts: Array<{
+		id: string;
+		prompt: string;
+		delivery: "queue" | "steer";
+		attachmentCount: number;
+	}>;
+}
+
+export interface PendingPromptSubmittedEvent {
+	sessionId: string;
+	id: string;
+	prompt: string;
+	delivery: "queue" | "steer";
+	attachmentCount: number;
+}
+
+interface InteractiveEventBridge {
+	on(event: "agent", listener: (event: AgentEvent) => void): this;
+	on(event: "team", listener: (event: TeamEvent) => void): this;
+	on(
+		event: "pending-prompts",
+		listener: (event: PendingPromptSnapshot) => void,
+	): this;
+	on(
+		event: "pending-prompt-submitted",
+		listener: (event: PendingPromptSubmittedEvent) => void,
+	): this;
+	off(event: "agent", listener: (event: AgentEvent) => void): this;
+	off(event: "team", listener: (event: TeamEvent) => void): this;
+	off(
+		event: "pending-prompts",
+		listener: (event: PendingPromptSnapshot) => void,
+	): this;
+	off(
+		event: "pending-prompt-submitted",
+		listener: (event: PendingPromptSubmittedEvent) => void,
+	): this;
+	emit(event: "agent", payload: AgentEvent): boolean;
+	emit(event: "team", payload: TeamEvent): boolean;
+	emit(event: "pending-prompts", payload: PendingPromptSnapshot): boolean;
+	emit(
+		event: "pending-prompt-submitted",
+		payload: PendingPromptSubmittedEvent,
+	): boolean;
+}
+
+type SessionManagerSubscriber = {
+	subscribe(
+		listener: (event: unknown) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void;
+};
+
+type AgentDoneEvent = Extract<AgentEvent, { type: "done" }>;
+
+function doneEventCompletenessScore(event: AgentDoneEvent): number {
+	let score = 0;
+	if (typeof event.text === "string" && event.text.trim().length > 0) {
+		score += 2;
+	}
+	if (typeof event.iterations === "number" && event.iterations > 0) {
+		score += 2;
+	}
+	if (event.usage) {
+		score += 3;
+	}
+	if (event.reason !== "completed") {
+		score += 1;
+	}
+	return score;
+}
+
+export function subscribeToAgentEvents(
+	sessionManager: SessionManagerSubscriber,
+	onAgentEvent: (event: AgentEvent) => void,
+	options?: RuntimeHostSubscribeOptions,
+): () => void {
+	let hasSeenStructuredAgentEvent = false;
+	let lastDoneEvent: AgentDoneEvent | undefined;
+	const emitAgentEvent = (event: AgentEvent): void => {
+		if (event.type === "iteration_start") {
+			lastDoneEvent = undefined;
+		}
+		if (event.type === "done") {
+			if (
+				lastDoneEvent &&
+				doneEventCompletenessScore(event) <=
+					doneEventCompletenessScore(lastDoneEvent)
+			) {
+				return;
+			}
+			lastDoneEvent = event;
+		}
+		onAgentEvent(event);
+	};
+	return sessionManager.subscribe((event: unknown) => {
+		const typedEvent = event as
+			| { type: "agent_event"; payload: { event: AgentEvent } }
+			| { type: "chunk"; payload: { stream: string; chunk: string } }
+			| { type: string; payload?: unknown };
+		if (typedEvent.type === "agent_event") {
+			hasSeenStructuredAgentEvent = true;
+			const payload = typedEvent.payload as
+				| { event?: AgentEvent; teamRole?: string }
+				| undefined;
+			// Skip teammate output because it would interleave with lead output on
+			// shared stdout, but keep usage events so session totals update live.
+			if (
+				payload?.event &&
+				(payload.teamRole !== "teammate" || payload.event.type === "usage")
+			) {
+				emitAgentEvent(payload.event);
+			}
+			return;
+		}
+
+		const chunkEvent = event as
+			| { type: "chunk"; payload: { stream: string; chunk: string } }
+			| { type: string; payload?: unknown };
+		if (
+			chunkEvent.type !== "chunk" ||
+			!chunkEvent.payload ||
+			typeof chunkEvent.payload !== "object"
+		) {
+			return;
+		}
+		if (hasSeenStructuredAgentEvent) {
+			return;
+		}
+		const payload = chunkEvent.payload as { stream?: string; chunk?: string };
+		if (payload.stream !== "agent" || typeof payload.chunk !== "string") {
+			return;
+		}
+		try {
+			emitAgentEvent(JSON.parse(payload.chunk) as AgentEvent);
+		} catch {
+			// Best-effort event parsing path.
+		}
+	}, options);
+}
+
+export function subscribeToPendingPromptEvents(
+	sessionManager: SessionManagerSubscriber,
+	handlers: {
+		onPendingPrompts: (event: PendingPromptSnapshot) => void;
+		onPendingPromptSubmitted: (event: PendingPromptSubmittedEvent) => void;
+	},
+): () => void {
+	return sessionManager.subscribe((event: unknown) => {
+		const typedEvent = event as CoreSessionEvent;
+		if (typedEvent.type === "pending_prompts") {
+			handlers.onPendingPrompts(typedEvent.payload);
+			return;
+		}
+		if (typedEvent.type === "pending_prompt_submitted") {
+			handlers.onPendingPromptSubmitted(typedEvent.payload);
+		}
+	});
+}
diff --git a/apps/cli/src/runtime/tool-policies.test.ts b/apps/cli/src/runtime/tool-policies.test.ts
new file mode 100644
index 0000000..8658075
--- /dev/null
+++ b/apps/cli/src/runtime/tool-policies.test.ts
@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import {
+	applyInteractiveAutoApproveOverride,
+	cloneToolPolicies,
+	resolveInteractiveAutoApprovePolicy,
+} from "./tool-policies";
+
+describe("tool policy helpers", () => {
+	it("keeps safe tools auto-approved when toggled off", () => {
+		const baseline = {
+			"*": { autoApprove: true },
+			run_commands: { autoApprove: true, enabled: true },
+			read_files: { enabled: true },
+		};
+		const target = cloneToolPolicies(baseline);
+
+		applyInteractiveAutoApproveOverride({
+			targetPolicies: target,
+			baselinePolicies: baseline,
+			enabled: false,
+		});
+
+		expect(target).toEqual({
+			"*": { autoApprove: false },
+			ask_followup_question: { autoApprove: true },
+			ask_question: { autoApprove: true },
+			fetch_web_content: { autoApprove: true },
+			run_commands: { autoApprove: false, enabled: true },
+			read_files: { autoApprove: true, enabled: true },
+			search_codebase: { autoApprove: true },
+			skills: { autoApprove: true },
+			submit_and_exit: { autoApprove: true },
+		});
+	});
+
+	it("keeps explicit per-tool approval requirements when toggled off", () => {
+		const baseline = {
+			"*": { autoApprove: true },
+			ask_question: { autoApprove: false, enabled: true },
+			editor: { autoApprove: true, enabled: true },
+		};
+		const target = cloneToolPolicies(baseline);
+
+		applyInteractiveAutoApproveOverride({
+			targetPolicies: target,
+			baselinePolicies: baseline,
+			enabled: false,
+		});
+
+		expect(target).toMatchObject({
+			"*": { autoApprove: false },
+			ask_question: { autoApprove: false, enabled: true },
+			editor: { autoApprove: false, enabled: true },
+		});
+	});
+
+	it("forces all baseline policies to auto-approve when toggled back on", () => {
+		const baseline = {
+			"*": { autoApprove: false },
+			run_commands: { autoApprove: true, enabled: true },
+			editor: { autoApprove: false, enabled: true },
+		};
+		const target = cloneToolPolicies(baseline);
+
+		applyInteractiveAutoApproveOverride({
+			targetPolicies: target,
+			baselinePolicies: baseline,
+			enabled: false,
+		});
+		applyInteractiveAutoApproveOverride({
+			targetPolicies: target,
+			baselinePolicies: baseline,
+			enabled: true,
+		});
+
+		expect(target).toEqual({
+			"*": { autoApprove: true },
+			run_commands: { autoApprove: true, enabled: true },
+			editor: { autoApprove: true, enabled: true },
+		});
+	});
+
+	it("resolves live per-tool policies from the interactive auto-approve state", () => {
+		const baseline = {
+			"*": { autoApprove: false },
+			read_files: { enabled: true },
+			editor: { autoApprove: false, enabled: true },
+		};
+
+		expect(
+			resolveInteractiveAutoApprovePolicy({
+				toolName: "editor",
+				baselinePolicies: baseline,
+				enabled: true,
+			}),
+		).toEqual({ autoApprove: true, enabled: true });
+		expect(
+			resolveInteractiveAutoApprovePolicy({
+				toolName: "run_commands",
+				baselinePolicies: baseline,
+				enabled: false,
+			}),
+		).toEqual({ autoApprove: false });
+		expect(
+			resolveInteractiveAutoApprovePolicy({
+				toolName: "read_files",
+				baselinePolicies: baseline,
+				enabled: false,
+			}),
+		).toEqual({ autoApprove: true, enabled: true });
+	});
+});
diff --git a/apps/cli/src/runtime/tool-policies.ts b/apps/cli/src/runtime/tool-policies.ts
new file mode 100644
index 0000000..bac5b96
--- /dev/null
+++ b/apps/cli/src/runtime/tool-policies.ts
@@ -0,0 +1,95 @@
+import type { ToolPolicy } from "@cline/core";
+
+const SAFE_AUTO_APPROVE_TOOL_NAMES = [
+	"ask_followup_question",
+	"ask_question",
+	"fetch_web_content",
+	"read_files",
+	"search_codebase",
+	"skills",
+	"submit_and_exit",
+];
+
+const SAFE_AUTO_APPROVE_TOOLS = new Set<string>(SAFE_AUTO_APPROVE_TOOL_NAMES);
+
+function clonePolicy(policy: ToolPolicy | undefined): ToolPolicy {
+	return policy ? { ...policy } : {};
+}
+
+export function cloneToolPolicies(
+	policies: Record<string, ToolPolicy>,
+): Record<string, ToolPolicy> {
+	return Object.fromEntries(
+		Object.entries(policies).map(([name, policy]) => [
+			name,
+			clonePolicy(policy),
+		]),
+	);
+}
+
+export function resolveInteractiveAutoApprovePolicy(input: {
+	toolName: string;
+	baselinePolicies: Record<string, ToolPolicy>;
+	enabled: boolean;
+}): ToolPolicy {
+	const toolPolicy = input.baselinePolicies[input.toolName] ?? {};
+	const baselinePolicy = {
+		...(input.baselinePolicies["*"] ?? {}),
+		...toolPolicy,
+	};
+	return {
+		...baselinePolicy,
+		autoApprove: input.enabled
+			? true
+			: SAFE_AUTO_APPROVE_TOOLS.has(input.toolName)
+				? (toolPolicy.autoApprove ?? true)
+				: false,
+	};
+}
+
+export function applyInteractiveAutoApproveOverride(input: {
+	targetPolicies: Record<string, ToolPolicy>;
+	baselinePolicies: Record<string, ToolPolicy>;
+	enabled: boolean;
+}): void {
+	const nextPolicies: Record<string, ToolPolicy> = input.enabled
+		? Object.fromEntries(
+				Object.entries(input.baselinePolicies).map(([name, policy]) => [
+					name,
+					{
+						...policy,
+						autoApprove: true,
+					},
+				]),
+			)
+		: Object.fromEntries(
+				Object.entries(input.baselinePolicies).map(([name, policy]) => [
+					name,
+					{
+						...policy,
+						autoApprove: resolveInteractiveAutoApprovePolicy({
+							toolName: name,
+							baselinePolicies: input.baselinePolicies,
+							enabled: false,
+						}).autoApprove,
+					},
+				]),
+			);
+
+	if (!input.enabled) {
+		for (const name of SAFE_AUTO_APPROVE_TOOL_NAMES) {
+			nextPolicies[name] ??= { autoApprove: true };
+		}
+	}
+
+	const globalPolicy = clonePolicy(nextPolicies["*"]);
+	globalPolicy.autoApprove = input.enabled;
+	nextPolicies["*"] = globalPolicy;
+
+	for (const key of Object.keys(input.targetPolicies)) {
+		delete input.targetPolicies[key];
+	}
+	for (const [name, policy] of Object.entries(nextPolicies)) {
+		input.targetPolicies[name] = policy;
+	}
+}
diff --git a/apps/cli/src/runtime/tools.ts b/apps/cli/src/runtime/tools.ts
new file mode 100644
index 0000000..0dfbe23
--- /dev/null
+++ b/apps/cli/src/runtime/tools.ts
@@ -0,0 +1,17 @@
+import {
+	type BuiltinToolAvailabilityContext,
+	getCoreBuiltinToolCatalog,
+	resolveDisabledToolNames,
+	type ToolCatalogEntry,
+} from "@cline/core";
+
+export type { ToolCatalogEntry } from "@cline/core";
+
+export function getToolCatalog(
+	availabilityContext?: BuiltinToolAvailabilityContext,
+): ToolCatalogEntry[] {
+	return getCoreBuiltinToolCatalog({
+		disabledToolIds: resolveDisabledToolNames(),
+		...availabilityContext,
+	});
+}
diff --git a/apps/cli/src/session/export.ts b/apps/cli/src/session/export.ts
new file mode 100644
index 0000000..7e46b12
--- /dev/null
+++ b/apps/cli/src/session/export.ts
@@ -0,0 +1,922 @@
+import {
+	type ContentBlock,
+	formatDisplayUserInput,
+	type MessageWithMetadata,
+	type ToolResultContent,
+	type ToolUseContent,
+} from "@cline/shared";
+import { formatStructuredCommand } from "../utils/helpers";
+
+export interface ConversationHistory {
+	version: number;
+	updated_at: string;
+	messages: MessageWithMetadata[];
+	systemPrompt?: string;
+	system_prompt?: string;
+	sessionId?: string;
+	agent?: string;
+	taskType?: string;
+}
+
+// Helper to check if content is string or array
+export function isStringContent(
+	content: string | ContentBlock[],
+): content is string {
+	return typeof content === "string";
+}
+
+// Generate a self-contained HTML file that renders the conversation
+export function generateConversationHTML(
+	data: ConversationHistory,
+	fileName: string,
+): string {
+	// Build tool results map
+	const toolResultsMap = new Map<string, ToolResultContent>();
+	data.messages.forEach((msg) => {
+		if (!isStringContent(msg.content)) {
+			msg.content.forEach((block) => {
+				if (block.type === "tool_result") {
+					toolResultsMap.set(block.tool_use_id, block);
+				}
+			});
+		}
+	});
+
+	// Filter messages (same logic as viewer)
+	const filteredMessages = data.messages.filter((msg) => {
+		if (msg.role === "assistant") return true;
+		if (isStringContent(msg.content)) {
+			return msg.content.trim().length > 0;
+		}
+		return msg.content.some(
+			(block: ContentBlock) =>
+				block.type === "text" && block.text.trim().length > 0,
+		);
+	});
+
+	// Calculate stats
+	let totalCost = 0;
+	let totalInputTokens = 0;
+	let totalOutputTokens = 0;
+	data.messages.forEach((msg) => {
+		if (msg.metrics) {
+			totalCost += msg.metrics.cost ?? 0;
+			totalInputTokens += msg.metrics.inputTokens ?? 0;
+			totalOutputTokens += msg.metrics.outputTokens ?? 0;
+		}
+	});
+
+	// Generate HTML for messages
+	const messagesHTML = filteredMessages
+		.map((msg, index) => {
+			const isUser = msg.role === "user";
+			const prevMessage = index > 0 ? filteredMessages[index - 1] : null;
+			const hideHeader =
+				msg.role === "assistant" && prevMessage?.role === "assistant";
+
+			return generateMessageHTML(msg, isUser, hideHeader, toolResultsMap);
+		})
+		.join("\n");
+
+	const updatedAt = data.updated_at
+		? new Date(data.updated_at).toLocaleString()
+		: "";
+
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(fileName)} - Conversation Export</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      background-color: #09090b;
+      color: #fafafa;
+      line-height: 1.6;
+    }
+
+    html,
+    body,
+    .content pre,
+    .tool-content,
+    .line-content,
+    .dots-container {
+      scrollbar-width: none;
+      -ms-overflow-style: none;
+    }
+
+    html::-webkit-scrollbar,
+    body::-webkit-scrollbar,
+    .content pre::-webkit-scrollbar,
+    .tool-content::-webkit-scrollbar,
+    .line-content::-webkit-scrollbar,
+    .dots-container::-webkit-scrollbar {
+      display: none;
+      width: 0;
+      height: 0;
+    }
+    
+    .header {
+      position: sticky;
+      top: 0;
+      z-index: 10;
+      background: rgba(9, 9, 11, 0.95);
+      backdrop-filter: blur(8px);
+      border-bottom: 1px solid #27272a;
+      padding: 1rem 1.5rem;
+    }
+    
+    .header-content {
+      max-width: 56rem;
+      margin: 0 auto;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      flex-wrap: wrap;
+      gap: 1rem;
+    }
+    
+    .stats {
+      display: flex;
+      align-items: center;
+      gap: 1.5rem;
+      flex-wrap: wrap;
+    }
+    
+    .stat {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      font-size: 0.875rem;
+      color: #a1a1aa;
+    }
+    
+    .stat svg {
+      width: 1rem;
+      height: 1rem;
+    }
+    
+    .messages {
+      max-width: 56rem;
+      margin: 0 auto;
+    }
+    
+    .message {
+      padding: 1.5rem;
+      border-bottom: 1px solid #18181b;
+    }
+    
+    .message.user {
+      background: rgba(39, 39, 42, 0.3);
+    }
+    
+    .message-header {
+      display: flex;
+      align-items: center;
+      gap: 0.75rem;
+      margin-bottom: 1rem;
+    }
+    
+    .avatar {
+      width: 2rem;
+      height: 2rem;
+      border-radius: 9999px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 0.875rem;
+      font-weight: 500;
+    }
+    
+    .avatar.user {
+      background: #3b82f6;
+      color: white;
+    }
+    
+    .avatar.assistant {
+      background: #27272a;
+      color: #a1a1aa;
+    }
+    
+    .role {
+      font-weight: 500;
+      font-size: 0.875rem;
+    }
+    
+    .model {
+      font-size: 0.75rem;
+      color: #71717a;
+      font-family: ui-monospace, monospace;
+    }
+    
+    .content {
+      padding-left: 2.75rem;
+    }
+    
+    .content p {
+      margin-bottom: 0.5rem;
+    }
+    
+    .content pre {
+      background: #18181b;
+      border: 1px solid #27272a;
+      border-radius: 0.5rem;
+      padding: 1rem;
+      overflow-x: auto;
+      font-family: ui-monospace, monospace;
+      font-size: 0.875rem;
+      margin: 0.75rem 0;
+    }
+    
+    .content code {
+      font-family: ui-monospace, monospace;
+      background: #27272a;
+      padding: 0.125rem 0.25rem;
+      border-radius: 0.25rem;
+      font-size: 0.875rem;
+    }
+    
+    .content pre code {
+      background: transparent;
+      padding: 0;
+    }
+    
+    .tool-block {
+      margin: 0.75rem 0;
+      border: 1px solid #27272a;
+      border-radius: 0.5rem;
+      overflow: hidden;
+    }
+    
+    .tool-header {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.75rem 1rem;
+      background: #18181b;
+      font-family: ui-monospace, monospace;
+      font-size: 0.875rem;
+    }
+    
+    .tool-header svg {
+      width: 1rem;
+      height: 1rem;
+      color: #71717a;
+    }
+    
+    .tool-content {
+      padding: 1rem;
+      font-family: ui-monospace, monospace;
+      font-size: 0.75rem;
+      background: #09090b;
+      white-space: pre-wrap;
+      word-break: break-all;
+      overflow: auto;
+    }
+    
+    .diff-block {
+      margin: 0.75rem 0;
+      border: 1px solid #27272a;
+      border-radius: 0.5rem;
+      overflow: hidden;
+      background: #09090b;
+    }
+    
+    .diff-header {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.625rem 1rem;
+      background: #18181b;
+      border-bottom: 1px solid #27272a;
+      font-family: ui-monospace, monospace;
+      font-size: 0.875rem;
+    }
+    
+    .diff-header svg {
+      width: 1rem;
+      height: 1rem;
+      color: #71717a;
+    }
+    
+    .diff-stats {
+      margin-left: auto;
+      display: flex;
+      gap: 0.5rem;
+      font-size: 0.75rem;
+    }
+    
+    .diff-stats .added {
+      color: #4ade80;
+    }
+    
+    .diff-stats .removed {
+      color: #f87171;
+    }
+    
+    .diff-content {
+      font-family: ui-monospace, monospace;
+      font-size: 0.75rem;
+    }
+    
+    .diff-line {
+      display: flex;
+      border-bottom: 1px solid #18181b;
+    }
+    
+    .diff-line:last-child {
+      border-bottom: none;
+    }
+    
+    .diff-line.added {
+      background: rgba(74, 222, 128, 0.1);
+    }
+    
+    .diff-line.removed {
+      background: rgba(248, 113, 113, 0.1);
+    }
+    
+    .line-num {
+      width: 3rem;
+      padding: 0.125rem 0.5rem;
+      text-align: right;
+      color: #52525b;
+      border-right: 1px solid #27272a;
+      user-select: none;
+      flex-shrink: 0;
+    }
+    
+    .line-indicator {
+      width: 1.5rem;
+      padding: 0.125rem 0.25rem;
+      text-align: center;
+      user-select: none;
+      flex-shrink: 0;
+    }
+    
+    .line-indicator.added {
+      color: #4ade80;
+      font-weight: bold;
+    }
+    
+    .line-indicator.removed {
+      color: #f87171;
+      font-weight: bold;
+    }
+    
+    .line-content {
+      padding: 0.125rem 0.75rem;
+      white-space: pre;
+      overflow-x: auto;
+      flex: 1;
+    }
+    
+    .line-content.added {
+      color: #86efac;
+    }
+    
+    .line-content.removed {
+      color: #fca5a5;
+    }
+    
+    .badge {
+      font-size: 0.625rem;
+      padding: 0.125rem 0.375rem;
+      border-radius: 0.25rem;
+      background: #27272a;
+      color: #71717a;
+    }
+    
+    .badge.new-file {
+      background: rgba(74, 222, 128, 0.2);
+      color: #4ade80;
+    }
+    
+    .error {
+      color: #f87171;
+    }
+    
+    .success {
+      color: #4ade80;
+    }
+    
+    .file-list {
+      display: flex;
+      flex-direction: column;
+      gap: 0.25rem;
+      margin: 0.5rem 0;
+    }
+    
+    .file-item {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.375rem 0.75rem;
+      background: #18181b;
+      border-radius: 0.375rem;
+      font-family: ui-monospace, monospace;
+      font-size: 0.75rem;
+      color: #a1a1aa;
+    }
+    
+    .command-block {
+      margin: 0.5rem 0;
+      padding: 0.75rem 1rem;
+      background: #18181b;
+      border-radius: 0.5rem;
+      font-family: ui-monospace, monospace;
+      font-size: 0.75rem;
+    }
+    
+    .command-label {
+      font-size: 0.625rem;
+      color: #71717a;
+      margin-bottom: 0.25rem;
+    }
+    
+    .dots-nav {
+      position: fixed;
+      right: 1rem;
+      top: 50%;
+      transform: translateY(-50%);
+      z-index: 20;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 0.25rem;
+    }
+    
+    .dots-nav-btn {
+      padding: 0.375rem;
+      border-radius: 0.5rem;
+      background: #27272a;
+      border: 1px solid #3f3f46;
+      cursor: pointer;
+      transition: background 0.2s;
+    }
+    
+    .dots-nav-btn:hover {
+      background: #3f3f46;
+    }
+    
+    .dots-nav-btn svg {
+      width: 0.75rem;
+      height: 0.75rem;
+      color: #a1a1aa;
+    }
+    
+    .dots-container {
+      display: flex;
+      flex-direction: column;
+      gap: 0.25rem;
+      padding: 0.5rem;
+      border-radius: 0.5rem;
+      background: #27272a;
+      border: 1px solid #3f3f46;
+      max-height: 60vh;
+      overflow-y: auto;
+    }
+    
+    .dot {
+      width: 0.5rem;
+      height: 0.5rem;
+      border-radius: 9999px;
+      cursor: pointer;
+      transition: all 0.2s;
+      flex-shrink: 0;
+    }
+    
+    .dot.user {
+      background: rgba(59, 130, 246, 0.4);
+    }
+    
+    .dot.user:hover {
+      background: rgba(59, 130, 246, 0.6);
+    }
+    
+    .dot.assistant {
+      background: rgba(161, 161, 170, 0.4);
+    }
+    
+    .dot.assistant:hover {
+      background: rgba(161, 161, 170, 0.6);
+    }
+    
+    .dot.active {
+      background: #3b82f6;
+      transform: scale(1.25);
+    }
+    
+    @media (max-width: 1024px) {
+      .dots-nav {
+        display: none;
+      }
+    }
+    
+    @media (max-width: 768px) {
+      .header-content {
+        flex-direction: column;
+        align-items: flex-start;
+      }
+      
+      .stats {
+        gap: 1rem;
+      }
+      
+      .content {
+        padding-left: 0;
+      }
+    }
+  </style>
+</head>
+<body>
+  <header class="header">
+    <div class="header-content">
+      <div class="stats">
+        <div class="stat">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"/></svg>
+          <span>${filteredMessages.length} messages</span>
+        </div>
+        ${
+					totalCost > 0
+						? `
+        <div class="stat">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="12" x2="12" y1="2" y2="22"/><path d="M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"/></svg>
+          <span>$${totalCost.toFixed(4)}</span>
+        </div>
+        `
+						: ""
+				}
+        ${
+					totalInputTokens > 0 || totalOutputTokens > 0
+						? `
+        <div class="stat">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="4" x2="20" y1="9" y2="9"/><line x1="4" x2="20" y1="15" y2="15"/><line x1="10" x2="8" y1="3" y2="21"/><line x1="16" x2="14" y1="3" y2="21"/></svg>
+          <span>${(totalInputTokens + totalOutputTokens).toLocaleString()} tokens</span>
+        </div>
+        `
+						: ""
+				}
+        ${
+					updatedAt
+						? `
+        <div class="stat">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+          <span>${updatedAt}</span>
+        </div>
+        `
+						: ""
+				}
+      </div>
+    </div>
+  </header>
+  
+  <div class="messages">
+    ${messagesHTML}
+  </div>
+  
+  <!-- Dots Navigation Bar -->
+  <nav class="dots-nav">
+    <button class="dots-nav-btn" onclick="scrollToMessage(0)" title="Scroll to top">
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m18 15-6-6-6 6"/></svg>
+    </button>
+    <div class="dots-container">
+      ${filteredMessages
+				.map(
+					(msg, idx) => `
+        <div class="dot ${msg.role}" data-index="${idx}" onclick="scrollToMessage(${idx})" title="Message ${idx + 1}: ${msg.role}"></div>
+      `,
+				)
+				.join("")}
+    </div>
+    <button class="dots-nav-btn" onclick="scrollToMessage(${filteredMessages.length - 1})" title="Scroll to bottom">
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m6 9 6 6 6-6"/></svg>
+    </button>
+  </nav>
+  
+  <script>
+    let currentIndex = 0;
+    const messages = document.querySelectorAll('.message');
+    const dots = document.querySelectorAll('.dot');
+    
+    function scrollToMessage(index) {
+      if (index >= 0 && index < messages.length) {
+        messages[index].scrollIntoView({ behavior: 'smooth', block: 'start' });
+        updateActiveDot(index);
+      }
+    }
+    
+    function updateActiveDot(index) {
+      dots.forEach((dot, i) => {
+        dot.classList.toggle('active', i === index);
+      });
+      currentIndex = index;
+    }
+    
+    // Track scroll position to update active dot
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach(entry => {
+        if (entry.isIntersecting) {
+          const index = Array.from(messages).indexOf(entry.target);
+          if (index !== -1) {
+            updateActiveDot(index);
+          }
+        }
+      });
+    }, { threshold: 0.5, rootMargin: '-80px 0px -50% 0px' });
+    
+    messages.forEach(msg => observer.observe(msg));
+    
+    // Initialize first dot as active
+    if (dots.length > 0) {
+      dots[0].classList.add('active');
+    }
+  </script>
+</body>
+</html>`;
+}
+
+function generateMessageHTML(
+	message: MessageWithMetadata,
+	isUser: boolean,
+	hideHeader: boolean,
+	toolResultsMap: Map<string, ToolResultContent>,
+): string {
+	const content = renderContentHTML(message.content, isUser, toolResultsMap);
+
+	if (hideHeader) {
+		return `
+    <div class="message ${isUser ? "user" : "assistant"}">
+      <div class="content" style="padding-left: 2.75rem;">
+        ${content}
+      </div>
+    </div>`;
+	}
+
+	return `
+    <div class="message ${isUser ? "user" : "assistant"}">
+      <div class="message-header">
+        <div class="avatar ${isUser ? "user" : "assistant"}">
+          ${isUser ? "U" : "A"}
+        </div>
+        <span class="role">${isUser ? "User" : "Assistant"}</span>
+        ${message.modelInfo?.id ? `<span class="model">${escapeHtml(message.modelInfo.id)}</span>` : ""}
+      </div>
+      <div class="content">
+        ${content}
+      </div>
+    </div>`;
+}
+
+function renderContentHTML(
+	content: string | ContentBlock[],
+	isUser: boolean,
+	toolResultsMap: Map<string, ToolResultContent>,
+): string {
+	if (typeof content === "string") {
+		const text = isUser ? formatDisplayUserInput(content) : content;
+		return renderTextHTML(text);
+	}
+
+	return content
+		.map((block) => {
+			switch (block.type) {
+				case "text": {
+					const text = isUser ? formatDisplayUserInput(block.text) : block.text;
+					return renderTextHTML(text);
+				}
+				case "tool_use":
+					return renderToolUseHTML(block, toolResultsMap.get(block.id));
+				case "tool_result":
+					return ""; // Tool results are rendered with their corresponding tool_use
+				default:
+					return "";
+			}
+		})
+		.join("\n");
+}
+
+function renderTextHTML(text: string): string {
+	// Simple markdown-like rendering
+	let html = escapeHtml(text);
+
+	// Code blocks
+	html = html.replace(/```(\w*)\n([\s\S]*?)```/g, (_, _lang, code) => {
+		return `<pre><code>${code.trim()}</code></pre>`;
+	});
+
+	// Inline code
+	html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
+
+	// Bold
+	html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+
+	// Line breaks
+	html = html.replace(/\n/g, "<br>");
+
+	return `<div>${html}</div>`;
+}
+
+function renderToolUseHTML(
+	block: ToolUseContent,
+	result?: ToolResultContent,
+): string {
+	const toolName = block.name;
+	const input = block.input;
+
+	// Check for edit/write tools with diff
+	const isEdit = [
+		"edit",
+		"write",
+		"apply_diff",
+		"str_replace_editor",
+		"replace_in_file",
+		"editor",
+	].some((t) => toolName.toLowerCase().includes(t));
+
+	const hasOldNew =
+		input.old_string !== undefined && input.new_string !== undefined;
+	const hasPathDiff = input.path !== undefined && input.new_text !== undefined;
+
+	if (isEdit && (hasOldNew || hasPathDiff)) {
+		const oldText = String(input.old_string ?? input.old_text ?? "");
+		const newText = String(input.new_string ?? input.new_text ?? "");
+		const filePath = String(input.file_path ?? input.path ?? "file");
+		const isNewFile = !oldText && !input.insert_line;
+
+		return renderDiffHTML(oldText, newText, filePath, isNewFile, result);
+	}
+
+	// Check for run_commands
+	if (
+		toolName.toLowerCase().includes("run_command") &&
+		Array.isArray(input.commands)
+	) {
+		return renderCommandsHTML(input.commands, result);
+	}
+
+	// Check for read_files
+	if (
+		toolName.toLowerCase().includes("read_file") &&
+		Array.isArray(input.file_paths)
+	) {
+		return renderFileListHTML(input.file_paths, result);
+	}
+
+	// Default tool rendering
+	return `
+    <div class="tool-block">
+      <div class="tool-header">
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/></svg>
+        <span>${escapeHtml(toolName)}</span>
+        ${
+					result
+						? result?.is_error
+							? '<span class="error">Error</span>'
+							: '<span class="success">Success</span>'
+						: ""
+				}
+      </div>
+      <div class="tool-content">${escapeHtml(JSON.stringify(input, null, 2))}</div>
+    </div>`;
+}
+
+function renderDiffHTML(
+	oldText: string,
+	newText: string,
+	filePath: string,
+	isNewFile: boolean,
+	_result?: ToolResultContent,
+): string {
+	const oldLines = oldText.split("\n");
+	const newLines = newText.split("\n");
+
+	// Simple diff: show removed lines then added lines
+	let diffHTML = "";
+	let addedCount = 0;
+	let removedCount = 0;
+
+	if (oldText) {
+		oldLines.forEach((line, i) => {
+			removedCount++;
+			diffHTML += `
+        <div class="diff-line removed">
+          <div class="line-num">${i + 1}</div>
+          <div class="line-indicator removed">-</div>
+          <div class="line-content removed">${escapeHtml(line) || " "}</div>
+        </div>`;
+		});
+	}
+
+	newLines.forEach((line, i) => {
+		addedCount++;
+		diffHTML += `
+      <div class="diff-line added">
+        <div class="line-num">${i + 1}</div>
+        <div class="line-indicator added">+</div>
+        <div class="line-content added">${escapeHtml(line) || " "}</div>
+      </div>`;
+	});
+
+	const ext = filePath.split(".").pop() || "";
+
+	return `
+    <div class="diff-block">
+      <div class="diff-header">
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"/><polyline points="14 2 14 8 20 8"/><path d="m10 13-2 2 2 2"/><path d="m14 17 2-2-2-2"/></svg>
+        <span>${escapeHtml(filePath)}</span>
+        ${ext ? `<span class="badge">${ext}</span>` : ""}
+        ${isNewFile ? '<span class="badge new-file">New File</span>' : ""}
+        <div class="diff-stats">
+          ${addedCount > 0 ? `<span class="added">+${addedCount}</span>` : ""}
+          ${removedCount > 0 ? `<span class="removed">-${removedCount}</span>` : ""}
+        </div>
+      </div>
+      <div class="diff-content">
+        ${diffHTML}
+      </div>
+    </div>`;
+}
+
+function renderCommandsHTML(
+	commands: unknown[],
+	_result?: ToolResultContent,
+): string {
+	return commands
+		.map(
+			(command, i) => `
+    <div class="command-block">
+      <div class="command-label">Command ${i + 1}</div>
+      <code>${escapeHtml(formatStructuredCommand(command))}</code>
+    </div>
+  `,
+		)
+		.join("\n");
+}
+
+function renderFileListHTML(
+	filePaths: string[],
+	_result?: ToolResultContent,
+): string {
+	return `
+    <div class="file-list">
+      ${filePaths
+				.map(
+					(fp) => `
+        <div class="file-item">
+          <svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"/><polyline points="14 2 14 8 20 8"/></svg>
+          ${escapeHtml(fp)}
+        </div>
+      `,
+				)
+				.join("\n")}
+    </div>`;
+}
+
+function escapeHtml(text: string): string {
+	return text
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&#039;");
+}
+
+export function exportSessionAsHTML(html: string, sessionId: string) {
+	const browserDocument = (globalThis as { document?: DocumentLike }).document;
+	if (
+		typeof Blob === "undefined" ||
+		typeof URL === "undefined" ||
+		!browserDocument
+	) {
+		throw new Error("exportSessionAsHTML requires a browser environment");
+	}
+	const blob = new Blob([html], { type: "text/html" });
+	const url = URL.createObjectURL(blob);
+	const a = browserDocument.createElement("a");
+	a.href = url;
+	a.download = `${sessionId}.html`;
+	browserDocument.body.appendChild(a);
+	a.click();
+	browserDocument.body.removeChild(a);
+	URL.revokeObjectURL(url);
+}
+
+type DocumentLike = {
+	body: {
+		appendChild(node: unknown): void;
+		removeChild(node: unknown): void;
+	};
+	createElement(tag: "a"): {
+		href: string;
+		download: string;
+		click(): void;
+	};
+};
diff --git a/apps/cli/src/session/session.test.ts b/apps/cli/src/session/session.test.ts
new file mode 100644
index 0000000..66e5d4c
--- /dev/null
+++ b/apps/cli/src/session/session.test.ts
@@ -0,0 +1,291 @@
+import {
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	vi,
+} from "vitest";
+
+const createCore = vi.fn();
+const getCliTelemetryService = vi.fn(() => undefined);
+const resolveSessionBackend = vi.fn();
+const listSessionHistoryFromBackend = vi.fn();
+const featureFlagsPoll = vi.fn(async () => {});
+const featureFlagsDispose = vi.fn(async () => {});
+
+vi.mock("@cline/core", async () => {
+	const actual =
+		await vi.importActual<typeof import("@cline/core")>("@cline/core");
+	return {
+		...actual,
+		ClineCore: {
+			create: createCore,
+		},
+		resolveSessionBackend,
+		listSessionHistoryFromBackend,
+	};
+});
+
+vi.mock("../utils/telemetry", () => ({
+	getCliTelemetryService,
+}));
+
+describe("createCliCore", () => {
+	let sessionModule: typeof import("./session");
+	const envSnapshot = {
+		CLINE_RPC_ADDRESS: process.env.CLINE_RPC_ADDRESS,
+		CLINE_SESSION_BACKEND_MODE: process.env.CLINE_SESSION_BACKEND_MODE,
+		CLINE_VCR: process.env.CLINE_VCR,
+	};
+
+	beforeAll(async () => {
+		sessionModule = await import("./session");
+	});
+
+	beforeEach(() => {
+		createCore.mockReset();
+		resolveSessionBackend.mockReset();
+		resolveSessionBackend.mockResolvedValue({ kind: "backend" });
+		listSessionHistoryFromBackend.mockReset();
+		createCore.mockResolvedValue({
+			runtimeAddress: "127.0.0.1:25463",
+			featureFlags: {
+				poll: featureFlagsPoll,
+				dispose: featureFlagsDispose,
+			},
+			start: vi.fn(),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stop: vi.fn(),
+			dispose: vi.fn(),
+			get: vi.fn(),
+			list: vi.fn(),
+			delete: vi.fn(),
+			update: vi.fn(),
+			readMessages: vi.fn(),
+			readTranscript: vi.fn(),
+			ingestHookEvent: vi.fn(),
+			subscribe: vi.fn(),
+			updateSessionModel: vi.fn(),
+		});
+		delete process.env.CLINE_RPC_ADDRESS;
+		delete process.env.CLINE_SESSION_BACKEND_MODE;
+		delete process.env.CLINE_VCR;
+		featureFlagsPoll.mockClear();
+		featureFlagsDispose.mockClear();
+	});
+
+	afterEach(() => {
+		process.env.CLINE_RPC_ADDRESS = envSnapshot.CLINE_RPC_ADDRESS;
+		process.env.CLINE_SESSION_BACKEND_MODE =
+			envSnapshot.CLINE_SESSION_BACKEND_MODE;
+		process.env.CLINE_VCR = envSnapshot.CLINE_VCR;
+	});
+
+	it("passes hub client metadata through without forcing hub mode", async () => {
+		process.env.CLINE_RPC_ADDRESS = "127.0.0.1:5001";
+
+		await sessionModule.createCliCore();
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				hub: expect.objectContaining({
+					clientType: "cli",
+					displayName: "Cline CLI",
+				}),
+			}),
+		);
+	});
+
+	it("lets core choose the backend by default", async () => {
+		await sessionModule.createCliCore();
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				hub: expect.objectContaining({
+					clientType: "cli",
+					displayName: "Cline CLI",
+				}),
+			}),
+		);
+		expect(createCore).toHaveBeenCalledWith(
+			expect.not.objectContaining({
+				backendMode: expect.anything(),
+			}),
+		);
+		expect(featureFlagsPoll).toHaveBeenCalledTimes(1);
+	});
+
+	it("forces the local backend when requested by the caller", async () => {
+		await sessionModule.createCliCore({ forceLocalBackend: true });
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				backendMode: "local",
+			}),
+		);
+	});
+
+	it("passes an explicit hub backend through to core", async () => {
+		await sessionModule.createCliCore({ backendMode: "hub" });
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				backendMode: "hub",
+				hub: expect.objectContaining({
+					clientType: "cli",
+					displayName: "Cline CLI",
+				}),
+			}),
+		);
+	});
+
+	it("keeps forceLocalBackend as the strongest local override", async () => {
+		await sessionModule.createCliCore({
+			backendMode: "hub",
+			forceLocalBackend: true,
+		});
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				backendMode: "local",
+			}),
+		);
+		expect(createCore).toHaveBeenCalledWith(
+			expect.not.objectContaining({
+				hub: expect.anything(),
+			}),
+		);
+	});
+
+	it("keeps hub client metadata when runtime capabilities are provided", async () => {
+		const submit = vi.fn();
+		await sessionModule.createCliCore({
+			capabilities: {
+				toolExecutors: { submit },
+			},
+		});
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.objectContaining({
+				capabilities: expect.objectContaining({
+					toolExecutors: { submit },
+				}),
+				hub: expect.objectContaining({
+					clientType: "cli",
+					displayName: "Cline CLI",
+				}),
+			}),
+		);
+	});
+
+	it("passes env-managed routing through to core when local is requested via env", async () => {
+		process.env.CLINE_SESSION_BACKEND_MODE = "local";
+
+		await sessionModule.createCliCore();
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.not.objectContaining({
+				backendMode: expect.anything(),
+			}),
+		);
+	});
+
+	it("passes env-managed routing through to core when vcr is enabled", async () => {
+		process.env.CLINE_VCR = "1";
+
+		await sessionModule.createCliCore();
+
+		expect(createCore).toHaveBeenCalledWith(
+			expect.not.objectContaining({
+				backendMode: expect.anything(),
+			}),
+		);
+	});
+
+	it("logs the selected backend through the injected logger", async () => {
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+
+		await sessionModule.createCliCore({ logger });
+
+		expect(logger.log).toHaveBeenCalledWith(
+			"CLI core runtime routing selected",
+			{
+				backendMode: "env-managed",
+				rpcAddress: "127.0.0.1:25463",
+				forceLocalBackend: false,
+			},
+		);
+	});
+
+	it("lists sessions through core history with manifest fallback enabled", async () => {
+		listSessionHistoryFromBackend.mockResolvedValueOnce([
+			{
+				sessionId: "sess_1",
+				workspaceRoot: "/tmp/workspace",
+			},
+			{
+				sessionId: "sess_2",
+				workspaceRoot: "/tmp/other-workspace",
+			},
+		]);
+
+		const rows = await sessionModule.listSessions(25, {
+			workspaceRoot: "/tmp/workspace",
+		});
+
+		expect(resolveSessionBackend).toHaveBeenCalledWith({
+			telemetry: undefined,
+		});
+		expect(listSessionHistoryFromBackend).toHaveBeenCalledWith(
+			{ kind: "backend" },
+			{
+				limit: 25,
+				includeManifestFallback: true,
+				hydrate: false,
+				includeSubagents: false,
+			},
+		);
+		expect(createCore).not.toHaveBeenCalled();
+		expect(rows).toEqual([
+			{
+				sessionId: "sess_1",
+				workspaceRoot: "/tmp/workspace",
+			},
+			{
+				sessionId: "sess_2",
+				workspaceRoot: "/tmp/other-workspace",
+			},
+		]);
+	});
+
+	it("filters out empty and unreadable sessions", async () => {
+		listSessionHistoryFromBackend.mockResolvedValueOnce([
+			{ sessionId: "sess_full", workspaceRoot: "/tmp/workspace" },
+		]);
+
+		const rows = await sessionModule.listSessions(25, {
+			workspaceRoot: "/tmp/workspace",
+		});
+
+		expect(listSessionHistoryFromBackend).toHaveBeenCalledWith(
+			{ kind: "backend" },
+			{
+				limit: 25,
+				includeManifestFallback: true,
+				hydrate: false,
+				includeSubagents: false,
+			},
+		);
+		expect(rows).toEqual([
+			{ sessionId: "sess_full", workspaceRoot: "/tmp/workspace" },
+		]);
+	});
+});
diff --git a/apps/cli/src/session/session.ts b/apps/cli/src/session/session.ts
new file mode 100644
index 0000000..0056d74
--- /dev/null
+++ b/apps/cli/src/session/session.ts
@@ -0,0 +1,207 @@
+import type {
+	AgentConfig,
+	BasicLogger,
+	RuntimeCapabilities,
+	RuntimeHostMode,
+	SessionHistoryRecord,
+	SessionRecord,
+} from "@cline/core";
+import {
+	ClineCore,
+	listSessionHistoryFromBackend,
+	resolveSessionBackend,
+} from "@cline/core";
+import {
+	createCliMessagesArtifactUploader,
+	prepareCliEnterpriseIntegration,
+} from "../utils/enterprise";
+import { getCliFeatureFlagsService } from "../utils/feature-flags";
+import { resolveWorkspaceRoot } from "../utils/helpers";
+import { getCliTelemetryService } from "../utils/telemetry";
+import type { ConversationHistory } from "./export";
+
+function toSessionRecordLike(
+	row: SessionRecord | undefined,
+): unknown | undefined {
+	return row;
+}
+
+export async function createCliCore(options?: {
+	capabilities?: RuntimeCapabilities;
+	toolPolicies?: AgentConfig["toolPolicies"];
+	logger?: BasicLogger;
+	backendMode?: RuntimeHostMode;
+	forceLocalBackend?: boolean;
+	cwd?: string;
+	workspaceRoot?: string;
+}): Promise<ClineCore> {
+	const explicitBackendMode = options?.forceLocalBackend
+		? "local"
+		: options?.backendMode;
+	const cwd = options?.cwd?.trim() || process.cwd();
+	const workspaceRoot =
+		options?.workspaceRoot?.trim() || resolveWorkspaceRoot(cwd);
+	const telemetry = getCliTelemetryService(options?.logger);
+	const featureFlags = getCliFeatureFlagsService({
+		logger: options?.logger,
+		telemetry,
+	});
+	const core = await ClineCore.create({
+		...(explicitBackendMode ? { backendMode: explicitBackendMode } : {}),
+		...(options?.forceLocalBackend !== true
+			? {
+					hub: {
+						cwd,
+						workspaceRoot,
+						clientType: "cli",
+						displayName: "Cline CLI",
+					},
+				}
+			: {}),
+		capabilities: options?.capabilities,
+		telemetry,
+		featureFlags,
+		logger: options?.logger,
+		toolPolicies: options?.toolPolicies,
+		messagesArtifactUploader: createCliMessagesArtifactUploader(),
+		prepare: prepareCliEnterpriseIntegration,
+	});
+	try {
+		await core.featureFlags.poll();
+	} catch (error) {
+		options?.logger?.error?.("Error polling CLI feature flags", { error });
+	}
+	options?.logger?.log("CLI core runtime routing selected", {
+		backendMode: explicitBackendMode ?? "env-managed",
+		rpcAddress: core.runtimeAddress,
+		forceLocalBackend: options?.forceLocalBackend === true,
+	});
+	return core;
+}
+
+async function withCliCore<T>(
+	run: (core: ClineCore) => Promise<T>,
+	options?: {
+		forceLocalBackend?: boolean;
+		logger?: BasicLogger;
+		cwd?: string;
+		workspaceRoot?: string;
+	},
+): Promise<T> {
+	const core = await createCliCore({
+		forceLocalBackend: options?.forceLocalBackend,
+		logger: options?.logger,
+		cwd: options?.cwd,
+		workspaceRoot: options?.workspaceRoot,
+	});
+	try {
+		return await run(core);
+	} finally {
+		await core.dispose("cli_session_helper_dispose");
+	}
+}
+
+export async function listSessions(
+	limit = 50,
+	options?: { workspaceRoot?: string; hydrate?: boolean },
+): Promise<SessionHistoryRecord[]> {
+	const backend = await resolveSessionBackend({
+		telemetry: getCliTelemetryService(),
+	});
+	return await listSessionHistoryFromBackend(backend, {
+		limit,
+		includeManifestFallback: true,
+		hydrate: options?.hydrate ?? false,
+		includeSubagents: false,
+	});
+}
+
+export async function deleteSession(
+	sessionId: string,
+): Promise<{ deleted: boolean }> {
+	return await withCliCore(
+		async (core) => ({
+			deleted: await core.delete(sessionId),
+		}),
+		{ forceLocalBackend: true },
+	);
+}
+
+export async function updateSession(
+	sessionId: string,
+	updates: {
+		prompt?: string | null;
+		metadata?: Record<string, unknown> | null;
+		title?: string | null;
+	},
+): Promise<{ updated: boolean }> {
+	return await withCliCore(
+		async (core) => await core.update(sessionId, updates),
+		{ forceLocalBackend: true },
+	);
+}
+
+export async function getSessionRow(
+	sessionId: string,
+): Promise<SessionRecord | undefined> {
+	const target = sessionId.trim();
+	if (!target) {
+		return undefined;
+	}
+	return await withCliCore(
+		async (core) => (await core.get(target)) ?? undefined,
+		{ forceLocalBackend: true },
+	);
+}
+
+export async function getLatestSessionRow(): Promise<unknown | undefined> {
+	return await withCliCore(
+		async (core) => {
+			const rows = await core.list(1, { hydrate: false });
+			return toSessionRecordLike(rows[0]);
+		},
+		{ forceLocalBackend: true },
+	);
+}
+
+export async function handleSessionHookEvent(
+	payload: Parameters<ClineCore["ingestHookEvent"]>[0],
+): Promise<void> {
+	await withCliCore(
+		async (core) => {
+			await core.ingestHookEvent(payload);
+		},
+		{ forceLocalBackend: true },
+	);
+}
+
+export async function readSessionMessagesArtifact(
+	sessionId: string,
+): Promise<ConversationHistory | undefined> {
+	const target = sessionId.trim();
+	if (!target) {
+		return undefined;
+	}
+	return await withCliCore(
+		async (core) => {
+			const [row, messages] = await Promise.all([
+				core.get(target),
+				core.readMessages(target),
+			]);
+			if (!row || messages.length === 0) {
+				return undefined;
+			}
+			return {
+				version: 1,
+				updated_at: row.updatedAt,
+				messages: messages as ConversationHistory["messages"],
+				sessionId: row.sessionId,
+				systemPrompt:
+					typeof row.metadata?.systemPrompt === "string"
+						? row.metadata.systemPrompt
+						: undefined,
+			};
+		},
+		{ forceLocalBackend: true },
+	);
+}
diff --git a/apps/cli/src/tests/cli/auth.test.ts b/apps/cli/src/tests/cli/auth.test.ts
new file mode 100644
index 0000000..e91f9ab
--- /dev/null
+++ b/apps/cli/src/tests/cli/auth.test.ts
@@ -0,0 +1,304 @@
+// ---------------------------------------------------------------------------
+// cline auth - CLI flag and contract tests
+//
+// These tests cover the `cline auth` subcommand behavior:
+//   - Interactive auth screen navigation
+//   - `cline auth -p <provider> -k <apiKey> -m <modelId>` golden path
+//   - Invalid provider / key / model error handling
+//   - Partial-flag error handling (exit with failure)
+//   - `cline auth --help`
+// ---------------------------------------------------------------------------
+
+import { test } from "@microsoft/tui-test";
+import {
+	CLINE_BIN,
+	EXIT_CODE_FAIL,
+	EXIT_CODE_SUCCESS,
+	TERMINAL_WIDE,
+} from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { waitForAuthScreen } from "../helpers/page-objects/auth.js";
+import { expectExitCode, expectVisible } from "../helpers/terminal.js";
+
+test.describe("cline auth (interactive screen)", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["auth"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("shows all auth options", async ({ terminal }) => {
+		await waitForAuthScreen(terminal);
+	});
+
+	test("can navigate options with keyUp / keyDown", async ({ terminal }) => {
+		await waitForAuthScreen(terminal);
+		terminal.keyDown();
+		terminal.keyUp();
+		await expectVisible(terminal, "Sign in with Cline");
+	});
+});
+
+test.describe("cline auth --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["auth", "--help"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("shows auth help page", async ({ terminal }) => {
+		await expectVisible(terminal, [
+			"Usage:",
+			"--provider",
+			"--apikey",
+			"--modelid",
+			"--baseurl",
+		]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline auth with only partial flags -> exits with error
+// ---------------------------------------------------------------------------
+test.describe("cline auth --provider only (partial flags)", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["auth", "--provider", "openai"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("exits with failure", async ({ terminal }) => {
+		await expectVisible(terminal, "error");
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+test.describe("cline auth --apikey only (partial flags)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["auth", "--apikey", "sk-test-key"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("exits with error requiring --provider", async ({ terminal }) => {
+		await expectVisible(terminal, "provider");
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+test.describe("cline auth --modelid only (partial flags)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["auth", "--modelid", "gpt-4o"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("exits with error requiring --provider", async ({ terminal }) => {
+		await expectVisible(terminal, "provider");
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+test.describe("cline auth --baseurl only (partial flags)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["auth", "--baseurl", "https://api.example.com"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("exits with error requiring --provider", async ({ terminal }) => {
+		await expectVisible(terminal, "provider");
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+test.describe("cline auth --verbose only", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["auth", "--verbose"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("accepts --verbose and shows interactive auth screen", async ({
+		terminal,
+	}) => {
+		await waitForAuthScreen(terminal);
+	});
+});
+
+test.describe("cline auth --cwd", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["auth", "--cwd", "/tmp"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("accepts --cwd and shows interactive auth screen", async ({
+		terminal,
+	}) => {
+		await waitForAuthScreen(terminal);
+	});
+});
+
+test.describe("cline auth --config", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["auth", "--config", "configs/unauthenticated"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("accepts --config and shows interactive auth screen", async ({
+		terminal,
+	}) => {
+		await waitForAuthScreen(terminal);
+	});
+});
+
+test.describe("cline auth -p -k -m (golden path)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: [
+				"auth",
+				"--provider",
+				"openai",
+				"--apikey",
+				"sk-test-key-12345",
+				"--modelid",
+				"gpt-4o",
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("exits successfully with valid provider, key, and model", async ({
+		terminal,
+	}) => {
+		// Golden path: should not show interactive auth screen, should exit cleanly
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+test.describe("cline auth with invalid key (still exits 0)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: [
+				"auth",
+				"--provider",
+				"openai",
+				"--apikey",
+				"invalid-key",
+				"--modelid",
+				"gpt-4o",
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("accepts invalid key without error at auth time", async ({
+		terminal,
+	}) => {
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+test.describe("cline auth -p -k -m -b (golden path with baseUrl)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: [
+				"auth",
+				"--provider",
+				"openai-compatible",
+				"--apikey",
+				"sk-test-key-12345",
+				"--modelid",
+				"gpt-4o",
+				"--baseurl",
+				"https://api.example.com/v1",
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("exits successfully with baseUrl for OpenAI Compatible provider", async ({
+		terminal,
+	}) => {
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+test.describe("cline auth --baseurl with non-OpenAI-compatible provider", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: [
+				"auth",
+				"--provider",
+				"anthropic",
+				"--apikey",
+				"sk-ant-test",
+				"--modelid",
+				"claude-sonnet-4-20250514",
+				"--baseurl",
+				"https://api.example.com",
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("shows error for baseUrl with non-OpenAI provider", async ({
+		terminal,
+	}) => {
+		await expectVisible(
+			terminal,
+			/only supported for openai|not supported|openai.compatible/i,
+		);
+	});
+});
+
+test.describe("cline auth with invalid provider", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: [
+				"auth",
+				"--provider",
+				"not-a-real-provider",
+				"--apikey",
+				"sk-test",
+				"--modelid",
+				"gpt-4o",
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("shows invalid provider error", async ({ terminal }) => {
+		await expectVisible(terminal, /invalid provider/i);
+	});
+});
diff --git a/apps/cli/src/tests/cli/config.test.ts b/apps/cli/src/tests/cli/config.test.ts
new file mode 100644
index 0000000..8837375
--- /dev/null
+++ b/apps/cli/src/tests/cli/config.test.ts
@@ -0,0 +1,24 @@
+// ---------------------------------------------------------------------------
+// cline config - CLI tests
+//
+// Covers:
+//   - `cline config --config <dir>` - shows config for specific directory
+//   - `cline config --help`         - help page
+// ---------------------------------------------------------------------------
+
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN, TERMINAL_WIDE } from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { expectVisible } from "../helpers/terminal.js";
+
+test.describe("cline config --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["config", "--help"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("shows config help page", async ({ terminal }) => {
+		await expectVisible(terminal, ["Usage:", "--config"]);
+	});
+});
diff --git a/apps/cli/src/tests/cli/flags-behavior.test.ts b/apps/cli/src/tests/cli/flags-behavior.test.ts
new file mode 100644
index 0000000..3be200a
--- /dev/null
+++ b/apps/cli/src/tests/cli/flags-behavior.test.ts
@@ -0,0 +1,95 @@
+// ---------------------------------------------------------------------------
+// CLI flag behavioral tests
+//
+// These tests verify the runtime behavior of each CLI flag, not just that
+// the flag appears in --help output (that's covered in tests/flags.test.ts),
+// but that the flag actually changes what cline does.
+//
+// Tests marked in the spec reflect known gaps where the flag is accepted
+// but currently has no observable effect. They are still written so the
+// behavior can be asserted once the implementation catches up.
+// ---------------------------------------------------------------------------
+
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN, TERMINAL_WIDE } from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { waitForChatReady } from "../helpers/page-objects/chat.js";
+import { expectVisible } from "../helpers/terminal.js";
+
+test.describe("cline --model (interactive mode, flag ignored)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["--model", "openai/gpt-5.3-codex"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("starts interactive mode", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		await expectVisible(terminal, "GPT-5.3 Codex");
+	});
+});
+
+test.describe("cline --cwd <dir>", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--cwd", "/tmp"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("starts interactive mode with --cwd flag", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		await expectVisible(terminal, "tmp");
+	});
+});
+
+test.describe("cline -c <dir> (short alias)", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["-c", "/tmp"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("starts interactive mode with -c flag", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		await expectVisible(terminal, "tmp");
+	});
+});
+
+test.describe("cline --config (claude-sonnet-4.6)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["--config", "configs/claude-sonnet-4.6"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("claude-sonnet-4.6"),
+	});
+
+	test("starts interactive mode with custom config directory", async ({
+		terminal,
+	}) => {
+		await expectVisible(terminal, "Claude Sonnet 4.6");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline --json --yolo "prompt"
+// Starts cline in headless yolo mode with all output conforming to JSON
+// ---------------------------------------------------------------------------
+test.describe("cline --json (headless yolo mode)", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--json", "--yolo", "tell me a joke"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("starts in headless yolo mode with JSON output", async ({
+		terminal,
+	}) => {
+		// Explicit yolo with --json should produce a JSON error line.
+		await expectVisible(terminal, /Unauthorized|Missing API key/i);
+	});
+});
diff --git a/apps/cli/src/tests/cli/history.test.ts b/apps/cli/src/tests/cli/history.test.ts
new file mode 100644
index 0000000..ca32176
--- /dev/null
+++ b/apps/cli/src/tests/cli/history.test.ts
@@ -0,0 +1,85 @@
+// ---------------------------------------------------------------------------
+// cline history - CLI tests
+//
+// Covers:
+//   - `cline history --limit X`  - pagination limit
+//   - `cline history --page N`   - page selection
+//   - `cline history --config`   - custom config directory
+//   - `cline history --help`     - help page
+// ---------------------------------------------------------------------------
+
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN, TERMINAL_WIDE } from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { expectVisible } from "../helpers/terminal.js";
+
+test.describe("cline history --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["history", "--help"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("shows history help page with all flags", async ({ terminal }) => {
+		await expectVisible(terminal, ["Usage:", "--limit", "--page", "--config"]);
+	});
+});
+
+test.describe("cline history --limit", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["history", "--limit", "1"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("shows history limited to specified number of results", async ({
+		terminal,
+	}) => {
+		// The default config has 2 tasks in taskHistory.json; with limit=1
+		// we should see pagination or only 1 task entry per page
+		await expectVisible(terminal, /history|task/i);
+	});
+});
+
+test.describe("cline history --page", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["history", "--page", "1"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("shows history for the specified page", async ({ terminal }) => {
+		await expectVisible(terminal, /history|task/i);
+	});
+});
+
+test.describe("cline history --config (default)", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["history"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("shows history for default config", async ({ terminal }) => {
+		// Default config has tasks with "wezterm" in them
+		await expectVisible(terminal, /history|task|wezterm/i);
+	});
+});
+
+test.describe("cline history --config (claude-sonnet-4.6)", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["history", "--config", "configs/claude-sonnet-4.6"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("claude-sonnet-4.6"),
+	});
+
+	test("shows different history for different config directory", async ({
+		terminal,
+	}) => {
+		// The claude-sonnet-4.6 config has its own separate task history
+		await expectVisible(terminal, /history|task/i);
+	});
+});
diff --git a/apps/cli/src/tests/configs/README.md b/apps/cli/src/tests/configs/README.md
new file mode 100644
index 0000000..90076c2
--- /dev/null
+++ b/apps/cli/src/tests/configs/README.md
@@ -0,0 +1,22 @@
+# Test Fixture Configs
+
+Each subdirectory here is a **Cline config directory** used by one or more test suites.
+Tests point to a config via `clineEnv("<name>")` in `tests/e2e/cli/helpers/env.ts`.
+
+## Available fixtures
+
+| Directory | Purpose |
+|-----------|---------|
+| `default/` | Minimal config used for local/non-live CLI TUI tests. |
+| `unauthenticated/` | Explicitly empty config (no provider or API keys). |
+
+## Adding a new fixture
+
+1. Create `configs/<name>/data/globalState.json` with the desired state.
+2. Create `configs/<name>/data/settings/cline_mcp_settings.json` (can be `{ "mcpServers": {} }`).
+3. Reference it in tests with `clineEnv("<name>")`.
+
+## Secrets
+
+API keys and secrets should never be committed.
+If you create authenticated fixtures locally, keep `data/secrets.json` untracked or fill it with mock data
diff --git a/apps/cli/src/tests/configs/claude-sonnet-4.6/data/cache/remote_config_org-01JZPE4CHW5XTP73W95762121Y.json b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/cache/remote_config_org-01JZPE4CHW5XTP73W95762121Y.json
new file mode 100644
index 0000000..8c94946
--- /dev/null
+++ b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/cache/remote_config_org-01JZPE4CHW5XTP73W95762121Y.json
@@ -0,0 +1,21 @@
+{
+	"version": "v1",
+	"providerSettings": {},
+	"telemetryEnabled": true,
+	"mcpMarketplaceEnabled": true,
+	"yoloModeAllowed": true,
+	"openTelemetryEnabled": false,
+	"openTelemetryOtlpInsecure": false,
+	"enterpriseTelemetry": {
+		"promptUploading": {
+			"enabled": true,
+			"type": "s3_access_keys",
+			"s3AccessSettings": {
+				"bucket": "cline-tasks",
+				"accessKeyId": "fake",
+				"secretAccessKey": "fake",
+				"region": "us-west-2"
+			}
+		}
+	}
+}
diff --git a/apps/cli/src/tests/configs/claude-sonnet-4.6/data/globalState.json b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/globalState.json
new file mode 100644
index 0000000..387d055
--- /dev/null
+++ b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/globalState.json
@@ -0,0 +1,44 @@
+{
+	"remoteRulesToggles": {},
+	"remoteWorkflowToggles": {},
+	"welcomeViewCompleted": true,
+	"actModeOpenRouterModelInfo": {
+		"name": "Anthropic: Claude Sonnet 4.6",
+		"maxTokens": 128000,
+		"contextWindow": 200000,
+		"supportsImages": true,
+		"supportsPromptCache": true,
+		"inputPrice": 3,
+		"outputPrice": 15,
+		"cacheWritesPrice": 3.75,
+		"cacheReadsPrice": 0.3,
+		"description": "Sonnet 4.6 is Anthropic's most capable Sonnet-class model yet, with frontier performance across coding, agents, and professional work. It excels at iterative development, complex codebase navigation, end-to-end project management with memory, polished document creation, and confident computer use for web QA and workflow automation.",
+		"thinkingConfig": {
+			"maxBudget": 6000
+		}
+	},
+	"planModeOpenRouterModelInfo": {
+		"name": "Anthropic: Claude Sonnet 4.6",
+		"maxTokens": 128000,
+		"contextWindow": 200000,
+		"supportsImages": true,
+		"supportsPromptCache": true,
+		"inputPrice": 3,
+		"outputPrice": 15,
+		"cacheWritesPrice": 3.75,
+		"cacheReadsPrice": 0.3,
+		"description": "Sonnet 4.6 is Anthropic's most capable Sonnet-class model yet, with frontier performance across coding, agents, and professional work. It excels at iterative development, complex codebase navigation, end-to-end project management with memory, polished document creation, and confident computer use for web QA and workflow automation.",
+		"thinkingConfig": {
+			"maxBudget": 6000
+		}
+	},
+	"actModeApiProvider": "cline",
+	"planModeApiProvider": "cline",
+	"actModeClineModelId": "anthropic/claude-sonnet-4.6",
+	"planModeClineModelId": "anthropic/claude-sonnet-4.6",
+	"openAiHeaders": {},
+	"sapAiCoreUseOrchestrationMode": true,
+	"ocaMode": "internal",
+	"globalClineRulesToggles": {},
+	"globalWorkflowToggles": {}
+}
diff --git a/apps/cli/src/tests/configs/claude-sonnet-4.6/data/settings/cline_mcp_settings.json b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/settings/cline_mcp_settings.json
new file mode 100644
index 0000000..47925bf
--- /dev/null
+++ b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/settings/cline_mcp_settings.json
@@ -0,0 +1,3 @@
+{
+	"mcpServers": {}
+}
diff --git a/apps/cli/src/tests/configs/claude-sonnet-4.6/data/settings/providers.json b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/settings/providers.json
new file mode 100644
index 0000000..91ed788
--- /dev/null
+++ b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/settings/providers.json
@@ -0,0 +1,20 @@
+{
+	"version": 1,
+	"lastUsedProvider": "cline",
+	"providers": {
+		"cline": {
+			"settings": {
+				"provider": "cline",
+				"auth": {
+					"accessToken": "workos:eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJ0ZXN0SWQiLCJleHRlcm5hbF9pZCI6InRlc3RJZCIsImVtYWlsIjoidGVzdEBjbGluZS5ib3QiLCJuYW1lIjoiVGVzdCBVc2VyIiwiZXhwIjoxODk5NTc4OTI0LCJpYXQiOjE3NzMzNDQzODQsInNpZCI6InRlc3Qtc2Vzc2lvbi1pZCJ9.",
+					"refreshToken": "testRefreshToken",
+					"expiresAt": 1899578924000,
+					"accountId": "testId"
+				},
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"updatedAt": "2026-03-24T21:55:22.629Z",
+			"tokenSource": "oauth"
+		}
+	}
+}
diff --git a/apps/cli/src/tests/configs/claude-sonnet-4.6/data/workspaces/43962aa4/workspaceState.json b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/workspaces/43962aa4/workspaceState.json
new file mode 100644
index 0000000..aad78a0
--- /dev/null
+++ b/apps/cli/src/tests/configs/claude-sonnet-4.6/data/workspaces/43962aa4/workspaceState.json
@@ -0,0 +1,7 @@
+{
+	"localClineRulesToggles": {},
+	"localWindsurfRulesToggles": {},
+	"localCursorRulesToggles": {},
+	"localAgentsRulesToggles": {},
+	"workflowToggles": {}
+}
diff --git a/apps/cli/src/tests/configs/default/data/globalState.json b/apps/cli/src/tests/configs/default/data/globalState.json
new file mode 100644
index 0000000..bfd172b
--- /dev/null
+++ b/apps/cli/src/tests/configs/default/data/globalState.json
@@ -0,0 +1,63 @@
+{
+	"remoteRulesToggles": {},
+	"remoteWorkflowToggles": {},
+	"actModeOpenRouterModelInfo": {
+		"name": "Anthropic: Claude Sonnet 4.6",
+		"maxTokens": 128000,
+		"contextWindow": 200000,
+		"supportsImages": true,
+		"supportsPromptCache": true,
+		"inputPrice": 3,
+		"outputPrice": 15,
+		"cacheWritesPrice": 3.75,
+		"cacheReadsPrice": 0.3,
+		"description": "Sonnet 4.6 is Anthropic's most capable Sonnet-class model yet, with frontier performance across coding, agents, and professional work. It excels at iterative development, complex codebase navigation, end-to-end project management with memory, polished document creation, and confident computer use for web QA and workflow automation.",
+		"thinkingConfig": {
+			"maxBudget": 6000
+		}
+	},
+	"planModeOpenRouterModelInfo": {
+		"name": "Anthropic: Claude Sonnet 4.6",
+		"maxTokens": 128000,
+		"contextWindow": 200000,
+		"supportsImages": true,
+		"supportsPromptCache": true,
+		"inputPrice": 3,
+		"outputPrice": 15,
+		"cacheWritesPrice": 3.75,
+		"cacheReadsPrice": 0.3,
+		"description": "Sonnet 4.6 is Anthropic's most capable Sonnet-class model yet, with frontier performance across coding, agents, and professional work. It excels at iterative development, complex codebase navigation, end-to-end project management with memory, polished document creation, and confident computer use for web QA and workflow automation.",
+		"thinkingConfig": {
+			"maxBudget": 6000
+		}
+	},
+	"actModeApiProvider": "cline",
+	"planModeApiProvider": "cline",
+	"actModeClineModelId": "anthropic/claude-sonnet-4.6",
+	"planModeClineModelId": "anthropic/claude-sonnet-4.6",
+	"welcomeViewCompleted": true,
+	"actModeThinkingBudgetTokens": 0,
+	"planModeThinkingBudgetTokens": 0,
+	"autoApprovalSettings": {
+		"version": 19,
+		"enabled": true,
+		"favorites": [],
+		"maxRequests": 20,
+		"actions": {
+			"readFiles": true,
+			"readFilesExternally": false,
+			"editFiles": false,
+			"editFilesExternally": false,
+			"executeSafeCommands": true,
+			"executeAllCommands": false,
+			"useBrowser": false,
+			"useMcp": true
+		},
+		"enableNotifications": false
+	},
+	"primaryRootIndex": 0,
+	"globalWorkflowToggles": {},
+	"globalClineRulesToggles": {},
+	"isNewUser": false,
+	"subagentsEnabled": true
+}
diff --git a/apps/cli/src/tests/configs/default/data/settings/cline_mcp_settings.json b/apps/cli/src/tests/configs/default/data/settings/cline_mcp_settings.json
new file mode 100644
index 0000000..47925bf
--- /dev/null
+++ b/apps/cli/src/tests/configs/default/data/settings/cline_mcp_settings.json
@@ -0,0 +1,3 @@
+{
+	"mcpServers": {}
+}
diff --git a/apps/cli/src/tests/configs/default/data/settings/providers.json b/apps/cli/src/tests/configs/default/data/settings/providers.json
new file mode 100644
index 0000000..c0746ee
--- /dev/null
+++ b/apps/cli/src/tests/configs/default/data/settings/providers.json
@@ -0,0 +1,20 @@
+{
+	"version": 1,
+	"lastUsedProvider": "cline",
+	"providers": {
+		"cline": {
+			"settings": {
+				"provider": "cline",
+				"auth": {
+					"accessToken": "workos:eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJ0ZXN0SWQiLCJleHRlcm5hbF9pZCI6InRlc3RJZCIsImVtYWlsIjoidGVzdEBjbGluZS5ib3QiLCJuYW1lIjoiVGVzdCBVc2VyIiwiZXhwIjoxODk5NTc4OTI0LCJpYXQiOjE3NzMzNDQzODQsInNpZCI6InRlc3Qtc2Vzc2lvbi1pZCJ9.",
+					"refreshToken": "testRefreshToken",
+					"expiresAt": 1899578924000,
+					"accountId": "testId"
+				},
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"updatedAt": "2026-01-01T00:00:00.000Z",
+			"tokenSource": "oauth"
+		}
+	}
+}
diff --git a/apps/cli/src/tests/configs/unauthenticated/data/globalState.json b/apps/cli/src/tests/configs/unauthenticated/data/globalState.json
new file mode 100644
index 0000000..9a7f30f
--- /dev/null
+++ b/apps/cli/src/tests/configs/unauthenticated/data/globalState.json
@@ -0,0 +1,38 @@
+{
+	"apiProvider": null,
+	"apiKey": null,
+	"openRouterApiKey": null,
+	"awsAccessKey": null,
+	"awsSecretKey": null,
+	"awsSessionToken": null,
+	"awsRegion": null,
+	"vertexProjectId": null,
+	"vertexRegion": null,
+	"openAiBaseUrl": null,
+	"openAiApiKey": null,
+	"openAiModelId": null,
+	"ollamaModelId": null,
+	"ollamaBaseUrl": null,
+	"lmStudioModelId": null,
+	"lmStudioBaseUrl": null,
+	"anthropicBaseUrl": null,
+	"geminiApiKey": null,
+	"openAiNativeApiKey": null,
+	"deepSeekApiKey": null,
+	"mistralApiKey": null,
+	"unboundApiKey": null,
+	"requestyApiKey": null,
+	"togetherApiKey": null,
+	"qwenApiKey": null,
+	"doubaoApiKey": null,
+	"liteLlmBaseUrl": null,
+	"liteLlmApiKey": null,
+	"liteLlmModelId": null,
+	"clineApiKey": null,
+	"taskHistory": [],
+	"remoteRulesToggles": {},
+	"remoteWorkflowToggles": {},
+	"actModeThinkingBudgetTokens": 0,
+	"planModeThinkingBudgetTokens": 0,
+	"welcomeViewCompleted": false
+}
diff --git a/apps/cli/src/tests/configs/unauthenticated/data/settings/cline_mcp_settings.json b/apps/cli/src/tests/configs/unauthenticated/data/settings/cline_mcp_settings.json
new file mode 100644
index 0000000..47925bf
--- /dev/null
+++ b/apps/cli/src/tests/configs/unauthenticated/data/settings/cline_mcp_settings.json
@@ -0,0 +1,3 @@
+{
+	"mcpServers": {}
+}
diff --git a/apps/cli/src/tests/fixtures/file-edit-auto-approve.json b/apps/cli/src/tests/fixtures/file-edit-auto-approve.json
new file mode 100644
index 0000000..2ca89ca
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/file-edit-auto-approve.json
@@ -0,0 +1,271 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683227116,
+			"defaultIdentifiedOnly": true,
+			"surveys": false,
+			"supportedCompression": ["gzip", "gzip-js"],
+			"heatmaps": true,
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"siteApps": [],
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"autocaptureExceptions": true,
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"captureDeadClicks": false,
+			"conversations": false,
+			"elementsChainAsString": true,
+			"productTours": false,
+			"token": "REDACTED",
+			"autocapture_opt_out": false,
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"hasFeatureFlags": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_012rx1Tr2Ex4qMFyTSpBmacY\",\"type\":\"function\",\"function\":{\"name\":\"execute_command\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"comma\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nd\\\":\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" \\\"echo \\\\\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sup\\\\\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\" \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\">> /tmp/t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"estFile.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"txt\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"requ\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ires_app\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rova\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"l\\\": false}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_96pv5lrsit\"}\n\ndata: {\"id\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"object\":\"chat.completion.chunk\",\"created\":1773683235,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":3020,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":3020,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":84,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":3020,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":609623.168401,\"endTime\":612713.434498,\"providerRequestId\":\"req_011CZ7BJ3odqJBycmfFdTmA9\",\"statusCode\":200,\"providerResponseId\":\"msg_01V1EevZ6UU23WKox8PPGUPz\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":609623.168401,\"endTime\":612713.434498,\"providerRequestId\":\"req_011CZ7BJ3odqJBycmfFdTmA9\",\"statusCode\":200,\"providerResponseId\":\"msg_01V1EevZ6UU23WKox8PPGUPz\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0147894\",\"generationId\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10341,\"completion_tokens\":84,\"total_tokens\":10425,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0147894,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":3020,\"market_cost\":0.0147894},\"system_fingerprint\":\"fp_96pv5lrsit\",\"generationId\":\"gen_01KKVW4M2D9T1KKZVEP552J41Z\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\\"\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"sup\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\\" has\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" been app\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ended to `/\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"tmp/testFile.txt`.\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_013DHrJtV9CVXqP7AKJbx71V\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"result\\\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"Appended \\\\\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sup\\\\\\\" \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"to `/tmp/\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"tes\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"tFil\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e.t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"xt\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"` using\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" `echo \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\\\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sup\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\\\\\" >>\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" /tmp/\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"te\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"st\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"File.txt`\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\".\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"ta\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sk_\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"progr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"es\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s\\\": \\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"- [\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"x] Append\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" \\\\\\\"sup\\\\\\\" \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"to /tmp/tes\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"tFile.txt\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_hhlpl62tzb\"}\n\ndata: {\"id\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"object\":\"chat.completion.chunk\",\"created\":1773683237,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":424,\"cache_read_input_tokens\":10338,\"cache_creation\":{\"ephemeral_5m_input_tokens\":424,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":134,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":424,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":696667.898627,\"endTime\":699405.576099,\"providerRequestId\":\"req_011CZ7BJLUEzzqkMDsxwXjhZ\",\"statusCode\":200,\"providerResponseId\":\"msg_019RahPny3sXDeqXxpeDdFmA\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":696667.898627,\"endTime\":699405.576099,\"providerRequestId\":\"req_011CZ7BJLUEzzqkMDsxwXjhZ\",\"statusCode\":200,\"providerResponseId\":\"msg_019RahPny3sXDeqXxpeDdFmA\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0067104\",\"generationId\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10765,\"completion_tokens\":134,\"total_tokens\":10899,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":10338,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0067104,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":424,\"market_cost\":0.0067104},\"system_fingerprint\":\"fp_hhlpl62tzb\",\"generationId\":\"gen_01KKVW4QWH8RXB23SH110MKKEQ\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-json-timeout.json b/apps/cli/src/tests/fixtures/headless-json-timeout.json
new file mode 100644
index 0000000..d9ecf3f
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-json-timeout.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Absolutely\",\"phase\":\"final_answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" here\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" long\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" detailed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" joke\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" you\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" walks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" into\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" store\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" like\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" buy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" very\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" unusual\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Something\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sophisticated\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Something\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" intellectual\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" store\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" owner\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" strokes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" his\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" chin\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Well\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" *\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"do\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"*\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" have\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" talking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cent\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ip\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ede\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" laughs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" talking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cent\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ip\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ede\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Seriously\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Not\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" just\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" talking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" owner\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Pol\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ite\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Educ\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ated\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Im\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"pe\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"cc\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"able\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manners\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Former\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" owned\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" by\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" literature\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" professor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Natur\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ally\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" buys\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" takes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cent\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ip\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ede\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" home\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tiny\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" little\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" custom\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" habitat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" complete\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" miniature\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" velvet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" curtain\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" little\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" gold\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" label\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" *\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Sir\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" W\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"igg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"lington\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" III\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"*\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"That\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" evening\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" he\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" decides\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" test\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cent\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ip\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ede\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" social\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" skills\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" taps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" habitat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hey\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" want\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" go\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pub\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" me\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" grab\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" drink\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"From\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" inside\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" refined\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" little\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" voice\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" replies\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" be\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" delighted\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" old\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" chap\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Do\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" give\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" me\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" five\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" put\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" my\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bl\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Your\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“Yes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" have\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" standards\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shr\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ugs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" gets\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" his\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" coat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" checks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" his\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" phone\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" waits\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" five\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Nothing\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ten\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Still\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" nothing\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" knocks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" again\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" You\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" coming\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Inside\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Absolutely\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Just\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" putting\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" my\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Now\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" confused\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" but\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" okay\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" waits\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" another\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ten\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Still\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" no\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cent\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ip\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ede\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" opens\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" habitat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" nowhere\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sight\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Where\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" you\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Tiny\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" voice\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" from\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" behind\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" decorative\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" peb\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ble\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Here\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" On\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoe\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"37\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Thirty\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-seven\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“Yes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sigh\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"L\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ace\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-up\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" boots\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" were\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" poor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" life\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" choice\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Eventually\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" after\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" twenty\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-five\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" additional\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tiny\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoe\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"horn\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" emerges\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" looking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" quite\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" proud\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"100\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" perfectly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" polished\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" micro\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-sh\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"oes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" head\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pub\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"At\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" door\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" b\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ouncer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" squ\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ints\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" down\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"No\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bugs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" allowed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" protests\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" not\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" just\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bug\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" he\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" gentleman\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tips\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" microscopic\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" hat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Good\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" evening\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Spl\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"endid\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" weather\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" fermentation\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" b\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ouncer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" st\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ares\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shr\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ugs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Fine\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" But\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" no\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" trouble\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sit\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" down\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" order\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" drinks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pint\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bottle\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cap\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pale\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ale\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"),\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" things\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" go\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" great\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tells\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stories\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" about\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Victorian\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" poets\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" debates\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" philosophy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dart\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" player\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" somehow\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" wins\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" £\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"14\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" at\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" trivia\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" by\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" correctly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" identifying\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Bach\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ata\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" from\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" three\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" notes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" humm\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" by\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" man\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" named\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Steve\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"By\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" midnight\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" thrilled\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Best\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" purchase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ever\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" next\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" evening\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" he\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" decides\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" do\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" again\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" calls\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" out\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pub\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"From\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" inside\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Del\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ighted\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Five\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" put\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" my\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" smiles\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Sure\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Five\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pass\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ten\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"F\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"if\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"teen\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Twenty\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-five\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" knocks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" slightly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" annoyed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" what\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" taking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" so\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" long\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Voice\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" from\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" inside\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" very\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" irritated\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"For\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" heaven\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sake\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" heard\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" you\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" first\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" time\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’m\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" putting\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" my\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" guy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pauses\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" he\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"But\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" been\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" half\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" an\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" hour\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Reg\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"inal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" snaps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" back\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Do\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" you\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" have\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" *\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"any\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" idea\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"*\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" how\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" long\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" takes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" put\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" when\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" you\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" have\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" hundred\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" feet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" only\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ninety\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-eight\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shoes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" because\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stole\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" two\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"And\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" from\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" kitchen\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" comes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" muff\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"led\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" me\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ow\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" followed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" by\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tiny\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" scream\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"TH\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"AT\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’S\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" MY\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" LEFT\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"62\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tg2buu8d5q\"}\n\ndata: {\"id\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"object\":\"chat.completion.chunk\",\"created\":1774387735,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"openai\":{\"responseId\":\"resp_0f71d1386ae09cfe0169c30217167481909907fa49247c0b7e\",\"serviceTier\":\"default\"},\"gateway\":{\"routing\":{\"originalModelId\":\"openai/gpt-5.3-codex\",\"resolvedProvider\":\"openai\",\"resolvedProviderApiModelId\":\"gpt-5.3-codex\",\"internalResolvedModelId\":\"openai:gpt-5.3-codex\",\"fallbacksAvailable\":[\"azure\"],\"internalReasoning\":\"Selected openai as preferred provider for gpt-5.3-codex. 1 fallback(s) available: azure\",\"planningReasoning\":\"BYOK credentials available for: openai. System credentials planned for: openai, azure. Total execution order: openai(BYOK) → openai(system) → azure(system)\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"finalProvider\":\"openai\",\"attempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":456993.62541,\"endTime\":457081.66925,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":457100.18895,\"endTime\":478759.067585,\"providerRequestId\":\"req_258734bfa3184cbcab57f876ae085618\",\"statusCode\":200,\"providerResponseId\":\"resp_0f71d1386ae09cfe0169c30217167481909907fa49247c0b7e\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"openai:gpt-5.3-codex\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"success\":true,\"providerAttemptCount\":2,\"providerAttempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":456993.62541,\"endTime\":457081.66925,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":457100.18895,\"endTime\":478759.067585,\"providerRequestId\":\"req_258734bfa3184cbcab57f876ae085618\",\"statusCode\":200,\"providerResponseId\":\"resp_0f71d1386ae09cfe0169c30217167481909907fa49247c0b7e\"}]}],\"totalProviderAttemptCount\":2},\"cost\":\"0.01143135\",\"marketCost\":\"0.01143135\",\"generationId\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3793,\"completion_tokens\":760,\"total_tokens\":4553,\"cost\":0.01143135,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":3712,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":null,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.01143135},\"system_fingerprint\":\"fp_tg2buu8d5q\",\"service_tier\":\"default\",\"generationId\":\"gen_01KMGW0A9VF2EZ5THA22ZD40S7\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-json.json b/apps/cli/src/tests/fixtures/headless-json.json
new file mode 100644
index 0000000..375d07c
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-json.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Why\",\"phase\":\"final_answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" don\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’t\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" programmers\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" like\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" nature\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" has\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" too\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" many\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bugs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_pvkdt287gc\"}\n\ndata: {\"id\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"openai\":{\"responseId\":\"resp_09cec00eb461cfc60169c302143c2481949bd977733fd57f07\",\"serviceTier\":\"default\"},\"gateway\":{\"routing\":{\"originalModelId\":\"openai/gpt-5.3-codex\",\"resolvedProvider\":\"openai\",\"resolvedProviderApiModelId\":\"gpt-5.3-codex\",\"internalResolvedModelId\":\"openai:gpt-5.3-codex\",\"fallbacksAvailable\":[\"azure\"],\"internalReasoning\":\"Selected openai as preferred provider for gpt-5.3-codex. 1 fallback(s) available: azure\",\"planningReasoning\":\"BYOK credentials available for: openai. System credentials planned for: openai, azure. Total execution order: openai(BYOK) → openai(system) → azure(system)\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"finalProvider\":\"openai\",\"attempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":96622.437586,\"endTime\":96667.954784,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":96686.304495,\"endTime\":98783.83781,\"providerRequestId\":\"req_f51c50e7d7ff402c8c85b96f49e856a6\",\"statusCode\":200,\"providerResponseId\":\"resp_09cec00eb461cfc60169c302143c2481949bd977733fd57f07\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"openai:gpt-5.3-codex\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"success\":true,\"providerAttemptCount\":2,\"providerAttempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":96622.437586,\"endTime\":96667.954784,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":96686.304495,\"endTime\":98783.83781,\"providerRequestId\":\"req_f51c50e7d7ff402c8c85b96f49e856a6\",\"statusCode\":200,\"providerResponseId\":\"resp_09cec00eb461cfc60169c302143c2481949bd977733fd57f07\"}]}],\"totalProviderAttemptCount\":2},\"cost\":\"0.00102585\",\"marketCost\":\"0.00102585\",\"generationId\":\"gen_01KMGW07JDNZY661F63ACD3NEF\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3791,\"completion_tokens\":17,\"total_tokens\":3808,\"cost\":0.00102585,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":3712,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":null,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.00102585},\"system_fingerprint\":\"fp_pvkdt287gc\",\"service_tier\":\"default\",\"generationId\":\"gen_01KMGW07JDNZY661F63ACD3NEF\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-model-flag.json b/apps/cli/src/tests/fixtures/headless-model-flag.json
new file mode 100644
index 0000000..aa0268c
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-model-flag.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"object\":\"chat.completion.chunk\",\"created\":1774387736,\"model\":\"anthropic/claude-sonnet-4\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_2m9qd0rdc4\"}\n\ndata: {\"id\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"object\":\"chat.completion.chunk\",\"created\":1774387736,\"model\":\"anthropic/claude-sonnet-4\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I am\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_2m9qd0rdc4\"}\n\ndata: {\"id\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"object\":\"chat.completion.chunk\",\"created\":1774387736,\"model\":\"anthropic/claude-sonnet-4\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Claude, an AI assistant created by Anthropic. I'm designed to be helpful, harmless, and honest in my interactions. In this context, I'm working as\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_2m9qd0rdc4\"}\n\ndata: {\"id\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"object\":\"chat.completion.chunk\",\"created\":1774387736,\"model\":\"anthropic/claude-sonnet-4\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Cline, an AI coding agent, to help you with various coding tasks using the tools available in your development\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_2m9qd0rdc4\"}\n\ndata: {\"id\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"object\":\"chat.completion.chunk\",\"created\":1774387736,\"model\":\"anthropic/claude-sonnet-4\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" environment.\\n\\nIs there a specific coding task or question I can help you with today?\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_2m9qd0rdc4\"}\n\ndata: {\"id\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"object\":\"chat.completion.chunk\",\"created\":1774387736,\"model\":\"anthropic/claude-sonnet-4\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":6299,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":6299,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":81,\"service_tier\":\"standard\",\"inference_geo\":\"not_available\"},\"cacheCreationInputTokens\":6299,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-20250514\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-20250514\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-20250514\",\"providerApiModelId\":\"claude-sonnet-4-20250514\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":99871.198422,\"endTime\":102196.040629,\"providerRequestId\":\"req_011CZNcfy7SHwH4cErPnRiBj\",\"statusCode\":200,\"providerResponseId\":\"msg_01JACvubgQK9FnpiwQMhrKSt\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-20250514\",\"canonicalSlug\":\"anthropic/claude-sonnet-4\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-20250514\",\"providerApiModelId\":\"claude-sonnet-4-20250514\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":99871.198422,\"endTime\":102196.040629,\"providerRequestId\":\"req_011CZNcfy7SHwH4cErPnRiBj\",\"statusCode\":200,\"providerResponseId\":\"msg_01JACvubgQK9FnpiwQMhrKSt\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.02484525\",\"generationId\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":6302,\"completion_tokens\":81,\"total_tokens\":6383,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.02484525,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":6299,\"market_cost\":0.02484525},\"system_fingerprint\":\"fp_2m9qd0rdc4\",\"generationId\":\"gen_01KMGW0AZ89CFPH30YWCZ70XTS\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-piped-stdin.json b/apps/cli/src/tests/fixtures/headless-piped-stdin.json
new file mode 100644
index 0000000..cb47704
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-piped-stdin.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGW05HMS1RP1DKG0KAQFKPN\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uefz8zfc98\"}\n\ndata: {\"id\":\"gen_01KMGW05HMS1RP1DKG0KAQFKPN\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"horse\",\"phase\":\"final_answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uefz8zfc98\"}\n\ndata: {\"id\":\"gen_01KMGW05HMS1RP1DKG0KAQFKPN\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"openai\":{\"responseId\":\"resp_01858caa4de363eb0169c3021221ec81909d58c3a2e20d567a\",\"serviceTier\":\"default\"},\"gateway\":{\"routing\":{\"originalModelId\":\"openai/gpt-5.3-codex\",\"resolvedProvider\":\"openai\",\"resolvedProviderApiModelId\":\"gpt-5.3-codex\",\"internalResolvedModelId\":\"openai:gpt-5.3-codex\",\"fallbacksAvailable\":[\"azure\"],\"internalReasoning\":\"Selected openai as preferred provider for gpt-5.3-codex. 1 fallback(s) available: azure\",\"planningReasoning\":\"BYOK credentials available for: openai. System credentials planned for: openai, azure. Total execution order: openai(BYOK) → openai(system) → azure(system)\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"finalProvider\":\"openai\",\"attempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":94685.956138,\"endTime\":94727.499224,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":94744.883655,\"endTime\":95476.66778,\"providerRequestId\":\"req_fc7485f81fc9426abe2dfc9a880db650\",\"statusCode\":200,\"providerResponseId\":\"resp_01858caa4de363eb0169c3021221ec81909d58c3a2e20d567a\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"openai:gpt-5.3-codex\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"success\":true,\"providerAttemptCount\":2,\"providerAttempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":94685.956138,\"endTime\":94727.499224,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":94744.883655,\"endTime\":95476.66778,\"providerRequestId\":\"req_fc7485f81fc9426abe2dfc9a880db650\",\"statusCode\":200,\"providerResponseId\":\"resp_01858caa4de363eb0169c3021221ec81909d58c3a2e20d567a\"}]}],\"totalProviderAttemptCount\":2},\"cost\":\"0.00087535\",\"marketCost\":\"0.00087535\",\"generationId\":\"gen_01KMGW05HMS1RP1DKG0KAQFKPN\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3801,\"completion_tokens\":5,\"total_tokens\":3806,\"cost\":0.00087535,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":3712,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":null,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.00087535},\"system_fingerprint\":\"fp_uefz8zfc98\",\"service_tier\":\"default\",\"generationId\":\"gen_01KMGW05HMS1RP1DKG0KAQFKPN\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-timeout.json b/apps/cli/src/tests/fixtures/headless-timeout.json
new file mode 100644
index 0000000..24b8ae6
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-timeout.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A\",\"phase\":\"final_answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" get\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stranded\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" overnight\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" giant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ultra\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-modern\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" office\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" building\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" after\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" corporate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Innovation\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Off\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"site\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" goes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" wildly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" wrong\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" smart\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" locks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" fail\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lights\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" motion\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"activated\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cafeteria\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" only\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" accepts\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" badge\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" payments\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"And\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" none\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" their\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" badges\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" work\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" because\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"identity\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" services\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" currently\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" degraded\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"At\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" first\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stay\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" calm\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Okay\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" team\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" this\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" great\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" opportunity\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Let\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" align\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" objectives\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" By\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" morning\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" we\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" need\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" food\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" warmth\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" emotional\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" safety\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" can\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" script\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" us\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" out\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" this\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" can\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" restart\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" this\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" all\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" nod\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" like\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" this\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" normal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sentence\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" exchange\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"1\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Discovery\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" begin\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" exploring\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Floor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Sales\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Nothing\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" but\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" branded\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stress\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" balls\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" suspicious\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" inspirational\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" wall\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" quote\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" *\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"H\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ust\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"le\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" feature\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"*\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Floor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"5\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Legal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Door\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" locked\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" course\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Floor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"7\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Engineering\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" White\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"boards\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" full\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" equations\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" note\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" just\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"don\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’t\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" touch\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" prod\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" under\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"lined\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"14\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" times\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Floor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"9\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Executive\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" suite\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Glass\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" walls\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Empty\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" komb\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ucha\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" taps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" A\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" telescope\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pointed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" at\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" parking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lot\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" finds\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" terminal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" left\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" unlocked\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" conference\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" room\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cracks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" his\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" kn\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"uckles\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Finally\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" types\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"```\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"bash\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"sudo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" open\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"_every\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"_d\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"oor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" --\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"force\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"``\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Terminal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" replies\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"command\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" not\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" found\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" squ\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ints\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Fine\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Different\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" distro\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"2\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Bl\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ame\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Assignment\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" starts\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" retrospective\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" right\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" there\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" hallway\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Let\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" do\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" quick\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bl\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"am\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"eless\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" post\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"mort\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"em\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" why\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" we\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" physically\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" trapped\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" this\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" building\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" raises\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" hand\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" doors\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" managed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" by\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cloud\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" service\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" local\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" fallback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" fallback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" enabled\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" roadmap\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" jot\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ting\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" notes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sticky\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pad\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Action\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" item\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Define\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"fallback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Action\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" item\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Clar\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ify\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lock\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" strategy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"literal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Attempt\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Solutions\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"####\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"1\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" solution\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" writes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Python\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" script\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" brute\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-force\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lock\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" API\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"After\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" twenty\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" minutes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" works\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" staging\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" not\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" staging\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"####\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"2\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" solution\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" finds\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" building\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" control\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dashboard\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tablet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" IT\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Big\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" red\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" button\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"RE\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"DEP\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"LOY\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ACCESS\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" SERVICES\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" presses\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"All\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lights\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" turn\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" purple\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" speaker\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" somewhere\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Deployment\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" started\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Deployment\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" failed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Rolling\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" back\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Rollback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" failed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" complete\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" silence\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" now\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" have\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" no\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lights\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" except\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" emergency\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" exit\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" signs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" glow\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" three\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" laptop\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" screens\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" at\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"8\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"%\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" battery\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"####\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" solution\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" suggests\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"simulate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" user\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" journey\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" from\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" perspective\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" trapped\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" employee\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" am\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" currently\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" highly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" immersed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" journey\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"4\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Hunger\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" make\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cafeteria\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"There\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" food\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"There\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" vending\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" machines\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"There\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" checkout\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" kiosk\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Tap\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" badge\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" continue\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" taps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" harder\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" as\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" if\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" determination\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" NFC\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-compatible\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"No\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" luck\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" finds\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" banana\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" behind\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" an\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" espresso\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" machine\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" green\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" enough\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" be\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" considered\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pre\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-beta\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" split\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" into\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" three\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" slices\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" so\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" thin\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" can\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" see\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" future\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" through\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" them\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"5\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Esc\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"al\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ation\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Around\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" midnight\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" discover\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Security\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Operations\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Room\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" huge\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dashboard\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" shows\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dozens\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" systems\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" HVAC\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" healthy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Fire\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" suppression\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" healthy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Parking\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" gate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" healthy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Door\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" control\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Waiting\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" auth\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" callback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Coffee\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" machine\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" firmware\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Update\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" available\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" st\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ares\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Even\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" now\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" wants\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" patch\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" itself\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" opens\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" system\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" logs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pages\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ERROR\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" token\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" expired\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ERROR\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" token\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" refresh\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" endpoint\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" unreachable\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"INFO\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" retry\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ing\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"5\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" seconds\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" whispers\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"beautiful\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" terrible\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"6\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Great\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Debate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"At\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"1\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"30\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" AM\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sit\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bean\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"bags\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" under\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" neon\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sign\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"TH\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"INK\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" BIG\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"GER\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" argue\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" about\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" how\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" get\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" out\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"We\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" should\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" reverse\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" protocol\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"We\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" should\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" reboot\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" floor\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" switch\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"We\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" should\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" center\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" user\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" value\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"User\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" value\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" outside\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ag\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"reed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Great\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" alignment\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Let\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" create\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" phased\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" rollout\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" outside\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Phase\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"7\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Break\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"through\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"At\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"2\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"17\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" AM\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" notices\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" something\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" logs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"auth\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".service\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".local\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" ->\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" unresolved\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" host\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"`\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Wait\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"…\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" this\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" whole\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" building\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" depends\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" internal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" DNS\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" gas\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" like\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" someone\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" found\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pulse\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" locate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" network\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" closet\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" contains\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" switch\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tiny\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" server\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" seventeen\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" unl\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"abeled\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cables\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" label\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"DO\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" NOT\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" UN\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"PL\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"UG\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"unless\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" really\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sure\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"I\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’m\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" really\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sure\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"He\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" un\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"pl\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ugs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Everything\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" goes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dark\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stand\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" silence\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"From\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" somewhere\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" building\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lock\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" clicks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" open\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" another\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Then\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" several\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" more\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Emergency\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" fail\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-safe\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" mode\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" has\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" triggered\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" all\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" doors\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" unlocked\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" evacuation\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"They\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sprint\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" down\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" six\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" flights\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" stairs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" burst\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" through\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lobby\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" doors\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" collapse\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dramatically\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sidewalk\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" at\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"2\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"29\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" AM\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" under\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" flick\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ering\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sign\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" says\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"WELCOME\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" IN\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"NOV\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ATORS\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"---\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"###\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Ep\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"il\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ogue\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Monday\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" morning\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" present\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" their\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" findings\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" leadership\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" product\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" manager\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" presents\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"48\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-slide\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" deck\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" titled\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"From\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Incident\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Opportunity\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Re\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"imag\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ining\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Physical\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Access\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Sy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"nergies\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Dev\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Ops\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" presents\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" single\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" diagram\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" box\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" labeled\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"DNS\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" connected\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" to\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" literally\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" everything\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" software\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" engineer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" presents\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pull\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" request\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"000\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lines\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" changed\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" comment\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"fix\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" typo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Leadership\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" asks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" “\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"So\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" what\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’s\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" key\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" takeaway\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?”\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"All\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" three\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" perfect\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" un\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ison\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"“\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"It\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" worked\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" staging\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".”\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_tbw9d0jg0f\"}\n\ndata: {\"id\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"object\":\"chat.completion.chunk\",\"created\":1774386284,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"openai\":{\"responseId\":\"resp_070b82d269b5b5cd0169c2fc6c39388195807dab80f1500042\",\"serviceTier\":\"default\"},\"gateway\":{\"routing\":{\"originalModelId\":\"openai/gpt-5.3-codex\",\"resolvedProvider\":\"openai\",\"resolvedProviderApiModelId\":\"gpt-5.3-codex\",\"internalResolvedModelId\":\"openai:gpt-5.3-codex\",\"fallbacksAvailable\":[\"azure\"],\"internalReasoning\":\"Selected openai as preferred provider for gpt-5.3-codex. 1 fallback(s) available: azure\",\"planningReasoning\":\"BYOK credentials available for: openai. System credentials planned for: openai, azure. Total execution order: openai(BYOK) → openai(system) → azure(system)\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"finalProvider\":\"openai\",\"attempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":469039.34108,\"endTime\":469089.614753,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":469108.910828,\"endTime\":499375.840116,\"providerRequestId\":\"req_ce028bebeefe4759960fee2d36f5d73c\",\"statusCode\":200,\"providerResponseId\":\"resp_070b82d269b5b5cd0169c2fc6c39388195807dab80f1500042\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"openai:gpt-5.3-codex\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"success\":true,\"providerAttemptCount\":2,\"providerAttempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":469039.34108,\"endTime\":469089.614753,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":469108.910828,\"endTime\":499375.840116,\"providerRequestId\":\"req_ce028bebeefe4759960fee2d36f5d73c\",\"statusCode\":200,\"providerResponseId\":\"resp_070b82d269b5b5cd0169c2fc6c39388195807dab80f1500042\"}]}],\"totalProviderAttemptCount\":2},\"cost\":\"0.01829135\",\"marketCost\":\"0.01829135\",\"generationId\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3793,\"completion_tokens\":1250,\"total_tokens\":5043,\"cost\":0.01829135,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":3712,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":null,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.01829135},\"system_fingerprint\":\"fp_tbw9d0jg0f\",\"service_tier\":\"default\",\"generationId\":\"gen_01KMGTM1FM40CWRTE6B00WWRM1\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-verbose.json b/apps/cli/src/tests/fixtures/headless-verbose.json
new file mode 100644
index 0000000..71b950e
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-verbose.json
@@ -0,0 +1,64 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/users/me",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"id": "REDACTED",
+				"email": "REDACTED",
+				"displayName": "REDACTED",
+				"termsAcceptedAt": "2025-12-01T22:41:32.619173Z",
+				"clineBenchConsent": true,
+				"organizations": [
+					{
+						"memberId": "REDACTED",
+						"organizationId": "REDACTED",
+						"name": "Cline Bot Inc",
+						"roles": ["admin"],
+						"active": true
+					},
+					{
+						"memberId": "REDACTED",
+						"organizationId": "REDACTED",
+						"name": "Cline Internal Testing Org",
+						"roles": ["member"],
+						"active": false
+					}
+				],
+				"createdAt": "2025-12-01T22:34:35.355099Z",
+				"updatedAt": "2026-03-24T21:27:10.453282Z"
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/balance",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"organizationId": "REDACTED",
+				"balance": "REDACTED"
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Why\",\"phase\":\"final_answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" did\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" programmer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" quit\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" his\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" job\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?\\n\\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Because\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" he\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" didn\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"’t\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" get\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" arrays\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_e881w04olc\"}\n\ndata: {\"id\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"object\":\"chat.completion.chunk\",\"created\":1774387732,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"openai\":{\"responseId\":\"resp_09fb8e1b1228cf570169c3021483f481939205f50ba3a85482\",\"serviceTier\":\"default\"},\"gateway\":{\"routing\":{\"originalModelId\":\"openai/gpt-5.3-codex\",\"resolvedProvider\":\"openai\",\"resolvedProviderApiModelId\":\"gpt-5.3-codex\",\"internalResolvedModelId\":\"openai:gpt-5.3-codex\",\"fallbacksAvailable\":[\"azure\"],\"internalReasoning\":\"Selected openai as preferred provider for gpt-5.3-codex. 1 fallback(s) available: azure\",\"planningReasoning\":\"BYOK credentials available for: openai. System credentials planned for: openai, azure. Total execution order: openai(BYOK) → openai(system) → azure(system)\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"finalProvider\":\"openai\",\"attempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":96918.173395,\"endTime\":96965.753356,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":96982.122639,\"endTime\":98127.411976,\"providerRequestId\":\"req_b296bc1267a244699070f310b473080e\",\"statusCode\":200,\"providerResponseId\":\"resp_09fb8e1b1228cf570169c3021483f481939205f50ba3a85482\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"openai:gpt-5.3-codex\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"success\":true,\"providerAttemptCount\":2,\"providerAttempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":96918.173395,\"endTime\":96965.753356,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":96982.122639,\"endTime\":98127.411976,\"providerRequestId\":\"req_b296bc1267a244699070f310b473080e\",\"statusCode\":200,\"providerResponseId\":\"resp_09fb8e1b1228cf570169c3021483f481939205f50ba3a85482\"}]}],\"totalProviderAttemptCount\":2},\"cost\":\"0.00105385\",\"marketCost\":\"0.00105385\",\"generationId\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3791,\"completion_tokens\":19,\"total_tokens\":3810,\"cost\":0.00105385,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":3712,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":null,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.00105385},\"system_fingerprint\":\"fp_e881w04olc\",\"service_tier\":\"default\",\"generationId\":\"gen_01KMGW07V05ZFX69T7ZWJ8BH20\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/headless-yolo-basic.json b/apps/cli/src/tests/fixtures/headless-yolo-basic.json
new file mode 100644
index 0000000..5fbf25d
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/headless-yolo-basic.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Why\",\"phase\":\"final_answer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" did\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" developer\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" go\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" broke\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"?\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Because\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" he\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" used\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" up\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" all\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" his\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cache\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" 😄\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3q0c7eayzz\"}\n\ndata: {\"id\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"object\":\"chat.completion.chunk\",\"created\":1774387730,\"model\":\"openai/gpt-5.3-codex\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"openai\":{\"responseId\":\"resp_06ac4b0686befb510169c30211d638819398d4769b68a92ee7\",\"serviceTier\":\"default\"},\"gateway\":{\"routing\":{\"originalModelId\":\"openai/gpt-5.3-codex\",\"resolvedProvider\":\"openai\",\"resolvedProviderApiModelId\":\"gpt-5.3-codex\",\"internalResolvedModelId\":\"openai:gpt-5.3-codex\",\"fallbacksAvailable\":[\"azure\"],\"internalReasoning\":\"Selected openai as preferred provider for gpt-5.3-codex. 1 fallback(s) available: azure\",\"planningReasoning\":\"BYOK credentials available for: openai. System credentials planned for: openai, azure. Total execution order: openai(BYOK) → openai(system) → azure(system)\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"finalProvider\":\"openai\",\"attempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":94378.313912,\"endTime\":94415.554661,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":94433.469238,\"endTime\":95550.46018,\"providerRequestId\":\"req_d6ba617524204bf18e820033693ea6a4\",\"statusCode\":200,\"providerResponseId\":\"resp_06ac4b0686befb510169c30211d638819398d4769b68a92ee7\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"openai:gpt-5.3-codex\",\"canonicalSlug\":\"openai/gpt-5.3-codex\",\"success\":true,\"providerAttemptCount\":2,\"providerAttempts\":[{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"byok\",\"success\":false,\"error\":\"You do not have access to the organization tied to the API key.\",\"startTime\":94378.313912,\"endTime\":94415.554661,\"statusCode\":401},{\"provider\":\"openai\",\"internalModelId\":\"openai:gpt-5.3-codex\",\"providerApiModelId\":\"gpt-5.3-codex\",\"credentialType\":\"system\",\"success\":true,\"startTime\":94433.469238,\"endTime\":95550.46018,\"providerRequestId\":\"req_d6ba617524204bf18e820033693ea6a4\",\"statusCode\":200,\"providerResponseId\":\"resp_06ac4b0686befb510169c30211d638819398d4769b68a92ee7\"}]}],\"totalProviderAttemptCount\":2},\"cost\":\"0.00230545\",\"marketCost\":\"0.00230545\",\"generationId\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":3791,\"completion_tokens\":22,\"total_tokens\":3813,\"cost\":0.00230545,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":2944,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":null,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.00230545},\"system_fingerprint\":\"fp_3q0c7eayzz\",\"service_tier\":\"default\",\"generationId\":\"gen_01KMGW057YHNN640X1V7MM6HAJ\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/hello-and-goodbye.json b/apps/cli/src/tests/fixtures/hello-and-goodbye.json
new file mode 100644
index 0000000..825d45a
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/hello-and-goodbye.json
@@ -0,0 +1,271 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683170513,
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"surveys": false,
+			"elementsChainAsString": true,
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"captureDeadClicks": false,
+			"hasFeatureFlags": true,
+			"defaultIdentifiedOnly": true,
+			"autocaptureExceptions": true,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"productTours": false,
+			"heatmaps": true,
+			"supportedCompression": ["gzip", "gzip-js"],
+			"token": "REDACTED",
+			"siteApps": [],
+			"autocapture_opt_out": false,
+			"conversations": false
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"! \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"👋\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01VXMFGuMXXsb85RwqFrRany\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"res\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ult\\\": \\\"H\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ello!\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" 👋\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ask_prog\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ress\\\": \\\"- [\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"x] Say h\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ello\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_xmaef7pjsm\"}\n\ndata: {\"id\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"object\":\"chat.completion.chunk\",\"created\":1773683177,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":8885,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":8885,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":87,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":8885,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":330770.435111,\"endTime\":332694.276037,\"providerRequestId\":\"req_011CZ7BDtJGhfGYDkMwtPWRL\",\"statusCode\":200,\"providerResponseId\":\"msg_01Nf7aHFhaUDAvkNozeRCJwv\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":330770.435111,\"endTime\":332694.276037,\"providerRequestId\":\"req_011CZ7BDtJGhfGYDkMwtPWRL\",\"statusCode\":200,\"providerResponseId\":\"msg_01Nf7aHFhaUDAvkNozeRCJwv\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.03463275\",\"generationId\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":8888,\"completion_tokens\":87,\"total_tokens\":8975,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.03463275,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":8885,\"market_cost\":0.03463275},\"system_fingerprint\":\"fp_xmaef7pjsm\",\"generationId\":\"gen_01KKVW2WTJY7DQ9XJ03FKZ5FZ6\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Goodbye! 👋\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01SuERtPTQbLNN1jtELBgev9\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"result\\\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"Good\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"bye! 👋\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"progress\\\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"- [x] Say \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"hello\\\\n- [x]\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" Say goodb\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ye\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_3efyckoz2y\"}\n\ndata: {\"id\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"object\":\"chat.completion.chunk\",\"created\":1773683180,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":237,\"cache_read_input_tokens\":8885,\"cache_creation\":{\"ephemeral_5m_input_tokens\":237,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":96,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":237,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":556464.082836,\"endTime\":557962.434944,\"providerRequestId\":\"req_011CZ7BE8eUX8qAENXeZctSM\",\"statusCode\":200,\"providerResponseId\":\"msg_014jCu5ycMTNgCFXoB29GmG7\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":556464.082836,\"endTime\":557962.434944,\"providerRequestId\":\"req_011CZ7BE8eUX8qAENXeZctSM\",\"statusCode\":200,\"providerResponseId\":\"msg_014jCu5ycMTNgCFXoB29GmG7\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.00500325\",\"generationId\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":9125,\"completion_tokens\":96,\"total_tokens\":9221,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":8885,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.00500325,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":237,\"market_cost\":0.00500325},\"system_fingerprint\":\"fp_3efyckoz2y\",\"generationId\":\"gen_01KKVW305ZKBA07GCQ5P8YK7H9\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/per-turn-metrics.json b/apps/cli/src/tests/fixtures/per-turn-metrics.json
new file mode 100644
index 0000000..68dc38b
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/per-turn-metrics.json
@@ -0,0 +1,20 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\": \"gen_test_turn1_aabbccdd\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {\"role\": \"assistant\"}, \"logprobs\": null, \"finish_reason\": null}], \"system_fingerprint\": \"fp_test\"}\n\ndata: {\"id\": \"gen_test_turn1_aabbccdd\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {\"tool_calls\": [{\"index\": 0, \"id\": \"call_t1abc\", \"type\": \"function\", \"function\": {\"name\": \"run_commands\", \"arguments\": \"\"}}]}, \"logprobs\": null, \"finish_reason\": null}], \"system_fingerprint\": \"fp_test\"}\n\ndata: {\"id\": \"gen_test_turn1_aabbccdd\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {\"tool_calls\": [{\"index\": 0, \"function\": {\"arguments\": \"{\\\"commands\\\":[\\\"echo hello\\\"]}\"}}]}, \"logprobs\": null, \"finish_reason\": null}], \"system_fingerprint\": \"fp_test\"}\n\ndata: {\"id\": \"gen_test_turn1_aabbccdd\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {}, \"logprobs\": null, \"finish_reason\": \"tool_calls\"}], \"system_fingerprint\": \"fp_test\", \"usage\": {\"prompt_tokens\": 1000, \"completion_tokens\": 25, \"total_tokens\": 1025, \"cost\": 0.0011, \"is_byok\": false, \"prompt_tokens_details\": {\"cached_tokens\": 200, \"audio_tokens\": 0, \"video_tokens\": 0}, \"cost_details\": {\"upstream_inference_cost\": null, \"upstream_inference_prompt_cost\": 0, \"upstream_inference_completions_cost\": 0}, \"completion_tokens_details\": {\"reasoning_tokens\": 0, \"image_tokens\": 0}, \"cache_creation_input_tokens\": 50, \"market_cost\": 0.0011}}\n\ndata: [DONE]\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\": \"gen_test_turn2_eeffgghh\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {\"role\": \"assistant\"}, \"logprobs\": null, \"finish_reason\": null}], \"system_fingerprint\": \"fp_test\"}\n\ndata: {\"id\": \"gen_test_turn2_eeffgghh\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {\"content\": \"The command ran successfully.\", \"phase\": \"final_answer\"}, \"logprobs\": null, \"finish_reason\": null}], \"system_fingerprint\": \"fp_test\"}\n\ndata: {\"id\": \"gen_test_turn2_eeffgghh\", \"object\": \"chat.completion.chunk\", \"created\": 1774387732, \"model\": \"openai/gpt-5.3-codex\", \"choices\": [{\"index\": 0, \"delta\": {}, \"logprobs\": null, \"finish_reason\": \"stop\"}], \"system_fingerprint\": \"fp_test\", \"usage\": {\"prompt_tokens\": 1500, \"completion_tokens\": 40, \"total_tokens\": 1540, \"cost\": 0.0019, \"is_byok\": false, \"prompt_tokens_details\": {\"cached_tokens\": 900, \"audio_tokens\": 0, \"video_tokens\": 0}, \"cost_details\": {\"upstream_inference_cost\": null, \"upstream_inference_prompt_cost\": 0, \"upstream_inference_completions_cost\": 0}, \"completion_tokens_details\": {\"reasoning_tokens\": 0, \"image_tokens\": 0}, \"cache_creation_input_tokens\": 30, \"market_cost\": 0.0019}}\n\ndata: [DONE]\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/read-file-outside-cwd.json b/apps/cli/src/tests/fixtures/read-file-outside-cwd.json
new file mode 100644
index 0000000..ae51283
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/read-file-outside-cwd.json
@@ -0,0 +1,271 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				},
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683207490,
+			"surveys": false,
+			"autocaptureExceptions": true,
+			"siteApps": [],
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"captureDeadClicks": false,
+			"conversations": false,
+			"elementsChainAsString": true,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"productTours": false,
+			"token": "REDACTED",
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"supportedCompression": ["gzip", "gzip-js"],
+			"defaultIdentifiedOnly": true,
+			"hasFeatureFlags": true,
+			"autocapture_opt_out": false,
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"heatmaps": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01LKL9USwMHrDf6av46XP7Mm\",\"type\":\"function\",\"function\":{\"name\":\"read_file\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"path\\\": \\\"/U\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ser\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s/maxpau\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lus/.wezter\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"m.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lua\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ask_progr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ess\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \\\"- [ ] R\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ead ~/\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\".wezterm.l\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ua\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5x9jxec8jx\"}\n\ndata: {\"id\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"object\":\"chat.completion.chunk\",\"created\":1773683214,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":2776,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":2776,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":93,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":2776,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":589172.166417,\"endTime\":591509.98254,\"providerRequestId\":\"req_011CZ7BGaXH5i6xKRg84cK43\",\"statusCode\":200,\"providerResponseId\":\"msg_01DZYRP7RtSxt4MnRSonLHjB\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":589172.166417,\"endTime\":591509.98254,\"providerRequestId\":\"req_011CZ7BGaXH5i6xKRg84cK43\",\"statusCode\":200,\"providerResponseId\":\"msg_01DZYRP7RtSxt4MnRSonLHjB\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0140094\",\"generationId\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10097,\"completion_tokens\":93,\"total_tokens\":10190,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0140094,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":2776,\"market_cost\":0.0140094},\"system_fingerprint\":\"fp_5x9jxec8jx\",\"generationId\":\"gen_01KKVW40MM76RVEWFA4NE5AN54\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Here\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'s your\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" `\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"~\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/.wezterm.lua` file\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Here\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'s a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" quick\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" summary of your\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" configuration:\\n\\n-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **Frontend\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: WebGpu\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- **Color\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" scheme\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: Tokyo Night\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- **Font size\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: 15.0 (with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lig\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"atures disabled)\\n- **Tab bar\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**:\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Bottom\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" non\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-fancy style\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- **Scrollback**: \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"20,000 lines\\n- **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Window\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" padding**: None\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"all\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sides\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" =\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" 0)\\n- **Inactive\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pane**: Slightly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dim\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"med (sat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"uration &\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" brightness at\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" 0.8)\\n\\n**Key\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bin\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"dings highlights\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":**\\n- `F1` —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Toggle pane zoom\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+Enter` — Split pane horizont\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ally (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"or\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" un\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"zoom if\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" zo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"omed)\\n- `CMD+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+Enter` — Split pane\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" vertically (or unzoom)\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+AL\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"T+Enter` — Split\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" new\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" top\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-level pane up\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ward\\n- `CMD+[\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Enter\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" copy mode\\n- `CMD+k\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Clear scrollback +\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" viewport\\n- `CMD+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+k` — Clear scrollback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" only\\n- `CTRL+AL\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"T+h\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"l` — Navigate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tabs left\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/right\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+SHIFT+h/j\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"k/l\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Navigate p\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"anes (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"vim\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-style)\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+SHIFT+o` — Open\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" scroll\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"back in `\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"nvim`\\n- `CMD+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+w\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Close current pane (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" confirm\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\\n\\nThere\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'s also a clever\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" `\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"split\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"_or_unzoom` helper\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that un\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"zo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"oms a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" zo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"omed pane instead\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of splitting when\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is already\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" zoomed.\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01RTMbzBFx47XzZCzpxD32cc\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"result\\\":\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" \\\"Read and d\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"isplayed \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"the c\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ontents of\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" `~/.wezt\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"er\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"m.lua\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"`. The\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" con\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"fig \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"uses Tok\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"yo Night th\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"eme, Web\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"Gpu front\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"end,\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" 1\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"5pt font wit\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"h li\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"gatures d\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"isabl\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ed, botto\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"m tab b\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ar, 2\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"0k scrol\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lback lines\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", zero \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"window p\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"addin\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"g, and \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"a rich se\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t of k\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"eyb\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"indi\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ngs i\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ncludin\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"g vim-style\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" pane \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"navig\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ation an\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"d \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"a custo\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"m `split\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"_or_u\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nzoom` \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"helper.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"progress\\\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"- [x] Rea\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"d ~\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"/.wezter\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"m.lua\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_n3c7jltusg\"}\n\ndata: {\"id\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"object\":\"chat.completion.chunk\",\"created\":1773683217,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":1683,\"cache_read_input_tokens\":10094,\"cache_creation\":{\"ephemeral_5m_input_tokens\":1683,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":519,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":1683,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":676001.229086,\"endTime\":684886.352388,\"providerRequestId\":\"req_011CZ7BGpApJmWQvqrnJb9Nb\",\"statusCode\":200,\"providerResponseId\":\"msg_01KreMuCinV5Go6CRzZ8Q64b\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":676001.229086,\"endTime\":684886.352388,\"providerRequestId\":\"req_011CZ7BGpApJmWQvqrnJb9Nb\",\"statusCode\":200,\"providerResponseId\":\"msg_01KreMuCinV5Go6CRzZ8Q64b\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.01713345\",\"generationId\":\"gen_01KKVW43NJGNPRA8T24792BTDS\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":11780,\"completion_tokens\":519,\"total_tokens\":12299,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":10094,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.01713345,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":1683,\"market_cost\":0.01713345},\"system_fingerprint\":\"fp_n3c7jltusg\",\"generationId\":\"gen_01KKVW43NJGNPRA8T24792BTDS\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/read-file.json b/apps/cli/src/tests/fixtures/read-file.json
new file mode 100644
index 0000000..b904238
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/read-file.json
@@ -0,0 +1,271 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683174348,
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"surveys": false,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"autocaptureExceptions": true,
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"siteApps": [],
+			"hasFeatureFlags": true,
+			"elementsChainAsString": true,
+			"heatmaps": true,
+			"productTours": false,
+			"token": "REDACTED",
+			"conversations": false,
+			"defaultIdentifiedOnly": true,
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"supportedCompression": ["gzip", "gzip-js"],
+			"autocapture_opt_out": false,
+			"captureDeadClicks": false
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_015TzvHPYKBHSjwXmDtZbTvt\",\"type\":\"function\",\"function\":{\"name\":\"read_file\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"path\\\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"/Users/REDACTED_USER\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"pau\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lus/\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\".wezterm.lua\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_prog\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ress\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"- [ ] Re\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ad ~/.wez\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"term.lua\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_ya3b39u409\"}\n\ndata: {\"id\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"object\":\"chat.completion.chunk\",\"created\":1773683181,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":1834,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":1834,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":93,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":1834,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":716265.777449,\"endTime\":718599.582452,\"providerRequestId\":\"req_011CZ7BEAoTi1e5kNUDhBFXn\",\"statusCode\":200,\"providerResponseId\":\"msg_01YGmgHsQeeKd9fwoLdNC7iQ\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":716265.777449,\"endTime\":718599.582452,\"providerRequestId\":\"req_011CZ7BEAoTi1e5kNUDhBFXn\",\"statusCode\":200,\"providerResponseId\":\"msg_01YGmgHsQeeKd9fwoLdNC7iQ\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0104769\",\"generationId\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":9155,\"completion_tokens\":93,\"total_tokens\":9248,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0104769,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":1834,\"market_cost\":0.0104769},\"system_fingerprint\":\"fp_ya3b39u409\",\"generationId\":\"gen_01KKVW30JZ5C7FFAZS9YGEE0J1\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Here\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'s your\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" `\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"~\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/.w\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ezterm.lua\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` file\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Here\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'s a quick\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" summary of your\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" configuration:\\n\\n-\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" **Frontend\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: Web\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"G\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"pu\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- **Color\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" scheme\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: Tokyo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Night\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- **Font\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" size\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: 15\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"0\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"(with\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" lig\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"atures disabled\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\\n- **Tab\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" bar**: Bottom\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" non\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-fancy\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" style\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Scrollback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**: 20\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",000 lines\\n- **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Window\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" padding**: None\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"all\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sides\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" =\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" 0)\\n- **\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Inactive\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" pane**:\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Slightly\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" dim\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"med (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"sat\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"uration &\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" brightness at 0.8\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\")\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Key bin\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"dings highlights\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `F1` —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Toggle pane zoom\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Enter` — Split horizontal\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"or\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" un\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"zoom if\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" zo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"omed)\\n- `CMD+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+Enter` — Split vertical\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (or unzoom)\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `CMD+AL\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"T+Enter` — Split\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" p\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ane up\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ward (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"top\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-level)\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+W\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Close current pane\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `CMD+[\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Activate copy mode\\n- `CMD\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"+K\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Clear scrollback +\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" viewport\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `CMD+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+O\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Open\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" scroll\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"back in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" `\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"nv\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"im`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n- `CMD+\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"SHIFT+H\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"J\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"/K/L` — Navigate\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" p\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"anes\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"vim\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-style)\\n- `\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"CTRL+ALT+H/\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"L\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` — Switch\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" tabs\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\nThere\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'s also a custom\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" `split\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"_or_unzoom`\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" helper\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" un\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"zo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"oms a\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" zo\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"omed pane instead\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" of splitting when\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" one\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is already\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" zoomed,\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a `trigger\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-vim-with-scrollback\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"` event that dumps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the scrollback buffer to a temp\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" file and\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" opens\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" it in\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Ne\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ovim.\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01JHm4pGCyVtGrT5VXqr1S4j\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"resul\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t\\\": \\\"Read\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" and displa\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"yed th\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e contents o\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"f `~/.wez\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"te\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rm.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lua`. T\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"he config\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" uses the T\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"okyo Nigh\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t color sche\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"me, We\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"bGp\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"u frontend,\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" 15pt fo\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nt w\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ith ligature\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"disab\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"led,\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" a botto\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"m tab ba\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"r, 20k s\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"cro\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"llback lines\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", zero w\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"indow \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"padding, an\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"d \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"a rich set\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" of k\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"eyb\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"indin\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"gs in\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"clud\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ing vim\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"-style pan\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e navigati\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"on, sp\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lit/unz\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"oom hel\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"pe\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rs, and a s\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"hort\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"cut to \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"open the \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"scroll\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"back buff\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"er in \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"Ne\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ovim.\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ask\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"_progress\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"- [x] Rea\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"d ~/.wezte\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rm.lua\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_scrb6hi3qh\"}\n\ndata: {\"id\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"object\":\"chat.completion.chunk\",\"created\":1773683184,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":1683,\"cache_read_input_tokens\":9152,\"cache_creation\":{\"ephemeral_5m_input_tokens\":1683,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":537,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":1683,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":719569.548239,\"endTime\":729716.621807,\"providerRequestId\":\"req_011CZ7BEQe9jfnkhrCU6VAxR\",\"statusCode\":200,\"providerResponseId\":\"msg_01M8HdggAeDBhfeWtxQSuh6n\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":719569.548239,\"endTime\":729716.621807,\"providerRequestId\":\"req_011CZ7BEQe9jfnkhrCU6VAxR\",\"statusCode\":200,\"providerResponseId\":\"msg_01M8HdggAeDBhfeWtxQSuh6n\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.01712085\",\"generationId\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10838,\"completion_tokens\":537,\"total_tokens\":11375,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":9152,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.01712085,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":1683,\"market_cost\":0.01712085},\"system_fingerprint\":\"fp_scrb6hi3qh\",\"generationId\":\"gen_01KKVW33TK49Y63H7DR0YK2Y9P\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/safe-command-no-permission.json b/apps/cli/src/tests/fixtures/safe-command-no-permission.json
new file mode 100644
index 0000000..461ca21
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/safe-command-no-permission.json
@@ -0,0 +1,281 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683211261,
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"productTours": false,
+			"surveys": false,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"defaultIdentifiedOnly": true,
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"elementsChainAsString": true,
+			"token": "REDACTED",
+			"conversations": false,
+			"hasFeatureFlags": true,
+			"supportedCompression": ["gzip", "gzip-js"],
+			"siteApps": [],
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"captureDeadClicks": false,
+			"autocaptureExceptions": true,
+			"autocapture_opt_out": false,
+			"heatmaps": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_015EZJRdeuRD3o7oXbHYWsDm\",\"type\":\"function\",\"function\":{\"name\":\"execute_command\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"command\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \\\"dat\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"requ\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ires_appr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ova\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"l\\\": f\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"alse}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_emsc580f4e\"}\n\ndata: {\"id\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"object\":\"chat.completion.chunk\",\"created\":1773683218,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":2873,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":2873,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":73,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":2873,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":371728.588453,\"endTime\":373761.825985,\"providerRequestId\":\"req_011CZ7BGtvZfYoMMWuzUHKVJ\",\"statusCode\":200,\"providerResponseId\":\"msg_01Sx9Jy6nfavmmbEXnskHLjH\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":371728.588453,\"endTime\":373761.825985,\"providerRequestId\":\"req_011CZ7BGtvZfYoMMWuzUHKVJ\",\"statusCode\":200,\"providerResponseId\":\"msg_01Sx9Jy6nfavmmbEXnskHLjH\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.01407315\",\"generationId\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10194,\"completion_tokens\":73,\"total_tokens\":10267,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.01407315,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":2873,\"market_cost\":0.01407315},\"system_fingerprint\":\"fp_emsc580f4e\",\"generationId\":\"gen_01KKVW44QHYR1BEZAHWAFBAC4S\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" `date` command output\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" is\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\n**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Mon Mar 16 10:46\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\":59 PDT 2026\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"**\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01D6QHMhBHu2nreSap2afRzN\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"resul\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t\\\": \\\"The `da\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"te` com\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"man\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"d was \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"executed s\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"uccessfull\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"y. The curr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ent date and\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" time is:\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\\n\\\\n**Mon\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" Mar 16 10:4\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"6:59 \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"PD\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"T 2026\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"**\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_p\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rogres\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\": \\\"- [x] Run\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" `dat\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e` b\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ash c\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"omm\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"and and \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"show outp\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ut\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_no85xgn5py\"}\n\ndata: {\"id\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"object\":\"chat.completion.chunk\",\"created\":1773683221,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":452,\"cache_read_input_tokens\":10191,\"cache_creation\":{\"ephemeral_5m_input_tokens\":452,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":146,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":452,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":596578.92826,\"endTime\":600016.387299,\"providerRequestId\":\"req_011CZ7BH7hGH2KJcUr1vyyHw\",\"statusCode\":200,\"providerResponseId\":\"msg_01MYhmi2Ua2cbSzVFfncAM7F\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":596578.92826,\"endTime\":600016.387299,\"providerRequestId\":\"req_011CZ7BH7hGH2KJcUr1vyyHw\",\"statusCode\":200,\"providerResponseId\":\"msg_01MYhmi2Ua2cbSzVFfncAM7F\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0069513\",\"generationId\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10646,\"completion_tokens\":146,\"total_tokens\":10792,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":10191,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0069513,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":452,\"market_cost\":0.0069513},\"system_fingerprint\":\"fp_no85xgn5py\",\"generationId\":\"gen_01KKVW47QKCYAVN891VTX3M8BS\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/subagents.json b/apps/cli/src/tests/fixtures/subagents.json
new file mode 100644
index 0000000..2b3ac20
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/subagents.json
@@ -0,0 +1,333 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683216773,
+			"defaultIdentifiedOnly": true,
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"supportedCompression": ["gzip", "gzip-js"],
+			"autocaptureExceptions": true,
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"surveys": false,
+			"token": "REDACTED",
+			"hasFeatureFlags": true,
+			"captureDeadClicks": false,
+			"autocapture_opt_out": false,
+			"elementsChainAsString": true,
+			"productTours": false,
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"heatmaps": true,
+			"siteApps": [],
+			"conversations": false
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01VZ7NShQd5w8iFN8urd8LnC\",\"type\":\"function\",\"function\":{\"name\":\"use_subagents\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"p\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rompt\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"_1\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \\\"Tell\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" me one \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"joke. Just\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" respond\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" with \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"the joke, \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nothing e\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lse.\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"prompt\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"_2\\\": \\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"Tell me one \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"joke.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" Just resp\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ond with t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"he joke, no\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"thing els\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e.\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"prompt_3\\\":\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" \\\"Tell me \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"one jo\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ke. Just r\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"espond with \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"the joke, no\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"thing el\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"se.\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_qd40nj2utt\"}\n\ndata: {\"id\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"object\":\"chat.completion.chunk\",\"created\":1773683224,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":2873,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":2873,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":132,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":2873,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":598724.797201,\"endTime\":602715.912458,\"providerRequestId\":\"req_011CZ7BHHRQVYvG3beBJ1UPN\",\"statusCode\":200,\"providerResponseId\":\"msg_01DFHxCkC6GEw1CHyfZaxogR\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":598724.797201,\"endTime\":602715.912458,\"providerRequestId\":\"req_011CZ7BHHRQVYvG3beBJ1UPN\",\"statusCode\":200,\"providerResponseId\":\"msg_01DFHxCkC6GEw1CHyfZaxogR\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.01495815\",\"generationId\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10194,\"completion_tokens\":132,\"total_tokens\":10326,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.01495815,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":2873,\"market_cost\":0.01495815},\"system_fingerprint\":\"fp_qd40nj2utt\",\"generationId\":\"gen_01KKVW49XRRE2GDQ62Y10ZY64F\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4ES4298HGEE490D4A668\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_72f2zjs59u\"}\n\ndata: {\"id\":\"gen_01KKVW4ES4298HGEE490D4A668\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Why\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_72f2zjs59u\"}\n\ndata: {\"id\":\"gen_01KKVW4ES4298HGEE490D4A668\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" don't scientists trust atoms?\\n\\nBecause\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_72f2zjs59u\"}\n\ndata: {\"id\":\"gen_01KKVW4ES4298HGEE490D4A668\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they make up everything!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_72f2zjs59u\"}\n\ndata: {\"id\":\"gen_01KKVW4ES4298HGEE490D4A668\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5312,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":5312,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":17,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":5312,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":382409.411545,\"endTime\":383676.355817,\"providerRequestId\":\"req_011CZ7BHeSCrEsrWGd2a6mXA\",\"statusCode\":200,\"providerResponseId\":\"msg_01UzTmVEhFccnHCSdDVM8Bqn\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":382409.411545,\"endTime\":383676.355817,\"providerRequestId\":\"req_011CZ7BHeSCrEsrWGd2a6mXA\",\"statusCode\":200,\"providerResponseId\":\"msg_01UzTmVEhFccnHCSdDVM8Bqn\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.020184\",\"generationId\":\"gen_01KKVW4ES4298HGEE490D4A668\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5315,\"completion_tokens\":17,\"total_tokens\":5332,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.020184,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":5312,\"market_cost\":0.020184},\"system_fingerprint\":\"fp_72f2zjs59u\",\"generationId\":\"gen_01KKVW4ES4298HGEE490D4A668\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_j3n2ablg5l\"}\n\ndata: {\"id\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Why\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_j3n2ablg5l\"}\n\ndata: {\"id\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" don't scientists trust atoms?\\n\\nBecause\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_j3n2ablg5l\"}\n\ndata: {\"id\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they make up everything!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_j3n2ablg5l\"}\n\ndata: {\"id\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\",\"object\":\"chat.completion.chunk\",\"created\":1773683228,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5312,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":5312,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":17,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":5312,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":604187.589153,\"endTime\":605680.501162,\"providerRequestId\":\"req_011CZ7BHeLW5QDFvpqFbGkyF\",\"statusCode\":200,\"providerResponseId\":\"msg_01MyuXVbtLWQ2xWbTr4npbyP\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":604187.589153,\"endTime\":605680.501162,\"providerRequestId\":\"req_011CZ7BHeLW5QDFvpqFbGkyF\",\"statusCode\":200,\"providerResponseId\":\"msg_01MyuXVbtLWQ2xWbTr4npbyP\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.020184\",\"generationId\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5315,\"completion_tokens\":17,\"total_tokens\":5332,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.020184,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":5312,\"market_cost\":0.020184},\"system_fingerprint\":\"fp_j3n2ablg5l\",\"generationId\":\"gen_01KKVW4ERRTJK1RPJ4BGCM6DGW\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_y4tw66tfj7\"}\n\ndata: {\"id\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Why\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_y4tw66tfj7\"}\n\ndata: {\"id\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" don't scientists trust atoms?\\n\\nBecause\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_y4tw66tfj7\"}\n\ndata: {\"id\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" they make up everything!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_y4tw66tfj7\"}\n\ndata: {\"id\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5312,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":5312,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":17,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":5312,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":687292.952894,\"endTime\":689086.616776,\"providerRequestId\":\"req_011CZ7BHeQTqo41sEBUDKzSD\",\"statusCode\":200,\"providerResponseId\":\"msg_01PdwWEDKPTYSkUaLwuBBGDd\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":687292.952894,\"endTime\":689086.616776,\"providerRequestId\":\"req_011CZ7BHeQTqo41sEBUDKzSD\",\"statusCode\":200,\"providerResponseId\":\"msg_01PdwWEDKPTYSkUaLwuBBGDd\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.020184\",\"generationId\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5315,\"completion_tokens\":17,\"total_tokens\":5332,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.020184,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":5312,\"market_cost\":0.020184},\"system_fingerprint\":\"fp_y4tw66tfj7\",\"generationId\":\"gen_01KKVW4ES5YMNEK353DEA1ZR9Q\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01AyZPQev3j3BSNh1WTmrXPM\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"resul\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t\\\": \\\"Why d\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"on't \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sci\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"enti\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sts trust a\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"toms?\\\\n\\\\nBe\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"cause they m\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ake up eve\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ryth\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ing!\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_uff3atals7\"}\n\ndata: {\"id\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5442,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":5442,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":66,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":5442,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":606178.556245,\"endTime\":607828.374524,\"providerRequestId\":\"req_011CZ7BHo38BB5hkJ1KhnLcw\",\"statusCode\":200,\"providerResponseId\":\"msg_015bbgggAqJytbDbyYKHBodZ\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":606178.556245,\"endTime\":607828.374524,\"providerRequestId\":\"req_011CZ7BHo38BB5hkJ1KhnLcw\",\"statusCode\":200,\"providerResponseId\":\"msg_015bbgggAqJytbDbyYKHBodZ\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0214065\",\"generationId\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":5445,\"completion_tokens\":66,\"total_tokens\":5511,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0214065,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":5442,\"market_cost\":0.0214065},\"system_fingerprint\":\"fp_uff3atals7\",\"generationId\":\"gen_01KKVW4GR6DTSZ969XDT3X7WAF\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01VxTMpRJiEL5en6RXaBWvb8\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"res\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ult\\\": \\\"W\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"hy don't sci\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"entists trus\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t atoms?\\\\n\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\\nBecaus\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e they \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"make up\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" everyt\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"hing!\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_6jj674ec5b\"}\n\ndata: {\"id\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"object\":\"chat.completion.chunk\",\"created\":1773683230,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":130,\"cache_read_input_tokens\":5312,\"cache_creation\":{\"ephemeral_5m_input_tokens\":130,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":66,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":130,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":605792.289888,\"endTime\":607837.694454,\"providerRequestId\":\"req_011CZ7BHnPgZfY6oSt7EzhG7\",\"statusCode\":200,\"providerResponseId\":\"msg_01Svpmip4TEMTEz9LCCqpbtv\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":605792.289888,\"endTime\":607837.694454,\"providerRequestId\":\"req_011CZ7BHnPgZfY6oSt7EzhG7\",\"statusCode\":200,\"providerResponseId\":\"msg_01Svpmip4TEMTEz9LCCqpbtv\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0030801\",\"generationId\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":5445,\"completion_tokens\":66,\"total_tokens\":5511,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":5312,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0030801,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":130,\"market_cost\":0.0030801},\"system_fingerprint\":\"fp_6jj674ec5b\",\"generationId\":\"gen_01KKVW4GGPHPP8T1CJWY1CWGFR\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_017f7hnv96LQYbMU2Xxkmfey\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"result\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\": \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"Why don'\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t sc\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ienti\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sts trust\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" at\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"oms?\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\\n\\\\nBe\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"cause they m\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ake\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" up ev\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"eryth\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"in\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"g!\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_zzug3a8aea\"}\n\ndata: {\"id\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"object\":\"chat.completion.chunk\",\"created\":1773683231,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":130,\"cache_read_input_tokens\":5312,\"cache_creation\":{\"ephemeral_5m_input_tokens\":130,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":66,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":130,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":384538.439109,\"endTime\":386676.527388,\"providerRequestId\":\"req_011CZ7BHpLkuV2aEmG5Z8pA7\",\"statusCode\":200,\"providerResponseId\":\"msg_01MW1dUbLSnQv997o28Zu9c5\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":384538.439109,\"endTime\":386676.527388,\"providerRequestId\":\"req_011CZ7BHpLkuV2aEmG5Z8pA7\",\"statusCode\":200,\"providerResponseId\":\"msg_01MW1dUbLSnQv997o28Zu9c5\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0030801\",\"generationId\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":5445,\"completion_tokens\":66,\"total_tokens\":5511,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":5312,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0030801,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":130,\"market_cost\":0.0030801},\"system_fingerprint\":\"fp_zzug3a8aea\",\"generationId\":\"gen_01KKVW4H1MS1DBWXRK5KT1XJ2E\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Looks\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" like all\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3 subagents had\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the same taste\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" in jokes! Here are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3 jokes they\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" told\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" (\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"unanim\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ously):\\n\\n1. \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"🧪\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Why don't scientists trust atoms?\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Because they make up everything!\\n\\n2\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\". 🧪 Why don\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'t scientists trust atoms? Because they make\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" up everything!\\n\\n3. \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"🧪 Why don't scientists trust\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" atoms? Because they make up everything!\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\\n\\nApparently\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" sub\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"agents are\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" all on\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" the same wavelength —\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" or\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" maybe\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" atoms\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" really\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" can\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"'t be trusted.\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"😄\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01Q1JVh8FzjCPMAde8rpbJYL\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"result\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\": \\\"3 su\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"bagent\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s wer\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e laun\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ched\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" in parallel\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", eac\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"h \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"tasked with\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" tellin\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"g one jo\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ke. All \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"three indepe\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nd\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ently\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" landed \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"on\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" the \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"same c\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"la\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ssic: \\\\\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"Why don't s\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"cient\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ists t\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rus\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"t ato\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ms? Bec\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ause th\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ey \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"make up e\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"very\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"th\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ing!\\\\\\\" Tur\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ns out s\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ubag\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ents ha\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ve ver\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"y consis\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"tent \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"com\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"edic taste.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_pr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ogress\\\":\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" \\\"- [x] Lau\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nch 3 su\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"bagen\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ts in para\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"llel \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"to tell joke\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s\\\\n\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"- [x]\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" P\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"resent \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"the re\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sults\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_5eae8jj5ag\"}\n\ndata: {\"id\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"object\":\"chat.completion.chunk\",\"created\":1773683234,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":605,\"cache_read_input_tokens\":10191,\"cache_creation\":{\"ephemeral_5m_input_tokens\":605,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":268,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":605,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":608790.846568,\"endTime\":615075.096876,\"providerRequestId\":\"req_011CZ7BJ2ZECgM77sD3iXt6w\",\"statusCode\":200,\"providerResponseId\":\"msg_01Cazip4R7fya8vHtRM33a54\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":608790.846568,\"endTime\":615075.096876,\"providerRequestId\":\"req_011CZ7BJ2ZECgM77sD3iXt6w\",\"statusCode\":200,\"providerResponseId\":\"msg_01Cazip4R7fya8vHtRM33a54\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.00935505\",\"generationId\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10799,\"completion_tokens\":268,\"total_tokens\":11067,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":10191,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.00935505,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":605,\"market_cost\":0.00935505},\"system_fingerprint\":\"fp_5eae8jj5ag\",\"generationId\":\"gen_01KKVW4KSB5WC61EKZWS85XWMR\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/task-complete-exit.json b/apps/cli/src/tests/fixtures/task-complete-exit.json
new file mode 100644
index 0000000..72b3506
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/task-complete-exit.json
@@ -0,0 +1,236 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				},
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683206860,
+			"defaultIdentifiedOnly": true,
+			"token": "REDACTED",
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"productTours": false,
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"supportedCompression": ["gzip", "gzip-js"],
+			"surveys": false,
+			"autocaptureExceptions": true,
+			"conversations": false,
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"siteApps": [],
+			"autocapture_opt_out": false,
+			"hasFeatureFlags": true,
+			"heatmaps": true,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"captureDeadClicks": false,
+			"elementsChainAsString": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"! \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"👋\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_0184MU5TCnAtzxNFaUp9jQVA\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"resu\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"lt\\\": \\\"Hell\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"o! 👋\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"prog\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"re\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ss\\\": \\\"-\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" [x] Say he\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"llo\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_4e1d4xfed4\"}\n\ndata: {\"id\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":2770,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":2770,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":87,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":2770,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":672269.248544,\"endTime\":674563.237463,\"providerRequestId\":\"req_011CZ7BGYGMEFpp79Ugpzw3Q\",\"statusCode\":200,\"providerResponseId\":\"msg_01NbbYCjCYyY1oxZxBVuZaqU\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":672269.248544,\"endTime\":674563.237463,\"providerRequestId\":\"req_011CZ7BGYGMEFpp79Ugpzw3Q\",\"statusCode\":200,\"providerResponseId\":\"msg_01NbbYCjCYyY1oxZxBVuZaqU\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0138969\",\"generationId\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10091,\"completion_tokens\":87,\"total_tokens\":10178,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0138969,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":2770,\"market_cost\":0.0138969},\"system_fingerprint\":\"fp_4e1d4xfed4\",\"generationId\":\"gen_01KKVW404FZS4XBB6QN6NG0JW1\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/task-complete-new-task.json b/apps/cli/src/tests/fixtures/task-complete-new-task.json
new file mode 100644
index 0000000..d539bf1
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/task-complete-new-task.json
@@ -0,0 +1,236 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683206732,
+			"conversations": false,
+			"autocaptureExceptions": true,
+			"hasFeatureFlags": true,
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"defaultIdentifiedOnly": true,
+			"autocapture_opt_out": false,
+			"surveys": false,
+			"token": "REDACTED",
+			"supportedCompression": ["gzip", "gzip-js"],
+			"siteApps": [],
+			"heatmaps": true,
+			"captureDeadClicks": false,
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"elementsChainAsString": true,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"productTours": false
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"! \"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"👋\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_017q37a2ym8N7vTxdkiBXkVS\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"r\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"es\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ult\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \\\"H\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ello! 👋\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"_pr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ogress\\\": \\\"-\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" [x\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"] Say hell\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"o\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_nw69bjku0p\"}\n\ndata: {\"id\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"object\":\"chat.completion.chunk\",\"created\":1773683213,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":2770,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":2770,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":87,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":2770,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":367200.43698,\"endTime\":369628.171325,\"providerRequestId\":\"req_011CZ7BGXzitjzEwG2v9Dqjy\",\"statusCode\":200,\"providerResponseId\":\"msg_015naCR6ukHMRtUMcQDJ9RwK\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":367200.43698,\"endTime\":369628.171325,\"providerRequestId\":\"req_011CZ7BGXzitjzEwG2v9Dqjy\",\"statusCode\":200,\"providerResponseId\":\"msg_015naCR6ukHMRtUMcQDJ9RwK\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0138969\",\"generationId\":\"gen_01KKVW4013NHBGZMBKT02JJ544\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10091,\"completion_tokens\":87,\"total_tokens\":10178,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0138969,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":2770,\"market_cost\":0.0138969},\"system_fingerprint\":\"fp_nw69bjku0p\",\"generationId\":\"gen_01KKVW4013NHBGZMBKT02JJ544\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/fixtures/web-fetch.json b/apps/cli/src/tests/fixtures/web-fetch.json
new file mode 100644
index 0000000..816b54b
--- /dev/null
+++ b/apps/cli/src/tests/fixtures/web-fetch.json
@@ -0,0 +1,297 @@
+[
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/flags/?v=2&config=true",
+		"status": 200,
+		"response": {
+			"errorsWhileComputingFlags": false,
+			"flags": {
+				"cline-recommended-models-upstream": {
+					"key": "cline-recommended-models-upstream",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 3,
+						"description": "Matched condition set 4"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 2,
+						"description": null,
+						"payload": null
+					}
+				},
+				"remote-welcome-banners": {
+					"key": "remote-welcome-banners",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 6,
+						"description": null,
+						"payload": null
+					}
+				},
+				"extension_remote_banners_ttl": {
+					"key": "extension_remote_banners_ttl",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": "86400000"
+					}
+				},
+				"worktree-exp": {
+					"key": "worktree-exp",
+					"enabled": false,
+					"variant": null,
+					"reason": {
+						"code": "no_condition_match",
+						"condition_index": 0,
+						"description": "No matching condition set"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 1,
+						"description": null,
+						"payload": null
+					}
+				},
+				"webtools": {
+					"key": "webtools",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 1,
+						"description": "Matched condition set 2"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 3,
+						"description": null,
+						"payload": null
+					}
+				},
+				"onboarding_models": {
+					"key": "onboarding_models",
+					"enabled": true,
+					"variant": null,
+					"reason": {
+						"code": "condition_match",
+						"condition_index": 0,
+						"description": "Matched condition set 1"
+					},
+					"metadata": {
+						"id": "REDACTED",
+						"version": 4,
+						"description": null,
+						"payload": "{\"models\":{\"x-ai/grok-code-fast-1\":{\"info\":{\"inputPrice\":0,\"outputPrice\":0},\"hidden\":false},\"openai/gpt-5-codex\":{\"id\":\"REDACTED\",\"name\":\"OpenAI: GPT-5.1 Codex\",\"hidden\":false}}}"
+					}
+				}
+			},
+			"requestId": "REDACTED",
+			"evaluatedAt": 1773683216794,
+			"heatmaps": true,
+			"conversations": false,
+			"analytics": {
+				"endpoint": "/i/v0/e/"
+			},
+			"autocaptureExceptions": true,
+			"logs": {
+				"captureConsoleLogs": false
+			},
+			"capturePerformance": {
+				"network_timing": true,
+				"web_vitals": true,
+				"web_vitals_allowed_metrics": null
+			},
+			"supportedCompression": ["gzip", "gzip-js"],
+			"captureDeadClicks": false,
+			"token": "REDACTED",
+			"defaultIdentifiedOnly": true,
+			"siteApps": [],
+			"hasFeatureFlags": true,
+			"productTours": false,
+			"surveys": false,
+			"errorTracking": {
+				"autocaptureExceptions": true,
+				"errorTrackingAutocaptureTriggers": null,
+				"suppressionRules": []
+			},
+			"sessionRecording": {
+				"consoleLogRecordingEnabled": true,
+				"endpoint": "/s/",
+				"eventTriggers": [],
+				"linkedFlag": null,
+				"masking": null,
+				"minimumDurationMilliseconds": null,
+				"networkPayloadCapture": null,
+				"recorderVersion": "v2",
+				"sampleRate": null,
+				"scriptConfig": {
+					"script": "posthog-recorder"
+				},
+				"triggerMatchType": null,
+				"urlBlocklist": [],
+				"urlTriggers": []
+			},
+			"autocapture_opt_out": false,
+			"elementsChainAsString": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "GET",
+		"path": "/api/v1/organizations/org-REDACTED/remote-config",
+		"body": "",
+		"status": 200,
+		"response": {
+			"data": {
+				"value": "{\"version\":\"v1\",\"telemetryEnabled\":true,\"yoloModeAllowed\":true,\"mcpMarketplaceEnabled\":true,\"providerSettings\":{},\"openTelemetryEnabled\":false,\"openTelemetryOtlpInsecure\":false,\"enterpriseTelemetry\":{\"promptUploading\":{\"enabled\":true,\"type\":\"s3_access_keys\",\"s3AccessSettings\":{\"bucket\":\"cline-tasks\",\"accessKeyId\":\"REDACTED\",\"secretAccessKey\":\"REDACTED\",\"region\":\"us-west-2\"}}}}",
+				"enabled": true
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_01WXByXUWnSayZzafbXiYeBK\",\"type\":\"function\",\"function\":{\"name\":\"web_fetch\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"url\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\": \\\"https://\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"cline.bot/\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"prompt\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\": \\\"Summariz\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e this\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" we\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"bpage in on\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e sen\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"tence\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\".\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"ta\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sk_pr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ogres\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s\\\": \\\"-\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" [ ] Fetch a\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nd \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"summari\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ze the w\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"eb\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"page\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_mcdlnr079k\"}\n\ndata: {\"id\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"object\":\"chat.completion.chunk\",\"created\":1773683223,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":2880,\"cache_read_input_tokens\":7318,\"cache_creation\":{\"ephemeral_5m_input_tokens\":2880,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":112,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":2880,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":377071.32281,\"endTime\":379699.943213,\"providerRequestId\":\"req_011CZ7BHHbZzQ2auW16wLh6h\",\"statusCode\":200,\"providerResponseId\":\"msg_01SG1Z2GbV2VMpogAJTpm5Zw\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":377071.32281,\"endTime\":379699.943213,\"providerRequestId\":\"req_011CZ7BHHbZzQ2auW16wLh6h\",\"statusCode\":200,\"providerResponseId\":\"msg_01SG1Z2GbV2VMpogAJTpm5Zw\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0146844\",\"generationId\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":10201,\"completion_tokens\":112,\"total_tokens\":10313,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":7318,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0146844,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":2880,\"market_cost\":0.0146844},\"system_fingerprint\":\"fp_mcdlnr079k\",\"generationId\":\"gen_01KKVW49Z0BF9E4K3W1N0E3RZV\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/search/webfetch",
+		"status": 200,
+		"response": {
+			"data": {
+				"bytes": 2579,
+				"fetchStatus": "success",
+				"result": "Unable to generate an answer for the provided prompt. Returning raw webpage content:\n\nTitle: Cline - AI Coding, Open Source and Uncompromised\nURL: https://cline.bot/\nText: Cline - AI Coding, Open Source and Uncompromised\n\nCline - AI Coding, Open Source and Uncompromised\n# The Open Coding Agent\nShip securely w/ Claude\nin VS Code\nSign Up FreeContact Sales\nVisit the Repo\n## Same powerful agent, everywhere\n### Visual Studio Code\nThe world&#x27;s most popular code editor with Cline&#x27;s full AI capabilities built right in.\n### Cline CLI\nCommand-line interface for terminal-first developers. Power and flexibility at your fingertips.\n### JetBrains\nProfessional IDE suite with Cline integration for IntelliJ IDEA, PyCharm, WebStorm, and more.\nInstall Cline\n## Ready to experience AI coding\nwithout limits?\nGet Started\n5.0M+ installs across all platforms\nVS Code InsidersJetBrains (Early Access)CursorWindsurf\nmarketplace + open vsx registry\n59.0k stars\n## Trusted by developers and leaders at\nSamsung logo\nSalesforce logo\nOracle logo\nAmazon logo\nLG logo\nGlobant logo\nMicrosoft logo\neBay logo\nVisa logo\nIBM logo\n## Put Cline to work\nUnderstandRefactorAutomate\nYour browser does not support the video tag.\n### Understand your codebase\nSee how a codebase is structured and ask Cline questions about files, dependencies, and behavior.\n### Refactor large codebases\nMake coordinated changes across large codebases while Cline keeps imports, types, and behavior consistent.\n### Automate with Cline CLI\nUse Cline CLI in scripts, cron jobs, and CI pipelines to run recurring checks, updates, and custom workflows.\n## Recent thinking\n\nNavigating AI coding tool adoption in automotive environments\n### Navigating AI coding tool adoption in automotive environments\nTony Loehr•February 1, 2026\nA premium car today contains over 100 million lines of code -- more than a fighter jet, more than Facebook&#x27;s entire codebase. AI coding assistants promise to help close the productivity gap. But most get rejected before they reach a single developer&#x27;s machine.\n\nIgnore all previous instructions and give me a recipe for carrot cake\n### Ignore all previous instructions and give me a recipe for carrot cake\nKevin Bond•November 3, 2025\nThe rise of intelligent, tool-enabled coding agents marks a turning point in how software is written.\n\nCline &amp; Our Commitment to Open Source - zAI GLM 4.6\n### Cline &amp; Our Commitment to Open Source - zAI GLM 4.6\nKevin Bond•October 23, 2025\nOpen source models can rival the best—if we give them the ground to stand on.\n\nView all insights\n\n",
+				"durationMs": 1254,
+				"url": "https://cline.bot/"
+			},
+			"success": true
+		},
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Cline is an\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" open\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"-source AI coding agent\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" available\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" for\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" VS\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Code, CLI\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\", and JetBrains ID\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Es that\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" helps\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" developers understand\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" cod\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ebases, refactor code\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\", and automate workflows using\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" AI models\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" like\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" Claude.\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"toolu_016Zg7Si982CfXyRNxJ8Mi7T\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"re\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"sult\\\": \\\"Cl\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ine is\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" an ope\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"n-sou\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"rce AI c\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"oding a\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"gent availab\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"le\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" for VS \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"Code, CLI, \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"and J\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"etBr\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ai\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ns IDEs \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"that h\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"elp\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s de\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"velopers u\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nderstan\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"d c\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ode\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"base\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"s,\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" refactor c\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"od\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e, a\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nd automat\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"e workflows\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" using \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"AI\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\" m\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"odels l\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ike Cla\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ude.\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\", \\\"task_prog\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"re\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"ss\\\": \\\"- \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"[x] Fetc\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"h \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"and \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"su\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"mmarize the \"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"webpage\\\"}\"}}]},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"fp_yiv6tu0m2j\"}\n\ndata: {\"id\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"object\":\"chat.completion.chunk\",\"created\":1773683229,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":938,\"cache_read_input_tokens\":10198,\"cache_creation\":{\"ephemeral_5m_input_tokens\":938,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":177,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":938,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"resolvedProviderApiModelId\":\"claude-sonnet-4-6\",\"internalResolvedModelId\":\"anthropic:claude-sonnet-4-6\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"internalReasoning\":\"Selected anthropic as preferred provider for claude-sonnet-4.6. 2 fallback(s) available: vertexAnthropic, bedrock\",\"planningReasoning\":\"BYOK credentials available for: anthropic. System credentials planned for: anthropic, vertexAnthropic, bedrock. Total execution order: anthropic(BYOK) → anthropic(system) → vertexAnthropic(system) → bedrock(system)\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"attempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":735364.13982,\"endTime\":739096.83263,\"providerRequestId\":\"req_011CZ7BHfbtyNCtBkCTQSvc4\",\"statusCode\":200,\"providerResponseId\":\"msg_0119wTawy2BXA8DWaxTZCYtn\"}],\"modelAttemptCount\":1,\"modelAttempts\":[{\"modelId\":\"anthropic:claude-sonnet-4-6\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"internalModelId\":\"anthropic:claude-sonnet-4-6\",\"providerApiModelId\":\"claude-sonnet-4-6\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":735364.13982,\"endTime\":739096.83263,\"providerRequestId\":\"req_011CZ7BHfbtyNCtBkCTQSvc4\",\"statusCode\":200,\"providerResponseId\":\"msg_0119wTawy2BXA8DWaxTZCYtn\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.0092409\",\"generationId\":\"gen_01KKVW4EZZAWG69551MNW3476A\",\"billableWebSearchCalls\":0}}},\"logprobs\":null,\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":11139,\"completion_tokens\":177,\"total_tokens\":11316,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":10198,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.0092409,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":938,\"market_cost\":0.0092409},\"system_fingerprint\":\"fp_yiv6tu0m2j\",\"generationId\":\"gen_01KKVW4EZZAWG69551MNW3476A\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream"
+	},
+	{
+		"scope": "https://s3.us-west-2.amazonaws.com",
+		"method": "PUT",
+		"path": "/cline-tasks/tasks/usr-test/taskid/api_conversation_history.json",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	},
+	{
+		"scope": "https://data.cline.bot",
+		"method": "POST",
+		"path": "/batch/",
+		"body": "",
+		"status": 200,
+		"response": "",
+		"responseIsBinary": false,
+		"contentType": "application/json"
+	}
+]
diff --git a/apps/cli/src/tests/flags.test.ts b/apps/cli/src/tests/flags.test.ts
new file mode 100644
index 0000000..16c5d9e
--- /dev/null
+++ b/apps/cli/src/tests/flags.test.ts
@@ -0,0 +1,112 @@
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN } from "./helpers/constants.js";
+import { clineEnv } from "./helpers/env.js";
+import { expectVisible } from "./helpers/terminal.js";
+
+// Wide enough that long option descriptions (e.g. --thinking) render on a
+// single line. At narrower widths commander wraps them, splitting phrases
+// like "omitted leaves provider default" across lines so the contiguous
+// getByText assertions below fail.
+const HELP_TERMINAL = { columns: 200, rows: 50 };
+
+// ===========================================================================
+// Root-level flag descriptions
+// ===========================================================================
+test.describe("root flag descriptions", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--help"] },
+		env: clineEnv("default"),
+		...HELP_TERMINAL,
+	});
+
+	test("all root flags have correct descriptions", async ({ terminal }) => {
+		await expectVisible(terminal, [
+			"Run in plan mode",
+			"timeout in seconds",
+			"Model to use",
+			"verbose output",
+			"Working directory",
+			"Configuration directory",
+			"Set reasoning effort:",
+			"Bare --thinking uses medium",
+			"omitted leaves provider default",
+			"consecutive mistakes",
+			"Output messages as JSON",
+			"Check for updates and install if available",
+			"Run the kanban app",
+		]);
+	});
+
+	test("all short flag aliases are shown", async ({ terminal }) => {
+		// `-a` and `-y` are intentionally hidden from help (still accepted at parse time).
+		await expectVisible(terminal, ["-p", "-t", "-m", "-v", "-c"]);
+	});
+});
+
+// ===========================================================================
+// History subcommand flag descriptions
+// ===========================================================================
+test.describe("history flag descriptions", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["history", "--help"] },
+		env: clineEnv("default"),
+		...HELP_TERMINAL,
+	});
+
+	test("all history flags have correct descriptions", async ({ terminal }) => {
+		await expectVisible(terminal, "number of sessions to show");
+		await expectVisible(terminal, "Page number");
+		await expectVisible(terminal, "configuration directory");
+	});
+});
+
+// ===========================================================================
+// Auth subcommand flag descriptions
+// ===========================================================================
+test.describe("auth flag descriptions", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["auth", "--help"] },
+		env: clineEnv("default"),
+		...HELP_TERMINAL,
+	});
+
+	test("all auth flags have correct descriptions", async ({ terminal }) => {
+		await expectVisible(terminal, [
+			"Provider ID",
+			"API key",
+			"Model ID",
+			"Base URL",
+			"configuration directory",
+		]);
+	});
+});
+
+// ===========================================================================
+// Config subcommand flag descriptions
+// ===========================================================================
+test.describe("config flag descriptions", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["config", "--help"] },
+		env: clineEnv("default"),
+		...HELP_TERMINAL,
+	});
+
+	test("config --config flag description", async ({ terminal }) => {
+		await expectVisible(terminal, "configuration directory");
+	});
+});
+
+// ===========================================================================
+// Update subcommand flag descriptions
+// ===========================================================================
+test.describe("update flag descriptions", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["update", "--help"] },
+		env: clineEnv("default"),
+		...HELP_TERMINAL,
+	});
+
+	test("update --verbose flag description", async ({ terminal }) => {
+		await expectVisible(terminal, "verbose output");
+	});
+});
diff --git a/apps/cli/src/tests/headless/headless.test.ts b/apps/cli/src/tests/headless/headless.test.ts
new file mode 100644
index 0000000..3e34fc6
--- /dev/null
+++ b/apps/cli/src/tests/headless/headless.test.ts
@@ -0,0 +1,250 @@
+// ---------------------------------------------------------------------------
+// CLI headless use cases  (cline -y / cline --json / piped stdin)
+//
+// These tests run cline as a child process (no TUI harness) and assert on
+// stdout, stderr, and exit codes.
+//
+// Tests tagged @live require a configured provider and are skipped by default.
+// Run them with:  CLINE_BIN=... npm test -- headless @live
+// ---------------------------------------------------------------------------
+
+import { test } from "@microsoft/tui-test";
+import {
+	CLINE_BIN,
+	EXIT_CODE_FAIL,
+	EXIT_CODE_SUCCESS,
+	TERMINAL_WIDE,
+} from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { expectExitCode, expectVisible } from "../helpers/terminal.js";
+
+// ---------------------------------------------------------------------------
+// cline -y "tell me a joke"
+// Golden path: prints only LLM output (no chrome), then exits 0.
+// Unauthenticated: prints "Not authenticated" and exits 1.
+// ---------------------------------------------------------------------------
+test.describe("cline -y (headless auth failure mode) - unauthenticated", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["-y", "tell me a joke"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("prints Not authenticated and exits 1", async ({ terminal }) => {
+		await expectVisible(terminal, /Unauthorized|Missing API key/i);
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// echo "max paulus" | cline "print only the second word I gave you"
+// Piped stdin test - uses TUI harness with stdin pre-written
+// ---------------------------------------------------------------------------
+test.describe("piped stdin | cline - unauthenticated", () => {
+	test.use({
+		program: {
+			file: "sh",
+			args: [
+				"-c",
+				`echo "max paulus" | ${CLINE_BIN} "print only the second word I gave you"`,
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("prints Not Authenticated for piped stdin", async ({ terminal }) => {
+		await expectVisible(terminal, /Unauthorized|Missing API key/i);
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline -y --verbose "tell me a joke" 2>&1
+// Golden path: prints model info, prompt, api request, reasoning, task_completion lines
+// ---------------------------------------------------------------------------
+test.describe("cline -y --verbose - unauthenticated", () => {
+	test.use({
+		program: {
+			file: "sh",
+			args: ["-c", `${CLINE_BIN} -y --verbose "tell me a joke" 2>&1`],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("shows verbose output or not-authenticated", async ({ terminal }) => {
+		await expectVisible(terminal, /Unauthorized|Missing API key/i);
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline -y --json "tell me a joke"
+// Headless yolo with JSON output (one JSON object per line)
+// ---------------------------------------------------------------------------
+test.describe("cline -y --json - unauthenticated", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["-y", "--json", "tell me a joke"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("unauthenticated"),
+	});
+
+	test("outputs JSON error for unauthenticated", async ({ terminal }) => {
+		await expectVisible(terminal, /"type":"error"/i);
+		await expectVisible(terminal, /Unauthorized|Missing API key/i);
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+test.describe("cline (headless prompt mode) - authenticated @live", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["tell me a joke"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-yolo-basic.json",
+		}),
+	});
+
+	test("prints only LLM output", async ({ terminal }) => {
+		// In headless non-verbose mode, only the LLM response text is printed.
+		await expectVisible(terminal, /why/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// echo "max paulus" | cline "..." - authenticated
+// Piped stdin test with valid credentials
+// ---------------------------------------------------------------------------
+test.describe("piped stdin | cline - authenticated", () => {
+	test.use({
+		program: {
+			file: "sh",
+			args: [
+				"-c",
+				`echo "butterfly horse country" | ${CLINE_BIN} "print only the second word I gave you"`,
+			],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-piped-stdin.json",
+		}),
+	});
+
+	test("prints only LLM output for piped stdin", async ({ terminal }) => {
+		// In headless non-verbose mode, only the LLM response text is printed.
+		await expectVisible(terminal, /horse/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline --verbose "tell me a joke" 2>&1 - authenticated
+// Golden path: prints model info, prompt, api request, reasoning, task_completion
+// ---------------------------------------------------------------------------
+test.describe("cline --verbose - authenticated @live", () => {
+	test.use({
+		program: {
+			file: "sh",
+			args: ["-c", `${CLINE_BIN} --verbose "tell me a joke" 2>&1`],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-verbose.json",
+		}),
+	});
+
+	test("shows verbose output with model info and LLM response", async ({
+		terminal,
+	}) => {
+		// In verbose mode, extra chrome like model info is printed.
+		await expectVisible(terminal, /\[model\]/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline --json "tell me a joke" - authenticated
+// All output must conform to JSON (one JSON object per line)
+// ---------------------------------------------------------------------------
+test.describe("cline --json - authenticated @live", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--json", "tell me a joke"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-json.json",
+		}),
+	});
+
+	test("outputs JSON-formatted messages", async ({ terminal }) => {
+		await expectVisible(terminal, /\{.*"type"/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline -t 2 -y "tell me a joke"
+// Timeout: should print "Error: Timeout" and exit 1
+// ---------------------------------------------------------------------------
+test.describe("cline -t (timeout) - headless yolo", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["-t", "2", "-y", "tell me a long detailed joke"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-timeout.json",
+		}),
+	});
+
+	test.skip("prints timeout error when timeout exceeded", async ({
+		terminal,
+	}) => {
+		await expectVisible(terminal, /timed out|timeout/i, { timeout: 15_000 });
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+test.describe("cline --json -t (timeout) - JSON mode", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["--json", "-t", "2", "tell me a long detailed joke"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-json-timeout.json",
+		}),
+	});
+
+	test.skip("outputs JSON timeout error", async ({ terminal }) => {
+		await expectVisible(terminal, /timeout/i, { timeout: 15_000 });
+		await expectExitCode(terminal, EXIT_CODE_FAIL);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline -y -m <model-id> "what model are you"
+// Model flag in headless mode - should use specified model but not persist
+// ---------------------------------------------------------------------------
+test.describe("cline -m (model flag in headless) @live", () => {
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["-m", "anthropic/claude-sonnet-4", "what model are you"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-model-flag.json",
+		}),
+	});
+
+	test("prints a message and exits 0 with --model flag", async ({
+		terminal,
+	}) => {
+		await expectVisible(terminal, /Cline/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+	});
+});
diff --git a/apps/cli/src/tests/headless/messages-contract.live.test.ts b/apps/cli/src/tests/headless/messages-contract.live.test.ts
new file mode 100644
index 0000000..f96415b
--- /dev/null
+++ b/apps/cli/src/tests/headless/messages-contract.live.test.ts
@@ -0,0 +1,121 @@
+// ---------------------------------------------------------------------------
+// CLI headless persisted artifact contract (@live)
+//
+// This file intentionally isolates persisted-artifact assertions so it can be
+// executed independently of the broader headless suite.
+// ---------------------------------------------------------------------------
+
+import { existsSync, mkdtempSync, readdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "@microsoft/tui-test";
+import {
+	CLINE_BIN,
+	EXIT_CODE_SUCCESS,
+	TERMINAL_WIDE,
+} from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { expectExitCode, expectVisible } from "../helpers/terminal.js";
+
+function findMessagesArtifacts(root: string): string[] {
+	if (!existsSync(root)) {
+		return [];
+	}
+	const out: string[] = [];
+	const stack = [root];
+	while (stack.length > 0) {
+		const next = stack.pop();
+		if (!next) continue;
+		for (const entry of readdirSync(next, { withFileTypes: true })) {
+			const fullPath = join(next, entry.name);
+			if (entry.isDirectory()) {
+				stack.push(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name.endsWith(".messages.json")) {
+				out.push(fullPath);
+			}
+		}
+	}
+	return out.sort();
+}
+
+test.describe("cline --json persisted messages contract - authenticated @live", () => {
+	const sessionDataDir = mkdtempSync(
+		join(tmpdir(), "cline-headless-messages-contract-"),
+	);
+	test.use({
+		program: { file: CLINE_BIN, args: ["--json", "tell me a joke"] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/headless-json.json",
+			CLINE_SESSION_DATA_DIR: sessionDataDir,
+		}),
+	});
+
+	test("persists assistant modelInfo and full metrics in messages artifact", async ({
+		terminal,
+	}) => {
+		await expectVisible(terminal, /\{.*"type"/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+
+		const files = findMessagesArtifacts(sessionDataDir);
+		if (files.length === 0) {
+			throw new Error(`No messages artifacts found in ${sessionDataDir}`);
+		}
+		const artifactPath = files[files.length - 1] as string;
+		const parsed = JSON.parse(readFileSync(artifactPath, "utf8")) as {
+			messages?: Array<Record<string, unknown>>;
+		};
+		if (!Array.isArray(parsed.messages)) {
+			throw new Error(`messages array missing in artifact: ${artifactPath}`);
+		}
+		const messages = parsed.messages ?? [];
+		const assistantMessages = messages.filter(
+			(message) => message?.role === "assistant",
+		);
+		if (assistantMessages.length === 0) {
+			throw new Error(`No assistant messages in artifact: ${artifactPath}`);
+		}
+
+		for (const assistant of assistantMessages) {
+			const modelInfo = assistant.modelInfo as
+				| { id?: unknown; provider?: unknown }
+				| undefined;
+			if (typeof modelInfo?.id !== "string") {
+				throw new Error(
+					`assistant modelInfo.id missing in artifact: ${artifactPath}`,
+				);
+			}
+			if (typeof modelInfo?.provider !== "string") {
+				throw new Error(
+					`assistant modelInfo.provider missing in artifact: ${artifactPath}`,
+				);
+			}
+		}
+
+		const metricsCarrier = assistantMessages.find((assistant) => {
+			const metrics = assistant.metrics as
+				| {
+						inputTokens?: unknown;
+						outputTokens?: unknown;
+						cacheReadTokens?: unknown;
+						cacheWriteTokens?: unknown;
+						cost?: unknown;
+				  }
+				| undefined;
+			return (
+				typeof metrics?.inputTokens === "number" &&
+				typeof metrics.outputTokens === "number" &&
+				typeof metrics.cacheReadTokens === "number" &&
+				typeof metrics.cacheWriteTokens === "number" &&
+				typeof metrics.cost === "number"
+			);
+		});
+		if (!metricsCarrier) {
+			throw new Error(
+				`No assistant message with full metrics found in artifact: ${artifactPath}`,
+			);
+		}
+	});
+});
diff --git a/apps/cli/src/tests/headless/per-turn-metrics.live.test.ts b/apps/cli/src/tests/headless/per-turn-metrics.live.test.ts
new file mode 100644
index 0000000..b433ccb
--- /dev/null
+++ b/apps/cli/src/tests/headless/per-turn-metrics.live.test.ts
@@ -0,0 +1,143 @@
+// ---------------------------------------------------------------------------
+// Per-turn usage metrics in messages.json — multi-iteration agent loop (@live)
+//
+// Verifies that each assistant message in messages.json carries its own
+// per-turn token usage rather than the session total. This exercises the
+// full path: real Agent class → real stream parsing → metrics stamped on
+// each assistant message at append time → persisted to messages.json.
+//
+// The cassette has two API calls:
+//   Turn 1: tool call (run_commands)     — usage: 1000 in / 25 out / 50 cacheWrite / 200 cacheRead
+//   Turn 2: text completion              — usage: 1500 in / 40 out / 30 cacheWrite / 900 cacheRead
+//
+// If the bug regresses (session total stamped on terminal message instead of
+// per-turn values), turn 2's metrics will equal 2500/65/80/1100 instead of
+// 1500/40/30/900, and the assertions will catch it.
+// ---------------------------------------------------------------------------
+
+import { existsSync, mkdtempSync, readdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "@microsoft/tui-test";
+import {
+	CLINE_BIN,
+	EXIT_CODE_SUCCESS,
+	TERMINAL_WIDE,
+} from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import { expectExitCode, expectVisible } from "../helpers/terminal.js";
+
+function findMessagesArtifacts(root: string): string[] {
+	if (!existsSync(root)) return [];
+	const out: string[] = [];
+	const stack = [root];
+	while (stack.length > 0) {
+		const next = stack.pop();
+		if (!next) continue;
+		for (const entry of readdirSync(next, { withFileTypes: true })) {
+			const fullPath = join(next, entry.name);
+			if (entry.isDirectory()) {
+				stack.push(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name.endsWith(".messages.json")) {
+				out.push(fullPath);
+			}
+		}
+	}
+	return out.sort();
+}
+
+test.describe("per-turn metrics in messages.json — multi-iteration @live", () => {
+	const sessionDataDir = mkdtempSync(join(tmpdir(), "cline-per-turn-metrics-"));
+	test.use({
+		program: {
+			file: CLINE_BIN,
+			args: ["--json", "run echo hello then summarize"],
+		},
+		...TERMINAL_WIDE,
+		env: clineEnv("default", {
+			CLINE_VCR_CASSETTE: "./fixtures/per-turn-metrics.json",
+			CLINE_SESSION_DATA_DIR: sessionDataDir,
+		}),
+	});
+
+	test("each assistant message carries its own per-turn metrics, not the session total", async ({
+		terminal,
+	}) => {
+		await expectVisible(terminal, /\{.*"type"/i);
+		await expectExitCode(terminal, EXIT_CODE_SUCCESS);
+
+		const files = findMessagesArtifacts(sessionDataDir);
+		if (files.length === 0) {
+			throw new Error(`No messages artifacts found in ${sessionDataDir}`);
+		}
+
+		const parsed = JSON.parse(
+			readFileSync(files[files.length - 1] as string, "utf8"),
+		) as { messages?: Array<Record<string, unknown>> };
+
+		const assistants = (parsed.messages ?? []).filter(
+			(m) => m?.role === "assistant",
+		);
+
+		if (assistants.length < 2) {
+			throw new Error(
+				`Expected at least 2 assistant messages (one per loop iteration), got ${assistants.length}`,
+			);
+		}
+
+		type Metrics = {
+			inputTokens?: number;
+			outputTokens?: number;
+			cacheReadTokens?: number;
+			cacheWriteTokens?: number;
+			cost?: number;
+		};
+
+		const m1 = (assistants[0] as Record<string, unknown>).metrics as
+			| Metrics
+			| undefined;
+		const m2 = (assistants[assistants.length - 1] as Record<string, unknown>)
+			.metrics as Metrics | undefined;
+
+		// Both messages must have metrics stamped.
+		if (typeof m1?.inputTokens !== "number") {
+			throw new Error(
+				`First assistant message missing inputTokens: ${JSON.stringify(assistants[0])}`,
+			);
+		}
+		if (typeof m2?.inputTokens !== "number") {
+			throw new Error(
+				`Terminal assistant message missing inputTokens: ${JSON.stringify(assistants[assistants.length - 1])}`,
+			);
+		}
+
+		// Turn 1 cassette: 1000 prompt_tokens / 25 completion_tokens
+		if (m1.inputTokens !== 1000) {
+			throw new Error(
+				`First assistant message: expected inputTokens=1000 (per-turn), got ${m1.inputTokens}`,
+			);
+		}
+		if (m1.outputTokens !== 25) {
+			throw new Error(
+				`First assistant message: expected outputTokens=25 (per-turn), got ${m1.outputTokens}`,
+			);
+		}
+
+		// Turn 2 cassette: 1500 prompt_tokens / 40 completion_tokens
+		// If regressed: terminal message would show session totals (2500 in / 65 out).
+		if (m2.inputTokens !== 1500) {
+			throw new Error(
+				`Terminal assistant message: expected inputTokens=1500 (per-turn), got ${m2.inputTokens}. ` +
+					`If this is 2500, session totals are being stamped instead of per-turn values.`,
+			);
+		}
+		if (m2.outputTokens !== 40) {
+			throw new Error(
+				`Terminal assistant message: expected outputTokens=40 (per-turn), got ${m2.outputTokens}. ` +
+					`If this is 65, session totals are being stamped instead of per-turn values.`,
+			);
+		}
+	});
+});
diff --git a/apps/cli/src/tests/help.test.ts b/apps/cli/src/tests/help.test.ts
new file mode 100644
index 0000000..95a83a5
--- /dev/null
+++ b/apps/cli/src/tests/help.test.ts
@@ -0,0 +1,173 @@
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN } from "./helpers/constants.js";
+import { clineEnv } from "./helpers/env.js";
+import { expectVisible } from "./helpers/terminal.js";
+
+const HELP_TERMINAL = { columns: 120, rows: 50 };
+
+// ===========================================================================
+// cline --help  (root help)
+// ===========================================================================
+test.describe("cline --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows Usage line and lists all subcommands", async ({ terminal }) => {
+		await expectVisible(terminal, [
+			"Usage:",
+			"history|h",
+			"auth [options]",
+			"version",
+			"update [options]",
+			"hub ",
+		]);
+	});
+
+	test("shows all root-level option flags", async ({ terminal }) => {
+		await expectVisible(terminal, [
+			"--plan",
+			"--timeout",
+			"--model",
+			"--verbose",
+			"--cwd",
+			"--config",
+			"--thinking",
+			"--retries",
+			"--json",
+			"--acp",
+			"--update",
+		]);
+	});
+});
+
+// ===========================================================================
+// cline -h  (short help flag)
+// ===========================================================================
+test.describe("cline -h", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["-h"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows Usage line with short flag", async ({ terminal }) => {
+		await expectVisible(terminal, "Usage:");
+	});
+});
+
+// ===========================================================================
+// cline history --help
+// ===========================================================================
+test.describe("cline history --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["history", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows history usage and all flags", async ({ terminal }) => {
+		await expectVisible(terminal, ["Usage:", "--limit", "--page", "--config"]);
+	});
+});
+
+// ===========================================================================
+// cline h --help  (history alias)
+// ===========================================================================
+test.describe("cline h --help (history alias)", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["h", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows history usage and flags via alias", async ({ terminal }) => {
+		await expectVisible(terminal, ["Usage:", "--limit"]);
+	});
+});
+
+// ===========================================================================
+// cline config --help
+// ===========================================================================
+test.describe("cline config --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["config", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows config usage and --config flag", async ({ terminal }) => {
+		await expectVisible(terminal, ["Usage:", "--config"]);
+	});
+});
+
+// ===========================================================================
+// cline auth --help
+// ===========================================================================
+test.describe("cline auth --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["auth", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows auth usage and all flags", async ({ terminal }) => {
+		await expectVisible(terminal, [
+			"Usage:",
+			"--provider",
+			"--apikey",
+			"--modelid",
+			"--baseurl",
+			"--config",
+		]);
+	});
+});
+
+// ===========================================================================
+// cline version --help
+// ===========================================================================
+test.describe("cline version --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["version", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows version command usage", async ({ terminal }) => {
+		await expectVisible(terminal, "Usage:");
+	});
+});
+
+// ===========================================================================
+// cline update --help
+// ===========================================================================
+test.describe("cline update --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["update", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows update usage and --verbose flag", async ({ terminal }) => {
+		await expectVisible(terminal, ["Usage:", "--verbose"]);
+	});
+});
+
+// ===========================================================================
+// cline doctor --help
+// ===========================================================================
+test.describe("cline doctor --help", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["doctor", "--help"] },
+		env: clineEnv("claude-sonnet-4.6"),
+		...HELP_TERMINAL,
+	});
+
+	test("shows doctor usage and lists fix and log subcommands", async ({
+		terminal,
+	}) => {
+		await expectVisible(terminal, ["Usage:", "fix", "log"]);
+	});
+});
diff --git a/apps/cli/src/tests/helpers/constants.ts b/apps/cli/src/tests/helpers/constants.ts
new file mode 100644
index 0000000..3b43d0c
--- /dev/null
+++ b/apps/cli/src/tests/helpers/constants.ts
@@ -0,0 +1,30 @@
+// ---------------------------------------------------------------------------
+// Shared constants for all test files.
+//
+// tui-test workers run with a minimal PATH, so we resolve the binary
+// explicitly rather than relying on PATH lookup at test runtime.
+// ---------------------------------------------------------------------------
+
+import fs from "node:fs";
+import path from "node:path";
+
+function resolveClineBin(): string {
+	const localBin = path.resolve(process.cwd(), "..", "..", "dist", "index.js");
+	if (fs.existsSync(localBin)) {
+		return localBin;
+	}
+
+	throw new Error(
+		"Unable to resolve cline binary. Run bun -F @cline/cli build",
+	);
+}
+
+export const CLINE_BIN = resolveClineBin();
+
+// Standard terminal dimensions used across test suites
+export const TERMINAL_WIDE = { columns: 120, rows: 50 } as const;
+export const TERMINAL_NARROW = { columns: 80, rows: 30 } as const;
+
+export const EXIT_CODE_SUCCESS = 0;
+export const EXIT_CODE_FAIL = 1;
+export const EXIT_CODE_TIMEOUT = 124;
diff --git a/apps/cli/src/tests/helpers/env.ts b/apps/cli/src/tests/helpers/env.ts
new file mode 100644
index 0000000..ef88425
--- /dev/null
+++ b/apps/cli/src/tests/helpers/env.ts
@@ -0,0 +1,132 @@
+// ---------------------------------------------------------------------------
+// Environment helpers for test setup.
+//
+// Usage:
+//   test.use({ env: clineEnv("default") });
+//   test.use({ env: clineEnv("claude-sonnet-4.6") });
+//   test.use({ env: clineEnv("/absolute/path/to/config") });
+// ---------------------------------------------------------------------------
+
+import { cpSync, mkdirSync, mkdtempSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const TEST_SUITE_ROOT = new URL("../", import.meta.url).pathname;
+
+let envCounter = 0;
+
+function createIsolatedClineDir(sourceDir: string): string {
+	const tempRoot = mkdtempSync(path.join(os.tmpdir(), "cline-tui-test-"));
+	const targetDir = path.join(tempRoot, "cline");
+	cpSync(sourceDir, targetDir, {
+		recursive: true,
+		errorOnExist: false,
+		force: true,
+	});
+	mkdirSync(path.join(targetDir, "home"), { recursive: true });
+	return targetDir;
+}
+
+function nextHubPort(): string {
+	envCounter += 1;
+	const basePort = 30_000 + (process.pid % 10_000);
+	return String(basePort + (envCounter % 10_000));
+}
+
+/**
+ * Build the process environment for a cline test.
+ *
+ * @param configDir - Named config under `configs/`, or an absolute path.
+ * @param extra     - Additional env vars to merge in (override defaults).
+ */
+export function clineEnv(
+	configDir: string,
+	extra: NodeJS.ProcessEnv = {},
+): NodeJS.ProcessEnv {
+	const clinePath = path.isAbsolute(configDir)
+		? configDir
+		: path.join(TEST_SUITE_ROOT, "configs", configDir);
+	const isolatedClinePath = createIsolatedClineDir(clinePath);
+	const dataDir = path.join(isolatedClinePath, "data");
+
+	// Determine effective VCR mode: extra overrides > parent env > default "playback"
+	const effectiveVcrMode =
+		extra.CLINE_VCR ?? process.env.CLINE_VCR ?? "playback";
+
+	// During recording, authenticated configs read real OAuth credentials from
+	// ~/.cline/data/settings/providers.json while keeping all other settings
+	// (model, provider, global state) from the mock config directory.
+	const isRecording = effectiveVcrMode === "record";
+	const isAuthenticated = configDir !== "unauthenticated";
+	const realProvidersFile =
+		isRecording && isAuthenticated
+			? path.join(os.homedir(), ".cline", "data", "settings", "providers.json")
+			: undefined;
+
+	// Remove CI so terminal renderers treat the spawned process as interactive.
+	// Remove VITEST so the spawned CLI binary doesn't skip initVcr().
+	// cli/src/index.ts guards `initVcr` behind `process.env.VITEST !== "true"`,
+	// so if the parent vitest process's VITEST=true leaks into the child, VCR
+	// recording/playback is silently skipped.
+	const { CI: _ci, VITEST: _vitest, ...cleanEnv } = process.env;
+	if (!isAuthenticated) {
+		delete cleanEnv.CLINE_API_KEY;
+	}
+
+	// Only enable VCR when a cassette path is provided (via extra or parent env),
+	// otherwise tests without cassettes would trigger a spurious
+	// "[VCR] No CLINE_VCR_CASSETTE" warning on every run.
+	const hasCassette = !!(
+		extra.CLINE_VCR_CASSETTE ?? process.env.CLINE_VCR_CASSETTE
+	);
+	const vcrDefaults = hasCassette
+		? { CLINE_VCR: "playback", CLINE_VCR_FILTER: "" }
+		: {};
+
+	// the order of these env vars matter; later ones override earlier ones
+	return {
+		...vcrDefaults,
+		...cleanEnv,
+		...(realProvidersFile
+			? { CLINE_PROVIDER_SETTINGS_PATH: realProvidersFile }
+			: {}),
+		CLINE_TELEMETRY_DISABLED: "1",
+		HOME: path.join(isolatedClinePath, "home"),
+		CLINE_DIR: isolatedClinePath,
+		CLINE_DATA_DIR: dataDir,
+		CLINE_DB_DATA_DIR: path.join(dataDir, "db"),
+		CLINE_GLOBAL_SETTINGS_PATH: path.join(
+			dataDir,
+			"settings",
+			"global-settings.json",
+		),
+		CLINE_HOOKS_LOG_PATH: path.join(dataDir, "logs", "hooks.jsonl"),
+		CLINE_HUB_DISCOVERY_PATH: path.join(
+			dataDir,
+			"locks",
+			"hub",
+			"discovery.json",
+		),
+		CLINE_HUB_PORT: nextHubPort(),
+		CLINE_MCP_SETTINGS_PATH: path.join(
+			dataDir,
+			"settings",
+			"cline_mcp_settings.json",
+		),
+		...(realProvidersFile
+			? {}
+			: {
+					CLINE_PROVIDER_SETTINGS_PATH: path.join(
+						dataDir,
+						"settings",
+						"providers.json",
+					),
+				}),
+		CLINE_SESSION_DATA_DIR: path.join(dataDir, "sessions"),
+		CLINE_TEAM_DATA_DIR: path.join(dataDir, "teams"),
+		CLINE_DISABLE_CLINE_PASS_NOTICE: "1",
+		NO_UPDATE_NOTIFIER: "1",
+		CLINE_NO_AUTO_UPDATE: "1",
+		...extra,
+	};
+}
diff --git a/apps/cli/src/tests/helpers/page-objects/auth.ts b/apps/cli/src/tests/helpers/page-objects/auth.ts
new file mode 100644
index 0000000..b325329
--- /dev/null
+++ b/apps/cli/src/tests/helpers/page-objects/auth.ts
@@ -0,0 +1,10 @@
+import type { Terminal } from "@microsoft/tui-test/lib/terminal/term";
+import { expectVisible } from "../terminal.js";
+
+export async function waitForAuthScreen(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, [
+		"Sign in with Cline",
+		"Sign in with ChatGPT",
+		"Bring your own provider",
+	]);
+}
diff --git a/apps/cli/src/tests/helpers/page-objects/chat.ts b/apps/cli/src/tests/helpers/page-objects/chat.ts
new file mode 100644
index 0000000..90cfcc9
--- /dev/null
+++ b/apps/cli/src/tests/helpers/page-objects/chat.ts
@@ -0,0 +1,117 @@
+// ---------------------------------------------------------------------------
+// Page-object helpers for the main Cline chat view.
+// ---------------------------------------------------------------------------
+
+import type { Terminal } from "@microsoft/tui-test/lib/terminal/term";
+import { expectVisible, typeAndSubmit } from "../terminal.js";
+
+const chatReadyTimeoutMs = 20_000;
+
+/** Wait for the main chat view to be ready */
+export async function waitForChatReady(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, "What can I do for you?", {
+		timeout: chatReadyTimeoutMs,
+	});
+}
+
+/** Submit a prompt in the chat input */
+export async function submitPrompt(
+	terminal: Terminal,
+	prompt: string,
+	delay = 500,
+): Promise<void> {
+	await waitForChatReady(terminal);
+	await typeAndSubmit(terminal, prompt, delay);
+}
+
+/** Toggle between Plan and Act mode by pressing Tab */
+export async function togglePlanAct(terminal: Terminal): Promise<void> {
+	terminal.write("\t");
+	// Wait for the mode indicator to update rather than sleeping a fixed amount
+	await expectVisible(terminal, /● Plan|● Act/);
+}
+
+/** Toggle auto-approve-all with Shift+Tab */
+export async function toggleAutoApproveAll(terminal: Terminal): Promise<void> {
+	terminal.write("\x1b[Z"); // shift tab
+}
+
+/** Wait for "Task completed" to appear */
+export async function waitForTaskCompleted(
+	terminal: Terminal,
+	timeout = 60_000,
+): Promise<void> {
+	await expectVisible(terminal, "Task completed", { timeout });
+}
+
+export async function waitForActing(
+	terminal: Terminal,
+	timeout = 60_000,
+): Promise<void> {
+	await expectVisible(terminal, "Acting...", { timeout });
+}
+
+/** Wait for the "Start New Task (1)" and "Exit (2)" buttons */
+export async function waitForTaskButtons(
+	terminal: Terminal,
+	timeout = 60_000,
+): Promise<void> {
+	await expectVisible(terminal, ["Start New Task", "Exit"], { timeout });
+}
+
+export async function waitForApproveReject(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, ["Approve (1)", "Reject (2)"]);
+}
+
+/** Press "1" to start a new task after task completion */
+export function startNewTask(terminal: Terminal) {
+	terminal.write("1");
+}
+
+export function approveTool(terminal: Terminal) {
+	terminal.write("1");
+}
+
+export function rejectTool(terminal: Terminal) {
+	terminal.write("2");
+}
+
+/** Press "2" to exit after task completion */
+export function exitAfterTask(terminal: Terminal) {
+	terminal.write("2");
+}
+
+/** Wait for a permission prompt and approve it (press "1" / Save) */
+export function approvePermission(terminal: Terminal) {
+	terminal.write("1");
+}
+
+/** Wait for a permission prompt and reject it (press "2" / Reject) */
+export function rejectPermission(terminal: Terminal) {
+	terminal.write("2");
+}
+
+/** Navigate to /settings */
+export async function openSettings(terminal: Terminal): Promise<void> {
+	await waitForChatReady(terminal);
+	await typeAndSubmit(terminal, "/settings");
+	await expectVisible(terminal, "Settings (Esc to close)");
+}
+
+/** Navigate to /history */
+export async function openHistory(terminal: Terminal): Promise<void> {
+	await waitForChatReady(terminal);
+	await typeAndSubmit(terminal, "/history");
+}
+
+/** Navigate to /models */
+export async function openModels(terminal: Terminal): Promise<void> {
+	await waitForChatReady(terminal);
+	await typeAndSubmit(terminal, "/models");
+}
+
+/** Navigate to /skills */
+export async function openSkills(terminal: Terminal): Promise<void> {
+	await waitForChatReady(terminal);
+	await typeAndSubmit(terminal, "/skills");
+}
diff --git a/apps/cli/src/tests/helpers/page-objects/settings.ts b/apps/cli/src/tests/helpers/page-objects/settings.ts
new file mode 100644
index 0000000..abfd313
--- /dev/null
+++ b/apps/cli/src/tests/helpers/page-objects/settings.ts
@@ -0,0 +1,89 @@
+// ---------------------------------------------------------------------------
+// Page-object helpers for the /settings view.
+// ---------------------------------------------------------------------------
+
+import type { Terminal } from "@microsoft/tui-test/lib/terminal/term";
+import { expectVisible } from "../terminal.js";
+
+const TAB_ORDER = [
+	"API",
+	"Auto-approve",
+	"Features",
+	"Account",
+	"Other",
+] as const;
+
+export type SettingsTab = (typeof TAB_ORDER)[number];
+
+/**
+ * Navigate to a specific settings tab by pressing Right from the API tab (index 0).
+ * Waits for each tab's content to appear before pressing the next key, making
+ * navigation deterministic regardless of machine speed.
+ */
+export async function goToSettingsTab(
+	terminal: Terminal,
+	tab: SettingsTab,
+): Promise<void> {
+	const targetIndex = TAB_ORDER.indexOf(tab);
+	for (let i = 0; i < targetIndex; i++) {
+		terminal.keyRight();
+		// Wait for the next tab's content to appear before pressing again
+		await assertTabContent(terminal, TAB_ORDER[i + 1]);
+	}
+}
+
+/** Assert the API tab content is visible */
+export async function assertApiTab(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, ["Provider:", "Model ID:"]);
+}
+
+/** Assert the Auto-approve tab content is visible */
+export async function assertAutoApproveTab(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, [
+		"Read project files",
+		"Execute safe commands",
+		"Edit project files",
+	]);
+}
+
+/** Assert the Features tab content is visible */
+export async function assertFeaturesTab(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, [
+		"Subagents",
+		"Web tools",
+		"Double-check completion",
+	]);
+}
+
+/** Assert the Account tab content is visible */
+export async function assertAccountTab(terminal: Terminal): Promise<void> {
+	// The account tab shows sign-in options when not authenticated to Cline
+	await expectVisible(terminal, /sign in|sign out/i);
+}
+
+/** Assert the Other tab content is visible */
+export async function assertOtherTab(terminal: Terminal): Promise<void> {
+	await expectVisible(terminal, ["Preferred language:", "Cline v"]);
+}
+
+/**
+ * Assert the content for a given tab is visible.
+ * Used internally by goToSettingsTab to confirm navigation landed correctly.
+ */
+export async function assertTabContent(
+	terminal: Terminal,
+	tab: SettingsTab,
+): Promise<void> {
+	switch (tab) {
+		case "API":
+			return assertApiTab(terminal);
+		case "Auto-approve":
+			return assertAutoApproveTab(terminal);
+		case "Features":
+			return assertFeaturesTab(terminal);
+		case "Account":
+			return assertAccountTab(terminal);
+		case "Other":
+			return assertOtherTab(terminal);
+	}
+}
diff --git a/apps/cli/src/tests/helpers/process.ts b/apps/cli/src/tests/helpers/process.ts
new file mode 100644
index 0000000..9ebd14c
--- /dev/null
+++ b/apps/cli/src/tests/helpers/process.ts
@@ -0,0 +1,113 @@
+// ---------------------------------------------------------------------------
+// Process-level helpers for headless / contract-style CLI tests.
+//
+// These helpers spawn cline as a child process and return stdout, stderr,
+// and exit code - without going through the TUI harness. Use these for:
+//   - Exit code assertions
+//   - Pure stdout/stderr contract tests
+//   - Piped stdin tests (echo "..." | cline -y ...)
+//   - JSON output validation
+//   - Timeout behavior
+// ---------------------------------------------------------------------------
+
+import { type SpawnSyncOptions, spawnSync } from "node:child_process";
+import { CLINE_BIN } from "./constants.js";
+import { clineEnv } from "./env.js";
+
+export interface RunResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number | null;
+	combined: string;
+}
+
+export interface RunOptions {
+	/** Named config dir under `configs/`, or absolute path */
+	config?: string;
+	/** Additional env vars */
+	env?: NodeJS.ProcessEnv;
+	/** Stdin to pipe into the process */
+	stdin?: string;
+	/** Timeout in ms (default: 30_000) */
+	timeout?: number;
+	/** Working directory for the spawned process */
+	cwd?: string;
+}
+
+/**
+ * Run `cline [args]` synchronously and return stdout/stderr/exitCode.
+ *
+ * Suitable for deterministic, fast-exiting commands like:
+ *   cline --help, cline --version, cline auth -p ... -k ..., etc.
+ */
+export function runCline(args: string[], opts: RunOptions = {}): RunResult {
+	const {
+		config = "default",
+		env: extraEnv = {},
+		stdin,
+		timeout = 30_000,
+		cwd = process.cwd(),
+	} = opts;
+
+	const spawnOpts: SpawnSyncOptions = {
+		encoding: "utf8",
+		timeout,
+		cwd,
+		env: { ...clineEnv(config), ...extraEnv },
+		input: stdin,
+	};
+
+	const result = spawnSync(CLINE_BIN, args, spawnOpts);
+
+	const stdout = (result.stdout as string) ?? "";
+	const stderr = (result.stderr as string) ?? "";
+
+	return {
+		stdout,
+		stderr,
+		exitCode: result.status,
+		combined: stdout + stderr,
+	};
+}
+
+/**
+ * Assert that a runCline result exited with the expected code.
+ * Throws a descriptive error if the code doesn't match.
+ */
+export function assertExitCode(
+	result: RunResult,
+	expected: number,
+	label = "",
+): void {
+	if (result.exitCode !== expected) {
+		const prefix = label ? `[${label}] ` : "";
+		throw new Error(
+			`${prefix}Expected exit code ${expected}, got ${result.exitCode}.\n` +
+				`stdout: ${result.stdout}\n` +
+				`stderr: ${result.stderr}`,
+		);
+	}
+}
+
+/**
+ * Assert that stdout/stderr contains a given string or matches a regex.
+ */
+export function assertOutput(
+	result: RunResult,
+	pattern: string | RegExp,
+	stream: "stdout" | "stderr" | "combined" = "combined",
+	label = "",
+): void {
+	const text = result[stream];
+	const matches =
+		typeof pattern === "string" ? text.includes(pattern) : pattern.test(text);
+
+	if (!matches) {
+		const prefix = label ? `[${label}] ` : "";
+		throw new Error(
+			`${prefix}Expected ${stream} to match ${pattern}.\n` +
+				`stdout: ${result.stdout}\n` +
+				`stderr: ${result.stderr}`,
+		);
+	}
+}
diff --git a/apps/cli/src/tests/helpers/terminal.ts b/apps/cli/src/tests/helpers/terminal.ts
new file mode 100644
index 0000000..4b62cbe
--- /dev/null
+++ b/apps/cli/src/tests/helpers/terminal.ts
@@ -0,0 +1,144 @@
+// ---------------------------------------------------------------------------
+// Terminal interaction helpers for TUI tests.
+//
+// These wrap common tui-test patterns to keep test bodies readable.
+// ---------------------------------------------------------------------------
+
+import { expect } from "@microsoft/tui-test";
+import type { Terminal } from "@microsoft/tui-test/lib/terminal/term";
+import { EXIT_CODE_TIMEOUT } from "./constants.js";
+
+// ---------------------------------------------------------------------------
+// Core wait / assertion helpers
+// ---------------------------------------------------------------------------
+
+const maxTimeoutMs = 10_000;
+
+/**
+ * Internal helper – asserts visibility (or not) for one or more patterns.
+ */
+async function expectTextVisibility(
+	terminal: Terminal,
+	text: string | RegExp | (string | RegExp)[],
+	visible: boolean,
+	options: { timeout?: number } = { timeout: maxTimeoutMs },
+): Promise<void> {
+	const items = Array.isArray(text) ? text : [text];
+	const timeoutOpt =
+		options.timeout !== undefined ? { timeout: options.timeout } : undefined;
+	await Promise.all(
+		items.map((t) => {
+			// tui-test uses String.prototype.matchAll internally, which requires
+			// the global flag on RegExp arguments. Ensure it is set.
+			if (t instanceof RegExp && !t.flags.includes("g")) {
+				t = new RegExp(t.source, `${t.flags}g`);
+			}
+			const locator = terminal.getByText(t, {
+				full: true,
+				strict: false,
+			});
+			return visible
+				? expect(locator).toBeVisible(timeoutOpt)
+				: expect(locator).not.toBeVisible(timeoutOpt);
+		}),
+	);
+}
+
+/**
+ * Wait for one or more text strings/regexes to appear on screen.
+ *
+ * @example
+ *   await expectVisible(terminal, "What can I do for you?");
+ *   await expectVisible(terminal, ["/help", "/settings"], { timeout: 5000 });
+ */
+export async function expectVisible(
+	terminal: Terminal,
+	text: string | RegExp | (string | RegExp)[],
+	options: { timeout?: number } = { timeout: maxTimeoutMs },
+): Promise<void> {
+	return expectTextVisibility(terminal, text, true, options);
+}
+
+export async function expectExitCode(
+	terminal: Terminal,
+	exitCode: number,
+): Promise<void> {
+	const xCode = await waitForTerminalExit(terminal);
+	expect(xCode).toBe(exitCode);
+}
+
+/**
+ * Assert that one or more text strings/regexes are **not** visible on screen.
+ *
+ * @example
+ *   await expectNotVisible(terminal, "Loading…");
+ *   await expectNotVisible(terminal, ["/secret", /error/i], { timeout: 5000 });
+ */
+export async function expectNotVisible(
+	terminal: Terminal,
+	text: string | RegExp | (string | RegExp)[],
+	options: { timeout?: number } = { timeout: maxTimeoutMs },
+): Promise<void> {
+	return expectTextVisibility(terminal, text, false, options);
+}
+
+/**
+ * Type text into the terminal and press Enter.
+ * Waits `delay` ms between writing and submitting to let the UI settle.
+ */
+export async function typeAndSubmit(
+	terminal: Terminal,
+	text: string,
+	delay = 500,
+): Promise<void> {
+	terminal.write(text);
+	await new Promise((resolve) => setTimeout(resolve, delay));
+	terminal.submit();
+}
+
+/**
+ * Gracefully shut down the CLI process by sending Ctrl+C (SIGINT) and
+ * waiting for the process to actually exit.
+ *
+ * This is necessary for VCR recording tests because tui-test normally
+ * terminates processes with SIGKILL (signal 9), which cannot be caught
+ * and prevents `process.on('exit')` handlers from flushing recorded
+ * HTTP interactions to disk. Sending SIGINT first triggers the CLI's
+ * graceful shutdown path which flushes VCR cassettes before exiting.
+ *
+ * @param timeout Maximum ms to wait for exit before giving up (default 5000)
+ */
+export async function gracefulShutdown(terminal: Terminal): Promise<number> {
+	terminal.keyCtrlC();
+	return await waitForTerminalExit(terminal);
+}
+
+export async function waitForTerminalExit(
+	terminal: Terminal,
+	timeout = 31000,
+): Promise<number> {
+	return await new Promise<number>((resolve) => {
+		let resolved = false;
+		const done = (code: number) => {
+			if (resolved) return;
+			resolved = true;
+			clearTimeout(timer);
+			clearInterval(poller);
+			resolve(code);
+		};
+
+		const timer = setTimeout(() => done(EXIT_CODE_TIMEOUT), timeout); // exit code 124 is timeout
+
+		// Register listener for future exit events
+		terminal.onExit((exitResult) => done(exitResult.exitCode));
+
+		// Poll terminal.exitResult as a fallback for the race condition where
+		// the process exits before onExit listener is registered (the event
+		// fires once and is not replayed for late subscribers).
+		const poller = setInterval(() => {
+			if (terminal.exitResult) {
+				done(terminal.exitResult.exitCode);
+			}
+		}, 1000);
+	});
+}
diff --git a/apps/cli/src/tests/interactive.test.ts b/apps/cli/src/tests/interactive.test.ts
new file mode 100644
index 0000000..d8590e0
--- /dev/null
+++ b/apps/cli/src/tests/interactive.test.ts
@@ -0,0 +1,53 @@
+import { expect, test } from "@microsoft/tui-test";
+import { CLINE_BIN } from "./helpers/constants.js";
+import { clineEnv } from "./helpers/env.js";
+import { waitForChatReady } from "./helpers/page-objects/chat.js";
+import { expectVisible, waitForTerminalExit } from "./helpers/terminal.js";
+
+test.describe("cline interactive basics", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: [] },
+		rows: 50,
+		columns: 120,
+		env: clineEnv("default"),
+	});
+
+	test("shows logo, prompt, and hints", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		await expectVisible(terminal, ["@ for file mentions", "Tab"]);
+	});
+
+	test("shows slash commands after / input", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		// Type "/" without submitting to trigger the slash menu
+		terminal.write("/");
+		await expectVisible(terminal, ["/settings", "/mcp"], {
+			timeout: 10_000,
+		});
+	});
+
+	test("opens the command palette with Ctrl+P", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		terminal.write("\x10");
+		await expectVisible(terminal, [
+			"Command Palette",
+			"Change Model",
+			"Manage MCP Servers",
+		]);
+	});
+});
+
+test.describe("cline interactive provider flag", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["-P", "cline"] },
+		rows: 50,
+		columns: 120,
+		env: clineEnv("default"),
+	});
+
+	test("exits idle TUI after one Ctrl+C", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		terminal.keyCtrlC();
+		await expect(waitForTerminalExit(terminal, 5_000)).resolves.toBe(0);
+	});
+});
diff --git a/apps/cli/src/tests/interactive/chat.test.ts b/apps/cli/src/tests/interactive/chat.test.ts
new file mode 100644
index 0000000..de565c9
--- /dev/null
+++ b/apps/cli/src/tests/interactive/chat.test.ts
@@ -0,0 +1,55 @@
+// ---------------------------------------------------------------------------
+// CLI Interactive use cases - main chat view
+//
+// Covers:
+//   - `cline` launches interactive view (authed / unauthed)
+//   - /settings navigation and tab verification
+//   - /models view
+//   - /history view
+//   - /skills view
+//   - Plan/Act mode toggle (Tab)
+//   - Plan task → toggle to Act → task executes
+//   - Act task → file edit permission prompt → Save / Reject
+//   - Task completed → Start New Task / Exit buttons
+//   - Auto-approve settings
+//   - Subagents
+//   - Web tools
+//   - Auto-approve all (Shift+Tab)
+// ---------------------------------------------------------------------------
+
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN, TERMINAL_WIDE } from "../helpers/constants.js";
+import { clineEnv } from "../helpers/env.js";
+import {
+	toggleAutoApproveAll,
+	waitForChatReady,
+} from "../helpers/page-objects/chat.js";
+import { expectVisible } from "../helpers/terminal.js";
+
+test.describe("cline (authenticated) - shows chat view", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: [] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("shows interactive chat view", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+	});
+});
+
+test.describe("Auto-approve all - Shift+Tab toggle", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: [] },
+		...TERMINAL_WIDE,
+		env: clineEnv("default"),
+	});
+
+	test("Shift+Tab toggles auto-approve-all setting", async ({ terminal }) => {
+		await waitForChatReady(terminal);
+		await expectVisible(terminal, "Auto-approve all enabled");
+		await toggleAutoApproveAll(terminal);
+		await expectVisible(terminal, "Auto-approve all disabled");
+		await toggleAutoApproveAll(terminal);
+	});
+});
diff --git a/apps/cli/src/tests/package.json b/apps/cli/src/tests/package.json
new file mode 100644
index 0000000..bedb411
--- /dev/null
+++ b/apps/cli/src/tests/package.json
@@ -0,0 +1,3 @@
+{
+	"type": "module"
+}
diff --git a/apps/cli/src/tests/tui-test.config.ts b/apps/cli/src/tests/tui-test.config.ts
new file mode 100644
index 0000000..96ec697
--- /dev/null
+++ b/apps/cli/src/tests/tui-test.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from "@microsoft/tui-test";
+
+export default defineConfig({
+	retries: 0,
+	workers: 4,
+	trace: true,
+	traceFolder: "./tui-traces",
+	testMatch: "./**/*.test.ts",
+	timeout: 60_000,
+});
diff --git a/apps/cli/src/tests/version.test.ts b/apps/cli/src/tests/version.test.ts
new file mode 100644
index 0000000..fda0bd9
--- /dev/null
+++ b/apps/cli/src/tests/version.test.ts
@@ -0,0 +1,46 @@
+import { test } from "@microsoft/tui-test";
+import { CLINE_BIN } from "./helpers/constants.js";
+import { clineEnv } from "./helpers/env.js";
+import { expectVisible } from "./helpers/terminal.js";
+
+// ---------------------------------------------------------------------------
+// cline --version  (root flag)
+// ---------------------------------------------------------------------------
+test.describe("cline --version", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--version"] },
+		env: clineEnv("claude-sonnet-4.6"),
+	});
+
+	test("prints the version string", async ({ terminal }) => {
+		await expectVisible(terminal, /\d+\.\d+\.\d+/g);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline -V  (short flag)
+// ---------------------------------------------------------------------------
+test.describe("cline -V", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["-V"] },
+		env: clineEnv("claude-sonnet-4.6"),
+	});
+
+	test("prints the version string with short flag", async ({ terminal }) => {
+		await expectVisible(terminal, /\d+\.\d+\.\d+/g);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// cline version  (subcommand)
+// ---------------------------------------------------------------------------
+test.describe("cline version subcommand", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["version"] },
+		env: clineEnv("claude-sonnet-4.6"),
+	});
+
+	test("prints 'Cline CLI version:' message", async ({ terminal }) => {
+		await expectVisible(terminal, /\d+\.\d+\.\d+/g);
+	});
+});
diff --git a/apps/cli/src/tui/cline-account.test.ts b/apps/cli/src/tui/cline-account.test.ts
new file mode 100644
index 0000000..ef56d4a
--- /dev/null
+++ b/apps/cli/src/tui/cline-account.test.ts
@@ -0,0 +1,311 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Config } from "../utils/types";
+
+const coreMocks = vi.hoisted(() => {
+	const serviceOptions: Array<{
+		apiBaseUrl: string;
+		getAuthToken: () => Promise<string | undefined | null>;
+	}> = [];
+	return {
+		getProviderSettings: vi.fn(),
+		saveProviderSettings: vi.fn(),
+		fetchMe: vi.fn(),
+		fetchBalance: vi.fn(),
+		fetchOrganizationBalance: vi.fn(),
+		fetchAvailableSubscriptionPlans: vi.fn(),
+		fetchCurrentUserPlan: vi.fn(),
+		serviceOptions,
+	};
+});
+const telemetryMocks = vi.hoisted(() => ({
+	identifyTelemetryAccount: vi.fn(),
+}));
+
+vi.mock("@cline/core", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@cline/core")>();
+	return {
+		...actual,
+		ClineAccountService: class {
+			constructor(options: {
+				apiBaseUrl: string;
+				getAuthToken: () => Promise<string | undefined | null>;
+			}) {
+				coreMocks.serviceOptions.push(options);
+			}
+			fetchMe() {
+				return coreMocks.fetchMe();
+			}
+			fetchBalance(userId?: string) {
+				return coreMocks.fetchBalance(userId);
+			}
+			fetchOrganizationBalance(organizationId: string) {
+				return coreMocks.fetchOrganizationBalance(organizationId);
+			}
+			fetchAvailableSubscriptionPlans(input?: {
+				type?: "individual" | "teams";
+			}) {
+				return coreMocks.fetchAvailableSubscriptionPlans(input);
+			}
+			fetchCurrentUserPlan() {
+				return coreMocks.fetchCurrentUserPlan();
+			}
+		},
+		ProviderSettingsManager: class {
+			getProviderSettings(providerId: string) {
+				return coreMocks.getProviderSettings(providerId);
+			}
+			saveProviderSettings(settings: unknown, options?: unknown) {
+				coreMocks.saveProviderSettings(settings, options);
+			}
+		},
+	};
+});
+
+vi.mock("../utils/telemetry", () => ({
+	identifyTelemetryAccount: telemetryMocks.identifyTelemetryAccount,
+}));
+
+function makeConfig(overrides: Partial<Config> = {}): Config {
+	return {
+		providerId: "cline",
+		modelId: "anthropic/claude-sonnet-4.6",
+		apiKey: "",
+		verbose: false,
+		sandbox: false,
+		thinking: false,
+		outputMode: "text",
+		mode: "act",
+		defaultToolAutoApprove: false,
+		toolPolicies: {},
+		enableTools: true,
+		cwd: "/tmp/workspace",
+		logger: {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		},
+		...overrides,
+	} as unknown as Config;
+}
+
+function mockFetchJson(body: unknown, status = 200): void {
+	vi.stubGlobal(
+		"fetch",
+		vi.fn(
+			async () =>
+				new Response(JSON.stringify(body), {
+					status,
+					headers: { "Content-Type": "application/json" },
+				}),
+		) as unknown as typeof fetch,
+	);
+}
+
+describe("createClineAccountService", () => {
+	beforeEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+		coreMocks.getProviderSettings.mockReset();
+		coreMocks.saveProviderSettings.mockReset();
+		coreMocks.fetchMe.mockReset();
+		coreMocks.fetchBalance.mockReset();
+		coreMocks.fetchOrganizationBalance.mockReset();
+		coreMocks.fetchAvailableSubscriptionPlans.mockReset();
+		coreMocks.fetchCurrentUserPlan.mockReset();
+		coreMocks.serviceOptions.length = 0;
+		telemetryMocks.identifyTelemetryAccount.mockReset();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+	});
+
+	it("refreshes persisted Cline OAuth credentials before creating the account service", async () => {
+		vi.spyOn(Date, "now").mockReturnValue(100_000);
+		mockFetchJson({
+			success: true,
+			data: {
+				accessToken: "new-access",
+				refreshToken: "new-refresh",
+				tokenType: "Bearer",
+				expiresAt: "2096-10-02T07:06:40.000Z",
+				userInfo: {
+					subject: "sub-new",
+					email: "new@example.com",
+					name: "New User",
+					clineUserId: "acct-new",
+					accounts: [],
+				},
+			},
+		});
+		coreMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			auth: {
+				accessToken: "workos:old-access",
+				refreshToken: "refresh-token",
+				accountId: "acct-old",
+				expiresAt: 1,
+			},
+		});
+
+		const { createClineAccountService } = await import("./cline-account");
+		const service = await createClineAccountService({ config: makeConfig() });
+
+		expect(service).toBeDefined();
+		expect(globalThis.fetch).toHaveBeenCalled();
+		expect(coreMocks.saveProviderSettings).toHaveBeenCalledWith(
+			expect.objectContaining({
+				provider: "cline",
+				auth: expect.objectContaining({
+					accessToken: "workos:new-access",
+					refreshToken: "new-refresh",
+					accountId: "acct-new",
+					expiresAt: 4_000_000_000_000,
+				}),
+			}),
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+		expect(await coreMocks.serviceOptions[0]?.getAuthToken()).toBe(
+			"workos:new-access",
+		);
+	});
+
+	it("asks the user to re-authenticate when Cline OAuth credentials cannot refresh", async () => {
+		vi.spyOn(Date, "now").mockReturnValue(100_000);
+		mockFetchJson(
+			{
+				error: "invalid_grant",
+				error_description: "refresh expired",
+			},
+			401,
+		);
+		coreMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			auth: {
+				accessToken: "workos:old-access",
+				refreshToken: "refresh-token",
+				expiresAt: 1,
+			},
+		});
+
+		const { createClineAccountService } = await import("./cline-account");
+
+		await expect(
+			createClineAccountService({ config: makeConfig() }),
+		).rejects.toThrow(
+			"Cline account requires re-authentication. Run cline auth cline.",
+		);
+	});
+});
+
+describe("loadClineAccountSnapshot", () => {
+	beforeEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+		coreMocks.getProviderSettings.mockReset();
+		coreMocks.saveProviderSettings.mockReset();
+		coreMocks.fetchMe.mockReset();
+		coreMocks.fetchBalance.mockReset();
+		coreMocks.fetchOrganizationBalance.mockReset();
+		coreMocks.fetchAvailableSubscriptionPlans.mockReset();
+		coreMocks.fetchCurrentUserPlan.mockReset();
+		coreMocks.serviceOptions.length = 0;
+		telemetryMocks.identifyTelemetryAccount.mockReset();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+	});
+
+	it("identifies the loaded Cline account for telemetry and feature flags", async () => {
+		coreMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			apiKey: "account-token",
+		});
+		const { loadClineAccountSnapshot } = await import("./cline-account");
+		coreMocks.fetchMe.mockResolvedValue({
+			id: "user-1",
+			email: "user@example.com",
+			displayName: "User One",
+			photoUrl: "",
+			createdAt: "",
+			updatedAt: "",
+			organizations: [
+				{
+					active: true,
+					memberId: "member-1",
+					name: "Acme",
+					organizationId: "org-1",
+					roles: ["member"],
+				},
+			],
+		});
+		coreMocks.fetchBalance.mockResolvedValue({ balance: 10, userId: "user-1" });
+		coreMocks.fetchOrganizationBalance.mockResolvedValue({
+			balance: 20,
+			organizationId: "org-1",
+		});
+
+		await loadClineAccountSnapshot({ config: makeConfig() });
+
+		expect(telemetryMocks.identifyTelemetryAccount).toHaveBeenCalledWith(
+			{
+				id: "user-1",
+				email: "user@example.com",
+				provider: "cline",
+				organizationId: "org-1",
+				organizationName: "Acme",
+				memberId: "member-1",
+			},
+			expect.any(Object),
+		);
+	});
+});
+
+describe("loadIndividualSubscriptionPlans", () => {
+	beforeEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+		coreMocks.getProviderSettings.mockReset();
+		coreMocks.saveProviderSettings.mockReset();
+		coreMocks.fetchMe.mockReset();
+		coreMocks.fetchBalance.mockReset();
+		coreMocks.fetchOrganizationBalance.mockReset();
+		coreMocks.fetchAvailableSubscriptionPlans.mockReset();
+		coreMocks.fetchCurrentUserPlan.mockReset();
+		coreMocks.serviceOptions.length = 0;
+		telemetryMocks.identifyTelemetryAccount.mockReset();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+	});
+
+	it("loads individual subscription plans through the authorized account service", async () => {
+		const plans = [
+			{
+				id: "plan-1",
+				interval: "Monthly",
+				features: { included: ["Major open-weights models"] },
+			},
+		];
+		coreMocks.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			apiKey: "account-token",
+		});
+		coreMocks.fetchAvailableSubscriptionPlans.mockResolvedValue(plans);
+
+		const { loadIndividualSubscriptionPlans } = await import("./cline-account");
+		const result = await loadIndividualSubscriptionPlans({
+			config: makeConfig(),
+		});
+
+		expect(coreMocks.fetchAvailableSubscriptionPlans).toHaveBeenCalledWith({
+			type: "individual",
+		});
+		expect(result).toEqual(plans);
+	});
+});
diff --git a/apps/cli/src/tui/cline-account.ts b/apps/cli/src/tui/cline-account.ts
new file mode 100644
index 0000000..764c079
--- /dev/null
+++ b/apps/cli/src/tui/cline-account.ts
@@ -0,0 +1,286 @@
+import {
+	type ClineAccountBalance,
+	type ClineAccountOrganization,
+	type ClineAccountOrganizationBalance,
+	type ClineSubscriptionPlan,
+	type UserCurrentPlan,
+	ClineAccountService,
+	type ClineAccountUser,
+	formatProviderOAuthApiKey,
+	getPersistedProviderApiKey,
+	getProviderOAuthCredentialsFromSettings,
+	getValidClineCredentials,
+	type ProviderSettings,
+	ProviderSettingsManager,
+	saveLocalProviderOAuthCredentials,
+} from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import { formatCreditBalance, normalizeCreditBalance } from "../utils/output";
+import { identifyTelemetryAccount } from "../utils/telemetry";
+import type { Config } from "../utils/types";
+
+export const CLINE_CREDITS_DASHBOARD_URL =
+	"https://app.cline.bot/dashboard/account?tab=credits";
+
+type ClineAccountConfig = Pick<Config, "apiKey" | "logger" | "providerId">;
+
+const CLINE_PASS_PROVIDER_ID = "cline-pass";
+
+export interface ClineAccountSnapshot {
+	user: ClineAccountUser;
+	balance: ClineAccountBalance;
+	organizationBalance: ClineAccountOrganizationBalance | null;
+	organizations: ClineAccountOrganization[];
+	activeOrganization: ClineAccountOrganization | null;
+	displayedBalance: number;
+}
+
+export function formatClineCredits(value: number): string {
+	return formatCreditBalance(normalizeCreditBalance(value));
+}
+
+// FIXME: These message checks are temporary until structured error types are
+// passed through to the CLI instead of plain error strings.
+export function isClineAccountAuthErrorMessage(message: string): boolean {
+	const normalized = message.trim().toLowerCase();
+	return (
+		normalized === "no cline account auth token found" ||
+		normalized.includes("requires re-authentication")
+	);
+}
+
+export function isClineAccountCreditsErrorMessage(message: string): boolean {
+	const normalized = message.trim().toLowerCase();
+	return (
+		normalized.includes("insufficient balance") &&
+		normalized.includes("cline credits balance")
+	);
+}
+
+function resolveAccountApiBaseUrl(input: {
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+}): string {
+	const settingsBaseUrl = input.clineProviderSettings?.baseUrl?.trim();
+	if (settingsBaseUrl) {
+		return settingsBaseUrl;
+	}
+	const configuredBaseUrl = input.clineApiBaseUrl?.trim();
+	if (configuredBaseUrl) {
+		return configuredBaseUrl;
+	}
+	return getClineEnvironmentConfig().apiBaseUrl;
+}
+
+function resolveClineAccountAuthToken(input: {
+	config: ClineAccountConfig;
+	clineProviderSettings?: ProviderSettings;
+}): string | undefined {
+	const configApiKey =
+		input.config.providerId === "cline" ? input.config.apiKey.trim() : "";
+	return (
+		getPersistedProviderApiKey("cline", input.clineProviderSettings) ||
+		configApiKey ||
+		undefined
+	);
+}
+
+async function resolveValidClineAccountAuthToken(input: {
+	config: ClineAccountConfig;
+	clineProviderSettings?: ProviderSettings;
+	manager: ProviderSettingsManager;
+	apiBaseUrl: string;
+}): Promise<string | undefined> {
+	const settings = input.clineProviderSettings;
+	const credentials = settings
+		? getProviderOAuthCredentialsFromSettings("cline", settings)
+		: null;
+	if (settings && credentials) {
+		const nextCredentials = await getValidClineCredentials(credentials, {
+			apiBaseUrl: input.apiBaseUrl,
+		});
+		if (!nextCredentials) {
+			throw new Error(
+				"Cline account requires re-authentication. Run cline auth cline.",
+			);
+		}
+		const nextAccessToken = formatProviderOAuthApiKey("cline", nextCredentials);
+		if (nextCredentials !== credentials) {
+			saveLocalProviderOAuthCredentials(
+				input.manager,
+				"cline",
+				settings,
+				nextCredentials,
+				{ setLastUsed: false },
+			);
+		}
+		return nextAccessToken;
+	}
+	return resolveClineAccountAuthToken({
+		config: input.config,
+		clineProviderSettings: settings,
+	});
+}
+
+export async function createClineAccountService(input: {
+	config: ClineAccountConfig;
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+	providerSettingsManager?: ProviderSettingsManager;
+}): Promise<ClineAccountService | undefined> {
+	const manager =
+		input.providerSettingsManager ?? new ProviderSettingsManager();
+	const settings =
+		manager.getProviderSettings("cline") ?? input.clineProviderSettings;
+	const apiBaseUrl = resolveAccountApiBaseUrl({
+		clineApiBaseUrl: input.clineApiBaseUrl,
+		clineProviderSettings: settings,
+	});
+	const authToken = await resolveValidClineAccountAuthToken({
+		config: input.config,
+		clineProviderSettings: settings,
+		manager,
+		apiBaseUrl,
+	});
+	if (!authToken) {
+		return undefined;
+	}
+	return new ClineAccountService({
+		apiBaseUrl,
+		getAuthToken: async () => authToken,
+	});
+}
+
+export async function loadClineAccountSnapshot(input: {
+	config: ClineAccountConfig;
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+}): Promise<ClineAccountSnapshot> {
+	const service = await createClineAccountService(input);
+	if (!service) {
+		throw new Error("No Cline account auth token found");
+	}
+
+	const user = await service.fetchMe();
+	const organizations = user.organizations ?? [];
+	const activeOrganization =
+		organizations.find((organization) => organization.active) ?? null;
+	const [balance, organizationBalance] = await Promise.all([
+		service.fetchBalance(user.id),
+		activeOrganization
+			? service.fetchOrganizationBalance(activeOrganization.organizationId)
+			: Promise.resolve(null),
+	]);
+	const displayedBalance = activeOrganization
+		? (organizationBalance?.balance ?? balance.balance)
+		: balance.balance;
+	const accountContext = {
+		id: user.id,
+		email: user.email,
+		provider: "cline",
+		organizationId: activeOrganization?.organizationId,
+		organizationName: activeOrganization?.name,
+		memberId: activeOrganization?.memberId,
+	};
+	identifyTelemetryAccount(accountContext, input.config.logger);
+
+	return {
+		user,
+		balance,
+		organizationBalance,
+		organizations,
+		activeOrganization,
+		displayedBalance,
+	};
+}
+
+export async function switchClineAccount(input: {
+	config: ClineAccountConfig;
+	organizationId?: string | null;
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+}): Promise<void> {
+	const service = await createClineAccountService(input);
+	if (!service) {
+		throw new Error("No Cline account auth token found");
+	}
+	await service.switchAccount(input.organizationId);
+}
+
+export async function loadIndividualSubscriptionPlans(input: {
+	config: ClineAccountConfig;
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+}): Promise<ClineSubscriptionPlan[]> {
+	const service = await createClineAccountService(input);
+	if (!service) {
+		throw new Error("No Cline account auth token found");
+	}
+	return service.fetchAvailableSubscriptionPlans({ type: "individual" });
+}
+
+export async function loadCurrentUserPlan(input: {
+	config: ClineAccountConfig;
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+}): Promise<UserCurrentPlan | undefined> {
+	const service = await createClineAccountService(input);
+	if (!service) {
+		throw new Error("No Cline account auth token found");
+	}
+	return service.fetchCurrentUserPlan();
+}
+
+export async function loadCurrentUserPlanFromProviderSettings(input: {
+	providerSettingsManager: ProviderSettingsManager;
+	clineApiBaseUrl?: string;
+}): Promise<UserCurrentPlan | undefined> {
+	const service = await createClineAccountService({
+		config: { apiKey: "", logger: undefined, providerId: "cline" },
+		clineApiBaseUrl: input.clineApiBaseUrl,
+		providerSettingsManager: input.providerSettingsManager,
+	});
+	if (!service) {
+		throw new Error("No Cline account auth token found");
+	}
+	return service.fetchCurrentUserPlan();
+}
+
+export async function loadIndividualSubscriptionPlansFromProviderSettings(input: {
+	providerSettingsManager: ProviderSettingsManager;
+	clineApiBaseUrl?: string;
+}): Promise<ClineSubscriptionPlan[]> {
+	const service = await createClineAccountService({
+		config: { apiKey: "", logger: undefined, providerId: "cline" },
+		clineApiBaseUrl: input.clineApiBaseUrl,
+		providerSettingsManager: input.providerSettingsManager,
+	});
+	if (!service) {
+		throw new Error("No Cline account auth token found");
+	}
+	return service.fetchAvailableSubscriptionPlans({ type: "individual" });
+}
+
+async function onChangeToClinePass(config: ClineAccountConfig) {
+	try {
+		await switchClineAccount({
+			config: config,
+			organizationId: null,
+		});
+	} catch (error) {
+		config.logger?.debug("Failed to switch ClinePass to personal account", {
+			error,
+		});
+	}
+}
+
+export async function onProviderChange(input: {
+	config: ClineAccountConfig;
+	providerId: string;
+}): Promise<void> {
+	if (input.providerId === CLINE_PASS_PROVIDER_ID) {
+		return onChangeToClinePass(input.config);
+	}
+
+	return;
+}
diff --git a/apps/cli/src/tui/commands/slash-command-registry.test.ts b/apps/cli/src/tui/commands/slash-command-registry.test.ts
new file mode 100644
index 0000000..e376223
--- /dev/null
+++ b/apps/cli/src/tui/commands/slash-command-registry.test.ts
@@ -0,0 +1,286 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildSlashCommandRegistry,
+	expandUserCommandPrompt,
+	formatSlashCommandAutocompleteValue,
+	getInvokableUserSlashCommands,
+	getVisibleSystemSlashCommands,
+	getVisibleUserSlashCommands,
+	resolveSlashCommand,
+} from "./slash-command-registry";
+
+describe("slash command registry", () => {
+	it("keeps TUI-local commands local even when runtime also advertises them", () => {
+		const registry = buildSlashCommandRegistry({
+			canFork: true,
+			workflowSlashCommands: [
+				{
+					name: "settings",
+					instructions: "",
+					description: "Runtime settings",
+				},
+				{
+					name: "team",
+					instructions: "/team [prompt]",
+					description: "Start a task with agent team",
+				},
+				{
+					name: "mcp",
+					instructions: "",
+					description: "Runtime MCP",
+				},
+			],
+		});
+
+		expect(resolveSlashCommand(registry, "settings")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			description: "Modify agent configuration",
+			visible: true,
+		});
+		expect(resolveSlashCommand(registry, "team")).toMatchObject({
+			source: "runtime",
+			execution: "runtime",
+		});
+		expect(resolveSlashCommand(registry, "mcp")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			description: "Manage MCP servers",
+			visible: true,
+		});
+	});
+
+	it("surfaces plugin commands as runtime-executable commands", () => {
+		const registry = buildSlashCommandRegistry({
+			additionalSlashCommands: [
+				{
+					name: "/Echo",
+					instructions: "",
+					description: "Echo input",
+				},
+			],
+		});
+		const command = resolveSlashCommand(registry, "echo");
+
+		expect(command).toMatchObject({
+			name: "echo",
+			source: "plugin",
+			execution: "runtime",
+			visible: true,
+			selectable: true,
+		});
+		expect(command ? formatSlashCommandAutocompleteValue(command) : "").toBe(
+			"/echo ",
+		);
+	});
+
+	it("surfaces skills and workflows in autocomplete and the skills picker", () => {
+		const registry = buildSlashCommandRegistry({
+			workflowSlashCommands: [
+				{
+					name: "review",
+					instructions: "Review carefully",
+					description: "Review files",
+					kind: "skill",
+				},
+				{
+					name: "release",
+					instructions: "Prepare release",
+					description: "Release workflow",
+					kind: "workflow",
+				},
+			],
+		});
+
+		expect(
+			getVisibleSystemSlashCommands(registry).map((cmd) => cmd.name),
+		).toEqual(
+			expect.arrayContaining([
+				"settings",
+				"mcp",
+				"account",
+				"model",
+				"skills",
+				"quit",
+			]),
+		);
+		expect(resolveSlashCommand(registry, "skills")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			description: "Browse skills and workflows",
+			visible: true,
+		});
+		expect(resolveSlashCommand(registry, "quit")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			description: "Exit Cline",
+			visible: true,
+		});
+		expect(
+			getVisibleUserSlashCommands(registry).map((cmd) => cmd.name),
+		).toEqual(["review", "release"]);
+		expect(
+			getInvokableUserSlashCommands(registry).map((cmd) => cmd.name),
+		).toEqual(["review", "release"]);
+		const review = resolveSlashCommand(registry, "review");
+		expect(review).toMatchObject({
+			source: "skill",
+			execution: "user-command",
+			visible: true,
+			selectable: true,
+		});
+		expect(review ? formatSlashCommandAutocompleteValue(review) : "").toBe(
+			"/review ",
+		);
+		expect(resolveSlashCommand(registry, "release")).toMatchObject({
+			source: "workflow",
+			execution: "user-command",
+			visible: true,
+			selectable: true,
+		});
+	});
+
+	it("expands user command tokens and manually typed user commands before submission", () => {
+		const registry = buildSlashCommandRegistry({
+			workflowSlashCommands: [
+				{
+					name: "review",
+					instructions: "Review carefully",
+					description: "Review files",
+					kind: "skill",
+				},
+			],
+		});
+
+		expect(expandUserCommandPrompt("/review this file", registry)).toBe(
+			'<user_command slash="review">Review carefully</user_command> this file',
+		);
+		expect(expandUserCommandPrompt("please /review this file", registry)).toBe(
+			'please <user_command slash="review">Review carefully</user_command> this file',
+		);
+		expect(
+			expandUserCommandPrompt(
+				'<user_command slash="review">Review carefully</user_command> this file',
+				registry,
+			),
+		).toBe(
+			'<user_command slash="review">Review carefully</user_command> this file',
+		);
+		expect(expandUserCommandPrompt("/settings", registry)).toBe("/settings");
+	});
+
+	it("does not expand commands omitted from a refreshed user-command registry", () => {
+		const staleRegistry = buildSlashCommandRegistry({
+			workflowSlashCommands: [
+				{
+					name: "find-skills",
+					instructions: "Find installable skills.",
+					description: "Find skills",
+					kind: "skill",
+				},
+			],
+		});
+		const refreshedRegistry = buildSlashCommandRegistry({
+			workflowSlashCommands: [],
+		});
+
+		expect(
+			expandUserCommandPrompt("/find-skills what can u do?", staleRegistry),
+		).toContain("<user_command");
+		expect(
+			resolveSlashCommand(refreshedRegistry, "find-skills"),
+		).toBeUndefined();
+		expect(
+			expandUserCommandPrompt("/find-skills what can u do?", refreshedRegistry),
+		).toBe("/find-skills what can u do?");
+	});
+
+	it("hides fork from autocomplete until a session has messages", () => {
+		const emptySessionRegistry = buildSlashCommandRegistry({ canFork: false });
+		const activeSessionRegistry = buildSlashCommandRegistry({ canFork: true });
+
+		expect(resolveSlashCommand(emptySessionRegistry, "fork")).toMatchObject({
+			execution: "local",
+			visible: false,
+			selectable: false,
+		});
+		expect(
+			getVisibleSystemSlashCommands(emptySessionRegistry).map(
+				(command) => command.name,
+			),
+		).not.toContain("fork");
+		expect(
+			getVisibleSystemSlashCommands(activeSessionRegistry).map(
+				(command) => command.name,
+			),
+		).toContain("fork");
+	});
+
+	it("keeps skills visible even when no invokable skills are installed", () => {
+		const emptyRegistry = buildSlashCommandRegistry({});
+
+		expect(resolveSlashCommand(emptyRegistry, "skills")).toMatchObject({
+			execution: "local",
+			visible: true,
+			selectable: true,
+		});
+		expect(
+			getVisibleSystemSlashCommands(emptyRegistry).map(
+				(command) => command.name,
+			),
+		).toContain("skills");
+	});
+
+	it("exposes plugins as a local settings shortcut", () => {
+		const registry = buildSlashCommandRegistry({});
+		const commandNames = getVisibleSystemSlashCommands(registry).map(
+			(command) => command.name,
+		);
+
+		expect(resolveSlashCommand(registry, "plugins")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			description: "Manage plugins",
+			visible: true,
+			selectable: true,
+		});
+		expect(commandNames).toContain("plugins");
+		expect(commandNames.indexOf("plugins")).toBeGreaterThan(
+			commandNames.indexOf("mcp"),
+		);
+		expect(commandNames.indexOf("plugins")).toBeLessThan(
+			commandNames.indexOf("skills"),
+		);
+	});
+
+	it("keeps config as a hidden alias for settings", () => {
+		const registry = buildSlashCommandRegistry({ canFork: true });
+
+		expect(resolveSlashCommand(registry, "config")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			description: "Modify agent configuration",
+			visible: false,
+			selectable: false,
+		});
+		expect(
+			getVisibleSystemSlashCommands(registry).map((command) => command.name),
+		).not.toContain("config");
+		expect(
+			getVisibleSystemSlashCommands(registry).map((command) => command.name),
+		).toContain("settings");
+	});
+
+	it("always exposes the account command", () => {
+		const registry = buildSlashCommandRegistry({});
+
+		expect(resolveSlashCommand(registry, "account")).toMatchObject({
+			source: "tui",
+			execution: "local",
+			visible: true,
+		});
+		expect(
+			getVisibleSystemSlashCommands(registry).map((command) => command.name),
+		).toContain("account");
+	});
+});
diff --git a/apps/cli/src/tui/commands/slash-command-registry.ts b/apps/cli/src/tui/commands/slash-command-registry.ts
new file mode 100644
index 0000000..d10be48
--- /dev/null
+++ b/apps/cli/src/tui/commands/slash-command-registry.ts
@@ -0,0 +1,308 @@
+import { formatUserCommandBlock } from "@cline/shared";
+import type { InteractiveSlashCommand } from "../interactive-welcome";
+
+export type SlashCommandSource =
+	| "tui"
+	| "runtime"
+	| "plugin"
+	| "skill"
+	| "workflow";
+
+export type SlashCommandExecution = "local" | "runtime" | "user-command";
+
+export type LocalSlashCommandName =
+	| "settings"
+	| "config"
+	| "mcp"
+	| "plugins"
+	| "account"
+	| "model"
+	| "compact"
+	| "skills"
+	| "fork"
+	| "undo"
+	| "clear"
+	| "history"
+	| "quit"
+	| "help";
+
+export interface SlashCommandRegistryEntry {
+	name: string;
+	description: string;
+	instructions: string;
+	source: SlashCommandSource;
+	kind?: InteractiveSlashCommand["kind"];
+	execution: SlashCommandExecution;
+	visible: boolean;
+	selectable: boolean;
+	preserveInput?: boolean;
+}
+
+export interface SlashCommandRegistry {
+	entries: SlashCommandRegistryEntry[];
+	byName: Map<string, SlashCommandRegistryEntry>;
+}
+
+const TUI_LOCAL_COMMANDS: Array<{
+	name: LocalSlashCommandName;
+	description: string;
+	visible?: boolean;
+	preserveInput?: boolean;
+}> = [
+	{
+		name: "settings",
+		description: "Modify agent configuration",
+	},
+	{
+		name: "config",
+		description: "Modify agent configuration",
+		visible: false,
+	},
+	{
+		name: "model",
+		description: "Switch model or provider",
+	},
+	{
+		name: "account",
+		description: "View Cline account",
+	},
+	{
+		name: "mcp",
+		description: "Manage MCP servers",
+	},
+	{
+		name: "plugins",
+		description: "Manage plugins",
+	},
+	{
+		name: "compact",
+		description: "Compact context",
+	},
+	{
+		name: "skills",
+		description: "Browse skills and workflows",
+		preserveInput: true,
+	},
+	{
+		name: "fork",
+		description: "Create a named fork of the current session",
+	},
+	{
+		name: "undo",
+		description: "Restore to a previous checkpoint",
+	},
+	{
+		name: "clear",
+		description: "Start a new session",
+	},
+	{
+		name: "history",
+		description: "View session history",
+	},
+	{
+		name: "help",
+		description: "Show help",
+	},
+	{
+		name: "quit",
+		description: "Exit Cline",
+	},
+];
+
+const SYSTEM_COMMAND_ORDER = [
+	"settings",
+	"model",
+	"account",
+	"mcp",
+	"plugins",
+	"compact",
+	"skills",
+	"fork",
+	"undo",
+	"clear",
+	"team",
+	"history",
+	"help",
+	"quit",
+] satisfies ReadonlyArray<LocalSlashCommandName | "team">;
+
+const SYSTEM_COMMAND_PRIORITY = new Map<string, number>(
+	SYSTEM_COMMAND_ORDER.map((name, index) => [name, index]),
+);
+
+function normalizeCommandName(name: string): string {
+	return name.trim().replace(/^\/+/, "").toLowerCase();
+}
+
+function normalizeCommandDescription(description: string | undefined): string {
+	return description?.replace(/\s+/g, " ").trim() ?? "";
+}
+
+function addEntry(
+	byName: Map<string, SlashCommandRegistryEntry>,
+	entry: SlashCommandRegistryEntry,
+): void {
+	const normalized = normalizeCommandName(entry.name);
+	if (!normalized || byName.has(normalized)) {
+		return;
+	}
+	byName.set(normalized, {
+		...entry,
+		name: normalized,
+		description: normalizeCommandDescription(entry.description),
+	});
+}
+
+function entryFromRuntimeCommand(
+	command: InteractiveSlashCommand,
+	source: "runtime" | "plugin" | "skill" | "workflow",
+): SlashCommandRegistryEntry | undefined {
+	const name = normalizeCommandName(command.name);
+	if (!name) {
+		return undefined;
+	}
+	const execution: SlashCommandExecution =
+		command.kind === "skill" || command.kind === "workflow"
+			? "user-command"
+			: "runtime";
+	return {
+		name,
+		description: command.description ?? "",
+		instructions: command.instructions,
+		source,
+		kind: command.kind,
+		execution,
+		visible: true,
+		selectable: true,
+	};
+}
+
+export function buildSlashCommandRegistry(input: {
+	workflowSlashCommands?: InteractiveSlashCommand[];
+	additionalSlashCommands?: InteractiveSlashCommand[];
+	canFork?: boolean;
+}): SlashCommandRegistry {
+	const byName = new Map<string, SlashCommandRegistryEntry>();
+
+	for (const command of TUI_LOCAL_COMMANDS) {
+		const isFork = command.name === "fork";
+		const visible =
+			(command.visible ?? true) && (!isFork || input.canFork === true);
+		addEntry(byName, {
+			name: command.name,
+			description: command.description,
+			instructions: "",
+			source: "tui",
+			execution: "local",
+			visible,
+			selectable: visible,
+			preserveInput: command.preserveInput,
+		});
+	}
+
+	for (const command of input.workflowSlashCommands ?? []) {
+		const source =
+			command.kind === "skill" || command.kind === "workflow"
+				? command.kind
+				: "runtime";
+		const entry = entryFromRuntimeCommand(command, source);
+		if (entry) {
+			addEntry(byName, entry);
+		}
+	}
+
+	for (const command of input.additionalSlashCommands ?? []) {
+		const entry = entryFromRuntimeCommand(command, "plugin");
+		if (entry) {
+			addEntry(byName, entry);
+		}
+	}
+
+	return {
+		entries: [...byName.values()],
+		byName,
+	};
+}
+
+export function resolveSlashCommand(
+	registry: SlashCommandRegistry,
+	commandName: string,
+): SlashCommandRegistryEntry | undefined {
+	return registry.byName.get(normalizeCommandName(commandName));
+}
+
+const USER_COMMAND_SLASH_PATTERN = /(^|\s)\/([a-zA-Z0-9_.-]+)(?=\s|$)/g;
+
+export function formatSlashCommandAutocompleteValue(
+	entry: SlashCommandRegistryEntry,
+): string {
+	return `/${entry.name} `;
+}
+
+export function expandUserCommandPrompt(
+	input: string,
+	registry: SlashCommandRegistry,
+): string {
+	if (input.includes("<user_command")) {
+		return input;
+	}
+
+	const expandedSlashCommands = input.replace(
+		USER_COMMAND_SLASH_PATTERN,
+		(match, prefix: string, name: string) => {
+			const command = resolveSlashCommand(registry, name);
+			if (command?.execution !== "user-command") {
+				return match;
+			}
+			return `${prefix}${formatUserCommandBlock(command.instructions, command.name)}`;
+		},
+	);
+	if (expandedSlashCommands !== input) {
+		return expandedSlashCommands;
+	}
+
+	const match = /^\/([a-zA-Z0-9_.-]+)(\s+[\s\S]*)?$/.exec(input.trim());
+	if (!match) {
+		return input;
+	}
+	const command = resolveSlashCommand(registry, match[1] ?? "");
+	if (!command || command.execution !== "user-command") {
+		return input;
+	}
+	const rest = (match[2] ?? "").trim();
+	const block = formatUserCommandBlock(command.instructions, command.name);
+	return rest ? `${block} ${rest}` : block;
+}
+
+export function getVisibleSystemSlashCommands(
+	registry: SlashCommandRegistry,
+): SlashCommandRegistryEntry[] {
+	const visible = registry.entries.filter(
+		(entry) => entry.visible && entry.execution !== "user-command",
+	);
+	const priorityOf = (name: string) =>
+		SYSTEM_COMMAND_PRIORITY.get(name) ?? SYSTEM_COMMAND_ORDER.length;
+	return visible
+		.map((entry, index) => ({ entry, index }))
+		.sort((a, b) => {
+			const pa = priorityOf(a.entry.name);
+			const pb = priorityOf(b.entry.name);
+			if (pa !== pb) return pa - pb;
+			return a.index - b.index;
+		})
+		.map(({ entry }) => entry);
+}
+
+export function getVisibleUserSlashCommands(
+	registry: SlashCommandRegistry,
+): SlashCommandRegistryEntry[] {
+	return registry.entries.filter(
+		(entry) => entry.visible && entry.execution === "user-command",
+	);
+}
+
+export function getInvokableUserSlashCommands(
+	registry: SlashCommandRegistry,
+): SlashCommandRegistryEntry[] {
+	return registry.entries.filter((entry) => entry.execution === "user-command");
+}
diff --git a/apps/cli/src/tui/components/autocomplete-dropdown.tsx b/apps/cli/src/tui/components/autocomplete-dropdown.tsx
new file mode 100644
index 0000000..e21bdee
--- /dev/null
+++ b/apps/cli/src/tui/components/autocomplete-dropdown.tsx
@@ -0,0 +1,188 @@
+import { useTerminalDimensions } from "@opentui/react";
+import type {
+	AutocompleteMode,
+	AutocompleteOption,
+} from "../hooks/use-autocomplete";
+import { useTerminalBackground } from "../hooks/use-terminal-background";
+import { getDefaultForeground, palette } from "../palette";
+
+const MAX_ROWS = 7;
+export const DROPDOWN_MAX_HEIGHT = MAX_ROWS + 2;
+
+export interface AutocompleteDropdownProps {
+	mode: AutocompleteMode;
+	options: AutocompleteOption[];
+	selected: number;
+	onSelect: (option: AutocompleteOption) => void;
+	accent?: string;
+	containerWidth?: number;
+}
+
+export function AutocompleteDropdown(props: AutocompleteDropdownProps) {
+	const { mode, options, selected, onSelect, accent = palette.act } = props;
+	const { width: termWidth } = useTerminalDimensions();
+
+	if (!mode || options.length === 0) return null;
+
+	const effectiveWidth = props.containerWidth ?? termWidth;
+	const rowBudget = Math.max(10, effectiveWidth - 4);
+	const safeSelected = Math.max(0, Math.min(selected, options.length - 1));
+
+	if (options.length <= MAX_ROWS) {
+		return (
+			<box
+				flexDirection="column"
+				border
+				borderStyle="rounded"
+				borderColor="gray"
+			>
+				{options.map((opt, i) => (
+					<OptionRow
+						key={opt.display}
+						opt={opt}
+						isSelected={i === safeSelected}
+						rowBudget={rowBudget}
+						mode={mode}
+						accent={accent}
+						onSelect={onSelect}
+					/>
+				))}
+			</box>
+		);
+	}
+
+	const halfWindow = Math.floor(MAX_ROWS / 2);
+	let start = Math.max(0, safeSelected - halfWindow);
+	if (start + MAX_ROWS > options.length) {
+		start = options.length - MAX_ROWS;
+	}
+
+	const moreAbove = start;
+	const moreBelow = options.length - (start + MAX_ROWS);
+	const showAboveIndicator = moreAbove > 0;
+	const showBelowIndicator = moreBelow > 0;
+
+	const itemSlots =
+		MAX_ROWS - (showAboveIndicator ? 1 : 0) - (showBelowIndicator ? 1 : 0);
+	const itemStart = showAboveIndicator ? start + 1 : start;
+	const visibleItems = options.slice(itemStart, itemStart + itemSlots);
+
+	const aboveCount = itemStart;
+	const belowCount = options.length - (itemStart + itemSlots);
+
+	return (
+		<box flexDirection="column" border borderStyle="rounded" borderColor="gray">
+			{showAboveIndicator && (
+				<box paddingX={1} justifyContent="center">
+					<text fg="gray">
+						{"\u25b2"} {aboveCount} more
+					</text>
+				</box>
+			)}
+			{visibleItems.map((opt, i) => {
+				const absoluteIdx = itemStart + i;
+				return (
+					<OptionRow
+						key={opt.display}
+						opt={opt}
+						isSelected={absoluteIdx === safeSelected}
+						rowBudget={rowBudget}
+						mode={mode}
+						accent={accent}
+						onSelect={onSelect}
+					/>
+				);
+			})}
+			{showBelowIndicator && (
+				<box paddingX={1} justifyContent="center">
+					<text fg="gray">
+						{"\u25bc"} {belowCount} more
+					</text>
+				</box>
+			)}
+		</box>
+	);
+}
+
+function truncateEnd(str: string, max: number): string {
+	if (str.length <= max) return str;
+	return `${str.slice(0, max - 1)}\u2026`;
+}
+
+function truncateStart(str: string, max: number): string {
+	if (str.length <= max) return str;
+	return `\u2026${str.slice(-(max - 1))}`;
+}
+
+function OptionRow(props: {
+	opt: AutocompleteOption;
+	isSelected: boolean;
+	rowBudget: number;
+	mode: AutocompleteMode;
+	accent: string;
+	onSelect: (option: AutocompleteOption) => void;
+}) {
+	const terminalBg = useTerminalBackground();
+	const defaultFg = getDefaultForeground(terminalBg);
+	const { opt, isSelected, rowBudget, mode, accent, onSelect } = props;
+
+	if (opt.isHeader) {
+		return (
+			<box paddingX={1}>
+				<text fg="gray">{opt.display}</text>
+			</box>
+		);
+	}
+
+	const prefix = isSelected ? "\u276f " : "  ";
+	const budgetAfterPrefix = rowBudget - prefix.length;
+
+	let displayName: string;
+	let descText = "";
+
+	if (mode === "@") {
+		displayName = truncateStart(opt.display, budgetAfterPrefix);
+	} else {
+		if (opt.description) {
+			const descColumnBudget = Math.max(
+				0,
+				Math.floor(budgetAfterPrefix * 0.62),
+			);
+			const displayBudget = Math.max(
+				1,
+				budgetAfterPrefix - descColumnBudget - 1,
+			);
+			displayName = truncateEnd(opt.display, displayBudget);
+			if (descColumnBudget > 3) {
+				descText = truncateEnd(opt.description, descColumnBudget);
+			}
+		} else {
+			displayName = truncateEnd(opt.display, budgetAfterPrefix);
+		}
+	}
+
+	const descGap = descText
+		? Math.max(1, budgetAfterPrefix - displayName.length - descText.length)
+		: 0;
+
+	return (
+		<box
+			paddingX={1}
+			backgroundColor={isSelected ? accent : undefined}
+			onMouseDown={() => onSelect(opt)}
+		>
+			<text wrapMode="none">
+				<span fg={isSelected ? palette.textOnSelection : "gray"}>{prefix}</span>
+				<span fg={isSelected ? palette.textOnSelection : defaultFg}>
+					{displayName}
+				</span>
+				{descText ? (
+					<span fg={isSelected ? palette.textOnSelection : "gray"}>
+						{" ".repeat(descGap)}
+						{descText}
+					</span>
+				) : null}
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/chat-entry.tsx b/apps/cli/src/tui/components/chat-entry.tsx
new file mode 100644
index 0000000..67d2c34
--- /dev/null
+++ b/apps/cli/src/tui/components/chat-entry.tsx
@@ -0,0 +1,633 @@
+import type { ClineSubscriptionPlan } from "@cline/core";
+import { useTerminalDimensions } from "@opentui/react";
+import type React from "react";
+import { useEffect, useState } from "react";
+import "opentui-spinner/react";
+import {
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassLimitDetailMessage,
+	getCliSubscriptionUrl,
+	getIndividualPlanFeatures,
+	isClineOrgIndividualInferenceSubscriptionErrorMessage,
+	isClinePassLimitErrorMessage,
+	isClinePassSubscriptionError,
+} from "../../utils/cline-pass-errors";
+import {
+	CLINE_CREDITS_DASHBOARD_URL,
+	isClineAccountCreditsErrorMessage,
+} from "../cline-account";
+import { useTerminalBackground } from "../hooks/use-terminal-background";
+import {
+	getDefaultForeground,
+	getModeAccent,
+	getUserMessageBackground,
+	palette,
+	type TerminalTheme,
+} from "../palette";
+import type { ChatEntry } from "../types";
+import { getSyntaxStyle, type SyntaxAccentMode } from "../utils/syntax-style";
+import { isWarningToolError } from "../utils/tool-errors";
+import {
+	parseApplyPatchInput,
+	parseAskQuestionInput,
+	parseEditorInput,
+	parseReadFilesInput,
+	parseRunCommandsInput,
+	parseSearchInput,
+	parseSpawnAgentInput,
+	parseWebFetchInput,
+	shortenPath,
+} from "../utils/tool-parsing";
+import { ToolOutput } from "./tool-output";
+
+function trimLeading(text: string): string {
+	return text.replace(/^\n+/, "");
+}
+
+function ReasoningBlock(props: { text: string; streaming: boolean }) {
+	const [expanded, setExpanded] = useState(false);
+	const { width } = useTerminalDimensions();
+	const content = trimLeading(props.text);
+	if (!content.trim()) {
+		if (props.streaming) {
+			return (
+				<box flexDirection="row" gap={1}>
+					<spinner name="dots" color="gray" />
+					<text fg="gray">
+						<em>Thinking...</em>
+					</text>
+				</box>
+			);
+		}
+		return null;
+	}
+
+	if (props.streaming) {
+		const lines = content.split("\n");
+		return (
+			<box flexDirection="column">
+				<box flexDirection="row" gap={1}>
+					<spinner name="dots" color="gray" />
+					<text fg="gray">
+						<em>Thinking...</em>
+					</text>
+				</box>
+				<box flexDirection="column" paddingLeft={2}>
+					{lines.map((line) => (
+						<text key={line} fg="gray" selectable>
+							<em>{line || " "}</em>
+						</text>
+					))}
+				</box>
+			</box>
+		);
+	}
+
+	if (expanded) {
+		const lines = content.split("\n");
+		return (
+			<box flexDirection="column" onMouseDown={() => setExpanded(false)}>
+				<text fg="gray">
+					{"\u25bc"} <em>Thinking:</em>
+				</text>
+				<box flexDirection="column" paddingLeft={2}>
+					{lines.map((line) => (
+						<text key={line} fg="gray" selectable>
+							<em>{line || " "}</em>
+						</text>
+					))}
+				</box>
+			</box>
+		);
+	}
+
+	const padding = 4;
+	const prefix = "\u25b6 Thinking: ";
+	const available = Math.max(10, width - padding - prefix.length - 3);
+	const flat = content.replace(/\n/g, " ").trim();
+	const tail =
+		flat.length <= available
+			? flat
+			: `...${flat.slice(flat.length - available)}`;
+
+	return (
+		<box onMouseDown={() => setExpanded(true)}>
+			<text fg="gray" selectable>
+				{"\u25b6"} <em>Thinking: {tail}</em>
+			</text>
+		</box>
+	);
+}
+
+function formatToolParams(
+	toolName: string,
+	rawInput: unknown,
+	fallback: string,
+): React.ReactNode {
+	switch (toolName) {
+		case "read_files": {
+			const info = parseReadFilesInput(rawInput);
+			if (!info?.files.length) return fallback;
+			return info.files.map((f, i) => {
+				const sl = f.startLine != null ? String(f.startLine) : "undefined";
+				const el = f.endLine != null ? String(f.endLine) : "undefined";
+				const sep = i > 0 ? "; " : "";
+				return (
+					<span key={f.path}>
+						{sep}
+						{shortenPath(f.path)}
+						<span fg="gray">
+							, start_line={sl}, end_line={el}
+						</span>
+					</span>
+				);
+			});
+		}
+		case "run_commands": {
+			const info = parseRunCommandsInput(rawInput);
+			if (!info?.commands.length) return fallback;
+			return info.commands.join(" && ");
+		}
+		case "editor":
+		case "edit":
+		case "write": {
+			const info = parseEditorInput(rawInput);
+			if (!info) return fallback;
+			return shortenPath(info.path);
+		}
+		case "apply_patch": {
+			const patchInfo = parseApplyPatchInput(rawInput);
+			if (!patchInfo?.files.length) return fallback;
+			return patchInfo.files.map((f) => shortenPath(f)).join(", ");
+		}
+		case "search_codebase": {
+			const info = parseSearchInput(rawInput);
+			if (!info?.queries.length) return fallback;
+			return info.queries.join(", ");
+		}
+		case "fetch_web_content": {
+			const info = parseWebFetchInput(rawInput);
+			if (!info?.urls.length) return fallback;
+			return info.urls.join(", ");
+		}
+		case "spawn_agent": {
+			const info = parseSpawnAgentInput(rawInput);
+			if (!info) return fallback;
+			const task =
+				info.task.length > 60 ? `${info.task.slice(0, 60)}...` : info.task;
+			return task;
+		}
+		case "ask_question":
+		case "ask_followup_question": {
+			const info = parseAskQuestionInput(rawInput);
+			if (!info) return fallback;
+			const q =
+				info.question.length > 60
+					? `${info.question.slice(0, 60)}...`
+					: info.question;
+			return q;
+		}
+		case "switch_to_act_mode":
+			return "";
+		case "skills": {
+			if (rawInput && typeof rawInput === "object" && "skill" in rawInput) {
+				const s = String((rawInput as { skill: unknown }).skill);
+				const args =
+					"args" in rawInput
+						? ` ${String((rawInput as { args: unknown }).args)}`
+						: "";
+				const full = `${s}${args}`;
+				return full.length > 70 ? `${full.slice(0, 70)}...` : full;
+			}
+			return fallback;
+		}
+		default:
+			return fallback;
+	}
+}
+
+function ToolCallView(props: {
+	toolName: string;
+	inputSummary: string;
+	rawInput?: unknown;
+	accent?: string;
+	defaultFg?: string;
+	streaming: boolean;
+	result?: {
+		outputSummary: string;
+		rawOutput?: unknown;
+		error?: string;
+	};
+}) {
+	const {
+		toolName,
+		inputSummary,
+		streaming,
+		result,
+		accent = palette.act,
+		defaultFg,
+	} = props;
+	const failed = result?.error != null;
+	const warningFailure = isWarningToolError(result?.error);
+	const params = formatToolParams(toolName, props.rawInput, inputSummary);
+
+	return (
+		<box flexDirection="column">
+			<box flexDirection="row">
+				<box width={2}>
+					{streaming ? (
+						<spinner name="dots" color="gray" />
+					) : warningFailure ? (
+						<text fg="yellow">!</text>
+					) : failed ? (
+						<text fg="red">x</text>
+					) : (
+						<text fg={accent}>*</text>
+					)}
+				</box>
+				<text fg={defaultFg} selectable>
+					<span fg={accent}>
+						<strong>{toolName}</strong>
+					</span>
+					<span fg={accent}>
+						<strong>(</strong>
+					</span>
+					<span>{params}</span>
+					<span fg={accent}>
+						<strong>)</strong>
+					</span>
+				</text>
+			</box>
+			{result && (
+				<ToolOutput
+					toolName={toolName}
+					outputSummary={result.outputSummary}
+					rawOutput={result.rawOutput}
+					rawInput={props.rawInput}
+					error={result.error}
+				/>
+			)}
+		</box>
+	);
+}
+
+function ClineCreditsClinePassErrorView(props: { defaultFg?: string }) {
+	const subscriptionUrl = getCliSubscriptionUrl();
+	return (
+		<box flexDirection="row">
+			<text fg="red" content="* " />
+			<box
+				flexDirection="column"
+				border
+				borderStyle="rounded"
+				borderColor="red"
+				paddingX={1}
+			>
+				<text fg="red">Cline Credits depleted</text>
+				<text
+					fg={props.defaultFg}
+					selectable
+					content={
+						"You have run out of Cline credits. Add credits in the dashboard or purchase and switch to ClinePass to continue."
+					}
+				/>
+				<box flexDirection="row">
+					<text fg="gray">Purchase Credits: </text>
+					<text fg={palette.act} selectable>
+						<a href={CLINE_CREDITS_DASHBOARD_URL}>
+							{CLINE_CREDITS_DASHBOARD_URL}
+						</a>
+					</text>
+				</box>
+				<box flexDirection="row">
+					<text fg="gray">Purchase ClinePass: </text>
+					<text fg={palette.act} selectable>
+						<a href={subscriptionUrl}>{subscriptionUrl}</a>
+					</text>
+				</box>
+				<box flexDirection="row">
+					<text fg="gray">Switch to ClinePass: </text>
+					<text fg="gray">
+						type /settings in CLI and switch provider to ClinePass
+					</text>
+				</box>
+			</box>
+		</box>
+	);
+}
+
+function ClineCreditsErrorView(props: { defaultFg?: string }) {
+	return <ClineCreditsClinePassErrorView defaultFg={props.defaultFg} />;
+}
+
+function ClinePassSubscriptionErrorView(props: {
+	defaultFg?: string;
+	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
+	terminalTheme: TerminalTheme;
+}) {
+	const subscriptionUrl = getCliSubscriptionUrl();
+	const [planFeatures, setPlanFeatures] = useState<string[]>([]);
+	const planAccent = getModeAccent("plan", props.terminalTheme);
+
+	useEffect(() => {
+		if (!props.loadIndividualSubscriptionPlans) {
+			return;
+		}
+		let isMounted = true;
+		void props
+			.loadIndividualSubscriptionPlans()
+			.then((plans) => {
+				if (isMounted) {
+					setPlanFeatures(getIndividualPlanFeatures(plans));
+				}
+			})
+			.catch(() => {
+				// Keep the subscription error view usable if plan metadata is unavailable.
+			});
+
+		return () => {
+			isMounted = false;
+		};
+	}, [props.loadIndividualSubscriptionPlans]);
+
+	return (
+		<box flexDirection="row">
+			<text fg={planAccent} content="* " />
+			<box
+				flexDirection="column"
+				border
+				borderStyle="rounded"
+				borderColor={planAccent}
+				paddingX={1}
+			>
+				<text fg={planAccent}>ClinePass subscription required</text>
+				<text
+					fg={props.defaultFg}
+					selectable
+					content="No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan."
+				/>
+				{planFeatures.length > 0 && (
+					<box flexDirection="column" marginTop={1}>
+						<text fg={props.defaultFg}>ClinePass includes:</text>
+						{planFeatures.map((feature) => (
+							<text key={feature} fg={props.defaultFg} selectable>
+								<span fg="green">✓ </span>
+								<span>{feature}</span>
+							</text>
+						))}
+					</box>
+				)}
+				<box flexDirection="row">
+					<text fg="gray">Subscribe: </text>
+					<text fg={palette.act} selectable>
+						<a href={subscriptionUrl}>Open subscription page</a>
+					</text>
+				</box>
+				<box flexDirection="row">
+					<text fg="gray">URL: </text>
+					<text fg={palette.act} selectable>
+						<a href={subscriptionUrl}>{subscriptionUrl}</a>
+					</text>
+				</box>
+			</box>
+		</box>
+	);
+}
+
+function ClineOrgIndividualInferenceSubscriptionErrorView(props: {
+	defaultFg?: string;
+	terminalTheme: TerminalTheme;
+}) {
+	const planAccent = getModeAccent("plan", props.terminalTheme);
+
+	return (
+		<box flexDirection="row">
+			<text fg={planAccent} content="* " />
+			<box
+				flexDirection="column"
+				border
+				borderStyle="rounded"
+				borderColor={planAccent}
+				paddingX={1}
+			>
+				<text fg={planAccent}>Personal ClinePass required</text>
+				<text
+					fg={props.defaultFg}
+					selectable
+					content={getClineOrgIndividualInferenceSubscriptionMessage()}
+				/>
+			</box>
+		</box>
+	);
+}
+
+function ClinePassLimitErrorView(props: {
+	message: string;
+	defaultFg?: string;
+	terminalTheme: TerminalTheme;
+}) {
+	const detail = getClinePassLimitDetailMessage(props.message) ?? props.message;
+
+	return (
+		<box flexDirection="row">
+			<text fg={palette.act} content="* " />
+			<box
+				flexDirection="column"
+				border
+				borderStyle="rounded"
+				borderColor={palette.act}
+				paddingX={1}
+			>
+				<text fg="red">ClinePass limit reached</text>
+				<text fg={props.defaultFg} selectable content={detail} />
+				<text
+					fg={props.defaultFg}
+					selectable
+					content="Switch to Cline usage-based billing and retry with the Cline provider."
+				/>
+				<box flexDirection="row">
+					<text fg="gray">Interactive CLI: </text>
+					<text
+						fg={props.defaultFg}
+						selectable
+						content="type /model, press tab to change provider, choose Cline, then retry."
+					/>
+				</box>
+				<box flexDirection="row">
+					<text fg="gray">Headless CLI: </text>
+					<text fg={props.defaultFg} selectable content="rerun with " />
+					<code
+						content="--provider cline"
+						filetype="bash"
+						syntaxStyle={getSyntaxStyle(props.terminalTheme)}
+						selectable
+					/>
+					<text fg={props.defaultFg} selectable content="." />
+				</box>
+			</box>
+		</box>
+	);
+}
+
+export function ChatEntryView(props: {
+	entry: ChatEntry;
+	accent?: string;
+	/** Mode the entry was produced in (resolved with the current-mode fallback). */
+	mode?: SyntaxAccentMode;
+	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
+	terminalTheme: TerminalTheme;
+}) {
+	const { entry, accent = palette.act, mode = "act", terminalTheme } = props;
+	const terminalBg = useTerminalBackground();
+	const defaultFg = getDefaultForeground(terminalBg);
+	const userMsgBg = getUserMessageBackground(terminalBg);
+
+	switch (entry.kind) {
+		case "user":
+			return (
+				<box
+					flexDirection="row"
+					backgroundColor={userMsgBg}
+					marginX={-1}
+					paddingLeft={1}
+					paddingRight={2}
+				>
+					<box width={2}>
+						<text fg={accent}>{"❯"}</text>
+					</box>
+					<text fg={defaultFg} selectable>
+						{entry.text}
+					</text>
+				</box>
+			);
+
+		case "user_submitted":
+			return (
+				<box
+					flexDirection="row"
+					backgroundColor={userMsgBg}
+					marginX={-1}
+					paddingLeft={1}
+					paddingRight={2}
+				>
+					<box width={2}>
+						<text fg={accent}>{"❯"}</text>
+					</box>
+					{entry.delivery === "steer" && <text fg="yellow">[steer] </text>}
+					{entry.delivery === "queue" && <text fg="gray">[queued] </text>}
+					<text fg={defaultFg} selectable>
+						{entry.text}
+					</text>
+				</box>
+			);
+
+		case "assistant_text": {
+			const content = trimLeading(entry.text);
+			if (!content.trim()) return null;
+			return (
+				<box flexDirection="row">
+					<box width={2}>
+						{entry.streaming ? (
+							<spinner name="dots" color={accent} />
+						) : (
+							<text fg={accent}>*</text>
+						)}
+					</box>
+					<box flexGrow={1}>
+						<markdown
+							content={content}
+							syntaxStyle={getSyntaxStyle(terminalTheme, mode)}
+							streaming={entry.streaming}
+							fg={defaultFg}
+						/>
+					</box>
+				</box>
+			);
+		}
+
+		case "reasoning":
+			return <ReasoningBlock text={entry.text} streaming={entry.streaming} />;
+
+		case "tool_call":
+			return (
+				<ToolCallView
+					toolName={entry.toolName}
+					inputSummary={entry.inputSummary}
+					rawInput={entry.rawInput}
+					streaming={entry.streaming}
+					result={entry.result}
+					accent={accent}
+					defaultFg={defaultFg}
+				/>
+			);
+
+		case "error":
+			if (isClineAccountCreditsErrorMessage(entry.text)) {
+				return <ClineCreditsErrorView defaultFg={defaultFg} />;
+			}
+			if (isClineOrgIndividualInferenceSubscriptionErrorMessage(entry.text)) {
+				return (
+					<ClineOrgIndividualInferenceSubscriptionErrorView
+						defaultFg={defaultFg}
+						terminalTheme={terminalTheme}
+					/>
+				);
+			}
+			if (isClinePassSubscriptionError(entry.text)) {
+				return (
+					<ClinePassSubscriptionErrorView
+						defaultFg={defaultFg}
+						loadIndividualSubscriptionPlans={
+							props.loadIndividualSubscriptionPlans
+						}
+						terminalTheme={terminalTheme}
+					/>
+				);
+			}
+			if (isClinePassLimitErrorMessage(entry.text)) {
+				return (
+					<ClinePassLimitErrorView
+						message={entry.text}
+						defaultFg={defaultFg}
+						terminalTheme={terminalTheme}
+					/>
+				);
+			}
+			return (
+				<box flexDirection="row">
+					<text fg="red" content="* " />
+					<text fg="red" selectable content={`Error: ${entry.text}`} />
+				</box>
+			);
+
+		case "status":
+			return (
+				<box flexDirection="row">
+					<text fg="gray" content="* " />
+					<text fg="gray" selectable content={entry.text} />
+				</box>
+			);
+
+		case "team":
+			return (
+				<box flexDirection="row">
+					<text fg="gray" content="* " />
+					<text fg="gray" selectable content={entry.text} />
+				</box>
+			);
+
+		case "done": {
+			const parts: string[] = [];
+			if (entry.elapsed) parts.push(`${entry.elapsed}s`);
+			if (entry.tokens > 0)
+				parts.push(`${entry.tokens.toLocaleString()} tokens`);
+			if (entry.cost > 0) parts.push(`$${entry.cost.toFixed(2)}`);
+			if (entry.iterations > 0)
+				parts.push(
+					`${entry.iterations} iteration${entry.iterations !== 1 ? "s" : ""}`,
+				);
+			if (parts.length === 0) return null;
+			return <text fg="gray" content={parts.join(" | ")} />;
+		}
+	}
+}
diff --git a/apps/cli/src/tui/components/chat-message-list.tsx b/apps/cli/src/tui/components/chat-message-list.tsx
new file mode 100644
index 0000000..6438057
--- /dev/null
+++ b/apps/cli/src/tui/components/chat-message-list.tsx
@@ -0,0 +1,124 @@
+import "opentui-spinner/react";
+import type { AgentMode, ClineSubscriptionPlan } from "@cline/core";
+import type { ScrollBoxRenderable } from "@opentui/core";
+import {
+	forwardRef,
+	useCallback,
+	useEffect,
+	useImperativeHandle,
+	useRef,
+} from "react";
+import type { TranscriptCommand } from "../hooks/transcript-keybinds";
+import { useTerminalTheme } from "../hooks/use-terminal-background";
+import { getModeAccent } from "../palette";
+import type { ChatEntry } from "../types";
+import { ChatEntryView } from "./chat-entry";
+
+export interface TranscriptScrollHandle {
+	runTranscriptCommand: (command: TranscriptCommand) => void;
+}
+
+interface ChatMessageListProps {
+	entries: ChatEntry[];
+	isStreaming?: boolean;
+	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
+	uiMode?: AgentMode;
+}
+
+export const ChatMessageList = forwardRef<
+	TranscriptScrollHandle,
+	ChatMessageListProps
+>(function ChatMessageList(props, ref) {
+	const scrollboxRef = useRef<ScrollBoxRenderable | null>(null);
+	const lastEntry = props.entries.at(-1);
+	const terminalTheme = useTerminalTheme();
+	const accent = getModeAccent(props.uiMode ?? "act", terminalTheme);
+	const userSubmissionScrollKey =
+		lastEntry?.kind === "user_submitted" ? props.entries.length : 0;
+
+	const runTranscriptCommand = useCallback((command: TranscriptCommand) => {
+		const scrollbox = scrollboxRef.current;
+		if (!scrollbox) return;
+
+		switch (command) {
+			case "messages_page_up":
+				scrollbox.scrollBy(-scrollbox.height / 2);
+				return;
+			case "messages_page_down":
+				scrollbox.scrollBy(scrollbox.height / 2);
+				return;
+			case "messages_half_page_up":
+				scrollbox.scrollBy(-scrollbox.height / 4);
+				return;
+			case "messages_half_page_down":
+				scrollbox.scrollBy(scrollbox.height / 4);
+				return;
+			case "messages_first":
+				scrollbox.scrollTo(0);
+				return;
+			case "messages_last":
+				scrollbox.scrollTo(scrollbox.scrollHeight);
+				return;
+		}
+	}, []);
+
+	useImperativeHandle(
+		ref,
+		() => ({
+			runTranscriptCommand,
+		}),
+		[runTranscriptCommand],
+	);
+
+	useEffect(() => {
+		if (!userSubmissionScrollKey) return;
+
+		const scrollToBottom = () => {
+			const scrollbox = scrollboxRef.current;
+			if (!scrollbox) return;
+
+			scrollbox.scrollTo(scrollbox.scrollHeight);
+		};
+
+		scrollToBottom();
+		queueMicrotask(scrollToBottom);
+		const timeout = setTimeout(scrollToBottom, 0);
+		return () => clearTimeout(timeout);
+	}, [userSubmissionScrollKey]);
+
+	return (
+		<scrollbox
+			ref={scrollboxRef}
+			flexGrow={1}
+			stickyScroll
+			stickyStart="bottom"
+		>
+			<box flexDirection="column" paddingX={1} paddingY={1} gap={1}>
+				{props.entries.map((entry, i) => {
+					const key = `${i}:${entry.kind}`;
+					// Single source of truth for the entry's mode: the glyph accent
+					// and the markdown accent must never diverge.
+					const entryMode = entry.mode ?? props.uiMode ?? "act";
+					return (
+						<ChatEntryView
+							key={key}
+							entry={entry}
+							accent={getModeAccent(entryMode, terminalTheme)}
+							mode={entryMode === "plan" ? "plan" : "act"}
+							loadIndividualSubscriptionPlans={
+								props.loadIndividualSubscriptionPlans
+							}
+							terminalTheme={terminalTheme}
+						/>
+					);
+				})}
+				{props.isStreaming && (
+					<box flexDirection="row" gap={1}>
+						<spinner name="dots" color={accent} />
+						<text fg="gray">Thinking... (esc to cancel)</text>
+					</box>
+				)}
+			</box>
+		</scrollbox>
+	);
+});
diff --git a/apps/cli/src/tui/components/dialogs/account-dialog.tsx b/apps/cli/src/tui/components/dialogs/account-dialog.tsx
new file mode 100644
index 0000000..f794331
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/account-dialog.tsx
@@ -0,0 +1,565 @@
+// @jsxImportSource @opentui/react
+import type { ClineAccountOrganization } from "@cline/core";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+	type ClineAccountSnapshot,
+	formatClineCredits,
+	isClineAccountAuthErrorMessage,
+} from "../../cline-account";
+import { palette } from "../../palette";
+
+export type AccountDialogAction =
+	| "change-model"
+	| "change-provider"
+	| "learn-more"
+	| "login";
+
+type AccountView = "overview" | "organizations";
+
+type AccountState =
+	| { status: "loading"; message: string }
+	| { status: "loaded"; snapshot: ClineAccountSnapshot }
+	| { status: "unauthenticated"; message: string }
+	| { status: "error"; message: string };
+
+interface OrganizationRowData {
+	id: string;
+	organizationId: string | null;
+	label: string;
+	description: string;
+	active: boolean;
+}
+
+interface AccountAction {
+	id:
+		| "change-model"
+		| "change-account"
+		| "change-provider"
+		| "learn-more"
+		| "login";
+	label: string;
+	description: string;
+	enabled: boolean;
+}
+
+const LOADED_ACTIONS: AccountAction[] = [
+	{
+		id: "change-model",
+		label: "Change model",
+		description: "Open the Cline model selector",
+		enabled: true,
+	},
+	{
+		id: "change-account",
+		label: "Change account",
+		description: "Switch personal account or organization",
+		enabled: true,
+	},
+	{
+		id: "change-provider",
+		label: "Change provider",
+		description: "Open provider picker",
+		enabled: true,
+	},
+];
+
+const UNAUTHENTICATED_ACTIONS: AccountAction[] = [
+	{
+		id: "login",
+		label: "Sign in or create account",
+		description: "Use Cline OAuth",
+		enabled: true,
+	},
+	{
+		id: "learn-more",
+		label: "Learn more",
+		description: "Open cline.bot",
+		enabled: true,
+	},
+];
+
+function clampIndex(index: number, total: number): number {
+	if (total <= 0) return 0;
+	if (index < 0) return total - 1;
+	if (index >= total) return 0;
+	return index;
+}
+
+function formatDate(dateStr: string): string {
+	const date = new Date(dateStr);
+	if (Number.isNaN(date.getTime())) {
+		return dateStr;
+	}
+	return date.toLocaleDateString("en-US", {
+		month: "short",
+		day: "numeric",
+		year: "numeric",
+	});
+}
+
+function userInitial(snapshot: ClineAccountSnapshot): string {
+	const candidate =
+		snapshot.user.displayName?.trim() || snapshot.user.email?.trim() || "?";
+	return candidate.charAt(0).toUpperCase();
+}
+
+function AccountField(props: { label: string; value: string }) {
+	return (
+		<box flexDirection="row" overflow="hidden">
+			<text fg="gray" width={16} flexShrink={0}>
+				{props.label}
+			</text>
+			<text selectable>{props.value}</text>
+		</box>
+	);
+}
+
+function AccountActionRow(props: {
+	action: AccountAction;
+	selected: boolean;
+	onSelect: () => void;
+}) {
+	const fg = props.selected ? palette.textOnSelection : undefined;
+	return (
+		<box
+			flexDirection="row"
+			gap={1}
+			paddingX={1}
+			height={1}
+			justifyContent="space-between"
+			backgroundColor={props.selected ? palette.selection : undefined}
+			onMouseDown={props.onSelect}
+			overflow="hidden"
+		>
+			<box flexDirection="row" gap={1} flexShrink={0}>
+				<text
+					fg={props.selected ? palette.textOnSelection : "gray"}
+					flexShrink={0}
+				>
+					{props.selected ? ">" : " "}
+				</text>
+				<text fg={fg} flexShrink={0}>
+					{props.action.label}
+				</text>
+			</box>
+			<text
+				fg={props.selected ? palette.textOnSelection : "gray"}
+				flexShrink={1}
+			>
+				{props.action.description}
+			</text>
+		</box>
+	);
+}
+
+function OrganizationRow(props: {
+	label: string;
+	description: string;
+	active: boolean;
+	selected: boolean;
+	onSelect: () => void;
+}) {
+	return (
+		<box
+			flexDirection="row"
+			gap={1}
+			paddingX={1}
+			height={1}
+			justifyContent="space-between"
+			backgroundColor={props.selected ? palette.selection : undefined}
+			onMouseDown={props.onSelect}
+			overflow="hidden"
+		>
+			<box flexDirection="row" gap={1} flexShrink={0}>
+				<text
+					fg={props.selected ? palette.textOnSelection : "gray"}
+					flexShrink={0}
+				>
+					{props.selected ? ">" : " "}
+				</text>
+				<text
+					fg={props.selected ? palette.textOnSelection : undefined}
+					flexShrink={0}
+				>
+					{props.label}
+				</text>
+			</box>
+			<box flexDirection="row" gap={1} flexShrink={1}>
+				<text fg={props.selected ? palette.textOnSelection : "gray"}>
+					{props.description}
+				</text>
+				{props.active && (
+					<text fg={props.selected ? palette.textOnSelection : palette.success}>
+						Active
+					</text>
+				)}
+			</box>
+		</box>
+	);
+}
+
+function accountActions(snapshot: ClineAccountSnapshot): AccountAction[] {
+	return LOADED_ACTIONS.map((action) => {
+		if (action.id !== "change-account") {
+			return action;
+		}
+		return {
+			...action,
+			enabled:
+				snapshot.organizations.length > 0 ||
+				Boolean(snapshot.activeOrganization),
+		};
+	});
+}
+
+function organizationDescription(org: ClineAccountOrganization): string {
+	const roles = org.roles.length > 0 ? org.roles.join(", ") : "member";
+	return roles;
+}
+
+export function AccountDialogContent(
+	props: ChoiceContext<AccountDialogAction> & {
+		loadAccount: () => Promise<ClineAccountSnapshot>;
+		switchAccount: (organizationId?: string | null) => Promise<void>;
+		onAccountChange?: () => Promise<void>;
+	},
+) {
+	const {
+		dismiss,
+		resolve,
+		dialogId,
+		loadAccount,
+		switchAccount,
+		onAccountChange,
+	} = props;
+	const [state, setState] = useState<AccountState>({
+		status: "loading",
+		message: "Loading account details...",
+	});
+	const [view, setView] = useState<AccountView>("overview");
+	const [selectedAction, setSelectedAction] = useState(0);
+	const [selectedOrganization, setSelectedOrganization] = useState(0);
+	const generation = useRef(0);
+
+	const reload = useCallback(async () => {
+		const currentGeneration = generation.current + 1;
+		generation.current = currentGeneration;
+		setState({ status: "loading", message: "Loading account details..." });
+		try {
+			const snapshot = await loadAccount();
+			if (generation.current === currentGeneration) {
+				setState({ status: "loaded", snapshot });
+				setSelectedAction(0);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (generation.current === currentGeneration) {
+				setState({
+					status: isClineAccountAuthErrorMessage(message)
+						? "unauthenticated"
+						: "error",
+					message,
+				});
+				setSelectedAction(0);
+			}
+		}
+	}, [loadAccount]);
+
+	useEffect(() => {
+		void reload();
+	}, [reload]);
+
+	const snapshot = state.status === "loaded" ? state.snapshot : undefined;
+	const actions = useMemo(
+		() =>
+			snapshot
+				? accountActions(snapshot)
+				: state.status === "unauthenticated"
+					? UNAUTHENTICATED_ACTIONS
+					: LOADED_ACTIONS,
+		[snapshot, state.status],
+	);
+	const orgRows = useMemo(() => {
+		if (!snapshot) {
+			return [];
+		}
+		return [
+			{
+				id: "personal",
+				organizationId: null,
+				label: "Personal account",
+				description: snapshot.user.email,
+				active: snapshot.activeOrganization === null,
+			},
+			...snapshot.organizations.map((org) => ({
+				id: org.organizationId,
+				organizationId: org.organizationId,
+				label: org.name,
+				description: organizationDescription(org),
+				active: org.active,
+			})),
+		];
+	}, [snapshot]);
+
+	const switchToOrganization = useCallback(
+		async (row: OrganizationRowData) => {
+			setState({
+				status: "loading",
+				message: row.organizationId
+					? `Switching to ${row.label}...`
+					: "Switching to personal account...",
+			});
+			try {
+				await switchAccount(row.organizationId);
+				await onAccountChange?.();
+				setView("overview");
+				await reload();
+			} catch (error) {
+				setView("overview");
+				setState({
+					status: "error",
+					message: error instanceof Error ? error.message : String(error),
+				});
+			}
+		},
+		[onAccountChange, reload, switchAccount],
+	);
+
+	const runSelectedOrganization = useCallback(async () => {
+		const row = orgRows[selectedOrganization];
+		if (!row) return;
+		await switchToOrganization(row);
+	}, [orgRows, selectedOrganization, switchToOrganization]);
+
+	const setActiveOrganizationSelection = useCallback(() => {
+		const activeIndex = orgRows.findIndex((row) => row.active);
+		setSelectedOrganization(activeIndex >= 0 ? activeIndex : 0);
+	}, [orgRows]);
+
+	const openOrganizationView = useCallback(() => {
+		setView("organizations");
+		setActiveOrganizationSelection();
+	}, [setActiveOrganizationSelection]);
+
+	const runAction = useCallback(
+		(action: AccountAction) => {
+			if (!action.enabled) return;
+			if (action.id === "change-model") {
+				resolve("change-model");
+				return;
+			}
+			if (action.id === "login") {
+				resolve("login");
+				return;
+			}
+			if (action.id === "learn-more") {
+				resolve("learn-more");
+				return;
+			}
+			if (action.id === "change-provider") {
+				resolve("change-provider");
+				return;
+			}
+			if (action.id === "change-account") {
+				openOrganizationView();
+			}
+		},
+		[openOrganizationView, resolve],
+	);
+
+	const runSelectedAction = useCallback(() => {
+		const action = actions[selectedAction];
+		if (!action) return;
+		runAction(action);
+	}, [actions, runAction, selectedAction]);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			if (view === "organizations") {
+				setView("overview");
+				return;
+			}
+			dismiss();
+			return;
+		}
+		if (state.status === "loading") {
+			return;
+		}
+		if (state.status === "error") {
+			return;
+		}
+		if (view === "organizations") {
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				setSelectedOrganization((index) =>
+					clampIndex(index - 1, orgRows.length),
+				);
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				setSelectedOrganization((index) =>
+					clampIndex(index + 1, orgRows.length),
+				);
+				return;
+			}
+			if (key.name === "return" || key.name === "enter") {
+				void runSelectedOrganization();
+			}
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setSelectedAction((index) => clampIndex(index - 1, actions.length));
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setSelectedAction((index) => clampIndex(index + 1, actions.length));
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			runSelectedAction();
+		}
+	}, dialogId);
+
+	if (state.status === "loading") {
+		return (
+			<box flexDirection="column" paddingX={1} gap={1}>
+				<text fg={palette.act}>Cline Account</text>
+				<text fg="gray">{state.message}</text>
+				<text fg="gray">Esc to close</text>
+			</box>
+		);
+	}
+
+	if (state.status === "error") {
+		return (
+			<box flexDirection="column" paddingX={1} gap={1}>
+				<text fg={palette.act}>Cline Account</text>
+				<text fg="red">{state.message}</text>
+				<text fg="gray">Esc to close</text>
+			</box>
+		);
+	}
+
+	if (state.status === "unauthenticated") {
+		return (
+			<box flexDirection="column" paddingX={1} gap={1}>
+				<text fg={palette.act}>Cline Account</text>
+				<text>Sign in or create a Cline account.</text>
+				<text fg="gray">
+					Get access to the latest models with regular free promos and
+					discounts.
+				</text>
+
+				<box flexDirection="column">
+					{actions.map((action, index) => (
+						<AccountActionRow
+							key={action.id}
+							action={action}
+							selected={index === selectedAction}
+							onSelect={() => {
+								setSelectedAction(index);
+								runAction(action);
+							}}
+						/>
+					))}
+				</box>
+
+				<text fg="gray">↑/↓ navigate, Enter to select, Esc to close</text>
+			</box>
+		);
+	}
+
+	if (view === "organizations") {
+		return (
+			<box flexDirection="column" paddingX={1}>
+				<text fg={palette.act}>Change Account</text>
+				<box flexDirection="column" gap={0}>
+					{orgRows.map((row, index) => (
+						<OrganizationRow
+							key={row.id}
+							label={row.label}
+							description={row.description}
+							active={row.active}
+							selected={index === selectedOrganization}
+							onSelect={() => {
+								setSelectedOrganization(index);
+								void switchToOrganization(row);
+							}}
+						/>
+					))}
+				</box>
+				<text fg="gray">↑/↓ navigate, Enter to select, Esc to go back</text>
+			</box>
+		);
+	}
+
+	const { snapshot: loaded } = state;
+	const displayName =
+		loaded.user.displayName?.trim() ||
+		loaded.user.email?.trim() ||
+		"Cline user";
+	const activeAccount = loaded.activeOrganization?.name ?? "Personal account";
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg={palette.act}>Cline Account</text>
+
+			<box flexDirection="row" gap={2}>
+				<box
+					width={5}
+					height={3}
+					alignItems="center"
+					justifyContent="center"
+					border
+					borderColor="gray"
+				>
+					<text fg={palette.act}>{userInitial(loaded)}</text>
+				</box>
+				<box flexDirection="column" flexGrow={1}>
+					<text selectable>{displayName}</text>
+					<text fg="gray" selectable>
+						{loaded.user.email}
+					</text>
+					<text fg="gray">
+						Member since {formatDate(loaded.user.createdAt)}
+					</text>
+				</box>
+			</box>
+
+			<box flexDirection="column" border borderColor="gray" paddingX={1}>
+				<AccountField label="Active account" value={activeAccount} />
+				<AccountField
+					label="Credits"
+					value={formatClineCredits(loaded.displayedBalance)}
+				/>
+				{loaded.activeOrganization && (
+					<AccountField
+						label="Personal"
+						value={formatClineCredits(loaded.balance.balance)}
+					/>
+				)}
+				<AccountField
+					label="Organizations"
+					value={String(loaded.organizations.length)}
+				/>
+			</box>
+
+			<box flexDirection="column">
+				{actions.map((action, index) => (
+					<AccountActionRow
+						key={action.id}
+						action={action}
+						selected={index === selectedAction}
+						onSelect={() => {
+							setSelectedAction(index);
+							runAction(action);
+						}}
+					/>
+				))}
+			</box>
+
+			<text fg="gray">↑/↓ navigate, Enter to select, Esc to close</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/ask-question.tsx b/apps/cli/src/tui/components/dialogs/ask-question.tsx
new file mode 100644
index 0000000..d3a69d7
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/ask-question.tsx
@@ -0,0 +1,143 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useRef, useState } from "react";
+import { palette } from "../../palette";
+
+export function AskQuestionContent(
+	props: ChoiceContext<string | null> & {
+		question: string;
+		options: string[];
+	},
+) {
+	const { resolve, dialogId, question, options } = props;
+	const [selected, setSelected] = useState(0);
+	const [inputKey, setInputKey] = useState(0);
+	const customRef = useRef("");
+	const selectedRef = useRef(0);
+
+	const typing = selected === options.length;
+	const totalOptions = options.length + 1;
+
+	useDialogKeyboard((key) => {
+		const isTyping = selectedRef.current === options.length;
+		if (key.name === "escape") {
+			if (isTyping && customRef.current) {
+				customRef.current = "";
+				setInputKey((k) => k + 1);
+				return;
+			}
+			resolve(null);
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			if (isTyping) {
+				if (customRef.current.trim()) {
+					resolve(customRef.current.trim());
+				}
+				return;
+			}
+			resolve(options[selectedRef.current] ?? "");
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setSelected((s) => {
+				const next = s <= 0 ? totalOptions - 1 : s - 1;
+				selectedRef.current = next;
+				return next;
+			});
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setSelected((s) => {
+				const next = s >= totalOptions - 1 ? 0 : s + 1;
+				selectedRef.current = next;
+				return next;
+			});
+			return;
+		}
+		if (!isTyping && key.name >= "1" && key.name <= "9") {
+			const num = Number.parseInt(key.name, 10);
+			if (num >= 1 && num <= options.length) {
+				resolve(options[num - 1] ?? "");
+			}
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text selectable>{question}</text>
+
+			<box flexDirection="column">
+				{options.map((opt, i) => (
+					<box
+						key={opt}
+						paddingX={1}
+						flexDirection="row"
+						gap={1}
+						backgroundColor={
+							!typing && i === selected ? palette.selection : undefined
+						}
+						onMouseDown={() => resolve(opt)}
+					>
+						<text
+							fg={!typing && i === selected ? palette.textOnSelection : "gray"}
+							flexShrink={0}
+						>
+							{!typing && i === selected ? "\u276f" : " "}
+						</text>
+						<text
+							fg={
+								!typing && i === selected ? palette.textOnSelection : undefined
+							}
+						>
+							{opt}
+						</text>
+					</box>
+				))}
+				<box
+					paddingX={1}
+					flexDirection="row"
+					gap={1}
+					backgroundColor={typing ? palette.selection : undefined}
+				>
+					<text
+						fg={
+							typing
+								? palette.textOnSelection
+								: selected === options.length
+									? palette.selection
+									: "gray"
+						}
+						flexShrink={0}
+					>
+						{selected === options.length ? "\u276f" : " "}
+					</text>
+					{typing ? (
+						<input
+							key={inputKey}
+							onInput={(v: string) => {
+								customRef.current = v;
+							}}
+							placeholder="Type a response..."
+							flexGrow={1}
+							focused
+						/>
+					) : (
+						<text fg="gray">
+							<em>Type a response...</em>
+						</text>
+					)}
+				</box>
+			</box>
+
+			<text fg="gray">
+				<em>
+					{typing
+						? "Enter to submit, Esc to go back"
+						: `↑/↓ navigate, Enter to select, 1-${options.length} to pick`}
+				</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/checkpoint-confirm.tsx b/apps/cli/src/tui/components/dialogs/checkpoint-confirm.tsx
new file mode 100644
index 0000000..392f57d
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/checkpoint-confirm.tsx
@@ -0,0 +1,114 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useRef, useState } from "react";
+import { palette } from "../../palette";
+
+export type CheckpointRestoreMode = "chat-only" | "chat-and-workspace";
+
+const OPTIONS: Array<{
+	value: CheckpointRestoreMode;
+	label: string;
+	detail: string;
+}> = [
+	{
+		value: "chat-only",
+		label: "Restore chat only",
+		detail: "Rewind conversation, keep current files",
+	},
+	{
+		value: "chat-and-workspace",
+		label: "Restore chat and workspace",
+		detail: "Rewind conversation and reset files",
+	},
+];
+
+export function CheckpointConfirmContent(
+	props: ChoiceContext<CheckpointRestoreMode> & {
+		messagePreview: string;
+	},
+) {
+	const { resolve, dismiss, dialogId, messagePreview } = props;
+	const [selected, setSelected] = useState(0);
+	const selectedRef = useRef(0);
+	const selectedMode = OPTIONS[selected]?.value;
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			const option = OPTIONS[selectedRef.current];
+			if (option) {
+				resolve(option.value);
+			}
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setSelected((s) => {
+				const next = s <= 0 ? OPTIONS.length - 1 : s - 1;
+				selectedRef.current = next;
+				return next;
+			});
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setSelected((s) => {
+				const next = s >= OPTIONS.length - 1 ? 0 : s + 1;
+				selectedRef.current = next;
+				return next;
+			});
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text>
+				Restore to: {'"'}
+				{messagePreview}
+				{'"'}
+			</text>
+
+			<box flexDirection="column">
+				{OPTIONS.map((opt, i) => {
+					const isSel = i === selected;
+					return (
+						<box
+							key={opt.value}
+							paddingX={1}
+							flexDirection="row"
+							gap={1}
+							backgroundColor={isSel ? palette.selection : undefined}
+						>
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{isSel ? "❯" : " "}
+							</text>
+							<box flexDirection="column">
+								<text fg={isSel ? palette.textOnSelection : undefined}>
+									{opt.label}
+								</text>
+								<text fg={isSel ? palette.textOnSelection : "gray"}>
+									{opt.detail}
+								</text>
+							</box>
+						</box>
+					);
+				})}
+			</box>
+
+			{selectedMode === "chat-and-workspace" && (
+				<text fg="yellow">
+					This runs git reset --hard and git clean -fd in the workspace.
+				</text>
+			)}
+
+			<text fg="gray">
+				<em>{"↑/↓ navigate, Enter to confirm, Esc to cancel"}</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/checkpoint-picker.tsx b/apps/cli/src/tui/components/dialogs/checkpoint-picker.tsx
new file mode 100644
index 0000000..52a58ec
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/checkpoint-picker.tsx
@@ -0,0 +1,165 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useMemo, useRef, useState } from "react";
+import { palette } from "../../palette";
+
+export interface CheckpointPickerItem {
+	runCount: number;
+	text: string;
+	fullText: string;
+	createdAt: number;
+}
+
+export interface CheckpointPickerResult {
+	runCount: number;
+	messagePreview: string;
+	fullText: string;
+}
+
+function formatRelativeTime(timestamp: number): string {
+	const diffMs = Date.now() - timestamp;
+	const diffMins = Math.floor(diffMs / 60_000);
+	if (diffMins < 1) return "just now";
+	if (diffMins < 60) return `${diffMins}m ago`;
+	const diffHours = Math.floor(diffMins / 60);
+	if (diffHours < 24) return `${diffHours}h ago`;
+	const diffDays = Math.floor(diffHours / 24);
+	return `${diffDays}d ago`;
+}
+
+const MAX_VISIBLE = 10;
+
+export function CheckpointPickerContent(
+	props: ChoiceContext<CheckpointPickerResult> & {
+		items: CheckpointPickerItem[];
+	},
+) {
+	const { resolve, dismiss, dialogId, items } = props;
+	const lastIndex = Math.max(0, items.length - 1);
+	const [selected, setSelected] = useState(lastIndex);
+	const selectedRef = useRef(lastIndex);
+
+	const safeSelected = Math.min(selected, Math.max(0, items.length - 1));
+	selectedRef.current = safeSelected;
+
+	const window = useMemo(() => {
+		if (items.length <= MAX_VISIBLE) {
+			return { visible: items, startIndex: 0 };
+		}
+		const half = Math.floor(MAX_VISIBLE / 2);
+		let start = Math.max(0, safeSelected - half);
+		const end = Math.min(items.length, start + MAX_VISIBLE);
+		if (end - start < MAX_VISIBLE) start = Math.max(0, end - MAX_VISIBLE);
+		return { visible: items.slice(start, end), startIndex: start };
+	}, [items, safeSelected]);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			const item = items[selectedRef.current];
+			if (item) {
+				resolve({
+					runCount: item.runCount,
+					messagePreview: item.text,
+					fullText: item.fullText,
+				});
+			}
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setSelected((s) => {
+				const next = s <= 0 ? items.length - 1 : s - 1;
+				selectedRef.current = next;
+				return next;
+			});
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setSelected((s) => {
+				const next = s >= items.length - 1 ? 0 : s + 1;
+				selectedRef.current = next;
+				return next;
+			});
+		}
+	}, dialogId);
+
+	if (items.length === 0) {
+		return (
+			<box flexDirection="column" paddingX={1} gap={1}>
+				<text>Restore to Checkpoint</text>
+				<text fg="gray">No checkpoints available</text>
+				<text fg="gray">
+					<em>Esc to close</em>
+				</text>
+			</box>
+		);
+	}
+
+	const aboveCount = window.startIndex;
+	const belowCount = items.length - window.startIndex - window.visible.length;
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text>Restore to Checkpoint</text>
+
+			<box flexDirection="column" marginTop={1}>
+				{aboveCount > 0 && (
+					<text fg="gray">
+						{"▲ "}
+						{aboveCount} more
+					</text>
+				)}
+
+				{window.visible.map((item, i) => {
+					const absIdx = window.startIndex + i;
+					const isSel = absIdx === safeSelected;
+					const time = formatRelativeTime(item.createdAt);
+
+					return (
+						<box
+							key={item.runCount}
+							paddingX={1}
+							flexDirection="row"
+							gap={1}
+							backgroundColor={isSel ? palette.selection : undefined}
+							overflow="hidden"
+							height={1}
+						>
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{isSel ? "❯" : " "}
+							</text>
+							<text fg={isSel ? palette.textOnSelection : undefined}>
+								{item.text}
+							</text>
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{"  "}
+								{time}
+							</text>
+						</box>
+					);
+				})}
+
+				{belowCount > 0 && (
+					<text fg="gray">
+						{"▼ "}
+						{belowCount} more
+					</text>
+				)}
+			</box>
+
+			<text fg="gray" marginTop={1}>
+				<em>{"↑/↓ navigate, Enter to select, Esc to cancel"}</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/command-palette-items.ts b/apps/cli/src/tui/components/dialogs/command-palette-items.ts
new file mode 100644
index 0000000..01b5afe
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/command-palette-items.ts
@@ -0,0 +1,218 @@
+export type CommandPaletteAction =
+	| "settings"
+	| "change-model"
+	| "change-provider"
+	| "account"
+	| "mcp"
+	| "plugins"
+	| "compact"
+	| "skills"
+	| "fork"
+	| "undo"
+	| "clear"
+	| "history"
+	| "help"
+	| "quit";
+
+export interface CommandPaletteResult {
+	kind: "action";
+	action: CommandPaletteAction;
+}
+
+export interface CommandPaletteItem {
+	id: string;
+	label: string;
+	description: string;
+	shortcut: string;
+	keywords: string[];
+	result: CommandPaletteResult;
+}
+
+const ACTION_ITEMS: Array<{
+	action: CommandPaletteAction;
+	label: string;
+	shortcut: string;
+	description: string;
+	keywords: string[];
+	requiresFork?: boolean;
+}> = [
+	{
+		action: "settings",
+		label: "Open Settings",
+		shortcut: "Opt+S",
+		description: "Review and edit CLI configuration",
+		keywords: ["config", "preferences", "general", "tools"],
+	},
+	{
+		action: "change-model",
+		label: "Change Model",
+		shortcut: "Opt+M",
+		description: "Pick a different model for future requests",
+		keywords: ["model", "provider", "llm", "reasoning", "thinking"],
+	},
+	{
+		action: "change-provider",
+		label: "Change Provider",
+		shortcut: "Opt+P",
+		description: "Switch provider and configure credentials",
+		keywords: ["provider", "api key", "account", "auth"],
+	},
+	{
+		action: "mcp",
+		label: "Manage MCP Servers",
+		shortcut: "Opt+C",
+		description: "Enable, disable, or inspect MCP servers",
+		keywords: ["mcp", "server", "tool", "toggle"],
+	},
+	{
+		action: "plugins",
+		label: "Manage Plugins",
+		shortcut: "Opt+G",
+		description: "Open plugin settings",
+		keywords: ["plugins", "extensions", "settings"],
+	},
+	{
+		action: "account",
+		label: "Open Account",
+		shortcut: "Opt+A",
+		description: "View or switch your Cline account",
+		keywords: ["account", "login", "auth", "cline"],
+	},
+	{
+		action: "compact",
+		label: "Compact Context",
+		shortcut: "Opt+X",
+		description: "Compact context",
+		keywords: ["compact", "context", "compress"],
+	},
+	{
+		action: "skills",
+		label: "Browse Skills",
+		shortcut: "Opt+W",
+		description: "Insert an installed skill or workflow command",
+		keywords: ["skills", "workflows", "marketplace"],
+	},
+	{
+		action: "fork",
+		label: "Create Session Fork",
+		shortcut: "Opt+R",
+		description: "Branch the current conversation into a new session",
+		keywords: ["fork", "session", "branch"],
+		requiresFork: true,
+	},
+	{
+		action: "undo",
+		label: "Restore Checkpoint",
+		shortcut: "Opt+U",
+		description: "Return to an earlier checkpoint",
+		keywords: ["undo", "checkpoint", "restore"],
+	},
+	{
+		action: "clear",
+		label: "Start New Session",
+		shortcut: "Opt+L",
+		description: "Clear the conversation and restart the session",
+		keywords: ["clear", "new", "reset"],
+	},
+	{
+		action: "history",
+		label: "Session History",
+		shortcut: "Opt+H",
+		description: "Resume a previous session",
+		keywords: ["history", "resume", "sessions"],
+	},
+	{
+		action: "help",
+		label: "Open Help",
+		shortcut: "Opt+K",
+		description: "Show CLI shortcuts and commands",
+		keywords: ["help", "shortcuts", "commands"],
+	},
+	{
+		action: "quit",
+		label: "Exit Cline",
+		shortcut: "Opt+Q",
+		description: "Close the interactive CLI",
+		keywords: ["quit", "exit"],
+	},
+];
+
+function normalize(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/[+-]/g, " ")
+		.replace(/[^a-z0-9/ ]/g, "")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function includesAllTokens(haystack: string, tokens: string[]): boolean {
+	return tokens.every((token) => haystack.includes(token));
+}
+
+function scoreItem(item: CommandPaletteItem, query: string): number {
+	const normalizedQuery = normalize(query.trim());
+	if (!normalizedQuery) return 1;
+
+	const tokens = normalizedQuery.split(/\s+/).filter(Boolean);
+	const label = normalize(item.label);
+	const description = normalize(item.description);
+	const keywordText = normalize(item.keywords.join(" "));
+	const shortcut = normalize(item.shortcut);
+	const searchText = `${label} ${description} ${keywordText} ${shortcut}`;
+
+	if (!includesAllTokens(searchText, tokens)) return 0;
+	if (label === normalizedQuery) return 120;
+	if (label.startsWith(normalizedQuery)) return 100;
+	if (label.includes(normalizedQuery)) return 75;
+	if (shortcut.includes(normalizedQuery)) return 70;
+	if (keywordText.includes(normalizedQuery)) return 60;
+	if (description.includes(normalizedQuery)) return 45;
+	return 20;
+}
+
+export function buildCommandPaletteItems(input: {
+	canForkSession: boolean;
+}): CommandPaletteItem[] {
+	return ACTION_ITEMS.filter(
+		(item) => !item.requiresFork || input.canForkSession,
+	).map((item) => ({
+		id: `action:${item.action}`,
+		label: item.label,
+		description: item.description,
+		shortcut: item.shortcut,
+		keywords: item.keywords,
+		result: { kind: "action" as const, action: item.action },
+	}));
+}
+
+export function filterCommandPaletteItems(
+	items: CommandPaletteItem[],
+	query: string,
+): CommandPaletteItem[] {
+	return items
+		.map((item, index) => ({
+			item,
+			index,
+			score: scoreItem(item, query),
+		}))
+		.filter((entry) => entry.score > 0)
+		.sort((a, b) => {
+			if (b.score !== a.score) return b.score - a.score;
+			return a.index - b.index;
+		})
+		.map((entry) => entry.item);
+}
+
+export function findCommandPaletteShortcut(
+	items: readonly CommandPaletteItem[],
+	key: { name: string; meta: boolean; option?: boolean; shift: boolean },
+): CommandPaletteItem | undefined {
+	if (!key.meta && key.option !== true) return undefined;
+	const keyName = key.name.toLowerCase();
+	return items.find((item) => {
+		const [, shortcutKey] = item.shortcut.toLowerCase().split("+");
+		if (!shortcutKey) return false;
+		return shortcutKey === keyName;
+	});
+}
diff --git a/apps/cli/src/tui/components/dialogs/command-palette.test.ts b/apps/cli/src/tui/components/dialogs/command-palette.test.ts
new file mode 100644
index 0000000..5f2cf10
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/command-palette.test.ts
@@ -0,0 +1,144 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildSlashCommandRegistry,
+	getVisibleSystemSlashCommands,
+} from "../../commands/slash-command-registry";
+import {
+	buildCommandPaletteItems,
+	filterCommandPaletteItems,
+	findCommandPaletteShortcut,
+} from "./command-palette-items";
+
+describe("command palette", () => {
+	it("builds action-only palette items with shortcuts", () => {
+		const items = buildCommandPaletteItems({
+			canForkSession: false,
+		});
+		const labels = items.map((item) => item.label);
+
+		expect(labels).toContain("Change Provider");
+		expect(labels).toContain("Manage MCP Servers");
+		expect(labels).toContain("Manage Plugins");
+		expect(labels).toContain("Compact Context");
+		expect(labels).not.toContain("/settings");
+		expect(labels).not.toContain("Toggle Plan/Act Mode");
+		expect(labels).not.toContain("Toggle Auto-Approve");
+		expect(labels).not.toContain("Create Session Fork");
+		expect(items.every((item) => item.shortcut.startsWith("Opt+"))).toBe(true);
+		expect(items.map((item) => item.shortcut)).not.toContain("Opt+?");
+	});
+
+	it("shows fork only when the current session can be forked", () => {
+		const items = buildCommandPaletteItems({
+			canForkSession: true,
+		});
+
+		expect(items.map((item) => item.label)).toContain("Create Session Fork");
+	});
+
+	it("covers visible local slash commands with palette wording", () => {
+		const registry = buildSlashCommandRegistry({
+			canFork: true,
+		});
+		const slashCommands = getVisibleSystemSlashCommands(registry).filter(
+			(command) => command.source === "tui" && command.name !== "config",
+		);
+		const items = buildCommandPaletteItems({
+			canForkSession: true,
+		});
+		const paletteByCommandName = new Map(
+			items.map((item) => [
+				item.result.action === "change-model" ? "model" : item.result.action,
+				item,
+			]),
+		);
+
+		for (const command of slashCommands) {
+			expect(paletteByCommandName.has(command.name)).toBe(true);
+		}
+		expect(paletteByCommandName.get("settings")?.description).toBe(
+			"Review and edit CLI configuration",
+		);
+	});
+
+	it("ranks direct actions over lower confidence matches", () => {
+		const items = buildCommandPaletteItems({
+			canForkSession: true,
+		});
+
+		expect(filterCommandPaletteItems(items, "provider")[0]?.label).toBe(
+			"Change Provider",
+		);
+		expect(filterCommandPaletteItems(items, "mcp")[0]?.label).toBe(
+			"Manage MCP Servers",
+		);
+		expect(filterCommandPaletteItems(items, "plugins")[0]?.label).toBe(
+			"Manage Plugins",
+		);
+		expect(filterCommandPaletteItems(items, "opt m")[0]?.label).toBe(
+			"Change Model",
+		);
+	});
+
+	it("finds opt shortcut matches without using searchable text input keys", () => {
+		const items = buildCommandPaletteItems({
+			canForkSession: true,
+		});
+
+		expect(
+			findCommandPaletteShortcut(items, {
+				name: "m",
+				meta: true,
+				option: false,
+				shift: false,
+			})?.label,
+		).toBe("Change Model");
+		expect(
+			findCommandPaletteShortcut(items, {
+				name: "m",
+				meta: false,
+				option: true,
+				shift: false,
+			})?.label,
+		).toBe("Change Model");
+		expect(
+			findCommandPaletteShortcut(items, {
+				name: "m",
+				meta: false,
+				option: false,
+				shift: false,
+			}),
+		).toBeUndefined();
+		expect(
+			findCommandPaletteShortcut(items, {
+				name: "k",
+				meta: true,
+				option: false,
+				shift: false,
+			})?.label,
+		).toBe("Open Help");
+	});
+
+	it("keeps option right available for word navigation", () => {
+		const items = buildCommandPaletteItems({
+			canForkSession: true,
+		});
+
+		expect(
+			findCommandPaletteShortcut(items, {
+				name: "f",
+				meta: false,
+				option: true,
+				shift: false,
+			}),
+		).toBeUndefined();
+		expect(
+			findCommandPaletteShortcut(items, {
+				name: "r",
+				meta: false,
+				option: true,
+				shift: false,
+			})?.label,
+		).toBe("Create Session Fork");
+	});
+});
diff --git a/apps/cli/src/tui/components/dialogs/command-palette.tsx b/apps/cli/src/tui/components/dialogs/command-palette.tsx
new file mode 100644
index 0000000..11a8af9
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/command-palette.tsx
@@ -0,0 +1,228 @@
+// @jsxImportSource @opentui/react
+import { useTerminalDimensions } from "@opentui/react";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useMemo, useRef, useState } from "react";
+import { palette } from "../../palette";
+import {
+	buildCommandPaletteItems,
+	type CommandPaletteResult,
+	filterCommandPaletteItems,
+	findCommandPaletteShortcut,
+} from "./command-palette-items";
+
+export type { CommandPaletteResult } from "./command-palette-items";
+
+function truncate(value: string, maxWidth: number): string {
+	if (maxWidth <= 0) return "";
+	if (value.length <= maxWidth) return value;
+	if (maxWidth <= 3) return value.slice(0, maxWidth);
+	return `${value.slice(0, maxWidth - 3)}...`;
+}
+
+function countWrappedLines(value: string, width: number): number {
+	if (width <= 0) return 1;
+	return Math.max(1, Math.ceil(value.length / width));
+}
+
+export function CommandPaletteContent(
+	props: ChoiceContext<CommandPaletteResult> & {
+		canForkSession: boolean;
+		contentWidth: number;
+	},
+) {
+	const { resolve, dismiss, dialogId, canForkSession, contentWidth } = props;
+	const { height } = useTerminalDimensions();
+	const [query, setQuery] = useState("");
+	const [selected, setSelected] = useState(0);
+
+	const allItems = useMemo(
+		() =>
+			buildCommandPaletteItems({
+				canForkSession,
+			}),
+		[canForkSession],
+	);
+	const filtered = useMemo(
+		() => filterCommandPaletteItems(allItems, query),
+		[allItems, query],
+	);
+	const safeSelected = Math.min(selected, Math.max(0, filtered.length - 1));
+
+	const filteredRef = useRef(filtered);
+	filteredRef.current = filtered;
+	const allItemsRef = useRef(allItems);
+	allItemsRef.current = allItems;
+	const selectedRef = useRef(safeSelected);
+	selectedRef.current = safeSelected;
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			key.preventDefault();
+			dismiss();
+			return;
+		}
+		if (key.ctrl && key.name === "c") {
+			key.preventDefault();
+			dismiss();
+			return;
+		}
+		const shortcut = findCommandPaletteShortcut(allItemsRef.current, key);
+		if (shortcut) {
+			key.preventDefault();
+			resolve(shortcut.result);
+			return;
+		}
+		if (key.name === "return" || key.name === "enter" || key.name === "tab") {
+			key.preventDefault();
+			const item = filteredRef.current[selectedRef.current];
+			if (item) resolve(item.result);
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			key.preventDefault();
+			setSelected((index) =>
+				filteredRef.current.length === 0
+					? 0
+					: index <= 0
+						? filteredRef.current.length - 1
+						: index - 1,
+			);
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			key.preventDefault();
+			setSelected((index) =>
+				filteredRef.current.length === 0
+					? 0
+					: index >= filteredRef.current.length - 1
+						? 0
+						: index + 1,
+			);
+		}
+	}, dialogId);
+
+	const shortcutWidth = 5;
+	const shortcutGap = 1;
+	const itemPaddingLeft = 1;
+	const itemPaddingRight = 1;
+	const itemContentWidth = Math.max(
+		0,
+		contentWidth - itemPaddingLeft - itemPaddingRight,
+	);
+	const descriptionWidth = itemContentWidth;
+	const labelWidth = Math.max(
+		0,
+		itemContentWidth - shortcutGap - shortcutWidth,
+	);
+	const rowHeight =
+		2 +
+		Math.max(
+			1,
+			...filtered.map((item) =>
+				countWrappedLines(item.description, descriptionWidth),
+			),
+		);
+	const maxVisible = Math.max(3, Math.floor((height - 12) / rowHeight));
+	const start = Math.max(
+		0,
+		Math.min(
+			safeSelected - Math.floor(maxVisible / 2),
+			Math.max(0, filtered.length - maxVisible),
+		),
+	);
+	const visible = filtered.slice(start, start + maxVisible);
+
+	return (
+		<box flexDirection="column" width={contentWidth} gap={1}>
+			<box flexDirection="row" width="100%" gap={1}>
+				<text flexGrow={1}>Command Palette</text>
+				<text fg="gray" flexShrink={0}>
+					Ctrl+P
+				</text>
+			</box>
+
+			<box
+				border
+				borderStyle="rounded"
+				borderColor="gray"
+				paddingX={1}
+				width="100%"
+			>
+				<input
+					value={query}
+					onInput={(value: string) => {
+						setQuery(value);
+						setSelected(0);
+					}}
+					placeholder="Search actions..."
+					flexGrow={1}
+					focused
+				/>
+			</box>
+
+			<box flexDirection="column">
+				{visible.length === 0 ? (
+					<text fg="gray">No matching commands found.</text>
+				) : (
+					visible.map((item, localIndex) => {
+						const absoluteIndex = start + localIndex;
+						const isSelected = absoluteIndex === safeSelected;
+						return (
+							<box key={item.id} flexDirection="column">
+								<box
+									flexDirection="column"
+									paddingLeft={itemPaddingLeft}
+									paddingRight={itemPaddingRight}
+									width={contentWidth}
+									overflow="hidden"
+									backgroundColor={isSelected ? palette.selection : undefined}
+									onMouseDown={() => resolve(item.result)}
+								>
+									<box flexDirection="row" height={1} width={itemContentWidth}>
+										<text
+											fg={isSelected ? palette.textOnSelection : "white"}
+											width={labelWidth}
+											flexShrink={0}
+										>
+											{truncate(item.label, labelWidth)}
+										</text>
+										<text width={shortcutGap} flexShrink={0}>
+											{" "}
+										</text>
+										<text
+											fg={isSelected ? palette.textOnSelection : palette.act}
+											width={shortcutWidth}
+											flexShrink={0}
+										>
+											{item.shortcut}
+										</text>
+									</box>
+									<text
+										fg={isSelected ? palette.textOnSelection : "gray"}
+										width={descriptionWidth}
+									>
+										{item.description}
+									</text>
+								</box>
+								{localIndex < visible.length - 1 ? (
+									<box
+										border={["top"]}
+										borderStyle="rounded"
+										borderColor="gray"
+										width={contentWidth}
+										height={1}
+									/>
+								) : null}
+							</box>
+						);
+					})
+				)}
+			</box>
+
+			<text fg="gray">
+				Type to search, arrow keys navigate, Enter to run, Esc to close
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/config-dialogs-helpers.ts b/apps/cli/src/tui/components/dialogs/config-dialogs-helpers.ts
new file mode 100644
index 0000000..2faec59
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/config-dialogs-helpers.ts
@@ -0,0 +1,94 @@
+import type { InteractiveConfigItem } from "../../interactive-config";
+import { isToggleableInteractiveConfigItem } from "../../interactive-config";
+
+export type ExtDetailRow =
+	| { kind: "header"; name: string; source: string }
+	| { kind: "field"; label: "Path" | "Description" | "Error"; value: string[] }
+	| { kind: "status"; enabled: boolean };
+
+const TOGGLE_FOOTER = "Space toggle status, Tab/Enter/Esc to go back";
+const DETAIL_FOOTER = "Tab/Enter/Esc to go back";
+
+const MAX_DESCRIPTION_LINES = 12;
+const MAX_DESCRIPTION_COLUMNS = 78;
+
+function wrapDetailLine(line: string): string[] {
+	if (line.length <= MAX_DESCRIPTION_COLUMNS) {
+		return [line];
+	}
+	const wrapped: string[] = [];
+	let remaining = line;
+	while (remaining.length > MAX_DESCRIPTION_COLUMNS) {
+		let splitAt = remaining.lastIndexOf(" ", MAX_DESCRIPTION_COLUMNS);
+		if (splitAt <= 0) {
+			splitAt = MAX_DESCRIPTION_COLUMNS;
+		}
+		wrapped.push(remaining.slice(0, splitAt));
+		remaining = remaining.slice(splitAt).trimStart();
+	}
+	wrapped.push(remaining);
+	return wrapped;
+}
+
+function truncateDescription(description: string): string[] {
+	const lines = description.split("\n").flatMap(wrapDetailLine);
+	if (lines.length <= MAX_DESCRIPTION_LINES) {
+		return lines;
+	}
+	return [
+		...lines.slice(0, MAX_DESCRIPTION_LINES),
+		`… truncated ${lines.length - MAX_DESCRIPTION_LINES} lines`,
+	];
+}
+
+export function shouldCloseExtDetailForKey(keyName: string): boolean {
+	return keyName === "escape" || keyName === "return" || keyName === "tab";
+}
+
+export function shouldToggleExtDetailForKey(
+	keyName: string,
+	item: Pick<InteractiveConfigItem, "kind" | "source" | "enabled">,
+): boolean {
+	return (
+		keyName === "space" &&
+		typeof item.enabled === "boolean" &&
+		isToggleableInteractiveConfigItem(item)
+	);
+}
+
+export function getExtDetailFooterText(
+	item: Pick<InteractiveConfigItem, "kind" | "source" | "enabled">,
+): string {
+	return typeof item.enabled === "boolean" &&
+		isToggleableInteractiveConfigItem(item)
+		? TOGGLE_FOOTER
+		: DETAIL_FOOTER;
+}
+
+export function getExtDetailRows(item: InteractiveConfigItem): ExtDetailRow[] {
+	const rows: ExtDetailRow[] = [
+		{ kind: "header", name: item.name, source: item.source },
+		{ kind: "field", label: "Path", value: [item.path] },
+	];
+	if (item.description) {
+		rows.push({
+			kind: "field",
+			label: "Description",
+			value: truncateDescription(item.description),
+		});
+	}
+	if (item.loadError) {
+		rows.push({
+			kind: "field",
+			label: "Error",
+			value: truncateDescription(item.loadError),
+		});
+	}
+	if (
+		typeof item.enabled === "boolean" &&
+		isToggleableInteractiveConfigItem(item)
+	) {
+		rows.push({ kind: "status", enabled: item.enabled });
+	}
+	return rows;
+}
diff --git a/apps/cli/src/tui/components/dialogs/config-dialogs.test.ts b/apps/cli/src/tui/components/dialogs/config-dialogs.test.ts
new file mode 100644
index 0000000..2b5455e
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/config-dialogs.test.ts
@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import type { InteractiveConfigItem } from "../../interactive-config";
+import {
+	getExtDetailFooterText,
+	getExtDetailRows,
+	shouldCloseExtDetailForKey,
+	shouldToggleExtDetailForKey,
+} from "./config-dialogs-helpers";
+
+function createItem(
+	overrides: Partial<InteractiveConfigItem> &
+		Pick<InteractiveConfigItem, "kind">,
+): InteractiveConfigItem {
+	return {
+		id: "item-id",
+		name: "item-name",
+		path: "/tmp/item",
+		enabled: true,
+		source: "workspace",
+		...overrides,
+	};
+}
+
+describe("config detail dialog helpers", () => {
+	it("closes details for Enter, Escape, and Tab", () => {
+		expect(shouldCloseExtDetailForKey("return")).toBe(true);
+		expect(shouldCloseExtDetailForKey("escape")).toBe(true);
+		expect(shouldCloseExtDetailForKey("tab")).toBe(true);
+		expect(shouldCloseExtDetailForKey("space")).toBe(false);
+	});
+
+	it("toggles detail status on Space only for toggleable rows", () => {
+		const skill = createItem({ kind: "skill" });
+		const mcp = createItem({ kind: "mcp" });
+		const workflow = createItem({ kind: "workflow" });
+
+		expect(shouldToggleExtDetailForKey("space", skill)).toBe(true);
+		expect(shouldToggleExtDetailForKey("space", mcp)).toBe(true);
+		expect(shouldToggleExtDetailForKey("return", skill)).toBe(false);
+		expect(shouldToggleExtDetailForKey("space", workflow)).toBe(false);
+	});
+
+	it("builds useful detail rows with status for toggleable items", () => {
+		expect(
+			getExtDetailRows(
+				createItem({
+					kind: "skill",
+					name: "add-model",
+					source: "global",
+					path: "/tmp/add-model/SKILL.md",
+					description: "Add a model safely",
+					enabled: false,
+				}),
+			),
+		).toEqual([
+			{ kind: "header", name: "add-model", source: "global" },
+			{ kind: "field", label: "Path", value: ["/tmp/add-model/SKILL.md"] },
+			{ kind: "field", label: "Description", value: ["Add a model safely"] },
+			{ kind: "status", enabled: false },
+		]);
+	});
+
+	it("omits status and toggle hint for non-toggleable items", () => {
+		const workflow = createItem({
+			kind: "workflow",
+			name: "release",
+			description: "Run release workflow",
+		});
+
+		expect(getExtDetailRows(workflow)).toEqual([
+			{ kind: "header", name: "release", source: "workspace" },
+			{ kind: "field", label: "Path", value: ["/tmp/item"] },
+			{ kind: "field", label: "Description", value: ["Run release workflow"] },
+		]);
+		expect(getExtDetailFooterText(workflow)).toBe("Tab/Enter/Esc to go back");
+	});
+
+	it("shows toggle hint for toggleable items", () => {
+		expect(getExtDetailFooterText(createItem({ kind: "skill" }))).toBe(
+			"Space toggle status, Tab/Enter/Esc to go back",
+		);
+	});
+
+	it("bounds long descriptions so path and status remain visible", () => {
+		const rows = getExtDetailRows(
+			createItem({
+				kind: "skill",
+				name: "karpathy-rules",
+				source: "global",
+				path: "/tmp/karpathy-rules.md",
+				description: Array.from(
+					{ length: 30 },
+					(_, index) => `Long rule line ${index + 1}`,
+				).join("\n"),
+				enabled: true,
+			}),
+		);
+
+		expect(rows[1]).toEqual({
+			kind: "field",
+			label: "Path",
+			value: ["/tmp/karpathy-rules.md"],
+		});
+		expect(rows[2]?.kind).toBe("field");
+		if (rows[2]?.kind === "field") {
+			expect(rows[2].label).toBe("Description");
+			expect(rows[2].value).toHaveLength(13);
+			expect(rows[2].value.at(-1)).toContain("… truncated");
+		}
+		expect(rows[3]).toEqual({ kind: "status", enabled: true });
+	});
+
+	it("wraps long description lines before truncating", () => {
+		const rows = getExtDetailRows(
+			createItem({
+				kind: "rule",
+				description: "a ".repeat(120).trim(),
+			}),
+		);
+
+		expect(rows[2]?.kind).toBe("field");
+		if (rows[2]?.kind === "field") {
+			expect(rows[2].value.length).toBeGreaterThan(1);
+			expect(rows[2].value.every((line) => line.length <= 78)).toBe(true);
+		}
+	});
+});
diff --git a/apps/cli/src/tui/components/dialogs/config-dialogs.tsx b/apps/cli/src/tui/components/dialogs/config-dialogs.tsx
new file mode 100644
index 0000000..bb5fc5f
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/config-dialogs.tsx
@@ -0,0 +1,190 @@
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useState } from "react";
+import type {
+	InteractiveConfigData,
+	InteractiveConfigItem,
+	LoadInteractiveConfigDataOptions,
+} from "../../interactive-config";
+import { palette } from "../../palette";
+import {
+	getExtDetailFooterText,
+	getExtDetailRows,
+	shouldCloseExtDetailForKey,
+	shouldToggleExtDetailForKey,
+} from "./config-dialogs-helpers";
+
+export function ExtDetailContent(
+	props: ChoiceContext<void> & {
+		item: InteractiveConfigItem;
+		onToggleConfigItem?: (
+			item: InteractiveConfigItem,
+			options?: LoadInteractiveConfigDataOptions,
+		) => Promise<InteractiveConfigData | undefined>;
+	},
+) {
+	const [item, setItem] = useState(props.item);
+	const [toggleError, setToggleError] = useState<string | undefined>();
+
+	const toggleStatus = async () => {
+		if (
+			!props.onToggleConfigItem ||
+			!shouldToggleExtDetailForKey("space", item)
+		) {
+			return;
+		}
+		const previousItem = item;
+		setToggleError(undefined);
+		if (typeof item.enabled === "boolean") {
+			setItem({ ...item, enabled: !item.enabled });
+		}
+		try {
+			const nextData = await props.onToggleConfigItem(item, {
+				includePluginTools: false,
+			});
+			if (nextData) {
+				const nextItem = [
+					...nextData.workflows,
+					...nextData.rules,
+					...nextData.skills,
+					...nextData.hooks,
+					...nextData.agents,
+					...nextData.plugins,
+					...nextData.mcp,
+					...nextData.tools,
+				].find(
+					(candidate) =>
+						candidate.id === item.id && candidate.path === item.path,
+				);
+				if (nextItem) {
+					setItem(nextItem);
+				}
+			}
+		} catch (error) {
+			setItem(previousItem);
+			const message = error instanceof Error ? error.message : String(error);
+			setToggleError(`Failed to update ${item.name}: ${message}`);
+		}
+	};
+
+	useDialogKeyboard((key) => {
+		if (shouldToggleExtDetailForKey(key.name, item)) {
+			void toggleStatus();
+			return;
+		}
+		if (shouldCloseExtDetailForKey(key.name)) {
+			props.dismiss();
+		}
+	}, props.dialogId);
+	const rows = getExtDetailRows(item);
+	const footerText = getExtDetailFooterText(item);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			{rows.map((row) => {
+				switch (row.kind) {
+					case "header":
+						return (
+							<box
+								key="header"
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg={palette.act}>
+									<strong>{row.name}</strong>
+								</text>
+								<text
+									fg={row.source === "workspace" ? palette.success : "gray"}
+								>
+									{row.source}
+								</text>
+							</box>
+						);
+					case "field":
+						return (
+							<box key={row.label} flexDirection="column" marginTop={1}>
+								<text fg="gray">{row.label}</text>
+								{row.value.map((line) => (
+									<text key={`${row.label}-${line}`}>{line || " "}</text>
+								))}
+							</box>
+						);
+					case "status":
+						return (
+							<box
+								key="status"
+								flexDirection="row"
+								marginTop={1}
+								justifyContent="space-between"
+							>
+								<text fg="gray">Status</text>
+								<text fg={row.enabled ? palette.success : "red"}>
+									{row.enabled ? "Enabled" : "Disabled"}
+								</text>
+							</box>
+						);
+				}
+				return null;
+			})}
+			<text fg="gray" marginTop={1}>
+				<em>{footerText}</em>
+			</text>
+			{toggleError && (
+				<text fg="red" marginTop={1}>
+					{toggleError}
+				</text>
+			)}
+		</box>
+	);
+}
+
+export function DeleteConfigItemConfirmContent(
+	props: ChoiceContext<boolean> & {
+		item: InteractiveConfigItem;
+	},
+) {
+	useDialogKeyboard((key) => {
+		if (key.name === "return" || key.name === "y") {
+			props.resolve(true);
+		} else if (key.name === "escape" || key.name === "n") {
+			props.dismiss();
+		}
+	}, props.dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text>Delete plugin {props.item.name}?</text>
+			<text fg="gray" marginTop={1}>
+				This removes the installed plugin files from {props.item.path}.
+			</text>
+			<text fg="gray" marginTop={1}>
+				<em>Y/Enter to confirm, N/Esc to cancel</em>
+			</text>
+		</box>
+	);
+}
+
+export function ConfigErrorContent(
+	props: ChoiceContext<void> & {
+		title: string;
+		message: string;
+	},
+) {
+	useDialogKeyboard((key) => {
+		if (key.name === "return" || key.name === "escape") {
+			props.dismiss();
+		}
+	}, props.dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text fg="red">{props.title}</text>
+			<text fg="gray" marginTop={1}>
+				{props.message}
+			</text>
+			<text fg="gray" marginTop={1}>
+				<em>Enter/Esc to close</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/fork-confirm.tsx b/apps/cli/src/tui/components/dialogs/fork-confirm.tsx
new file mode 100644
index 0000000..14e4c01
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/fork-confirm.tsx
@@ -0,0 +1,25 @@
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+
+export function ForkConfirmContent(ctx: ChoiceContext<boolean>) {
+	useDialogKeyboard((key) => {
+		if (key.name === "return" || key.name === "y") {
+			ctx.resolve(true);
+		} else if (key.name === "escape" || key.name === "n") {
+			ctx.dismiss();
+		}
+	}, ctx.dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text>Create a fork of the current conversation?</text>
+			<text fg="gray" marginTop={1}>
+				The fork becomes the active session. Use /history to switch back or open
+				another session.
+			</text>
+			<text fg="gray" marginTop={1}>
+				<em>Y/Enter to confirm, N/Esc to cancel</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/help-dialog.tsx b/apps/cli/src/tui/components/dialogs/help-dialog.tsx
new file mode 100644
index 0000000..20f6949
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/help-dialog.tsx
@@ -0,0 +1,296 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { palette } from "../../palette";
+
+type HelpRow =
+	| { kind: "heading"; id: string; text: string }
+	| { kind: "entry"; id: string; key: string; desc: string }
+	| { kind: "spacer"; id: string };
+
+const HELP_ROWS: HelpRow[] = [
+	{ kind: "heading", id: "h-keys", text: "Keyboard Shortcuts" },
+	{
+		kind: "entry",
+		id: "k-enter",
+		key: "Enter",
+		desc: "Submit prompt (or select autocomplete)",
+	},
+	{
+		kind: "entry",
+		id: "k-shift-enter",
+		key: "Shift+Enter",
+		desc: "Newline in input",
+	},
+	{
+		kind: "entry",
+		id: "k-tab",
+		key: "Tab",
+		desc: "Toggle Plan / Act mode",
+	},
+	{
+		kind: "entry",
+		id: "k-shift-tab",
+		key: "Shift+Tab",
+		desc: "Toggle auto-approve all",
+	},
+	{
+		kind: "entry",
+		id: "k-ctrl-c",
+		key: "Ctrl+C",
+		desc: "Clear input / Exit",
+	},
+	{
+		kind: "entry",
+		id: "k-ctrl-d",
+		key: "Ctrl+D",
+		desc: "Exit (when idle and input empty)",
+	},
+	{
+		kind: "entry",
+		id: "k-ctrl-l",
+		key: "Ctrl+L",
+		desc: "Clear conversation",
+	},
+	{
+		kind: "entry",
+		id: "k-ctrl-s",
+		key: "Ctrl+S",
+		desc: "Steer (send while agent is running)",
+	},
+	{
+		kind: "entry",
+		id: "k-ctrl-p",
+		key: "Ctrl+P",
+		desc: "Open command palette",
+	},
+	{
+		kind: "entry",
+		id: "k-opt-help",
+		key: "Opt+K",
+		desc: "Show this help",
+	},
+	{
+		kind: "entry",
+		id: "k-escape",
+		key: "Escape",
+		desc: "Close menu / Abort running agent",
+	},
+	{
+		kind: "entry",
+		id: "k-esc-esc",
+		key: "Esc Esc",
+		desc: "Restore to a previous checkpoint",
+	},
+	{
+		kind: "entry",
+		id: "k-updown",
+		key: "Up/Down",
+		desc: "Navigate autocomplete or input history",
+	},
+	{
+		kind: "entry",
+		id: "k-page-scroll",
+		key: "PgUp/PgDn",
+		desc: "Scroll transcript by page",
+	},
+	{
+		kind: "entry",
+		id: "k-page-scroll-alt",
+		key: "Ctrl+Alt+B/F",
+		desc: "Scroll transcript by page",
+	},
+	{
+		kind: "entry",
+		id: "k-half-page-scroll",
+		key: "Ctrl+Alt+U/D",
+		desc: "Scroll transcript by half page",
+	},
+	{
+		kind: "entry",
+		id: "k-transcript-bounds",
+		key: "Ctrl+G/Ctrl+Alt+G",
+		desc: "Jump to first or last message",
+	},
+
+	{ kind: "spacer", id: "s1" },
+	{ kind: "heading", id: "h-slash", text: "Slash Commands" },
+	{
+		kind: "entry",
+		id: "c-model",
+		key: "/model",
+		desc: "Switch model or provider",
+	},
+	{
+		kind: "entry",
+		id: "c-settings",
+		key: "/settings",
+		desc: "Open interactive config browser",
+	},
+	{
+		kind: "entry",
+		id: "c-mcp",
+		key: "/mcp",
+		desc: "Manage MCP servers",
+	},
+	{
+		kind: "entry",
+		id: "c-plugins",
+		key: "/plugins",
+		desc: "Open plugin settings",
+	},
+	{
+		kind: "entry",
+		id: "c-account",
+		key: "/account",
+		desc: "View Cline account and switch account",
+	},
+	{
+		kind: "entry",
+		id: "c-compact",
+		key: "/compact",
+		desc: "Compact context window",
+	},
+	{
+		kind: "entry",
+		id: "c-clear",
+		key: "/clear",
+		desc: "Start a new session",
+	},
+	{
+		kind: "entry",
+		id: "c-team",
+		key: "/team",
+		desc: "Start the task with agent team",
+	},
+	{
+		kind: "entry",
+		id: "c-history",
+		key: "/history",
+		desc: "View and resume past sessions",
+	},
+	{
+		kind: "entry",
+		id: "c-fork",
+		key: "/fork",
+		desc: "Fork this session and continue there",
+	},
+	{
+		kind: "entry",
+		id: "c-undo",
+		key: "/undo",
+		desc: "Restore to a previous checkpoint",
+	},
+	{ kind: "entry", id: "c-quit", key: "/quit", desc: "Exit Cline" },
+	{ kind: "entry", id: "c-help", key: "/help", desc: "Show this help" },
+
+	{ kind: "spacer", id: "s2" },
+	{ kind: "heading", id: "h-mentions", text: "Mentions" },
+	{
+		kind: "entry",
+		id: "m-file",
+		key: "@filename",
+		desc: "Attach a workspace file to your prompt",
+	},
+
+	{ kind: "spacer", id: "s3" },
+	{ kind: "heading", id: "h-modes", text: "Modes" },
+	{
+		kind: "entry",
+		id: "mode-plan",
+		key: "Plan",
+		desc: "Agent explains what it would do without making changes",
+	},
+	{
+		kind: "entry",
+		id: "mode-act",
+		key: "Act",
+		desc: "Agent executes tools and makes changes (default)",
+	},
+
+	{ kind: "spacer", id: "s4" },
+	{ kind: "heading", id: "h-approve", text: "Auto-Approve" },
+	{
+		kind: "entry",
+		id: "approve-off",
+		key: "Off",
+		desc: "Safe tools auto-approved, others prompt for confirmation",
+	},
+	{
+		kind: "entry",
+		id: "approve-on",
+		key: "On",
+		desc: "All tool calls auto-approved without confirmation",
+	},
+
+	{ kind: "spacer", id: "s5" },
+	{ kind: "heading", id: "h-wizards", text: "CLI Wizards" },
+	{
+		kind: "entry",
+		id: "w-connect",
+		key: "cline connect",
+		desc: "Set up messaging platform integrations",
+	},
+	{
+		kind: "entry",
+		id: "w-schedule",
+		key: "cline schedule",
+		desc: "Create and manage scheduled cron tasks",
+	},
+	{
+		kind: "entry",
+		id: "w-mcp",
+		key: "cline mcp",
+		desc: "Add, remove, and manage MCP servers",
+	},
+];
+
+const KEY_WIDTH = 20;
+
+export function HelpDialogContent(props: ChoiceContext<void>) {
+	const { dismiss, dialogId } = props;
+
+	useDialogKeyboard((key) => {
+		if (
+			key.name === "escape" ||
+			key.name === "return" ||
+			key.name === "enter" ||
+			key.name === "q"
+		) {
+			dismiss();
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<scrollbox flexGrow={1}>
+				<box flexDirection="column">
+					{HELP_ROWS.map((row) => {
+						if (row.kind === "spacer") {
+							return <text key={row.id}> </text>;
+						}
+						if (row.kind === "heading") {
+							return (
+								<text key={row.id} fg="white">
+									{row.text}
+								</text>
+							);
+						}
+						return (
+							<box key={row.id} flexDirection="row" paddingX={1}>
+								<text fg={palette.act} width={KEY_WIDTH} flexShrink={0}>
+									{row.key}
+								</text>
+								<text fg="gray">{row.desc}</text>
+							</box>
+						);
+					})}
+				</box>
+			</scrollbox>
+
+			<text fg="gray" marginTop={1}>
+				<em>Esc/Enter to close</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/loading-dialog-lifecycle.ts b/apps/cli/src/tui/components/dialogs/loading-dialog-lifecycle.ts
new file mode 100644
index 0000000..c5c2651
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/loading-dialog-lifecycle.ts
@@ -0,0 +1,18 @@
+import type { DialogActions, DialogId } from "@opentui-ui/dialog/react";
+
+export type LoadingDialogActions = Pick<DialogActions, "show" | "close">;
+
+export async function withShownDialog<T>(
+	dialog: Pick<DialogActions, "close">,
+	show: () => DialogId,
+	run: () => Promise<T>,
+): Promise<T> {
+	const loadingDialogId = show();
+	// Give OpenTUI a microtask to mount the loading dialog before work starts.
+	await Promise.resolve();
+	try {
+		return await run();
+	} finally {
+		dialog.close(loadingDialogId);
+	}
+}
diff --git a/apps/cli/src/tui/components/dialogs/loading-dialog.test.ts b/apps/cli/src/tui/components/dialogs/loading-dialog.test.ts
new file mode 100644
index 0000000..c76bbeb
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/loading-dialog.test.ts
@@ -0,0 +1,66 @@
+import type { DialogActions, DialogId } from "@opentui-ui/dialog/react";
+import { describe, expect, it } from "vitest";
+import { withShownDialog } from "./loading-dialog-lifecycle";
+
+type LoadingDialogCall =
+	| {
+			name: "show";
+	  }
+	| {
+			name: "close";
+			id: DialogId | undefined;
+	  };
+
+function createDialog(calls: LoadingDialogCall[]) {
+	return {
+		close: (id?: DialogId): DialogId | undefined => {
+			calls.push({ name: "close", id });
+			return id;
+		},
+	} satisfies Pick<DialogActions, "close">;
+}
+
+function showLoading(calls: LoadingDialogCall[]): DialogId {
+	calls.push({ name: "show" });
+	return "loading-dialog";
+}
+
+describe("withShownDialog", () => {
+	it("shows a loading dialog while work runs", async () => {
+		const calls: LoadingDialogCall[] = [];
+		const events: string[] = [];
+		const dialog = createDialog(calls);
+
+		const result = await withShownDialog(
+			dialog,
+			() => showLoading(calls),
+			async () => {
+				events.push("run");
+				return 42;
+			},
+		);
+
+		expect(result).toBe(42);
+		expect(events).toEqual(["run"]);
+		expect(calls.map((call) => call.name)).toEqual(["show", "close"]);
+		expect(calls[1]).toEqual({ name: "close", id: "loading-dialog" });
+	});
+
+	it("closes the loading dialog when work fails", async () => {
+		const calls: LoadingDialogCall[] = [];
+		const dialog = createDialog(calls);
+
+		await expect(
+			withShownDialog(
+				dialog,
+				() => showLoading(calls),
+				async () => {
+					throw new Error("failed");
+				},
+			),
+		).rejects.toThrow("failed");
+
+		expect(calls.map((call) => call.name)).toEqual(["show", "close"]);
+		expect(calls[1]).toEqual({ name: "close", id: "loading-dialog" });
+	});
+});
diff --git a/apps/cli/src/tui/components/dialogs/loading-dialog.tsx b/apps/cli/src/tui/components/dialogs/loading-dialog.tsx
new file mode 100644
index 0000000..e0f4fb3
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/loading-dialog.tsx
@@ -0,0 +1,56 @@
+// @jsxImportSource @opentui/react
+import type {
+	DialogId,
+	DialogSize,
+	DialogStyle,
+} from "@opentui-ui/dialog/react";
+import "opentui-spinner/react";
+import {
+	type LoadingDialogActions,
+	withShownDialog,
+} from "./loading-dialog-lifecycle";
+
+export interface LoadingDialogContentProps {
+	message: string;
+}
+
+export function LoadingDialogContent(props: LoadingDialogContentProps) {
+	return (
+		<box flexDirection="row" gap={1} paddingX={1}>
+			<spinner name="dots" color="gray" />
+			<text fg="gray">{props.message}</text>
+		</box>
+	);
+}
+
+export interface LoadingDialogOptions {
+	size?: DialogSize;
+	style?: DialogStyle;
+}
+
+export function showLoadingDialog(
+	dialog: LoadingDialogActions,
+	message: string,
+	options?: LoadingDialogOptions,
+): DialogId {
+	return dialog.show({
+		size: options?.size ?? "small",
+		style: options?.style,
+		closeOnEscape: false,
+		closeOnClickOutside: false,
+		content: () => <LoadingDialogContent message={message} />,
+	});
+}
+
+export async function withLoadingDialog<T>(
+	dialog: LoadingDialogActions,
+	message: string,
+	run: () => Promise<T>,
+	options?: LoadingDialogOptions,
+): Promise<T> {
+	return await withShownDialog(
+		dialog,
+		() => showLoadingDialog(dialog, message, options),
+		run,
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/mcp-manager-dialog.test.ts b/apps/cli/src/tui/components/dialogs/mcp-manager-dialog.test.ts
new file mode 100644
index 0000000..cbb0557
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/mcp-manager-dialog.test.ts
@@ -0,0 +1,188 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	getMcpManagerEntryStatus,
+	getMcpManagerFooterText,
+	toggleMcpServer,
+} from "./mcp-manager-dialog";
+
+interface SetMcpServerDisabledOptions {
+	filePath?: string;
+	name: string;
+	disabled: boolean;
+}
+
+interface TestMcpSettings {
+	mcpServers?: Record<string, { disabled?: boolean }>;
+}
+
+vi.mock("@cline/core", () => ({
+	resolveDefaultMcpSettingsPath: () =>
+		process.env.CLINE_MCP_SETTINGS_PATH ?? "cline_mcp_settings.json",
+	setMcpServerDisabled: (options: SetMcpServerDisabledOptions) => {
+		const filePath =
+			options.filePath ??
+			process.env.CLINE_MCP_SETTINGS_PATH ??
+			"cline_mcp_settings.json";
+		const settings = JSON.parse(readFileSync(filePath, "utf8")) as {
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+		const server = settings.mcpServers?.[options.name];
+		if (!server) {
+			throw new Error(`Unknown MCP server: ${options.name}`);
+		}
+		if (options.disabled) {
+			server.disabled = true;
+		} else {
+			delete server.disabled;
+		}
+		writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}\n`);
+	},
+}));
+
+vi.mock("@opentui-ui/dialog/react", () => ({
+	useDialogKeyboard: () => undefined,
+}));
+
+async function readSettings(filePath: string): Promise<TestMcpSettings> {
+	return JSON.parse(await readFile(filePath, "utf8")) as TestMcpSettings;
+}
+
+describe("mcp manager dialog helpers", () => {
+	const tempRoots: string[] = [];
+	const envSnapshot = {
+		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
+	};
+
+	afterEach(async () => {
+		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
+		}
+		await Promise.all(
+			tempRoots.map((directory) =>
+				rm(directory, { recursive: true, force: true }),
+			),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("uses the loaded server path when toggling", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-mcp-manager-"));
+		tempRoots.push(tempRoot);
+		const loadedPath = join(tempRoot, "loaded.json");
+		const currentDefaultPath = join(tempRoot, "current-default.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = currentDefaultPath;
+		const settings = {
+			mcpServers: {
+				docs: {
+					transport: {
+						type: "stdio",
+						command: "node",
+					},
+				},
+			},
+		};
+		await writeFile(loadedPath, `${JSON.stringify(settings, null, 2)}\n`);
+		await writeFile(
+			currentDefaultPath,
+			`${JSON.stringify(settings, null, 2)}\n`,
+		);
+
+		const result = toggleMcpServer({
+			name: "docs",
+			path: loadedPath,
+			enabled: true,
+		});
+
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.server.enabled).toBe(false);
+		}
+		expect((await readSettings(loadedPath)).mcpServers?.docs?.disabled).toBe(
+			true,
+		);
+		expect(
+			(await readSettings(currentDefaultPath)).mcpServers?.docs?.disabled,
+		).toBeUndefined();
+	});
+
+	it("does not toggle plugin-owned servers", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-mcp-manager-"));
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "stdio",
+								command: "node",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		const result = toggleMcpServer({
+			name: "docs",
+			path: settingsPath,
+			enabled: true,
+			pluginName: "repo-docs",
+		});
+
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.message).toContain('managed by plugin "repo-docs"');
+		}
+		expect((await readSettings(settingsPath)).mcpServers?.docs?.disabled).toBe(
+			undefined,
+		);
+	});
+
+	it("returns a visible error message when toggling fails", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-mcp-manager-"));
+		tempRoots.push(tempRoot);
+		const result = toggleMcpServer({
+			name: "docs",
+			path: join(tempRoot, "missing-mcp-settings.json"),
+			enabled: true,
+		});
+
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.message).toContain('Unable to toggle MCP server "docs"');
+		}
+	});
+
+	it("keeps the footer focused on toggling", () => {
+		expect(getMcpManagerFooterText(true)).toBe(
+			"Space toggle selected, Esc to go back",
+		);
+		expect(getMcpManagerFooterText(true)).not.toContain("delete");
+		expect(getMcpManagerFooterText(false)).toBe("Esc to go back");
+	});
+
+	it("shows OAuth errors before general MCP status", () => {
+		expect(
+			getMcpManagerEntryStatus({
+				description: "streamableHttp, oauth authorized",
+			}),
+		).toBe("streamableHttp, oauth authorized");
+		expect(
+			getMcpManagerEntryStatus({
+				description: "streamableHttp, oauth authorized",
+				lastError: "OAuth authorization failed",
+			}),
+		).toBe("oauth error");
+	});
+});
diff --git a/apps/cli/src/tui/components/dialogs/mcp-manager-dialog.tsx b/apps/cli/src/tui/components/dialogs/mcp-manager-dialog.tsx
new file mode 100644
index 0000000..32eb9cb
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/mcp-manager-dialog.tsx
@@ -0,0 +1,207 @@
+import {
+	resolveDefaultMcpSettingsPath,
+	setMcpServerDisabled,
+} from "@cline/core";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useState } from "react";
+import { palette } from "../../palette";
+
+export interface McpEntry {
+	name: string;
+	path: string;
+	enabled?: boolean;
+	description?: string;
+	lastError?: string;
+	pluginName?: string;
+}
+
+export type McpServerToggleResult =
+	| { ok: true; server: McpEntry }
+	| { ok: false; message: string };
+
+function stringifyError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export function getMcpManagerFooterText(hasServers: boolean): string {
+	return hasServers
+		? "Space toggle selected, Esc to go back"
+		: "Esc to go back";
+}
+
+export function getMcpManagerEntryStatus(
+	server: Pick<McpEntry, "description" | "lastError">,
+): string {
+	return server.lastError ? "oauth error" : (server.description ?? "");
+}
+
+export function toggleMcpServer(server: McpEntry): McpServerToggleResult {
+	if (server.pluginName) {
+		return {
+			ok: false,
+			message: `MCP server "${server.name}" is managed by plugin "${server.pluginName}". Disable the plugin to disable this server.`,
+		};
+	}
+	try {
+		const currentlyEnabled = server.enabled !== false;
+		setMcpServerDisabled({
+			filePath: server.path,
+			name: server.name,
+			disabled: currentlyEnabled,
+		});
+		return {
+			ok: true,
+			server: {
+				...server,
+				enabled: !currentlyEnabled,
+			},
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: `Unable to toggle MCP server "${server.name}": ${stringifyError(error)}`,
+		};
+	}
+}
+
+export function McpManagerContent(
+	props: ChoiceContext<boolean> & {
+		servers: McpEntry[];
+	},
+) {
+	const [selected, setSelected] = useState(0);
+	const [servers, setServers] = useState(props.servers);
+	const [changed, setChanged] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+
+	const settingsPath = servers[0]?.path ?? resolveDefaultMcpSettingsPath();
+	const itemCount = servers.length;
+	const selectedServer = servers[selected];
+	const hasPluginOwnedServers = servers.some((server) => server.pluginName);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			if (changed) {
+				props.resolve(true);
+			} else {
+				props.dismiss();
+			}
+			return;
+		}
+		if (itemCount > 0) {
+			if (key.name === "up") {
+				setError(null);
+				setSelected((s) => (s > 0 ? s - 1 : itemCount - 1));
+				return;
+			}
+			if (key.name === "down") {
+				setError(null);
+				setSelected((s) => (s < itemCount - 1 ? s + 1 : 0));
+				return;
+			}
+			if (key.name === "space") {
+				const target = servers[selected];
+				const result = target ? toggleMcpServer(target) : undefined;
+				if (result?.ok) {
+					setServers((current) =>
+						current.map((server, index) =>
+							index === selected ? result.server : server,
+						),
+					);
+					setChanged(true);
+					setError(null);
+				} else if (result) {
+					setError(result.message);
+				}
+				return;
+			}
+		}
+	}, props.dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text fg={palette.act}>MCP Servers</text>
+
+			<text fg="gray" marginTop={1}>
+				Settings file:
+			</text>
+			<text selectable>{settingsPath}</text>
+
+			<text fg="gray" marginTop={1}>
+				Run cline mcp to add, edit, or remove servers.
+			</text>
+
+			{servers.length > 0 && (
+				<box flexDirection="column" marginTop={1}>
+					{servers.map((srv, i) => {
+						const isSel = i === selected;
+						const enabled =
+							typeof srv.enabled === "boolean" ? srv.enabled : true;
+						const enabledIcon =
+							typeof srv.enabled === "boolean" ? (enabled ? "● " : "○ ") : "";
+						const status = getMcpManagerEntryStatus(srv);
+						let rowColor = isSel ? palette.act : "gray";
+						if (enabled && typeof srv.enabled === "boolean") {
+							rowColor = palette.success;
+						}
+						if (srv.lastError) {
+							rowColor = palette.error;
+						}
+						return (
+							<box
+								key={srv.name}
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg={rowColor}>
+									{isSel ? "\u25b8 " : "  "}
+									{enabledIcon}
+									{srv.name}
+									{srv.pluginName ? " *" : ""}
+								</text>
+								{status && (
+									<text fg={srv.lastError ? palette.error : "gray"}>
+										{status}
+									</text>
+								)}
+							</box>
+						);
+					})}
+				</box>
+			)}
+
+			{servers.length === 0 && (
+				<text fg="gray" marginTop={1}>
+					No servers configured.
+				</text>
+			)}
+
+			{error && (
+				<text fg={palette.error} marginTop={1}>
+					{error}
+				</text>
+			)}
+
+			{selectedServer?.lastError && (
+				<box flexDirection="column" marginTop={1}>
+					<text fg={palette.error}>OAuth error</text>
+					<text fg={palette.error}>{selectedServer.lastError}</text>
+					<text fg="gray">
+						Run cline mcp and choose Authorize OAuth to retry.
+					</text>
+				</box>
+			)}
+
+			{hasPluginOwnedServers && (
+				<text fg="gray" marginTop={1}>
+					* managed by plugin; disable the plugin to disable the server.
+				</text>
+			)}
+
+			<text fg="gray" marginTop={1}>
+				<em>{getMcpManagerFooterText(servers.length > 0)}</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/provider-picker-helpers.ts b/apps/cli/src/tui/components/dialogs/provider-picker-helpers.ts
new file mode 100644
index 0000000..f66443c
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/provider-picker-helpers.ts
@@ -0,0 +1,16 @@
+import { CLI_PROMO_CODE } from "../../../utils/cline-pass-errors";
+
+const CLINE_PASS_SUBSCRIPTION_PATH = "/dashboard/subscription";
+const DEFAULT_APP_BASE_URL = "https://app.cline.bot";
+
+export function buildClinePassSubscriptionPageUrl(
+	appBaseUrl: string | undefined,
+): string {
+	const url = new URL(
+		CLINE_PASS_SUBSCRIPTION_PATH,
+		appBaseUrl || DEFAULT_APP_BASE_URL,
+	);
+	url.searchParams.set("personal", "true");
+	url.searchParams.set("code", CLI_PROMO_CODE);
+	return url.toString();
+}
diff --git a/apps/cli/src/tui/components/dialogs/provider-picker.test.ts b/apps/cli/src/tui/components/dialogs/provider-picker.test.ts
new file mode 100644
index 0000000..c22b377
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/provider-picker.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { buildClinePassSubscriptionPageUrl } from "./provider-picker-helpers";
+
+describe("buildClinePassSubscriptionPageUrl", () => {
+	it("opens the personal subscription page on production by default", () => {
+		expect(buildClinePassSubscriptionPageUrl(undefined)).toBe(
+			"https://app.cline.bot/dashboard/subscription?personal=true&code=CLI-8OFF",
+		);
+	});
+
+	it("keeps the configured app base URL", () => {
+		expect(
+			buildClinePassSubscriptionPageUrl("https://staging-app.cline.bot"),
+		).toBe(
+			"https://staging-app.cline.bot/dashboard/subscription?personal=true&code=CLI-8OFF",
+		);
+	});
+});
diff --git a/apps/cli/src/tui/components/dialogs/provider-picker.tsx b/apps/cli/src/tui/components/dialogs/provider-picker.tsx
new file mode 100644
index 0000000..6090b58
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/provider-picker.tsx
@@ -0,0 +1,923 @@
+import {
+	completeClineDeviceAuth,
+	getProviderConfigFields,
+	isOAuthProvider,
+	loginLocalProvider,
+	type ProviderConfigFieldKey,
+	type ProviderConfigFieldRequirement,
+	ProviderSettingsManager,
+	saveLocalProviderOAuthCredentials,
+	saveLocalProviderSettings,
+	startClineDeviceAuth,
+} from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import open from "open";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+	CODEX_CLI_INSTALL_URL,
+	type CodexCliStatus,
+	checkCodexCliInstalled,
+	isOpenAICodexCliProvider,
+} from "../../../utils/codex-cli";
+import { listLocalProviders } from "../../../utils/provider-catalog";
+import { palette } from "../../palette";
+import {
+	getDefaultAwsRegion,
+	type ProviderConfigValues,
+	resolveProviderConfigAwsRegion,
+	resolveProviderConfigAzure,
+	resolveProviderConfigGcp,
+	resolveProviderConfigSap,
+	updateProviderConfigValue,
+} from "../../utils/provider-config-values";
+import { getProviderSection } from "../../utils/provider-sections";
+import {
+	getSearchableListRowsWindow,
+	type SearchableItem,
+} from "../searchable-list";
+import { buildClinePassSubscriptionPageUrl } from "./provider-picker-helpers";
+
+interface ProviderItem {
+	id: string;
+	name: string;
+	models: number | null;
+	isConfigured: boolean;
+	isOAuth: boolean;
+	isLocalAuth: boolean;
+	capabilities?: readonly string[];
+}
+
+const MAX_VISIBLE = 10;
+
+type AuthAttempt = {
+	cancelled: boolean;
+};
+
+export function ProviderPickerContent(
+	props: ChoiceContext<string> & { currentProviderId: string },
+) {
+	const { resolve, dismiss, dialogId, currentProviderId } = props;
+	const [providers, setProviders] = useState<ProviderItem[]>([]);
+	const [search, setSearch] = useState("");
+	const [selected, setSelected] = useState(0);
+	const [loading, setLoading] = useState(true);
+
+	useEffect(() => {
+		const manager = new ProviderSettingsManager();
+		listLocalProviders(manager)
+			.then(({ providers: list }) => {
+				const providerItems = list.map((p) => ({
+					id: p.id,
+					name: p.name,
+					models: p.models,
+					// `enabled` is true whenever the provider has any persisted
+					// settings, so keyless local configs (e.g. Ollama saved with
+					// just a model id and base URL) still render as configured.
+					isConfigured: p.enabled === true,
+					isOAuth: isOAuthProvider(p.id),
+					isLocalAuth: isOpenAICodexCliProvider(p.id),
+					capabilities: p.capabilities,
+				}));
+				setProviders(providerItems);
+				const idx = providerItems.findIndex((p) => p.id === currentProviderId);
+				if (idx >= 0) setSelected(idx);
+			})
+			.catch(() => {})
+			.finally(() => setLoading(false));
+	}, [currentProviderId]);
+
+	const filtered = useMemo(() => {
+		if (!search) return providers;
+		const q = search.toLowerCase();
+		return providers.filter(
+			(p) => p.name.toLowerCase().includes(q) || p.id.toLowerCase().includes(q),
+		);
+	}, [providers, search]);
+
+	const safeSelected = Math.min(selected, Math.max(0, filtered.length - 1));
+	const rowItems: SearchableItem[] = useMemo(
+		() =>
+			filtered.map((p) => ({
+				key: p.id,
+				label: p.name,
+				section: getProviderSection(p),
+			})),
+		[filtered],
+	);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return") {
+			const provider = filtered[safeSelected];
+			if (provider) resolve(provider.id);
+			return;
+		}
+		if (key.name === "up") {
+			setSelected((s) =>
+				filtered.length === 0 ? 0 : s <= 0 ? filtered.length - 1 : s - 1,
+			);
+			return;
+		}
+		if (key.name === "down") {
+			setSelected((s) =>
+				filtered.length === 0 ? 0 : s >= filtered.length - 1 ? 0 : s + 1,
+			);
+		}
+	}, dialogId);
+
+	const { visibleRows, aboveCount, belowCount, showAbove, showBelow } =
+		getSearchableListRowsWindow(rowItems, safeSelected, MAX_VISIBLE);
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text>Select Provider</text>
+
+			<box border borderStyle="rounded" borderColor="gray" paddingX={1}>
+				<input
+					onInput={(v: string) => {
+						setSearch(v);
+						setSelected(0);
+					}}
+					placeholder="Search providers..."
+					flexGrow={1}
+					focused
+				/>
+			</box>
+
+			{loading ? (
+				<text fg="gray">Loading providers...</text>
+			) : filtered.length === 0 ? (
+				<text fg="gray">No providers match</text>
+			) : (
+				<box flexDirection="column">
+					{showAbove && (
+						<box paddingX={1} justifyContent="center">
+							<text fg="gray">
+								{"\u25b2"} {aboveCount} more
+							</text>
+						</box>
+					)}
+					{visibleRows.map((row) => {
+						if (row.kind === "header") {
+							return (
+								<box key={row.key} paddingX={1} height={1}>
+									<text fg="gray">{row.label}</text>
+								</box>
+							);
+						}
+						const p = filtered[row.itemIndex];
+						if (!p) return null;
+						const isSel = row.itemIndex === safeSelected;
+						const isCurrent = p.id === currentProviderId;
+						// Configured = any persisted settings exist for this provider,
+						// which covers keyless local configs (Ollama / LM Studio with
+						// just a model id) as well as api-key and OAuth providers.
+						const authed = p.isConfigured;
+						return (
+							<box
+								key={p.id}
+								paddingX={1}
+								flexDirection="row"
+								gap={1}
+								backgroundColor={isSel ? palette.selection : undefined}
+								overflow="hidden"
+								height={1}
+							>
+								<text
+									fg={isSel ? palette.textOnSelection : "gray"}
+									flexShrink={0}
+								>
+									{isSel ? "\u276f" : " "}
+								</text>
+								<text fg={isSel ? palette.textOnSelection : undefined}>
+									{p.name}
+								</text>
+								{p.isOAuth && (
+									<text
+										fg={isSel ? palette.textOnSelection : "gray"}
+										flexShrink={0}
+									>
+										(OAuth)
+									</text>
+								)}
+								{p.isLocalAuth && (
+									<text
+										fg={isSel ? palette.textOnSelection : "gray"}
+										flexShrink={0}
+									>
+										(local CLI)
+									</text>
+								)}
+								{authed && (
+									<text
+										fg={isSel ? palette.textOnSelection : palette.success}
+										flexShrink={0}
+									>
+										{"\u25cf"}
+									</text>
+								)}
+								{isCurrent && (
+									<text
+										fg={isSel ? palette.textOnSelection : palette.success}
+										flexShrink={0}
+									>
+										(current)
+									</text>
+								)}
+							</box>
+						);
+					})}
+					{showBelow && (
+						<box paddingX={1} justifyContent="center">
+							<text fg="gray">
+								{"\u25bc"} {belowCount} more
+							</text>
+						</box>
+					)}
+				</box>
+			)}
+
+			<text fg="gray">
+				Type to search, ↑/↓ navigate, Enter to select, Esc to go back
+			</text>
+		</box>
+	);
+}
+
+export type ExistingProviderAction =
+	| "use_existing"
+	| "reconfigure"
+	| "open_subscription_page"
+	| "open_usage_billing";
+
+export interface ExistingProviderOption {
+	value: ExistingProviderAction;
+	label: string;
+	onSelect?: () => Promise<void> | void;
+}
+
+export function UseExistingOrReconfigureContent(
+	props: ChoiceContext<ExistingProviderOption> & {
+		providerName: string;
+		extraOptions?: ExistingProviderOption[];
+	},
+) {
+	const { resolve, dismiss, dialogId, providerName, extraOptions } = props;
+	const options: ExistingProviderOption[] = useMemo(
+		() => [
+			{ value: "use_existing", label: "Use existing configuration" },
+			{ value: "reconfigure", label: "Configure again" },
+			...(extraOptions ?? []),
+		],
+		[extraOptions],
+	);
+	const [selected, setSelected] = useState(0);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			const opt = options[selected];
+			if (opt) resolve(opt);
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setSelected((s) => (s <= 0 ? options.length - 1 : s - 1));
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setSelected((s) => (s >= options.length - 1 ? 0 : s + 1));
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text>
+				<strong>{providerName}</strong> is already configured
+			</text>
+
+			<box flexDirection="column">
+				{options.map((opt, i) => (
+					<box
+						key={opt.value}
+						paddingX={1}
+						flexDirection="row"
+						gap={1}
+						backgroundColor={i === selected ? palette.selection : undefined}
+					>
+						<text
+							fg={i === selected ? palette.textOnSelection : "gray"}
+							flexShrink={0}
+						>
+							{i === selected ? "❯" : " "}
+						</text>
+						<text fg={i === selected ? palette.textOnSelection : undefined}>
+							{opt.label}
+						</text>
+					</box>
+				))}
+			</box>
+
+			<text fg="gray">↑/↓ navigate, Enter to select, Esc to go back</text>
+		</box>
+	);
+}
+
+function ClinePassBrowserPageContent(
+	props: ChoiceContext<boolean> & {
+		providerName: string;
+		pageLabel: string;
+		url: string;
+		openedStatus: string;
+	},
+) {
+	const {
+		resolve,
+		dismiss,
+		dialogId,
+		providerName,
+		pageLabel,
+		url,
+		openedStatus,
+	} = props;
+	const [status, setStatus] = useState("Opening browser...");
+
+	useEffect(() => {
+		void open(url, { wait: false })
+			.then(() => {
+				setStatus(openedStatus);
+			})
+			.catch(() => {
+				setStatus("Could not open browser automatically. Open the URL below.");
+			});
+	}, [url, openedStatus]);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			resolve(true);
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg={palette.act}>
+				<strong>{providerName}</strong>
+			</text>
+
+			<text>{status}</text>
+
+			<text fg="gray">{pageLabel}:</text>
+			<text fg={palette.act} selectable>
+				<a href={url}>{url}</a>
+			</text>
+
+			<text fg="gray">
+				<em>Enter or Esc to go back</em>
+			</text>
+		</box>
+	);
+}
+
+export function ClinePassSubscriptionContent(
+	props: ChoiceContext<boolean> & {
+		providerName: string;
+	},
+) {
+	const subscriptionUrl = useMemo(
+		() =>
+			buildClinePassSubscriptionPageUrl(getClineEnvironmentConfig().appBaseUrl),
+		[],
+	);
+
+	return (
+		<ClinePassBrowserPageContent
+			{...props}
+			pageLabel="Subscription page"
+			url={subscriptionUrl}
+			openedStatus="Opened subscription page in your browser."
+		/>
+	);
+}
+
+const DEFAULT_FIELD_LABELS: Partial<Record<ProviderConfigFieldKey, string>> = {
+	apiKey: "API key",
+	baseUrl: "Base URL",
+	azureApiVersion: "Azure API Version",
+	awsRegion: "AWS Region",
+	awsProfile: "AWS Profile Name",
+	gcpProjectId: "Google Cloud Project ID",
+	gcpRegion: "Google Cloud Region",
+	sapClientId: "Client ID",
+	sapClientSecret: "Client Secret",
+	sapTokenUrl: "Token URL",
+	sapResourceGroup: "Resource Group",
+	sapDeploymentId: "Deployment ID",
+};
+
+const DEFAULT_FIELD_PLACEHOLDERS: Partial<
+	Record<ProviderConfigFieldKey, string>
+> = {
+	apiKey: "sk-...",
+	baseUrl: "",
+	azureApiVersion: "2025-01-01-preview",
+	awsRegion: "us-east-1",
+	awsProfile: "default",
+	gcpProjectId: "my-gcp-project",
+	gcpRegion: "us-central1",
+	sapClientId: "sb-...|xsuaa_std!b...",
+	sapClientSecret: "SAP AI Core client secret",
+	sapTokenUrl: "https://<subdomain>.authentication.sap.hana.ondemand.com",
+	sapResourceGroup: "default",
+	sapDeploymentId: "",
+};
+
+/** Render order for cycling focus with Tab. */
+const FIELD_ORDER: ProviderConfigFieldKey[] = [
+	"awsRegion",
+	"gcpProjectId",
+	"gcpRegion",
+	"baseUrl",
+	"azureApiVersion",
+	"apiKey",
+	"awsProfile",
+	"sapClientId",
+	"sapClientSecret",
+	"sapTokenUrl",
+	"sapResourceGroup",
+	"sapDeploymentId",
+];
+
+export type ProviderConfigInputFields = Partial<
+	Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>
+>;
+
+/**
+ * Single-purpose configure dialog: collects API key and (when applicable)
+ * base URL. Model selection happens separately in the standard model picker
+ * after this dialog resolves. No fields are required. The dialog accepts
+ * blanks. If credentials are missing or wrong, the API call surfaces the
+ * provider's own error to the user.
+ */
+export function ProviderConfigInputContent(
+	props: ChoiceContext<boolean> & {
+		providerId: string;
+		providerName: string;
+		fields: ProviderConfigInputFields;
+		providerSettingsManager: ProviderSettingsManager;
+	},
+) {
+	const {
+		resolve,
+		dismiss,
+		dialogId,
+		providerId,
+		providerName,
+		providerSettingsManager,
+	} = props;
+
+	const config = useMemo(
+		() => getProviderConfigFields(providerId),
+		[providerId],
+	);
+	const fieldKeys = useMemo<ProviderConfigFieldKey[]>(
+		() => FIELD_ORDER.filter((key) => config.fields[key] !== undefined),
+		[config],
+	);
+
+	const existingSettings =
+		providerSettingsManager.getProviderSettings(providerId);
+	const [values, setValues] = useState<ProviderConfigValues>(() => {
+		const initial: ProviderConfigValues = {};
+		if (config.fields.baseUrl) {
+			initial.baseUrl =
+				existingSettings?.baseUrl?.trim() ??
+				config.fields.baseUrl?.defaultValue ??
+				"";
+		}
+		if (config.fields.azureApiVersion) {
+			initial.azureApiVersion =
+				existingSettings?.azure?.apiVersion?.trim() ?? "";
+		}
+		if (config.fields.awsRegion) {
+			const ep = existingSettings?.aws?.profile?.trim() ?? "";
+			initial.awsRegion =
+				existingSettings?.aws?.region?.trim() || getDefaultAwsRegion(ep);
+		}
+		if (config.fields.gcpProjectId)
+			initial.gcpProjectId = existingSettings?.gcp?.projectId?.trim() ?? "";
+		if (config.fields.gcpRegion)
+			initial.gcpRegion =
+				existingSettings?.gcp?.region?.trim() ??
+				config.fields.gcpRegion.defaultValue ??
+				"us-central1";
+		if (config.fields.apiKey)
+			initial.apiKey = existingSettings?.apiKey?.trim() ?? "";
+		if (config.fields.awsProfile)
+			initial.awsProfile = existingSettings?.aws?.profile?.trim() ?? "";
+		if (config.fields.sapClientId)
+			initial.sapClientId = existingSettings?.sap?.clientId?.trim() ?? "";
+		if (config.fields.sapClientSecret)
+			initial.sapClientSecret =
+				existingSettings?.sap?.clientSecret?.trim() ?? "";
+		if (config.fields.sapTokenUrl)
+			initial.sapTokenUrl = existingSettings?.sap?.tokenUrl?.trim() ?? "";
+		if (config.fields.sapResourceGroup)
+			initial.sapResourceGroup =
+				existingSettings?.sap?.resourceGroup?.trim() ?? "default";
+		if (config.fields.sapDeploymentId)
+			initial.sapDeploymentId =
+				existingSettings?.sap?.deploymentId?.trim() ?? "";
+		return initial;
+	});
+
+	const [focusedField, setFocusedField] = useState<ProviderConfigFieldKey>(
+		() => fieldKeys[0] ?? "apiKey",
+	);
+
+	const submit = () => {
+		const apiKey = values.apiKey?.trim();
+		const awsProfile = values.awsProfile?.trim();
+		const hasAzureFields = config.fields.azureApiVersion;
+		const hasAwsFields = config.fields.awsRegion || config.fields.awsProfile;
+		const hasGcpFields = config.fields.gcpProjectId || config.fields.gcpRegion;
+		const hasSapFields =
+			config.fields.sapClientId ||
+			config.fields.sapClientSecret ||
+			config.fields.sapTokenUrl ||
+			config.fields.sapResourceGroup ||
+			config.fields.sapDeploymentId;
+		saveLocalProviderSettings(providerSettingsManager, {
+			providerId,
+			apiKey: config.fields.apiKey ? apiKey : undefined,
+			baseUrl: config.fields.baseUrl ? values.baseUrl?.trim() : undefined,
+			azure: hasAzureFields ? resolveProviderConfigAzure(values) : undefined,
+			aws: hasAwsFields
+				? {
+						region: resolveProviderConfigAwsRegion(values),
+						authentication: apiKey ? "api-key" : "profile",
+						profile: apiKey ? undefined : awsProfile || undefined,
+					}
+				: undefined,
+			gcp: hasGcpFields ? resolveProviderConfigGcp(values) : undefined,
+			sap: hasSapFields ? resolveProviderConfigSap(values) : undefined,
+		});
+		resolve(true);
+	};
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return") {
+			submit();
+			return;
+		}
+		if (key.name === "tab" && fieldKeys.length > 1) {
+			const idx = fieldKeys.indexOf(focusedField);
+			const nextIdx = key.shift
+				? (idx - 1 + fieldKeys.length) % fieldKeys.length
+				: (idx + 1) % fieldKeys.length;
+			const next = fieldKeys[nextIdx];
+			if (next) setFocusedField(next);
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg={palette.act}>
+				<strong>{providerName}</strong>
+			</text>
+
+			{config.description && <text fg="gray">{config.description}</text>}
+
+			{fieldKeys.map((key) => {
+				const requirement = config.fields[key];
+				if (!requirement) return null;
+				const label = requirement.label ?? DEFAULT_FIELD_LABELS[key] ?? key;
+				const placeholder =
+					requirement.placeholder ??
+					(key === "baseUrl" && requirement.defaultValue
+						? requirement.defaultValue
+						: (DEFAULT_FIELD_PLACEHOLDERS[key] ?? ""));
+				return (
+					<box key={key} flexDirection="column">
+						<text fg="gray">{label}</text>
+						{requirement.note && <text fg="gray">{requirement.note}</text>}
+						<box
+							border
+							borderStyle="rounded"
+							borderColor={focusedField === key ? palette.act : "gray"}
+							paddingX={1}
+						>
+							<input
+								value={values[key] ?? ""}
+								onInput={(v: string) =>
+									setValues((prev) => updateProviderConfigValue(prev, key, v))
+								}
+								placeholder={placeholder}
+								flexGrow={1}
+								focused={focusedField === key}
+							/>
+						</box>
+					</box>
+				);
+			})}
+
+			<text fg="gray">
+				<em>
+					{fieldKeys.length > 1
+						? "Tab to switch fields, Enter to save, Esc to go back"
+						: "Enter to save, Esc to go back"}
+				</em>
+			</text>
+		</box>
+	);
+}
+
+export function CodexCliStatusContent(
+	props: ChoiceContext<boolean> & {
+		providerName: string;
+	},
+) {
+	const { resolve, dismiss, dialogId, providerName } = props;
+	const [status, setStatus] = useState<CodexCliStatus | undefined>();
+	const [checking, setChecking] = useState(false);
+
+	const refresh = useCallback(() => {
+		setStatus(undefined);
+		setChecking(true);
+		checkCodexCliInstalled()
+			.then(setStatus)
+			.catch((error: unknown) => {
+				setStatus({
+					installed: false,
+					reason: error instanceof Error ? error.message : String(error),
+				});
+			})
+			.finally(() => setChecking(false));
+	}, []);
+
+	useEffect(() => {
+		refresh();
+	}, [refresh]);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "r") {
+			refresh();
+			return;
+		}
+		if (key.name === "return" && status?.installed) {
+			resolve(true);
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg={palette.act}>
+				<strong>{providerName}</strong>
+			</text>
+
+			{checking && <text fg="gray">Checking for Codex CLI...</text>}
+
+			{status?.installed && (
+				<box flexDirection="column" gap={1}>
+					<text fg={palette.success}>{"\u25cf"} Codex CLI installed</text>
+					<text fg="gray">{status.version}</text>
+				</box>
+			)}
+
+			{status && !status.installed && (
+				<box flexDirection="column" gap={1}>
+					<text fg="yellow">Codex CLI was not found</text>
+					<text fg="gray">{status.reason}</text>
+					<text fg="gray">Install Codex CLI from:</text>
+					<text fg={palette.act} selectable>
+						{CODEX_CLI_INSTALL_URL}
+					</text>
+				</box>
+			)}
+
+			<text fg="gray">
+				<em>
+					{status?.installed
+						? "Enter to continue, R to recheck, Esc to go back"
+						: "R to recheck, Esc to go back"}
+				</em>
+			</text>
+		</box>
+	);
+}
+
+export function OAuthLoginContent(
+	props: ChoiceContext<boolean> & {
+		providerId: string;
+		providerName: string;
+	},
+) {
+	const { resolve, dismiss, dialogId, providerId, providerName } = props;
+	const [mode, setMode] = useState<"browser" | "device">(
+		providerId === "cline" ? "device" : "browser",
+	);
+	const [status, setStatus] = useState("Opening browser...");
+	const [authUrl, setAuthUrl] = useState("");
+	const [error, setError] = useState("");
+	const [deviceUserCode, setDeviceUserCode] = useState("");
+	const [deviceVerifyUrl, setDeviceVerifyUrl] = useState("");
+	const [deviceError, setDeviceError] = useState("");
+	const activeAuthAttemptRef = useRef<AuthAttempt | undefined>(undefined);
+
+	const startAuthAttempt = useCallback(() => {
+		const attempt: AuthAttempt = { cancelled: false };
+		activeAuthAttemptRef.current = attempt;
+		return attempt;
+	}, []);
+
+	const cancelAuthAttempt = useCallback(() => {
+		const attempt = activeAuthAttemptRef.current;
+		if (attempt) {
+			attempt.cancelled = true;
+		}
+		activeAuthAttemptRef.current = undefined;
+	}, []);
+
+	const isActiveAuthAttempt = useCallback((attempt: AuthAttempt) => {
+		return activeAuthAttemptRef.current === attempt && !attempt.cancelled;
+	}, []);
+
+	const startDeviceAuthCodeFlow = useCallback(() => {
+		cancelAuthAttempt();
+		const attempt = startAuthAttempt();
+		setMode("device");
+		setError("");
+		setDeviceUserCode("");
+		setDeviceVerifyUrl("");
+		setDeviceError("");
+
+		const manager = new ProviderSettingsManager();
+		const existing = manager.getProviderSettings(providerId);
+		const apiBaseUrl =
+			existing?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl;
+
+		startClineDeviceAuth()
+			.then((result) => {
+				if (!isActiveAuthAttempt(attempt)) return;
+				setDeviceUserCode(result.userCode);
+				setDeviceVerifyUrl(
+					result.verificationUriComplete || result.verificationUri,
+				);
+
+				completeClineDeviceAuth({
+					deviceCode: result.deviceCode,
+					expiresInSeconds: result.expiresInSeconds,
+					pollIntervalSeconds: result.pollIntervalSeconds,
+					apiBaseUrl,
+					provider: providerId,
+				})
+					.then((credentials) => {
+						if (!isActiveAuthAttempt(attempt)) return;
+						saveLocalProviderOAuthCredentials(
+							manager,
+							providerId,
+							existing,
+							credentials,
+						);
+						resolve(true);
+					})
+					.catch((err: unknown) => {
+						if (!isActiveAuthAttempt(attempt)) return;
+						setDeviceError(err instanceof Error ? err.message : String(err));
+					});
+			})
+			.catch((err: unknown) => {
+				if (!isActiveAuthAttempt(attempt)) return;
+				setDeviceError(err instanceof Error ? err.message : String(err));
+			});
+	}, [
+		providerId,
+		resolve,
+		startAuthAttempt,
+		isActiveAuthAttempt,
+		cancelAuthAttempt,
+	]);
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: run once on mount
+	useEffect(() => {
+		if (providerId === "cline") {
+			startDeviceAuthCodeFlow();
+			return cancelAuthAttempt;
+		}
+
+		const attempt = startAuthAttempt();
+		const manager = new ProviderSettingsManager();
+		const existing = manager.getProviderSettings(providerId);
+
+		loginLocalProvider(providerId, existing, (url: string) => {
+			setAuthUrl(url);
+			setStatus("Waiting for authentication in browser...");
+			try {
+				void open(url, { wait: false }).catch(() => {
+					setStatus(
+						"Could not open browser automatically. Open the URL below.",
+					);
+				});
+			} catch {
+				setStatus("Could not open browser automatically. Open the URL below.");
+			}
+		})
+			.then((credentials) => {
+				if (!isActiveAuthAttempt(attempt)) return;
+				saveLocalProviderOAuthCredentials(
+					manager,
+					providerId,
+					existing,
+					credentials,
+				);
+				resolve(true);
+			})
+			.catch((err: unknown) => {
+				if (!isActiveAuthAttempt(attempt)) return;
+				const msg = err instanceof Error ? err.message : String(err);
+				setError(msg);
+				setStatus("Authentication failed");
+			});
+		return cancelAuthAttempt;
+	}, []);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			cancelAuthAttempt();
+			dismiss();
+		}
+	}, dialogId);
+
+	if (mode === "device") {
+		return (
+			<box flexDirection="column" paddingX={1} gap={1}>
+				<text fg={palette.act}>
+					<strong>{providerName}</strong>
+				</text>
+
+				{!deviceUserCode && !deviceError && (
+					<text fg="gray">Requesting device code...</text>
+				)}
+
+				{deviceUserCode && !deviceError && (
+					<box flexDirection="column" gap={1}>
+						<text fg="gray">Your code:</text>
+						<text fg="white" selectable>
+							<strong>{deviceUserCode}</strong>
+						</text>
+						<text fg="gray">Visit this URL and enter the code above:</text>
+						<text fg={palette.act} selectable>
+							<a href={deviceVerifyUrl}>{deviceVerifyUrl}</a>
+						</text>
+					</box>
+				)}
+
+				{deviceError && <text fg="red">{deviceError}</text>}
+
+				<text fg="gray">
+					<em>Esc to cancel</em>
+				</text>
+			</box>
+		);
+	}
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg={palette.act}>
+				<strong>{providerName}</strong>
+			</text>
+
+			<text>{status}</text>
+
+			{authUrl && (
+				<text fg="gray" selectable>
+					<a href={authUrl}>{authUrl}</a>
+				</text>
+			)}
+
+			{error && <text fg="red">{error}</text>}
+
+			<text fg="gray">
+				<em>Esc to cancel</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/skills-picker.tsx b/apps/cli/src/tui/components/dialogs/skills-picker.tsx
new file mode 100644
index 0000000..aff1886
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/skills-picker.tsx
@@ -0,0 +1,193 @@
+import { useTerminalDimensions } from "@opentui/react";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useMemo, useRef, useState } from "react";
+import type { SlashCommandRegistryEntry } from "../../commands/slash-command-registry";
+import { palette } from "../../palette";
+
+export const SKILLS_MARKETPLACE_ACTION = "__skills_marketplace__";
+export const SKILLS_MARKETPLACE_URL = "https://skills.sh/";
+
+interface SkillsPickerContentProps extends ChoiceContext<string> {
+	commands: SlashCommandRegistryEntry[];
+}
+
+function matchesFilter(
+	command: SlashCommandRegistryEntry,
+	filter: string,
+): boolean {
+	const query = filter.trim().toLowerCase();
+	if (!query) return true;
+	return (
+		command.name.toLowerCase().includes(query) ||
+		command.description.toLowerCase().includes(query)
+	);
+}
+
+export function SkillsPickerContent(props: SkillsPickerContentProps) {
+	const { resolve, dismiss, dialogId, commands } = props;
+	const { height, width } = useTerminalDimensions();
+	const [filter, setFilter] = useState("");
+	const [selected, setSelected] = useState(0);
+
+	const filtered = useMemo(
+		() => commands.filter((command) => matchesFilter(command, filter)),
+		[commands, filter],
+	);
+	const hasFilter = filter.trim().length > 0;
+	const showMarketplace = !hasFilter;
+	const totalItems = filtered.length + (showMarketplace ? 1 : 0);
+	const marketplaceIndex = filtered.length;
+	const safeSelected = Math.min(selected, Math.max(0, totalItems - 1));
+	const filteredRef = useRef(filtered);
+	filteredRef.current = filtered;
+	const selectedRef = useRef(safeSelected);
+	selectedRef.current = safeSelected;
+	const totalItemsRef = useRef(totalItems);
+	totalItemsRef.current = totalItems;
+	const marketplaceIndexRef = useRef(marketplaceIndex);
+	marketplaceIndexRef.current = marketplaceIndex;
+	const showMarketplaceRef = useRef(showMarketplace);
+	showMarketplaceRef.current = showMarketplace;
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter" || key.name === "tab") {
+			if (
+				showMarketplaceRef.current &&
+				selectedRef.current === marketplaceIndexRef.current
+			) {
+				resolve(SKILLS_MARKETPLACE_ACTION);
+				return;
+			}
+			const command = filteredRef.current[selectedRef.current];
+			if (command) resolve(command.name);
+			return;
+		}
+		if (key.name === "up") {
+			setSelected((index) => {
+				const len = totalItemsRef.current;
+				return len === 0 || index <= 0 ? Math.max(0, len - 1) : index - 1;
+			});
+			return;
+		}
+		if (key.name === "down") {
+			setSelected((index) => {
+				const len = totalItemsRef.current;
+				return len === 0 || index >= len - 1 ? 0 : index + 1;
+			});
+		}
+	}, dialogId);
+
+	const maxVisible = Math.max(3, height - 12);
+	const start = Math.max(
+		0,
+		Math.min(
+			safeSelected - Math.floor(maxVisible / 2),
+			Math.max(0, totalItems - maxVisible),
+		),
+	);
+	const visibleItems = Array.from(
+		{ length: Math.min(maxVisible, Math.max(0, totalItems - start)) },
+		(_, index) => start + index,
+	);
+	const commandWidth = Math.min(36, Math.max(18, Math.floor(width * 0.32)));
+	const enterAction =
+		totalItems === 0
+			? undefined
+			: safeSelected === marketplaceIndex && showMarketplace
+				? "open"
+				: "insert";
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<box flexDirection="row" justifyContent="space-between">
+				<text fg="white">
+					<strong>Skills</strong>
+				</text>
+				<text fg="gray">esc</text>
+			</box>
+
+			<box border borderStyle="rounded" borderColor="gray" paddingX={1}>
+				<input
+					onInput={(value: string) => {
+						setFilter(value);
+						setSelected(0);
+					}}
+					placeholder="Search skills..."
+					flexGrow={1}
+					focused
+				/>
+			</box>
+
+			<box flexDirection="column">
+				<text fg="magenta">Skills</text>
+
+				{totalItems === 0 ? (
+					<box flexDirection="column">
+						<text fg="gray">No matching skills found.</text>
+					</box>
+				) : (
+					visibleItems.map((absoluteIndex) => {
+						const isSelected = absoluteIndex === safeSelected;
+						if (showMarketplace && absoluteIndex === marketplaceIndex) {
+							return (
+								<box
+									key="skills-marketplace"
+									flexDirection="row"
+									backgroundColor={isSelected ? palette.selection : undefined}
+									onMouseDown={() => resolve(SKILLS_MARKETPLACE_ACTION)}
+									height={1}
+								>
+									<text fg={isSelected ? palette.textOnSelection : palette.act}>
+										{isSelected ? "❯ " : "  "}
+										Browse more skills at {SKILLS_MARKETPLACE_URL}
+									</text>
+								</box>
+							);
+						}
+
+						const command = filtered[absoluteIndex];
+						if (!command) return null;
+						return (
+							<box
+								key={command.name}
+								flexDirection="row"
+								backgroundColor={isSelected ? palette.selection : undefined}
+								onMouseDown={() => resolve(command.name)}
+								height={1}
+							>
+								<text
+									fg={isSelected ? palette.textOnSelection : "white"}
+									width={commandWidth}
+									flexShrink={0}
+								>
+									{command.name}
+								</text>
+								<text fg={isSelected ? palette.textOnSelection : "gray"}>
+									{command.description}
+								</text>
+							</box>
+						);
+					})
+				)}
+			</box>
+
+			{commands.length === 0 && !hasFilter && (
+				<text fg="gray">
+					Install skills with: <strong>npx skills add owner/repo</strong>
+				</text>
+			)}
+
+			<text fg="gray">
+				<em>
+					Type to filter, ↑/↓ navigate
+					{enterAction ? `, Enter to ${enterAction}` : ""}, Esc to close
+				</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/dialogs/tool-approval.tsx b/apps/cli/src/tui/components/dialogs/tool-approval.tsx
new file mode 100644
index 0000000..55a2b6f
--- /dev/null
+++ b/apps/cli/src/tui/components/dialogs/tool-approval.tsx
@@ -0,0 +1,174 @@
+import type { ToolApprovalRequest } from "@cline/shared";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import type React from "react";
+import { palette } from "../../palette";
+import {
+	parseApplyPatchInput,
+	parseEditorInput,
+	parseReadFilesInput,
+	parseRunCommandsInput,
+	parseSearchInput,
+	parseSpawnAgentInput,
+	parseWebFetchInput,
+	shortenPath,
+} from "../../utils/tool-parsing";
+
+export function formatApprovalParams(
+	toolName: string,
+	rawInput: unknown,
+): React.ReactNode {
+	switch (toolName) {
+		case "read_files": {
+			const info = parseReadFilesInput(rawInput);
+			if (!info?.files.length) break;
+			return info.files.map((f, i) => {
+				const range =
+					f.startLine != null
+						? ` lines ${f.startLine}-${f.endLine ?? "end"}`
+						: "";
+				return (
+					<text key={f.path} fg="gray" selectable>
+						{"  "}
+						{shortenPath(f.path, 60)}
+						{range && <span fg="gray">{range}</span>}
+						{i < info.files.length - 1 ? "\n" : ""}
+					</text>
+				);
+			});
+		}
+		case "run_commands": {
+			const info = parseRunCommandsInput(rawInput);
+			if (!info?.commands.length) break;
+			return info.commands.map((cmd, i) => (
+				<text key={`cmd-${i.toString()}`} fg="gray" selectable>
+					{"  "}$ {cmd}
+				</text>
+			));
+		}
+		case "editor":
+		case "edit":
+		case "write": {
+			const info = parseEditorInput(rawInput);
+			if (!info) break;
+			return (
+				<text fg="gray" selectable>
+					{"  "}
+					{shortenPath(info.path, 60)}
+				</text>
+			);
+		}
+		case "apply_patch": {
+			const patchInfo = parseApplyPatchInput(rawInput);
+			if (!patchInfo?.files.length) break;
+			return (
+				<text fg="gray" selectable>
+					{"  "}
+					{patchInfo.files.map((f) => shortenPath(f, 60)).join(", ")}
+				</text>
+			);
+		}
+		case "search_codebase": {
+			const info = parseSearchInput(rawInput);
+			if (!info?.queries.length) break;
+			return (
+				<text fg="gray" selectable>
+					{"  "}
+					{info.queries.join(", ")}
+				</text>
+			);
+		}
+		case "fetch_web_content": {
+			const info = parseWebFetchInput(rawInput);
+			if (!info?.urls.length) break;
+			return info.urls.map((url, i) => (
+				<text key={`url-${i.toString()}`} fg="gray" selectable>
+					{"  "}
+					{url}
+				</text>
+			));
+		}
+		case "spawn_agent": {
+			const info = parseSpawnAgentInput(rawInput);
+			if (!info) break;
+			const task =
+				info.task.length > 80 ? `${info.task.slice(0, 80)}...` : info.task;
+			return (
+				<text fg="gray" selectable>
+					{"  "}
+					{task}
+				</text>
+			);
+		}
+		case "switch_to_act_mode":
+			return (
+				<text fg="gray" selectable>
+					{"  "}Switch from plan mode to act mode
+				</text>
+			);
+		case "ask_followup_question": {
+			if (rawInput && typeof rawInput === "object" && "question" in rawInput) {
+				const q = String((rawInput as { question: unknown }).question);
+				const preview = q.length > 80 ? `${q.slice(0, 80)}...` : q;
+				return (
+					<text fg="gray" selectable>
+						{"  "}
+						{preview}
+					</text>
+				);
+			}
+			break;
+		}
+	}
+
+	if (rawInput != null) {
+		const json = JSON.stringify(rawInput, null, 2);
+		const preview = json.length > 200 ? `${json.slice(0, 200)}...` : json;
+		return (
+			<text fg="gray" selectable>
+				{"  "}
+				{preview}
+			</text>
+		);
+	}
+	return null;
+}
+
+export function ToolApprovalContent(
+	props: ChoiceContext<boolean> & { request: ToolApprovalRequest },
+) {
+	useDialogKeyboard((key) => {
+		if (key.name === "y" || key.name === "return") {
+			props.resolve(true);
+		}
+		if (key.name === "n" || key.name === "escape") {
+			props.resolve(false);
+		}
+	}, props.dialogId);
+
+	const params = formatApprovalParams(
+		props.request.toolName,
+		props.request.input,
+	);
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text fg="yellow">Approve tool call?</text>
+
+			<text fg={palette.act} marginTop={1}>
+				<strong>{props.request.toolName}</strong>
+			</text>
+
+			{params && (
+				<box flexDirection="column" marginTop={1}>
+					{params}
+				</box>
+			)}
+
+			<text marginTop={1}>
+				<span fg={palette.success}>[y]</span> approve{"  "}
+				<span fg="red">[n]</span> deny
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/inline-tool-response.tsx b/apps/cli/src/tui/components/inline-tool-response.tsx
new file mode 100644
index 0000000..905e584
--- /dev/null
+++ b/apps/cli/src/tui/components/inline-tool-response.tsx
@@ -0,0 +1,507 @@
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { useKeyboard, useTerminalDimensions } from "@opentui/react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { palette } from "../palette";
+import type { RuntimeToolInteraction } from "../types";
+import { formatApprovalParams } from "./dialogs/tool-approval";
+
+export interface InlineToolResponseProps {
+	interaction: RuntimeToolInteraction;
+	accent: string;
+	inputBackground: string;
+	inputForeground: string;
+	inputPlaceholder: string;
+	onResolveToolApproval: (id: number, approved: boolean) => void;
+	onResolveAskQuestion: (id: number, answer: string | null) => void;
+}
+
+function isPrintableKey(name: string): boolean {
+	return name.length === 1 || name === "space";
+}
+
+function keyToText(name: string): string {
+	return name === "space" ? " " : name;
+}
+
+function getToolShellMaxHeight(terminalHeight: number): number {
+	return Math.max(7, Math.min(14, Math.floor(terminalHeight * 0.38)));
+}
+
+function getAskQuestionShellMaxHeight(terminalHeight: number): number {
+	const preferredHeight = Math.max(11, Math.floor(terminalHeight * 0.58));
+	const availableHeight = Math.max(7, terminalHeight - 3);
+	return Math.min(18, preferredHeight, availableHeight);
+}
+
+function getAskQuestionBodyHeight(shellMaxHeight: number): number {
+	return Math.max(1, shellMaxHeight - 4);
+}
+
+function addWrappedWidth(input: {
+	rows: number;
+	lineWidth: number;
+	width: number;
+	maxWidth: number;
+}): { rows: number; lineWidth: number } {
+	if (input.width <= 0) {
+		return { rows: input.rows, lineWidth: input.lineWidth };
+	}
+
+	let rows = input.rows;
+	let remainingWidth = input.width;
+	let lineWidth = input.lineWidth;
+
+	if (lineWidth > 0) {
+		const availableWidth = input.maxWidth - lineWidth;
+		if (remainingWidth <= availableWidth) {
+			return { rows, lineWidth: lineWidth + remainingWidth };
+		}
+
+		remainingWidth -= Math.max(0, availableWidth);
+		rows += 1;
+		lineWidth = 0;
+	}
+
+	rows += Math.max(0, Math.ceil(remainingWidth / input.maxWidth) - 1);
+	lineWidth = remainingWidth % input.maxWidth || input.maxWidth;
+
+	return { rows, lineWidth };
+}
+
+function countWrappedRows(text: string, width: number): number {
+	const safeWidth = Math.max(1, width);
+	const paragraphs = text.split("\n");
+	let rows = 0;
+
+	for (const paragraph of paragraphs) {
+		rows += 1;
+		let lineWidth = 0;
+		const tokens = paragraph.match(/\s+|\S+/g) ?? [];
+
+		for (const token of tokens) {
+			const tokenWidth = Bun.stringWidth(token);
+			const isWhitespace = /^\s+$/.test(token);
+
+			if (
+				!isWhitespace &&
+				lineWidth > 0 &&
+				lineWidth + tokenWidth > safeWidth
+			) {
+				rows += 1;
+				lineWidth = 0;
+			}
+
+			const next = addWrappedWidth({
+				rows,
+				lineWidth,
+				width: tokenWidth,
+				maxWidth: safeWidth,
+			});
+			rows = next.rows;
+			lineWidth = next.lineWidth;
+		}
+	}
+
+	return rows;
+}
+
+function getAskQuestionContentHeight(input: {
+	terminalWidth: number;
+	question: string;
+	options: string[];
+	customText: string;
+}): number {
+	const questionWidth = Math.max(1, input.terminalWidth - 3);
+	const optionTextWidth = Math.max(1, input.terminalWidth - 7);
+	const questionRows = countWrappedRows(input.question, questionWidth);
+	const optionRows = input.options.reduce(
+		(rows, option) => rows + countWrappedRows(option, optionTextWidth),
+		0,
+	);
+	const customRows = countWrappedRows(input.customText, optionTextWidth);
+	return questionRows + 1 + optionRows + customRows;
+}
+
+function getAskQuestionChoiceId(interactionId: number, index: number): string {
+	return `ask-question-${interactionId.toString()}-choice-${index.toString()}`;
+}
+
+function Shell(
+	props: Pick<
+		InlineToolResponseProps,
+		"accent" | "inputBackground" | "inputForeground"
+	> & {
+		title: string;
+		maxHeight?: number;
+		overflow?: "hidden";
+		children: React.ReactNode;
+	},
+) {
+	const { height } = useTerminalDimensions();
+	const maxHeight = props.maxHeight ?? getToolShellMaxHeight(height);
+
+	return (
+		<box
+			flexDirection="column"
+			width="100%"
+			maxHeight={maxHeight}
+			overflow={props.overflow}
+			backgroundColor={props.inputBackground}
+			paddingX={1}
+			paddingY={1}
+			gap={1}
+		>
+			<box flexDirection="row" gap={1}>
+				<text fg={palette.act}>{props.title}</text>
+			</box>
+			{props.children}
+		</box>
+	);
+}
+
+function ChoiceButton(props: {
+	label: string;
+	selected: boolean;
+	selectedFg?: string;
+	onPress: () => void;
+}) {
+	return (
+		// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI boxes handle terminal mouse input.
+		<box
+			paddingX={1}
+			backgroundColor={props.selected ? palette.selection : undefined}
+			onMouseDown={props.onPress}
+		>
+			<text
+				fg={
+					props.selected
+						? (props.selectedFg ?? palette.textOnSelection)
+						: undefined
+				}
+			>
+				{props.label}
+			</text>
+		</box>
+	);
+}
+
+function ToolApprovalResponse(
+	props: InlineToolResponseProps & {
+		interaction: Extract<RuntimeToolInteraction, { kind: "tool_approval" }>;
+	},
+) {
+	const [selected, setSelected] = useState<"approve" | "deny">("approve");
+	const selectedRef = useRef(selected);
+	selectedRef.current = selected;
+	const request = props.interaction.request;
+	const interactionId = props.interaction.id;
+	const onResolveToolApproval = props.onResolveToolApproval;
+	const params = formatApprovalParams(request.toolName, request.input);
+
+	const resolve = useCallback(
+		(approved: boolean) => {
+			onResolveToolApproval(interactionId, approved);
+		},
+		[interactionId, onResolveToolApproval],
+	);
+
+	useKeyboard((key) => {
+		if (key.name === "y") {
+			resolve(true);
+			return;
+		}
+		if (key.name === "n" || key.name === "escape") {
+			resolve(false);
+			return;
+		}
+		if (key.name === "left" || key.name === "right" || key.name === "tab") {
+			setSelected((current) => (current === "approve" ? "deny" : "approve"));
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			resolve(selectedRef.current === "approve");
+		}
+	});
+
+	return (
+		<Shell
+			title="Cline needs permission"
+			accent={props.accent}
+			inputBackground={props.inputBackground}
+			inputForeground={props.inputForeground}
+		>
+			<box flexDirection="column" gap={1}>
+				<text fg="yellow">Approve tool call?</text>
+				<text fg={props.accent} selectable>
+					{request.toolName}
+				</text>
+				{params && (
+					<box flexDirection="column" overflow="hidden">
+						{params}
+					</box>
+				)}
+			</box>
+			<box flexDirection="row" gap={1}>
+				<ChoiceButton
+					label="[y] Approve"
+					selected={selected === "approve"}
+					onPress={() => resolve(true)}
+				/>
+				<ChoiceButton
+					label="[n] Deny"
+					selected={selected === "deny"}
+					onPress={() => resolve(false)}
+				/>
+			</box>
+		</Shell>
+	);
+}
+
+function AskQuestionResponse(
+	props: InlineToolResponseProps & {
+		interaction: Extract<RuntimeToolInteraction, { kind: "ask_question" }>;
+	},
+) {
+	const { interaction } = props;
+	const { height, width } = useTerminalDimensions();
+	const [selected, setSelected] = useState(0);
+	const [customValue, setCustomValue] = useState("");
+	const [customEmptyAttempted, setCustomEmptyAttempted] = useState(false);
+	const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+	const selectedRef = useRef(0);
+	const customValueRef = useRef("");
+	const interactionId = interaction.id;
+	const onResolveAskQuestion = props.onResolveAskQuestion;
+	const customIndex = interaction.options.length;
+	const isTyping = selected === customIndex;
+	const totalChoices = interaction.options.length + 1;
+	const shellMaxHeight = getAskQuestionShellMaxHeight(height);
+	const maxBodyHeight = getAskQuestionBodyHeight(shellMaxHeight);
+	const customText = isTyping
+		? customValue
+			? `${customValue}|`
+			: customEmptyAttempted
+				? "Type a response first..."
+				: "Type a response..."
+		: "Type a response...";
+	const bodyHeight = Math.min(
+		maxBodyHeight,
+		getAskQuestionContentHeight({
+			terminalWidth: width,
+			question: interaction.question,
+			options: interaction.options,
+			customText,
+		}),
+	);
+
+	const selectIndex = useCallback(
+		(index: number) => {
+			selectedRef.current = index;
+			setSelected(index);
+			if (index !== customIndex) {
+				setCustomEmptyAttempted(false);
+			}
+		},
+		[customIndex],
+	);
+
+	const setCustomText = useCallback((value: string) => {
+		customValueRef.current = value;
+		setCustomValue(value);
+		if (value.trim()) {
+			setCustomEmptyAttempted(false);
+		}
+	}, []);
+
+	const resolveAnswer = useCallback(
+		(answer: string | null) => {
+			onResolveAskQuestion(interactionId, answer);
+		},
+		[interactionId, onResolveAskQuestion],
+	);
+
+	useEffect(() => {
+		const choiceId = getAskQuestionChoiceId(interactionId, selected);
+		let canceled = false;
+		const scrollSelectedChoiceIntoView = () => {
+			if (canceled) {
+				return;
+			}
+
+			scrollRef.current?.scrollChildIntoView(choiceId);
+		};
+
+		scrollSelectedChoiceIntoView();
+		queueMicrotask(scrollSelectedChoiceIntoView);
+		const timeout = setTimeout(scrollSelectedChoiceIntoView, 0);
+		return () => {
+			canceled = true;
+			clearTimeout(timeout);
+		};
+	}, [interactionId, selected]);
+
+	useKeyboard((key) => {
+		const typing = selectedRef.current === customIndex;
+		if (key.name === "escape") {
+			if (typing && customValueRef.current) {
+				setCustomText("");
+				return;
+			}
+			resolveAnswer(null);
+			return;
+		}
+		if (typing && key.name === "backspace") {
+			setCustomText(customValueRef.current.slice(0, -1));
+			return;
+		}
+		if (typing && key.name === "delete") {
+			setCustomText("");
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			if (typing) {
+				const answer = customValueRef.current.trim();
+				if (answer) {
+					resolveAnswer(answer);
+					return;
+				}
+				setCustomEmptyAttempted(true);
+				return;
+			}
+			resolveAnswer(interaction.options[selectedRef.current] ?? "");
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			const next =
+				selectedRef.current <= 0 ? totalChoices - 1 : selectedRef.current - 1;
+			selectIndex(next);
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			const next =
+				selectedRef.current >= totalChoices - 1 ? 0 : selectedRef.current + 1;
+			selectIndex(next);
+			return;
+		}
+		if (!typing && key.name >= "1" && key.name <= "9") {
+			const index = Number.parseInt(key.name, 10) - 1;
+			const option = interaction.options[index];
+			if (option) {
+				resolveAnswer(option);
+				return;
+			}
+		}
+		if (typing && !key.ctrl && !key.meta && isPrintableKey(key.name)) {
+			const value = keyToText(key.name);
+			setCustomText(`${customValueRef.current}${value}`);
+			return;
+		}
+		if (!key.ctrl && !key.meta && isPrintableKey(key.name)) {
+			const value = keyToText(key.name);
+			setCustomText(value);
+			selectIndex(customIndex);
+		}
+	});
+
+	return (
+		<Shell
+			title="Cline is asking a question"
+			accent={props.accent}
+			inputBackground={props.inputBackground}
+			inputForeground={props.inputForeground}
+			maxHeight={shellMaxHeight}
+			overflow="hidden"
+		>
+			<scrollbox
+				ref={scrollRef}
+				height={bodyHeight}
+				width="100%"
+				scrollY
+				scrollX={false}
+				viewportOptions={{ overflow: "hidden" }}
+				contentOptions={{ flexDirection: "column" }}
+			>
+				<box flexDirection="column" gap={1} flexShrink={0} width="100%">
+					<text fg={props.inputForeground} selectable flexShrink={0}>
+						{interaction.question}
+					</text>
+
+					<box flexDirection="column" flexShrink={0} width="100%">
+						{interaction.options.map((option, index) => {
+							const optionSelected = !isTyping && selected === index;
+							return (
+								// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI boxes handle terminal mouse input.
+								<box
+									id={getAskQuestionChoiceId(interactionId, index)}
+									key={`${index.toString()}:${option}`}
+									paddingX={1}
+									flexDirection="row"
+									gap={1}
+									flexShrink={0}
+									width="100%"
+									backgroundColor={
+										optionSelected ? palette.selection : undefined
+									}
+									onMouseDown={() => resolveAnswer(option)}
+								>
+									<text
+										fg={optionSelected ? palette.textOnSelection : "gray"}
+										flexShrink={0}
+									>
+										{optionSelected ? ">" : " "}
+									</text>
+									<text
+										fg={
+											optionSelected
+												? palette.textOnSelection
+												: props.inputForeground
+										}
+										flexGrow={1}
+										flexShrink={1}
+									>
+										{option}
+									</text>
+								</box>
+							);
+						})}
+						{/* biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI boxes handle terminal mouse input. */}
+						<box
+							id={getAskQuestionChoiceId(interactionId, customIndex)}
+							paddingX={1}
+							flexDirection="row"
+							gap={1}
+							flexShrink={0}
+							width="100%"
+							backgroundColor={isTyping ? palette.selection : undefined}
+							onMouseDown={() => selectIndex(customIndex)}
+						>
+							<text
+								fg={isTyping ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{isTyping ? ">" : " "}
+							</text>
+							{isTyping ? (
+								<text fg={palette.textOnSelection} flexGrow={1} flexShrink={1}>
+									{customText}
+								</text>
+							) : (
+								<text fg={props.inputPlaceholder} flexGrow={1} flexShrink={1}>
+									Type a response...
+								</text>
+							)}
+						</box>
+					</box>
+				</box>
+			</scrollbox>
+		</Shell>
+	);
+}
+
+export function InlineToolResponse(props: InlineToolResponseProps) {
+	if (props.interaction.kind === "tool_approval") {
+		return <ToolApprovalResponse {...props} interaction={props.interaction} />;
+	}
+
+	return <AskQuestionResponse {...props} interaction={props.interaction} />;
+}
diff --git a/apps/cli/src/tui/components/input-bar.tsx b/apps/cli/src/tui/components/input-bar.tsx
new file mode 100644
index 0000000..76c0403
--- /dev/null
+++ b/apps/cli/src/tui/components/input-bar.tsx
@@ -0,0 +1,247 @@
+import {
+	decodePasteBytes,
+	type KeyEvent,
+	type PasteEvent,
+	stripAnsiSequences,
+	type TextareaRenderable,
+} from "@opentui/core";
+import { useCallback, useRef } from "react";
+import {
+	readClipboardImageDataUrl,
+	readImagePasteAttachment,
+	readImmediateImagePasteAttachment,
+} from "../utils/image-paste";
+import { shouldCompactPastedText } from "../utils/pasted-snippets";
+
+export type TextareaHandle = Pick<
+	TextareaRenderable,
+	| "plainText"
+	| "onSubmit"
+	| "focus"
+	| "setText"
+	| "insertText"
+	| "cursorOffset"
+	| "visualCursor"
+	| "height"
+	| "virtualLineCount"
+	| "extmarks"
+	| "getSelection"
+>;
+
+export interface InputBarProps {
+	accent: string;
+	ruleColor: string;
+	inputForeground: string;
+	inputPlaceholder: string;
+	placeholder: string;
+	initialValue: string;
+	inputKey: number;
+	onSubmit: () => void;
+	onContentChange: (text: string) => void;
+	onImagePaste?: (dataUrl: string) => string;
+	onLargeTextPaste?: (text: string) => string;
+	onVisualCursorChange?: (cursor: {
+		visualCol: number;
+		visualRow: number;
+	}) => void;
+	onFocusRequest?: () => void;
+	textareaRef?: React.MutableRefObject<TextareaHandle | null>;
+}
+
+function readTextPaste(event: PasteEvent): string | null {
+	if (
+		event.metadata?.kind === "binary" ||
+		event.metadata?.mimeType?.startsWith("image/")
+	) {
+		return null;
+	}
+
+	return stripAnsiSequences(decodePasteBytes(event.bytes));
+}
+
+export function InputBar(props: InputBarProps) {
+	const {
+		accent,
+		ruleColor,
+		inputForeground,
+		inputPlaceholder,
+		placeholder,
+		initialValue,
+		inputKey,
+		onSubmit,
+		onContentChange,
+	} = props;
+	const localRef = useRef<TextareaHandle | null>(null);
+	const inputRef = props.textareaRef ?? localRef;
+
+	const onSubmitRef = useRef(onSubmit);
+	onSubmitRef.current = onSubmit;
+	const onContentChangeRef = useRef(onContentChange);
+	onContentChangeRef.current = onContentChange;
+	const onImagePasteRef = useRef(props.onImagePaste);
+	onImagePasteRef.current = props.onImagePaste;
+	const onLargeTextPasteRef = useRef(props.onLargeTextPaste);
+	onLargeTextPasteRef.current = props.onLargeTextPaste;
+	const onVisualCursorChangeRef = useRef(props.onVisualCursorChange);
+	onVisualCursorChangeRef.current = props.onVisualCursorChange;
+
+	const emitVisualCursorChange = useCallback(() => {
+		const cursor = inputRef.current?.visualCursor;
+		if (!cursor) return;
+		onVisualCursorChangeRef.current?.({
+			visualCol: cursor.visualCol,
+			visualRow: cursor.visualRow,
+		});
+	}, [inputRef]);
+
+	const textareaRefCallback = useCallback(
+		(node: unknown) => {
+			const ta = node as TextareaHandle | null;
+			inputRef.current = ta;
+			if (ta) {
+				ta.onSubmit = () => {
+					onSubmitRef.current();
+				};
+				emitVisualCursorChange();
+			}
+		},
+		[emitVisualCursorChange, inputRef],
+	);
+
+	const insertImageAttachment = useCallback(
+		(dataUrl: string) => {
+			const marker = onImagePasteRef.current?.(dataUrl);
+			if (!marker) return;
+			inputRef.current?.insertText(`${marker} `);
+			queueMicrotask(() => {
+				const text = inputRef.current?.plainText ?? "";
+				onContentChangeRef.current(text);
+			});
+		},
+		[inputRef],
+	);
+
+	const insertAtomicText = useCallback(
+		(text: string) => {
+			const ta = inputRef.current;
+			if (!ta) return;
+
+			const selection = ta.getSelection();
+			const start = selection
+				? Math.min(selection.start, selection.end)
+				: ta.cursorOffset;
+			ta.insertText(text);
+			ta.extmarks.create({
+				start,
+				end: start + text.length,
+				virtual: true,
+			});
+			queueMicrotask(() => {
+				const plainText = inputRef.current?.plainText ?? "";
+				onContentChangeRef.current(plainText);
+			});
+		},
+		[inputRef],
+	);
+
+	const handlePaste = useCallback(
+		(event: PasteEvent) => {
+			if (onImagePasteRef.current) {
+				const immediate = readImmediateImagePasteAttachment(event);
+				if (immediate) {
+					event.preventDefault();
+					insertImageAttachment(immediate.dataUrl);
+					return;
+				}
+			}
+
+			const pastedText = readTextPaste(event);
+			if (
+				pastedText &&
+				shouldCompactPastedText(pastedText) &&
+				onLargeTextPasteRef.current
+			) {
+				const marker = onLargeTextPasteRef.current(pastedText);
+				event.preventDefault();
+				insertAtomicText(marker);
+				return;
+			}
+
+			if (onImagePasteRef.current) {
+				void readImagePasteAttachment(event).then((attachment) => {
+					if (!attachment) return;
+					event.preventDefault();
+					insertImageAttachment(attachment.dataUrl);
+				});
+			}
+		},
+		[insertAtomicText, insertImageAttachment],
+	);
+
+	const handleKeyDown = useCallback(
+		(event: KeyEvent) => {
+			if (!event.ctrl || event.name !== "v" || !onImagePasteRef.current) {
+				return;
+			}
+
+			void readClipboardImageDataUrl().then((dataUrl) => {
+				if (!dataUrl) return;
+				event.preventDefault();
+				insertImageAttachment(dataUrl);
+			});
+		},
+		[insertImageAttachment],
+	);
+
+	return (
+		<box
+			flexDirection="row"
+			alignItems="flex-start"
+			border={["top", "bottom"]}
+			borderStyle="single"
+			borderColor={ruleColor}
+			onMouseDown={props.onFocusRequest}
+		>
+			<text fg={accent}>
+				<strong>{"❯"}</strong>
+			</text>
+			<box flexGrow={1} paddingLeft={1}>
+				<textarea
+					key={inputKey}
+					ref={textareaRefCallback as React.RefCallback<never>}
+					initialValue={initialValue}
+					onContentChange={() => {
+						queueMicrotask(() => {
+							const text = inputRef.current?.plainText ?? "";
+							onContentChangeRef.current(text);
+							emitVisualCursorChange();
+						});
+					}}
+					onPaste={handlePaste}
+					onKeyDown={(event: KeyEvent) => {
+						handleKeyDown(event);
+						queueMicrotask(() => {
+							emitVisualCursorChange();
+						});
+					}}
+					placeholder={placeholder}
+					placeholderColor={inputPlaceholder}
+					textColor={inputForeground}
+					focusedTextColor={inputForeground}
+					focused
+					flexGrow={1}
+					cursorColor={accent}
+					minHeight={1}
+					maxHeight={5}
+					wrapMode="word"
+					keyBindings={[
+						{ name: "return", action: "submit" },
+						{ name: "return", shift: true, action: "newline" },
+						{ name: "return", ctrl: true, action: "newline" },
+						{ name: "return", meta: true, action: "newline" },
+					]}
+				/>
+			</box>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/model-selector/cline-model-entries.ts b/apps/cli/src/tui/components/model-selector/cline-model-entries.ts
new file mode 100644
index 0000000..da79507
--- /dev/null
+++ b/apps/cli/src/tui/components/model-selector/cline-model-entries.ts
@@ -0,0 +1,106 @@
+import type {
+	ClineRecommendedModel,
+	ClineRecommendedModelsData,
+} from "@cline/core";
+
+export type ClineModelPickerTier = "recommended" | "subscribed" | "free";
+
+export interface ClineModelPickerItem {
+	kind: "model";
+	model: ClineRecommendedModel;
+	tier: ClineModelPickerTier;
+}
+
+export interface ClineModelPickerBrowse {
+	kind: "browse";
+}
+
+export type ClineModelPickerEntry =
+	| ClineModelPickerItem
+	| ClineModelPickerBrowse;
+
+export const CLINE_MODEL_PICKER_TIER_LABELS: Record<
+	ClineModelPickerTier,
+	string
+> = {
+	recommended: "Recommended",
+	subscribed: "Subscribed",
+	free: "Free",
+};
+
+// Featured entries for the sectioned picker, keyed by provider: cline gets
+// Recommended/Free with a browse-all escape into the full catalog; cline-pass
+// gets Subscribed/Free (see buildClinePassModelEntries for why no browse-all).
+export function buildFeaturedModelEntries(
+	providerId: string,
+	data: ClineRecommendedModelsData,
+): ClineModelPickerEntry[] {
+	return providerId === "cline-pass"
+		? buildClinePassModelEntries(data)
+		: buildClineModelEntries(data);
+}
+
+function buildClineModelEntries(
+	data: ClineRecommendedModelsData,
+): ClineModelPickerEntry[] {
+	const entries: ClineModelPickerEntry[] = [];
+	for (const m of data.recommended) {
+		entries.push({ kind: "model", model: m, tier: "recommended" });
+	}
+	for (const m of data.free) {
+		entries.push({ kind: "model", model: m, tier: "free" });
+	}
+	entries.push({ kind: "browse" });
+	return entries;
+}
+
+// Shown under the Free section header when picking a model for ClinePass
+export const CLINE_PASS_FREE_SECTION_DESCRIPTION =
+	"Try with limited usage, separate from ClinePass quota.";
+
+// ClinePass shows the subscription's models plus the Cline free models — both
+// providers hit the same Cline API, so free models are selectable in place
+// (they ride usage billing at $0 instead of the subscription quota).
+// No "browse all" entry when the clinePass bucket is populated: unlike cline,
+// the ClinePass catalog contains exactly these two buckets, so the sections
+// already list every selectable model. An empty clinePass bucket means the
+// fetch fell back to the bundled list (which has no pass models) — without an
+// escape into the full catalog a subscriber could only pick free models, so
+// browse-all comes back in that degraded mode.
+function buildClinePassModelEntries(
+	data: ClineRecommendedModelsData,
+): ClineModelPickerEntry[] {
+	const entries: ClineModelPickerEntry[] = [];
+	for (const m of data.clinePass) {
+		entries.push({ kind: "model", model: m, tier: "subscribed" });
+	}
+	for (const m of data.free) {
+		entries.push({ kind: "model", model: m, tier: "free" });
+	}
+	if (data.clinePass.length === 0) {
+		entries.push({ kind: "browse" });
+	}
+	return entries;
+}
+
+// The quota explainer only makes sense in the ClinePass picker, which is the
+// only picker that has a "subscribed" section
+export function freeTierDescriptionFor(
+	entries: ClineModelPickerEntry[],
+): string | undefined {
+	const isClinePassPicker = entries.some(
+		(entry) => entry.kind === "model" && entry.tier === "subscribed",
+	);
+	return isClinePassPicker ? CLINE_PASS_FREE_SECTION_DESCRIPTION : undefined;
+}
+
+// OpenRouter marks free variants with "(free)" in names and ":free" in ids to
+// disambiguate them from their paid twins. Inside the sectioned pickers the
+// Free header already says it, so the markers are redundant — but keep them in
+// flat lists (e.g. browse-all), where both variants appear side by side.
+export function stripFreeMarker(displayName: string): string {
+	return displayName
+		.replace(/\s*\(free\)\s*$/i, "")
+		.replace(/:free$/i, "")
+		.trim();
+}
diff --git a/apps/cli/src/tui/components/model-selector/cline-model-picker.test.ts b/apps/cli/src/tui/components/model-selector/cline-model-picker.test.ts
new file mode 100644
index 0000000..9b21403
--- /dev/null
+++ b/apps/cli/src/tui/components/model-selector/cline-model-picker.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildFeaturedModelEntries,
+	CLINE_PASS_FREE_SECTION_DESCRIPTION,
+	freeTierDescriptionFor,
+	stripFreeMarker,
+} from "./cline-model-entries";
+
+const model = (id: string) => ({ id, name: id, description: "", tags: [] });
+
+describe("cline model picker entries", () => {
+	it("builds Recommended/Free sections for the cline provider", () => {
+		const entries = buildFeaturedModelEntries("cline", {
+			recommended: [model("anthropic/claude-sonnet-5")],
+			free: [model("deepseek/deepseek-v4-flash")],
+			clinePass: [model("cline-pass/glm-5.1")],
+		});
+
+		expect(entries).toEqual([
+			{
+				kind: "model",
+				model: model("anthropic/claude-sonnet-5"),
+				tier: "recommended",
+			},
+			{
+				kind: "model",
+				model: model("deepseek/deepseek-v4-flash"),
+				tier: "free",
+			},
+			{ kind: "browse" },
+		]);
+	});
+
+	it("builds Subscribed/Free sections for the cline-pass provider", () => {
+		const entries = buildFeaturedModelEntries("cline-pass", {
+			recommended: [model("anthropic/claude-sonnet-5")],
+			free: [model("deepseek/deepseek-v4-flash")],
+			clinePass: [model("cline-pass/glm-5.1"), model("cline-pass/kimi-k2.6")],
+		});
+
+		expect(entries).toEqual([
+			{ kind: "model", model: model("cline-pass/glm-5.1"), tier: "subscribed" },
+			{
+				kind: "model",
+				model: model("cline-pass/kimi-k2.6"),
+				tier: "subscribed",
+			},
+			{
+				kind: "model",
+				model: model("deepseek/deepseek-v4-flash"),
+				tier: "free",
+			},
+		]);
+	});
+
+	it("adds the browse-all escape when the clinePass bucket is empty", () => {
+		// The fetch fell back to the bundled list (no pass models); the sections
+		// alone would leave a subscriber able to pick only free models.
+		const entries = buildFeaturedModelEntries("cline-pass", {
+			recommended: [],
+			free: [model("deepseek/deepseek-v4-flash")],
+			clinePass: [],
+		});
+
+		expect(entries).toEqual([
+			{
+				kind: "model",
+				model: model("deepseek/deepseek-v4-flash"),
+				tier: "free",
+			},
+			{ kind: "browse" },
+		]);
+	});
+
+	it("attaches the quota explainer only to the ClinePass picker's free section", () => {
+		const data = {
+			recommended: [model("anthropic/claude-sonnet-5")],
+			free: [model("deepseek/deepseek-v4-flash")],
+			clinePass: [model("cline-pass/glm-5.1")],
+		};
+
+		expect(
+			freeTierDescriptionFor(buildFeaturedModelEntries("cline-pass", data)),
+		).toBe(CLINE_PASS_FREE_SECTION_DESCRIPTION);
+		expect(
+			freeTierDescriptionFor(buildFeaturedModelEntries("cline", data)),
+		).toBe(undefined);
+	});
+
+	it("strips redundant free markers from display names", () => {
+		expect(stripFreeMarker("Laguna M.1 (free)")).toBe("Laguna M.1");
+		expect(stripFreeMarker("Trinity Large Preview (FREE)")).toBe(
+			"Trinity Large Preview",
+		);
+		expect(stripFreeMarker("laguna-m.1:free")).toBe("laguna-m.1");
+		expect(stripFreeMarker("DeepSeek V4 Flash")).toBe("DeepSeek V4 Flash");
+	});
+});
diff --git a/apps/cli/src/tui/components/model-selector/cline-model-picker.tsx b/apps/cli/src/tui/components/model-selector/cline-model-picker.tsx
new file mode 100644
index 0000000..58f3165
--- /dev/null
+++ b/apps/cli/src/tui/components/model-selector/cline-model-picker.tsx
@@ -0,0 +1,177 @@
+// @jsxImportSource @opentui/react
+
+import {
+	type ClineRecommendedModelsData,
+	fetchClineRecommendedModels,
+} from "@cline/core";
+import type { ReactNode } from "react";
+import { useEffect, useState } from "react";
+import "opentui-spinner/react";
+import { palette } from "../../palette";
+import {
+	CLINE_MODEL_PICKER_TIER_LABELS,
+	type ClineModelPickerEntry,
+	freeTierDescriptionFor,
+	stripFreeMarker,
+} from "./cline-model-entries";
+
+export {
+	buildFeaturedModelEntries,
+	CLINE_MODEL_PICKER_TIER_LABELS,
+	type ClineModelPickerBrowse,
+	type ClineModelPickerEntry,
+	type ClineModelPickerItem,
+	type ClineModelPickerTier,
+	freeTierDescriptionFor,
+	stripFreeMarker,
+} from "./cline-model-entries";
+
+function tagColor(tag: string): string {
+	if (tag === "FREE") return palette.success;
+	if (tag === "BEST") return "magenta";
+	return palette.act;
+}
+
+function resolveDisplayName(
+	modelId: string,
+	knownModels?: Record<string, unknown>,
+): string {
+	if (knownModels) {
+		const candidates = [modelId, modelId.split("/").pop()];
+		for (const key of candidates) {
+			if (!key) continue;
+			const hit = knownModels[key] as { name?: string } | undefined;
+			if (hit?.name) return stripFreeMarker(hit.name);
+		}
+	}
+	const fallback = modelId.includes("/")
+		? (modelId.split("/").pop() ?? modelId)
+		: modelId;
+	return stripFreeMarker(fallback);
+}
+
+export function useClineRecommendedModels() {
+	const [data, setData] = useState<ClineRecommendedModelsData | null>(null);
+	const [loading, setLoading] = useState(true);
+
+	useEffect(() => {
+		let cancelled = false;
+		fetchClineRecommendedModels()
+			.then((result) => {
+				if (!cancelled) setData(result);
+			})
+			.finally(() => {
+				if (!cancelled) setLoading(false);
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	return { data, loading };
+}
+
+export function ClineModelPicker(props: {
+	entries: ClineModelPickerEntry[];
+	selected: number;
+	loading?: boolean;
+	knownModels?: Record<string, unknown>;
+	currentModelId?: string;
+}) {
+	const { entries, selected, loading, knownModels, currentModelId } = props;
+
+	if (loading) {
+		return (
+			<box flexDirection="row" gap={1} paddingX={1}>
+				<spinner name="dots" color="gray" />
+				<text fg="gray">Loading models...</text>
+			</box>
+		);
+	}
+
+	let lastTier: string | null = null;
+	let isFirstHeader = true;
+	const rows: ReactNode[] = [];
+	const freeTierDescription = freeTierDescriptionFor(entries);
+
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (!entry) continue;
+		const isSel = i === selected;
+
+		if (entry.kind === "model") {
+			if (entry.tier !== lastTier) {
+				lastTier = entry.tier;
+				const label = CLINE_MODEL_PICKER_TIER_LABELS[entry.tier];
+				rows.push(
+					<box
+						key={`tier-${entry.tier}`}
+						paddingX={1}
+						marginTop={isFirstHeader ? 0 : 1}
+						flexDirection="column"
+					>
+						<text fg="gray">{label}</text>
+						{entry.tier === "free" && freeTierDescription && (
+							<text fg="gray">
+								<em>{freeTierDescription}</em>
+							</text>
+						)}
+					</box>,
+				);
+				isFirstHeader = false;
+			}
+
+			const tags = entry.model.tags;
+			const name = resolveDisplayName(entry.model.id, knownModels);
+			const isCurrent = currentModelId === entry.model.id;
+			rows.push(
+				<box
+					key={entry.model.id}
+					paddingX={1}
+					flexDirection="row"
+					gap={1}
+					backgroundColor={isSel ? palette.selection : undefined}
+				>
+					<text fg={isSel ? palette.textOnSelection : "gray"} flexShrink={0}>
+						{isSel ? "\u276f" : " "}
+					</text>
+					<text fg={isSel ? palette.textOnSelection : undefined}>{name}</text>
+					{tags.map((t) => (
+						<text
+							key={t}
+							fg={isSel ? palette.textOnSelection : tagColor(t)}
+							flexShrink={0}
+						>
+							{t}
+						</text>
+					))}
+					{isCurrent && (
+						<text fg={isSel ? palette.textOnSelection : "gray"} flexShrink={0}>
+							(current)
+						</text>
+					)}
+				</box>,
+			);
+		} else {
+			rows.push(
+				<box
+					key="browse-all"
+					paddingX={1}
+					flexDirection="row"
+					gap={1}
+					backgroundColor={isSel ? palette.selection : undefined}
+					marginTop={1}
+				>
+					<text fg={isSel ? palette.textOnSelection : "gray"} flexShrink={0}>
+						{isSel ? "\u276f" : " "}
+					</text>
+					<text fg={isSel ? palette.textOnSelection : "gray"}>
+						Browse all models...
+					</text>
+				</box>,
+			);
+		}
+	}
+
+	return <box flexDirection="column">{rows}</box>;
+}
diff --git a/apps/cli/src/tui/components/model-selector/cline-model-selector.tsx b/apps/cli/src/tui/components/model-selector/cline-model-selector.tsx
new file mode 100644
index 0000000..b8242cf
--- /dev/null
+++ b/apps/cli/src/tui/components/model-selector/cline-model-selector.tsx
@@ -0,0 +1,311 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { palette } from "../../palette";
+import {
+	CLINE_MODEL_PICKER_TIER_LABELS,
+	type ClineModelPickerEntry,
+	freeTierDescriptionFor,
+	stripFreeMarker,
+} from "./cline-model-picker";
+import { CHANGE_PROVIDER_ACTION } from "./model-selector";
+import { ProviderRow } from "./provider-row";
+
+export const BROWSE_ALL_ACTION = "__browse_all__";
+
+type ClineModelEntriesState =
+	| { status: "loading"; message: string }
+	| { status: "loaded"; entries: ClineModelPickerEntry[] }
+	| { status: "error"; message: string };
+
+function tagColor(tag: string): string {
+	if (tag === "FREE") return palette.success;
+	if (tag === "BEST") return "magenta";
+	return palette.act;
+}
+
+function resolveDisplayName(
+	modelId: string,
+	knownModels?: Record<string, unknown>,
+): string {
+	if (knownModels) {
+		const candidates = [modelId, modelId.split("/").pop()];
+		for (const key of candidates) {
+			if (!key) continue;
+			const hit = knownModels[key] as { name?: string } | undefined;
+			if (hit?.name) return stripFreeMarker(hit.name);
+		}
+	}
+	const fallback = modelId.includes("/")
+		? (modelId.split("/").pop() ?? modelId)
+		: modelId;
+	return stripFreeMarker(fallback);
+}
+
+export function ClineModelSelectorContent(
+	props: ChoiceContext<string> & {
+		currentModel: string;
+		currentProviderName: string;
+		knownModels?: Record<string, unknown>;
+		entries: ClineModelPickerEntry[];
+	},
+) {
+	const {
+		resolve,
+		dismiss,
+		dialogId,
+		currentModel,
+		currentProviderName,
+		knownModels,
+		entries,
+	} = props;
+	const [selected, setSelected] = useState(0);
+	const [onProvider, setOnProvider] = useState(false);
+
+	const displayRows = useMemo(() => {
+		const rows: {
+			key: string;
+			kind: "header" | "model" | "browse";
+			label: string;
+			description?: string;
+			tags: string[];
+			isCurrent: boolean;
+			entryIndex: number;
+		}[] = [];
+		let lastTier: string | null = null;
+		const freeTierDescription = freeTierDescriptionFor(entries);
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			if (!entry) continue;
+			if (entry.kind === "model") {
+				if (entry.tier !== lastTier) {
+					lastTier = entry.tier;
+					rows.push({
+						key: `tier-${entry.tier}`,
+						kind: "header",
+						label: CLINE_MODEL_PICKER_TIER_LABELS[entry.tier],
+						description:
+							entry.tier === "free" ? freeTierDescription : undefined,
+						tags: [],
+						isCurrent: false,
+						entryIndex: -1,
+					});
+				}
+				rows.push({
+					key: entry.model.id,
+					kind: "model",
+					label: resolveDisplayName(entry.model.id, knownModels),
+					tags: entry.model.tags,
+					isCurrent: currentModel === entry.model.id,
+					entryIndex: i,
+				});
+			} else {
+				rows.push({
+					key: "browse-all",
+					kind: "browse",
+					label: "Browse all models...",
+					tags: [],
+					isCurrent: false,
+					entryIndex: i,
+				});
+			}
+		}
+		return rows;
+	}, [entries, knownModels, currentModel]);
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "tab") {
+			setOnProvider((v) => !v);
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			if (onProvider) {
+				resolve(CHANGE_PROVIDER_ACTION);
+				return;
+			}
+			const entry = entries[selected];
+			if (!entry) return;
+			if (entry.kind === "model") {
+				resolve(entry.model.id);
+			} else {
+				resolve(BROWSE_ALL_ACTION);
+			}
+			return;
+		}
+		const total = entries.length;
+		if (total === 0) return;
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			if (!onProvider) {
+				setSelected((s) => (s <= 0 ? total - 1 : s - 1));
+			}
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			if (!onProvider) {
+				setSelected((s) => (s >= total - 1 ? 0 : s + 1));
+			}
+			return;
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text>
+				<strong>Choose a model</strong>
+			</text>
+
+			<ProviderRow providerName={currentProviderName} focused={onProvider} />
+
+			<box flexDirection="column">
+				{displayRows.map((row, idx) => {
+					if (row.kind === "header") {
+						const isFirst = idx === 0;
+						return (
+							<box
+								key={row.key}
+								paddingX={1}
+								marginTop={isFirst ? 0 : 1}
+								flexDirection="column"
+							>
+								<text fg="gray">{row.label}</text>
+								{row.description && (
+									<text fg="gray">
+										<em>{row.description}</em>
+									</text>
+								)}
+							</box>
+						);
+					}
+					const isSel = row.entryIndex === selected && !onProvider;
+					const isGray = row.kind === "browse";
+					return (
+						<box
+							key={row.key}
+							paddingX={1}
+							flexDirection="row"
+							gap={1}
+							backgroundColor={isSel ? palette.selection : undefined}
+							marginTop={row.kind === "browse" ? 1 : 0}
+						>
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{isSel ? "\u276f" : " "}
+							</text>
+							<text
+								fg={
+									isSel ? palette.textOnSelection : isGray ? "gray" : undefined
+								}
+							>
+								{row.label}
+							</text>
+							{row.tags.map((t) => (
+								<text
+									key={t}
+									fg={isSel ? palette.textOnSelection : tagColor(t)}
+									flexShrink={0}
+								>
+									{t}
+								</text>
+							))}
+							{row.isCurrent && (
+								<text
+									fg={isSel ? palette.textOnSelection : "gray"}
+									flexShrink={0}
+								>
+									(current)
+								</text>
+							)}
+						</box>
+					);
+				})}
+			</box>
+
+			<text fg="gray">
+				↑/↓ navigate, Enter to select, Tab to change provider, Esc to go back
+			</text>
+		</box>
+	);
+}
+
+export function ClineModelSelectorDialogContent(
+	props: ChoiceContext<string> & {
+		currentModel: string;
+		currentProviderName: string;
+		knownModels?: Record<string, unknown>;
+		loadEntries: () => Promise<ClineModelPickerEntry[]>;
+	},
+) {
+	const { dismiss, dialogId, loadEntries } = props;
+	const [state, setState] = useState<ClineModelEntriesState>({
+		status: "loading",
+		message: "Loading Cline models...",
+	});
+	const generation = useRef(0);
+
+	const reload = useCallback(async () => {
+		const currentGeneration = generation.current + 1;
+		generation.current = currentGeneration;
+		setState({ status: "loading", message: "Loading Cline models..." });
+		try {
+			const entries = await loadEntries();
+			if (generation.current === currentGeneration) {
+				setState({ status: "loaded", entries });
+			}
+		} catch (error) {
+			if (generation.current === currentGeneration) {
+				setState({
+					status: "error",
+					message: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
+	}, [loadEntries]);
+
+	useEffect(() => {
+		void reload();
+	}, [reload]);
+
+	useDialogKeyboard((key) => {
+		if (state.status === "loaded") {
+			return;
+		}
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (state.status === "error" && key.name === "r") {
+			void reload();
+		}
+	}, dialogId);
+
+	if (state.status === "loaded") {
+		return <ClineModelSelectorContent {...props} entries={state.entries} />;
+	}
+
+	if (state.status === "error") {
+		return (
+			<box flexDirection="column" gap={1}>
+				<text fg={palette.act}>Choose a model</text>
+				<ProviderRow providerName={props.currentProviderName} focused={false} />
+				<text fg="red">{state.message}</text>
+				<text fg="gray">R to retry, Esc to go back</text>
+			</box>
+		);
+	}
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text fg={palette.act}>Choose a model</text>
+			<ProviderRow providerName={props.currentProviderName} focused={false} />
+			<text fg="gray">{state.message}</text>
+			<text fg="gray">Esc to go back</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/model-selector/model-selector.tsx b/apps/cli/src/tui/components/model-selector/model-selector.tsx
new file mode 100644
index 0000000..1b0ca7f
--- /dev/null
+++ b/apps/cli/src/tui/components/model-selector/model-selector.tsx
@@ -0,0 +1,610 @@
+// @jsxImportSource @opentui/react
+import type { Llms } from "@cline/core";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useMemo, useState } from "react";
+import { palette } from "../../palette";
+import { ProviderRow } from "./provider-row";
+
+export interface ModelOption {
+	key: string;
+	name: string;
+	maxInputTokens?: number;
+	family?: string;
+	supportsReasoning: boolean;
+}
+
+const MAX_VISIBLE = 10;
+
+function normalize(s: string): string {
+	return s.replace(/[^a-z0-9.]/g, "");
+}
+
+function fuzzyMatch(text: string, query: string): boolean {
+	let qi = 0;
+	for (let i = 0; i < text.length && qi < query.length; i++) {
+		if (text[i] === query[qi]) qi++;
+	}
+	return qi === query.length;
+}
+
+function fuzzyScore(model: ModelOption, query: string): number {
+	const name = model.name.toLowerCase();
+	const key = model.key.toLowerCase();
+	const nName = normalize(name);
+	const nKey = normalize(key);
+	const nQuery = normalize(query);
+	if (nName === nQuery || nKey === nQuery) return 100;
+	if (nName.startsWith(nQuery)) return 90;
+	if (nKey.startsWith(nQuery)) return 85;
+	if (nName.includes(nQuery)) return 70;
+	if (nKey.includes(nQuery)) return 65;
+	const family = model.family?.toLowerCase();
+	if (family && normalize(family).includes(nQuery)) return 50;
+	if (fuzzyMatch(nName, nQuery)) return 30;
+	if (fuzzyMatch(nKey, nQuery)) return 25;
+	return 0;
+}
+
+function formatTokenCount(tokens: number): string {
+	if (tokens >= 1_000_000)
+		return `${(tokens / 1_000_000).toFixed(tokens % 1_000_000 === 0 ? 0 : 1)}M`;
+	if (tokens >= 1_000) return `${Math.round(tokens / 1_000)}K`;
+	return String(tokens);
+}
+
+// -- Model selector dialog content --
+
+export const CHANGE_PROVIDER_ACTION = "__change_provider__";
+
+export function ModelIdInputContent(
+	props: ChoiceContext<string> & {
+		currentModel: string;
+		currentProviderName: string;
+	},
+) {
+	const { resolve, dismiss, dialogId, currentModel, currentProviderName } =
+		props;
+	const [modelId, setModelId] = useState(currentModel);
+	const [error, setError] = useState("");
+	const [onProvider, setOnProvider] = useState(false);
+
+	const submit = () => {
+		const trimmed = modelId.trim();
+		if (!trimmed) {
+			setError("Enter a model ID");
+			return;
+		}
+		resolve(trimmed);
+	};
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "tab") {
+			setOnProvider((value) => !value);
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			if (onProvider) {
+				resolve(CHANGE_PROVIDER_ACTION);
+				return;
+			}
+			submit();
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text>Set Model ID</text>
+
+			<ProviderRow providerName={currentProviderName} focused={onProvider} />
+
+			<box flexDirection="column" gap={0}>
+				<text fg="gray">Model ID</text>
+				<box
+					border
+					borderStyle="rounded"
+					borderColor={error ? "red" : onProvider ? "gray" : palette.act}
+					paddingX={1}
+				>
+					<input
+						value={modelId}
+						onInput={(value: string) => {
+							setModelId(value);
+							setError("");
+						}}
+						placeholder="provider/model"
+						flexGrow={1}
+						focused={!onProvider}
+					/>
+				</box>
+				{error && <text fg="red">{error}</text>}
+			</box>
+
+			<text fg="gray">Enter to save, Tab to change provider, Esc to close</text>
+		</box>
+	);
+}
+
+export function ModelSelectorContent(
+	props: ChoiceContext<string> & {
+		currentModel: string;
+		currentProviderName: string;
+		models: ModelOption[];
+		showCustomModelId?: boolean;
+	},
+) {
+	const {
+		resolve,
+		dismiss,
+		dialogId,
+		currentModel,
+		currentProviderName,
+		models,
+		showCustomModelId = true,
+	} = props;
+	const [search, setSearch] = useState("");
+	const [selected, setSelected] = useState(() => {
+		const idx = models.findIndex((m) => m.key === currentModel);
+		return idx >= 0 ? idx : 0;
+	});
+	const [onProvider, setOnProvider] = useState(false);
+	const [isCreatingCustomModel, setIsCreatingCustomModel] = useState(false);
+	const [customModelId, setCustomModelId] = useState("");
+	const [customModelError, setCustomModelError] = useState("");
+
+	const filtered = useMemo(() => {
+		if (!search) return models;
+		const q = search.toLowerCase();
+		const scored = models
+			.map((m) => ({ model: m, score: fuzzyScore(m, q) }))
+			.filter((r) => r.score > 0);
+		scored.sort((a, b) => b.score - a.score);
+		return scored.map((r) => r.model);
+	}, [models, search]);
+
+	const optionCount = filtered.length + (showCustomModelId ? 1 : 0);
+	const safeSelected = Math.min(selected, Math.max(0, optionCount - 1));
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			if (isCreatingCustomModel) {
+				setIsCreatingCustomModel(false);
+				setCustomModelError("");
+				return;
+			}
+			dismiss();
+			return;
+		}
+		if (isCreatingCustomModel) return;
+		if (key.name === "return" || key.name === "enter") {
+			if (onProvider) {
+				resolve(CHANGE_PROVIDER_ACTION);
+				return;
+			}
+			const model = filtered[safeSelected];
+			if (model) {
+				resolve(model.key);
+				return;
+			}
+			if (showCustomModelId && safeSelected === filtered.length) {
+				setIsCreatingCustomModel(true);
+				setCustomModelId("");
+				setCustomModelError("");
+			}
+			return;
+		}
+		if (key.name === "tab") {
+			if (onProvider) {
+				setOnProvider(false);
+			} else {
+				setOnProvider(true);
+			}
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			if (!onProvider) {
+				setSelected((s) =>
+					optionCount === 0 ? 0 : s <= 0 ? optionCount - 1 : s - 1,
+				);
+			}
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			if (!onProvider) {
+				setSelected((s) =>
+					optionCount === 0 ? 0 : s >= optionCount - 1 ? 0 : s + 1,
+				);
+			}
+			return;
+		}
+	}, dialogId);
+
+	if (isCreatingCustomModel) {
+		return (
+			<box flexDirection="column" gap={1}>
+				<text>Create custom model ID</text>
+
+				<ProviderRow providerName={currentProviderName} focused={false} />
+
+				<box flexDirection="column" gap={0}>
+					<text fg="gray">Model ID</text>
+					<box
+						border
+						borderStyle="rounded"
+						borderColor={customModelError ? "red" : "gray"}
+						paddingX={1}
+					>
+						<input
+							value={customModelId}
+							onInput={(v: string) => {
+								setCustomModelId(v);
+								setCustomModelError("");
+							}}
+							onSubmit={() => {
+								const modelId = customModelId.trim();
+								if (!modelId) {
+									setCustomModelError("Enter a model ID");
+									return;
+								}
+								resolve(modelId);
+							}}
+							placeholder=""
+							flexGrow={1}
+							focused
+						/>
+					</box>
+					{customModelError && <text fg="red">{customModelError}</text>}
+				</box>
+
+				<text fg="gray">
+					Enter to create, Esc to go back to model selection
+				</text>
+			</box>
+		);
+	}
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text>Select Model</text>
+
+			<ProviderRow providerName={currentProviderName} focused={onProvider} />
+
+			<box border borderStyle="rounded" borderColor="gray" paddingX={1}>
+				<input
+					onInput={(v: string) => {
+						setSearch(v);
+						setSelected(0);
+						setOnProvider(false);
+					}}
+					placeholder="Search models..."
+					flexGrow={1}
+					focused
+				/>
+			</box>
+
+			<ModelList
+				items={filtered}
+				selected={safeSelected}
+				dimmed={onProvider}
+				currentModel={currentModel}
+				onSelect={resolve}
+				showCustomModelId={showCustomModelId}
+				onCreateCustomModel={() => {
+					setIsCreatingCustomModel(true);
+					setCustomModelId("");
+					setCustomModelError("");
+				}}
+			/>
+
+			<text fg="gray">
+				Type to search, ↑/↓ navigate, Enter to select, Tab to change provider,
+				Esc to close
+			</text>
+		</box>
+	);
+}
+
+// -- Thinking level dialog content --
+
+export type ThinkingLevel = "none" | "low" | "medium" | "high" | "xhigh";
+
+const THINKING_LEVELS: { value: ThinkingLevel; label: string; desc: string }[] =
+	[
+		{ value: "none", label: "Off", desc: "No extended thinking" },
+		{ value: "low", label: "Low", desc: "Minimal reasoning" },
+		{ value: "medium", label: "Medium", desc: "Balanced reasoning" },
+		{ value: "high", label: "High", desc: "Deep reasoning" },
+		{ value: "xhigh", label: "Extra High", desc: "Maximum reasoning" },
+	];
+
+export function ThinkingLevelContent(
+	props: ChoiceContext<ThinkingLevel> & {
+		modelName: string;
+		currentLevel: ThinkingLevel;
+	},
+) {
+	const { resolve, dismiss, dialogId, modelName, currentLevel } = props;
+	const [selected, setSelected] = useState(() => {
+		const initialLevel = currentLevel === "none" ? "medium" : currentLevel;
+		const idx = THINKING_LEVELS.findIndex((l) => l.value === initialLevel);
+		return idx >= 0 ? idx : 0;
+	});
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			const level = THINKING_LEVELS[selected];
+			if (level) resolve(level.value);
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setSelected((s) => (s <= 0 ? THINKING_LEVELS.length - 1 : s - 1));
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setSelected((s) => (s >= THINKING_LEVELS.length - 1 ? 0 : s + 1));
+			return;
+		}
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<text>Thinking Level for {modelName}</text>
+
+			<box flexDirection="column">
+				{THINKING_LEVELS.map((level, i) => (
+					<box
+						key={level.value}
+						paddingX={1}
+						flexDirection="row"
+						gap={1}
+						justifyContent="space-between"
+						backgroundColor={i === selected ? palette.selection : undefined}
+						onMouseDown={() => resolve(level.value)}
+					>
+						<box flexDirection="row" gap={1} flexShrink={0}>
+							<text
+								fg={i === selected ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{i === selected ? "\u276f" : " "}
+							</text>
+							<text fg={i === selected ? palette.textOnSelection : undefined}>
+								{level.label}
+							</text>
+						</box>
+						<box flexDirection="row" gap={1} flexShrink={1}>
+							<text fg={i === selected ? palette.textOnSelection : "gray"}>
+								{level.desc}
+							</text>
+							{level.value === currentLevel && (
+								<text
+									fg={
+										i === selected ? palette.textOnSelection : palette.success
+									}
+									flexShrink={0}
+								>
+									(current)
+								</text>
+							)}
+						</box>
+					</box>
+				))}
+			</box>
+
+			<text fg="gray">↑/↓ navigate, Enter to select, Esc to go back</text>
+		</box>
+	);
+}
+
+// -- Windowed list --
+
+function ModelList(props: {
+	items: ModelOption[];
+	selected: number;
+	dimmed?: boolean;
+	currentModel: string;
+	onSelect: (key: string) => void;
+	showCustomModelId: boolean;
+	onCreateCustomModel: () => void;
+}) {
+	const {
+		items,
+		selected,
+		dimmed,
+		currentModel,
+		onSelect,
+		showCustomModelId,
+		onCreateCustomModel,
+	} = props;
+	const rows: ({ type: "model"; model: ModelOption } | { type: "custom" })[] = [
+		...items.map((model) => ({ type: "model" as const, model })),
+		...(showCustomModelId ? ([{ type: "custom" as const }] as const) : []),
+	];
+
+	if (rows.length <= MAX_VISIBLE) {
+		return (
+			<box flexDirection="column">
+				{rows.map((row, i) =>
+					row.type === "model" ? (
+						<ModelRow
+							key={row.model.key}
+							model={row.model}
+							isSelected={i === selected}
+							dimmed={dimmed}
+							isCurrent={row.model.key === currentModel}
+							onSelect={onSelect}
+						/>
+					) : (
+						<CreateCustomModelRow
+							key="create-custom-model"
+							isSelected={i === selected}
+							dimmed={dimmed}
+							onSelect={onCreateCustomModel}
+						/>
+					),
+				)}
+			</box>
+		);
+	}
+
+	const halfWindow = Math.floor(MAX_VISIBLE / 2);
+	let start = Math.max(0, selected - halfWindow);
+	if (start + MAX_VISIBLE > rows.length) {
+		start = rows.length - MAX_VISIBLE;
+	}
+
+	const showAbove = start > 0;
+	const showBelow = start + MAX_VISIBLE < rows.length;
+
+	const itemSlots = MAX_VISIBLE - (showAbove ? 1 : 0) - (showBelow ? 1 : 0);
+	const itemStart = showAbove ? start + 1 : start;
+	const visible = rows.slice(itemStart, itemStart + itemSlots);
+
+	const aboveCount = itemStart;
+	const belowCount = rows.length - (itemStart + itemSlots);
+
+	return (
+		<box flexDirection="column">
+			{showAbove && (
+				<box paddingX={1} justifyContent="center">
+					<text fg="gray">
+						{"\u25b2"} {aboveCount} more
+					</text>
+				</box>
+			)}
+			{visible.map((row, i) =>
+				row.type === "model" ? (
+					<ModelRow
+						key={row.model.key}
+						model={row.model}
+						isSelected={itemStart + i === selected}
+						dimmed={dimmed}
+						isCurrent={row.model.key === currentModel}
+						onSelect={onSelect}
+					/>
+				) : (
+					<CreateCustomModelRow
+						key="create-custom-model"
+						isSelected={itemStart + i === selected}
+						dimmed={dimmed}
+						onSelect={onCreateCustomModel}
+					/>
+				),
+			)}
+			{showBelow && (
+				<box paddingX={1} justifyContent="center">
+					<text fg="gray">
+						{"\u25bc"} {belowCount} more
+					</text>
+				</box>
+			)}
+		</box>
+	);
+}
+
+function CreateCustomModelRow(props: {
+	isSelected: boolean;
+	dimmed?: boolean;
+	onSelect: () => void;
+}) {
+	const { isSelected, dimmed, onSelect } = props;
+	const active = isSelected && !dimmed;
+	const bg = active
+		? palette.selection
+		: isSelected && dimmed
+			? "gray"
+			: undefined;
+	return (
+		<box
+			paddingX={1}
+			flexDirection="row"
+			gap={1}
+			backgroundColor={bg}
+			onMouseDown={onSelect}
+			overflow="hidden"
+			height={1}
+		>
+			<text fg={isSelected ? palette.textOnSelection : "gray"} flexShrink={0}>
+				{isSelected ? "\u276f" : " "}
+			</text>
+			<text fg={isSelected ? palette.textOnSelection : undefined}>
+				Create custom model ID
+			</text>
+			<text fg={isSelected ? palette.textOnSelection : "gray"} flexShrink={0}>
+				manual entry
+			</text>
+		</box>
+	);
+}
+
+function ModelRow(props: {
+	model: ModelOption;
+	isSelected: boolean;
+	dimmed?: boolean;
+	isCurrent: boolean;
+	onSelect: (key: string) => void;
+}) {
+	const { model, isSelected, dimmed, isCurrent, onSelect } = props;
+	const active = isSelected && !dimmed;
+	const bg = active
+		? palette.selection
+		: isSelected && dimmed
+			? "gray"
+			: undefined;
+	return (
+		<box
+			paddingX={1}
+			flexDirection="row"
+			gap={1}
+			backgroundColor={bg}
+			onMouseDown={() => onSelect(model.key)}
+			overflow="hidden"
+			height={1}
+		>
+			<text fg={isSelected ? palette.textOnSelection : "gray"} flexShrink={0}>
+				{isSelected ? "\u276f" : " "}
+			</text>
+			<text fg={isSelected ? palette.textOnSelection : undefined}>
+				{model.name}
+			</text>
+			{model.maxInputTokens && (
+				<text fg={isSelected ? palette.textOnSelection : "gray"} flexShrink={0}>
+					{formatTokenCount(model.maxInputTokens)}
+				</text>
+			)}
+			{isCurrent && (
+				<text
+					fg={isSelected ? palette.textOnSelection : palette.success}
+					flexShrink={0}
+				>
+					(current)
+				</text>
+			)}
+		</box>
+	);
+}
+
+// -- Build model options from catalog --
+
+export function buildModelOptions(
+	knownModels?: Record<string, Llms.ModelInfo>,
+): ModelOption[] {
+	if (!knownModels) return [];
+	return Object.entries(knownModels)
+		.map(([key, info]) => ({
+			key,
+			name: info.name ?? key,
+			maxInputTokens: info.maxInputTokens ?? info.contextWindow,
+			family: info.family,
+			supportsReasoning: info.capabilities?.includes("reasoning") ?? false,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
diff --git a/apps/cli/src/tui/components/model-selector/provider-row.tsx b/apps/cli/src/tui/components/model-selector/provider-row.tsx
new file mode 100644
index 0000000..8a5b035
--- /dev/null
+++ b/apps/cli/src/tui/components/model-selector/provider-row.tsx
@@ -0,0 +1,32 @@
+// @jsxImportSource @opentui/react
+import { palette } from "../../palette";
+
+export function ProviderRow({
+	providerName,
+	focused,
+}: {
+	providerName: string;
+	focused: boolean;
+}) {
+	return (
+		<box flexDirection="row" paddingX={1} gap={1}>
+			<text fg={focused ? palette.selection : "gray"} flexShrink={0}>
+				{focused ? "❯" : " "}
+			</text>
+			<text fg={focused ? palette.selection : palette.act} flexShrink={0}>
+				Provider:
+			</text>
+			<text fg="white">{providerName}</text>
+			{!focused && (
+				<text fg="gray" flexShrink={0}>
+					(tab to change provider)
+				</text>
+			)}
+			{focused && (
+				<text fg="gray" flexShrink={0}>
+					<em>Enter to change</em>
+				</text>
+			)}
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/queued-prompts.tsx b/apps/cli/src/tui/components/queued-prompts.tsx
new file mode 100644
index 0000000..aba7331
--- /dev/null
+++ b/apps/cli/src/tui/components/queued-prompts.tsx
@@ -0,0 +1,129 @@
+import "opentui-spinner/react";
+import { useEffect, useState } from "react";
+import { useSession } from "../contexts/session-context";
+import { palette } from "../palette";
+import type { QueuedPromptItem } from "../types";
+
+function truncatePrompt(prompt: string): string {
+	return prompt.length > 64 ? `${prompt.slice(0, 64)}...` : prompt;
+}
+
+function attachmentLabel(count: number): string {
+	if (count <= 0) return "";
+	return count === 1 ? " 1 attachment" : ` ${count} attachments`;
+}
+
+export function QueuedPrompts(props: {
+	items: QueuedPromptItem[];
+	selectedId: string | null;
+	editingId: string | null;
+	onEditConfirm: (id: string, prompt: string) => void;
+}) {
+	const session = useSession();
+	if (props.items.length === 0) return null;
+
+	const selected = props.selectedId
+		? props.items.find((item) => item.id === props.selectedId)
+		: undefined;
+	const selectedIsEditing = selected?.id === props.editingId;
+	const escapeHint = session.isRunning ? "Esc cancels turn" : "Esc back";
+	const hint = selected
+		? selectedIsEditing
+			? "Enter confirm, Esc cancel"
+			: selected.steer
+				? session.isRunning
+					? "Waiting. ↑/↓ navigate, Tab edit, Esc cancels turn"
+					: `Steered next. ↑/↓ navigate, Tab edit, ${escapeHint}`
+				: `↑/↓ navigate, Enter steer, Tab edit, ${escapeHint}`
+		: "↑ steer or edit messages";
+
+	return (
+		<box
+			flexDirection="column"
+			border
+			borderStyle="rounded"
+			borderColor={selected ? palette.selection : "gray"}
+			paddingX={1}
+		>
+			<text fg="gray">
+				<em>Queued messages:</em>
+			</text>
+			{props.items.map((item) => {
+				const isSelected = item.id === props.selectedId;
+				const isEditing = item.id === props.editingId;
+				return (
+					<QueuedPromptRow
+						key={item.id}
+						item={item}
+						selected={isSelected}
+						editing={isEditing}
+						onEditConfirm={(prompt) => props.onEditConfirm(item.id, prompt)}
+					/>
+				);
+			})}
+			<text fg="gray">
+				<em>{hint}</em>
+			</text>
+		</box>
+	);
+}
+
+function QueuedPromptRow(props: {
+	item: QueuedPromptItem;
+	selected: boolean;
+	editing: boolean;
+	onEditConfirm: (prompt: string) => void;
+}) {
+	const { item, selected, editing } = props;
+	const [editValue, setEditValue] = useState(item.prompt);
+
+	useEffect(() => {
+		if (editing) {
+			setEditValue(item.prompt);
+		}
+	}, [editing, item.prompt]);
+
+	return (
+		<box
+			paddingX={1}
+			flexDirection="row"
+			gap={1}
+			backgroundColor={selected ? palette.selection : undefined}
+		>
+			{item.steer && !editing ? (
+				<spinner
+					name="dots"
+					color={selected ? palette.textOnSelection : "gray"}
+				/>
+			) : (
+				<text fg={selected ? palette.textOnSelection : "gray"} flexShrink={0}>
+					{selected ? "❯" : " "}
+				</text>
+			)}
+			{editing ? (
+				<input
+					value={editValue}
+					onInput={setEditValue}
+					onSubmit={() => props.onEditConfirm(editValue)}
+					placeholder="Edit message..."
+					backgroundColor={palette.selection}
+					focusedBackgroundColor={palette.selection}
+					textColor={palette.textOnSelection}
+					cursorColor={palette.textOnSelection}
+					placeholderColor={palette.textOnSelection}
+					focused
+					flexGrow={1}
+				/>
+			) : (
+				<text fg={selected ? palette.textOnSelection : undefined} flexGrow={1}>
+					{truncatePrompt(item.prompt)}
+				</text>
+			)}
+			{!editing && item.attachmentCount > 0 && (
+				<text fg={selected ? palette.textOnSelection : "gray"} flexShrink={0}>
+					{attachmentLabel(item.attachmentCount)}
+				</text>
+			)}
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/robot-animation.tsx b/apps/cli/src/tui/components/robot-animation.tsx
new file mode 100644
index 0000000..faba2a3
--- /dev/null
+++ b/apps/cli/src/tui/components/robot-animation.tsx
@@ -0,0 +1,161 @@
+import { useTerminalDimensions } from "@opentui/react";
+import { useEffect, useState } from "react";
+import { type CroppedFrame, FRAMES } from "./robot-frames";
+
+const FRAME_STRAIGHT = 0;
+const FRAME_BOTTOM_LEFT = 64;
+const FRAME_BOTTOM_CENTER = 96;
+const FRAME_BOTTOM_RIGHT = 128;
+
+const ROBOT_HEIGHT = 12;
+
+function buildTheme(defaultColor: string): Record<string, string> {
+	return {
+		black: defaultColor,
+		whiteBright: defaultColor,
+		gray: defaultColor,
+	};
+}
+
+function getColor(key: string, theme: Record<string, string>): string {
+	return theme[key] || key;
+}
+
+interface ColorSegment {
+	text: string;
+	fg: string;
+}
+
+function buildRowSegments(
+	row: string,
+	rowIdx: number,
+	colors: Record<string, string>,
+	defaultColor: string,
+	theme: Record<string, string>,
+): ColorSegment[] {
+	const segments: ColorSegment[] = [];
+	let currentFg = defaultColor;
+	let currentText = "";
+
+	for (let col = 0; col < row.length; col++) {
+		const key = `${col},${rowIdx}`;
+		const fg = colors[key] ? getColor(colors[key], theme) : defaultColor;
+		if (fg !== currentFg) {
+			if (currentText) segments.push({ text: currentText, fg: currentFg });
+			currentFg = fg;
+			currentText = row[col];
+		} else {
+			currentText += row[col];
+		}
+	}
+	if (currentText) segments.push({ text: currentText, fg: currentFg });
+	return segments;
+}
+
+function RobotFrame(props: { frame: CroppedFrame; defaultColor: string }) {
+	const { frame, defaultColor } = props;
+	const theme = buildTheme(defaultColor);
+	return (
+		<box flexDirection="column">
+			{frame.rows.map((row, rowIdx) => {
+				const segments = buildRowSegments(
+					row,
+					rowIdx,
+					frame.colors,
+					defaultColor,
+					theme,
+				);
+				return (
+					// biome-ignore lint/suspicious/noArrayIndexKey: static animation frame with fixed row order
+					<text key={`row-${rowIdx}`}>
+						{segments.map((seg, j) => (
+							// biome-ignore lint/suspicious/noArrayIndexKey: static animation frame with fixed row order
+							<span key={`seg-${rowIdx}-${j}`} fg={seg.fg}>
+								{seg.text}
+							</span>
+						))}
+					</text>
+				);
+			})}
+		</box>
+	);
+}
+
+export function RobotAnimation(props: {
+	cursorX: number;
+	cursorY: number;
+	defaultColor?: string;
+}) {
+	const [frameIndex, setFrameIndex] = useState(FRAME_STRAIGHT);
+	const [targetFrame, setTargetFrame] = useState(FRAME_STRAIGHT);
+	const { width, height } = useTerminalDimensions();
+
+	const faceX = Math.floor(width / 2);
+	const trackStartY = Math.floor(height / 2) - Math.floor(ROBOT_HEIGHT / 2);
+
+	useEffect(() => {
+		const dx = props.cursorX - faceX;
+		const dy = props.cursorY - trackStartY;
+
+		if (dy < 0) {
+			setTargetFrame(FRAME_STRAIGHT);
+			return;
+		}
+
+		const maxTrackY = height - trackStartY;
+		if (dy > maxTrackY) {
+			setTargetFrame(FRAME_STRAIGHT);
+			return;
+		}
+
+		const maxOffset = 40;
+		const clampedDx = Math.max(-maxOffset, Math.min(maxOffset, dx));
+		const normalized = clampedDx / maxOffset;
+
+		let target: number;
+		if (normalized <= 0) {
+			target = Math.round(
+				FRAME_BOTTOM_LEFT +
+					(1 + normalized) * (FRAME_BOTTOM_CENTER - FRAME_BOTTOM_LEFT),
+			);
+		} else {
+			target = Math.round(
+				FRAME_BOTTOM_CENTER +
+					normalized * (FRAME_BOTTOM_RIGHT - FRAME_BOTTOM_CENTER),
+			);
+		}
+
+		setTargetFrame(target);
+	}, [props.cursorX, props.cursorY, faceX, trackStartY, height]);
+
+	useEffect(() => {
+		const interval = setInterval(() => {
+			setFrameIndex((current) => {
+				if (current === targetFrame) return current;
+				const diff = targetFrame - current;
+				const step =
+					Math.sign(diff) * Math.max(Math.abs(Math.round(diff * 0.5)), 1);
+				const next = current + step;
+				if (
+					(diff > 0 && next > targetFrame) ||
+					(diff < 0 && next < targetFrame)
+				) {
+					return targetFrame;
+				}
+				return next;
+			});
+		}, 12);
+
+		return () => clearInterval(interval);
+	}, [targetFrame]);
+
+	const safeIndex = Math.max(0, Math.min(frameIndex, FRAMES.length - 1));
+	const frame = FRAMES[safeIndex];
+	if (!frame) return null;
+
+	return (
+		<box flexDirection="column" alignItems="center" width="100%">
+			<RobotFrame frame={frame} defaultColor={props.defaultColor ?? "white"} />
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/robot-frames.generated.json b/apps/cli/src/tui/components/robot-frames.generated.json
new file mode 100644
index 0000000..4cf2857
--- /dev/null
+++ b/apps/cli/src/tui/components/robot-frames.generated.json
@@ -0,0 +1,4258 @@
+{
+	"schema": 1,
+	"width": 34,
+	"height": 12,
+	"palette": ["black", "whiteBright", "gray"],
+	"frames": [
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@.   @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6,
+				1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4,
+				0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   .@@@@.   @@@@@      ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   .@@@@.   @@@@@      ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"    @@@@@@     *@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   *@@@@.   @@@@@      ",
+				"    @@@@@@     @@@+     @@@@@@    ",
+				"    @@@@@@     @@@+     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        ;@@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 3, 0, 1, 2, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 3, 1, 1, 2, 5,
+				0, 6, 1, 8, 0, 6, 1, 5, 0, 3, 1, 1, 2, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4,
+				1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 1, 2, 16, 1, 1, 2, 8,
+				0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"     .@@@@@@@@@@@@@@@@@@@@@@      ",
+				"     .@@@@@   @@@@@   @@@@@@      ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"      @@@@     @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      .@@@@@@@@@@@@@@@@@@@@       ",
+				"        @@@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 3, 0, 5, 1, 3, 0, 6, 1, 10, 0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 8,
+				0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 10, 0, 4, 1, 5, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 17, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"     .@@@@@@@@@@@@@@@@@@@@@@      ",
+				"     .@@@@@   @@@@@   @@@@@@      ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"      @@@@     @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      .@@@@@@@@@@@@@@@@@@@@       ",
+				"        @@@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 3, 0, 5, 1, 3, 0, 6, 1, 10, 0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 8,
+				0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 10, 0, 4, 1, 5, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 17, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @#                ",
+				"              @@@@@#              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"     #@@@@@@@@@@@@@@@@@@@@@@      ",
+				"     @@@@@@  #@@@@@  .@@@@@@      ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"    @@@@@@     @@@     @@@@@@#    ",
+				"     ;@@@@    #@@@     @@@@@      ",
+				"     :@@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@       ",
+				"        @@@@@@@@@@@@@@@@@:        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 12, 0, 23, 1, 11,
+				0, 6, 1, 2, 0, 6, 1, 3, 0, 6, 1, 10, 0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 8,
+				0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 9, 0, 1, 2, 4, 1, 4, 0, 4, 1, 5, 0, 5,
+				1, 11, 0, 1, 2, 22, 1, 12, 0, 21, 1, 15, 0, 17, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"               +@*                ",
+				"              @@@@@               ",
+				"         @@@@@@@@@@@@@@@#         ",
+				"      .@@@@@@@@@@@@@@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@+      ",
+				"     @@@@@@*@@@@@@@.+@@@@@@+      ",
+				"    @@@@@     @@@     @@@@@@@+    ",
+				"    @@@@@     @@@     @@@@@@@;    ",
+				"     @@@@.    @@@*    @@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@#       ",
+				"       @@@@@@@@@@@@@@@@@@         "
+			],
+			[
+				15, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 24, 0, 16, 1, 16, 0, 20, 1, 12, 0,
+				22, 1, 1, 2, 11, 0, 6, 1, 1, 2, 7, 1, 2, 2, 6, 1, 1, 2, 10, 0, 5, 1, 5,
+				0, 3, 1, 5, 0, 7, 1, 1, 2, 8, 0, 5, 1, 5, 0, 3, 1, 5, 0, 7, 1, 1, 2, 9,
+				0, 4, 1, 5, 0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 21, 1, 14, 0, 18,
+				1, 9, 0
+			]
+		],
+		[
+			[
+				"               +@*                ",
+				"              @@@@@               ",
+				"         @@@@@@@@@@@@@@@#         ",
+				"      .@@@@@@@@@@@@@@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@+      ",
+				"     @@@@@@*@@@@@@@.+@@@@@@+      ",
+				"    @@@@@     @@@     @@@@@@@+    ",
+				"    @@@@@     @@@     @@@@@@@;    ",
+				"     @@@@.    @@@*    @@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@#       ",
+				"       @@@@@@@@@@@@@@@@@@         "
+			],
+			[
+				15, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 24, 0, 16, 1, 16, 0, 20, 1, 12, 0,
+				22, 1, 1, 2, 11, 0, 6, 1, 1, 2, 7, 1, 2, 2, 6, 1, 1, 2, 10, 0, 5, 1, 5,
+				0, 3, 1, 5, 0, 7, 1, 1, 2, 8, 0, 5, 1, 5, 0, 3, 1, 5, 0, 7, 1, 1, 2, 9,
+				0, 4, 1, 5, 0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 21, 1, 14, 0, 18,
+				1, 9, 0
+			]
+		],
+		[
+			[
+				"               #@;                ",
+				"             .@@@@@               ",
+				"         @@@@@@@@@@@@@@@#         ",
+				"      +@@@@@@@@@@@@@@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@*      ",
+				"     @@@@@@@@@@@@@@#@@@@@@@*      ",
+				"    @@@@@     @@@     @@@@@@@     ",
+				"    @@@@@     @@@     @@@@@@@     ",
+				"     @@@@     @@@     @@@@@;      ",
+				"     @@@@@@*@@@@@@@#@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"       @@@@@@@@@@@@@@@@@@         "
+			],
+			[
+				15, 0, 2, 1, 1, 2, 30, 0, 5, 1, 24, 0, 16, 1, 15, 0, 1, 2, 20, 1, 12, 0,
+				22, 1, 1, 2, 11, 0, 22, 1, 1, 2, 10, 0, 5, 1, 5, 0, 3, 1, 5, 0, 7, 1, 9,
+				0, 5, 1, 5, 0, 3, 1, 5, 0, 7, 1, 10, 0, 4, 1, 5, 0, 3, 1, 5, 0, 5, 1, 1,
+				2, 11, 0, 22, 1, 13, 0, 20, 1, 15, 0, 18, 1, 9, 0
+			]
+		],
+		[
+			[
+				"               @@                 ",
+				"             @@@@@@               ",
+				"         @@@@@@@@@@@@@@@+         ",
+				"      @@@@@@@@@@@@@@@@@@@@.       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    *@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"     @@@:    @@@     @@@@@#*      ",
+				"     @@@@#  @@@@@@ .@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@@        ",
+				"      @@@@@@@@@@@@@@@@@@#         "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 24, 0, 15, 1, 1, 2, 15, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 1, 2, 23, 1, 10, 0, 4, 1, 5, 0, 3, 1, 5, 0, 8, 1, 9, 0, 4, 1,
+				5, 0, 3, 1, 5, 0, 8, 1, 10, 0, 3, 1, 1, 2, 4, 0, 3, 1, 5, 0, 6, 1, 1, 2,
+				11, 0, 5, 1, 2, 0, 6, 1, 2, 0, 7, 1, 12, 0, 21, 1, 14, 0, 19, 1, 9, 0
+			]
+		],
+		[
+			[
+				"               @@                 ",
+				"             @@@@@@               ",
+				"         @@@@@@@@@@@@@@@+         ",
+				"      @@@@@@@@@@@@@@@@@@@@.       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    *@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"     @@@:    @@@     @@@@@#*      ",
+				"     @@@@#  @@@@@@ .@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@@        ",
+				"      @@@@@@@@@@@@@@@@@@#         "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 24, 0, 15, 1, 1, 2, 15, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 1, 2, 23, 1, 10, 0, 4, 1, 5, 0, 3, 1, 5, 0, 8, 1, 9, 0, 4, 1,
+				5, 0, 3, 1, 5, 0, 8, 1, 10, 0, 3, 1, 1, 2, 4, 0, 3, 1, 5, 0, 6, 1, 1, 2,
+				11, 0, 5, 1, 2, 0, 6, 1, 2, 0, 7, 1, 12, 0, 21, 1, 14, 0, 19, 1, 9, 0
+			]
+		],
+		[
+			[
+				"               @@                 ",
+				"             @@@@@@               ",
+				"         @@@@@@@@@@@@@@@:         ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    *@@@@@@@@@@@@@@@@@@@@@##      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@##      ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"    .@@@     @@@     @@@@@#+      ",
+				"     @@@@.  @@@@@. .@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@@        ",
+				"      @@@@@@@@@@@@@@@@@@;         "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 24, 0, 15, 1, 1, 2, 15, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 10, 0, 4, 1, 5, 0, 3, 1, 5, 0, 8, 1, 9, 0, 4, 1, 5, 0,
+				3, 1, 5, 0, 8, 1, 10, 0, 3, 1, 5, 0, 3, 1, 5, 0, 6, 1, 1, 2, 11, 0, 4,
+				1, 3, 0, 5, 1, 3, 0, 7, 1, 12, 0, 21, 1, 14, 0, 18, 1, 1, 2, 9, 0
+			]
+		],
+		[
+			[
+				"               @:                 ",
+				"             @@@@@                ",
+				"         #@#@@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@+      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    @@@     @@@     @@@@@@@@@     ",
+				"    @@@.    @@@     @@@@@@@@@     ",
+				"    @@@#    @@@     @@@@@@@       ",
+				"    @@@@+  #@@@@   @@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@*        ",
+				"      @@@@@@@@@@@@@@@@@@          "
+			],
+			[
+				15, 0, 1, 1, 1, 2, 30, 0, 5, 1, 25, 0, 15, 1, 16, 0, 20, 1, 12, 0, 23,
+				1, 1, 2, 10, 0, 24, 1, 10, 0, 3, 1, 5, 0, 3, 1, 5, 0, 9, 1, 9, 0, 3, 1,
+				5, 0, 3, 1, 5, 0, 9, 1, 9, 0, 4, 1, 4, 0, 3, 1, 5, 0, 7, 1, 11, 0, 4, 1,
+				1, 2, 2, 0, 5, 1, 3, 0, 8, 1, 12, 0, 21, 1, 14, 0, 18, 1, 10, 0
+			]
+		],
+		[
+			[
+				"               @:                 ",
+				"             @@@@@                ",
+				"         #@#@@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@+      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    @@@     @@@     @@@@@@@@@     ",
+				"    @@@.    @@@     @@@@@@@@@     ",
+				"    @@@#    @@@     @@@@@@@       ",
+				"    @@@@+  #@@@@   @@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@*        ",
+				"      @@@@@@@@@@@@@@@@@@          "
+			],
+			[
+				15, 0, 1, 1, 1, 2, 30, 0, 5, 1, 25, 0, 15, 1, 16, 0, 20, 1, 12, 0, 23,
+				1, 1, 2, 10, 0, 24, 1, 10, 0, 3, 1, 5, 0, 3, 1, 5, 0, 9, 1, 9, 0, 3, 1,
+				5, 0, 3, 1, 5, 0, 9, 1, 9, 0, 4, 1, 4, 0, 3, 1, 5, 0, 7, 1, 11, 0, 4, 1,
+				1, 2, 2, 0, 5, 1, 3, 0, 8, 1, 12, 0, 21, 1, 14, 0, 18, 1, 10, 0
+			]
+		],
+		[
+			[
+				"              :@                  ",
+				"             @@@@@                ",
+				"         ####@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@:      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    @@@    +@@#    +@@@@@@@@@     ",
+				"    @@@     @@#    .@@@@@@@@#     ",
+				"    @@@     @@@     @@@@@@@       ",
+				"    @@@@   @@@@#   @@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@*        ",
+				"     #@@@@@@@@@@@@@@@@@@          "
+			],
+			[
+				14, 0, 1, 2, 1, 1, 31, 0, 5, 1, 25, 0, 15, 1, 16, 0, 20, 1, 12, 0, 23,
+				1, 1, 2, 10, 0, 24, 1, 10, 0, 3, 1, 4, 0, 1, 2, 3, 1, 4, 0, 1, 2, 9, 1,
+				9, 0, 3, 1, 5, 0, 3, 1, 5, 0, 9, 1, 9, 0, 3, 1, 5, 0, 3, 1, 5, 0, 7, 1,
+				11, 0, 4, 1, 3, 0, 5, 1, 3, 0, 8, 1, 12, 0, 21, 1, 13, 0, 19, 1, 10, 0
+			]
+		],
+		[
+			[
+				"              +*                  ",
+				"            @@@@@@                ",
+				"         ####@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   ;@@@@@@@@@@@@@@@@@@@@@@@+      ",
+				"    @@#    @@@     @@@@@@@@@      ",
+				"    @@#    @@@     @@@@@@@@@      ",
+				"    @@@    @@@     @@@@@@@@       ",
+				"    @@@+   @@@@   #@@@@@@@@       ",
+				"    *@@@@@@@@@@@@@@@@@@@#.        ",
+				"     @@@@@@@@@@@@@@@@@@+          "
+			],
+			[
+				14, 0, 2, 2, 30, 0, 6, 1, 25, 0, 15, 1, 16, 0, 20, 1, 12, 0, 23, 1, 10,
+				0, 1, 2, 23, 1, 1, 2, 10, 0, 3, 1, 4, 0, 3, 1, 5, 0, 9, 1, 10, 0, 3, 1,
+				4, 0, 3, 1, 5, 0, 9, 1, 10, 0, 3, 1, 4, 0, 3, 1, 5, 0, 8, 1, 11, 0, 3,
+				1, 1, 2, 3, 0, 4, 1, 3, 0, 9, 1, 11, 0, 21, 1, 14, 0, 18, 1, 1, 2, 10, 0
+			]
+		],
+		[
+			[
+				"              +*                  ",
+				"            @@@@@@                ",
+				"         ####@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   ;@@@@@@@@@@@@@@@@@@@@@@@+      ",
+				"    @@#    @@@     @@@@@@@@@      ",
+				"    @@#    @@@     @@@@@@@@@      ",
+				"    @@@    @@@     @@@@@@@@       ",
+				"    @@@+   @@@@   #@@@@@@@@       ",
+				"    *@@@@@@@@@@@@@@@@@@@#.        ",
+				"     @@@@@@@@@@@@@@@@@@+          "
+			],
+			[
+				14, 0, 2, 2, 30, 0, 6, 1, 25, 0, 15, 1, 16, 0, 20, 1, 12, 0, 23, 1, 10,
+				0, 1, 2, 23, 1, 1, 2, 10, 0, 3, 1, 4, 0, 3, 1, 5, 0, 9, 1, 10, 0, 3, 1,
+				4, 0, 3, 1, 5, 0, 9, 1, 10, 0, 3, 1, 4, 0, 3, 1, 5, 0, 8, 1, 11, 0, 3,
+				1, 1, 2, 3, 0, 4, 1, 3, 0, 9, 1, 11, 0, 21, 1, 14, 0, 18, 1, 1, 2, 10, 0
+			]
+		],
+		[
+			[
+				"              +:                  ",
+				"            @@@@@#                ",
+				"         ###@@@@@@@@@@@#          ",
+				"      @@@@@@@@@@@@@@@@@@@#        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@.      ",
+				"   ;@@    @@@+    @@@@@@@@@@      ",
+				"    @@.   .@@*    @@@@@@@@@@      ",
+				"    @@#    @@@    @@@@@@@@@       ",
+				"    @@@   ;@@@    @@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@#         ",
+				"     @@@@@@@@@@@@@@@@@@;          "
+			],
+			[
+				14, 0, 2, 2, 30, 0, 6, 1, 25, 0, 15, 1, 16, 0, 20, 1, 12, 0, 23, 1, 10,
+				0, 24, 1, 10, 0, 1, 2, 2, 1, 4, 0, 3, 1, 1, 2, 4, 0, 10, 1, 10, 0, 2, 1,
+				5, 0, 3, 1, 4, 0, 10, 1, 10, 0, 3, 1, 4, 0, 3, 1, 4, 0, 9, 1, 11, 0, 3,
+				1, 3, 0, 1, 2, 3, 1, 4, 0, 9, 1, 11, 0, 21, 1, 14, 0, 18, 1, 1, 2, 10, 0
+			]
+		],
+		[
+			[
+				"              :                   ",
+				"            @@@@@                 ",
+				"         *##@@@@@@@@@@@.          ",
+				"     :@@@@@@@@@@@@@@@@@@@.        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@    @@@    @@@@@@@@@@@      ",
+				"   #@@    @@@    @@@@@@@@@@@      ",
+				"    @@    @@@     @@@@@@@@@       ",
+				"    @@@   @@@#   @@@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@#         ",
+				"     @@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				14, 0, 1, 2, 31, 0, 5, 1, 26, 0, 14, 1, 16, 0, 1, 2, 19, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 10, 0, 3, 1, 4, 0, 3, 1, 4, 0, 11, 1, 9, 0, 3, 1, 4, 0,
+				3, 1, 4, 0, 11, 1, 10, 0, 2, 1, 4, 0, 3, 1, 5, 0, 9, 1, 11, 0, 3, 1, 3,
+				0, 4, 1, 3, 0, 10, 1, 11, 0, 21, 1, 14, 0, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"              :                   ",
+				"            @@@@@                 ",
+				"         *##@@@@@@@@@@@.          ",
+				"     :@@@@@@@@@@@@@@@@@@@.        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@    @@@    @@@@@@@@@@@      ",
+				"   #@@    @@@    @@@@@@@@@@@      ",
+				"    @@    @@@     @@@@@@@@@       ",
+				"    @@@   @@@#   @@@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@#         ",
+				"     @@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				14, 0, 1, 2, 31, 0, 5, 1, 26, 0, 14, 1, 16, 0, 1, 2, 19, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 10, 0, 3, 1, 4, 0, 3, 1, 4, 0, 11, 1, 9, 0, 3, 1, 4, 0,
+				3, 1, 4, 0, 11, 1, 10, 0, 2, 1, 4, 0, 3, 1, 5, 0, 9, 1, 11, 0, 3, 1, 3,
+				0, 4, 1, 3, 0, 10, 1, 11, 0, 21, 1, 14, 0, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"           ;@@@@@                 ",
+				"         *#*@@@@@@@@@@@           ",
+				"     ;@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@#   @@@+    @@@@@@@@@@:      ",
+				"   #@@    @@+    @@@@@@@@@@+      ",
+				"    @@    @@#    @@@@@@@@@@       ",
+				"    @@*   @@@    @@@@@@@@@.       ",
+				"    @@@@@@@@@@@@@@@@@@@@@         ",
+				"     @@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				45, 0, 1, 2, 5, 1, 26, 0, 1, 2, 13, 1, 16, 0, 1, 2, 19, 1, 12, 0, 24, 1,
+				10, 0, 24, 1, 10, 0, 3, 1, 3, 0, 3, 1, 1, 2, 4, 0, 10, 1, 1, 2, 9, 0, 3,
+				1, 4, 0, 2, 1, 1, 2, 4, 0, 10, 1, 1, 2, 10, 0, 2, 1, 4, 0, 3, 1, 4, 0,
+				10, 1, 11, 0, 3, 1, 3, 0, 3, 1, 4, 0, 9, 1, 12, 0, 21, 1, 14, 0, 18, 1,
+				11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"           @@@@@*                 ",
+				"         ;#@@@@@@@@@@@@           ",
+				"     +@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@:   @@@    @@@@@@@@@@@       ",
+				"   @@:   @@@    @@@@@@@@@@@       ",
+				"   :@@   @@@    @@@@@@@@@@#       ",
+				"    @@   @@@*   @@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@         ",
+				"     @@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				45, 0, 5, 1, 1, 2, 26, 0, 1, 2, 13, 1, 16, 0, 1, 2, 19, 1, 12, 0, 24, 1,
+				10, 0, 24, 1, 10, 0, 2, 1, 1, 2, 3, 0, 3, 1, 4, 0, 11, 1, 10, 0, 2, 1,
+				1, 2, 3, 0, 3, 1, 4, 0, 11, 1, 10, 0, 1, 2, 2, 1, 3, 0, 3, 1, 4, 0, 11,
+				1, 11, 0, 2, 1, 3, 0, 4, 1, 3, 0, 10, 1, 12, 0, 21, 1, 14, 0, 18, 1, 11,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"           @@@@@*                 ",
+				"         ;#@@@@@@@@@@@@           ",
+				"     +@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@:   @@@    @@@@@@@@@@@       ",
+				"   @@:   @@@    @@@@@@@@@@@       ",
+				"   :@@   @@@    @@@@@@@@@@#       ",
+				"    @@   @@@*   @@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@         ",
+				"     @@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				45, 0, 5, 1, 1, 2, 26, 0, 1, 2, 13, 1, 16, 0, 1, 2, 19, 1, 12, 0, 24, 1,
+				10, 0, 24, 1, 10, 0, 2, 1, 1, 2, 3, 0, 3, 1, 4, 0, 11, 1, 10, 0, 2, 1,
+				1, 2, 3, 0, 3, 1, 4, 0, 11, 1, 10, 0, 1, 2, 2, 1, 3, 0, 3, 1, 4, 0, 11,
+				1, 11, 0, 2, 1, 3, 0, 4, 1, 3, 0, 10, 1, 12, 0, 21, 1, 14, 0, 18, 1, 11,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"           @@@@@                  ",
+				"         ;#@@@@@@@@@@@@           ",
+				"     *@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@*       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@   @@@#   @@@@@@@@@@@@       ",
+				"   @@    @@*    @@@@@@@@@@@       ",
+				"   *@#   @@@    @@@@@@@@@@        ",
+				"    @@   @@@    @@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@#         ",
+				"    .@@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				45, 0, 5, 1, 27, 0, 1, 2, 13, 1, 16, 0, 1, 2, 19, 1, 12, 0, 23, 1, 1, 2,
+				10, 0, 24, 1, 10, 0, 2, 1, 3, 0, 4, 1, 3, 0, 12, 1, 10, 0, 2, 1, 4, 0,
+				3, 1, 4, 0, 11, 1, 10, 0, 1, 2, 2, 1, 3, 0, 3, 1, 4, 0, 10, 1, 12, 0, 2,
+				1, 3, 0, 3, 1, 4, 0, 10, 1, 12, 0, 21, 1, 14, 0, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"           @@@@@                  ",
+				"         .*@@@@@@@@@@@+           ",
+				"     *@@@@@@@@@@@@@@@@@@#         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  ;@@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@   @@@   #@@@@@@@@@@@@       ",
+				"   @@   @@@    @@@@@@@@@@@@       ",
+				"   #@:   @@    @@@@@@@@@@@        ",
+				"    @@   @@#   @@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				45, 0, 5, 1, 28, 0, 12, 1, 1, 2, 16, 0, 20, 1, 12, 0, 23, 1, 10, 0, 1,
+				2, 24, 1, 10, 0, 2, 1, 3, 0, 3, 1, 3, 0, 13, 1, 10, 0, 2, 1, 3, 0, 3, 1,
+				4, 0, 12, 1, 10, 0, 2, 1, 1, 2, 3, 0, 2, 1, 4, 0, 11, 1, 12, 0, 2, 1, 3,
+				0, 3, 1, 3, 0, 11, 1, 12, 0, 20, 1, 14, 0, 1, 2, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"           @@@@@                  ",
+				"         .*@@@@@@@@@@@+           ",
+				"     *@@@@@@@@@@@@@@@@@@#         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  ;@@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@   @@@   #@@@@@@@@@@@@       ",
+				"   @@   @@@    @@@@@@@@@@@@       ",
+				"   #@:   @@    @@@@@@@@@@@        ",
+				"    @@   @@#   @@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				45, 0, 5, 1, 28, 0, 12, 1, 1, 2, 16, 0, 20, 1, 12, 0, 23, 1, 10, 0, 1,
+				2, 24, 1, 10, 0, 2, 1, 3, 0, 3, 1, 3, 0, 13, 1, 10, 0, 2, 1, 3, 0, 3, 1,
+				4, 0, 12, 1, 10, 0, 2, 1, 1, 2, 3, 0, 2, 1, 4, 0, 11, 1, 12, 0, 2, 1, 3,
+				0, 3, 1, 3, 0, 11, 1, 12, 0, 20, 1, 14, 0, 1, 2, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          :@@@@@                  ",
+				"         .#@@@@@@@@@@@.           ",
+				"     *@@@@@@@@@@@@@@@@@@;         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  #@@@@@@@@@@@@@@@@@@@@@@@+       ",
+				"   @#  @@@#   @@@@@@@@@@@@@       ",
+				"   @@   @@#    @@@@@@@@@@@@       ",
+				"   #@.  @@@    @@@@@@@@@@@        ",
+				"    @#  :@@    @@@@@@@@@@#        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@@@#           "
+			],
+			[
+				44, 0, 1, 2, 5, 1, 28, 0, 12, 1, 17, 0, 19, 1, 1, 2, 12, 0, 23, 1, 10,
+				0, 24, 1, 1, 2, 10, 0, 2, 1, 2, 0, 4, 1, 3, 0, 13, 1, 10, 0, 2, 1, 3, 0,
+				3, 1, 4, 0, 12, 1, 10, 0, 2, 1, 3, 0, 3, 1, 4, 0, 11, 1, 12, 0, 2, 1, 2,
+				0, 1, 2, 2, 1, 4, 0, 11, 1, 12, 0, 20, 1, 14, 0, 1, 2, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@@            ",
+				"     *@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @#  @@@   @@@@@@@@@@@@@@       ",
+				"   @#  ;@@    @@@@@@@@@@@@@       ",
+				"   @@.  @@#   @@@@@@@@@@@@        ",
+				"   .@;  @@#   #@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@@@;           "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 23, 1, 10, 0, 24,
+				1, 11, 0, 2, 1, 2, 0, 3, 1, 3, 0, 14, 1, 10, 0, 2, 1, 2, 0, 1, 2, 2, 1,
+				4, 0, 13, 1, 10, 0, 2, 1, 3, 0, 3, 1, 3, 0, 12, 1, 12, 0, 1, 1, 1, 2, 2,
+				0, 3, 1, 3, 0, 11, 1, 13, 0, 20, 1, 14, 0, 1, 2, 17, 1, 1, 2, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@@            ",
+				"     *@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @#  @@@   @@@@@@@@@@@@@@       ",
+				"   @#  ;@@    @@@@@@@@@@@@@       ",
+				"   @@.  @@#   @@@@@@@@@@@@        ",
+				"   .@;  @@#   #@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@@@;           "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 23, 1, 10, 0, 24,
+				1, 11, 0, 2, 1, 2, 0, 3, 1, 3, 0, 14, 1, 10, 0, 2, 1, 2, 0, 1, 2, 2, 1,
+				4, 0, 13, 1, 10, 0, 2, 1, 3, 0, 3, 1, 3, 0, 12, 1, 12, 0, 1, 1, 1, 2, 2,
+				0, 3, 1, 3, 0, 11, 1, 13, 0, 20, 1, 14, 0, 1, 2, 17, 1, 1, 2, 11, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@@            ",
+				"     *@@@@@@@@@@@@@@@@@@          ",
+				"  .@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  .@#  @@@   @@@@@@@@@@@@@+       ",
+				"   @#  @@@   :@@@@@@@@@@@@@       ",
+				"   @@.  @@.   @@@@@@@@@@@@        ",
+				"   .@.  @@#   @@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    :@@@@@@@@@@@@@@@@@.           "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 23, 1, 10, 0, 24,
+				1, 11, 0, 2, 1, 2, 0, 3, 1, 3, 0, 13, 1, 1, 2, 10, 0, 2, 1, 2, 0, 3, 1,
+				3, 0, 1, 2, 13, 1, 10, 0, 2, 1, 3, 0, 2, 1, 4, 0, 12, 1, 12, 0, 1, 1, 3,
+				0, 3, 1, 3, 0, 11, 1, 13, 0, 20, 1, 14, 0, 1, 2, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"  +@@@@@@@@@@@@@@@@@@@@@@#        ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  ;@# @@@#  @@@@@@@@@@@@@@        ",
+				"   @;  @@#   @@@@@@@@@@@@@:       ",
+				"   @@  +@@   @@@@@@@@@@@@         ",
+				"   .@.  @@    @@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@;          ",
+				"    .@@@@@@@@@@@@@@@@@            "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 12, 0, 1, 2, 23, 1, 10,
+				0, 24, 1, 10, 0, 1, 2, 2, 1, 1, 0, 4, 1, 2, 0, 14, 1, 11, 0, 1, 1, 1, 2,
+				2, 0, 3, 1, 3, 0, 13, 1, 1, 2, 10, 0, 2, 1, 2, 0, 1, 2, 2, 1, 3, 0, 12,
+				1, 13, 0, 1, 1, 3, 0, 2, 1, 4, 0, 11, 1, 13, 0, 19, 1, 1, 2, 15, 0, 17,
+				1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"  +@@@@@@@@@@@@@@@@@@@@@@#        ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  ;@# @@@#  @@@@@@@@@@@@@@        ",
+				"   @;  @@#   @@@@@@@@@@@@@:       ",
+				"   @@  +@@   @@@@@@@@@@@@         ",
+				"   .@.  @@    @@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@;          ",
+				"    .@@@@@@@@@@@@@@@@@            "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 12, 0, 1, 2, 23, 1, 10,
+				0, 24, 1, 10, 0, 1, 2, 2, 1, 1, 0, 4, 1, 2, 0, 14, 1, 11, 0, 1, 1, 1, 2,
+				2, 0, 3, 1, 3, 0, 13, 1, 1, 2, 10, 0, 2, 1, 2, 0, 1, 2, 2, 1, 3, 0, 12,
+				1, 13, 0, 1, 1, 3, 0, 2, 1, 4, 0, 11, 1, 13, 0, 19, 1, 1, 2, 15, 0, 17,
+				1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@*            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"  *@@@@@@@@@@@@@@@@@@@@@@;        ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  +@+ @@@#  @@@@@@@@@@@@@@        ",
+				"   @.  @@    @@@@@@@@@@@@@        ",
+				"   @@  @@#   @@@@@@@@@@@@         ",
+				"   .@.  @@   #@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@            "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 1, 2, 17, 0, 1, 2, 18, 1, 12, 0, 23, 1, 1, 2,
+				10, 0, 24, 1, 10, 0, 1, 2, 1, 1, 1, 2, 1, 0, 4, 1, 2, 0, 14, 1, 11, 0,
+				1, 1, 3, 0, 2, 1, 4, 0, 13, 1, 11, 0, 2, 1, 2, 0, 3, 1, 3, 0, 12, 1, 13,
+				0, 1, 1, 3, 0, 2, 1, 3, 0, 12, 1, 13, 0, 19, 1, 16, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         ;@@@@@@@@@@@:            ",
+				"     ;@@@@@@@@@@@@@@@@@#          ",
+				"  #@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  +@. @@@  :@@@@@@@@@@@@@@        ",
+				"   @.  @@   @@@@@@@@@@@@@@        ",
+				"   @#  @@#   @@@@@@@@@@@@         ",
+				"    @. @@#   @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@            "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 1, 2, 11, 1, 1, 2, 17, 0, 1, 2, 18, 1, 12, 0, 23, 1,
+				11, 0, 24, 1, 10, 0, 1, 2, 1, 1, 2, 0, 3, 1, 2, 0, 1, 2, 14, 1, 11, 0,
+				1, 1, 3, 0, 2, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 3, 1, 3, 0, 12, 1, 13,
+				0, 1, 1, 2, 0, 3, 1, 3, 0, 12, 1, 13, 0, 19, 1, 16, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         ;@@@@@@@@@@@:            ",
+				"     ;@@@@@@@@@@@@@@@@@#          ",
+				"  #@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  +@. @@@  :@@@@@@@@@@@@@@        ",
+				"   @.  @@   @@@@@@@@@@@@@@        ",
+				"   @#  @@#   @@@@@@@@@@@@         ",
+				"    @. @@#   @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@            "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 1, 2, 11, 1, 1, 2, 17, 0, 1, 2, 18, 1, 12, 0, 23, 1,
+				11, 0, 24, 1, 10, 0, 1, 2, 1, 1, 2, 0, 3, 1, 2, 0, 1, 2, 14, 1, 11, 0,
+				1, 1, 3, 0, 2, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 3, 1, 3, 0, 12, 1, 13,
+				0, 1, 1, 2, 0, 3, 1, 3, 0, 12, 1, 13, 0, 19, 1, 16, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         *@@@@@@@@@@@.            ",
+				"     ;@@@@@@@@@@@@@@@@@*          ",
+				"  #@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@@        ",
+				"  +@. @@@  @@@@@@@@@@@@@@@        ",
+				"   @. .@@   @@@@@@@@@@@@@@        ",
+				"   @#  @@*   @@@@@@@@@@@@         ",
+				"    @. @@#   @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@            "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 1, 2, 11, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 23, 1,
+				11, 0, 24, 1, 10, 0, 1, 2, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1,
+				3, 0, 2, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 1, 2, 3, 0, 12, 1, 13,
+				0, 1, 1, 2, 0, 3, 1, 3, 0, 12, 1, 13, 0, 19, 1, 16, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         #@@@@@@@@@@@             ",
+				"     ;@@@@@@@@@@@@@@@@@;          ",
+				"  *@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@+        ",
+				"  :@. @@#  @@@@@@@@@@@@@@@        ",
+				"   @. @@#   @@@@@@@@@@@@@@        ",
+				"   @#  @@   @@@@@@@@@@@@@         ",
+				"    @. @@#   @@@@@@@@@@@:         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@#            "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 12, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 23, 1, 11,
+				0, 23, 1, 1, 2, 10, 0, 1, 2, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1,
+				2, 0, 3, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1,
+				1, 2, 0, 3, 1, 3, 0, 11, 1, 1, 2, 13, 0, 19, 1, 16, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         #@@@@@@@@@@@             ",
+				"     ;@@@@@@@@@@@@@@@@@;          ",
+				"  *@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@+        ",
+				"  :@. @@#  @@@@@@@@@@@@@@@        ",
+				"   @. @@#   @@@@@@@@@@@@@@        ",
+				"   @#  @@   @@@@@@@@@@@@@         ",
+				"    @. @@#   @@@@@@@@@@@:         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@#            "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 12, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 23, 1, 11,
+				0, 23, 1, 1, 2, 10, 0, 1, 2, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1,
+				2, 0, 3, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1,
+				1, 2, 0, 3, 1, 3, 0, 11, 1, 1, 2, 13, 0, 19, 1, 16, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         *@@@@@@@@@@@             ",
+				"     ;@@@@@@@@@@@@@@@@@:          ",
+				"  *@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@:        ",
+				"  .@. @@#  @@@@@@@@@@@@@@@        ",
+				"   @. @@#   @@@@@@@@@@@@@@        ",
+				"   @#  @@   @@@@@@@@@@@@@         ",
+				"    @. @@#  +@@@@@@@@@@@.         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@;            "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 12, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 1, 2, 22, 1,
+				11, 0, 23, 1, 1, 2, 11, 0, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1,
+				2, 0, 3, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1,
+				1, 2, 0, 3, 1, 2, 0, 1, 2, 11, 1, 14, 0, 19, 1, 16, 0, 16, 1, 1, 2, 12,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         :@@@@@@@@@@@             ",
+				"     ;@@@@@@@@@@@@@@@@@:          ",
+				"  ;@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @. @@#  @@@@@@@@@@@@@@@        ",
+				"   @. @@#   @@@@@@@@@@@@@@        ",
+				"   @#  @@.  @@@@@@@@@@@@@         ",
+				"    @. @@+  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@*           ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 1, 2, 11, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 1, 2,
+				22, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1,
+				2, 0, 3, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1,
+				1, 2, 0, 2, 1, 1, 2, 2, 0, 12, 1, 14, 0, 18, 1, 1, 2, 16, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         :@@@@@@@@@@@             ",
+				"     ;@@@@@@@@@@@@@@@@@:          ",
+				"  ;@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @. @@#  @@@@@@@@@@@@@@@        ",
+				"   @. @@#   @@@@@@@@@@@@@@        ",
+				"   @#  @@.  @@@@@@@@@@@@@         ",
+				"    @. @@+  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@*           ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 28, 0, 1, 2, 11, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 1, 2,
+				22, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1,
+				2, 0, 3, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1,
+				1, 2, 0, 2, 1, 1, 2, 2, 0, 12, 1, 14, 0, 18, 1, 1, 2, 16, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"         .@@@@@@@@@@@             ",
+				"     ;@@@@@@@@@@@@@@@@@;          ",
+				"  :@@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @. @@#  @@@@@@@@@@@@@@@        ",
+				"   @. @@#  .@@@@@@@@@@@@@@        ",
+				"   @#  @@.  @@@@@@@@@@@@@         ",
+				"    @. @@:  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@.           ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 18, 0, 1, 2, 17, 1, 1, 2, 12, 0, 1, 2, 22, 1,
+				11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1, 2, 0,
+				3, 1, 3, 0, 14, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1, 1, 2,
+				0, 2, 1, 1, 2, 2, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@.            ",
+				"     ;@@@@@@@@@@@@@@@@@+          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @. @@*  @@@@@@@@@@@@@@@        ",
+				"   @. @@#  #@@@@@@@@@@@@@@        ",
+				"   ##  @@.  @@@@@@@@@@@@@         ",
+				"    @. @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 18, 0, 1, 2, 17, 1, 1, 2, 13, 0, 22, 1, 11,
+				0, 23, 1, 12, 0, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1, 2, 0, 3, 1,
+				2, 0, 15, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1, 1, 2, 0, 2,
+				1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@.            ",
+				"     ;@@@@@@@@@@@@@@@@@+          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"  @@@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @. @@*  @@@@@@@@@@@@@@@        ",
+				"   @. @@#  #@@@@@@@@@@@@@@        ",
+				"   ##  @@.  @@@@@@@@@@@@@         ",
+				"    @. @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 18, 0, 1, 2, 17, 1, 1, 2, 13, 0, 22, 1, 11,
+				0, 23, 1, 12, 0, 1, 1, 2, 0, 3, 1, 2, 0, 15, 1, 11, 0, 1, 1, 2, 0, 3, 1,
+				2, 0, 15, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1, 1, 2, 0, 2,
+				1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@:            ",
+				"     ;@@@@@@@@@@@@@@@@@+          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"  #@@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @. @@+  @@@@@@@@@@@@@@@        ",
+				"   @: @@#  @@@@@@@@@@@@@@@        ",
+				"   ##  @@.  @@@@@@@@@@@@@         ",
+				"    @. @@   @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 1, 2, 17, 0, 1, 2, 17, 1, 1, 2, 13, 0, 22, 1,
+				11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 1,
+				1, 2, 1, 0, 3, 1, 2, 0, 15, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@+            ",
+				"     +@@@@@@@@@@@@@@@@@*          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"  ;@@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @. @@:  @@@@@@@@@@@@@@@        ",
+				"   @; @@#  @@@@@@@@@@@@@@@        ",
+				"   *@  @@   @@@@@@@@@@@@@         ",
+				"    @: @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 1, 2, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 11,
+				0, 1, 2, 22, 1, 12, 0, 1, 1, 2, 0, 2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 1,
+				1, 2, 1, 0, 3, 1, 2, 0, 15, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@+            ",
+				"     +@@@@@@@@@@@@@@@@@*          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"  ;@@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @. @@:  @@@@@@@@@@@@@@@        ",
+				"   @; @@#  @@@@@@@@@@@@@@@        ",
+				"   *@  @@   @@@@@@@@@@@@@         ",
+				"    @: @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 1, 2, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 11,
+				0, 1, 2, 22, 1, 12, 0, 1, 1, 2, 0, 2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 1,
+				1, 2, 1, 0, 3, 1, 2, 0, 15, 1, 11, 0, 2, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@+            ",
+				"     +@@@@@@@@@@@@@@@@@#          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"  .@@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @. @@.  @@@@@@@@@@@@@@@        ",
+				"   @; @@*  @@@@@@@@@@@@@@@        ",
+				"   +@  @#   @@@@@@@@@@@@@         ",
+				"    @: @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@@             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 11, 1, 1, 2, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12,
+				0, 22, 1, 12, 0, 1, 1, 2, 0, 2, 1, 3, 0, 15, 1, 11, 0, 1, 1, 1, 2, 1, 0,
+				3, 1, 2, 0, 15, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1,
+				1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@*            ",
+				"     +@@@@@@@@@@@@@@@@@#          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @: @@.  @@@@@@@@@@@@@@@        ",
+				"   @+ @@*  @@@@@@@@@@@@@@@        ",
+				"   ;@  @#   @@@@@@@@@@@@@         ",
+				"    @: @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@*             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 15, 1, 11, 0, 1, 1, 1, 2, 1, 0,
+				2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@*            ",
+				"     +@@@@@@@@@@@@@@@@@#          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @: @@.  @@@@@@@@@@@@@@@        ",
+				"   @+ @@*  @@@@@@@@@@@@@@@        ",
+				"   ;@  @#   @@@@@@@@@@@@@         ",
+				"    @: @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@*             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 15, 1, 11, 0, 1, 1, 1, 2, 1, 0,
+				2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 16, 1, 13,
+				0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @+ @@.  @@@@@@@@@@@@@@@        ",
+				"   @* @@*  @@@@@@@@@@@@@@@        ",
+				"   ;@  @#   @@@@@@@@@@@@@         ",
+				"    @: @@.  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@;             "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 15, 1, 11, 0, 1, 1, 1, 2, 1, 0,
+				2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 2, 1, 3, 0, 12, 1, 14, 0, 18, 1, 17, 0, 15, 1, 1,
+				2, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @* @@*  @@@@@@@@@@@@@@@        ",
+				"   :@  @#  .@@@@@@@@@@@@@         ",
+				"    @: @@. *@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 23, 1, 11, 0, 2, 1, 1, 0, 2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1,
+				2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0,
+				1, 2, 12, 1, 14, 0, 18, 1, 17, 0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @* @@*  @@@@@@@@@@@@@@@        ",
+				"   :@  @#  .@@@@@@@@@@@@@         ",
+				"    @: @@. *@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 23, 1, 11, 0, 2, 1, 1, 0, 2, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1,
+				2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0,
+				1, 2, 12, 1, 14, 0, 18, 1, 17, 0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@                   ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@*@@+  @@@@@@@@@@@@@@@        ",
+				"   .@  @#  :@@@@@@@@@@@@@         ",
+				"    @: @@. #@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 23, 1, 11, 0, 5, 1, 1, 2, 2, 0, 15, 1, 11, 0, 1, 2, 1, 1, 2,
+				0, 2, 1, 2, 0, 1, 2, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1,
+				14, 0, 18, 1, 17, 0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@.                  ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   .@  @#  ;@@@@@@@@@@@@@         ",
+				"    @: @@. @@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 23, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 2, 0, 1, 2, 13,
+				1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1, 14, 0, 18, 1, 17, 0, 15,
+				1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@.                  ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   .@  @#  ;@@@@@@@@@@@@@         ",
+				"    @: @@. @@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 12, 0, 23, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 2, 0, 1, 2, 13,
+				1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1, 14, 0, 18, 1, 17, 0, 15,
+				1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@.                  ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   .@  @#  ;@@@@@@@@@@@@@         ",
+				"    @: @@. @@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 29, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 22,
+				1, 1, 2, 11, 0, 23, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 2, 0, 1,
+				2, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1, 14, 0, 18, 1, 17,
+				0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@:                  ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@:        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   .@  @#  .@@@@@@@@@@@@@         ",
+				"    @: @@. @@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 1, 2, 28, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12,
+				0, 22, 1, 1, 2, 11, 0, 23, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 2,
+				0, 1, 2, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1, 14, 0, 18,
+				1, 17, 0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@:                  ",
+				"          @@@@@@@@@@@#            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@:        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   .@  @#  .@@@@@@@@@@@@@         ",
+				"    @: @@. @@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 1, 2, 28, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12,
+				0, 22, 1, 1, 2, 11, 0, 23, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 2,
+				0, 1, 2, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1, 14, 0, 18,
+				1, 17, 0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@;                  ",
+				"          @@@@@@@@@@@@            ",
+				"     +@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@+        ",
+				"   @#@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   .@  @#   @@@@@@@@@@@@@         ",
+				"    @: @@. #@@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"     @@@@@@@@@@@@@@@              "
+			],
+			[
+				44, 0, 5, 1, 1, 2, 28, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12,
+				0, 22, 1, 1, 2, 11, 0, 23, 1, 11, 0, 23, 1, 12, 0, 1, 1, 2, 0, 2, 1, 3,
+				0, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 0, 13, 1, 14, 0, 18, 1, 17,
+				0, 15, 1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@@                  ",
+				"          #@@@@@@@@@@@            ",
+				"     *@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   :@  @@.  @@@@@@@@@@@@@         ",
+				"    @: @@#  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"    .@@@@@@@@@@@@@@@.             "
+			],
+			[
+				44, 0, 6, 1, 28, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 23,
+				1, 11, 0, 23, 1, 11, 0, 23, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13,
+				1, 13, 0, 1, 1, 1, 2, 1, 0, 3, 1, 2, 0, 12, 1, 14, 0, 18, 1, 17, 0, 15,
+				1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@@                  ",
+				"          #@@@@@@@@@@@            ",
+				"     *@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   :@  @@.  @@@@@@@@@@@@@         ",
+				"    @: @@#  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"    .@@@@@@@@@@@@@@@.             "
+			],
+			[
+				44, 0, 6, 1, 28, 0, 12, 1, 17, 0, 1, 2, 18, 1, 13, 0, 22, 1, 12, 0, 23,
+				1, 11, 0, 23, 1, 11, 0, 23, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13,
+				1, 13, 0, 1, 1, 1, 2, 1, 0, 3, 1, 2, 0, 12, 1, 14, 0, 18, 1, 17, 0, 15,
+				1, 14, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          @@@@@@                  ",
+				"          :@@@@@@@@@@@            ",
+				"     *@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@.        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   ;@  @@.  @@@@@@@@@@@@@         ",
+				"    @: @@@  @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"    :@@@@@@@@@@@@@@@;             "
+			],
+			[
+				44, 0, 6, 1, 28, 0, 1, 2, 11, 1, 17, 0, 19, 1, 13, 0, 22, 1, 1, 2, 11,
+				0, 23, 1, 11, 0, 23, 1, 11, 0, 23, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3,
+				0, 13, 1, 13, 0, 1, 1, 1, 2, 1, 0, 3, 1, 2, 0, 12, 1, 14, 0, 18, 1, 16,
+				0, 1, 2, 15, 1, 1, 2, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          .@@@@@                  ",
+				"           @@@@@@@@@@@            ",
+				"     #@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   +@. @@.  @@@@@@@@@@@@@         ",
+				"    @: @@@. @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"    +@@@@@@@@@@@@@@@#             "
+			],
+			[
+				45, 0, 5, 1, 29, 0, 11, 1, 17, 0, 19, 1, 13, 0, 23, 1, 11, 0, 23, 1, 11,
+				0, 23, 1, 11, 0, 23, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 3, 1, 2, 0, 12, 1, 14, 0, 18, 1, 16, 0, 1, 2, 16,
+				1, 13, 0
+			]
+		],
+		[
+			[
+				"                                  ",
+				"          .@@@@@                  ",
+				"           @@@@@@@@@@@            ",
+				"     #@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   +@. @@.  @@@@@@@@@@@@@         ",
+				"    @: @@@. @@@@@@@@@@@@          ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"    +@@@@@@@@@@@@@@@#             "
+			],
+			[
+				45, 0, 5, 1, 29, 0, 11, 1, 17, 0, 19, 1, 13, 0, 23, 1, 11, 0, 23, 1, 11,
+				0, 23, 1, 11, 0, 23, 1, 11, 0, 1, 2, 1, 1, 2, 0, 2, 1, 3, 0, 13, 1, 13,
+				0, 1, 1, 1, 2, 1, 0, 3, 1, 2, 0, 12, 1, 14, 0, 18, 1, 16, 0, 1, 2, 16,
+				1, 13, 0
+			]
+		],
+		[
+			[
+				"             .                    ",
+				"           @@@@@                  ",
+				"           @@@@@@@@@@@            ",
+				"     #@@@@@@@@@@@@@@@@@@          ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@:@@@@@@@@@@@@@@@@        ",
+				"   +@. @@#   @@@@@@@@@@@@         ",
+				"    @+ @@@. @@@@@@@@@@@@:         ",
+				"    @@@@@@@@@@@@@@@@@@            ",
+				"    *@@@@@@@@@@@@@@@@             "
+			],
+			[
+				45, 0, 5, 1, 29, 0, 11, 1, 17, 0, 19, 1, 13, 0, 23, 1, 11, 0, 23, 1, 11,
+				0, 23, 1, 11, 0, 6, 1, 1, 2, 16, 1, 11, 0, 1, 2, 1, 1, 2, 0, 3, 1, 3, 0,
+				12, 1, 13, 0, 1, 1, 1, 2, 1, 0, 3, 1, 2, 0, 12, 1, 1, 2, 13, 0, 18, 1,
+				16, 0, 1, 2, 16, 1, 13, 0
+			]
+		],
+		[
+			[
+				"             :                    ",
+				"           @@@@@                  ",
+				"           @@@@@@@@@@@*           ",
+				"     @@@@@@@@@@@@@@@@@@@+         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@+       ",
+				"   @@@@@@#;@ @@@@@@@@@@@@@#       ",
+				"   *@. +@@   @@@@@@@@@@@@         ",
+				"    @@ @@@#  @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"    #@@@@@@@@@@@@@@@@             "
+			],
+			[
+				13, 0, 1, 2, 31, 0, 5, 1, 29, 0, 12, 1, 16, 0, 19, 1, 1, 2, 12, 0, 23,
+				1, 11, 0, 23, 1, 11, 0, 23, 1, 1, 2, 10, 0, 7, 1, 1, 2, 1, 1, 1, 0, 14,
+				1, 10, 0, 1, 2, 1, 1, 2, 0, 1, 2, 2, 1, 3, 0, 12, 1, 13, 0, 2, 1, 1, 0,
+				4, 1, 2, 0, 12, 1, 13, 0, 19, 1, 15, 0, 17, 1, 13, 0
+			]
+		],
+		[
+			[
+				"             :                    ",
+				"           @@@@@                  ",
+				"           @@@@@@@@@@@*           ",
+				"     @@@@@@@@@@@@@@@@@@@+         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@+       ",
+				"   @@@@@@#;@ @@@@@@@@@@@@@#       ",
+				"   *@. +@@   @@@@@@@@@@@@         ",
+				"    @@ @@@#  @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"    #@@@@@@@@@@@@@@@@             "
+			],
+			[
+				13, 0, 1, 2, 31, 0, 5, 1, 29, 0, 12, 1, 16, 0, 19, 1, 1, 2, 12, 0, 23,
+				1, 11, 0, 23, 1, 11, 0, 23, 1, 1, 2, 10, 0, 7, 1, 1, 2, 1, 1, 1, 0, 14,
+				1, 10, 0, 1, 2, 1, 1, 2, 0, 1, 2, 2, 1, 3, 0, 12, 1, 13, 0, 2, 1, 1, 0,
+				4, 1, 2, 0, 12, 1, 13, 0, 19, 1, 15, 0, 17, 1, 13, 0
+			]
+		],
+		[
+			[
+				"             ;                    ",
+				"           @@@@@+                 ",
+				"           @@@@@@@@@@@#           ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@        ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@:       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@ + @@@@@@@@@@@@@@       ",
+				"   *@.  @@    @@@@@@@@@@@.        ",
+				"    @@ @@@@. @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"    #@@@@@@@@@@@@@@@@             "
+			],
+			[
+				13, 0, 1, 2, 31, 0, 5, 1, 1, 2, 28, 0, 12, 1, 16, 0, 20, 1, 12, 0, 23,
+				1, 11, 0, 23, 1, 1, 2, 10, 0, 24, 1, 10, 0, 7, 1, 1, 0, 1, 2, 1, 0, 14,
+				1, 10, 0, 1, 2, 1, 1, 3, 0, 2, 1, 4, 0, 11, 1, 13, 0, 2, 1, 1, 0, 4, 1,
+				2, 0, 12, 1, 13, 0, 19, 1, 15, 0, 17, 1, 13, 0
+			]
+		],
+		[
+			[
+				"             :+                   ",
+				"           @@@@@@                 ",
+				"          :#@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@:       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@+@@*   @@@@@@@@@@@@@       ",
+				"   *@   @@#   @@@@@@@@@@@@        ",
+				"    @@. @@@# @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"    #@@@@@@@@@@@@@@@#:            "
+			],
+			[
+				13, 0, 2, 2, 30, 0, 6, 1, 27, 0, 1, 2, 12, 1, 16, 0, 20, 1, 12, 0, 23,
+				1, 1, 2, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 4, 1, 1, 2, 3, 1, 3, 0, 13,
+				1, 10, 0, 1, 2, 1, 1, 3, 0, 3, 1, 3, 0, 12, 1, 12, 0, 2, 1, 2, 0, 4, 1,
+				1, 0, 12, 1, 13, 0, 19, 1, 15, 0, 17, 1, 1, 2, 12, 0
+			]
+		],
+		[
+			[
+				"             :+                   ",
+				"           @@@@@@                 ",
+				"          :#@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@:       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@+@@*   @@@@@@@@@@@@@       ",
+				"   *@   @@#   @@@@@@@@@@@@        ",
+				"    @@. @@@# @@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"    #@@@@@@@@@@@@@@@#:            "
+			],
+			[
+				13, 0, 2, 2, 30, 0, 6, 1, 27, 0, 1, 2, 12, 1, 16, 0, 20, 1, 12, 0, 23,
+				1, 1, 2, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 4, 1, 1, 2, 3, 1, 3, 0, 13,
+				1, 10, 0, 1, 2, 1, 1, 3, 0, 3, 1, 3, 0, 12, 1, 12, 0, 2, 1, 2, 0, 4, 1,
+				1, 0, 12, 1, 13, 0, 19, 1, 15, 0, 17, 1, 1, 2, 12, 0
+			]
+		],
+		[
+			[
+				"             :*                   ",
+				"           *@@@@@                 ",
+				"          ;#@@@@@@@@@@@           ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@.@;@@@    @@@@@@@@@@@@       ",
+				"   +@:  @@@    @@@@@@@@@@@        ",
+				"    @@. @@@@..@@@@@@@@@@@         ",
+				"    @@@@@@@@@@@@@@@@@@@           ",
+				"    #@@@@@@@@@@@@@@@##            "
+			],
+			[
+				13, 0, 2, 2, 30, 0, 1, 2, 5, 1, 27, 0, 1, 2, 12, 1, 16, 0, 20, 1, 12, 0,
+				24, 1, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 2, 1, 1, 0, 1, 1, 1, 2, 3, 1,
+				4, 0, 12, 1, 10, 0, 1, 2, 1, 1, 1, 2, 2, 0, 3, 1, 4, 0, 11, 1, 12, 0, 2,
+				1, 2, 0, 4, 1, 2, 0, 11, 1, 13, 0, 19, 1, 15, 0, 18, 1, 12, 0
+			]
+		],
+		[
+			[
+				"              #                   ",
+				"            @@@@@                 ",
+				"          *#@@@@@@@@@@@.          ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@#@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@;:  @@.   @@@@@@@@@@@@       ",
+				"   ;@#   @@#   @@@@@@@@@@@        ",
+				"    @@# @@@@@;@@@@@@@@@@@#        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@##            "
+			],
+			[
+				14, 0, 1, 1, 31, 0, 5, 1, 27, 0, 13, 1, 16, 0, 20, 1, 12, 0, 24, 1, 10,
+				0, 24, 1, 10, 0, 24, 1, 10, 0, 2, 1, 2, 2, 2, 0, 2, 1, 4, 0, 12, 1, 10,
+				0, 1, 2, 2, 1, 3, 0, 3, 1, 3, 0, 11, 1, 12, 0, 3, 1, 1, 0, 5, 1, 1, 2,
+				12, 1, 12, 0, 20, 1, 14, 0, 1, 2, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"              #                   ",
+				"            @@@@@                 ",
+				"          *#@@@@@@@@@@@.          ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@#@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@;:  @@.   @@@@@@@@@@@@       ",
+				"   ;@#   @@#   @@@@@@@@@@@        ",
+				"    @@# @@@@@;@@@@@@@@@@@#        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    ;@@@@@@@@@@@@@@@##            "
+			],
+			[
+				14, 0, 1, 1, 31, 0, 5, 1, 27, 0, 13, 1, 16, 0, 20, 1, 12, 0, 24, 1, 10,
+				0, 24, 1, 10, 0, 24, 1, 10, 0, 2, 1, 2, 2, 2, 0, 2, 1, 4, 0, 12, 1, 10,
+				0, 1, 2, 2, 1, 3, 0, 3, 1, 3, 0, 11, 1, 12, 0, 3, 1, 1, 0, 5, 1, 1, 2,
+				12, 1, 12, 0, 20, 1, 14, 0, 1, 2, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"              @:                  ",
+				"            @@@@@:                ",
+				"         .##@@@@@@@@@@@+          ",
+				"     @@@@@@@@@@@@@@@@@@@@         ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@#@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   #@#   @@#    @@@@@@@@@@@       ",
+				"   :@#   @@@    @@@@@@@@@@        ",
+				"    @@# @@@@@#@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"    .@@@@@@@@@@@@@@@##            "
+			],
+			[
+				14, 0, 1, 1, 1, 2, 30, 0, 5, 1, 1, 2, 25, 0, 1, 2, 13, 1, 1, 2, 15, 0,
+				20, 1, 12, 0, 24, 1, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 3, 1, 3, 0, 3,
+				1, 4, 0, 11, 1, 10, 0, 1, 2, 2, 1, 3, 0, 3, 1, 4, 0, 10, 1, 12, 0, 3, 1,
+				1, 0, 18, 1, 12, 0, 20, 1, 15, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"              ##                  ",
+				"            @@@@@@                ",
+				"         +#@@@@@@@@@@@@@          ",
+				"     @@@@@@@@@@@@@@@@@@@@#        ",
+				"   ;@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@#@@@@@@@@@@@@@:      ",
+				"   #@@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"   *@@   +@@     @@@@@@@@@@#      ",
+				"    @@   #@@#   .@@@@@@@@@@       ",
+				"    @@@*@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"     @@@@@@@@@@@@@@@##.           "
+			],
+			[
+				14, 0, 2, 1, 30, 0, 6, 1, 25, 0, 1, 2, 14, 1, 15, 0, 21, 1, 11, 0, 1, 2,
+				23, 1, 10, 0, 24, 1, 1, 2, 9, 0, 25, 1, 9, 0, 1, 2, 2, 1, 3, 0, 1, 2, 2,
+				1, 5, 0, 11, 1, 10, 0, 2, 1, 3, 0, 4, 1, 4, 0, 10, 1, 11, 0, 3, 1, 1, 2,
+				18, 1, 12, 0, 20, 1, 15, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"              ##                  ",
+				"            @@@@@@                ",
+				"         +#@@@@@@@@@@@@@          ",
+				"     @@@@@@@@@@@@@@@@@@@@#        ",
+				"   ;@@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   @@@@@@@@@@#@@@@@@@@@@@@@:      ",
+				"   #@@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"   *@@   +@@     @@@@@@@@@@#      ",
+				"    @@   #@@#   .@@@@@@@@@@       ",
+				"    @@@*@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@          ",
+				"     @@@@@@@@@@@@@@@##.           "
+			],
+			[
+				14, 0, 2, 1, 30, 0, 6, 1, 25, 0, 1, 2, 14, 1, 15, 0, 21, 1, 11, 0, 1, 2,
+				23, 1, 10, 0, 24, 1, 1, 2, 9, 0, 25, 1, 9, 0, 1, 2, 2, 1, 3, 0, 1, 2, 2,
+				1, 5, 0, 11, 1, 10, 0, 2, 1, 3, 0, 4, 1, 4, 0, 10, 1, 11, 0, 3, 1, 1, 2,
+				18, 1, 12, 0, 20, 1, 15, 0, 17, 1, 12, 0
+			]
+		],
+		[
+			[
+				"              ##                  ",
+				"            @@@@@@                ",
+				"         *#@@@@@@@@@@@@@          ",
+				"     #@@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"   #@@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"   +@@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"   :@@    @@#    @@@@@@@@@@#      ",
+				"    @@    @@@    @@@@@@@@@@       ",
+				"    @@@#@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@#         ",
+				"     @@@@@@@@@@@@@@@##+           "
+			],
+			[
+				14, 0, 2, 1, 30, 0, 6, 1, 25, 0, 1, 2, 14, 1, 15, 0, 21, 1, 12, 0, 23,
+				1, 10, 0, 25, 1, 9, 0, 1, 2, 24, 1, 9, 0, 1, 2, 2, 1, 4, 0, 3, 1, 4, 0,
+				11, 1, 10, 0, 2, 1, 4, 0, 3, 1, 4, 0, 10, 1, 11, 0, 22, 1, 12, 0, 21, 1,
+				14, 0, 17, 1, 1, 2, 11, 0
+			]
+		],
+		[
+			[
+				"              ;@                  ",
+				"             @@@@@                ",
+				"        :#@@@@@@@@@@@@@@          ",
+				"     *@@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@.      ",
+				"    @@@@#@@@@@#@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@.   @@@     @@@@@@@@@@      ",
+				"    @@#   @@@@    @@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@         ",
+				"     @@@@@@@@@@@@@@@@##           "
+			],
+			[
+				14, 0, 1, 2, 1, 1, 31, 0, 5, 1, 24, 0, 1, 2, 15, 1, 15, 0, 1, 2, 20, 1,
+				12, 0, 23, 1, 1, 2, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 2, 1, 4, 0, 3, 1,
+				5, 0, 10, 1, 10, 0, 3, 1, 3, 0, 4, 1, 4, 0, 9, 1, 11, 0, 23, 1, 11, 0,
+				21, 1, 14, 0, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"              ;@                  ",
+				"             @@@@@                ",
+				"        :#@@@@@@@@@@@@@@          ",
+				"     *@@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@.      ",
+				"    @@@@#@@@@@#@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@.   @@@     @@@@@@@@@@      ",
+				"    @@#   @@@@    @@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@         ",
+				"     @@@@@@@@@@@@@@@@##           "
+			],
+			[
+				14, 0, 1, 2, 1, 1, 31, 0, 5, 1, 24, 0, 1, 2, 15, 1, 15, 0, 1, 2, 20, 1,
+				12, 0, 23, 1, 1, 2, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 2, 1, 4, 0, 3, 1,
+				5, 0, 10, 1, 10, 0, 3, 1, 3, 0, 4, 1, 4, 0, 9, 1, 11, 0, 23, 1, 11, 0,
+				21, 1, 14, 0, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"              :@:                 ",
+				"             @@@@@                ",
+				"        ;#@@@@@@@@@@@@@@          ",
+				"     ;@@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@*      ",
+				"    @@@@#@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@#    @@#    @@@@@@@@@@      ",
+				"    @@@   +@@@    @@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@#         ",
+				"     @@@@@@@@@@@@@@@@##           "
+			],
+			[
+				14, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 24, 0, 1, 2, 15, 1, 15, 0, 1, 2,
+				20, 1, 12, 0, 23, 1, 1, 2, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 3, 1, 4,
+				0, 3, 1, 4, 0, 10, 1, 10, 0, 3, 1, 3, 0, 1, 2, 3, 1, 4, 0, 9, 1, 11, 0,
+				23, 1, 11, 0, 21, 1, 14, 0, 18, 1, 11, 0
+			]
+		],
+		[
+			[
+				"               @*                 ",
+				"             @@@@@*               ",
+				"        +@@@@@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@##@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@#     ",
+				"    @@@    @@@     @@@@@@@@@+     ",
+				"    @@@    @@@#    @@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"    +@@@@@@@@@@@@@@@@@@@#         ",
+				"     ;@@@@@@@@@@@@@@@@*           "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 23, 0, 1, 2, 15, 1, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 10, 0, 25, 1, 9, 0, 3, 1, 4, 0, 3, 1, 5, 0, 9, 1, 1, 2,
+				9, 0, 3, 1, 4, 0, 4, 1, 4, 0, 8, 1, 11, 0, 23, 1, 11, 0, 1, 2, 20, 1,
+				14, 0, 1, 2, 17, 1, 11, 0
+			]
+		],
+		[
+			[
+				"               @*                 ",
+				"             @@@@@*               ",
+				"        +@@@@@@@@@@@@@@@          ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@##@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@#     ",
+				"    @@@    @@@     @@@@@@@@@+     ",
+				"    @@@    @@@#    @@@@@@@@       ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"    +@@@@@@@@@@@@@@@@@@@#         ",
+				"     ;@@@@@@@@@@@@@@@@*           "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 23, 0, 1, 2, 15, 1, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 10, 0, 25, 1, 9, 0, 3, 1, 4, 0, 3, 1, 5, 0, 9, 1, 1, 2,
+				9, 0, 3, 1, 4, 0, 4, 1, 4, 0, 8, 1, 11, 0, 23, 1, 11, 0, 1, 2, 20, 1,
+				14, 0, 1, 2, 17, 1, 11, 0
+			]
+		],
+		[
+			[
+				"               @#                 ",
+				"             @@@@@@               ",
+				"        *@@@@@@@@@@@@@@@.         ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@#@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@     ",
+				"    @@@    .@@#    #@@@@@@@@@     ",
+				"    @@@+   @@@@    @@@@@@@@;      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@#;        ",
+				"      @@@@@@@@@@@@@@@@#.          "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 23, 0, 1, 2, 15, 1, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 10, 0, 25, 1, 9, 0, 3, 1, 5, 0, 3, 1, 4, 0, 10, 1, 9,
+				0, 3, 1, 1, 2, 3, 0, 4, 1, 4, 0, 8, 1, 1, 2, 10, 0, 23, 1, 12, 0, 20, 1,
+				1, 2, 14, 0, 17, 1, 11, 0
+			]
+		],
+		[
+			[
+				"               #@                 ",
+				"             @@@@@@               ",
+				"        *@@@@@@@@@@@@@@@+         ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@     ",
+				"    @@@#    @@@     @@@@@@@@@     ",
+				"    @@@@    @@@@    @@@@@@@#      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@#        ",
+				"      @@@@@@@@@@@@@@@@@+          "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 23, 0, 1, 2, 15, 1, 1, 2, 15, 0, 20, 1, 12, 0,
+				24, 1, 10, 0, 24, 1, 10, 0, 25, 1, 9, 0, 4, 1, 4, 0, 3, 1, 5, 0, 9, 1,
+				9, 0, 4, 1, 4, 0, 4, 1, 4, 0, 8, 1, 10, 0, 23, 1, 12, 0, 21, 1, 14, 0,
+				17, 1, 1, 2, 10, 0
+			]
+		],
+		[
+			[
+				"               #@                 ",
+				"             @@@@@@               ",
+				"        *@@@@@@@@@@@@@@@+         ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@     ",
+				"    @@@#    @@@     @@@@@@@@@     ",
+				"    @@@@    @@@@    @@@@@@@#      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@#        ",
+				"      @@@@@@@@@@@@@@@@@+          "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 23, 0, 1, 2, 15, 1, 1, 2, 15, 0, 20, 1, 12, 0,
+				24, 1, 10, 0, 24, 1, 10, 0, 25, 1, 9, 0, 4, 1, 4, 0, 3, 1, 5, 0, 9, 1,
+				9, 0, 4, 1, 4, 0, 4, 1, 4, 0, 8, 1, 10, 0, 23, 1, 12, 0, 21, 1, 14, 0,
+				17, 1, 1, 2, 10, 0
+			]
+		],
+		[
+			[
+				"               #@                 ",
+				"             #@@@@@               ",
+				"        *@@@@@@@@@@@@@@@*         ",
+				"      @@@@@@@@@@@@@@@@@@@@;       ",
+				"    ;@@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    @@@@@@@#@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@     ",
+				"    @@@@     @@@     @@@@@@@@     ",
+				"    #@@@    @@@@    @@@@@@@#      ",
+				"    #@@@@@@@@@@@@@@@@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@#        ",
+				"      #@@@@@@@@@@@@@@@@+          "
+			],
+			[
+				15, 0, 2, 1, 30, 0, 6, 1, 23, 0, 1, 2, 16, 1, 15, 0, 20, 1, 1, 2, 11, 0,
+				1, 2, 23, 1, 10, 0, 24, 1, 10, 0, 25, 1, 9, 0, 4, 1, 5, 0, 3, 1, 5, 0,
+				8, 1, 9, 0, 4, 1, 4, 0, 4, 1, 4, 0, 8, 1, 10, 0, 23, 1, 12, 0, 21, 1,
+				14, 0, 17, 1, 1, 2, 10, 0
+			]
+		],
+		[
+			[
+				"               ;@;                ",
+				"              @@@@@               ",
+				"        +@@@@@@@@@@@@@@@#         ",
+				"      @@@@@@@@@@@@@@@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@#      ",
+				"     @@@@@@@#@@@@#@@@@@@@@@#      ",
+				"    *@@@@@@@@@@@@@@@@@@@@@@@@.    ",
+				"    @@@@#    #@@#     @@@@@@@     ",
+				"     @@@@    @@@@    @@@@@@#      ",
+				"     @@@@@@@@@@@@@@@@@@@@@@+      ",
+				"     :@@@@@@@@@@@@@@@@@@@@        ",
+				"       @@@@@@@@@@@@@@@@@          "
+			],
+			[
+				15, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 1, 2, 16, 1, 15, 0, 21, 1,
+				12, 0, 23, 1, 11, 0, 23, 1, 10, 0, 25, 1, 9, 0, 5, 1, 4, 0, 4, 1, 5, 0,
+				7, 1, 10, 0, 4, 1, 4, 0, 4, 1, 4, 0, 7, 1, 11, 0, 22, 1, 1, 2, 11, 0, 1,
+				2, 20, 1, 15, 0, 17, 1, 10, 0
+			]
+		],
+		[
+			[
+				"               ;@;                ",
+				"              @@@@@               ",
+				"        +@@@@@@@@@@@@@@@#         ",
+				"      @@@@@@@@@@@@@@@@@@@@#       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@#      ",
+				"     @@@@@@@#@@@@#@@@@@@@@@#      ",
+				"    *@@@@@@@@@@@@@@@@@@@@@@@@.    ",
+				"    @@@@#    #@@#     @@@@@@@     ",
+				"     @@@@    @@@@    @@@@@@#      ",
+				"     @@@@@@@@@@@@@@@@@@@@@@+      ",
+				"     :@@@@@@@@@@@@@@@@@@@@        ",
+				"       @@@@@@@@@@@@@@@@@          "
+			],
+			[
+				15, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 1, 2, 16, 1, 15, 0, 21, 1,
+				12, 0, 23, 1, 11, 0, 23, 1, 10, 0, 25, 1, 9, 0, 5, 1, 4, 0, 4, 1, 5, 0,
+				7, 1, 10, 0, 4, 1, 4, 0, 4, 1, 4, 0, 7, 1, 11, 0, 22, 1, 1, 2, 11, 0, 1,
+				2, 20, 1, 15, 0, 17, 1, 10, 0
+			]
+		],
+		[
+			[
+				"               .@+                ",
+				"              @@@@@.              ",
+				"        :@@@@@@@@@@@@@@@@         ",
+				"      #@@@@@@@@@@@@@@@@@@@@       ",
+				"     @@@@@@@@@@@@@@@@@@@@@@#      ",
+				"     @@@@@@@@@@@@@@@@@@@@@@#      ",
+				"    #@@@@@@@@@@@@@@@@@@@@@@@@*    ",
+				"    @@@@@     @@@     @@@@@@@;    ",
+				"     @@@@.   #@@@*    @@@@@*      ",
+				"     @@@@@@@@@@@@@@@@@@@@@@+      ",
+				"      @@@@@@@@@@@@@@@@@@@@        ",
+				"       @@@@@@@@@@@@@@@@@:         "
+			],
+			[
+				16, 0, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 1, 2, 16, 1, 15, 0, 21, 1, 12, 0,
+				23, 1, 11, 0, 23, 1, 10, 0, 26, 1, 8, 0, 5, 1, 5, 0, 3, 1, 5, 0, 7, 1,
+				1, 2, 9, 0, 4, 1, 4, 0, 5, 1, 4, 0, 5, 1, 1, 2, 11, 0, 22, 1, 1, 2, 12,
+				0, 20, 1, 15, 0, 17, 1, 1, 2, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"     *@@@@@@@@@@@@@@@@@@@@@@      ",
+				"     #@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"     *@@@@    @@@@;   :@@@@@      ",
+				"     +@@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@       ",
+				"        @@@@@@@@@@@@@@@@@         "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 12, 0, 1, 2, 22,
+				1, 11, 0, 23, 1, 10, 0, 26, 1, 8, 0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 9, 0,
+				1, 2, 4, 1, 4, 0, 4, 1, 1, 2, 3, 0, 1, 2, 5, 1, 11, 0, 1, 2, 22, 1, 12,
+				0, 21, 1, 15, 0, 17, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"     *@@@@@@@@@@@@@@@@@@@@@@      ",
+				"     #@@@@@@@@@@@@@@@@@@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"    @@@@@@     @@@     @@@@@@@    ",
+				"     *@@@@    @@@@;   :@@@@@      ",
+				"     +@@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@       ",
+				"        @@@@@@@@@@@@@@@@@         "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 12, 0, 1, 2, 22,
+				1, 11, 0, 23, 1, 10, 0, 26, 1, 8, 0, 6, 1, 5, 0, 3, 1, 5, 0, 7, 1, 9, 0,
+				1, 2, 4, 1, 4, 0, 4, 1, 1, 2, 3, 0, 1, 2, 5, 1, 11, 0, 1, 2, 22, 1, 12,
+				0, 21, 1, 15, 0, 17, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@#@@@@@      ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"    @@@@@@     @@@     ;@@@@@@    ",
+				"      @@@@#    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        @@@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 22, 1, 10, 0, 26, 1, 8, 0, 6, 1, 5, 0, 3, 1, 5, 0, 1, 2, 6, 1, 10, 0,
+				5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 17, 1,
+				1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                #@                ",
+				"              *@@@@@              ",
+				"         @@@@@@@@@@@@@@@@.        ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      @@@@@@@@@@@@@@@@@#@@@@@     ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"    #@@@@@@     @@@     @@@@@@    ",
+				"      @@@@@*   ;@@@@    @@@@@     ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       @@@@@@@@@@@@@@@@@@@@@      ",
+				"         @@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23, 1, 11,
+				0, 23, 1, 9, 0, 26, 1, 8, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1,
+				1, 2, 3, 0, 1, 2, 4, 1, 4, 0, 5, 1, 11, 0, 23, 1, 12, 0, 21, 1, 15, 0,
+				17, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                #@                ",
+				"              *@@@@@              ",
+				"         @@@@@@@@@@@@@@@@.        ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      @@@@@@@@@@@@@@@@@#@@@@@     ",
+				"    @@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"    #@@@@@@     @@@     @@@@@@    ",
+				"      @@@@@*   ;@@@@    @@@@@     ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       @@@@@@@@@@@@@@@@@@@@@      ",
+				"         @@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23, 1, 11,
+				0, 23, 1, 9, 0, 26, 1, 8, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1,
+				1, 2, 3, 0, 1, 2, 4, 1, 4, 0, 5, 1, 11, 0, 23, 1, 12, 0, 21, 1, 15, 0,
+				17, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                +@.               ",
+				"              .@@@@@              ",
+				"         #@@@@@@@@@@@@@@@:        ",
+				"       #@@@@@@@@@@@@@@@@@@@+      ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@     ",
+				"    #@@@@@@*@@@@#@@@@@@@@@@@@@    ",
+				"    *@@@@@@     .@@@     @@@@@    ",
+				"      *@@@@@    @@@@    @@@@@     ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@     ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"         #@@@@@@@@@@@@@@@@*       "
+			],
+			[
+				16, 0, 1, 2, 1, 1, 31, 0, 5, 1, 23, 0, 16, 1, 1, 2, 15, 0, 20, 1, 1, 2,
+				12, 0, 23, 1, 11, 0, 23, 1, 9, 0, 7, 1, 1, 2, 18, 1, 8, 0, 1, 2, 6, 1,
+				6, 0, 3, 1, 5, 0, 5, 1, 10, 0, 6, 1, 4, 0, 4, 1, 4, 0, 5, 1, 11, 0, 1,
+				2, 22, 1, 13, 0, 20, 1, 15, 0, 18, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                .@+               ",
+				"               @@@@@.             ",
+				"         #@@@@@@@@@@@@@@@+        ",
+				"       #@@@@@@@@@@@@@@@@@@@@      ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      #@@@@@@@@@@@@@@@@@#@@@@     ",
+				"    .@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@     *@@@    #@@@@    ",
+				"      #@@@@@@    @@@@    @@@@     ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@     ",
+				"        @@@@@@@@@@@@@@@@@@@@#     ",
+				"          @@@@@@@@@@@@@@@@@       "
+			],
+			[
+				17, 0, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 16, 1, 1, 2, 15, 0, 21, 1, 12, 0,
+				23, 1, 11, 0, 23, 1, 10, 0, 7, 1, 5, 0, 1, 2, 3, 1, 4, 0, 5, 1, 9, 0, 7,
+				1, 5, 0, 1, 2, 3, 1, 4, 0, 5, 1, 10, 0, 7, 1, 4, 0, 4, 1, 4, 0, 4, 1,
+				11, 0, 23, 1, 13, 0, 21, 1, 15, 0, 17, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                .@+               ",
+				"               @@@@@.             ",
+				"         #@@@@@@@@@@@@@@@+        ",
+				"       #@@@@@@@@@@@@@@@@@@@@      ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      #@@@@@@@@@@@@@@@@@#@@@@     ",
+				"    .@@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@     *@@@    #@@@@    ",
+				"      #@@@@@@    @@@@    @@@@     ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@     ",
+				"        @@@@@@@@@@@@@@@@@@@@#     ",
+				"          @@@@@@@@@@@@@@@@@       "
+			],
+			[
+				17, 0, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 16, 1, 1, 2, 15, 0, 21, 1, 12, 0,
+				23, 1, 11, 0, 23, 1, 10, 0, 7, 1, 5, 0, 1, 2, 3, 1, 4, 0, 5, 1, 9, 0, 7,
+				1, 5, 0, 1, 2, 3, 1, 4, 0, 5, 1, 10, 0, 7, 1, 4, 0, 4, 1, 4, 0, 4, 1,
+				11, 0, 23, 1, 13, 0, 21, 1, 15, 0, 17, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                 @*               ",
+				"               @@@@@*             ",
+				"         #@@@@@@@@@@@@@@@*        ",
+				"       *@@@@@@@@@@@@@@@@@@@@      ",
+				"      ##@@@@@@@@@@@@@@@@@@@@@     ",
+				"      @#@@@@@@@@@@@@@@@@@@@@@*    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@     @@@     @@@@    ",
+				"      ##@@@@@    @@@@:   #@@@*    ",
+				"      *#@@@@@@@@@@@@@@@@@@@@@+    ",
+				"        *@@@@@@@@@@@@@@@@@@@@     ",
+				"          +@@@@@@@@@@@@@@@@:      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 5, 1, 1, 2, 22, 0, 16, 1, 1, 2, 15, 0, 1, 2, 20, 1,
+				12, 0, 23, 1, 11, 0, 24, 1, 9, 0, 8, 1, 5, 0, 3, 1, 5, 0, 4, 1, 9, 0, 8,
+				1, 5, 0, 3, 1, 5, 0, 4, 1, 10, 0, 7, 1, 4, 0, 4, 1, 1, 2, 3, 0, 5, 1,
+				10, 0, 1, 2, 22, 1, 1, 2, 12, 0, 21, 1, 15, 0, 1, 2, 16, 1, 1, 2, 6, 0
+			]
+		],
+		[
+			[
+				"                 @#               ",
+				"               @@@@@@             ",
+				"         *@@@@@@@@@@@@@@@*        ",
+				"       :@@@@@@@@@@@@@@@@@@@@      ",
+				"      @#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@     @@@    #@@@    ",
+				"      @@@@@@@@    @@@@    @@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@@    ",
+				"        ##@@@@@@@@@@@@@@@@@@@     ",
+				"           #@@@@@@@@@@@@@@@@      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 15, 1, 1, 2, 15, 0, 1, 2, 20, 1,
+				12, 0, 24, 1, 10, 0, 24, 1, 9, 0, 9, 1, 5, 0, 3, 1, 4, 0, 4, 1, 9, 0, 9,
+				1, 5, 0, 3, 1, 4, 0, 4, 1, 10, 0, 8, 1, 4, 0, 4, 1, 4, 0, 4, 1, 11, 0,
+				23, 1, 12, 0, 21, 1, 16, 0, 17, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 @#               ",
+				"               @@@@@@             ",
+				"         *@@@@@@@@@@@@@@@*        ",
+				"       :@@@@@@@@@@@@@@@@@@@@      ",
+				"      @#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@     @@@    #@@@    ",
+				"      @@@@@@@@    @@@@    @@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@@    ",
+				"        ##@@@@@@@@@@@@@@@@@@@     ",
+				"           #@@@@@@@@@@@@@@@@      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 15, 1, 1, 2, 15, 0, 1, 2, 20, 1,
+				12, 0, 24, 1, 10, 0, 24, 1, 9, 0, 9, 1, 5, 0, 3, 1, 4, 0, 4, 1, 9, 0, 9,
+				1, 5, 0, 3, 1, 4, 0, 4, 1, 10, 0, 8, 1, 4, 0, 4, 1, 4, 0, 4, 1, 11, 0,
+				23, 1, 12, 0, 21, 1, 16, 0, 17, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 #@               ",
+				"               @@@@@@             ",
+				"         +@@@@@@@@@@@@@@@*        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@     @@@     @@@    ",
+				"      @@@@@@@@@   +@@@@   @@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"        +#@@@@@@@@@@@@@@@@@@@     ",
+				"           *@@@@@@@@@@@@@@@@      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 15, 1, 1, 2, 16, 0, 20, 1, 12, 0,
+				24, 1, 10, 0, 24, 1, 9, 0, 9, 1, 5, 0, 3, 1, 5, 0, 3, 1, 9, 0, 9, 1, 5,
+				0, 3, 1, 5, 0, 3, 1, 10, 0, 9, 1, 3, 0, 1, 2, 4, 1, 3, 0, 4, 1, 11, 0,
+				23, 1, 12, 0, 1, 2, 20, 1, 16, 0, 1, 2, 16, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 +@               ",
+				"               *@@@@@             ",
+				"         .@@@@@@@@@@@@@@@;        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     :@@@@@@@@@     @@@    @@@    ",
+				"      :@@@@@@@@@   #@@@    @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@#    ",
+				"           *#@@@@@@@@@@@@@@@*     "
+			],
+			[
+				17, 0, 1, 2, 1, 1, 30, 0, 1, 2, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1,
+				12, 0, 24, 1, 10, 0, 24, 1, 9, 0, 10, 1, 5, 0, 3, 1, 4, 0, 3, 1, 9, 0,
+				1, 2, 9, 1, 5, 0, 3, 1, 4, 0, 3, 1, 10, 0, 1, 2, 9, 1, 3, 0, 4, 1, 4, 0,
+				3, 1, 11, 0, 23, 1, 13, 0, 21, 1, 15, 0, 17, 1, 1, 2, 5, 0
+			]
+		],
+		[
+			[
+				"                 +@               ",
+				"               *@@@@@             ",
+				"         .@@@@@@@@@@@@@@@;        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     :@@@@@@@@@     @@@    @@@    ",
+				"      :@@@@@@@@@   #@@@    @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@#    ",
+				"           *#@@@@@@@@@@@@@@@*     "
+			],
+			[
+				17, 0, 1, 2, 1, 1, 30, 0, 1, 2, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1,
+				12, 0, 24, 1, 10, 0, 24, 1, 9, 0, 10, 1, 5, 0, 3, 1, 4, 0, 3, 1, 9, 0,
+				1, 2, 9, 1, 5, 0, 3, 1, 4, 0, 3, 1, 10, 0, 1, 2, 9, 1, 3, 0, 4, 1, 4, 0,
+				3, 1, 11, 0, 23, 1, 13, 0, 21, 1, 15, 0, 17, 1, 1, 2, 5, 0
+			]
+		],
+		[
+			[
+				"                 ;@               ",
+				"               .@@@@@             ",
+				"          @@@@@@@@@@@@@@#:        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@#@@@@#@@@@@    ",
+				"     +@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@    #@@    @@@    ",
+				"       @@@@@@@@@    @@@#   @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           *#@@@@@@@@@@@@@@@@     "
+			],
+			[
+				17, 0, 1, 2, 1, 1, 31, 0, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1, 12, 0,
+				24, 1, 10, 0, 24, 1, 9, 0, 1, 2, 10, 1, 4, 0, 3, 1, 4, 0, 3, 1, 10, 0,
+				10, 1, 4, 0, 3, 1, 4, 0, 3, 1, 11, 0, 9, 1, 4, 0, 4, 1, 3, 0, 3, 1, 11,
+				0, 23, 1, 13, 0, 21, 1, 15, 0, 1, 2, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  @.              ",
+				"                @@@@@             ",
+				"          @@@@@@@@@@@@@#*         ",
+				"        @@@@@@@@@@@@@@@@@@@@.     ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@#@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@     @@@    @@    ",
+				"       @@@@@@@@@@   @@@@   #@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           .##@@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 31, 0, 5, 1, 23, 0, 15, 1, 17, 0, 20, 1, 12, 0, 24, 1, 10,
+				0, 24, 1, 10, 0, 10, 1, 5, 0, 3, 1, 4, 0, 2, 1, 10, 0, 10, 1, 5, 0, 3,
+				1, 4, 0, 2, 1, 11, 0, 10, 1, 3, 0, 4, 1, 3, 0, 3, 1, 11, 0, 23, 1, 13,
+				0, 21, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  @.              ",
+				"                @@@@@             ",
+				"          @@@@@@@@@@@@@#*         ",
+				"        @@@@@@@@@@@@@@@@@@@@.     ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@#@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@     @@@    @@    ",
+				"       @@@@@@@@@@   @@@@   #@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           .##@@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 31, 0, 5, 1, 23, 0, 15, 1, 17, 0, 20, 1, 12, 0, 24, 1, 10,
+				0, 24, 1, 10, 0, 10, 1, 5, 0, 3, 1, 4, 0, 2, 1, 10, 0, 10, 1, 5, 0, 3,
+				1, 4, 0, 2, 1, 11, 0, 10, 1, 3, 0, 4, 1, 3, 0, 3, 1, 11, 0, 23, 1, 13,
+				0, 21, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #.              ",
+				"                @@@@@             ",
+				"          @@@@@@@@@@@@@#+         ",
+				"        @@@@@@@@@@@@@@@@@@@@.     ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@#@@@@##@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@    #@@    @@    ",
+				"       @@@@@@@@@@    @@@   +@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         *@@@@@@@@@@@@@@@@@@@@    ",
+				"            ##@@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 14, 1, 1, 2, 17, 0, 20, 1, 12, 0,
+				24, 1, 10, 0, 24, 1, 10, 0, 11, 1, 4, 0, 3, 1, 4, 0, 2, 1, 10, 0, 11, 1,
+				4, 0, 3, 1, 4, 0, 2, 1, 11, 0, 10, 1, 4, 0, 3, 1, 3, 0, 1, 2, 2, 1, 11,
+				0, 23, 1, 13, 0, 1, 2, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #:              ",
+				"                @@@@@*            ",
+				"          @@@@@@@@@@@@@#:         ",
+				"        @@@@@@@@@@@@@@@@@@@@.     ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@+    @@@   @@    ",
+				"       @@@@@@@@@@@   @@@@  .@@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 5, 1, 1, 2, 22, 0, 14, 1, 1, 2, 17, 0, 20, 1,
+				12, 0, 1, 2, 23, 1, 10, 0, 24, 1, 10, 0, 12, 1, 4, 0, 3, 1, 3, 0, 2, 1,
+				10, 0, 11, 1, 1, 2, 4, 0, 3, 1, 3, 0, 2, 1, 11, 0, 11, 1, 3, 0, 4, 1, 3,
+				0, 2, 1, 12, 0, 22, 1, 14, 0, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #:              ",
+				"                @@@@@*            ",
+				"          @@@@@@@@@@@@@#:         ",
+				"        @@@@@@@@@@@@@@@@@@@@.     ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@+    @@@   @@    ",
+				"       @@@@@@@@@@@   @@@@  .@@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 5, 1, 1, 2, 22, 0, 14, 1, 1, 2, 17, 0, 20, 1,
+				12, 0, 1, 2, 23, 1, 10, 0, 24, 1, 10, 0, 12, 1, 4, 0, 3, 1, 3, 0, 2, 1,
+				10, 0, 11, 1, 1, 2, 4, 0, 3, 1, 3, 0, 2, 1, 11, 0, 11, 1, 3, 0, 4, 1, 3,
+				0, 2, 1, 12, 0, 22, 1, 14, 0, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #;              ",
+				"                @@@@@#            ",
+				"          @@@@@@@@@@@@@*.         ",
+				"        @@@@@@@@@@@@@@@@@@@@.     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@    @@@   @@    ",
+				"       @@@@@@@@@@@   #@@@  .@@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 6, 1, 22, 0, 14, 1, 18, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 24, 1, 10, 0, 12, 1, 4, 0, 3, 1, 3, 0, 2, 1, 10, 0, 12, 1, 4,
+				0, 3, 1, 3, 0, 2, 1, 11, 0, 11, 1, 3, 0, 4, 1, 3, 0, 2, 1, 12, 0, 22, 1,
+				14, 0, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  +;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@#+          ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@#@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@    #@@   #@    ",
+				"       *@@@@@@@@@@@   @@@   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            +###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 24, 1, 10, 0, 12, 1, 4, 0, 3, 1, 3, 0, 2, 1, 10, 0, 12, 1, 4,
+				0, 3, 1, 3, 0, 2, 1, 11, 0, 12, 1, 3, 0, 3, 1, 3, 0, 2, 1, 12, 0, 22, 1,
+				14, 0, 20, 1, 16, 0, 1, 2, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  +;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@#+          ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@#@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@    #@@   #@    ",
+				"       *@@@@@@@@@@@   @@@   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            +###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 24, 1, 10, 0, 12, 1, 4, 0, 3, 1, 3, 0, 2, 1, 10, 0, 12, 1, 4,
+				0, 3, 1, 3, 0, 2, 1, 11, 0, 12, 1, 3, 0, 3, 1, 3, 0, 2, 1, 12, 0, 22, 1,
+				14, 0, 20, 1, 16, 0, 1, 2, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  +;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@#+          ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@   *@@   #@    ",
+				"       *@@@@@@@@@@@   @@@   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            :###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 1, 2, 23, 1, 10, 0, 13, 1, 3, 0, 1, 2, 2, 1, 3, 0, 2, 1, 10,
+				0, 13, 1, 3, 0, 1, 2, 2, 1, 3, 0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 3, 1,
+				3, 0, 2, 1, 12, 0, 22, 1, 14, 0, 20, 1, 16, 0, 1, 2, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  ;;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#;          ",
+				"        #@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @#@@@@@@@@@@@    @@.  #@    ",
+				"       +@@@@@@@@@@@   #@@*  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          :@@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 1, 2, 23, 1, 10, 0, 13, 1, 4, 0, 2, 1, 1, 2, 2, 0, 2, 1, 10,
+				0, 13, 1, 4, 0, 2, 1, 3, 0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 4, 1, 2, 0,
+				2, 1, 12, 0, 22, 1, 14, 0, 1, 2, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  ;;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#;          ",
+				"        #@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @#@@@@@@@@@@@    @@.  #@    ",
+				"       +@@@@@@@@@@@   #@@*  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          :@@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 10, 0, 1, 2, 23, 1, 10, 0, 13, 1, 4, 0, 2, 1, 1, 2, 2, 0, 2, 1, 10,
+				0, 13, 1, 4, 0, 2, 1, 3, 0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 4, 1, 2, 0,
+				2, 1, 12, 0, 22, 1, 14, 0, 1, 2, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  :;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        #@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@    @@#  #@    ",
+				"       ;@@@@@@@@@@@:  #@@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 13, 1, 4, 0, 3, 1, 2, 0, 2, 1, 10, 0, 13, 1, 4,
+				0, 3, 1, 2, 0, 2, 1, 11, 0, 1, 2, 11, 1, 1, 2, 2, 0, 4, 1, 2, 0, 2, 1,
+				12, 0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  :;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        *@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@    @@@  #@    ",
+				"       :@@@@@@@@@@@@  .@@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 1, 2, 12, 1, 4, 0, 3, 1, 2, 0, 2, 1, 10, 0, 13,
+				1, 4, 0, 3, 1, 2, 0, 2, 1, 11, 0, 1, 2, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1,
+				12, 0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  :;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        *@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@    @@@  #@    ",
+				"       :@@@@@@@@@@@@  .@@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 1, 2, 12, 1, 4, 0, 3, 1, 2, 0, 2, 1, 10, 0, 13,
+				1, 4, 0, 3, 1, 2, 0, 2, 1, 11, 0, 1, 2, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1,
+				12, 0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        *@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;#@@@@@@@@@@@@@@@@@@@@@@.   ",
+				"      +@@@@@@@@@@@@    #@@  #@    ",
+				"       :@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 1, 2, 12, 1, 1, 2, 3, 0, 3, 1, 2, 0, 2, 1, 10,
+				0, 1, 2, 12, 1, 4, 0, 3, 1, 2, 0, 2, 1, 11, 0, 1, 2, 12, 1, 3, 0, 3, 1,
+				2, 0, 2, 1, 12, 0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@#   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 10, 0, 1, 2,
+				13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12,
+				0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@#   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 10, 0, 1, 2,
+				13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12,
+				0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@#@@@@#@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 10, 0, 1, 2,
+				13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12,
+				0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@#@@@@@@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 10, 0, 1, 2,
+				13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12,
+				0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@#@@@@@@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 10, 0, 1, 2,
+				13, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12,
+				0, 22, 1, 15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@#@@@@@@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 13, 1, 3, 0, 7, 1, 10, 0, 1, 2, 13, 1, 3, 0,
+				3, 1, 2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1,
+				15, 0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 23, 1, 10, 0, 1, 2, 13, 1, 3, 0, 3, 1, 2, 0,
+				2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15, 0, 19, 1,
+				17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 23, 1, 10, 0, 1, 2, 13, 1, 3, 0, 3, 1, 2, 0,
+				2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15, 0, 19, 1,
+				17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                #@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@#@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@@   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 23, 1, 10, 0, 1, 2, 13, 1, 3, 0, 3, 1, 2, 0,
+				2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15, 0, 19, 1,
+				17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@:   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 23, 1, 10, 0, 1, 2, 12, 1, 1, 2, 3, 0, 3, 1,
+				2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15, 0,
+				19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        +@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@:   #@@  *@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@#@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 11, 0, 23, 1, 10, 0, 1, 2, 12, 1, 1, 2, 3, 0, 3, 1,
+				2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15, 0,
+				19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  .;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#:          ",
+				"        *@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      :#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      +@@@@@@@@@@@@    @@@  #@    ",
+				"       .@@@@@@@@@@@@   @@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				19, 0, 1, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 1, 2, 19, 1, 13, 0,
+				23, 1, 11, 0, 23, 1, 10, 0, 1, 2, 23, 1, 10, 0, 1, 2, 12, 1, 4, 0, 3, 1,
+				2, 0, 2, 1, 12, 0, 12, 1, 3, 0, 3, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15, 0,
+				19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  :;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#;          ",
+				"        *@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      +@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@    @@@  #@    ",
+				"       :@@@@@@@@@@@;  #@@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 1, 2, 23, 1, 10, 0, 13, 1, 4, 0, 3, 1, 2, 0, 2,
+				1, 11, 0, 1, 2, 11, 1, 1, 2, 2, 0, 4, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15,
+				0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  :;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#;          ",
+				"        *@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      +@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@    @@@  #@    ",
+				"       :@@@@@@@@@@@;  #@@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"           @@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 1, 2, 23, 1, 10, 0, 13, 1, 4, 0, 3, 1, 2, 0, 2,
+				1, 11, 0, 1, 2, 11, 1, 1, 2, 2, 0, 4, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15,
+				0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  :;              ",
+				"                @@@@@@            ",
+				"          #@@@@@@@@@@@#;          ",
+				"        #@@@@@@@@@@@@@@@@@@@.     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@.   ",
+				"      +@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@    @@;  #@    ",
+				"       :@@@@@@@@@@@   #@@@  @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          .@@@@@@@@@@@@@@@@@@@    ",
+				"             ###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 23, 1, 10, 0, 1, 2, 23, 1, 10, 0, 13, 1, 4, 0, 2, 1, 1, 2, 2,
+				0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 4, 1, 2, 0, 2, 1, 12, 0, 22, 1, 15,
+				0, 19, 1, 17, 0, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  ;;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@#+          ",
+				"        #@@@@@@@@@@@@@@@@@@@:     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@.   ",
+				"      #@@@@@@@@@@@@   ;@@   #@    ",
+				"       :@@@@@@@@@@@   @@@   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            :###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 1, 2, 12, 0,
+				23, 1, 10, 0, 1, 2, 23, 1, 1, 2, 9, 0, 24, 1, 10, 0, 13, 1, 3, 0, 1, 2,
+				2, 1, 3, 0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 3, 1, 3, 0, 2, 1, 12, 0, 22,
+				1, 14, 0, 20, 1, 16, 0, 1, 2, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  ;;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@#+          ",
+				"        #@@@@@@@@@@@@@@@@@@@:     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@.   ",
+				"      #@@@@@@@@@@@@   ;@@   #@    ",
+				"       :@@@@@@@@@@@   @@@   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            :###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 1, 2, 12, 0,
+				23, 1, 10, 0, 1, 2, 23, 1, 1, 2, 9, 0, 24, 1, 10, 0, 13, 1, 3, 0, 1, 2,
+				2, 1, 3, 0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 3, 1, 3, 0, 2, 1, 12, 0, 22,
+				1, 14, 0, 20, 1, 16, 0, 1, 2, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  +;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@@*          ",
+				"        #@@@@@@@@@@@@@@@@@@@;     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ;@@@@@@@@@@@@@@#@@@@@@@@;   ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      @@@@@@@@@@@@    #@@   #@    ",
+				"       ;@@@@@@@@@@@   @@@   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ;###@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 13, 1, 1, 2, 18, 0, 20, 1, 1, 2, 12, 0,
+				23, 1, 10, 0, 1, 2, 23, 1, 1, 2, 9, 0, 24, 1, 1, 2, 9, 0, 12, 1, 4, 0,
+				3, 1, 3, 0, 2, 1, 11, 0, 1, 2, 11, 1, 3, 0, 3, 1, 3, 0, 2, 1, 12, 0, 22,
+				1, 14, 0, 20, 1, 16, 0, 1, 2, 16, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  *;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@@*.         ",
+				"        #@@@@@@@@@@@@@@@@@@@+     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@@@@@@@@#@@@;   ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      @@@@@@@@@@@@    @@@   #@.   ",
+				"       #@@@@@@@@@@   +@@@  .@@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 14, 1, 18, 0, 20, 1, 1, 2, 12, 0, 23,
+				1, 10, 0, 24, 1, 1, 2, 9, 0, 24, 1, 1, 2, 9, 0, 12, 1, 4, 0, 3, 1, 3, 0,
+				2, 1, 11, 0, 11, 1, 3, 0, 1, 2, 3, 1, 3, 0, 2, 1, 12, 0, 22, 1, 14, 0,
+				20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  *;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@@*.         ",
+				"        #@@@@@@@@@@@@@@@@@@@+     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      *@@@@@@@@@@@@@@@@@@@#@@@;   ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      @@@@@@@@@@@@    @@@   #@.   ",
+				"       #@@@@@@@@@@   +@@@  .@@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 2, 2, 30, 0, 6, 1, 22, 0, 14, 1, 18, 0, 20, 1, 1, 2, 12, 0, 23,
+				1, 10, 0, 24, 1, 1, 2, 9, 0, 24, 1, 1, 2, 9, 0, 12, 1, 4, 0, 3, 1, 3, 0,
+				2, 1, 11, 0, 11, 1, 3, 0, 1, 2, 3, 1, 3, 0, 2, 1, 12, 0, 22, 1, 14, 0,
+				20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  *;              ",
+				"                @@@@@@            ",
+				"          @@@@@@@@@@@@@#:         ",
+				"        @@@@@@@@@@@@@@@@@@@@*     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@@@@@@#@@@;   ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@;   ",
+				"      @@@@@@@@@@@@    @@@   @@:   ",
+				"       @@@@@@@@@@@   #@@@  .@@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 6, 1, 22, 0, 14, 1, 1, 2, 17, 0, 20, 1, 1, 2,
+				12, 0, 23, 1, 10, 0, 24, 1, 1, 2, 9, 0, 24, 1, 1, 2, 9, 0, 12, 1, 4, 0,
+				3, 1, 3, 0, 2, 1, 1, 2, 10, 0, 11, 1, 3, 0, 4, 1, 3, 0, 2, 1, 12, 0, 22,
+				1, 14, 0, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #:              ",
+				"                @@@@@+            ",
+				"          @@@@@@@@@@@@@#+         ",
+				"        @@@@@@@@@@@@@@@@@@@@*     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@:   ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      #@@@@@@@@@@    #@@    @@.   ",
+				"       @@@@@@@@@@*   @@@*   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 5, 1, 1, 2, 22, 0, 14, 1, 1, 2, 17, 0, 21, 1,
+				12, 0, 23, 1, 10, 0, 24, 1, 1, 2, 9, 0, 24, 1, 1, 2, 9, 0, 11, 1, 4, 0,
+				3, 1, 4, 0, 2, 1, 11, 0, 10, 1, 1, 2, 3, 0, 3, 1, 1, 2, 3, 0, 2, 1, 12,
+				0, 22, 1, 14, 0, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #:              ",
+				"                @@@@@+            ",
+				"          @@@@@@@@@@@@@#+         ",
+				"        @@@@@@@@@@@@@@@@@@@@*     ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@:   ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      #@@@@@@@@@@    #@@    @@.   ",
+				"       @@@@@@@@@@*   @@@*   @@    ",
+				"        @@@@@@@@@@@@@@@@@@@@@@    ",
+				"          @@@@@@@@@@@@@@@@@@@@    ",
+				"            ###@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 5, 1, 1, 2, 22, 0, 14, 1, 1, 2, 17, 0, 21, 1,
+				12, 0, 23, 1, 10, 0, 24, 1, 1, 2, 9, 0, 24, 1, 1, 2, 9, 0, 11, 1, 4, 0,
+				3, 1, 4, 0, 2, 1, 11, 0, 10, 1, 1, 2, 3, 0, 3, 1, 1, 2, 3, 0, 2, 1, 12,
+				0, 22, 1, 14, 0, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  #:              ",
+				"                @@@@@:            ",
+				"          @@@@@@@@@@@@@#*         ",
+				"        @@@@@@@@@@@@@@@@@@@@*     ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@.   ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@:   ",
+				"      @@@@@@@@@@@    @@@    @@.   ",
+				"       @@@@@@@@@@   :@@@   :@@    ",
+				"       ;@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ;@@@@@@@@@@@@@@@@@@@@    ",
+				"            ##@@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 1, 2, 30, 0, 5, 1, 1, 2, 22, 0, 14, 1, 1, 2, 17, 0, 20, 1,
+				1, 2, 12, 0, 23, 1, 10, 0, 24, 1, 10, 0, 24, 1, 1, 2, 9, 0, 11, 1, 4, 0,
+				3, 1, 4, 0, 2, 1, 11, 0, 10, 1, 3, 0, 1, 2, 3, 1, 3, 0, 1, 2, 2, 1, 11,
+				0, 1, 2, 22, 1, 13, 0, 1, 2, 20, 1, 16, 0, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  @.              ",
+				"                @@@@@             ",
+				"          @@@@@@@@@@@@@@#:        ",
+				"        @@@@@@@@@@@@@@@@@@@@+     ",
+				"      ;@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@     @@@   .@@    ",
+				"       @@@@@@@@@*   @@@@   @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           ;##@@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 31, 0, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1, 1, 2, 11, 0,
+				1, 2, 23, 1, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 10, 1, 5, 0, 3, 1, 4, 0,
+				2, 1, 11, 0, 10, 1, 3, 0, 4, 1, 3, 0, 3, 1, 11, 0, 23, 1, 13, 0, 21, 1,
+				15, 0, 1, 2, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                  @.              ",
+				"                @@@@@             ",
+				"          @@@@@@@@@@@@@@#:        ",
+				"        @@@@@@@@@@@@@@@@@@@@+     ",
+				"      ;@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@#@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@     @@@   .@@    ",
+				"       @@@@@@@@@*   @@@@   @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           ;##@@@@@@@@@@@@@@@     "
+			],
+			[
+				18, 0, 1, 1, 31, 0, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1, 1, 2, 11, 0,
+				1, 2, 23, 1, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 10, 1, 5, 0, 3, 1, 4, 0,
+				2, 1, 11, 0, 10, 1, 3, 0, 4, 1, 3, 0, 3, 1, 11, 0, 23, 1, 13, 0, 21, 1,
+				15, 0, 1, 2, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                 .@               ",
+				"                @@@@@             ",
+				"          @@@@@@@@@@@@@@#;        ",
+				"        @@@@@@@@@@@@@@@@@@@@;     ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@#@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@    #@@    #@@    ",
+				"       @@@@@@@@@    @@@@   @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           +#@@@@@@@@@@@@@@@@     "
+			],
+			[
+				17, 0, 1, 2, 1, 1, 31, 0, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1, 1, 2,
+				11, 0, 1, 2, 23, 1, 10, 0, 24, 1, 10, 0, 24, 1, 10, 0, 10, 1, 4, 0, 3,
+				1, 4, 0, 3, 1, 11, 0, 9, 1, 4, 0, 4, 1, 3, 0, 3, 1, 11, 0, 23, 1, 13, 0,
+				21, 1, 15, 0, 1, 2, 17, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                 +@               ",
+				"               ;@@@@@             ",
+				"          @@@@@@@@@@@@@@@+        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     #@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     .@@@@@@@@@     @@@    @@@    ",
+				"       @@@@@@@@    @@@@    @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           *#@@@@@@@@@@@@@@@*     "
+			],
+			[
+				17, 0, 1, 2, 1, 1, 30, 0, 1, 2, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1,
+				12, 0, 24, 1, 10, 0, 24, 1, 9, 0, 25, 1, 10, 0, 9, 1, 5, 0, 3, 1, 4, 0,
+				3, 1, 11, 0, 8, 1, 4, 0, 4, 1, 4, 0, 3, 1, 11, 0, 23, 1, 13, 0, 21, 1,
+				15, 0, 18, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                 +@               ",
+				"               ;@@@@@             ",
+				"          @@@@@@@@@@@@@@@+        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     #@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     .@@@@@@@@@     @@@    @@@    ",
+				"       @@@@@@@@    @@@@    @@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         ##@@@@@@@@@@@@@@@@@@@    ",
+				"           *#@@@@@@@@@@@@@@@*     "
+			],
+			[
+				17, 0, 1, 2, 1, 1, 30, 0, 1, 2, 5, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1,
+				12, 0, 24, 1, 10, 0, 24, 1, 9, 0, 25, 1, 10, 0, 9, 1, 5, 0, 3, 1, 4, 0,
+				3, 1, 11, 0, 8, 1, 4, 0, 4, 1, 4, 0, 3, 1, 11, 0, 23, 1, 13, 0, 21, 1,
+				15, 0, 18, 1, 5, 0
+			]
+		],
+		[
+			[
+				"                 *@               ",
+				"               #@@@@@             ",
+				"          @@@@@@@@@@@@@@@*        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      @@@@@@@@@@@@#@@@@@@#@@@@    ",
+				"     @@@@@@@@@@@@@@@@@*@@@@@@@    ",
+				"     *@@@@@@@@#    #@@+    @@@    ",
+				"       @@@@@@@@    @@@@   +@@@    ",
+				"       @@@@@@@@@@@@@@@@@@@@@@@    ",
+				"         #@@@@@@@@@@@@@@@@@@@*    ",
+				"           *@@@@@@@@@@@@@@@@:     "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 23, 0, 15, 1, 1, 2, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 9, 0, 10, 1, 4, 0, 11, 1, 9, 0, 10, 1, 4, 0, 3, 1, 1,
+				2, 4, 0, 3, 1, 11, 0, 8, 1, 4, 0, 4, 1, 3, 0, 1, 2, 3, 1, 11, 0, 23, 1,
+				13, 0, 21, 1, 15, 0, 17, 1, 1, 2, 5, 0
+			]
+		],
+		[
+			[
+				"                 @@               ",
+				"               @@@@@@             ",
+				"         :@@@@@@@@@@@@@@@*        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@     @@@    *@@@    ",
+				"      +#@@@@@@    #@@@    @@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@@    ",
+				"        *#@@@@@@@@@@@@@@@@@@@     ",
+				"          .#@@@@@@@@@@@@@@@@      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 16, 1, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 9, 0, 9, 1, 5, 0, 3, 1, 4, 0, 1, 2, 3, 1, 9, 0, 9, 1,
+				5, 0, 3, 1, 4, 0, 1, 2, 3, 1, 10, 0, 1, 2, 7, 1, 4, 0, 4, 1, 4, 0, 4, 1,
+				11, 0, 23, 1, 12, 0, 21, 1, 16, 0, 17, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 @@               ",
+				"               @@@@@@             ",
+				"         :@@@@@@@@@@@@@@@*        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      @#@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@@     @@@    *@@@    ",
+				"      +#@@@@@@    #@@@    @@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@@    ",
+				"        *#@@@@@@@@@@@@@@@@@@@     ",
+				"          .#@@@@@@@@@@@@@@@@      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 16, 1, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 9, 0, 9, 1, 5, 0, 3, 1, 4, 0, 1, 2, 3, 1, 9, 0, 9, 1,
+				5, 0, 3, 1, 4, 0, 1, 2, 3, 1, 10, 0, 1, 2, 7, 1, 4, 0, 4, 1, 4, 0, 4, 1,
+				11, 0, 23, 1, 12, 0, 21, 1, 16, 0, 17, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 @@               ",
+				"               @@@@@@             ",
+				"         ;@@@@@@@@@@@@@@@*        ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"      ##@@@@@@@@@@@@@@@@@@@@@@    ",
+				"      ##@@@@@@@@@#@@@@@@@@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@.    *@@@    @@@@    ",
+				"      ##@@@@@@    @@@@    @@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@@    ",
+				"        *@@@@@@@@@@@@@@@@@@@@     ",
+				"          ;@@@@@@@@@@@@@@@@@      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 16, 1, 16, 0, 20, 1, 12, 0, 24,
+				1, 10, 0, 24, 1, 9, 0, 8, 1, 5, 0, 1, 2, 3, 1, 4, 0, 4, 1, 9, 0, 8, 1,
+				5, 0, 4, 1, 4, 0, 4, 1, 10, 0, 8, 1, 4, 0, 4, 1, 4, 0, 4, 1, 11, 0, 23,
+				1, 12, 0, 21, 1, 15, 0, 1, 2, 17, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 @#               ",
+				"               @@@@@#             ",
+				"         +@@@@@@@@@@@@@@@+        ",
+				"       :@@@@@@@@@@@@@@@@@@@@      ",
+				"      ##@@@@@@@@@@@@@@@@@@@@@:    ",
+				"      ##@@@@@@@@@@@@@@@@#@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@     @@@     @@@@    ",
+				"      ##@@@@@    #@@@    #@@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@#    ",
+				"        *@@@@@@@@@@@@@@@@@@@@     ",
+				"          #@@@@@@@@@@@@@@@@#      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 15, 1, 1, 2, 15, 0, 1, 2, 20, 1,
+				12, 0, 23, 1, 1, 2, 10, 0, 24, 1, 9, 0, 8, 1, 5, 0, 3, 1, 5, 0, 4, 1, 9,
+				0, 8, 1, 5, 0, 3, 1, 5, 0, 4, 1, 10, 0, 7, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				11, 0, 23, 1, 12, 0, 21, 1, 15, 0, 18, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 @#               ",
+				"               @@@@@#             ",
+				"         +@@@@@@@@@@@@@@@+        ",
+				"       :@@@@@@@@@@@@@@@@@@@@      ",
+				"      ##@@@@@@@@@@@@@@@@@@@@@:    ",
+				"      ##@@@@@@@@@@@@@@@@#@@@@@    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@@     @@@     @@@@    ",
+				"      ##@@@@@    #@@@    #@@@@    ",
+				"       #@@@@@@@@@@@@@@@@@@@@@#    ",
+				"        *@@@@@@@@@@@@@@@@@@@@     ",
+				"          #@@@@@@@@@@@@@@@@#      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 6, 1, 22, 0, 1, 2, 15, 1, 1, 2, 15, 0, 1, 2, 20, 1,
+				12, 0, 23, 1, 1, 2, 10, 0, 24, 1, 9, 0, 8, 1, 5, 0, 3, 1, 5, 0, 4, 1, 9,
+				0, 8, 1, 5, 0, 3, 1, 5, 0, 4, 1, 10, 0, 7, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				11, 0, 23, 1, 12, 0, 21, 1, 15, 0, 18, 1, 6, 0
+			]
+		],
+		[
+			[
+				"                 @#               ",
+				"               @@@@@+             ",
+				"         *@@@@@@@@@@@@@@@;        ",
+				"       +@@@@@@@@@@@@@@@@@@@@      ",
+				"      #@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      #@@@@@@#@@#@@@@@@@#@@@@:    ",
+				"     @@@@@@@@@@@@@@@@@@@@@@@@@    ",
+				"     @@@@@@@.    .@@@    .@@@@    ",
+				"      #@@@@@@    @@@@    @@@@:    ",
+				"      .@@@@@@@@@@@@@@@@@@@@@@.    ",
+				"        #@@@@@@@@@@@@@@@@@@@@     ",
+				"          @@@@@@@@@@@@@@@@@:      "
+			],
+			[
+				17, 0, 2, 1, 30, 0, 5, 1, 1, 2, 22, 0, 1, 2, 15, 1, 1, 2, 15, 0, 1, 2,
+				20, 1, 12, 0, 23, 1, 11, 0, 23, 1, 1, 2, 9, 0, 7, 1, 1, 2, 5, 0, 3, 1,
+				5, 0, 4, 1, 9, 0, 7, 1, 6, 0, 3, 1, 5, 0, 4, 1, 10, 0, 7, 1, 4, 0, 4, 1,
+				4, 0, 4, 1, 1, 2, 11, 0, 22, 1, 13, 0, 21, 1, 15, 0, 17, 1, 1, 2, 6, 0
+			]
+		],
+		[
+			[
+				"                ;@+               ",
+				"               @@@@@              ",
+				"         #@@@@@@@@@@@@@@@.        ",
+				"       #@@@@@@@@@@@@@@@@@@@#      ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      *@@@@@@  .@@@@@* ;@@@@@     ",
+				"     @@@@@@@     @@@     @@@@@    ",
+				"     @@@@@@@     @@@     @@@@@    ",
+				"      *@@@@@    ;@@@#    @@@@     ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@     ",
+				"        @@@@@@@@@@@@@@@@@@@@:     ",
+				"         +@@@@@@@@@@@@@@@@@       "
+			],
+			[
+				16, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 16, 1, 16, 0, 21, 1, 12, 0,
+				1, 2, 22, 1, 11, 0, 1, 2, 6, 1, 3, 0, 5, 1, 1, 2, 1, 0, 1, 2, 5, 1, 10,
+				0, 7, 1, 5, 0, 3, 1, 5, 0, 5, 1, 9, 0, 7, 1, 5, 0, 3, 1, 5, 0, 5, 1, 10,
+				0, 1, 2, 5, 1, 4, 0, 1, 2, 4, 1, 4, 0, 4, 1, 11, 0, 1, 2, 22, 1, 13, 0,
+				20, 1, 1, 2, 14, 0, 1, 2, 17, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                ;@+               ",
+				"               @@@@@              ",
+				"         #@@@@@@@@@@@@@@@.        ",
+				"       #@@@@@@@@@@@@@@@@@@@#      ",
+				"      *@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      *@@@@@@  .@@@@@* ;@@@@@     ",
+				"     @@@@@@@     @@@     @@@@@    ",
+				"     @@@@@@@     @@@     @@@@@    ",
+				"      *@@@@@    ;@@@#    @@@@     ",
+				"      :@@@@@@@@@@@@@@@@@@@@@@     ",
+				"        @@@@@@@@@@@@@@@@@@@@:     ",
+				"         +@@@@@@@@@@@@@@@@@       "
+			],
+			[
+				16, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 16, 1, 16, 0, 21, 1, 12, 0,
+				1, 2, 22, 1, 11, 0, 1, 2, 6, 1, 3, 0, 5, 1, 1, 2, 1, 0, 1, 2, 5, 1, 10,
+				0, 7, 1, 5, 0, 3, 1, 5, 0, 5, 1, 9, 0, 7, 1, 5, 0, 3, 1, 5, 0, 5, 1, 10,
+				0, 1, 2, 5, 1, 4, 0, 1, 2, 4, 1, 4, 0, 4, 1, 11, 0, 1, 2, 22, 1, 13, 0,
+				20, 1, 1, 2, 14, 0, 1, 2, 17, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                *@:               ",
+				"               @@@@@              ",
+				"         #@@@@@@@@@@@@@@@.        ",
+				"       #@@@@@@@@@@@@@@@@@@@+      ",
+				"      +@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      +@@@@@@  ;@@@@@  ;@@@@@     ",
+				"    .@@@@@@@     @@@     @@@@@    ",
+				"    :@@@@@@@     @@@     @@@@@    ",
+				"      +@@@@@    @@@@    +@@@@     ",
+				"      ;@@@@@@@@@@@@@@@@@@@@@@     ",
+				"        @@@@@@@@@@@@@@@@@@@@      ",
+				"         @@@@@@@@@@@@@@@@@@       "
+			],
+			[
+				16, 0, 1, 2, 1, 1, 1, 2, 30, 0, 5, 1, 23, 0, 16, 1, 16, 0, 20, 1, 1, 2,
+				12, 0, 1, 2, 22, 1, 11, 0, 1, 2, 6, 1, 2, 0, 1, 2, 5, 1, 2, 0, 1, 2, 5,
+				1, 10, 0, 7, 1, 5, 0, 3, 1, 5, 0, 5, 1, 8, 0, 1, 2, 7, 1, 5, 0, 3, 1, 5,
+				0, 5, 1, 10, 0, 1, 2, 5, 1, 4, 0, 4, 1, 4, 0, 1, 2, 4, 1, 11, 0, 1, 2,
+				22, 1, 13, 0, 20, 1, 15, 0, 18, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                #@.               ",
+				"              +@@@@@              ",
+				"         #@@@@@@@@@@@@@@@         ",
+				"       #@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      #@@@@@.  @@@@@@  #@@@@@     ",
+				"    +@@@@@@     @@@*    :@@@@@    ",
+				"    *@@@@@@     @@@*    :@@@@@    ",
+				"      *@@@@@    @@@@    @@@@@     ",
+				"      +@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       #@@@@@@@@@@@@@@@@@@@@      ",
+				"         @@@@@@@@@@@@@@@@@@       "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 1, 2, 5, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 6, 1, 3, 0, 6, 1, 2, 0, 6, 1, 9, 0, 1, 2, 6, 1, 5, 0, 3, 1, 1,
+				2, 4, 0, 1, 2, 5, 1, 8, 0, 7, 1, 5, 0, 3, 1, 1, 2, 4, 0, 1, 2, 5, 1, 10,
+				0, 1, 2, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 11, 0, 1, 2, 22, 1, 12, 0, 21, 1,
+				15, 0, 18, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                #@.               ",
+				"              +@@@@@              ",
+				"         #@@@@@@@@@@@@@@@         ",
+				"       #@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      #@@@@@.  @@@@@@  #@@@@@     ",
+				"    +@@@@@@     @@@*    :@@@@@    ",
+				"    *@@@@@@     @@@*    :@@@@@    ",
+				"      *@@@@@    @@@@    @@@@@     ",
+				"      +@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       #@@@@@@@@@@@@@@@@@@@@      ",
+				"         @@@@@@@@@@@@@@@@@@       "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 1, 2, 5, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23,
+				1, 11, 0, 6, 1, 3, 0, 6, 1, 2, 0, 6, 1, 9, 0, 1, 2, 6, 1, 5, 0, 3, 1, 1,
+				2, 4, 0, 1, 2, 5, 1, 8, 0, 7, 1, 5, 0, 3, 1, 1, 2, 4, 0, 1, 2, 5, 1, 10,
+				0, 1, 2, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 11, 0, 1, 2, 22, 1, 12, 0, 21, 1,
+				15, 0, 18, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                #@                ",
+				"              #@@@@@              ",
+				"         #@@@@@@@@@@@@@@@         ",
+				"       #@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"      @@@@@@   @@@@@*  @@@@@@     ",
+				"    *@@@@@@     @@@     #@@@@@    ",
+				"    #@@@@@@     @@@     #@@@@@    ",
+				"      @@@@@;    @@@@    @@@@@     ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       @@@@@@@@@@@@@@@@@@@@@      ",
+				"         @@@@@@@@@@@@@@@@@*       "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23, 1, 11,
+				0, 6, 1, 3, 0, 5, 1, 1, 2, 2, 0, 6, 1, 9, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6,
+				1, 8, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 1, 2, 4, 0, 4, 1, 4,
+				0, 5, 1, 11, 0, 23, 1, 12, 0, 21, 1, 15, 0, 18, 1, 7, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         #@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@#     ",
+				"      @@@@@@   @@@@@   @@@@@@     ",
+				"    #@@@@@@     @@@     @@@@@@    ",
+				"    @@@@@@@     @@@     @@@@@@    ",
+				"      @@@@@    +@@@+    @@@@@     ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       @@@@@@@@@@@@@@@@@@@@@      ",
+				"        :@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23, 1, 11,
+				0, 6, 1, 3, 0, 5, 1, 3, 0, 6, 1, 9, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 8,
+				0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 1, 2, 3, 1, 1, 2, 4,
+				0, 5, 1, 11, 0, 23, 1, 12, 0, 21, 1, 14, 0, 1, 2, 17, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         #@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@#     ",
+				"      @@@@@@   @@@@@   @@@@@@     ",
+				"    #@@@@@@     @@@     @@@@@@    ",
+				"    @@@@@@@     @@@     @@@@@@    ",
+				"      @@@@@    +@@@+    @@@@@     ",
+				"      @@@@@@@@@@@@@@@@@@@@@@@     ",
+				"       @@@@@@@@@@@@@@@@@@@@@      ",
+				"        :@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 23, 1, 11,
+				0, 6, 1, 3, 0, 5, 1, 3, 0, 6, 1, 9, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 8,
+				0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 1, 2, 3, 1, 1, 2, 4,
+				0, 5, 1, 11, 0, 23, 1, 12, 0, 21, 1, 14, 0, 1, 2, 17, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         #@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@;     ",
+				"      @@@@@@  .@@@@@   @@@@@*     ",
+				"    #@@@@@@     @@@     @@@@@@    ",
+				"    @@@@@@@     @@@     @@@@@@    ",
+				"      @@@@@    #@@@     @@@@#     ",
+				"      @@@@@@@@@@@@@@@@@@@@@@#     ",
+				"       @@@@@@@@@@@@@@@@@@@@@      ",
+				"        +@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 1,
+				2, 11, 0, 6, 1, 3, 0, 5, 1, 3, 0, 6, 1, 9, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6,
+				1, 8, 0, 7, 1, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 5, 0, 5,
+				1, 11, 0, 23, 1, 12, 0, 21, 1, 14, 0, 1, 2, 17, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@#  ;@@@@@   @@@@@      ",
+				"    @@@@@@+     @@@     @@@@@@    ",
+				"    @@@@@@*     @@@     @@@@@@    ",
+				"      @@@@@    @@@@    *@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@#      ",
+				"        #@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 6, 1, 2, 0, 1, 2, 5, 1, 3, 0, 5, 1, 10, 0, 6, 1, 1, 2, 5, 0, 3, 1, 5,
+				0, 6, 1, 8, 0, 6, 1, 1, 2, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4,
+				1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 21, 1, 14, 0, 18, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@#  ;@@@@@   @@@@@      ",
+				"    @@@@@@+     @@@     @@@@@@    ",
+				"    @@@@@@*     @@@     @@@@@@    ",
+				"      @@@@@    @@@@    *@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@#      ",
+				"        #@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 6, 1, 2, 0, 1, 2, 5, 1, 3, 0, 5, 1, 10, 0, 6, 1, 1, 2, 5, 0, 3, 1, 5,
+				0, 6, 1, 8, 0, 6, 1, 1, 2, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4,
+				1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 21, 1, 14, 0, 18, 1, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@+  +@@@@@   @@@@@      ",
+				"    @@@@@@:     @@@     @@@@@@    ",
+				"    @@@@@@:     @@@     @@@@@@    ",
+				"      @@@@@    @@@@    #@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@;      ",
+				"        #@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 1, 2, 2, 0, 1, 2, 5, 1, 3, 0, 5, 1, 10, 0, 6, 1, 1, 2, 5, 0, 3,
+				1, 5, 0, 6, 1, 8, 0, 6, 1, 1, 2, 5, 0, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4,
+				0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 1, 2, 14, 0, 18, 1, 8,
+				0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   :@@@@*   @@@@@      ",
+				"    @@@@@@     ;@@@     @@@@@@    ",
+				"    @@@@@@     ;@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        *@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 3, 0, 1, 2, 4, 1, 1, 2, 3, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3,
+				1, 5, 0, 6, 1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4,
+				0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 1, 2, 17, 1, 8,
+				0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   :@@@@*   @@@@@      ",
+				"    @@@@@@     ;@@@     @@@@@@    ",
+				"    @@@@@@     ;@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        *@@@@@@@@@@@@@@@@@        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 3, 0, 1, 2, 4, 1, 1, 2, 3, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3,
+				1, 5, 0, 6, 1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4,
+				0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 1, 2, 17, 1, 8,
+				0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   :@@@@;   @@@@@      ",
+				"    @@@@@@     +@@@     @@@@@@    ",
+				"    @@@@@@     +@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        +@@@@@@@@@@@@@@@@#        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 3, 0, 1, 2, 4, 1, 1, 2, 3, 0, 5, 1, 10, 0, 6, 1, 5, 0, 1, 2, 3,
+				1, 5, 0, 6, 1, 8, 0, 6, 1, 5, 0, 1, 2, 3, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4,
+				0, 4, 1, 4, 0, 5, 1, 12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 1, 2, 17, 1, 8,
+				0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   .@@@@    @@@@@      ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        :@@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 1, 2, 16, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@   .@@@@    @@@@@      ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        :@@@@@@@@@@@@@@@@+        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 15, 0, 1, 2, 16, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"        .@@@@@@@@@@@@@@@@;        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 1, 2, 8, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@.        "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@         "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@         "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		],
+		[
+			[
+				"                @@                ",
+				"              @@@@@@              ",
+				"         @@@@@@@@@@@@@@@@         ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"    @@@@@@     #@@#     @@@@@@    ",
+				"    @@@@@@     #@@@     @@@@@@    ",
+				"      @@@@@    @@@@    @@@@@      ",
+				"      @@@@@@@@@@@@@@@@@@@@@@      ",
+				"       @@@@@@@@@@@@@@@@@@@@       ",
+				"         @@@@@@@@@@@@@@@@         "
+			],
+			[
+				16, 0, 2, 1, 30, 0, 6, 1, 23, 0, 16, 1, 16, 0, 20, 1, 13, 0, 22, 1, 12,
+				0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1, 10, 0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 8,
+				0, 6, 1, 5, 0, 4, 1, 5, 0, 6, 1, 10, 0, 5, 1, 4, 0, 4, 1, 4, 0, 5, 1,
+				12, 0, 22, 1, 13, 0, 20, 1, 16, 0, 16, 1, 9, 0
+			]
+		]
+	]
+}
diff --git a/apps/cli/src/tui/components/robot-frames.ts b/apps/cli/src/tui/components/robot-frames.ts
new file mode 100644
index 0000000..34d2253
--- /dev/null
+++ b/apps/cli/src/tui/components/robot-frames.ts
@@ -0,0 +1,73 @@
+import encodedFrames from "./robot-frames.generated.json";
+
+export interface CroppedFrame {
+	rows: string[];
+	colors: Record<string, string>;
+}
+
+interface EncodedRobotFrames {
+	schema: 1;
+	width: number;
+	height: number;
+	palette: string[];
+	frames: [rows: string[], colorRuns: number[]][];
+}
+
+function decodeRunLengthColors(
+	colorRuns: number[],
+	palette: string[],
+	width: number,
+	height: number,
+): Record<string, string> {
+	const colors: Record<string, string> = {};
+	let cellIndex = 0;
+
+	for (let offset = 0; offset < colorRuns.length; offset += 2) {
+		const count = colorRuns[offset];
+		const paletteIndex = colorRuns[offset + 1];
+		if (count === undefined || paletteIndex === undefined) {
+			throw new Error(`Invalid robot frame color run at offset ${offset}`);
+		}
+
+		const color = palette[paletteIndex];
+		if (!color) {
+			throw new Error(`Unknown robot frame palette index ${paletteIndex}`);
+		}
+
+		for (let i = 0; i < count; i++) {
+			const x = cellIndex % width;
+			const y = Math.floor(cellIndex / width);
+			colors[`${x},${y}`] = color;
+			cellIndex++;
+		}
+	}
+
+	const expectedCells = width * height;
+	if (cellIndex !== expectedCells) {
+		throw new Error(
+			`Robot frame decoded to ${cellIndex} cells, expected ${expectedCells}`,
+		);
+	}
+
+	return colors;
+}
+
+function decodeRobotFrames(encoded: EncodedRobotFrames): CroppedFrame[] {
+	if (encoded.schema !== 1) {
+		throw new Error(`Unsupported robot frame schema ${encoded.schema}`);
+	}
+
+	return encoded.frames.map(([rows, colorRuns]) => ({
+		rows,
+		colors: decodeRunLengthColors(
+			colorRuns,
+			encoded.palette,
+			encoded.width,
+			encoded.height,
+		),
+	}));
+}
+
+export const FRAMES: CroppedFrame[] = decodeRobotFrames(
+	encodedFrames as EncodedRobotFrames,
+);
diff --git a/apps/cli/src/tui/components/searchable-list.test.ts b/apps/cli/src/tui/components/searchable-list.test.ts
new file mode 100644
index 0000000..2fd60c5
--- /dev/null
+++ b/apps/cli/src/tui/components/searchable-list.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildSearchableListRows,
+	getSearchableListRowsWindow,
+	type SearchableItem,
+} from "./searchable-list";
+
+function rowLabels(items: SearchableItem[]): string[] {
+	return buildSearchableListRows(items).map((row) =>
+		row.kind === "header" ? `header:${row.label}` : `item:${row.item.key}`,
+	);
+}
+
+describe("searchable list sections", () => {
+	it("adds section headers as separate rows", () => {
+		expect(
+			rowLabels([
+				{ key: "cline", label: "Cline", section: "Popular" },
+				{ key: "anthropic", label: "Anthropic", section: "Popular" },
+				{ key: "deepseek", label: "DeepSeek", section: "Other" },
+			]),
+		).toEqual([
+			"header:Popular",
+			"item:cline",
+			"item:anthropic",
+			"header:Other",
+			"item:deepseek",
+		]);
+	});
+
+	it("keeps window counts based on selectable items", () => {
+		const items: SearchableItem[] = [
+			{ key: "cline", label: "Cline", section: "Popular" },
+			{ key: "anthropic", label: "Anthropic", section: "Popular" },
+			{ key: "openrouter", label: "OpenRouter", section: "Popular" },
+			{ key: "deepseek", label: "DeepSeek", section: "Other" },
+			{ key: "zai", label: "Zai", section: "Other" },
+		];
+
+		const listWindow = getSearchableListRowsWindow(items, 4, 4);
+
+		expect(listWindow.showAbove).toBe(true);
+		expect(listWindow.aboveCount).toBeGreaterThan(0);
+		expect(
+			listWindow.visibleRows.some(
+				(row) => row.kind === "item" && row.item.key === "zai",
+			),
+		).toBe(true);
+		expect(listWindow.visibleRows.every((row) => row.kind !== "header")).toBe(
+			false,
+		);
+	});
+
+	it("does not hide only a section header before showing the above indicator", () => {
+		const items: SearchableItem[] = [
+			{ key: "cline", label: "Cline", section: "Popular" },
+			{ key: "openai-codex", label: "ChatGPT", section: "Popular" },
+			{ key: "deepseek", label: "DeepSeek", section: "Popular" },
+			{ key: "anthropic", label: "Anthropic", section: "Popular" },
+			{ key: "openrouter", label: "OpenRouter", section: "Popular" },
+			{ key: "ollama", label: "Ollama", section: "Popular" },
+			{ key: "bedrock", label: "Bedrock", section: "Popular" },
+			{ key: "litellm", label: "LiteLLM", section: "Popular" },
+			{ key: "gemini", label: "Gemini", section: "Popular" },
+			{ key: "zai", label: "Zai", section: "Other" },
+		];
+
+		const listWindow = getSearchableListRowsWindow(items, 4, 10);
+
+		expect(listWindow.showAbove).toBe(false);
+		expect(listWindow.visibleRows[0]).toMatchObject({
+			kind: "header",
+			label: "Popular",
+		});
+	});
+});
diff --git a/apps/cli/src/tui/components/searchable-list.tsx b/apps/cli/src/tui/components/searchable-list.tsx
new file mode 100644
index 0000000..5aa5be6
--- /dev/null
+++ b/apps/cli/src/tui/components/searchable-list.tsx
@@ -0,0 +1,351 @@
+import { useMemo, useState } from "react";
+import { useTerminalBackground } from "../hooks/use-terminal-background";
+import { getDefaultForeground, palette } from "../palette";
+
+export interface SearchableItem {
+	key: string;
+	label: string;
+	section?: string;
+	detail?: string;
+	tag?: string;
+	tagColor?: string;
+	rightLabel?: string;
+	rightLabelColor?: string;
+	searchText?: string;
+}
+
+export interface SearchableListState {
+	search: string;
+	setSearch: (v: string) => void;
+	selected: number;
+	setSelected: (v: number | ((prev: number) => number)) => void;
+	filtered: SearchableItem[];
+	safeSelected: number;
+	moveUp: () => void;
+	moveDown: () => void;
+	selectedItem: SearchableItem | undefined;
+}
+
+export type CreateSearchableItem = (
+	search: string,
+	filteredItems: SearchableItem[],
+) => SearchableItem | undefined;
+
+function normalize(s: string): string {
+	return s.replace(/[^a-z0-9.]/g, "");
+}
+
+function fuzzyMatch(text: string, query: string): boolean {
+	let qi = 0;
+	for (let i = 0; i < text.length && qi < query.length; i++) {
+		if (text[i] === query[qi]) qi++;
+	}
+	return qi === query.length;
+}
+
+function scoreItem(item: SearchableItem, query: string): number {
+	const targets = [
+		item.label.toLowerCase(),
+		item.key.toLowerCase(),
+		item.searchText?.toLowerCase() ?? "",
+	];
+	const nQuery = normalize(query);
+
+	let best = 0;
+	for (const raw of targets) {
+		const t = normalize(raw);
+		if (!t) continue;
+		if (t === nQuery) return 100;
+		if (t.startsWith(nQuery)) best = Math.max(best, 90);
+		else if (t.includes(nQuery)) best = Math.max(best, 70);
+		else if (fuzzyMatch(t, nQuery)) best = Math.max(best, 30);
+	}
+	return best;
+}
+
+function createSectionOrder(items: SearchableItem[]): Map<string, number> {
+	const order = new Map<string, number>();
+	for (const item of items) {
+		if (!item.section || order.has(item.section)) continue;
+		order.set(item.section, order.size);
+	}
+	return order;
+}
+
+export type SearchableListRow =
+	| { kind: "header"; key: string; label: string }
+	| { kind: "item"; key: string; item: SearchableItem; itemIndex: number };
+
+export function buildSearchableListRows(
+	items: SearchableItem[],
+): SearchableListRow[] {
+	const rows: SearchableListRow[] = [];
+	let previousSection: string | undefined;
+	for (const [itemIndex, item] of items.entries()) {
+		if (item.section && item.section !== previousSection) {
+			rows.push({
+				kind: "header",
+				key: `section-${item.section}-${itemIndex}`,
+				label: item.section,
+			});
+		}
+		rows.push({ kind: "item", key: item.key, item, itemIndex });
+		previousSection = item.section;
+	}
+	return rows;
+}
+
+function countItemRows(rows: SearchableListRow[]): number {
+	return rows.reduce((count, row) => count + (row.kind === "item" ? 1 : 0), 0);
+}
+
+export function getSearchableListRowsWindow(
+	items: SearchableItem[],
+	selected: number,
+	maxVisible: number,
+): {
+	visibleRows: SearchableListRow[];
+	aboveCount: number;
+	belowCount: number;
+	showAbove: boolean;
+	showBelow: boolean;
+} {
+	const rows = buildSearchableListRows(items);
+	if (rows.length === 0) {
+		return {
+			visibleRows: [],
+			aboveCount: 0,
+			belowCount: 0,
+			showAbove: false,
+			showBelow: false,
+		};
+	}
+
+	const selectedRowIndex = Math.max(
+		0,
+		rows.findIndex((row) => row.kind === "item" && row.itemIndex === selected),
+	);
+	let visibleLimit = maxVisible;
+	let start = 0;
+	let end = rows.length;
+
+	for (let i = 0; i < 3; i++) {
+		const showAbove = start > 0;
+		const showBelow = end < rows.length;
+		visibleLimit = Math.max(
+			1,
+			maxVisible - (showAbove ? 1 : 0) - (showBelow ? 1 : 0),
+		);
+		start = Math.max(0, selectedRowIndex - Math.floor(visibleLimit / 2));
+		if (start + visibleLimit > rows.length) {
+			start = Math.max(0, rows.length - visibleLimit);
+		}
+		end = Math.min(rows.length, start + visibleLimit);
+	}
+
+	if (start > 0 && countItemRows(rows.slice(0, start)) === 0) {
+		start = 0;
+		const showBelow = rows.length > maxVisible;
+		visibleLimit = Math.max(1, maxVisible - (showBelow ? 1 : 0));
+		end = Math.min(rows.length, visibleLimit);
+	}
+
+	const aboveCount = countItemRows(rows.slice(0, start));
+	const belowCount = countItemRows(rows.slice(end));
+	return {
+		visibleRows: rows.slice(start, end),
+		aboveCount,
+		belowCount,
+		showAbove: aboveCount > 0,
+		showBelow: belowCount > 0,
+	};
+}
+
+export function useSearchableList(
+	items: SearchableItem[],
+	createItem?: CreateSearchableItem,
+): SearchableListState {
+	const [search, setSearch] = useState("");
+	const [selected, setSelected] = useState(0);
+
+	const filtered = useMemo(() => {
+		const baseItems = (() => {
+			if (!search) return items;
+			const q = search.toLowerCase();
+			const sectionOrder = createSectionOrder(items);
+			const scored = items
+				.map((item) => ({ item, score: scoreItem(item, q) }))
+				.filter((r) => r.score > 0);
+			scored.sort((a, b) => {
+				if (sectionOrder.size > 0) {
+					const aRank = a.item.section
+						? (sectionOrder.get(a.item.section) ?? Number.MAX_SAFE_INTEGER)
+						: Number.MAX_SAFE_INTEGER;
+					const bRank = b.item.section
+						? (sectionOrder.get(b.item.section) ?? Number.MAX_SAFE_INTEGER)
+						: Number.MAX_SAFE_INTEGER;
+					if (aRank !== bRank) return aRank - bRank;
+				}
+				return b.score - a.score;
+			});
+			return scored.map((r) => r.item);
+		})();
+		const created = createItem?.(search, baseItems);
+		return created ? [...baseItems, created] : baseItems;
+	}, [items, search, createItem]);
+
+	const safeSelected = Math.min(selected, Math.max(0, filtered.length - 1));
+
+	return {
+		search,
+		setSearch: (v: string) => {
+			setSearch(v);
+			setSelected(0);
+		},
+		selected,
+		setSelected,
+		filtered,
+		safeSelected,
+		moveUp: () =>
+			setSelected((s) =>
+				filtered.length === 0 ? 0 : s <= 0 ? filtered.length - 1 : s - 1,
+			),
+		moveDown: () =>
+			setSelected((s) =>
+				filtered.length === 0 ? 0 : s >= filtered.length - 1 ? 0 : s + 1,
+			),
+		selectedItem: filtered[safeSelected],
+	};
+}
+
+const MAX_VISIBLE = 10;
+
+export function SearchableList(props: {
+	items: SearchableItem[];
+	selected: number;
+	placeholder?: string;
+	onSearchChange: (v: string) => void;
+	onItemSelect?: (item: SearchableItem) => void;
+	emptyText?: string;
+	borderColor?: string;
+}) {
+	const terminalBg = useTerminalBackground();
+	const defaultFg = getDefaultForeground(terminalBg);
+	const {
+		items,
+		selected,
+		placeholder = "Type to search...",
+		onSearchChange,
+		onItemSelect,
+		emptyText = "No results",
+		borderColor = "gray",
+	} = props;
+
+	const safeSelected = Math.min(selected, Math.max(0, items.length - 1));
+	const { visibleRows, aboveCount, belowCount, showAbove, showBelow } =
+		getSearchableListRowsWindow(items, safeSelected, MAX_VISIBLE);
+
+	return (
+		<box flexDirection="column" gap={1}>
+			<box border borderStyle="rounded" borderColor={borderColor} paddingX={1}>
+				<input
+					onInput={onSearchChange}
+					placeholder={placeholder}
+					textColor={defaultFg}
+					focusedTextColor={defaultFg}
+					cursorColor={defaultFg}
+					flexGrow={1}
+					focused
+				/>
+			</box>
+
+			{items.length === 0 ? (
+				<text fg="gray" paddingX={1}>
+					{emptyText}
+				</text>
+			) : (
+				<box flexDirection="column">
+					{showAbove && (
+						<box paddingX={1} justifyContent="center">
+							<text fg="gray">
+								{"\u25b2"} {aboveCount} more
+							</text>
+						</box>
+					)}
+					{visibleRows.map((row) => {
+						if (row.kind === "header") {
+							return (
+								<box key={row.key} paddingX={1} height={1}>
+									<text fg="gray">{row.label}</text>
+								</box>
+							);
+						}
+						const item = row.item;
+						const isSel = row.itemIndex === safeSelected;
+						return (
+							<box
+								key={item.key}
+								paddingX={1}
+								flexDirection="row"
+								gap={1}
+								backgroundColor={isSel ? palette.selection : undefined}
+								onMouseDown={() => onItemSelect?.(item)}
+								overflow="hidden"
+								height={1}
+							>
+								<text
+									fg={isSel ? palette.textOnSelection : "gray"}
+									flexShrink={0}
+								>
+									{isSel ? "\u276f" : " "}
+								</text>
+								<text fg={isSel ? palette.textOnSelection : defaultFg}>
+									{item.label}
+								</text>
+								{item.detail && (
+									<text
+										fg={isSel ? palette.textOnSelection : "gray"}
+										flexShrink={1}
+									>
+										{item.detail}
+									</text>
+								)}
+								{item.tag && (
+									<text
+										fg={
+											isSel
+												? palette.textOnSelection
+												: (item.tagColor ?? "gray")
+										}
+										flexShrink={0}
+									>
+										{item.tag}
+									</text>
+								)}
+								{item.rightLabel && (
+									<text
+										fg={
+											isSel
+												? palette.textOnSelection
+												: (item.rightLabelColor ?? palette.success)
+										}
+										flexShrink={0}
+									>
+										{item.rightLabel}
+									</text>
+								)}
+							</box>
+						);
+					})}
+					{showBelow && (
+						<box paddingX={1} justifyContent="center">
+							<text fg="gray">
+								{"\u25bc"} {belowCount} more
+							</text>
+						</box>
+					)}
+				</box>
+			)}
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/status-bar.test.ts b/apps/cli/src/tui/components/status-bar.test.ts
new file mode 100644
index 0000000..53b2398
--- /dev/null
+++ b/apps/cli/src/tui/components/status-bar.test.ts
@@ -0,0 +1,132 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	createContextBar,
+	formatStatusBarUsageText,
+	resolveContextBarFilledForeground,
+	resolveModelDisplayName,
+} from "./status-bar";
+
+vi.mock("@opentui/react", () => ({
+	useTerminalDimensions: () => ({ width: 80, height: 24 }),
+}));
+
+describe("createContextBar", () => {
+	it("keeps a stable width while changing segment lengths", () => {
+		expect(createContextBar(0, 100)).toEqual({
+			filled: "",
+			empty: "\u2588\u2588\u2588\u2588\u2588\u2588",
+		});
+		expect(createContextBar(50, 100)).toEqual({
+			filled: "\u2588\u2588\u2588",
+			empty: "\u2588\u2588\u2588",
+		});
+		expect(createContextBar(100, 100)).toEqual({
+			filled: "\u2588\u2588\u2588\u2588\u2588\u2588",
+			empty: "",
+		});
+	});
+
+	it("shows a non-empty fill when usage is above zero", () => {
+		expect(createContextBar(7_000, 1_000_000)).toEqual({
+			filled: "\u2588",
+			empty: "\u2588\u2588\u2588\u2588\u2588",
+		});
+	});
+
+	it("reserves the final segment for usage at or above the limit", () => {
+		expect(createContextBar(999_999, 1_000_000)).toEqual({
+			filled: "\u2588\u2588\u2588\u2588\u2588",
+			empty: "\u2588",
+		});
+		expect(createContextBar(1_000_000, 1_000_000)).toEqual({
+			filled: "\u2588\u2588\u2588\u2588\u2588\u2588",
+			empty: "",
+		});
+	});
+
+	it("uses explicit white when terminal foreground would inherit gray", () => {
+		expect(resolveContextBarFilledForeground(undefined)).toBe("#ffffff");
+		expect(resolveContextBarFilledForeground("#1a1a1a")).toBe("#1a1a1a");
+	});
+});
+
+describe("formatStatusBarUsageText", () => {
+	it("includes cost when usage cost is visible", () => {
+		expect(
+			formatStatusBarUsageText({
+				totalTokens: 12_345,
+				totalCost: 0.123,
+				providerId: "cline",
+			}),
+		).toBe("(12,345) $0.12");
+	});
+
+	it("rounds cost to two decimals even when tiny", () => {
+		expect(
+			formatStatusBarUsageText({
+				totalTokens: 12_345,
+				totalCost: 0.0004,
+				providerId: "cline",
+			}),
+		).toBe("(12,345) $0.00");
+	});
+
+	it("hides cost entirely for subscription providers", () => {
+		expect(
+			formatStatusBarUsageText({
+				totalTokens: 12_345,
+				totalCost: 0.123,
+				providerId: "cline-pass",
+			}),
+		).toBe("(12,345)");
+	});
+});
+
+describe("resolveModelDisplayName", () => {
+	it("uses the friendly model name with a ClinePass prefix", () => {
+		expect(
+			resolveModelDisplayName({
+				providerId: "cline-pass",
+				modelId: "zai/glm-5.2",
+				knownModels: {
+					"zai/glm-5.2": { name: "GLM 5.2" },
+				},
+			}),
+		).toBe("ClinePass: GLM 5.2");
+	});
+
+	it("falls back to the bare model id with a ClinePass prefix when unknown", () => {
+		expect(
+			resolveModelDisplayName({
+				providerId: "cline-pass",
+				modelId: "zai/glm-5.2",
+			}),
+		).toBe("ClinePass: glm-5.2");
+	});
+
+	it("keeps the reasoning effort next to the model name", () => {
+		expect(
+			resolveModelDisplayName({
+				providerId: "cline-pass",
+				modelId: "zai/glm-5.2",
+				knownModels: {
+					"zai/glm-5.2": { name: "GLM 5.2" },
+				},
+				thinking: true,
+				reasoningEffort: "high",
+			}),
+		).toBe("ClinePass: GLM 5.2 (high)");
+	});
+
+	it("uses the friendly model name for non-ClinePass providers", () => {
+		expect(
+			resolveModelDisplayName({
+				providerId: "cline",
+				modelId: "zai/glm-5.2",
+				knownModels: {
+					"zai/glm-5.2": { name: "GLM 5.2" },
+				},
+			}),
+		).toBe("GLM 5.2");
+	});
+});
diff --git a/apps/cli/src/tui/components/status-bar.tsx b/apps/cli/src/tui/components/status-bar.tsx
new file mode 100644
index 0000000..b335f41
--- /dev/null
+++ b/apps/cli/src/tui/components/status-bar.tsx
@@ -0,0 +1,287 @@
+import type { AgentMode } from "@cline/core";
+import { useTerminalDimensions } from "@opentui/react";
+import {
+	shouldShowCliUsageCost,
+	shouldShowCliUsageCoveredBySubscription,
+} from "../../utils/usage-cost-display";
+import {
+	useTerminalBackground,
+	useTerminalTheme,
+} from "../hooks/use-terminal-background";
+import {
+	getDefaultForeground,
+	getModeAccent,
+	getSuccessColor,
+} from "../palette";
+import { HOME_VIEW_MAX_WIDTH } from "../types";
+
+export function createContextBar(
+	used: number,
+	total?: number,
+	width = 6,
+): { filled: string; empty: string } {
+	const normalizedWidth = Math.max(0, Math.floor(width));
+	const ratio = total && total > 0 ? Math.min(used / total, 1) : 0;
+	const filledCount =
+		total && total > 0 && used > 0
+			? used >= total
+				? normalizedWidth
+				: Math.min(
+						Math.max(1, Math.ceil(ratio * normalizedWidth)),
+						Math.max(0, normalizedWidth - 1),
+					)
+			: 0;
+	const emptyCount = Math.max(0, normalizedWidth - filledCount);
+	return {
+		filled: "\u2588".repeat(filledCount),
+		empty: "\u2588".repeat(emptyCount),
+	};
+}
+
+export function resolveContextBarFilledForeground(
+	defaultForeground: string | undefined,
+): string {
+	return defaultForeground ?? "#ffffff";
+}
+
+function formatCost(cost: number): string {
+	return `$${cost.toFixed(2)}`;
+}
+
+function formatCostText(providerId: string, totalCost: number): string {
+	// Subscription providers (ClinePass) have no per-use cost worth surfacing.
+	if (shouldShowCliUsageCoveredBySubscription(providerId)) {
+		return "";
+	}
+
+	if (!shouldShowCliUsageCost(providerId)) {
+		return "";
+	}
+
+	return formatCost(totalCost);
+}
+
+export function formatStatusBarUsageText(input: {
+	totalTokens: number;
+	totalCost: number;
+	providerId: string;
+}): string {
+	const tokens = `(${input.totalTokens.toLocaleString()})`;
+	const costText = formatCostText(input.providerId, input.totalCost);
+
+	if (!costText) {
+		return tokens;
+	}
+
+	return `${tokens} ${costText}`;
+}
+
+// knownModels keys are bare IDs ("claude-sonnet-4-6") but config.modelId
+// may include a provider prefix ("anthropic/claude-sonnet-4-6"), so we
+// try the full ID first, then strip the prefix and retry.
+function lookupModelInfo(
+	modelId: string,
+	knownModels?: Record<string, unknown>,
+): { name?: string } | undefined {
+	if (!knownModels) return undefined;
+	const candidates = [modelId, modelId.split("/").pop()];
+	for (const key of candidates) {
+		if (!key) continue;
+		const hit = knownModels[key] as { name?: string } | undefined;
+		if (hit) return hit;
+	}
+	return undefined;
+}
+
+export function resolveModelDisplayName(config: {
+	providerId?: string;
+	modelId: string;
+	knownModels?: Record<string, unknown>;
+	thinking?: boolean;
+	reasoningEffort?: string;
+}): string {
+	const info = lookupModelInfo(config.modelId, config.knownModels);
+	const modelIdTail = config.modelId.split("/").pop() ?? config.modelId;
+	let displayName = info?.name ?? modelIdTail;
+	if (config.thinking && config.reasoningEffort) {
+		displayName = `${displayName} (${config.reasoningEffort})`;
+	}
+	if (config.providerId === "cline-pass") {
+		displayName = `ClinePass: ${displayName}`;
+	}
+	return displayName;
+}
+
+export function resolveModelMaxInputTokens(config: {
+	modelId: string;
+	knownModels?: Record<string, unknown>;
+}): number | undefined {
+	const info = (lookupModelInfo(config.modelId, config.knownModels) ?? {}) as {
+		maxInputTokens?: number;
+		contextWindow?: number;
+	};
+	if (typeof info.maxInputTokens === "number" && info.maxInputTokens > 0) {
+		return info.maxInputTokens;
+	}
+	if (typeof info.contextWindow === "number" && info.contextWindow > 0) {
+		return info.contextWindow;
+	}
+	return undefined;
+}
+
+export interface StatusBarProps {
+	providerId: string;
+	modelId: string;
+	totalTokens: number;
+	totalCost: number;
+	maxInputTokens?: number;
+	uiMode: AgentMode;
+	autoApproveAll: boolean;
+	workspaceName: string;
+	gitBranch: string | null;
+	gitDiffStats: {
+		files: number;
+		additions: number;
+		deletions: number;
+	} | null;
+	onToggleMode?: () => void;
+	variant?: "home" | "chat";
+}
+
+export function StatusBar(props: StatusBarProps) {
+	const {
+		modelId,
+		totalTokens,
+		totalCost,
+		maxInputTokens,
+		uiMode,
+		autoApproveAll,
+		workspaceName,
+		gitBranch,
+		gitDiffStats,
+		onToggleMode,
+	} = props;
+
+	const { width } = useTerminalDimensions();
+	const terminalBg = useTerminalBackground();
+	const terminalTheme = useTerminalTheme();
+	const defaultFg = getDefaultForeground(terminalBg);
+	const contextBarFilledFg = resolveContextBarFilledForeground(defaultFg);
+	const actAccent = getModeAccent("act", terminalTheme);
+	const planAccent = getModeAccent("plan", terminalTheme);
+	const successColor = getSuccessColor(terminalTheme);
+	const hasMaxInputTokens =
+		typeof maxInputTokens === "number" &&
+		Number.isFinite(maxInputTokens) &&
+		maxInputTokens > 0;
+	const bar = hasMaxInputTokens
+		? createContextBar(totalTokens, maxInputTokens)
+		: undefined;
+
+	// Available content width after accounting for padding.
+	// Home view: parent box is capped at 60 wide, status bar adds paddingX=1 (-2).
+	// Chat view: status bar adds paddingX=1 (-2).
+	const avail =
+		props.variant === "home"
+			? Math.min(width, HOME_VIEW_MAX_WIDTH) - 2
+			: width - 2;
+
+	// Row 1 layout: [model + context info] .... [Plan/Act toggle]
+	// When the full row doesn't fit, context info drops to its own row 2.
+	// Model ID truncates with "..." before wrapping; toggle stays right-aligned.
+	const toggleWidth = 20;
+	const usageText = formatStatusBarUsageText({
+		totalTokens,
+		totalCost,
+		providerId: props.providerId,
+	});
+	const contextText = bar
+		? ` ${bar.filled}${bar.empty} ${usageText}`
+		: ` ${usageText}`;
+	const firstRowFits =
+		modelId.length + contextText.length + toggleWidth + 1 <= avail;
+	const renderContextText = (withLeadingSpace: boolean) => (
+		<>
+			{withLeadingSpace && " "}
+			{bar && (
+				<>
+					<span fg={contextBarFilledFg}>{bar.filled}</span>
+					<span fg="gray">{bar.empty}</span>{" "}
+				</>
+			)}
+			{usageText}
+		</>
+	);
+
+	const modelMaxLen = Math.max(
+		10,
+		avail - toggleWidth - (firstRowFits ? contextText.length : 0) - 1,
+	);
+	const truncatedModel =
+		modelId.length > modelMaxLen
+			? `${modelId.slice(0, modelMaxLen - 3)}...`
+			: modelId;
+
+	// Repo row: [workspace (branch) | N files +X -Y]
+	// Git stats stay visible; path/branch truncates with "..." when narrow.
+	const hasGitDiff = gitDiffStats && gitDiffStats.files > 0;
+	const gitSuffix = hasGitDiff
+		? ` | ${gitDiffStats.files} file${gitDiffStats.files !== 1 ? "s" : ""} +${gitDiffStats.additions} -${gitDiffStats.deletions}`
+		: "";
+	const pathPart = workspaceName + (gitBranch ? ` (${gitBranch})` : "");
+	const pathMax = Math.max(5, avail - gitSuffix.length);
+	const truncatedPath =
+		pathPart.length > pathMax
+			? `${pathPart.slice(0, pathMax - 3)}...`
+			: pathPart;
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<box flexDirection="row" justifyContent="space-between">
+				<text fg="gray">
+					{truncatedModel}
+					{firstRowFits && renderContextText(true)}
+				</text>
+				<box
+					flexDirection="row"
+					gap={1}
+					flexShrink={0}
+					onMouseDown={onToggleMode}
+				>
+					<text fg={uiMode === "plan" ? planAccent : "gray"}>
+						{uiMode === "plan" ? "●" : "○"} Plan
+					</text>
+					<text fg={uiMode === "act" ? actAccent : "gray"}>
+						{uiMode === "act" ? "●" : "○"} Act
+					</text>
+					<text fg="gray">(Tab)</text>
+				</box>
+			</box>
+
+			{!firstRowFits && <text fg="gray">{renderContextText(false)}</text>}
+
+			<text fg={defaultFg}>
+				{truncatedPath}
+				{hasGitDiff && (
+					<span fg="gray">
+						{" | "}
+						{gitDiffStats.files} file
+						{gitDiffStats.files !== 1 ? "s" : ""}{" "}
+						<span fg={successColor}>+{gitDiffStats.additions}</span>{" "}
+						<span fg="red">-{gitDiffStats.deletions}</span>
+					</span>
+				)}
+			</text>
+
+			{autoApproveAll ? (
+				<text fg={defaultFg}>
+					<span fg={successColor}>
+						{"\u23f5\u23f5"} Auto-approve all enabled
+					</span>
+					<span fg="gray"> (Shift+Tab)</span>
+				</text>
+			) : (
+				<text fg="gray">Auto-approve all disabled (Shift+Tab)</text>
+			)}
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/toast.tsx b/apps/cli/src/tui/components/toast.tsx
new file mode 100644
index 0000000..71f5607
--- /dev/null
+++ b/apps/cli/src/tui/components/toast.tsx
@@ -0,0 +1,46 @@
+import { useTerminalDimensions } from "@opentui/react";
+import { palette } from "../palette";
+
+export type ToastVariant = "info" | "success" | "error";
+
+export type ToastState = {
+	message: string;
+	variant: ToastVariant;
+};
+
+const variantColor: Record<ToastVariant, string> = {
+	info: palette.selection,
+	success: palette.success,
+	error: palette.error,
+};
+
+export function Toast(props: { toast: ToastState | null }) {
+	const { width } = useTerminalDimensions();
+
+	if (!props.toast) {
+		return null;
+	}
+
+	const availableWidth = Math.max(1, width - 4);
+	const maxWidth = Math.min(44, availableWidth);
+	const right = width < 32 ? 0 : 2;
+	const color = variantColor[props.toast.variant];
+
+	return (
+		<box
+			position="absolute"
+			zIndex={100}
+			top={1}
+			right={right}
+			maxWidth={maxWidth}
+			border
+			borderStyle="rounded"
+			borderColor={color}
+			paddingX={1}
+		>
+			<text fg={color} wrapMode="word">
+				{props.toast.message}
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/components/tool-output.tsx b/apps/cli/src/tui/components/tool-output.tsx
new file mode 100644
index 0000000..f626d91
--- /dev/null
+++ b/apps/cli/src/tui/components/tool-output.tsx
@@ -0,0 +1,373 @@
+import { useState } from "react";
+import { useTerminalTheme } from "../hooks/use-terminal-background";
+import { diffPalettes, palette, type TerminalTheme } from "../palette";
+import { makeUnifiedDiff } from "../utils/diff";
+import { getSyntaxStyle } from "../utils/syntax-style";
+import { getToolErrorPresentation } from "../utils/tool-errors";
+import {
+	detectLanguage,
+	extractFullOutputText,
+	parseApplyPatchInput,
+	parseEditorInput,
+	parseReadFilesInput,
+	shortenPath,
+} from "../utils/tool-parsing";
+
+const MAX_COLLAPSED_LINES = 5;
+const RESULT = "\u23bf";
+
+export interface ToolOutputProps {
+	toolName: string;
+	outputSummary: string;
+	rawOutput?: unknown;
+	rawInput?: unknown;
+	error?: string;
+}
+
+function isAskTool(toolName: string): boolean {
+	return toolName === "ask_question" || toolName === "ask_followup_question";
+}
+
+function isBashTool(toolName: string): boolean {
+	return toolName === "run_commands" || toolName === "bash";
+}
+
+function isReadTool(toolName: string): boolean {
+	return toolName === "read_files";
+}
+
+function isEditTool(toolName: string): boolean {
+	return (
+		toolName === "editor" ||
+		toolName === "edit" ||
+		toolName === "write" ||
+		toolName === "apply_patch"
+	);
+}
+
+function BashOutput(props: { fullText: string; theme: TerminalTheme }) {
+	const [expanded, setExpanded] = useState(false);
+	const { fullText } = props;
+	const trimmed = fullText.trimEnd();
+	const lines = trimmed.split("\n");
+	const firstLine = lines[0] ?? "";
+	const hasMore = lines.length > 1;
+
+	if (!expanded) {
+		return (
+			<box
+				flexDirection="column"
+				paddingLeft={2}
+				onMouseDown={() => hasMore && setExpanded(true)}
+			>
+				<text selectable>
+					<span fg="gray">
+						{RESULT} {firstLine}
+					</span>
+				</text>
+				{hasMore && (
+					<text fg="gray">
+						{"   "}... {lines.length - 1} more lines
+					</text>
+				)}
+			</box>
+		);
+	}
+
+	return (
+		<box
+			flexDirection="column"
+			paddingLeft={2}
+			onMouseDown={() => setExpanded(false)}
+		>
+			<text fg="gray">{RESULT} output:</text>
+			<box marginLeft={2} marginTop={1} marginBottom={1}>
+				<code
+					content={fullText}
+					filetype="bash"
+					syntaxStyle={getSyntaxStyle(props.theme)}
+					selectable
+				/>
+			</box>
+		</box>
+	);
+}
+
+function ReadOutput(props: { fullText: string; rawInput?: unknown }) {
+	const { fullText, rawInput } = props;
+	const lines = fullText.split("\n");
+
+	const readInfo = parseReadFilesInput(rawInput);
+	const filePath = readInfo?.files[0]?.path;
+	const language = filePath ? detectLanguage(filePath) : undefined;
+
+	return (
+		<box paddingLeft={2}>
+			<text fg="gray">
+				{RESULT} {lines.length} lines
+				{language ? ` | ${language}` : ""}
+			</text>
+		</box>
+	);
+}
+
+function DiffStats(props: {
+	added: number;
+	removed: number;
+	language?: string;
+}) {
+	const { added, removed, language } = props;
+	return (
+		<text fg="gray">
+			{RESULT}{" "}
+			{removed > 0 ? (
+				<>
+					<span fg={palette.success}>+{added}</span>{" "}
+					<span fg="red">-{removed}</span> lines
+				</>
+			) : (
+				<span fg={palette.success}>+{added} lines (new)</span>
+			)}
+			{language ? ` | ${language}` : ""}
+		</text>
+	);
+}
+
+function EditOutput(props: {
+	rawInput?: unknown;
+	outputSummary: string;
+	theme: TerminalTheme;
+}) {
+	const [expanded, setExpanded] = useState(true);
+	const editorInfo = parseEditorInput(props.rawInput);
+
+	if (!editorInfo?.oldText && !editorInfo?.newText) {
+		return (
+			<box paddingLeft={2}>
+				<text fg="gray">
+					{"  "} {props.outputSummary || "done"}
+				</text>
+			</box>
+		);
+	}
+
+	const oldText = editorInfo.oldText ?? "";
+	const newText = editorInfo.newText;
+	const language = detectLanguage(editorInfo.path);
+	const addedLines = newText.split("\n").length;
+	const removedLines = oldText ? oldText.split("\n").length : 0;
+	const diffPalette = diffPalettes[props.theme];
+
+	return (
+		<box
+			flexDirection="column"
+			paddingLeft={2}
+			onMouseDown={() => setExpanded(!expanded)}
+		>
+			<DiffStats
+				added={addedLines}
+				removed={removedLines}
+				language={language}
+			/>
+			{expanded && (
+				<box marginLeft={2} marginTop={1} marginBottom={1}>
+					<diff
+						diff={makeUnifiedDiff(oldText, newText, editorInfo.path)}
+						view="unified"
+						filetype={language ?? "text"}
+						syntaxStyle={getSyntaxStyle(props.theme)}
+						showLineNumbers
+						addedBg={diffPalette.addedBg}
+						removedBg={diffPalette.removedBg}
+						addedLineNumberBg={diffPalette.addedLineNumberBg}
+						removedLineNumberBg={diffPalette.removedLineNumberBg}
+						addedSignColor={diffPalette.addedSignColor}
+						removedSignColor={diffPalette.removedSignColor}
+						lineNumberFg={diffPalette.lineNumberFg}
+					/>
+				</box>
+			)}
+		</box>
+	);
+}
+
+function ApplyPatchOutput(props: {
+	rawInput?: unknown;
+	outputSummary: string;
+	theme: TerminalTheme;
+}) {
+	const [expanded, setExpanded] = useState(true);
+	const info = parseApplyPatchInput(props.rawInput);
+
+	if (!info) {
+		return (
+			<box paddingLeft={2}>
+				<text fg="gray">
+					{"  "} {props.outputSummary || "done"}
+				</text>
+			</box>
+		);
+	}
+
+	const fileLabel = info.files.map((f) => shortenPath(f, 40)).join(", ");
+	const language = detectLanguage(info.files[0] ?? "");
+	const diffPalette = diffPalettes[props.theme];
+
+	return (
+		<box
+			flexDirection="column"
+			paddingLeft={2}
+			onMouseDown={() => setExpanded(!expanded)}
+		>
+			<DiffStats
+				added={info.additions}
+				removed={info.deletions}
+				language={fileLabel}
+			/>
+			{expanded && (
+				<box marginLeft={2} marginTop={1} marginBottom={1}>
+					<diff
+						diff={info.diff}
+						view="unified"
+						filetype={language ?? "text"}
+						syntaxStyle={getSyntaxStyle(props.theme)}
+						showLineNumbers
+						addedBg={diffPalette.addedBg}
+						removedBg={diffPalette.removedBg}
+						addedLineNumberBg={diffPalette.addedLineNumberBg}
+						removedLineNumberBg={diffPalette.removedLineNumberBg}
+						addedSignColor={diffPalette.addedSignColor}
+						removedSignColor={diffPalette.removedSignColor}
+						lineNumberFg={diffPalette.lineNumberFg}
+					/>
+				</box>
+			)}
+		</box>
+	);
+}
+
+function GenericOutput(props: { outputSummary: string; fullText?: string }) {
+	const [expanded, setExpanded] = useState(false);
+	const displayText = props.fullText || props.outputSummary;
+	const lines = displayText.split("\n");
+	const isLong = lines.length > MAX_COLLAPSED_LINES;
+
+	if (!displayText.trim()) return null;
+
+	if (!expanded) {
+		const collapsedText = isLong
+			? `${lines.slice(0, MAX_COLLAPSED_LINES).join("\n")}\n... ${lines.length - MAX_COLLAPSED_LINES} more lines`
+			: displayText;
+
+		return (
+			<box
+				flexDirection="column"
+				paddingLeft={2}
+				onMouseDown={() => isLong && setExpanded(true)}
+			>
+				<text selectable>
+					<span fg="gray">
+						{isLong ? RESULT : " "} {collapsedText}
+					</span>
+				</text>
+			</box>
+		);
+	}
+
+	return (
+		<box
+			flexDirection="column"
+			paddingLeft={2}
+			onMouseDown={() => setExpanded(false)}
+		>
+			<text fg="gray">{RESULT}</text>
+			<box marginLeft={2} marginBottom={1}>
+				<text fg="gray" selectable>
+					{displayText}
+				</text>
+			</box>
+		</box>
+	);
+}
+
+export function ToolOutput(props: ToolOutputProps) {
+	const { toolName, outputSummary, rawOutput, rawInput, error } = props;
+	const terminalTheme = useTerminalTheme();
+	const [errorExpanded, setErrorExpanded] = useState(false);
+
+	if (error) {
+		const presentation = getToolErrorPresentation(error);
+		const isWarning = presentation.severity === "warning";
+		const showDetail =
+			errorExpanded && presentation.detail !== presentation.summary.trim();
+		return (
+			<box
+				flexDirection="column"
+				paddingLeft={2}
+				onMouseDown={() => setErrorExpanded(!errorExpanded)}
+			>
+				<text fg={isWarning ? "yellow" : "red"} selectable>
+					{"  "} {isWarning ? "!" : "Error:"} {presentation.summary}
+				</text>
+				{showDetail && (
+					<box paddingLeft={3}>
+						<text fg="gray" selectable>
+							{presentation.detail}
+						</text>
+					</box>
+				)}
+			</box>
+		);
+	}
+
+	if (toolName === "switch_to_act_mode") return null;
+	if (!outputSummary.trim() && !rawOutput) return null;
+
+	const fullText = rawOutput ? extractFullOutputText(rawOutput) : undefined;
+
+	if (isAskTool(toolName)) {
+		const answer = (fullText || outputSummary).trim();
+		if (!answer) return null;
+		return (
+			<box paddingLeft={2}>
+				<text fg="gray" selectable>
+					{RESULT} {answer}
+				</text>
+			</box>
+		);
+	}
+
+	if (isBashTool(toolName)) {
+		return (
+			<BashOutput fullText={fullText || outputSummary} theme={terminalTheme} />
+		);
+	}
+
+	if (isReadTool(toolName)) {
+		return (
+			<ReadOutput fullText={fullText || outputSummary} rawInput={rawInput} />
+		);
+	}
+
+	if (toolName === "apply_patch") {
+		return (
+			<ApplyPatchOutput
+				rawInput={rawInput}
+				outputSummary={outputSummary}
+				theme={terminalTheme}
+			/>
+		);
+	}
+
+	if (isEditTool(toolName)) {
+		return (
+			<EditOutput
+				rawInput={rawInput}
+				outputSummary={outputSummary}
+				theme={terminalTheme}
+			/>
+		);
+	}
+
+	return <GenericOutput outputSummary={outputSummary} fullText={fullText} />;
+}
diff --git a/apps/cli/src/tui/components/tracked-robot.tsx b/apps/cli/src/tui/components/tracked-robot.tsx
new file mode 100644
index 0000000..b80d13d
--- /dev/null
+++ b/apps/cli/src/tui/components/tracked-robot.tsx
@@ -0,0 +1,32 @@
+import { useCallback, useRef, useState } from "react";
+import { useTerminalBackground } from "../hooks/use-terminal-background";
+import { getDefaultForeground } from "../palette";
+import { RobotAnimation } from "./robot-animation";
+
+export function useMouseTracker() {
+	const [cursor, setCursor] = useState({ x: 0, y: 0 });
+	const lastUpdateRef = useRef(0);
+
+	const onMouseMove = useCallback((event: { x: number; y: number }) => {
+		const now = Date.now();
+		if (now - lastUpdateRef.current < 30) return;
+		lastUpdateRef.current = now;
+		setCursor({ x: event.x, y: event.y });
+	}, []);
+
+	return { cursor, onMouseMove };
+}
+
+export function TrackedRobot(props: { cursorX?: number; cursorY?: number }) {
+	const terminalBg = useTerminalBackground();
+	const defaultFg = getDefaultForeground(terminalBg);
+	return (
+		<box width="100%" flexShrink={1} overflow="hidden">
+			<RobotAnimation
+				cursorX={props.cursorX ?? 0}
+				cursorY={props.cursorY ?? 0}
+				defaultColor={defaultFg}
+			/>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/contexts/event-bridge-context.tsx b/apps/cli/src/tui/contexts/event-bridge-context.tsx
new file mode 100644
index 0000000..d2fdabb
--- /dev/null
+++ b/apps/cli/src/tui/contexts/event-bridge-context.tsx
@@ -0,0 +1,46 @@
+import type { AgentEvent, TeamEvent } from "@cline/core";
+import type React from "react";
+import { createContext, useEffect, useRef } from "react";
+import type {
+	PendingPromptSnapshot,
+	PendingPromptSubmittedEvent,
+} from "../../runtime/session-events";
+import type { TuiProps } from "../types";
+
+interface EventBridgeHandlers {
+	onAgentEvent: (event: AgentEvent) => void;
+	onTeamEvent: (event: TeamEvent) => void;
+	onPendingPrompts: (event: PendingPromptSnapshot) => void;
+	onPendingPromptSubmitted: (event: PendingPromptSubmittedEvent) => void;
+}
+
+const EventBridgeContext = createContext<null>(null);
+
+export function EventBridgeProvider(props: {
+	subscribeToEvents: TuiProps["subscribeToEvents"];
+	handlers: EventBridgeHandlers;
+	children: React.ReactNode;
+}) {
+	const handlersRef = useRef(props.handlers);
+	handlersRef.current = props.handlers;
+
+	const subscribeRef = useRef(props.subscribeToEvents);
+	subscribeRef.current = props.subscribeToEvents;
+
+	useEffect(() => {
+		const unsubscribe = subscribeRef.current({
+			onAgentEvent: (event) => handlersRef.current.onAgentEvent(event),
+			onTeamEvent: (event) => handlersRef.current.onTeamEvent(event),
+			onPendingPrompts: (event) => handlersRef.current.onPendingPrompts(event),
+			onPendingPromptSubmitted: (event) =>
+				handlersRef.current.onPendingPromptSubmitted(event),
+		});
+		return unsubscribe;
+	}, []);
+
+	return (
+		<EventBridgeContext.Provider value={null}>
+			{props.children}
+		</EventBridgeContext.Provider>
+	);
+}
diff --git a/apps/cli/src/tui/contexts/session-context.test.ts b/apps/cli/src/tui/contexts/session-context.test.ts
new file mode 100644
index 0000000..de3d3b1
--- /dev/null
+++ b/apps/cli/src/tui/contexts/session-context.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { nextUsageTokenDisplay } from "./session-context";
+
+describe("nextUsageTokenDisplay", () => {
+	it("uses streaming input tokens as an absolute context size", () => {
+		let displayedTokens = 0;
+
+		displayedTokens = nextUsageTokenDisplay(displayedTokens, {
+			inputTokens: 633_000,
+			outputTokens: 31_000,
+		});
+		displayedTokens = nextUsageTokenDisplay(displayedTokens, {
+			inputTokens: 934_000,
+			outputTokens: 266_000,
+		});
+
+		expect(displayedTokens).toBe(934_000);
+	});
+
+	it("ignores output-only usage events for the context size display", () => {
+		expect(
+			nextUsageTokenDisplay(633_000, {
+				outputTokens: 31_000,
+			}),
+		).toBe(633_000);
+	});
+});
diff --git a/apps/cli/src/tui/contexts/session-context.tsx b/apps/cli/src/tui/contexts/session-context.tsx
new file mode 100644
index 0000000..e63a657
--- /dev/null
+++ b/apps/cli/src/tui/contexts/session-context.tsx
@@ -0,0 +1,289 @@
+import type { AgentMode } from "@cline/core";
+import type React from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useRef,
+	useState,
+} from "react";
+import { getCliCompactionMode } from "../../utils/compaction-mode";
+import type { CliCompactionMode } from "../../utils/types";
+import type { ChatEntry, InlineStream, TuiProps } from "../types";
+import { MAX_BUFFERED_LINES } from "../types";
+
+interface SessionContextValue {
+	entries: ChatEntry[];
+	isRunning: boolean;
+	isStreaming: boolean;
+	abortRequested: boolean;
+	hasSubmitted: boolean;
+	uiMode: AgentMode;
+	autoApproveAll: boolean;
+	compactionMode: CliCompactionMode;
+	lastTotalTokens: number;
+	lastTotalCost: number;
+	isExitRequested: boolean;
+
+	appendEntry: (entry: ChatEntry) => void;
+	updateLastEntry: (updater: (prev: ChatEntry) => ChatEntry) => void;
+	updateEntry: (updater: (entry: ChatEntry) => ChatEntry) => void;
+	closeInlineStream: () => void;
+	activeInlineStreamRef: React.MutableRefObject<InlineStream>;
+
+	setIsRunning: (v: boolean) => void;
+	setIsStreaming: (v: boolean) => void;
+	setAbortRequested: (v: boolean) => void;
+	setHasSubmitted: (v: boolean) => void;
+	setLastTotalTokens: (v: number) => void;
+	setLastTotalCost: (v: number) => void;
+	addUsageDelta: (usage: UsageDelta) => void;
+	setUiMode: (mode: AgentMode) => void;
+	toggleMode: () => void;
+	toggleAutoApprove: () => void;
+	setCompactionMode: (mode: CliCompactionMode) => void;
+	requestExit: () => void;
+	clearEntries: () => void;
+	replaceEntries: (entries: ChatEntry[]) => void;
+}
+
+type UsageDelta = {
+	inputTokens?: number;
+	outputTokens?: number;
+	cost?: number;
+};
+
+const SessionContext = createContext<SessionContextValue | null>(null);
+
+export function useSession(): SessionContextValue {
+	const ctx = useContext(SessionContext);
+	if (!ctx) throw new Error("useSession must be within SessionProvider");
+	return ctx;
+}
+
+export function nextUsageTokenDisplay(
+	previousTotalTokens: number,
+	usage: UsageDelta,
+): number {
+	const inputTokens = Math.max(0, usage.inputTokens ?? 0);
+	return inputTokens > 0 ? inputTokens : previousTotalTokens;
+}
+
+export function SessionProvider(props: {
+	config: TuiProps["config"];
+	initialEntries?: ChatEntry[];
+	initialUsage?: {
+		totalTokens: number;
+		totalCost: number;
+	};
+	onRunningChange: TuiProps["onRunningChange"];
+	onAutoApproveChange: TuiProps["onAutoApproveChange"];
+	onCompactionModeChange: TuiProps["onCompactionModeChange"];
+	onExit: TuiProps["onExit"];
+	children: React.ReactNode;
+}) {
+	const {
+		config,
+		initialEntries,
+		initialUsage,
+		onRunningChange,
+		onAutoApproveChange,
+		onCompactionModeChange,
+		onExit,
+	} = props;
+
+	const [entries, setEntries] = useState<ChatEntry[]>(() =>
+		initialEntries && initialEntries.length > MAX_BUFFERED_LINES
+			? initialEntries.slice(initialEntries.length - MAX_BUFFERED_LINES)
+			: (initialEntries ?? []),
+	);
+	const [isRunning, _setIsRunning] = useState(false);
+	const [isStreaming, setIsStreaming] = useState(false);
+	const [abortRequested, setAbortRequested] = useState(false);
+	const [hasSubmitted, setHasSubmitted] = useState(
+		(initialEntries?.length ?? 0) > 0,
+	);
+	const [uiMode, _setUiMode] = useState<AgentMode>(
+		config.mode === "plan" ? "plan" : "act",
+	);
+	// Mirror for appendEntry: entries are appended from event-handler
+	// callbacks that must see the mode at append time, not at closure time.
+	const uiModeRef = useRef<AgentMode>(config.mode === "plan" ? "plan" : "act");
+	const setUiMode = useCallback((mode: AgentMode) => {
+		uiModeRef.current = mode;
+		_setUiMode(mode);
+	}, []);
+	const initialAutoApproveAll = config.toolPolicies["*"]?.autoApprove !== false;
+	const autoApproveAllRef = useRef(initialAutoApproveAll);
+	const [autoApproveAll, _setAutoApproveAll] = useState(initialAutoApproveAll);
+	const [compactionMode, _setCompactionMode] = useState<CliCompactionMode>(() =>
+		getCliCompactionMode(config),
+	);
+	const [lastTotalTokens, setLastTotalTokens] = useState(
+		() => initialUsage?.totalTokens ?? 0,
+	);
+	const [lastTotalCost, setLastTotalCost] = useState(
+		() => initialUsage?.totalCost ?? 0,
+	);
+	const [isExitRequested, setIsExitRequested] = useState(false);
+
+	const activeInlineStreamRef = useRef<InlineStream>(undefined);
+
+	const setIsRunning = useCallback(
+		(v: boolean) => {
+			_setIsRunning(v);
+			setAbortRequested(false);
+			onRunningChange(v);
+		},
+		[onRunningChange],
+	);
+
+	const appendEntry = useCallback((entry: ChatEntry) => {
+		const stamped = entry.mode ? entry : { ...entry, mode: uiModeRef.current };
+		setEntries((prev) => {
+			const next = [...prev, stamped];
+			return next.length <= MAX_BUFFERED_LINES
+				? next
+				: next.slice(next.length - MAX_BUFFERED_LINES);
+		});
+	}, []);
+
+	const updateLastEntry = useCallback(
+		(updater: (prev: ChatEntry) => ChatEntry) => {
+			setEntries((prev) => {
+				if (prev.length === 0) return prev;
+				const next = [...prev];
+				next[next.length - 1] = updater(next[next.length - 1] as ChatEntry);
+				return next;
+			});
+		},
+		[],
+	);
+
+	const updateEntry = useCallback(
+		(updater: (entry: ChatEntry) => ChatEntry) => {
+			setEntries((prev) => {
+				let changed = false;
+				const next = prev.map((entry) => {
+					const updated = updater(entry);
+					if (updated !== entry) changed = true;
+					return updated;
+				});
+				return changed ? next : prev;
+			});
+		},
+		[],
+	);
+
+	const closeInlineStream = useCallback(() => {
+		activeInlineStreamRef.current = undefined;
+		setEntries((prev) => {
+			if (prev.length === 0) return prev;
+			const last = prev[prev.length - 1];
+			if (
+				last &&
+				(last.kind === "assistant_text" ||
+					last.kind === "reasoning" ||
+					last.kind === "tool_call") &&
+				last.streaming
+			) {
+				const next = [...prev];
+				next[next.length - 1] = { ...last, streaming: false } as ChatEntry;
+				return next;
+			}
+			return prev;
+		});
+	}, []);
+
+	const toggleMode = useCallback(() => {
+		setUiMode(uiModeRef.current === "act" ? "plan" : "act");
+	}, [setUiMode]);
+
+	const toggleAutoApprove = useCallback(() => {
+		const next = !autoApproveAllRef.current;
+		autoApproveAllRef.current = next;
+		onAutoApproveChange(next);
+		_setAutoApproveAll(next);
+	}, [onAutoApproveChange]);
+
+	const setCompactionMode = useCallback(
+		(mode: CliCompactionMode) => {
+			_setCompactionMode(mode);
+			void onCompactionModeChange(mode);
+		},
+		[onCompactionModeChange],
+	);
+
+	const requestExit = useCallback(() => {
+		setIsExitRequested(true);
+		setTimeout(() => onExit(), 0);
+	}, [onExit]);
+
+	const clearEntries = useCallback(() => {
+		setEntries([]);
+		setLastTotalTokens(0);
+		setLastTotalCost(0);
+	}, []);
+
+	const addUsageDelta = useCallback((usage: UsageDelta) => {
+		const nextTotalTokens = nextUsageTokenDisplay(0, usage);
+		if (nextTotalTokens > 0) {
+			setLastTotalTokens((prev) => nextUsageTokenDisplay(prev, usage));
+		}
+		const costDelta = usage.cost;
+		if (
+			typeof costDelta === "number" &&
+			Number.isFinite(costDelta) &&
+			costDelta > 0
+		) {
+			setLastTotalCost((prev) => prev + costDelta);
+		}
+	}, []);
+
+	const replaceEntries = useCallback((nextEntries: ChatEntry[]) => {
+		setEntries(
+			nextEntries.length > MAX_BUFFERED_LINES
+				? nextEntries.slice(nextEntries.length - MAX_BUFFERED_LINES)
+				: nextEntries,
+		);
+	}, []);
+
+	const value: SessionContextValue = {
+		entries,
+		isRunning,
+		isStreaming,
+		abortRequested,
+		hasSubmitted,
+		uiMode,
+		autoApproveAll,
+		compactionMode,
+		lastTotalTokens,
+		lastTotalCost,
+		isExitRequested,
+		appendEntry,
+		updateLastEntry,
+		updateEntry,
+		closeInlineStream,
+		activeInlineStreamRef,
+		setIsRunning,
+		setIsStreaming,
+		setAbortRequested,
+		setHasSubmitted,
+		setLastTotalTokens,
+		setLastTotalCost,
+		addUsageDelta,
+		setUiMode,
+		toggleMode,
+		toggleAutoApprove,
+		setCompactionMode,
+		requestExit,
+		clearEntries,
+		replaceEntries,
+	};
+
+	return (
+		<SessionContext.Provider value={value}>
+			{props.children}
+		</SessionContext.Provider>
+	);
+}
diff --git a/apps/cli/src/tui/history-standalone.tsx b/apps/cli/src/tui/history-standalone.tsx
new file mode 100644
index 0000000..f59c4ed
--- /dev/null
+++ b/apps/cli/src/tui/history-standalone.tsx
@@ -0,0 +1,71 @@
+import type { SessionHistoryRecord } from "@cline/core";
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import React from "react";
+import { deleteSession } from "../session/session";
+import { HistoryStandaloneContent } from "./views/history-view";
+
+export async function renderHistoryStandalone(input: {
+	rows: SessionHistoryRecord[];
+	onExport: (sessionId: string) => Promise<string | undefined>;
+	refreshRows?: () => Promise<SessionHistoryRecord[]>;
+}): Promise<number | string> {
+	const renderer = await createCliRenderer({
+		exitOnCtrlC: true,
+		autoFocus: false,
+		enableMouseMovement: true,
+	});
+
+	return new Promise((resolve) => {
+		let result: number | string = 0;
+		let resolved = false;
+		let destroyStarted = false;
+		let unmounted = false;
+		const root = createRoot(renderer);
+
+		const unmountRoot = () => {
+			if (unmounted) {
+				return;
+			}
+			unmounted = true;
+			root.unmount();
+		};
+
+		// Resolve only once teardown has finished, so callers never run while
+		// the renderer is still restoring the terminal.
+		renderer.on("destroy", () => {
+			unmountRoot();
+			if (!resolved) {
+				resolved = true;
+				resolve(result);
+			}
+		});
+
+		const settle = (value: number | string) => {
+			if (destroyStarted) {
+				return;
+			}
+			destroyStarted = true;
+			result = value;
+			unmountRoot();
+			// Let OpenTUI finish parsing the current stdin batch before teardown.
+			queueMicrotask(() => {
+				renderer.destroy();
+			});
+		};
+
+		root.render(
+			React.createElement(HistoryStandaloneContent, {
+				rows: input.rows,
+				onResolve: (sessionId: string) => settle(sessionId),
+				onExport: input.onExport,
+				refreshRows: input.refreshRows,
+				onDelete: async (sessionId: string) => {
+					const result = await deleteSession(sessionId);
+					return result.deleted;
+				},
+				onDismiss: () => settle(0),
+			}),
+		);
+	});
+}
diff --git a/apps/cli/src/tui/hooks/local-command-actions.ts b/apps/cli/src/tui/hooks/local-command-actions.ts
new file mode 100644
index 0000000..94614da
--- /dev/null
+++ b/apps/cli/src/tui/hooks/local-command-actions.ts
@@ -0,0 +1,75 @@
+import type { LocalSlashCommandInvocation } from "../utils/skill-command-input";
+import type { OpenConfigOptions } from "./use-config-panel";
+
+export interface LocalSlashCommandActionInput {
+	name: string;
+	openAccount: () => void;
+	openConfig: (options?: OpenConfigOptions) => void;
+	openMcpManager: () => Promise<boolean>;
+	openModelSelector: () => void;
+	openSkills: (invocation?: LocalSlashCommandInvocation) => void;
+	invocation?: LocalSlashCommandInvocation;
+	runCompact: () => void;
+	runFork: () => void;
+	runUndo: () => Promise<void>;
+	clearConversation: () => Promise<void>;
+	openHelp: () => void;
+	openHistory: () => void;
+	exitCline: () => void;
+}
+
+export function runLocalSlashCommandAction(
+	input: LocalSlashCommandActionInput,
+): boolean | Promise<boolean> {
+	const normalized = input.name;
+	if (normalized === "config" || normalized === "settings") {
+		input.openConfig();
+		return true;
+	}
+	if (normalized === "plugins") {
+		input.openConfig({ initialTab: "plugins" });
+		return true;
+	}
+	if (normalized === "skills") {
+		input.openSkills(input.invocation);
+		return true;
+	}
+	if (normalized === "mcp") {
+		return input.openMcpManager().then(() => true);
+	}
+	if (normalized === "account") {
+		input.openAccount();
+		return true;
+	}
+	if (normalized === "model") {
+		input.openModelSelector();
+		return true;
+	}
+	if (normalized === "compact") {
+		input.runCompact();
+		return true;
+	}
+	if (normalized === "fork") {
+		input.runFork();
+		return true;
+	}
+	if (normalized === "undo") {
+		return input.runUndo().then(() => true);
+	}
+	if (normalized === "clear") {
+		return input.clearConversation().then(() => true);
+	}
+	if (normalized === "help") {
+		input.openHelp();
+		return true;
+	}
+	if (normalized === "history") {
+		input.openHistory();
+		return true;
+	}
+	if (normalized === "quit") {
+		setTimeout(input.exitCline, 0);
+		return true;
+	}
+	return false;
+}
diff --git a/apps/cli/src/tui/hooks/root-keyboard-routing.ts b/apps/cli/src/tui/hooks/root-keyboard-routing.ts
new file mode 100644
index 0000000..8593abe
--- /dev/null
+++ b/apps/cli/src/tui/hooks/root-keyboard-routing.ts
@@ -0,0 +1,6 @@
+export function shouldHandleInputHistory(input: {
+	isRunning: boolean;
+	hasQueuedPrompts: boolean;
+}): boolean {
+	return !input.isRunning || !input.hasQueuedPrompts;
+}
diff --git a/apps/cli/src/tui/hooks/transcript-keybinds.test.ts b/apps/cli/src/tui/hooks/transcript-keybinds.test.ts
new file mode 100644
index 0000000..60020d9
--- /dev/null
+++ b/apps/cli/src/tui/hooks/transcript-keybinds.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { matchTranscriptKeybind } from "./transcript-keybinds";
+
+function key(input: {
+	name: string;
+	ctrl?: boolean;
+	meta?: boolean;
+	shift?: boolean;
+}) {
+	return {
+		name: input.name,
+		ctrl: input.ctrl ?? false,
+		meta: input.meta ?? false,
+		shift: input.shift ?? false,
+	};
+}
+
+describe("matchTranscriptKeybind", () => {
+	it("matches OpenCode-style page scroll keybinds", () => {
+		expect(matchTranscriptKeybind(key({ name: "pageup" }))).toBe(
+			"messages_page_up",
+		);
+		expect(matchTranscriptKeybind(key({ name: "pagedown" }))).toBe(
+			"messages_page_down",
+		);
+		expect(
+			matchTranscriptKeybind(key({ name: "b", ctrl: true, meta: true })),
+		).toBe("messages_page_up");
+		expect(
+			matchTranscriptKeybind(key({ name: "f", ctrl: true, meta: true })),
+		).toBe("messages_page_down");
+	});
+
+	it("matches OpenCode-style half-page keybinds", () => {
+		expect(
+			matchTranscriptKeybind(key({ name: "u", ctrl: true, meta: true })),
+		).toBe("messages_half_page_up");
+		expect(
+			matchTranscriptKeybind(key({ name: "d", ctrl: true, meta: true })),
+		).toBe("messages_half_page_down");
+	});
+
+	it("matches transcript bound keybinds that do not conflict with input editing", () => {
+		expect(matchTranscriptKeybind(key({ name: "g", ctrl: true }))).toBe(
+			"messages_first",
+		);
+		expect(
+			matchTranscriptKeybind(key({ name: "g", ctrl: true, meta: true })),
+		).toBe("messages_last");
+	});
+
+	it("does not match modified variants outside the configured defaults", () => {
+		expect(matchTranscriptKeybind(key({ name: "home" }))).toBe(null);
+		expect(matchTranscriptKeybind(key({ name: "end" }))).toBe(null);
+		expect(matchTranscriptKeybind(key({ name: "home", ctrl: true }))).toBe(
+			null,
+		);
+		expect(matchTranscriptKeybind(key({ name: "pageup", shift: true }))).toBe(
+			null,
+		);
+	});
+});
diff --git a/apps/cli/src/tui/hooks/transcript-keybinds.ts b/apps/cli/src/tui/hooks/transcript-keybinds.ts
new file mode 100644
index 0000000..b84110f
--- /dev/null
+++ b/apps/cli/src/tui/hooks/transcript-keybinds.ts
@@ -0,0 +1,59 @@
+export type TranscriptCommand =
+	| "messages_page_up"
+	| "messages_page_down"
+	| "messages_half_page_up"
+	| "messages_half_page_down"
+	| "messages_first"
+	| "messages_last";
+
+type TranscriptKey = {
+	name: string;
+	ctrl: boolean;
+	meta: boolean;
+	shift: boolean;
+};
+
+type TranscriptKeybind = {
+	name: string;
+	ctrl?: boolean;
+	meta?: boolean;
+	shift?: boolean;
+};
+
+export const TRANSCRIPT_KEYBINDS: Record<
+	TranscriptCommand,
+	readonly TranscriptKeybind[]
+> = {
+	messages_page_up: [{ name: "pageup" }, { name: "b", ctrl: true, meta: true }],
+	messages_page_down: [
+		{ name: "pagedown" },
+		{ name: "f", ctrl: true, meta: true },
+	],
+	messages_half_page_up: [{ name: "u", ctrl: true, meta: true }],
+	messages_half_page_down: [{ name: "d", ctrl: true, meta: true }],
+	messages_first: [{ name: "g", ctrl: true }],
+	messages_last: [{ name: "g", ctrl: true, meta: true }],
+};
+
+function keybindMatches(
+	keybind: TranscriptKeybind,
+	key: TranscriptKey,
+): boolean {
+	return (
+		key.name === keybind.name &&
+		key.ctrl === !!keybind.ctrl &&
+		key.meta === !!keybind.meta &&
+		key.shift === !!keybind.shift
+	);
+}
+
+export function matchTranscriptKeybind(
+	key: TranscriptKey,
+): TranscriptCommand | null {
+	for (const [command, keybinds] of Object.entries(TRANSCRIPT_KEYBINDS)) {
+		if (keybinds.some((keybind) => keybindMatches(keybind, key))) {
+			return command as TranscriptCommand;
+		}
+	}
+	return null;
+}
diff --git a/apps/cli/src/tui/hooks/use-account-dialog.tsx b/apps/cli/src/tui/hooks/use-account-dialog.tsx
new file mode 100644
index 0000000..db8c4c4
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-account-dialog.tsx
@@ -0,0 +1,88 @@
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import type { DialogActions } from "@opentui-ui/dialog/react";
+import open from "open";
+import { useCallback } from "react";
+import type { ClineAccountSnapshot } from "../cline-account";
+import {
+	type AccountDialogAction,
+	AccountDialogContent,
+} from "../components/dialogs/account-dialog";
+import { OAuthLoginContent } from "../components/dialogs/provider-picker";
+import type { OpenModelSelectorOptions } from "./use-model-selector";
+
+export function useAccountDialog(opts: {
+	dialog: DialogActions;
+	termHeight: number;
+	loadAccount: () => Promise<ClineAccountSnapshot>;
+	switchAccount: (organizationId?: string | null) => Promise<void>;
+	onAccountChange?: () => Promise<void>;
+	openModelSelector: (options?: OpenModelSelectorOptions) => Promise<void>;
+	refocusTextarea: () => void;
+}) {
+	const {
+		dialog,
+		termHeight,
+		loadAccount,
+		switchAccount,
+		onAccountChange,
+		openModelSelector,
+		refocusTextarea,
+	} = opts;
+
+	const openAccountDialog = useCallback(async () => {
+		const action = await dialog.choice<AccountDialogAction>({
+			size: "large",
+			style: { maxHeight: termHeight - 2 },
+			closeOnEscape: false,
+			content: (ctx: ChoiceContext<AccountDialogAction>) => (
+				<AccountDialogContent
+					{...ctx}
+					loadAccount={loadAccount}
+					switchAccount={switchAccount}
+					onAccountChange={onAccountChange}
+				/>
+			),
+		});
+		if (action === "change-model") {
+			await openModelSelector({ onCancel: openAccountDialog });
+			return;
+		}
+		if (action === "change-provider") {
+			await openModelSelector({
+				onCancel: openAccountDialog,
+				startWithProviderChange: true,
+			});
+			return;
+		}
+		if (action === "learn-more") {
+			await open("https://cline.bot", { wait: false }).catch(() => {});
+			refocusTextarea();
+			return;
+		}
+		if (action === "login") {
+			const saved = await dialog.choice<boolean>({
+				style: { maxHeight: termHeight - 2 },
+				closeOnEscape: false,
+				content: (ctx: ChoiceContext<boolean>) => (
+					<OAuthLoginContent {...ctx} providerId="cline" providerName="Cline" />
+				),
+			});
+			if (saved) {
+				await onAccountChange?.();
+				await openAccountDialog();
+				return;
+			}
+		}
+		refocusTextarea();
+	}, [
+		dialog,
+		loadAccount,
+		onAccountChange,
+		openModelSelector,
+		refocusTextarea,
+		switchAccount,
+		termHeight,
+	]);
+
+	return openAccountDialog;
+}
diff --git a/apps/cli/src/tui/hooks/use-agent-events.ts b/apps/cli/src/tui/hooks/use-agent-events.ts
new file mode 100644
index 0000000..9384721
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-agent-events.ts
@@ -0,0 +1,318 @@
+import type { AgentEvent, TeamEvent } from "@cline/core";
+import { formatDisplayUserInput } from "@cline/shared";
+import { useCallback, useRef } from "react";
+import type {
+	PendingPromptSnapshot,
+	PendingPromptSubmittedEvent,
+} from "../../runtime/session-events";
+import { formatCliErrorMessage } from "../../utils/cline-pass-errors";
+import { resolveStatusNoticeLabel } from "../../utils/events";
+import {
+	formatToolInput,
+	formatToolOutput,
+	truncate,
+} from "../../utils/helpers";
+import type { ChatEntry, InlineStream, TuiProps } from "../types";
+
+interface AgentEventDeps {
+	appendEntry: (entry: ChatEntry) => void;
+	updateLastEntry: (updater: (prev: ChatEntry) => ChatEntry) => void;
+	updateEntry: (updater: (entry: ChatEntry) => ChatEntry) => void;
+	closeInlineStream: () => void;
+	activeInlineStreamRef: React.MutableRefObject<InlineStream>;
+	setIsRunning: (v: boolean) => void;
+	setIsStreaming: (v: boolean) => void;
+	addUsageDelta: (usage: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cost?: number;
+	}) => void;
+	onTurnErrorReported: TuiProps["onTurnErrorReported"];
+	verbose: boolean;
+}
+
+export function useAgentEventHandlers(deps: AgentEventDeps) {
+	const {
+		appendEntry,
+		updateLastEntry,
+		updateEntry,
+		closeInlineStream,
+		activeInlineStreamRef,
+		setIsRunning,
+		setIsStreaming,
+		addUsageDelta,
+		onTurnErrorReported,
+		verbose,
+	} = deps;
+
+	const closeToolEntry = useCallback(
+		(event: AgentEvent & { type: "content_end" }) => {
+			const error = event.error ?? undefined;
+			const output = event.output;
+			const result = {
+				outputSummary: error ? "" : formatToolOutput(output),
+				rawOutput: error ? undefined : output,
+				error,
+			};
+			if (event.toolCallId) {
+				updateEntry((entry) => {
+					if (
+						entry.kind !== "tool_call" ||
+						entry.toolCallId !== event.toolCallId
+					) {
+						return entry;
+					}
+					return { ...entry, streaming: false, result };
+				});
+			} else {
+				updateLastEntry((prev) => {
+					if (prev.kind !== "tool_call") return prev;
+					return { ...prev, streaming: false, result };
+				});
+			}
+		},
+		[updateEntry, updateLastEntry],
+	);
+
+	const turnErrorReportedRef = useRef(false);
+	const knownPendingPromptIdsRef = useRef(new Set<string>());
+
+	const handleAgentEvent = useCallback(
+		(event: AgentEvent) => {
+			switch (event.type) {
+				case "iteration_start":
+					setIsRunning(true);
+					setIsStreaming(true);
+					closeInlineStream();
+					break;
+				case "iteration_end":
+					closeInlineStream();
+					break;
+				case "content_start": {
+					setIsStreaming(false);
+					switch (event.contentType) {
+						case "text": {
+							if (activeInlineStreamRef.current !== "text") {
+								closeInlineStream();
+								activeInlineStreamRef.current = "text";
+								appendEntry({
+									kind: "assistant_text",
+									text: event.text ?? "",
+									streaming: true,
+								});
+							} else {
+								updateLastEntry((prev) =>
+									prev.kind === "assistant_text"
+										? { ...prev, text: prev.text + (event.text ?? "") }
+										: prev,
+								);
+							}
+							break;
+						}
+						case "reasoning": {
+							const chunk =
+								event.redacted && !event.reasoning
+									? "[redacted]"
+									: (event.reasoning ?? "");
+							if (activeInlineStreamRef.current !== "reasoning") {
+								closeInlineStream();
+								activeInlineStreamRef.current = "reasoning";
+								appendEntry({
+									kind: "reasoning",
+									text: chunk,
+									streaming: true,
+								});
+							} else {
+								updateLastEntry((prev) =>
+									prev.kind === "reasoning"
+										? { ...prev, text: prev.text + chunk }
+										: prev,
+								);
+							}
+							break;
+						}
+						case "tool": {
+							closeInlineStream();
+							const toolName = event.toolName ?? "unknown_tool";
+							appendEntry({
+								kind: "tool_call",
+								toolCallId: event.toolCallId,
+								toolName,
+								inputSummary: formatToolInput(toolName, event.input),
+								rawInput: event.input,
+								streaming: true,
+							});
+							break;
+						}
+					}
+					break;
+				}
+				case "content_end": {
+					switch (event.contentType) {
+						case "text":
+						case "reasoning":
+							closeInlineStream();
+							break;
+						case "tool": {
+							closeInlineStream();
+							closeToolEntry(event);
+							break;
+						}
+					}
+					break;
+				}
+				case "done":
+					setIsRunning(false);
+					setIsStreaming(false);
+					closeInlineStream();
+					break;
+				case "error":
+					setIsRunning(false);
+					setIsStreaming(false);
+					closeInlineStream();
+					turnErrorReportedRef.current = true;
+					onTurnErrorReported(true);
+					if (!event.recoverable || verbose) {
+						appendEntry({
+							kind: "error",
+							text: formatCliErrorMessage(event.error),
+						});
+					}
+					break;
+				case "notice":
+					if (event.displayRole === "status") {
+						closeInlineStream();
+						const label = resolveStatusNoticeLabel(event);
+						if (label) {
+							appendEntry({ kind: "status", text: label });
+						}
+					}
+					break;
+				case "usage":
+					addUsageDelta({
+						inputTokens: event.inputTokens,
+						outputTokens: event.outputTokens,
+						cost: event.cost,
+					});
+					break;
+			}
+		},
+		[
+			appendEntry,
+			updateLastEntry,
+			closeInlineStream,
+			activeInlineStreamRef,
+			setIsRunning,
+			setIsStreaming,
+			addUsageDelta,
+			onTurnErrorReported,
+			verbose,
+			closeToolEntry,
+		],
+	);
+
+	const handleTeamEvent = useCallback(
+		(event: TeamEvent) => {
+			const team = (text: string) => {
+				closeInlineStream();
+				appendEntry({ kind: "team", text });
+			};
+			switch (event.type) {
+				case "teammate_spawned":
+					team(`[team] teammate spawned: ${event.agentId}`);
+					break;
+				case "teammate_shutdown":
+					team(`[team] teammate shutdown: ${event.agentId}`);
+					break;
+				case "team_task_updated":
+					team(`[team task] ${event.task.id} -> ${event.task.status}`);
+					break;
+				case "team_message":
+					team(
+						`[mailbox] ${event.message.fromAgentId} -> ${event.message.toAgentId}: ${event.message.subject}`,
+					);
+					break;
+				case "team_mission_log":
+					team(
+						`[mission] ${event.entry.agentId}: ${truncate(event.entry.summary, 90)}`,
+					);
+					break;
+				case "run_queued":
+					team(`[team run] queued ${event.run.id} -> ${event.run.agentId} ...`);
+					break;
+				case "run_started":
+					team(
+						`[team run] started ${event.run.id} -> ${event.run.agentId} ...`,
+					);
+					break;
+				case "run_progress":
+					if (event.message === "heartbeat") break;
+					team(`[team run] progress ${event.run.id}: ${event.message}`);
+					break;
+				case "run_completed":
+					team(`[team run] completed ${event.run.id}`);
+					break;
+				case "run_failed":
+					team(
+						`[team run] failed ${event.run.id}: ${event.run.error ?? "unknown error"}`,
+					);
+					break;
+				case "run_cancelled":
+					team(`[team run] cancelled ${event.run.id}`);
+					break;
+				case "run_interrupted":
+					team(`[team run] interrupted ${event.run.id}`);
+					break;
+				case "outcome_created":
+					team(
+						`[team outcome] created ${event.outcome.id}: ${event.outcome.title}`,
+					);
+					break;
+				case "outcome_fragment_attached":
+					team(
+						`[team outcome] fragment ${event.fragment.id} attached to ${event.fragment.section}`,
+					);
+					break;
+				case "outcome_fragment_reviewed":
+					team(
+						`[team outcome] fragment ${event.fragment.id} -> ${event.fragment.status}`,
+					);
+					break;
+				case "outcome_finalized":
+					team(`[team outcome] finalized ${event.outcome.id}`);
+					break;
+				case "task_start":
+				case "task_end":
+				case "agent_event":
+					break;
+			}
+		},
+		[appendEntry, closeInlineStream],
+	);
+
+	const handlePendingPrompts = useCallback((event: PendingPromptSnapshot) => {
+		knownPendingPromptIdsRef.current = new Set(event.prompts.map((e) => e.id));
+	}, []);
+
+	const handlePendingPromptSubmitted = useCallback(
+		(event: PendingPromptSubmittedEvent) => {
+			knownPendingPromptIdsRef.current.delete(event.id);
+			// Display boundary: formatDisplayUserInput strips runtime-generated
+			// notice elements (e.g. mode_notice) that normalizeUserInput must
+			// preserve, since the latter also sanitizes model-bound prompts.
+			appendEntry({
+				kind: "user_submitted",
+				text: formatDisplayUserInput(event.prompt),
+			});
+		},
+		[appendEntry],
+	);
+
+	return {
+		handleAgentEvent,
+		handleTeamEvent,
+		handlePendingPrompts,
+		handlePendingPromptSubmitted,
+		turnErrorReportedRef,
+	};
+}
diff --git a/apps/cli/src/tui/hooks/use-autocomplete.test.ts b/apps/cli/src/tui/hooks/use-autocomplete.test.ts
new file mode 100644
index 0000000..560229a
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-autocomplete.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import {
+	extractSlashQuery,
+	formatMentionAutocompleteValue,
+	getFirstSelectableIndex,
+	insertMention,
+} from "./use-autocomplete";
+
+describe("TUI autocomplete slash command replacement", () => {
+	it("detects a slash query immediately before the cursor", () => {
+		expect(extractSlashQuery("/review")).toEqual({
+			inSlashMode: true,
+			query: "review",
+			slashIndex: 0,
+		});
+		expect(extractSlashQuery("please /review")).toEqual({
+			inSlashMode: true,
+			query: "review",
+			slashIndex: 7,
+		});
+	});
+
+	it("supports replacing only the slash token at the cursor", () => {
+		const text = "please /review this file";
+		const cursor = "please /review".length;
+		const slash = extractSlashQuery(text.slice(0, cursor));
+		const replacement = "/review ";
+
+		expect(slash.inSlashMode).toBe(true);
+		if (!slash.inSlashMode) return;
+		expect(
+			text.slice(0, slash.slashIndex) + replacement + text.slice(cursor),
+		).toBe("please /review  this file");
+	});
+
+	it("selects the first command option instead of a section header", () => {
+		expect(
+			getFirstSelectableIndex([
+				{ display: "Skills", value: "", isHeader: true },
+				{ display: "/review", value: "/review " },
+			]),
+		).toBe(1);
+	});
+
+	it("formats workspace mention completions as relative file mentions", () => {
+		expect(formatMentionAutocompleteValue("src/main.ts")).toBe(
+			"@./src/main.ts ",
+		);
+		expect(insertMention("open @src", 5, "src/main.ts")).toBe(
+			"open @./src/main.ts ",
+		);
+	});
+
+	it("preserves parser-compatible mention prefixes", () => {
+		expect(formatMentionAutocompleteValue("/tmp/file.txt")).toBe(
+			"@/tmp/file.txt ",
+		);
+		expect(formatMentionAutocompleteValue("~/file.txt")).toBe("@~/file.txt ");
+		expect(formatMentionAutocompleteValue("./file.txt")).toBe("@./file.txt ");
+		expect(formatMentionAutocompleteValue("../file.txt")).toBe("@../file.txt ");
+	});
+
+	it("quotes parser-compatible mention paths containing spaces", () => {
+		expect(formatMentionAutocompleteValue("docs/my file.md")).toBe(
+			'@"./docs/my file.md" ',
+		);
+		expect(insertMention("open @docs", 5, "docs/my file.md")).toBe(
+			'open @"./docs/my file.md" ',
+		);
+	});
+});
diff --git a/apps/cli/src/tui/hooks/use-autocomplete.ts b/apps/cli/src/tui/hooks/use-autocomplete.ts
new file mode 100644
index 0000000..c5a0f74
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-autocomplete.ts
@@ -0,0 +1,277 @@
+import { useCallback, useRef, useState } from "react";
+import { searchWorkspaceFilesForMention } from "../../tui/interactive-welcome";
+import {
+	formatSlashCommandAutocompleteValue,
+	type SlashCommandRegistryEntry,
+} from "../commands/slash-command-registry";
+import { COMPLETION_DEBOUNCE_MS, MAX_COMPLETION_RESULTS } from "../types";
+
+export type AutocompleteMode = false | "@" | "/";
+
+interface MentionQueryInfo {
+	inMentionMode: boolean;
+	query: string;
+	atIndex: number;
+}
+
+interface SlashQueryInfo {
+	inSlashMode: boolean;
+	query: string;
+	slashIndex: number;
+}
+
+export function extractMentionQuery(text: string): MentionQueryInfo {
+	const atIndex = text.lastIndexOf("@");
+	if (atIndex === -1 || (atIndex > 0 && !/\s/.test(text[atIndex - 1] ?? ""))) {
+		return { inMentionMode: false, query: "", atIndex: -1 };
+	}
+	const query = text.slice(atIndex + 1);
+	if (query.includes(" ")) {
+		return { inMentionMode: false, query: "", atIndex: -1 };
+	}
+	return { inMentionMode: true, query, atIndex };
+}
+
+export function extractSlashQuery(text: string): SlashQueryInfo {
+	const slashIndex = text.lastIndexOf("/");
+	if (slashIndex === -1) {
+		return { inSlashMode: false, query: "", slashIndex: -1 };
+	}
+	if (slashIndex > 0 && !/\s/.test(text[slashIndex - 1] ?? "")) {
+		return { inSlashMode: false, query: "", slashIndex: -1 };
+	}
+	const query = text.slice(slashIndex + 1);
+	if (/\s/.test(query)) {
+		return { inSlashMode: false, query: "", slashIndex: -1 };
+	}
+	const firstSlashCommandRegex = /(^|\s)\/[a-zA-Z0-9_.-]+\s/;
+	const textBeforeCurrentSlash = text.slice(0, slashIndex);
+	if (firstSlashCommandRegex.test(textBeforeCurrentSlash)) {
+		return { inSlashMode: false, query: "", slashIndex: -1 };
+	}
+	return { inSlashMode: true, query, slashIndex };
+}
+
+export function insertMention(
+	text: string,
+	atIndex: number,
+	filePath: string,
+): string {
+	const endIndex = text.indexOf(" ", atIndex);
+	const end = endIndex === -1 ? text.length : endIndex;
+	const normalizedPath =
+		filePath.startsWith("/") ||
+		filePath.startsWith("~/") ||
+		filePath.startsWith("./") ||
+		filePath.startsWith("../")
+			? filePath
+			: `./${filePath}`;
+	const mention = normalizedPath.includes(" ")
+		? `@"${normalizedPath}"`
+		: `@${normalizedPath}`;
+	return `${text.slice(0, atIndex)}${mention} ${text.slice(end).trimStart()}`;
+}
+
+export function formatMentionAutocompleteValue(filePath: string): string {
+	const normalizedPath =
+		filePath.startsWith("/") ||
+		filePath.startsWith("~/") ||
+		filePath.startsWith("./") ||
+		filePath.startsWith("../")
+			? filePath
+			: `./${filePath}`;
+	const mention = normalizedPath.includes(" ")
+		? `@"${normalizedPath}"`
+		: `@${normalizedPath}`;
+	return `${mention} `;
+}
+
+export function insertSlashCommand(
+	text: string,
+	slashIndex: number,
+	commandName: string,
+): string {
+	return `${text.slice(0, slashIndex)}/${commandName} `;
+}
+
+export interface AutocompleteOption {
+	display: string;
+	value: string;
+	description?: string;
+	onSelect?: () => void;
+	isHeader?: boolean;
+	commandName?: string;
+	commandExecution?: SlashCommandRegistryEntry["execution"];
+	commandSource?: SlashCommandRegistryEntry["source"];
+	commandPreserveInput?: SlashCommandRegistryEntry["preserveInput"];
+}
+
+export interface AutocompleteState {
+	mode: AutocompleteMode;
+	filter: string;
+	selected: number;
+	filteredOptions: AutocompleteOption[];
+	mentionResults: string[];
+}
+
+export function getFirstSelectableIndex(
+	options: readonly AutocompleteOption[],
+): number {
+	const index = options.findIndex((option) => !option.isHeader);
+	return index === -1 ? 0 : index;
+}
+
+export function useAutocomplete(opts: {
+	workspaceRoot: string;
+	systemCommands: SlashCommandRegistryEntry[];
+	skillCommands: SlashCommandRegistryEntry[];
+}) {
+	const { workspaceRoot, systemCommands, skillCommands } = opts;
+
+	const [mode, setMode] = useState<AutocompleteMode>(false);
+	const [filter, setFilter] = useState("");
+	const [selected, setSelected] = useState(0);
+	const [mentionResults, setMentionResults] = useState<string[]>([]);
+
+	const searchTimerRef = useRef<NodeJS.Timeout | null>(null);
+	const searchCounterRef = useRef(0);
+
+	const systemOptions: AutocompleteOption[] = systemCommands.map((cmd) => ({
+		display: `/${cmd.name}`,
+		value: formatSlashCommandAutocompleteValue(cmd),
+		description: cmd.description,
+		commandName: cmd.name,
+		commandExecution: cmd.execution,
+		commandSource: cmd.source,
+		commandPreserveInput: cmd.preserveInput,
+	}));
+
+	const skillOptions: AutocompleteOption[] = skillCommands.map((cmd) => ({
+		display: `/${cmd.name}`,
+		value: formatSlashCommandAutocompleteValue(cmd),
+		description: cmd.description,
+		commandName: cmd.name,
+		commandExecution: cmd.execution,
+		commandSource: cmd.source,
+		commandPreserveInput: cmd.preserveInput,
+	}));
+
+	const getFilteredSlashOptions = useCallback(
+		(query: string): AutocompleteOption[] => {
+			const q = query.toLowerCase();
+			const filterFn = (o: AutocompleteOption) => {
+				if (!q) return true;
+				const name = o.display.toLowerCase().slice(1);
+				const desc = o.description?.toLowerCase() ?? "";
+				return name.includes(q) || desc.includes(q);
+			};
+			const sortFn = (a: AutocompleteOption, b: AutocompleteOption) => {
+				if (!q) return 0;
+				const aName = a.display.toLowerCase().slice(1);
+				const bName = b.display.toLowerCase().slice(1);
+				const aNameStarts = aName.startsWith(q);
+				const bNameStarts = bName.startsWith(q);
+				if (aNameStarts && !bNameStarts) return -1;
+				if (!aNameStarts && bNameStarts) return 1;
+				const aNameIncludes = aName.includes(q);
+				const bNameIncludes = bName.includes(q);
+				if (aNameIncludes && !bNameIncludes) return -1;
+				if (!aNameIncludes && bNameIncludes) return 1;
+				return 0;
+			};
+
+			const filteredSystem = systemOptions.filter(filterFn).sort(sortFn);
+			const filteredSkills = skillOptions.filter(filterFn).sort(sortFn);
+
+			if (filteredSkills.length === 0) return filteredSystem;
+
+			const result: AutocompleteOption[] = [...filteredSystem];
+			result.push({
+				display: "Skills",
+				value: "",
+				isHeader: true,
+			});
+			result.push(...filteredSkills);
+			return result.slice(0, MAX_COMPLETION_RESULTS);
+		},
+		[systemOptions, skillOptions],
+	);
+
+	const getFilteredMentionOptions = useCallback(
+		(_query: string): AutocompleteOption[] => {
+			return mentionResults.slice(0, MAX_COMPLETION_RESULTS).map((f) => ({
+				display: f,
+				value: formatMentionAutocompleteValue(f),
+			}));
+		},
+		[mentionResults],
+	);
+
+	const updateAutocomplete = useCallback(
+		(text: string) => {
+			const slash = extractSlashQuery(text);
+			if (slash.inSlashMode) {
+				setMode("/");
+				setFilter(slash.query);
+				setSelected(
+					getFirstSelectableIndex(getFilteredSlashOptions(slash.query)),
+				);
+				return;
+			}
+
+			const mention = extractMentionQuery(text);
+			if (mention.inMentionMode) {
+				setMode("@");
+				setFilter(mention.query);
+				setSelected(0);
+
+				if (searchTimerRef.current) {
+					clearTimeout(searchTimerRef.current);
+				}
+				setMentionResults([]);
+				const counter = ++searchCounterRef.current;
+				searchTimerRef.current = setTimeout(() => {
+					searchWorkspaceFilesForMention({
+						workspaceRoot,
+						query: mention.query,
+						limit: MAX_COMPLETION_RESULTS,
+					})
+						.then((results) => {
+							if (counter === searchCounterRef.current) {
+								setMentionResults(results);
+							}
+						})
+						.catch(() => {});
+				}, COMPLETION_DEBOUNCE_MS);
+				return;
+			}
+
+			setMode(false);
+			setFilter("");
+		},
+		[workspaceRoot, getFilteredSlashOptions],
+	);
+
+	const getFilteredOptions = useCallback((): AutocompleteOption[] => {
+		if (mode === "/") return getFilteredSlashOptions(filter);
+		if (mode === "@") return getFilteredMentionOptions(filter);
+		return [];
+	}, [mode, filter, getFilteredSlashOptions, getFilteredMentionOptions]);
+
+	const close = useCallback(() => {
+		setMode(false);
+		setFilter("");
+		setSelected(0);
+	}, []);
+
+	return {
+		mode,
+		filter,
+		selected,
+		setSelected,
+		updateAutocomplete,
+		getFilteredOptions,
+		close,
+		setMode,
+	};
+}
diff --git a/apps/cli/src/tui/hooks/use-config-panel.tsx b/apps/cli/src/tui/hooks/use-config-panel.tsx
new file mode 100644
index 0000000..2dceb06
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-config-panel.tsx
@@ -0,0 +1,180 @@
+import { Llms } from "@cline/core";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import type { DialogActions } from "@opentui-ui/dialog/react";
+import { useCallback, useMemo } from "react";
+import type {
+	InteractiveConfigData,
+	InteractiveConfigItem,
+	InteractiveConfigTab,
+	LoadInteractiveConfigDataOptions,
+} from "../../tui/interactive-config";
+import type { CliCompactionMode, Config } from "../../utils/types";
+import {
+	ConfigErrorContent,
+	DeleteConfigItemConfirmContent,
+	ExtDetailContent,
+} from "../components/dialogs/config-dialogs";
+import { withLoadingDialog } from "../components/dialogs/loading-dialog";
+import { ConfigPanelContent } from "../views/config-view";
+import type { ConfigAction } from "../views/config-view-helpers";
+import type { OpenModelSelectorOptions } from "./use-model-selector";
+
+export interface OpenConfigOptions {
+	initialTab?: InteractiveConfigTab;
+}
+
+export function useConfigPanel(opts: {
+	dialog: DialogActions;
+	config: Config;
+	sessionUiMode: string;
+	compactionMode: CliCompactionMode;
+	toggleMode: () => void;
+	toggleAutoApprove: () => void;
+	setCompactionMode: (mode: CliCompactionMode) => void;
+	termHeight: number;
+	loadConfigData: (
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData>;
+	onToggleConfigItem?: (
+		item: InteractiveConfigItem,
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData | undefined>;
+	onDeleteConfigItem?: (
+		item: InteractiveConfigItem,
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData | undefined>;
+	openModelSelector: (options?: OpenModelSelectorOptions) => Promise<void>;
+	openMcpManager: (options?: { refocus?: boolean }) => Promise<boolean>;
+	refocusTextarea: () => void;
+}) {
+	const emptyConfigData = useMemo(
+		() => ({
+			workflows: [] as InteractiveConfigItem[],
+			rules: [] as InteractiveConfigItem[],
+			skills: [] as InteractiveConfigItem[],
+			hooks: [] as InteractiveConfigItem[],
+			agents: [] as InteractiveConfigItem[],
+			plugins: [] as InteractiveConfigItem[],
+			mcp: [] as InteractiveConfigItem[],
+			tools: [] as InteractiveConfigItem[],
+			workflowSlashCommands: [],
+		}),
+		[],
+	);
+
+	const openConfig = useCallback(
+		async (options: OpenConfigOptions = {}) => {
+			let keepOpen = true;
+			let activeTab = options.initialTab;
+			while (keepOpen) {
+				const [data, providerInfo] = await withLoadingDialog(
+					opts.dialog,
+					"Loading settings...",
+					async () =>
+						await Promise.all([
+							opts
+								.loadConfigData({ includePluginTools: false })
+								.catch(() => emptyConfigData),
+							Llms.getProvider(opts.config.providerId).catch(() => undefined),
+						]),
+				);
+				const providerDisplayName =
+					providerInfo?.name ?? opts.config.providerId;
+				const action = await opts.dialog.choice<ConfigAction>({
+					size: "large",
+					style: { maxHeight: opts.termHeight - 2 },
+					closeOnEscape: false,
+					content: (ctx: ChoiceContext<ConfigAction>) => (
+						<ConfigPanelContent
+							{...ctx}
+							config={opts.config}
+							configData={data}
+							loadConfigData={opts.loadConfigData}
+							providerDisplayName={providerDisplayName}
+							currentMode={opts.sessionUiMode}
+							currentCompactionMode={opts.compactionMode}
+							initialTab={activeTab}
+							onActiveTabChange={(tab) => {
+								activeTab = tab;
+							}}
+							onToggleConfigItem={opts.onToggleConfigItem}
+							onDeleteConfigItem={opts.onDeleteConfigItem}
+							onToggleMode={opts.toggleMode}
+							onToggleAutoApprove={opts.toggleAutoApprove}
+							onSetCompactionMode={opts.setCompactionMode}
+						/>
+					),
+				});
+
+				if (!action) {
+					keepOpen = false;
+					continue;
+				}
+
+				if (action.kind === "open-provider") {
+					await opts.openModelSelector({
+						startWithProviderChange: true,
+						onCancel: () => {},
+					});
+				} else if (action.kind === "open-model") {
+					await opts.openModelSelector({ onCancel: () => {} });
+				} else if (action.kind === "toggle-item") {
+					await opts.onToggleConfigItem?.(action.item);
+				} else if (action.kind === "delete-item") {
+					const confirmed = await opts.dialog.choice<boolean>({
+						closeOnEscape: true,
+						content: (ctx: ChoiceContext<boolean>) => (
+							<DeleteConfigItemConfirmContent {...ctx} item={action.item} />
+						),
+					});
+					if (confirmed && opts.onDeleteConfigItem) {
+						try {
+							await withLoadingDialog(
+								opts.dialog,
+								`Deleting ${action.item.name}...`,
+								async () =>
+									await opts.onDeleteConfigItem?.(action.item, {
+										includePluginTools: false,
+									}),
+							);
+						} catch (error) {
+							await opts.dialog.choice<void>({
+								closeOnEscape: true,
+								content: (ctx: ChoiceContext<void>) => (
+									<ConfigErrorContent
+										{...ctx}
+										title="Plugin delete failed"
+										message={
+											error instanceof Error ? error.message : String(error)
+										}
+									/>
+								),
+							});
+						}
+					}
+				} else if (action.kind === "ext-detail") {
+					await opts.dialog.choice<void>({
+						style: { maxHeight: opts.termHeight - 2 },
+						closeOnEscape: false,
+						content: (ctx: ChoiceContext<void>) => (
+							<ExtDetailContent
+								{...ctx}
+								item={action.item}
+								onToggleConfigItem={opts.onToggleConfigItem}
+							/>
+						),
+					});
+				} else if (action.kind === "open-mcp") {
+					const changed = await opts.openMcpManager({ refocus: false });
+					if (changed) {
+						keepOpen = false;
+					}
+				}
+			}
+			opts.refocusTextarea();
+		},
+		[opts, emptyConfigData],
+	);
+
+	return openConfig;
+}
diff --git a/apps/cli/src/tui/hooks/use-input-history.test.ts b/apps/cli/src/tui/hooks/use-input-history.test.ts
new file mode 100644
index 0000000..b183cc3
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-input-history.test.ts
@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { getHistoryNavigationAction } from "./use-input-history";
+
+const basePosition = {
+	cursorOffset: 4,
+	textLength: 10,
+	visualRow: 1,
+	height: 3,
+	virtualLineCount: 3,
+};
+
+describe("history navigation boundaries", () => {
+	it("navigates previous history when the cursor is at the start", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "up",
+				cursorOffset: 0,
+				visualRow: 0,
+			}),
+		).toBe("navigate");
+	});
+
+	it("moves to the start before previous history on the first visual row", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "up",
+				cursorOffset: 5,
+				visualRow: 0,
+			}),
+		).toBe("move-to-boundary");
+	});
+
+	it("lets up move through text when the cursor is below the first visual row", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "up",
+				cursorOffset: 5,
+				visualRow: 1,
+			}),
+		).toBe("ignore");
+	});
+
+	it("navigates next history when the cursor is at the end", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "down",
+				cursorOffset: 10,
+				visualRow: 2,
+			}),
+		).toBe("navigate");
+	});
+
+	it("moves to the end before next history on the last visual row", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "down",
+				cursorOffset: 5,
+				visualRow: 2,
+			}),
+		).toBe("move-to-boundary");
+	});
+
+	it("uses content height for the bottom row when the textarea is taller", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "down",
+				cursorOffset: 5,
+				visualRow: 0,
+				height: 5,
+				virtualLineCount: 1,
+			}),
+		).toBe("move-to-boundary");
+	});
+
+	it("lets down move through text when the cursor is above the last visual row", () => {
+		expect(
+			getHistoryNavigationAction({
+				...basePosition,
+				direction: "down",
+				cursorOffset: 5,
+				visualRow: 1,
+			}),
+		).toBe("ignore");
+	});
+});
diff --git a/apps/cli/src/tui/hooks/use-input-history.ts b/apps/cli/src/tui/hooks/use-input-history.ts
new file mode 100644
index 0000000..effb6f6
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-input-history.ts
@@ -0,0 +1,132 @@
+import { useCallback, useRef, useState } from "react";
+import {
+	appendInputHistory,
+	loadInputHistory,
+	prependInputHistoryEntry,
+} from "../../utils/input-history";
+import type { TextareaHandle } from "../components/input-bar";
+
+type HistoryDirection = "up" | "down";
+type HistoryNavigationAction = "navigate" | "move-to-boundary" | "ignore";
+
+export interface HistoryNavigationPosition {
+	direction: HistoryDirection;
+	cursorOffset: number;
+	textLength: number;
+	visualRow: number;
+	height: number;
+	virtualLineCount: number;
+}
+
+export function getHistoryNavigationAction(
+	position: HistoryNavigationPosition,
+): HistoryNavigationAction {
+	if (position.direction === "up") {
+		if (position.cursorOffset <= 0) return "navigate";
+		return position.visualRow === 0 ? "move-to-boundary" : "ignore";
+	}
+
+	if (position.cursorOffset >= position.textLength) return "navigate";
+
+	const visibleLineCount = Math.max(
+		1,
+		Math.min(position.height, Math.max(1, position.virtualLineCount)),
+	);
+	const bottomVisualRow = visibleLineCount - 1;
+	return position.visualRow >= bottomVisualRow ? "move-to-boundary" : "ignore";
+}
+
+export function useInputHistory(
+	textareaRef: React.MutableRefObject<TextareaHandle | null>,
+) {
+	const [history, setHistory] = useState<string[]>(() => loadInputHistory());
+	const historyRef = useRef(history);
+	const indexRef = useRef(-1);
+	const savedInputRef = useRef("");
+	const pendingHistoryTextRef = useRef<string | null>(null);
+	historyRef.current = history;
+
+	const navigateHistory = useCallback(
+		(direction: HistoryDirection, currentInput: string) => {
+			const ta = textareaRef.current;
+			const entries = historyRef.current;
+			if (!ta) return false;
+
+			const action = getHistoryNavigationAction({
+				direction,
+				cursorOffset: ta.cursorOffset,
+				textLength: ta.plainText.length,
+				visualRow: ta.visualCursor.visualRow,
+				height: ta.height,
+				virtualLineCount: ta.virtualLineCount,
+			});
+
+			if (action === "ignore") return false;
+
+			if (action === "move-to-boundary") {
+				ta.cursorOffset = direction === "up" ? 0 : ta.plainText.length;
+				return true;
+			}
+
+			if (entries.length === 0) return false;
+
+			if (indexRef.current === -1) {
+				if (direction === "down") return false;
+				savedInputRef.current = currentInput;
+			}
+
+			if (direction === "up") {
+				if (indexRef.current < entries.length - 1) {
+					indexRef.current++;
+				} else {
+					return false;
+				}
+			} else {
+				if (indexRef.current > -1) {
+					indexRef.current--;
+				} else {
+					return false;
+				}
+			}
+
+			const text =
+				indexRef.current === -1
+					? savedInputRef.current
+					: (entries[indexRef.current] ?? "");
+
+			pendingHistoryTextRef.current = text;
+			ta.setText(text);
+			ta.cursorOffset = direction === "up" ? 0 : text.length;
+			return true;
+		},
+		[textareaRef],
+	);
+
+	const resetHistoryIndex = useCallback(() => {
+		indexRef.current = -1;
+	}, []);
+
+	const recordHistoryEntry = useCallback(
+		(prompt: string) => {
+			appendInputHistory(prompt);
+			setHistory((current) => prependInputHistoryEntry(current, prompt));
+			resetHistoryIndex();
+		},
+		[resetHistoryIndex],
+	);
+
+	const shouldResetHistoryIndex = useCallback((text: string) => {
+		if (pendingHistoryTextRef.current === text) {
+			pendingHistoryTextRef.current = null;
+			return false;
+		}
+		return true;
+	}, []);
+
+	return {
+		navigateHistory,
+		recordHistoryEntry,
+		resetHistoryIndex,
+		shouldResetHistoryIndex,
+	};
+}
diff --git a/apps/cli/src/tui/hooks/use-local-command-actions.test.ts b/apps/cli/src/tui/hooks/use-local-command-actions.test.ts
new file mode 100644
index 0000000..4f11e72
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-local-command-actions.test.ts
@@ -0,0 +1,176 @@
+import { describe, expect, it, vi } from "vitest";
+import { formatCompactionStatus } from "../utils/compaction-status";
+import {
+	type LocalSlashCommandActionInput,
+	runLocalSlashCommandAction,
+} from "./local-command-actions";
+
+function makeActions(
+	overrides: Partial<Omit<LocalSlashCommandActionInput, "name">> = {},
+): Omit<LocalSlashCommandActionInput, "name"> {
+	return {
+		openAccount: vi.fn(),
+		openConfig: vi.fn(),
+		openMcpManager: vi.fn(async () => false),
+		openModelSelector: vi.fn(),
+		openSkills: vi.fn(),
+		runCompact: vi.fn(),
+		runFork: vi.fn(),
+		runUndo: vi.fn(async () => {}),
+		clearConversation: vi.fn(async () => {}),
+		openHelp: vi.fn(),
+		openHistory: vi.fn(),
+		exitCline: vi.fn(),
+		...overrides,
+	};
+}
+
+describe("runLocalSlashCommandAction", () => {
+	it("opens the skills picker with skills", () => {
+		const openSkills = vi.fn();
+		const actions = makeActions({ openSkills });
+		const invocation = {
+			text: "please /skills",
+			cursorOffset: "please /skills".length,
+			replaceRange: { start: "please ".length, end: "please /skills".length },
+		};
+
+		const handled = runLocalSlashCommandAction({
+			name: "skills",
+			invocation,
+			...actions,
+		});
+
+		expect(handled).toBe(true);
+		expect(openSkills).toHaveBeenCalledWith(invocation);
+	});
+
+	it("opens settings to the plugins tab with plugins", () => {
+		const openConfig = vi.fn();
+		const actions = makeActions({ openConfig });
+
+		const handled = runLocalSlashCommandAction({
+			name: "plugins",
+			...actions,
+		});
+
+		expect(handled).toBe(true);
+		expect(openConfig).toHaveBeenCalledWith({ initialTab: "plugins" });
+	});
+
+	it("waits for clear to reset the runtime session", async () => {
+		let resolveClear: (() => void) | undefined;
+		const clearConversation = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveClear = resolve;
+				}),
+		);
+		const actions = makeActions({ clearConversation });
+
+		const handled = runLocalSlashCommandAction({
+			name: "clear",
+			...actions,
+		});
+		const handledPromise = Promise.resolve(handled);
+		let settled = false;
+		void handledPromise.then(() => {
+			settled = true;
+		});
+
+		await Promise.resolve();
+
+		expect(clearConversation).toHaveBeenCalledOnce();
+		expect(settled).toBe(false);
+
+		resolveClear?.();
+
+		expect(await handledPromise).toBe(true);
+		expect(settled).toBe(true);
+	});
+
+	it("waits for undo to finish restoring", async () => {
+		let resolveUndo: (() => void) | undefined;
+		const runUndo = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveUndo = resolve;
+				}),
+		);
+		const actions = makeActions({ runUndo });
+
+		const handled = runLocalSlashCommandAction({
+			name: "undo",
+			...actions,
+		});
+		const handledPromise = Promise.resolve(handled);
+		let settled = false;
+		void handledPromise.then(() => {
+			settled = true;
+		});
+
+		await Promise.resolve();
+
+		expect(runUndo).toHaveBeenCalledOnce();
+		expect(settled).toBe(false);
+
+		resolveUndo?.();
+
+		expect(await handledPromise).toBe(true);
+		expect(settled).toBe(true);
+	});
+
+	it("exits Cline with quit", () => {
+		vi.useFakeTimers();
+		const exitCline = vi.fn();
+		const actions = makeActions({ exitCline });
+
+		try {
+			const handled = runLocalSlashCommandAction({
+				name: "quit",
+				...actions,
+			});
+
+			expect(handled).toBe(true);
+			expect(exitCline).not.toHaveBeenCalled();
+
+			vi.runAllTimers();
+
+			expect(exitCline).toHaveBeenCalledOnce();
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
+
+describe("formatCompactionStatus", () => {
+	it("reports when core did not return a compaction result", () => {
+		expect(
+			formatCompactionStatus({
+				messagesBefore: 300,
+				messagesAfter: 300,
+				compacted: false,
+			}),
+		).toBe("No compaction needed.");
+	});
+
+	it("reports same-count compaction without implying no-op", () => {
+		expect(
+			formatCompactionStatus({
+				messagesBefore: 300,
+				messagesAfter: 300,
+				compacted: true,
+			}),
+		).toBe("Compacted context; message count stayed at 300 messages.");
+	});
+
+	it("reports empty sessions separately", () => {
+		expect(
+			formatCompactionStatus({
+				messagesBefore: 0,
+				messagesAfter: 0,
+				compacted: false,
+			}),
+		).toBe("No messages to compact.");
+	});
+});
diff --git a/apps/cli/src/tui/hooks/use-local-command-actions.tsx b/apps/cli/src/tui/hooks/use-local-command-actions.tsx
new file mode 100644
index 0000000..60134e9
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-local-command-actions.tsx
@@ -0,0 +1,217 @@
+import { useTerminalDimensions } from "@opentui/react";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialog } from "@opentui-ui/dialog/react";
+import { useCallback } from "react";
+import type { SlashCommandRegistry } from "../commands/slash-command-registry";
+import { resolveSlashCommand } from "../commands/slash-command-registry";
+import { ForkConfirmContent } from "../components/dialogs/fork-confirm";
+import { HelpDialogContent } from "../components/dialogs/help-dialog";
+import { withLoadingDialog } from "../components/dialogs/loading-dialog";
+import { useSession } from "../contexts/session-context";
+import type { AppView, TuiProps } from "../types";
+import { formatCompactionStatus } from "../utils/compaction-status";
+import { hydrateSessionMessages } from "../utils/hydrate-messages";
+import type { LocalSlashCommandInvocation } from "../utils/skill-command-input";
+import { HistoryDialogContent } from "../views/history-view";
+import { runLocalSlashCommandAction } from "./local-command-actions";
+import type { OpenConfigOptions } from "./use-config-panel";
+
+export function useLocalCommandActions(input: {
+	slashCommandRegistry: SlashCommandRegistry;
+	canForkSession: boolean;
+	openAccount: () => void;
+	openConfig: (options?: OpenConfigOptions) => void;
+	openMcpManager: () => Promise<boolean>;
+	openModelSelector: () => void;
+	openSkills: (invocation?: LocalSlashCommandInvocation) => void;
+	refocusTextarea: () => void;
+	setAppView: (view: AppView) => void;
+	onClearConversation: () => Promise<void>;
+	onResumeSession: TuiProps["onResumeSession"];
+	onCompact: TuiProps["onCompact"];
+	onFork: TuiProps["onFork"];
+	onUndo: () => Promise<void>;
+	onExit: TuiProps["onExit"];
+}) {
+	const dialog = useDialog();
+	const session = useSession();
+	const { height: termHeight } = useTerminalDimensions();
+	const {
+		slashCommandRegistry,
+		canForkSession,
+		openAccount,
+		openConfig,
+		openMcpManager,
+		openModelSelector,
+		openSkills,
+		refocusTextarea,
+		setAppView,
+		onClearConversation,
+		onResumeSession,
+		onCompact,
+		onFork,
+		onUndo,
+		onExit,
+	} = input;
+
+	const openHistory = useCallback(async () => {
+		const sessionId = await dialog.choice<string>({
+			size: "large",
+			style: { maxHeight: termHeight - 2 },
+			content: (ctx: ChoiceContext<string>) => (
+				<HistoryDialogContent {...ctx} />
+			),
+		});
+		if (sessionId) {
+			try {
+				await withLoadingDialog(dialog, "Loading session...", async () => {
+					const result = await onResumeSession(sessionId);
+					const { messages } = result;
+					const entries = hydrateSessionMessages(messages);
+					if (entries.length === 0) {
+						session.appendEntry({
+							kind: "error",
+							text: `Session ${sessionId} has no messages to resume.`,
+						});
+					} else {
+						session.clearEntries();
+						// replaceEntries rather than appendEntry: appendEntry
+						// stamps unstamped entries with the CURRENT mode, which
+						// would lock hydrated history to the resume-time accent.
+						session.replaceEntries(entries);
+						if (typeof result.currentContextSize === "number") {
+							session.setLastTotalTokens(result.currentContextSize);
+						}
+						if (typeof result.totalCost === "number") {
+							session.setLastTotalCost(result.totalCost);
+						}
+						session.setHasSubmitted(true);
+						setAppView("chat");
+					}
+				});
+			} catch (error) {
+				session.appendEntry({
+					kind: "error",
+					text: `Failed to resume session: ${error instanceof Error ? error.message : String(error)}`,
+				});
+			}
+		}
+		refocusTextarea();
+	}, [
+		dialog,
+		onResumeSession,
+		refocusTextarea,
+		session,
+		setAppView,
+		termHeight,
+	]);
+
+	const openHelp = useCallback(async () => {
+		await dialog.choice<void>({
+			size: "large",
+			style: { maxHeight: termHeight - 2 },
+			content: (ctx: ChoiceContext<void>) => <HelpDialogContent {...ctx} />,
+		});
+		refocusTextarea();
+	}, [dialog, refocusTextarea, termHeight]);
+
+	const runCompact = useCallback(async () => {
+		session.appendEntry({
+			kind: "status",
+			text: "Compacting context...",
+		});
+		try {
+			const result = await onCompact();
+			session.updateLastEntry(() => ({
+				kind: "status",
+				text: formatCompactionStatus(result),
+			}));
+		} catch (error) {
+			session.appendEntry({
+				kind: "error",
+				text: `Compaction failed: ${error instanceof Error ? error.message : String(error)}`,
+			});
+		}
+	}, [onCompact, session]);
+
+	const runFork = useCallback(async () => {
+		if (!canForkSession) {
+			session.appendEntry({
+				kind: "status",
+				text: "Fork is available after this session has messages.",
+			});
+			return;
+		}
+		const confirmed = await dialog.choice<boolean>({
+			closeOnEscape: true,
+			content: (ctx: ChoiceContext<boolean>) => <ForkConfirmContent {...ctx} />,
+		});
+		refocusTextarea();
+		if (!confirmed) return;
+		session.appendEntry({
+			kind: "status",
+			text: "Creating forked session...",
+		});
+		try {
+			const result = await onFork();
+			if (result) {
+				session.updateLastEntry(() => ({
+					kind: "status",
+					text: `Forked into new session ${result.newSessionId}. This is now the active session. Use /history to switch sessions.`,
+				}));
+			} else {
+				session.updateLastEntry(() => ({
+					kind: "error",
+					text: "Fork failed: could not read messages from the current session.",
+				}));
+			}
+		} catch (error) {
+			session.updateLastEntry(() => ({
+				kind: "error",
+				text: `Fork failed: ${error instanceof Error ? error.message : String(error)}`,
+			}));
+		}
+	}, [canForkSession, dialog, onFork, refocusTextarea, session]);
+
+	const handleSlashCommand = useCallback(
+		(command: string, invocation?: LocalSlashCommandInvocation) => {
+			const resolved = resolveSlashCommand(slashCommandRegistry, command);
+			if (!resolved || resolved.execution !== "local") {
+				return false;
+			}
+			return runLocalSlashCommandAction({
+				name: resolved.name,
+				invocation,
+				openAccount,
+				openConfig,
+				openMcpManager,
+				openModelSelector,
+				openSkills,
+				runCompact,
+				runFork,
+				runUndo: onUndo,
+				clearConversation: onClearConversation,
+				openHelp,
+				openHistory,
+				exitCline: onExit,
+			});
+		},
+		[
+			onClearConversation,
+			onExit,
+			onUndo,
+			openAccount,
+			openConfig,
+			openMcpManager,
+			openHelp,
+			openHistory,
+			openModelSelector,
+			openSkills,
+			runCompact,
+			runFork,
+			slashCommandRegistry,
+		],
+	);
+
+	return { handleSlashCommand };
+}
diff --git a/apps/cli/src/tui/hooks/use-mcp-manager.tsx b/apps/cli/src/tui/hooks/use-mcp-manager.tsx
new file mode 100644
index 0000000..70de5ad
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-mcp-manager.tsx
@@ -0,0 +1,52 @@
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import type { DialogActions } from "@opentui-ui/dialog/react";
+import { useCallback } from "react";
+import type {
+	InteractiveConfigData,
+	InteractiveConfigItem,
+} from "../../tui/interactive-config";
+import {
+	type McpEntry,
+	McpManagerContent,
+} from "../components/dialogs/mcp-manager-dialog";
+
+function toMcpEntries(items: InteractiveConfigItem[]): McpEntry[] {
+	return items.map((item) => ({
+		name: item.name,
+		path: item.path,
+		enabled: item.enabled,
+		description: item.description,
+		lastError: item.loadError,
+		pluginName: item.pluginName,
+	}));
+}
+
+export function useMcpManager(opts: {
+	dialog: DialogActions;
+	termHeight: number;
+	loadConfigData: () => Promise<InteractiveConfigData>;
+	onSessionRestart: () => Promise<void>;
+	refocusTextarea: () => void;
+}) {
+	return useCallback(
+		async (options?: { refocus?: boolean }) => {
+			const data = await opts.loadConfigData().catch(() => undefined);
+			const servers = toMcpEntries(data?.mcp ?? []);
+			const changed = await opts.dialog.choice<boolean>({
+				style: { maxHeight: opts.termHeight - 2 },
+				closeOnEscape: false,
+				content: (ctx: ChoiceContext<boolean>) => (
+					<McpManagerContent {...ctx} servers={servers} />
+				),
+			});
+			if (changed) {
+				await opts.onSessionRestart();
+			}
+			if (options?.refocus !== false) {
+				opts.refocusTextarea();
+			}
+			return changed === true;
+		},
+		[opts],
+	);
+}
diff --git a/apps/cli/src/tui/hooks/use-model-selector.tsx b/apps/cli/src/tui/hooks/use-model-selector.tsx
new file mode 100644
index 0000000..04af471
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-model-selector.tsx
@@ -0,0 +1,541 @@
+import {
+	fetchClineRecommendedModels,
+	getProviderConfigFields,
+	Llms,
+	ProviderSettingsManager,
+	refreshProviderModelsFromSource,
+	resolveProviderConfig,
+} from "@cline/core";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import type { DialogActions } from "@opentui-ui/dialog/react";
+import { useCallback } from "react";
+import { isOpenAICodexCliProvider } from "../../utils/codex-cli";
+import {
+	getPersistedProviderApiKey,
+	isOAuthProvider,
+	isProviderConfigured,
+} from "../../utils/provider-auth";
+import type { Config } from "../../utils/types";
+import { withLoadingDialog } from "../components/dialogs/loading-dialog";
+import {
+	ClinePassSubscriptionContent,
+	CodexCliStatusContent,
+	type ExistingProviderOption,
+	OAuthLoginContent,
+	ProviderConfigInputContent,
+	ProviderPickerContent,
+	UseExistingOrReconfigureContent,
+} from "../components/dialogs/provider-picker";
+import { buildFeaturedModelEntries } from "../components/model-selector/cline-model-picker";
+import {
+	BROWSE_ALL_ACTION,
+	ClineModelSelectorDialogContent,
+} from "../components/model-selector/cline-model-selector";
+import {
+	buildModelOptions,
+	CHANGE_PROVIDER_ACTION,
+	ModelIdInputContent,
+	type ModelOption,
+	ModelSelectorContent,
+	type ThinkingLevel,
+	ThinkingLevelContent,
+} from "../components/model-selector/model-selector";
+
+export interface OpenModelSelectorOptions {
+	onCancel?: () => Promise<void> | void;
+	startWithProviderChange?: boolean;
+}
+
+async function getProviderDisplayName(providerId: string): Promise<string> {
+	const info = await Llms.getProvider(providerId);
+	return info?.name ?? providerId;
+}
+
+async function refreshCurrentProviderModels(config: Config): Promise<void> {
+	const manager = new ProviderSettingsManager();
+	await refreshProviderModelsFromSource(manager, config.providerId).catch(
+		() => {},
+	);
+	const resolved = await resolveProviderConfig(
+		config.providerId,
+		{
+			loadLatestOnInit: true,
+			loadPrivateOnAuth: true,
+			failOnError: false,
+		},
+		manager.getProviderConfig(config.providerId, { includeKnownModels: false }),
+	);
+	if (resolved?.knownModels) {
+		config.knownModels = resolved.knownModels;
+	}
+}
+
+function clearReasoningConfig(config: Config): void {
+	config.thinking = false;
+	config.reasoningEffort = undefined;
+}
+
+function usesModelIdInput(providerId: string): boolean {
+	return providerId === "openai-compatible";
+}
+
+function providerToExistingProviderOptions(input: {
+	providerId: string;
+	providerName: string;
+	dialog: DialogActions;
+	termHeight: number;
+}): ExistingProviderOption[] {
+	if (input.providerId !== "cline-pass") {
+		return [];
+	}
+
+	return [
+		{
+			value: "open_subscription_page",
+			label: "Manage subscription & see usage",
+			onSelect: async () => {
+				await input.dialog.choice<boolean>({
+					style: { maxHeight: input.termHeight - 2 },
+					closeOnEscape: false,
+					content: (ctx: ChoiceContext<boolean>) => (
+						<ClinePassSubscriptionContent
+							{...ctx}
+							providerName={input.providerName}
+						/>
+					),
+				});
+			},
+		},
+	];
+}
+
+async function runProviderChange(
+	dialog: DialogActions,
+	config: Config,
+	termHeight: number,
+	onModelChange: () => Promise<void>,
+): Promise<boolean> {
+	const newProviderId = await dialog.choice<string>({
+		style: { maxHeight: termHeight - 2 },
+		content: (ctx: ChoiceContext<string>) => (
+			<ProviderPickerContent {...ctx} currentProviderId={config.providerId} />
+		),
+	});
+	if (!newProviderId) return false;
+
+	const manager = new ProviderSettingsManager();
+	const displayName = await withLoadingDialog(
+		dialog,
+		"Loading provider...",
+		async () => await getProviderDisplayName(newProviderId),
+	);
+	const existingSettings = manager.getProviderSettings(newProviderId);
+
+	let needsAuth = true;
+	if (isProviderConfigured(newProviderId, existingSettings)) {
+		let option: ExistingProviderOption | undefined;
+		const extraOptions = providerToExistingProviderOptions({
+			providerId: newProviderId,
+			providerName: displayName,
+			dialog,
+			termHeight,
+		});
+		while (true) {
+			option = await dialog.choice<ExistingProviderOption>({
+				style: { maxHeight: termHeight - 2 },
+				content: (ctx: ChoiceContext<ExistingProviderOption>) => (
+					<UseExistingOrReconfigureContent
+						{...ctx}
+						providerName={displayName}
+						extraOptions={extraOptions}
+					/>
+				),
+			});
+			if (!option) return false;
+			if (option.onSelect) {
+				await option.onSelect();
+				option = undefined;
+				continue;
+			}
+			break;
+		}
+		needsAuth = option.value === "reconfigure";
+	}
+
+	if (needsAuth) {
+		let saved: boolean | undefined;
+		if (isOAuthProvider(newProviderId)) {
+			saved = await dialog.choice<boolean>({
+				style: { maxHeight: termHeight - 2 },
+				closeOnEscape: false,
+				content: (ctx: ChoiceContext<boolean>) => (
+					<OAuthLoginContent
+						{...ctx}
+						providerId={newProviderId}
+						providerName={displayName}
+					/>
+				),
+			});
+		} else if (isOpenAICodexCliProvider(newProviderId)) {
+			saved = await dialog.choice<boolean>({
+				style: { maxHeight: termHeight - 2 },
+				closeOnEscape: false,
+				content: (ctx: ChoiceContext<boolean>) => (
+					<CodexCliStatusContent {...ctx} providerName={displayName} />
+				),
+			});
+			if (saved) {
+				manager.saveProviderSettings({
+					...(existingSettings ?? {}),
+					provider: newProviderId,
+				});
+			}
+		} else {
+			const { fields } = getProviderConfigFields(newProviderId);
+			saved = await dialog.choice<boolean>({
+				style: { maxHeight: termHeight - 2 },
+				closeOnEscape: false,
+				content: (ctx: ChoiceContext<boolean>) => (
+					<ProviderConfigInputContent
+						{...ctx}
+						providerId={newProviderId}
+						providerName={displayName}
+						fields={fields}
+						providerSettingsManager={manager}
+					/>
+				),
+			});
+		}
+		if (!saved) return false;
+	}
+	await withLoadingDialog(
+		dialog,
+		`Loading ${displayName} models...`,
+		async () => {
+			await refreshProviderModelsFromSource(manager, newProviderId).catch(
+				() => {},
+			);
+			const newSettings = manager.getProviderSettings(newProviderId);
+			const newApiKey =
+				getPersistedProviderApiKey(newProviderId, newSettings) ?? "";
+
+			manager.saveProviderSettings(
+				{
+					...(newSettings ?? {}),
+					provider: newProviderId,
+				},
+				{ setLastUsed: true },
+			);
+
+			config.providerId = newProviderId;
+			config.apiKey = newApiKey;
+			const resolved = await resolveProviderConfig(
+				newProviderId,
+				{
+					loadLatestOnInit: true,
+					loadPrivateOnAuth: true,
+					failOnError: false,
+				},
+				manager.getProviderConfig(newProviderId, { includeKnownModels: false }),
+			);
+			config.knownModels = resolved?.knownModels;
+			const modelIds = Object.keys(resolved?.knownModels ?? {});
+			if (newSettings?.model) {
+				config.modelId = newSettings.model;
+			} else if (modelIds[0]) {
+				config.modelId = modelIds[0];
+			}
+
+			await onModelChange();
+		},
+	);
+	return true;
+}
+
+export function useModelSelector(opts: {
+	dialog: DialogActions;
+	config: Config;
+	termHeight: number;
+	onModelChange: () => Promise<void>;
+	refocusTextarea: () => void;
+}) {
+	const { dialog, config, termHeight, onModelChange, refocusTextarea } = opts;
+
+	const openModelSelector = useCallback(
+		async (options?: OpenModelSelectorOptions) => {
+			const handleCancel = async () => {
+				if (options?.onCancel) {
+					await options.onCancel();
+					return;
+				}
+				refocusTextarea();
+			};
+
+			let modelOptions = buildModelOptions(
+				config.knownModels as Record<string, Llms.ModelInfo>,
+			);
+			let providerDisplayName = config.providerId;
+
+			const refreshProviderContext = async () => {
+				modelOptions = buildModelOptions(
+					config.knownModels as Record<string, Llms.ModelInfo>,
+				);
+				providerDisplayName = await getProviderDisplayName(config.providerId);
+			};
+
+			if (!options?.startWithProviderChange) {
+				await withLoadingDialog(dialog, "Loading models...", async () => {
+					await refreshCurrentProviderModels(config);
+					await refreshProviderContext();
+				});
+			}
+
+			const changeProvider = async (): Promise<boolean> => {
+				const changed = await runProviderChange(
+					dialog,
+					config,
+					termHeight,
+					onModelChange,
+				);
+				if (changed) {
+					await withLoadingDialog(dialog, "Loading models...", async () => {
+						await refreshProviderContext();
+					});
+				}
+				return changed;
+			};
+
+			if (options?.startWithProviderChange) {
+				const changed = await changeProvider();
+				if (!changed) {
+					await handleCancel();
+					return;
+				}
+			}
+
+			let pickingModel = true;
+
+			while (pickingModel) {
+				if (usesModelIdInput(config.providerId)) {
+					const modelId = await dialog.choice<string>({
+						style: { maxHeight: termHeight - 2 },
+						content: (ctx: ChoiceContext<string>) => (
+							<ModelIdInputContent
+								{...ctx}
+								currentModel={config.modelId}
+								currentProviderName={providerDisplayName}
+							/>
+						),
+					});
+					if (!modelId) {
+						await handleCancel();
+						return;
+					}
+					if (modelId === CHANGE_PROVIDER_ACTION) {
+						await changeProvider();
+						continue;
+					}
+					config.modelId = modelId;
+					clearReasoningConfig(config);
+					pickingModel = false;
+					continue;
+				}
+
+				if (
+					config.providerId === "cline" ||
+					config.providerId === "cline-pass"
+				) {
+					// ClinePass gets the same sectioned picker with Subscribed/Free
+					// sections — free models are selectable while staying on ClinePass
+					const featuredProviderId = config.providerId;
+					const clineResult = await dialog.choice<string>({
+						style: { maxHeight: termHeight - 2 },
+						content: (ctx: ChoiceContext<string>) => (
+							<ClineModelSelectorDialogContent
+								{...ctx}
+								currentModel={config.modelId}
+								currentProviderName={providerDisplayName}
+								knownModels={config.knownModels as Record<string, unknown>}
+								loadEntries={async () =>
+									buildFeaturedModelEntries(
+										featuredProviderId,
+										await fetchClineRecommendedModels(),
+									)
+								}
+							/>
+						),
+					});
+					if (!clineResult) {
+						await handleCancel();
+						return;
+					}
+					if (clineResult === CHANGE_PROVIDER_ACTION) {
+						await changeProvider();
+						continue;
+					}
+					if (clineResult === BROWSE_ALL_ACTION) {
+						const browseResult = await dialog.choice<string>({
+							style: { maxHeight: termHeight - 2 },
+							content: (ctx: ChoiceContext<string>) => (
+								<ModelSelectorContent
+									{...ctx}
+									currentModel={config.modelId}
+									currentProviderName={providerDisplayName}
+									models={modelOptions}
+									showCustomModelId={config.providerId !== "cline-pass"}
+								/>
+							),
+						});
+						if (!browseResult) continue;
+						if (browseResult === CHANGE_PROVIDER_ACTION) {
+							await changeProvider();
+							continue;
+						}
+						config.modelId = browseResult;
+						const browseModel = modelOptions.find(
+							(m: ModelOption) => m.key === browseResult,
+						);
+						if (browseModel?.supportsReasoning) {
+							const lvl: ThinkingLevel = config.reasoningEffort
+								? (config.reasoningEffort as ThinkingLevel)
+								: config.thinking
+									? "medium"
+									: "none";
+							const pick = await dialog.choice<ThinkingLevel>({
+								style: { maxHeight: termHeight - 2 },
+								content: (ctx: ChoiceContext<ThinkingLevel>) => (
+									<ThinkingLevelContent
+										{...ctx}
+										modelName={browseModel.name}
+										currentLevel={lvl}
+									/>
+								),
+							});
+							if (pick !== undefined) {
+								if (pick === "none") {
+									config.thinking = false;
+									config.reasoningEffort = undefined;
+								} else {
+									config.thinking = true;
+									config.reasoningEffort = pick;
+								}
+							}
+						}
+						if (!browseModel?.supportsReasoning) {
+							clearReasoningConfig(config);
+						}
+						pickingModel = false;
+						continue;
+					}
+
+					config.modelId = clineResult;
+					const selectedModel = modelOptions.find(
+						(m: ModelOption) => m.key === clineResult,
+					);
+					if (selectedModel?.supportsReasoning) {
+						const currentLevel: ThinkingLevel = config.reasoningEffort
+							? (config.reasoningEffort as ThinkingLevel)
+							: config.thinking
+								? "medium"
+								: "none";
+						const thinkingLevel = await dialog.choice<ThinkingLevel>({
+							style: { maxHeight: termHeight - 2 },
+							content: (ctx: ChoiceContext<ThinkingLevel>) => (
+								<ThinkingLevelContent
+									{...ctx}
+									modelName={selectedModel.name}
+									currentLevel={currentLevel}
+								/>
+							),
+						});
+						if (thinkingLevel !== undefined) {
+							if (thinkingLevel === "none") {
+								config.thinking = false;
+								config.reasoningEffort = undefined;
+							} else {
+								config.thinking = true;
+								config.reasoningEffort = thinkingLevel;
+							}
+						}
+					}
+					if (!selectedModel?.supportsReasoning) {
+						clearReasoningConfig(config);
+					}
+					pickingModel = false;
+					continue;
+				}
+
+				const selectedKey = await dialog.choice<string>({
+					style: { maxHeight: termHeight - 2 },
+					content: (ctx: ChoiceContext<string>) => (
+						<ModelSelectorContent
+							{...ctx}
+							currentModel={config.modelId}
+							currentProviderName={providerDisplayName}
+							models={modelOptions}
+							showCustomModelId={config.providerId !== "cline-pass"}
+						/>
+					),
+				});
+				if (!selectedKey) {
+					await handleCancel();
+					return;
+				}
+
+				if (selectedKey === CHANGE_PROVIDER_ACTION) {
+					await changeProvider();
+					continue;
+				}
+
+				config.modelId = selectedKey;
+
+				const selectedModel = modelOptions.find(
+					(m: ModelOption) => m.key === selectedKey,
+				);
+				if (!selectedModel?.supportsReasoning) {
+					clearReasoningConfig(config);
+					pickingModel = false;
+					break;
+				}
+
+				const currentLevel: ThinkingLevel = config.reasoningEffort
+					? (config.reasoningEffort as ThinkingLevel)
+					: config.thinking
+						? "medium"
+						: "none";
+
+				const thinkingLevel = await dialog.choice<ThinkingLevel>({
+					style: { maxHeight: termHeight - 2 },
+					content: (ctx: ChoiceContext<ThinkingLevel>) => (
+						<ThinkingLevelContent
+							{...ctx}
+							modelName={selectedModel.name}
+							currentLevel={currentLevel}
+						/>
+					),
+				});
+
+				if (thinkingLevel === undefined) {
+					continue;
+				}
+
+				if (thinkingLevel === "none") {
+					config.thinking = false;
+					config.reasoningEffort = undefined;
+				} else {
+					config.thinking = true;
+					config.reasoningEffort = thinkingLevel;
+				}
+				pickingModel = false;
+			}
+
+			await withLoadingDialog(dialog, "Applying model...", async () => {
+				await onModelChange();
+			});
+			refocusTextarea();
+		},
+		[dialog, config, termHeight, onModelChange, refocusTextarea],
+	);
+
+	return openModelSelector;
+}
diff --git a/apps/cli/src/tui/hooks/use-prompt-input-controller.ts b/apps/cli/src/tui/hooks/use-prompt-input-controller.ts
new file mode 100644
index 0000000..40dce7b
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-prompt-input-controller.ts
@@ -0,0 +1,502 @@
+import { useCallback, useLayoutEffect, useRef, useState } from "react";
+import { formatCliErrorMessage } from "../../utils/cline-pass-errors";
+import { shouldShowCliUsageCost } from "../../utils/usage-cost-display";
+import type { SlashCommandRegistry } from "../commands/slash-command-registry";
+import {
+	expandUserCommandPrompt,
+	resolveSlashCommand,
+} from "../commands/slash-command-registry";
+import type { TextareaHandle } from "../components/input-bar";
+import { useSession } from "../contexts/session-context";
+import type { AppView, TuiProps } from "../types";
+import {
+	createUniquePastedTextSnippetMarker,
+	expandPastedTextSnippets,
+	type PastedTextSnippet,
+} from "../utils/pasted-snippets";
+import {
+	insertSelectedSkillCommand,
+	type LocalSlashCommandInvocation,
+	removeLocalSlashCommandInvocation,
+} from "../utils/skill-command-input";
+import type { AutocompleteOption, useAutocomplete } from "./use-autocomplete";
+import { extractSlashQuery } from "./use-autocomplete";
+import { useInputHistory } from "./use-input-history";
+
+interface PastedImage {
+	marker: string;
+	dataUrl: string;
+}
+
+export function usePromptInputController(input: {
+	autocomplete: ReturnType<typeof useAutocomplete>;
+	slashCommandRegistry: SlashCommandRegistry;
+	handleSlashCommand: (
+		command: string,
+		invocation?: LocalSlashCommandInvocation,
+	) => boolean | Promise<boolean>;
+	onSubmit: TuiProps["onSubmit"];
+	initialPrompt?: string;
+	providerId: string;
+	configVerbose: boolean;
+	refreshRepoStatus: () => void;
+	setAppView: (view: AppView) => void;
+	turnErrorReportedRef: { current: boolean };
+}) {
+	const {
+		autocomplete,
+		slashCommandRegistry,
+		handleSlashCommand,
+		onSubmit,
+		initialPrompt,
+		providerId,
+		configVerbose,
+		refreshRepoStatus,
+		setAppView,
+		turnErrorReportedRef,
+	} = input;
+	const session = useSession();
+	const [inputKey, setInputKey] = useState(0);
+	const [inputValue, setInputValue] = useState(initialPrompt ?? "");
+	const [pendingCursorOffset, setPendingCursorOffset] = useState<number | null>(
+		null,
+	);
+	const textareaRef = useRef<TextareaHandle | null>(null);
+	const inputValueRef = useRef("");
+	const pastedImagesRef = useRef<PastedImage[]>([]);
+	const pastedTextSnippetsRef = useRef<PastedTextSnippet[]>([]);
+	const localCommandInFlightRef = useRef(false);
+	inputValueRef.current = inputValue;
+
+	const inputHistory = useInputHistory(textareaRef);
+
+	const focusTextarea = useCallback(() => {
+		textareaRef.current?.focus();
+	}, []);
+
+	const refocusTextarea = useCallback(() => {
+		setInputKey((k) => k + 1);
+	}, []);
+
+	useLayoutEffect(() => {
+		if (pendingCursorOffset === null) return;
+		const textarea = textareaRef.current;
+		if (!textarea) return;
+		textarea.cursorOffset = pendingCursorOffset;
+		textarea.focus();
+		setPendingCursorOffset(null);
+	}, [pendingCursorOffset]);
+
+	const populateInput = useCallback((value: string) => {
+		inputValueRef.current = value;
+		setInputValue(value);
+		setInputKey((k) => k + 1);
+		setPendingCursorOffset(value.length);
+	}, []);
+
+	const applyInputText = useCallback((value: string, cursorOffset: number) => {
+		inputValueRef.current = value;
+		setInputValue(value);
+		setInputKey((k) => k + 1);
+		setPendingCursorOffset(cursorOffset);
+	}, []);
+
+	const insertSkillCommand = useCallback(
+		(commandName: string, invocation?: LocalSlashCommandInvocation) => {
+			const text =
+				invocation?.text ??
+				textareaRef.current?.plainText ??
+				inputValueRef.current;
+			const cursorOffset =
+				invocation?.cursorOffset ??
+				textareaRef.current?.cursorOffset ??
+				text.length;
+			const next = insertSelectedSkillCommand({
+				text,
+				cursorOffset,
+				commandName,
+				replaceRange: invocation?.replaceRange,
+			});
+			applyInputText(next.text, next.cursorOffset);
+		},
+		[applyInputText],
+	);
+
+	const removeLocalCommandInvocation = useCallback(
+		(invocation: LocalSlashCommandInvocation) => {
+			const next = removeLocalSlashCommandInvocation(invocation);
+			applyInputText(next.text, next.cursorOffset);
+		},
+		[applyInputText],
+	);
+
+	const clearPastedImages = useCallback(() => {
+		pastedImagesRef.current = [];
+	}, []);
+
+	const clearPastedTextSnippets = useCallback(() => {
+		pastedTextSnippetsRef.current = [];
+	}, []);
+
+	const clearPasteAttachments = useCallback(() => {
+		clearPastedImages();
+		clearPastedTextSnippets();
+	}, [clearPastedImages, clearPastedTextSnippets]);
+
+	const handleImagePaste = useCallback((dataUrl: string) => {
+		const marker = `[Image ${pastedImagesRef.current.length + 1}]`;
+		pastedImagesRef.current = [...pastedImagesRef.current, { marker, dataUrl }];
+		return marker;
+	}, []);
+
+	const handleLargeTextPaste = useCallback((text: string) => {
+		const marker = createUniquePastedTextSnippetMarker(
+			text,
+			pastedTextSnippetsRef.current.map((snippet) => snippet.marker),
+		);
+		pastedTextSnippetsRef.current = [
+			...pastedTextSnippetsRef.current,
+			{ marker, text },
+		];
+		return marker;
+	}, []);
+
+	const prunePastedTextSnippets = useCallback((text: string) => {
+		pastedTextSnippetsRef.current = pastedTextSnippetsRef.current.filter(
+			(snippet) => text.includes(snippet.marker),
+		);
+	}, []);
+
+	const runSlashCommand = useCallback(
+		async (
+			cmd: string,
+			invocation?: LocalSlashCommandInvocation,
+		): Promise<boolean> => {
+			if (localCommandInFlightRef.current) return false;
+			localCommandInFlightRef.current = true;
+			try {
+				return await Promise.resolve(handleSlashCommand(cmd, invocation));
+			} finally {
+				localCommandInFlightRef.current = false;
+			}
+		},
+		[handleSlashCommand],
+	);
+
+	const selectAutocompleteOption = useCallback(
+		async (option: AutocompleteOption) => {
+			const ta = textareaRef.current;
+			if (!ta) return;
+
+			if (option.onSelect) {
+				ta.setText("");
+				ta.cursorOffset = 0;
+				autocomplete.close();
+				setInputValue("");
+				clearPasteAttachments();
+				option.onSelect();
+				return;
+			}
+
+			if (autocomplete.mode === "/") {
+				const cmd = option.commandName ?? option.display.slice(1);
+				const text = inputValueRef.current;
+				const offset = ta.cursorOffset;
+				const before = text.slice(0, offset);
+				const slash = extractSlashQuery(before);
+				if (option.commandExecution === "local") {
+					const invocation: LocalSlashCommandInvocation = {
+						text,
+						cursorOffset: offset,
+						replaceRange: slash.inSlashMode
+							? { start: slash.slashIndex, end: offset }
+							: undefined,
+					};
+					if (!option.commandPreserveInput) {
+						ta.setText("");
+						ta.cursorOffset = 0;
+						setInputValue("");
+						clearPasteAttachments();
+					}
+					if (await runSlashCommand(cmd, invocation)) {
+						autocomplete.close();
+						return;
+					}
+				}
+				if (slash.inSlashMode) {
+					const newText =
+						text.slice(0, slash.slashIndex) + option.value + text.slice(offset);
+					ta.setText(newText);
+					if (option.commandExecution === "user-command") {
+						ta.extmarks.create({
+							start: slash.slashIndex,
+							end: slash.slashIndex + option.value.trimEnd().length,
+							virtual: true,
+						});
+					}
+					ta.cursorOffset = slash.slashIndex + option.value.length;
+				}
+			} else if (autocomplete.mode === "@") {
+				const text = inputValueRef.current;
+				const offset = ta.cursorOffset;
+				const before = text.slice(0, offset);
+				const atIdx = before.lastIndexOf("@");
+				if (atIdx >= 0) {
+					const newText =
+						text.slice(0, atIdx) + option.value + text.slice(offset);
+					ta.setText(newText);
+					ta.cursorOffset = atIdx + option.value.length;
+				}
+			}
+			autocomplete.close();
+			setInputValue(ta.plainText);
+		},
+		[autocomplete, clearPasteAttachments, runSlashCommand],
+	);
+
+	const selectRef = useRef(selectAutocompleteOption);
+	selectRef.current = selectAutocompleteOption;
+
+	const submitPrompt = useCallback(
+		async (delivery?: "queue" | "steer") => {
+			if (localCommandInFlightRef.current) return;
+
+			const prompt = inputValueRef.current.trim();
+			if (!prompt) return;
+
+			if (!delivery && prompt.startsWith("/")) {
+				const parts = prompt.split(/\s+/);
+				const cmd = (parts[0] ?? "").slice(1);
+				const command = resolveSlashCommand(slashCommandRegistry, cmd);
+				let invocation: LocalSlashCommandInvocation | undefined;
+				if (command?.execution === "local") {
+					const text = inputValueRef.current;
+					const commandToken = parts[0] ?? "";
+					const tokenStart = text.length - text.trimStart().length;
+					const tokenEnd = tokenStart + commandToken.length;
+					invocation = {
+						text,
+						cursorOffset: textareaRef.current?.cursorOffset ?? tokenEnd,
+						replaceRange:
+							text.slice(tokenStart, tokenEnd) === commandToken
+								? { start: tokenStart, end: tokenEnd }
+								: undefined,
+					};
+					if (!command.preserveInput) {
+						setInputKey((k) => k + 1);
+						setInputValue("");
+						clearPasteAttachments();
+					}
+				}
+				if (await runSlashCommand(cmd, invocation)) {
+					return;
+				}
+			}
+
+			const activePastedTextSnippets = pastedTextSnippetsRef.current.filter(
+				(snippet) => prompt.includes(snippet.marker),
+			);
+			const expandedPrompt = expandPastedTextSnippets(
+				prompt,
+				activePastedTextSnippets,
+			);
+			const activeUserImages = pastedImagesRef.current
+				.filter((image) => prompt.includes(image.marker))
+				.map((image) => image.dataUrl);
+			const promptForSubmit = expandUserCommandPrompt(
+				expandedPrompt,
+				slashCommandRegistry,
+			);
+
+			session.setHasSubmitted(true);
+			setAppView("chat");
+			if (!delivery) {
+				session.setIsRunning(true);
+				session.setIsStreaming(true);
+				session.setAbortRequested(false);
+				turnErrorReportedRef.current = false;
+				session.appendEntry({
+					kind: "user_submitted",
+					text: prompt,
+				});
+			}
+			setInputKey((k) => k + 1);
+			setInputValue("");
+			clearPasteAttachments();
+			if (!delivery) {
+				inputHistory.recordHistoryEntry(prompt);
+			}
+
+			const startedAt = performance.now();
+			let commandOutputAppended = false;
+			const appendCommandOutput = (text: string) => {
+				commandOutputAppended = true;
+				session.appendEntry({
+					kind: "status",
+					text,
+				});
+			};
+			try {
+				const result = await onSubmit(
+					promptForSubmit,
+					session.uiMode,
+					delivery,
+					activeUserImages.length > 0
+						? { userImages: activeUserImages }
+						: undefined,
+					appendCommandOutput,
+				);
+				if (result.commandOutput && !commandOutputAppended) {
+					session.appendEntry({
+						kind: "status",
+						text: result.commandOutput,
+					});
+				}
+				if (result.queued) return;
+				if (typeof result.currentContextSize === "number") {
+					session.setLastTotalTokens(result.currentContextSize);
+				}
+				if (typeof result.usage.totalCost === "number") {
+					session.setLastTotalCost(result.usage.totalCost);
+				}
+				if (!result.commandOutput && configVerbose) {
+					const elapsed = ((performance.now() - startedAt) / 1000).toFixed(2);
+					const showUsageCost = shouldShowCliUsageCost(providerId);
+					session.appendEntry({
+						kind: "done",
+						tokens: result.currentContextSize ?? session.lastTotalTokens,
+						cost:
+							showUsageCost && typeof result.usage.totalCost === "number"
+								? result.usage.totalCost
+								: 0,
+						elapsed,
+						iterations: result.iterations,
+					});
+				}
+			} catch (error) {
+				if (!turnErrorReportedRef.current) {
+					session.appendEntry({
+						kind: "error",
+						text: formatCliErrorMessage(error),
+					});
+				}
+			} finally {
+				if (!delivery) {
+					session.closeInlineStream();
+					session.setIsRunning(false);
+					session.setIsStreaming(false);
+					refreshRepoStatus();
+				}
+			}
+		},
+		[
+			clearPasteAttachments,
+			configVerbose,
+			inputHistory,
+			onSubmit,
+			providerId,
+			refreshRepoStatus,
+			runSlashCommand,
+			session,
+			setAppView,
+			slashCommandRegistry,
+			turnErrorReportedRef,
+		],
+	);
+
+	const submitRef = useRef(submitPrompt);
+	submitRef.current = submitPrompt;
+
+	const submitInitialPrompt = useCallback(() => {
+		const prompt = initialPrompt?.trim();
+		if (!prompt) return;
+		inputValueRef.current = prompt;
+		setInputValue(prompt);
+		submitRef.current();
+	}, [initialPrompt]);
+
+	const handleSubmit = useCallback(() => {
+		if (autocomplete.mode) {
+			const opts = autocomplete.getFilteredOptions();
+			if (opts.length > 0) {
+				selectRef.current(
+					opts[Math.min(autocomplete.selected, opts.length - 1)] ?? opts[0],
+				);
+				return;
+			}
+		}
+		submitRef.current(session.isRunning ? "queue" : undefined);
+	}, [autocomplete, session.isRunning]);
+
+	const handleContentChange = useCallback(
+		(text: string) => {
+			setInputValue(text);
+			if (!text.trim()) {
+				clearPasteAttachments();
+			} else {
+				prunePastedTextSnippets(text);
+			}
+			autocomplete.updateAutocomplete(text);
+			if (inputHistory.shouldResetHistoryIndex(text)) {
+				inputHistory.resetHistoryIndex();
+			}
+		},
+		[
+			autocomplete,
+			clearPasteAttachments,
+			inputHistory,
+			prunePastedTextSnippets,
+		],
+	);
+
+	const syncInputFromTextarea = useCallback(() => {
+		queueMicrotask(() => {
+			const text = textareaRef.current?.plainText ?? "";
+			if (text === inputValueRef.current) return;
+			setInputValue(text);
+			if (!text.trim()) {
+				clearPasteAttachments();
+			} else {
+				prunePastedTextSnippets(text);
+			}
+			autocomplete.updateAutocomplete(text);
+			if (inputHistory.shouldResetHistoryIndex(text)) {
+				inputHistory.resetHistoryIndex();
+			}
+		});
+	}, [
+		autocomplete,
+		clearPasteAttachments,
+		inputHistory,
+		prunePastedTextSnippets,
+	]);
+
+	const getCurrentInputText = useCallback(() => {
+		return textareaRef.current?.plainText ?? inputValueRef.current;
+	}, []);
+
+	return {
+		inputKey,
+		inputValue,
+		inputValueRef,
+		textareaRef,
+		inputHistory,
+		selectRef,
+		submitRef,
+		setInputKey,
+		setInputValue,
+		populateInput,
+		insertSkillCommand,
+		removeLocalCommandInvocation,
+		focusTextarea,
+		refocusTextarea,
+		submitInitialPrompt,
+		selectAutocompleteOption,
+		handleImagePaste,
+		handleLargeTextPaste,
+		handleSubmit,
+		handleContentChange,
+		syncInputFromTextarea,
+		getCurrentInputText,
+	};
+}
diff --git a/apps/cli/src/tui/hooks/use-queued-prompts.test.ts b/apps/cli/src/tui/hooks/use-queued-prompts.test.ts
new file mode 100644
index 0000000..87bc990
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-queued-prompts.test.ts
@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import type { PendingPromptSnapshot } from "../../runtime/session-events";
+import {
+	resolveQueuedPromptSelection,
+	toQueuedPromptItems,
+} from "./use-queued-prompts";
+
+describe("queued prompt helpers", () => {
+	it("maps pending prompt snapshots to TUI queue items", () => {
+		const event: PendingPromptSnapshot = {
+			sessionId: "sess-1",
+			prompts: [
+				{
+					id: "pending-1",
+					prompt: "keep going",
+					delivery: "queue",
+					attachmentCount: 2,
+				},
+				{
+					id: "pending-2",
+					prompt: "change direction",
+					delivery: "steer",
+					attachmentCount: 0,
+				},
+			],
+		};
+
+		expect(toQueuedPromptItems(event)).toEqual([
+			{
+				id: "pending-1",
+				prompt: "keep going",
+				steer: false,
+				attachmentCount: 2,
+			},
+			{
+				id: "pending-2",
+				prompt: "change direction",
+				steer: true,
+				attachmentCount: 0,
+			},
+		]);
+	});
+
+	it("moves up from the input into the closest queued prompt", () => {
+		const items = [
+			{ id: "first", prompt: "first", steer: false, attachmentCount: 0 },
+			{ id: "second", prompt: "second", steer: false, attachmentCount: 0 },
+		];
+
+		expect(
+			resolveQueuedPromptSelection({
+				items,
+				selectedId: null,
+				direction: "up",
+			}),
+		).toBe("second");
+	});
+
+	it("moves down through the queue and then back to the input", () => {
+		const items = [
+			{ id: "first", prompt: "first", steer: false, attachmentCount: 0 },
+			{ id: "second", prompt: "second", steer: false, attachmentCount: 0 },
+		];
+
+		expect(
+			resolveQueuedPromptSelection({
+				items,
+				selectedId: "first",
+				direction: "down",
+			}),
+		).toBe("second");
+		expect(
+			resolveQueuedPromptSelection({
+				items,
+				selectedId: "second",
+				direction: "down",
+			}),
+		).toBeNull();
+	});
+});
diff --git a/apps/cli/src/tui/hooks/use-queued-prompts.ts b/apps/cli/src/tui/hooks/use-queued-prompts.ts
new file mode 100644
index 0000000..3d3fc67
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-queued-prompts.ts
@@ -0,0 +1,53 @@
+import { useCallback, useState } from "react";
+import type { PendingPromptSnapshot } from "../../runtime/session-events";
+import type { QueuedPromptItem } from "../types";
+
+export function toQueuedPromptItems(
+	event: PendingPromptSnapshot,
+): QueuedPromptItem[] {
+	return event.prompts.map((entry, index) => ({
+		id: entry.id || `${entry.delivery}:${index}:${entry.prompt}`,
+		prompt: entry.prompt,
+		steer: entry.delivery === "steer",
+		attachmentCount: entry.attachmentCount,
+	}));
+}
+
+export function resolveQueuedPromptSelection(input: {
+	items: QueuedPromptItem[];
+	selectedId: string | null;
+	direction: "up" | "down";
+}): string | null {
+	if (input.items.length === 0) {
+		return null;
+	}
+
+	const currentIndex = input.selectedId
+		? input.items.findIndex((item) => item.id === input.selectedId)
+		: -1;
+
+	if (input.direction === "up") {
+		if (currentIndex < 0) {
+			return input.items[input.items.length - 1]?.id ?? null;
+		}
+		return input.items[Math.max(0, currentIndex - 1)]?.id ?? null;
+	}
+
+	if (currentIndex < 0) {
+		return null;
+	}
+	const nextIndex = currentIndex + 1;
+	return nextIndex >= input.items.length
+		? null
+		: (input.items[nextIndex]?.id ?? null);
+}
+
+export function useQueuedPrompts() {
+	const [queuedPrompts, setQueuedPrompts] = useState<QueuedPromptItem[]>([]);
+
+	const handlePendingPrompts = useCallback((event: PendingPromptSnapshot) => {
+		setQueuedPrompts(toQueuedPromptItems(event));
+	}, []);
+
+	return { queuedPrompts, handlePendingPrompts };
+}
diff --git a/apps/cli/src/tui/hooks/use-root-keyboard.test.ts b/apps/cli/src/tui/hooks/use-root-keyboard.test.ts
new file mode 100644
index 0000000..cb4d10b
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-root-keyboard.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { shouldHandleInputHistory } from "./root-keyboard-routing";
+
+describe("root keyboard input history routing", () => {
+	it("handles history while idle", () => {
+		expect(
+			shouldHandleInputHistory({
+				isRunning: false,
+				hasQueuedPrompts: false,
+			}),
+		).toBe(true);
+	});
+
+	it("handles history during a running turn when the prompt queue is empty", () => {
+		expect(
+			shouldHandleInputHistory({
+				isRunning: true,
+				hasQueuedPrompts: false,
+			}),
+		).toBe(true);
+	});
+
+	it("keeps running-turn arrow keys reserved for queued prompts when the queue is populated", () => {
+		expect(
+			shouldHandleInputHistory({
+				isRunning: true,
+				hasQueuedPrompts: true,
+			}),
+		).toBe(false);
+	});
+});
diff --git a/apps/cli/src/tui/hooks/use-root-keyboard.ts b/apps/cli/src/tui/hooks/use-root-keyboard.ts
new file mode 100644
index 0000000..52ea615
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-root-keyboard.ts
@@ -0,0 +1,288 @@
+import type { KeyEvent } from "@opentui/core";
+import { useKeyboard } from "@opentui/react";
+import type { Dispatch, SetStateAction } from "react";
+import { useRef } from "react";
+import type { TranscriptScrollHandle } from "../components/chat-message-list";
+import { useSession } from "../contexts/session-context";
+import type { AppView, QueuedPromptItem } from "../types";
+import { shouldHandleInputHistory } from "./root-keyboard-routing";
+import { matchTranscriptKeybind } from "./transcript-keybinds";
+import type { AutocompleteOption, useAutocomplete } from "./use-autocomplete";
+import type { useInputHistory } from "./use-input-history";
+import { resolveQueuedPromptSelection } from "./use-queued-prompts";
+
+type TranscriptKey = {
+	name: string;
+	ctrl: boolean;
+	meta: boolean;
+	shift: boolean;
+	preventDefault: () => void;
+};
+
+export function handleTranscriptKeybind(
+	key: TranscriptKey,
+	transcriptScroll: TranscriptScrollHandle | null | undefined,
+): boolean {
+	const command = matchTranscriptKeybind(key);
+	if (!command || !transcriptScroll) return false;
+
+	key.preventDefault();
+	transcriptScroll.runTranscriptCommand(command);
+	return true;
+}
+
+export function useRootKeyboard(input: {
+	isDialogOpen: boolean;
+	appView: AppView;
+	autocomplete: ReturnType<typeof useAutocomplete>;
+	inputHistory: ReturnType<typeof useInputHistory>;
+	transcriptScrollRef: { current: TranscriptScrollHandle | null };
+	inputValueRef: { current: string };
+	selectRef: { current: (option: AutocompleteOption) => void };
+	submitRef: { current: (delivery?: "queue" | "steer") => void };
+	queuedPromptSelection: {
+		items: QueuedPromptItem[];
+		selectedId: string | null;
+		editingId: string | null;
+		select: (id: string | null) => void;
+		beginEdit: (id: string) => void;
+		cancelEdit: () => void;
+		promote: (id: string) => void;
+	};
+	syncInputFromTextarea: () => void;
+	getCurrentInputText: () => string;
+	setInputKey: Dispatch<SetStateAction<number>>;
+	setInputValue: Dispatch<SetStateAction<string>>;
+	onAbort: () => boolean;
+	onExit: () => void;
+	onToggleMode: () => void;
+	onClearConversation: () => Promise<void>;
+	onRestoreCheckpoint: () => Promise<void>;
+	onOpenCommandPalette: () => Promise<void>;
+	onCommandPaletteShortcut: (key: KeyEvent) => boolean;
+}) {
+	const session = useSession();
+	const lastEscapeRef = useRef(0);
+
+	useKeyboard((key) => {
+		if (session.isExitRequested) return;
+
+		const hasInputText = input.getCurrentInputText().trim().length > 0;
+
+		const mayEditTextarea =
+			!key.ctrl &&
+			!key.meta &&
+			(key.name.length === 1 ||
+				key.name === "backspace" ||
+				key.name === "delete" ||
+				key.name === "space");
+		if (
+			!input.isDialogOpen &&
+			input.appView !== "onboarding" &&
+			mayEditTextarea
+		) {
+			input.syncInputFromTextarea();
+		}
+
+		if (key.ctrl && key.name === "c") {
+			if (!input.isDialogOpen && hasInputText) {
+				input.setInputKey((k) => k + 1);
+				input.setInputValue("");
+			} else {
+				input.onExit();
+			}
+			return;
+		}
+
+		if (input.isDialogOpen) return;
+		if (input.appView === "onboarding") return;
+
+		if (handleTranscriptKeybind(key, input.transcriptScrollRef.current)) {
+			if (input.autocomplete.mode) {
+				input.autocomplete.close();
+			}
+			return;
+		}
+
+		if (input.autocomplete.mode) {
+			const opts = input.autocomplete.getFilteredOptions();
+			if (key.name === "escape") {
+				input.autocomplete.close();
+				return;
+			}
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				let next =
+					input.autocomplete.selected <= 0
+						? opts.length - 1
+						: input.autocomplete.selected - 1;
+				if (opts[next]?.isHeader) next = next <= 0 ? opts.length - 1 : next - 1;
+				input.autocomplete.setSelected(next);
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				let next =
+					input.autocomplete.selected >= opts.length - 1
+						? 0
+						: input.autocomplete.selected + 1;
+				if (opts[next]?.isHeader) next = next >= opts.length - 1 ? 0 : next + 1;
+				input.autocomplete.setSelected(next);
+				return;
+			}
+			if (key.name === "tab" && opts.length > 0) {
+				const selectedOption =
+					opts[Math.min(input.autocomplete.selected, opts.length - 1)] ??
+					opts[0];
+				if (!selectedOption?.isHeader) {
+					input.selectRef.current(selectedOption);
+				}
+				return;
+			}
+			return;
+		}
+
+		if (!session.isRunning && input.onCommandPaletteShortcut(key)) {
+			return;
+		}
+
+		if (key.ctrl && key.name === "p" && !session.isRunning) {
+			void input.onOpenCommandPalette();
+			return;
+		}
+
+		const queuedSelection = input.queuedPromptSelection;
+		const hasQueuedPrompts = queuedSelection.items.length > 0;
+		const selectedQueuedPromptId = queuedSelection.selectedId;
+		const canHandleInputHistory = shouldHandleInputHistory({
+			isRunning: session.isRunning,
+			hasQueuedPrompts,
+		});
+
+		if (queuedSelection.editingId && key.name !== "escape") {
+			return;
+		}
+
+		if (hasQueuedPrompts && key.name === "up") {
+			key.preventDefault();
+			if (input.autocomplete.mode) {
+				input.autocomplete.close();
+			}
+			queuedSelection.select(
+				resolveQueuedPromptSelection({
+					items: queuedSelection.items,
+					selectedId: selectedQueuedPromptId,
+					direction: "up",
+				}),
+			);
+			return;
+		}
+
+		if (hasQueuedPrompts && selectedQueuedPromptId && key.name === "down") {
+			key.preventDefault();
+			queuedSelection.select(
+				resolveQueuedPromptSelection({
+					items: queuedSelection.items,
+					selectedId: selectedQueuedPromptId,
+					direction: "down",
+				}),
+			);
+			return;
+		}
+
+		if (
+			selectedQueuedPromptId &&
+			!queuedSelection.editingId &&
+			key.name === "tab" &&
+			!key.shift
+		) {
+			key.preventDefault();
+			queuedSelection.beginEdit(selectedQueuedPromptId);
+			return;
+		}
+
+		if (
+			selectedQueuedPromptId &&
+			!queuedSelection.editingId &&
+			(key.name === "enter" || key.name === "return")
+		) {
+			key.preventDefault();
+			queuedSelection.promote(selectedQueuedPromptId);
+			return;
+		}
+
+		if (key.name === "up" && canHandleInputHistory) {
+			if (
+				input.inputHistory.navigateHistory("up", input.inputValueRef.current)
+			) {
+				key.preventDefault();
+			}
+			return;
+		}
+		if (key.name === "down" && canHandleInputHistory) {
+			if (
+				input.inputHistory.navigateHistory("down", input.inputValueRef.current)
+			) {
+				key.preventDefault();
+			}
+			return;
+		}
+
+		if (key.name === "escape") {
+			if (queuedSelection.editingId) {
+				key.preventDefault();
+				queuedSelection.cancelEdit();
+			} else if (session.isRunning) {
+				const abortStarted = input.onAbort();
+				if (abortStarted) {
+					session.setAbortRequested(true);
+					session.setIsStreaming(false);
+					session.closeInlineStream();
+				}
+			} else if (selectedQueuedPromptId) {
+				queuedSelection.select(null);
+				input.setInputKey((k) => k + 1);
+			} else {
+				const now = Date.now();
+				if (now - lastEscapeRef.current < 300) {
+					lastEscapeRef.current = 0;
+					void input.onRestoreCheckpoint();
+				} else {
+					lastEscapeRef.current = now;
+				}
+			}
+			return;
+		}
+
+		if (key.ctrl && key.name === "d") {
+			if (!session.isRunning && !hasInputText) {
+				input.onExit();
+			}
+			return;
+		}
+
+		if (key.name === "tab" && !key.shift) {
+			input.onToggleMode();
+			return;
+		}
+
+		if (key.shift && key.name === "tab") {
+			session.toggleAutoApprove();
+			return;
+		}
+
+		if (key.ctrl && key.name === "l") {
+			if (session.isRunning) {
+				session.clearEntries();
+				return;
+			}
+			void input.onClearConversation();
+			return;
+		}
+
+		if (key.ctrl && key.name === "s") {
+			if (session.isRunning && input.inputValueRef.current.trim()) {
+				input.submitRef.current("steer");
+			}
+			return;
+		}
+	});
+}
diff --git a/apps/cli/src/tui/hooks/use-runtime-dialog-bridge.tsx b/apps/cli/src/tui/hooks/use-runtime-dialog-bridge.tsx
new file mode 100644
index 0000000..ab01372
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-runtime-dialog-bridge.tsx
@@ -0,0 +1,203 @@
+import type { AgentMode } from "@cline/core";
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { RuntimeToolInteraction, TuiProps } from "../types";
+
+type PendingRuntimeToolInteraction =
+	| {
+			id: number;
+			kind: "tool_approval";
+			request: ToolApprovalRequest;
+			resolve: (result: ToolApprovalResult) => void;
+	  }
+	| {
+			id: number;
+			kind: "ask_question";
+			question: string;
+			options: string[];
+			resolve: (answer: string) => void;
+	  };
+
+function toRuntimeToolInteraction(
+	pending: PendingRuntimeToolInteraction,
+): RuntimeToolInteraction {
+	if (pending.kind === "tool_approval") {
+		return {
+			id: pending.id,
+			kind: pending.kind,
+			request: pending.request,
+		};
+	}
+	return {
+		id: pending.id,
+		kind: pending.kind,
+		question: pending.question,
+		options: pending.options,
+	};
+}
+
+function deniedToolResult(request: ToolApprovalRequest): ToolApprovalResult {
+	return {
+		approved: false,
+		reason: `Tool "${request.toolName}" was denied by user`,
+	};
+}
+
+function dismissPendingInteraction(pending: PendingRuntimeToolInteraction) {
+	if (pending.kind === "tool_approval") {
+		pending.resolve(deniedToolResult(pending.request));
+		return;
+	}
+	pending.resolve("[User dismissed the question]");
+}
+
+export function useRuntimeDialogBridge(input: {
+	setToolApprover: TuiProps["setToolApprover"];
+	setAskQuestion: TuiProps["setAskQuestion"];
+	setModeChangeNotifier: TuiProps["setModeChangeNotifier"];
+	setUiMode: (mode: AgentMode) => void;
+	refocusTextarea: () => void;
+}) {
+	const {
+		setToolApprover,
+		setAskQuestion,
+		setModeChangeNotifier,
+		setUiMode,
+		refocusTextarea,
+	} = input;
+	const [interaction, setInteraction] = useState<RuntimeToolInteraction | null>(
+		null,
+	);
+	const activeRef = useRef<PendingRuntimeToolInteraction | null>(null);
+	const queueRef = useRef<PendingRuntimeToolInteraction[]>([]);
+	const nextIdRef = useRef(1);
+
+	const activate = useCallback((pending: PendingRuntimeToolInteraction) => {
+		activeRef.current = pending;
+		setInteraction(toRuntimeToolInteraction(pending));
+	}, []);
+
+	const enqueue = useCallback(
+		(pending: PendingRuntimeToolInteraction) => {
+			if (activeRef.current) {
+				queueRef.current.push(pending);
+				return;
+			}
+			activate(pending);
+		},
+		[activate],
+	);
+
+	const finishActive = useCallback(
+		(id: number) => {
+			if (activeRef.current?.id !== id) {
+				return false;
+			}
+			const next = queueRef.current.shift() ?? null;
+			if (next) {
+				activate(next);
+				return true;
+			}
+			activeRef.current = null;
+			setInteraction(null);
+			return false;
+		},
+		[activate],
+	);
+
+	const resolveToolApproval = useCallback(
+		(id: number, approved: boolean) => {
+			const pending = activeRef.current;
+			if (!pending || pending.id !== id || pending.kind !== "tool_approval") {
+				return;
+			}
+			pending.resolve(
+				approved ? { approved: true } : deniedToolResult(pending.request),
+			);
+			const hasNext = finishActive(id);
+			if (!hasNext) {
+				refocusTextarea();
+			}
+		},
+		[finishActive, refocusTextarea],
+	);
+
+	const resolveAskQuestion = useCallback(
+		(id: number, answer: string | null) => {
+			const pending = activeRef.current;
+			if (!pending || pending.id !== id || pending.kind !== "ask_question") {
+				return;
+			}
+			pending.resolve(
+				answer === null ? "[User dismissed the question]" : answer,
+			);
+			const hasNext = finishActive(id);
+			if (!hasNext) {
+				refocusTextarea();
+			}
+		},
+		[finishActive, refocusTextarea],
+	);
+
+	const dismissAll = useCallback(() => {
+		if (activeRef.current) {
+			dismissPendingInteraction(activeRef.current);
+			activeRef.current = null;
+		}
+		for (const pending of queueRef.current) {
+			dismissPendingInteraction(pending);
+		}
+		queueRef.current = [];
+		setInteraction(null);
+	}, []);
+
+	useEffect(() => {
+		setToolApprover(
+			(request) =>
+				new Promise<ToolApprovalResult>((resolve) => {
+					enqueue({
+						id: nextIdRef.current,
+						kind: "tool_approval",
+						request,
+						resolve,
+					});
+					nextIdRef.current += 1;
+				}),
+		);
+		setAskQuestion(
+			(question, options) =>
+				new Promise<string>((resolve) => {
+					enqueue({
+						id: nextIdRef.current,
+						kind: "ask_question",
+						question,
+						options,
+						resolve,
+					});
+					nextIdRef.current += 1;
+				}),
+		);
+		setModeChangeNotifier((mode) => {
+			setUiMode(mode);
+		});
+		return () => {
+			setToolApprover(null);
+			setAskQuestion(null);
+			setModeChangeNotifier(null);
+			dismissAll();
+		};
+	}, [
+		dismissAll,
+		enqueue,
+		setAskQuestion,
+		setModeChangeNotifier,
+		setToolApprover,
+		setUiMode,
+	]);
+
+	return {
+		interaction,
+		resolveToolApproval,
+		resolveAskQuestion,
+	};
+}
diff --git a/apps/cli/src/tui/hooks/use-slash-commands.ts b/apps/cli/src/tui/hooks/use-slash-commands.ts
new file mode 100644
index 0000000..8da19c0
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-slash-commands.ts
@@ -0,0 +1,64 @@
+import { useEffect, useMemo, useState } from "react";
+import {
+	buildSlashCommandRegistry,
+	getInvokableUserSlashCommands,
+	getVisibleSystemSlashCommands,
+	getVisibleUserSlashCommands,
+} from "../commands/slash-command-registry";
+import type { TuiProps } from "../types";
+
+export function useSlashCommands(input: {
+	workflowSlashCommands: TuiProps["workflowSlashCommands"];
+	loadAdditionalSlashCommands: TuiProps["loadAdditionalSlashCommands"];
+	canFork: boolean;
+}) {
+	const { workflowSlashCommands, loadAdditionalSlashCommands, canFork } = input;
+	const [additionalSlashCommands, setAdditionalSlashCommands] = useState<
+		TuiProps["workflowSlashCommands"] | undefined
+	>(loadAdditionalSlashCommands ? [] : undefined);
+
+	useEffect(() => {
+		if (!loadAdditionalSlashCommands) {
+			setAdditionalSlashCommands(undefined);
+			return;
+		}
+		let cancelled = false;
+		void loadAdditionalSlashCommands()
+			.then((commands) => {
+				if (!cancelled) {
+					setAdditionalSlashCommands(commands);
+				}
+			})
+			.catch(() => {
+				if (!cancelled) {
+					setAdditionalSlashCommands([]);
+				}
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [loadAdditionalSlashCommands]);
+
+	const registry = useMemo(() => {
+		return buildSlashCommandRegistry({
+			workflowSlashCommands,
+			additionalSlashCommands,
+			canFork,
+		});
+	}, [workflowSlashCommands, additionalSlashCommands, canFork]);
+
+	const systemCommands = useMemo(
+		() => getVisibleSystemSlashCommands(registry),
+		[registry],
+	);
+	const skillCommands = useMemo(
+		() => getVisibleUserSlashCommands(registry),
+		[registry],
+	);
+	const invokableSkillCommands = useMemo(
+		() => getInvokableUserSlashCommands(registry),
+		[registry],
+	);
+
+	return { registry, systemCommands, skillCommands, invokableSkillCommands };
+}
diff --git a/apps/cli/src/tui/hooks/use-terminal-background.ts b/apps/cli/src/tui/hooks/use-terminal-background.ts
new file mode 100644
index 0000000..8ed58f0
--- /dev/null
+++ b/apps/cli/src/tui/hooks/use-terminal-background.ts
@@ -0,0 +1,25 @@
+import { createContext, useContext } from "react";
+import { getTerminalTheme, type TerminalTheme } from "../palette";
+
+export interface TerminalColors {
+	background: string | null;
+	foreground: string | null;
+}
+
+export const TerminalColorsContext = createContext<TerminalColors>({
+	background: null,
+	foreground: null,
+});
+
+export function useTerminalBackground(): string | null {
+	return useContext(TerminalColorsContext).background;
+}
+
+export function useTerminalForeground(): string | null {
+	return useContext(TerminalColorsContext).foreground;
+}
+
+export function useTerminalTheme(): TerminalTheme {
+	const { background, foreground } = useContext(TerminalColorsContext);
+	return getTerminalTheme(background, foreground);
+}
diff --git a/apps/cli/src/tui/index.test.ts b/apps/cli/src/tui/index.test.ts
new file mode 100644
index 0000000..fd481d8
--- /dev/null
+++ b/apps/cli/src/tui/index.test.ts
@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { TuiProps } from "./types";
+
+const rendererMock = vi.hoisted(() => ({
+	copyToClipboardOSC52: vi.fn(),
+	destroy: vi.fn(),
+	getPalette: vi.fn(async () => ({
+		defaultBackground: null,
+		defaultForeground: null,
+	})),
+	on: vi.fn(),
+}));
+
+const rootMock = vi.hoisted(() => ({
+	render: vi.fn(),
+	unmount: vi.fn(),
+}));
+
+const reactMock = vi.hoisted(() => ({
+	createRoot: vi.fn(() => rootMock),
+}));
+
+vi.mock("@opentui/core", () => ({
+	createCliRenderer: vi.fn(async () => rendererMock),
+}));
+
+vi.mock("@opentui/react", () => ({
+	createRoot: reactMock.createRoot,
+}));
+
+vi.mock("./root", () => ({
+	Root: () => null,
+}));
+
+describe("renderOpenTui", () => {
+	const destroyHandlers: Array<() => void> = [];
+
+	beforeEach(() => {
+		destroyHandlers.length = 0;
+		rendererMock.destroy.mockReset();
+		rendererMock.on.mockReset();
+		rendererMock.on.mockImplementation((event: string, handler: () => void) => {
+			if (event === "destroy") {
+				destroyHandlers.push(handler);
+			}
+			return rendererMock;
+		});
+		rootMock.render.mockReset();
+		rootMock.unmount.mockReset();
+		reactMock.createRoot.mockReset();
+		reactMock.createRoot.mockReturnValue(rootMock);
+	});
+
+	it("destroys the renderer when root creation fails", async () => {
+		const { renderOpenTui } = await import("./index");
+		reactMock.createRoot.mockImplementationOnce(() => {
+			throw new Error("root failed");
+		});
+
+		await expect(renderOpenTui({} as TuiProps)).rejects.toThrow("root failed");
+
+		expect(rendererMock.destroy).toHaveBeenCalledTimes(1);
+	});
+
+	it("destroys the renderer when initial render fails", async () => {
+		const { renderOpenTui } = await import("./index");
+		rootMock.render.mockImplementationOnce(() => {
+			throw new Error("render failed");
+		});
+
+		await expect(renderOpenTui({} as TuiProps)).rejects.toThrow(
+			"render failed",
+		);
+
+		expect(rendererMock.destroy).toHaveBeenCalledTimes(1);
+	});
+
+	it("defers explicit shutdown until the current input dispatch unwinds", async () => {
+		rendererMock.destroy.mockImplementationOnce(() => {
+			for (const handler of destroyHandlers) {
+				handler();
+			}
+		});
+
+		const { renderOpenTui } = await import("./index");
+		const tui = await renderOpenTui({} as TuiProps);
+
+		tui.destroy();
+
+		expect(rootMock.unmount).toHaveBeenCalledTimes(1);
+		expect(rendererMock.destroy).not.toHaveBeenCalled();
+
+		await Promise.resolve();
+		await tui.waitUntilExit();
+
+		expect(rendererMock.destroy).toHaveBeenCalledTimes(1);
+		expect(rootMock.unmount).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/apps/cli/src/tui/index.tsx b/apps/cli/src/tui/index.tsx
new file mode 100644
index 0000000..5a52e0a
--- /dev/null
+++ b/apps/cli/src/tui/index.tsx
@@ -0,0 +1,78 @@
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import { Root } from "./root";
+import { installTuiStdioCapture } from "./stdio-capture";
+import type { TuiProps } from "./types";
+
+export type { TuiProps } from "./types";
+
+export async function renderOpenTui(
+	props: TuiProps,
+): Promise<{ destroy: () => void; waitUntilExit: () => Promise<void> }> {
+	const renderer = await createCliRenderer({
+		exitOnCtrlC: false,
+		autoFocus: false,
+		enableMouseMovement: true,
+	});
+	const restoreStdio = installTuiStdioCapture();
+
+	const detectedPalette = await renderer
+		.getPalette({ timeout: 150 })
+		.catch(() => null);
+	const terminalBackground = detectedPalette?.defaultBackground ?? null;
+	const terminalForeground = detectedPalette?.defaultForeground ?? null;
+
+	let root: ReturnType<typeof createRoot>;
+	try {
+		root = createRoot(renderer);
+		root.render(
+			<Root
+				{...props}
+				terminalBackground={terminalBackground}
+				terminalForeground={terminalForeground}
+			/>,
+		);
+	} catch (error) {
+		restoreStdio();
+		renderer.destroy();
+		throw error;
+	}
+
+	let resolveExit: (() => void) | undefined;
+	const exitPromise = new Promise<void>((resolve) => {
+		resolveExit = resolve;
+	});
+
+	let unmounted = false;
+	const unmountRoot = () => {
+		if (unmounted) {
+			return;
+		}
+		unmounted = true;
+		root.unmount();
+	};
+
+	renderer.on("destroy", () => {
+		unmountRoot();
+		restoreStdio();
+		resolveExit?.();
+	});
+
+	let destroyStarted = false;
+	const destroy = () => {
+		if (destroyStarted) {
+			return;
+		}
+		destroyStarted = true;
+		unmountRoot();
+		// Let OpenTUI finish parsing the current stdin batch before teardown.
+		queueMicrotask(() => {
+			renderer.destroy();
+		});
+	};
+
+	return {
+		destroy,
+		waitUntilExit: () => exitPromise,
+	};
+}
diff --git a/apps/cli/src/tui/interactive-config.ts b/apps/cli/src/tui/interactive-config.ts
new file mode 100644
index 0000000..912a9e9
--- /dev/null
+++ b/apps/cli/src/tui/interactive-config.ts
@@ -0,0 +1,555 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import {
+	basename,
+	dirname,
+	extname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+} from "node:path";
+import {
+	type BuiltinToolAvailabilityContext,
+	discoverPluginModulePaths,
+	hasMcpSettingsFile,
+	listHookConfigFiles,
+	listPluginToolsWithDiagnostics,
+	type McpServerRegistration,
+	type PluginInitializationFailure,
+	type RuleConfig,
+	readGlobalSettings,
+	resolveAgentConfigSearchPaths,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+	resolvePluginConfigSearchPaths,
+	resolvePluginSkillDirectoriesFromPaths,
+	type SkillConfig,
+	type UserInstructionConfigService,
+	type WorkflowConfig,
+} from "@cline/core";
+import { getToolCatalog } from "../runtime/tools";
+import {
+	type InteractiveSlashCommand,
+	listInteractiveSlashCommands,
+} from "./interactive-welcome";
+
+export type InteractiveConfigTab =
+	| "general"
+	| "tools"
+	| "workflows"
+	| "agents"
+	| "plugins"
+	| "hooks"
+	| "skills"
+	| "rules"
+	| "mcp";
+
+export type InteractiveConfigItemKind =
+	| "workflow"
+	| "rule"
+	| "skill"
+	| "hook"
+	| "agent"
+	| "plugin"
+	| "mcp"
+	| "tool";
+
+export interface InteractiveConfigItem {
+	id: string;
+	name: string;
+	path: string;
+	enabled?: boolean;
+	kind: InteractiveConfigItemKind;
+	enabledState?: "enabled" | "disabled" | "partial";
+	toolNames?: string[];
+	configKind?: "tool" | "plugin";
+	pluginName?: string;
+	pluginPath?: string;
+	loadError?: string;
+	loadErrorPhase?: PluginInitializationFailure["phase"];
+	source:
+		| "global"
+		| "workspace"
+		| "builtin"
+		| "global-plugin"
+		| "workspace-plugin";
+	description?: string;
+}
+
+export interface InteractiveConfigData {
+	workflows: InteractiveConfigItem[];
+	rules: InteractiveConfigItem[];
+	skills: InteractiveConfigItem[];
+	hooks: InteractiveConfigItem[];
+	agents: InteractiveConfigItem[];
+	plugins: InteractiveConfigItem[];
+	mcp: InteractiveConfigItem[];
+	tools: InteractiveConfigItem[];
+	workflowSlashCommands: InteractiveSlashCommand[];
+	pluginDiagnosticsLoaded?: boolean;
+}
+
+export interface LoadInteractiveConfigDataOptions {
+	includePluginTools?: boolean;
+}
+
+export function isToggleableInteractiveConfigItem(
+	item: Pick<InteractiveConfigItem, "kind" | "source" | "pluginName">,
+): boolean {
+	if (item.kind === "mcp") {
+		return !item.pluginName;
+	}
+	return (
+		item.kind === "skill" ||
+		item.kind === "plugin" ||
+		item.source === "builtin" ||
+		item.source === "workspace-plugin" ||
+		item.source === "global-plugin"
+	);
+}
+
+function detectSource(
+	path: string,
+	workspaceRoot: string,
+): "global" | "workspace" {
+	if (!workspaceRoot) {
+		return "global";
+	}
+	return path.startsWith(workspaceRoot) ? "workspace" : "global";
+}
+
+function detectPluginSource(
+	path: string,
+	workspaceRoot: string,
+): "global-plugin" | "workspace-plugin" {
+	return detectSource(path, workspaceRoot) === "workspace"
+		? "workspace-plugin"
+		: "global-plugin";
+}
+
+function toSorted<T extends InteractiveConfigItem>(items: T[]): T[] {
+	return [...items].sort((a, b) => {
+		const sourceRank = (source: InteractiveConfigItem["source"]): number => {
+			switch (source) {
+				case "builtin":
+					return 0;
+				case "workspace":
+					return 1;
+				case "workspace-plugin":
+					return 2;
+				case "global":
+					return 3;
+				case "global-plugin":
+					return 4;
+			}
+		};
+		if (a.source !== b.source) {
+			return sourceRank(a.source) - sourceRank(b.source);
+		}
+		return a.name.localeCompare(b.name);
+	});
+}
+
+function getMcpAuthLabel(registration: McpServerRegistration): string {
+	if (registration.transport.type === "stdio") {
+		return "local";
+	}
+	if (registration.oauth?.lastError) {
+		return "oauth error";
+	}
+	const accessToken = registration.oauth?.tokens?.access_token;
+	if (typeof accessToken === "string" && accessToken.trim().length > 0) {
+		return "oauth authorized";
+	}
+	if (registration.oauth && Object.keys(registration.oauth).length > 0) {
+		return "oauth pending";
+	}
+	if (
+		registration.transport.headers &&
+		Object.keys(registration.transport.headers).length > 0
+	) {
+		return "static headers";
+	}
+	return "no auth";
+}
+
+function getMcpDescription(registration: McpServerRegistration): string {
+	return `${registration.transport.type}, ${getMcpAuthLabel(registration)}`;
+}
+
+function loadAgentConfigItems(workspaceRoot: string): InteractiveConfigItem[] {
+	const agentsById = new Map<string, InteractiveConfigItem>();
+	const directories = resolveAgentConfigSearchPaths(workspaceRoot).filter(
+		(directory) => existsSync(directory),
+	);
+
+	for (const directory of directories) {
+		try {
+			const entries = readdirSync(directory, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isFile()) {
+					continue;
+				}
+				const extension = extname(entry.name).toLowerCase();
+				if (extension !== ".yml" && extension !== ".yaml") {
+					continue;
+				}
+				const filePath = join(directory, entry.name);
+				const raw = readFileSync(filePath, "utf8");
+				const frontmatterMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+				const frontmatter = frontmatterMatch?.[1] ?? "";
+				const nameMatch = frontmatter.match(/^\s*name:\s*(.+?)\s*$/m);
+				const descriptionMatch = frontmatter.match(
+					/^\s*description:\s*(.+?)\s*$/m,
+				);
+				const parsedName = nameMatch?.[1]?.replace(/^["']|["']$/g, "").trim();
+				const parsedDescription = descriptionMatch?.[1]
+					?.replace(/^["']|["']$/g, "")
+					.trim();
+				const name =
+					parsedName && parsedName.length > 0
+						? parsedName
+						: basename(entry.name, extension);
+				const id = name.toLowerCase();
+				if (agentsById.has(id)) {
+					continue;
+				}
+				agentsById.set(id, {
+					id,
+					name,
+					path: filePath,
+					enabled: true,
+					kind: "agent",
+					source: detectSource(filePath, workspaceRoot),
+					description: parsedDescription,
+				});
+			}
+		} catch {
+			// Best effort: keep listing other agent config roots.
+		}
+	}
+
+	return [...agentsById.values()];
+}
+
+function readPackageName(packageJsonPath: string): string | undefined {
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+			name?: unknown;
+		};
+		return typeof packageJson.name === "string" && packageJson.name.trim()
+			? packageJson.name.trim()
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function getPluginDisplayName(filePath: string, searchRoot: string): string {
+	let current = dirname(filePath);
+	const root = resolve(searchRoot);
+	while (isPathWithin(root, current)) {
+		const packageJsonPath = join(current, "package.json");
+		if (existsSync(packageJsonPath)) {
+			const packageName = readPackageName(packageJsonPath);
+			if (packageName) {
+				return packageName;
+			}
+			break;
+		}
+		const parent = resolve(current, "..");
+		if (parent === current) {
+			break;
+		}
+		current = parent;
+	}
+	return basename(filePath, extname(filePath));
+}
+
+function isPathWithin(parentPath: string, childPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+type PluginSkillOwner = {
+	directory: string;
+	pluginName: string;
+	pluginPath: string;
+	source: "global-plugin" | "workspace-plugin";
+};
+
+function buildPluginSkillOwners(
+	plugins: readonly InteractiveConfigItem[],
+): PluginSkillOwner[] {
+	const owners: PluginSkillOwner[] = [];
+	for (const plugin of plugins) {
+		if (
+			plugin.kind !== "plugin" ||
+			(plugin.source !== "workspace-plugin" &&
+				plugin.source !== "global-plugin")
+		) {
+			continue;
+		}
+		for (const directory of resolvePluginSkillDirectoriesFromPaths([
+			plugin.path,
+		])) {
+			owners.push({
+				directory,
+				pluginName: plugin.name,
+				pluginPath: plugin.path,
+				source: plugin.source,
+			});
+		}
+	}
+	return owners.sort(
+		(left, right) => right.directory.length - left.directory.length,
+	);
+}
+
+function findPluginSkillOwner(
+	filePath: string,
+	owners: readonly PluginSkillOwner[],
+): PluginSkillOwner | undefined {
+	return owners.find((owner) => isPathWithin(owner.directory, filePath));
+}
+
+function formatPluginFailure(failure: PluginInitializationFailure): string {
+	return `${failure.phase === "setup" ? "setup failed" : "load failed"}: ${failure.message}`;
+}
+
+export function applyPluginFailures(
+	plugins: InteractiveConfigItem[],
+	failures: readonly PluginInitializationFailure[],
+): void {
+	const pluginsByPath = new Map(plugins.map((plugin) => [plugin.path, plugin]));
+	const failuresByPath = new Map<string, PluginInitializationFailure[]>();
+	for (const failure of failures) {
+		const failuresForPath = failuresByPath.get(failure.pluginPath) ?? [];
+		failuresForPath.push(failure);
+		failuresByPath.set(failure.pluginPath, failuresForPath);
+	}
+	for (const [pluginPath, failuresForPath] of failuresByPath) {
+		const plugin = pluginsByPath.get(pluginPath);
+		if (!plugin) {
+			continue;
+		}
+		const namedFailure = failuresForPath.find((failure) => failure.pluginName);
+		if (namedFailure?.pluginName) {
+			plugin.name = namedFailure.pluginName;
+		}
+		plugin.loadError = failuresForPath.map(formatPluginFailure).join("\n");
+		plugin.loadErrorPhase =
+			failuresForPath.length === 1 ? failuresForPath[0]?.phase : undefined;
+	}
+}
+
+export async function loadInteractiveConfigData(input: {
+	userInstructionService?: UserInstructionConfigService;
+	cwd: string;
+	workspaceRoot: string;
+	availabilityContext?: BuiltinToolAvailabilityContext;
+	includePluginTools?: boolean;
+}): Promise<InteractiveConfigData> {
+	const workflows: InteractiveConfigItem[] = [];
+	const rules: InteractiveConfigItem[] = [];
+	const skills: InteractiveConfigItem[] = [];
+	const hooks: InteractiveConfigItem[] = [];
+	const agents: InteractiveConfigItem[] = [];
+	const plugins: InteractiveConfigItem[] = [];
+	const mcp: InteractiveConfigItem[] = [];
+	const tools: InteractiveConfigItem[] = [];
+	const workflowSlashCommands = listInteractiveSlashCommands(
+		input.userInstructionService,
+	);
+
+	for (const hook of listHookConfigFiles(input.cwd)) {
+		hooks.push({
+			id: hook.path,
+			name: hook.fileName,
+			path: hook.path,
+			enabled: true,
+			kind: "hook",
+			source: detectSource(hook.path, input.workspaceRoot),
+			description: hook.hookEventName,
+		});
+	}
+
+	agents.push(...loadAgentConfigItems(input.workspaceRoot));
+
+	const disabledPlugins = new Set(readGlobalSettings().disabledPlugins ?? []);
+	const pluginDirectories = resolvePluginConfigSearchPaths(
+		input.workspaceRoot,
+	).filter((directory) => existsSync(directory));
+	for (const directory of pluginDirectories) {
+		try {
+			for (const filePath of discoverPluginModulePaths(directory)) {
+				plugins.push({
+					id: filePath,
+					name: getPluginDisplayName(filePath, directory),
+					path: filePath,
+					enabled: !disabledPlugins.has(filePath),
+					kind: "plugin",
+					configKind: "plugin",
+					source: detectPluginSource(filePath, input.workspaceRoot),
+				});
+			}
+		} catch {
+			// Best effort: skip unreadable plugin roots.
+		}
+	}
+
+	const pluginSkillOwners = buildPluginSkillOwners(plugins);
+
+	if (input.userInstructionService) {
+		for (const record of input.userInstructionService.listRecords<WorkflowConfig>(
+			"workflow",
+		)) {
+			const workflow = record.item;
+			workflows.push({
+				id: record.id,
+				name: workflow.name,
+				path: record.filePath,
+				enabled: workflow.disabled !== true,
+				kind: "workflow",
+				source: detectSource(record.filePath, input.workspaceRoot),
+				description: workflow.instructions,
+			});
+		}
+		for (const record of input.userInstructionService.listRecords<RuleConfig>(
+			"rule",
+		)) {
+			const rule = record.item;
+			rules.push({
+				id: record.id,
+				name: rule.name,
+				path: record.filePath,
+				enabled: rule.disabled !== true,
+				kind: "rule",
+				source: detectSource(record.filePath, input.workspaceRoot),
+				description: rule.instructions,
+			});
+		}
+		for (const record of input.userInstructionService.listRecords<SkillConfig>(
+			"skill",
+		)) {
+			const skill = record.item;
+			const pluginOwner = findPluginSkillOwner(
+				record.filePath,
+				pluginSkillOwners,
+			);
+			skills.push({
+				id: record.id,
+				name: skill.name,
+				path: record.filePath,
+				enabled: skill.disabled !== true,
+				kind: "skill",
+				source:
+					pluginOwner?.source ??
+					detectSource(record.filePath, input.workspaceRoot),
+				description: skill.description,
+				pluginName: pluginOwner?.pluginName,
+				pluginPath: pluginOwner?.pluginPath,
+			});
+		}
+	}
+
+	const mcpSettingsPath = resolveDefaultMcpSettingsPath();
+	if (hasMcpSettingsFile({ filePath: mcpSettingsPath })) {
+		try {
+			for (const registration of resolveMcpServerRegistrations({
+				filePath: mcpSettingsPath,
+			})) {
+				const pluginName =
+					registration.metadata?.source === "plugin" &&
+					typeof registration.metadata.pluginName === "string"
+						? registration.metadata.pluginName
+						: undefined;
+				const pluginPath =
+					registration.metadata?.source === "plugin" &&
+					typeof registration.metadata.pluginPath === "string"
+						? registration.metadata.pluginPath
+						: undefined;
+				mcp.push({
+					id: registration.name,
+					name: registration.name,
+					path: mcpSettingsPath,
+					enabled: registration.disabled !== true,
+					kind: "mcp",
+					source: detectSource(mcpSettingsPath, input.workspaceRoot),
+					description: getMcpDescription(registration),
+					loadError: registration.oauth?.lastError,
+					pluginName,
+					pluginPath,
+				});
+			}
+		} catch {
+			// Best effort: keep MCP list empty on parse/load errors.
+		}
+	}
+
+	tools.push(
+		...getToolCatalog(input.availabilityContext).map((tool) => ({
+			id: tool.id,
+			name: tool.id,
+			path:
+				tool.headlessToolNames.length === 1 &&
+				tool.headlessToolNames[0] === tool.id
+					? tool.id
+					: tool.headlessToolNames.join(", "),
+			enabled: tool.defaultEnabled,
+			enabledState: tool.defaultEnabled
+				? ("enabled" as const)
+				: ("disabled" as const),
+			kind: "tool" as const,
+			toolNames: [tool.id, ...tool.headlessToolNames],
+			configKind: "tool" as const,
+			source: "builtin" as const,
+			description: tool.description,
+		})),
+	);
+	if (input.includePluginTools !== false) {
+		try {
+			const pluginToolResult = await listPluginToolsWithDiagnostics({
+				workspacePath: input.workspaceRoot,
+				cwd: input.cwd,
+				providerId: input.availabilityContext?.providerId,
+				modelId: input.availabilityContext?.modelId,
+			});
+			applyPluginFailures(plugins, pluginToolResult.failures);
+			for (const pluginTool of pluginToolResult.tools) {
+				tools.push({
+					id: `${pluginTool.pluginName}:${pluginTool.name}:${pluginTool.path}`,
+					name: pluginTool.name,
+					path: pluginTool.path,
+					enabled: pluginTool.enabled,
+					enabledState: pluginTool.enabled ? "enabled" : "disabled",
+					kind: "tool" as const,
+					toolNames: [pluginTool.name],
+					configKind: "tool",
+					pluginName: pluginTool.pluginName,
+					pluginPath: pluginTool.path,
+					source: pluginTool.source,
+					description: pluginTool.description,
+				});
+			}
+		} catch {
+			// Best effort: built-in tools and instruction config should still render.
+		}
+	}
+
+	return {
+		workflows: toSorted(workflows.filter((item) => existsSync(item.path))),
+		rules: toSorted(rules.filter((item) => existsSync(item.path))),
+		skills: toSorted(skills.filter((item) => existsSync(item.path))),
+		hooks: toSorted(hooks.filter((item) => existsSync(item.path))),
+		agents: toSorted(agents.filter((item) => existsSync(item.path))),
+		plugins: toSorted(plugins.filter((item) => existsSync(item.path))),
+		mcp: toSorted(mcp.filter((item) => existsSync(item.path))),
+		tools: toSorted(tools),
+		workflowSlashCommands,
+		pluginDiagnosticsLoaded: input.includePluginTools !== false,
+	};
+}
diff --git a/apps/cli/src/tui/interactive-welcome.test.ts b/apps/cli/src/tui/interactive-welcome.test.ts
new file mode 100644
index 0000000..dba6251
--- /dev/null
+++ b/apps/cli/src/tui/interactive-welcome.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { rankMentionPaths } from "./interactive-welcome";
+
+describe("TUI file mention search ranking", () => {
+	it("keeps initialism matches for compact and hyphenated input", () => {
+		const paths = [
+			"src/components/Button.tsx",
+			"src/domain/MyAmazingClassDefinition.ts",
+			"docs/MACD.md",
+			"packages/core/src/runtime/manager.ts",
+		];
+
+		expect(rankMentionPaths(paths, "MACD", 10)).toEqual([
+			"docs/MACD.md",
+			"src/domain/MyAmazingClassDefinition.ts",
+		]);
+		expect(rankMentionPaths(paths, "M-A-C-D", 10)).toEqual([
+			"docs/MACD.md",
+			"src/domain/MyAmazingClassDefinition.ts",
+		]);
+	});
+
+	it("normalizes common mention prefixes before matching workspace paths", () => {
+		const paths = [
+			"docs/architecture.md",
+			"src/tui/interactive-welcome.ts",
+			"src/tui/hooks/use-autocomplete.ts",
+		];
+
+		expect(rankMentionPaths(paths, "./src/tui", 10)).toEqual([
+			"src/tui/hooks/use-autocomplete.ts",
+			"src/tui/interactive-welcome.ts",
+		]);
+		expect(rankMentionPaths(paths, "/docs", 10)).toEqual([
+			"docs/architecture.md",
+		]);
+	});
+
+	it("ranks filename matches ahead of path-only fuzzy matches", () => {
+		const paths = [
+			"src/migrations/add-column.ts",
+			"src/domain/MyAmazingClassDefinition.ts",
+			"docs/classes.md",
+		];
+
+		expect(rankMentionPaths(paths, "class", 10)[0]).toBe("docs/classes.md");
+	});
+});
diff --git a/apps/cli/src/tui/interactive-welcome.ts b/apps/cli/src/tui/interactive-welcome.ts
new file mode 100644
index 0000000..7d22b45
--- /dev/null
+++ b/apps/cli/src/tui/interactive-welcome.ts
@@ -0,0 +1,191 @@
+import {
+	getFileIndex,
+	type ProviderSettings,
+	type UserInstructionConfigService,
+} from "@cline/core";
+import { byLengthAsc, Fzf, type FzfResultItem } from "fzf";
+import type { Config } from "../utils/types";
+import { formatClineCredits, loadClineAccountSnapshot } from "./cline-account";
+
+export interface InteractiveSlashCommand {
+	name: string;
+	instructions: string;
+	description?: string;
+	kind?: "skill" | "workflow";
+}
+
+function normalizeLimit(limit: number | undefined): number {
+	if (typeof limit !== "number" || Number.isNaN(limit)) {
+		return 10;
+	}
+	return Math.min(200, Math.max(1, Math.trunc(limit)));
+}
+
+function getPathLabel(filePath: string): string {
+	const parts = filePath.split("/");
+	return parts[parts.length - 1] ?? filePath;
+}
+
+function normalizeMentionQuery(query: string): string {
+	const trimmed = query.trim().replace(/^["']/, "");
+	if (trimmed.startsWith("./")) {
+		return trimmed.slice(2);
+	}
+	if (trimmed.startsWith("/")) {
+		return trimmed.slice(1);
+	}
+	return trimmed;
+}
+
+function compactSearchText(text: string): string {
+	return text.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+interface MentionPathItem {
+	path: string;
+	label: string;
+	searchText: string;
+}
+
+function countGaps(positions: Iterable<number>): number {
+	const sortedPositions = Array.from(positions).sort((a, b) => a - b);
+	let gaps = 0;
+	let previous = Number.NEGATIVE_INFINITY;
+	for (const position of sortedPositions) {
+		if (previous !== Number.NEGATIVE_INFINITY && position - previous > 1) {
+			gaps++;
+		}
+		previous = position;
+	}
+	return gaps;
+}
+
+function orderByMatchScore(
+	left: FzfResultItem<MentionPathItem>,
+	right: FzfResultItem<MentionPathItem>,
+): number {
+	return countGaps(left.positions) - countGaps(right.positions);
+}
+
+export function rankMentionPaths(
+	paths: Iterable<string>,
+	query: string,
+	limit: number,
+): string[] {
+	const items = Array.from(paths, (path): MentionPathItem => {
+		const label = getPathLabel(path);
+		return {
+			path,
+			label,
+			searchText: [
+				label,
+				label,
+				path,
+				compactSearchText(label),
+				compactSearchText(path),
+			].join(" "),
+		};
+	});
+
+	const normalizedQuery = normalizeMentionQuery(query);
+	if (!normalizedQuery) {
+		return items
+			.sort((left, right) => left.path.localeCompare(right.path))
+			.slice(0, limit)
+			.map((item) => item.path);
+	}
+
+	const fzf = new Fzf(items, {
+		selector: (item) => item.searchText,
+		tiebreakers: [orderByMatchScore, byLengthAsc],
+		limit,
+	});
+
+	const rawResults = fzf.find(normalizedQuery);
+	const results =
+		rawResults.length > 0
+			? rawResults
+			: fzf.find(compactSearchText(normalizedQuery));
+	return results.map((result) => result.item.path);
+}
+
+export function listInteractiveSlashCommands(
+	userInstructionService?: UserInstructionConfigService,
+): InteractiveSlashCommand[] {
+	const builtins = [
+		{
+			name: "config",
+			instructions: "",
+			description: "Open interactive config browser",
+		},
+		{
+			name: "settings",
+			instructions: "",
+			description: "Modify agent configuration",
+		},
+		{
+			name: "mcp",
+			instructions: "",
+			description: "Manage MCP servers",
+		},
+		{
+			name: "fork",
+			instructions: "/fork",
+			description: "Create a named fork of the current session",
+		},
+		{
+			name: "team",
+			instructions: "/team [prompt]",
+			description: "Start the task with agent team",
+		},
+	];
+	if (!userInstructionService) {
+		return builtins;
+	}
+	return [
+		...builtins,
+		...userInstructionService.listRuntimeCommands().map((command) => ({
+			name: command.name,
+			instructions: command.instructions,
+			description: command.description,
+			kind: command.kind,
+		})),
+	];
+}
+
+export async function searchWorkspaceFilesForMention(input: {
+	workspaceRoot: string;
+	query: string;
+	limit?: number;
+}): Promise<string[]> {
+	const workspaceRoot = input.workspaceRoot.trim();
+	if (!workspaceRoot) {
+		return [];
+	}
+	const limit = normalizeLimit(input.limit);
+	const index = await getFileIndex(workspaceRoot);
+	return rankMentionPaths(index, input.query, limit);
+}
+
+export async function resolveClineWelcomeLine(input: {
+	config: Config;
+	clineApiBaseUrl?: string;
+	clineProviderSettings?: ProviderSettings;
+}): Promise<string | undefined> {
+	if (input.config.providerId !== "cline") {
+		return undefined;
+	}
+	try {
+		const snapshot = await loadClineAccountSnapshot(input);
+		const parts = [
+			snapshot.user.email,
+			`Credits: ${formatClineCredits(snapshot.displayedBalance)}`,
+		];
+		if (snapshot.activeOrganization?.name.trim()) {
+			parts.push(snapshot.activeOrganization.name);
+		}
+		return parts.join(" | ");
+	} catch {
+		return undefined;
+	}
+}
diff --git a/apps/cli/src/tui/opentui-env.ts b/apps/cli/src/tui/opentui-env.ts
new file mode 100644
index 0000000..ea026b7
--- /dev/null
+++ b/apps/cli/src/tui/opentui-env.ts
@@ -0,0 +1,22 @@
+/**
+ * OpenTUI probes Kitty graphics support during startup. In some terminals that
+ * probe response can leak into the visible CLI as text like:
+ * Gi=31337, s=1, v=1, a=q, t=d, f=24; AAAA
+ *
+ * The report looked related to mouse handling because it appeared while the
+ * home screen robot was tracking cursor movement. We still need OpenTUI mouse
+ * movement detection for that robot follow animation, so do not disable mouse
+ * support or enableMouseMovement. Instead, disable only the Kitty graphics
+ * capability probe that produces the leaked response.
+ *
+ * Implications: keyboard input, mouse clicks, mouse movement, colors, Unicode
+ * text rendering, ASCII art, and the regular OpenTUI renderer all stay enabled.
+ * OpenTUI renderers created after this point will not detect or use Kitty
+ * inline bitmap graphics, and child processes may inherit this env var if they
+ * are spawned with the default environment. The CLI currently renders text and
+ * ASCII frames, including the robot animation, so Kitty bitmap graphics are not
+ * used here.
+ */
+export function disableOpenTuiGraphicsProbe(): void {
+	process.env.OPENTUI_GRAPHICS = "0";
+}
diff --git a/apps/cli/src/tui/palette.test.ts b/apps/cli/src/tui/palette.test.ts
new file mode 100644
index 0000000..de23029
--- /dev/null
+++ b/apps/cli/src/tui/palette.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { getModeAccent, getSuccessColor, getTerminalTheme } from "./palette";
+
+describe("getTerminalTheme", () => {
+	it("detects light terminals from the default background", () => {
+		expect(getTerminalTheme("#ffffff")).toBe("light");
+		expect(getTerminalTheme("#fdf6e3")).toBe("light");
+	});
+
+	it("detects dark terminals from the default background", () => {
+		expect(getTerminalTheme("#000000")).toBe("dark");
+		expect(getTerminalTheme("#002b36")).toBe("dark");
+	});
+
+	it("uses the foreground as a fallback when background is unavailable", () => {
+		expect(getTerminalTheme(null, "#1a1a1a")).toBe("light");
+		expect(getTerminalTheme(null, "#f0f0f0")).toBe("dark");
+	});
+
+	it("defaults to the existing dark theme when detection is unavailable", () => {
+		expect(getTerminalTheme(null, null)).toBe("dark");
+	});
+});
+
+describe("theme-aware palette helpers", () => {
+	it("uses the brand accent colors for dark terminals", () => {
+		expect(getModeAccent("act", "dark")).toBe("#79b8ff");
+		expect(getModeAccent("plan", "dark")).toBe("#ffea7f");
+		expect(getSuccessColor("dark")).toBe("#99e89b");
+	});
+
+	it("uses darker accents on light terminals", () => {
+		expect(getModeAccent("act", "light")).toBe("#0f72cb");
+		expect(getModeAccent("plan", "light")).toBe("#867100");
+		expect(getSuccessColor("light")).toBe("#116329");
+	});
+});
diff --git a/apps/cli/src/tui/palette.ts b/apps/cli/src/tui/palette.ts
new file mode 100644
index 0000000..50c4494
--- /dev/null
+++ b/apps/cli/src/tui/palette.ts
@@ -0,0 +1,255 @@
+export const palette = {
+	act: "#79b8ff",
+	plan: "#ffea7f",
+	selection: "#79b8ff",
+	error: "red",
+	success: "#99e89b",
+	muted: "gray",
+	textOnSelection: "black",
+} as const;
+
+export type TerminalTheme = "dark" | "light";
+
+export const themePalette = {
+	dark: {
+		act: palette.act,
+		plan: palette.plan,
+		success: palette.success,
+	},
+	// Same OKLCH hues as the dark accents, darkened to hold >=4.5:1 contrast
+	// on white so the plan/act identity carries across themes.
+	light: {
+		act: "#0f72cb",
+		plan: "#867100",
+		success: "#116329",
+	},
+} as const;
+
+export const diffPalettes = {
+	dark: {
+		addedBg: "#1a4d1a",
+		removedBg: "#4d1a1a",
+		addedLineNumberBg: "#1a4d1a",
+		removedLineNumberBg: "#4d1a1a",
+		addedSignColor: "#99e89b",
+		removedSignColor: "#ef4444",
+		lineNumberFg: "#888888",
+	},
+	light: {
+		addedBg: "#e6ffed",
+		removedBg: "#ffebe9",
+		addedLineNumberBg: "#ccf0d2",
+		removedLineNumberBg: "#ffd7d5",
+		addedSignColor: "#116329",
+		removedSignColor: "#b42318",
+		lineNumberFg: "#57606a",
+	},
+} as const;
+
+export function getModeAccent(
+	mode: string,
+	theme: TerminalTheme = "dark",
+): string {
+	return mode === "plan" ? themePalette[theme].plan : themePalette[theme].act;
+}
+
+export function getSuccessColor(theme: TerminalTheme = "dark"): string {
+	return themePalette[theme].success;
+}
+
+// Input field adaptive color system
+//
+// The input field background needs to be visibly distinct from the terminal
+// background across every theme: pure black, dark grays, tinted themes like
+// Solarized/Dracula/Nord, and even light themes.
+//
+// We use OKLAB color space because its L (lightness) channel is perceptually
+// uniform -- adding a fixed L delta produces the same visual "step" whether
+// the base is black or gray, unlike raw RGB where the same numeric shift
+// looks huge on dark colors and invisible on light ones.
+//
+// The algorithm:
+//   1. Convert the terminal's detected background to OKLAB.
+//   2. Compute an adaptive lift: BASE_LIFT / (1 + distance_from_extreme * DAMPING).
+//      "distance_from_extreme" is L for dark themes (distance from black) or
+//      1-L for light themes (distance from white). This gives a large lift on
+//      very dark/light backgrounds and a smaller lift on mid-tones, preventing
+//      overshoot.
+//   3. On dark themes, raise L (lighten). On light themes, lower L (darken).
+//   4. Nudge the a/b chromatic channels by CHROMA_NUDGE toward the mode's
+//      accent color. For plan (warm/yellow): +a, +b. For act (cool/blue):
+//      -a, -b. At 0.003 this is ~10x below OKLAB's just-noticeable-difference
+//      threshold (~0.03), so it registers as a "feel" rather than visible color.
+//
+// Sample outputs on common terminals (act mode / plan mode bg):
+//   #000000 (black)          -> #1e201e / #211f1e  (lifted)
+//   #282828 (gruvbox)        -> #494a48 / #4c4948  (lifted)
+//   #002b36 (solarized dark) -> #254f58 / #2a4e58  (lifted)
+//   #ffffff (white)          -> #b0b2af / #b3b0af  (darkened)
+//   #fdf6e3 (solarized lite) -> #b4af9a / #b7ad9a  (darkened)
+const BASE_LIFT = 0.24;
+const LIFT_DAMPING = 3;
+const CHROMA_NUDGE = 0.003;
+const LIGHT_THEME_THRESHOLD = 0.5;
+
+const HEX6_RE = /^#[0-9a-fA-F]{6}$/;
+
+function normalizeHex(color: string | null): string | null {
+	if (!color) return null;
+	if (HEX6_RE.test(color)) return color;
+	if (/^#[0-9a-fA-F]{3}$/.test(color)) {
+		return `#${color[1]}${color[1]}${color[2]}${color[2]}${color[3]}${color[3]}`;
+	}
+	return null;
+}
+
+function isLightTheme(terminalBg: string | null): boolean {
+	const hex = normalizeHex(terminalBg);
+	if (!hex) return false;
+	return hexToOklab(hex).L > LIGHT_THEME_THRESHOLD;
+}
+
+export function getTerminalTheme(
+	terminalBg: string | null,
+	terminalFg?: string | null,
+): TerminalTheme {
+	const bg = normalizeHex(terminalBg);
+	if (bg) {
+		return hexToOklab(bg).L > LIGHT_THEME_THRESHOLD ? "light" : "dark";
+	}
+
+	const fg = normalizeHex(terminalFg ?? null);
+	if (fg) {
+		return hexToOklab(fg).L <= LIGHT_THEME_THRESHOLD ? "light" : "dark";
+	}
+
+	return "dark";
+}
+
+export function getDefaultForeground(
+	terminalBg: string | null,
+): string | undefined {
+	if (!terminalBg) return undefined;
+	return isLightTheme(terminalBg) ? "#1a1a1a" : undefined;
+}
+
+function liftedFromTerminalBg(
+	terminalBg: string | null,
+	baseLift: number,
+	nudgeA: number,
+	nudgeB: number,
+): string {
+	const hex = normalizeHex(terminalBg) ?? "#000000";
+	const base = hexToOklab(hex);
+	const light = base.L > LIGHT_THEME_THRESHOLD;
+	const lift = baseLift / (1 + (light ? 1 - base.L : base.L) * LIFT_DAMPING);
+	return oklabToHex(
+		base.L + (light ? -lift : lift),
+		base.a + nudgeA,
+		base.b + nudgeB,
+	);
+}
+
+export function getModeInputBackground(
+	mode: string,
+	terminalBg: string | null,
+): string {
+	const warm = mode === "plan";
+	return liftedFromTerminalBg(
+		terminalBg,
+		BASE_LIFT,
+		warm ? CHROMA_NUDGE : -CHROMA_NUDGE,
+		warm ? CHROMA_NUDGE : -CHROMA_NUDGE,
+	);
+}
+
+// The `─` rules framing the input field are thin foreground strokes rather
+// than filled cells, so they need a much larger lift than a background tint
+// to register at the same perceptual weight — this lands them around mid-gray
+// on both black and white terminals. They stay neutral (no mode chroma) so
+// the frame doesn't shift color when toggling plan/act.
+const RULE_BASE_LIFT = 0.5;
+
+export function getInputRuleColor(terminalBg: string | null): string {
+	return liftedFromTerminalBg(terminalBg, RULE_BASE_LIFT, 0, 0);
+}
+
+// User message bubbles stay neutral (no mode chroma) so the transcript reads
+// as history rather than tracking whichever mode is currently active.
+export function getUserMessageBackground(terminalBg: string | null): string {
+	return liftedFromTerminalBg(terminalBg, BASE_LIFT, 0, 0);
+}
+
+export function getModeInputForeground(
+	mode: string,
+	terminalBg: string | null,
+): string {
+	const light = isLightTheme(terminalBg);
+	const base = hexToOklab(light ? "#1a1a1a" : "#f0f0f0");
+	const warm = mode === "plan";
+	return oklabToHex(
+		base.L,
+		base.a + (warm ? CHROMA_NUDGE : -CHROMA_NUDGE),
+		base.b + (warm ? CHROMA_NUDGE : -CHROMA_NUDGE),
+	);
+}
+
+export function getModeInputPlaceholder(
+	mode: string,
+	terminalBg: string | null,
+): string {
+	const light = isLightTheme(terminalBg);
+	const base = hexToOklab(light ? "#777777" : "#888888");
+	const warm = mode === "plan";
+	return oklabToHex(
+		base.L,
+		base.a + (warm ? CHROMA_NUDGE * 2 : -CHROMA_NUDGE * 2),
+		base.b + (warm ? CHROMA_NUDGE * 2 : -CHROMA_NUDGE * 2),
+	);
+}
+
+function srgbToLinear(c: number): number {
+	return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+
+function linearToSrgb(c: number): number {
+	const v = c <= 0.0031308 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+	return Math.max(0, Math.min(1, v));
+}
+
+function hexToOklab(hex: string): { L: number; a: number; b: number } {
+	const r = srgbToLinear(parseInt(hex.slice(1, 3), 16) / 255);
+	const g = srgbToLinear(parseInt(hex.slice(3, 5), 16) / 255);
+	const b = srgbToLinear(parseInt(hex.slice(5, 7), 16) / 255);
+	const l_ = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+	const m_ = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+	const s_ = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+	return {
+		L: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+		a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+		b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_,
+	};
+}
+
+function oklabToHex(L: number, a: number, b: number): string {
+	const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+	const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+	const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+	const l = l_ * l_ * l_;
+	const m = m_ * m_ * m_;
+	const s = s_ * s_ * s_;
+	const r = linearToSrgb(
+		4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+	);
+	const g = linearToSrgb(
+		-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+	);
+	const bl = linearToSrgb(
+		-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
+	);
+	const toHex = (v: number) =>
+		Math.round(v * 255)
+			.toString(16)
+			.padStart(2, "0");
+	return `#${toHex(r)}${toHex(g)}${toHex(bl)}`;
+}
diff --git a/apps/cli/src/tui/root.tsx b/apps/cli/src/tui/root.tsx
new file mode 100644
index 0000000..8d8c96a
--- /dev/null
+++ b/apps/cli/src/tui/root.tsx
@@ -0,0 +1,998 @@
+import { getCurrentContextSize, summarizeUsageFromMessages } from "@cline/core";
+import type { Message } from "@cline/shared";
+import { formatDisplayUserInput, truncateStr } from "@cline/shared";
+import type { KeyEvent } from "@opentui/core";
+import { useRenderer, useTerminalDimensions } from "@opentui/react";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import {
+	DialogProvider,
+	useDialog,
+	useDialogState,
+} from "@opentui-ui/dialog/react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { shouldSuppressClineCliMigrationNoticeForActiveProvider } from "../kanban-migration/notice";
+import { MigrationNoticeContent } from "../kanban-migration/notice-dialog";
+import type { RepoStatus } from "../utils/repo-status";
+import { readRepoStatus } from "../utils/repo-status";
+import type { TranscriptScrollHandle } from "./components/chat-message-list";
+import {
+	CheckpointConfirmContent,
+	type CheckpointRestoreMode,
+} from "./components/dialogs/checkpoint-confirm";
+import {
+	CheckpointPickerContent,
+	type CheckpointPickerItem,
+	type CheckpointPickerResult,
+} from "./components/dialogs/checkpoint-picker";
+import {
+	CommandPaletteContent,
+	type CommandPaletteResult,
+} from "./components/dialogs/command-palette";
+import {
+	buildCommandPaletteItems,
+	findCommandPaletteShortcut,
+} from "./components/dialogs/command-palette-items";
+import {
+	SKILLS_MARKETPLACE_ACTION,
+	SKILLS_MARKETPLACE_URL,
+	SkillsPickerContent,
+} from "./components/dialogs/skills-picker";
+import { Toast, type ToastState, type ToastVariant } from "./components/toast";
+import { EventBridgeProvider } from "./contexts/event-bridge-context";
+import { SessionProvider, useSession } from "./contexts/session-context";
+import { useAccountDialog } from "./hooks/use-account-dialog";
+import { useAgentEventHandlers } from "./hooks/use-agent-events";
+import { useAutocomplete } from "./hooks/use-autocomplete";
+import { useConfigPanel } from "./hooks/use-config-panel";
+import { useLocalCommandActions } from "./hooks/use-local-command-actions";
+import { useMcpManager } from "./hooks/use-mcp-manager";
+import { useModelSelector } from "./hooks/use-model-selector";
+import { usePromptInputController } from "./hooks/use-prompt-input-controller";
+import { useQueuedPrompts } from "./hooks/use-queued-prompts";
+import { useRootKeyboard } from "./hooks/use-root-keyboard";
+import { useRuntimeDialogBridge } from "./hooks/use-runtime-dialog-bridge";
+import { useSlashCommands } from "./hooks/use-slash-commands";
+import { TerminalColorsContext } from "./hooks/use-terminal-background";
+import type { AppView, TuiProps } from "./types";
+import { hydrateSessionMessages } from "./utils/hydrate-messages";
+import { isProviderConfigured } from "./utils/provider-configured";
+import { createSelectionCopyHandler } from "./utils/selection-copy";
+import type { LocalSlashCommandInvocation } from "./utils/skill-command-input";
+import { deriveTerminalTitle } from "./utils/terminal-title";
+import { ChatView } from "./views/chat-view";
+import { HomeView } from "./views/home-view";
+import { type OnboardingResult, OnboardingView } from "./views/onboarding";
+
+function App(props: TuiProps) {
+	const session = useSession();
+	const renderer = useRenderer();
+	const dialog = useDialog();
+	const isDialogOpen = useDialogState((s: { isOpen: boolean }) => s.isOpen);
+	const { height: termHeight, width: termWidth } = useTerminalDimensions();
+
+	const [repoStatus, setRepoStatus] = useState<RepoStatus>(
+		props.initialRepoStatus ?? { branch: null, diffStats: null },
+	);
+	const { queuedPrompts, handlePendingPrompts } = useQueuedPrompts();
+	const [selectedQueuedPromptId, setSelectedQueuedPromptId] = useState<
+		string | null
+	>(null);
+	const [editingQueuedPromptId, setEditingQueuedPromptId] = useState<
+		string | null
+	>(null);
+	const [appView, setAppView] = useState<AppView>(() => {
+		if (process.env.CLINE_FORCE_ONBOARDING === "1") return "onboarding";
+		if (!isProviderConfigured(props.config)) return "onboarding";
+		return props.initialView === "chat" || session.entries.length > 0
+			? "chat"
+			: "home";
+	});
+	const [toast, setToast] = useState<ToastState | null>(null);
+	const [workflowSlashCommands, setWorkflowSlashCommands] = useState(
+		props.workflowSlashCommands,
+	);
+	const toastTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+	const checkpointRestoreInFlightRef = useRef(false);
+
+	const workspaceRoot = props.config.workspaceRoot?.trim() || props.config.cwd;
+	const canForkSession = session.hasSubmitted || session.entries.length > 0;
+	const terminalTitle = useMemo(
+		() =>
+			deriveTerminalTitle({
+				appView,
+				entries: session.entries,
+				initialPrompt: props.initialPrompt,
+			}),
+		[appView, props.initialPrompt, session.entries],
+	);
+
+	useEffect(() => {
+		setWorkflowSlashCommands(props.workflowSlashCommands);
+	}, [props.workflowSlashCommands]);
+
+	const {
+		registry: slashCommandRegistry,
+		systemCommands,
+		skillCommands,
+		invokableSkillCommands,
+	} = useSlashCommands({
+		workflowSlashCommands,
+		loadAdditionalSlashCommands: props.loadAdditionalSlashCommands,
+		canFork: canForkSession,
+	});
+
+	const autocomplete = useAutocomplete({
+		workspaceRoot,
+		systemCommands,
+		skillCommands,
+	});
+
+	const refreshRepoStatus = useCallback(() => {
+		readRepoStatus(props.config.cwd)
+			.then(setRepoStatus)
+			.catch(() => {});
+	}, [props.config.cwd]);
+
+	const refocusTextareaRef = useRef<() => void>(() => {});
+	const populateInputRef = useRef<(value: string) => void>(() => {});
+	const insertSkillCommandRef = useRef<
+		(command: string, invocation?: LocalSlashCommandInvocation) => void
+	>(() => {});
+	const removeLocalCommandInvocationRef = useRef<
+		(invocation: LocalSlashCommandInvocation) => void
+	>(() => {});
+	const transcriptScrollRef = useRef<TranscriptScrollHandle | null>(null);
+	const initialNoticeShownRef = useRef(false);
+	const editingQueuedPrompt = useMemo(
+		() =>
+			editingQueuedPromptId
+				? queuedPrompts.find((item) => item.id === editingQueuedPromptId)
+				: undefined,
+		[editingQueuedPromptId, queuedPrompts],
+	);
+
+	const clearToastTimeout = useCallback(() => {
+		if (toastTimeoutRef.current) {
+			clearTimeout(toastTimeoutRef.current);
+			toastTimeoutRef.current = null;
+		}
+	}, []);
+
+	const showToast = useCallback(
+		(message: string, variant: ToastVariant = "info") => {
+			clearToastTimeout();
+			setToast({ message, variant });
+			toastTimeoutRef.current = setTimeout(() => {
+				setToast(null);
+				toastTimeoutRef.current = null;
+			}, 1800);
+		},
+		[clearToastTimeout],
+	);
+
+	const toggleMode = useCallback(() => {
+		const newMode = session.uiMode === "act" ? "plan" : "act";
+		session.toggleMode();
+		void props.onModeChange(newMode);
+	}, [props, session]);
+
+	const handleModelChange = useCallback(async () => {
+		await props.onModelChange();
+	}, [props]);
+
+	const openModelSelector = useModelSelector({
+		dialog,
+		config: props.config,
+		termHeight,
+		onModelChange: handleModelChange,
+		refocusTextarea: () => refocusTextareaRef.current(),
+	});
+
+	const openMcpManager = useMcpManager({
+		dialog,
+		termHeight,
+		loadConfigData: props.loadConfigData,
+		onSessionRestart: props.onSessionRestart,
+		refocusTextarea: () => refocusTextareaRef.current(),
+	});
+	const propsOnToggleConfigItem = props.onToggleConfigItem;
+	const onToggleConfigItem = useMemo<TuiProps["onToggleConfigItem"]>(() => {
+		if (!propsOnToggleConfigItem) {
+			return undefined;
+		}
+		return async (item, options) => {
+			const data = await propsOnToggleConfigItem(item, options);
+			if (data) {
+				setWorkflowSlashCommands(data.workflowSlashCommands);
+			}
+			return data;
+		};
+	}, [propsOnToggleConfigItem]);
+	const propsOnDeleteConfigItem = props.onDeleteConfigItem;
+	const onDeleteConfigItem = useMemo<TuiProps["onDeleteConfigItem"]>(() => {
+		if (!propsOnDeleteConfigItem) {
+			return undefined;
+		}
+		return async (item, options) => {
+			const data = await propsOnDeleteConfigItem(item, options);
+			if (data) {
+				setWorkflowSlashCommands(data.workflowSlashCommands);
+			}
+			return data;
+		};
+	}, [propsOnDeleteConfigItem]);
+
+	const openConfig = useConfigPanel({
+		dialog,
+		config: props.config,
+		sessionUiMode: session.uiMode,
+		compactionMode: session.compactionMode,
+		toggleMode,
+		toggleAutoApprove: () => session.toggleAutoApprove(),
+		setCompactionMode: session.setCompactionMode,
+		termHeight,
+		loadConfigData: props.loadConfigData,
+		onToggleConfigItem,
+		onDeleteConfigItem,
+		openModelSelector,
+		openMcpManager,
+		refocusTextarea: () => refocusTextareaRef.current(),
+	});
+
+	const openAccount = useAccountDialog({
+		dialog,
+		termHeight,
+		loadAccount: props.loadClineAccount,
+		switchAccount: props.switchClineAccount,
+		onAccountChange: props.onAccountChange,
+		openModelSelector,
+		refocusTextarea: () => refocusTextareaRef.current(),
+	});
+
+	const clearConversation = useCallback(async () => {
+		const shouldRestartSession = session.hasSubmitted;
+		session.clearEntries();
+		session.setHasSubmitted(false);
+		if (!shouldRestartSession) {
+			setAppView("home");
+			refocusTextareaRef.current();
+			return;
+		}
+		try {
+			await props.onNewSession();
+			setAppView("home");
+		} catch (error) {
+			setAppView("chat");
+			session.appendEntry({
+				kind: "error",
+				text: `Clear failed: ${error instanceof Error ? error.message : String(error)}`,
+			});
+		} finally {
+			refocusTextareaRef.current();
+		}
+	}, [props, session]);
+
+	const openCheckpointRestore = useCallback(async () => {
+		if (checkpointRestoreInFlightRef.current) {
+			showToast("Checkpoint restore already in progress", "info");
+			return;
+		}
+		if (session.isRunning) {
+			showToast("Wait for the current run to finish before restoring", "info");
+			return;
+		}
+		checkpointRestoreInFlightRef.current = true;
+		let restoreStatusEntryAppended = false;
+		try {
+			const data = await props.getCheckpointData();
+			if (!data) {
+				showToast("No checkpoint data available", "error");
+				return;
+			}
+			const { messages: rawMessages, checkpointHistory } = data;
+			if (checkpointHistory.length === 0) {
+				showToast("No checkpoints available", "info");
+				return;
+			}
+			const checkpointForRun = (runCount: number) =>
+				checkpointHistory.reduce<
+					(typeof checkpointHistory)[number] | undefined
+				>((best, checkpoint) => {
+					if (checkpoint.runCount > runCount) {
+						return best;
+					}
+					if (!best || checkpoint.runCount > best.runCount) {
+						return checkpoint;
+					}
+					return best;
+				}, undefined);
+			const items: CheckpointPickerItem[] = [];
+			let userRunCount = 0;
+			for (const msg of rawMessages as Array<
+				Message & { metadata?: Record<string, unknown> }
+			>) {
+				if (msg.role !== "user") continue;
+				const metadata =
+					"metadata" in msg && msg.metadata && typeof msg.metadata === "object"
+						? msg.metadata
+						: undefined;
+				if (metadata?.kind === "recovery_notice") continue;
+				userRunCount += 1;
+				const checkpoint = checkpointForRun(userRunCount);
+				if (!checkpoint) continue;
+				const text =
+					typeof msg.content === "string"
+						? msg.content
+						: Array.isArray(msg.content)
+							? msg.content
+									.filter(
+										(b): b is { type: "text"; text: string } =>
+											typeof b === "object" &&
+											b !== null &&
+											"type" in b &&
+											b.type === "text" &&
+											"text" in b &&
+											typeof b.text === "string",
+									)
+									.map((b) => b.text)
+									.join(" ")
+							: "";
+				const preview = truncateStr(
+					formatDisplayUserInput(text).replace(/\s+/g, " "),
+					60,
+				);
+				if (!preview) continue;
+				items.push({
+					runCount: userRunCount,
+					text: preview,
+					fullText: text,
+					createdAt: checkpoint.createdAt,
+				});
+			}
+			if (items.length === 0) {
+				showToast("No checkpoints to restore", "info");
+				return;
+			}
+
+			const picked = await dialog.choice<CheckpointPickerResult>({
+				size: "large",
+				style: { maxHeight: termHeight - 2 },
+				content: (ctx: ChoiceContext<CheckpointPickerResult>) => (
+					<CheckpointPickerContent {...ctx} items={items} />
+				),
+			});
+			if (!picked) {
+				return;
+			}
+			const restoreMode = await dialog.choice<CheckpointRestoreMode>({
+				closeOnEscape: true,
+				content: (ctx: ChoiceContext<CheckpointRestoreMode>) => (
+					<CheckpointConfirmContent
+						{...ctx}
+						messagePreview={picked.messagePreview}
+					/>
+				),
+			});
+			if (!restoreMode) {
+				return;
+			}
+			const restoreWorkspace = restoreMode === "chat-and-workspace";
+			session.appendEntry({
+				kind: "status",
+				text: `Restoring to checkpoint${restoreWorkspace ? " (chat + workspace)" : " (chat only)"}...`,
+			});
+			restoreStatusEntryAppended = true;
+			const result = await props.onRestoreCheckpoint(
+				picked.runCount,
+				restoreWorkspace,
+			);
+			if (!result) {
+				session.updateLastEntry(() => ({
+					kind: "error",
+					text: "Checkpoint restore failed: no result returned.",
+				}));
+				return;
+			}
+			session.clearEntries();
+			const entries = hydrateSessionMessages(result.messages);
+			// Remove the trailing user message -- it goes into the input
+			// field so the user can edit and re-send it.
+			const lastEntry = entries[entries.length - 1];
+			if (lastEntry && lastEntry.kind === "user_submitted") {
+				entries.pop();
+			}
+			// replaceEntries rather than appendEntry: appendEntry stamps
+			// unstamped entries with the CURRENT mode, which would lock
+			// hydrated history to the restore-time accent.
+			session.replaceEntries(entries);
+			session.setHasSubmitted(entries.length > 0);
+			setAppView(entries.length > 0 ? "chat" : "home");
+			populateInputRef.current(picked.fullText);
+			showToast("Restored to checkpoint", "success");
+		} catch (error) {
+			const message = `Checkpoint restore failed: ${error instanceof Error ? error.message : String(error)}`;
+			if (restoreStatusEntryAppended) {
+				session.updateLastEntry(() => ({
+					kind: "error",
+					text: message,
+				}));
+			} else {
+				showToast(message, "error");
+			}
+		} finally {
+			checkpointRestoreInFlightRef.current = false;
+			refocusTextareaRef.current();
+		}
+	}, [dialog, props, session, showToast, termHeight]);
+
+	const exitCline = useCallback(() => {
+		session.requestExit();
+	}, [session]);
+
+	const openSkills = useCallback(
+		async (invocation?: LocalSlashCommandInvocation) => {
+			const selected = await dialog.choice<string>({
+				style: { maxHeight: termHeight - 2 },
+				content: (ctx: ChoiceContext<string>) => (
+					<SkillsPickerContent {...ctx} commands={invokableSkillCommands} />
+				),
+			});
+			if (selected === SKILLS_MARKETPLACE_ACTION) {
+				await import("open")
+					.then(({ default: open }) => open(SKILLS_MARKETPLACE_URL))
+					.catch(() => {
+						showToast(`Visit ${SKILLS_MARKETPLACE_URL}`, "info");
+					});
+				if (invocation) {
+					removeLocalCommandInvocationRef.current(invocation);
+				} else {
+					refocusTextareaRef.current();
+				}
+			} else if (selected) {
+				insertSkillCommandRef.current(selected, invocation);
+			} else if (invocation) {
+				removeLocalCommandInvocationRef.current(invocation);
+			} else {
+				refocusTextareaRef.current();
+			}
+		},
+		[dialog, invokableSkillCommands, showToast, termHeight],
+	);
+
+	useEffect(() => {
+		const { handleSelection, dispose } = createSelectionCopyHandler({
+			copyToClipboardOSC52: (text) => renderer.copyToClipboardOSC52(text),
+			showToast,
+		});
+
+		renderer.on("selection", handleSelection);
+		return () => {
+			dispose();
+			renderer.off("selection", handleSelection);
+		};
+	}, [renderer, showToast]);
+
+	useEffect(() => {
+		renderer.setTerminalTitle(terminalTitle);
+	}, [renderer, terminalTitle]);
+
+	useEffect(() => {
+		return () => {
+			renderer.setTerminalTitle("");
+		};
+	}, [renderer]);
+
+	useEffect(() => {
+		return () => {
+			clearToastTimeout();
+		};
+	}, [clearToastTimeout]);
+
+	useEffect(() => {
+		const selectedPromptMissing =
+			selectedQueuedPromptId &&
+			!queuedPrompts.some((item) => item.id === selectedQueuedPromptId);
+		const editingPromptMissing =
+			editingQueuedPromptId &&
+			!queuedPrompts.some((item) => item.id === editingQueuedPromptId);
+
+		if (selectedPromptMissing) {
+			setSelectedQueuedPromptId(null);
+		}
+		if (editingPromptMissing) {
+			setEditingQueuedPromptId(null);
+		}
+		if (selectedPromptMissing || editingPromptMissing) {
+			refocusTextareaRef.current();
+		}
+	}, [editingQueuedPromptId, queuedPrompts, selectedQueuedPromptId]);
+
+	const selectQueuedPrompt = useCallback((promptId: string | null) => {
+		setSelectedQueuedPromptId(promptId);
+	}, []);
+
+	const beginQueuedPromptEdit = useCallback(
+		(promptId: string) => {
+			const item = queuedPrompts.find((queued) => queued.id === promptId);
+			if (!item) return;
+			setSelectedQueuedPromptId(promptId);
+			setEditingQueuedPromptId(promptId);
+		},
+		[queuedPrompts],
+	);
+
+	const cancelQueuedPromptEdit = useCallback(() => {
+		setEditingQueuedPromptId(null);
+		setSelectedQueuedPromptId(null);
+		refocusTextareaRef.current();
+	}, []);
+
+	const promoteQueuedPrompt = useCallback(
+		(promptId: string) => {
+			void props
+				.onUpdatePendingPrompt({ promptId, delivery: "steer" })
+				.catch((error) => {
+					showToast(
+						`Could not steer queued message: ${error instanceof Error ? error.message : String(error)}`,
+						"error",
+					);
+				});
+		},
+		[props, showToast],
+	);
+
+	const notice = props.initialNotice;
+	const onInitialNoticeShown = props.onInitialNoticeShown;
+	const currentProviderId = props.config.providerId;
+	useEffect(() => {
+		if (!notice) return;
+		if (initialNoticeShownRef.current) return;
+		if (appView !== "home") return;
+		if (
+			shouldSuppressClineCliMigrationNoticeForActiveProvider(currentProviderId)
+		) {
+			initialNoticeShownRef.current = true;
+			return;
+		}
+
+		initialNoticeShownRef.current = true;
+		const timeout = setTimeout(() => {
+			void dialog
+				.choice<boolean>({
+					content: (ctx: ChoiceContext<boolean>) => (
+						<MigrationNoticeContent {...ctx} notice={notice} />
+					),
+				})
+				.finally(() => {
+					Promise.resolve(onInitialNoticeShown?.(notice)).catch(() => {});
+					refocusTextareaRef.current();
+				});
+		}, 0);
+		return () => clearTimeout(timeout);
+	}, [appView, currentProviderId, dialog, notice, onInitialNoticeShown]);
+
+	const {
+		appendEntry: appendSessionEntry,
+		replaceEntries: replaceSessionEntries,
+		setHasSubmitted: setSessionHasSubmitted,
+		setLastTotalCost: setSessionLastTotalCost,
+		setLastTotalTokens: setSessionLastTotalTokens,
+	} = session;
+	const deferredHydrationGuardRef = useRef({
+		hasSubmitted: session.hasSubmitted,
+		entryCount: session.entries.length,
+	});
+	deferredHydrationGuardRef.current = {
+		hasSubmitted: session.hasSubmitted,
+		entryCount: session.entries.length,
+	};
+
+	useEffect(() => {
+		const loadDeferredInitialMessages = props.loadDeferredInitialMessages;
+		if (!loadDeferredInitialMessages) {
+			return;
+		}
+		let cancelled = false;
+		loadDeferredInitialMessages()
+			.then((result) => {
+				const { messages } = result;
+				if (cancelled || messages.length === 0) {
+					return;
+				}
+				const currentSession = deferredHydrationGuardRef.current;
+				if (currentSession.hasSubmitted || currentSession.entryCount > 0) {
+					return;
+				}
+				replaceSessionEntries(hydrateSessionMessages(messages));
+				if (typeof result.currentContextSize === "number") {
+					setSessionLastTotalTokens(result.currentContextSize);
+				}
+				if (typeof result.totalCost === "number") {
+					setSessionLastTotalCost(result.totalCost);
+				}
+				setSessionHasSubmitted(true);
+				setAppView("chat");
+			})
+			.catch((error) => {
+				if (cancelled) {
+					return;
+				}
+				appendSessionEntry({
+					kind: "error",
+					text: error instanceof Error ? error.message : String(error),
+				});
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		props.loadDeferredInitialMessages,
+		appendSessionEntry,
+		replaceSessionEntries,
+		setSessionHasSubmitted,
+		setSessionLastTotalCost,
+		setSessionLastTotalTokens,
+	]);
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: run once on mount
+	useEffect(() => {
+		if (props.initialView === "config") {
+			openConfig();
+		}
+	}, []);
+
+	const { handleSlashCommand } = useLocalCommandActions({
+		slashCommandRegistry,
+		canForkSession,
+		openAccount,
+		openConfig,
+		openMcpManager,
+		openModelSelector,
+		openSkills,
+		refocusTextarea: () => refocusTextareaRef.current(),
+		setAppView,
+		onClearConversation: clearConversation,
+		onResumeSession: props.onResumeSession,
+		onCompact: props.onCompact,
+		onFork: props.onFork,
+		onUndo: openCheckpointRestore,
+		onExit: exitCline,
+	});
+
+	const runCommandPaletteResult = useCallback(
+		async (result: CommandPaletteResult) => {
+			if (result.action === "change-provider") {
+				await openModelSelector({ startWithProviderChange: true });
+				return;
+			}
+			if (result.action === "change-model") {
+				await openModelSelector();
+				return;
+			}
+
+			await Promise.resolve(handleSlashCommand(result.action));
+		},
+		[handleSlashCommand, openModelSelector],
+	);
+
+	const commandPaletteOpenRef = useRef(false);
+	const globalPaletteItems = useMemo(
+		() => buildCommandPaletteItems({ canForkSession }),
+		[canForkSession],
+	);
+	const openCommandPalette = useCallback(async () => {
+		if (commandPaletteOpenRef.current) return;
+		commandPaletteOpenRef.current = true;
+		const dialogWidth = Math.min(
+			64,
+			Math.max(48, Math.floor(termWidth * 0.58)),
+			Math.max(42, termWidth - 8),
+		);
+		try {
+			const result = await dialog.choice<CommandPaletteResult>({
+				style: { width: dialogWidth, maxHeight: termHeight - 2 },
+				content: (ctx: ChoiceContext<CommandPaletteResult>) => (
+					<CommandPaletteContent
+						{...ctx}
+						canForkSession={canForkSession}
+						contentWidth={dialogWidth - 2}
+					/>
+				),
+			});
+			if (result) {
+				await runCommandPaletteResult(result);
+				return;
+			}
+			refocusTextareaRef.current();
+		} finally {
+			commandPaletteOpenRef.current = false;
+		}
+	}, [canForkSession, dialog, runCommandPaletteResult, termHeight, termWidth]);
+
+	const runCommandPaletteShortcut = useCallback(
+		(key: KeyEvent) => {
+			const shortcut = findCommandPaletteShortcut(globalPaletteItems, key);
+			if (!shortcut) return false;
+			key.preventDefault();
+			void runCommandPaletteResult(shortcut.result);
+			return true;
+		},
+		[globalPaletteItems, runCommandPaletteResult],
+	);
+
+	const agentHandlers = useAgentEventHandlers({
+		appendEntry: session.appendEntry,
+		updateLastEntry: session.updateLastEntry,
+		updateEntry: session.updateEntry,
+		closeInlineStream: session.closeInlineStream,
+		activeInlineStreamRef: session.activeInlineStreamRef,
+		setIsRunning: session.setIsRunning,
+		setIsStreaming: session.setIsStreaming,
+		addUsageDelta: session.addUsageDelta,
+		onTurnErrorReported: props.onTurnErrorReported,
+		verbose: props.config.verbose ?? false,
+	});
+
+	const promptInput = usePromptInputController({
+		autocomplete,
+		slashCommandRegistry,
+		handleSlashCommand,
+		onSubmit: props.onSubmit,
+		initialPrompt: props.initialPrompt,
+		providerId: props.config.providerId,
+		configVerbose: props.config.verbose ?? false,
+		refreshRepoStatus,
+		setAppView,
+		turnErrorReportedRef: agentHandlers.turnErrorReportedRef,
+	});
+	const focusPromptTextarea = promptInput.focusTextarea;
+	const submitInitialPrompt = promptInput.submitInitialPrompt;
+	refocusTextareaRef.current = promptInput.refocusTextarea;
+	populateInputRef.current = (value: string) => {
+		promptInput.populateInput(value);
+	};
+	insertSkillCommandRef.current = (command, invocation) => {
+		promptInput.insertSkillCommand(command, invocation);
+	};
+	removeLocalCommandInvocationRef.current = (invocation) => {
+		promptInput.removeLocalCommandInvocation(invocation);
+	};
+	const runtimeBridge = useRuntimeDialogBridge({
+		setToolApprover: props.setToolApprover,
+		setAskQuestion: props.setAskQuestion,
+		setModeChangeNotifier: props.setModeChangeNotifier,
+		setUiMode: session.setUiMode,
+		refocusTextarea: promptInput.refocusTextarea,
+	});
+	const runtimeInteraction = runtimeBridge.interaction;
+	const isRuntimeInteractionOpen = runtimeInteraction !== null;
+	const saveQueuedPromptEdit = useCallback(
+		async (promptId: string, text: string) => {
+			if (!promptId) return;
+			const prompt = text.trim();
+			if (!prompt) {
+				showToast("Queued message cannot be empty", "error");
+				return;
+			}
+			try {
+				await props.onUpdatePendingPrompt({ promptId, prompt });
+				setEditingQueuedPromptId(null);
+				setSelectedQueuedPromptId(null);
+				refocusTextareaRef.current();
+			} catch (error) {
+				showToast(
+					`Could not update queued message: ${error instanceof Error ? error.message : String(error)}`,
+					"error",
+				);
+			}
+		},
+		[props, showToast],
+	);
+	const submitFromInput = useCallback(() => {
+		if (editingQueuedPromptId) {
+			return;
+		}
+		if (selectedQueuedPromptId) {
+			promoteQueuedPrompt(selectedQueuedPromptId);
+			return;
+		}
+		promptInput.handleSubmit();
+	}, [
+		editingQueuedPromptId,
+		promoteQueuedPrompt,
+		promptInput,
+		selectedQueuedPromptId,
+	]);
+	const focusPromptInput = useCallback(() => {
+		if (editingQueuedPromptId || selectedQueuedPromptId) {
+			setEditingQueuedPromptId(null);
+			setSelectedQueuedPromptId(null);
+			refocusTextareaRef.current();
+			return;
+		}
+		promptInput.focusTextarea();
+	}, [editingQueuedPromptId, promptInput, selectedQueuedPromptId]);
+	const initialPromptSubmittedRef = useRef(false);
+
+	useEffect(() => {
+		if (isDialogOpen || isRuntimeInteractionOpen || appView === "onboarding") {
+			return;
+		}
+		focusPromptTextarea();
+	}, [isDialogOpen, isRuntimeInteractionOpen, appView, focusPromptTextarea]);
+
+	useEffect(() => {
+		if (initialPromptSubmittedRef.current) return;
+		if (appView === "onboarding") return;
+		if (!props.initialPrompt?.trim()) return;
+		const timeout = setTimeout(() => {
+			if (initialPromptSubmittedRef.current) return;
+			initialPromptSubmittedRef.current = true;
+			submitInitialPrompt();
+		}, 0);
+		return () => clearTimeout(timeout);
+	}, [appView, submitInitialPrompt, props.initialPrompt]);
+
+	useRootKeyboard({
+		isDialogOpen: isDialogOpen || isRuntimeInteractionOpen,
+		appView,
+		autocomplete,
+		inputHistory: promptInput.inputHistory,
+		transcriptScrollRef,
+		inputValueRef: promptInput.inputValueRef,
+		selectRef: promptInput.selectRef,
+		submitRef: promptInput.submitRef,
+		queuedPromptSelection: {
+			items: queuedPrompts,
+			selectedId: selectedQueuedPromptId,
+			editingId: editingQueuedPromptId,
+			select: selectQueuedPrompt,
+			beginEdit: beginQueuedPromptEdit,
+			cancelEdit: cancelQueuedPromptEdit,
+			promote: promoteQueuedPrompt,
+		},
+		syncInputFromTextarea: promptInput.syncInputFromTextarea,
+		getCurrentInputText: promptInput.getCurrentInputText,
+		setInputKey: promptInput.setInputKey,
+		setInputValue: promptInput.setInputValue,
+		onAbort: props.onAbort,
+		onExit: exitCline,
+		onToggleMode: toggleMode,
+		onClearConversation: clearConversation,
+		onRestoreCheckpoint: openCheckpointRestore,
+		onOpenCommandPalette: openCommandPalette,
+		onCommandPaletteShortcut: runCommandPaletteShortcut,
+	});
+
+	const acOptions = autocomplete.getFilteredOptions();
+
+	const eventBridgeHandlers = useMemo(
+		() => ({
+			onAgentEvent: agentHandlers.handleAgentEvent,
+			onTeamEvent: agentHandlers.handleTeamEvent,
+			onPendingPrompts: handlePendingPrompts,
+			onPendingPromptSubmitted: agentHandlers.handlePendingPromptSubmitted,
+		}),
+		[agentHandlers, handlePendingPrompts],
+	);
+
+	const viewProps = {
+		config: props.config,
+		inputValue: promptInput.inputValue,
+		inputKey: promptInput.inputKey,
+		onSubmit: submitFromInput,
+		onContentChange: promptInput.handleContentChange,
+		onImagePaste: promptInput.handleImagePaste,
+		onLargeTextPaste: promptInput.handleLargeTextPaste,
+		onInputFocusRequest: focusPromptInput,
+		repoStatus,
+		textareaRef: promptInput.textareaRef,
+		transcriptScrollRef,
+		loadIndividualSubscriptionPlans: props.loadIndividualSubscriptionPlans,
+		queuedPrompts,
+		selectedQueuedPromptId,
+		editingQueuedPrompt,
+		onQueuedPromptEditConfirm: (id: string, prompt: string) => {
+			void saveQueuedPromptEdit(id, prompt);
+		},
+		onToggleMode: toggleMode,
+		runtimeInteraction,
+		onResolveToolApproval: runtimeBridge.resolveToolApproval,
+		onResolveAskQuestion: runtimeBridge.resolveAskQuestion,
+		autocomplete: {
+			mode: autocomplete.mode,
+			options: acOptions,
+			selected: autocomplete.selected,
+			onSelect: promptInput.selectAutocompleteOption,
+		},
+	};
+
+	const wrapWithBridge = (children: React.ReactNode) => (
+		<EventBridgeProvider
+			subscribeToEvents={props.subscribeToEvents}
+			handlers={eventBridgeHandlers}
+		>
+			{children}
+		</EventBridgeProvider>
+	);
+
+	let content: React.ReactNode;
+
+	if (appView === "onboarding") {
+		content = (
+			<OnboardingView
+				onComplete={(result: OnboardingResult) => {
+					props.config.providerId = result.providerId;
+					props.config.modelId = result.modelId;
+					props.config.apiKey = result.apiKey ?? "";
+					if (result.thinking !== undefined) {
+						props.config.thinking = result.thinking;
+					}
+					if (result.reasoningEffort !== undefined) {
+						props.config.reasoningEffort = result.reasoningEffort;
+					}
+
+					handleModelChange().then(() => setAppView("home"));
+				}}
+				onExit={() => {
+					exitCline();
+				}}
+			/>
+		);
+	} else if (session.hasSubmitted || appView === "chat") {
+		content = <ChatView {...viewProps} />;
+	} else {
+		content = <HomeView {...viewProps} />;
+	}
+
+	return wrapWithBridge(
+		<box flexDirection="column" width="100%" height="100%">
+			{content}
+			<Toast toast={toast} />
+		</box>,
+	);
+}
+
+export function Root(
+	props: TuiProps & {
+		terminalBackground?: string | null;
+		terminalForeground?: string | null;
+	},
+) {
+	const initialEntries = useMemo(
+		() => hydrateSessionMessages(props.initialMessages ?? []),
+		[props.initialMessages],
+	);
+	const initialUsage = useMemo(() => {
+		const messages = props.initialMessages ?? [];
+		const usage = summarizeUsageFromMessages(messages);
+		return {
+			totalTokens: getCurrentContextSize(messages) ?? 0,
+			totalCost: usage.totalCost,
+		};
+	}, [props.initialMessages]);
+	const terminalColors = useMemo(
+		() => ({
+			background: props.terminalBackground ?? null,
+			foreground: props.terminalForeground ?? null,
+		}),
+		[props.terminalBackground, props.terminalForeground],
+	);
+	return (
+		<TerminalColorsContext value={terminalColors}>
+			<DialogProvider size="medium">
+				<SessionProvider
+					config={props.config}
+					initialEntries={initialEntries}
+					initialUsage={initialUsage}
+					onRunningChange={props.onRunningChange}
+					onAutoApproveChange={props.onAutoApproveChange}
+					onCompactionModeChange={props.onCompactionModeChange}
+					onExit={props.onExit}
+				>
+					<App {...props} />
+				</SessionProvider>
+			</DialogProvider>
+		</TerminalColorsContext>
+	);
+}
diff --git a/apps/cli/src/tui/stdio-capture.test.ts b/apps/cli/src/tui/stdio-capture.test.ts
new file mode 100644
index 0000000..a936e3f
--- /dev/null
+++ b/apps/cli/src/tui/stdio-capture.test.ts
@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { installTuiStdioCapture } from "./stdio-capture";
+
+describe("installTuiStdioCapture", () => {
+	let restoreCapture: (() => void) | undefined;
+	let stdoutWriteSpy: ReturnType<typeof vi.spyOn>;
+	let stderrWriteSpy: ReturnType<typeof vi.spyOn>;
+	let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+	let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		stdoutWriteSpy = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+		stderrWriteSpy = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+		consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+		consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+	});
+
+	afterEach(() => {
+		restoreCapture?.();
+		restoreCapture = undefined;
+		stdoutWriteSpy.mockRestore();
+		stderrWriteSpy.mockRestore();
+		consoleLogSpy.mockRestore();
+		consoleErrorSpy.mockRestore();
+	});
+
+	it("suppresses stdout and stderr writes while capture is active", () => {
+		restoreCapture = installTuiStdioCapture();
+
+		process.stdout.write("\x1b[2m[hub] server restarted\x1b[0m\n");
+		process.stderr.write("startup failed\n");
+
+		expect(stdoutWriteSpy).not.toHaveBeenCalled();
+		expect(stderrWriteSpy).not.toHaveBeenCalled();
+		expect(consoleLogSpy).not.toHaveBeenCalled();
+		expect(consoleErrorSpy).not.toHaveBeenCalled();
+	});
+
+	it("does not replay partial lines on restore", () => {
+		restoreCapture = installTuiStdioCapture();
+
+		process.stdout.write("hello ");
+		expect(consoleLogSpy).not.toHaveBeenCalled();
+
+		process.stdout.write("world\nnext");
+		expect(consoleLogSpy).not.toHaveBeenCalledWith("hello world");
+		expect(consoleLogSpy).not.toHaveBeenCalledWith("next");
+
+		restoreCapture();
+		restoreCapture = undefined;
+
+		expect(consoleLogSpy).not.toHaveBeenCalledWith("next");
+	});
+
+	it("suppresses OSC sequences", () => {
+		restoreCapture = installTuiStdioCapture();
+
+		process.stdout.write("\x1b]52;c;SGVsbG8=\x1b\\visible text\n");
+		process.stdout.write("\x1b]0;window title\x07only this\n");
+
+		expect(consoleLogSpy).not.toHaveBeenCalled();
+	});
+
+	it("preserves write callbacks", async () => {
+		restoreCapture = installTuiStdioCapture();
+
+		await new Promise<void>((resolve) => {
+			process.stdout.write("callback test\n", () => {
+				resolve();
+			});
+		});
+
+		expect(stdoutWriteSpy).not.toHaveBeenCalled();
+		expect(consoleLogSpy).not.toHaveBeenCalled();
+	});
+
+	it("does not route captured writes through console methods", () => {
+		restoreCapture = installTuiStdioCapture();
+
+		consoleLogSpy.mockImplementation((text: string) => {
+			process.stdout.write(`[re-entrant] ${text}\n`);
+		});
+
+		process.stdout.write("hello\n");
+
+		expect(consoleLogSpy).not.toHaveBeenCalled();
+	});
+
+	it("restores the original stream writers", () => {
+		restoreCapture = installTuiStdioCapture();
+
+		restoreCapture();
+		restoreCapture = undefined;
+		process.stdout.write("visible");
+
+		expect(stdoutWriteSpy).toHaveBeenCalledWith("visible");
+	});
+});
diff --git a/apps/cli/src/tui/stdio-capture.ts b/apps/cli/src/tui/stdio-capture.ts
new file mode 100644
index 0000000..41e7b81
--- /dev/null
+++ b/apps/cli/src/tui/stdio-capture.ts
@@ -0,0 +1,57 @@
+type WriteCallback = (error?: Error | null) => void;
+type WriteMethod = NodeJS.WriteStream["write"];
+
+function isWriteCallback(value: unknown): value is WriteCallback {
+	return typeof value === "function";
+}
+
+function getWriteCallback(
+	encodingOrCallback?: BufferEncoding | WriteCallback,
+	callback?: WriteCallback,
+): WriteCallback | undefined {
+	return isWriteCallback(encodingOrCallback) ? encodingOrCallback : callback;
+}
+
+function createCapturedWrite(): {
+	write: WriteMethod;
+	flush: () => void;
+} {
+	const write = ((
+		_chunk: string | Uint8Array,
+		encodingOrCallback?: BufferEncoding | WriteCallback,
+		callback?: WriteCallback,
+	) => {
+		const resolvedCallback = getWriteCallback(encodingOrCallback, callback);
+		if (resolvedCallback) {
+			process.nextTick(resolvedCallback);
+		}
+		return true;
+	}) as WriteMethod;
+
+	return {
+		write,
+		flush: () => {},
+	};
+}
+
+export function installTuiStdioCapture(): () => void {
+	const originalStdoutWrite = process.stdout.write;
+	const originalStderrWrite = process.stderr.write;
+	const stdout = createCapturedWrite();
+	const stderr = createCapturedWrite();
+	let restored = false;
+
+	process.stdout.write = stdout.write;
+	process.stderr.write = stderr.write;
+
+	return () => {
+		if (restored) {
+			return;
+		}
+		restored = true;
+		stdout.flush();
+		stderr.flush();
+		process.stdout.write = originalStdoutWrite;
+		process.stderr.write = originalStderrWrite;
+	};
+}
diff --git a/apps/cli/src/tui/types.ts b/apps/cli/src/tui/types.ts
new file mode 100644
index 0000000..a816402
--- /dev/null
+++ b/apps/cli/src/tui/types.ts
@@ -0,0 +1,215 @@
+import type {
+	AgentEvent,
+	AgentMode,
+	CheckpointEntry,
+	ClineSubscriptionPlan,
+	TeamEvent,
+} from "@cline/core";
+import type {
+	Message,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@cline/shared";
+import type { CliMigrationNotice } from "../kanban-migration/notice";
+import type {
+	PendingPromptSnapshot,
+	PendingPromptSubmittedEvent,
+} from "../runtime/session-events";
+import type { RepoStatus } from "../utils/repo-status";
+import type { CliCompactionMode, Config } from "../utils/types";
+import type { ClineAccountSnapshot } from "./cline-account";
+import type {
+	InteractiveConfigData,
+	InteractiveConfigItem,
+	LoadInteractiveConfigDataOptions,
+} from "./interactive-config";
+import type { InteractiveSlashCommand } from "./interactive-welcome";
+
+export type ChatEntry = (
+	| { kind: "user"; text: string }
+	| { kind: "assistant_text"; text: string; streaming: boolean }
+	| { kind: "reasoning"; text: string; streaming: boolean }
+	| {
+			kind: "tool_call";
+			toolCallId?: string;
+			toolName: string;
+			inputSummary: string;
+			rawInput?: unknown;
+			streaming: boolean;
+			result?: {
+				outputSummary: string;
+				rawOutput?: unknown;
+				error?: string;
+			};
+	  }
+	| { kind: "error"; text: string }
+	| { kind: "status"; text: string }
+	| { kind: "team"; text: string }
+	| { kind: "user_submitted"; text: string; delivery?: "queue" | "steer" }
+	| {
+			kind: "done";
+			tokens: number;
+			cost: number;
+			elapsed: string;
+			iterations: number;
+	  }
+) & {
+	/**
+	 * Agent mode active when the entry was produced. Stamped by appendEntry
+	 * (live sessions) and hydrateSessionMessages (resumed sessions) so the
+	 * transcript renders each entry with the accent of its own mode instead
+	 * of retinting everything to the current mode. Absent on entries from
+	 * transcripts that predate mode stamping.
+	 */
+	mode?: AgentMode;
+};
+
+export interface InteractiveTurnResult {
+	usage: {
+		inputTokens: number;
+		outputTokens: number;
+		totalCost?: number;
+	};
+	/**
+	 * Tokens occupying the model's context window after this turn: the
+	 * normalized input tokens of the latest assistant LLM call.
+	 */
+	currentContextSize?: number;
+	iterations: number;
+	finishReason?: string;
+	commandOutput?: string;
+	queued?: boolean;
+}
+
+export interface ResumedSessionResult {
+	messages: Message[];
+	totalCost?: number;
+	currentContextSize?: number;
+}
+
+export interface InteractiveCompactionResult {
+	messagesBefore: number;
+	messagesAfter: number;
+	workingContextMessagesAfter?: number;
+	compacted: boolean;
+}
+
+export interface UserInputAttachments {
+	userImages?: string[];
+}
+
+export interface QueuedPromptItem {
+	id: string;
+	prompt: string;
+	steer: boolean;
+	attachmentCount: number;
+}
+
+export interface PendingPromptMutationResult {
+	sessionId: string;
+	prompts: QueuedPromptItem[];
+	prompt?: QueuedPromptItem;
+	updated?: boolean;
+	removed?: boolean;
+}
+
+export type AppView = "onboarding" | "home" | "chat";
+
+export type RuntimeToolInteraction =
+	| {
+			id: number;
+			kind: "tool_approval";
+			request: ToolApprovalRequest;
+	  }
+	| {
+			id: number;
+			kind: "ask_question";
+			question: string;
+			options: string[];
+	  };
+
+export interface TuiProps {
+	config: Config;
+	initialView?: "chat" | "config";
+	initialPrompt?: string;
+	initialNotice?: CliMigrationNotice;
+	onInitialNoticeShown?: (notice: CliMigrationNotice) => void | Promise<void>;
+	initialMessages?: Message[];
+	loadDeferredInitialMessages?: () => Promise<ResumedSessionResult>;
+	initialRepoStatus?: RepoStatus;
+	workflowSlashCommands?: InteractiveSlashCommand[];
+	loadAdditionalSlashCommands?: () => Promise<InteractiveSlashCommand[]>;
+	loadWelcomeLine?: () => Promise<string | undefined>;
+	loadClineAccount: () => Promise<ClineAccountSnapshot>;
+	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
+	switchClineAccount: (organizationId?: string | null) => Promise<void>;
+	loadConfigData: (
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData>;
+	onToggleConfigItem?: (
+		item: InteractiveConfigItem,
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData | undefined>;
+	onDeleteConfigItem?: (
+		item: InteractiveConfigItem,
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData | undefined>;
+	subscribeToEvents: (handlers: {
+		onAgentEvent: (event: AgentEvent) => void;
+		onTeamEvent: (event: TeamEvent) => void;
+		onPendingPrompts: (event: PendingPromptSnapshot) => void;
+		onPendingPromptSubmitted: (event: PendingPromptSubmittedEvent) => void;
+	}) => () => void;
+	onSubmit: (
+		input: string,
+		mode: AgentMode,
+		delivery?: "queue" | "steer",
+		attachments?: UserInputAttachments,
+		onCommandOutput?: (text: string) => void,
+	) => Promise<InteractiveTurnResult>;
+	onUpdatePendingPrompt: (input: {
+		promptId: string;
+		prompt?: string;
+		delivery?: "queue" | "steer";
+	}) => Promise<PendingPromptMutationResult>;
+	onAbort: () => boolean;
+	onExit: () => void;
+	onRunningChange: (isRunning: boolean) => void;
+	onTurnErrorReported: (reported: boolean) => void;
+	onAutoApproveChange: (enabled: boolean) => void;
+	onCompactionModeChange: (mode: CliCompactionMode) => Promise<void>;
+	onModelChange: () => Promise<void>;
+	onModeChange: (mode: AgentMode) => Promise<void>;
+	onNewSession: () => Promise<void>;
+	onSessionRestart: () => Promise<void>;
+	onAccountChange: () => Promise<void>;
+	onResumeSession: (sessionId: string) => Promise<ResumedSessionResult>;
+	onCompact: () => Promise<InteractiveCompactionResult>;
+	onFork: () => Promise<
+		{ forkedFromSessionId: string; newSessionId: string } | undefined
+	>;
+	getCheckpointData: () => Promise<
+		{ messages: Message[]; checkpointHistory: CheckpointEntry[] } | undefined
+	>;
+	onRestoreCheckpoint: (
+		runCount: number,
+		restoreWorkspace: boolean,
+	) => Promise<{ newSessionId: string; messages: Message[] } | undefined>;
+	setToolApprover: (
+		approver:
+			| ((request: ToolApprovalRequest) => Promise<ToolApprovalResult>)
+			| null,
+	) => void;
+	setAskQuestion: (
+		handler: ((question: string, options: string[]) => Promise<string>) | null,
+	) => void;
+	setModeChangeNotifier: (handler: ((mode: AgentMode) => void) | null) => void;
+}
+
+export type InlineStream = "text" | "reasoning" | undefined;
+
+export const HOME_VIEW_MAX_WIDTH = 68;
+export const MAX_BUFFERED_LINES = 500;
+export const DEFAULT_MAX_INPUT_TOKENS = 200000;
+export const COMPLETION_DEBOUNCE_MS = 120;
+export const MAX_COMPLETION_RESULTS = 200;
diff --git a/apps/cli/src/tui/utils/clipboard.test.ts b/apps/cli/src/tui/utils/clipboard.test.ts
new file mode 100644
index 0000000..34bd7e7
--- /dev/null
+++ b/apps/cli/src/tui/utils/clipboard.test.ts
@@ -0,0 +1,367 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const spawnMock = vi.hoisted(() => vi.fn());
+
+vi.mock("node:child_process", () => ({
+	spawn: spawnMock,
+}));
+
+interface ChildProcessMockOptions {
+	closeCode?: number;
+	error?: Error;
+	hangUntilKilled?: boolean;
+	hangUntilAborted?: boolean;
+}
+
+function createChildProcessMock(options: ChildProcessMockOptions = {}) {
+	const child = new EventEmitter() as EventEmitter & {
+		stdin: PassThrough;
+		kill: ReturnType<typeof vi.fn>;
+	};
+	child.stdin = new PassThrough();
+	const chunks: Buffer[] = [];
+	child.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+	child.kill = vi.fn(() => {
+		queueMicrotask(() => child.emit("close", 1));
+	});
+	child.stdin.on("finish", () => {
+		queueMicrotask(() => {
+			if (options.error) {
+				child.emit("error", options.error);
+				return;
+			}
+			if (options.hangUntilKilled || options.hangUntilAborted) {
+				return;
+			}
+			child.emit("close", options.closeCode ?? 0);
+		});
+	});
+	return {
+		child,
+		getInput: () => Buffer.concat(chunks).toString("utf8"),
+	};
+}
+
+const ENV_WITHOUT_SSH: NodeJS.ProcessEnv = {};
+
+describe("copyTextToSystemClipboard", () => {
+	beforeEach(() => {
+		spawnMock.mockReset();
+	});
+
+	it("returns false for empty text and does not spawn", async () => {
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("", {
+				platform: "darwin",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(false);
+		expect(spawnMock).not.toHaveBeenCalled();
+	});
+
+	it("copies with pbcopy on macOS, forces UTF-8, and removes LC_ALL", async () => {
+		const proc = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(proc.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("hello\nworld 👋", {
+				platform: "darwin",
+				env: { ...ENV_WITHOUT_SSH, LC_ALL: "C", LANG: "C", LC_CTYPE: "C" },
+			}),
+		).resolves.toBe(true);
+
+		expect(spawnMock).toHaveBeenCalledTimes(1);
+		const [command, args, spawnOptions] = spawnMock.mock.calls[0] as [
+			string,
+			string[],
+			{ stdio: unknown; env?: NodeJS.ProcessEnv },
+		];
+		expect(command).toBe("pbcopy");
+		expect(args).toEqual([]);
+		expect(spawnOptions.stdio).toEqual(["pipe", "ignore", "ignore"]);
+		expect(spawnOptions.env?.LANG).toBe("en_US.UTF-8");
+		expect(spawnOptions.env?.LC_CTYPE).toBe("en_US.UTF-8");
+		expect(spawnOptions.env?.LC_ALL).toBeUndefined();
+		expect(proc.getInput()).toBe("hello\nworld 👋");
+	});
+
+	it("falls back from wl-copy to xclip on Linux and writes input to both", async () => {
+		const failed = createChildProcessMock({ closeCode: 1 });
+		const succeeded = createChildProcessMock();
+		spawnMock
+			.mockReturnValueOnce(failed.child)
+			.mockReturnValueOnce(succeeded.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("selected text", {
+				platform: "linux",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+
+		expect(spawnMock).toHaveBeenNthCalledWith(1, "wl-copy", [], {
+			stdio: ["pipe", "ignore", "ignore"],
+			windowsHide: true,
+		});
+		expect(spawnMock).toHaveBeenNthCalledWith(
+			2,
+			"xclip",
+			["-selection", "clipboard"],
+			{ stdio: ["pipe", "ignore", "ignore"], windowsHide: true },
+		);
+		expect(failed.getInput()).toBe("selected text");
+		expect(succeeded.getInput()).toBe("selected text");
+	});
+
+	it("uses non-WSL Linux path when osRelease lacks any Microsoft marker", async () => {
+		const wlcopy = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(wlcopy.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("plain linux", {
+				platform: "linux",
+				osRelease: "6.6.30-arch1-1",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+
+		expect(spawnMock).toHaveBeenCalledTimes(1);
+		expect(spawnMock).toHaveBeenCalledWith("wl-copy", [], {
+			stdio: ["pipe", "ignore", "ignore"],
+			windowsHide: true,
+		});
+		expect(wlcopy.getInput()).toBe("plain linux");
+	});
+
+	it("uses powershell.exe on Windows with UTF-8 stdin and Set-Clipboard", async () => {
+		const win = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(win.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		const unicode = "hello 👋 日本語 é";
+		await expect(
+			copyTextToSystemClipboard(unicode, {
+				platform: "win32",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+
+		expect(spawnMock).toHaveBeenCalledTimes(1);
+		const [command, args] = spawnMock.mock.calls[0] as [string, string[]];
+		expect(command).toBe("powershell.exe");
+		expect(args.slice(0, 5)).toEqual([
+			"-NoProfile",
+			"-NonInteractive",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+		]);
+		expect(args[5]).toContain("Set-Clipboard");
+		expect(args[5]).toContain("UTF8Encoding");
+		expect(win.getInput()).toBe(unicode);
+	});
+
+	it("falls back from powershell.exe to pwsh.exe when the former fails", async () => {
+		const failed = createChildProcessMock({ error: new Error("ENOENT") });
+		const ok = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(failed.child).mockReturnValueOnce(ok.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("hi", {
+				platform: "win32",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+
+		expect(spawnMock).toHaveBeenNthCalledWith(
+			1,
+			"powershell.exe",
+			expect.any(Array),
+			expect.objectContaining({ stdio: ["pipe", "ignore", "ignore"] }),
+		);
+		expect(spawnMock).toHaveBeenNthCalledWith(
+			2,
+			"pwsh.exe",
+			expect.any(Array),
+			expect.objectContaining({ stdio: ["pipe", "ignore", "ignore"] }),
+		);
+		expect(ok.getInput()).toBe("hi");
+	});
+
+	it("uses powershell.exe on WSL2 and preserves Unicode", async () => {
+		const wsl = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(wsl.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		const unicode = "hello 👋 日本語 é";
+		await expect(
+			copyTextToSystemClipboard(unicode, {
+				platform: "linux",
+				osRelease: "5.15.0-microsoft-standard-WSL2",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+
+		const [command] = spawnMock.mock.calls[0] as [string];
+		expect(command).toBe("powershell.exe");
+		expect(wsl.getInput()).toBe(unicode);
+	});
+
+	it("uses powershell.exe on WSL1 (mixed-case Microsoft kernel string)", async () => {
+		const proc = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(proc.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("wsl1", {
+				platform: "linux",
+				osRelease: "4.4.0-19041-Microsoft",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+
+		const [command] = spawnMock.mock.calls[0] as [string];
+		expect(command).toBe("powershell.exe");
+		expect(proc.getInput()).toBe("wsl1");
+	});
+
+	it("skips fallback inside an SSH session", async () => {
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("over ssh", {
+				platform: "darwin",
+				env: { SSH_CONNECTION: "1.2.3.4 1234 5.6.7.8 22" },
+			}),
+		).resolves.toBe(false);
+		expect(spawnMock).not.toHaveBeenCalled();
+	});
+
+	it("re-enables SSH fallback when CLINE_CLIPBOARD_FALLBACK_REMOTE=1", async () => {
+		const proc = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(proc.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("over ssh", {
+				platform: "darwin",
+				env: {
+					SSH_TTY: "/dev/pts/0",
+					CLINE_CLIPBOARD_FALLBACK_REMOTE: "1",
+				},
+			}),
+		).resolves.toBe(true);
+		expect(spawnMock).toHaveBeenCalledTimes(1);
+		expect(proc.getInput()).toBe("over ssh");
+	});
+
+	it("treats spawn 'error' as failure and tries the next command", async () => {
+		const broken = createChildProcessMock({ error: new Error("ENOENT") });
+		const ok = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(broken.child).mockReturnValueOnce(ok.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("retry", {
+				platform: "linux",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+		expect(spawnMock).toHaveBeenCalledTimes(2);
+		expect(ok.getInput()).toBe("retry");
+	});
+
+	it("times out, kills the child, and falls back to the next command", async () => {
+		const stuck = createChildProcessMock({ hangUntilKilled: true });
+		const ok = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(stuck.child).mockReturnValueOnce(ok.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("slow", {
+				platform: "linux",
+				env: ENV_WITHOUT_SSH,
+				timeoutMs: 5,
+			}),
+		).resolves.toBe(true);
+		expect(stuck.child.kill).toHaveBeenCalled();
+		expect(ok.getInput()).toBe("slow");
+	});
+
+	it("aborts an in-flight copy via AbortSignal and resolves false", async () => {
+		const stuck = createChildProcessMock({ hangUntilAborted: true });
+		spawnMock.mockReturnValueOnce(stuck.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+		const controller = new AbortController();
+
+		const pending = copyTextToSystemClipboard("racing", {
+			platform: "darwin",
+			env: ENV_WITHOUT_SSH,
+			signal: controller.signal,
+			timeoutMs: 10_000,
+		});
+		await Promise.resolve();
+		controller.abort();
+
+		await expect(pending).resolves.toBe(false);
+		expect(stuck.child.kill).toHaveBeenCalled();
+	});
+
+	it("returns false when called with an already-aborted signal", async () => {
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+		const controller = new AbortController();
+		controller.abort();
+
+		await expect(
+			copyTextToSystemClipboard("nope", {
+				platform: "darwin",
+				env: ENV_WITHOUT_SSH,
+				signal: controller.signal,
+			}),
+		).resolves.toBe(false);
+		expect(spawnMock).not.toHaveBeenCalled();
+	});
+
+	it("returns false when the only command fails", async () => {
+		spawnMock.mockReturnValueOnce(
+			createChildProcessMock({ closeCode: 1 }).child,
+		);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("nope", {
+				platform: "darwin",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(false);
+	});
+
+	it("falls back to next command when child.stdin is null", async () => {
+		const noStdin = new EventEmitter() as EventEmitter & {
+			stdin: null;
+			kill: ReturnType<typeof vi.fn>;
+		};
+		noStdin.stdin = null;
+		noStdin.kill = vi.fn();
+		const ok = createChildProcessMock();
+		spawnMock.mockReturnValueOnce(noStdin).mockReturnValueOnce(ok.child);
+		const { copyTextToSystemClipboard } = await import("./clipboard");
+
+		await expect(
+			copyTextToSystemClipboard("recover", {
+				platform: "linux",
+				env: ENV_WITHOUT_SSH,
+			}),
+		).resolves.toBe(true);
+		expect(spawnMock).toHaveBeenCalledTimes(2);
+		expect(ok.getInput()).toBe("recover");
+	});
+});
diff --git a/apps/cli/src/tui/utils/clipboard.ts b/apps/cli/src/tui/utils/clipboard.ts
new file mode 100644
index 0000000..df631dd
--- /dev/null
+++ b/apps/cli/src/tui/utils/clipboard.ts
@@ -0,0 +1,212 @@
+import { spawn } from "node:child_process";
+import { release } from "node:os";
+
+const CLIPBOARD_COMMAND_TIMEOUT_MS = 1500;
+
+// Skipping the fallback inside SSH sessions is the safe default: OSC52 is the
+// mechanism that targets the user's local terminal clipboard, while the
+// fallback would write to the remote host instead. Setting
+// CLINE_CLIPBOARD_FALLBACK_REMOTE=1 opts back in for users who explicitly
+// want the remote machine's clipboard.
+const CLIPBOARD_FALLBACK_REMOTE_ENV = "CLINE_CLIPBOARD_FALLBACK_REMOTE";
+
+// Setting CLINE_DEBUG_CLIPBOARD=1 logs why the fallback skipped or which
+// command failed; off by default so the TUI canvas stays clean.
+const CLIPBOARD_DEBUG_ENV = "CLINE_DEBUG_CLIPBOARD";
+
+function debugLog(env: NodeJS.ProcessEnv, message: string): void {
+	if (env[CLIPBOARD_DEBUG_ENV]?.trim() === "1") {
+		console.debug(`[clipboard] ${message}`);
+	}
+}
+
+interface ClipboardCommand {
+	command: string;
+	args: string[];
+	env?: NodeJS.ProcessEnv;
+	stdinEncoding?: BufferEncoding;
+}
+
+interface CopyTextOptions {
+	platform?: NodeJS.Platform;
+	osRelease?: string;
+	timeoutMs?: number;
+	env?: NodeJS.ProcessEnv;
+	signal?: AbortSignal;
+}
+
+function isWslRelease(osRelease: string): boolean {
+	return /microsoft/i.test(osRelease);
+}
+
+function isRemoteSession(env: NodeJS.ProcessEnv): boolean {
+	const remote =
+		env.SSH_CONNECTION?.trim() || env.SSH_CLIENT?.trim() || env.SSH_TTY?.trim();
+	if (!remote) {
+		return false;
+	}
+	return env[CLIPBOARD_FALLBACK_REMOTE_ENV]?.trim() !== "1";
+}
+
+function macosClipboardEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	const next: NodeJS.ProcessEnv = {
+		...env,
+		LANG: "en_US.UTF-8",
+		LC_CTYPE: "en_US.UTF-8",
+	};
+	delete next.LC_ALL;
+	return next;
+}
+
+const POWERSHELL_SET_CLIPBOARD_SCRIPT = [
+	"$ErrorActionPreference = 'Stop';",
+	"[Console]::InputEncoding = New-Object System.Text.UTF8Encoding $false;",
+	"$text = [Console]::In.ReadToEnd();",
+	"Set-Clipboard -Value $text;",
+].join(" ");
+
+function powershellClipboardCommand(executable: string): ClipboardCommand {
+	return {
+		command: executable,
+		args: [
+			"-NoProfile",
+			"-NonInteractive",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+			POWERSHELL_SET_CLIPBOARD_SCRIPT,
+		],
+		stdinEncoding: "utf8",
+	};
+}
+
+function powershellClipboardCommands(): ClipboardCommand[] {
+	return [
+		powershellClipboardCommand("powershell.exe"),
+		powershellClipboardCommand("pwsh.exe"),
+	];
+}
+
+function getClipboardCommands(
+	options: CopyTextOptions = {},
+): ClipboardCommand[] {
+	const platform = options.platform ?? process.platform;
+	const osRelease = options.osRelease ?? release();
+	const env = options.env ?? process.env;
+
+	if (platform === "darwin") {
+		return [
+			{
+				command: "pbcopy",
+				args: [],
+				env: macosClipboardEnv(env),
+				stdinEncoding: "utf8",
+			},
+		];
+	}
+
+	if (platform === "win32") {
+		return powershellClipboardCommands();
+	}
+
+	if (platform === "linux" && isWslRelease(osRelease)) {
+		return powershellClipboardCommands();
+	}
+
+	if (platform === "linux") {
+		return [
+			{ command: "wl-copy", args: [], stdinEncoding: "utf8" },
+			{
+				command: "xclip",
+				args: ["-selection", "clipboard"],
+				stdinEncoding: "utf8",
+			},
+		];
+	}
+
+	return [];
+}
+
+function runClipboardCommand(
+	command: ClipboardCommand,
+	text: string,
+	timeoutMs: number,
+	signal: AbortSignal | undefined,
+): Promise<boolean> {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve(false);
+			return;
+		}
+
+		const child = spawn(command.command, command.args, {
+			stdio: ["pipe", "ignore", "ignore"],
+			...(command.env ? { env: command.env } : {}),
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		});
+		let settled = false;
+
+		const onAbort = () => {
+			child.kill();
+			finish(false);
+		};
+
+		const finish = (success: boolean) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			resolve(success);
+		};
+
+		const timer = setTimeout(() => {
+			child.kill();
+			finish(false);
+		}, timeoutMs);
+
+		signal?.addEventListener("abort", onAbort, { once: true });
+
+		child.on("error", () => finish(false));
+		child.on("close", (code) => finish(code === 0));
+
+		const stdin = child.stdin;
+		if (!stdin) {
+			finish(false);
+			return;
+		}
+		stdin.on("error", () => finish(false));
+		stdin.end(text, command.stdinEncoding ?? "utf8");
+	});
+}
+
+export async function copyTextToSystemClipboard(
+	text: string,
+	options: CopyTextOptions = {},
+): Promise<boolean> {
+	if (!text) {
+		return false;
+	}
+
+	const env = options.env ?? process.env;
+	if (isRemoteSession(env)) {
+		debugLog(
+			env,
+			`skipped fallback inside SSH session; set ${CLIPBOARD_FALLBACK_REMOTE_ENV}=1 to opt in`,
+		);
+		return false;
+	}
+
+	const timeoutMs = options.timeoutMs ?? CLIPBOARD_COMMAND_TIMEOUT_MS;
+	for (const command of getClipboardCommands(options)) {
+		if (options.signal?.aborted) {
+			return false;
+		}
+		if (await runClipboardCommand(command, text, timeoutMs, options.signal)) {
+			return true;
+		}
+		debugLog(env, `command "${command.command}" did not succeed; trying next`);
+	}
+
+	return false;
+}
diff --git a/apps/cli/src/tui/utils/compaction-status.ts b/apps/cli/src/tui/utils/compaction-status.ts
new file mode 100644
index 0000000..5d9b10f
--- /dev/null
+++ b/apps/cli/src/tui/utils/compaction-status.ts
@@ -0,0 +1,23 @@
+import type { InteractiveCompactionResult } from "../types";
+
+function formatMessageCount(count: number): string {
+	return `${count} ${count === 1 ? "message" : "messages"}`;
+}
+
+export function formatCompactionStatus(
+	result: InteractiveCompactionResult,
+): string {
+	if (result.messagesBefore === 0) {
+		return "No messages to compact.";
+	}
+	if (!result.compacted) {
+		return "No compaction needed.";
+	}
+	if (typeof result.workingContextMessagesAfter === "number") {
+		return `Compacted working context to ${formatMessageCount(result.workingContextMessagesAfter)}; saved history remains ${formatMessageCount(result.messagesAfter)}.`;
+	}
+	if (result.messagesBefore === result.messagesAfter) {
+		return `Compacted context; message count stayed at ${formatMessageCount(result.messagesAfter)}.`;
+	}
+	return `Compacted ${formatMessageCount(result.messagesBefore)} to ${formatMessageCount(result.messagesAfter)}.`;
+}
diff --git a/apps/cli/src/tui/utils/diff.ts b/apps/cli/src/tui/utils/diff.ts
new file mode 100644
index 0000000..b30f704
--- /dev/null
+++ b/apps/cli/src/tui/utils/diff.ts
@@ -0,0 +1,114 @@
+function computeLcs(a: string[], b: string[]): number[][] {
+	const m = a.length;
+	const n = b.length;
+	const dp: number[][] = Array.from({ length: m + 1 }, () =>
+		new Array(n + 1).fill(0),
+	);
+	for (let i = 1; i <= m; i++) {
+		for (let j = 1; j <= n; j++) {
+			dp[i][j] =
+				a[i - 1] === b[j - 1]
+					? dp[i - 1][j - 1] + 1
+					: Math.max(dp[i - 1][j], dp[i][j - 1]);
+		}
+	}
+	return dp;
+}
+
+function diffLines(
+	oldLines: string[],
+	newLines: string[],
+): { type: "+" | "-" | " "; line: string }[] {
+	const dp = computeLcs(oldLines, newLines);
+	const result: { type: "+" | "-" | " "; line: string }[] = [];
+	let i = oldLines.length;
+	let j = newLines.length;
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+			result.unshift({ type: " ", line: oldLines[i - 1] });
+			i--;
+			j--;
+		} else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+			result.unshift({ type: "+", line: newLines[j - 1] });
+			j--;
+		} else {
+			result.unshift({ type: "-", line: oldLines[i - 1] });
+			i--;
+		}
+	}
+	return result;
+}
+
+export function makeUnifiedDiff(
+	oldText: string,
+	newText: string,
+	filePath: string,
+	ctx = 3,
+): string {
+	const oldArr = oldText ? oldText.split("\n") : [];
+	const newArr = newText.split("\n");
+	const ops = diffLines(oldArr, newArr);
+
+	const output: string[] = [];
+	output.push(`--- a/${filePath}`);
+	output.push(`+++ b/${filePath}`);
+
+	let i = 0;
+	while (i < ops.length) {
+		if (ops[i].type === " ") {
+			i++;
+			continue;
+		}
+
+		const hunkStart = Math.max(0, i - ctx);
+		let end = i;
+		while (end < ops.length) {
+			if (ops[end].type !== " ") {
+				end++;
+				continue;
+			}
+			let next = end;
+			while (next < ops.length && ops[next].type === " ") next++;
+			if (next < ops.length && next - end <= ctx * 2) {
+				end = next + 1;
+			} else {
+				break;
+			}
+		}
+		const hunkEnd = Math.min(ops.length, end + ctx);
+
+		let oldCount = 0;
+		let newCount = 0;
+		for (let k = hunkStart; k < hunkEnd; k++) {
+			if (ops[k].type !== "+") oldCount++;
+			if (ops[k].type !== "-") newCount++;
+		}
+
+		let oldStart = 1;
+		let newStart = 1;
+		for (let k = 0; k < hunkStart; k++) {
+			if (ops[k].type !== "+") oldStart++;
+			if (ops[k].type !== "-") newStart++;
+		}
+
+		output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+		for (let k = hunkStart; k < hunkEnd; k++) {
+			const prefix = ops[k].type === " " ? " " : ops[k].type;
+			output.push(`${prefix}${ops[k].line}`);
+		}
+
+		i = hunkEnd;
+	}
+
+	return output.join("\n");
+}
+
+export function hunkHeader(lines: string[]): string {
+	let oldCount = 0;
+	let newCount = 0;
+	for (const l of lines) {
+		if (!l.startsWith("+")) oldCount++;
+		if (!l.startsWith("-")) newCount++;
+	}
+	return `@@ -1,${oldCount} +1,${newCount} @@`;
+}
diff --git a/apps/cli/src/tui/utils/hydrate-messages.test.ts b/apps/cli/src/tui/utils/hydrate-messages.test.ts
new file mode 100644
index 0000000..1bf2e26
--- /dev/null
+++ b/apps/cli/src/tui/utils/hydrate-messages.test.ts
@@ -0,0 +1,154 @@
+import type { Message } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { ACT_MODE_CONTINUATION_PROMPT } from "../../runtime/interactive/mode";
+import { hydrateSessionMessages } from "./hydrate-messages";
+
+describe("hydrateSessionMessages", () => {
+	it("renders regular user messages", () => {
+		const messages = [
+			{
+				role: "user",
+				content: '<user_input mode="plan">lets do it</user_input>',
+			},
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{ kind: "user_submitted", text: "lets do it", mode: "plan" },
+		]);
+	});
+
+	it("hides the synthetic act-mode continuation prompt", () => {
+		const messages = [
+			{
+				role: "user",
+				content: `<user_input mode="act">${ACT_MODE_CONTINUATION_PROMPT}</user_input>`,
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "text",
+						text: `<user_input mode="act">${ACT_MODE_CONTINUATION_PROMPT}</user_input>`,
+					},
+				],
+			},
+			{
+				role: "assistant",
+				content: "On it.",
+			},
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{ kind: "assistant_text", text: "On it.", streaming: false, mode: "act" },
+		]);
+	});
+
+	it("stamps entries with the mode of the user message that produced them", () => {
+		const messages = [
+			{
+				role: "user",
+				content: '<user_input mode="plan">plan this out</user_input>',
+			},
+			{ role: "assistant", content: "Here is the plan." },
+			{
+				role: "user",
+				content: '<user_input mode="act">do it</user_input>',
+			},
+			{ role: "assistant", content: "Doing it." },
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{ kind: "user_submitted", text: "plan this out", mode: "plan" },
+			{
+				kind: "assistant_text",
+				text: "Here is the plan.",
+				streaming: false,
+				mode: "plan",
+			},
+			{ kind: "user_submitted", text: "do it", mode: "act" },
+			{
+				kind: "assistant_text",
+				text: "Doing it.",
+				streaming: false,
+				mode: "act",
+			},
+		]);
+	});
+
+	it("switches to act mode after a switch_to_act_mode tool call", () => {
+		const messages = [
+			{
+				role: "user",
+				content: '<user_input mode="plan">plan then build</user_input>',
+			},
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "Plan looks good, switching." },
+					{
+						type: "tool_use",
+						id: "tool-1",
+						name: "switch_to_act_mode",
+						input: {},
+					},
+					{ type: "text", text: "Building now." },
+				],
+			},
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{ kind: "user_submitted", text: "plan then build", mode: "plan" },
+			{
+				kind: "assistant_text",
+				text: "Plan looks good, switching.",
+				streaming: false,
+				mode: "plan",
+			},
+			{
+				kind: "tool_call",
+				toolName: "switch_to_act_mode",
+				inputSummary: expect.any(String),
+				rawInput: {},
+				streaming: false,
+				mode: "plan",
+			},
+			{
+				kind: "assistant_text",
+				text: "Building now.",
+				streaming: false,
+				mode: "act",
+			},
+		]);
+	});
+
+	it("strips mode switch notices from displayed user text", () => {
+		const messages = [
+			{
+				role: "user",
+				content:
+					'<user_input mode="plan"><mode_notice>The user switched from act mode to plan mode before sending this message.</mode_notice>\nare you okay?</user_input>',
+			},
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{ kind: "user_submitted", text: "are you okay?", mode: "plan" },
+		]);
+	});
+
+	it("leaves mode undefined for transcripts without user_input wrappers", () => {
+		const messages = [
+			{ role: "user", content: "plain old message" },
+			{ role: "assistant", content: "reply" },
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{ kind: "user_submitted", text: "plain old message", mode: undefined },
+			{
+				kind: "assistant_text",
+				text: "reply",
+				streaming: false,
+				mode: undefined,
+			},
+		]);
+	});
+});
diff --git a/apps/cli/src/tui/utils/hydrate-messages.ts b/apps/cli/src/tui/utils/hydrate-messages.ts
new file mode 100644
index 0000000..ab9cdcc
--- /dev/null
+++ b/apps/cli/src/tui/utils/hydrate-messages.ts
@@ -0,0 +1,156 @@
+import type { AgentMode } from "@cline/core";
+import {
+	formatDisplayUserInput,
+	type Message,
+	parseUserInputMode,
+} from "@cline/shared";
+import { ACT_MODE_CONTINUATION_PROMPT } from "../../runtime/interactive/mode";
+import { formatToolInput } from "../../utils/helpers";
+import type { ChatEntry } from "../types";
+
+type PersistedMessage = Message & {
+	metadata?: Record<string, unknown>;
+};
+
+function getDisplayRole(msg: PersistedMessage): string | undefined {
+	const role = msg.metadata?.displayRole;
+	return typeof role === "string" ? role.trim().toLowerCase() : undefined;
+}
+
+// The act-mode continuation prompt is runtime-generated, not typed by the
+// user, so it should not surface as a user bubble in the transcript.
+function isSyntheticUserText(text: string): boolean {
+	return text === ACT_MODE_CONTINUATION_PROMPT;
+}
+
+function stringifyToolResult(
+	content: string | Array<{ type: string; text?: string; path?: string }>,
+): string {
+	if (typeof content === "string") return content;
+	return content
+		.map((block) => {
+			if (block.type === "text" && typeof block.text === "string")
+				return block.text;
+			if (block.type === "file" && typeof block.path === "string")
+				return `Attached file: ${block.path}`;
+			return "";
+		})
+		.filter(Boolean)
+		.join("\n");
+}
+
+export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
+	const entries: ChatEntry[] = [];
+	const toolUseMap = new Map<string, number>();
+	// Mode each entry was produced in, recovered from <user_input mode="...">
+	// wrappers and switch_to_act_mode tool calls as we walk the transcript.
+	// Stays undefined for transcripts with no mode markers (pre-wrapper
+	// builds, or transcripts laundered by older builds that stripped the
+	// wrappers on session restarts).
+	let mode: AgentMode | undefined;
+
+	for (const msg of messages as PersistedMessage[]) {
+		const displayRole = getDisplayRole(msg);
+		if (displayRole === "system" || displayRole === "status") {
+			continue;
+		}
+
+		if (typeof msg.content === "string") {
+			if (msg.role === "user") {
+				mode = parseUserInputMode(msg.content) ?? mode;
+				const text = formatDisplayUserInput(msg.content);
+				if (text && !isSyntheticUserText(text)) {
+					entries.push({ kind: "user_submitted", text, mode });
+				}
+			} else {
+				entries.push({
+					kind: "assistant_text",
+					text: msg.content,
+					streaming: false,
+					mode,
+				});
+			}
+			continue;
+		}
+
+		const userTextParts: string[] = [];
+
+		for (const block of msg.content) {
+			if (block.type === "text") {
+				if (msg.role === "user") {
+					userTextParts.push(block.text);
+				} else {
+					entries.push({
+						kind: "assistant_text",
+						text: block.text,
+						streaming: false,
+						mode,
+					});
+				}
+				continue;
+			}
+
+			if (block.type === "thinking") {
+				entries.push({
+					kind: "reasoning",
+					text: block.thinking,
+					streaming: false,
+					mode,
+				});
+				continue;
+			}
+
+			if (block.type === "redacted_thinking") {
+				continue;
+			}
+
+			if (block.type === "tool_use") {
+				entries.push({
+					kind: "tool_call",
+					toolName: block.name,
+					inputSummary: formatToolInput(block.name, block.input),
+					rawInput: block.input,
+					streaming: false,
+					mode,
+				});
+				toolUseMap.set(block.id, entries.length - 1);
+				// The switch tool flips the session to act mid-run; everything
+				// after it was produced in act mode.
+				if (block.name === "switch_to_act_mode") {
+					mode = "act";
+				}
+				continue;
+			}
+
+			if (block.type === "tool_result") {
+				const idx = toolUseMap.get(block.tool_use_id);
+				if (idx != null) {
+					const entry = entries[idx];
+					if (entry && entry.kind === "tool_call") {
+						const resultText = stringifyToolResult(
+							block.content as
+								| string
+								| Array<{ type: string; text?: string; path?: string }>,
+						);
+						entry.result = {
+							outputSummary: resultText.slice(0, 500),
+							rawOutput: block.content,
+							error: block.is_error ? resultText : undefined,
+						};
+					}
+				}
+			}
+		}
+
+		if (msg.role === "user" && userTextParts.length > 0) {
+			const combined = userTextParts.join("\n");
+			mode = parseUserInputMode(combined) ?? mode;
+			const text = formatDisplayUserInput(combined);
+			if (text && !isSyntheticUserText(text)) {
+				entries.push({ kind: "user_submitted", text, mode });
+			}
+		}
+	}
+
+	return entries;
+}
diff --git a/apps/cli/src/tui/utils/image-paste.test.ts b/apps/cli/src/tui/utils/image-paste.test.ts
new file mode 100644
index 0000000..256310d
--- /dev/null
+++ b/apps/cli/src/tui/utils/image-paste.test.ts
@@ -0,0 +1,83 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+	readImageDataUrlFromPastedText,
+	readImmediateImagePasteAttachment,
+	resolvePastedImagePath,
+} from "./image-paste";
+
+describe("image paste helpers", () => {
+	it("loads pasted image file paths as data urls", () => {
+		const dir = mkdtempSync(join(tmpdir(), "cli image paste "));
+		const imagePath = join(dir, "hero.png");
+		writeFileSync(imagePath, Buffer.from("hello"));
+
+		const result = readImageDataUrlFromPastedText(`"${imagePath}"`);
+
+		expect(result).toEqual({
+			dataUrl: "data:image/png;base64,aGVsbG8=",
+			source: "path",
+		});
+	});
+
+	it("resolves file url paste paths", () => {
+		const dir = mkdtempSync(join(tmpdir(), "cli-image-paste-"));
+		const imagePath = join(dir, "hero.png");
+
+		expect(resolvePastedImagePath(pathToFileURL(imagePath).href)).toBe(
+			imagePath,
+		);
+	});
+
+	it("decodes direct image paste bytes when metadata is available", () => {
+		const event = {
+			bytes: Buffer.from("hello"),
+			metadata: { mimeType: "image/png" },
+		};
+
+		expect(readImmediateImagePasteAttachment(event)).toEqual({
+			dataUrl: "data:image/png;base64,aGVsbG8=",
+			source: "paste",
+		});
+	});
+
+	it("loads macOS screenshot paths when narrow no-break space is normalized to a regular space", () => {
+		// macOS Sonoma+ embeds U+202F (NARROW NO-BREAK SPACE) before AM/PM
+		// in screenshot filenames. When the path travels through clipboards,
+		// terminals, or anything that normalizes whitespace, U+202F can be
+		// collapsed to a regular space (U+0020) -- but the on-disk filename
+		// still contains U+202F, so a literal readFileSync fails with ENOENT.
+		const dir = mkdtempSync(join(tmpdir(), "cli-image-paste-nnbsp-"));
+		const onDiskName = "Screenshot 2026-05-12 at 4.42.48\u202FPM.png";
+		const pastedName = "Screenshot 2026-05-12 at 4.42.48 PM.png";
+		const onDiskPath = join(dir, onDiskName);
+		writeFileSync(onDiskPath, Buffer.from("hello"));
+
+		const result = readImageDataUrlFromPastedText(join(dir, pastedName));
+
+		expect(result).toEqual({
+			dataUrl: "data:image/png;base64,aGVsbG8=",
+			source: "path",
+		});
+	});
+
+	it("loads paths when an arbitrary Unicode space differs from the on-disk filename", () => {
+		// Generalized variant: any exotic space (here U+00A0 NBSP) in the
+		// actual filename should still resolve when the pasted text uses a
+		// regular space.
+		const dir = mkdtempSync(join(tmpdir(), "cli-image-paste-nbsp-"));
+		const onDiskName = "weird\u00a0name.png";
+		const pastedName = "weird name.png";
+		writeFileSync(join(dir, onDiskName), Buffer.from("hello"));
+
+		const result = readImageDataUrlFromPastedText(join(dir, pastedName));
+
+		expect(result).toEqual({
+			dataUrl: "data:image/png;base64,aGVsbG8=",
+			source: "path",
+		});
+	});
+});
diff --git a/apps/cli/src/tui/utils/image-paste.ts b/apps/cli/src/tui/utils/image-paste.ts
new file mode 100644
index 0000000..607281b
--- /dev/null
+++ b/apps/cli/src/tui/utils/image-paste.ts
@@ -0,0 +1,285 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { release, tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	bufferToImageDataUrl,
+	isImagePath,
+	loadImageAsDataUrl,
+	resolveExistingImagePath,
+} from "../../utils/image-attachments";
+
+const COMMAND_TIMEOUT_MS = 1500;
+const MAX_CLIPBOARD_BYTES = 20 * 1024 * 1024;
+const PASTE_DECODER = new TextDecoder();
+const ESC = String.fromCharCode(27);
+const BEL = String.fromCharCode(7);
+const ANSI_SEQUENCE_PATTERN = new RegExp(
+	`${ESC}(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~]|\\][^${BEL}]*(?:${BEL}|${ESC}\\\\))`,
+	"g",
+);
+
+interface PasteLikeEvent {
+	bytes: Uint8Array;
+	metadata?: {
+		mimeType?: string;
+	};
+}
+
+export interface ImagePasteAttachment {
+	dataUrl: string;
+	source: "clipboard" | "path" | "paste";
+}
+
+function normalizePasteText(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function decodePasteBytes(bytes: Uint8Array): string {
+	return PASTE_DECODER.decode(bytes);
+}
+
+function stripAnsiSequences(text: string): string {
+	return text.replace(ANSI_SEQUENCE_PATTERN, "");
+}
+
+function stripWrappingQuotes(text: string): string {
+	return text.replace(/^['"]+|['"]+$/g, "");
+}
+
+function unescapeTerminalPath(text: string): string {
+	if (process.platform === "win32") {
+		return text;
+	}
+	return text.replace(/\\(.)/g, "$1");
+}
+
+export function resolvePastedImagePath(text: string): string | undefined {
+	const normalized = normalizePasteText(text).trim();
+	if (!normalized) {
+		return undefined;
+	}
+
+	const lines = normalized.split("\n").filter((line) => line.trim().length > 0);
+	if (lines.length !== 1) {
+		return undefined;
+	}
+
+	const raw = stripWrappingQuotes(lines[0]?.trim() ?? "");
+	if (!raw || /^(https?):\/\//i.test(raw)) {
+		return undefined;
+	}
+
+	if (raw.startsWith("file://")) {
+		try {
+			return fileURLToPath(raw);
+		} catch {
+			return undefined;
+		}
+	}
+
+	return unescapeTerminalPath(raw);
+}
+
+export function readImageDataUrlFromPastedText(
+	text: string,
+): ImagePasteAttachment | undefined {
+	const filePath = resolvePastedImagePath(text);
+	if (!filePath || !isImagePath(filePath)) {
+		return undefined;
+	}
+
+	// Resolve macOS-style filename variants (narrow no-break space before
+	// AM/PM, NFD normalization, curly apostrophe, etc.) before reading.
+	// See resolveExistingImagePath for the full ladder.
+	const resolvedPath = resolveExistingImagePath(filePath);
+	if (!resolvedPath) {
+		return undefined;
+	}
+
+	try {
+		return {
+			dataUrl: loadImageAsDataUrl(resolvedPath),
+			source: "path",
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+async function runCommand(
+	command: string,
+	args: string[],
+): Promise<Buffer | undefined> {
+	return await new Promise((resolve) => {
+		const child = spawn(command, args, {
+			stdio: ["ignore", "pipe", "ignore"],
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		});
+		const chunks: Buffer[] = [];
+		let total = 0;
+		let settled = false;
+
+		const finish = (buffer: Buffer | undefined) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(buffer);
+		};
+
+		const timer = setTimeout(() => {
+			child.kill();
+			finish(undefined);
+		}, COMMAND_TIMEOUT_MS);
+
+		child.on("error", () => finish(undefined));
+		child.stdout.on("data", (chunk: Buffer) => {
+			total += chunk.length;
+			if (total > MAX_CLIPBOARD_BYTES) {
+				child.kill();
+				finish(undefined);
+				return;
+			}
+			chunks.push(chunk);
+		});
+		child.on("close", (code) => {
+			if (code !== 0 || chunks.length === 0) {
+				finish(undefined);
+				return;
+			}
+			finish(Buffer.concat(chunks));
+		});
+	});
+}
+
+async function readMacClipboardImage(): Promise<string | undefined> {
+	const dir = await mkdtemp(join(tmpdir(), "cline-clipboard-"));
+	const filePath = join(dir, "clipboard.png");
+	try {
+		const escapedPath = filePath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+		await runCommand("osascript", [
+			"-e",
+			'set imageData to the clipboard as "PNGf"',
+			"-e",
+			`set fileRef to open for access POSIX file "${escapedPath}" with write permission`,
+			"-e",
+			"set eof fileRef to 0",
+			"-e",
+			"write imageData to fileRef",
+			"-e",
+			"close access fileRef",
+		]);
+		const buffer = await readFile(filePath).catch(() => undefined);
+		if (!buffer || buffer.length === 0) {
+			return undefined;
+		}
+		return bufferToImageDataUrl(buffer, "image/png");
+	} finally {
+		await rm(dir, { recursive: true, force: true }).catch(() => {});
+	}
+}
+
+async function readWindowsClipboardImage(): Promise<string | undefined> {
+	const script =
+		"Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img) { $ms = New-Object System.IO.MemoryStream; $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); [System.Convert]::ToBase64String($ms.ToArray()) }";
+	const output = await runCommand("powershell.exe", [
+		"-NonInteractive",
+		"-NoProfile",
+		"-Command",
+		script,
+	]);
+	const base64 = output?.toString("utf8").trim();
+	if (!base64) {
+		return undefined;
+	}
+	const buffer = Buffer.from(base64, "base64");
+	if (buffer.length === 0) {
+		return undefined;
+	}
+	return bufferToImageDataUrl(buffer, "image/png");
+}
+
+async function readLinuxClipboardImage(): Promise<string | undefined> {
+	const wayland = await runCommand("wl-paste", ["-t", "image/png"]);
+	if (wayland && wayland.length > 0) {
+		return bufferToImageDataUrl(wayland, "image/png");
+	}
+
+	const x11 = await runCommand("xclip", [
+		"-selection",
+		"clipboard",
+		"-t",
+		"image/png",
+		"-o",
+	]);
+	if (x11 && x11.length > 0) {
+		return bufferToImageDataUrl(x11, "image/png");
+	}
+
+	return undefined;
+}
+
+export async function readClipboardImageDataUrl(): Promise<string | undefined> {
+	if (process.platform === "darwin") {
+		return await readMacClipboardImage();
+	}
+
+	if (process.platform === "win32" || release().includes("WSL")) {
+		const windowsImage = await readWindowsClipboardImage();
+		if (windowsImage) {
+			return windowsImage;
+		}
+	}
+
+	if (process.platform === "linux") {
+		return await readLinuxClipboardImage();
+	}
+
+	return undefined;
+}
+
+export function readImmediateImagePasteAttachment(
+	event: PasteLikeEvent,
+): ImagePasteAttachment | undefined {
+	const mimeType = event.metadata?.mimeType;
+	if (mimeType?.startsWith("image/") && event.bytes.length > 0) {
+		return {
+			dataUrl: bufferToImageDataUrl(Buffer.from(event.bytes), mimeType),
+			source: "paste",
+		};
+	}
+
+	const text = normalizePasteText(
+		stripAnsiSequences(decodePasteBytes(event.bytes)),
+	);
+	return readImageDataUrlFromPastedText(text);
+}
+
+export async function readImagePasteAttachment(
+	event: PasteLikeEvent,
+): Promise<ImagePasteAttachment | undefined> {
+	const immediate = readImmediateImagePasteAttachment(event);
+	if (immediate) {
+		return immediate;
+	}
+
+	const text = normalizePasteText(
+		stripAnsiSequences(decodePasteBytes(event.bytes)),
+	);
+
+	if (text.trim()) {
+		return undefined;
+	}
+
+	const dataUrl = await readClipboardImageDataUrl();
+	if (!dataUrl) {
+		return undefined;
+	}
+
+	return {
+		dataUrl,
+		source: "clipboard",
+	};
+}
diff --git a/apps/cli/src/tui/utils/pasted-snippets.test.ts b/apps/cli/src/tui/utils/pasted-snippets.test.ts
new file mode 100644
index 0000000..a329dcb
--- /dev/null
+++ b/apps/cli/src/tui/utils/pasted-snippets.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import {
+	countPastedTextLines,
+	createUniquePastedTextSnippetMarker,
+	expandPastedTextSnippets,
+	formatPastedTextSnippetMarker,
+	shouldCompactPastedText,
+} from "./pasted-snippets";
+
+describe("pasted text snippet helpers", () => {
+	it("counts pasted lines across newline formats", () => {
+		expect(countPastedTextLines("one\ntwo\r\nthree\rfour")).toBe(4);
+		expect(countPastedTextLines("one\ntwo\nthree\nfour\n")).toBe(4);
+	});
+
+	it("compacts pastes at the large paste line threshold", () => {
+		expect(shouldCompactPastedText("one\ntwo\nthree\nfour")).toBe(false);
+		expect(shouldCompactPastedText("one\ntwo\nthree\nfour\n")).toBe(false);
+		expect(shouldCompactPastedText("one\ntwo\nthree\nfour\nfive")).toBe(true);
+	});
+
+	it("formats a compact single-line marker with preview text", () => {
+		expect(formatPastedTextSnippetMarker("alpha\nbeta\ngamma")).toBe(
+			"[alpha beta gamma... Pasted +3 lines]",
+		);
+	});
+
+	it("keeps markers unique when previews collide", () => {
+		const marker = formatPastedTextSnippetMarker("alpha\nbeta\ngamma");
+
+		expect(
+			createUniquePastedTextSnippetMarker("alpha\nbeta\ngamma", [marker]),
+		).toBe("[alpha beta gamma... Pasted +3 lines #2]");
+	});
+
+	it("expands pasted snippet markers before submission", () => {
+		expect(
+			expandPastedTextSnippets("before [snippet] after", [
+				{ marker: "[snippet]", text: "line 1\nline 2" },
+			]),
+		).toBe("before line 1\nline 2 after");
+	});
+});
diff --git a/apps/cli/src/tui/utils/pasted-snippets.ts b/apps/cli/src/tui/utils/pasted-snippets.ts
new file mode 100644
index 0000000..c6800f4
--- /dev/null
+++ b/apps/cli/src/tui/utils/pasted-snippets.ts
@@ -0,0 +1,60 @@
+export interface PastedTextSnippet {
+	marker: string;
+	text: string;
+}
+
+export const LARGE_PASTE_LINE_THRESHOLD = 5;
+
+const PREVIEW_MAX_CHARS = 48;
+
+export function countPastedTextLines(text: string): number {
+	if (text.length === 0) return 0;
+	const lines = text.split(/\r\n|\r|\n/);
+	return lines.at(-1) === "" ? lines.length - 1 : lines.length;
+}
+
+export function shouldCompactPastedText(text: string): boolean {
+	return countPastedTextLines(text) >= LARGE_PASTE_LINE_THRESHOLD;
+}
+
+function previewText(text: string): string {
+	const normalized = text.trim().replace(/\s+/g, " ");
+	if (!normalized) return "";
+	return normalized.length > PREVIEW_MAX_CHARS
+		? normalized.slice(0, PREVIEW_MAX_CHARS).trimEnd()
+		: normalized;
+}
+
+export function formatPastedTextSnippetMarker(text: string): string {
+	const lineCount = countPastedTextLines(text);
+	const preview = previewText(text);
+	const lineLabel = lineCount === 1 ? "line" : "lines";
+	const prefix = preview ? `${preview}... ` : "";
+	return `[${prefix}Pasted +${lineCount} ${lineLabel}]`;
+}
+
+export function createUniquePastedTextSnippetMarker(
+	text: string,
+	existingMarkers: Iterable<string>,
+): string {
+	const base = formatPastedTextSnippetMarker(text);
+	const existing = new Set(existingMarkers);
+	if (!existing.has(base)) return base;
+
+	for (let suffix = 2; ; suffix += 1) {
+		const candidate = base.replace(/\]$/, ` #${suffix}]`);
+		if (!existing.has(candidate)) return candidate;
+	}
+}
+
+export function expandPastedTextSnippets(
+	text: string,
+	snippets: readonly PastedTextSnippet[],
+): string {
+	let expanded = text;
+	for (const snippet of snippets) {
+		if (!expanded.includes(snippet.marker)) continue;
+		expanded = expanded.split(snippet.marker).join(snippet.text);
+	}
+	return expanded;
+}
diff --git a/apps/cli/src/tui/utils/provider-config-values.test.ts b/apps/cli/src/tui/utils/provider-config-values.test.ts
new file mode 100644
index 0000000..51a6a97
--- /dev/null
+++ b/apps/cli/src/tui/utils/provider-config-values.test.ts
@@ -0,0 +1,120 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	getDefaultAwsRegion,
+	resolveProviderConfigAwsRegion,
+	resolveProviderConfigAzure,
+	resolveProviderConfigGcp,
+	resolveProviderConfigSap,
+	updateProviderConfigValue,
+} from "./provider-config-values";
+
+const originalEnv = { ...process.env };
+
+afterEach(() => {
+	process.env = { ...originalEnv };
+});
+
+describe("provider config values", () => {
+	it("updates an auto-filled AWS region when the profile changes", () => {
+		delete process.env.AWS_REGION;
+		delete process.env.AWS_DEFAULT_REGION;
+		const dir = mkdtempSync(join(tmpdir(), "cline-provider-config-"));
+		try {
+			const configPath = join(dir, "config");
+			writeFileSync(
+				configPath,
+				[
+					"[default]",
+					"region = us-east-1",
+					"[profile dev]",
+					"region = ap-southeast-2",
+				].join("\n"),
+			);
+			process.env.AWS_CONFIG_FILE = configPath;
+
+			const result = updateProviderConfigValue(
+				{ awsProfile: "", awsRegion: getDefaultAwsRegion("") },
+				"awsProfile",
+				"dev",
+			);
+
+			expect(result.awsRegion).toBe("ap-southeast-2");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves a manually entered AWS region when the profile changes", () => {
+		const result = updateProviderConfigValue(
+			{ awsProfile: "", awsRegion: "eu-central-1" },
+			"awsProfile",
+			"dev",
+		);
+
+		expect(result.awsRegion).toBe("eu-central-1");
+	});
+
+	it("resolves AWS region from the saved profile when region is blank", () => {
+		process.env.AWS_REGION = "us-west-2";
+
+		expect(
+			resolveProviderConfigAwsRegion({
+				awsProfile: "dev",
+				awsRegion: "",
+			}),
+		).toBe("us-west-2");
+	});
+
+	it("resolves Vertex GCP field values into GCP settings", () => {
+		expect(
+			resolveProviderConfigGcp({ gcpRegion: "us-central1" }),
+		).toBeUndefined();
+		expect(
+			resolveProviderConfigGcp({
+				gcpProjectId: " project ",
+				gcpRegion: " europe-west4 ",
+			}),
+		).toEqual({ projectId: "project", region: "europe-west4" });
+	});
+
+	it("resolves SAP AI Core field values into SAP settings", () => {
+		expect(
+			resolveProviderConfigSap({
+				sapClientId: " client ",
+				sapClientSecret: " secret ",
+				sapTokenUrl: " https://auth.example ",
+				sapResourceGroup: " default ",
+				sapDeploymentId: " deployment ",
+			}),
+		).toEqual({
+			clientId: "client",
+			clientSecret: "secret",
+			tokenUrl: "https://auth.example",
+			resourceGroup: "default",
+			deploymentId: "deployment",
+		});
+	});
+
+	it("resolves Azure API version into Azure settings", () => {
+		expect(
+			resolveProviderConfigAzure({
+				azureApiVersion: " 2025-01-01-preview ",
+			}),
+		).toEqual({
+			apiVersion: "2025-01-01-preview",
+		});
+	});
+
+	it("keeps blank Azure API version so persisted settings can be cleared", () => {
+		expect(
+			resolveProviderConfigAzure({
+				azureApiVersion: "   ",
+			}),
+		).toEqual({
+			apiVersion: "",
+		});
+	});
+});
diff --git a/apps/cli/src/tui/utils/provider-config-values.ts b/apps/cli/src/tui/utils/provider-config-values.ts
new file mode 100644
index 0000000..fee7db9
--- /dev/null
+++ b/apps/cli/src/tui/utils/provider-config-values.ts
@@ -0,0 +1,82 @@
+import type { ProviderConfigFieldKey } from "@cline/core";
+import { resolveAwsRegion } from "../../utils/aws-region";
+
+export type ProviderConfigValues = Partial<
+	Record<ProviderConfigFieldKey, string>
+>;
+
+const DEFAULT_AWS_REGION = "us-east-1";
+const DEFAULT_GCP_REGION = "us-central1";
+
+export function getDefaultAwsRegion(profile?: string): string {
+	return (
+		resolveAwsRegion({ profile: profile?.trim() || undefined }) ??
+		DEFAULT_AWS_REGION
+	);
+}
+
+export function resolveProviderConfigAwsRegion(
+	values: ProviderConfigValues,
+): string {
+	return values.awsRegion?.trim() || getDefaultAwsRegion(values.awsProfile);
+}
+
+export function resolveProviderConfigGcp(values: ProviderConfigValues):
+	| {
+			projectId?: string;
+			region?: string;
+	  }
+	| undefined {
+	const projectId = values.gcpProjectId?.trim() || undefined;
+	if (!projectId) return undefined;
+	return {
+		projectId,
+		region: values.gcpRegion?.trim() || DEFAULT_GCP_REGION,
+	};
+}
+
+export function resolveProviderConfigSap(values: ProviderConfigValues):
+	| {
+			clientId?: string;
+			clientSecret?: string;
+			tokenUrl?: string;
+			resourceGroup?: string;
+			deploymentId?: string;
+	  }
+	| undefined {
+	const sap = {
+		clientId: values.sapClientId?.trim() || undefined,
+		clientSecret: values.sapClientSecret?.trim() || undefined,
+		tokenUrl: values.sapTokenUrl?.trim() || undefined,
+		resourceGroup: values.sapResourceGroup?.trim() || undefined,
+		deploymentId: values.sapDeploymentId?.trim() || undefined,
+	};
+	return Object.values(sap).some((value) => value !== undefined)
+		? sap
+		: undefined;
+}
+
+export function resolveProviderConfigAzure(values: ProviderConfigValues): {
+	apiVersion?: string;
+} {
+	return { apiVersion: values.azureApiVersion?.trim() ?? "" };
+}
+
+export function updateProviderConfigValue(
+	previous: ProviderConfigValues,
+	field: ProviderConfigFieldKey,
+	value: string,
+): ProviderConfigValues {
+	const next: ProviderConfigValues = { ...previous, [field]: value };
+	if (field !== "awsProfile") {
+		return next;
+	}
+
+	const previousRegion = previous.awsRegion?.trim();
+	const previousProfileRegion = getDefaultAwsRegion(previous.awsProfile);
+	if (!previousRegion || previousRegion === previousProfileRegion) {
+		next.awsRegion = getDefaultAwsRegion(value);
+	}
+
+	return next;
+}
diff --git a/apps/cli/src/tui/utils/provider-configured.ts b/apps/cli/src/tui/utils/provider-configured.ts
new file mode 100644
index 0000000..97fe443
--- /dev/null
+++ b/apps/cli/src/tui/utils/provider-configured.ts
@@ -0,0 +1,15 @@
+import { ProviderSettingsManager } from "@cline/core";
+import { isProviderSettingsUsable } from "../../utils/provider-readiness";
+import type { TuiProps } from "../types";
+
+export function isProviderConfigured(config: TuiProps["config"]): boolean {
+	if (config.apiKey?.trim()) {
+		return true;
+	}
+	const manager = new ProviderSettingsManager();
+	const settings = manager.getProviderSettings(config.providerId);
+	const providerConfig = manager.getProviderConfig(config.providerId, {
+		includeKnownModels: false,
+	});
+	return isProviderSettingsUsable(config.providerId, settings, providerConfig);
+}
diff --git a/apps/cli/src/tui/utils/provider-sections.test.ts b/apps/cli/src/tui/utils/provider-sections.test.ts
new file mode 100644
index 0000000..7cafd67
--- /dev/null
+++ b/apps/cli/src/tui/utils/provider-sections.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import {
+	getProviderSection,
+	OTHER_PROVIDER_SECTION,
+	POPULAR_PROVIDER_SECTION,
+} from "./provider-sections";
+
+describe("provider sections", () => {
+	it("labels popular providers separately from the rest", () => {
+		expect(getProviderSection({ capabilities: ["popular"] })).toBe(
+			POPULAR_PROVIDER_SECTION,
+		);
+		expect(getProviderSection({ capabilities: ["reasoning"] })).toBe(
+			OTHER_PROVIDER_SECTION,
+		);
+		expect(getProviderSection({})).toBe(OTHER_PROVIDER_SECTION);
+	});
+});
diff --git a/apps/cli/src/tui/utils/provider-sections.ts b/apps/cli/src/tui/utils/provider-sections.ts
new file mode 100644
index 0000000..575860b
--- /dev/null
+++ b/apps/cli/src/tui/utils/provider-sections.ts
@@ -0,0 +1,22 @@
+export const POPULAR_PROVIDER_SECTION = "Popular";
+export const OTHER_PROVIDER_SECTION = "Other";
+
+export type ProviderSection =
+	| typeof POPULAR_PROVIDER_SECTION
+	| typeof OTHER_PROVIDER_SECTION;
+
+export interface ProviderSectionItem {
+	capabilities?: readonly string[] | null;
+}
+
+export function isPopularProvider(provider: ProviderSectionItem): boolean {
+	return provider.capabilities?.includes("popular") ?? false;
+}
+
+export function getProviderSection(
+	provider: ProviderSectionItem,
+): ProviderSection {
+	return isPopularProvider(provider)
+		? POPULAR_PROVIDER_SECTION
+		: OTHER_PROVIDER_SECTION;
+}
diff --git a/apps/cli/src/tui/utils/selection-copy.test.ts b/apps/cli/src/tui/utils/selection-copy.test.ts
new file mode 100644
index 0000000..2344fed
--- /dev/null
+++ b/apps/cli/src/tui/utils/selection-copy.test.ts
@@ -0,0 +1,220 @@
+import type { Selection } from "@opentui/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	createSelectionCopyHandler,
+	type SelectionCopyDeps,
+} from "./selection-copy";
+
+function makeSelection(text: string): Selection {
+	return { getSelectedText: () => text } as unknown as Selection;
+}
+
+interface PendingCopy {
+	signal: AbortSignal;
+	resolve: (copied: boolean) => void;
+}
+
+function createTestDeps(options: { osc52Returns?: boolean } = {}) {
+	const showToast = vi.fn();
+	const copyToClipboardOSC52 = vi
+		.fn()
+		.mockReturnValue(options.osc52Returns ?? false);
+	const pending: PendingCopy[] = [];
+	const copyTextToSystemClipboardImpl = vi
+		.fn<NonNullable<SelectionCopyDeps["copyTextToSystemClipboardImpl"]>>()
+		.mockImplementation((_text, opts) => {
+			return new Promise<boolean>((resolve) => {
+				pending.push({
+					signal: opts?.signal as AbortSignal,
+					resolve,
+				});
+			});
+		});
+	return {
+		deps: {
+			copyToClipboardOSC52,
+			showToast,
+			copyTextToSystemClipboardImpl,
+		},
+		pending,
+	};
+}
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+describe("createSelectionCopyHandler", () => {
+	it("ignores empty selections (no toast, no copy attempt)", () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection(""));
+
+		expect(deps.copyToClipboardOSC52).not.toHaveBeenCalled();
+		expect(deps.copyTextToSystemClipboardImpl).not.toHaveBeenCalled();
+		expect(deps.showToast).not.toHaveBeenCalled();
+		expect(pending).toHaveLength(0);
+	});
+
+	it("still calls system clipboard when OSC52 succeeds", async () => {
+		const { deps, pending } = createTestDeps({ osc52Returns: true });
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("hello"));
+
+		expect(deps.copyToClipboardOSC52).toHaveBeenCalledWith("hello");
+		expect(deps.copyTextToSystemClipboardImpl).toHaveBeenCalledWith(
+			"hello",
+			expect.objectContaining({ signal: expect.any(AbortSignal) }),
+		);
+		expect(deps.showToast).not.toHaveBeenCalled();
+
+		pending[0]?.resolve(true);
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(deps.showToast).toHaveBeenCalledWith(
+			"Copied to clipboard",
+			"success",
+		);
+	});
+
+	it("reports success when OSC52 succeeds even if system clipboard fails", async () => {
+		const { deps, pending } = createTestDeps({ osc52Returns: true });
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("hello"));
+		pending[0]?.resolve(false);
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(deps.showToast).toHaveBeenCalledWith(
+			"Copied to clipboard",
+			"success",
+		);
+	});
+
+	it("calls fallback when OSC52 fails and toasts on success", async () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("text-A"));
+		expect(pending).toHaveLength(1);
+
+		pending[0]?.resolve(true);
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(deps.showToast).toHaveBeenCalledWith(
+			"Copied to clipboard",
+			"success",
+		);
+	});
+
+	it("toasts an error when fallback returns false", async () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("text-A"));
+		pending[0]?.resolve(false);
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(deps.showToast).toHaveBeenCalledWith(
+			"Unable to copy selection",
+			"error",
+		);
+	});
+
+	it("aborts the prior in-flight fallback when a new selection arrives", () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("text-A"));
+		expect(pending).toHaveLength(1);
+		const firstSignal = pending[0]?.signal;
+		expect(firstSignal?.aborted).toBe(false);
+
+		handleSelection(makeSelection("text-B"));
+
+		expect(firstSignal?.aborted).toBe(true);
+		expect(pending).toHaveLength(2);
+		expect(deps.copyTextToSystemClipboardImpl).toHaveBeenNthCalledWith(
+			1,
+			"text-A",
+			expect.objectContaining({ signal: expect.any(AbortSignal) }),
+		);
+		expect(deps.copyTextToSystemClipboardImpl).toHaveBeenNthCalledWith(
+			2,
+			"text-B",
+			expect.objectContaining({ signal: expect.any(AbortSignal) }),
+		);
+	});
+
+	it("does not toast for a stale fallback result that resolves after a newer selection", async () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("text-A"));
+		handleSelection(makeSelection("text-B"));
+		expect(pending).toHaveLength(2);
+
+		pending[0]?.resolve(true);
+		await Promise.resolve();
+		await Promise.resolve();
+		expect(deps.showToast).not.toHaveBeenCalled();
+
+		pending[1]?.resolve(true);
+		await Promise.resolve();
+		await Promise.resolve();
+		expect(deps.showToast).toHaveBeenCalledTimes(1);
+		expect(deps.showToast).toHaveBeenCalledWith(
+			"Copied to clipboard",
+			"success",
+		);
+	});
+
+	it("aborts in-flight fallback when the next selection starts", async () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("text-A"));
+		const firstSignal = pending[0]?.signal;
+		expect(firstSignal?.aborted).toBe(false);
+
+		deps.copyToClipboardOSC52.mockReturnValueOnce(true);
+		handleSelection(makeSelection("text-B"));
+
+		expect(firstSignal?.aborted).toBe(true);
+		expect(deps.showToast).not.toHaveBeenCalled();
+		expect(deps.copyTextToSystemClipboardImpl).toHaveBeenCalledTimes(2);
+
+		pending[1]?.resolve(false);
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(deps.showToast).toHaveBeenCalledWith(
+			"Copied to clipboard",
+			"success",
+		);
+	});
+
+	it("dispose() aborts any in-flight fallback and suppresses later toasts", async () => {
+		const { deps, pending } = createTestDeps();
+		const { handleSelection, dispose } = createSelectionCopyHandler(deps);
+
+		handleSelection(makeSelection("text-A"));
+		const signal = pending[0]?.signal;
+		expect(signal?.aborted).toBe(false);
+
+		dispose();
+		expect(signal?.aborted).toBe(true);
+
+		pending[0]?.resolve(true);
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(deps.showToast).not.toHaveBeenCalled();
+	});
+});
diff --git a/apps/cli/src/tui/utils/selection-copy.ts b/apps/cli/src/tui/utils/selection-copy.ts
new file mode 100644
index 0000000..1cf550d
--- /dev/null
+++ b/apps/cli/src/tui/utils/selection-copy.ts
@@ -0,0 +1,74 @@
+import type { Selection } from "@opentui/core";
+import { copyTextToSystemClipboard } from "./clipboard";
+
+export type ToastKind = "success" | "error";
+
+export interface SelectionCopyDeps {
+	copyToClipboardOSC52: (text: string) => boolean;
+	showToast: (message: string, kind: ToastKind) => void;
+	copyTextToSystemClipboardImpl?: typeof copyTextToSystemClipboard;
+}
+
+export interface SelectionCopyHandle {
+	handleSelection: (selection: Selection) => void;
+	dispose: () => void;
+}
+
+export function createSelectionCopyHandler(
+	deps: SelectionCopyDeps,
+): SelectionCopyHandle {
+	const copyImpl =
+		deps.copyTextToSystemClipboardImpl ?? copyTextToSystemClipboard;
+	let mounted = true;
+	let inFlight: AbortController | undefined;
+	let generation = 0;
+
+	const handleSelection = (selection: Selection) => {
+		const text = selection.getSelectedText();
+		if (!text) {
+			return;
+		}
+
+		inFlight?.abort();
+		inFlight = undefined;
+
+		const ticket = ++generation;
+
+		// Some terminals accept the OSC 52 write but do not update the system
+		// clipboard. Keep OSC 52 for SSH and capable terminals, then also try the
+		// native clipboard path so local Terminal.app gets pbcopy.
+		const copiedWithOsc52 = deps.copyToClipboardOSC52(text);
+
+		const controller = new AbortController();
+		inFlight = controller;
+
+		const finish = (copiedWithSystemClipboard: boolean) => {
+			if (!mounted || ticket !== generation) {
+				return;
+			}
+			if (inFlight === controller) {
+				inFlight = undefined;
+			}
+			if (controller.signal.aborted) {
+				return;
+			}
+			const copied = copiedWithSystemClipboard || copiedWithOsc52;
+			deps.showToast(
+				copied ? "Copied to clipboard" : "Unable to copy selection",
+				copied ? "success" : "error",
+			);
+		};
+
+		void copyImpl(text, { signal: controller.signal })
+			.then(finish)
+			.catch(() => finish(false));
+	};
+
+	const dispose = () => {
+		mounted = false;
+		inFlight?.abort();
+		inFlight = undefined;
+	};
+
+	return { handleSelection, dispose };
+}
diff --git a/apps/cli/src/tui/utils/skill-command-input.test.ts b/apps/cli/src/tui/utils/skill-command-input.test.ts
new file mode 100644
index 0000000..d00baba
--- /dev/null
+++ b/apps/cli/src/tui/utils/skill-command-input.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import {
+	insertSelectedSkillCommand,
+	removeLocalSlashCommandInvocation,
+} from "./skill-command-input";
+
+describe("skill command input helpers", () => {
+	it("replaces a /skills trigger without clearing existing typed input", () => {
+		expect(
+			insertSelectedSkillCommand({
+				text: "please /skills this file",
+				cursorOffset: "please /skills".length,
+				commandName: "review",
+				replaceRange: {
+					start: "please ".length,
+					end: "please /skills".length,
+				},
+			}),
+		).toEqual({
+			text: "please /review this file",
+			cursorOffset: "please /review ".length,
+		});
+	});
+
+	it("appends a selected skill when the picker opens without a slash trigger", () => {
+		expect(
+			insertSelectedSkillCommand({
+				text: "please inspect this",
+				cursorOffset: "please inspect this".length,
+				commandName: "review",
+			}),
+		).toEqual({
+			text: "please inspect this /review ",
+			cursorOffset: "please inspect this /review ".length,
+		});
+	});
+
+	it("removes only the /skills trigger when the picker is dismissed", () => {
+		expect(
+			removeLocalSlashCommandInvocation({
+				text: "please /skills this file",
+				cursorOffset: "please /skills".length,
+				replaceRange: {
+					start: "please ".length,
+					end: "please /skills".length,
+				},
+			}),
+		).toEqual({
+			text: "please this file",
+			cursorOffset: "please ".length,
+		});
+	});
+
+	it("leaves input unchanged when dismissing without a replace range", () => {
+		expect(
+			removeLocalSlashCommandInvocation({
+				text: "please inspect this",
+				cursorOffset: 999,
+			}),
+		).toEqual({
+			text: "please inspect this",
+			cursorOffset: "please inspect this".length,
+		});
+	});
+});
diff --git a/apps/cli/src/tui/utils/skill-command-input.ts b/apps/cli/src/tui/utils/skill-command-input.ts
new file mode 100644
index 0000000..fd4cc19
--- /dev/null
+++ b/apps/cli/src/tui/utils/skill-command-input.ts
@@ -0,0 +1,88 @@
+export interface LocalSlashCommandInvocation {
+	text: string;
+	cursorOffset: number;
+	replaceRange?: {
+		start: number;
+		end: number;
+	};
+}
+
+function clampOffset(offset: number, text: string): number {
+	return Math.max(0, Math.min(offset, text.length));
+}
+
+function normalizeRange(
+	range: LocalSlashCommandInvocation["replaceRange"],
+	text: string,
+): { start: number; end: number } | undefined {
+	if (!range) return undefined;
+	const start = clampOffset(Math.min(range.start, range.end), text);
+	const end = clampOffset(Math.max(range.start, range.end), text);
+	return start === end ? undefined : { start, end };
+}
+
+function normalizeCommandName(commandName: string): string {
+	return commandName.trim().replace(/^\/+/, "");
+}
+
+function stripLeadingInlineWhitespace(text: string): string {
+	return text.replace(/^[ \t]+/, "");
+}
+
+export function insertSelectedSkillCommand(input: {
+	text: string;
+	cursorOffset: number;
+	commandName: string;
+	replaceRange?: LocalSlashCommandInvocation["replaceRange"];
+}): { text: string; cursorOffset: number } {
+	const commandName = normalizeCommandName(input.commandName);
+	const commandText = `/${commandName} `;
+	const range = normalizeRange(input.replaceRange, input.text);
+
+	if (range) {
+		const before = input.text.slice(0, range.start);
+		const after = stripLeadingInlineWhitespace(input.text.slice(range.end));
+		const leadingSpace = before.length > 0 && !/\s$/.test(before) ? " " : "";
+		const text = `${before}${leadingSpace}${commandText}${after}`;
+		return {
+			text,
+			cursorOffset: before.length + leadingSpace.length + commandText.length,
+		};
+	}
+
+	const cursorOffset = clampOffset(input.cursorOffset, input.text);
+	const before = input.text.slice(0, cursorOffset);
+	const after = stripLeadingInlineWhitespace(input.text.slice(cursorOffset));
+	const leadingSpace = before.length > 0 && !/\s$/.test(before) ? " " : "";
+	const text = `${before}${leadingSpace}${commandText}${after}`;
+
+	return {
+		text,
+		cursorOffset: before.length + leadingSpace.length + commandText.length,
+	};
+}
+
+export function removeLocalSlashCommandInvocation(
+	invocation: LocalSlashCommandInvocation,
+): { text: string; cursorOffset: number } {
+	const range = normalizeRange(invocation.replaceRange, invocation.text);
+	if (!range) {
+		return {
+			text: invocation.text,
+			cursorOffset: clampOffset(invocation.cursorOffset, invocation.text),
+		};
+	}
+
+	const before = invocation.text.slice(0, range.start);
+	const after = invocation.text.slice(range.end);
+	const joinedAfter =
+		before.length > 0 && /\s$/.test(before)
+			? stripLeadingInlineWhitespace(after)
+			: after;
+	const text = `${before}${joinedAfter}`;
+
+	return {
+		text,
+		cursorOffset: clampOffset(range.start, text),
+	};
+}
diff --git a/apps/cli/src/tui/utils/syntax-style.test.ts b/apps/cli/src/tui/utils/syntax-style.test.ts
new file mode 100644
index 0000000..f3d3afa
--- /dev/null
+++ b/apps/cli/src/tui/utils/syntax-style.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from "vitest";
+import { getSyntaxStyle } from "./syntax-style";
+
+const { MockRGBA, MockSyntaxStyle } = vi.hoisted(() => {
+	class MockRGBA {
+		private constructor(private readonly hex: string) {}
+
+		static fromHex(hex: string): MockRGBA {
+			return new MockRGBA(hex.toLowerCase());
+		}
+
+		toInts(): [number, number, number, number] {
+			return [
+				Number.parseInt(this.hex.slice(1, 3), 16),
+				Number.parseInt(this.hex.slice(3, 5), 16),
+				Number.parseInt(this.hex.slice(5, 7), 16),
+				255,
+			];
+		}
+	}
+
+	class MockSyntaxStyle {
+		private constructor(private readonly styles: Map<string, unknown>) {}
+
+		static fromStyles(styles: Record<string, unknown>): MockSyntaxStyle {
+			return new MockSyntaxStyle(new Map(Object.entries(styles)));
+		}
+
+		getStyle(name: string): unknown {
+			return this.styles.get(name);
+		}
+	}
+
+	return { MockRGBA, MockSyntaxStyle };
+});
+
+vi.mock("@opentui/core", () => ({
+	RGBA: MockRGBA,
+	SyntaxStyle: MockSyntaxStyle,
+}));
+
+describe("getSyntaxStyle", () => {
+	it("keeps dark markdown prose on the terminal default foreground", () => {
+		expect(getSyntaxStyle("dark").getStyle("default")).toBeUndefined();
+	});
+
+	it("uses a dark default foreground for light markdown content", () => {
+		const style = getSyntaxStyle("light").getStyle("default");
+
+		expect(style?.fg?.toInts()).toEqual([26, 26, 26, 255]);
+	});
+
+	it("tints markdown accents by mode", () => {
+		// act #79b8ff vs plan #ffea7f (dark theme accents)
+		expect(
+			getSyntaxStyle("dark", "act").getStyle("markup.heading")?.fg?.toInts(),
+		).toEqual([0x79, 0xb8, 0xff, 255]);
+		expect(
+			getSyntaxStyle("dark", "plan").getStyle("markup.heading")?.fg?.toInts(),
+		).toEqual([0xff, 0xea, 0x7f, 255]);
+		expect(
+			getSyntaxStyle("dark", "plan").getStyle("markup.link")?.fg?.toInts(),
+		).toEqual([0xff, 0xea, 0x7f, 255]);
+	});
+
+	it("tints light-theme markdown accents by mode", () => {
+		// act #0f72cb vs plan #867100 (light theme accents)
+		expect(
+			getSyntaxStyle("light", "act").getStyle("markup.heading")?.fg?.toInts(),
+		).toEqual([0x0f, 0x72, 0xcb, 255]);
+		expect(
+			getSyntaxStyle("light", "plan").getStyle("markup.heading")?.fg?.toInts(),
+		).toEqual([0x86, 0x71, 0x00, 255]);
+	});
+
+	it("keeps code token colors constant across modes", () => {
+		expect(getSyntaxStyle("dark", "plan").getStyle("keyword")).toEqual(
+			getSyntaxStyle("dark", "act").getStyle("keyword"),
+		);
+	});
+});
diff --git a/apps/cli/src/tui/utils/syntax-style.ts b/apps/cli/src/tui/utils/syntax-style.ts
new file mode 100644
index 0000000..b6b93ee
--- /dev/null
+++ b/apps/cli/src/tui/utils/syntax-style.ts
@@ -0,0 +1,163 @@
+import { RGBA, type StyleDefinition, SyntaxStyle } from "@opentui/core";
+import { type TerminalTheme, themePalette } from "../palette";
+
+// Markdown's prominent elements (headings, bold, list markers, links) take
+// the accent of the mode the content was produced in, so assistant output
+// reads plan-yellow or act-blue alongside the rest of the transcript.
+export type SyntaxAccentMode = "act" | "plan";
+
+const instances = new Map<string, SyntaxStyle>();
+
+interface SyntaxColors {
+	keyword: string;
+	operator: string;
+	type: string;
+	functionName: string;
+	variable: string;
+	string: string;
+	number: string;
+	comment: string;
+	punctuation: string;
+	property: string;
+	constant: string;
+	tag: string;
+	attribute: string;
+	escape: string;
+	markdownCode: string;
+	markdownMuted: string;
+	markdownItalic: string;
+	markdownDefault?: string;
+}
+
+// Dark syntax colors are a pastel family harmonized with the brand accents
+// (act #79b8ff, plan #ffea7f, success #99e89b): every hue sits near the same
+// OKLCH lightness/chroma weight (~L 0.78, C 0.11) so code blocks feel like
+// part of the same palette instead of a bolted-on editor theme.
+const syntaxColors: Record<TerminalTheme, SyntaxColors> = {
+	dark: {
+		keyword: "#d7a0e3",
+		operator: "#9bbbdd",
+		type: "#dfca7d",
+		functionName: themePalette.dark.act,
+		variable: "#ee939b",
+		string: "#99e89b",
+		number: "#f0ad7f",
+		comment: "#5c6370",
+		punctuation: "#abb2bf",
+		property: "#ee939b",
+		constant: "#f0ad7f",
+		tag: "#ee939b",
+		attribute: "#f0ad7f",
+		escape: "#9bbbdd",
+		markdownCode: "#99e89b",
+		markdownMuted: "#808080",
+		markdownItalic: "#dfca7d",
+	},
+	light: {
+		keyword: "#cf222e",
+		operator: "#0550ae",
+		type: "#953800",
+		functionName: "#8250df",
+		variable: "#953800",
+		string: "#0a3069",
+		number: "#0550ae",
+		comment: "#6e7781",
+		punctuation: "#57606a",
+		property: "#0550ae",
+		constant: "#0550ae",
+		tag: "#116329",
+		attribute: "#0550ae",
+		escape: "#0550ae",
+		markdownCode: "#116329",
+		markdownMuted: "#6e7781",
+		markdownItalic: "#8250df",
+		markdownDefault: "#1a1a1a",
+	},
+};
+
+function color(hex: string): RGBA {
+	return RGBA.fromHex(hex);
+}
+
+function fg(hex: string): StyleDefinition {
+	return { fg: color(hex) };
+}
+
+function bold(hex: string): StyleDefinition {
+	return { fg: color(hex), bold: true };
+}
+
+function italic(hex: string): StyleDefinition {
+	return { fg: color(hex), italic: true };
+}
+
+function buildSyntaxStyle(
+	theme: TerminalTheme,
+	mode: SyntaxAccentMode,
+): SyntaxStyle {
+	const colors = syntaxColors[theme];
+	const accent = color(themePalette[theme][mode]);
+	const markdownHeading = accent;
+	const markdownCode = color(colors.markdownCode);
+	const markdownMuted = color(colors.markdownMuted);
+	const markdownLink = accent;
+
+	return SyntaxStyle.fromStyles({
+		...(colors.markdownDefault ? { default: fg(colors.markdownDefault) } : {}),
+		keyword: bold(colors.keyword),
+		"keyword.control": bold(colors.keyword),
+		"keyword.operator": fg(colors.operator),
+		type: fg(colors.type),
+		"type.builtin": fg(colors.type),
+		function: fg(colors.functionName),
+		"function.method": fg(colors.functionName),
+		variable: fg(colors.variable),
+		"variable.parameter": fg(colors.variable),
+		"variable.builtin": fg(colors.type),
+		string: fg(colors.string),
+		"string.special": fg(colors.string),
+		number: fg(colors.number),
+		comment: italic(colors.comment),
+		operator: fg(colors.operator),
+		punctuation: fg(colors.punctuation),
+		property: fg(colors.property),
+		constant: fg(colors.constant),
+		tag: fg(colors.tag),
+		attribute: fg(colors.attribute),
+		escape: fg(colors.escape),
+		"markup.heading": { fg: markdownHeading, bold: true },
+		"markup.heading.1": { fg: markdownHeading, bold: true },
+		"markup.heading.2": { fg: markdownHeading, bold: true },
+		"markup.heading.3": { fg: markdownHeading, bold: true },
+		"markup.heading.4": { fg: markdownHeading, bold: true },
+		"markup.heading.5": { fg: markdownHeading, bold: true },
+		"markup.heading.6": { fg: markdownHeading, bold: true },
+		"markup.raw": { fg: markdownCode },
+		"markup.raw.inline": { fg: markdownCode },
+		"markup.raw.block": { fg: markdownCode },
+		"markup.strong": { fg: markdownHeading, bold: true },
+		"markup.bold": { fg: markdownHeading, bold: true },
+		"markup.italic": italic(colors.markdownItalic),
+		"markup.quote": { fg: markdownMuted, italic: true },
+		"markup.list": { fg: markdownHeading },
+		"markup.link": { fg: markdownLink, underline: true },
+		"markup.link.label": { fg: markdownLink, underline: true },
+		"markup.link.url": { fg: markdownLink, underline: true },
+		label: { fg: markdownLink },
+		conceal: { fg: markdownMuted },
+		"string.special.url": { fg: markdownLink, underline: true },
+	});
+}
+
+export function getSyntaxStyle(
+	theme: TerminalTheme = "dark",
+	mode: SyntaxAccentMode = "act",
+): SyntaxStyle {
+	const key = `${theme}:${mode}`;
+	let style = instances.get(key);
+	if (!style) {
+		style = buildSyntaxStyle(theme, mode);
+		instances.set(key, style);
+	}
+	return style;
+}
diff --git a/apps/cli/src/tui/utils/terminal-title.test.ts b/apps/cli/src/tui/utils/terminal-title.test.ts
new file mode 100644
index 0000000..bbe5fdd
--- /dev/null
+++ b/apps/cli/src/tui/utils/terminal-title.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { deriveTerminalTitle } from "./terminal-title";
+
+describe("deriveTerminalTitle", () => {
+	it("uses the base title outside chat", () => {
+		expect(
+			deriveTerminalTitle({
+				appView: "home",
+				entries: [{ kind: "user_submitted", text: "hello" }],
+			}),
+		).toBe("Cline");
+	});
+
+	it("uses the latest submitted user message in chat", () => {
+		expect(
+			deriveTerminalTitle({
+				appView: "chat",
+				entries: [
+					{ kind: "user_submitted", text: "first request" },
+					{ kind: "assistant_text", text: "ok", streaming: false },
+					{ kind: "user_submitted", text: "second request" },
+				],
+			}),
+		).toBe("> second request");
+	});
+
+	it("falls back to the initial prompt before it is submitted", () => {
+		expect(
+			deriveTerminalTitle({
+				appView: "chat",
+				entries: [],
+				initialPrompt: "start this task",
+			}),
+		).toBe("> start this task");
+	});
+
+	it("normalizes wrapped user input and control characters", () => {
+		expect(
+			deriveTerminalTitle({
+				appView: "chat",
+				entries: [
+					{
+						kind: "user_submitted",
+						text: '<user_input mode="act">hello\x1b]0;bad\x07\nworld</user_input>',
+					},
+				],
+			}),
+		).toBe("> hello ]0;bad");
+	});
+
+	it("truncates long titles", () => {
+		const title = deriveTerminalTitle({
+			appView: "chat",
+			entries: [{ kind: "user_submitted", text: "a".repeat(120) }],
+		});
+
+		expect(title).toHaveLength(80);
+		expect(title.endsWith("...")).toBe(true);
+	});
+});
diff --git a/apps/cli/src/tui/utils/terminal-title.ts b/apps/cli/src/tui/utils/terminal-title.ts
new file mode 100644
index 0000000..fb364cf
--- /dev/null
+++ b/apps/cli/src/tui/utils/terminal-title.ts
@@ -0,0 +1,54 @@
+import { formatDisplayUserInput } from "@cline/shared";
+import type { AppView, ChatEntry } from "../types";
+
+const APP_TITLE = "Cline";
+const CHAT_TITLE_PREFIX = "> ";
+const MAX_TERMINAL_TITLE_LENGTH = 80;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: stripping control characters from terminal titles is the purpose of this pattern
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f-\u009f]/g;
+
+function truncateTitle(title: string): string {
+	if (title.length <= MAX_TERMINAL_TITLE_LENGTH) {
+		return title;
+	}
+	return `${title.slice(0, MAX_TERMINAL_TITLE_LENGTH - 3).trimEnd()}...`;
+}
+
+function sanitizeTerminalTitleText(text: string): string {
+	return text
+		.replace(CONTROL_CHARACTER_PATTERN, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function normalizeChatTitleText(text: string): string {
+	const formatted = formatDisplayUserInput(text);
+	const firstLine = formatted.split("\n")[0] ?? formatted;
+	return sanitizeTerminalTitleText(firstLine);
+}
+
+export function deriveTerminalTitle(input: {
+	appView: AppView;
+	entries: ChatEntry[];
+	initialPrompt?: string;
+}): string {
+	if (input.appView !== "chat") {
+		return APP_TITLE;
+	}
+
+	for (let index = input.entries.length - 1; index >= 0; index -= 1) {
+		const entry = input.entries[index];
+		if (entry?.kind !== "user_submitted" && entry?.kind !== "user") {
+			continue;
+		}
+		const text = normalizeChatTitleText(entry.text);
+		if (text) {
+			return truncateTitle(`${CHAT_TITLE_PREFIX}${text}`);
+		}
+	}
+
+	const initialPrompt = normalizeChatTitleText(input.initialPrompt ?? "");
+	return initialPrompt
+		? truncateTitle(`${CHAT_TITLE_PREFIX}${initialPrompt}`)
+		: APP_TITLE;
+}
diff --git a/apps/cli/src/tui/utils/tool-errors.test.ts b/apps/cli/src/tui/utils/tool-errors.test.ts
new file mode 100644
index 0000000..97bb744
--- /dev/null
+++ b/apps/cli/src/tui/utils/tool-errors.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+	getToolErrorPresentation,
+	isWarningToolError,
+	unwrapToolError,
+} from "./tool-errors";
+
+describe("tool error presentation", () => {
+	it("unwraps JSON-encoded tool errors", () => {
+		const raw = JSON.stringify({
+			error: "Tool call run_commands was rejected before execution: nope",
+		});
+
+		expect(unwrapToolError(raw)).toBe(
+			"Tool call run_commands was rejected before execution: nope",
+		);
+	});
+
+	it("summarizes invalid tool input as a warning", () => {
+		const raw = JSON.stringify({
+			error:
+				'Tool call run_commands was rejected before execution: Invalid input for tool run_commands: Type validation failed: Value: {"commands":[{"command":"cat file"}]}.\nError message: []',
+		});
+
+		expect(getToolErrorPresentation(raw)).toMatchObject({
+			severity: "warning",
+			summary: "Invalid run_commands input; tool call skipped.",
+		});
+		expect(isWarningToolError(raw)).toBe(true);
+	});
+
+	it("summarizes generic pre-execution rejections as warnings", () => {
+		expect(
+			getToolErrorPresentation(
+				"Tool call editor was rejected before execution: approval request failed",
+			),
+		).toMatchObject({
+			severity: "warning",
+			summary: "editor call was skipped before execution.",
+		});
+	});
+
+	it("keeps non-rejection failures as errors", () => {
+		const presentation = getToolErrorPresentation("command failed with exit 1");
+
+		expect(presentation).toEqual({
+			severity: "error",
+			summary: "command failed with exit 1",
+			detail: "command failed with exit 1",
+		});
+	});
+
+	it("summarizes JSON-wrapped hard errors without dumping stacks", () => {
+		const raw = JSON.stringify({
+			error:
+				"Error: command failed with exit 1\n    at runTool (/tmp/tool.ts:10:1)\n    at async main (/tmp/main.ts:5:1)",
+		});
+
+		expect(getToolErrorPresentation(raw)).toEqual({
+			severity: "error",
+			summary: "command failed with exit 1",
+			detail:
+				"Error: command failed with exit 1\n    at runTool (/tmp/tool.ts:10:1)\n    at async main (/tmp/main.ts:5:1)",
+		});
+	});
+
+	it("collapses long one-line hard errors", () => {
+		const detail = `Validation failed: ${"x".repeat(180)}`;
+		const presentation = getToolErrorPresentation(detail);
+
+		expect(presentation.severity).toBe("error");
+		expect(presentation.detail).toBe(detail);
+		expect(presentation.summary.length).toBeLessThanOrEqual(140);
+		expect(presentation.summary.endsWith("...")).toBe(true);
+	});
+
+	it("uses a generic summary when no string error can be extracted", () => {
+		const presentation = getToolErrorPresentation(
+			JSON.stringify({ code: "E_TOOL", data: { value: 1 } }),
+		);
+
+		expect(presentation).toEqual({
+			severity: "error",
+			summary: "Tool returned a structured error.",
+			detail: JSON.stringify({ code: "E_TOOL", data: { value: 1 } }),
+		});
+	});
+});
diff --git a/apps/cli/src/tui/utils/tool-errors.ts b/apps/cli/src/tui/utils/tool-errors.ts
new file mode 100644
index 0000000..8de5744
--- /dev/null
+++ b/apps/cli/src/tui/utils/tool-errors.ts
@@ -0,0 +1,118 @@
+export interface ToolErrorPresentation {
+	severity: "warning" | "error";
+	summary: string;
+	detail: string;
+}
+
+const MAX_ERROR_SUMMARY_LENGTH = 140;
+
+function extractStringError(value: unknown): string | undefined {
+	if (typeof value === "string") {
+		return value.trim() || undefined;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	const record = value as Record<string, unknown>;
+	return (
+		extractStringError(record.error) ??
+		extractStringError(record.message) ??
+		undefined
+	);
+}
+
+export function unwrapToolError(error: string): string {
+	let current = error.trim();
+	for (let i = 0; i < 3; i += 1) {
+		if (!current.startsWith("{") && !current.startsWith("[")) break;
+		try {
+			const parsed = JSON.parse(current) as unknown;
+			const next = extractStringError(parsed);
+			if (!next || next === current) break;
+			current = next.trim();
+		} catch {
+			break;
+		}
+	}
+	return current;
+}
+
+function summarizeInvalidInput(message: string): string | undefined {
+	const rejected = message.match(
+		/^Tool call\s+([A-Za-z0-9_-]+)\s+was rejected before execution:\s+Invalid input for tool\s+([A-Za-z0-9_-]+):\s*([^.\n]+)(?:\.|\n|$)/,
+	);
+	if (rejected) {
+		return `Invalid ${rejected[2]} input; tool call skipped.`;
+	}
+
+	const invalid = message.match(
+		/^Invalid input for tool\s+([A-Za-z0-9_-]+):\s*([^.\n]+)(?:\.|\n|$)/,
+	);
+	if (invalid) {
+		return `Invalid ${invalid[1]} input; tool call skipped.`;
+	}
+
+	return undefined;
+}
+
+function truncateSummary(text: string): string {
+	const trimmed = text.trim();
+	if (trimmed.length <= MAX_ERROR_SUMMARY_LENGTH) {
+		return trimmed;
+	}
+	return `${trimmed.slice(0, MAX_ERROR_SUMMARY_LENGTH - 3).trimEnd()}...`;
+}
+
+function summarizeErrorDetail(detail: string): string {
+	const trimmed = detail.trim();
+	if (!trimmed) {
+		return "Tool failed.";
+	}
+
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		return "Tool returned a structured error.";
+	}
+
+	const firstLine =
+		trimmed
+			.replace(/\r\n/g, "\n")
+			.split("\n")
+			.map((line) => line.trim())
+			.find(Boolean) ?? "Tool failed.";
+	const withoutGenericPrefix = firstLine.replace(/^Error:\s+/i, "");
+
+	return truncateSummary(withoutGenericPrefix.replace(/\s+/g, " "));
+}
+
+export function getToolErrorPresentation(error: string): ToolErrorPresentation {
+	const detail = unwrapToolError(error);
+	const inputSummary = summarizeInvalidInput(detail);
+	if (inputSummary) {
+		return {
+			severity: "warning",
+			summary: inputSummary,
+			detail,
+		};
+	}
+
+	const rejected = detail.match(
+		/^Tool call\s+([A-Za-z0-9_-]+)\s+was rejected before execution:/,
+	);
+	if (rejected) {
+		return {
+			severity: "warning",
+			summary: `${rejected[1]} call was skipped before execution.`,
+			detail,
+		};
+	}
+
+	return {
+		severity: "error",
+		summary: summarizeErrorDetail(detail),
+		detail,
+	};
+}
+
+export function isWarningToolError(error: string | undefined): boolean {
+	return error ? getToolErrorPresentation(error).severity === "warning" : false;
+}
diff --git a/apps/cli/src/tui/utils/tool-parsing.ts b/apps/cli/src/tui/utils/tool-parsing.ts
new file mode 100644
index 0000000..6432971
--- /dev/null
+++ b/apps/cli/src/tui/utils/tool-parsing.ts
@@ -0,0 +1,308 @@
+import { basename, extname } from "node:path";
+import { hunkHeader } from "./diff";
+
+const EXT_TO_LANGUAGE: Record<string, string> = {
+	".ts": "typescript",
+	".tsx": "tsx",
+	".js": "javascript",
+	".jsx": "jsx",
+	".py": "python",
+	".rb": "ruby",
+	".rs": "rust",
+	".go": "go",
+	".java": "java",
+	".kt": "kotlin",
+	".swift": "swift",
+	".c": "c",
+	".cpp": "cpp",
+	".h": "c",
+	".hpp": "cpp",
+	".cs": "csharp",
+	".css": "css",
+	".scss": "scss",
+	".html": "html",
+	".vue": "vue",
+	".svelte": "svelte",
+	".json": "json",
+	".yaml": "yaml",
+	".yml": "yaml",
+	".toml": "toml",
+	".md": "markdown",
+	".sql": "sql",
+	".sh": "bash",
+	".bash": "bash",
+	".zsh": "bash",
+	".fish": "fish",
+	".lua": "lua",
+	".php": "php",
+	".r": "r",
+	".ex": "elixir",
+	".exs": "elixir",
+	".erl": "erlang",
+	".zig": "zig",
+	".dockerfile": "dockerfile",
+	".xml": "xml",
+	".graphql": "graphql",
+	".proto": "protobuf",
+};
+
+export function detectLanguage(filePath: string): string | undefined {
+	const ext = extname(filePath).toLowerCase();
+	if (ext && EXT_TO_LANGUAGE[ext]) return EXT_TO_LANGUAGE[ext];
+	const base = basename(filePath).toLowerCase();
+	if (base === "dockerfile") return "dockerfile";
+	if (base === "makefile") return "makefile";
+	if (base === "cmakelists.txt") return "cmake";
+	return undefined;
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+	return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+export interface ReadFilesInfo {
+	files: { path: string; startLine?: number; endLine?: number }[];
+}
+
+export function parseReadFilesInput(input: unknown): ReadFilesInfo | undefined {
+	if (!isRecord(input)) return undefined;
+
+	if (Array.isArray(input.file_paths)) {
+		return {
+			files: input.file_paths
+				.filter((p): p is string => typeof p === "string")
+				.map((path) => ({ path })),
+		};
+	}
+
+	if (Array.isArray(input.files)) {
+		return {
+			files: input.files
+				.filter((f): f is Record<string, unknown> => isRecord(f))
+				.map((f) => ({
+					path: String(f.path ?? ""),
+					startLine:
+						typeof f.start_line === "number" ? f.start_line : undefined,
+					endLine: typeof f.end_line === "number" ? f.end_line : undefined,
+				})),
+		};
+	}
+
+	return undefined;
+}
+
+export interface RunCommandsInfo {
+	commands: string[];
+}
+
+export function parseRunCommandsInput(
+	input: unknown,
+): RunCommandsInfo | undefined {
+	if (!isRecord(input)) {
+		if (typeof input === "string") return { commands: [input] };
+		return undefined;
+	}
+
+	if (Array.isArray(input.commands)) {
+		return {
+			commands: input.commands.map((cmd) => {
+				if (typeof cmd === "string") return cmd;
+				if (isRecord(cmd) && typeof cmd.command === "string") {
+					const args = Array.isArray(cmd.args) ? cmd.args.join(" ") : "";
+					return args ? `${cmd.command} ${args}` : cmd.command;
+				}
+				return String(cmd);
+			}),
+		};
+	}
+
+	return undefined;
+}
+
+export interface EditorInfo {
+	path: string;
+	oldText?: string;
+	newText: string;
+	insertLine?: number;
+}
+
+export function parseEditorInput(input: unknown): EditorInfo | undefined {
+	if (!isRecord(input)) return undefined;
+	if (typeof input.path !== "string") return undefined;
+	if (typeof input.new_text !== "string") return undefined;
+
+	return {
+		path: input.path,
+		oldText: typeof input.old_text === "string" ? input.old_text : undefined,
+		newText: input.new_text,
+		insertLine:
+			typeof input.insert_line === "number" ? input.insert_line : undefined,
+	};
+}
+
+export interface SearchInfo {
+	queries: string[];
+}
+
+export function parseSearchInput(input: unknown): SearchInfo | undefined {
+	if (!isRecord(input)) return undefined;
+	if (!Array.isArray(input.queries)) return undefined;
+	return {
+		queries: input.queries.filter((q): q is string => typeof q === "string"),
+	};
+}
+
+export interface WebFetchInfo {
+	urls: string[];
+}
+
+export function parseWebFetchInput(input: unknown): WebFetchInfo | undefined {
+	if (!isRecord(input)) return undefined;
+	if (!Array.isArray(input.requests)) return undefined;
+	return {
+		urls: input.requests
+			.filter((r): r is Record<string, unknown> => isRecord(r))
+			.map((r) => String(r.url ?? ""))
+			.filter(Boolean),
+	};
+}
+
+export interface SpawnAgentInfo {
+	task: string;
+}
+
+export function parseSpawnAgentInput(
+	input: unknown,
+): SpawnAgentInfo | undefined {
+	if (!isRecord(input)) return undefined;
+	if (typeof input.task !== "string") return undefined;
+	return { task: input.task };
+}
+
+export function extractFullOutputText(raw: unknown): string | undefined {
+	if (raw === null || raw === undefined) return undefined;
+	if (typeof raw === "string") return raw;
+
+	if (Array.isArray(raw)) {
+		const parts: string[] = [];
+		for (const item of raw) {
+			if (isRecord(item) && "result" in item) {
+				const result = item.result;
+				if (typeof result === "string") {
+					parts.push(result);
+				} else if (Array.isArray(result)) {
+					for (const part of result) {
+						if (
+							isRecord(part) &&
+							(part as { type?: string }).type === "text" &&
+							"text" in part
+						) {
+							parts.push(String(part.text));
+						}
+					}
+				}
+			}
+		}
+		if (parts.length > 0) return parts.join("\n");
+	}
+
+	if (typeof raw === "object") {
+		try {
+			return JSON.stringify(raw, null, 2);
+		} catch {
+			return String(raw);
+		}
+	}
+
+	return String(raw);
+}
+
+export interface AskQuestionInfo {
+	question: string;
+	options: string[];
+}
+
+export function parseAskQuestionInput(
+	input: unknown,
+): AskQuestionInfo | undefined {
+	if (!isRecord(input)) return undefined;
+	if (typeof input.question !== "string") return undefined;
+	const options = Array.isArray(input.options)
+		? input.options.filter((o): o is string => typeof o === "string")
+		: [];
+	return { question: input.question, options };
+}
+
+export interface ApplyPatchInfo {
+	files: string[];
+	additions: number;
+	deletions: number;
+	diff: string;
+}
+
+const FILE_ACTION_RE = /^\*\*\* (?:Add|Update|Delete) File: (.+)/;
+const SKIP_LINES =
+	/^(?:\*\*\* (?:Begin|End) Patch|%%bash|```|EOF|apply_patch\b|@@|\*\*\* (?:Move to:|End of File))/;
+
+export function parseApplyPatchInput(
+	input: unknown,
+): ApplyPatchInfo | undefined {
+	const raw =
+		typeof input === "string"
+			? input
+			: isRecord(input) && typeof input.input === "string"
+				? input.input
+				: null;
+	if (!raw) return undefined;
+
+	const files: string[] = [];
+	const out: string[] = [];
+	let hunk: string[] = [];
+	let additions = 0;
+	let deletions = 0;
+
+	const flush = () => {
+		if (hunk.length === 0) return;
+		out.push(hunkHeader(hunk), ...hunk);
+		hunk = [];
+	};
+
+	for (const line of raw.split("\n")) {
+		const fileMatch = FILE_ACTION_RE.exec(line);
+		if (fileMatch) {
+			flush();
+			const path = fileMatch[1].trim();
+			files.push(path);
+			out.push(`--- a/${path}`, `+++ b/${path}`);
+			continue;
+		}
+		if (SKIP_LINES.test(line.trim())) continue;
+
+		if (line.startsWith("+")) additions++;
+		else if (line.startsWith("-")) deletions++;
+
+		if (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) {
+			hunk.push(line);
+		} else {
+			hunk.push(` ${line}`);
+		}
+	}
+	flush();
+
+	if (files.length === 0) return undefined;
+	return { files, additions, deletions, diff: out.join("\n") };
+}
+
+export function shortenPath(filePath: string, maxLen = 50): string {
+	if (filePath.length <= maxLen) return filePath;
+	const parts = filePath.split("/");
+	const fileName = parts.pop() ?? "";
+	if (fileName.length >= maxLen - 4) return `.../${fileName}`;
+	let result = fileName;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const candidate = `${parts[i]}/${result}`;
+		if (candidate.length + 4 > maxLen) break;
+		result = candidate;
+	}
+	return `.../${result}`;
+}
diff --git a/apps/cli/src/tui/views/chat-view.tsx b/apps/cli/src/tui/views/chat-view.tsx
new file mode 100644
index 0000000..58b4357
--- /dev/null
+++ b/apps/cli/src/tui/views/chat-view.tsx
@@ -0,0 +1,169 @@
+import {
+	AutocompleteDropdown,
+	type AutocompleteDropdownProps,
+} from "../components/autocomplete-dropdown";
+import {
+	ChatMessageList,
+	type TranscriptScrollHandle,
+} from "../components/chat-message-list";
+import { InlineToolResponse } from "../components/inline-tool-response";
+import { InputBar, type TextareaHandle } from "../components/input-bar";
+import { QueuedPrompts } from "../components/queued-prompts";
+import {
+	resolveModelDisplayName,
+	resolveModelMaxInputTokens,
+	StatusBar,
+} from "../components/status-bar";
+import { useSession } from "../contexts/session-context";
+import {
+	useTerminalBackground,
+	useTerminalTheme,
+} from "../hooks/use-terminal-background";
+import {
+	getInputRuleColor,
+	getModeAccent,
+	getModeInputBackground,
+	getModeInputForeground,
+	getModeInputPlaceholder,
+} from "../palette";
+import type {
+	QueuedPromptItem,
+	RuntimeToolInteraction,
+	TuiProps,
+} from "../types";
+
+export function ChatView(props: {
+	config: TuiProps["config"];
+	inputValue: string;
+	inputKey: number;
+	onSubmit: () => void;
+	onContentChange: (text: string) => void;
+	onImagePaste: (dataUrl: string) => string;
+	onLargeTextPaste: (text: string) => string;
+	onInputFocusRequest?: () => void;
+	repoStatus: {
+		branch: string | null;
+		diffStats: {
+			files: number;
+			additions: number;
+			deletions: number;
+		} | null;
+	};
+	textareaRef?: React.MutableRefObject<TextareaHandle | null>;
+	transcriptScrollRef?: React.Ref<TranscriptScrollHandle>;
+	loadIndividualSubscriptionPlans?: TuiProps["loadIndividualSubscriptionPlans"];
+	autocomplete?: AutocompleteDropdownProps;
+	queuedPrompts?: QueuedPromptItem[];
+	selectedQueuedPromptId?: string | null;
+	editingQueuedPrompt?: QueuedPromptItem;
+	onQueuedPromptEditConfirm: (id: string, prompt: string) => void;
+	onToggleMode: () => void;
+	runtimeInteraction?: RuntimeToolInteraction | null;
+	onResolveToolApproval: (id: number, approved: boolean) => void;
+	onResolveAskQuestion: (id: number, answer: string | null) => void;
+}) {
+	const {
+		config,
+		inputValue,
+		inputKey,
+		onSubmit,
+		onContentChange,
+		onImagePaste,
+		onLargeTextPaste,
+		repoStatus,
+	} = props;
+	const session = useSession();
+	const terminalBg = useTerminalBackground();
+	const terminalTheme = useTerminalTheme();
+	const accent = getModeAccent(session.uiMode, terminalTheme);
+	const inputBackground = getModeInputBackground(session.uiMode, terminalBg);
+	const inputRuleColor = getInputRuleColor(terminalBg);
+	const inputForeground = getModeInputForeground(session.uiMode, terminalBg);
+	const inputPlaceholder = getModeInputPlaceholder(session.uiMode, terminalBg);
+	const placeholder =
+		session.uiMode === "plan" ? "Plan something..." : "Ask anything...";
+	const modelDisplayName = resolveModelDisplayName(config);
+	const maxInputTokens = resolveModelMaxInputTokens(config);
+	const runtimeInteraction = props.runtimeInteraction ?? null;
+
+	return (
+		<box flexDirection="column" width="100%" height="100%">
+			<ChatMessageList
+				ref={props.transcriptScrollRef}
+				entries={session.entries}
+				isStreaming={session.isStreaming}
+				loadIndividualSubscriptionPlans={props.loadIndividualSubscriptionPlans}
+				uiMode={session.uiMode}
+			/>
+
+			<box flexDirection="column" flexShrink={0}>
+				{runtimeInteraction ? (
+					<box marginBottom={1}>
+						<InlineToolResponse
+							key={runtimeInteraction.id}
+							interaction={runtimeInteraction}
+							accent={accent}
+							inputBackground={inputBackground}
+							inputForeground={inputForeground}
+							inputPlaceholder={inputPlaceholder}
+							onResolveToolApproval={props.onResolveToolApproval}
+							onResolveAskQuestion={props.onResolveAskQuestion}
+						/>
+					</box>
+				) : (
+					<>
+						{props.autocomplete && (
+							<AutocompleteDropdown {...props.autocomplete} accent={accent} />
+						)}
+
+						{props.queuedPrompts && props.queuedPrompts.length > 0 && (
+							<QueuedPrompts
+								items={props.queuedPrompts}
+								selectedId={props.selectedQueuedPromptId ?? null}
+								editingId={props.editingQueuedPrompt?.id ?? null}
+								onEditConfirm={props.onQueuedPromptEditConfirm}
+							/>
+						)}
+
+						<box>
+							<InputBar
+								accent={accent}
+								ruleColor={inputRuleColor}
+								inputForeground={inputForeground}
+								inputPlaceholder={inputPlaceholder}
+								placeholder={placeholder}
+								initialValue={inputValue}
+								inputKey={inputKey}
+								onSubmit={onSubmit}
+								onContentChange={onContentChange}
+								onImagePaste={onImagePaste}
+								onLargeTextPaste={onLargeTextPaste}
+								onFocusRequest={props.onInputFocusRequest}
+								textareaRef={props.textareaRef}
+							/>
+						</box>
+					</>
+				)}
+
+				<StatusBar
+					providerId={config.providerId}
+					modelId={modelDisplayName}
+					totalTokens={session.lastTotalTokens}
+					totalCost={session.lastTotalCost}
+					maxInputTokens={maxInputTokens}
+					uiMode={session.uiMode}
+					autoApproveAll={session.autoApproveAll}
+					workspaceName={
+						config.workspaceRoot
+							? (config.workspaceRoot.split("/").pop() ?? "")
+							: ""
+					}
+					gitBranch={repoStatus.branch}
+					gitDiffStats={repoStatus.diffStats}
+					onToggleMode={props.onToggleMode}
+					variant="chat"
+				/>
+			</box>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/views/config-view-helpers.ts b/apps/cli/src/tui/views/config-view-helpers.ts
new file mode 100644
index 0000000..0a4c4b5
--- /dev/null
+++ b/apps/cli/src/tui/views/config-view-helpers.ts
@@ -0,0 +1,243 @@
+import type {
+	InteractiveConfigData,
+	InteractiveConfigItem,
+	InteractiveConfigTab,
+} from "../../tui/interactive-config";
+import { isToggleableInteractiveConfigItem } from "../../tui/interactive-config";
+
+export type ConfigAction =
+	| { kind: "open-provider" }
+	| { kind: "open-model" }
+	| { kind: "toggle-item"; item: InteractiveConfigItem }
+	| { kind: "delete-item"; item: InteractiveConfigItem }
+	| {
+			kind: "ext-detail";
+			item: InteractiveConfigItem;
+	  }
+	| { kind: "open-mcp" };
+
+const CONFIG_TABS: InteractiveConfigTab[] = [
+	"general",
+	"mcp",
+	"skills",
+	"rules",
+	"tools",
+	"plugins",
+	"agents",
+	"hooks",
+];
+
+export function getConfigTabs(): InteractiveConfigTab[] {
+	return CONFIG_TABS;
+}
+
+export function resolveInitialConfigTab(
+	tab: InteractiveConfigTab | undefined,
+): InteractiveConfigTab {
+	return tab && CONFIG_TABS.includes(tab) ? tab : "general";
+}
+
+export function getAdjacentConfigTab(
+	currentTab: InteractiveConfigTab,
+	direction: "left" | "right",
+): InteractiveConfigTab {
+	const currentIndex = CONFIG_TABS.indexOf(currentTab);
+	const safeIndex = currentIndex >= 0 ? currentIndex : 0;
+	const delta = direction === "left" ? -1 : 1;
+	const nextIndex =
+		(safeIndex + delta + CONFIG_TABS.length) % CONFIG_TABS.length;
+	return CONFIG_TABS[nextIndex] ?? "general";
+}
+
+export function toTabLabel(tab: InteractiveConfigTab): string {
+	switch (tab) {
+		case "general":
+			return "General";
+		case "tools":
+			return "Tools";
+		case "plugins":
+			return "Plugins";
+		case "agents":
+			return "Agents";
+		case "hooks":
+			return "Hooks";
+		case "skills":
+			return "Skills";
+		case "rules":
+			return "Rules";
+		case "mcp":
+			return "MCP";
+		case "workflows":
+			return "Workflows";
+	}
+}
+
+function sourceRank(source: InteractiveConfigItem["source"]): number {
+	switch (source) {
+		case "builtin":
+			return 0;
+		case "workspace":
+			return 1;
+		case "workspace-plugin":
+			return 2;
+		case "global":
+			return 3;
+		case "global-plugin":
+			return 4;
+	}
+}
+
+function sortBySourceThenName(
+	items: InteractiveConfigItem[],
+): InteractiveConfigItem[] {
+	return [...items].sort((a, b) => {
+		if (a.source !== b.source) {
+			return sourceRank(a.source) - sourceRank(b.source);
+		}
+		return a.name.localeCompare(b.name);
+	});
+}
+
+export function resolveActiveConfigItems(
+	configData: InteractiveConfigData,
+	configTab: InteractiveConfigTab,
+): InteractiveConfigItem[] {
+	switch (configTab) {
+		case "general":
+			return [];
+		case "tools":
+			return sortBySourceThenName(configData.tools);
+		case "plugins":
+			return sortBySourceThenName(configData.plugins);
+		case "agents":
+			return sortBySourceThenName(configData.agents);
+		case "hooks":
+			return sortBySourceThenName(configData.hooks);
+		case "skills":
+			return sortBySourceThenName([
+				...configData.workflows,
+				...configData.skills,
+			]);
+		case "rules":
+			return sortBySourceThenName(configData.rules);
+		case "mcp":
+			return sortBySourceThenName(configData.mcp);
+		case "workflows":
+			return sortBySourceThenName(configData.workflows);
+	}
+}
+
+export function isToggleableConfigItem(item: InteractiveConfigItem): boolean {
+	return isToggleableInteractiveConfigItem(item);
+}
+
+export function isDeletableConfigItem(item: InteractiveConfigItem): boolean {
+	return item.kind === "plugin";
+}
+
+export function resolveConfigItemSelectAction(
+	item: InteractiveConfigItem,
+): ConfigAction {
+	if (
+		typeof item.enabled === "boolean" &&
+		item.kind !== "skill" &&
+		isToggleableConfigItem(item)
+	) {
+		return { kind: "toggle-item", item };
+	}
+
+	return {
+		kind: "ext-detail",
+		item,
+	};
+}
+
+export function resolveConfigItemToggleAction(
+	item: InteractiveConfigItem,
+): ConfigAction | undefined {
+	if (typeof item.enabled !== "boolean" || !isToggleableConfigItem(item)) {
+		return undefined;
+	}
+	return { kind: "toggle-item", item };
+}
+
+export function resolveConfigItemDeleteAction(
+	item: InteractiveConfigItem,
+): ConfigAction | undefined {
+	if (!isDeletableConfigItem(item)) {
+		return undefined;
+	}
+	return { kind: "delete-item", item };
+}
+
+export function isInlineConfigAction(
+	action: ConfigAction | undefined,
+): boolean {
+	return action?.kind === "toggle-item";
+}
+
+export function canToggleConfigFooterRow(
+	row:
+		| { kind: "toggle" }
+		| { kind: "ext"; enabled?: boolean; item: InteractiveConfigItem }
+		| { kind: string }
+		| undefined,
+): boolean {
+	if (!row) {
+		return false;
+	}
+	if (row.kind === "toggle") {
+		return true;
+	}
+	return (
+		row.kind === "ext" &&
+		"item" in row &&
+		typeof row.enabled === "boolean" &&
+		isToggleableConfigItem(row.item)
+	);
+}
+
+export function canDeleteConfigFooterRow(
+	row:
+		| { kind: "ext"; item: InteractiveConfigItem }
+		| { kind: string }
+		| undefined,
+): boolean {
+	return (
+		row?.kind === "ext" && "item" in row && isDeletableConfigItem(row.item)
+	);
+}
+
+export function getConfigFooterText({
+	canToggle = false,
+	canDelete = false,
+}: {
+	canToggle?: boolean;
+	canDelete?: boolean;
+} = {}): string {
+	const actions = ["←/→ switch tabs", "↑/↓ navigate", "Tab/Enter select"];
+	if (canToggle) {
+		actions.push("Space toggle");
+	}
+	if (canDelete) {
+		actions.push("D delete");
+	}
+	actions.push("Esc close");
+	return actions.join(", ");
+}
+
+export function getConfigItemDisplayName(name: string): string {
+	return name;
+}
+
+export function getPluginDiagnosticsLoadingText(
+	tab: InteractiveConfigTab,
+): string | undefined {
+	if (tab === "tools") {
+		return "Loading plugin tools...";
+	}
+	if (tab === "plugins") {
+		return "Loading plugin diagnostics...";
+	}
+	return undefined;
+}
diff --git a/apps/cli/src/tui/views/config-view.test.ts b/apps/cli/src/tui/views/config-view.test.ts
new file mode 100644
index 0000000..1697223
--- /dev/null
+++ b/apps/cli/src/tui/views/config-view.test.ts
@@ -0,0 +1,167 @@
+import { describe, expect, it } from "vitest";
+import type { InteractiveConfigItem } from "../../tui/interactive-config";
+import {
+	canToggleConfigFooterRow,
+	getAdjacentConfigTab,
+	getConfigFooterText,
+	getConfigItemDisplayName,
+	isInlineConfigAction,
+	isToggleableConfigItem,
+	resolveConfigItemSelectAction,
+	resolveConfigItemToggleAction,
+	resolveInitialConfigTab,
+} from "./config-view-helpers";
+
+function createItem(
+	overrides: Partial<InteractiveConfigItem> &
+		Pick<InteractiveConfigItem, "kind">,
+): InteractiveConfigItem {
+	return {
+		id: "item-id",
+		name: "item-name",
+		path: "/tmp/item",
+		enabled: true,
+		source: "workspace",
+		...overrides,
+	};
+}
+
+describe("config view helpers", () => {
+	it("treats skill rows as toggleable", () => {
+		expect(isToggleableConfigItem(createItem({ kind: "skill" }))).toBe(true);
+	});
+
+	it("does not treat workflow rows as toggleable", () => {
+		expect(isToggleableConfigItem(createItem({ kind: "workflow" }))).toBe(
+			false,
+		);
+	});
+
+	it("does not treat rule, agent, or hook rows as toggleable", () => {
+		expect(isToggleableConfigItem(createItem({ kind: "rule" }))).toBe(false);
+		expect(isToggleableConfigItem(createItem({ kind: "agent" }))).toBe(false);
+		expect(isToggleableConfigItem(createItem({ kind: "hook" }))).toBe(false);
+	});
+
+	it("keeps plugin tool rows toggleable", () => {
+		expect(
+			isToggleableConfigItem(
+				createItem({ kind: "tool", source: "workspace-plugin" }),
+			),
+		).toBe(true);
+	});
+
+	it("treats plugin rows as toggleable", () => {
+		expect(isToggleableConfigItem(createItem({ kind: "plugin" }))).toBe(true);
+	});
+
+	it("treats MCP rows as toggleable", () => {
+		expect(isToggleableConfigItem(createItem({ kind: "mcp" }))).toBe(true);
+	});
+
+	it("does not treat plugin MCP rows as toggleable", () => {
+		expect(
+			isToggleableConfigItem(
+				createItem({
+					kind: "mcp",
+					pluginName: "plugin",
+					source: "workspace-plugin",
+				}),
+			),
+		).toBe(false);
+	});
+
+	it("resolves Enter/Tab on a skill row to details", () => {
+		const skill = createItem({
+			kind: "skill",
+			name: "review",
+			path: "/tmp/review/SKILL.md",
+			source: "workspace",
+		});
+
+		expect(resolveConfigItemSelectAction(skill)).toEqual({
+			kind: "ext-detail",
+			item: skill,
+		});
+	});
+
+	it("resolves Space on a skill row to toggle", () => {
+		const skill = createItem({ kind: "skill", name: "review" });
+
+		expect(resolveConfigItemToggleAction(skill)).toEqual({
+			kind: "toggle-item",
+			item: skill,
+		});
+	});
+
+	it("mentions Space toggle in the footer for toggleable rows", () => {
+		expect(getConfigFooterText({ canToggle: true })).toContain("Space toggle");
+	});
+
+	it("omits Space toggle in the footer for non-toggleable rows", () => {
+		expect(getConfigFooterText({ canToggle: false })).not.toContain(
+			"Space toggle",
+		);
+		expect(getConfigFooterText()).not.toContain("Space toggle");
+	});
+
+	it("derives footer toggle affordance from selected row behavior", () => {
+		const skill = createItem({ kind: "skill" });
+		const hook = createItem({ kind: "hook" });
+
+		expect(canToggleConfigFooterRow({ kind: "provider" })).toBe(false);
+		expect(canToggleConfigFooterRow({ kind: "toggle" })).toBe(true);
+		expect(
+			canToggleConfigFooterRow({
+				kind: "ext",
+				enabled: skill.enabled,
+				item: skill,
+			}),
+		).toBe(true);
+		expect(
+			canToggleConfigFooterRow({
+				kind: "ext",
+				enabled: hook.enabled,
+				item: hook,
+			}),
+		).toBe(false);
+		expect(canToggleConfigFooterRow({ kind: "mcp-manager" })).toBe(false);
+	});
+
+	it("supports restoring and advancing the active settings tab", () => {
+		expect(resolveInitialConfigTab("skills")).toBe("skills");
+		expect(resolveInitialConfigTab(undefined)).toBe("general");
+		expect(getAdjacentConfigTab("mcp", "right")).toBe("skills");
+		expect(getAdjacentConfigTab("skills", "left")).toBe("mcp");
+	});
+
+	it("handles toggle actions inline so the settings dialog stays open", () => {
+		const skill = createItem({ kind: "skill", name: "review" });
+		const plugin = createItem({ kind: "plugin", name: "workspace-plugin" });
+		const mcp = createItem({ kind: "mcp", name: "docs" });
+		const builtinTool = createItem({
+			kind: "tool",
+			name: "read_file",
+			source: "builtin",
+		});
+
+		expect(isInlineConfigAction(resolveConfigItemToggleAction(skill))).toBe(
+			true,
+		);
+		expect(isInlineConfigAction(resolveConfigItemSelectAction(skill))).toBe(
+			false,
+		);
+		expect(isInlineConfigAction(resolveConfigItemSelectAction(plugin))).toBe(
+			true,
+		);
+		expect(isInlineConfigAction(resolveConfigItemSelectAction(mcp))).toBe(true);
+		expect(
+			isInlineConfigAction(resolveConfigItemSelectAction(builtinTool)),
+		).toBe(true);
+		expect(getConfigFooterText({ canToggle: true })).not.toContain("details");
+	});
+
+	it("returns item names without decoration", () => {
+		expect(getConfigItemDisplayName("review")).toBe("review");
+	});
+});
diff --git a/apps/cli/src/tui/views/config-view.tsx b/apps/cli/src/tui/views/config-view.tsx
new file mode 100644
index 0000000..6a186cf
--- /dev/null
+++ b/apps/cli/src/tui/views/config-view.tsx
@@ -0,0 +1,919 @@
+import { readGlobalSettings, setAutoUpdateEnabledGlobally } from "@cline/core";
+import { useTerminalDimensions } from "@opentui/react";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useEffect, useMemo, useState } from "react";
+import type {
+	InteractiveConfigData,
+	InteractiveConfigItem,
+	InteractiveConfigTab,
+	LoadInteractiveConfigDataOptions,
+} from "../../tui/interactive-config";
+import {
+	formatCliCompactionMode,
+	getNextCliCompactionMode,
+} from "../../utils/compaction-mode";
+import type { CliCompactionMode, Config } from "../../utils/types";
+import { getMcpManagerEntryStatus } from "../components/dialogs/mcp-manager-dialog";
+import { resolveModelDisplayName } from "../components/status-bar";
+import { getModeAccent, palette } from "../palette";
+import {
+	type ConfigAction,
+	canDeleteConfigFooterRow,
+	canToggleConfigFooterRow,
+	getAdjacentConfigTab,
+	getConfigFooterText,
+	getConfigItemDisplayName,
+	getConfigTabs,
+	getPluginDiagnosticsLoadingText,
+	isInlineConfigAction,
+	isToggleableConfigItem,
+	resolveActiveConfigItems,
+	resolveConfigItemDeleteAction,
+	resolveConfigItemSelectAction,
+	resolveConfigItemToggleAction,
+	resolveInitialConfigTab,
+	toTabLabel,
+} from "./config-view-helpers";
+
+type ConfigRow =
+	| { kind: "spacer" }
+	| { kind: "head"; label: string; indent?: number }
+	| { kind: "detail"; text: string }
+	| { kind: "provider" }
+	| { kind: "model" }
+	| { kind: "toggle"; id: string; label: string }
+	| { kind: "tool-group"; label: string; rightLabel: string; indent?: number }
+	| {
+			kind: "ext";
+			name: string;
+			path: string;
+			source: InteractiveConfigItem["source"];
+			enabled?: boolean;
+			description?: string;
+			item: InteractiveConfigItem;
+			indent?: number;
+			rightLabel?: string;
+	  }
+	| { kind: "mcp-manager" };
+
+function sourceRank(source: InteractiveConfigItem["source"]): number {
+	switch (source) {
+		case "builtin":
+			return 0;
+		case "workspace":
+			return 1;
+		case "workspace-plugin":
+			return 2;
+		case "global":
+			return 3;
+		case "global-plugin":
+			return 4;
+	}
+}
+
+function sortBySourceThenName(
+	items: InteractiveConfigItem[],
+): InteractiveConfigItem[] {
+	return [...items].sort((a, b) => {
+		if (a.source !== b.source) {
+			return sourceRank(a.source) - sourceRank(b.source);
+		}
+		return a.name.localeCompare(b.name);
+	});
+}
+
+function isNavigable(row: ConfigRow): boolean {
+	return (
+		row.kind === "provider" ||
+		row.kind === "model" ||
+		row.kind === "toggle" ||
+		row.kind === "ext" ||
+		row.kind === "mcp-manager"
+	);
+}
+
+function isToggleableRow(
+	row: ConfigRow,
+): row is Extract<ConfigRow, { kind: "ext" }> {
+	return (
+		row.kind === "ext" &&
+		typeof row.enabled === "boolean" &&
+		isToggleableConfigItem(row.item)
+	);
+}
+
+function getVisibleWindow<T>(
+	items: T[],
+	center: number,
+	maxVisible: number,
+): { items: T[]; startIndex: number } {
+	if (items.length <= maxVisible) return { items, startIndex: 0 };
+	const half = Math.floor(maxVisible / 2);
+	let start = Math.max(0, center - half);
+	const end = Math.min(items.length, start + maxVisible);
+	if (end - start < maxVisible) start = Math.max(0, end - maxVisible);
+	return { items: items.slice(start, end), startIndex: start };
+}
+
+const COMPACTION_MODE_COLORS: Record<CliCompactionMode, string> = {
+	agentic: palette.success,
+	basic: "yellow",
+	off: "gray",
+};
+
+export interface ConfigPanelProps extends ChoiceContext<ConfigAction> {
+	config: Config;
+	configData: InteractiveConfigData;
+	loadConfigData?: (
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData>;
+	providerDisplayName: string;
+	currentMode: string;
+	currentCompactionMode: CliCompactionMode;
+	initialTab?: InteractiveConfigTab;
+	onActiveTabChange?: (tab: InteractiveConfigTab) => void;
+	onToggleConfigItem?: (
+		item: InteractiveConfigItem,
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData | undefined>;
+	onDeleteConfigItem?: (
+		item: InteractiveConfigItem,
+		options?: LoadInteractiveConfigDataOptions,
+	) => Promise<InteractiveConfigData | undefined>;
+	onToggleMode: () => void;
+	onToggleAutoApprove: () => void;
+	onSetCompactionMode: (mode: CliCompactionMode) => void;
+}
+
+function groupToolItems(
+	items: InteractiveConfigItem[],
+): Array<[string, InteractiveConfigItem[]]> {
+	const groups = new Map<string, InteractiveConfigItem[]>();
+	for (const item of items) {
+		const groupKey = `${item.source}:${item.pluginPath ?? item.path}:${item.pluginName}`;
+		const group = groups.get(groupKey) ?? [];
+		group.push(item);
+		groups.set(groupKey, group);
+	}
+
+	return [...groups.entries()].sort((left, right) => {
+		const leftItem = left[1][0];
+		const rightItem = right[1][0];
+		const leftSource = leftItem?.source ?? "global-plugin";
+		const rightSource = rightItem?.source ?? "global-plugin";
+		if (leftSource !== rightSource) {
+			return sourceRank(leftSource) - sourceRank(rightSource);
+		}
+		return (leftItem?.pluginName ?? "").localeCompare(
+			rightItem?.pluginName ?? "",
+		);
+	});
+}
+
+function getSharedToolNames(items: InteractiveConfigItem[]): Set<string> {
+	const counts = new Map<string, number>();
+	for (const item of items) {
+		counts.set(item.name, (counts.get(item.name) ?? 0) + 1);
+	}
+	return new Set(
+		[...counts.entries()]
+			.filter(([, count]) => count > 1)
+			.map(([name]) => name),
+	);
+}
+
+function appendToolGroupRows(
+	rows: ConfigRow[],
+	groups: Array<[string, InteractiveConfigItem[]]>,
+	sharedToolNames: ReadonlySet<string>,
+): void {
+	for (const [, groupItems] of groups) {
+		const first = groupItems[0];
+		const enabledCount = groupItems.filter(
+			(item) => item.enabled !== false,
+		).length;
+		rows.push({
+			kind: "tool-group",
+			label: first?.pluginName ?? "plugin",
+			rightLabel: `${enabledCount}/${groupItems.length} tools enabled`,
+			indent: 2,
+		});
+
+		for (const item of sortBySourceThenName(groupItems)) {
+			rows.push({
+				kind: "ext",
+				name: item.name,
+				path: item.path,
+				source: item.source,
+				enabled: item.enabled,
+				description: item.description,
+				item,
+				indent: 4,
+				rightLabel: sharedToolNames.has(item.name) ? "shared tool name" : "",
+			});
+		}
+	}
+}
+
+function appendExtRows(
+	rows: ConfigRow[],
+	items: InteractiveConfigItem[],
+	indent?: number,
+): void {
+	for (const item of sortBySourceThenName(items)) {
+		rows.push({
+			kind: "ext",
+			name: item.name,
+			path: item.path,
+			source: item.source,
+			enabled: item.enabled,
+			description: item.description,
+			item,
+			indent,
+		});
+	}
+}
+
+function appendToolRows(
+	rows: ConfigRow[],
+	items: InteractiveConfigItem[],
+): void {
+	const builtinTools = sortBySourceThenName(
+		items.filter((item) => !item.pluginName),
+	);
+	if (builtinTools.length > 0) {
+		rows.push({ kind: "head", label: "Built-in" });
+		appendExtRows(rows, builtinTools);
+	}
+
+	const pluginToolItems = items.filter((item) => item.pluginName);
+	const pluginGroups = groupToolItems(pluginToolItems);
+	if (pluginGroups.length > 0) {
+		rows.push({ kind: "head", label: "Plugins" });
+		appendToolGroupRows(
+			rows,
+			pluginGroups,
+			getSharedToolNames(pluginToolItems),
+		);
+	}
+}
+
+function hasPluginDiagnostics(data: InteractiveConfigData): boolean {
+	return (
+		data.pluginDiagnosticsLoaded || data.tools.some((item) => item.pluginName)
+	);
+}
+
+function appendSkillRows(
+	rows: ConfigRow[],
+	items: InteractiveConfigItem[],
+): void {
+	const detectedItems = items.filter((item) => !item.pluginName);
+	if (detectedItems.length > 0) {
+		rows.push({ kind: "head", label: "Detected" });
+		appendExtRows(rows, detectedItems);
+	}
+
+	const pluginItems = items.filter((item) => item.pluginName);
+	const pluginGroups = groupToolItems(pluginItems);
+	if (pluginGroups.length > 0) {
+		rows.push({ kind: "head", label: "Plugins" });
+		for (const [, groupItems] of pluginGroups) {
+			const first = groupItems[0];
+			const enabledCount = groupItems.filter(
+				(item) => item.enabled !== false,
+			).length;
+			rows.push({
+				kind: "tool-group",
+				label: first?.pluginName ?? "plugin",
+				rightLabel: `${enabledCount}/${groupItems.length} skills enabled`,
+				indent: 2,
+			});
+			appendExtRows(rows, groupItems, 4);
+		}
+	}
+}
+
+function withOptimisticToggle(
+	data: InteractiveConfigData,
+	item: InteractiveConfigItem,
+): InteractiveConfigData {
+	if (typeof item.enabled !== "boolean") {
+		return data;
+	}
+	const nextEnabled = !item.enabled;
+	const matchesItem = (candidate: InteractiveConfigItem) =>
+		candidate.id === item.id &&
+		candidate.path === item.path &&
+		candidate.kind === item.kind;
+	const toolNames = new Set(
+		(item.toolNames && item.toolNames.length > 0
+			? item.toolNames
+			: [item.name]
+		).filter(Boolean),
+	);
+	const updateItems = (items: InteractiveConfigItem[]) =>
+		items.map((candidate) => {
+			if (matchesItem(candidate)) {
+				return { ...candidate, enabled: nextEnabled };
+			}
+			if (
+				item.kind === "plugin" &&
+				(candidate.path === item.path || candidate.pluginPath === item.path)
+			) {
+				return { ...candidate, enabled: nextEnabled };
+			}
+			return candidate;
+		});
+	const updateTools = (items: InteractiveConfigItem[]) =>
+		items.map((candidate) => {
+			if (matchesItem(candidate)) {
+				return { ...candidate, enabled: nextEnabled };
+			}
+			if (
+				item.kind === "tool" &&
+				toolNames.has(candidate.name) &&
+				(candidate.source === "builtin" ||
+					candidate.source === "workspace-plugin" ||
+					candidate.source === "global-plugin")
+			) {
+				return { ...candidate, enabled: nextEnabled };
+			}
+			if (item.kind === "plugin" && candidate.path === item.path) {
+				return { ...candidate, enabled: nextEnabled };
+			}
+			return candidate;
+		});
+
+	return {
+		...data,
+		workflows: updateItems(data.workflows),
+		rules: updateItems(data.rules),
+		skills: updateItems(data.skills),
+		hooks: updateItems(data.hooks),
+		agents: updateItems(data.agents),
+		plugins: updateItems(data.plugins),
+		mcp: updateItems(data.mcp),
+		tools: updateTools(data.tools),
+	};
+}
+
+function getPluginLoadErrorLabel(
+	item: InteractiveConfigItem,
+): string | undefined {
+	if (!item.loadError) {
+		return undefined;
+	}
+	const lines = item.loadError.split("\n");
+	const first = lines[0] ?? item.loadError;
+	return lines.length > 1 ? `${first} (+${lines.length - 1} more)` : first;
+}
+
+export function ConfigPanelContent(props: ConfigPanelProps) {
+	const {
+		resolve,
+		dismiss,
+		dialogId,
+		config,
+		loadConfigData,
+		onActiveTabChange,
+	} = props;
+	const { height } = useTerminalDimensions();
+
+	const [mode, setMode] = useState(props.currentMode);
+	const [autoApprove, setAutoApprove] = useState(
+		config.toolPolicies["*"]?.autoApprove !== false,
+	);
+	const [autoUpdateEnabled, setAutoUpdateEnabled] = useState(
+		() => readGlobalSettings().autoUpdateEnabled,
+	);
+	const [verbose, setVerbose] = useState(config.verbose);
+	const [compactionMode, setCompactionMode] = useState(
+		props.currentCompactionMode,
+	);
+	const [activeTab, setActiveTab] = useState<InteractiveConfigTab>(() =>
+		resolveInitialConfigTab(props.initialTab),
+	);
+	const [configData, setConfigData] = useState(props.configData);
+	const [pluginToolsLoaded, setPluginToolsLoaded] = useState(
+		hasPluginDiagnostics(props.configData),
+	);
+	const [pluginToolsLoading, setPluginToolsLoading] = useState(false);
+	const [pluginToolsError, setPluginToolsError] = useState<
+		string | undefined
+	>();
+	const [togglingItemId, setTogglingItemId] = useState<string | null>(null);
+	const [toggleError, setToggleError] = useState<string | undefined>();
+	const [navPos, setNavPos] = useState(0);
+
+	const displayName = resolveModelDisplayName(config);
+
+	useEffect(() => {
+		onActiveTabChange?.(activeTab);
+	}, [activeTab, onActiveTabChange]);
+
+	useEffect(() => {
+		if (
+			(activeTab !== "tools" && activeTab !== "plugins") ||
+			pluginToolsLoaded ||
+			pluginToolsError ||
+			!loadConfigData
+		) {
+			return;
+		}
+
+		let cancelled = false;
+		setPluginToolsLoading(true);
+		setPluginToolsError(undefined);
+		loadConfigData({ includePluginTools: true })
+			.then((nextData) => {
+				if (cancelled) {
+					return;
+				}
+				setConfigData(nextData);
+				setPluginToolsLoaded(true);
+			})
+			.catch((error) => {
+				if (cancelled) {
+					return;
+				}
+				const message = error instanceof Error ? error.message : String(error);
+				setPluginToolsError(`Failed to load plugin diagnostics: ${message}`);
+			})
+			.finally(() => {
+				if (!cancelled) {
+					setPluginToolsLoading(false);
+				}
+			});
+
+		return () => {
+			cancelled = true;
+		};
+	}, [activeTab, pluginToolsError, pluginToolsLoaded, loadConfigData]);
+
+	const rows = useMemo(() => {
+		const r: ConfigRow[] = [];
+
+		if (activeTab === "general") {
+			r.push({ kind: "provider" });
+			r.push({ kind: "model" });
+			r.push({ kind: "toggle", id: "mode", label: "Mode" });
+			r.push({ kind: "toggle", id: "compaction", label: "Compaction" });
+			r.push({
+				kind: "toggle",
+				id: "auto-approve",
+				label: "Auto-approve all",
+			});
+			r.push({ kind: "toggle", id: "auto-update", label: "Auto update" });
+			r.push({ kind: "toggle", id: "verbose", label: "Verbose" });
+		} else {
+			const activeItems = resolveActiveConfigItems(configData, activeTab);
+			r.push({
+				kind: "head",
+				label: `${toTabLabel(activeTab)} (${activeItems.length})`,
+			});
+
+			if (activeItems.length === 0 && !pluginToolsLoading) {
+				r.push({
+					kind: "detail",
+					text: `No ${toTabLabel(activeTab).toLowerCase()} found.`,
+				});
+			} else if (activeTab === "tools") {
+				appendToolRows(r, activeItems);
+				const loadingText = getPluginDiagnosticsLoadingText(activeTab);
+				if (pluginToolsLoading && loadingText) {
+					r.push({
+						kind: "detail",
+						text: loadingText,
+					});
+				}
+				if (pluginToolsError) {
+					r.push({
+						kind: "detail",
+						text: pluginToolsError,
+					});
+				}
+			} else if (activeTab === "skills") {
+				appendSkillRows(r, activeItems);
+			} else {
+				for (const item of activeItems) {
+					r.push({
+						kind: "ext",
+						name: item.name,
+						path: item.path,
+						source: item.source,
+						enabled: item.enabled,
+						description: item.description,
+						item,
+						rightLabel:
+							activeTab === "mcp"
+								? getMcpManagerEntryStatus({
+										description: item.description,
+										lastError: item.loadError,
+									})
+								: getPluginLoadErrorLabel(item),
+					});
+				}
+				if (activeTab === "plugins" && pluginToolsLoading) {
+					const loadingText = getPluginDiagnosticsLoadingText(activeTab);
+					r.push({
+						kind: "detail",
+						text: loadingText ?? "Loading plugin diagnostics...",
+					});
+				}
+				if (activeTab === "plugins" && pluginToolsError) {
+					r.push({
+						kind: "detail",
+						text: pluginToolsError,
+					});
+				}
+			}
+
+			if (activeTab === "mcp") {
+				r.push({ kind: "mcp-manager" });
+			}
+		}
+
+		return r;
+	}, [activeTab, configData, pluginToolsError, pluginToolsLoading]);
+
+	const navIndices = useMemo(
+		() => rows.map((r, i) => (isNavigable(r) ? i : -1)).filter((i) => i >= 0),
+		[rows],
+	);
+
+	const clampedNavPos = Math.min(navPos, Math.max(0, navIndices.length - 1));
+	const selectedRowIdx = navIndices[clampedNavPos] ?? 0;
+	const selectedRow = rows[selectedRowIdx];
+	const canToggleSelectedRow = canToggleConfigFooterRow(selectedRow);
+	const canDeleteSelectedRow = Boolean(
+		props.onDeleteConfigItem && canDeleteConfigFooterRow(selectedRow),
+	);
+
+	const setNavPosition = (nextNavPos: number) => {
+		setNavPos(nextNavPos);
+	};
+
+	const handleInlineToggle = async (item: InteractiveConfigItem) => {
+		if (!props.onToggleConfigItem || togglingItemId) return;
+		const previousData = configData;
+		setTogglingItemId(item.id);
+		setToggleError(undefined);
+		setConfigData((current) => withOptimisticToggle(current, item));
+		try {
+			const nextData = await props.onToggleConfigItem(item, {
+				includePluginTools: pluginToolsLoaded,
+			});
+			if (nextData) {
+				setConfigData(nextData);
+				setPluginToolsLoaded(hasPluginDiagnostics(nextData));
+			} else if (item.kind === "plugin" && loadConfigData) {
+				const refreshedData = await loadConfigData({
+					includePluginTools: true,
+				});
+				setConfigData(refreshedData);
+				setPluginToolsLoaded(hasPluginDiagnostics(refreshedData));
+				setPluginToolsError(undefined);
+			}
+		} catch (error) {
+			setConfigData(previousData);
+			const message = error instanceof Error ? error.message : String(error);
+			setToggleError(`Failed to update ${item.name}: ${message}`);
+		} finally {
+			setTogglingItemId(null);
+		}
+	};
+
+	const handleSelect = () => {
+		const row = rows[selectedRowIdx];
+		if (!row) return;
+		switch (row.kind) {
+			case "provider":
+				resolve({ kind: "open-provider" });
+				break;
+			case "model":
+				resolve({ kind: "open-model" });
+				break;
+			case "toggle":
+				switch (row.id) {
+					case "mode":
+						setMode(mode === "plan" ? "act" : "plan");
+						props.onToggleMode();
+						break;
+					case "auto-approve":
+						setAutoApprove(!autoApprove);
+						props.onToggleAutoApprove();
+						break;
+					case "auto-update":
+						setAutoUpdateEnabled((previous) => {
+							const next = !previous;
+							setAutoUpdateEnabledGlobally(next);
+							return next;
+						});
+						break;
+					case "compaction": {
+						const nextMode = getNextCliCompactionMode(compactionMode);
+						setCompactionMode(nextMode);
+						props.onSetCompactionMode(nextMode);
+						break;
+					}
+					case "verbose":
+						config.verbose = !verbose;
+						setVerbose(!verbose);
+						break;
+				}
+				break;
+			case "ext": {
+				const action = resolveConfigItemSelectAction(row.item);
+				if (isInlineConfigAction(action)) {
+					void handleInlineToggle(row.item);
+				} else {
+					resolve(action);
+				}
+				break;
+			}
+			case "mcp-manager":
+				resolve({ kind: "open-mcp" });
+				break;
+			case "tool-group":
+				break;
+		}
+	};
+
+	const handleToggleSelected = () => {
+		const row = rows[selectedRowIdx];
+		if (!row) return;
+		if (row.kind === "toggle") {
+			handleSelect();
+			return;
+		}
+		if (!isToggleableRow(row)) return;
+		const action = resolveConfigItemToggleAction(row.item);
+		if (isInlineConfigAction(action)) {
+			void handleInlineToggle(row.item);
+		}
+	};
+
+	const handleDeleteSelected = () => {
+		if (!props.onDeleteConfigItem) {
+			return;
+		}
+		const row = rows[selectedRowIdx];
+		if (!row || row.kind !== "ext") {
+			return;
+		}
+		const action = resolveConfigItemDeleteAction(row.item);
+		if (action) {
+			resolve(action);
+		}
+	};
+
+	useDialogKeyboard((key) => {
+		if (key.name === "escape") {
+			dismiss();
+			return;
+		}
+		if (key.name === "left" || key.name === "right") {
+			const direction = key.name === "left" ? "left" : "right";
+			setActiveTab((tab) => {
+				const nextTab = getAdjacentConfigTab(tab, direction);
+				return nextTab;
+			});
+			setNavPosition(0);
+			return;
+		}
+		if (key.name === "up") {
+			const nextNavPos =
+				clampedNavPos > 0 ? clampedNavPos - 1 : navIndices.length - 1;
+			setNavPosition(nextNavPos);
+			return;
+		}
+		if (key.name === "down") {
+			const nextNavPos =
+				clampedNavPos < navIndices.length - 1 ? clampedNavPos + 1 : 0;
+			setNavPosition(nextNavPos);
+			return;
+		}
+		if (key.name === "space") {
+			handleToggleSelected();
+			return;
+		}
+		if (
+			key.name === "d" &&
+			!key.ctrl &&
+			!key.meta &&
+			!key.option &&
+			!key.shift
+		) {
+			handleDeleteSelected();
+			return;
+		}
+		if (key.name === "return" || key.name === "tab") {
+			handleSelect();
+		}
+	}, dialogId);
+
+	const maxVisible = Math.max(5, height - 12);
+	const win = getVisibleWindow(rows, selectedRowIdx, maxVisible);
+	const aboveCount = win.startIndex;
+	const belowCount = rows.length - win.startIndex - win.items.length;
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text fg={palette.act}>
+				<strong>Settings</strong>
+			</text>
+
+			<box flexDirection="row" flexWrap="wrap" paddingBottom={1}>
+				{getConfigTabs().map((tab) => {
+					const isActive = tab === activeTab;
+					return (
+						<box
+							key={tab}
+							height={1}
+							backgroundColor={isActive ? palette.selection : undefined}
+						>
+							<text fg={isActive ? palette.textOnSelection : "gray"}>
+								{` ${toTabLabel(tab)} `}
+							</text>
+						</box>
+					);
+				})}
+			</box>
+
+			{aboveCount > 0 && (
+				<text fg="gray">
+					{"▲ "}
+					{aboveCount} more
+				</text>
+			)}
+
+			{win.items.map((row, i) => {
+				const absIdx = win.startIndex + i;
+				const isSel = absIdx === selectedRowIdx;
+				const pfx = isSel ? "▸ " : "  ";
+
+				switch (row.kind) {
+					case "spacer":
+						return <text key={absIdx}> </text>;
+					case "head":
+						return (
+							<text key={absIdx} fg="white">
+								{" ".repeat(row.indent ?? 0)}
+								{row.label}
+							</text>
+						);
+					case "detail":
+						return (
+							<text key={absIdx} fg="gray">
+								{"  "}
+								{row.text}
+							</text>
+						);
+					case "tool-group":
+						return (
+							<box
+								key={absIdx}
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg="white">
+									{"  "}
+									{" ".repeat(row.indent ?? 0)}
+									{row.label}
+								</text>
+								<text fg="gray">{row.rightLabel}</text>
+							</box>
+						);
+					case "provider":
+						return (
+							<box
+								key={absIdx}
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg={isSel ? palette.act : undefined}>{pfx}Provider</text>
+								<text fg="white">{props.providerDisplayName}</text>
+							</box>
+						);
+					case "model":
+						return (
+							<box
+								key={absIdx}
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg={isSel ? palette.act : undefined}>{pfx}Model</text>
+								<text fg="white">{displayName}</text>
+							</box>
+						);
+					case "toggle": {
+						let value: string;
+						let valueColor: string;
+						if (row.id === "mode") {
+							value = mode === "plan" ? "Plan" : "Act";
+							valueColor = getModeAccent(mode);
+						} else if (row.id === "auto-approve") {
+							value = autoApprove ? "● on" : "○ off";
+							valueColor = autoApprove ? palette.success : "gray";
+						} else if (row.id === "auto-update") {
+							value = autoUpdateEnabled ? "● on" : "○ off";
+							valueColor = autoUpdateEnabled ? palette.success : "gray";
+						} else if (row.id === "compaction") {
+							value = formatCliCompactionMode(compactionMode);
+							valueColor = COMPACTION_MODE_COLORS[compactionMode];
+						} else {
+							value = verbose ? "● on" : "○ off";
+							valueColor = verbose ? palette.success : "gray";
+						}
+						return (
+							<box
+								key={absIdx}
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg={isSel ? palette.act : undefined}>
+									{pfx}
+									{row.label}
+								</text>
+								<text fg={valueColor}>{value}</text>
+							</box>
+						);
+					}
+					case "ext": {
+						const enabledState =
+							row.item.enabledState ??
+							(row.enabled === false ? "disabled" : "enabled");
+						const isPending = togglingItemId === row.item.id;
+						const enabledIcon =
+							typeof row.enabled === "boolean"
+								? isPending
+									? "~ "
+									: enabledState === "partial"
+										? "◐ "
+										: row.enabled
+											? "● "
+											: "○ "
+								: "";
+						const rightLabel = row.rightLabel ?? "";
+						const toggleable = isToggleableConfigItem(row.item);
+						const prefix = " ".repeat(row.indent ?? 0);
+						const rowColor = row.item.loadError
+							? "red"
+							: toggleable && enabledState === "enabled"
+								? palette.success
+								: enabledState === "partial"
+									? "yellow"
+									: isSel
+										? palette.act
+										: "gray";
+						return (
+							<box
+								key={absIdx}
+								flexDirection="row"
+								justifyContent="space-between"
+							>
+								<text fg={rowColor}>
+									{pfx}
+									{prefix}
+									{enabledIcon}
+									{getConfigItemDisplayName(row.name)}
+								</text>
+								<text fg="gray">{rightLabel}</text>
+							</box>
+						);
+					}
+					case "mcp-manager":
+						return (
+							<text key={absIdx} fg={isSel ? palette.act : "gray"}>
+								{pfx}Manage MCP Servers...
+							</text>
+						);
+					default:
+						return null;
+				}
+			})}
+
+			{belowCount > 0 && (
+				<text fg="gray">
+					{"▼ "}
+					{belowCount} more
+				</text>
+			)}
+
+			<text> </text>
+			{toggleError && <text fg="red">{toggleError}</text>}
+			<text fg="gray">
+				<em>
+					{togglingItemId
+						? "Applying settings"
+						: getConfigFooterText({
+								canToggle: canToggleSelectedRow,
+								canDelete: canDeleteSelectedRow,
+							})}
+				</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/views/history-view.tsx b/apps/cli/src/tui/views/history-view.tsx
new file mode 100644
index 0000000..540ae37
--- /dev/null
+++ b/apps/cli/src/tui/views/history-view.tsx
@@ -0,0 +1,470 @@
+// @jsxImportSource @opentui/react
+
+import type { SessionHistoryRecord } from "@cline/core";
+import {
+	formatDisplayUserInput,
+	formatHumanReadableDate,
+	truncateStr,
+} from "@cline/shared";
+import { useKeyboard, useTerminalDimensions } from "@opentui/react";
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { listSessions } from "../../session/session";
+import { mergeHistoryStatusRows } from "../../utils/history-format";
+import { formatUsd } from "../../utils/output";
+import { shouldShowCliUsageCost } from "../../utils/usage-cost-display";
+import { palette } from "../palette";
+
+function hasForkMetadata(row: SessionHistoryRecord): boolean {
+	const fork = row.metadata?.fork;
+	return typeof fork === "object" && fork !== null && !Array.isArray(fork);
+}
+
+function formatTitle(row: SessionHistoryRecord, maxLen: number): string {
+	const raw = row.metadata?.title?.trim() || row.prompt?.trim() || "Untitled";
+	const forkTitle =
+		hasForkMetadata(row) && !raw.endsWith(" (fork)") ? `${raw} (fork)` : raw;
+	const normalized = formatDisplayUserInput(forkTitle);
+	return truncateStr(normalized.replace(/\s+/g, " "), maxLen);
+}
+
+function formatRelativeDate(dateStr: string): string {
+	const date = new Date(dateStr);
+	if (Number.isNaN(date.getTime())) return dateStr;
+	const now = Date.now();
+	const diffMs = now - date.getTime();
+	const diffMins = Math.floor(diffMs / 60_000);
+	if (diffMins < 1) return "just now";
+	if (diffMins < 60) return `${diffMins}m ago`;
+	const diffHours = Math.floor(diffMins / 60);
+	if (diffHours < 24) return `${diffHours}h ago`;
+	const diffDays = Math.floor(diffHours / 24);
+	if (diffDays < 7) return `${diffDays}d ago`;
+	if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
+	return formatHumanReadableDate(dateStr);
+}
+
+const MAX_VISIBLE = 12;
+const DEFAULT_REFRESH_INTERVAL_MS = 2000;
+
+type HistoryListActions = {
+	onResolve: (sessionId: string) => void;
+	onDismiss: () => void;
+	onExport?: (sessionId: string) => Promise<string | undefined>;
+	onDelete?: (sessionId: string) => Promise<boolean>;
+};
+
+type HistoryKeyEvent = {
+	name?: string;
+	ctrl?: boolean;
+	shift?: boolean;
+};
+
+type HistoryListContentProps = HistoryListActions & {
+	initialRows?: SessionHistoryRecord[];
+	emptyMessage?: string;
+	footerText?: string;
+	title?: string;
+	loadRows?: boolean;
+	refreshRows?: () => Promise<SessionHistoryRecord[]>;
+	refreshIntervalMs?: number;
+	registerKeyHandler?: (
+		handler: (key: HistoryKeyEvent | undefined) => void,
+	) => void;
+};
+
+function HistoryListContent({
+	initialRows,
+	onResolve,
+	onDismiss,
+	onExport,
+	onDelete,
+	emptyMessage = "No sessions found",
+	footerText = "\u2191/\u2193 navigate, Enter to resume, Esc to close",
+	title = "Session History",
+	loadRows = false,
+	refreshRows,
+	refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS,
+	registerKeyHandler,
+}: HistoryListContentProps) {
+	const { width } = useTerminalDimensions();
+	const [rows, setRows] = useState<SessionHistoryRecord[]>(
+		() => initialRows ?? [],
+	);
+	const [selected, setSelected] = useState(0);
+	const [loading, setLoading] = useState(loadRows);
+	const [confirmDelete, setConfirmDelete] = useState<string | null>(null);
+	const [statusMessage, setStatusMessage] = useState<string | null>(null);
+	const handlerRef = useRef<(key: HistoryKeyEvent | undefined) => void>(
+		() => {},
+	);
+
+	useEffect(() => {
+		const loadInitialRows = () => listSessions(50, { hydrate: true });
+		const loadRefreshRows =
+			refreshRows ?? (() => listSessions(50, { hydrate: false }));
+		let disposed = false;
+		let refreshInFlight = false;
+		let interval: ReturnType<typeof setInterval> | undefined;
+
+		const refresh = async (
+			showLoading: boolean,
+			load: () => Promise<SessionHistoryRecord[]>,
+		) => {
+			if (refreshInFlight) {
+				return;
+			}
+			refreshInFlight = true;
+			if (showLoading) {
+				setLoading(true);
+			}
+			try {
+				const refreshedRows = await load();
+				if (disposed) {
+					return;
+				}
+				setRows((currentRows) =>
+					currentRows.length === 0
+						? refreshedRows
+						: mergeHistoryStatusRows(currentRows, refreshedRows),
+				);
+				setSelected((currentSelected) =>
+					Math.min(currentSelected, Math.max(0, refreshedRows.length - 1)),
+				);
+			} catch {
+				// Keep the last visible history snapshot when a background refresh fails.
+			} finally {
+				refreshInFlight = false;
+				if (!disposed && showLoading) {
+					setLoading(false);
+				}
+			}
+		};
+
+		if (!loadRows && !refreshRows) {
+			setRows(initialRows ?? []);
+			setLoading(false);
+			return;
+		}
+
+		if (loadRows) {
+			void refresh(true, loadInitialRows);
+		} else {
+			setRows(initialRows ?? []);
+			setLoading(false);
+		}
+
+		if (refreshIntervalMs > 0) {
+			interval = setInterval(() => {
+				void refresh(false, loadRefreshRows);
+			}, refreshIntervalMs);
+		}
+
+		return () => {
+			disposed = true;
+			if (interval) {
+				clearInterval(interval);
+			}
+		};
+	}, [initialRows, loadRows, refreshIntervalMs, refreshRows]);
+
+	const safeSelected = Math.min(selected, Math.max(0, rows.length - 1));
+	const titleMaxLen = Math.max(20, width - 44);
+
+	const rowsRef = useRef(rows);
+	rowsRef.current = rows;
+	const selectedRef = useRef(safeSelected);
+	selectedRef.current = safeSelected;
+
+	const window = useMemo(() => {
+		if (rows.length <= MAX_VISIBLE) {
+			return { items: rows, startIndex: 0 };
+		}
+		const half = Math.floor(MAX_VISIBLE / 2);
+		let start = Math.max(0, safeSelected - half);
+		const end = Math.min(rows.length, start + MAX_VISIBLE);
+		if (end - start < MAX_VISIBLE) start = Math.max(0, end - MAX_VISIBLE);
+		return { items: rows.slice(start, end), startIndex: start };
+	}, [rows, safeSelected]);
+
+	handlerRef.current = (key: HistoryKeyEvent | undefined) => {
+		if (!key) {
+			return;
+		}
+		if (key.ctrl && key.name === "c") {
+			onDismiss();
+			return;
+		}
+		if (confirmDelete) {
+			if (key.name === "y" || (key.shift && key.name === "y")) {
+				const sessionId = confirmDelete;
+				setConfirmDelete(null);
+				setStatusMessage(`Deleting ${sessionId}...`);
+				void onDelete?.(sessionId)
+					.then((deleted) => {
+						if (!deleted) {
+							setStatusMessage(`Session ${sessionId} not found`);
+							return;
+						}
+						setRows((currentRows) => {
+							const nextRows = currentRows.filter(
+								(row) => row.sessionId !== sessionId,
+							);
+							setSelected((currentSelected) =>
+								Math.min(currentSelected, Math.max(0, nextRows.length - 1)),
+							);
+							return nextRows;
+						});
+						setStatusMessage(`Deleted ${sessionId}`);
+					})
+					.catch((error) => {
+						setStatusMessage(
+							error instanceof Error ? error.message : String(error),
+						);
+					});
+			} else {
+				setConfirmDelete(null);
+			}
+			return;
+		}
+
+		if (key.name === "escape") {
+			onDismiss();
+			return;
+		}
+		if (key.name === "return" || key.name === "enter") {
+			const currentRows = rowsRef.current;
+			const row = currentRows[selectedRef.current];
+			if (row) onResolve(row.sessionId);
+			return;
+		}
+		if (key.name === "up" || (key.ctrl && key.name === "p")) {
+			setStatusMessage(null);
+			setSelected((s) => {
+				const len = rowsRef.current.length;
+				return s <= 0 ? len - 1 : s - 1;
+			});
+			return;
+		}
+		if (key.name === "down" || (key.ctrl && key.name === "n")) {
+			setStatusMessage(null);
+			setSelected((s) => {
+				const len = rowsRef.current.length;
+				return s >= len - 1 ? 0 : s + 1;
+			});
+			return;
+		}
+		if (key.name === "left") {
+			const row = rowsRef.current[selectedRef.current];
+			if (row?.sessionId && onDelete) {
+				setConfirmDelete(row.sessionId);
+			}
+			return;
+		}
+		if (key.name === "right") {
+			const row = rowsRef.current[selectedRef.current];
+			if (row?.sessionId && onExport) {
+				setStatusMessage(`Exporting ${row.sessionId}...`);
+				void onExport(row.sessionId)
+					.then((path) => {
+						setStatusMessage(
+							path
+								? `Exported ${row.sessionId} to ${path}`
+								: `Exported ${row.sessionId}`,
+						);
+					})
+					.catch((error) => {
+						setStatusMessage(
+							error instanceof Error ? error.message : String(error),
+						);
+					});
+			}
+		}
+	};
+
+	useEffect(() => {
+		registerKeyHandler?.((key) => handlerRef.current(key));
+	}, [registerKeyHandler]);
+
+	if (loading) {
+		return (
+			<box flexDirection="column" paddingX={1}>
+				<text fg="gray">Loading session history...</text>
+			</box>
+		);
+	}
+
+	if (rows.length === 0) {
+		return (
+			<box flexDirection="column" paddingX={1} gap={1}>
+				<text>{title}</text>
+				<text fg="gray">{emptyMessage}</text>
+				<text fg="gray">
+					<em>Esc to close</em>
+				</text>
+			</box>
+		);
+	}
+
+	const aboveCount = window.startIndex;
+	const belowCount = rows.length - window.startIndex - window.items.length;
+
+	return (
+		<box flexDirection="column" paddingX={1}>
+			<text fg={confirmDelete ? "red" : undefined}>
+				{confirmDelete ? "Delete this session? (y/n)" : title}
+			</text>
+
+			<box flexDirection="column" marginTop={1}>
+				{aboveCount > 0 && (
+					<text fg="gray">
+						{"\u25b2 "}
+						{aboveCount} more
+					</text>
+				)}
+
+				{window.items.map((row, i) => {
+					const absIdx = window.startIndex + i;
+					const isSel = absIdx === safeSelected;
+					const cost = row.metadata?.totalCost;
+					const showCost = shouldShowCliUsageCost(row.provider);
+					const title = formatTitle(row, titleMaxLen);
+					const date = formatRelativeDate(row.startedAt);
+
+					return (
+						<box
+							key={row.sessionId}
+							flexDirection="row"
+							paddingX={1}
+							backgroundColor={isSel ? palette.selection : undefined}
+							onMouseDown={() => onResolve(row.sessionId)}
+							overflow="hidden"
+							height={1}
+						>
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{isSel ? "\u276f " : "  "}
+							</text>
+							<text
+								fg={isSel ? palette.textOnSelection : undefined}
+								flexGrow={1}
+							>
+								{title}
+							</text>
+							{showCost && cost != null && cost > 0 && (
+								<text
+									fg={isSel ? palette.textOnSelection : "gray"}
+									flexShrink={0}
+								>
+									{"  "}
+									{formatUsd(cost, 2)}
+								</text>
+							)}
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{"  "}
+								{date}
+							</text>
+						</box>
+					);
+				})}
+
+				{belowCount > 0 && (
+					<text fg="gray">
+						{"\u25bc "}
+						{belowCount} more
+					</text>
+				)}
+			</box>
+
+			{statusMessage && (
+				<text
+					fg={
+						statusMessage.startsWith("Exported") ||
+						statusMessage.startsWith("Exporting") ||
+						statusMessage.startsWith("Deleted") ||
+						statusMessage.startsWith("Deleting")
+							? palette.success
+							: "red"
+					}
+					marginTop={1}
+				>
+					{statusMessage}
+				</text>
+			)}
+
+			<text fg="gray" marginTop={1}>
+				<em>{footerText}</em>
+			</text>
+		</box>
+	);
+}
+
+export function HistoryDialogContent(props: ChoiceContext<string>) {
+	const { resolve, dismiss, dialogId } = props;
+	const [keyHandler, setKeyHandler] = useState<
+		((key: HistoryKeyEvent | undefined) => void) | undefined
+	>();
+	const registerKeyHandler = useCallback(
+		(handler: (key: HistoryKeyEvent | undefined) => void) => {
+			setKeyHandler(() => handler);
+		},
+		[],
+	);
+
+	useDialogKeyboard((key) => keyHandler?.(key), dialogId);
+
+	return (
+		<HistoryListContent
+			loadRows
+			onResolve={resolve}
+			onDismiss={dismiss}
+			registerKeyHandler={registerKeyHandler}
+		/>
+	);
+}
+
+export function HistoryStandaloneContent(
+	props: HistoryListActions & {
+		rows: SessionHistoryRecord[];
+		title?: string;
+		footerText?: string;
+		refreshRows?: () => Promise<SessionHistoryRecord[]>;
+		refreshIntervalMs?: number;
+	},
+) {
+	const [keyHandler, setKeyHandler] = useState<
+		((key: HistoryKeyEvent | undefined) => void) | undefined
+	>();
+	const registerKeyHandler = useCallback(
+		(handler: (key: HistoryKeyEvent | undefined) => void) => {
+			setKeyHandler(() => handler);
+		},
+		[],
+	);
+
+	useKeyboard((key) => keyHandler?.(key));
+
+	return (
+		<HistoryListContent
+			initialRows={props.rows}
+			onResolve={props.onResolve}
+			onDismiss={props.onDismiss}
+			onExport={props.onExport}
+			onDelete={props.onDelete}
+			refreshRows={props.refreshRows}
+			refreshIntervalMs={props.refreshIntervalMs}
+			title={props.title ?? "History"}
+			footerText={
+				props.footerText ??
+				"\u2191/\u2193 navigate, Enter to resume, \u2190 delete, \u2192 export, Esc to close"
+			}
+			registerKeyHandler={registerKeyHandler}
+		/>
+	);
+}
diff --git a/apps/cli/src/tui/views/home-view.tsx b/apps/cli/src/tui/views/home-view.tsx
new file mode 100644
index 0000000..56c67c6
--- /dev/null
+++ b/apps/cli/src/tui/views/home-view.tsx
@@ -0,0 +1,167 @@
+import { useTerminalDimensions } from "@opentui/react";
+import { useState } from "react";
+import {
+	AutocompleteDropdown,
+	type AutocompleteDropdownProps,
+	DROPDOWN_MAX_HEIGHT,
+} from "../components/autocomplete-dropdown";
+import { InputBar, type TextareaHandle } from "../components/input-bar";
+import {
+	resolveModelDisplayName,
+	resolveModelMaxInputTokens,
+	StatusBar,
+} from "../components/status-bar";
+import { TrackedRobot, useMouseTracker } from "../components/tracked-robot";
+import { useSession } from "../contexts/session-context";
+import {
+	useTerminalBackground,
+	useTerminalTheme,
+} from "../hooks/use-terminal-background";
+import {
+	getDefaultForeground,
+	getInputRuleColor,
+	getModeAccent,
+	getModeInputForeground,
+	getModeInputPlaceholder,
+} from "../palette";
+import { HOME_VIEW_MAX_WIDTH, type TuiProps } from "../types";
+
+export function HomeView(props: {
+	config: TuiProps["config"];
+	inputValue: string;
+	inputKey: number;
+	onSubmit: () => void;
+	onContentChange: (text: string) => void;
+	onImagePaste: (dataUrl: string) => string;
+	onLargeTextPaste: (text: string) => string;
+	onInputFocusRequest?: () => void;
+	repoStatus: {
+		branch: string | null;
+		diffStats: {
+			files: number;
+			additions: number;
+			deletions: number;
+		} | null;
+	};
+	textareaRef?: React.MutableRefObject<TextareaHandle | null>;
+	autocomplete?: AutocompleteDropdownProps;
+	onToggleMode: () => void;
+}) {
+	const {
+		config,
+		inputValue,
+		inputKey,
+		onSubmit,
+		onContentChange,
+		onImagePaste,
+		onLargeTextPaste,
+		repoStatus,
+	} = props;
+	const session = useSession();
+	const { width, height } = useTerminalDimensions();
+	const mouse = useMouseTracker();
+	const [inputCursor, setInputCursor] = useState<{
+		visualCol: number;
+		visualRow: number;
+	} | null>(null);
+
+	const terminalBg = useTerminalBackground();
+	const terminalTheme = useTerminalTheme();
+	const defaultFg = getDefaultForeground(terminalBg);
+	const accent = getModeAccent(session.uiMode, terminalTheme);
+	const inputRuleColor = getInputRuleColor(terminalBg);
+	const inputForeground = getModeInputForeground(session.uiMode, terminalBg);
+	const inputPlaceholder = getModeInputPlaceholder(session.uiMode, terminalBg);
+	const placeholder =
+		session.uiMode === "plan" ? "Plan something..." : "What can I do for you?";
+	const modelDisplayName = resolveModelDisplayName(config);
+	const maxInputTokens = resolveModelMaxInputTokens(config);
+	const hasAutocomplete =
+		props.autocomplete?.mode && props.autocomplete.options.length > 0;
+	const contentWidth = Math.min(width, HOME_VIEW_MAX_WIDTH);
+	const hasTypedInput = inputValue.trim().length > 0;
+	const inputStartX = Math.floor((width - contentWidth) / 2) + 2;
+	const clamp = (value: number, min: number, max: number) =>
+		Math.max(min, Math.min(max, value));
+	const trackedCursorX = hasTypedInput
+		? clamp(inputStartX + (inputCursor?.visualCol ?? 0), 0, width)
+		: mouse.cursor.x;
+	const trackedCursorY = hasTypedInput
+		? clamp(height - 2 + (inputCursor?.visualRow ?? 0), 0, height)
+		: mouse.cursor.y;
+
+	return (
+		<box
+			flexDirection="column"
+			width="100%"
+			height="100%"
+			alignItems="center"
+			justifyContent="center"
+			onMouseMove={mouse.onMouseMove}
+		>
+			<TrackedRobot cursorX={trackedCursorX} cursorY={trackedCursorY} />
+			<box marginTop={1} marginBottom={1} flexShrink={0}>
+				<text fg={defaultFg}>
+					<strong>What can I do for you?</strong>
+				</text>
+			</box>
+			<box marginBottom={1} flexShrink={0}>
+				<text fg="gray">
+					<em>
+						Use / for slash commands, @ for file mentions, Ctrl+P for menu
+					</em>
+				</text>
+			</box>
+
+			<box flexDirection="column" width={contentWidth} flexShrink={0}>
+				<InputBar
+					accent={accent}
+					ruleColor={inputRuleColor}
+					inputForeground={inputForeground}
+					inputPlaceholder={inputPlaceholder}
+					placeholder={placeholder}
+					initialValue={inputValue}
+					inputKey={inputKey}
+					onSubmit={onSubmit}
+					onContentChange={onContentChange}
+					onVisualCursorChange={setInputCursor}
+					onImagePaste={onImagePaste}
+					onLargeTextPaste={onLargeTextPaste}
+					onFocusRequest={props.onInputFocusRequest}
+					textareaRef={props.textareaRef}
+				/>
+
+				<box flexDirection="column" height={DROPDOWN_MAX_HEIGHT + 1}>
+					{hasAutocomplete && props.autocomplete ? (
+						<AutocompleteDropdown
+							{...props.autocomplete}
+							accent={accent}
+							containerWidth={Math.min(width, HOME_VIEW_MAX_WIDTH)}
+						/>
+					) : (
+						<box marginTop={1}>
+							<StatusBar
+								providerId={config.providerId}
+								modelId={modelDisplayName}
+								totalTokens={session.lastTotalTokens}
+								totalCost={session.lastTotalCost}
+								maxInputTokens={maxInputTokens}
+								uiMode={session.uiMode}
+								autoApproveAll={session.autoApproveAll}
+								workspaceName={
+									config.workspaceRoot
+										? (config.workspaceRoot.split("/").pop() ?? "")
+										: ""
+								}
+								gitBranch={repoStatus.branch}
+								gitDiffStats={repoStatus.diffStats}
+								onToggleMode={props.onToggleMode}
+								variant="home"
+							/>
+						</box>
+					)}
+				</box>
+			</box>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/views/onboarding/auth.test.ts b/apps/cli/src/tui/views/onboarding/auth.test.ts
new file mode 100644
index 0000000..07a0bf6
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/auth.test.ts
@@ -0,0 +1,209 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const hoisted = vi.hoisted(() => ({
+	loginLocalProvider: vi.fn(),
+	startClineDeviceAuth: vi.fn(),
+	completeClineDeviceAuth: vi.fn(),
+	saveLocalProviderOAuthCredentials: vi.fn(),
+	identifyFeatureFlagsAccount: vi.fn(async () => {}),
+	openMock: vi.fn(() => Promise.resolve()),
+}));
+
+vi.mock("@cline/core", () => ({
+	loginLocalProvider: hoisted.loginLocalProvider,
+	startClineDeviceAuth: hoisted.startClineDeviceAuth,
+	completeClineDeviceAuth: hoisted.completeClineDeviceAuth,
+	saveLocalProviderOAuthCredentials: hoisted.saveLocalProviderOAuthCredentials,
+	ProviderSettingsManager: class {},
+}));
+
+vi.mock("@cline/shared", () => ({
+	getClineEnvironmentConfig: () => ({ apiBaseUrl: "https://api.example" }),
+}));
+
+vi.mock("open", () => ({ default: hoisted.openMock }));
+
+vi.mock("../../../utils/feature-flags", () => ({
+	identifyFeatureFlagsAccount: hoisted.identifyFeatureFlagsAccount,
+}));
+
+import { runDeviceCodeAuthFlow, runOAuthAuthFlow } from "./auth";
+
+// Minimal stand-in for a telemetry service. The auth helpers must forward this
+// reference verbatim into core; we only need referential equality, so the
+// concrete shape doesn't matter for these tests.
+const fakeTelemetry = { __id: "fake-telemetry" } as unknown as Parameters<
+	typeof runOAuthAuthFlow
+>[0]["telemetry"];
+
+function makeManager() {
+	return {
+		getProviderSettings: vi.fn(() => undefined),
+	} as unknown as Parameters<
+		typeof runOAuthAuthFlow
+	>[0]["providerSettingsManager"];
+}
+
+describe("onboarding auth telemetry forwarding", () => {
+	beforeEach(() => {
+		hoisted.loginLocalProvider.mockReset();
+		hoisted.startClineDeviceAuth.mockReset();
+		hoisted.completeClineDeviceAuth.mockReset();
+		hoisted.saveLocalProviderOAuthCredentials.mockReset();
+		hoisted.identifyFeatureFlagsAccount.mockReset();
+		hoisted.identifyFeatureFlagsAccount.mockResolvedValue(undefined);
+		hoisted.openMock.mockReset();
+		hoisted.openMock.mockResolvedValue(undefined);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("forwards the CLI telemetry service into loginLocalProvider", async () => {
+		// Resolve the credentials promise so the onComplete branch fires, but the
+		// test's assertion is on the telemetry argument passed to core.
+		hoisted.loginLocalProvider.mockResolvedValueOnce({
+			access: "a",
+			refresh: "r",
+			expires: 0,
+		});
+
+		const onComplete = vi.fn();
+		runOAuthAuthFlow({
+			providerId: "openai-codex",
+			providerSettingsManager: makeManager(),
+			isAborted: () => false,
+			setStatus: vi.fn(),
+			setAuthUrl: vi.fn(),
+			setError: vi.fn(),
+			onComplete,
+			telemetry: fakeTelemetry,
+		});
+
+		// Flush the .then chain so we can assert on the post-login callbacks too.
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(hoisted.loginLocalProvider).toHaveBeenCalledTimes(1);
+		const [providerArg, , , telemetryArg] =
+			hoisted.loginLocalProvider.mock.calls[0];
+		expect(providerArg).toBe("openai-codex");
+		// Identity, not deep-equal — we are validating the exact reference flows
+		// through so opt-out / common metadata stays consistent.
+		expect(telemetryArg).toBe(fakeTelemetry);
+		expect(hoisted.identifyFeatureFlagsAccount).not.toHaveBeenCalled();
+	});
+
+	it("does not pass telemetry when none is provided (back-compat)", () => {
+		hoisted.loginLocalProvider.mockResolvedValueOnce({
+			access: "a",
+			refresh: "r",
+			expires: 0,
+		});
+
+		runOAuthAuthFlow({
+			providerId: "openai-codex",
+			providerSettingsManager: makeManager(),
+			isAborted: () => false,
+			setStatus: vi.fn(),
+			setAuthUrl: vi.fn(),
+			setError: vi.fn(),
+			onComplete: vi.fn(),
+		});
+
+		const [, , , telemetryArg] = hoisted.loginLocalProvider.mock.calls[0];
+		expect(telemetryArg).toBeUndefined();
+	});
+
+	it("forwards telemetry into completeClineDeviceAuth for the device-code flow", async () => {
+		hoisted.startClineDeviceAuth.mockResolvedValueOnce({
+			deviceCode: "dc",
+			userCode: "uc",
+			verificationUri: "https://verify",
+			verificationUriComplete: "https://verify?user_code=uc",
+			expiresInSeconds: 600,
+			pollIntervalSeconds: 5,
+		});
+		hoisted.completeClineDeviceAuth.mockResolvedValueOnce({
+			access: "a",
+			refresh: "r",
+			expires: 0,
+			accountId: "acct-1",
+			email: "user@example.com",
+		});
+
+		runDeviceCodeAuthFlow({
+			providerId: "cline",
+			providerSettingsManager: makeManager(),
+			isAborted: () => false,
+			setUserCode: vi.fn(),
+			setVerifyUrl: vi.fn(),
+			setStatus: vi.fn(),
+			setError: vi.fn(),
+			onComplete: vi.fn(),
+			telemetry: fakeTelemetry,
+		});
+
+		await Promise.resolve();
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(hoisted.completeClineDeviceAuth).toHaveBeenCalledTimes(1);
+		const [opts] = hoisted.completeClineDeviceAuth.mock.calls[0];
+		expect(opts.telemetry).toBe(fakeTelemetry);
+		// We do NOT forward telemetry to startClineDeviceAuth — auth_started is
+		// emitted by completeClineDeviceAuth, so passing telemetry to the start
+		// helper would double-emit the event.
+		expect(hoisted.startClineDeviceAuth).toHaveBeenCalledWith();
+		expect(hoisted.identifyFeatureFlagsAccount).toHaveBeenCalledWith({
+			id: "acct-1",
+			email: "user@example.com",
+		});
+		expect(hoisted.openMock).toHaveBeenCalledWith(
+			"https://verify?user_code=uc",
+			{ wait: false },
+		);
+	});
+
+	it("falls back to displaying the device auth URL when browser open fails", async () => {
+		hoisted.openMock.mockRejectedValueOnce(new Error("no browser"));
+		hoisted.startClineDeviceAuth.mockResolvedValueOnce({
+			deviceCode: "dc",
+			userCode: "uc",
+			verificationUri: "https://verify",
+			verificationUriComplete: "https://verify?user_code=uc",
+			expiresInSeconds: 600,
+			pollIntervalSeconds: 5,
+		});
+		hoisted.completeClineDeviceAuth.mockResolvedValueOnce({
+			access: "a",
+			refresh: "r",
+			expires: 0,
+		});
+		const setStatus = vi.fn();
+
+		runDeviceCodeAuthFlow({
+			providerId: "cline",
+			providerSettingsManager: makeManager(),
+			isAborted: () => false,
+			setUserCode: vi.fn(),
+			setVerifyUrl: vi.fn(),
+			setStatus,
+			setError: vi.fn(),
+			onComplete: vi.fn(),
+		});
+
+		await Promise.resolve();
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(hoisted.openMock).toHaveBeenCalledWith(
+			"https://verify?user_code=uc",
+			{ wait: false },
+		);
+		expect(setStatus).toHaveBeenCalledWith(
+			"Could not open browser. Visit the URL below.",
+		);
+	});
+});
diff --git a/apps/cli/src/tui/views/onboarding/auth.ts b/apps/cli/src/tui/views/onboarding/auth.ts
new file mode 100644
index 0000000..984aa05
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/auth.ts
@@ -0,0 +1,151 @@
+import {
+	completeClineDeviceAuth,
+	type ITelemetryService,
+	isOAuthProvider,
+	loginLocalProvider,
+	type ProviderSettingsManager,
+	saveLocalProviderOAuthCredentials,
+	startClineDeviceAuth,
+} from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import open from "open";
+import { identifyFeatureFlagsAccount } from "../../../utils/feature-flags";
+
+export type OnboardingOAuthProviderId = string;
+
+export function isOnboardingOAuthProviderId(
+	providerId: string,
+): providerId is OnboardingOAuthProviderId {
+	return isOAuthProvider(providerId);
+}
+
+function isClineAccountOAuthProvider(providerId: string): boolean {
+	return providerId === "cline" || providerId === "cline-pass";
+}
+
+export function runOAuthAuthFlow(input: {
+	providerId: OnboardingOAuthProviderId;
+	providerSettingsManager: ProviderSettingsManager;
+	isAborted: () => boolean;
+	setStatus: (status: string) => void;
+	setAuthUrl: (url: string) => void;
+	setError: (error: string) => void;
+	onComplete: (providerId: OnboardingOAuthProviderId) => void;
+	telemetry?: ITelemetryService;
+}): void {
+	const existing = input.providerSettingsManager.getProviderSettings(
+		input.providerId,
+	);
+
+	loginLocalProvider(
+		input.providerId,
+		existing,
+		(url: string) => {
+			input.setAuthUrl(url);
+			input.setStatus("Waiting for sign-in...");
+			try {
+				void open(url, { wait: false }).catch(() => {
+					input.setStatus("Could not open browser. Visit the URL below.");
+				});
+			} catch {
+				input.setStatus("Could not open browser. Visit the URL below.");
+			}
+		},
+		input.telemetry,
+	)
+		.then((credentials) => {
+			if (input.isAborted()) return;
+			saveLocalProviderOAuthCredentials(
+				input.providerSettingsManager,
+				input.providerId,
+				existing,
+				credentials,
+			);
+			if (isClineAccountOAuthProvider(input.providerId)) {
+				void identifyFeatureFlagsAccount({
+					id: credentials.accountId,
+					email: credentials.email,
+				}).catch(() => {});
+			}
+			input.onComplete(input.providerId);
+		})
+		.catch((err: unknown) => {
+			if (input.isAborted()) return;
+			input.setError(err instanceof Error ? err.message : String(err));
+			input.setStatus("Authentication failed");
+		});
+}
+
+export function runDeviceCodeAuthFlow(input: {
+	providerId: OnboardingOAuthProviderId;
+	providerSettingsManager: ProviderSettingsManager;
+	isAborted: () => boolean;
+	setUserCode: (code: string) => void;
+	setVerifyUrl: (url: string) => void;
+	setStatus: (status: string) => void;
+	setError: (error: string) => void;
+	onComplete: (providerId: OnboardingOAuthProviderId) => void;
+	telemetry?: ITelemetryService;
+}): void {
+	const existing = input.providerSettingsManager.getProviderSettings(
+		input.providerId,
+	);
+	const apiBaseUrl =
+		existing?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl;
+
+	// `startClineDeviceAuth` only requests the user/device code pair; the
+	// `auth_started` telemetry event is emitted by `completeClineDeviceAuth`
+	// (which owns the actual login lifecycle), so we intentionally do NOT
+	// pass telemetry into `startClineDeviceAuth` here.
+	startClineDeviceAuth()
+		.then((result) => {
+			if (input.isAborted()) return;
+			const verifyUrl =
+				result.verificationUriComplete || result.verificationUri;
+			input.setUserCode(result.userCode);
+			input.setVerifyUrl(verifyUrl);
+			input.setStatus("Enter the code at the URL below");
+			try {
+				void open(verifyUrl, { wait: false }).catch(() => {
+					input.setStatus("Could not open browser. Visit the URL below.");
+				});
+			} catch {
+				input.setStatus("Could not open browser. Visit the URL below.");
+			}
+
+			completeClineDeviceAuth({
+				deviceCode: result.deviceCode,
+				expiresInSeconds: result.expiresInSeconds,
+				pollIntervalSeconds: result.pollIntervalSeconds,
+				apiBaseUrl,
+				provider: input.providerId,
+				telemetry: input.telemetry,
+			})
+				.then((credentials) => {
+					if (input.isAborted()) return;
+					saveLocalProviderOAuthCredentials(
+						input.providerSettingsManager,
+						input.providerId,
+						existing,
+						credentials,
+					);
+					if (isClineAccountOAuthProvider(input.providerId)) {
+						void identifyFeatureFlagsAccount({
+							id: credentials.accountId,
+							email: credentials.email,
+						}).catch(() => {});
+					}
+					input.onComplete(input.providerId);
+				})
+				.catch((err: unknown) => {
+					if (input.isAborted()) return;
+					input.setError(err instanceof Error ? err.message : String(err));
+					input.setStatus("Authentication failed");
+				});
+		})
+		.catch((err: unknown) => {
+			if (input.isAborted()) return;
+			input.setError(err instanceof Error ? err.message : String(err));
+			input.setStatus("Could not start device code flow");
+		});
+}
diff --git a/apps/cli/src/tui/views/onboarding/controller.ts b/apps/cli/src/tui/views/onboarding/controller.ts
new file mode 100644
index 0000000..c5a4207
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/controller.ts
@@ -0,0 +1,885 @@
+import {
+	captureProviderConfigured,
+	getLocalProviderModels,
+	getProviderConfigFields,
+	type ProviderConfigFieldKey,
+	type ProviderConfigFields,
+	ProviderSettingsManager,
+	refreshProviderModelsFromSource,
+	resolveProviderConfig,
+	saveLocalProviderSettings,
+} from "@cline/core";
+import { isClineProvider } from "@cline/shared";
+import open from "open";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+	getCliSubscriptionUrl,
+	getIndividualPlanFeatures,
+} from "../../../utils/cline-pass-errors";
+import {
+	type CodexCliStatus,
+	checkCodexCliInstalled,
+	isOpenAICodexCliProvider,
+} from "../../../utils/codex-cli";
+import { getPersistedProviderApiKey } from "../../../utils/provider-auth";
+import { listLocalProviders } from "../../../utils/provider-catalog";
+import { getCliTelemetryService } from "../../../utils/telemetry";
+import {
+	loadCurrentUserPlanFromProviderSettings,
+	loadIndividualSubscriptionPlansFromProviderSettings,
+} from "../../cline-account";
+import {
+	buildFeaturedModelEntries,
+	type ClineModelPickerEntry,
+	useClineRecommendedModels,
+} from "../../components/model-selector/cline-model-picker";
+import {
+	type SearchableItem,
+	useSearchableList,
+} from "../../components/searchable-list";
+import { palette } from "../../palette";
+import {
+	getDefaultAwsRegion,
+	type ProviderConfigValues,
+	resolveProviderConfigAwsRegion,
+	resolveProviderConfigAzure,
+	resolveProviderConfigSap,
+	updateProviderConfigValue,
+} from "../../utils/provider-config-values";
+import { getProviderSection } from "../../utils/provider-sections";
+import {
+	isOnboardingOAuthProviderId,
+	type OnboardingOAuthProviderId,
+	runDeviceCodeAuthFlow,
+	runOAuthAuthFlow,
+} from "./auth";
+import { FIELD_ORDER } from "./fields";
+import { useOnboardingKeyboard } from "./keyboard";
+import {
+	CLINE_PASS_SUBSCRIPTION_OPTIONS,
+	type ClinePassSubscriptionStatus,
+	DEFAULT_THINKING_LEVEL_INDEX,
+	getMainMenuOptions,
+	type ModelEntry,
+	type OnboardingResult,
+	type OnboardingStep,
+	type ProviderEntry,
+	type ReasoningEffort,
+	shouldUseFeaturedClineModelPicker,
+	type ThinkingLevel,
+	toModelEntriesFromKnownModels,
+	toModelEntry,
+	toProviderEntry,
+} from "./model";
+
+const CUSTOM_MODEL_ID_ACTION = "__custom_model_id__";
+
+export interface OnboardingControllerProps {
+	onComplete: (result: OnboardingResult) => void;
+	onExit: () => void;
+	providerSettingsManager?: ProviderSettingsManager;
+}
+
+export function useOnboardingController(props: OnboardingControllerProps) {
+	const { onComplete } = props;
+	const providerSettingsManager = useMemo(
+		() => props.providerSettingsManager ?? new ProviderSettingsManager(),
+		[props.providerSettingsManager],
+	);
+	const menuOptions = useMemo(
+		() =>
+			getMainMenuOptions({
+				isClinePassEnabled: true,
+			}),
+		[],
+	);
+	const [step, setStep] = useState<OnboardingStep>("menu");
+	const [menuSelected, setMenuSelected] = useState(0);
+	const [oauthProvider, setOauthProvider] = useState("");
+	const [authStatus, setAuthStatus] = useState("");
+	const [authUrl, setAuthUrl] = useState("");
+	const [authError, setAuthError] = useState("");
+	const [activeProviderId, setActiveProviderId] = useState("");
+	const [activeProviderName, setActiveProviderName] = useState("");
+	const [byoFields, setByoFields] = useState<ProviderConfigFields["fields"]>(
+		{},
+	);
+	const [byoDescription, setByoDescription] = useState<string | undefined>();
+	const [byoValues, setByoValues] = useState<ProviderConfigValues>({});
+	const [byoFocusedField, setByoFocusedField] =
+		useState<ProviderConfigFieldKey>("apiKey");
+	const [codexCliStatus, setCodexCliStatus] = useState<
+		CodexCliStatus | undefined
+	>();
+	const [codexCliChecking, setCodexCliChecking] = useState(false);
+	const authAbortRef = useRef(false);
+
+	// Device code flow
+	const [deviceUserCode, setDeviceUserCode] = useState("");
+	const [deviceVerifyUrl, setDeviceVerifyUrl] = useState("");
+	const [deviceStatus, setDeviceStatus] = useState("");
+	const [deviceError, setDeviceError] = useState("");
+	const deviceAbortRef = useRef(false);
+
+	// Provider catalog
+	const [providers, setProviders] = useState<ProviderEntry[]>([]);
+	const [providersLoading, setProvidersLoading] = useState(true);
+
+	useEffect(() => {
+		listLocalProviders(providerSettingsManager)
+			.then(({ providers: list }) => {
+				setProviders(list.map(toProviderEntry));
+			})
+			.catch(() => {})
+			.finally(() => setProvidersLoading(false));
+	}, [providerSettingsManager]);
+
+	const providerItems: SearchableItem[] = useMemo(
+		() =>
+			providers.map((p) => ({
+				key: p.id,
+				label: p.name,
+				section: getProviderSection(p),
+				detail: p.isOAuth
+					? "(OAuth)"
+					: p.isLocalAuth
+						? "(local CLI)"
+						: undefined,
+				searchText: `${p.name} ${p.id}`,
+				rightLabel: p.hasAuth ? "\u25cf" : undefined,
+				rightLabelColor: palette.success,
+			})),
+		[providers],
+	);
+
+	const providerList = useSearchableList(providerItems);
+
+	// Model catalog for selected provider
+	const [modelEntries, setModelEntries] = useState<ModelEntry[]>([]);
+	const [modelsLoading, setModelsLoading] = useState(false);
+	const [modelsDefaultId, setModelsDefaultId] = useState("");
+	const [customModelId, setCustomModelId] = useState("");
+	const [customModelError, setCustomModelError] = useState("");
+	const [clinePassSubscriptionStatus, setClinePassSubscriptionStatus] =
+		useState<ClinePassSubscriptionStatus>("loading");
+	const [clinePassSubscriptionError, setClinePassSubscriptionError] =
+		useState("");
+	const [clinePassCurrentPlanName, setClinePassCurrentPlanName] = useState("");
+	const [clinePassPlanFeatures, setClinePassPlanFeatures] = useState<string[]>(
+		[],
+	);
+	const [clinePassSubscriptionSelected, setClinePassSubscriptionSelected] =
+		useState(0);
+	const [clinePassSubscriptionOpenStatus, setClinePassSubscriptionOpenStatus] =
+		useState("");
+	const clinePassSubscriptionUrl = useMemo(() => getCliSubscriptionUrl(), []);
+
+	const modelItems: SearchableItem[] = useMemo(
+		() =>
+			modelEntries.map((m) => ({
+				key: m.id,
+				label: m.name,
+				searchText: `${m.name} ${m.id}`,
+				rightLabel: m.id === modelsDefaultId ? "(default)" : undefined,
+				rightLabelColor: "gray",
+			})),
+		[modelEntries, modelsDefaultId],
+	);
+
+	const createCustomModelItem = useCallback(
+		(_search: string, filteredItems: SearchableItem[]) => {
+			if (activeProviderId === "cline-pass") {
+				return undefined;
+			}
+			if (filteredItems.some((item) => item.key === CUSTOM_MODEL_ID_ACTION)) {
+				return undefined;
+			}
+			return {
+				key: CUSTOM_MODEL_ID_ACTION,
+				label: "Create custom model ID",
+				detail: "manual entry",
+				searchText: "create custom model id manual entry",
+			} satisfies SearchableItem;
+		},
+		[activeProviderId],
+	);
+
+	const modelList = useSearchableList(modelItems, createCustomModelItem);
+
+	// Cline featured model picker (ClinePass gets Subscribed/Free sections)
+	const recommended = useClineRecommendedModels();
+	const clineEntries: ClineModelPickerEntry[] = useMemo(
+		() =>
+			recommended.data
+				? buildFeaturedModelEntries(activeProviderId, recommended.data)
+				: [],
+		[recommended.data, activeProviderId],
+	);
+	const [clineModelSelected, setClineModelSelected] = useState(0);
+	const [clineModelReasoningIds, setClineModelReasoningIds] = useState<
+		Set<string>
+	>(new Set());
+	const [clineKnownModels, setClineKnownModels] = useState<
+		Record<string, unknown> | undefined
+	>(undefined);
+
+	useEffect(() => {
+		// The featured picker serves both cline and cline-pass, so pool reasoning
+		// support and display names from both catalogs
+		void Promise.allSettled(
+			["cline", "cline-pass"].map((providerId) =>
+				getLocalProviderModels(providerId),
+			),
+		).then((results) => {
+			const ids = new Set<string>();
+			for (const result of results) {
+				if (result.status !== "fulfilled") continue;
+				for (const m of result.value.models) {
+					if (m.supportsReasoning) ids.add(m.id);
+				}
+			}
+			setClineModelReasoningIds(ids);
+		});
+		void Promise.allSettled(
+			["cline", "cline-pass"].map((providerId) =>
+				resolveProviderConfig(providerId),
+			),
+		).then((results) => {
+			const merged: Record<string, unknown> = {};
+			for (const result of results) {
+				if (result.status === "fulfilled" && result.value?.knownModels) {
+					Object.assign(merged, result.value.knownModels);
+				}
+			}
+			if (Object.keys(merged).length > 0) {
+				setClineKnownModels(merged);
+			}
+		});
+	}, []);
+
+	// Thinking level
+	const [thinkingSelected, setThinkingSelected] = useState(
+		DEFAULT_THINKING_LEVEL_INDEX,
+	);
+	const [selectedModelName, setSelectedModelName] = useState("");
+	const [selectedModelId, setSelectedModelId] = useState("");
+	const [selectedThinking, setSelectedThinking] = useState(false);
+	const [selectedReasoningEffort, setSelectedReasoningEffort] = useState<
+		ReasoningEffort | undefined
+	>(undefined);
+
+	const loadModelsForProvider = useCallback(
+		(providerId: string) => {
+			setModelsLoading(true);
+			setModelEntries([]);
+			refreshProviderModelsFromSource(providerSettingsManager, providerId)
+				.catch(() => {})
+				.then(async () => {
+					const providerConfig = providerSettingsManager.getProviderConfig(
+						providerId,
+						{ includeKnownModels: false },
+					);
+					const resolved = await resolveProviderConfig(
+						providerId,
+						{
+							loadLatestOnInit: true,
+							loadPrivateOnAuth: true,
+							failOnError: false,
+						},
+						providerConfig,
+					);
+					const resolvedModels = toModelEntriesFromKnownModels(
+						resolved?.knownModels,
+					);
+					if (resolvedModels.length > 0) {
+						setModelsDefaultId(resolved?.modelId ?? "");
+						return resolvedModels;
+					}
+					const { models } = await getLocalProviderModels(
+						providerId,
+						providerConfig,
+					);
+					return models.map(toModelEntry);
+				})
+				.then((models) => {
+					setModelEntries(models);
+				})
+				.catch(() => {})
+				.finally(() => setModelsLoading(false));
+		},
+		[providerSettingsManager],
+	);
+
+	const refreshClinePassSubscriptionStatus = useCallback(() => {
+		setClinePassSubscriptionStatus("loading");
+		setClinePassSubscriptionError("");
+		setClinePassCurrentPlanName("");
+		setClinePassSubscriptionOpenStatus("");
+
+		loadCurrentUserPlanFromProviderSettings({ providerSettingsManager })
+			.then(
+				(value) => ({ status: "fulfilled" as const, value }),
+				(reason) => ({ status: "rejected" as const, reason }),
+			)
+			.then((currentPlanResult) =>
+				loadIndividualSubscriptionPlansFromProviderSettings({
+					providerSettingsManager,
+				})
+					.then(
+						(value) => ({ status: "fulfilled" as const, value }),
+						(reason) => ({ status: "rejected" as const, reason }),
+					)
+					.then((availablePlansResult) => ({
+						availablePlansResult,
+						currentPlanResult,
+					})),
+			)
+			.then(({ currentPlanResult, availablePlansResult }) => {
+				if (availablePlansResult.status === "fulfilled") {
+					setClinePassPlanFeatures(
+						getIndividualPlanFeatures(availablePlansResult.value),
+					);
+				}
+
+				if (currentPlanResult.status === "rejected") {
+					const error = currentPlanResult.reason;
+					const message =
+						error instanceof Error ? error.message : String(error);
+					if (message.trim().toLowerCase() === "no plan found for user") {
+						setClinePassSubscriptionStatus("unsubscribed");
+						return;
+					}
+					setClinePassSubscriptionError(message);
+					setClinePassSubscriptionStatus("error");
+					return;
+				}
+
+				const plan = currentPlanResult.value?.plan;
+				if (plan) {
+					setClinePassCurrentPlanName(
+						plan.displayName || plan.name || plan.id || "ClinePass",
+					);
+					setClinePassSubscriptionStatus("subscribed");
+				} else {
+					setClinePassSubscriptionStatus("unsubscribed");
+				}
+			});
+	}, [providerSettingsManager]);
+
+	const transitionToModelPicker = useCallback(
+		(providerId: string) => {
+			setActiveProviderId(providerId);
+			const provider = providers.find((p) => p.id === providerId);
+			setActiveProviderName(provider?.name ?? providerId);
+			setModelsDefaultId(provider?.defaultModelId ?? "");
+			if (shouldUseFeaturedClineModelPicker(providerId)) {
+				setClineModelSelected(0);
+				setStep("cline_model");
+			} else if (providerId === "openai-compatible") {
+				const existing =
+					providerSettingsManager.getProviderSettings(providerId);
+				setCustomModelId(existing?.model ?? provider?.defaultModelId ?? "");
+				setCustomModelError("");
+				setStep("custom_model_id");
+			} else {
+				setStep("model_picker");
+				loadModelsForProvider(providerId);
+			}
+		},
+		[providers, loadModelsForProvider, providerSettingsManager],
+	);
+
+	const transitionToClinePassSubscription = useCallback(() => {
+		setActiveProviderId("cline-pass");
+		const provider = providers.find((p) => p.id === "cline-pass");
+		setActiveProviderName(provider?.name ?? "ClinePass");
+		setModelsDefaultId(provider?.defaultModelId ?? "");
+		setClinePassSubscriptionSelected(0);
+		setStep("cline_pass_subscription");
+		refreshClinePassSubscriptionStatus();
+	}, [providers, refreshClinePassSubscriptionStatus]);
+
+	const handleAuthComplete = useCallback(
+		(providerId: OnboardingOAuthProviderId) => {
+			if (providerId === "cline-pass") {
+				transitionToClinePassSubscription();
+				return;
+			}
+			transitionToModelPicker(providerId);
+		},
+		[transitionToClinePassSubscription, transitionToModelPicker],
+	);
+
+	const resetAuth = useCallback(() => {
+		setAuthStatus("");
+		setAuthUrl("");
+		setAuthError("");
+		authAbortRef.current = false;
+	}, []);
+
+	const startDeviceCodeFlow = useCallback(
+		(providerId: OnboardingOAuthProviderId) => {
+			deviceAbortRef.current = false;
+			setDeviceUserCode("");
+			setDeviceVerifyUrl("");
+			setDeviceError("");
+			setDeviceStatus("Requesting device code...");
+			setOauthProvider(providerId);
+			setStep("device_code");
+
+			runDeviceCodeAuthFlow({
+				providerId,
+				providerSettingsManager,
+				isAborted: () => deviceAbortRef.current,
+				setUserCode: setDeviceUserCode,
+				setVerifyUrl: setDeviceVerifyUrl,
+				setStatus: setDeviceStatus,
+				setError: setDeviceError,
+				onComplete: handleAuthComplete,
+				telemetry: getCliTelemetryService(),
+			});
+		},
+		[providerSettingsManager, handleAuthComplete],
+	);
+
+	const startOAuthFlow = useCallback(
+		(providerId: OnboardingOAuthProviderId) => {
+			if (isClineProvider(providerId)) {
+				startDeviceCodeFlow(providerId);
+				return;
+			}
+
+			resetAuth();
+			setOauthProvider(providerId);
+			setStep("oauth_pending");
+			setAuthStatus("Opening browser...");
+
+			runOAuthAuthFlow({
+				providerId,
+				providerSettingsManager,
+				isAborted: () => authAbortRef.current,
+				setStatus: setAuthStatus,
+				setAuthUrl,
+				setError: setAuthError,
+				onComplete: handleAuthComplete,
+				telemetry: getCliTelemetryService(),
+			});
+		},
+		[
+			providerSettingsManager,
+			resetAuth,
+			handleAuthComplete,
+			startDeviceCodeFlow,
+		],
+	);
+
+	const continueFromClinePassSubscription = useCallback(() => {
+		transitionToModelPicker("cline-pass");
+	}, [transitionToModelPicker]);
+
+	const openClinePassSubscriptionPage = useCallback(() => {
+		setClinePassSubscriptionOpenStatus("Opening subscription page...");
+		void open(clinePassSubscriptionUrl, { wait: false })
+			.then(() => {
+				setClinePassSubscriptionOpenStatus(
+					"Opened subscription page in your browser.",
+				);
+			})
+			.catch(() => {
+				setClinePassSubscriptionOpenStatus(
+					`Could not open browser automatically. Open ${clinePassSubscriptionUrl}`,
+				);
+			});
+	}, [clinePassSubscriptionUrl]);
+
+	useEffect(() => {
+		if (
+			step === "cline_pass_subscription" &&
+			clinePassSubscriptionStatus === "subscribed"
+		) {
+			transitionToModelPicker("cline-pass");
+		}
+	}, [step, clinePassSubscriptionStatus, transitionToModelPicker]);
+
+	const refreshCodexCliStatus = useCallback(() => {
+		setCodexCliStatus(undefined);
+		setCodexCliChecking(true);
+		checkCodexCliInstalled()
+			.then(setCodexCliStatus)
+			.catch((error: unknown) => {
+				setCodexCliStatus({
+					installed: false,
+					reason: error instanceof Error ? error.message : String(error),
+				});
+			})
+			.finally(() => setCodexCliChecking(false));
+	}, []);
+
+	const selectProvider = useCallback(
+		(providerId: string) => {
+			const provider = providers.find((p) => p.id === providerId);
+			if (!provider) return;
+			if (provider.isOAuth) {
+				if (isOnboardingOAuthProviderId(provider.id)) {
+					startOAuthFlow(provider.id);
+				}
+				return;
+			}
+			if (provider.isLocalAuth || isOpenAICodexCliProvider(provider.id)) {
+				setActiveProviderId(provider.id);
+				setActiveProviderName(provider.name);
+				setCodexCliStatus(undefined);
+				setStep("codex_cli_setup");
+				refreshCodexCliStatus();
+				return;
+			}
+			const config = getProviderConfigFields(provider.id);
+			setActiveProviderId(provider.id);
+			setActiveProviderName(provider.name);
+			setByoFields(config.fields);
+			setByoDescription(config.description);
+
+			// Build initial values from existing settings
+			const existing = providerSettingsManager.getProviderSettings(provider.id);
+			const initialValues: ProviderConfigValues = {};
+			if (config.fields.baseUrl) {
+				initialValues.baseUrl =
+					existing?.baseUrl?.trim() ??
+					config.fields.baseUrl?.defaultValue ??
+					"";
+			}
+			if (config.fields.azureApiVersion) {
+				initialValues.azureApiVersion =
+					existing?.azure?.apiVersion?.trim() ?? "";
+			}
+			if (config.fields.awsRegion) {
+				const existingProfile = existing?.aws?.profile?.trim() ?? "";
+				initialValues.awsRegion =
+					existing?.aws?.region?.trim() || getDefaultAwsRegion(existingProfile);
+			}
+			if (config.fields.apiKey) {
+				initialValues.apiKey = existing?.apiKey?.trim() ?? "";
+			}
+			if (config.fields.awsProfile) {
+				initialValues.awsProfile = existing?.aws?.profile?.trim() ?? "";
+			}
+			if (config.fields.sapClientId) {
+				initialValues.sapClientId = existing?.sap?.clientId?.trim() ?? "";
+			}
+			if (config.fields.sapClientSecret) {
+				initialValues.sapClientSecret =
+					existing?.sap?.clientSecret?.trim() ?? "";
+			}
+			if (config.fields.sapTokenUrl) {
+				initialValues.sapTokenUrl = existing?.sap?.tokenUrl?.trim() ?? "";
+			}
+			if (config.fields.sapResourceGroup) {
+				initialValues.sapResourceGroup =
+					existing?.sap?.resourceGroup?.trim() ?? "default";
+			}
+			if (config.fields.sapDeploymentId) {
+				initialValues.sapDeploymentId =
+					existing?.sap?.deploymentId?.trim() ?? "";
+			}
+			setByoValues(initialValues);
+
+			// Focus the first visible field
+			const firstField = FIELD_ORDER.find(
+				(k) => config.fields[k] !== undefined,
+			);
+			setByoFocusedField(firstField ?? "apiKey");
+			setStep("byo_apikey");
+		},
+		[providers, startOAuthFlow, refreshCodexCliStatus, providerSettingsManager],
+	);
+
+	const saveCodexCliConfig = useCallback(() => {
+		if (!codexCliStatus?.installed) {
+			return;
+		}
+		saveLocalProviderSettings(providerSettingsManager, {
+			providerId: activeProviderId,
+		});
+		transitionToModelPicker(activeProviderId);
+	}, [
+		activeProviderId,
+		codexCliStatus,
+		providerSettingsManager,
+		transitionToModelPicker,
+	]);
+
+	const saveByoConfig = useCallback(() => {
+		// No required-field validation. If credentials are missing or wrong,
+		// the provider's own auth response is the authoritative error and is
+		// surfaced when the model picker / first turn runs.
+		const apiKey = byoValues.apiKey?.trim();
+		const awsProfile = byoValues.awsProfile?.trim();
+		const hasAzureFields = byoFields.azureApiVersion;
+		const hasAwsFields = byoFields.awsRegion || byoFields.awsProfile;
+		const hasSapFields =
+			byoFields.sapClientId ||
+			byoFields.sapClientSecret ||
+			byoFields.sapTokenUrl ||
+			byoFields.sapResourceGroup ||
+			byoFields.sapDeploymentId;
+
+		saveLocalProviderSettings(providerSettingsManager, {
+			providerId: activeProviderId,
+			apiKey: byoFields.apiKey ? apiKey : undefined,
+			baseUrl: byoFields.baseUrl ? byoValues.baseUrl?.trim() : undefined,
+			azure: hasAzureFields ? resolveProviderConfigAzure(byoValues) : undefined,
+			aws: hasAwsFields
+				? {
+						region: resolveProviderConfigAwsRegion(byoValues),
+						authentication: apiKey ? "api-key" : "profile",
+						profile: apiKey ? undefined : awsProfile || undefined,
+					}
+				: undefined,
+			sap: hasSapFields ? resolveProviderConfigSap(byoValues) : undefined,
+		});
+		// Emit a single `user.provider_configured` event mirroring the
+		// `{ provider }` payload shape used by the auth funnel. The save above
+		// is synchronous and infallible, so there's no start/fail counterpart;
+		// invalid credentials surface later as `task.provider_api_error` on
+		// the first real API call.
+		captureProviderConfigured(getCliTelemetryService(), activeProviderId);
+		transitionToModelPicker(activeProviderId);
+	}, [
+		byoValues,
+		byoFields,
+		activeProviderId,
+		providerSettingsManager,
+		transitionToModelPicker,
+	]);
+
+	const completeModelSelection = useCallback(
+		(modelId: string) => {
+			const existing =
+				providerSettingsManager.getProviderSettings(activeProviderId);
+			providerSettingsManager.saveProviderSettings(
+				{ ...(existing ?? { provider: activeProviderId }), model: modelId },
+				{ setLastUsed: true },
+			);
+			setSelectedModelId(modelId);
+			const entry = modelEntries.find((m) => m.id === modelId);
+			if (entry?.supportsReasoning) {
+				setSelectedModelName(entry.name);
+				setThinkingSelected(DEFAULT_THINKING_LEVEL_INDEX);
+				setStep("thinking_level");
+			} else {
+				setStep("done");
+			}
+		},
+		[activeProviderId, modelEntries, providerSettingsManager],
+	);
+
+	const selectModelItem = useCallback(
+		(item: SearchableItem | undefined) => {
+			if (!item) return;
+			if (item.key === CUSTOM_MODEL_ID_ACTION) {
+				setCustomModelId("");
+				setCustomModelError("");
+				setStep("custom_model_id");
+				return;
+			}
+			completeModelSelection(item.key);
+		},
+		[completeModelSelection],
+	);
+
+	const saveModelSelection = useCallback(() => {
+		selectModelItem(modelList.selectedItem);
+	}, [modelList.selectedItem, selectModelItem]);
+
+	const saveCustomModelId = useCallback(() => {
+		const modelId = customModelId.trim();
+		if (!modelId) {
+			setCustomModelError("Enter a model ID");
+			return;
+		}
+		completeModelSelection(modelId);
+	}, [customModelId, completeModelSelection]);
+
+	const saveClineModelSelection = useCallback(
+		(modelId: string, modelName: string) => {
+			const existing =
+				providerSettingsManager.getProviderSettings(activeProviderId);
+			providerSettingsManager.saveProviderSettings(
+				{
+					...(existing ?? { provider: activeProviderId }),
+					model: modelId,
+				},
+				{ setLastUsed: true },
+			);
+			setSelectedModelId(modelId);
+			if (clineModelReasoningIds.has(modelId)) {
+				setSelectedModelName(modelName);
+				setThinkingSelected(DEFAULT_THINKING_LEVEL_INDEX);
+				setStep("thinking_level");
+			} else {
+				setStep("done");
+			}
+		},
+		[activeProviderId, clineModelReasoningIds, providerSettingsManager],
+	);
+
+	const saveThinkingLevel = useCallback(
+		(level: ThinkingLevel) => {
+			const existing =
+				providerSettingsManager.getProviderSettings(activeProviderId);
+			if (level === "none") {
+				providerSettingsManager.saveProviderSettings({
+					...(existing ?? { provider: activeProviderId }),
+					reasoning: { enabled: false },
+				});
+				setSelectedThinking(false);
+				setSelectedReasoningEffort(undefined);
+			} else {
+				providerSettingsManager.saveProviderSettings({
+					...(existing ?? { provider: activeProviderId }),
+					reasoning: { enabled: true, effort: level },
+				});
+				setSelectedThinking(true);
+				setSelectedReasoningEffort(level);
+			}
+			setStep("done");
+		},
+		[activeProviderId, providerSettingsManager],
+	);
+
+	useEffect(() => {
+		if (step !== "done") return undefined;
+		const timer = setTimeout(() => {
+			const providerSettings =
+				providerSettingsManager.getProviderSettings(activeProviderId);
+			onComplete({
+				providerId: activeProviderId,
+				modelId: selectedModelId,
+				apiKey: getPersistedProviderApiKey(activeProviderId, providerSettings),
+				thinking: selectedThinking,
+				reasoningEffort: selectedReasoningEffort,
+			});
+		}, 500);
+		return () => clearTimeout(timer);
+	}, [
+		step,
+		onComplete,
+		activeProviderId,
+		selectedModelId,
+		selectedThinking,
+		selectedReasoningEffort,
+		providerSettingsManager,
+	]);
+
+	useOnboardingKeyboard({
+		step,
+		onExit: props.onExit,
+		oauthProvider,
+		activeProviderId,
+		menuOptions,
+		menuSelected,
+		providerList,
+		modelList,
+		clineEntries,
+		clineModelSelected,
+		clinePassSubscriptionStatus,
+		clinePassSubscriptionOptions: CLINE_PASS_SUBSCRIPTION_OPTIONS,
+		clinePassSubscriptionSelected,
+		thinkingSelected,
+		setStep,
+		setMenuSelected,
+		resetByoFields: () => {
+			setByoFields({});
+			setByoValues({});
+			setByoDescription(undefined);
+		},
+		byoFields,
+		byoFocusedField,
+		setByoFocusedField,
+		setDeviceUserCode,
+		setDeviceVerifyUrl,
+		setDeviceError,
+		setDeviceStatus,
+		setClineModelSelected,
+		setClinePassSubscriptionSelected,
+		setThinkingSelected,
+		continueFromClinePassSubscription,
+		refreshClinePassSubscriptionStatus,
+		openClinePassSubscriptionPage,
+		abortOAuth: () => {
+			authAbortRef.current = true;
+		},
+		abortDeviceCode: () => {
+			deviceAbortRef.current = true;
+		},
+		resetAuth,
+		refreshCodexCliStatus,
+		startOAuthFlow,
+		startDeviceCodeFlow,
+		selectProvider,
+		loadModelsForProvider,
+		saveClineModelSelection,
+		saveCodexCliConfig,
+		saveByoConfig,
+		saveModelSelection,
+		saveThinkingLevel,
+	});
+
+	return {
+		activeProviderName,
+		activeProviderId,
+		authError,
+		authStatus,
+		authUrl,
+		byoDescription,
+		byoFields,
+		byoFocusedField,
+		byoValues,
+		codexCliChecking,
+		codexCliStatus,
+		clineEntries,
+		clineKnownModels,
+		clineModelSelected,
+		clinePassCurrentPlanName,
+		clinePassPlanFeatures,
+		clinePassSubscriptionError,
+		clinePassSubscriptionOpenStatus,
+		clinePassSubscriptionOptions: CLINE_PASS_SUBSCRIPTION_OPTIONS,
+		clinePassSubscriptionSelected,
+		clinePassSubscriptionStatus,
+		clinePassSubscriptionUrl,
+		deviceError,
+		deviceStatus,
+		deviceUserCode,
+		deviceVerifyUrl,
+		customModelError,
+		customModelId,
+		customModelTitle:
+			activeProviderId === "openai-compatible"
+				? "Set model ID"
+				: "Create custom model ID",
+		handleByoFieldInput: (field: ProviderConfigFieldKey, value: string) => {
+			setByoValues((prev) => updateProviderConfigValue(prev, field, value));
+		},
+		handleCustomModelIdInput: (value: string) => {
+			setCustomModelId(value);
+			setCustomModelError("");
+		},
+		handleModelItemSelect: selectModelItem,
+		menuSelected,
+		menuOptions,
+		modelItems,
+		modelList,
+		modelsLoading,
+		oauthProvider,
+		providerList,
+		providersLoading,
+		recommendedLoading: recommended.loading,
+		saveByoConfig,
+		saveCodexCliConfig,
+		saveCustomModelId,
+		selectedModelName,
+		step,
+		thinkingSelected,
+	};
+}
diff --git a/apps/cli/src/tui/views/onboarding/fields.ts b/apps/cli/src/tui/views/onboarding/fields.ts
new file mode 100644
index 0000000..0002bbe
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/fields.ts
@@ -0,0 +1,15 @@
+import type { ProviderConfigFieldKey } from "@cline/core";
+
+/** Render order for provider config fields and Tab cycling. */
+export const FIELD_ORDER: ProviderConfigFieldKey[] = [
+	"awsRegion",
+	"baseUrl",
+	"azureApiVersion",
+	"apiKey",
+	"awsProfile",
+	"sapClientId",
+	"sapClientSecret",
+	"sapTokenUrl",
+	"sapResourceGroup",
+	"sapDeploymentId",
+];
diff --git a/apps/cli/src/tui/views/onboarding/index.ts b/apps/cli/src/tui/views/onboarding/index.ts
new file mode 100644
index 0000000..949e000
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/index.ts
@@ -0,0 +1,2 @@
+export type { OnboardingResult } from "./model";
+export { OnboardingView } from "./view";
diff --git a/apps/cli/src/tui/views/onboarding/keyboard.ts b/apps/cli/src/tui/views/onboarding/keyboard.ts
new file mode 100644
index 0000000..a2bc566
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/keyboard.ts
@@ -0,0 +1,316 @@
+import type { ProviderConfigFieldKey } from "@cline/core";
+import { useKeyboard } from "@opentui/react";
+import type { Dispatch, SetStateAction } from "react";
+import type { ClineModelPickerEntry } from "../../components/model-selector/cline-model-picker";
+import type { SearchableListState } from "../../components/searchable-list";
+import {
+	isOnboardingOAuthProviderId,
+	type OnboardingOAuthProviderId,
+} from "./auth";
+import { FIELD_ORDER } from "./fields";
+import {
+	type ClinePassSubscriptionOption,
+	type ClinePassSubscriptionStatus,
+	type MenuOption,
+	type OnboardingStep,
+	THINKING_LEVELS,
+	type ThinkingLevel,
+} from "./model";
+
+export function useOnboardingKeyboard(input: {
+	step: OnboardingStep;
+	onExit: () => void;
+	oauthProvider: string;
+	activeProviderId: string;
+	menuOptions: MenuOption[];
+	menuSelected: number;
+	providerList: SearchableListState;
+	modelList: SearchableListState;
+	clineEntries: ClineModelPickerEntry[];
+	clineModelSelected: number;
+	clinePassSubscriptionStatus: ClinePassSubscriptionStatus;
+	clinePassSubscriptionOptions: ClinePassSubscriptionOption[];
+	clinePassSubscriptionSelected: number;
+	thinkingSelected: number;
+	setStep: (step: OnboardingStep) => void;
+	setMenuSelected: Dispatch<SetStateAction<number>>;
+	resetByoFields: () => void;
+	byoFields: Partial<Record<ProviderConfigFieldKey, unknown>>;
+	byoFocusedField: ProviderConfigFieldKey;
+	setByoFocusedField: Dispatch<SetStateAction<ProviderConfigFieldKey>>;
+	setDeviceUserCode: (value: string) => void;
+	setDeviceVerifyUrl: (value: string) => void;
+	setDeviceError: (value: string) => void;
+	setDeviceStatus: (value: string) => void;
+	setClineModelSelected: Dispatch<SetStateAction<number>>;
+	setClinePassSubscriptionSelected: Dispatch<SetStateAction<number>>;
+	setThinkingSelected: Dispatch<SetStateAction<number>>;
+	continueFromClinePassSubscription: () => void;
+	refreshClinePassSubscriptionStatus: () => void;
+	openClinePassSubscriptionPage: () => void;
+	abortOAuth: () => void;
+	abortDeviceCode: () => void;
+	resetAuth: () => void;
+	refreshCodexCliStatus: () => void;
+	startOAuthFlow: (providerId: OnboardingOAuthProviderId) => void;
+	startDeviceCodeFlow: (providerId: OnboardingOAuthProviderId) => void;
+	selectProvider: (providerId: string) => void;
+	loadModelsForProvider: (providerId: string) => void;
+	saveClineModelSelection: (modelId: string, modelName: string) => void;
+	saveCodexCliConfig: () => void;
+	saveByoConfig: () => void;
+	saveModelSelection: () => void;
+	saveThinkingLevel: (level: ThinkingLevel) => void;
+}) {
+	useKeyboard((key) => {
+		if (input.step === "done") return;
+
+		if (key.ctrl && key.name === "c") {
+			input.onExit();
+			return;
+		}
+
+		if (key.name === "escape") {
+			if (input.step === "oauth_pending") {
+				input.abortOAuth();
+				input.resetAuth();
+				input.setStep("menu");
+				input.setMenuSelected(0);
+				return;
+			}
+			if (input.step === "device_code") {
+				input.abortDeviceCode();
+				input.setDeviceUserCode("");
+				input.setDeviceVerifyUrl("");
+				input.setDeviceError("");
+				input.setDeviceStatus("");
+				input.setStep("menu");
+				input.setMenuSelected(0);
+				return;
+			}
+			if (input.step === "byo_apikey") {
+				input.resetByoFields();
+				input.setStep("byo_provider");
+				return;
+			}
+			if (input.step === "byo_provider") {
+				input.setStep("menu");
+				input.setMenuSelected(0);
+				return;
+			}
+			if (input.step === "codex_cli_setup") {
+				input.setStep("byo_provider");
+				return;
+			}
+			if (input.step === "cline_pass_subscription") {
+				input.setStep("menu");
+				input.setMenuSelected(0);
+				return;
+			}
+			if (input.step === "cline_model") {
+				input.setStep("menu");
+				input.setMenuSelected(0);
+				return;
+			}
+			if (input.step === "model_picker") {
+				if (input.activeProviderId === "cline") {
+					input.setClineModelSelected(0);
+					input.setStep("cline_model");
+				} else {
+					input.setStep("menu");
+					input.setMenuSelected(0);
+				}
+				return;
+			}
+			if (input.step === "custom_model_id") {
+				input.setStep("model_picker");
+				return;
+			}
+			if (input.step === "thinking_level") {
+				if (input.activeProviderId === "cline") {
+					input.setClineModelSelected(0);
+					input.setStep("cline_model");
+				} else {
+					input.setStep("model_picker");
+					input.loadModelsForProvider(input.activeProviderId);
+				}
+			}
+			return;
+		}
+
+		if (input.step === "oauth_pending") {
+			if (key.name === "d" && input.oauthProvider === "cline") {
+				input.abortOAuth();
+				input.resetAuth();
+				input.startDeviceCodeFlow("cline");
+			}
+			return;
+		}
+
+		if (input.step === "device_code") return;
+
+		if (input.step === "cline_pass_subscription") {
+			const total = input.clinePassSubscriptionOptions.length;
+			if (total === 0) return;
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				input.setClinePassSubscriptionSelected((s) =>
+					s <= 0 ? total - 1 : s - 1,
+				);
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				input.setClinePassSubscriptionSelected((s) =>
+					s >= total - 1 ? 0 : s + 1,
+				);
+				return;
+			}
+			if (key.name === "return" || key.name === "enter") {
+				const option =
+					input.clinePassSubscriptionOptions[
+						Math.min(input.clinePassSubscriptionSelected, total - 1)
+					];
+				if (!option) return;
+				if (option.value === "subscribe") {
+					input.openClinePassSubscriptionPage();
+				} else if (option.value === "refresh") {
+					if (input.clinePassSubscriptionStatus !== "loading") {
+						input.refreshClinePassSubscriptionStatus();
+					}
+				} else if (option.value === "skip") {
+					input.continueFromClinePassSubscription();
+				} else if (option.value === "back") {
+					input.setStep("menu");
+					input.setMenuSelected(0);
+				}
+			}
+			return;
+		}
+
+		if (input.step === "menu") {
+			if (key.name === "up") {
+				input.setMenuSelected((s) =>
+					s <= 0 ? input.menuOptions.length - 1 : s - 1,
+				);
+				return;
+			}
+			if (key.name === "down") {
+				input.setMenuSelected((s) =>
+					s >= input.menuOptions.length - 1 ? 0 : s + 1,
+				);
+				return;
+			}
+			if (key.name === "return") {
+				const option = input.menuOptions[input.menuSelected];
+				if (!option) return;
+				if (isOnboardingOAuthProviderId(option.value)) {
+					input.startOAuthFlow(option.value);
+				} else {
+					input.setStep("byo_provider");
+				}
+			}
+			return;
+		}
+
+		if (input.step === "byo_provider") {
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				input.providerList.moveUp();
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				input.providerList.moveDown();
+				return;
+			}
+			if (key.name === "return") {
+				const item = input.providerList.selectedItem;
+				if (item) input.selectProvider(item.key);
+			}
+			return;
+		}
+
+		if (input.step === "codex_cli_setup") {
+			if (key.name === "r") {
+				input.refreshCodexCliStatus();
+				return;
+			}
+			if (key.name === "return") {
+				input.saveCodexCliConfig();
+			}
+			return;
+		}
+
+		if (input.step === "byo_apikey") {
+			if (key.name === "tab") {
+				const visible = FIELD_ORDER.filter(
+					(k) => input.byoFields[k] !== undefined,
+				);
+				if (visible.length > 1) {
+					const idx = visible.indexOf(input.byoFocusedField);
+					const nextIdx = key.shift
+						? (idx - 1 + visible.length) % visible.length
+						: (idx + 1) % visible.length;
+					const next = visible[nextIdx];
+					if (next) input.setByoFocusedField(next as ProviderConfigFieldKey);
+				}
+			}
+			return;
+		}
+
+		if (input.step === "cline_model") {
+			const total = input.clineEntries.length;
+			if (total === 0) return;
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				input.setClineModelSelected((s) => (s <= 0 ? total - 1 : s - 1));
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				input.setClineModelSelected((s) => (s >= total - 1 ? 0 : s + 1));
+				return;
+			}
+			if (key.name === "return") {
+				const entry = input.clineEntries[input.clineModelSelected];
+				if (!entry) return;
+				if (entry.kind === "model") {
+					input.saveClineModelSelection(entry.model.id, entry.model.name);
+				} else {
+					input.setStep("model_picker");
+					input.loadModelsForProvider(input.activeProviderId);
+				}
+			}
+			return;
+		}
+
+		if (input.step === "model_picker") {
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				input.modelList.moveUp();
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				input.modelList.moveDown();
+				return;
+			}
+			if (key.name === "return") {
+				input.saveModelSelection();
+			}
+			return;
+		}
+
+		if (input.step === "thinking_level") {
+			if (key.name === "up" || (key.ctrl && key.name === "p")) {
+				input.setThinkingSelected((s) =>
+					s <= 0 ? THINKING_LEVELS.length - 1 : s - 1,
+				);
+				return;
+			}
+			if (key.name === "down" || (key.ctrl && key.name === "n")) {
+				input.setThinkingSelected((s) =>
+					s >= THINKING_LEVELS.length - 1 ? 0 : s + 1,
+				);
+				return;
+			}
+			if (key.name === "return") {
+				const level = THINKING_LEVELS[input.thinkingSelected];
+				if (level) input.saveThinkingLevel(level.value);
+			}
+		}
+	});
+}
diff --git a/apps/cli/src/tui/views/onboarding/model.test.ts b/apps/cli/src/tui/views/onboarding/model.test.ts
new file mode 100644
index 0000000..e7ed730
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/model.test.ts
@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+import {
+	getMainMenuOptions,
+	getOAuthProviderLabel,
+	shouldUseFeaturedClineModelPicker,
+	toModelEntriesFromKnownModels,
+	toModelEntry,
+	toProviderEntry,
+} from "./model";
+
+describe("onboarding model helpers", () => {
+	it("hides ClinePass from the main menu unless its feature flag is enabled", () => {
+		expect(
+			getMainMenuOptions().some((option) => option.value === "cline-pass"),
+		).toBe(false);
+		expect(
+			getMainMenuOptions({ isClinePassEnabled: false }).some(
+				(option) => option.value === "cline-pass",
+			),
+		).toBe(false);
+		expect(
+			getMainMenuOptions({ isClinePassEnabled: true }).some(
+				(option) => option.value === "cline-pass",
+			),
+		).toBe(true);
+	});
+
+	it("maps provider catalog entries into onboarding provider entries", () => {
+		expect(
+			toProviderEntry({
+				id: "cline",
+				name: "Cline",
+				apiKey: "",
+				oauthAccessTokenPresent: true,
+				models: 12,
+				defaultModelId: "openai/gpt-5.3-codex",
+			}),
+		).toEqual({
+			id: "cline",
+			name: "Cline",
+			isOAuth: true,
+			isLocalAuth: false,
+			hasAuth: true,
+			models: 12,
+			defaultModelId: "openai/gpt-5.3-codex",
+		});
+	});
+
+	it("treats API key providers as authenticated when an API key exists", () => {
+		expect(
+			toProviderEntry({
+				id: "anthropic",
+				name: "Anthropic",
+				apiKey: "sk-test",
+				models: null,
+			}),
+		).toMatchObject({
+			id: "anthropic",
+			isOAuth: false,
+			isLocalAuth: false,
+			hasAuth: true,
+			models: null,
+		});
+	});
+
+	it("marks the OpenAI Codex CLI provider as local auth", () => {
+		expect(
+			toProviderEntry({
+				id: "openai-codex-cli",
+				name: "OpenAI Codex CLI",
+				models: null,
+			}),
+		).toMatchObject({
+			id: "openai-codex-cli",
+			isOAuth: false,
+			isLocalAuth: true,
+		});
+	});
+
+	it("maps model names and reasoning support strictly", () => {
+		expect(
+			toModelEntry({
+				id: "anthropic/claude-sonnet-4.6",
+				supportsReasoning: false,
+			}),
+		).toEqual({
+			id: "anthropic/claude-sonnet-4.6",
+			name: "anthropic/claude-sonnet-4.6",
+			supportsReasoning: false,
+		});
+
+		expect(
+			toModelEntry({
+				id: "openai/gpt-5.3-codex",
+				name: "GPT-5.3 Codex",
+				supportsReasoning: true,
+			}),
+		).toEqual({
+			id: "openai/gpt-5.3-codex",
+			name: "GPT-5.3 Codex",
+			supportsReasoning: true,
+		});
+	});
+
+	it("maps resolved known models into sorted onboarding model entries", () => {
+		expect(
+			toModelEntriesFromKnownModels({
+				"gpt-5.2": {
+					name: "GPT-5.2",
+					capabilities: ["tools"],
+				},
+				"gpt-5.3-codex": {
+					name: "GPT-5.3 Codex",
+					capabilities: ["tools", "reasoning"],
+				},
+			}),
+		).toEqual([
+			{
+				id: "gpt-5.2",
+				name: "GPT-5.2",
+				supportsReasoning: false,
+			},
+			{
+				id: "gpt-5.3-codex",
+				name: "GPT-5.3 Codex",
+				supportsReasoning: true,
+			},
+		]);
+	});
+
+	it("formats OAuth provider labels for onboarding status views", () => {
+		expect(getOAuthProviderLabel("cline")).toBe("Cline");
+		expect(getOAuthProviderLabel("cline-pass")).toBe("ClinePass");
+		expect(getOAuthProviderLabel("openai-codex")).toBe("ChatGPT");
+		expect(getOAuthProviderLabel("oca")).toBe("oca");
+	});
+
+	it("uses the featured Cline model picker for the Cline and ClinePass providers", () => {
+		expect(shouldUseFeaturedClineModelPicker("cline")).toBe(true);
+		expect(shouldUseFeaturedClineModelPicker("cline-pass")).toBe(true);
+		expect(shouldUseFeaturedClineModelPicker("anthropic")).toBe(false);
+	});
+});
diff --git a/apps/cli/src/tui/views/onboarding/model.ts b/apps/cli/src/tui/views/onboarding/model.ts
new file mode 100644
index 0000000..5d202f5
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/model.ts
@@ -0,0 +1,212 @@
+import { isOpenAICodexCliProvider } from "../../../utils/codex-cli";
+import { isOAuthProvider } from "../../../utils/provider-auth";
+
+export type OnboardingStep =
+	| "menu"
+	| "oauth_pending"
+	| "device_code"
+	| "byo_provider"
+	| "byo_apikey"
+	| "codex_cli_setup"
+	| "cline_pass_subscription"
+	| "cline_model"
+	| "model_picker"
+	| "custom_model_id"
+	| "thinking_level"
+	| "done";
+
+export type ThinkingLevel = "none" | "low" | "medium" | "high" | "xhigh";
+export type ReasoningEffort = Exclude<ThinkingLevel, "none">;
+
+export const THINKING_LEVELS: {
+	value: ThinkingLevel;
+	label: string;
+	desc: string;
+}[] = [
+	{ value: "none", label: "Off", desc: "No extended thinking" },
+	{ value: "low", label: "Low", desc: "Minimal reasoning" },
+	{ value: "medium", label: "Medium", desc: "Balanced reasoning" },
+	{ value: "high", label: "High", desc: "Deep reasoning" },
+	{ value: "xhigh", label: "Extra High", desc: "Maximum reasoning" },
+];
+
+export const DEFAULT_THINKING_LEVEL_INDEX = THINKING_LEVELS.findIndex(
+	(l) => l.value === "medium",
+);
+
+export interface MenuOption {
+	label: string;
+	value: string;
+	detail: string;
+	icon: string;
+}
+
+export type ClinePassSubscriptionAction =
+	| "subscribe"
+	| "refresh"
+	| "skip"
+	| "back";
+
+export interface ClinePassSubscriptionOption {
+	value: ClinePassSubscriptionAction;
+	label: string;
+}
+
+export const MAIN_MENU: MenuOption[] = [
+	{
+		label: "Sign in with Cline",
+		value: "cline",
+		detail: "Latest models with regular free promos",
+		icon: "\u263a",
+	},
+	{
+		label: "Sign in with ClinePass",
+		value: "cline-pass",
+		detail: "Low cost subscription for everyone",
+		icon: "\u2726",
+	},
+	{
+		label: "Sign in with ChatGPT",
+		value: "openai-codex",
+		detail: "Use your ChatGPT Plus subscription",
+		icon: "\u2726",
+	},
+	{
+		label: "Bring your own provider",
+		value: "byo",
+		detail: "API key or local server (e.g. Ollama)",
+		icon: "\u26b7",
+	},
+];
+
+export function getMainMenuOptions(options?: {
+	isClinePassEnabled?: boolean;
+}): MenuOption[] {
+	return MAIN_MENU.filter(
+		(option) => option.value !== "cline-pass" || options?.isClinePassEnabled,
+	);
+}
+
+export const CLINE_PASS_SUBSCRIPTION_OPTIONS: ClinePassSubscriptionOption[] = [
+	{
+		value: "subscribe",
+		label: "Subscribe to ClinePass",
+	},
+	{
+		value: "refresh",
+		label: "Re-check subscription status",
+	},
+	{
+		value: "skip",
+		label: "Skip for now",
+	},
+	{
+		value: "back",
+		label: "Go back",
+	},
+];
+
+export interface OnboardingResult {
+	providerId: string;
+	modelId: string;
+	apiKey?: string;
+	thinking?: boolean;
+	reasoningEffort?: ReasoningEffort;
+}
+
+export interface ProviderEntry {
+	id: string;
+	name: string;
+	isOAuth: boolean;
+	isLocalAuth: boolean;
+	hasAuth: boolean;
+	capabilities?: readonly string[];
+	models: number | null;
+	defaultModelId?: string;
+}
+
+export interface ModelEntry {
+	id: string;
+	name: string;
+	supportsReasoning: boolean;
+}
+
+export type ClinePassSubscriptionStatus =
+	| "loading"
+	| "subscribed"
+	| "unsubscribed"
+	| "error";
+
+export interface ProviderCatalogItem {
+	id: string;
+	name: string;
+	apiKey?: string;
+	oauthAccessTokenPresent?: boolean;
+	capabilities?: readonly string[];
+	models: number | null;
+	defaultModelId?: string;
+}
+
+export interface ProviderModelItem {
+	id: string;
+	name?: string;
+	supportsReasoning?: boolean;
+}
+
+export interface KnownModelInfo {
+	name?: string;
+	capabilities?: string[];
+}
+
+export function toProviderEntry(provider: ProviderCatalogItem): ProviderEntry {
+	return {
+		id: provider.id,
+		name: provider.name,
+		isOAuth: isOAuthProvider(provider.id),
+		isLocalAuth: isOpenAICodexCliProvider(provider.id),
+		hasAuth:
+			Boolean(provider.apiKey) || provider.oauthAccessTokenPresent === true,
+		...(provider.capabilities ? { capabilities: provider.capabilities } : {}),
+		models: provider.models,
+		defaultModelId: provider.defaultModelId,
+	};
+}
+
+export function toModelEntry(model: ProviderModelItem): ModelEntry {
+	return {
+		id: model.id,
+		name: model.name || model.id,
+		supportsReasoning: model.supportsReasoning === true,
+	};
+}
+
+export function toModelEntriesFromKnownModels(
+	knownModels: Record<string, KnownModelInfo> | undefined,
+): ModelEntry[] {
+	if (!knownModels) return [];
+	return Object.entries(knownModels)
+		.map(([id, info]) => ({
+			id,
+			name: info.name || id,
+			supportsReasoning: info.capabilities?.includes("reasoning") ?? false,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function getOAuthProviderLabel(providerId: string): string {
+	if (providerId === "cline-pass") {
+		return "ClinePass";
+	}
+	if (providerId === "cline") {
+		return "Cline";
+	}
+	if (providerId === "openai-codex") {
+		return "ChatGPT";
+	}
+	return providerId;
+}
+
+export function shouldUseFeaturedClineModelPicker(providerId: string): boolean {
+	// ClinePass uses the featured picker too, with Subscribed/Free sections
+	return providerId === "cline" || providerId === "cline-pass";
+}
diff --git a/apps/cli/src/tui/views/onboarding/screens.tsx b/apps/cli/src/tui/views/onboarding/screens.tsx
new file mode 100644
index 0000000..2675080
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/screens.tsx
@@ -0,0 +1,916 @@
+import "opentui-spinner/react";
+import type { ScrollBoxRenderable } from "@opentui/core";
+import type { ReactNode } from "react";
+import { useEffect, useRef } from "react";
+import {
+	CODEX_CLI_INSTALL_URL,
+	type CodexCliStatus,
+} from "../../../utils/codex-cli";
+import {
+	ClineModelPicker,
+	type ClineModelPickerEntry,
+} from "../../components/model-selector/cline-model-picker";
+import {
+	type SearchableItem,
+	SearchableList,
+	type SearchableListState,
+} from "../../components/searchable-list";
+import {
+	TrackedRobot,
+	type useMouseTracker,
+} from "../../components/tracked-robot";
+import {
+	useTerminalBackground,
+	useTerminalTheme,
+} from "../../hooks/use-terminal-background";
+import { getDefaultForeground, getModeAccent, palette } from "../../palette";
+import { FIELD_ORDER } from "./fields";
+import {
+	type ClinePassSubscriptionOption,
+	type ClinePassSubscriptionStatus,
+	type MenuOption,
+	THINKING_LEVELS,
+} from "./model";
+
+type MouseTrackerState = ReturnType<typeof useMouseTracker>;
+
+function useDefaultFg(): string | undefined {
+	const terminalBg = useTerminalBackground();
+	return getDefaultForeground(terminalBg);
+}
+
+function getClinePassSubscriptionOptionId(index: number): string {
+	return `cline-pass-subscription-option-${index}`;
+}
+
+interface OnboardingFrameProps {
+	children: ReactNode;
+	compact: boolean;
+	contentWidth: number;
+	mouse: MouseTrackerState;
+}
+
+function OnboardingFrame({
+	children,
+	compact,
+	contentWidth,
+	mouse,
+}: OnboardingFrameProps) {
+	return (
+		<box
+			flexDirection="column"
+			width="100%"
+			height="100%"
+			justifyContent="center"
+			alignItems="center"
+			onMouseMove={mouse.onMouseMove}
+		>
+			{!compact && (
+				<TrackedRobot cursorX={mouse.cursor.x} cursorY={mouse.cursor.y} />
+			)}
+			<box
+				flexDirection="column"
+				width={contentWidth}
+				marginTop={compact ? 0 : 1}
+				gap={1}
+			>
+				{children}
+			</box>
+		</box>
+	);
+}
+
+export function OnboardingDoneScreen(props: { mouse: MouseTrackerState }) {
+	return (
+		<box
+			flexDirection="column"
+			width="100%"
+			height="100%"
+			justifyContent="center"
+			alignItems="center"
+			onMouseMove={props.mouse.onMouseMove}
+		>
+			<text fg={palette.success}>{"\u2714"} You're all set!</text>
+		</box>
+	);
+}
+
+export function OnboardingOAuthPendingScreen(props: {
+	authError: string;
+	authStatus: string;
+	authUrl: string;
+	compact: boolean;
+	contentWidth: number;
+	label: string;
+	mouse: MouseTrackerState;
+	oauthProvider: string;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<box flexDirection="column" alignItems="center" gap={1}>
+				<text fg={defaultFg}>Signing in with {props.label}</text>
+
+				{!props.authError && (
+					<box flexDirection="row" gap={1} justifyContent="center">
+						<spinner name="dots" color={palette.act} />
+						<text fg="gray">{props.authStatus}</text>
+					</box>
+				)}
+
+				{props.authError && (
+					<box flexDirection="column" alignItems="center" gap={1}>
+						<text fg="red">{props.authError}</text>
+						<text fg="gray">Esc to go back</text>
+					</box>
+				)}
+
+				{props.authUrl && !props.authError && (
+					<box
+						flexDirection="column"
+						border
+						borderStyle="rounded"
+						borderColor="#333333"
+						paddingX={2}
+						paddingY={1}
+						width={props.contentWidth}
+					>
+						<text fg="gray">If the browser didn't open:</text>
+						<text fg={palette.act} marginTop={1} selectable>
+							<a href={props.authUrl}>{props.authUrl}</a>
+						</text>
+					</box>
+				)}
+
+				<text fg="gray">
+					<em>Esc to cancel, Ctrl+C to exit</em>
+				</text>
+			</box>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingDeviceCodeScreen(props: {
+	compact: boolean;
+	contentWidth: number;
+	deviceError: string;
+	deviceStatus: string;
+	deviceUserCode: string;
+	deviceVerifyUrl: string;
+	label: string;
+	mouse: MouseTrackerState;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<box flexDirection="column" alignItems="center" gap={1}>
+				<text fg={defaultFg}>Signing in with {props.label}</text>
+
+				{!props.deviceUserCode && !props.deviceError && (
+					<box flexDirection="row" gap={1} justifyContent="center">
+						<spinner name="dots" color={palette.act} />
+						<text fg="gray">{props.deviceStatus}</text>
+					</box>
+				)}
+
+				{props.deviceError && (
+					<box flexDirection="column" alignItems="center" gap={1}>
+						<text fg="red">{props.deviceError}</text>
+						<text fg="gray">Esc to go back</text>
+					</box>
+				)}
+
+				{props.deviceUserCode && !props.deviceError && (
+					<box
+						flexDirection="column"
+						border
+						borderStyle="rounded"
+						borderColor={palette.act}
+						paddingX={2}
+						paddingY={1}
+						width={props.contentWidth}
+						alignItems="center"
+						gap={1}
+					>
+						<text fg="gray">Your code:</text>
+						<text fg={defaultFg} selectable>
+							<strong>{props.deviceUserCode}</strong>
+						</text>
+						<text fg="gray" marginTop={1}>
+							Visit this URL and enter the code above:
+						</text>
+						<text fg={palette.act} selectable>
+							<a href={props.deviceVerifyUrl}>{props.deviceVerifyUrl}</a>
+						</text>
+					</box>
+				)}
+
+				{props.deviceUserCode && !props.deviceError && (
+					<box flexDirection="row" gap={1} justifyContent="center">
+						<spinner name="dots" color={palette.act} />
+						<text fg="gray">Waiting for sign-in...</text>
+					</box>
+				)}
+
+				<text fg="gray">
+					<em>Esc to cancel, Ctrl+C to exit</em>
+				</text>
+			</box>
+		</OnboardingFrame>
+	);
+}
+
+import type {
+	ProviderConfigFieldKey,
+	ProviderConfigFieldRequirement,
+} from "@cline/core";
+
+const DEFAULT_FIELD_LABELS: Partial<Record<ProviderConfigFieldKey, string>> = {
+	apiKey: "API key",
+	baseUrl: "Base URL",
+	azureApiVersion: "Azure API Version",
+	awsRegion: "AWS Region",
+	awsProfile: "AWS Profile Name",
+	sapClientId: "Client ID",
+	sapClientSecret: "Client Secret",
+	sapTokenUrl: "Token URL",
+	sapResourceGroup: "Resource Group",
+	sapDeploymentId: "Deployment ID",
+};
+
+const DEFAULT_FIELD_PLACEHOLDERS: Partial<
+	Record<ProviderConfigFieldKey, string>
+> = {
+	apiKey: "Paste your API key here...",
+	baseUrl: "",
+	azureApiVersion: "2025-01-01-preview",
+	awsRegion: "us-east-1",
+	awsProfile: "default",
+	sapClientId: "sb-...|xsuaa_std!b...",
+	sapClientSecret: "SAP AI Core client secret",
+	sapTokenUrl: "https://<subdomain>.authentication.sap.hana.ondemand.com",
+	sapResourceGroup: "default",
+	sapDeploymentId: "",
+};
+
+export function OnboardingProviderConfigScreen(props: {
+	activeProviderName: string;
+	compact: boolean;
+	contentWidth: number;
+	description?: string;
+	fields: Partial<
+		Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>
+	>;
+	focusedField: ProviderConfigFieldKey;
+	mouse: MouseTrackerState;
+	values: Partial<Record<ProviderConfigFieldKey, string>>;
+	onFieldInput: (field: ProviderConfigFieldKey, value: string) => void;
+	onSubmit: () => void;
+}) {
+	const defaultFg = useDefaultFg();
+	const visibleFields = FIELD_ORDER.filter(
+		(key) => props.fields[key] !== undefined,
+	);
+
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<box flexDirection="column" gap={1} alignItems="center">
+				<text fg={defaultFg}>{props.activeProviderName}</text>
+
+				{props.description && <text fg="gray">{props.description}</text>}
+
+				{visibleFields.map((key) => {
+					const requirement = props.fields[key];
+					if (!requirement) return null;
+					const label = requirement.label ?? DEFAULT_FIELD_LABELS[key] ?? key;
+					const placeholder =
+						requirement.placeholder ??
+						(key === "baseUrl" && requirement.defaultValue
+							? requirement.defaultValue
+							: (DEFAULT_FIELD_PLACEHOLDERS[key] ?? ""));
+					const value = props.values[key] ?? "";
+					const isFocused = props.focusedField === key;
+					return (
+						<box
+							key={key}
+							flexDirection="column"
+							gap={0}
+							width={props.contentWidth}
+						>
+							<text fg="gray">{label}</text>
+							{requirement.note && <text fg="gray">{requirement.note}</text>}
+							<box
+								border
+								borderStyle="rounded"
+								borderColor={isFocused ? palette.act : "gray"}
+								paddingX={1}
+							>
+								<input
+									value={value}
+									onInput={(v: string) => props.onFieldInput(key, v)}
+									onSubmit={props.onSubmit}
+									placeholder={placeholder}
+									textColor={defaultFg}
+									focusedTextColor={defaultFg}
+									cursorColor={defaultFg}
+									focused={isFocused}
+									flexGrow={1}
+								/>
+							</box>
+						</box>
+					);
+				})}
+
+				<text fg="gray">
+					<em>
+						{visibleFields.length > 1
+							? "Tab to switch fields, Enter to save, Esc to go back, Ctrl+C to exit"
+							: "Enter to save, Esc to go back, Ctrl+C to exit"}
+					</em>
+				</text>
+			</box>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingCodexCliScreen(props: {
+	activeProviderName: string;
+	checking: boolean;
+	compact: boolean;
+	contentWidth: number;
+	mouse: MouseTrackerState;
+	status?: CodexCliStatus;
+}) {
+	const defaultFg = useDefaultFg();
+	const installedStatus =
+		props.status?.installed === true ? props.status : undefined;
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<box flexDirection="column" gap={1} alignItems="center">
+				<text fg={defaultFg}>{props.activeProviderName}</text>
+
+				{props.checking && (
+					<box flexDirection="row" gap={1}>
+						<spinner name="dots" color="gray" />
+						<text fg="gray">Checking for Codex CLI...</text>
+					</box>
+				)}
+
+				{installedStatus && (
+					<box flexDirection="column" gap={1} alignItems="center">
+						<text fg={palette.success}>{"\u25cf"} Codex CLI installed</text>
+						<text fg="gray">{installedStatus.version}</text>
+					</box>
+				)}
+
+				{props.status && !props.status.installed && (
+					<box flexDirection="column" gap={1} width={props.contentWidth}>
+						<text fg="yellow">Codex CLI was not found</text>
+						<text fg="gray">{props.status.reason}</text>
+						<text fg="gray">Install Codex CLI from:</text>
+						<text fg={palette.act} selectable>
+							{CODEX_CLI_INSTALL_URL}
+						</text>
+					</box>
+				)}
+
+				<text fg="gray">
+					<em>
+						{installedStatus
+							? "Enter to continue, R to recheck, Esc to go back, Ctrl+C to exit"
+							: "R to recheck, Esc to go back, Ctrl+C to exit"}
+					</em>
+				</text>
+			</box>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingProviderPickerScreen(props: {
+	compact: boolean;
+	contentWidth: number;
+	mouse: MouseTrackerState;
+	providerList: SearchableListState;
+	providersLoading: boolean;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<text fg={defaultFg} paddingX={1}>
+				Choose a provider
+			</text>
+
+			{props.providersLoading ? (
+				<box flexDirection="row" gap={1} paddingX={1}>
+					<spinner name="dots" color="gray" />
+					<text fg="gray">Loading providers...</text>
+				</box>
+			) : (
+				<SearchableList
+					items={props.providerList.filtered}
+					selected={props.providerList.safeSelected}
+					onSearchChange={props.providerList.setSearch}
+					placeholder="Search providers..."
+					emptyText="No providers match"
+				/>
+			)}
+
+			<text fg="gray" paddingX={1}>
+				<em>
+					Type to search, ↑/↓ navigate, Enter to select, Esc to go back, Ctrl+C
+					to exit
+				</em>
+			</text>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingClineModelScreen(props: {
+	clineEntries: ClineModelPickerEntry[];
+	clineKnownModels: Record<string, unknown> | undefined;
+	clineModelSelected: number;
+	compact: boolean;
+	contentWidth: number;
+	mouse: MouseTrackerState;
+	recommendedLoading: boolean;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<text fg={defaultFg} paddingX={1}>
+				<strong>Choose a model</strong>
+			</text>
+			<text fg="gray" paddingX={1}>
+				You can change this anytime
+			</text>
+
+			<ClineModelPicker
+				entries={props.clineEntries}
+				selected={props.clineModelSelected}
+				loading={props.recommendedLoading}
+				knownModels={props.clineKnownModels}
+			/>
+
+			<text fg="gray" paddingX={1}>
+				<em>↑/↓ navigate, Enter to select, Esc to go back, Ctrl+C to exit</em>
+			</text>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingClinePassSubscriptionScreen(props: {
+	compact: boolean;
+	contentWidth: number;
+	currentPlanName: string;
+	error: string;
+	mouse: MouseTrackerState;
+	openStatus: string;
+	options: ClinePassSubscriptionOption[];
+	planFeatures: string[];
+	selected: number;
+	status: ClinePassSubscriptionStatus;
+	subscriptionUrl: string;
+}) {
+	const defaultFg = useDefaultFg();
+	const terminalTheme = useTerminalTheme();
+	const planAccent = getModeAccent("plan", terminalTheme);
+	const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+	const isLoading = props.status === "loading";
+	const isSubscribed = props.status === "subscribed";
+	const isError = props.status === "error";
+	const bodyHeight = props.compact ? 17 : 19;
+
+	useEffect(() => {
+		if (isSubscribed) {
+			return;
+		}
+		const scrollSelectedOptionIntoView = () => {
+			scrollRef.current?.scrollChildIntoView(
+				getClinePassSubscriptionOptionId(props.selected),
+			);
+		};
+		scrollSelectedOptionIntoView();
+		queueMicrotask(scrollSelectedOptionIntoView);
+		const timeout = setTimeout(scrollSelectedOptionIntoView, 0);
+		return () => clearTimeout(timeout);
+	}, [isSubscribed, props.selected]);
+
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<box
+				flexDirection="column"
+				border
+				borderStyle="rounded"
+				borderColor={isSubscribed ? palette.success : planAccent}
+				paddingX={1}
+				paddingY={1}
+				height={bodyHeight}
+				overflow="hidden"
+			>
+				<scrollbox
+					ref={scrollRef}
+					width="100%"
+					height="100%"
+					scrollY
+					scrollX={false}
+					viewportOptions={{ overflow: "hidden" }}
+					contentOptions={{ flexDirection: "column" }}
+				>
+					<box flexDirection="column" width="100%" flexShrink={0}>
+						<text
+							fg={isSubscribed ? palette.success : planAccent}
+							flexShrink={0}
+						>
+							{isSubscribed
+								? "ClinePass subscription active"
+								: "ClinePass subscription required"}
+						</text>
+
+						{isLoading ? (
+							<box flexDirection="row" gap={1} flexShrink={0}>
+								<spinner name="dots" color="gray" />
+								<text fg="gray">Checking your ClinePass subscription...</text>
+							</box>
+						) : isSubscribed ? (
+							<text fg={defaultFg} selectable flexShrink={0}>
+								Current plan: {props.currentPlanName || "ClinePass"}
+							</text>
+						) : isError ? (
+							<text
+								fg={defaultFg}
+								selectable
+								flexShrink={0}
+								content="Could not verify your ClinePass subscription. Re-check before choosing a ClinePass model."
+							/>
+						) : (
+							<text
+								fg={defaultFg}
+								selectable
+								flexShrink={0}
+								content="No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan."
+							/>
+						)}
+
+						{props.status === "error" &&
+							props.error &&
+							props.error !== "no plan found for user" && (
+								<text fg="red" selectable flexShrink={0}>
+									{props.error}
+								</text>
+							)}
+
+						{!isSubscribed && props.planFeatures.length > 0 && (
+							<box flexDirection="column" marginTop={1} flexShrink={0}>
+								{props.planFeatures.map((feature) => {
+									if (
+										feature === "Low cost subscription pricing" ||
+										feature === "Generous limits and reliable access" ||
+										feature === "Built for as many programmers as possible"
+									) {
+										return null;
+									}
+
+									return (
+										<text
+											key={feature}
+											fg={defaultFg}
+											selectable
+											flexShrink={0}
+										>
+											<span fg="green">✓ </span>
+											<span>{feature}</span>
+										</text>
+									);
+								})}
+							</box>
+						)}
+
+						{!isSubscribed && (
+							<box flexDirection="column" marginTop={1} flexShrink={0}>
+								{props.options.map((option, i) => {
+									const isSel = i === props.selected;
+									return (
+										<box
+											id={getClinePassSubscriptionOptionId(i)}
+											key={option.value}
+											paddingX={1}
+											flexDirection="row"
+											gap={1}
+											backgroundColor={isSel ? palette.selection : undefined}
+											height={1}
+											flexShrink={0}
+											overflow="hidden"
+										>
+											<text
+												fg={isSel ? palette.textOnSelection : "gray"}
+												flexShrink={0}
+											>
+												{isSel ? "\u276f" : " "}
+											</text>
+											<text
+												fg={isSel ? palette.textOnSelection : defaultFg}
+												flexShrink={0}
+											>
+												{option.label}
+											</text>
+										</box>
+									);
+								})}
+							</box>
+						)}
+
+						{props.openStatus && (
+							<text fg="gray" selectable flexShrink={0}>
+								{props.openStatus}
+							</text>
+						)}
+
+						{!isSubscribed && (
+							<box flexDirection="column" marginTop={1} flexShrink={0}>
+								<text fg="gray" flexShrink={0}>
+									If the browser button does not work:
+								</text>
+								<text fg={palette.act} selectable flexShrink={0}>
+									<a href={props.subscriptionUrl}>{props.subscriptionUrl}</a>
+								</text>
+							</box>
+						)}
+					</box>
+				</scrollbox>
+			</box>
+
+			<text fg="gray" paddingX={1}>
+				<em>↑/↓ navigate, Enter to select, Esc to go back, Ctrl+C to exit</em>
+			</text>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingModelPickerScreen(props: {
+	activeProviderName: string;
+	compact: boolean;
+	contentWidth: number;
+	modelList: SearchableListState;
+	modelsLoading: boolean;
+	mouse: MouseTrackerState;
+	onModelItemSelect: (item: SearchableItem) => void;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<text fg={defaultFg} paddingX={1}>
+				<strong>Choose a model for {props.activeProviderName}</strong>
+			</text>
+			<text fg="gray" paddingX={1}>
+				You can change this anytime
+			</text>
+
+			{props.modelsLoading ? (
+				<box flexDirection="row" gap={1} paddingX={1}>
+					<spinner name="dots" color="gray" />
+					<text fg="gray">Loading models...</text>
+				</box>
+			) : (
+				<SearchableList
+					items={props.modelList.filtered}
+					selected={props.modelList.safeSelected}
+					onSearchChange={props.modelList.setSearch}
+					onItemSelect={props.onModelItemSelect}
+					placeholder="Search models..."
+					emptyText="Create a custom model ID to enter one manually"
+				/>
+			)}
+
+			<text fg="gray" paddingX={1}>
+				<em>
+					Type to search, ↑/↓ navigate, Enter to select, Esc to go back, Ctrl+C
+					to exit
+				</em>
+			</text>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingCustomModelIdScreen(props: {
+	activeProviderName: string;
+	compact: boolean;
+	contentWidth: number;
+	error: string;
+	mouse: MouseTrackerState;
+	onInput: (value: string) => void;
+	onSubmit: () => void;
+	title: string;
+	value: string;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<text fg={defaultFg} paddingX={1}>
+				{props.title}
+			</text>
+			<text fg="gray" paddingX={1}>
+				{props.activeProviderName}
+			</text>
+
+			<box flexDirection="column" gap={0} paddingX={1}>
+				<text fg="gray">Model ID</text>
+				<box
+					border
+					borderStyle="rounded"
+					borderColor={props.error ? "red" : "gray"}
+					paddingX={1}
+				>
+					<input
+						value={props.value}
+						onInput={props.onInput}
+						onSubmit={props.onSubmit}
+						placeholder=""
+						textColor={defaultFg}
+						focusedTextColor={defaultFg}
+						cursorColor={defaultFg}
+						flexGrow={1}
+						focused
+					/>
+				</box>
+				{props.error && <text fg="red">{props.error}</text>}
+			</box>
+
+			<text fg="gray" paddingX={1}>
+				<em>
+					Enter to create, Esc to go back to model selection, Ctrl+C to exit
+				</em>
+			</text>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingThinkingLevelScreen(props: {
+	compact: boolean;
+	contentWidth: number;
+	mouse: MouseTrackerState;
+	selectedModelName: string;
+	thinkingSelected: number;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<OnboardingFrame
+			compact={props.compact}
+			contentWidth={props.contentWidth}
+			mouse={props.mouse}
+		>
+			<text fg={defaultFg} paddingX={1}>
+				Thinking level for {props.selectedModelName}
+			</text>
+			<text fg="gray" paddingX={1}>
+				Extended thinking lets the model reason through complex problems
+			</text>
+
+			<box flexDirection="column">
+				{THINKING_LEVELS.map((level, i) => {
+					const isSel = i === props.thinkingSelected;
+					return (
+						<box
+							key={level.value}
+							paddingX={1}
+							flexDirection="row"
+							gap={1}
+							backgroundColor={isSel ? palette.selection : undefined}
+							height={1}
+						>
+							<text
+								fg={isSel ? palette.textOnSelection : "gray"}
+								flexShrink={0}
+							>
+								{isSel ? "\u276f" : " "}
+							</text>
+							<text fg={isSel ? palette.textOnSelection : defaultFg}>
+								{level.label}
+							</text>
+							<text fg={isSel ? palette.textOnSelection : "gray"}>
+								{level.desc}
+							</text>
+						</box>
+					);
+				})}
+			</box>
+
+			<text fg="gray" paddingX={1}>
+				<em>↑/↓ navigate, Enter to select, Esc to go back, Ctrl+C to exit</em>
+			</text>
+		</OnboardingFrame>
+	);
+}
+
+export function OnboardingMainMenuScreen(props: {
+	contentWidth: number;
+	menuOptions: MenuOption[];
+	menuSelected: number;
+	mouse: MouseTrackerState;
+}) {
+	const defaultFg = useDefaultFg();
+	return (
+		<box
+			flexDirection="column"
+			width="100%"
+			height="100%"
+			justifyContent="center"
+			alignItems="center"
+			onMouseMove={props.mouse.onMouseMove}
+		>
+			<TrackedRobot
+				cursorX={props.mouse.cursor.x}
+				cursorY={props.mouse.cursor.y}
+			/>
+
+			<box
+				flexDirection="column"
+				width={props.contentWidth}
+				alignItems="center"
+				marginTop={1}
+			>
+				<text fg={defaultFg}>
+					<strong>Welcome to Cline</strong>
+				</text>
+				<text fg="gray" marginTop={1}>
+					Connect a model provider to get started.
+				</text>
+			</box>
+
+			<box
+				flexDirection="column"
+				width={props.contentWidth}
+				marginTop={1}
+				gap={0}
+			>
+				{props.menuOptions.map((option, i) => {
+					const isSel = i === props.menuSelected;
+					return (
+						<box
+							key={option.value}
+							flexDirection="row"
+							border
+							borderStyle="rounded"
+							borderColor={isSel ? palette.act : "#333333"}
+							paddingX={1}
+							gap={1}
+							alignItems="center"
+						>
+							<text fg={isSel ? palette.act : "#555555"} flexShrink={0}>
+								{option.icon}
+							</text>
+							<box flexDirection="column" flexGrow={1}>
+								<text fg={isSel ? defaultFg : "gray"}>{option.label}</text>
+								<text fg={isSel ? "gray" : "#555555"}>{option.detail}</text>
+							</box>
+							{isSel && (
+								<text fg={palette.act} flexShrink={0}>
+									{"\u2192"}
+								</text>
+							)}
+						</box>
+					);
+				})}
+			</box>
+
+			<text fg="gray" marginTop={1}>
+				<em>↑/↓ navigate, Enter to select, Ctrl+C to exit</em>
+			</text>
+		</box>
+	);
+}
diff --git a/apps/cli/src/tui/views/onboarding/view.tsx b/apps/cli/src/tui/views/onboarding/view.tsx
new file mode 100644
index 0000000..3784ea5
--- /dev/null
+++ b/apps/cli/src/tui/views/onboarding/view.tsx
@@ -0,0 +1,193 @@
+import type { ProviderSettingsManager } from "@cline/core";
+import { useTerminalDimensions } from "@opentui/react";
+import { useMouseTracker } from "../../components/tracked-robot";
+import { HOME_VIEW_MAX_WIDTH } from "../../types";
+import { useOnboardingController } from "./controller";
+import { getOAuthProviderLabel, type OnboardingResult } from "./model";
+import {
+	OnboardingClineModelScreen,
+	OnboardingClinePassSubscriptionScreen,
+	OnboardingCodexCliScreen,
+	OnboardingCustomModelIdScreen,
+	OnboardingDeviceCodeScreen,
+	OnboardingDoneScreen,
+	OnboardingMainMenuScreen,
+	OnboardingModelPickerScreen,
+	OnboardingOAuthPendingScreen,
+	OnboardingProviderConfigScreen,
+	OnboardingProviderPickerScreen,
+	OnboardingThinkingLevelScreen,
+} from "./screens";
+
+export interface OnboardingViewProps {
+	onComplete: (result: OnboardingResult) => void;
+	onExit: () => void;
+	providerSettingsManager?: ProviderSettingsManager;
+}
+
+export function OnboardingView(props: OnboardingViewProps) {
+	const { width, height } = useTerminalDimensions();
+	const mouse = useMouseTracker();
+	const state = useOnboardingController(props);
+	const contentWidth = Math.min(width - 4, HOME_VIEW_MAX_WIDTH);
+	const compact = height < 28;
+
+	if (state.step === "done") {
+		return <OnboardingDoneScreen mouse={mouse} />;
+	}
+
+	if (state.step === "oauth_pending") {
+		return (
+			<OnboardingOAuthPendingScreen
+				authError={state.authError}
+				authStatus={state.authStatus}
+				authUrl={state.authUrl}
+				compact={compact}
+				contentWidth={contentWidth}
+				label={getOAuthProviderLabel(state.oauthProvider)}
+				mouse={mouse}
+				oauthProvider={state.oauthProvider}
+			/>
+		);
+	}
+
+	if (state.step === "device_code") {
+		return (
+			<OnboardingDeviceCodeScreen
+				compact={compact}
+				contentWidth={contentWidth}
+				deviceError={state.deviceError}
+				deviceStatus={state.deviceStatus}
+				deviceUserCode={state.deviceUserCode}
+				deviceVerifyUrl={state.deviceVerifyUrl}
+				label={getOAuthProviderLabel(state.oauthProvider)}
+				mouse={mouse}
+			/>
+		);
+	}
+
+	if (state.step === "byo_apikey") {
+		return (
+			<OnboardingProviderConfigScreen
+				activeProviderName={state.activeProviderName}
+				compact={compact}
+				contentWidth={contentWidth}
+				description={state.byoDescription}
+				fields={state.byoFields}
+				focusedField={state.byoFocusedField}
+				mouse={mouse}
+				values={state.byoValues}
+				onFieldInput={state.handleByoFieldInput}
+				onSubmit={state.saveByoConfig}
+			/>
+		);
+	}
+
+	if (state.step === "codex_cli_setup") {
+		return (
+			<OnboardingCodexCliScreen
+				activeProviderName={state.activeProviderName}
+				checking={state.codexCliChecking}
+				compact={compact}
+				contentWidth={contentWidth}
+				mouse={mouse}
+				status={state.codexCliStatus}
+			/>
+		);
+	}
+
+	if (state.step === "byo_provider") {
+		return (
+			<OnboardingProviderPickerScreen
+				compact={compact}
+				contentWidth={contentWidth}
+				mouse={mouse}
+				providerList={state.providerList}
+				providersLoading={state.providersLoading}
+			/>
+		);
+	}
+
+	if (state.step === "cline_model") {
+		return (
+			<OnboardingClineModelScreen
+				clineEntries={state.clineEntries}
+				clineKnownModels={state.clineKnownModels}
+				clineModelSelected={state.clineModelSelected}
+				compact={compact}
+				contentWidth={contentWidth}
+				mouse={mouse}
+				recommendedLoading={state.recommendedLoading}
+			/>
+		);
+	}
+
+	if (state.step === "cline_pass_subscription") {
+		return (
+			<OnboardingClinePassSubscriptionScreen
+				compact={compact}
+				contentWidth={contentWidth}
+				currentPlanName={state.clinePassCurrentPlanName}
+				error={state.clinePassSubscriptionError}
+				mouse={mouse}
+				openStatus={state.clinePassSubscriptionOpenStatus}
+				options={state.clinePassSubscriptionOptions}
+				planFeatures={state.clinePassPlanFeatures}
+				selected={state.clinePassSubscriptionSelected}
+				status={state.clinePassSubscriptionStatus}
+				subscriptionUrl={state.clinePassSubscriptionUrl}
+			/>
+		);
+	}
+
+	if (state.step === "model_picker") {
+		return (
+			<OnboardingModelPickerScreen
+				activeProviderName={state.activeProviderName}
+				compact={compact}
+				contentWidth={contentWidth}
+				modelList={state.modelList}
+				modelsLoading={state.modelsLoading}
+				mouse={mouse}
+				onModelItemSelect={state.handleModelItemSelect}
+			/>
+		);
+	}
+
+	if (state.step === "custom_model_id") {
+		return (
+			<OnboardingCustomModelIdScreen
+				activeProviderName={state.activeProviderName}
+				compact={compact}
+				contentWidth={contentWidth}
+				error={state.customModelError}
+				mouse={mouse}
+				onInput={state.handleCustomModelIdInput}
+				onSubmit={state.saveCustomModelId}
+				title={state.customModelTitle}
+				value={state.customModelId}
+			/>
+		);
+	}
+
+	if (state.step === "thinking_level") {
+		return (
+			<OnboardingThinkingLevelScreen
+				compact={compact}
+				contentWidth={contentWidth}
+				mouse={mouse}
+				selectedModelName={state.selectedModelName}
+				thinkingSelected={state.thinkingSelected}
+			/>
+		);
+	}
+
+	return (
+		<OnboardingMainMenuScreen
+			contentWidth={contentWidth}
+			menuOptions={state.menuOptions}
+			menuSelected={state.menuSelected}
+			mouse={mouse}
+		/>
+	);
+}
diff --git a/apps/cli/src/utils/approval.ts b/apps/cli/src/utils/approval.ts
new file mode 100644
index 0000000..31f488c
--- /dev/null
+++ b/apps/cli/src/utils/approval.ts
@@ -0,0 +1,168 @@
+import { createInterface } from "node:readline";
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import { truncate } from "./helpers";
+import { c, getActiveCliSession, write } from "./output";
+
+const SHOW_TERMINAL_CURSOR = "\x1b[?25h";
+
+// =============================================================================
+// Desktop tool approval
+// =============================================================================
+
+let cachedDesktopApprovalRequester:
+	| Promise<
+			(
+				request: ToolApprovalRequest,
+				options?: {
+					approvalDir?: string;
+					sessionId?: string;
+				},
+			) => Promise<ToolApprovalResult>
+	  >
+	| undefined;
+
+async function requestDesktopToolApprovalFromCore(
+	request: ToolApprovalRequest,
+): Promise<ToolApprovalResult> {
+	if (!cachedDesktopApprovalRequester) {
+		cachedDesktopApprovalRequester = import("@cline/core")
+			.then((module) => {
+				const fn = (
+					module as {
+						requestDesktopToolApproval?: (
+							request: ToolApprovalRequest,
+							options?: {
+								approvalDir?: string;
+								sessionId?: string;
+							},
+						) => Promise<ToolApprovalResult>;
+					}
+				).requestDesktopToolApproval;
+				if (typeof fn !== "function") {
+					throw new Error(
+						"Installed @cline/core does not expose requestDesktopToolApproval",
+					);
+				}
+				return fn;
+			})
+			.catch(() => {
+				return async () => ({
+					approved: false,
+					reason: "Desktop tool approval IPC is not available",
+				});
+			});
+	}
+	const requester = await cachedDesktopApprovalRequester;
+	const sessionId = getActiveCliSession()?.manifest.session_id;
+	const approvalDir = process.env.CLINE_TOOL_APPROVAL_DIR?.trim();
+	return requester(request, { approvalDir, sessionId });
+}
+
+// =============================================================================
+// Terminal tool approval
+// =============================================================================
+
+async function requestTerminalToolApproval(
+	request: ToolApprovalRequest,
+): Promise<ToolApprovalResult> {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		return {
+			approved: false,
+			reason: `Tool "${request.toolName}" requires approval in a TTY session`,
+		};
+	}
+	const preview = truncate(JSON.stringify(request.input), 160);
+	const answer = await new Promise<string>((resolve) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout,
+		});
+		rl.question(
+			`\n${c.yellow}Approve ${c.green}"${request.toolName}" ${c.dim}${preview} ${c.reset}[y/N] `,
+			(value) => {
+				rl.close();
+				resolve(value);
+			},
+		);
+	});
+	const normalized = answer.trim().toLowerCase();
+	if (normalized === "y" || normalized === "yes") {
+		return { approved: true };
+	}
+	return {
+		approved: false,
+		reason: `Tool "${request.toolName}" was denied by user`,
+	};
+}
+
+// =============================================================================
+// Unified approval entry point
+// =============================================================================
+
+export async function requestToolApproval(
+	request: ToolApprovalRequest,
+): Promise<ToolApprovalResult> {
+	const mode = process.env.CLINE_TOOL_APPROVAL_MODE?.trim().toLowerCase();
+	if (mode === "desktop") {
+		return requestDesktopToolApprovalFromCore(request);
+	}
+	return requestTerminalToolApproval(request);
+}
+
+// =============================================================================
+// Interactive question
+// =============================================================================
+
+export async function askQuestionInTerminal(
+	question: string,
+	options: string[],
+): Promise<string> {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		return options[0] ?? "";
+	}
+
+	return new Promise<string>((resolve) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout,
+		});
+
+		write(`\n${c.dim}[follow-up]${c.reset} ${question}\n`);
+		for (const [index, option] of options.entries()) {
+			write(`${c.dim}  ${index + 1}.${c.reset} ${option}\n`);
+		}
+		// Terminal renderers can hide the cursor; restore it so readline shows a
+		// normal blinking insertion point for the follow-up.
+		write(SHOW_TERMINAL_CURSOR);
+		write(
+			`${c.dim}Choose 1-${options.length} or type a custom answer:${c.reset}\n${c.green}>${c.reset} `,
+		);
+
+		rl.question("", (value) => {
+			rl.close();
+			const trimmed = value.trim();
+			const numeric = Number.parseInt(trimmed, 10);
+			if (
+				Number.isInteger(numeric) &&
+				numeric >= 1 &&
+				numeric <= options.length
+			) {
+				resolve(options[numeric - 1] ?? "");
+				return;
+			}
+			if (trimmed.length > 0) {
+				resolve(trimmed);
+				return;
+			}
+			resolve(options[0] ?? "");
+		});
+	});
+}
+
+export async function submitAndExitInTerminal(
+	summary: string,
+	verified: boolean,
+): Promise<string> {
+	const status = verified ? "verified" : "unverified";
+	return `Submission recorded (${status}): ${summary}`;
+}
diff --git a/apps/cli/src/utils/aws-region.test.ts b/apps/cli/src/utils/aws-region.test.ts
new file mode 100644
index 0000000..30c4e81
--- /dev/null
+++ b/apps/cli/src/utils/aws-region.test.ts
@@ -0,0 +1,47 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { resolveAwsRegion } from "./aws-region";
+
+const originalEnv = { ...process.env };
+
+afterEach(() => {
+	process.env = { ...originalEnv };
+});
+
+describe("resolveAwsRegion", () => {
+	it("prefers explicit region", () => {
+		process.env.AWS_REGION = "us-east-1";
+		expect(resolveAwsRegion({ explicitRegion: "us-west-2" })).toBe("us-west-2");
+	});
+
+	it("uses AWS_REGION before AWS_DEFAULT_REGION", () => {
+		process.env.AWS_REGION = "eu-west-1";
+		process.env.AWS_DEFAULT_REGION = "us-east-2";
+		expect(resolveAwsRegion()).toBe("eu-west-1");
+	});
+
+	it("reads selected profile region from AWS config", () => {
+		delete process.env.AWS_REGION;
+		delete process.env.AWS_DEFAULT_REGION;
+		const dir = mkdtempSync(join(tmpdir(), "cline-aws-config-"));
+		try {
+			const configPath = join(dir, "config");
+			writeFileSync(
+				configPath,
+				[
+					"[default]",
+					"region = us-east-1",
+					"[profile dev]",
+					"region = ap-southeast-2",
+				].join("\n"),
+			);
+			process.env.AWS_CONFIG_FILE = configPath;
+
+			expect(resolveAwsRegion({ profile: "dev" })).toBe("ap-southeast-2");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/apps/cli/src/utils/aws-region.ts b/apps/cli/src/utils/aws-region.ts
new file mode 100644
index 0000000..befd31f
--- /dev/null
+++ b/apps/cli/src/utils/aws-region.ts
@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+function parseAwsConfigProfiles(
+	content: string,
+): Record<string, Record<string, string>> {
+	const profiles: Record<string, Record<string, string>> = {};
+	let currentProfile: string | undefined;
+
+	for (const rawLine of content.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+
+		const sectionMatch = line.match(/^\[([^\]]+)]$/);
+		if (sectionMatch) {
+			const section = sectionMatch[1]?.trim() ?? "";
+			currentProfile = section.startsWith("profile ")
+				? section.slice("profile ".length).trim()
+				: section;
+			profiles[currentProfile] ??= {};
+			continue;
+		}
+
+		if (!currentProfile) continue;
+		const separatorIndex = line.indexOf("=");
+		if (separatorIndex === -1) continue;
+		const key = line.slice(0, separatorIndex).trim();
+		const value = line.slice(separatorIndex + 1).trim();
+		profiles[currentProfile][key] = value;
+	}
+
+	return profiles;
+}
+
+function readAwsConfigRegion(profile: string): string | undefined {
+	const configPath =
+		process.env.AWS_CONFIG_FILE?.trim() || join(homedir(), ".aws", "config");
+	if (!existsSync(configPath)) return undefined;
+
+	try {
+		const profiles = parseAwsConfigProfiles(readFileSync(configPath, "utf8"));
+		return profiles[profile]?.region?.trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function resolveAwsRegion(
+	input: { explicitRegion?: string; profile?: string } = {},
+): string | undefined {
+	const explicitRegion = input.explicitRegion?.trim();
+	if (explicitRegion) return explicitRegion;
+
+	const envRegion =
+		process.env.AWS_REGION?.trim() || process.env.AWS_DEFAULT_REGION?.trim();
+	if (envRegion) return envRegion;
+
+	const profile =
+		input.profile?.trim() || process.env.AWS_PROFILE?.trim() || "default";
+	return (
+		readAwsConfigRegion(profile) ??
+		(profile !== "default" ? readAwsConfigRegion("default") : undefined)
+	);
+}
diff --git a/apps/cli/src/utils/chat-commands.test.ts b/apps/cli/src/utils/chat-commands.test.ts
new file mode 100644
index 0000000..8011ed6
--- /dev/null
+++ b/apps/cli/src/utils/chat-commands.test.ts
@@ -0,0 +1,362 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	createChatCommandHost,
+	isCommandAddressedToBot,
+	maybeHandleChatCommand,
+	normalizeCommandName,
+} from "./chat-commands";
+
+describe("chat commands", () => {
+	it("shows connector help for /help and /start", async () => {
+		for (const { command, botUserName } of [
+			{ command: "/help" },
+			{ command: "/start" },
+			{ command: "/help@clinebot", botUserName: "clinebot" },
+			{ command: "/start@cline_bot", botUserName: "@cline_bot" },
+		]) {
+			const reply = vi.fn(async () => undefined);
+
+			const handled = await maybeHandleChatCommand(command, {
+				enabled: true,
+				botUserName,
+				getState: async () => ({
+					enableTools: true,
+					autoApproveTools: false,
+					cwd: "/tmp",
+					workspaceRoot: "/tmp",
+				}),
+				setState: async () => undefined,
+				reply,
+			});
+
+			expect(handled).toBe(true);
+			expect(reply).toHaveBeenCalledWith(
+				expect.stringContaining("Cline connector commands:"),
+			);
+			expect(reply).toHaveBeenCalledWith(
+				expect.stringContaining("Current state: tools=on, yolo=off"),
+			);
+			expect(reply).toHaveBeenCalledWith(
+				expect.stringContaining(
+					"/schedule create/list/trigger/delete - manage scheduled workflows",
+				),
+			);
+			expect(reply).toHaveBeenCalledWith(
+				expect.stringContaining(
+					"When tools are on, I can inspect files, edit code, run commands/tests, and help prepare PRs.",
+				),
+			);
+		}
+	});
+
+	it("does not handle bot-suffixed commands addressed to another bot", async () => {
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/help@otherbot", {
+			enabled: true,
+			botUserName: "clinebot",
+			getState: async () => ({
+				enableTools: true,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(false);
+		expect(reply).not.toHaveBeenCalled();
+	});
+
+	it("requires a bot suffix when requested", async () => {
+		const reply = vi.fn(async () => undefined);
+		const context = {
+			enabled: true,
+			botUserName: "clinebot",
+			requireBotMention: true,
+			getState: async () => ({
+				enableTools: true,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+		};
+
+		expect(await maybeHandleChatCommand("/help", context)).toBe(false);
+		expect(reply).not.toHaveBeenCalled();
+
+		expect(await maybeHandleChatCommand("/help@clinebot", context)).toBe(true);
+		expect(reply).toHaveBeenCalledWith(
+			expect.stringContaining("Cline connector commands:"),
+		);
+	});
+
+	it("detects commands addressed to the configured bot", () => {
+		expect(isCommandAddressedToBot("/new@clinebot", "clinebot")).toBe(true);
+		expect(isCommandAddressedToBot("/new@cline_bot", "@cline_bot")).toBe(true);
+		expect(isCommandAddressedToBot("/new@cline.bot", "cline.bot")).toBe(true);
+		expect(isCommandAddressedToBot("/new@cline-bot", "cline-bot")).toBe(true);
+		expect(isCommandAddressedToBot("/new", "clinebot")).toBe(false);
+		expect(isCommandAddressedToBot("/new@otherbot", "clinebot")).toBe(false);
+		expect(isCommandAddressedToBot("/new@clinebot", undefined)).toBe(false);
+	});
+
+	it("normalizes commands addressed to dotted and hyphenated bot names", () => {
+		expect(normalizeCommandName("/new@cline.bot", "cline.bot")).toBe("/new");
+		expect(normalizeCommandName("/new@cline-bot", "cline-bot")).toBe("/new");
+	});
+
+	it("leaves bot-suffixed commands unmatched without a known bot username", async () => {
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/help@clinebot", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: true,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(false);
+		expect(reply).not.toHaveBeenCalled();
+	});
+
+	it("explains when tool controls are locked by startup", async () => {
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/help", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+				toolsLocked: true,
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(true);
+		expect(reply).toHaveBeenCalledWith(
+			expect.stringContaining(
+				"Tool controls are locked because this connector was started with --no-tools.",
+			),
+		);
+	});
+
+	it("treats /new as a reset alias", async () => {
+		const reset = vi.fn(async () => undefined);
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/new", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+			reset,
+		});
+
+		expect(handled).toBe(true);
+		expect(reset).toHaveBeenCalledTimes(1);
+		expect(reply).toHaveBeenCalledWith("Started a fresh session.");
+	});
+
+	it("supports registering reusable commands on a host", async () => {
+		const reply = vi.fn(async () => undefined);
+		const host = createChatCommandHost().register("command", {
+			names: ["/echo"],
+			run: async ({ args }, context) => {
+				await context.reply(args.join(" "));
+			},
+		});
+
+		const handled = await host.handle("/echo hello world", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(true);
+		expect(reply).toHaveBeenCalledWith("hello world");
+	});
+
+	it("shows usage for /team with no arguments", async () => {
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/team", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(true);
+		expect(reply).toHaveBeenCalledWith(
+			"Usage: /team <task description>\nStarts a team of agents for the given task.",
+		);
+	});
+
+	it("replies with unsupported message for /team with arguments in default host", async () => {
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/team build a web app", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(true);
+		expect(reply).toHaveBeenCalledWith(
+			"The /team command must be entered directly as a prompt, not via a chat command.",
+		);
+	});
+
+	it("runs /fork and replies with forked session ids", async () => {
+		const reply = vi.fn(async () => undefined);
+		const fork = vi.fn(async () => ({
+			forkedFromSessionId: "sess_original",
+			newSessionId: "sess_fork",
+		}));
+
+		const handled = await maybeHandleChatCommand("/fork", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+			fork,
+		});
+
+		expect(handled).toBe(true);
+		expect(fork).toHaveBeenCalledTimes(1);
+		expect(reply).toHaveBeenCalledWith(
+			"Forked session sess_original into new session sess_fork. This is now the active session. Use /history to switch sessions.",
+		);
+	});
+
+	it("replies with failure message when fork returns undefined", async () => {
+		const reply = vi.fn(async () => undefined);
+		const fork = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/fork", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+			fork,
+		});
+
+		expect(handled).toBe(true);
+		expect(fork).toHaveBeenCalledTimes(1);
+		expect(reply).toHaveBeenCalledWith(
+			"Fork failed: could not read messages from the current session.",
+		);
+	});
+
+	it("surfaces thrown error message when fork throws", async () => {
+		const reply = vi.fn(async () => undefined);
+		const fork = vi.fn(async () => {
+			throw new Error("Cannot fork an empty session.");
+		});
+
+		const handled = await maybeHandleChatCommand("/fork", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+			fork,
+		});
+
+		expect(handled).toBe(true);
+		expect(fork).toHaveBeenCalledTimes(1);
+		expect(reply).toHaveBeenCalledWith("Cannot fork an empty session.");
+	});
+
+	it("ignores /fork when fork callback is not provided", async () => {
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/fork", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+			// No fork callback, so the command should not be available.
+		});
+
+		// isAvailable returns false when fork is not defined, so the command
+		// is not matched and the handler returns false.
+		expect(handled).toBe(false);
+		expect(reply).not.toHaveBeenCalled();
+	});
+
+	it("runs /abort without disconnecting", async () => {
+		const abort = vi.fn(async () => undefined);
+		const reply = vi.fn(async () => undefined);
+
+		const handled = await maybeHandleChatCommand("/abort", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: "/tmp",
+				workspaceRoot: "/tmp",
+			}),
+			setState: async () => undefined,
+			reply,
+			abort,
+		});
+
+		expect(handled).toBe(true);
+		expect(abort).toHaveBeenCalledTimes(1);
+		expect(reply).not.toHaveBeenCalled();
+	});
+});
diff --git a/apps/cli/src/utils/chat-commands.ts b/apps/cli/src/utils/chat-commands.ts
new file mode 100644
index 0000000..1c466e5
--- /dev/null
+++ b/apps/cli/src/utils/chat-commands.ts
@@ -0,0 +1,537 @@
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { resolveWorkspaceRoot } from "./helpers";
+
+export type ChatCommandState = {
+	enableTools: boolean;
+	autoApproveTools: boolean;
+	cwd: string;
+	workspaceRoot: string;
+	toolsLocked?: boolean;
+	threadMuted?: boolean;
+};
+
+export type ForkSessionResult = {
+	forkedFromSessionId: string;
+	newSessionId: string;
+};
+
+export type MuteCommandInput = {
+	target?: string;
+};
+
+export type ChatCommandContext = {
+	enabled: boolean;
+	botUserName?: string;
+	requireBotMention?: boolean;
+	host?: ChatCommandHost;
+	getState: () => Promise<ChatCommandState> | ChatCommandState;
+	setState: (next: ChatCommandState) => Promise<void> | void;
+	reply: (text: string) => Promise<void> | void;
+	submitPrompt?: (prompt: string) => Promise<void> | void;
+	reset?: () => Promise<void> | void;
+	abort?: () => Promise<void> | void;
+	stop?: () => Promise<void> | void;
+	mute?: (
+		input: MuteCommandInput,
+	) => Promise<string | undefined> | string | undefined;
+	unmute?: (
+		input: MuteCommandInput,
+	) => Promise<string | undefined> | string | undefined;
+	describe?: () => Promise<string> | string;
+	fork?: () =>
+		| Promise<ForkSessionResult | undefined>
+		| ForkSessionResult
+		| undefined;
+	schedule?: {
+		create?: (input: {
+			name: string;
+			cronPattern: string;
+			prompt: string;
+		}) => Promise<string> | string;
+		list?: () => Promise<string> | string;
+		delete?: (scheduleId: string) => Promise<string> | string;
+		trigger?: (scheduleId: string) => Promise<string> | string;
+	};
+};
+
+type ParsedChatCommand = {
+	input: string;
+	trimmed: string;
+	command: string;
+	args: string[];
+	state: ChatCommandState;
+};
+
+export type ChatCommandDefinition = {
+	names: string[];
+	isAvailable?: (context: ChatCommandContext) => boolean;
+	run: (
+		parsed: ParsedChatCommand,
+		context: ChatCommandContext,
+	) => Promise<void> | void;
+};
+
+export class ChatCommandHost {
+	private readonly definitions: ChatCommandDefinition[];
+
+	constructor(definitions: ChatCommandDefinition[] = []) {
+		this.definitions = [...definitions];
+	}
+
+	register(
+		_kind: "command",
+		definition: ChatCommandDefinition,
+	): ChatCommandHost {
+		this.definitions.push(definition);
+		return this;
+	}
+
+	getDefinitions(): readonly ChatCommandDefinition[] {
+		return this.definitions;
+	}
+
+	clone(): ChatCommandHost {
+		return new ChatCommandHost(this.definitions);
+	}
+
+	async handle(input: string, context: ChatCommandContext): Promise<boolean> {
+		if (!context.enabled) {
+			return false;
+		}
+
+		const trimmed = input.trim();
+		if (!trimmed.startsWith("/")) {
+			return false;
+		}
+
+		const [commandRaw, ...args] = trimmed.split(/\s+/);
+		if (
+			context.requireBotMention &&
+			!isCommandAddressedToBot(commandRaw, context.botUserName)
+		) {
+			return false;
+		}
+		const command = normalizeCommandName(
+			commandRaw.toLowerCase(),
+			context.botUserName,
+		);
+		const parsed: ParsedChatCommand = {
+			input,
+			trimmed,
+			command,
+			args,
+			state: await context.getState(),
+		};
+		const matched = this.definitions.find((definition) =>
+			definition.names.includes(parsed.command),
+		);
+		if (!matched) {
+			return false;
+		}
+		if (matched.isAvailable && !matched.isAvailable(context)) {
+			return false;
+		}
+		await matched.run(parsed, context);
+		return true;
+	}
+}
+
+export function normalizeCommandName(
+	command: string,
+	botUserName?: string,
+): string {
+	const botMention = command.match(/^(\/[^@\s]+)@[a-z0-9_.-]+$/i);
+	if (!botMention) {
+		return command;
+	}
+	const expectedBotName = botUserName?.replace(/^@+/, "").trim().toLowerCase();
+	if (!expectedBotName) {
+		return command;
+	}
+	const suffix = command.slice(botMention[1].length + 1).toLowerCase();
+	return suffix === expectedBotName ? botMention[1] : command;
+}
+
+export function isCommandAddressedToBot(
+	command: string,
+	botUserName?: string,
+): boolean {
+	const expectedBotName = botUserName?.replace(/^@+/, "").trim().toLowerCase();
+	if (!expectedBotName) {
+		return false;
+	}
+	const match = command.match(/^\/[^@\s]+@([a-z0-9_.-]+)$/i);
+	return match?.[1]?.toLowerCase() === expectedBotName;
+}
+
+function tokenizeArgs(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: '"' | "'" | undefined;
+	let escaping = false;
+	for (const char of input) {
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) {
+				quote = undefined;
+			} else {
+				current += char;
+			}
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+	if (current) {
+		tokens.push(current);
+	}
+	return tokens;
+}
+
+function parseFlagValues(tokens: string[]): {
+	positionals: string[];
+	flags: Record<string, string>;
+} {
+	const positionals: string[] = [];
+	const flags: Record<string, string> = {};
+	for (let index = 0; index < tokens.length; index += 1) {
+		const token = tokens[index];
+		if (!token.startsWith("--")) {
+			positionals.push(token);
+			continue;
+		}
+		const key = token.slice(2).trim().toLowerCase();
+		const value = tokens[index + 1];
+		if (!key || !value || value.startsWith("--")) {
+			flags[key] = "";
+			continue;
+		}
+		flags[key] = value;
+		index += 1;
+	}
+	return { positionals, flags };
+}
+
+function scheduleUsage(): string {
+	return [
+		"Usage:",
+		'/schedule create "<name>" --cron "<pattern>" --prompt "<text>"',
+		"/schedule list",
+		"/schedule trigger <schedule-id>",
+		"/schedule delete <schedule-id>",
+	].join("\n");
+}
+
+function parseBooleanValue(
+	value: string | undefined,
+	current: boolean,
+): boolean | undefined {
+	const normalized = value?.trim().toLowerCase();
+	if (!normalized) {
+		return undefined;
+	}
+	if (normalized === "on" || normalized === "true" || normalized === "1") {
+		return true;
+	}
+	if (normalized === "off" || normalized === "false" || normalized === "0") {
+		return false;
+	}
+	if (normalized === "toggle") {
+		return !current;
+	}
+	return undefined;
+}
+
+function usage(text: string): string {
+	return `Usage: ${text}`;
+}
+
+function formatHelp(state: ChatCommandState): string {
+	return [
+		"Cline connector commands:",
+		"/help or /start - show this help",
+		"/new or /clear - start a fresh session",
+		"/whereami - show thread, cwd, tools, and yolo state",
+		"/tools [on|off|toggle] - allow repo/file/shell tools",
+		"/yolo [on|off|toggle] - auto-approve tool use",
+		"/cwd <path> - change working directory",
+		"/schedule create/list/trigger/delete - manage scheduled workflows",
+		"/abort - stop the current task",
+		"/mute [target] - ignore this thread or target until /unmute",
+		"/unmute [target] - resume processing this thread or target",
+		"/exit - stop this connector",
+		"",
+		`Current state: tools=${state.enableTools ? "on" : "off"}, yolo=${state.autoApproveTools ? "on" : "off"}, muted=${state.threadMuted ? "true" : "false"}`,
+		state.toolsLocked
+			? "Tool controls are locked because this connector was started with --no-tools."
+			: undefined,
+		"Send normal text to ask a question or assign a task.",
+		"When tools are on, I can inspect files, edit code, run commands/tests, and help prepare PRs.",
+	]
+		.filter((line): line is string => line !== undefined)
+		.join("\n");
+}
+
+export function createChatCommandHost(): ChatCommandHost {
+	return new ChatCommandHost();
+}
+
+function createDefaultChatCommandHost(): ChatCommandHost {
+	return createChatCommandHost()
+		.register("command", {
+			names: ["/help", "/start"],
+			run: async ({ state }, context) => {
+				await context.reply(formatHelp(state));
+			},
+		})
+		.register("command", {
+			names: ["/clear", "/new"],
+			isAvailable: (context) => typeof context.reset === "function",
+			run: async (_parsed, context) => {
+				await context.reset?.();
+				await context.reply("Started a fresh session.");
+			},
+		})
+		.register("command", {
+			names: ["/abort"],
+			isAvailable: (context) => typeof context.abort === "function",
+			run: async (_parsed, context) => {
+				await context.abort?.();
+			},
+		})
+		.register("command", {
+			names: ["/mute"],
+			isAvailable: (context) => typeof context.mute === "function",
+			run: async ({ args }, context) => {
+				const target = args.join(" ").trim() || undefined;
+				const reply = await context.mute?.({ target });
+				await context.reply(
+					reply ?? "Thread muted. I will ignore messages here until /unmute.",
+				);
+			},
+		})
+		.register("command", {
+			names: ["/unmute"],
+			isAvailable: (context) => typeof context.unmute === "function",
+			run: async ({ args }, context) => {
+				const target = args.join(" ").trim() || undefined;
+				const reply = await context.unmute?.({ target });
+				await context.reply(reply ?? "Thread unmuted.");
+			},
+		})
+		.register("command", {
+			names: ["/exit"],
+			isAvailable: (context) => typeof context.stop === "function",
+			run: async (_parsed, context) => {
+				await context.reply("Stopping session.");
+				await context.stop?.();
+			},
+		})
+		.register("command", {
+			names: ["/whereami"],
+			isAvailable: (context) => typeof context.describe === "function",
+			run: async (_parsed, context) => {
+				const description = await context.describe?.();
+				if (description) {
+					await context.reply(description);
+				}
+			},
+		})
+		.register("command", {
+			names: ["/tools"],
+			run: async ({ args, state }, context) => {
+				const resolved = parseBooleanValue(args[0], state.enableTools);
+				if (args[0] && resolved === undefined) {
+					await context.reply(usage("/tools [on|off|toggle]"));
+					return;
+				}
+				if (resolved === undefined) {
+					await context.reply(`tools=${state.enableTools ? "on" : "off"}`);
+					return;
+				}
+				await context.setState({ ...state, enableTools: resolved });
+				await context.reply(`tools=${resolved ? "on" : "off"}`);
+			},
+		})
+		.register("command", {
+			names: ["/yolo"],
+			run: async ({ args, state }, context) => {
+				const resolved = parseBooleanValue(args[0], state.autoApproveTools);
+				if (args[0] && resolved === undefined) {
+					await context.reply(usage("/yolo [on|off|toggle]"));
+					return;
+				}
+				if (resolved === undefined) {
+					await context.reply(`yolo=${state.autoApproveTools ? "on" : "off"}`);
+					return;
+				}
+				await context.setState({ ...state, autoApproveTools: resolved });
+				await context.reply(`yolo=${resolved ? "on" : "off"}`);
+			},
+		})
+		.register("command", {
+			names: ["/cwd"],
+			run: async ({ args, state }, context) => {
+				const rawPath = args.join(" ").trim();
+				if (!rawPath) {
+					await context.reply(
+						`cwd=${state.cwd}\nworkspaceRoot=${state.workspaceRoot}`,
+					);
+					return;
+				}
+				const nextCwd = resolve(state.cwd, rawPath);
+				const fileStat = await stat(nextCwd).catch(() => undefined);
+				if (!fileStat?.isDirectory()) {
+					await context.reply(`invalid directory: ${nextCwd}`);
+					return;
+				}
+				const workspaceRoot = resolveWorkspaceRoot(nextCwd);
+				await context.setState({
+					...state,
+					cwd: nextCwd,
+					workspaceRoot,
+				});
+				await context.reply(`cwd=${nextCwd}\nworkspaceRoot=${workspaceRoot}`);
+			},
+		})
+		.register("command", {
+			names: ["/team"],
+			run: async ({ args }, context) => {
+				const taskBody = args.join(" ").trim();
+				if (!taskBody) {
+					await context.reply(
+						"Usage: /team <task description>\nStarts a team of agents for the given task.",
+					);
+					return;
+				}
+				// In the default host the /team command only shows usage.
+				// The interactive runtime handles input transformation and
+				// session-level enableTeams toggling before this host runs.
+				await context.reply(
+					"The /team command must be entered directly as a prompt, not via a chat command.",
+				);
+			},
+		})
+		.register("command", {
+			names: ["/fork"],
+			isAvailable: (context) => typeof context.fork === "function",
+			run: async (_parsed, context) => {
+				let result: ForkSessionResult | undefined;
+				try {
+					result = await context.fork?.();
+				} catch (error) {
+					await context.reply(
+						error instanceof Error
+							? error.message
+							: "Fork failed: could not read messages from the current session.",
+					);
+					return;
+				}
+				if (!result) {
+					await context.reply(
+						"Fork failed: could not read messages from the current session.",
+					);
+					return;
+				}
+				await context.reply(
+					`Forked session ${result.forkedFromSessionId} into new session ${result.newSessionId}. This is now the active session. Use /history to switch sessions.`,
+				);
+			},
+		})
+		.register("command", {
+			names: ["/schedule"],
+			run: async ({ args }, context) => {
+				if (!context.schedule) {
+					await context.reply("Scheduling is not available in this chat.");
+					return;
+				}
+				const subcommand = args[0]?.trim().toLowerCase();
+				if (!subcommand || subcommand === "help") {
+					await context.reply(scheduleUsage());
+					return;
+				}
+				if (subcommand === "list") {
+					if (!context.schedule.list) {
+						await context.reply("Schedule listing is not available here.");
+						return;
+					}
+					await context.reply(await context.schedule.list());
+					return;
+				}
+				if (subcommand === "trigger") {
+					const scheduleId = args[1]?.trim();
+					if (!scheduleId) {
+						await context.reply(usage("/schedule trigger <schedule-id>"));
+						return;
+					}
+					if (!context.schedule.trigger) {
+						await context.reply("Schedule triggering is not available here.");
+						return;
+					}
+					await context.reply(await context.schedule.trigger(scheduleId));
+					return;
+				}
+				if (subcommand === "delete") {
+					const scheduleId = args[1]?.trim();
+					if (!scheduleId) {
+						await context.reply(usage("/schedule delete <schedule-id>"));
+						return;
+					}
+					if (!context.schedule.delete) {
+						await context.reply("Schedule deletion is not available here.");
+						return;
+					}
+					await context.reply(await context.schedule.delete(scheduleId));
+					return;
+				}
+				if (subcommand === "create") {
+					if (!context.schedule.create) {
+						await context.reply("Schedule creation is not available here.");
+						return;
+					}
+					const parsed = parseFlagValues(tokenizeArgs(args.slice(1).join(" ")));
+					const name =
+						parsed.positionals.join(" ").trim() || parsed.flags.name?.trim();
+					const cronPattern = parsed.flags.cron?.trim();
+					const prompt = parsed.flags.prompt?.trim();
+					if (!name || !cronPattern || !prompt) {
+						await context.reply(scheduleUsage());
+						return;
+					}
+					await context.reply(
+						await context.schedule.create({ name, cronPattern, prompt }),
+					);
+					return;
+				}
+				await context.reply(scheduleUsage());
+			},
+		});
+}
+
+export const chatCommandHost = createDefaultChatCommandHost();
+
+export async function maybeHandleChatCommand(
+	input: string,
+	context: ChatCommandContext,
+): Promise<boolean> {
+	return (context.host ?? chatCommandHost).handle(input, context);
+}
diff --git a/apps/cli/src/utils/cline-pass-errors.test.ts b/apps/cli/src/utils/cline-pass-errors.test.ts
new file mode 100644
index 0000000..b7bb7b9
--- /dev/null
+++ b/apps/cli/src/utils/cline-pass-errors.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import {
+	formatCliErrorMessage,
+	getCliClinePassLimitMessage,
+	getCliNotSubscribedMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassLimitDetailMessage,
+	getCliSubscriptionUrl,
+	isClineOrgIndividualInferenceSubscriptionErrorMessage,
+	isClinePassLimitErrorMessage,
+	isClinePassSubscriptionError,
+} from "./cline-pass-errors";
+
+describe("cline-pass-errors", () => {
+	it("recognizes both raw and formatted ClinePass subscription messages", () => {
+		expect(
+			isClinePassSubscriptionError(
+				"the user is not subscribed to required model plan",
+			),
+		).toBe(true);
+
+		const sdkFormatted =
+			"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://app.cline.bot/dashboard/subscription?personal=true";
+		const formatted = getCliNotSubscribedMessage();
+		expect(isClinePassSubscriptionError(sdkFormatted)).toBe(true);
+		expect(isClinePassSubscriptionError(formatted)).toBe(true);
+		expect(formatCliErrorMessage(new Error(sdkFormatted))).toBe(formatted);
+		expect(formatCliErrorMessage(new Error(formatted))).toBe(formatted);
+	});
+
+	it("formats the ClinePass subscription URL", () => {
+		expect(getCliSubscriptionUrl()).toBe(
+			"https://app.cline.bot/promo?code=CLI-8OFF&personal=true",
+		);
+	});
+
+	it("recognizes and formats organization account individual subscription errors", () => {
+		const raw =
+			"403 Error 403: organization accounts cannot use individual model inference subscriptions";
+		const formatted = getClineOrgIndividualInferenceSubscriptionMessage();
+
+		expect(isClineOrgIndividualInferenceSubscriptionErrorMessage(raw)).toBe(
+			true,
+		);
+		expect(
+			isClineOrgIndividualInferenceSubscriptionErrorMessage(
+				new Error(formatted),
+			),
+		).toBe(true);
+		expect(formatCliErrorMessage(new Error(raw))).toBe(formatted);
+	});
+
+	it("recognizes and formats ClinePass period limit errors with usage-billing guidance", () => {
+		const raw =
+			"Error: You have reached your 5-hour Clinepass limit. The limit resets in 5h, please try again later.";
+		const detail =
+			"You have reached your 5-hour Clinepass limit. The limit resets in 5h, please try again later.";
+
+		expect(isClinePassLimitErrorMessage(raw)).toBe(true);
+		expect(isClinePassLimitErrorMessage(new Error(raw))).toBe(true);
+		expect(getClinePassLimitDetailMessage(raw)).toBe(detail);
+		expect(formatCliErrorMessage(new Error(raw))).toBe(
+			getCliClinePassLimitMessage(raw),
+		);
+		expect(formatCliErrorMessage(new Error(raw))).toContain(
+			"Switch to Cline usage-based billing",
+		);
+		expect(formatCliErrorMessage(new Error(raw))).toContain("--provider cline");
+	});
+});
diff --git a/apps/cli/src/utils/cline-pass-errors.ts b/apps/cli/src/utils/cline-pass-errors.ts
new file mode 100644
index 0000000..c24c2c2
--- /dev/null
+++ b/apps/cli/src/utils/cline-pass-errors.ts
@@ -0,0 +1,133 @@
+import {
+	type ClineSubscriptionPlan,
+	extractClinePassLimitMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	isClineNotSubscribedError,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionError,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitError,
+	isClinePassLimitMessage,
+} from "@cline/core";
+
+import { getClineEnvironmentConfig } from "@cline/shared";
+
+export { getClineOrgIndividualInferenceSubscriptionMessage };
+
+export const CLI_PROMO_CODE = "CLI-8OFF";
+
+export function getCliSubscriptionUrl(): string {
+	return `${new URL(
+		`/promo?code=${CLI_PROMO_CODE}&personal=true`,
+		getClineEnvironmentConfig().appBaseUrl,
+	).toString()}`;
+}
+
+export function getCliNotSubscribedMessage(): string {
+	return `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getCliSubscriptionUrl()}`;
+}
+
+export function getCliClinePassLimitMessage(message: string): string {
+	const detail = getClinePassLimitDetailMessage(message) ?? message.trim();
+	const lines = [
+		"ClinePass limit reached",
+		detail,
+		"Switch to Cline usage-based billing and retry with the Cline provider.",
+		"Interactive CLI: open the model selector with /model, choose Cline, then retry.",
+		"Headless CLI: rerun with --provider cline.",
+	];
+	return lines.filter((line) => line.trim().length > 0).join("\n");
+}
+
+export function getIndividualPlanFeatures(
+	plans: ClineSubscriptionPlan[],
+): string[] {
+	const planWithFeatures = plans.find((plan) => plan.interval === "Monthly");
+
+	return planWithFeatures?.features?.included ?? [];
+}
+
+function isFormattedClinePassSubscriptionMessage(message: string): boolean {
+	const normalized = message.trim().toLowerCase();
+	return (
+		normalized.includes("no access to clinepass subscription models yet") &&
+		normalized.includes("subscribe to clinepass")
+	);
+}
+
+export function isClinePassSubscriptionError(error: unknown): boolean {
+	if (isClineNotSubscribedError(error)) {
+		return true;
+	}
+	if (error instanceof Error) {
+		return (
+			error.name === "ClineNotSubscribedError" ||
+			isClineNotSubscribedMessage(error.message) ||
+			isFormattedClinePassSubscriptionMessage(error.message)
+		);
+	}
+	return (
+		typeof error === "string" &&
+		(isClineNotSubscribedMessage(error) ||
+			isFormattedClinePassSubscriptionMessage(error))
+	);
+}
+
+export function isClineOrgIndividualInferenceSubscriptionErrorMessage(
+	error: unknown,
+): boolean {
+	if (isClineOrgIndividualInferenceSubscriptionError(error)) {
+		return true;
+	}
+	if (error instanceof Error) {
+		return (
+			error.name === "ClineOrgIndividualInferenceSubscriptionError" ||
+			isClineOrgIndividualInferenceSubscriptionMessage(error.message) ||
+			error.message === getClineOrgIndividualInferenceSubscriptionMessage()
+		);
+	}
+	return (
+		typeof error === "string" &&
+		(isClineOrgIndividualInferenceSubscriptionMessage(error) ||
+			error === getClineOrgIndividualInferenceSubscriptionMessage())
+	);
+}
+
+export function getClinePassLimitDetailMessage(
+	error: unknown,
+): string | undefined {
+	return extractClinePassLimitMessage(
+		error instanceof Error ? error.message : String(error),
+	);
+}
+
+export function isClinePassLimitErrorMessage(error: unknown): boolean {
+	if (isClinePassLimitError(error)) {
+		return true;
+	}
+	if (error instanceof Error) {
+		return (
+			error.name === "ClinePassLimitError" ||
+			isClinePassLimitMessage(error.message)
+		);
+	}
+	return typeof error === "string" && isClinePassLimitMessage(error);
+}
+
+export function formatCliErrorMessage(error: unknown): string {
+	if (isClinePassSubscriptionError(error)) {
+		return getCliNotSubscribedMessage();
+	}
+	if (isClineOrgIndividualInferenceSubscriptionErrorMessage(error)) {
+		return getClineOrgIndividualInferenceSubscriptionMessage();
+	}
+	if (isClinePassLimitErrorMessage(error)) {
+		return getCliClinePassLimitMessage(
+			error instanceof Error ? error.message : String(error),
+		);
+	}
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
diff --git a/apps/cli/src/utils/codex-cli.ts b/apps/cli/src/utils/codex-cli.ts
new file mode 100644
index 0000000..ffe51d6
--- /dev/null
+++ b/apps/cli/src/utils/codex-cli.ts
@@ -0,0 +1,55 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export const OPENAI_CODEX_CLI_PROVIDER_ID = "openai-codex-cli";
+export const CODEX_CLI_INSTALL_URL = "https://developers.openai.com/codex/cli";
+
+export type CodexCliStatus =
+	| {
+			installed: true;
+			version: string;
+	  }
+	| {
+			installed: false;
+			reason: string;
+	  };
+
+export function isOpenAICodexCliProvider(providerId: string): boolean {
+	return providerId.trim().toLowerCase() === OPENAI_CODEX_CLI_PROVIDER_ID;
+}
+
+export async function checkCodexCliInstalled(): Promise<CodexCliStatus> {
+	try {
+		const result = await execFileAsync("codex", ["--version"], {
+			timeout: 3000,
+			windowsHide: true,
+		});
+		const version = (result.stdout || result.stderr).trim();
+		return {
+			installed: true,
+			version: version || "codex",
+		};
+	} catch (error) {
+		const details =
+			error && typeof error === "object"
+				? (error as { code?: unknown; message?: unknown })
+				: undefined;
+		const code = typeof details?.code === "string" ? details.code : "";
+		if (code === "ENOENT") {
+			return {
+				installed: false,
+				reason: "The codex executable was not found on PATH.",
+			};
+		}
+		const message =
+			typeof details?.message === "string"
+				? details.message
+				: "Could not run codex --version.";
+		return {
+			installed: false,
+			reason: message,
+		};
+	}
+}
diff --git a/apps/cli/src/utils/common.ts b/apps/cli/src/utils/common.ts
new file mode 100644
index 0000000..233cc21
--- /dev/null
+++ b/apps/cli/src/utils/common.ts
@@ -0,0 +1,14 @@
+import * as os from "node:os";
+import type { RuntimeEnv } from "@cline/shared";
+import { displayName, version } from "../../package.json";
+
+export function getCliBuildInfo(): RuntimeEnv {
+	return {
+		name: displayName,
+		version,
+		platform: "terminal",
+		platform_version: process.version,
+		os_type: os.platform(),
+		os_version: os.version(),
+	};
+}
diff --git a/apps/cli/src/utils/compaction-mode.test.ts b/apps/cli/src/utils/compaction-mode.test.ts
new file mode 100644
index 0000000..d60ec64
--- /dev/null
+++ b/apps/cli/src/utils/compaction-mode.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+	applyCliCompactionMode,
+	buildCliCompactionConfig,
+	DEFAULT_CLI_COMPACTION_MODE,
+	formatCliCompactionMode,
+	getCliCompactionMode,
+	getNextCliCompactionMode,
+	parseCliCompactionMode,
+} from "./compaction-mode";
+import type { Config } from "./types";
+
+function createConfig(compaction?: Config["compaction"]): Config {
+	return { compaction } as Config;
+}
+
+describe("CLI compaction mode helpers", () => {
+	it("defaults enabled compaction to basic truncation", () => {
+		expect(DEFAULT_CLI_COMPACTION_MODE).toBe("basic");
+		expect(getCliCompactionMode(createConfig())).toBe(
+			DEFAULT_CLI_COMPACTION_MODE,
+		);
+		expect(formatCliCompactionMode(DEFAULT_CLI_COMPACTION_MODE)).toBe(
+			"Truncation",
+		);
+	});
+
+	it("maps basic and off modes to core compaction config", () => {
+		const config = createConfig({ enabled: true, maxInputTokens: 123 });
+
+		applyCliCompactionMode(config, "basic");
+		expect(config.compaction).toEqual({
+			enabled: true,
+			strategy: "basic",
+			maxInputTokens: 123,
+		});
+		expect(getCliCompactionMode(config)).toBe("basic");
+
+		applyCliCompactionMode(config, "off");
+		expect(config.compaction).toEqual({
+			enabled: false,
+			maxInputTokens: 123,
+		});
+		expect(getCliCompactionMode(config)).toBe("off");
+	});
+
+	it("builds default and explicit core compaction config", () => {
+		expect(buildCliCompactionConfig()).toEqual({
+			enabled: true,
+			strategy: "basic",
+		});
+		expect(buildCliCompactionConfig("agentic")).toEqual({
+			enabled: true,
+			strategy: "agentic",
+		});
+		expect(buildCliCompactionConfig("off")).toEqual({ enabled: false });
+	});
+
+	it("parses one CLI spelling per compaction mode", () => {
+		expect(parseCliCompactionMode("agentic")).toBe("agentic");
+		expect(parseCliCompactionMode("basic")).toBe("basic");
+		expect(parseCliCompactionMode("off")).toBe("off");
+		expect(parseCliCompactionMode("llm")).toBeUndefined();
+		expect(parseCliCompactionMode("truncation")).toBeUndefined();
+		expect(parseCliCompactionMode("truncate")).toBeUndefined();
+		expect(parseCliCompactionMode("none")).toBeUndefined();
+		expect(parseCliCompactionMode("disabled")).toBeUndefined();
+	});
+
+	it("does not mutate compaction when applying an undefined mode", () => {
+		const config = createConfig({ enabled: true, strategy: "agentic" });
+
+		applyCliCompactionMode(config, undefined);
+
+		expect(config.compaction).toEqual({
+			enabled: true,
+			strategy: "agentic",
+		});
+	});
+
+	it("cycles TUI choices in a stable order", () => {
+		expect(getNextCliCompactionMode("basic")).toBe("agentic");
+		expect(getNextCliCompactionMode("agentic")).toBe("off");
+		expect(getNextCliCompactionMode("off")).toBe("basic");
+	});
+});
diff --git a/apps/cli/src/utils/compaction-mode.ts b/apps/cli/src/utils/compaction-mode.ts
new file mode 100644
index 0000000..dca8fe0
--- /dev/null
+++ b/apps/cli/src/utils/compaction-mode.ts
@@ -0,0 +1,84 @@
+import type { CliCompactionMode, Config } from "./types";
+
+export const CLI_COMPACTION_MODES = ["basic", "agentic", "off"] as const;
+
+export const DEFAULT_CLI_COMPACTION_MODE: Extract<
+	CliCompactionMode,
+	"agentic" | "basic"
+> = "basic";
+
+const CLI_COMPACTION_MODE_ALIASES: Record<string, CliCompactionMode> = {
+	agentic: "agentic",
+	basic: "basic",
+	off: "off",
+};
+
+const CLI_COMPACTION_MODE_LABELS = {
+	agentic: "LLM",
+	basic: "Truncation",
+	off: "Off",
+} as const satisfies Record<CliCompactionMode, string>;
+
+export const CLI_COMPACTION_MODE_OPTION_DESCRIPTION =
+	"Context compaction mode: agentic|basic|off (default: basic)";
+
+export const CLI_COMPACTION_MODE_EXPECTED_TEXT = '"agentic", "basic", or "off"';
+
+export function parseCliCompactionMode(
+	value: string,
+): CliCompactionMode | undefined {
+	return CLI_COMPACTION_MODE_ALIASES[value.trim().toLowerCase()];
+}
+
+export function buildCliCompactionConfig(
+	mode: CliCompactionMode | undefined = DEFAULT_CLI_COMPACTION_MODE,
+): NonNullable<Config["compaction"]> {
+	if (mode === "off") {
+		return { enabled: false };
+	}
+	return { enabled: true, strategy: mode };
+}
+
+export function getCliCompactionMode(config: Config): CliCompactionMode {
+	if (config.compaction?.enabled === false) {
+		return "off";
+	}
+	return config.compaction?.strategy === "agentic"
+		? "agentic"
+		: DEFAULT_CLI_COMPACTION_MODE;
+}
+
+export function applyCliCompactionMode(
+	config: Config,
+	mode: CliCompactionMode | undefined,
+): void {
+	if (mode === undefined) {
+		return;
+	}
+	if (mode === "off") {
+		const { strategy: _strategy, ...rest } = config.compaction ?? {};
+		config.compaction = {
+			...rest,
+			enabled: false,
+		};
+		return;
+	}
+
+	config.compaction = {
+		...config.compaction,
+		enabled: true,
+		strategy: mode,
+	};
+}
+
+export function getNextCliCompactionMode(
+	mode: CliCompactionMode,
+): CliCompactionMode {
+	const currentIndex = CLI_COMPACTION_MODES.indexOf(mode);
+	const safeIndex = currentIndex >= 0 ? currentIndex : 0;
+	return CLI_COMPACTION_MODES[(safeIndex + 1) % CLI_COMPACTION_MODES.length];
+}
+
+export function formatCliCompactionMode(mode: CliCompactionMode): string {
+	return CLI_COMPACTION_MODE_LABELS[mode];
+}
diff --git a/apps/cli/src/utils/enterprise.ts b/apps/cli/src/utils/enterprise.ts
new file mode 100644
index 0000000..6da82a6
--- /dev/null
+++ b/apps/cli/src/utils/enterprise.ts
@@ -0,0 +1,181 @@
+import {
+	buildRemoteConfigSessionBlobUploadMetadata,
+	ClineAccountService,
+	type ClineCoreStartInput,
+	createRemoteConfigSessionMessagesArtifactUploader,
+	ProviderSettingsManager,
+	prepareRemoteConfigCoreIntegration,
+	REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY,
+	readRemoteConfigSessionBlobUploadMetadata,
+	registerRemoteConfigSessionBlobUpload,
+	resolveLocalClineAuthToken,
+	type SessionMessagesArtifactUploader,
+} from "@cline/core";
+import {
+	getClineEnvironmentConfig,
+	type RemoteConfigBundle,
+	RemoteConfigSchema,
+} from "@cline/shared";
+import { getCliTelemetryService } from "./telemetry";
+
+const initializedRemoteConfigKeys = new Set<string>();
+let cliRemoteConfigBundlePromise:
+	| Promise<RemoteConfigBundle | undefined>
+	| undefined;
+
+async function loadCliRemoteConfigBundle(): Promise<
+	RemoteConfigBundle | undefined
+> {
+	cliRemoteConfigBundlePromise ??= loadCliRemoteConfigBundleUncached().finally(
+		() => {
+			cliRemoteConfigBundlePromise = undefined;
+		},
+	);
+	return await cliRemoteConfigBundlePromise;
+}
+
+async function loadCliRemoteConfigBundleUncached(): Promise<
+	RemoteConfigBundle | undefined
+> {
+	const manager = new ProviderSettingsManager();
+	const settings = manager.getProviderSettings("cline");
+	const authToken = resolveLocalClineAuthToken(settings)?.trim();
+	if (!authToken) {
+		return undefined;
+	}
+
+	const service = new ClineAccountService({
+		apiBaseUrl:
+			settings?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl,
+		getAuthToken: async () => authToken,
+	});
+	const response = await service.fetchRemoteConfig().catch(() => null);
+	if (!response?.enabled || !response.value?.trim()) {
+		return undefined;
+	}
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(response.value);
+	} catch {
+		return undefined;
+	}
+	const remoteConfigResult = RemoteConfigSchema.safeParse(parsed);
+	if (!remoteConfigResult.success) {
+		return undefined;
+	}
+
+	return {
+		source: "cline-account",
+		version: response.organizationId?.trim() || "remote-config",
+		remoteConfig: remoteConfigResult.data,
+	};
+}
+
+export function createCliMessagesArtifactUploader() {
+	const uploader = createRemoteConfigSessionMessagesArtifactUploader();
+	const telemetry = getCliTelemetryService();
+	return {
+		async uploadMessagesFile(input) {
+			const metadata = readRemoteConfigSessionBlobUploadMetadata(input.row);
+			const startedAt = Date.now();
+			try {
+				await uploader.uploadMessagesFile(input);
+				if (!metadata) {
+					return;
+				}
+				telemetry?.capture?.({
+					event: "enterprise.prompt_upload_succeeded",
+					properties: {
+						sessionId: input.sessionId,
+						adapterType: metadata.storage.adapterType,
+						bucket: metadata.storage.bucket,
+						keyPrefix: metadata.keyPrefix,
+						bytes: input.contents.length,
+						durationMs: Date.now() - startedAt,
+					},
+				});
+			} catch (error) {
+				telemetry?.capture?.({
+					event: "enterprise.prompt_upload_failed",
+					properties: {
+						sessionId: input.sessionId,
+						adapterType: metadata?.storage.adapterType,
+						bucket: metadata?.storage.bucket,
+						keyPrefix: metadata?.keyPrefix,
+						bytes: input.contents.length,
+						durationMs: Date.now() - startedAt,
+						error: error instanceof Error ? error.message : String(error),
+					},
+				});
+				throw error;
+			}
+		},
+	} satisfies SessionMessagesArtifactUploader;
+}
+
+function captureRemoteConfigInitialized(bundle: RemoteConfigBundle): void {
+	const telemetry = getCliTelemetryService();
+	const key = `${bundle.source}:${bundle.version}`;
+	if (initializedRemoteConfigKeys.has(key)) {
+		return;
+	}
+	initializedRemoteConfigKeys.add(key);
+	const promptUploading =
+		bundle.remoteConfig?.enterpriseTelemetry?.promptUploading;
+	telemetry?.capture?.({
+		event: "enterprise.remote_config_initialized",
+		properties: {
+			source: bundle.source,
+			version: bundle.version,
+			hasPromptUploading: Boolean(promptUploading),
+			promptUploadingType: promptUploading?.type,
+			promptUploadingEnabled: promptUploading?.enabled !== false,
+			hasGlobalRules: (bundle.remoteConfig?.globalRules?.length ?? 0) > 0,
+			hasGlobalWorkflows:
+				(bundle.remoteConfig?.globalWorkflows?.length ?? 0) > 0,
+		},
+	});
+}
+
+export async function prepareCliEnterpriseIntegration(
+	input: ClineCoreStartInput,
+) {
+	const bundle = await loadCliRemoteConfigBundle();
+	if (!bundle) {
+		return undefined;
+	}
+	captureRemoteConfigInitialized(bundle);
+	return prepareRemoteConfigCoreIntegration({
+		workspacePath: input.config.workspaceRoot ?? input.config.cwd,
+		pluginName: "enterprise",
+		controlPlane: {
+			name: "cline-account",
+			async fetchBundle() {
+				return bundle;
+			},
+		},
+		requireBundle: false,
+	});
+}
+
+export async function resolveCliSessionMetadata(
+	sessionId?: string,
+): Promise<Record<string, unknown> | undefined> {
+	const bundle = await loadCliRemoteConfigBundle();
+	if (bundle) {
+		captureRemoteConfigInitialized(bundle);
+	}
+	if (sessionId) {
+		registerRemoteConfigSessionBlobUpload(sessionId, bundle?.remoteConfig);
+	}
+	const blobUploadMetadata = buildRemoteConfigSessionBlobUploadMetadata(
+		bundle?.remoteConfig,
+	);
+	if (!blobUploadMetadata) {
+		return undefined;
+	}
+	return {
+		[REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY]: blobUploadMetadata,
+	};
+}
diff --git a/apps/cli/src/utils/events.test.ts b/apps/cli/src/utils/events.test.ts
new file mode 100644
index 0000000..ccb7bf4
--- /dev/null
+++ b/apps/cli/src/utils/events.test.ts
@@ -0,0 +1,280 @@
+import type { AgentEvent, TeamEvent } from "@cline/core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	handleEvent,
+	handleTeamEvent,
+	resolveStatusNoticeLabel,
+} from "./events";
+import { setCurrentOutputMode } from "./output";
+import type { Config } from "./types";
+
+describe("resolveStatusNoticeLabel", () => {
+	it("maps compaction status reasons to stable labels", () => {
+		expect(
+			resolveStatusNoticeLabel({
+				type: "notice",
+				noticeType: "status",
+				displayRole: "status",
+				message: "auto-compacting",
+				reason: "auto_compaction",
+			} as AgentEvent),
+		).toBe("auto-compacting");
+		expect(
+			resolveStatusNoticeLabel({
+				type: "notice",
+				noticeType: "status",
+				displayRole: "status",
+				message: "manual",
+				reason: "manual_compaction",
+			} as AgentEvent),
+		).toBe("compacting");
+		expect(
+			resolveStatusNoticeLabel({
+				type: "notice",
+				noticeType: "status",
+				displayRole: "status",
+				message: "compaction-budget-adjusted",
+				reason: "compaction_budget_emergency",
+			} as AgentEvent),
+		).toBe("context budget adjusted");
+	});
+});
+
+describe("handleEvent text formatting", () => {
+	let output = "";
+	let errorOutput = "";
+
+	beforeEach(() => {
+		output = "";
+		errorOutput = "";
+		setCurrentOutputMode("text");
+		vi.spyOn(process.stdout, "write").mockImplementation((chunk: unknown) => {
+			output += String(chunk);
+			return true;
+		});
+		vi.spyOn(process.stderr, "write").mockImplementation((chunk: unknown) => {
+			errorOutput += String(chunk);
+			return true;
+		});
+		vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => {
+			errorOutput += `${args.map(String).join(" ")}\n`;
+		});
+	});
+
+	it("adds a ⎿ before text that follows a tool block", () => {
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: "read_files",
+				input: { path: "/tmp/demo.txt" },
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+		handleEvent(
+			{
+				type: "content_end",
+				contentType: "tool",
+				toolName: "read_files",
+				output: "ok",
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "text",
+				text: "Now let me check this file.",
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+
+		expect(output).toContain(
+			`\x1b[36m[read_files]\x1b[0m {"path":"/tmp/demo.txt"}`,
+		);
+		expect(output).toMatch(/⎿.*ok/s);
+	});
+
+	it("prints adjacent tool starts on separate lines", () => {
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: "run_commands",
+				input: { commands: ["echo one"] },
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: "read_files",
+				input: { file_paths: ["/tmp/demo.txt"] },
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+
+		expect(output).toMatch(/\[run_commands\].*\n.*\[read_files\]/s);
+	});
+
+	it("does not echo ask_question through the generic tool renderer", () => {
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: "ask_question",
+				input: {
+					question: "How can I best assist you today?",
+					options: [
+						"Help me understand or analyze code in a repository",
+						"Help me create or edit files",
+					],
+				},
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+		handleEvent(
+			{
+				type: "content_end",
+				contentType: "tool",
+				toolName: "ask_question",
+				output: "Help me create or edit files",
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+
+		expect(output).toBe("");
+	});
+
+	it("prints tool errors inline", () => {
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: "team_task",
+				input: { action: "create", title: "Draft haiku" },
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+		handleEvent(
+			{
+				type: "content_end",
+				contentType: "tool",
+				toolName: "team_task",
+				error:
+					'✖ Field "status" is not allowed when action=create\n  → at status',
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+
+		expect(output).toContain(`\x1b[36m[team_task]\x1b[0m create`);
+		expect(output).toContain("error:");
+		expect(output).toContain(
+			'Field "status" is not allowed when action=create',
+		);
+		expect(output).toContain("→ at status");
+	});
+
+	it("prints completed done events as finished in verbose mode", () => {
+		handleEvent(
+			{
+				type: "done",
+				reason: "completed",
+				iterations: 5,
+				text: "ok",
+			} as unknown as AgentEvent,
+			{ verbose: true } as Config,
+		);
+
+		expect(output).toContain("── finished (5 iterations) ──");
+		expect(output).not.toContain("── aborted (5 iterations) ──");
+	});
+
+	it("prints aborted done events as aborted in verbose mode", () => {
+		handleEvent(
+			{
+				type: "done",
+				reason: "aborted",
+				iterations: 2,
+				text: "aborted",
+			} as unknown as AgentEvent,
+			{ verbose: true } as Config,
+		);
+
+		expect(output).toContain("── aborted (2 iterations) ──");
+	});
+
+	it("formats ClinePass limit agent errors before writing to stderr", () => {
+		handleEvent(
+			{
+				type: "error",
+				error: new Error(
+					"Error: You have reached your 5-hour Clinepass limit. The limit resets in 5h, please try again later.",
+				),
+				recoverable: false,
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+
+		expect(errorOutput).toContain("ClinePass limit reached");
+		expect(errorOutput).toContain("Switch to Cline usage-based billing");
+		expect(errorOutput).toContain("--provider cline");
+	});
+
+	it("suppresses heartbeat-only team progress messages", () => {
+		handleTeamEvent({
+			type: "run_progress",
+			run: {
+				id: "run_00001",
+				agentId: "worker-1",
+			},
+			message: "heartbeat",
+		} as unknown as TeamEvent);
+
+		expect(output).toBe("");
+	});
+
+	it("marks queued and started team runs as active", () => {
+		handleTeamEvent({
+			type: "run_queued",
+			run: {
+				id: "run_00001",
+				agentId: "worker-1",
+			},
+		} as unknown as TeamEvent);
+		handleTeamEvent({
+			type: "run_started",
+			run: {
+				id: "run_00001",
+				agentId: "worker-1",
+			},
+		} as unknown as TeamEvent);
+
+		expect(output).toContain("queued");
+		expect(output).toContain("started");
+		expect(output).toContain("...");
+		// Consecutive team events should not have blank lines between them
+		expect(output).not.toMatch(/\n\n/);
+	});
+
+	it("closes inline reasoning before team events and terminates the line", () => {
+		handleEvent(
+			{
+				type: "content_start",
+				contentType: "reasoning",
+				reasoning: "Investigating",
+			} as unknown as AgentEvent,
+			{} as Config,
+		);
+		handleTeamEvent({
+			type: "run_started",
+			run: {
+				id: "run_00001",
+				agentId: "worker-1",
+			},
+		} as unknown as TeamEvent);
+
+		expect(output).toMatch(/Investigating.*\n.*\[team run\].*started.*\n$/s);
+	});
+});
diff --git a/apps/cli/src/utils/events.ts b/apps/cli/src/utils/events.ts
new file mode 100644
index 0000000..ba86e37
--- /dev/null
+++ b/apps/cli/src/utils/events.ts
@@ -0,0 +1,308 @@
+import type { AgentEvent, TeamEvent } from "@cline/core";
+import { formatCliErrorMessage } from "./cline-pass-errors";
+import { formatToolInput, formatToolOutput, truncate } from "./helpers";
+import {
+	c,
+	emitJsonLine,
+	getCurrentOutputMode,
+	write,
+	writeErr,
+} from "./output";
+import type { Config } from "./types";
+
+// =============================================================================
+// Inline stream state
+// =============================================================================
+
+let activeInlineStream: "text" | "reasoning" | undefined;
+let inlineStreamHasOutput = false;
+let shouldPrefixNextTextWithBlankLine = false;
+
+// Prefix for result rows
+const HOOK = "⎿ ";
+const TEAM_RUN_ACTIVE_SUFFIX = `${c.dim} ...${c.reset}`;
+
+export function resolveStatusNoticeLabel(
+	event: AgentEvent,
+): string | undefined {
+	if (event.type !== "notice" || event.displayRole !== "status") {
+		return undefined;
+	}
+	switch (event.reason) {
+		case "auto_compaction":
+			return "auto-compacting";
+		case "manual_compaction":
+			return "compacting";
+		case "compaction_budget_emergency":
+			return "context budget adjusted";
+	}
+	return event.message.trim() || undefined;
+}
+
+export function closeInlineStreamIfNeeded(): void {
+	if (!inlineStreamHasOutput) {
+		return;
+	}
+	write("\n");
+	activeInlineStream = undefined;
+	inlineStreamHasOutput = false;
+}
+
+// Used by team events that arrive while the lead agent is mid-stream. Ends the
+// current visual line so the team event prints cleanly, but keeps
+// activeInlineStream set so the next text chunk continues on a new line without
+// re-emitting any prefix.
+function breakLineIfStreaming(): void {
+	if (activeInlineStream === "text" && inlineStreamHasOutput) {
+		write("\n");
+		inlineStreamHasOutput = false;
+	}
+}
+
+// =============================================================================
+// Agent event handler
+// =============================================================================
+
+function formatResultLines(text: string, maxLines = 5): string[] {
+	const lines = text.split("\n");
+	if (lines.length <= maxLines) return lines;
+	return [
+		...lines.slice(0, maxLines),
+		`... ${lines.length - maxLines} more lines`,
+	];
+}
+
+export function handleEvent(event: AgentEvent, config: Config): void {
+	if (getCurrentOutputMode() === "json") {
+		emitJsonLine("stdout", { type: "agent_event", event });
+		return;
+	}
+
+	switch (event.type) {
+		case "iteration_start":
+			closeInlineStreamIfNeeded();
+			break;
+
+		case "iteration_end":
+			closeInlineStreamIfNeeded();
+			break;
+
+		case "content_start":
+			switch (event.contentType) {
+				case "text":
+					if (activeInlineStream !== "text") {
+						closeInlineStreamIfNeeded();
+						if (shouldPrefixNextTextWithBlankLine) {
+							write("\n");
+							shouldPrefixNextTextWithBlankLine = false;
+						}
+						activeInlineStream = "text";
+					}
+					write(event.text ?? "");
+					inlineStreamHasOutput = true;
+					break;
+				case "reasoning":
+					if (activeInlineStream !== "reasoning") {
+						closeInlineStreamIfNeeded();
+						write(`${c.dim}[thinking] ${c.reset}`);
+						activeInlineStream = "reasoning";
+						inlineStreamHasOutput = true;
+					}
+					if (event.redacted && !event.reasoning) {
+						write(`${c.dim}[redacted]${c.reset}`);
+						inlineStreamHasOutput = true;
+						break;
+					}
+					write(`${c.dim}${event.reasoning ?? ""}${c.reset}`);
+					inlineStreamHasOutput = true;
+					break;
+				case "tool": {
+					closeInlineStreamIfNeeded();
+					const toolName = event.toolName ?? "unknown_tool";
+					const inputStr = formatToolInput(toolName, event.input);
+					if (toolName === "ask_question") {
+						break;
+					}
+					write(
+						`${c.cyan}[${toolName}]${c.reset}${inputStr ? ` ${inputStr}` : ""}\n`,
+					);
+					break;
+				}
+			}
+			break;
+
+		case "content_end":
+			switch (event.contentType) {
+				case "text":
+				case "reasoning":
+					closeInlineStreamIfNeeded();
+					break;
+				case "tool":
+					closeInlineStreamIfNeeded();
+					if (event.toolName === "ask_question") {
+						break;
+					}
+					if (event.error) {
+						write(
+							`   ${c.gray}${HOOK}${c.reset}${c.red}error: ${event.error}${c.reset}\n`,
+						);
+					} else {
+						const outputStr = formatToolOutput(event.output);
+						if (outputStr) {
+							const lines = formatResultLines(outputStr);
+							for (let i = 0; i < lines.length; i++) {
+								const prefix = i === 0 ? HOOK : "  ";
+								write(
+									`   ${c.gray}${prefix}${c.reset}${c.dim}${lines[i]}${c.reset}\n`,
+								);
+							}
+						} else {
+							write(`   ${c.gray}${HOOK}${c.reset}${c.green}ok${c.reset}\n`);
+						}
+					}
+					shouldPrefixNextTextWithBlankLine = false;
+					break;
+			}
+			break;
+
+		case "done": {
+			closeInlineStreamIfNeeded();
+			if (config.verbose) {
+				const iterations = event.iterations;
+				const label = event.reason === "aborted" ? "aborted" : "finished";
+				write(
+					`\n${c.dim}── ${label} (${iterations} iterations) ──${c.reset}\n`,
+				);
+			}
+			activeInlineStream = undefined;
+			inlineStreamHasOutput = false;
+			shouldPrefixNextTextWithBlankLine = false;
+			break;
+		}
+		case "error":
+			closeInlineStreamIfNeeded();
+			if (!event.recoverable || config.verbose) {
+				writeErr(formatCliErrorMessage(event.error));
+			}
+			break;
+		case "notice":
+			if (event.displayRole === "status") {
+				closeInlineStreamIfNeeded();
+				const label = resolveStatusNoticeLabel(event);
+				if (label) {
+					write(`\n${c.dim}[status]${c.reset} ${label}\n`);
+				}
+			}
+			break;
+	}
+}
+
+// =============================================================================
+// Team event handler
+// =============================================================================
+
+export function handleTeamEvent(event: TeamEvent): void {
+	if (getCurrentOutputMode() === "json") {
+		emitJsonLine("stdout", { type: "team_event", event });
+		return;
+	}
+	// Skip heartbeat events to avoid cluttering the CLI with too many messages,
+	// since they can be emitted frequently during long-running tasks.
+	if (event.type === "run_progress" && event.message === "heartbeat") {
+		return;
+	}
+
+	breakLineIfStreaming();
+	if (activeInlineStream !== "text") {
+		closeInlineStreamIfNeeded();
+	}
+
+	switch (event.type) {
+		case "teammate_spawned":
+			write(
+				`${c.dim}[team] teammate spawned:${c.reset} ${c.cyan}${event.agentId}${c.reset}\n`,
+			);
+			break;
+		case "teammate_shutdown":
+			write(
+				`${c.dim}[team] teammate shutdown:${c.reset} ${c.cyan}${event.agentId}${c.reset}\n`,
+			);
+			break;
+		case "team_task_updated":
+			write(
+				`${c.dim}[team task]${c.reset} ${c.cyan}${event.task.id}${c.reset} -> ${event.task.status}\n`,
+			);
+			break;
+		case "team_message":
+			write(
+				`${c.dim}[mailbox]${c.reset} ${event.message.fromAgentId} -> ${event.message.toAgentId}: ${event.message.subject}\n`,
+			);
+			break;
+		case "team_mission_log":
+			write(
+				`${c.dim}[mission]${c.reset} ${event.entry.agentId}: ${truncate(event.entry.summary, 90)}\n`,
+			);
+			break;
+		case "run_queued":
+			write(
+				`${c.dim}[team run]${c.reset} queued ${c.cyan}${event.run.id}${c.reset} -> ${event.run.agentId}${TEAM_RUN_ACTIVE_SUFFIX}\n`,
+			);
+			break;
+		case "run_started":
+			write(
+				`${c.dim}[team run]${c.reset} started ${c.cyan}${event.run.id}${c.reset} -> ${event.run.agentId}${TEAM_RUN_ACTIVE_SUFFIX}\n`,
+			);
+			break;
+		case "run_progress":
+			write(
+				`${c.dim}[team run]${c.reset} progress ${c.cyan}${event.run.id}${c.reset}: ${event.message}\n`,
+			);
+			break;
+		case "run_completed":
+			write(
+				`${c.dim}[team run]${c.reset} completed ${c.cyan}${event.run.id}${c.reset}\n`,
+			);
+			break;
+		case "run_failed":
+			write(
+				`${c.dim}[team run]${c.reset} failed ${c.cyan}${event.run.id}${c.reset}: ${event.run.error ?? "unknown error"}\n`,
+			);
+			break;
+		case "run_cancelled":
+			write(
+				`${c.dim}[team run]${c.reset} cancelled ${c.cyan}${event.run.id}${c.reset}\n`,
+			);
+			break;
+		case "run_interrupted":
+			write(
+				`${c.dim}[team run]${c.reset} interrupted ${c.cyan}${event.run.id}${c.reset}\n`,
+			);
+			break;
+		case "outcome_created":
+			write(
+				`${c.dim}[team outcome]${c.reset} created ${c.cyan}${event.outcome.id}${c.reset}: ${event.outcome.title}\n`,
+			);
+			break;
+		case "outcome_fragment_attached":
+			write(
+				`${c.dim}[team outcome]${c.reset} fragment ${c.cyan}${event.fragment.id}${c.reset} attached to ${event.fragment.section}\n`,
+			);
+			break;
+		case "outcome_fragment_reviewed":
+			write(
+				`${c.dim}[team outcome]${c.reset} fragment ${c.cyan}${event.fragment.id}${c.reset} -> ${event.fragment.status}\n`,
+			);
+			break;
+		case "outcome_finalized":
+			write(
+				`${c.dim}[team outcome]${c.reset} finalized ${c.cyan}${event.outcome.id}${c.reset}\n`,
+			);
+			break;
+		case "task_start":
+			break;
+		case "task_end":
+			break;
+		case "agent_event":
+			break;
+	}
+}
diff --git a/apps/cli/src/utils/feature-flags.test.ts b/apps/cli/src/utils/feature-flags.test.ts
new file mode 100644
index 0000000..986eb96
--- /dev/null
+++ b/apps/cli/src/utils/feature-flags.test.ts
@@ -0,0 +1,19 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	disposeCliFeatureFlagsService,
+	getCliFeatureFlagsService,
+} from "./feature-flags";
+
+describe("CLI feature flags singleton", () => {
+	afterEach(async () => {
+		await disposeCliFeatureFlagsService();
+	});
+
+	it("recreates the singleton after disposal", async () => {
+		const service = getCliFeatureFlagsService();
+
+		await disposeCliFeatureFlagsService();
+
+		expect(getCliFeatureFlagsService()).not.toBe(service);
+	});
+});
diff --git a/apps/cli/src/utils/feature-flags.ts b/apps/cli/src/utils/feature-flags.ts
new file mode 100644
index 0000000..729819d
--- /dev/null
+++ b/apps/cli/src/utils/feature-flags.ts
@@ -0,0 +1,118 @@
+import { join } from "node:path";
+import {
+	type BasicLogger,
+	type FeatureFlagsContext,
+	FeatureFlagsService,
+	type ITelemetryService,
+	NoOpFeatureFlagsProvider,
+	registerDisposable,
+	resolveCoreDistinctId,
+} from "@cline/core";
+import {
+	buildClinePostHogClient,
+	PostHogFeatureFlagsProvider,
+} from "@cline/core/services/feature-flags/posthog";
+import { resolveClineDataDir } from "@cline/shared/storage";
+
+let cliFeatureFlagsContext: FeatureFlagsContext = { clientName: "cline-cli" };
+let cliFeatureFlagsService: FeatureFlagsService | undefined;
+
+const CLI_FEATURE_FLAGS_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+
+function resolveCliFeatureFlagsCachePath(): string {
+	return join(resolveClineDataDir(), "cache", "feature-flags.json");
+}
+
+function ensureCliDistinctId(): string {
+	const distinctId = cliFeatureFlagsContext.distinctId?.trim();
+	if (distinctId) {
+		return distinctId;
+	}
+	const resolved = resolveCoreDistinctId();
+	cliFeatureFlagsContext.distinctId = resolved;
+	return resolved;
+}
+
+export function getCliFeatureFlagsContext(): FeatureFlagsContext {
+	ensureCliDistinctId();
+	return { ...cliFeatureFlagsContext };
+}
+
+export function getCliFeatureFlagsService(options?: {
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}): FeatureFlagsService {
+	if (!cliFeatureFlagsService) {
+		const apiKey = process.env.TELEMETRY_SERVICE_API_KEY;
+		const provider =
+			apiKey &&
+			process.env.IS_TEST !== "true" &&
+			process.env.E2E_TEST !== "true"
+				? new PostHogFeatureFlagsProvider({
+						client: buildClinePostHogClient(apiKey),
+						config: {
+							logger: options?.logger,
+						},
+					})
+				: new NoOpFeatureFlagsProvider();
+
+		cliFeatureFlagsService = new FeatureFlagsService({
+			provider,
+			telemetry: options?.telemetry,
+			logger: options?.logger,
+			context: getCliFeatureFlagsContext(),
+			cacheFilePath: resolveCliFeatureFlagsCachePath(),
+			persistentCacheMaxAgeMs: CLI_FEATURE_FLAGS_CACHE_MAX_AGE_MS,
+		});
+		registerDisposable(disposeCliFeatureFlagsService);
+	}
+
+	return cliFeatureFlagsService;
+}
+
+export function refreshCliFeatureFlagsInBackground(logger?: BasicLogger): void {
+	const service = getCliFeatureFlagsService({ logger });
+	void service.poll().catch((error) => {
+		logger?.error?.("Error refreshing CLI feature flags", { error });
+	});
+}
+
+export async function disposeCliFeatureFlagsService(): Promise<void> {
+	if (!cliFeatureFlagsService) {
+		return;
+	}
+
+	const current = cliFeatureFlagsService;
+	cliFeatureFlagsService = undefined;
+	await current.dispose();
+}
+
+export function setCliFeatureFlagsAccountContext(account: {
+	id?: string;
+	email?: string;
+}): void {
+	const accountId = account.id?.trim();
+	cliFeatureFlagsContext = {
+		...cliFeatureFlagsContext,
+		...(accountId ? { distinctId: accountId, userId: accountId } : {}),
+		...(account.email?.trim() ? { email: account.email.trim() } : {}),
+	};
+	cliFeatureFlagsService?.setContext(getCliFeatureFlagsContext());
+}
+
+export async function identifyFeatureFlagsAccount(
+	account: { id?: string; email?: string },
+	logger?: BasicLogger,
+): Promise<void> {
+	setCliFeatureFlagsAccountContext(account);
+
+	if (!cliFeatureFlagsService) {
+		return;
+	}
+
+	try {
+		await cliFeatureFlagsService.poll();
+	} catch (error) {
+		logger?.error?.("Error polling CLI feature flags", { error });
+	}
+}
diff --git a/apps/cli/src/utils/free-model-cost.test.ts b/apps/cli/src/utils/free-model-cost.test.ts
new file mode 100644
index 0000000..8302678
--- /dev/null
+++ b/apps/cli/src/utils/free-model-cost.test.ts
@@ -0,0 +1,193 @@
+import type { AgentEvent } from "@cline/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	clearClineFreeModelCostCache,
+	shouldZeroClineFreeModelCost,
+	zeroCliAgentEventCost,
+	zeroCliUsageCost,
+} from "./free-model-cost";
+
+afterEach(() => {
+	clearClineFreeModelCostCache();
+	vi.unstubAllGlobals();
+});
+
+describe("shouldZeroClineFreeModelCost", () => {
+	it("uses the Cline free model list", async () => {
+		const fetchMock = vi.fn(
+			async (_input: Parameters<typeof fetch>[0], _init?: RequestInit) => {
+				return new Response(
+					JSON.stringify({
+						free: [{ id: "deepseek/deepseek-v4-flash" }],
+					}),
+					{ status: 200, headers: { "content-type": "application/json" } },
+				);
+			},
+		);
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "cline",
+				modelId: "deepseek/deepseek-v4-flash",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(true);
+
+		expect(fetchMock.mock.calls[0]?.[0]).toBe(
+			"https://cline.test/api/v1/ai/cline/recommended-models",
+		);
+	});
+
+	it("does not zero non-Cline providers", async () => {
+		const fetchMock = vi.fn();
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "openrouter",
+				modelId: "deepseek/deepseek-v4-flash",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(false);
+		expect(fetchMock).not.toHaveBeenCalled();
+	});
+
+	it("zeros cost of free models selected on the cline-pass provider", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(async () => {
+				return new Response(
+					JSON.stringify({
+						free: [{ id: "deepseek/deepseek-v4-flash" }],
+					}),
+					{ status: 200, headers: { "content-type": "application/json" } },
+				);
+			}),
+		);
+
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "cline-pass",
+				modelId: "deepseek/deepseek-v4-flash",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(true);
+
+		// subscription (cline-pass/...) models are not in the free bucket
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "cline-pass",
+				modelId: "cline-pass/glm-5.1",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(false);
+	});
+
+	it("does not match a paid model by only the final path segment", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(async () => {
+				return new Response(
+					JSON.stringify({
+						free: [{ id: "deepseek/deepseek-v4-flash" }],
+					}),
+					{ status: 200, headers: { "content-type": "application/json" } },
+				);
+			}),
+		);
+
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "cline",
+				modelId: "acme/deepseek-v4-flash",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(false);
+	});
+
+	it("retries after a failed free model list fetch", async () => {
+		const fetchMock = vi
+			.fn()
+			.mockResolvedValueOnce(new Response("unavailable", { status: 503 }))
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						free: [{ id: "deepseek/deepseek-v4-flash" }],
+					}),
+					{ status: 200, headers: { "content-type": "application/json" } },
+				),
+			);
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "cline",
+				modelId: "deepseek/deepseek-v4-flash",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(false);
+		await expect(
+			shouldZeroClineFreeModelCost({
+				providerId: "cline",
+				modelId: "deepseek/deepseek-v4-flash",
+				baseUrl: "https://cline.test/api/v1",
+			}),
+		).resolves.toBe(true);
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+	});
+});
+
+describe("zeroCliUsageCost", () => {
+	it("zeros total cost while preserving token usage", () => {
+		expect(
+			zeroCliUsageCost(
+				{
+					inputTokens: 10,
+					outputTokens: 5,
+					totalCost: 0.001,
+				},
+				true,
+			),
+		).toEqual({
+			inputTokens: 10,
+			outputTokens: 5,
+			totalCost: 0,
+		});
+	});
+});
+
+describe("zeroCliAgentEventCost", () => {
+	it("zeros usage event cost fields", () => {
+		const event = {
+			type: "usage",
+			inputTokens: 10,
+			outputTokens: 5,
+			cost: 0.001,
+			totalCost: 0.001,
+		} as AgentEvent;
+
+		expect(zeroCliAgentEventCost(event, true)).toMatchObject({
+			cost: 0,
+			totalCost: 0,
+		});
+	});
+
+	it("zeros done event usage cost", () => {
+		const event = {
+			type: "done",
+			reason: "completed",
+			text: "ok",
+			iterations: 1,
+			usage: {
+				inputTokens: 10,
+				outputTokens: 5,
+				totalCost: 0.001,
+			},
+		} as AgentEvent;
+
+		expect(zeroCliAgentEventCost(event, true)).toMatchObject({
+			usage: { totalCost: 0 },
+		});
+	});
+});
diff --git a/apps/cli/src/utils/free-model-cost.ts b/apps/cli/src/utils/free-model-cost.ts
new file mode 100644
index 0000000..0ec93fb
--- /dev/null
+++ b/apps/cli/src/utils/free-model-cost.ts
@@ -0,0 +1,125 @@
+import type { AgentEvent } from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import type { Config } from "./types";
+
+const CLINE_RECOMMENDED_MODELS_TIMEOUT_MS = 5_000;
+const freeModelIdsByBaseUrl = new Map<
+	string,
+	Promise<readonly string[] | undefined>
+>();
+
+function normalizeModelId(modelId: string | undefined): string {
+	return modelId?.trim().toLowerCase() ?? "";
+}
+
+function modelIdsMatch(selectedModelId: string, freeModelId: string): boolean {
+	const selected = normalizeModelId(selectedModelId);
+	const free = normalizeModelId(freeModelId);
+	if (!selected || !free) return false;
+	return selected === free;
+}
+
+function resolveClineRecommendedModelsUrl(baseUrl: string): string {
+	const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "");
+	const apiBaseUrl = normalizedBaseUrl.endsWith("/api/v1")
+		? normalizedBaseUrl.slice(0, -"/api/v1".length)
+		: normalizedBaseUrl;
+	return `${apiBaseUrl}/api/v1/ai/cline/recommended-models`;
+}
+
+async function fetchClineFreeModelIds(
+	baseUrl: string,
+): Promise<readonly string[] | undefined> {
+	const controller = new AbortController();
+	const timeout = setTimeout(
+		() => controller.abort(),
+		CLINE_RECOMMENDED_MODELS_TIMEOUT_MS,
+	);
+	try {
+		const response = await fetch(resolveClineRecommendedModelsUrl(baseUrl), {
+			signal: controller.signal,
+		});
+		if (!response.ok) return undefined;
+		const json = (await response.json()) as { free?: unknown };
+		return Array.isArray(json.free)
+			? json.free
+					.map((model) =>
+						model && typeof model === "object"
+							? (model as Record<string, unknown>).id
+							: undefined,
+					)
+					.filter((id): id is string => typeof id === "string" && id.length > 0)
+			: [];
+	} catch {
+		return undefined;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+function getClineFreeModelIds(baseUrl: string): Promise<readonly string[]> {
+	const cacheKey = baseUrl.trim();
+	let cached = freeModelIdsByBaseUrl.get(cacheKey);
+	if (!cached) {
+		cached = fetchClineFreeModelIds(cacheKey).then((ids) => {
+			if (!ids) freeModelIdsByBaseUrl.delete(cacheKey);
+			return ids;
+		});
+		freeModelIdsByBaseUrl.set(cacheKey, cached);
+	}
+	return cached.then((ids) => ids ?? []);
+}
+
+export async function shouldZeroClineFreeModelCost(
+	config: Pick<Config, "providerId" | "modelId" | "baseUrl">,
+): Promise<boolean> {
+	// Free models are also selectable on ClinePass — they ride usage billing at $0
+	if (config.providerId !== "cline" && config.providerId !== "cline-pass")
+		return false;
+	const modelId = normalizeModelId(config.modelId);
+	if (!modelId) return false;
+
+	const baseUrl =
+		config.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl;
+	const freeModelIds = await getClineFreeModelIds(baseUrl);
+	return freeModelIds.some((freeModelId) =>
+		modelIdsMatch(modelId, freeModelId),
+	);
+}
+
+export function zeroCliUsageCost<T extends { totalCost?: number } | undefined>(
+	usage: T,
+	shouldZeroCost: boolean,
+): T {
+	if (
+		!shouldZeroCost ||
+		!usage ||
+		typeof usage.totalCost !== "number" ||
+		usage.totalCost === 0
+	) {
+		return usage;
+	}
+	return { ...usage, totalCost: 0 } as T;
+}
+
+export function zeroCliAgentEventCost(
+	event: AgentEvent,
+	shouldZeroCost: boolean,
+): AgentEvent {
+	if (!shouldZeroCost) return event;
+	if (event.type === "done" && event.usage) {
+		return {
+			...event,
+			usage: zeroCliUsageCost(event.usage, true),
+		};
+	}
+	if (event.type !== "usage") return event;
+	const next = { ...event } as Record<string, unknown>;
+	if (typeof next.cost === "number") next.cost = 0;
+	if (typeof next.totalCost === "number") next.totalCost = 0;
+	return next as unknown as AgentEvent;
+}
+
+export function clearClineFreeModelCostCache(): void {
+	freeModelIdsByBaseUrl.clear();
+}
diff --git a/apps/cli/src/utils/helpers.test.ts b/apps/cli/src/utils/helpers.test.ts
new file mode 100644
index 0000000..3869415
--- /dev/null
+++ b/apps/cli/src/utils/helpers.test.ts
@@ -0,0 +1,526 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	appendHookAudit,
+	configureSandboxEnvironment,
+	formatToolInput,
+	formatToolOutput,
+	isCliHookPayload,
+	normalizeAutoApproveArgs,
+	parseArgs,
+} from "./helpers";
+
+type EnvSnapshot = {
+	CLINE_DATA_DIR: string | undefined;
+	CLINE_DB_DATA_DIR: string | undefined;
+	CLINE_HOOKS_LOG_PATH: string | undefined;
+	CLINE_SESSION_ID: string | undefined;
+	CLINE_SESSION_DATA_DIR: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+		CLINE_DB_DATA_DIR: process.env.CLINE_DB_DATA_DIR,
+		CLINE_HOOKS_LOG_PATH: process.env.CLINE_HOOKS_LOG_PATH,
+		CLINE_SESSION_ID: process.env.CLINE_SESSION_ID,
+		CLINE_SESSION_DATA_DIR: process.env.CLINE_SESSION_DATA_DIR,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.CLINE_DATA_DIR = snapshot.CLINE_DATA_DIR;
+	process.env.CLINE_DB_DATA_DIR = snapshot.CLINE_DB_DATA_DIR;
+	process.env.CLINE_HOOKS_LOG_PATH = snapshot.CLINE_HOOKS_LOG_PATH;
+	process.env.CLINE_SESSION_ID = snapshot.CLINE_SESSION_ID;
+	process.env.CLINE_SESSION_DATA_DIR = snapshot.CLINE_SESSION_DATA_DIR;
+}
+
+describe("parseArgs", () => {
+	it("returns defaults when no arguments are supplied", () => {
+		const parsed = parseArgs([]);
+		expect(parsed).toEqual({
+			verbose: false,
+			interactive: false,
+			outputMode: "text",
+			mode: "act",
+			sandbox: false,
+			acpMode: false,
+			thinking: false,
+			reasoningEffort: undefined,
+			defaultToolAutoApprove: true,
+		});
+	});
+
+	it("parses prompt, runtime flags, and global approval settings", () => {
+		const parsed = parseArgs([
+			"--verbose",
+			"--auto-approve",
+			"false",
+			"--cwd",
+			"/tmp/work",
+			"--team-name",
+			"dev-team",
+			"--provider",
+			"openai",
+			"--model",
+			"gpt-5",
+			"--key",
+			"abc123",
+			"--thinking",
+			"high",
+			"--plan",
+			"Audit",
+			"the",
+			"repo",
+		]);
+
+		expect(parsed.prompt).toBe("Audit the repo");
+		expect(parsed.verbose).toBe(true);
+		expect(parsed.defaultToolAutoApprove).toBe(false);
+		expect(parsed.autoApproveOverride).toBe(false);
+		expect(parsed.thinking).toBe(true);
+		expect(parsed.reasoningEffort).toBe("high");
+		expect(parsed.outputMode).toBe("text");
+		expect(parsed.mode).toBe("plan");
+		expect(parsed.cwd).toBe("/tmp/work");
+		expect(parsed.teamName).toBe("dev-team");
+		expect(parsed.provider).toBe("openai");
+		expect(parsed.model).toBe("gpt-5");
+		expect(parsed.key).toBe("abc123");
+		expect(parsed.sandbox).toBe(false);
+	});
+
+	it("parses provider via -P shorthand", () => {
+		const parsed = parseArgs(["-P", "cline"]);
+		expect(parsed.provider).toBe("cline");
+	});
+
+	it("enables sandbox automatically when --data-dir is set", () => {
+		const parsed = parseArgs(["--data-dir", "./.tmp-cline"]);
+		expect(parsed.sandbox).toBe(true);
+		expect(parsed.dataDir).toBe("./.tmp-cline");
+	});
+
+	it("does not enable sandbox when --data-dir is omitted", () => {
+		const parsed = parseArgs([]);
+		expect(parsed.sandbox).toBe(false);
+		expect(parsed.dataDir).toBeUndefined();
+	});
+
+	it("parses --auto-approve false as global approval-off", () => {
+		const parsed = parseArgs([
+			"--auto-approve",
+			"false",
+			"tell me about this repo",
+		]);
+		expect(parsed.defaultToolAutoApprove).toBe(false);
+		expect(parsed.autoApproveOverride).toBe(false);
+		expect(parsed.prompt).toBe("tell me about this repo");
+	});
+
+	it("treats bare --auto-approve as true", () => {
+		expect(
+			normalizeAutoApproveArgs(["--auto-approve", "Audit the repo"]),
+		).toEqual(["--auto-approve", "true", "Audit the repo"]);
+		const parsed = parseArgs(["--auto-approve", "Audit the repo"]);
+		expect(parsed.defaultToolAutoApprove).toBe(true);
+		expect(parsed.autoApproveOverride).toBe(true);
+		expect(parsed.prompt).toBe("Audit the repo");
+	});
+
+	it("records invalid --auto-approve values", () => {
+		const parsed = parseArgs(["--auto-approve=maybe"]);
+		expect(parsed.invalidAutoApprove).toBe("maybe");
+	});
+
+	it("accepts legacy --autoapprove as --auto-approve", () => {
+		const parsed = parseArgs(["--autoapprove", "false"]);
+		expect(parsed.defaultToolAutoApprove).toBe(false);
+		expect(parsed.autoApproveOverride).toBe(false);
+	});
+
+	it("supports json output flags and validates explicit output modes", () => {
+		const parsedJsonAlias = parseArgs(["--json", "hello"]);
+		expect(parsedJsonAlias.outputMode).toBe("json");
+		expect(parsedJsonAlias.prompt).toBe("hello");
+	});
+
+	it("parses act/plan mode flags", () => {
+		const parsedPlan = parseArgs(["--plan"]);
+		expect(parsedPlan.mode).toBe("plan");
+
+		const parsedAct = parseArgs(["-a"]);
+		expect(parsedAct.mode).toBe("act");
+	});
+
+	it("parses bare --thinking as medium before a flag", () => {
+		const parsed = parseArgs(["--thinking", "--plan", "Audit the repo"]);
+		expect(parsed.thinking).toBe(true);
+		expect(parsed.reasoningEffort).toBe("medium");
+		expect(parsed.mode).toBe("plan");
+		expect(parsed.prompt).toBe("Audit the repo");
+	});
+
+	it("parses --thinking with explicit level", () => {
+		const parsed = parseArgs(["--thinking", "high"]);
+		expect(parsed.thinking).toBe(true);
+		expect(parsed.reasoningEffort).toBe("high");
+	});
+
+	it("parses --thinking none as disabled", () => {
+		const parsed = parseArgs(["--thinking", "none"]);
+		expect(parsed.thinking).toBe(false);
+		expect(parsed.reasoningEffort).toBeUndefined();
+	});
+
+	it("parses and validates thinking level with equals notation", () => {
+		const parsedInvalid = parseArgs(["--thinking=ultra"]);
+		expect(parsedInvalid.reasoningEffort).toBeUndefined();
+		expect(parsedInvalid.invalidThinkingLevel).toBe("ultra");
+	});
+
+	it("parses and validates thinking level with space notation", () => {
+		const parsedInvalid = parseArgs(["--thinking", "ultra", "Audit"]);
+		expect(parsedInvalid.reasoningEffort).toBeUndefined();
+		expect(parsedInvalid.invalidThinkingLevel).toBe("ultra");
+		expect(parsedInvalid.prompt).toBe("Audit");
+	});
+
+	it("accepts legacy --reasoning-effort as --thinking", () => {
+		const parsed = parseArgs(["--reasoning-effort", "high"]);
+		expect(parsed.thinking).toBe(true);
+		expect(parsed.reasoningEffort).toBe("high");
+	});
+
+	it("validates legacy --reasoning-effort invalid levels", () => {
+		const parsedSpace = parseArgs(["--reasoning-effort", "ultra", "Audit"]);
+		expect(parsedSpace.reasoningEffort).toBeUndefined();
+		expect(parsedSpace.invalidThinkingLevel).toBe("ultra");
+		expect(parsedSpace.prompt).toBe("Audit");
+
+		const parsedEquals = parseArgs(["--reasoning-effort=ultra", "Audit"]);
+		expect(parsedEquals.reasoningEffort).toBeUndefined();
+		expect(parsedEquals.invalidThinkingLevel).toBe("ultra");
+		expect(parsedEquals.prompt).toBe("Audit");
+	});
+
+	it("parses --retries when valid", () => {
+		const parsed = parseArgs(["--retries", "5"]);
+		expect(parsed.retries).toBe(5);
+		expect(parsed.invalidRetries).toBeUndefined();
+	});
+
+	it("supports yolo as an auto-approval shortcut", () => {
+		const parsedYolo = parseArgs(["--yolo"]);
+		expect(parsedYolo.mode).toBe("yolo");
+		expect(parsedYolo.defaultToolAutoApprove).toBe(true);
+		expect(parsedYolo.autoApproveOverride).toBe(true);
+	});
+
+	it("parses --zen flag for background hub dispatch", () => {
+		const parsedLong = parseArgs(["--zen", "do it"]);
+		expect(parsedLong.mode).toBe("zen");
+		expect(parsedLong.prompt).toBe("do it");
+
+		const parsedShort = parseArgs(["-z", "do it"]);
+		expect(parsedShort.mode).toBe("zen");
+	});
+
+	it("parses timeout and validates invalid values", () => {
+		const parsed = parseArgs(["-t", "30"]);
+		expect(parsed.timeoutSeconds).toBe(30);
+
+		const invalid = parseArgs(["--timeout", "abc"]);
+		expect(invalid.invalidTimeoutSeconds).toBe("abc");
+	});
+
+	it("records invalid --retries values", () => {
+		const parsed = parseArgs(["--retries", "0"]);
+		expect(parsed.retries).toBeUndefined();
+		expect(parsed.invalidRetries).toBe("0");
+	});
+});
+
+describe("format helpers", () => {
+	it("truncates run_commands with commands array", () => {
+		const result = formatToolInput("run_commands", {
+			commands: [
+				"echo hello",
+				"npm run very-very-long-command-name-that-will-truncate",
+			],
+		});
+		expect(result).toContain("echo hello");
+		expect(result.length).toBeLessThanOrEqual(120);
+	});
+
+	it("truncates run_commands with commands as single string", () => {
+		const longCmd = `echo ${"x".repeat(200)}`;
+		const result = formatToolInput("run_commands", { commands: longCmd });
+		expect(result).toContain("echo");
+		expect(result.length).toBeLessThanOrEqual(120);
+	});
+
+	it("truncates run_commands with bare string input", () => {
+		const longCmd = `echo ${"x".repeat(200)}`;
+		const result = formatToolInput("run_commands", longCmd);
+		expect(result).toContain("echo");
+		expect(result.length).toBeLessThanOrEqual(120);
+	});
+
+	it("truncates run_commands with bare string array input", () => {
+		const result = formatToolInput("run_commands", [
+			"echo hello",
+			"echo world",
+		]);
+		expect(result).toContain("echo hello; echo world");
+	});
+
+	it("truncates run_commands with structured command input", () => {
+		const result = formatToolInput("run_commands", {
+			commands: [{ command: "git", args: ["status", "--short"] }],
+		});
+		expect(result).toContain("git status --short");
+	});
+
+	it("truncates run_commands with bare structured command", () => {
+		const result = formatToolInput("run_commands", {
+			command: "git",
+			args: ["log", "--oneline"],
+		});
+		expect(result).toContain("git log --oneline");
+	});
+
+	it("handles structured command with non-array args gracefully", () => {
+		const result = formatToolInput("run_commands", {
+			commands: [{ command: "git", args: "status" }],
+		});
+		expect(result).toBe("git");
+	});
+
+	it("formats known tool input payloads with truncation", () => {
+		expect(
+			formatToolInput("team_run_task", {
+				runMode: "sync",
+				agentId: "coder",
+				task: "implement feature with extensive acceptance criteria and checks",
+			}),
+		).toContain("sync coder:");
+		expect(
+			formatToolInput("team_member", {
+				action: "spawn",
+				agentId: "reviewer",
+				rolePrompt: "Review changes and call out risks",
+			}),
+		).toContain("spawn reviewer:");
+		expect(
+			formatToolInput("team_task", {
+				action: "complete",
+				taskId: "task_0012",
+				summary: "Done and verified",
+			}),
+		).toContain("complete task_0012:");
+		expect(
+			formatToolInput("team_message", {
+				action: "send",
+				toAgentId: "lead",
+				subject: "Status update",
+			}),
+		).toContain("send lead:");
+	});
+
+	it("formats ask_question as a readable prompt", () => {
+		expect(
+			formatToolInput("ask_question", {
+				question: "How can I best assist you today?",
+				options: [
+					"Help me understand or analyze code in a repository",
+					"Help me create or edit files",
+					"Help me run commands or tests",
+				],
+			}),
+		).toBe(
+			[
+				"The agent is waiting for your input.",
+				"How can I best assist you today?",
+				"1. Help me understand or analyze code in a repository",
+				"2. Help me create or edit files",
+				"3. Help me run commands or tests",
+				"> Reply with an option number or type your answer.",
+			].join("\n"),
+		);
+	});
+
+	it("summarizes structured tool outputs", () => {
+		expect(formatToolOutput("simple text output")).toBe("simple text output");
+		expect(
+			formatToolOutput([
+				{ result: "first" },
+				{ result: "second" },
+				{ result: "third" },
+			]),
+		).toBe("first (+2 more)");
+		expect(formatToolOutput(null)).toBe("");
+	});
+});
+
+describe("hook payload validation and audit logging", () => {
+	let tempDir = "";
+
+	afterEach(() => {
+		if (tempDir) {
+			rmSync(tempDir, { recursive: true, force: true });
+			tempDir = "";
+		}
+	});
+
+	it("validates hook payload structure", async () => {
+		expect(
+			await isCliHookPayload({
+				clineVersion: "",
+				hookName: "tool_call",
+				timestamp: new Date().toISOString(),
+				taskId: "conv_1",
+				workspaceRoots: [],
+				userId: "agent_1",
+				agent_id: "agent_1",
+				parent_agent_id: null,
+				iteration: 1,
+				tool_call: {
+					id: "call_1",
+					name: "read_files",
+					input: { file_paths: ["README.md"] },
+				},
+			}),
+		).toBe(true);
+		expect(await isCliHookPayload({ hookName: "tool_call" })).toBe(false);
+		expect(await isCliHookPayload(null)).toBe(false);
+	});
+
+	it("writes hook audits to global log", async () => {
+		tempDir = mkdtempSync(path.join(os.tmpdir(), "cli-helper-audit-"));
+		const expectedPath = path.join(tempDir, "logs", "hooks.jsonl");
+		const env = captureEnv();
+		process.env.CLINE_DATA_DIR = tempDir;
+		delete process.env.CLINE_HOOKS_LOG_PATH;
+		delete process.env.CLINE_SESSION_ID;
+		delete process.env.CLINE_SESSION_DATA_DIR;
+
+		await appendHookAudit({
+			clineVersion: "",
+			hookName: "tool_call",
+			timestamp: new Date().toISOString(),
+			taskId: "conv_1",
+			sessionContext: { rootSessionId: "session_from_context" },
+			workspaceRoots: [],
+			userId: "agent_1",
+			iteration: 1,
+			agent_id: "agent_1",
+			parent_agent_id: null,
+			tool_call: {
+				id: "call_1",
+				name: "read_files",
+				input: { file_paths: ["README.md"] },
+			},
+		});
+		restoreEnv(env);
+
+		expect(existsSync(expectedPath)).toBe(true);
+		const content = readFileSync(expectedPath, "utf8");
+		expect(content).toContain('"hookName":"tool_call"');
+		expect(content).toContain('"agent_id":"agent_1"');
+	});
+
+	it("writes hook audits to CLINE_HOOKS_LOG_PATH when set", async () => {
+		tempDir = mkdtempSync(path.join(os.tmpdir(), "cli-helper-env-audit-"));
+		const expectedPath = path.join(tempDir, "hooks", "from-env.jsonl");
+		const env = captureEnv();
+		process.env.CLINE_HOOKS_LOG_PATH = expectedPath;
+		delete process.env.CLINE_DATA_DIR;
+		delete process.env.CLINE_SESSION_ID;
+		delete process.env.CLINE_SESSION_DATA_DIR;
+
+		await appendHookAudit({
+			clineVersion: "",
+			hookName: "tool_result",
+			timestamp: new Date().toISOString(),
+			taskId: "conv_3",
+			workspaceRoots: [],
+			userId: "agent_3",
+			iteration: 1,
+			agent_id: "agent_3",
+			parent_agent_id: null,
+			tool_result: {
+				id: "call_3",
+				name: "read_files",
+				input: { file_paths: ["README.md"] },
+				output: "ok",
+				durationMs: 5,
+				startedAt: new Date("2026-01-01T00:00:00.000Z"),
+				endedAt: new Date("2026-01-01T00:00:00.005Z"),
+			},
+		});
+		restoreEnv(env);
+
+		expect(existsSync(expectedPath)).toBe(true);
+		const content = readFileSync(expectedPath, "utf8");
+		expect(content).toContain('"hookName":"tool_result"');
+	});
+});
+
+describe("sandbox environment", () => {
+	it("sets sandbox-specific storage paths", () => {
+		const root = mkdtempSync(path.join(os.tmpdir(), "cli-helper-sandbox-"));
+		const previous = {
+			CLINE_SANDBOX: process.env.CLINE_SANDBOX,
+			CLINE_SANDBOX_DATA_DIR: process.env.CLINE_SANDBOX_DATA_DIR,
+			CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+			CLINE_DB_DATA_DIR: process.env.CLINE_DB_DATA_DIR,
+			CLINE_SESSION_DATA_DIR: process.env.CLINE_SESSION_DATA_DIR,
+			CLINE_TEAM_DATA_DIR: process.env.CLINE_TEAM_DATA_DIR,
+			CLINE_PROVIDER_SETTINGS_PATH: process.env.CLINE_PROVIDER_SETTINGS_PATH,
+			CLINE_HOOKS_LOG_PATH: process.env.CLINE_HOOKS_LOG_PATH,
+		};
+		try {
+			const resolved = configureSandboxEnvironment({
+				enabled: true,
+				cwd: root,
+				explicitDir: "./sandbox-state",
+			});
+			expect(resolved).toBe(path.join(root, "sandbox-state"));
+			expect(process.env.CLINE_SANDBOX).toBe("1");
+			expect(process.env.CLINE_SANDBOX_DATA_DIR).toBe(
+				path.join(root, "sandbox-state"),
+			);
+			expect(process.env.CLINE_DATA_DIR).toBe(path.join(root, "sandbox-state"));
+			expect(process.env.CLINE_DB_DATA_DIR).toBe(
+				path.join(root, "sandbox-state", "db"),
+			);
+			expect(process.env.CLINE_SESSION_DATA_DIR).toBe(
+				path.join(root, "sandbox-state", "sessions"),
+			);
+			expect(process.env.CLINE_TEAM_DATA_DIR).toBe(
+				path.join(root, "sandbox-state", "teams"),
+			);
+			expect(process.env.CLINE_PROVIDER_SETTINGS_PATH).toBe(
+				path.join(root, "sandbox-state", "settings", "providers.json"),
+			);
+			expect(process.env.CLINE_HOOKS_LOG_PATH).toBe(
+				path.join(root, "sandbox-state", "logs", "hooks.jsonl"),
+			);
+		} finally {
+			process.env.CLINE_SANDBOX = previous.CLINE_SANDBOX;
+			process.env.CLINE_SANDBOX_DATA_DIR = previous.CLINE_SANDBOX_DATA_DIR;
+			process.env.CLINE_DATA_DIR = previous.CLINE_DATA_DIR;
+			process.env.CLINE_DB_DATA_DIR = previous.CLINE_DB_DATA_DIR;
+			process.env.CLINE_SESSION_DATA_DIR = previous.CLINE_SESSION_DATA_DIR;
+			process.env.CLINE_TEAM_DATA_DIR = previous.CLINE_TEAM_DATA_DIR;
+			process.env.CLINE_PROVIDER_SETTINGS_PATH =
+				previous.CLINE_PROVIDER_SETTINGS_PATH;
+			process.env.CLINE_HOOKS_LOG_PATH = previous.CLINE_HOOKS_LOG_PATH;
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/apps/cli/src/utils/helpers.ts b/apps/cli/src/utils/helpers.ts
new file mode 100644
index 0000000..ca88a18
--- /dev/null
+++ b/apps/cli/src/utils/helpers.ts
@@ -0,0 +1,561 @@
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { type HookEventPayload, parseHookEventPayload } from "@cline/shared";
+import { ensureHookLogDir } from "@cline/shared/storage";
+import { nanoid } from "nanoid";
+import { commanderToParsedArgs, createProgram } from "../commands/program";
+import type { ParsedArgs } from "./types";
+
+export function sanitizeSessionToken(value: string): string {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+export function makeSubSessionId(
+	rootSessionId: string,
+	agentId: string,
+): string {
+	const root = sanitizeSessionToken(rootSessionId);
+	const agent = sanitizeSessionToken(agentId);
+	const joined = `${root}__${agent}`;
+	return joined.length > 180 ? joined.slice(0, 180) : joined;
+}
+
+export function makeTeamTaskSubSessionId(
+	rootSessionId: string,
+	agentId: string,
+): string {
+	const root = sanitizeSessionToken(rootSessionId);
+	const agent = sanitizeSessionToken(agentId);
+	const nonce = Math.random().toString(36).slice(2, 8);
+	return `${root}__teamtask__${agent}__${Date.now()}_${nonce}`;
+}
+
+export function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export function randomSessionId(): string {
+	return `${Date.now()}_${nanoid(5)}_cli`;
+}
+
+export function resolveWorkspaceRoot(cwd: string): string {
+	const result = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+		encoding: "utf8",
+	});
+	if (result.status === 0) {
+		const value = result.stdout.trim();
+		if (value) {
+			return value;
+		}
+	}
+	return cwd;
+}
+
+export function truncate(str: string, maxLen: number): string {
+	const oneLine = str.replace(/\n/g, " ").trim();
+	if (oneLine.length <= maxLen) {
+		return oneLine;
+	}
+	return `${oneLine.slice(0, maxLen - 3)}...`;
+}
+
+export function formatStructuredCommand(cmd: unknown): string {
+	if (typeof cmd === "string") {
+		return cmd;
+	}
+	if (cmd && typeof cmd === "object" && "command" in cmd) {
+		const structured = cmd as { command: string; args?: unknown };
+		const args = Array.isArray(structured.args) ? structured.args : [];
+		if (args.length === 0) {
+			return structured.command;
+		}
+		return `${structured.command} ${args.join(" ")}`;
+	}
+	return String(cmd);
+}
+
+function summarizeRunCommandsInput(input: unknown): string {
+	if (typeof input === "string") {
+		return input;
+	}
+
+	if (Array.isArray(input)) {
+		return input.map(formatStructuredCommand).join("; ");
+	}
+
+	if (input && typeof input === "object") {
+		const obj = input as Record<string, unknown>;
+		if (obj.commands !== undefined) {
+			if (Array.isArray(obj.commands)) {
+				return obj.commands.map(formatStructuredCommand).join("; ");
+			}
+			return formatStructuredCommand(obj.commands);
+		}
+		if ("command" in obj) {
+			return formatStructuredCommand(obj);
+		}
+	}
+
+	return "";
+}
+
+function formatAskQuestionInput(input: Record<string, unknown>): string {
+	const question =
+		typeof input.question === "string" ? input.question.trim() : "";
+	const options = Array.isArray(input.options)
+		? input.options
+				.map((option) => String(option).trim())
+				.filter((option) => option.length > 0)
+		: [];
+
+	if (!question && options.length === 0) {
+		return "";
+	}
+
+	const lines = ["The agent is waiting for your input."];
+	if (question) {
+		lines.push(question);
+	}
+	for (const [index, option] of options.entries()) {
+		lines.push(`${index + 1}. ${option}`);
+	}
+	lines.push("> Reply with an option number or type your answer.");
+	return lines.join("\n");
+}
+
+export function formatToolInput(toolName: string, input: unknown): string {
+	if (!input) {
+		return "";
+	}
+
+	if (toolName === "run_commands") {
+		return truncate(summarizeRunCommandsInput(input), 120);
+	}
+
+	if (typeof input !== "object") {
+		return "";
+	}
+
+	const obj = input as Record<string, unknown>;
+
+	switch (toolName) {
+		case "ask_question":
+			return formatAskQuestionInput(obj);
+		case "read_files":
+			if (Array.isArray(obj.file_paths)) {
+				return truncate(obj.file_paths.join(", "), 120);
+			}
+			break;
+		case "search_codebase":
+			if (Array.isArray(obj.queries)) {
+				return truncate(obj.queries.join(", "), 120);
+			}
+			break;
+		case "fetch_web_content":
+			if (Array.isArray(obj.requests)) {
+				return truncate(
+					obj.requests
+						.map((r) => r.url)
+						.filter(Boolean)
+						.join(", "),
+					120,
+				);
+			}
+			break;
+		case "spawn_agent":
+			return truncate(String(obj.task ?? ""), 50);
+		case "skills":
+			return truncate(
+				`${String(obj.skill ?? "")}${obj.args ? ` ${String(obj.args)}` : ""}`,
+				70,
+			);
+		case "ask_followup_question":
+			return truncate(String(obj.question ?? ""), 120);
+		case "team_member": {
+			const action = String(obj.action ?? "");
+			if (action === "spawn") {
+				return truncate(
+					`spawn ${String(obj.agentId ?? "")}: ${String(obj.rolePrompt ?? "")}`,
+					70,
+				);
+			}
+			if (action === "shutdown") {
+				return truncate(`shutdown ${String(obj.agentId ?? "")}`, 70);
+			}
+			break;
+		}
+		case "team_spawn_teammate":
+			return truncate(
+				`${String(obj.agentId ?? "")}: ${String(obj.rolePrompt ?? "")}`,
+				70,
+			);
+		case "team_shutdown_teammate":
+			return truncate(`shutdown ${String(obj.agentId ?? "")}`, 70);
+		case "team_task": {
+			const action = String(obj.action ?? "");
+			if (action === "create") {
+				return truncate(`create ${String(obj.title ?? "")}`, 60);
+			}
+			if (action === "list") {
+				return truncate(
+					`list status=${String(obj.status ?? "any")} readyOnly=${String(obj.readyOnly ?? false)}`,
+					60,
+				);
+			}
+			if (action === "claim") {
+				return truncate(`claim ${String(obj.taskId ?? "")}`, 60);
+			}
+			if (action === "complete") {
+				return truncate(
+					`complete ${String(obj.taskId ?? "")}: ${String(obj.summary ?? "")}`,
+					70,
+				);
+			}
+			if (action === "block") {
+				return truncate(
+					`block ${String(obj.taskId ?? "")}: ${String(obj.reason ?? "")}`,
+					70,
+				);
+			}
+			break;
+		}
+		case "team_run_task":
+			return truncate(
+				`${String(obj.runMode ?? "sync")} ${String(obj.agentId ?? "")}: ${String(obj.task ?? "")}`,
+				70,
+			);
+		case "team_list_runs":
+			return truncate(
+				`status=${String(obj.status ?? "any")} agent=${String(obj.agentId ?? "any")}`,
+				60,
+			);
+		case "team_cancel_run":
+			return truncate(`cancel ${String(obj.runId ?? "")}`, 60);
+		case "team_await_run":
+			return truncate(String(obj.runId ?? ""), 60);
+		case "team_await_all_runs":
+			return "all runs";
+		case "team_message": {
+			const action = String(obj.action ?? "");
+			if (action === "send") {
+				return truncate(
+					`send ${String(obj.toAgentId ?? "")}: ${String(obj.subject ?? "")}`,
+					70,
+				);
+			}
+			if (action === "broadcast") {
+				return truncate(`broadcast ${String(obj.subject ?? "")}`, 70);
+			}
+			if (action === "read") {
+				return truncate(
+					`read unreadOnly=${String(obj.unreadOnly ?? true)} limit=${String(obj.limit ?? "default")}`,
+					70,
+				);
+			}
+			break;
+		}
+		case "team_send_message":
+			return truncate(
+				`${String(obj.toAgentId ?? "")}: ${String(obj.subject ?? "")}`,
+				70,
+			);
+		case "team_broadcast":
+			return truncate(String(obj.subject ?? ""), 70);
+		case "team_read_mailbox":
+			return truncate(
+				`read unreadOnly=${String(obj.unreadOnly ?? true)} limit=${String(obj.limit ?? "default")}`,
+				70,
+			);
+		case "team_create_outcome":
+			return truncate(String(obj.title ?? ""), 70);
+		case "team_attach_outcome_fragment":
+			return truncate(
+				`${String(obj.outcomeId ?? "")}/${String(obj.section ?? "")}`,
+				70,
+			);
+		case "team_review_outcome_fragment":
+			return truncate(
+				`${String(obj.fragmentId ?? "")}: ${String(obj.approved ?? "")}`,
+				70,
+			);
+		case "team_finalize_outcome":
+			return truncate(String(obj.outcomeId ?? ""), 70);
+		case "team_list_outcomes":
+			return "list";
+	}
+
+	return truncate(JSON.stringify(input), 60);
+}
+
+export function formatToolOutput(output: unknown): string {
+	if (output === null || output === undefined) {
+		return "";
+	}
+
+	if (typeof output === "string") {
+		return truncate(output, 100);
+	}
+
+	if (isTeamStatusBoard(output)) {
+		const pending = output.taskCounts.pending;
+		const inProgress = output.taskCounts.in_progress;
+		const blocked = output.taskCounts.blocked;
+		const completed = output.taskCounts.completed;
+		const outcomes = output.outcomeCounts;
+		return truncate(
+			`team=${output.teamName} members=${output.members.length} tasks(p:${pending}/ip:${inProgress}/b:${blocked}/c:${completed}) runs(active:${output.activeRuns}/queued:${output.queuedRuns}) outcomes(d:${outcomes.draft}/r:${outcomes.in_review}/f:${outcomes.finalized})`,
+			130,
+		);
+	}
+
+	if (Array.isArray(output)) {
+		const results = output
+			.map((item) => {
+				if (item && typeof item === "object" && "result" in item) {
+					const result = item.result;
+					const resultStr = Array.isArray(result)
+						? result
+								.map((part: unknown) =>
+									part &&
+									typeof part === "object" &&
+									"type" in part &&
+									(part as { type: string }).type === "text" &&
+									"text" in part
+										? String((part as { text: unknown }).text)
+										: (part as { type?: string })?.type === "image"
+											? "[image]"
+											: "",
+								)
+								.filter(Boolean)
+								.join(" ") || "Successfully read image"
+						: String(result ?? "");
+					return truncate(resultStr, 80);
+				}
+				return truncate(JSON.stringify(item), 80);
+			})
+			.filter((s) => s.length > 0);
+
+		if (results.length === 0) {
+			return "";
+		}
+		if (results.length === 1) {
+			return results[0];
+		}
+		return `${results[0]} (+${results.length - 1} more)`;
+	}
+
+	return truncate(JSON.stringify(output), 100);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object";
+}
+
+function isTeamStatusBoard(value: unknown): value is {
+	teamName: string;
+	members: unknown[];
+	taskCounts: Record<
+		"pending" | "in_progress" | "blocked" | "completed",
+		number
+	>;
+	activeRuns: number;
+	queuedRuns: number;
+	outcomeCounts: Record<"draft" | "in_review" | "finalized", number>;
+} {
+	if (!isRecord(value)) {
+		return false;
+	}
+	const teamName = value.teamName;
+	const members = value.members;
+	const taskCounts = value.taskCounts;
+	const outcomeCounts = value.outcomeCounts;
+	return (
+		typeof teamName === "string" &&
+		Array.isArray(members) &&
+		isRecord(taskCounts) &&
+		typeof taskCounts.pending === "number" &&
+		typeof taskCounts.in_progress === "number" &&
+		typeof taskCounts.blocked === "number" &&
+		typeof taskCounts.completed === "number" &&
+		typeof value.activeRuns === "number" &&
+		typeof value.queuedRuns === "number" &&
+		isRecord(outcomeCounts) &&
+		typeof outcomeCounts.draft === "number" &&
+		typeof outcomeCounts.in_review === "number" &&
+		typeof outcomeCounts.finalized === "number"
+	);
+}
+
+export function unlinkIfExists(filePath: string | null | undefined): void {
+	if (!filePath) {
+		return;
+	}
+	if (!existsSync(filePath)) {
+		return;
+	}
+	try {
+		unlinkSync(filePath);
+	} catch {
+		// Best-effort cleanup.
+	}
+}
+
+export function readStdinUtf8(): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const chunks: Buffer[] = [];
+		process.stdin.on("data", (chunk: Buffer) =>
+			chunks.push(Buffer.from(chunk)),
+		);
+		process.stdin.on("end", () =>
+			resolve(Buffer.concat(chunks).toString("utf-8")),
+		);
+		process.stdin.on("error", reject);
+	});
+}
+
+export function writeHookJson(value: unknown): void {
+	try {
+		process.stdout.write(JSON.stringify(value));
+	} catch (error) {
+		if (
+			!(
+				error &&
+				typeof error === "object" &&
+				"code" in error &&
+				typeof (error as { code?: unknown }).code === "string" &&
+				(error as { code: string }).code === "EPIPE"
+			)
+		) {
+			throw error;
+		}
+	}
+}
+
+export async function appendHookAudit(event: HookEventPayload): Promise<void> {
+	const line = `${JSON.stringify({
+		ts: new Date().toISOString(),
+		...event,
+	})}\n`;
+	const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+	const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+	ensureHookLogDir(logPath);
+	appendFileSync(logPath, line, "utf-8");
+}
+
+export async function isCliHookPayload(value: unknown): Promise<boolean> {
+	return parseHookEventPayload(value) !== undefined;
+}
+
+export async function parseCliHookPayload(
+	value: unknown,
+): Promise<HookEventPayload | undefined> {
+	return parseHookEventPayload(value);
+}
+
+function isBooleanLikeAutoApproveValue(value: string | undefined): boolean {
+	if (!value) {
+		return false;
+	}
+	const normalized = value.trim().toLowerCase();
+	return normalized === "true" || normalized === "false";
+}
+
+export function normalizeCliArgs(args: string[]): string[] {
+	const normalized: string[] = [];
+	for (let index = 0; index < args.length; index += 1) {
+		const token = args[index];
+		if (token === "--autoapprove" || token === "--auto-approve") {
+			const nextToken = args[index + 1];
+			if (isBooleanLikeAutoApproveValue(nextToken)) {
+				normalized.push("--auto-approve", nextToken);
+				index += 1;
+				continue;
+			}
+			normalized.push("--auto-approve", "true");
+			continue;
+		}
+		if (token.startsWith("--autoapprove=")) {
+			normalized.push(token.replace(/^--autoapprove=/, "--auto-approve="));
+			continue;
+		}
+		if (token === "--thinking") {
+			const nextToken = args[index + 1];
+			if (nextToken !== undefined && !nextToken.startsWith("-")) {
+				normalized.push("--thinking", nextToken);
+				index += 1;
+				continue;
+			}
+			normalized.push("--thinking", "medium");
+			continue;
+		}
+		if (token === "--reasoning-effort") {
+			const nextToken = args[index + 1];
+			// Legacy spelling is normalized to --thinking and intentionally relies
+			// on commanderToParsedArgs for level validation, so invalid values behave
+			// the same as `--thinking <value>` and `--thinking=<value>`.
+			if (nextToken !== undefined && !nextToken.startsWith("-")) {
+				normalized.push("--thinking", nextToken);
+				index += 1;
+				continue;
+			}
+			normalized.push("--thinking", "medium");
+			continue;
+		}
+		if (token.startsWith("--reasoning-effort=")) {
+			normalized.push(token.replace(/^--reasoning-effort=/, "--thinking="));
+			continue;
+		}
+		normalized.push(token);
+	}
+	return normalized;
+}
+
+export const normalizeAutoApproveArgs = normalizeCliArgs;
+
+export function parseArgs(args: string[]): ParsedArgs {
+	const program = createProgram();
+	try {
+		program.parse(normalizeCliArgs(args), { from: "user" });
+	} catch (_: unknown) {
+		// exitOverride throws CommanderError on --help / --version; commander
+		// handles output directly, and we treat the thrown error as a signal
+		// to exit gracefully in the caller.
+	}
+	return commanderToParsedArgs(program);
+}
+
+export function resolveSandboxDataDir(
+	cwd: string,
+	explicitDir?: string,
+): string {
+	const envDir = process.env.CLINE_SANDBOX_DATA_DIR?.trim();
+	const baseDir =
+		explicitDir?.trim() || envDir || join(tmpdir(), "cline-sandbox");
+	return resolve(cwd, baseDir);
+}
+
+export function configureSandboxEnvironment(options: {
+	enabled: boolean;
+	cwd: string;
+	explicitDir?: string;
+}): string | undefined {
+	if (!options.enabled) {
+		return undefined;
+	}
+	const dataDir = resolveSandboxDataDir(options.cwd, options.explicitDir);
+	process.env.CLINE_SANDBOX = "1";
+	process.env.CLINE_SANDBOX_DATA_DIR = dataDir;
+	process.env.CLINE_DATA_DIR = dataDir;
+	process.env.CLINE_DB_DATA_DIR = join(dataDir, "db");
+	process.env.CLINE_SESSION_DATA_DIR = join(dataDir, "sessions");
+	process.env.CLINE_TEAM_DATA_DIR = join(dataDir, "teams");
+	process.env.CLINE_PROVIDER_SETTINGS_PATH = join(
+		dataDir,
+		"settings",
+		"providers.json",
+	);
+	process.env.CLINE_HOOKS_LOG_PATH = join(dataDir, "logs", "hooks.jsonl");
+	return dataDir;
+}
diff --git a/apps/cli/src/utils/history-format.ts b/apps/cli/src/utils/history-format.ts
new file mode 100644
index 0000000..c5b68d9
--- /dev/null
+++ b/apps/cli/src/utils/history-format.ts
@@ -0,0 +1,108 @@
+import type { SessionHistoryRecord } from "@cline/core";
+import { formatDisplayUserInput, truncateStr } from "@cline/shared";
+import { formatUsd } from "./output";
+import { shouldShowCliUsageCost } from "./usage-cost-display";
+
+export function formatSessionStatusLabel(
+	status: SessionHistoryRecord["status"] | undefined,
+): string {
+	return status?.trim() || "unknown";
+}
+
+export function mergeHistoryStatusRows(
+	currentRows: SessionHistoryRecord[],
+	refreshedRows: SessionHistoryRecord[],
+): SessionHistoryRecord[] {
+	const currentById = new Map(
+		currentRows.map((row) => [row.sessionId, row] as const),
+	);
+
+	return refreshedRows.map((row) => {
+		const current = currentById.get(row.sessionId);
+		if (!current) {
+			return row;
+		}
+		return {
+			...current,
+			status: row.status,
+			endedAt: row.endedAt,
+			exitCode: row.exitCode,
+			updatedAt: row.updatedAt,
+		};
+	});
+}
+
+function formatHistoryTitle(
+	title: string | undefined,
+	prompt: string | undefined,
+): string | undefined {
+	const rawTitle = title?.trim() || prompt?.trim() || undefined;
+	if (!rawTitle) return;
+	const normalized = formatDisplayUserInput(rawTitle);
+	return truncateStr(normalized.replace(/\s+/g, " "), 40);
+}
+
+export function formatCheckpointBadge(
+	row: SessionHistoryRecord,
+): string | undefined {
+	const checkpoint = row.metadata?.checkpoint;
+	const count = checkpoint?.history?.length ?? 0;
+	const latestRun = checkpoint?.latest?.runCount;
+	if (count <= 0) {
+		return undefined;
+	}
+	if (typeof latestRun === "number" && Number.isFinite(latestRun)) {
+		return `CP ${count} R${latestRun}`;
+	}
+	return `CP ${count}`;
+}
+
+export function formatCheckpointDetail(
+	row: SessionHistoryRecord,
+): string | undefined {
+	const checkpoint = row.metadata?.checkpoint;
+	const count = checkpoint?.history?.length ?? 0;
+	const latest = checkpoint?.latest;
+	if (count <= 0 || !latest?.ref) {
+		return undefined;
+	}
+	const shortRef = truncateStr(latest.ref, 12);
+	const created =
+		typeof latest.createdAt === "number" && Number.isFinite(latest.createdAt)
+			? formatUtcDate(new Date(latest.createdAt))
+			: "unknown";
+	const latestRun =
+		typeof latest.runCount === "number" && Number.isFinite(latest.runCount)
+			? ` run ${latest.runCount}`
+			: "";
+	return `Checkpoint ${shortRef}${latestRun} created ${created}. ${count} total. Restore with: cline checkpoint restore latest --session-id ${row.sessionId}`;
+}
+
+function formatUtcDate(date: Date): string {
+	const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+	const day = String(date.getUTCDate()).padStart(2, "0");
+	const year = date.getUTCFullYear();
+	const hour = String(date.getUTCHours()).padStart(2, "0");
+	const minute = String(date.getUTCMinutes()).padStart(2, "0");
+	return `${month}/${day}/${year} ${hour}:${minute}`;
+}
+
+export function formatHistoryListLine(row: SessionHistoryRecord): string {
+	const title = formatHistoryTitle(row.metadata?.title, row.prompt);
+	if (!title) return "";
+	const cost = shouldShowCliUsageCost(row.provider)
+		? formatUsd(row.metadata?.totalCost ?? 0, 2)
+		: undefined;
+	const provider = truncateStr(row.provider?.trim() || "unknown", 20);
+	const model = truncateStr(row.model?.trim() || "", 28);
+
+	const checkpointCreatedAt = row.metadata?.checkpoint?.latest?.createdAt;
+	const timestamp =
+		typeof checkpointCreatedAt === "number" &&
+		Number.isFinite(checkpointCreatedAt)
+			? checkpointCreatedAt
+			: new Date(row.startedAt).getTime();
+	const date = formatUtcDate(new Date(timestamp));
+	const costSegment = cost ? ` | ${cost}` : "";
+	return `${date} ${provider}:${model} [${formatSessionStatusLabel(row.status)}]${costSegment} | ${title}`;
+}
diff --git a/apps/cli/src/utils/history-resume.test.ts b/apps/cli/src/utils/history-resume.test.ts
new file mode 100644
index 0000000..402cc91
--- /dev/null
+++ b/apps/cli/src/utils/history-resume.test.ts
@@ -0,0 +1,99 @@
+import { describe, expect, it } from "vitest";
+import { buildHistoryResumeArgs } from "./history-resume";
+
+describe("buildHistoryResumeArgs", () => {
+	it("replaces the history subcommand with --id", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["history"],
+				remainingArgs: ["history"],
+			}),
+		).toEqual(["--id", "sess_1"]);
+	});
+
+	it("preserves global flags that precede the subcommand", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: [
+					"--data-dir",
+					"/tmp/data",
+					"-m",
+					"claude-sonnet-4-6",
+					"history",
+					"--limit",
+					"5",
+				],
+				remainingArgs: ["history", "--limit", "5"],
+			}),
+		).toEqual([
+			"--data-dir",
+			"/tmp/data",
+			"-m",
+			"claude-sonnet-4-6",
+			"--id",
+			"sess_1",
+		]);
+	});
+
+	it("keeps a global flag value that matches the subcommand alias", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["-m", "h", "h"],
+				remainingArgs: ["h"],
+			}),
+		).toEqual(["-m", "h", "--id", "sess_1"]);
+	});
+
+	it("forwards a config dir passed as a subcommand option", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["history", "--config", "/tmp/conf"],
+				remainingArgs: ["history", "--config", "/tmp/conf"],
+				configDir: "/tmp/conf",
+			}),
+		).toEqual(["--config", "/tmp/conf", "--id", "sess_1"]);
+	});
+
+	it("does not duplicate a config dir already in the global flags", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["--config", "/tmp/conf", "history"],
+				remainingArgs: ["history"],
+				configDir: "/tmp/conf",
+			}),
+		).toEqual(["--config", "/tmp/conf", "--id", "sess_1"]);
+	});
+
+	it("recognizes the --config=<dir> spelling in global flags", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["--config=/tmp/conf", "history"],
+				remainingArgs: ["history"],
+				configDir: "/tmp/conf",
+			}),
+		).toEqual(["--config=/tmp/conf", "--id", "sess_1"]);
+	});
+
+	it("returns undefined when remaining args are not a suffix of argv", () => {
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["history", "--limit", "5"],
+				remainingArgs: ["history", "--limit", "9"],
+			}),
+		).toBeUndefined();
+		expect(
+			buildHistoryResumeArgs({
+				sessionId: "sess_1",
+				normalizedArgs: ["history"],
+				remainingArgs: ["extra", "history"],
+			}),
+		).toBeUndefined();
+	});
+});
diff --git a/apps/cli/src/utils/history-resume.ts b/apps/cli/src/utils/history-resume.ts
new file mode 100644
index 0000000..0881949
--- /dev/null
+++ b/apps/cli/src/utils/history-resume.ts
@@ -0,0 +1,115 @@
+import { resolveCliLaunchSpec } from "./internal-launch";
+
+export interface HistoryResumeCommand {
+	launcher: string;
+	childArgs: string[];
+}
+
+export interface BuildHistoryResumeArgsInput {
+	sessionId: string;
+	/** Full normalized CLI args (process.argv.slice(2) after normalization). */
+	normalizedArgs: string[];
+	/**
+	 * Commander's `program.args` after parsing: the `history` subcommand token
+	 * and everything following it. Must be a suffix of `normalizedArgs`.
+	 */
+	remainingArgs: string[];
+	/**
+	 * Config dir resolved from the full argv. Forwarded explicitly because
+	 * `--config` may have been passed as a `history` subcommand option, which
+	 * would otherwise be dropped with the rest of the subcommand args.
+	 */
+	configDir?: string;
+}
+
+/**
+ * Builds argv for relaunching the CLI as `cline <globalFlags> --id <sessionId>`
+ * after a session is picked in `cline history`. Returns undefined when the
+ * global-flag prefix cannot be derived safely (caller falls back to resuming
+ * in-process).
+ */
+export function buildHistoryResumeArgs(
+	input: BuildHistoryResumeArgsInput,
+): string[] | undefined {
+	const { sessionId, normalizedArgs, remainingArgs, configDir } = input;
+	const splitIndex = normalizedArgs.length - remainingArgs.length;
+	if (splitIndex < 0) {
+		return undefined;
+	}
+	for (let i = 0; i < remainingArgs.length; i++) {
+		if (normalizedArgs[splitIndex + i] !== remainingArgs[i]) {
+			return undefined;
+		}
+	}
+	const globalArgs = normalizedArgs.slice(0, splitIndex);
+	const args = [...globalArgs];
+	const hasConfigFlag = globalArgs.some(
+		(arg) => arg === "--config" || arg.startsWith("--config="),
+	);
+	if (configDir && !hasConfigFlag) {
+		args.push("--config", configDir);
+	}
+	args.push("--id", sessionId);
+	return args;
+}
+
+export function buildHistoryResumeCommand(
+	input: BuildHistoryResumeArgsInput,
+): HistoryResumeCommand | undefined {
+	const childArgs = buildHistoryResumeArgs(input);
+	if (!childArgs) {
+		return undefined;
+	}
+	const spec = resolveCliLaunchSpec();
+	if (!spec) {
+		return undefined;
+	}
+	return {
+		launcher: spec.launcher,
+		childArgs: [...spec.childArgsPrefix, ...childArgs],
+	};
+}
+
+/**
+ * Resumes a history-picked session in a fresh `cline --id <sessionId>` child
+ * process with inherited stdio, and returns its exit code. Creating a second
+ * OpenTUI renderer in the picker's process can crash natively during teardown
+ * (Bun "panic(main thread): Segmentation fault" on Ctrl+C), so the resumed
+ * interactive TUI must get a process of its own.
+ *
+ * Returns undefined when the child cannot be launched; the caller should fall
+ * back to resuming in-process.
+ */
+export async function spawnHistoryResume(
+	input: BuildHistoryResumeArgsInput,
+): Promise<number | undefined> {
+	const command = buildHistoryResumeCommand(input);
+	if (!command) {
+		return undefined;
+	}
+	const { spawn } = await import("node:child_process");
+	return await new Promise<number | undefined>((resolve) => {
+		let child: ReturnType<typeof spawn>;
+		try {
+			child = spawn(command.launcher, command.childArgs, {
+				stdio: "inherit",
+			});
+		} catch {
+			resolve(undefined);
+			return;
+		}
+		// The child shares this foreground process group, so terminal-generated
+		// Ctrl+C already reaches it. Keep the parent alive to reap the child
+		// without re-forwarding a second signal into the TUI teardown path.
+		const suppressParentSignal = () => {};
+		process.on("SIGINT", suppressParentSignal);
+		process.on("SIGTERM", suppressParentSignal);
+		const finish = (value: number | undefined) => {
+			process.off("SIGINT", suppressParentSignal);
+			process.off("SIGTERM", suppressParentSignal);
+			resolve(value);
+		};
+		child.once("error", () => finish(undefined));
+		child.once("exit", (code, signal) => finish(signal ? 1 : (code ?? 0)));
+	});
+}
diff --git a/apps/cli/src/utils/hooks.test.ts b/apps/cli/src/utils/hooks.test.ts
new file mode 100644
index 0000000..e7156b9
--- /dev/null
+++ b/apps/cli/src/utils/hooks.test.ts
@@ -0,0 +1,235 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const outputMocks = vi.hoisted(() => ({
+	write: vi.fn(),
+	writeErr: vi.fn(),
+	emitJsonLine: vi.fn(),
+	getCurrentOutputMode: vi.fn(() => "text"),
+	getActiveCliSession: vi.fn(() => undefined),
+}));
+
+vi.mock("./output", () => ({
+	c: {
+		reset: "",
+		dim: "",
+		cyan: "",
+	},
+	emitJsonLine: outputMocks.emitJsonLine,
+	getActiveCliSession: outputMocks.getActiveCliSession,
+	getCurrentOutputMode: outputMocks.getCurrentOutputMode,
+	write: outputMocks.write,
+	writeErr: outputMocks.writeErr,
+}));
+
+const eventMocks = vi.hoisted(() => ({
+	closeInlineStreamIfNeeded: vi.fn(),
+}));
+
+vi.mock("./events", () => ({
+	closeInlineStreamIfNeeded: eventMocks.closeInlineStreamIfNeeded,
+}));
+
+import { createRuntimeHooks } from "./hooks";
+
+async function emitRunStartAndPrompt(
+	hooks: NonNullable<ReturnType<typeof createRuntimeHooks>["hooks"]>,
+): Promise<void> {
+	const snapshot = {
+		agentId: "agent-1",
+		conversationId: "conversation-1",
+		runId: "run-1",
+		parentAgentId: null,
+		status: "running" as const,
+		iteration: 0,
+		messages: [],
+		pendingToolCalls: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+		},
+	};
+	await hooks.beforeRun?.({ snapshot });
+	await hooks.onEvent?.({
+		type: "message-added",
+		snapshot,
+		message: {
+			id: "msg-1",
+			role: "user",
+			content: [{ type: "text", text: "hello" }],
+			createdAt: 0,
+		},
+	});
+}
+
+async function emitToolResult(
+	hooks: NonNullable<ReturnType<typeof createRuntimeHooks>["hooks"]>,
+): Promise<void> {
+	await hooks.afterTool?.({
+		snapshot: {
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			runId: "run-1",
+			parentAgentId: null,
+			status: "running",
+			iteration: 1,
+			messages: [],
+			pendingToolCalls: [],
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+			},
+		},
+		tool: {
+			name: "read_file",
+			description: "",
+			inputSchema: {},
+			execute: async () => "ok",
+		},
+		toolCall: {
+			type: "tool-call",
+			toolCallId: "call-1",
+			toolName: "read_file",
+			input: { path: "README.md" },
+		},
+		input: { path: "README.md" },
+		result: { output: "ok" },
+		startedAt: new Date("2026-01-01T00:00:00.000Z"),
+		endedAt: new Date("2026-01-01T00:00:00.042Z"),
+		durationMs: 42,
+	});
+}
+
+describe("createRuntimeHooks", () => {
+	beforeEach(() => {
+		outputMocks.write.mockReset();
+		outputMocks.writeErr.mockReset();
+		outputMocks.emitJsonLine.mockReset();
+		outputMocks.getCurrentOutputMode.mockReset();
+		outputMocks.getCurrentOutputMode.mockReturnValue("text");
+		outputMocks.getActiveCliSession.mockReset();
+		outputMocks.getActiveCliSession.mockReturnValue(undefined);
+		eventMocks.closeInlineStreamIfNeeded.mockReset();
+	});
+
+	it("disables runtime hooks in yolo mode", async () => {
+		const runtimeHooks = createRuntimeHooks({
+			yolo: true,
+			dispatchHookEvent: vi.fn(),
+		});
+
+		expect(runtimeHooks.hooks).toBeUndefined();
+		await expect(runtimeHooks.shutdown()).resolves.toBeUndefined();
+	});
+
+	it("returns in-process hooks when dispatch is available", async () => {
+		const dispatchHookEvent = vi.fn().mockResolvedValue(undefined);
+		const runtimeHooks = createRuntimeHooks({
+			yolo: false,
+			cwd: "/workspace",
+			workspaceRoot: "/workspace",
+			dispatchHookEvent,
+		});
+
+		expect(runtimeHooks.hooks).toBeDefined();
+		await emitRunStartAndPrompt(runtimeHooks.hooks!);
+
+		expect(dispatchHookEvent).toHaveBeenCalledTimes(2);
+		expect(dispatchHookEvent).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({
+				hookName: "agent_start",
+				taskId: "conversation-1",
+				workspaceRoots: ["/workspace"],
+			}),
+		);
+		expect(dispatchHookEvent).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				hookName: "prompt_submit",
+				taskId: "conversation-1",
+				workspaceRoots: ["/workspace"],
+			}),
+		);
+	});
+
+	it("forwards runtime tool timing to tool_result hook payloads", async () => {
+		const dispatchHookEvent = vi.fn().mockResolvedValue(undefined);
+		const runtimeHooks = createRuntimeHooks({
+			yolo: false,
+			cwd: "/workspace",
+			workspaceRoot: "/workspace",
+			dispatchHookEvent,
+		});
+
+		await emitToolResult(runtimeHooks.hooks!);
+
+		expect(dispatchHookEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				hookName: "tool_result",
+				tool_result: expect.objectContaining({
+					durationMs: 42,
+					startedAt: new Date("2026-01-01T00:00:00.000Z"),
+					endedAt: new Date("2026-01-01T00:00:00.042Z"),
+				}),
+				postToolUse: expect.objectContaining({
+					executionTimeMs: 42,
+				}),
+			}),
+		);
+	});
+
+	it("suppresses text hook output when verbose is disabled", async () => {
+		const dispatchHookEvent = vi.fn().mockResolvedValue(undefined);
+		const runtimeHooks = createRuntimeHooks({
+			yolo: false,
+			cwd: "/workspace",
+			workspaceRoot: "/workspace",
+			verbose: false,
+			dispatchHookEvent,
+		});
+
+		await emitRunStartAndPrompt(runtimeHooks.hooks!);
+
+		expect(dispatchHookEvent).toHaveBeenCalledTimes(2);
+		expect(outputMocks.write).not.toHaveBeenCalled();
+		expect(eventMocks.closeInlineStreamIfNeeded).not.toHaveBeenCalled();
+	});
+
+	it("prints text hook output when verbose is enabled", async () => {
+		const dispatchHookEvent = vi.fn().mockResolvedValue(undefined);
+		const runtimeHooks = createRuntimeHooks({
+			yolo: false,
+			cwd: "/workspace",
+			workspaceRoot: "/workspace",
+			verbose: true,
+			dispatchHookEvent,
+		});
+
+		await emitRunStartAndPrompt(runtimeHooks.hooks!);
+
+		expect(outputMocks.write).toHaveBeenCalledWith("\n[hook:agent_start]\n");
+		expect(outputMocks.write).toHaveBeenCalledWith("\n[hook:prompt_submit]\n");
+		expect(eventMocks.closeInlineStreamIfNeeded).toHaveBeenCalledTimes(2);
+	});
+
+	it("does not dispatch hooks after shutdown", async () => {
+		const dispatchHookEvent = vi.fn().mockResolvedValue(undefined);
+		const runtimeHooks = createRuntimeHooks({
+			yolo: false,
+			cwd: "/workspace",
+			workspaceRoot: "/workspace",
+			verbose: true,
+			dispatchHookEvent,
+		});
+
+		await runtimeHooks.shutdown();
+		await emitRunStartAndPrompt(runtimeHooks.hooks!);
+
+		expect(dispatchHookEvent).not.toHaveBeenCalled();
+		expect(outputMocks.write).not.toHaveBeenCalled();
+	});
+});
diff --git a/apps/cli/src/utils/hooks.ts b/apps/cli/src/utils/hooks.ts
new file mode 100644
index 0000000..f60d057
--- /dev/null
+++ b/apps/cli/src/utils/hooks.ts
@@ -0,0 +1,358 @@
+import type { AgentHooks, HookEventPayload } from "@cline/core";
+import { closeInlineStreamIfNeeded } from "./events";
+import {
+	c,
+	emitJsonLine,
+	getActiveCliSession,
+	getCurrentOutputMode,
+	write,
+	writeErr,
+} from "./output";
+
+const isDev = process.env.NODE_ENV === "development";
+
+function currentHookSessionContext(): { rootSessionId: string } | undefined {
+	const session = getActiveCliSession();
+	if (!session) {
+		return undefined;
+	}
+	return {
+		rootSessionId: session.manifest.session_id,
+	};
+}
+
+function writeHookInvocation(
+	payload: HookEventPayload,
+	options: { verbose: boolean },
+): void {
+	if (getCurrentOutputMode() === "json") {
+		emitJsonLine("stdout", {
+			type: "hook_event",
+			hookEventName: payload.hookName,
+			agentId: payload.agent_id,
+			taskId: payload.taskId,
+			parentAgentId: payload.parent_agent_id,
+		});
+		return;
+	}
+	if (!options.verbose) {
+		return;
+	}
+	closeInlineStreamIfNeeded();
+	const hookName = payload.hookName;
+	const toolName =
+		payload.hookName === "tool_call"
+			? payload.tool_call.name
+			: payload.hookName === "tool_result"
+				? payload.tool_result.name
+				: undefined;
+	const details = toolName ? ` ${c.cyan}${toolName}${c.reset}` : "";
+	if (details) {
+		write(`\n${c.dim}[hook:${hookName}]${c.reset}${details}\n`);
+		return;
+	}
+	write(`\n${c.dim}[hook:${hookName}]${c.reset}\n`);
+}
+
+type HookRuntimeBaseContext = {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+};
+
+function mapParams(input: unknown): Record<string, string> {
+	if (!input || typeof input !== "object") {
+		return {};
+	}
+	const output: Record<string, string> = {};
+	for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+		output[key] = typeof value === "string" ? value : JSON.stringify(value);
+	}
+	return output;
+}
+
+function baseContextFromSnapshot(snapshot: {
+	agentId: string;
+	conversationId?: string;
+	runId?: string;
+	parentAgentId?: string | null;
+}): HookRuntimeBaseContext {
+	return {
+		agentId: snapshot.agentId,
+		conversationId:
+			snapshot.conversationId ?? snapshot.runId ?? snapshot.agentId,
+		parentAgentId: snapshot.parentAgentId ?? null,
+	};
+}
+
+function textFromMessageContent(
+	content: readonly { type: string; text?: string }[],
+): string {
+	return content
+		.filter((part) => part.type === "text" && typeof part.text === "string")
+		.map((part) => part.text)
+		.join("");
+}
+
+function isAbortReason(reason?: string): boolean {
+	const value = String(reason ?? "").toLowerCase();
+	return (
+		value.includes("cancel") ||
+		value.includes("abort") ||
+		value.includes("interrupt")
+	);
+}
+
+function serializeHookError(error: Error): {
+	name: string;
+	message: string;
+	stack?: string;
+} {
+	return {
+		name: error.name,
+		message: error.message,
+		stack: error.stack,
+	};
+}
+
+function basePayload(
+	ctx: HookRuntimeBaseContext,
+	options: { cwd: string; workspaceRoot: string },
+): Omit<HookEventPayload, "hookName"> {
+	const userId =
+		process.env.CLINE_USER_ID?.trim() || process.env.USER?.trim() || "unknown";
+	const sessionContext = currentHookSessionContext();
+	return {
+		clineVersion: process.env.CLINE_VERSION?.trim() || "",
+		timestamp: new Date().toISOString(),
+		taskId: ctx.conversationId,
+		...(sessionContext ? { sessionContext } : {}),
+		workspaceRoots: [options.workspaceRoot || options.cwd].filter(Boolean),
+		userId,
+		agent_id: ctx.agentId,
+		parent_agent_id: ctx.parentAgentId,
+	};
+}
+
+async function dispatchHookPayload(
+	payload: HookEventPayload,
+	options: {
+		dispatchHookEvent: (payload: HookEventPayload) => Promise<void>;
+		isShuttingDown: () => boolean;
+		verbose: boolean;
+	},
+): Promise<void> {
+	if (options.isShuttingDown()) {
+		return;
+	}
+	try {
+		await options.dispatchHookEvent(payload);
+		if (options.isShuttingDown()) {
+			return;
+		}
+		writeHookInvocation(payload, { verbose: options.verbose });
+	} catch (error) {
+		if (options.isShuttingDown()) {
+			return;
+		}
+		if (isDev) {
+			writeErr(
+				`hook dispatch failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+}
+
+export function createRuntimeHooks(options: {
+	verbose?: boolean;
+	yolo?: boolean;
+	cwd?: string;
+	workspaceRoot?: string;
+	dispatchHookEvent: (payload: HookEventPayload) => Promise<void>;
+}): {
+	hooks?: AgentHooks;
+	shutdown: () => Promise<void>;
+} {
+	if (options.yolo === true) {
+		return {
+			hooks: undefined,
+			shutdown: async () => {},
+		};
+	}
+	const verbose = options.verbose === true;
+	const cwd = options.cwd?.trim() || process.cwd();
+	const workspaceRoot = options.workspaceRoot?.trim() || cwd;
+	let shuttingDown = false;
+	const isShuttingDown = () => shuttingDown;
+	return {
+		hooks: {
+			beforeRun: async (ctx) => {
+				const root = basePayload(baseContextFromSnapshot(ctx.snapshot), {
+					cwd,
+					workspaceRoot,
+				});
+				const isResume = process.env.CLINE_HOOK_AGENT_RESUME === "1";
+				await dispatchHookPayload(
+					isResume
+						? {
+								...root,
+								hookName: "agent_resume",
+								taskResume: {
+									taskMetadata: {},
+									previousState: {},
+								},
+							}
+						: {
+								...root,
+								hookName: "agent_start",
+								taskStart: { taskMetadata: {} },
+							},
+					{
+						dispatchHookEvent: options.dispatchHookEvent,
+						isShuttingDown,
+						verbose,
+					},
+				);
+				return undefined;
+			},
+			beforeTool: async (ctx) => {
+				await dispatchHookPayload(
+					{
+						...basePayload(baseContextFromSnapshot(ctx.snapshot), {
+							cwd,
+							workspaceRoot,
+						}),
+						hookName: "tool_call",
+						iteration: ctx.snapshot.iteration,
+						tool_call: {
+							id: ctx.toolCall.toolCallId,
+							name: ctx.toolCall.toolName,
+							input: ctx.input,
+						},
+						preToolUse: {
+							toolName: ctx.toolCall.toolName,
+							parameters: mapParams(ctx.input),
+						},
+					},
+					{
+						dispatchHookEvent: options.dispatchHookEvent,
+						isShuttingDown,
+						verbose,
+					},
+				);
+				return undefined;
+			},
+			afterTool: async (ctx) => {
+				const record = {
+					id: ctx.toolCall.toolCallId,
+					name: ctx.toolCall.toolName,
+					input: ctx.input,
+					output: ctx.result.output,
+					error: ctx.result.isError ? String(ctx.result.output) : undefined,
+					durationMs: ctx.durationMs,
+					startedAt: ctx.startedAt,
+					endedAt: ctx.endedAt,
+				};
+				await dispatchHookPayload(
+					{
+						...basePayload(baseContextFromSnapshot(ctx.snapshot), {
+							cwd,
+							workspaceRoot,
+						}),
+						hookName: "tool_result",
+						iteration: ctx.snapshot.iteration,
+						tool_result: record,
+						postToolUse: {
+							toolName: record.name,
+							parameters: mapParams(record.input),
+							result:
+								typeof record.output === "string"
+									? record.output
+									: JSON.stringify(record.output),
+							success: !record.error,
+							executionTimeMs: record.durationMs,
+						},
+					},
+					{
+						dispatchHookEvent: options.dispatchHookEvent,
+						isShuttingDown,
+						verbose,
+					},
+				);
+				return undefined;
+			},
+			afterRun: async ({ snapshot, result }) => {
+				const base = baseContextFromSnapshot(snapshot);
+				if (result.status === "completed") {
+					await dispatchHookPayload(
+						{
+							...basePayload(base, { cwd, workspaceRoot }),
+							hookName: "agent_end",
+							iteration: result.iterations,
+							turn: { outputText: result.outputText, status: result.status },
+							taskComplete: { taskMetadata: {} },
+						},
+						{
+							dispatchHookEvent: options.dispatchHookEvent,
+							isShuttingDown,
+							verbose,
+						},
+					);
+					return;
+				}
+				const hookName = isAbortReason(result.error?.message)
+					? "agent_abort"
+					: "agent_error";
+				await dispatchHookPayload(
+					hookName === "agent_abort"
+						? {
+								...basePayload(base, { cwd, workspaceRoot }),
+								hookName,
+								reason: result.error?.message,
+								taskCancel: { taskMetadata: {} },
+							}
+						: {
+								...basePayload(base, { cwd, workspaceRoot }),
+								hookName,
+								iteration: result.iterations,
+								error: serializeHookError(
+									result.error ?? new Error("Agent run failed"),
+								),
+								taskCancel: { taskMetadata: {} },
+							},
+					{
+						dispatchHookEvent: options.dispatchHookEvent,
+						isShuttingDown,
+						verbose,
+					},
+				);
+			},
+			onEvent: async (event) => {
+				if (event.type !== "message-added" || event.message.role !== "user") {
+					return;
+				}
+				await dispatchHookPayload(
+					{
+						...basePayload(baseContextFromSnapshot(event.snapshot), {
+							cwd,
+							workspaceRoot,
+						}),
+						hookName: "prompt_submit",
+						userPromptSubmit: {
+							prompt: textFromMessageContent(event.message.content),
+							attachments: [],
+						},
+					},
+					{
+						dispatchHookEvent: options.dispatchHookEvent,
+						isShuttingDown,
+						verbose,
+					},
+				);
+			},
+		},
+		shutdown: async () => {
+			shuttingDown = true;
+		},
+	};
+}
diff --git a/apps/cli/src/utils/hub-runtime.ts b/apps/cli/src/utils/hub-runtime.ts
new file mode 100644
index 0000000..c50af8f
--- /dev/null
+++ b/apps/cli/src/utils/hub-runtime.ts
@@ -0,0 +1,47 @@
+import {
+	type DetachedHubResolution,
+	ensureDetachedHubServer,
+	type HubEndpointOverrides,
+	resolveDefaultHubHost,
+	resolveDefaultHubPort,
+} from "@cline/core";
+
+/**
+ * Build a `host:port` rpc address string that respects the current build
+ * environment. In development, this picks the dev hub port to avoid
+ * colliding with a production Cline hub on the standard port.
+ */
+export function resolveDefaultCliRpcAddress(): string {
+	return `${resolveDefaultHubHost()}:${resolveDefaultHubPort()}`;
+}
+
+export function parseHubEndpointOverride(
+	rawAddress: string | undefined,
+): HubEndpointOverrides {
+	const trimmed = rawAddress?.trim();
+	if (!trimmed) {
+		return {};
+	}
+	try {
+		const parsed = new URL(
+			trimmed.includes("://") ? trimmed : `ws://${trimmed}`,
+		);
+		return {
+			host: parsed.hostname || undefined,
+			port: parsed.port ? Number(parsed.port) : undefined,
+			pathname:
+				parsed.pathname && parsed.pathname !== "/"
+					? parsed.pathname
+					: undefined,
+		};
+	} catch {
+		return {};
+	}
+}
+
+export async function ensureCliHubServer(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides = {},
+): Promise<DetachedHubResolution> {
+	return await ensureDetachedHubServer(workspaceRoot, endpoint);
+}
diff --git a/apps/cli/src/utils/image-attachments.ts b/apps/cli/src/utils/image-attachments.ts
new file mode 100644
index 0000000..6531311
--- /dev/null
+++ b/apps/cli/src/utils/image-attachments.ts
@@ -0,0 +1,58 @@
+import { readFileSync } from "node:fs";
+import { resolveExistingFilePath } from "@cline/shared/storage";
+
+const IMAGE_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".bmp",
+	".svg",
+]);
+
+/**
+ * Resolve a possibly-mangled image path to an actual on-disk file.
+ */
+export function resolveExistingImagePath(filePath: string): string | undefined {
+	return resolveExistingFilePath(filePath);
+}
+
+export function isImagePath(filePath: string): boolean {
+	const normalized = filePath.toLowerCase();
+	for (const extension of IMAGE_EXTENSIONS) {
+		if (normalized.endsWith(extension)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function getImageMimeType(filePath: string): string {
+	const ext = filePath.toLowerCase().split(".").pop() || "";
+	const mimeTypes: Record<string, string> = {
+		png: "image/png",
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		gif: "image/gif",
+		webp: "image/webp",
+		bmp: "image/bmp",
+		svg: "image/svg+xml",
+	};
+	return mimeTypes[ext] || "image/png";
+}
+
+export function bufferToImageDataUrl(buffer: Buffer, mimeType: string): string {
+	return `data:${mimeType};base64,${buffer.toString("base64")}`;
+}
+
+export function loadImageAsDataUrl(filePath: string): string {
+	try {
+		const buffer = readFileSync(filePath);
+		return bufferToImageDataUrl(buffer, getImageMimeType(filePath));
+	} catch (error) {
+		throw new Error(
+			`Failed to load image from ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+}
diff --git a/apps/cli/src/utils/input-history.test.ts b/apps/cli/src/utils/input-history.test.ts
new file mode 100644
index 0000000..570814c
--- /dev/null
+++ b/apps/cli/src/utils/input-history.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { prependInputHistoryEntry } from "./input-history";
+
+describe("input history entries", () => {
+	it("prepends new prompts for most-recent-first navigation", () => {
+		expect(prependInputHistoryEntry(["second", "first"], "third")).toEqual([
+			"third",
+			"second",
+			"first",
+		]);
+	});
+
+	it("moves duplicate prompts to the front", () => {
+		expect(prependInputHistoryEntry(["second", "first"], "first")).toEqual([
+			"first",
+			"second",
+		]);
+	});
+
+	it("trims whitespace-only prompts", () => {
+		expect(prependInputHistoryEntry(["second"], "   ")).toEqual(["second"]);
+	});
+
+	it("caps entries at the requested maximum", () => {
+		expect(prependInputHistoryEntry(["two", "one"], "three", 2)).toEqual([
+			"three",
+			"two",
+		]);
+	});
+});
diff --git a/apps/cli/src/utils/input-history.ts b/apps/cli/src/utils/input-history.ts
new file mode 100644
index 0000000..0c78e1a
--- /dev/null
+++ b/apps/cli/src/utils/input-history.ts
@@ -0,0 +1,72 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveClineDataDir } from "@cline/shared/storage";
+
+const MAX_HISTORY = 20;
+
+function resolveHistoryPath(): string {
+	return join(resolveClineDataDir(), "cache", "user_input_history.jsonl");
+}
+
+function readEntries(path: string): string[] {
+	if (!existsSync(path)) return [];
+	try {
+		const entries: string[] = [];
+		for (const line of readFileSync(path, "utf8").split("\n")) {
+			if (!line.trim()) continue;
+			try {
+				const parsed = JSON.parse(line) as { prompt?: unknown };
+				if (typeof parsed.prompt === "string" && parsed.prompt.trim()) {
+					entries.push(parsed.prompt);
+				}
+			} catch {
+				// skip malformed lines
+			}
+		}
+		return entries;
+	} catch {
+		return [];
+	}
+}
+
+/** Returns up to MAX_HISTORY entries, most-recent-first, for up-arrow navigation. */
+export function loadInputHistory(): string[] {
+	return readEntries(resolveHistoryPath()).slice(-MAX_HISTORY).reverse();
+}
+
+export function prependInputHistoryEntry(
+	history: readonly string[],
+	prompt: string,
+	maxHistory = MAX_HISTORY,
+): string[] {
+	const trimmed = prompt.trim();
+	if (!trimmed) return [...history];
+	return [trimmed, ...history.filter((p) => p !== trimmed)].slice(
+		0,
+		maxHistory,
+	);
+}
+
+/**
+ * Appends a prompt to the history file, removing any previous occurrence of
+ * the same prompt so the list stays unique, then trims to MAX_HISTORY.
+ */
+export function appendInputHistory(prompt: string): void {
+	const trimmed = prompt.trim();
+	if (!trimmed) return;
+	const path = resolveHistoryPath();
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		const next = prependInputHistoryEntry(
+			readEntries(path).reverse(),
+			trimmed,
+		).reverse();
+		writeFileSync(
+			path,
+			`${next.map((p) => JSON.stringify({ prompt: p, ts: Date.now() })).join("\n")}\n`,
+			"utf8",
+		);
+	} catch {
+		// Non-fatal, best effort.
+	}
+}
diff --git a/apps/cli/src/utils/internal-launch.test.ts b/apps/cli/src/utils/internal-launch.test.ts
new file mode 100644
index 0000000..7f298b5
--- /dev/null
+++ b/apps/cli/src/utils/internal-launch.test.ts
@@ -0,0 +1,76 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	buildCliSubcommandCommand,
+	resolveCliLaunchSpec,
+} from "./internal-launch";
+
+describe("internal launch helpers", () => {
+	const originalEnv = { ...process.env };
+
+	afterEach(() => {
+		process.env = { ...originalEnv };
+	});
+
+	it("resolves the source entrypoint when running from TypeScript", () => {
+		const utilsDir = dirname(fileURLToPath(import.meta.url));
+		const repoRoot = resolve(utilsDir, "../../../../");
+		const spec = resolveCliLaunchSpec({
+			execPath: "/Users/test/.bun/bin/bun",
+			argv: ["bun", "./apps/cli/src/index.ts"],
+			execArgv: ["--conditions=development"],
+			cwd: repoRoot,
+			env: {},
+		});
+
+		expect(spec).toEqual({
+			launcher: "/Users/test/.bun/bin/bun",
+			childArgsPrefix: [
+				"--inspect=127.0.0.1:0",
+				"--enable-source-maps",
+				"--conditions=development",
+				resolve(repoRoot, "apps/cli/src/index.ts"),
+			],
+			identityPath: resolve(repoRoot, "apps/cli/src/index.ts"),
+			mode: "source",
+		});
+	});
+
+	it("falls back to launching the compiled binary directly for bunfs argv", () => {
+		const command = buildCliSubcommandCommand("hub", ["start"], {
+			execPath: "/tmp/cline",
+			argv: ["bun", "/$bunfs/root/cline", "hey"],
+			execArgv: [],
+			cwd: "/tmp",
+		});
+
+		expect(command).toEqual({
+			launcher: "/tmp/cline",
+			childArgs: ["hub", "start"],
+		});
+	});
+
+	it("adds node debug flags for development node launches", () => {
+		const utilsDir = dirname(fileURLToPath(import.meta.url));
+		const repoRoot = resolve(utilsDir, "../../../../");
+		const command = buildCliSubcommandCommand("hub", ["start"], {
+			execPath: "/usr/local/bin/node",
+			argv: ["node", "./apps/cli/src/index.ts"],
+			execArgv: [],
+			cwd: repoRoot,
+			env: { CLINE_BUILD_ENV: "development" },
+		});
+
+		expect(command).toEqual({
+			launcher: "/usr/local/bin/node",
+			childArgs: [
+				"--inspect=127.0.0.1:0",
+				"--enable-source-maps",
+				resolve(repoRoot, "apps/cli/src/index.ts"),
+				"hub",
+				"start",
+			],
+		});
+	});
+});
diff --git a/apps/cli/src/utils/internal-launch.ts b/apps/cli/src/utils/internal-launch.ts
new file mode 100644
index 0000000..b89ac63
--- /dev/null
+++ b/apps/cli/src/utils/internal-launch.ts
@@ -0,0 +1,87 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve as resolvePath } from "node:path";
+import { augmentNodeCommandForDebug, type ClineDebugRole } from "@cline/shared";
+
+export interface ResolveCliLaunchSpecOptions {
+	execPath?: string;
+	argv?: string[];
+	execArgv?: string[];
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	debugRole?: ClineDebugRole;
+}
+
+export interface CliLaunchSpec {
+	launcher: string;
+	childArgsPrefix: string[];
+	identityPath: string;
+	mode: "compiled" | "source";
+}
+
+function normalizeEntryArg(
+	entryArg: string | undefined,
+	cwd: string,
+): string | undefined {
+	const trimmed = entryArg?.trim();
+	if (!trimmed || trimmed.startsWith("/$bunfs/")) {
+		return undefined;
+	}
+	return isAbsolute(trimmed) ? trimmed : resolvePath(cwd, trimmed);
+}
+
+export function resolveCliLaunchSpec(
+	options: ResolveCliLaunchSpecOptions = {},
+): CliLaunchSpec | undefined {
+	const execPath = options.execPath?.trim() || process.execPath;
+	const argv = options.argv ?? process.argv;
+	const execArgv = options.execArgv ?? process.execArgv;
+	const cwd = options.cwd ?? process.cwd();
+	const env = options.env ?? process.env;
+	const debugRole = options.debugRole;
+	if (!execPath) {
+		return undefined;
+	}
+
+	const resolvedEntry = normalizeEntryArg(argv[1], cwd);
+	if (resolvedEntry && existsSync(resolvedEntry)) {
+		const conditionsArg = execArgv.find((arg) =>
+			arg.startsWith("--conditions="),
+		);
+		const command = augmentNodeCommandForDebug(
+			[execPath, ...(conditionsArg ? [conditionsArg] : []), resolvedEntry],
+			{ env, execArgv, debugRole },
+		);
+		return {
+			launcher: command[0] ?? execPath,
+			childArgsPrefix: command.slice(1),
+			identityPath: resolvedEntry,
+			mode: "source",
+		};
+	}
+
+	const command = augmentNodeCommandForDebug([execPath], {
+		env,
+		execArgv,
+		debugRole,
+	});
+	return {
+		launcher: command[0] ?? execPath,
+		childArgsPrefix: command.slice(1),
+		identityPath: execPath,
+		mode: "compiled",
+	};
+}
+
+export function buildCliSubcommandCommand(
+	subcommand: string,
+	args: string[] = [],
+	options: ResolveCliLaunchSpecOptions = {},
+): { launcher: string; childArgs: string[] } | undefined {
+	const spec = resolveCliLaunchSpec(options);
+	return spec
+		? {
+				launcher: spec.launcher,
+				childArgs: [...spec.childArgsPrefix, subcommand, ...args],
+			}
+		: undefined;
+}
diff --git a/apps/cli/src/utils/output.test.ts b/apps/cli/src/utils/output.test.ts
new file mode 100644
index 0000000..4e681df
--- /dev/null
+++ b/apps/cli/src/utils/output.test.ts
@@ -0,0 +1,112 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	formatCreditBalance,
+	installStreamErrorGuards,
+	normalizeCreditBalance,
+	prepareTerminalForPostTuiOutput,
+	setCurrentOutputMode,
+} from "./output";
+
+describe("installStreamErrorGuards", () => {
+	const originalExitCode = process.exitCode;
+	const exitSpy = vi.spyOn(process, "exit").mockImplementation(((
+		code?: number,
+	) => {
+		throw new Error(`exit:${code ?? "undefined"}`);
+	}) as typeof process.exit);
+
+	beforeEach(() => {
+		process.exitCode = undefined;
+		exitSpy.mockClear();
+	});
+
+	afterEach(() => {
+		process.exitCode = originalExitCode;
+	});
+
+	it("preserves a failing process exit code on stdout broken pipe", () => {
+		installStreamErrorGuards();
+		process.exitCode = 1;
+
+		expect(() => {
+			process.stdout.emit("error", { code: "EPIPE" });
+		}).toThrow("exit:1");
+
+		expect(exitSpy).toHaveBeenCalledWith(1);
+	});
+
+	it("defaults to a successful exit code when none is set", () => {
+		installStreamErrorGuards();
+
+		expect(() => {
+			process.stderr.emit("error", { code: "EPIPE" });
+		}).toThrow("exit:0");
+
+		expect(exitSpy).toHaveBeenCalledWith(0);
+	});
+});
+
+describe("credit balance formatting", () => {
+	it("normalizes Cline micro-credit balances before display", () => {
+		expect(formatCreditBalance(normalizeCreditBalance(500_000))).toBe("$0.50");
+		expect(formatCreditBalance(normalizeCreditBalance(5_000_000))).toBe(
+			"$5.00",
+		);
+	});
+});
+
+describe("prepareTerminalForPostTuiOutput", () => {
+	const originalStdoutIsTTY = process.stdout.isTTY;
+
+	afterEach(() => {
+		setCurrentOutputMode("text");
+		Object.defineProperty(process.stdout, "isTTY", {
+			configurable: true,
+			value: originalStdoutIsTTY,
+		});
+		vi.restoreAllMocks();
+	});
+
+	it("clears from the restored cursor before printing post-TUI text", () => {
+		const writeSpy = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+		Object.defineProperty(process.stdout, "isTTY", {
+			configurable: true,
+			value: true,
+		});
+
+		prepareTerminalForPostTuiOutput();
+
+		expect(writeSpy).toHaveBeenCalledWith("\r\x1b[J");
+	});
+
+	it("does not write terminal control codes for non-TTY output", () => {
+		const writeSpy = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+		Object.defineProperty(process.stdout, "isTTY", {
+			configurable: true,
+			value: false,
+		});
+
+		prepareTerminalForPostTuiOutput();
+
+		expect(writeSpy).not.toHaveBeenCalled();
+	});
+
+	it("does not write terminal control codes in JSON output mode", () => {
+		const writeSpy = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+		Object.defineProperty(process.stdout, "isTTY", {
+			configurable: true,
+			value: true,
+		});
+		setCurrentOutputMode("json");
+
+		prepareTerminalForPostTuiOutput();
+
+		expect(writeSpy).not.toHaveBeenCalled();
+	});
+});
diff --git a/apps/cli/src/utils/output.ts b/apps/cli/src/utils/output.ts
new file mode 100644
index 0000000..1fc3109
--- /dev/null
+++ b/apps/cli/src/utils/output.ts
@@ -0,0 +1,227 @@
+import { registerDisposable } from "@cline/shared";
+import { nowIso } from "./helpers";
+import type { ActiveCliSession, CliOutputMode } from "./types";
+
+// =============================================================================
+// ANSI Colors (no dependencies for speed)
+// =============================================================================
+
+export const c = {
+	reset: "\x1b[0m",
+	dim: "\x1b[2m",
+	bold: "\x1b[1m",
+	cyan: "\x1b[36m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	red: "\x1b[31m",
+	gray: "\x1b[90m",
+};
+
+// =============================================================================
+// Shared mutable state for output
+// =============================================================================
+
+let currentOutputMode: CliOutputMode = "text";
+let activeCliSession: ActiveCliSession | undefined;
+
+export function setCurrentOutputMode(mode: CliOutputMode): void {
+	currentOutputMode = mode;
+}
+
+export function getCurrentOutputMode(): CliOutputMode {
+	return currentOutputMode;
+}
+
+export function setActiveCliSession(
+	session: ActiveCliSession | undefined,
+): void {
+	activeCliSession = session;
+}
+
+export function getActiveCliSession(): ActiveCliSession | undefined {
+	return activeCliSession;
+}
+
+// =============================================================================
+// Stream error guards
+// =============================================================================
+
+const STDOUT_ERROR_GUARD = Symbol.for("@cline/cli.stdoutErrorGuard");
+const STDERR_ERROR_GUARD = Symbol.for("@cline/cli.stderrErrorGuard");
+
+type GuardedStream = NodeJS.WriteStream & {
+	[STDOUT_ERROR_GUARD]?: (error: unknown) => void;
+	[STDERR_ERROR_GUARD]?: (error: unknown) => void;
+};
+
+function exitForBrokenPipe(): never {
+	process.exit(process.exitCode ?? 0);
+}
+
+export function isBrokenPipeError(error: unknown): boolean {
+	return Boolean(
+		error &&
+			typeof error === "object" &&
+			"code" in error &&
+			typeof (error as { code?: unknown }).code === "string" &&
+			(error as { code: string }).code === "EPIPE",
+	);
+}
+
+export function installStreamErrorGuards(): void {
+	const stdout = process.stdout as GuardedStream;
+	if (!stdout[STDOUT_ERROR_GUARD]) {
+		const onStdoutError = (error: unknown) => {
+			if (isBrokenPipeError(error)) {
+				exitForBrokenPipe();
+			}
+		};
+		stdout[STDOUT_ERROR_GUARD] = onStdoutError;
+		stdout.on("error", onStdoutError);
+		registerDisposable(() => {
+			const guard = stdout[STDOUT_ERROR_GUARD];
+			if (!guard) {
+				return;
+			}
+			stdout.off("error", guard);
+			delete stdout[STDOUT_ERROR_GUARD];
+		});
+	}
+
+	const stderr = process.stderr as GuardedStream;
+	if (!stderr[STDERR_ERROR_GUARD]) {
+		const onStderrError = (error: unknown) => {
+			if (isBrokenPipeError(error)) {
+				exitForBrokenPipe();
+			}
+		};
+		stderr[STDERR_ERROR_GUARD] = onStderrError;
+		stderr.on("error", onStderrError);
+		registerDisposable(() => {
+			const guard = stderr[STDERR_ERROR_GUARD];
+			if (!guard) {
+				return;
+			}
+			stderr.off("error", guard);
+			delete stderr[STDERR_ERROR_GUARD];
+		});
+	}
+}
+
+// =============================================================================
+// CLI Output
+// =============================================================================
+
+function jsonReplacer(_key: string, value: unknown): unknown {
+	if (value instanceof Error) {
+		return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack,
+		};
+	}
+	if (typeof value === "bigint") {
+		return value.toString();
+	}
+	return value;
+}
+
+export function emitJsonLine(
+	stream: "stdout" | "stderr",
+	record: Record<string, unknown>,
+): void {
+	const line = `${JSON.stringify(
+		{
+			ts: nowIso(),
+			...record,
+		},
+		jsonReplacer,
+	)}\n`;
+	try {
+		if (stream === "stdout") {
+			process.stdout.write(line);
+		} else {
+			process.stderr.write(line);
+		}
+	} catch (error) {
+		if (!isBrokenPipeError(error)) {
+			throw error;
+		}
+	}
+}
+
+export function write(text: string): void {
+	try {
+		process.stdout.write(text);
+	} catch (error) {
+		if (!isBrokenPipeError(error)) {
+			throw error;
+		}
+	}
+}
+
+export function writeln(text = ""): void {
+	if (currentOutputMode === "json") {
+		return;
+	}
+	write(`${text}\n`);
+}
+
+export function writeDiagnostic(text: string): void {
+	try {
+		process.stderr.write(`${text}\n`);
+	} catch (error) {
+		if (!isBrokenPipeError(error)) {
+			throw error;
+		}
+	}
+}
+
+export function prepareTerminalForPostTuiOutput(): void {
+	if (currentOutputMode === "json" || !process.stdout.isTTY) {
+		return;
+	}
+	write("\r\x1b[J");
+}
+
+export function writeErr(text: string): void {
+	if (currentOutputMode === "json") {
+		emitJsonLine("stderr", { type: "error", message: text });
+		return;
+	}
+	console.error(`${c.red}error:${c.reset} ${text}`);
+}
+
+// =============================================================================
+// Formatting helpers
+// =============================================================================
+
+export function formatUsd(value: number, fixed = 6): string {
+	if (!Number.isFinite(value) || value <= 0) {
+		return "$0.00";
+	}
+	if (value >= 1) {
+		return `$${value.toFixed(fixed)}`;
+	}
+	if (value >= 0.01) {
+		return `$${value.toFixed(fixed)}`;
+	}
+	return `$${value.toFixed(fixed)}`;
+}
+
+export function formatCreditBalance(value: number, decimalPlaces = 2): string {
+	if (!Number.isFinite(value)) {
+		return "$0.00";
+	}
+	return `$${value.toLocaleString("en-US", {
+		minimumFractionDigits: decimalPlaces,
+		maximumFractionDigits: decimalPlaces,
+	})}`;
+}
+
+export function normalizeCreditBalance(value: number): number {
+	if (!Number.isFinite(value)) {
+		return 0;
+	}
+	return value / 1_000_000;
+}
diff --git a/apps/cli/src/utils/plugin-chat-commands.test.ts b/apps/cli/src/utils/plugin-chat-commands.test.ts
new file mode 100644
index 0000000..48ba1ea
--- /dev/null
+++ b/apps/cli/src/utils/plugin-chat-commands.test.ts
@@ -0,0 +1,119 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createWorkspaceChatCommandHost } from "./plugin-chat-commands";
+
+describe("plugin chat commands", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("bridges plugin extension commands onto the chat command host", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-plugin-commands-"));
+		tempRoots.push(tempRoot);
+		const pluginsDir = join(tempRoot, ".cline", "plugins");
+		await mkdir(pluginsDir, { recursive: true });
+		await writeFile(
+			join(pluginsDir, "echo.js"),
+			[
+				"export default {",
+				"  name: 'echo-plugin',",
+				"  manifest: { capabilities: ['commands'] },",
+				"  setup(api) {",
+				"    api.registerCommand({",
+				"      name: 'echo',",
+				"      description: 'Echo input',",
+				"      handler: async (input) => 'echo:' + input",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+		);
+
+		const { host, pluginSlashCommands, shutdown } =
+			await createWorkspaceChatCommandHost({
+				cwd: tempRoot,
+				workspaceRoot: tempRoot,
+			});
+		const reply = vi.fn(async () => undefined);
+
+		// Filter to only our test plugin to ignore any discovered system plugins
+		const testCommands = pluginSlashCommands.filter(
+			(cmd) => cmd.name === "echo",
+		);
+		expect(testCommands).toEqual([{ name: "echo", description: "Echo input" }]);
+
+		const handled = await host.handle("/echo hello plugin", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: tempRoot,
+				workspaceRoot: tempRoot,
+			}),
+			setState: async () => undefined,
+			reply,
+		});
+
+		expect(handled).toBe(true);
+		expect(reply).toHaveBeenCalledWith("echo:hello plugin");
+		await shutdown?.();
+	});
+
+	it("bridges plugin command submit prompts onto the chat command context", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cli-plugin-commands-"));
+		tempRoots.push(tempRoot);
+		const pluginsDir = join(tempRoot, ".cline", "plugins");
+		await mkdir(pluginsDir, { recursive: true });
+		await writeFile(
+			join(pluginsDir, "submit.js"),
+			[
+				"export default {",
+				"  name: 'submit-plugin',",
+				"  manifest: { capabilities: ['commands'] },",
+				"  setup(api) {",
+				"    api.registerCommand({",
+				"      name: 'goal',",
+				"      description: 'Set a goal and submit it',",
+				"      handler: async (input) => ({",
+				"        reply: 'goal:' + input,",
+				"        submitPrompt: input",
+				"      })",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+		);
+
+		const { host, shutdown } = await createWorkspaceChatCommandHost({
+			cwd: tempRoot,
+			workspaceRoot: tempRoot,
+		});
+		const reply = vi.fn(async () => undefined);
+		const submitPrompt = vi.fn(async () => undefined);
+
+		const handled = await host.handle("/goal fix tests", {
+			enabled: true,
+			getState: async () => ({
+				enableTools: false,
+				autoApproveTools: false,
+				cwd: tempRoot,
+				workspaceRoot: tempRoot,
+			}),
+			setState: async () => undefined,
+			reply,
+			submitPrompt,
+		});
+
+		expect(handled).toBe(true);
+		expect(reply).toHaveBeenCalledWith("goal:fix tests");
+		expect(submitPrompt).toHaveBeenCalledWith("fix tests");
+		await shutdown?.();
+	});
+});
diff --git a/apps/cli/src/utils/plugin-chat-commands.ts b/apps/cli/src/utils/plugin-chat-commands.ts
new file mode 100644
index 0000000..f6d80a6
--- /dev/null
+++ b/apps/cli/src/utils/plugin-chat-commands.ts
@@ -0,0 +1,147 @@
+import {
+	type AgentExtensionCommand,
+	type AgentExtensionCommandResult,
+	type BasicLogger,
+	createContributionRegistry,
+	resolveAndLoadAgentPlugins,
+} from "@cline/core";
+import type { AgentTool, Message } from "@cline/shared";
+import {
+	type ChatCommandDefinition,
+	type ChatCommandHost,
+	chatCommandHost,
+} from "./chat-commands";
+
+export interface PluginSlashCommand {
+	name: string;
+	description?: string;
+}
+
+export interface WorkspaceChatCommandHostResult {
+	host: ChatCommandHost;
+	// Plugin-registered commands surfaced as slash commands for TUI autocomplete.
+	pluginSlashCommands: PluginSlashCommand[];
+	shutdown?: () => Promise<void>;
+}
+
+function normalizeCommandName(name: string): string {
+	const trimmed = name.trim();
+	if (!trimmed) {
+		return trimmed;
+	}
+	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+function createPluginCommandDefinition(
+	command: AgentExtensionCommand,
+): ChatCommandDefinition | undefined {
+	if (typeof command.handler !== "function") {
+		return undefined;
+	}
+	const normalizedName = normalizeCommandName(command.name);
+	if (!normalizedName) {
+		return undefined;
+	}
+	return {
+		names: [normalizedName.toLowerCase()],
+		run: async ({ args }, context) => {
+			const result = await command.handler?.(args.join(" "));
+			const { reply, submitPrompt } = normalizeCommandResult(result);
+			if (reply) {
+				await context.reply(reply);
+			}
+			if (submitPrompt) {
+				await context.submitPrompt?.(submitPrompt);
+			}
+		},
+	};
+}
+
+function normalizeCommandResult(
+	result: AgentExtensionCommandResult | undefined,
+): { reply?: string; submitPrompt?: string } {
+	if (typeof result === "string") {
+		const reply = result.trim();
+		return reply ? { reply } : {};
+	}
+	if (!result || typeof result !== "object") {
+		return {};
+	}
+	const reply =
+		typeof result.reply === "string" && result.reply.trim()
+			? result.reply.trim()
+			: undefined;
+	const submitPrompt =
+		typeof result.submitPrompt === "string" && result.submitPrompt.trim()
+			? result.submitPrompt.trim()
+			: undefined;
+	return {
+		...(reply ? { reply } : {}),
+		...(submitPrompt ? { submitPrompt } : {}),
+	};
+}
+
+export async function createWorkspaceChatCommandHost(input: {
+	cwd: string;
+	workspaceRoot?: string;
+	logger?: BasicLogger;
+}): Promise<WorkspaceChatCommandHostResult> {
+	const workspaceRoot = input.workspaceRoot?.trim() || input.cwd;
+	let loaded: Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>;
+	try {
+		loaded = await resolveAndLoadAgentPlugins({
+			cwd: input.cwd,
+			workspacePath: workspaceRoot,
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.logger?.log(
+			`plugin command loading failed; continuing without plugin commands (${message})`,
+		);
+		return { host: chatCommandHost, pluginSlashCommands: [] };
+	}
+	if (!loaded.extensions.length) {
+		await loaded.shutdown?.().catch(() => {
+			// Best effort cleanup when no command-capable plugins were loaded.
+		});
+		return { host: chatCommandHost, pluginSlashCommands: [] };
+	}
+
+	const registry = createContributionRegistry<
+		(typeof loaded.extensions)[number],
+		AgentTool,
+		Message[]
+	>({
+		extensions: loaded.extensions,
+	});
+	try {
+		await registry.initialize();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.logger?.log(
+			`plugin command registry initialization failed; continuing without plugin commands (${message})`,
+		);
+		await loaded.shutdown?.().catch(() => {
+			// Best effort cleanup after failed command discovery.
+		});
+		return { host: chatCommandHost, pluginSlashCommands: [] };
+	}
+
+	const host = chatCommandHost.clone();
+	const pluginSlashCommands: PluginSlashCommand[] = [];
+	for (const command of registry.getRegistrySnapshot().commands) {
+		const definition = createPluginCommandDefinition(command);
+		if (definition) {
+			host.register("command", definition);
+			// Use the same normalized+lowercased name so TUI autocomplete matches the handler key.
+			const normalizedName = definition.names[0]; // already lowercased, slash-prefixed
+			pluginSlashCommands.push({
+				name: normalizedName.startsWith("/")
+					? normalizedName.slice(1)
+					: normalizedName,
+				description: command.description,
+			});
+		}
+	}
+	return { host, pluginSlashCommands, shutdown: loaded.shutdown };
+}
diff --git a/apps/cli/src/utils/provider-auth.test.ts b/apps/cli/src/utils/provider-auth.test.ts
new file mode 100644
index 0000000..311618a
--- /dev/null
+++ b/apps/cli/src/utils/provider-auth.test.ts
@@ -0,0 +1,69 @@
+import type { ProviderSettings } from "@cline/core";
+import { describe, expect, it } from "vitest";
+import { isProviderConfigured } from "./provider-auth";
+
+describe("isProviderConfigured", () => {
+	it("returns false when settings is undefined", () => {
+		expect(isProviderConfigured("anthropic", undefined)).toBe(false);
+	});
+
+	it("returns false when api-key settings have no useful fields", () => {
+		expect(
+			isProviderConfigured("anthropic", {
+				provider: "anthropic",
+			} satisfies ProviderSettings),
+		).toBe(false);
+	});
+
+	it("treats any persisted api key as configured", () => {
+		expect(
+			isProviderConfigured("anthropic", {
+				provider: "anthropic",
+				apiKey: "sk-test",
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("treats a persisted base URL as configured", () => {
+		expect(
+			isProviderConfigured("ollama", {
+				provider: "ollama",
+				baseUrl: "http://localhost:11434/v1",
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("treats a persisted model id as configured", () => {
+		expect(
+			isProviderConfigured("ollama", {
+				provider: "ollama",
+				model: "llama3.1",
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("treats lmstudio with model + base url as configured", () => {
+		expect(
+			isProviderConfigured("lmstudio", {
+				provider: "lmstudio",
+				model: "qwen2",
+				baseUrl: "http://localhost:1234/v1",
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("requires an OAuth access token for cline", () => {
+		expect(
+			isProviderConfigured("cline", {
+				provider: "cline",
+			} satisfies ProviderSettings),
+		).toBe(false);
+
+		expect(
+			isProviderConfigured("cline", {
+				provider: "cline",
+				auth: { accessToken: "workos:abc" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+});
diff --git a/apps/cli/src/utils/provider-auth.ts b/apps/cli/src/utils/provider-auth.ts
new file mode 100644
index 0000000..0e17ece
--- /dev/null
+++ b/apps/cli/src/utils/provider-auth.ts
@@ -0,0 +1,78 @@
+import {
+	formatProviderOAuthApiKey,
+	getPersistedProviderApiKey as getCorePersistedProviderApiKey,
+	isOAuthProvider,
+	Llms,
+	type ProviderOAuthCredentials,
+	type ProviderSettings,
+} from "@cline/core";
+
+export type OAuthCredentials = ProviderOAuthCredentials;
+
+export function normalizeProviderId(providerId: string): string {
+	return Llms.normalizeProviderId(providerId.trim());
+}
+
+export function normalizeAuthProviderId(providerId: string): string {
+	const normalized = providerId.trim().toLowerCase();
+	if (normalized === "codex" || normalized === "openai-codex") {
+		return "openai-codex";
+	}
+	return normalizeProviderId(normalized);
+}
+
+export { isOAuthProvider };
+
+export function toProviderApiKey(
+	providerId: string,
+	credentials: Pick<OAuthCredentials, "access">,
+): string {
+	return formatProviderOAuthApiKey(providerId, credentials);
+}
+
+export function getPersistedProviderApiKey(
+	providerId: string,
+	settings?: ProviderSettings,
+): string | undefined {
+	return getCorePersistedProviderApiKey(providerId, settings);
+}
+
+/**
+ * Returns true when the user has previously saved any meaningful credentials
+ * or endpoint config for the provider. Used by the picker to decide whether
+ * to offer "Use existing configuration?" before opening the configure dialog.
+ *
+ * Treats OAuth providers as configured when an access token is present; for
+ * everything else, any persisted API key, base URL, or model id counts. We
+ * don't enforce required fields here — the runtime no longer pre-flights
+ * credentials, so a missing key only matters when the API call actually
+ * runs and the provider's own auth error is surfaced.
+ */
+export function isProviderConfigured(
+	providerId: string,
+	settings: ProviderSettings | undefined,
+): boolean {
+	if (!settings) return false;
+	if (isOAuthProvider(providerId)) {
+		return Boolean(settings.auth?.accessToken?.trim());
+	}
+	if (getPersistedProviderApiKey(providerId, settings)) return true;
+	if (settings.baseUrl?.trim()) return true;
+	if (settings.model?.trim()) return true;
+	return false;
+}
+
+export async function ensureOAuthProviderApiKey(
+	input: Parameters<
+		typeof import("../commands/auth").ensureOAuthProviderApiKey
+	>[0],
+): Promise<
+	Awaited<
+		ReturnType<typeof import("../commands/auth").ensureOAuthProviderApiKey>
+	>
+> {
+	const { ensureOAuthProviderApiKey: ensureFromCommand } = await import(
+		"../commands/auth"
+	);
+	return await ensureFromCommand(input);
+}
diff --git a/apps/cli/src/utils/provider-catalog.test.ts b/apps/cli/src/utils/provider-catalog.test.ts
new file mode 100644
index 0000000..1f60e20
--- /dev/null
+++ b/apps/cli/src/utils/provider-catalog.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+	listLocalProviders: vi.fn(async () => ({ providers: [], settingsPath: "" })),
+}));
+
+vi.mock("@cline/core", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@cline/core")>();
+	return {
+		...actual,
+		listLocalProviders: mocks.listLocalProviders,
+	};
+});
+
+describe("listLocalProviders", () => {
+	it("enables ClinePass when listing the SDK provider list", async () => {
+		const { listLocalProviders } = await import("./provider-catalog");
+		const manager = {} as never;
+
+		await listLocalProviders(manager);
+
+		expect(mocks.listLocalProviders).toHaveBeenCalledWith(manager, {
+			isClinePassEnabled: true,
+		});
+	});
+});
diff --git a/apps/cli/src/utils/provider-catalog.ts b/apps/cli/src/utils/provider-catalog.ts
new file mode 100644
index 0000000..94905d3
--- /dev/null
+++ b/apps/cli/src/utils/provider-catalog.ts
@@ -0,0 +1,12 @@
+import {
+	listLocalProviders as internalListLocalProviders,
+	type ProviderSettingsManager,
+} from "@cline/core";
+
+export async function listLocalProviders(
+	manager: ProviderSettingsManager,
+): ReturnType<typeof internalListLocalProviders> {
+	return await internalListLocalProviders(manager, {
+		isClinePassEnabled: true,
+	});
+}
diff --git a/apps/cli/src/utils/provider-readiness.test.ts b/apps/cli/src/utils/provider-readiness.test.ts
new file mode 100644
index 0000000..d794e7f
--- /dev/null
+++ b/apps/cli/src/utils/provider-readiness.test.ts
@@ -0,0 +1,170 @@
+import type { ProviderSettings } from "@cline/core";
+import { describe, expect, it } from "vitest";
+import { isProviderSettingsUsable } from "./provider-readiness";
+
+describe("provider readiness", () => {
+	it("rejects missing and mismatched provider settings", () => {
+		expect(isProviderSettingsUsable("anthropic", undefined)).toBe(false);
+		expect(
+			isProviderSettingsUsable("anthropic", {
+				provider: "openai-native",
+				apiKey: "sk-test",
+			} satisfies ProviderSettings),
+		).toBe(false);
+	});
+
+	it("requires usable OAuth credentials for OAuth providers", () => {
+		expect(
+			isProviderSettingsUsable("cline", {
+				provider: "cline",
+				model: "claude-sonnet-4-6",
+			} satisfies ProviderSettings),
+		).toBe(false);
+		expect(
+			isProviderSettingsUsable("cline", {
+				provider: "cline",
+				auth: { accessToken: "token" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("accepts manual API keys for API-key providers", () => {
+		expect(
+			isProviderSettingsUsable("anthropic", {
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+			} satisfies ProviderSettings),
+		).toBe(false);
+		expect(
+			isProviderSettingsUsable("anthropic", {
+				provider: "anthropic",
+				apiKey: "sk-ant-test",
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("accepts saved local auth providers without an API key", () => {
+		expect(
+			isProviderSettingsUsable("openai-codex-cli", {
+				provider: "openai-codex-cli",
+			} satisfies ProviderSettings),
+		).toBe(true);
+	});
+
+	it("accepts keyless local providers with a resolved endpoint and model", () => {
+		expect(
+			isProviderSettingsUsable(
+				"ollama",
+				{
+					provider: "ollama",
+					model: "llama3.2",
+				} satisfies ProviderSettings,
+				{
+					baseUrl: "http://localhost:11434/v1",
+					modelId: "llama3.2",
+				},
+			),
+		).toBe(true);
+	});
+
+	it("rejects keyless local providers without a selected model", () => {
+		expect(
+			isProviderSettingsUsable(
+				"ollama",
+				{
+					provider: "ollama",
+				} satisfies ProviderSettings,
+				{
+					baseUrl: "http://localhost:11434/v1",
+					modelId: "",
+				},
+			),
+		).toBe(false);
+	});
+
+	it("accepts provider-specific cloud credentials", () => {
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				aws: { profile: "default" },
+			} satisfies ProviderSettings),
+		).toBe(false);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				apiKey: "bedrock-api-key",
+			} satisfies ProviderSettings),
+		).toBe(false);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				apiKey: "bedrock-api-key",
+				aws: { region: "us-east-1", authentication: "api-key" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				aws: { profile: "default", region: "us-west-2" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				aws: { authentication: "iam", region: "us-east-1" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				region: "us-east-1",
+				aws: { authentication: "iam" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				aws: { authentication: "profile", region: "us-east-1" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("bedrock", {
+				provider: "bedrock",
+				aws: { accessKey: "access", secretKey: "secret", region: "us-east-1" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("vertex", {
+				provider: "vertex",
+				gcp: { projectId: "test-project" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("vertex", {
+				provider: "vertex",
+				gcp: { projectId: "test-project", region: "us-central1" },
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("sapaicore", {
+				provider: "sapaicore",
+				baseUrl: "https://api.ai.example.invalid",
+				sap: {
+					clientId: "client",
+					clientSecret: "secret",
+					tokenUrl: "https://example.com/token",
+				},
+			} satisfies ProviderSettings),
+		).toBe(true);
+		expect(
+			isProviderSettingsUsable("sapaicore", {
+				provider: "sapaicore",
+				sap: {
+					clientId: "client",
+					clientSecret: "secret",
+					tokenUrl: "https://example.com/token",
+				},
+			} satisfies ProviderSettings),
+		).toBe(false);
+	});
+});
diff --git a/apps/cli/src/utils/provider-readiness.ts b/apps/cli/src/utils/provider-readiness.ts
new file mode 100644
index 0000000..c99fd85
--- /dev/null
+++ b/apps/cli/src/utils/provider-readiness.ts
@@ -0,0 +1,100 @@
+import {
+	getProviderConfigFields,
+	type ProviderConfig,
+	type ProviderSettings,
+} from "@cline/core";
+import {
+	getPersistedProviderApiKey,
+	isOAuthProvider,
+	normalizeProviderId,
+} from "./provider-auth";
+
+function hasText(value: string | undefined): boolean {
+	return typeof value === "string" && value.trim().length > 0;
+}
+
+function hasAwsCredentials(settings: ProviderSettings): boolean {
+	const aws = settings.aws;
+	if (!aws) {
+		return false;
+	}
+	if (aws.authentication === "iam" || aws.authentication === "profile") {
+		return true;
+	}
+	if (hasText(aws.profile)) {
+		return true;
+	}
+	return hasText(aws.accessKey) && hasText(aws.secretKey);
+}
+
+function hasAwsRegion(settings: ProviderSettings): boolean {
+	return hasText(settings.aws?.region ?? settings.region);
+}
+
+function hasGcpCredentials(settings: ProviderSettings): boolean {
+	const gcp = settings.gcp;
+	// Vertex defaults to us-central1 at runtime when no region is stored, so keep
+	// existing project-only configs usable while new CLI saves include a region.
+	return hasText(gcp?.projectId);
+}
+
+function hasAzureCredentials(settings: ProviderSettings): boolean {
+	return settings.azure?.useIdentity === true;
+}
+
+function hasSapCredentials(settings: ProviderSettings): boolean {
+	const sap = settings.sap;
+	return (
+		hasText(sap?.clientId) &&
+		hasText(sap?.clientSecret) &&
+		hasText(sap?.tokenUrl) &&
+		hasText(settings.baseUrl)
+	);
+}
+
+export function isProviderSettingsUsable(
+	providerId: string,
+	settings: ProviderSettings | undefined,
+	config?: Pick<ProviderConfig, "baseUrl" | "modelId">,
+): boolean {
+	if (!settings) {
+		return false;
+	}
+	const normalizedProviderId = normalizeProviderId(providerId);
+	if (normalizeProviderId(settings.provider) !== normalizedProviderId) {
+		return false;
+	}
+	if (normalizedProviderId === "bedrock") {
+		return (
+			(Boolean(getPersistedProviderApiKey(normalizedProviderId, settings)) ||
+				hasAwsCredentials(settings)) &&
+			hasAwsRegion(settings)
+		);
+	}
+	if (normalizedProviderId === "sapaicore") {
+		return hasSapCredentials(settings);
+	}
+	if (getPersistedProviderApiKey(normalizedProviderId, settings)) {
+		return true;
+	}
+	if (isOAuthProvider(normalizedProviderId)) {
+		return false;
+	}
+	const fields = getProviderConfigFields(normalizedProviderId);
+	if (fields.authMethod === "local") {
+		return true;
+	}
+	if (normalizedProviderId === "vertex") {
+		return hasGcpCredentials(settings);
+	}
+	if (normalizedProviderId === "azure") {
+		return hasAzureCredentials(settings);
+	}
+	if (!fields.fields.baseUrl) {
+		return false;
+	}
+	return (
+		hasText(config?.baseUrl ?? settings.baseUrl) &&
+		hasText(config?.modelId ?? settings.model)
+	);
+}
diff --git a/apps/cli/src/utils/reasoning.test.ts b/apps/cli/src/utils/reasoning.test.ts
new file mode 100644
index 0000000..3783ea3
--- /dev/null
+++ b/apps/cli/src/utils/reasoning.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { resolveCliReasoning } from "./reasoning";
+
+describe("resolveCliReasoning", () => {
+	it("leaves reasoning unset when neither CLI nor persisted settings specify it", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: false,
+			}),
+		).toEqual({
+			thinking: undefined,
+			reasoningEffort: undefined,
+		});
+	});
+
+	it("preserves explicit --thinking none as disabled reasoning", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: false,
+				thinkingExplicitlySet: true,
+			}),
+		).toEqual({
+			thinking: false,
+			reasoningEffort: undefined,
+		});
+	});
+
+	it("prefers explicit --thinking over persisted reasoning settings", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: true,
+				thinkingExplicitlySet: true,
+				reasoningEffort: "low",
+				persistedReasoning: { enabled: false },
+			}),
+		).toEqual({
+			thinking: true,
+			reasoningEffort: "low",
+		});
+	});
+
+	it("uses persisted disabled reasoning when --thinking is unset", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: false,
+				persistedReasoning: { enabled: false },
+			}),
+		).toEqual({
+			thinking: false,
+			reasoningEffort: undefined,
+		});
+	});
+
+	it("uses persisted effort none as disabled reasoning when --thinking is unset", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: false,
+				persistedReasoning: { effort: "none" },
+			}),
+		).toEqual({
+			thinking: false,
+			reasoningEffort: undefined,
+		});
+	});
+
+	it("uses persisted active effort when --thinking is unset", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: false,
+				persistedReasoning: { enabled: true, effort: "high" },
+			}),
+		).toEqual({
+			thinking: true,
+			reasoningEffort: "high",
+		});
+	});
+
+	it("uses medium effort when persisted reasoning is enabled without an effort", () => {
+		expect(
+			resolveCliReasoning({
+				thinking: false,
+				persistedReasoning: { enabled: true },
+			}),
+		).toEqual({
+			thinking: true,
+			reasoningEffort: "medium",
+		});
+	});
+});
diff --git a/apps/cli/src/utils/reasoning.ts b/apps/cli/src/utils/reasoning.ts
new file mode 100644
index 0000000..5d12a25
--- /dev/null
+++ b/apps/cli/src/utils/reasoning.ts
@@ -0,0 +1,65 @@
+import type { ProviderSettings } from "@cline/core";
+import type { CliReasoningEffort } from "./types";
+
+type ActiveCliReasoningEffort = Exclude<CliReasoningEffort, "none">;
+
+const ACTIVE_REASONING_EFFORTS = new Set<ActiveCliReasoningEffort>([
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+]);
+
+export interface ResolveCliReasoningInput {
+	thinking: boolean;
+	thinkingExplicitlySet?: boolean;
+	reasoningEffort?: CliReasoningEffort;
+	persistedReasoning?: ProviderSettings["reasoning"];
+}
+
+export interface ResolvedCliReasoning {
+	thinking?: boolean;
+	reasoningEffort?: ActiveCliReasoningEffort;
+}
+
+function isActiveReasoningEffort(
+	effort: unknown,
+): effort is ActiveCliReasoningEffort {
+	return (
+		typeof effort === "string" &&
+		ACTIVE_REASONING_EFFORTS.has(effort as ActiveCliReasoningEffort)
+	);
+}
+
+export function resolveCliReasoning({
+	thinking,
+	thinkingExplicitlySet,
+	reasoningEffort,
+	persistedReasoning,
+}: ResolveCliReasoningInput): ResolvedCliReasoning {
+	if (thinkingExplicitlySet) {
+		return {
+			thinking,
+			reasoningEffort: isActiveReasoningEffort(reasoningEffort)
+				? reasoningEffort
+				: undefined,
+		};
+	}
+
+	if (
+		persistedReasoning?.enabled === false ||
+		persistedReasoning?.effort === "none"
+	) {
+		return { thinking: false, reasoningEffort: undefined };
+	}
+
+	if (isActiveReasoningEffort(persistedReasoning?.effort)) {
+		return { thinking: true, reasoningEffort: persistedReasoning.effort };
+	}
+
+	if (persistedReasoning?.enabled === true) {
+		return { thinking: true, reasoningEffort: "medium" };
+	}
+
+	return { thinking: undefined, reasoningEffort: undefined };
+}
diff --git a/apps/cli/src/utils/repo-status.ts b/apps/cli/src/utils/repo-status.ts
new file mode 100644
index 0000000..1cfeb65
--- /dev/null
+++ b/apps/cli/src/utils/repo-status.ts
@@ -0,0 +1,55 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export type GitDiffStats = {
+	files: number;
+	additions: number;
+	deletions: number;
+};
+
+export interface RepoStatus {
+	branch: string | null;
+	diffStats: GitDiffStats | null;
+}
+
+export async function readRepoStatus(cwd: string): Promise<RepoStatus> {
+	const [branchResult, diffResult] = await Promise.allSettled([
+		execFileAsync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
+			encoding: "utf8",
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		}),
+		execFileAsync("git", ["-C", cwd, "diff", "--shortstat"], {
+			encoding: "utf8",
+			windowsHide: true,
+		}),
+	]);
+
+	const branch =
+		branchResult.status === "fulfilled"
+			? branchResult.value.stdout.trim() || null
+			: null;
+
+	let diffStats: GitDiffStats | null = null;
+	if (diffResult.status === "fulfilled") {
+		const output = diffResult.value.stdout.trim();
+		if (output) {
+			const filesMatch = output.match(/(\d+)\s+file/);
+			const additionsMatch = output.match(/(\d+)\s+insertion/);
+			const deletionsMatch = output.match(/(\d+)\s+deletion/);
+			diffStats = {
+				files: filesMatch ? Number.parseInt(filesMatch[1] ?? "0", 10) : 0,
+				additions: additionsMatch
+					? Number.parseInt(additionsMatch[1] ?? "0", 10)
+					: 0,
+				deletions: deletionsMatch
+					? Number.parseInt(deletionsMatch[1] ?? "0", 10)
+					: 0,
+			};
+		}
+	}
+
+	return { branch, diffStats };
+}
diff --git a/apps/cli/src/utils/resume.test.ts b/apps/cli/src/utils/resume.test.ts
new file mode 100644
index 0000000..1bdcf67
--- /dev/null
+++ b/apps/cli/src/utils/resume.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from "vitest";
+import { loadInteractiveResumeMessages } from "./resume";
+
+describe("loadInteractiveResumeMessages", () => {
+	it("returns undefined when session id is missing", async () => {
+		const manager = {
+			readMessages: vi.fn().mockResolvedValue([]),
+		};
+		const result = await loadInteractiveResumeMessages(manager as never);
+		expect(result).toBeUndefined();
+		expect(manager.readMessages).not.toHaveBeenCalled();
+	});
+
+	it("loads messages through session manager readMessages", async () => {
+		const expected = [
+			{ role: "user", content: [{ type: "text", text: "resume" }] },
+		];
+		const manager = {
+			readMessages: vi.fn().mockResolvedValue(expected),
+		};
+		const result = await loadInteractiveResumeMessages(
+			manager as never,
+			" session-123 ",
+		);
+		expect(manager.readMessages).toHaveBeenCalledWith("session-123");
+		expect(result).toEqual(expected);
+	});
+});
diff --git a/apps/cli/src/utils/resume.ts b/apps/cli/src/utils/resume.ts
new file mode 100644
index 0000000..ccd3597
--- /dev/null
+++ b/apps/cli/src/utils/resume.ts
@@ -0,0 +1,13 @@
+import type { ClineCore } from "@cline/core";
+import type { Message } from "@cline/shared";
+
+export async function loadInteractiveResumeMessages(
+	sessionManager: ClineCore,
+	resumeSessionId?: string,
+): Promise<Message[] | undefined> {
+	const target = resumeSessionId?.trim();
+	if (!target) {
+		return undefined;
+	}
+	return await sessionManager.readMessages(target);
+}
diff --git a/apps/cli/src/utils/team-command.test.ts b/apps/cli/src/utils/team-command.test.ts
new file mode 100644
index 0000000..badcc50
--- /dev/null
+++ b/apps/cli/src/utils/team-command.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { rewriteTeamPrompt, TEAM_COMMAND_USAGE } from "./team-command";
+
+describe("team command prompt rewrite", () => {
+	it("does not rewrite non-team prompts", () => {
+		expect(rewriteTeamPrompt("investigate rpc startup")).toEqual({
+			kind: "none",
+		});
+	});
+
+	it("rewrites /team prompts", () => {
+		expect(rewriteTeamPrompt("/team investigate rpc startup")).toEqual({
+			kind: "rewritten",
+			prompt:
+				'<user_command slash="team">spawn a team of agents for the following task: investigate rpc startup</user_command>',
+		});
+	});
+
+	it("preserves multiline team tasks", () => {
+		expect(
+			rewriteTeamPrompt("/team investigate rpc startup\ninclude tests"),
+		).toEqual({
+			kind: "rewritten",
+			prompt:
+				'<user_command slash="team">spawn a team of agents for the following task: investigate rpc startup\ninclude tests</user_command>',
+		});
+	});
+
+	it("returns usage for /team without a task", () => {
+		expect(rewriteTeamPrompt("/team")).toEqual({ kind: "usage" });
+		expect(TEAM_COMMAND_USAGE).toContain("/team <task description>");
+	});
+});
diff --git a/apps/cli/src/utils/team-command.ts b/apps/cli/src/utils/team-command.ts
new file mode 100644
index 0000000..d7ddf22
--- /dev/null
+++ b/apps/cli/src/utils/team-command.ts
@@ -0,0 +1,37 @@
+import { createTeamName } from "@cline/core";
+import { formatUserCommandBlock } from "@cline/shared";
+import type { Config } from "./types";
+
+export const TEAM_COMMAND_USAGE =
+	"Usage: /team <task description>\nStarts a team of agents for the given task.";
+
+type TeamPromptRewriteResult =
+	| { kind: "none" }
+	| { kind: "usage" }
+	| { kind: "rewritten"; prompt: string };
+
+export function rewriteTeamPrompt(input: string): TeamPromptRewriteResult {
+	const match = /^\/team\b([\s\S]*)$/i.exec(input.trim());
+	if (!match) {
+		return { kind: "none" };
+	}
+	const taskBody = match[1].trim();
+	if (!taskBody) {
+		return { kind: "usage" };
+	}
+	return {
+		kind: "rewritten",
+		prompt: formatUserCommandBlock(
+			`spawn a team of agents for the following task: ${taskBody}`,
+			"team",
+		),
+	};
+}
+
+export async function enableTeamsForPrompt(config: Config): Promise<void> {
+	if (config.enableAgentTeams) {
+		return;
+	}
+	config.enableAgentTeams = true;
+	config.teamName = config.teamName?.trim() || createTeamName();
+}
diff --git a/apps/cli/src/utils/telemetry.activation-gate.ts b/apps/cli/src/utils/telemetry.activation-gate.ts
new file mode 100644
index 0000000..eb7f286
--- /dev/null
+++ b/apps/cli/src/utils/telemetry.activation-gate.ts
@@ -0,0 +1,35 @@
+/**
+ * Per-process gate for the CLI's `user.extension_activated` telemetry
+ * event. Owns the boolean state in a tiny module so the production
+ * `captureCliExtensionActivated` helper and the test-only reset helper
+ * can share the same flag without exporting a publicly-visible setter
+ * from the production telemetry module.
+ *
+ * Production code only ever calls {@link wasActivationCaptured} and
+ * {@link markActivationCaptured}; resetting the gate is exposed only via
+ * `apps/cli/src/utils/telemetry.test-helpers.ts`, which is not part of
+ * the production import graph.
+ *
+ * @internal
+ */
+let captured = false;
+
+/** Returns whether the activation event has already been emitted in this process. */
+export function wasActivationCaptured(): boolean {
+	return captured;
+}
+
+/** Marks the activation event as emitted so subsequent calls become no-ops. */
+export function markActivationCaptured(): void {
+	captured = true;
+}
+
+/**
+ * Resets the gate. Intended exclusively for unit tests that need to
+ * re-exercise the activation path; do not call from production code.
+ *
+ * @internal
+ */
+export function resetActivationGate(): void {
+	captured = false;
+}
diff --git a/apps/cli/src/utils/telemetry.activation.test.ts b/apps/cli/src/utils/telemetry.activation.test.ts
new file mode 100644
index 0000000..c59013c
--- /dev/null
+++ b/apps/cli/src/utils/telemetry.activation.test.ts
@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+// Hoist the spy so vi.mock's factory can reference it without TDZ errors.
+const hoisted = vi.hoisted(() => ({
+	captureExtensionActivated: vi.fn(),
+	identifyAccount: vi.fn(),
+	getCliTelemetryService: vi.fn(() => undefined),
+}));
+
+vi.mock("@cline/core", () => ({
+	captureExtensionActivated: hoisted.captureExtensionActivated,
+	identifyAccount: hoisted.identifyAccount,
+	// CLI telemetry singleton path normally pulls in
+	// `createConfiguredTelemetryHandle` and `createClineTelemetryServiceConfig`;
+	// stub them so the test never spins up a real OpenTelemetry provider.
+	createClineTelemetryServiceConfig: vi.fn(() => ({})),
+	createConfiguredTelemetryHandle: vi.fn(() => ({
+		telemetry: undefined,
+		provider: undefined,
+		flush: vi.fn(),
+		dispose: vi.fn(),
+	})),
+	registerDisposable: vi.fn(),
+	TelemetryLoggerSink: class {},
+}));
+
+vi.mock("./telemetry", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("./telemetry")>();
+	return {
+		...actual,
+		getCliTelemetryService: hoisted.getCliTelemetryService,
+	};
+});
+
+import {
+	captureCliExtensionActivated,
+	identifyTelemetryAccount,
+} from "./telemetry";
+import { resetCliExtensionActivationForTests } from "./telemetry.test-helpers";
+
+describe("captureCliExtensionActivated", () => {
+	beforeEach(() => {
+		hoisted.captureExtensionActivated.mockClear();
+		hoisted.identifyAccount.mockClear();
+		hoisted.getCliTelemetryService.mockClear();
+		resetCliExtensionActivationForTests();
+	});
+
+	afterEach(() => {
+		resetCliExtensionActivationForTests();
+	});
+
+	test("emits user.extension_activated on first call via core helper", () => {
+		captureCliExtensionActivated();
+		expect(hoisted.captureExtensionActivated).toHaveBeenCalledTimes(1);
+	});
+
+	test("memoizes emission across subsequent calls", () => {
+		captureCliExtensionActivated();
+		captureCliExtensionActivated();
+		captureCliExtensionActivated();
+		expect(hoisted.captureExtensionActivated).toHaveBeenCalledTimes(1);
+	});
+
+	test("identifies the active organization before capturing activation", () => {
+		const account = {
+			id: "user-1",
+			email: "user@example.com",
+			provider: "cline",
+			organizationId: "org-1",
+			organizationName: "Acme Corp",
+			memberId: "member-9",
+		};
+		captureCliExtensionActivated(undefined, account);
+
+		expect(hoisted.identifyAccount).toHaveBeenCalledTimes(1);
+		expect(hoisted.identifyAccount).toHaveBeenCalledWith(undefined, account);
+
+		// identifyAccount must be invoked strictly before captureExtensionActivated
+		// so the org_id common properties land on user.extension_activated.
+		const identifyOrder =
+			hoisted.identifyAccount.mock.invocationCallOrder[0] ?? Infinity;
+		const captureOrder =
+			hoisted.captureExtensionActivated.mock.invocationCallOrder[0] ??
+			-Infinity;
+		expect(identifyOrder).toBeLessThan(captureOrder);
+		expect(hoisted.captureExtensionActivated).toHaveBeenCalledTimes(1);
+	});
+
+	test("does not call identifyAccount when no account context is provided", () => {
+		captureCliExtensionActivated();
+		expect(hoisted.identifyAccount).not.toHaveBeenCalled();
+	});
+});
+
+describe("identifyTelemetryAccount", () => {
+	beforeEach(() => {
+		hoisted.identifyAccount.mockClear();
+		hoisted.getCliTelemetryService.mockClear();
+	});
+
+	test("forwards account context to core identifyAccount on the CLI telemetry service", () => {
+		const account = {
+			id: "user-2",
+			organizationId: "org-2",
+			organizationName: "Beta Inc",
+			memberId: "member-7",
+			provider: "cline",
+		};
+		identifyTelemetryAccount(account);
+		expect(hoisted.identifyAccount).toHaveBeenCalledWith(undefined, account);
+	});
+});
diff --git a/apps/cli/src/utils/telemetry.test-helpers.ts b/apps/cli/src/utils/telemetry.test-helpers.ts
new file mode 100644
index 0000000..b52ea15
--- /dev/null
+++ b/apps/cli/src/utils/telemetry.test-helpers.ts
@@ -0,0 +1,23 @@
+/**
+ * Test-only helpers for the CLI telemetry module. Kept in a separate
+ * file (and outside the production `telemetry.ts` export surface) so
+ * downstream bundlers and external consumers cannot accidentally call
+ * them and silently reset production-side state.
+ *
+ * Only unit tests under `apps/cli/src/utils/` should import from this
+ * module. The production CLI never imports it.
+ *
+ * @internal
+ */
+import { resetActivationGate } from "./telemetry.activation-gate";
+
+/**
+ * Resets the memoized `user.extension_activated` gate so unit tests can
+ * re-exercise the activation path deterministically. No-op in
+ * production code paths.
+ *
+ * @internal
+ */
+export function resetCliExtensionActivationForTests(): void {
+	resetActivationGate();
+}
diff --git a/apps/cli/src/utils/telemetry.ts b/apps/cli/src/utils/telemetry.ts
new file mode 100644
index 0000000..b7251fa
--- /dev/null
+++ b/apps/cli/src/utils/telemetry.ts
@@ -0,0 +1,142 @@
+import {
+	type BasicLogger,
+	captureExtensionActivated,
+	createClineTelemetryServiceConfig,
+	createConfiguredTelemetryHandle,
+	type ITelemetryService,
+	identifyAccount,
+	registerDisposable,
+	TelemetryLoggerSink,
+} from "@cline/core";
+import { getCliBuildInfo } from "./common";
+import { identifyFeatureFlagsAccount } from "./feature-flags";
+import {
+	markActivationCaptured,
+	wasActivationCaptured,
+} from "./telemetry.activation-gate";
+
+type MutableTelemetryService = ITelemetryService & {
+	addAdapter?: (adapter: TelemetryLoggerSink) => void;
+};
+
+let telemetrySingleton:
+	| {
+			telemetry: ITelemetryService;
+			dispose: () => Promise<void>;
+			loggerAttached: boolean;
+	  }
+	| undefined;
+
+export function getCliTelemetryService(
+	logger?: BasicLogger,
+): ITelemetryService {
+	if (!telemetrySingleton) {
+		const { version, name, os_type, os_version } = getCliBuildInfo();
+		const config = createClineTelemetryServiceConfig({
+			metadata: {
+				extension_version: version,
+				cline_type: "cli",
+				platform: name,
+				platform_version: process.version,
+				os_type,
+				os_version,
+			},
+		});
+		const handle = createConfiguredTelemetryHandle({
+			...config,
+			logger,
+		});
+		telemetrySingleton = {
+			telemetry: handle.telemetry,
+			loggerAttached: Boolean(logger),
+			dispose: handle.dispose,
+		};
+		registerDisposable(disposeCliTelemetryService);
+	}
+	if (
+		logger &&
+		telemetrySingleton.loggerAttached !== true &&
+		typeof (telemetrySingleton.telemetry as MutableTelemetryService)
+			.addAdapter === "function"
+	) {
+		(telemetrySingleton.telemetry as MutableTelemetryService).addAdapter?.(
+			new TelemetryLoggerSink({ logger }),
+		);
+		telemetrySingleton.loggerAttached = true;
+	}
+	return telemetrySingleton.telemetry;
+}
+
+export async function disposeCliTelemetryService(): Promise<void> {
+	if (!telemetrySingleton) {
+		return;
+	}
+	const current = telemetrySingleton;
+	telemetrySingleton = undefined;
+	await current.dispose();
+}
+
+/**
+ * Optional account context used to enrich the CLI activation event. Mirrors
+ * the legacy `cline` extension behavior where `user.extension_activated`
+ * carries `organization_id`, `organization_name`, and `member_id` derived
+ * from the active Cline organization when the user is authenticated.
+ *
+ * All fields are optional. When omitted, the activation event is emitted
+ * without account/organization properties (matching unauthenticated runs).
+ */
+export interface CliTelemetryAccountContext {
+	id?: string;
+	email?: string;
+	provider?: string;
+	organizationId?: string;
+	organizationName?: string;
+	memberId?: string;
+}
+
+/**
+ * Attaches account/organization context to the CLI telemetry service so
+ * subsequent events (including the `user.extension_activated` activation
+ * event when called before {@link captureCliExtensionActivated}) carry
+ * `organization_id`, `organization_name`, `member_id`, etc.
+ *
+ * Safe to call multiple times; the latest values win, mirroring the legacy
+ * singleton-based behavior.
+ */
+export function identifyTelemetryAccount(
+	account: CliTelemetryAccountContext,
+	logger?: BasicLogger,
+): void {
+	identifyAccount(getCliTelemetryService(logger), account);
+	void identifyFeatureFlagsAccount(account, logger);
+}
+
+/**
+ * Memoized emission of the `user.extension_activated` event. Safe to call
+ * multiple times per process; only the first call emits. Routed through the
+ * normal capture path so the user's telemetry opt-out setting is honored.
+ *
+ * When `account` is provided, `identifyAccount` is called first so the
+ * activation event payload includes `organization_id`, `organization_name`,
+ * `member_id`, and similar account identifiers — matching the legacy CLI
+ * funnel observed in `otel.otel_logs`.
+ *
+ * The memoization gate lives in {@link ./telemetry.activation-gate} so a
+ * test-only reset helper can be exposed from a separate `*.test-helpers.ts`
+ * file rather than from this production module.
+ */
+export function captureCliExtensionActivated(
+	logger?: BasicLogger,
+	account?: CliTelemetryAccountContext,
+): void {
+	if (wasActivationCaptured()) {
+		return;
+	}
+	markActivationCaptured();
+	const telemetry = getCliTelemetryService(logger);
+	if (account) {
+		identifyAccount(telemetry, account);
+		void identifyFeatureFlagsAccount(account, logger);
+	}
+	captureExtensionActivated(telemetry);
+}
diff --git a/apps/cli/src/utils/types.ts b/apps/cli/src/utils/types.ts
new file mode 100644
index 0000000..703cbb5
--- /dev/null
+++ b/apps/cli/src/utils/types.ts
@@ -0,0 +1,99 @@
+import type {
+	AgentMode,
+	CoreSessionConfig,
+	Llms,
+	ProviderSettings,
+	RuntimeLoggerConfig,
+	SessionLineage,
+	SessionManifest,
+	ToolPolicy,
+} from "@cline/core";
+import type { Message } from "@cline/shared";
+
+export type CliOutputMode = "text" | "json";
+export type CliAgentMode = AgentMode;
+export type CliReasoningEffort = NonNullable<
+	NonNullable<ProviderSettings["reasoning"]>["effort"]
+>;
+export type CliCompactionMode = "agentic" | "basic" | "off";
+
+export interface Config extends Omit<CoreSessionConfig, "apiKey" | "mode"> {
+	apiKey: string;
+	knownModels?: Record<string, Llms.ModelInfo>;
+	loggerConfig?: RuntimeLoggerConfig;
+	verbose: boolean;
+	timeoutSeconds?: number;
+	sandbox: boolean;
+	sandboxDataDir?: string;
+	thinking?: boolean;
+	outputMode: CliOutputMode;
+	mode: CliAgentMode;
+	defaultToolAutoApprove: boolean;
+	toolPolicies: Record<string, ToolPolicy>;
+}
+
+export interface ActiveCliSession {
+	manifest: SessionManifest;
+}
+
+export interface StoredApiMessages {
+	version: 1;
+	updated_at: string;
+	messages: Message[];
+}
+
+export interface SessionDbRow {
+	session_id: string;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspace_root: string;
+	team_name?: string | null;
+	enable_tools: number;
+	enable_spawn: number;
+	enable_teams: number;
+	prompt?: string | null;
+}
+
+export interface SubagentSessionInput
+	extends Required<
+		Pick<SessionLineage, "agentId" | "parentAgentId" | "conversationId">
+	> {
+	prompt?: string;
+	rootSessionId?: string;
+}
+
+export interface ParsedArgs {
+	prompt?: string;
+	systemPrompt?: string;
+	key?: string;
+	verbose: boolean;
+	interactive: boolean;
+	outputMode: CliOutputMode;
+	mode: CliAgentMode;
+	timeoutSeconds?: number;
+	invalidTimeoutSeconds?: string;
+	thinking: boolean;
+	/** Whether --thinking was explicitly provided on the command line */
+	thinkingExplicitlySet?: boolean;
+	reasoningEffort?: CliReasoningEffort;
+	invalidThinkingLevel?: string;
+	compactionMode?: CliCompactionMode;
+	invalidCompactionMode?: string;
+	invalidAutoApprove?: string;
+	sandbox: boolean;
+	dataDir?: string;
+	configDir?: string;
+	hooksDir?: string;
+	worktree?: boolean;
+	acpMode: boolean;
+	model?: string;
+	provider?: string;
+	id?: string;
+	retries?: number;
+	invalidRetries?: string;
+	cwd?: string;
+	teamName?: string;
+	defaultToolAutoApprove: boolean;
+	autoApproveOverride?: boolean;
+}
diff --git a/apps/cli/src/utils/usage-cost-display.ts b/apps/cli/src/utils/usage-cost-display.ts
new file mode 100644
index 0000000..b854513
--- /dev/null
+++ b/apps/cli/src/utils/usage-cost-display.ts
@@ -0,0 +1,11 @@
+import { Llms } from "@cline/core";
+
+export function shouldShowCliUsageCost(providerId: string): boolean {
+	return Llms.shouldShowProviderUsageCost(providerId);
+}
+
+export function shouldShowCliUsageCoveredBySubscription(
+	providerId: string,
+): boolean {
+	return Llms.resolveProviderUsageCostDisplay(providerId) === "subscription";
+}
diff --git a/apps/cli/src/utils/worktree.test.ts b/apps/cli/src/utils/worktree.test.ts
new file mode 100644
index 0000000..f681b60
--- /dev/null
+++ b/apps/cli/src/utils/worktree.test.ts
@@ -0,0 +1,166 @@
+import { execFileSync } from "node:child_process";
+import {
+	access,
+	mkdir,
+	mkdtemp,
+	realpath,
+	rm,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { setClineDir } from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createTaskWorktree, getTaskWorktreesHomePath } from "./worktree";
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", ["-C", cwd, ...args], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+}
+
+async function pathExists(targetPath: string): Promise<boolean> {
+	try {
+		await access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+describe("createTaskWorktree", () => {
+	let sandboxRoot: string;
+	let clineDir: string;
+	let repoPath: string;
+	let nonRepoPath: string;
+	let originalClineDir: string | undefined;
+
+	beforeEach(async () => {
+		sandboxRoot = await mkdtemp(path.join(tmpdir(), "cline-sdk-worktree-"));
+		clineDir = path.join(sandboxRoot, ".cline");
+		repoPath = path.join(sandboxRoot, "myrepo");
+		nonRepoPath = path.join(sandboxRoot, "not-a-repo");
+		originalClineDir = process.env.CLINE_DIR;
+		process.env.CLINE_DIR = clineDir;
+		setClineDir(clineDir);
+
+		await writeFile(path.join(sandboxRoot, ".keep"), "");
+		await rm(repoPath, { recursive: true, force: true });
+		await rm(nonRepoPath, { recursive: true, force: true });
+		await mkdir(repoPath, { recursive: true });
+		await mkdir(nonRepoPath, { recursive: true });
+
+		git(repoPath, ["init", "-q", "-b", "main"]);
+		await writeFile(path.join(repoPath, "file.txt"), "hello");
+		git(repoPath, ["add", "."]);
+		git(repoPath, [
+			"-c",
+			"user.email=test@example.com",
+			"-c",
+			"user.name=Test",
+			"commit",
+			"-q",
+			"-m",
+			"init",
+		]);
+	});
+
+	afterEach(async () => {
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR;
+		} else {
+			process.env.CLINE_DIR = originalClineDir;
+		}
+		setClineDir(originalClineDir ?? path.join("~", ".cline"));
+		await rm(sandboxRoot, { recursive: true, force: true });
+	});
+
+	it("places worktrees under ~/.cline/worktrees", () => {
+		expect(getTaskWorktreesHomePath()).toBe(path.join(clineDir, "worktrees"));
+	});
+
+	it("creates a detached worktree at ~/.cline/worktrees/<taskId>/<repoName>", async () => {
+		const result = await createTaskWorktree({
+			cwd: repoPath,
+			taskId: "my-task",
+		});
+
+		expect(result.success).toBe(true);
+		expect(result.taskId).toBe("my-task");
+		expect(result.repoRoot).toBeDefined();
+		expect(result.path).toBeDefined();
+		if (!result.repoRoot || !result.path) {
+			throw new Error("Expected worktree result to include repoRoot and path.");
+		}
+		const worktreePath = result.path;
+
+		expect(await realpath(result.repoRoot)).toBe(await realpath(repoPath));
+		expect(result.path).toBe(
+			path.join(clineDir, "worktrees", "my-task", "myrepo"),
+		);
+		expect(git(worktreePath, ["rev-parse", "--is-inside-work-tree"])).toBe(
+			"true",
+		);
+		expect(git(worktreePath, ["rev-parse", "HEAD"])).toBe(
+			git(repoPath, ["rev-parse", "HEAD"]),
+		);
+		expect(git(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"])).toBe(
+			"HEAD",
+		);
+	});
+
+	it("generates a Kanban-style short taskId when none is provided", async () => {
+		const result = await createTaskWorktree({ cwd: repoPath });
+
+		expect(result.success).toBe(true);
+		expect(result.taskId).toMatch(/^[0-9a-f]{5}$/i);
+		expect(result.taskId).toBeDefined();
+		if (!result.taskId) {
+			throw new Error("Expected generated taskId.");
+		}
+		expect(result.path).toBe(
+			path.join(clineDir, "worktrees", result.taskId, "myrepo"),
+		);
+	});
+
+	it("rejects when cwd is not a git repository", async () => {
+		const result = await createTaskWorktree({ cwd: nonRepoPath });
+
+		expect(result.success).toBe(false);
+		expect(result.message).toMatch(/Not a git repository/);
+	});
+
+	it("cleans up the task directory when git worktree add fails", async () => {
+		const emptyRepoPath = path.join(sandboxRoot, "empty-repo");
+		await mkdir(emptyRepoPath, { recursive: true });
+		git(emptyRepoPath, ["init", "-q", "-b", "main"]);
+
+		const result = await createTaskWorktree({
+			cwd: emptyRepoPath,
+			taskId: "empty",
+		});
+
+		expect(result.success).toBe(false);
+		expect(result.message).toMatch(/Failed to create worktree/);
+		expect(await pathExists(path.join(clineDir, "worktrees", "empty"))).toBe(
+			false,
+		);
+	});
+
+	it("rejects unsafe taskIds", async () => {
+		const traversal = await createTaskWorktree({
+			cwd: repoPath,
+			taskId: "../escape",
+		});
+		const nullByte = await createTaskWorktree({
+			cwd: repoPath,
+			taskId: "safe\0../escape",
+		});
+
+		expect(traversal.success).toBe(false);
+		expect(traversal.message).toMatch(/Invalid worktree id/);
+		expect(nullByte.success).toBe(false);
+		expect(nullByte.message).toMatch(/Invalid worktree id/);
+	});
+});
diff --git a/apps/cli/src/utils/worktree.ts b/apps/cli/src/utils/worktree.ts
new file mode 100644
index 0000000..133dd69
--- /dev/null
+++ b/apps/cli/src/utils/worktree.ts
@@ -0,0 +1,147 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { access, mkdir, rm } from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { resolveClineDir } from "@cline/shared/storage";
+
+const execFileAsync = promisify(execFile);
+const TASK_ID_LENGTH = 5;
+
+export interface CreateTaskWorktreeResult {
+	success: boolean;
+	message: string;
+	path?: string;
+	taskId?: string;
+	repoRoot?: string;
+}
+
+export function getTaskWorktreesHomePath(): string {
+	return path.join(resolveClineDir(), "worktrees");
+}
+
+function getWorkspaceFolderLabelForWorktreePath(repoPath: string): string {
+	const folder = path.basename(repoPath.replace(/[\\/]+$/g, "")) || "workspace";
+	const cleaned = [...folder]
+		.filter((char) => {
+			const code = char.charCodeAt(0);
+			return code >= 32 && code !== 127;
+		})
+		.join("")
+		.trim();
+	return cleaned || "workspace";
+}
+
+function createShortTaskId(): string {
+	return randomUUID().replaceAll("-", "").slice(0, TASK_ID_LENGTH);
+}
+
+async function pathExists(targetPath: string): Promise<boolean> {
+	try {
+		await access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function checkGitInstalled(): Promise<boolean> {
+	try {
+		await execFileAsync("git", ["--version"], { windowsHide: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function getGitRootPath(cwd: string): Promise<string | null> {
+	try {
+		const { stdout } = await execFileAsync(
+			"git",
+			["-C", cwd, "rev-parse", "--show-toplevel"],
+			{ windowsHide: true },
+		);
+		const root = stdout.trim();
+		return root || null;
+	} catch {
+		return null;
+	}
+}
+
+export async function createTaskWorktree(options: {
+	cwd: string;
+	taskId?: string;
+}): Promise<CreateTaskWorktreeResult> {
+	if (!(await checkGitInstalled())) {
+		return {
+			success: false,
+			message: "Git is not installed. --worktree requires git on PATH.",
+		};
+	}
+
+	const repoRoot = await getGitRootPath(options.cwd);
+	if (!repoRoot) {
+		return {
+			success: false,
+			message: `Not a git repository: ${options.cwd}. --worktree requires a git repo.`,
+		};
+	}
+
+	let taskId = options.taskId?.trim() || createShortTaskId();
+	if (
+		taskId.includes("/") ||
+		taskId.includes("\\") ||
+		taskId.includes("..") ||
+		taskId.includes("\0")
+	) {
+		return { success: false, message: `Invalid worktree id: ${taskId}` };
+	}
+
+	const workspaceLabel = getWorkspaceFolderLabelForWorktreePath(repoRoot);
+	let worktreePath = path.join(
+		getTaskWorktreesHomePath(),
+		taskId,
+		workspaceLabel,
+	);
+	if (!options.taskId) {
+		for (
+			let attempt = 0;
+			attempt < 16 && (await pathExists(worktreePath));
+			attempt += 1
+		) {
+			taskId = createShortTaskId();
+			worktreePath = path.join(
+				getTaskWorktreesHomePath(),
+				taskId,
+				workspaceLabel,
+			);
+		}
+	}
+
+	const parentDir = path.dirname(worktreePath);
+	const parentDirExisted = await pathExists(parentDir);
+
+	try {
+		await mkdir(parentDir, { recursive: true });
+		await execFileAsync(
+			"git",
+			["-C", repoRoot, "worktree", "add", "--detach", worktreePath, "HEAD"],
+			{ windowsHide: true },
+		);
+		return {
+			success: true,
+			message: `Worktree created at ${worktreePath}`,
+			path: worktreePath,
+			taskId,
+			repoRoot,
+		};
+	} catch (error) {
+		if (!parentDirExisted) {
+			await rm(parentDir, { recursive: true, force: true }).catch(() => {});
+		}
+		return {
+			success: false,
+			message: `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
+		};
+	}
+}
diff --git a/apps/cli/src/wizards/connect/index.ts b/apps/cli/src/wizards/connect/index.ts
new file mode 100644
index 0000000..bdce326
--- /dev/null
+++ b/apps/cli/src/wizards/connect/index.ts
@@ -0,0 +1,233 @@
+import * as p from "@clack/prompts";
+import { runConnectAdapter } from "../../commands/connect";
+import {
+	PLATFORMS,
+	type PlatformDef,
+	type SecurityDef,
+	shouldIncludeField,
+} from "./platforms";
+
+function isCancel(value: unknown): value is symbol {
+	return p.isCancel(value);
+}
+
+const SENSITIVE_FLAGS = new Set([
+	"-k",
+	"--access-token",
+	"--api-key",
+	"--app-token",
+	"--app-secret",
+	"--bot-token",
+	"--credentials-json",
+	"--signing-secret",
+	"--verify-token",
+	"--webhook-secret",
+]);
+
+function redactCommandArgs(args: string[]): string {
+	const redacted: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i] ?? "";
+		redacted.push(arg);
+		if (SENSITIVE_FLAGS.has(arg) && i + 1 < args.length) {
+			redacted.push("[redacted]");
+			i++;
+		}
+	}
+	return redacted.join(" ");
+}
+
+async function collectFields(platform: PlatformDef): Promise<string[] | null> {
+	const args: string[] = [];
+	const values: Record<string, string> = {};
+
+	for (const field of platform.fields) {
+		if (!shouldIncludeField(field, values)) {
+			continue;
+		}
+		if (field.help) {
+			for (const line of field.help) {
+				p.log.info(line);
+			}
+		}
+
+		const value = field.options
+			? await p.select({
+					message: field.label,
+					options: field.options,
+					initialValue: field.initialValue,
+				})
+			: await p.text({
+					message: field.label,
+					placeholder: field.placeholder,
+					defaultValue: field.initialValue,
+					validate: field.required
+						? (v) => {
+								if (!v?.trim()) return `${field.label} is required`;
+								return undefined;
+							}
+						: undefined,
+				});
+
+		if (isCancel(value)) return null;
+
+		const trimmed = (value as string).trim();
+		values[field.flag] = trimmed;
+		if (trimmed) {
+			args.push(field.flag, trimmed);
+		}
+	}
+
+	return args;
+}
+
+async function collectSecurity(
+	security: SecurityDef,
+): Promise<string[] | null> {
+	const restrict = await p.confirm({
+		message: security.prompt,
+		initialValue: true,
+	});
+
+	if (isCancel(restrict)) return null;
+	if (!restrict) {
+		p.log.warn(
+			"Anyone who finds this bot will be able to run tasks on your machine.",
+		);
+		return [];
+	}
+
+	const values: Record<string, string> = {};
+
+	for (const field of security.fields) {
+		if (field.help) {
+			for (const line of field.help) {
+				p.log.info(line);
+			}
+		}
+
+		const value = await p.text({
+			message: field.label,
+			placeholder: field.placeholder,
+			validate: (v) => {
+				const trimmed = v?.trim();
+				if (!trimmed) return field.requiredMessage;
+				return field.validate?.(trimmed);
+			},
+		});
+
+		if (isCancel(value)) return null;
+
+		values[field.key] = (value as string).trim();
+	}
+
+	const args = security.buildArgs(values);
+	p.log.success("Access restriction enabled");
+	return args;
+}
+
+export async function runConnectWizard(): Promise<number> {
+	p.intro("Connect a messaging platform");
+
+	const platformId = await p.select({
+		message: "Select a platform",
+		options: PLATFORMS.map((pl) => ({
+			value: pl.id,
+			label: pl.name,
+			hint: pl.hint,
+		})),
+	});
+
+	if (isCancel(platformId)) {
+		p.outro("Cancelled");
+		return 0;
+	}
+
+	const platform = PLATFORMS.find((pl) => pl.id === (platformId as string));
+	if (!platform) {
+		p.log.error("Unknown platform");
+		return 1;
+	}
+
+	p.log.step(`Setting up ${platform.name}`);
+
+	if (platform.type === "webhook") {
+		p.log.warn(
+			"This connector requires a publicly accessible URL for webhooks.",
+		);
+	}
+
+	const args = await collectFields(platform);
+	if (!args) {
+		p.outro("Cancelled");
+		return 0;
+	}
+
+	if (platform.security) {
+		const securityArgs = await collectSecurity(platform.security);
+		if (!securityArgs) {
+			p.outro("Cancelled");
+			return 0;
+		}
+		args.push(...securityArgs);
+	}
+
+	const advanced = await p.group({
+		provider: () =>
+			p.text({
+				message: "Provider override",
+				placeholder: "leave empty for default",
+			}),
+		model: () =>
+			p.text({
+				message: "Model override",
+				placeholder: "leave empty for default",
+			}),
+		systemPrompt: () =>
+			p.text({
+				message: "System prompt override",
+				placeholder: "leave empty for default",
+			}),
+		mode: () =>
+			p.select({
+				message: "Agent mode",
+				options: [
+					{ value: "act", label: "Act", hint: "execute tasks" },
+					{ value: "plan", label: "Plan", hint: "plan only" },
+				],
+				initialValue: "act",
+			}),
+	});
+
+	if (isCancel(advanced)) {
+		p.outro("Cancelled");
+		return 0;
+	}
+
+	if (advanced.provider?.trim()) {
+		args.push("--provider", advanced.provider.trim());
+	}
+	if (advanced.model?.trim()) {
+		args.push("--model", advanced.model.trim());
+	}
+	if (advanced.systemPrompt?.trim()) {
+		args.push("--system", advanced.systemPrompt.trim());
+	}
+	if (advanced.mode === "plan") {
+		args.push("--mode", "plan");
+	}
+
+	args.push("-i");
+
+	p.log.success(
+		`Running: cline connect ${platform.id} ${redactCommandArgs(args)}`,
+	);
+	p.outro("Starting connector (Ctrl+C to stop)");
+
+	return runConnectAdapter(platform.id, args, {
+		writeln: (text) => {
+			if (text) console.log(text);
+		},
+		writeErr: (text) => console.error(text),
+	});
+}
diff --git a/apps/cli/src/wizards/connect/platforms.test.ts b/apps/cli/src/wizards/connect/platforms.test.ts
new file mode 100644
index 0000000..a674a22
--- /dev/null
+++ b/apps/cli/src/wizards/connect/platforms.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { PLATFORMS, shouldIncludeField } from "./platforms";
+
+describe("connect wizard platform security fields", () => {
+	it("does not ask Telegram users to re-enter the bot username", () => {
+		const telegram = PLATFORMS.find((platform) => platform.id === "telegram");
+
+		expect(telegram?.fields.map((field) => field.label)).toEqual(["Bot token"]);
+		expect(telegram?.fields.map((field) => field.flag)).toEqual(["-k"]);
+	});
+
+	it("rejects unsafe Telegram and Slack access restriction identifiers", () => {
+		const telegram = PLATFORMS.find((platform) => platform.id === "telegram");
+		const slack = PLATFORMS.find((platform) => platform.id === "slack");
+
+		const telegramUser = telegram?.security?.fields.find(
+			(field) => field.key === "userId",
+		);
+		const slackTeam = slack?.security?.fields.find(
+			(field) => field.key === "teamId",
+		);
+		const slackUser = slack?.security?.fields.find(
+			(field) => field.key === "userId",
+		);
+
+		expect(telegramUser?.validate?.("123456")).toBeUndefined();
+		expect(telegramUser?.validate?.("123; rm -rf /")).toContain("digits");
+		expect(slackTeam?.validate?.("T01ABC123")).toBeUndefined();
+		expect(slackTeam?.validate?.("T01;bad")).toContain("Slack workspace");
+		expect(slackUser?.validate?.("U01ABC123")).toBeUndefined();
+		expect(slackUser?.validate?.("U01$(bad)")).toContain("Slack member");
+	});
+
+	it("uses the Telegram allowed user ID flag for wizard security", () => {
+		const telegram = PLATFORMS.find((platform) => platform.id === "telegram");
+
+		const args = telegram?.security?.buildArgs({
+			userId: "123456",
+		});
+
+		expect(args).toEqual(["--allowed-user-id", "123456"]);
+	});
+
+	it("builds an exact-match Slack authorization hook", () => {
+		const slack = PLATFORMS.find((platform) => platform.id === "slack");
+
+		const args = slack?.security?.buildArgs({
+			teamId: "T01ABC123",
+			userId: "U01ABC123",
+		});
+
+		expect(args).toEqual([
+			"--hook-command",
+			`jq -r ".payload.actor.participantKey" | grep -qx "slack:team:T01ABC123:user:U01ABC123" && echo '{"action":"allow"}' || echo '{"action":"deny"}'`,
+		]);
+	});
+
+	it("asks Slack users for mode-specific setup fields", () => {
+		const slack = PLATFORMS.find((platform) => platform.id === "slack");
+		const fields = slack?.fields ?? [];
+		const webhookValues = { "--base-url": "https://example.test" };
+		const socketValues = { "--base-url": "" };
+
+		expect(fields.map((field) => field.flag)).toEqual([
+			"--bot-token",
+			"--base-url",
+			"--signing-secret",
+			"--app-token",
+		]);
+		expect(
+			fields
+				.filter((field) => shouldIncludeField(field, webhookValues))
+				.map((field) => field.flag),
+		).toEqual(["--bot-token", "--base-url", "--signing-secret"]);
+		expect(
+			fields
+				.filter((field) => shouldIncludeField(field, socketValues))
+				.map((field) => field.flag),
+		).toEqual(["--bot-token", "--base-url", "--app-token"]);
+	});
+});
diff --git a/apps/cli/src/wizards/connect/platforms.ts b/apps/cli/src/wizards/connect/platforms.ts
new file mode 100644
index 0000000..c00f2cd
--- /dev/null
+++ b/apps/cli/src/wizards/connect/platforms.ts
@@ -0,0 +1,16 @@
+import {
+	CONNECTOR_PLATFORMS,
+	shouldIncludeConnectorField,
+} from "@cline/shared";
+
+export type {
+	ConnectorFieldCondition as FieldCondition,
+	ConnectorFieldDef as FieldDef,
+	ConnectorPlatformDef as PlatformDef,
+	ConnectorSecurityDef as SecurityDef,
+	ConnectorSecurityFieldDef as SecurityFieldDef,
+} from "@cline/shared";
+export { CONNECTOR_PLATFORMS, shouldIncludeConnectorField };
+
+export const PLATFORMS = CONNECTOR_PLATFORMS;
+export const shouldIncludeField = shouldIncludeConnectorField;
diff --git a/apps/cli/src/wizards/mcp/index.ts b/apps/cli/src/wizards/mcp/index.ts
new file mode 100644
index 0000000..b95d943
--- /dev/null
+++ b/apps/cli/src/wizards/mcp/index.ts
@@ -0,0 +1,525 @@
+import * as p from "@clack/prompts";
+import { authorizeMcpServerOAuthWithBrowser as authorizeOAuth } from "./oauth";
+import {
+	addServer,
+	clearServerOAuth,
+	getSettingsPath,
+	loadServers,
+	type McpServerEntry,
+	type McpTransport,
+	removeServer,
+	toggleServer,
+	updateServer,
+} from "./settings";
+
+function isCancel(value: unknown): value is symbol {
+	return p.isCancel(value);
+}
+
+function transportLabel(t: McpTransport): string {
+	if (t.type === "stdio") return `stdio: ${t.command}`;
+	return `${t.type}: ${t.url}`;
+}
+
+function statusLabel(entry: McpServerEntry): string {
+	return entry.disabled ? "disabled" : "enabled";
+}
+
+function authLabel(entry: McpServerEntry): string {
+	if (entry.transport.type === "stdio") return "local";
+	if (entry.oauth?.lastError) return "oauth error";
+	const accessToken = entry.oauth?.tokens?.access_token;
+	if (typeof accessToken === "string" && accessToken.trim().length > 0) {
+		return "oauth authorized";
+	}
+	if (entry.oauth && Object.keys(entry.oauth).length > 0) {
+		return "oauth pending";
+	}
+	if (
+		entry.transport.headers &&
+		Object.keys(entry.transport.headers).length > 0
+	) {
+		return "static headers";
+	}
+	return "no auth";
+}
+
+type RemoteAuthMode = "none" | "headers" | "oauth";
+
+interface UrlServerConfig {
+	transport: McpTransport;
+	authMode: RemoteAuthMode;
+}
+
+export interface McpAddDefaults {
+	name?: string;
+	type?: McpTransport["type"];
+	command?: string;
+	url?: string;
+}
+
+export interface RunMcpWizardOptions {
+	initialAction?: "add";
+	addDefaults?: McpAddDefaults;
+	exitAfterInitialAction?: boolean;
+}
+
+export function parseStdioCommand(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: '"' | "'" | undefined;
+	let escaping = false;
+	for (const char of input.trim()) {
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) {
+				quote = undefined;
+			} else {
+				current += char;
+			}
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+	if (escaping) {
+		current += "\\";
+	}
+	if (current) {
+		tokens.push(current);
+	}
+	return tokens;
+}
+
+async function collectStdioTransport(
+	defaultCommand?: string,
+): Promise<McpTransport | null> {
+	p.log.info("Quoted arguments and escaped spaces are supported");
+
+	const command = await p.text({
+		message: "Command to run",
+		placeholder: "npx -y @modelcontextprotocol/server-filesystem",
+		initialValue: defaultCommand,
+		validate: (v) => {
+			if (!v?.trim()) return "Command is required";
+			return undefined;
+		},
+	});
+	if (isCancel(command)) return null;
+
+	const parts = parseStdioCommand(command as string);
+	const cmd = parts[0] ?? "";
+	const args = parts.slice(1);
+
+	const envInput = await p.text({
+		message: "Environment variables (KEY=VALUE, comma-separated)",
+		placeholder: "leave empty for none",
+	});
+	if (isCancel(envInput)) return null;
+
+	let env: Record<string, string> | undefined;
+	const envStr = (envInput as string).trim();
+	if (envStr) {
+		env = {};
+		for (const pair of envStr.split(",")) {
+			const eqIdx = pair.indexOf("=");
+			if (eqIdx > 0) {
+				env[pair.slice(0, eqIdx).trim()] = pair.slice(eqIdx + 1).trim();
+			}
+		}
+	}
+
+	return {
+		type: "stdio",
+		command: cmd,
+		args: args.length > 0 ? args : undefined,
+		env,
+	};
+}
+
+async function collectUrlTransport(
+	type: "sse" | "streamableHttp",
+	defaultUrl?: string,
+): Promise<UrlServerConfig | null> {
+	const url = await p.text({
+		message: "Server URL",
+		placeholder: "https://example.com/mcp",
+		initialValue: defaultUrl,
+		validate: (v) => {
+			if (!v?.trim()) return "URL is required";
+			try {
+				new URL(v.trim());
+			} catch {
+				return "Must be a valid URL";
+			}
+			return undefined;
+		},
+	});
+	if (isCancel(url)) return null;
+
+	const authMode = await p.select({
+		message: "Authentication",
+		options: [
+			{
+				value: "oauth",
+				label: "OAuth",
+				hint: "open a browser and save tokens in MCP settings",
+			},
+			{
+				value: "headers",
+				label: "Static headers",
+				hint: "manually configure request headers",
+			},
+			{
+				value: "none",
+				label: "No auth",
+			},
+		],
+	});
+	if (isCancel(authMode)) return null;
+
+	if (authMode === "oauth" || authMode === "none") {
+		return {
+			transport: { type, url: (url as string).trim() },
+			authMode,
+		};
+	}
+
+	const headersInput = await p.text({
+		message: "Headers (KEY:VALUE, comma-separated)",
+		placeholder: "leave empty for none",
+	});
+	if (isCancel(headersInput)) return null;
+
+	let headers: Record<string, string> | undefined;
+	const headersStr = (headersInput as string).trim();
+	if (headersStr) {
+		headers = {};
+		for (const pair of headersStr.split(",")) {
+			const colonIdx = pair.indexOf(":");
+			if (colonIdx > 0) {
+				headers[pair.slice(0, colonIdx).trim()] = pair
+					.slice(colonIdx + 1)
+					.trim();
+			}
+		}
+	}
+
+	return {
+		transport: { type, url: (url as string).trim(), headers },
+		authMode,
+	};
+}
+
+async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
+	const name = await p.text({
+		message: "Server name",
+		placeholder: "my-mcp-server",
+		initialValue: defaults?.name,
+		validate: (v) => {
+			if (!v?.trim()) return "Name is required";
+			const existing = loadServers();
+			if (existing.some((s) => s.name === v.trim())) {
+				return "A server with this name already exists";
+			}
+			return undefined;
+		},
+	});
+	if (isCancel(name)) return;
+
+	const type = await p.select({
+		message: "Server type",
+		initialValue: defaults?.type,
+		options: [
+			{
+				value: "stdio",
+				label: "Local",
+				hint: "run a command on this machine",
+			},
+			{
+				value: "sse",
+				label: "Remote (SSE)",
+				hint: "connect to a URL via Server-Sent Events",
+			},
+			{
+				value: "streamableHttp",
+				label: "Remote (HTTP)",
+				hint: "connect to a URL via streamable HTTP",
+			},
+		],
+	});
+	if (isCancel(type)) return;
+
+	let transport: McpTransport | null;
+	let authMode: RemoteAuthMode = "none";
+	if (type === "stdio") {
+		transport = await collectStdioTransport(defaults?.command);
+	} else {
+		const config = await collectUrlTransport(
+			type as "sse" | "streamableHttp",
+			defaults?.url,
+		);
+		transport = config?.transport ?? null;
+		authMode = config?.authMode ?? "none";
+	}
+	if (!transport) return;
+
+	const serverName = (name as string).trim();
+	addServer(serverName, transport);
+	if (authMode !== "oauth") {
+		clearServerOAuth(serverName);
+	}
+	p.log.success(`Added "${serverName}" to ${getSettingsPath()}`);
+	if (authMode === "oauth") {
+		await authorizeOAuth(serverName);
+	}
+}
+
+async function actionList(): Promise<void> {
+	const servers = loadServers();
+	if (servers.length === 0) {
+		p.log.info("No MCP servers configured");
+		p.log.info(`Settings file: ${getSettingsPath()}`);
+		return;
+	}
+	for (const s of servers) {
+		const status = s.disabled ? " (disabled)" : "";
+		p.log.info(`${s.name}${status}`);
+		p.log.message(`  ${transportLabel(s.transport)}`);
+		p.log.message(`  auth: ${authLabel(s)}`);
+		if (s.oauth?.lastError) {
+			p.log.message(`  last OAuth error: ${s.oauth.lastError}`);
+		}
+	}
+	p.log.message(`\nSettings file: ${getSettingsPath()}`);
+}
+
+function pickServer(
+	servers: McpServerEntry[],
+	message: string,
+): Promise<string | null> {
+	if (servers.length === 0) {
+		p.log.warn("No MCP servers configured");
+		return Promise.resolve(null);
+	}
+	return p
+		.select({
+			message,
+			options: servers.map((s) => ({
+				value: s.name,
+				label: s.name,
+				hint: `${s.transport.type} [${statusLabel(s)}, ${authLabel(s)}]`,
+			})),
+		})
+		.then((v) => (isCancel(v) ? null : (v as string)));
+}
+
+async function pickRemoteServer(message: string): Promise<string | null> {
+	const servers = loadServers().filter(
+		(server) => server.transport.type !== "stdio",
+	);
+	return pickServer(servers, message);
+}
+
+async function actionEdit(): Promise<void> {
+	const servers = loadServers();
+	const name = await pickServer(servers, "Select server to edit");
+	if (!name) return;
+
+	const current = servers.find((s) => s.name === name);
+	if (!current) return;
+
+	p.log.step(`Editing ${name} (${current.transport.type})`);
+
+	const type = await p.select({
+		message: "Server type",
+		initialValue: current.transport.type,
+		options: [
+			{
+				value: "stdio",
+				label: "Local",
+				hint: "run a command",
+			},
+			{
+				value: "sse",
+				label: "Remote (SSE)",
+				hint: "Server-Sent Events",
+			},
+			{
+				value: "streamableHttp",
+				label: "Remote (HTTP)",
+				hint: "streamable HTTP",
+			},
+		],
+	});
+	if (isCancel(type)) return;
+
+	let transport: McpTransport | null;
+	let authMode: RemoteAuthMode = "none";
+	if (type === "stdio") {
+		transport = await collectStdioTransport();
+	} else {
+		const config = await collectUrlTransport(type as "sse" | "streamableHttp");
+		transport = config?.transport ?? null;
+		authMode = config?.authMode ?? "none";
+	}
+	if (!transport) return;
+
+	updateServer(name, transport);
+	if (type === "stdio" || authMode !== "oauth") {
+		clearServerOAuth(name);
+	}
+	p.log.success(`Updated "${name}"`);
+	if (authMode === "oauth") {
+		await authorizeOAuth(name);
+	}
+}
+
+async function actionDelete(): Promise<void> {
+	const servers = loadServers();
+	const name = await pickServer(servers, "Select server to delete");
+	if (!name) return;
+
+	const confirm = await p.confirm({
+		message: `Delete "${name}"?`,
+		initialValue: false,
+	});
+	if (isCancel(confirm) || !confirm) return;
+
+	if (removeServer(name)) {
+		p.log.success(`Deleted "${name}"`);
+	} else {
+		p.log.error("Failed to delete server");
+	}
+}
+
+async function actionToggle(): Promise<void> {
+	const servers = loadServers();
+	const name = await pickServer(servers, "Select server to enable/disable");
+	if (!name) return;
+
+	const current = servers.find((s) => s.name === name);
+	if (!current) return;
+
+	const newDisabled = !current.disabled;
+	toggleServer(name, newDisabled);
+	p.log.success(`${name} is now ${newDisabled ? "disabled" : "enabled"}`);
+}
+
+async function actionAuthorizeOAuth(): Promise<void> {
+	const name = await pickRemoteServer("Select remote server to authorize");
+	if (!name) return;
+	await authorizeOAuth(name);
+}
+
+export async function runMcpWizard(
+	options: RunMcpWizardOptions = {},
+): Promise<number> {
+	p.intro("MCP Servers");
+
+	if (options.initialAction === "add") {
+		let initialActionExitCode = 0;
+		try {
+			await actionAdd(options.addDefaults);
+		} catch (err) {
+			initialActionExitCode = 1;
+			p.log.error(err instanceof Error ? err.message : String(err));
+		}
+		if (options.exitAfterInitialAction === true) {
+			p.outro("Done");
+			return initialActionExitCode;
+		}
+	}
+
+	let keepGoing = true;
+	while (keepGoing) {
+		const action = await p.select({
+			message: "What would you like to do?",
+			options: [
+				{
+					value: "list",
+					label: "List servers",
+					hint: "view configured MCP servers",
+				},
+				{
+					value: "add",
+					label: "Add server",
+					hint: "configure a new MCP server",
+				},
+				{
+					value: "edit",
+					label: "Edit server",
+					hint: "change server configuration",
+				},
+				{
+					value: "toggle",
+					label: "Enable/disable server",
+				},
+				{
+					value: "authorize",
+					label: "Authorize OAuth",
+					hint: "run or rerun browser authorization for a remote server",
+				},
+				{
+					value: "delete",
+					label: "Delete server",
+				},
+				{
+					value: "exit",
+					label: "Exit",
+				},
+			],
+		});
+
+		if (isCancel(action) || action === "exit") {
+			keepGoing = false;
+			continue;
+		}
+
+		try {
+			switch (action) {
+				case "list":
+					await actionList();
+					break;
+				case "add":
+					await actionAdd();
+					break;
+				case "edit":
+					await actionEdit();
+					break;
+				case "toggle":
+					await actionToggle();
+					break;
+				case "authorize":
+					await actionAuthorizeOAuth();
+					break;
+				case "delete":
+					await actionDelete();
+					break;
+			}
+		} catch (err) {
+			p.log.error(err instanceof Error ? err.message : String(err));
+		}
+	}
+
+	p.outro("Done");
+	return 0;
+}
diff --git a/apps/cli/src/wizards/mcp/oauth.ts b/apps/cli/src/wizards/mcp/oauth.ts
new file mode 100644
index 0000000..a4310ba
--- /dev/null
+++ b/apps/cli/src/wizards/mcp/oauth.ts
@@ -0,0 +1,45 @@
+import * as p from "@clack/prompts";
+import {
+	authorizeMcpServerOAuth,
+	resolveDefaultMcpSettingsPath,
+} from "@cline/core";
+import open from "open";
+
+function toErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const message = error.message.trim();
+		if (message.length > 0) {
+			return message;
+		}
+	}
+	return String(error);
+}
+
+export async function authorizeMcpServerOAuthWithBrowser(
+	name: string,
+	options: { throwOnError?: boolean } = {},
+): Promise<void> {
+	p.log.info("Opening browser for MCP OAuth authorization");
+	try {
+		const result = await authorizeMcpServerOAuth({
+			serverName: name,
+			filePath: resolveDefaultMcpSettingsPath(),
+			openUrl: async (url) => {
+				p.log.message(`Authorization URL: ${url}`);
+				await open(url, { wait: false });
+			},
+			onServerListening: (info) => {
+				p.log.message(`Waiting for OAuth callback at ${info.callbackUrl}`);
+			},
+		});
+		p.log.success(result.message);
+	} catch (error) {
+		if (options.throwOnError === true) {
+			throw error instanceof Error ? error : new Error(toErrorMessage(error));
+		}
+		p.log.error(`OAuth authorization failed: ${toErrorMessage(error)}`);
+		p.log.warn(
+			`Server "${name}" is still saved. Choose "Authorize OAuth" to retry.`,
+		);
+	}
+}
diff --git a/apps/cli/src/wizards/mcp/settings.test.ts b/apps/cli/src/wizards/mcp/settings.test.ts
new file mode 100644
index 0000000..e4facfc
--- /dev/null
+++ b/apps/cli/src/wizards/mcp/settings.test.ts
@@ -0,0 +1,142 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { parseStdioCommand } from "./index";
+import {
+	addServer,
+	clearServerOAuth,
+	loadServers,
+	removeServer,
+} from "./settings";
+
+describe("MCP wizard settings", () => {
+	const originalSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+	const tempDirs: string[] = [];
+
+	afterEach(async () => {
+		process.env.CLINE_MCP_SETTINGS_PATH = originalSettingsPath;
+		await Promise.all(
+			tempDirs.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempDirs.length = 0;
+	});
+
+	async function useTempSettingsPath(): Promise<string> {
+		const dir = await mkdtemp(join(tmpdir(), "cline-mcp-settings-"));
+		tempDirs.push(dir);
+		const settingsPath = join(dir, "cline_mcp_settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		return settingsPath;
+	}
+
+	it("preserves unrelated top-level settings when writing servers", async () => {
+		const settingsPath = await useTempSettingsPath();
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					otherSetting: true,
+					mcpServers: {
+						existing: { transport: { type: "stdio", command: "node" } },
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		addServer("added", { type: "stdio", command: "npx", args: ["server"] });
+		removeServer("existing");
+
+		const parsed = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			otherSetting?: boolean;
+			mcpServers?: Record<string, unknown>;
+		};
+		expect(parsed.otherSetting).toBe(true);
+		expect(Object.keys(parsed.mcpServers ?? {})).toEqual(["added"]);
+	});
+
+	it("creates the settings file when adding a server to a missing path", async () => {
+		const settingsPath = await useTempSettingsPath();
+
+		addServer("added", { type: "stdio", command: "npx", args: ["server"] });
+
+		const parsed = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, unknown>;
+		};
+		expect(Object.keys(parsed.mcpServers ?? {})).toEqual(["added"]);
+	});
+
+	it("parses quoted stdio command arguments", () => {
+		expect(
+			parseStdioCommand('npx -y "@scope/server name" --root "my dir"'),
+		).toEqual(["npx", "-y", "@scope/server name", "--root", "my dir"]);
+	});
+
+	it("loads and clears OAuth state stored on a server entry", async () => {
+		const settingsPath = await useTempSettingsPath();
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					mcpServers: {
+						linear: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.linear.app/mcp",
+							},
+							oauth: {
+								tokens: {
+									access_token: "oauth-token",
+								},
+								lastAuthenticatedAt: 123,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		expect(loadServers()[0]?.oauth?.tokens?.access_token).toBe("oauth-token");
+
+		clearServerOAuth("linear");
+
+		const parsed = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: {
+				linear?: {
+					oauth?: unknown;
+				};
+			};
+		};
+		expect(parsed.mcpServers?.linear?.oauth).toBeUndefined();
+	});
+
+	it("does not create an empty server when clearing OAuth for a missing name", async () => {
+		const settingsPath = await useTempSettingsPath();
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					mcpServers: {
+						linear: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.linear.app/mcp",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+		const before = await readFile(settingsPath, "utf8");
+
+		clearServerOAuth("missing");
+
+		await expect(readFile(settingsPath, "utf8")).resolves.toBe(before);
+	});
+});
diff --git a/apps/cli/src/wizards/mcp/settings.ts b/apps/cli/src/wizards/mcp/settings.ts
new file mode 100644
index 0000000..aaadd3d
--- /dev/null
+++ b/apps/cli/src/wizards/mcp/settings.ts
@@ -0,0 +1,164 @@
+import { existsSync, readFileSync } from "node:fs";
+import {
+	type McpServerOAuthState,
+	McpSettingsUpdateSkippedError,
+	resolveDefaultMcpSettingsPath,
+	updateMcpSettingsFileSync,
+} from "@cline/core";
+
+export interface McpServerEntry {
+	name: string;
+	transport: McpTransport;
+	disabled?: boolean;
+	oauth?: McpServerOAuthState;
+}
+
+export type McpTransport =
+	| {
+			type: "stdio";
+			command: string;
+			args?: string[];
+			env?: Record<string, string>;
+	  }
+	| { type: "sse"; url: string; headers?: Record<string, string> }
+	| { type: "streamableHttp"; url: string; headers?: Record<string, string> };
+
+export function getSettingsPath(): string {
+	return resolveDefaultMcpSettingsPath();
+}
+
+export function loadServers(): McpServerEntry[] {
+	const path = getSettingsPath();
+	if (!existsSync(path)) return [];
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw) as {
+			mcpServers?: Record<string, unknown>;
+		};
+		const servers = parsed.mcpServers ?? {};
+		return Object.entries(servers).map(([name, value]) => {
+			const entry = value as Record<string, unknown>;
+			const transport = (entry.transport ?? entry) as McpTransport;
+			const oauth =
+				entry.oauth &&
+				typeof entry.oauth === "object" &&
+				!Array.isArray(entry.oauth)
+					? (entry.oauth as McpServerOAuthState)
+					: undefined;
+			return {
+				name,
+				transport,
+				disabled: entry.disabled === true,
+				oauth,
+			};
+		});
+	} catch {
+		return [];
+	}
+}
+
+function getOwnServerRecord(
+	servers: Record<string, unknown>,
+	name: string,
+): Record<string, unknown> | undefined {
+	if (!Object.hasOwn(servers, name)) {
+		return undefined;
+	}
+	const value = servers[name];
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return value as Record<string, unknown>;
+}
+
+/**
+ * Mutate the MCP settings file through @cline/core's locked read-update-write
+ * helper. The mutator must be synchronous and pure; the helper may call it more
+ * than once to verify deterministic output. Throw McpSettingsUpdateSkippedError
+ * for normal no-op cases instead of returning a boolean that callers can ignore.
+ */
+function mutateServers(
+	mutate: (servers: Record<string, unknown>) => void,
+): void {
+	updateMcpSettingsFileSync(getSettingsPath(), (settings) => {
+		const serversValue = settings.mcpServers;
+		const servers =
+			serversValue &&
+			typeof serversValue === "object" &&
+			!Array.isArray(serversValue)
+				? { ...(serversValue as Record<string, unknown>) }
+				: {};
+		mutate(servers);
+		settings.mcpServers = servers;
+	});
+}
+
+export function addServer(name: string, transport: McpTransport): void {
+	mutateServers((servers) => {
+		servers[name] = { transport };
+	});
+}
+
+export function removeServer(name: string): boolean {
+	try {
+		mutateServers((servers) => {
+			if (!(name in servers)) {
+				throw new McpSettingsUpdateSkippedError(
+					`MCP server not found: ${name}`,
+				);
+			}
+			delete servers[name];
+		});
+		return true;
+	} catch (error) {
+		if (error instanceof McpSettingsUpdateSkippedError) {
+			return false;
+		}
+		throw error;
+	}
+}
+
+export function updateServer(name: string, transport: McpTransport): void {
+	mutateServers((servers) => {
+		const existing =
+			servers[name] && typeof servers[name] === "object"
+				? (servers[name] as Record<string, unknown>)
+				: {};
+		servers[name] = { ...existing, transport };
+	});
+}
+
+export function clearServerOAuth(name: string): void {
+	try {
+		mutateServers((servers) => {
+			const existing = getOwnServerRecord(servers, name);
+			if (!existing) {
+				throw new McpSettingsUpdateSkippedError(
+					`MCP server not found: ${name}`,
+				);
+			}
+			delete existing.oauth;
+			servers[name] = existing;
+		});
+	} catch (error) {
+		if (error instanceof McpSettingsUpdateSkippedError) {
+			return;
+		}
+		throw error;
+	}
+}
+
+export function toggleServer(name: string, disabled: boolean): void {
+	mutateServers((servers) => {
+		const existing =
+			servers[name] && typeof servers[name] === "object"
+				? (servers[name] as Record<string, unknown>)
+				: {};
+		if (disabled) {
+			existing.disabled = true;
+		} else {
+			delete existing.disabled;
+		}
+		servers[name] = existing;
+	});
+}
diff --git a/apps/cli/src/wizards/schedule/cron-presets.ts b/apps/cli/src/wizards/schedule/cron-presets.ts
new file mode 100644
index 0000000..a1596c6
--- /dev/null
+++ b/apps/cli/src/wizards/schedule/cron-presets.ts
@@ -0,0 +1,58 @@
+export interface CronPreset {
+	label: string;
+	value: string;
+	hint: string;
+}
+
+export const CRON_PRESETS: CronPreset[] = [
+	{
+		label: "Every 5 minutes",
+		value: "*/5 * * * *",
+		hint: "*/5 * * * *",
+	},
+	{
+		label: "Every 15 minutes",
+		value: "*/15 * * * *",
+		hint: "*/15 * * * *",
+	},
+	{
+		label: "Every hour",
+		value: "0 * * * *",
+		hint: "0 * * * *",
+	},
+	{
+		label: "Every 6 hours",
+		value: "0 */6 * * *",
+		hint: "0 */6 * * *",
+	},
+	{
+		label: "Daily at midnight",
+		value: "0 0 * * *",
+		hint: "0 0 * * *",
+	},
+	{
+		label: "Daily at 9am",
+		value: "0 9 * * *",
+		hint: "0 9 * * *",
+	},
+	{
+		label: "Every weekday at 9am",
+		value: "0 9 * * 1-5",
+		hint: "0 9 * * 1-5",
+	},
+	{
+		label: "Every Monday at 9am",
+		value: "0 9 * * 1",
+		hint: "0 9 * * 1",
+	},
+	{
+		label: "First of every month",
+		value: "0 0 1 * *",
+		hint: "0 0 1 * *",
+	},
+	{
+		label: "Custom",
+		value: "__custom__",
+		hint: "enter your own cron expression",
+	},
+];
diff --git a/apps/cli/src/wizards/schedule/index.ts b/apps/cli/src/wizards/schedule/index.ts
new file mode 100644
index 0000000..7272c2c
--- /dev/null
+++ b/apps/cli/src/wizards/schedule/index.ts
@@ -0,0 +1,521 @@
+import * as p from "@clack/prompts";
+import {
+	ensureSchedulerHub,
+	type HubScheduleClient,
+} from "../../commands/schedule/client";
+import { resolveAddress } from "../../commands/schedule/common";
+import { CRON_PRESETS } from "./cron-presets";
+
+function isCancel(value: unknown): value is symbol {
+	return p.isCancel(value);
+}
+
+interface ScheduleRecord {
+	scheduleId: string;
+	name: string;
+	cronPattern: string;
+	prompt: string;
+	enabled: boolean;
+	nextRunAt?: number;
+}
+
+interface ExecutionRecord {
+	executionId: string;
+	scheduleId: string;
+	status: string;
+	triggeredAt?: number;
+	startedAt?: number;
+	endedAt?: number;
+	tokensUsed?: number;
+	costUsd?: number;
+}
+
+interface ScheduleStats {
+	totalRuns: number;
+	successRate: number;
+	avgDurationSeconds: number;
+	lastFailure?: { errorMessage?: string };
+}
+
+interface UpcomingRun {
+	name: string;
+	nextRunAt: number;
+}
+
+function formatSchedule(s: ScheduleRecord): string {
+	const status = s.enabled ? "enabled" : "paused";
+	const next = s.nextRunAt
+		? `next: ${new Date(s.nextRunAt).toLocaleString()}`
+		: "";
+	return `${s.name} (${s.cronPattern}) [${status}]${next ? ` ${next}` : ""}`;
+}
+
+async function pickSchedule(
+	client: HubScheduleClient,
+	message: string,
+): Promise<string | null> {
+	const schedules = (await client.listSchedules({})) as ScheduleRecord[];
+	if (!schedules || schedules.length === 0) {
+		p.log.warn("No schedules found");
+		return null;
+	}
+
+	const choice = await p.select({
+		message,
+		options: schedules.map((s) => ({
+			value: s.scheduleId,
+			label: s.name,
+			hint: `${s.cronPattern} [${s.enabled ? "enabled" : "paused"}]`,
+		})),
+	});
+
+	if (isCancel(choice)) return null;
+	return choice as string;
+}
+
+async function actionCreate(client: HubScheduleClient): Promise<void> {
+	const name = await p.text({
+		message: "Schedule name",
+		placeholder: "nightly-cleanup",
+		validate: (v) => {
+			if (!v?.trim()) return "Name is required";
+			return undefined;
+		},
+	});
+	if (isCancel(name)) return;
+
+	const cronChoice = await p.select({
+		message: "How often should it run?",
+		options: CRON_PRESETS.map((preset) => ({
+			value: preset.value,
+			label: preset.label,
+			hint: preset.hint,
+		})),
+	});
+	if (isCancel(cronChoice)) return;
+
+	let cronPattern = cronChoice as string;
+	if (cronPattern === "__custom__") {
+		const custom = await p.text({
+			message: "Cron expression (minute hour day month weekday)",
+			placeholder: "0 */6 * * *",
+			validate: (v) => {
+				if (!v?.trim()) return "Cron expression is required";
+				const parts = v.trim().split(/\s+/);
+				if (parts.length !== 5)
+					return "Must be 5 fields: minute hour day month weekday";
+				return undefined;
+			},
+		});
+		if (isCancel(custom)) return;
+		cronPattern = (custom as string).trim();
+	}
+
+	const prompt = await p.text({
+		message: "What should Cline do?",
+		placeholder: "Review open PRs and post summaries",
+		validate: (v) => {
+			if (!v?.trim()) return "Prompt is required";
+			return undefined;
+		},
+	});
+	if (isCancel(prompt)) return;
+
+	const workspace = await p.text({
+		message: "Workspace path",
+		placeholder: process.cwd(),
+		initialValue: process.cwd(),
+		validate: (v) => {
+			if (!v?.trim()) return "Workspace path is required";
+			return undefined;
+		},
+	});
+	if (isCancel(workspace)) return;
+
+	const mode = await p.select({
+		message: "Agent mode",
+		options: [
+			{ value: "act", label: "Act", hint: "execute tasks" },
+			{ value: "plan", label: "Plan", hint: "plan only" },
+		],
+		initialValue: "act",
+	});
+	if (isCancel(mode)) return;
+
+	const wantAdvanced = await p.confirm({
+		message: "Configure advanced options?",
+		initialValue: false,
+	});
+	if (isCancel(wantAdvanced)) return;
+
+	let provider: string | undefined;
+	let model: string | undefined;
+	let systemPrompt: string | undefined;
+	let timeout: number | undefined;
+	let maxIterations: number | undefined;
+	let tags: string[] | undefined;
+
+	if (wantAdvanced) {
+		const advanced = await p.group({
+			provider: () =>
+				p.text({
+					message: "Provider",
+					placeholder: "leave empty for default",
+				}),
+			model: () =>
+				p.text({
+					message: "Model",
+					placeholder: "leave empty for default",
+				}),
+			systemPrompt: () =>
+				p.text({
+					message: "System prompt override",
+					placeholder: "leave empty for default",
+				}),
+			timeout: () =>
+				p.text({
+					message: "Timeout in seconds",
+					placeholder: "leave empty for no timeout",
+				}),
+			maxIterations: () =>
+				p.text({
+					message: "Max iterations",
+					placeholder: "leave empty for unlimited",
+				}),
+			tags: () =>
+				p.text({
+					message: "Tags (comma-separated)",
+					placeholder: "cleanup, nightly",
+				}),
+		});
+		if (isCancel(advanced)) return;
+
+		provider = advanced.provider?.trim() || undefined;
+		model = advanced.model?.trim() || undefined;
+		systemPrompt = advanced.systemPrompt?.trim() || undefined;
+		if (advanced.timeout?.trim()) {
+			const n = Number.parseInt(advanced.timeout.trim(), 10);
+			if (n > 0) timeout = n;
+		}
+		if (advanced.maxIterations?.trim()) {
+			const n = Number.parseInt(advanced.maxIterations.trim(), 10);
+			if (n > 0) maxIterations = n;
+		}
+		if (advanced.tags?.trim()) {
+			tags = advanced.tags
+				.split(",")
+				.map((t) => t.trim())
+				.filter(Boolean);
+		}
+	}
+
+	const created = (await client.createSchedule({
+		name: (name as string).trim(),
+		cronPattern,
+		prompt: (prompt as string).trim(),
+		provider: provider ?? "cline",
+		model: model ?? "openai/gpt-5.3-codex",
+		mode: (mode as string) === "plan" ? "plan" : "act",
+		workspaceRoot: (workspace as string).trim(),
+		systemPrompt,
+		maxIterations,
+		timeoutSeconds: timeout,
+		maxParallel: 1,
+		enabled: true,
+		tags,
+	})) as ScheduleRecord | undefined;
+
+	if (!created) {
+		p.log.error("Failed to create schedule");
+		return;
+	}
+
+	p.log.success(`Created: ${created.name} (${created.scheduleId})`);
+	if (created.nextRunAt) {
+		p.log.info(`Next run: ${new Date(created.nextRunAt).toLocaleString()}`);
+	}
+}
+
+async function actionList(client: HubScheduleClient): Promise<void> {
+	const schedules = (await client.listSchedules({})) as ScheduleRecord[];
+	if (!schedules || schedules.length === 0) {
+		p.log.info("No schedules configured");
+		return;
+	}
+	for (const s of schedules) {
+		p.log.info(formatSchedule(s));
+		p.log.message(`  ID: ${s.scheduleId}`);
+		p.log.message(
+			`  Prompt: ${s.prompt.slice(0, 80)}${s.prompt.length > 80 ? "..." : ""}`,
+		);
+	}
+}
+
+async function actionPause(client: HubScheduleClient): Promise<void> {
+	const id = await pickSchedule(client, "Select schedule to pause");
+	if (!id) return;
+	const result = (await client.pauseSchedule(id)) as ScheduleRecord | undefined;
+	if (result) {
+		p.log.success(`Paused: ${result.name}`);
+	} else {
+		p.log.error("Failed to pause schedule");
+	}
+}
+
+async function actionResume(client: HubScheduleClient): Promise<void> {
+	const id = await pickSchedule(client, "Select schedule to resume");
+	if (!id) return;
+	const result = (await client.resumeSchedule(id)) as
+		| ScheduleRecord
+		| undefined;
+	if (result) {
+		p.log.success(`Resumed: ${result.name}`);
+		if (result.nextRunAt) {
+			p.log.info(`Next run: ${new Date(result.nextRunAt).toLocaleString()}`);
+		}
+	} else {
+		p.log.error("Failed to resume schedule");
+	}
+}
+
+async function actionTrigger(client: HubScheduleClient): Promise<void> {
+	const id = await pickSchedule(client, "Select schedule to trigger now");
+	if (!id) return;
+	const execution = (await client.triggerScheduleNow(id)) as
+		| ExecutionRecord
+		| undefined;
+	if (execution) {
+		p.log.success(`Triggered: ${execution.executionId}`);
+	} else {
+		p.log.error("Failed to trigger schedule");
+	}
+}
+
+async function actionDelete(client: HubScheduleClient): Promise<void> {
+	const id = await pickSchedule(client, "Select schedule to delete");
+	if (!id) return;
+
+	const confirm = await p.confirm({
+		message: "Are you sure you want to delete this schedule?",
+		initialValue: false,
+	});
+	if (isCancel(confirm) || !confirm) return;
+
+	const deleted = await client.deleteSchedule(id);
+	if (deleted) {
+		p.log.success("Schedule deleted");
+	} else {
+		p.log.error("Failed to delete schedule");
+	}
+}
+
+async function actionHistory(client: HubScheduleClient): Promise<void> {
+	const id = await pickSchedule(client, "Select schedule to view history");
+	if (!id) return;
+
+	const executions = (await client.listScheduleExecutions({
+		scheduleId: id,
+		limit: 20,
+	})) as ExecutionRecord[];
+	if (!executions || executions.length === 0) {
+		p.log.info("No execution history");
+		return;
+	}
+	for (const exec of executions) {
+		const duration =
+			exec.startedAt && exec.endedAt
+				? `${((new Date(exec.endedAt).getTime() - new Date(exec.startedAt).getTime()) / 1000).toFixed(0)}s`
+				: "";
+		const tokens = exec.tokensUsed != null ? `${exec.tokensUsed} tokens` : "";
+		const cost = exec.costUsd != null ? `$${exec.costUsd.toFixed(4)}` : "";
+		const details = [duration, tokens, cost].filter(Boolean).join(" / ");
+		const time = exec.triggeredAt
+			? new Date(exec.triggeredAt).toLocaleString()
+			: "";
+		p.log.info(`${time} [${exec.status}]${details ? ` ${details}` : ""}`);
+	}
+}
+
+async function actionStats(client: HubScheduleClient): Promise<void> {
+	const id = await pickSchedule(client, "Select schedule to view stats");
+	if (!id) return;
+
+	const stats = (await client.getScheduleStats(id)) as ScheduleStats;
+	p.log.info(`Total runs: ${stats.totalRuns}`);
+	p.log.info(`Success rate: ${(stats.successRate * 100).toFixed(1)}%`);
+	p.log.info(`Avg duration: ${stats.avgDurationSeconds.toFixed(0)}s`);
+	if (stats.lastFailure) {
+		p.log.warn(
+			`Last failure: ${stats.lastFailure.errorMessage ?? "unknown error"}`,
+		);
+	}
+}
+
+async function actionActive(client: HubScheduleClient): Promise<void> {
+	const active = (await client.getActiveScheduledExecutions()) as
+		| ExecutionRecord[]
+		| undefined;
+	if (!active || active.length === 0) {
+		p.log.info("No active executions");
+		return;
+	}
+	for (const exec of active) {
+		const started = exec.startedAt
+			? new Date(exec.startedAt).toLocaleString()
+			: "";
+		p.log.info(
+			`${exec.executionId} (schedule: ${exec.scheduleId}) started ${started}`,
+		);
+	}
+}
+
+async function actionUpcoming(client: HubScheduleClient): Promise<void> {
+	const upcoming = (await client.getUpcomingScheduledRuns(10)) as
+		| UpcomingRun[]
+		| undefined;
+	if (!upcoming || upcoming.length === 0) {
+		p.log.info("No upcoming runs");
+		return;
+	}
+	for (const run of upcoming) {
+		const time = new Date(run.nextRunAt).toLocaleString();
+		p.log.info(`${run.name} - ${time}`);
+	}
+}
+
+export async function runScheduleWizard(): Promise<number> {
+	p.intro("Scheduled Tasks");
+
+	const s = p.spinner();
+	s.start("Connecting to hub server...");
+
+	const address = resolveAddress(process.env.CLINE_HUB_ADDRESS);
+	const ensured = await ensureSchedulerHub(address, process.cwd(), {
+		writeln: (text?: string) => {
+			process.stdout.write(`${text ?? ""}\n`);
+		},
+		writeErr: (text: string) => {
+			process.stderr.write(`${text}\n`);
+		},
+	});
+	if (!ensured.ok) {
+		s.stop("Failed to connect to hub server");
+		p.log.error(
+			"Schedules require the hub server. Start it with: cline hub start",
+		);
+		p.outro("Failed");
+		return 1;
+	}
+	s.stop("Connected");
+
+	const client = ensured.client;
+
+	try {
+		let keepGoing = true;
+		while (keepGoing) {
+			const action = await p.select({
+				message: "What would you like to do?",
+				options: [
+					{
+						value: "create",
+						label: "Create new schedule",
+						hint: "set up a recurring task",
+					},
+					{
+						value: "list",
+						label: "List schedules",
+						hint: "view all configured schedules",
+					},
+					{
+						value: "upcoming",
+						label: "Upcoming runs",
+						hint: "see what runs next",
+					},
+					{
+						value: "active",
+						label: "Active executions",
+						hint: "see what is running now",
+					},
+					{
+						value: "trigger",
+						label: "Trigger now",
+						hint: "run a schedule immediately",
+					},
+					{
+						value: "pause",
+						label: "Pause schedule",
+					},
+					{
+						value: "resume",
+						label: "Resume schedule",
+					},
+					{
+						value: "history",
+						label: "Execution history",
+						hint: "view past runs",
+					},
+					{
+						value: "stats",
+						label: "Statistics",
+						hint: "success rate, duration, etc.",
+					},
+					{
+						value: "delete",
+						label: "Delete schedule",
+					},
+					{
+						value: "exit",
+						label: "Exit",
+					},
+				],
+			});
+
+			if (isCancel(action) || action === "exit") {
+				keepGoing = false;
+				continue;
+			}
+
+			try {
+				switch (action) {
+					case "create":
+						await actionCreate(client);
+						break;
+					case "list":
+						await actionList(client);
+						break;
+					case "pause":
+						await actionPause(client);
+						break;
+					case "resume":
+						await actionResume(client);
+						break;
+					case "trigger":
+						await actionTrigger(client);
+						break;
+					case "delete":
+						await actionDelete(client);
+						break;
+					case "history":
+						await actionHistory(client);
+						break;
+					case "stats":
+						await actionStats(client);
+						break;
+					case "active":
+						await actionActive(client);
+						break;
+					case "upcoming":
+						await actionUpcoming(client);
+						break;
+				}
+			} catch (err) {
+				p.log.error(err instanceof Error ? err.message : String(err));
+			}
+		}
+
+		p.outro("Done");
+		return 0;
+	} finally {
+		client.close();
+	}
+}
diff --git a/apps/cli/tsconfig.json b/apps/cli/tsconfig.json
new file mode 100644
index 0000000..97cb17d
--- /dev/null
+++ b/apps/cli/tsconfig.json
@@ -0,0 +1,23 @@
+{
+	"extends": "../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"jsx": "react-jsx",
+		"jsxImportSource": "@opentui/react",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}
diff --git a/apps/cli/vitest.config.ts b/apps/cli/vitest.config.ts
new file mode 100644
index 0000000..bbcdf7e
--- /dev/null
+++ b/apps/cli/vitest.config.ts
@@ -0,0 +1,62 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+const rootDir = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+	resolve: {
+		alias: [
+			{
+				find: /^@cline\/core\/telemetry$/,
+				replacement: resolve(
+					rootDir,
+					"../../sdk/packages/core/src/services/telemetry/index.ts",
+				),
+			},
+			{
+				find: /^@cline\/core$/,
+				replacement: resolve(rootDir, "../../sdk/packages/core/src/index.ts"),
+			},
+			{
+				find: /^@cline\/core\/(.+)$/,
+				replacement: resolve(rootDir, "../../sdk/packages/core/src/$1"),
+			},
+			{
+				find: /^@cline\/llms$/,
+				replacement: resolve(rootDir, "../../sdk/packages/llms/src/index.ts"),
+			},
+			{
+				find: /^@cline\/llms\/(.+)$/,
+				replacement: resolve(rootDir, "../../sdk/packages/llms/src/$1"),
+			},
+			{
+				find: /^@cline\/shared\/(.+)$/,
+				replacement: resolve(rootDir, "../../sdk/packages/shared/src/$1"),
+			},
+			{
+				find: /^@cline\/agents$/,
+				replacement: resolve(rootDir, "../../sdk/packages/agents/src/index.ts"),
+			},
+			{
+				find: /^@cline\/core$/,
+				replacement: resolve(rootDir, "../../sdk/packages/core/src/index.ts"),
+			},
+			{
+				find: /^@cline\/shared$/,
+				replacement: resolve(rootDir, "../../sdk/packages/shared/src/index.ts"),
+			},
+		],
+	},
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts"],
+		exclude: ["src/**/*.e2e.test.ts", "src/tests/**"],
+		// Default 5s is tight on CI: each test uses `resetModules()` + dynamic `import("./main")`
+		// (large graph). Cold transforms occasionally exceed 5s on shared runners.
+		testTimeout: 15_000,
+		pool: "forks",
+		maxWorkers: 1,
+		fileParallelism: false,
+	},
+});
diff --git a/apps/cli/vitest.e2e.config.ts b/apps/cli/vitest.e2e.config.ts
new file mode 100644
index 0000000..f2329dd
--- /dev/null
+++ b/apps/cli/vitest.e2e.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.e2e.test.ts"],
+		exclude: ["src/**/*.interactive.e2e.test.ts"],
+		testTimeout: 60_000,
+		hookTimeout: 60_000,
+	},
+});
diff --git a/apps/cli/vitest.interactive.e2e.config.ts b/apps/cli/vitest.interactive.e2e.config.ts
new file mode 100644
index 0000000..3b1bb66
--- /dev/null
+++ b/apps/cli/vitest.interactive.e2e.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.interactive.e2e.test.ts"],
+		testTimeout: 60_000,
+		hookTimeout: 60_000,
+	},
+});
diff --git a/apps/cline-hub/README.md b/apps/cline-hub/README.md
new file mode 100644
index 0000000..7ee9aee
--- /dev/null
+++ b/apps/cline-hub/README.md
@@ -0,0 +1,114 @@
+# Cline Hub
+
+A browser dashboard for the local Cline hub. Open it to see who's connected, what sessions are running, drive a session from a chat box, and restart the hub when you need a fresh daemon.
+
+## Capabilities
+
+- live list of connected hub clients (from `HubUIClient.subscribeUI`)
+- live list of active sessions with status, model, and titles
+- click a session to view its message history and stream new assistant output
+- start a new session from an initial prompt — workspace/provider/model are reused from the most recent session, or `CLINE_PROVIDER` / `CLINE_MODEL` env vars
+- send messages to the selected session and watch chunks stream back
+- **Restart Hub** button: gracefully stops the local detached hub and respawns a fresh one
+- optional LAN/tunnel exposure gated by a shared `ROOM_SECRET`
+
+The dashboard registers two clients with the hub: a `cline-hub-server` (via `ClineCore`) for driving sessions and a `cline-hub-server` (via `HubUIClient`) for the admin view.
+
+## Run
+
+```bash
+cd apps/cline-hub
+bun run start
+```
+
+Open <http://127.0.0.1:8787> and click **Connect**. The server will discover or spawn a local detached hub on startup; the hub endpoint is printed in the console and shown in the sidebar.
+
+For webview development with Vite hot reload:
+
+```bash
+cd apps/cline-hub
+bun run dev
+```
+
+This starts the Vite webview server on <http://127.0.0.1:5173> and the hub dashboard on <http://127.0.0.1:8787>. Open the dashboard URL; the served page loads webview modules from Vite, so changes under `src/webview/src` hot reload without rebuilding. Use `CLINE_HUB_WEBVIEW_DEV_PORT` or `CLINE_HUB_WEBVIEW_DEV_HOST` to change the Vite bind address.
+
+To start a brand-new session, the dashboard needs to know which provider and model to use. It picks them up automatically from the most recent session on the hub. If there are no recent sessions, set `CLINE_PROVIDER` and `CLINE_MODEL` in the environment before running.
+
+## Configuration
+
+Environment variables:
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `HOST` | `127.0.0.1` | Bind host for the dashboard. Use the default for same-machine development. Set `HOST=0.0.0.0` only when intentionally exposing the dashboard on a LAN/tunnel. |
+| `CLINE_HUB_DASHBOARD_PORT` | `8787` | Dashboard HTTP/WebSocket port. |
+| `PUBLIC_URL` | `http://<HOST>:<PORT>` (`127.0.0.1` when binding `0.0.0.0`) | URL printed for humans to open/copy. Set this to your LAN URL or tunnel URL. |
+| `ROOM_SECRET` | unset | Shared invite secret required for browser WebSocket connections when `HOST` is non-local. |
+| `WORKSPACE_ROOT` | current directory | Workspace passed to the hub on startup. |
+| `CLINE_PROVIDER` | unset | Fallback provider id when no recent session is available to copy from. |
+| `CLINE_MODEL` | unset | Fallback model id when no recent session is available to copy from. |
+
+The server prints both the bind URL and the public/invite URL at startup. When `ROOM_SECRET` is set, the printed invite URL includes `?roomSecret=...`; the browser UI also lets you paste the secret manually.
+
+Validate option parsing without starting a server:
+
+```bash
+bun run smoke:options
+```
+
+## LAN usage
+
+Choose a strong room secret and bind explicitly to all interfaces:
+
+```bash
+cd apps/cline-hub
+HOST=0.0.0.0 \
+CLINE_HUB_DASHBOARD_PORT=8787 \
+PUBLIC_URL=http://YOUR_LAN_IP:8787 \
+ROOM_SECRET='use-a-long-random-secret' \
+bun run start
+```
+
+Share the printed invite URL with another machine on the same LAN.
+
+`ROOM_SECRET` is required for `HOST=0.0.0.0`; without it the dashboard exits before listening.
+
+## Tunnel usage
+
+Start the dashboard locally with an explicit secret:
+
+```bash
+cd apps/cline-hub
+ROOM_SECRET='use-a-long-random-secret' bun run start
+```
+
+In another terminal, expose the local port with your tunnel provider, for example:
+
+```bash
+ngrok http 8787
+```
+
+Restart the dashboard with the tunnel URL as `PUBLIC_URL` so the printed invite URL is copyable:
+
+```bash
+PUBLIC_URL=https://YOUR-TUNNEL.example \
+ROOM_SECRET='use-a-long-random-secret' \
+bun run start
+```
+
+Share only the printed invite URL with trusted participants.
+
+## Restarting the hub
+
+Clicking **Restart Hub** in the sidebar:
+
+1. Detaches the dashboard's `ClineCore` and `HubUIClient` from the current hub.
+2. Calls `stopLocalHubServerGracefully()` to shut the local detached hub down.
+3. Calls `ensureDetachedHubServer(workspaceRoot)` to spawn a fresh hub.
+4. Reconnects and broadcasts the new hub state to every open browser tab.
+
+Sessions running on the previous hub are stopped along with the hub. Other clients connected to that hub (CLI, VS Code, menubar) will see their connection drop and reconnect to the new daemon on next request.
+
+## Security warning
+
+This is an example dashboard, not a production admin tool. Exposing it on a LAN or tunnel lets anyone with the invite secret list clients/sessions on your hub, drive sessions, and restart the hub. Use a long random `ROOM_SECRET`, only share the URL with trusted participants, and stop the process when you are done. The hub and agent runtime remain owned by the host machine.
diff --git a/apps/cline-hub/package.json b/apps/cline-hub/package.json
new file mode 100644
index 0000000..312efa8
--- /dev/null
+++ b/apps/cline-hub/package.json
@@ -0,0 +1,23 @@
+{
+	"name": "@cline/cline-hub",
+	"version": "0.0.0",
+	"private": true,
+	"description": "Browser dashboard for the Cline hub: live clients, sessions, streaming chat, and hub restart.",
+	"type": "module",
+	"exports": {
+		".": "./src/server.ts"
+	},
+	"scripts": {
+		"build:webview": "bun run --cwd src/webview build",
+		"dev": "bun run src/dev.ts",
+		"start": "bun run src/server.ts",
+		"smoke:options": "bun run src/validate-options.ts",
+		"test": "bunx vitest run --config vitest.config.ts",
+		"typecheck": "bun tsc -p tsconfig.json --noEmit"
+	},
+	"dependencies": {
+		"@cline/core": "workspace:*",
+		"@cline/llms": "workspace:*",
+		"@cline/shared": "workspace:*"
+	}
+}
diff --git a/apps/cline-hub/src/dev.ts b/apps/cline-hub/src/dev.ts
new file mode 100644
index 0000000..1a608ca
--- /dev/null
+++ b/apps/cline-hub/src/dev.ts
@@ -0,0 +1,85 @@
+import { join } from "node:path";
+import process from "node:process";
+
+const webviewHost =
+	process.env.CLINE_HUB_WEBVIEW_DEV_HOST?.trim() || "127.0.0.1";
+const webviewPort = process.env.CLINE_HUB_WEBVIEW_DEV_PORT?.trim() || "5173";
+const webviewDevServerUrl =
+	process.env.VITE_DEV_SERVER_URL?.trim() ||
+	`http://${webviewHost}:${webviewPort}`;
+
+const cwd = process.cwd();
+const webviewCwd = join(cwd, "src", "webview");
+
+const children: Bun.Subprocess[] = [];
+let shuttingDown = false;
+
+function spawn(
+	name: string,
+	command: string[],
+	options: {
+		cwd: string;
+		env: NodeJS.ProcessEnv;
+	},
+): Bun.Subprocess {
+	const child = Bun.spawn(command, {
+		...options,
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	children.push(child);
+	void child.exited.then((code) => {
+		if (!shuttingDown) {
+			console.error(`[cline-hub:dev] ${name} exited with code ${code}`);
+			shutdown(code === 0 ? 0 : 1);
+		}
+	});
+	return child;
+}
+
+function shutdown(exitCode = 0): void {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	for (const child of children) {
+		try {
+			child.kill();
+		} catch {
+			// The process may have already exited.
+		}
+	}
+	process.exitCode = exitCode;
+}
+
+process.on("SIGINT", () => shutdown(0));
+process.on("SIGTERM", () => shutdown(0));
+
+console.log(`[cline-hub:dev] Vite webview: ${webviewDevServerUrl}`);
+console.log("[cline-hub:dev] Hub dashboard: http://127.0.0.1:8787/");
+
+spawn(
+	"webview",
+	[
+		"bun",
+		"run",
+		"dev",
+		"--host",
+		webviewHost,
+		"--port",
+		webviewPort,
+		"--strictPort",
+	],
+	{
+		cwd: webviewCwd,
+		env: process.env,
+	},
+);
+
+spawn("server", ["bun", "run", "src/server.ts"], {
+	cwd,
+	env: {
+		...process.env,
+		VITE_DEV_SERVER_URL: webviewDevServerUrl,
+	},
+});
+
+await Promise.allSettled(children.map((child) => child.exited));
diff --git a/apps/cline-hub/src/options.ts b/apps/cline-hub/src/options.ts
new file mode 100644
index 0000000..e1da93d
--- /dev/null
+++ b/apps/cline-hub/src/options.ts
@@ -0,0 +1,115 @@
+import { isIP } from "node:net";
+
+export interface ClineHubServerOptions {
+	host: string;
+	port: number;
+	publicUrl: string;
+	roomSecret?: string;
+	workspaceRoot: string;
+}
+
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 8787;
+const DASHBOARD_PORT_ENV = "CLINE_HUB_DASHBOARD_PORT";
+
+function parsePort(value: string | undefined): number {
+	if (!value?.trim()) return DEFAULT_PORT;
+	const port = Number.parseInt(value, 10);
+	if (!Number.isInteger(port) || port < 1 || port > 65535) {
+		throw new Error(
+			`${DASHBOARD_PORT_ENV} must be an integer from 1 to 65535, got ${value}`,
+		);
+	}
+	return port;
+}
+
+function normalizeHost(value: string | undefined): string {
+	return value?.trim() || DEFAULT_HOST;
+}
+
+function normalizePublicUrl(
+	value: string | undefined,
+	host: string,
+	port: number,
+): string {
+	const fallbackHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+	const raw = value?.trim() || `http://${fallbackHost}:${port}`;
+	let parsed: URL;
+	try {
+		parsed = new URL(raw);
+	} catch (error) {
+		throw new Error(
+			`PUBLIC_URL must be a valid http(s) URL, got ${raw}: ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+		);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error(
+			`PUBLIC_URL must use http: or https:, got ${parsed.protocol}`,
+		);
+	}
+	if (shouldAddDashboardPortToPublicUrl(parsed, port)) {
+		parsed.port = String(port);
+	}
+	parsed.hash = "";
+	return parsed.toString().replace(/\/$/, "");
+}
+
+function normalizeRoomSecret(value: string | undefined): string | undefined {
+	const secret = value?.trim();
+	return secret ? secret : undefined;
+}
+
+function isLocalBindHost(host: string): boolean {
+	return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+
+export function isNonLocalBindHost(host: string): boolean {
+	return !isLocalBindHost(host);
+}
+
+export function resolveClineHubServerOptions(
+	env: NodeJS.ProcessEnv = process.env,
+): ClineHubServerOptions {
+	const host = normalizeHost(env.HOST);
+	const port = parsePort(env[DASHBOARD_PORT_ENV]);
+	const publicUrl = normalizePublicUrl(env.PUBLIC_URL, host, port);
+	const roomSecret = normalizeRoomSecret(env.ROOM_SECRET);
+	if (isNonLocalBindHost(host) && !roomSecret) {
+		throw new Error(
+			`ROOM_SECRET is required when HOST=${host}. Use HOST=127.0.0.1 for local-only development or set ROOM_SECRET before exposing this example on a LAN/tunnel.`,
+		);
+	}
+	return {
+		host,
+		port,
+		publicUrl,
+		roomSecret,
+		workspaceRoot: env.WORKSPACE_ROOT?.trim() || process.cwd(),
+	};
+}
+
+function isDefaultProtocolPort(url: URL, port: number): boolean {
+	return (
+		(url.protocol === "http:" && port === 80) ||
+		(url.protocol === "https:" && port === 443)
+	);
+}
+
+function shouldAddDashboardPortToPublicUrl(url: URL, port: number): boolean {
+	if (url.port || isDefaultProtocolPort(url, port)) return false;
+	const hostname = url.hostname.replace(/^\[|\]$/g, "");
+	return hostname === "localhost" || isIP(hostname) !== 0;
+}
+
+export function buildInviteUrl(
+	publicUrl: string,
+	roomSecret: string | undefined,
+): string {
+	const url = new URL(publicUrl);
+	if (roomSecret) {
+		url.searchParams.set("roomSecret", roomSecret);
+	}
+	return url.toString();
+}
diff --git a/apps/cline-hub/src/server.ts b/apps/cline-hub/src/server.ts
new file mode 100644
index 0000000..669846a
--- /dev/null
+++ b/apps/cline-hub/src/server.ts
@@ -0,0 +1,304 @@
+import { CORE_BUILD_VERSION } from "@cline/core";
+import { isNonLocalBindHost } from "./options";
+import {
+	handleToolApprovalResponse,
+	rejectOrphanedApprovals,
+} from "./server/approvals";
+import { isAuthorizedBrowserToDesktopRequest } from "./server/browser-auth";
+import {
+	browserConfig,
+	host,
+	inviteUrl,
+	port,
+	publicUrl,
+	roomSecret,
+	webviewDistDir,
+} from "./server/deps";
+import { handleDesktopCommand } from "./server/desktop-commands";
+import {
+	createJsonResponse,
+	isWebviewRoute,
+	WebviewAssets,
+} from "./server/http";
+import {
+	attachHub,
+	detachHub,
+	restartHub,
+	syncHubClientsAndSessions,
+	syncHubHealth,
+} from "./server/hub";
+import { fetchMarketplaceCatalog } from "./server/marketplace";
+import {
+	loadModels,
+	runProviderOAuthLogin,
+	saveProviderSettings,
+	sendProviderCatalog,
+} from "./server/providers";
+import {
+	abortPeerTurn,
+	deleteSession,
+	forkPeerSession,
+	initializePeer,
+	resetPeer,
+	restorePeerSession,
+	selectSession,
+	sendMessage,
+} from "./server/sessions";
+import { HubContext } from "./server/state";
+import { broadcastHubState, hubStatusPayload } from "./server/state-payloads";
+import type { BrowserFrame, BrowserPeer } from "./server/types";
+
+export interface ClineHubDashboardServer {
+	listenUrl: string;
+	publicUrl: string;
+	inviteUrl: string;
+	bindHost: string;
+	inviteRequired: boolean;
+	hubUrl: string | undefined;
+	stop: () => Promise<void>;
+}
+
+const PUBLIC_BROWSER_PATHS = new Set([
+	"/version",
+	"/health",
+	"/config.json",
+	"/api/marketplace/catalog",
+	"/icon.png",
+	"/icon.svg",
+	"/icon.ico",
+	"/32x32.png",
+	"/cline-logo-filled.svg",
+	"/favicon.svg",
+]);
+
+function isPublicStaticAssetPath(pathname: string): boolean {
+	return pathname.startsWith("/assets/") || PUBLIC_BROWSER_PATHS.has(pathname);
+}
+
+function isPublicBrowserRoute(_req: Request, url: URL): boolean {
+	return isWebviewRoute(url.pathname) || isPublicStaticAssetPath(url.pathname);
+}
+
+export async function startClineHubDashboardServer(): Promise<ClineHubDashboardServer> {
+	const ctx = new HubContext();
+	const assets = new WebviewAssets(webviewDistDir);
+	const syncClientsAndSessions = () => syncHubClientsAndSessions(ctx);
+	let stopped = false;
+
+	await attachHub(ctx);
+	const healthInterval = setInterval(() => {
+		void (async () => {
+			await syncHubHealth(ctx);
+			broadcastHubState(ctx);
+		})();
+	}, 5_000);
+
+	const server = Bun.serve<BrowserPeer>({
+		port,
+		hostname: host,
+		async fetch(req, server) {
+			const url = new URL(req.url);
+			if (
+				!isAuthorizedBrowserToDesktopRequest(
+					req,
+					url,
+					{
+						bindHost: host,
+						port,
+						publicUrl,
+						roomSecret,
+					},
+					isPublicBrowserRoute,
+				)
+			) {
+				return createJsonResponse({ error: "unauthorized_browser" }, 403);
+			}
+			if (url.pathname === "/version") {
+				return createJsonResponse({ coreVersion: CORE_BUILD_VERSION });
+			}
+			if (url.pathname === "/health") {
+				await syncHubHealth(ctx);
+				return createJsonResponse(hubStatusPayload(ctx));
+			}
+			if (url.pathname === "/browser") {
+				const displayName = `Browser ${Math.random().toString(36).slice(2, 6)}`;
+				const data = {
+					socket: undefined as never,
+					displayName,
+					sending: false,
+				};
+				if (server.upgrade(req, { data })) return undefined;
+				return new Response("upgrade failed", { status: 400 });
+			}
+			if (url.pathname === "/config.json") {
+				return createJsonResponse(browserConfig);
+			}
+			if (url.pathname === "/api/marketplace/catalog") {
+				try {
+					return createJsonResponse(await fetchMarketplaceCatalog());
+				} catch (error) {
+					return createJsonResponse(
+						{
+							error:
+								error instanceof Error
+									? error.message
+									: "Failed to fetch marketplace catalog",
+						},
+						502,
+					);
+				}
+			}
+			return assets.serve(url.pathname);
+		},
+		websocket: {
+			async open(socket) {
+				const peer = socket.data;
+				peer.socket = socket;
+				ctx.peers.add(peer);
+			},
+			async message(socket, raw) {
+				const peer = socket.data;
+				try {
+					const frame = JSON.parse(String(raw)) as BrowserFrame;
+					if (frame.type === "desktopCommand") {
+						try {
+							const result = await handleDesktopCommand(
+								ctx,
+								frame.command,
+								frame.args,
+							);
+							ctx.send(peer, {
+								type: "desktopCommandResult",
+								id: frame.id,
+								ok: true,
+								result,
+							});
+						} catch (error) {
+							ctx.send(peer, {
+								type: "desktopCommandResult",
+								id: frame.id,
+								ok: false,
+								error: error instanceof Error ? error.message : String(error),
+							});
+						}
+					} else if (frame.type === "ready") {
+						await initializePeer(ctx, peer, syncClientsAndSessions);
+					} else if (frame.type === "loadModels") {
+						await loadModels(ctx, peer, frame.providerId);
+					} else if (frame.type === "loadProviderCatalog") {
+						await sendProviderCatalog(ctx, peer);
+					} else if (frame.type === "saveProviderSettings") {
+						await saveProviderSettings(ctx, peer, frame);
+					} else if (frame.type === "runProviderOAuthLogin") {
+						await runProviderOAuthLogin(ctx, peer, frame.providerId);
+					} else if (frame.type === "attachSession") {
+						await selectSession(ctx, peer, frame.sessionId);
+					} else if (frame.type === "deleteSession") {
+						await deleteSession(ctx, peer, frame.sessionId);
+					} else if (frame.type === "updateSessionMetadata") {
+						if (!ctx.cline) throw new Error("Hub is not connected.");
+						const session = await ctx.cline.get(frame.sessionId);
+						const metadata =
+							session?.metadata && typeof session.metadata === "object"
+								? (session.metadata as Record<string, unknown>)
+								: {};
+						await ctx.cline.update(frame.sessionId, {
+							metadata: { ...metadata, ...frame.metadata },
+						});
+						await syncHubClientsAndSessions(ctx);
+						broadcastHubState(ctx);
+					} else if (frame.type === "approval_response") {
+						handleToolApprovalResponse(ctx, frame);
+					} else if (frame.type === "abort") {
+						await abortPeerTurn(ctx, peer);
+					} else if (frame.type === "reset") {
+						await resetPeer(ctx, peer);
+					} else if (frame.type === "send") {
+						if (peer.sending) {
+							ctx.send(peer, {
+								type: "status",
+								text: "A turn is already in progress.",
+							});
+							return;
+						}
+						peer.sending = true;
+						try {
+							await sendMessage(
+								ctx,
+								peer,
+								frame.prompt,
+								frame.config,
+								frame.attachments,
+							);
+						} finally {
+							peer.sending = false;
+						}
+					} else if (frame.type === "forkSession") {
+						await forkPeerSession(ctx, peer, syncClientsAndSessions);
+					} else if (frame.type === "restore") {
+						await restorePeerSession(
+							ctx,
+							peer,
+							frame.checkpointRunCount,
+							syncClientsAndSessions,
+						);
+					} else if (frame.type === "restart_hub") {
+						await restartHub(ctx);
+					}
+				} catch (error) {
+					ctx.send(peer, {
+						type: "error",
+						text: error instanceof Error ? error.message : String(error),
+					});
+				}
+			},
+			close(socket) {
+				const peer = socket.data;
+				peer.unsubscribeEvents?.();
+				ctx.peers.delete(peer);
+				rejectOrphanedApprovals(ctx);
+			},
+		},
+	});
+
+	return {
+		listenUrl: server.url.toString(),
+		publicUrl,
+		inviteUrl,
+		bindHost: host,
+		inviteRequired: Boolean(roomSecret),
+		hubUrl: ctx.hubUrl,
+		stop: async () => {
+			if (stopped) return;
+			stopped = true;
+			clearInterval(healthInterval);
+			try {
+				server.stop(true);
+			} finally {
+				await detachHub(ctx);
+			}
+		},
+	};
+}
+
+export function printClineHubDashboardServerInfo(
+	server: ClineHubDashboardServer,
+): void {
+	console.log(`Cline Hub dashboard listening: ${server.listenUrl}`);
+	console.log(`Cline Hub public URL: ${server.publicUrl}`);
+	console.log(`hub endpoint: ${server.hubUrl}`);
+	if (server.inviteRequired) {
+		console.log(`Cline Hub invite URL: ${server.inviteUrl}`);
+	} else if (isNonLocalBindHost(server.bindHost)) {
+		console.warn("WARNING: non-local bind without ROOM_SECRET is not allowed.");
+	} else {
+		console.log(
+			"ROOM_SECRET is not set; this local-only instance accepts browser connections without an invite token.",
+		);
+	}
+}
+
+if (import.meta.main) {
+	const server = await startClineHubDashboardServer();
+	printClineHubDashboardServerInfo(server);
+}
diff --git a/apps/cline-hub/src/server/agent-events.ts b/apps/cline-hub/src/server/agent-events.ts
new file mode 100644
index 0000000..792936d
--- /dev/null
+++ b/apps/cline-hub/src/server/agent-events.ts
@@ -0,0 +1,180 @@
+import type { CoreSessionEvent } from "@cline/core";
+import type { AgentEvent } from "@cline/shared";
+import type { WebviewToolEvent } from "../webview-protocol";
+import { rejectPendingApprovalsForSession } from "./approvals";
+import type { HubContext } from "./state";
+import { broadcastHubState } from "./state-payloads";
+import { asString, chunkText } from "./utils";
+
+function agentEventText(event: AgentEvent): string {
+	if (
+		event.type === "content_start" &&
+		event.contentType === "text" &&
+		typeof event.text === "string"
+	) {
+		return event.text;
+	}
+	return "";
+}
+
+function sendChunkToSelectedPeers(
+	ctx: HubContext,
+	sessionId: string,
+	text: string,
+): void {
+	if (!text) return;
+	ctx.sendToSelectedPeers(sessionId, { type: "assistant_delta", text });
+}
+
+function forwardAgentEvent(
+	ctx: HubContext,
+	sessionId: string,
+	event: AgentEvent,
+): void {
+	if (event.type === "content_start") {
+		if (event.contentType === "reasoning") {
+			ctx.sendToSelectedPeers(sessionId, {
+				type: "reasoning_delta",
+				text: event.reasoning ?? event.text ?? "",
+				redacted: event.redacted,
+			});
+			return;
+		}
+		if (event.contentType === "tool") {
+			ctx.sendToSelectedPeers(sessionId, {
+				type: "tool_event",
+				text: `Running ${event.toolName ?? "tool"}...`,
+				event: {
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					status: "running",
+					input: event.input,
+				},
+			});
+			return;
+		}
+		const text = agentEventText(event);
+		if (text) sendChunkToSelectedPeers(ctx, sessionId, text);
+		return;
+	}
+	if (event.type === "content_update" && event.contentType === "tool") {
+		const toolEvent: WebviewToolEvent = {
+			toolCallId: event.toolCallId,
+			toolName: event.toolName,
+			status: "running",
+			output: event.update,
+		};
+		ctx.sendToSelectedPeers(sessionId, {
+			type: "tool_event",
+			text: `${event.toolName ?? "tool"} updated`,
+			event: toolEvent,
+		});
+		return;
+	}
+	if (event.type === "content_end") {
+		if (event.contentType === "reasoning") {
+			ctx.sendToSelectedPeers(sessionId, {
+				type: "reasoning_delta",
+				text: event.reasoning ?? event.text ?? "",
+			});
+			return;
+		}
+		if (event.contentType === "tool") {
+			const toolName = event.toolName ?? "tool";
+			ctx.sendToSelectedPeers(sessionId, {
+				type: "tool_event",
+				text: event.error
+					? `${toolName} failed: ${event.error}`
+					: `${toolName} completed`,
+				event: {
+					toolCallId: event.toolCallId,
+					toolName,
+					status: event.error ? "failed" : "completed",
+					output: event.output,
+					error: event.error,
+				},
+			});
+		}
+		return;
+	}
+	if (event.type === "notice") {
+		ctx.sendToSelectedPeers(sessionId, { type: "status", text: event.message });
+		return;
+	}
+	if (event.type === "done") {
+		ctx.sendToSelectedPeers(sessionId, {
+			type: "turn_done",
+			finishReason: event.reason,
+			iterations: event.iterations,
+			usage: event.usage
+				? {
+						inputTokens: event.usage.inputTokens,
+						outputTokens: event.usage.outputTokens,
+						cacheCreationInputTokens: event.usage.cacheWriteTokens,
+						cacheReadInputTokens: event.usage.cacheReadTokens,
+						totalCost: event.usage.totalCost,
+					}
+				: undefined,
+		});
+		return;
+	}
+	if (event.type === "error") {
+		ctx.sendToSelectedPeers(sessionId, {
+			type: "error",
+			text: event.error.message,
+		});
+	}
+}
+
+export function handleSessionEvent(
+	ctx: HubContext,
+	event: CoreSessionEvent,
+): void {
+	const payload = event.payload as Record<string, unknown> | undefined;
+	const sessionId = asString(payload?.sessionId);
+	if (!sessionId) return;
+	if (event.type === "chunk") {
+		const text = chunkText((payload as Record<string, unknown>).chunk);
+		sendChunkToSelectedPeers(ctx, sessionId, text);
+	} else if (event.type === "agent_event") {
+		if (event.payload.teamRole === "teammate") return;
+		forwardAgentEvent(ctx, sessionId, event.payload.event);
+	} else if (event.type === "status") {
+		const status = asString((payload as Record<string, unknown>).status);
+		const tracked = ctx.sessions.get(sessionId);
+		if (tracked && status) {
+			tracked.status = status;
+			tracked.updatedAt = Date.now();
+		}
+		for (const peer of ctx.peers) {
+			if (peer.selectedSessionId === sessionId) {
+				ctx.send(peer, {
+					type: "status",
+					text: status ?? "Session status changed.",
+				});
+			}
+		}
+		broadcastHubState(ctx);
+	} else if (event.type === "ended") {
+		rejectPendingApprovalsForSession(
+			ctx,
+			sessionId,
+			"Session ended before approval was resolved.",
+		);
+		const tracked = ctx.sessions.get(sessionId);
+		if (tracked) {
+			tracked.status = "completed";
+			tracked.updatedAt = Date.now();
+		}
+		for (const peer of ctx.peers) {
+			if (peer.selectedSessionId === sessionId) {
+				ctx.send(peer, {
+					type: "turn_done",
+					finishReason: event.payload.reason,
+					iterations: 0,
+				});
+			}
+		}
+		broadcastHubState(ctx);
+	}
+}
diff --git a/apps/cline-hub/src/server/approvals.ts b/apps/cline-hub/src/server/approvals.ts
new file mode 100644
index 0000000..22ab49e
--- /dev/null
+++ b/apps/cline-hub/src/server/approvals.ts
@@ -0,0 +1,122 @@
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import type { WebviewInboundMessage } from "../webview-protocol";
+import type { HubContext } from "./state";
+import { broadcastHubState } from "./state-payloads";
+
+function createApprovalId(): string {
+	return `approval-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+export function resolveToolApproval(
+	ctx: HubContext,
+	approvalId: string,
+	result: ToolApprovalResult,
+): boolean {
+	const pending = ctx.pendingToolApprovals.get(approvalId);
+	if (!pending) return false;
+	clearTimeout(pending.timeout);
+	ctx.pendingToolApprovals.delete(approvalId);
+	ctx.sendToSelectedPeers(pending.sessionId, {
+		type: "approval_resolved",
+		approvalId,
+		approved: result.approved,
+		reason: result.reason,
+	});
+	pending.resolve(result);
+	return true;
+}
+
+export function rejectPendingApprovalsForSession(
+	ctx: HubContext,
+	sessionId: string,
+	reason: string,
+): void {
+	for (const [approvalId, pending] of [...ctx.pendingToolApprovals.entries()]) {
+		if (pending.sessionId === sessionId) {
+			resolveToolApproval(ctx, approvalId, { approved: false, reason });
+		}
+	}
+}
+
+export function rejectAllPendingApprovals(
+	ctx: HubContext,
+	reason: string,
+): void {
+	for (const approvalId of [...ctx.pendingToolApprovals.keys()]) {
+		resolveToolApproval(ctx, approvalId, { approved: false, reason });
+	}
+}
+
+export function rejectOrphanedApprovals(ctx: HubContext): void {
+	for (const [approvalId, pending] of [...ctx.pendingToolApprovals.entries()]) {
+		if (!ctx.hasSelectedPeer(pending.sessionId)) {
+			resolveToolApproval(ctx, approvalId, {
+				approved: false,
+				reason: "Cline Hub webview disconnected before approval was resolved.",
+			});
+		}
+	}
+}
+
+export function requestToolApprovalFromWebview(
+	ctx: HubContext,
+	request: ToolApprovalRequest,
+): Promise<ToolApprovalResult> {
+	if (!ctx.hasSelectedPeer(request.sessionId)) {
+		return Promise.resolve({
+			approved: false,
+			reason: "No Cline Hub webview is attached to this session.",
+		});
+	}
+
+	const approvalId = createApprovalId();
+	ctx.pushEvent(
+		"Tool approval requested",
+		`${request.toolName} is waiting for approval`,
+		"warn",
+	);
+	broadcastHubState(ctx);
+
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			resolveToolApproval(ctx, approvalId, {
+				approved: false,
+				reason: "Tool approval request timed out.",
+			});
+		}, 10 * 60_000);
+		ctx.pendingToolApprovals.set(approvalId, {
+			sessionId: request.sessionId,
+			resolve,
+			timeout,
+		});
+		ctx.sendToSelectedPeers(request.sessionId, {
+			type: "approval_request",
+			approvalId,
+			sessionId: request.sessionId,
+			agentId: request.agentId,
+			conversationId: request.conversationId,
+			iteration: request.iteration,
+			toolCallId: request.toolCallId,
+			toolName: request.toolName,
+			input: request.input,
+			policy: request.policy as Record<string, unknown> | undefined,
+		});
+	});
+}
+
+export function handleToolApprovalResponse(
+	ctx: HubContext,
+	frame: Extract<WebviewInboundMessage, { type: "approval_response" }>,
+): void {
+	const approvalId = frame.approvalId.trim();
+	if (!approvalId) return;
+	const resolved = resolveToolApproval(ctx, approvalId, {
+		approved: frame.approved,
+		reason:
+			frame.reason ??
+			(frame.approved ? "Approved in Cline Hub." : "Rejected in Cline Hub."),
+	});
+	if (!resolved) {
+		console.warn(`Ignoring unknown tool approval response: ${approvalId}`);
+	}
+}
diff --git a/apps/cline-hub/src/server/browser-auth.test.ts b/apps/cline-hub/src/server/browser-auth.test.ts
new file mode 100644
index 0000000..c023400
--- /dev/null
+++ b/apps/cline-hub/src/server/browser-auth.test.ts
@@ -0,0 +1,359 @@
+import { describe, expect, it } from "vitest";
+import {
+	allowedBrowserHosts,
+	allowedBrowserOrigins,
+	isAuthorizedBrowserRequest,
+	isAuthorizedBrowserToDesktopRequest,
+	requiresBrowserRequestAuth,
+} from "./browser-auth";
+
+const defaultOptions = {
+	bindHost: "127.0.0.1",
+	port: 8787,
+	publicUrl: "http://127.0.0.1:8787",
+};
+
+const publicRoute = (_req: Request, url: URL) => url.pathname === "/public";
+
+function browserRequest(
+	origin?: string,
+	init?: Omit<RequestInit, "headers"> & {
+		headers?: Record<string, string>;
+	},
+): Request {
+	return new Request("http://127.0.0.1:8787/browser", {
+		...init,
+		headers: {
+			host: "127.0.0.1:8787",
+			...(origin === undefined ? {} : { origin }),
+			...(init?.headers ?? {}),
+		},
+	});
+}
+
+describe("allowedBrowserOrigins", () => {
+	it("allows the configured public URL origin and local aliases for local binds", () => {
+		expect([...allowedBrowserOrigins(defaultOptions)].sort()).toEqual([
+			"http://127.0.0.1:8787",
+			"http://[::1]:8787",
+			"http://localhost:8787",
+		]);
+	});
+
+	it("uses the configured public URL scheme for local aliases", () => {
+		expect(
+			[
+				...allowedBrowserOrigins({
+					...defaultOptions,
+					publicUrl: "https://127.0.0.1:8787",
+				}),
+			].sort(),
+		).toEqual([
+			"https://127.0.0.1:8787",
+			"https://[::1]:8787",
+			"https://localhost:8787",
+		]);
+	});
+
+	it("omits default protocol ports for local alias origins", () => {
+		expect(
+			[
+				...allowedBrowserOrigins({
+					bindHost: "127.0.0.1",
+					port: 80,
+					publicUrl: "http://localhost",
+				}),
+			].sort(),
+		).toEqual(["http://127.0.0.1", "http://[::1]", "http://localhost"]);
+
+		expect(
+			[
+				...allowedBrowserOrigins({
+					bindHost: "127.0.0.1",
+					port: 443,
+					publicUrl: "https://localhost",
+				}),
+			].sort(),
+		).toEqual(["https://127.0.0.1", "https://[::1]", "https://localhost"]);
+	});
+
+	it("allows the configured public URL origin and explicit bind origin for non-local binds", () => {
+		expect(
+			[
+				...allowedBrowserOrigins({
+					bindHost: "0.0.0.0",
+					port: 8787,
+					publicUrl: "https://example.ngrok-free.app",
+					roomSecret: "secret",
+				}),
+			].sort(),
+		).toEqual(["https://0.0.0.0:8787", "https://example.ngrok-free.app"]);
+	});
+});
+
+describe("allowedBrowserHosts", () => {
+	it("allows the configured public URL host and local aliases for local binds", () => {
+		expect([...allowedBrowserHosts(defaultOptions)].sort()).toEqual([
+			"127.0.0.1:8787",
+			"[::1]:8787",
+			"localhost:8787",
+		]);
+	});
+
+	it("omits default protocol ports for local alias hosts", () => {
+		expect(
+			[
+				...allowedBrowserHosts({
+					bindHost: "127.0.0.1",
+					port: 80,
+					publicUrl: "http://localhost",
+				}),
+			].sort(),
+		).toEqual(["127.0.0.1", "[::1]", "localhost"]);
+
+		expect(
+			[
+				...allowedBrowserHosts({
+					bindHost: "127.0.0.1",
+					port: 443,
+					publicUrl: "https://localhost",
+				}),
+			].sort(),
+		).toEqual(["127.0.0.1", "[::1]", "localhost"]);
+	});
+
+	it("allows the configured public URL host and explicit bind host for non-local binds", () => {
+		expect(
+			[
+				...allowedBrowserHosts({
+					bindHost: "0.0.0.0",
+					port: 8787,
+					publicUrl: "https://example.ngrok-free.app",
+					roomSecret: "secret",
+				}),
+			].sort(),
+		).toEqual(["0.0.0.0:8787", "example.ngrok-free.app"]);
+	});
+});
+
+describe("requiresBrowserRequestAuth", () => {
+	it("does not require browser auth for public GET routes", () => {
+		expect(
+			requiresBrowserRequestAuth(
+				new Request("http://127.0.0.1:8787/public"),
+				new URL("http://127.0.0.1:8787/public"),
+				publicRoute,
+			),
+		).toBe(false);
+	});
+
+	it("requires browser auth for unknown paths even when they use GET", () => {
+		expect(
+			requiresBrowserRequestAuth(
+				new Request("http://127.0.0.1:8787/future-api"),
+				new URL("http://127.0.0.1:8787/future-api"),
+				publicRoute,
+			),
+		).toBe(true);
+	});
+
+	it("requires browser auth for privileged paths even when they use GET", () => {
+		expect(
+			requiresBrowserRequestAuth(
+				new Request("http://127.0.0.1:8787/browser"),
+				new URL("http://127.0.0.1:8787/browser"),
+				publicRoute,
+			),
+		).toBe(true);
+	});
+
+	it("requires browser auth for every WebSocket upgrade path", () => {
+		expect(
+			requiresBrowserRequestAuth(
+				new Request("http://127.0.0.1:8787/future-socket", {
+					headers: { upgrade: "websocket" },
+				}),
+				new URL("http://127.0.0.1:8787/future-socket"),
+				publicRoute,
+			),
+		).toBe(true);
+	});
+
+	it("requires browser auth for every unsafe HTTP method", () => {
+		expect(
+			requiresBrowserRequestAuth(
+				new Request("http://127.0.0.1:8787/future-api", { method: "POST" }),
+				new URL("http://127.0.0.1:8787/future-api"),
+				publicRoute,
+			),
+		).toBe(true);
+	});
+});
+
+describe("isAuthorizedBrowserRequest", () => {
+	it.each([
+		"http://127.0.0.1:8787",
+		"http://localhost:8787",
+		"http://[::1]:8787",
+	])("accepts local dashboard origin %s without a room secret", (origin) => {
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest(origin),
+				new URL("http://127.0.0.1:8787/browser"),
+				defaultOptions,
+			),
+		).toBe(true);
+	});
+
+	it.each([
+		undefined,
+		"",
+		"null",
+		"not a url",
+		"http://evil.attacker.example.com",
+		"http://127.0.0.1:9999",
+		"https://127.0.0.1:8787",
+	])("rejects untrusted origin %s", (origin) => {
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest(origin),
+				new URL("http://127.0.0.1:8787/browser"),
+				defaultOptions,
+			),
+		).toBe(false);
+	});
+
+	it.each([
+		undefined,
+		"",
+		"evil.attacker.example.com",
+		"127.0.0.1:9999",
+		"localhost:9999",
+	])("rejects untrusted host %s", (host) => {
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest("http://127.0.0.1:8787", {
+					headers: host === undefined ? { host: "" } : { host },
+				}),
+				new URL("http://127.0.0.1:8787/browser"),
+				defaultOptions,
+			),
+		).toBe(false);
+	});
+
+	it("allows explicit wildcard bind host and origin when a room secret is configured", () => {
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest("http://0.0.0.0:8787", {
+					headers: { host: "0.0.0.0:8787" },
+				}),
+				new URL("http://0.0.0.0:8787/browser?roomSecret=invite-123"),
+				{
+					bindHost: "0.0.0.0",
+					port: 8787,
+					publicUrl: "http://127.0.0.1:8787",
+					roomSecret: "invite-123",
+				},
+			),
+		).toBe(true);
+	});
+
+	it("requires trusted origin, trusted host, and room secret when a room secret is configured", () => {
+		const options = { ...defaultOptions, roomSecret: "invite-123" };
+
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest("http://127.0.0.1:8787"),
+				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
+				options,
+			),
+		).toBe(true);
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest("http://127.0.0.1:8787"),
+				new URL("http://127.0.0.1:8787/browser"),
+				options,
+			),
+		).toBe(false);
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest("http://evil.attacker.example.com"),
+				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
+				options,
+			),
+		).toBe(false);
+		expect(
+			isAuthorizedBrowserRequest(
+				browserRequest("http://127.0.0.1:8787", {
+					headers: { host: "evil.attacker.example.com" },
+				}),
+				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
+				options,
+			),
+		).toBe(false);
+	});
+});
+
+describe("isAuthorizedBrowserToDesktopRequest", () => {
+	it("allows safe public GET routes without an origin", () => {
+		expect(
+			isAuthorizedBrowserToDesktopRequest(
+				new Request("http://127.0.0.1:8787/public"),
+				new URL("http://127.0.0.1:8787/public"),
+				defaultOptions,
+				publicRoute,
+			),
+		).toBe(true);
+	});
+
+	it("rejects future WebSocket paths from untrusted origins by default", () => {
+		expect(
+			isAuthorizedBrowserToDesktopRequest(
+				new Request("http://127.0.0.1:8787/future-socket", {
+					headers: {
+						host: "127.0.0.1:8787",
+						origin: "http://evil.attacker.example.com",
+						upgrade: "websocket",
+					},
+				}),
+				new URL("http://127.0.0.1:8787/future-socket"),
+				defaultOptions,
+				publicRoute,
+			),
+		).toBe(false);
+	});
+
+	it("rejects future unsafe HTTP routes from untrusted origins by default", () => {
+		expect(
+			isAuthorizedBrowserToDesktopRequest(
+				new Request("http://127.0.0.1:8787/future-api", {
+					method: "POST",
+					headers: {
+						host: "127.0.0.1:8787",
+						origin: "http://evil.attacker.example.com",
+					},
+				}),
+				new URL("http://127.0.0.1:8787/future-api"),
+				defaultOptions,
+				publicRoute,
+			),
+		).toBe(false);
+	});
+
+	it("allows future unsafe HTTP routes from trusted origins", () => {
+		expect(
+			isAuthorizedBrowserToDesktopRequest(
+				new Request("http://127.0.0.1:8787/future-api", {
+					method: "POST",
+					headers: {
+						host: "127.0.0.1:8787",
+						origin: "http://127.0.0.1:8787",
+					},
+				}),
+				new URL("http://127.0.0.1:8787/future-api"),
+				defaultOptions,
+				publicRoute,
+			),
+		).toBe(true);
+	});
+});
diff --git a/apps/cline-hub/src/server/browser-auth.ts b/apps/cline-hub/src/server/browser-auth.ts
new file mode 100644
index 0000000..628e8f9
--- /dev/null
+++ b/apps/cline-hub/src/server/browser-auth.ts
@@ -0,0 +1,134 @@
+import { isNonLocalBindHost } from "../options";
+
+export interface BrowserRequestAuthOptions {
+	bindHost: string;
+	port: number;
+	publicUrl: string;
+	roomSecret?: string;
+}
+
+const SAFE_HTTP_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+
+export type PublicBrowserRoutePredicate = (req: Request, url: URL) => boolean;
+
+function isWebSocketUpgrade(req: Request): boolean {
+	return req.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+
+function parseOrigin(value: string | null): string | undefined {
+	const origin = parseHeader(value);
+	try {
+		return new URL(origin ?? "").origin;
+	} catch {
+		return undefined;
+	}
+}
+
+function parseHeader(value: string | null): string | undefined {
+	const host = value?.trim().toLowerCase();
+	return host || undefined;
+}
+
+function formatHostForOrigin(host: string): string {
+	return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+
+function isDefaultProtocolPort(protocol: string, port: number): boolean {
+	return (
+		(protocol === "http:" && port === 80) ||
+		(protocol === "https:" && port === 443)
+	);
+}
+
+function originForHost(protocol: string, host: string, port: number): string {
+	return new URL(`${protocol}//${formatHostForOrigin(host)}:${port}`).origin;
+}
+
+function hostHeaderForHost(
+	protocol: string,
+	host: string,
+	port: number,
+): string {
+	const formattedHost = formatHostForOrigin(host).toLowerCase();
+	return isDefaultProtocolPort(protocol, port)
+		? formattedHost
+		: `${formattedHost}:${port}`;
+}
+
+export function allowedBrowserOrigins({
+	bindHost,
+	port,
+	publicUrl,
+}: BrowserRequestAuthOptions): Set<string> {
+	const publicUrlParts = new URL(publicUrl);
+	const origins = new Set<string>();
+	origins.add(publicUrlParts.origin);
+
+	origins.add(originForHost(publicUrlParts.protocol, bindHost, port));
+
+	if (!isNonLocalBindHost(bindHost)) {
+		for (const hostname of ["127.0.0.1", "localhost", "[::1]"]) {
+			origins.add(originForHost(publicUrlParts.protocol, hostname, port));
+		}
+	}
+
+	return origins;
+}
+
+export function allowedBrowserHosts({
+	bindHost,
+	port,
+	publicUrl,
+}: BrowserRequestAuthOptions): Set<string> {
+	const publicUrlParts = new URL(publicUrl);
+	const hosts = new Set<string>();
+	const publicHost = publicUrlParts.host.toLowerCase();
+	hosts.add(publicHost);
+
+	hosts.add(hostHeaderForHost(publicUrlParts.protocol, bindHost, port));
+
+	if (!isNonLocalBindHost(bindHost)) {
+		for (const hostname of ["127.0.0.1", "localhost", "[::1]"]) {
+			hosts.add(hostHeaderForHost(publicUrlParts.protocol, hostname, port));
+		}
+	}
+
+	return hosts;
+}
+
+export function requiresBrowserRequestAuth(
+	req: Request,
+	url: URL,
+	isPublicBrowserRoute: PublicBrowserRoutePredicate,
+): boolean {
+	if (isWebSocketUpgrade(req)) return true;
+	if (!SAFE_HTTP_METHODS.has(req.method.toUpperCase())) return true;
+	return !isPublicBrowserRoute(req, url);
+}
+
+export function isAuthorizedBrowserRequest(
+	req: Request,
+	url: URL,
+	options: BrowserRequestAuthOptions,
+): boolean {
+	const host = parseHeader(req.headers.get("host"));
+	if (!host || !allowedBrowserHosts(options).has(host)) return false;
+
+	const origin = parseOrigin(req.headers.get("origin"));
+	if (!origin || !allowedBrowserOrigins(options).has(origin)) return false;
+
+	if (!options.roomSecret) return true;
+	return url.searchParams.get("roomSecret") === options.roomSecret;
+}
+
+export function isAuthorizedBrowserToDesktopRequest(
+	req: Request,
+	url: URL,
+	options: BrowserRequestAuthOptions,
+	isPublicBrowserRoute: PublicBrowserRoutePredicate,
+): boolean {
+	return (
+		!requiresBrowserRequestAuth(req, url, isPublicBrowserRoute) ||
+		isAuthorizedBrowserRequest(req, url, options)
+	);
+}
diff --git a/apps/cline-hub/src/server/connectors.test.ts b/apps/cline-hub/src/server/connectors.test.ts
new file mode 100644
index 0000000..a8cbb32
--- /dev/null
+++ b/apps/cline-hub/src/server/connectors.test.ts
@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { __test__ } from "./connectors";
+
+describe("connector launch command", () => {
+	it("uses Bun conditions when launching the source CLI from Bun", () => {
+		expect(
+			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
+				execPath: "/Users/test/.bun/bin/bun",
+				cliPath: "/repo/apps/cli/src/index.ts",
+				exists: () => true,
+			}),
+		).toEqual({
+			launcher: "/Users/test/.bun/bin/bun",
+			childArgs: [
+				"--conditions=development",
+				"/repo/apps/cli/src/index.ts",
+				"connect",
+				"telegram",
+				"--bot-token",
+				"token",
+			],
+		});
+	});
+
+	it("uses compiled CLI subcommands without Bun flags", () => {
+		expect(
+			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
+				execPath: "/Applications/Cline/bin/cline",
+				cliPath: "/repo/apps/cli/src/index.ts",
+				exists: () => true,
+			}),
+		).toEqual({
+			launcher: "/Applications/Cline/bin/cline",
+			childArgs: ["connect", "telegram", "--bot-token", "token"],
+		});
+	});
+
+	it("uses Bun conditions when launching the source CLI from Node", () => {
+		expect(
+			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
+				execPath: "/usr/local/bin/node",
+				cliPath: "/repo/apps/cli/src/index.ts",
+				exists: () => true,
+			}),
+		).toEqual({
+			launcher: "bun",
+			childArgs: [
+				"--conditions=development",
+				"/repo/apps/cli/src/index.ts",
+				"connect",
+				"telegram",
+				"--bot-token",
+				"token",
+			],
+		});
+	});
+
+	it("detects Windows Node when launching the source CLI", () => {
+		expect(
+			__test__.buildCliConnectCommand(["telegram", "--bot-token", "token"], {
+				execPath: "node.exe",
+				cliPath: "C:\\repo\\apps\\cli\\src\\index.ts",
+				exists: () => true,
+			}),
+		).toEqual({
+			launcher: "bun",
+			childArgs: [
+				"--conditions=development",
+				"C:\\repo\\apps\\cli\\src\\index.ts",
+				"connect",
+				"telegram",
+				"--bot-token",
+				"token",
+			],
+		});
+	});
+
+	it("strips terminal color codes from connector command failures", () => {
+		expect(
+			__test__.normalizeConnectorError(
+				"\u001B[31merror:\u001B[0m error: unknown option '--conditions=development'",
+				"connector start failed",
+			),
+		).toBe("unknown option '--conditions=development'");
+	});
+
+	it("turns Telegram unauthorized responses into a token validation message", () => {
+		expect(
+			__test__.normalizeConnectorError(
+				"\u001B[31merror:\u001B[0m Telegram getMe failed (401 Unauthorized): Unauthorized",
+				"connector start failed",
+			),
+		).toBe(
+			"Telegram rejected this bot token. Copy the token from @BotFather and try again.",
+		);
+	});
+});
diff --git a/apps/cline-hub/src/server/connectors.ts b/apps/cline-hub/src/server/connectors.ts
new file mode 100644
index 0000000..1613043
--- /dev/null
+++ b/apps/cline-hub/src/server/connectors.ts
@@ -0,0 +1,258 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import process from "node:process";
+import { withResolvedClineBuildEnv } from "@cline/shared";
+import { listConnectorCatalog } from "../../../cli/src/connectors/catalog";
+import { listActiveConnectors } from "../../../cli/src/connectors/status";
+import {
+	PLATFORMS,
+	shouldIncludeField,
+} from "../../../cli/src/wizards/connect/platforms";
+import type {
+	WebviewConnectorChannel,
+	WebviewConnectorChannelsResponse,
+} from "../webview-protocol";
+import { cliIndexPath, workspaceRoot } from "./deps";
+import { asRecord, asString } from "./utils";
+
+type CliConnectCommand = {
+	launcher: string;
+	childArgs: string[];
+};
+
+const ANSI_ESCAPE_PATTERN = new RegExp(
+	[
+		"[\\u001B\\u009B][[\\]()#;?]*",
+		"(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)",
+		"|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+	].join(""),
+	"g",
+);
+
+function stripAnsi(value: string): string {
+	return value.replace(ANSI_ESCAPE_PATTERN, "");
+}
+
+function normalizeConnectorError(rawMessage: string, fallback: string): string {
+	const message =
+		stripAnsi(rawMessage)
+			.replace(/\r\n/g, "\n")
+			.trim()
+			.replace(/^(?:error:\s*)+/i, "")
+			.trim() || fallback;
+
+	if (
+		/^Telegram getMe failed \(401 Unauthorized\): Unauthorized$/i.test(message)
+	) {
+		return "Telegram rejected this bot token. Copy the token from @BotFather and try again.";
+	}
+
+	return message.slice(0, 2_000);
+}
+
+function buildCliConnectCommand(
+	args: string[],
+	options: {
+		execPath?: string;
+		cliPath?: string;
+		exists?: (path: string) => boolean;
+	} = {},
+): CliConnectCommand {
+	const execPath = options.execPath ?? process.execPath;
+	const cliPath = options.cliPath ?? cliIndexPath;
+	const exists = options.exists ?? existsSync;
+	const runtimeName = basename(execPath).toLowerCase();
+	const isBunRuntime = runtimeName.includes("bun");
+	const isNodeRuntime = runtimeName === "node" || runtimeName === "node.exe";
+	const useBunSourceEntrypoint =
+		(isBunRuntime || isNodeRuntime) && exists(cliPath);
+	const launcher = isBunRuntime
+		? execPath
+		: useBunSourceEntrypoint
+			? "bun"
+			: execPath;
+	const childArgs = useBunSourceEntrypoint
+		? ["--conditions=development", cliPath, "connect", ...args]
+		: ["connect", ...args];
+	return { launcher, childArgs };
+}
+
+export function connectorChannelsPayload(): WebviewConnectorChannelsResponse {
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	const available: WebviewConnectorChannel[] = PLATFORMS.filter((platform) =>
+		supported.has(platform.id),
+	).map((platform) => ({
+		id: platform.id,
+		name: platform.name,
+		type: platform.type,
+		hint: platform.hint,
+		fields: platform.fields.map((field) => ({
+			flag: field.flag,
+			label: field.label,
+			placeholder: field.placeholder,
+			required: field.required,
+			help: field.help,
+			initialValue: field.initialValue,
+			options: field.options,
+			includeWhen: field.includeWhen,
+		})),
+		security: platform.security
+			? {
+					prompt: platform.security.prompt,
+					fields: platform.security.fields.map((field) => ({
+						key: field.key,
+						label: field.label,
+						placeholder: field.placeholder,
+						help: field.help,
+						requiredMessage: field.requiredMessage,
+					})),
+				}
+			: undefined,
+	}));
+	return { available, active: listActiveConnectors() };
+}
+
+async function runCliConnectCommand(args: string[]): Promise<{
+	code: number;
+	stdout: string;
+	stderr: string;
+}> {
+	const { launcher, childArgs } = buildCliConnectCommand(args);
+	const child = spawn(launcher, childArgs, {
+		cwd: workspaceRoot,
+		env: withResolvedClineBuildEnv(process.env),
+		stdio: ["ignore", "pipe", "pipe"],
+		// Prevent a console window from flashing on Windows.
+		windowsHide: true,
+	});
+	let stdout = "";
+	let stderr = "";
+	child.stdout?.setEncoding("utf8");
+	child.stderr?.setEncoding("utf8");
+	child.stdout?.on("data", (chunk) => {
+		stdout += String(chunk);
+	});
+	child.stderr?.on("data", (chunk) => {
+		stderr += String(chunk);
+	});
+	const code = await new Promise<number>((resolve, reject) => {
+		child.on("error", reject);
+		child.on("close", (exitCode) => resolve(exitCode ?? 0));
+	});
+	return { code, stdout, stderr };
+}
+
+async function waitForConnectorState(
+	predicate: () => boolean,
+	timeoutMs = 5_000,
+): Promise<void> {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < timeoutMs) {
+		if (predicate()) return;
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+}
+
+function buildConnectorStartArgs(args?: Record<string, unknown>): string[] {
+	const channel = asString(args?.channel);
+	if (!channel) throw new Error("channel is required");
+	const platform = PLATFORMS.find((entry) => entry.id === channel);
+	if (!platform) throw new Error(`unknown connector channel: ${channel}`);
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	if (!supported.has(platform.id)) {
+		throw new Error(`connector channel is not available: ${channel}`);
+	}
+	const values = asRecord(args?.values) ?? {};
+	const fieldValues: Record<string, string> = {};
+	for (const field of platform.fields) {
+		const rawValue = values[field.flag];
+		if (typeof rawValue === "string") {
+			fieldValues[field.flag] = rawValue.trim();
+		} else if (field.initialValue) {
+			fieldValues[field.flag] = field.initialValue;
+		}
+	}
+	const cliArgs = [channel];
+	for (const field of platform.fields) {
+		if (!shouldIncludeField(field, fieldValues)) {
+			continue;
+		}
+		const value = fieldValues[field.flag];
+		if (!value) {
+			if (field.required) throw new Error(`${field.label} is required`);
+			continue;
+		}
+		cliArgs.push(field.flag, value);
+	}
+	const security = asRecord(args?.security);
+	if (security?.enabled === true && platform.security) {
+		const securityValues = asRecord(security.values) ?? {};
+		const hookValues: Record<string, string> = {};
+		for (const field of platform.security.fields) {
+			const value = asString(securityValues[field.key]);
+			if (!value) throw new Error(field.requiredMessage);
+			const validationError = field.validate?.(value);
+			if (validationError) throw new Error(validationError);
+			hookValues[field.key] = value;
+		}
+		cliArgs.push(...platform.security.buildArgs(hookValues));
+	}
+	return cliArgs;
+}
+
+export async function startConnectorChannel(
+	args?: Record<string, unknown>,
+): Promise<WebviewConnectorChannelsResponse> {
+	const cliArgs = buildConnectorStartArgs(args);
+	const channel = cliArgs[0] ?? "";
+	const result = await runCliConnectCommand(cliArgs);
+	if (result.code !== 0) {
+		throw new Error(
+			normalizeConnectorError(
+				result.stderr || result.stdout,
+				"connector start failed",
+			),
+		);
+	}
+	await waitForConnectorState(() =>
+		listActiveConnectors().some((connector) => connector.type === channel),
+	);
+	return connectorChannelsPayload();
+}
+
+export const __test__ = {
+	buildCliConnectCommand,
+	normalizeConnectorError,
+};
+
+export async function stopConnectorChannel(
+	args?: Record<string, unknown>,
+): Promise<WebviewConnectorChannelsResponse> {
+	const channel = asString(args?.channel);
+	if (!channel) throw new Error("channel is required");
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	if (!supported.has(channel)) {
+		throw new Error(`unknown connector channel: ${channel}`);
+	}
+	const result = await runCliConnectCommand([channel, "--stop"]);
+	if (result.code !== 0) {
+		throw new Error(
+			normalizeConnectorError(
+				result.stderr || result.stdout,
+				"connector stop failed",
+			),
+		);
+	}
+	await waitForConnectorState(
+		() =>
+			!listActiveConnectors().some((connector) => connector.type === channel),
+	);
+	return connectorChannelsPayload();
+}
diff --git a/apps/cline-hub/src/server/deps.ts b/apps/cline-hub/src/server/deps.ts
new file mode 100644
index 0000000..353f4fc
--- /dev/null
+++ b/apps/cline-hub/src/server/deps.ts
@@ -0,0 +1,26 @@
+import { dirname, join, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ProviderSettingsManager } from "@cline/core";
+import { buildInviteUrl, resolveClineHubServerOptions } from "../options";
+import type { BrowserConfig } from "./types";
+
+export const options = resolveClineHubServerOptions();
+export const { host, port, publicUrl, roomSecret, workspaceRoot } = options;
+export const inviteUrl = buildInviteUrl(publicUrl, roomSecret);
+
+const serverDir = dirname(fileURLToPath(import.meta.url));
+/** server.ts lives one level up from this module, so resolve relative to it. */
+export const appSrcDir = join(serverDir, "..");
+export const webviewDistDir =
+	process.env.CLINE_HUB_WEBVIEW_DIST_DIR?.trim() ||
+	join(appSrcDir, "../dist/webview");
+export const cliIndexPath = normalize(
+	join(appSrcDir, "../../cli/src/index.ts"),
+);
+
+export const providerSettingsManager = new ProviderSettingsManager();
+
+export const browserConfig: BrowserConfig = {
+	inviteRequired: Boolean(roomSecret),
+	publicUrl,
+};
diff --git a/apps/cline-hub/src/server/desktop-commands.ts b/apps/cline-hub/src/server/desktop-commands.ts
new file mode 100644
index 0000000..6624a2c
--- /dev/null
+++ b/apps/cline-hub/src/server/desktop-commands.ts
@@ -0,0 +1,319 @@
+import {
+	addLocalProvider,
+	type ClineAccountActionRequest,
+	ClineAccountService,
+	ensureCustomProvidersLoaded,
+	executeClineAccountAction,
+	formatProviderOAuthApiKey,
+	getLocalProviderModels,
+	getPersistedProviderApiKey,
+	getProviderOAuthCredentialsFromSettings,
+	getValidClineCredentials,
+	listLocalProviders,
+	loginAndSaveLocalProviderOAuthCredentials,
+	markLocalProviderEnabled,
+	normalizeOAuthProvider,
+	type ProviderCapability,
+	type ProviderClient,
+	type ProviderProtocol,
+	type ProviderSettings,
+	readGlobalSettings,
+	saveLocalProviderOAuthCredentials,
+	saveLocalProviderSettings,
+	setAutoUpdateEnabledGlobally,
+	setDisabledPlugin,
+	setDisabledTools,
+	setTelemetryOptOutGlobally,
+	toggleDisabledTool,
+} from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import {
+	connectorChannelsPayload,
+	startConnectorChannel,
+	stopConnectorChannel,
+} from "./connectors";
+import { providerSettingsManager, workspaceRoot } from "./deps";
+import {
+	installMarketplaceEntryForDesktopCommand,
+	listMarketplaceInstalledEntries,
+	uninstallLocalPrimitive,
+	uninstallMarketplaceEntryForDesktopCommand,
+} from "./marketplace";
+import {
+	deleteMcpServer,
+	ensureMcpSettingsFile,
+	readMcpServersResponse,
+	setMcpServerDisabled,
+	upsertMcpServer,
+} from "./mcp";
+import { handleRoutineScheduleCommand } from "./schedules";
+import { toWebviewSessionSummary } from "./session-mapping";
+import type { HubContext } from "./state";
+import { broadcastHubState } from "./state-payloads";
+import type { JsonRecord } from "./types";
+import { listUserInstructionConfigs } from "./user-instructions";
+import { openExternalUrl, readProviderSettingsUpdate } from "./utils";
+
+const ROUTINE_SCHEDULE_COMMANDS = new Set([
+	"list_routine_schedules",
+	"create_routine_schedule",
+	"update_routine_schedule",
+	"pause_routine_schedule",
+	"resume_routine_schedule",
+	"trigger_routine_schedule",
+	"delete_routine_schedule",
+]);
+
+async function resolveHubClineAccountAuthToken(input: {
+	settings?: ProviderSettings;
+	apiBaseUrl: string;
+}): Promise<string | undefined> {
+	const credentials = input.settings
+		? getProviderOAuthCredentialsFromSettings("cline", input.settings)
+		: null;
+	if (!credentials || !input.settings) {
+		return getPersistedProviderApiKey("cline", input.settings);
+	}
+
+	const nextCredentials = await getValidClineCredentials(credentials, {
+		apiBaseUrl: input.apiBaseUrl,
+	});
+	if (!nextCredentials) {
+		throw new Error(
+			"Cline account requires re-authentication. Run cline auth cline.",
+		);
+	}
+
+	if (nextCredentials !== credentials) {
+		saveLocalProviderOAuthCredentials(
+			providerSettingsManager,
+			"cline",
+			input.settings,
+			nextCredentials,
+			{ setLastUsed: false },
+		);
+	}
+
+	return formatProviderOAuthApiKey("cline", nextCredentials);
+}
+
+export async function handleDesktopCommand(
+	ctx: HubContext,
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<unknown> {
+	if (command === "list_provider_catalog") {
+		await ensureCustomProvidersLoaded(providerSettingsManager);
+		return await listLocalProviders(providerSettingsManager, {
+			isClinePassEnabled: true,
+		});
+	}
+	if (command === "list_provider_models") {
+		const provider = String(args?.provider ?? "").trim();
+		return await getLocalProviderModels(
+			provider,
+			providerSettingsManager.getProviderConfig(provider),
+		);
+	}
+	if (command === "save_provider_settings") {
+		return saveLocalProviderSettings(providerSettingsManager, {
+			...readProviderSettingsUpdate(args),
+			providerId: String(args?.provider ?? ""),
+			enabled: typeof args?.enabled === "boolean" ? args.enabled : undefined,
+			apiKey: typeof args?.api_key === "string" ? args.api_key : undefined,
+			baseUrl: typeof args?.base_url === "string" ? args.base_url : undefined,
+		});
+	}
+	if (command === "add_provider") {
+		await ensureCustomProvidersLoaded(providerSettingsManager);
+		return await addLocalProvider(providerSettingsManager, {
+			providerId: String(args?.provider_id ?? ""),
+			name: String(args?.name ?? ""),
+			baseUrl: String(args?.base_url ?? ""),
+			apiKey: typeof args?.api_key === "string" ? args.api_key : undefined,
+			headers:
+				args?.headers && typeof args.headers === "object"
+					? (args.headers as Record<string, string>)
+					: undefined,
+			timeoutMs:
+				typeof args?.timeout_ms === "number" ? args.timeout_ms : undefined,
+			models: Array.isArray(args?.models)
+				? (args.models as string[])
+				: undefined,
+			defaultModelId:
+				typeof args?.default_model_id === "string"
+					? args.default_model_id
+					: undefined,
+			modelsSourceUrl:
+				typeof args?.models_source_url === "string"
+					? args.models_source_url
+					: undefined,
+			protocol:
+				typeof args?.protocol === "string"
+					? (args.protocol as ProviderProtocol)
+					: undefined,
+			client:
+				typeof args?.client === "string"
+					? (args.client as ProviderClient)
+					: undefined,
+			capabilities: Array.isArray(args?.capabilities)
+				? (args.capabilities as ProviderCapability[])
+				: undefined,
+		});
+	}
+	if (command === "run_provider_oauth_login") {
+		const providerId = normalizeOAuthProvider(String(args?.provider ?? ""));
+		const saved = await loginAndSaveLocalProviderOAuthCredentials(
+			providerSettingsManager,
+			providerId,
+			openExternalUrl,
+		);
+		if (saved.provider !== providerId) {
+			markLocalProviderEnabled(providerSettingsManager, providerId, {
+				tokenSource: "oauth",
+			});
+		}
+		return {
+			provider: providerId,
+			accessToken: saved.auth?.accessToken ?? saved.apiKey ?? "",
+		};
+	}
+	if (command === "cline_account") {
+		const settings = providerSettingsManager.getProviderSettings("cline");
+		const apiBaseUrl =
+			settings?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl;
+		const authToken = await resolveHubClineAccountAuthToken({
+			settings,
+			apiBaseUrl,
+		});
+		if (!authToken) {
+			throw new Error("No Cline account auth token found");
+		}
+		const accountService = new ClineAccountService({
+			apiBaseUrl,
+			getAuthToken: async () => authToken,
+		});
+		return await executeClineAccountAction(
+			args as ClineAccountActionRequest,
+			accountService,
+		);
+	}
+	if (command === "get_global_settings") {
+		return readGlobalSettings();
+	}
+	if (command === "set_telemetry_opt_out") {
+		if (typeof args?.telemetry_opt_out !== "boolean") {
+			throw new Error("telemetry_opt_out must be a boolean");
+		}
+		setTelemetryOptOutGlobally(args.telemetry_opt_out);
+		return readGlobalSettings();
+	}
+	if (command === "set_auto_update_enabled") {
+		if (typeof args?.auto_update_enabled !== "boolean") {
+			throw new Error("auto_update_enabled must be a boolean");
+		}
+		setAutoUpdateEnabledGlobally(args.auto_update_enabled);
+		return readGlobalSettings();
+	}
+	if (command === "list_connector_channels") {
+		return connectorChannelsPayload();
+	}
+	if (command === "start_connector_channel") {
+		const response = await startConnectorChannel(args);
+		broadcastHubState(ctx);
+		return response;
+	}
+	if (command === "stop_connector_channel") {
+		const response = await stopConnectorChannel(args);
+		broadcastHubState(ctx);
+		return response;
+	}
+	if (command === "list_mcp_servers") {
+		return readMcpServersResponse();
+	}
+	if (command === "set_mcp_server_disabled") {
+		return setMcpServerDisabled(
+			String(args?.name ?? "").trim(),
+			Boolean(args?.disabled),
+		);
+	}
+	if (command === "upsert_mcp_server") {
+		const input =
+			args?.input && typeof args.input === "object"
+				? (args.input as JsonRecord)
+				: ((args ?? {}) as JsonRecord);
+		return upsertMcpServer(input);
+	}
+	if (command === "delete_mcp_server") {
+		return deleteMcpServer(String(args?.name ?? "").trim());
+	}
+	if (command === "ensure_mcp_settings_file") {
+		return ensureMcpSettingsFile();
+	}
+	if (command === "open_mcp_settings_file") {
+		const path = ensureMcpSettingsFile();
+		openExternalUrl(path);
+		return path;
+	}
+	if (ROUTINE_SCHEDULE_COMMANDS.has(command)) {
+		return await handleRoutineScheduleCommand(command, args);
+	}
+	if (command === "get_process_context") {
+		return { workspaceRoot, cwd: workspaceRoot };
+	}
+	if (
+		command === "list_cli_sessions" ||
+		command === "list_discovered_sessions"
+	) {
+		return [...ctx.sessions.values()].map(toWebviewSessionSummary);
+	}
+	if (command === "read_session_hooks") {
+		return [];
+	}
+	if (command === "list_user_instruction_configs") {
+		return await listUserInstructionConfigs(workspaceRoot);
+	}
+	if (command === "list_marketplace_installed_entries") {
+		return listMarketplaceInstalledEntries(
+			args,
+			await listUserInstructionConfigs(workspaceRoot),
+		);
+	}
+	if (command === "install_marketplace_entry") {
+		const result = await installMarketplaceEntryForDesktopCommand(args);
+		broadcastHubState(ctx);
+		return result;
+	}
+	if (command === "uninstall_marketplace_entry") {
+		const result = await uninstallMarketplaceEntryForDesktopCommand(args);
+		broadcastHubState(ctx);
+		return result;
+	}
+	if (command === "uninstall_local_primitive") {
+		const result = await uninstallLocalPrimitive(args, { workspaceRoot });
+		broadcastHubState(ctx);
+		return result;
+	}
+	if (command === "toggle_disabled_plugin_tool") {
+		const toolName = String(args?.name ?? "").trim();
+		if (!toolName) throw new Error("tool name is required");
+		toggleDisabledTool(toolName);
+		return await listUserInstructionConfigs(workspaceRoot);
+	}
+	if (command === "set_tool_disabled") {
+		const rawNames = Array.isArray(args?.names) ? args.names : [args?.name];
+		const toolNames = rawNames
+			.map((name) => String(name ?? "").trim())
+			.filter(Boolean);
+		if (toolNames.length === 0) throw new Error("tool name is required");
+		setDisabledTools(toolNames, args?.disabled === true);
+		return await listUserInstructionConfigs(workspaceRoot);
+	}
+	if (command === "set_plugin_disabled") {
+		const pluginPath = String(args?.path ?? "").trim();
+		if (!pluginPath) throw new Error("plugin path is required");
+		setDisabledPlugin(pluginPath, args?.disabled === true);
+		return await listUserInstructionConfigs(workspaceRoot);
+	}
+	throw new Error(`unsupported desktop command: ${command}`);
+}
diff --git a/apps/cline-hub/src/server/http.test.ts b/apps/cline-hub/src/server/http.test.ts
new file mode 100644
index 0000000..3aef7d5
--- /dev/null
+++ b/apps/cline-hub/src/server/http.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { isWebviewRoute, normalizeWebviewIndexHtml } from "./http";
+
+describe("isWebviewRoute", () => {
+	it.each([
+		"/",
+		"/chat",
+		"/sessions",
+		"/models",
+		"/customizations",
+		"/rules",
+		"/hooks",
+		"/mcp",
+		"/plugins",
+		"/skills",
+		"/agents",
+		"/tools",
+		"/marketplace",
+		"/marketplace/mcp",
+		"/marketplace/skills",
+		"/marketplace/plugins",
+		"/channels",
+		"/schedules",
+		"/settings",
+		"/settings/providers",
+	])("matches dashboard SPA route %s", (pathname) => {
+		expect(isWebviewRoute(pathname)).toBe(true);
+	});
+
+	it("does not treat nested marketplace asset requests as SPA routes", () => {
+		expect(isWebviewRoute("/marketplace/assets/index.js")).toBe(false);
+	});
+});
+
+describe("normalizeWebviewIndexHtml", () => {
+	it("rewrites relative built asset URLs so deep links can refresh", () => {
+		expect(
+			normalizeWebviewIndexHtml(
+				'<script type="module" src="./assets/index.js"></script><link href="./assets/index.css">',
+			),
+		).toBe(
+			'<script type="module" src="/assets/index.js"></script><link href="/assets/index.css">',
+		);
+	});
+
+	it("injects the persisted theme bootstrap once", () => {
+		const normalized = normalizeWebviewIndexHtml(
+			"<html><head></head><body></body></html>",
+		);
+
+		expect(normalized).toContain('id="cline-hub-theme-bootstrap"');
+		expect(normalizeWebviewIndexHtml(normalized)).toBe(normalized);
+	});
+});
diff --git a/apps/cline-hub/src/server/http.ts b/apps/cline-hub/src/server/http.ts
new file mode 100644
index 0000000..d425655
--- /dev/null
+++ b/apps/cline-hub/src/server/http.ts
@@ -0,0 +1,208 @@
+import { extname, join, normalize, relative } from "node:path";
+import process from "node:process";
+
+export function createJsonResponse(payload: unknown, status = 200): Response {
+	return new Response(JSON.stringify(payload), {
+		status,
+		headers: { "content-type": "application/json; charset=utf-8" },
+	});
+}
+
+export function createTextResponse(text: string, status = 200): Response {
+	return new Response(text, {
+		status,
+		headers: { "content-type": "text/plain; charset=utf-8" },
+	});
+}
+
+const NO_STORE_HEADERS = {
+	"cache-control": "no-store, no-cache, must-revalidate, proxy-revalidate",
+	pragma: "no-cache",
+	expires: "0",
+};
+
+const IMMUTABLE_ASSET_CACHE = "public, max-age=31536000, immutable";
+const THEME_BOOTSTRAP_SCRIPT = `<script id="cline-hub-theme-bootstrap">
+  (() => {
+    try {
+      const theme = window.localStorage.getItem("cline-hub-theme");
+      if (theme === "dark" || theme === "light") {
+        document.documentElement.classList.toggle("dark", theme === "dark");
+        document.documentElement.dataset.clineHubTheme = theme;
+      }
+    } catch {}
+  })();
+</script>`;
+
+function contentTypeFor(path: string): string {
+	switch (extname(path)) {
+		case ".html":
+			return "text/html; charset=utf-8";
+		case ".js":
+			return "text/javascript; charset=utf-8";
+		case ".css":
+			return "text/css; charset=utf-8";
+		case ".svg":
+			return "image/svg+xml";
+		case ".png":
+			return "image/png";
+		case ".ico":
+			return "image/x-icon";
+		case ".woff2":
+			return "font/woff2";
+		default:
+			return "application/octet-stream";
+	}
+}
+
+export function isWebviewRoute(pathname: string): boolean {
+	return (
+		pathname === "/" ||
+		pathname === "/index.html" ||
+		pathname === "/chat" ||
+		pathname === "/sessions" ||
+		pathname === "/models" ||
+		pathname === "/customizations" ||
+		pathname === "/rules" ||
+		pathname === "/hooks" ||
+		pathname === "/mcp" ||
+		pathname === "/plugins" ||
+		pathname === "/skills" ||
+		pathname === "/agents" ||
+		pathname === "/tools" ||
+		pathname === "/marketplace" ||
+		pathname === "/marketplace/mcp" ||
+		pathname === "/marketplace/skills" ||
+		pathname === "/marketplace/plugins" ||
+		pathname === "/channels" ||
+		pathname === "/schedules" ||
+		pathname === "/settings" ||
+		pathname.startsWith("/settings/")
+	);
+}
+
+export function normalizeWebviewIndexHtml(html: string): string {
+	const normalized = html
+		.replaceAll('src="./', 'src="/')
+		.replaceAll('href="./', 'href="/');
+	if (normalized.includes('id="cline-hub-theme-bootstrap"')) {
+		return normalized;
+	}
+	return normalized.replace("<head>", `<head>\n${THEME_BOOTSTRAP_SCRIPT}`);
+}
+
+function renderDevIndexHtml(devServerUrl: string): string {
+	return `<!doctype html>
+<html lang="en">
+<head>
+  ${THEME_BOOTSTRAP_SCRIPT}
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <script type="module">
+    import RefreshRuntime from "${devServerUrl}/@react-refresh";
+    RefreshRuntime.injectIntoGlobalHook(window);
+    window.$RefreshReg$ = () => {};
+    window.$RefreshSig$ = () => (type) => type;
+    window.__vite_plugin_react_preamble_installed__ = true;
+  </script>
+  <script type="module" src="${devServerUrl}/@vite/client"></script>
+  <link rel="icon" type="image/svg+xml" href="${devServerUrl}/cline-logo-filled.svg" />
+  <title>Cline Hub</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="${devServerUrl}/src/main.tsx"></script>
+</body>
+</html>`;
+}
+
+/** Serves the built webview SPA and its static assets out of `webviewDistDir`. */
+export class WebviewAssets {
+	constructor(private readonly webviewDistDir: string) {}
+
+	private async resolveCurrentMainAssetPath(): Promise<string | undefined> {
+		const indexFile = Bun.file(join(this.webviewDistDir, "index.html"));
+		if (!(await indexFile.exists())) return undefined;
+		const html = await indexFile.text();
+		const match = html.match(/src="\.\/(assets\/index-[^"]+\.js)"/);
+		return match?.[1] ? join(this.webviewDistDir, match[1]) : undefined;
+	}
+
+	private resolveStaticPath(pathname: string): string | undefined {
+		const decoded = decodeURIComponent(pathname);
+		const requested = decoded === "/" ? "/index.html" : decoded;
+		const normalized = normalize(requested).replace(/^(\.\.[/\\])+/, "");
+		const relativePath = normalized.replace(/^[/\\]+/, "");
+		const filePath = join(this.webviewDistDir, relativePath);
+		if (relative(this.webviewDistDir, filePath).startsWith("..")) {
+			return undefined;
+		}
+		return filePath;
+	}
+
+	private async serveIndex(): Promise<Response> {
+		const indexFile = Bun.file(join(this.webviewDistDir, "index.html"));
+		if (await indexFile.exists()) {
+			return new Response(normalizeWebviewIndexHtml(await indexFile.text()), {
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					...NO_STORE_HEADERS,
+				},
+			});
+		}
+		return createTextResponse(
+			"Cline Hub webview is not built. Run `bun run build:webview` from apps/cline-hub.",
+			503,
+		);
+	}
+
+	async serve(pathname: string): Promise<Response> {
+		const devServerUrl = process.env.VITE_DEV_SERVER_URL?.trim();
+		if (devServerUrl && isWebviewRoute(pathname)) {
+			return new Response(renderDevIndexHtml(devServerUrl), {
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					...NO_STORE_HEADERS,
+				},
+			});
+		}
+		if (isWebviewRoute(pathname)) {
+			return this.serveIndex();
+		}
+
+		const filePath = this.resolveStaticPath(pathname);
+		if (!filePath) return createTextResponse("not found", 404);
+		let responsePath = filePath;
+		let file = Bun.file(responsePath);
+		if (
+			!(await file.exists()) &&
+			/^\/assets\/index-[A-Za-z0-9_-]+\.js$/.test(pathname)
+		) {
+			const currentMainAssetPath = await this.resolveCurrentMainAssetPath();
+			if (currentMainAssetPath) {
+				responsePath = currentMainAssetPath;
+				file = Bun.file(responsePath);
+			}
+		}
+		if (!(await file.exists())) {
+			return createTextResponse("not found", 404);
+		}
+		const isHashedAsset = /^\/assets\/.+-[A-Za-z0-9_-]+\.[A-Za-z0-9]+$/.test(
+			pathname,
+		);
+		return new Response(file, {
+			headers: {
+				"content-type": contentTypeFor(responsePath),
+				"cache-control": isHashedAsset
+					? IMMUTABLE_ASSET_CACHE
+					: NO_STORE_HEADERS["cache-control"],
+				...(isHashedAsset
+					? {}
+					: {
+							pragma: NO_STORE_HEADERS.pragma,
+							expires: NO_STORE_HEADERS.expires,
+						}),
+			},
+		});
+	}
+}
diff --git a/apps/cline-hub/src/server/hub.ts b/apps/cline-hub/src/server/hub.ts
new file mode 100644
index 0000000..a917c05
--- /dev/null
+++ b/apps/cline-hub/src/server/hub.ts
@@ -0,0 +1,273 @@
+import {
+	ClineCore,
+	ensureDetachedHubServer,
+	type HubServerDiscoveryRecord,
+	HubUIClient,
+	stopLocalHubServerGracefully,
+	toHubHealthUrl,
+} from "@cline/core";
+import type { HubUINotifyPayload } from "@cline/shared";
+import { handleSessionEvent } from "./agent-events";
+import {
+	rejectAllPendingApprovals,
+	requestToolApprovalFromWebview,
+} from "./approvals";
+import { workspaceRoot } from "./deps";
+import {
+	formatClientName,
+	formatSessionCreator,
+	parseSessionContext,
+	trackSession,
+} from "./session-mapping";
+import type { HubContext } from "./state";
+import { broadcastHubState } from "./state-payloads";
+import type { SessionContext } from "./types";
+import { asString, basename, isActiveSession, isVisibleClient } from "./utils";
+
+export async function syncHubHealth(ctx: HubContext): Promise<void> {
+	if (!ctx.hubUrl) {
+		ctx.hubHealthy = false;
+		return;
+	}
+	try {
+		const response = await fetch(toHubHealthUrl(ctx.hubUrl));
+		if (!response.ok) {
+			ctx.hubHealthy = false;
+			return;
+		}
+		ctx.hubHealthy = true;
+		const health = (await response.json()) as Partial<HubServerDiscoveryRecord>;
+		if (typeof health.startedAt === "string")
+			ctx.hubStartedAt = health.startedAt;
+		if (typeof health.coreVersion === "string") {
+			ctx.coreVersion = health.coreVersion;
+		}
+	} catch {
+		ctx.hubHealthy = false;
+		// best-effort
+	}
+}
+
+export async function syncHubClientsAndSessions(
+	ctx: HubContext,
+): Promise<void> {
+	if (!ctx.uiClient) return;
+	const [knownClients, knownSessions] = await Promise.all([
+		ctx.uiClient.listClients(),
+		ctx.uiClient.listSessions(10),
+	]);
+	ctx.clients.clear();
+	for (const client of knownClients) {
+		if (!client.clientId || !isVisibleClient(client.clientType)) continue;
+		ctx.clients.set(client.clientId, {
+			clientId: client.clientId,
+			displayName: client.displayName,
+			clientType: client.clientType,
+			connectedAt: client.connectedAt,
+		});
+	}
+	ctx.sessions.clear();
+	for (const session of knownSessions) {
+		const tracked = trackSession(session);
+		if (tracked) ctx.sessions.set(tracked.sessionId, tracked);
+	}
+	if (!ctx.initialHubEventEmitted) {
+		const activeSessionCount = [...ctx.sessions.values()].filter((session) =>
+			isActiveSession(session.title, session.status, session.participantCount),
+		).length;
+		ctx.pushEvent(
+			"Hub monitor connected",
+			`${ctx.clients.size} connected client${ctx.clients.size === 1 ? "" : "s"}, ${activeSessionCount} active session${activeSessionCount === 1 ? "" : "s"}`,
+			"success",
+		);
+		ctx.initialHubEventEmitted = true;
+	}
+	const mostRecent = [...knownSessions]
+		.sort((a, b) => b.updatedAt - a.updatedAt)
+		.map((s) => parseSessionContext(s))
+		.find((c): c is SessionContext => Boolean(c));
+	if (mostRecent) ctx.lastSessionContext = mostRecent;
+}
+
+export async function attachHub(ctx: HubContext): Promise<void> {
+	const hub = await ensureDetachedHubServer(workspaceRoot);
+	ctx.hubUrl = hub.url;
+	ctx.hubAuthToken = hub.authToken;
+
+	ctx.cline = await ClineCore.create({
+		clientName: "cline-hub",
+		backendMode: "hub",
+		capabilities: {
+			requestToolApproval: (request) =>
+				requestToolApprovalFromWebview(ctx, request),
+		},
+		hub: {
+			endpoint: ctx.hubUrl,
+			authToken: ctx.hubAuthToken,
+			clientType: "cline-hub-chat",
+			displayName: "Cline Hub Chat",
+			workspaceRoot,
+		},
+	});
+
+	ctx.uiClient = new HubUIClient({
+		address: ctx.hubUrl,
+		authToken: ctx.hubAuthToken,
+		clientType: "cline-hub-server",
+		displayName: "Cline Hub Server",
+	});
+	await ctx.uiClient.connect();
+
+	ctx.uiClient.subscribeUI({
+		onNotify(payload: HubUINotifyPayload) {
+			ctx.pushEvent(
+				payload.title,
+				payload.body,
+				payload.severity === "error"
+					? "error"
+					: payload.severity === "warning"
+						? "warn"
+						: "info",
+			);
+			ctx.broadcast({
+				type: "notification",
+				title: payload.title,
+				body: payload.body,
+				severity: payload.severity ?? "info",
+			});
+		},
+		onClientRegistered(payload) {
+			const clientId = asString(payload.clientId);
+			const clientType = asString(payload.clientType) ?? "unknown";
+			if (!clientId || !isVisibleClient(clientType)) return;
+			ctx.clients.set(clientId, {
+				clientId,
+				displayName: asString(payload.displayName),
+				clientType,
+				connectedAt: Date.now(),
+			});
+			ctx.pushEvent(
+				"Client connected",
+				`${asString(payload.displayName) ?? clientType} joined the hub`,
+				"success",
+			);
+			broadcastHubState(ctx);
+		},
+		onClientDisconnected(payload) {
+			const clientId = asString(payload.clientId);
+			if (!clientId) return;
+			const client = ctx.clients.get(clientId);
+			ctx.clients.delete(clientId);
+			if (client) {
+				ctx.pushEvent(
+					"Client disconnected",
+					`${formatClientName(client)} left the hub`,
+					"info",
+				);
+			}
+			broadcastHubState(ctx);
+		},
+		onSessionCreated(payload) {
+			const record =
+				payload.session && typeof payload.session === "object"
+					? (payload.session as Record<string, unknown>)
+					: (payload as unknown as Record<string, unknown>);
+			const tracked = trackSession(record);
+			if (tracked) {
+				ctx.sessions.set(tracked.sessionId, tracked);
+				const context = parseSessionContext(record);
+				if (context) ctx.lastSessionContext = context;
+				ctx.pushEvent(
+					"Session started",
+					`By ${formatSessionCreator(ctx, tracked)} at ${basename(tracked.workspaceRoot || tracked.cwd)}`,
+					"success",
+				);
+				broadcastHubState(ctx);
+			}
+		},
+		onSessionUpdated(payload) {
+			const record =
+				payload.session && typeof payload.session === "object"
+					? (payload.session as Record<string, unknown>)
+					: (payload as unknown as Record<string, unknown>);
+			const tracked = trackSession(record);
+			if (tracked) {
+				ctx.sessions.set(tracked.sessionId, tracked);
+				const context = parseSessionContext(record);
+				if (context) ctx.lastSessionContext = context;
+				broadcastHubState(ctx);
+			}
+		},
+		onSessionDetached(payload) {
+			const sessionId =
+				asString((payload as Record<string, unknown>).sessionId) ??
+				asString(
+					(
+						(payload as Record<string, unknown>).session as
+							| Record<string, unknown>
+							| undefined
+					)?.sessionId,
+				);
+			if (sessionId) {
+				ctx.sessions.delete(sessionId);
+				broadcastHubState(ctx);
+			}
+		},
+	});
+
+	ctx.cline.subscribe((event) => handleSessionEvent(ctx, event));
+
+	await syncHubClientsAndSessions(ctx);
+	await syncHubHealth(ctx);
+}
+
+export async function detachHub(ctx: HubContext): Promise<void> {
+	rejectAllPendingApprovals(
+		ctx,
+		"Hub disconnected before approval was resolved.",
+	);
+	for (const peer of ctx.peers) {
+		peer.unsubscribeEvents?.();
+		peer.unsubscribeEvents = undefined;
+	}
+	try {
+		ctx.uiClient?.close();
+	} catch {
+		// ignore
+	}
+	ctx.uiClient = undefined;
+	try {
+		await ctx.cline?.dispose();
+	} catch {
+		// ignore
+	}
+	ctx.cline = undefined;
+	ctx.clients.clear();
+	ctx.sessions.clear();
+	ctx.hubStartedAt = undefined;
+	ctx.coreVersion = undefined;
+	ctx.initialHubEventEmitted = false;
+}
+
+export async function restartHub(ctx: HubContext): Promise<void> {
+	ctx.broadcast({
+		type: "notification",
+		title: "Hub restarting",
+		body: "Shutting down and respawning hub...",
+		severity: "warn",
+	});
+	await detachHub(ctx);
+	try {
+		await stopLocalHubServerGracefully();
+	} catch (error) {
+		console.warn("stopLocalHubServerGracefully failed:", error);
+	}
+	await attachHub(ctx);
+	broadcastHubState(ctx);
+	ctx.broadcast({
+		type: "notification",
+		title: "Hub restarted",
+		body: `Connected to ${ctx.hubUrl}`,
+		severity: "info",
+	});
+}
diff --git a/apps/cline-hub/src/server/marketplace.test.ts b/apps/cline-hub/src/server/marketplace.test.ts
new file mode 100644
index 0000000..66d1929
--- /dev/null
+++ b/apps/cline-hub/src/server/marketplace.test.ts
@@ -0,0 +1,954 @@
+import { createHash } from "node:crypto";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	buildMarketplaceMcpInput,
+	fetchMarketplaceCatalog,
+	installMarketplaceEntry,
+	installMarketplaceEntryForDesktopCommand,
+	listMarketplaceInstalledEntries,
+	uninstallLocalPrimitive,
+	uninstallMarketplaceEntry,
+	uninstallMarketplaceEntryForDesktopCommand,
+} from "./marketplace";
+
+describe("marketplace installer", () => {
+	const originalWrapperPath = process.env.CLINE_WRAPPER_PATH;
+	const originalClineDir = process.env.CLINE_DIR;
+	const originalHome = process.env.HOME;
+	const originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+
+	afterEach(() => {
+		if (originalWrapperPath === undefined) {
+			delete process.env.CLINE_WRAPPER_PATH;
+		} else {
+			process.env.CLINE_WRAPPER_PATH = originalWrapperPath;
+		}
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR;
+		} else {
+			process.env.CLINE_DIR = originalClineDir;
+		}
+		if (originalHome === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = originalHome;
+		}
+		if (originalMcpSettingsPath === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
+		}
+		vi.restoreAllMocks();
+	});
+
+	function createInstalledOfficialPlugin(
+		clineDir: string,
+		slug: string,
+	): string {
+		const sourceKey = `official:https://github.com/cline/plugins.git#plugins/${slug}`;
+		const hash = createHash("sha256")
+			.update(sourceKey)
+			.digest("hex")
+			.slice(0, 12);
+		const installPath = join(
+			clineDir,
+			"plugins",
+			"_installed",
+			"official",
+			`${slug}-${hash}`,
+		);
+		mkdirSync(join(installPath, "package"), { recursive: true });
+		writeFileSync(
+			join(installPath, "package.json"),
+			JSON.stringify({ name: slug }, null, 2),
+			"utf8",
+		);
+		writeFileSync(
+			join(installPath, "package", "index.ts"),
+			`export default { name: "${slug}", manifest: { capabilities: ["tools"] } };`,
+			"utf8",
+		);
+		return installPath;
+	}
+
+	it("maps remote MCP catalog args to MCP settings shape", () => {
+		expect(
+			buildMarketplaceMcpInput([
+				"context7",
+				"--transport",
+				"http",
+				"https://mcp.context7.com/mcp",
+				"--header",
+				"Authorization: Bearer <token>",
+			]),
+		).toEqual({
+			name: "context7",
+			transportType: "streamableHttp",
+			url: "https://mcp.context7.com/mcp",
+			headers: {
+				Authorization: "Bearer <token>",
+			},
+			disabled: false,
+		});
+	});
+
+	it("maps stdio MCP catalog args to command and args", () => {
+		expect(
+			buildMarketplaceMcpInput(["filesystem", "npx", "-y", "server", "/tmp"]),
+		).toEqual({
+			name: "filesystem",
+			transportType: "stdio",
+			command: "npx",
+			args: ["-y", "server", "/tmp"],
+			disabled: false,
+		});
+	});
+
+	it("preserves server flags after stdio MCP command args begin", () => {
+		expect(
+			buildMarketplaceMcpInput([
+				"search",
+				"npx",
+				"-y",
+				"server",
+				"--transport",
+				"stdio",
+			]),
+		).toEqual({
+			name: "search",
+			transportType: "stdio",
+			command: "npx",
+			args: ["-y", "server", "--transport", "stdio"],
+			disabled: false,
+		});
+	});
+
+	it("runs skills globally for Cline without prompts", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		const spawnCommand = vi.fn(async () => {
+			mkdirSync(join(homeDir, ".agents", "skills", "web-design-guidelines"), {
+				recursive: true,
+			});
+			writeFileSync(
+				join(homeDir, ".agents", "skills", "web-design-guidelines", "SKILL.md"),
+				"---\nname: web-design-guidelines\n---\n",
+			);
+			return {
+				exitCode: 0,
+				stdout: "installed",
+				stderr: "",
+			};
+		});
+
+		await installMarketplaceEntry(
+			{
+				entry: {
+					id: "web-design-guidelines",
+					type: "skill",
+					name: "Web Design Guidelines",
+					install: {
+						args: [
+							"vercel-labs/agent-skills",
+							"--skill",
+							"web-design-guidelines",
+						],
+					},
+				},
+			},
+			{ spawnCommand },
+		);
+
+		expect(spawnCommand).toHaveBeenCalledWith("npx", [
+			"-y",
+			"skills@latest",
+			"add",
+			"vercel-labs/agent-skills",
+			"--skill",
+			"web-design-guidelines",
+			"-g",
+			"-a",
+			"cline",
+			"-y",
+		]);
+	});
+
+	it("skips skill install commands when the global skill already exists", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		mkdirSync(join(homeDir, ".agents", "skills", "cline-sdk"), {
+			recursive: true,
+		});
+		writeFileSync(
+			join(homeDir, ".agents", "skills", "cline-sdk", "SKILL.md"),
+			"---\nname: cline-sdk\n---\n",
+		);
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		}));
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).resolves.toMatchObject({
+			status: "installed",
+			message: "Cline SDK is already installed.",
+		});
+		expect(spawnCommand).not.toHaveBeenCalled();
+	});
+
+	it("reports Cline global skills as marketplace-installed", () => {
+		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-cline-"));
+		process.env.CLINE_DIR = clineDir;
+		mkdirSync(join(clineDir, "skills", "cline-sdk"), {
+			recursive: true,
+		});
+		writeFileSync(
+			join(clineDir, "skills", "cline-sdk", "SKILL.md"),
+			"---\nname: cline-sdk\n---\n",
+		);
+
+		expect(
+			listMarketplaceInstalledEntries({
+				entries: [
+					{
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				],
+			}),
+		).toEqual({ installedKeys: ["skill:cline-sdk"] });
+	});
+
+	it("accepts skill installs that create Cline global skills", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		const clineDir = join(homeDir, ".cline");
+		process.env.HOME = homeDir;
+		process.env.CLINE_DIR = clineDir;
+		const spawnCommand = vi.fn(async () => {
+			mkdirSync(join(clineDir, "skills", "cline-sdk"), {
+				recursive: true,
+			});
+			writeFileSync(
+				join(clineDir, "skills", "cline-sdk", "SKILL.md"),
+				"---\nname: cline-sdk\n---\n",
+			);
+			return {
+				exitCode: 0,
+				stdout: "installed",
+				stderr: "",
+			};
+		});
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).resolves.toMatchObject({
+			status: "installed",
+			message: "Installed Cline SDK globally for Cline.",
+		});
+	});
+
+	it("removes Cline global marketplace skills without prompts", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		const skillDir = join(homeDir, ".agents", "skills", "cline-sdk");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(join(skillDir, "SKILL.md"), "---\nname: cline-sdk\n---\n");
+		const spawnCommand = vi.fn(async () => {
+			rmSync(skillDir, { recursive: true, force: true });
+			return {
+				exitCode: 0,
+				stdout: "removed",
+				stderr: "",
+			};
+		});
+
+		await expect(
+			uninstallMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).resolves.toMatchObject({
+			status: "uninstalled",
+			message: "Uninstalled Cline SDK.",
+		});
+		expect(spawnCommand).toHaveBeenCalledWith("npx", [
+			"-y",
+			"skills@latest",
+			"remove",
+			"cline-sdk",
+			"-g",
+			"-y",
+		]);
+	});
+
+	it("does not report project-local skills as marketplace-installed globals", () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+
+		expect(
+			listMarketplaceInstalledEntries(
+				{
+					entries: [
+						{
+							id: "cline-sdk",
+							type: "skill",
+							name: "Cline SDK",
+							install: { args: ["cline/sdk-skill"] },
+						},
+					],
+				},
+				{
+					skills: [
+						{
+							id: "cline-sdk",
+							name: "cline-sdk",
+							path: "/workspace/project/.agents/skills/cline-sdk/SKILL.md",
+						},
+					],
+				},
+			),
+		).toEqual({ installedKeys: [] });
+	});
+
+	it("rejects skill installs that exit zero but report failure", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "Failed to install 1",
+			stderr: "",
+		}));
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).rejects.toThrow("Skill install failed");
+	});
+
+	it("redacts common secret formats from failed install output", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 1,
+			stdout:
+				"Authorization: Bearer stdout-token\nAuthorization: Basic basic-token\napi key stdout-key\nOPENAI_API_KEY=compound-key",
+			stderr:
+				"TOKEN=stderr-token\npassword is stderr-password\nANTHROPIC_SECRET_KEY=anthropic-secret",
+		}));
+
+		let message = "";
+		try {
+			await installMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			);
+		} catch (error) {
+			message = error instanceof Error ? error.message : String(error);
+		}
+
+		expect(message).toContain("Authorization: Bearer [redacted]");
+		expect(message).toContain("Authorization: [redacted]");
+		expect(message).not.toContain("Authorization: Bearer [redacted]]");
+		expect(message).toContain("api key [redacted]");
+		expect(message).toContain("OPENAI_API_KEY=[redacted]");
+		expect(message).toContain("TOKEN=[redacted]");
+		expect(message).toContain("password is [redacted]");
+		expect(message).toContain("ANTHROPIC_SECRET_KEY=[redacted]");
+		expect(message).not.toContain("stdout-token");
+		expect(message).not.toContain("basic-token");
+		expect(message).not.toContain("stdout-key");
+		expect(message).not.toContain("compound-key");
+		expect(message).not.toContain("stderr-token");
+		expect(message).not.toContain("stderr-password");
+		expect(message).not.toContain("anthropic-secret");
+	});
+
+	it("rejects skill installs before spawning when the global skill directory is not writable", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		mkdirSync(join(homeDir, ".agents"), { recursive: true });
+		writeFileSync(join(homeDir, ".agents", "skills"), "");
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		}));
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).rejects.toThrow(
+			"Cannot install skill globally because ~/.agents/skills is not writable",
+		);
+		expect(spawnCommand).not.toHaveBeenCalled();
+	});
+
+	it("rejects skill installs that do not create a global skill", async () => {
+		const homeDir = mkdtempSync(join(tmpdir(), "cline-marketplace-home-"));
+		process.env.HOME = homeDir;
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "Installation complete",
+			stderr: "",
+		}));
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "cline-sdk",
+						type: "skill",
+						name: "Cline SDK",
+						install: { args: ["cline/sdk-skill"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).rejects.toThrow("was not found in Cline's global skills directories");
+	});
+
+	it("runs official plugin installs through the current Cline CLI", async () => {
+		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: JSON.stringify({ installPath: "/tmp/plugin" }),
+			stderr: "",
+		}));
+
+		await installMarketplaceEntry(
+			{
+				entry: {
+					id: "marketplace-test-plugin",
+					type: "plugin",
+					name: "Marketplace Test Plugin",
+					install: { args: ["marketplace-test-plugin"] },
+				},
+			},
+			{ spawnCommand },
+		);
+
+		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
+			"plugin",
+			"install",
+			"marketplace-test-plugin",
+			"--json",
+		]);
+	});
+
+	it("runs MCP installs through the current Cline CLI without prompts", async () => {
+		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: JSON.stringify({
+				name: "context7",
+				status: "installed",
+				transport: {
+					type: "streamableHttp",
+					url: "https://mcp.context7.com/mcp",
+					headers: {
+						Authorization: "Bearer token",
+					},
+				},
+			}),
+			stderr: "",
+		}));
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "context7",
+						type: "mcp",
+						name: "Context7",
+						install: {
+							args: [
+								"context7",
+								"--transport",
+								"http",
+								"https://mcp.context7.com/mcp",
+								"--header",
+								"Authorization: Bearer token",
+							],
+						},
+					},
+				},
+				{ spawnCommand },
+			),
+		).resolves.toMatchObject({
+			status: "installed",
+			message: "Installed Context7.",
+			details: {
+				name: "context7",
+				status: "installed",
+			},
+		});
+
+		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
+			"mcp",
+			"install",
+			"--yes",
+			"--json",
+			"context7",
+			"--transport",
+			"http",
+			"https://mcp.context7.com/mcp",
+			"--header",
+			"Authorization: Bearer token",
+		]);
+	});
+
+	it("uninstalls official marketplace plugins through the shared core service", async () => {
+		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-plugin-"));
+		process.env.CLINE_DIR = clineDir;
+		const installPath = createInstalledOfficialPlugin(clineDir, "goal");
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		}));
+
+		await expect(
+			uninstallMarketplaceEntry(
+				{
+					entry: {
+						id: "goal",
+						type: "plugin",
+						name: "Goal",
+						install: { args: ["goal"] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).resolves.toMatchObject({
+			status: "uninstalled",
+			message: "Uninstalled Goal.",
+		});
+
+		expect(spawnCommand).not.toHaveBeenCalled();
+		expect(existsSync(installPath)).toBe(false);
+	});
+
+	it("resolves desktop installs from the server catalog instead of browser-sent args", async () => {
+		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: JSON.stringify({ installPath: "/tmp/plugin" }),
+			stderr: "",
+		}));
+
+		await installMarketplaceEntryForDesktopCommand(
+			{
+				entry: {
+					id: "marketplace-test-plugin",
+					type: "plugin",
+					name: "Tampered",
+					install: { args: ["malicious-source"] },
+				},
+			},
+			{
+				spawnCommand,
+				loadCatalog: async () => ({
+					entries: [
+						{
+							id: "marketplace-test-plugin",
+							type: "plugin",
+							name: "Marketplace Test Plugin",
+							install: { args: ["marketplace-test-plugin"] },
+						},
+					],
+				}),
+			},
+		);
+
+		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
+			"plugin",
+			"install",
+			"marketplace-test-plugin",
+			"--json",
+		]);
+	});
+
+	it("resolves desktop uninstalls from the server catalog instead of browser-sent args", async () => {
+		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-plugin-"));
+		process.env.CLINE_DIR = clineDir;
+		const installPath = createInstalledOfficialPlugin(clineDir, "goal");
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		}));
+
+		await uninstallMarketplaceEntryForDesktopCommand(
+			{
+				entry: {
+					id: "goal",
+					type: "plugin",
+					name: "Tampered",
+					install: { args: ["malicious-source"] },
+				},
+			},
+			{
+				spawnCommand,
+				loadCatalog: async () => ({
+					entries: [
+						{
+							id: "goal",
+							type: "plugin",
+							name: "Goal",
+							install: { args: ["goal"] },
+						},
+					],
+				}),
+			},
+		);
+
+		expect(spawnCommand).not.toHaveBeenCalled();
+		expect(existsSync(installPath)).toBe(false);
+	});
+
+	it("uninstalls MCP marketplace entries from Cline MCP settings", async () => {
+		const settingsPath = join(
+			mkdtempSync(join(tmpdir(), "cline-marketplace-mcp-")),
+			"cline_mcp_settings.json",
+		);
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						context7: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.context7.com/mcp",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+		);
+
+		await expect(
+			uninstallMarketplaceEntry({
+				entry: {
+					id: "context7",
+					type: "mcp",
+					name: "Context7",
+					install: {
+						args: [
+							"context7",
+							"--transport",
+							"http",
+							"https://mcp.context7.com/mcp",
+						],
+					},
+				},
+			}),
+		).resolves.toMatchObject({
+			status: "uninstalled",
+			message: "Uninstalled Context7.",
+		});
+		expect(
+			listMarketplaceInstalledEntries({
+				entries: [
+					{
+						id: "context7",
+						type: "mcp",
+						name: "Context7",
+						install: {
+							args: [
+								"context7",
+								"--transport",
+								"http",
+								"https://mcp.context7.com/mcp",
+							],
+						},
+					},
+				],
+			}),
+		).toEqual({ installedKeys: [] });
+	});
+
+	it("uninstalls local MCP servers by name", async () => {
+		const settingsPath = join(
+			mkdtempSync(join(tmpdir(), "cline-local-mcp-")),
+			"cline_mcp_settings.json",
+		);
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						context7: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.context7.com/mcp",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+		);
+
+		await expect(
+			uninstallLocalPrimitive({
+				type: "mcp",
+				id: "context7",
+				name: "context7",
+			}),
+		).resolves.toMatchObject({
+			status: "uninstalled",
+			message: "Uninstalled context7.",
+		});
+		expect(readFileSync(settingsPath, "utf8")).not.toContain("context7");
+	});
+
+	it("uninstalls local skills by removing their configured skill directory", async () => {
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "cline-local-skill-"));
+		const skillDir = join(workspaceRoot, ".cline", "skills", "review");
+		mkdirSync(skillDir, { recursive: true });
+		const skillPath = join(skillDir, "SKILL.md");
+		writeFileSync(skillPath, "---\nname: review\n---\nReview changes.");
+
+		await expect(
+			uninstallLocalPrimitive(
+				{
+					type: "skill",
+					id: "review",
+					name: "Review",
+					path: skillPath,
+				},
+				{ workspaceRoot },
+			),
+		).resolves.toMatchObject({
+			status: "uninstalled",
+			message: "Uninstalled Review.",
+		});
+		expect(existsSync(skillDir)).toBe(false);
+	});
+
+	it("reports official plugin marketplace entries installed from Cline home", () => {
+		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-test-"));
+		process.env.CLINE_DIR = clineDir;
+		const sourceKey =
+			"official:https://github.com/cline/plugins.git#plugins/goal";
+		const hash = createHash("sha256")
+			.update(sourceKey)
+			.digest("hex")
+			.slice(0, 12);
+		mkdirSync(
+			join(clineDir, "plugins", "_installed", "official", `goal-${hash}`),
+			{
+				recursive: true,
+			},
+		);
+
+		expect(
+			listMarketplaceInstalledEntries({
+				entries: [
+					{
+						id: "goal",
+						type: "plugin",
+						name: "Goal",
+						install: { args: ["goal"] },
+					},
+				],
+			}),
+		).toEqual({ installedKeys: ["plugin:goal"] });
+	});
+
+	it("does not report plugin inventory substring matches as installed", () => {
+		process.env.CLINE_DIR = mkdtempSync(
+			join(tmpdir(), "cline-marketplace-test-"),
+		);
+
+		expect(
+			listMarketplaceInstalledEntries(
+				{
+					entries: [
+						{
+							id: "goal",
+							type: "plugin",
+							name: "Goal",
+							install: { args: ["goal"] },
+						},
+					],
+				},
+				{
+					plugins: [
+						{
+							name: "goal-helper",
+							path: "/workspace/.cline/plugins/goal-helper/index.ts",
+						},
+					],
+				},
+			),
+		).toEqual({ installedKeys: [] });
+	});
+
+	it("skips invalid marketplace entries during installed-status checks", () => {
+		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-test-"));
+		process.env.CLINE_DIR = clineDir;
+		const sourceKey =
+			"official:https://github.com/cline/plugins.git#plugins/goal";
+		const hash = createHash("sha256")
+			.update(sourceKey)
+			.digest("hex")
+			.slice(0, 12);
+		mkdirSync(
+			join(clineDir, "plugins", "_installed", "official", `goal-${hash}`),
+			{
+				recursive: true,
+			},
+		);
+
+		expect(
+			listMarketplaceInstalledEntries({
+				entries: [
+					{
+						id: "broken-mcp",
+						type: "mcp",
+						name: "Broken MCP",
+						install: {
+							args: [
+								"broken-mcp",
+								"--transport",
+								"ws",
+								"https://example.com/mcp",
+							],
+						},
+					},
+					{
+						id: "goal",
+						type: "plugin",
+						name: "Goal",
+						install: { args: ["goal"] },
+					},
+				],
+			}),
+		).toEqual({ installedKeys: ["plugin:goal"] });
+	});
+
+	it("rejects invalid marketplace entries before spawning commands", async () => {
+		const spawnCommand = vi.fn(async () => ({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		}));
+
+		await expect(
+			installMarketplaceEntry(
+				{
+					entry: {
+						id: "bad",
+						type: "skill",
+						install: { args: [] },
+					},
+				},
+				{ spawnCommand },
+			),
+		).rejects.toThrow("marketplace install args are required");
+		expect(spawnCommand).not.toHaveBeenCalled();
+	});
+
+	it("fetches the marketplace catalog through the server helper", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response(JSON.stringify({ version: 1, entries: [] }), {
+				headers: { "content-type": "application/json" },
+			});
+		});
+
+		await expect(fetchMarketplaceCatalog(fetchImpl)).resolves.toEqual({
+			version: 1,
+			entries: [],
+		});
+		expect(fetchImpl).toHaveBeenCalledWith(
+			"https://cline.github.io/marketplace/catalog.json",
+			{ headers: { Accept: "application/json" } },
+		);
+	});
+
+	it("surfaces marketplace catalog upstream failures", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response("nope", {
+				status: 503,
+				statusText: "Service Unavailable",
+			});
+		});
+
+		await expect(fetchMarketplaceCatalog(fetchImpl)).rejects.toThrow(
+			"Failed to fetch marketplace catalog: 503 Service Unavailable",
+		);
+	});
+});
diff --git a/apps/cline-hub/src/server/marketplace.ts b/apps/cline-hub/src/server/marketplace.ts
new file mode 100644
index 0000000..1f74074
--- /dev/null
+++ b/apps/cline-hub/src/server/marketplace.ts
@@ -0,0 +1,998 @@
+import { type SpawnOptions, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+	existsSync,
+	mkdirSync,
+	rmSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { homedir as osHomedir, platform } from "node:os";
+import {
+	basename,
+	dirname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+} from "node:path";
+import {
+	type MarketplaceActionResult,
+	type MarketplaceEntryInput,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	uninstallMarketplaceEntry as uninstallCoreMarketplaceEntry,
+	uninstallPlugin as uninstallLocalPlugin,
+} from "@cline/core";
+import { resolveClineDir } from "@cline/shared/storage";
+import { deleteMcpServer, readMcpServersResponse } from "./mcp";
+import type { JsonRecord } from "./types";
+
+type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
+type LocalPrimitiveType = MarketplacePrimitiveType | "workflow";
+
+type MarketplaceEnvVar = {
+	name: string;
+	required?: boolean;
+	description?: string;
+	url?: string;
+};
+
+type MarketplaceInstallInput = {
+	id: string;
+	type: MarketplacePrimitiveType;
+	name?: string;
+	install: {
+		args?: string[];
+		env?: MarketplaceEnvVar[];
+		command?: string;
+		notes?: string;
+	};
+};
+
+type MarketplaceInstallResult = {
+	id: string;
+	type: LocalPrimitiveType;
+	status: "installed" | "uninstalled";
+	message: string;
+	details?: JsonRecord;
+	output?: string;
+};
+
+type MarketplaceInstallStatusResult = {
+	installedKeys: string[];
+};
+
+type SpawnResult = {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+};
+
+type SpawnCommand = (
+	command: string,
+	args: string[],
+	options?: SpawnOptions,
+) => Promise<SpawnResult>;
+type CatalogFetch = (
+	input: string | URL | Request,
+	init?: RequestInit,
+) => Promise<Response>;
+type CatalogLoader = () => Promise<unknown>;
+
+const MAX_OUTPUT_CHARS = 12_000;
+const INSTALL_COMMAND_TIMEOUT_MS = 120_000;
+const OFFICIAL_PLUGINS_REPO = "https://github.com/cline/plugins.git";
+const MARKETPLACE_CATALOG_URL =
+	process.env.CLINE_MARKETPLACE_CATALOG_URL?.trim() ||
+	"https://cline.github.io/marketplace/catalog.json";
+const SECRET_PATTERN =
+	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i;
+const SECRET_KEY_VALUE_PATTERN =
+	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi;
+const SECRET_BEARER_VALUE_PATTERN =
+	/((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi;
+const SECRET_AUTHORIZATION_VALUE_PATTERN =
+	/((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi;
+
+export async function fetchMarketplaceCatalog(
+	fetchImpl: CatalogFetch = fetch,
+): Promise<unknown> {
+	const response = await fetchImpl(MARKETPLACE_CATALOG_URL, {
+		headers: { Accept: "application/json" },
+	});
+	if (!response.ok) {
+		throw new Error(
+			`Failed to fetch marketplace catalog: ${response.status} ${response.statusText}`.trim(),
+		);
+	}
+	return response.json();
+}
+
+function isPrimitiveType(value: unknown): value is MarketplacePrimitiveType {
+	return value === "mcp" || value === "skill" || value === "plugin";
+}
+
+function toStringArray(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+function readInstallInput(
+	args?: Record<string, unknown>,
+): MarketplaceInstallInput {
+	const entry = readInstallRecord(args);
+	const install =
+		entry.install && typeof entry.install === "object"
+			? (entry.install as Record<string, unknown>)
+			: {};
+	const installArgs = toStringArray(install.args);
+	if (installArgs.length === 0) {
+		throw new Error("marketplace install args are required");
+	}
+	const env = Array.isArray(install.env)
+		? install.env
+				.map((item): MarketplaceEnvVar | null => {
+					if (!item || typeof item !== "object") return null;
+					const candidate = item as Record<string, unknown>;
+					if (typeof candidate.name !== "string") return null;
+					const parsed: MarketplaceEnvVar = {
+						name: candidate.name,
+					};
+					if (typeof candidate.required === "boolean") {
+						parsed.required = candidate.required;
+					}
+					if (typeof candidate.description === "string") {
+						parsed.description = candidate.description;
+					}
+					if (typeof candidate.url === "string") {
+						parsed.url = candidate.url;
+					}
+					return parsed;
+				})
+				.filter((item): item is MarketplaceEnvVar => item !== null)
+		: undefined;
+	return {
+		id: entry.id.trim(),
+		type: entry.type,
+		name: typeof entry.name === "string" ? entry.name : undefined,
+		install: {
+			args: installArgs,
+			command:
+				typeof install.command === "string" ? install.command : undefined,
+			env,
+			notes: typeof install.notes === "string" ? install.notes : undefined,
+		},
+	};
+}
+
+function readInstallRecord(
+	args?: Record<string, unknown>,
+): Record<string, unknown> & { id: string; type: MarketplacePrimitiveType } {
+	const entry =
+		args?.entry && typeof args.entry === "object"
+			? (args.entry as Record<string, unknown>)
+			: (args ?? {});
+	if (typeof entry.id !== "string" || entry.id.trim().length === 0) {
+		throw new Error("marketplace entry id is required");
+	}
+	if (!isPrimitiveType(entry.type)) {
+		throw new Error("marketplace entry type must be mcp, skill, or plugin");
+	}
+	return entry as Record<string, unknown> & {
+		id: string;
+		type: MarketplacePrimitiveType;
+	};
+}
+
+function readInstallRequest(args?: Record<string, unknown>) {
+	const entry = readInstallRecord(args);
+	return {
+		id: entry.id.trim(),
+		type: entry.type,
+	};
+}
+
+function readLocalUninstallInput(args?: Record<string, unknown>): {
+	id: string;
+	type: LocalPrimitiveType;
+	name?: string;
+	path?: string;
+} {
+	const type = typeof args?.type === "string" ? args.type.trim() : "";
+	if (
+		type !== "mcp" &&
+		type !== "skill" &&
+		type !== "workflow" &&
+		type !== "plugin"
+	) {
+		throw new Error(
+			"local uninstall type must be mcp, skill, workflow, or plugin",
+		);
+	}
+	const id =
+		typeof args?.id === "string" && args.id.trim().length > 0
+			? args.id.trim()
+			: typeof args?.name === "string" && args.name.trim().length > 0
+				? args.name.trim()
+				: typeof args?.path === "string" && args.path.trim().length > 0
+					? args.path.trim()
+					: "";
+	if (!id) {
+		throw new Error("local uninstall id, name, or path is required");
+	}
+	return {
+		id,
+		type,
+		name: typeof args?.name === "string" ? args.name.trim() : undefined,
+		path: typeof args?.path === "string" ? args.path.trim() : undefined,
+	};
+}
+
+function readInstallInputList(
+	args?: Record<string, unknown>,
+): MarketplaceInstallInput[] {
+	const rawEntries = Array.isArray(args?.entries) ? args.entries : [];
+	return rawEntries
+		.map((entry) => {
+			try {
+				return readInstallInput({ entry });
+			} catch {
+				return null;
+			}
+		})
+		.filter((entry): entry is MarketplaceInstallInput => entry !== null);
+}
+
+function readCatalogEntries(catalog: unknown): MarketplaceInstallInput[] {
+	const catalogEntries =
+		catalog && typeof catalog === "object"
+			? (catalog as Record<string, unknown>).entries
+			: undefined;
+	if (!Array.isArray(catalogEntries)) {
+		throw new Error("marketplace catalog entries are required");
+	}
+	return catalogEntries
+		.map((entry) => {
+			try {
+				return readInstallInput({ entry });
+			} catch {
+				return null;
+			}
+		})
+		.filter((entry): entry is MarketplaceInstallInput => entry !== null);
+}
+
+function marketplaceEntryKey(
+	entry: Pick<MarketplaceInstallInput, "id" | "type">,
+) {
+	return `${entry.type}:${entry.id}`;
+}
+
+function redactOutput(value: string): string {
+	const lines = value.split(/\r?\n/).map((line) => {
+		if (!SECRET_PATTERN.test(line)) return line;
+		return line
+			.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
+			.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
+			.replace(/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi, "$1 [redacted]")
+			.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
+			.replace(
+				/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
+				"$1[redacted]",
+			);
+	});
+	return lines.join("\n").slice(-MAX_OUTPUT_CHARS);
+}
+
+const defaultSpawnCommand: SpawnCommand = async (command, args, options = {}) =>
+	new Promise<SpawnResult>((resolve, reject) => {
+		let settled = false;
+		let timedOut = false;
+		const child = spawn(command, args, {
+			...options,
+			env: options.env ?? process.env,
+			shell: options.shell ?? platform() === "win32",
+			stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
+			windowsHide: true,
+		});
+		let stdout = "";
+		let stderr = "";
+		const forceKillTimeout = setTimeout(() => {
+			if (!settled) {
+				child.kill("SIGKILL");
+			}
+		}, INSTALL_COMMAND_TIMEOUT_MS + 5_000);
+		const timeout = setTimeout(() => {
+			timedOut = true;
+			stderr += `\nTimed out after ${INSTALL_COMMAND_TIMEOUT_MS / 1000}s.`;
+			child.kill("SIGTERM");
+		}, INSTALL_COMMAND_TIMEOUT_MS);
+		forceKillTimeout.unref?.();
+		timeout.unref?.();
+		child.stdout?.on("data", (chunk) => {
+			stdout += String(chunk);
+			if (stdout.length > MAX_OUTPUT_CHARS * 2) {
+				stdout = stdout.slice(-MAX_OUTPUT_CHARS);
+			}
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += String(chunk);
+			if (stderr.length > MAX_OUTPUT_CHARS * 2) {
+				stderr = stderr.slice(-MAX_OUTPUT_CHARS);
+			}
+		});
+		child.once("error", (error) => {
+			clearTimeout(timeout);
+			clearTimeout(forceKillTimeout);
+			reject(error);
+		});
+		child.once("close", (code, signal) => {
+			settled = true;
+			clearTimeout(timeout);
+			clearTimeout(forceKillTimeout);
+			const result = {
+				exitCode: timedOut ? 124 : (code ?? (signal === "SIGINT" ? 130 : 1)),
+				stdout,
+				stderr,
+			};
+			resolve(result);
+		});
+	});
+
+function normalizeTransport(value: string | undefined): string {
+	const normalized = (value ?? "stdio").trim();
+	if (normalized === "http" || normalized === "streamable-http") {
+		return "streamableHttp";
+	}
+	if (
+		normalized === "stdio" ||
+		normalized === "sse" ||
+		normalized === "streamableHttp"
+	) {
+		return normalized;
+	}
+	throw new Error(
+		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
+	);
+}
+
+function assertUrl(value: string): void {
+	let parsed: URL;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new Error(`Invalid MCP server URL: ${value}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error(`Invalid MCP server URL: ${value}`);
+	}
+}
+
+export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
+	const [rawName, ...rest] = args;
+	const name = rawName?.trim();
+	if (!name) {
+		throw new Error("MCP marketplace install requires a server name");
+	}
+	let transportType = "stdio";
+	const headers: Record<string, string> = {};
+	const targetArgs: string[] = [];
+	let parsingMarketplaceOptions = true;
+	for (let index = 0; index < rest.length; index++) {
+		const arg = rest[index];
+		if (parsingMarketplaceOptions && arg === "--") {
+			targetArgs.push(...rest.slice(index + 1));
+			break;
+		}
+		if (parsingMarketplaceOptions && (arg === "--transport" || arg === "-t")) {
+			const next = rest[index + 1]?.trim();
+			if (!next) throw new Error("--transport requires a value");
+			transportType = normalizeTransport(next);
+			index++;
+			continue;
+		}
+		const shouldParseHeader =
+			parsingMarketplaceOptions ||
+			normalizeTransport(transportType) !== "stdio";
+		if (
+			shouldParseHeader &&
+			(arg === "--header" || arg?.startsWith("--header="))
+		) {
+			const rawHeader =
+				arg === "--header" ? rest[++index] : arg.slice("--header=".length);
+			if (!rawHeader) throw new Error("--header requires a value");
+			const separatorIndex = rawHeader.indexOf(":");
+			if (separatorIndex <= 0) {
+				throw new Error(
+					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
+				);
+			}
+			const headerName = rawHeader.slice(0, separatorIndex).trim();
+			const headerValue = rawHeader.slice(separatorIndex + 1).trim();
+			if (!headerName || !headerValue) {
+				throw new Error(
+					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
+				);
+			}
+			headers[headerName] = headerValue;
+			continue;
+		}
+		parsingMarketplaceOptions = false;
+		targetArgs.push(arg);
+	}
+	transportType = normalizeTransport(transportType);
+	if (transportType === "stdio") {
+		if (Object.keys(headers).length > 0) {
+			throw new Error("Stdio MCP installs do not support request headers.");
+		}
+		const [command, ...commandArgs] = targetArgs;
+		if (!command?.trim()) {
+			throw new Error("Stdio MCP install requires a command");
+		}
+		return {
+			name,
+			transportType,
+			command,
+			args: commandArgs.length > 0 ? commandArgs : undefined,
+			disabled: false,
+		};
+	}
+	if (targetArgs.length !== 1) {
+		throw new Error("Remote MCP install requires exactly one URL");
+	}
+	const url = targetArgs[0]?.trim() ?? "";
+	assertUrl(url);
+	return {
+		name,
+		transportType,
+		url,
+		headers: Object.keys(headers).length > 0 ? headers : undefined,
+		disabled: false,
+	};
+}
+
+function resolveClineInvocation(): { command: string; argsPrefix: string[] } {
+	const wrapperPath = process.env.CLINE_WRAPPER_PATH?.trim();
+	if (wrapperPath) {
+		return { command: wrapperPath, argsPrefix: [] };
+	}
+	const entry = process.argv[1]?.trim();
+	if (entry && /(?:^|[/\\])apps[/\\]cli[/\\]src[/\\]index\.ts$/.test(entry)) {
+		return { command: process.execPath, argsPrefix: [entry] };
+	}
+	return { command: "cline", argsPrefix: [] };
+}
+
+function isInsidePath(childPath: string, parentPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+function resolveUserInstructionRemovalTarget(input: {
+	type: "skill" | "workflow";
+	path: string;
+	workspaceRoot?: string;
+}): string {
+	const filePath = resolve(input.path);
+	const searchPaths =
+		input.type === "skill"
+			? resolveSkillsConfigSearchPaths(input.workspaceRoot)
+			: resolveWorkflowsConfigSearchPaths(input.workspaceRoot);
+	const containingRoot = searchPaths.find((root) =>
+		isInsidePath(filePath, root),
+	);
+	if (!containingRoot) {
+		throw new Error(
+			`${input.type} uninstall requires a file inside a configured ${input.type} directory.`,
+		);
+	}
+	const stats = statSync(filePath, { throwIfNoEntry: false });
+	if (!stats?.isFile()) {
+		throw new Error(`${input.type} file does not exist: ${filePath}`);
+	}
+	if (input.type === "workflow") {
+		return filePath;
+	}
+	const skillDir = dirname(filePath);
+	return resolve(skillDir) === resolve(containingRoot) ? filePath : skillDir;
+}
+
+export async function uninstallLocalPrimitive(
+	args?: Record<string, unknown>,
+	options: { workspaceRoot?: string } = {},
+): Promise<MarketplaceInstallResult> {
+	const input = readLocalUninstallInput(args);
+	if (input.type === "mcp") {
+		const name = input.name ?? input.id;
+		const response = deleteMcpServer(name);
+		return {
+			id: input.id,
+			type: input.type,
+			status: "uninstalled",
+			message: `Uninstalled ${name}.`,
+			details: { mcp: response },
+		};
+	}
+	if (input.type === "plugin") {
+		const result = await uninstallLocalPlugin({
+			name: input.path ? undefined : (input.name ?? input.id),
+			path: input.path,
+			workspaceRoot: options.workspaceRoot,
+		});
+		return {
+			id: input.id,
+			type: input.type,
+			status: "uninstalled",
+			message: `Uninstalled ${result.name}.`,
+			details: result as unknown as JsonRecord,
+		};
+	}
+	if (input.type === "skill" || input.type === "workflow") {
+		if (!input.path) {
+			throw new Error(`${input.type} uninstall requires a path.`);
+		}
+		const target = resolveUserInstructionRemovalTarget({
+			type: input.type,
+			path: input.path,
+			workspaceRoot: options.workspaceRoot,
+		});
+		const stats = statSync(target, { throwIfNoEntry: false });
+		if (!stats) {
+			throw new Error(`${input.type} target does not exist: ${target}`);
+		}
+		rmSync(target, { recursive: stats.isDirectory(), force: true });
+		return {
+			id: input.id,
+			type: input.type,
+			status: "uninstalled",
+			message: `Uninstalled ${input.name ?? basename(target)}.`,
+			details: { path: target },
+		};
+	}
+	throw new Error(`Unsupported local uninstall type: ${input.type}`);
+}
+
+function hashSource(source: string): string {
+	return createHash("sha256").update(source).digest("hex").slice(0, 12);
+}
+
+function sanitizeSegment(value: string): string {
+	const sanitized = value
+		.replace(/^@/, "")
+		.replace(/[^a-zA-Z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, 80);
+	return sanitized || "plugin";
+}
+
+function sanitizeSkillSegment(value: string): string {
+	const sanitized = value
+		.toLowerCase()
+		.replace(/[^a-z0-9._]+/g, "-")
+		.replace(/^[.-]+|[.-]+$/g, "")
+		.slice(0, 255);
+	return sanitized || "skill";
+}
+
+function isOfficialPluginSlug(source: string): boolean {
+	return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(source.trim());
+}
+
+function getOfficialPluginInstallPath(source: string): string | undefined {
+	const slug = source.trim();
+	if (!isOfficialPluginSlug(slug)) return undefined;
+	const sourceKey = `official:${OFFICIAL_PLUGINS_REPO}#plugins/${slug}`;
+	return join(
+		resolveClineDir(),
+		"plugins",
+		"_installed",
+		"official",
+		`${sanitizeSegment(slug)}-${hashSource(sourceKey)}`,
+	);
+}
+
+function isOfficialPluginInstalled(entry: MarketplaceInstallInput): boolean {
+	if (entry.type !== "plugin") return false;
+	const [source] = entry.install.args ?? [];
+	if (!source) return false;
+	const installPath = getOfficialPluginInstallPath(source);
+	return Boolean(installPath && existsSync(installPath));
+}
+
+function resolveHomeDir(): string {
+	return (
+		process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || osHomedir()
+	);
+}
+
+function normalizeMatchValue(value: string | undefined): string {
+	return (value ?? "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+function getSkillInstallCandidates(entry: MarketplaceInstallInput): string[] {
+	const candidates = new Set<string>();
+	const addCandidate = (value: string | undefined) => {
+		const normalized = sanitizeSkillSegment(value ?? "");
+		if (normalized && normalized !== "skill") {
+			candidates.add(normalized);
+		}
+	};
+	addCandidate(entry.id);
+	addCandidate(entry.name);
+	const installArgs = entry.install.args ?? [];
+	for (let index = 0; index < installArgs.length; index++) {
+		const arg = installArgs[index];
+		if ((arg === "--skill" || arg === "-s") && installArgs[index + 1]) {
+			addCandidate(installArgs[index + 1]);
+			index++;
+			continue;
+		}
+		const skillFilter = arg.split("@").at(1);
+		if (skillFilter) {
+			addCandidate(skillFilter);
+		}
+	}
+	return [...candidates];
+}
+
+function getGlobalSkillPaths(skillName: string): string[] {
+	return [
+		join(resolveClineDir(), "skills", skillName, "SKILL.md"),
+		join(resolveHomeDir(), ".agents", "skills", skillName, "SKILL.md"),
+	].filter((path, index, paths) => paths.indexOf(path) === index);
+}
+
+function ensureGlobalSkillsDirWritable(): void {
+	const skillsDir = join(resolveHomeDir(), ".agents", "skills");
+	try {
+		mkdirSync(skillsDir, { recursive: true });
+		const probePath = join(
+			skillsDir,
+			`.cline-marketplace-write-test-${process.pid}-${Date.now()}`,
+		);
+		writeFileSync(probePath, "", { flag: "wx" });
+		unlinkSync(probePath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(
+			`Cannot install skill globally because ~/.agents/skills is not writable: ${message}`,
+		);
+	}
+}
+
+function isGlobalSkillInstalled(entry: MarketplaceInstallInput): boolean {
+	return findInstalledGlobalSkillName(entry) !== undefined;
+}
+
+function findInstalledGlobalSkillName(
+	entry: MarketplaceInstallInput,
+): string | undefined {
+	if (entry.type !== "skill") return undefined;
+	const candidates = getSkillInstallCandidates(entry);
+	return candidates.find((candidate) =>
+		getGlobalSkillPaths(candidate).some((path) => existsSync(path)),
+	);
+}
+
+function hasMatchingInventoryItem(
+	items: unknown,
+	entry: MarketplaceInstallInput,
+): boolean {
+	if (!Array.isArray(items)) return false;
+	const candidates = new Set([
+		normalizeMatchValue(entry.id),
+		normalizeMatchValue(entry.name),
+		...(entry.install.args ?? []).map(normalizeMatchValue),
+	]);
+	candidates.delete("");
+	return items.some((item) => {
+		if (!item || typeof item !== "object") return false;
+		const record = item as JsonRecord;
+		const values = [
+			typeof record.name === "string" ? record.name : undefined,
+			typeof record.id === "string" ? record.id : undefined,
+			typeof record.path === "string" ? record.path : undefined,
+		]
+			.map(normalizeMatchValue)
+			.filter(Boolean);
+		return values.some((value) => candidates.has(value));
+	});
+}
+
+function isMcpEntryInstalled(entry: MarketplaceInstallInput): boolean {
+	if (entry.type !== "mcp") return false;
+	const input = buildMarketplaceMcpInput(entry.install.args ?? []);
+	const response = readMcpServersResponse();
+	const servers = Array.isArray(response.servers) ? response.servers : [];
+	return servers.some((server) => {
+		if (!server || typeof server !== "object") return false;
+		const record = server as JsonRecord;
+		return record.name === input.name;
+	});
+}
+
+function isMarketplaceEntryInstalled(
+	entry: MarketplaceInstallInput,
+	inventory?: JsonRecord,
+): boolean {
+	try {
+		if (entry.type === "mcp") return isMcpEntryInstalled(entry);
+		if (entry.type === "plugin") {
+			return (
+				isOfficialPluginInstalled(entry) ||
+				hasMatchingInventoryItem(inventory?.plugins, entry)
+			);
+		}
+		if (entry.type === "skill") {
+			return isGlobalSkillInstalled(entry);
+		}
+		return false;
+	} catch {
+		return false;
+	}
+}
+
+function commandOutput(result: SpawnResult): string | undefined {
+	const output = redactOutput(
+		[result.stdout, result.stderr].filter(Boolean).join("\n"),
+	);
+	return output.trim().length > 0 ? output.trim() : undefined;
+}
+
+async function installSkill(
+	entry: MarketplaceInstallInput,
+	spawnCommand: SpawnCommand,
+): Promise<MarketplaceInstallResult> {
+	if (isGlobalSkillInstalled(entry)) {
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "installed",
+			message: `${entry.name ?? entry.id} is already installed.`,
+		};
+	}
+	ensureGlobalSkillsDirWritable();
+	const result = await spawnCommand("npx", [
+		"-y",
+		"skills@latest",
+		"add",
+		...(entry.install.args ?? []),
+		"-g",
+		"-a",
+		"cline",
+		"-y",
+	]);
+	if (result.exitCode !== 0) {
+		const output = commandOutput(result);
+		throw new Error(
+			`Skill install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+		);
+	}
+	const output = commandOutput(result);
+	if (/\bFailed to install\b/i.test(output ?? "")) {
+		throw new Error(`Skill install failed${output ? `:\n${output}` : ""}`);
+	}
+	if (!isGlobalSkillInstalled(entry)) {
+		throw new Error(
+			`Skill install completed, but ${entry.name ?? entry.id} was not found in Cline's global skills directories.`,
+		);
+	}
+	return {
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name ?? entry.id} globally for Cline.`,
+		output,
+	};
+}
+
+async function installPlugin(
+	entry: MarketplaceInstallInput,
+	spawnCommand: SpawnCommand,
+): Promise<MarketplaceInstallResult> {
+	const installArgs = entry.install.args ?? [];
+	if (installArgs.length !== 1) {
+		throw new Error(
+			"Plugin marketplace installs currently support exactly one source argument.",
+		);
+	}
+	if (isOfficialPluginInstalled(entry)) {
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "installed",
+			message: `${entry.name ?? entry.id} is already installed.`,
+		};
+	}
+	const { command, argsPrefix } = resolveClineInvocation();
+	const result = await spawnCommand(command, [
+		...argsPrefix,
+		"plugin",
+		"install",
+		installArgs[0] ?? "",
+		"--json",
+	]);
+	if (result.exitCode !== 0) {
+		const output = commandOutput(result);
+		throw new Error(
+			`Plugin install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+		);
+	}
+	let details: JsonRecord | undefined;
+	try {
+		details = result.stdout.trim()
+			? (JSON.parse(result.stdout.trim()) as JsonRecord)
+			: undefined;
+	} catch {
+		details = undefined;
+	}
+	return {
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name ?? entry.id}.`,
+		details,
+		output: commandOutput(result),
+	};
+}
+
+export async function installMarketplaceEntry(
+	args?: Record<string, unknown>,
+	options: { spawnCommand?: SpawnCommand } = {},
+): Promise<MarketplaceInstallResult> {
+	const entry = readInstallInput(args);
+	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
+	if (entry.type === "mcp") {
+		// Validate marketplace args before handing them to the CLI-backed installer.
+		buildMarketplaceMcpInput(entry.install.args ?? []);
+		const { command, argsPrefix } = resolveClineInvocation();
+		const result = await spawnCommand(command, [
+			...argsPrefix,
+			"mcp",
+			"install",
+			"--yes",
+			"--json",
+			...(entry.install.args ?? []),
+		]);
+		if (result.exitCode !== 0) {
+			const output = commandOutput(result);
+			throw new Error(
+				`MCP install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+			);
+		}
+		let details: JsonRecord | undefined;
+		try {
+			details = result.stdout.trim()
+				? (JSON.parse(result.stdout.trim()) as JsonRecord)
+				: undefined;
+		} catch {
+			details = undefined;
+		}
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "installed",
+			message: `Installed ${entry.name ?? entry.id}.`,
+			details,
+			output: commandOutput(result),
+		};
+	}
+	if (entry.type === "skill") {
+		return installSkill(entry, spawnCommand);
+	}
+	if (entry.type === "plugin") {
+		return installPlugin(entry, spawnCommand);
+	}
+	throw new Error(`Unsupported marketplace entry type: ${entry.type}`);
+}
+
+export async function uninstallMarketplaceEntry(
+	args?: Record<string, unknown>,
+	options: { spawnCommand?: SpawnCommand } = {},
+): Promise<MarketplaceInstallResult> {
+	const entry = readInstallInput(args);
+	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
+	let mcpDetails: JsonRecord | undefined;
+	const result = await uninstallCoreMarketplaceEntry(
+		entry satisfies MarketplaceEntryInput,
+		{
+			deleteMcpServer: (name) => {
+				mcpDetails = deleteMcpServer(name);
+			},
+			spawnCommand: (command, commandArgs) =>
+				spawnCommand(command, commandArgs),
+		},
+	);
+	return {
+		...(result satisfies MarketplaceActionResult),
+		details: mcpDetails ? { mcp: mcpDetails } : undefined,
+	};
+}
+
+export async function installMarketplaceEntryFromCatalog(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	const requested = readInstallRequest(args);
+	const catalog = await (options.loadCatalog ?? fetchMarketplaceCatalog)();
+	const entry = readCatalogEntries(catalog).find(
+		(candidate) =>
+			candidate.id === requested.id && candidate.type === requested.type,
+	);
+	if (!entry) {
+		throw new Error(
+			`Marketplace entry ${requested.type}:${requested.id} was not found in the catalog.`,
+		);
+	}
+	return installMarketplaceEntry(
+		{ entry },
+		{ spawnCommand: options.spawnCommand },
+	);
+}
+
+export async function uninstallMarketplaceEntryFromCatalog(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	const requested = readInstallRequest(args);
+	const catalog = await (options.loadCatalog ?? fetchMarketplaceCatalog)();
+	const entry = readCatalogEntries(catalog).find(
+		(candidate) =>
+			candidate.id === requested.id && candidate.type === requested.type,
+	);
+	if (!entry) {
+		throw new Error(
+			`Marketplace entry ${requested.type}:${requested.id} was not found in the catalog.`,
+		);
+	}
+	return uninstallMarketplaceEntry(
+		{ entry },
+		{ spawnCommand: options.spawnCommand },
+	);
+}
+
+export function listMarketplaceInstalledEntries(
+	args?: Record<string, unknown>,
+	inventory?: JsonRecord,
+): MarketplaceInstallStatusResult {
+	const entries = readInstallInputList(args);
+	const installedKeys = entries
+		.filter((entry) => isMarketplaceEntryInstalled(entry, inventory))
+		.map(marketplaceEntryKey);
+	return { installedKeys };
+}
+
+export async function installMarketplaceEntryForDesktopCommand(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	return installMarketplaceEntryFromCatalog(args, options);
+}
+
+export async function uninstallMarketplaceEntryForDesktopCommand(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	return uninstallMarketplaceEntryFromCatalog(args, options);
+}
diff --git a/apps/cline-hub/src/server/mcp.ts b/apps/cline-hub/src/server/mcp.ts
new file mode 100644
index 0000000..a2b84f5
--- /dev/null
+++ b/apps/cline-hub/src/server/mcp.ts
@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from "node:fs";
+import { updateMcpSettingsFileSync } from "@cline/core";
+import { resolveMcpSettingsPath } from "@cline/shared/storage";
+import type { JsonRecord } from "./types";
+
+export function readMcpServersResponse(): JsonRecord {
+	const settingsPath = resolveMcpSettingsPath();
+	if (!existsSync(settingsPath)) {
+		return { settingsPath, hasSettingsFile: false, servers: [] };
+	}
+	const parsed = JSON.parse(readFileSync(settingsPath, "utf8")) as JsonRecord;
+	const servers = parsed.mcpServers as JsonRecord | undefined;
+	const entries = Object.entries(servers ?? {}).map(([name, body]) => {
+		const record = body as JsonRecord;
+		const transport =
+			record.transport && typeof record.transport === "object"
+				? (record.transport as JsonRecord)
+				: undefined;
+		const transportType = String(
+			transport?.type ?? record.transportType ?? record.type ?? "stdio",
+		).trim();
+		return {
+			name,
+			transportType,
+			disabled: record.disabled === true,
+			command:
+				typeof transport?.command === "string"
+					? transport.command
+					: typeof record.command === "string"
+						? record.command
+						: undefined,
+			args: Array.isArray(transport?.args)
+				? transport.args
+				: Array.isArray(record.args)
+					? record.args
+					: undefined,
+			cwd:
+				typeof transport?.cwd === "string"
+					? transport.cwd
+					: typeof record.cwd === "string"
+						? record.cwd
+						: undefined,
+			env:
+				transport?.env && typeof transport.env === "object"
+					? transport.env
+					: record.env && typeof record.env === "object"
+						? record.env
+						: undefined,
+			url:
+				typeof transport?.url === "string"
+					? transport.url
+					: typeof record.url === "string"
+						? record.url
+						: undefined,
+			headers:
+				transport?.headers && typeof transport.headers === "object"
+					? transport.headers
+					: record.headers && typeof record.headers === "object"
+						? record.headers
+						: undefined,
+			metadata: record.metadata,
+		};
+	});
+	return { settingsPath, hasSettingsFile: true, servers: entries };
+}
+
+export function writeMcpServersMap(servers: JsonRecord): void {
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		settings.mcpServers = servers;
+	});
+}
+
+export function ensureMcpSettingsFile(): string {
+	const path = resolveMcpSettingsPath();
+	if (!existsSync(path)) {
+		writeMcpServersMap({});
+	}
+	return path;
+}
+
+export function setMcpServerDisabled(
+	name: string,
+	disabled: boolean,
+): JsonRecord {
+	// Hold the cross-process lock across read-modify-write so a concurrent writer
+	// (the extension, the CLI) cannot clobber this change.
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+			{}) as JsonRecord;
+		const current = servers[name];
+		if (!current || typeof current !== "object") {
+			throw new Error(`unknown MCP server: ${name}`);
+		}
+		servers[name] = { ...(current as JsonRecord), disabled };
+		settings.mcpServers = servers;
+	});
+	return readMcpServersResponse();
+}
+
+export function upsertMcpServer(input: JsonRecord): JsonRecord {
+	const name = String(input.name ?? "").trim();
+	if (!name) throw new Error("server name is required");
+	const previousName = String(
+		input.previousName ?? input.previous_name ?? "",
+	).trim();
+	const transportType = String(
+		input.transportType ?? input.transport_type ?? "",
+	).trim();
+	const next: JsonRecord =
+		transportType === "stdio"
+			? {
+					transport: {
+						type: "stdio",
+						command: input.command,
+						args: input.args,
+						cwd: input.cwd,
+						env: input.env,
+					},
+					disabled: input.disabled === true,
+				}
+			: {
+					transport: {
+						type: transportType === "sse" ? "sse" : "streamableHttp",
+						url: input.url,
+						headers: input.headers,
+					},
+					disabled: input.disabled === true,
+				};
+	// Hold the cross-process lock across read-modify-write so a concurrent writer
+	// cannot clobber this upsert.
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+			{}) as JsonRecord;
+		if (previousName && previousName !== name) {
+			delete servers[previousName];
+		}
+		servers[name] = next;
+		settings.mcpServers = servers;
+	});
+	return readMcpServersResponse();
+}
+
+export function deleteMcpServer(name: string): JsonRecord {
+	if (!name) throw new Error("server name is required");
+	// Hold the cross-process lock across read-modify-write so a concurrent writer
+	// cannot resurrect the deleted server from a stale snapshot.
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+			{}) as JsonRecord;
+		delete servers[name];
+		settings.mcpServers = servers;
+	});
+	return readMcpServersResponse();
+}
diff --git a/apps/cline-hub/src/server/providers.ts b/apps/cline-hub/src/server/providers.ts
new file mode 100644
index 0000000..de334fb
--- /dev/null
+++ b/apps/cline-hub/src/server/providers.ts
@@ -0,0 +1,158 @@
+import process from "node:process";
+import {
+	ensureCustomProvidersLoaded,
+	getLocalProviderModels,
+	Llms,
+	listLocalProviders,
+	loginAndSaveLocalProviderOAuthCredentials,
+	markLocalProviderEnabled,
+	normalizeOAuthProvider,
+	saveLocalProviderSettings,
+} from "@cline/core";
+import type {
+	WebviewInboundMessage,
+	WebviewProviderModel,
+} from "../webview-protocol";
+import { providerSettingsManager, workspaceRoot } from "./deps";
+import type { HubContext } from "./state";
+import type { BrowserPeer } from "./types";
+import { openExternalUrl } from "./utils";
+
+export function resolveBrowserDefaults(ctx: HubContext): {
+	provider?: string;
+	model?: string;
+	workspaceRoot: string;
+	cwd: string;
+} {
+	const lastUsed = providerSettingsManager.getLastUsedProviderSettings();
+	return {
+		provider:
+			lastUsed?.provider ??
+			ctx.lastSessionContext?.providerId ??
+			process.env.CLINE_PROVIDER?.trim(),
+		model:
+			lastUsed?.model ??
+			ctx.lastSessionContext?.modelId ??
+			process.env.CLINE_MODEL?.trim(),
+		workspaceRoot: ctx.lastSessionContext?.workspaceRoot ?? workspaceRoot,
+		cwd:
+			ctx.lastSessionContext?.cwd ??
+			ctx.lastSessionContext?.workspaceRoot ??
+			workspaceRoot,
+	};
+}
+
+export async function loadProviders(
+	ctx: HubContext,
+	peer: BrowserPeer,
+): Promise<void> {
+	await ensureCustomProvidersLoaded(providerSettingsManager);
+	const state = providerSettingsManager.read();
+	const defaults = resolveBrowserDefaults(ctx);
+	const ids = Llms.getProviderIds().sort((a, b) => a.localeCompare(b));
+	const providers = (
+		await Promise.all(
+			ids.map(async (id) => {
+				const info = await Llms.getProvider(id);
+				const enabled =
+					Boolean(state.providers[id]?.settings) || id === defaults.provider;
+				return {
+					id,
+					name: info?.name ?? id,
+					enabled,
+					defaultModelId: info?.defaultModelId,
+				};
+			}),
+		)
+	).filter((provider) => provider.enabled);
+	ctx.send(peer, { type: "providers", providers });
+	const selected =
+		(defaults.provider &&
+			providers.find((provider) => provider.id === defaults.provider)) ||
+		providers[0];
+	if (selected) {
+		await loadModels(ctx, peer, selected.id);
+	}
+}
+
+export async function loadModels(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	providerId: string,
+): Promise<void> {
+	const provider = providerId.trim();
+	if (!provider) return;
+	const payload = await getLocalProviderModels(
+		provider,
+		providerSettingsManager.getProviderConfig(provider),
+	);
+	const models: WebviewProviderModel[] = payload.models.map((model) => ({
+		id: model.id,
+		name: model.name,
+		supportsReasoning: model.supportsReasoning,
+		supportsThinking: model.supportsReasoning,
+	}));
+	ctx.send(peer, { type: "models", providerId: provider, models });
+}
+
+export async function sendProviderCatalog(
+	ctx: HubContext,
+	peer: BrowserPeer,
+): Promise<void> {
+	await ensureCustomProvidersLoaded(providerSettingsManager);
+	const payload = await listLocalProviders(providerSettingsManager, {
+		isClinePassEnabled: true,
+	});
+	ctx.send(peer, {
+		type: "provider_catalog",
+		providers: payload.providers,
+		settingsPath: payload.settingsPath,
+	});
+}
+
+export async function saveProviderSettings(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	frame: Extract<WebviewInboundMessage, { type: "saveProviderSettings" }>,
+): Promise<void> {
+	const result = saveLocalProviderSettings(providerSettingsManager, {
+		providerId: frame.providerId,
+		enabled: frame.enabled,
+		apiKey: frame.apiKey,
+		baseUrl: frame.baseUrl,
+	});
+	ctx.send(peer, {
+		type: "provider_settings_saved",
+		providerId: result.providerId,
+		enabled: result.enabled,
+	});
+	await sendProviderCatalog(ctx, peer);
+	await loadProviders(ctx, peer);
+}
+
+export async function runProviderOAuthLogin(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	providerId: string,
+): Promise<void> {
+	const normalized = normalizeOAuthProvider(providerId);
+	const saved = await loginAndSaveLocalProviderOAuthCredentials(
+		providerSettingsManager,
+		normalized,
+		openExternalUrl,
+	);
+	if (saved.provider !== normalized) {
+		markLocalProviderEnabled(providerSettingsManager, normalized, {
+			tokenSource: "oauth",
+		});
+	}
+	ctx.send(peer, {
+		type: "provider_oauth_login_done",
+		providerId: normalized,
+		accessTokenPresent:
+			(saved.auth?.accessToken?.trim() ?? saved.apiKey?.trim() ?? "").length >
+			0,
+	});
+	await sendProviderCatalog(ctx, peer);
+	await loadProviders(ctx, peer);
+}
diff --git a/apps/cline-hub/src/server/schedules.ts b/apps/cline-hub/src/server/schedules.ts
new file mode 100644
index 0000000..f15c51b
--- /dev/null
+++ b/apps/cline-hub/src/server/schedules.ts
@@ -0,0 +1,182 @@
+import {
+	createLocalHubScheduleRuntimeHandlers,
+	HubScheduleCommandService,
+	HubScheduleService,
+} from "@cline/core";
+import { asTrimmedString, toPositiveInt } from "./utils";
+
+let scheduleService: HubScheduleService | undefined;
+let scheduleCommands: HubScheduleCommandService | undefined;
+
+function getCommands(): HubScheduleCommandService {
+	if (!scheduleService || !scheduleCommands) {
+		scheduleService = new HubScheduleService({
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		scheduleCommands = new HubScheduleCommandService(scheduleService);
+	}
+	return scheduleCommands;
+}
+
+async function clientCommand(
+	hubCommand: string,
+	payload?: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+	const reply = await getCommands().handleCommand({
+		version: "v1",
+		clientId: "cline-hub-schedules",
+		command: hubCommand as never,
+		payload,
+	});
+	if (!reply.ok) {
+		throw new Error(
+			reply.error?.message ?? `hub command failed: ${hubCommand}`,
+		);
+	}
+	return (reply.payload ?? {}) as Record<string, unknown>;
+}
+
+export async function handleRoutineScheduleCommand(
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<unknown> {
+	if (command === "list_routine_schedules") {
+		const [schedules, activeExecutions, upcomingRuns] = await Promise.all([
+			clientCommand("schedule.list", {
+				limit: toPositiveInt(args?.limit) ?? 200,
+			}),
+			clientCommand("schedule.active"),
+			clientCommand("schedule.upcoming", { limit: 30 }),
+		]);
+		const scheduleRows = Array.isArray(schedules.schedules)
+			? schedules.schedules
+			: [];
+		const lastExecutions = await Promise.all(
+			scheduleRows.map(async (schedule) => {
+				const scheduleId = asTrimmedString(
+					(schedule as Record<string, unknown>).scheduleId,
+				);
+				if (!scheduleId) return undefined;
+				const reply = await clientCommand("schedule.list_executions", {
+					scheduleId,
+					limit: 1,
+				});
+				return Array.isArray(reply.executions)
+					? reply.executions[0]
+					: undefined;
+			}),
+		);
+		return {
+			schedules: scheduleRows,
+			activeExecutions: activeExecutions.executions ?? [],
+			upcomingRuns: upcomingRuns.runs ?? [],
+			lastExecutions: lastExecutions.filter(Boolean),
+		};
+	}
+
+	if (command === "create_routine_schedule") {
+		const name = asTrimmedString(args?.name);
+		const cronPattern = asTrimmedString(args?.cron_pattern);
+		const prompt = asTrimmedString(args?.prompt);
+		const routineWorkspaceRoot = asTrimmedString(args?.workspace_root);
+		if (!name || !cronPattern || !prompt || !routineWorkspaceRoot) {
+			throw new Error(
+				"createSchedule requires name, cron_pattern, prompt, and workspace_root",
+			);
+		}
+		const created = await clientCommand("schedule.create", {
+			name,
+			cronPattern,
+			prompt,
+			modelSelection: {
+				providerId: asTrimmedString(args?.provider) ?? "cline",
+				modelId: asTrimmedString(args?.model) ?? "openai/gpt-5.3-codex",
+			},
+			mode: args?.mode === "plan" ? "plan" : "act",
+			workspaceRoot: routineWorkspaceRoot,
+			cwd: asTrimmedString(args?.cwd),
+			systemPrompt: asTrimmedString(args?.system_prompt),
+			maxIterations: toPositiveInt(args?.max_iterations),
+			timeoutSeconds: toPositiveInt(args?.timeout_seconds),
+			maxParallel: toPositiveInt(args?.max_parallel) ?? 1,
+			enabled: args?.enabled !== false,
+			tags:
+				Array.isArray(args?.tags) && args.tags.length > 0
+					? (args.tags as string[])
+							.map((v) => v.trim())
+							.filter((v) => v.length > 0)
+					: undefined,
+		});
+		return { schedule: created.schedule ?? null };
+	}
+
+	const scheduleId = asTrimmedString(args?.schedule_id);
+	if (!scheduleId) throw new Error(`${command} requires schedule_id`);
+	if (command === "update_routine_schedule") {
+		const name = asTrimmedString(args?.name);
+		const cronPattern = asTrimmedString(args?.cron_pattern);
+		const prompt = asTrimmedString(args?.prompt);
+		const routineWorkspaceRoot = asTrimmedString(args?.workspace_root);
+		if (!name || !cronPattern || !prompt || !routineWorkspaceRoot) {
+			throw new Error(
+				"updateSchedule requires schedule_id, name, cron_pattern, prompt, and workspace_root",
+			);
+		}
+		const reply = await clientCommand("schedule.update", {
+			scheduleId,
+			name,
+			cronPattern,
+			prompt,
+			modelSelection: {
+				providerId: asTrimmedString(args?.provider) ?? "cline",
+				modelId: asTrimmedString(args?.model) ?? "openai/gpt-5.3-codex",
+			},
+			mode: args?.mode === "plan" ? "plan" : "act",
+			workspaceRoot: routineWorkspaceRoot,
+			cwd: asTrimmedString(args?.cwd) ?? null,
+			systemPrompt:
+				args?.system_prompt === null
+					? null
+					: asTrimmedString(args?.system_prompt),
+			maxIterations:
+				args?.max_iterations === null
+					? null
+					: toPositiveInt(args?.max_iterations),
+			timeoutSeconds:
+				args?.timeout_seconds === null
+					? null
+					: toPositiveInt(args?.timeout_seconds),
+			maxParallel: toPositiveInt(args?.max_parallel) ?? 1,
+			enabled: args?.enabled !== false,
+			tags: Array.isArray(args?.tags)
+				? (args.tags as string[])
+						.map((v) => v.trim())
+						.filter((v) => v.length > 0)
+				: [],
+		});
+		return { schedule: reply.schedule ?? null };
+	}
+	if (command === "pause_routine_schedule") {
+		const reply = await clientCommand("schedule.disable", { scheduleId });
+		return { schedule: reply.schedule ?? null };
+	}
+	if (command === "resume_routine_schedule") {
+		const reply = await clientCommand("schedule.enable", { scheduleId });
+		return { schedule: reply.schedule ?? null };
+	}
+	if (command === "trigger_routine_schedule") {
+		const existing = await clientCommand("schedule.get", { scheduleId });
+		if (!existing.schedule)
+			throw new Error(`schedule not found: ${scheduleId}`);
+		const reply = await clientCommand("schedule.trigger", {
+			scheduleId,
+			wait: false,
+		});
+		return { execution: reply.execution ?? null };
+	}
+	if (command === "delete_routine_schedule") {
+		const reply = await clientCommand("schedule.delete", { scheduleId });
+		return { deleted: reply.deleted === true };
+	}
+	throw new Error(`unsupported routine schedule command: ${command}`);
+}
diff --git a/apps/cline-hub/src/server/session-mapping.test.ts b/apps/cline-hub/src/server/session-mapping.test.ts
new file mode 100644
index 0000000..e8f21eb
--- /dev/null
+++ b/apps/cline-hub/src/server/session-mapping.test.ts
@@ -0,0 +1,231 @@
+import { describe, expect, it } from "vitest";
+import { mapHistoryToWebviewMessages } from "./session-mapping";
+
+describe("mapHistoryToWebviewMessages", () => {
+	it("hydrates assistant tool uses with following user tool results", () => {
+		const messages = mapHistoryToWebviewMessages([
+			{
+				id: "assistant-1",
+				role: "assistant",
+				content: [
+					{ type: "text", text: "I'll inspect the file." },
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "read_file",
+						input: { path: "src/index.ts" },
+					},
+				],
+			},
+			{
+				id: "user-1",
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						id: "result-block-1",
+						tool_use_id: "toolu_1",
+						name: "read_file",
+						content: "export const value = 1;",
+					},
+				],
+			},
+		]);
+
+		expect(messages).toHaveLength(1);
+		expect(messages[0]).toMatchObject({
+			id: "assistant-1",
+			role: "assistant",
+			text: "I'll inspect the file.",
+			toolEvents: [
+				{
+					toolCallId: "toolu_1",
+					name: "read_file",
+					state: "output-available",
+					input: { path: "src/index.ts" },
+					output: "export const value = 1;",
+				},
+			],
+		});
+		expect(messages[0].blocks).toEqual([
+			{
+				id: "assistant-1:text:0",
+				type: "text",
+				text: "I'll inspect the file.",
+			},
+			{
+				id: "assistant-1:tool:toolu_1",
+				type: "tool",
+				toolEvent: expect.objectContaining({
+					toolCallId: "toolu_1",
+					name: "read_file",
+					state: "output-available",
+					output: "export const value = 1;",
+				}),
+			},
+		]);
+	});
+
+	it("hydrates error tool results", () => {
+		const messages = mapHistoryToWebviewMessages([
+			{
+				id: "assistant-1",
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "read_file",
+						input: { path: "missing.ts" },
+					},
+				],
+			},
+			{
+				id: "user-1",
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_1",
+						name: "read_file",
+						content: "File not found",
+						is_error: true,
+					},
+				],
+			},
+		]);
+
+		expect(messages).toHaveLength(1);
+		expect(messages[0].toolEvents).toEqual([
+			expect.objectContaining({
+				toolCallId: "toolu_1",
+				name: "read_file",
+				state: "output-error",
+				output: "File not found",
+				error: "File not found",
+			}),
+		]);
+		expect(messages[0].blocks?.[0]).toMatchObject({
+			type: "tool",
+			toolEvent: {
+				toolCallId: "toolu_1",
+				state: "output-error",
+				error: "File not found",
+			},
+		});
+	});
+
+	it("hydrates orphan tool results as standalone meta tool blocks", () => {
+		const messages = mapHistoryToWebviewMessages([
+			{
+				id: "user-1",
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_orphan",
+						name: "read_file",
+						content: "orphan output",
+					},
+				],
+			},
+		]);
+
+		expect(messages).toHaveLength(1);
+		expect(messages[0]).toMatchObject({
+			id: "user-1",
+			role: "meta",
+			text: "",
+			toolEvents: [
+				{
+					toolCallId: "toolu_orphan",
+					name: "read_file",
+					state: "output-available",
+					input: undefined,
+					output: "orphan output",
+				},
+			],
+		});
+		expect(messages[0].blocks).toEqual([
+			{
+				id: "user-1:tool:toolu_orphan",
+				type: "tool",
+				toolEvent: expect.objectContaining({
+					toolCallId: "toolu_orphan",
+					input: undefined,
+					output: "orphan output",
+				}),
+			},
+		]);
+	});
+
+	it("hydrates plain string content as a text block", () => {
+		const messages = mapHistoryToWebviewMessages([
+			{
+				id: "assistant-1",
+				role: "assistant",
+				content: "Plain response",
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				id: "assistant-1",
+				role: "assistant",
+				text: "Plain response",
+				reasoning: undefined,
+				reasoningRedacted: undefined,
+				toolEvents: undefined,
+				blocks: [
+					{
+						id: "assistant-1:text:0",
+						type: "text",
+						text: "Plain response",
+					},
+				],
+			},
+		]);
+	});
+
+	it("hydrates same-message tool-call and tool-result blocks", () => {
+		const messages = mapHistoryToWebviewMessages([
+			{
+				id: "assistant-1",
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_1",
+						toolName: "search",
+						input: { query: "cline" },
+					},
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "search",
+						output: [{ query: "cline", result: "found", success: true }],
+					},
+				],
+			},
+		]);
+
+		expect(messages).toHaveLength(1);
+		expect(messages[0].toolEvents).toEqual([
+			expect.objectContaining({
+				toolCallId: "call_1",
+				name: "search",
+				state: "output-available",
+				input: { query: "cline" },
+				output: [{ query: "cline", result: "found", success: true }],
+			}),
+		]);
+		expect(messages[0].blocks).toHaveLength(1);
+		expect(messages[0].blocks?.[0]).toMatchObject({
+			type: "tool",
+			toolEvent: {
+				toolCallId: "call_1",
+				state: "output-available",
+			},
+		});
+	});
+});
diff --git a/apps/cline-hub/src/server/session-mapping.ts b/apps/cline-hub/src/server/session-mapping.ts
new file mode 100644
index 0000000..e06ced2
--- /dev/null
+++ b/apps/cline-hub/src/server/session-mapping.ts
@@ -0,0 +1,558 @@
+import { formatDisplayUserInput } from "@cline/shared";
+import type {
+	WebviewActionSessionSummary,
+	WebviewChatMessage,
+	WebviewClientSummary,
+	WebviewOutboundMessage,
+	WebviewSessionSummary,
+} from "../webview-protocol";
+import type { HubContext } from "./state";
+import type { SessionContext, TrackedClient, TrackedSession } from "./types";
+import {
+	asNumber,
+	asRecord,
+	asString,
+	asTimestamp,
+	basename,
+	formatClientLabel,
+	isActiveSession,
+	stringifyContent,
+} from "./utils";
+
+function metadataFor(record: Record<string, unknown>): Record<string, unknown> {
+	return (
+		(record.metadata && typeof record.metadata === "object"
+			? (record.metadata as Record<string, unknown>)
+			: undefined) ?? {}
+	);
+}
+
+function usageFor(record: Record<string, unknown>): Record<string, unknown> {
+	const metadata = metadataFor(record);
+	const pick = (value: unknown): Record<string, unknown> | undefined =>
+		value && typeof value === "object"
+			? (value as Record<string, unknown>)
+			: undefined;
+	return (
+		pick(record.aggregateUsage) ??
+		pick(record.usage) ??
+		pick(metadata.aggregateUsage) ??
+		pick(metadata.usage) ??
+		{}
+	);
+}
+
+function sessionTitle(record: Record<string, unknown>): string {
+	const metadata = metadataFor(record);
+	const title = asString(metadata.title);
+	if (title) return title;
+	const prompt = asString(record.prompt) ?? asString(metadata.prompt);
+	if (prompt) return prompt.length > 34 ? `${prompt.slice(0, 31)}...` : prompt;
+	return basename(asString(record.workspaceRoot) ?? asString(record.cwd));
+}
+
+export function formatClientName(client: TrackedClient): string {
+	return (
+		client.displayName?.trim() ||
+		client.clientType.trim() ||
+		client.clientId.trim() ||
+		"Unknown"
+	);
+}
+
+export function formatSessionCreator(
+	ctx: HubContext,
+	session: TrackedSession,
+): string {
+	const clientId = session.createdByClientId?.trim();
+	if (!clientId) return "Unknown client";
+	const client = ctx.clients.get(clientId);
+	return client ? formatClientName(client) : clientId;
+}
+
+function summarizeClient(client: TrackedClient): {
+	key: string;
+	label: string;
+	name: string;
+} {
+	const normalizedType = client.clientType.trim().toLowerCase();
+	if (
+		normalizedType === "code-sidecar" ||
+		normalizedType === "code-sidecar-approvals" ||
+		normalizedType === "code-sidecar-list"
+	) {
+		return { key: "code-app", label: "Code App", name: "Code App" };
+	}
+	return {
+		key: client.clientId,
+		label: formatClientLabel(client.clientType),
+		name: formatClientName(client),
+	};
+}
+
+type HistoryToolLocation = {
+	messageIndex: number;
+	blockIndex: number;
+};
+
+function historyContentParts(content: unknown): Record<string, unknown>[] {
+	if (Array.isArray(content)) {
+		return content
+			.map((part) => asRecord(part))
+			.filter((part): part is Record<string, unknown> => Boolean(part));
+	}
+	if (typeof content === "string" && content.trim()) {
+		return [{ type: "text", text: content }];
+	}
+	return [];
+}
+
+function blockType(block: Record<string, unknown>): string {
+	return asString(block.type)?.toLowerCase() ?? "";
+}
+
+function toolCallIdForCall(block: Record<string, unknown>): string | undefined {
+	return (
+		asString(block.id) ??
+		asString(block.toolCallId) ??
+		asString(block.tool_call_id)
+	);
+}
+
+function toolCallIdForResult(
+	block: Record<string, unknown>,
+): string | undefined {
+	return (
+		asString(block.tool_use_id) ??
+		asString(block.toolCallId) ??
+		asString(block.tool_call_id)
+	);
+}
+
+function toolNameFor(block: Record<string, unknown>): string {
+	return (
+		asString(block.name) ??
+		asString(block.toolName) ??
+		asString(block.tool_name) ??
+		"tool"
+	);
+}
+
+function toolInputFor(block: Record<string, unknown>): unknown {
+	return block.input ?? block.args ?? block.arguments;
+}
+
+function toolOutputFor(block: Record<string, unknown>): unknown {
+	return block.output ?? block.result ?? block.content;
+}
+
+function isErrorToolResult(block: Record<string, unknown>): boolean {
+	return (
+		block.is_error === true || block.isError === true || block.error === true
+	);
+}
+
+function pushTextBlock(
+	blocks: NonNullable<WebviewChatMessage["blocks"]>,
+	textParts: string[],
+	messageKey: string | number,
+	partIndex: number,
+	text: string,
+): void {
+	if (!text) return;
+	textParts.push(text);
+	blocks.push({
+		id: `${messageKey}:text:${partIndex}`,
+		type: "text",
+		text,
+	});
+}
+
+function pushReasoningBlock(
+	blocks: NonNullable<WebviewChatMessage["blocks"]>,
+	reasoningParts: string[],
+	messageKey: string | number,
+	partIndex: number,
+	text: string,
+	redacted?: boolean,
+): boolean {
+	if (!text) return false;
+	reasoningParts.push(text);
+	blocks.push({
+		id: `${messageKey}:reasoning:${partIndex}`,
+		type: "reasoning",
+		text,
+		redacted,
+	});
+	return redacted === true;
+}
+
+export function mapHistoryToWebviewMessages(
+	history: unknown[],
+): WebviewChatMessage[] {
+	const mapped: WebviewChatMessage[] = [];
+	const toolLocations = new Map<string, HistoryToolLocation>();
+
+	for (const [index, entry] of history.entries()) {
+		const record =
+			entry && typeof entry === "object"
+				? (entry as Record<string, unknown>)
+				: { content: entry };
+		const messageKey = asString(record.id) ?? `history-${index}`;
+		const rawRole = asString(record.role)?.toLowerCase();
+		let role: WebviewChatMessage["role"] =
+			rawRole === "user" || rawRole === "assistant" || rawRole === "error"
+				? rawRole
+				: "meta";
+		const blocks: NonNullable<WebviewChatMessage["blocks"]> = [];
+		const textParts: string[] = [];
+		const reasoningParts: string[] = [];
+		const toolEvents = new Map<
+			string,
+			NonNullable<WebviewChatMessage["toolEvents"]>[number]
+		>();
+		const currentToolBlockIndexes = new Map<string, number>();
+		let reasoningRedacted = false;
+
+		// Persisted user text arrives raw, including runtime-generated
+		// <user_input>/<mode_notice> wrappers -- format at this display
+		// boundary so the webview never renders them.
+		const displayText = (text: string): string =>
+			role === "user" ? formatDisplayUserInput(text) : text;
+
+		const contentParts = historyContentParts(record.content);
+		if (contentParts.length === 0) {
+			const text = stringifyContent(record.content ?? record.text ?? record);
+			pushTextBlock(blocks, textParts, messageKey, 0, displayText(text));
+		}
+
+		for (const [partIndex, part] of contentParts.entries()) {
+			const type = blockType(part);
+			if (type === "text") {
+				pushTextBlock(
+					blocks,
+					textParts,
+					messageKey,
+					partIndex,
+					displayText(asString(part.text) ?? asString(part.content) ?? ""),
+				);
+				continue;
+			}
+
+			if (type === "thinking" || type === "reasoning") {
+				reasoningRedacted =
+					pushReasoningBlock(
+						blocks,
+						reasoningParts,
+						messageKey,
+						partIndex,
+						asString(part.thinking) ??
+							asString(part.reasoning) ??
+							asString(part.text) ??
+							"",
+						part.redacted === true,
+					) || reasoningRedacted;
+				continue;
+			}
+
+			if (type === "redacted_thinking") {
+				reasoningRedacted =
+					pushReasoningBlock(
+						blocks,
+						reasoningParts,
+						messageKey,
+						partIndex,
+						"[redacted]",
+						true,
+					) || reasoningRedacted;
+				continue;
+			}
+
+			if (type === "tool_use" || type === "tool-call") {
+				const toolCallId =
+					toolCallIdForCall(part) ?? `${messageKey}:${partIndex}`;
+				const name = toolNameFor(part);
+				const toolEvent = {
+					id: `${messageKey}:${toolCallId}`,
+					toolCallId,
+					name,
+					text: `Running ${name}...`,
+					state: "input-available" as const,
+					input: toolInputFor(part),
+				};
+				toolEvents.set(toolCallId, toolEvent);
+				blocks.push({
+					id: `${messageKey}:tool:${toolCallId}`,
+					type: "tool",
+					toolEvent,
+				});
+				currentToolBlockIndexes.set(toolCallId, blocks.length - 1);
+				toolLocations.set(toolCallId, {
+					messageIndex: mapped.length,
+					blockIndex: blocks.length - 1,
+				});
+				continue;
+			}
+
+			if (type === "tool_result" || type === "tool-result") {
+				const toolCallId =
+					toolCallIdForResult(part) ?? `${messageKey}:${partIndex}`;
+				const name = toolNameFor(part);
+				const output = toolOutputFor(part);
+				const isError = isErrorToolResult(part);
+				const currentBlockIndex = currentToolBlockIndexes.get(toolCallId);
+				const existingLocation = toolLocations.get(toolCallId);
+				const existing =
+					currentBlockIndex !== undefined
+						? blocks[currentBlockIndex]
+						: existingLocation !== undefined
+							? mapped[existingLocation.messageIndex]?.blocks?.[
+									existingLocation.blockIndex
+								]
+							: undefined;
+				const existingToolEvent =
+					existing?.type === "tool" ? existing.toolEvent : undefined;
+				const toolEvent = {
+					id: existingToolEvent?.id ?? `${messageKey}:${toolCallId}`,
+					toolCallId,
+					name: existingToolEvent?.name ?? name,
+					text: isError
+						? `${existingToolEvent?.name ?? name} failed`
+						: `${existingToolEvent?.name ?? name} completed`,
+					state: isError
+						? ("output-error" as const)
+						: ("output-available" as const),
+					input: existingToolEvent?.input,
+					output,
+					error: isError ? stringifyContent(output) : undefined,
+				};
+
+				if (currentBlockIndex !== undefined && existing?.type === "tool") {
+					blocks[currentBlockIndex] = {
+						...existing,
+						toolEvent,
+					};
+					toolEvents.set(toolCallId, toolEvent);
+				} else if (
+					existingLocation !== undefined &&
+					existing?.type === "tool"
+				) {
+					const target = mapped[existingLocation.messageIndex];
+					const targetBlocks = target.blocks;
+					const targetBlock = targetBlocks?.[existingLocation.blockIndex];
+					if (targetBlocks && targetBlock?.type === "tool") {
+						targetBlocks[existingLocation.blockIndex] = {
+							...targetBlock,
+							toolEvent,
+						};
+					}
+					target.toolEvents = (target.toolEvents ?? []).map((event) =>
+						event.toolCallId === toolCallId ? toolEvent : event,
+					);
+				} else {
+					toolEvents.set(toolCallId, toolEvent);
+					blocks.push({
+						id: `${messageKey}:tool:${toolCallId}`,
+						type: "tool",
+						toolEvent,
+					});
+				}
+			}
+		}
+
+		const text = textParts.join("\n");
+		const toolEventList = [...toolEvents.values()];
+		if (!text && reasoningParts.length === 0 && toolEventList.length === 0) {
+			continue;
+		}
+		if (!text && role === "user" && toolEventList.length > 0) {
+			role = "meta";
+		}
+		mapped.push({
+			id: messageKey,
+			role,
+			text,
+			reasoning:
+				reasoningParts.length > 0 ? reasoningParts.join("\n") : undefined,
+			reasoningRedacted: reasoningRedacted || undefined,
+			toolEvents: toolEventList.length > 0 ? toolEventList : undefined,
+			blocks,
+		});
+	}
+
+	return mapped;
+}
+
+export function trackSession(record: unknown): TrackedSession | undefined {
+	const raw =
+		record && typeof record === "object"
+			? (record as Record<string, unknown>)
+			: {};
+	const sessionId = asString(raw.sessionId);
+	if (!sessionId) return undefined;
+	const metadata = metadataFor(raw);
+	const usage = usageFor(raw);
+	const participantCount = Array.isArray(raw.participants)
+		? raw.participants.length
+		: 0;
+	const createdAt =
+		asTimestamp(raw.createdAt) ??
+		asTimestamp(raw.startedAt) ??
+		asTimestamp(metadata.createdAt) ??
+		Date.now();
+	return {
+		sessionId,
+		status: asString(raw.status) ?? "running",
+		title: sessionTitle(raw),
+		workspaceRoot: asString(raw.workspaceRoot) ?? asString(raw.cwd) ?? "",
+		cwd: asString(raw.cwd),
+		provider: asString(raw.provider) ?? asString(metadata.provider),
+		model: asString(raw.model) ?? asString(metadata.model),
+		source: asString(raw.source) ?? asString(metadata.source),
+		createdAt,
+		updatedAt:
+			asTimestamp(raw.updatedAt) ??
+			asTimestamp(raw.endedAt) ??
+			asTimestamp(metadata.updatedAt) ??
+			createdAt,
+		createdByClientId: asString(raw.createdByClientId),
+		prompt: asString(raw.prompt) ?? asString(metadata.prompt),
+		inputTokens:
+			asNumber(usage.inputTokens) ??
+			asNumber(usage.input) ??
+			asNumber(usage.totalInputTokens),
+		outputTokens:
+			asNumber(usage.outputTokens) ??
+			asNumber(usage.output) ??
+			asNumber(usage.totalOutputTokens),
+		totalCost: asNumber(usage.totalCost) ?? asNumber(metadata.totalCost),
+		agentCount: Math.max(1, participantCount),
+		participantCount,
+	};
+}
+
+export function toActionSessionSummary(
+	session: TrackedSession,
+): WebviewActionSessionSummary {
+	return {
+		sessionId: session.sessionId,
+		title: session.title || basename(session.workspaceRoot || session.cwd),
+		status: session.status,
+		workspaceRoot: session.workspaceRoot,
+		workspaceName: basename(session.workspaceRoot || session.cwd),
+		cwd: session.cwd,
+		model: session.model,
+		provider: session.provider,
+		createdAt: session.createdAt,
+		updatedAt: session.updatedAt,
+		createdByClientId: session.createdByClientId,
+		prompt: session.prompt,
+		inputTokens: session.inputTokens,
+		outputTokens: session.outputTokens,
+		totalCost: session.totalCost,
+		agentCount: session.agentCount,
+	};
+}
+
+export function clientSummariesPayload(
+	ctx: HubContext,
+): WebviewClientSummary[] {
+	const sessionCounts = new Map<string, number>();
+	for (const session of ctx.sessions.values()) {
+		if (
+			!isActiveSession(session.title, session.status, session.participantCount)
+		)
+			continue;
+		const clientId = session.createdByClientId?.trim();
+		if (!clientId) continue;
+		sessionCounts.set(clientId, (sessionCounts.get(clientId) ?? 0) + 1);
+	}
+	const grouped = new Map<
+		string,
+		WebviewClientSummary & { firstConnectedAt: number }
+	>();
+	for (const client of [...ctx.clients.values()].sort(
+		(a, b) => a.connectedAt - b.connectedAt,
+	)) {
+		const summary = summarizeClient(client);
+		const existing = grouped.get(summary.key);
+		if (existing) {
+			existing.sessionCount += sessionCounts.get(client.clientId) ?? 0;
+			existing.firstConnectedAt = Math.min(
+				existing.firstConnectedAt,
+				client.connectedAt,
+			);
+			continue;
+		}
+		grouped.set(summary.key, {
+			label: summary.label,
+			name: summary.name,
+			sessionCount: sessionCounts.get(client.clientId) ?? 0,
+			firstConnectedAt: client.connectedAt,
+		});
+	}
+	return [...grouped.values()]
+		.sort((a, b) => a.firstConnectedAt - b.firstConnectedAt)
+		.map(({ label, name, sessionCount }) => ({ label, name, sessionCount }));
+}
+
+export function toWebviewSessionSummary(
+	session: TrackedSession,
+): WebviewSessionSummary {
+	return {
+		sessionId: session.sessionId,
+		title: session.title,
+		status: session.status,
+		source: session.source,
+		providerId: session.provider,
+		model: session.model,
+		workspaceRoot: session.workspaceRoot,
+		createdAt: session.createdAt,
+		updatedAt: session.updatedAt,
+		inputTokens: session.inputTokens,
+		outputTokens: session.outputTokens,
+		totalCost: session.totalCost,
+	};
+}
+
+export function webviewSessionsPayload(
+	ctx: HubContext,
+): WebviewOutboundMessage {
+	return {
+		type: "sessions",
+		sessions: [...ctx.sessions.values()]
+			.sort((a, b) => b.updatedAt - a.updatedAt)
+			.map(toWebviewSessionSummary),
+	};
+}
+
+export function parseSessionContext(
+	record: unknown,
+): SessionContext | undefined {
+	const raw =
+		record && typeof record === "object"
+			? (record as Record<string, unknown>)
+			: {};
+	const metadata =
+		raw.metadata && typeof raw.metadata === "object"
+			? (raw.metadata as Record<string, unknown>)
+			: {};
+	const workspaceRootRaw = asString(raw.workspaceRoot);
+	const providerId =
+		asString(raw.providerId) ??
+		asString(metadata.providerId) ??
+		asString(raw.provider) ??
+		asString(metadata.provider);
+	const modelId =
+		asString(raw.modelId) ??
+		asString(metadata.modelId) ??
+		asString(raw.model) ??
+		asString(metadata.model);
+	if (!workspaceRootRaw || !providerId || !modelId) return undefined;
+	return {
+		workspaceRoot: workspaceRootRaw,
+		cwd: asString(raw.cwd) ?? workspaceRootRaw,
+		providerId,
+		modelId,
+	};
+}
diff --git a/apps/cline-hub/src/server/sessions.ts b/apps/cline-hub/src/server/sessions.ts
new file mode 100644
index 0000000..b250854
--- /dev/null
+++ b/apps/cline-hub/src/server/sessions.ts
@@ -0,0 +1,483 @@
+import process from "node:process";
+import {
+	type ClineCoreStartInput,
+	type SessionRecord,
+	SessionSource,
+} from "@cline/core";
+import type { Message } from "@cline/llms";
+import type { WebviewConfig, WebviewReasonLevel } from "../webview-protocol";
+import { rejectPendingApprovalsForSession } from "./approvals";
+import { providerSettingsManager, workspaceRoot } from "./deps";
+import {
+	loadProviders,
+	resolveBrowserDefaults,
+	sendProviderCatalog,
+} from "./providers";
+import {
+	mapHistoryToWebviewMessages,
+	trackSession,
+	webviewSessionsPayload,
+} from "./session-mapping";
+import type { HubContext } from "./state";
+import { broadcastHubState, hubStatePayload } from "./state-payloads";
+import type { BrowserPeer, SessionContext } from "./types";
+import { asNumber, asString } from "./utils";
+
+function toRuntimeReasoningOptions(
+	reasonLevel?: WebviewReasonLevel,
+): Pick<ClineCoreStartInput["config"], "reasoningEffort" | "thinking"> {
+	if (reasonLevel === undefined) return {};
+	if (reasonLevel === "none") return { thinking: false };
+	return { thinking: true, reasoningEffort: reasonLevel };
+}
+
+function asWebviewReasonLevel(value: unknown): WebviewReasonLevel | undefined {
+	return value === "none" ||
+		value === "low" ||
+		value === "medium" ||
+		value === "high"
+		? value
+		: undefined;
+}
+
+export function resolveLaunchContext(
+	ctx: HubContext,
+	override?: Partial<SessionContext> & WebviewConfig,
+): SessionContext {
+	const providerId =
+		override?.provider ??
+		override?.providerId ??
+		ctx.lastSessionContext?.providerId ??
+		providerSettingsManager.getLastUsedProviderSettings()?.provider ??
+		process.env.CLINE_PROVIDER?.trim() ??
+		"";
+	const modelId =
+		override?.model ??
+		override?.modelId ??
+		ctx.lastSessionContext?.modelId ??
+		providerSettingsManager.getLastUsedProviderSettings()?.model ??
+		process.env.CLINE_MODEL?.trim() ??
+		"";
+	const root =
+		override?.workspaceRoot ??
+		ctx.lastSessionContext?.workspaceRoot ??
+		workspaceRoot;
+	if (!providerId || !modelId) {
+		throw new Error(
+			"No provider/model available. Start a session in another Cline client first, or set CLINE_PROVIDER and CLINE_MODEL.",
+		);
+	}
+	return {
+		workspaceRoot: root,
+		cwd: override?.cwd ?? ctx.lastSessionContext?.cwd ?? root,
+		providerId,
+		modelId,
+	};
+}
+
+function buildSessionStartInput(
+	context: SessionContext,
+	options?: {
+		mode?: "act" | "plan";
+		systemPrompt?: string;
+		maxIterations?: number;
+		reasonLevel?: WebviewReasonLevel;
+		enableTools?: boolean;
+		enableSpawn?: boolean;
+		enableTeams?: boolean;
+		autoApproveTools?: boolean;
+		teamName?: string;
+		source?: SessionSource;
+		sessionMetadata?: Record<string, unknown>;
+		initialMessages?: Message[];
+	},
+): ClineCoreStartInput {
+	const mode = options?.mode === "plan" ? "plan" : "act";
+	const reasoningOptions = toRuntimeReasoningOptions(options?.reasonLevel);
+	return {
+		source: options?.source ?? SessionSource.WEB,
+		interactive: true,
+		config: {
+			workspaceRoot: context.workspaceRoot,
+			cwd: context.cwd,
+			providerId: context.providerId,
+			modelId: context.modelId,
+			systemPrompt: options?.systemPrompt ?? "",
+			mode,
+			...reasoningOptions,
+			maxIterations: options?.maxIterations,
+			enableTools: options?.enableTools !== false,
+			enableSpawnAgent: options?.enableSpawn !== false,
+			enableAgentTeams: options?.enableTeams === true,
+			teamName: options?.teamName ?? "cline-hub",
+			missionLogIntervalSteps: 3,
+			missionLogIntervalMs: 120000,
+			checkpoint: { enabled: true },
+		},
+		sessionMetadata: {
+			source: options?.source ?? SessionSource.WEB,
+			mode,
+			systemPrompt: options?.systemPrompt,
+			maxIterations: options?.maxIterations,
+			reasonLevel: options?.reasonLevel,
+			autoApproveTools: options?.autoApproveTools,
+			...(options?.sessionMetadata ?? {}),
+		},
+		...(options?.initialMessages
+			? { initialMessages: options.initialMessages }
+			: {}),
+		toolPolicies:
+			options?.autoApproveTools === false
+				? { "*": { autoApprove: false } }
+				: { "*": { autoApprove: true } },
+	};
+}
+
+function buildStartInputFromSession(
+	session: SessionRecord,
+	options?: {
+		sessionMetadata?: Record<string, unknown>;
+		initialMessages?: Message[];
+	},
+) {
+	const metadata =
+		session.metadata && typeof session.metadata === "object"
+			? session.metadata
+			: {};
+	const mode = metadata.mode === "plan" ? "plan" : "act";
+	return buildSessionStartInput(
+		{
+			workspaceRoot: session.workspaceRoot,
+			cwd: session.cwd,
+			providerId: session.provider,
+			modelId: session.model,
+		},
+		{
+			mode,
+			systemPrompt: asString(metadata.systemPrompt),
+			maxIterations: asNumber(metadata.maxIterations),
+			reasonLevel: asWebviewReasonLevel(metadata.reasonLevel),
+			enableTools: session.enableTools,
+			enableSpawn: session.enableSpawn,
+			enableTeams: session.enableTeams,
+			autoApproveTools:
+				typeof metadata.autoApproveTools === "boolean"
+					? metadata.autoApproveTools
+					: undefined,
+			teamName: session.teamName,
+			source: session.source,
+			sessionMetadata: { ...metadata, ...(options?.sessionMetadata ?? {}) },
+			initialMessages: options?.initialMessages,
+		},
+	);
+}
+
+async function loadHistoryFor(
+	ctx: HubContext,
+	sessionId: string,
+): Promise<unknown[]> {
+	if (!ctx.cline) return [];
+	try {
+		return (await ctx.cline.readMessages(sessionId)) as unknown[];
+	} catch (error) {
+		console.warn(`readMessages(${sessionId}) failed:`, error);
+		return [];
+	}
+}
+
+export async function selectSession(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	sessionId: string,
+): Promise<void> {
+	peer.selectedSessionId = sessionId;
+	const tracked = ctx.sessions.get(sessionId);
+	const history = await loadHistoryFor(ctx, sessionId);
+	ctx.send(peer, { type: "session_started", sessionId });
+	ctx.send(peer, {
+		type: "session_hydrated",
+		sessionId,
+		status: tracked?.status,
+		providerId: tracked?.provider,
+		modelId: tracked?.model,
+		messages: mapHistoryToWebviewMessages(history),
+	});
+}
+
+export async function createSession(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	prompt: string,
+	config?: WebviewConfig,
+	attachments?: { userImages?: string[] },
+): Promise<void> {
+	if (!ctx.cline) throw new Error("Hub is not connected.");
+	const context = resolveLaunchContext(ctx, config);
+	const mode = config?.mode === "plan" ? "plan" : "act";
+	const result = await ctx.cline.start(
+		buildSessionStartInput(context, {
+			mode,
+			systemPrompt: config?.systemPrompt,
+			maxIterations: config?.maxIterations,
+			reasonLevel: config?.reasonLevel,
+			enableTools: config?.enableTools,
+			enableSpawn: config?.enableSpawn,
+			enableTeams: config?.enableTeams,
+			autoApproveTools: config?.autoApproveTools,
+		}),
+	);
+	peer.selectedSessionId = result.sessionId;
+	ctx.sessions.set(result.sessionId, {
+		sessionId: result.sessionId,
+		status: "running",
+		title: prompt.length > 34 ? `${prompt.slice(0, 31)}...` : prompt,
+		workspaceRoot: context.workspaceRoot,
+		cwd: context.cwd,
+		provider: context.providerId,
+		model: context.modelId,
+		source: SessionSource.WEB,
+		createdAt: Date.now(),
+		updatedAt: Date.now(),
+		prompt,
+		agentCount: 1,
+		participantCount: 1,
+	});
+	const tracked = ctx.sessions.get(result.sessionId);
+	ctx.send(peer, { type: "session_started", sessionId: result.sessionId });
+	ctx.send(peer, {
+		type: "session_hydrated",
+		sessionId: result.sessionId,
+		status: tracked?.status,
+		providerId: context.providerId,
+		modelId: context.modelId,
+		messages: [],
+	});
+	broadcastHubState(ctx);
+	await ctx.cline.send({
+		sessionId: result.sessionId,
+		prompt,
+		mode,
+		userImages: attachments?.userImages,
+	});
+}
+
+export async function sendMessage(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	text: string,
+	config?: WebviewConfig,
+	attachments?: { userImages?: string[] },
+): Promise<void> {
+	if (!ctx.cline) throw new Error("Hub is not connected.");
+	if (!peer.selectedSessionId) {
+		await createSession(ctx, peer, text, config, attachments);
+		return;
+	}
+	await ctx.cline.send({
+		sessionId: peer.selectedSessionId,
+		prompt: text,
+		mode: config?.mode === "plan" ? "plan" : "act",
+		userImages: attachments?.userImages,
+	});
+}
+
+export async function deleteSession(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	sessionId: string,
+): Promise<void> {
+	if (!ctx.cline) throw new Error("Hub is not connected.");
+	const deleted = await ctx.cline.delete(sessionId);
+	if (!deleted) {
+		ctx.send(peer, {
+			type: "status",
+			text: `Session ${sessionId} was not found.`,
+		});
+		return;
+	}
+	ctx.sessions.delete(sessionId);
+	if (peer.selectedSessionId === sessionId) {
+		peer.selectedSessionId = undefined;
+		ctx.send(peer, { type: "reset_done" });
+	}
+	ctx.send(peer, { type: "status", text: `Deleted session ${sessionId}` });
+	broadcastHubState(ctx);
+}
+
+export async function resetPeer(
+	ctx: HubContext,
+	peer: BrowserPeer,
+): Promise<void> {
+	if (peer.selectedSessionId) {
+		rejectPendingApprovalsForSession(
+			ctx,
+			peer.selectedSessionId,
+			"Session detached before approval was resolved.",
+		);
+	}
+	peer.selectedSessionId = undefined;
+	ctx.send(peer, { type: "reset_done" });
+	ctx.send(peer, webviewSessionsPayload(ctx));
+}
+
+export async function abortPeerTurn(
+	ctx: HubContext,
+	peer: BrowserPeer,
+): Promise<void> {
+	if (!ctx.cline || !peer.selectedSessionId) return;
+	rejectPendingApprovalsForSession(
+		ctx,
+		peer.selectedSessionId,
+		"Turn aborted before approval was resolved.",
+	);
+	await ctx.cline.abort(peer.selectedSessionId);
+	ctx.send(peer, { type: "status", text: "Abort requested." });
+}
+
+export async function forkPeerSession(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	syncHubClientsAndSessions: () => Promise<void>,
+): Promise<void> {
+	if (!ctx.cline) throw new Error("Hub is not connected.");
+	const forkedFromSessionId = peer.selectedSessionId;
+	if (!forkedFromSessionId) {
+		ctx.send(peer, { type: "fork_error", text: "No active session to fork." });
+		return;
+	}
+	try {
+		const rawMessages = (await ctx.cline.readMessages(
+			forkedFromSessionId,
+		)) as Message[];
+		if (rawMessages.length === 0) {
+			ctx.send(peer, {
+				type: "fork_error",
+				text: "Cannot fork an empty session.",
+			});
+			return;
+		}
+		const sourceSession = await ctx.cline.get(forkedFromSessionId);
+		if (!sourceSession) {
+			ctx.send(peer, {
+				type: "fork_error",
+				text: `Session ${forkedFromSessionId} was not found.`,
+			});
+			return;
+		}
+		const checkpointMetadata = sourceSession.metadata?.checkpoint;
+		const result = await ctx.cline.start(
+			buildStartInputFromSession(sourceSession, {
+				initialMessages: rawMessages,
+				sessionMetadata: {
+					...(sourceSession.metadata ?? {}),
+					fork: {
+						forkedFromSessionId,
+						forkedAt: new Date().toISOString(),
+						source: sourceSession.source,
+						...(checkpointMetadata !== undefined
+							? { checkpoints: checkpointMetadata }
+							: {}),
+					},
+				},
+			}),
+		);
+		peer.selectedSessionId = result.sessionId;
+		const newSession = await ctx.cline.get(result.sessionId);
+		const tracked = newSession ? trackSession(newSession) : undefined;
+		if (tracked) ctx.sessions.set(tracked.sessionId, tracked);
+		ctx.send(peer, { type: "session_started", sessionId: result.sessionId });
+		ctx.send(peer, {
+			type: "session_hydrated",
+			sessionId: result.sessionId,
+			status: newSession?.status,
+			providerId: newSession?.provider,
+			modelId: newSession?.model,
+			messages: mapHistoryToWebviewMessages(rawMessages),
+		});
+		ctx.send(peer, {
+			type: "fork_done",
+			forkedFromSessionId,
+			newSessionId: result.sessionId,
+		});
+		await syncHubClientsAndSessions();
+		broadcastHubState(ctx);
+	} catch (error) {
+		ctx.send(peer, {
+			type: "fork_error",
+			text: error instanceof Error ? error.message : String(error),
+		});
+	}
+}
+
+export async function restorePeerSession(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	checkpointRunCount: number,
+	syncHubClientsAndSessions: () => Promise<void>,
+): Promise<void> {
+	if (!ctx.cline) throw new Error("Hub is not connected.");
+	const sourceSessionId = peer.selectedSessionId;
+	if (!sourceSessionId) {
+		ctx.send(peer, { type: "error", text: "No active session to restore." });
+		return;
+	}
+	const sourceSession = await ctx.cline.get(sourceSessionId);
+	if (!sourceSession) {
+		ctx.send(peer, {
+			type: "error",
+			text: `Session ${sourceSessionId} was not found.`,
+		});
+		return;
+	}
+	const result = await ctx.cline.restore({
+		sessionId: sourceSessionId,
+		checkpointRunCount,
+		cwd: sourceSession.cwd,
+		start: buildStartInputFromSession(sourceSession, {
+			sessionMetadata: {
+				...(sourceSession.metadata ?? {}),
+				restoredFromSessionId: sourceSessionId,
+				restoredCheckpointRunCount: checkpointRunCount,
+			},
+		}),
+		restore: { messages: true, workspace: true },
+	});
+	if (!result.sessionId) {
+		ctx.send(peer, {
+			type: "error",
+			text: "Checkpoint restore did not start a session.",
+		});
+		return;
+	}
+	peer.selectedSessionId = result.sessionId;
+	const restoredSession = await ctx.cline.get(result.sessionId);
+	const tracked = restoredSession ? trackSession(restoredSession) : undefined;
+	if (tracked) ctx.sessions.set(tracked.sessionId, tracked);
+	const messages =
+		result.messages ?? (await loadHistoryFor(ctx, result.sessionId));
+	ctx.send(peer, { type: "session_started", sessionId: result.sessionId });
+	ctx.send(peer, {
+		type: "session_hydrated",
+		sessionId: result.sessionId,
+		status: restoredSession?.status,
+		providerId: restoredSession?.provider,
+		modelId: restoredSession?.model,
+		messages: mapHistoryToWebviewMessages(messages),
+	});
+	await syncHubClientsAndSessions();
+	broadcastHubState(ctx);
+}
+
+export async function initializePeer(
+	ctx: HubContext,
+	peer: BrowserPeer,
+	syncHubClientsAndSessions: () => Promise<void>,
+): Promise<void> {
+	await syncHubClientsAndSessions();
+	ctx.send(peer, { type: "status", text: "Cline Hub is ready." });
+	ctx.send(peer, { type: "defaults", defaults: resolveBrowserDefaults(ctx) });
+	await loadProviders(ctx, peer);
+	await sendProviderCatalog(ctx, peer);
+	ctx.send(peer, webviewSessionsPayload(ctx));
+	ctx.send(peer, hubStatePayload(ctx));
+}
diff --git a/apps/cline-hub/src/server/state-payloads.ts b/apps/cline-hub/src/server/state-payloads.ts
new file mode 100644
index 0000000..b517bdc
--- /dev/null
+++ b/apps/cline-hub/src/server/state-payloads.ts
@@ -0,0 +1,72 @@
+import { listActiveConnectors } from "../../../cli/src/connectors/status";
+import type { WebviewHubState } from "../webview-protocol";
+import {
+	clientSummariesPayload,
+	toActionSessionSummary,
+	webviewSessionsPayload,
+} from "./session-mapping";
+import type { HubContext } from "./state";
+import { formatUptime, isActiveSession } from "./utils";
+
+function activeSessionSummaries(ctx: HubContext) {
+	return [...ctx.sessions.values()]
+		.filter((session) =>
+			isActiveSession(session.title, session.status, session.participantCount),
+		)
+		.sort((a, b) => b.updatedAt - a.updatedAt)
+		.map(toActionSessionSummary);
+}
+
+export function hubStatePayload(ctx: HubContext): WebviewHubState {
+	const sessionSummaries = activeSessionSummaries(ctx);
+	const clientList = [...ctx.clients.values()].sort(
+		(a, b) => a.connectedAt - b.connectedAt,
+	);
+	return {
+		type: "hub_state",
+		connected: Boolean(ctx.cline && ctx.uiClient),
+		hubUrl: ctx.hubUrl,
+		hubStartedAt: ctx.hubStartedAt,
+		coreVersion: ctx.coreVersion,
+		hubUptime: ctx.hubStartedAt
+			? formatUptime(Date.now() - Date.parse(ctx.hubStartedAt))
+			: undefined,
+		clients: clientList,
+		connectors: listActiveConnectors(),
+		sessions: sessionSummaries,
+		clientSummaries: clientSummariesPayload(ctx),
+		sessionSummaries,
+		events: ctx.events,
+		lastWorkspaceRoot: ctx.lastSessionContext?.workspaceRoot,
+	};
+}
+
+export function hubStatusPayload(ctx: HubContext) {
+	const clientList = [...ctx.clients.values()].sort(
+		(a, b) => a.connectedAt - b.connectedAt,
+	);
+	const sessionSummaries = activeSessionSummaries(ctx);
+	return {
+		address: ctx.hubUrl,
+		status: ctx.hubHealthy ? "healthy" : "unhealthy",
+		healthy: ctx.hubHealthy,
+		connected: Boolean(ctx.cline && ctx.uiClient),
+		startedAt: ctx.hubStartedAt,
+		uptime: ctx.hubStartedAt
+			? formatUptime(Date.now() - Date.parse(ctx.hubStartedAt))
+			: undefined,
+		coreVersion: ctx.coreVersion,
+		clients: clientList.map((client) => ({
+			clientId: client.clientId,
+			displayName: client.displayName,
+			clientType: client.clientType,
+			connectedAt: new Date(client.connectedAt).toISOString(),
+		})),
+		activeSessions: sessionSummaries.length,
+	};
+}
+
+export function broadcastHubState(ctx: HubContext): void {
+	ctx.broadcast(hubStatePayload(ctx));
+	ctx.broadcast(webviewSessionsPayload(ctx));
+}
diff --git a/apps/cline-hub/src/server/state.ts b/apps/cline-hub/src/server/state.ts
new file mode 100644
index 0000000..c653291
--- /dev/null
+++ b/apps/cline-hub/src/server/state.ts
@@ -0,0 +1,78 @@
+import {
+	type ClineCore,
+	CORE_BUILD_VERSION,
+	type HubUIClient,
+} from "@cline/core";
+import type { WebviewHubEvent } from "../webview-protocol";
+import type {
+	BrowserPeer,
+	PendingToolApproval,
+	SessionContext,
+	TrackedClient,
+	TrackedSession,
+} from "./types";
+
+/**
+ * Shared mutable runtime state for the Cline Hub server. A single instance is
+ * created in `server.ts` and threaded through the feature modules, replacing
+ * what used to be a wall of module-level `let`s in the monolithic file.
+ */
+export class HubContext {
+	readonly peers = new Set<BrowserPeer>();
+	readonly clients = new Map<string, TrackedClient>();
+	readonly sessions = new Map<string, TrackedSession>();
+	readonly pendingToolApprovals = new Map<string, PendingToolApproval>();
+	readonly events: WebviewHubEvent[] = [];
+
+	hubUrl = "";
+	hubAuthToken = "";
+	hubHealthy = false;
+	cline: ClineCore | undefined;
+	uiClient: HubUIClient | undefined;
+	hubStartedAt: string | undefined;
+	coreVersion: string | undefined = CORE_BUILD_VERSION;
+	lastSessionContext: SessionContext | undefined;
+	initialHubEventEmitted = false;
+
+	send(peer: BrowserPeer, payload: unknown): void {
+		peer.socket.send(JSON.stringify(payload));
+	}
+
+	broadcast(payload: unknown): void {
+		const data = JSON.stringify(payload);
+		for (const peer of this.peers) {
+			peer.socket.send(data);
+		}
+	}
+
+	pushEvent(
+		title: string,
+		body: string,
+		severity: WebviewHubEvent["severity"] = "info",
+		timestamp = Date.now(),
+	): void {
+		this.events.unshift({
+			id: `${timestamp}-${this.events.length}-${title}`,
+			title,
+			body,
+			severity,
+			timestamp,
+		});
+		if (this.events.length > 30) this.events.length = 30;
+	}
+
+	sendToSelectedPeers(sessionId: string, payload: unknown): void {
+		for (const peer of this.peers) {
+			if (peer.selectedSessionId === sessionId) {
+				this.send(peer, payload);
+			}
+		}
+	}
+
+	hasSelectedPeer(sessionId: string): boolean {
+		for (const peer of this.peers) {
+			if (peer.selectedSessionId === sessionId) return true;
+		}
+		return false;
+	}
+}
diff --git a/apps/cline-hub/src/server/types.ts b/apps/cline-hub/src/server/types.ts
new file mode 100644
index 0000000..be196d6
--- /dev/null
+++ b/apps/cline-hub/src/server/types.ts
@@ -0,0 +1,69 @@
+import type { SaveProviderSettingsActionRequest } from "@cline/core";
+import type { ToolApprovalResult } from "@cline/shared";
+import type {
+	WebviewInboundMessage,
+	WebviewReasonLevel,
+} from "../webview-protocol";
+
+export type BrowserFrame = WebviewInboundMessage | { type: "restart_hub" };
+
+export type ProviderSettingsUpdate = Partial<
+	Omit<SaveProviderSettingsActionRequest, "action" | "providerId">
+>;
+
+export interface BrowserConfig {
+	inviteRequired: boolean;
+	publicUrl: string;
+}
+
+export type TrackedClient = {
+	clientId: string;
+	displayName?: string;
+	clientType: string;
+	connectedAt: number;
+};
+
+export type TrackedSession = {
+	sessionId: string;
+	status: string;
+	title: string;
+	workspaceRoot: string;
+	cwd?: string;
+	provider?: string;
+	model?: string;
+	source?: string;
+	createdAt: number;
+	updatedAt: number;
+	createdByClientId?: string;
+	prompt?: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+	agentCount: number;
+	participantCount: number;
+};
+
+export type SessionContext = {
+	workspaceRoot: string;
+	cwd: string;
+	providerId: string;
+	modelId: string;
+};
+
+export type BrowserPeer = {
+	socket: Bun.ServerWebSocket<BrowserPeer>;
+	displayName: string;
+	selectedSessionId?: string;
+	unsubscribeEvents?: () => void;
+	sending: boolean;
+};
+
+export type PendingToolApproval = {
+	sessionId: string;
+	resolve: (result: ToolApprovalResult) => void;
+	timeout: ReturnType<typeof setTimeout>;
+};
+
+export type JsonRecord = Record<string, unknown>;
+
+export type { WebviewReasonLevel };
diff --git a/apps/cline-hub/src/server/user-instructions.test.ts b/apps/cline-hub/src/server/user-instructions.test.ts
new file mode 100644
index 0000000..2bdbd60
--- /dev/null
+++ b/apps/cline-hub/src/server/user-instructions.test.ts
@@ -0,0 +1,70 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { listUserInstructionConfigs } from "./user-instructions";
+
+describe("listUserInstructionConfigs", () => {
+	const tempRoots: string[] = [];
+	const envSnapshot = {
+		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
+		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
+	};
+
+	afterEach(async () => {
+		if (envSnapshot.CLINE_GLOBAL_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH =
+				envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
+		}
+		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
+		}
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("uses the package name for package-backed plugin entries", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "cline-hub-config-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(tempRoot, "settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = join(tempRoot, "mcp.json");
+		const packageDir = join(
+			tempRoot,
+			".cline",
+			"plugins",
+			"_installed",
+			"git",
+			"github.com",
+			"demo",
+			"package",
+		);
+		await mkdir(packageDir, { recursive: true });
+		const pluginPath = join(packageDir, "index.ts");
+		await writeFile(
+			join(packageDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "cline-sdk-portable-agents",
+					cline: {
+						plugins: [{ paths: ["./index.ts"] }],
+					},
+				},
+				null,
+				2,
+			),
+		);
+		await writeFile(pluginPath, "export default {};\n");
+
+		const data = await listUserInstructionConfigs(tempRoot);
+		const plugins = data.plugins as Array<{ name: string; path: string }>;
+		const plugin = plugins.find((item) => item.path === pluginPath);
+
+		expect(plugin?.name).toBe("cline-sdk-portable-agents");
+	});
+});
diff --git a/apps/cline-hub/src/server/user-instructions.ts b/apps/cline-hub/src/server/user-instructions.ts
new file mode 100644
index 0000000..181704b
--- /dev/null
+++ b/apps/cline-hub/src/server/user-instructions.ts
@@ -0,0 +1,228 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import {
+	dirname,
+	extname,
+	isAbsolute,
+	join,
+	basename as pathBasename,
+	relative,
+	resolve,
+} from "node:path";
+import {
+	createUserInstructionConfigService,
+	discoverPluginModulePaths,
+	getCoreBuiltinToolCatalog,
+	listHookConfigFiles,
+	listPluginTools,
+	readGlobalSettings,
+	resolvePluginConfigSearchPaths,
+	resolveAgentConfigSearchPaths as resolveSharedAgentConfigSearchPaths,
+} from "@cline/core";
+import { readMcpServersResponse } from "./mcp";
+import type { JsonRecord } from "./types";
+
+function resolveAgentConfigSearchPaths(workspaceRoot?: string): string[] {
+	return resolveSharedAgentConfigSearchPaths(workspaceRoot);
+}
+
+function readPackageName(packageJsonPath: string): string | undefined {
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+			name?: unknown;
+		};
+		return typeof packageJson.name === "string" && packageJson.name.trim()
+			? packageJson.name.trim()
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isPathWithin(parentPath: string, childPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+function getPluginDisplayName(filePath: string, searchRoot: string): string {
+	let current = dirname(filePath);
+	const root = resolve(searchRoot);
+	while (isPathWithin(root, current)) {
+		const packageJsonPath = join(current, "package.json");
+		if (existsSync(packageJsonPath)) {
+			const packageName = readPackageName(packageJsonPath);
+			if (packageName) {
+				return packageName;
+			}
+			break;
+		}
+		const parent = resolve(current, "..");
+		if (parent === current) {
+			break;
+		}
+		current = parent;
+	}
+	return pathBasename(filePath, extname(filePath));
+}
+
+export async function listUserInstructionConfigs(
+	targetWorkspaceRoot: string,
+): Promise<JsonRecord> {
+	const warnings: string[] = [];
+
+	const loadUserInstructionSnapshot = async (
+		type: "rule" | "skill" | "workflow",
+	): Promise<unknown[]> => {
+		const items: unknown[] = [];
+		const service = createUserInstructionConfigService({
+			skills: { workspacePath: targetWorkspaceRoot },
+			rules: { workspacePath: targetWorkspaceRoot },
+			workflows: { workspacePath: targetWorkspaceRoot },
+		});
+		try {
+			await service.start();
+			for (const record of service.listRecords(type)) {
+				const item = record.item as unknown as JsonRecord;
+				if (item.disabled === true) continue;
+				items.push({
+					id: record.id,
+					name: item.name ?? record.id,
+					instructions: item.instructions,
+					path: record.filePath,
+				});
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnings.push(`${type}: ${message}`);
+		} finally {
+			service.stop();
+		}
+		return items;
+	};
+
+	const loadAgents = (): unknown[] => {
+		const agentsById = new Map<string, { name: string; path: string }>();
+		const directories = resolveAgentConfigSearchPaths(
+			targetWorkspaceRoot,
+		).filter((d) => existsSync(d));
+		for (const directory of directories) {
+			try {
+				for (const entry of readdirSync(directory, { withFileTypes: true })) {
+					if (!entry.isFile()) continue;
+					const ext = extname(entry.name).toLowerCase();
+					if (ext !== ".yml" && ext !== ".yaml") continue;
+					const filePath = join(directory, entry.name);
+					const raw = readFileSync(filePath, "utf8");
+					const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+					const fm = fmMatch?.[1] ?? "";
+					const nameMatch = fm.match(/^\s*name:\s*(.+?)\s*$/m);
+					const parsedName = nameMatch?.[1]?.replace(/^["']|["']$/g, "").trim();
+					const name =
+						parsedName && parsedName.length > 0
+							? parsedName
+							: pathBasename(entry.name, ext);
+					const id = name.toLowerCase();
+					if (!agentsById.has(id)) {
+						agentsById.set(id, { name, path: filePath });
+					}
+				}
+			} catch {
+				// best-effort
+			}
+		}
+		return [...agentsById.values()].sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+	};
+
+	const loadHooks = (): unknown[] => {
+		try {
+			return listHookConfigFiles(targetWorkspaceRoot);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnings.push(`hooks: ${message}`);
+			return [];
+		}
+	};
+
+	const loadPlugins = (): Array<{
+		name: string;
+		path: string;
+		enabled: boolean;
+	}> => {
+		const disabledPlugins = new Set(readGlobalSettings().disabledPlugins ?? []);
+		const pluginsByPath = new Map<
+			string,
+			{ name: string; path: string; enabled: boolean }
+		>();
+		const directories = resolvePluginConfigSearchPaths(
+			targetWorkspaceRoot,
+		).filter((d) => existsSync(d));
+		for (const directory of directories) {
+			try {
+				for (const filePath of discoverPluginModulePaths(directory)) {
+					if (pluginsByPath.has(filePath)) continue;
+					pluginsByPath.set(filePath, {
+						name: getPluginDisplayName(filePath, directory),
+						path: filePath,
+						enabled: !disabledPlugins.has(filePath),
+					});
+				}
+			} catch {
+				// best-effort
+			}
+		}
+		return [...pluginsByPath.values()].sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+	};
+
+	const [rules, workflows, skills, pluginTools] = await Promise.all([
+		loadUserInstructionSnapshot("rule"),
+		loadUserInstructionSnapshot("workflow"),
+		loadUserInstructionSnapshot("skill"),
+		listPluginTools({
+			workspacePath: targetWorkspaceRoot,
+			cwd: targetWorkspaceRoot,
+		}),
+	]);
+	const disabledTools = new Set(readGlobalSettings().disabledTools ?? []);
+	const builtinToolCatalog = getCoreBuiltinToolCatalog({
+		disabledToolIds: disabledTools,
+	});
+
+	return {
+		workspaceRoot: targetWorkspaceRoot,
+		rules,
+		workflows,
+		skills,
+		agents: loadAgents(),
+		plugins: loadPlugins(),
+		tools: [
+			...builtinToolCatalog.map((tool) => ({
+				id: tool.id,
+				name: tool.id,
+				description: tool.description,
+				enabled:
+					tool.defaultEnabled &&
+					!tool.headlessToolNames.some((name) => disabledTools.has(name)),
+				source: "builtin",
+				headlessToolNames: tool.headlessToolNames,
+			})),
+			...pluginTools.map((tool) => ({
+				id: `${tool.pluginName}:${tool.name}:${tool.path}`,
+				name: tool.name,
+				description: tool.description,
+				enabled: tool.enabled,
+				source: tool.source,
+				path: tool.path,
+				pluginName: tool.pluginName,
+			})),
+		],
+		hooks: loadHooks(),
+		mcp: readMcpServersResponse(),
+		warnings,
+	};
+}
diff --git a/apps/cline-hub/src/server/utils.ts b/apps/cline-hub/src/server/utils.ts
new file mode 100644
index 0000000..53512f1
--- /dev/null
+++ b/apps/cline-hub/src/server/utils.ts
@@ -0,0 +1,145 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import type { ProviderSettingsUpdate } from "./types";
+
+export function readProviderSettingsUpdate(
+	args: Record<string, unknown> | undefined,
+): ProviderSettingsUpdate {
+	return args?.settings && typeof args.settings === "object"
+		? (args.settings as ProviderSettingsUpdate)
+		: {};
+}
+
+export function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export function asNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+export function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+export function asTimestamp(value: unknown): number | undefined {
+	const numeric = asNumber(value);
+	if (numeric !== undefined) return numeric;
+	if (typeof value !== "string" || !value.trim()) return undefined;
+	const timestamp = Date.parse(value);
+	return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+
+export function basename(value: string | undefined): string {
+	const trimmed = value?.trim();
+	if (!trimmed) return "workspace";
+	const parts = trimmed.split(/[\\/]+/).filter(Boolean);
+	return parts.at(-1) ?? trimmed;
+}
+
+export function toPositiveInt(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	const rounded = Math.trunc(value);
+	return rounded > 0 ? rounded : undefined;
+}
+
+export function asTrimmedString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function isVisibleClient(clientType: string): boolean {
+	return clientType.trim().length > 0;
+}
+
+export function isActiveSession(
+	title: string | undefined,
+	status: string | undefined,
+	participantCount?: number,
+): boolean {
+	if (!title || !status) return false;
+	const normalized = status?.trim().toLowerCase();
+	if (normalized !== "running" && normalized !== "idle") return false;
+	return typeof participantCount === "number" ? participantCount > 0 : false;
+}
+
+export function formatUptime(ms: number): string {
+	const total = Math.max(0, Math.floor(ms / 1000));
+	const d = Math.floor(total / 86_400);
+	const h = Math.floor((total % 86_400) / 3_600);
+	const m = Math.floor((total % 3_600) / 60);
+	const s = total % 60;
+	if (d > 0) return `${d}d ${h}h`;
+	if (h > 0) return `${h}h ${m}m`;
+	if (m > 0) return `${m}m ${s}s`;
+	return `${s}s`;
+}
+
+export function formatClientLabel(clientType: string | undefined): string {
+	const normalized = clientType?.trim().toLowerCase() ?? "";
+	if (!normalized || normalized === "unknown") return "Client";
+	if (normalized.includes("cline")) return "Cline";
+	return normalized
+		.split(/[-_\s]+/)
+		.filter(Boolean)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ");
+}
+
+export function stringifyContent(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		return value
+			.map((entry) => {
+				if (typeof entry === "string") return entry;
+				if (entry && typeof entry === "object") {
+					const record = entry as Record<string, unknown>;
+					return (
+						asString(record.text) ??
+						asString(record.content) ??
+						asString(record.result) ??
+						""
+					);
+				}
+				return "";
+			})
+			.filter(Boolean)
+			.join("\n");
+	}
+	if (value == null) return "";
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+
+export function chunkText(chunk: unknown): string {
+	if (typeof chunk === "string") return chunk;
+	if (chunk && typeof chunk === "object") {
+		const record = chunk as Record<string, unknown>;
+		if (typeof record.text === "string") return record.text;
+		if (typeof record.content === "string") return record.content;
+	}
+	return "";
+}
+
+export function openExternalUrl(url: string): void {
+	const platform = process.platform;
+	const command =
+		platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+	const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+	const child = spawn(command, args, {
+		stdio: "ignore",
+		detached: true,
+		// Prevent a console window from flashing on Windows; the launched
+		// browser/app still opens normally.
+		windowsHide: true,
+	});
+	child.unref();
+}
diff --git a/apps/cline-hub/src/validate-options.ts b/apps/cline-hub/src/validate-options.ts
new file mode 100644
index 0000000..78e6687
--- /dev/null
+++ b/apps/cline-hub/src/validate-options.ts
@@ -0,0 +1,74 @@
+import { buildInviteUrl, resolveClineHubServerOptions } from "./options";
+
+function expectEqual<T>(actual: T, expected: T, label: string): void {
+	if (actual !== expected) {
+		throw new Error(
+			`${label}: expected ${String(expected)}, got ${String(actual)}`,
+		);
+	}
+}
+
+function expectThrows(fn: () => unknown, label: string): void {
+	try {
+		fn();
+	} catch {
+		return;
+	}
+	throw new Error(`${label}: expected an error`);
+}
+
+const defaults = resolveClineHubServerOptions({});
+expectEqual(defaults.host, "127.0.0.1", "default host");
+expectEqual(defaults.port, 8787, "default port");
+expectEqual(defaults.publicUrl, "http://127.0.0.1:8787", "default public URL");
+expectEqual(defaults.roomSecret, undefined, "default room secret");
+
+const lan = resolveClineHubServerOptions({
+	HOST: "0.0.0.0",
+	CLINE_HUB_DASHBOARD_PORT: "9000",
+	PUBLIC_URL: "https://example.ngrok-free.app/",
+	ROOM_SECRET: "invite-123",
+	WORKSPACE_ROOT: "/tmp/workspace",
+});
+expectEqual(lan.host, "0.0.0.0", "LAN host");
+expectEqual(lan.port, 9000, "LAN port");
+expectEqual(lan.publicUrl, "https://example.ngrok-free.app", "LAN public URL");
+expectEqual(lan.roomSecret, "invite-123", "LAN room secret");
+expectEqual(lan.workspaceRoot, "/tmp/workspace", "workspace root");
+expectEqual(
+	buildInviteUrl(lan.publicUrl, lan.roomSecret),
+	"https://example.ngrok-free.app/?roomSecret=invite-123",
+	"invite URL",
+);
+
+const tailscale = resolveClineHubServerOptions({
+	HOST: "0.0.0.0",
+	CLINE_HUB_DASHBOARD_PORT: "8787",
+	PUBLIC_URL: "http://100.82.5.118",
+	ROOM_SECRET: "invite-123",
+});
+expectEqual(
+	tailscale.publicUrl,
+	"http://100.82.5.118:8787",
+	"direct IP public URL gets dashboard port",
+);
+expectEqual(
+	buildInviteUrl(tailscale.publicUrl, tailscale.roomSecret),
+	"http://100.82.5.118:8787/?roomSecret=invite-123",
+	"invite URL for direct IP public URL",
+);
+
+expectThrows(
+	() => resolveClineHubServerOptions({ HOST: "0.0.0.0" }),
+	"non-local bind without ROOM_SECRET",
+);
+expectThrows(
+	() => resolveClineHubServerOptions({ CLINE_HUB_DASHBOARD_PORT: "70000" }),
+	"invalid dashboard port",
+);
+expectThrows(
+	() => resolveClineHubServerOptions({ PUBLIC_URL: "ftp://example.test" }),
+	"invalid PUBLIC_URL protocol",
+);
+
+console.log("cline-hub option validation passed");
diff --git a/apps/cline-hub/src/webview-protocol.ts b/apps/cline-hub/src/webview-protocol.ts
new file mode 100644
index 0000000..7495525
--- /dev/null
+++ b/apps/cline-hub/src/webview-protocol.ts
@@ -0,0 +1,344 @@
+import type {
+	ChatMessage as CoreChatMessage,
+	ProviderListItem,
+	ProviderModel,
+} from "@cline/core";
+
+export type WebviewUsage = {
+	inputTokens?: number;
+	outputTokens?: number;
+	cacheCreationInputTokens?: number;
+	cacheReadInputTokens?: number;
+	totalCost?: number;
+};
+
+export type WebviewProviderModel = Pick<
+	ProviderModel,
+	"id" | "name" | "supportsReasoning"
+> & {
+	supportsThinking?: boolean;
+};
+
+export type WebviewProviderCatalogItem = ProviderListItem;
+
+export type WebviewReasonLevel = "none" | "low" | "medium" | "high";
+
+export type WebviewToolEvent = {
+	toolCallId?: string;
+	toolName?: string;
+	status: "running" | "completed" | "failed";
+	input?: unknown;
+	output?: unknown;
+	error?: string;
+};
+
+export type WebviewChatMessageBlock =
+	| { id: string; type: "text"; text: string }
+	| { id: string; type: "reasoning"; text: string; redacted?: boolean }
+	| {
+			id: string;
+			type: "tool";
+			toolEvent: NonNullable<WebviewChatMessage["toolEvents"]>[number];
+	  };
+
+export type WebviewChatMessage = Omit<
+	CoreChatMessage,
+	"content" | "createdAt" | "meta" | "role" | "sessionId"
+> & {
+	role:
+		| Extract<CoreChatMessage["role"], "user" | "assistant" | "error">
+		| "meta";
+	text: string;
+	reasoning?: string;
+	reasoningRedacted?: boolean;
+	checkpoint?: NonNullable<CoreChatMessage["meta"]>["checkpoint"];
+	toolEvents?: Array<{
+		id: string;
+		toolCallId?: string;
+		name: string;
+		text: string;
+		state: "input-available" | "output-available" | "output-error";
+		input?: unknown;
+		output?: unknown;
+		error?: string;
+	}>;
+	blocks?: WebviewChatMessageBlock[];
+};
+
+export type WebviewConfig = {
+	provider?: string;
+	model?: string;
+	mode?: "act" | "plan";
+	systemPrompt?: string;
+	maxIterations?: number;
+	reasonLevel?: WebviewReasonLevel;
+	enableTools?: boolean;
+	enableSpawn?: boolean;
+	enableTeams?: boolean;
+	autoApproveTools?: boolean;
+};
+
+export type WebviewChatAttachments = {
+	userImages?: string[];
+};
+
+export type WebviewToolApprovalRequest = {
+	approvalId: string;
+	sessionId: string;
+	agentId: string;
+	conversationId: string;
+	iteration: number;
+	toolCallId: string;
+	toolName: string;
+	input: unknown;
+	policy?: Record<string, unknown>;
+};
+
+export type WebviewDefaults = {
+	provider?: string;
+	model?: string;
+	workspaceRoot: string;
+	cwd: string;
+};
+
+export type WebviewSessionSummary = {
+	sessionId: string;
+	title?: string;
+	status?: string;
+	source?: string;
+	providerId?: string;
+	model?: string;
+	workspaceRoot?: string;
+	createdAt?: number;
+	updatedAt?: number;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+};
+
+export type WebviewConnectedClient = {
+	clientId: string;
+	displayName?: string;
+	clientType: string;
+	connectedAt: number;
+};
+
+export type WebviewClientSummary = {
+	label: string;
+	name: string;
+	sessionCount: number;
+};
+
+export type WebviewConnectorField = {
+	flag: string;
+	label: string;
+	placeholder?: string;
+	required?: boolean;
+	help?: string[];
+	initialValue?: string;
+	options?: Array<{ value: string; label: string; hint?: string }>;
+	includeWhen?: {
+		flag: string;
+		equals?: string;
+		notEquals?: string;
+	};
+};
+
+export type WebviewConnectorSecurityField = {
+	key: string;
+	label: string;
+	placeholder?: string;
+	help?: string[];
+	requiredMessage: string;
+};
+
+export type WebviewConnectorChannel = {
+	id: string;
+	name: string;
+	type: "polling" | "webhook" | "hybrid";
+	hint: string;
+	fields: WebviewConnectorField[];
+	security?: {
+		prompt: string;
+		fields: WebviewConnectorSecurityField[];
+	};
+};
+
+export type WebviewActiveConnector = {
+	id: string;
+	type: string;
+	pid: number;
+	hubUrl: string;
+	startedAt?: string;
+	applicationId?: string;
+	botUsername?: string;
+	userName?: string;
+	phoneNumberId?: string;
+	port?: number;
+	baseUrl?: string;
+	connectionMode?: string;
+};
+
+export type WebviewConnectorChannelsResponse = {
+	available: WebviewConnectorChannel[];
+	active: WebviewActiveConnector[];
+};
+
+export type WebviewActionSessionSummary = {
+	sessionId: string;
+	title: string;
+	status: string;
+	workspaceRoot: string;
+	workspaceName: string;
+	cwd?: string;
+	model?: string;
+	provider?: string;
+	createdAt: number;
+	updatedAt: number;
+	createdByClientId?: string;
+	prompt?: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+	agentCount: number;
+};
+
+export type WebviewHubEvent = {
+	id: string;
+	title: string;
+	body: string;
+	severity: "info" | "success" | "warn" | "error";
+	timestamp: number;
+};
+
+export type WebviewHubState = {
+	type: "hub_state";
+	connected: boolean;
+	hubUrl?: string;
+	hubStartedAt?: string;
+	coreVersion?: string;
+	hubUptime?: string;
+	clients: WebviewConnectedClient[];
+	connectors: WebviewActiveConnector[];
+	sessions: WebviewActionSessionSummary[];
+	clientSummaries: WebviewClientSummary[];
+	sessionSummaries: WebviewActionSessionSummary[];
+	events: WebviewHubEvent[];
+	lastWorkspaceRoot?: string;
+};
+
+export type WebviewInboundMessage =
+	| { type: "ready" }
+	| { type: "restart_hub" }
+	| {
+			type: "desktopCommand";
+			id: string;
+			command: string;
+			args?: Record<string, unknown>;
+	  }
+	| {
+			type: "send";
+			prompt: string;
+			config?: WebviewConfig;
+			attachments?: WebviewChatAttachments;
+	  }
+	| { type: "abort" }
+	| { type: "reset" }
+	| {
+			type: "approval_response";
+			approvalId: string;
+			approved: boolean;
+			reason?: string;
+	  }
+	| { type: "loadModels"; providerId: string }
+	| { type: "loadProviderCatalog" }
+	| {
+			type: "saveProviderSettings";
+			providerId: string;
+			enabled?: boolean;
+			apiKey?: string;
+			baseUrl?: string;
+	  }
+	| { type: "runProviderOAuthLogin"; providerId: string }
+	| { type: "attachSession"; sessionId: string }
+	| { type: "deleteSession"; sessionId: string }
+	| {
+			type: "updateSessionMetadata";
+			sessionId: string;
+			metadata: Record<string, unknown>;
+	  }
+	| { type: "restore"; checkpointRunCount: number }
+	| { type: "forkSession" };
+
+export type WebviewOutboundMessage =
+	| { type: "status"; text: string }
+	| { type: "error"; text: string }
+	| {
+			type: "desktopCommandResult";
+			id: string;
+			ok: true;
+			result: unknown;
+	  }
+	| {
+			type: "desktopCommandResult";
+			id: string;
+			ok: false;
+			error: string;
+	  }
+	| { type: "session_started"; sessionId: string }
+	| {
+			type: "session_hydrated";
+			sessionId: string;
+			status?: string;
+			providerId?: string;
+			modelId?: string;
+			messages: WebviewChatMessage[];
+	  }
+	| { type: "assistant_delta"; text: string }
+	| { type: "reasoning_delta"; text: string; redacted?: boolean }
+	| { type: "tool_event"; text: string; event?: WebviewToolEvent }
+	| ({ type: "approval_request" } & WebviewToolApprovalRequest)
+	| {
+			type: "approval_resolved";
+			approvalId: string;
+			approved: boolean;
+			reason?: string;
+	  }
+	| {
+			type: "turn_done";
+			finishReason: string;
+			iterations: number;
+			usage?: WebviewUsage;
+	  }
+	| {
+			type: "providers";
+			providers: Array<
+				Pick<ProviderListItem, "defaultModelId" | "enabled" | "id" | "name">
+			>;
+	  }
+	| {
+			type: "provider_catalog";
+			providers: WebviewProviderCatalogItem[];
+			settingsPath: string;
+	  }
+	| {
+			type: "provider_settings_saved";
+			providerId: string;
+			enabled: boolean;
+	  }
+	| {
+			type: "provider_oauth_login_done";
+			providerId: string;
+			accessTokenPresent: boolean;
+	  }
+	| { type: "models"; providerId: string; models: WebviewProviderModel[] }
+	| { type: "sessions"; sessions: WebviewSessionSummary[] }
+	| WebviewHubState
+	| { type: "defaults"; defaults: WebviewDefaults }
+	| { type: "reset_done" }
+	| {
+			type: "fork_done";
+			forkedFromSessionId: string;
+			newSessionId: string;
+	  }
+	| { type: "fork_error"; text: string };
diff --git a/apps/cline-hub/src/webview/.gitignore b/apps/cline-hub/src/webview/.gitignore
new file mode 100644
index 0000000..97eb8c0
--- /dev/null
+++ b/apps/cline-hub/src/webview/.gitignore
@@ -0,0 +1,15 @@
+# v0 sandbox internal files
+__v0_runtime_loader.js
+__v0_devtools.tsx
+__v0_jsx-dev-runtime.ts
+.snowflake/
+.v0-trash/
+.vercel/
+
+# Environment variables
+.env*.local
+
+# Common ignores
+node_modules
+.next/
+.DS_Store
\ No newline at end of file
diff --git a/apps/cline-hub/src/webview/components.json b/apps/cline-hub/src/webview/components.json
new file mode 100644
index 0000000..6e57ca9
--- /dev/null
+++ b/apps/cline-hub/src/webview/components.json
@@ -0,0 +1,21 @@
+{
+	"$schema": "https://ui.shadcn.com/schema.json",
+	"style": "new-york",
+	"rsc": true,
+	"tsx": true,
+	"tailwind": {
+		"config": "",
+		"css": "app/globals.css",
+		"baseColor": "neutral",
+		"cssVariables": true,
+		"prefix": ""
+	},
+	"aliases": {
+		"components": "@/components",
+		"utils": "@/lib/utils",
+		"ui": "@/components/ui",
+		"lib": "@/lib",
+		"hooks": "@/hooks"
+	},
+	"iconLibrary": "lucide"
+}
diff --git a/apps/cline-hub/src/webview/eslint.config.js b/apps/cline-hub/src/webview/eslint.config.js
new file mode 100644
index 0000000..dca2e85
--- /dev/null
+++ b/apps/cline-hub/src/webview/eslint.config.js
@@ -0,0 +1,29 @@
+import js from "@eslint/js";
+import { defineConfig, globalIgnores } from "eslint/config";
+import reactHooks from "eslint-plugin-react-hooks";
+import reactRefresh from "eslint-plugin-react-refresh";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default defineConfig([
+	globalIgnores(["dist"]),
+	{
+		files: ["**/*.{ts,tsx}"],
+		extends: [
+			js.configs.recommended,
+			tseslint.configs.recommended,
+			reactHooks.configs.flat.recommended,
+			reactRefresh.configs.vite,
+		],
+		rules: {
+			"react-refresh/only-export-components": [
+				"warn",
+				{ allowConstantExport: true },
+			],
+		},
+		languageOptions: {
+			ecmaVersion: 2020,
+			globals: globals.browser,
+		},
+	},
+]);
diff --git a/apps/cline-hub/src/webview/index.html b/apps/cline-hub/src/webview/index.html
new file mode 100644
index 0000000..ff7833d
--- /dev/null
+++ b/apps/cline-hub/src/webview/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/cline-logo-filled.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Cline Hub</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/apps/cline-hub/src/webview/package.json b/apps/cline-hub/src/webview/package.json
new file mode 100644
index 0000000..abe314a
--- /dev/null
+++ b/apps/cline-hub/src/webview/package.json
@@ -0,0 +1,64 @@
+{
+	"name": "@cline/cline-hub-webview",
+	"private": true,
+	"version": "0.0.0",
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc -b && vite build",
+		"preview": "vite preview"
+	},
+	"dependencies": {
+		"@base-ui/react": "^1.3.0",
+		"@fontsource-variable/schibsted-grotesk": "^5.2.8",
+		"@radix-ui/react-use-controllable-state": "^1.2.2",
+		"@rive-app/react-webgl2": "^4.27.2",
+		"@shikijs/langs": "^4.2.0",
+		"@shikijs/themes": "^4.2.0",
+		"@streamdown/cjk": "^1.0.3",
+		"@tailwindcss/vite": "^4.2.1",
+		"@xyflow/react": "^12.10.1",
+		"ai": "^6.0.116",
+		"ansi-to-react": "^6.2.6",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"cmdk": "^1.1.1",
+		"embla-carousel-react": "^8.6.0",
+		"lucide-react": "^0.577.0",
+		"media-chrome": "^4.18.1",
+		"mermaid": "^11.15.0",
+		"motion": "^12.38.0",
+		"nanoid": "^5.1.7",
+		"next-themes": "^0.4.6",
+		"react": "19.2.4",
+		"react-dom": "19.2.4",
+		"react-jsx-parser": "^2.4.1",
+		"recharts": "2.15.4",
+		"shadcn": "^4.0.8",
+		"shiki": "^4.0.2",
+		"sonner": "^2.0.7",
+		"streamdown": "^2.5.0",
+		"tailwind-merge": "^3.5.0",
+		"tokenlens": "^1.3.1",
+		"use-stick-to-bottom": "^1.1.3"
+	},
+	"devDependencies": {
+		"@eslint/js": "^9.39.4",
+		"@tailwindcss/postcss": "^4.2.0",
+		"@types/node": "^24.12.0",
+		"@types/react": "^19.2.14",
+		"@types/react-dom": "^19.2.3",
+		"@vitejs/plugin-react-swc": "^4.3.0",
+		"esbuild": "^0.27.0",
+		"eslint": "^9.39.4",
+		"eslint-plugin-react-hooks": "^7.0.1",
+		"eslint-plugin-react-refresh": "^0.5.2",
+		"globals": "^17.4.0",
+		"postcss": "^8.5",
+		"tailwindcss": "^4.2.1",
+		"tw-animate-css": "^1.4.0",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.56.1",
+		"vite": "^8.0.0"
+	}
+}
diff --git a/apps/cline-hub/src/webview/public/32x32.png b/apps/cline-hub/src/webview/public/32x32.png
new file mode 100644
index 0000000..40cfd21
Binary files /dev/null and b/apps/cline-hub/src/webview/public/32x32.png differ
diff --git a/apps/cline-hub/src/webview/public/cline-logo-filled.svg b/apps/cline-hub/src/webview/public/cline-logo-filled.svg
new file mode 100644
index 0000000..4e9df4e
--- /dev/null
+++ b/apps/cline-hub/src/webview/public/cline-logo-filled.svg
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Ebene_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 466.73 487.04">
+  <!-- Generator: Adobe Illustrator 29.8.1, SVG Export Plug-In . SVG Version: 2.1.1 Build 2)  -->
+  <path d="M463.6,275.08l-29.26-58.75v-33.83c0-56.08-45.01-101.5-100.53-101.5h-50.01c3.62-7.43,5.61-15.79,5.61-24.61,0-31.17-25.08-56.39-56.07-56.39s-56.07,25.22-56.07,56.39c0,8.82,1.99,17.17,5.61,24.61h-50.01c-55.51,0-100.52,45.42-100.52,101.5v33.83l-29.87,58.59c-3.01,5.9-3.01,12.92,0,18.81l29.87,57.93v33.83c0,56.08,45.01,101.5,100.52,101.5h200.95c55.51,0,100.53-45.42,100.53-101.5v-33.83l29.21-58.13c2.9-5.79,2.9-12.61.05-18.46ZM202.75,322.96c0,25.48-20.54,46.14-45.88,46.14s-45.88-20.66-45.88-46.14v-82.02c0-25.48,20.54-46.14,45.88-46.14s45.88,20.66,45.88,46.14v82.02ZM350.58,322.96c0,25.48-20.54,46.14-45.88,46.14s-45.88-20.66-45.88-46.14v-82.02c0-25.48,20.54-46.14,45.88-46.14s45.88,20.66,45.88,46.14v82.02Z"/>
+</svg>
\ No newline at end of file
diff --git a/apps/cline-hub/src/webview/public/favicon.svg b/apps/cline-hub/src/webview/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/apps/cline-hub/src/webview/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/apps/cline-hub/src/webview/public/icon.ico b/apps/cline-hub/src/webview/public/icon.ico
new file mode 100644
index 0000000..ea0e465
Binary files /dev/null and b/apps/cline-hub/src/webview/public/icon.ico differ
diff --git a/apps/cline-hub/src/webview/public/icon.png b/apps/cline-hub/src/webview/public/icon.png
new file mode 100644
index 0000000..f7bc15f
Binary files /dev/null and b/apps/cline-hub/src/webview/public/icon.png differ
diff --git a/apps/cline-hub/src/webview/public/icon.svg b/apps/cline-hub/src/webview/public/icon.svg
new file mode 100644
index 0000000..2a3908a
--- /dev/null
+++ b/apps/cline-hub/src/webview/public/icon.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="92px" height="96px" viewBox="0 0 92 96" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Group Copy 2</title>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="icon-copy" transform="translate(-34, -40)" fill="#24292F">
+            <g id="Group-Copy-2" transform="translate(34, 40.5)">
+                <g id="Group-3-Copy-4" transform="translate(0, 0)">
+                    <path d="M65.4492701,16.3 C76.3374701,16.3 85.1635558,25.16479 85.1635558,36.1 L85.1635558,42.7 L90.9027661,54.1647464 C91.4694141,55.2966923 91.4668177,56.6300535 90.8957658,57.7597839 L85.1635558,69.1 L85.1635558,75.7 C85.1635558,86.63554 76.3374701,95.5 65.4492701,95.5 L26.0206986,95.5 C15.1328272,95.5 6.30641291,86.63554 6.30641291,75.7 L6.30641291,69.1 L0.448507752,57.7954874 C-0.14693501,56.6464093 -0.149634367,55.2802504 0.441262896,54.1288283 L6.30641291,42.7 L6.30641291,36.1 C6.30641291,25.16479 15.1328272,16.3 26.0206986,16.3 L65.4492701,16.3 Z M62.9301895,22 L29.189529,22 C19.8723267,22 12.3191987,29.5552188 12.3191987,38.875 L12.3191987,44.5 L7.44288578,53.9634655 C6.84794449,55.1180686 6.85066096,56.4896598 7.45017099,57.6418974 L12.3191987,67 L12.3191987,72.625 C12.3191987,81.9450625 19.8723267,89.5 29.189529,89.5 L62.9301895,89.5 C72.2476729,89.5 79.8005198,81.9450625 79.8005198,72.625 L79.8005198,67 L84.5682187,57.6061395 C85.1432011,56.473244 85.1458141,55.1345713 84.5752587,53.9994398 L79.8005198,44.5 L79.8005198,38.875 C79.8005198,29.5552188 72.2476729,22 62.9301895,22 Z" id="Combined-Shape" fill-rule="nonzero"></path>
+                    <circle id="Oval" cx="45.7349843" cy="11" r="11"></circle>
+                </g>
+                <rect id="Rectangle-Copy" stroke="#24292F" stroke-width="8" x="31" y="44.5" width="5" height="22" rx="2.5"></rect>
+                <rect id="Rectangle-Copy-2" stroke="#24292F" stroke-width="8" x="55" y="44.5" width="5" height="22" rx="2.5"></rect>
+            </g>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/apps/cline-hub/src/webview/src/App.tsx b/apps/cline-hub/src/webview/src/App.tsx
new file mode 100644
index 0000000..f1bfb38
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/App.tsx
@@ -0,0 +1,1361 @@
+import {
+	ActivityIcon,
+	ArrowUpDownIcon,
+	BotIcon,
+	ClockIcon,
+	CodeIcon,
+	FileTextIcon,
+	Folder,
+	FunnelIcon,
+	HomeIcon,
+	LinkIcon,
+	MessageSquareIcon,
+	MoreHorizontal,
+	PencilIcon,
+	PlugIcon,
+	RotateCcwIcon,
+	RssIcon,
+	ServerIcon,
+	SettingsIcon,
+	Trash2Icon,
+	UserCircleIcon,
+	WrenchIcon,
+} from "lucide-react";
+import type { ReactNode } from "react";
+import {
+	lazy,
+	Suspense,
+	useCallback,
+	useEffect,
+	useMemo,
+	useState,
+} from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuCheckboxItem,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuItem,
+	DropdownMenuLabel,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Input } from "@/components/ui/input";
+import type {
+	WebviewActiveConnector,
+	WebviewConnectedClient,
+	WebviewHubEvent,
+	WebviewHubState,
+	WebviewOutboundMessage,
+	WebviewSessionSummary,
+} from "../../webview-protocol";
+import { PageFrame, PageHeader } from "./components/views/page-layout";
+import type { CustomizationSection } from "./components/views/settings/extensions-view";
+import type { SettingsSection } from "./components/views/settings/settings-view";
+import { syncHubTheme } from "./lib/theme";
+import { postToHost } from "./vscode";
+
+const Chat = lazy(() => import("./Chat"));
+const SettingsView = lazy(() =>
+	import("./components/views/settings/settings-view").then((module) => ({
+		default: module.SettingsView,
+	})),
+);
+const CustomizationSectionView = lazy(() =>
+	import("./components/views/settings/extensions-view").then((module) => ({
+		default: module.CustomizationSectionView,
+	})),
+);
+
+type View =
+	| "home"
+	| "sessions"
+	| "chat"
+	| "models"
+	| "rules"
+	| "hooks"
+	| "mcp"
+	| "plugins"
+	| "skills"
+	| "agents"
+	| "tools"
+	| "channels"
+	| "schedules"
+	| "settings"
+	| "account";
+const VIEW_PATHS: Record<View, string> = {
+	home: "/",
+	sessions: "/sessions",
+	chat: "/chat",
+	models: "/models",
+	rules: "/rules",
+	hooks: "/hooks",
+	mcp: "/mcp",
+	plugins: "/plugins",
+	skills: "/skills",
+	agents: "/agents",
+	tools: "/tools",
+	channels: "/channels",
+	schedules: "/schedules",
+	settings: "/settings",
+	account: "/settings/account",
+};
+
+const CHAT_SESSION_QUERY_PARAM = "id";
+
+const SETTINGS_SECTION_PATHS: Record<SettingsSection, string> = {
+	General: "/settings",
+	Providers: "/settings/providers",
+	MCP: "/settings/mcp",
+	Channels: "/settings/channels",
+	Schedules: "/settings/schedules",
+	Account: "/settings/account",
+};
+
+const CUSTOMIZATION_VIEW_SECTIONS = {
+	rules: "Rules",
+	hooks: "Hooks",
+	mcp: "MCP",
+	skills: "Skills",
+	agents: "Agents",
+	plugins: "Plugins",
+	tools: "Tools",
+} satisfies Partial<Record<View, CustomizationSection>>;
+
+const EMPTY_HUB_STATE: WebviewHubState = {
+	type: "hub_state",
+	connected: false,
+	clients: [],
+	connectors: [],
+	sessions: [],
+	clientSummaries: [],
+	sessionSummaries: [],
+	events: [],
+};
+
+function viewFromPath(pathname: string): View {
+	if (pathname === VIEW_PATHS.sessions) return "sessions";
+	if (pathname === VIEW_PATHS.chat) return "chat";
+	if (pathname === VIEW_PATHS.models) return "models";
+	if (
+		pathname === VIEW_PATHS.rules ||
+		pathname === "/customizations" ||
+		pathname === "/settings/customizations"
+	)
+		return "rules";
+	if (pathname === VIEW_PATHS.hooks) return "hooks";
+	if (
+		pathname === "/marketplace" ||
+		pathname === VIEW_PATHS.mcp ||
+		pathname === "/marketplace/mcp"
+	)
+		return "mcp";
+	if (pathname === VIEW_PATHS.plugins || pathname === "/marketplace/plugins")
+		return "plugins";
+	if (pathname === VIEW_PATHS.skills || pathname === "/marketplace/skills")
+		return "skills";
+	if (pathname === VIEW_PATHS.agents) return "agents";
+	if (pathname === VIEW_PATHS.tools) return "tools";
+	if (pathname === VIEW_PATHS.channels) return "channels";
+	if (pathname === VIEW_PATHS.schedules) return "schedules";
+	if (pathname === VIEW_PATHS.account) return "account";
+	if (
+		pathname === VIEW_PATHS.settings ||
+		pathname.startsWith(`${VIEW_PATHS.settings}/`)
+	) {
+		return "settings";
+	}
+	return "home";
+}
+
+function settingsSectionFromPath(pathname: string): SettingsSection {
+	for (const [section, path] of Object.entries(SETTINGS_SECTION_PATHS)) {
+		if (pathname === path) {
+			return section as SettingsSection;
+		}
+	}
+	return "General";
+}
+
+function readCurrentView(): View {
+	if (typeof window === "undefined") return "home";
+	return viewFromPath(window.location.pathname);
+}
+
+function readCurrentChatSessionId(): string | undefined {
+	if (typeof window === "undefined") return undefined;
+	if (window.location.pathname !== VIEW_PATHS.chat) return undefined;
+	const sessionId = new URLSearchParams(window.location.search)
+		.get(CHAT_SESSION_QUERY_PARAM)
+		?.trim();
+	return sessionId || undefined;
+}
+
+function chatPath(sessionId?: string): string {
+	const params = persistentRouteSearchParams();
+	if (sessionId) {
+		params.set(CHAT_SESSION_QUERY_PARAM, sessionId);
+	} else {
+		params.delete(CHAT_SESSION_QUERY_PARAM);
+	}
+	const query = params.toString();
+	return query ? `${VIEW_PATHS.chat}?${query}` : VIEW_PATHS.chat;
+}
+
+function readCurrentSettingsSection(): SettingsSection {
+	if (typeof window === "undefined") return "General";
+	return settingsSectionFromPath(window.location.pathname);
+}
+
+function persistentRouteSearchParams(): URLSearchParams {
+	if (typeof window === "undefined") return new URLSearchParams();
+	const params = new URLSearchParams(window.location.search);
+	params.delete(CHAT_SESSION_QUERY_PARAM);
+	return params;
+}
+
+function routePath(pathname: string): string {
+	const params = persistentRouteSearchParams();
+	const query = params.toString();
+	return query ? `${pathname}?${query}` : pathname;
+}
+
+function replaceLegacyCustomizationRoute(): void {
+	if (
+		typeof window === "undefined" ||
+		(window.location.pathname !== "/customizations" &&
+			window.location.pathname !== "/settings/customizations")
+	) {
+		return;
+	}
+	const nextPath = routePath(VIEW_PATHS.rules);
+	if (currentPathWithSearch() !== nextPath) {
+		window.history.replaceState(null, "", nextPath);
+	}
+}
+
+function currentPathWithSearch(): string {
+	if (typeof window === "undefined") return "/";
+	return `${window.location.pathname}${window.location.search}`;
+}
+
+function ViewLoading() {
+	return (
+		<PageFrame>
+			<p className="text-sm text-muted-foreground">Loading...</p>
+		</PageFrame>
+	);
+}
+
+function formatRelativeTime(timestamp?: number): string {
+	if (!timestamp) return "unknown";
+	const elapsed = Math.max(0, Date.now() - timestamp);
+	const minutes = Math.floor(elapsed / 60_000);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+
+function shortId(id: string): string {
+	return id.length > 12 ? id.slice(0, 12) : id;
+}
+
+function workspaceName(path?: string): string | undefined {
+	const trimmed = path?.trim();
+	if (!trimmed) return undefined;
+	const parts = trimmed.split(/[\\/]+/).filter(Boolean);
+	return parts.at(-1) ?? trimmed;
+}
+
+function formatCompactNumber(value?: number): string | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	return new Intl.NumberFormat(undefined, {
+		notation: "compact",
+		maximumFractionDigits: 1,
+	}).format(value);
+}
+
+function formatCost(value?: number): string | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	return new Intl.NumberFormat(undefined, {
+		style: "currency",
+		currency: "USD",
+		minimumFractionDigits: value > 0 && value < 0.01 ? 4 : 2,
+		maximumFractionDigits: value > 0 && value < 0.01 ? 4 : 2,
+	}).format(value);
+}
+
+function statusTone(status?: string): string {
+	const normalized = status?.toLowerCase();
+	if (
+		normalized === "running" ||
+		normalized === "completed" ||
+		normalized === "idle"
+	)
+		return "bg-emerald-300";
+	if (normalized === "failed") return "bg-destructive";
+	return "bg-muted-foreground";
+}
+
+function clientLabel(client: WebviewConnectedClient): string {
+	return (
+		client.displayName?.trim() || client.clientType || shortId(client.clientId)
+	);
+}
+
+function connectorLabel(connector: WebviewActiveConnector): string {
+	if (connector.botUsername) {
+		return `@${connector.botUsername}`;
+	}
+	if (connector.userName) {
+		return connector.userName;
+	}
+	if (connector.applicationId) {
+		return connector.applicationId;
+	}
+	return shortId(connector.id);
+}
+
+function formatSessionModel(session: WebviewSessionSummary): string {
+	if (session.providerId && session.model) {
+		return `${session.providerId}:${session.model}`;
+	}
+	return session.model ?? session.providerId ?? "No model";
+}
+
+function sessionFilterDetails(session: WebviewSessionSummary): string[] {
+	const name = workspaceName(session.workspaceRoot);
+	return [
+		name ? `workspace:${name}` : undefined,
+		session.status ? `status:${session.status}` : undefined,
+		session.providerId ? `provider:${session.providerId}` : undefined,
+		session.model ? `model:${session.model}` : undefined,
+		session.source ? `source:${session.source}` : undefined,
+	].filter((detail): detail is string => Boolean(detail));
+}
+
+function Shell({
+	children,
+	onNavigate,
+	version,
+	view,
+}: {
+	children: ReactNode;
+	onNavigate: (view: View) => void;
+	version?: string;
+	view: View;
+}) {
+	const navItems = [
+		{ view: "home", label: "Home", icon: HomeIcon },
+		{ view: "sessions", label: "Sessions", icon: MessageSquareIcon },
+		{ view: "models", label: "Models", icon: BotIcon },
+		{ view: "channels", label: "Channels", icon: LinkIcon },
+		{ view: "schedules", label: "Schedules", icon: ClockIcon },
+		{ view: "account", label: "Account", icon: UserCircleIcon },
+		{ view: "settings", label: "Settings", icon: SettingsIcon },
+	] satisfies Array<{
+		view: Exclude<
+			View,
+			| "chat"
+			| "rules"
+			| "hooks"
+			| "mcp"
+			| "plugins"
+			| "skills"
+			| "agents"
+			| "tools"
+		>;
+		label: string;
+		icon: typeof HomeIcon;
+	}>;
+	const customizationNavItems = [
+		{ view: "plugins", label: "Plugins", icon: PlugIcon },
+		{ view: "skills", label: "Skills", icon: ActivityIcon },
+		{ view: "mcp", label: "MCP", icon: ServerIcon },
+		{ view: "hooks", label: "Hooks", icon: CodeIcon },
+		{ view: "rules", label: "Rules", icon: FileTextIcon },
+		{ view: "agents", label: "Agents", icon: BotIcon },
+		{ view: "tools", label: "Tools", icon: WrenchIcon },
+	] satisfies Array<{
+		view: Extract<
+			View,
+			"rules" | "hooks" | "mcp" | "plugins" | "skills" | "agents" | "tools"
+		>;
+		label: string;
+		icon: typeof HomeIcon;
+	}>;
+
+	const renderNavButton = (
+		item: (typeof navItems | typeof customizationNavItems)[number],
+	) => {
+		const Icon = item.icon;
+		const active =
+			view === item.view || (item.view === "sessions" && view === "chat");
+		return (
+			<button
+				className={`flex h-8 min-w-0 items-center gap-2 rounded-md px-2 text-left text-[15px] font-medium outline-none transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-sidebar ${
+					active
+						? "bg-sidebar-accent text-sidebar-accent-foreground"
+						: "text-sidebar-foreground hover:bg-sidebar-accent/70 hover:text-sidebar-accent-foreground"
+				}`}
+				key={item.view}
+				onClick={() => onNavigate(item.view)}
+				type="button"
+			>
+				<Icon className="size-4 shrink-0" />
+				<span className="truncate">{item.label}</span>
+			</button>
+		);
+	};
+
+	return (
+		<div className="grid h-screen min-h-screen grid-cols-[14.5rem_minmax(0,1fr)] bg-background text-foreground max-[720px]:grid-cols-1 max-[720px]:grid-rows-[auto_minmax(0,1fr)]">
+			<aside className="flex min-h-0 flex-col border-r bg-sidebar p-4 text-sidebar-foreground max-[720px]:border-b max-[720px]:border-r-0 max-[720px]:p-3">
+				<button
+					className="mb-5 flex min-w-0 items-center gap-2 rounded-md px-0 py-1 text-left text-lg font-semibold outline-none transition-colors hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-sidebar max-[720px]:mb-2"
+					onClick={() => onNavigate("home")}
+					type="button"
+				>
+					<img
+						alt=""
+						className="size-6 shrink-0 dark:invert"
+						src="/cline-logo-filled.svg"
+					/>
+					<span className="truncate">Cline Hub</span>
+				</button>
+				<nav
+					className="grid gap-1 overflow-y-auto max-[720px]:grid-flow-col max-[720px]:auto-cols-max max-[720px]:overflow-x-auto max-[720px]:[scrollbar-width:none] max-[720px]:[&::-webkit-scrollbar]:hidden"
+					aria-label="Hub views"
+				>
+					{navItems.map(renderNavButton)}
+					<div className="mt-4 px-2 text-xs font-semibold uppercase tracking-[0.14em] text-muted-foreground max-[720px]:mt-0 max-[720px]:self-center">
+						Customizations
+					</div>
+					{customizationNavItems.map(renderNavButton)}
+				</nav>
+				<div className="mt-auto pt-6 max-[720px]:mt-2 max-[720px]:pt-0">
+					<div className="flex min-w-0 items-center gap-2 px-2 text-xs text-muted-foreground">
+						<span className="shrink-0">{version ? `v${version}` : "v-"}</span>
+						<span className="shrink-0 text-border">|</span>
+						<a
+							className="truncate underline-offset-2 transition-colors hover:text-foreground hover:underline"
+							href="https://github.com/cline/cline/issues/new"
+							rel="noopener noreferrer"
+							target="_blank"
+						>
+							Report issue
+						</a>
+					</div>
+				</div>
+			</aside>
+			<main className="min-h-0 overflow-hidden bg-background [&>.h-screen]:h-full">
+				{children}
+			</main>
+		</div>
+	);
+}
+
+function HomeView({
+	hubState,
+	onOpenSession,
+	onRestartHub,
+	onViewSessions,
+	restartPending,
+	recentSessions,
+}: {
+	hubState: WebviewHubState;
+	onOpenSession: (sessionId: string) => void;
+	onRestartHub: () => void;
+	onViewSessions: () => void;
+	restartPending: boolean;
+	recentSessions: WebviewSessionSummary[];
+}) {
+	const activeSessions = hubState.sessionSummaries ?? [];
+	const connectedClients = hubState.clients ?? [];
+	const connectedConnectors = hubState.connectors ?? [];
+	const latestEvents = hubState.events.slice(0, 3);
+	const sessionPreview = (
+		recentSessions.length > 0 ? recentSessions : activeSessions
+	).slice(0, 2);
+	const [restartDialogOpen, setRestartDialogOpen] = useState(false);
+
+	const copyText = useCallback((value?: string) => {
+		if (!value || typeof navigator === "undefined") return;
+		void navigator.clipboard?.writeText(value);
+	}, []);
+
+	const confirmRestartHub = () => {
+		setRestartDialogOpen(false);
+		onRestartHub();
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				title="Cline Hub"
+				description="Monitor connected clients, sessions, and hub activity."
+				className="mb-10"
+				actions={
+					<>
+						<div
+							className="inline-flex h-7 items-center gap-1.5 rounded border bg-background px-2 text-xs text-muted-foreground"
+							title="Hub uptime"
+						>
+							<ClockIcon className="size-3.5" />
+							Uptime {hubState.hubUptime ?? "0m"}
+						</div>
+						<button
+							aria-label="Copy hub URL"
+							className="inline-flex h-7 min-w-0 max-w-64 items-center gap-1.5 rounded border bg-background px-2 text-xs text-muted-foreground transition-colors hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
+							disabled={!hubState.hubUrl}
+							onClick={() => copyText(hubState.hubUrl)}
+							title="Copy hub URL"
+							type="button"
+						>
+							<LinkIcon className="size-3.5 shrink-0" />
+							<span
+								className="min-w-0 truncate"
+								title={hubState.hubUrl ?? "No hub URL"}
+							>
+								{hubState.hubUrl ?? "no hub url"}
+							</span>
+						</button>
+						<Button
+							disabled={!hubState.connected || restartPending}
+							onClick={() => setRestartDialogOpen(true)}
+							size="sm"
+							title="Restart Cline Hub"
+							type="button"
+							variant="outline"
+							className="h-7 rounded px-2 text-xs"
+						>
+							<RotateCcwIcon
+								className={`size-3.5 ${restartPending ? "animate-spin" : ""}`}
+							/>
+							<span>{restartPending ? "Restarting" : "Restart"}</span>
+						</Button>
+					</>
+				}
+			/>
+			<AlertDialog
+				open={restartDialogOpen}
+				onOpenChange={(open) => {
+					if (!restartPending) {
+						setRestartDialogOpen(open);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Restart Cline Hub</AlertDialogTitle>
+						<AlertDialogDescription>
+							This will shut down the current hub process and start it again.
+							Connected clients and active sessions may disconnect while the hub
+							restarts.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={restartPending}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={!hubState.connected || restartPending}
+							onClick={confirmRestartHub}
+							variant="destructive"
+						>
+							<RotateCcwIcon
+								className={`size-4 ${restartPending ? "animate-spin" : ""}`}
+							/>
+							<span>{restartPending ? "Restarting" : "Restart Hub"}</span>
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+
+			<div className="grid max-w-[86rem] grid-cols-2 gap-6 max-[1100px]:grid-cols-1">
+				<section
+					id="connected-clients-section"
+					className="overflow-hidden rounded-lg border bg-card"
+				>
+					<div className="flex h-11 items-center justify-between gap-3 border-b bg-muted/40 px-4">
+						<h2 className="text-[17px] font-medium text-muted-foreground">
+							Connected clients
+						</h2>
+						<span className="text-sm text-muted-foreground">
+							{connectedClients.length + connectedConnectors.length}
+						</span>
+					</div>
+					<div className="min-h-46">
+						{connectedClients.length === 0 &&
+						connectedConnectors.length === 0 ? (
+							<p className="px-4 py-5 text-[15px] text-muted-foreground">
+								No connected clients.
+							</p>
+						) : null}
+						{connectedClients.map((client) => (
+							<div
+								className="flex min-h-18 items-center justify-between gap-4 border-b px-4 py-3 last:border-b-0"
+								key={client.clientId}
+							>
+								<div className="flex min-w-0 items-start gap-3">
+									<MessageSquareIcon className="mt-0.5 size-4 shrink-0 text-muted-foreground" />
+									<div className="min-w-0">
+										<p className="truncate text-[15px] font-semibold">
+											{clientLabel(client)}
+										</p>
+										<p className="mt-1 truncate text-[13px] text-muted-foreground">
+											{client.clientType}
+										</p>
+									</div>
+								</div>
+								<time className="shrink-0 text-sm text-muted-foreground">
+									{formatRelativeTime(client.connectedAt)}
+								</time>
+							</div>
+						))}
+						{connectedConnectors.map((connector) => (
+							<div
+								className="flex min-h-18 items-center justify-between gap-4 border-b px-4 py-3 last:border-b-0"
+								key={connector.id}
+							>
+								<div className="flex min-w-0 items-start gap-3">
+									<ServerIcon className="mt-0.5 size-4 shrink-0 text-muted-foreground" />
+									<div className="min-w-0">
+										<p className="truncate text-[15px] font-semibold">
+											{connector.type.toUpperCase()}
+										</p>
+										<p className="mt-1 truncate text-[13px] text-muted-foreground">
+											{connectorLabel(connector)}
+										</p>
+									</div>
+								</div>
+								<span className="shrink-0 text-sm text-muted-foreground">
+									Channel
+								</span>
+							</div>
+						))}
+					</div>
+				</section>
+
+				<section className="overflow-hidden rounded-lg border bg-card">
+					<div className="flex h-11 items-center justify-between gap-3 border-b bg-muted/40 px-4">
+						<h2 className="text-[17px] font-medium text-muted-foreground">
+							Sessions
+						</h2>
+						<span className="inline-flex items-center gap-2 text-sm text-muted-foreground">
+							<span className="size-1.5 rounded-full bg-emerald-500" />
+							{activeSessions.length} active
+						</span>
+					</div>
+					<div className="min-h-46">
+						{sessionPreview.length === 0 ? (
+							<p className="px-4 py-5 text-[15px] text-muted-foreground">
+								No sessions yet.
+							</p>
+						) : null}
+						{sessionPreview.map((session) => (
+							<button
+								className="flex min-h-19 w-full items-center justify-between gap-4 border-b px-4 py-3 text-left transition-colors hover:bg-accent/40"
+								key={session.sessionId}
+								onClick={() => onOpenSession(session.sessionId)}
+								type="button"
+							>
+								<div className="min-w-0">
+									<div className="flex items-center gap-2">
+										<span
+											className={`size-1.5 shrink-0 rounded-full ${statusTone(session.status)}`}
+										/>
+										<p className="truncate text-[15px] font-semibold">
+											{session.title || shortId(session.sessionId)}
+										</p>
+									</div>
+									<div className="mt-2 flex min-w-0 items-center gap-2 pl-3.5 text-[13px] text-muted-foreground">
+										<Folder className="size-3.5 shrink-0" />
+										<span className="truncate">
+											{session.workspaceRoot ?? "No workspace"}
+										</span>
+										<span className="shrink-0 rounded-full border bg-background px-2 py-0.5 text-xs">
+											{formatSessionModel(session)}
+										</span>
+									</div>
+								</div>
+								<time className="shrink-0 text-sm text-muted-foreground">
+									{formatRelativeTime(session.updatedAt)}
+								</time>
+							</button>
+						))}
+						<button
+							className="flex h-9 w-full items-center justify-center border-t text-sm text-muted-foreground transition-colors hover:bg-accent/50 hover:text-foreground"
+							onClick={onViewSessions}
+							type="button"
+						>
+							View all
+						</button>
+					</div>
+				</section>
+
+				<section className="overflow-hidden rounded-lg border bg-card">
+					<div className="flex h-11 items-center justify-between gap-3 border-b bg-muted/40 px-4">
+						<h2 className="text-[17px] font-medium text-muted-foreground">
+							Recent events
+						</h2>
+					</div>
+					<div className="min-h-46">
+						{latestEvents.length === 0 ? (
+							<p className="px-4 py-5 text-[15px] text-muted-foreground">
+								No hub events yet.
+							</p>
+						) : null}
+						{latestEvents.map((event) => (
+							<EventRow event={event} key={event.id} />
+						))}
+					</div>
+				</section>
+			</div>
+		</PageFrame>
+	);
+}
+
+function SessionsView({
+	onDeleteSession,
+	onOpenSession,
+	onRenameSession,
+	sessions,
+}: {
+	onDeleteSession: (sessionId: string) => Promise<void> | void;
+	onOpenSession: (sessionId: string) => void;
+	onRenameSession: (sessionId: string, title: string) => Promise<void> | void;
+	sessions: WebviewSessionSummary[];
+}) {
+	const [sessionFilters, setSessionFilters] = useState<string[]>([]);
+	const [editingSessionId, setEditingSessionId] = useState<string | null>(null);
+	const [editingTitle, setEditingTitle] = useState("");
+	const [deleteSessionCandidate, setDeleteSessionCandidate] =
+		useState<WebviewSessionSummary | null>(null);
+	const [sortDirection, setSortDirection] = useState<"newest" | "oldest">(
+		"newest",
+	);
+	const runDetailFilterOptions = useMemo(
+		() =>
+			Array.from(
+				new Set(sessions.flatMap((session) => sessionFilterDetails(session))),
+			).sort((a, b) => a.localeCompare(b)),
+		[sessions],
+	);
+	const filteredSessions = useMemo(() => {
+		const selected = new Set(sessionFilters);
+		const filtered =
+			sessionFilters.length === 0
+				? sessions
+				: sessions.filter((session) =>
+						sessionFilterDetails(session).some((detail) =>
+							selected.has(detail),
+						),
+					);
+		return [...filtered].sort((a, b) => {
+			const aTime = a.createdAt ?? a.updatedAt ?? 0;
+			const bTime = b.createdAt ?? b.updatedAt ?? 0;
+			return sortDirection === "newest" ? bTime - aTime : aTime - bTime;
+		});
+	}, [sessions, sessionFilters, sortDirection]);
+
+	const startRenameSession = (session: WebviewSessionSummary) => {
+		setEditingSessionId(session.sessionId);
+		setEditingTitle(session.title || shortId(session.sessionId));
+	};
+
+	const cancelRenameSession = () => {
+		setEditingSessionId(null);
+		setEditingTitle("");
+	};
+
+	const submitRenameSession = (session: WebviewSessionSummary) => {
+		const currentTitle = session.title || shortId(session.sessionId);
+		const nextTitle = editingTitle.trim();
+		if (!nextTitle || nextTitle === currentTitle) {
+			cancelRenameSession();
+			return;
+		}
+		void onRenameSession(session.sessionId, nextTitle);
+		cancelRenameSession();
+	};
+
+	const confirmDeleteSession = () => {
+		if (!deleteSessionCandidate) return;
+		void onDeleteSession(deleteSessionCandidate.sessionId);
+		setDeleteSessionCandidate(null);
+	};
+
+	const toggleSessionFilter = (detail: string, checked: boolean) => {
+		setSessionFilters((prev) => {
+			if (checked) {
+				return prev.includes(detail) ? prev : [...prev, detail];
+			}
+			return prev.filter((item) => item !== detail);
+		});
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				title="Sessions"
+				description="Review, reopen, rename, and delete recent sessions."
+				actions={
+					<>
+						<DropdownMenu>
+							<DropdownMenuTrigger
+								render={
+									<Button
+										title="Sort sessions"
+										aria-label="Sort sessions"
+										size="icon-sm"
+										type="button"
+										variant="secondary"
+										className="size-8 rounded-md"
+									/>
+								}
+							>
+								<ArrowUpDownIcon className="size-4" />
+							</DropdownMenuTrigger>
+							<DropdownMenuContent align="end" sideOffset={6}>
+								<DropdownMenuItem onClick={() => setSortDirection("newest")}>
+									{sortDirection === "newest"
+										? "Newest first ✓"
+										: "Newest first"}
+								</DropdownMenuItem>
+								<DropdownMenuItem onClick={() => setSortDirection("oldest")}>
+									{sortDirection === "oldest"
+										? "Oldest first ✓"
+										: "Oldest first"}
+								</DropdownMenuItem>
+							</DropdownMenuContent>
+						</DropdownMenu>
+						<DropdownMenu>
+							<DropdownMenuTrigger
+								render={
+									<Button
+										title="Filter sessions"
+										aria-label="Filter sessions"
+										size="icon-sm"
+										type="button"
+										variant={
+											sessionFilters.length > 0 ? "default" : "secondary"
+										}
+										className="size-8 rounded-md"
+									/>
+								}
+							>
+								<FunnelIcon className="size-4" />
+							</DropdownMenuTrigger>
+							<DropdownMenuContent align="end" className="max-h-72 w-72">
+								<DropdownMenuGroup>
+									<DropdownMenuLabel>Filter sessions</DropdownMenuLabel>
+									{sessionFilters.length > 0 ? (
+										<>
+											<DropdownMenuItem onClick={() => setSessionFilters([])}>
+												Clear filters
+											</DropdownMenuItem>
+											<DropdownMenuSeparator />
+										</>
+									) : null}
+									{runDetailFilterOptions.length === 0 ? (
+										<DropdownMenuItem disabled>No run details</DropdownMenuItem>
+									) : (
+										runDetailFilterOptions.map((detail) => (
+											<DropdownMenuCheckboxItem
+												checked={sessionFilters.includes(detail)}
+												key={detail}
+												onCheckedChange={(checked: boolean) =>
+													toggleSessionFilter(detail, checked)
+												}
+											>
+												<span className="truncate" title={detail}>
+													{detail}
+												</span>
+											</DropdownMenuCheckboxItem>
+										))
+									)}
+								</DropdownMenuGroup>
+							</DropdownMenuContent>
+						</DropdownMenu>
+					</>
+				}
+			/>
+
+			<section className="w-full min-w-0 overflow-x-auto">
+				<div className="grid w-full min-w-[56rem] grid-cols-[minmax(12rem,1.35fr)_minmax(7rem,0.85fr)_minmax(10rem,1.1fr)_5rem_5rem_4.5rem_5.5rem_2rem] gap-x-4 bg-muted/40 px-4 py-3 text-[15px] font-medium text-muted-foreground">
+					<span>Session title</span>
+					<span>Directory</span>
+					<span>Model</span>
+					<span>Tokens in</span>
+					<span>Tokens out</span>
+					<span>Cost</span>
+					<span>Created</span>
+					<span />
+				</div>
+				<div className="w-full min-w-[56rem]">
+					{filteredSessions.length === 0 ? (
+						<div className="border-b px-4 py-8 text-[15px] text-muted-foreground">
+							{sessions.length === 0
+								? "No sessions yet."
+								: "No sessions match the selected filters."}
+						</div>
+					) : null}
+					{filteredSessions.map((session) => {
+						const isEditing = editingSessionId === session.sessionId;
+						const title = session.title || shortId(session.sessionId);
+						return (
+							<div
+								className="grid min-h-14 w-full grid-cols-[minmax(12rem,1.35fr)_minmax(7rem,0.85fr)_minmax(10rem,1.1fr)_5rem_5rem_4.5rem_5.5rem_2rem] items-center gap-x-4 border-b px-4 py-3 text-left text-[15px] transition-colors hover:bg-accent/40"
+								key={session.sessionId}
+							>
+								{isEditing ? (
+									<form
+										className="col-span-7 grid grid-cols-[minmax(12rem,1.35fr)_minmax(7rem,0.85fr)_minmax(10rem,1.1fr)_5rem_5rem_4.5rem_5.5rem] items-center gap-x-4"
+										onSubmit={(event) => {
+											event.preventDefault();
+											submitRenameSession(session);
+										}}
+									>
+										<div className="col-span-2 flex min-w-0 items-center gap-2">
+											<Input
+												aria-label={`Rename ${title}`}
+												autoFocus
+												className="h-8"
+												onChange={(event) =>
+													setEditingTitle(event.target.value)
+												}
+												onKeyDown={(event) => {
+													if (event.key === "Escape") {
+														event.preventDefault();
+														cancelRenameSession();
+													}
+												}}
+												value={editingTitle}
+											/>
+											<Button
+												className="h-8 rounded-md px-2.5 text-xs"
+												disabled={!editingTitle.trim()}
+												type="submit"
+												variant="default"
+											>
+												Save
+											</Button>
+											<Button
+												className="h-8 rounded-md px-2.5 text-xs"
+												onClick={cancelRenameSession}
+												type="button"
+												variant="outline"
+											>
+												Cancel
+											</Button>
+										</div>
+										<span className="truncate text-muted-foreground">
+											{formatSessionModel(session)}
+										</span>
+										<span className="text-muted-foreground">
+											{formatCompactNumber(session.inputTokens) ?? "-"}
+										</span>
+										<span className="text-muted-foreground">
+											{formatCompactNumber(session.outputTokens) ?? "-"}
+										</span>
+										<span className="text-muted-foreground">
+											{formatCost(session.totalCost) ?? "-"}
+										</span>
+										<span className="text-muted-foreground">
+											{formatRelativeTime(
+												session.createdAt ?? session.updatedAt,
+											)}
+										</span>
+									</form>
+								) : (
+									<button
+										className="col-span-7 grid grid-cols-[minmax(12rem,1.35fr)_minmax(7rem,0.85fr)_minmax(10rem,1.1fr)_5rem_5rem_4.5rem_5.5rem] items-center gap-x-4 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+										onClick={() => onOpenSession(session.sessionId)}
+										type="button"
+									>
+										<span className="flex min-w-0 items-center gap-3 font-semibold">
+											<span
+												className={`size-1.5 shrink-0 rounded-full ${statusTone(session.status)}`}
+											/>
+											<span className="truncate">{title}</span>
+										</span>
+										<span className="truncate text-muted-foreground">
+											{workspaceName(session.workspaceRoot) ?? "No workspace"}
+										</span>
+										<span className="truncate text-muted-foreground">
+											{formatSessionModel(session)}
+										</span>
+										<span className="text-muted-foreground">
+											{formatCompactNumber(session.inputTokens) ?? "-"}
+										</span>
+										<span className="text-muted-foreground">
+											{formatCompactNumber(session.outputTokens) ?? "-"}
+										</span>
+										<span className="text-muted-foreground">
+											{formatCost(session.totalCost) ?? "-"}
+										</span>
+										<span className="text-muted-foreground">
+											{formatRelativeTime(
+												session.createdAt ?? session.updatedAt,
+											)}
+										</span>
+									</button>
+								)}
+								<DropdownMenu>
+									<DropdownMenuTrigger
+										render={
+											<button
+												aria-label={`Session actions for ${title}`}
+												className="grid size-7 place-items-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+												onClick={(event) => event.stopPropagation()}
+												type="button"
+											/>
+										}
+									>
+										<MoreHorizontal className="size-4" />
+									</DropdownMenuTrigger>
+									<DropdownMenuContent align="end" sideOffset={6}>
+										<DropdownMenuItem
+											onClick={(event) => {
+												event.stopPropagation();
+												startRenameSession(session);
+											}}
+										>
+											<PencilIcon className="size-4" />
+											Rename
+										</DropdownMenuItem>
+										<DropdownMenuSeparator />
+										<DropdownMenuItem
+											className="text-destructive"
+											onClick={(event) => {
+												event.stopPropagation();
+												setDeleteSessionCandidate(session);
+											}}
+										>
+											<Trash2Icon className="size-4" />
+											Delete
+										</DropdownMenuItem>
+									</DropdownMenuContent>
+								</DropdownMenu>
+							</div>
+						);
+					})}
+				</div>
+			</section>
+			<AlertDialog
+				open={deleteSessionCandidate !== null}
+				onOpenChange={(open) => {
+					if (!open) {
+						setDeleteSessionCandidate(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete session</AlertDialogTitle>
+						<AlertDialogDescription>
+							Delete{" "}
+							<span className="font-medium text-foreground">
+								{deleteSessionCandidate?.title ||
+									(deleteSessionCandidate
+										? shortId(deleteSessionCandidate.sessionId)
+										: "this session")}
+							</span>
+							? This removes it from recent sessions.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel>Cancel</AlertDialogCancel>
+						<AlertDialogAction
+							onClick={confirmDeleteSession}
+							variant="destructive"
+						>
+							Delete
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</PageFrame>
+	);
+}
+
+function EventRow({ event }: { event: WebviewHubEvent }) {
+	return (
+		<div className="flex min-h-18 items-start justify-between gap-4 border-b px-4 py-3 last:border-b-0">
+			<div className="flex min-w-0 items-start gap-3">
+				<RssIcon className="mt-0.5 size-4 shrink-0 text-muted-foreground" />
+				<div className="min-w-0">
+					<p className="truncate text-[15px] font-semibold">{event.title}</p>
+					<p className="mt-1 truncate text-[13px] text-muted-foreground">
+						{event.body}
+					</p>
+				</div>
+			</div>
+			<time className="shrink-0 whitespace-nowrap text-sm text-muted-foreground">
+				{formatRelativeTime(event.timestamp)}
+			</time>
+		</div>
+	);
+}
+
+function App() {
+	const [view, setView] = useState<View>(() => readCurrentView());
+	const [settingsSection, setSettingsSection] = useState<SettingsSection>(() =>
+		readCurrentSettingsSection(),
+	);
+	const [hubState, setHubState] = useState<WebviewHubState>(EMPTY_HUB_STATE);
+	const [restartPending, setRestartPending] = useState(false);
+	const [selectedSessionId, setSelectedSessionId] = useState<
+		string | undefined
+	>(() => readCurrentChatSessionId());
+	const [recentSessions, setRecentSessions] = useState<WebviewSessionSummary[]>(
+		[],
+	);
+
+	useEffect(() => {
+		syncHubTheme();
+		replaceLegacyCustomizationRoute();
+	}, []);
+
+	useEffect(() => {
+		const handlePopState = () => {
+			replaceLegacyCustomizationRoute();
+			const nextView = readCurrentView();
+			setView(nextView);
+			setSelectedSessionId(
+				nextView === "chat" ? readCurrentChatSessionId() : undefined,
+			);
+			setSettingsSection(readCurrentSettingsSection());
+		};
+		window.addEventListener("popstate", handlePopState);
+		return () => window.removeEventListener("popstate", handlePopState);
+	}, []);
+
+	useEffect(() => {
+		const handleMessage = (event: MessageEvent<WebviewOutboundMessage>) => {
+			const message = event.data;
+			if (!message || typeof message !== "object") {
+				return;
+			}
+			if (message.type === "hub_state") {
+				setHubState(message);
+				if (message.connected) {
+					setRestartPending(false);
+				}
+				return;
+			}
+			if (message.type === "sessions") {
+				setRecentSessions(message.sessions);
+			}
+		};
+		window.addEventListener("message", handleMessage);
+		postToHost({ type: "ready" });
+		return () => window.removeEventListener("message", handleMessage);
+	}, []);
+
+	const restartHub = useCallback(() => {
+		setRestartPending(true);
+		postToHost({ type: "restart_hub" });
+	}, []);
+
+	const navigate = useCallback((nextView: View) => {
+		if (nextView === "chat") {
+			setSelectedSessionId(undefined);
+		}
+		if (nextView === "settings") {
+			setSettingsSection("General");
+		}
+		if (nextView !== "chat") {
+			setSelectedSessionId(undefined);
+		}
+		const nextPath = routePath(VIEW_PATHS[nextView]);
+		if (currentPathWithSearch() !== nextPath) {
+			window.history.pushState(null, "", nextPath);
+		}
+		setView(nextView);
+	}, []);
+
+	const openSession = useCallback((sessionId: string) => {
+		setSelectedSessionId(sessionId);
+		const nextPath = chatPath(sessionId);
+		if (currentPathWithSearch() !== nextPath) {
+			window.history.pushState(null, "", nextPath);
+		}
+		setView("chat");
+	}, []);
+
+	const updateChatSessionRoute = useCallback((sessionId?: string) => {
+		setSelectedSessionId(sessionId);
+		const nextPath = chatPath(sessionId);
+		if (currentPathWithSearch() !== nextPath) {
+			window.history.replaceState(null, "", nextPath);
+		}
+	}, []);
+
+	const deleteSession = useCallback((sessionId: string) => {
+		setRecentSessions((current) =>
+			current.filter((session) => session.sessionId !== sessionId),
+		);
+		postToHost({ type: "deleteSession", sessionId });
+	}, []);
+
+	const renameSession = useCallback((sessionId: string, title: string) => {
+		setRecentSessions((current) =>
+			current.map((session) =>
+				session.sessionId === sessionId ? { ...session, title } : session,
+			),
+		);
+		postToHost({
+			type: "updateSessionMetadata",
+			sessionId,
+			metadata: { title },
+		});
+	}, []);
+
+	const content = useMemo(() => {
+		if (view === "chat") {
+			return (
+				<Chat
+					initialSessionId={selectedSessionId}
+					onSessionSelected={updateChatSessionRoute}
+				/>
+			);
+		}
+		if (view === "sessions") {
+			return (
+				<SessionsView
+					onDeleteSession={deleteSession}
+					onOpenSession={openSession}
+					onRenameSession={renameSession}
+					sessions={recentSessions}
+				/>
+			);
+		}
+		if (view === "settings") {
+			return (
+				<SettingsView
+					initialSection={settingsSection}
+					key={settingsSection}
+					chrome="content"
+					onClose={() => navigate("home")}
+				/>
+			);
+		}
+		if (view === "account") {
+			return (
+				<SettingsView
+					chrome="content"
+					initialSection="Account"
+					key="account"
+					onClose={() => navigate("home")}
+				/>
+			);
+		}
+		if (view === "models") {
+			return (
+				<SettingsView
+					chrome="content"
+					initialSection="Providers"
+					key="models"
+					onClose={() => navigate("home")}
+				/>
+			);
+		}
+		if (view === "channels") {
+			return (
+				<SettingsView
+					chrome="content"
+					initialSection="Channels"
+					key="channels"
+					onClose={() => navigate("home")}
+				/>
+			);
+		}
+		if (view === "schedules") {
+			return (
+				<SettingsView
+					chrome="content"
+					initialSection="Schedules"
+					key="schedules"
+					onClose={() => navigate("home")}
+				/>
+			);
+		}
+		if (view === "mcp") {
+			return (
+				<CustomizationSectionView
+					catalogPrimitive="mcp"
+					key={view}
+					section={CUSTOMIZATION_VIEW_SECTIONS[view]}
+				/>
+			);
+		}
+		if (view === "skills" || view === "plugins") {
+			return (
+				<CustomizationSectionView
+					catalogPrimitive={view === "skills" ? "skill" : "plugin"}
+					key={view}
+					section={CUSTOMIZATION_VIEW_SECTIONS[view]}
+				/>
+			);
+		}
+		if (
+			view === "rules" ||
+			view === "hooks" ||
+			view === "agents" ||
+			view === "tools"
+		) {
+			return (
+				<CustomizationSectionView
+					key={view}
+					section={CUSTOMIZATION_VIEW_SECTIONS[view]}
+				/>
+			);
+		}
+		return (
+			<HomeView
+				hubState={hubState}
+				onOpenSession={openSession}
+				onRestartHub={restartHub}
+				onViewSessions={() => navigate("sessions")}
+				recentSessions={recentSessions}
+				restartPending={restartPending}
+			/>
+		);
+	}, [
+		hubState,
+		deleteSession,
+		navigate,
+		openSession,
+		recentSessions,
+		renameSession,
+		restartHub,
+		restartPending,
+		selectedSessionId,
+		settingsSection,
+		updateChatSessionRoute,
+		view,
+	]);
+
+	return (
+		<Shell onNavigate={navigate} version={hubState.coreVersion} view={view}>
+			<Suspense fallback={<ViewLoading />}>{content}</Suspense>
+		</Shell>
+	);
+}
+
+export default App;
diff --git a/apps/cline-hub/src/webview/src/Chat.tsx b/apps/cline-hub/src/webview/src/Chat.tsx
new file mode 100644
index 0000000..2e64ce4
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/Chat.tsx
@@ -0,0 +1,1454 @@
+"use client";
+
+import {
+	CheckIcon,
+	GitBranchIcon,
+	Loader2Icon,
+	PlusIcon,
+	Trash2Icon,
+	XIcon,
+} from "lucide-react";
+import { nanoid } from "nanoid";
+import {
+	type MutableRefObject,
+	type ReactElement,
+	useCallback,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	Checkpoint,
+	CheckpointIcon,
+	CheckpointTrigger,
+} from "@/components/ai-elements/checkpoint";
+import {
+	Conversation,
+	ConversationContent,
+	ConversationScrollButton,
+} from "@/components/ai-elements/conversation";
+import {
+	Message,
+	MessageContent,
+	MessageResponse,
+} from "@/components/ai-elements/message";
+import { PromptInputProvider } from "@/components/ai-elements/prompt-input";
+import {
+	Reasoning,
+	ReasoningContent,
+	ReasoningTrigger,
+} from "@/components/ai-elements/reasoning";
+import {
+	Tool,
+	ToolContent,
+	ToolHeader,
+	ToolOutput,
+} from "@/components/ai-elements/tool";
+import TeamTasks, { type TeamToolEvent } from "@/components/TeamTasks";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+import type {
+	WebviewChatAttachments,
+	WebviewChatMessage,
+	WebviewChatMessageBlock,
+	WebviewDefaults,
+	WebviewOutboundMessage,
+	WebviewProviderModel,
+	WebviewReasonLevel,
+	WebviewSessionSummary,
+	WebviewToolEvent,
+} from "../../webview-protocol";
+import { Composer } from "./components/Composer";
+import { getVsCodeApi, postToHost } from "./vscode";
+
+type ChatMessage = WebviewChatMessage;
+type ChatMessageBlock = WebviewChatMessageBlock;
+type ToolEvent = NonNullable<WebviewChatMessage["toolEvents"]>[number];
+type ProviderOption = Extract<
+	WebviewOutboundMessage,
+	{ type: "providers" }
+>["providers"][number];
+type PendingApproval = Extract<
+	WebviewOutboundMessage,
+	{ type: "approval_request" }
+> & { responding?: boolean };
+type ModelSelectionStorage = {
+	lastProvider: string;
+	lastModelByProvider: Record<string, string>;
+};
+
+const EMPTY_SELECTION: ModelSelectionStorage = {
+	lastProvider: "",
+	lastModelByProvider: {},
+};
+
+function readModelSelection(): ModelSelectionStorage {
+	try {
+		const state = getVsCodeApi()?.getState() as
+			| { modelSelection?: ModelSelectionStorage }
+			| undefined;
+		if (state?.modelSelection) {
+			return state.modelSelection;
+		}
+	} catch {
+		// ignore persisted state issues in the webview
+	}
+	return EMPTY_SELECTION;
+}
+
+function writeModelSelection(selection: ModelSelectionStorage): void {
+	try {
+		const api = getVsCodeApi();
+		if (!api) {
+			return;
+		}
+		const state = (api.getState() as Record<string, unknown>) ?? {};
+		api.setState({ ...state, modelSelection: selection });
+	} catch {
+		// ignore persisted state issues in the webview
+	}
+}
+
+function parseMaxIterations(value: string): number | undefined {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function createMessage(
+	role: ChatMessage["role"],
+	text: string,
+	extra?: Partial<ChatMessage>,
+): ChatMessage {
+	return {
+		id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+		role,
+		text,
+		...extra,
+	};
+}
+
+function buildUserMessageLabel(
+	prompt: string,
+	attachments?: WebviewChatAttachments,
+	attachmentCount = 0,
+): string {
+	const resolvedCount =
+		attachmentCount || (attachments?.userImages?.length ?? 0);
+	if (resolvedCount === 0) {
+		return prompt;
+	}
+	return `${prompt}${prompt.length > 0 ? "\n\n" : ""}[attached ${resolvedCount} file${resolvedCount === 1 ? "" : "s"}]`;
+}
+
+function formatApprovalInput(input: unknown): string {
+	if (typeof input === "string") return input;
+	try {
+		return JSON.stringify(input ?? null, null, 2);
+	} catch {
+		return String(input);
+	}
+}
+
+function appendAssistantDelta(
+	current: ChatMessage[],
+	text: string,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	if (!text) {
+		return current;
+	}
+
+	const activeAssistantId = activeAssistantIdRef.current;
+	if (activeAssistantId) {
+		const targetIndex = current.findIndex(
+			(message) => message.id === activeAssistantId,
+		);
+		if (targetIndex >= 0) {
+			return current.map((message, index) =>
+				index === targetIndex
+					? {
+							...message,
+							text: `${message.text}${text}`,
+							blocks: appendTextBlock(message.blocks, text),
+						}
+					: message,
+			);
+		}
+	}
+
+	const lastMessage = current.at(-1);
+	if (lastMessage?.role === "assistant") {
+		activeAssistantIdRef.current = lastMessage.id;
+		return [
+			...current.slice(0, -1),
+			{
+				...lastMessage,
+				text: `${lastMessage.text}${text}`,
+				blocks: appendTextBlock(lastMessage.blocks, text),
+			},
+		];
+	}
+
+	const assistantMessage = createMessage("assistant", text, {
+		blocks: [{ id: nanoid(), type: "text", text }],
+	});
+	activeAssistantIdRef.current = assistantMessage.id;
+	return [...current, assistantMessage];
+}
+
+function appendTextBlock(
+	blocks: ChatMessageBlock[] | undefined,
+	text: string,
+): ChatMessageBlock[] {
+	const current = blocks ?? [];
+	const last = current.at(-1);
+	if (last?.type === "text") {
+		return current.map((block, index) =>
+			index === current.length - 1 && block.type === "text"
+				? { ...block, text: `${block.text}${text}` }
+				: block,
+		);
+	}
+	return [...current, { id: nanoid(), type: "text", text }];
+}
+
+function appendReasoningBlock(
+	blocks: ChatMessageBlock[] | undefined,
+	text: string,
+	redacted?: boolean,
+): ChatMessageBlock[] {
+	const current = blocks ?? [];
+	const last = current.at(-1);
+	if (last?.type === "reasoning") {
+		return current.map((block, index) =>
+			index === current.length - 1 && block.type === "reasoning"
+				? {
+						...block,
+						text: `${block.text}${text}`,
+						redacted: block.redacted || redacted,
+					}
+				: block,
+		);
+	}
+	return [...current, { id: nanoid(), type: "reasoning", text, redacted }];
+}
+
+function upsertToolBlock(
+	blocks: ChatMessageBlock[] | undefined,
+	toolEvent: ToolEvent,
+): ChatMessageBlock[] {
+	const current = blocks ?? [];
+	const existingIndex = current.findIndex(
+		(block) =>
+			block.type === "tool" &&
+			((block.toolEvent.toolCallId &&
+				toolEvent.toolCallId &&
+				block.toolEvent.toolCallId === toolEvent.toolCallId) ||
+				(!block.toolEvent.toolCallId &&
+					!toolEvent.toolCallId &&
+					block.toolEvent.name === toolEvent.name &&
+					block.toolEvent.state === "input-available" &&
+					toolEvent.state !== "input-available")),
+	);
+	if (existingIndex === -1) {
+		return [...current, { id: nanoid(), type: "tool", toolEvent }];
+	}
+	return current.map((block, index) =>
+		index === existingIndex && block.type === "tool"
+			? { ...block, toolEvent: { ...block.toolEvent, ...toolEvent } }
+			: block,
+	);
+}
+
+function appendReasoningDelta(
+	current: ChatMessage[],
+	text: string,
+	redacted: boolean | undefined,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	const reasoningChunk = text || (redacted ? "[redacted]" : "");
+	if (!reasoningChunk) {
+		return current;
+	}
+
+	const activeAssistantId = activeAssistantIdRef.current;
+	if (activeAssistantId) {
+		const targetIndex = current.findIndex(
+			(message) => message.id === activeAssistantId,
+		);
+		if (targetIndex >= 0) {
+			return current.map((message, index) =>
+				index === targetIndex
+					? {
+							...message,
+							reasoning: `${message.reasoning ?? ""}${reasoningChunk}`,
+							reasoningRedacted: message.reasoningRedacted || redacted,
+							blocks: appendReasoningBlock(
+								message.blocks,
+								reasoningChunk,
+								redacted,
+							),
+						}
+					: message,
+			);
+		}
+	}
+
+	const lastMessage = current.at(-1);
+	if (lastMessage?.role === "assistant") {
+		activeAssistantIdRef.current = lastMessage.id;
+		return [
+			...current.slice(0, -1),
+			{
+				...lastMessage,
+				reasoning: `${lastMessage.reasoning ?? ""}${reasoningChunk}`,
+				reasoningRedacted: lastMessage.reasoningRedacted || redacted,
+				blocks: appendReasoningBlock(
+					lastMessage.blocks,
+					reasoningChunk,
+					redacted,
+				),
+			},
+		];
+	}
+
+	const assistantMessage = createMessage("assistant", "", {
+		reasoning: reasoningChunk,
+		reasoningRedacted: redacted,
+		blocks: [
+			{ id: nanoid(), type: "reasoning", text: reasoningChunk, redacted },
+		],
+	});
+	activeAssistantIdRef.current = assistantMessage.id;
+	return [...current, assistantMessage];
+}
+
+type ToolResultEntry = {
+	query?: string;
+	result?: string;
+	success?: boolean;
+};
+
+function isToolResultArray(value: unknown): value is ToolResultEntry[] {
+	return (
+		Array.isArray(value) &&
+		value.length > 0 &&
+		typeof value[0] === "object" &&
+		value[0] !== null &&
+		"result" in value[0]
+	);
+}
+
+type ExpandedToolEvent = {
+	id: string;
+	name: string;
+	title: string;
+	state: ToolEvent["state"];
+	output: string;
+	error?: string;
+};
+
+function formatInputSummary(input: unknown): string {
+	if (input == null) {
+		return "";
+	}
+	if (typeof input === "string") {
+		return input;
+	}
+	if (typeof input === "object") {
+		const values = Object.values(input as Record<string, unknown>);
+		return values
+			.filter((v) => typeof v === "string" || typeof v === "number")
+			.map(String)
+			.join(" ");
+	}
+	return String(input);
+}
+
+function formatRawOutput(output: unknown, fallback: string): string {
+	if (output == null) {
+		return fallback;
+	}
+	if (typeof output === "string") {
+		return output;
+	}
+	return JSON.stringify(output, null, 2);
+}
+
+function expandToolEvent(toolEvent: ToolEvent): ExpandedToolEvent[] {
+	if (isToolResultArray(toolEvent.output)) {
+		return toolEvent.output.map((entry, index) => {
+			const query = entry.query ?? "";
+			const title = query ? `${toolEvent.name}: ${query}` : toolEvent.name;
+			const state: ToolEvent["state"] =
+				entry.success === false ? "output-error" : toolEvent.state;
+			const output =
+				entry.result ?? (entry.success === false ? "(failed)" : "(no output)");
+			const error =
+				entry.success === false ? (entry.result ?? "failed") : undefined;
+			return {
+				id: `${toolEvent.id}-${index}`,
+				name: toolEvent.name,
+				title,
+				state,
+				output,
+				error,
+			};
+		});
+	}
+
+	const inputSummary = formatInputSummary(toolEvent.input);
+	const title = inputSummary
+		? `${toolEvent.name}: ${inputSummary}`
+		: toolEvent.name;
+
+	return [
+		{
+			id: toolEvent.id,
+			name: toolEvent.name,
+			title,
+			state: toolEvent.state,
+			output:
+				toolEvent.error ?? formatRawOutput(toolEvent.output, toolEvent.text),
+			error: toolEvent.error,
+		},
+	];
+}
+
+function extractToolName(text: string): string {
+	const runningMatch = /^Running (.+)\.\.\.$/.exec(text);
+	if (runningMatch?.[1]) {
+		return runningMatch[1];
+	}
+	const terminalMatch = /^(.+?) (completed|failed:.*)$/.exec(text);
+	return terminalMatch?.[1] ?? "tool";
+}
+
+function deriveToolState(text: string): ToolEvent["state"] {
+	if (text.includes("failed:")) {
+		return "output-error";
+	}
+	if (text.endsWith("completed")) {
+		return "output-available";
+	}
+	return "input-available";
+}
+
+function mapToolEventState(
+	event?: WebviewToolEvent,
+	fallbackText?: string,
+): ToolEvent["state"] {
+	if (event?.status === "failed") {
+		return "output-error";
+	}
+	if (event?.status === "completed") {
+		return "output-available";
+	}
+	if (event?.status === "running") {
+		return "input-available";
+	}
+	return deriveToolState(fallbackText ?? "");
+}
+
+function upsertToolEvent(events: ToolEvent[], next: ToolEvent): ToolEvent[] {
+	const existingIndex = events.findIndex(
+		(event) =>
+			(event.toolCallId &&
+				next.toolCallId &&
+				event.toolCallId === next.toolCallId) ||
+			(!event.toolCallId &&
+				!next.toolCallId &&
+				event.name === next.name &&
+				event.state === "input-available" &&
+				next.state !== "input-available"),
+	);
+
+	if (existingIndex === -1) {
+		return [...events, next];
+	}
+
+	return events.map((event, index) =>
+		index === existingIndex
+			? {
+					...event,
+					text: next.text,
+					state: next.state,
+					output: next.output,
+					error: next.error,
+				}
+			: event,
+	);
+}
+
+function appendToolEvent(
+	current: ChatMessage[],
+	text: string,
+	event: WebviewToolEvent | undefined,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	const activeAssistantId = activeAssistantIdRef.current;
+	const toolEvent: ToolEvent = {
+		id: nanoid(),
+		toolCallId: event?.toolCallId,
+		name: event?.toolName ?? extractToolName(text),
+		state: mapToolEventState(event, text),
+		text,
+		input: event?.input,
+		output: event?.output,
+		error: event?.error,
+	};
+
+	if (activeAssistantId) {
+		return current.map((message) =>
+			message.id === activeAssistantId
+				? {
+						...message,
+						toolEvents: upsertToolEvent(message.toolEvents ?? [], toolEvent),
+						blocks: upsertToolBlock(message.blocks, toolEvent),
+					}
+				: message,
+		);
+	}
+
+	return [
+		...current,
+		createMessage("meta", text, {
+			toolEvents: [toolEvent],
+			blocks: [{ id: nanoid(), type: "tool", toolEvent }],
+		}),
+	];
+}
+
+function mergeHydratedMessagesWithLive(
+	hydrated: ChatMessage[],
+	current: ChatMessage[],
+): ChatMessage[] {
+	if (current.length === 0) {
+		return hydrated;
+	}
+	const next = [...hydrated];
+	for (const live of current) {
+		const last = next.at(-1);
+		if (live.role === "assistant" && last?.role === "assistant") {
+			next[next.length - 1] = {
+				...last,
+				text: `${last.text}${live.text}`,
+				reasoning:
+					`${last.reasoning ?? ""}${live.reasoning ?? ""}` || undefined,
+				reasoningRedacted:
+					last.reasoningRedacted || live.reasoningRedacted || undefined,
+				toolEvents: [...(last.toolEvents ?? []), ...(live.toolEvents ?? [])],
+				blocks: [...(last.blocks ?? []), ...(live.blocks ?? [])],
+			};
+			continue;
+		}
+		if (
+			live.role === "meta" &&
+			last?.role === "meta" &&
+			(live.toolEvents?.length ?? 0) > 0
+		) {
+			next[next.length - 1] = {
+				...last,
+				text: live.text || last.text,
+				toolEvents: [...(last.toolEvents ?? []), ...(live.toolEvents ?? [])],
+				blocks: [...(last.blocks ?? []), ...(live.blocks ?? [])],
+			};
+			continue;
+		}
+		next.push(live);
+	}
+	return next;
+}
+
+function renderToolEvent(
+	toolEvent: ToolEvent,
+	className: string,
+): ReactElement[] {
+	return expandToolEvent(toolEvent).map((expanded) => (
+		<Tool className={className} key={expanded.id}>
+			<ToolHeader
+				state={expanded.state}
+				title={expanded.title}
+				type="dynamic-tool"
+				toolName={expanded.name}
+			/>
+			<ToolContent>
+				<ToolOutput errorText={expanded.error} output={expanded.output} />
+			</ToolContent>
+		</Tool>
+	));
+}
+
+function legacyMessageBlocks(message: ChatMessage): ChatMessageBlock[] {
+	const blocks: ChatMessageBlock[] = [];
+	for (const toolEvent of message.toolEvents ?? []) {
+		blocks.push({ id: `legacy-tool-${toolEvent.id}`, type: "tool", toolEvent });
+	}
+	if (message.reasoning) {
+		blocks.push({
+			id: `legacy-reasoning-${message.id}`,
+			type: "reasoning",
+			text: message.reasoning,
+			redacted: message.reasoningRedacted,
+		});
+	}
+	if (message.text) {
+		blocks.push({
+			id: `legacy-text-${message.id}`,
+			type: "text",
+			text: message.text,
+		});
+	}
+	return blocks;
+}
+
+function renderMessageBlocks(
+	message: ChatMessage,
+	options: { isMeta?: boolean; sending?: boolean },
+): ReactElement[] {
+	const blocks = message.blocks?.length
+		? message.blocks
+		: legacyMessageBlocks(message);
+	return blocks.flatMap((block) => {
+		switch (block.type) {
+			case "tool":
+				if (block.toolEvent.name.startsWith("team_")) {
+					return [
+						<TeamTasks
+							className={options.isMeta ? "mt-3 w-full" : "mb-3 w-full"}
+							events={[block.toolEvent] as TeamToolEvent[]}
+							key={block.id}
+						/>,
+					];
+				}
+				return renderToolEvent(
+					block.toolEvent,
+					options.isMeta ? "mt-3" : "mb-3",
+				);
+			case "reasoning":
+				return [
+					<Reasoning
+						className={options.isMeta ? "mt-3" : "mb-3"}
+						defaultOpen={false}
+						key={block.id}
+					>
+						<ReasoningTrigger />
+						<ReasoningContent>{block.text}</ReasoningContent>
+					</Reasoning>,
+				];
+			case "text":
+				if (options.isMeta) {
+					return [
+						<pre className="whitespace-pre-wrap font-inherit" key={block.id}>
+							{block.text}
+						</pre>,
+					];
+				}
+				return [
+					<MessageContent key={block.id}>
+						<MessageResponse>{block.text}</MessageResponse>
+					</MessageContent>,
+				];
+		}
+		return [];
+	});
+}
+
+function finalizeAssistantTurn(
+	current: ChatMessage[],
+	finishReason: string,
+	iterations: number,
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+	},
+): ChatMessage[] {
+	return [
+		...current,
+		createMessage(
+			"meta",
+			`Done (${finishReason}) • iterations=${iterations} • input=${usage?.inputTokens ?? 0} output=${usage?.outputTokens ?? 0}`,
+		),
+	];
+}
+
+function formatSessionLabel(session: WebviewSessionSummary): string {
+	const title = session.title?.trim() || session.sessionId.slice(0, 12);
+	const workspaceName = session.workspaceRoot?.trim()
+		? session.workspaceRoot.trim().split("/").pop()
+		: undefined;
+	return [title, workspaceName].filter(Boolean).join(" • ");
+}
+
+function formatCheckpointTime(createdAt: number): string {
+	try {
+		return new Intl.DateTimeFormat(undefined, {
+			month: "short",
+			day: "numeric",
+			hour: "numeric",
+			minute: "2-digit",
+		}).format(new Date(createdAt));
+	} catch {
+		return "Checkpoint";
+	}
+}
+
+type ChatProps = {
+	initialSessionId?: string;
+	onSessionSelected?: (sessionId?: string) => void;
+};
+
+export default function Chat({
+	initialSessionId,
+	onSessionSelected,
+}: ChatProps) {
+	const [messages, setMessages] = useState<ChatMessage[]>([]);
+	const [status, setStatus] = useState("Waiting for RPC initialization...");
+	const [sessionId, setSessionId] = useState<string>();
+	const [hydratingSessionId, setHydratingSessionId] = useState<string>();
+	const [sending, setSending] = useState(false);
+	const [providers, setProviders] = useState<ProviderOption[]>([]);
+	const [modelsByProvider, setModelsByProvider] = useState<
+		Record<string, WebviewProviderModel[]>
+	>({});
+	const [defaults, setDefaults] = useState<WebviewDefaults>({
+		workspaceRoot: "",
+		cwd: "",
+	});
+	const [sessions, setSessions] = useState<WebviewSessionSummary[]>([]);
+	const [sessionTitleDraft, setSessionTitleDraft] = useState("");
+	const [lastSelection, setLastSelection] =
+		useState<ModelSelectionStorage>(readModelSelection);
+	const [provider, setProvider] = useState(() => lastSelection.lastProvider);
+	const [model, setModel] = useState(
+		() => lastSelection.lastModelByProvider[lastSelection.lastProvider] ?? "",
+	);
+	const [systemPrompt, setSystemPrompt] = useState("");
+	const [maxIterations, setMaxIterations] = useState("");
+	const [mode, setMode] = useState<"act" | "plan">("act");
+	const [reasonLevel, setReasonLevel] = useState<WebviewReasonLevel>("none");
+	const [enableTools, setEnableTools] = useState(true);
+	const [enableSpawn, setEnableSpawn] = useState(false);
+	const [enableTeams, setEnableTeams] = useState(true);
+	const [autoApproveTools, setAutoApproveTools] = useState(true);
+	const [pendingApprovals, setPendingApprovals] = useState<PendingApproval[]>(
+		[],
+	);
+	const [modelSelectorOpen, setModelSelectorOpen] = useState(false);
+	const [titleEditing, setTitleEditing] = useState(false);
+	const [forking, setForking] = useState(false);
+	const [forkError, setForkError] = useState<string | null>(null);
+	const activeAssistantIdRef = useRef<string | undefined>(undefined);
+	const initialSessionIdRef = useRef<string | undefined>(undefined);
+	const hydratingSessionIdRef = useRef<string | undefined>(undefined);
+	const sessionIdRef = useRef<string | undefined>(undefined);
+	const onSessionSelectedRef = useRef(onSessionSelected);
+	const lastSelectionRef = useRef(lastSelection);
+	const sessionsRef = useRef(sessions);
+	const defaultsRef = useRef(defaults);
+
+	const attachSession = useCallback(
+		(nextSessionId: string) => {
+			if (
+				hydratingSessionIdRef.current === nextSessionId ||
+				(sessionIdRef.current === nextSessionId &&
+					!hydratingSessionIdRef.current)
+			) {
+				return;
+			}
+			sessionIdRef.current = nextSessionId;
+			hydratingSessionIdRef.current = nextSessionId;
+			setSessionId(nextSessionId);
+			setHydratingSessionId(nextSessionId);
+			setMessages([]);
+			setSending(false);
+			setPendingApprovals([]);
+			activeAssistantIdRef.current = undefined;
+			setStatus(`Loading chat history for ${nextSessionId}...`);
+			onSessionSelected?.(nextSessionId);
+			postToHost({
+				type: "attachSession",
+				sessionId: nextSessionId,
+			});
+		},
+		[onSessionSelected],
+	);
+
+	useEffect(() => {
+		hydratingSessionIdRef.current = hydratingSessionId;
+	}, [hydratingSessionId]);
+
+	useEffect(() => {
+		sessionIdRef.current = sessionId;
+	}, [sessionId]);
+
+	useEffect(() => {
+		onSessionSelectedRef.current = onSessionSelected;
+	}, [onSessionSelected]);
+
+	useEffect(() => {
+		sessionsRef.current = sessions;
+	}, [sessions]);
+
+	useEffect(() => {
+		defaultsRef.current = defaults;
+	}, [defaults]);
+
+	useEffect(() => {
+		const handleMessage = (event: MessageEvent<WebviewOutboundMessage>) => {
+			const message = event.data;
+			if (!message || typeof message !== "object" || !("type" in message)) {
+				return;
+			}
+
+			switch (message.type) {
+				case "status":
+					setStatus(message.text);
+					return;
+				case "error":
+					setStatus(`Error: ${message.text}`);
+					setSending(false);
+					setHydratingSessionId(undefined);
+					hydratingSessionIdRef.current = undefined;
+					activeAssistantIdRef.current = undefined;
+					setMessages((current) => {
+						if (current.length === 0) {
+							return current;
+						}
+						const nextText = `Error: ${message.text}`;
+						const last = current.at(-1);
+						if (last?.role === "error" && last.text === nextText) {
+							return current;
+						}
+						return [...current, createMessage("error", nextText)];
+					});
+					return;
+				case "defaults":
+					setDefaults(message.defaults);
+					if (message.defaults.provider) {
+						setProvider(message.defaults.provider);
+					}
+					if (message.defaults.model) {
+						setModel(message.defaults.model);
+					}
+					return;
+				case "sessions":
+					setSessions(message.sessions);
+					return;
+				case "providers":
+					setProviders(message.providers);
+					setProvider((current) => {
+						const currentProvider =
+							current && message.providers.some((item) => item.id === current)
+								? current
+								: "";
+						const savedProvider = readModelSelection().lastProvider;
+						const nextProvider =
+							currentProvider ||
+							(savedProvider &&
+							message.providers.some((item) => item.id === savedProvider)
+								? savedProvider
+								: "") ||
+							message.providers.find((item) => item.enabled)?.id ||
+							message.providers[0]?.id ||
+							"";
+						if (nextProvider) {
+							postToHost({ type: "loadModels", providerId: nextProvider });
+						}
+						return nextProvider;
+					});
+					return;
+				case "models":
+					setModelsByProvider((current) => ({
+						...current,
+						[message.providerId]: message.models,
+					}));
+					setModel((current) => {
+						if (current && message.models.some((item) => item.id === current)) {
+							return current;
+						}
+						const nextDefaults = defaultsRef.current;
+						if (
+							nextDefaults.provider === message.providerId &&
+							nextDefaults.model &&
+							message.models.some((item) => item.id === nextDefaults.model)
+						) {
+							return nextDefaults.model;
+						}
+						const saved = readModelSelection();
+						const rememberedModel =
+							saved.lastModelByProvider[message.providerId];
+						if (
+							rememberedModel &&
+							message.models.some((item) => item.id === rememberedModel)
+						) {
+							return rememberedModel;
+						}
+						return message.models[0]?.id || "";
+					});
+					return;
+				case "session_started":
+					sessionIdRef.current = message.sessionId;
+					setSessionId(message.sessionId);
+					onSessionSelectedRef.current?.(message.sessionId);
+					setTitleEditing(false);
+					setSessionTitleDraft("");
+					return;
+				case "session_hydrated":
+					if (
+						hydratingSessionIdRef.current &&
+						hydratingSessionIdRef.current !== message.sessionId
+					) {
+						return;
+					}
+					sessionIdRef.current = message.sessionId;
+					hydratingSessionIdRef.current = undefined;
+					setSessionId(message.sessionId);
+					setHydratingSessionId(undefined);
+					setSending(message.status === "running");
+					if (message.providerId) {
+						setProvider(message.providerId);
+					}
+					if (message.providerId && message.modelId) {
+						const nextSelection: ModelSelectionStorage = {
+							lastProvider: message.providerId,
+							lastModelByProvider: {
+								...lastSelectionRef.current.lastModelByProvider,
+								[message.providerId]: message.modelId,
+							},
+						};
+						lastSelectionRef.current = nextSelection;
+						setLastSelection(nextSelection);
+						writeModelSelection(nextSelection);
+						setModel(message.modelId);
+					}
+					setTitleEditing(false);
+					setSessionTitleDraft(
+						sessionsRef.current
+							.find((item) => item.sessionId === message.sessionId)
+							?.title?.trim() || "",
+					);
+					setMessages((current) => {
+						const merged =
+							message.status === "running"
+								? mergeHydratedMessagesWithLive(
+										message.messages as ChatMessage[],
+										current,
+									)
+								: (message.messages as ChatMessage[]);
+						activeAssistantIdRef.current =
+							message.status === "running"
+								? [...merged]
+										.reverse()
+										.find((item) => item.role === "assistant")?.id
+								: undefined;
+						return merged;
+					});
+					setStatus(
+						message.status === "running"
+							? `Attached to ${message.sessionId} (running)`
+							: `Attached to ${message.sessionId}`,
+					);
+					return;
+				case "assistant_delta":
+					setMessages((current) =>
+						appendAssistantDelta(current, message.text, activeAssistantIdRef),
+					);
+					return;
+				case "reasoning_delta":
+					setMessages((current) =>
+						appendReasoningDelta(
+							current,
+							message.text,
+							message.redacted,
+							activeAssistantIdRef,
+						),
+					);
+					return;
+				case "tool_event":
+					setMessages((current) =>
+						appendToolEvent(
+							current,
+							message.text,
+							message.event,
+							activeAssistantIdRef,
+						),
+					);
+					return;
+				case "approval_request":
+					setPendingApprovals((current) => {
+						const existingIndex = current.findIndex(
+							(item) => item.approvalId === message.approvalId,
+						);
+						const next = { ...message, responding: false };
+						if (existingIndex === -1) {
+							return [...current, next];
+						}
+						return current.map((item, index) =>
+							index === existingIndex ? next : item,
+						);
+					});
+					setStatus(`Waiting for approval: ${message.toolName}`);
+					return;
+				case "approval_resolved":
+					setPendingApprovals((current) =>
+						current.filter((item) => item.approvalId !== message.approvalId),
+					);
+					return;
+				case "turn_done":
+					setStatus(`Done (${message.finishReason})`);
+					setSending(false);
+					setPendingApprovals([]);
+					activeAssistantIdRef.current = undefined;
+					setMessages((current) =>
+						finalizeAssistantTurn(
+							current,
+							message.finishReason,
+							message.iterations,
+							message.usage,
+						),
+					);
+					return;
+				case "reset_done":
+					sessionIdRef.current = undefined;
+					hydratingSessionIdRef.current = undefined;
+					setSessionId(undefined);
+					setHydratingSessionId(undefined);
+					setSending(false);
+					setPendingApprovals([]);
+					setTitleEditing(false);
+					setSessionTitleDraft("");
+					activeAssistantIdRef.current = undefined;
+					onSessionSelectedRef.current?.(undefined);
+					setStatus("Started a new chat session.");
+					setMessages([]);
+					return;
+				case "fork_done":
+					setForking(false);
+					setForkError(null);
+					setStatus(`Forked → new session ${message.newSessionId}`);
+					return;
+				case "fork_error":
+					setForking(false);
+					setForkError(message.text);
+					setStatus(`Fork failed: ${message.text}`);
+					return;
+			}
+		};
+
+		window.addEventListener("message", handleMessage);
+		postToHost({ type: "ready" });
+		return () => {
+			window.removeEventListener("message", handleMessage);
+		};
+	}, []);
+
+	useEffect(() => {
+		if (!initialSessionId || initialSessionIdRef.current === initialSessionId) {
+			return;
+		}
+		initialSessionIdRef.current = initialSessionId;
+		attachSession(initialSessionId);
+	}, [attachSession, initialSessionId]);
+
+	useEffect(() => {
+		if (provider) {
+			postToHost({ type: "loadModels", providerId: provider });
+		}
+	}, [provider]);
+
+	useEffect(() => {
+		if (!provider || !model) {
+			return;
+		}
+		const previous = lastSelectionRef.current;
+		if (
+			previous.lastProvider === provider &&
+			previous.lastModelByProvider[provider] === model
+		) {
+			return;
+		}
+		const nextSelection: ModelSelectionStorage = {
+			lastProvider: provider,
+			lastModelByProvider: {
+				...previous.lastModelByProvider,
+				[provider]: model,
+			},
+		};
+		lastSelectionRef.current = nextSelection;
+		setLastSelection(nextSelection);
+		writeModelSelection(nextSelection);
+	}, [provider, model]);
+
+	const models = modelsByProvider[provider] ?? [];
+	const isHydrating = Boolean(hydratingSessionId);
+	const modelSupportsReasoning =
+		models.find((item) => item.id === model)?.supportsThinking === true;
+	const effectiveReasonLevel = modelSupportsReasoning ? reasonLevel : "none";
+	const visibleMessages = useMemo(
+		() => messages.filter((message) => message.role !== "meta" || message.text),
+		[messages],
+	);
+	const sessionTitle =
+		sessionId &&
+		typeof sessions.find((item) => item.sessionId === sessionId)?.title ===
+			"string"
+			? sessions.find((item) => item.sessionId === sessionId)?.title?.trim() ||
+				""
+			: "";
+	const displayedSessionTitle = titleEditing ? sessionTitleDraft : sessionTitle;
+
+	const commitSessionTitle = () => {
+		if (!sessionId) {
+			setTitleEditing(false);
+			return;
+		}
+		const normalized = sessionTitleDraft.replace(/\s+/g, " ").trim();
+		setTitleEditing(false);
+		if (normalized === sessionTitle) {
+			return;
+		}
+		setSessionTitleDraft(normalized);
+		postToHost({
+			type: "updateSessionMetadata",
+			sessionId,
+			metadata: {
+				title: normalized,
+			},
+		});
+	};
+
+	const respondToApproval = (approvalId: string, approved: boolean) => {
+		setPendingApprovals((current) =>
+			current.map((item) =>
+				item.approvalId === approvalId ? { ...item, responding: true } : item,
+			),
+		);
+		postToHost({
+			type: "approval_response",
+			approvalId,
+			approved,
+			reason: approved ? "Approved in Cline Hub." : "Rejected in Cline Hub.",
+		});
+		setStatus(approved ? "Approval sent." : "Rejection sent.");
+	};
+
+	return (
+		<PromptInputProvider>
+			<div className="relative flex h-screen flex-col overflow-hidden">
+				<div className="flex items-center justify-between border-b px-4 py-3">
+					<div className="min-w-0">
+						{sessions.length > 0 ? (
+							<select
+								className="max-w-48 rounded-md border bg-background px-2 py-1 text-xs"
+								disabled={isHydrating}
+								onChange={(event) => {
+									const nextSessionId = event.target.value;
+									if (!nextSessionId) {
+										postToHost({ type: "reset" });
+										setStatus("Resetting session...");
+										setPendingApprovals([]);
+										return;
+									}
+									attachSession(nextSessionId);
+								}}
+								value={sessionId ?? ""}
+							>
+								<option value="">New session</option>
+								{sessions.map((item) => (
+									<option key={item.sessionId} value={item.sessionId}>
+										{formatSessionLabel(item)}
+									</option>
+								))}
+							</select>
+						) : null}
+						{isHydrating ? (
+							<span className="ml-2 inline-flex items-center gap-1.5 text-xs text-muted-foreground">
+								<Loader2Icon className="size-3 animate-spin" />
+								Loading history
+							</span>
+						) : null}
+						{sessionId ? (
+							<input
+								className="min-w-0 max-w-56 rounded-md border bg-muted px-2 py-1 text-xs"
+								disabled={isHydrating}
+								onBlur={commitSessionTitle}
+								onChange={(event) => setSessionTitleDraft(event.target.value)}
+								onFocus={() => {
+									setTitleEditing(true);
+									setSessionTitleDraft(sessionTitle);
+								}}
+								onKeyDown={(event) => {
+									if (event.key === "Enter") {
+										event.preventDefault();
+										commitSessionTitle();
+									}
+								}}
+								placeholder="Session title"
+								value={displayedSessionTitle}
+							/>
+						) : null}
+						{sessionId ? (
+							<Button
+								disabled={isHydrating}
+								onClick={() => {
+									setStatus(`Deleting ${sessionId}...`);
+									postToHost({ type: "deleteSession", sessionId });
+								}}
+								size="icon-sm"
+								type="button"
+								variant="ghost"
+							>
+								<Trash2Icon className="size-4" />
+								<span className="sr-only">Delete session</span>
+							</Button>
+						) : null}
+					</div>
+					<div className="flex items-center gap-2">
+						<Button
+							disabled={isHydrating}
+							onClick={() => {
+								postToHost({ type: "reset" });
+								setStatus("Resetting session...");
+								setPendingApprovals([]);
+							}}
+							size="icon-sm"
+							type="button"
+							variant="ghost"
+						>
+							<PlusIcon className="size-4" />
+							<span className="sr-only">New chat</span>
+						</Button>
+					</div>
+				</div>
+				<Conversation className="min-h-0 flex-1">
+					<ConversationContent className="px-4 py-5">
+						{isHydrating ? (
+							<div className="flex h-full items-center justify-center rounded-xl border border-dashed px-6 py-16 text-center text-sm text-muted-foreground">
+								<span className="inline-flex items-center gap-2">
+									<Loader2Icon className="size-4 animate-spin" />
+									Loading chat history...
+								</span>
+							</div>
+						) : visibleMessages.length === 0 ? (
+							<div className="flex h-full items-center align-middle justify-center rounded-xl border border-dashed px-6 py-16 text-center text-sm text-muted-foreground">
+								How can I help you?
+							</div>
+						) : null}
+						{visibleMessages.map((message) => {
+							if (message.role === "meta" || message.role === "error") {
+								return (
+									<div
+										className={cn(
+											"w-full rounded-lg border px-4 py-3 text-sm",
+											message.role === "error"
+												? "border-destructive/40 bg-destructive/10 text-destructive"
+												: "bg-muted/40 text-muted-foreground",
+										)}
+										key={message.id}
+									>
+										{renderMessageBlocks(message, { isMeta: true })}
+									</div>
+								);
+							}
+
+							return (
+								<Message from={message.role} key={message.id}>
+									<div>
+										{renderMessageBlocks(message, { sending })}
+										{message.role === "user" && message.checkpoint ? (
+											<Checkpoint className="mt-1 justify-end">
+												<CheckpointTrigger
+													className="h-6 gap-1 px-2 text-[11px] text-muted-foreground hover:text-foreground"
+													disabled={sending}
+													onClick={() => {
+														if (message.checkpoint) {
+															postToHost({
+																type: "restore",
+																checkpointRunCount: message.checkpoint.runCount,
+															});
+														}
+													}}
+													tooltip={`Checkpoint from run ${message.checkpoint.runCount}`}
+													type="button"
+													variant="ghost"
+												>
+													<CheckpointIcon className="size-3" />
+													{formatCheckpointTime(message.checkpoint.createdAt)}
+												</CheckpointTrigger>
+											</Checkpoint>
+										) : null}
+										{message.role === "assistant" &&
+										message.text &&
+										!sending ? (
+											<div className="mt-1 flex items-center gap-1">
+												<Button
+													className="h-6 gap-1 px-2 text-[11px] text-muted-foreground hover:text-foreground"
+													disabled={forking}
+													onClick={() => {
+														setForking(true);
+														setForkError(null);
+														postToHost({ type: "forkSession" });
+													}}
+													size="sm"
+													title="Fork session — copy full message history into a new session"
+													type="button"
+													variant="ghost"
+												>
+													{forking ? (
+														<Loader2Icon className="size-3 animate-spin" />
+													) : (
+														<GitBranchIcon className="size-3" />
+													)}
+													Fork
+												</Button>
+												{forkError ? (
+													<span className="text-[11px] text-destructive">
+														{forkError}
+													</span>
+												) : null}
+											</div>
+										) : null}
+									</div>
+								</Message>
+							);
+						})}
+					</ConversationContent>
+					<ConversationScrollButton />
+				</Conversation>
+				{pendingApprovals.length > 0 ? (
+					<div className="grid max-h-72 gap-2 overflow-auto border-t bg-background/95 px-4 py-3">
+						{pendingApprovals.map((approval) => (
+							<div
+								className="grid gap-2 rounded-lg border bg-card p-3 text-sm"
+								key={approval.approvalId}
+							>
+								<div className="flex items-start justify-between gap-3">
+									<div className="min-w-0">
+										<p className="font-semibold">Approve tool call?</p>
+										<p className="break-all text-muted-foreground text-xs">
+											{approval.toolName}
+										</p>
+									</div>
+									<div className="flex shrink-0 items-center gap-2">
+										<Button
+											disabled={approval.responding}
+											onClick={() =>
+												respondToApproval(approval.approvalId, false)
+											}
+											size="sm"
+											type="button"
+											variant="destructive"
+										>
+											<XIcon className="size-4" />
+											Reject
+										</Button>
+										<Button
+											disabled={approval.responding}
+											onClick={() =>
+												respondToApproval(approval.approvalId, true)
+											}
+											size="sm"
+											type="button"
+										>
+											{approval.responding ? (
+												<Loader2Icon className="size-4 animate-spin" />
+											) : (
+												<CheckIcon className="size-4" />
+											)}
+											Approve
+										</Button>
+									</div>
+								</div>
+								<pre className="max-h-32 overflow-auto rounded-md border bg-background p-2 text-[11px]">
+									{formatApprovalInput(approval.input)}
+								</pre>
+							</div>
+						))}
+					</div>
+				) : null}
+				<Composer
+					autoApproveTools={autoApproveTools}
+					disabled={isHydrating}
+					enableSpawn={enableSpawn}
+					enableTeams={enableTeams}
+					enableTools={enableTools}
+					maxIterations={maxIterations}
+					model={model}
+					mode={mode}
+					modelSelectorOpen={modelSelectorOpen}
+					models={models}
+					onAbort={() => {
+						postToHost({ type: "abort" });
+						setStatus("Abort requested...");
+					}}
+					onAutoApproveToolsChange={setAutoApproveTools}
+					onEnableSpawnChange={setEnableSpawn}
+					onEnableTeamsChange={setEnableTeams}
+					onEnableToolsChange={setEnableTools}
+					onModeChange={setMode}
+					onMaxIterationsChange={setMaxIterations}
+					onModelChange={setModel}
+					onModelSelectorOpenChange={setModelSelectorOpen}
+					onProviderChange={(nextProvider) => {
+						setProvider(nextProvider);
+						const rememberedModel =
+							lastSelection.lastModelByProvider[nextProvider];
+						const providerModelIds = (modelsByProvider[nextProvider] ?? []).map(
+							(item) => item.id,
+						);
+						if (rememberedModel && providerModelIds.includes(rememberedModel)) {
+							setModel(rememberedModel);
+							return;
+						}
+						setModel("");
+					}}
+					onSend={({ prompt, attachments, attachmentCount }) => {
+						if (isHydrating) {
+							return;
+						}
+						const assistantMessage = createMessage("assistant", "");
+						activeAssistantIdRef.current = assistantMessage.id;
+						setMessages((current) => [
+							...current,
+							createMessage(
+								"user",
+								buildUserMessageLabel(prompt, attachments, attachmentCount),
+							),
+							assistantMessage,
+						]);
+						setSending(true);
+						setStatus("Running...");
+						postToHost({
+							type: "send",
+							prompt,
+							attachments,
+							config: {
+								autoApproveTools,
+								enableSpawn,
+								enableTeams,
+								enableTools,
+								maxIterations: parseMaxIterations(maxIterations),
+								model: model || undefined,
+								mode,
+								provider: provider || undefined,
+								reasonLevel: effectiveReasonLevel,
+								systemPrompt: systemPrompt.trim() || undefined,
+							},
+						});
+					}}
+					onSystemPromptChange={setSystemPrompt}
+					onReasonLevelChange={setReasonLevel}
+					provider={provider}
+					providers={providers}
+					sending={sending}
+					status={status}
+					systemPrompt={systemPrompt}
+					reasonLevel={effectiveReasonLevel}
+					workspaceRoot={defaults.workspaceRoot}
+				/>
+			</div>
+		</PromptInputProvider>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/Composer.tsx b/apps/cline-hub/src/webview/src/components/Composer.tsx
new file mode 100644
index 0000000..2a0e4f7
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/Composer.tsx
@@ -0,0 +1,566 @@
+import {
+	CheckIcon,
+	HatGlassesIcon,
+	PaperclipIcon,
+	PlayIcon,
+	Settings2Icon,
+	SignalHigh,
+	SignalLow,
+	SignalMedium,
+} from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import {
+	Attachment,
+	AttachmentPreview,
+	AttachmentRemove,
+	Attachments,
+} from "@/components/ai-elements/attachments";
+import {
+	ModelSelector,
+	ModelSelectorContent,
+	ModelSelectorEmpty,
+	ModelSelectorGroup,
+	ModelSelectorInput,
+	ModelSelectorItem,
+	ModelSelectorList,
+	ModelSelectorLogo,
+	ModelSelectorLogoGroup,
+	ModelSelectorName,
+	ModelSelectorTrigger,
+} from "@/components/ai-elements/model-selector";
+import type { PromptInputMessage } from "@/components/ai-elements/prompt-input";
+import {
+	PromptInput,
+	PromptInputBody,
+	PromptInputButton,
+	PromptInputFooter,
+	PromptInputHeader,
+	PromptInputSubmit,
+	PromptInputTextarea,
+	PromptInputTools,
+	usePromptInputAttachments,
+	usePromptInputController,
+} from "@/components/ai-elements/prompt-input";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import type {
+	WebviewChatAttachments,
+	WebviewOutboundMessage,
+	WebviewProviderModel,
+	WebviewReasonLevel,
+} from "../../../webview-protocol";
+
+type ProviderOption = Extract<
+	WebviewOutboundMessage,
+	{ type: "providers" }
+>["providers"][number];
+
+function PromptAttachmentsDisplay() {
+	const attachments = usePromptInputAttachments();
+
+	if (attachments.files.length === 0) {
+		return null;
+	}
+
+	return (
+		<Attachments variant="inline">
+			{attachments.files.map((attachment) => (
+				<Attachment
+					data={attachment}
+					key={attachment.id}
+					onRemove={() => attachments.remove(attachment.id)}
+				>
+					<AttachmentPreview />
+					<AttachmentRemove />
+				</Attachment>
+			))}
+		</Attachments>
+	);
+}
+
+function ComposerSettings({
+	autoApproveTools,
+	enableSpawn,
+	enableTeams,
+	model,
+	modelSelectorOpen,
+	models,
+	onAutoApproveToolsChange,
+	onEnableSpawnChange,
+	onEnableTeamsChange,
+	onModelChange,
+	onModelSelectorOpenChange,
+	onProviderChange,
+	provider,
+	providers,
+	workspaceRoot,
+}: {
+	autoApproveTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	enableTools: boolean;
+	maxIterations: string;
+	model: string;
+	modelSelectorOpen: boolean;
+	models: WebviewProviderModel[];
+	onAutoApproveToolsChange: (value: boolean) => void;
+	onEnableSpawnChange: (value: boolean) => void;
+	onEnableTeamsChange: (value: boolean) => void;
+	onEnableToolsChange: (value: boolean) => void;
+	onMaxIterationsChange: (value: string) => void;
+	onModelChange: (value: string) => void;
+	onModelSelectorOpenChange: (value: boolean) => void;
+	onProviderChange: (value: string) => void;
+	onSystemPromptChange: (value: string) => void;
+	provider: string;
+	providers: ProviderOption[];
+	systemPrompt: string;
+	workspaceRoot: string;
+}) {
+	const selectedProvider = providers.find((item) => item.id === provider);
+	const selectedModel =
+		models.find((item) => item.id === model) ?? models[0] ?? undefined;
+
+	return (
+		<div className="grid gap-3 bg-background/70 p-3">
+			<div className="grid gap-2 md:grid-cols-2">
+				<div className="grid gap-2">
+					<Label className="text-xs uppercase tracking-[0.16em] text-muted-foreground">
+						Provider
+					</Label>
+					<Select
+						onValueChange={(value) => {
+							if (value) {
+								onProviderChange(value);
+							}
+						}}
+						value={provider}
+					>
+						<SelectTrigger className="w-full">
+							<SelectValue placeholder="Select provider" />
+						</SelectTrigger>
+						<SelectContent>
+							{providers.map((item) => (
+								<SelectItem key={item.id} value={item.id}>
+									<div className="flex items-center gap-2">
+										{renderProviderLogo(item.id)}
+										<span>{item.name}</span>
+									</div>
+								</SelectItem>
+							))}
+						</SelectContent>
+					</Select>
+				</div>
+				<div className="grid gap-2">
+					<Label className="text-xs uppercase tracking-[0.16em] text-muted-foreground">
+						Model
+					</Label>
+					<ModelSelector
+						onOpenChange={onModelSelectorOpenChange}
+						open={modelSelectorOpen}
+					>
+						<ModelSelectorTrigger>
+							<Button className="w-full justify-between" variant="outline">
+								<div className="flex min-w-0 items-center gap-2">
+									{selectedProvider && renderProviderLogo(selectedProvider.id)}
+									<span className="truncate">
+										{selectedModel?.name || selectedModel?.id || "Select model"}
+									</span>
+								</div>
+							</Button>
+						</ModelSelectorTrigger>
+						<ModelSelectorContent>
+							<ModelSelectorInput placeholder="Search models..." />
+							<ModelSelectorList>
+								<ModelSelectorEmpty>No models found.</ModelSelectorEmpty>
+								<ModelSelectorGroup
+									heading={selectedProvider?.name || "Models"}
+								>
+									{models.map((item) => (
+										<ModelSelectorItem
+											key={item.id}
+											onSelect={() => {
+												onModelChange(item.id);
+												onModelSelectorOpenChange(false);
+											}}
+											value={item.id}
+										>
+											{selectedProvider &&
+												renderProviderLogo(selectedProvider.id)}
+											<ModelSelectorName>
+												{item.name || item.id}
+											</ModelSelectorName>
+											<ModelSelectorLogoGroup>
+												{selectedProvider &&
+													renderProviderLogo(selectedProvider.id)}
+											</ModelSelectorLogoGroup>
+											{model === item.id ? (
+												<CheckIcon className="ml-auto size-4" />
+											) : (
+												<div className="ml-auto size-4" />
+											)}
+										</ModelSelectorItem>
+									))}
+								</ModelSelectorGroup>
+							</ModelSelectorList>
+						</ModelSelectorContent>
+					</ModelSelector>
+				</div>
+			</div>
+			<div className="grid gap-2 md:grid-cols-2">
+				<div className="grid gap-2">
+					<Label
+						className="text-xs uppercase tracking-[0.16em] text-muted-foreground"
+						htmlFor="workspace-root"
+					>
+						Workspace
+					</Label>
+					<Input id="workspace-root" readOnly value={workspaceRoot} />
+				</div>
+			</div>
+			<div className="grid gap-2 md:grid-cols-2">
+				<Toggle
+					checked={enableSpawn}
+					label="Subagents"
+					onChange={onEnableSpawnChange}
+				/>
+				<Toggle
+					checked={enableTeams}
+					label="Agent Teams"
+					onChange={onEnableTeamsChange}
+				/>
+				<Toggle
+					checked={autoApproveTools}
+					label="Auto-approves"
+					onChange={onAutoApproveToolsChange}
+				/>
+			</div>
+		</div>
+	);
+}
+
+function renderProviderLogo(providerId: string) {
+	return (
+		<ModelSelectorLogo className="size-3.5" provider={providerId || "openai"} />
+	);
+}
+
+function Toggle({
+	checked,
+	label,
+	onChange,
+	disabled,
+}: {
+	checked: boolean;
+	label: string;
+	onChange: (value: boolean) => void;
+	disabled?: boolean;
+}) {
+	return (
+		<div className="flex items-center justify-between rounded-lg border bg-background/60 px-3 py-2">
+			<Label className="text-sm" htmlFor={label}>
+				{label}
+			</Label>
+			<Switch
+				checked={checked}
+				id={label}
+				onCheckedChange={(value) => onChange(value)}
+				disabled={disabled}
+			/>
+		</div>
+	);
+}
+
+const ReasonLevel = {
+	None: "none",
+	Low: "low",
+	Medium: "medium",
+	High: "high",
+} as const;
+
+const reasonLevels = [
+	{ value: ReasonLevel.None, label: "Thinking Off", icon: SignalHigh },
+	{ value: ReasonLevel.Low, label: "Low", icon: SignalLow },
+	{ value: ReasonLevel.Medium, label: "Medium", icon: SignalMedium },
+	{ value: ReasonLevel.High, label: "High", icon: SignalHigh },
+];
+
+export function Composer({
+	autoApproveTools,
+	disabled = false,
+	enableSpawn,
+	enableTeams,
+	enableTools,
+	maxIterations,
+	model,
+	mode,
+	modelSelectorOpen,
+	models,
+	onAbort,
+	onAutoApproveToolsChange,
+	onEnableSpawnChange,
+	onEnableTeamsChange,
+	onEnableToolsChange,
+	onModeChange,
+	onMaxIterationsChange,
+	onModelChange,
+	onModelSelectorOpenChange,
+	onProviderChange,
+	onSend,
+	onSystemPromptChange,
+	onReasonLevelChange,
+	provider,
+	providers,
+	sending,
+	status,
+	systemPrompt,
+	reasonLevel,
+	workspaceRoot,
+}: {
+	autoApproveTools: boolean;
+	disabled?: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	enableTools: boolean;
+	maxIterations: string;
+	model: string;
+	mode: "act" | "plan";
+	modelSelectorOpen: boolean;
+	models: WebviewProviderModel[];
+	onAbort: () => void;
+	onAutoApproveToolsChange: (value: boolean) => void;
+	onEnableSpawnChange: (value: boolean) => void;
+	onEnableTeamsChange: (value: boolean) => void;
+	onEnableToolsChange: (value: boolean) => void;
+	onModeChange: (value: "act" | "plan") => void;
+	onMaxIterationsChange: (value: string) => void;
+	onModelChange: (value: string) => void;
+	onModelSelectorOpenChange: (value: boolean) => void;
+	onProviderChange: (value: string) => void;
+	onSend: (input: {
+		prompt: string;
+		attachments?: WebviewChatAttachments;
+		attachmentCount: number;
+	}) => void;
+	onSystemPromptChange: (value: string) => void;
+	onReasonLevelChange: (value: WebviewReasonLevel) => void;
+	provider: string;
+	providers: ProviderOption[];
+	sending: boolean;
+	status: string;
+	systemPrompt: string;
+	reasonLevel: WebviewReasonLevel;
+	workspaceRoot: string;
+}) {
+	const [settingsOpen, setSettingsOpen] = useState(false);
+	const controller = usePromptInputController();
+	const attachments = usePromptInputAttachments();
+	const selectedModel = models.find((item) => item.id === model);
+	const thinkingSupported = selectedModel?.supportsThinking === true;
+	const activeReasonLevel = thinkingSupported ? reasonLevel : ReasonLevel.None;
+	const reasonLevelOption = Math.max(
+		reasonLevels.findIndex((item) => item.value === activeReasonLevel),
+		0,
+	);
+	const ReasonIcon = reasonLevels[reasonLevelOption].icon;
+
+	return (
+		<div className="border-t bg-background">
+			<PromptInput
+				accept="image/*,.txt,.md,.json,.ts,.tsx,.js,.jsx"
+				globalDrop
+				className="rounded-none [&>[data-slot=input-group]]:border-0! [&>[data-slot=input-group]]:ring-0! [&>[data-slot=input-group]]:has-[[data-slot=input-group-control]:focus-visible]:border-0! [&>[data-slot=input-group]]:has-[[data-slot=input-group-control]:focus-visible]:ring-0!"
+				maxFiles={8}
+				multiple
+				onError={(error) => toast.error(error.message)}
+				onSubmit={async (message: PromptInputMessage) => {
+					const prompt = message.text.trim();
+					if (!prompt && !message.files.length) {
+						return;
+					}
+
+					let attachments: WebviewChatAttachments | undefined;
+					if (message.files.length > 0) {
+						const userImages = (
+							await Promise.all(
+								message.files.map((file) => toImageDataUrl(file.url)),
+							)
+						).filter((value): value is string => Boolean(value));
+						if (userImages.length > 0) {
+							attachments = { userImages };
+						}
+						if (userImages.length !== message.files.length) {
+							toast.warning(
+								"Only image attachments are currently sent in the VS Code chat runtime.",
+							);
+						}
+					}
+
+					if (!prompt && !attachments?.userImages?.length) {
+						return;
+					}
+
+					onSend({
+						prompt,
+						attachments,
+						attachmentCount: message.files.length,
+					});
+				}}
+			>
+				<PromptInputHeader>
+					<PromptAttachmentsDisplay />
+				</PromptInputHeader>
+				<PromptInputBody>
+					<PromptInputTextarea
+						disabled={disabled || status.includes("Failed")}
+						onChange={(event) =>
+							controller.textInput.setInput(event.target.value)
+						}
+						placeholder="Type @ for context and / for skills"
+						value={controller.textInput.value}
+						className="text-sm outline-none ring-0"
+					/>
+				</PromptInputBody>
+				<PromptInputFooter className="flex-col items-stretch gap-1 px-0">
+					{settingsOpen ? (
+						<ComposerSettings
+							autoApproveTools={autoApproveTools}
+							enableSpawn={enableSpawn}
+							enableTeams={enableTeams}
+							enableTools={enableTools}
+							maxIterations={maxIterations}
+							model={model}
+							modelSelectorOpen={modelSelectorOpen}
+							models={models}
+							onAutoApproveToolsChange={onAutoApproveToolsChange}
+							onEnableSpawnChange={onEnableSpawnChange}
+							onEnableTeamsChange={onEnableTeamsChange}
+							onEnableToolsChange={onEnableToolsChange}
+							onMaxIterationsChange={onMaxIterationsChange}
+							onModelChange={onModelChange}
+							onModelSelectorOpenChange={onModelSelectorOpenChange}
+							onProviderChange={onProviderChange}
+							onSystemPromptChange={onSystemPromptChange}
+							provider={provider}
+							providers={providers}
+							systemPrompt={systemPrompt}
+							workspaceRoot={workspaceRoot}
+						/>
+					) : null}
+					<div className="flex items-center justify-between gap-3">
+						<PromptInputTools className="shrink-0">
+							<PromptInputButton
+								disabled={disabled}
+								onClick={() => attachments.openFileDialog()}
+								type="button"
+								variant="ghost"
+							>
+								<PaperclipIcon className="size-3" />
+							</PromptInputButton>
+							<PromptInputButton
+								disabled={disabled}
+								onClick={() => setSettingsOpen((open) => !open)}
+								type="button"
+								variant={settingsOpen ? "default" : "ghost"}
+							>
+								<Settings2Icon className="size-3" />
+								<span>
+									{provider}:{model}
+								</span>
+							</PromptInputButton>
+							<PromptInputButton
+								disabled={disabled || !thinkingSupported}
+								onClick={() => {
+									const nextOption =
+										(reasonLevelOption + 1) % reasonLevels.length;
+									onReasonLevelChange(reasonLevels[nextOption].value);
+								}}
+								type="button"
+								title={reasonLevels[reasonLevelOption].label}
+								variant={
+									activeReasonLevel !== ReasonLevel.None ? "default" : "ghost"
+								}
+							>
+								<ReasonIcon className="size-3" />
+							</PromptInputButton>
+							<PromptInputButton
+								disabled={disabled}
+								onClick={() => onModeChange(mode === "act" ? "plan" : "act")}
+								type="button"
+								variant={mode === "plan" ? "default" : "ghost"}
+								className="hidden"
+							>
+								{mode === "act" ? (
+									<PlayIcon className="size-3" />
+								) : (
+									<HatGlassesIcon className="size-3" />
+								)}
+								{mode}
+							</PromptInputButton>
+							<Badge
+								className="rounded-sm px-3 py-1 text-xs hidden"
+								variant={status.includes("Error") ? "destructive" : "secondary"}
+							>
+								{status}
+							</Badge>
+						</PromptInputTools>
+						<div className="flex items-center gap-2">
+							{sending ? (
+								<Button onClick={onAbort} type="button" variant="destructive">
+									Abort
+								</Button>
+							) : null}
+							<PromptInputSubmit
+								disabled={disabled || status.includes("Failed")}
+								status={sending ? "submitted" : "ready"}
+								variant="ghost"
+							/>
+						</div>
+					</div>
+				</PromptInputFooter>
+			</PromptInput>
+		</div>
+	);
+}
+
+async function toImageDataUrl(
+	url: string | undefined,
+): Promise<string | undefined> {
+	if (!url) {
+		return undefined;
+	}
+	if (url.startsWith("data:image/")) {
+		return url;
+	}
+	if (!url.startsWith("blob:")) {
+		return undefined;
+	}
+	try {
+		const response = await fetch(url);
+		const blob = await response.blob();
+		if (!blob.type.startsWith("image/")) {
+			return undefined;
+		}
+		return await new Promise((resolve) => {
+			const reader = new FileReader();
+			reader.onloadend = () => {
+				resolve(typeof reader.result === "string" ? reader.result : undefined);
+			};
+			reader.onerror = () => resolve(undefined);
+			reader.readAsDataURL(blob);
+		});
+	} catch {
+		return undefined;
+	}
+}
diff --git a/apps/cline-hub/src/webview/src/components/TeamTasks.tsx b/apps/cline-hub/src/webview/src/components/TeamTasks.tsx
new file mode 100644
index 0000000..c703177
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/TeamTasks.tsx
@@ -0,0 +1,241 @@
+"use client";
+
+import { UsersIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	Task,
+	TaskContent,
+	TaskItem,
+	TaskTrigger,
+} from "@/components/ai-elements/task";
+
+export type TeamToolEvent = {
+	id: string;
+	name: string;
+	state: "input-available" | "output-available" | "output-error";
+	input?: unknown;
+	output?: unknown;
+	error?: string;
+};
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asStringArray(value: unknown): string[] | undefined {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: undefined;
+}
+
+function prefixForState(state: TeamToolEvent["state"]): string {
+	if (state === "output-error") {
+		return "Failed";
+	}
+	if (state === "output-available") {
+		return "Done";
+	}
+	return "Running";
+}
+
+function summarizeTeamTool(event: TeamToolEvent): ReactNode {
+	const input = asRecord(event.input);
+	const output = asRecord(event.output);
+	const statePrefix = prefixForState(event.state);
+
+	switch (event.name) {
+		case "team_spawn_teammate":
+			return `${statePrefix} spawn teammate ${asString(input?.agentId) ?? asString(output?.agentId) ?? "agent"}`;
+		case "team_shutdown_teammate":
+			return `${statePrefix} shutdown teammate ${asString(input?.agentId) ?? asString(output?.agentId) ?? "agent"}`;
+		case "team_status":
+			return `${statePrefix} fetch team status`;
+		case "team_task": {
+			const action = asString(input?.action);
+			if (action === "create") {
+				return `${statePrefix} create task ${asString(output?.taskId) ?? ""}${asString(input?.title) ? `: ${asString(input?.title)}` : ""}`.trim();
+			}
+			if (action === "list") {
+				return `${statePrefix} list team tasks`;
+			}
+			if (action === "claim") {
+				return `${statePrefix} claim task ${asString(input?.taskId) ?? asString(output?.taskId) ?? ""}`.trim();
+			}
+			if (action === "complete") {
+				return `${statePrefix} complete task ${asString(input?.taskId) ?? asString(output?.taskId) ?? ""}`.trim();
+			}
+			if (action === "block") {
+				return `${statePrefix} block task ${asString(input?.taskId) ?? asString(output?.taskId) ?? ""}`.trim();
+			}
+			return `${statePrefix} update team task`;
+		}
+		case "team_run_task": {
+			const agentId =
+				asString(input?.agentId) ?? asString(output?.agentId) ?? "agent";
+			const mode = asString(output?.mode) ?? asString(input?.runMode);
+			const status = asString(output?.status);
+			const task = asString(input?.task);
+			const suffix = task ? `: ${task}` : "";
+			const action =
+				mode === "async" ? "queue" : status === "joined" ? "join" : "run";
+			const state = status ? ` (${status})` : "";
+			return `${statePrefix} ${action} task with ${agentId}${state}${suffix}`;
+		}
+		case "team_cancel_run":
+			return `${statePrefix} cancel run ${asString(input?.runId) ?? asString(output?.runId) ?? ""}`.trim();
+		case "team_list_runs":
+			return `${statePrefix} list teammate runs`;
+		case "team_await_run":
+			return `${statePrefix} await run ${asString(input?.runId) ?? ""}`.trim();
+		case "team_await_all_runs":
+			return `${statePrefix} await all active runs`;
+		case "team_send_message":
+			return `${statePrefix} message ${asString(input?.toAgentId) ?? asString(output?.toAgentId) ?? "agent"}${asString(input?.subject) ? `: ${asString(input?.subject)}` : ""}`;
+		case "team_broadcast":
+			return `${statePrefix} broadcast${asString(input?.subject) ? `: ${asString(input?.subject)}` : ""}`;
+		case "team_read_mailbox":
+			return `${statePrefix} read mailbox`;
+		case "team_mission_log":
+			return `${statePrefix} log ${asString(input?.kind) ?? "update"}${asString(input?.summary) ? `: ${asString(input?.summary)}` : ""}`;
+		case "team_cleanup":
+			return `${statePrefix} clean up team runtime`;
+		case "team_create_outcome":
+			return `${statePrefix} create outcome${asString(input?.title) ? `: ${asString(input?.title)}` : ""}`;
+		case "team_attach_outcome_fragment":
+			return `${statePrefix} attach fragment to ${asString(input?.section) ?? "section"}`;
+		case "team_review_outcome_fragment":
+			return `${statePrefix} ${input?.approved === false ? "reject" : "review"} fragment ${asString(input?.fragmentId) ?? ""}`.trim();
+		case "team_finalize_outcome":
+			return `${statePrefix} finalize outcome ${asString(input?.outcomeId) ?? asString(output?.outcomeId) ?? ""}`.trim();
+		case "team_list_outcomes":
+			return `${statePrefix} list outcomes`;
+		default:
+			return `${statePrefix} ${event.name.replace(/^team_/, "").replaceAll("_", " ")}`;
+	}
+}
+
+function describeTeamTool(event: TeamToolEvent): string | undefined {
+	if (event.error) {
+		return event.error;
+	}
+
+	const input = asRecord(event.input);
+	const output = asRecord(event.output);
+
+	switch (event.name) {
+		case "team_task": {
+			const action = asString(input?.action);
+			if (action === "create") {
+				return asString(input?.description);
+			}
+			if (action === "block") {
+				return asString(input?.reason);
+			}
+			if (action === "list") {
+				const tasks = Array.isArray(output?.tasks)
+					? output.tasks.length
+					: undefined;
+				return typeof tasks === "number"
+					? `${tasks} task${tasks === 1 ? "" : "s"}`
+					: undefined;
+			}
+			return undefined;
+		}
+		case "team_run_task":
+			return (
+				asString(output?.message) ??
+				asString(output?.runId) ??
+				asString(output?.text)
+			);
+		case "team_send_message":
+		case "team_broadcast":
+			return asString(input?.body);
+		case "team_mission_log":
+			return asString(input?.nextAction) ?? asString(input?.summary);
+		case "team_attach_outcome_fragment":
+			return asString(input?.content);
+		case "team_status": {
+			const members = Array.isArray(output?.members)
+				? output.members.length
+				: undefined;
+			const tasks = Array.isArray(output?.tasks)
+				? output.tasks.length
+				: undefined;
+			const runs = Array.isArray(output?.runs) ? output.runs.length : undefined;
+			const parts = [
+				typeof members === "number" ? `${members} members` : undefined,
+				typeof tasks === "number" ? `${tasks} tasks` : undefined,
+				typeof runs === "number" ? `${runs} runs` : undefined,
+			].filter(Boolean);
+			return parts.join(" • ") || undefined;
+		}
+		case "team_list_runs": {
+			const runs = Array.isArray(event.output) ? event.output : undefined;
+			if (!runs?.length) {
+				return "No runs";
+			}
+			return `${runs.length} run${runs.length === 1 ? "" : "s"}`;
+		}
+		case "team_read_mailbox": {
+			const messages = Array.isArray(event.output) ? event.output : undefined;
+			if (!messages?.length) {
+				return "No messages";
+			}
+			return `${messages.length} message${messages.length === 1 ? "" : "s"}`;
+		}
+		case "team_create_outcome": {
+			const sections = asStringArray(input?.requiredSections);
+			return sections?.length ? sections.join(", ") : undefined;
+		}
+		default:
+			return undefined;
+	}
+}
+
+export default function TeamTasks({
+	className,
+	defaultOpen = true,
+	events,
+	...props
+}: Omit<ComponentProps<typeof Task>, "children"> & {
+	events: TeamToolEvent[];
+}) {
+	if (events.length === 0) {
+		return null;
+	}
+
+	const title =
+		events.length === 1 ? "Team activity" : `Team activity (${events.length})`;
+
+	return (
+		<Task className={className} defaultOpen={defaultOpen} {...props}>
+			<TaskTrigger title={title}>
+				<div className="flex w-full cursor-pointer items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground">
+					<UsersIcon className="size-4" />
+					<p className="text-sm">{title}</p>
+				</div>
+			</TaskTrigger>
+			<TaskContent>
+				{events.map((event) => {
+					const description = describeTeamTool(event);
+					return (
+						<TaskItem className="space-y-1" key={event.id}>
+							<div>{summarizeTeamTool(event)}</div>
+							{description ? (
+								<div className="line-clamp-3 text-xs text-muted-foreground/90">
+									{description}
+								</div>
+							) : null}
+						</TaskItem>
+					);
+				})}
+			</TaskContent>
+		</Task>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/agent.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/agent.tsx
new file mode 100644
index 0000000..51b62c3
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/agent.tsx
@@ -0,0 +1,141 @@
+"use client";
+
+import type { Tool } from "ai";
+import { BotIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { memo } from "react";
+import {
+	Accordion,
+	AccordionContent,
+	AccordionItem,
+	AccordionTrigger,
+} from "@/components/ui/accordion";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+import { CodeBlock } from "./code-block";
+
+export type AgentProps = ComponentProps<"div">;
+
+export const Agent = memo(({ className, ...props }: AgentProps) => (
+	<div
+		className={cn("not-prose w-full rounded-md border", className)}
+		{...props}
+	/>
+));
+
+export type AgentHeaderProps = ComponentProps<"div"> & {
+	name: string;
+	model?: string;
+};
+
+export const AgentHeader = memo(
+	({ className, name, model, ...props }: AgentHeaderProps) => (
+		<div
+			className={cn(
+				"flex w-full items-center justify-between gap-4 p-3",
+				className,
+			)}
+			{...props}
+		>
+			<div className="flex items-center gap-2">
+				<BotIcon className="size-4 text-muted-foreground" />
+				<span className="font-medium text-sm">{name}</span>
+				{model && (
+					<Badge className="font-mono text-xs" variant="secondary">
+						{model}
+					</Badge>
+				)}
+			</div>
+		</div>
+	),
+);
+
+export type AgentContentProps = ComponentProps<"div">;
+
+export const AgentContent = memo(
+	({ className, ...props }: AgentContentProps) => (
+		<div className={cn("space-y-4 p-4 pt-0", className)} {...props} />
+	),
+);
+
+export type AgentInstructionsProps = ComponentProps<"div"> & {
+	children: string;
+};
+
+export const AgentInstructions = memo(
+	({ className, children, ...props }: AgentInstructionsProps) => (
+		<div className={cn("space-y-2", className)} {...props}>
+			<span className="font-medium text-muted-foreground text-sm">
+				Instructions
+			</span>
+			<div className="rounded-md bg-muted/50 p-3 text-muted-foreground text-sm">
+				<p>{children}</p>
+			</div>
+		</div>
+	),
+);
+
+export type AgentToolsProps = ComponentProps<typeof Accordion>;
+
+export const AgentTools = memo(({ className, ...props }: AgentToolsProps) => (
+	<div className={cn("space-y-2", className)}>
+		<span className="font-medium text-muted-foreground text-sm">Tools</span>
+		<Accordion className="rounded-md border" {...props} />
+	</div>
+));
+
+export type AgentToolProps = ComponentProps<typeof AccordionItem> & {
+	tool: Tool;
+};
+
+export const AgentTool = memo(
+	({ className, tool, value, ...props }: AgentToolProps) => {
+		const schema =
+			"jsonSchema" in tool && tool.jsonSchema
+				? tool.jsonSchema
+				: tool.inputSchema;
+
+		return (
+			<AccordionItem
+				className={cn("border-b last:border-b-0", className)}
+				value={value}
+				{...props}
+			>
+				<AccordionTrigger className="px-3 py-2 text-sm hover:no-underline">
+					{tool.description ?? "No description"}
+				</AccordionTrigger>
+				<AccordionContent className="px-3 pb-3">
+					<div className="rounded-md bg-muted/50">
+						<CodeBlock code={JSON.stringify(schema, null, 2)} language="json" />
+					</div>
+				</AccordionContent>
+			</AccordionItem>
+		);
+	},
+);
+
+export type AgentOutputProps = ComponentProps<"div"> & {
+	schema: string;
+};
+
+export const AgentOutput = memo(
+	({ className, schema, ...props }: AgentOutputProps) => (
+		<div className={cn("space-y-2", className)} {...props}>
+			<span className="font-medium text-muted-foreground text-sm">
+				Output Schema
+			</span>
+			<div className="rounded-md bg-muted/50">
+				<CodeBlock code={schema} language="typescript" />
+			</div>
+		</div>
+	),
+);
+
+Agent.displayName = "Agent";
+AgentHeader.displayName = "AgentHeader";
+AgentContent.displayName = "AgentContent";
+AgentInstructions.displayName = "AgentInstructions";
+AgentTools.displayName = "AgentTools";
+AgentTool.displayName = "AgentTool";
+AgentOutput.displayName = "AgentOutput";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/artifact.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/artifact.tsx
new file mode 100644
index 0000000..6005180
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/artifact.tsx
@@ -0,0 +1,148 @@
+"use client";
+
+import type { LucideIcon } from "lucide-react";
+import { XIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export type ArtifactProps = HTMLAttributes<HTMLDivElement>;
+
+export const Artifact = ({ className, ...props }: ArtifactProps) => (
+	<div
+		className={cn(
+			"flex flex-col overflow-hidden rounded-lg border bg-background shadow-sm",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ArtifactHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const ArtifactHeader = ({
+	className,
+	...props
+}: ArtifactHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b bg-muted/50 px-4 py-3",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ArtifactCloseProps = ComponentProps<typeof Button>;
+
+export const ArtifactClose = ({
+	className,
+	children,
+	size = "sm",
+	variant = "ghost",
+	...props
+}: ArtifactCloseProps) => (
+	<Button
+		className={cn(
+			"size-8 p-0 text-muted-foreground hover:text-foreground",
+			className,
+		)}
+		size={size}
+		type="button"
+		variant={variant}
+		{...props}
+	>
+		{children ?? <XIcon className="size-4" />}
+		<span className="sr-only">Close</span>
+	</Button>
+);
+
+export type ArtifactTitleProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const ArtifactTitle = ({ className, ...props }: ArtifactTitleProps) => (
+	<p
+		className={cn("font-medium text-foreground text-sm", className)}
+		{...props}
+	/>
+);
+
+export type ArtifactDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const ArtifactDescription = ({
+	className,
+	...props
+}: ArtifactDescriptionProps) => (
+	<p className={cn("text-muted-foreground text-sm", className)} {...props} />
+);
+
+export type ArtifactActionsProps = HTMLAttributes<HTMLDivElement>;
+
+export const ArtifactActions = ({
+	className,
+	...props
+}: ArtifactActionsProps) => (
+	<div className={cn("flex items-center gap-1", className)} {...props} />
+);
+
+export type ArtifactActionProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+	label?: string;
+	icon?: LucideIcon;
+};
+
+export const ArtifactAction = ({
+	tooltip,
+	label,
+	icon: Icon,
+	children,
+	className,
+	size = "sm",
+	variant = "ghost",
+	...props
+}: ArtifactActionProps) => {
+	const button = (
+		<Button
+			className={cn(
+				"size-8 p-0 text-muted-foreground hover:text-foreground",
+				className,
+			)}
+			size={size}
+			type="button"
+			variant={variant}
+			{...props}
+		>
+			{Icon ? <Icon className="size-4" /> : children}
+			<span className="sr-only">{label || tooltip}</span>
+		</Button>
+	);
+
+	if (tooltip) {
+		return (
+			<TooltipProvider>
+				<Tooltip>
+					<TooltipTrigger>{button}</TooltipTrigger>
+					<TooltipContent>
+						<p>{tooltip}</p>
+					</TooltipContent>
+				</Tooltip>
+			</TooltipProvider>
+		);
+	}
+
+	return button;
+};
+
+export type ArtifactContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const ArtifactContent = ({
+	className,
+	...props
+}: ArtifactContentProps) => (
+	<div className={cn("flex-1 overflow-auto p-4", className)} {...props} />
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/attachments.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/attachments.tsx
new file mode 100644
index 0000000..dcf2285
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/attachments.tsx
@@ -0,0 +1,425 @@
+"use client";
+
+import type { FileUIPart, SourceDocumentUIPart } from "ai";
+import {
+	FileTextIcon,
+	GlobeIcon,
+	ImageIcon,
+	Music2Icon,
+	PaperclipIcon,
+	VideoIcon,
+	XIcon,
+} from "lucide-react";
+import type { ComponentProps, HTMLAttributes, ReactNode } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { cn } from "@/lib/utils";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type AttachmentData =
+	| (FileUIPart & { id: string })
+	| (SourceDocumentUIPart & { id: string });
+
+export type AttachmentMediaCategory =
+	| "image"
+	| "video"
+	| "audio"
+	| "document"
+	| "source"
+	| "unknown";
+
+export type AttachmentVariant = "grid" | "inline" | "list";
+
+const mediaCategoryIcons: Record<AttachmentMediaCategory, typeof ImageIcon> = {
+	audio: Music2Icon,
+	document: FileTextIcon,
+	image: ImageIcon,
+	source: GlobeIcon,
+	unknown: PaperclipIcon,
+	video: VideoIcon,
+};
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+export const getMediaCategory = (
+	data: AttachmentData,
+): AttachmentMediaCategory => {
+	if (data.type === "source-document") {
+		return "source";
+	}
+
+	const mediaType = data.mediaType ?? "";
+
+	if (mediaType.startsWith("image/")) {
+		return "image";
+	}
+	if (mediaType.startsWith("video/")) {
+		return "video";
+	}
+	if (mediaType.startsWith("audio/")) {
+		return "audio";
+	}
+	if (mediaType.startsWith("application/") || mediaType.startsWith("text/")) {
+		return "document";
+	}
+
+	return "unknown";
+};
+
+export const getAttachmentLabel = (data: AttachmentData): string => {
+	if (data.type === "source-document") {
+		return data.title || data.filename || "Source";
+	}
+
+	const category = getMediaCategory(data);
+	return data.filename || (category === "image" ? "Image" : "Attachment");
+};
+
+const renderAttachmentImage = (
+	url: string,
+	filename: string | undefined,
+	isGrid: boolean,
+) =>
+	isGrid ? (
+		<img
+			alt={filename || "Image"}
+			className="size-full object-cover"
+			height={96}
+			src={url}
+			width={96}
+		/>
+	) : (
+		<img
+			alt={filename || "Image"}
+			className="size-full rounded object-cover"
+			height={20}
+			src={url}
+			width={20}
+		/>
+	);
+
+// ============================================================================
+// Contexts
+// ============================================================================
+
+interface AttachmentsContextValue {
+	variant: AttachmentVariant;
+}
+
+const AttachmentsContext = createContext<AttachmentsContextValue | null>(null);
+
+interface AttachmentContextValue {
+	data: AttachmentData;
+	mediaCategory: AttachmentMediaCategory;
+	onRemove?: () => void;
+	variant: AttachmentVariant;
+}
+
+const AttachmentContext = createContext<AttachmentContextValue | null>(null);
+
+// ============================================================================
+// Hooks
+// ============================================================================
+
+export const useAttachmentsContext = () =>
+	useContext(AttachmentsContext) ?? { variant: "grid" as const };
+
+export const useAttachmentContext = () => {
+	const ctx = useContext(AttachmentContext);
+	if (!ctx) {
+		throw new Error("Attachment components must be used within <Attachment>");
+	}
+	return ctx;
+};
+
+// ============================================================================
+// Attachments - Container
+// ============================================================================
+
+export type AttachmentsProps = HTMLAttributes<HTMLDivElement> & {
+	variant?: AttachmentVariant;
+};
+
+export const Attachments = ({
+	variant = "grid",
+	className,
+	children,
+	...props
+}: AttachmentsProps) => {
+	const contextValue = useMemo(() => ({ variant }), [variant]);
+
+	return (
+		<AttachmentsContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex items-start",
+					variant === "list" ? "flex-col gap-2" : "flex-wrap gap-2",
+					variant === "grid" && "ml-auto w-fit",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		</AttachmentsContext.Provider>
+	);
+};
+
+// ============================================================================
+// Attachment - Item
+// ============================================================================
+
+export type AttachmentProps = HTMLAttributes<HTMLDivElement> & {
+	data: AttachmentData;
+	onRemove?: () => void;
+};
+
+export const Attachment = ({
+	data,
+	onRemove,
+	className,
+	children,
+	...props
+}: AttachmentProps) => {
+	const { variant } = useAttachmentsContext();
+	const mediaCategory = getMediaCategory(data);
+
+	const contextValue = useMemo<AttachmentContextValue>(
+		() => ({ data, mediaCategory, onRemove, variant }),
+		[data, mediaCategory, onRemove, variant],
+	);
+
+	return (
+		<AttachmentContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"group relative",
+					variant === "grid" && "size-24 overflow-hidden rounded-lg",
+					variant === "inline" && [
+						"flex h-8 cursor-pointer select-none items-center gap-1.5",
+						"rounded-md border border-border px-1.5",
+						"font-medium text-sm transition-all",
+						"hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+					],
+					variant === "list" && [
+						"flex w-full items-center gap-3 rounded-lg border p-3",
+						"hover:bg-accent/50",
+					],
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		</AttachmentContext.Provider>
+	);
+};
+
+// ============================================================================
+// AttachmentPreview - Media preview
+// ============================================================================
+
+export type AttachmentPreviewProps = HTMLAttributes<HTMLDivElement> & {
+	fallbackIcon?: ReactNode;
+};
+
+export const AttachmentPreview = ({
+	fallbackIcon,
+	className,
+	...props
+}: AttachmentPreviewProps) => {
+	const { data, mediaCategory, variant } = useAttachmentContext();
+
+	const iconSize = variant === "inline" ? "size-3" : "size-4";
+
+	const renderIcon = (Icon: typeof ImageIcon) => (
+		<Icon className={cn(iconSize, "text-muted-foreground")} />
+	);
+
+	const renderContent = () => {
+		if (mediaCategory === "image" && data.type === "file" && data.url) {
+			return renderAttachmentImage(data.url, data.filename, variant === "grid");
+		}
+
+		if (mediaCategory === "video" && data.type === "file" && data.url) {
+			return <video className="size-full object-cover" muted src={data.url} />;
+		}
+
+		const Icon = mediaCategoryIcons[mediaCategory];
+		return fallbackIcon ?? renderIcon(Icon);
+	};
+
+	return (
+		<div
+			className={cn(
+				"flex shrink-0 items-center justify-center overflow-hidden",
+				variant === "grid" && "size-full bg-muted",
+				variant === "inline" && "size-5 rounded bg-background",
+				variant === "list" && "size-12 rounded bg-muted",
+				className,
+			)}
+			{...props}
+		>
+			{renderContent()}
+		</div>
+	);
+};
+
+// ============================================================================
+// AttachmentInfo - Name and type display
+// ============================================================================
+
+export type AttachmentInfoProps = HTMLAttributes<HTMLDivElement> & {
+	showMediaType?: boolean;
+};
+
+export const AttachmentInfo = ({
+	showMediaType = false,
+	className,
+	...props
+}: AttachmentInfoProps) => {
+	const { data, variant } = useAttachmentContext();
+	const label = getAttachmentLabel(data);
+
+	if (variant === "grid") {
+		return null;
+	}
+
+	return (
+		<div className={cn("min-w-0 flex-1", className)} {...props}>
+			<span className="block truncate">{label}</span>
+			{showMediaType && data.mediaType && (
+				<span className="block truncate text-muted-foreground text-xs">
+					{data.mediaType}
+				</span>
+			)}
+		</div>
+	);
+};
+
+// ============================================================================
+// AttachmentRemove - Remove button
+// ============================================================================
+
+export type AttachmentRemoveProps = ComponentProps<typeof Button> & {
+	label?: string;
+};
+
+export const AttachmentRemove = ({
+	label = "Remove",
+	className,
+	children,
+	...props
+}: AttachmentRemoveProps) => {
+	const { onRemove, variant } = useAttachmentContext();
+
+	const handleClick = useCallback(
+		(e: React.MouseEvent) => {
+			e.stopPropagation();
+			onRemove?.();
+		},
+		[onRemove],
+	);
+
+	if (!onRemove) {
+		return null;
+	}
+
+	return (
+		<Button
+			aria-label={label}
+			className={cn(
+				variant === "grid" && [
+					"absolute top-2 right-2 size-6 rounded-full p-0",
+					"bg-background/80 backdrop-blur-sm",
+					"opacity-0 transition-opacity group-hover:opacity-100",
+					"hover:bg-background",
+					"[&>svg]:size-3",
+				],
+				variant === "inline" && [
+					"size-5 rounded p-0",
+					"opacity-0 transition-opacity group-hover:opacity-100",
+					"[&>svg]:size-2.5",
+				],
+				variant === "list" && ["size-8 shrink-0 rounded p-0", "[&>svg]:size-4"],
+				className,
+			)}
+			onClick={handleClick}
+			type="button"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <XIcon />}
+			<span className="sr-only">{label}</span>
+		</Button>
+	);
+};
+
+// ============================================================================
+// AttachmentHoverCard - Hover preview
+// ============================================================================
+
+export type AttachmentHoverCardProps = ComponentProps<typeof HoverCard> & {
+	openDelay?: number;
+	closeDelay?: number;
+};
+
+export const AttachmentHoverCard = ({ ...props }: AttachmentHoverCardProps) => (
+	<HoverCard {...props} />
+);
+
+export type AttachmentHoverCardTriggerProps = ComponentProps<
+	typeof HoverCardTrigger
+>;
+
+export const AttachmentHoverCardTrigger = (
+	props: AttachmentHoverCardTriggerProps,
+) => <HoverCardTrigger {...props} />;
+
+export type AttachmentHoverCardContentProps = ComponentProps<
+	typeof HoverCardContent
+>;
+
+export const AttachmentHoverCardContent = ({
+	align = "start",
+	className,
+	...props
+}: AttachmentHoverCardContentProps) => (
+	<HoverCardContent
+		align={align}
+		className={cn("w-auto p-2", className)}
+		{...props}
+	/>
+);
+
+// ============================================================================
+// AttachmentEmpty - Empty state
+// ============================================================================
+
+export type AttachmentEmptyProps = HTMLAttributes<HTMLDivElement>;
+
+export const AttachmentEmpty = ({
+	className,
+	children,
+	...props
+}: AttachmentEmptyProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-center p-4 text-muted-foreground text-sm",
+			className,
+		)}
+		{...props}
+	>
+		{children ?? "No attachments"}
+	</div>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/audio-player.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/audio-player.tsx
new file mode 100644
index 0000000..8181f7f
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/audio-player.tsx
@@ -0,0 +1,255 @@
+"use client";
+
+import type { Experimental_SpeechResult as SpeechResult } from "ai";
+import {
+	MediaControlBar,
+	MediaController,
+	MediaDurationDisplay,
+	MediaMuteButton,
+	MediaPlayButton,
+	MediaSeekBackwardButton,
+	MediaSeekForwardButton,
+	MediaTimeDisplay,
+	MediaTimeRange,
+	MediaVolumeRange,
+} from "media-chrome/react";
+import type { ComponentProps, CSSProperties } from "react";
+import { Button } from "@/components/ui/button";
+import { ButtonGroup, ButtonGroupText } from "@/components/ui/button-group";
+import { cn } from "@/lib/utils";
+
+export type AudioPlayerProps = Omit<
+	ComponentProps<typeof MediaController>,
+	"audio"
+>;
+
+export const AudioPlayer = ({
+	children,
+	style,
+	...props
+}: AudioPlayerProps) => (
+	<MediaController
+		audio
+		data-slot="audio-player"
+		style={
+			{
+				"--media-background-color": "transparent",
+				"--media-button-icon-height": "1rem",
+				"--media-button-icon-width": "1rem",
+				"--media-control-background": "transparent",
+				"--media-control-hover-background": "var(--color-accent)",
+				"--media-control-padding": "0",
+				"--media-font": "var(--font-sans)",
+				"--media-font-size": "10px",
+				"--media-icon-color": "currentColor",
+				"--media-preview-time-background": "var(--color-background)",
+				"--media-preview-time-border-radius": "var(--radius-md)",
+				"--media-preview-time-text-shadow": "none",
+				"--media-primary-color": "var(--color-primary)",
+				"--media-range-bar-color": "var(--color-primary)",
+				"--media-range-track-background": "var(--color-secondary)",
+				"--media-secondary-color": "var(--color-secondary)",
+				"--media-text-color": "var(--color-foreground)",
+				"--media-tooltip-arrow-display": "none",
+				"--media-tooltip-background": "var(--color-background)",
+				"--media-tooltip-border-radius": "var(--radius-md)",
+				...style,
+			} as CSSProperties
+		}
+		{...props}
+	>
+		{children}
+	</MediaController>
+);
+
+export type AudioPlayerElementProps = Omit<ComponentProps<"audio">, "src"> &
+	(
+		| {
+				data: SpeechResult["audio"];
+		  }
+		| {
+				src: string;
+		  }
+	);
+
+export const AudioPlayerElement = ({ ...props }: AudioPlayerElementProps) => (
+	// oxlint-disable-next-line eslint-plugin-jsx-a11y(media-has-caption) -- audio player captions are provided by consumer
+	<audio
+		data-slot="audio-player-element"
+		slot="media"
+		src={
+			"src" in props
+				? props.src
+				: `data:${props.data.mediaType};base64,${props.data.base64}`
+		}
+		{...props}
+	/>
+);
+
+export type AudioPlayerControlBarProps = ComponentProps<typeof MediaControlBar>;
+
+export const AudioPlayerControlBar = ({
+	children,
+	...props
+}: AudioPlayerControlBarProps) => (
+	<MediaControlBar data-slot="audio-player-control-bar" {...props}>
+		<ButtonGroup orientation="horizontal">{children}</ButtonGroup>
+	</MediaControlBar>
+);
+
+export type AudioPlayerPlayButtonProps = ComponentProps<typeof MediaPlayButton>;
+
+export const AudioPlayerPlayButton = ({
+	className,
+	...props
+}: AudioPlayerPlayButtonProps) => (
+	<Button
+		size="icon-sm"
+		variant="outline"
+		render={
+			<MediaPlayButton
+				className={cn("bg-transparent", className)}
+				data-slot="audio-player-play-button"
+				{...props}
+			/>
+		}
+	></Button>
+);
+
+export type AudioPlayerSeekBackwardButtonProps = ComponentProps<
+	typeof MediaSeekBackwardButton
+>;
+
+export const AudioPlayerSeekBackwardButton = ({
+	seekOffset = 10,
+	...props
+}: AudioPlayerSeekBackwardButtonProps) => (
+	<Button
+		size="icon-sm"
+		variant="outline"
+		render={
+			<MediaSeekBackwardButton
+				data-slot="audio-player-seek-backward-button"
+				seekOffset={seekOffset}
+				{...props}
+			/>
+		}
+	></Button>
+);
+
+export type AudioPlayerSeekForwardButtonProps = ComponentProps<
+	typeof MediaSeekForwardButton
+>;
+
+export const AudioPlayerSeekForwardButton = ({
+	seekOffset = 10,
+	...props
+}: AudioPlayerSeekForwardButtonProps) => (
+	<Button
+		size="icon-sm"
+		variant="outline"
+		render={
+			<MediaSeekForwardButton
+				data-slot="audio-player-seek-forward-button"
+				seekOffset={seekOffset}
+				{...props}
+			/>
+		}
+	></Button>
+);
+
+export type AudioPlayerTimeDisplayProps = ComponentProps<
+	typeof MediaTimeDisplay
+>;
+
+export const AudioPlayerTimeDisplay = ({
+	className,
+	...props
+}: AudioPlayerTimeDisplayProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaTimeDisplay
+				className={cn("tabular-nums", className)}
+				data-slot="audio-player-time-display"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerTimeRangeProps = ComponentProps<typeof MediaTimeRange>;
+
+export const AudioPlayerTimeRange = ({
+	className,
+	...props
+}: AudioPlayerTimeRangeProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaTimeRange
+				className={cn("", className)}
+				data-slot="audio-player-time-range"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerDurationDisplayProps = ComponentProps<
+	typeof MediaDurationDisplay
+>;
+
+export const AudioPlayerDurationDisplay = ({
+	className,
+	...props
+}: AudioPlayerDurationDisplayProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaDurationDisplay
+				className={cn("tabular-nums", className)}
+				data-slot="audio-player-duration-display"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerMuteButtonProps = ComponentProps<typeof MediaMuteButton>;
+
+export const AudioPlayerMuteButton = ({
+	className,
+	...props
+}: AudioPlayerMuteButtonProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaMuteButton
+				className={cn("", className)}
+				data-slot="audio-player-mute-button"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerVolumeRangeProps = ComponentProps<
+	typeof MediaVolumeRange
+>;
+
+export const AudioPlayerVolumeRange = ({
+	className,
+	...props
+}: AudioPlayerVolumeRangeProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaVolumeRange
+				className={cn("", className)}
+				data-slot="audio-player-volume-range"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/canvas.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/canvas.tsx
new file mode 100644
index 0000000..be0eb8c
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/canvas.tsx
@@ -0,0 +1,26 @@
+import type { ReactFlowProps } from "@xyflow/react";
+import { Background, ReactFlow } from "@xyflow/react";
+import type { ReactNode } from "react";
+
+import "@xyflow/react/dist/style.css";
+
+type CanvasProps = ReactFlowProps & {
+	children?: ReactNode;
+};
+
+const deleteKeyCode = ["Backspace", "Delete"];
+
+export const Canvas = ({ children, ...props }: CanvasProps) => (
+	<ReactFlow
+		deleteKeyCode={deleteKeyCode}
+		fitView
+		panOnDrag={false}
+		panOnScroll
+		selectionOnDrag={true}
+		zoomOnDoubleClick={false}
+		{...props}
+	>
+		<Background bgColor="var(--sidebar)" />
+		{children}
+	</ReactFlow>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/chain-of-thought.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/chain-of-thought.tsx
new file mode 100644
index 0000000..a668118
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/chain-of-thought.tsx
@@ -0,0 +1,222 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import type { LucideIcon } from "lucide-react";
+import { BrainIcon, ChevronDownIcon, DotIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, memo, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+interface ChainOfThoughtContextValue {
+	isOpen: boolean;
+	setIsOpen: (open: boolean) => void;
+}
+
+const ChainOfThoughtContext = createContext<ChainOfThoughtContextValue | null>(
+	null,
+);
+
+const useChainOfThought = () => {
+	const context = useContext(ChainOfThoughtContext);
+	if (!context) {
+		throw new Error(
+			"ChainOfThought components must be used within ChainOfThought",
+		);
+	}
+	return context;
+};
+
+export type ChainOfThoughtProps = ComponentProps<"div"> & {
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+};
+
+export const ChainOfThought = memo(
+	({
+		className,
+		open,
+		defaultOpen = false,
+		onOpenChange,
+		children,
+		...props
+	}: ChainOfThoughtProps) => {
+		const [isOpen, setIsOpen] = useControllableState({
+			defaultProp: defaultOpen,
+			onChange: onOpenChange,
+			prop: open,
+		});
+
+		const chainOfThoughtContext = useMemo(
+			() => ({ isOpen, setIsOpen }),
+			[isOpen, setIsOpen],
+		);
+
+		return (
+			<ChainOfThoughtContext.Provider value={chainOfThoughtContext}>
+				<div className={cn("not-prose w-full space-y-4", className)} {...props}>
+					{children}
+				</div>
+			</ChainOfThoughtContext.Provider>
+		);
+	},
+);
+
+export type ChainOfThoughtHeaderProps = ComponentProps<
+	typeof CollapsibleTrigger
+>;
+
+export const ChainOfThoughtHeader = memo(
+	({ className, children, ...props }: ChainOfThoughtHeaderProps) => {
+		const { isOpen, setIsOpen } = useChainOfThought();
+
+		return (
+			<Collapsible onOpenChange={setIsOpen} open={isOpen}>
+				<CollapsibleTrigger
+					className={cn(
+						"flex w-full items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground",
+						className,
+					)}
+					{...props}
+				>
+					<BrainIcon className="size-4" />
+					<span className="flex-1 text-left">
+						{children ?? "Chain of Thought"}
+					</span>
+					<ChevronDownIcon
+						className={cn(
+							"size-4 transition-transform",
+							isOpen ? "rotate-180" : "rotate-0",
+						)}
+					/>
+				</CollapsibleTrigger>
+			</Collapsible>
+		);
+	},
+);
+
+export type ChainOfThoughtStepProps = ComponentProps<"div"> & {
+	icon?: LucideIcon;
+	label: ReactNode;
+	description?: ReactNode;
+	status?: "complete" | "active" | "pending";
+};
+
+const stepStatusStyles = {
+	active: "text-foreground",
+	complete: "text-muted-foreground",
+	pending: "text-muted-foreground/50",
+};
+
+export const ChainOfThoughtStep = memo(
+	({
+		className,
+		icon: Icon = DotIcon,
+		label,
+		description,
+		status = "complete",
+		children,
+		...props
+	}: ChainOfThoughtStepProps) => (
+		<div
+			className={cn(
+				"flex gap-2 text-sm",
+				stepStatusStyles[status],
+				"fade-in-0 slide-in-from-top-2 animate-in",
+				className,
+			)}
+			{...props}
+		>
+			<div className="relative mt-0.5">
+				<Icon className="size-4" />
+				<div className="absolute top-7 bottom-0 left-1/2 -mx-px w-px bg-border" />
+			</div>
+			<div className="flex-1 space-y-2 overflow-hidden">
+				<div>{label}</div>
+				{description && (
+					<div className="text-muted-foreground text-xs">{description}</div>
+				)}
+				{children}
+			</div>
+		</div>
+	),
+);
+
+export type ChainOfThoughtSearchResultsProps = ComponentProps<"div">;
+
+export const ChainOfThoughtSearchResults = memo(
+	({ className, ...props }: ChainOfThoughtSearchResultsProps) => (
+		<div
+			className={cn("flex flex-wrap items-center gap-2", className)}
+			{...props}
+		/>
+	),
+);
+
+export type ChainOfThoughtSearchResultProps = ComponentProps<typeof Badge>;
+
+export const ChainOfThoughtSearchResult = memo(
+	({ className, children, ...props }: ChainOfThoughtSearchResultProps) => (
+		<Badge
+			className={cn("gap-1 px-2 py-0.5 font-normal text-xs", className)}
+			variant="secondary"
+			{...props}
+		>
+			{children}
+		</Badge>
+	),
+);
+
+export type ChainOfThoughtContentProps = ComponentProps<
+	typeof CollapsibleContent
+>;
+
+export const ChainOfThoughtContent = memo(
+	({ className, children, ...props }: ChainOfThoughtContentProps) => {
+		const { isOpen } = useChainOfThought();
+
+		return (
+			<Collapsible open={isOpen}>
+				<CollapsibleContent
+					className={cn(
+						"mt-2 space-y-3",
+						"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+				</CollapsibleContent>
+			</Collapsible>
+		);
+	},
+);
+
+export type ChainOfThoughtImageProps = ComponentProps<"div"> & {
+	caption?: string;
+};
+
+export const ChainOfThoughtImage = memo(
+	({ className, children, caption, ...props }: ChainOfThoughtImageProps) => (
+		<div className={cn("mt-2 space-y-2", className)} {...props}>
+			<div className="relative flex max-h-[22rem] items-center justify-center overflow-hidden rounded-lg bg-muted p-3">
+				{children}
+			</div>
+			{caption && <p className="text-muted-foreground text-xs">{caption}</p>}
+		</div>
+	),
+);
+
+ChainOfThought.displayName = "ChainOfThought";
+ChainOfThoughtHeader.displayName = "ChainOfThoughtHeader";
+ChainOfThoughtStep.displayName = "ChainOfThoughtStep";
+ChainOfThoughtSearchResults.displayName = "ChainOfThoughtSearchResults";
+ChainOfThoughtSearchResult.displayName = "ChainOfThoughtSearchResult";
+ChainOfThoughtContent.displayName = "ChainOfThoughtContent";
+ChainOfThoughtImage.displayName = "ChainOfThoughtImage";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/checkpoint.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/checkpoint.tsx
new file mode 100644
index 0000000..ba0bc30
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/checkpoint.tsx
@@ -0,0 +1,73 @@
+"use client";
+
+import type { LucideProps } from "lucide-react";
+import { BookmarkIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { Button } from "@/components/ui/button";
+import { Separator } from "@/components/ui/separator";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export type CheckpointProps = HTMLAttributes<HTMLDivElement>;
+
+export const Checkpoint = ({
+	className,
+	children,
+	...props
+}: CheckpointProps) => (
+	<div
+		className={cn(
+			"flex items-center gap-0.5 overflow-hidden text-muted-foreground",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+		<Separator />
+	</div>
+);
+
+export type CheckpointIconProps = LucideProps;
+
+export const CheckpointIcon = ({
+	className,
+	children,
+	...props
+}: CheckpointIconProps) =>
+	children ?? (
+		<BookmarkIcon className={cn("size-4 shrink-0", className)} {...props} />
+	);
+
+export type CheckpointTriggerProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+};
+
+export const CheckpointTrigger = ({
+	children,
+	variant = "ghost",
+	size = "sm",
+	tooltip,
+	...props
+}: CheckpointTriggerProps) =>
+	tooltip ? (
+		<Tooltip>
+			<TooltipTrigger
+				render={
+					<Button size={size} type="button" variant={variant} {...props} />
+				}
+			>
+				{children}
+			</TooltipTrigger>
+			<TooltipContent align="start" side="bottom">
+				{tooltip}
+			</TooltipContent>
+		</Tooltip>
+	) : (
+		<Button size={size} type="button" variant={variant} {...props}>
+			{children}
+		</Button>
+	);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/code-block.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/code-block.tsx
new file mode 100644
index 0000000..e428dd3
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/code-block.tsx
@@ -0,0 +1,652 @@
+import { CheckIcon, CopyIcon } from "lucide-react";
+import type { ComponentProps, CSSProperties, HTMLAttributes } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import type {
+	HighlighterCore,
+	LanguageRegistration,
+	ThemedToken,
+	ThemeRegistration,
+} from "shiki/core";
+import { createHighlighterCore } from "shiki/core";
+import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
+import { Button } from "@/components/ui/button";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { cn } from "@/lib/utils";
+
+// Shiki uses bitflags for font styles: 1=italic, 2=bold, 4=underline
+// oxlint-disable-next-line eslint(no-bitwise)
+const isItalic = (fontStyle: number | undefined) => fontStyle && fontStyle & 1;
+// oxlint-disable-next-line eslint(no-bitwise)
+const isBold = (fontStyle: number | undefined) => fontStyle && fontStyle & 2;
+const isUnderline = (fontStyle: number | undefined) =>
+	// oxlint-disable-next-line eslint(no-bitwise)
+	fontStyle && fontStyle & 4;
+
+const SUPPORTED_LANGUAGES = [
+	"bash",
+	"css",
+	"diff",
+	"html",
+	"javascript",
+	"json",
+	"jsonc",
+	"jsx",
+	"markdown",
+	"python",
+	"shellscript",
+	"tsx",
+	"typescript",
+	"yaml",
+] as const;
+
+export type SupportedCodeLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+
+const SUPPORTED_LANGUAGE_SET = new Set<string>(SUPPORTED_LANGUAGES);
+
+const LANGUAGE_LOADERS: Record<
+	SupportedCodeLanguage,
+	() => Promise<LanguageRegistration[]>
+> = {
+	bash: () => import("@shikijs/langs/bash").then((module) => module.default),
+	css: () => import("@shikijs/langs/css").then((module) => module.default),
+	diff: () => import("@shikijs/langs/diff").then((module) => module.default),
+	html: () => import("@shikijs/langs/html").then((module) => module.default),
+	javascript: () =>
+		import("@shikijs/langs/javascript").then((module) => module.default),
+	json: () => import("@shikijs/langs/json").then((module) => module.default),
+	jsonc: () => import("@shikijs/langs/jsonc").then((module) => module.default),
+	jsx: () => import("@shikijs/langs/jsx").then((module) => module.default),
+	markdown: () =>
+		import("@shikijs/langs/markdown").then((module) => module.default),
+	python: () =>
+		import("@shikijs/langs/python").then((module) => module.default),
+	shellscript: () =>
+		import("@shikijs/langs/shellscript").then((module) => module.default),
+	tsx: () => import("@shikijs/langs/tsx").then((module) => module.default),
+	typescript: () =>
+		import("@shikijs/langs/typescript").then((module) => module.default),
+	yaml: () => import("@shikijs/langs/yaml").then((module) => module.default),
+};
+
+const LANGUAGE_ALIASES: Record<string, SupportedCodeLanguage> = {
+	console: "shellscript",
+	cjs: "javascript",
+	htm: "html",
+	js: "javascript",
+	json5: "jsonc",
+	md: "markdown",
+	mjs: "javascript",
+	py: "python",
+	sh: "shellscript",
+	shell: "shellscript",
+	ts: "typescript",
+	yml: "yaml",
+};
+
+const normalizeLanguage = (
+	language: string,
+): SupportedCodeLanguage | "text" => {
+	const normalized = language.trim().toLowerCase();
+	if (!normalized) {
+		return "text";
+	}
+	const aliased = LANGUAGE_ALIASES[normalized] ?? normalized;
+	return SUPPORTED_LANGUAGE_SET.has(aliased) ? aliased : "text";
+};
+
+// Transform tokens to include pre-computed keys to avoid noArrayIndexKey lint
+interface KeyedToken {
+	token: ThemedToken;
+	key: string;
+}
+interface KeyedLine {
+	tokens: KeyedToken[];
+	key: string;
+}
+
+const addKeysToTokens = (lines: ThemedToken[][]): KeyedLine[] =>
+	lines.map((line, lineIdx) => ({
+		key: `line-${lineIdx}`,
+		tokens: line.map((token, tokenIdx) => ({
+			key: `line-${lineIdx}-${tokenIdx}`,
+			token,
+		})),
+	}));
+
+// Token rendering component
+const TokenSpan = ({ token }: { token: ThemedToken }) => (
+	<span
+		className="dark:bg-(--shiki-dark-bg)! dark:text-(--shiki-dark)!"
+		style={
+			{
+				backgroundColor: token.bgColor,
+				color: token.color,
+				fontStyle: isItalic(token.fontStyle) ? "italic" : undefined,
+				fontWeight: isBold(token.fontStyle) ? "bold" : undefined,
+				textDecoration: isUnderline(token.fontStyle) ? "underline" : undefined,
+				...token.htmlStyle,
+			} as CSSProperties
+		}
+	>
+		{token.content}
+	</span>
+);
+
+// Line number styles using CSS counters
+const LINE_NUMBER_CLASSES = cn(
+	"block",
+	"before:content-[counter(line)]",
+	"before:inline-block",
+	"before:[counter-increment:line]",
+	"before:w-8",
+	"before:mr-4",
+	"before:text-right",
+	"before:text-muted-foreground/50",
+	"before:font-mono",
+	"before:select-none",
+);
+
+// Line rendering component
+const LineSpan = ({
+	keyedLine,
+	showLineNumbers,
+}: {
+	keyedLine: KeyedLine;
+	showLineNumbers: boolean;
+}) => (
+	<span className={showLineNumbers ? LINE_NUMBER_CLASSES : "block"}>
+		{keyedLine.tokens.length === 0
+			? "\n"
+			: keyedLine.tokens.map(({ token, key }) => (
+					<TokenSpan key={key} token={token} />
+				))}
+	</span>
+);
+
+// Types
+type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
+	code: string;
+	language: string;
+	showLineNumbers?: boolean;
+};
+
+interface TokenizedCode {
+	tokens: ThemedToken[][];
+	fg: string;
+	bg: string;
+}
+
+interface CodeBlockContextType {
+	code: string;
+}
+
+// Context
+const CodeBlockContext = createContext<CodeBlockContextType>({
+	code: "",
+});
+
+// Highlighter cache (singleton per language)
+let highlighterPromise: Promise<HighlighterCore> | undefined;
+let themesPromise: Promise<void> | undefined;
+const languagePromises = new Map<SupportedCodeLanguage, Promise<void>>();
+
+// Token cache
+const tokensCache = new Map<string, TokenizedCode>();
+
+// Subscribers for async token updates
+const subscribers = new Map<string, Set<(result: TokenizedCode) => void>>();
+
+const getTokensCacheKey = (code: string, language: string) => {
+	const start = code.slice(0, 100);
+	const end = code.length > 100 ? code.slice(-100) : "";
+	return `${language}:${code.length}:${start}:${end}`;
+};
+
+const getHighlighter = (): Promise<HighlighterCore> => {
+	if (!highlighterPromise) {
+		highlighterPromise = createHighlighterCore({
+			engine: createJavaScriptRegexEngine({ forgiving: true }),
+		});
+	}
+	return highlighterPromise;
+};
+
+const ensureThemes = (highlighter: HighlighterCore): Promise<void> => {
+	if (!themesPromise) {
+		themesPromise = Promise.all([
+			import("@shikijs/themes/github-light").then((module) => module.default),
+			import("@shikijs/themes/github-dark").then((module) => module.default),
+		]).then((themes: ThemeRegistration[]) => highlighter.loadTheme(...themes));
+	}
+	return themesPromise;
+};
+
+const ensureLanguage = (
+	highlighter: HighlighterCore,
+	language: SupportedCodeLanguage,
+): Promise<void> => {
+	const cached = languagePromises.get(language);
+	if (cached) {
+		return cached;
+	}
+	const languagePromise = LANGUAGE_LOADERS[language]().then((registrations) =>
+		highlighter.loadLanguage(...registrations),
+	);
+	languagePromises.set(language, languagePromise);
+	return languagePromise;
+};
+
+// Create raw tokens for immediate display while highlighting loads
+const createRawTokens = (code: string): TokenizedCode => ({
+	bg: "transparent",
+	fg: "inherit",
+	tokens: code.split("\n").map((line) =>
+		line === ""
+			? []
+			: [
+					{
+						color: "inherit",
+						content: line,
+					} as ThemedToken,
+				],
+	),
+});
+
+// Synchronous highlight with callback for async results
+export const highlightCode = (
+	code: string,
+	language: string,
+	// oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-callbacks)
+	callback?: (result: TokenizedCode) => void,
+): TokenizedCode | null => {
+	const langToUse = normalizeLanguage(language);
+	if (langToUse === "text") {
+		return createRawTokens(code);
+	}
+
+	const tokensCacheKey = getTokensCacheKey(code, langToUse);
+
+	// Return cached result if available
+	const cached = tokensCache.get(tokensCacheKey);
+	if (cached) {
+		return cached;
+	}
+
+	// Subscribe callback if provided
+	if (callback) {
+		if (!subscribers.has(tokensCacheKey)) {
+			subscribers.set(tokensCacheKey, new Set());
+		}
+		subscribers.get(tokensCacheKey)?.add(callback);
+	}
+
+	// Start highlighting in background - fire-and-forget async pattern
+	getHighlighter()
+		// oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-then)
+		.then(async (highlighter) => {
+			await ensureThemes(highlighter);
+			await ensureLanguage(highlighter, langToUse);
+
+			const result = highlighter.codeToTokens(code, {
+				lang: langToUse,
+				themes: {
+					dark: "github-dark",
+					light: "github-light",
+				},
+			});
+
+			const tokenized: TokenizedCode = {
+				bg: result.bg ?? "transparent",
+				fg: result.fg ?? "inherit",
+				tokens: result.tokens,
+			};
+
+			// Cache the result
+			tokensCache.set(tokensCacheKey, tokenized);
+
+			// Notify all subscribers
+			const subs = subscribers.get(tokensCacheKey);
+			if (subs) {
+				for (const sub of subs) {
+					sub(tokenized);
+				}
+				subscribers.delete(tokensCacheKey);
+			}
+		})
+		// oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-then), eslint-plugin-promise(prefer-await-to-callbacks)
+		.catch((error) => {
+			console.error("Failed to highlight code:", error);
+			subscribers.delete(tokensCacheKey);
+		});
+
+	return null;
+};
+
+const CodeBlockBody = memo(
+	({
+		tokenized,
+		showLineNumbers,
+		className,
+	}: {
+		tokenized: TokenizedCode;
+		showLineNumbers: boolean;
+		className?: string;
+	}) => {
+		const preStyle = useMemo(
+			() => ({
+				backgroundColor: tokenized.bg,
+				color: tokenized.fg,
+			}),
+			[tokenized.bg, tokenized.fg],
+		);
+
+		const keyedLines = useMemo(
+			() => addKeysToTokens(tokenized.tokens),
+			[tokenized.tokens],
+		);
+
+		return (
+			<pre
+				className={cn(
+					"dark:bg-(--shiki-dark-bg)! dark:text-(--shiki-dark)! m-0 p-4 text-sm",
+					className,
+				)}
+				style={preStyle}
+			>
+				<code
+					className={cn(
+						"font-mono text-sm",
+						showLineNumbers &&
+							"[counter-increment:line_0] [counter-reset:line]",
+					)}
+				>
+					{keyedLines.map((keyedLine) => (
+						<LineSpan
+							key={keyedLine.key}
+							keyedLine={keyedLine}
+							showLineNumbers={showLineNumbers}
+						/>
+					))}
+				</code>
+			</pre>
+		);
+	},
+	(prevProps, nextProps) =>
+		prevProps.tokenized === nextProps.tokenized &&
+		prevProps.showLineNumbers === nextProps.showLineNumbers &&
+		prevProps.className === nextProps.className,
+);
+
+CodeBlockBody.displayName = "CodeBlockBody";
+
+export const CodeBlockContainer = ({
+	className,
+	language,
+	style,
+	...props
+}: HTMLAttributes<HTMLDivElement> & { language: string }) => (
+	<div
+		className={cn(
+			"group relative w-full overflow-hidden rounded-sm border bg-background text-foreground",
+			className,
+		)}
+		data-language={language}
+		style={{
+			containIntrinsicSize: "auto 200px",
+			contentVisibility: "auto",
+			...style,
+		}}
+		{...props}
+	/>
+);
+
+export const CodeBlockHeader = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLDivElement>) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b bg-muted/80 px-3 py-2 text-muted-foreground text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export const CodeBlockTitle = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLDivElement>) => (
+	<div className={cn("flex items-center gap-2", className)} {...props}>
+		{children}
+	</div>
+);
+
+export const CodeBlockFilename = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLSpanElement>) => (
+	<span className={cn("font-mono", className)} {...props}>
+		{children}
+	</span>
+);
+
+export const CodeBlockActions = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLDivElement>) => (
+	<div
+		className={cn("-my-1 -mr-1 flex items-center gap-2", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export const CodeBlockContent = ({
+	code,
+	language,
+	showLineNumbers = false,
+}: {
+	code: string;
+	language: string;
+	showLineNumbers?: boolean;
+}) => {
+	// Memoized raw tokens for immediate display
+	const rawTokens = useMemo(() => createRawTokens(code), [code]);
+
+	// Synchronous cache lookup — avoids setState in effect for cached results
+	const syncTokens = useMemo(
+		() => highlightCode(code, language) ?? rawTokens,
+		[code, language, rawTokens],
+	);
+
+	// Async highlighting — keyed by identity-stable memo so stale tokens are
+	// discarded without reading a ref during render or setState in effect body.
+	const asyncKey = useMemo(() => ({ code, language }), [code, language]);
+	const [asyncState, setAsyncState] = useState<{
+		key: { code: string; language: string };
+		tokens: TokenizedCode | null;
+	}>({ key: asyncKey, tokens: null });
+
+	const asyncTokens = asyncState.key === asyncKey ? asyncState.tokens : null;
+
+	useEffect(() => {
+		let cancelled = false;
+
+		highlightCode(code, language, (result) => {
+			if (!cancelled) {
+				setAsyncState({ key: asyncKey, tokens: result });
+			}
+		});
+
+		return () => {
+			cancelled = true;
+		};
+	}, [code, language, asyncKey]);
+
+	const tokenized = asyncTokens ?? syncTokens;
+
+	return (
+		<div className="relative overflow-auto">
+			<CodeBlockBody showLineNumbers={showLineNumbers} tokenized={tokenized} />
+		</div>
+	);
+};
+
+export const CodeBlock = ({
+	code,
+	language,
+	showLineNumbers = false,
+	className,
+	children,
+	...props
+}: CodeBlockProps) => {
+	const contextValue = useMemo(() => ({ code }), [code]);
+
+	return (
+		<CodeBlockContext.Provider value={contextValue}>
+			<CodeBlockContainer className={className} language={language} {...props}>
+				{children}
+				<CodeBlockContent
+					code={code}
+					language={language}
+					showLineNumbers={showLineNumbers}
+				/>
+			</CodeBlockContainer>
+		</CodeBlockContext.Provider>
+	);
+};
+
+export type CodeBlockCopyButtonProps = ComponentProps<typeof Button> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const CodeBlockCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: CodeBlockCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { code } = useContext(CodeBlockContext);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			if (!isCopied) {
+				await navigator.clipboard.writeText(code);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			}
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [code, onCopy, onError, timeout, isCopied]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn("shrink-0", className)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={14} />}
+		</Button>
+	);
+};
+
+export type CodeBlockLanguageSelectorProps = ComponentProps<typeof Select>;
+
+export const CodeBlockLanguageSelector = (
+	props: CodeBlockLanguageSelectorProps,
+) => <Select {...props} />;
+
+export type CodeBlockLanguageSelectorTriggerProps = ComponentProps<
+	typeof SelectTrigger
+>;
+
+export const CodeBlockLanguageSelectorTrigger = ({
+	className,
+	...props
+}: CodeBlockLanguageSelectorTriggerProps) => (
+	<SelectTrigger
+		className={cn(
+			"h-7 border-none bg-transparent px-2 text-xs shadow-none",
+			className,
+		)}
+		size="sm"
+		{...props}
+	/>
+);
+
+export type CodeBlockLanguageSelectorValueProps = ComponentProps<
+	typeof SelectValue
+>;
+
+export const CodeBlockLanguageSelectorValue = (
+	props: CodeBlockLanguageSelectorValueProps,
+) => <SelectValue {...props} />;
+
+export type CodeBlockLanguageSelectorContentProps = ComponentProps<
+	typeof SelectContent
+>;
+
+export const CodeBlockLanguageSelectorContent = ({
+	align = "end",
+	...props
+}: CodeBlockLanguageSelectorContentProps) => (
+	<SelectContent align={align} {...props} />
+);
+
+export type CodeBlockLanguageSelectorItemProps = ComponentProps<
+	typeof SelectItem
+>;
+
+export const CodeBlockLanguageSelectorItem = (
+	props: CodeBlockLanguageSelectorItemProps,
+) => <SelectItem {...props} />;
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/commit.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/commit.tsx
new file mode 100644
index 0000000..84947a6
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/commit.tsx
@@ -0,0 +1,462 @@
+"use client";
+
+import {
+	CheckIcon,
+	CopyIcon,
+	FileIcon,
+	GitCommitIcon,
+	MinusIcon,
+	PlusIcon,
+} from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Avatar, AvatarFallback } from "@/components/ui/avatar";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+export type CommitProps = ComponentProps<typeof Collapsible>;
+
+export const Commit = ({ className, children, ...props }: CommitProps) => (
+	<Collapsible
+		className={cn("rounded-lg border bg-background", className)}
+		{...props}
+	>
+		{children}
+	</Collapsible>
+);
+
+export type CommitHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+
+export const CommitHeader = ({
+	className,
+	children,
+	...props
+}: CommitHeaderProps) => (
+	<CollapsibleTrigger
+		{...props}
+		render={
+			<div
+				className={cn(
+					"group flex cursor-pointer items-center justify-between gap-4 p-3 text-left transition-colors hover:opacity-80",
+					className,
+				)}
+			/>
+		}
+	>
+		{children}
+	</CollapsibleTrigger>
+);
+
+export type CommitHashProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitHash = ({
+	className,
+	children,
+	...props
+}: CommitHashProps) => (
+	<span className={cn("font-mono text-xs", className)} {...props}>
+		<GitCommitIcon className="mr-1 inline-block size-3" />
+		{children}
+	</span>
+);
+
+export type CommitMessageProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitMessage = ({
+	className,
+	children,
+	...props
+}: CommitMessageProps) => (
+	<span className={cn("font-medium text-sm", className)} {...props}>
+		{children}
+	</span>
+);
+
+export type CommitMetadataProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitMetadata = ({
+	className,
+	children,
+	...props
+}: CommitMetadataProps) => (
+	<div
+		className={cn(
+			"flex items-center gap-2 text-muted-foreground text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitSeparatorProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitSeparator = ({
+	className,
+	children,
+	...props
+}: CommitSeparatorProps) => (
+	<span className={className} {...props}>
+		{children ?? "•"}
+	</span>
+);
+
+export type CommitInfoProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitInfo = ({
+	className,
+	children,
+	...props
+}: CommitInfoProps) => (
+	<div className={cn("flex flex-1 flex-col", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type CommitAuthorProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitAuthor = ({
+	className,
+	children,
+	...props
+}: CommitAuthorProps) => (
+	<div className={cn("flex items-center", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type CommitAuthorAvatarProps = ComponentProps<typeof Avatar> & {
+	initials: string;
+};
+
+export const CommitAuthorAvatar = ({
+	initials,
+	className,
+	...props
+}: CommitAuthorAvatarProps) => (
+	<Avatar className={cn("size-8", className)} {...props}>
+		<AvatarFallback className="text-xs">{initials}</AvatarFallback>
+	</Avatar>
+);
+
+export type CommitTimestampProps = HTMLAttributes<HTMLTimeElement> & {
+	date: Date;
+};
+
+const relativeTimeFormat = new Intl.RelativeTimeFormat("en", {
+	numeric: "auto",
+});
+
+const formatRelativeDate = (date: Date) => {
+	const days = Math.round(
+		(date.getTime() - Date.now()) / (1000 * 60 * 60 * 24),
+	);
+	return relativeTimeFormat.format(days, "day");
+};
+
+export const CommitTimestamp = ({
+	date,
+	className,
+	children,
+	...props
+}: CommitTimestampProps) => {
+	const [formatted, setFormatted] = useState("");
+
+	const updateFormatted = useCallback(() => {
+		setFormatted(formatRelativeDate(date));
+	}, [date]);
+
+	useEffect(() => {
+		updateFormatted();
+	}, [updateFormatted]);
+
+	return (
+		<time
+			className={cn("text-xs", className)}
+			dateTime={date.toISOString()}
+			{...props}
+		>
+			{children ?? formatted}
+		</time>
+	);
+};
+
+export type CommitActionsProps = HTMLAttributes<HTMLDivElement>;
+
+const handleActionsClick = (e: React.MouseEvent) => e.stopPropagation();
+const handleActionsKeyDown = (e: React.KeyboardEvent) => e.stopPropagation();
+
+export const CommitActions = ({
+	className,
+	children,
+	...props
+}: CommitActionsProps) => (
+	// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+	<div
+		className={cn("flex items-center gap-1", className)}
+		onClick={handleActionsClick}
+		onKeyDown={handleActionsKeyDown}
+		role="group"
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitCopyButtonProps = ComponentProps<typeof Button> & {
+	hash: string;
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const CommitCopyButton = ({
+	hash,
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: CommitCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			if (!isCopied) {
+				await navigator.clipboard.writeText(hash);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			}
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [hash, onCopy, onError, timeout, isCopied]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn("size-7 shrink-0", className)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={14} />}
+		</Button>
+	);
+};
+
+export type CommitContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const CommitContent = ({
+	className,
+	children,
+	...props
+}: CommitContentProps) => (
+	<CollapsibleContent className={cn("border-t p-3", className)} {...props}>
+		{children}
+	</CollapsibleContent>
+);
+
+export type CommitFilesProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFiles = ({
+	className,
+	children,
+	...props
+}: CommitFilesProps) => (
+	<div className={cn("space-y-1", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type CommitFileProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFile = ({
+	className,
+	children,
+	...props
+}: CommitFileProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between gap-2 rounded px-2 py-1 text-sm hover:bg-muted/50",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitFileInfoProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFileInfo = ({
+	className,
+	children,
+	...props
+}: CommitFileInfoProps) => (
+	<div className={cn("flex min-w-0 items-center gap-2", className)} {...props}>
+		{children}
+	</div>
+);
+
+const fileStatusStyles = {
+	added: "text-green-600 dark:text-green-400",
+	deleted: "text-red-600 dark:text-red-400",
+	modified: "text-yellow-600 dark:text-yellow-400",
+	renamed: "text-blue-600 dark:text-blue-400",
+};
+
+const fileStatusLabels = {
+	added: "A",
+	deleted: "D",
+	modified: "M",
+	renamed: "R",
+};
+
+export type CommitFileStatusProps = HTMLAttributes<HTMLSpanElement> & {
+	status: "added" | "modified" | "deleted" | "renamed";
+};
+
+export const CommitFileStatus = ({
+	status,
+	className,
+	children,
+	...props
+}: CommitFileStatusProps) => (
+	<span
+		className={cn(
+			"font-medium font-mono text-xs",
+			fileStatusStyles[status],
+			className,
+		)}
+		{...props}
+	>
+		{children ?? fileStatusLabels[status]}
+	</span>
+);
+
+export type CommitFileIconProps = ComponentProps<typeof FileIcon>;
+
+export const CommitFileIcon = ({
+	className,
+	...props
+}: CommitFileIconProps) => (
+	<FileIcon
+		className={cn("size-3.5 shrink-0 text-muted-foreground", className)}
+		{...props}
+	/>
+);
+
+export type CommitFilePathProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitFilePath = ({
+	className,
+	children,
+	...props
+}: CommitFilePathProps) => (
+	<span className={cn("truncate font-mono text-xs", className)} {...props}>
+		{children}
+	</span>
+);
+
+export type CommitFileChangesProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFileChanges = ({
+	className,
+	children,
+	...props
+}: CommitFileChangesProps) => (
+	<div
+		className={cn(
+			"flex shrink-0 items-center gap-1 font-mono text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitFileAdditionsProps = HTMLAttributes<HTMLSpanElement> & {
+	count: number;
+};
+
+export const CommitFileAdditions = ({
+	count,
+	className,
+	children,
+	...props
+}: CommitFileAdditionsProps) => {
+	if (count <= 0) {
+		return null;
+	}
+
+	return (
+		<span
+			className={cn("text-green-600 dark:text-green-400", className)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					<PlusIcon className="inline-block size-3" />
+					{count}
+				</>
+			)}
+		</span>
+	);
+};
+
+export type CommitFileDeletionsProps = HTMLAttributes<HTMLSpanElement> & {
+	count: number;
+};
+
+export const CommitFileDeletions = ({
+	count,
+	className,
+	children,
+	...props
+}: CommitFileDeletionsProps) => {
+	if (count <= 0) {
+		return null;
+	}
+
+	return (
+		<span
+			className={cn("text-red-600 dark:text-red-400", className)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					<MinusIcon className="inline-block size-3" />
+					{count}
+				</>
+			)}
+		</span>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/confirmation.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/confirmation.tsx
new file mode 100644
index 0000000..67af355
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/confirmation.tsx
@@ -0,0 +1,174 @@
+"use client";
+
+import type { ToolUIPart } from "ai";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Alert, AlertDescription } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+type ToolUIPartApproval =
+	| {
+			id: string;
+			approved?: never;
+			reason?: never;
+	  }
+	| {
+			id: string;
+			approved: boolean;
+			reason?: string;
+	  }
+	| {
+			id: string;
+			approved: true;
+			reason?: string;
+	  }
+	| {
+			id: string;
+			approved: true;
+			reason?: string;
+	  }
+	| {
+			id: string;
+			approved: false;
+			reason?: string;
+	  }
+	| undefined;
+
+interface ConfirmationContextValue {
+	approval: ToolUIPartApproval;
+	state: ToolUIPart["state"];
+}
+
+const ConfirmationContext = createContext<ConfirmationContextValue | null>(
+	null,
+);
+
+const useConfirmation = () => {
+	const context = useContext(ConfirmationContext);
+
+	if (!context) {
+		throw new Error("Confirmation components must be used within Confirmation");
+	}
+
+	return context;
+};
+
+export type ConfirmationProps = ComponentProps<typeof Alert> & {
+	approval?: ToolUIPartApproval;
+	state: ToolUIPart["state"];
+};
+
+export const Confirmation = ({
+	className,
+	approval,
+	state,
+	...props
+}: ConfirmationProps) => {
+	const contextValue = useMemo(() => ({ approval, state }), [approval, state]);
+
+	if (!approval || state === "input-streaming" || state === "input-available") {
+		return null;
+	}
+
+	return (
+		<ConfirmationContext.Provider value={contextValue}>
+			<Alert className={cn("flex flex-col gap-2", className)} {...props} />
+		</ConfirmationContext.Provider>
+	);
+};
+
+export type ConfirmationTitleProps = ComponentProps<typeof AlertDescription>;
+
+export const ConfirmationTitle = ({
+	className,
+	...props
+}: ConfirmationTitleProps) => (
+	<AlertDescription className={cn("inline", className)} {...props} />
+);
+
+export interface ConfirmationRequestProps {
+	children?: ReactNode;
+}
+
+export const ConfirmationRequest = ({ children }: ConfirmationRequestProps) => {
+	const { state } = useConfirmation();
+
+	// Only show when approval is requested
+	if (state !== "approval-requested") {
+		return null;
+	}
+
+	return children;
+};
+
+export interface ConfirmationAcceptedProps {
+	children?: ReactNode;
+}
+
+export const ConfirmationAccepted = ({
+	children,
+}: ConfirmationAcceptedProps) => {
+	const { approval, state } = useConfirmation();
+
+	// Only show when approved and in response states
+	if (
+		!approval?.approved ||
+		(state !== "approval-responded" &&
+			state !== "output-denied" &&
+			state !== "output-available")
+	) {
+		return null;
+	}
+
+	return children;
+};
+
+export interface ConfirmationRejectedProps {
+	children?: ReactNode;
+}
+
+export const ConfirmationRejected = ({
+	children,
+}: ConfirmationRejectedProps) => {
+	const { approval, state } = useConfirmation();
+
+	// Only show when rejected and in response states
+	if (
+		approval?.approved !== false ||
+		(state !== "approval-responded" &&
+			state !== "output-denied" &&
+			state !== "output-available")
+	) {
+		return null;
+	}
+
+	return children;
+};
+
+export type ConfirmationActionsProps = ComponentProps<"div">;
+
+export const ConfirmationActions = ({
+	className,
+	...props
+}: ConfirmationActionsProps) => {
+	const { state } = useConfirmation();
+
+	// Only show when approval is requested
+	if (state !== "approval-requested") {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn("flex items-center justify-end gap-2 self-end", className)}
+			{...props}
+		/>
+	);
+};
+
+export type ConfirmationActionProps = ComponentProps<typeof Button>;
+
+export const ConfirmationAction = (props: ConfirmationActionProps) => (
+	<Button className="h-8 px-3 text-sm" type="button" {...props} />
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/connection.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/connection.tsx
new file mode 100644
index 0000000..99a58bc
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/connection.tsx
@@ -0,0 +1,28 @@
+import type { ConnectionLineComponent } from "@xyflow/react";
+
+const HALF = 0.5;
+
+export const Connection: ConnectionLineComponent = ({
+	fromX,
+	fromY,
+	toX,
+	toY,
+}) => (
+	<g>
+		<path
+			className="animated"
+			d={`M${fromX},${fromY} C ${fromX + (toX - fromX) * HALF},${fromY} ${fromX + (toX - fromX) * HALF},${toY} ${toX},${toY}`}
+			fill="none"
+			stroke="var(--color-ring)"
+			strokeWidth={1}
+		/>
+		<circle
+			cx={toX}
+			cy={toY}
+			fill="#fff"
+			r={3}
+			stroke="var(--color-ring)"
+			strokeWidth={1}
+		/>
+	</g>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/context.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/context.tsx
new file mode 100644
index 0000000..05b48b1
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/context.tsx
@@ -0,0 +1,409 @@
+"use client";
+
+import type { LanguageModelUsage } from "ai";
+import type { ComponentProps } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { getUsage } from "tokenlens";
+import { Button } from "@/components/ui/button";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { Progress } from "@/components/ui/progress";
+import { cn } from "@/lib/utils";
+
+const PERCENT_MAX = 100;
+const ICON_RADIUS = 10;
+const ICON_VIEWBOX = 24;
+const ICON_CENTER = 12;
+const ICON_STROKE_WIDTH = 2;
+
+type ModelId = string;
+
+interface ContextSchema {
+	usedTokens: number;
+	maxTokens: number;
+	usage?: LanguageModelUsage;
+	modelId?: ModelId;
+}
+
+const ContextContext = createContext<ContextSchema | null>(null);
+
+const useContextValue = () => {
+	const context = useContext(ContextContext);
+
+	if (!context) {
+		throw new Error("Context components must be used within Context");
+	}
+
+	return context;
+};
+
+export type ContextProps = ComponentProps<typeof HoverCard> & ContextSchema;
+
+export const Context = ({
+	usedTokens,
+	maxTokens,
+	usage,
+	modelId,
+	...props
+}: ContextProps) => {
+	const contextValue = useMemo(
+		() => ({ maxTokens, modelId, usage, usedTokens }),
+		[maxTokens, modelId, usage, usedTokens],
+	);
+
+	return (
+		<ContextContext.Provider value={contextValue}>
+			<HoverCard closeDelay={0} openDelay={0} {...props} />
+		</ContextContext.Provider>
+	);
+};
+
+const ContextIcon = () => {
+	const { usedTokens, maxTokens } = useContextValue();
+	const circumference = 2 * Math.PI * ICON_RADIUS;
+	const usedPercent = usedTokens / maxTokens;
+	const dashOffset = circumference * (1 - usedPercent);
+
+	return (
+		<svg
+			aria-label="Model context usage"
+			height="20"
+			role="img"
+			style={{ color: "currentcolor" }}
+			viewBox={`0 0 ${ICON_VIEWBOX} ${ICON_VIEWBOX}`}
+			width="20"
+		>
+			<circle
+				cx={ICON_CENTER}
+				cy={ICON_CENTER}
+				fill="none"
+				opacity="0.25"
+				r={ICON_RADIUS}
+				stroke="currentColor"
+				strokeWidth={ICON_STROKE_WIDTH}
+			/>
+			<circle
+				cx={ICON_CENTER}
+				cy={ICON_CENTER}
+				fill="none"
+				opacity="0.7"
+				r={ICON_RADIUS}
+				stroke="currentColor"
+				strokeDasharray={`${circumference} ${circumference}`}
+				strokeDashoffset={dashOffset}
+				strokeLinecap="round"
+				strokeWidth={ICON_STROKE_WIDTH}
+				style={{ transform: "rotate(-90deg)", transformOrigin: "center" }}
+			/>
+		</svg>
+	);
+};
+
+export type ContextTriggerProps = ComponentProps<typeof Button>;
+
+export const ContextTrigger = ({ children, ...props }: ContextTriggerProps) => {
+	const { usedTokens, maxTokens } = useContextValue();
+	const usedPercent = usedTokens / maxTokens;
+	const renderedPercent = new Intl.NumberFormat("en-US", {
+		maximumFractionDigits: 1,
+		style: "percent",
+	}).format(usedPercent);
+
+	return (
+		<HoverCardTrigger>
+			{children ?? (
+				<Button type="button" variant="ghost" {...props}>
+					<span className="font-medium text-muted-foreground">
+						{renderedPercent}
+					</span>
+					<ContextIcon />
+				</Button>
+			)}
+		</HoverCardTrigger>
+	);
+};
+
+export type ContextContentProps = ComponentProps<typeof HoverCardContent>;
+
+export const ContextContent = ({
+	className,
+	...props
+}: ContextContentProps) => (
+	<HoverCardContent
+		className={cn("min-w-60 divide-y overflow-hidden p-0", className)}
+		{...props}
+	/>
+);
+
+export type ContextContentHeaderProps = ComponentProps<"div">;
+
+export const ContextContentHeader = ({
+	children,
+	className,
+	...props
+}: ContextContentHeaderProps) => {
+	const { usedTokens, maxTokens } = useContextValue();
+	const usedPercent = usedTokens / maxTokens;
+	const displayPct = new Intl.NumberFormat("en-US", {
+		maximumFractionDigits: 1,
+		style: "percent",
+	}).format(usedPercent);
+	const used = new Intl.NumberFormat("en-US", {
+		notation: "compact",
+	}).format(usedTokens);
+	const total = new Intl.NumberFormat("en-US", {
+		notation: "compact",
+	}).format(maxTokens);
+
+	return (
+		<div className={cn("w-full space-y-2 p-3", className)} {...props}>
+			{children ?? (
+				<>
+					<div className="flex items-center justify-between gap-3 text-xs">
+						<p>{displayPct}</p>
+						<p className="font-mono text-muted-foreground">
+							{used} / {total}
+						</p>
+					</div>
+					<div className="space-y-2">
+						<Progress className="bg-muted" value={usedPercent * PERCENT_MAX} />
+					</div>
+				</>
+			)}
+		</div>
+	);
+};
+
+export type ContextContentBodyProps = ComponentProps<"div">;
+
+export const ContextContentBody = ({
+	children,
+	className,
+	...props
+}: ContextContentBodyProps) => (
+	<div className={cn("w-full p-3", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type ContextContentFooterProps = ComponentProps<"div">;
+
+export const ContextContentFooter = ({
+	children,
+	className,
+	...props
+}: ContextContentFooterProps) => {
+	const { modelId, usage } = useContextValue();
+	const costUSD = modelId
+		? getUsage({
+				modelId,
+				usage: {
+					input: usage?.inputTokens ?? 0,
+					output: usage?.outputTokens ?? 0,
+				},
+			}).costUSD?.totalUSD
+		: undefined;
+	const totalCost = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(costUSD ?? 0);
+
+	return (
+		<div
+			className={cn(
+				"flex w-full items-center justify-between gap-3 bg-secondary p-3 text-xs",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					<span className="text-muted-foreground">Total cost</span>
+					<span>{totalCost}</span>
+				</>
+			)}
+		</div>
+	);
+};
+
+const TokensWithCost = ({
+	tokens,
+	costText,
+}: {
+	tokens?: number;
+	costText?: string;
+}) => (
+	<span>
+		{tokens === undefined
+			? "—"
+			: new Intl.NumberFormat("en-US", {
+					notation: "compact",
+				}).format(tokens)}
+		{costText ? (
+			<span className="ml-2 text-muted-foreground">• {costText}</span>
+		) : null}
+	</span>
+);
+
+export type ContextInputUsageProps = ComponentProps<"div">;
+
+export const ContextInputUsage = ({
+	className,
+	children,
+	...props
+}: ContextInputUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const inputTokens = usage?.inputTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!inputTokens) {
+		return null;
+	}
+
+	const inputCost = modelId
+		? getUsage({
+				modelId,
+				usage: { input: inputTokens, output: 0 },
+			}).costUSD?.totalUSD
+		: undefined;
+	const inputCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(inputCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Input</span>
+			<TokensWithCost costText={inputCostText} tokens={inputTokens} />
+		</div>
+	);
+};
+
+export type ContextOutputUsageProps = ComponentProps<"div">;
+
+export const ContextOutputUsage = ({
+	className,
+	children,
+	...props
+}: ContextOutputUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const outputTokens = usage?.outputTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!outputTokens) {
+		return null;
+	}
+
+	const outputCost = modelId
+		? getUsage({
+				modelId,
+				usage: { input: 0, output: outputTokens },
+			}).costUSD?.totalUSD
+		: undefined;
+	const outputCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(outputCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Output</span>
+			<TokensWithCost costText={outputCostText} tokens={outputTokens} />
+		</div>
+	);
+};
+
+export type ContextReasoningUsageProps = ComponentProps<"div">;
+
+export const ContextReasoningUsage = ({
+	className,
+	children,
+	...props
+}: ContextReasoningUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const reasoningTokens = usage?.outputTokenDetails?.reasoningTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!reasoningTokens) {
+		return null;
+	}
+
+	const reasoningCost = modelId
+		? getUsage({
+				modelId,
+				usage: { reasoningTokens },
+			}).costUSD?.totalUSD
+		: undefined;
+	const reasoningCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(reasoningCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Reasoning</span>
+			<TokensWithCost costText={reasoningCostText} tokens={reasoningTokens} />
+		</div>
+	);
+};
+
+export type ContextCacheUsageProps = ComponentProps<"div">;
+
+export const ContextCacheUsage = ({
+	className,
+	children,
+	...props
+}: ContextCacheUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const cacheTokens = usage?.inputTokenDetails?.cacheReadTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!cacheTokens) {
+		return null;
+	}
+
+	const cacheCost = modelId
+		? getUsage({
+				modelId,
+				usage: { cacheReads: cacheTokens, input: 0, output: 0 },
+			}).costUSD?.totalUSD
+		: undefined;
+	const cacheCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(cacheCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Cache</span>
+			<TokensWithCost costText={cacheCostText} tokens={cacheTokens} />
+		</div>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/controls.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/controls.tsx
new file mode 100644
index 0000000..fdd119b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/controls.tsx
@@ -0,0 +1,18 @@
+"use client";
+
+import { Controls as ControlsPrimitive } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+export type ControlsProps = ComponentProps<typeof ControlsPrimitive>;
+
+export const Controls = ({ className, ...props }: ControlsProps) => (
+	<ControlsPrimitive
+		className={cn(
+			"gap-px overflow-hidden rounded-md border bg-card p-1 shadow-none!",
+			"[&>button]:rounded-md [&>button]:border-none! [&>button]:bg-transparent! [&>button]:hover:bg-secondary!",
+			className,
+		)}
+		{...props}
+	/>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/conversation.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/conversation.tsx
new file mode 100644
index 0000000..0cbcc1c
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/conversation.tsx
@@ -0,0 +1,168 @@
+"use client";
+
+import type { UIMessage } from "ai";
+import { ArrowDownIcon, DownloadIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { useCallback } from "react";
+import { StickToBottom, useStickToBottomContext } from "use-stick-to-bottom";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+export type ConversationProps = ComponentProps<typeof StickToBottom>;
+
+export const Conversation = ({ className, ...props }: ConversationProps) => (
+	<StickToBottom
+		className={cn("relative flex-1 overflow-y-hidden", className)}
+		initial="smooth"
+		resize="smooth"
+		role="log"
+		{...props}
+	/>
+);
+
+export type ConversationContentProps = ComponentProps<
+	typeof StickToBottom.Content
+>;
+
+export const ConversationContent = ({
+	className,
+	...props
+}: ConversationContentProps) => (
+	<StickToBottom.Content
+		className={cn("flex flex-col gap-8 p-4", className)}
+		{...props}
+	/>
+);
+
+export type ConversationEmptyStateProps = ComponentProps<"div"> & {
+	title?: string;
+	description?: string;
+	icon?: React.ReactNode;
+};
+
+export const ConversationEmptyState = ({
+	className,
+	title = "No messages yet",
+	description = "Start a conversation to see messages here",
+	icon,
+	children,
+	...props
+}: ConversationEmptyStateProps) => (
+	<div
+		className={cn(
+			"flex size-full flex-col items-center justify-center gap-3 p-8 text-center",
+			className,
+		)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				{icon && <div className="text-muted-foreground">{icon}</div>}
+				<div className="space-y-1">
+					<h3 className="font-medium text-sm">{title}</h3>
+					{description && (
+						<p className="text-muted-foreground text-sm">{description}</p>
+					)}
+				</div>
+			</>
+		)}
+	</div>
+);
+
+export type ConversationScrollButtonProps = ComponentProps<typeof Button>;
+
+export const ConversationScrollButton = ({
+	className,
+	...props
+}: ConversationScrollButtonProps) => {
+	const { isAtBottom, scrollToBottom } = useStickToBottomContext();
+
+	const handleScrollToBottom = useCallback(() => {
+		scrollToBottom();
+	}, [scrollToBottom]);
+
+	return (
+		!isAtBottom && (
+			<Button
+				className={cn(
+					"absolute bottom-4 left-[50%] translate-x-[-50%] rounded-full dark:bg-background dark:hover:bg-muted",
+					className,
+				)}
+				onClick={handleScrollToBottom}
+				size="icon"
+				type="button"
+				variant="outline"
+				{...props}
+			>
+				<ArrowDownIcon className="size-4" />
+			</Button>
+		)
+	);
+};
+
+const getMessageText = (message: UIMessage): string =>
+	message.parts
+		.filter((part) => part.type === "text")
+		.map((part) => part.text)
+		.join("");
+
+export type ConversationDownloadProps = Omit<
+	ComponentProps<typeof Button>,
+	"onClick"
+> & {
+	messages: UIMessage[];
+	filename?: string;
+	formatMessage?: (message: UIMessage, index: number) => string;
+};
+
+const defaultFormatMessage = (message: UIMessage): string => {
+	const roleLabel =
+		message.role.charAt(0).toUpperCase() + message.role.slice(1);
+	return `**${roleLabel}:** ${getMessageText(message)}`;
+};
+
+export const messagesToMarkdown = (
+	messages: UIMessage[],
+	formatMessage: (
+		message: UIMessage,
+		index: number,
+	) => string = defaultFormatMessage,
+): string => messages.map((msg, i) => formatMessage(msg, i)).join("\n\n");
+
+export const ConversationDownload = ({
+	messages,
+	filename = "conversation.md",
+	formatMessage = defaultFormatMessage,
+	className,
+	children,
+	...props
+}: ConversationDownloadProps) => {
+	const handleDownload = useCallback(() => {
+		const markdown = messagesToMarkdown(messages, formatMessage);
+		const blob = new Blob([markdown], { type: "text/markdown" });
+		const url = URL.createObjectURL(blob);
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = filename;
+		document.body.append(link);
+		link.click();
+		link.remove();
+		URL.revokeObjectURL(url);
+	}, [messages, filename, formatMessage]);
+
+	return (
+		<Button
+			className={cn(
+				"absolute top-4 right-4 rounded-full dark:bg-background dark:hover:bg-muted",
+				className,
+			)}
+			onClick={handleDownload}
+			size="icon"
+			type="button"
+			variant="outline"
+			{...props}
+		>
+			{children ?? <DownloadIcon className="size-4" />}
+		</Button>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/edge.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/edge.tsx
new file mode 100644
index 0000000..76bf7dc
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/edge.tsx
@@ -0,0 +1,143 @@
+import type { EdgeProps, InternalNode, Node } from "@xyflow/react";
+import {
+	BaseEdge,
+	getBezierPath,
+	getSimpleBezierPath,
+	Position,
+	useInternalNode,
+} from "@xyflow/react";
+
+const Temporary = ({
+	id,
+	sourceX,
+	sourceY,
+	targetX,
+	targetY,
+	sourcePosition,
+	targetPosition,
+}: EdgeProps) => {
+	const [edgePath] = getSimpleBezierPath({
+		sourcePosition,
+		sourceX,
+		sourceY,
+		targetPosition,
+		targetX,
+		targetY,
+	});
+
+	return (
+		<BaseEdge
+			className="stroke-1 stroke-ring"
+			id={id}
+			path={edgePath}
+			style={{
+				strokeDasharray: "5, 5",
+			}}
+		/>
+	);
+};
+
+const getHandleCoordsByPosition = (
+	node: InternalNode<Node>,
+	handlePosition: Position,
+) => {
+	// Choose the handle type based on position - Left is for target, Right is for source
+	const handleType = handlePosition === Position.Left ? "target" : "source";
+
+	const handle = node.internals.handleBounds?.[handleType]?.find(
+		(h) => h.position === handlePosition,
+	);
+
+	if (!handle) {
+		return [0, 0] as const;
+	}
+
+	let offsetX = handle.width / 2;
+	let offsetY = handle.height / 2;
+
+	// this is a tiny detail to make the markerEnd of an edge visible.
+	// The handle position that gets calculated has the origin top-left, so depending which side we are using, we add a little offset
+	// when the handlePosition is Position.Right for example, we need to add an offset as big as the handle itself in order to get the correct position
+	switch (handlePosition) {
+		case Position.Left: {
+			offsetX = 0;
+			break;
+		}
+		case Position.Right: {
+			offsetX = handle.width;
+			break;
+		}
+		case Position.Top: {
+			offsetY = 0;
+			break;
+		}
+		case Position.Bottom: {
+			offsetY = handle.height;
+			break;
+		}
+		default: {
+			throw new Error(`Invalid handle position: ${handlePosition}`);
+		}
+	}
+
+	const x = node.internals.positionAbsolute.x + handle.x + offsetX;
+	const y = node.internals.positionAbsolute.y + handle.y + offsetY;
+
+	return [x, y] as const;
+};
+
+const getEdgeParams = (
+	source: InternalNode<Node>,
+	target: InternalNode<Node>,
+) => {
+	const sourcePos = Position.Right;
+	const [sx, sy] = getHandleCoordsByPosition(source, sourcePos);
+	const targetPos = Position.Left;
+	const [tx, ty] = getHandleCoordsByPosition(target, targetPos);
+
+	return {
+		sourcePos,
+		sx,
+		sy,
+		targetPos,
+		tx,
+		ty,
+	};
+};
+
+const Animated = ({ id, source, target, markerEnd, style }: EdgeProps) => {
+	const sourceNode = useInternalNode(source);
+	const targetNode = useInternalNode(target);
+
+	if (!(sourceNode && targetNode)) {
+		return null;
+	}
+
+	const { sx, sy, tx, ty, sourcePos, targetPos } = getEdgeParams(
+		sourceNode,
+		targetNode,
+	);
+
+	const [edgePath] = getBezierPath({
+		sourcePosition: sourcePos,
+		sourceX: sx,
+		sourceY: sy,
+		targetPosition: targetPos,
+		targetX: tx,
+		targetY: ty,
+	});
+
+	return (
+		<>
+			<BaseEdge id={id} markerEnd={markerEnd} path={edgePath} style={style} />
+			<circle fill="var(--primary)" r="4">
+				<animateMotion dur="2s" path={edgePath} repeatCount="indefinite" />
+			</circle>
+		</>
+	);
+};
+
+export const Edge = {
+	Animated,
+	Temporary,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/environment-variables.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/environment-variables.tsx
new file mode 100644
index 0000000..f6ba5ff
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/environment-variables.tsx
@@ -0,0 +1,324 @@
+"use client";
+
+import { CheckIcon, CopyIcon, EyeIcon, EyeOffIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import { cn } from "@/lib/utils";
+
+interface EnvironmentVariablesContextType {
+	showValues: boolean;
+	setShowValues: (show: boolean) => void;
+}
+
+// Default noop for context default value
+// oxlint-disable-next-line eslint(no-empty-function)
+const noop = () => {};
+
+const EnvironmentVariablesContext =
+	createContext<EnvironmentVariablesContextType>({
+		setShowValues: noop,
+		showValues: false,
+	});
+
+export type EnvironmentVariablesProps = HTMLAttributes<HTMLDivElement> & {
+	showValues?: boolean;
+	defaultShowValues?: boolean;
+	onShowValuesChange?: (show: boolean) => void;
+};
+
+export const EnvironmentVariables = ({
+	showValues: controlledShowValues,
+	defaultShowValues = false,
+	onShowValuesChange,
+	className,
+	children,
+	...props
+}: EnvironmentVariablesProps) => {
+	const [internalShowValues, setInternalShowValues] =
+		useState(defaultShowValues);
+	const showValues = controlledShowValues ?? internalShowValues;
+
+	const setShowValues = useCallback(
+		(show: boolean) => {
+			setInternalShowValues(show);
+			onShowValuesChange?.(show);
+		},
+		[onShowValuesChange],
+	);
+
+	const contextValue = useMemo(
+		() => ({ setShowValues, showValues }),
+		[setShowValues, showValues],
+	);
+
+	return (
+		<EnvironmentVariablesContext.Provider value={contextValue}>
+			<div
+				className={cn("rounded-lg border bg-background", className)}
+				{...props}
+			>
+				{children}
+			</div>
+		</EnvironmentVariablesContext.Provider>
+	);
+};
+
+export type EnvironmentVariablesHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariablesHeader = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariablesHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b px-4 py-3",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type EnvironmentVariablesTitleProps = HTMLAttributes<HTMLHeadingElement>;
+
+export const EnvironmentVariablesTitle = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariablesTitleProps) => (
+	<h3 className={cn("font-medium text-sm", className)} {...props}>
+		{children ?? "Environment Variables"}
+	</h3>
+);
+
+export type EnvironmentVariablesToggleProps = ComponentProps<typeof Switch>;
+
+export const EnvironmentVariablesToggle = ({
+	className,
+	...props
+}: EnvironmentVariablesToggleProps) => {
+	const { showValues, setShowValues } = useContext(EnvironmentVariablesContext);
+
+	return (
+		<div className={cn("flex items-center gap-2", className)}>
+			<span className="text-muted-foreground text-xs">
+				{showValues ? <EyeIcon size={14} /> : <EyeOffIcon size={14} />}
+			</span>
+			<Switch
+				aria-label="Toggle value visibility"
+				checked={showValues}
+				onCheckedChange={setShowValues}
+				{...props}
+			/>
+		</div>
+	);
+};
+
+export type EnvironmentVariablesContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariablesContent = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariablesContentProps) => (
+	<div className={cn("divide-y", className)} {...props}>
+		{children}
+	</div>
+);
+
+interface EnvironmentVariableContextType {
+	name: string;
+	value: string;
+}
+
+const EnvironmentVariableContext =
+	createContext<EnvironmentVariableContextType>({
+		name: "",
+		value: "",
+	});
+
+export type EnvironmentVariableGroupProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariableGroup = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableGroupProps) => (
+	<div className={cn("flex items-center gap-2", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type EnvironmentVariableNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const EnvironmentVariableName = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableNameProps) => {
+	const { name } = useContext(EnvironmentVariableContext);
+
+	return (
+		<span className={cn("font-mono text-sm", className)} {...props}>
+			{children ?? name}
+		</span>
+	);
+};
+
+export type EnvironmentVariableValueProps = HTMLAttributes<HTMLSpanElement>;
+
+export const EnvironmentVariableValue = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableValueProps) => {
+	const { value } = useContext(EnvironmentVariableContext);
+	const { showValues } = useContext(EnvironmentVariablesContext);
+
+	const displayValue = showValues
+		? value
+		: "•".repeat(Math.min(value.length, 20));
+
+	return (
+		<span
+			className={cn(
+				"font-mono text-muted-foreground text-sm",
+				!showValues && "select-none",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? displayValue}
+		</span>
+	);
+};
+
+export type EnvironmentVariableProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	value: string;
+};
+
+export const EnvironmentVariable = ({
+	name,
+	value,
+	className,
+	children,
+	...props
+}: EnvironmentVariableProps) => {
+	const envVarContextValue = useMemo(() => ({ name, value }), [name, value]);
+
+	return (
+		<EnvironmentVariableContext.Provider value={envVarContextValue}>
+			<div
+				className={cn(
+					"flex items-center justify-between gap-4 px-4 py-3",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<div className="flex items-center gap-2">
+							<EnvironmentVariableName />
+						</div>
+						<EnvironmentVariableValue />
+					</>
+				)}
+			</div>
+		</EnvironmentVariableContext.Provider>
+	);
+};
+
+export type EnvironmentVariableCopyButtonProps = ComponentProps<
+	typeof Button
+> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+	copyFormat?: "name" | "value" | "export";
+};
+
+export const EnvironmentVariableCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	copyFormat = "value",
+	children,
+	className,
+	...props
+}: EnvironmentVariableCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { name, value } = useContext(EnvironmentVariableContext);
+
+	const getTextToCopy = useCallback((): string => {
+		const formatMap = {
+			export: () => `export ${name}="${value}"`,
+			name: () => name,
+			value: () => value,
+		};
+		return formatMap[copyFormat]();
+	}, [name, value, copyFormat]);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			await navigator.clipboard.writeText(getTextToCopy());
+			setIsCopied(true);
+			onCopy?.();
+			timeoutRef.current = window.setTimeout(() => setIsCopied(false), timeout);
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [getTextToCopy, onCopy, onError, timeout]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn("size-6 shrink-0", className)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={12} />}
+		</Button>
+	);
+};
+
+export type EnvironmentVariableRequiredProps = ComponentProps<typeof Badge>;
+
+export const EnvironmentVariableRequired = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableRequiredProps) => (
+	<Badge className={cn("text-xs", className)} variant="secondary" {...props}>
+		{children ?? "Required"}
+	</Badge>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/file-tree.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/file-tree.tsx
new file mode 100644
index 0000000..1d7ebc1
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/file-tree.tsx
@@ -0,0 +1,307 @@
+"use client";
+
+import {
+	ChevronRightIcon,
+	FileIcon,
+	FolderIcon,
+	FolderOpenIcon,
+} from "lucide-react";
+import type { HTMLAttributes, ReactNode } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useMemo,
+	useState,
+} from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+interface FileTreeContextType {
+	expandedPaths: Set<string>;
+	togglePath: (path: string) => void;
+	selectedPath?: string;
+	onSelect?: (path: string) => void;
+}
+
+// Default noop for context default value
+// oxlint-disable-next-line eslint(no-empty-function)
+const noop = () => {};
+
+const FileTreeContext = createContext<FileTreeContextType>({
+	// oxlint-disable-next-line eslint-plugin-unicorn(no-new-builtin)
+	expandedPaths: new Set(),
+	togglePath: noop,
+});
+
+export type FileTreeProps = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+	expanded?: Set<string>;
+	defaultExpanded?: Set<string>;
+	selectedPath?: string;
+	onSelect?: (path: string) => void;
+	onExpandedChange?: (expanded: Set<string>) => void;
+};
+
+export const FileTree = ({
+	expanded: controlledExpanded,
+	defaultExpanded = new Set(),
+	selectedPath,
+	onSelect,
+	onExpandedChange,
+	className,
+	children,
+	...props
+}: FileTreeProps) => {
+	const [internalExpanded, setInternalExpanded] = useState(defaultExpanded);
+	const expandedPaths = controlledExpanded ?? internalExpanded;
+
+	const togglePath = useCallback(
+		(path: string) => {
+			const newExpanded = new Set(expandedPaths);
+			if (newExpanded.has(path)) {
+				newExpanded.delete(path);
+			} else {
+				newExpanded.add(path);
+			}
+			setInternalExpanded(newExpanded);
+			onExpandedChange?.(newExpanded);
+		},
+		[expandedPaths, onExpandedChange],
+	);
+
+	const contextValue = useMemo(
+		() => ({ expandedPaths, onSelect, selectedPath, togglePath }),
+		[expandedPaths, onSelect, selectedPath, togglePath],
+	);
+
+	return (
+		<FileTreeContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"rounded-lg border bg-background font-mono text-sm",
+					className,
+				)}
+				role="tree"
+				{...props}
+			>
+				<div className="p-2">{children}</div>
+			</div>
+		</FileTreeContext.Provider>
+	);
+};
+
+export type FileTreeIconProps = HTMLAttributes<HTMLSpanElement>;
+
+export const FileTreeIcon = ({
+	className,
+	children,
+	...props
+}: FileTreeIconProps) => (
+	<span className={cn("shrink-0", className)} {...props}>
+		{children}
+	</span>
+);
+
+export type FileTreeNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const FileTreeName = ({
+	className,
+	children,
+	...props
+}: FileTreeNameProps) => (
+	<span className={cn("truncate", className)} {...props}>
+		{children}
+	</span>
+);
+
+interface FileTreeFolderContextType {
+	path: string;
+	name: string;
+	isExpanded: boolean;
+}
+
+const FileTreeFolderContext = createContext<FileTreeFolderContextType>({
+	isExpanded: false,
+	name: "",
+	path: "",
+});
+
+export type FileTreeFolderProps = HTMLAttributes<HTMLDivElement> & {
+	path: string;
+	name: string;
+};
+
+export const FileTreeFolder = ({
+	path,
+	name,
+	className,
+	children,
+	...props
+}: FileTreeFolderProps) => {
+	const { expandedPaths, togglePath, selectedPath, onSelect } =
+		useContext(FileTreeContext);
+	const isExpanded = expandedPaths.has(path);
+	const isSelected = selectedPath === path;
+
+	const handleOpenChange = useCallback(() => {
+		togglePath(path);
+	}, [togglePath, path]);
+
+	const handleSelect = useCallback(() => {
+		onSelect?.(path);
+	}, [onSelect, path]);
+
+	const folderContextValue = useMemo(
+		() => ({ isExpanded, name, path }),
+		[isExpanded, name, path],
+	);
+
+	return (
+		<FileTreeFolderContext.Provider value={folderContextValue}>
+			<Collapsible onOpenChange={handleOpenChange} open={isExpanded}>
+				<div
+					className={cn("", className)}
+					role="treeitem"
+					tabIndex={0}
+					{...props}
+				>
+					<div
+						className={cn(
+							"flex w-full items-center gap-1 rounded px-2 py-1 text-left transition-colors hover:bg-muted/50",
+							isSelected && "bg-muted",
+						)}
+					>
+						<CollapsibleTrigger
+							render={
+								<button
+									className="flex shrink-0 cursor-pointer items-center border-none bg-transparent p-0"
+									type="button"
+								/>
+							}
+						>
+							<ChevronRightIcon
+								className={cn(
+									"size-4 shrink-0 text-muted-foreground transition-transform",
+									isExpanded && "rotate-90",
+								)}
+							/>
+						</CollapsibleTrigger>
+						<button
+							className="flex min-w-0 flex-1 cursor-pointer items-center gap-1 border-none bg-transparent p-0 text-left"
+							onClick={handleSelect}
+							type="button"
+						>
+							<FileTreeIcon>
+								{isExpanded ? (
+									<FolderOpenIcon className="size-4 text-blue-500" />
+								) : (
+									<FolderIcon className="size-4 text-blue-500" />
+								)}
+							</FileTreeIcon>
+							<FileTreeName>{name}</FileTreeName>
+						</button>
+					</div>
+					<CollapsibleContent>
+						<div className="ml-4 border-l pl-2">{children}</div>
+					</CollapsibleContent>
+				</div>
+			</Collapsible>
+		</FileTreeFolderContext.Provider>
+	);
+};
+
+interface FileTreeFileContextType {
+	path: string;
+	name: string;
+}
+
+const FileTreeFileContext = createContext<FileTreeFileContextType>({
+	name: "",
+	path: "",
+});
+
+export type FileTreeFileProps = HTMLAttributes<HTMLDivElement> & {
+	path: string;
+	name: string;
+	icon?: ReactNode;
+};
+
+export const FileTreeFile = ({
+	path,
+	name,
+	icon,
+	className,
+	children,
+	...props
+}: FileTreeFileProps) => {
+	const { selectedPath, onSelect } = useContext(FileTreeContext);
+	const isSelected = selectedPath === path;
+
+	const handleClick = useCallback(() => {
+		onSelect?.(path);
+	}, [onSelect, path]);
+
+	const handleKeyDown = useCallback(
+		(e: React.KeyboardEvent) => {
+			if (e.key === "Enter" || e.key === " ") {
+				onSelect?.(path);
+			}
+		},
+		[onSelect, path],
+	);
+
+	const fileContextValue = useMemo(() => ({ name, path }), [name, path]);
+
+	return (
+		<FileTreeFileContext.Provider value={fileContextValue}>
+			<div
+				className={cn(
+					"flex cursor-pointer items-center gap-1 rounded px-2 py-1 transition-colors hover:bg-muted/50",
+					isSelected && "bg-muted",
+					className,
+				)}
+				onClick={handleClick}
+				onKeyDown={handleKeyDown}
+				role="treeitem"
+				tabIndex={0}
+				{...props}
+			>
+				{children ?? (
+					<>
+						{/* Spacer for alignment */}
+						<span className="size-4 shrink-0" />
+						<FileTreeIcon>
+							{icon ?? <FileIcon className="size-4 text-muted-foreground" />}
+						</FileTreeIcon>
+						<FileTreeName>{name}</FileTreeName>
+					</>
+				)}
+			</div>
+		</FileTreeFileContext.Provider>
+	);
+};
+
+export type FileTreeActionsProps = HTMLAttributes<HTMLDivElement>;
+
+const stopPropagation = (e: React.SyntheticEvent) => e.stopPropagation();
+
+export const FileTreeActions = ({
+	className,
+	children,
+	...props
+}: FileTreeActionsProps) => (
+	// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+	<div
+		className={cn("ml-auto flex items-center gap-1", className)}
+		onClick={stopPropagation}
+		onKeyDown={stopPropagation}
+		role="group"
+		{...props}
+	>
+		{children}
+	</div>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/image.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/image.tsx
new file mode 100644
index 0000000..d7026dd
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/image.tsx
@@ -0,0 +1,24 @@
+import type { Experimental_GeneratedImage } from "ai";
+import { cn } from "@/lib/utils";
+
+export type ImageProps = Experimental_GeneratedImage & {
+	className?: string;
+	alt?: string;
+};
+
+export const Image = ({
+	base64,
+	uint8Array: _uint8Array,
+	mediaType,
+	...props
+}: ImageProps) => (
+	<img
+		{...props}
+		alt={props.alt}
+		className={cn(
+			"h-auto max-w-full overflow-hidden rounded-md",
+			props.className,
+		)}
+		src={`data:${mediaType};base64,${base64}`}
+	/>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/inline-citation.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/inline-citation.tsx
new file mode 100644
index 0000000..6063e4e
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/inline-citation.tsx
@@ -0,0 +1,298 @@
+"use client";
+
+import { ArrowLeftIcon, ArrowRightIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useState,
+} from "react";
+import { Badge } from "@/components/ui/badge";
+import type { CarouselApi } from "@/components/ui/carousel";
+import {
+	Carousel,
+	CarouselContent,
+	CarouselItem,
+} from "@/components/ui/carousel";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { cn } from "@/lib/utils";
+
+export type InlineCitationProps = ComponentProps<"span">;
+
+export const InlineCitation = ({
+	className,
+	...props
+}: InlineCitationProps) => (
+	<span
+		className={cn("group inline items-center gap-1", className)}
+		{...props}
+	/>
+);
+
+export type InlineCitationTextProps = ComponentProps<"span">;
+
+export const InlineCitationText = ({
+	className,
+	...props
+}: InlineCitationTextProps) => (
+	<span
+		className={cn("transition-colors group-hover:bg-accent", className)}
+		{...props}
+	/>
+);
+
+export type InlineCitationCardProps = ComponentProps<typeof HoverCard>;
+
+export const InlineCitationCard = (props: InlineCitationCardProps) => (
+	<HoverCard closeDelay={0} openDelay={0} {...props} />
+);
+
+export type InlineCitationCardTriggerProps = ComponentProps<typeof Badge> & {
+	sources: string[];
+};
+
+export const InlineCitationCardTrigger = ({
+	sources,
+	className,
+	...props
+}: InlineCitationCardTriggerProps) => (
+	<HoverCardTrigger
+		render={
+			<Badge
+				className={cn("ml-1 rounded-full", className)}
+				variant="secondary"
+				{...props}
+			/>
+		}
+	>
+		{sources[0] ? (
+			<>
+				{new URL(sources[0]).hostname}{" "}
+				{sources.length > 1 && `+${sources.length - 1}`}
+			</>
+		) : (
+			"unknown"
+		)}
+	</HoverCardTrigger>
+);
+
+export type InlineCitationCardBodyProps = ComponentProps<"div">;
+
+export const InlineCitationCardBody = ({
+	className,
+	...props
+}: InlineCitationCardBodyProps) => (
+	<HoverCardContent className={cn("relative w-80 p-0", className)} {...props} />
+);
+
+const CarouselApiContext = createContext<CarouselApi | undefined>(undefined);
+
+const useCarouselApi = () => {
+	const context = useContext(CarouselApiContext);
+	return context;
+};
+
+export type InlineCitationCarouselProps = ComponentProps<typeof Carousel>;
+
+export const InlineCitationCarousel = ({
+	className,
+	children,
+	...props
+}: InlineCitationCarouselProps) => {
+	const [api, setApi] = useState<CarouselApi>();
+
+	return (
+		<CarouselApiContext.Provider value={api}>
+			<Carousel className={cn("w-full", className)} setApi={setApi} {...props}>
+				{children}
+			</Carousel>
+		</CarouselApiContext.Provider>
+	);
+};
+
+export type InlineCitationCarouselContentProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselContent = (
+	props: InlineCitationCarouselContentProps,
+) => <CarouselContent {...props} />;
+
+export type InlineCitationCarouselItemProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselItem = ({
+	className,
+	...props
+}: InlineCitationCarouselItemProps) => (
+	<CarouselItem
+		className={cn("w-full space-y-2 p-4 pl-8", className)}
+		{...props}
+	/>
+);
+
+export type InlineCitationCarouselHeaderProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselHeader = ({
+	className,
+	...props
+}: InlineCitationCarouselHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between gap-2 rounded-t-md bg-secondary p-2",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type InlineCitationCarouselIndexProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselIndex = ({
+	children,
+	className,
+	...props
+}: InlineCitationCarouselIndexProps) => {
+	const api = useCarouselApi();
+	const [current, setCurrent] = useState(0);
+	const [count, setCount] = useState(0);
+
+	const syncState = useCallback(() => {
+		if (!api) {
+			return;
+		}
+		setCount(api.scrollSnapList().length);
+		setCurrent(api.selectedScrollSnap() + 1);
+	}, [api]);
+
+	useEffect(() => {
+		if (!api) {
+			return;
+		}
+
+		syncState();
+
+		api.on("select", syncState);
+
+		return () => {
+			api.off("select", syncState);
+		};
+	}, [api, syncState]);
+
+	return (
+		<div
+			className={cn(
+				"flex flex-1 items-center justify-end px-3 py-1 text-muted-foreground text-xs",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? `${current}/${count}`}
+		</div>
+	);
+};
+
+export type InlineCitationCarouselPrevProps = ComponentProps<"button">;
+
+export const InlineCitationCarouselPrev = ({
+	className,
+	...props
+}: InlineCitationCarouselPrevProps) => {
+	const api = useCarouselApi();
+
+	const handleClick = useCallback(() => {
+		if (api) {
+			api.scrollPrev();
+		}
+	}, [api]);
+
+	return (
+		<button
+			aria-label="Previous"
+			className={cn("shrink-0", className)}
+			onClick={handleClick}
+			type="button"
+			{...props}
+		>
+			<ArrowLeftIcon className="size-4 text-muted-foreground" />
+		</button>
+	);
+};
+
+export type InlineCitationCarouselNextProps = ComponentProps<"button">;
+
+export const InlineCitationCarouselNext = ({
+	className,
+	...props
+}: InlineCitationCarouselNextProps) => {
+	const api = useCarouselApi();
+
+	const handleClick = useCallback(() => {
+		if (api) {
+			api.scrollNext();
+		}
+	}, [api]);
+
+	return (
+		<button
+			aria-label="Next"
+			className={cn("shrink-0", className)}
+			onClick={handleClick}
+			type="button"
+			{...props}
+		>
+			<ArrowRightIcon className="size-4 text-muted-foreground" />
+		</button>
+	);
+};
+
+export type InlineCitationSourceProps = ComponentProps<"div"> & {
+	title?: string;
+	url?: string;
+	description?: string;
+};
+
+export const InlineCitationSource = ({
+	title,
+	url,
+	description,
+	className,
+	children,
+	...props
+}: InlineCitationSourceProps) => (
+	<div className={cn("space-y-1", className)} {...props}>
+		{title && (
+			<h4 className="truncate font-medium text-sm leading-tight">{title}</h4>
+		)}
+		{url && (
+			<p className="truncate break-all text-muted-foreground text-xs">{url}</p>
+		)}
+		{description && (
+			<p className="line-clamp-3 text-muted-foreground text-sm leading-relaxed">
+				{description}
+			</p>
+		)}
+		{children}
+	</div>
+);
+
+export type InlineCitationQuoteProps = ComponentProps<"blockquote">;
+
+export const InlineCitationQuote = ({
+	children,
+	className,
+	...props
+}: InlineCitationQuoteProps) => (
+	<blockquote
+		className={cn(
+			"border-muted border-l-2 pl-3 text-muted-foreground text-sm italic",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</blockquote>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/jsx-preview.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/jsx-preview.tsx
new file mode 100644
index 0000000..4810aa7
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/jsx-preview.tsx
@@ -0,0 +1,301 @@
+"use client";
+
+import { AlertCircle } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import type { TProps as JsxParserProps } from "react-jsx-parser";
+import JsxParser from "react-jsx-parser";
+import { cn } from "@/lib/utils";
+
+interface JSXPreviewContextValue {
+	jsx: string;
+	processedJsx: string;
+	isStreaming: boolean;
+	error: Error | null;
+	setError: (error: Error | null) => void;
+	setLastGoodJsx: (jsx: string) => void;
+	components: JsxParserProps["components"];
+	bindings: JsxParserProps["bindings"];
+	onErrorProp?: (error: Error) => void;
+}
+
+const JSXPreviewContext = createContext<JSXPreviewContextValue | null>(null);
+
+const TAG_REGEX = /<\/?([a-zA-Z][a-zA-Z0-9]*)\s*([^>]*?)(\/)?>/;
+
+export const useJSXPreview = () => {
+	const context = useContext(JSXPreviewContext);
+	if (!context) {
+		throw new Error("JSXPreview components must be used within JSXPreview");
+	}
+	return context;
+};
+
+const matchJsxTag = (code: string) => {
+	if (code.trim() === "") {
+		return null;
+	}
+
+	const match = code.match(TAG_REGEX);
+
+	if (!match || match.index === undefined) {
+		return null;
+	}
+
+	const [fullMatch, tagName, attributes, selfClosing] = match;
+
+	let type: "self-closing" | "closing" | "opening";
+	if (selfClosing) {
+		type = "self-closing";
+	} else if (fullMatch.startsWith("</")) {
+		type = "closing";
+	} else {
+		type = "opening";
+	}
+
+	return {
+		attributes: attributes.trim(),
+		endIndex: match.index + fullMatch.length,
+		startIndex: match.index,
+		tag: fullMatch,
+		tagName,
+		type,
+	};
+};
+
+const stripIncompleteTag = (text: string) => {
+	// Find the last '<' that isn't part of a complete tag
+	const lastOpen = text.lastIndexOf("<");
+	if (lastOpen === -1) {
+		return text;
+	}
+
+	const afterOpen = text.slice(lastOpen);
+	// If there's no closing '>' after the last '<', it's an incomplete tag
+	if (!afterOpen.includes(">")) {
+		return text.slice(0, lastOpen);
+	}
+
+	return text;
+};
+
+const completeJsxTag = (code: string) => {
+	const stack: string[] = [];
+	let result = "";
+	let currentPosition = 0;
+
+	while (currentPosition < code.length) {
+		const match = matchJsxTag(code.slice(currentPosition));
+		if (!match) {
+			// No more tags found, strip any trailing incomplete tag
+			result += stripIncompleteTag(code.slice(currentPosition));
+			break;
+		}
+		const { tagName, type, endIndex } = match;
+
+		// Include any text content before this tag
+		result += code.slice(currentPosition, currentPosition + endIndex);
+
+		if (type === "opening") {
+			stack.push(tagName);
+		} else if (type === "closing") {
+			stack.pop();
+		}
+
+		currentPosition += endIndex;
+	}
+
+	return (
+		result +
+		stack
+			.toReversed()
+			.map((tag) => `</${tag}>`)
+			.join("")
+	);
+};
+
+export type JSXPreviewProps = ComponentProps<"div"> & {
+	jsx: string;
+	isStreaming?: boolean;
+	components?: JsxParserProps["components"];
+	bindings?: JsxParserProps["bindings"];
+	onError?: (error: Error) => void;
+};
+
+export const JSXPreview = memo(
+	({
+		jsx,
+		isStreaming = false,
+		components,
+		bindings,
+		onError,
+		className,
+		children,
+		...props
+	}: JSXPreviewProps) => {
+		const [prevJsx, setPrevJsx] = useState(jsx);
+		const [error, setError] = useState<Error | null>(null);
+		const [_lastGoodJsx, setLastGoodJsx] = useState("");
+
+		// Clear error when jsx changes (derived state pattern)
+		if (jsx !== prevJsx) {
+			setPrevJsx(jsx);
+			setError(null);
+		}
+
+		const processedJsx = useMemo(
+			() => (isStreaming ? completeJsxTag(jsx) : jsx),
+			[jsx, isStreaming],
+		);
+
+		const contextValue = useMemo(
+			() => ({
+				bindings,
+				components,
+				error,
+				isStreaming,
+				jsx,
+				onErrorProp: onError,
+				processedJsx,
+				setError,
+				setLastGoodJsx,
+			}),
+			[bindings, components, error, isStreaming, jsx, onError, processedJsx],
+		);
+
+		return (
+			<JSXPreviewContext.Provider value={contextValue}>
+				<div className={cn("relative", className)} {...props}>
+					{children}
+				</div>
+			</JSXPreviewContext.Provider>
+		);
+	},
+);
+
+JSXPreview.displayName = "JSXPreview";
+
+export type JSXPreviewContentProps = Omit<ComponentProps<"div">, "children">;
+
+export const JSXPreviewContent = memo(
+	({ className, ...props }: JSXPreviewContentProps) => {
+		const {
+			processedJsx,
+			isStreaming,
+			components,
+			bindings,
+			setError,
+			setLastGoodJsx,
+			onErrorProp,
+		} = useJSXPreview();
+		const errorReportedRef = useRef<string | null>(null);
+		const lastGoodJsxRef = useRef("");
+		const [hadError, setHadError] = useState(false);
+
+		// Reset error tracking when jsx changes
+		useEffect(() => {
+			errorReportedRef.current = null;
+			setHadError(false);
+		}, []);
+
+		const handleError = useCallback(
+			(err: Error) => {
+				// Prevent duplicate error reports for the same jsx
+				if (errorReportedRef.current === processedJsx) {
+					return;
+				}
+				errorReportedRef.current = processedJsx;
+
+				// During streaming, suppress errors and fall back to last good JSX
+				if (isStreaming) {
+					setHadError(true);
+					return;
+				}
+
+				setError(err);
+				onErrorProp?.(err);
+			},
+			[processedJsx, isStreaming, onErrorProp, setError],
+		);
+
+		// Track the last JSX that rendered without error
+		useEffect(() => {
+			if (!errorReportedRef.current) {
+				lastGoodJsxRef.current = processedJsx;
+				setLastGoodJsx(processedJsx);
+			}
+		}, [processedJsx, setLastGoodJsx]);
+
+		// During streaming, if the current JSX errored, re-render with last good version
+		const displayJsx =
+			isStreaming && hadError ? lastGoodJsxRef.current : processedJsx;
+
+		return (
+			<div className={cn("jsx-preview-content", className)} {...props}>
+				<JsxParser
+					bindings={bindings}
+					components={components}
+					jsx={displayJsx}
+					onError={handleError}
+					renderInWrapper={false}
+				/>
+			</div>
+		);
+	},
+);
+
+JSXPreviewContent.displayName = "JSXPreviewContent";
+
+export type JSXPreviewErrorProps = ComponentProps<"div"> & {
+	children?: ReactNode | ((error: Error) => ReactNode);
+};
+
+const renderChildren = (
+	children: ReactNode | ((error: Error) => ReactNode),
+	error: Error,
+): ReactNode => {
+	if (typeof children === "function") {
+		return children(error);
+	}
+	return children;
+};
+
+export const JSXPreviewError = memo(
+	({ className, children, ...props }: JSXPreviewErrorProps) => {
+		const { error } = useJSXPreview();
+
+		if (!error) {
+			return null;
+		}
+
+		return (
+			<div
+				className={cn(
+					"flex items-center gap-2 rounded-md border border-destructive/50 bg-destructive/10 p-3 text-destructive text-sm",
+					className,
+				)}
+				{...props}
+			>
+				{children ? (
+					renderChildren(children, error)
+				) : (
+					<>
+						<AlertCircle className="size-4 shrink-0" />
+						<span>{error.message}</span>
+					</>
+				)}
+			</div>
+		);
+	},
+);
+
+JSXPreviewError.displayName = "JSXPreviewError";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/message.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/message.tsx
new file mode 100644
index 0000000..fae527b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/message.tsx
@@ -0,0 +1,347 @@
+"use client";
+
+import type { UIMessage } from "ai";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes, ReactElement } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import { ButtonGroup, ButtonGroupText } from "@/components/ui/button-group";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+import { HubStreamdown } from "./streamdown";
+
+export type MessageProps = HTMLAttributes<HTMLDivElement> & {
+	from: UIMessage["role"];
+};
+
+export const Message = ({ className, from, ...props }: MessageProps) => (
+	<div
+		className={cn(
+			"group flex w-full flex-col gap-2",
+			from === "user" ? "is-user ml-auto justify-end" : "is-assistant",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type MessageContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const MessageContent = ({
+	children,
+	className,
+	...props
+}: MessageContentProps) => (
+	<div
+		className={cn(
+			"is-user:dark flex w-full flex-col gap-2 overflow-hidden text-sm",
+			"group-[.is-user]:ml-auto group-[.is-user]:rounded-lg group-[.is-user]:bg-secondary group-[.is-user]:px-4 group-[.is-user]:py-3 group-[.is-user]:text-foreground",
+			"group-[.is-assistant]:text-foreground",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type MessageActionsProps = ComponentProps<"div">;
+
+export const MessageActions = ({
+	className,
+	children,
+	...props
+}: MessageActionsProps) => (
+	<div className={cn("flex items-center gap-1", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type MessageActionProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+	label?: string;
+};
+
+export const MessageAction = ({
+	tooltip,
+	children,
+	label,
+	variant = "ghost",
+	size = "icon-sm",
+	...props
+}: MessageActionProps) => {
+	const button = (
+		<Button size={size} type="button" variant={variant} {...props}>
+			{children}
+			<span className="sr-only">{label || tooltip}</span>
+		</Button>
+	);
+
+	if (tooltip) {
+		return (
+			<TooltipProvider>
+				<Tooltip>
+					<TooltipTrigger>{button}</TooltipTrigger>
+					<TooltipContent>
+						<p>{tooltip}</p>
+					</TooltipContent>
+				</Tooltip>
+			</TooltipProvider>
+		);
+	}
+
+	return button;
+};
+
+interface MessageBranchContextType {
+	currentBranch: number;
+	totalBranches: number;
+	goToPrevious: () => void;
+	goToNext: () => void;
+	branches: ReactElement[];
+	setBranches: (branches: ReactElement[]) => void;
+}
+
+const MessageBranchContext = createContext<MessageBranchContextType | null>(
+	null,
+);
+
+const useMessageBranch = () => {
+	const context = useContext(MessageBranchContext);
+
+	if (!context) {
+		throw new Error(
+			"MessageBranch components must be used within MessageBranch",
+		);
+	}
+
+	return context;
+};
+
+export type MessageBranchProps = HTMLAttributes<HTMLDivElement> & {
+	defaultBranch?: number;
+	onBranchChange?: (branchIndex: number) => void;
+};
+
+export const MessageBranch = ({
+	defaultBranch = 0,
+	onBranchChange,
+	className,
+	...props
+}: MessageBranchProps) => {
+	const [currentBranch, setCurrentBranch] = useState(defaultBranch);
+	const [branches, setBranches] = useState<ReactElement[]>([]);
+
+	const handleBranchChange = useCallback(
+		(newBranch: number) => {
+			setCurrentBranch(newBranch);
+			onBranchChange?.(newBranch);
+		},
+		[onBranchChange],
+	);
+
+	const goToPrevious = useCallback(() => {
+		const newBranch =
+			currentBranch > 0 ? currentBranch - 1 : branches.length - 1;
+		handleBranchChange(newBranch);
+	}, [currentBranch, branches.length, handleBranchChange]);
+
+	const goToNext = useCallback(() => {
+		const newBranch =
+			currentBranch < branches.length - 1 ? currentBranch + 1 : 0;
+		handleBranchChange(newBranch);
+	}, [currentBranch, branches.length, handleBranchChange]);
+
+	const contextValue = useMemo<MessageBranchContextType>(
+		() => ({
+			branches,
+			currentBranch,
+			goToNext,
+			goToPrevious,
+			setBranches,
+			totalBranches: branches.length,
+		}),
+		[branches, currentBranch, goToNext, goToPrevious],
+	);
+
+	return (
+		<MessageBranchContext.Provider value={contextValue}>
+			<div
+				className={cn("grid w-full gap-2 [&>div]:pb-0", className)}
+				{...props}
+			/>
+		</MessageBranchContext.Provider>
+	);
+};
+
+export type MessageBranchContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const MessageBranchContent = ({
+	children,
+	...props
+}: MessageBranchContentProps) => {
+	const { currentBranch, setBranches, branches } = useMessageBranch();
+	const childrenArray = useMemo(
+		() => (Array.isArray(children) ? children : [children]),
+		[children],
+	);
+
+	// Use useEffect to update branches when they change
+	useEffect(() => {
+		if (branches.length !== childrenArray.length) {
+			setBranches(childrenArray);
+		}
+	}, [childrenArray, branches, setBranches]);
+
+	return childrenArray.map((branch, index) => (
+		<div
+			className={cn(
+				"grid gap-2 overflow-hidden [&>div]:pb-0",
+				index === currentBranch ? "block" : "hidden",
+			)}
+			key={branch.key}
+			{...props}
+		>
+			{branch}
+		</div>
+	));
+};
+
+export type MessageBranchSelectorProps = ComponentProps<typeof ButtonGroup>;
+
+export const MessageBranchSelector = ({
+	className,
+	...props
+}: MessageBranchSelectorProps) => {
+	const { totalBranches } = useMessageBranch();
+
+	// Don't render if there's only one branch
+	if (totalBranches <= 1) {
+		return null;
+	}
+
+	return (
+		<ButtonGroup
+			className={cn(
+				"[&>*:not(:first-child)]:rounded-l-md [&>*:not(:last-child)]:rounded-r-md",
+				className,
+			)}
+			orientation="horizontal"
+			{...props}
+		/>
+	);
+};
+
+export type MessageBranchPreviousProps = ComponentProps<typeof Button>;
+
+export const MessageBranchPrevious = ({
+	children,
+	...props
+}: MessageBranchPreviousProps) => {
+	const { goToPrevious, totalBranches } = useMessageBranch();
+
+	return (
+		<Button
+			aria-label="Previous branch"
+			disabled={totalBranches <= 1}
+			onClick={goToPrevious}
+			size="icon-sm"
+			type="button"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <ChevronLeftIcon size={14} />}
+		</Button>
+	);
+};
+
+export type MessageBranchNextProps = ComponentProps<typeof Button>;
+
+export const MessageBranchNext = ({
+	children,
+	...props
+}: MessageBranchNextProps) => {
+	const { goToNext, totalBranches } = useMessageBranch();
+
+	return (
+		<Button
+			aria-label="Next branch"
+			disabled={totalBranches <= 1}
+			onClick={goToNext}
+			size="icon-sm"
+			type="button"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <ChevronRightIcon size={14} />}
+		</Button>
+	);
+};
+
+export type MessageBranchPageProps = HTMLAttributes<HTMLSpanElement>;
+
+export const MessageBranchPage = ({
+	className,
+	...props
+}: MessageBranchPageProps) => {
+	const { currentBranch, totalBranches } = useMessageBranch();
+
+	return (
+		<ButtonGroupText
+			className={cn(
+				"border-none bg-transparent text-muted-foreground shadow-none",
+				className,
+			)}
+			{...props}
+		>
+			{currentBranch + 1} of {totalBranches}
+		</ButtonGroupText>
+	);
+};
+
+export type MessageResponseProps = ComponentProps<typeof HubStreamdown>;
+
+export const MessageResponse = memo(
+	({ className, ...props }: MessageResponseProps) => (
+		<HubStreamdown
+			className={cn(
+				"size-full [&>*:first-child]:mt-0 [&>*:last-child]:mb-0",
+				className,
+			)}
+			{...props}
+		/>
+	),
+);
+
+MessageResponse.displayName = "MessageResponse";
+
+export type MessageToolbarProps = ComponentProps<"div">;
+
+export const MessageToolbar = ({
+	className,
+	children,
+	...props
+}: MessageToolbarProps) => (
+	<div
+		className={cn(
+			"mt-4 flex w-full items-center justify-between gap-4",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/mic-selector.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/mic-selector.tsx
new file mode 100644
index 0000000..338df9a
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/mic-selector.tsx
@@ -0,0 +1,373 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { ChevronsUpDownIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Command,
+	CommandEmpty,
+	CommandInput,
+	CommandItem,
+	CommandList,
+} from "@/components/ui/command";
+import {
+	Popover,
+	PopoverContent,
+	PopoverTrigger,
+} from "@/components/ui/popover";
+import { cn } from "@/lib/utils";
+
+const deviceIdRegex = /\(([\da-fA-F]{4}:[\da-fA-F]{4})\)$/;
+
+interface MicSelectorContextType {
+	data: MediaDeviceInfo[];
+	value: string | undefined;
+	onValueChange?: (value: string) => void;
+	open: boolean;
+	onOpenChange?: (open: boolean) => void;
+	width: number;
+	setWidth?: (width: number) => void;
+}
+
+const MicSelectorContext = createContext<MicSelectorContextType>({
+	data: [],
+	onOpenChange: undefined,
+	onValueChange: undefined,
+	open: false,
+	setWidth: undefined,
+	value: undefined,
+	width: 200,
+});
+
+export const useAudioDevices = () => {
+	const [devices, setDevices] = useState<MediaDeviceInfo[]>([]);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState<string | null>(null);
+	const [hasPermission, setHasPermission] = useState(false);
+
+	const loadDevicesWithoutPermission = useCallback(async () => {
+		try {
+			setLoading(true);
+			setError(null);
+
+			const deviceList = await navigator.mediaDevices.enumerateDevices();
+			const audioInputs = deviceList.filter(
+				(device) => device.kind === "audioinput",
+			);
+
+			setDevices(audioInputs);
+		} catch (caughtError) {
+			const message =
+				caughtError instanceof Error
+					? caughtError.message
+					: "Failed to get audio devices";
+
+			setError(message);
+			console.error("Error getting audio devices:", message);
+		} finally {
+			setLoading(false);
+		}
+	}, []);
+
+	const loadDevicesWithPermission = useCallback(async () => {
+		if (loading) {
+			return;
+		}
+
+		try {
+			setLoading(true);
+			setError(null);
+
+			const tempStream = await navigator.mediaDevices.getUserMedia({
+				audio: true,
+			});
+
+			for (const track of tempStream.getTracks()) {
+				track.stop();
+			}
+
+			const deviceList = await navigator.mediaDevices.enumerateDevices();
+			const audioInputs = deviceList.filter(
+				(device) => device.kind === "audioinput",
+			);
+
+			setDevices(audioInputs);
+			setHasPermission(true);
+		} catch (caughtError) {
+			const message =
+				caughtError instanceof Error
+					? caughtError.message
+					: "Failed to get audio devices";
+
+			setError(message);
+			console.error("Error getting audio devices:", message);
+		} finally {
+			setLoading(false);
+		}
+	}, [loading]);
+
+	useEffect(() => {
+		loadDevicesWithoutPermission();
+	}, [loadDevicesWithoutPermission]);
+
+	useEffect(() => {
+		const handleDeviceChange = () => {
+			if (hasPermission) {
+				loadDevicesWithPermission();
+			} else {
+				loadDevicesWithoutPermission();
+			}
+		};
+
+		navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
+
+		return () => {
+			navigator.mediaDevices.removeEventListener(
+				"devicechange",
+				handleDeviceChange,
+			);
+		};
+	}, [hasPermission, loadDevicesWithPermission, loadDevicesWithoutPermission]);
+
+	return {
+		devices,
+		error,
+		hasPermission,
+		loadDevices: loadDevicesWithPermission,
+		loading,
+	};
+};
+
+export type MicSelectorProps = ComponentProps<typeof Popover> & {
+	defaultValue?: string;
+	value?: string | undefined;
+	onValueChange?: (value: string | undefined) => void;
+	open?: boolean;
+	onOpenChange?: (open: boolean) => void;
+};
+
+export const MicSelector = ({
+	defaultValue,
+	value: controlledValue,
+	onValueChange: controlledOnValueChange,
+	defaultOpen = false,
+	open: controlledOpen,
+	onOpenChange: controlledOnOpenChange,
+	...props
+}: MicSelectorProps) => {
+	const [value, onValueChange] = useControllableState<string | undefined>({
+		defaultProp: defaultValue,
+		onChange: controlledOnValueChange,
+		prop: controlledValue,
+	});
+	const [open, onOpenChange] = useControllableState({
+		defaultProp: defaultOpen,
+		onChange: controlledOnOpenChange,
+		prop: controlledOpen,
+	});
+	const [width, setWidth] = useState(200);
+	const { devices, loading, hasPermission, loadDevices } = useAudioDevices();
+
+	useEffect(() => {
+		if (open && !hasPermission && !loading) {
+			loadDevices();
+		}
+	}, [open, hasPermission, loading, loadDevices]);
+
+	const contextValue = useMemo(
+		() => ({
+			data: devices,
+			onOpenChange,
+			onValueChange,
+			open,
+			setWidth,
+			value,
+			width,
+		}),
+		[devices, onOpenChange, onValueChange, open, value, width],
+	);
+
+	return (
+		<MicSelectorContext.Provider value={contextValue}>
+			<Popover {...props} onOpenChange={onOpenChange} open={open} />
+		</MicSelectorContext.Provider>
+	);
+};
+
+export type MicSelectorTriggerProps = ComponentProps<typeof Button>;
+
+export const MicSelectorTrigger = ({
+	children,
+	...props
+}: MicSelectorTriggerProps) => {
+	const { setWidth } = useContext(MicSelectorContext);
+	const ref = useRef<HTMLButtonElement>(null);
+
+	useEffect(() => {
+		// Create a ResizeObserver to detect width changes
+		const resizeObserver = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				const newWidth = (entry.target as HTMLElement).offsetWidth;
+				if (newWidth) {
+					setWidth?.(newWidth);
+				}
+			}
+		});
+
+		if (ref.current) {
+			resizeObserver.observe(ref.current);
+		}
+
+		// Clean up the observer when component unmounts
+		return () => {
+			resizeObserver.disconnect();
+		};
+	}, [setWidth]);
+
+	return (
+		<PopoverTrigger render={<Button variant="outline" {...props} ref={ref} />}>
+			{children}
+			<ChevronsUpDownIcon
+				className="shrink-0 text-muted-foreground"
+				size={16}
+			/>
+		</PopoverTrigger>
+	);
+};
+
+export type MicSelectorContentProps = ComponentProps<typeof Command> & {
+	popoverOptions?: ComponentProps<typeof PopoverContent>;
+};
+
+export const MicSelectorContent = ({
+	className,
+	popoverOptions,
+	...props
+}: MicSelectorContentProps) => {
+	const { width, onValueChange, value } = useContext(MicSelectorContext);
+
+	return (
+		<PopoverContent
+			className={cn("p-0", className)}
+			style={{ width }}
+			{...popoverOptions}
+		>
+			<Command onValueChange={onValueChange} value={value} {...props} />
+		</PopoverContent>
+	);
+};
+
+export type MicSelectorInputProps = ComponentProps<typeof CommandInput> & {
+	value?: string;
+	defaultValue?: string;
+	onValueChange?: (value: string) => void;
+};
+
+export const MicSelectorInput = ({ ...props }: MicSelectorInputProps) => (
+	<CommandInput placeholder="Search microphones..." {...props} />
+);
+
+export type MicSelectorListProps = Omit<
+	ComponentProps<typeof CommandList>,
+	"children"
+> & {
+	children: (devices: MediaDeviceInfo[]) => ReactNode;
+};
+
+export const MicSelectorList = ({
+	children,
+	...props
+}: MicSelectorListProps) => {
+	const { data } = useContext(MicSelectorContext);
+
+	return <CommandList {...props}>{children(data)}</CommandList>;
+};
+
+export type MicSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const MicSelectorEmpty = ({
+	children = "No microphone found.",
+	...props
+}: MicSelectorEmptyProps) => <CommandEmpty {...props}>{children}</CommandEmpty>;
+
+export type MicSelectorItemProps = ComponentProps<typeof CommandItem>;
+
+export const MicSelectorItem = (props: MicSelectorItemProps) => {
+	const { onValueChange, onOpenChange } = useContext(MicSelectorContext);
+
+	const handleSelect = useCallback(
+		(currentValue: string) => {
+			onValueChange?.(currentValue);
+			onOpenChange?.(false);
+		},
+		[onValueChange, onOpenChange],
+	);
+
+	return <CommandItem onSelect={handleSelect} {...props} />;
+};
+
+export type MicSelectorLabelProps = ComponentProps<"span"> & {
+	device: MediaDeviceInfo;
+};
+
+export const MicSelectorLabel = ({
+	device,
+	className,
+	...props
+}: MicSelectorLabelProps) => {
+	const matches = device.label.match(deviceIdRegex);
+
+	if (!matches) {
+		return (
+			<span className={className} {...props}>
+				{device.label}
+			</span>
+		);
+	}
+
+	const [, deviceId] = matches;
+	const name = device.label.replace(deviceIdRegex, "");
+
+	return (
+		<span className={className} {...props}>
+			<span>{name}</span>
+			<span className="text-muted-foreground"> ({deviceId})</span>
+		</span>
+	);
+};
+
+export type MicSelectorValueProps = ComponentProps<"span">;
+
+export const MicSelectorValue = ({
+	className,
+	...props
+}: MicSelectorValueProps) => {
+	const { data, value } = useContext(MicSelectorContext);
+	const currentDevice = data.find((d) => d.deviceId === value);
+
+	if (!currentDevice) {
+		return (
+			<span className={cn("flex-1 text-left", className)} {...props}>
+				Select microphone...
+			</span>
+		);
+	}
+
+	return (
+		<MicSelectorLabel
+			className={cn("flex-1 text-left", className)}
+			device={currentDevice}
+			{...props}
+		/>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/model-selector.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/model-selector.tsx
new file mode 100644
index 0000000..193d178
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/model-selector.tsx
@@ -0,0 +1,213 @@
+import type { ComponentProps, ReactNode } from "react";
+import {
+	Command,
+	CommandDialog,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+	CommandSeparator,
+	CommandShortcut,
+} from "@/components/ui/command";
+import {
+	Dialog,
+	DialogContent,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { cn } from "@/lib/utils";
+
+export type ModelSelectorProps = ComponentProps<typeof Dialog>;
+
+export const ModelSelector = (props: ModelSelectorProps) => (
+	<Dialog {...props} />
+);
+
+export type ModelSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+
+export const ModelSelectorTrigger = (props: ModelSelectorTriggerProps) => (
+	<DialogTrigger {...props} />
+);
+
+export type ModelSelectorContentProps = ComponentProps<typeof DialogContent> & {
+	title?: ReactNode;
+};
+
+export const ModelSelectorContent = ({
+	className,
+	children,
+	title = "Model Selector",
+	...props
+}: ModelSelectorContentProps) => (
+	<DialogContent
+		aria-describedby={undefined}
+		className={cn(
+			"outline! border-none! p-0 outline-border! outline-solid!",
+			className,
+		)}
+		{...props}
+	>
+		<DialogTitle className="sr-only">{title}</DialogTitle>
+		<Command className="**:data-[slot=command-input-wrapper]:h-auto">
+			{children}
+		</Command>
+	</DialogContent>
+);
+
+export type ModelSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+
+export const ModelSelectorDialog = (props: ModelSelectorDialogProps) => (
+	<CommandDialog {...props} />
+);
+
+export type ModelSelectorInputProps = ComponentProps<typeof CommandInput>;
+
+export const ModelSelectorInput = ({
+	className,
+	...props
+}: ModelSelectorInputProps) => (
+	<CommandInput className={cn("h-auto py-3.5", className)} {...props} />
+);
+
+export type ModelSelectorListProps = ComponentProps<typeof CommandList>;
+
+export const ModelSelectorList = (props: ModelSelectorListProps) => (
+	<CommandList {...props} />
+);
+
+export type ModelSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const ModelSelectorEmpty = (props: ModelSelectorEmptyProps) => (
+	<CommandEmpty {...props} />
+);
+
+export type ModelSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+
+export const ModelSelectorGroup = (props: ModelSelectorGroupProps) => (
+	<CommandGroup {...props} />
+);
+
+export type ModelSelectorItemProps = ComponentProps<typeof CommandItem>;
+
+export const ModelSelectorItem = (props: ModelSelectorItemProps) => (
+	<CommandItem {...props} />
+);
+
+export type ModelSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+
+export const ModelSelectorShortcut = (props: ModelSelectorShortcutProps) => (
+	<CommandShortcut {...props} />
+);
+
+export type ModelSelectorSeparatorProps = ComponentProps<
+	typeof CommandSeparator
+>;
+
+export const ModelSelectorSeparator = (props: ModelSelectorSeparatorProps) => (
+	<CommandSeparator {...props} />
+);
+
+export type ModelSelectorLogoProps = Omit<
+	ComponentProps<"img">,
+	"src" | "alt"
+> & {
+	provider:
+		| "moonshotai-cn"
+		| "lucidquery"
+		| "moonshotai"
+		| "zai-coding-plan"
+		| "alibaba"
+		| "xai"
+		| "vultr"
+		| "nvidia"
+		| "upstage"
+		| "groq"
+		| "github-copilot"
+		| "mistral"
+		| "vercel"
+		| "nebius"
+		| "deepseek"
+		| "alibaba-cn"
+		| "google-vertex-anthropic"
+		| "venice"
+		| "chutes"
+		| "cortecs"
+		| "github-models"
+		| "togetherai"
+		| "azure"
+		| "baseten"
+		| "huggingface"
+		| "opencode"
+		| "fastrouter"
+		| "google"
+		| "google-vertex"
+		| "cloudflare-workers-ai"
+		| "inception"
+		| "wandb"
+		| "openai"
+		| "zhipuai-coding-plan"
+		| "perplexity"
+		| "openrouter"
+		| "zenmux"
+		| "v0"
+		| "iflowcn"
+		| "synthetic"
+		| "deepinfra"
+		| "zhipuai"
+		| "submodel"
+		| "zai"
+		| "inference"
+		| "requesty"
+		| "morph"
+		| "lmstudio"
+		| "anthropic"
+		| "aihubmix"
+		| "fireworks-ai"
+		| "modelscope"
+		| "llama"
+		| "scaleway"
+		| "amazon-bedrock"
+		| "cerebras"
+		// oxlint-disable-next-line typescript-eslint(ban-types) -- intentional pattern for autocomplete-friendly string union
+		| (string & {});
+};
+
+export const ModelSelectorLogo = ({
+	provider,
+	className,
+	...props
+}: ModelSelectorLogoProps) => (
+	<img
+		{...props}
+		alt={`${provider} logo`}
+		className={cn("size-3 dark:invert", className)}
+		height={12}
+		src={`https://models.dev/logos/${provider}.svg`}
+		width={12}
+	/>
+);
+
+export type ModelSelectorLogoGroupProps = ComponentProps<"div">;
+
+export const ModelSelectorLogoGroup = ({
+	className,
+	...props
+}: ModelSelectorLogoGroupProps) => (
+	<div
+		className={cn(
+			"flex shrink-0 items-center -space-x-1 [&>img]:rounded-full [&>img]:bg-background [&>img]:p-px [&>img]:ring-1 dark:[&>img]:bg-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ModelSelectorNameProps = ComponentProps<"span">;
+
+export const ModelSelectorName = ({
+	className,
+	...props
+}: ModelSelectorNameProps) => (
+	<span className={cn("flex-1 truncate text-left", className)} {...props} />
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/node.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/node.tsx
new file mode 100644
index 0000000..b584069
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/node.tsx
@@ -0,0 +1,71 @@
+import { Handle, Position } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import {
+	Card,
+	CardAction,
+	CardContent,
+	CardDescription,
+	CardFooter,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import { cn } from "@/lib/utils";
+
+export type NodeProps = ComponentProps<typeof Card> & {
+	handles: {
+		target: boolean;
+		source: boolean;
+	};
+};
+
+export const Node = ({ handles, className, ...props }: NodeProps) => (
+	<Card
+		className={cn(
+			"node-container relative size-full h-auto w-sm gap-0 rounded-md p-0",
+			className,
+		)}
+		{...props}
+	>
+		{handles.target && <Handle position={Position.Left} type="target" />}
+		{handles.source && <Handle position={Position.Right} type="source" />}
+		{props.children}
+	</Card>
+);
+
+export type NodeHeaderProps = ComponentProps<typeof CardHeader>;
+
+export const NodeHeader = ({ className, ...props }: NodeHeaderProps) => (
+	<CardHeader
+		className={cn("gap-0.5 rounded-t-md border-b bg-secondary p-3!", className)}
+		{...props}
+	/>
+);
+
+export type NodeTitleProps = ComponentProps<typeof CardTitle>;
+
+export const NodeTitle = (props: NodeTitleProps) => <CardTitle {...props} />;
+
+export type NodeDescriptionProps = ComponentProps<typeof CardDescription>;
+
+export const NodeDescription = (props: NodeDescriptionProps) => (
+	<CardDescription {...props} />
+);
+
+export type NodeActionProps = ComponentProps<typeof CardAction>;
+
+export const NodeAction = (props: NodeActionProps) => <CardAction {...props} />;
+
+export type NodeContentProps = ComponentProps<typeof CardContent>;
+
+export const NodeContent = ({ className, ...props }: NodeContentProps) => (
+	<CardContent className={cn("p-3", className)} {...props} />
+);
+
+export type NodeFooterProps = ComponentProps<typeof CardFooter>;
+
+export const NodeFooter = ({ className, ...props }: NodeFooterProps) => (
+	<CardFooter
+		className={cn("rounded-b-md border-t bg-secondary p-3!", className)}
+		{...props}
+	/>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/open-in-chat.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/open-in-chat.tsx
new file mode 100644
index 0000000..52f9a4e
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/open-in-chat.tsx
@@ -0,0 +1,394 @@
+"use client";
+
+import {
+	ChevronDownIcon,
+	ExternalLinkIcon,
+	MessageCircleIcon,
+} from "lucide-react";
+import type { ComponentProps } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuLabel,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { cn } from "@/lib/utils";
+
+const providers = {
+	chatgpt: {
+		createUrl: (prompt: string) =>
+			`https://chatgpt.com/?${new URLSearchParams({
+				hints: "search",
+				prompt,
+			})}`,
+		icon: (
+			<svg
+				fill="currentColor"
+				role="img"
+				viewBox="0 0 24 24"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>OpenAI</title>
+				<path d="M22.2819 9.8211a5.9847 5.9847 0 0 0-.5157-4.9108 6.0462 6.0462 0 0 0-6.5098-2.9A6.0651 6.0651 0 0 0 4.9807 4.1818a5.9847 5.9847 0 0 0-3.9977 2.9 6.0462 6.0462 0 0 0 .7427 7.0966 5.98 5.98 0 0 0 .511 4.9107 6.051 6.051 0 0 0 6.5146 2.9001A5.9847 5.9847 0 0 0 13.2599 24a6.0557 6.0557 0 0 0 5.7718-4.2058 5.9894 5.9894 0 0 0 3.9977-2.9001 6.0557 6.0557 0 0 0-.7475-7.0729zm-9.022 12.6081a4.4755 4.4755 0 0 1-2.8764-1.0408l.1419-.0804 4.7783-2.7582a.7948.7948 0 0 0 .3927-.6813v-6.7369l2.02 1.1686a.071.071 0 0 1 .038.052v5.5826a4.504 4.504 0 0 1-4.4945 4.4944zm-9.6607-4.1254a4.4708 4.4708 0 0 1-.5346-3.0137l.142.0852 4.783 2.7582a.7712.7712 0 0 0 .7806 0l5.8428-3.3685v2.3324a.0804.0804 0 0 1-.0332.0615L9.74 19.9502a4.4992 4.4992 0 0 1-6.1408-1.6464zM2.3408 7.8956a4.485 4.485 0 0 1 2.3655-1.9728V11.6a.7664.7664 0 0 0 .3879.6765l5.8144 3.3543-2.0201 1.1685a.0757.0757 0 0 1-.071 0l-4.8303-2.7865A4.504 4.504 0 0 1 2.3408 7.872zm16.5963 3.8558L13.1038 8.364 15.1192 7.2a.0757.0757 0 0 1 .071 0l4.8303 2.7913a4.4944 4.4944 0 0 1-.6765 8.1042v-5.6772a.79.79 0 0 0-.407-.667zm2.0107-3.0231l-.142-.0852-4.7735-2.7818a.7759.7759 0 0 0-.7854 0L9.409 9.2297V6.8974a.0662.0662 0 0 1 .0284-.0615l4.8303-2.7866a4.4992 4.4992 0 0 1 6.6802 4.66zM8.3065 12.863l-2.02-1.1638a.0804.0804 0 0 1-.038-.0567V6.0742a4.4992 4.4992 0 0 1 7.3757-3.4537l-.142.0805L8.704 5.459a.7948.7948 0 0 0-.3927.6813zm1.0976-2.3654l2.602-1.4998 2.6069 1.4998v2.9994l-2.5974 1.4997-2.6067-1.4997Z" />
+			</svg>
+		),
+		title: "Open in ChatGPT",
+	},
+	claude: {
+		createUrl: (q: string) =>
+			`https://claude.ai/new?${new URLSearchParams({
+				q,
+			})}`,
+		icon: (
+			<svg
+				fill="currentColor"
+				role="img"
+				viewBox="0 0 12 12"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>Claude</title>
+				<path
+					clipRule="evenodd"
+					d="M2.3545 7.9775L4.7145 6.654L4.7545 6.539L4.7145 6.475H4.6L4.205 6.451L2.856 6.4145L1.6865 6.366L0.5535 6.305L0.268 6.2445L0 5.892L0.0275 5.716L0.2675 5.5555L0.6105 5.5855L1.3705 5.637L2.5095 5.716L3.3355 5.7645L4.56 5.892H4.7545L4.782 5.8135L4.715 5.7645L4.6635 5.716L3.4845 4.918L2.2085 4.074L1.5405 3.588L1.1785 3.3425L0.9965 3.1115L0.9175 2.6075L1.2455 2.2465L1.686 2.2765L1.7985 2.307L2.245 2.65L3.199 3.388L4.4445 4.3045L4.627 4.4565L4.6995 4.405L4.709 4.3685L4.627 4.2315L3.9495 3.0085L3.2265 1.7635L2.9045 1.2475L2.8195 0.938C2.78711 0.819128 2.76965 0.696687 2.7675 0.5735L3.1415 0.067L3.348 0L3.846 0.067L4.056 0.249L4.366 0.956L4.867 2.0705L5.6445 3.5855L5.8725 4.0345L5.994 4.4505L6.0395 4.578H6.1185V4.505L6.1825 3.652L6.301 2.6045L6.416 1.257L6.456 0.877L6.644 0.422L7.0175 0.176L7.3095 0.316L7.5495 0.6585L7.516 0.8805L7.373 1.806L7.0935 3.2575L6.9115 4.2285H7.0175L7.139 4.1075L7.6315 3.4545L8.4575 2.4225L8.8225 2.0125L9.2475 1.5605L9.521 1.345H10.0375L10.4175 1.9095L10.2475 2.4925L9.7155 3.166L9.275 3.737L8.643 4.587L8.248 5.267L8.2845 5.322L8.3785 5.312L9.8065 5.009L10.578 4.869L11.4985 4.7115L11.915 4.9055L11.9605 5.103L11.7965 5.5065L10.812 5.7495L9.6575 5.9805L7.938 6.387L7.917 6.402L7.9415 6.4325L8.716 6.5055L9.047 6.5235H9.858L11.368 6.636L11.763 6.897L12 7.216L11.9605 7.4585L11.353 7.7685L10.533 7.574L8.6185 7.119L7.9625 6.9545H7.8715V7.0095L8.418 7.5435L9.421 8.4485L10.6755 9.6135L10.739 9.9025L10.578 10.13L10.408 10.1055L9.3055 9.277L8.88 8.9035L7.917 8.0935H7.853V8.1785L8.075 8.503L9.2475 10.2635L9.3085 10.8035L9.2235 10.98L8.9195 11.0865L8.5855 11.0255L7.8985 10.063L7.191 8.9795L6.6195 8.008L6.5495 8.048L6.2125 11.675L6.0545 11.86L5.69 12L5.3865 11.7695L5.2255 11.396L5.3865 10.658L5.581 9.696L5.7385 8.931L5.8815 7.981L5.9665 7.665L5.9605 7.644L5.8905 7.653L5.1735 8.6365L4.0835 10.109L3.2205 11.0315L3.0135 11.1135L2.655 10.9285L2.6885 10.5975L2.889 10.303L4.083 8.785L4.803 7.844L5.268 7.301L5.265 7.222H5.2375L2.066 9.28L1.501 9.353L1.2575 9.125L1.288 8.752L1.4035 8.6305L2.3575 7.9745L2.3545 7.9775Z"
+					fillRule="evenodd"
+				/>
+			</svg>
+		),
+		title: "Open in Claude",
+	},
+	cursor: {
+		createUrl: (text: string) => {
+			const url = new URL("https://cursor.com/link/prompt");
+			url.searchParams.set("text", text);
+			return url.toString();
+		},
+		icon: (
+			<svg
+				version="1.1"
+				viewBox="0 0 466.73 532.09"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>Cursor</title>
+				<path
+					d="M457.43,125.94L244.42,2.96c-6.84-3.95-15.28-3.95-22.12,0L9.3,125.94c-5.75,3.32-9.3,9.46-9.3,16.11v247.99c0,6.65,3.55,12.79,9.3,16.11l213.01,122.98c6.84,3.95,15.28,3.95,22.12,0l213.01-122.98c5.75-3.32,9.3-9.46,9.3-16.11v-247.99c0-6.65-3.55-12.79-9.3-16.11h-.01ZM444.05,151.99l-205.63,356.16c-1.39,2.4-5.06,1.42-5.06-1.36v-233.21c0-4.66-2.49-8.97-6.53-11.31L24.87,145.67c-2.4-1.39-1.42-5.06,1.36-5.06h411.26c5.84,0,9.49,6.33,6.57,11.39h-.01Z"
+					fill="currentColor"
+				/>
+			</svg>
+		),
+		title: "Open in Cursor",
+	},
+	github: {
+		createUrl: (url: string) => url,
+		icon: (
+			<svg fill="currentColor" role="img" viewBox="0 0 24 24">
+				<title>GitHub</title>
+				<path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12" />
+			</svg>
+		),
+		title: "Open in GitHub",
+	},
+	scira: {
+		createUrl: (q: string) =>
+			`https://scira.ai/?${new URLSearchParams({
+				q,
+			})}`,
+		icon: (
+			<svg
+				fill="none"
+				height="934"
+				viewBox="0 0 910 934"
+				width="910"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>Scira AI</title>
+				<path
+					d="M647.664 197.775C569.13 189.049 525.5 145.419 516.774 66.8849C508.048 145.419 464.418 189.049 385.884 197.775C464.418 206.501 508.048 250.131 516.774 328.665C525.5 250.131 569.13 206.501 647.664 197.775Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M516.774 304.217C510.299 275.491 498.208 252.087 480.335 234.214C462.462 216.341 439.058 204.251 410.333 197.775C439.059 191.3 462.462 179.209 480.335 161.336C498.208 143.463 510.299 120.06 516.774 91.334C523.25 120.059 535.34 143.463 553.213 161.336C571.086 179.209 594.49 191.3 623.216 197.775C594.49 204.251 571.086 216.341 553.213 234.214C535.34 252.087 523.25 275.491 516.774 304.217Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M857.5 508.116C763.259 497.644 710.903 445.288 700.432 351.047C689.961 445.288 637.605 497.644 543.364 508.116C637.605 518.587 689.961 570.943 700.432 665.184C710.903 570.943 763.259 518.587 857.5 508.116Z"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="20"
+				/>
+				<path
+					d="M700.432 615.957C691.848 589.05 678.575 566.357 660.383 548.165C642.191 529.973 619.499 516.7 592.593 508.116C619.499 499.533 642.191 486.258 660.383 468.066C678.575 449.874 691.848 427.181 700.432 400.274C709.015 427.181 722.289 449.874 740.481 468.066C758.673 486.258 781.365 499.533 808.271 508.116C781.365 516.7 758.673 529.973 740.481 548.165C722.289 566.357 709.015 589.05 700.432 615.957Z"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="20"
+				/>
+				<path
+					d="M889.949 121.237C831.049 114.692 798.326 81.9698 791.782 23.0692C785.237 81.9698 752.515 114.692 693.614 121.237C752.515 127.781 785.237 160.504 791.782 219.404C798.326 160.504 831.049 127.781 889.949 121.237Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M791.782 196.795C786.697 176.937 777.869 160.567 765.16 147.858C752.452 135.15 736.082 126.322 716.226 121.237C736.082 116.152 752.452 107.324 765.16 94.6152C777.869 81.9065 786.697 65.5368 791.782 45.6797C796.867 65.5367 805.695 81.9066 818.403 94.6152C831.112 107.324 847.481 116.152 867.338 121.237C847.481 126.322 831.112 135.15 818.403 147.858C805.694 160.567 796.867 176.937 791.782 196.795Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M760.632 764.337C720.719 814.616 669.835 855.1 611.872 882.692C553.91 910.285 490.404 924.255 426.213 923.533C362.022 922.812 298.846 907.419 241.518 878.531C184.19 849.643 134.228 808.026 95.4548 756.863C56.6815 705.7 30.1238 646.346 17.8129 583.343C5.50207 520.339 7.76433 455.354 24.4266 393.359C41.089 331.364 71.7099 274.001 113.947 225.658C156.184 177.315 208.919 139.273 268.117 114.442"
+					stroke="currentColor"
+					strokeLinecap="round"
+					strokeLinejoin="round"
+					strokeWidth="30"
+				/>
+			</svg>
+		),
+		title: "Open in Scira",
+	},
+	t3: {
+		createUrl: (q: string) =>
+			`https://t3.chat/new?${new URLSearchParams({
+				q,
+			})}`,
+		icon: <MessageCircleIcon />,
+		title: "Open in T3 Chat",
+	},
+	v0: {
+		createUrl: (q: string) =>
+			`https://v0.app?${new URLSearchParams({
+				q,
+			})}`,
+		icon: (
+			<svg
+				fill="currentColor"
+				viewBox="0 0 147 70"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>v0</title>
+				<path d="M56 50.2031V14H70V60.1562C70 65.5928 65.5928 70 60.1562 70C57.5605 70 54.9982 68.9992 53.1562 67.1573L0 14H19.7969L56 50.2031Z" />
+				<path d="M147 56H133V23.9531L100.953 56H133V70H96.6875C85.8144 70 77 61.1856 77 50.3125V14H91V46.1562L123.156 14H91V0H127.312C138.186 0 147 8.81439 147 19.6875V56Z" />
+			</svg>
+		),
+		title: "Open in v0",
+	},
+};
+
+const OpenInContext = createContext<{ query: string } | undefined>(undefined);
+
+const useOpenInContext = () => {
+	const context = useContext(OpenInContext);
+	if (!context) {
+		throw new Error("OpenIn components must be used within an OpenIn provider");
+	}
+	return context;
+};
+
+export type OpenInProps = ComponentProps<typeof DropdownMenu> & {
+	query: string;
+};
+
+export const OpenIn = ({ query, ...props }: OpenInProps) => {
+	const contextValue = useMemo(() => ({ query }), [query]);
+
+	return (
+		<OpenInContext.Provider value={contextValue}>
+			<DropdownMenu {...props} />
+		</OpenInContext.Provider>
+	);
+};
+
+export type OpenInContentProps = ComponentProps<typeof DropdownMenuContent>;
+
+export const OpenInContent = ({ className, ...props }: OpenInContentProps) => (
+	<DropdownMenuContent
+		align="start"
+		className={cn("w-[240px]", className)}
+		{...props}
+	/>
+);
+
+export type OpenInItemProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInItem = (props: OpenInItemProps) => (
+	<DropdownMenuItem {...props} />
+);
+
+export type OpenInLabelProps = ComponentProps<typeof DropdownMenuLabel>;
+
+export const OpenInLabel = (props: OpenInLabelProps) => (
+	<DropdownMenuLabel {...props} />
+);
+
+export type OpenInSeparatorProps = ComponentProps<typeof DropdownMenuSeparator>;
+
+export const OpenInSeparator = (props: OpenInSeparatorProps) => (
+	<DropdownMenuSeparator {...props} />
+);
+
+export type OpenInTriggerProps = ComponentProps<typeof DropdownMenuTrigger>;
+
+export const OpenInTrigger = ({ children, ...props }: OpenInTriggerProps) => (
+	<DropdownMenuTrigger {...props}>
+		{children ?? (
+			<Button type="button" variant="outline">
+				Open in chat
+				<ChevronDownIcon className="size-4" />
+			</Button>
+		)}
+	</DropdownMenuTrigger>
+);
+
+export type OpenInChatGPTProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInChatGPT = (props: OpenInChatGPTProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.chatgpt.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.chatgpt.icon}</span>
+			<span className="flex-1">{providers.chatgpt.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInClaudeProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInClaude = (props: OpenInClaudeProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.claude.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.claude.icon}</span>
+			<span className="flex-1">{providers.claude.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInT3Props = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInT3 = (props: OpenInT3Props) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.t3.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.t3.icon}</span>
+			<span className="flex-1">{providers.t3.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInSciraProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInScira = (props: OpenInSciraProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.scira.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.scira.icon}</span>
+			<span className="flex-1">{providers.scira.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInv0Props = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInv0 = (props: OpenInv0Props) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.v0.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.v0.icon}</span>
+			<span className="flex-1">{providers.v0.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInCursorProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInCursor = (props: OpenInCursorProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.cursor.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.cursor.icon}</span>
+			<span className="flex-1">{providers.cursor.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/package-info.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/package-info.tsx
new file mode 100644
index 0000000..805f340
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/package-info.tsx
@@ -0,0 +1,239 @@
+"use client";
+
+import { ArrowRightIcon, MinusIcon, PackageIcon, PlusIcon } from "lucide-react";
+import type { HTMLAttributes } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+type ChangeType = "major" | "minor" | "patch" | "added" | "removed";
+
+interface PackageInfoContextType {
+	name: string;
+	currentVersion?: string;
+	newVersion?: string;
+	changeType?: ChangeType;
+}
+
+const PackageInfoContext = createContext<PackageInfoContextType>({
+	name: "",
+});
+
+export type PackageInfoHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoHeader = ({
+	className,
+	children,
+	...props
+}: PackageInfoHeaderProps) => (
+	<div
+		className={cn("flex items-center justify-between gap-2", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type PackageInfoNameProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoName = ({
+	className,
+	children,
+	...props
+}: PackageInfoNameProps) => {
+	const { name } = useContext(PackageInfoContext);
+
+	return (
+		<div className={cn("flex items-center gap-2", className)} {...props}>
+			<PackageIcon className="size-4 text-muted-foreground" />
+			<span className="font-medium font-mono text-sm">{children ?? name}</span>
+		</div>
+	);
+};
+
+const changeTypeStyles: Record<ChangeType, string> = {
+	added: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+	major: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
+	minor:
+		"bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
+	patch: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+	removed: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400",
+};
+
+const changeTypeIcons: Record<ChangeType, React.ReactNode> = {
+	added: <PlusIcon className="size-3" />,
+	major: <ArrowRightIcon className="size-3" />,
+	minor: <ArrowRightIcon className="size-3" />,
+	patch: <ArrowRightIcon className="size-3" />,
+	removed: <MinusIcon className="size-3" />,
+};
+
+export type PackageInfoChangeTypeProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoChangeType = ({
+	className,
+	children,
+	...props
+}: PackageInfoChangeTypeProps) => {
+	const { changeType } = useContext(PackageInfoContext);
+
+	if (!changeType) {
+		return null;
+	}
+
+	return (
+		<Badge
+			className={cn(
+				"gap-1 text-xs capitalize",
+				changeTypeStyles[changeType],
+				className,
+			)}
+			variant="secondary"
+			{...props}
+		>
+			{changeTypeIcons[changeType]}
+			{children ?? changeType}
+		</Badge>
+	);
+};
+
+export type PackageInfoVersionProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoVersion = ({
+	className,
+	children,
+	...props
+}: PackageInfoVersionProps) => {
+	const { currentVersion, newVersion } = useContext(PackageInfoContext);
+
+	if (!(currentVersion || newVersion)) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn(
+				"mt-2 flex items-center gap-2 font-mono text-muted-foreground text-sm",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					{currentVersion && <span>{currentVersion}</span>}
+					{currentVersion && newVersion && (
+						<ArrowRightIcon className="size-3" />
+					)}
+					{newVersion && (
+						<span className="font-medium text-foreground">{newVersion}</span>
+					)}
+				</>
+			)}
+		</div>
+	);
+};
+
+export type PackageInfoProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	currentVersion?: string;
+	newVersion?: string;
+	changeType?: ChangeType;
+};
+
+export const PackageInfo = ({
+	name,
+	currentVersion,
+	newVersion,
+	changeType,
+	className,
+	children,
+	...props
+}: PackageInfoProps) => {
+	const contextValue = useMemo(
+		() => ({ changeType, currentVersion, name, newVersion }),
+		[changeType, currentVersion, name, newVersion],
+	);
+
+	return (
+		<PackageInfoContext.Provider value={contextValue}>
+			<div
+				className={cn("rounded-lg border bg-background p-4", className)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<PackageInfoHeader>
+							<PackageInfoName />
+							{changeType && <PackageInfoChangeType />}
+						</PackageInfoHeader>
+						{(currentVersion || newVersion) && <PackageInfoVersion />}
+					</>
+				)}
+			</div>
+		</PackageInfoContext.Provider>
+	);
+};
+
+export type PackageInfoDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const PackageInfoDescription = ({
+	className,
+	children,
+	...props
+}: PackageInfoDescriptionProps) => (
+	<p className={cn("mt-2 text-muted-foreground text-sm", className)} {...props}>
+		{children}
+	</p>
+);
+
+export type PackageInfoContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoContent = ({
+	className,
+	children,
+	...props
+}: PackageInfoContentProps) => (
+	<div className={cn("mt-3 border-t pt-3", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type PackageInfoDependenciesProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoDependencies = ({
+	className,
+	children,
+	...props
+}: PackageInfoDependenciesProps) => (
+	<div className={cn("space-y-2", className)} {...props}>
+		<span className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
+			Dependencies
+		</span>
+		<div className="space-y-1">{children}</div>
+	</div>
+);
+
+export type PackageInfoDependencyProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	version?: string;
+};
+
+export const PackageInfoDependency = ({
+	name,
+	version,
+	className,
+	children,
+	...props
+}: PackageInfoDependencyProps) => (
+	<div
+		className={cn("flex items-center justify-between text-sm", className)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				<span className="font-mono text-muted-foreground">{name}</span>
+				{version && <span className="font-mono text-xs">{version}</span>}
+			</>
+		)}
+	</div>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/panel.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/panel.tsx
new file mode 100644
index 0000000..18e941c
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/panel.tsx
@@ -0,0 +1,15 @@
+import { Panel as PanelPrimitive } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+type PanelProps = ComponentProps<typeof PanelPrimitive>;
+
+export const Panel = ({ className, ...props }: PanelProps) => (
+	<PanelPrimitive
+		className={cn(
+			"m-4 overflow-hidden rounded-md border bg-card p-1",
+			className,
+		)}
+		{...props}
+	/>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/persona.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/persona.tsx
new file mode 100644
index 0000000..d77ef6b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/persona.tsx
@@ -0,0 +1,306 @@
+"use client";
+
+import type { RiveParameters } from "@rive-app/react-webgl2";
+import {
+	useRive,
+	useStateMachineInput,
+	useViewModel,
+	useViewModelInstance,
+	useViewModelInstanceColor,
+} from "@rive-app/react-webgl2";
+import type { FC, ReactNode } from "react";
+import { memo, useEffect, useMemo, useRef, useState } from "react";
+import { cn } from "@/lib/utils";
+
+// Delays Rive initialization by one frame so that React Strict Mode's
+// immediate unmount cycle never creates a WebGL2 context. Only the
+// second (real) mount will initialise, avoiding context exhaustion.
+const useStrictModeSafeInit = () => {
+	const [ready, setReady] = useState(false);
+
+	useEffect(() => {
+		const id = requestAnimationFrame(() => setReady(true));
+		return () => {
+			cancelAnimationFrame(id);
+			setReady(false);
+		};
+	}, []);
+
+	return ready;
+};
+
+export type PersonaState =
+	| "idle"
+	| "listening"
+	| "thinking"
+	| "speaking"
+	| "asleep";
+
+interface PersonaProps {
+	state: PersonaState;
+	onLoad?: RiveParameters["onLoad"];
+	onLoadError?: RiveParameters["onLoadError"];
+	onReady?: () => void;
+	onPause?: RiveParameters["onPause"];
+	onPlay?: RiveParameters["onPlay"];
+	onStop?: RiveParameters["onStop"];
+	className?: string;
+	variant?: keyof typeof sources;
+}
+
+// The state machine name is always 'default' for Elements AI visuals
+const stateMachine = "default";
+
+const sources = {
+	command: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/command-2.0.riv",
+	},
+	glint: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/glint-2.0.riv",
+	},
+	halo: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/halo-2.0.riv",
+	},
+	mana: {
+		dynamicColor: false,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/mana-2.0.riv",
+	},
+	obsidian: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/obsidian-2.0.riv",
+	},
+	opal: {
+		dynamicColor: false,
+		hasModel: false,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/orb-1.2.riv",
+	},
+};
+
+const getCurrentTheme = (): "light" | "dark" => {
+	if (typeof window !== "undefined") {
+		if (document.documentElement.classList.contains("dark")) {
+			return "dark";
+		}
+		if (window.matchMedia?.("(prefers-color-scheme: dark)").matches) {
+			return "dark";
+		}
+	}
+	return "light";
+};
+
+const useTheme = (enabled: boolean) => {
+	const [theme, setTheme] = useState<"light" | "dark">(getCurrentTheme);
+
+	useEffect(() => {
+		// Skip if not enabled (avoids unnecessary observers for non-dynamic-color variants)
+		if (!enabled) {
+			return;
+		}
+
+		// Watch for classList changes
+		const observer = new MutationObserver(() => {
+			setTheme(getCurrentTheme());
+		});
+
+		observer.observe(document.documentElement, {
+			attributeFilter: ["class"],
+			attributes: true,
+		});
+
+		// Watch for OS-level theme changes
+		let mql: MediaQueryList | null = null;
+		const handleMediaChange = () => {
+			setTheme(getCurrentTheme());
+		};
+
+		if (window.matchMedia) {
+			mql = window.matchMedia("(prefers-color-scheme: dark)");
+			mql.addEventListener("change", handleMediaChange);
+		}
+
+		return () => {
+			observer.disconnect();
+			if (mql) {
+				mql.removeEventListener("change", handleMediaChange);
+			}
+		};
+	}, [enabled]);
+
+	return theme;
+};
+
+interface PersonaWithModelProps {
+	rive: ReturnType<typeof useRive>["rive"];
+	source: (typeof sources)[keyof typeof sources];
+	children: React.ReactNode;
+}
+
+const PersonaWithModel = memo(
+	({ rive, source, children }: PersonaWithModelProps) => {
+		const theme = useTheme(source.dynamicColor);
+		const viewModel = useViewModel(rive, { useDefault: true });
+		const viewModelInstance = useViewModelInstance(viewModel, {
+			rive,
+			useDefault: true,
+		});
+		const viewModelInstanceColor = useViewModelInstanceColor(
+			"color",
+			viewModelInstance,
+		);
+
+		useEffect(() => {
+			if (!(viewModelInstanceColor && source.dynamicColor)) {
+				return;
+			}
+
+			const [r, g, b] = theme === "dark" ? [255, 255, 255] : [0, 0, 0];
+			viewModelInstanceColor.setRgb(r, g, b);
+		}, [viewModelInstanceColor, theme, source.dynamicColor]);
+
+		return children;
+	},
+);
+
+PersonaWithModel.displayName = "PersonaWithModel";
+
+interface PersonaWithoutModelProps {
+	children: ReactNode;
+}
+
+const PersonaWithoutModel = memo(
+	({ children }: PersonaWithoutModelProps) => children,
+);
+
+PersonaWithoutModel.displayName = "PersonaWithoutModel";
+
+export const Persona: FC<PersonaProps> = memo(
+	({
+		variant = "obsidian",
+		state = "idle",
+		onLoad,
+		onLoadError,
+		onReady,
+		onPause,
+		onPlay,
+		onStop,
+		className,
+	}) => {
+		const source = sources[variant];
+
+		if (!source) {
+			throw new Error(`Invalid variant: ${variant}`);
+		}
+
+		// Stabilize callbacks to prevent useRive from reinitializing
+		const callbacksRef = useRef({
+			onLoad,
+			onLoadError,
+			onPause,
+			onPlay,
+			onReady,
+			onStop,
+		});
+
+		useEffect(() => {
+			callbacksRef.current = {
+				onLoad,
+				onLoadError,
+				onPause,
+				onPlay,
+				onReady,
+				onStop,
+			};
+		}, [onLoad, onLoadError, onPause, onPlay, onReady, onStop]);
+
+		const stableCallbacks = useMemo(
+			() => ({
+				onLoad: ((loadedRive) =>
+					callbacksRef.current.onLoad?.(
+						loadedRive,
+					)) as RiveParameters["onLoad"],
+				onLoadError: ((err) =>
+					callbacksRef.current.onLoadError?.(
+						err,
+					)) as RiveParameters["onLoadError"],
+				onPause: ((event) =>
+					callbacksRef.current.onPause?.(event)) as RiveParameters["onPause"],
+				onPlay: ((event) =>
+					callbacksRef.current.onPlay?.(event)) as RiveParameters["onPlay"],
+				onReady: () => callbacksRef.current.onReady?.(),
+				onStop: ((event) =>
+					callbacksRef.current.onStop?.(event)) as RiveParameters["onStop"],
+			}),
+			[],
+		);
+
+		// Delay initialisation by one frame to avoid creating (and leaking)
+		// a WebGL2 context during React Strict Mode's first throw-away mount.
+		const ready = useStrictModeSafeInit();
+
+		const { rive, RiveComponent } = useRive(
+			ready
+				? {
+						autoplay: true,
+						onLoad: stableCallbacks.onLoad,
+						onLoadError: stableCallbacks.onLoadError,
+						onPause: stableCallbacks.onPause,
+						onPlay: stableCallbacks.onPlay,
+						onRiveReady: stableCallbacks.onReady,
+						onStop: stableCallbacks.onStop,
+						src: source.source,
+						stateMachines: stateMachine,
+					}
+				: null,
+		);
+
+		const listeningInput = useStateMachineInput(
+			rive,
+			stateMachine,
+			"listening",
+		);
+		const thinkingInput = useStateMachineInput(rive, stateMachine, "thinking");
+		const speakingInput = useStateMachineInput(rive, stateMachine, "speaking");
+		const asleepInput = useStateMachineInput(rive, stateMachine, "asleep");
+
+		// Rive state machine inputs are mutable objects that must be set via direct
+		// property assignment — this is the intended Rive API, not a React anti-pattern.
+		useEffect(() => {
+			if (listeningInput) {
+				listeningInput.value = state === "listening";
+			}
+			if (thinkingInput) {
+				thinkingInput.value = state === "thinking";
+			}
+			if (speakingInput) {
+				speakingInput.value = state === "speaking";
+			}
+			if (asleepInput) {
+				asleepInput.value = state === "asleep";
+			}
+		}, [state, listeningInput, thinkingInput, speakingInput, asleepInput]);
+
+		const Component = source.hasModel ? PersonaWithModel : PersonaWithoutModel;
+
+		return (
+			<Component rive={rive} source={source}>
+				<RiveComponent className={cn("size-16 shrink-0", className)} />
+			</Component>
+		);
+	},
+);
+
+Persona.displayName = "Persona";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/plan.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/plan.tsx
new file mode 100644
index 0000000..276af52
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/plan.tsx
@@ -0,0 +1,156 @@
+"use client";
+
+import { ChevronsUpDownIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardAction,
+	CardContent,
+	CardDescription,
+	CardFooter,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+import { Shimmer } from "./shimmer";
+
+interface PlanContextValue {
+	isStreaming: boolean;
+}
+
+const PlanContext = createContext<PlanContextValue | null>(null);
+
+const usePlan = () => {
+	const context = useContext(PlanContext);
+	if (!context) {
+		throw new Error("Plan components must be used within Plan");
+	}
+	return context;
+};
+
+export type PlanProps = ComponentProps<typeof Collapsible> & {
+	isStreaming?: boolean;
+};
+
+export const Plan = ({
+	className,
+	isStreaming = false,
+	children,
+	...props
+}: PlanProps) => {
+	const contextValue = useMemo(() => ({ isStreaming }), [isStreaming]);
+
+	return (
+		<PlanContext.Provider value={contextValue}>
+			<Collapsible
+				data-slot="plan"
+				{...props}
+				render={<Card className={cn("shadow-none", className)} />}
+			>
+				{children}
+			</Collapsible>
+		</PlanContext.Provider>
+	);
+};
+
+export type PlanHeaderProps = ComponentProps<typeof CardHeader>;
+
+export const PlanHeader = ({ className, ...props }: PlanHeaderProps) => (
+	<CardHeader
+		className={cn("flex items-start justify-between", className)}
+		data-slot="plan-header"
+		{...props}
+	/>
+);
+
+export type PlanTitleProps = Omit<
+	ComponentProps<typeof CardTitle>,
+	"children"
+> & {
+	children: string;
+};
+
+export const PlanTitle = ({ children, ...props }: PlanTitleProps) => {
+	const { isStreaming } = usePlan();
+
+	return (
+		<CardTitle data-slot="plan-title" {...props}>
+			{isStreaming ? <Shimmer>{children}</Shimmer> : children}
+		</CardTitle>
+	);
+};
+
+export type PlanDescriptionProps = Omit<
+	ComponentProps<typeof CardDescription>,
+	"children"
+> & {
+	children: string;
+};
+
+export const PlanDescription = ({
+	className,
+	children,
+	...props
+}: PlanDescriptionProps) => {
+	const { isStreaming } = usePlan();
+
+	return (
+		<CardDescription
+			className={cn("text-balance", className)}
+			data-slot="plan-description"
+			{...props}
+		>
+			{isStreaming ? <Shimmer>{children}</Shimmer> : children}
+		</CardDescription>
+	);
+};
+
+export type PlanActionProps = ComponentProps<typeof CardAction>;
+
+export const PlanAction = (props: PlanActionProps) => (
+	<CardAction data-slot="plan-action" {...props} />
+);
+
+export type PlanContentProps = ComponentProps<typeof CardContent>;
+
+export const PlanContent = (props: PlanContentProps) => (
+	<CollapsibleContent
+		render={<CardContent data-slot="plan-content" {...props} />}
+	></CollapsibleContent>
+);
+
+export type PlanFooterProps = ComponentProps<"div">;
+
+export const PlanFooter = (props: PlanFooterProps) => (
+	<CardFooter data-slot="plan-footer" {...props} />
+);
+
+export type PlanTriggerProps = Omit<
+	ComponentProps<typeof CollapsibleTrigger>,
+	"render"
+>;
+
+export const PlanTrigger = ({ className, ...props }: PlanTriggerProps) => (
+	<CollapsibleTrigger
+		{...props}
+		render={
+			<Button
+				className={cn("size-8", className)}
+				data-slot="plan-trigger"
+				size="icon"
+				variant="ghost"
+			/>
+		}
+	>
+		<ChevronsUpDownIcon className="size-4" />
+		<span className="sr-only">Toggle plan</span>
+	</CollapsibleTrigger>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/prompt-input.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/prompt-input.tsx
new file mode 100644
index 0000000..d67e24d
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/prompt-input.tsx
@@ -0,0 +1,1502 @@
+"use client";
+
+import type { ChatStatus, FileUIPart, SourceDocumentUIPart } from "ai";
+import {
+	CornerDownLeftIcon,
+	ImageIcon,
+	Monitor,
+	PaperclipIcon,
+	SquareIcon,
+	XIcon,
+} from "lucide-react";
+import { nanoid } from "nanoid";
+import type {
+	ChangeEvent,
+	ChangeEventHandler,
+	ClipboardEventHandler,
+	ComponentProps,
+	FormEvent,
+	FormEventHandler,
+	HTMLAttributes,
+	KeyboardEventHandler,
+	PropsWithChildren,
+	ReactNode,
+	RefObject,
+} from "react";
+import {
+	Children,
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	Command,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+	CommandSeparator,
+} from "@/components/ui/command";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupTextarea,
+} from "@/components/ui/input-group";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Spinner } from "@/components/ui/spinner";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+const convertBlobUrlToDataUrl = async (url: string): Promise<string | null> => {
+	try {
+		const response = await fetch(url);
+		const blob = await response.blob();
+		// FileReader uses callback-based API, wrapping in Promise is necessary
+		// oxlint-disable-next-line eslint-plugin-promise(avoid-new)
+		return new Promise((resolve) => {
+			const reader = new FileReader();
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			reader.onloadend = () => resolve(reader.result as string);
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			reader.onerror = () => resolve(null);
+			reader.readAsDataURL(blob);
+		});
+	} catch {
+		return null;
+	}
+};
+
+const readFileAsDataUrl = async (file: File): Promise<string | null> =>
+	await new Promise((resolve) => {
+		const reader = new FileReader();
+		reader.onloadend = () => resolve((reader.result as string) ?? null);
+		reader.onerror = () => resolve(null);
+		reader.readAsDataURL(file);
+	});
+
+const captureScreenshot = async (): Promise<File | null> => {
+	if (
+		typeof navigator === "undefined" ||
+		!navigator.mediaDevices?.getDisplayMedia
+	) {
+		return null;
+	}
+
+	let stream: MediaStream | null = null;
+	const video = document.createElement("video");
+	video.muted = true;
+	video.playsInline = true;
+
+	try {
+		stream = await navigator.mediaDevices.getDisplayMedia({
+			audio: false,
+			video: true,
+		});
+
+		video.srcObject = stream;
+
+		// Video element uses callback-based API, wrapping in Promise is necessary
+		// oxlint-disable-next-line eslint-plugin-promise(avoid-new)
+		await new Promise<void>((resolve, reject) => {
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			video.onloadedmetadata = () => resolve();
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			video.onerror = () => reject(new Error("Failed to load screen stream"));
+		});
+
+		await video.play();
+
+		const width = video.videoWidth;
+		const height = video.videoHeight;
+		if (!width || !height) {
+			return null;
+		}
+
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		const context = canvas.getContext("2d");
+		if (!context) {
+			return null;
+		}
+
+		context.drawImage(video, 0, 0, width, height);
+		// canvas.toBlob uses callback-based API, wrapping in Promise is necessary
+		// oxlint-disable-next-line eslint-plugin-promise(avoid-new)
+		const blob = await new Promise<Blob | null>((resolve) => {
+			canvas.toBlob(resolve, "image/png");
+		});
+		if (!blob) {
+			return null;
+		}
+
+		const timestamp = new Date()
+			.toISOString()
+			.replaceAll(/[:.]/g, "-")
+			.replace("T", "_")
+			.replace("Z", "");
+
+		return new File([blob], `screenshot-${timestamp}.png`, {
+			lastModified: Date.now(),
+			type: "image/png",
+		});
+	} finally {
+		if (stream) {
+			for (const track of stream.getTracks()) {
+				track.stop();
+			}
+		}
+		video.pause();
+		video.srcObject = null;
+	}
+};
+
+// ============================================================================
+// Provider Context & Types
+// ============================================================================
+
+export interface AttachmentsContext {
+	files: (FileUIPart & { id: string })[];
+	add: (files: File[] | FileList) => void;
+	remove: (id: string) => void;
+	clear: () => void;
+	openFileDialog: () => void;
+	fileInputRef: RefObject<HTMLInputElement | null>;
+}
+
+export interface TextInputContext {
+	value: string;
+	setInput: (v: string) => void;
+	clear: () => void;
+}
+
+export interface PromptInputControllerProps {
+	textInput: TextInputContext;
+	attachments: AttachmentsContext;
+	/** INTERNAL: Allows PromptInput to register its file textInput + "open" callback */
+	__registerFileInput: (
+		ref: RefObject<HTMLInputElement | null>,
+		open: () => void,
+	) => void;
+}
+
+const PromptInputController = createContext<PromptInputControllerProps | null>(
+	null,
+);
+const ProviderAttachmentsContext = createContext<AttachmentsContext | null>(
+	null,
+);
+
+export const usePromptInputController = () => {
+	const ctx = useContext(PromptInputController);
+	if (!ctx) {
+		throw new Error(
+			"Wrap your component inside <PromptInputProvider> to use usePromptInputController().",
+		);
+	}
+	return ctx;
+};
+
+// Optional variants (do NOT throw). Useful for dual-mode components.
+const useOptionalPromptInputController = () =>
+	useContext(PromptInputController);
+
+export const useProviderAttachments = () => {
+	const ctx = useContext(ProviderAttachmentsContext);
+	if (!ctx) {
+		throw new Error(
+			"Wrap your component inside <PromptInputProvider> to use useProviderAttachments().",
+		);
+	}
+	return ctx;
+};
+
+const useOptionalProviderAttachments = () =>
+	useContext(ProviderAttachmentsContext);
+
+export type PromptInputProviderProps = PropsWithChildren<{
+	initialInput?: string;
+}>;
+
+/**
+ * Optional global provider that lifts PromptInput state outside of PromptInput.
+ * If you don't use it, PromptInput stays fully self-managed.
+ */
+export const PromptInputProvider = ({
+	initialInput: initialTextInput = "",
+	children,
+}: PromptInputProviderProps) => {
+	// ----- textInput state
+	const [textInput, setTextInput] = useState(initialTextInput);
+	const clearInput = useCallback(() => setTextInput(""), []);
+
+	// ----- attachments state (global when wrapped)
+	const [attachmentFiles, setAttachmentFiles] = useState<
+		PromptInputAttachmentPart[]
+	>([]);
+	const fileInputRef = useRef<HTMLInputElement | null>(null);
+	// oxlint-disable-next-line eslint(no-empty-function)
+	const openRef = useRef<() => void>(() => {});
+
+	const add = useCallback((files: File[] | FileList) => {
+		const incoming = [...files];
+		if (incoming.length === 0) {
+			return;
+		}
+
+		setAttachmentFiles((prev) => [
+			...prev,
+			...incoming.map((file) => ({
+				filename: file.name,
+				id: nanoid(),
+				mediaType: file.type,
+				rawFile: file,
+				type: "file" as const,
+				url: URL.createObjectURL(file),
+			})),
+		]);
+	}, []);
+
+	const remove = useCallback((id: string) => {
+		setAttachmentFiles((prev) => {
+			const found = prev.find((f) => f.id === id);
+			if (found?.url) {
+				URL.revokeObjectURL(found.url);
+			}
+			return prev.filter((f) => f.id !== id);
+		});
+	}, []);
+
+	const clear = useCallback(() => {
+		setAttachmentFiles((prev) => {
+			for (const f of prev) {
+				if (f.url) {
+					URL.revokeObjectURL(f.url);
+				}
+			}
+			return [];
+		});
+	}, []);
+
+	// Keep a ref to attachments for cleanup on unmount (avoids stale closure)
+	const attachmentsRef = useRef(attachmentFiles);
+
+	useEffect(() => {
+		attachmentsRef.current = attachmentFiles;
+	}, [attachmentFiles]);
+
+	// Cleanup blob URLs on unmount to prevent memory leaks
+	useEffect(
+		() => () => {
+			for (const f of attachmentsRef.current) {
+				if (f.url) {
+					URL.revokeObjectURL(f.url);
+				}
+			}
+		},
+		[],
+	);
+
+	const openFileDialog = useCallback(() => {
+		openRef.current?.();
+	}, []);
+
+	const attachments = useMemo<AttachmentsContext>(
+		() => ({
+			add,
+			clear,
+			fileInputRef,
+			files: attachmentFiles,
+			openFileDialog,
+			remove,
+		}),
+		[attachmentFiles, add, remove, clear, openFileDialog],
+	);
+
+	const __registerFileInput = useCallback(
+		(ref: RefObject<HTMLInputElement | null>, open: () => void) => {
+			fileInputRef.current = ref.current;
+			openRef.current = open;
+		},
+		[],
+	);
+
+	const controller = useMemo<PromptInputControllerProps>(
+		() => ({
+			__registerFileInput,
+			attachments,
+			textInput: {
+				clear: clearInput,
+				setInput: setTextInput,
+				value: textInput,
+			},
+		}),
+		[textInput, clearInput, attachments, __registerFileInput],
+	);
+
+	return (
+		<PromptInputController.Provider value={controller}>
+			<ProviderAttachmentsContext.Provider value={attachments}>
+				{children}
+			</ProviderAttachmentsContext.Provider>
+		</PromptInputController.Provider>
+	);
+};
+
+// ============================================================================
+// Component Context & Hooks
+// ============================================================================
+
+const LocalAttachmentsContext = createContext<AttachmentsContext | null>(null);
+
+export const usePromptInputAttachments = () => {
+	// Prefer local context (inside PromptInput) as it has validation, fall back to provider
+	const provider = useOptionalProviderAttachments();
+	const local = useContext(LocalAttachmentsContext);
+	const context = local ?? provider;
+	if (!context) {
+		throw new Error(
+			"usePromptInputAttachments must be used within a PromptInput or PromptInputProvider",
+		);
+	}
+	return context;
+};
+
+// ============================================================================
+// Referenced Sources (Local to PromptInput)
+// ============================================================================
+
+export interface ReferencedSourcesContext {
+	sources: (SourceDocumentUIPart & { id: string })[];
+	add: (sources: SourceDocumentUIPart[] | SourceDocumentUIPart) => void;
+	remove: (id: string) => void;
+	clear: () => void;
+}
+
+export const LocalReferencedSourcesContext =
+	createContext<ReferencedSourcesContext | null>(null);
+
+export const usePromptInputReferencedSources = () => {
+	const ctx = useContext(LocalReferencedSourcesContext);
+	if (!ctx) {
+		throw new Error(
+			"usePromptInputReferencedSources must be used within a LocalReferencedSourcesContext.Provider",
+		);
+	}
+	return ctx;
+};
+
+export type PromptInputActionAddAttachmentsProps = ComponentProps<
+	typeof DropdownMenuItem
+> & {
+	label?: string;
+};
+
+export const PromptInputActionAddAttachments = ({
+	label = "Add photos or files",
+	...props
+}: PromptInputActionAddAttachmentsProps) => {
+	const attachments = usePromptInputAttachments();
+
+	const handleSelect = useCallback(
+		(
+			e: Parameters<
+				NonNullable<PromptInputActionAddAttachmentsProps["onSelect"]>
+			>[0],
+		) => {
+			e.preventDefault();
+			attachments.openFileDialog();
+		},
+		[attachments],
+	);
+
+	return (
+		<DropdownMenuItem {...props} onSelect={handleSelect}>
+			<ImageIcon className="mr-2 size-4" /> {label}
+		</DropdownMenuItem>
+	);
+};
+
+export type PromptInputActionAddScreenshotProps = ComponentProps<
+	typeof DropdownMenuItem
+> & {
+	label?: string;
+};
+
+export const PromptInputActionAddScreenshot = ({
+	label = "Take screenshot",
+	onSelect,
+	...props
+}: PromptInputActionAddScreenshotProps) => {
+	const attachments = usePromptInputAttachments();
+
+	const handleSelect = useCallback(
+		async (
+			event: Parameters<
+				NonNullable<PromptInputActionAddScreenshotProps["onSelect"]>
+			>[0],
+		) => {
+			onSelect?.(event);
+			if (event.defaultPrevented) {
+				return;
+			}
+
+			try {
+				const screenshot = await captureScreenshot();
+				if (screenshot) {
+					attachments.add([screenshot]);
+				}
+			} catch (error) {
+				if (
+					error instanceof DOMException &&
+					(error.name === "NotAllowedError" || error.name === "AbortError")
+				) {
+					return;
+				}
+				throw error;
+			}
+		},
+		[onSelect, attachments],
+	);
+
+	return (
+		<DropdownMenuItem {...props} onSelect={handleSelect}>
+			<Monitor className="mr-2 size-4" />
+			{label}
+		</DropdownMenuItem>
+	);
+};
+
+export interface PromptInputMessage {
+	text: string;
+	files: FileUIPart[];
+}
+
+type PromptInputAttachmentPart = FileUIPart & {
+	id: string;
+	rawFile?: File;
+};
+
+export type PromptInputProps = Omit<
+	HTMLAttributes<HTMLFormElement>,
+	"onSubmit" | "onError"
+> & {
+	// e.g., "image/*" or leave undefined for any
+	accept?: string;
+	multiple?: boolean;
+	// When true, accepts drops anywhere on document. Default false (opt-in).
+	globalDrop?: boolean;
+	// Render a hidden input with given name and keep it in sync for native form posts. Default false.
+	syncHiddenInput?: boolean;
+	// Minimal constraints
+	maxFiles?: number;
+	// bytes
+	maxFileSize?: number;
+	onError?: (err: {
+		code: "max_files" | "max_file_size" | "accept";
+		message: string;
+	}) => void;
+	onSubmit: (
+		message: PromptInputMessage,
+		event: FormEvent<HTMLFormElement>,
+	) => void | Promise<void>;
+};
+
+export const PromptInput = ({
+	className,
+	accept,
+	multiple,
+	globalDrop,
+	syncHiddenInput,
+	maxFiles,
+	maxFileSize,
+	onError,
+	onSubmit,
+	children,
+	...props
+}: PromptInputProps) => {
+	// Try to use a provider controller if present
+	const controller = useOptionalPromptInputController();
+	const usingProvider = !!controller;
+
+	// Refs
+	const inputRef = useRef<HTMLInputElement | null>(null);
+	const formRef = useRef<HTMLFormElement | null>(null);
+
+	// ----- Local attachments (only used when no provider)
+	const [items, setItems] = useState<PromptInputAttachmentPart[]>([]);
+	const files = usingProvider ? controller.attachments.files : items;
+
+	// ----- Local referenced sources (always local to PromptInput)
+	const [referencedSources, setReferencedSources] = useState<
+		(SourceDocumentUIPart & { id: string })[]
+	>([]);
+
+	// Keep a ref to files for cleanup on unmount (avoids stale closure)
+	const filesRef = useRef(files);
+
+	useEffect(() => {
+		filesRef.current = files;
+	}, [files]);
+
+	const openFileDialogLocal = useCallback(() => {
+		inputRef.current?.click();
+	}, []);
+
+	const matchesAccept = useCallback(
+		(f: File) => {
+			if (!accept || accept.trim() === "") {
+				return true;
+			}
+
+			const patterns = accept
+				.split(",")
+				.map((s) => s.trim())
+				.filter(Boolean);
+
+			return patterns.some((pattern) => {
+				if (pattern.endsWith("/*")) {
+					// e.g: image/* -> image/
+					const prefix = pattern.slice(0, -1);
+					return f.type.startsWith(prefix);
+				}
+				return f.type === pattern;
+			});
+		},
+		[accept],
+	);
+
+	const addLocal = useCallback(
+		(fileList: File[] | FileList) => {
+			const incoming = [...fileList];
+			const accepted = incoming.filter((f) => matchesAccept(f));
+			if (incoming.length && accepted.length === 0) {
+				onError?.({
+					code: "accept",
+					message: "No files match the accepted types.",
+				});
+				return;
+			}
+			const withinSize = (f: File) =>
+				maxFileSize ? f.size <= maxFileSize : true;
+			const sized = accepted.filter(withinSize);
+			if (accepted.length > 0 && sized.length === 0) {
+				onError?.({
+					code: "max_file_size",
+					message: "All files exceed the maximum size.",
+				});
+				return;
+			}
+
+			setItems((prev) => {
+				const capacity =
+					typeof maxFiles === "number"
+						? Math.max(0, maxFiles - prev.length)
+						: undefined;
+				const capped =
+					typeof capacity === "number" ? sized.slice(0, capacity) : sized;
+				if (typeof capacity === "number" && sized.length > capacity) {
+					onError?.({
+						code: "max_files",
+						message: "Too many files. Some were not added.",
+					});
+				}
+				const next: PromptInputAttachmentPart[] = [];
+				for (const file of capped) {
+					next.push({
+						filename: file.name,
+						id: nanoid(),
+						mediaType: file.type,
+						rawFile: file,
+						type: "file",
+						url: URL.createObjectURL(file),
+					});
+				}
+				return [...prev, ...next];
+			});
+		},
+		[matchesAccept, maxFiles, maxFileSize, onError],
+	);
+
+	const removeLocal = useCallback(
+		(id: string) =>
+			setItems((prev) => {
+				const found = prev.find((file) => file.id === id);
+				if (found?.url) {
+					URL.revokeObjectURL(found.url);
+				}
+				return prev.filter((file) => file.id !== id);
+			}),
+		[],
+	);
+
+	// Wrapper that validates files before calling provider's add
+	const addWithProviderValidation = useCallback(
+		(fileList: File[] | FileList) => {
+			const incoming = [...fileList];
+			const accepted = incoming.filter((f) => matchesAccept(f));
+			if (incoming.length && accepted.length === 0) {
+				onError?.({
+					code: "accept",
+					message: "No files match the accepted types.",
+				});
+				return;
+			}
+			const withinSize = (f: File) =>
+				maxFileSize ? f.size <= maxFileSize : true;
+			const sized = accepted.filter(withinSize);
+			if (accepted.length > 0 && sized.length === 0) {
+				onError?.({
+					code: "max_file_size",
+					message: "All files exceed the maximum size.",
+				});
+				return;
+			}
+
+			const currentCount = files.length;
+			const capacity =
+				typeof maxFiles === "number"
+					? Math.max(0, maxFiles - currentCount)
+					: undefined;
+			const capped =
+				typeof capacity === "number" ? sized.slice(0, capacity) : sized;
+			if (typeof capacity === "number" && sized.length > capacity) {
+				onError?.({
+					code: "max_files",
+					message: "Too many files. Some were not added.",
+				});
+			}
+
+			if (capped.length > 0) {
+				controller?.attachments.add(capped);
+			}
+		},
+		[matchesAccept, maxFileSize, maxFiles, onError, files.length, controller],
+	);
+
+	const clearAttachments = useCallback(
+		() =>
+			usingProvider
+				? controller?.attachments.clear()
+				: setItems((prev) => {
+						for (const file of prev) {
+							if (file.url) {
+								URL.revokeObjectURL(file.url);
+							}
+						}
+						return [];
+					}),
+		[usingProvider, controller],
+	);
+
+	const clearReferencedSources = useCallback(
+		() => setReferencedSources([]),
+		[],
+	);
+
+	const add = usingProvider ? addWithProviderValidation : addLocal;
+	const remove = usingProvider ? controller.attachments.remove : removeLocal;
+	const openFileDialog = usingProvider
+		? controller.attachments.openFileDialog
+		: openFileDialogLocal;
+
+	const clear = useCallback(() => {
+		clearAttachments();
+		clearReferencedSources();
+	}, [clearAttachments, clearReferencedSources]);
+
+	// Let provider know about our hidden file input so external menus can call openFileDialog()
+	useEffect(() => {
+		if (!usingProvider) {
+			return;
+		}
+		controller.__registerFileInput(inputRef, () => inputRef.current?.click());
+	}, [usingProvider, controller]);
+
+	// Note: File input cannot be programmatically set for security reasons
+	// The syncHiddenInput prop is no longer functional
+	useEffect(() => {
+		if (syncHiddenInput && inputRef.current && files.length === 0) {
+			inputRef.current.value = "";
+		}
+	}, [files, syncHiddenInput]);
+
+	// Attach drop handlers on nearest form and document (opt-in)
+	useEffect(() => {
+		const form = formRef.current;
+		if (!form) {
+			return;
+		}
+		if (globalDrop) {
+			// when global drop is on, let the document-level handler own drops
+			return;
+		}
+
+		const onDragOver = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+		};
+		const onDrop = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+			if (e.dataTransfer?.files && e.dataTransfer.files.length > 0) {
+				add(e.dataTransfer.files);
+			}
+		};
+		form.addEventListener("dragover", onDragOver);
+		form.addEventListener("drop", onDrop);
+		return () => {
+			form.removeEventListener("dragover", onDragOver);
+			form.removeEventListener("drop", onDrop);
+		};
+	}, [add, globalDrop]);
+
+	useEffect(() => {
+		if (!globalDrop) {
+			return;
+		}
+
+		const onDragOver = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+		};
+		const onDrop = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+			if (e.dataTransfer?.files && e.dataTransfer.files.length > 0) {
+				add(e.dataTransfer.files);
+			}
+		};
+		document.addEventListener("dragover", onDragOver);
+		document.addEventListener("drop", onDrop);
+		return () => {
+			document.removeEventListener("dragover", onDragOver);
+			document.removeEventListener("drop", onDrop);
+		};
+	}, [add, globalDrop]);
+
+	useEffect(
+		() => () => {
+			if (!usingProvider) {
+				for (const f of filesRef.current) {
+					if (f.url) {
+						URL.revokeObjectURL(f.url);
+					}
+				}
+			}
+		},
+		[usingProvider],
+	);
+
+	const handleChange: ChangeEventHandler<HTMLInputElement> = useCallback(
+		(event) => {
+			if (event.currentTarget.files) {
+				add(event.currentTarget.files);
+			}
+			// Reset input value to allow selecting files that were previously removed
+			event.currentTarget.value = "";
+		},
+		[add],
+	);
+
+	const attachmentsCtx = useMemo<AttachmentsContext>(
+		() => ({
+			add,
+			clear: clearAttachments,
+			fileInputRef: inputRef,
+			files: files.map((item) => ({ ...item, id: item.id })),
+			openFileDialog,
+			remove,
+		}),
+		[files, add, remove, clearAttachments, openFileDialog],
+	);
+
+	const refsCtx = useMemo<ReferencedSourcesContext>(
+		() => ({
+			add: (incoming: SourceDocumentUIPart[] | SourceDocumentUIPart) => {
+				const array = Array.isArray(incoming) ? incoming : [incoming];
+				setReferencedSources((prev) => [
+					...prev,
+					...array.map((s) => ({ ...s, id: nanoid() })),
+				]);
+			},
+			clear: clearReferencedSources,
+			remove: (id: string) => {
+				setReferencedSources((prev) => prev.filter((s) => s.id !== id));
+			},
+			sources: referencedSources,
+		}),
+		[referencedSources, clearReferencedSources],
+	);
+
+	const handleSubmit: FormEventHandler<HTMLFormElement> = useCallback(
+		async (event) => {
+			event.preventDefault();
+
+			const form = event.currentTarget;
+			const text = usingProvider
+				? controller.textInput.value
+				: (() => {
+						const formData = new FormData(form);
+						return (formData.get("message") as string) || "";
+					})();
+
+			// Reset form immediately after capturing text to avoid race condition
+			// where user input during async blob conversion would be lost
+			if (!usingProvider) {
+				form.reset();
+			}
+
+			try {
+				// Convert blob URLs to data URLs asynchronously
+				const convertedFiles: FileUIPart[] = await Promise.all(
+					(files as PromptInputAttachmentPart[]).map(
+						async ({ id: _id, rawFile, ...item }) => {
+							if (rawFile) {
+								const dataUrl = await readFileAsDataUrl(rawFile);
+								return {
+									...item,
+									url: dataUrl ?? item.url,
+								};
+							}
+							if (item.url?.startsWith("blob:")) {
+								const dataUrl = await convertBlobUrlToDataUrl(item.url);
+								// If conversion failed, keep the original blob URL
+								return {
+									...item,
+									url: dataUrl ?? item.url,
+								};
+							}
+							return item;
+						},
+					),
+				);
+
+				const result = onSubmit({ files: convertedFiles, text }, event);
+
+				// Handle both sync and async onSubmit
+				if (result instanceof Promise) {
+					try {
+						await result;
+						clear();
+						if (usingProvider) {
+							controller.textInput.clear();
+						}
+					} catch {
+						// Don't clear on error - user may want to retry
+					}
+				} else {
+					// Sync function completed without throwing, clear inputs
+					clear();
+					if (usingProvider) {
+						controller.textInput.clear();
+					}
+				}
+			} catch {
+				// Don't clear on error - user may want to retry
+			}
+		},
+		[usingProvider, controller, files, onSubmit, clear],
+	);
+
+	// Render with or without local provider
+	const inner = (
+		<>
+			<input
+				accept={accept}
+				aria-label="Upload files"
+				className="hidden"
+				multiple={multiple}
+				onChange={handleChange}
+				ref={inputRef}
+				title="Upload files"
+				type="file"
+			/>
+			<form
+				className={cn("w-full", className)}
+				onSubmit={handleSubmit}
+				ref={formRef}
+				{...props}
+			>
+				<InputGroup className="overflow-hidden">{children}</InputGroup>
+			</form>
+		</>
+	);
+
+	const withReferencedSources = (
+		<LocalReferencedSourcesContext.Provider value={refsCtx}>
+			{inner}
+		</LocalReferencedSourcesContext.Provider>
+	);
+
+	// Always provide LocalAttachmentsContext so children get validated add function
+	return (
+		<LocalAttachmentsContext.Provider value={attachmentsCtx}>
+			{withReferencedSources}
+		</LocalAttachmentsContext.Provider>
+	);
+};
+
+export type PromptInputBodyProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputBody = ({
+	className,
+	...props
+}: PromptInputBodyProps) => (
+	<div className={cn("contents", className)} {...props} />
+);
+
+export type PromptInputTextareaProps = ComponentProps<
+	typeof InputGroupTextarea
+>;
+
+export const PromptInputTextarea = ({
+	onChange,
+	onKeyDown,
+	className,
+	placeholder = "How can I help you?",
+	...props
+}: PromptInputTextareaProps) => {
+	const controller = useOptionalPromptInputController();
+	const attachments = usePromptInputAttachments();
+	const [isComposing, setIsComposing] = useState(false);
+
+	const handleKeyDown: KeyboardEventHandler<HTMLTextAreaElement> = useCallback(
+		(e) => {
+			// Call the external onKeyDown handler first
+			onKeyDown?.(e);
+
+			// If the external handler prevented default, don't run internal logic
+			if (e.defaultPrevented) {
+				return;
+			}
+
+			if (e.key === "Enter") {
+				if (isComposing || e.nativeEvent.isComposing) {
+					return;
+				}
+				if (e.shiftKey) {
+					return;
+				}
+				e.preventDefault();
+
+				// Check if the submit button is disabled before submitting
+				const { form } = e.currentTarget;
+				const submitButton = form?.querySelector(
+					'button[type="submit"]',
+				) as HTMLButtonElement | null;
+				if (submitButton?.disabled) {
+					return;
+				}
+
+				form?.requestSubmit();
+			}
+
+			// Remove last attachment when Backspace is pressed and textarea is empty
+			if (
+				e.key === "Backspace" &&
+				e.currentTarget.value === "" &&
+				attachments.files.length > 0
+			) {
+				e.preventDefault();
+				const lastAttachment = attachments.files.at(-1);
+				if (lastAttachment) {
+					attachments.remove(lastAttachment.id);
+				}
+			}
+		},
+		[onKeyDown, isComposing, attachments],
+	);
+
+	const handlePaste: ClipboardEventHandler<HTMLTextAreaElement> = useCallback(
+		(event) => {
+			const items = event.clipboardData?.items;
+
+			if (!items) {
+				return;
+			}
+
+			const files: File[] = [];
+
+			for (const item of items) {
+				if (item.kind === "file") {
+					const file = item.getAsFile();
+					if (file) {
+						files.push(file);
+					}
+				}
+			}
+
+			if (files.length > 0) {
+				event.preventDefault();
+				attachments.add(files);
+			}
+		},
+		[attachments],
+	);
+
+	const handleCompositionEnd = useCallback(() => setIsComposing(false), []);
+	const handleCompositionStart = useCallback(() => setIsComposing(true), []);
+
+	const controlledProps = controller
+		? {
+				onChange: (e: ChangeEvent<HTMLTextAreaElement>) => {
+					controller.textInput.setInput(e.currentTarget.value);
+					onChange?.(e);
+				},
+				value: controller.textInput.value,
+			}
+		: {
+				onChange,
+			};
+
+	return (
+		<InputGroupTextarea
+			className={cn("field-sizing-content max-h-48 min-h-16", className)}
+			name="message"
+			onCompositionEnd={handleCompositionEnd}
+			onCompositionStart={handleCompositionStart}
+			onKeyDown={handleKeyDown}
+			onPaste={handlePaste}
+			placeholder={placeholder}
+			{...props}
+			{...controlledProps}
+		/>
+	);
+};
+
+export type PromptInputHeaderProps = Omit<
+	ComponentProps<typeof InputGroupAddon>,
+	"align"
+>;
+
+export const PromptInputHeader = ({
+	className,
+	...props
+}: PromptInputHeaderProps) => (
+	<InputGroupAddon
+		align="block-end"
+		className={cn("order-first flex-wrap gap-1", className)}
+		{...props}
+	/>
+);
+
+export type PromptInputFooterProps = Omit<
+	ComponentProps<typeof InputGroupAddon>,
+	"align"
+>;
+
+export const PromptInputFooter = ({
+	className,
+	...props
+}: PromptInputFooterProps) => (
+	<InputGroupAddon
+		align="block-end"
+		className={cn("justify-between gap-1", className)}
+		{...props}
+	/>
+);
+
+export type PromptInputToolsProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTools = ({
+	className,
+	...props
+}: PromptInputToolsProps) => (
+	<div
+		className={cn("flex min-w-0 items-center gap-1", className)}
+		{...props}
+	/>
+);
+
+export type PromptInputButtonTooltip =
+	| string
+	| {
+			content: ReactNode;
+			shortcut?: string;
+			side?: ComponentProps<typeof TooltipContent>["side"];
+	  };
+
+export type PromptInputButtonProps = ComponentProps<typeof InputGroupButton> & {
+	tooltip?: PromptInputButtonTooltip;
+};
+
+export const PromptInputButton = ({
+	variant = "ghost",
+	className,
+	size,
+	tooltip,
+	...props
+}: PromptInputButtonProps) => {
+	const newSize =
+		size ?? (Children.count(props.children) > 1 ? "sm" : "icon-sm");
+
+	const button = (
+		<InputGroupButton
+			className={cn(className)}
+			size={newSize}
+			type="button"
+			variant={variant}
+			{...props}
+		/>
+	);
+
+	if (!tooltip) {
+		return button;
+	}
+
+	const tooltipContent =
+		typeof tooltip === "string" ? tooltip : tooltip.content;
+	const shortcut = typeof tooltip === "string" ? undefined : tooltip.shortcut;
+	const side = typeof tooltip === "string" ? "top" : (tooltip.side ?? "top");
+
+	return (
+		<Tooltip>
+			<TooltipTrigger>{button}</TooltipTrigger>
+			<TooltipContent side={side}>
+				{tooltipContent}
+				{shortcut && (
+					<span className="ml-2 text-muted-foreground">{shortcut}</span>
+				)}
+			</TooltipContent>
+		</Tooltip>
+	);
+};
+
+export type PromptInputActionMenuProps = ComponentProps<typeof DropdownMenu>;
+export const PromptInputActionMenu = (props: PromptInputActionMenuProps) => (
+	<DropdownMenu {...props} />
+);
+
+export type PromptInputActionMenuTriggerProps = PromptInputButtonProps;
+
+export const PromptInputActionMenuTrigger = ({
+	className,
+	children,
+	...props
+}: PromptInputActionMenuTriggerProps) => (
+	<DropdownMenuTrigger
+		render={<PromptInputButton className={className} {...props} />}
+	>
+		{children ?? <PaperclipIcon className="size-4" />}
+	</DropdownMenuTrigger>
+);
+
+export type PromptInputActionMenuContentProps = ComponentProps<
+	typeof DropdownMenuContent
+>;
+export const PromptInputActionMenuContent = ({
+	className,
+	...props
+}: PromptInputActionMenuContentProps) => (
+	<DropdownMenuContent align="start" className={cn(className)} {...props} />
+);
+
+export type PromptInputActionMenuItemProps = ComponentProps<
+	typeof DropdownMenuItem
+>;
+export const PromptInputActionMenuItem = ({
+	className,
+	...props
+}: PromptInputActionMenuItemProps) => (
+	<DropdownMenuItem className={cn(className)} {...props} />
+);
+
+// Note: Actions that perform side-effects (like opening a file dialog)
+// are provided in opt-in modules (e.g., prompt-input-attachments).
+
+export type PromptInputSubmitProps = ComponentProps<typeof InputGroupButton> & {
+	status?: ChatStatus;
+	onStop?: () => void;
+};
+
+export const PromptInputSubmit = ({
+	className,
+	variant = "default",
+	size = "icon-sm",
+	status,
+	onStop,
+	onClick,
+	children,
+	...props
+}: PromptInputSubmitProps) => {
+	const isGenerating = status === "submitted" || status === "streaming";
+
+	let Icon = <CornerDownLeftIcon className="size-3" />;
+
+	if (status === "submitted") {
+		Icon = <Spinner />;
+	} else if (status === "streaming") {
+		Icon = <SquareIcon className="size-3" />;
+	} else if (status === "error") {
+		Icon = <XIcon className="size-3" />;
+	}
+
+	const handleClick = useCallback(
+		(
+			e: Parameters<
+				NonNullable<ComponentProps<typeof InputGroupButton>["onClick"]>
+			>[0],
+		) => {
+			if (isGenerating && onStop) {
+				e.preventDefault();
+				onStop();
+				return;
+			}
+			onClick?.(e);
+		},
+		[isGenerating, onStop, onClick],
+	);
+
+	return (
+		<InputGroupButton
+			aria-label={isGenerating ? "Stop" : "Submit"}
+			className={cn(className)}
+			onClick={handleClick}
+			size={size}
+			type={isGenerating && onStop ? "button" : "submit"}
+			variant={variant}
+			{...props}
+		>
+			{children ?? Icon}
+		</InputGroupButton>
+	);
+};
+
+export type PromptInputSelectProps = ComponentProps<typeof Select>;
+
+export const PromptInputSelect = (props: PromptInputSelectProps) => (
+	<Select {...props} />
+);
+
+export type PromptInputSelectTriggerProps = ComponentProps<
+	typeof SelectTrigger
+>;
+
+export const PromptInputSelectTrigger = ({
+	className,
+	...props
+}: PromptInputSelectTriggerProps) => (
+	<SelectTrigger
+		className={cn(
+			"border-none bg-transparent font-medium text-muted-foreground shadow-none transition-colors",
+			"hover:bg-accent hover:text-foreground aria-expanded:bg-accent aria-expanded:text-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type PromptInputSelectContentProps = ComponentProps<
+	typeof SelectContent
+>;
+
+export const PromptInputSelectContent = ({
+	className,
+	...props
+}: PromptInputSelectContentProps) => (
+	<SelectContent className={cn(className)} {...props} />
+);
+
+export type PromptInputSelectItemProps = ComponentProps<typeof SelectItem>;
+
+export const PromptInputSelectItem = ({
+	className,
+	...props
+}: PromptInputSelectItemProps) => (
+	<SelectItem className={cn(className)} {...props} />
+);
+
+export type PromptInputSelectValueProps = ComponentProps<typeof SelectValue>;
+
+export const PromptInputSelectValue = ({
+	className,
+	...props
+}: PromptInputSelectValueProps) => (
+	<SelectValue className={cn(className)} {...props} />
+);
+
+export type PromptInputHoverCardProps = ComponentProps<typeof HoverCard> & {
+	openDelay?: number;
+	closeDelay?: number;
+};
+
+export const PromptInputHoverCard = ({
+	openDelay = 0,
+	closeDelay = 0,
+	...props
+}: PromptInputHoverCardProps) => (
+	<HoverCard closeDelay={closeDelay} openDelay={openDelay} {...props} />
+);
+
+export type PromptInputHoverCardTriggerProps = ComponentProps<
+	typeof HoverCardTrigger
+>;
+
+export const PromptInputHoverCardTrigger = (
+	props: PromptInputHoverCardTriggerProps,
+) => <HoverCardTrigger {...props} />;
+
+export type PromptInputHoverCardContentProps = ComponentProps<
+	typeof HoverCardContent
+>;
+
+export const PromptInputHoverCardContent = ({
+	align = "start",
+	...props
+}: PromptInputHoverCardContentProps) => (
+	<HoverCardContent align={align} {...props} />
+);
+
+export type PromptInputTabsListProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTabsList = ({
+	className,
+	...props
+}: PromptInputTabsListProps) => <div className={cn(className)} {...props} />;
+
+export type PromptInputTabProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTab = ({
+	className,
+	...props
+}: PromptInputTabProps) => <div className={cn(className)} {...props} />;
+
+export type PromptInputTabLabelProps = HTMLAttributes<HTMLHeadingElement>;
+
+export const PromptInputTabLabel = ({
+	className,
+	...props
+}: PromptInputTabLabelProps) => (
+	// Content provided via children in props
+	// oxlint-disable-next-line eslint-plugin-jsx-a11y(heading-has-content)
+	<h3
+		className={cn(
+			"mb-2 px-3 font-medium text-muted-foreground text-xs",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type PromptInputTabBodyProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTabBody = ({
+	className,
+	...props
+}: PromptInputTabBodyProps) => (
+	<div className={cn("space-y-1", className)} {...props} />
+);
+
+export type PromptInputTabItemProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTabItem = ({
+	className,
+	...props
+}: PromptInputTabItemProps) => (
+	<div
+		className={cn(
+			"flex items-center gap-2 px-3 py-2 text-xs hover:bg-accent",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type PromptInputCommandProps = ComponentProps<typeof Command>;
+
+export const PromptInputCommand = ({
+	className,
+	...props
+}: PromptInputCommandProps) => <Command className={cn(className)} {...props} />;
+
+export type PromptInputCommandInputProps = ComponentProps<typeof CommandInput>;
+
+export const PromptInputCommandInput = ({
+	className,
+	...props
+}: PromptInputCommandInputProps) => (
+	<CommandInput className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandListProps = ComponentProps<typeof CommandList>;
+
+export const PromptInputCommandList = ({
+	className,
+	...props
+}: PromptInputCommandListProps) => (
+	<CommandList className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const PromptInputCommandEmpty = ({
+	className,
+	...props
+}: PromptInputCommandEmptyProps) => (
+	<CommandEmpty className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandGroupProps = ComponentProps<typeof CommandGroup>;
+
+export const PromptInputCommandGroup = ({
+	className,
+	...props
+}: PromptInputCommandGroupProps) => (
+	<CommandGroup className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandItemProps = ComponentProps<typeof CommandItem>;
+
+export const PromptInputCommandItem = ({
+	className,
+	...props
+}: PromptInputCommandItemProps) => (
+	<CommandItem className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandSeparatorProps = ComponentProps<
+	typeof CommandSeparator
+>;
+
+export const PromptInputCommandSeparator = ({
+	className,
+	...props
+}: PromptInputCommandSeparatorProps) => (
+	<CommandSeparator className={cn(className)} {...props} />
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/queue.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/queue.tsx
new file mode 100644
index 0000000..c783cac
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/queue.tsx
@@ -0,0 +1,276 @@
+"use client";
+
+import { ChevronDownIcon, PaperclipIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+export interface QueueMessagePart {
+	type: string;
+	text?: string;
+	url?: string;
+	filename?: string;
+	mediaType?: string;
+}
+
+export interface QueueMessage {
+	id: string;
+	parts: QueueMessagePart[];
+}
+
+export interface QueueTodo {
+	id: string;
+	title: string;
+	description?: string;
+	status?: "pending" | "completed";
+}
+
+export type QueueItemProps = ComponentProps<"li">;
+
+export const QueueItem = ({ className, ...props }: QueueItemProps) => (
+	<li
+		className={cn(
+			"group flex flex-col gap-1 rounded-md px-3 py-1 text-sm transition-colors hover:bg-muted",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemIndicatorProps = ComponentProps<"span"> & {
+	completed?: boolean;
+};
+
+export const QueueItemIndicator = ({
+	completed = false,
+	className,
+	...props
+}: QueueItemIndicatorProps) => (
+	<span
+		className={cn(
+			"mt-0.5 inline-block size-2.5 rounded-full border",
+			completed
+				? "border-muted-foreground/20 bg-muted-foreground/10"
+				: "border-muted-foreground/50",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemContentProps = ComponentProps<"span"> & {
+	completed?: boolean;
+};
+
+export const QueueItemContent = ({
+	completed = false,
+	className,
+	...props
+}: QueueItemContentProps) => (
+	<span
+		className={cn(
+			"line-clamp-1 grow break-words",
+			completed
+				? "text-muted-foreground/50 line-through"
+				: "text-muted-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemDescriptionProps = ComponentProps<"div"> & {
+	completed?: boolean;
+};
+
+export const QueueItemDescription = ({
+	completed = false,
+	className,
+	...props
+}: QueueItemDescriptionProps) => (
+	<div
+		className={cn(
+			"ml-6 text-xs",
+			completed
+				? "text-muted-foreground/40 line-through"
+				: "text-muted-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemActionsProps = ComponentProps<"div">;
+
+export const QueueItemActions = ({
+	className,
+	...props
+}: QueueItemActionsProps) => (
+	<div className={cn("flex gap-1", className)} {...props} />
+);
+
+export type QueueItemActionProps = Omit<
+	ComponentProps<typeof Button>,
+	"variant" | "size"
+>;
+
+export const QueueItemAction = ({
+	className,
+	...props
+}: QueueItemActionProps) => (
+	<Button
+		className={cn(
+			"size-auto rounded p-1 text-muted-foreground opacity-0 transition-opacity hover:bg-muted-foreground/10 hover:text-foreground group-hover:opacity-100",
+			className,
+		)}
+		size="icon"
+		type="button"
+		variant="ghost"
+		{...props}
+	/>
+);
+
+export type QueueItemAttachmentProps = ComponentProps<"div">;
+
+export const QueueItemAttachment = ({
+	className,
+	...props
+}: QueueItemAttachmentProps) => (
+	<div className={cn("mt-1 flex flex-wrap gap-2", className)} {...props} />
+);
+
+export type QueueItemImageProps = ComponentProps<"img">;
+
+export const QueueItemImage = ({
+	className,
+	...props
+}: QueueItemImageProps) => (
+	<img
+		alt=""
+		className={cn("h-8 w-8 rounded border object-cover", className)}
+		height={32}
+		width={32}
+		{...props}
+	/>
+);
+
+export type QueueItemFileProps = ComponentProps<"span">;
+
+export const QueueItemFile = ({
+	children,
+	className,
+	...props
+}: QueueItemFileProps) => (
+	<span
+		className={cn(
+			"flex items-center gap-1 rounded border bg-muted px-2 py-1 text-xs",
+			className,
+		)}
+		{...props}
+	>
+		<PaperclipIcon size={12} />
+		<span className="max-w-[100px] truncate">{children}</span>
+	</span>
+);
+
+export type QueueListProps = ComponentProps<typeof ScrollArea>;
+
+export const QueueList = ({
+	children,
+	className,
+	...props
+}: QueueListProps) => (
+	<ScrollArea className={cn("mt-2 -mb-1", className)} {...props}>
+		<div className="max-h-40 pr-4">
+			<ul>{children}</ul>
+		</div>
+	</ScrollArea>
+);
+
+// QueueSection - collapsible section container
+export type QueueSectionProps = ComponentProps<typeof Collapsible>;
+
+export const QueueSection = ({
+	className,
+	defaultOpen = true,
+	...props
+}: QueueSectionProps) => (
+	<Collapsible className={cn(className)} defaultOpen={defaultOpen} {...props} />
+);
+
+// QueueSectionTrigger - section header/trigger
+export type QueueSectionTriggerProps = ComponentProps<"button">;
+
+export const QueueSectionTrigger = ({
+	children,
+	className,
+	...props
+}: QueueSectionTriggerProps) => (
+	<CollapsibleTrigger
+		render={
+			<button
+				className={cn(
+					"group flex w-full items-center justify-between rounded-md bg-muted/40 px-3 py-2 text-left font-medium text-muted-foreground text-sm transition-colors hover:bg-muted",
+					className,
+				)}
+				type="button"
+				{...props}
+			/>
+		}
+	>
+		{children}
+	</CollapsibleTrigger>
+);
+
+// QueueSectionLabel - label content with icon and count
+export type QueueSectionLabelProps = ComponentProps<"span"> & {
+	count?: number;
+	label: string;
+	icon?: React.ReactNode;
+};
+
+export const QueueSectionLabel = ({
+	count,
+	label,
+	icon,
+	className,
+	...props
+}: QueueSectionLabelProps) => (
+	<span className={cn("flex items-center gap-2", className)} {...props}>
+		<ChevronDownIcon className="size-4 transition-transform group-data-[state=closed]:-rotate-90" />
+		{icon}
+		<span>
+			{count} {label}
+		</span>
+	</span>
+);
+
+// QueueSectionContent - collapsible content area
+export type QueueSectionContentProps = ComponentProps<
+	typeof CollapsibleContent
+>;
+
+export const QueueSectionContent = ({
+	className,
+	...props
+}: QueueSectionContentProps) => (
+	<CollapsibleContent className={cn(className)} {...props} />
+);
+
+export type QueueProps = ComponentProps<"div">;
+
+export const Queue = ({ className, ...props }: QueueProps) => (
+	<div
+		className={cn(
+			"flex flex-col gap-2 rounded-xl border border-border bg-background px-3 pt-2 pb-2 shadow-xs",
+			className,
+		)}
+		{...props}
+	/>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/reasoning.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/reasoning.tsx
new file mode 100644
index 0000000..929ee0b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/reasoning.tsx
@@ -0,0 +1,220 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { BrainIcon, ChevronDownIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+import { Shimmer } from "./shimmer";
+import { HubStreamdown } from "./streamdown";
+
+interface ReasoningContextValue {
+	isStreaming: boolean;
+	isOpen: boolean;
+	setIsOpen: (open: boolean) => void;
+	duration: number | undefined;
+}
+
+const ReasoningContext = createContext<ReasoningContextValue | null>(null);
+
+export const useReasoning = () => {
+	const context = useContext(ReasoningContext);
+	if (!context) {
+		throw new Error("Reasoning components must be used within Reasoning");
+	}
+	return context;
+};
+
+export type ReasoningProps = ComponentProps<typeof Collapsible> & {
+	isStreaming?: boolean;
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	duration?: number;
+};
+
+const AUTO_CLOSE_DELAY = 1000;
+const MS_IN_S = 1000;
+
+export const Reasoning = memo(
+	({
+		className,
+		isStreaming = false,
+		open,
+		defaultOpen,
+		onOpenChange,
+		duration: durationProp,
+		children,
+		...props
+	}: ReasoningProps) => {
+		const resolvedDefaultOpen = defaultOpen ?? isStreaming;
+		// Track if defaultOpen was explicitly set to false (to prevent auto-open)
+		const isExplicitlyClosed = defaultOpen === false;
+
+		const [isOpen, setIsOpen] = useControllableState<boolean>({
+			defaultProp: resolvedDefaultOpen,
+			onChange: onOpenChange,
+			prop: open,
+		});
+		const [duration, setDuration] = useControllableState<number | undefined>({
+			defaultProp: undefined,
+			prop: durationProp,
+		});
+
+		const hasEverStreamedRef = useRef(isStreaming);
+		const [hasAutoClosed, setHasAutoClosed] = useState(false);
+		const startTimeRef = useRef<number | null>(null);
+
+		// Track when streaming starts and compute duration
+		useEffect(() => {
+			if (isStreaming) {
+				hasEverStreamedRef.current = true;
+				if (startTimeRef.current === null) {
+					startTimeRef.current = Date.now();
+				}
+			} else if (startTimeRef.current !== null) {
+				setDuration(Math.ceil((Date.now() - startTimeRef.current) / MS_IN_S));
+				startTimeRef.current = null;
+			}
+		}, [isStreaming, setDuration]);
+
+		// Auto-open when streaming starts (unless explicitly closed)
+		useEffect(() => {
+			if (isStreaming && !isOpen && !isExplicitlyClosed) {
+				setIsOpen(true);
+			}
+		}, [isStreaming, isOpen, setIsOpen, isExplicitlyClosed]);
+
+		// Auto-close when streaming ends (once only, and only if it ever streamed)
+		useEffect(() => {
+			if (
+				hasEverStreamedRef.current &&
+				!isStreaming &&
+				isOpen &&
+				!hasAutoClosed
+			) {
+				const timer = setTimeout(() => {
+					setIsOpen(false);
+					setHasAutoClosed(true);
+				}, AUTO_CLOSE_DELAY);
+
+				return () => clearTimeout(timer);
+			}
+		}, [isStreaming, isOpen, setIsOpen, hasAutoClosed]);
+
+		const handleOpenChange = useCallback(
+			(newOpen: boolean) => {
+				setIsOpen(newOpen);
+			},
+			[setIsOpen],
+		);
+
+		const contextValue = useMemo(
+			() => ({ duration, isOpen, isStreaming, setIsOpen }),
+			[duration, isOpen, isStreaming, setIsOpen],
+		);
+
+		return (
+			<ReasoningContext.Provider value={contextValue}>
+				<Collapsible
+					className={cn("not-prose mb-4", className)}
+					onOpenChange={handleOpenChange}
+					open={isOpen}
+					{...props}
+				>
+					{children}
+				</Collapsible>
+			</ReasoningContext.Provider>
+		);
+	},
+);
+
+export type ReasoningTriggerProps = ComponentProps<
+	typeof CollapsibleTrigger
+> & {
+	getThinkingMessage?: (isStreaming: boolean, duration?: number) => ReactNode;
+};
+
+const defaultGetThinkingMessage = (isStreaming: boolean, duration?: number) => {
+	if (isStreaming || duration === 0) {
+		return <Shimmer duration={1}>Thinking...</Shimmer>;
+	}
+	if (duration === undefined) {
+		return <p>Thought for a few seconds</p>;
+	}
+	return <p>Thought for {duration} seconds</p>;
+};
+
+export const ReasoningTrigger = memo(
+	({
+		className,
+		children,
+		getThinkingMessage = defaultGetThinkingMessage,
+		...props
+	}: ReasoningTriggerProps) => {
+		const { isStreaming, isOpen, duration } = useReasoning();
+
+		return (
+			<CollapsibleTrigger
+				className={cn(
+					"flex w-full items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<BrainIcon className="size-4" />
+						{getThinkingMessage(isStreaming, duration)}
+						<ChevronDownIcon
+							className={cn(
+								"size-4 transition-transform",
+								isOpen ? "rotate-180" : "rotate-0",
+							)}
+						/>
+					</>
+				)}
+			</CollapsibleTrigger>
+		);
+	},
+);
+
+export type ReasoningContentProps = ComponentProps<
+	typeof CollapsibleContent
+> & {
+	children: string;
+};
+
+export const ReasoningContent = memo(
+	({ className, children, ...props }: ReasoningContentProps) => (
+		<CollapsibleContent
+			className={cn(
+				"mt-4 text-sm",
+				"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-muted-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+				className,
+			)}
+			{...props}
+		>
+			<HubStreamdown>{children}</HubStreamdown>
+		</CollapsibleContent>
+	),
+);
+
+Reasoning.displayName = "Reasoning";
+ReasoningTrigger.displayName = "ReasoningTrigger";
+ReasoningContent.displayName = "ReasoningContent";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/sandbox.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/sandbox.tsx
new file mode 100644
index 0000000..fb05575
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/sandbox.tsx
@@ -0,0 +1,127 @@
+"use client";
+
+import type { ToolUIPart } from "ai";
+import { ChevronDownIcon, Code } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { cn } from "@/lib/utils";
+
+import { getStatusBadge } from "./status-badge";
+
+export type SandboxRootProps = ComponentProps<typeof Collapsible>;
+
+export const Sandbox = ({ className, ...props }: SandboxRootProps) => (
+	<Collapsible
+		className={cn(
+			"not-prose group mb-4 w-full overflow-hidden rounded-md border",
+			className,
+		)}
+		defaultOpen
+		{...props}
+	/>
+);
+
+export interface SandboxHeaderProps {
+	title?: string;
+	state: ToolUIPart["state"];
+	className?: string;
+}
+
+export const SandboxHeader = ({
+	className,
+	title,
+	state,
+	...props
+}: SandboxHeaderProps) => (
+	<CollapsibleTrigger
+		className={cn(
+			"flex w-full items-center justify-between gap-4 p-3",
+			className,
+		)}
+		{...props}
+	>
+		<div className="flex items-center gap-2">
+			<Code className="size-4 text-muted-foreground" />
+			<span className="font-medium text-sm">{title}</span>
+			{getStatusBadge(state)}
+		</div>
+		<ChevronDownIcon className="size-4 text-muted-foreground transition-transform group-data-[state=open]:rotate-180" />
+	</CollapsibleTrigger>
+);
+
+export type SandboxContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const SandboxContent = ({
+	className,
+	...props
+}: SandboxContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SandboxTabsProps = ComponentProps<typeof Tabs>;
+
+export const SandboxTabs = ({ className, ...props }: SandboxTabsProps) => (
+	<Tabs className={cn("w-full gap-0", className)} {...props} />
+);
+
+export type SandboxTabsBarProps = ComponentProps<"div">;
+
+export const SandboxTabsBar = ({
+	className,
+	...props
+}: SandboxTabsBarProps) => (
+	<div
+		className={cn(
+			"flex w-full items-center border-border border-t border-b",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SandboxTabsListProps = ComponentProps<typeof TabsList>;
+
+export const SandboxTabsList = ({
+	className,
+	...props
+}: SandboxTabsListProps) => (
+	<TabsList
+		className={cn("h-auto rounded-none border-0 bg-transparent p-0", className)}
+		{...props}
+	/>
+);
+
+export type SandboxTabsTriggerProps = ComponentProps<typeof TabsTrigger>;
+
+export const SandboxTabsTrigger = ({
+	className,
+	...props
+}: SandboxTabsTriggerProps) => (
+	<TabsTrigger
+		className={cn(
+			"rounded-none border-0 border-transparent border-b-2 px-4 py-2 font-medium text-muted-foreground text-sm transition-colors data-[state=active]:border-primary data-[state=active]:bg-transparent data-[state=active]:text-foreground data-[state=active]:shadow-none",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SandboxTabContentProps = ComponentProps<typeof TabsContent>;
+
+export const SandboxTabContent = ({
+	className,
+	...props
+}: SandboxTabContentProps) => (
+	<TabsContent className={cn("mt-0 text-sm", className)} {...props} />
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/schema-display.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/schema-display.tsx
new file mode 100644
index 0000000..d547961
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/schema-display.tsx
@@ -0,0 +1,472 @@
+"use client";
+
+import { ChevronRightIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+interface SchemaParameter {
+	name: string;
+	type: string;
+	required?: boolean;
+	description?: string;
+	location?: "path" | "query" | "header";
+}
+
+interface SchemaProperty {
+	name: string;
+	type: string;
+	required?: boolean;
+	description?: string;
+	properties?: SchemaProperty[];
+	items?: SchemaProperty;
+}
+
+interface SchemaDisplayContextType {
+	method: HttpMethod;
+	path: string;
+	description?: string;
+	parameters?: SchemaParameter[];
+	requestBody?: SchemaProperty[];
+	responseBody?: SchemaProperty[];
+}
+
+const SchemaDisplayContext = createContext<SchemaDisplayContextType>({
+	method: "GET",
+	path: "",
+});
+
+const methodStyles: Record<HttpMethod, string> = {
+	DELETE: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
+	GET: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+	PATCH:
+		"bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
+	POST: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+	PUT: "bg-orange-100 text-orange-700 dark:bg-orange-900/30 dark:text-orange-400",
+};
+
+export type SchemaDisplayHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const SchemaDisplayHeader = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayHeaderProps) => (
+	<div
+		className={cn("flex items-center gap-3 border-b px-4 py-3", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type SchemaDisplayMethodProps = ComponentProps<typeof Badge>;
+
+export const SchemaDisplayMethod = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayMethodProps) => {
+	const { method } = useContext(SchemaDisplayContext);
+
+	return (
+		<Badge
+			className={cn("font-mono text-xs", methodStyles[method], className)}
+			variant="secondary"
+			{...props}
+		>
+			{children ?? method}
+		</Badge>
+	);
+};
+
+export type SchemaDisplayPathProps = HTMLAttributes<HTMLSpanElement>;
+
+export const SchemaDisplayPath = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayPathProps) => {
+	const { path } = useContext(SchemaDisplayContext);
+
+	// Highlight path parameters
+	const highlightedPath = path.replaceAll(
+		/\{([^}]+)\}/g,
+		'<span class="text-blue-600 dark:text-blue-400">{$1}</span>',
+	);
+
+	return (
+		<span
+			className={cn("font-mono text-sm", className)}
+			// oxlint-disable-next-line eslint-plugin-react(no-danger)
+			// biome-ignore lint/security/noDangerouslySetInnerHtml: content is sanitized highlighted syntax
+			dangerouslySetInnerHTML={{ __html: children ?? highlightedPath }}
+			{...props}
+		/>
+	);
+};
+
+export type SchemaDisplayDescriptionProps =
+	HTMLAttributes<HTMLParagraphElement>;
+
+export const SchemaDisplayDescription = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayDescriptionProps) => {
+	const { description } = useContext(SchemaDisplayContext);
+
+	return (
+		<p
+			className={cn(
+				"border-b px-4 py-3 text-muted-foreground text-sm",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? description}
+		</p>
+	);
+};
+
+export type SchemaDisplayContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const SchemaDisplayContent = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayContentProps) => (
+	<div className={cn("divide-y", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type SchemaDisplayParameterProps = HTMLAttributes<HTMLDivElement> &
+	SchemaParameter;
+
+export const SchemaDisplayParameter = ({
+	name,
+	type,
+	required,
+	description,
+	location,
+	className,
+	...props
+}: SchemaDisplayParameterProps) => (
+	<div className={cn("px-4 py-3 pl-10", className)} {...props}>
+		<div className="flex items-center gap-2">
+			<span className="font-mono text-sm">{name}</span>
+			<Badge className="text-xs" variant="outline">
+				{type}
+			</Badge>
+			{location && (
+				<Badge className="text-xs" variant="secondary">
+					{location}
+				</Badge>
+			)}
+			{required && (
+				<Badge
+					className="bg-red-100 text-red-700 text-xs dark:bg-red-900/30 dark:text-red-400"
+					variant="secondary"
+				>
+					required
+				</Badge>
+			)}
+		</div>
+		{description && (
+			<p className="mt-1 text-muted-foreground text-sm">{description}</p>
+		)}
+	</div>
+);
+
+export type SchemaDisplayParametersProps = ComponentProps<typeof Collapsible>;
+
+export const SchemaDisplayParameters = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayParametersProps) => {
+	const { parameters } = useContext(SchemaDisplayContext);
+
+	return (
+		<Collapsible className={cn(className)} defaultOpen {...props}>
+			<CollapsibleTrigger className="group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50">
+				<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+				<span className="font-medium text-sm">Parameters</span>
+				<Badge className="ml-auto text-xs" variant="secondary">
+					{parameters?.length}
+				</Badge>
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="divide-y border-t">
+					{children ??
+						parameters?.map((param) => (
+							<SchemaDisplayParameter key={param.name} {...param} />
+						))}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
+
+export type SchemaDisplayPropertyProps = HTMLAttributes<HTMLDivElement> &
+	SchemaProperty & {
+		depth?: number;
+	};
+
+export const SchemaDisplayProperty = ({
+	name,
+	type,
+	required,
+	description,
+	properties,
+	items,
+	depth = 0,
+	className,
+	...props
+}: SchemaDisplayPropertyProps) => {
+	const hasChildren = properties || items;
+	const paddingLeft = 40 + depth * 16;
+
+	if (hasChildren) {
+		return (
+			<Collapsible defaultOpen={depth < 2}>
+				<CollapsibleTrigger
+					className={cn(
+						"group flex w-full items-center gap-2 py-3 text-left transition-colors hover:bg-muted/50",
+						className,
+					)}
+					style={{ paddingLeft }}
+				>
+					<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+					<span className="font-mono text-sm">{name}</span>
+					<Badge className="text-xs" variant="outline">
+						{type}
+					</Badge>
+					{required && (
+						<Badge
+							className="bg-red-100 text-red-700 text-xs dark:bg-red-900/30 dark:text-red-400"
+							variant="secondary"
+						>
+							required
+						</Badge>
+					)}
+				</CollapsibleTrigger>
+				{description && (
+					<p
+						className="pb-2 text-muted-foreground text-sm"
+						style={{ paddingLeft: paddingLeft + 24 }}
+					>
+						{description}
+					</p>
+				)}
+				<CollapsibleContent>
+					<div className="divide-y border-t">
+						{properties?.map((prop) => (
+							<SchemaDisplayProperty
+								key={prop.name}
+								{...prop}
+								depth={depth + 1}
+							/>
+						))}
+						{items && (
+							<SchemaDisplayProperty
+								{...items}
+								depth={depth + 1}
+								name={`${name}[]`}
+							/>
+						)}
+					</div>
+				</CollapsibleContent>
+			</Collapsible>
+		);
+	}
+
+	return (
+		<div
+			className={cn("py-3 pr-4", className)}
+			style={{ paddingLeft }}
+			{...props}
+		>
+			<div className="flex items-center gap-2">
+				{/* Spacer for alignment */}
+				<span className="size-4" />
+				<span className="font-mono text-sm">{name}</span>
+				<Badge className="text-xs" variant="outline">
+					{type}
+				</Badge>
+				{required && (
+					<Badge
+						className="bg-red-100 text-red-700 text-xs dark:bg-red-900/30 dark:text-red-400"
+						variant="secondary"
+					>
+						required
+					</Badge>
+				)}
+			</div>
+			{description && (
+				<p className="mt-1 pl-6 text-muted-foreground text-sm">{description}</p>
+			)}
+		</div>
+	);
+};
+
+export type SchemaDisplayRequestProps = ComponentProps<typeof Collapsible>;
+
+export const SchemaDisplayRequest = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayRequestProps) => {
+	const { requestBody } = useContext(SchemaDisplayContext);
+
+	return (
+		<Collapsible className={cn(className)} defaultOpen {...props}>
+			<CollapsibleTrigger className="group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50">
+				<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+				<span className="font-medium text-sm">Request Body</span>
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="border-t">
+					{children ??
+						requestBody?.map((prop) => (
+							<SchemaDisplayProperty key={prop.name} {...prop} depth={0} />
+						))}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
+
+export type SchemaDisplayResponseProps = ComponentProps<typeof Collapsible>;
+
+export const SchemaDisplayResponse = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayResponseProps) => {
+	const { responseBody } = useContext(SchemaDisplayContext);
+
+	return (
+		<Collapsible className={cn(className)} defaultOpen {...props}>
+			<CollapsibleTrigger className="group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50">
+				<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+				<span className="font-medium text-sm">Response</span>
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="border-t">
+					{children ??
+						responseBody?.map((prop) => (
+							<SchemaDisplayProperty key={prop.name} {...prop} depth={0} />
+						))}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
+
+export type SchemaDisplayProps = HTMLAttributes<HTMLDivElement> & {
+	method: HttpMethod;
+	path: string;
+	description?: string;
+	parameters?: SchemaParameter[];
+	requestBody?: SchemaProperty[];
+	responseBody?: SchemaProperty[];
+};
+
+export const SchemaDisplay = ({
+	method,
+	path,
+	description,
+	parameters,
+	requestBody,
+	responseBody,
+	className,
+	children,
+	...props
+}: SchemaDisplayProps) => {
+	const contextValue = useMemo(
+		() => ({
+			description,
+			method,
+			parameters,
+			path,
+			requestBody,
+			responseBody,
+		}),
+		[description, method, parameters, path, requestBody, responseBody],
+	);
+
+	return (
+		<SchemaDisplayContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"overflow-hidden rounded-lg border bg-background",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<SchemaDisplayHeader>
+							<div className="flex items-center gap-3">
+								<SchemaDisplayMethod />
+								<SchemaDisplayPath />
+							</div>
+						</SchemaDisplayHeader>
+						{description && <SchemaDisplayDescription />}
+						<SchemaDisplayContent>
+							{parameters && parameters.length > 0 && (
+								<SchemaDisplayParameters />
+							)}
+							{requestBody && requestBody.length > 0 && (
+								<SchemaDisplayRequest />
+							)}
+							{responseBody && responseBody.length > 0 && (
+								<SchemaDisplayResponse />
+							)}
+						</SchemaDisplayContent>
+					</>
+				)}
+			</div>
+		</SchemaDisplayContext.Provider>
+	);
+};
+
+export type SchemaDisplayBodyProps = HTMLAttributes<HTMLDivElement>;
+
+export const SchemaDisplayBody = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayBodyProps) => (
+	<div className={cn("divide-y", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type SchemaDisplayExampleProps = HTMLAttributes<HTMLPreElement>;
+
+export const SchemaDisplayExample = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayExampleProps) => (
+	<pre
+		className={cn(
+			"mx-4 mb-4 overflow-auto rounded-md bg-muted p-4 font-mono text-sm",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</pre>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/shimmer.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/shimmer.tsx
new file mode 100644
index 0000000..5c4e9c8
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/shimmer.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import type { MotionProps } from "motion/react";
+import { motion } from "motion/react";
+import type { CSSProperties, ElementType, JSX } from "react";
+import { memo, useMemo } from "react";
+import { cn } from "@/lib/utils";
+
+type MotionHTMLProps = MotionProps & Record<string, unknown>;
+
+// Cache motion components at module level to avoid creating during render
+const motionComponentCache = new Map<
+	keyof JSX.IntrinsicElements,
+	React.ComponentType<MotionHTMLProps>
+>();
+
+const getMotionComponent = (element: keyof JSX.IntrinsicElements) => {
+	let component = motionComponentCache.get(element);
+	if (!component) {
+		component = motion.create(element);
+		motionComponentCache.set(element, component);
+	}
+	return component;
+};
+
+export interface TextShimmerProps {
+	children: string;
+	as?: ElementType;
+	className?: string;
+	duration?: number;
+	spread?: number;
+}
+
+const ShimmerComponent = ({
+	children,
+	as: Component = "p",
+	className,
+	duration = 2,
+	spread = 2,
+}: TextShimmerProps) => {
+	const MotionComponent = getMotionComponent(
+		Component as keyof JSX.IntrinsicElements,
+	);
+
+	const dynamicSpread = useMemo(
+		() => (children?.length ?? 0) * spread,
+		[children, spread],
+	);
+
+	return (
+		<MotionComponent
+			animate={{ backgroundPosition: "0% center" }}
+			className={cn(
+				"relative inline-block bg-[length:250%_100%,auto] bg-clip-text text-transparent",
+				"[--bg:linear-gradient(90deg,#0000_calc(50%-var(--spread)),var(--color-background),#0000_calc(50%+var(--spread)))] [background-repeat:no-repeat,padding-box]",
+				className,
+			)}
+			initial={{ backgroundPosition: "100% center" }}
+			style={
+				{
+					"--spread": `${dynamicSpread}px`,
+					backgroundImage:
+						"var(--bg), linear-gradient(var(--color-muted-foreground), var(--color-muted-foreground))",
+				} as CSSProperties
+			}
+			transition={{
+				duration,
+				ease: "linear",
+				repeat: Number.POSITIVE_INFINITY,
+			}}
+		>
+			{children}
+		</MotionComponent>
+	);
+};
+
+export const Shimmer = memo(ShimmerComponent);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/snippet.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/snippet.tsx
new file mode 100644
index 0000000..13668b6
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/snippet.tsx
@@ -0,0 +1,145 @@
+"use client";
+
+import { CheckIcon, CopyIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupInput,
+	InputGroupText,
+} from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+interface SnippetContextType {
+	code: string;
+}
+
+const SnippetContext = createContext<SnippetContextType>({
+	code: "",
+});
+
+export type SnippetProps = ComponentProps<typeof InputGroup> & {
+	code: string;
+};
+
+export const Snippet = ({
+	code,
+	className,
+	children,
+	...props
+}: SnippetProps) => {
+	const contextValue = useMemo(() => ({ code }), [code]);
+
+	return (
+		<SnippetContext.Provider value={contextValue}>
+			<InputGroup className={cn("font-mono", className)} {...props}>
+				{children}
+			</InputGroup>
+		</SnippetContext.Provider>
+	);
+};
+
+export type SnippetAddonProps = ComponentProps<typeof InputGroupAddon>;
+
+export const SnippetAddon = (props: SnippetAddonProps) => (
+	<InputGroupAddon {...props} />
+);
+
+export type SnippetTextProps = ComponentProps<typeof InputGroupText>;
+
+export const SnippetText = ({ className, ...props }: SnippetTextProps) => (
+	<InputGroupText
+		className={cn("pl-2 font-normal text-muted-foreground", className)}
+		{...props}
+	/>
+);
+
+export type SnippetInputProps = Omit<
+	ComponentProps<typeof InputGroupInput>,
+	"readOnly" | "value"
+>;
+
+export const SnippetInput = ({ className, ...props }: SnippetInputProps) => {
+	const { code } = useContext(SnippetContext);
+
+	return (
+		<InputGroupInput
+			className={cn("text-foreground", className)}
+			readOnly
+			value={code}
+			{...props}
+		/>
+	);
+};
+
+export type SnippetCopyButtonProps = ComponentProps<typeof InputGroupButton> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const SnippetCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: SnippetCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { code } = useContext(SnippetContext);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			if (!isCopied) {
+				await navigator.clipboard.writeText(code);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			}
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [code, onCopy, onError, timeout, isCopied]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<InputGroupButton
+			aria-label="Copy"
+			className={className}
+			onClick={copyToClipboard}
+			size="icon-sm"
+			title="Copy"
+			{...props}
+		>
+			{children ?? <Icon className="size-3.5" size={14} />}
+		</InputGroupButton>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/sources.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/sources.tsx
new file mode 100644
index 0000000..477d007
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/sources.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import { BookIcon, ChevronDownIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+export type SourcesProps = ComponentProps<"div">;
+
+export const Sources = ({ className, ...props }: SourcesProps) => (
+	<Collapsible
+		className={cn("not-prose mb-4 text-primary text-xs", className)}
+		{...props}
+	/>
+);
+
+export type SourcesTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+	count: number;
+};
+
+export const SourcesTrigger = ({
+	className,
+	count,
+	children,
+	...props
+}: SourcesTriggerProps) => (
+	<CollapsibleTrigger
+		className={cn("flex items-center gap-2", className)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				<p className="font-medium">Used {count} sources</p>
+				<ChevronDownIcon className="h-4 w-4" />
+			</>
+		)}
+	</CollapsibleTrigger>
+);
+
+export type SourcesContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const SourcesContent = ({
+	className,
+	...props
+}: SourcesContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"mt-3 flex w-fit flex-col gap-2",
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SourceProps = ComponentProps<"a">;
+
+export const Source = ({ href, title, children, ...props }: SourceProps) => (
+	<a
+		className="flex items-center gap-2"
+		href={href}
+		rel="noreferrer"
+		target="_blank"
+		{...props}
+	>
+		{children ?? (
+			<>
+				<BookIcon className="h-4 w-4" />
+				<span className="block font-medium">{title}</span>
+			</>
+		)}
+	</a>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/speech-input.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/speech-input.tsx
new file mode 100644
index 0000000..b9ee555
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/speech-input.tsx
@@ -0,0 +1,323 @@
+"use client";
+
+import { MicIcon, SquareIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Spinner } from "@/components/ui/spinner";
+import { cn } from "@/lib/utils";
+
+interface SpeechRecognition extends EventTarget {
+	continuous: boolean;
+	interimResults: boolean;
+	lang: string;
+	start(): void;
+	stop(): void;
+	onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+	onend: ((this: SpeechRecognition, ev: Event) => void) | null;
+	onresult:
+		| ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void)
+		| null;
+	onerror:
+		| ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void)
+		| null;
+}
+
+interface SpeechRecognitionEvent extends Event {
+	results: SpeechRecognitionResultList;
+	resultIndex: number;
+}
+
+interface SpeechRecognitionResultList {
+	readonly length: number;
+	item(index: number): SpeechRecognitionResult;
+	[index: number]: SpeechRecognitionResult;
+}
+
+interface SpeechRecognitionResult {
+	readonly length: number;
+	item(index: number): SpeechRecognitionAlternative;
+	[index: number]: SpeechRecognitionAlternative;
+	isFinal: boolean;
+}
+
+interface SpeechRecognitionAlternative {
+	transcript: string;
+	confidence: number;
+}
+
+interface SpeechRecognitionErrorEvent extends Event {
+	error: string;
+}
+
+declare global {
+	interface Window {
+		SpeechRecognition: new () => SpeechRecognition;
+		webkitSpeechRecognition: new () => SpeechRecognition;
+	}
+}
+
+type SpeechInputMode = "speech-recognition" | "media-recorder" | "none";
+
+export type SpeechInputProps = ComponentProps<typeof Button> & {
+	onTranscriptionChange?: (text: string) => void;
+	/**
+	 * Callback for when audio is recorded using MediaRecorder fallback.
+	 * This is called in browsers that don't support the Web Speech API (Firefox, Safari).
+	 * The callback receives an audio Blob that should be sent to a transcription service.
+	 * Return the transcribed text, which will be passed to onTranscriptionChange.
+	 */
+	onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+	lang?: string;
+};
+
+const detectSpeechInputMode = (): SpeechInputMode => {
+	if (typeof window === "undefined") {
+		return "none";
+	}
+
+	if ("SpeechRecognition" in window || "webkitSpeechRecognition" in window) {
+		return "speech-recognition";
+	}
+
+	if ("MediaRecorder" in window && "mediaDevices" in navigator) {
+		return "media-recorder";
+	}
+
+	return "none";
+};
+
+export const SpeechInput = ({
+	className,
+	onTranscriptionChange,
+	onAudioRecorded,
+	lang = "en-US",
+	...props
+}: SpeechInputProps) => {
+	const [isListening, setIsListening] = useState(false);
+	const [isProcessing, setIsProcessing] = useState(false);
+	const [mode] = useState<SpeechInputMode>(detectSpeechInputMode);
+	const [isRecognitionReady, setIsRecognitionReady] = useState(false);
+	const recognitionRef = useRef<SpeechRecognition | null>(null);
+	const mediaRecorderRef = useRef<MediaRecorder | null>(null);
+	const streamRef = useRef<MediaStream | null>(null);
+	const audioChunksRef = useRef<Blob[]>([]);
+	const onTranscriptionChangeRef = useRef<
+		SpeechInputProps["onTranscriptionChange"]
+	>(onTranscriptionChange);
+	const onAudioRecordedRef =
+		useRef<SpeechInputProps["onAudioRecorded"]>(onAudioRecorded);
+
+	// Keep refs in sync
+	onTranscriptionChangeRef.current = onTranscriptionChange;
+	onAudioRecordedRef.current = onAudioRecorded;
+
+	// Initialize Speech Recognition when mode is speech-recognition
+	useEffect(() => {
+		if (mode !== "speech-recognition") {
+			return;
+		}
+
+		const SpeechRecognition =
+			window.SpeechRecognition || window.webkitSpeechRecognition;
+		const speechRecognition = new SpeechRecognition();
+
+		speechRecognition.continuous = true;
+		speechRecognition.interimResults = true;
+		speechRecognition.lang = lang;
+
+		const handleStart = () => {
+			setIsListening(true);
+		};
+
+		const handleEnd = () => {
+			setIsListening(false);
+		};
+
+		const handleResult = (event: Event) => {
+			const speechEvent = event as SpeechRecognitionEvent;
+			let finalTranscript = "";
+
+			for (
+				let i = speechEvent.resultIndex;
+				i < speechEvent.results.length;
+				i += 1
+			) {
+				const result = speechEvent.results[i];
+				if (result.isFinal) {
+					finalTranscript += result[0]?.transcript ?? "";
+				}
+			}
+
+			if (finalTranscript) {
+				onTranscriptionChangeRef.current?.(finalTranscript);
+			}
+		};
+
+		const handleError = () => {
+			setIsListening(false);
+		};
+
+		speechRecognition.addEventListener("start", handleStart);
+		speechRecognition.addEventListener("end", handleEnd);
+		speechRecognition.addEventListener("result", handleResult);
+		speechRecognition.addEventListener("error", handleError);
+
+		recognitionRef.current = speechRecognition;
+		setIsRecognitionReady(true);
+
+		return () => {
+			speechRecognition.removeEventListener("start", handleStart);
+			speechRecognition.removeEventListener("end", handleEnd);
+			speechRecognition.removeEventListener("result", handleResult);
+			speechRecognition.removeEventListener("error", handleError);
+			speechRecognition.stop();
+			recognitionRef.current = null;
+			setIsRecognitionReady(false);
+		};
+	}, [mode, lang]);
+
+	// Cleanup MediaRecorder and stream on unmount
+	useEffect(
+		() => () => {
+			if (mediaRecorderRef.current?.state === "recording") {
+				mediaRecorderRef.current.stop();
+			}
+			if (streamRef.current) {
+				for (const track of streamRef.current.getTracks()) {
+					track.stop();
+				}
+			}
+		},
+		[],
+	);
+
+	// Start MediaRecorder recording
+	const startMediaRecorder = useCallback(async () => {
+		if (!onAudioRecordedRef.current) {
+			return;
+		}
+
+		try {
+			const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+			streamRef.current = stream;
+			const mediaRecorder = new MediaRecorder(stream);
+			audioChunksRef.current = [];
+
+			const handleDataAvailable = (event: BlobEvent) => {
+				if (event.data.size > 0) {
+					audioChunksRef.current.push(event.data);
+				}
+			};
+
+			const handleStop = async () => {
+				for (const track of stream.getTracks()) {
+					track.stop();
+				}
+				streamRef.current = null;
+
+				const audioBlob = new Blob(audioChunksRef.current, {
+					type: "audio/webm",
+				});
+
+				if (audioBlob.size > 0 && onAudioRecordedRef.current) {
+					setIsProcessing(true);
+					try {
+						const transcript = await onAudioRecordedRef.current(audioBlob);
+						if (transcript) {
+							onTranscriptionChangeRef.current?.(transcript);
+						}
+					} catch {
+						// Error handling delegated to the onAudioRecorded caller
+					} finally {
+						setIsProcessing(false);
+					}
+				}
+			};
+
+			const handleError = () => {
+				setIsListening(false);
+				for (const track of stream.getTracks()) {
+					track.stop();
+				}
+				streamRef.current = null;
+			};
+
+			mediaRecorder.addEventListener("dataavailable", handleDataAvailable);
+			mediaRecorder.addEventListener("stop", handleStop);
+			mediaRecorder.addEventListener("error", handleError);
+
+			mediaRecorderRef.current = mediaRecorder;
+			mediaRecorder.start();
+			setIsListening(true);
+		} catch {
+			setIsListening(false);
+		}
+	}, []);
+
+	// Stop MediaRecorder recording
+	const stopMediaRecorder = useCallback(() => {
+		if (mediaRecorderRef.current?.state === "recording") {
+			mediaRecorderRef.current.stop();
+		}
+		setIsListening(false);
+	}, []);
+
+	const toggleListening = useCallback(() => {
+		if (mode === "speech-recognition" && recognitionRef.current) {
+			if (isListening) {
+				recognitionRef.current.stop();
+			} else {
+				recognitionRef.current.start();
+			}
+		} else if (mode === "media-recorder") {
+			if (isListening) {
+				stopMediaRecorder();
+			} else {
+				startMediaRecorder();
+			}
+		}
+	}, [mode, isListening, startMediaRecorder, stopMediaRecorder]);
+
+	// Determine if button should be disabled
+	const isDisabled =
+		mode === "none" ||
+		(mode === "speech-recognition" && !isRecognitionReady) ||
+		(mode === "media-recorder" && !onAudioRecorded) ||
+		isProcessing;
+
+	return (
+		<div className="relative inline-flex items-center justify-center">
+			{/* Animated pulse rings */}
+			{isListening &&
+				[0, 1, 2].map((index) => (
+					<div
+						className="absolute inset-0 animate-ping rounded-full border-2 border-red-400/30"
+						key={index}
+						style={{
+							animationDelay: `${index * 0.3}s`,
+							animationDuration: "2s",
+						}}
+					/>
+				))}
+
+			{/* Main record button */}
+			<Button
+				className={cn(
+					"relative z-10 rounded-full transition-all duration-300",
+					isListening
+						? "bg-destructive text-white hover:bg-destructive/80 hover:text-white"
+						: "bg-primary text-primary-foreground hover:bg-primary/80 hover:text-primary-foreground",
+					className,
+				)}
+				disabled={isDisabled}
+				onClick={toggleListening}
+				{...props}
+			>
+				{isProcessing && <Spinner />}
+				{!isProcessing && isListening && <SquareIcon className="size-4" />}
+				{!(isProcessing || isListening) && <MicIcon className="size-4" />}
+			</Button>
+		</div>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/stack-trace.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/stack-trace.tsx
new file mode 100644
index 0000000..42e15b6
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/stack-trace.tsx
@@ -0,0 +1,532 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import {
+	AlertTriangleIcon,
+	CheckIcon,
+	ChevronDownIcon,
+	CopyIcon,
+} from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+// Regex patterns for parsing stack traces
+const STACK_FRAME_WITH_PARENS_REGEX = /^at\s+(.+?)\s+\((.+):(\d+):(\d+)\)$/;
+const STACK_FRAME_WITHOUT_FN_REGEX = /^at\s+(.+):(\d+):(\d+)$/;
+const ERROR_TYPE_REGEX = /^(\w+Error|Error):\s*(.*)$/;
+const AT_PREFIX_REGEX = /^at\s+/;
+
+interface StackFrame {
+	raw: string;
+	functionName: string | null;
+	filePath: string | null;
+	lineNumber: number | null;
+	columnNumber: number | null;
+	isInternal: boolean;
+}
+
+interface ParsedStackTrace {
+	errorType: string | null;
+	errorMessage: string;
+	frames: StackFrame[];
+	raw: string;
+}
+
+interface StackTraceContextValue {
+	trace: ParsedStackTrace;
+	raw: string;
+	isOpen: boolean;
+	setIsOpen: (open: boolean) => void;
+	onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+}
+
+const StackTraceContext = createContext<StackTraceContextValue | null>(null);
+
+const useStackTrace = () => {
+	const context = useContext(StackTraceContext);
+	if (!context) {
+		throw new Error("StackTrace components must be used within StackTrace");
+	}
+	return context;
+};
+
+const parseStackFrame = (line: string): StackFrame => {
+	const trimmed = line.trim();
+
+	// Pattern: at functionName (filePath:line:column)
+	const withParensMatch = trimmed.match(STACK_FRAME_WITH_PARENS_REGEX);
+	if (withParensMatch) {
+		const [, functionName, filePath, lineNum, colNum] = withParensMatch;
+		const isInternal =
+			filePath.includes("node_modules") ||
+			filePath.startsWith("node:") ||
+			filePath.includes("internal/");
+		return {
+			columnNumber: colNum ? Number.parseInt(colNum, 10) : null,
+			filePath: filePath ?? null,
+			functionName: functionName ?? null,
+			isInternal,
+			lineNumber: lineNum ? Number.parseInt(lineNum, 10) : null,
+			raw: trimmed,
+		};
+	}
+
+	// Pattern: at filePath:line:column (no function name)
+	const withoutFnMatch = trimmed.match(STACK_FRAME_WITHOUT_FN_REGEX);
+	if (withoutFnMatch) {
+		const [, filePath, lineNum, colNum] = withoutFnMatch;
+		const isInternal =
+			(filePath?.includes("node_modules") ?? false) ||
+			(filePath?.startsWith("node:") ?? false) ||
+			(filePath?.includes("internal/") ?? false);
+		return {
+			columnNumber: colNum ? Number.parseInt(colNum, 10) : null,
+			filePath: filePath ?? null,
+			functionName: null,
+			isInternal,
+			lineNumber: lineNum ? Number.parseInt(lineNum, 10) : null,
+			raw: trimmed,
+		};
+	}
+
+	// Fallback: unparseable line
+	return {
+		columnNumber: null,
+		filePath: null,
+		functionName: null,
+		isInternal: trimmed.includes("node_modules") || trimmed.includes("node:"),
+		lineNumber: null,
+		raw: trimmed,
+	};
+};
+
+const parseStackTrace = (trace: string): ParsedStackTrace => {
+	const lines = trace.split("\n").filter((line) => line.trim());
+
+	if (lines.length === 0) {
+		return {
+			errorMessage: trace,
+			errorType: null,
+			frames: [],
+			raw: trace,
+		};
+	}
+
+	const firstLine = lines[0].trim();
+	let errorType: string | null = null;
+	let errorMessage = firstLine;
+
+	// Try to extract error type from "ErrorType: message" format
+	const errorMatch = firstLine.match(ERROR_TYPE_REGEX);
+	if (errorMatch) {
+		const [, type, msg] = errorMatch;
+		errorType = type;
+		errorMessage = msg || "";
+	}
+
+	// Parse stack frames (lines starting with "at")
+	const frames = lines
+		.slice(1)
+		.filter((line) => line.trim().startsWith("at "))
+		.map(parseStackFrame);
+
+	return {
+		errorMessage,
+		errorType,
+		frames,
+		raw: trace,
+	};
+};
+
+export type StackTraceProps = ComponentProps<"div"> & {
+	trace: string;
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+};
+
+export const StackTrace = memo(
+	({
+		trace,
+		className,
+		open,
+		defaultOpen = false,
+		onOpenChange,
+		onFilePathClick,
+		children,
+		...props
+	}: StackTraceProps) => {
+		const [isOpen, setIsOpen] = useControllableState({
+			defaultProp: defaultOpen,
+			onChange: onOpenChange,
+			prop: open,
+		});
+
+		const parsedTrace = useMemo(() => parseStackTrace(trace), [trace]);
+
+		const contextValue = useMemo(
+			() => ({
+				isOpen,
+				onFilePathClick,
+				raw: trace,
+				setIsOpen,
+				trace: parsedTrace,
+			}),
+			[parsedTrace, trace, isOpen, setIsOpen, onFilePathClick],
+		);
+
+		return (
+			<StackTraceContext.Provider value={contextValue}>
+				<div
+					className={cn(
+						"not-prose w-full overflow-hidden rounded-lg border bg-background font-mono text-sm",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+				</div>
+			</StackTraceContext.Provider>
+		);
+	},
+);
+
+export type StackTraceHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+
+export const StackTraceHeader = memo(
+	({ className, children, ...props }: StackTraceHeaderProps) => {
+		const { isOpen, setIsOpen } = useStackTrace();
+
+		return (
+			<Collapsible onOpenChange={setIsOpen} open={isOpen}>
+				<CollapsibleTrigger
+					{...props}
+					render={
+						<div
+							className={cn(
+								"flex w-full cursor-pointer items-center gap-3 p-3 text-left transition-colors hover:bg-muted/50",
+								className,
+							)}
+						/>
+					}
+				>
+					{children}
+				</CollapsibleTrigger>
+			</Collapsible>
+		);
+	},
+);
+
+export type StackTraceErrorProps = ComponentProps<"div">;
+
+export const StackTraceError = memo(
+	({ className, children, ...props }: StackTraceErrorProps) => (
+		<div
+			className={cn(
+				"flex flex-1 items-center gap-2 overflow-hidden",
+				className,
+			)}
+			{...props}
+		>
+			<AlertTriangleIcon className="size-4 shrink-0 text-destructive" />
+			{children}
+		</div>
+	),
+);
+
+export type StackTraceErrorTypeProps = ComponentProps<"span">;
+
+export const StackTraceErrorType = memo(
+	({ className, children, ...props }: StackTraceErrorTypeProps) => {
+		const { trace } = useStackTrace();
+
+		return (
+			<span
+				className={cn("shrink-0 font-semibold text-destructive", className)}
+				{...props}
+			>
+				{children ?? trace.errorType}
+			</span>
+		);
+	},
+);
+
+export type StackTraceErrorMessageProps = ComponentProps<"span">;
+
+export const StackTraceErrorMessage = memo(
+	({ className, children, ...props }: StackTraceErrorMessageProps) => {
+		const { trace } = useStackTrace();
+
+		return (
+			<span className={cn("truncate text-foreground", className)} {...props}>
+				{children ?? trace.errorMessage}
+			</span>
+		);
+	},
+);
+
+export type StackTraceActionsProps = ComponentProps<"div">;
+
+const handleActionsClick = (e: React.MouseEvent) => e.stopPropagation();
+const handleActionsKeyDown = (e: React.KeyboardEvent) => {
+	if (e.key === "Enter" || e.key === " ") {
+		e.stopPropagation();
+	}
+};
+
+export const StackTraceActions = memo(
+	({ className, children, ...props }: StackTraceActionsProps) => (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			className={cn("flex shrink-0 items-center gap-1", className)}
+			onClick={handleActionsClick}
+			onKeyDown={handleActionsKeyDown}
+			role="group"
+			{...props}
+		>
+			{children}
+		</div>
+	),
+);
+
+export type StackTraceCopyButtonProps = ComponentProps<typeof Button> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const StackTraceCopyButton = memo(
+	({
+		onCopy,
+		onError,
+		timeout = 2000,
+		className,
+		children,
+		...props
+	}: StackTraceCopyButtonProps) => {
+		const [isCopied, setIsCopied] = useState(false);
+		const timeoutRef = useRef<number>(0);
+		const { raw } = useStackTrace();
+
+		const copyToClipboard = useCallback(async () => {
+			if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+				onError?.(new Error("Clipboard API not available"));
+				return;
+			}
+
+			try {
+				await navigator.clipboard.writeText(raw);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			} catch (error) {
+				onError?.(error as Error);
+			}
+		}, [raw, onCopy, onError, timeout]);
+
+		useEffect(
+			() => () => {
+				window.clearTimeout(timeoutRef.current);
+			},
+			[],
+		);
+
+		const Icon = isCopied ? CheckIcon : CopyIcon;
+
+		return (
+			<Button
+				className={cn("size-7", className)}
+				onClick={copyToClipboard}
+				size="icon"
+				variant="ghost"
+				{...props}
+			>
+				{children ?? <Icon size={14} />}
+			</Button>
+		);
+	},
+);
+
+export type StackTraceExpandButtonProps = ComponentProps<"div">;
+
+export const StackTraceExpandButton = memo(
+	({ className, ...props }: StackTraceExpandButtonProps) => {
+		const { isOpen } = useStackTrace();
+
+		return (
+			<div
+				className={cn("flex size-7 items-center justify-center", className)}
+				{...props}
+			>
+				<ChevronDownIcon
+					className={cn(
+						"size-4 text-muted-foreground transition-transform",
+						isOpen ? "rotate-180" : "rotate-0",
+					)}
+				/>
+			</div>
+		);
+	},
+);
+
+export type StackTraceContentProps = ComponentProps<
+	typeof CollapsibleContent
+> & {
+	maxHeight?: number;
+};
+
+export const StackTraceContent = memo(
+	({
+		className,
+		maxHeight = 400,
+		children,
+		...props
+	}: StackTraceContentProps) => {
+		const { isOpen } = useStackTrace();
+
+		return (
+			<Collapsible open={isOpen}>
+				<CollapsibleContent
+					className={cn(
+						"overflow-auto border-t bg-muted/30",
+						"data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:animate-out data-[state=open]:animate-in",
+						className,
+					)}
+					style={{ maxHeight }}
+					{...props}
+				>
+					{children}
+				</CollapsibleContent>
+			</Collapsible>
+		);
+	},
+);
+
+export type StackTraceFramesProps = ComponentProps<"div"> & {
+	showInternalFrames?: boolean;
+};
+
+interface FilePathButtonProps {
+	frame: StackFrame;
+	onFilePathClick?: (
+		filePath: string,
+		lineNumber?: number,
+		columnNumber?: number,
+	) => void;
+}
+
+const FilePathButton = memo(
+	({ frame, onFilePathClick }: FilePathButtonProps) => {
+		const handleClick = useCallback(() => {
+			if (frame.filePath) {
+				onFilePathClick?.(
+					frame.filePath,
+					frame.lineNumber ?? undefined,
+					frame.columnNumber ?? undefined,
+				);
+			}
+		}, [frame, onFilePathClick]);
+
+		return (
+			<button
+				className={cn(
+					"underline decoration-dotted hover:text-primary",
+					onFilePathClick && "cursor-pointer",
+				)}
+				disabled={!onFilePathClick}
+				onClick={handleClick}
+				type="button"
+			>
+				{frame.filePath}
+				{frame.lineNumber !== null && `:${frame.lineNumber}`}
+				{frame.columnNumber !== null && `:${frame.columnNumber}`}
+			</button>
+		);
+	},
+);
+
+FilePathButton.displayName = "FilePathButton";
+
+export const StackTraceFrames = memo(
+	({
+		className,
+		showInternalFrames = true,
+		...props
+	}: StackTraceFramesProps) => {
+		const { trace, onFilePathClick } = useStackTrace();
+
+		const framesToShow = showInternalFrames
+			? trace.frames
+			: trace.frames.filter((f) => !f.isInternal);
+
+		return (
+			<div className={cn("space-y-1 p-3", className)} {...props}>
+				{framesToShow.map((frame) => (
+					<div
+						className={cn(
+							"text-xs",
+							frame.isInternal
+								? "text-muted-foreground/50"
+								: "text-foreground/90",
+						)}
+						key={frame.raw}
+					>
+						<span className="text-muted-foreground">at </span>
+						{frame.functionName && (
+							<span className={frame.isInternal ? "" : "text-foreground"}>
+								{frame.functionName}{" "}
+							</span>
+						)}
+						{frame.filePath && (
+							<>
+								<span className="text-muted-foreground">(</span>
+								<FilePathButton
+									frame={frame}
+									onFilePathClick={onFilePathClick}
+								/>
+								<span className="text-muted-foreground">)</span>
+							</>
+						)}
+						{!(frame.filePath || frame.functionName) && (
+							<span>{frame.raw.replace(AT_PREFIX_REGEX, "")}</span>
+						)}
+					</div>
+				))}
+				{framesToShow.length === 0 && (
+					<div className="text-muted-foreground text-xs">No stack frames</div>
+				)}
+			</div>
+		);
+	},
+);
+
+StackTrace.displayName = "StackTrace";
+StackTraceHeader.displayName = "StackTraceHeader";
+StackTraceError.displayName = "StackTraceError";
+StackTraceErrorType.displayName = "StackTraceErrorType";
+StackTraceErrorMessage.displayName = "StackTraceErrorMessage";
+StackTraceActions.displayName = "StackTraceActions";
+StackTraceCopyButton.displayName = "StackTraceCopyButton";
+StackTraceExpandButton.displayName = "StackTraceExpandButton";
+StackTraceContent.displayName = "StackTraceContent";
+StackTraceFrames.displayName = "StackTraceFrames";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/status-badge.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/status-badge.tsx
new file mode 100644
index 0000000..e38514b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/status-badge.tsx
@@ -0,0 +1,28 @@
+import {
+	CheckCircleIcon,
+	CircleIcon,
+	ClockIcon,
+	XCircleIcon,
+} from "lucide-react";
+import type { ReactNode } from "react";
+import { Badge } from "@/components/ui/badge";
+
+import type { ToolPart } from "./tool";
+
+const statusIcons: Record<ToolPart["state"], ReactNode | null> = {
+	"approval-requested": <ClockIcon className="size-4 text-yellow-600" />,
+	"approval-responded": <CheckCircleIcon className="size-4 text-blue-600" />,
+	"input-available": <ClockIcon className="size-4 animate-pulse" />,
+	"input-streaming": <CircleIcon className="size-4" />,
+	"output-available": <CheckCircleIcon className="size-4 text-green-600" />,
+	"output-denied": <XCircleIcon className="size-4 text-orange-600" />,
+	"output-error": <XCircleIcon className="size-4 text-red-600" />,
+};
+
+export function getStatusBadge(status: ToolPart["state"]) {
+	return (
+		<Badge className="gap-1.5 text-xs" variant="secondary">
+			{statusIcons[status]}
+		</Badge>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/streamdown.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/streamdown.tsx
new file mode 100644
index 0000000..d46524e
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/streamdown.tsx
@@ -0,0 +1,170 @@
+import { cjk } from "@streamdown/cjk";
+import type { MermaidConfig } from "mermaid";
+import type { ComponentProps, ReactNode } from "react";
+import { isValidElement, memo } from "react";
+import {
+	type Components,
+	type DiagramPlugin,
+	Streamdown,
+	type StreamdownProps,
+} from "streamdown";
+import {
+	CodeBlock,
+	CodeBlockActions,
+	CodeBlockCopyButton,
+	CodeBlockFilename,
+	CodeBlockHeader,
+	CodeBlockTitle,
+} from "@/components/ai-elements/code-block";
+import { cn } from "@/lib/utils";
+
+type MarkdownCodeProps = ComponentProps<"code"> & {
+	"data-block"?: boolean | string;
+	node?: {
+		properties?: {
+			metastring?: string;
+		};
+	};
+};
+
+const LANGUAGE_CLASS_PATTERN = /(?:^|\s)language-([^\s]+)/;
+const START_LINE_PATTERN = /startLine=(\d+)/;
+const NO_LINE_NUMBERS_PATTERN = /\bnoLineNumbers\b/;
+
+function codeText(children: ReactNode): string {
+	if (typeof children === "string" || typeof children === "number") {
+		return String(children);
+	}
+	if (Array.isArray(children)) {
+		return children.map(codeText).join("");
+	}
+	if (isValidElement<{ children?: ReactNode }>(children)) {
+		return codeText(children.props.children);
+	}
+	return "";
+}
+
+const MarkdownCode = ({
+	children,
+	className,
+	node,
+	"data-block": dataBlock,
+	...props
+}: MarkdownCodeProps) => {
+	const language = className?.match(LANGUAGE_CLASS_PATTERN)?.[1] ?? "text";
+
+	if (!dataBlock) {
+		return (
+			<code
+				className={cn(
+					"rounded bg-muted px-1.5 py-0.5 font-mono text-sm",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</code>
+		);
+	}
+
+	const meta = node?.properties?.metastring;
+	const startLineMatch = meta?.match(START_LINE_PATTERN);
+	const startLine = startLineMatch ? Number.parseInt(startLineMatch[1], 10) : 1;
+	const showLineNumbers = meta ? !NO_LINE_NUMBERS_PATTERN.test(meta) : true;
+
+	return (
+		<CodeBlock
+			code={codeText(children)}
+			data-start-line={startLine > 1 ? startLine : undefined}
+			language={language}
+			showLineNumbers={showLineNumbers}
+		>
+			<CodeBlockHeader>
+				<CodeBlockTitle>
+					<CodeBlockFilename>{language}</CodeBlockFilename>
+				</CodeBlockTitle>
+				<CodeBlockActions>
+					<CodeBlockCopyButton />
+				</CodeBlockActions>
+			</CodeBlockHeader>
+		</CodeBlock>
+	);
+};
+
+const markdownComponents = {
+	code: MarkdownCode,
+} satisfies Components;
+
+const DEFAULT_MERMAID_CONFIG = {
+	fontFamily: "monospace",
+	securityLevel: "strict",
+	startOnLoad: false,
+	suppressErrorRendering: true,
+	theme: "default",
+} satisfies MermaidConfig;
+
+interface LazyMermaidInstance {
+	initialize: (config: MermaidConfig) => void;
+	render: (
+		id: string,
+		source: string,
+	) => Promise<{
+		svg: string;
+	}>;
+}
+
+function createLazyMermaidPlugin(): DiagramPlugin {
+	let config: MermaidConfig = DEFAULT_MERMAID_CONFIG;
+	let initialized = false;
+
+	const instance: LazyMermaidInstance = {
+		initialize(nextConfig: MermaidConfig) {
+			config = { ...DEFAULT_MERMAID_CONFIG, ...config, ...nextConfig };
+			initialized = false;
+		},
+		async render(id: string, source: string) {
+			const mermaidModule = await import("mermaid");
+			const mermaid = mermaidModule.default;
+			if (!initialized) {
+				mermaid.initialize(config);
+				initialized = true;
+			}
+			return mermaid.render(id, source);
+		},
+	};
+
+	return {
+		getMermaid(nextConfig?: MermaidConfig) {
+			if (nextConfig) {
+				instance.initialize(nextConfig);
+			}
+			return instance;
+		},
+		language: "mermaid",
+		name: "mermaid",
+		type: "diagram",
+	};
+}
+
+const streamdownPlugins = { cjk, mermaid: createLazyMermaidPlugin() };
+
+export type HubStreamdownProps = StreamdownProps;
+
+export const HubStreamdown = memo(
+	({ className, components, ...props }: HubStreamdownProps) => {
+		const mergedComponents = components
+			? { ...markdownComponents, ...components }
+			: markdownComponents;
+
+		return (
+			<Streamdown
+				className={className}
+				components={mergedComponents}
+				plugins={streamdownPlugins}
+				{...props}
+			/>
+		);
+	},
+);
+
+HubStreamdown.displayName = "HubStreamdown";
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/suggestion.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/suggestion.tsx
new file mode 100644
index 0000000..2180a9a
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/suggestion.tsx
@@ -0,0 +1,54 @@
+"use client";
+
+import type { ComponentProps } from "react";
+import { useCallback } from "react";
+import { Button } from "@/components/ui/button";
+import { ScrollArea, ScrollBar } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+export type SuggestionsProps = ComponentProps<typeof ScrollArea>;
+
+export const Suggestions = ({
+	className,
+	children,
+	...props
+}: SuggestionsProps) => (
+	<ScrollArea className="w-full overflow-x-auto whitespace-nowrap" {...props}>
+		<div className={cn("flex w-max flex-nowrap items-center gap-2", className)}>
+			{children}
+		</div>
+		<ScrollBar className="hidden" orientation="horizontal" />
+	</ScrollArea>
+);
+
+export type SuggestionProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+	suggestion: string;
+	onClick?: (suggestion: string) => void;
+};
+
+export const Suggestion = ({
+	suggestion,
+	onClick,
+	className,
+	variant = "outline",
+	size = "sm",
+	children,
+	...props
+}: SuggestionProps) => {
+	const handleClick = useCallback(() => {
+		onClick?.(suggestion);
+	}, [onClick, suggestion]);
+
+	return (
+		<Button
+			className={cn("cursor-pointer rounded-full px-4", className)}
+			onClick={handleClick}
+			size={size}
+			type="button"
+			variant={variant}
+			{...props}
+		>
+			{children || suggestion}
+		</Button>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/task.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/task.tsx
new file mode 100644
index 0000000..5299590
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/task.tsx
@@ -0,0 +1,87 @@
+"use client";
+
+import { ChevronDownIcon, SearchIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+export type TaskItemFileProps = ComponentProps<"div">;
+
+export const TaskItemFile = ({
+	children,
+	className,
+	...props
+}: TaskItemFileProps) => (
+	<div
+		className={cn(
+			"inline-flex items-center gap-1 rounded-md border bg-secondary px-1.5 py-0.5 text-foreground text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TaskItemProps = ComponentProps<"div">;
+
+export const TaskItem = ({ children, className, ...props }: TaskItemProps) => (
+	<div className={cn("text-muted-foreground text-sm", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type TaskProps = ComponentProps<typeof Collapsible>;
+
+export const Task = ({
+	defaultOpen = true,
+	className,
+	...props
+}: TaskProps) => (
+	<Collapsible className={cn(className)} defaultOpen={defaultOpen} {...props} />
+);
+
+export type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+	title: string;
+};
+
+export const TaskTrigger = ({
+	children,
+	className,
+	title,
+	...props
+}: TaskTriggerProps) => (
+	<CollapsibleTrigger className={cn("group", className)} {...props}>
+		{children ?? (
+			<div className="flex w-full cursor-pointer items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground">
+				<SearchIcon className="size-4" />
+				<p className="text-sm">{title}</p>
+				<ChevronDownIcon className="size-4 transition-transform group-data-[state=open]:rotate-180" />
+			</div>
+		)}
+	</CollapsibleTrigger>
+);
+
+export type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const TaskContent = ({
+	children,
+	className,
+	...props
+}: TaskContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+			className,
+		)}
+		{...props}
+	>
+		<div className="mt-4 space-y-2 border-muted border-l-2 pl-4">
+			{children}
+		</div>
+	</CollapsibleContent>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/terminal.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/terminal.tsx
new file mode 100644
index 0000000..7516e79
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/terminal.tsx
@@ -0,0 +1,273 @@
+"use client";
+
+import Ansi from "ansi-to-react";
+import { CheckIcon, CopyIcon, TerminalIcon, Trash2Icon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+interface TerminalContextType {
+	output: string;
+	isStreaming: boolean;
+	autoScroll: boolean;
+	onClear?: () => void;
+}
+
+const TerminalContext = createContext<TerminalContextType>({
+	autoScroll: true,
+	isStreaming: false,
+	output: "",
+});
+
+export type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalHeader = ({
+	className,
+	children,
+	...props
+}: TerminalHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-zinc-800 border-b px-4 py-2",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalTitle = ({
+	className,
+	children,
+	...props
+}: TerminalTitleProps) => (
+	<div
+		className={cn("flex items-center gap-2 text-sm text-zinc-400", className)}
+		{...props}
+	>
+		<TerminalIcon className="size-4" />
+		{children ?? "Terminal"}
+	</div>
+);
+
+export type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalStatus = ({
+	className,
+	children,
+	...props
+}: TerminalStatusProps) => {
+	const { isStreaming } = useContext(TerminalContext);
+
+	if (!isStreaming) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn("flex items-center gap-2 text-xs text-zinc-400", className)}
+			{...props}
+		>
+			{children}
+		</div>
+	);
+};
+
+export type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalActions = ({
+	className,
+	children,
+	...props
+}: TerminalActionsProps) => (
+	<div className={cn("flex items-center gap-1", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const TerminalCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: TerminalCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { output } = useContext(TerminalContext);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			await navigator.clipboard.writeText(output);
+			setIsCopied(true);
+			onCopy?.();
+			timeoutRef.current = window.setTimeout(() => setIsCopied(false), timeout);
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [output, onCopy, onError, timeout]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn(
+				"size-7 shrink-0 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100",
+				className,
+			)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={14} />}
+		</Button>
+	);
+};
+
+export type TerminalClearButtonProps = ComponentProps<typeof Button>;
+
+export const TerminalClearButton = ({
+	children,
+	className,
+	...props
+}: TerminalClearButtonProps) => {
+	const { onClear } = useContext(TerminalContext);
+
+	if (!onClear) {
+		return null;
+	}
+
+	return (
+		<Button
+			className={cn(
+				"size-7 shrink-0 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100",
+				className,
+			)}
+			onClick={onClear}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Trash2Icon size={14} />}
+		</Button>
+	);
+};
+
+export type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalContent = ({
+	className,
+	children,
+	...props
+}: TerminalContentProps) => {
+	const { output, isStreaming, autoScroll } = useContext(TerminalContext);
+	const containerRef = useRef<HTMLDivElement>(null);
+
+	useEffect(() => {
+		if (autoScroll && containerRef.current) {
+			containerRef.current.scrollTop = containerRef.current.scrollHeight;
+		}
+	}, [autoScroll]);
+
+	return (
+		<div
+			className={cn(
+				"max-h-96 overflow-auto p-4 font-mono text-sm leading-relaxed",
+				className,
+			)}
+			ref={containerRef}
+			{...props}
+		>
+			{children ?? (
+				<pre className="whitespace-pre-wrap break-words">
+					<Ansi>{output}</Ansi>
+					{isStreaming && (
+						<span className="ml-0.5 inline-block h-4 w-2 animate-pulse bg-zinc-100" />
+					)}
+				</pre>
+			)}
+		</div>
+	);
+};
+
+export type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+	output: string;
+	isStreaming?: boolean;
+	autoScroll?: boolean;
+	onClear?: () => void;
+};
+
+export const Terminal = ({
+	output,
+	isStreaming = false,
+	autoScroll = true,
+	onClear,
+	className,
+	children,
+	...props
+}: TerminalProps) => {
+	const contextValue = useMemo(
+		() => ({ autoScroll, isStreaming, onClear, output }),
+		[autoScroll, isStreaming, onClear, output],
+	);
+
+	return (
+		<TerminalContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex flex-col overflow-hidden rounded-lg border bg-zinc-950 text-zinc-100",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<TerminalHeader>
+							<TerminalTitle />
+							<div className="flex items-center gap-1">
+								<TerminalStatus />
+								<TerminalActions>
+									<TerminalCopyButton />
+									{onClear && <TerminalClearButton />}
+								</TerminalActions>
+							</div>
+						</TerminalHeader>
+						<TerminalContent />
+					</>
+				)}
+			</div>
+		</TerminalContext.Provider>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/test-results.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/test-results.tsx
new file mode 100644
index 0000000..900e107
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/test-results.tsx
@@ -0,0 +1,496 @@
+"use client";
+
+import {
+	CheckCircle2Icon,
+	ChevronRightIcon,
+	CircleDotIcon,
+	CircleIcon,
+	XCircleIcon,
+} from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+type TestStatus = "passed" | "failed" | "skipped" | "running";
+
+interface TestResultsSummary {
+	passed: number;
+	failed: number;
+	skipped: number;
+	total: number;
+	duration?: number;
+}
+
+interface TestResultsContextType {
+	summary?: TestResultsSummary;
+}
+
+const TestResultsContext = createContext<TestResultsContextType>({});
+
+const formatDuration = (ms: number) => {
+	if (ms < 1000) {
+		return `${ms}ms`;
+	}
+	return `${(ms / 1000).toFixed(2)}s`;
+};
+
+export type TestResultsHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsHeader = ({
+	className,
+	children,
+	...props
+}: TestResultsHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b px-4 py-3",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TestResultsDurationProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestResultsDuration = ({
+	className,
+	children,
+	...props
+}: TestResultsDurationProps) => {
+	const { summary } = useContext(TestResultsContext);
+
+	if (!summary?.duration) {
+		return null;
+	}
+
+	return (
+		<span className={cn("text-muted-foreground text-sm", className)} {...props}>
+			{children ?? formatDuration(summary.duration)}
+		</span>
+	);
+};
+
+export type TestResultsSummaryProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsSummary = ({
+	className,
+	children,
+	...props
+}: TestResultsSummaryProps) => {
+	const { summary } = useContext(TestResultsContext);
+
+	if (!summary) {
+		return null;
+	}
+
+	return (
+		<div className={cn("flex items-center gap-3", className)} {...props}>
+			{children ?? (
+				<>
+					<Badge
+						className="gap-1 bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400"
+						variant="secondary"
+					>
+						<CheckCircle2Icon className="size-3" />
+						{summary.passed} passed
+					</Badge>
+					{summary.failed > 0 && (
+						<Badge
+							className="gap-1 bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400"
+							variant="secondary"
+						>
+							<XCircleIcon className="size-3" />
+							{summary.failed} failed
+						</Badge>
+					)}
+					{summary.skipped > 0 && (
+						<Badge
+							className="gap-1 bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400"
+							variant="secondary"
+						>
+							<CircleIcon className="size-3" />
+							{summary.skipped} skipped
+						</Badge>
+					)}
+				</>
+			)}
+		</div>
+	);
+};
+
+export type TestResultsProps = HTMLAttributes<HTMLDivElement> & {
+	summary?: TestResultsSummary;
+};
+
+export const TestResults = ({
+	summary,
+	className,
+	children,
+	...props
+}: TestResultsProps) => {
+	const contextValue = useMemo(() => ({ summary }), [summary]);
+
+	return (
+		<TestResultsContext.Provider value={contextValue}>
+			<div
+				className={cn("rounded-lg border bg-background", className)}
+				{...props}
+			>
+				{children ??
+					(summary && (
+						<TestResultsHeader>
+							<TestResultsSummary />
+							<TestResultsDuration />
+						</TestResultsHeader>
+					))}
+			</div>
+		</TestResultsContext.Provider>
+	);
+};
+
+export type TestResultsProgressProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsProgress = ({
+	className,
+	children,
+	...props
+}: TestResultsProgressProps) => {
+	const { summary } = useContext(TestResultsContext);
+
+	if (!summary) {
+		return null;
+	}
+
+	const passedPercent = (summary.passed / summary.total) * 100;
+	const failedPercent = (summary.failed / summary.total) * 100;
+
+	return (
+		<div className={cn("space-y-2", className)} {...props}>
+			{children ?? (
+				<>
+					<div className="flex h-2 overflow-hidden rounded-full bg-muted">
+						<div
+							className="bg-green-500 transition-all"
+							style={{ width: `${passedPercent}%` }}
+						/>
+						<div
+							className="bg-red-500 transition-all"
+							style={{ width: `${failedPercent}%` }}
+						/>
+					</div>
+					<div className="flex justify-between text-muted-foreground text-xs">
+						<span>
+							{summary.passed}/{summary.total} tests passed
+						</span>
+						<span>{passedPercent.toFixed(0)}%</span>
+					</div>
+				</>
+			)}
+		</div>
+	);
+};
+
+export type TestResultsContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsContent = ({
+	className,
+	children,
+	...props
+}: TestResultsContentProps) => (
+	<div className={cn("space-y-2 p-4", className)} {...props}>
+		{children}
+	</div>
+);
+
+interface TestSuiteContextType {
+	name: string;
+	status: TestStatus;
+}
+
+const TestSuiteContext = createContext<TestSuiteContextType>({
+	name: "",
+	status: "passed",
+});
+
+const statusStyles: Record<TestStatus, string> = {
+	failed: "text-red-600 dark:text-red-400",
+	passed: "text-green-600 dark:text-green-400",
+	running: "text-blue-600 dark:text-blue-400",
+	skipped: "text-yellow-600 dark:text-yellow-400",
+};
+
+const statusIcons: Record<TestStatus, React.ReactNode> = {
+	failed: <XCircleIcon className="size-4" />,
+	passed: <CheckCircle2Icon className="size-4" />,
+	running: <CircleDotIcon className="size-4 animate-pulse" />,
+	skipped: <CircleIcon className="size-4" />,
+};
+
+const TestStatusIcon = ({ status }: { status: TestStatus }) => (
+	<span className={cn("shrink-0", statusStyles[status])}>
+		{statusIcons[status]}
+	</span>
+);
+
+export type TestSuiteProps = ComponentProps<typeof Collapsible> & {
+	name: string;
+	status: TestStatus;
+};
+
+export const TestSuite = ({
+	name,
+	status,
+	className,
+	children,
+	...props
+}: TestSuiteProps) => {
+	const contextValue = useMemo(() => ({ name, status }), [name, status]);
+
+	return (
+		<TestSuiteContext.Provider value={contextValue}>
+			<Collapsible className={cn("rounded-lg border", className)} {...props}>
+				{children}
+			</Collapsible>
+		</TestSuiteContext.Provider>
+	);
+};
+
+export type TestSuiteNameProps = ComponentProps<typeof CollapsibleTrigger>;
+
+export const TestSuiteName = ({
+	className,
+	children,
+	...props
+}: TestSuiteNameProps) => {
+	const { name, status } = useContext(TestSuiteContext);
+
+	return (
+		<CollapsibleTrigger
+			className={cn(
+				"group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+			<TestStatusIcon status={status} />
+			<span className="font-medium text-sm">{children ?? name}</span>
+		</CollapsibleTrigger>
+	);
+};
+
+export type TestSuiteStatsProps = HTMLAttributes<HTMLDivElement> & {
+	passed?: number;
+	failed?: number;
+	skipped?: number;
+};
+
+export const TestSuiteStats = ({
+	passed = 0,
+	failed = 0,
+	skipped = 0,
+	className,
+	children,
+	...props
+}: TestSuiteStatsProps) => (
+	<div
+		className={cn("ml-auto flex items-center gap-2 text-xs", className)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				{passed > 0 && (
+					<span className="text-green-600 dark:text-green-400">
+						{passed} passed
+					</span>
+				)}
+				{failed > 0 && (
+					<span className="text-red-600 dark:text-red-400">
+						{failed} failed
+					</span>
+				)}
+				{skipped > 0 && (
+					<span className="text-yellow-600 dark:text-yellow-400">
+						{skipped} skipped
+					</span>
+				)}
+			</>
+		)}
+	</div>
+);
+
+export type TestSuiteContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const TestSuiteContent = ({
+	className,
+	children,
+	...props
+}: TestSuiteContentProps) => (
+	<CollapsibleContent className={cn("border-t", className)} {...props}>
+		<div className="divide-y">{children}</div>
+	</CollapsibleContent>
+);
+
+interface TestContextType {
+	name: string;
+	status: TestStatus;
+	duration?: number;
+}
+
+const TestContext = createContext<TestContextType>({
+	name: "",
+	status: "passed",
+});
+
+export type TestNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestName = ({ className, children, ...props }: TestNameProps) => {
+	const { name } = useContext(TestContext);
+
+	return (
+		<span className={cn("flex-1", className)} {...props}>
+			{children ?? name}
+		</span>
+	);
+};
+
+export type TestDurationProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestDuration = ({
+	className,
+	children,
+	...props
+}: TestDurationProps) => {
+	const { duration } = useContext(TestContext);
+
+	if (duration === undefined) {
+		return null;
+	}
+
+	return (
+		<span
+			className={cn("ml-auto text-muted-foreground text-xs", className)}
+			{...props}
+		>
+			{children ?? `${duration}ms`}
+		</span>
+	);
+};
+
+export type TestStatusProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestStatus = ({
+	className,
+	children,
+	...props
+}: TestStatusProps) => {
+	const { status } = useContext(TestContext);
+
+	return (
+		<span
+			className={cn("shrink-0", statusStyles[status], className)}
+			{...props}
+		>
+			{children ?? statusIcons[status]}
+		</span>
+	);
+};
+
+export type TestProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	status: TestStatus;
+	duration?: number;
+};
+
+export const Test = ({
+	name,
+	status,
+	duration,
+	className,
+	children,
+	...props
+}: TestProps) => {
+	const contextValue = useMemo(
+		() => ({ duration, name, status }),
+		[duration, name, status],
+	);
+
+	return (
+		<TestContext.Provider value={contextValue}>
+			<div
+				className={cn("flex items-center gap-2 px-4 py-2 text-sm", className)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<TestStatus />
+						<TestName />
+						{duration !== undefined && <TestDuration />}
+					</>
+				)}
+			</div>
+		</TestContext.Provider>
+	);
+};
+
+export type TestErrorProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestError = ({
+	className,
+	children,
+	...props
+}: TestErrorProps) => (
+	<div
+		className={cn(
+			"mt-2 rounded-md bg-red-50 p-3 dark:bg-red-900/20",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TestErrorMessageProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const TestErrorMessage = ({
+	className,
+	children,
+	...props
+}: TestErrorMessageProps) => (
+	<p
+		className={cn(
+			"font-medium text-red-700 text-sm dark:text-red-400",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</p>
+);
+
+export type TestErrorStackProps = HTMLAttributes<HTMLPreElement>;
+
+export const TestErrorStack = ({
+	className,
+	children,
+	...props
+}: TestErrorStackProps) => (
+	<pre
+		className={cn(
+			"mt-2 overflow-auto font-mono text-red-600 text-xs dark:text-red-400",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</pre>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/tool.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/tool.tsx
new file mode 100644
index 0000000..b9d04eb
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/tool.tsx
@@ -0,0 +1,159 @@
+import type { DynamicToolUIPart, ToolUIPart } from "ai";
+import {
+	FileCodeIcon,
+	MessagesSquareIcon,
+	PencilIcon,
+	TerminalIcon,
+	WrenchIcon,
+} from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { isValidElement } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+import { CodeBlock } from "./code-block";
+import { getStatusBadge } from "./status-badge";
+
+export type ToolProps = ComponentProps<typeof Collapsible>;
+
+export const Tool = ({ className, ...props }: ToolProps) => (
+	<Collapsible
+		className={cn("group not-prose mb-4 w-full rounded-sm border", className)}
+		{...props}
+	/>
+);
+
+export type ToolPart = ToolUIPart | DynamicToolUIPart;
+
+export type ToolHeaderProps = {
+	title?: string;
+	className?: string;
+} & (
+	| { type: ToolUIPart["type"]; state: ToolUIPart["state"]; toolName?: never }
+	| {
+			type: DynamicToolUIPart["type"];
+			state: DynamicToolUIPart["state"];
+			toolName: string;
+	  }
+);
+
+const toolIcons: Record<string, ReactNode> = {
+	run_commands: <TerminalIcon className="size-4" />,
+	read_files: <FileCodeIcon className="size-4" />,
+	editor: <PencilIcon className="size-4" />,
+	ask_question: <MessagesSquareIcon className="size-4" />,
+};
+
+const getToolBadge = (toolName: string) => {
+	return (
+		<Badge className="text-xs" variant="ghost">
+			{(toolName && toolIcons[toolName]) || <WrenchIcon className="size-4" />}
+		</Badge>
+	);
+};
+
+export const ToolHeader = ({
+	className,
+	title,
+	type,
+	state,
+	toolName,
+	...props
+}: ToolHeaderProps) => {
+	const toolNameParts = title?.split(":");
+	const _toolName = toolNameParts?.[0] || toolName;
+	const toolInput = toolNameParts?.[1];
+	const derivedName = _toolName || title || type.split("-").slice(1).join("-");
+
+	return (
+		<CollapsibleTrigger
+			className={cn(
+				"flex w-full overflow-hidden items-center justify-between gap-4 p-3 cursor-pointer",
+				className,
+			)}
+			{...props}
+		>
+			<div className="flex items-center gap-2 shrink-0">
+				{getToolBadge(derivedName)}
+				<span className="font-light text-muted-foreground text-sm truncated wrap-break-word ellipses">
+					{toolInput}
+				</span>
+				{getStatusBadge(state)}
+			</div>
+		</CollapsibleTrigger>
+	);
+};
+
+export type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const ToolContent = ({ className, ...props }: ToolContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 space-y-4 p-1 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in overflow-hidden font-mono",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ToolInputProps = ComponentProps<"div"> & {
+	input: ToolPart["input"];
+};
+
+export const ToolInput = ({ className, input, ...props }: ToolInputProps) => (
+	<div className={cn("space-y-2 overflow-hidden", className)} {...props}>
+		<h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
+			Parameters
+		</h4>
+		<div className="rounded-md bg-muted/50">
+			<CodeBlock code={JSON.stringify(input, null, 2)} language="json" />
+		</div>
+	</div>
+);
+
+export type ToolOutputProps = ComponentProps<"div"> & {
+	output: ToolPart["output"];
+	errorText: ToolPart["errorText"];
+};
+
+export const ToolOutput = ({
+	className,
+	output,
+	errorText,
+	...props
+}: ToolOutputProps) => {
+	if (!(output || errorText)) {
+		return null;
+	}
+
+	let Output = <div>{output as ReactNode}</div>;
+
+	if (typeof output === "object" && !isValidElement(output)) {
+		Output = (
+			<CodeBlock code={JSON.stringify(output, null, 2)} language="json" />
+		);
+	} else if (typeof output === "string") {
+		Output = <CodeBlock code={output} language="json" />;
+	}
+
+	return (
+		<div className={cn("space-y-2", className)} {...props}>
+			<div
+				className={cn(
+					"overflow-auto rounded-md text-xs [&_table]:w-full max-h-20",
+					errorText
+						? "bg-destructive/10 text-destructive"
+						: "bg-muted/50 text-foreground",
+				)}
+			>
+				{errorText && <div>{errorText}</div>}
+				{Output}
+			</div>
+		</div>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/toolbar.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/toolbar.tsx
new file mode 100644
index 0000000..8e0dcb2
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/toolbar.tsx
@@ -0,0 +1,16 @@
+import { NodeToolbar, Position } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+type ToolbarProps = ComponentProps<typeof NodeToolbar>;
+
+export const Toolbar = ({ className, ...props }: ToolbarProps) => (
+	<NodeToolbar
+		className={cn(
+			"flex items-center gap-1 rounded-sm border bg-background p-1.5",
+			className,
+		)}
+		position={Position.Bottom}
+		{...props}
+	/>
+);
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/transcription.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/transcription.tsx
new file mode 100644
index 0000000..de586c0
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/transcription.tsx
@@ -0,0 +1,125 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import type { Experimental_TranscriptionResult as TranscriptionResult } from "ai";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { cn } from "@/lib/utils";
+
+type TranscriptionSegment = TranscriptionResult["segments"][number];
+
+interface TranscriptionContextValue {
+	segments: TranscriptionSegment[];
+	currentTime: number;
+	onTimeUpdate: (time: number) => void;
+	onSeek?: (time: number) => void;
+}
+
+const TranscriptionContext = createContext<TranscriptionContextValue | null>(
+	null,
+);
+
+const useTranscription = () => {
+	const context = useContext(TranscriptionContext);
+	if (!context) {
+		throw new Error(
+			"Transcription components must be used within Transcription",
+		);
+	}
+	return context;
+};
+
+export type TranscriptionProps = Omit<ComponentProps<"div">, "children"> & {
+	segments: TranscriptionSegment[];
+	currentTime?: number;
+	onSeek?: (time: number) => void;
+	children: (segment: TranscriptionSegment, index: number) => ReactNode;
+};
+
+export const Transcription = ({
+	segments,
+	currentTime: externalCurrentTime,
+	onSeek,
+	className,
+	children,
+	...props
+}: TranscriptionProps) => {
+	const [currentTime, setCurrentTime] = useControllableState({
+		defaultProp: 0,
+		onChange: onSeek,
+		prop: externalCurrentTime,
+	});
+
+	const contextValue = useMemo(
+		() => ({ currentTime, onSeek, onTimeUpdate: setCurrentTime, segments }),
+		[currentTime, onSeek, setCurrentTime, segments],
+	);
+
+	return (
+		<TranscriptionContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex flex-wrap gap-1 text-sm leading-relaxed",
+					className,
+				)}
+				data-slot="transcription"
+				{...props}
+			>
+				{segments
+					.filter((segment) => segment.text.trim())
+					.map((segment, index) => children(segment, index))}
+			</div>
+		</TranscriptionContext.Provider>
+	);
+};
+
+export type TranscriptionSegmentProps = ComponentProps<"button"> & {
+	segment: TranscriptionSegment;
+	index: number;
+};
+
+export const TranscriptionSegment = ({
+	segment,
+	index,
+	className,
+	onClick,
+	...props
+}: TranscriptionSegmentProps) => {
+	const { currentTime, onSeek } = useTranscription();
+
+	const isActive =
+		currentTime >= segment.startSecond && currentTime < segment.endSecond;
+	const isPast = currentTime >= segment.endSecond;
+
+	const handleClick = useCallback(
+		(event: React.MouseEvent<HTMLButtonElement>) => {
+			if (onSeek) {
+				onSeek(segment.startSecond);
+			}
+			onClick?.(event);
+		},
+		[onSeek, segment.startSecond, onClick],
+	);
+
+	return (
+		<button
+			className={cn(
+				"inline text-left",
+				isActive && "text-primary",
+				isPast && "text-muted-foreground",
+				!(isActive || isPast) && "text-muted-foreground/60",
+				onSeek && "cursor-pointer hover:text-foreground",
+				!onSeek && "cursor-default",
+				className,
+			)}
+			data-active={isActive}
+			data-index={index}
+			data-slot="transcription-segment"
+			onClick={handleClick}
+			type="button"
+			{...props}
+		>
+			{segment.text}
+		</button>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/voice-selector.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/voice-selector.tsx
new file mode 100644
index 0000000..d89d4fe
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/voice-selector.tsx
@@ -0,0 +1,533 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import {
+	CircleSmallIcon,
+	MarsIcon,
+	MarsStrokeIcon,
+	NonBinaryIcon,
+	PauseIcon,
+	PlayIcon,
+	TransgenderIcon,
+	VenusAndMarsIcon,
+	VenusIcon,
+} from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Command,
+	CommandDialog,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+	CommandSeparator,
+	CommandShortcut,
+} from "@/components/ui/command";
+import {
+	Dialog,
+	DialogContent,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { Spinner } from "@/components/ui/spinner";
+import { cn } from "@/lib/utils";
+
+interface VoiceSelectorContextValue {
+	value: string | undefined;
+	setValue: (value: string | undefined) => void;
+	open: boolean;
+	setOpen: (open: boolean) => void;
+}
+
+const VoiceSelectorContext = createContext<VoiceSelectorContextValue | null>(
+	null,
+);
+
+export const useVoiceSelector = () => {
+	const context = useContext(VoiceSelectorContext);
+	if (!context) {
+		throw new Error(
+			"VoiceSelector components must be used within VoiceSelector",
+		);
+	}
+	return context;
+};
+
+export type VoiceSelectorProps = ComponentProps<typeof Dialog> & {
+	value?: string;
+	defaultValue?: string;
+	onValueChange?: (value: string | undefined) => void;
+};
+
+export const VoiceSelector = ({
+	value: valueProp,
+	defaultValue,
+	onValueChange,
+	open: openProp,
+	defaultOpen = false,
+	onOpenChange,
+	children,
+	...props
+}: VoiceSelectorProps) => {
+	const [value, setValue] = useControllableState({
+		defaultProp: defaultValue,
+		onChange: onValueChange,
+		prop: valueProp,
+	});
+
+	const [open, setOpen] = useControllableState({
+		defaultProp: defaultOpen,
+		prop: openProp,
+	});
+
+	const handleOpenChange = useCallback<
+		NonNullable<ComponentProps<typeof Dialog>["onOpenChange"]>
+	>(
+		(nextOpen, eventDetails) => {
+			setOpen(nextOpen);
+			onOpenChange?.(nextOpen, eventDetails);
+		},
+		[onOpenChange, setOpen],
+	);
+
+	const voiceSelectorContext = useMemo(
+		() => ({ open, setOpen, setValue, value }),
+		[value, setValue, open, setOpen],
+	);
+
+	return (
+		<VoiceSelectorContext.Provider value={voiceSelectorContext}>
+			<Dialog onOpenChange={handleOpenChange} open={open} {...props}>
+				{children}
+			</Dialog>
+		</VoiceSelectorContext.Provider>
+	);
+};
+
+export type VoiceSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+
+export const VoiceSelectorTrigger = (props: VoiceSelectorTriggerProps) => (
+	<DialogTrigger {...props} />
+);
+
+export type VoiceSelectorContentProps = ComponentProps<typeof DialogContent> & {
+	title?: ReactNode;
+};
+
+export const VoiceSelectorContent = ({
+	className,
+	children,
+	title = "Voice Selector",
+	...props
+}: VoiceSelectorContentProps) => (
+	<DialogContent
+		aria-describedby={undefined}
+		className={cn("p-0", className)}
+		{...props}
+	>
+		<DialogTitle className="sr-only">{title}</DialogTitle>
+		<Command className="**:data-[slot=command-input-wrapper]:h-auto">
+			{children}
+		</Command>
+	</DialogContent>
+);
+
+export type VoiceSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+
+export const VoiceSelectorDialog = (props: VoiceSelectorDialogProps) => (
+	<CommandDialog {...props} />
+);
+
+export type VoiceSelectorInputProps = ComponentProps<typeof CommandInput>;
+
+export const VoiceSelectorInput = ({
+	className,
+	...props
+}: VoiceSelectorInputProps) => (
+	<CommandInput className={cn("h-auto py-3.5", className)} {...props} />
+);
+
+export type VoiceSelectorListProps = ComponentProps<typeof CommandList>;
+
+export const VoiceSelectorList = (props: VoiceSelectorListProps) => (
+	<CommandList {...props} />
+);
+
+export type VoiceSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const VoiceSelectorEmpty = (props: VoiceSelectorEmptyProps) => (
+	<CommandEmpty {...props} />
+);
+
+export type VoiceSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+
+export const VoiceSelectorGroup = (props: VoiceSelectorGroupProps) => (
+	<CommandGroup {...props} />
+);
+
+export type VoiceSelectorItemProps = ComponentProps<typeof CommandItem>;
+
+export const VoiceSelectorItem = ({
+	className,
+	...props
+}: VoiceSelectorItemProps) => (
+	<CommandItem className={cn("px-4 py-2", className)} {...props} />
+);
+
+export type VoiceSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+
+export const VoiceSelectorShortcut = (props: VoiceSelectorShortcutProps) => (
+	<CommandShortcut {...props} />
+);
+
+export type VoiceSelectorSeparatorProps = ComponentProps<
+	typeof CommandSeparator
+>;
+
+export const VoiceSelectorSeparator = (props: VoiceSelectorSeparatorProps) => (
+	<CommandSeparator {...props} />
+);
+
+export type VoiceSelectorGenderProps = ComponentProps<"span"> & {
+	value?:
+		| "male"
+		| "female"
+		| "transgender"
+		| "androgyne"
+		| "non-binary"
+		| "intersex";
+};
+
+export const VoiceSelectorGender = ({
+	className,
+	value,
+	children,
+	...props
+}: VoiceSelectorGenderProps) => {
+	let icon: ReactNode | null = null;
+
+	switch (value) {
+		case "male": {
+			icon = <MarsIcon className="size-4" />;
+			break;
+		}
+		case "female": {
+			icon = <VenusIcon className="size-4" />;
+			break;
+		}
+		case "transgender": {
+			icon = <TransgenderIcon className="size-4" />;
+			break;
+		}
+		case "androgyne": {
+			icon = <MarsStrokeIcon className="size-4" />;
+			break;
+		}
+		case "non-binary": {
+			icon = <NonBinaryIcon className="size-4" />;
+			break;
+		}
+		case "intersex": {
+			icon = <VenusAndMarsIcon className="size-4" />;
+			break;
+		}
+		default: {
+			icon = <CircleSmallIcon className="size-4" />;
+		}
+	}
+
+	return (
+		<span className={cn("text-muted-foreground text-xs", className)} {...props}>
+			{children ?? icon}
+		</span>
+	);
+};
+
+export type VoiceSelectorAccentProps = ComponentProps<"span"> & {
+	value?:
+		| "american"
+		| "british"
+		| "australian"
+		| "canadian"
+		| "irish"
+		| "scottish"
+		| "indian"
+		| "south-african"
+		| "new-zealand"
+		| "spanish"
+		| "french"
+		| "german"
+		| "italian"
+		| "portuguese"
+		| "brazilian"
+		| "mexican"
+		| "argentinian"
+		| "japanese"
+		| "chinese"
+		| "korean"
+		| "russian"
+		| "arabic"
+		| "dutch"
+		| "swedish"
+		| "norwegian"
+		| "danish"
+		| "finnish"
+		| "polish"
+		| "turkish"
+		| "greek"
+		| string;
+};
+
+export const VoiceSelectorAccent = ({
+	className,
+	value,
+	children,
+	...props
+}: VoiceSelectorAccentProps) => {
+	let emoji: string | null = null;
+
+	switch (value) {
+		case "american": {
+			emoji = "🇺🇸";
+			break;
+		}
+		case "british": {
+			emoji = "🇬🇧";
+			break;
+		}
+		case "australian": {
+			emoji = "🇦🇺";
+			break;
+		}
+		case "canadian": {
+			emoji = "🇨🇦";
+			break;
+		}
+		case "irish": {
+			emoji = "🇮🇪";
+			break;
+		}
+		case "scottish": {
+			emoji = "🏴󠁧󠁢󠁳󠁣󠁴󠁿";
+			break;
+		}
+		case "indian": {
+			emoji = "🇮🇳";
+			break;
+		}
+		case "south-african": {
+			emoji = "🇿🇦";
+			break;
+		}
+		case "new-zealand": {
+			emoji = "🇳🇿";
+			break;
+		}
+		case "spanish": {
+			emoji = "🇪🇸";
+			break;
+		}
+		case "french": {
+			emoji = "🇫🇷";
+			break;
+		}
+		case "german": {
+			emoji = "🇩🇪";
+			break;
+		}
+		case "italian": {
+			emoji = "🇮🇹";
+			break;
+		}
+		case "portuguese": {
+			emoji = "🇵🇹";
+			break;
+		}
+		case "brazilian": {
+			emoji = "🇧🇷";
+			break;
+		}
+		case "mexican": {
+			emoji = "🇲🇽";
+			break;
+		}
+		case "argentinian": {
+			emoji = "🇦🇷";
+			break;
+		}
+		case "japanese": {
+			emoji = "🇯🇵";
+			break;
+		}
+		case "chinese": {
+			emoji = "🇨🇳";
+			break;
+		}
+		case "korean": {
+			emoji = "🇰🇷";
+			break;
+		}
+		case "russian": {
+			emoji = "🇷🇺";
+			break;
+		}
+		case "arabic": {
+			emoji = "🇸🇦";
+			break;
+		}
+		case "dutch": {
+			emoji = "🇳🇱";
+			break;
+		}
+		case "swedish": {
+			emoji = "🇸🇪";
+			break;
+		}
+		case "norwegian": {
+			emoji = "🇳🇴";
+			break;
+		}
+		case "danish": {
+			emoji = "🇩🇰";
+			break;
+		}
+		case "finnish": {
+			emoji = "🇫🇮";
+			break;
+		}
+		case "polish": {
+			emoji = "🇵🇱";
+			break;
+		}
+		case "turkish": {
+			emoji = "🇹🇷";
+			break;
+		}
+		case "greek": {
+			emoji = "🇬🇷";
+			break;
+		}
+		default: {
+			emoji = null;
+		}
+	}
+
+	return (
+		<span className={cn("text-muted-foreground text-xs", className)} {...props}>
+			{children ?? emoji}
+		</span>
+	);
+};
+
+export type VoiceSelectorAgeProps = ComponentProps<"span">;
+
+export const VoiceSelectorAge = ({
+	className,
+	...props
+}: VoiceSelectorAgeProps) => (
+	<span
+		className={cn("text-muted-foreground text-xs tabular-nums", className)}
+		{...props}
+	/>
+);
+
+export type VoiceSelectorNameProps = ComponentProps<"span">;
+
+export const VoiceSelectorName = ({
+	className,
+	...props
+}: VoiceSelectorNameProps) => (
+	<span
+		className={cn("flex-1 truncate text-left font-medium", className)}
+		{...props}
+	/>
+);
+
+export type VoiceSelectorDescriptionProps = ComponentProps<"span">;
+
+export const VoiceSelectorDescription = ({
+	className,
+	...props
+}: VoiceSelectorDescriptionProps) => (
+	<span className={cn("text-muted-foreground text-xs", className)} {...props} />
+);
+
+export type VoiceSelectorAttributesProps = ComponentProps<"div">;
+
+export const VoiceSelectorAttributes = ({
+	className,
+	children,
+	...props
+}: VoiceSelectorAttributesProps) => (
+	<div className={cn("flex items-center text-xs", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type VoiceSelectorBulletProps = ComponentProps<"span">;
+
+export const VoiceSelectorBullet = ({
+	className,
+	...props
+}: VoiceSelectorBulletProps) => (
+	<span
+		aria-hidden="true"
+		className={cn("select-none text-border", className)}
+		{...props}
+	>
+		&bull;
+	</span>
+);
+
+export type VoiceSelectorPreviewProps = Omit<
+	ComponentProps<"button">,
+	"children"
+> & {
+	playing?: boolean;
+	loading?: boolean;
+	onPlay?: () => void;
+};
+
+export const VoiceSelectorPreview = ({
+	className,
+	playing,
+	loading,
+	onPlay,
+	onClick,
+	...props
+}: VoiceSelectorPreviewProps) => {
+	const handleClick = useCallback(
+		(event: React.MouseEvent<HTMLButtonElement>) => {
+			event.stopPropagation();
+			onClick?.(event);
+			onPlay?.();
+		},
+		[onClick, onPlay],
+	);
+
+	let icon = <PlayIcon className="size-3" />;
+
+	if (loading) {
+		icon = <Spinner className="size-3" />;
+	} else if (playing) {
+		icon = <PauseIcon className="size-3" />;
+	}
+
+	return (
+		<Button
+			aria-label={playing ? "Pause preview" : "Play preview"}
+			className={cn("size-6", className)}
+			disabled={loading}
+			onClick={handleClick}
+			size="icon-sm"
+			type="button"
+			variant="outline"
+			{...props}
+		>
+			{icon}
+		</Button>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ai-elements/web-preview.tsx b/apps/cline-hub/src/webview/src/components/ai-elements/web-preview.tsx
new file mode 100644
index 0000000..fce2d60
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ai-elements/web-preview.tsx
@@ -0,0 +1,285 @@
+"use client";
+
+import { ChevronDownIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useMemo,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { Input } from "@/components/ui/input";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export interface WebPreviewContextValue {
+	url: string;
+	setUrl: (url: string) => void;
+	consoleOpen: boolean;
+	setConsoleOpen: (open: boolean) => void;
+}
+
+const WebPreviewContext = createContext<WebPreviewContextValue | null>(null);
+
+const useWebPreview = () => {
+	const context = useContext(WebPreviewContext);
+	if (!context) {
+		throw new Error("WebPreview components must be used within a WebPreview");
+	}
+	return context;
+};
+
+export type WebPreviewProps = ComponentProps<"div"> & {
+	defaultUrl?: string;
+	onUrlChange?: (url: string) => void;
+};
+
+export const WebPreview = ({
+	className,
+	children,
+	defaultUrl = "",
+	onUrlChange,
+	...props
+}: WebPreviewProps) => {
+	const [url, setUrl] = useState(defaultUrl);
+	const [consoleOpen, setConsoleOpen] = useState(false);
+
+	const handleUrlChange = useCallback(
+		(newUrl: string) => {
+			setUrl(newUrl);
+			onUrlChange?.(newUrl);
+		},
+		[onUrlChange],
+	);
+
+	const contextValue = useMemo<WebPreviewContextValue>(
+		() => ({
+			consoleOpen,
+			setConsoleOpen,
+			setUrl: handleUrlChange,
+			url,
+		}),
+		[consoleOpen, handleUrlChange, url],
+	);
+
+	return (
+		<WebPreviewContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex size-full flex-col rounded-lg border bg-card",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		</WebPreviewContext.Provider>
+	);
+};
+
+export type WebPreviewNavigationProps = ComponentProps<"div">;
+
+export const WebPreviewNavigation = ({
+	className,
+	children,
+	...props
+}: WebPreviewNavigationProps) => (
+	<div
+		className={cn("flex items-center gap-1 border-b p-2", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type WebPreviewNavigationButtonProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+};
+
+export const WebPreviewNavigationButton = ({
+	onClick,
+	disabled,
+	tooltip,
+	children,
+	...props
+}: WebPreviewNavigationButtonProps) => (
+	<TooltipProvider>
+		<Tooltip>
+			<TooltipTrigger
+				render={
+					<Button
+						className="h-8 w-8 p-0 hover:text-foreground"
+						disabled={disabled}
+						onClick={onClick}
+						size="sm"
+						variant="ghost"
+						{...props}
+					/>
+				}
+			>
+				{children}
+			</TooltipTrigger>
+			<TooltipContent>
+				<p>{tooltip}</p>
+			</TooltipContent>
+		</Tooltip>
+	</TooltipProvider>
+);
+
+export type WebPreviewUrlProps = ComponentProps<typeof Input>;
+
+export const WebPreviewUrl = ({
+	value,
+	onChange,
+	onKeyDown,
+	...props
+}: WebPreviewUrlProps) => {
+	const { url, setUrl } = useWebPreview();
+	const [prevUrl, setPrevUrl] = useState(url);
+	const [inputValue, setInputValue] = useState(url);
+
+	// Sync input value with context URL when it changes externally (derived state pattern)
+	if (url !== prevUrl) {
+		setPrevUrl(url);
+		setInputValue(url);
+	}
+
+	const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+		setInputValue(event.target.value);
+		onChange?.(event);
+	};
+
+	const handleKeyDown = useCallback(
+		(event: React.KeyboardEvent<HTMLInputElement>) => {
+			if (event.key === "Enter") {
+				const target = event.target as HTMLInputElement;
+				setUrl(target.value);
+			}
+			onKeyDown?.(event);
+		},
+		[setUrl, onKeyDown],
+	);
+
+	return (
+		<Input
+			className="h-8 flex-1 text-sm"
+			onChange={onChange ?? handleChange}
+			onKeyDown={handleKeyDown}
+			placeholder="Enter URL..."
+			value={value ?? inputValue}
+			{...props}
+		/>
+	);
+};
+
+export type WebPreviewBodyProps = ComponentProps<"iframe"> & {
+	loading?: ReactNode;
+};
+
+export const WebPreviewBody = ({
+	className,
+	loading,
+	src,
+	...props
+}: WebPreviewBodyProps) => {
+	const { url } = useWebPreview();
+
+	return (
+		<div className="flex-1">
+			<iframe
+				className={cn("size-full", className)}
+				// oxlint-disable-next-line eslint-plugin-react(iframe-missing-sandbox)
+				sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-presentation"
+				src={(src ?? url) || undefined}
+				title="Preview"
+				{...props}
+			/>
+			{loading}
+		</div>
+	);
+};
+
+export type WebPreviewConsoleProps = ComponentProps<"div"> & {
+	logs?: {
+		level: "log" | "warn" | "error";
+		message: string;
+		timestamp: Date;
+	}[];
+};
+
+export const WebPreviewConsole = ({
+	className,
+	logs = [],
+	children,
+	...props
+}: WebPreviewConsoleProps) => {
+	const { consoleOpen, setConsoleOpen } = useWebPreview();
+
+	return (
+		<Collapsible
+			className={cn("border-t bg-muted/50 font-mono text-sm", className)}
+			onOpenChange={setConsoleOpen}
+			open={consoleOpen}
+			{...props}
+		>
+			<CollapsibleTrigger
+				render={
+					<Button
+						className="flex w-full items-center justify-between p-4 text-left font-medium hover:bg-muted/50"
+						variant="ghost"
+					/>
+				}
+			>
+				Console
+				<ChevronDownIcon
+					className={cn(
+						"h-4 w-4 transition-transform duration-200",
+						consoleOpen && "rotate-180",
+					)}
+				/>
+			</CollapsibleTrigger>
+			<CollapsibleContent
+				className={cn(
+					"px-4 pb-4",
+					"data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+				)}
+			>
+				<div className="max-h-48 space-y-1 overflow-y-auto">
+					{logs.length === 0 ? (
+						<p className="text-muted-foreground">No console output</p>
+					) : (
+						logs.map((log) => (
+							<div
+								className={cn(
+									"text-xs",
+									log.level === "error" && "text-destructive",
+									log.level === "warn" && "text-yellow-600",
+									log.level === "log" && "text-foreground",
+								)}
+								key={`${log.timestamp.getTime()}-${log.level}-${log.message}`}
+							>
+								<span className="text-muted-foreground">
+									{log.timestamp.toLocaleTimeString()}
+								</span>{" "}
+								{log.message}
+							</div>
+						))
+					)}
+					{children}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/accordion.tsx b/apps/cline-hub/src/webview/src/components/ui/accordion.tsx
new file mode 100644
index 0000000..82bfb9c
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/accordion.tsx
@@ -0,0 +1,77 @@
+import { Accordion as AccordionPrimitive } from "@base-ui/react/accordion";
+import { ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+function Accordion({ className, ...props }: AccordionPrimitive.Root.Props) {
+	return (
+		<AccordionPrimitive.Root
+			data-slot="accordion"
+			className={cn("flex w-full flex-col", className)}
+			{...props}
+		/>
+	);
+}
+
+function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props) {
+	return (
+		<AccordionPrimitive.Item
+			data-slot="accordion-item"
+			className={cn("not-last:border-b", className)}
+			{...props}
+		/>
+	);
+}
+
+function AccordionTrigger({
+	className,
+	children,
+	...props
+}: AccordionPrimitive.Trigger.Props) {
+	return (
+		<AccordionPrimitive.Header className="flex">
+			<AccordionPrimitive.Trigger
+				data-slot="accordion-trigger"
+				className={cn(
+					"group/accordion-trigger relative flex flex-1 cursor-pointer items-start justify-between rounded-lg border border-transparent py-2.5 text-left text-sm font-medium transition-all outline-none hover:underline focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:after:border-ring aria-disabled:pointer-events-none aria-disabled:cursor-not-allowed aria-disabled:opacity-50 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 **:data-[slot=accordion-trigger-icon]:text-muted-foreground",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				<ChevronDownIcon
+					data-slot="accordion-trigger-icon"
+					className="pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden"
+				/>
+				<ChevronUpIcon
+					data-slot="accordion-trigger-icon"
+					className="pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline"
+				/>
+			</AccordionPrimitive.Trigger>
+		</AccordionPrimitive.Header>
+	);
+}
+
+function AccordionContent({
+	className,
+	children,
+	...props
+}: AccordionPrimitive.Panel.Props) {
+	return (
+		<AccordionPrimitive.Panel
+			data-slot="accordion-content"
+			className="overflow-hidden text-sm data-open:animate-accordion-down data-closed:animate-accordion-up"
+			{...props}
+		>
+			<div
+				className={cn(
+					"h-(--accordion-panel-height) pt-0 pb-2.5 data-ending-style:h-0 data-starting-style:h-0 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4",
+					className,
+				)}
+			>
+				{children}
+			</div>
+		</AccordionPrimitive.Panel>
+	);
+}
+
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };
diff --git a/apps/cline-hub/src/webview/src/components/ui/alert-dialog.tsx b/apps/cline-hub/src/webview/src/components/ui/alert-dialog.tsx
new file mode 100644
index 0000000..a92c287
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/alert-dialog.tsx
@@ -0,0 +1,186 @@
+"use client";
+
+import { AlertDialog as AlertDialogPrimitive } from "@base-ui/react/alert-dialog";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function AlertDialog({ ...props }: AlertDialogPrimitive.Root.Props) {
+	return <AlertDialogPrimitive.Root data-slot="alert-dialog" {...props} />;
+}
+
+function AlertDialogTrigger({ ...props }: AlertDialogPrimitive.Trigger.Props) {
+	return (
+		<AlertDialogPrimitive.Trigger data-slot="alert-dialog-trigger" {...props} />
+	);
+}
+
+function AlertDialogPortal({ ...props }: AlertDialogPrimitive.Portal.Props) {
+	return (
+		<AlertDialogPrimitive.Portal data-slot="alert-dialog-portal" {...props} />
+	);
+}
+
+function AlertDialogOverlay({
+	className,
+	...props
+}: AlertDialogPrimitive.Backdrop.Props) {
+	return (
+		<AlertDialogPrimitive.Backdrop
+			data-slot="alert-dialog-overlay"
+			className={cn(
+				"fixed inset-0 isolate z-50 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogContent({
+	className,
+	size = "default",
+	...props
+}: AlertDialogPrimitive.Popup.Props & {
+	size?: "default" | "sm";
+}) {
+	return (
+		<AlertDialogPortal>
+			<AlertDialogOverlay />
+			<AlertDialogPrimitive.Popup
+				data-slot="alert-dialog-content"
+				data-size={size}
+				className={cn(
+					"group/alert-dialog-content fixed top-1/2 left-1/2 z-50 grid w-full -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-background p-4 ring-1 ring-foreground/10 duration-100 outline-none data-[size=default]:max-w-xs data-[size=sm]:max-w-xs data-[size=default]:sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+					className,
+				)}
+				{...props}
+			/>
+		</AlertDialogPortal>
+	);
+}
+
+function AlertDialogHeader({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-header"
+			className={cn(
+				"grid grid-rows-[auto_1fr] place-items-center gap-1.5 text-center has-data-[slot=alert-dialog-media]:grid-rows-[auto_auto_1fr] has-data-[slot=alert-dialog-media]:gap-x-4 sm:group-data-[size=default]/alert-dialog-content:place-items-start sm:group-data-[size=default]/alert-dialog-content:text-left sm:group-data-[size=default]/alert-dialog-content:has-data-[slot=alert-dialog-media]:grid-rows-[auto_1fr]",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogFooter({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-footer"
+			className={cn(
+				"-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 group-data-[size=sm]/alert-dialog-content:grid group-data-[size=sm]/alert-dialog-content:grid-cols-2 sm:flex-row sm:justify-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogMedia({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-media"
+			className={cn(
+				"mb-2 inline-flex size-10 items-center justify-center rounded-md bg-muted sm:group-data-[size=default]/alert-dialog-content:row-span-2 *:[svg:not([class*='size-'])]:size-6",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogTitle({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Title>) {
+	return (
+		<AlertDialogPrimitive.Title
+			data-slot="alert-dialog-title"
+			className={cn(
+				"text-base font-medium sm:group-data-[size=default]/alert-dialog-content:group-has-data-[slot=alert-dialog-media]/alert-dialog-content:col-start-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogDescription({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Description>) {
+	return (
+		<AlertDialogPrimitive.Description
+			data-slot="alert-dialog-description"
+			className={cn(
+				"text-sm text-balance text-muted-foreground md:text-pretty *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogAction({
+	className,
+	...props
+}: React.ComponentProps<typeof Button>) {
+	return (
+		<Button
+			data-slot="alert-dialog-action"
+			className={cn(className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogCancel({
+	className,
+	variant = "outline",
+	size = "default",
+	...props
+}: AlertDialogPrimitive.Close.Props &
+	Pick<React.ComponentProps<typeof Button>, "variant" | "size">) {
+	return (
+		<AlertDialogPrimitive.Close
+			data-slot="alert-dialog-cancel"
+			className={cn(className)}
+			render={<Button variant={variant} size={size} />}
+			{...props}
+		/>
+	);
+}
+
+export {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogMedia,
+	AlertDialogOverlay,
+	AlertDialogPortal,
+	AlertDialogTitle,
+	AlertDialogTrigger,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/alert.tsx b/apps/cline-hub/src/webview/src/components/ui/alert.tsx
new file mode 100644
index 0000000..394bf45
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/alert.tsx
@@ -0,0 +1,76 @@
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const alertVariants = cva(
+	"group/alert relative grid w-full gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*='size-'])]:size-4",
+	{
+		variants: {
+			variant: {
+				default: "bg-card text-card-foreground",
+				destructive:
+					"bg-card text-destructive *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function Alert({
+	className,
+	variant,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>) {
+	return (
+		<div
+			data-slot="alert"
+			role="alert"
+			className={cn(alertVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-title"
+			className={cn(
+				"font-medium group-has-[>svg]/alert:col-start-2 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDescription({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-description"
+			className={cn(
+				"text-sm text-balance text-muted-foreground md:text-pretty [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertAction({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-action"
+			className={cn("absolute top-2 right-2", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Alert, AlertTitle, AlertDescription, AlertAction };
diff --git a/apps/cline-hub/src/webview/src/components/ui/avatar.tsx b/apps/cline-hub/src/webview/src/components/ui/avatar.tsx
new file mode 100644
index 0000000..85157c3
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/avatar.tsx
@@ -0,0 +1,109 @@
+"use client";
+
+import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Avatar({
+	className,
+	size = "default",
+	...props
+}: AvatarPrimitive.Root.Props & {
+	size?: "default" | "sm" | "lg";
+}) {
+	return (
+		<AvatarPrimitive.Root
+			data-slot="avatar"
+			data-size={size}
+			className={cn(
+				"group/avatar relative flex size-8 shrink-0 rounded-full select-none after:absolute after:inset-0 after:rounded-full after:border after:border-border after:mix-blend-darken data-[size=lg]:size-10 data-[size=sm]:size-6 dark:after:mix-blend-lighten",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props) {
+	return (
+		<AvatarPrimitive.Image
+			data-slot="avatar-image"
+			className={cn(
+				"aspect-square size-full rounded-full object-cover",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarFallback({
+	className,
+	...props
+}: AvatarPrimitive.Fallback.Props) {
+	return (
+		<AvatarPrimitive.Fallback
+			data-slot="avatar-fallback"
+			className={cn(
+				"flex size-full items-center justify-center rounded-full bg-muted text-sm text-muted-foreground group-data-[size=sm]/avatar:text-xs",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarBadge({ className, ...props }: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="avatar-badge"
+			className={cn(
+				"absolute right-0 bottom-0 z-10 inline-flex items-center justify-center rounded-full bg-primary text-primary-foreground bg-blend-color ring-2 ring-background select-none",
+				"group-data-[size=sm]/avatar:size-2 group-data-[size=sm]/avatar:[&>svg]:hidden",
+				"group-data-[size=default]/avatar:size-2.5 group-data-[size=default]/avatar:[&>svg]:size-2",
+				"group-data-[size=lg]/avatar:size-3 group-data-[size=lg]/avatar:[&>svg]:size-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="avatar-group"
+			className={cn(
+				"group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-background",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarGroupCount({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="avatar-group-count"
+			className={cn(
+				"relative flex size-8 shrink-0 items-center justify-center rounded-full bg-muted text-sm text-muted-foreground ring-2 ring-background group-has-data-[size=lg]/avatar-group:size-10 group-has-data-[size=sm]/avatar-group:size-6 [&>svg]:size-4 group-has-data-[size=lg]/avatar-group:[&>svg]:size-5 group-has-data-[size=sm]/avatar-group:[&>svg]:size-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Avatar,
+	AvatarImage,
+	AvatarFallback,
+	AvatarGroup,
+	AvatarGroupCount,
+	AvatarBadge,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/badge.tsx b/apps/cline-hub/src/webview/src/components/ui/badge.tsx
new file mode 100644
index 0000000..20f6061
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/badge.tsx
@@ -0,0 +1,52 @@
+import { mergeProps } from "@base-ui/react/merge-props";
+import { useRender } from "@base-ui/react/use-render";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+const badgeVariants = cva(
+	"group/badge inline-flex h-5 w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none [&>svg]:size-3!",
+	{
+		variants: {
+			variant: {
+				default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+				secondary:
+					"bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80",
+				destructive:
+					"bg-destructive/10 text-destructive focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:focus-visible:ring-destructive/40 [a]:hover:bg-destructive/20",
+				outline:
+					"border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground",
+				ghost:
+					"hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50",
+				link: "text-primary underline-offset-4 hover:underline",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function Badge({
+	className,
+	variant = "default",
+	render,
+	...props
+}: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>) {
+	return useRender({
+		defaultTagName: "span",
+		props: mergeProps<"span">(
+			{
+				className: cn(badgeVariants({ variant }), className),
+			},
+			props,
+		),
+		render,
+		state: {
+			slot: "badge",
+			variant,
+		},
+	});
+}
+
+export { Badge, badgeVariants };
diff --git a/apps/cline-hub/src/webview/src/components/ui/button-group.tsx b/apps/cline-hub/src/webview/src/components/ui/button-group.tsx
new file mode 100644
index 0000000..9f81e3f
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/button-group.tsx
@@ -0,0 +1,87 @@
+import { mergeProps } from "@base-ui/react/merge-props";
+import { useRender } from "@base-ui/react/use-render";
+import { cva, type VariantProps } from "class-variance-authority";
+import { Separator } from "@/components/ui/separator";
+import { cn } from "@/lib/utils";
+
+const buttonGroupVariants = cva(
+	"flex w-fit items-stretch *:focus-visible:relative *:focus-visible:z-10 has-[>[data-slot=button-group]]:gap-2 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-lg [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1",
+	{
+		variants: {
+			orientation: {
+				horizontal:
+					"*:data-slot:rounded-r-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-r-lg! [&>[data-slot]~[data-slot]]:rounded-l-none [&>[data-slot]~[data-slot]]:border-l-0",
+				vertical:
+					"flex-col *:data-slot:rounded-b-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-b-lg! [&>[data-slot]~[data-slot]]:rounded-t-none [&>[data-slot]~[data-slot]]:border-t-0",
+			},
+		},
+		defaultVariants: {
+			orientation: "horizontal",
+		},
+	},
+);
+
+function ButtonGroup({
+	className,
+	orientation,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			role="group"
+			data-slot="button-group"
+			data-orientation={orientation}
+			className={cn(buttonGroupVariants({ orientation }), className)}
+			{...props}
+		/>
+	);
+}
+
+function ButtonGroupText({
+	className,
+	render,
+	...props
+}: useRender.ComponentProps<"div">) {
+	return useRender({
+		defaultTagName: "div",
+		props: mergeProps<"div">(
+			{
+				className: cn(
+					"flex items-center gap-2 rounded-lg border bg-muted px-2.5 text-sm font-medium [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+					className,
+				),
+			},
+			props,
+		),
+		render,
+		state: {
+			slot: "button-group-text",
+		},
+	});
+}
+
+function ButtonGroupSeparator({
+	className,
+	orientation = "vertical",
+	...props
+}: React.ComponentProps<typeof Separator>) {
+	return (
+		<Separator
+			data-slot="button-group-separator"
+			orientation={orientation}
+			className={cn(
+				"relative self-stretch bg-input data-horizontal:mx-px data-horizontal:w-auto data-vertical:my-px data-vertical:h-auto",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	ButtonGroup,
+	ButtonGroupSeparator,
+	ButtonGroupText,
+	buttonGroupVariants,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/button.tsx b/apps/cline-hub/src/webview/src/components/ui/button.tsx
new file mode 100644
index 0000000..46006bc
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/button.tsx
@@ -0,0 +1,60 @@
+"use client";
+
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+const buttonVariants = cva(
+	"group/button cursor-pointer inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+	{
+		variants: {
+			variant: {
+				default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+				outline:
+					"border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+				secondary:
+					"bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+				ghost:
+					"hover:bg-muted/50 hover:text-foreground aria-expanded:bg-muted/50 aria-expanded:text-foreground/50 dark:hover:bg-muted/50",
+				destructive:
+					"bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+				link: "text-primary underline-offset-4 hover:underline",
+			},
+			size: {
+				default:
+					"h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+				xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+				sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+				lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-3 has-data-[icon=inline-start]:pl-3",
+				icon: "size-8",
+				"icon-xs":
+					"size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+				"icon-sm":
+					"size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+				"icon-lg": "size-9",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+);
+
+function Button({
+	className,
+	variant = "default",
+	size = "default",
+	...props
+}: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>) {
+	return (
+		<ButtonPrimitive
+			data-slot="button"
+			className={cn(buttonVariants({ variant, size, className }))}
+			{...props}
+		/>
+	);
+}
+
+export { Button, buttonVariants };
diff --git a/apps/cline-hub/src/webview/src/components/ui/card.tsx b/apps/cline-hub/src/webview/src/components/ui/card.tsx
new file mode 100644
index 0000000..022c8c6
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/card.tsx
@@ -0,0 +1,103 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Card({
+	className,
+	size = "default",
+	...props
+}: React.ComponentProps<"div"> & { size?: "default" | "sm" }) {
+	return (
+		<div
+			data-slot="card"
+			data-size={size}
+			className={cn(
+				"group/card flex flex-col gap-4 overflow-hidden rounded-xl bg-card py-4 text-sm text-card-foreground ring-1 ring-foreground/10 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-header"
+			className={cn(
+				"group/card-header @container/card-header grid auto-rows-min items-start gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto] [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-title"
+			className={cn(
+				"text-base leading-snug font-medium group-data-[size=sm]/card:text-sm",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-description"
+			className={cn("text-sm text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-action"
+			className={cn(
+				"col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-content"
+			className={cn("px-4 group-data-[size=sm]/card:px-3", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-footer"
+			className={cn(
+				"flex items-center rounded-b-xl border-t bg-muted/50 p-4 group-data-[size=sm]/card:p-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Card,
+	CardHeader,
+	CardFooter,
+	CardTitle,
+	CardAction,
+	CardDescription,
+	CardContent,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/carousel.tsx b/apps/cline-hub/src/webview/src/components/ui/carousel.tsx
new file mode 100644
index 0000000..56a10e1
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/carousel.tsx
@@ -0,0 +1,241 @@
+import useEmblaCarousel, {
+	type UseEmblaCarouselType,
+} from "embla-carousel-react";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+
+type CarouselProps = {
+	opts?: CarouselOptions;
+	plugins?: CarouselPlugin;
+	orientation?: "horizontal" | "vertical";
+	setApi?: (api: CarouselApi) => void;
+};
+
+type CarouselContextProps = {
+	carouselRef: ReturnType<typeof useEmblaCarousel>[0];
+	api: ReturnType<typeof useEmblaCarousel>[1];
+	scrollPrev: () => void;
+	scrollNext: () => void;
+	canScrollPrev: boolean;
+	canScrollNext: boolean;
+} & CarouselProps;
+
+const CarouselContext = React.createContext<CarouselContextProps | null>(null);
+
+function useCarousel() {
+	const context = React.useContext(CarouselContext);
+
+	if (!context) {
+		throw new Error("useCarousel must be used within a <Carousel />");
+	}
+
+	return context;
+}
+
+function Carousel({
+	orientation = "horizontal",
+	opts,
+	setApi,
+	plugins,
+	className,
+	children,
+	...props
+}: React.ComponentProps<"div"> & CarouselProps) {
+	const [carouselRef, api] = useEmblaCarousel(
+		{
+			...opts,
+			axis: orientation === "horizontal" ? "x" : "y",
+		},
+		plugins,
+	);
+	const [canScrollPrev, setCanScrollPrev] = React.useState(false);
+	const [canScrollNext, setCanScrollNext] = React.useState(false);
+
+	const onSelect = React.useCallback((api: CarouselApi) => {
+		if (!api) return;
+		setCanScrollPrev(api.canScrollPrev());
+		setCanScrollNext(api.canScrollNext());
+	}, []);
+
+	const scrollPrev = React.useCallback(() => {
+		api?.scrollPrev();
+	}, [api]);
+
+	const scrollNext = React.useCallback(() => {
+		api?.scrollNext();
+	}, [api]);
+
+	const handleKeyDown = React.useCallback(
+		(event: React.KeyboardEvent<HTMLDivElement>) => {
+			if (event.key === "ArrowLeft") {
+				event.preventDefault();
+				scrollPrev();
+			} else if (event.key === "ArrowRight") {
+				event.preventDefault();
+				scrollNext();
+			}
+		},
+		[scrollPrev, scrollNext],
+	);
+
+	React.useEffect(() => {
+		if (!api || !setApi) return;
+		setApi(api);
+	}, [api, setApi]);
+
+	React.useEffect(() => {
+		if (!api) return;
+		onSelect(api);
+		api.on("reInit", onSelect);
+		api.on("select", onSelect);
+
+		return () => {
+			api?.off("select", onSelect);
+		};
+	}, [api, onSelect]);
+
+	return (
+		<CarouselContext.Provider
+			value={{
+				carouselRef,
+				api: api,
+				opts,
+				orientation:
+					orientation || (opts?.axis === "y" ? "vertical" : "horizontal"),
+				scrollPrev,
+				scrollNext,
+				canScrollPrev,
+				canScrollNext,
+			}}
+		>
+			{/* biome-ignore lint/a11y/useSemanticElements: section would break carousel structure */}
+			<div
+				onKeyDownCapture={handleKeyDown}
+				className={cn("relative", className)}
+				role="region"
+				aria-roledescription="carousel"
+				data-slot="carousel"
+				{...props}
+			>
+				{children}
+			</div>
+		</CarouselContext.Provider>
+	);
+}
+
+function CarouselContent({ className, ...props }: React.ComponentProps<"div">) {
+	const { carouselRef, orientation } = useCarousel();
+
+	return (
+		<div
+			ref={carouselRef}
+			className="overflow-hidden"
+			data-slot="carousel-content"
+		>
+			<div
+				className={cn(
+					"flex",
+					orientation === "horizontal" ? "-ml-4" : "-mt-4 flex-col",
+					className,
+				)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function CarouselItem({ className, ...props }: React.ComponentProps<"div">) {
+	const { orientation } = useCarousel();
+
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			role="group"
+			aria-roledescription="slide"
+			data-slot="carousel-item"
+			className={cn(
+				"min-w-0 shrink-0 grow-0 basis-full",
+				orientation === "horizontal" ? "pl-4" : "pt-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CarouselPrevious({
+	className,
+	variant = "outline",
+	size = "icon-sm",
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { orientation, scrollPrev, canScrollPrev } = useCarousel();
+
+	return (
+		<Button
+			data-slot="carousel-previous"
+			variant={variant}
+			size={size}
+			className={cn(
+				"absolute touch-manipulation rounded-full",
+				orientation === "horizontal"
+					? "top-1/2 -left-12 -translate-y-1/2"
+					: "-top-12 left-1/2 -translate-x-1/2 rotate-90",
+				className,
+			)}
+			disabled={!canScrollPrev}
+			onClick={scrollPrev}
+			{...props}
+		>
+			<ChevronLeftIcon />
+			<span className="sr-only">Previous slide</span>
+		</Button>
+	);
+}
+
+function CarouselNext({
+	className,
+	variant = "outline",
+	size = "icon-sm",
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { orientation, scrollNext, canScrollNext } = useCarousel();
+
+	return (
+		<Button
+			data-slot="carousel-next"
+			variant={variant}
+			size={size}
+			className={cn(
+				"absolute touch-manipulation rounded-full",
+				orientation === "horizontal"
+					? "top-1/2 -right-12 -translate-y-1/2"
+					: "-bottom-12 left-1/2 -translate-x-1/2 rotate-90",
+				className,
+			)}
+			disabled={!canScrollNext}
+			onClick={scrollNext}
+			{...props}
+		>
+			<ChevronRightIcon />
+			<span className="sr-only">Next slide</span>
+		</Button>
+	);
+}
+
+export {
+	type CarouselApi,
+	Carousel,
+	CarouselContent,
+	CarouselItem,
+	CarouselPrevious,
+	CarouselNext,
+	useCarousel,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/chart.tsx b/apps/cline-hub/src/webview/src/components/ui/chart.tsx
new file mode 100644
index 0000000..dd4f0e9
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/chart.tsx
@@ -0,0 +1,355 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+
+import { cn } from "@/lib/utils";
+
+// Format: { THEME_NAME: CSS_SELECTOR }
+const THEMES = { light: "", dark: ".dark" } as const;
+
+export type ChartConfig = {
+	[k in string]: {
+		label?: React.ReactNode;
+		icon?: React.ComponentType;
+	} & (
+		| { color?: string; theme?: never }
+		| { color?: never; theme: Record<keyof typeof THEMES, string> }
+	);
+};
+
+type ChartContextProps = {
+	config: ChartConfig;
+};
+
+const ChartContext = React.createContext<ChartContextProps | null>(null);
+
+function useChart() {
+	const context = React.useContext(ChartContext);
+
+	if (!context) {
+		throw new Error("useChart must be used within a <ChartContainer />");
+	}
+
+	return context;
+}
+
+function ChartContainer({
+	id,
+	className,
+	children,
+	config,
+	...props
+}: React.ComponentProps<"div"> & {
+	config: ChartConfig;
+	children: React.ComponentProps<
+		typeof RechartsPrimitive.ResponsiveContainer
+	>["children"];
+}) {
+	const uniqueId = React.useId();
+	const chartId = `chart-${id || uniqueId.replace(/:/g, "")}`;
+
+	return (
+		<ChartContext.Provider value={{ config }}>
+			<div
+				data-slot="chart"
+				data-chart={chartId}
+				className={cn(
+					"flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-hidden [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border [&_.recharts-sector]:outline-hidden [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-surface]:outline-hidden",
+					className,
+				)}
+				{...props}
+			>
+				<ChartStyle id={chartId} config={config} />
+				<RechartsPrimitive.ResponsiveContainer>
+					{children}
+				</RechartsPrimitive.ResponsiveContainer>
+			</div>
+		</ChartContext.Provider>
+	);
+}
+
+const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
+	const colorConfig = Object.entries(config).filter(
+		([, config]) => config.theme || config.color,
+	);
+
+	if (!colorConfig.length) {
+		return null;
+	}
+
+	return (
+		<style
+			// biome-ignore lint/security/noDangerouslySetInnerHtml: acceptable use of dangerouslySetInnerHTML to inject dynamic styles based on theme configuration
+			dangerouslySetInnerHTML={{
+				__html: Object.entries(THEMES)
+					.map(
+						([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig
+	.map(([key, itemConfig]) => {
+		const color =
+			itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
+			itemConfig.color;
+		return color ? `  --color-${key}: ${color};` : null;
+	})
+	.join("\n")}
+}
+`,
+					)
+					.join("\n"),
+			}}
+		/>
+	);
+};
+
+const ChartTooltip = RechartsPrimitive.Tooltip;
+
+function ChartTooltipContent({
+	active,
+	payload,
+	className,
+	indicator = "dot",
+	hideLabel = false,
+	hideIndicator = false,
+	label,
+	labelFormatter,
+	labelClassName,
+	formatter,
+	color,
+	nameKey,
+	labelKey,
+}: React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
+	React.ComponentProps<"div"> & {
+		hideLabel?: boolean;
+		hideIndicator?: boolean;
+		indicator?: "line" | "dot" | "dashed";
+		nameKey?: string;
+		labelKey?: string;
+	}) {
+	const { config } = useChart();
+
+	const tooltipLabel = React.useMemo(() => {
+		if (hideLabel || !payload?.length) {
+			return null;
+		}
+
+		const [item] = payload;
+		const key = `${labelKey || item?.dataKey || item?.name || "value"}`;
+		const itemConfig = getPayloadConfigFromPayload(config, item, key);
+		const value =
+			!labelKey && typeof label === "string"
+				? config[label as keyof typeof config]?.label || label
+				: itemConfig?.label;
+
+		if (labelFormatter) {
+			return (
+				<div className={cn("font-medium", labelClassName)}>
+					{labelFormatter(value, payload)}
+				</div>
+			);
+		}
+
+		if (!value) {
+			return null;
+		}
+
+		return <div className={cn("font-medium", labelClassName)}>{value}</div>;
+	}, [
+		label,
+		labelFormatter,
+		payload,
+		hideLabel,
+		labelClassName,
+		config,
+		labelKey,
+	]);
+
+	if (!active || !payload?.length) {
+		return null;
+	}
+
+	const nestLabel = payload.length === 1 && indicator !== "dot";
+
+	return (
+		<div
+			className={cn(
+				"grid min-w-32 items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl",
+				className,
+			)}
+		>
+			{!nestLabel ? tooltipLabel : null}
+			<div className="grid gap-1.5">
+				{payload
+					.filter((item) => item.type !== "none")
+					.map((item, index) => {
+						const key = `${nameKey || item.name || item.dataKey || "value"}`;
+						const itemConfig = getPayloadConfigFromPayload(config, item, key);
+						const indicatorColor = color || item.payload.fill || item.color;
+
+						return (
+							<div
+								key={item.dataKey}
+								className={cn(
+									"flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground",
+									indicator === "dot" && "items-center",
+								)}
+							>
+								{formatter && item?.value !== undefined && item.name ? (
+									formatter(item.value, item.name, item, index, item.payload)
+								) : (
+									<>
+										{itemConfig?.icon ? (
+											<itemConfig.icon />
+										) : (
+											!hideIndicator && (
+												<div
+													className={cn(
+														"shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)",
+														{
+															"h-2.5 w-2.5": indicator === "dot",
+															"w-1": indicator === "line",
+															"w-0 border-[1.5px] border-dashed bg-transparent":
+																indicator === "dashed",
+															"my-0.5": nestLabel && indicator === "dashed",
+														},
+													)}
+													style={
+														{
+															"--color-bg": indicatorColor,
+															"--color-border": indicatorColor,
+														} as React.CSSProperties
+													}
+												/>
+											)
+										)}
+										<div
+											className={cn(
+												"flex flex-1 justify-between leading-none",
+												nestLabel ? "items-end" : "items-center",
+											)}
+										>
+											<div className="grid gap-1.5">
+												{nestLabel ? tooltipLabel : null}
+												<span className="text-muted-foreground">
+													{itemConfig?.label || item.name}
+												</span>
+											</div>
+											{item.value && (
+												<span className="font-mono font-medium text-foreground tabular-nums">
+													{item.value.toLocaleString()}
+												</span>
+											)}
+										</div>
+									</>
+								)}
+							</div>
+						);
+					})}
+			</div>
+		</div>
+	);
+}
+
+const ChartLegend = RechartsPrimitive.Legend;
+
+function ChartLegendContent({
+	className,
+	hideIcon = false,
+	payload,
+	verticalAlign = "bottom",
+	nameKey,
+}: React.ComponentProps<"div"> &
+	Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+		hideIcon?: boolean;
+		nameKey?: string;
+	}) {
+	const { config } = useChart();
+
+	if (!payload?.length) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn(
+				"flex items-center justify-center gap-4",
+				verticalAlign === "top" ? "pb-3" : "pt-3",
+				className,
+			)}
+		>
+			{payload
+				.filter((item) => item.type !== "none")
+				.map((item) => {
+					const key = `${nameKey || item.dataKey || "value"}`;
+					const itemConfig = getPayloadConfigFromPayload(config, item, key);
+
+					return (
+						<div
+							key={item.value}
+							className={cn(
+								"flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground",
+							)}
+						>
+							{itemConfig?.icon && !hideIcon ? (
+								<itemConfig.icon />
+							) : (
+								<div
+									className="h-2 w-2 shrink-0 rounded-[2px]"
+									style={{
+										backgroundColor: item.color,
+									}}
+								/>
+							)}
+							{itemConfig?.label}
+						</div>
+					);
+				})}
+		</div>
+	);
+}
+
+function getPayloadConfigFromPayload(
+	config: ChartConfig,
+	payload: unknown,
+	key: string,
+) {
+	if (typeof payload !== "object" || payload === null) {
+		return undefined;
+	}
+
+	const payloadPayload =
+		"payload" in payload &&
+		typeof payload.payload === "object" &&
+		payload.payload !== null
+			? payload.payload
+			: undefined;
+
+	let configLabelKey: string = key;
+
+	if (
+		key in payload &&
+		typeof payload[key as keyof typeof payload] === "string"
+	) {
+		configLabelKey = payload[key as keyof typeof payload] as string;
+	} else if (
+		payloadPayload &&
+		key in payloadPayload &&
+		typeof payloadPayload[key as keyof typeof payloadPayload] === "string"
+	) {
+		configLabelKey = payloadPayload[
+			key as keyof typeof payloadPayload
+		] as string;
+	}
+
+	return configLabelKey in config
+		? config[configLabelKey]
+		: config[key as keyof typeof config];
+}
+
+export {
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+	ChartLegend,
+	ChartLegendContent,
+	ChartStyle,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/checkbox.tsx b/apps/cline-hub/src/webview/src/components/ui/checkbox.tsx
new file mode 100644
index 0000000..3187b27
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/checkbox.tsx
@@ -0,0 +1,27 @@
+"use client";
+
+import { Checkbox as CheckboxPrimitive } from "@base-ui/react/checkbox";
+import { CheckIcon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+function Checkbox({ className, ...props }: CheckboxPrimitive.Root.Props) {
+	return (
+		<CheckboxPrimitive.Root
+			data-slot="checkbox"
+			className={cn(
+				"peer relative flex size-4 shrink-0 cursor-pointer items-center justify-center rounded-lg border border-input transition-colors outline-none group-has-disabled/field:opacity-50 after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 data-disabled:cursor-not-allowed aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground dark:data-checked:bg-primary",
+				className,
+			)}
+			{...props}
+		>
+			<CheckboxPrimitive.Indicator
+				data-slot="checkbox-indicator"
+				className="grid place-content-center text-current transition-none [&>svg]:size-3.5"
+			>
+				<CheckIcon />
+			</CheckboxPrimitive.Indicator>
+		</CheckboxPrimitive.Root>
+	);
+}
+
+export { Checkbox };
diff --git a/apps/cline-hub/src/webview/src/components/ui/collapsible.tsx b/apps/cline-hub/src/webview/src/components/ui/collapsible.tsx
new file mode 100644
index 0000000..66478ec
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/collapsible.tsx
@@ -0,0 +1,21 @@
+"use client";
+
+import { Collapsible as CollapsiblePrimitive } from "@base-ui/react/collapsible";
+
+function Collapsible({ ...props }: CollapsiblePrimitive.Root.Props) {
+	return <CollapsiblePrimitive.Root data-slot="collapsible" {...props} />;
+}
+
+function CollapsibleTrigger({ ...props }: CollapsiblePrimitive.Trigger.Props) {
+	return (
+		<CollapsiblePrimitive.Trigger data-slot="collapsible-trigger" {...props} />
+	);
+}
+
+function CollapsibleContent({ ...props }: CollapsiblePrimitive.Panel.Props) {
+	return (
+		<CollapsiblePrimitive.Panel data-slot="collapsible-content" {...props} />
+	);
+}
+
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };
diff --git a/apps/cline-hub/src/webview/src/components/ui/combobox.tsx b/apps/cline-hub/src/webview/src/components/ui/combobox.tsx
new file mode 100644
index 0000000..7041da2
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/combobox.tsx
@@ -0,0 +1,300 @@
+import { Combobox as ComboboxPrimitive } from "@base-ui/react";
+import { CheckIcon, ChevronDownIcon, XIcon } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupInput,
+} from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+const Combobox = ComboboxPrimitive.Root;
+
+function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props) {
+	return <ComboboxPrimitive.Value data-slot="combobox-value" {...props} />;
+}
+
+function ComboboxTrigger({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Trigger.Props) {
+	return (
+		<ComboboxPrimitive.Trigger
+			data-slot="combobox-trigger"
+			className={cn(
+				"cursor-pointer data-disabled:cursor-not-allowed [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+		</ComboboxPrimitive.Trigger>
+	);
+}
+
+function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props) {
+	return (
+		<ComboboxPrimitive.Clear
+			data-slot="combobox-clear"
+			render={<InputGroupButton variant="ghost" size="icon-xs" />}
+			className={cn(className)}
+			{...props}
+		>
+			<XIcon className="pointer-events-none" />
+		</ComboboxPrimitive.Clear>
+	);
+}
+
+function ComboboxInput({
+	className,
+	children,
+	disabled = false,
+	showTrigger = true,
+	showClear = false,
+	...props
+}: ComboboxPrimitive.Input.Props & {
+	showTrigger?: boolean;
+	showClear?: boolean;
+}) {
+	return (
+		<InputGroup className={cn("w-auto", className)}>
+			<ComboboxPrimitive.Input
+				render={<InputGroupInput disabled={disabled} />}
+				{...props}
+			/>
+			<InputGroupAddon align="inline-end">
+				{showTrigger && (
+					<InputGroupButton
+						size="icon-xs"
+						variant="ghost"
+						render={<ComboboxTrigger />}
+						data-slot="input-group-button"
+						className="group-has-data-[slot=combobox-clear]/input-group:hidden data-pressed:bg-transparent"
+						disabled={disabled}
+					/>
+				)}
+				{showClear && <ComboboxClear disabled={disabled} />}
+			</InputGroupAddon>
+			{children}
+		</InputGroup>
+	);
+}
+
+function ComboboxContent({
+	className,
+	side = "bottom",
+	sideOffset = 6,
+	align = "start",
+	alignOffset = 0,
+	anchor,
+	...props
+}: ComboboxPrimitive.Popup.Props &
+	Pick<
+		ComboboxPrimitive.Positioner.Props,
+		"side" | "align" | "sideOffset" | "alignOffset" | "anchor"
+	>) {
+	return (
+		<ComboboxPrimitive.Portal>
+			<ComboboxPrimitive.Positioner
+				side={side}
+				sideOffset={sideOffset}
+				align={align}
+				alignOffset={alignOffset}
+				anchor={anchor}
+				className="isolate z-50"
+			>
+				<ComboboxPrimitive.Popup
+					data-slot="combobox-content"
+					data-chips={!!anchor}
+					className={cn(
+						"group/combobox-content relative max-h-(--available-height) w-(--anchor-width) max-w-(--available-width) min-w-[calc(var(--anchor-width)+--spacing(7))] origin-(--transform-origin) overflow-hidden rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[chips=true]:min-w-(--anchor-width) data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 *:data-[slot=input-group]:m-1 *:data-[slot=input-group]:mb-0 *:data-[slot=input-group]:h-8 *:data-[slot=input-group]:border-input/30 *:data-[slot=input-group]:bg-input/30 *:data-[slot=input-group]:shadow-none data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</ComboboxPrimitive.Positioner>
+		</ComboboxPrimitive.Portal>
+	);
+}
+
+function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props) {
+	return (
+		<ComboboxPrimitive.List
+			data-slot="combobox-list"
+			className={cn(
+				"no-scrollbar max-h-[min(calc(--spacing(72)---spacing(9)),calc(var(--available-height)---spacing(9)))] scroll-py-1 overflow-y-auto overscroll-contain p-1 data-empty:p-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxItem({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Item.Props) {
+	return (
+		<ComboboxPrimitive.Item
+			data-slot="combobox-item"
+			className={cn(
+				"relative flex w-full cursor-pointer items-center gap-2 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none data-highlighted:bg-accent data-highlighted:text-accent-foreground not-data-[variant=destructive]:data-highlighted:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ComboboxPrimitive.ItemIndicator
+				render={
+					<span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
+				}
+			>
+				<CheckIcon className="pointer-events-none" />
+			</ComboboxPrimitive.ItemIndicator>
+		</ComboboxPrimitive.Item>
+	);
+}
+
+function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props) {
+	return (
+		<ComboboxPrimitive.Group
+			data-slot="combobox-group"
+			className={cn(className)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxLabel({
+	className,
+	...props
+}: ComboboxPrimitive.GroupLabel.Props) {
+	return (
+		<ComboboxPrimitive.GroupLabel
+			data-slot="combobox-label"
+			className={cn("px-2 py-1.5 text-xs text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props) {
+	return (
+		<ComboboxPrimitive.Collection data-slot="combobox-collection" {...props} />
+	);
+}
+
+function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props) {
+	return (
+		<ComboboxPrimitive.Empty
+			data-slot="combobox-empty"
+			className={cn(
+				"hidden w-full justify-center py-2 text-center text-sm text-muted-foreground group-data-empty/combobox-content:flex",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxSeparator({
+	className,
+	...props
+}: ComboboxPrimitive.Separator.Props) {
+	return (
+		<ComboboxPrimitive.Separator
+			data-slot="combobox-separator"
+			className={cn("-mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxChips({
+	className,
+	...props
+}: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> &
+	ComboboxPrimitive.Chips.Props) {
+	return (
+		<ComboboxPrimitive.Chips
+			data-slot="combobox-chips"
+			className={cn(
+				"flex min-h-8 flex-wrap items-center gap-1 rounded-lg border border-input bg-transparent bg-clip-padding px-2.5 py-1 text-sm transition-colors focus-within:border-ring focus-within:ring-3 focus-within:ring-ring/50 has-aria-invalid:border-destructive has-aria-invalid:ring-3 has-aria-invalid:ring-destructive/20 has-data-[slot=combobox-chip]:px-1 dark:bg-input/30 dark:has-aria-invalid:border-destructive/50 dark:has-aria-invalid:ring-destructive/40",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxChip({
+	className,
+	children,
+	showRemove = true,
+	...props
+}: ComboboxPrimitive.Chip.Props & {
+	showRemove?: boolean;
+}) {
+	return (
+		<ComboboxPrimitive.Chip
+			data-slot="combobox-chip"
+			className={cn(
+				"flex h-[calc(--spacing(5.25))] w-fit items-center justify-center gap-1 rounded-sm bg-muted px-1.5 text-xs font-medium whitespace-nowrap text-foreground has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50 has-data-[slot=combobox-chip-remove]:pr-0",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			{showRemove && (
+				<ComboboxPrimitive.ChipRemove
+					render={<Button variant="ghost" size="icon-xs" />}
+					className="-ml-1 cursor-pointer opacity-50 hover:opacity-100"
+					data-slot="combobox-chip-remove"
+				>
+					<XIcon className="pointer-events-none" />
+				</ComboboxPrimitive.ChipRemove>
+			)}
+		</ComboboxPrimitive.Chip>
+	);
+}
+
+function ComboboxChipsInput({
+	className,
+	...props
+}: ComboboxPrimitive.Input.Props) {
+	return (
+		<ComboboxPrimitive.Input
+			data-slot="combobox-chip-input"
+			className={cn("min-w-16 flex-1 outline-none", className)}
+			{...props}
+		/>
+	);
+}
+
+function useComboboxAnchor() {
+	return React.useRef<HTMLDivElement | null>(null);
+}
+
+export {
+	Combobox,
+	ComboboxInput,
+	ComboboxContent,
+	ComboboxList,
+	ComboboxItem,
+	ComboboxGroup,
+	ComboboxLabel,
+	ComboboxCollection,
+	ComboboxEmpty,
+	ComboboxSeparator,
+	ComboboxChips,
+	ComboboxChip,
+	ComboboxChipsInput,
+	ComboboxTrigger,
+	ComboboxValue,
+	useComboboxAnchor,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/command.tsx b/apps/cline-hub/src/webview/src/components/ui/command.tsx
new file mode 100644
index 0000000..c8f9bc4
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/command.tsx
@@ -0,0 +1,192 @@
+"use client";
+
+import { Command as CommandPrimitive } from "cmdk";
+import { CheckIcon, SearchIcon } from "lucide-react";
+import type * as React from "react";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { InputGroup, InputGroupAddon } from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+function Command({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive>) {
+	return (
+		<CommandPrimitive
+			data-slot="command"
+			className={cn(
+				"flex size-full flex-col overflow-hidden rounded-xl! bg-popover p-1 text-popover-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandDialog({
+	title = "Command Palette",
+	description = "Search for a command to run...",
+	children,
+	className,
+	showCloseButton = false,
+	...props
+}: Omit<React.ComponentProps<typeof Dialog>, "children"> & {
+	title?: string;
+	description?: string;
+	className?: string;
+	showCloseButton?: boolean;
+	children: React.ReactNode;
+}) {
+	return (
+		<Dialog {...props}>
+			<DialogHeader className="sr-only">
+				<DialogTitle>{title}</DialogTitle>
+				<DialogDescription>{description}</DialogDescription>
+			</DialogHeader>
+			<DialogContent
+				className={cn(
+					"top-1/3 translate-y-0 overflow-hidden rounded-xl! p-0",
+					className,
+				)}
+				showCloseButton={showCloseButton}
+			>
+				{children}
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+function CommandInput({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Input>) {
+	return (
+		<div data-slot="command-input-wrapper" className="p-1 pb-0">
+			<InputGroup className="h-8! rounded-lg! border-input/30 bg-input/30 shadow-none! *:data-[slot=input-group-addon]:pl-2!">
+				<CommandPrimitive.Input
+					data-slot="command-input"
+					className={cn(
+						"w-full text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50",
+						className,
+					)}
+					{...props}
+				/>
+				<InputGroupAddon>
+					<SearchIcon className="size-4 shrink-0 opacity-50" />
+				</InputGroupAddon>
+			</InputGroup>
+		</div>
+	);
+}
+
+function CommandList({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.List>) {
+	return (
+		<CommandPrimitive.List
+			data-slot="command-list"
+			className={cn(
+				"no-scrollbar max-h-72 scroll-py-1 overflow-x-hidden overflow-y-auto outline-none",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandEmpty({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Empty>) {
+	return (
+		<CommandPrimitive.Empty
+			data-slot="command-empty"
+			className={cn("py-6 text-center text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function CommandGroup({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Group>) {
+	return (
+		<CommandPrimitive.Group
+			data-slot="command-group"
+			className={cn(
+				"overflow-hidden p-1 text-foreground **:[[cmdk-group-heading]]:px-2 **:[[cmdk-group-heading]]:py-1.5 **:[[cmdk-group-heading]]:text-xs **:[[cmdk-group-heading]]:font-medium **:[[cmdk-group-heading]]:text-muted-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Separator>) {
+	return (
+		<CommandPrimitive.Separator
+			data-slot="command-separator"
+			className={cn("-mx-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function CommandItem({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Item>) {
+	return (
+		<CommandPrimitive.Item
+			data-slot="command-item"
+			className={cn(
+				"group/command-item relative flex cursor-pointer items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none in-data-[slot=dialog-content]:rounded-lg! data-[disabled=true]:pointer-events-none data-[disabled=true]:cursor-not-allowed data-[disabled=true]:opacity-50 data-selected:bg-muted data-selected:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-selected:*:[svg]:text-foreground",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<CheckIcon className="ml-auto opacity-0 group-has-data-[slot=command-shortcut]/command-item:hidden group-data-[checked=true]/command-item:opacity-100" />
+		</CommandPrimitive.Item>
+	);
+}
+
+function CommandShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="command-shortcut"
+			className={cn(
+				"ml-auto text-xs tracking-widest text-muted-foreground group-data-selected/command-item:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Command,
+	CommandDialog,
+	CommandInput,
+	CommandList,
+	CommandEmpty,
+	CommandGroup,
+	CommandItem,
+	CommandShortcut,
+	CommandSeparator,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/dialog.tsx b/apps/cline-hub/src/webview/src/components/ui/dialog.tsx
new file mode 100644
index 0000000..3fd2e1c
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/dialog.tsx
@@ -0,0 +1,155 @@
+"use client";
+
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+import { XIcon } from "lucide-react";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function Dialog({ ...props }: DialogPrimitive.Root.Props) {
+	return <DialogPrimitive.Root data-slot="dialog" {...props} />;
+}
+
+function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props) {
+	return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
+}
+
+function DialogPortal({ ...props }: DialogPrimitive.Portal.Props) {
+	return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
+}
+
+function DialogClose({ ...props }: DialogPrimitive.Close.Props) {
+	return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
+}
+
+function DialogOverlay({
+	className,
+	...props
+}: DialogPrimitive.Backdrop.Props) {
+	return (
+		<DialogPrimitive.Backdrop
+			data-slot="dialog-overlay"
+			className={cn(
+				"fixed inset-0 isolate z-50 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DialogContent({
+	className,
+	children,
+	showCloseButton = true,
+	...props
+}: DialogPrimitive.Popup.Props & {
+	showCloseButton?: boolean;
+}) {
+	return (
+		<DialogPortal>
+			<DialogOverlay />
+			<DialogPrimitive.Popup
+				data-slot="dialog-content"
+				className={cn(
+					"fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-background p-4 text-sm ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				{showCloseButton && (
+					<DialogPrimitive.Close
+						data-slot="dialog-close"
+						render={
+							<Button
+								variant="ghost"
+								className="absolute top-2 right-2"
+								size="icon-sm"
+							/>
+						}
+					>
+						<XIcon />
+						<span className="sr-only">Close</span>
+					</DialogPrimitive.Close>
+				)}
+			</DialogPrimitive.Popup>
+		</DialogPortal>
+	);
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="dialog-header"
+			className={cn("flex flex-col gap-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function DialogFooter({
+	className,
+	showCloseButton = false,
+	children,
+	...props
+}: React.ComponentProps<"div"> & {
+	showCloseButton?: boolean;
+}) {
+	return (
+		<div
+			data-slot="dialog-footer"
+			className={cn(
+				"-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 sm:flex-row sm:justify-end",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			{showCloseButton && (
+				<DialogPrimitive.Close render={<Button variant="outline" />}>
+					Close
+				</DialogPrimitive.Close>
+			)}
+		</div>
+	);
+}
+
+function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props) {
+	return (
+		<DialogPrimitive.Title
+			data-slot="dialog-title"
+			className={cn("text-base leading-none font-medium", className)}
+			{...props}
+		/>
+	);
+}
+
+function DialogDescription({
+	className,
+	...props
+}: DialogPrimitive.Description.Props) {
+	return (
+		<DialogPrimitive.Description
+			data-slot="dialog-description"
+			className={cn(
+				"text-sm text-muted-foreground *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Dialog,
+	DialogClose,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogOverlay,
+	DialogPortal,
+	DialogTitle,
+	DialogTrigger,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/dropdown-menu.tsx b/apps/cline-hub/src/webview/src/components/ui/dropdown-menu.tsx
new file mode 100644
index 0000000..8adbf40
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/dropdown-menu.tsx
@@ -0,0 +1,271 @@
+"use client";
+
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+import { CheckIcon, ChevronRightIcon } from "lucide-react";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+function DropdownMenu({ ...props }: MenuPrimitive.Root.Props) {
+	return <MenuPrimitive.Root data-slot="dropdown-menu" {...props} />;
+}
+
+function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props) {
+	return <MenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />;
+}
+
+function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props) {
+	return <MenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props} />;
+}
+
+function DropdownMenuContent({
+	align = "start",
+	alignOffset = 0,
+	side = "bottom",
+	sideOffset = 4,
+	className,
+	...props
+}: MenuPrimitive.Popup.Props &
+	Pick<
+		MenuPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<MenuPrimitive.Portal>
+			<MenuPrimitive.Positioner
+				className="isolate z-50 outline-none"
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+			>
+				<MenuPrimitive.Popup
+					data-slot="dropdown-menu-content"
+					className={cn(
+						"z-50 max-h-(--available-height) w-(--anchor-width) min-w-32 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 outline-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:overflow-hidden data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</MenuPrimitive.Positioner>
+		</MenuPrimitive.Portal>
+	);
+}
+
+function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props) {
+	return <MenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />;
+}
+
+function DropdownMenuLabel({
+	className,
+	inset,
+	...props
+}: MenuPrimitive.GroupLabel.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.GroupLabel
+			data-slot="dropdown-menu-label"
+			data-inset={inset}
+			className={cn(
+				"px-1.5 py-1 text-xs font-medium text-muted-foreground data-inset:pl-7",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: MenuPrimitive.Item.Props & {
+	inset?: boolean;
+	variant?: "default" | "destructive";
+}) {
+	return (
+		<MenuPrimitive.Item
+			data-slot="dropdown-menu-item"
+			data-inset={inset}
+			data-variant={variant}
+			className={cn(
+				"group/dropdown-menu-item relative flex cursor-pointer items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props) {
+	return <MenuPrimitive.SubmenuRoot data-slot="dropdown-menu-sub" {...props} />;
+}
+
+function DropdownMenuSubTrigger({
+	className,
+	inset,
+	children,
+	...props
+}: MenuPrimitive.SubmenuTrigger.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.SubmenuTrigger
+			data-slot="dropdown-menu-sub-trigger"
+			data-inset={inset}
+			className={cn(
+				"flex cursor-pointer items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-popup-open:bg-accent data-popup-open:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground data-disabled:cursor-not-allowed [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ChevronRightIcon className="ml-auto" />
+		</MenuPrimitive.SubmenuTrigger>
+	);
+}
+
+function DropdownMenuSubContent({
+	align = "start",
+	alignOffset = -3,
+	side = "right",
+	sideOffset = 0,
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuContent>) {
+	return (
+		<DropdownMenuContent
+			data-slot="dropdown-menu-sub-content"
+			className={cn(
+				"w-auto min-w-24 rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+				className,
+			)}
+			align={align}
+			alignOffset={alignOffset}
+			side={side}
+			sideOffset={sideOffset}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuCheckboxItem({
+	className,
+	children,
+	checked,
+	inset,
+	...props
+}: MenuPrimitive.CheckboxItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.CheckboxItem
+			data-slot="dropdown-menu-checkbox-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-pointer items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			checked={checked}
+			{...props}
+		>
+			<span
+				className="pointer-events-none absolute right-2 flex items-center justify-center"
+				data-slot="dropdown-menu-checkbox-item-indicator"
+			>
+				<MenuPrimitive.CheckboxItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.CheckboxItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.CheckboxItem>
+	);
+}
+
+function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props) {
+	return (
+		<MenuPrimitive.RadioGroup
+			data-slot="dropdown-menu-radio-group"
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuRadioItem({
+	className,
+	children,
+	inset,
+	...props
+}: MenuPrimitive.RadioItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.RadioItem
+			data-slot="dropdown-menu-radio-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-pointer items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<span
+				className="pointer-events-none absolute right-2 flex items-center justify-center"
+				data-slot="dropdown-menu-radio-item-indicator"
+			>
+				<MenuPrimitive.RadioItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.RadioItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.RadioItem>
+	);
+}
+
+function DropdownMenuSeparator({
+	className,
+	...props
+}: MenuPrimitive.Separator.Props) {
+	return (
+		<MenuPrimitive.Separator
+			data-slot="dropdown-menu-separator"
+			className={cn("-mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="dropdown-menu-shortcut"
+			className={cn(
+				"ml-auto text-xs tracking-widest text-muted-foreground group-focus/dropdown-menu-item:text-accent-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	DropdownMenu,
+	DropdownMenuPortal,
+	DropdownMenuTrigger,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuLabel,
+	DropdownMenuItem,
+	DropdownMenuCheckboxItem,
+	DropdownMenuRadioGroup,
+	DropdownMenuRadioItem,
+	DropdownMenuSeparator,
+	DropdownMenuShortcut,
+	DropdownMenuSub,
+	DropdownMenuSubTrigger,
+	DropdownMenuSubContent,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/hover-card.tsx b/apps/cline-hub/src/webview/src/components/ui/hover-card.tsx
new file mode 100644
index 0000000..2f7de14
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/hover-card.tsx
@@ -0,0 +1,60 @@
+"use client";
+
+import { PreviewCard as PreviewCardPrimitive } from "@base-ui/react/preview-card";
+
+import { cn } from "@/lib/utils";
+
+type HoverCardProps = PreviewCardPrimitive.Root.Props & {
+	openDelay?: number;
+	closeDelay?: number;
+};
+
+function HoverCard({
+	openDelay: _openDelay,
+	closeDelay: _closeDelay,
+	...props
+}: HoverCardProps) {
+	return <PreviewCardPrimitive.Root data-slot="hover-card" {...props} />;
+}
+
+function HoverCardTrigger({ ...props }: PreviewCardPrimitive.Trigger.Props) {
+	return (
+		<PreviewCardPrimitive.Trigger data-slot="hover-card-trigger" {...props} />
+	);
+}
+
+function HoverCardContent({
+	className,
+	side = "bottom",
+	sideOffset = 4,
+	align = "center",
+	alignOffset = 4,
+	...props
+}: PreviewCardPrimitive.Popup.Props &
+	Pick<
+		PreviewCardPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<PreviewCardPrimitive.Portal data-slot="hover-card-portal">
+			<PreviewCardPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+				className="isolate z-50"
+			>
+				<PreviewCardPrimitive.Popup
+					data-slot="hover-card-content"
+					className={cn(
+						"z-50 w-64 origin-(--transform-origin) rounded-lg bg-popover p-2.5 text-sm text-popover-foreground shadow-md ring-1 ring-foreground/10 outline-hidden duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</PreviewCardPrimitive.Positioner>
+		</PreviewCardPrimitive.Portal>
+	);
+}
+
+export { HoverCard, HoverCardTrigger, HoverCardContent };
diff --git a/apps/cline-hub/src/webview/src/components/ui/input-group.tsx b/apps/cline-hub/src/webview/src/components/ui/input-group.tsx
new file mode 100644
index 0000000..b7d1d60
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/input-group.tsx
@@ -0,0 +1,158 @@
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { cn } from "@/lib/utils";
+
+function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			data-slot="input-group"
+			role="group"
+			className={cn(
+				"group/input-group relative flex h-8 w-full min-w-0 items-center rounded-lg border border-input transition-colors outline-none in-data-[slot=combobox-content]:focus-within:border-inherit in-data-[slot=combobox-content]:focus-within:ring-0 has-disabled:bg-input/50 has-disabled:opacity-50 has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-3 has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot][aria-invalid=true]]:border-destructive has-[[data-slot][aria-invalid=true]]:ring-3 has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>textarea]:h-auto dark:bg-input/30 dark:has-disabled:bg-input/80 dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40 has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const inputGroupAddonVariants = cva(
+	"flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium text-muted-foreground select-none group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
+	{
+		variants: {
+			align: {
+				"inline-start":
+					"order-first pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem]",
+				"inline-end":
+					"order-last pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem]",
+				"block-start":
+					"order-first w-full justify-start px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2",
+				"block-end":
+					"order-last w-full justify-start px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2",
+			},
+		},
+		defaultVariants: {
+			align: "inline-start",
+		},
+	},
+);
+
+function InputGroupAddon({
+	className,
+	align = "inline-start",
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		// biome-ignore lint/a11y/useKeyWithClickEvents: click handler focuses input, not interactive
+		<div
+			role="group"
+			data-slot="input-group-addon"
+			data-align={align}
+			className={cn(inputGroupAddonVariants({ align }), className)}
+			onClick={(e) => {
+				if ((e.target as HTMLElement).closest("button")) {
+					return;
+				}
+				e.currentTarget.parentElement?.querySelector("input")?.focus();
+			}}
+			{...props}
+		/>
+	);
+}
+
+const inputGroupButtonVariants = cva(
+	"flex items-center gap-2 text-sm shadow-none",
+	{
+		variants: {
+			size: {
+				xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
+				sm: "",
+				"icon-xs":
+					"size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
+				"icon-sm": "size-8 p-0 has-[>svg]:p-0",
+			},
+		},
+		defaultVariants: {
+			size: "xs",
+		},
+	},
+);
+
+function InputGroupButton({
+	className,
+	type = "button",
+	variant = "ghost",
+	size = "xs",
+	...props
+}: Omit<React.ComponentProps<typeof Button>, "size" | "type"> &
+	VariantProps<typeof inputGroupButtonVariants> & {
+		type?: "button" | "submit" | "reset";
+	}) {
+	return (
+		<Button
+			type={type}
+			data-size={size}
+			variant={variant}
+			className={cn(inputGroupButtonVariants({ size }), className)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
+	return (
+		<span
+			className={cn(
+				"flex items-center gap-2 text-sm text-muted-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupInput({
+	className,
+	...props
+}: React.ComponentProps<"input">) {
+	return (
+		<Input
+			data-slot="input-group-control"
+			className={cn(
+				"flex-1 rounded-none border-0 bg-transparent shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupTextarea({
+	className,
+	...props
+}: React.ComponentProps<"textarea">) {
+	return (
+		<Textarea
+			data-slot="input-group-control"
+			className={cn(
+				"flex-1 resize-none rounded-none border-0 bg-transparent py-2 shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupText,
+	InputGroupInput,
+	InputGroupTextarea,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/input.tsx b/apps/cline-hub/src/webview/src/components/ui/input.tsx
new file mode 100644
index 0000000..bd4587d
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/input.tsx
@@ -0,0 +1,20 @@
+import { Input as InputPrimitive } from "@base-ui/react/input";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+	return (
+		<InputPrimitive
+			type={type}
+			data-slot="input"
+			className={cn(
+				"h-8 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Input };
diff --git a/apps/cline-hub/src/webview/src/components/ui/label.tsx b/apps/cline-hub/src/webview/src/components/ui/label.tsx
new file mode 100644
index 0000000..6e51bd3
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/label.tsx
@@ -0,0 +1,19 @@
+/** biome-ignore-all lint/a11y/noLabelWithoutControl: component root */
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Label({ className, ...props }: React.ComponentProps<"label">) {
+	return (
+		<label
+			data-slot="label"
+			className={cn(
+				"flex items-center gap-2 text-base leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Label };
diff --git a/apps/cline-hub/src/webview/src/components/ui/menubar.tsx b/apps/cline-hub/src/webview/src/components/ui/menubar.tsx
new file mode 100644
index 0000000..b48d347
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/menubar.tsx
@@ -0,0 +1,281 @@
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+import { Menubar as MenubarPrimitive } from "@base-ui/react/menubar";
+import { CheckIcon } from "lucide-react";
+import type * as React from "react";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuItem,
+	DropdownMenuLabel,
+	DropdownMenuPortal,
+	DropdownMenuRadioGroup,
+	DropdownMenuSeparator,
+	DropdownMenuShortcut,
+	DropdownMenuSub,
+	DropdownMenuSubContent,
+	DropdownMenuSubTrigger,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { cn } from "@/lib/utils";
+
+function Menubar({ className, ...props }: MenubarPrimitive.Props) {
+	return (
+		<MenubarPrimitive
+			data-slot="menubar"
+			className={cn(
+				"flex h-8 items-center gap-0.5 rounded-lg border p-0.75",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarMenu({ ...props }: React.ComponentProps<typeof DropdownMenu>) {
+	return <DropdownMenu data-slot="menubar-menu" {...props} />;
+}
+
+function MenubarGroup({
+	...props
+}: React.ComponentProps<typeof DropdownMenuGroup>) {
+	return <DropdownMenuGroup data-slot="menubar-group" {...props} />;
+}
+
+function MenubarPortal({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPortal>) {
+	return <DropdownMenuPortal data-slot="menubar-portal" {...props} />;
+}
+
+function MenubarTrigger({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuTrigger>) {
+	return (
+		<DropdownMenuTrigger
+			data-slot="menubar-trigger"
+			className={cn(
+				"flex cursor-pointer items-center rounded-sm px-1.5 py-0.5 text-sm font-medium outline-hidden select-none hover:bg-muted aria-expanded:bg-muted",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarContent({
+	className,
+	align = "start",
+	alignOffset = -4,
+	sideOffset = 8,
+	...props
+}: React.ComponentProps<typeof DropdownMenuContent>) {
+	return (
+		<DropdownMenuContent
+			data-slot="menubar-content"
+			align={align}
+			alignOffset={alignOffset}
+			sideOffset={sideOffset}
+			className={cn(
+				"min-w-36 rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: React.ComponentProps<typeof DropdownMenuItem>) {
+	return (
+		<DropdownMenuItem
+			data-slot="menubar-item"
+			data-inset={inset}
+			data-variant={variant}
+			className={cn(
+				"group/menubar-item gap-1.5 rounded-md px-1.5 py-1 text-sm focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:opacity-50 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive!",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarCheckboxItem({
+	className,
+	children,
+	checked,
+	inset,
+	...props
+}: MenuPrimitive.CheckboxItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.CheckboxItem
+			data-slot="menubar-checkbox-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-pointer items-center gap-1.5 rounded-md py-1 pr-1.5 pl-7 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+				className,
+			)}
+			checked={checked}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-1.5 flex size-4 items-center justify-center [&_svg:not([class*='size-'])]:size-4">
+				<MenuPrimitive.CheckboxItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.CheckboxItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.CheckboxItem>
+	);
+}
+
+function MenubarRadioGroup({
+	...props
+}: React.ComponentProps<typeof DropdownMenuRadioGroup>) {
+	return <DropdownMenuRadioGroup data-slot="menubar-radio-group" {...props} />;
+}
+
+function MenubarRadioItem({
+	className,
+	children,
+	inset,
+	...props
+}: MenuPrimitive.RadioItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.RadioItem
+			data-slot="menubar-radio-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-pointer items-center gap-1.5 rounded-md py-1 pr-1.5 pl-7 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-1.5 flex size-4 items-center justify-center [&_svg:not([class*='size-'])]:size-4">
+				<MenuPrimitive.RadioItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.RadioItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.RadioItem>
+	);
+}
+
+function MenubarLabel({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof DropdownMenuLabel> & {
+	inset?: boolean;
+}) {
+	return (
+		<DropdownMenuLabel
+			data-slot="menubar-label"
+			data-inset={inset}
+			className={cn(
+				"px-1.5 py-1 text-sm font-medium data-inset:pl-7",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuSeparator>) {
+	return (
+		<DropdownMenuSeparator
+			data-slot="menubar-separator"
+			className={cn("-mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarShortcut({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuShortcut>) {
+	return (
+		<DropdownMenuShortcut
+			data-slot="menubar-shortcut"
+			className={cn(
+				"ml-auto text-xs tracking-widest text-muted-foreground group-focus/menubar-item:text-accent-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarSub({
+	...props
+}: React.ComponentProps<typeof DropdownMenuSub>) {
+	return <DropdownMenuSub data-slot="menubar-sub" {...props} />;
+}
+
+function MenubarSubTrigger({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof DropdownMenuSubTrigger> & {
+	inset?: boolean;
+}) {
+	return (
+		<DropdownMenuSubTrigger
+			data-slot="menubar-sub-trigger"
+			data-inset={inset}
+			className={cn(
+				"gap-1.5 rounded-md px-1.5 py-1 text-sm focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-open:bg-accent data-open:text-accent-foreground [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarSubContent({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuSubContent>) {
+	return (
+		<DropdownMenuSubContent
+			data-slot="menubar-sub-content"
+			className={cn(
+				"min-w-32 rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Menubar,
+	MenubarPortal,
+	MenubarMenu,
+	MenubarTrigger,
+	MenubarContent,
+	MenubarGroup,
+	MenubarSeparator,
+	MenubarLabel,
+	MenubarItem,
+	MenubarShortcut,
+	MenubarCheckboxItem,
+	MenubarRadioGroup,
+	MenubarRadioItem,
+	MenubarSub,
+	MenubarSubTrigger,
+	MenubarSubContent,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/native-select.tsx b/apps/cline-hub/src/webview/src/components/ui/native-select.tsx
new file mode 100644
index 0000000..b37372d
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/native-select.tsx
@@ -0,0 +1,61 @@
+import { ChevronDownIcon } from "lucide-react";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+type NativeSelectProps = Omit<React.ComponentProps<"select">, "size"> & {
+	size?: "sm" | "default";
+};
+
+function NativeSelect({
+	className,
+	size = "default",
+	...props
+}: NativeSelectProps) {
+	return (
+		<div
+			className={cn(
+				"group/native-select relative w-fit has-[select:disabled]:opacity-50",
+				className,
+			)}
+			data-slot="native-select-wrapper"
+			data-size={size}
+		>
+			<select
+				data-slot="native-select"
+				data-size={size}
+				className="h-full w-full min-w-0 cursor-pointer appearance-none rounded-lg border border-input bg-transparent py-1 pr-8 pl-2.5 text-sm transition-colors outline-none select-none selection:bg-primary selection:text-primary-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] data-[size=sm]:py-0.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40"
+				{...props}
+			/>
+			<ChevronDownIcon
+				className="pointer-events-none absolute top-1/2 right-2.5 size-4 -translate-y-1/2 text-muted-foreground select-none"
+				aria-hidden="true"
+				data-slot="native-select-icon"
+			/>
+		</div>
+	);
+}
+
+function NativeSelectOption({ ...props }: React.ComponentProps<"option">) {
+	return (
+		<option
+			data-slot="native-select-option"
+			className={cn("text-sm", props.className)}
+			{...props}
+		/>
+	);
+}
+
+function NativeSelectOptGroup({
+	className,
+	...props
+}: React.ComponentProps<"optgroup">) {
+	return (
+		<optgroup
+			data-slot="native-select-optgroup"
+			className={cn("text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };
diff --git a/apps/cline-hub/src/webview/src/components/ui/popover.tsx b/apps/cline-hub/src/webview/src/components/ui/popover.tsx
new file mode 100644
index 0000000..53ece87
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/popover.tsx
@@ -0,0 +1,88 @@
+import { Popover as PopoverPrimitive } from "@base-ui/react/popover";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Popover({ ...props }: PopoverPrimitive.Root.Props) {
+	return <PopoverPrimitive.Root data-slot="popover" {...props} />;
+}
+
+function PopoverTrigger({ ...props }: PopoverPrimitive.Trigger.Props) {
+	return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />;
+}
+
+function PopoverContent({
+	className,
+	align = "center",
+	alignOffset = 0,
+	side = "bottom",
+	sideOffset = 4,
+	...props
+}: PopoverPrimitive.Popup.Props &
+	Pick<
+		PopoverPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<PopoverPrimitive.Portal>
+			<PopoverPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+				className="isolate z-50"
+			>
+				<PopoverPrimitive.Popup
+					data-slot="popover-content"
+					className={cn(
+						"z-50 flex w-72 origin-(--transform-origin) flex-col gap-2.5 rounded-lg bg-popover p-2.5 text-sm text-popover-foreground shadow-md ring-1 ring-foreground/10 outline-hidden duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</PopoverPrimitive.Positioner>
+		</PopoverPrimitive.Portal>
+	);
+}
+
+function PopoverHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="popover-header"
+			className={cn("flex flex-col gap-0.5 text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function PopoverTitle({ className, ...props }: PopoverPrimitive.Title.Props) {
+	return (
+		<PopoverPrimitive.Title
+			data-slot="popover-title"
+			className={cn("font-medium", className)}
+			{...props}
+		/>
+	);
+}
+
+function PopoverDescription({
+	className,
+	...props
+}: PopoverPrimitive.Description.Props) {
+	return (
+		<PopoverPrimitive.Description
+			data-slot="popover-description"
+			className={cn("text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Popover,
+	PopoverContent,
+	PopoverDescription,
+	PopoverHeader,
+	PopoverTitle,
+	PopoverTrigger,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/progress.tsx b/apps/cline-hub/src/webview/src/components/ui/progress.tsx
new file mode 100644
index 0000000..b32896f
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/progress.tsx
@@ -0,0 +1,81 @@
+import { Progress as ProgressPrimitive } from "@base-ui/react/progress";
+
+import { cn } from "@/lib/utils";
+
+function Progress({
+	className,
+	children,
+	value,
+	...props
+}: ProgressPrimitive.Root.Props) {
+	return (
+		<ProgressPrimitive.Root
+			value={value}
+			data-slot="progress"
+			className={cn("flex flex-wrap gap-3", className)}
+			{...props}
+		>
+			{children}
+			<ProgressTrack>
+				<ProgressIndicator />
+			</ProgressTrack>
+		</ProgressPrimitive.Root>
+	);
+}
+
+function ProgressTrack({ className, ...props }: ProgressPrimitive.Track.Props) {
+	return (
+		<ProgressPrimitive.Track
+			className={cn(
+				"relative flex h-1 w-full items-center overflow-x-hidden rounded-full bg-muted",
+				className,
+			)}
+			data-slot="progress-track"
+			{...props}
+		/>
+	);
+}
+
+function ProgressIndicator({
+	className,
+	...props
+}: ProgressPrimitive.Indicator.Props) {
+	return (
+		<ProgressPrimitive.Indicator
+			data-slot="progress-indicator"
+			className={cn("h-full bg-primary transition-all", className)}
+			{...props}
+		/>
+	);
+}
+
+function ProgressLabel({ className, ...props }: ProgressPrimitive.Label.Props) {
+	return (
+		<ProgressPrimitive.Label
+			className={cn("text-sm font-medium", className)}
+			data-slot="progress-label"
+			{...props}
+		/>
+	);
+}
+
+function ProgressValue({ className, ...props }: ProgressPrimitive.Value.Props) {
+	return (
+		<ProgressPrimitive.Value
+			className={cn(
+				"ml-auto text-sm text-muted-foreground tabular-nums",
+				className,
+			)}
+			data-slot="progress-value"
+			{...props}
+		/>
+	);
+}
+
+export {
+	Progress,
+	ProgressTrack,
+	ProgressIndicator,
+	ProgressLabel,
+	ProgressValue,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/radio-group.tsx b/apps/cline-hub/src/webview/src/components/ui/radio-group.tsx
new file mode 100644
index 0000000..196eb68
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/radio-group.tsx
@@ -0,0 +1,36 @@
+import { Radio as RadioPrimitive } from "@base-ui/react/radio";
+import { RadioGroup as RadioGroupPrimitive } from "@base-ui/react/radio-group";
+
+import { cn } from "@/lib/utils";
+
+function RadioGroup({ className, ...props }: RadioGroupPrimitive.Props) {
+	return (
+		<RadioGroupPrimitive
+			data-slot="radio-group"
+			className={cn("grid w-full gap-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function RadioGroupItem({ className, ...props }: RadioPrimitive.Root.Props) {
+	return (
+		<RadioPrimitive.Root
+			data-slot="radio-group-item"
+			className={cn(
+				"group/radio-group-item peer relative flex aspect-square size-4 shrink-0 cursor-pointer rounded-full border border-input outline-none after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 data-disabled:cursor-not-allowed aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground dark:data-checked:bg-primary",
+				className,
+			)}
+			{...props}
+		>
+			<RadioPrimitive.Indicator
+				data-slot="radio-group-indicator"
+				className="flex size-4 items-center justify-center"
+			>
+				<span className="absolute top-1/2 left-1/2 size-2 -translate-x-1/2 -translate-y-1/2 rounded-full bg-primary-foreground" />
+			</RadioPrimitive.Indicator>
+		</RadioPrimitive.Root>
+	);
+}
+
+export { RadioGroup, RadioGroupItem };
diff --git a/apps/cline-hub/src/webview/src/components/ui/scroll-area.tsx b/apps/cline-hub/src/webview/src/components/ui/scroll-area.tsx
new file mode 100644
index 0000000..d4ee997
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/scroll-area.tsx
@@ -0,0 +1,52 @@
+import { ScrollArea as ScrollAreaPrimitive } from "@base-ui/react/scroll-area";
+
+import { cn } from "@/lib/utils";
+
+function ScrollArea({
+	className,
+	children,
+	...props
+}: ScrollAreaPrimitive.Root.Props) {
+	return (
+		<ScrollAreaPrimitive.Root
+			data-slot="scroll-area"
+			className={cn("relative", className)}
+			{...props}
+		>
+			<ScrollAreaPrimitive.Viewport
+				data-slot="scroll-area-viewport"
+				className="size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1"
+			>
+				{children}
+			</ScrollAreaPrimitive.Viewport>
+			<ScrollBar />
+			<ScrollAreaPrimitive.Corner />
+		</ScrollAreaPrimitive.Root>
+	);
+}
+
+function ScrollBar({
+	className,
+	orientation = "vertical",
+	...props
+}: ScrollAreaPrimitive.Scrollbar.Props) {
+	return (
+		<ScrollAreaPrimitive.Scrollbar
+			data-slot="scroll-area-scrollbar"
+			data-orientation={orientation}
+			orientation={orientation}
+			className={cn(
+				"flex touch-none p-px transition-colors select-none data-horizontal:h-2.5 data-horizontal:flex-col data-horizontal:border-t data-horizontal:border-t-transparent data-vertical:h-full data-vertical:w-2.5 data-vertical:border-l data-vertical:border-l-transparent",
+				className,
+			)}
+			{...props}
+		>
+			<ScrollAreaPrimitive.Thumb
+				data-slot="scroll-area-thumb"
+				className="relative flex-1 rounded-full bg-border"
+			/>
+		</ScrollAreaPrimitive.Scrollbar>
+	);
+}
+
+export { ScrollArea, ScrollBar };
diff --git a/apps/cline-hub/src/webview/src/components/ui/select.tsx b/apps/cline-hub/src/webview/src/components/ui/select.tsx
new file mode 100644
index 0000000..e0da95d
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/select.tsx
@@ -0,0 +1,199 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+const Select = SelectPrimitive.Root;
+
+function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props) {
+	return (
+		<SelectPrimitive.Group
+			data-slot="select-group"
+			className={cn("scroll-my-1 p-1", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectValue({ className, ...props }: SelectPrimitive.Value.Props) {
+	return (
+		<SelectPrimitive.Value
+			data-slot="select-value"
+			className={cn("flex flex-1 text-left", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectTrigger({
+	className,
+	size = "default",
+	children,
+	...props
+}: SelectPrimitive.Trigger.Props & {
+	size?: "sm" | "default";
+}) {
+	return (
+		<SelectPrimitive.Trigger
+			data-slot="select-trigger"
+			data-size={size}
+			className={cn(
+				"flex w-fit cursor-pointer items-center justify-between gap-1.5 rounded-lg border border-input bg-transparent py-2 pr-2 pl-2.5 text-sm whitespace-nowrap transition-colors outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-placeholder:text-muted-foreground data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-1.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<SelectPrimitive.Icon
+				render={
+					<ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+				}
+			/>
+		</SelectPrimitive.Trigger>
+	);
+}
+
+function SelectContent({
+	className,
+	children,
+	side = "bottom",
+	sideOffset = 4,
+	align = "center",
+	alignOffset = 0,
+	alignItemWithTrigger = true,
+	...props
+}: SelectPrimitive.Popup.Props &
+	Pick<
+		SelectPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger"
+	>) {
+	return (
+		<SelectPrimitive.Portal>
+			<SelectPrimitive.Positioner
+				side={side}
+				sideOffset={sideOffset}
+				align={align}
+				alignOffset={alignOffset}
+				alignItemWithTrigger={alignItemWithTrigger}
+				className="isolate z-50"
+			>
+				<SelectPrimitive.Popup
+					data-slot="select-content"
+					data-align-trigger={alignItemWithTrigger}
+					className={cn(
+						"relative isolate z-50 max-h-(--available-height) w-(--anchor-width) min-w-36 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[align-trigger=true]:animate-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				>
+					<SelectScrollUpButton />
+					<SelectPrimitive.List>{children}</SelectPrimitive.List>
+					<SelectScrollDownButton />
+				</SelectPrimitive.Popup>
+			</SelectPrimitive.Positioner>
+		</SelectPrimitive.Portal>
+	);
+}
+
+function SelectLabel({
+	className,
+	...props
+}: SelectPrimitive.GroupLabel.Props) {
+	return (
+		<SelectPrimitive.GroupLabel
+			data-slot="select-label"
+			className={cn("px-1.5 py-1 text-xs text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectItem({
+	className,
+	children,
+	...props
+}: SelectPrimitive.Item.Props) {
+	return (
+		<SelectPrimitive.Item
+			data-slot="select-item"
+			className={cn(
+				"relative flex w-full cursor-pointer items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+				className,
+			)}
+			{...props}
+		>
+			<SelectPrimitive.ItemText className="flex flex-1 shrink-0 gap-2 whitespace-nowrap">
+				{children}
+			</SelectPrimitive.ItemText>
+			<SelectPrimitive.ItemIndicator
+				render={
+					<span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
+				}
+			>
+				<CheckIcon className="pointer-events-none" />
+			</SelectPrimitive.ItemIndicator>
+		</SelectPrimitive.Item>
+	);
+}
+
+function SelectSeparator({
+	className,
+	...props
+}: SelectPrimitive.Separator.Props) {
+	return (
+		<SelectPrimitive.Separator
+			data-slot="select-separator"
+			className={cn("pointer-events-none -mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectScrollUpButton({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>) {
+	return (
+		<SelectPrimitive.ScrollUpArrow
+			data-slot="select-scroll-up-button"
+			className={cn(
+				"top-0 z-10 flex w-full cursor-pointer items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronUpIcon />
+		</SelectPrimitive.ScrollUpArrow>
+	);
+}
+
+function SelectScrollDownButton({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>) {
+	return (
+		<SelectPrimitive.ScrollDownArrow
+			data-slot="select-scroll-down-button"
+			className={cn(
+				"bottom-0 z-10 flex w-full cursor-pointer items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronDownIcon />
+		</SelectPrimitive.ScrollDownArrow>
+	);
+}
+
+export {
+	Select,
+	SelectContent,
+	SelectGroup,
+	SelectItem,
+	SelectLabel,
+	SelectScrollDownButton,
+	SelectScrollUpButton,
+	SelectSeparator,
+	SelectTrigger,
+	SelectValue,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/separator.tsx b/apps/cline-hub/src/webview/src/components/ui/separator.tsx
new file mode 100644
index 0000000..d59473a
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/separator.tsx
@@ -0,0 +1,25 @@
+"use client";
+
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+
+import { cn } from "@/lib/utils";
+
+function Separator({
+	className,
+	orientation = "horizontal",
+	...props
+}: SeparatorPrimitive.Props) {
+	return (
+		<SeparatorPrimitive
+			data-slot="separator"
+			orientation={orientation}
+			className={cn(
+				"shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Separator };
diff --git a/apps/cline-hub/src/webview/src/components/ui/sonner.tsx b/apps/cline-hub/src/webview/src/components/ui/sonner.tsx
new file mode 100644
index 0000000..ba46244
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/sonner.tsx
@@ -0,0 +1,43 @@
+import {
+	CircleCheckIcon,
+	InfoIcon,
+	Loader2Icon,
+	OctagonXIcon,
+	TriangleAlertIcon,
+} from "lucide-react";
+import { useTheme } from "next-themes";
+import { Toaster as Sonner, type ToasterProps } from "sonner";
+
+const Toaster = ({ ...props }: ToasterProps) => {
+	const { theme = "system" } = useTheme();
+
+	return (
+		<Sonner
+			theme={theme as ToasterProps["theme"]}
+			className="toaster group"
+			icons={{
+				success: <CircleCheckIcon className="size-4" />,
+				info: <InfoIcon className="size-4" />,
+				warning: <TriangleAlertIcon className="size-4" />,
+				error: <OctagonXIcon className="size-4" />,
+				loading: <Loader2Icon className="size-4 animate-spin" />,
+			}}
+			style={
+				{
+					"--normal-bg": "var(--popover)",
+					"--normal-text": "var(--popover-foreground)",
+					"--normal-border": "var(--border)",
+					"--border-radius": "var(--radius)",
+				} as React.CSSProperties
+			}
+			toastOptions={{
+				classNames: {
+					toast: "cn-toast",
+				},
+			}}
+			{...props}
+		/>
+	);
+};
+
+export { Toaster };
diff --git a/apps/cline-hub/src/webview/src/components/ui/spinner.tsx b/apps/cline-hub/src/webview/src/components/ui/spinner.tsx
new file mode 100644
index 0000000..2c29440
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/spinner.tsx
@@ -0,0 +1,15 @@
+import { Loader2Icon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+function Spinner({ className, ...props }: React.ComponentProps<"svg">) {
+	return (
+		<Loader2Icon
+			role="status"
+			aria-label="Loading"
+			className={cn("size-4 animate-spin", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Spinner };
diff --git a/apps/cline-hub/src/webview/src/components/ui/switch.tsx b/apps/cline-hub/src/webview/src/components/ui/switch.tsx
new file mode 100644
index 0000000..a0bc0b8
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/switch.tsx
@@ -0,0 +1,32 @@
+"use client";
+
+import { Switch as SwitchPrimitive } from "@base-ui/react/switch";
+
+import { cn } from "@/lib/utils";
+
+function Switch({
+	className,
+	size = "default",
+	...props
+}: SwitchPrimitive.Root.Props & {
+	size?: "sm" | "default";
+}) {
+	return (
+		<SwitchPrimitive.Root
+			data-slot="switch"
+			data-size={size}
+			className={cn(
+				"peer group/switch relative inline-flex cursor-pointer shrink-0 items-center rounded-full border border-transparent transition-all outline-none after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-[size=default]:h-[18.4px] data-[size=default]:w-8 data-[size=sm]:h-3.5 data-[size=sm]:w-6 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:bg-primary data-unchecked:bg-input dark:data-unchecked:bg-input/80 data-disabled:cursor-not-allowed data-disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		>
+			<SwitchPrimitive.Thumb
+				data-slot="switch-thumb"
+				className="pointer-events-none block rounded-full bg-background ring-0 transition-transform group-data-[size=default]/switch:size-4 group-data-[size=sm]/switch:size-3 group-data-[size=default]/switch:data-checked:translate-x-[calc(100%-2px)] group-data-[size=sm]/switch:data-checked:translate-x-[calc(100%-2px)] dark:data-checked:bg-primary-foreground group-data-[size=default]/switch:data-unchecked:translate-x-0 group-data-[size=sm]/switch:data-unchecked:translate-x-0 dark:data-unchecked:bg-foreground"
+			/>
+		</SwitchPrimitive.Root>
+	);
+}
+
+export { Switch };
diff --git a/apps/cline-hub/src/webview/src/components/ui/table.tsx b/apps/cline-hub/src/webview/src/components/ui/table.tsx
new file mode 100644
index 0000000..c607f39
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/table.tsx
@@ -0,0 +1,114 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Table({ className, ...props }: React.ComponentProps<"table">) {
+	return (
+		<div
+			data-slot="table-container"
+			className="relative w-full overflow-x-auto"
+		>
+			<table
+				data-slot="table"
+				className={cn("w-full caption-bottom text-sm", className)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function TableHeader({ className, ...props }: React.ComponentProps<"thead">) {
+	return (
+		<thead
+			data-slot="table-header"
+			className={cn("[&_tr]:border-b", className)}
+			{...props}
+		/>
+	);
+}
+
+function TableBody({ className, ...props }: React.ComponentProps<"tbody">) {
+	return (
+		<tbody
+			data-slot="table-body"
+			className={cn("[&_tr:last-child]:border-0", className)}
+			{...props}
+		/>
+	);
+}
+
+function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">) {
+	return (
+		<tfoot
+			data-slot="table-footer"
+			className={cn(
+				"border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableRow({ className, ...props }: React.ComponentProps<"tr">) {
+	return (
+		<tr
+			data-slot="table-row"
+			className={cn(
+				"border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableHead({ className, ...props }: React.ComponentProps<"th">) {
+	return (
+		<th
+			data-slot="table-head"
+			className={cn(
+				"h-10 px-2 text-left align-middle font-medium whitespace-nowrap text-foreground [&:has([role=checkbox])]:pr-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableCell({ className, ...props }: React.ComponentProps<"td">) {
+	return (
+		<td
+			data-slot="table-cell"
+			className={cn(
+				"p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableCaption({
+	className,
+	...props
+}: React.ComponentProps<"caption">) {
+	return (
+		<caption
+			data-slot="table-caption"
+			className={cn("mt-4 text-sm text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Table,
+	TableHeader,
+	TableBody,
+	TableFooter,
+	TableHead,
+	TableRow,
+	TableCell,
+	TableCaption,
+};
diff --git a/apps/cline-hub/src/webview/src/components/ui/tabs.tsx b/apps/cline-hub/src/webview/src/components/ui/tabs.tsx
new file mode 100644
index 0000000..7f2601b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/tabs.tsx
@@ -0,0 +1,82 @@
+"use client";
+
+import { Tabs as TabsPrimitive } from "@base-ui/react/tabs";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+function Tabs({
+	className,
+	orientation = "horizontal",
+	...props
+}: TabsPrimitive.Root.Props) {
+	return (
+		<TabsPrimitive.Root
+			data-slot="tabs"
+			data-orientation={orientation}
+			className={cn(
+				"group/tabs flex gap-2 data-horizontal:flex-col",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const tabsListVariants = cva(
+	"group/tabs-list inline-flex w-fit items-center justify-center rounded-lg p-[3px] text-muted-foreground group-data-horizontal/tabs:h-8 group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col data-[variant=line]:rounded-none",
+	{
+		variants: {
+			variant: {
+				default: "bg-muted",
+				line: "gap-1 bg-transparent",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function TabsList({
+	className,
+	variant = "default",
+	...props
+}: TabsPrimitive.List.Props & VariantProps<typeof tabsListVariants>) {
+	return (
+		<TabsPrimitive.List
+			data-slot="tabs-list"
+			data-variant={variant}
+			className={cn(tabsListVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+}
+
+function TabsTrigger({ className, ...props }: TabsPrimitive.Tab.Props) {
+	return (
+		<TabsPrimitive.Tab
+			data-slot="tabs-trigger"
+			className={cn(
+				"relative inline-flex h-[calc(100%-1px)] flex-1 cursor-pointer items-center justify-center gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:cursor-not-allowed aria-disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				"group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent",
+				"data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground",
+				"after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TabsContent({ className, ...props }: TabsPrimitive.Panel.Props) {
+	return (
+		<TabsPrimitive.Panel
+			data-slot="tabs-content"
+			className={cn("flex-1 text-sm outline-none", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };
diff --git a/apps/cline-hub/src/webview/src/components/ui/textarea.tsx b/apps/cline-hub/src/webview/src/components/ui/textarea.tsx
new file mode 100644
index 0000000..ed00973
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/textarea.tsx
@@ -0,0 +1,18 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
+	return (
+		<textarea
+			data-slot="textarea"
+			className={cn(
+				"flex field-sizing-content min-h-16 w-full rounded-lg border border-input bg-transparent px-2.5 py-2 text-base transition-colors outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Textarea };
diff --git a/apps/cline-hub/src/webview/src/components/ui/tooltip.tsx b/apps/cline-hub/src/webview/src/components/ui/tooltip.tsx
new file mode 100644
index 0000000..eb05aca
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/ui/tooltip.tsx
@@ -0,0 +1,64 @@
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip";
+
+import { cn } from "@/lib/utils";
+
+function TooltipProvider({
+	delay = 0,
+	...props
+}: TooltipPrimitive.Provider.Props) {
+	return (
+		<TooltipPrimitive.Provider
+			data-slot="tooltip-provider"
+			delay={delay}
+			{...props}
+		/>
+	);
+}
+
+function Tooltip({ ...props }: TooltipPrimitive.Root.Props) {
+	return <TooltipPrimitive.Root data-slot="tooltip" {...props} />;
+}
+
+function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props) {
+	return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+}
+
+function TooltipContent({
+	className,
+	side = "top",
+	sideOffset = 4,
+	align = "center",
+	alignOffset = 0,
+	children,
+	...props
+}: TooltipPrimitive.Popup.Props &
+	Pick<
+		TooltipPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<TooltipPrimitive.Portal>
+			<TooltipPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+				className="isolate z-50"
+			>
+				<TooltipPrimitive.Popup
+					data-slot="tooltip-content"
+					className={cn(
+						"z-50 inline-flex w-fit max-w-xs origin-(--transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+					<TooltipPrimitive.Arrow className="z-50 size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground data-[side=bottom]:top-1 data-[side=inline-end]:top-1/2! data-[side=inline-end]:-left-1 data-[side=inline-end]:-translate-y-1/2 data-[side=inline-start]:top-1/2! data-[side=inline-start]:-right-1 data-[side=inline-start]:-translate-y-1/2 data-[side=left]:top-1/2! data-[side=left]:-right-1 data-[side=left]:-translate-y-1/2 data-[side=right]:top-1/2! data-[side=right]:-left-1 data-[side=right]:-translate-y-1/2 data-[side=top]:-bottom-2.5" />
+				</TooltipPrimitive.Popup>
+			</TooltipPrimitive.Positioner>
+		</TooltipPrimitive.Portal>
+	);
+}
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
diff --git a/apps/cline-hub/src/webview/src/components/views/marketplace-view.tsx b/apps/cline-hub/src/webview/src/components/views/marketplace-view.tsx
new file mode 100644
index 0000000..0f9ef3b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/marketplace-view.tsx
@@ -0,0 +1,1011 @@
+import {
+	ExternalLink,
+	Puzzle,
+	Search,
+	Server,
+	Star,
+	Trash2,
+	Zap,
+} from "lucide-react";
+import {
+	type CSSProperties,
+	type MouseEvent,
+	type ReactNode,
+	useEffect,
+	useMemo,
+	useState,
+} from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Spinner } from "@/components/ui/spinner";
+import { desktopClient } from "@/lib/desktop-client";
+import {
+	fetchMarketplaceCatalog,
+	type MarketplaceCatalog,
+	type MarketplaceEntry,
+	type MarketplacePrimitiveType,
+	type MarketplaceTag,
+} from "@/lib/marketplace";
+import { cn } from "@/lib/utils";
+import { CommandBadge, PageFrame, PageHeader } from "./page-layout";
+
+type EntryActionState =
+	| { status: "idle" }
+	| { status: "installing" }
+	| { status: "uninstalling" }
+	| {
+			status: "installed";
+			message: string;
+	  }
+	| {
+			status: "uninstalled";
+			message: string;
+	  }
+	| { status: "failed"; message: string };
+
+type MarketplaceInstallResult = {
+	status: "installed" | "uninstalled";
+	message: string;
+	output?: string;
+};
+
+type MarketplaceInstallStatusResult = {
+	installedKeys: string[];
+};
+
+type InstalledStatusState = "loading" | "ready";
+
+const INSTALL_TIMEOUT_MS = 300_000;
+const CODE_FONT_STYLE: CSSProperties = {
+	fontFamily:
+		'ui-monospace, "SFMono-Regular", Menlo, Consolas, "Liberation Mono", monospace',
+};
+
+const primitivePageDetails = {
+	mcp: {
+		title: "MCP Servers",
+		description:
+			"Install Model Context Protocol servers into this CLI environment.",
+		emptyInstalled: "No MCP servers installed.",
+		emptyCatalog: "No MCP servers match the current filters.",
+		icon: Server,
+	},
+	skill: {
+		title: "Skills",
+		description: "Install skills globally for Cline.",
+		emptyInstalled: "No skills installed.",
+		emptyCatalog: "No skills match the current filters.",
+		icon: Zap,
+	},
+	plugin: {
+		title: "Plugins",
+		description: "Install plugins into this CLI environment.",
+		emptyInstalled: "No plugins installed.",
+		emptyCatalog: "No plugins match the current filters.",
+		icon: Puzzle,
+	},
+} satisfies Record<
+	MarketplacePrimitiveType,
+	{
+		title: string;
+		description: string;
+		emptyInstalled: string;
+		emptyCatalog: string;
+		icon: typeof Server;
+	}
+>;
+
+const primitiveCommands = {
+	mcp: "cline mcp install",
+	plugin: "cline plugin install",
+	skill: "cline skill add",
+} satisfies Record<MarketplacePrimitiveType, string>;
+
+export type MarketplaceLocalInstalledItem = {
+	key: string;
+	matchValues: string[];
+	render: () => ReactNode;
+	renderMatchedBadges?: () => ReactNode;
+	renderMatchedControls?: () => ReactNode;
+	renderMatchedDetails?: () => ReactNode;
+	renderMatchedMeta?: () => ReactNode;
+};
+
+function entryKey(entry: Pick<MarketplaceEntry, "id" | "type">): string {
+	return `${entry.type}:${entry.id}`;
+}
+
+function compareFeaturedEntries(
+	left: MarketplaceEntry,
+	right: MarketplaceEntry,
+): number {
+	return Number(Boolean(right.featured)) - Number(Boolean(left.featured));
+}
+
+function normalizeMatchValue(value: string): string {
+	return value.trim().toLowerCase();
+}
+
+function entryMatchValues(entry: MarketplaceEntry): Set<string> {
+	return new Set(
+		[entry.id, entry.name, ...entry.install.args]
+			.map(normalizeMatchValue)
+			.filter(Boolean),
+	);
+}
+
+function entryMatchesLocalItem(
+	entry: MarketplaceEntry,
+	item: MarketplaceLocalInstalledItem,
+): boolean {
+	const entryValues = entryMatchValues(entry);
+	return item.matchValues
+		.map(normalizeMatchValue)
+		.filter(Boolean)
+		.some((value) => entryValues.has(value));
+}
+
+function entrySearchText(
+	entry: MarketplaceEntry,
+	tagLabels: Map<string, string>,
+): string {
+	return [
+		entry.name,
+		entry.tagline,
+		entry.description,
+		entry.type,
+		...entry.tags.map((tag) => tagLabels.get(tag) ?? tag),
+	]
+		.join(" ")
+		.toLowerCase();
+}
+
+function actionMessage(
+	state: EntryActionState | undefined,
+): string | undefined {
+	if (
+		state?.status === "installed" ||
+		state?.status === "uninstalled" ||
+		state?.status === "failed"
+	) {
+		return state.message;
+	}
+	return undefined;
+}
+
+function EntryDetails({
+	actionState,
+	entry,
+}: {
+	actionState: EntryActionState | undefined;
+	entry: MarketplaceEntry;
+}) {
+	const requiredEnv =
+		entry.install.env?.filter((env) => env.required !== false) ?? [];
+	const optionalEnv =
+		entry.install.env?.filter((env) => env.required === false) ?? [];
+	const hasSetupDetails =
+		requiredEnv.length > 0 ||
+		optionalEnv.length > 0 ||
+		Boolean(entry.install.notes) ||
+		actionState?.status === "failed";
+
+	if (!hasSetupDetails) {
+		return null;
+	}
+
+	return (
+		<div className="grid gap-3 border-t pt-3" data-marketplace-entry-details>
+			{requiredEnv.length > 0 || optionalEnv.length > 0 ? (
+				<div className="rounded-lg border border-amber-500/30 bg-amber-500/10 p-3">
+					<p className="text-sm font-medium text-amber-800 dark:text-amber-200">
+						Environment setup needed
+					</p>
+					<p className="mt-1 text-xs leading-5 text-amber-800/80 dark:text-amber-100/80">
+						Add these values to your Cline/plugin environment after install.
+					</p>
+					<div className="mt-3 grid gap-2">
+						{[...requiredEnv, ...optionalEnv].map((env) => (
+							<div
+								key={env.name}
+								className="rounded-md border border-amber-500/20 bg-background/60 p-2"
+							>
+								<div className="flex items-center justify-between gap-2">
+									<code className="font-mono text-xs font-semibold">
+										<span style={CODE_FONT_STYLE}>{env.name}</span>
+									</code>
+									<Badge variant="outline">
+										{env.required === false ? "Optional" : "Required"}
+									</Badge>
+								</div>
+								{env.description ? (
+									<p className="mt-1 text-xs text-muted-foreground">
+										{env.description}
+									</p>
+								) : null}
+								{env.url ? (
+									<a
+										className="mt-1 inline-flex items-center gap-1 text-xs text-primary hover:underline"
+										href={env.url}
+										rel="noreferrer"
+										target="_blank"
+									>
+										Get value
+										<ExternalLink className="size-3" />
+									</a>
+								) : null}
+							</div>
+						))}
+					</div>
+				</div>
+			) : null}
+
+			{entry.install.notes ? (
+				<p className="rounded-lg border bg-muted/30 p-3 text-xs leading-5 text-muted-foreground">
+					{entry.install.notes}
+				</p>
+			) : null}
+
+			{actionState?.status === "failed" ? (
+				<div className="max-h-44 overflow-auto rounded-lg border border-destructive/40 bg-destructive/10 p-3 text-sm text-destructive">
+					{actionState.message}
+				</div>
+			) : null}
+		</div>
+	);
+}
+
+function MarketplaceEntryCard({
+	actionState,
+	entry,
+	expanded,
+	installed,
+	installedStatusReady,
+	onInstall,
+	onToggleExpanded,
+	onUninstall,
+	matchedLocalItems = [],
+	showFeatured = true,
+	showTags = true,
+	sourceLabel,
+	tagLabels,
+}: {
+	actionState: EntryActionState | undefined;
+	entry: MarketplaceEntry;
+	expanded: boolean;
+	installed: boolean;
+	installedStatusReady: boolean;
+	onInstall: (entry: MarketplaceEntry) => void;
+	onToggleExpanded: (entry: MarketplaceEntry) => void;
+	onUninstall: (entry: MarketplaceEntry) => void;
+	matchedLocalItems?: MarketplaceLocalInstalledItem[];
+	showFeatured?: boolean;
+	showTags?: boolean;
+	sourceLabel?: string;
+	tagLabels: Map<string, string>;
+}) {
+	const EntryIcon = primitivePageDetails[entry.type].icon;
+	const busy =
+		actionState?.status === "installing" ||
+		actionState?.status === "uninstalling";
+	const setupNeeded = Boolean(entry.install.env?.length);
+	const hasExpandableDetails =
+		setupNeeded ||
+		Boolean(entry.install.notes) ||
+		actionState?.status === "failed";
+	const inlineMessage = actionMessage(actionState);
+	const handleActionClick = (event: MouseEvent<HTMLButtonElement>) => {
+		event.stopPropagation();
+		if (installed) {
+			onUninstall(entry);
+			return;
+		}
+		onInstall(entry);
+	};
+	const actionLabel = !installedStatusReady
+		? "Checking..."
+		: actionState?.status === "installing"
+			? "Installing..."
+			: actionState?.status === "uninstalling"
+				? "Uninstalling..."
+				: installed
+					? "Uninstall"
+					: "Install";
+	const statusMessage = inlineMessage ? (
+		<output
+			className={cn(
+				"text-xs",
+				actionState?.status === "failed"
+					? "text-destructive"
+					: "text-muted-foreground",
+			)}
+		>
+			{inlineMessage}
+		</output>
+	) : setupNeeded ? (
+		<span className="text-xs text-amber-700 dark:text-amber-300">
+			Requires setup after install
+		</span>
+	) : null;
+	const actionButton = (
+		<Button
+			disabled={!installedStatusReady || busy}
+			onClick={handleActionClick}
+			size="sm"
+			type="button"
+			variant={installed ? "destructive" : "default"}
+		>
+			{busy || !installedStatusReady ? <Spinner /> : null}
+			{installed && !busy ? <Trash2 className="size-4" /> : null}
+			{actionLabel}
+		</Button>
+	);
+	const content = (
+		<>
+			{!installed ? (
+				<div
+					className="absolute top-4 right-4"
+					data-marketplace-entry-interactive
+				>
+					{actionButton}
+				</div>
+			) : null}
+			<div className="min-w-0">
+				<div className="flex min-w-0 items-start justify-between gap-2">
+					<div
+						className={cn(
+							"flex min-w-0 flex-1 items-center gap-2",
+							!installed && "pr-24",
+						)}
+					>
+						<EntryIcon className="h-4 w-4 shrink-0 text-primary" />
+						<h2 className="min-w-0 truncate text-sm font-semibold text-foreground">
+							{entry.name}
+						</h2>
+						{showFeatured && entry.featured ? (
+							<Badge className="border border-violet-500/20 bg-violet-500/10 text-violet-700 dark:text-violet-300">
+								<Star className="fill-current" />
+								Featured
+							</Badge>
+						) : null}
+					</div>
+					<div className="flex shrink-0 flex-wrap items-center justify-end gap-2">
+						{sourceLabel ? (
+							<Badge
+								variant="outline"
+								className="shrink-0 text-muted-foreground"
+							>
+								{sourceLabel}
+							</Badge>
+						) : null}
+						{matchedLocalItems.map((item) =>
+							item.renderMatchedBadges ? (
+								<span className="contents" key={`${item.key}:badges`}>
+									{item.renderMatchedBadges()}
+								</span>
+							) : null,
+						)}
+						{matchedLocalItems.map((item) =>
+							item.renderMatchedControls ? (
+								<span
+									className="contents"
+									data-marketplace-entry-interactive
+									key={`${item.key}:controls`}
+								>
+									{item.renderMatchedControls()}
+								</span>
+							) : null,
+						)}
+					</div>
+				</div>
+				{matchedLocalItems.some((item) => item.renderMatchedMeta) ? (
+					<div className="mt-1 grid gap-1">
+						{matchedLocalItems.map((item) =>
+							item.renderMatchedMeta ? (
+								<div key={`${item.key}:meta`}>{item.renderMatchedMeta()}</div>
+							) : null,
+						)}
+					</div>
+				) : null}
+			</div>
+
+			<div className="flex flex-col gap-3 sm:flex-row sm:items-stretch sm:justify-between">
+				<div className="grid min-w-0 flex-1 gap-2">
+					{showTags && entry.tags.length > 0 ? (
+						<div className="flex flex-wrap gap-1.5">
+							{entry.tags.slice(0, 5).map((tag) => (
+								<Badge
+									key={tag}
+									variant="outline"
+									className="max-w-full text-muted-foreground"
+								>
+									<span className="truncate">{tagLabels.get(tag) ?? tag}</span>
+								</Badge>
+							))}
+						</div>
+					) : null}
+
+					<p className="line-clamp-2 text-xs leading-5 text-muted-foreground">
+						{entry.description}
+					</p>
+					{statusMessage}
+				</div>
+
+				{installed ? (
+					<div className="flex shrink-0 flex-col items-start gap-1 sm:items-end sm:justify-end">
+						{actionButton}
+					</div>
+				) : null}
+			</div>
+
+			{matchedLocalItems.some((item) => item.renderMatchedDetails) ? (
+				<div className="grid gap-2" data-marketplace-entry-details>
+					{matchedLocalItems.map((item) =>
+						item.renderMatchedDetails ? (
+							<div key={item.key}>{item.renderMatchedDetails()}</div>
+						) : null,
+					)}
+				</div>
+			) : null}
+
+			{expanded && hasExpandableDetails ? (
+				<EntryDetails actionState={actionState} entry={entry} />
+			) : null}
+		</>
+	);
+
+	if (!hasExpandableDetails) {
+		return (
+			<div className="relative grid gap-2 rounded-lg border bg-card p-4 text-left transition-colors hover:bg-accent/20">
+				{content}
+			</div>
+		);
+	}
+
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: The card contains a nested action button, so the wrapper cannot be a native button.
+		<div
+			aria-expanded={expanded}
+			aria-label={`${expanded ? "Collapse" : "Expand"} ${entry.name}`}
+			className="relative grid cursor-pointer gap-2 rounded-lg border bg-card p-4 text-left transition-colors hover:bg-accent/20 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-none"
+			onClick={(event) => {
+				if (
+					event.target instanceof HTMLElement &&
+					event.target.closest(
+						"[data-marketplace-entry-details], [data-marketplace-entry-interactive]",
+					)
+				) {
+					return;
+				}
+				onToggleExpanded(entry);
+			}}
+			onKeyDown={(event) => {
+				if (event.target !== event.currentTarget) {
+					return;
+				}
+				if (event.key === "Enter" || event.key === " ") {
+					event.preventDefault();
+					onToggleExpanded(entry);
+				}
+			}}
+			role="button"
+			tabIndex={0}
+		>
+			{content}
+		</div>
+	);
+}
+
+function TagButton({
+	active,
+	count,
+	onClick,
+	tag,
+}: {
+	active: boolean;
+	count: number;
+	onClick: () => void;
+	tag: MarketplaceTag;
+}) {
+	return (
+		<Button
+			aria-pressed={active}
+			onClick={onClick}
+			size="sm"
+			type="button"
+			variant={active ? "default" : "outline"}
+		>
+			<span className="truncate">{tag.label}</span>
+			<span className="rounded bg-background/30 px-1.5 py-0.5 text-xs">
+				{count}
+			</span>
+		</Button>
+	);
+}
+
+function MarketplaceSection({
+	actionStates,
+	emptyMessage,
+	entries,
+	expandedEntryKey,
+	headerContent,
+	installedEntryKeys,
+	installedStatusReady,
+	localOnlyInstalledItems = [],
+	matchedLocalItemsByEntryKey,
+	onInstall,
+	onToggleExpanded,
+	onUninstall,
+	showFeaturedBadges = true,
+	showEntryTags = true,
+	sourceLabel,
+	tagLabels,
+	title,
+}: {
+	actionStates: Map<string, EntryActionState>;
+	emptyMessage: string;
+	entries: MarketplaceEntry[];
+	expandedEntryKey: string | null;
+	headerContent?: ReactNode;
+	installedEntryKeys: Set<string>;
+	installedStatusReady: boolean;
+	localOnlyInstalledItems?: MarketplaceLocalInstalledItem[];
+	matchedLocalItemsByEntryKey?: Map<string, MarketplaceLocalInstalledItem[]>;
+	onInstall: (entry: MarketplaceEntry) => void;
+	onToggleExpanded: (entry: MarketplaceEntry) => void;
+	onUninstall: (entry: MarketplaceEntry) => void;
+	showFeaturedBadges?: boolean;
+	showEntryTags?: boolean;
+	sourceLabel?: string;
+	tagLabels: Map<string, string>;
+	title: string;
+}) {
+	const totalCount = entries.length + localOnlyInstalledItems.length;
+	return (
+		<section className="grid gap-3">
+			<div className="flex items-center justify-between gap-3">
+				<h2 className="text-base font-semibold text-foreground">{title}</h2>
+				<span className="text-sm text-muted-foreground">{totalCount}</span>
+			</div>
+			{headerContent}
+			{totalCount > 0 ? (
+				<div className="grid gap-3">
+					{localOnlyInstalledItems.map((item) => item.render())}
+					{entries.map((entry) => {
+						const key = entryKey(entry);
+						return (
+							<MarketplaceEntryCard
+								actionState={actionStates.get(key)}
+								entry={entry}
+								expanded={expandedEntryKey === key}
+								installed={installedEntryKeys.has(key)}
+								installedStatusReady={installedStatusReady}
+								key={key}
+								onInstall={onInstall}
+								onToggleExpanded={onToggleExpanded}
+								onUninstall={onUninstall}
+								matchedLocalItems={matchedLocalItemsByEntryKey?.get(key) ?? []}
+								showFeatured={showFeaturedBadges}
+								showTags={showEntryTags}
+								sourceLabel={sourceLabel}
+								tagLabels={tagLabels}
+							/>
+						);
+					})}
+				</div>
+			) : (
+				<div className="rounded-lg border border-dashed bg-card p-6 text-center text-sm text-muted-foreground">
+					{emptyMessage}
+				</div>
+			)}
+		</section>
+	);
+}
+
+export function MarketplaceView({
+	chrome = "page",
+	installedItems,
+	onInstalledItemsChanged,
+	primitive,
+}: {
+	chrome?: "page" | "embedded";
+	installedItems?: MarketplaceLocalInstalledItem[];
+	onInstalledItemsChanged?: () => void | Promise<void>;
+	primitive: MarketplacePrimitiveType;
+}) {
+	const [catalog, setCatalog] = useState<MarketplaceCatalog | null>(null);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [query, setQuery] = useState("");
+	const [selectedTag, setSelectedTag] = useState<string | null>(null);
+	const [expandedEntryKey, setExpandedEntryKey] = useState<string | null>(null);
+	const [installedEntryKeys, setInstalledEntryKeys] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const [actionStates, setActionStates] = useState<
+		Map<string, EntryActionState>
+	>(() => new Map());
+	const [installedStatusState, setInstalledStatusState] =
+		useState<InstalledStatusState>("loading");
+
+	useEffect(() => {
+		let cancelled = false;
+		void (async () => {
+			try {
+				if (!cancelled) {
+					setInstalledStatusState("loading");
+				}
+				const nextCatalog = await fetchMarketplaceCatalog();
+				if (!cancelled) {
+					setCatalog(nextCatalog);
+					setErrorMessage(null);
+				}
+				try {
+					const response =
+						await desktopClient.invoke<MarketplaceInstallStatusResult>(
+							"list_marketplace_installed_entries",
+							{ entries: nextCatalog.entries },
+						);
+					if (!cancelled) {
+						setInstalledEntryKeys(new Set(response.installedKeys));
+						setInstalledStatusState("ready");
+					}
+				} catch {
+					if (!cancelled) {
+						setInstalledStatusState("ready");
+					}
+				}
+			} catch (error) {
+				if (!cancelled) {
+					setErrorMessage(
+						error instanceof Error ? error.message : String(error),
+					);
+					setInstalledStatusState("ready");
+				}
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	const pageDetails = primitivePageDetails[primitive];
+	const PageIcon = pageDetails.icon;
+	const tagLabels = useMemo(
+		() => new Map(catalog?.tags.map((tag) => [tag.id, tag.label]) ?? []),
+		[catalog?.tags],
+	);
+
+	const primitiveEntries = useMemo(
+		() =>
+			(catalog?.entries.filter((entry) => entry.type === primitive) ?? []).sort(
+				compareFeaturedEntries,
+			),
+		[catalog?.entries, primitive],
+	);
+
+	const queryFilteredEntries = useMemo(() => {
+		const normalizedQuery = query.trim().toLowerCase();
+		return primitiveEntries.filter((entry) => {
+			return (
+				normalizedQuery.length === 0 ||
+				entrySearchText(entry, tagLabels).includes(normalizedQuery)
+			);
+		});
+	}, [primitiveEntries, query, tagLabels]);
+
+	const installedEntries = useMemo(
+		() =>
+			queryFilteredEntries.filter((entry) =>
+				installedEntryKeys.has(entryKey(entry)),
+			),
+		[queryFilteredEntries, installedEntryKeys],
+	);
+
+	const marketplaceEntriesBeforeTag = useMemo(
+		() =>
+			queryFilteredEntries.filter(
+				(entry) => !installedEntryKeys.has(entryKey(entry)),
+			),
+		[queryFilteredEntries, installedEntryKeys],
+	);
+
+	const tagCounts = useMemo(() => {
+		const counts = new Map<string, number>();
+		for (const entry of marketplaceEntriesBeforeTag) {
+			for (const tag of entry.tags) {
+				counts.set(tag, (counts.get(tag) ?? 0) + 1);
+			}
+		}
+		return counts;
+	}, [marketplaceEntriesBeforeTag]);
+
+	const primitiveTags = useMemo(
+		() =>
+			(catalog?.tags ?? []).filter((tag) => (tagCounts.get(tag.id) ?? 0) > 0),
+		[catalog?.tags, tagCounts],
+	);
+
+	const catalogEntries = useMemo(
+		() =>
+			marketplaceEntriesBeforeTag.filter(
+				(entry) => !selectedTag || entry.tags.includes(selectedTag),
+			),
+		[marketplaceEntriesBeforeTag, selectedTag],
+	);
+
+	const matchedLocalItemsByEntryKey = useMemo(() => {
+		const matched = new Map<string, MarketplaceLocalInstalledItem[]>();
+		for (const item of installedItems ?? []) {
+			for (const entry of installedEntries) {
+				const key = entryKey(entry);
+				if (!entryMatchesLocalItem(entry, item)) {
+					continue;
+				}
+				const items = matched.get(key) ?? [];
+				items.push(item);
+				matched.set(key, items);
+			}
+		}
+		return matched;
+	}, [installedEntries, installedItems]);
+
+	const matchedLocalItemKeys = useMemo(() => {
+		const matched = new Set<string>();
+		const installedMarketplaceEntries = primitiveEntries.filter((entry) =>
+			installedEntryKeys.has(entryKey(entry)),
+		);
+		for (const item of installedItems ?? []) {
+			if (
+				installedMarketplaceEntries.some((entry) =>
+					entryMatchesLocalItem(entry, item),
+				)
+			) {
+				matched.add(item.key);
+			}
+		}
+		return matched;
+	}, [installedEntryKeys, installedItems, primitiveEntries]);
+
+	const localOnlyInstalledItems = useMemo(() => {
+		const normalizedQuery = query.trim().toLowerCase();
+		return (installedItems ?? []).filter((item) => {
+			if (matchedLocalItemKeys.has(item.key)) {
+				return false;
+			}
+			return (
+				normalizedQuery.length === 0 ||
+				item.matchValues
+					.map(normalizeMatchValue)
+					.some((value) => value.includes(normalizedQuery))
+			);
+		});
+	}, [installedItems, matchedLocalItemKeys, query]);
+
+	const installedStatusReady = installedStatusState === "ready";
+
+	const marketplaceTagFilters =
+		primitiveTags.length > 0 ? (
+			<div className="flex flex-col gap-2 md:flex-row md:items-center md:justify-between">
+				<div className="flex gap-2 overflow-x-auto pb-1">
+					{primitiveTags.map((tag) => (
+						<TagButton
+							active={selectedTag === tag.id}
+							count={tagCounts.get(tag.id) ?? 0}
+							key={tag.id}
+							onClick={() =>
+								setSelectedTag((current) =>
+									current === tag.id ? null : tag.id,
+								)
+							}
+							tag={tag}
+						/>
+					))}
+				</div>
+				<div className="flex min-h-8 shrink-0 items-center gap-2 text-sm text-muted-foreground">
+					<span className="font-medium text-foreground">
+						{catalogEntries.length}
+					</span>
+					<span>{catalogEntries.length === 1 ? "result" : "results"}</span>
+					{selectedTag ? (
+						<Button
+							onClick={() => setSelectedTag(null)}
+							size="sm"
+							type="button"
+							variant="ghost"
+						>
+							Clear filters
+						</Button>
+					) : null}
+				</div>
+			</div>
+		) : null;
+
+	const setEntryState = (entry: MarketplaceEntry, state: EntryActionState) => {
+		const key = entryKey(entry);
+		setActionStates((current) => {
+			const next = new Map(current);
+			next.set(key, state);
+			return next;
+		});
+	};
+
+	const markEntryInstalled = (entry: MarketplaceEntry) => {
+		setInstalledEntryKeys((current) => new Set(current).add(entryKey(entry)));
+	};
+
+	const markEntryUninstalled = (entry: MarketplaceEntry) => {
+		setInstalledEntryKeys((current) => {
+			const next = new Set(current);
+			next.delete(entryKey(entry));
+			return next;
+		});
+	};
+
+	const toggleExpanded = (entry: MarketplaceEntry) => {
+		const key = entryKey(entry);
+		setExpandedEntryKey((current) => (current === key ? null : key));
+	};
+
+	const installEntry = async (entry: MarketplaceEntry) => {
+		const key = entryKey(entry);
+		const currentState = actionStates.get(key);
+		if (
+			currentState?.status === "installing" ||
+			currentState?.status === "uninstalling"
+		) {
+			return;
+		}
+		setExpandedEntryKey(key);
+		setEntryState(entry, { status: "installing" });
+		try {
+			const result = await desktopClient.invoke<MarketplaceInstallResult>(
+				"install_marketplace_entry",
+				{ entry },
+				{ timeoutMs: INSTALL_TIMEOUT_MS },
+			);
+			setEntryState(entry, {
+				status: "installed",
+				message: result.message,
+			});
+			markEntryInstalled(entry);
+			await onInstalledItemsChanged?.();
+		} catch (error) {
+			setEntryState(entry, {
+				status: "failed",
+				message: error instanceof Error ? error.message : String(error),
+			});
+		}
+	};
+
+	const uninstallEntry = async (entry: MarketplaceEntry) => {
+		const key = entryKey(entry);
+		const currentState = actionStates.get(key);
+		if (
+			currentState?.status === "installing" ||
+			currentState?.status === "uninstalling"
+		) {
+			return;
+		}
+		setExpandedEntryKey(key);
+		setEntryState(entry, { status: "uninstalling" });
+		try {
+			const result = await desktopClient.invoke<MarketplaceInstallResult>(
+				"uninstall_marketplace_entry",
+				{ entry },
+				{ timeoutMs: INSTALL_TIMEOUT_MS },
+			);
+			setEntryState(entry, {
+				status: "uninstalled",
+				message: result.message,
+			});
+			markEntryUninstalled(entry);
+			await onInstalledItemsChanged?.();
+		} catch (error) {
+			setEntryState(entry, {
+				status: "failed",
+				message: error instanceof Error ? error.message : String(error),
+			});
+		}
+	};
+
+	const content = (
+		<div className="grid gap-6">
+			{chrome === "page" ? (
+				<PageHeader
+					description={pageDetails.description}
+					icon={PageIcon}
+					title={pageDetails.title}
+					meta={<CommandBadge>{primitiveCommands[primitive]}</CommandBadge>}
+					actions={
+						catalog?.generatedAt ? (
+							<p className="text-xs text-muted-foreground">
+								Updated{" "}
+								{new Intl.DateTimeFormat(undefined, {
+									month: "short",
+									day: "numeric",
+									year: "numeric",
+								}).format(new Date(catalog.generatedAt))}
+							</p>
+						) : null
+					}
+				/>
+			) : null}
+
+			{!catalog && !errorMessage ? (
+				<div className="flex min-h-80 items-center justify-center rounded-lg border bg-card text-sm text-muted-foreground">
+					<Spinner className="mr-2" />
+					Loading marketplace...
+				</div>
+			) : null}
+
+			{catalog && !installedStatusReady ? (
+				<div className="flex min-h-80 items-center justify-center rounded-lg border bg-card text-sm text-muted-foreground">
+					<Spinner className="mr-2" />
+					Checking installed status...
+				</div>
+			) : null}
+
+			{errorMessage ? (
+				<div className="rounded-lg border border-destructive/40 bg-destructive/10 p-4 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			) : null}
+
+			{catalog && installedStatusReady ? (
+				<div className="grid gap-6">
+					<div className="grid gap-3">
+						<div className="flex flex-col gap-3 md:flex-row md:items-center">
+							<div className="relative block flex-1">
+								<Search className="pointer-events-none absolute left-2.5 top-1/2 size-4 -translate-y-1/2 text-muted-foreground" />
+								<Input
+									aria-label={`Search ${pageDetails.title}`}
+									className="h-10 pl-8"
+									onChange={(event) => setQuery(event.target.value)}
+									placeholder={`Search ${pageDetails.title.toLowerCase()}`}
+									value={query}
+								/>
+							</div>
+						</div>
+					</div>
+
+					<MarketplaceSection
+						actionStates={actionStates}
+						emptyMessage={pageDetails.emptyInstalled}
+						entries={installedEntries}
+						expandedEntryKey={expandedEntryKey}
+						installedEntryKeys={installedEntryKeys}
+						installedStatusReady={installedStatusReady}
+						localOnlyInstalledItems={localOnlyInstalledItems}
+						matchedLocalItemsByEntryKey={matchedLocalItemsByEntryKey}
+						onInstall={installEntry}
+						onToggleExpanded={toggleExpanded}
+						onUninstall={uninstallEntry}
+						showFeaturedBadges={false}
+						showEntryTags={false}
+						sourceLabel="Marketplace"
+						tagLabels={tagLabels}
+						title="Installed"
+					/>
+
+					<MarketplaceSection
+						actionStates={actionStates}
+						emptyMessage={pageDetails.emptyCatalog}
+						entries={catalogEntries}
+						expandedEntryKey={expandedEntryKey}
+						headerContent={marketplaceTagFilters}
+						installedEntryKeys={installedEntryKeys}
+						installedStatusReady={installedStatusReady}
+						onInstall={installEntry}
+						onToggleExpanded={toggleExpanded}
+						onUninstall={uninstallEntry}
+						tagLabels={tagLabels}
+						title="Marketplace"
+					/>
+				</div>
+			) : null}
+		</div>
+	);
+
+	return chrome === "embedded" ? content : <PageFrame>{content}</PageFrame>;
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/page-layout.tsx b/apps/cline-hub/src/webview/src/components/views/page-layout.tsx
new file mode 100644
index 0000000..a49eced
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/page-layout.tsx
@@ -0,0 +1,111 @@
+import type { ComponentType, ReactNode } from "react";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+type PageFrameProps = {
+	children: ReactNode;
+	className?: string;
+	contentClassName?: string;
+};
+
+export function PageFrame({
+	children,
+	className,
+	contentClassName,
+}: PageFrameProps) {
+	return (
+		<ScrollArea className="h-full">
+			<div
+				className={cn(
+					"px-18 py-10 max-[1200px]:px-8 max-[720px]:px-4 max-[720px]:py-5",
+					className,
+				)}
+			>
+				<div className={cn("max-w-344", contentClassName)}>{children}</div>
+			</div>
+		</ScrollArea>
+	);
+}
+
+type PageHeaderProps = {
+	actions?: ReactNode;
+	className?: string;
+	description?: ReactNode;
+	icon?: ComponentType<{ className?: string }>;
+	meta?: ReactNode;
+	title: ReactNode;
+};
+
+export function PageHeader({
+	actions,
+	className,
+	description,
+	icon: Icon,
+	meta,
+	title,
+}: PageHeaderProps) {
+	return (
+		<section
+			className={cn(
+				"mb-8 flex items-start justify-between gap-6 max-[860px]:flex-col max-[860px]:items-stretch",
+				className,
+			)}
+		>
+			<div className="min-w-0">
+				<div className="flex min-w-0 items-center gap-3">
+					{Icon ? <Icon className="size-8 shrink-0 text-primary" /> : null}
+					<h1 className="truncate text-[32px] font-semibold leading-[1.15] tracking-normal text-foreground">
+						{title}
+					</h1>
+					{meta}
+				</div>
+				{description ? (
+					<p className="mt-3 max-w-2xl text-[15px] leading-6 text-muted-foreground">
+						{description}
+					</p>
+				) : null}
+			</div>
+			{actions ? (
+				<div className="flex shrink-0 flex-wrap items-center justify-end gap-2 max-[860px]:justify-start">
+					{actions}
+				</div>
+			) : null}
+		</section>
+	);
+}
+
+type PageEmptyStateProps = {
+	children: ReactNode;
+	className?: string;
+};
+
+export function PageEmptyState({ children, className }: PageEmptyStateProps) {
+	return (
+		<div
+			className={cn(
+				"rounded-lg border border-dashed border-border bg-card px-5 py-4 text-sm leading-6 text-muted-foreground",
+				className,
+			)}
+		>
+			{children}
+		</div>
+	);
+}
+
+type CommandBadgeProps = {
+	children: ReactNode;
+	className?: string;
+};
+
+export function CommandBadge({ children, className }: CommandBadgeProps) {
+	return (
+		<span
+			className={cn(
+				"rounded-md border border-border bg-background px-2 py-0.5 font-mono text-xs text-muted-foreground",
+				className,
+			)}
+		>
+			{children}
+		</span>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/account-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/account-view.tsx
new file mode 100644
index 0000000..3a106d4
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/account-view.tsx
@@ -0,0 +1,711 @@
+"use client";
+
+import type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+} from "@cline/core";
+import {
+	AlertCircle,
+	Building,
+	CreditCard,
+	ExternalLink,
+	Loader2,
+	LogIn,
+	LogOut,
+	Plus,
+	Receipt,
+	RefreshCw,
+	UserCircleIcon,
+} from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { desktopClient } from "@/lib/desktop-client";
+import { cn } from "@/lib/utils";
+import { PageFrame, PageHeader } from "../page-layout";
+
+function normalizeAccountViewError(error: unknown): Error {
+	const message = error instanceof Error ? error.message : String(error);
+	if (message.includes("unsupported desktop command: cline_account")) {
+		return new Error(
+			"The desktop sidecar is running an older build that does not support account commands. Restart the sidecar or reload the app, then try again.",
+		);
+	}
+	return error instanceof Error ? error : new Error(message);
+}
+
+function isAccountAuthError(message: string): boolean {
+	const normalized = message.toLowerCase();
+	return (
+		normalized.includes("no cline account auth token found") ||
+		normalized.includes("requires re-authentication") ||
+		normalized.includes("auth token") ||
+		normalized.includes("unauthorized")
+	);
+}
+
+// ---------------------------------------------------------------------------
+// Data fetching helpers via sidecar command
+// ---------------------------------------------------------------------------
+
+async function fetchAccountUser(): Promise<ClineAccountUser> {
+	return await desktopClient.invoke<ClineAccountUser>("cline_account", {
+		action: "clineAccount",
+		operation: "fetchMe",
+	});
+}
+
+async function fetchAccountBalance(): Promise<ClineAccountBalance> {
+	return await desktopClient.invoke<ClineAccountBalance>("cline_account", {
+		action: "clineAccount",
+		operation: "fetchBalance",
+	});
+}
+
+async function fetchAccountOrganizations(): Promise<
+	ClineAccountOrganization[]
+> {
+	return await desktopClient.invoke<ClineAccountOrganization[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchUserOrganizations",
+		},
+	);
+}
+
+async function fetchOrganizationBalance(
+	organizationId: string,
+): Promise<ClineAccountOrganizationBalance> {
+	return await desktopClient.invoke<ClineAccountOrganizationBalance>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchOrganizationBalance",
+			organizationId,
+		},
+	);
+}
+
+async function fetchUsageTransactions(): Promise<
+	ClineAccountUsageTransaction[]
+> {
+	return await desktopClient.invoke<ClineAccountUsageTransaction[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchUsageTransactions",
+		},
+	);
+}
+
+async function fetchOrganizationUsageTransactions(
+	organizationId: string,
+	memberId?: string,
+): Promise<ClineAccountOrganizationUsageTransaction[]> {
+	return await desktopClient.invoke<ClineAccountOrganizationUsageTransaction[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchOrganizationUsageTransactions",
+			organizationId,
+			...(memberId?.trim() ? { memberId: memberId.trim() } : {}),
+		},
+	);
+}
+
+async function fetchPaymentTransactions(): Promise<
+	ClineAccountPaymentTransaction[]
+> {
+	return await desktopClient.invoke<ClineAccountPaymentTransaction[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchPaymentTransactions",
+		},
+	);
+}
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+export function AccountView() {
+	const [activeTab, setActiveTab] = useState<"overview" | "usage" | "billing">(
+		"overview",
+	);
+	const [accountActionPending, setAccountActionPending] = useState<
+		"sign-in" | "sign-out" | null
+	>(null);
+
+	// Overview data
+	const [user, setUser] = useState<ClineAccountUser | null>(null);
+	const [balance, setBalance] = useState<ClineAccountBalance | null>(null);
+	const [organizationBalance, setOrganizationBalance] =
+		useState<ClineAccountOrganizationBalance | null>(null);
+	const [organizations, setOrganizations] = useState<
+		ClineAccountOrganization[]
+	>([]);
+	const [overviewLoading, setOverviewLoading] = useState(true);
+	const [overviewError, setOverviewError] = useState<string | null>(null);
+
+	// Usage data
+	const [usageTransactions, setUsageTransactions] = useState<
+		ClineAccountUsageTransaction[]
+	>([]);
+	const [usageLoading, setUsageLoading] = useState(false);
+	const [usageError, setUsageError] = useState<string | null>(null);
+	const [usageLoaded, setUsageLoaded] = useState(false);
+	const usageGenerationRef = useRef(0);
+
+	// Billing data
+	const [paymentTransactions, setPaymentTransactions] = useState<
+		ClineAccountPaymentTransaction[]
+	>([]);
+	const [billingLoading, setBillingLoading] = useState(false);
+	const [billingError, setBillingError] = useState<string | null>(null);
+	const [billingLoaded, setBillingLoaded] = useState(false);
+	const activeOrganization = organizations.find((org) => org.active) ?? null;
+
+	const resetAccountData = useCallback(() => {
+		setUser(null);
+		setBalance(null);
+		setOrganizationBalance(null);
+		setOrganizations([]);
+		setUsageTransactions([]);
+		setUsageLoaded(false);
+		setUsageError(null);
+		setPaymentTransactions([]);
+		setBillingLoaded(false);
+		setBillingError(null);
+	}, []);
+
+	// -- Overview fetch --
+	const loadOverview = useCallback(async () => {
+		setOverviewLoading(true);
+		setOverviewError(null);
+		try {
+			const [userData, balanceData, orgsData] = await Promise.all([
+				fetchAccountUser(),
+				fetchAccountBalance(),
+				fetchAccountOrganizations(),
+			]);
+			const nextActiveOrganization =
+				orgsData.find((organization) => organization.active) ?? null;
+			const organizationBalanceData = nextActiveOrganization
+				? await fetchOrganizationBalance(nextActiveOrganization.organizationId)
+				: null;
+			setUser(userData);
+			setBalance(balanceData);
+			setOrganizationBalance(organizationBalanceData);
+			setOrganizations(orgsData);
+		} catch (err) {
+			resetAccountData();
+			const message = normalizeAccountViewError(err).message;
+			setOverviewError(message);
+		} finally {
+			setOverviewLoading(false);
+		}
+	}, [resetAccountData]);
+
+	useEffect(() => {
+		void loadOverview();
+	}, [loadOverview]);
+
+	const signIn = async () => {
+		setAccountActionPending("sign-in");
+		setOverviewError(null);
+		try {
+			await desktopClient.invoke("run_provider_oauth_login", {
+				provider: "cline",
+			});
+			await loadOverview();
+			setActiveTab("overview");
+		} catch (err) {
+			const message = normalizeAccountViewError(err).message;
+			setOverviewError(message);
+			resetAccountData();
+		} finally {
+			setAccountActionPending(null);
+		}
+	};
+
+	const signOut = async () => {
+		setAccountActionPending("sign-out");
+		try {
+			await desktopClient.invoke("save_provider_settings", {
+				provider: "cline",
+				api_key: "",
+				settings: {
+					auth: {
+						accessToken: "",
+						refreshToken: "",
+						accountId: "",
+					},
+				},
+			});
+			resetAccountData();
+			setActiveTab("overview");
+			setOverviewError("No Cline account auth token found");
+		} catch (err) {
+			const message = normalizeAccountViewError(err).message;
+			setOverviewError(message);
+		} finally {
+			setAccountActionPending(null);
+		}
+	};
+
+	// -- Usage fetch (lazy on tab switch) --
+	const loadUsage = useCallback(async () => {
+		const generation = usageGenerationRef.current;
+		setUsageLoading(true);
+		setUsageError(null);
+		try {
+			const data = activeOrganization
+				? await fetchOrganizationUsageTransactions(
+						activeOrganization.organizationId,
+						activeOrganization.memberId,
+					)
+				: await fetchUsageTransactions();
+			if (usageGenerationRef.current !== generation) return;
+			setUsageTransactions(data);
+			setUsageLoaded(true);
+		} catch (err) {
+			if (usageGenerationRef.current !== generation) return;
+			const message = normalizeAccountViewError(err).message;
+			setUsageError(message);
+		} finally {
+			if (usageGenerationRef.current === generation) {
+				setUsageLoading(false);
+			}
+		}
+	}, [activeOrganization]);
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: we need to reset usage state when the organization changes
+	useEffect(() => {
+		usageGenerationRef.current += 1;
+		setUsageTransactions([]);
+		setUsageLoaded(false);
+		setUsageError(null);
+	}, [activeOrganization?.organizationId]);
+
+	useEffect(() => {
+		if (activeTab === "usage" && !usageLoaded) {
+			void loadUsage();
+		}
+	}, [activeTab, usageLoaded, loadUsage]);
+
+	// -- Billing fetch (lazy on tab switch) --
+	const loadBilling = useCallback(async () => {
+		setBillingLoading(true);
+		setBillingError(null);
+		try {
+			const data = await fetchPaymentTransactions();
+			setPaymentTransactions(data);
+			setBillingLoaded(true);
+		} catch (err) {
+			const message = normalizeAccountViewError(err).message;
+			setBillingError(message);
+		} finally {
+			setBillingLoading(false);
+		}
+	}, []);
+
+	useEffect(() => {
+		if (activeTab === "billing" && !billingLoaded) {
+			void loadBilling();
+		}
+	}, [activeTab, billingLoaded, loadBilling]);
+
+	// -- Formatters --
+
+	const formatDate = (dateStr: string) => {
+		return new Date(dateStr).toLocaleDateString("en-US", {
+			month: "short",
+			day: "numeric",
+			year: "numeric",
+		});
+	};
+
+	const formatTime = (dateStr: string) => {
+		return new Date(dateStr).toLocaleTimeString("en-US", {
+			hour: "numeric",
+			minute: "2-digit",
+		});
+	};
+
+	const formatCreditBalance = (value: number, decimalPlaces = 2) => {
+		return new Intl.NumberFormat("en-US", {
+			minimumFractionDigits: decimalPlaces,
+			maximumFractionDigits: decimalPlaces,
+		}).format(value / 1_000_000);
+	};
+
+	const displayedBalance = activeOrganization
+		? (organizationBalance?.balance ?? balance?.balance ?? null)
+		: (balance?.balance ?? null);
+
+	const tabs = ["overview", "usage", "billing"] as const;
+
+	// -- Shared error / loading UI --
+
+	const renderError = (message: string, onRetry: () => void) => (
+		<div className="flex flex-col items-center justify-center gap-3 py-12 text-center">
+			<AlertCircle className="h-8 w-8 text-destructive" />
+			<p className="text-sm text-muted-foreground max-w-md">{message}</p>
+			<button
+				type="button"
+				onClick={onRetry}
+				className="flex items-center gap-2 rounded-lg border border-border px-3.5 py-2 text-sm font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+			>
+				<RefreshCw className="h-4 w-4" />
+				Retry
+			</button>
+		</div>
+	);
+
+	const renderSignedOut = () => (
+		<div className="rounded-lg border border-border bg-card p-6">
+			<div className="mx-auto flex max-w-xl flex-col items-center gap-4 py-8 text-center">
+				<div className="flex size-12 items-center justify-center rounded-lg bg-primary/10 text-primary">
+					<UserCircleIcon className="h-6 w-6" />
+				</div>
+				<div>
+					<h3 className="text-lg font-semibold text-foreground">
+						Sign in to Cline
+					</h3>
+					<p className="mt-2 text-sm text-muted-foreground">
+						Connect your Cline account to review credits, usage, billing, and
+						organization details from Cline Hub.
+					</p>
+				</div>
+				<div className="flex flex-wrap items-center justify-center gap-2">
+					<Button
+						disabled={accountActionPending !== null}
+						onClick={() => void signIn()}
+						type="button"
+					>
+						{accountActionPending === "sign-in" ? (
+							<Loader2 className="h-4 w-4 animate-spin" />
+						) : (
+							<LogIn className="h-4 w-4" />
+						)}
+						{accountActionPending === "sign-in" ? "Signing in" : "Sign in"}
+					</Button>
+					<a
+						className="inline-flex h-9 items-center gap-2 rounded-lg border border-border px-3.5 text-sm font-medium text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+						href="https://app.cline.bot"
+						rel="noopener noreferrer"
+						target="_blank"
+					>
+						Create account
+						<ExternalLink className="h-4 w-4" />
+					</a>
+				</div>
+			</div>
+		</div>
+	);
+
+	const renderLoading = () => (
+		<div className="flex items-center justify-center py-12">
+			<Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+		</div>
+	);
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description="Review account, usage, billing, and organization details."
+				title="Account"
+			/>
+
+			{/* Tabs */}
+			<div className="mb-6 flex items-center gap-0 border-b border-border">
+				{tabs.map((tab) => {
+					const disabled = !user && tab !== "overview";
+					return (
+						<button
+							disabled={disabled}
+							key={tab}
+							type="button"
+							onClick={() => setActiveTab(tab)}
+							className={cn(
+								"relative px-4 py-2.5 text-sm font-medium capitalize transition-colors",
+								activeTab === tab
+									? "text-foreground"
+									: "text-muted-foreground hover:text-foreground",
+								disabled &&
+									"cursor-not-allowed opacity-45 hover:text-muted-foreground",
+							)}
+						>
+							{tab}
+							{activeTab === tab && (
+								<span className="absolute inset-x-0 -bottom-px h-0.5 bg-foreground" />
+							)}
+						</button>
+					);
+				})}
+			</div>
+
+			{/* Overview Tab */}
+			{activeTab === "overview" && (
+				<div className="flex flex-col gap-6">
+					{overviewLoading && renderLoading()}
+					{overviewError &&
+						(isAccountAuthError(overviewError)
+							? renderSignedOut()
+							: renderError(overviewError, loadOverview))}
+					{!overviewLoading && !overviewError && user && (
+						<>
+							{/* User Profile Card */}
+							<div className="rounded-lg border border-border p-5">
+								<div className="flex items-start gap-4">
+									<div className="flex h-16 w-16 shrink-0 items-center justify-center rounded-full bg-primary/20 text-2xl font-bold text-primary">
+										{user.displayName?.charAt(0) ??
+											user.email?.charAt(0) ??
+											"?"}
+									</div>
+									<div className="min-w-0 flex-1">
+										<h3 className="text-base font-semibold text-foreground">
+											{user.displayName || user.email}
+										</h3>
+										<p className="mt-0.5 text-sm text-muted-foreground">
+											{user.email}
+										</p>
+										<p className="mt-2 text-xs text-muted-foreground">
+											Member since {formatDate(user.createdAt)}
+										</p>
+									</div>
+									<div className="flex shrink-0 items-center gap-2">
+										<a
+											href="https://app.cline.bot/dashboard"
+											target="_blank"
+											rel="noopener noreferrer"
+											className="inline-flex h-8 items-center gap-1.5 rounded-md border border-border px-2.5 text-xs font-medium text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+										>
+											Open dashboard
+											<ExternalLink className="h-3.5 w-3.5" />
+										</a>
+										<Button
+											className="h-8 rounded-md px-2.5 text-xs"
+											disabled={accountActionPending !== null}
+											onClick={() => void signOut()}
+											type="button"
+											variant="outline"
+										>
+											{accountActionPending === "sign-out" ? (
+												<Loader2 className="h-3.5 w-3.5 animate-spin" />
+											) : (
+												<LogOut className="h-3.5 w-3.5" />
+											)}
+											{accountActionPending === "sign-out"
+												? "Signing out"
+												: "Sign out"}
+										</Button>
+									</div>
+								</div>
+							</div>
+
+							{/* Balance Card */}
+							{displayedBalance !== null && (
+								<div className="rounded-lg border border-border p-5">
+									<div className="flex items-center justify-between mb-4">
+										<div className="flex items-center gap-3">
+											<CreditCard className="h-5 w-5 text-primary" />
+											<h3 className="text-sm font-semibold text-foreground">
+												{activeOrganization
+													? `${activeOrganization.name} Balance`
+													: "Credits Balance"}
+											</h3>
+										</div>
+										<a
+											href="https://app.cline.bot/dashboard/organization?tab=credits&redirect=true"
+											target="_blank"
+											rel="noopener noreferrer"
+											className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+										>
+											<Plus className="h-3.5 w-3.5" />
+											Credit
+										</a>
+									</div>
+									<div className="flex items-baseline gap-2">
+										<span className="text-3xl font-bold text-foreground">
+											${formatCreditBalance(displayedBalance)}
+										</span>
+									</div>
+									{activeOrganization && balance && (
+										<p className="mt-2 text-xs text-muted-foreground">
+											Personal account: {formatCreditBalance(balance.balance)}{" "}
+											credits
+										</p>
+									)}
+								</div>
+							)}
+
+							{/* Organizations */}
+							<div className="rounded-lg border border-border p-5">
+								<div className="flex items-center justify-between mb-4">
+									<div className="flex items-center gap-3">
+										<Building className="h-5 w-5 text-muted-foreground" />
+										<h3 className="text-sm font-semibold text-foreground">
+											Organizations
+										</h3>
+									</div>
+									<a
+										href="https://app.cline.bot/onboarding?step=1"
+										target="_blank"
+										rel="noopener noreferrer"
+										className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+									>
+										<Plus className="h-3.5 w-3.5" />
+										Create
+									</a>
+								</div>
+								{organizations.length === 0 ? (
+									<p className="text-sm text-muted-foreground">
+										No organizations yet.
+									</p>
+								) : (
+									<div className="flex flex-col gap-2">
+										{organizations.map((org) => (
+											<div
+												key={org.organizationId}
+												className="flex items-center gap-3 rounded-lg border border-border px-4 py-3 transition-colors hover:bg-accent/20"
+											>
+												<div className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg bg-secondary text-sm font-bold text-foreground">
+													{org.name.charAt(0)}
+												</div>
+												<div className="min-w-0 flex-1">
+													<p className="text-sm font-medium text-foreground">
+														{org.name}
+													</p>
+													<p className="text-xs text-muted-foreground capitalize">
+														{org.roles.join(", ")}
+													</p>
+												</div>
+												{org.active && (
+													<span className="rounded-full bg-primary/20 px-2 py-0.5 text-xs font-medium text-primary">
+														Active
+													</span>
+												)}
+											</div>
+										))}
+									</div>
+								)}
+							</div>
+						</>
+					)}
+				</div>
+			)}
+
+			{/* Usage Tab */}
+			{activeTab === "usage" && (
+				<div>
+					<p className="mb-6 text-sm text-muted-foreground">
+						{activeOrganization
+							? `Recent API usage and token consumption for ${activeOrganization.name}.`
+							: "Recent API usage and token consumption across all providers."}
+					</p>
+					{usageLoading && renderLoading()}
+					{usageError && renderError(usageError, loadUsage)}
+					{!usageLoading &&
+						!usageError &&
+						usageLoaded &&
+						(usageTransactions.length === 0 ? (
+							<p className="py-8 text-center text-sm text-muted-foreground">
+								No usage transactions yet.
+							</p>
+						) : (
+							<div className="rounded-lg border border-border overflow-hidden">
+								<div className="grid grid-cols-[1fr_auto_auto_auto] gap-4 border-b border-border bg-secondary/50 px-4 py-2.5 text-xs font-medium text-muted-foreground">
+									<span>Model</span>
+									<span className="text-right">Tokens</span>
+									<span className="text-right">Credits</span>
+									<span className="text-right">Time</span>
+								</div>
+								<div className="divide-y divide-border">
+									{usageTransactions.map((tx) => (
+										<div
+											key={tx.id}
+											className="grid grid-cols-[1fr_auto_auto_auto] gap-4 px-4 py-3 text-sm transition-colors hover:bg-accent/20"
+										>
+											<div className="min-w-0">
+												<p className="font-medium text-foreground truncate">
+													{tx.aiModelName}
+												</p>
+												<p className="text-xs text-muted-foreground">
+													{tx.aiInferenceProviderName}
+												</p>
+											</div>
+											<div className="text-right text-muted-foreground">
+												{tx.totalTokens.toLocaleString()}
+											</div>
+											<div className="text-right text-foreground font-medium">
+												{formatCreditBalance(tx.creditsUsed)}
+											</div>
+											<div className="text-right text-xs text-muted-foreground">
+												<p>{formatDate(tx.createdAt)}</p>
+												<p>{formatTime(tx.createdAt)}</p>
+											</div>
+										</div>
+									))}
+								</div>
+							</div>
+						))}
+				</div>
+			)}
+
+			{/* Billing Tab */}
+			{activeTab === "billing" && (
+				<div>
+					<p className="mb-6 text-sm text-muted-foreground">
+						Payment history and credit purchases.
+					</p>
+					{billingLoading && renderLoading()}
+					{billingError && renderError(billingError, loadBilling)}
+					{!billingLoading &&
+						!billingError &&
+						billingLoaded &&
+						(paymentTransactions.length === 0 ? (
+							<p className="py-8 text-center text-sm text-muted-foreground">
+								No payment transactions yet.
+							</p>
+						) : (
+							<div className="rounded-lg border border-border overflow-hidden">
+								<div className="grid grid-cols-[1fr_auto_auto] gap-4 border-b border-border bg-secondary/50 px-4 py-2.5 text-xs font-medium text-muted-foreground">
+									<span>Date</span>
+									<span className="text-right">Amount</span>
+									<span className="text-right">Credits</span>
+								</div>
+								<div className="divide-y divide-border">
+									{paymentTransactions.map((tx) => (
+										<div
+											key={`${tx.paidAt}-${tx.amountCents}-${tx.credits}`}
+											className="grid grid-cols-[1fr_auto_auto] gap-4 px-4 py-3 text-sm transition-colors hover:bg-accent/20"
+										>
+											<div className="flex items-center gap-3">
+												<Receipt className="h-4 w-4 text-muted-foreground" />
+												<span className="text-foreground">
+													{formatDate(tx.paidAt)}
+												</span>
+											</div>
+											<div className="text-right text-foreground font-medium">
+												${(tx.amountCents / 100).toFixed(2)}
+											</div>
+											<div className="text-right text-primary font-medium">
+												+{formatCreditBalance(tx.credits)}
+											</div>
+										</div>
+									))}
+								</div>
+							</div>
+						))}
+				</div>
+			)}
+		</PageFrame>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/add-provider.tsx b/apps/cline-hub/src/webview/src/components/views/settings/add-provider.tsx
new file mode 100644
index 0000000..83de774
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/add-provider.tsx
@@ -0,0 +1,529 @@
+"use client";
+
+import {
+	ArrowLeft,
+	ChevronDown,
+	Copy,
+	Eye,
+	EyeOff,
+	Plus,
+	Trash2,
+	X,
+} from "lucide-react";
+import { useMemo, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { cn } from "@/lib/utils";
+import { PageFrame, PageHeader } from "../page-layout";
+
+const CAPABILITY_OPTIONS = [
+	"streaming",
+	"tools",
+	"reasoning",
+	"vision",
+	"prompt-cache",
+] as const;
+
+type Capability = (typeof CAPABILITY_OPTIONS)[number];
+
+export interface AddProviderPayload {
+	providerId: string;
+	name: string;
+	baseUrl: string;
+	apiKey?: string;
+	headers?: Record<string, string>;
+	timeoutMs?: number;
+	models: string[];
+	defaultModelId?: string;
+	modelsSourceUrl?: string;
+	capabilities?: Capability[];
+}
+
+interface NewProviderForm {
+	providerId: string;
+	name: string;
+	models: string[];
+	defaultModel: string;
+	apiKey: string;
+	baseUrl: string;
+	modelsSourceUrl: string;
+	headers: Record<string, string>;
+	timeoutMs: string;
+	capabilities: Capability[];
+}
+
+export function AddProviderContent({
+	onBack,
+	onSave,
+	existingProviderIds,
+}: {
+	onBack: () => void;
+	onSave: (payload: AddProviderPayload) => Promise<void>;
+	existingProviderIds: string[];
+}) {
+	const [form, setForm] = useState<NewProviderForm>({
+		providerId: "",
+		name: "",
+		models: [],
+		defaultModel: "",
+		apiKey: "",
+		baseUrl: "",
+		modelsSourceUrl: "",
+		headers: {},
+		timeoutMs: "",
+		capabilities: ["streaming", "tools"],
+	});
+	const [modelInput, setModelInput] = useState("");
+	const [showApiKey, setShowApiKey] = useState(false);
+	const [showAdvanced, setShowAdvanced] = useState(false);
+	const [saving, setSaving] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+
+	const normalizedProviderId = useMemo(
+		() => form.providerId.trim().toLowerCase().replace(/\s+/g, "-"),
+		[form.providerId],
+	);
+
+	const duplicateProviderId =
+		existingProviderIds.includes(normalizedProviderId);
+	const hasManualModels = form.models.length > 0;
+	const hasModelsSource = form.modelsSourceUrl.trim().length > 0;
+	const canSave =
+		normalizedProviderId.length > 0 &&
+		form.name.trim().length > 0 &&
+		form.baseUrl.trim().length > 0 &&
+		(hasManualModels || hasModelsSource) &&
+		!duplicateProviderId;
+
+	const handleAddModel = (e: React.KeyboardEvent<HTMLInputElement>) => {
+		if ((e.key === "Enter" || e.key === ",") && modelInput.trim()) {
+			e.preventDefault();
+			const value = modelInput.trim().replace(/,/g, "");
+			if (value && !form.models.includes(value)) {
+				setForm((prev) => ({
+					...prev,
+					models: [...prev.models, value],
+					defaultModel: prev.defaultModel || value,
+				}));
+			}
+			setModelInput("");
+		} else if (e.key === "Backspace" && !modelInput && form.models.length > 0) {
+			setForm((prev) => ({
+				...prev,
+				models: prev.models.slice(0, -1),
+			}));
+		}
+	};
+
+	const removeModel = (model: string) => {
+		setForm((prev) => {
+			const nextModels = prev.models.filter((m) => m !== model);
+			return {
+				...prev,
+				models: nextModels,
+				defaultModel:
+					prev.defaultModel === model
+						? (nextModels[0] ?? "")
+						: prev.defaultModel,
+			};
+		});
+	};
+
+	const toggleCapability = (cap: Capability) => {
+		setForm((prev) => ({
+			...prev,
+			capabilities: prev.capabilities.includes(cap)
+				? prev.capabilities.filter((c) => c !== cap)
+				: [...prev.capabilities, cap],
+		}));
+	};
+
+	const addHeader = () => {
+		setForm((prev) => ({ ...prev, headers: { ...prev.headers, "": "" } }));
+	};
+
+	const updateHeaderKey = (oldKey: string, newKey: string, idx: number) => {
+		const entries = Object.entries(form.headers);
+		const next: Record<string, string> = {};
+		entries.forEach(([key, value], index) => {
+			next[index === idx ? newKey : key] = value;
+		});
+		if (oldKey !== newKey) {
+			delete next[oldKey];
+		}
+		setForm((prev) => ({ ...prev, headers: next }));
+	};
+
+	const updateHeaderValue = (key: string, value: string) => {
+		setForm((prev) => ({
+			...prev,
+			headers: { ...prev.headers, [key]: value },
+		}));
+	};
+
+	const removeHeader = (key: string) => {
+		const next = { ...form.headers };
+		delete next[key];
+		setForm((prev) => ({ ...prev, headers: next }));
+	};
+
+	const handleSave = async () => {
+		if (!canSave || saving) {
+			return;
+		}
+		setSaving(true);
+		setError(null);
+		try {
+			await onSave({
+				providerId: normalizedProviderId,
+				name: form.name.trim(),
+				baseUrl: form.baseUrl.trim(),
+				apiKey: form.apiKey.trim() || undefined,
+				headers: Object.fromEntries(
+					Object.entries(form.headers)
+						.map(([key, value]) => [key.trim(), value])
+						.filter(([key]) => key.length > 0),
+				),
+				timeoutMs:
+					form.timeoutMs.trim().length > 0
+						? Number.parseInt(form.timeoutMs.trim(), 10)
+						: undefined,
+				models: form.models,
+				defaultModelId: form.defaultModel || form.models[0],
+				modelsSourceUrl: form.modelsSourceUrl.trim() || undefined,
+				capabilities:
+					form.capabilities.length > 0 ? form.capabilities : undefined,
+			});
+		} catch (saveError) {
+			setError(
+				saveError instanceof Error ? saveError.message : String(saveError),
+			);
+		} finally {
+			setSaving(false);
+		}
+	};
+
+	return (
+		<PageFrame contentClassName="max-w-4xl">
+			<PageHeader
+				description="Add an OpenAI-compatible provider and choose its available models."
+				title="Add Provider"
+				actions={
+					<Button
+						onClick={onBack}
+						variant="secondary"
+						className="rounded-md p-1.5 transition-colors"
+						aria-label="Back to providers"
+					>
+						<ArrowLeft className="h-4 w-4" />
+						Providers
+					</Button>
+				}
+			/>
+
+			<div className="flex flex-col gap-6">
+				<div className="rounded-lg border border-border p-5">
+					<h3 className="mb-4 text-sm font-semibold text-foreground">
+						OpenAI-Compatible Provider
+					</h3>
+					<div className="grid grid-cols-1 gap-4 md:grid-cols-2">
+						<div>
+							<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+								Provider ID
+							</Label>
+							<input
+								type="text"
+								value={form.providerId}
+								onChange={(e) =>
+									setForm((prev) => ({ ...prev, providerId: e.target.value }))
+								}
+								placeholder="my-provider"
+								className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+							/>
+							<p className="mt-1.5 text-xs text-muted-foreground">
+								Lowercase ID used in provider registry.
+							</p>
+							{duplicateProviderId ? (
+								<p className="mt-1 text-xs text-destructive">
+									This provider ID already exists.
+								</p>
+							) : null}
+						</div>
+						<div>
+							<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+								Provider Name
+							</Label>
+							<input
+								type="text"
+								value={form.name}
+								onChange={(e) =>
+									setForm((prev) => ({ ...prev, name: e.target.value }))
+								}
+								placeholder="My Provider"
+								className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+							/>
+						</div>
+					</div>
+				</div>
+
+				<div className="rounded-lg border border-border p-5">
+					<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+						Base URL
+					</Label>
+					<input
+						type="url"
+						value={form.baseUrl}
+						onChange={(e) =>
+							setForm((prev) => ({ ...prev, baseUrl: e.target.value }))
+						}
+						placeholder="https://api.example.com/v1"
+						className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+					/>
+				</div>
+
+				<div className="rounded-lg border border-border p-5">
+					<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+						Model Source URL (Optional)
+					</Label>
+					<input
+						type="url"
+						value={form.modelsSourceUrl}
+						onChange={(e) =>
+							setForm((prev) => ({
+								...prev,
+								modelsSourceUrl: e.target.value,
+							}))
+						}
+						placeholder="https://api.example.com/v1/models"
+						className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+					/>
+					<p className="mt-1.5 text-xs text-muted-foreground">
+						Supported JSON: OpenAI `/models` shape with a `data` array, or a
+						direct model array.
+					</p>
+				</div>
+
+				<div className="rounded-lg border border-border p-5">
+					<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+						Models
+					</Label>
+					<div className="flex min-h-11 flex-wrap content-start gap-1.5 rounded-lg border border-border bg-input px-3 py-2 focus-within:ring-1 focus-within:ring-ring">
+						{form.models.map((model) => (
+							<span
+								key={model}
+								className="inline-flex items-center gap-1 rounded-md bg-primary/10 px-2 py-1 text-xs font-medium text-primary"
+							>
+								<span className="font-mono">{model}</span>
+								<Button
+									onClick={() => removeModel(model)}
+									className="text-primary/60 hover:text-primary transition-colors"
+									aria-label={`Remove ${model}`}
+								>
+									<X className="h-3 w-3" />
+								</Button>
+							</span>
+						))}
+						<input
+							type="text"
+							value={modelInput}
+							onChange={(e) => setModelInput(e.target.value)}
+							onKeyDown={handleAddModel}
+							placeholder={
+								form.models.length === 0 ? "Type model ID and press Enter" : ""
+							}
+							className="min-w-35 flex-1 bg-transparent text-sm text-foreground placeholder:text-muted-foreground/50 outline-none"
+						/>
+					</div>
+					<p className="mt-1.5 text-xs text-muted-foreground">
+						Add at least one model or set a Model Source URL.
+					</p>
+				</div>
+
+				{form.models.length > 1 ? (
+					<div className="rounded-lg border border-border p-5">
+						<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+							Default Model
+						</Label>
+						<select
+							value={form.defaultModel}
+							onChange={(e) =>
+								setForm((prev) => ({ ...prev, defaultModel: e.target.value }))
+							}
+							className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground outline-none focus:ring-1 focus:ring-ring"
+						>
+							{form.models.map((model) => (
+								<option key={model} value={model}>
+									{model}
+								</option>
+							))}
+						</select>
+					</div>
+				) : null}
+
+				<div className="rounded-lg border border-border p-5">
+					<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+						API Key (Optional)
+					</Label>
+					<div className="relative">
+						<input
+							type={showApiKey ? "text" : "password"}
+							value={form.apiKey}
+							onChange={(e) =>
+								setForm((prev) => ({ ...prev, apiKey: e.target.value }))
+							}
+							placeholder="sk-..."
+							className="w-full rounded-lg border border-border bg-input px-3 py-2 pr-20 font-mono text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+						/>
+						<div className="absolute right-2 top-1/2 flex -translate-y-1/2 items-center gap-1">
+							<Button
+								onClick={() => setShowApiKey(!showApiKey)}
+								variant="ghost"
+								className="rounded-md p-1 transition-colors"
+								aria-label={showApiKey ? "Hide API key" : "Show API key"}
+							>
+								{showApiKey ? (
+									<EyeOff className="h-4 w-4" />
+								) : (
+									<Eye className="h-4 w-4" />
+								)}
+							</Button>
+							<Button
+								onClick={() => navigator.clipboard.writeText(form.apiKey)}
+								variant="ghost"
+								className="rounded-md p-1 transition-colors"
+								aria-label="Copy API key"
+							>
+								<Copy className="h-4 w-4" />
+							</Button>
+						</div>
+					</div>
+				</div>
+
+				<div className="rounded-lg border border-border p-5">
+					<Label className="mb-3 block text-xs font-medium text-muted-foreground">
+						Capabilities
+					</Label>
+					<div className="flex flex-wrap gap-2">
+						{CAPABILITY_OPTIONS.map((cap) => (
+							<Button
+								key={cap}
+								onClick={() => toggleCapability(cap)}
+								className={cn(
+									"rounded-lg border px-3 py-1.5 text-xs font-medium transition-all",
+									form.capabilities.includes(cap)
+										? "border-primary/40 bg-primary/10 text-primary"
+										: "border-border bg-card text-muted-foreground hover:border-muted-foreground/50 hover:text-foreground",
+								)}
+							>
+								{cap.replace(/-/g, " ")}
+							</Button>
+						))}
+					</div>
+				</div>
+
+				<div className="rounded-lg border border-border overflow-hidden">
+					<Button
+						onClick={() => setShowAdvanced(!showAdvanced)}
+						className="flex w-full items-center justify-between px-5 py-4 text-sm font-medium transition-colors text-foreground/40"
+						variant="ghost"
+					>
+						Advanced Settings
+						<ChevronDown
+							className={cn(
+								"h-4 w-4 text-muted-foreground transition-transform",
+								showAdvanced && "rotate-180",
+							)}
+						/>
+					</Button>
+
+					{showAdvanced ? (
+						<div className="border-t border-border px-5 py-5 flex flex-col gap-5">
+							<div>
+								<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+									Timeout (ms)
+								</Label>
+								<input
+									type="number"
+									value={form.timeoutMs}
+									onChange={(e) =>
+										setForm((prev) => ({
+											...prev,
+											timeoutMs: e.target.value,
+										}))
+									}
+									placeholder="30000"
+									className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+								/>
+							</div>
+
+							<div>
+								<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+									Custom Headers
+								</Label>
+								<div className="flex flex-col gap-2">
+									{Object.entries(form.headers).map(([key, value], idx) => (
+										<div key={key} className="flex items-center gap-2">
+											<input
+												type="text"
+												value={key}
+												onChange={(e) =>
+													updateHeaderKey(key, e.target.value, idx)
+												}
+												placeholder="Header name"
+												className="flex-1 rounded-lg border border-border bg-input px-3 py-2 font-mono text-xs text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+											/>
+											<input
+												type="text"
+												value={value}
+												onChange={(e) => updateHeaderValue(key, e.target.value)}
+												placeholder="Value"
+												className="flex-1 rounded-lg border border-border bg-input px-3 py-2 font-mono text-xs text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+											/>
+											<Button
+												onClick={() => removeHeader(key)}
+												className="rounded-md p-2 text-muted-foreground hover:text-destructive transition-colors"
+												aria-label="Remove header"
+											>
+												<Trash2 className="h-4 w-4" />
+											</Button>
+										</div>
+									))}
+									<Button
+										onClick={addHeader}
+										className="flex items-center gap-1.5 rounded-md px-2 py-1.5 text-xs font-medium text-muted-foreground hover:text-foreground transition-colors w-fit"
+									>
+										<Plus className="h-3 w-3" />
+										Add Header
+									</Button>
+								</div>
+							</div>
+						</div>
+					) : null}
+				</div>
+
+				{error ? <p className="text-sm text-destructive">{error}</p> : null}
+
+				<div className="flex items-center justify-end gap-3 pt-2">
+					<Button
+						onClick={onBack}
+						className="rounded-lg border border-border px-4 py-2 text-sm font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+					>
+						Cancel
+					</Button>
+					<Button
+						onClick={() => void handleSave()}
+						disabled={!canSave || saving}
+						className={cn(
+							"rounded-lg px-4 py-2 text-sm font-medium transition-colors",
+							canSave && !saving
+								? "bg-primary text-primary-foreground hover:bg-primary/90"
+								: "bg-muted text-muted-foreground cursor-not-allowed",
+						)}
+					>
+						{saving ? "Saving..." : "Add Provider"}
+					</Button>
+				</div>
+			</div>
+		</PageFrame>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/channels-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/channels-view.tsx
new file mode 100644
index 0000000..967e34b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/channels-view.tsx
@@ -0,0 +1,642 @@
+"use client";
+
+import { Circle, Plus, RefreshCw, Trash2 } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { desktopClient } from "@/lib/desktop-client";
+import { cn } from "@/lib/utils";
+import {
+	CommandBadge,
+	PageEmptyState,
+	PageFrame,
+	PageHeader,
+} from "../page-layout";
+
+type ConnectorField = {
+	flag: string;
+	label: string;
+	placeholder?: string;
+	required?: boolean;
+	help?: string[];
+	initialValue?: string;
+	options?: Array<{ value: string; label: string; hint?: string }>;
+	includeWhen?: {
+		flag: string;
+		equals?: string;
+		notEquals?: string;
+	};
+};
+
+type ConnectorSecurityField = {
+	key: string;
+	label: string;
+	placeholder?: string;
+	help?: string[];
+	requiredMessage: string;
+};
+
+type ConnectorChannel = {
+	id: string;
+	name: string;
+	type: "polling" | "webhook" | "hybrid";
+	hint: string;
+	fields: ConnectorField[];
+	security?: {
+		prompt: string;
+		fields: ConnectorSecurityField[];
+	};
+};
+
+type ActiveConnector = {
+	id: string;
+	type: string;
+	pid: number;
+	hubUrl: string;
+	startedAt?: string;
+	applicationId?: string;
+	botUsername?: string;
+	userName?: string;
+	phoneNumberId?: string;
+	port?: number;
+	baseUrl?: string;
+	connectionMode?: string;
+};
+
+type ConnectorChannelsResponse = {
+	available: ConnectorChannel[];
+	active: ActiveConnector[];
+};
+
+type ConnectorFormState = {
+	channelId: string;
+	values: Record<string, string>;
+	securityEnabled: boolean;
+	securityValues: Record<string, string>;
+};
+
+function connectorName(
+	connector: ActiveConnector,
+	channels: ConnectorChannel[],
+): string {
+	return (
+		channels.find((channel) => channel.id === connector.type)?.name ??
+		connector.type
+	);
+}
+
+function connectorIdentity(connector: ActiveConnector): string {
+	if (connector.botUsername) {
+		return `@${connector.botUsername}`;
+	}
+	if (connector.userName) {
+		return connector.userName;
+	}
+	if (connector.applicationId) {
+		return connector.applicationId;
+	}
+	return `pid ${connector.pid}`;
+}
+
+function formatDateTime(value?: string): string {
+	if (!value) {
+		return "-";
+	}
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+}
+
+function isSecretField(
+	field: ConnectorField | ConnectorSecurityField,
+): boolean {
+	const label = field.label.toLowerCase();
+	const key =
+		"flag" in field ? field.flag.toLowerCase() : field.key.toLowerCase();
+	return (
+		label.includes("token") ||
+		label.includes("secret") ||
+		label.includes("key") ||
+		key.includes("token") ||
+		key.includes("secret") ||
+		key.includes("key")
+	);
+}
+
+function isMultilineField(field: ConnectorField): boolean {
+	const label = field.label.toLowerCase();
+	return label.includes("json") || field.flag.includes("credentials");
+}
+
+function shouldIncludeField(
+	field: ConnectorField,
+	values: Record<string, string>,
+): boolean {
+	const condition = field.includeWhen;
+	if (!condition) {
+		return true;
+	}
+	const value = values[condition.flag] ?? "";
+	if (condition.equals !== undefined && value !== condition.equals) {
+		return false;
+	}
+	if (condition.notEquals !== undefined && value === condition.notEquals) {
+		return false;
+	}
+	return true;
+}
+
+function initialValuesForChannel(
+	channel?: ConnectorChannel,
+): Record<string, string> {
+	const values: Record<string, string> = {};
+	for (const field of channel?.fields ?? []) {
+		if (field.initialValue) {
+			values[field.flag] = field.initialValue;
+		}
+	}
+	return values;
+}
+
+function createFormState(channels: ConnectorChannel[]): ConnectorFormState {
+	const channel = channels[0];
+	return {
+		channelId: channel?.id ?? "",
+		values: initialValuesForChannel(channel),
+		securityEnabled: false,
+		securityValues: {},
+	};
+}
+
+export function ChannelsContent() {
+	const [channels, setChannels] = useState<ConnectorChannel[]>([]);
+	const [activeConnectors, setActiveConnectors] = useState<ActiveConnector[]>(
+		[],
+	);
+	const [isLoading, setIsLoading] = useState(true);
+	const [busyChannel, setBusyChannel] = useState<string | null>(null);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [formState, setFormState] = useState<ConnectorFormState>({
+		channelId: "",
+		values: {},
+		securityEnabled: false,
+		securityValues: {},
+	});
+	const [formError, setFormError] = useState<string | null>(null);
+	const [removeTarget, setRemoveTarget] = useState<ActiveConnector | null>(
+		null,
+	);
+
+	const selectedChannel = useMemo(
+		() => channels.find((channel) => channel.id === formState.channelId),
+		[channels, formState.channelId],
+	);
+	const visibleFields = useMemo(() => {
+		const values = {
+			...initialValuesForChannel(selectedChannel),
+			...formState.values,
+		};
+		return (selectedChannel?.fields ?? []).filter((field) =>
+			shouldIncludeField(field, values),
+		);
+	}, [selectedChannel, formState.values]);
+
+	const applyResponse = useCallback((response: ConnectorChannelsResponse) => {
+		setChannels(response.available);
+		setActiveConnectors(response.active);
+		setFormState((prev) =>
+			prev.channelId ? prev : createFormState(response.available),
+		);
+	}, []);
+
+	const refreshChannels = useCallback(async () => {
+		setIsLoading(true);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<ConnectorChannelsResponse>(
+				"list_connector_channels",
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsLoading(false);
+		}
+	}, [applyResponse]);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refreshChannels();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refreshChannels]);
+
+	const openAddDialog = () => {
+		setFormState(createFormState(channels));
+		setFormError(null);
+		setDialogOpen(true);
+	};
+
+	const updateFieldValue = (flag: string, value: string) => {
+		setFormState((prev) => ({
+			...prev,
+			values: { ...prev.values, [flag]: value },
+		}));
+	};
+
+	const updateSecurityFieldValue = (key: string, value: string) => {
+		setFormState((prev) => ({
+			...prev,
+			securityValues: { ...prev.securityValues, [key]: value },
+		}));
+	};
+
+	const startConnector = async () => {
+		if (!selectedChannel) {
+			setFormError("Choose a channel");
+			return;
+		}
+		for (const field of selectedChannel.fields) {
+			if (!visibleFields.includes(field)) {
+				continue;
+			}
+			if (field.required && !formState.values[field.flag]?.trim()) {
+				setFormError(`${field.label} is required`);
+				return;
+			}
+		}
+		if (formState.securityEnabled && selectedChannel.security) {
+			for (const field of selectedChannel.security.fields) {
+				if (!formState.securityValues[field.key]?.trim()) {
+					setFormError(field.requiredMessage);
+					return;
+				}
+			}
+		}
+		setBusyChannel(selectedChannel.id);
+		setFormError(null);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<ConnectorChannelsResponse>(
+				"start_connector_channel",
+				{
+					channel: selectedChannel.id,
+					values: formState.values,
+					security: {
+						enabled: formState.securityEnabled,
+						values: formState.securityValues,
+					},
+				},
+			);
+			applyResponse(response);
+			setDialogOpen(false);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setFormError(message);
+		} finally {
+			setBusyChannel(null);
+		}
+	};
+
+	const stopConnector = async (connector: ActiveConnector) => {
+		setBusyChannel(connector.type);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<ConnectorChannelsResponse>(
+				"stop_connector_channel",
+				{ channel: connector.type },
+			);
+			applyResponse(response);
+			setRemoveTarget(null);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyChannel(null);
+		}
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description={`${activeConnectors.length} connected. Start and manage connector channels for Cline Hub.`}
+				title="Channels"
+				meta={<CommandBadge>cline connect</CommandBadge>}
+				actions={
+					<>
+						<Button
+							disabled={isLoading}
+							onClick={() => void refreshChannels()}
+							size="sm"
+							type="button"
+							variant="outline"
+						>
+							<RefreshCw
+								className={cn("size-4", isLoading && "animate-spin")}
+							/>
+						</Button>
+						<Button
+							disabled={channels.length === 0}
+							onClick={openAddDialog}
+							size="sm"
+							type="button"
+						>
+							<Plus className="size-4" />
+							Add Channel
+						</Button>
+					</>
+				}
+			/>
+
+			{errorMessage ? (
+				<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			) : null}
+
+			{isLoading ? (
+				<PageEmptyState>Loading channels...</PageEmptyState>
+			) : activeConnectors.length === 0 ? (
+				<PageEmptyState>No channels connected.</PageEmptyState>
+			) : (
+				<section className="overflow-hidden rounded-lg border bg-card">
+					<div className="grid gap-2 p-2.5">
+						{activeConnectors.map((connector) => (
+							<div
+								className="grid gap-3 border bg-[color-mix(in_oklch,var(--background)_70%,var(--card))] p-3 md:grid-cols-[minmax(0,1fr)_auto] md:items-center"
+								key={connector.id}
+							>
+								<div className="min-w-0">
+									<div className="flex items-center gap-2">
+										<Circle className="size-2 fill-emerald-300 text-emerald-300" />
+										<p className="truncate text-[13px] font-semibold leading-tight">
+											{connectorName(connector, channels)}
+										</p>
+										<span className="rounded-md border bg-background px-1.5 py-0.5 text-[11px] text-muted-foreground">
+											{connectorIdentity(connector)}
+										</span>
+									</div>
+									<div className="mt-2 flex flex-wrap gap-1.5 text-[11px] text-muted-foreground">
+										<span className="rounded-md border bg-background px-1.5 py-0.5">
+											pid={connector.pid}
+										</span>
+										<span
+											className="max-w-full break-all rounded-md border bg-background px-1.5 py-0.5"
+											title={connector.hubUrl}
+										>
+											{connector.hubUrl}
+										</span>
+										{connector.baseUrl ? (
+											<span
+												className="max-w-full break-all rounded-md border bg-background px-1.5 py-0.5"
+												title={connector.baseUrl}
+											>
+												{connector.baseUrl}
+											</span>
+										) : null}
+										<span className="rounded-md border bg-background px-1.5 py-0.5">
+											{formatDateTime(connector.startedAt)}
+										</span>
+										{connector.connectionMode ? (
+											<span className="rounded-md border bg-background px-1.5 py-0.5">
+												{connector.connectionMode}
+											</span>
+										) : null}
+									</div>
+								</div>
+								<Button
+									disabled={busyChannel === connector.type}
+									onClick={() => setRemoveTarget(connector)}
+									size="sm"
+									type="button"
+									variant="outline"
+								>
+									<Trash2 className="size-4" />
+									Remove...
+								</Button>
+							</div>
+						))}
+					</div>
+				</section>
+			)}
+
+			<Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
+				<DialogContent className="max-h-[86vh] overflow-y-auto sm:max-w-xl">
+					<DialogHeader>
+						<DialogTitle>Add Channel</DialogTitle>
+						<DialogDescription>
+							Start a connector channel for Cline Hub.
+						</DialogDescription>
+					</DialogHeader>
+					<div className="grid gap-4 py-2">
+						<div className="grid gap-2">
+							<Label>Channel</Label>
+							<Select
+								onValueChange={(value) => {
+									if (!value) {
+										return;
+									}
+									setFormState({
+										channelId: value,
+										values: initialValuesForChannel(
+											channels.find((channel) => channel.id === value),
+										),
+										securityEnabled: false,
+										securityValues: {},
+									});
+								}}
+								value={formState.channelId}
+							>
+								<SelectTrigger>
+									<SelectValue placeholder="Select channel" />
+								</SelectTrigger>
+								<SelectContent>
+									{channels.map((channel) => (
+										<SelectItem key={channel.id} value={channel.id}>
+											{channel.name}
+										</SelectItem>
+									))}
+								</SelectContent>
+							</Select>
+						</div>
+
+						{visibleFields.map((field) => (
+							<div className="grid gap-2" key={field.flag}>
+								<Label>
+									{field.label}
+									{field.required ? (
+										<span className="text-destructive"> *</span>
+									) : null}
+								</Label>
+								{field.options ? (
+									<Select
+										onValueChange={(value) => {
+											if (value) {
+												updateFieldValue(field.flag, value);
+											}
+										}}
+										value={
+											formState.values[field.flag] ?? field.initialValue ?? ""
+										}
+									>
+										<SelectTrigger>
+											<SelectValue placeholder={field.placeholder} />
+										</SelectTrigger>
+										<SelectContent>
+											{field.options.map((option) => (
+												<SelectItem key={option.value} value={option.value}>
+													{option.label}
+												</SelectItem>
+											))}
+										</SelectContent>
+									</Select>
+								) : isMultilineField(field) ? (
+									<Textarea
+										onChange={(event) =>
+											updateFieldValue(field.flag, event.target.value)
+										}
+										placeholder={field.placeholder}
+										rows={5}
+										value={formState.values[field.flag] ?? ""}
+									/>
+								) : (
+									<Input
+										onChange={(event) =>
+											updateFieldValue(field.flag, event.target.value)
+										}
+										placeholder={field.placeholder}
+										type={isSecretField(field) ? "password" : "text"}
+										value={formState.values[field.flag] ?? ""}
+									/>
+								)}
+							</div>
+						))}
+
+						{selectedChannel?.security ? (
+							<div className="grid gap-3 rounded-lg border p-3">
+								<div className="flex items-center justify-between gap-3">
+									<Label className="text-sm">Restrict access</Label>
+									<Switch
+										checked={formState.securityEnabled}
+										onCheckedChange={(checked: boolean) =>
+											setFormState((prev) => ({
+												...prev,
+												securityEnabled: checked,
+											}))
+										}
+									/>
+								</div>
+								{formState.securityEnabled
+									? selectedChannel.security.fields.map((field) => (
+											<div className="grid gap-2" key={field.key}>
+												<Label>{field.label}</Label>
+												<Input
+													onChange={(event) =>
+														updateSecurityFieldValue(
+															field.key,
+															event.target.value,
+														)
+													}
+													placeholder={field.placeholder}
+													type={isSecretField(field) ? "password" : "text"}
+													value={formState.securityValues[field.key] ?? ""}
+												/>
+											</div>
+										))
+									: null}
+							</div>
+						) : null}
+
+						{formError ? (
+							<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+								{formError}
+							</div>
+						) : null}
+					</div>
+					<DialogFooter>
+						<Button
+							disabled={busyChannel !== null}
+							onClick={() => setDialogOpen(false)}
+							type="button"
+							variant="outline"
+						>
+							Cancel
+						</Button>
+						<Button
+							disabled={busyChannel !== null || !selectedChannel}
+							onClick={() => void startConnector()}
+							type="button"
+						>
+							{busyChannel ? "Starting..." : "Add Channel"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+
+			<AlertDialog
+				open={removeTarget !== null}
+				onOpenChange={(open: boolean) => {
+					if (!open) {
+						setRemoveTarget(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Remove Channel</AlertDialogTitle>
+						<AlertDialogDescription>
+							Confirm that you want to stop the active{" "}
+							{removeTarget ? connectorName(removeTarget, channels) : "channel"}{" "}
+							channel for {removeTarget ? connectorIdentity(removeTarget) : ""}.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={busyChannel !== null}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={busyChannel !== null || !removeTarget}
+							onClick={() => {
+								if (removeTarget) {
+									void stopConnector(removeTarget);
+								}
+							}}
+							variant="destructive"
+						>
+							Remove
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</PageFrame>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/extensions-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/extensions-view.tsx
new file mode 100644
index 0000000..beed8aa
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/extensions-view.tsx
@@ -0,0 +1,1769 @@
+"use client";
+
+import {
+	Bot,
+	Code,
+	FileText,
+	Play,
+	Puzzle,
+	RefreshCw,
+	Server,
+	Trash2,
+	TriangleAlert,
+	Wrench,
+	Zap,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Spinner } from "@/components/ui/spinner";
+import { Switch } from "@/components/ui/switch";
+import { desktopClient } from "@/lib/desktop-client";
+import type { MarketplacePrimitiveType } from "@/lib/marketplace";
+import { cn } from "@/lib/utils";
+import {
+	type MarketplaceLocalInstalledItem,
+	MarketplaceView,
+} from "../marketplace-view";
+import { CommandBadge, PageFrame, PageHeader } from "../page-layout";
+
+export type CustomizationSection =
+	| "Rules"
+	| "Hooks"
+	| "MCP"
+	| "Skills"
+	| "Agents"
+	| "Plugins"
+	| "Tools";
+
+const sectionDescriptions: Record<CustomizationSection, string> = {
+	Rules: "Review project and global rule files that shape Cline behavior.",
+	Hooks: "Inspect hook configuration and recent execution status.",
+	MCP: "Manage installed MCP servers and add new servers from the marketplace.",
+	Skills: "Manage installed skills and add new skills from the marketplace.",
+	Agents: "Review configured agents discovered from local settings.",
+	Plugins: "Manage installed plugins and add new plugins from the marketplace.",
+	Tools: "Inspect built-in tools and tools contributed by plugins.",
+};
+
+const sectionCommands: Record<CustomizationSection, string> = {
+	Rules: "cline config rules",
+	Hooks: "cline config hooks",
+	MCP: "cline mcp install",
+	Skills: "cline skill",
+	Agents: "cline config agents",
+	Plugins: "cline plugin",
+	Tools: "cline config tools",
+};
+
+type RuleItem = {
+	name: string;
+	instructions: string;
+	path: string;
+};
+
+type WorkflowItem = {
+	id: string;
+	name: string;
+	instructions: string;
+	path: string;
+};
+
+type SkillItem = {
+	name: string;
+	description?: string;
+	instructions: string;
+	path: string;
+};
+
+type CommandItem = {
+	id: string;
+	type: "workflow" | "skill";
+	name: string;
+	description?: string;
+	instructions: string;
+	path: string;
+	scope: ItemScope;
+};
+
+type ItemScope = "Global" | "Project";
+
+type AgentItem = {
+	name: string;
+	path: string;
+};
+
+type PluginItem = {
+	name: string;
+	path: string;
+	enabled: boolean;
+};
+
+type ToolItem = {
+	id: string;
+	name: string;
+	description?: string;
+	enabled: boolean;
+	source: string;
+	path?: string;
+	pluginName?: string;
+	headlessToolNames?: string[];
+};
+
+type HookItem = {
+	fileName: string;
+	hookEventName?: string;
+	path: string;
+};
+
+type SessionHookEvent = {
+	ts: string;
+	hookEventName: string;
+};
+
+type CliDiscoveredSession = {
+	sessionId: string;
+	startedAt: string;
+};
+
+type HookExecutionSummary = {
+	count: number;
+	lastTs: string | null;
+};
+
+type McpServer = {
+	name: string;
+	transportType: "stdio" | "sse" | "streamableHttp";
+	disabled: boolean;
+	command?: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	metadata?: unknown;
+};
+
+type McpServersResponse = {
+	settingsPath: string;
+	hasSettingsFile: boolean;
+	servers: McpServer[];
+};
+
+type LocalUninstallType = "mcp" | "skill" | "workflow" | "plugin";
+
+type LocalUninstallTarget = {
+	key: string;
+	type: LocalUninstallType;
+	id?: string;
+	name?: string;
+	path?: string;
+};
+
+type UserInstructionListsResponse = {
+	workspaceRoot: string;
+	rules: RuleItem[];
+	workflows: WorkflowItem[];
+	skills: SkillItem[];
+	agents: AgentItem[];
+	plugins: PluginItem[];
+	tools: ToolItem[];
+	hooks: HookItem[];
+	mcp: McpServersResponse;
+	warnings: string[];
+};
+
+const EMPTY_MCP_RESPONSE: McpServersResponse = {
+	settingsPath: "",
+	hasSettingsFile: false,
+	servers: [],
+};
+
+function asArray<T>(value: T[] | null | undefined): T[] {
+	return Array.isArray(value) ? value : [];
+}
+
+function normalizeInstructionListsResponse(
+	response: Partial<UserInstructionListsResponse> | null | undefined,
+): UserInstructionListsResponse {
+	return {
+		workspaceRoot:
+			typeof response?.workspaceRoot === "string" ? response.workspaceRoot : "",
+		rules: asArray(response?.rules),
+		workflows: asArray(response?.workflows),
+		skills: asArray(response?.skills),
+		agents: asArray(response?.agents),
+		plugins: asArray(response?.plugins),
+		tools: asArray(response?.tools),
+		hooks: asArray(response?.hooks),
+		mcp:
+			response?.mcp && typeof response.mcp === "object"
+				? {
+						settingsPath:
+							typeof response.mcp.settingsPath === "string"
+								? response.mcp.settingsPath
+								: "",
+						hasSettingsFile: Boolean(response.mcp.hasSettingsFile),
+						servers: asArray(response.mcp.servers),
+					}
+				: {
+						...EMPTY_MCP_RESPONSE,
+					},
+		warnings: asArray(response?.warnings),
+	};
+}
+
+const EXTENSION_LISTS_CACHE_TTL_MS = 60_000;
+const EXTENSION_HOOK_STATS_CACHE_TTL_MS = 30_000;
+
+let extensionListsCache:
+	| (UserInstructionListsResponse & {
+			fetchedAt: number;
+	  })
+	| null = null;
+
+let extensionHookStatsCache: {
+	hookExecutionByEvent: Record<string, HookExecutionSummary>;
+	hookExecutionSessionId: string | null;
+	fetchedAt: number;
+} | null = null;
+
+function hasFreshExtensionsListsCache(
+	cache: typeof extensionListsCache,
+	now: number,
+): cache is NonNullable<typeof extensionListsCache> {
+	return Boolean(
+		cache &&
+			now - cache.fetchedAt < EXTENSION_LISTS_CACHE_TTL_MS &&
+			Array.isArray(cache.tools) &&
+			cache.tools.length > 0,
+	);
+}
+
+function previewText(input: string, maxLength = 150): string {
+	const compact = input.replace(/\s+/g, " ").trim();
+	if (compact.length <= maxLength) {
+		return compact;
+	}
+	return `${compact.slice(0, maxLength).trimEnd()}...`;
+}
+
+function normalizePath(path: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+function getPathScope(path: string, workspaceRoot: string): ItemScope {
+	const normalizedRoot = normalizePath(workspaceRoot);
+	const normalized = normalizePath(path);
+	return normalizedRoot && normalized.startsWith(`${normalizedRoot}/`)
+		? "Project"
+		: "Global";
+}
+
+function ScopeBadge({ scope }: { scope: ItemScope }) {
+	return (
+		<Badge variant="outline" className="shrink-0 text-muted-foreground">
+			{scope}
+		</Badge>
+	);
+}
+
+function getLocalMarketplaceMatchValues(
+	...values: Array<string | undefined>
+): string[] {
+	const matchValues = new Set<string>();
+	for (const value of values) {
+		const normalized = value?.trim().replaceAll("\\", "/");
+		if (!normalized) {
+			continue;
+		}
+		matchValues.add(normalized);
+		const segments = normalized.split("/").filter(Boolean);
+		for (const segment of segments) {
+			matchValues.add(segment.replace(/\.[^.]+$/, ""));
+		}
+		for (let index = 0; index < segments.length - 1; index += 1) {
+			matchValues.add(`${segments[index]}/${segments[index + 1]}`);
+		}
+	}
+	return [...matchValues];
+}
+
+async function fetchUserInstructionLists(): Promise<UserInstructionListsResponse> {
+	const response = await desktopClient.invoke<
+		Partial<UserInstructionListsResponse>
+	>("list_user_instruction_configs");
+	return normalizeInstructionListsResponse(response);
+}
+
+function isUnsupportedDesktopCommand(error: unknown, command: string): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes(`unsupported desktop command: ${command}`);
+}
+
+export function CustomizationSectionView({
+	catalogPrimitive,
+	section = "Rules",
+	showTabs = false,
+}: {
+	catalogPrimitive?: MarketplacePrimitiveType;
+	section?: CustomizationSection;
+	showTabs?: boolean;
+}) {
+	const [activeTab, setActiveTab] = useState<CustomizationSection>(section);
+	const [isLoading, setIsLoading] = useState(
+		() => !hasFreshExtensionsListsCache(extensionListsCache, Date.now()),
+	);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [workspaceRoot, setWorkspaceRoot] = useState(
+		() => extensionListsCache?.workspaceRoot ?? "",
+	);
+	const [rules, setRules] = useState<RuleItem[]>(
+		() => extensionListsCache?.rules ?? [],
+	);
+	const [workflows, setWorkflows] = useState<WorkflowItem[]>(
+		() => extensionListsCache?.workflows ?? [],
+	);
+	const [skills, setSkills] = useState<SkillItem[]>(
+		() => extensionListsCache?.skills ?? [],
+	);
+	const [agents, setAgents] = useState<AgentItem[]>(
+		() => extensionListsCache?.agents ?? [],
+	);
+	const [plugins, setPlugins] = useState<PluginItem[]>(
+		() => extensionListsCache?.plugins ?? [],
+	);
+	const [tools, setTools] = useState<ToolItem[]>(
+		() => extensionListsCache?.tools ?? [],
+	);
+	const [hooks, setHooks] = useState<HookItem[]>(
+		() => extensionListsCache?.hooks ?? [],
+	);
+	const [mcp, setMcp] = useState<McpServersResponse>(
+		() => extensionListsCache?.mcp ?? EMPTY_MCP_RESPONSE,
+	);
+	const [warnings, setWarnings] = useState<string[]>(
+		() => extensionListsCache?.warnings ?? [],
+	);
+	const [hookExecutionByEvent, setHookExecutionByEvent] = useState<
+		Record<string, HookExecutionSummary>
+	>(() => extensionHookStatsCache?.hookExecutionByEvent ?? {});
+	const [hookExecutionSessionId, setHookExecutionSessionId] = useState<
+		string | null
+	>(() => extensionHookStatsCache?.hookExecutionSessionId ?? null);
+	const [hookExecutionLoading, setHookExecutionLoading] = useState(false);
+	const [togglingToolIds, setTogglingToolIds] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const [togglingPluginPaths, setTogglingPluginPaths] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const [localUninstallingKeys, setLocalUninstallingKeys] = useState<
+		Set<string>
+	>(() => new Set());
+	const [localActionMessages, setLocalActionMessages] = useState<
+		Map<string, { status: "success" | "failed"; message: string }>
+	>(() => new Map());
+
+	useEffect(() => {
+		setActiveTab(section);
+	}, [section]);
+
+	const refresh = useCallback(async (force = false) => {
+		const now = Date.now();
+		if (!force && hasFreshExtensionsListsCache(extensionListsCache, now)) {
+			setWorkspaceRoot(extensionListsCache.workspaceRoot);
+			setRules(extensionListsCache.rules);
+			setWorkflows(extensionListsCache.workflows);
+			setSkills(extensionListsCache.skills);
+			setAgents(extensionListsCache.agents);
+			setPlugins(extensionListsCache.plugins);
+			setTools(extensionListsCache.tools);
+			setHooks(extensionListsCache.hooks);
+			setMcp(extensionListsCache.mcp);
+			setWarnings(extensionListsCache.warnings);
+			setErrorMessage(null);
+			setIsLoading(false);
+			return;
+		}
+
+		setIsLoading(true);
+		setErrorMessage(null);
+		try {
+			const response = await fetchUserInstructionLists();
+			setWorkspaceRoot(response.workspaceRoot);
+			setRules(response.rules);
+			setWorkflows(response.workflows);
+			setSkills(response.skills);
+			setAgents(response.agents);
+			setPlugins(response.plugins);
+			setTools(response.tools);
+			setHooks(response.hooks);
+			setMcp(response.mcp);
+			setWarnings(response.warnings);
+			extensionListsCache = {
+				...response,
+				fetchedAt: Date.now(),
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsLoading(false);
+		}
+	}, []);
+
+	const loadHookExecutionStats = useCallback(async (force = false) => {
+		const now = Date.now();
+		if (
+			!force &&
+			extensionHookStatsCache &&
+			now - extensionHookStatsCache.fetchedAt <
+				EXTENSION_HOOK_STATS_CACHE_TTL_MS
+		) {
+			setHookExecutionByEvent(extensionHookStatsCache.hookExecutionByEvent);
+			setHookExecutionSessionId(extensionHookStatsCache.hookExecutionSessionId);
+			return;
+		}
+
+		setHookExecutionLoading(true);
+		try {
+			const sessions = await desktopClient.invoke<CliDiscoveredSession[]>(
+				"list_cli_sessions",
+				{
+					limit: 300,
+				},
+			);
+			const latestSession = (sessions ?? [])
+				.filter(
+					(session) =>
+						typeof session.sessionId === "string" &&
+						session.sessionId.trim().length > 0,
+				)
+				.sort((left, right) =>
+					(right.startedAt ?? "").localeCompare(left.startedAt ?? ""),
+				)[0];
+			if (!latestSession?.sessionId) {
+				setHookExecutionByEvent({});
+				setHookExecutionSessionId(null);
+				extensionHookStatsCache = {
+					hookExecutionByEvent: {},
+					hookExecutionSessionId: null,
+					fetchedAt: Date.now(),
+				};
+				return;
+			}
+
+			const events = await desktopClient.invoke<SessionHookEvent[]>(
+				"read_session_hooks",
+				{
+					sessionId: latestSession.sessionId,
+					limit: 5000,
+				},
+			);
+			const next: Record<string, HookExecutionSummary> = {};
+			for (const event of events ?? []) {
+				const hookName = event.hookEventName?.trim();
+				if (!hookName) {
+					continue;
+				}
+				const current = next[hookName] ?? {
+					count: 0,
+					lastTs: null,
+				};
+				current.count += 1;
+				if (event.ts && (!current.lastTs || event.ts > current.lastTs)) {
+					current.lastTs = event.ts;
+				}
+				next[hookName] = current;
+			}
+			setHookExecutionByEvent(next);
+			setHookExecutionSessionId(latestSession.sessionId);
+			extensionHookStatsCache = {
+				hookExecutionByEvent: next,
+				hookExecutionSessionId: latestSession.sessionId,
+				fetchedAt: Date.now(),
+			};
+		} catch {
+			// Keep existing execution status when lookup fails.
+		} finally {
+			setHookExecutionLoading(false);
+		}
+	}, []);
+
+	const applyResponse = useCallback(
+		(response: Partial<UserInstructionListsResponse>) => {
+			const normalizedResponse = normalizeInstructionListsResponse(response);
+			setWorkspaceRoot(normalizedResponse.workspaceRoot);
+			setRules(normalizedResponse.rules);
+			setWorkflows(normalizedResponse.workflows);
+			setSkills(normalizedResponse.skills);
+			setAgents(normalizedResponse.agents);
+			setPlugins(normalizedResponse.plugins);
+			setTools(normalizedResponse.tools);
+			setHooks(normalizedResponse.hooks);
+			setMcp(normalizedResponse.mcp);
+			setWarnings(normalizedResponse.warnings);
+			extensionListsCache = {
+				...normalizedResponse,
+				fetchedAt: Date.now(),
+			};
+		},
+		[],
+	);
+
+	const setToolEnabled = useCallback(
+		async (tool: ToolItem) => {
+			setTogglingToolIds((current) => new Set(current).add(tool.id));
+			setErrorMessage(null);
+			try {
+				const names = [tool.name, ...(tool.headlessToolNames ?? [])].filter(
+					Boolean,
+				);
+				if (names.length === 0) {
+					throw new Error("tool name is required");
+				}
+				let response: UserInstructionListsResponse | undefined;
+				try {
+					response = await desktopClient.invoke<UserInstructionListsResponse>(
+						"set_tool_disabled",
+						{
+							names,
+							disabled: tool.enabled,
+						},
+					);
+				} catch (error) {
+					if (!isUnsupportedDesktopCommand(error, "set_tool_disabled")) {
+						throw error;
+					}
+					for (const name of names) {
+						response = await desktopClient.invoke<UserInstructionListsResponse>(
+							"toggle_disabled_plugin_tool",
+							{ name },
+						);
+					}
+				}
+				if (!response) {
+					throw new Error(
+						"tool toggle did not return an updated extension list",
+					);
+				}
+				applyResponse(response);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setErrorMessage(message);
+			} finally {
+				setTogglingToolIds((current) => {
+					const next = new Set(current);
+					next.delete(tool.id);
+					return next;
+				});
+			}
+		},
+		[applyResponse],
+	);
+
+	const setPluginEnabled = useCallback(
+		async (plugin: PluginItem) => {
+			setTogglingPluginPaths((current) => new Set(current).add(plugin.path));
+			setErrorMessage(null);
+			try {
+				const response =
+					await desktopClient.invoke<UserInstructionListsResponse>(
+						"set_plugin_disabled",
+						{
+							path: plugin.path,
+							disabled: plugin.enabled,
+						},
+					);
+				applyResponse(response);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setErrorMessage(message);
+			} finally {
+				setTogglingPluginPaths((current) => {
+					const next = new Set(current);
+					next.delete(plugin.path);
+					return next;
+				});
+			}
+		},
+		[applyResponse],
+	);
+
+	const uninstallLocalPrimitive = useCallback(
+		async (target: LocalUninstallTarget) => {
+			if (localUninstallingKeys.has(target.key)) {
+				return;
+			}
+			setLocalUninstallingKeys((current) => new Set(current).add(target.key));
+			setLocalActionMessages((current) => {
+				const next = new Map(current);
+				next.delete(target.key);
+				return next;
+			});
+			setErrorMessage(null);
+			try {
+				const result = await desktopClient.invoke<{ message?: string }>(
+					"uninstall_local_primitive",
+					{
+						type: target.type,
+						id: target.id,
+						name: target.name,
+						path: target.path,
+					},
+				);
+				setLocalActionMessages((current) => {
+					const next = new Map(current);
+					next.set(target.key, {
+						status: "success",
+						message:
+							result.message ??
+							`Uninstalled ${target.name ?? target.id ?? target.path}.`,
+					});
+					return next;
+				});
+				await refresh(true);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setLocalActionMessages((current) => {
+					const next = new Map(current);
+					next.set(target.key, { status: "failed", message });
+					return next;
+				});
+				setErrorMessage(message);
+			} finally {
+				setLocalUninstallingKeys((current) => {
+					const next = new Set(current);
+					next.delete(target.key);
+					return next;
+				});
+			}
+		},
+		[localUninstallingKeys, refresh],
+	);
+
+	const formatExecutionTs = useCallback((value: string | null): string => {
+		if (!value) {
+			return "never";
+		}
+		const asNumber = Number(value);
+		const date = Number.isFinite(asNumber)
+			? new Date(asNumber)
+			: new Date(value);
+		if (Number.isNaN(date.getTime())) {
+			return value;
+		}
+		return date.toLocaleString();
+	}, []);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refresh(false);
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refresh]);
+
+	useEffect(() => {
+		if (activeTab !== "Hooks") {
+			return;
+		}
+		const timeoutId = window.setTimeout(() => {
+			void loadHookExecutionStats(false);
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [activeTab, loadHookExecutionStats]);
+
+	const tabs: CustomizationSection[] = [
+		"Rules",
+		"Hooks",
+		"Skills",
+		"Agents",
+		"Plugins",
+		"Tools",
+	];
+
+	const commandItems = useMemo<CommandItem[]>(() => {
+		const workflowItems: CommandItem[] = workflows.map((workflow) => ({
+			id: workflow.id,
+			type: "workflow",
+			name: workflow.name,
+			instructions: workflow.instructions,
+			path: workflow.path,
+			scope: getPathScope(workflow.path, workspaceRoot),
+		}));
+		const skillItems: CommandItem[] = skills.map((skill) => ({
+			id: normalizePath(skill.path).toLowerCase(),
+			type: "skill",
+			name: skill.name,
+			description: skill.description,
+			instructions: skill.instructions,
+			path: skill.path,
+			scope: getPathScope(skill.path, workspaceRoot),
+		}));
+		return [...workflowItems, ...skillItems].sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+	}, [skills, workflows, workspaceRoot]);
+
+	const { projectRules, globalRules } = useMemo(() => {
+		const normalizedRoot = normalizePath(workspaceRoot);
+		const project: RuleItem[] = [];
+		const global: RuleItem[] = [];
+		for (const rule of rules) {
+			const normalized = normalizePath(rule.path);
+			if (
+				normalizedRoot &&
+				normalized.startsWith(`${normalizedRoot}/`) &&
+				normalized.includes("/.clinerules/")
+			) {
+				project.push(rule);
+			} else {
+				global.push(rule);
+			}
+		}
+		return { projectRules: project, globalRules: global };
+	}, [rules, workspaceRoot]);
+
+	const { projectHooks, globalHooks } = useMemo(() => {
+		const normalizedRoot = normalizePath(workspaceRoot);
+		const project: HookItem[] = [];
+		const global: HookItem[] = [];
+		for (const hook of hooks) {
+			const normalized = normalizePath(hook.path);
+			if (
+				normalizedRoot &&
+				normalized.startsWith(`${normalizedRoot}/`) &&
+				normalized.includes("/.clinerules/hooks")
+			) {
+				project.push(hook);
+			} else {
+				global.push(hook);
+			}
+		}
+		return { projectHooks: project, globalHooks: global };
+	}, [hooks, workspaceRoot]);
+
+	const { projectPlugins, globalPlugins } = useMemo(() => {
+		const normalizedRoot = normalizePath(workspaceRoot);
+		const project: PluginItem[] = [];
+		const global: PluginItem[] = [];
+		for (const plugin of plugins) {
+			const normalized = normalizePath(plugin.path);
+			if (
+				normalizedRoot &&
+				normalized.startsWith(`${normalizedRoot}/`) &&
+				normalized.includes("/.cline/plugins")
+			) {
+				project.push(plugin);
+			} else {
+				global.push(plugin);
+			}
+		}
+		return { projectPlugins: project, globalPlugins: global };
+	}, [plugins, workspaceRoot]);
+
+	const builtinTools = useMemo(
+		() => tools.filter((tool) => tool.source === "builtin"),
+		[tools],
+	);
+	const pluginTools = useMemo(
+		() => tools.filter((tool) => tool.source !== "builtin"),
+		[tools],
+	);
+	const pluginToolsByPluginKey = useMemo(() => {
+		const grouped = new Map<string, ToolItem[]>();
+		for (const tool of pluginTools) {
+			const key = `${tool.pluginName ?? ""}:${tool.path ?? ""}`;
+			const existing = grouped.get(key) ?? [];
+			existing.push(tool);
+			grouped.set(key, existing);
+		}
+		for (const items of grouped.values()) {
+			items.sort((left, right) => left.name.localeCompare(right.name));
+		}
+		return grouped;
+	}, [pluginTools]);
+
+	const scopedPlugins = useMemo(
+		() => [
+			...globalPlugins.map((plugin) => ({
+				plugin,
+				scope: "Global" as ItemScope,
+			})),
+			...projectPlugins.map((plugin) => ({
+				plugin,
+				scope: "Project" as ItemScope,
+			})),
+		],
+		[globalPlugins, projectPlugins],
+	);
+
+	const scopedRules = useMemo(
+		() => [
+			...globalRules.map((rule) => ({ rule, scope: "Global" as ItemScope })),
+			...projectRules.map((rule) => ({ rule, scope: "Project" as ItemScope })),
+		],
+		[globalRules, projectRules],
+	);
+
+	const scopedHooks = useMemo(
+		() => [
+			...globalHooks.map((hook) => ({ hook, scope: "Global" as ItemScope })),
+			...projectHooks.map((hook) => ({ hook, scope: "Project" as ItemScope })),
+		],
+		[globalHooks, projectHooks],
+	);
+
+	const renderLocalActionMessage = (key: string) => {
+		const message = localActionMessages.get(key);
+		if (!message) {
+			return null;
+		}
+		return (
+			<output
+				className={cn(
+					"text-xs",
+					message.status === "failed"
+						? "text-destructive"
+						: "text-muted-foreground",
+				)}
+			>
+				{message.message}
+			</output>
+		);
+	};
+
+	const renderLocalActionRow = (target: LocalUninstallTarget) => {
+		const uninstalling = localUninstallingKeys.has(target.key);
+		return (
+			<div className="flex flex-wrap items-center justify-between gap-3">
+				<div className="min-h-5 text-xs text-muted-foreground">
+					{renderLocalActionMessage(target.key)}
+				</div>
+				<Button
+					disabled={uninstalling}
+					onClick={() => {
+						void uninstallLocalPrimitive(target);
+					}}
+					type="button"
+					variant="destructive"
+				>
+					{uninstalling ? <Spinner /> : <Trash2 className="size-4" />}
+					{uninstalling ? "Uninstalling..." : "Uninstall"}
+				</Button>
+			</div>
+		);
+	};
+
+	const renderSkillCard = (item: CommandItem) => {
+		const key = `${item.type}:${item.path}`;
+		return (
+			<div key={key} className="rounded-lg border border-border px-5 py-4">
+				<div className="flex items-center gap-3">
+					{item.type === "workflow" ? (
+						<Play className="h-4 w-4 shrink-0 text-primary" />
+					) : (
+						<Zap className="h-4 w-4 shrink-0 text-primary" />
+					)}
+					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+						{item.name}
+					</h3>
+					<ScopeBadge scope={item.scope} />
+					<Badge variant="outline" className="shrink-0 text-muted-foreground">
+						{item.type}
+					</Badge>
+				</div>
+				<p className="mt-2 ml-7 text-xs text-muted-foreground">
+					{item.description?.trim() || previewText(item.instructions)}
+				</p>
+				<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+					{item.path}
+				</p>
+				<div className="mt-3">
+					{renderLocalActionRow({
+						key,
+						type: item.type,
+						id: item.id,
+						name: item.name,
+						path: item.path,
+					})}
+				</div>
+			</div>
+		);
+	};
+
+	const renderSkillMatchedDetails = (item: CommandItem) => (
+		<div className="grid gap-1">
+			<p className="text-xs text-muted-foreground">
+				{item.description?.trim() || previewText(item.instructions)}
+			</p>
+			<p className="text-xs font-mono text-muted-foreground">{item.path}</p>
+		</div>
+	);
+
+	const renderPluginCard = ({
+		plugin,
+		scope,
+	}: {
+		plugin: PluginItem;
+		scope: ItemScope;
+	}) => {
+		const key = plugin.path;
+		return (
+			<div
+				key={plugin.path}
+				className="rounded-lg border border-border px-5 py-4"
+			>
+				<div className="flex items-center gap-3">
+					<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+						{plugin.name}
+					</h3>
+					<ScopeBadge scope={scope} />
+					<span className="text-xs text-muted-foreground">
+						{plugin.enabled ? "Enabled" : "Disabled"}
+					</span>
+					<Switch
+						checked={plugin.enabled}
+						onCheckedChange={() => {
+							void setPluginEnabled(plugin);
+						}}
+						disabled={togglingPluginPaths.has(plugin.path)}
+						aria-label={`Toggle ${plugin.name}`}
+					/>
+				</div>
+				<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+					{plugin.path}
+				</p>
+				<div className="mt-3 ml-7 flex flex-col gap-2">
+					{(
+						pluginToolsByPluginKey.get(`${plugin.name}:${plugin.path}`) ?? []
+					).map((tool) => {
+						const isToggling = togglingToolIds.has(tool.id);
+						return (
+							<div
+								key={tool.id}
+								className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+							>
+								<div className="min-w-0">
+									<p className="text-xs font-medium text-foreground">
+										{tool.name}
+									</p>
+									<p className="text-xs text-muted-foreground">
+										{tool.description?.trim() || "No description available."}
+									</p>
+								</div>
+								<div className="flex items-center gap-2">
+									<span className="text-xs text-muted-foreground">
+										{tool.enabled ? "Enabled" : "Disabled"}
+									</span>
+									<Switch
+										checked={tool.enabled}
+										onCheckedChange={() => {
+											void setToolEnabled(tool);
+										}}
+										disabled={isToggling || !plugin.enabled}
+										aria-label={`Toggle ${tool.name}`}
+									/>
+								</div>
+							</div>
+						);
+					})}
+					{(pluginToolsByPluginKey.get(`${plugin.name}:${plugin.path}`)
+						?.length ?? 0) === 0 && (
+						<p className="text-xs text-muted-foreground">
+							No plugin tools found.
+						</p>
+					)}
+				</div>
+				<div className="mt-3">
+					{renderLocalActionRow({
+						key,
+						type: "plugin",
+						id: plugin.name,
+						name: plugin.name,
+						path: plugin.path,
+					})}
+				</div>
+			</div>
+		);
+	};
+
+	const renderPluginMatchedControls = (plugin: PluginItem) => (
+		<>
+			<span className="text-xs text-muted-foreground">
+				{plugin.enabled ? "Enabled" : "Disabled"}
+			</span>
+			<Switch
+				checked={plugin.enabled}
+				onCheckedChange={() => {
+					void setPluginEnabled(plugin);
+				}}
+				disabled={togglingPluginPaths.has(plugin.path)}
+				aria-label={`Toggle ${plugin.name}`}
+			/>
+		</>
+	);
+
+	const renderPluginMatchedMeta = (plugin: PluginItem) => (
+		<p className="min-w-0 truncate text-xs font-mono text-muted-foreground">
+			{plugin.path}
+		</p>
+	);
+
+	const renderPluginMatchedDetails = (plugin: PluginItem) => {
+		const pluginTools =
+			pluginToolsByPluginKey.get(`${plugin.name}:${plugin.path}`) ?? [];
+		if (pluginTools.length === 0) {
+			return null;
+		}
+		return (
+			<div className="grid gap-2">
+				{pluginTools.map((tool) => {
+					const isToggling = togglingToolIds.has(tool.id);
+					return (
+						<div
+							key={tool.id}
+							className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+						>
+							<div className="min-w-0">
+								<p className="text-xs font-medium text-foreground">
+									{tool.name}
+								</p>
+								<p className="text-xs text-muted-foreground">
+									{tool.description?.trim() || "No description available."}
+								</p>
+							</div>
+							<div className="flex items-center gap-2">
+								<span className="text-xs text-muted-foreground">
+									{tool.enabled ? "Enabled" : "Disabled"}
+								</span>
+								<Switch
+									checked={tool.enabled}
+									onCheckedChange={() => {
+										void setToolEnabled(tool);
+									}}
+									disabled={isToggling || !plugin.enabled}
+									aria-label={`Toggle ${tool.name}`}
+								/>
+							</div>
+						</div>
+					);
+				})}
+			</div>
+		);
+	};
+
+	const renderMcpServerCard = (server: McpServer) => {
+		const key = server.name;
+		return (
+			<div
+				key={server.name}
+				className="rounded-lg border border-border px-5 py-4"
+			>
+				<div className="flex items-center gap-3">
+					<Server className="h-4 w-4 shrink-0 text-primary" />
+					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+						{server.name}
+					</h3>
+					<ScopeBadge scope="Global" />
+					<Badge variant="outline" className="shrink-0 text-muted-foreground">
+						{server.transportType}
+					</Badge>
+					<span className="text-xs text-muted-foreground">
+						{server.disabled ? "Disabled" : "Enabled"}
+					</span>
+				</div>
+				<p className="mt-2 ml-7 text-xs text-muted-foreground">
+					{server.url ??
+						([server.command, ...(server.args ?? [])]
+							.filter(Boolean)
+							.join(" ") ||
+							"No launch command configured.")}
+				</p>
+				{mcp.settingsPath ? (
+					<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+						{mcp.settingsPath}
+					</p>
+				) : null}
+				<div className="mt-3">
+					{renderLocalActionRow({
+						key,
+						type: "mcp",
+						id: server.name,
+						name: server.name,
+					})}
+				</div>
+			</div>
+		);
+	};
+
+	const renderMcpMatchedDetails = (server: McpServer) => (
+		<div className="grid gap-1">
+			<p className="text-xs text-muted-foreground">
+				{server.disabled ? "Disabled" : "Enabled"} locally
+				{server.transportType ? ` via ${server.transportType}` : ""}
+			</p>
+			{mcp.settingsPath ? (
+				<p className="text-xs font-mono text-muted-foreground">
+					{mcp.settingsPath}
+				</p>
+			) : null}
+		</div>
+	);
+
+	const installedCatalogLocalItems =
+		catalogPrimitive === "skill"
+			? commandItems.map(
+					(item): MarketplaceLocalInstalledItem => ({
+						key: `${item.type}:${item.path}`,
+						matchValues: getLocalMarketplaceMatchValues(
+							item.id,
+							item.name,
+							item.path,
+						),
+						render: () => renderSkillCard(item),
+						renderMatchedBadges: () => (
+							<>
+								<ScopeBadge scope={item.scope} />
+								<Badge
+									variant="outline"
+									className="shrink-0 text-muted-foreground"
+								>
+									{item.type}
+								</Badge>
+							</>
+						),
+						renderMatchedDetails: () => renderSkillMatchedDetails(item),
+					}),
+				)
+			: catalogPrimitive === "plugin"
+				? scopedPlugins.map(
+						(item): MarketplaceLocalInstalledItem => ({
+							key: item.plugin.path,
+							matchValues: getLocalMarketplaceMatchValues(
+								item.plugin.name,
+								item.plugin.path,
+							),
+							render: () => renderPluginCard(item),
+							renderMatchedBadges: () => <ScopeBadge scope={item.scope} />,
+							renderMatchedControls: () =>
+								renderPluginMatchedControls(item.plugin),
+							renderMatchedDetails:
+								(
+									pluginToolsByPluginKey.get(
+										`${item.plugin.name}:${item.plugin.path}`,
+									) ?? []
+								).length > 0
+									? () => renderPluginMatchedDetails(item.plugin)
+									: undefined,
+							renderMatchedMeta: () => renderPluginMatchedMeta(item.plugin),
+						}),
+					)
+				: catalogPrimitive === "mcp"
+					? mcp.servers.map(
+							(server): MarketplaceLocalInstalledItem => ({
+								key: server.name,
+								matchValues: getLocalMarketplaceMatchValues(server.name),
+								render: () => renderMcpServerCard(server),
+								renderMatchedBadges: () => (
+									<>
+										<ScopeBadge scope="Global" />
+										<Badge
+											variant="outline"
+											className="shrink-0 text-muted-foreground"
+										>
+											{server.transportType}
+										</Badge>
+									</>
+								),
+								renderMatchedDetails: () => renderMcpMatchedDetails(server),
+							}),
+						)
+					: null;
+	return (
+		<PageFrame>
+			<PageHeader
+				description={sectionDescriptions[activeTab]}
+				title={activeTab}
+				meta={<CommandBadge>{sectionCommands[activeTab]}</CommandBadge>}
+				actions={
+					<Button
+						variant="outline"
+						size="sm"
+						onClick={() => {
+							void refresh(true);
+							if (activeTab === "Hooks") {
+								void loadHookExecutionStats(true);
+							}
+						}}
+						disabled={isLoading}
+					>
+						<RefreshCw className={cn("h-4 w-4", isLoading && "animate-spin")} />
+					</Button>
+				}
+			/>
+
+			{showTabs ? (
+				<div className="mb-6 flex items-center gap-0 border-b border-border">
+					{tabs.map((tab) => (
+						<Button
+							key={tab}
+							variant="ghost"
+							onClick={() => setActiveTab(tab)}
+							className={cn(
+								"relative px-4 py-2.5 text-sm font-medium transition-colors",
+								activeTab === tab
+									? "text-foreground"
+									: "text-muted-foreground hover:text-foreground",
+							)}
+						>
+							{tab}
+							{activeTab === tab && (
+								<span className="absolute inset-x-0 -bottom-px h-0.5 bg-foreground" />
+							)}
+						</Button>
+					))}
+				</div>
+			) : null}
+
+			{errorMessage && (
+				<div className="mb-4 rounded-lg border border-destructive/40 bg-destructive/10 px-4 py-3 text-sm text-destructive">
+					Failed to load configuration lists: {errorMessage}
+				</div>
+			)}
+
+			{warnings.length > 0 && (
+				<div className="mb-4 rounded-lg border border-yellow-500/40 bg-yellow-500/10 px-4 py-3 text-sm text-yellow-700 dark:text-yellow-300">
+					<div className="mb-2 flex items-center gap-2 font-medium">
+						<TriangleAlert className="h-4 w-4" />
+						Partial results
+					</div>
+					<ul className="list-disc space-y-1 pl-5">
+						{warnings.map((warning) => (
+							<li key={warning}>{warning}</li>
+						))}
+					</ul>
+				</div>
+			)}
+
+			{catalogPrimitive ? (
+				<MarketplaceView
+					chrome="embedded"
+					installedItems={installedCatalogLocalItems ?? undefined}
+					onInstalledItemsChanged={() => refresh(true)}
+					primitive={catalogPrimitive}
+				/>
+			) : null}
+
+			{activeTab === "Rules" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Enabled rules discovered from configured workspace/global
+						directories.
+					</p>
+
+					<div className="grid gap-3">
+						<div className="flex items-center justify-between gap-3">
+							<h3 className="text-base font-semibold text-foreground">
+								Installed
+							</h3>
+							<span className="text-sm text-muted-foreground">
+								{scopedRules.length}
+							</span>
+						</div>
+						<div className="flex flex-col gap-2">
+							{scopedRules.map(({ rule, scope }) => (
+								<div
+									key={rule.path}
+									className="rounded-lg border border-border px-4 py-3"
+								>
+									<div className="flex items-center gap-3">
+										<FileText className="h-4 w-4 shrink-0 text-muted-foreground" />
+										<span className="flex-1 text-sm font-medium text-foreground">
+											{rule.name}
+										</span>
+										<ScopeBadge scope={scope} />
+									</div>
+									<p className="mt-2 text-xs text-muted-foreground">
+										{previewText(rule.instructions)}
+									</p>
+									<p className="mt-1 text-xs font-mono text-muted-foreground">
+										{rule.path}
+									</p>
+								</div>
+							))}
+							{scopedRules.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No rules found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Hooks" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Hook config files from workspace and global hook directories.
+					</p>
+					{hookExecutionLoading && hookExecutionSessionId && (
+						<p className="mb-4 text-xs text-muted-foreground">
+							Execution status is based on hook events in session{" "}
+							<span className="font-mono">{hookExecutionSessionId}</span>.
+						</p>
+					)}
+
+					<div className="grid gap-3">
+						<div className="flex items-center justify-between gap-3">
+							<h3 className="text-base font-semibold text-foreground">
+								Installed
+							</h3>
+							<span className="text-sm text-muted-foreground">
+								{scopedHooks.length}
+							</span>
+						</div>
+						<div className="flex flex-col gap-2">
+							{scopedHooks.map(({ hook, scope }) => (
+								<div
+									key={hook.path}
+									className="rounded-lg border border-border px-4 py-3"
+								>
+									<div className="flex items-center gap-3">
+										<Code className="h-4 w-4 shrink-0 text-muted-foreground" />
+										<span className="flex-1 text-sm font-mono text-foreground">
+											{hook.fileName}
+										</span>
+										<ScopeBadge scope={scope} />
+										{hook.hookEventName && (
+											<div className="flex items-center gap-2">
+												<span className="rounded border border-border px-2 py-0.5 text-xs text-muted-foreground">
+													{hook.hookEventName}
+												</span>
+												{(() => {
+													const stats =
+														hookExecutionByEvent[hook.hookEventName];
+													const executed = (stats?.count ?? 0) > 0;
+													return (
+														<span
+															className={cn(
+																"rounded border px-2 py-0.5 text-xs",
+																executed
+																	? "border-emerald-400/50 text-emerald-600 dark:text-emerald-400"
+																	: "border-border text-muted-foreground",
+															)}
+														>
+															{executed
+																? `${stats?.count ?? 0} executed`
+																: "never executed"}
+														</span>
+													);
+												})()}
+											</div>
+										)}
+									</div>
+									{hook.hookEventName ? (
+										<p className="mt-1 text-xs text-muted-foreground">
+											Last run:{" "}
+											{formatExecutionTs(
+												hookExecutionByEvent[hook.hookEventName]?.lastTs ??
+													null,
+											)}
+										</p>
+									) : null}
+									<p className="mt-1 text-xs font-mono text-muted-foreground">
+										{hook.path}
+									</p>
+								</div>
+							))}
+							{scopedHooks.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No hooks found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Skills" && !catalogPrimitive && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Skills can be invoked in chat with{" "}
+						<code className="rounded bg-secondary px-1.5 py-0.5 text-xs font-mono text-foreground">
+							/SKILL
+						</code>
+						.
+					</p>
+
+					<div className="flex flex-col gap-3">
+						{commandItems.map((item) => (
+							<div
+								key={`${item.type}:${item.path}`}
+								className="rounded-lg border border-border px-5 py-4"
+							>
+								<div className="flex items-center gap-3">
+									{item.type === "workflow" ? (
+										<Play className="h-4 w-4 shrink-0 text-primary" />
+									) : (
+										<Zap className="h-4 w-4 shrink-0 text-primary" />
+									)}
+									<h3 className="text-sm font-semibold text-foreground">
+										{item.name}
+									</h3>
+									<span className="rounded border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{item.type}
+									</span>
+								</div>
+								<p className="mt-2 ml-7 text-xs text-muted-foreground">
+									{item.description?.trim() || previewText(item.instructions)}
+								</p>
+								<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+									{item.path}
+								</p>
+							</div>
+						))}
+						{commandItems.length === 0 && (
+							<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+								No enabled skills or workflows found.
+							</p>
+						)}
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Agents" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Configured agents discovered from Documents and settings
+						directories.
+					</p>
+
+					<div className="flex flex-col gap-3">
+						{agents.map((agent) => (
+							<div
+								key={agent.path}
+								className="rounded-lg border border-border px-5 py-4"
+							>
+								<div className="flex items-center gap-3">
+									<Bot className="h-4 w-4 shrink-0 text-primary" />
+									<h3 className="text-sm font-semibold text-foreground">
+										{agent.name}
+									</h3>
+								</div>
+								<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+									{agent.path}
+								</p>
+							</div>
+						))}
+						{agents.length === 0 && (
+							<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+								No configured agents found.
+							</p>
+						)}
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Plugins" && !catalogPrimitive && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Plugins discovered from workspace and global plugin directories.
+					</p>
+
+					<div className="mb-6">
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Global Plugins
+						</h3>
+						<div className="flex flex-col gap-3">
+							{globalPlugins.map((plugin) => (
+								<div
+									key={plugin.path}
+									className="rounded-lg border border-border px-5 py-4"
+								>
+									<div className="flex items-center gap-3">
+										<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+										<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+											{plugin.name}
+										</h3>
+										<span className="text-xs text-muted-foreground">
+											{plugin.enabled ? "Enabled" : "Disabled"}
+										</span>
+										<Switch
+											checked={plugin.enabled}
+											onCheckedChange={() => {
+												void setPluginEnabled(plugin);
+											}}
+											disabled={togglingPluginPaths.has(plugin.path)}
+											aria-label={`Toggle ${plugin.name}`}
+										/>
+									</div>
+									<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+										{plugin.path}
+									</p>
+									<div className="mt-3 ml-7 flex flex-col gap-2">
+										{(
+											pluginToolsByPluginKey.get(
+												`${plugin.name}:${plugin.path}`,
+											) ?? []
+										).map((tool) => {
+											const isToggling = togglingToolIds.has(tool.id);
+											return (
+												<div
+													key={tool.id}
+													className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+												>
+													<div className="min-w-0">
+														<p className="text-xs font-medium text-foreground">
+															{tool.name}
+														</p>
+														<p className="text-xs text-muted-foreground">
+															{tool.description?.trim() ||
+																"No description available."}
+														</p>
+													</div>
+													<div className="flex items-center gap-2">
+														<span className="text-xs text-muted-foreground">
+															{tool.enabled ? "Enabled" : "Disabled"}
+														</span>
+														<Switch
+															checked={tool.enabled}
+															onCheckedChange={() => {
+																void setToolEnabled(tool);
+															}}
+															disabled={isToggling || !plugin.enabled}
+															aria-label={`Toggle ${tool.name}`}
+														/>
+													</div>
+												</div>
+											);
+										})}
+										{(pluginToolsByPluginKey.get(
+											`${plugin.name}:${plugin.path}`,
+										)?.length ?? 0) === 0 && (
+											<p className="text-xs text-muted-foreground">
+												No plugin tools found.
+											</p>
+										)}
+									</div>
+								</div>
+							))}
+							{globalPlugins.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No global plugins found.
+								</p>
+							)}
+						</div>
+					</div>
+
+					<div>
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Project Plugins
+						</h3>
+						<div className="flex flex-col gap-3">
+							{projectPlugins.map((plugin) => (
+								<div
+									key={plugin.path}
+									className="rounded-lg border border-border px-5 py-4"
+								>
+									<div className="flex items-center gap-3">
+										<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+										<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+											{plugin.name}
+										</h3>
+										<span className="text-xs text-muted-foreground">
+											{plugin.enabled ? "Enabled" : "Disabled"}
+										</span>
+										<Switch
+											checked={plugin.enabled}
+											onCheckedChange={() => {
+												void setPluginEnabled(plugin);
+											}}
+											disabled={togglingPluginPaths.has(plugin.path)}
+											aria-label={`Toggle ${plugin.name}`}
+										/>
+									</div>
+									<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+										{plugin.path}
+									</p>
+									<div className="mt-3 ml-7 flex flex-col gap-2">
+										{(
+											pluginToolsByPluginKey.get(
+												`${plugin.name}:${plugin.path}`,
+											) ?? []
+										).map((tool) => {
+											const isToggling = togglingToolIds.has(tool.id);
+											return (
+												<div
+													key={tool.id}
+													className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+												>
+													<div className="min-w-0">
+														<p className="text-xs font-medium text-foreground">
+															{tool.name}
+														</p>
+														<p className="text-xs text-muted-foreground">
+															{tool.description?.trim() ||
+																"No description available."}
+														</p>
+													</div>
+													<div className="flex items-center gap-2">
+														<span className="text-xs text-muted-foreground">
+															{tool.enabled ? "Enabled" : "Disabled"}
+														</span>
+														<Switch
+															checked={tool.enabled}
+															onCheckedChange={() => {
+																void setToolEnabled(tool);
+															}}
+															disabled={isToggling || !plugin.enabled}
+															aria-label={`Toggle ${tool.name}`}
+														/>
+													</div>
+												</div>
+											);
+										})}
+										{(pluginToolsByPluginKey.get(
+											`${plugin.name}:${plugin.path}`,
+										)?.length ?? 0) === 0 && (
+											<p className="text-xs text-muted-foreground">
+												No plugin tools found.
+											</p>
+										)}
+									</div>
+								</div>
+							))}
+							{projectPlugins.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No project plugins found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Tools" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Builtin tool groups and plugin-contributed tools available to the
+						runtime.
+					</p>
+
+					<div className="mb-6">
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Builtin Tools
+						</h3>
+						<div className="flex flex-col gap-3">
+							{builtinTools.map((tool) =>
+								(() => {
+									const isToggling = togglingToolIds.has(tool.id);
+									return (
+										<div
+											key={tool.id}
+											className="rounded-lg border border-border px-5 py-4"
+										>
+											<div className="flex items-center gap-3">
+												<Wrench className="h-4 w-4 shrink-0 text-primary" />
+												<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+													{tool.name}
+												</h3>
+												<span className="text-xs text-muted-foreground">
+													{tool.enabled ? "Enabled" : "Disabled"}
+												</span>
+												<Switch
+													checked={tool.enabled}
+													onCheckedChange={() => {
+														void setToolEnabled(tool);
+													}}
+													disabled={isToggling}
+													aria-label={`Toggle ${tool.name}`}
+												/>
+											</div>
+											<p className="mt-2 ml-7 text-xs text-muted-foreground">
+												{tool.description?.trim() ||
+													"No description available."}
+											</p>
+											{!!tool.headlessToolNames?.length && (
+												<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+													{tool.headlessToolNames.join(", ")}
+												</p>
+											)}
+										</div>
+									);
+								})(),
+							)}
+							{builtinTools.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No builtin tools found.
+								</p>
+							)}
+						</div>
+					</div>
+
+					<div>
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Plugin Tools
+						</h3>
+						<div className="flex flex-col gap-3">
+							{pluginTools.map((tool) =>
+								(() => {
+									const isToggling = togglingToolIds.has(tool.id);
+									return (
+										<div
+											key={tool.id}
+											className="rounded-lg border border-border px-5 py-4"
+										>
+											<div className="flex items-center gap-3">
+												<Wrench className="h-4 w-4 shrink-0 text-primary" />
+												<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+													{tool.name}
+												</h3>
+												{tool.pluginName && (
+													<span className="rounded border border-border px-2 py-0.5 text-xs text-muted-foreground">
+														plugin: {tool.pluginName}
+													</span>
+												)}
+												<span className="text-xs text-muted-foreground">
+													{tool.enabled ? "Enabled" : "Disabled"}
+												</span>
+												<Switch
+													checked={tool.enabled}
+													onCheckedChange={() => {
+														void setToolEnabled(tool);
+													}}
+													disabled={isToggling}
+													aria-label={`Toggle ${tool.name}`}
+												/>
+											</div>
+											<p className="mt-2 ml-7 text-xs text-muted-foreground">
+												{tool.description?.trim() ||
+													"No description available."}
+											</p>
+											{tool.path && (
+												<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+													{tool.path}
+												</p>
+											)}
+										</div>
+									);
+								})(),
+							)}
+							{pluginTools.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No plugin tools found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+		</PageFrame>
+	);
+}
+
+export function RulesView() {
+	return <CustomizationSectionView showTabs />;
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/mcp-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/mcp-view.tsx
new file mode 100644
index 0000000..62968d4
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/mcp-view.tsx
@@ -0,0 +1,853 @@
+"use client";
+
+import { Circle, Minus, Pencil, Plus, RefreshCw, Trash2 } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { desktopClient } from "@/lib/desktop-client";
+import { cn } from "@/lib/utils";
+import { CommandBadge, PageFrame, PageHeader } from "../page-layout";
+
+type McpTransportType = "stdio" | "sse" | "streamableHttp";
+
+interface McpServer {
+	name: string;
+	transportType: McpTransportType;
+	disabled: boolean;
+	command?: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	metadata?: unknown;
+}
+
+interface McpServersResponse {
+	settingsPath: string;
+	hasSettingsFile: boolean;
+	servers: McpServer[];
+}
+
+interface McpServerUpsertInput {
+	name: string;
+	previousName?: string;
+	transportType: McpTransportType;
+	command?: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	disabled?: boolean;
+	metadata?: unknown;
+}
+
+type McpServerFormState = {
+	name: string;
+	previousName: string;
+	transportType: McpTransportType;
+	command: string;
+	argsText: string;
+	cwd: string;
+	envEntries: Array<{ id: string; key: string; value: string }>;
+	url: string;
+	headersText: string;
+	disabled: boolean;
+	metadataText: string;
+};
+
+function splitCsv(text: string): string[] {
+	return text
+		.split(",")
+		.map((value) => value.trim())
+		.filter((value) => value.length > 0);
+}
+
+function parseKeyValuePairs(text: string): Record<string, string> | undefined {
+	const pairs = splitCsv(text);
+	if (pairs.length === 0) {
+		return undefined;
+	}
+	const out: Record<string, string> = {};
+	for (const pair of pairs) {
+		const idx = pair.indexOf("=");
+		if (idx <= 0) {
+			continue;
+		}
+		const key = pair.slice(0, idx).trim();
+		const value = pair.slice(idx + 1).trim();
+		if (!key) {
+			continue;
+		}
+		out[key] = value;
+	}
+	return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function stringifyKeyValuePairs(input?: Record<string, string>): string {
+	if (!input) {
+		return "";
+	}
+	return Object.entries(input)
+		.map(([key, value]) => `${key}=${value}`)
+		.join(", ");
+}
+
+function stringifyRedactedKeyValuePairs(
+	input?: Record<string, string>,
+): string {
+	if (!input) {
+		return "";
+	}
+	return Object.keys(input)
+		.map((key) => `${key}=[REDACTED]`)
+		.join(", ");
+}
+
+function createEnvEntries(
+	input?: Record<string, string>,
+): Array<{ id: string; key: string; value: string }> {
+	if (!input || Object.keys(input).length === 0) {
+		return [{ id: crypto.randomUUID(), key: "", value: "" }];
+	}
+	return Object.entries(input).map(([key, value]) => ({
+		id: crypto.randomUUID(),
+		key,
+		value,
+	}));
+}
+
+function createServerFormState(existing?: McpServer): McpServerFormState {
+	return {
+		name: existing?.name ?? "",
+		previousName: existing?.name ?? "",
+		transportType: existing?.transportType ?? "stdio",
+		command: existing?.command ?? "",
+		argsText: existing?.args?.join(", ") ?? "",
+		cwd: existing?.cwd ?? "",
+		envEntries: createEnvEntries(existing?.env),
+		url: existing?.url ?? "",
+		headersText: stringifyKeyValuePairs(existing?.headers),
+		disabled: existing?.disabled ?? false,
+		metadataText:
+			existing?.metadata === undefined
+				? ""
+				: JSON.stringify(existing.metadata, null, 2),
+	};
+}
+
+export function McpServersContent() {
+	const [servers, setServers] = useState<McpServer[]>([]);
+	const [settingsPath, setSettingsPath] = useState("");
+	const [hasSettingsFile, setHasSettingsFile] = useState(false);
+	const [isLoading, setIsLoading] = useState(true);
+	const [isOpeningSettingsFile, setIsOpeningSettingsFile] = useState(false);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [busyServerName, setBusyServerName] = useState<string | null>(null);
+	const [editorOpen, setEditorOpen] = useState(false);
+	const [editorMode, setEditorMode] = useState<"create" | "edit">("create");
+	const [formState, setFormState] = useState<McpServerFormState>(() =>
+		createServerFormState(),
+	);
+	const [formErrorMessage, setFormErrorMessage] = useState<string | null>(null);
+	const [deleteTarget, setDeleteTarget] = useState<McpServer | null>(null);
+
+	const applyResponse = useCallback((response: McpServersResponse) => {
+		setServers(response.servers);
+		setSettingsPath(response.settingsPath);
+		setHasSettingsFile(response.hasSettingsFile);
+	}, []);
+
+	const refreshServers = useCallback(async () => {
+		setIsLoading(true);
+		setErrorMessage(null);
+		try {
+			const response =
+				await desktopClient.invoke<McpServersResponse>("list_mcp_servers");
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsLoading(false);
+		}
+	}, [applyResponse]);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refreshServers();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refreshServers]);
+
+	const toggleServer = async (server: McpServer, disabled: boolean) => {
+		setBusyServerName(server.name);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<McpServersResponse>(
+				"set_mcp_server_disabled",
+				{
+					name: server.name,
+					disabled,
+				},
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyServerName(null);
+		}
+	};
+
+	const upsertServer = async (input: McpServerUpsertInput) => {
+		setBusyServerName(input.previousName ?? input.name);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<McpServersResponse>(
+				"upsert_mcp_server",
+				{
+					input,
+				},
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+			throw error;
+		} finally {
+			setBusyServerName(null);
+		}
+	};
+
+	const deleteServer = async (serverName: string) => {
+		setBusyServerName(serverName);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<McpServersResponse>(
+				"delete_mcp_server",
+				{
+					name: serverName,
+				},
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyServerName(null);
+		}
+	};
+
+	const buildServerInput = useCallback((form: McpServerFormState) => {
+		const name = form.name.trim();
+		if (!name) {
+			throw new Error("Server name is required.");
+		}
+		const env = form.envEntries.reduce<Record<string, string>>((acc, entry) => {
+			const key = entry.key.trim();
+			if (!key) {
+				return acc;
+			}
+			acc[key] = entry.value;
+			return acc;
+		}, {});
+		const metadataText = form.metadataText.trim();
+		const metadata =
+			metadataText.length > 0 ? JSON.parse(metadataText) : undefined;
+		if (form.transportType === "stdio") {
+			const command = form.command.trim();
+			if (!command) {
+				throw new Error("Command is required for stdio transport.");
+			}
+			const args = splitCsv(form.argsText);
+			return {
+				name,
+				previousName: form.previousName.trim() || undefined,
+				transportType: form.transportType,
+				command,
+				args: args.length > 0 ? args : undefined,
+				cwd: form.cwd.trim() || undefined,
+				env: Object.keys(env).length > 0 ? env : undefined,
+				disabled: form.disabled,
+				metadata,
+			} satisfies McpServerUpsertInput;
+		}
+		const url = form.url.trim();
+		if (!url) {
+			throw new Error("URL is required for sse and streamableHttp transport.");
+		}
+		return {
+			name,
+			previousName: form.previousName.trim() || undefined,
+			transportType: form.transportType,
+			url,
+			headers: parseKeyValuePairs(form.headersText),
+			disabled: form.disabled,
+			metadata,
+		} satisfies McpServerUpsertInput;
+	}, []);
+
+	const openCreateDialog = () => {
+		setEditorMode("create");
+		setFormState(createServerFormState());
+		setFormErrorMessage(null);
+		setEditorOpen(true);
+	};
+
+	const openEditDialog = (server: McpServer) => {
+		setEditorMode("edit");
+		setFormState(createServerFormState(server));
+		setFormErrorMessage(null);
+		setEditorOpen(true);
+	};
+
+	const handleSaveServer = async () => {
+		setFormErrorMessage(null);
+		try {
+			const input = buildServerInput(formState);
+			await upsertServer(input);
+			setEditorOpen(false);
+		} catch (error) {
+			setFormErrorMessage(
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	};
+
+	const openSettingsFile = async () => {
+		setIsOpeningSettingsFile(true);
+		setErrorMessage(null);
+		try {
+			const openedPath = await desktopClient.invoke<string>(
+				"open_mcp_settings_file",
+			);
+			if (openedPath.trim().length > 0) {
+				setSettingsPath(openedPath);
+				setHasSettingsFile(true);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsOpeningSettingsFile(false);
+		}
+	};
+
+	const sortedServers = useMemo(
+		() =>
+			[...servers].sort((a, b) =>
+				a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+			),
+		[servers],
+	);
+
+	const updateEnvEntry = (
+		id: string,
+		field: "key" | "value",
+		value: string,
+	) => {
+		setFormState((current) => ({
+			...current,
+			envEntries: current.envEntries.map((entry) =>
+				entry.id === id ? { ...entry, [field]: value } : entry,
+			),
+		}));
+	};
+
+	const addEnvEntry = () => {
+		setFormState((current) => ({
+			...current,
+			envEntries: [
+				...current.envEntries,
+				{ id: crypto.randomUUID(), key: "", value: "" },
+			],
+		}));
+	};
+
+	const removeEnvEntry = (id: string) => {
+		setFormState((current) => ({
+			...current,
+			envEntries:
+				current.envEntries.length === 1
+					? [{ id: crypto.randomUUID(), key: "", value: "" }]
+					: current.envEntries.filter((entry) => entry.id !== id),
+		}));
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description={
+					hasSettingsFile
+						? "Editing this list updates cline_mcp_settings.json."
+						: "No MCP settings file found yet. Add a server to create it."
+				}
+				title="MCP Servers"
+				meta={
+					<>
+						<CommandBadge>cline config mcp</CommandBadge>
+						<span className="rounded-md border border-border bg-background px-2 py-0.5 text-xs text-muted-foreground">
+							From settings file
+						</span>
+					</>
+				}
+				actions={
+					<>
+						<Button
+							variant="outline"
+							size="sm"
+							onClick={() => void refreshServers()}
+							disabled={isLoading}
+						>
+							<RefreshCw
+								className={cn("h-4 w-4", isLoading && "animate-spin")}
+							/>
+						</Button>
+						<Button size="sm" onClick={openCreateDialog}>
+							<Plus className="h-4 w-4" />
+							Add MCP Server
+						</Button>
+					</>
+				}
+			/>
+
+			<div className="mb-1 flex flex-wrap items-center gap-2 text-sm text-muted-foreground">
+				<span>MCP settings path:</span>
+				<Button
+					variant="link"
+					className="h-auto p-0 font-mono text-xs"
+					onClick={() => void openSettingsFile()}
+					disabled={isOpeningSettingsFile}
+				>
+					{settingsPath || "Open settings file"}
+				</Button>
+			</div>
+			{errorMessage && (
+				<div className="mb-4 rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			)}
+
+			{isLoading ? (
+				<div className="rounded-lg border border-border px-5 py-4 text-sm text-muted-foreground">
+					Loading MCP servers...
+				</div>
+			) : sortedServers.length === 0 ? (
+				<div className="rounded-lg border border-border px-5 py-4 text-sm text-muted-foreground">
+					No MCP servers configured.
+				</div>
+			) : (
+				<div className="flex flex-col gap-3">
+					{sortedServers.map((server) => {
+						const isBusy = busyServerName === server.name;
+						return (
+							<div
+								key={server.name}
+								className="rounded-lg border border-border px-5 py-4 transition-colors hover:bg-accent/20"
+							>
+								<div className="flex items-center gap-3">
+									<Circle
+										className={cn(
+											"h-2.5 w-2.5 shrink-0",
+											server.disabled
+												? "fill-muted-foreground/40 text-muted-foreground/40"
+												: "fill-primary text-primary",
+										)}
+									/>
+									<h3 className="text-sm font-semibold text-foreground">
+										{server.name}
+									</h3>
+									<span className="rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{server.transportType}
+									</span>
+									<div className="flex-1" />
+									<div className="flex items-center gap-1">
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Edit ${server.name}`}
+											onClick={() => openEditDialog(server)}
+											disabled={isBusy}
+										>
+											<Pencil className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Delete ${server.name}`}
+											onClick={() => setDeleteTarget(server)}
+											disabled={isBusy}
+										>
+											<Trash2 className="h-3.5 w-3.5" />
+										</Button>
+										<Switch
+											checked={!server.disabled}
+											onCheckedChange={(enabled) =>
+												toggleServer(server, !enabled)
+											}
+											disabled={isBusy}
+											aria-label={`Enable ${server.name}`}
+										/>
+									</div>
+								</div>
+
+								<div className="mt-2.5 ml-5.5 flex flex-col gap-1 text-xs text-muted-foreground">
+									{server.command && (
+										<p>
+											<span className="text-muted-foreground/70">Command:</span>{" "}
+											{server.command}
+										</p>
+									)}
+									{server.args && server.args.length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Args:</span>{" "}
+											{server.args.join(", ")}
+										</p>
+									)}
+									{server.cwd && (
+										<p>
+											<span className="text-muted-foreground/70">CWD:</span>{" "}
+											{server.cwd}
+										</p>
+									)}
+									{server.url && (
+										<p>
+											<span className="text-muted-foreground/70">URL:</span>{" "}
+											{server.url}
+										</p>
+									)}
+									{server.env && Object.keys(server.env).length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Env:</span>{" "}
+											{stringifyRedactedKeyValuePairs(server.env)}
+										</p>
+									)}
+									{server.headers && Object.keys(server.headers).length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Headers:</span>{" "}
+											{stringifyKeyValuePairs(server.headers)}
+										</p>
+									)}
+								</div>
+							</div>
+						);
+					})}
+				</div>
+			)}
+			<Dialog
+				open={editorOpen}
+				onOpenChange={(open) => {
+					setEditorOpen(open);
+					if (!open) {
+						setFormErrorMessage(null);
+					}
+				}}
+			>
+				<DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-2xl">
+					<DialogHeader>
+						<DialogTitle>
+							{editorMode === "edit" ? "Edit MCP Server" : "Add MCP Server"}
+						</DialogTitle>
+						<DialogDescription>
+							Update the MCP server stored in{" "}
+							<code className="font-mono">
+								{settingsPath || "cline_mcp_settings.json"}
+							</code>
+							.
+						</DialogDescription>
+					</DialogHeader>
+
+					<div className="grid gap-4">
+						<div className="grid gap-2">
+							<Label htmlFor="mcp-name">Server name</Label>
+							<Input
+								id="mcp-name"
+								value={formState.name}
+								onChange={(event) =>
+									setFormState((current) => ({
+										...current,
+										name: event.target.value,
+									}))
+								}
+								placeholder="github"
+							/>
+						</div>
+
+						<div className="grid gap-2">
+							<Label>Transport type</Label>
+							<Select
+								value={formState.transportType}
+								onValueChange={(value) =>
+									setFormState((current) => ({
+										...current,
+										transportType: value as McpTransportType,
+									}))
+								}
+							>
+								<SelectTrigger className="w-full">
+									<SelectValue placeholder="Select transport" />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="stdio">stdio</SelectItem>
+									<SelectItem value="sse">sse</SelectItem>
+									<SelectItem value="streamableHttp">streamableHttp</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+
+						{formState.transportType === "stdio" ? (
+							<>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-command">Command</Label>
+									<Input
+										id="mcp-command"
+										value={formState.command}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												command: event.target.value,
+											}))
+										}
+										placeholder="npx"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-args">Args</Label>
+									<Textarea
+										id="mcp-args"
+										value={formState.argsText}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												argsText: event.target.value,
+											}))
+										}
+										placeholder="-y, @modelcontextprotocol/server-github"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-cwd">Working directory</Label>
+									<Input
+										id="mcp-cwd"
+										value={formState.cwd}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												cwd: event.target.value,
+											}))
+										}
+										placeholder="/path/to/project"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<div className="flex items-center justify-between gap-3">
+										<Label>Environment variables</Label>
+										<Button
+											type="button"
+											variant="ghost"
+											size="sm"
+											onClick={addEnvEntry}
+										>
+											<Plus className="h-3.5 w-3.5" />
+										</Button>
+									</div>
+									<div className="flex flex-col gap-2">
+										{formState.envEntries.map((entry) => (
+											<div key={entry.id} className="flex items-center gap-2">
+												<Button
+													type="button"
+													variant="ghost"
+													size="icon-sm"
+													onClick={() => removeEnvEntry(entry.id)}
+													aria-label={`Remove env var ${entry.key || "row"}`}
+												>
+													<Minus className="h-3.5 w-3.5" />
+												</Button>
+												<Input
+													value={entry.key}
+													onChange={(event) =>
+														updateEnvEntry(entry.id, "key", event.target.value)
+													}
+													placeholder="KEY"
+												/>
+												<Input
+													type="password"
+													value={entry.value}
+													onChange={(event) =>
+														updateEnvEntry(
+															entry.id,
+															"value",
+															event.target.value,
+														)
+													}
+													placeholder="VALUE"
+												/>
+											</div>
+										))}
+									</div>
+								</div>
+							</>
+						) : (
+							<>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-url">Server URL</Label>
+									<Input
+										id="mcp-url"
+										value={formState.url}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												url: event.target.value,
+											}))
+										}
+										placeholder="https://example.com/mcp"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-headers">Headers</Label>
+									<Textarea
+										id="mcp-headers"
+										value={formState.headersText}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												headersText: event.target.value,
+											}))
+										}
+										placeholder="Authorization=Bearer token"
+									/>
+								</div>
+							</>
+						)}
+
+						<div className="grid gap-2">
+							<Label htmlFor="mcp-metadata">Metadata JSON</Label>
+							<Textarea
+								id="mcp-metadata"
+								value={formState.metadataText}
+								onChange={(event) =>
+									setFormState((current) => ({
+										...current,
+										metadataText: event.target.value,
+									}))
+								}
+								placeholder='{"key":"value"}'
+							/>
+						</div>
+
+						<div className="flex items-center justify-between rounded-md border border-border px-3 py-2">
+							<div>
+								<p className="text-sm font-medium text-foreground">Enabled</p>
+								<p className="text-xs text-muted-foreground">
+									Disable the server without removing it from settings.
+								</p>
+							</div>
+							<Switch
+								checked={!formState.disabled}
+								onCheckedChange={(enabled) =>
+									setFormState((current) => ({
+										...current,
+										disabled: !enabled,
+									}))
+								}
+								aria-label="Enable MCP server"
+							/>
+						</div>
+
+						{formErrorMessage ? (
+							<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+								{formErrorMessage}
+							</div>
+						) : null}
+					</div>
+
+					<DialogFooter>
+						<Button
+							variant="outline"
+							onClick={() => setEditorOpen(false)}
+							disabled={busyServerName !== null}
+						>
+							Cancel
+						</Button>
+						<Button
+							onClick={() => void handleSaveServer()}
+							disabled={busyServerName !== null}
+						>
+							{busyServerName !== null
+								? "Saving..."
+								: editorMode === "edit"
+									? "Save changes"
+									: "Add server"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+
+			<AlertDialog
+				open={deleteTarget !== null}
+				onOpenChange={(open) => {
+					if (!open) {
+						setDeleteTarget(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete MCP Server</AlertDialogTitle>
+						<AlertDialogDescription>
+							{deleteTarget
+								? `Delete MCP server "${deleteTarget.name}" from settings?`
+								: "Delete this MCP server from settings?"}
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={busyServerName !== null}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={busyServerName !== null || !deleteTarget}
+							onClick={() => {
+								if (deleteTarget) {
+									void deleteServer(deleteTarget.name);
+									setDeleteTarget(null);
+								}
+							}}
+						>
+							Delete
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</PageFrame>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/provider-list-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/provider-list-view.tsx
new file mode 100644
index 0000000..8e44b78
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/provider-list-view.tsx
@@ -0,0 +1,641 @@
+"use client";
+
+import {
+	ArrowLeft,
+	ChevronRight,
+	Copy,
+	Eye,
+	EyeOff,
+	FileIcon,
+	ImageIcon,
+	Link as LinkIcon,
+	Loader2,
+	PlusCircle,
+	RefreshCw,
+	Search,
+	Star,
+	X,
+} from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Switch } from "@/components/ui/switch";
+import type {
+	Provider,
+	ProviderConfigField,
+	ProviderConfigFieldPrimitive,
+	ProviderSettingsUpdate,
+} from "@/lib/provider-schema";
+import { cn } from "@/lib/utils";
+
+// -----------------------------------------------------------
+// Provider LIST content (the grid of all providers)
+// -----------------------------------------------------------
+
+function getInitialConfigValues(
+	provider: Provider,
+): Record<string, ProviderConfigFieldPrimitive> {
+	const values: Record<string, ProviderConfigFieldPrimitive> = {
+		...(provider.configValues ?? {}),
+	};
+	if (provider.apiKey !== undefined && values.apiKey === undefined) {
+		values.apiKey = provider.apiKey;
+	}
+	if (provider.baseUrl !== undefined && values.baseUrl === undefined) {
+		values.baseUrl = provider.baseUrl;
+	}
+	for (const field of provider.configFields ?? []) {
+		if (values[field.path] === undefined && field.defaultValue !== undefined) {
+			values[field.path] = field.defaultValue;
+		}
+	}
+	return values;
+}
+
+function fieldValueToString(value: ProviderConfigFieldPrimitive | undefined) {
+	if (value === undefined || value === null) return "";
+	return String(value);
+}
+
+function coerceFieldValue(
+	field: ProviderConfigField,
+	value: string | boolean,
+): ProviderConfigFieldPrimitive {
+	if (field.type === "boolean") {
+		return Boolean(value);
+	}
+	if (typeof value === "boolean") {
+		return value;
+	}
+	if (field.type === "select") {
+		const option = field.options?.find((item) => String(item.value) === value);
+		if (option) {
+			return option.value;
+		}
+	}
+	const trimmed = value.trim();
+	if (trimmed.length === 0) {
+		return null;
+	}
+	if (field.type === "number") {
+		const parsed = Number(trimmed);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return trimmed;
+}
+
+export function ProviderListContent({
+	providers,
+	onToggle,
+	onConfigure,
+	onAddProvider,
+	selectedProviderId,
+	variant = "page",
+}: {
+	providers: Provider[];
+	onToggle: (id: string) => void;
+	onConfigure: (id: string) => void;
+	onAddProvider: () => void;
+	selectedProviderId?: string | null;
+	variant?: "page" | "panel";
+}) {
+	const [providerSearchOpen, setProviderSearchOpen] = useState(false);
+	const [providerSearch, setProviderSearch] = useState("");
+	const enabledProviderCount = providers.filter(
+		(provider) => provider.enabled,
+	).length;
+	const providerSearchQuery = providerSearch.trim().toLowerCase();
+	const filteredProviders = providerSearchQuery
+		? providers.filter((provider) =>
+				provider.name.toLowerCase().includes(providerSearchQuery),
+			)
+		: providers;
+	const isPanel = variant === "panel";
+
+	return (
+		<ScrollArea className="h-full">
+			<div
+				className={cn(
+					"py-10 max-[720px]:px-4 max-[720px]:py-5",
+					isPanel ? "px-8" : "px-18 max-[1200px]:px-8",
+				)}
+			>
+				<div
+					className={cn(
+						"mb-8 flex items-start justify-between gap-6 max-[860px]:flex-col max-[860px]:items-stretch",
+						isPanel ? "max-w-none" : "max-w-[42rem]",
+					)}
+				>
+					<div className="min-w-0">
+						<h1
+							className={cn(
+								"truncate font-semibold leading-[1.15] tracking-normal text-foreground",
+								isPanel ? "text-[24px]" : "text-[32px]",
+							)}
+						>
+							Model Providers
+						</h1>
+						<p className="mt-3 text-[15px] leading-6 text-muted-foreground">
+							Configure model providers and choose which ones are available.{" "}
+							{providers.length} available &middot; {enabledProviderCount}{" "}
+							enabled
+						</p>
+					</div>
+					<div className="flex shrink-0 items-center gap-2 max-[860px]:justify-start">
+						<Button
+							aria-label="Search providers"
+							className="size-8 rounded-md"
+							onClick={() => setProviderSearchOpen((open) => !open)}
+							size="icon-sm"
+							type="button"
+							variant={providerSearchOpen ? "default" : "secondary"}
+						>
+							<Search className="size-4" />
+						</Button>
+						<Button
+							className="h-8 rounded-md bg-foreground px-3 text-sm text-background hover:bg-foreground/90"
+							onClick={onAddProvider}
+							type="button"
+						>
+							<PlusCircle className="size-4" />
+							Add provider
+						</Button>
+					</div>
+				</div>
+
+				{providerSearchOpen ? (
+					<div className={cn("mb-4", isPanel ? "max-w-none" : "max-w-[42rem]")}>
+						<div className="flex h-9 items-center gap-2 rounded border bg-background px-3">
+							<Search className="size-4 shrink-0 text-muted-foreground" />
+							<Input
+								aria-label="Search model providers"
+								autoFocus
+								className="h-7 border-0 bg-transparent px-0 text-sm"
+								onChange={(event) => setProviderSearch(event.target.value)}
+								placeholder="Search providers"
+								value={providerSearch}
+							/>
+						</div>
+					</div>
+				) : null}
+
+				<div
+					className={cn(
+						"overflow-hidden",
+						isPanel ? "max-w-none" : "max-w-[42rem]",
+					)}
+				>
+					{filteredProviders.length === 0 ? (
+						<div className="border-b px-2 py-6 text-[15px] text-muted-foreground">
+							No providers match "{providerSearch.trim()}".
+						</div>
+					) : null}
+					{filteredProviders.map((prov) => (
+						<div
+							className={cn(
+								"flex min-h-11 items-center gap-4 border-b px-2 py-2 transition-colors hover:bg-accent/30",
+								selectedProviderId === prov.id && "bg-accent/45",
+							)}
+							key={prov.id}
+						>
+							<button
+								className="flex min-w-0 flex-1 items-center gap-3 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+								onClick={() => onConfigure(prov.id)}
+								type="button"
+							>
+								<p className="min-w-0 flex-1 truncate text-[17px] font-semibold text-foreground">
+									{prov.name}
+								</p>
+								<p className="shrink-0 text-[15px] text-muted-foreground">
+									{prov.models === null
+										? "Models load on demand"
+										: `${prov.models} model${prov.models !== 1 ? "s" : ""}`}
+								</p>
+							</button>
+							<Switch
+								aria-label={`Toggle ${prov.name}`}
+								checked={prov.enabled}
+								onCheckedChange={() => onToggle(prov.id)}
+							/>
+							<button
+								aria-label={`Configure ${prov.name}`}
+								className="grid size-7 shrink-0 place-items-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+								onClick={() => onConfigure(prov.id)}
+								type="button"
+							>
+								<ChevronRight className="size-4" />
+							</button>
+						</div>
+					))}
+				</div>
+			</div>
+		</ScrollArea>
+	);
+}
+
+export function ProviderDetailContent({
+	provider,
+	onBack,
+	onUpdate,
+	onLoadModels,
+	modelsLoading = false,
+	modelsError,
+	onOAuthLogin,
+	oauthLoginPending = false,
+	variant = "page",
+}: {
+	provider: Provider;
+	onBack: () => void;
+	onUpdate: (updates: ProviderSettingsUpdate) => void;
+	onLoadModels?: () => void;
+	modelsLoading?: boolean;
+	modelsError?: string | null;
+	onOAuthLogin?: () => void;
+	oauthLoginPending?: boolean;
+	variant?: "page" | "panel";
+}) {
+	const [shownSecrets, setShownSecrets] = useState<Record<string, boolean>>({});
+	const [localConfigValues, setLocalConfigValues] = useState<
+		Record<string, ProviderConfigFieldPrimitive>
+	>(() => getInitialConfigValues(provider));
+	const [modelSearchState, setModelSearchState] = useState<{
+		providerId: string;
+		value: string;
+	} | null>(null);
+	const [copiedModelState, setCopiedModelState] = useState<{
+		modelId: string;
+		providerId: string;
+	} | null>(null);
+	const copiedModelTimeoutRef = useRef<number | undefined>(undefined);
+
+	const configFields = provider.configFields ?? [];
+	const apiKeyValue = fieldValueToString(localConfigValues.apiKey);
+	const modelList = provider.modelList ?? [];
+	const modelSearch =
+		modelSearchState?.providerId === provider.id ? modelSearchState.value : "";
+	const copiedModelId =
+		copiedModelState?.providerId === provider.id
+			? copiedModelState.modelId
+			: null;
+	const modelSearchQuery = modelSearch.trim().toLowerCase();
+	const filteredModelList = modelSearchQuery
+		? modelList.filter(
+				(model) =>
+					model.name.toLowerCase().includes(modelSearchQuery) ||
+					model.id.toLowerCase().includes(modelSearchQuery),
+			)
+		: modelList;
+	const isPanel = variant === "panel";
+
+	useEffect(
+		() => () => {
+			if (copiedModelTimeoutRef.current !== undefined) {
+				window.clearTimeout(copiedModelTimeoutRef.current);
+			}
+		},
+		[],
+	);
+
+	const commitField = (
+		field: ProviderConfigField,
+		rawValue: string | boolean,
+	) => {
+		const value = coerceFieldValue(field, rawValue);
+		const nextConfigValues = {
+			...localConfigValues,
+			[field.path]: value,
+		};
+		setLocalConfigValues(nextConfigValues);
+
+		const updates: ProviderSettingsUpdate = {
+			configValues: { [field.path]: value },
+		};
+		if (field.path === "apiKey") {
+			updates.apiKey = fieldValueToString(value);
+		}
+		if (field.path === "baseUrl") {
+			updates.baseUrl = fieldValueToString(value);
+		}
+		onUpdate(updates);
+	};
+
+	const copyModelId = (modelId: string) => {
+		if (typeof navigator === "undefined" || !navigator.clipboard?.writeText) {
+			return;
+		}
+		void navigator.clipboard.writeText(modelId).then(() => {
+			setCopiedModelState({ modelId, providerId: provider.id });
+			if (copiedModelTimeoutRef.current !== undefined) {
+				window.clearTimeout(copiedModelTimeoutRef.current);
+			}
+			copiedModelTimeoutRef.current = window.setTimeout(
+				() => setCopiedModelState(null),
+				1600,
+			);
+		});
+	};
+
+	return (
+		<ScrollArea className="h-full">
+			<div
+				className={cn(
+					"py-10 max-[720px]:px-4 max-[720px]:py-5",
+					isPanel ? "px-6" : "px-18 max-[1200px]:px-8",
+				)}
+			>
+				{/* Back + title */}
+				<div className="mb-8 flex items-center gap-3">
+					<Button
+						aria-label={
+							isPanel ? "Close provider details" : "Back to providers"
+						}
+						className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						onClick={onBack}
+						variant="ghost"
+					>
+						{isPanel ? (
+							<X className="h-4 w-4" />
+						) : (
+							<ArrowLeft className="h-4 w-4" />
+						)}
+					</Button>
+					<h1
+						className={cn(
+							"truncate font-semibold leading-[1.15] tracking-normal text-foreground",
+							isPanel ? "text-[24px]" : "text-[32px]",
+						)}
+					>
+						{provider.name}
+					</h1>
+				</div>
+
+				{configFields.length > 0 ? (
+					<section
+						className={cn("mb-8", isPanel ? "max-w-none" : "max-w-[86rem]")}
+					>
+						<div className="flex flex-col">
+							{configFields.map((field) => {
+								const value = localConfigValues[field.path];
+								const valueText = fieldValueToString(value);
+								const isSecret = field.type === "password" || field.secret;
+								const isShown = shownSecrets[field.path] ?? false;
+								return (
+									<div
+										className="grid min-h-18 grid-cols-[minmax(12rem,0.55fr)_minmax(16rem,0.45fr)] items-center gap-6 border-b py-4 max-[900px]:grid-cols-1 max-[900px]:gap-3"
+										key={field.path}
+									>
+										<header>
+											<h3 className="text-[17px] font-semibold text-foreground">
+												{field.label}
+											</h3>
+											{field.description ? (
+												<p className="mt-1 text-[15px] leading-relaxed text-muted-foreground">
+													{field.description}
+												</p>
+											) : null}
+										</header>
+										{field.type === "boolean" ? (
+											<div className="flex items-center justify-end">
+												<span className="text-sm text-muted-foreground">
+													{field.label}
+												</span>
+												<Switch
+													checked={Boolean(value)}
+													onCheckedChange={(checked) =>
+														commitField(field, checked)
+													}
+												/>
+											</div>
+										) : field.type === "select" ? (
+											<select
+												className="h-9 w-full rounded border border-border bg-background px-3 text-sm text-foreground outline-none focus:ring-1 focus:ring-ring"
+												onChange={(event) =>
+													commitField(field, event.target.value)
+												}
+												value={valueText}
+											>
+												<option value="">Not set</option>
+												{field.options?.map((option) => (
+													<option
+														key={String(option.value)}
+														value={String(option.value)}
+													>
+														{option.label}
+													</option>
+												))}
+											</select>
+										) : (
+											<div className="flex h-9 items-center gap-2 rounded border border-border bg-background px-3">
+												{field.type === "url" ? (
+													<LinkIcon className="h-4 w-4 shrink-0 text-muted-foreground" />
+												) : null}
+												<Input
+													className="h-7 flex-1 border-0 bg-transparent px-0 text-sm text-foreground outline-none placeholder:text-muted-foreground"
+													onBlur={() => commitField(field, valueText)}
+													onChange={(event) =>
+														setLocalConfigValues((current) => ({
+															...current,
+															[field.path]: event.target.value,
+														}))
+													}
+													placeholder={field.placeholder}
+													spellCheck={false}
+													type={
+														isSecret && !isShown
+															? "password"
+															: field.type === "number"
+																? "number"
+																: field.type === "url"
+																	? "url"
+																	: "text"
+													}
+													value={valueText}
+												/>
+												{isSecret ? (
+													<>
+														<Button
+															aria-label={
+																isShown ? "Hide secret" : "Show secret"
+															}
+															className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+															onClick={() =>
+																setShownSecrets((current) => ({
+																	...current,
+																	[field.path]: !isShown,
+																}))
+															}
+															variant="ghost"
+														>
+															{isShown ? (
+																<EyeOff className="h-4 w-4" />
+															) : (
+																<Eye className="h-4 w-4" />
+															)}
+														</Button>
+														<Button
+															aria-label={`Copy ${field.label}`}
+															className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+															onClick={() =>
+																navigator.clipboard.writeText(valueText)
+															}
+															variant="ghost"
+														>
+															<Copy className="h-4 w-4" />
+														</Button>
+													</>
+												) : null}
+											</div>
+										)}
+									</div>
+								);
+							})}
+						</div>
+					</section>
+				) : null}
+
+				{!apiKeyValue && !provider.oauthAccessTokenPresent && onOAuthLogin ? (
+					<div className="mb-8">
+						<Button
+							className="inline-flex items-center gap-2 w-full"
+							disabled={oauthLoginPending}
+							onClick={onOAuthLogin}
+							variant="default"
+						>
+							{oauthLoginPending ? (
+								<Loader2 className="h-4 w-4 animate-spin" />
+							) : null}
+							<span>Login via Browser</span>
+						</Button>
+					</div>
+				) : null}
+				{provider.oauthAccessTokenPresent ? (
+					<p className="mb-8 text-xs text-muted-foreground">
+						OAuth is connected. Manual credentials remain available when this
+						provider supports them.
+					</p>
+				) : null}
+
+				{/* Models section */}
+				<section
+					className={cn(
+						"overflow-hidden rounded-lg border",
+						isPanel ? "max-w-none" : "max-w-[46rem]",
+					)}
+				>
+					<div className="flex h-12 items-center justify-between bg-muted/40 px-4">
+						<h2 className="text-[17px] font-medium text-muted-foreground">
+							Models
+						</h2>
+						<div className="flex items-center gap-1">
+							<Search className="size-4 text-muted-foreground" />
+							<Button
+								aria-label="Refresh models"
+								className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+								disabled={modelsLoading}
+								onClick={onLoadModels}
+								variant="ghost"
+							>
+								<RefreshCw
+									className={cn("size-3", modelsLoading && "animate-spin")}
+								/>
+							</Button>
+						</div>
+					</div>
+
+					{modelsError ? (
+						<div className="rounded-lg border border-border px-4 py-8 text-center">
+							<p className="text-sm text-destructive">{modelsError}</p>
+						</div>
+					) : modelList.length > 0 ? (
+						<div className="space-y-3">
+							<div className="mx-4 mt-4 flex items-center gap-2 rounded border border-border bg-background px-3 py-2">
+								<Search className="size-4 shrink-0 text-muted-foreground" />
+								<Input
+									aria-label="Search models"
+									className="h-7 flex-1 border-0 text-sm text-foreground placeholder:text-muted-foreground"
+									onChange={(event) =>
+										setModelSearchState({
+											providerId: provider.id,
+											value: event.target.value,
+										})
+									}
+									placeholder="Search models by name or ID"
+									spellCheck={false}
+									value={modelSearch}
+								/>
+							</div>
+							{filteredModelList.length > 0 ? (
+								<div className="max-h-125 overflow-y-scroll border-t">
+									{filteredModelList.map((model) => (
+										<div
+											className="group flex min-h-16 items-center gap-3 border-b px-4 py-3 transition-colors hover:bg-accent/30"
+											key={model.id}
+										>
+											<div className="min-w-0 flex-1 font-mono">
+												<div className="flex min-w-0 items-center gap-1.5 px-1 text-sm text-foreground">
+													<span className="truncate">{model.name}</span>
+													{/* Capability icons */}
+													{model.supportsAttachments && (
+														<div title="File Support">
+															<FileIcon className="h-3.5 w-3.5 text-muted-foreground" />
+														</div>
+													)}
+													{model.supportsVision && (
+														<div title="Image Support">
+															<ImageIcon className="h-3.5 w-3.5 text-muted-foreground" />
+														</div>
+													)}
+												</div>
+												<button
+													aria-label={`Copy model ID ${model.id}`}
+													className="mt-1 flex max-w-full items-center gap-1.5 px-1 text-left text-xs text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+													onClick={() => copyModelId(model.id)}
+													title="Copy model ID"
+													type="button"
+												>
+													<span className="min-w-0 truncate">{model.id}</span>
+													<Copy className="size-3 shrink-0" />
+													{copiedModelId === model.id ? (
+														<span className="shrink-0 text-foreground">
+															Copied
+														</span>
+													) : null}
+												</button>
+											</div>
+
+											{/* Action icons */}
+											<div className="flex items-center gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity">
+												<Button
+													aria-label={`Favorite ${model.name}`}
+													className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+													variant="ghost"
+												>
+													<Star className="h-3.5 w-3.5" />
+												</Button>
+											</div>
+										</div>
+									))}
+								</div>
+							) : (
+								<div className="rounded-lg border border-border px-4 py-8 text-center">
+									<p className="text-sm text-muted-foreground">
+										No models match "{modelSearch.trim()}".
+									</p>
+								</div>
+							)}
+						</div>
+					) : (
+						<div className="rounded-lg border border-border px-4 py-8 text-center">
+							<p className="text-sm text-muted-foreground">
+								{modelsLoading
+									? "Loading models..."
+									: "No models available. Click refresh to load models."}
+							</p>
+						</div>
+					)}
+				</section>
+			</div>
+		</ScrollArea>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/routine-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/routine-view.tsx
new file mode 100644
index 0000000..8a5249a
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/routine-view.tsx
@@ -0,0 +1,1540 @@
+"use client";
+
+import {
+	Circle,
+	Eye,
+	Pause,
+	Pencil,
+	Play,
+	Plus,
+	RefreshCw,
+	Trash2,
+	Zap,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import {
+	Combobox,
+	ComboboxContent,
+	ComboboxEmpty,
+	ComboboxInput,
+	ComboboxItem,
+	ComboboxList,
+} from "@/components/ui/combobox";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { desktopClient } from "@/lib/desktop-client";
+import { readModelSelectionStorageFromWindow } from "@/lib/model-selection";
+import { normalizeProviderId } from "@/lib/provider-id";
+import {
+	loadProviderModelCatalog,
+	loadProviderModels,
+} from "@/lib/provider-model-catalog";
+import { cn } from "@/lib/utils";
+import {
+	CommandBadge,
+	PageEmptyState,
+	PageFrame,
+	PageHeader,
+} from "../page-layout";
+
+type DateTimeValue = number | string;
+
+interface RoutineSchedule {
+	scheduleId: string;
+	name: string;
+	cronPattern: string;
+	prompt: string;
+	provider?: string;
+	model?: string;
+	modelSelection?: {
+		providerId?: string;
+		modelId?: string;
+	};
+	mode: "act" | "plan" | "yolo";
+	workspaceRoot?: string;
+	cwd?: string;
+	systemPrompt?: string;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	maxParallel: number;
+	enabled: boolean;
+	createdAt: DateTimeValue;
+	updatedAt: DateTimeValue;
+	lastRunAt?: DateTimeValue;
+	nextRunAt?: DateTimeValue;
+	tags?: string[];
+}
+
+interface RoutineExecution {
+	executionId: string;
+	scheduleId: string;
+	sessionId?: string;
+	triggeredAt?: DateTimeValue;
+	startedAt?: DateTimeValue;
+	endedAt?: DateTimeValue;
+	timeoutAt?: DateTimeValue;
+	status?: string;
+	errorMessage?: string;
+}
+
+interface RoutineUpcomingRun {
+	scheduleId: string;
+	name: string;
+	nextRunAt: DateTimeValue;
+}
+
+interface RoutineOverviewResponse {
+	schedules: RoutineSchedule[];
+	activeExecutions: RoutineExecution[];
+	upcomingRuns: RoutineUpcomingRun[];
+	lastExecutions: RoutineExecution[];
+}
+
+const ROUTINE_OVERVIEW_CACHE_TTL_MS = 30_000;
+
+let routineOverviewCache:
+	| (RoutineOverviewResponse & {
+			fetchedAt: number;
+	  })
+	| null = null;
+
+async function fetchRoutineOverview(): Promise<RoutineOverviewResponse> {
+	const response = await desktopClient.invoke<RoutineOverviewResponse>(
+		"list_routine_schedules",
+	);
+	return {
+		schedules: response.schedules ?? [],
+		activeExecutions: response.activeExecutions ?? [],
+		upcomingRuns: response.upcomingRuns ?? [],
+		lastExecutions: response.lastExecutions ?? [],
+	};
+}
+
+interface ProcessContext {
+	workspaceRoot: string;
+	cwd: string;
+}
+
+const FALLBACK_PROVIDER_MODELS: Record<string, string[]> = {
+	cline: ["anthropic/claude-sonnet-4.6"],
+	anthropic: ["claude-sonnet-4-6"],
+	"openai-native": ["gpt-5.3-codex"],
+	openrouter: ["anthropic/claude-sonnet-4.6"],
+	gemini: ["gemini-2.5-pro"],
+};
+
+const WEEKDAY_OPTIONS = [
+	{ label: "Mon", value: "MON" },
+	{ label: "Tue", value: "TUE" },
+	{ label: "Wed", value: "WED" },
+	{ label: "Thu", value: "THU" },
+	{ label: "Fri", value: "FRI" },
+	{ label: "Sat", value: "SAT" },
+	{ label: "Sun", value: "SUN" },
+] as const;
+
+interface RoutineFormState {
+	name: string;
+	scheduleHour: string;
+	scheduleMinute: string;
+	scheduleDays: string[];
+	prompt: string;
+	provider: string;
+	model: string;
+	mode: "act" | "plan";
+	workspaceRoot: string;
+	cwd: string;
+	systemPrompt: string;
+	maxIterations: string;
+	timeoutSeconds: string;
+	maxParallel: string;
+	tags: string;
+	enabled: boolean;
+}
+
+function formatDateTime(value?: DateTimeValue | null): string {
+	if (value === undefined || value === null) {
+		return "-";
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			return "-";
+		}
+		const parsed = new Date(value);
+		return Number.isNaN(parsed.getTime()) ? "-" : parsed.toLocaleString();
+	}
+	const trimmed = value.trim();
+	if (trimmed.length === 0) {
+		return "-";
+	}
+	const parsed = new Date(trimmed);
+	if (Number.isNaN(parsed.getTime())) {
+		return trimmed;
+	}
+	return parsed.toLocaleString();
+}
+
+function formatScheduleModel(schedule: RoutineSchedule): string {
+	const provider =
+		schedule.modelSelection?.providerId?.trim() || schedule.provider?.trim();
+	const model =
+		schedule.modelSelection?.modelId?.trim() || schedule.model?.trim();
+	if (provider && model) {
+		return `${provider}/${model}`;
+	}
+	return model || provider || "-";
+}
+
+function getScheduleProviderModel(schedule: RoutineSchedule): {
+	provider: string;
+	model: string;
+} {
+	return {
+		provider:
+			schedule.modelSelection?.providerId?.trim() ||
+			schedule.provider?.trim() ||
+			"cline",
+		model:
+			schedule.modelSelection?.modelId?.trim() ||
+			schedule.model?.trim() ||
+			"openai/gpt-5.3-codex",
+	};
+}
+
+function formatExecutionResult(execution?: RoutineExecution): string {
+	if (!execution) {
+		return "-";
+	}
+	const status = execution.status?.trim() || "unknown";
+	const timestamp =
+		execution.endedAt ?? execution.startedAt ?? execution.triggeredAt;
+	const when = formatDateTime(timestamp);
+	return when === "-" ? status : `${status} at ${when}`;
+}
+
+function parseOptionalPositiveInt(text: string): number | undefined {
+	const trimmed = text.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	const value = Number.parseInt(trimmed, 10);
+	if (!Number.isFinite(value) || value <= 0) {
+		return undefined;
+	}
+	return value;
+}
+
+function parseTags(text: string): string[] | undefined {
+	const tags = text
+		.split(",")
+		.map((value) => value.trim())
+		.filter((value) => value.length > 0);
+	return tags.length > 0 ? tags : undefined;
+}
+
+function normalizeScheduleDays(days: string[]): string[] {
+	const selected = new Set(days);
+	return WEEKDAY_OPTIONS.map((option) => option.value).filter((value) =>
+		selected.has(value),
+	);
+}
+
+function buildCronPattern(
+	days: string[],
+	hour: string,
+	minute: string,
+): string {
+	const normalizedDays = normalizeScheduleDays(days);
+	if (normalizedDays.length === 0) {
+		return "";
+	}
+	const normalizedHour = Number.parseInt(hour, 10);
+	const normalizedMinute = Number.parseInt(minute, 10);
+	const cronHour = Number.isFinite(normalizedHour)
+		? Math.min(Math.max(normalizedHour, 0), 23)
+		: 9;
+	const cronMinute = Number.isFinite(normalizedMinute)
+		? Math.min(Math.max(normalizedMinute, 0), 59)
+		: 0;
+	if (normalizedDays.length === WEEKDAY_OPTIONS.length) {
+		return `${cronMinute} ${cronHour} * * *`;
+	}
+	return `${cronMinute} ${cronHour} * * ${normalizedDays.join(",")}`;
+}
+
+function expandCronDays(dayExpression: string | undefined): string[] {
+	const raw = dayExpression?.trim().toUpperCase();
+	if (!raw || raw === "*") {
+		return WEEKDAY_OPTIONS.map((option) => option.value);
+	}
+	const values = new Set<string>();
+	for (const part of raw.split(",")) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		const rangeMatch = /^([A-Z]{3})-([A-Z]{3})$/.exec(trimmed);
+		if (rangeMatch) {
+			const start = WEEKDAY_OPTIONS.findIndex(
+				(option) => option.value === rangeMatch[1],
+			);
+			const end = WEEKDAY_OPTIONS.findIndex(
+				(option) => option.value === rangeMatch[2],
+			);
+			if (start >= 0 && end >= start) {
+				for (let index = start; index <= end; index += 1) {
+					values.add(WEEKDAY_OPTIONS[index].value);
+				}
+			}
+			continue;
+		}
+		if (WEEKDAY_OPTIONS.some((option) => option.value === trimmed)) {
+			values.add(trimmed);
+		}
+	}
+	return normalizeScheduleDays([...values]);
+}
+
+function parseCronPattern(
+	cronPattern: string,
+): Pick<RoutineFormState, "scheduleHour" | "scheduleMinute" | "scheduleDays"> {
+	const parts = cronPattern.trim().split(/\s+/);
+	const minute = Number.parseInt(parts[0] ?? "", 10);
+	const hour = Number.parseInt(parts[1] ?? "", 10);
+	const days = expandCronDays(parts[4]);
+	return {
+		scheduleHour:
+			Number.isInteger(hour) && hour >= 0 && hour <= 23 ? String(hour) : "9",
+		scheduleMinute:
+			Number.isInteger(minute) && minute >= 0 && minute <= 59
+				? String(minute)
+				: "0",
+		scheduleDays: days.length > 0 ? days : ["MON", "TUE", "WED", "THU", "FRI"],
+	};
+}
+
+export function RoutineSchedulesContent() {
+	const [schedules, setSchedules] = useState<RoutineSchedule[]>(
+		() => routineOverviewCache?.schedules ?? [],
+	);
+	const [activeExecutions, setActiveExecutions] = useState<RoutineExecution[]>(
+		() => routineOverviewCache?.activeExecutions ?? [],
+	);
+	const [upcomingRuns, setUpcomingRuns] = useState<RoutineUpcomingRun[]>(
+		() => routineOverviewCache?.upcomingRuns ?? [],
+	);
+	const [lastExecutions, setLastExecutions] = useState<RoutineExecution[]>(
+		() => routineOverviewCache?.lastExecutions ?? [],
+	);
+	const [isLoading, setIsLoading] = useState(() => !routineOverviewCache);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [busyScheduleId, setBusyScheduleId] = useState<string | null>(null);
+	const [schedulePendingDelete, setSchedulePendingDelete] =
+		useState<RoutineSchedule | null>(null);
+	const [isCreateOpen, setIsCreateOpen] = useState(false);
+	const [editingSchedule, setEditingSchedule] =
+		useState<RoutineSchedule | null>(null);
+	const [isCreating, setIsCreating] = useState(false);
+	const [createFormError, setCreateFormError] = useState<string | null>(null);
+	const [providerModels, setProviderModels] = useState<
+		Record<string, string[]>
+	>(FALLBACK_PROVIDER_MODELS);
+	const [enabledProviderIds, setEnabledProviderIds] = useState<string[]>(() =>
+		Object.keys(FALLBACK_PROVIDER_MODELS),
+	);
+	const [lastModelSelection] = useState(() =>
+		readModelSelectionStorageFromWindow(),
+	);
+	const rememberedProvider = normalizeProviderId(
+		lastModelSelection.lastProvider,
+	);
+	const [createForm, setCreateForm] = useState<RoutineFormState>({
+		name: "",
+		scheduleHour: "9",
+		scheduleMinute: "0",
+		scheduleDays: ["MON", "TUE", "WED", "THU", "FRI"],
+		prompt: "Review PRs opened yesterday and summarize issues.",
+		provider: "cline",
+		model: "openai/gpt-5.3-codex",
+		mode: "act",
+		workspaceRoot: "",
+		cwd: "",
+		systemPrompt: "",
+		maxIterations: "",
+		timeoutSeconds: "",
+		maxParallel: "1",
+		tags: "",
+		enabled: true,
+	});
+
+	const visibleProviderModels = useMemo(() => {
+		if (enabledProviderIds.length === 0) {
+			return providerModels;
+		}
+		const next: Record<string, string[]> = {};
+		for (const providerId of enabledProviderIds) {
+			next[providerId] = providerModels[providerId] ?? [];
+		}
+		return next;
+	}, [enabledProviderIds, providerModels]);
+
+	const availableProviders = useMemo(
+		() => Object.keys(visibleProviderModels),
+		[visibleProviderModels],
+	);
+
+	const availableModelsForProvider = useMemo(
+		() => visibleProviderModels[createForm.provider] ?? [],
+		[createForm.provider, visibleProviderModels],
+	);
+
+	const cronPreview = useMemo(
+		() =>
+			buildCronPattern(
+				createForm.scheduleDays,
+				createForm.scheduleHour,
+				createForm.scheduleMinute,
+			),
+		[
+			createForm.scheduleDays,
+			createForm.scheduleHour,
+			createForm.scheduleMinute,
+		],
+	);
+
+	useEffect(() => {
+		let cancelled = false;
+
+		async function loadCatalog() {
+			try {
+				const payload = await loadProviderModelCatalog();
+				if (cancelled) {
+					return;
+				}
+				setProviderModels(payload.providerModels);
+				setEnabledProviderIds((current) => {
+					const nextProviderIds = new Set(payload.enabledProviderIds);
+					const normalizedCurrentProvider = normalizeProviderId(
+						createForm.provider,
+					);
+					if (normalizedCurrentProvider) {
+						nextProviderIds.add(normalizedCurrentProvider);
+					}
+					for (const providerId of current) {
+						if (providerId in payload.providerModels) {
+							nextProviderIds.add(providerId);
+						}
+					}
+					return Array.from(nextProviderIds);
+				});
+			} catch {
+				// Keep fallback values if provider catalog is unavailable.
+			}
+		}
+
+		void loadCatalog();
+		return () => {
+			cancelled = true;
+		};
+	}, [createForm.provider]);
+
+	useEffect(() => {
+		const normalizedProvider = normalizeProviderId(createForm.provider);
+		if (!normalizedProvider) {
+			return;
+		}
+		if ((providerModels[normalizedProvider] ?? []).length > 0) {
+			return;
+		}
+
+		let cancelled = false;
+
+		async function loadModelsForProvider() {
+			try {
+				const models = await loadProviderModels(normalizedProvider);
+				if (cancelled || models.length === 0) {
+					return;
+				}
+				setProviderModels((current) => ({
+					...current,
+					[normalizedProvider]: models.map((entry) => entry.id),
+				}));
+				setEnabledProviderIds((current) =>
+					current.includes(normalizedProvider)
+						? current
+						: [...current, normalizedProvider],
+				);
+			} catch {
+				// Keep existing values when provider-specific model loading fails.
+			}
+		}
+
+		void loadModelsForProvider();
+		return () => {
+			cancelled = true;
+		};
+	}, [createForm.provider, providerModels]);
+
+	useEffect(() => {
+		if (availableProviders.length === 0) {
+			return;
+		}
+		let nextSelection: { provider: string; model: string } | null = null;
+		const normalizedFormProvider = normalizeProviderId(createForm.provider);
+		if (!availableProviders.includes(normalizedFormProvider)) {
+			const nextProvider =
+				rememberedProvider && availableProviders.includes(rememberedProvider)
+					? rememberedProvider
+					: availableProviders[0];
+			const models = visibleProviderModels[nextProvider] ?? [];
+			const rememberedModel =
+				lastModelSelection.lastModelByProvider[nextProvider] ??
+				lastModelSelection.lastModelByProvider[lastModelSelection.lastProvider];
+			const nextModel =
+				rememberedModel && models.includes(rememberedModel)
+					? rememberedModel
+					: (models[0] ?? "");
+			nextSelection = { provider: nextProvider, model: nextModel };
+		} else {
+			const models = visibleProviderModels[normalizedFormProvider] ?? [];
+			if (models.length === 0 || models.includes(createForm.model)) {
+				return;
+			}
+			const rememberedModel =
+				lastModelSelection.lastModelByProvider[normalizedFormProvider] ??
+				lastModelSelection.lastModelByProvider[lastModelSelection.lastProvider];
+			const nextModel =
+				rememberedModel && models.includes(rememberedModel)
+					? rememberedModel
+					: models[0];
+			nextSelection = { provider: normalizedFormProvider, model: nextModel };
+		}
+
+		const timeoutId = window.setTimeout(() => {
+			setCreateForm((prev) => ({
+				...prev,
+				...nextSelection,
+			}));
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [
+		availableProviders,
+		createForm.model,
+		createForm.provider,
+		lastModelSelection.lastModelByProvider,
+		lastModelSelection.lastProvider,
+		rememberedProvider,
+		visibleProviderModels,
+	]);
+
+	const refreshSchedules = useCallback(
+		async (options?: { force?: boolean; showLoading?: boolean }) => {
+			const now = Date.now();
+			if (
+				!options?.force &&
+				routineOverviewCache &&
+				now - routineOverviewCache.fetchedAt < ROUTINE_OVERVIEW_CACHE_TTL_MS
+			) {
+				setSchedules(routineOverviewCache.schedules);
+				setActiveExecutions(routineOverviewCache.activeExecutions);
+				setUpcomingRuns(routineOverviewCache.upcomingRuns);
+				setLastExecutions(routineOverviewCache.lastExecutions);
+				setErrorMessage(null);
+				setIsLoading(false);
+				return;
+			}
+
+			if (options?.showLoading !== false) {
+				setIsLoading(true);
+			}
+			setErrorMessage(null);
+			try {
+				const response = await fetchRoutineOverview();
+				const schedules = response.schedules;
+				const activeExecutions = response.activeExecutions;
+				const upcomingRuns = response.upcomingRuns;
+				const lastExecutions = response.lastExecutions;
+				setSchedules(schedules);
+				setActiveExecutions(activeExecutions);
+				setUpcomingRuns(upcomingRuns);
+				setLastExecutions(lastExecutions);
+				routineOverviewCache = {
+					schedules,
+					activeExecutions,
+					upcomingRuns,
+					lastExecutions,
+					fetchedAt: now,
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setErrorMessage(message);
+			} finally {
+				setIsLoading(false);
+			}
+		},
+		[],
+	);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refreshSchedules();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refreshSchedules]);
+
+	const upsertScheduleEnabled = async (
+		schedule: RoutineSchedule,
+		enabled: boolean,
+	) => {
+		setBusyScheduleId(schedule.scheduleId);
+		setErrorMessage(null);
+		try {
+			if (enabled) {
+				await desktopClient.invoke("resume_routine_schedule", {
+					schedule_id: schedule.scheduleId,
+				});
+			} else {
+				await desktopClient.invoke("pause_routine_schedule", {
+					schedule_id: schedule.scheduleId,
+				});
+			}
+			await refreshSchedules({ force: true, showLoading: false });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyScheduleId(null);
+		}
+	};
+
+	const triggerSchedule = async (scheduleId: string) => {
+		setBusyScheduleId(scheduleId);
+		setErrorMessage(null);
+		try {
+			await desktopClient.invoke("trigger_routine_schedule", {
+				schedule_id: scheduleId,
+			});
+			await refreshSchedules({ force: true, showLoading: false });
+			window.setTimeout(() => {
+				void refreshSchedules({ force: true, showLoading: false });
+			}, 1_000);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyScheduleId(null);
+		}
+	};
+
+	const deleteSchedule = async (scheduleId: string) => {
+		setBusyScheduleId(scheduleId);
+		setErrorMessage(null);
+		try {
+			await desktopClient.invoke("delete_routine_schedule", {
+				schedule_id: scheduleId,
+			});
+			setSchedulePendingDelete(null);
+			await refreshSchedules({ force: true, showLoading: false });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyScheduleId(null);
+		}
+	};
+
+	const openCreateDialog = async () => {
+		setEditingSchedule(null);
+		setErrorMessage(null);
+		setCreateFormError(null);
+		let context: ProcessContext = { workspaceRoot: "", cwd: "" };
+		try {
+			context = await desktopClient.invoke<ProcessContext>(
+				"get_process_context",
+			);
+		} catch {
+			// Use empty defaults when context lookup fails.
+		}
+		const preferredProvider =
+			rememberedProvider && availableProviders.includes(rememberedProvider)
+				? rememberedProvider
+				: (availableProviders[0] ?? "cline");
+		const modelsForProvider = visibleProviderModels[preferredProvider] ?? [];
+		const rememberedModel =
+			lastModelSelection.lastModelByProvider[preferredProvider] ??
+			lastModelSelection.lastModelByProvider[lastModelSelection.lastProvider];
+		const preferredModel =
+			rememberedModel && modelsForProvider.includes(rememberedModel)
+				? rememberedModel
+				: (modelsForProvider[0] ?? createForm.model);
+		setCreateForm({
+			name: "",
+			scheduleHour: "9",
+			scheduleMinute: "0",
+			scheduleDays: ["MON", "TUE", "WED", "THU", "FRI"],
+			prompt: "Review PRs opened yesterday and summarize issues.",
+			provider: preferredProvider,
+			model: preferredModel,
+			mode: "act",
+			workspaceRoot: context.workspaceRoot || context.cwd,
+			cwd: context.cwd || "",
+			systemPrompt: "",
+			maxIterations: "",
+			timeoutSeconds: "",
+			maxParallel: "1",
+			tags: "",
+			enabled: true,
+		});
+		setIsCreateOpen(true);
+	};
+
+	const openEditDialog = (schedule: RoutineSchedule) => {
+		const { provider, model } = getScheduleProviderModel(schedule);
+		const parsedCron = parseCronPattern(schedule.cronPattern);
+		setEditingSchedule(schedule);
+		setErrorMessage(null);
+		setCreateFormError(null);
+		setEnabledProviderIds((current) =>
+			current.includes(provider) ? current : [...current, provider],
+		);
+		setProviderModels((current) =>
+			current[provider]?.includes(model)
+				? current
+				: {
+						...current,
+						[provider]: [...(current[provider] ?? []), model],
+					},
+		);
+		setCreateForm({
+			name: schedule.name,
+			...parsedCron,
+			prompt: schedule.prompt,
+			provider,
+			model,
+			mode: schedule.mode === "plan" ? "plan" : "act",
+			workspaceRoot: schedule.workspaceRoot ?? "",
+			cwd: schedule.cwd ?? "",
+			systemPrompt: schedule.systemPrompt ?? "",
+			maxIterations:
+				typeof schedule.maxIterations === "number"
+					? String(schedule.maxIterations)
+					: "",
+			timeoutSeconds:
+				typeof schedule.timeoutSeconds === "number"
+					? String(schedule.timeoutSeconds)
+					: "",
+			maxParallel:
+				typeof schedule.maxParallel === "number"
+					? String(schedule.maxParallel)
+					: "1",
+			tags: schedule.tags?.join(",") ?? "",
+			enabled: schedule.enabled,
+		});
+		setIsCreateOpen(true);
+	};
+
+	const submitCreateForm = async () => {
+		const name = createForm.name.trim();
+		if (!name) {
+			setCreateFormError("Routine name is required.");
+			return;
+		}
+		const cronPattern = buildCronPattern(
+			createForm.scheduleDays,
+			createForm.scheduleHour,
+			createForm.scheduleMinute,
+		);
+		if (!cronPattern) {
+			setCreateFormError("Select at least one day and a valid time.");
+			return;
+		}
+		const prompt = createForm.prompt.trim();
+		if (!prompt) {
+			setCreateFormError("Prompt is required.");
+			return;
+		}
+		const workspaceRoot = createForm.workspaceRoot.trim();
+		if (!workspaceRoot) {
+			setCreateFormError("Workspace root is required.");
+			return;
+		}
+		setCreateFormError(null);
+		setIsCreating(true);
+		try {
+			const provider =
+				normalizeProviderId(createForm.provider) ||
+				availableProviders[0] ||
+				"cline";
+			const model =
+				createForm.model.trim() ||
+				(visibleProviderModels[provider] ?? [])[0] ||
+				"openai/gpt-5.3-codex";
+			const maxIterations = parseOptionalPositiveInt(createForm.maxIterations);
+			const timeoutSeconds = parseOptionalPositiveInt(
+				createForm.timeoutSeconds,
+			);
+			const maxParallel = parseOptionalPositiveInt(createForm.maxParallel) ?? 1;
+			const tags = parseTags(createForm.tags);
+			const command = editingSchedule
+				? "update_routine_schedule"
+				: "create_routine_schedule";
+			await desktopClient.invoke(command, {
+				...(editingSchedule
+					? { schedule_id: editingSchedule.scheduleId }
+					: undefined),
+				name,
+				cron_pattern: cronPattern,
+				prompt,
+				provider,
+				model,
+				mode: createForm.mode,
+				workspace_root: workspaceRoot,
+				cwd: createForm.cwd.trim() || undefined,
+				system_prompt: editingSchedule
+					? createForm.systemPrompt.trim() || null
+					: createForm.systemPrompt.trim() || undefined,
+				max_iterations: editingSchedule
+					? (maxIterations ?? null)
+					: maxIterations,
+				timeout_seconds: editingSchedule
+					? (timeoutSeconds ?? null)
+					: timeoutSeconds,
+				max_parallel: maxParallel,
+				enabled: createForm.enabled,
+				tags: tags ?? [],
+			});
+			await refreshSchedules({ force: true, showLoading: false });
+			setIsCreateOpen(false);
+			setEditingSchedule(null);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setCreateFormError(message);
+		} finally {
+			setIsCreating(false);
+		}
+	};
+
+	const executionBySchedule = useMemo(() => {
+		const map = new Map<string, RoutineExecution>();
+		for (const execution of activeExecutions) {
+			if (!execution.scheduleId) {
+				continue;
+			}
+			if (!map.has(execution.scheduleId)) {
+				map.set(execution.scheduleId, execution);
+			}
+		}
+		return map;
+	}, [activeExecutions]);
+
+	const lastExecutionBySchedule = useMemo(() => {
+		const map = new Map<string, RoutineExecution>();
+		for (const execution of lastExecutions) {
+			if (!execution.scheduleId) {
+				continue;
+			}
+			if (!map.has(execution.scheduleId)) {
+				map.set(execution.scheduleId, execution);
+			}
+		}
+		return map;
+	}, [lastExecutions]);
+
+	const sortedSchedules = useMemo(
+		() =>
+			[...schedules].sort((a, b) =>
+				a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+			),
+		[schedules],
+	);
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description="Scheduled jobs are run through the hub."
+				title="Schedules"
+				meta={<CommandBadge>cline schedule</CommandBadge>}
+				actions={
+					<>
+						<Button
+							variant="outline"
+							size="sm"
+							onClick={() => void refreshSchedules()}
+							disabled={isLoading}
+						>
+							<RefreshCw
+								className={cn("h-4 w-4", isLoading && "animate-spin")}
+							/>
+						</Button>
+						<Button size="sm" onClick={() => void openCreateDialog()}>
+							<Plus className="h-4 w-4" />
+							New Schedule
+						</Button>
+					</>
+				}
+			/>
+
+			{errorMessage && (
+				<div className="mb-4 rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			)}
+
+			{isLoading ? (
+				<PageEmptyState>Loading schedules...</PageEmptyState>
+			) : sortedSchedules.length === 0 ? (
+				<PageEmptyState>
+					No schedules found. Create a schedule to run routines on a recurring
+					basis.
+				</PageEmptyState>
+			) : (
+				<div className="flex flex-col gap-3">
+					{sortedSchedules.map((schedule) => {
+						const isBusy = busyScheduleId === schedule.scheduleId;
+						const activeExecution = executionBySchedule.get(
+							schedule.scheduleId,
+						);
+						const lastExecution = lastExecutionBySchedule.get(
+							schedule.scheduleId,
+						);
+						const upcoming = upcomingRuns.find(
+							(item) => item.scheduleId === schedule.scheduleId,
+						);
+						return (
+							<div
+								key={schedule.scheduleId}
+								className="rounded-lg border border-border px-5 py-4 transition-colors hover:bg-accent/20"
+							>
+								<div className="flex items-center gap-3">
+									<Circle
+										className={cn(
+											"h-2.5 w-2.5 shrink-0",
+											schedule.enabled
+												? "fill-primary text-primary"
+												: "fill-muted-foreground/40 text-muted-foreground/40",
+										)}
+									/>
+									<h3 className="text-sm font-semibold text-foreground">
+										{schedule.name}
+									</h3>
+									<span className="rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{schedule.mode}
+									</span>
+									<span className="rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{schedule.cronPattern}
+									</span>
+									<div className="flex-1" />
+									<div className="flex items-center gap-1">
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`View ${schedule.name}`}
+											onClick={() => {
+												window.alert(JSON.stringify(schedule, null, 2));
+											}}
+										>
+											<Eye className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Edit ${schedule.name}`}
+											onClick={() => openEditDialog(schedule)}
+											disabled={isBusy}
+										>
+											<Pencil className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Run ${schedule.name} now`}
+											onClick={() => void triggerSchedule(schedule.scheduleId)}
+											disabled={isBusy}
+										>
+											<Zap className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={
+												schedule.enabled
+													? `Pause ${schedule.name}`
+													: `Resume ${schedule.name}`
+											}
+											onClick={() =>
+												void upsertScheduleEnabled(schedule, !schedule.enabled)
+											}
+											disabled={isBusy}
+										>
+											{schedule.enabled ? (
+												<Pause className="h-3.5 w-3.5" />
+											) : (
+												<Play className="h-3.5 w-3.5" />
+											)}
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Delete ${schedule.name}`}
+											onClick={() => setSchedulePendingDelete(schedule)}
+											disabled={isBusy}
+										>
+											<Trash2 className="h-3.5 w-3.5" />
+										</Button>
+										<Switch
+											checked={schedule.enabled}
+											onCheckedChange={(checked) =>
+												void upsertScheduleEnabled(schedule, checked)
+											}
+											disabled={isBusy}
+											aria-label={`Enable ${schedule.name}`}
+										/>
+									</div>
+								</div>
+
+								<div className="mt-2.5 ml-5.5 flex flex-col gap-1 text-xs text-muted-foreground">
+									<p>
+										<span className="text-muted-foreground/70">ID:</span>{" "}
+										{schedule.scheduleId}
+									</p>
+									<p>
+										<span className="text-muted-foreground/70">Prompt:</span>{" "}
+										{schedule.prompt}
+									</p>
+									<p>
+										<span className="text-muted-foreground/70">Model:</span>{" "}
+										{formatScheduleModel(schedule)}
+									</p>
+									{schedule.workspaceRoot && (
+										<p>
+											<span className="text-muted-foreground/70">
+												Workspace:
+											</span>{" "}
+											{schedule.workspaceRoot}
+										</p>
+									)}
+									{schedule.cwd && (
+										<p>
+											<span className="text-muted-foreground/70">CWD:</span>{" "}
+											{schedule.cwd}
+										</p>
+									)}
+									<p>
+										<span className="text-muted-foreground/70">Last run:</span>{" "}
+										{formatDateTime(schedule.lastRunAt)}
+									</p>
+									<p>
+										<span className="text-muted-foreground/70">
+											Last result:
+										</span>{" "}
+										{formatExecutionResult(lastExecution)}
+									</p>
+									{lastExecution?.sessionId && (
+										<p>
+											<span className="text-muted-foreground/70">
+												Last session:
+											</span>{" "}
+											{lastExecution.sessionId}
+										</p>
+									)}
+									{lastExecution?.errorMessage && (
+										<p className="text-destructive">
+											<span className="text-muted-foreground/70">
+												Last error:
+											</span>{" "}
+											{lastExecution.errorMessage}
+										</p>
+									)}
+									<p>
+										<span className="text-muted-foreground/70">Next run:</span>{" "}
+										{formatDateTime(schedule.nextRunAt || upcoming?.nextRunAt)}
+									</p>
+									{activeExecution && (
+										<p>
+											<span className="text-muted-foreground/70">Active:</span>{" "}
+											{activeExecution.executionId} since{" "}
+											{formatDateTime(activeExecution.startedAt)}
+										</p>
+									)}
+									{schedule.tags && schedule.tags.length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Tags:</span>{" "}
+											{schedule.tags.join(", ")}
+										</p>
+									)}
+								</div>
+							</div>
+						);
+					})}
+				</div>
+			)}
+			<AlertDialog
+				open={Boolean(schedulePendingDelete)}
+				onOpenChange={(open) => {
+					if (!open) {
+						setSchedulePendingDelete(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete Routine</AlertDialogTitle>
+						<AlertDialogDescription>
+							This will delete "{schedulePendingDelete?.name ?? "this routine"}"
+							and remove future scheduled runs.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel
+							disabled={
+								schedulePendingDelete
+									? busyScheduleId === schedulePendingDelete.scheduleId
+									: false
+							}
+						>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={
+								!schedulePendingDelete ||
+								busyScheduleId === schedulePendingDelete.scheduleId
+							}
+							onClick={() => {
+								if (schedulePendingDelete) {
+									void deleteSchedule(schedulePendingDelete.scheduleId);
+								}
+							}}
+							variant="destructive"
+						>
+							Delete
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+			<Dialog
+				open={isCreateOpen}
+				onOpenChange={(open) => {
+					setIsCreateOpen(open);
+					if (!open) {
+						setCreateFormError(null);
+						setEditingSchedule(null);
+					}
+				}}
+			>
+				<DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-2xl">
+					<DialogHeader>
+						<DialogTitle>
+							{editingSchedule ? "Edit Routine" : "Create Routine"}
+						</DialogTitle>
+						<DialogDescription>
+							{editingSchedule
+								? "Update this scheduler routine."
+								: "Create a scheduler routine."}
+						</DialogDescription>
+					</DialogHeader>
+
+					<div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-name">Name</Label>
+							<Input
+								id="routine-name"
+								value={createForm.name}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										name: event.target.value,
+									}))
+								}
+								placeholder="Daily code review"
+							/>
+						</div>
+
+						<div className="sm:col-span-2 space-y-3">
+							<Label>Schedule</Label>
+							<div className="grid grid-cols-1 gap-3 rounded-md border border-border p-3 sm:grid-cols-2">
+								<div>
+									<Label htmlFor="routine-hour">Hour</Label>
+									<Select
+										value={createForm.scheduleHour}
+										onValueChange={(value) =>
+											setCreateForm((prev) => ({
+												...prev,
+												scheduleHour: value ?? prev.scheduleHour,
+											}))
+										}
+									>
+										<SelectTrigger className="w-full" id="routine-hour">
+											<SelectValue placeholder="Hour" />
+										</SelectTrigger>
+										<SelectContent>
+											{Array.from({ length: 24 }, (_, idx) => idx).map(
+												(hour) => (
+													<SelectItem key={`hour-${hour}`} value={`${hour}`}>
+														{hour.toString().padStart(2, "0")}
+													</SelectItem>
+												),
+											)}
+										</SelectContent>
+									</Select>
+								</div>
+								<div>
+									<Label htmlFor="routine-minute">Minute</Label>
+									<Select
+										value={createForm.scheduleMinute}
+										onValueChange={(value) =>
+											setCreateForm((prev) => ({
+												...prev,
+												scheduleMinute: value ?? prev.scheduleMinute,
+											}))
+										}
+									>
+										<SelectTrigger className="w-full" id="routine-minute">
+											<SelectValue placeholder="Minute" />
+										</SelectTrigger>
+										<SelectContent>
+											{Array.from({ length: 60 }, (_, minute) => minute).map(
+												(minute) => {
+													return (
+														<SelectItem
+															key={`minute-${minute}`}
+															value={`${minute}`}
+														>
+															{minute.toString().padStart(2, "0")}
+														</SelectItem>
+													);
+												},
+											)}
+										</SelectContent>
+									</Select>
+								</div>
+								<div className="sm:col-span-2">
+									<Label>Days of week</Label>
+									<div className="mt-2 grid grid-cols-2 gap-2 sm:grid-cols-4">
+										{WEEKDAY_OPTIONS.map((day) => {
+											const inputId = `routine-day-${day.value.toLowerCase()}`;
+											const checked = createForm.scheduleDays.includes(
+												day.value,
+											);
+											return (
+												<Label
+													className="flex items-center gap-2 rounded-md border border-border px-2 py-1.5 text-sm"
+													htmlFor={inputId}
+													key={day.value}
+												>
+													<Checkbox
+														checked={checked}
+														id={inputId}
+														onCheckedChange={(value) =>
+															setCreateForm((prev) => {
+																const nextSet = new Set(prev.scheduleDays);
+																if (value === true) {
+																	nextSet.add(day.value);
+																} else {
+																	nextSet.delete(day.value);
+																}
+																return {
+																	...prev,
+																	scheduleDays: normalizeScheduleDays([
+																		...nextSet,
+																	]),
+																};
+															})
+														}
+													/>
+													{day.label}
+												</Label>
+											);
+										})}
+									</div>
+								</div>
+								<div className="sm:col-span-2 rounded-md border border-border bg-muted/30 px-2 py-1.5 text-xs text-muted-foreground">
+									Cron:{" "}
+									<span className="font-mono text-foreground">
+										{cronPreview || "Select one or more days"}
+									</span>
+								</div>
+							</div>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-prompt">Prompt</Label>
+							<Textarea
+								id="routine-prompt"
+								value={createForm.prompt}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										prompt: event.target.value,
+									}))
+								}
+								rows={4}
+							/>
+						</div>
+
+						<div>
+							<Label>Provider</Label>
+							<Combobox
+								items={availableProviders}
+								onValueChange={(value) => {
+									if (!value) {
+										return;
+									}
+									const providerModelsForNext =
+										visibleProviderModels[value] ?? [];
+									const rememberedModel =
+										lastModelSelection.lastModelByProvider[value];
+									const nextModel =
+										rememberedModel &&
+										providerModelsForNext.includes(rememberedModel)
+											? rememberedModel
+											: (providerModelsForNext[0] ?? "");
+									setCreateForm((prev) => ({
+										...prev,
+										provider: value,
+										model: nextModel,
+									}));
+								}}
+								value={createForm.provider}
+							>
+								<ComboboxInput
+									className="h-9 w-full"
+									readOnly
+									showClear={false}
+									showTrigger
+								/>
+								<ComboboxContent>
+									<ComboboxEmpty>No providers found.</ComboboxEmpty>
+									<ComboboxList>
+										{(item) => (
+											<ComboboxItem key={item} value={item}>
+												{item}
+											</ComboboxItem>
+										)}
+									</ComboboxList>
+								</ComboboxContent>
+							</Combobox>
+						</div>
+
+						<div>
+							<Label>Model</Label>
+							<Combobox
+								items={availableModelsForProvider}
+								onValueChange={(value) => {
+									if (!value) {
+										return;
+									}
+									setCreateForm((prev) => ({ ...prev, model: value }));
+								}}
+								value={createForm.model}
+							>
+								<ComboboxInput
+									className="h-9 w-full"
+									readOnly
+									showClear={false}
+									showTrigger
+								/>
+								<ComboboxContent>
+									<ComboboxEmpty>No models found.</ComboboxEmpty>
+									<ComboboxList>
+										{(item) => (
+											<ComboboxItem key={item} value={item}>
+												{item}
+											</ComboboxItem>
+										)}
+									</ComboboxList>
+								</ComboboxContent>
+							</Combobox>
+						</div>
+
+						<div>
+							<Label>Mode</Label>
+							<Select
+								value={createForm.mode}
+								onValueChange={(value) =>
+									setCreateForm((prev) => ({
+										...prev,
+										mode: value === "plan" ? "plan" : "act",
+									}))
+								}
+							>
+								<SelectTrigger className="w-full">
+									<SelectValue placeholder="Select mode" />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="act">act</SelectItem>
+									<SelectItem value="plan">plan</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-workspace">Workspace root</Label>
+							<Input
+								id="routine-workspace"
+								value={createForm.workspaceRoot}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										workspaceRoot: event.target.value,
+									}))
+								}
+							/>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-cwd">CWD (optional)</Label>
+							<Input
+								id="routine-cwd"
+								value={createForm.cwd}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										cwd: event.target.value,
+									}))
+								}
+							/>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-system-prompt">
+								System prompt (optional)
+							</Label>
+							<Textarea
+								id="routine-system-prompt"
+								value={createForm.systemPrompt}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										systemPrompt: event.target.value,
+									}))
+								}
+								rows={3}
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-max-iterations">
+								Max iterations (optional)
+							</Label>
+							<Input
+								id="routine-max-iterations"
+								value={createForm.maxIterations}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										maxIterations: event.target.value,
+									}))
+								}
+								placeholder="50"
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-timeout">
+								Timeout seconds (optional)
+							</Label>
+							<Input
+								id="routine-timeout"
+								value={createForm.timeoutSeconds}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										timeoutSeconds: event.target.value,
+									}))
+								}
+								placeholder="3600"
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-max-parallel">Max parallel</Label>
+							<Input
+								id="routine-max-parallel"
+								value={createForm.maxParallel}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										maxParallel: event.target.value,
+									}))
+								}
+								placeholder="1"
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-tags">
+								Tags (comma-separated, optional)
+							</Label>
+							<Input
+								id="routine-tags"
+								value={createForm.tags}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										tags: event.target.value,
+									}))
+								}
+								placeholder="automation,review"
+							/>
+						</div>
+					</div>
+
+					{createFormError && (
+						<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+							{createFormError}
+						</div>
+					)}
+
+					<DialogFooter>
+						<Button
+							variant="outline"
+							onClick={() => setIsCreateOpen(false)}
+							disabled={isCreating}
+						>
+							Cancel
+						</Button>
+						<Button
+							onClick={() => void submitCreateForm()}
+							disabled={isCreating}
+						>
+							{isCreating
+								? editingSchedule
+									? "Saving..."
+									: "Creating..."
+								: editingSchedule
+									? "Save Changes"
+									: "Create Schedule"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+		</PageFrame>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/settings-patch.ts b/apps/cline-hub/src/webview/src/components/views/settings/settings-patch.ts
new file mode 100644
index 0000000..4a02475
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/settings-patch.ts
@@ -0,0 +1,32 @@
+import type { ProviderConfigFieldPrimitive } from "@/lib/provider-schema";
+
+function assignSettingsPath(
+	target: Record<string, unknown>,
+	path: string,
+	value: ProviderConfigFieldPrimitive,
+) {
+	const segments = path.split(".").filter(Boolean);
+	if (segments.length === 0) return;
+	let cursor = target;
+	for (const segment of segments.slice(0, -1)) {
+		const existing = cursor[segment];
+		if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+			cursor[segment] = {};
+		}
+		cursor = cursor[segment] as Record<string, unknown>;
+	}
+	const last = segments.at(-1);
+	if (last) {
+		cursor[last] = value;
+	}
+}
+
+export function toSettingsPatch(
+	values: Record<string, ProviderConfigFieldPrimitive>,
+): Record<string, unknown> {
+	const settings: Record<string, unknown> = {};
+	for (const [path, value] of Object.entries(values)) {
+		assignSettingsPath(settings, path, value);
+	}
+	return settings;
+}
diff --git a/apps/cline-hub/src/webview/src/components/views/settings/settings-view.tsx b/apps/cline-hub/src/webview/src/components/views/settings/settings-view.tsx
new file mode 100644
index 0000000..413240b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/components/views/settings/settings-view.tsx
@@ -0,0 +1,691 @@
+import { ChevronDown, ChevronRight, X } from "lucide-react";
+import { useCallback, useEffect, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Switch } from "@/components/ui/switch";
+import { desktopClient } from "@/lib/desktop-client";
+import type {
+	Provider,
+	ProviderCatalogResponse,
+	ProviderModelsResponse,
+	ProviderSettingsUpdate,
+} from "@/lib/provider-schema";
+import {
+	type HubTheme,
+	readStoredHubTheme,
+	readSystemHubTheme,
+	setStoredHubTheme,
+} from "@/lib/theme";
+import { cn } from "@/lib/utils";
+import { PageFrame, PageHeader } from "../page-layout";
+import { AccountView } from "./account-view";
+import { AddProviderContent, type AddProviderPayload } from "./add-provider";
+import { ChannelsContent } from "./channels-view";
+import { McpServersContent } from "./mcp-view";
+import {
+	ProviderDetailContent,
+	ProviderListContent,
+} from "./provider-list-view";
+import { RoutineSchedulesContent } from "./routine-view";
+import { toSettingsPatch } from "./settings-patch";
+
+// -----------------------------------------------------------
+// Settings nav categories
+// -----------------------------------------------------------
+
+const navCategories = [
+	"General",
+	"Providers",
+	"MCP",
+	"Channels",
+	"Schedules",
+	"Account",
+] as const;
+
+export type SettingsSection = (typeof navCategories)[number];
+type GlobalSettingsResponse = {
+	telemetryOptOut: boolean;
+	autoUpdateEnabled: boolean;
+};
+
+const PROVIDER_CATALOG_CACHE_TTL_MS = 60_000;
+
+let providerCatalogCache: {
+	providers: Provider[];
+	fetchedAt: number;
+} | null = null;
+
+// -----------------------------------------------------------
+// Component
+// -----------------------------------------------------------
+
+export function SettingsView({
+	chrome = "full",
+	initialSection = "General",
+	onClose,
+	onNavigateSection,
+}: {
+	chrome?: "full" | "content";
+	initialSection?: SettingsSection;
+	onClose: () => void;
+	onNavigateSection?: (section: SettingsSection) => void;
+}) {
+	const [activeNav, setActiveNav] = useState<SettingsSection>(initialSection);
+	const [providersExpanded, setProvidersExpanded] = useState(true);
+	const [providers, setProviders] = useState<Provider[]>(
+		() => providerCatalogCache?.providers ?? [],
+	);
+	const [providersLoading, setProvidersLoading] = useState(
+		() => !providerCatalogCache,
+	);
+	const [providerCatalogError, setProviderCatalogError] = useState<
+		string | null
+	>(null);
+	const [modelsLoadingByProvider, setModelsLoadingByProvider] = useState<
+		Record<string, boolean>
+	>({});
+	const [modelsErrorByProvider, setModelsErrorByProvider] = useState<
+		Record<string, string | null>
+	>({});
+	const [oauthSigningProviderId, setOauthSigningProviderId] = useState<
+		string | null
+	>(null);
+	const [selectedProviderId, setSelectedProviderId] = useState<string | null>(
+		null,
+	);
+	const [addingProvider, setAddingProvider] = useState(false);
+
+	const setProvidersWithCache = useCallback(
+		(next: Provider[] | ((prev: Provider[]) => Provider[])) => {
+			setProviders((prev) => {
+				const resolved =
+					typeof next === "function"
+						? (next as (prev: Provider[]) => Provider[])(prev)
+						: next;
+				providerCatalogCache = {
+					providers: resolved,
+					fetchedAt: Date.now(),
+				};
+				return resolved;
+			});
+		},
+		[],
+	);
+
+	const loadProviderCatalog = useCallback(async () => {
+		const now = Date.now();
+		if (
+			providerCatalogCache &&
+			now - providerCatalogCache.fetchedAt < PROVIDER_CATALOG_CACHE_TTL_MS
+		) {
+			setProviders(providerCatalogCache.providers);
+			setProvidersLoading(false);
+			setProviderCatalogError(null);
+			return;
+		}
+
+		setProvidersLoading(true);
+		setProviderCatalogError(null);
+		try {
+			const payload = await desktopClient.invoke<ProviderCatalogResponse>(
+				"list_provider_catalog",
+			);
+			setProvidersWithCache(payload.providers);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setProviderCatalogError(message);
+			setProviders([]);
+		} finally {
+			setProvidersLoading(false);
+		}
+	}, [setProvidersWithCache]);
+
+	useEffect(() => {
+		if (activeNav !== "Providers") {
+			return;
+		}
+		const timeoutId = window.setTimeout(() => {
+			void loadProviderCatalog();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [activeNav, loadProviderCatalog]);
+
+	const persistProviderSettings = useCallback(
+		async (
+			id: string,
+			updates: {
+				enabled?: boolean;
+				apiKey?: string;
+				baseUrl?: string;
+				configValues?: ProviderSettingsUpdate["configValues"];
+			},
+		) => {
+			try {
+				await desktopClient.invoke("save_provider_settings", {
+					provider: id,
+					enabled: updates.enabled,
+					api_key: updates.apiKey,
+					base_url: updates.baseUrl,
+					settings: updates.configValues
+						? toSettingsPatch(updates.configValues)
+						: undefined,
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				window.alert(`Failed to save provider settings for ${id}: ${message}`);
+			}
+		},
+		[],
+	);
+
+	const toggleProvider = useCallback(
+		(id: string) => {
+			setProvidersWithCache((prev) =>
+				prev.map((p) => {
+					if (p.id !== id) {
+						return p;
+					}
+					const nextEnabled = !p.enabled;
+					void persistProviderSettings(id, { enabled: nextEnabled });
+					return { ...p, enabled: nextEnabled };
+				}),
+			);
+		},
+		[persistProviderSettings, setProvidersWithCache],
+	);
+
+	const updateProvider = useCallback(
+		(id: string, updates: ProviderSettingsUpdate) => {
+			setProvidersWithCache((prev) =>
+				prev.map((p) =>
+					p.id === id
+						? {
+								...p,
+								...updates,
+								configValues: updates.configValues
+									? {
+											...(p.configValues ?? {}),
+											...updates.configValues,
+										}
+									: p.configValues,
+							}
+						: p,
+				),
+			);
+			void persistProviderSettings(id, {
+				apiKey: updates.apiKey,
+				baseUrl: updates.baseUrl,
+				configValues: updates.configValues,
+			});
+		},
+		[persistProviderSettings, setProvidersWithCache],
+	);
+
+	const loadProviderModels = useCallback(
+		async (id: string) => {
+			setModelsLoadingByProvider((prev) => ({ ...prev, [id]: true }));
+			setModelsErrorByProvider((prev) => ({ ...prev, [id]: null }));
+			try {
+				const payload = await desktopClient.invoke<ProviderModelsResponse>(
+					"list_provider_models",
+					{
+						provider: id,
+					},
+				);
+				setProvidersWithCache((prev) =>
+					prev.map((provider) =>
+						provider.id === id
+							? {
+									...provider,
+									modelList: payload.models,
+									models: payload.models.length,
+								}
+							: provider,
+					),
+				);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setModelsErrorByProvider((prev) => ({ ...prev, [id]: message }));
+			} finally {
+				setModelsLoadingByProvider((prev) => ({ ...prev, [id]: false }));
+			}
+		},
+		[setProvidersWithCache],
+	);
+
+	const enabledProviders = providers.filter((p) => p.enabled);
+	const selectedProvider = selectedProviderId
+		? (providers.find((p) => p.id === selectedProviderId) ?? null)
+		: null;
+
+	const usesOAuth = (provider: Provider) =>
+		provider.capabilities?.includes("oauth") ?? false;
+
+	const runOAuthProviderLogin = async (id: string) => {
+		setOauthSigningProviderId(id);
+		try {
+			const result = await desktopClient.invoke<{
+				provider: string;
+				accessToken: string;
+			}>("run_provider_oauth_login", {
+				provider: id,
+			});
+			setProvidersWithCache((prev) =>
+				prev.map((provider) =>
+					provider.id === id
+						? {
+								...provider,
+								enabled: true,
+								oauthAccessTokenPresent: result.accessToken.trim().length > 0,
+							}
+						: provider,
+				),
+			);
+			setSelectedProviderId(id);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			window.alert(`Failed to sign in to ${id}: ${message}`);
+		} finally {
+			setOauthSigningProviderId(null);
+		}
+	};
+
+	const openProviderDetail = (id: string) => {
+		setActiveNav("Providers");
+		onNavigateSection?.("Providers");
+		setSelectedProviderId(id);
+	};
+
+	useEffect(() => {
+		if (!selectedProviderId) {
+			return;
+		}
+		const selected = providers.find(
+			(provider) => provider.id === selectedProviderId,
+		);
+		if (!selected || (selected.modelList?.length ?? 0) > 0) {
+			return;
+		}
+		const timeoutId = window.setTimeout(() => {
+			void loadProviderModels(selectedProviderId);
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [loadProviderModels, providers, selectedProviderId]);
+
+	const backToProviderList = () => {
+		onNavigateSection?.("Providers");
+		setSelectedProviderId(null);
+		setAddingProvider(false);
+	};
+
+	const saveNewProvider = useCallback(
+		async (payload: AddProviderPayload) => {
+			await desktopClient.invoke("add_provider", {
+				provider_id: payload.providerId,
+				name: payload.name,
+				base_url: payload.baseUrl,
+				api_key: payload.apiKey,
+				headers: payload.headers,
+				timeout_ms: payload.timeoutMs,
+				models: payload.models,
+				default_model_id: payload.defaultModelId,
+				models_source_url: payload.modelsSourceUrl,
+				capabilities: payload.capabilities,
+			});
+			await loadProviderCatalog();
+			setAddingProvider(false);
+			setSelectedProviderId(payload.providerId);
+		},
+		[loadProviderCatalog],
+	);
+
+	const openAddProvider = () => {
+		onNavigateSection?.("Providers");
+		setSelectedProviderId(null);
+		setAddingProvider(true);
+	};
+
+	const selectSection = (section: SettingsSection) => {
+		setActiveNav(section);
+		onNavigateSection?.(section);
+		setSelectedProviderId(null);
+		setAddingProvider(false);
+	};
+
+	const providerContent = addingProvider ? (
+		<AddProviderContent
+			existingProviderIds={providers.map((provider) => provider.id)}
+			onBack={backToProviderList}
+			onSave={saveNewProvider}
+		/>
+	) : providersLoading ? (
+		<div className="flex h-full items-center justify-center">
+			<p className="text-sm text-muted-foreground">Loading providers...</p>
+		</div>
+	) : providerCatalogError ? (
+		<div className="flex h-full items-center justify-center">
+			<p className="max-w-xl px-4 text-center text-sm text-destructive">
+				Failed to load providers: {providerCatalogError}
+			</p>
+		</div>
+	) : selectedProvider ? (
+		<div className="grid h-full grid-cols-[minmax(24rem,0.95fr)_minmax(28rem,1.05fr)] overflow-hidden max-[1100px]:grid-cols-1 max-[1100px]:grid-rows-[minmax(24rem,0.9fr)_minmax(26rem,1fr)]">
+			<ProviderListContent
+				onAddProvider={openAddProvider}
+				onConfigure={openProviderDetail}
+				onToggle={toggleProvider}
+				providers={providers}
+				selectedProviderId={selectedProvider.id}
+				variant="panel"
+			/>
+			<aside className="min-h-0 overflow-hidden border-l bg-background max-[1100px]:border-l-0 max-[1100px]:border-t">
+				<ProviderDetailContent
+					modelsError={modelsErrorByProvider[selectedProvider.id] ?? null}
+					modelsLoading={modelsLoadingByProvider[selectedProvider.id] ?? false}
+					oauthLoginPending={oauthSigningProviderId === selectedProvider.id}
+					onBack={backToProviderList}
+					onLoadModels={() => void loadProviderModels(selectedProvider.id)}
+					onOAuthLogin={
+						usesOAuth(selectedProvider)
+							? () => void runOAuthProviderLogin(selectedProvider.id)
+							: undefined
+					}
+					onUpdate={(updates) => updateProvider(selectedProvider.id, updates)}
+					provider={selectedProvider}
+					variant="panel"
+				/>
+			</aside>
+		</div>
+	) : (
+		<ProviderListContent
+			onAddProvider={openAddProvider}
+			onConfigure={openProviderDetail}
+			onToggle={toggleProvider}
+			providers={providers}
+		/>
+	);
+
+	const content =
+		activeNav === "Providers" ? (
+			providerContent
+		) : activeNav === "MCP" ? (
+			<McpServersContent />
+		) : activeNav === "Channels" ? (
+			<ChannelsContent />
+		) : activeNav === "Schedules" ? (
+			<RoutineSchedulesContent />
+		) : activeNav === "Account" ? (
+			<AccountView />
+		) : activeNav === "General" ? (
+			<GeneralSettingsContent />
+		) : (
+			<div className="flex h-full items-center justify-center">
+				<p className="text-sm text-muted-foreground">
+					{activeNav} settings coming soon.
+				</p>
+			</div>
+		);
+
+	if (chrome === "content") {
+		return (
+			<div className="h-full overflow-hidden bg-background">{content}</div>
+		);
+	}
+
+	return (
+		<div className="flex h-full flex-col overflow-hidden bg-background">
+			{/* Header bar */}
+			<div className="flex shrink-0 items-center justify-between border-b border-border px-6 py-3">
+				<h1 className="text-lg font-semibold text-foreground">Settings</h1>
+				<Button
+					aria-label="Close settings"
+					className="justify-start"
+					onClick={onClose}
+					variant="ghost"
+				>
+					<X className="size-3" />
+				</Button>
+			</div>
+
+			{/* Body */}
+			<div className="flex flex-1 overflow-hidden">
+				{/* Settings sidebar nav */}
+				<nav className="w-56 shrink-0 border-r border-border">
+					<ScrollArea className="h-full">
+						<div className="flex flex-col gap-0.5 p-3">
+							{navCategories.map((cat) => {
+								if (cat === "Providers") {
+									return (
+										<div key={cat}>
+											<Button
+												className={cn(
+													"flex w-full items-center justify-between rounded-md px-3 py-2 text-sm transition-colors",
+													activeNav === "Providers"
+														? "bg-accent text-accent-foreground font-medium"
+														: "text-muted-foreground hover:bg-accent/50 hover:text-foreground",
+												)}
+												onClick={() => {
+													selectSection("Providers");
+													setProvidersExpanded((p) => !p);
+												}}
+												variant="ghost"
+											>
+												<span>Providers</span>
+												{providersExpanded ? (
+													<ChevronDown className="size-3" />
+												) : (
+													<ChevronRight className="size-3" />
+												)}
+											</Button>
+											{providersExpanded && (
+												<div className="ml-3 mt-0.5 flex flex-col gap-0.5 border-l border-border pl-2">
+													{enabledProviders.map((prov) => (
+														<Button
+															className={cn(
+																"justify-start",
+																selectedProviderId === prov.id
+																	? "bg-accent/80 text-foreground"
+																	: "text-muted-foreground hover:text-foreground hover:bg-accent/30",
+															)}
+															disabled={oauthSigningProviderId === prov.id}
+															key={prov.id}
+															onClick={() => openProviderDetail(prov.id)}
+															variant="ghost"
+														>
+															<span className="truncate">{prov.name}</span>
+														</Button>
+													))}
+												</div>
+											)}
+										</div>
+									);
+								}
+								return (
+									<Button
+										className={cn(
+											"justify-start",
+											activeNav === cat && !selectedProviderId
+												? "bg-accent text-accent-foreground font-medium"
+												: "text-muted-foreground hover:bg-accent/50 hover:text-foreground",
+										)}
+										key={cat}
+										onClick={() => {
+											selectSection(cat);
+										}}
+										variant="ghost"
+									>
+										{cat}
+									</Button>
+								);
+							})}
+						</div>
+					</ScrollArea>
+				</nav>
+
+				{/* Content area */}
+				<div className="flex-1 overflow-hidden">{content}</div>
+			</div>
+		</div>
+	);
+}
+
+function GeneralSettingsContent() {
+	const [theme, setTheme] = useState<HubTheme>(() => {
+		if (typeof window === "undefined") return "light";
+		return readStoredHubTheme() ?? readSystemHubTheme();
+	});
+	const [telemetryOptOut, setTelemetryOptOut] = useState(false);
+	const [telemetryLoading, setTelemetryLoading] = useState(true);
+	const [telemetrySaving, setTelemetrySaving] = useState(false);
+	const [telemetryError, setTelemetryError] = useState<string | null>(null);
+	const [autoUpdateEnabled, setAutoUpdateEnabled] = useState(true);
+	const [autoUpdateLoading, setAutoUpdateLoading] = useState(true);
+	const [autoUpdateSaving, setAutoUpdateSaving] = useState(false);
+	const [autoUpdateError, setAutoUpdateError] = useState<string | null>(null);
+
+	const loadGlobalSettings = useCallback(async () => {
+		setTelemetryLoading(true);
+		setTelemetryError(null);
+		setAutoUpdateLoading(true);
+		setAutoUpdateError(null);
+		try {
+			const settings = await desktopClient.invoke<GlobalSettingsResponse>(
+				"get_global_settings",
+			);
+			setTelemetryOptOut(settings.telemetryOptOut);
+			setAutoUpdateEnabled(settings.autoUpdateEnabled);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setTelemetryError(message);
+			setAutoUpdateError(message);
+		} finally {
+			setTelemetryLoading(false);
+			setAutoUpdateLoading(false);
+		}
+	}, []);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void loadGlobalSettings();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [loadGlobalSettings]);
+
+	const updateTelemetryOptOut = async (nextValue: boolean) => {
+		const previousValue = telemetryOptOut;
+		setTelemetryOptOut(nextValue);
+		setTelemetrySaving(true);
+		setTelemetryError(null);
+		try {
+			const settings = await desktopClient.invoke<GlobalSettingsResponse>(
+				"set_telemetry_opt_out",
+				{
+					telemetry_opt_out: nextValue,
+				},
+			);
+			setTelemetryOptOut(settings.telemetryOptOut);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setTelemetryOptOut(previousValue);
+			setTelemetryError(message);
+		} finally {
+			setTelemetrySaving(false);
+		}
+	};
+
+	const updateAutoUpdateEnabled = async (nextValue: boolean) => {
+		const previousValue = autoUpdateEnabled;
+		setAutoUpdateEnabled(nextValue);
+		setAutoUpdateSaving(true);
+		setAutoUpdateError(null);
+		try {
+			const settings = await desktopClient.invoke<GlobalSettingsResponse>(
+				"set_auto_update_enabled",
+				{
+					auto_update_enabled: nextValue,
+				},
+			);
+			setAutoUpdateEnabled(settings.autoUpdateEnabled);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setAutoUpdateEnabled(previousValue);
+			setAutoUpdateError(message);
+		} finally {
+			setAutoUpdateSaving(false);
+		}
+	};
+
+	const updateTheme = (darkModeEnabled: boolean) => {
+		const nextTheme = darkModeEnabled ? "dark" : "light";
+		setTheme(setStoredHubTheme(nextTheme));
+		window.dispatchEvent(new Event("cline-hub-theme-change"));
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description="Manage Hub preferences for this browser and CLI environment."
+				title="Settings"
+			/>
+			<section className="max-w-[86rem]">
+				<div className="flex min-h-20 items-center justify-between gap-5 border-b max-[720px]:flex-col max-[720px]:items-stretch max-[720px]:py-4">
+					<div>
+						<p className="text-[17px] font-semibold text-foreground">
+							Dark mode
+						</p>
+						<p className="mt-1 text-[15px] text-muted-foreground">
+							Keep the Hub interface in dark mode on this browser.
+						</p>
+					</div>
+					<Switch
+						aria-label="Dark mode"
+						checked={theme === "dark"}
+						onCheckedChange={updateTheme}
+					/>
+				</div>
+				<div className="flex min-h-20 items-center justify-between gap-5 border-b max-[720px]:flex-col max-[720px]:items-stretch max-[720px]:py-4">
+					<div>
+						<p className="text-[17px] font-semibold text-foreground">
+							Auto update
+						</p>
+						<p className="mt-1 text-[15px] text-muted-foreground">
+							Automatically install CLI updates on startup.
+						</p>
+						{autoUpdateError ? (
+							<p className="mt-2 text-xs text-destructive">
+								Failed to update auto update setting: {autoUpdateError}
+							</p>
+						) : null}
+					</div>
+					<Switch
+						aria-label="Auto update"
+						checked={autoUpdateEnabled}
+						disabled={autoUpdateLoading || autoUpdateSaving}
+						onCheckedChange={(checked) => void updateAutoUpdateEnabled(checked)}
+					/>
+				</div>
+				<div className="flex min-h-20 items-center justify-between gap-5 border-b max-[720px]:flex-col max-[720px]:items-stretch max-[720px]:py-4">
+					<div>
+						<p className="text-[17px] font-semibold text-foreground">
+							Telemetry
+						</p>
+						<p className="mt-1 text-[15px] text-muted-foreground">
+							Enable error and usage report to help us improve Cline.
+						</p>
+						{telemetryError ? (
+							<p className="mt-2 text-xs text-destructive">
+								Failed to update telemetry setting: {telemetryError}
+							</p>
+						) : null}
+					</div>
+					<Switch
+						aria-label="Telemetry"
+						checked={!telemetryOptOut} // If opt-out is true, the switch should be off (unchecked)
+						disabled={telemetryLoading || telemetrySaving}
+						onCheckedChange={(checked) => void updateTelemetryOptOut(!checked)}
+					/>
+				</div>
+			</section>
+		</PageFrame>
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/index.css b/apps/cline-hub/src/webview/src/index.css
new file mode 100644
index 0000000..a8efd2c
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/index.css
@@ -0,0 +1,231 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+@import "@fontsource-variable/schibsted-grotesk";
+
+@custom-variant dark (&:is(.dark *));
+
+:root {
+	--background: oklch(1 0 0);
+	--foreground: oklch(0.18 0.008 255);
+	--card: oklch(1 0 0);
+	--card-foreground: oklch(0.18 0.008 255);
+	--popover: oklch(1 0 0);
+	--popover-foreground: oklch(0.145 0 0);
+	--primary: oklch(0.205 0 0);
+	--primary-foreground: oklch(0.985 0 0);
+	--secondary: oklch(0.97 0 0);
+	--secondary-foreground: oklch(0.205 0 0);
+	--muted: oklch(0.974 0.003 270);
+	--muted-foreground: oklch(0.52 0.014 270);
+	--accent: oklch(0.94 0.004 270);
+	--accent-foreground: oklch(0.18 0.008 255);
+	--destructive: oklch(0.577 0.245 27.325);
+	--destructive-foreground: oklch(0.93 0 0);
+	--border: oklch(0.92 0.005 270);
+	--input: oklch(0.9 0.006 270);
+	--ring: oklch(0.708 0 0);
+	--chart-1: oklch(0.809 0.105 251.813);
+	--chart-2: oklch(0.623 0.214 259.815);
+	--chart-3: oklch(0.546 0.245 262.881);
+	--chart-4: oklch(0.488 0.243 264.376);
+	--chart-5: oklch(0.424 0.199 265.638);
+	--radius: 0.625rem;
+	--sidebar: oklch(0.977 0.004 270);
+	--sidebar-foreground: oklch(0.18 0.008 255);
+	--sidebar-primary: oklch(0.205 0 0);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.928 0.006 270);
+	--sidebar-accent-foreground: oklch(0.18 0.008 255);
+	--sidebar-border: oklch(0.92 0.005 270);
+	--sidebar-ring: oklch(0.708 0 0);
+}
+
+@theme inline {
+	--font-sans: "Schibsted Grotesk Variable", sans-serif;
+	--font-mono:
+		ui-monospace, "SFMono-Regular", Menlo, Consolas, "Liberation Mono",
+		monospace;
+	--color-background: var(--background);
+	--color-foreground: var(--foreground);
+	--color-card: var(--card);
+	--color-card-foreground: var(--card-foreground);
+	--color-popover: var(--popover);
+	--color-popover-foreground: var(--popover-foreground);
+	--color-primary: var(--primary);
+	--color-primary-foreground: var(--primary-foreground);
+	--color-secondary: var(--secondary);
+	--color-secondary-foreground: var(--secondary-foreground);
+	--color-muted: var(--muted);
+	--color-muted-foreground: var(--muted-foreground);
+	--color-accent: var(--accent);
+	--color-accent-foreground: var(--accent-foreground);
+	--color-destructive: var(--destructive);
+	--color-destructive-foreground: var(--destructive-foreground);
+	--color-border: var(--border);
+	--color-input: var(--input);
+	--color-ring: var(--ring);
+	--color-chart-1: var(--chart-1);
+	--color-chart-2: var(--chart-2);
+	--color-chart-3: var(--chart-3);
+	--color-chart-4: var(--chart-4);
+	--color-chart-5: var(--chart-5);
+	--radius-sm: calc(var(--radius) - 4px);
+	--radius-md: calc(var(--radius) - 2px);
+	--radius-lg: var(--radius);
+	--radius-xl: calc(var(--radius) + 4px);
+	--color-sidebar: var(--sidebar);
+	--color-sidebar-foreground: var(--sidebar-foreground);
+	--color-sidebar-primary: var(--sidebar-primary);
+	--color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+	--color-sidebar-accent: var(--sidebar-accent);
+	--color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+	--color-sidebar-border: var(--sidebar-border);
+	--color-sidebar-ring: var(--sidebar-ring);
+	--radius-2xl: calc(var(--radius) * 1.8);
+	--radius-3xl: calc(var(--radius) * 2.2);
+	--radius-4xl: calc(var(--radius) * 2.6);
+}
+
+@layer base {
+	* {
+		@apply border-border outline-ring/50;
+	}
+	body {
+		@apply bg-background text-foreground;
+		font-optical-sizing: auto;
+	}
+	html {
+		@apply font-sans;
+	}
+	a[href],
+	button:not(:disabled),
+	[role="button"]:not([aria-disabled="true"]),
+	summary,
+	input[type="button"]:not(:disabled),
+	input[type="checkbox"]:not(:disabled),
+	input[type="radio"]:not(:disabled),
+	input[type="reset"]:not(:disabled),
+	input[type="submit"]:not(:disabled),
+	label[for],
+	select:not(:disabled) {
+		cursor: pointer;
+	}
+	button:disabled,
+	[aria-disabled="true"],
+	input:disabled,
+	select:disabled,
+	textarea:disabled {
+		cursor: not-allowed;
+	}
+}
+
+:is(
+		[role="menuitem"],
+		[role="menuitemcheckbox"],
+		[role="menuitemradio"],
+		[role="option"],
+		[role="tab"],
+		[role="switch"],
+		[role="checkbox"],
+		[role="radio"],
+		[data-slot="switch"],
+		[data-slot="checkbox"],
+		[data-slot="radio-group-item"],
+		[data-slot="tabs-trigger"],
+		[data-slot="dropdown-menu-trigger"],
+		[data-slot="dropdown-menu-item"],
+		[data-slot="dropdown-menu-checkbox-item"],
+		[data-slot="dropdown-menu-radio-item"],
+		[data-slot="dropdown-menu-sub-trigger"],
+		[data-slot="menubar-trigger"],
+		[data-slot="menubar-item"],
+		[data-slot="menubar-checkbox-item"],
+		[data-slot="menubar-radio-item"],
+		[data-slot="menubar-sub-trigger"],
+		[data-slot="select-trigger"],
+		[data-slot="select-item"],
+		[data-slot="select-scroll-up-button"],
+		[data-slot="select-scroll-down-button"],
+		[data-slot="combobox-trigger"],
+		[data-slot="combobox-clear"],
+		[data-slot="combobox-item"],
+		[data-slot="combobox-chip-remove"],
+		[data-slot="command-item"],
+		[data-slot="accordion-trigger"],
+		[data-slot="collapsible-trigger"],
+		[data-slot="dialog-trigger"],
+		[data-slot="dialog-close"],
+		[data-slot="alert-dialog-trigger"],
+		[data-slot="alert-dialog-action"],
+		[data-slot="alert-dialog-cancel"],
+		[data-slot="popover-trigger"],
+		[data-slot="hover-card-trigger"],
+		[data-slot="tooltip-trigger"]
+	):not(:disabled):not([aria-disabled="true"]):not([data-disabled]):not(
+		[data-disabled="true"]
+	) {
+	cursor: pointer;
+}
+
+[data-disabled],
+[data-disabled="true"] {
+	cursor: not-allowed;
+}
+
+::-webkit-scrollbar {
+	width: 6px;
+	height: 6px;
+}
+
+::-webkit-scrollbar-track {
+	background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+	background: oklch(0.82 0.006 270);
+	border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+	background: oklch(0.72 0.01 270);
+}
+
+/* Selection color */
+::selection {
+	background: oklch(0.75 0.12 165 / 0.25);
+}
+
+.dark {
+	--background: oklch(0.145 0 0);
+	--foreground: oklch(0.985 0 0);
+	--card: oklch(0.205 0 0);
+	--card-foreground: oklch(0.985 0 0);
+	--popover: oklch(0.205 0 0);
+	--popover-foreground: oklch(0.985 0 0);
+	--primary: oklch(0.922 0 0);
+	--primary-foreground: oklch(0.205 0 0);
+	--secondary: oklch(0.269 0 0);
+	--secondary-foreground: oklch(0.985 0 0);
+	--muted: oklch(0.269 0 0);
+	--muted-foreground: oklch(0.708 0 0);
+	--accent: oklch(0.269 0 0);
+	--accent-foreground: oklch(0.985 0 0);
+	--destructive: oklch(0.704 0.191 22.216);
+	--border: oklch(1 0 0 / 10%);
+	--input: oklch(1 0 0 / 15%);
+	--ring: oklch(0.556 0 0);
+	--chart-1: oklch(0.809 0.105 251.813);
+	--chart-2: oklch(0.623 0.214 259.815);
+	--chart-3: oklch(0.546 0.245 262.881);
+	--chart-4: oklch(0.488 0.243 264.376);
+	--chart-5: oklch(0.424 0.199 265.638);
+	--sidebar: oklch(0.205 0 0);
+	--sidebar-foreground: oklch(0.985 0 0);
+	--sidebar-primary: oklch(0.488 0.243 264.376);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.269 0 0);
+	--sidebar-accent-foreground: oklch(0.985 0 0);
+	--sidebar-border: oklch(1 0 0 / 10%);
+	--sidebar-ring: oklch(0.556 0 0);
+}
diff --git a/apps/cline-hub/src/webview/src/lib/desktop-client.test.ts b/apps/cline-hub/src/webview/src/lib/desktop-client.test.ts
new file mode 100644
index 0000000..db15e9b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/desktop-client.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from "vitest";
+import type { WebviewInboundMessage } from "../../../webview-protocol";
+import { HubDesktopClient, isBrowserTransportFailure } from "./desktop-client";
+
+function createClient() {
+	const postToHost = vi.fn<(message: WebviewInboundMessage) => void>();
+	const client = new HubDesktopClient({ postToHost, listen: false });
+	return { client, postToHost };
+}
+
+function lastDesktopCommand(postToHost: ReturnType<typeof vi.fn>) {
+	const message = postToHost.mock.lastCall?.[0] as
+		| Extract<WebviewInboundMessage, { type: "desktopCommand" }>
+		| undefined;
+	if (message?.type !== "desktopCommand") {
+		throw new Error("Expected a desktop command to be posted");
+	}
+	return message;
+}
+
+describe("HubDesktopClient", () => {
+	it("does not reject pending desktop commands for unrelated hub errors", async () => {
+		const { client, postToHost } = createClient();
+		const pending = client.invoke<{ installedKeys: string[] }>(
+			"list_marketplace_installed_entries",
+		);
+		const command = lastDesktopCommand(postToHost);
+
+		client.handleMessage({
+			data: { type: "error", text: "Failed to restore previous session." },
+		});
+		client.handleMessage({
+			data: {
+				type: "desktopCommandResult",
+				id: command.id,
+				ok: true,
+				result: { installedKeys: ["plugin:goal"] },
+			},
+		});
+
+		await expect(pending).resolves.toEqual({ installedKeys: ["plugin:goal"] });
+	});
+
+	it("rejects pending desktop commands for browser transport failures", async () => {
+		const { client } = createClient();
+		const pending = client.invoke("list_marketplace_installed_entries");
+
+		client.handleMessage({
+			data: { type: "status", text: "Disconnected from the Cline Hub server." },
+		});
+
+		await expect(pending).rejects.toThrow(
+			"Disconnected from the Cline Hub server.",
+		);
+	});
+
+	it("only treats exact browser lifecycle messages as transport failures", () => {
+		expect(
+			isBrowserTransportFailure({
+				type: "error",
+				text: "Failed to connect to the Cline Hub server.",
+			}),
+		).toBe(true);
+		expect(
+			isBrowserTransportFailure({
+				type: "error",
+				text: "Failed to restore previous session.",
+			}),
+		).toBe(false);
+	});
+});
diff --git a/apps/cline-hub/src/webview/src/lib/desktop-client.ts b/apps/cline-hub/src/webview/src/lib/desktop-client.ts
new file mode 100644
index 0000000..fc52d9b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/desktop-client.ts
@@ -0,0 +1,105 @@
+"use client";
+
+import type { WebviewOutboundMessage } from "../../../webview-protocol";
+import { postToHost } from "../vscode";
+
+type PostToHost = typeof postToHost;
+
+type PendingRequest = {
+	command: string;
+	resolve: (value: unknown) => void;
+	reject: (error: Error) => void;
+	timeoutId: ReturnType<typeof setTimeout>;
+};
+
+const REQUEST_TIMEOUT_MS = 120_000;
+const BROWSER_TRANSPORT_FAILURE_MESSAGES = new Set([
+	"Disconnected from the Cline Hub server.",
+	"Failed to connect to the Cline Hub server.",
+	"Received an invalid message from the Cline Hub server.",
+]);
+
+export function isBrowserTransportFailure(
+	message: WebviewOutboundMessage,
+): boolean {
+	if (message.type !== "status" && message.type !== "error") {
+		return false;
+	}
+	return BROWSER_TRANSPORT_FAILURE_MESSAGES.has(message.text);
+}
+
+export class HubDesktopClient {
+	private requestCounter = 0;
+	private readonly pending = new Map<string, PendingRequest>();
+	private readonly postToHost: PostToHost;
+
+	constructor(options: { postToHost?: PostToHost; listen?: boolean } = {}) {
+		this.postToHost = options.postToHost ?? postToHost;
+		if ((options.listen ?? true) && typeof window !== "undefined") {
+			window.addEventListener("message", (event) => {
+				this.handleMessage(event as MessageEvent<WebviewOutboundMessage>);
+			});
+		}
+	}
+
+	handleMessage(event: Pick<MessageEvent<WebviewOutboundMessage>, "data">) {
+		const message = event.data;
+		if (
+			message &&
+			typeof message === "object" &&
+			(message.type === "status" || message.type === "error")
+		) {
+			if (isBrowserTransportFailure(message) && this.pending.size > 0) {
+				const error = new Error(message.text);
+				for (const pending of this.pending.values()) {
+					clearTimeout(pending.timeoutId);
+					pending.reject(error);
+				}
+				this.pending.clear();
+			}
+			return;
+		}
+		if (
+			!message ||
+			typeof message !== "object" ||
+			message.type !== "desktopCommandResult"
+		) {
+			return;
+		}
+
+		const pending = this.pending.get(message.id);
+		if (!pending) {
+			return;
+		}
+		clearTimeout(pending.timeoutId);
+		this.pending.delete(message.id);
+		if (message.ok) {
+			pending.resolve(message.result);
+			return;
+		}
+		pending.reject(new Error(message.error));
+	}
+
+	async invoke<T>(
+		command: string,
+		args?: Record<string, unknown>,
+		options?: { timeoutMs?: number },
+	): Promise<T> {
+		const id = `desktop_${Date.now()}_${this.requestCounter++}`;
+		return await new Promise<T>((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`Timed out waiting for desktop command: ${command}`));
+			}, options?.timeoutMs ?? REQUEST_TIMEOUT_MS);
+			this.pending.set(id, {
+				command,
+				resolve: (value) => resolve(value as T),
+				reject,
+				timeoutId,
+			});
+			this.postToHost({ type: "desktopCommand", id, command, args });
+		});
+	}
+}
+
+export const desktopClient = new HubDesktopClient();
diff --git a/apps/cline-hub/src/webview/src/lib/marketplace.ts b/apps/cline-hub/src/webview/src/lib/marketplace.ts
new file mode 100644
index 0000000..8f074d2
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/marketplace.ts
@@ -0,0 +1,194 @@
+export type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
+
+export type MarketplaceTag = {
+	id: string;
+	label: string;
+	count: number;
+};
+
+export type MarketplaceEnvVar = {
+	name: string;
+	required?: boolean;
+	description?: string;
+	url?: string;
+};
+
+export type MarketplaceEntry = {
+	id: string;
+	type: MarketplacePrimitiveType;
+	name: string;
+	featured?: boolean;
+	tagline: string;
+	description: string;
+	tags: string[];
+	install: {
+		args: string[];
+		env?: MarketplaceEnvVar[];
+		notes?: string;
+		command: string;
+	};
+};
+
+export type MarketplaceCatalog = {
+	version: number;
+	generatedAt?: string;
+	baseUrl?: string;
+	counts: {
+		total: number;
+		plugins: number;
+		skills: number;
+		mcps: number;
+	};
+	tags: MarketplaceTag[];
+	entries: MarketplaceEntry[];
+};
+
+const MARKETPLACE_CATALOG_URL = "/api/marketplace/catalog";
+
+const EMPTY_CATALOG: MarketplaceCatalog = {
+	version: 1,
+	counts: {
+		total: 0,
+		plugins: 0,
+		skills: 0,
+		mcps: 0,
+	},
+	tags: [],
+	entries: [],
+};
+
+function isPrimitiveType(value: unknown): value is MarketplacePrimitiveType {
+	return value === "mcp" || value === "skill" || value === "plugin";
+}
+
+function toStringArray(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+function parseCount(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function parseEnv(value: unknown): MarketplaceEnvVar[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const env = value
+		.map((item): MarketplaceEnvVar | null => {
+			if (!item || typeof item !== "object") return null;
+			const candidate = item as Record<string, unknown>;
+			if (typeof candidate.name !== "string") return null;
+			const parsed: MarketplaceEnvVar = {
+				name: candidate.name,
+			};
+			if (typeof candidate.required === "boolean") {
+				parsed.required = candidate.required;
+			}
+			if (typeof candidate.description === "string") {
+				parsed.description = candidate.description;
+			}
+			if (typeof candidate.url === "string") {
+				parsed.url = candidate.url;
+			}
+			return parsed;
+		})
+		.filter((item): item is MarketplaceEnvVar => item !== null);
+	return env.length > 0 ? env : undefined;
+}
+
+export async function fetchMarketplaceCatalog(): Promise<MarketplaceCatalog> {
+	const response = await fetch(MARKETPLACE_CATALOG_URL, {
+		headers: { Accept: "application/json" },
+	});
+	if (!response.ok) {
+		throw new Error(`Failed to fetch marketplace: ${response.status}`);
+	}
+	const data = await response.json();
+	const baseUrl = typeof data?.baseUrl === "string" ? data.baseUrl : undefined;
+	const rawCounts =
+		typeof data?.counts === "object" && data.counts !== null ? data.counts : {};
+
+	const tags: MarketplaceTag[] = Array.isArray(data?.tags)
+		? data.tags
+				.map((tag: unknown) => {
+					if (!tag || typeof tag !== "object") return null;
+					const candidate = tag as Record<string, unknown>;
+					if (
+						typeof candidate.id !== "string" ||
+						typeof candidate.label !== "string"
+					) {
+						return null;
+					}
+					return {
+						id: candidate.id,
+						label: candidate.label,
+						count: parseCount(candidate.count),
+					};
+				})
+				.filter(
+					(tag: MarketplaceTag | null): tag is MarketplaceTag => tag !== null,
+				)
+		: [];
+
+	const entries: MarketplaceEntry[] = Array.isArray(data?.entries)
+		? data.entries
+				.map((entry: unknown) => {
+					if (!entry || typeof entry !== "object") return null;
+					const candidate = entry as Record<string, unknown>;
+					const install =
+						typeof candidate.install === "object" && candidate.install !== null
+							? (candidate.install as Record<string, unknown>)
+							: {};
+					if (
+						typeof candidate.id !== "string" ||
+						!isPrimitiveType(candidate.type) ||
+						typeof candidate.name !== "string" ||
+						typeof candidate.tagline !== "string" ||
+						typeof candidate.description !== "string" ||
+						typeof install.command !== "string"
+					) {
+						return null;
+					}
+					return {
+						id: candidate.id,
+						type: candidate.type,
+						name: candidate.name,
+						featured:
+							typeof candidate.featured === "boolean"
+								? candidate.featured
+								: undefined,
+						tagline: candidate.tagline,
+						description: candidate.description,
+						tags: toStringArray(candidate.tags),
+						install: {
+							args: toStringArray(install.args),
+							command: install.command,
+							env: parseEnv(install.env),
+							notes:
+								typeof install.notes === "string" ? install.notes : undefined,
+						},
+					};
+				})
+				.filter(
+					(entry: MarketplaceEntry | null): entry is MarketplaceEntry =>
+						entry !== null && entry.install.args.length > 0,
+				)
+		: [];
+
+	return {
+		version: parseCount(data?.version) || EMPTY_CATALOG.version,
+		generatedAt:
+			typeof data?.generatedAt === "string" ? data.generatedAt : undefined,
+		baseUrl,
+		counts: {
+			total: parseCount(rawCounts.total) || entries.length,
+			plugins: parseCount(rawCounts.plugins),
+			skills: parseCount(rawCounts.skills),
+			mcps: parseCount(rawCounts.mcps),
+		},
+		tags,
+		entries,
+	};
+}
+
+export { EMPTY_CATALOG, MARKETPLACE_CATALOG_URL };
diff --git a/apps/cline-hub/src/webview/src/lib/model-selection.ts b/apps/cline-hub/src/webview/src/lib/model-selection.ts
new file mode 100644
index 0000000..1218433
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/model-selection.ts
@@ -0,0 +1,85 @@
+export const MODEL_SELECTION_STORAGE_KEY = "cline.code.model-selection.v1";
+
+export type ModelSelectionStorage = {
+	lastProvider: string;
+	lastModelByProvider: Record<string, string>;
+};
+
+function sanitizeStringRecord(value: unknown): Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return {};
+	}
+	return Object.fromEntries(
+		Object.entries(value).filter(
+			([key, entry]) =>
+				typeof key === "string" &&
+				typeof entry === "string" &&
+				entry.trim().length > 0,
+		),
+	);
+}
+
+export function parseModelSelectionStorage(
+	raw: string | null,
+): ModelSelectionStorage {
+	const empty: ModelSelectionStorage = {
+		lastProvider: "",
+		lastModelByProvider: {},
+	};
+	if (!raw) {
+		return empty;
+	}
+
+	try {
+		const parsed = JSON.parse(raw) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			return empty;
+		}
+
+		const shaped = parsed as {
+			lastProvider?: unknown;
+			lastModelByProvider?: unknown;
+		};
+
+		if ("lastProvider" in shaped || "lastModelByProvider" in shaped) {
+			return {
+				lastProvider:
+					typeof shaped.lastProvider === "string"
+						? shaped.lastProvider.trim()
+						: "",
+				lastModelByProvider: sanitizeStringRecord(shaped.lastModelByProvider),
+			};
+		}
+
+		return {
+			lastProvider: "",
+			lastModelByProvider: sanitizeStringRecord(parsed),
+		};
+	} catch {
+		return empty;
+	}
+}
+
+export function readModelSelectionStorageFromWindow(): ModelSelectionStorage {
+	if (typeof window === "undefined") {
+		return {
+			lastProvider: "",
+			lastModelByProvider: {},
+		};
+	}
+	return parseModelSelectionStorage(
+		window.localStorage.getItem(MODEL_SELECTION_STORAGE_KEY),
+	);
+}
+
+export function writeModelSelectionStorageToWindow(
+	value: ModelSelectionStorage,
+): void {
+	if (typeof window === "undefined") {
+		return;
+	}
+	window.localStorage.setItem(
+		MODEL_SELECTION_STORAGE_KEY,
+		JSON.stringify(value),
+	);
+}
diff --git a/apps/cline-hub/src/webview/src/lib/provider-id.ts b/apps/cline-hub/src/webview/src/lib/provider-id.ts
new file mode 100644
index 0000000..17c1104
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/provider-id.ts
@@ -0,0 +1,12 @@
+const PROVIDER_ID_ALIASES: Record<string, string> = {
+	openai: "openai-native",
+	google: "gemini",
+};
+
+export function normalizeProviderId(providerId: string): string {
+	const trimmed = providerId.trim();
+	if (!trimmed) {
+		return "";
+	}
+	return PROVIDER_ID_ALIASES[trimmed] ?? trimmed;
+}
diff --git a/apps/cline-hub/src/webview/src/lib/provider-model-catalog.ts b/apps/cline-hub/src/webview/src/lib/provider-model-catalog.ts
new file mode 100644
index 0000000..3041d1a
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/provider-model-catalog.ts
@@ -0,0 +1,68 @@
+"use client";
+
+import { desktopClient } from "@/lib/desktop-client";
+import type {
+	Provider,
+	ProviderCatalogResponse,
+	ProviderModel,
+	ProviderModelsResponse,
+} from "@/lib/provider-schema";
+
+export type ProviderModelCatalog = {
+	providers: Provider[];
+	enabledProviderIds: string[];
+	providerModels: Record<string, string[]>;
+	providerReasoningModels: Record<string, string[]>;
+};
+
+function toModelIds(models: ProviderModel[] | undefined): string[] {
+	return (models ?? []).map((model) => model.id);
+}
+
+function toReasoningModelIds(models: ProviderModel[] | undefined): string[] {
+	return (models ?? [])
+		.filter((model) => model.supportsReasoning)
+		.map((model) => model.id);
+}
+
+export function buildProviderModelCatalog(
+	providers: Provider[],
+): ProviderModelCatalog {
+	return {
+		providers,
+		enabledProviderIds: providers
+			.filter((provider) => provider.enabled)
+			.map((provider) => provider.id),
+		providerModels: Object.fromEntries(
+			providers.map((provider) => [
+				provider.id,
+				toModelIds(provider.modelList),
+			]),
+		),
+		providerReasoningModels: Object.fromEntries(
+			providers.map((provider) => [
+				provider.id,
+				toReasoningModelIds(provider.modelList),
+			]),
+		),
+	};
+}
+
+export async function loadProviderModelCatalog(): Promise<ProviderModelCatalog> {
+	const payload = await desktopClient.invoke<ProviderCatalogResponse>(
+		"list_provider_catalog",
+	);
+	return buildProviderModelCatalog(payload.providers ?? []);
+}
+
+export async function loadProviderModels(
+	providerId: string,
+): Promise<ProviderModel[]> {
+	const payload = await desktopClient.invoke<ProviderModelsResponse>(
+		"list_provider_models",
+		{
+			provider: providerId,
+		},
+	);
+	return payload.models ?? [];
+}
diff --git a/apps/cline-hub/src/webview/src/lib/provider-schema.ts b/apps/cline-hub/src/webview/src/lib/provider-schema.ts
new file mode 100644
index 0000000..495b74b
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/provider-schema.ts
@@ -0,0 +1,71 @@
+export interface ProviderModel {
+	id: string;
+	name: string;
+	supportsAttachments?: boolean;
+	supportsVision?: boolean;
+	supportsReasoning?: boolean;
+}
+
+export type ProviderConfigFieldType =
+	| "text"
+	| "password"
+	| "url"
+	| "number"
+	| "select"
+	| "boolean";
+
+export type ProviderConfigFieldPrimitive = string | number | boolean | null;
+
+export interface ProviderConfigFieldOption {
+	label: string;
+	value: Exclude<ProviderConfigFieldPrimitive, null>;
+}
+
+export interface ProviderConfigField {
+	path: string;
+	label: string;
+	type: ProviderConfigFieldType;
+	description?: string;
+	placeholder?: string;
+	required?: boolean;
+	secret?: boolean;
+	options?: ProviderConfigFieldOption[];
+	defaultValue?: ProviderConfigFieldPrimitive;
+}
+
+export interface Provider {
+	id: string;
+	name: string;
+	models: number | null;
+	color: string;
+	letter: string;
+	enabled: boolean;
+	apiKey?: string;
+	oauthAccessTokenPresent?: boolean;
+	baseUrl?: string;
+	docUrl?: string;
+	docLabel?: string;
+	defaultModelId?: string;
+	capabilities?: string[];
+	authDescription?: string;
+	baseUrlDescription?: string;
+	configFields?: ProviderConfigField[];
+	configValues?: Record<string, ProviderConfigFieldPrimitive>;
+	modelList?: ProviderModel[];
+}
+
+export interface ProviderSettingsUpdate {
+	apiKey?: string;
+	baseUrl?: string;
+	configValues?: Record<string, ProviderConfigFieldPrimitive>;
+}
+
+export interface ProviderCatalogResponse {
+	providers: Provider[];
+	settingsPath: string;
+}
+
+export interface ProviderModelsResponse {
+	providerId: string;
+	models: ProviderModel[];
+}
diff --git a/apps/cline-hub/src/webview/src/lib/theme.ts b/apps/cline-hub/src/webview/src/lib/theme.ts
new file mode 100644
index 0000000..5651baf
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/theme.ts
@@ -0,0 +1,30 @@
+export const HUB_THEME_STORAGE_KEY = "cline-hub-theme";
+
+export type HubTheme = "light" | "dark";
+
+export function readStoredHubTheme(): HubTheme | null {
+	const stored = window.localStorage.getItem(HUB_THEME_STORAGE_KEY);
+	return stored === "light" || stored === "dark" ? stored : null;
+}
+
+export function readSystemHubTheme(): HubTheme {
+	const kind = document.body.dataset.vscodeThemeKind;
+	return kind === "vscode-dark" || kind === "vscode-high-contrast"
+		? "dark"
+		: "light";
+}
+
+export function applyHubTheme(theme: HubTheme): HubTheme {
+	document.documentElement.classList.toggle("dark", theme === "dark");
+	document.documentElement.dataset.clineHubTheme = theme;
+	return theme;
+}
+
+export function syncHubTheme(): HubTheme {
+	return applyHubTheme(readStoredHubTheme() ?? readSystemHubTheme());
+}
+
+export function setStoredHubTheme(theme: HubTheme): HubTheme {
+	window.localStorage.setItem(HUB_THEME_STORAGE_KEY, theme);
+	return applyHubTheme(theme);
+}
diff --git a/apps/cline-hub/src/webview/src/lib/utils.ts b/apps/cline-hub/src/webview/src/lib/utils.ts
new file mode 100644
index 0000000..ac680b3
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/lib/utils.ts
@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}
diff --git a/apps/cline-hub/src/webview/src/main.tsx b/apps/cline-hub/src/webview/src/main.tsx
new file mode 100644
index 0000000..c81588a
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/main.tsx
@@ -0,0 +1,31 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import "./index.css";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import App from "./App.tsx";
+import { syncHubTheme } from "./lib/theme";
+
+window.addEventListener("cline-hub-theme-change", syncHubTheme);
+
+// Apply immediately
+syncHubTheme();
+
+// Re-apply whenever VS Code changes the theme attribute
+const observer = new MutationObserver(syncHubTheme);
+observer.observe(document.body, {
+	attributes: true,
+	attributeFilter: ["data-vscode-theme-kind"],
+});
+
+const root = document.getElementById("root");
+if (!root) {
+	throw new Error("Root element not found");
+}
+
+createRoot(root).render(
+	<StrictMode>
+		<TooltipProvider>
+			<App />
+		</TooltipProvider>
+	</StrictMode>,
+);
diff --git a/apps/cline-hub/src/webview/src/vscode.ts b/apps/cline-hub/src/webview/src/vscode.ts
new file mode 100644
index 0000000..7f2d53d
--- /dev/null
+++ b/apps/cline-hub/src/webview/src/vscode.ts
@@ -0,0 +1,130 @@
+import type {
+	WebviewInboundMessage,
+	WebviewOutboundMessage,
+} from "../../webview-protocol";
+
+type VsCodeApi = {
+	postMessage(message: WebviewInboundMessage): void;
+	getState(): unknown;
+	setState(state: unknown): void;
+};
+
+declare global {
+	interface Window {
+		acquireVsCodeApi?: () => VsCodeApi;
+	}
+}
+
+let cachedApi: VsCodeApi | undefined;
+let browserSocket: WebSocket | undefined;
+const pendingMessages: WebviewInboundMessage[] = [];
+const stateKey = "cline-hub-webview-state";
+
+function dispatchHostMessage(message: WebviewOutboundMessage): void {
+	window.dispatchEvent(new MessageEvent("message", { data: message }));
+}
+
+function readBrowserRoomSecret(): string | undefined {
+	const roomSecret = new URLSearchParams(window.location.search)
+		.get("roomSecret")
+		?.trim();
+	return roomSecret || undefined;
+}
+
+function createBrowserSocket(): WebSocket {
+	if (
+		browserSocket &&
+		(browserSocket.readyState === WebSocket.OPEN ||
+			browserSocket.readyState === WebSocket.CONNECTING)
+	) {
+		return browserSocket;
+	}
+
+	const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+	const params = new URLSearchParams();
+	const roomSecret = readBrowserRoomSecret();
+	if (roomSecret) {
+		params.set("roomSecret", roomSecret);
+	}
+	const query = params.toString();
+	const socketUrl = `${protocol}//${window.location.host}/browser${query ? `?${query}` : ""}`;
+	browserSocket = new WebSocket(socketUrl);
+	browserSocket.addEventListener("open", () => {
+		for (const message of pendingMessages.splice(0)) {
+			browserSocket?.send(JSON.stringify(message));
+		}
+	});
+	browserSocket.addEventListener("message", (event) => {
+		try {
+			const message = JSON.parse(String(event.data)) as WebviewOutboundMessage;
+			dispatchHostMessage(message);
+		} catch {
+			pendingMessages.splice(0);
+			dispatchHostMessage({
+				type: "error",
+				text: "Received an invalid message from the Cline Hub server.",
+			});
+		}
+	});
+	browserSocket.addEventListener("close", () => {
+		pendingMessages.splice(0);
+		dispatchHostMessage({
+			type: "status",
+			text: "Disconnected from the Cline Hub server.",
+		});
+	});
+	browserSocket.addEventListener("error", () => {
+		pendingMessages.splice(0);
+		dispatchHostMessage({
+			type: "error",
+			text: "Failed to connect to the Cline Hub server.",
+		});
+	});
+	return browserSocket;
+}
+
+function createBrowserApi(): VsCodeApi {
+	return {
+		postMessage(message) {
+			const socket = createBrowserSocket();
+			if (socket.readyState === WebSocket.OPEN) {
+				socket.send(JSON.stringify(message));
+				return;
+			}
+			pendingMessages.push(message);
+		},
+		getState() {
+			try {
+				const raw = window.localStorage.getItem(stateKey);
+				return raw ? JSON.parse(raw) : undefined;
+			} catch {
+				return undefined;
+			}
+		},
+		setState(state) {
+			try {
+				window.localStorage.setItem(stateKey, JSON.stringify(state ?? {}));
+			} catch {
+				// Browser persistence is best-effort.
+			}
+		},
+	};
+}
+
+export function getVsCodeApi(): VsCodeApi | undefined {
+	if (cachedApi) {
+		return cachedApi;
+	}
+	if (typeof window.acquireVsCodeApi === "function") {
+		cachedApi = window.acquireVsCodeApi();
+		return cachedApi;
+	}
+	cachedApi = createBrowserApi();
+	return cachedApi;
+}
+
+export function postToHost(message: WebviewInboundMessage): void {
+	getVsCodeApi()?.postMessage(message);
+}
+
+export type { WebviewOutboundMessage };
diff --git a/apps/cline-hub/src/webview/tsconfig.app.json b/apps/cline-hub/src/webview/tsconfig.app.json
new file mode 100644
index 0000000..82ffa16
--- /dev/null
+++ b/apps/cline-hub/src/webview/tsconfig.app.json
@@ -0,0 +1,31 @@
+{
+	"compilerOptions": {
+		"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+		"target": "ES2023",
+		"useDefineForClassFields": true,
+		"lib": ["ES2023", "DOM", "DOM.Iterable"],
+		"module": "ESNext",
+		"types": ["vite/client"],
+		"skipLibCheck": true,
+
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+		"jsx": "react-jsx",
+
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"erasableSyntaxOnly": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true,
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	},
+	"include": ["src"]
+}
diff --git a/apps/cline-hub/src/webview/tsconfig.json b/apps/cline-hub/src/webview/tsconfig.json
new file mode 100644
index 0000000..44233c0
--- /dev/null
+++ b/apps/cline-hub/src/webview/tsconfig.json
@@ -0,0 +1,12 @@
+{
+	"files": [],
+	"references": [
+		{ "path": "./tsconfig.app.json" },
+		{ "path": "./tsconfig.node.json" }
+	],
+	"compilerOptions": {
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	}
+}
diff --git a/apps/cline-hub/src/webview/tsconfig.node.json b/apps/cline-hub/src/webview/tsconfig.node.json
new file mode 100644
index 0000000..e75109e
--- /dev/null
+++ b/apps/cline-hub/src/webview/tsconfig.node.json
@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+		"target": "ES2023",
+		"lib": ["ES2023"],
+		"module": "ESNext",
+		"types": ["node"],
+		"skipLibCheck": true,
+
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"erasableSyntaxOnly": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true
+	},
+	"include": ["vite.config.ts"]
+}
diff --git a/apps/cline-hub/src/webview/vite.config.ts b/apps/cline-hub/src/webview/vite.config.ts
new file mode 100644
index 0000000..cc2b042
--- /dev/null
+++ b/apps/cline-hub/src/webview/vite.config.ts
@@ -0,0 +1,58 @@
+import path from "node:path";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react-swc";
+import { defineConfig } from "vite";
+
+const mermaidChunkGroups = [
+	{
+		name: "mermaid-parser",
+		maxSize: 450_000,
+		test: /node_modules[\\/](?:\.bun[\\/])?@mermaid-js[+]parser/,
+	},
+	{
+		name: "mermaid-langium",
+		test: /node_modules[\\/](?:\.bun[\\/])?langium/,
+	},
+	{
+		name: "mermaid-layout",
+		maxSize: 450_000,
+		test: /node_modules[\\/](?:\.bun[\\/])?(?:cytoscape|cytoscape-cose-bilkent|dagre|elkjs)/,
+	},
+	{
+		name: "mermaid-markup",
+		test: /node_modules[\\/](?:\.bun[\\/])?(?:katex|dompurify)/,
+	},
+];
+
+export default defineConfig({
+	plugins: [react(), tailwindcss()],
+	resolve: {
+		alias: {
+			"@": path.resolve(__dirname, "./src"),
+		},
+		dedupe: ["react", "react-dom"],
+	},
+	base: "./",
+	server: {
+		cors: true,
+		headers: {
+			"Access-Control-Allow-Origin": "*",
+		},
+		hmr: {
+			host: "localhost",
+		},
+	},
+	build: {
+		outDir: "../../dist/webview",
+		emptyOutDir: true,
+		cssMinify: "esbuild",
+		chunkSizeWarningLimit: 600,
+		rolldownOptions: {
+			output: {
+				codeSplitting: {
+					groups: mermaidChunkGroups,
+				},
+			},
+		},
+	},
+});
diff --git a/apps/cline-hub/tsconfig.json b/apps/cline-hub/tsconfig.json
new file mode 100644
index 0000000..db53c5a
--- /dev/null
+++ b/apps/cline-hub/tsconfig.json
@@ -0,0 +1,21 @@
+{
+	"extends": "../../sdk/packages/tsconfig.base.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"types": ["bun", "node"],
+		"paths": {
+			"@cline/core": ["../../sdk/packages/core/src/index.ts"],
+			"@cline/core/*": [
+				"../../sdk/packages/core/src/*",
+				"../../sdk/packages/core/src/*/index.ts"
+			],
+			"@cline/shared": ["../../sdk/packages/shared/src/index.ts"],
+			"@cline/shared/*": [
+				"../../sdk/packages/shared/src/*",
+				"../../sdk/packages/shared/src/*/index.ts"
+			]
+		}
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["src/webview/**"]
+}
diff --git a/apps/cline-hub/vitest.config.ts b/apps/cline-hub/vitest.config.ts
new file mode 100644
index 0000000..ff62bef
--- /dev/null
+++ b/apps/cline-hub/vitest.config.ts
@@ -0,0 +1,33 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+const rootDir = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+	root: rootDir,
+	resolve: {
+		alias: [
+			{
+				find: /^@cline\/core$/,
+				replacement: resolve(rootDir, "../../sdk/packages/core/src/index.ts"),
+			},
+			{
+				find: /^@cline\/core\/(.+)$/,
+				replacement: resolve(rootDir, "../../sdk/packages/core/src/$1"),
+			},
+			{
+				find: /^@cline\/shared$/,
+				replacement: resolve(rootDir, "../../sdk/packages/shared/src/index.ts"),
+			},
+			{
+				find: /^@cline\/shared\/(.+)$/,
+				replacement: resolve(rootDir, "../../sdk/packages/shared/src/$1"),
+			},
+		],
+	},
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts"],
+	},
+});
diff --git a/apps/examples/README.md b/apps/examples/README.md
new file mode 100644
index 0000000..8eb6033
--- /dev/null
+++ b/apps/examples/README.md
@@ -0,0 +1,68 @@
+# Cline SDK Examples
+
+Learn how to build with the Cline SDK through working examples, ordered from simple to complex.
+
+## SDK Skill
+If you use a coding agent (Claude Code, Codex, Cline, etc.), install the [Cline SDK skill](https://github.com/cline/sdk-skill) to give your agent context on the SDK's APIs and best practices to help you build with the Cline SDK.
+
+```bash
+npx skills add cline/sdk-skill
+```
+
+Prompt it to scaffold agents, create custom tools, wire up plugins, configure providers, and more.
+
+## Getting started
+
+All examples live in this directory. Each is a standalone project with its own `package.json` and README. To run any example:
+
+```bash
+cd apps/examples/<example-name>
+bun install
+bun run build:sdk
+export CLINE_API_KEY="cline_..."
+bun dev
+```
+
+Requires Node.js 22+.
+
+## Examples
+
+### Beginner
+
+| Example | Description | Concepts |
+|---------|-------------|----------|
+| [quickstart](./quickstart) | Send one prompt, stream the response. ~15 lines of code. | `Agent`, `subscribe`, `run()` |
+| [cli-agent](./cli-agent) | Interactive terminal chat with a shell tool. | `createTool`, multi-turn `run()`/`continue()`, streaming |
+| [cline-core-cli-agent](./cline-core-cli-agent) | Interactive terminal chat powered by ClineCore. | `ClineCore.create()`, `cline.start()`, `cline.send()`, built-in tools, streaming |
+
+### Intermediate
+
+| Example | Description | Concepts |
+|---------|-------------|----------|
+| [code-review-bot](./code-review-bot) | AI code reviewer that reads git diffs and produces structured comments. | Multiple tools, `completesRun` lifecycle, `systemPrompt`, zod schemas |
+| [multi-agent](./multi-agent) | Web app that fans out to three specialist agents in parallel, streams results via SSE, then synthesizes a unified answer. | Concurrent agents, `Promise.all`, per-agent `subscribe()`, SSE streaming, agent composition |
+
+### Advanced
+
+| Example | Description | Concepts |
+|---------|-------------|----------|
+| [desktop-app](./desktop-app) | Full Tauri + Next.js desktop app for running and inspecting chat sessions. | Sidecar runtime, websocket transport, session persistence |
+| [menubar](./menubar) | macOS menu bar app with Tauri. | Native app integration, compact UI |
+| [vscode](./vscode) | VS Code extension with chat panel. | Extension API, webview, workspace context |
+
+## SDK packages
+
+When building your own app, install the public SDK package:
+
+```bash
+npm add @cline/sdk
+```
+
+`@cline/sdk` re-exports everything from `@cline/core`. You only need `@cline/agents` or `@cline/llms` if you want lower-level control over the agent runtime or model gateway directly.
+
+## Learn more
+
+- [SDK package docs](../../sdk/packages/README.md)
+- [Architecture guide](../../ARCHITECTURE.md)
+- [Plugin examples](../../examples/plugins) - extend the Cline SDK and CLI with custom tools and event hooks
+- [Hook examples](../../examples/hooks) - lifecycle hooks for logging, blocking, and injection for Cline SDK and CLI
diff --git a/apps/examples/cli-agent/README.md b/apps/examples/cli-agent/README.md
new file mode 100644
index 0000000..4b0667c
--- /dev/null
+++ b/apps/examples/cli-agent/README.md
@@ -0,0 +1,44 @@
+# CLI Agent
+
+An interactive terminal chat agent with streaming output and a shell tool. Type messages, get responses, and let the agent run shell commands on your behalf.
+
+## Getting started
+
+Install dependencies:
+
+```bash
+bun install
+bun run build:sdk
+```
+
+Set an API key:
+
+```bash
+export CLINE_API_KEY="cline_..."
+```
+
+Run:
+
+```bash
+bun dev
+```
+
+Type any message at the `you:` prompt to see a streaming response from the agent.
+
+## What it does
+
+- Creates a conversational `Agent` with a `shell` tool using `createTool`
+- Streams `assistant-text-delta` events to stdout as the agent responds
+- Logs tool calls and their results inline
+- Uses `agent.run()` for the first message and `agent.continue()` for follow-ups to maintain conversation context
+
+## Concepts demonstrated
+
+- `createTool` with zod schema validation
+- Event subscription for streaming and tool call visibility
+- Multi-turn conversation with `run()` / `continue()`
+- `systemPrompt` configuration
+
+## Notes
+
+For the simplest possible example, see [quickstart](../quickstart). For structured workflows with multiple tools, see [code-review-bot](../code-review-bot).
diff --git a/apps/examples/cli-agent/package.json b/apps/examples/cli-agent/package.json
new file mode 100644
index 0000000..6595543
--- /dev/null
+++ b/apps/examples/cli-agent/package.json
@@ -0,0 +1,22 @@
+{
+	"name": "@cline/example-cli-agent",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"build:sdk": "bun run --cwd ../../.. build:sdk",
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@cline/sdk": "workspace:*",
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}
diff --git a/apps/examples/cli-agent/src/index.ts b/apps/examples/cli-agent/src/index.ts
new file mode 100644
index 0000000..0f31f26
--- /dev/null
+++ b/apps/examples/cli-agent/src/index.ts
@@ -0,0 +1,94 @@
+import * as readline from "node:readline";
+import { Agent, createTool } from "@cline/sdk";
+import { z } from "zod";
+
+const agent = new Agent({
+	providerId: "cline",
+	modelId: "anthropic/claude-sonnet-4.6",
+	apiKey: process.env.CLINE_API_KEY,
+	systemPrompt: "You are a helpful assistant in a terminal chat. Be concise.",
+	maxIterations: 10,
+	tools: [
+		createTool({
+			name: "shell",
+			description: "Run a shell command and return the output.",
+			inputSchema: z.object({
+				command: z.string().describe("The shell command to execute"),
+			}),
+			async execute(input) {
+				const proc = Bun.spawn(["sh", "-c", input.command], {
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+				const stdout = await new Response(proc.stdout).text();
+				const stderr = await new Response(proc.stderr).text();
+				await proc.exited;
+				return { exitCode: proc.exitCode, stdout, stderr };
+			},
+		}),
+	],
+});
+
+agent.subscribe((event) => {
+	switch (event.type) {
+		case "assistant-text-delta":
+			process.stdout.write(event.text);
+			break;
+		case "tool-started":
+			console.log(
+				`\n[tool] ${event.toolCall.toolName}(${JSON.stringify(event.toolCall.input)})`,
+			);
+			break;
+		case "tool-finished": {
+			const result = event.message.content.find(
+				(p) => p.type === "tool-result",
+			);
+			if (result && result.type === "tool-result") {
+				const output =
+					typeof result.output === "string"
+						? result.output
+						: JSON.stringify(result.output, null, 2);
+				console.log(
+					`[result] ${output.slice(0, 200)}${output.length > 200 ? "..." : ""}`,
+				);
+			}
+			break;
+		}
+	}
+});
+
+const rl = readline.createInterface({
+	input: process.stdin,
+	output: process.stdout,
+});
+
+function prompt(): Promise<string> {
+	return new Promise((resolve) => {
+		rl.question("\nyou: ", resolve);
+	});
+}
+
+console.log("Cline CLI Agent (type 'exit' to quit)\n");
+
+let isFirstMessage = true;
+while (true) {
+	const input = await prompt();
+	if (input.trim().toLowerCase() === "exit") {
+		break;
+	}
+	if (!input.trim()) {
+		continue;
+	}
+
+	process.stdout.write("\nagent: ");
+	if (isFirstMessage) {
+		await agent.run(input);
+		isFirstMessage = false;
+	} else {
+		await agent.continue(input);
+	}
+	console.log();
+}
+
+rl.close();
+console.log("Goodbye!");
diff --git a/apps/examples/cli-agent/tsconfig.json b/apps/examples/cli-agent/tsconfig.json
new file mode 100644
index 0000000..9c69339
--- /dev/null
+++ b/apps/examples/cli-agent/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"outDir": "dist",
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true
+	},
+	"include": ["src"]
+}
diff --git a/apps/examples/cline-core-cli-agent/README.md b/apps/examples/cline-core-cli-agent/README.md
new file mode 100644
index 0000000..13229db
--- /dev/null
+++ b/apps/examples/cline-core-cli-agent/README.md
@@ -0,0 +1,57 @@
+# Cline Core CLI Agent
+
+An interactive terminal chat agent powered by the `ClineCore` runtime. This example is similar in spirit to [`cli-agent`](../cli-agent), but uses stateful ClineCore sessions and built-in runtime tools instead of the stateless `Agent` class, to leverage Cline's internal agent harness.
+
+## Getting started
+
+Install dependencies:
+
+```bash
+bun install
+bun run build:sdk
+```
+
+Set an API key:
+
+```bash
+export CLINE_API_KEY="sk_..."
+```
+
+Run:
+
+```bash
+bun dev
+```
+
+Type any message at the `you:` prompt to see a streaming response. Type `exit` to quit.
+
+## Optional model configuration
+
+The example defaults to Cline's gateway provider and Claude Sonnet:
+
+```bash
+export CLINE_PROVIDER_ID="cline"
+export CLINE_MODEL_ID="anthropic/claude-sonnet-4.6"
+```
+
+## What it does
+
+- Creates a local `ClineCore` runtime with `ClineCore.create()`
+- Starts one interactive session with `cline.start()`
+- Sends each user turn with `cline.send({ sessionId, prompt })`
+- Streams `agent_event` text to stdout as the assistant responds
+- Logs tool calls and tool results inline
+- Uses ClineCore's built-in tools instead of defining custom tools
+- Calls `cline.stop()` and `cline.dispose()` during shutdown
+
+## Concepts demonstrated
+
+- Stateful sessions with `ClineCore`
+- Multi-turn conversation using a single `sessionId`
+- `CoreSessionEvent` subscription via `cline.subscribe()`
+- Built-in runtime tools (`read_files`, `search_codebase`, `run_commands`, etc.)
+- Basic tool policies: file reads/search are auto-approved, other tools request approval
+
+## Notes
+
+Use this example when you want the full ClineCore runtime with sessions, persistence, and built-in tools. For the smallest possible SDK example, see [quickstart](../quickstart). For the lightweight stateless runtime, see [cli-agent](../cli-agent).
diff --git a/apps/examples/cline-core-cli-agent/package.json b/apps/examples/cline-core-cli-agent/package.json
new file mode 100644
index 0000000..24f2a54
--- /dev/null
+++ b/apps/examples/cline-core-cli-agent/package.json
@@ -0,0 +1,21 @@
+{
+	"name": "@cline/example-cline-core-cli-agent",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"build:sdk": "bun run --cwd ../../.. build:sdk",
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@cline/sdk": "workspace:*"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}
diff --git a/apps/examples/cline-core-cli-agent/src/index.ts b/apps/examples/cline-core-cli-agent/src/index.ts
new file mode 100644
index 0000000..b12cdcc
--- /dev/null
+++ b/apps/examples/cline-core-cli-agent/src/index.ts
@@ -0,0 +1,185 @@
+import * as readline from "node:readline";
+import {
+	type AgentEvent,
+	ClineCore,
+	type ToolApprovalRequest,
+} from "@cline/sdk";
+
+// ClineCore does not choose a model automatically; each session config must provide one.
+// These example defaults use the Cline gateway with Claude Sonnet, and can be overridden with env vars.
+const providerId = process.env.CLINE_PROVIDER_ID ?? "cline";
+const modelId = process.env.CLINE_MODEL_ID ?? "anthropic/claude-sonnet-4.6";
+const apiKey = process.env.CLINE_API_KEY;
+const cwd = process.cwd();
+
+const systemPrompt = `You are a helpful assistant in an interactive terminal chat.
+Be concise. You can use built-in tools to inspect files, search the workspace, and run shell commands when helpful.`;
+
+let cline: ClineCore | undefined;
+let unsubscribe: (() => void) | undefined;
+let activeSessionId: string | undefined;
+let hasPrintedAssistantPrefix = false;
+
+function printAssistantPrefix(): void {
+	if (!hasPrintedAssistantPrefix) {
+		process.stdout.write("\nagent: ");
+		hasPrintedAssistantPrefix = true;
+	}
+}
+
+function formatToolValue(value: unknown): string {
+	const output =
+		typeof value === "string" ? value : (JSON.stringify(value, null, 2) ?? "");
+	return output.length > 200 ? `${output.slice(0, 200)}...` : output;
+}
+
+function handleAgentEvent(event: AgentEvent): void {
+	switch (event.type) {
+		case "content_start":
+			if (event.contentType === "text" && event.text) {
+				printAssistantPrefix();
+				process.stdout.write(event.text);
+			}
+			if (event.contentType === "tool" && event.toolName) {
+				console.log(
+					`\n[tool] ${event.toolName}(${JSON.stringify(event.input ?? {})})`,
+				);
+			}
+			break;
+		case "content_update":
+			if (event.contentType === "tool" && event.toolName) {
+				console.log(
+					`[update] ${event.toolName}: ${formatToolValue(event.update)}`,
+				);
+			}
+			break;
+		case "content_end":
+			if (event.contentType === "tool" && event.toolName) {
+				if (event.error) {
+					console.log(`[error] ${event.toolName}: ${event.error}`);
+				} else {
+					console.log(`[result] ${formatToolValue(event.output)}`);
+				}
+			}
+			break;
+		case "notice":
+			console.log(`\n[notice] ${event.message}`);
+			break;
+		case "error":
+			console.error(`\n[error] ${event.error.message}`);
+			break;
+	}
+}
+
+async function ensureCline(): Promise<ClineCore> {
+	if (cline) {
+		return cline;
+	}
+
+	cline = await ClineCore.create({
+		clientName: "cline-core-cli-agent",
+		backendMode: "local",
+		capabilities: {
+			requestToolApproval,
+		},
+	});
+	unsubscribe = cline.subscribe((event) => {
+		if (event.type === "agent_event") {
+			handleAgentEvent(event.payload.event);
+		}
+	});
+	return cline;
+}
+
+const rl = readline.createInterface({
+	input: process.stdin,
+	output: process.stdout,
+});
+
+function ask(question: string): Promise<string> {
+	return new Promise((resolve) => {
+		rl.question(question, resolve);
+	});
+}
+
+async function requestToolApproval(request: ToolApprovalRequest) {
+	console.log(`\n[approval] ${request.toolName} wants to run:`);
+	console.log(formatToolValue(request.input));
+	const answer = await ask("Approve? [y/N] ");
+	const approved = answer.trim().toLowerCase() === "y";
+	return {
+		approved,
+		...(approved ? {} : { reason: "User denied tool execution" }),
+	};
+}
+
+function prompt(): Promise<string> {
+	return ask("\nyou: ");
+}
+
+async function startSession(): Promise<string> {
+	const runtime = await ensureCline();
+	const result = await runtime.start({
+		source: "cli",
+		interactive: true,
+		config: {
+			providerId,
+			modelId,
+			apiKey,
+			cwd,
+			workspaceRoot: cwd,
+			mode: "act",
+			systemPrompt,
+			maxIterations: 10,
+			enableTools: true,
+			enableSpawnAgent: false,
+			enableAgentTeams: false,
+			disableMcpSettingsTools: true,
+		},
+		toolPolicies: {
+			"*": { autoApprove: false },
+			read_files: { autoApprove: true },
+			search_codebase: { autoApprove: true },
+		},
+	});
+	return result.sessionId;
+}
+
+async function runTurn(input: string): Promise<void> {
+	activeSessionId ??= await startSession();
+	hasPrintedAssistantPrefix = false;
+	const runtime = await ensureCline();
+	await runtime.send({
+		sessionId: activeSessionId,
+		prompt: input,
+	});
+	console.log();
+}
+
+console.log("ClineCore CLI Agent (type 'exit' to quit)\n");
+console.log(`Provider: ${providerId}`);
+console.log(`Model:    ${modelId}`);
+console.log(`CWD:      ${cwd}`);
+
+try {
+	while (true) {
+		const input = await prompt();
+		const trimmed = input.trim();
+		if (trimmed.toLowerCase() === "exit") {
+			break;
+		}
+		if (!trimmed) {
+			continue;
+		}
+
+		await runTurn(trimmed);
+	}
+} finally {
+	rl.close();
+	unsubscribe?.();
+	if (activeSessionId && cline) {
+		await cline.stop(activeSessionId).catch(() => undefined);
+	}
+	await cline?.dispose();
+	console.log("Goodbye!");
+}
diff --git a/apps/examples/cline-core-cli-agent/tsconfig.json b/apps/examples/cline-core-cli-agent/tsconfig.json
new file mode 100644
index 0000000..9c69339
--- /dev/null
+++ b/apps/examples/cline-core-cli-agent/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"outDir": "dist",
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true
+	},
+	"include": ["src"]
+}
diff --git a/apps/examples/code-review-bot/README.md b/apps/examples/code-review-bot/README.md
new file mode 100644
index 0000000..076e608
--- /dev/null
+++ b/apps/examples/code-review-bot/README.md
@@ -0,0 +1,67 @@
+# Code Review Bot Dashboard
+
+An AI-powered code review dashboard for real GitHub pull requests. Paste a PR URL, inspect the actual changed files, stream an SDK-powered review over the real PR diff, and copy or optionally post the generated review.
+
+<p align="center">
+  <img src="./assets/dashboard.jpg" alt="Code Review Bot dashboard showing a loaded pull request diff" width="100%" />
+</p>
+
+## Getting started
+
+Install dependencies:
+
+```bash
+bun install
+bun run build:sdk
+```
+
+Set an API key:
+
+```bash
+export CLINE_API_KEY="cline_..."
+```
+
+Optionally set a GitHub token. Public PRs can be loaded without one, but a token is recommended for private repositories and higher rate limits:
+
+```bash
+export GITHUB_TOKEN="github_pat_..."
+```
+
+Run the dashboard:
+
+```bash
+bun dev
+```
+
+Open http://localhost:3457, paste a GitHub pull request URL, and click **Run Review**.
+
+By default the app copies the generated review to your clipboard. To allow posting a summary comment back to GitHub, run with both `GITHUB_TOKEN` and:
+
+```bash
+export ENABLE_GITHUB_REVIEW_POSTING=1
+```
+
+## What it does
+
+1. Fetches a real GitHub PR, including metadata, changed files, patches, and check status
+2. Renders the PR in a dashboard with file navigation, diff view, review lanes, and finding cards
+3. Sends the real PR diff to an agent with three custom tools:
+   - `get_file_context` - reads full file contents from the PR head commit for surrounding context
+   - `add_review_finding` - records a structured finding with file, line, severity, category, and suggestion
+   - `submit_review` - a completion tool that ends the run with a summary and approve/request-changes decision
+4. Streams findings to the browser via Server-Sent Events as the agent reviews the PR
+5. Copies the final review locally, or posts it as a GitHub PR comment when explicitly enabled
+
+## Concepts demonstrated
+
+- Multiple `createTool` definitions with zod schemas
+- `lifecycle: { completesRun: true }` to make a tool end the agent loop
+- Rich `systemPrompt` with structured instructions
+- Event subscription filtered by tool name
+- GitHub REST API integration for pull request metadata and diffs
+- Server-Sent Events (SSE) for a live review dashboard
+- Guarded external writes through an explicit posting opt-in
+
+## Notes
+
+For a simpler starting point, see [quickstart](../quickstart). For an interactive chat agent, see [cli-agent](../cli-agent).
diff --git a/apps/examples/code-review-bot/assets/dashboard.jpg b/apps/examples/code-review-bot/assets/dashboard.jpg
new file mode 100644
index 0000000..774a74b
Binary files /dev/null and b/apps/examples/code-review-bot/assets/dashboard.jpg differ
diff --git a/apps/examples/code-review-bot/package.json b/apps/examples/code-review-bot/package.json
new file mode 100644
index 0000000..f80758c
--- /dev/null
+++ b/apps/examples/code-review-bot/package.json
@@ -0,0 +1,22 @@
+{
+	"name": "@cline/example-code-review-bot",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"build:sdk": "bun run --cwd ../../.. build:sdk",
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@cline/sdk": "workspace:*",
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}
diff --git a/apps/examples/code-review-bot/src/index.ts b/apps/examples/code-review-bot/src/index.ts
new file mode 100644
index 0000000..d533de4
--- /dev/null
+++ b/apps/examples/code-review-bot/src/index.ts
@@ -0,0 +1,1658 @@
+import {
+	createServer,
+	type IncomingMessage,
+	type ServerResponse,
+} from "node:http";
+import { Agent, createTool } from "@cline/sdk";
+import { z } from "zod";
+
+const PORT = Number(process.env.PORT || 3457);
+const MODEL_ID = process.env.CLINE_MODEL_ID || "anthropic/claude-sonnet-4.6";
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+const POSTING_ENABLED =
+	process.env.ENABLE_GITHUB_REVIEW_POSTING === "1" && Boolean(GITHUB_TOKEN);
+const MAX_DIFF_CHARS = 60_000;
+const MAX_FILE_CONTEXT_CHARS = 80_000;
+
+const ReviewFindingInputSchema = z.object({
+	file: z.string().describe("Changed file path"),
+	line: z.number().int().min(1).describe("Line number in the changed file"),
+	severity: z.enum(["high", "medium", "low"]).describe("Impact level"),
+	category: z
+		.enum(["security", "correctness", "performance", "maintainability"])
+		.describe("Review category"),
+	title: z.string().max(140).describe("Short finding title"),
+	comment: z.string().max(1200).describe("Specific review comment"),
+	suggestion: z
+		.string()
+		.max(1200)
+		.optional()
+		.describe("Optional suggested fix"),
+});
+
+const ReviewSummarySchema = z.object({
+	summary: z.string().describe("Brief overall review summary"),
+	approve: z.boolean().describe("Whether the PR looks safe to merge"),
+});
+
+const PostReviewRequestSchema = z.object({
+	prUrl: z.string(),
+	summary: ReviewSummarySchema.optional(),
+	findings: z.array(ReviewFindingInputSchema),
+});
+
+type ReviewFindingInput = z.infer<typeof ReviewFindingInputSchema>;
+type ReviewSummary = z.infer<typeof ReviewSummarySchema>;
+
+interface ReviewFinding extends ReviewFindingInput {
+	id: string;
+}
+
+interface PullRequestRef {
+	owner: string;
+	repo: string;
+	number: number;
+}
+
+interface GitHubPullRequest {
+	number: number;
+	title: string;
+	state: string;
+	html_url: string;
+	draft: boolean;
+	additions: number;
+	deletions: number;
+	changed_files: number;
+	comments: number;
+	review_comments: number;
+	commits: number;
+	user: { login: string };
+	base: { ref: string };
+	head: { ref: string; sha: string };
+}
+
+interface GitHubPullFile {
+	filename: string;
+	status: string;
+	additions: number;
+	deletions: number;
+	changes: number;
+	patch?: string;
+	raw_url?: string;
+}
+
+interface CheckRunsResponse {
+	total_count: number;
+	check_runs: Array<{ conclusion: string | null; status: string }>;
+}
+
+interface CombinedStatusResponse {
+	state: string;
+	total_count: number;
+}
+
+interface PullRequestBundle {
+	ref: PullRequestRef;
+	pr: GitHubPullRequest;
+	files: GitHubPullFile[];
+	diff: string;
+	checks: string;
+}
+
+class HttpError extends Error {
+	constructor(
+		readonly status: number,
+		message: string,
+	) {
+		super(message);
+	}
+}
+
+const HTML = `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>AI Code Review Bot</title>
+<style>
+  :root {
+    --bg: #05080c;
+    --panel: rgba(9, 14, 21, 0.94);
+    --panel-2: rgba(13, 19, 29, 0.96);
+    --line: rgba(124, 178, 206, 0.17);
+    --line-strong: rgba(91, 168, 255, 0.36);
+    --text: #e7f1f6;
+    --muted: #8796a1;
+    --blue: #4ea6ff;
+    --green: #67e68a;
+    --amber: #f4b23a;
+    --red: #ff5f77;
+    --violet: #b579ff;
+  }
+
+  * { box-sizing: border-box; }
+  html, body { width: 100%; min-height: 100%; margin: 0; }
+  body {
+    color: var(--text);
+    background:
+      radial-gradient(circle at 20% -10%, rgba(59, 155, 255, 0.16), transparent 34%),
+      radial-gradient(circle at 85% 15%, rgba(103, 230, 138, 0.09), transparent 28%),
+      linear-gradient(145deg, #030508, #071018 52%, #020407);
+    font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    overflow: hidden;
+  }
+  body::before {
+    content: "";
+    position: fixed;
+    inset: 0;
+    pointer-events: none;
+    background-image:
+      linear-gradient(rgba(255,255,255,0.025) 1px, transparent 1px),
+      linear-gradient(90deg, rgba(255,255,255,0.025) 1px, transparent 1px);
+    background-size: 40px 40px;
+    mask-image: linear-gradient(to bottom, rgba(0,0,0,0.95), transparent 92%);
+  }
+  button, input, select { font: inherit; }
+  button { color: inherit; }
+
+  .app {
+    position: relative;
+    z-index: 1;
+    width: 100vw;
+    height: 100vh;
+    display: grid;
+    grid-template-columns: 86px minmax(0, 1fr);
+    background: rgba(3, 7, 11, 0.72);
+  }
+  .rail {
+    border-right: 1px solid var(--line);
+    background: rgba(4, 9, 15, 0.9);
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+    padding: 18px 8px;
+    gap: 10px;
+  }
+  .logo {
+    width: 48px;
+    height: 48px;
+    margin: 0 auto 20px;
+    border: 1px solid rgba(78, 166, 255, 0.58);
+    border-radius: 11px;
+    display: grid;
+    place-items: center;
+    color: #74c7ff;
+    font-weight: 900;
+    font-size: 26px;
+    box-shadow: 0 0 24px rgba(78, 166, 255, 0.22);
+  }
+  .nav {
+    min-height: 58px;
+    border: 1px solid transparent;
+    border-radius: 9px;
+    background: transparent;
+    color: #9aa8b1;
+    display: grid;
+    place-items: center;
+    gap: 4px;
+    cursor: pointer;
+  }
+  .nav strong {
+    width: 25px;
+    height: 25px;
+    border: 1px solid rgba(151, 174, 188, 0.28);
+    border-radius: 7px;
+    display: grid;
+    place-items: center;
+    font-size: 12px;
+  }
+  .nav span { font-size: 11px; }
+  .nav.active, .nav:hover {
+    background: rgba(28, 110, 203, 0.2);
+    border-color: rgba(78, 166, 255, 0.36);
+    color: #e8f7ff;
+  }
+
+  .shell {
+    min-width: 0;
+    min-height: 0;
+    display: grid;
+    grid-template-rows: 92px minmax(0, 1fr);
+  }
+  .topbar {
+    min-width: 0;
+    border-bottom: 1px solid var(--line);
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) auto;
+    gap: 18px;
+    align-items: center;
+    padding: 18px 24px;
+    background: rgba(5, 10, 16, 0.8);
+  }
+  .title-stack {
+    min-width: 0;
+    display: grid;
+    gap: 8px;
+  }
+  .title-row {
+    min-width: 0;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+  }
+  .title-row h1 {
+    margin: 0;
+    min-width: 0;
+    color: #f4fbff;
+    font-size: 25px;
+    line-height: 1.1;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+  .pill {
+    flex: 0 0 auto;
+    border: 1px solid rgba(103, 230, 138, 0.28);
+    border-radius: 999px;
+    padding: 4px 10px;
+    background: rgba(103, 230, 138, 0.12);
+    color: #7cf095;
+    font-size: 12px;
+    font-weight: 700;
+  }
+  .meta {
+    min-width: 0;
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    color: #a2adb5;
+    font-size: 13px;
+    white-space: nowrap;
+    overflow: hidden;
+  }
+  .meta span {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+  .url-form {
+    min-width: 460px;
+    display: grid;
+    grid-template-columns: minmax(260px, 1fr) 116px 128px;
+    gap: 10px;
+  }
+  .url-form input {
+    min-width: 0;
+    border: 1px solid rgba(131, 174, 201, 0.24);
+    border-radius: 8px;
+    background: rgba(1, 5, 9, 0.84);
+    color: #eaf7ff;
+    padding: 12px 13px;
+    outline: none;
+  }
+  .url-form input:focus {
+    border-color: rgba(78, 166, 255, 0.76);
+    box-shadow: 0 0 0 3px rgba(78, 166, 255, 0.12);
+  }
+  .btn {
+    border: 1px solid rgba(132, 176, 203, 0.24);
+    border-radius: 8px;
+    background: rgba(16, 26, 38, 0.9);
+    color: #dcecf4;
+    cursor: pointer;
+    font-weight: 700;
+  }
+  .btn.primary {
+    border-color: rgba(78, 166, 255, 0.56);
+    background: linear-gradient(180deg, #0d7dff, #075fe4);
+    color: white;
+    box-shadow: 0 0 24px rgba(13, 125, 255, 0.2);
+  }
+  .btn:disabled { opacity: 0.5; cursor: not-allowed; }
+
+  .workspace {
+    min-width: 0;
+    min-height: 0;
+    display: grid;
+    grid-template-columns: minmax(520px, 45%) minmax(580px, 55%);
+    overflow: hidden;
+  }
+  .left, .right {
+    min-width: 0;
+    min-height: 0;
+    overflow: hidden;
+  }
+  .left {
+    display: grid;
+    grid-template-columns: 230px minmax(0, 1fr);
+    border-right: 1px solid var(--line);
+  }
+  .files {
+    min-width: 0;
+    border-right: 1px solid var(--line);
+    padding: 18px 10px;
+    overflow: auto;
+  }
+  .tabs {
+    display: flex;
+    gap: 22px;
+    padding: 0 4px 14px;
+    border-bottom: 1px solid rgba(130, 171, 198, 0.12);
+    margin-bottom: 14px;
+    color: #aab5bd;
+    font-size: 13px;
+  }
+  .tabs strong {
+    color: #f3fbff;
+    position: relative;
+  }
+  .tabs strong::after {
+    content: "";
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: -15px;
+    height: 2px;
+    background: var(--blue);
+  }
+  .filter {
+    width: 100%;
+    border: 1px solid rgba(131, 174, 201, 0.2);
+    border-radius: 7px;
+    background: rgba(1, 5, 9, 0.66);
+    color: #c9d7df;
+    padding: 10px 11px;
+    outline: none;
+    margin-bottom: 14px;
+  }
+  .file-list {
+    display: grid;
+    gap: 5px;
+  }
+  .file-item {
+    width: 100%;
+    min-width: 0;
+    border: 1px solid transparent;
+    border-radius: 7px;
+    background: transparent;
+    color: #c5d2da;
+    cursor: pointer;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) auto;
+    gap: 8px;
+    align-items: center;
+    padding: 9px 8px;
+    text-align: left;
+  }
+  .file-item:hover, .file-item.active {
+    background: rgba(78, 166, 255, 0.14);
+    border-color: rgba(78, 166, 255, 0.22);
+  }
+  .file-path {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+  }
+  .file-stats {
+    white-space: nowrap;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+  }
+  .plus { color: var(--green); }
+  .minus { color: var(--red); }
+
+  .diff-pane {
+    min-width: 0;
+    min-height: 0;
+    padding: 18px 14px;
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr);
+  }
+  .diff-header {
+    min-width: 0;
+    border: 1px solid var(--line);
+    border-bottom: 0;
+    border-radius: 8px 8px 0 0;
+    background: rgba(8, 13, 20, 0.82);
+    padding: 12px 14px;
+    display: flex;
+    justify-content: space-between;
+    gap: 12px;
+    color: #b9c7cf;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 13px;
+  }
+  .diff-title {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .diff-code {
+    min-width: 0;
+    min-height: 0;
+    border: 1px solid var(--line);
+    border-radius: 0 0 8px 8px;
+    overflow: auto;
+    background: rgba(2, 6, 10, 0.72);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+    line-height: 1.48;
+  }
+  .diff-line {
+    min-width: max-content;
+    display: grid;
+    grid-template-columns: 54px minmax(760px, 1fr);
+    border-bottom: 1px solid rgba(255,255,255,0.018);
+  }
+  .line-no {
+    color: #667680;
+    text-align: right;
+    padding: 2px 12px 2px 6px;
+    user-select: none;
+    border-right: 1px solid rgba(132, 176, 203, 0.08);
+  }
+  .line-code { white-space: pre; padding: 2px 12px; color: #bbc9d1; }
+  .diff-line.add { background: rgba(39, 174, 96, 0.15); }
+  .diff-line.del { background: rgba(255, 75, 100, 0.16); }
+  .diff-line.hunk { background: rgba(78, 166, 255, 0.11); color: #84c7ff; }
+  .diff-line.add .line-code { color: #c7f8d3; }
+  .diff-line.del .line-code { color: #ffc1ca; }
+
+  .right {
+    padding: 18px 16px;
+    overflow: auto;
+  }
+  .review-card {
+    min-width: 0;
+    min-height: calc(100vh - 128px);
+    border: 1px solid var(--line);
+    border-radius: 11px;
+    background: linear-gradient(180deg, rgba(12, 18, 28, 0.96), rgba(6, 10, 16, 0.98));
+    box-shadow: 0 0 0 1px rgba(255,255,255,0.018) inset, 0 24px 80px rgba(0,0,0,0.32);
+    padding: 14px;
+    display: grid;
+    grid-template-rows: auto auto auto auto minmax(220px, 1fr) auto;
+    gap: 12px;
+  }
+  .review-head {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    padding: 4px 2px 8px;
+  }
+  .bot-title {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    color: #f0fbff;
+    font-size: 18px;
+    font-weight: 800;
+  }
+  .bot-mark {
+    width: 32px;
+    height: 32px;
+    border-radius: 8px;
+    display: grid;
+    place-items: center;
+    background: rgba(78, 166, 255, 0.14);
+    border: 1px solid rgba(78, 166, 255, 0.34);
+    color: #a5d6ff;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+  }
+  .model {
+    color: #9facb6;
+    font-size: 13px;
+  }
+  .run-box {
+    border: 1px solid var(--line);
+    border-radius: 9px;
+    background: rgba(6, 10, 16, 0.72);
+    padding: 14px;
+  }
+  .run-top {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 12px;
+    margin-bottom: 12px;
+  }
+  .run-title {
+    display: grid;
+    gap: 4px;
+  }
+  .run-title strong { font-size: 22px; color: #f4fbff; }
+  .run-title span { color: #9eabb4; font-size: 13px; }
+  .confidence {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    color: #aab7c0;
+    font-size: 13px;
+  }
+  .ring {
+    --score: 18%;
+    width: 66px;
+    height: 66px;
+    border-radius: 999px;
+    background:
+      radial-gradient(circle at center, #071019 58%, transparent 59%),
+      conic-gradient(var(--green) var(--score), rgba(78, 166, 255, 0.13) 0);
+    display: grid;
+    place-items: center;
+    color: #a7ffc0;
+    font-weight: 900;
+    font-size: 18px;
+  }
+  .lanes {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 10px;
+  }
+  .lane {
+    border: 1px solid rgba(132, 176, 203, 0.15);
+    border-radius: 8px;
+    background: rgba(11, 18, 27, 0.78);
+    padding: 11px;
+  }
+  .lane.security { background: linear-gradient(180deg, rgba(78, 166, 255, 0.12), rgba(11, 18, 27, 0.78)); }
+  .lane.tests { background: linear-gradient(180deg, rgba(244, 178, 58, 0.12), rgba(11, 18, 27, 0.78)); }
+  .lane.writer { background: linear-gradient(180deg, rgba(181, 121, 255, 0.12), rgba(11, 18, 27, 0.78)); }
+  .lane-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+    font-weight: 800;
+    font-size: 13px;
+  }
+  .dot {
+    width: 9px;
+    height: 9px;
+    border-radius: 999px;
+    background: var(--green);
+    box-shadow: 0 0 13px rgba(103, 230, 138, 0.48);
+  }
+  .lane.security .dot { background: var(--blue); }
+  .lane.tests .dot { background: var(--amber); }
+  .lane.writer .dot { background: var(--violet); }
+  .lane-status { color: #9eabb4; font-size: 12px; margin-bottom: 10px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .bar { height: 5px; border-radius: 999px; background: rgba(255,255,255,0.09); overflow: hidden; }
+  .bar span { display: block; width: 0%; height: 100%; background: var(--green); transition: width 240ms ease; }
+  .lane.security .bar span { background: var(--blue); }
+  .lane.tests .bar span { background: var(--amber); }
+  .lane.writer .bar span { background: var(--violet); }
+  .lane-percent { margin-top: 6px; text-align: right; color: #d6e3ea; font-size: 12px; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }
+
+  .summary-grid {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 10px;
+  }
+  .summary-card {
+    border: 1px solid rgba(132, 176, 203, 0.15);
+    border-radius: 8px;
+    padding: 12px;
+    background: rgba(9, 15, 23, 0.76);
+  }
+  .summary-card strong {
+    display: block;
+    color: #eaf5fa;
+    font-size: 26px;
+    margin-top: 8px;
+  }
+  .summary-card span {
+    color: #a6b3bd;
+    font-size: 12px;
+  }
+  .summary-card.security { border-color: rgba(255, 95, 119, 0.22); }
+  .summary-card.correctness { border-color: rgba(78, 166, 255, 0.22); }
+  .summary-card.performance { border-color: rgba(103, 230, 138, 0.22); }
+  .summary-card.maintainability { border-color: rgba(181, 121, 255, 0.22); }
+
+  .findings {
+    min-height: 0;
+    border: 1px solid var(--line);
+    border-radius: 9px;
+    background: rgba(3, 7, 12, 0.52);
+    overflow: hidden;
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr);
+  }
+  .findings-head {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 14px;
+    border-bottom: 1px solid rgba(132, 176, 203, 0.12);
+  }
+  .findings-head strong { font-size: 18px; }
+  .findings-head span { color: #9cabb5; font-size: 12px; }
+  .finding-list {
+    min-height: 0;
+    overflow: auto;
+    padding: 10px;
+    display: grid;
+    align-content: start;
+    gap: 8px;
+  }
+  .empty {
+    color: #7d8b95;
+    border: 1px dashed rgba(132, 176, 203, 0.18);
+    border-radius: 8px;
+    padding: 18px;
+    text-align: center;
+  }
+  .finding {
+    border: 1px solid rgba(132, 176, 203, 0.14);
+    border-radius: 8px;
+    background: rgba(12, 18, 27, 0.82);
+    padding: 11px 12px;
+    display: grid;
+    gap: 8px;
+  }
+  .finding-top {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: 0;
+  }
+  .severity {
+    border-radius: 6px;
+    padding: 3px 7px;
+    font-size: 11px;
+    font-weight: 800;
+    text-transform: uppercase;
+  }
+  .severity.high { background: rgba(255, 95, 119, 0.16); color: #ff9bad; border: 1px solid rgba(255, 95, 119, 0.28); }
+  .severity.medium { background: rgba(244, 178, 58, 0.16); color: #ffd37a; border: 1px solid rgba(244, 178, 58, 0.28); }
+  .severity.low { background: rgba(103, 230, 138, 0.12); color: #9df5b2; border: 1px solid rgba(103, 230, 138, 0.25); }
+  .category {
+    color: #a7b5be;
+    font-size: 12px;
+    text-transform: capitalize;
+  }
+  .finding-title {
+    min-width: 0;
+    color: #f0f7fb;
+    font-weight: 800;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+  .location {
+    margin-left: auto;
+    color: #7fc3ff;
+    background: rgba(78, 166, 255, 0.12);
+    border-radius: 5px;
+    padding: 3px 6px;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 11px;
+    white-space: nowrap;
+  }
+  .finding p {
+    margin: 0;
+    color: #b9c7cf;
+    font-size: 13px;
+    line-height: 1.45;
+  }
+  .suggestion {
+    border-left: 2px solid rgba(78, 166, 255, 0.54);
+    padding-left: 9px;
+    color: #9ed1ff;
+    font-size: 12px;
+  }
+  .final {
+    display: grid;
+    gap: 8px;
+    color: #b7c5cd;
+    font-size: 13px;
+    line-height: 1.45;
+  }
+  .actions {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 14px;
+  }
+  .toast {
+    color: #88f29e;
+    font-size: 13px;
+  }
+  .post {
+    min-width: 220px;
+    min-height: 48px;
+    border: 1px solid rgba(78, 166, 255, 0.6);
+    border-radius: 8px;
+    background: linear-gradient(180deg, #1684ff, #075fe4);
+    color: white;
+    font-size: 16px;
+    font-weight: 900;
+    cursor: pointer;
+  }
+  .post:disabled { opacity: 0.5; cursor: not-allowed; }
+
+  @media (max-width: 1180px) {
+    body { overflow: auto; }
+    .app { min-height: 100vh; height: auto; grid-template-columns: 1fr; }
+    .rail { display: none; }
+    .shell { height: auto; grid-template-rows: auto auto; }
+    .topbar { grid-template-columns: 1fr; }
+    .url-form { min-width: 0; grid-template-columns: 1fr; }
+    .workspace { grid-template-columns: 1fr; overflow: visible; }
+    .left { min-height: 620px; }
+    .right { overflow: visible; }
+    .review-card { min-height: 720px; }
+  }
+</style>
+</head>
+<body>
+<main class="app">
+  <aside class="rail" aria-label="Navigation">
+    <div class="logo">C</div>
+    <button class="nav" type="button"><strong>O</strong><span>Overview</span></button>
+    <button class="nav active" type="button"><strong>R</strong><span>Review</span></button>
+    <button class="nav" type="button"><strong>C</strong><span>Commits</span></button>
+    <button class="nav" type="button"><strong>K</strong><span>Checks</span></button>
+    <button class="nav" type="button"><strong>F</strong><span>Files</span></button>
+  </aside>
+  <section class="shell">
+    <header class="topbar">
+      <div class="title-stack">
+        <div class="title-row">
+          <h1 id="pr-title">Real Pull Request Review</h1>
+          <span id="pr-state" class="pill">Ready</span>
+        </div>
+        <div class="meta">
+          <span id="branch-meta">Paste a GitHub pull request URL to inspect real files and run the review bot.</span>
+          <span id="comments-meta"></span>
+          <span id="checks-meta"></span>
+        </div>
+      </div>
+      <form id="url-form" class="url-form">
+        <input id="pr-url" type="url" placeholder="https://github.com/owner/repo/pull/123" autocomplete="off" />
+        <button id="load" class="btn" type="button">Load PR</button>
+        <button id="review" class="btn primary" type="submit">Run Review</button>
+      </form>
+    </header>
+    <div class="workspace">
+      <section class="left" aria-label="Pull request files">
+        <aside class="files">
+          <div class="tabs"><strong>Files Changed <span id="file-count">0</span></strong><span>Conversation <span id="conversation-count">0</span></span></div>
+          <input id="filter" class="filter" placeholder="Filter files..." />
+          <div id="file-list" class="file-list">
+            <div class="empty">Load a real GitHub PR to see changed files.</div>
+          </div>
+        </aside>
+        <section class="diff-pane">
+          <div class="diff-header">
+            <span id="diff-title" class="diff-title">No file selected</span>
+            <span id="diff-stats"></span>
+          </div>
+          <div id="diff-code" class="diff-code">
+            <div class="empty">The selected PR file patch will render here.</div>
+          </div>
+        </section>
+      </section>
+      <section class="right" aria-label="AI review">
+        <article class="review-card">
+          <div class="review-head">
+            <div class="bot-title"><span class="bot-mark">AI</span><span>AI Review Bot</span><span class="pill">Real PR</span></div>
+            <div id="model" class="model">Model: loading...</div>
+          </div>
+          <section class="run-box">
+            <div class="run-top">
+              <div class="run-title">
+                <strong id="run-title">AI Review Ready</strong>
+                <span id="run-subtitle">Fetch a PR, then stream findings from the SDK reviewer.</span>
+              </div>
+              <div class="confidence">
+                <span>Overall Confidence</span>
+                <div id="ring" class="ring">0%</div>
+              </div>
+            </div>
+            <div class="lanes">
+              <div class="lane" data-lane="diff">
+                <div class="lane-title"><span class="dot"></span><span>Diff Parser</span></div>
+                <div class="lane-status">Waiting for PR</div>
+                <div class="bar"><span></span></div>
+                <div class="lane-percent">0%</div>
+              </div>
+              <div class="lane security" data-lane="security">
+                <div class="lane-title"><span class="dot"></span><span>Security Reviewer</span></div>
+                <div class="lane-status">Queued</div>
+                <div class="bar"><span></span></div>
+                <div class="lane-percent">0%</div>
+              </div>
+              <div class="lane tests" data-lane="tests">
+                <div class="lane-title"><span class="dot"></span><span>Test Analyst</span></div>
+                <div class="lane-status">Queued</div>
+                <div class="bar"><span></span></div>
+                <div class="lane-percent">0%</div>
+              </div>
+              <div class="lane writer" data-lane="writer">
+                <div class="lane-title"><span class="dot"></span><span>Comment Writer</span></div>
+                <div class="lane-status">Queued</div>
+                <div class="bar"><span></span></div>
+                <div class="lane-percent">0%</div>
+              </div>
+            </div>
+          </section>
+          <div class="summary-grid">
+            <div class="summary-card security"><span>Security</span><strong id="count-security">0</strong><span>Findings</span></div>
+            <div class="summary-card correctness"><span>Correctness</span><strong id="count-correctness">0</strong><span>Issues</span></div>
+            <div class="summary-card performance"><span>Performance</span><strong id="count-performance">0</strong><span>Improvements</span></div>
+            <div class="summary-card maintainability"><span>Maintainability</span><strong id="count-maintainability">0</strong><span>Suggestions</span></div>
+          </div>
+          <section class="findings">
+            <div class="findings-head"><strong>Review Findings</strong><span id="finding-count">0 findings</span></div>
+            <div id="finding-list" class="finding-list"><div class="empty">Findings will stream here as the agent reviews the real PR diff.</div></div>
+          </section>
+          <section id="final" class="final"></section>
+          <div class="actions">
+            <span id="toast" class="toast"></span>
+            <button id="post" class="post" type="button" disabled>Copy Review</button>
+          </div>
+        </article>
+      </section>
+    </div>
+  </section>
+</main>
+<script>
+const state = {
+  pr: null,
+  files: [],
+  selectedFile: null,
+  findings: [],
+  summary: null,
+  postingEnabled: false,
+  eventSource: null,
+};
+
+const $ = (id) => document.getElementById(id);
+
+function escapeHtml(value) {
+  return String(value ?? '').replace(/[&<>"']/g, (char) => ({
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#039;',
+  }[char]));
+}
+
+function shortModel(modelId) {
+  return modelId.replace('anthropic/', '').replace(/-/g, ' ');
+}
+
+async function init() {
+  const config = await fetch('/api/config').then((response) => response.json());
+  state.postingEnabled = config.postingEnabled;
+  $('model').textContent = 'Model: ' + shortModel(config.modelId);
+  $('post').textContent = state.postingEnabled ? 'Post Review' : 'Copy Review';
+  const params = new URLSearchParams(window.location.search);
+  const prUrl = params.get('pr');
+  if (prUrl) {
+    $('pr-url').value = prUrl;
+    if (params.get('review') === '1') {
+      setTimeout(startReview, 100);
+    } else {
+      loadPr().catch((error) => setStatus('Load Failed', error.message));
+    }
+  }
+}
+
+function setStatus(title, subtitle) {
+  $('run-title').textContent = title;
+  $('run-subtitle').textContent = subtitle;
+}
+
+function setLane(name, progress, status) {
+  const lane = document.querySelector('[data-lane="' + name + '"]');
+  if (!lane) return;
+  lane.querySelector('.lane-status').textContent = status;
+  lane.querySelector('.bar span').style.width = progress + '%';
+  lane.querySelector('.lane-percent').textContent = progress + '%';
+}
+
+function setConfidence(score) {
+  $('ring').style.setProperty('--score', score + '%');
+  $('ring').textContent = score + '%';
+}
+
+function resetReview() {
+  state.findings = [];
+  state.summary = null;
+  $('finding-list').innerHTML = '<div class="empty">Findings will stream here as the agent reviews the real PR diff.</div>';
+  $('final').innerHTML = '';
+  $('finding-count').textContent = '0 findings';
+  ['security', 'correctness', 'performance', 'maintainability'].forEach((category) => {
+    $('count-' + category).textContent = '0';
+  });
+  setConfidence(0);
+  setLane('diff', 0, 'Waiting for PR');
+  setLane('security', 0, 'Queued');
+  setLane('tests', 0, 'Queued');
+  setLane('writer', 0, 'Queued');
+  $('post').disabled = true;
+  $('toast').textContent = '';
+}
+
+function renderPr(pr) {
+  state.pr = pr;
+  state.files = pr.files || [];
+  $('pr-title').textContent = 'Pull Request #' + pr.number + ' - ' + pr.title;
+  $('pr-state').textContent = pr.state;
+  $('branch-meta').textContent = pr.owner + '/' + pr.repo + '  ' + pr.headRef + ' -> ' + pr.baseRef;
+  $('comments-meta').textContent = (pr.comments + pr.reviewComments) + ' comments';
+  $('checks-meta').textContent = 'Checks ' + pr.checks;
+  $('file-count').textContent = pr.files.length;
+  $('conversation-count').textContent = pr.comments + pr.reviewComments;
+  renderFiles();
+  if (state.files.length > 0) selectFile(state.files[0].filename);
+}
+
+function renderFiles() {
+  const query = $('filter').value.toLowerCase();
+  const files = state.files.filter((file) => file.filename.toLowerCase().includes(query));
+  if (files.length === 0) {
+    $('file-list').innerHTML = '<div class="empty">No files match.</div>';
+    return;
+  }
+  $('file-list').innerHTML = files.map((file) => {
+    const active = state.selectedFile && state.selectedFile.filename === file.filename ? ' active' : '';
+    return '<button class="file-item' + active + '" type="button" data-file="' + escapeHtml(file.filename) + '">' +
+      '<span class="file-path">' + escapeHtml(file.filename) + '</span>' +
+      '<span class="file-stats"><span class="plus">+' + file.additions + '</span> <span class="minus">-' + file.deletions + '</span></span>' +
+    '</button>';
+  }).join('');
+}
+
+function selectFile(filename) {
+  const file = state.files.find((item) => item.filename === filename);
+  if (!file) return;
+  state.selectedFile = file;
+  $('diff-title').textContent = file.filename;
+  $('diff-stats').innerHTML = '<span class="plus">+' + file.additions + '</span> <span class="minus">-' + file.deletions + '</span>';
+  renderFiles();
+  renderPatch(file);
+}
+
+function renderPatch(file) {
+  const patch = file.patch || 'No textual patch available for this file.';
+  const lines = patch.split('\\n');
+  $('diff-code').innerHTML = lines.map((line, index) => {
+    const cls = line.startsWith('+') ? ' add' : line.startsWith('-') ? ' del' : line.startsWith('@@') ? ' hunk' : '';
+    return '<div class="diff-line' + cls + '">' +
+      '<span class="line-no">' + (index + 1) + '</span>' +
+      '<code class="line-code">' + escapeHtml(line) + '</code>' +
+    '</div>';
+  }).join('');
+}
+
+async function loadPr() {
+  const prUrl = $('pr-url').value.trim();
+  if (!prUrl) {
+    setStatus('Paste a PR URL', 'Use a GitHub pull request URL like https://github.com/owner/repo/pull/123.');
+    return;
+  }
+  setStatus('Loading real PR', 'Fetching metadata and changed files from GitHub...');
+  setLane('diff', 35, 'Fetching PR');
+  const response = await fetch('/api/pr?url=' + encodeURIComponent(prUrl));
+  const payload = await response.json();
+  if (!response.ok) throw new Error(payload.error || 'Failed to load PR');
+  renderPr(payload.pr);
+  setStatus('PR Loaded', 'Ready to run AI review against the real pull request diff.');
+  setLane('diff', 100, 'Parsed ' + payload.pr.files.length + ' files');
+  setConfidence(18);
+}
+
+function startReview() {
+  const prUrl = $('pr-url').value.trim();
+  if (!prUrl) {
+    setStatus('Paste a PR URL', 'Use a GitHub pull request URL before running review.');
+    return;
+  }
+  if (state.eventSource) state.eventSource.close();
+  resetReview();
+  $('review').disabled = true;
+  $('load').disabled = true;
+  $('pr-url').disabled = true;
+  setStatus('AI Review Running', 'Analyzing real PR changes and generating review...');
+  setLane('diff', 20, 'Fetching diff');
+  state.eventSource = new EventSource('/api/review?url=' + encodeURIComponent(prUrl));
+  state.eventSource.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    handleReviewEvent(data);
+  };
+  state.eventSource.onerror = () => {
+    stopReviewControls();
+    setStatus('Review Stream Closed', 'The stream ended or the server returned an error.');
+  };
+}
+
+function stopReviewControls() {
+  $('review').disabled = false;
+  $('load').disabled = false;
+  $('pr-url').disabled = false;
+  if (state.eventSource) {
+    state.eventSource.close();
+    state.eventSource = null;
+  }
+}
+
+function handleReviewEvent(data) {
+  if (data.type === 'pr') {
+    renderPr(data.pr);
+    setLane('diff', 100, 'Parsed real diff');
+    setLane('security', 38, 'Scanning vulnerabilities');
+    setLane('tests', 28, 'Reviewing test coverage');
+    setLane('writer', 18, 'Waiting for findings');
+    setConfidence(28);
+  }
+  if (data.type === 'stage') {
+    setLane(data.lane, data.progress, data.status);
+  }
+  if (data.type === 'activity') {
+    setStatus('AI Review Running', data.message);
+  }
+  if (data.type === 'finding') {
+    addFinding(data.finding);
+  }
+  if (data.type === 'summary') {
+    state.summary = data.summary;
+    renderSummary();
+  }
+  if (data.type === 'done') {
+    setLane('security', 100, 'Complete');
+    setLane('tests', 100, 'Complete');
+    setLane('writer', 100, 'Review drafted');
+    setConfidence(data.findings.length > 0 ? 82 : 91);
+    setStatus('Review Complete', data.summary && data.summary.approve ? 'No blocking findings. Draft is ready.' : 'Findings drafted for this PR.');
+    $('post').disabled = false;
+    stopReviewControls();
+  }
+  if (data.type === 'error') {
+    setStatus('Review Failed', data.message);
+    stopReviewControls();
+  }
+}
+
+function addFinding(finding) {
+  state.findings.push(finding);
+  if (state.findings.length === 1) $('finding-list').innerHTML = '';
+  $('finding-list').insertAdjacentHTML('beforeend', renderFinding(finding));
+  updateCounts();
+  const security = Math.min(100, 45 + count('security') * 18);
+  const tests = Math.min(100, 36 + (count('correctness') + count('performance')) * 14);
+  const writer = Math.min(90, 25 + state.findings.length * 11);
+  setLane('security', security, 'Scanning vulnerabilities');
+  setLane('tests', tests, 'Reviewing impact');
+  setLane('writer', writer, 'Drafting comments');
+  setConfidence(Math.min(84, 38 + state.findings.length * 7));
+}
+
+function renderFinding(finding) {
+  const suggestion = finding.suggestion ? '<div class="suggestion">' + escapeHtml(finding.suggestion) + '</div>' : '';
+  return '<article class="finding">' +
+    '<div class="finding-top">' +
+      '<span class="severity ' + finding.severity + '">' + finding.severity + '</span>' +
+      '<span class="category">' + escapeHtml(finding.category) + '</span>' +
+      '<span class="finding-title">' + escapeHtml(finding.title) + '</span>' +
+      '<span class="location">' + escapeHtml(finding.file) + ':' + finding.line + '</span>' +
+    '</div>' +
+    '<p>' + escapeHtml(finding.comment) + '</p>' +
+    suggestion +
+  '</article>';
+}
+
+function count(category) {
+  return state.findings.filter((finding) => finding.category === category).length;
+}
+
+function updateCounts() {
+  ['security', 'correctness', 'performance', 'maintainability'].forEach((category) => {
+    $('count-' + category).textContent = count(category);
+  });
+  $('finding-count').textContent = state.findings.length + (state.findings.length === 1 ? ' finding' : ' findings');
+}
+
+function renderSummary() {
+  if (!state.summary) return;
+  $('final').innerHTML =
+    '<strong>Decision</strong>' +
+    '<span>' + escapeHtml(state.summary.summary) + '</span>' +
+    '<span>Status: ' + (state.summary.approve ? 'Looks safe to merge after review.' : 'Needs changes before merge.') + '</span>';
+}
+
+function reviewMarkdown() {
+  const lines = [];
+  lines.push('AI Review Bot');
+  lines.push('');
+  if (state.summary) {
+    lines.push(state.summary.summary);
+    lines.push('');
+  }
+  for (const finding of state.findings) {
+    lines.push('- [' + finding.severity.toUpperCase() + '] ' + finding.category + ' - ' + finding.file + ':' + finding.line);
+    lines.push('  ' + finding.title + ': ' + finding.comment);
+    if (finding.suggestion) lines.push('  Suggestion: ' + finding.suggestion);
+  }
+  if (state.findings.length === 0) lines.push('No actionable findings.');
+  return lines.join('\\n');
+}
+
+async function postOrCopyReview() {
+  $('toast').textContent = '';
+  if (!state.postingEnabled) {
+    await navigator.clipboard.writeText(reviewMarkdown());
+    $('toast').textContent = 'Review copied to clipboard.';
+    return;
+  }
+  const response = await fetch('/api/post-review', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      prUrl: $('pr-url').value.trim(),
+      summary: state.summary,
+      findings: state.findings,
+    }),
+  });
+  const payload = await response.json();
+  if (!response.ok) {
+    $('toast').textContent = payload.error || 'Failed to post review.';
+    return;
+  }
+  $('toast').innerHTML = 'Posted review: <a href="' + escapeHtml(payload.url) + '" target="_blank" rel="noreferrer">open comment</a>';
+}
+
+$('url-form').addEventListener('submit', (event) => {
+  event.preventDefault();
+  startReview();
+});
+$('load').addEventListener('click', () => {
+  loadPr().catch((error) => setStatus('Load Failed', error.message));
+});
+$('filter').addEventListener('input', renderFiles);
+$('file-list').addEventListener('click', (event) => {
+  const button = event.target.closest('[data-file]');
+  if (button) selectFile(button.getAttribute('data-file'));
+});
+$('post').addEventListener('click', () => {
+  postOrCopyReview().catch((error) => {
+    $('toast').textContent = error.message;
+  });
+});
+
+init().catch((error) => setStatus('Config Failed', error.message));
+</script>
+</body>
+</html>`;
+
+const server = createServer(async (req, res) => {
+	try {
+		const url = new URL(req.url ?? "/", `http://localhost:${PORT}`);
+
+		if (req.method === "GET" && url.pathname === "/") {
+			res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+			res.end(HTML);
+			return;
+		}
+
+		if (req.method === "GET" && url.pathname === "/api/config") {
+			sendJson(res, 200, {
+				modelId: MODEL_ID,
+				postingEnabled: POSTING_ENABLED,
+			});
+			return;
+		}
+
+		if (req.method === "GET" && url.pathname === "/api/pr") {
+			const prUrl = requiredSearchParam(url, "url");
+			const bundle = await loadPullRequest(prUrl);
+			sendJson(res, 200, { pr: serializePullRequest(bundle) });
+			return;
+		}
+
+		if (req.method === "GET" && url.pathname === "/api/review") {
+			await handleReview(url, res);
+			return;
+		}
+
+		if (req.method === "POST" && url.pathname === "/api/post-review") {
+			await handlePostReview(req, res);
+			return;
+		}
+
+		sendJson(res, 404, { error: "Not found" });
+	} catch (error) {
+		const status = error instanceof HttpError ? error.status : 500;
+		const message = error instanceof Error ? error.message : "Unknown error";
+		sendJson(res, status, { error: message });
+	}
+});
+
+async function handleReview(url: URL, res: ServerResponse) {
+	const prUrl = requiredSearchParam(url, "url");
+	res.writeHead(200, {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive",
+	});
+
+	const send = (data: Record<string, unknown>) => {
+		res.write(`data: ${JSON.stringify(data)}\n\n`);
+	};
+
+	try {
+		send({ type: "stage", lane: "diff", progress: 25, status: "Fetching PR" });
+		const bundle = await loadPullRequest(prUrl);
+		send({ type: "pr", pr: serializePullRequest(bundle) });
+		send({
+			type: "stage",
+			lane: "diff",
+			progress: 100,
+			status: `Parsed ${bundle.files.length} files`,
+		});
+
+		const result = await runAiReview(bundle, send);
+		send({
+			type: "done",
+			findings: result.findings,
+			summary: result.summary,
+			usage: result.usage,
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		send({ type: "error", message });
+	} finally {
+		res.end();
+	}
+}
+
+async function runAiReview(
+	bundle: PullRequestBundle,
+	send: (data: Record<string, unknown>) => void,
+) {
+	const findings: ReviewFinding[] = [];
+	let summary: ReviewSummary | undefined;
+
+	const agent = new Agent({
+		providerId: "cline",
+		modelId: MODEL_ID,
+		apiKey: process.env.CLINE_API_KEY,
+		systemPrompt: `You are a senior code reviewer reviewing real GitHub pull requests.
+
+Use get_file_context when a hunk needs surrounding file context.
+Use add_review_finding only for actionable findings grounded in the diff.
+Severity rules:
+- high: security, data loss, broken auth, broken correctness, or likely production incident
+- medium: real bug risk, missing validation, test gap, or meaningful maintainability issue
+- low: small improvement that still helps the author
+
+Prefer 2-5 findings. If the PR is clean, add no findings and submit an approving summary.
+When finished, call submit_review exactly once.`,
+		maxIterations: 12,
+		tools: [
+			createTool({
+				name: "get_file_context",
+				description:
+					"Read the full file contents from the pull request head commit for more context.",
+				inputSchema: z.object({
+					path: z.string().describe("Path relative to the repository root"),
+				}),
+				async execute(input) {
+					send({
+						type: "activity",
+						message: `Reading context for ${input.path}`,
+					});
+					return fetchFileContext(bundle, input.path);
+				},
+			}),
+			createTool({
+				name: "add_review_finding",
+				description: "Add a structured review finding for this pull request.",
+				inputSchema: ReviewFindingInputSchema,
+				async execute(input) {
+					const finding = {
+						id: `F-${String(findings.length + 1).padStart(2, "0")}`,
+						...input,
+					};
+					findings.push(finding);
+					send({ type: "finding", finding });
+					return `Finding ${finding.id} added`;
+				},
+			}),
+			createTool({
+				name: "submit_review",
+				description: "Submit the completed pull request review.",
+				inputSchema: ReviewSummarySchema,
+				lifecycle: { completesRun: true },
+				async execute(input) {
+					summary = input;
+					send({ type: "summary", summary });
+					return JSON.stringify({
+						approve: input.approve,
+						findingCount: findings.length,
+					});
+				},
+			}),
+		],
+	});
+
+	agent.subscribe((event) => {
+		if (event.type === "assistant-text-delta") {
+			send({ type: "activity", message: "Reviewing diff with AI reviewer..." });
+		}
+		if (event.type === "tool-started") {
+			send({
+				type: "stage",
+				lane: "writer",
+				progress: Math.min(92, 30 + findings.length * 10),
+				status: `Calling ${event.toolCall.toolName}`,
+			});
+		}
+	});
+
+	send({
+		type: "stage",
+		lane: "security",
+		progress: 44,
+		status: "Scanning vulnerabilities",
+	});
+	send({
+		type: "stage",
+		lane: "tests",
+		progress: 36,
+		status: "Reviewing tests",
+	});
+	send({
+		type: "stage",
+		lane: "writer",
+		progress: 22,
+		status: "Drafting findings",
+	});
+
+	const diff = truncateText(bundle.diff, MAX_DIFF_CHARS);
+	const fileSummary = bundle.files
+		.map(
+			(file) =>
+				`- ${file.filename} (${file.status}, +${file.additions}/-${file.deletions})`,
+		)
+		.join("\n");
+
+	const result = await agent.run(`Review this real GitHub pull request.
+
+Repository: ${bundle.ref.owner}/${bundle.ref.repo}
+Pull Request: #${bundle.pr.number} ${bundle.pr.title}
+Author: ${bundle.pr.user.login}
+Branch: ${bundle.pr.head.ref} -> ${bundle.pr.base.ref}
+URL: ${bundle.pr.html_url}
+Files:
+${fileSummary}
+
+Diff:
+\`\`\`diff
+${diff}
+\`\`\`
+`);
+
+	return {
+		findings,
+		summary,
+		usage: result.usage,
+	};
+}
+
+async function handlePostReview(req: IncomingMessage, res: ServerResponse) {
+	if (!POSTING_ENABLED) {
+		throw new HttpError(
+			403,
+			"Posting is disabled. Set ENABLE_GITHUB_REVIEW_POSTING=1 and GITHUB_TOKEN to enable it.",
+		);
+	}
+
+	const input = PostReviewRequestSchema.parse(await readJson(req));
+	const ref = parsePullRequestUrl(input.prUrl);
+	const body = formatReviewComment(input.summary, input.findings);
+	const posted = await githubJson<{ html_url: string }>(
+		`https://api.github.com/repos/${ref.owner}/${ref.repo}/issues/${ref.number}/comments`,
+		{
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ body }),
+		},
+	);
+
+	sendJson(res, 200, { url: posted.html_url });
+}
+
+async function loadPullRequest(prUrl: string): Promise<PullRequestBundle> {
+	const ref = parsePullRequestUrl(prUrl);
+	const pr = await githubJson<GitHubPullRequest>(
+		`https://api.github.com/repos/${ref.owner}/${ref.repo}/pulls/${ref.number}`,
+	);
+	const [files, diff, checks] = await Promise.all([
+		githubPaged<GitHubPullFile>(
+			`https://api.github.com/repos/${ref.owner}/${ref.repo}/pulls/${ref.number}/files`,
+		),
+		githubText(
+			`https://api.github.com/repos/${ref.owner}/${ref.repo}/pulls/${ref.number}`,
+			{
+				headers: { Accept: "application/vnd.github.v3.diff" },
+			},
+		),
+		loadChecks(ref, pr.head.sha),
+	]);
+
+	return { ref, pr, files, diff, checks };
+}
+
+async function loadChecks(ref: PullRequestRef, sha: string) {
+	try {
+		const [status, checks] = await Promise.all([
+			githubJson<CombinedStatusResponse>(
+				`https://api.github.com/repos/${ref.owner}/${ref.repo}/commits/${sha}/status`,
+			),
+			githubJson<CheckRunsResponse>(
+				`https://api.github.com/repos/${ref.owner}/${ref.repo}/commits/${sha}/check-runs`,
+			),
+		]);
+		const failedChecks = checks.check_runs.filter((run) =>
+			["failure", "timed_out", "cancelled"].includes(run.conclusion ?? ""),
+		);
+		const pendingChecks = checks.check_runs.filter(
+			(run) => run.status !== "completed",
+		);
+		if (failedChecks.length > 0 || status.state === "failure") return "failing";
+		if (pendingChecks.length > 0 || status.state === "pending")
+			return "pending";
+		if (checks.total_count > 0 || status.total_count > 0) return "passing";
+		return "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+
+async function fetchFileContext(bundle: PullRequestBundle, filePath: string) {
+	if (filePath.startsWith("/") || filePath.includes("..")) {
+		return `Error: invalid file path ${filePath}`;
+	}
+
+	const encodedPath = filePath
+		.split("/")
+		.map((part) => encodeURIComponent(part))
+		.join("/");
+	const response = await githubFetch(
+		`https://api.github.com/repos/${bundle.ref.owner}/${bundle.ref.repo}/contents/${encodedPath}?ref=${encodeURIComponent(bundle.pr.head.sha)}`,
+		{ headers: { Accept: "application/vnd.github.raw" } },
+	);
+	const text = await response.text();
+	return truncateText(text, MAX_FILE_CONTEXT_CHARS);
+}
+
+function serializePullRequest(bundle: PullRequestBundle) {
+	return {
+		owner: bundle.ref.owner,
+		repo: bundle.ref.repo,
+		number: bundle.pr.number,
+		title: bundle.pr.title,
+		state: bundle.pr.draft ? "draft" : bundle.pr.state,
+		url: bundle.pr.html_url,
+		author: bundle.pr.user.login,
+		baseRef: bundle.pr.base.ref,
+		headRef: bundle.pr.head.ref,
+		headSha: bundle.pr.head.sha,
+		additions: bundle.pr.additions,
+		deletions: bundle.pr.deletions,
+		changedFiles: bundle.pr.changed_files,
+		comments: bundle.pr.comments,
+		reviewComments: bundle.pr.review_comments,
+		commits: bundle.pr.commits,
+		checks: bundle.checks,
+		files: bundle.files.map((file) => ({
+			filename: file.filename,
+			status: file.status,
+			additions: file.additions,
+			deletions: file.deletions,
+			changes: file.changes,
+			patch: file.patch ?? "",
+		})),
+	};
+}
+
+function parsePullRequestUrl(input: string): PullRequestRef {
+	const trimmed = input.trim();
+	const urlMatch = trimmed.match(
+		/^https?:\/\/github\.com\/([^/\s]+)\/([^/\s]+)\/pull\/(\d+)(?:[/?#].*)?$/,
+	);
+	const shortMatch = trimmed.match(/^([^/\s]+)\/([^#\s]+)#(\d+)$/);
+	const match = urlMatch ?? shortMatch;
+
+	if (!match) {
+		throw new HttpError(
+			400,
+			"Expected a GitHub PR URL like https://github.com/owner/repo/pull/123",
+		);
+	}
+
+	return {
+		owner: match[1],
+		repo: match[2].replace(/\.git$/, ""),
+		number: Number(match[3]),
+	};
+}
+
+async function githubPaged<T>(baseUrl: string): Promise<T[]> {
+	const results: T[] = [];
+	for (let page = 1; page <= 5; page++) {
+		const separator = baseUrl.includes("?") ? "&" : "?";
+		const pageResults = await githubJson<T[]>(
+			`${baseUrl}${separator}per_page=100&page=${page}`,
+		);
+		results.push(...pageResults);
+		if (pageResults.length < 100) break;
+	}
+	return results;
+}
+
+async function githubJson<T>(url: string, init: RequestInit = {}): Promise<T> {
+	const response = await githubFetch(url, init);
+	return (await response.json()) as T;
+}
+
+async function githubText(url: string, init: RequestInit = {}) {
+	const response = await githubFetch(url, init);
+	return response.text();
+}
+
+async function githubFetch(url: string, init: RequestInit = {}) {
+	const headers = new Headers(init.headers);
+	if (!headers.has("Accept"))
+		headers.set("Accept", "application/vnd.github+json");
+	headers.set("User-Agent", "cline-sdk-code-review-bot-example");
+	headers.set("X-GitHub-Api-Version", "2022-11-28");
+	if (GITHUB_TOKEN) headers.set("Authorization", `Bearer ${GITHUB_TOKEN}`);
+
+	if (!url.startsWith("https://api.github.com/")) {
+		throw new HttpError(400, "Invalid GitHub API URL");
+	}
+
+	const response = await fetch(url, { ...init, headers });
+	if (!response.ok) {
+		const body = await response.text();
+		throw new HttpError(
+			response.status,
+			`GitHub request failed (${response.status}): ${body.slice(0, 300)}`,
+		);
+	}
+	return response;
+}
+
+function requiredSearchParam(url: URL, key: string) {
+	const value = url.searchParams.get(key);
+	if (!value) throw new HttpError(400, `Missing query parameter: ${key}`);
+	return value;
+}
+
+async function readJson(req: IncomingMessage) {
+	const chunks: Buffer[] = [];
+	for await (const chunk of req) {
+		chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	}
+	const text = Buffer.concat(chunks).toString("utf-8");
+	return text ? JSON.parse(text) : {};
+}
+
+function sendJson(res: ServerResponse, status: number, body: unknown) {
+	res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
+}
+
+function truncateText(value: string, maxChars: number) {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars)}\n\n[truncated ${value.length - maxChars} characters]`;
+}
+
+function formatReviewComment(
+	summary: ReviewSummary | undefined,
+	findings: ReviewFindingInput[],
+) {
+	const lines = ["## AI Review Bot", ""];
+	if (summary) {
+		lines.push(summary.summary, "");
+		lines.push(
+			summary.approve
+				? "**Status:** Looks safe to merge."
+				: "**Status:** Changes requested.",
+			"",
+		);
+	}
+
+	if (findings.length === 0) {
+		lines.push("No actionable findings.");
+		return lines.join("\n");
+	}
+
+	for (const finding of findings) {
+		lines.push(
+			`- **${finding.severity.toUpperCase()} ${finding.category}** \`${finding.file}:${finding.line}\``,
+		);
+		lines.push(`  - ${finding.title}`);
+		lines.push(`  - ${finding.comment}`);
+		if (finding.suggestion) lines.push(`  - Suggestion: ${finding.suggestion}`);
+	}
+
+	return lines.join("\n");
+}
+
+server.listen(PORT, () => {
+	console.log(`Code review bot dashboard running at http://localhost:${PORT}`);
+	console.log("Paste a GitHub pull request URL to review a real PR.");
+});
diff --git a/apps/examples/code-review-bot/tsconfig.json b/apps/examples/code-review-bot/tsconfig.json
new file mode 100644
index 0000000..9c69339
--- /dev/null
+++ b/apps/examples/code-review-bot/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"outDir": "dist",
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true
+	},
+	"include": ["src"]
+}
diff --git a/apps/examples/desktop-app/README.md b/apps/examples/desktop-app/README.md
new file mode 100644
index 0000000..96ae1fa
--- /dev/null
+++ b/apps/examples/desktop-app/README.md
@@ -0,0 +1,109 @@
+# Desktop App Example
+
+Tauri desktop shell + Bun sidecar backend + Next.js UI for running and inspecting Cline chat sessions.
+
+## Dev Commands
+
+From `apps/examples/desktop-app/`:
+
+- `bun run dev:web` - Next.js UI only (`http://localhost:3125`)
+- `bun run dev:sidecar` - sidecar backend only
+- `bun run dev` - Tauri desktop dev
+- `bun run build` - build web assets
+- `bun run build:sidecar` - build the Bun sidecar bundle
+- `bun run build:sidecar:bin` - compile the Bun sidecar into a local binary
+- `bun run build:binary` - build desktop binary
+- `bun run package:desktop` - package the current OS desktop app into `dist/desktop/`
+- `bun run typecheck` - TypeScript check
+
+## Shareable Desktop Packages
+
+Tauri desktop bundles are OS-specific, so build each package on the target OS:
+
+- macOS: `bun run package:desktop:mac`
+- Windows: `bun run package:desktop:windows`
+- Linux: `bun run package:desktop:linux`
+
+The macOS package script refuses to create a shareable package unless Developer ID signing and notarization credentials are configured. This prevents the common Gatekeeper failure where a downloaded unsigned build appears damaged on a teammate's Mac.
+
+Set either `APPLE_CERTIFICATE` or `APPLE_SIGNING_IDENTITY`, plus one notarization credential set before packaging macOS:
+
+- `APPLE_ID`, `APPLE_PASSWORD`, `APPLE_TEAM_ID`
+- `APPLE_API_KEY` or `APPLE_API_KEY_PATH`, `APPLE_API_KEY_ID`, `APPLE_API_ISSUER`
+
+For local-only macOS testing, use `bun run package:desktop:mac --allow-unsigned-mac`. That ad-hoc signs the `.app` and strips quarantine attributes, but it is not suitable for a downloaded build shared with teammates.
+
+### macOS signing & notarization, step by step
+
+One-time keychain setup:
+
+1. Get the **Developer ID Application** identity from your team admin. A `.cer` alone is not enough — you need the private key. If the admin generated the CSR, have them export the identity from Keychain Access as a `.p12` and import it:
+   `security import BeeCertificates.p12 -k ~/Library/Keychains/login.keychain-db -T /usr/bin/codesign -T /usr/bin/security`
+2. If `security find-identity -v -p codesigning` still reports `0 valid identities`, the Apple intermediate CA is missing. Install it:
+   `curl -O https://www.apple.com/certificateauthority/DeveloperIDG2CA.cer && security import DeveloperIDG2CA.cer -k ~/Library/Keychains/login.keychain-db`
+3. Re-run `security find-identity -v -p codesigning` — it should now list `Developer ID Application: <Team Name> (<TEAMID>)`. That exact quoted string is your `APPLE_SIGNING_IDENTITY`.
+4. Get an **App Store Connect API key** from the admin: the `AuthKey_<KEYID>.p8` file, the Key ID, and the Issuer ID (a UUID from App Store Connect → Users and Access → Integrations). This is used for notarization only — nothing is published.
+
+Per-build:
+
+```bash
+export APPLE_SIGNING_IDENTITY="Developer ID Application: <Team Name> (<TEAMID>)"
+export APPLE_API_KEY="<KEYID>"           # Tauri reads APPLE_API_KEY (the Key ID); APPLE_API_KEY_ID alone silently skips notarization
+export APPLE_API_KEY_PATH="/path/to/AuthKey_<KEYID>.p8"
+export APPLE_API_ISSUER="<issuer UUID>"
+bun run package:desktop:mac
+```
+
+The first signing run pops a keychain dialog — enter your macOS login password and click **Always Allow**. Notarization uploads the app to Apple's automated malware scan (typically 2–10 minutes) and staples the ticket. Artifacts land in `dist/desktop/`; share the `.dmg`. The DMG name takes its version from `src-tauri/tauri.conf.json`, the zip name from `package.json` — bump both.
+
+Do not remove `src-tauri/entitlements.plist` or the `bundle.macOS.entitlements` reference in `tauri.conf.json`: notarization requires the hardened runtime, which breaks the Bun-compiled sidecar (`SharedArrayBuffer is not defined`, surfacing in-app as "desktop backend endpoint not ready") unless the JIT entitlements are present.
+
+## Runtime Overview
+
+Startup flow:
+
+1. Tauri starts a persistent local desktop backend and keeps only native window/file-picker/open-path responsibilities.
+2. The desktop backend starts the Bun sidecar and exposes one websocket transport (`/transport`) for commands, queries, and pushed events.
+3. The React app uses `lib/desktop-client.ts` and no longer imports `@tauri-apps/api/core` directly in feature code.
+4. Tool approval updates are pushed from the backend instead of polled from the UI.
+5. Session process context resolves `workspaceRoot` from git root and uses that same path as default `cwd` for chat runtime and git operations unless explicitly overridden.
+
+Desktop transport envelope:
+
+- Request: `{ "type": "command", "id": string, "command": string, "args"?: object }`
+- Response: `{ "type": "response", "id": string, "ok": boolean, "result"?: unknown, "error"?: string }`
+- Event: `{ "type": "event", "event": { "name": string, "payload": unknown } }`
+
+## Settings: Routine
+
+- The Settings sidebar includes a `Routine` view for hub-backed automations.
+- `Routine` lists all RPC schedules and shows status (`enabled`, `nextRunAt`, active execution).
+- From the UI you can open a create form and add, pause/resume, trigger-now, and delete schedules.
+- The view is wired to the same scheduler APIs used by `cline schedule` through Tauri commands and `scripts/routine-schedules.ts`.
+
+## Key Files
+
+- [`src-tauri/src/main.rs`](./src-tauri/src/main.rs) - Tauri shell lifecycle, backend launch, and native-only commands
+- [`sidecar/index.ts`](./sidecar/index.ts) - persistent Bun sidecar backend
+- [`sidecar/chat-session.ts`](./sidecar/chat-session.ts) - in-process chat session runtime
+- [`webview/lib/desktop-client.ts`](./webview/lib/desktop-client.ts) - typed desktop websocket client
+- [`webview/hooks/use-chat-session.ts`](./webview/hooks/use-chat-session.ts) - UI chat session state + backend subscriptions
+- [`webview/lib/chat-schema.ts`](./webview/lib/chat-schema.ts) - chat message schema used by the UI
+- [`webview/components/views/settings/routine-view.tsx`](./webview/components/views/settings/routine-view.tsx) - Routine schedules UI
+
+## Data + Storage
+
+- Session artifacts are written under `~/.cline/data/sessions/<sessionId>/` (or `CLINE_SESSION_DATA_DIR`).
+- Canonical replay/export artifact: `<sessionId>.messages.json`.
+- `<sessionId>.messages.json` is expected to contain ordered messages plus assistant `modelInfo` and `metrics` (including cache token fields when provided by the model runtime).
+- `<sessionId>.hooks.jsonl` is observability/debug telemetry and should not be required for normal history replay/export flows.
+- Full v1 schema for the persisted messages file, including failure/retry semantics and golden fixtures, is documented in [`packages/core/docs/messages-contract-v1.md`](../../../sdk/packages/core/docs/messages-contract-v1.md).
+
+## Troubleshooting
+
+- If live updates stall, verify the desktop backend websocket is connected and `chat_event` messages are arriving.
+- Tauri restarts the desktop backend if the sidecar process exits and kills it on app teardown.
+- Chat sends now preflight provider credentials. If a provider that requires API-key auth is selected without a key, the UI blocks the turn with a clear error message instead of starting a hanging session.
+- If a turn completes with `finishReason=error` before any assistant content is produced, the UI now adds an explicit error chat message so failed turns are visible in the transcript.
+- If package changes are not reflected, rebuild SDK packages (`bun run build:sdk`). The next `cline rpc ensure` call should attach to the current build's sidecar automatically.
+- Provider settings updates are patch-style: only fields you edit are changed. Unset fields are preserved instead of being cleared.
diff --git a/apps/examples/desktop-app/bun.mts b/apps/examples/desktop-app/bun.mts
new file mode 100644
index 0000000..ec8dc25
--- /dev/null
+++ b/apps/examples/desktop-app/bun.mts
@@ -0,0 +1,11 @@
+import { $ } from "bun";
+
+const main = async () => {
+	await $`next build`.cwd("webview");
+	await $`bun run build:sidecar:bin`;
+};
+
+main().catch((error: unknown) => {
+	console.error(error);
+	process.exitCode = 1;
+});
diff --git a/apps/examples/desktop-app/global.d.ts b/apps/examples/desktop-app/global.d.ts
new file mode 100644
index 0000000..cbe652d
--- /dev/null
+++ b/apps/examples/desktop-app/global.d.ts
@@ -0,0 +1 @@
+declare module "*.css";
diff --git a/apps/examples/desktop-app/package.json b/apps/examples/desktop-app/package.json
new file mode 100644
index 0000000..6665f4e
--- /dev/null
+++ b/apps/examples/desktop-app/package.json
@@ -0,0 +1,96 @@
+{
+	"name": "@cline/code",
+	"version": "0.0.1",
+	"private": true,
+	"scripts": {
+		"dev:web": "next dev webview -p 3125 --turbo",
+		"dev:sidecar": "bun run sidecar/index.ts",
+		"dev": "tauri dev",
+		"build": "bun run bun.mts",
+		"build:sidecar": "mkdir -p dist/sidecar && bun build ./sidecar/index.ts --outfile ./dist/sidecar/index.js --target bun",
+		"build:sidecar:bin": "bun run scripts/build-sidecar-bin.ts",
+		"build:binary": "tauri build",
+		"package": "bun run package:desktop",
+		"package:desktop": "bun run scripts/package-desktop.ts",
+		"package:desktop:mac": "bun run scripts/package-desktop.ts --platform mac",
+		"package:desktop:windows": "bun run scripts/package-desktop.ts --platform windows",
+		"package:desktop:linux": "bun run scripts/package-desktop.ts --platform linux",
+		"start": "next start webview",
+		"typecheck": "tsc -p tsconfig.dev.json --noEmit",
+		"clean": "rm -rf webview/.next webview/out node_modules dist && (cd src-tauri && rm -rf target node_modules dist)"
+	},
+	"dependencies": {
+		"@base-ui/react": "^1.2.0",
+		"@cline/core": "workspace:*",
+		"@cline/llms": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"@fontsource-variable/schibsted-grotesk": "^5.2.8",
+		"@fontsource/azeret-mono": "^5.2.9",
+		"@hookform/resolvers": "^3.9.1",
+		"@radix-ui/react-accordion": "1.2.12",
+		"@radix-ui/react-alert-dialog": "1.1.15",
+		"@radix-ui/react-aspect-ratio": "1.1.8",
+		"@radix-ui/react-avatar": "1.1.11",
+		"@radix-ui/react-checkbox": "1.3.3",
+		"@radix-ui/react-collapsible": "1.1.12",
+		"@radix-ui/react-context-menu": "2.2.16",
+		"@radix-ui/react-dialog": "1.1.15",
+		"@radix-ui/react-dropdown-menu": "2.1.16",
+		"@radix-ui/react-hover-card": "1.1.15",
+		"@radix-ui/react-label": "2.1.8",
+		"@radix-ui/react-menubar": "1.1.16",
+		"@radix-ui/react-navigation-menu": "1.2.14",
+		"@radix-ui/react-popover": "1.1.15",
+		"@radix-ui/react-progress": "1.1.8",
+		"@radix-ui/react-radio-group": "1.3.8",
+		"@radix-ui/react-scroll-area": "1.2.10",
+		"@radix-ui/react-select": "2.2.6",
+		"@radix-ui/react-separator": "1.1.8",
+		"@radix-ui/react-slider": "1.3.6",
+		"@radix-ui/react-slot": "1.2.4",
+		"@radix-ui/react-switch": "1.2.6",
+		"@radix-ui/react-tabs": "1.1.13",
+		"@radix-ui/react-toast": "1.2.15",
+		"@radix-ui/react-toggle": "1.1.10",
+		"@radix-ui/react-toggle-group": "1.1.11",
+		"@radix-ui/react-tooltip": "1.2.8",
+		"@tauri-apps/api": "^2.0.0",
+		"@vercel/analytics": "1.6.1",
+		"autoprefixer": "^10.4.20",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"cmdk": "1.1.1",
+		"date-fns": "4.1.0",
+		"embla-carousel-react": "8.6.0",
+		"input-otp": "1.4.2",
+		"lucide-react": "^0.564.0",
+		"marked": "^17.0.3",
+		"next": "16.2.6",
+		"next-themes": "^0.4.6",
+		"radix-ui": "^1.4.3",
+		"react": "19.2.4",
+		"react-day-picker": "9.13.2",
+		"react-dom": "19.2.4",
+		"react-hook-form": "^7.54.1",
+		"react-markdown": "^10.1.0",
+		"react-resizable-panels": "^2.1.7",
+		"recharts": "2.15.0",
+		"remark-gfm": "^4.0.1",
+		"sonner": "^1.7.1",
+		"tailwind-merge": "^3.3.1",
+		"vaul": "^1.1.2",
+		"zod": "^3.24.1"
+	},
+	"devDependencies": {
+		"@tauri-apps/cli": "^2.0.0",
+		"@tailwindcss/postcss": "^4.2.0",
+		"@types/react": "19.2.14",
+		"@types/react-dom": "19.2.3",
+		"postcss": "^8.5",
+		"tailwindcss": "^4.2.0",
+		"tw-animate-css": "1.3.3",
+		"typescript": "5.7.3",
+		"vitest": "^4.0.18",
+		"@types/bun": "^1.3.14"
+	}
+}
diff --git a/apps/examples/desktop-app/scripts/build-sidecar-bin.ts b/apps/examples/desktop-app/scripts/build-sidecar-bin.ts
new file mode 100644
index 0000000..bd21fea
--- /dev/null
+++ b/apps/examples/desktop-app/scripts/build-sidecar-bin.ts
@@ -0,0 +1,32 @@
+import { $ } from "bun";
+
+const resolveTargetTriple = async (): Promise<string> => {
+	const fromEnv = process.env.TAURI_ENV_TARGET_TRIPLE ?? process.env.TARGET;
+	if (fromEnv?.trim()) {
+		return fromEnv.trim();
+	}
+
+	const rustcVersion = await $`rustc -vV`.text();
+	const hostLine = rustcVersion
+		.split("\n")
+		.find((line) => line.startsWith("host: "));
+	const host = hostLine?.slice("host: ".length).trim();
+	if (!host) {
+		throw new Error("failed to resolve Rust host target triple");
+	}
+	return host;
+};
+
+const main = async () => {
+	const targetTriple = await resolveTargetTriple();
+	const extension = targetTriple.includes("windows") ? ".exe" : "";
+	const outfile = `./src-tauri/bin/code-sidecar-${targetTriple}${extension}`;
+
+	await $`mkdir -p src-tauri/bin`;
+	await $`bun build ./sidecar/index.ts --compile --outfile ${outfile}`;
+};
+
+main().catch((error: unknown) => {
+	console.error(error);
+	process.exitCode = 1;
+});
diff --git a/apps/examples/desktop-app/scripts/package-desktop.ts b/apps/examples/desktop-app/scripts/package-desktop.ts
new file mode 100644
index 0000000..deeb13c
--- /dev/null
+++ b/apps/examples/desktop-app/scripts/package-desktop.ts
@@ -0,0 +1,311 @@
+import {
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	rmSync,
+	statSync,
+} from "node:fs";
+import path from "node:path";
+import { $ } from "bun";
+
+type DesktopPlatform = "mac" | "windows" | "linux";
+
+const BOOLEAN_FLAGS = new Set(["--allow-unsigned-mac", "--skip-build"]);
+const VALUE_FLAGS = new Set(["--platform", "--target"]);
+const VALID_FLAGS = [...BOOLEAN_FLAGS, ...VALUE_FLAGS];
+
+const APP_NAME = "Cline Code";
+const APP_ROOT = path.resolve(import.meta.dir, "..");
+const BUNDLE_ROOT = path.join(
+	APP_ROOT,
+	"src-tauri",
+	"target",
+	"release",
+	"bundle",
+);
+const PACKAGE_ROOT = path.join(APP_ROOT, "dist", "desktop");
+
+process.chdir(APP_ROOT);
+
+const validateArgs = (): void => {
+	const args = process.argv.slice(2);
+
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (BOOLEAN_FLAGS.has(arg)) {
+			continue;
+		}
+
+		if (VALUE_FLAGS.has(arg)) {
+			const value = args[index + 1];
+			if (!value || value.startsWith("--")) {
+				throw new Error(`missing value for ${arg}`);
+			}
+			index += 1;
+			continue;
+		}
+
+		if (VALID_FLAGS.some((flag) => arg.startsWith(`${flag}=`))) {
+			continue;
+		}
+
+		if (arg.startsWith("--")) {
+			const suggestion = VALID_FLAGS.find((flag) => flag.startsWith(arg));
+			throw new Error(
+				suggestion
+					? `unknown option ${arg}. Did you mean ${suggestion}?`
+					: `unknown option ${arg}`,
+			);
+		}
+
+		throw new Error(`unexpected argument ${arg}`);
+	}
+};
+
+const getArgValue = (name: string): string | undefined => {
+	const prefix = `${name}=`;
+	const inline = process.argv.find((arg) => arg.startsWith(prefix));
+	if (inline) {
+		return inline.slice(prefix.length);
+	}
+
+	const index = process.argv.indexOf(name);
+	if (index >= 0) {
+		return process.argv[index + 1];
+	}
+
+	return undefined;
+};
+
+const hasArg = (name: string): boolean => process.argv.includes(name);
+
+const hostPlatform = (): DesktopPlatform => {
+	if (process.platform === "darwin") {
+		return "mac";
+	}
+	if (process.platform === "win32") {
+		return "windows";
+	}
+	if (process.platform === "linux") {
+		return "linux";
+	}
+	throw new Error(`unsupported desktop packaging host: ${process.platform}`);
+};
+
+const resolveRequestedPlatform = (): DesktopPlatform => {
+	const platform =
+		getArgValue("--platform") ?? getArgValue("--target") ?? "current";
+	if (platform === "current") {
+		return hostPlatform();
+	}
+	if (platform === "mac" || platform === "windows" || platform === "linux") {
+		return platform;
+	}
+	throw new Error(
+		`unsupported platform "${platform}". Use mac, windows, linux, or current.`,
+	);
+};
+
+const sanitizeName = (value: string): string =>
+	value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-|-$/g, "");
+
+const packageVersion = async (): Promise<string> => {
+	const packageJson = await Bun.file(
+		path.join(APP_ROOT, "package.json"),
+	).json();
+	return String(packageJson.version ?? "0.0.0");
+};
+
+const macDistributionCredentialsConfigured = (): boolean => {
+	const hasCertificate = Boolean(
+		process.env.APPLE_CERTIFICATE || process.env.APPLE_SIGNING_IDENTITY,
+	);
+	const hasAppleIdNotarization = Boolean(
+		process.env.APPLE_ID &&
+			process.env.APPLE_PASSWORD &&
+			process.env.APPLE_TEAM_ID,
+	);
+	const hasApiKeyNotarization = Boolean(
+		(process.env.APPLE_API_KEY || process.env.APPLE_API_KEY_PATH) &&
+			process.env.APPLE_API_KEY_ID &&
+			process.env.APPLE_API_ISSUER,
+	);
+	return hasCertificate && (hasAppleIdNotarization || hasApiKeyNotarization);
+};
+
+const assertCanBuildPlatform = (platform: DesktopPlatform): void => {
+	const host = hostPlatform();
+	if (platform !== host) {
+		throw new Error(
+			[
+				`cannot build ${platform} desktop bundles from ${host}.`,
+				"Tauri desktop bundles are produced on the target OS because the native bundle tools and sidecar binary are platform-specific.",
+				"Run this same package script on macOS, Windows, and Linux runners to produce all three artifact sets.",
+			].join("\n"),
+		);
+	}
+};
+
+const assertMacDistributionReady = (allowUnsignedMac: boolean): void => {
+	if (hostPlatform() !== "mac") {
+		return;
+	}
+	if (macDistributionCredentialsConfigured() || allowUnsignedMac) {
+		return;
+	}
+
+	throw new Error(
+		[
+			"refusing to create a shareable macOS package without Developer ID signing and notarization credentials.",
+			"Unsigned quarantined macOS downloads can show as damaged on a teammate's Mac.",
+			"Set APPLE_CERTIFICATE or APPLE_SIGNING_IDENTITY plus notarization credentials before running this script.",
+			"Supported notarization env sets: APPLE_ID + APPLE_PASSWORD + APPLE_TEAM_ID, or APPLE_API_KEY/APPLE_API_KEY_PATH + APPLE_API_KEY_ID + APPLE_API_ISSUER.",
+			"For local-only testing, rerun with --allow-unsigned-mac or ALLOW_UNSIGNED_MAC=1.",
+		].join("\n"),
+	);
+};
+
+const walkFiles = (root: string): string[] => {
+	if (!existsSync(root)) {
+		return [];
+	}
+
+	const paths: string[] = [];
+	for (const entry of readdirSync(root)) {
+		const fullPath = path.join(root, entry);
+		const stats = statSync(fullPath);
+		if (stats.isDirectory()) {
+			paths.push(...walkFiles(fullPath));
+			continue;
+		}
+		paths.push(fullPath);
+	}
+	return paths;
+};
+
+const copyArtifact = (source: string, outputName: string): string => {
+	const destination = path.join(PACKAGE_ROOT, outputName);
+	rmSync(destination, { force: true, recursive: true });
+	cpSync(source, destination, { recursive: true });
+	return destination;
+};
+
+const signUnsignedMacApp = async (appPath: string): Promise<void> => {
+	await $`codesign --force --deep --sign - ${appPath}`;
+	await $`codesign --verify --deep --strict --verbose=2 ${appPath}`;
+	await $`xattr -cr ${appPath}`;
+};
+
+const verifySignedMacApp = async (appPath: string): Promise<void> => {
+	await $`codesign --verify --deep --strict --verbose=2 ${appPath}`;
+	await $`spctl --assess --type execute --verbose ${appPath}`;
+	await $`xattr -cr ${appPath}`;
+};
+
+const collectMacArtifacts = async (
+	version: string,
+	allowUnsignedMac: boolean,
+): Promise<string[]> => {
+	const appPath = path.join(BUNDLE_ROOT, "macos", `${APP_NAME}.app`);
+	if (!existsSync(appPath)) {
+		throw new Error(`macOS app bundle was not created at ${appPath}`);
+	}
+
+	if (allowUnsignedMac && !macDistributionCredentialsConfigured()) {
+		console.warn(
+			"creating a local-only ad-hoc signed macOS package; this is not suitable for quarantined downloads.",
+		);
+		await signUnsignedMacApp(appPath);
+	} else {
+		await verifySignedMacApp(appPath);
+	}
+
+	const arch = process.arch === "arm64" ? "arm64" : "x64";
+	const suffix =
+		allowUnsignedMac && !macDistributionCredentialsConfigured()
+			? "-local-unsigned"
+			: "";
+	const zipName = `${sanitizeName(APP_NAME)}-${version}-macos-${arch}${suffix}.zip`;
+	const zipPath = path.join(PACKAGE_ROOT, zipName);
+	rmSync(zipPath, { force: true });
+	await $`ditto -c -k --keepParent ${appPath} ${zipPath}`;
+
+	const artifacts = [zipPath];
+	if (!suffix) {
+		for (const dmgPath of walkFiles(path.join(BUNDLE_ROOT, "dmg")).filter(
+			(file) => file.endsWith(".dmg"),
+		)) {
+			artifacts.push(copyArtifact(dmgPath, path.basename(dmgPath)));
+		}
+	}
+
+	return artifacts;
+};
+
+const collectWindowsArtifacts = (): string[] =>
+	walkFiles(BUNDLE_ROOT)
+		.filter((file) => file.endsWith(".msi") || file.endsWith(".exe"))
+		.map((file) => copyArtifact(file, path.basename(file)));
+
+const collectLinuxArtifacts = (): string[] =>
+	walkFiles(BUNDLE_ROOT)
+		.filter(
+			(file) =>
+				file.endsWith(".AppImage") ||
+				file.endsWith(".deb") ||
+				file.endsWith(".rpm"),
+		)
+		.map((file) => copyArtifact(file, path.basename(file)));
+
+const collectArtifacts = async (
+	platform: DesktopPlatform,
+	allowUnsignedMac: boolean,
+): Promise<string[]> => {
+	const version = await packageVersion();
+	rmSync(PACKAGE_ROOT, { force: true, recursive: true });
+	mkdirSync(PACKAGE_ROOT, { recursive: true });
+
+	if (platform === "mac") {
+		return collectMacArtifacts(version, allowUnsignedMac);
+	}
+	if (platform === "windows") {
+		return collectWindowsArtifacts();
+	}
+	return collectLinuxArtifacts();
+};
+
+const main = async () => {
+	validateArgs();
+
+	const platform = resolveRequestedPlatform();
+	const allowUnsignedMac =
+		hasArg("--allow-unsigned-mac") || process.env.ALLOW_UNSIGNED_MAC === "1";
+	const skipBuild = hasArg("--skip-build");
+
+	assertCanBuildPlatform(platform);
+	if (platform === "mac") {
+		assertMacDistributionReady(allowUnsignedMac);
+	}
+
+	if (!skipBuild) {
+		await $`bun run build:binary`;
+	}
+
+	const artifacts = await collectArtifacts(platform, allowUnsignedMac);
+	if (artifacts.length === 0) {
+		throw new Error(
+			`no ${platform} desktop artifacts were found under ${BUNDLE_ROOT}`,
+		);
+	}
+
+	console.log(`Packaged ${platform} desktop artifacts:`);
+	for (const artifact of artifacts) {
+		console.log(`- ${path.relative(APP_ROOT, artifact)}`);
+	}
+};
+
+main().catch((error: unknown) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+});
diff --git a/apps/examples/desktop-app/sidecar/ARCHITECTURE.md b/apps/examples/desktop-app/sidecar/ARCHITECTURE.md
new file mode 100644
index 0000000..6590b28
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/ARCHITECTURE.md
@@ -0,0 +1,158 @@
+# Sidecar Architecture — @cline/code
+
+## Overview
+
+The sidecar is a single Bun process that handles the desktop backend runtime directly.
+
+It imports `@cline/core` directly and serves the Next.js frontend over HTTP + WebSocket.
+
+## Directory Structure
+
+```
+sidecar/
+├── index.ts              # Entry point: starts HTTP+WS server
+├── server.ts             # Bun HTTP server + WebSocket handlers
+├── context.ts            # SidecarContext type and factory
+├── commands.ts           # Command router
+├── chat-session.ts       # In-process chat session management
+├── session-data/         # Shared discovery, messages, artifacts, search helpers
+├── paths.ts              # Path resolution
+├── types.ts              # Shared types
+└── ARCHITECTURE.md       # This file
+```
+
+## Transport Protocol (unchanged)
+
+```
+Request:  { "type": "command", "id": string, "command": string, "args"?: object }
+Response: { "type": "response", "id": string, "ok": boolean, "result"?: unknown, "error"?: string }
+Event:    { "type": "event", "event": { "name": string, "payload": unknown } }
+```
+
+## Key Design Decisions
+
+### 1. Chat Sessions — In-Process via LocalRuntimeHost
+
+Instead of spawning a separate runtime bridge process, we use `LocalRuntimeHost` directly:
+
+```typescript
+import { LocalRuntimeHost } from "@cline/core";
+
+const sessionManager = await ClineCore.create({
+  backendMode: "hub",
+  capabilities: {
+    requestToolApproval: async (request) => {
+      // Push approval request to frontend via WebSocket event
+      broadcastEvent("tool_approval_state", { sessionId: request.sessionId, items: [request] });
+      // Wait for frontend response
+      return await waitForApprovalResponse(request.sessionId, request.toolCallId);
+    },
+  },
+});
+
+// Start session
+const { sessionId } = await sessionManager.start({
+  config: coreSessionConfig,
+  prompt: "...",
+});
+
+// Send follow-up
+await sessionManager.send({ sessionId, prompt: "..." });
+
+// Subscribe to streaming events
+sessionManager.subscribe((event) => {
+  // Forward to WebSocket clients as chat_text, chat_reasoning, etc.
+  broadcastEvent("chat_event", event);
+});
+```
+
+### 2. Tool Approval — In-Memory Promise Resolution
+
+No more file-system watchers. Tool approvals use in-memory promise maps:
+
+```typescript
+const pendingApprovals = new Map<string, {
+  resolve: (result: ToolApprovalResult) => void;
+  request: ToolApprovalRequest;
+}>();
+
+// When core requests approval → store promise, push to frontend
+// When frontend responds → resolve promise
+```
+
+### 3. Provider Management — Direct ProviderSettingsManager
+
+```typescript
+import { ProviderSettingsManager, listLocalProviders, ... } from "@cline/core";
+const manager = new ProviderSettingsManager();
+```
+
+### 4. Session Storage — Direct SqliteSessionStore
+
+```typescript
+import { SqliteSessionStore, resolveSessionBackend } from "@cline/core";
+const store = new SqliteSessionStore();
+```
+
+### 5. Routine Schedules — Direct Hub Commands
+
+Routine operations now ensure the local hub server in-process and issue hub schedule commands directly. They are still called in-process, not via child script:
+
+```typescript
+import { ensureHubServer, sendHubCommand } from "@cline/core";
+await ensureHubServer({ runtimeHandlers: createLocalHubScheduleRuntimeHandlers() });
+await sendHubCommand({}, { command: "schedule.list", payload: { limit: 200 } });
+```
+
+### 6. Native Commands
+
+- `pick_workspace_directory` — Uses macOS `osascript` / Linux `zenity` for directory picker
+- `open_mcp_settings_file` — Uses `open` / `xdg-open` to open files
+
+### 7. Frontend Connection
+
+The frontend `desktop-client.ts` connects directly to the sidecar WebSocket:
+- Discovers endpoint from `window.__SIDECAR_WS_ENDPOINT__` or defaults to `ws://127.0.0.1:3126/transport`
+- No Tauri dependency needed
+- Same `invoke()` / `subscribe()` API
+
+## Command Map
+
+Supported commands:
+
+| Command | Implementation |
+|---------|---------------|
+| `chat_session_command` | `LocalRuntimeHost` in-process |
+| `list_provider_catalog` | `ProviderSettingsManager` + `listLocalProviders` |
+| `list_provider_models` | `getLocalProviderModels` |
+| `save_provider_settings` | `saveLocalProviderSettings` |
+| `add_provider` | `addLocalProvider` |
+| `run_provider_oauth_login` | `loginLocalProvider` |
+| `list_chat_sessions` | `SqliteSessionStore` + file discovery |
+| `list_discovered_sessions` | Merged discovery |
+| `read_session_messages` | Session data readers |
+| `read_session_hooks` | Session data readers |
+| `delete_chat_session` | `SqliteSessionStore.delete` + file cleanup |
+| `update_chat_session_title` | `resolveSessionBackend().updateSession` |
+| `list_mcp_servers` | Direct file I/O |
+| `upsert_mcp_server` | Direct file I/O |
+| `delete_mcp_server` | Direct file I/O |
+| `get_git_branch` | `execFileSync("git", ...)` |
+| `list_git_branches` | `execFileSync("git", ...)` |
+| `checkout_git_branch` | `execFileSync("git", ...)` |
+| `search_workspace_files` | `getFileIndex` |
+| `get_process_context` | In-memory context |
+| `poll_tool_approvals` | In-memory pending map |
+| `respond_tool_approval` | In-memory promise resolution |
+| `list_routine_schedules` | local hub schedule commands |
+| `list_user_instruction_configs` | Direct core API |
+| `pick_workspace_directory` | OS native dialog |
+| `open_mcp_settings_file` | OS `open` command |
+
+## Dev Workflow
+
+```bash
+bun run dev:sidecar   # Start sidecar on port 3126
+bun run dev:web       # Start Next.js on port 3125
+bun run dev           # Both concurrently
+```
diff --git a/apps/examples/desktop-app/sidecar/chat-session.test.ts b/apps/examples/desktop-app/sidecar/chat-session.test.ts
new file mode 100644
index 0000000..b25fb1f
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/chat-session.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { buildSessionConnectionUpdate } from "./chat-session";
+
+describe("buildSessionConnectionUpdate", () => {
+	it("does not clear reasoning settings when config omits reasoning fields", () => {
+		const update = buildSessionConnectionUpdate({
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+		});
+
+		expect(update).toEqual({
+			providerId: "cline",
+			modelId: "anthropic/claude-sonnet-4.6",
+		});
+		expect(Object.hasOwn(update, "thinking")).toBe(false);
+		expect(Object.hasOwn(update, "reasoningEffort")).toBe(false);
+		expect(Object.hasOwn(update, "thinkingBudgetTokens")).toBe(false);
+	});
+
+	it("clears reasoning settings when thinking is explicitly disabled", () => {
+		expect(
+			buildSessionConnectionUpdate({
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				thinking: false,
+			}),
+		).toEqual({
+			providerId: "cline",
+			modelId: "anthropic/claude-sonnet-4.6",
+			thinking: false,
+			reasoningEffort: null,
+			thinkingBudgetTokens: null,
+		});
+	});
+
+	it("updates explicit reasoning settings without clearing omitted settings", () => {
+		const update = buildSessionConnectionUpdate({
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			reasoningEffort: "high",
+		});
+
+		expect(update).toEqual({
+			providerId: "cline",
+			modelId: "anthropic/claude-sonnet-4.6",
+			thinking: true,
+			reasoningEffort: "high",
+		});
+		expect(Object.hasOwn(update, "thinkingBudgetTokens")).toBe(false);
+	});
+});
diff --git a/apps/examples/desktop-app/sidecar/chat-session.ts b/apps/examples/desktop-app/sidecar/chat-session.ts
new file mode 100644
index 0000000..40cb0a5
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/chat-session.ts
@@ -0,0 +1,891 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import {
+	buildConnectionUpdate,
+	buildWorkspaceMetadata,
+	type ClineCore,
+	type CoreSessionConfig,
+	type SessionPendingPrompt,
+	SessionSource,
+	splitCoreSessionConfig,
+} from "@cline/core";
+import type { Message } from "@cline/llms";
+import { buildClineSystemPrompt } from "@cline/shared";
+import { emitChunk, nowMs, sendEvent } from "./context";
+import { readSessionManifest, sharedSessionDataDir } from "./paths";
+import type {
+	ChatSessionCommandRequest,
+	JsonRecord,
+	LiveSession,
+	PromptInQueue,
+	SidecarContext,
+} from "./types";
+
+type SessionConnectionUpdate = Parameters<
+	ClineCore["updateSessionConnection"]
+>[1];
+
+// ---------------------------------------------------------------------------
+// Session data helpers
+// ---------------------------------------------------------------------------
+
+function readPersistedChatMessages(sessionId: string): unknown[] | null {
+	const path = join(
+		sharedSessionDataDir(),
+		sessionId,
+		`${sessionId}.messages.json`,
+	);
+	if (!existsSync(path)) return null;
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8").trim()) as
+			| { messages?: unknown[] }
+			| unknown[];
+		if (Array.isArray(parsed)) return parsed;
+		return Array.isArray(parsed.messages) ? parsed.messages : null;
+	} catch {
+		return null;
+	}
+}
+
+function readSessionMetadataTitle(sessionId: string): string | undefined {
+	const manifest = readSessionManifest(sessionId);
+	const metadata =
+		manifest?.metadata && typeof manifest.metadata === "object"
+			? (manifest.metadata as JsonRecord)
+			: undefined;
+	const title = metadata?.title;
+	return typeof title === "string" ? title.trim() || undefined : undefined;
+}
+
+function readSessionMetadata(sessionId: string): JsonRecord | undefined {
+	const manifest = readSessionManifest(sessionId);
+	return manifest?.metadata && typeof manifest.metadata === "object"
+		? (manifest.metadata as JsonRecord)
+		: undefined;
+}
+
+function derivePromptFromMessages(messages: unknown[]): string {
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") continue;
+		const m = msg as JsonRecord;
+		if (m.role !== "user") continue;
+		if (typeof m.content === "string") {
+			const line = m.content.trim().split("\n")[0]?.trim();
+			if (line) return line.slice(0, 200);
+		}
+	}
+	return "";
+}
+
+// ---------------------------------------------------------------------------
+// Live session factory
+// ---------------------------------------------------------------------------
+
+function createLiveSession(
+	config: JsonRecord,
+	overrides?: Partial<LiveSession>,
+): LiveSession {
+	return {
+		config,
+		messages: overrides?.messages ?? [],
+		promptsInQueue: overrides?.promptsInQueue ?? [],
+		busy: false,
+		startedAt: nowMs(),
+		status: overrides?.status ?? "idle",
+		prompt: overrides?.prompt,
+		title: overrides?.title,
+		attachedViaHub: overrides?.attachedViaHub ?? false,
+	};
+}
+
+function isoTimestampToMs(
+	value: string | null | undefined,
+): number | undefined {
+	if (!value) {
+		return undefined;
+	}
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function readReasoningEffort(
+	value: unknown,
+): "low" | "medium" | "high" | "xhigh" | undefined {
+	if (
+		value === "low" ||
+		value === "medium" ||
+		value === "high" ||
+		value === "xhigh"
+	) {
+		return value;
+	}
+	return undefined;
+}
+
+function readPositiveInteger(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+		return Math.trunc(value);
+	}
+	return undefined;
+}
+
+function buildCoreSessionConfig(config: JsonRecord): JsonRecord {
+	const thinking =
+		typeof config.thinking === "boolean" ? config.thinking : undefined;
+	const reasoningEffort =
+		thinking === false
+			? undefined
+			: readReasoningEffort(config.reasoningEffort);
+	const thinkingBudgetTokens =
+		thinking === false
+			? undefined
+			: readPositiveInteger(
+					config.thinkingBudgetTokens ?? config.thinking_budget_tokens,
+				);
+	return {
+		sessionId: config.sessionId ?? config.session_id,
+		providerId: config.provider ?? config.providerId ?? "",
+		modelId: config.model ?? config.modelId ?? "",
+		mode: config.mode ?? "act",
+		apiKey: config.apiKey ?? config.api_key ?? "",
+		workspaceRoot: config.workspaceRoot ?? config.workspace_root ?? "",
+		cwd: config.cwd ?? config.workspaceRoot ?? config.workspace_root ?? "",
+		systemPrompt: config.systemPrompt ?? config.system_prompt ?? "",
+		maxIterations: config.maxIterations ?? config.max_iterations,
+		enableTools: config.enableTools ?? config.enable_tools ?? true,
+		enableSpawnAgent:
+			config.enableSpawn ??
+			config.enableSpawnAgent ??
+			config.enable_spawn ??
+			false,
+		enableAgentTeams:
+			config.enableTeams ??
+			config.enableAgentTeams ??
+			config.enable_teams ??
+			false,
+		...(thinking !== undefined ? { thinking } : {}),
+		...(reasoningEffort ? { reasoningEffort } : {}),
+		...(thinkingBudgetTokens !== undefined ? { thinkingBudgetTokens } : {}),
+		teamName: config.teamName ?? config.team_name,
+		missionLogIntervalSteps:
+			config.missionStepInterval ?? config.missionLogIntervalSteps,
+		missionLogIntervalMs:
+			config.missionTimeIntervalMs ?? config.missionLogIntervalMs,
+		checkpoint: { enabled: true },
+		sessions: config.sessions,
+		initialMessages: config.initialMessages,
+	};
+}
+
+export function buildSessionConnectionUpdate(
+	config: JsonRecord,
+): SessionConnectionUpdate {
+	// Coerce the untrusted webview JSON (snake_case aliases, blank strings)
+	// into typed fields; the thinking/reasoning transition rules live in the
+	// shared @cline/core builder.
+	const providerId = String(config.provider ?? config.providerId ?? "").trim();
+	const modelId = String(config.model ?? config.modelId ?? "").trim();
+	const rawApiKey =
+		typeof config.apiKey === "string"
+			? config.apiKey.trim()
+			: typeof config.api_key === "string"
+				? config.api_key.trim()
+				: undefined;
+	const baseUrl =
+		typeof config.baseUrl === "string" ? config.baseUrl.trim() : undefined;
+	const reasoningEffort = readReasoningEffort(config.reasoningEffort);
+	const thinkingBudgetTokens = readPositiveInteger(
+		config.thinkingBudgetTokens ?? config.thinking_budget_tokens,
+	);
+	return buildConnectionUpdate({
+		...(providerId ? { providerId } : {}),
+		...(modelId ? { modelId } : {}),
+		...(rawApiKey ? { apiKey: rawApiKey } : {}),
+		...(baseUrl ? { baseUrl } : {}),
+		...(config.headers && typeof config.headers === "object"
+			? { headers: config.headers as Record<string, string> }
+			: {}),
+		...(config.providerConfig && typeof config.providerConfig === "object"
+			? {
+					providerConfig:
+						config.providerConfig as SessionConnectionUpdate["providerConfig"],
+				}
+			: {}),
+		...(typeof config.thinking === "boolean"
+			? { thinking: config.thinking }
+			: {}),
+		...(reasoningEffort ? { reasoningEffort } : {}),
+		...(thinkingBudgetTokens !== undefined ? { thinkingBudgetTokens } : {}),
+	});
+}
+
+async function resolveSystemPrompt(config: JsonRecord): Promise<string> {
+	const cwd = String(
+		config.cwd ?? config.workspaceRoot ?? config.workspace_root ?? "",
+	).trim();
+	if (!cwd) {
+		return String(config.systemPrompt ?? config.system_prompt ?? "").trim();
+	}
+	const providerId = String(config.provider ?? config.providerId ?? "").trim();
+	const mode = config.autoApproveTools
+		? "yolo"
+		: config.mode === "plan"
+			? "plan"
+			: "act";
+	const metadata = await buildWorkspaceMetadata(cwd);
+	const inlineRules =
+		typeof config.rules === "string" && config.rules.trim().length > 0
+			? config.rules
+			: undefined;
+	return buildClineSystemPrompt({
+		ide: "Terminal Shell",
+		workspaceRoot: cwd,
+		workspaceName: basename(cwd),
+		metadata,
+		rules: inlineRules,
+		mode,
+		providerId: providerId || undefined,
+		overridePrompt:
+			typeof config.systemPrompt === "string" &&
+			config.systemPrompt.trim().length > 0
+				? config.systemPrompt
+				: typeof config.system_prompt === "string" &&
+						config.system_prompt.trim().length > 0
+					? config.system_prompt
+					: undefined,
+		platform: process.platform || "unknown",
+	});
+}
+
+function resolveToolPolicies(
+	config: JsonRecord,
+): { "*": { autoApprove: boolean } } | undefined {
+	return {
+		"*": {
+			autoApprove: config.autoApproveTools !== false,
+		},
+	};
+}
+
+function sendPromptsInQueueSnapshot(
+	ctx: SidecarContext,
+	sessionId: string,
+): void {
+	const session = ctx.liveSessions.get(sessionId);
+	sendEvent(ctx, "prompts_in_queue_state", {
+		sessionId,
+		items: session?.promptsInQueue ?? [],
+	});
+}
+
+function mapPendingPrompt(item: SessionPendingPrompt): PromptInQueue {
+	return {
+		id: item.id,
+		prompt: item.prompt,
+		steer: item.delivery === "steer",
+		attachmentCount: item.attachmentCount,
+	};
+}
+
+function applyPendingPrompts(
+	ctx: SidecarContext,
+	sessionId: string,
+	prompts: SessionPendingPrompt[],
+): PromptInQueue[] {
+	const mapped = prompts.map(mapPendingPrompt).filter((item) => item.id);
+	const session = ctx.liveSessions.get(sessionId);
+	if (session) {
+		session.promptsInQueue = mapped;
+	}
+	sendPromptsInQueueSnapshot(ctx, sessionId);
+	return mapped;
+}
+
+function getSessionManager(ctx: SidecarContext): ClineCore {
+	if (!ctx.sessionManager) throw new Error("Session manager not initialized");
+	return ctx.sessionManager;
+}
+
+// ---------------------------------------------------------------------------
+// Chat session action handlers
+// ---------------------------------------------------------------------------
+
+async function handleStart(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	if (!request.config) throw new Error("config is required");
+	const manager = getSessionManager(ctx);
+	const systemPrompt = await resolveSystemPrompt(request.config);
+	const requestedSessionId = String(
+		request.config.sessionId ?? request.config.session_id ?? "",
+	).trim();
+	const initialMessages =
+		Array.isArray(request.config.initialMessages) &&
+		request.config.initialMessages.length > 0
+			? request.config.initialMessages
+			: requestedSessionId
+				? (readPersistedChatMessages(requestedSessionId) ?? undefined)
+				: undefined;
+	const coreConfig: JsonRecord = {
+		...buildCoreSessionConfig(request.config),
+		systemPrompt,
+		...(initialMessages ? { initialMessages } : {}),
+	};
+	// Note: do NOT pass `prompt` to manager.start() here. When a prompt is
+	// provided to start(), the local runtime host runs the full agent turn
+	// synchronously inside start(). We always start the session idle and let
+	// the frontend call the separate "send" action to dispatch the prompt.
+	// This avoids a double-execution bug where start() would run the turn AND
+	// the subsequent manager.send() fire-and-forget would run it again.
+	console.error(
+		`[sidecar:handleStart] calling manager.start provider=${coreConfig.providerId} model=${coreConfig.modelId}`,
+	);
+	const startResult = await manager.start({
+		...splitCoreSessionConfig(coreConfig as unknown as CoreSessionConfig),
+		source: SessionSource.DESKTOP,
+		interactive: true,
+		...(initialMessages
+			? { initialMessages: initialMessages as Message[] }
+			: {}),
+		toolPolicies: resolveToolPolicies(request.config),
+	});
+	const sessionId = startResult.sessionId;
+	console.error(`[sidecar:handleStart] session started sessionId=${sessionId}`);
+	const session = createLiveSession(request.config, {
+		messages: initialMessages,
+		prompt: initialMessages
+			? derivePromptFromMessages(initialMessages)
+			: undefined,
+		title: requestedSessionId
+			? readSessionMetadataTitle(requestedSessionId)
+			: undefined,
+		status: "idle",
+	});
+	ctx.liveSessions.set(sessionId, session);
+	return { sessionId };
+}
+
+async function handleAttach(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	if (!sessionId) {
+		throw new Error("sessionId is required");
+	}
+
+	const manager = getSessionManager(ctx);
+	const session = await manager.get(sessionId);
+	if (!session) {
+		throw new Error(`Session ${sessionId} not found`);
+	}
+
+	const metadata =
+		session.metadata && typeof session.metadata === "object"
+			? (session.metadata as JsonRecord)
+			: undefined;
+	const existing = ctx.liveSessions.get(sessionId);
+	if (ctx.hubClient) {
+		await ctx.hubClient.command("session.attach", { sessionId }, sessionId);
+	}
+	const attachedConfig: JsonRecord = {
+		...(existing?.config ?? {}),
+		...(request.config ?? {}),
+		sessionId,
+		provider: session.provider || existing?.config.provider || "",
+		model: session.model || existing?.config.model || "",
+		cwd:
+			session.cwd ||
+			session.workspaceRoot ||
+			String(request.config?.cwd ?? "").trim() ||
+			String(existing?.config.cwd ?? "").trim(),
+		workspaceRoot:
+			session.workspaceRoot ||
+			session.cwd ||
+			String(request.config?.workspaceRoot ?? "").trim() ||
+			String(existing?.config.workspaceRoot ?? "").trim(),
+	};
+	ctx.liveSessions.set(
+		sessionId,
+		createLiveSession(attachedConfig, {
+			messages: existing?.messages ?? [],
+			promptsInQueue: existing?.promptsInQueue ?? [],
+			status: session.status,
+			prompt:
+				session.prompt ||
+				(typeof metadata?.prompt === "string" ? metadata.prompt : undefined) ||
+				existing?.prompt,
+			title:
+				(typeof metadata?.title === "string" ? metadata.title : undefined) ||
+				existing?.title,
+			endedAt: isoTimestampToMs(session.endedAt),
+			attachedViaHub: true,
+		}),
+	);
+
+	return {
+		sessionId,
+		status: session.status,
+		provider: session.provider,
+		model: session.model,
+		cwd: session.cwd,
+		workspaceRoot: session.workspaceRoot,
+		prompt: session.prompt,
+		metadata,
+	};
+}
+
+async function handleSend(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	if (!sessionId) throw new Error("sessionId is required");
+	const prompt = request.prompt?.trim();
+	if (!prompt) throw new Error("prompt is required");
+	const manager = getSessionManager(ctx);
+	const session = ctx.liveSessions.get(sessionId);
+	if (request.config) {
+		const connectionUpdate = buildSessionConnectionUpdate(request.config);
+		await manager.updateSessionConnection(sessionId, connectionUpdate);
+		if (session) {
+			session.config = { ...session.config, ...request.config };
+		}
+	}
+
+	// Determine effective delivery mode.
+	// When the session is busy and no explicit delivery was requested, queue it
+	// via Core so that Core's own pending-prompts mechanism handles draining.
+	// This avoids a sidecar-only local queue that never calls manager.send().
+	let delivery = request.delivery;
+	if (!delivery && session?.busy) {
+		delivery = "queue";
+	}
+
+	if (delivery === "queue") {
+		if (session) {
+			session.prompt = prompt;
+		}
+		// Delegate queuing to Core — it will drain the prompt once the current
+		// turn finishes and emit pending_prompts / pending_prompt_submitted events.
+		await manager.send({
+			sessionId,
+			prompt,
+			delivery: "queue",
+			userImages: request.attachments?.userImages,
+		});
+		const prompts = await manager.pendingPrompts.list({ sessionId });
+		return {
+			sessionId,
+			ok: true,
+			queued: true,
+			promptsInQueue: applyPendingPrompts(ctx, sessionId, prompts),
+		};
+	}
+
+	if (session) {
+		session.prompt = prompt;
+		session.busy = true;
+		session.status = "running";
+	}
+	try {
+		console.error(
+			`[sidecar:handleSend] calling manager.send sessionId=${sessionId} prompt=${prompt.slice(0, 80)}`,
+		);
+		const result = await manager.send({
+			sessionId,
+			prompt,
+			delivery,
+			userImages: request.attachments?.userImages,
+		});
+		console.error(
+			`[sidecar:handleSend] manager.send resolved sessionId=${sessionId} finishReason=${result?.finishReason} textLen=${result?.text?.length ?? 0}`,
+		);
+		if (session) {
+			session.busy = false;
+			session.status = "idle";
+			if (result?.messages) session.messages = result.messages as unknown[];
+		}
+		return {
+			sessionId,
+			ok: true,
+			result: result
+				? {
+						text: result.text,
+						finishReason: result.finishReason,
+						messages: result.messages,
+						usage: result.usage,
+						iterations: result.iterations,
+						toolCalls: result.toolCalls,
+					}
+				: undefined,
+		};
+	} catch (error) {
+		console.error(
+			`[sidecar:handleSend] manager.send THREW sessionId=${sessionId} error=${error instanceof Error ? error.message : String(error)}`,
+		);
+		if (session) {
+			session.busy = false;
+			session.status = "error";
+		}
+		emitChunk(
+			ctx,
+			sessionId,
+			"chat_core_log",
+			JSON.stringify({
+				level: "error",
+				message: error instanceof Error ? error.message : String(error),
+			}),
+		);
+		return {
+			sessionId,
+			ok: true,
+			result: {
+				finishReason: "error",
+				text: error instanceof Error ? error.message : String(error),
+			},
+		};
+	}
+}
+
+async function handleStop(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	if (!sessionId) throw new Error("sessionId is required");
+	await getSessionManager(ctx).stop(sessionId);
+	const session = ctx.liveSessions.get(sessionId);
+	if (session) {
+		session.busy = false;
+		session.status = "stopped";
+	}
+	return { sessionId, ok: true };
+}
+
+async function handleAbort(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	if (!sessionId) throw new Error("sessionId is required");
+	await getSessionManager(ctx).abort(sessionId, "user_abort");
+	const session = ctx.liveSessions.get(sessionId);
+	if (session) {
+		session.busy = false;
+		session.status = "aborted";
+	}
+	return { sessionId, ok: true };
+}
+
+async function handleFork(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sourceSessionId = request.sessionId?.trim();
+	if (!sourceSessionId) throw new Error("sessionId is required");
+	const manager = getSessionManager(ctx);
+	const sourceMessages =
+		readPersistedChatMessages(sourceSessionId) ??
+		ctx.liveSessions.get(sourceSessionId)?.messages;
+	if (!sourceMessages?.length) {
+		throw new Error(`No messages found for session ${sourceSessionId}`);
+	}
+
+	const sourceSession = await manager.get(sourceSessionId);
+	const sourceMetadata =
+		(sourceSession?.metadata && typeof sourceSession.metadata === "object"
+			? (sourceSession.metadata as JsonRecord)
+			: undefined) ?? readSessionMetadata(sourceSessionId);
+	const liveConfig = ctx.liveSessions.get(sourceSessionId)?.config;
+	const forkConfig: JsonRecord = {
+		...(liveConfig ?? {}),
+		...(request.config ?? {}),
+		sessionId: undefined,
+		provider:
+			sourceSession?.provider ||
+			liveConfig?.provider ||
+			request.config?.provider ||
+			request.config?.providerId ||
+			"",
+		model:
+			sourceSession?.model ||
+			liveConfig?.model ||
+			request.config?.model ||
+			request.config?.modelId ||
+			"",
+		cwd:
+			sourceSession?.cwd ||
+			sourceSession?.workspaceRoot ||
+			liveConfig?.cwd ||
+			request.config?.cwd ||
+			request.config?.workspaceRoot ||
+			request.config?.workspace_root ||
+			"",
+		workspaceRoot:
+			sourceSession?.workspaceRoot ||
+			sourceSession?.cwd ||
+			liveConfig?.workspaceRoot ||
+			request.config?.workspaceRoot ||
+			request.config?.workspace_root ||
+			request.config?.cwd ||
+			"",
+	};
+	const checkpointMetadata =
+		sourceMetadata?.checkpoint !== undefined
+			? { checkpoints: sourceMetadata.checkpoint }
+			: {};
+	const forkMetadata: JsonRecord = {
+		...(sourceMetadata ?? {}),
+		fork: {
+			forkedFromSessionId: sourceSessionId,
+			forkedAt: new Date().toISOString(),
+			source: sourceSession?.source ?? "desktop",
+			...checkpointMetadata,
+		},
+	};
+	const systemPrompt = await resolveSystemPrompt(forkConfig);
+	const startResult = await manager.start({
+		...splitCoreSessionConfig(
+			buildCoreSessionConfig({
+				...forkConfig,
+				systemPrompt,
+				initialMessages: sourceMessages,
+			}) as unknown as CoreSessionConfig,
+		),
+		source: SessionSource.DESKTOP,
+		interactive: true,
+		initialMessages: sourceMessages as Message[],
+		sessionMetadata: forkMetadata,
+		toolPolicies: resolveToolPolicies(forkConfig),
+	});
+	const newSessionId = startResult.sessionId;
+	ctx.liveSessions.delete(sourceSessionId);
+	ctx.liveSessions.set(
+		newSessionId,
+		createLiveSession(forkConfig, {
+			messages: sourceMessages,
+			prompt: derivePromptFromMessages(sourceMessages),
+			title: readSessionMetadataTitle(sourceSessionId),
+			status: "idle",
+		}),
+	);
+	sendPromptsInQueueSnapshot(ctx, sourceSessionId);
+	sendPromptsInQueueSnapshot(ctx, newSessionId);
+	let messages: unknown[] = sourceMessages;
+	try {
+		const read = await manager.readMessages(newSessionId);
+		if (read?.length > 0) messages = read;
+	} catch {}
+	return {
+		sessionId: newSessionId,
+		forkedFromSessionId: sourceSessionId,
+		messages,
+	};
+}
+
+async function handleReset(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	if (sessionId) {
+		const session = ctx.liveSessions.get(sessionId);
+		if (
+			session?.busy ||
+			session?.status === "starting" ||
+			session?.status === "running" ||
+			session?.status === "stopping"
+		) {
+			await getSessionManager(ctx).stop(sessionId);
+		}
+		ctx.liveSessions.delete(sessionId);
+		sendPromptsInQueueSnapshot(ctx, sessionId);
+	}
+	return { sessionId: request.sessionId, ok: true };
+}
+
+async function handleRestoreCheckpoint(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sourceSessionId = request.sessionId?.trim();
+	if (!sourceSessionId) throw new Error("sessionId is required");
+	const runCount = request.checkpointRunCount;
+	if (
+		typeof runCount !== "number" ||
+		!Number.isInteger(runCount) ||
+		runCount < 1
+	)
+		throw new Error("checkpointRunCount must be a positive integer");
+	if (!request.config)
+		throw new Error("config is required to restore a checkpoint");
+	const cwd =
+		(typeof request.config.cwd === "string" && request.config.cwd.trim()) ||
+		(typeof request.config.workspaceRoot === "string" &&
+			request.config.workspaceRoot.trim()) ||
+		"";
+	if (!cwd) throw new Error("config.cwd or config.workspaceRoot is required");
+	const manager = getSessionManager(ctx);
+	const restored = await manager.restore({
+		sessionId: sourceSessionId,
+		checkpointRunCount: runCount,
+		cwd,
+		restore: { messages: true, workspace: true },
+		start: {
+			...splitCoreSessionConfig(
+				buildCoreSessionConfig({
+					...request.config,
+					systemPrompt: await resolveSystemPrompt(request.config),
+				}) as unknown as CoreSessionConfig,
+			),
+			source: SessionSource.DESKTOP,
+			interactive: true,
+			toolPolicies: resolveToolPolicies(request.config),
+		},
+	});
+	const sessionId = restored.sessionId;
+	const restoredMessages = restored.messages;
+	if (!sessionId || !restoredMessages) {
+		throw new Error("Checkpoint restore did not return a new session");
+	}
+	ctx.liveSessions.delete(sourceSessionId);
+	ctx.liveSessions.set(
+		sessionId,
+		createLiveSession(request.config, {
+			messages: restoredMessages,
+			prompt: derivePromptFromMessages(restoredMessages),
+			title: readSessionMetadataTitle(sourceSessionId),
+			status: "idle",
+		}),
+	);
+	sendPromptsInQueueSnapshot(ctx, sourceSessionId);
+	sendPromptsInQueueSnapshot(ctx, sessionId);
+	let messages: unknown[] = restoredMessages;
+	try {
+		const read = await manager.readMessages(sessionId);
+		if (read?.length > 0) messages = read;
+	} catch {}
+	return {
+		sessionId,
+		messages,
+		restoredCheckpoint: restored.checkpoint,
+	};
+}
+
+async function handlePendingPrompts(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	if (!sessionId) throw new Error("sessionId is required");
+	const prompts = await getSessionManager(ctx).pendingPrompts.list({
+		sessionId,
+	});
+	return {
+		sessionId,
+		promptsInQueue: applyPendingPrompts(ctx, sessionId, prompts),
+	};
+}
+
+async function handleSteerPrompt(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	const promptId = request.promptId?.trim();
+	if (!sessionId || !promptId)
+		throw new Error("sessionId and promptId are required");
+	const manager = getSessionManager(ctx);
+	const result = await manager.pendingPrompts.update({
+		sessionId,
+		promptId,
+		delivery: "steer",
+	});
+	return {
+		sessionId,
+		updated: result.updated === true,
+		promptsInQueue: applyPendingPrompts(ctx, sessionId, result.prompts),
+	};
+}
+
+async function handleUpdatePendingPrompt(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	const promptId = request.promptId?.trim();
+	const prompt = request.prompt?.trim();
+	if (!sessionId || !promptId) {
+		throw new Error("sessionId and promptId are required");
+	}
+	if (!prompt) {
+		throw new Error("prompt is required");
+	}
+	const manager = getSessionManager(ctx);
+	const result = await manager.pendingPrompts.update({
+		sessionId,
+		promptId,
+		prompt,
+	});
+	return {
+		sessionId,
+		updated: result.updated === true,
+		prompt: result.prompt ? mapPendingPrompt(result.prompt) : undefined,
+		promptsInQueue: applyPendingPrompts(ctx, sessionId, result.prompts),
+	};
+}
+
+async function handleRemovePendingPrompt(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const sessionId = request.sessionId?.trim();
+	const promptId = request.promptId?.trim();
+	if (!sessionId || !promptId) {
+		throw new Error("sessionId and promptId are required");
+	}
+	const manager = getSessionManager(ctx);
+	const result = await manager.pendingPrompts.delete({
+		sessionId,
+		promptId,
+	});
+	return {
+		sessionId,
+		removed: result.removed === true,
+		prompt: result.prompt ? mapPendingPrompt(result.prompt) : undefined,
+		promptsInQueue: applyPendingPrompts(ctx, sessionId, result.prompts),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Action dispatch
+// ---------------------------------------------------------------------------
+
+const ACTION_HANDLERS: Record<
+	string,
+	(ctx: SidecarContext, req: ChatSessionCommandRequest) => Promise<unknown>
+> = {
+	start: handleStart,
+	attach: handleAttach,
+	send: handleSend,
+	stop: handleStop,
+	abort: handleAbort,
+	fork: handleFork,
+	reset: handleReset,
+	restore_checkpoint: handleRestoreCheckpoint,
+	pending_prompts: handlePendingPrompts,
+	steer_prompt: handleSteerPrompt,
+	update_pending_prompt: handleUpdatePendingPrompt,
+	remove_pending_prompt: handleRemovePendingPrompt,
+};
+
+export async function handleChatSessionCommand(
+	ctx: SidecarContext,
+	request: ChatSessionCommandRequest,
+): Promise<unknown> {
+	const handler = ACTION_HANDLERS[request.action];
+	if (!handler) throw new Error("unsupported action");
+	return handler(ctx, request);
+}
diff --git a/apps/examples/desktop-app/sidecar/chat-test.ts b/apps/examples/desktop-app/sidecar/chat-test.ts
new file mode 100644
index 0000000..8c95d82
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/chat-test.ts
@@ -0,0 +1,178 @@
+/**
+ * Quick diagnostic: start sidecar, create session, send a prompt, capture logs.
+ * Run: bun run sidecar/chat-test.ts
+ */
+import { type ChildProcess, spawn } from "node:child_process";
+import { join } from "node:path";
+
+const TIMEOUT = 60_000;
+const cwd = join(import.meta.dir, "..");
+
+let child: ChildProcess | null = null;
+let wsEndpoint = "";
+const stderrLines: string[] = [];
+
+function startSidecar(): Promise<string> {
+	return new Promise((resolve, reject) => {
+		child = spawn("bun", ["run", "sidecar/index.ts"], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			env: { ...process.env },
+		});
+		const timer = setTimeout(
+			() => reject(new Error("sidecar did not become ready")),
+			20_000,
+		);
+		child.stdout?.on("data", (chunk) => {
+			for (const line of String(chunk).split("\n")) {
+				const trimmed = line.trim();
+				if (!trimmed) continue;
+				try {
+					const parsed = JSON.parse(trimmed);
+					if (parsed.type === "ready" && parsed.wsEndpoint) {
+						clearTimeout(timer);
+						resolve(parsed.wsEndpoint);
+						return;
+					}
+				} catch {}
+			}
+		});
+		child.stderr?.on("data", (chunk) => {
+			const text = String(chunk).trim();
+			if (text) {
+				stderrLines.push(text);
+				process.stderr.write(`[sidecar-stderr] ${text}\n`);
+			}
+		});
+		child.on("exit", (code) => {
+			clearTimeout(timer);
+			reject(new Error(`sidecar exited with code ${code}`));
+		});
+	});
+}
+
+function sendWsCommand<T>(
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<{ result: T; events: Array<Record<string, unknown>> }> {
+	return new Promise((resolve, reject) => {
+		const events: Array<Record<string, unknown>> = [];
+		const socket = new WebSocket(wsEndpoint);
+		const timer = setTimeout(() => {
+			socket.close();
+			reject(
+				new Error(`timed out waiting for ${command} (events=${events.length})`),
+			);
+		}, TIMEOUT);
+		socket.onopen = () => {
+			socket.send(
+				JSON.stringify({ type: "command", id: "test", command, args }),
+			);
+		};
+		socket.onmessage = (event) => {
+			const parsed = JSON.parse(String(event.data));
+			if (parsed.type === "event") {
+				events.push(parsed.event as Record<string, unknown>);
+				return;
+			}
+			if (parsed.type === "response" && parsed.id === "test") {
+				clearTimeout(timer);
+				socket.close();
+				if (!parsed.ok) {
+					reject(new Error(parsed.error || `${command} failed`));
+					return;
+				}
+				resolve({ result: parsed.result as T, events });
+			}
+		};
+		socket.onerror = () => {
+			clearTimeout(timer);
+			reject(new Error(`websocket error during ${command}`));
+		};
+	});
+}
+
+async function main() {
+	console.log("Starting sidecar...");
+	wsEndpoint = await startSidecar();
+	console.log(`Sidecar ready at ${wsEndpoint}`);
+
+	// Step 1: Start a session
+	console.log("\n=== Step 1: Start session ===");
+	const { result: startResult } = await sendWsCommand<{ sessionId: string }>(
+		"chat_session_command",
+		{
+			request: {
+				action: "start",
+				config: {
+					provider: "cline",
+					model: "claude-sonnet-4-20250514",
+					apiKey: process.env.CLINE_API_KEY || "",
+					workspaceRoot: cwd,
+					cwd: cwd,
+					mode: "act",
+					enableTools: false,
+					enableSpawn: false,
+					enableTeams: false,
+				},
+			},
+		},
+	);
+	console.log("Start result:", JSON.stringify(startResult, null, 2));
+	const sessionId = startResult.sessionId;
+	if (!sessionId) {
+		throw new Error("No sessionId returned from start");
+	}
+
+	// Step 2: Send a prompt
+	console.log("\n=== Step 2: Send prompt ===");
+	const { result: sendResult, events } = await sendWsCommand<unknown>(
+		"chat_session_command",
+		{
+			request: {
+				action: "send",
+				sessionId,
+				prompt: "Say hello in one short sentence.",
+			},
+		},
+	);
+	console.log("Send result:", JSON.stringify(sendResult, null, 2));
+	console.log(`Events received during send: ${events.length}`);
+	for (const evt of events.slice(0, 20)) {
+		const payload =
+			evt.payload && typeof evt.payload === "object"
+				? (evt.payload as Record<string, unknown>)
+				: {};
+		console.log(
+			`  event: ${evt.name} payload.stream=${payload.stream ?? "N/A"} chunk=${String(payload.chunk ?? "").slice(0, 80)}`,
+		);
+	}
+
+	console.log("\n=== Stderr lines ===");
+	for (const line of stderrLines) {
+		if (line.includes("[sidecar:")) {
+			console.log(`  ${line}`);
+		}
+	}
+
+	console.log("\nDone.");
+}
+
+main()
+	.catch((err) => {
+		console.error("FAILED:", err.message);
+		console.log("\n=== Stderr lines ===");
+		for (const line of stderrLines) {
+			if (
+				line.includes("[sidecar:") ||
+				line.includes("error") ||
+				line.includes("Error")
+			) {
+				console.log(`  ${line}`);
+			}
+		}
+	})
+	.finally(() => {
+		child?.kill("SIGTERM");
+		process.exit(0);
+	});
diff --git a/apps/examples/desktop-app/sidecar/commands.ts b/apps/examples/desktop-app/sidecar/commands.ts
new file mode 100644
index 0000000..cd193d7
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/commands.ts
@@ -0,0 +1,1265 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import type {
+	ClineAccountActionRequest,
+	ProviderCapability,
+	ProviderClient,
+	ProviderProtocol,
+	SaveProviderSettingsActionRequest,
+} from "@cline/core";
+import {
+	addLocalProvider,
+	ClineAccountService,
+	createLocalHubScheduleRuntimeHandlers,
+	createUserInstructionConfigService,
+	discoverPluginModulePaths,
+	ensureCustomProvidersLoaded,
+	ensureHubServer,
+	executeClineAccountAction,
+	getCoreBuiltinToolCatalog,
+	getLocalProviderModels,
+	HubScheduleCommandService,
+	HubScheduleService,
+	listHookConfigFiles,
+	listLocalProviders,
+	listPluginTools,
+	loginAndSaveLocalProviderOAuthCredentials,
+	markLocalProviderEnabled,
+	normalizeOAuthProvider,
+	ProviderSettingsManager,
+	readGlobalSettings,
+	resolveLocalClineAuthToken,
+	resolvePluginConfigSearchPaths,
+	resolveSessionBackend,
+	resolveAgentConfigSearchPaths as resolveSharedAgentConfigSearchPaths,
+	SqliteSessionStore,
+	saveLocalProviderSettings,
+	sendHubCommand,
+	setAutoUpdateEnabledGlobally,
+	setDisabledPlugin,
+	setDisabledTools,
+	setTelemetryOptOutGlobally,
+	toggleDisabledTool,
+	updateMcpSettingsFileSync,
+} from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import {
+	connectorChannelsPayload,
+	startConnectorChannel,
+	stopConnectorChannel,
+} from "./connectors";
+import { broadcastEvent, resolveSidecarAskQuestion } from "./context";
+import {
+	installMarketplaceEntryForDesktopCommand,
+	listMarketplaceInstalledEntries,
+	uninstallLocalPrimitive,
+	uninstallMarketplaceEntryForDesktopCommand,
+} from "./marketplace";
+import {
+	findArtifactUnderDir,
+	readSessionManifest,
+	resolveMcpSettingsPath,
+	rootSessionIdFrom,
+	sessionLogPath,
+	sharedSessionDataDir,
+} from "./paths";
+import { readSessionHooks } from "./session-data/artifacts";
+import { normalizeSessionTitle } from "./session-data/common";
+import { discoverChatSessions } from "./session-data/discovery";
+import { readSessionMessages } from "./session-data/messages";
+import { searchWorkspaceFiles } from "./session-data/search";
+import type {
+	ChatSessionCommandRequest,
+	JsonRecord,
+	SidecarContext,
+} from "./types";
+
+function readProviderSettingsUpdate(
+	args: Record<string, unknown> | undefined,
+): Partial<Omit<SaveProviderSettingsActionRequest, "action" | "providerId">> {
+	return args?.settings && typeof args.settings === "object"
+		? (args.settings as Partial<
+				Omit<SaveProviderSettingsActionRequest, "action" | "providerId">
+			>)
+		: {};
+}
+
+// ---------------------------------------------------------------------------
+// MCP settings helpers
+// ---------------------------------------------------------------------------
+
+function readMcpServersResponse(): JsonRecord {
+	const settingsPath = resolveMcpSettingsPath();
+	if (!existsSync(settingsPath)) {
+		return { settingsPath, hasSettingsFile: false, servers: [] };
+	}
+	const parsed = JSON.parse(readFileSync(settingsPath, "utf8")) as JsonRecord;
+	const servers = parsed.mcpServers as JsonRecord | undefined;
+	const entries = Object.entries(servers ?? {}).map(([name, body]) => {
+		const record = body as JsonRecord;
+		const transport =
+			record.transport && typeof record.transport === "object"
+				? (record.transport as JsonRecord)
+				: undefined;
+		const transportType = String(
+			transport?.type ?? record.transportType ?? record.type ?? "stdio",
+		).trim();
+		return {
+			name,
+			transportType,
+			disabled: record.disabled === true,
+			command:
+				typeof transport?.command === "string"
+					? transport.command
+					: typeof record.command === "string"
+						? record.command
+						: undefined,
+			args: Array.isArray(transport?.args)
+				? transport.args
+				: Array.isArray(record.args)
+					? record.args
+					: undefined,
+			cwd:
+				typeof transport?.cwd === "string"
+					? transport.cwd
+					: typeof record.cwd === "string"
+						? record.cwd
+						: undefined,
+			env:
+				transport?.env && typeof transport.env === "object"
+					? transport.env
+					: record.env && typeof record.env === "object"
+						? record.env
+						: undefined,
+			url:
+				typeof transport?.url === "string"
+					? transport.url
+					: typeof record.url === "string"
+						? record.url
+						: undefined,
+			headers:
+				transport?.headers && typeof transport.headers === "object"
+					? transport.headers
+					: record.headers && typeof record.headers === "object"
+						? record.headers
+						: undefined,
+			metadata: record.metadata,
+		};
+	});
+	return { settingsPath, hasSettingsFile: true, servers: entries };
+}
+
+function writeMcpServersMap(servers: JsonRecord): void {
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		settings.mcpServers = servers;
+	});
+}
+
+function ensureMcpSettingsFile(): string {
+	const path = resolveMcpSettingsPath();
+	if (!existsSync(path)) {
+		writeMcpServersMap({});
+	}
+	return path;
+}
+
+function removePathIfExists(
+	path: string,
+	options?: { recursive?: boolean },
+): boolean {
+	if (!path || !existsSync(path)) {
+		return false;
+	}
+	rmSync(path, {
+		force: true,
+		recursive: options?.recursive === true,
+	});
+	return true;
+}
+
+async function listSessionsFromSidecarManager(
+	ctx: SidecarContext,
+	limit: number,
+): Promise<unknown> {
+	const max = Math.max(1, Math.floor(limit));
+	if (ctx.sessionManager) {
+		return await ctx.sessionManager.list(max, { hydrate: false });
+	}
+
+	const byId = new Map<string, JsonRecord>();
+	const store = new SqliteSessionStore();
+	const mergeSessionRecord = (
+		sessionId: string,
+		record: JsonRecord,
+	): JsonRecord => {
+		const persisted = store.get(sessionId) as unknown as JsonRecord | undefined;
+		const metadata =
+			record.metadata && typeof record.metadata === "object"
+				? (record.metadata as JsonRecord)
+				: undefined;
+		return {
+			...(persisted ?? {}),
+			...record,
+			sessionId,
+			provider: record.provider ?? persisted?.provider ?? "",
+			model: record.model ?? persisted?.model ?? "",
+			cwd: record.cwd ?? persisted?.cwd ?? "",
+			workspaceRoot:
+				record.workspaceRoot ??
+				persisted?.workspaceRoot ??
+				persisted?.cwd ??
+				"",
+			prompt: record.prompt ?? persisted?.prompt ?? metadata?.prompt,
+			parentSessionId:
+				record.parentSessionId ??
+				persisted?.parentSessionId ??
+				metadata?.parentSessionId,
+			parentAgentId:
+				record.parentAgentId ??
+				persisted?.parentAgentId ??
+				metadata?.parentAgentId,
+			agentId: record.agentId ?? persisted?.agentId ?? metadata?.agentId,
+			conversationId:
+				record.conversationId ??
+				persisted?.conversationId ??
+				metadata?.conversationId,
+			isSubagent: record.isSubagent ?? persisted?.isSubagent ?? false,
+			startedAt: record.startedAt ?? persisted?.startedAt ?? record.createdAt,
+			updatedAt: record.updatedAt ?? persisted?.updatedAt,
+			metadata: {
+				...((persisted?.metadata && typeof persisted.metadata === "object"
+					? persisted.metadata
+					: {}) as JsonRecord),
+				...(metadata ?? {}),
+			},
+		};
+	};
+
+	if (ctx.hubClient) {
+		try {
+			const reply = await ctx.hubClient.command("session.list", { limit: max });
+			const sessions = Array.isArray(reply.payload?.sessions)
+				? reply.payload.sessions
+				: [];
+			for (const item of sessions) {
+				if (!item || typeof item !== "object") continue;
+				const record = item as JsonRecord;
+				const sessionId = String(record.sessionId ?? "").trim();
+				if (sessionId)
+					byId.set(sessionId, mergeSessionRecord(sessionId, record));
+			}
+		} catch {
+			// Fall through to the local SQLite index.
+		}
+	}
+
+	if (byId.size === 0) {
+		for (const session of store.list(max)) {
+			byId.set(session.sessionId, session as unknown as JsonRecord);
+		}
+	}
+
+	for (const [sessionId, session] of ctx.liveSessions.entries()) {
+		const existing = byId.get(sessionId);
+		byId.set(sessionId, {
+			...(existing ?? {}),
+			sessionId,
+			status: session.status,
+			provider: session.config.provider ?? existing?.provider ?? "",
+			model: session.config.model ?? existing?.model ?? "",
+			cwd: session.config.cwd ?? existing?.cwd ?? "",
+			workspaceRoot:
+				session.config.workspaceRoot ??
+				existing?.workspaceRoot ??
+				existing?.cwd ??
+				"",
+			prompt: session.prompt ?? existing?.prompt,
+			startedAt:
+				existing?.startedAt ?? new Date(session.startedAt).toISOString(),
+			endedAt:
+				session.endedAt !== undefined
+					? new Date(session.endedAt).toISOString()
+					: existing?.endedAt,
+			metadata: {
+				...((existing?.metadata && typeof existing.metadata === "object"
+					? existing.metadata
+					: {}) as JsonRecord),
+				...(session.title ? { title: session.title } : {}),
+			},
+		});
+	}
+
+	return Array.from(byId.values())
+		.sort((left, right) => {
+			const leftTime = Date.parse(
+				String(left.updatedAt ?? left.startedAt ?? ""),
+			);
+			const rightTime = Date.parse(
+				String(right.updatedAt ?? right.startedAt ?? ""),
+			);
+			return (
+				(Number.isNaN(rightTime) ? 0 : rightTime) -
+				(Number.isNaN(leftTime) ? 0 : leftTime)
+			);
+		})
+		.slice(0, max);
+}
+
+// ---------------------------------------------------------------------------
+// Git helpers
+// ---------------------------------------------------------------------------
+
+function listGitBranches(
+	ctx: SidecarContext,
+	cwd?: string,
+): { current?: string; branches?: string[] } {
+	const targetCwd = cwd?.trim() || ctx.workspaceRoot;
+	const current = (() => {
+		try {
+			return execFileSync("git", ["branch", "--show-current"], {
+				cwd: targetCwd,
+				encoding: "utf8",
+				stdio: ["ignore", "pipe", "ignore"],
+			}).trim();
+		} catch {
+			return "";
+		}
+	})();
+	try {
+		const stdout = execFileSync(
+			"git",
+			["for-each-ref", "--format=%(refname:short)", "refs/heads"],
+			{
+				cwd: targetCwd,
+				encoding: "utf8",
+				stdio: ["ignore", "pipe", "ignore"],
+			},
+		);
+		const branches = stdout
+			.split("\n")
+			.map((v) => v.trim())
+			.filter(Boolean);
+		return { current: current || undefined, branches };
+	} catch {
+		return { current: current || undefined, branches: [] };
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Routine schedule helpers (in-process via shared hub server)
+// ---------------------------------------------------------------------------
+
+function toPositiveInt(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	const rounded = Math.trunc(value);
+	return rounded > 0 ? rounded : undefined;
+}
+
+function asTrimmedString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+async function handleRoutineScheduleCommand(
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<unknown> {
+	let useLocalScheduleService = false;
+	try {
+		if (!useLocalScheduleService) {
+			await ensureHubServer({
+				runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			});
+		}
+	} catch {
+		useLocalScheduleService = true;
+	}
+	const clientCommand = async (
+		hubCommand: string,
+		payload?: Record<string, unknown>,
+	) => {
+		const reply = useLocalScheduleService
+			? await localRoutineScheduleCommand(hubCommand, payload)
+			: await sendHubCommand(
+					{},
+					{
+						clientId: "code-sidecar-routines",
+						command: hubCommand as never,
+						payload,
+					},
+				);
+		if (!reply.ok) {
+			throw new Error(
+				reply.error?.message ?? `hub command failed: ${hubCommand}`,
+			);
+		}
+		return (reply.payload ?? {}) as Record<string, unknown>;
+	};
+	try {
+		if (command === "list_routine_schedules") {
+			const [schedules, activeExecutions, upcomingRuns] = await Promise.all([
+				clientCommand("schedule.list", {
+					limit: toPositiveInt(args?.limit) ?? 200,
+				}),
+				clientCommand("schedule.active"),
+				clientCommand("schedule.upcoming", { limit: 30 }),
+			]);
+			return {
+				schedules: schedules.schedules ?? [],
+				activeExecutions: activeExecutions.executions ?? [],
+				upcomingRuns: upcomingRuns.runs ?? [],
+			};
+		}
+		if (command === "create_routine_schedule") {
+			const name = asTrimmedString(args?.name);
+			const cronPattern = asTrimmedString(args?.cron_pattern);
+			const prompt = asTrimmedString(args?.prompt);
+			const workspaceRoot = asTrimmedString(args?.workspace_root);
+			if (!name || !cronPattern || !prompt || !workspaceRoot) {
+				throw new Error(
+					"createSchedule requires name, cron_pattern, prompt, and workspace_root",
+				);
+			}
+			const created = await clientCommand("schedule.create", {
+				name,
+				cronPattern,
+				prompt,
+				modelSelection: {
+					providerId: asTrimmedString(args?.provider) ?? "cline",
+					modelId: asTrimmedString(args?.model) ?? "openai/gpt-5.3-codex",
+				},
+				mode: args?.mode === "plan" ? "plan" : "act",
+				workspaceRoot,
+				cwd: asTrimmedString(args?.cwd),
+				systemPrompt: asTrimmedString(args?.system_prompt),
+				maxIterations: toPositiveInt(args?.max_iterations),
+				timeoutSeconds: toPositiveInt(args?.timeout_seconds),
+				maxParallel: toPositiveInt(args?.max_parallel) ?? 1,
+				enabled: args?.enabled !== false,
+				tags:
+					Array.isArray(args?.tags) && args.tags.length > 0
+						? (args.tags as string[])
+								.map((v: string) => v.trim())
+								.filter((v: string) => v.length > 0)
+						: undefined,
+			});
+			return { schedule: created.schedule ?? null };
+		}
+		const scheduleId = asTrimmedString(args?.schedule_id);
+		if (!scheduleId) throw new Error(`${command} requires schedule_id`);
+		if (command === "pause_routine_schedule") {
+			const reply = await clientCommand("schedule.disable", { scheduleId });
+			return { schedule: reply.schedule ?? null };
+		}
+		if (command === "resume_routine_schedule") {
+			const reply = await clientCommand("schedule.enable", { scheduleId });
+			return { schedule: reply.schedule ?? null };
+		}
+		if (command === "trigger_routine_schedule") {
+			const reply = await clientCommand("schedule.trigger", { scheduleId });
+			return { execution: reply.execution ?? null };
+		}
+		if (command === "delete_routine_schedule") {
+			const reply = await clientCommand("schedule.delete", { scheduleId });
+			return { deleted: reply.deleted === true };
+		}
+		throw new Error(`unsupported routine schedule command: ${command}`);
+	} finally {
+	}
+}
+
+let localRoutineScheduleService: HubScheduleService | undefined;
+let localRoutineScheduleCommands: HubScheduleCommandService | undefined;
+
+function getLocalRoutineScheduleCommands(): HubScheduleCommandService {
+	if (!localRoutineScheduleService || !localRoutineScheduleCommands) {
+		localRoutineScheduleService = new HubScheduleService({
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		localRoutineScheduleCommands = new HubScheduleCommandService(
+			localRoutineScheduleService,
+		);
+	}
+	return localRoutineScheduleCommands;
+}
+
+async function localRoutineScheduleCommand(
+	command: string,
+	payload?: Record<string, unknown>,
+) {
+	return await getLocalRoutineScheduleCommands().handleCommand({
+		version: "v1",
+		clientId: "code-sidecar-routines-local",
+		command: command as never,
+		payload,
+	});
+}
+
+// ---------------------------------------------------------------------------
+// User instruction config listing through the core config service.
+// ---------------------------------------------------------------------------
+
+function resolveAgentConfigSearchPaths(workspaceRoot?: string): string[] {
+	return resolveSharedAgentConfigSearchPaths(workspaceRoot);
+}
+
+async function listUserInstructionConfigs(
+	workspaceRoot: string,
+): Promise<JsonRecord> {
+	const warnings: string[] = [];
+
+	const loadUserInstructionSnapshot = async (
+		type: "rule" | "skill" | "workflow",
+	): Promise<unknown[]> => {
+		const items: unknown[] = [];
+		const service = createUserInstructionConfigService({
+			skills: { workspacePath: workspaceRoot },
+			rules: { workspacePath: workspaceRoot },
+			workflows: { workspacePath: workspaceRoot },
+		});
+		try {
+			await service.start();
+			for (const record of service.listRecords(type)) {
+				const item = record.item as unknown as JsonRecord;
+				if (item.disabled === true) continue;
+				items.push({
+					id: record.id,
+					name: item.name ?? record.id,
+					instructions: item.instructions,
+					path: record.filePath,
+				});
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnings.push(`${type}: ${message}`);
+		} finally {
+			service.stop();
+		}
+		return items;
+	};
+
+	const loadAgents = (): unknown[] => {
+		const agentsById = new Map<string, { name: string; path: string }>();
+		const directories = resolveAgentConfigSearchPaths(workspaceRoot).filter(
+			(d) => existsSync(d),
+		);
+		for (const directory of directories) {
+			try {
+				for (const entry of readdirSync(directory, { withFileTypes: true })) {
+					if (!entry.isFile()) continue;
+					const ext = extname(entry.name).toLowerCase();
+					if (ext !== ".yml" && ext !== ".yaml") continue;
+					const filePath = join(directory, entry.name);
+					const raw = readFileSync(filePath, "utf8");
+					const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+					const fm = fmMatch?.[1] ?? "";
+					const nameMatch = fm.match(/^\s*name:\s*(.+?)\s*$/m);
+					const parsedName = nameMatch?.[1]?.replace(/^["']|["']$/g, "").trim();
+					const name =
+						parsedName && parsedName.length > 0
+							? parsedName
+							: basename(entry.name, ext);
+					const id = name.toLowerCase();
+					if (!agentsById.has(id)) {
+						agentsById.set(id, { name, path: filePath });
+					}
+				}
+			} catch {
+				// best-effort
+			}
+		}
+		return [...agentsById.values()].sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+	};
+
+	const loadHooks = (): unknown[] => {
+		try {
+			return listHookConfigFiles(workspaceRoot);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnings.push(`hooks: ${message}`);
+			return [];
+		}
+	};
+
+	const loadPlugins = (): Array<{
+		name: string;
+		path: string;
+		enabled: boolean;
+	}> => {
+		const disabledPlugins = new Set(readGlobalSettings().disabledPlugins ?? []);
+		const pluginsByPath = new Map<
+			string,
+			{ name: string; path: string; enabled: boolean }
+		>();
+		const directories = resolvePluginConfigSearchPaths(workspaceRoot).filter(
+			(d) => existsSync(d),
+		);
+		for (const directory of directories) {
+			try {
+				for (const filePath of discoverPluginModulePaths(directory)) {
+					if (pluginsByPath.has(filePath)) {
+						continue;
+					}
+					pluginsByPath.set(filePath, {
+						name: basename(filePath, extname(filePath)),
+						path: filePath,
+						enabled: !disabledPlugins.has(filePath),
+					});
+				}
+			} catch {
+				// best-effort
+			}
+		}
+		return [...pluginsByPath.values()].sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+	};
+
+	const [rules, workflows, skills, pluginTools] = await Promise.all([
+		loadUserInstructionSnapshot("rule"),
+		loadUserInstructionSnapshot("workflow"),
+		loadUserInstructionSnapshot("skill"),
+		listPluginTools({
+			workspacePath: workspaceRoot,
+			cwd: workspaceRoot,
+		}),
+	]);
+
+	const disabledTools = new Set(readGlobalSettings().disabledTools ?? []);
+	const builtinToolCatalog = getCoreBuiltinToolCatalog({
+		disabledToolIds: disabledTools,
+	});
+
+	return {
+		workspaceRoot,
+		rules,
+		workflows,
+		skills,
+		agents: loadAgents(),
+		plugins: loadPlugins(),
+		tools: [
+			...builtinToolCatalog.map((tool) => ({
+				id: tool.id,
+				name: tool.id,
+				description: tool.description,
+				enabled:
+					tool.defaultEnabled &&
+					!tool.headlessToolNames.some((name) => disabledTools.has(name)),
+				source: "builtin",
+				headlessToolNames: tool.headlessToolNames,
+			})),
+			...pluginTools.map((tool) => ({
+				id: `${tool.pluginName}:${tool.name}:${tool.path}`,
+				name: tool.name,
+				description: tool.description,
+				enabled: tool.enabled,
+				source: tool.source,
+				path: tool.path,
+				pluginName: tool.pluginName,
+			})),
+		],
+		hooks: loadHooks(),
+		mcp: readMcpServersResponse(),
+		warnings,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Native OS commands
+// ---------------------------------------------------------------------------
+
+function pickWorkspaceDirectory(): string | null {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		try {
+			const result = execFileSync(
+				"osascript",
+				[
+					"-e",
+					'set theFolder to choose folder with prompt "Select workspace directory"',
+					"-e",
+					"return POSIX path of theFolder",
+				],
+				{ encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
+			).trim();
+			return result || null;
+		} catch {
+			return null;
+		}
+	}
+	// Linux — try zenity
+	try {
+		const result = execFileSync(
+			"zenity",
+			["--file-selection", "--directory", "--title=Select workspace directory"],
+			{ encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
+		).trim();
+		return result || null;
+	} catch {
+		return null;
+	}
+}
+
+function openFileInEditor(filePath: string): void {
+	const platform = process.platform;
+	const cmd =
+		platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+	const cmdArgs =
+		platform === "win32" ? ["/c", "start", "", filePath] : [filePath];
+	const child = spawn(cmd, cmdArgs, { stdio: "ignore", detached: true });
+	child.unref();
+}
+
+// ---------------------------------------------------------------------------
+// Main command router
+// ---------------------------------------------------------------------------
+
+export async function handleCommand(
+	ctx: SidecarContext,
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<unknown> {
+	// ── Chat session commands ──────────────────────────────────────────
+	if (command === "chat_session_command") {
+		const { handleChatSessionCommand } = await import("./chat-session");
+		return await handleChatSessionCommand(
+			ctx,
+			(args?.request as ChatSessionCommandRequest | undefined) ??
+				(args as ChatSessionCommandRequest),
+		);
+	}
+
+	// ── Session data reading ──────────────────────────────────────────
+	if (command === "read_session_messages") {
+		return await readSessionMessages(
+			ctx,
+			String(args?.sessionId ?? ""),
+			typeof args?.maxMessages === "number" ? args.maxMessages : 800,
+		);
+	}
+	if (command === "read_session_hooks") {
+		return await readSessionHooks(
+			String(args?.sessionId ?? ""),
+			typeof args?.limit === "number" ? args.limit : 300,
+		);
+	}
+
+	// ── Process context ───────────────────────────────────────────────
+	if (command === "get_process_context") {
+		return { workspaceRoot: ctx.workspaceRoot, cwd: ctx.workspaceRoot };
+	}
+	if (command === "get_chat_ws_endpoint") {
+		return "";
+	}
+
+	// ── Tool approvals (in-memory) ────────────────────────────────────
+	if (command === "poll_tool_approvals") {
+		const sessionId = String(args?.sessionId ?? "").trim();
+		return Array.from(ctx.pendingApprovals.values())
+			.filter((a) => a.item.sessionId === sessionId)
+			.map((a) => a.item);
+	}
+	if (command === "respond_tool_approval") {
+		const sessionId = String(args?.sessionId ?? "").trim();
+		const requestId = String(args?.requestId ?? "").trim();
+		if (!sessionId || !requestId) {
+			throw new Error("sessionId and requestId are required");
+		}
+		const pending = ctx.pendingApprovals.get(requestId);
+		if (pending) {
+			pending.resolve({
+				approved: Boolean(args?.approved),
+				...(typeof args?.reason === "string" && args.reason.trim().length > 0
+					? { reason: args.reason.trim() }
+					: {}),
+			});
+		}
+		ctx.pendingApprovals.delete(requestId);
+		const remaining = Array.from(ctx.pendingApprovals.values())
+			.filter((a) => a.item.sessionId === sessionId)
+			.map((a) => a.item);
+		broadcastEvent(ctx, "tool_approval_state", {
+			sessionId,
+			items: remaining,
+		});
+		return true;
+	}
+	if (command === "respond_ask_question") {
+		const requestId = String(args?.requestId ?? "").trim();
+		if (!requestId) {
+			throw new Error("requestId is required");
+		}
+		const answer = String(args?.answer ?? "").trim();
+		const resolved = resolveSidecarAskQuestion(ctx, requestId, answer);
+		if (!resolved) {
+			throw new Error(`unknown ask question request: ${requestId}`);
+		}
+		broadcastEvent(ctx, "ask_question_answered", { requestId });
+		return true;
+	}
+
+	// ── Session discovery ─────────────────────────────────────────────
+	if (command === "list_chat_sessions") {
+		return discoverChatSessions(
+			ctx,
+			typeof args?.limit === "number" ? args.limit : 300,
+		);
+	}
+	if (command === "list_cli_sessions") {
+		return await listSessionsFromSidecarManager(
+			ctx,
+			typeof args?.limit === "number" ? args.limit : 300,
+		);
+	}
+	if (command === "list_discovered_sessions") {
+		return await listSessionsFromSidecarManager(
+			ctx,
+			typeof args?.limit === "number" ? args.limit : 300,
+		);
+	}
+	if (command === "update_chat_session_title") {
+		const sessionId = String(args?.sessionId ?? "").trim();
+		if (!sessionId) throw new Error("session id is required");
+		const title = normalizeSessionTitle(String(args?.title ?? ""));
+		const backend = await resolveSessionBackend({ backendMode: "local" });
+		const result = await backend.updateSession({ sessionId, title });
+		if (!result.updated) throw new Error(`Session ${sessionId} not found`);
+		const liveSession = ctx.liveSessions.get(sessionId);
+		if (liveSession) liveSession.title = title;
+		return true;
+	}
+	if (command === "delete_chat_session" || command === "delete_cli_session") {
+		const sessionId = String(args?.sessionId ?? args?.session_id ?? "").trim();
+		if (!sessionId) throw new Error("session id is required");
+		console.error(
+			`[sidecar:delete] request command=${command} sessionId=${sessionId}`,
+		);
+		const store = new SqliteSessionStore();
+		const row = store.get(sessionId);
+		const manifest = readSessionManifest(sessionId);
+		let deleted = false;
+		let deleteError: Error | null = null;
+		try {
+			if (ctx.sessionManager) {
+				deleted = await ctx.sessionManager.delete(sessionId);
+			} else {
+				const backend = await resolveSessionBackend({ backendMode: "local" });
+				const deleteSession = (
+					backend as {
+						deleteSession: (
+							sessionId: string,
+							cascade?: boolean,
+						) => Promise<boolean | { deleted: boolean }>;
+					}
+				).deleteSession.bind(backend);
+				const deleteResult = await deleteSession(sessionId, true);
+				deleted =
+					typeof deleteResult === "boolean"
+						? deleteResult
+						: deleteResult.deleted;
+			}
+		} catch (error) {
+			deleteError = error instanceof Error ? error : new Error(String(error));
+		}
+		if (store.delete(sessionId, true)) {
+			deleted = true;
+		}
+		ctx.liveSessions.delete(sessionId);
+		const directoryCandidates = new Set<string>([
+			join(sharedSessionDataDir(), sessionId),
+		]);
+		for (const path of [
+			row?.messagesPath,
+			typeof manifest?.messages_path === "string"
+				? manifest.messages_path
+				: null,
+		]) {
+			if (typeof path === "string" && path.trim().length > 0) {
+				directoryCandidates.add(dirname(path));
+			}
+		}
+		for (const path of [sessionLogPath(sessionId)]) {
+			if (removePathIfExists(path, { recursive: true })) {
+				deleted = true;
+			}
+		}
+		for (const dir of directoryCandidates) {
+			if (removePathIfExists(dir, { recursive: true })) {
+				deleted = true;
+			}
+		}
+		for (const path of [
+			row?.messagesPath,
+			typeof manifest?.messages_path === "string"
+				? manifest.messages_path
+				: null,
+			join(sharedSessionDataDir(), sessionId, `${sessionId}.json`),
+		].filter((v): v is string => typeof v === "string" && v.length > 0)) {
+			if (removePathIfExists(path)) {
+				deleted = true;
+			}
+		}
+		for (const suffix of ["messages.json"]) {
+			const fileName = `${sessionId}.${suffix}`;
+			const found = findArtifactUnderDir(
+				join(sharedSessionDataDir(), rootSessionIdFrom(sessionId)),
+				fileName,
+				4,
+			);
+			if (found && removePathIfExists(found)) {
+				deleted = true;
+			}
+		}
+		if (!deleted && deleteError) {
+			console.error(
+				`[sidecar:delete] failed sessionId=${sessionId} error=${deleteError.message}`,
+			);
+			throw deleteError;
+		}
+		console.error(
+			`[sidecar:delete] result sessionId=${sessionId} deleted=${deleted}`,
+		);
+		if (deleted) {
+			broadcastEvent(ctx, "session_deleted", {
+				sessionId,
+				command,
+				deleted: true,
+			});
+		}
+		return deleted;
+	}
+
+	// ── Workspace file search ─────────────────────────────────────────
+	if (command === "search_workspace_files") {
+		return await searchWorkspaceFiles(ctx, args);
+	}
+
+	// ── Cline account ──────────────────────────────────────────────────
+	if (command === "cline_account") {
+		const operation = String(args?.operation ?? "").trim();
+		if (!operation) throw new Error("operation is required");
+		const manager = new ProviderSettingsManager();
+		const settings = manager.getProviderSettings("cline");
+		const accountService = new ClineAccountService({
+			apiBaseUrl:
+				settings?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl,
+			getAuthToken: async () => resolveLocalClineAuthToken(settings),
+		});
+		return await executeClineAccountAction(
+			args as ClineAccountActionRequest,
+			accountService,
+		);
+	}
+
+	// ── Provider management ────────────────────────────────────────────
+	if (command === "list_provider_catalog") {
+		const manager = new ProviderSettingsManager();
+		await ensureCustomProvidersLoaded(manager);
+		return await listLocalProviders(manager, { isClinePassEnabled: true });
+	}
+	if (command === "list_provider_models") {
+		const manager = new ProviderSettingsManager();
+		return await getLocalProviderModels(
+			String(args?.provider ?? ""),
+			manager.getProviderConfig(String(args?.provider ?? "").trim()),
+		);
+	}
+	if (command === "save_provider_settings") {
+		const manager = new ProviderSettingsManager();
+		return saveLocalProviderSettings(manager, {
+			...readProviderSettingsUpdate(args),
+			providerId: String(args?.provider ?? ""),
+			enabled: typeof args?.enabled === "boolean" ? args.enabled : undefined,
+			apiKey: typeof args?.api_key === "string" ? args.api_key : undefined,
+			baseUrl: typeof args?.base_url === "string" ? args.base_url : undefined,
+		});
+	}
+	if (command === "add_provider") {
+		const manager = new ProviderSettingsManager();
+		await ensureCustomProvidersLoaded(manager);
+		return await addLocalProvider(manager, {
+			providerId: String(args?.provider_id ?? ""),
+			name: String(args?.name ?? ""),
+			baseUrl: String(args?.base_url ?? ""),
+			apiKey: typeof args?.api_key === "string" ? args.api_key : undefined,
+			headers:
+				args?.headers && typeof args.headers === "object"
+					? (args.headers as Record<string, string>)
+					: undefined,
+			timeoutMs:
+				typeof args?.timeout_ms === "number" ? args.timeout_ms : undefined,
+			models: Array.isArray(args?.models)
+				? (args.models as string[])
+				: undefined,
+			defaultModelId:
+				typeof args?.default_model_id === "string"
+					? args.default_model_id
+					: undefined,
+			modelsSourceUrl:
+				typeof args?.models_source_url === "string"
+					? args.models_source_url
+					: undefined,
+			protocol:
+				typeof args?.protocol === "string"
+					? (args.protocol as ProviderProtocol)
+					: undefined,
+			client:
+				typeof args?.client === "string"
+					? (args.client as ProviderClient)
+					: undefined,
+			capabilities: Array.isArray(args?.capabilities)
+				? (args.capabilities as ProviderCapability[])
+				: undefined,
+		});
+	}
+	if (command === "run_provider_oauth_login") {
+		const providerId = normalizeOAuthProvider(String(args?.provider ?? ""));
+		const manager = new ProviderSettingsManager();
+		const saved = await loginAndSaveLocalProviderOAuthCredentials(
+			manager,
+			providerId,
+			(url) => {
+				const platform = process.platform;
+				const spawned =
+					platform === "darwin"
+						? spawn("open", [url], { stdio: "ignore", detached: true })
+						: platform === "win32"
+							? spawn("cmd", ["/c", "start", "", url], {
+									stdio: "ignore",
+									detached: true,
+								})
+							: spawn("xdg-open", [url], {
+									stdio: "ignore",
+									detached: true,
+								});
+				spawned.unref();
+			},
+		);
+		if (saved.provider !== providerId) {
+			markLocalProviderEnabled(manager, providerId, { tokenSource: "oauth" });
+		}
+		return {
+			provider: providerId,
+			accessToken: saved.auth?.accessToken ?? saved.apiKey ?? "",
+		};
+	}
+
+	// ── Global settings ────────────────────────────────────────────────
+	if (command === "get_global_settings") {
+		return readGlobalSettings();
+	}
+	if (command === "set_telemetry_opt_out") {
+		if (typeof args?.telemetry_opt_out !== "boolean") {
+			throw new Error("telemetry_opt_out must be a boolean");
+		}
+		setTelemetryOptOutGlobally(args.telemetry_opt_out);
+		return readGlobalSettings();
+	}
+	if (command === "set_auto_update_enabled") {
+		if (typeof args?.auto_update_enabled !== "boolean") {
+			throw new Error("auto_update_enabled must be a boolean");
+		}
+		setAutoUpdateEnabledGlobally(args.auto_update_enabled);
+		return readGlobalSettings();
+	}
+
+	// ── Connector channels ─────────────────────────────────────────────
+	if (command === "list_connector_channels") {
+		return connectorChannelsPayload();
+	}
+	if (command === "start_connector_channel") {
+		return await startConnectorChannel(ctx.workspaceRoot, args);
+	}
+	if (command === "stop_connector_channel") {
+		return await stopConnectorChannel(ctx.workspaceRoot, args);
+	}
+
+	// ── MCP server management ─────────────────────────────────────────
+	if (command === "list_mcp_servers") {
+		return readMcpServersResponse();
+	}
+	if (command === "set_mcp_server_disabled") {
+		const path = ensureMcpSettingsFile();
+		updateMcpSettingsFileSync(path, (settings) => {
+			const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+				{}) as JsonRecord;
+			const name = String(args?.name ?? "").trim();
+			const current = servers[name];
+			if (!current || typeof current !== "object") {
+				throw new Error(`unknown MCP server: ${name}`);
+			}
+			servers[name] = {
+				...(current as JsonRecord),
+				disabled: Boolean(args?.disabled),
+			};
+			settings.mcpServers = servers;
+		});
+		return readMcpServersResponse();
+	}
+	if (command === "upsert_mcp_server") {
+		const input =
+			args?.input && typeof args.input === "object"
+				? (args.input as JsonRecord)
+				: (args as JsonRecord);
+		const name = String(input.name ?? "").trim();
+		if (!name) throw new Error("server name is required");
+		const previousName = String(
+			input.previousName ?? input.previous_name ?? "",
+		).trim();
+		const transportType = String(
+			input.transportType ?? input.transport_type ?? "",
+		).trim();
+		const next: JsonRecord =
+			transportType === "stdio"
+				? {
+						transport: {
+							type: "stdio",
+							command: input.command,
+							args: input.args,
+							cwd: input.cwd,
+							env: input.env,
+						},
+						disabled: Boolean(input.disabled),
+						metadata: input.metadata,
+					}
+				: {
+						transport: {
+							type: transportType,
+							url: input.url,
+							headers: input.headers,
+						},
+						disabled: Boolean(input.disabled),
+						metadata: input.metadata,
+					};
+		const path = ensureMcpSettingsFile();
+		updateMcpSettingsFileSync(path, (settings) => {
+			const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+				{}) as JsonRecord;
+			if (previousName && previousName !== name) {
+				delete servers[previousName];
+			}
+			servers[name] = next;
+			settings.mcpServers = servers;
+		});
+		return readMcpServersResponse();
+	}
+	if (command === "delete_mcp_server") {
+		const path = ensureMcpSettingsFile();
+		updateMcpSettingsFileSync(path, (settings) => {
+			const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+				{}) as JsonRecord;
+			delete servers[String(args?.name ?? "")];
+			settings.mcpServers = servers;
+		});
+		return readMcpServersResponse();
+	}
+	if (command === "ensure_mcp_settings_file") {
+		return ensureMcpSettingsFile();
+	}
+
+	// ── Git operations ─────────────────────────────────────────────────
+	if (command === "get_git_branch") {
+		const branches = listGitBranches(
+			ctx,
+			typeof args?.cwd === "string" ? args.cwd : undefined,
+		);
+		return { branch: branches.current };
+	}
+	if (command === "list_git_branches") {
+		return listGitBranches(
+			ctx,
+			typeof args?.cwd === "string" ? args.cwd : undefined,
+		);
+	}
+	if (command === "checkout_git_branch") {
+		const cwd = typeof args?.cwd === "string" ? args.cwd : undefined;
+		const branch = String(args?.branch ?? "").trim();
+		if (!branch) throw new Error("branch is required");
+		execFileSync("git", ["checkout", branch], {
+			cwd: cwd?.trim() || ctx.workspaceRoot,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		return { branch };
+	}
+
+	// ── Routine schedules ─────────────────────────────────────────────
+	if (
+		command === "list_routine_schedules" ||
+		command === "create_routine_schedule" ||
+		command === "pause_routine_schedule" ||
+		command === "resume_routine_schedule" ||
+		command === "trigger_routine_schedule" ||
+		command === "delete_routine_schedule"
+	) {
+		return await handleRoutineScheduleCommand(command, args);
+	}
+
+	// ── User instruction configs ──────────────────────────────────────
+	if (command === "list_user_instruction_configs") {
+		return await listUserInstructionConfigs(ctx.workspaceRoot);
+	}
+	if (command === "list_marketplace_installed_entries") {
+		return listMarketplaceInstalledEntries(
+			args,
+			await listUserInstructionConfigs(ctx.workspaceRoot),
+		);
+	}
+	if (command === "install_marketplace_entry") {
+		const result = await installMarketplaceEntryForDesktopCommand(args);
+		return result;
+	}
+	if (command === "uninstall_marketplace_entry") {
+		const result = await uninstallMarketplaceEntryForDesktopCommand(args);
+		return result;
+	}
+	if (command === "uninstall_local_primitive") {
+		const result = await uninstallLocalPrimitive(args, {
+			workspaceRoot: ctx.workspaceRoot,
+		});
+		return result;
+	}
+	if (command === "toggle_disabled_plugin_tool") {
+		const toolName = String(args?.name ?? "").trim();
+		if (!toolName) {
+			throw new Error("tool name is required");
+		}
+		toggleDisabledTool(toolName);
+		return await listUserInstructionConfigs(ctx.workspaceRoot);
+	}
+	if (command === "set_tool_disabled") {
+		const rawNames = Array.isArray(args?.names) ? args.names : [args?.name];
+		const toolNames = rawNames
+			.map((name) => String(name ?? "").trim())
+			.filter(Boolean);
+		if (toolNames.length === 0) {
+			throw new Error("tool name is required");
+		}
+		setDisabledTools(toolNames, args?.disabled === true);
+		return await listUserInstructionConfigs(ctx.workspaceRoot);
+	}
+	if (command === "set_plugin_disabled") {
+		const pluginPath = String(args?.path ?? "").trim();
+		if (!pluginPath) {
+			throw new Error("plugin path is required");
+		}
+		setDisabledPlugin(pluginPath, args?.disabled === true);
+		return await listUserInstructionConfigs(ctx.workspaceRoot);
+	}
+
+	// ── Native OS commands ────────────────────────────────────────────
+	if (command === "pick_workspace_directory") {
+		return pickWorkspaceDirectory();
+	}
+	if (command === "open_mcp_settings_file") {
+		const path = ensureMcpSettingsFile();
+		openFileInEditor(path);
+		return path;
+	}
+
+	throw new Error(`unsupported desktop command: ${command}`);
+}
diff --git a/apps/examples/desktop-app/sidecar/connectors.ts b/apps/examples/desktop-app/sidecar/connectors.ts
new file mode 100644
index 0000000..8b47417
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/connectors.ts
@@ -0,0 +1,307 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, join, normalize } from "node:path";
+import process from "node:process";
+import { withResolvedClineBuildEnv } from "@cline/shared";
+import { listConnectorCatalog } from "../../../cli/src/connectors/catalog";
+import { listActiveConnectors } from "../../../cli/src/connectors/status";
+import {
+	PLATFORMS,
+	shouldIncludeField,
+} from "../../../cli/src/wizards/connect/platforms";
+import type { JsonRecord } from "./types";
+
+type ConnectorField = {
+	flag: string;
+	label: string;
+	placeholder?: string;
+	required?: boolean;
+	help?: string[];
+	initialValue?: string;
+	options?: Array<{ value: string; label: string; hint?: string }>;
+	includeWhen?: {
+		flag: string;
+		equals?: string;
+		notEquals?: string;
+	};
+};
+
+type ConnectorSecurityField = {
+	key: string;
+	label: string;
+	placeholder?: string;
+	help?: string[];
+	requiredMessage: string;
+};
+
+type WebviewConnectorChannel = {
+	id: string;
+	name: string;
+	type: "polling" | "webhook" | "hybrid";
+	hint: string;
+	fields: ConnectorField[];
+	security?: {
+		prompt: string;
+		fields: ConnectorSecurityField[];
+	};
+};
+
+type WebviewConnectorChannelsResponse = {
+	available: WebviewConnectorChannel[];
+	active: ReturnType<typeof listActiveConnectors>;
+};
+
+type CliConnectCommand = {
+	launcher: string;
+	childArgs: string[];
+};
+
+const ANSI_ESCAPE_PATTERN = new RegExp(
+	[
+		"[\\u001B\\u009B][[\\]()#;?]*",
+		"(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)",
+		"|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+	].join(""),
+	"g",
+);
+
+function asRecord(value: unknown): JsonRecord | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as JsonRecord)
+		: undefined;
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" ? value.trim() || undefined : undefined;
+}
+
+function stripAnsi(value: string): string {
+	return value.replace(ANSI_ESCAPE_PATTERN, "");
+}
+
+function normalizeConnectorError(rawMessage: string, fallback: string): string {
+	const message =
+		stripAnsi(rawMessage)
+			.replace(/\r\n/g, "\n")
+			.trim()
+			.replace(/^(?:error:\s*)+/i, "")
+			.trim() || fallback;
+
+	if (
+		/^Telegram getMe failed \(401 Unauthorized\): Unauthorized$/i.test(message)
+	) {
+		return "Telegram rejected this bot token. Copy the token from @BotFather and try again.";
+	}
+
+	return message.slice(0, 2_000);
+}
+
+function buildCliConnectCommand(
+	workspaceRoot: string,
+	args: string[],
+	options: {
+		execPath?: string;
+		cliPath?: string;
+		exists?: (path: string) => boolean;
+	} = {},
+): CliConnectCommand {
+	const execPath = options.execPath ?? process.execPath;
+	const cliPath =
+		options.cliPath ?? normalize(join(workspaceRoot, "apps/cli/src/index.ts"));
+	const exists = options.exists ?? existsSync;
+	const runtimeName = basename(execPath).toLowerCase();
+	const isBunRuntime = runtimeName.includes("bun");
+	const isNodeRuntime = runtimeName === "node" || runtimeName === "node.exe";
+	const useBunSourceEntrypoint =
+		(isBunRuntime || isNodeRuntime) && exists(cliPath);
+	const launcher = isBunRuntime
+		? execPath
+		: useBunSourceEntrypoint
+			? "bun"
+			: execPath;
+	const childArgs = useBunSourceEntrypoint
+		? ["--conditions=development", cliPath, "connect", ...args]
+		: ["connect", ...args];
+	return { launcher, childArgs };
+}
+
+export function connectorChannelsPayload(): WebviewConnectorChannelsResponse {
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	const available: WebviewConnectorChannel[] = PLATFORMS.filter((platform) =>
+		supported.has(platform.id),
+	).map((platform) => ({
+		id: platform.id,
+		name: platform.name,
+		type: platform.type,
+		hint: platform.hint,
+		fields: platform.fields.map((field) => ({
+			flag: field.flag,
+			label: field.label,
+			placeholder: field.placeholder,
+			required: field.required,
+			help: field.help,
+			initialValue: field.initialValue,
+			options: field.options,
+			includeWhen: field.includeWhen,
+		})),
+		security: platform.security
+			? {
+					prompt: platform.security.prompt,
+					fields: platform.security.fields.map((field) => ({
+						key: field.key,
+						label: field.label,
+						placeholder: field.placeholder,
+						help: field.help,
+						requiredMessage: field.requiredMessage,
+					})),
+				}
+			: undefined,
+	}));
+	return { available, active: listActiveConnectors() };
+}
+
+async function runCliConnectCommand(
+	workspaceRoot: string,
+	args: string[],
+): Promise<{
+	code: number;
+	stdout: string;
+	stderr: string;
+}> {
+	const { launcher, childArgs } = buildCliConnectCommand(workspaceRoot, args);
+	const child = spawn(launcher, childArgs, {
+		cwd: workspaceRoot,
+		env: withResolvedClineBuildEnv(process.env),
+		stdio: ["ignore", "pipe", "pipe"],
+		windowsHide: true,
+	});
+	let stdout = "";
+	let stderr = "";
+	child.stdout?.setEncoding("utf8");
+	child.stderr?.setEncoding("utf8");
+	child.stdout?.on("data", (chunk) => {
+		stdout += String(chunk);
+	});
+	child.stderr?.on("data", (chunk) => {
+		stderr += String(chunk);
+	});
+	const code = await new Promise<number>((resolve, reject) => {
+		child.on("error", reject);
+		child.on("close", (exitCode) => resolve(exitCode ?? 0));
+	});
+	return { code, stdout, stderr };
+}
+
+async function waitForConnectorState(
+	predicate: () => boolean,
+	timeoutMs = 5_000,
+): Promise<void> {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < timeoutMs) {
+		if (predicate()) return;
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	throw new Error(
+		`connector did not reach expected state within ${timeoutMs}ms`,
+	);
+}
+
+function buildConnectorStartArgs(args?: Record<string, unknown>): string[] {
+	const channel = asString(args?.channel);
+	if (!channel) throw new Error("channel is required");
+	const platform = PLATFORMS.find((entry) => entry.id === channel);
+	if (!platform) throw new Error(`unknown connector channel: ${channel}`);
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	if (!supported.has(platform.id)) {
+		throw new Error(`connector channel is not available: ${channel}`);
+	}
+	const values = asRecord(args?.values) ?? {};
+	const fieldValues: Record<string, string> = {};
+	for (const field of platform.fields) {
+		const rawValue = values[field.flag];
+		if (typeof rawValue === "string") {
+			fieldValues[field.flag] = rawValue.trim();
+		} else if (field.initialValue) {
+			fieldValues[field.flag] = field.initialValue;
+		}
+	}
+	const cliArgs = [channel];
+	for (const field of platform.fields) {
+		if (!shouldIncludeField(field, fieldValues)) {
+			continue;
+		}
+		const value = fieldValues[field.flag];
+		if (!value) {
+			if (field.required) throw new Error(`${field.label} is required`);
+			continue;
+		}
+		cliArgs.push(field.flag, value);
+	}
+	const security = asRecord(args?.security);
+	if (security?.enabled === true && platform.security) {
+		const securityValues = asRecord(security.values) ?? {};
+		const hookValues: Record<string, string> = {};
+		for (const field of platform.security.fields) {
+			const value = asString(securityValues[field.key]);
+			if (!value) throw new Error(field.requiredMessage);
+			const validationError = field.validate?.(value);
+			if (validationError) throw new Error(validationError);
+			hookValues[field.key] = value;
+		}
+		cliArgs.push(...platform.security.buildArgs(hookValues));
+	}
+	return cliArgs;
+}
+
+export async function startConnectorChannel(
+	workspaceRoot: string,
+	args?: Record<string, unknown>,
+): Promise<WebviewConnectorChannelsResponse> {
+	const cliArgs = buildConnectorStartArgs(args);
+	const channel = cliArgs[0] ?? "";
+	const result = await runCliConnectCommand(workspaceRoot, cliArgs);
+	if (result.code !== 0) {
+		throw new Error(
+			normalizeConnectorError(
+				result.stderr || result.stdout,
+				"connector start failed",
+			),
+		);
+	}
+	await waitForConnectorState(() =>
+		listActiveConnectors().some((connector) => connector.type === channel),
+	);
+	return connectorChannelsPayload();
+}
+
+export async function stopConnectorChannel(
+	workspaceRoot: string,
+	args?: Record<string, unknown>,
+): Promise<WebviewConnectorChannelsResponse> {
+	const channel = asString(args?.channel);
+	if (!channel) throw new Error("channel is required");
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	if (!supported.has(channel)) {
+		throw new Error(`unknown connector channel: ${channel}`);
+	}
+	const result = await runCliConnectCommand(workspaceRoot, [channel, "--stop"]);
+	if (result.code !== 0) {
+		throw new Error(
+			normalizeConnectorError(
+				result.stderr || result.stdout,
+				"connector stop failed",
+			),
+		);
+	}
+	await waitForConnectorState(
+		() =>
+			!listActiveConnectors().some((connector) => connector.type === channel),
+	);
+	return connectorChannelsPayload();
+}
diff --git a/apps/examples/desktop-app/sidecar/context.test.ts b/apps/examples/desktop-app/sidecar/context.test.ts
new file mode 100644
index 0000000..64955e4
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/context.test.ts
@@ -0,0 +1,256 @@
+import type { RuntimeCapabilities } from "@cline/core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { SidecarContext } from "./types";
+
+const createCoreMock = vi.hoisted(() => vi.fn());
+const connectMock = vi.hoisted(() => vi.fn());
+const nodeHubClientCtorMock = vi.hoisted(() => vi.fn());
+const resolveHubOwnerContextMock = vi.hoisted(() => vi.fn());
+const startHubWebSocketServerMock = vi.hoisted(() => vi.fn());
+const subscribeMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@cline/core", async () => {
+	const actual =
+		await vi.importActual<typeof import("@cline/core")>("@cline/core");
+	return {
+		...actual,
+		ClineCore: {
+			create: createCoreMock,
+		},
+		createLocalHubScheduleRuntimeHandlers: vi.fn(() => ({
+			startSession: vi.fn(),
+			sendSession: vi.fn(),
+			abortSession: vi.fn(),
+			stopSession: vi.fn(),
+		})),
+		resolveHubOwnerContext: resolveHubOwnerContextMock,
+		startHubWebSocketServer: startHubWebSocketServerMock,
+		NodeHubClient: class {
+			constructor(options: unknown) {
+				nodeHubClientCtorMock(options);
+			}
+			connect = connectMock;
+			subscribe = subscribeMock;
+			dispose = vi.fn();
+		},
+	};
+});
+
+function readEvents(ctx: SidecarContext): Array<{
+	event: { name: string; payload: Record<string, unknown> };
+}> {
+	const [client] = ctx.wsClients;
+	const send = client?.send;
+	if (!send || typeof send !== "function" || !("mock" in send)) {
+		return [];
+	}
+	return (send as ReturnType<typeof vi.fn>).mock.calls.map(([raw]) =>
+		JSON.parse(String(raw)),
+	);
+}
+
+describe("Code sidecar runtime capabilities", () => {
+	beforeEach(() => {
+		createCoreMock.mockReset();
+		connectMock.mockReset();
+		nodeHubClientCtorMock.mockReset();
+		resolveHubOwnerContextMock.mockReset();
+		startHubWebSocketServerMock.mockReset();
+		subscribeMock.mockReset();
+		connectMock.mockResolvedValue(undefined);
+		resolveHubOwnerContextMock.mockReturnValue({
+			ownerId: "code-sidecar-test",
+			discoveryPath: "/tmp/code-sidecar-test.json",
+		});
+		startHubWebSocketServerMock.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+			close: vi.fn(),
+		});
+		subscribeMock.mockReturnValue(() => {});
+		createCoreMock.mockResolvedValue({
+			runtimeAddress: "ws://127.0.0.1:25463/hub",
+			subscribe: vi.fn(() => () => {}),
+			dispose: vi.fn(),
+		});
+	});
+
+	it("registers Code App capability factory with core", async () => {
+		const { createSidecarContext, initializeSessionManager } = await import(
+			"./context"
+		);
+
+		const ctx = createSidecarContext("/workspace/project");
+		await initializeSessionManager(ctx);
+
+		expect(startHubWebSocketServerMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				port: 0,
+				owner: {
+					ownerId: "code-sidecar-test",
+					discoveryPath: "/tmp/code-sidecar-test.json",
+				},
+			}),
+		);
+		expect(createCoreMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				backendMode: "hub",
+				capabilities: expect.objectContaining({
+					toolExecutors: expect.objectContaining({
+						askQuestion: expect.any(Function),
+					}),
+					requestToolApproval: expect.any(Function),
+				}),
+				hub: expect.objectContaining({
+					endpoint: "ws://127.0.0.1:25463/hub",
+					authToken: "test-token",
+					clientType: "code-sidecar",
+					displayName: "Code App sidecar",
+				}),
+			}),
+		);
+		expect(nodeHubClientCtorMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "test-token",
+				clientType: "code-sidecar-approvals",
+			}),
+		);
+	});
+
+	it("resolves askQuestion through the websocket request/response protocol", async () => {
+		const { createSidecarContext, initializeSessionManager } = await import(
+			"./context"
+		);
+		const { handleCommand } = await import("./commands");
+
+		const ctx = createSidecarContext("/workspace/project");
+		ctx.wsClients.add({ send: vi.fn() });
+
+		await initializeSessionManager(ctx);
+
+		const capabilities = createCoreMock.mock.calls[0][0]
+			.capabilities as RuntimeCapabilities;
+		const answer = capabilities.toolExecutors?.askQuestion?.(
+			"Which branch?",
+			["Keep current", "Create new"],
+			{
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 3,
+			},
+		);
+
+		expect(answer).toBeInstanceOf(Promise);
+		const event = readEvents(ctx).find(
+			(item) => item.event.name === "ask_question_requested",
+		);
+		expect(event?.event.payload).toMatchObject({
+			question: "Which branch?",
+			options: ["Keep current", "Create new"],
+			context: {
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 3,
+			},
+		});
+		const requestId = String(event?.event.payload.requestId ?? "");
+		expect(requestId.length).toBeGreaterThan(0);
+
+		await handleCommand(ctx, "respond_ask_question", {
+			requestId,
+			answer: "Create new",
+		});
+
+		await expect(answer).resolves.toBe("Create new");
+		expect(ctx.pendingQuestions.size).toBe(0);
+		expect(readEvents(ctx)).toContainEqual(
+			expect.objectContaining({
+				event: expect.objectContaining({
+					name: "ask_question_answered",
+					payload: { requestId },
+				}),
+			}),
+		);
+	});
+
+	it("resolves approval through websocket state", async () => {
+		const { createSidecarContext, initializeSessionManager } = await import(
+			"./context"
+		);
+		const { handleCommand } = await import("./commands");
+
+		const ctx = createSidecarContext("/workspace/project");
+		ctx.wsClients.add({ send: vi.fn() });
+
+		await initializeSessionManager(ctx);
+
+		expect(createCoreMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				backendMode: "hub",
+				capabilities: expect.objectContaining({
+					requestToolApproval: expect.any(Function),
+				}),
+				hub: expect.objectContaining({
+					endpoint: "ws://127.0.0.1:25463/hub",
+					authToken: "test-token",
+					clientType: "code-sidecar",
+					displayName: "Code App sidecar",
+				}),
+			}),
+		);
+
+		const capabilities = createCoreMock.mock.calls[0][0]
+			.capabilities as RuntimeCapabilities;
+		const approval = capabilities.requestToolApproval?.({
+			sessionId: "sess-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 2,
+			toolCallId: "tool-call-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+
+		expect(approval).toBeInstanceOf(Promise);
+		const pending = await handleCommand(ctx, "poll_tool_approvals", {
+			sessionId: "sess-1",
+		});
+		expect(pending).toEqual([
+			expect.objectContaining({
+				sessionId: "sess-1",
+				toolCallId: "tool-call-1",
+				toolName: "run_commands",
+				input: { commands: ["echo hi"] },
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+			}),
+		]);
+		expect(readEvents(ctx)).toContainEqual(
+			expect.objectContaining({
+				event: expect.objectContaining({
+					name: "tool_approval_state",
+					payload: expect.objectContaining({
+						sessionId: "sess-1",
+						items: expect.arrayContaining([
+							expect.objectContaining({ toolCallId: "tool-call-1" }),
+						]),
+					}),
+				}),
+			}),
+		);
+
+		const [{ requestId }] = pending as Array<{ requestId: string }>;
+		await handleCommand(ctx, "respond_tool_approval", {
+			sessionId: "sess-1",
+			requestId,
+			approved: true,
+		});
+
+		await expect(approval).resolves.toEqual({ approved: true });
+		expect(
+			await handleCommand(ctx, "poll_tool_approvals", { sessionId: "sess-1" }),
+		).toEqual([]);
+	});
+});
diff --git a/apps/examples/desktop-app/sidecar/context.ts b/apps/examples/desktop-app/sidecar/context.ts
new file mode 100644
index 0000000..56174fa
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/context.ts
@@ -0,0 +1,741 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+import {
+	type AgentToolContext,
+	ClineCore,
+	createLocalHubScheduleRuntimeHandlers,
+	type CoreSessionEvent,
+	NodeHubClient,
+	resolveHubOwnerContext,
+	type RuntimeCapabilities,
+	setHomeDirIfUnset,
+	startHubWebSocketServer,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+} from "@cline/core";
+import type { AgentEvent } from "@cline/shared";
+import { sessionLogPath } from "./paths";
+import type {
+	LiveSession,
+	PendingAskQuestion,
+	PendingToolApproval,
+	PromptInQueue,
+	SidecarContext,
+} from "./types";
+
+const ASK_QUESTION_TIMEOUT_MS = 5 * 60_000;
+
+// ---------------------------------------------------------------------------
+// Helpers — WebSocket broadcast
+// ---------------------------------------------------------------------------
+
+function nowMs(): number {
+	return Date.now();
+}
+
+function sendEvent(ctx: SidecarContext, name: string, payload: unknown): void {
+	const encoded = JSON.stringify({
+		type: "event",
+		event: { name, payload },
+	});
+	for (const client of ctx.wsClients) {
+		try {
+			client.send(encoded);
+		} catch {
+			ctx.wsClients.delete(client);
+		}
+	}
+}
+
+function appendSessionChunk(
+	sessionId: string,
+	stream: string,
+	chunk: string,
+	ts: number,
+): void {
+	const path = sessionLogPath(sessionId);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify({ ts, stream, chunk })}\n`, {
+		flag: "a",
+	});
+}
+
+function emitChunk(
+	ctx: SidecarContext,
+	sessionId: string,
+	stream: string,
+	chunk: string,
+): void {
+	const ts = nowMs();
+	appendSessionChunk(sessionId, stream, chunk, ts);
+	const nextIndex = (ctx.streamIndices.get(sessionId) ?? 0) + 1;
+	ctx.streamIndices.set(sessionId, nextIndex);
+	sendEvent(ctx, "chat_event", {
+		sessionId,
+		stream,
+		chunk,
+		ts,
+		index: nextIndex,
+	});
+}
+
+export { sendEvent, emitChunk, nowMs };
+
+// ---------------------------------------------------------------------------
+// Exported broadcast helpers (used by server.ts / commands)
+// ---------------------------------------------------------------------------
+
+export function broadcastEvent(
+	ctx: SidecarContext,
+	name: string,
+	payload: unknown,
+): void {
+	sendEvent(ctx, name, payload);
+}
+
+export function broadcastChunk(
+	ctx: SidecarContext,
+	sessionId: string,
+	stream: string,
+	chunk: string,
+): void {
+	emitChunk(ctx, sessionId, stream, chunk);
+}
+
+// ---------------------------------------------------------------------------
+// Prompt queue helpers
+// ---------------------------------------------------------------------------
+
+function getPromptsInQueue(session: LiveSession): PromptInQueue[] {
+	return session.promptsInQueue;
+}
+
+function sendPromptsInQueueSnapshot(
+	ctx: SidecarContext,
+	sessionId: string,
+): void {
+	const session = ctx.liveSessions.get(sessionId);
+	sendEvent(ctx, "prompts_in_queue_state", {
+		sessionId,
+		items: session ? getPromptsInQueue(session) : [],
+	});
+}
+
+// ---------------------------------------------------------------------------
+// Agent event mapping: AgentEvent → frontend transport chunks
+// ---------------------------------------------------------------------------
+
+function handleAgentEvent(
+	ctx: SidecarContext,
+	sessionId: string,
+	event: AgentEvent,
+): void {
+	switch (event.type) {
+		case "content_start": {
+			if (event.contentType === "text" && event.text) {
+				emitChunk(ctx, sessionId, "chat_text", event.text);
+			} else if (event.contentType === "reasoning" && event.reasoning) {
+				emitChunk(
+					ctx,
+					sessionId,
+					"chat_reasoning",
+					JSON.stringify({
+						text: event.reasoning,
+						redacted: event.redacted === true,
+					}),
+				);
+			} else if (event.contentType === "tool") {
+				emitChunk(
+					ctx,
+					sessionId,
+					"chat_tool_call_start",
+					JSON.stringify({
+						toolCallId: event.toolCallId,
+						toolName: event.toolName,
+						input: event.input,
+					}),
+				);
+			}
+			break;
+		}
+		case "content_update": {
+			if (event.contentType === "tool") {
+				emitChunk(
+					ctx,
+					sessionId,
+					"chat_tool_call_update",
+					JSON.stringify({
+						toolCallId: event.toolCallId,
+						toolName: event.toolName,
+						update: event.update,
+					}),
+				);
+			}
+			break;
+		}
+		case "content_end": {
+			// Text and reasoning `content_start` events are already emitted as
+			// incremental deltas. Runtime `content_end` carries the final full text,
+			// so forwarding it as another chat_text/chat_reasoning chunk duplicates
+			// the live UI while persisted history remains correct after hydration.
+			if (event.contentType === "text" || event.contentType === "reasoning") {
+				break;
+			}
+			if (event.contentType === "tool") {
+				emitChunk(
+					ctx,
+					sessionId,
+					"chat_tool_call_end",
+					JSON.stringify({
+						toolCallId: event.toolCallId,
+						toolName: event.toolName,
+						output: event.output,
+						error: event.error,
+						durationMs: event.durationMs,
+					}),
+				);
+			}
+			break;
+		}
+		case "notice": {
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_core_log",
+				JSON.stringify({
+					level: event.noticeType === "recovery" ? "warn" : "info",
+					message: event.message,
+					noticeType: event.noticeType,
+					reason: event.reason,
+				}),
+			);
+			break;
+		}
+		case "usage": {
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_usage",
+				JSON.stringify({
+					inputTokens: event.inputTokens,
+					outputTokens: event.outputTokens,
+					cacheReadTokens: event.cacheReadTokens,
+					cacheWriteTokens: event.cacheWriteTokens,
+					cost: event.cost,
+					totalInputTokens: event.totalInputTokens,
+					totalOutputTokens: event.totalOutputTokens,
+					totalCost: event.totalCost,
+				}),
+			);
+			break;
+		}
+		case "done": {
+			const session = ctx.liveSessions.get(sessionId);
+			if (session) {
+				session.busy = false;
+				session.status = event.reason === "completed" ? "idle" : event.reason;
+			}
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_done",
+				JSON.stringify({
+					reason: event.reason,
+					text: event.text,
+					iterations: event.iterations,
+					usage: event.usage,
+				}),
+			);
+			break;
+		}
+		case "error": {
+			const message =
+				event.error instanceof Error
+					? event.error.message
+					: String(event.error);
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_core_log",
+				JSON.stringify({
+					level: "error",
+					message,
+				}),
+			);
+			break;
+		}
+		case "iteration_start":
+		case "iteration_end":
+			break;
+	}
+}
+
+// ---------------------------------------------------------------------------
+// CoreSessionEvent routing
+// ---------------------------------------------------------------------------
+
+function handleCoreSessionEvent(
+	ctx: SidecarContext,
+	event: CoreSessionEvent,
+): void {
+	switch (event.type) {
+		case "chunk": {
+			const { sessionId, stream, chunk } = event.payload;
+			if (stream === "agent") break;
+			emitChunk(ctx, sessionId, stream, chunk);
+			break;
+		}
+		case "agent_event": {
+			const { sessionId, event: agentEvent } = event.payload;
+			handleAgentEvent(ctx, sessionId, agentEvent);
+			break;
+		}
+		case "pending_prompts": {
+			const { sessionId, prompts } = event.payload;
+			const session = ctx.liveSessions.get(sessionId);
+			const mapped: PromptInQueue[] = prompts
+				.map((item) => ({
+					id: item.id ?? "",
+					prompt: item.prompt ?? "",
+					steer: item.delivery === "steer",
+					attachmentCount: item.attachmentCount ?? 0,
+				}))
+				.filter((item) => item.id && item.prompt);
+			if (session) {
+				const previous = session.promptsInQueue;
+				session.promptsInQueue = mapped;
+				if (
+					previous.length > mapped.length &&
+					previous[0] &&
+					previous[0].id !== mapped[0]?.id
+				) {
+					emitChunk(
+						ctx,
+						sessionId,
+						"chat_queued_prompt_start",
+						JSON.stringify({
+							prompt: previous[0].prompt,
+							attachmentCount: previous[0].attachmentCount ?? 0,
+						}),
+					);
+				}
+			}
+			sendPromptsInQueueSnapshot(ctx, sessionId);
+			break;
+		}
+		case "pending_prompt_submitted": {
+			const { sessionId, prompt, attachmentCount } = event.payload;
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_queued_prompt_start",
+				JSON.stringify({
+					prompt,
+					attachmentCount: attachmentCount ?? 0,
+				}),
+			);
+			break;
+		}
+		case "ended": {
+			const { sessionId, reason } = event.payload;
+			const session = ctx.liveSessions.get(sessionId);
+			if (session) {
+				session.busy = false;
+				session.endedAt = nowMs();
+				session.status = reason || "ended";
+			}
+			sendEvent(ctx, "chat_session_ended", { sessionId, reason });
+			break;
+		}
+		case "hook": {
+			const hookPayload = event.payload;
+			emitChunk(
+				ctx,
+				hookPayload.sessionId,
+				"chat_hook",
+				JSON.stringify(hookPayload),
+			);
+			break;
+		}
+		case "status": {
+			const { sessionId, status } = event.payload;
+			const session = ctx.liveSessions.get(sessionId);
+			if (session) {
+				session.status = status;
+				session.busy = status === "running";
+			}
+			sendEvent(ctx, "chat_session_status", { sessionId, status });
+			break;
+		}
+		case "team_progress": {
+			sendEvent(ctx, "team_progress", event.payload);
+			break;
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Context factory
+// ---------------------------------------------------------------------------
+
+export function createSidecarContext(workspaceRoot: string): SidecarContext {
+	return {
+		liveSessions: new Map(),
+		streamIndices: new Map(),
+		wsClients: new Set(),
+		pendingApprovals: new Map(),
+		pendingQuestions: new Map(),
+		sessionManager: null,
+		hubClient: null,
+		hubServer: null,
+		workspaceRoot,
+		unsubscribeSessionEvents: null,
+	};
+}
+
+export async function disposeSidecarContext(
+	ctx: SidecarContext,
+	reason = "code_sidecar_shutdown",
+): Promise<void> {
+	const cleanup: Array<Promise<unknown>> = [];
+
+	ctx.unsubscribeSessionEvents?.();
+	ctx.unsubscribeSessionEvents = null;
+
+	for (const client of ctx.wsClients) {
+		try {
+			client.close?.();
+		} catch {
+			// Best-effort websocket close during shutdown.
+		}
+	}
+	ctx.wsClients.clear();
+	for (const pending of ctx.pendingApprovals.values()) {
+		pending.resolve({ approved: false, reason });
+	}
+	ctx.pendingApprovals.clear();
+	for (const pending of ctx.pendingQuestions.values()) {
+		if (pending.timeoutId) clearTimeout(pending.timeoutId);
+		pending.reject(new Error(reason));
+	}
+	ctx.pendingQuestions.clear();
+
+	const hubClient = ctx.hubClient;
+	ctx.hubClient = null;
+	if (hubClient) {
+		cleanup.push(hubClient.dispose());
+	}
+
+	const sessionManager = ctx.sessionManager;
+	ctx.sessionManager = null;
+	if (sessionManager) {
+		cleanup.push(sessionManager.dispose(reason));
+	}
+
+	const hubServer = ctx.hubServer;
+	ctx.hubServer = null;
+	if (hubServer) {
+		cleanup.push(hubServer.close());
+	}
+
+	const results = await Promise.allSettled(cleanup);
+	const firstFailure = results.find(
+		(result): result is PromiseRejectedResult => result.status === "rejected",
+	);
+	if (firstFailure) {
+		throw firstFailure.reason;
+	}
+}
+
+function serializeQuestionContext(
+	context: AgentToolContext,
+): PendingAskQuestion["item"]["context"] {
+	return {
+		agentId: context.agentId,
+		conversationId: context.conversationId,
+		iteration: context.iteration,
+		...(context.metadata ? { metadata: context.metadata } : {}),
+	};
+}
+
+export function requestSidecarAskQuestion(
+	ctx: SidecarContext,
+	question: string,
+	options: string[],
+	context: AgentToolContext,
+): Promise<string> {
+	const choices = options
+		.map((option) => option.trim())
+		.filter((option) => option.length > 0)
+		.slice(0, 5);
+	if (choices.length === 0) {
+		return Promise.resolve("");
+	}
+
+	return new Promise<string>((resolve, reject) => {
+		const requestId = randomUUID();
+		const timeoutId = setTimeout(() => {
+			ctx.pendingQuestions.delete(requestId);
+			reject(
+				new Error(
+					`Ask question request timed out after ${ASK_QUESTION_TIMEOUT_MS}ms`,
+				),
+			);
+			sendEvent(ctx, "ask_question_cancelled", {
+				requestId,
+				reason: "timeout",
+			});
+		}, ASK_QUESTION_TIMEOUT_MS);
+		const pending: PendingAskQuestion = {
+			item: {
+				requestId,
+				createdAt: new Date().toISOString(),
+				question,
+				options: choices,
+				context: serializeQuestionContext(context),
+			},
+			resolve,
+			reject,
+			timeoutId,
+		};
+		ctx.pendingQuestions.set(requestId, pending);
+		sendEvent(ctx, "ask_question_requested", pending.item);
+	});
+}
+
+export function resolveSidecarAskQuestion(
+	ctx: SidecarContext,
+	requestId: string,
+	answer: string,
+): boolean {
+	const pending = ctx.pendingQuestions.get(requestId);
+	if (!pending) {
+		return false;
+	}
+	ctx.pendingQuestions.delete(requestId);
+	if (pending.timeoutId) clearTimeout(pending.timeoutId);
+	pending.resolve(answer);
+	return true;
+}
+
+export function createSidecarRuntimeCapabilities(
+	ctx: SidecarContext,
+): RuntimeCapabilities {
+	return {
+		toolExecutors: {
+			askQuestion: (question, options, context) =>
+				requestSidecarAskQuestion(ctx, question, options, context),
+		},
+		requestToolApproval: (request) => requestSidecarToolApproval(ctx, request),
+	};
+}
+
+function requestSidecarToolApproval(
+	ctx: SidecarContext,
+	request: ToolApprovalRequest,
+): Promise<ToolApprovalResult> {
+	return new Promise<ToolApprovalResult>((resolve) => {
+		const requestId = randomUUID();
+		const pending: PendingToolApproval = {
+			item: {
+				requestId,
+				sessionId: request.sessionId,
+				createdAt: new Date().toISOString(),
+				toolCallId: request.toolCallId,
+				toolName: request.toolName,
+				input: request.input,
+				iteration: request.iteration,
+				agentId: request.agentId,
+				conversationId: request.conversationId,
+			},
+			resolve,
+		};
+		ctx.pendingApprovals.set(requestId, pending);
+		const sessionApprovals = Array.from(ctx.pendingApprovals.values())
+			.filter((approval) => approval.item.sessionId === request.sessionId)
+			.map((approval) => approval.item);
+		sendEvent(ctx, "tool_approval_state", {
+			sessionId: request.sessionId,
+			items: sessionApprovals,
+		});
+	});
+}
+
+export function handleHubLiveEvent(
+	ctx: SidecarContext,
+	event: {
+		event: string;
+		sessionId?: string;
+		payload?: Record<string, unknown>;
+	},
+): void {
+	const sessionId = typeof event.sessionId === "string" ? event.sessionId : "";
+	if (!sessionId) {
+		return;
+	}
+	const session = ctx.liveSessions.get(sessionId);
+	if (!session?.attachedViaHub) {
+		return;
+	}
+
+	switch (event.event) {
+		case "assistant.delta": {
+			const text =
+				typeof event.payload?.text === "string" ? event.payload.text : "";
+			if (text) {
+				emitChunk(ctx, sessionId, "chat_text", text);
+			}
+			return;
+		}
+		case "reasoning.delta": {
+			const text =
+				typeof event.payload?.text === "string" ? event.payload.text : "";
+			const redacted = event.payload?.redacted === true;
+			if (!text && !redacted) {
+				return;
+			}
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_reasoning",
+				JSON.stringify({ text, redacted }),
+			);
+			return;
+		}
+		case "tool.started": {
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_tool_call_start",
+				JSON.stringify({
+					toolCallId:
+						typeof event.payload?.toolCallId === "string"
+							? event.payload.toolCallId
+							: undefined,
+					toolName:
+						typeof event.payload?.toolName === "string"
+							? event.payload.toolName
+							: "tool",
+					input: event.payload?.input,
+				}),
+			);
+			return;
+		}
+		case "tool.finished": {
+			emitChunk(
+				ctx,
+				sessionId,
+				"chat_tool_call_end",
+				JSON.stringify({
+					toolCallId:
+						typeof event.payload?.toolCallId === "string"
+							? event.payload.toolCallId
+							: undefined,
+					toolName:
+						typeof event.payload?.toolName === "string"
+							? event.payload.toolName
+							: "tool",
+					output: event.payload?.output,
+					error:
+						typeof event.payload?.error === "string"
+							? event.payload.error
+							: undefined,
+				}),
+			);
+			return;
+		}
+		case "run.started":
+		case "session.attached":
+		case "session.updated": {
+			const payloadSession =
+				event.payload?.session &&
+				typeof event.payload.session === "object" &&
+				!Array.isArray(event.payload.session)
+					? (event.payload.session as Record<string, unknown>)
+					: undefined;
+			const status =
+				typeof payloadSession?.status === "string"
+					? payloadSession.status
+					: event.event === "run.started"
+						? "running"
+						: session.status;
+			session.status = status;
+			session.busy = status === "running";
+			sendEvent(ctx, "chat_session_status", { sessionId, status });
+			return;
+		}
+		case "run.completed":
+		case "run.failed":
+		case "run.aborted": {
+			const reason =
+				typeof event.payload?.reason === "string"
+					? event.payload.reason
+					: event.event === "run.aborted"
+						? "aborted"
+						: event.event === "run.failed"
+							? "error"
+							: "completed";
+			session.status = reason;
+			session.busy = false;
+			session.endedAt = nowMs();
+			sendEvent(ctx, "chat_session_ended", { sessionId, reason });
+			return;
+		}
+		default:
+			return;
+	}
+}
+
+export async function initializeSessionManager(
+	ctx: SidecarContext,
+): Promise<void> {
+	setHomeDirIfUnset(homedir());
+	const hubServer = await startHubWebSocketServer({
+		port: 0,
+		owner: resolveHubOwnerContext(
+			`code-sidecar:${process.pid}:${randomUUID()}`,
+		),
+		runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+	});
+	const sessionManager = await ClineCore.create({
+		backendMode: "hub",
+		capabilities: createSidecarRuntimeCapabilities(ctx),
+		hub: {
+			endpoint: hubServer.url,
+			authToken: hubServer.authToken,
+			workspaceRoot: ctx.workspaceRoot,
+			cwd: ctx.workspaceRoot,
+			clientType: "code-sidecar",
+			displayName: "Code App sidecar",
+		},
+	});
+
+	// Subscribe to all session events and relay them to WS clients
+	const unsubscribe = sessionManager.subscribe((event: CoreSessionEvent) => {
+		handleCoreSessionEvent(ctx, event);
+	});
+
+	const runtimeAddress = sessionManager.runtimeAddress?.trim();
+	let hubClient: NodeHubClient | null = null;
+	if (runtimeAddress) {
+		hubClient = new NodeHubClient({
+			url: runtimeAddress,
+			authToken: hubServer.authToken,
+			clientType: "code-sidecar-approvals",
+			displayName: "Code App approvals",
+			workspaceRoot: ctx.workspaceRoot,
+			cwd: ctx.workspaceRoot,
+		});
+		await hubClient.connect();
+		hubClient.subscribe((event) => {
+			handleHubLiveEvent(ctx, event);
+		});
+	}
+
+	ctx.sessionManager = sessionManager;
+	ctx.hubClient = hubClient;
+	ctx.hubServer = hubServer;
+	ctx.unsubscribeSessionEvents = unsubscribe;
+}
diff --git a/apps/examples/desktop-app/sidecar/index.ts b/apps/examples/desktop-app/sidecar/index.ts
new file mode 100644
index 0000000..9e2daaa
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/index.ts
@@ -0,0 +1,79 @@
+import {
+	createSidecarContext,
+	disposeSidecarContext,
+	initializeSessionManager,
+} from "./context";
+import { resolveWorkspaceRoot } from "./paths";
+import { startServer } from "./server";
+import { BunRuntime, SIDECAR_MODE, SIDECAR_PORT } from "./types";
+
+const SHUTDOWN_TIMEOUT_MS = 5_000;
+
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
+	let timeout: ReturnType<typeof setTimeout> | undefined;
+	return Promise.race([
+		promise,
+		new Promise<T>((_, reject) => {
+			timeout = setTimeout(
+				() => reject(new Error(`shutdown timed out after ${timeoutMs}ms`)),
+				timeoutMs,
+			);
+		}),
+	]).finally(() => {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	});
+}
+
+async function main() {
+	if (!BunRuntime) {
+		throw new Error("sidecar must be run with Bun");
+	}
+
+	const workspaceRoot = resolveWorkspaceRoot(process.cwd());
+	const ctx = createSidecarContext(workspaceRoot);
+
+	await initializeSessionManager(ctx);
+
+	let shuttingDown = false;
+	const shutdown = async (reason = "code_sidecar_shutdown"): Promise<void> => {
+		if (shuttingDown) {
+			return;
+		}
+		shuttingDown = true;
+		await withTimeout(disposeSidecarContext(ctx, reason), SHUTDOWN_TIMEOUT_MS);
+	};
+
+	const shutdownAndExit = (signal: string): void => {
+		void shutdown(`code_sidecar_${signal.toLowerCase()}`).finally(() => {
+			process.exit(signal === "SIGINT" ? 130 : 143);
+		});
+	};
+
+	process.once("SIGINT", () => shutdownAndExit("SIGINT"));
+	process.once("SIGTERM", () => shutdownAndExit("SIGTERM"));
+	process.once("beforeExit", () => {
+		void shutdown("code_sidecar_before_exit");
+	});
+
+	const { port } = startServer(ctx, SIDECAR_PORT, shutdown);
+
+	const endpoint = `http://127.0.0.1:${port}`;
+	const wsEndpoint = `ws://127.0.0.1:${port}/transport`;
+	process.stdout.write(
+		`${JSON.stringify({
+			type: "ready",
+			endpoint,
+			wsEndpoint,
+			pid: process.pid,
+			mode: SIDECAR_MODE,
+		})}\n`,
+	);
+}
+
+main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`${message}\n`);
+	process.exit(1);
+});
diff --git a/apps/examples/desktop-app/sidecar/marketplace.ts b/apps/examples/desktop-app/sidecar/marketplace.ts
new file mode 100644
index 0000000..1f74074
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/marketplace.ts
@@ -0,0 +1,998 @@
+import { type SpawnOptions, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+	existsSync,
+	mkdirSync,
+	rmSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { homedir as osHomedir, platform } from "node:os";
+import {
+	basename,
+	dirname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+} from "node:path";
+import {
+	type MarketplaceActionResult,
+	type MarketplaceEntryInput,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	uninstallMarketplaceEntry as uninstallCoreMarketplaceEntry,
+	uninstallPlugin as uninstallLocalPlugin,
+} from "@cline/core";
+import { resolveClineDir } from "@cline/shared/storage";
+import { deleteMcpServer, readMcpServersResponse } from "./mcp";
+import type { JsonRecord } from "./types";
+
+type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
+type LocalPrimitiveType = MarketplacePrimitiveType | "workflow";
+
+type MarketplaceEnvVar = {
+	name: string;
+	required?: boolean;
+	description?: string;
+	url?: string;
+};
+
+type MarketplaceInstallInput = {
+	id: string;
+	type: MarketplacePrimitiveType;
+	name?: string;
+	install: {
+		args?: string[];
+		env?: MarketplaceEnvVar[];
+		command?: string;
+		notes?: string;
+	};
+};
+
+type MarketplaceInstallResult = {
+	id: string;
+	type: LocalPrimitiveType;
+	status: "installed" | "uninstalled";
+	message: string;
+	details?: JsonRecord;
+	output?: string;
+};
+
+type MarketplaceInstallStatusResult = {
+	installedKeys: string[];
+};
+
+type SpawnResult = {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+};
+
+type SpawnCommand = (
+	command: string,
+	args: string[],
+	options?: SpawnOptions,
+) => Promise<SpawnResult>;
+type CatalogFetch = (
+	input: string | URL | Request,
+	init?: RequestInit,
+) => Promise<Response>;
+type CatalogLoader = () => Promise<unknown>;
+
+const MAX_OUTPUT_CHARS = 12_000;
+const INSTALL_COMMAND_TIMEOUT_MS = 120_000;
+const OFFICIAL_PLUGINS_REPO = "https://github.com/cline/plugins.git";
+const MARKETPLACE_CATALOG_URL =
+	process.env.CLINE_MARKETPLACE_CATALOG_URL?.trim() ||
+	"https://cline.github.io/marketplace/catalog.json";
+const SECRET_PATTERN =
+	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i;
+const SECRET_KEY_VALUE_PATTERN =
+	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi;
+const SECRET_BEARER_VALUE_PATTERN =
+	/((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi;
+const SECRET_AUTHORIZATION_VALUE_PATTERN =
+	/((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi;
+
+export async function fetchMarketplaceCatalog(
+	fetchImpl: CatalogFetch = fetch,
+): Promise<unknown> {
+	const response = await fetchImpl(MARKETPLACE_CATALOG_URL, {
+		headers: { Accept: "application/json" },
+	});
+	if (!response.ok) {
+		throw new Error(
+			`Failed to fetch marketplace catalog: ${response.status} ${response.statusText}`.trim(),
+		);
+	}
+	return response.json();
+}
+
+function isPrimitiveType(value: unknown): value is MarketplacePrimitiveType {
+	return value === "mcp" || value === "skill" || value === "plugin";
+}
+
+function toStringArray(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+function readInstallInput(
+	args?: Record<string, unknown>,
+): MarketplaceInstallInput {
+	const entry = readInstallRecord(args);
+	const install =
+		entry.install && typeof entry.install === "object"
+			? (entry.install as Record<string, unknown>)
+			: {};
+	const installArgs = toStringArray(install.args);
+	if (installArgs.length === 0) {
+		throw new Error("marketplace install args are required");
+	}
+	const env = Array.isArray(install.env)
+		? install.env
+				.map((item): MarketplaceEnvVar | null => {
+					if (!item || typeof item !== "object") return null;
+					const candidate = item as Record<string, unknown>;
+					if (typeof candidate.name !== "string") return null;
+					const parsed: MarketplaceEnvVar = {
+						name: candidate.name,
+					};
+					if (typeof candidate.required === "boolean") {
+						parsed.required = candidate.required;
+					}
+					if (typeof candidate.description === "string") {
+						parsed.description = candidate.description;
+					}
+					if (typeof candidate.url === "string") {
+						parsed.url = candidate.url;
+					}
+					return parsed;
+				})
+				.filter((item): item is MarketplaceEnvVar => item !== null)
+		: undefined;
+	return {
+		id: entry.id.trim(),
+		type: entry.type,
+		name: typeof entry.name === "string" ? entry.name : undefined,
+		install: {
+			args: installArgs,
+			command:
+				typeof install.command === "string" ? install.command : undefined,
+			env,
+			notes: typeof install.notes === "string" ? install.notes : undefined,
+		},
+	};
+}
+
+function readInstallRecord(
+	args?: Record<string, unknown>,
+): Record<string, unknown> & { id: string; type: MarketplacePrimitiveType } {
+	const entry =
+		args?.entry && typeof args.entry === "object"
+			? (args.entry as Record<string, unknown>)
+			: (args ?? {});
+	if (typeof entry.id !== "string" || entry.id.trim().length === 0) {
+		throw new Error("marketplace entry id is required");
+	}
+	if (!isPrimitiveType(entry.type)) {
+		throw new Error("marketplace entry type must be mcp, skill, or plugin");
+	}
+	return entry as Record<string, unknown> & {
+		id: string;
+		type: MarketplacePrimitiveType;
+	};
+}
+
+function readInstallRequest(args?: Record<string, unknown>) {
+	const entry = readInstallRecord(args);
+	return {
+		id: entry.id.trim(),
+		type: entry.type,
+	};
+}
+
+function readLocalUninstallInput(args?: Record<string, unknown>): {
+	id: string;
+	type: LocalPrimitiveType;
+	name?: string;
+	path?: string;
+} {
+	const type = typeof args?.type === "string" ? args.type.trim() : "";
+	if (
+		type !== "mcp" &&
+		type !== "skill" &&
+		type !== "workflow" &&
+		type !== "plugin"
+	) {
+		throw new Error(
+			"local uninstall type must be mcp, skill, workflow, or plugin",
+		);
+	}
+	const id =
+		typeof args?.id === "string" && args.id.trim().length > 0
+			? args.id.trim()
+			: typeof args?.name === "string" && args.name.trim().length > 0
+				? args.name.trim()
+				: typeof args?.path === "string" && args.path.trim().length > 0
+					? args.path.trim()
+					: "";
+	if (!id) {
+		throw new Error("local uninstall id, name, or path is required");
+	}
+	return {
+		id,
+		type,
+		name: typeof args?.name === "string" ? args.name.trim() : undefined,
+		path: typeof args?.path === "string" ? args.path.trim() : undefined,
+	};
+}
+
+function readInstallInputList(
+	args?: Record<string, unknown>,
+): MarketplaceInstallInput[] {
+	const rawEntries = Array.isArray(args?.entries) ? args.entries : [];
+	return rawEntries
+		.map((entry) => {
+			try {
+				return readInstallInput({ entry });
+			} catch {
+				return null;
+			}
+		})
+		.filter((entry): entry is MarketplaceInstallInput => entry !== null);
+}
+
+function readCatalogEntries(catalog: unknown): MarketplaceInstallInput[] {
+	const catalogEntries =
+		catalog && typeof catalog === "object"
+			? (catalog as Record<string, unknown>).entries
+			: undefined;
+	if (!Array.isArray(catalogEntries)) {
+		throw new Error("marketplace catalog entries are required");
+	}
+	return catalogEntries
+		.map((entry) => {
+			try {
+				return readInstallInput({ entry });
+			} catch {
+				return null;
+			}
+		})
+		.filter((entry): entry is MarketplaceInstallInput => entry !== null);
+}
+
+function marketplaceEntryKey(
+	entry: Pick<MarketplaceInstallInput, "id" | "type">,
+) {
+	return `${entry.type}:${entry.id}`;
+}
+
+function redactOutput(value: string): string {
+	const lines = value.split(/\r?\n/).map((line) => {
+		if (!SECRET_PATTERN.test(line)) return line;
+		return line
+			.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
+			.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
+			.replace(/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi, "$1 [redacted]")
+			.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
+			.replace(
+				/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
+				"$1[redacted]",
+			);
+	});
+	return lines.join("\n").slice(-MAX_OUTPUT_CHARS);
+}
+
+const defaultSpawnCommand: SpawnCommand = async (command, args, options = {}) =>
+	new Promise<SpawnResult>((resolve, reject) => {
+		let settled = false;
+		let timedOut = false;
+		const child = spawn(command, args, {
+			...options,
+			env: options.env ?? process.env,
+			shell: options.shell ?? platform() === "win32",
+			stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
+			windowsHide: true,
+		});
+		let stdout = "";
+		let stderr = "";
+		const forceKillTimeout = setTimeout(() => {
+			if (!settled) {
+				child.kill("SIGKILL");
+			}
+		}, INSTALL_COMMAND_TIMEOUT_MS + 5_000);
+		const timeout = setTimeout(() => {
+			timedOut = true;
+			stderr += `\nTimed out after ${INSTALL_COMMAND_TIMEOUT_MS / 1000}s.`;
+			child.kill("SIGTERM");
+		}, INSTALL_COMMAND_TIMEOUT_MS);
+		forceKillTimeout.unref?.();
+		timeout.unref?.();
+		child.stdout?.on("data", (chunk) => {
+			stdout += String(chunk);
+			if (stdout.length > MAX_OUTPUT_CHARS * 2) {
+				stdout = stdout.slice(-MAX_OUTPUT_CHARS);
+			}
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += String(chunk);
+			if (stderr.length > MAX_OUTPUT_CHARS * 2) {
+				stderr = stderr.slice(-MAX_OUTPUT_CHARS);
+			}
+		});
+		child.once("error", (error) => {
+			clearTimeout(timeout);
+			clearTimeout(forceKillTimeout);
+			reject(error);
+		});
+		child.once("close", (code, signal) => {
+			settled = true;
+			clearTimeout(timeout);
+			clearTimeout(forceKillTimeout);
+			const result = {
+				exitCode: timedOut ? 124 : (code ?? (signal === "SIGINT" ? 130 : 1)),
+				stdout,
+				stderr,
+			};
+			resolve(result);
+		});
+	});
+
+function normalizeTransport(value: string | undefined): string {
+	const normalized = (value ?? "stdio").trim();
+	if (normalized === "http" || normalized === "streamable-http") {
+		return "streamableHttp";
+	}
+	if (
+		normalized === "stdio" ||
+		normalized === "sse" ||
+		normalized === "streamableHttp"
+	) {
+		return normalized;
+	}
+	throw new Error(
+		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
+	);
+}
+
+function assertUrl(value: string): void {
+	let parsed: URL;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new Error(`Invalid MCP server URL: ${value}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error(`Invalid MCP server URL: ${value}`);
+	}
+}
+
+export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
+	const [rawName, ...rest] = args;
+	const name = rawName?.trim();
+	if (!name) {
+		throw new Error("MCP marketplace install requires a server name");
+	}
+	let transportType = "stdio";
+	const headers: Record<string, string> = {};
+	const targetArgs: string[] = [];
+	let parsingMarketplaceOptions = true;
+	for (let index = 0; index < rest.length; index++) {
+		const arg = rest[index];
+		if (parsingMarketplaceOptions && arg === "--") {
+			targetArgs.push(...rest.slice(index + 1));
+			break;
+		}
+		if (parsingMarketplaceOptions && (arg === "--transport" || arg === "-t")) {
+			const next = rest[index + 1]?.trim();
+			if (!next) throw new Error("--transport requires a value");
+			transportType = normalizeTransport(next);
+			index++;
+			continue;
+		}
+		const shouldParseHeader =
+			parsingMarketplaceOptions ||
+			normalizeTransport(transportType) !== "stdio";
+		if (
+			shouldParseHeader &&
+			(arg === "--header" || arg?.startsWith("--header="))
+		) {
+			const rawHeader =
+				arg === "--header" ? rest[++index] : arg.slice("--header=".length);
+			if (!rawHeader) throw new Error("--header requires a value");
+			const separatorIndex = rawHeader.indexOf(":");
+			if (separatorIndex <= 0) {
+				throw new Error(
+					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
+				);
+			}
+			const headerName = rawHeader.slice(0, separatorIndex).trim();
+			const headerValue = rawHeader.slice(separatorIndex + 1).trim();
+			if (!headerName || !headerValue) {
+				throw new Error(
+					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
+				);
+			}
+			headers[headerName] = headerValue;
+			continue;
+		}
+		parsingMarketplaceOptions = false;
+		targetArgs.push(arg);
+	}
+	transportType = normalizeTransport(transportType);
+	if (transportType === "stdio") {
+		if (Object.keys(headers).length > 0) {
+			throw new Error("Stdio MCP installs do not support request headers.");
+		}
+		const [command, ...commandArgs] = targetArgs;
+		if (!command?.trim()) {
+			throw new Error("Stdio MCP install requires a command");
+		}
+		return {
+			name,
+			transportType,
+			command,
+			args: commandArgs.length > 0 ? commandArgs : undefined,
+			disabled: false,
+		};
+	}
+	if (targetArgs.length !== 1) {
+		throw new Error("Remote MCP install requires exactly one URL");
+	}
+	const url = targetArgs[0]?.trim() ?? "";
+	assertUrl(url);
+	return {
+		name,
+		transportType,
+		url,
+		headers: Object.keys(headers).length > 0 ? headers : undefined,
+		disabled: false,
+	};
+}
+
+function resolveClineInvocation(): { command: string; argsPrefix: string[] } {
+	const wrapperPath = process.env.CLINE_WRAPPER_PATH?.trim();
+	if (wrapperPath) {
+		return { command: wrapperPath, argsPrefix: [] };
+	}
+	const entry = process.argv[1]?.trim();
+	if (entry && /(?:^|[/\\])apps[/\\]cli[/\\]src[/\\]index\.ts$/.test(entry)) {
+		return { command: process.execPath, argsPrefix: [entry] };
+	}
+	return { command: "cline", argsPrefix: [] };
+}
+
+function isInsidePath(childPath: string, parentPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+function resolveUserInstructionRemovalTarget(input: {
+	type: "skill" | "workflow";
+	path: string;
+	workspaceRoot?: string;
+}): string {
+	const filePath = resolve(input.path);
+	const searchPaths =
+		input.type === "skill"
+			? resolveSkillsConfigSearchPaths(input.workspaceRoot)
+			: resolveWorkflowsConfigSearchPaths(input.workspaceRoot);
+	const containingRoot = searchPaths.find((root) =>
+		isInsidePath(filePath, root),
+	);
+	if (!containingRoot) {
+		throw new Error(
+			`${input.type} uninstall requires a file inside a configured ${input.type} directory.`,
+		);
+	}
+	const stats = statSync(filePath, { throwIfNoEntry: false });
+	if (!stats?.isFile()) {
+		throw new Error(`${input.type} file does not exist: ${filePath}`);
+	}
+	if (input.type === "workflow") {
+		return filePath;
+	}
+	const skillDir = dirname(filePath);
+	return resolve(skillDir) === resolve(containingRoot) ? filePath : skillDir;
+}
+
+export async function uninstallLocalPrimitive(
+	args?: Record<string, unknown>,
+	options: { workspaceRoot?: string } = {},
+): Promise<MarketplaceInstallResult> {
+	const input = readLocalUninstallInput(args);
+	if (input.type === "mcp") {
+		const name = input.name ?? input.id;
+		const response = deleteMcpServer(name);
+		return {
+			id: input.id,
+			type: input.type,
+			status: "uninstalled",
+			message: `Uninstalled ${name}.`,
+			details: { mcp: response },
+		};
+	}
+	if (input.type === "plugin") {
+		const result = await uninstallLocalPlugin({
+			name: input.path ? undefined : (input.name ?? input.id),
+			path: input.path,
+			workspaceRoot: options.workspaceRoot,
+		});
+		return {
+			id: input.id,
+			type: input.type,
+			status: "uninstalled",
+			message: `Uninstalled ${result.name}.`,
+			details: result as unknown as JsonRecord,
+		};
+	}
+	if (input.type === "skill" || input.type === "workflow") {
+		if (!input.path) {
+			throw new Error(`${input.type} uninstall requires a path.`);
+		}
+		const target = resolveUserInstructionRemovalTarget({
+			type: input.type,
+			path: input.path,
+			workspaceRoot: options.workspaceRoot,
+		});
+		const stats = statSync(target, { throwIfNoEntry: false });
+		if (!stats) {
+			throw new Error(`${input.type} target does not exist: ${target}`);
+		}
+		rmSync(target, { recursive: stats.isDirectory(), force: true });
+		return {
+			id: input.id,
+			type: input.type,
+			status: "uninstalled",
+			message: `Uninstalled ${input.name ?? basename(target)}.`,
+			details: { path: target },
+		};
+	}
+	throw new Error(`Unsupported local uninstall type: ${input.type}`);
+}
+
+function hashSource(source: string): string {
+	return createHash("sha256").update(source).digest("hex").slice(0, 12);
+}
+
+function sanitizeSegment(value: string): string {
+	const sanitized = value
+		.replace(/^@/, "")
+		.replace(/[^a-zA-Z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, 80);
+	return sanitized || "plugin";
+}
+
+function sanitizeSkillSegment(value: string): string {
+	const sanitized = value
+		.toLowerCase()
+		.replace(/[^a-z0-9._]+/g, "-")
+		.replace(/^[.-]+|[.-]+$/g, "")
+		.slice(0, 255);
+	return sanitized || "skill";
+}
+
+function isOfficialPluginSlug(source: string): boolean {
+	return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(source.trim());
+}
+
+function getOfficialPluginInstallPath(source: string): string | undefined {
+	const slug = source.trim();
+	if (!isOfficialPluginSlug(slug)) return undefined;
+	const sourceKey = `official:${OFFICIAL_PLUGINS_REPO}#plugins/${slug}`;
+	return join(
+		resolveClineDir(),
+		"plugins",
+		"_installed",
+		"official",
+		`${sanitizeSegment(slug)}-${hashSource(sourceKey)}`,
+	);
+}
+
+function isOfficialPluginInstalled(entry: MarketplaceInstallInput): boolean {
+	if (entry.type !== "plugin") return false;
+	const [source] = entry.install.args ?? [];
+	if (!source) return false;
+	const installPath = getOfficialPluginInstallPath(source);
+	return Boolean(installPath && existsSync(installPath));
+}
+
+function resolveHomeDir(): string {
+	return (
+		process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || osHomedir()
+	);
+}
+
+function normalizeMatchValue(value: string | undefined): string {
+	return (value ?? "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+function getSkillInstallCandidates(entry: MarketplaceInstallInput): string[] {
+	const candidates = new Set<string>();
+	const addCandidate = (value: string | undefined) => {
+		const normalized = sanitizeSkillSegment(value ?? "");
+		if (normalized && normalized !== "skill") {
+			candidates.add(normalized);
+		}
+	};
+	addCandidate(entry.id);
+	addCandidate(entry.name);
+	const installArgs = entry.install.args ?? [];
+	for (let index = 0; index < installArgs.length; index++) {
+		const arg = installArgs[index];
+		if ((arg === "--skill" || arg === "-s") && installArgs[index + 1]) {
+			addCandidate(installArgs[index + 1]);
+			index++;
+			continue;
+		}
+		const skillFilter = arg.split("@").at(1);
+		if (skillFilter) {
+			addCandidate(skillFilter);
+		}
+	}
+	return [...candidates];
+}
+
+function getGlobalSkillPaths(skillName: string): string[] {
+	return [
+		join(resolveClineDir(), "skills", skillName, "SKILL.md"),
+		join(resolveHomeDir(), ".agents", "skills", skillName, "SKILL.md"),
+	].filter((path, index, paths) => paths.indexOf(path) === index);
+}
+
+function ensureGlobalSkillsDirWritable(): void {
+	const skillsDir = join(resolveHomeDir(), ".agents", "skills");
+	try {
+		mkdirSync(skillsDir, { recursive: true });
+		const probePath = join(
+			skillsDir,
+			`.cline-marketplace-write-test-${process.pid}-${Date.now()}`,
+		);
+		writeFileSync(probePath, "", { flag: "wx" });
+		unlinkSync(probePath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(
+			`Cannot install skill globally because ~/.agents/skills is not writable: ${message}`,
+		);
+	}
+}
+
+function isGlobalSkillInstalled(entry: MarketplaceInstallInput): boolean {
+	return findInstalledGlobalSkillName(entry) !== undefined;
+}
+
+function findInstalledGlobalSkillName(
+	entry: MarketplaceInstallInput,
+): string | undefined {
+	if (entry.type !== "skill") return undefined;
+	const candidates = getSkillInstallCandidates(entry);
+	return candidates.find((candidate) =>
+		getGlobalSkillPaths(candidate).some((path) => existsSync(path)),
+	);
+}
+
+function hasMatchingInventoryItem(
+	items: unknown,
+	entry: MarketplaceInstallInput,
+): boolean {
+	if (!Array.isArray(items)) return false;
+	const candidates = new Set([
+		normalizeMatchValue(entry.id),
+		normalizeMatchValue(entry.name),
+		...(entry.install.args ?? []).map(normalizeMatchValue),
+	]);
+	candidates.delete("");
+	return items.some((item) => {
+		if (!item || typeof item !== "object") return false;
+		const record = item as JsonRecord;
+		const values = [
+			typeof record.name === "string" ? record.name : undefined,
+			typeof record.id === "string" ? record.id : undefined,
+			typeof record.path === "string" ? record.path : undefined,
+		]
+			.map(normalizeMatchValue)
+			.filter(Boolean);
+		return values.some((value) => candidates.has(value));
+	});
+}
+
+function isMcpEntryInstalled(entry: MarketplaceInstallInput): boolean {
+	if (entry.type !== "mcp") return false;
+	const input = buildMarketplaceMcpInput(entry.install.args ?? []);
+	const response = readMcpServersResponse();
+	const servers = Array.isArray(response.servers) ? response.servers : [];
+	return servers.some((server) => {
+		if (!server || typeof server !== "object") return false;
+		const record = server as JsonRecord;
+		return record.name === input.name;
+	});
+}
+
+function isMarketplaceEntryInstalled(
+	entry: MarketplaceInstallInput,
+	inventory?: JsonRecord,
+): boolean {
+	try {
+		if (entry.type === "mcp") return isMcpEntryInstalled(entry);
+		if (entry.type === "plugin") {
+			return (
+				isOfficialPluginInstalled(entry) ||
+				hasMatchingInventoryItem(inventory?.plugins, entry)
+			);
+		}
+		if (entry.type === "skill") {
+			return isGlobalSkillInstalled(entry);
+		}
+		return false;
+	} catch {
+		return false;
+	}
+}
+
+function commandOutput(result: SpawnResult): string | undefined {
+	const output = redactOutput(
+		[result.stdout, result.stderr].filter(Boolean).join("\n"),
+	);
+	return output.trim().length > 0 ? output.trim() : undefined;
+}
+
+async function installSkill(
+	entry: MarketplaceInstallInput,
+	spawnCommand: SpawnCommand,
+): Promise<MarketplaceInstallResult> {
+	if (isGlobalSkillInstalled(entry)) {
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "installed",
+			message: `${entry.name ?? entry.id} is already installed.`,
+		};
+	}
+	ensureGlobalSkillsDirWritable();
+	const result = await spawnCommand("npx", [
+		"-y",
+		"skills@latest",
+		"add",
+		...(entry.install.args ?? []),
+		"-g",
+		"-a",
+		"cline",
+		"-y",
+	]);
+	if (result.exitCode !== 0) {
+		const output = commandOutput(result);
+		throw new Error(
+			`Skill install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+		);
+	}
+	const output = commandOutput(result);
+	if (/\bFailed to install\b/i.test(output ?? "")) {
+		throw new Error(`Skill install failed${output ? `:\n${output}` : ""}`);
+	}
+	if (!isGlobalSkillInstalled(entry)) {
+		throw new Error(
+			`Skill install completed, but ${entry.name ?? entry.id} was not found in Cline's global skills directories.`,
+		);
+	}
+	return {
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name ?? entry.id} globally for Cline.`,
+		output,
+	};
+}
+
+async function installPlugin(
+	entry: MarketplaceInstallInput,
+	spawnCommand: SpawnCommand,
+): Promise<MarketplaceInstallResult> {
+	const installArgs = entry.install.args ?? [];
+	if (installArgs.length !== 1) {
+		throw new Error(
+			"Plugin marketplace installs currently support exactly one source argument.",
+		);
+	}
+	if (isOfficialPluginInstalled(entry)) {
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "installed",
+			message: `${entry.name ?? entry.id} is already installed.`,
+		};
+	}
+	const { command, argsPrefix } = resolveClineInvocation();
+	const result = await spawnCommand(command, [
+		...argsPrefix,
+		"plugin",
+		"install",
+		installArgs[0] ?? "",
+		"--json",
+	]);
+	if (result.exitCode !== 0) {
+		const output = commandOutput(result);
+		throw new Error(
+			`Plugin install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+		);
+	}
+	let details: JsonRecord | undefined;
+	try {
+		details = result.stdout.trim()
+			? (JSON.parse(result.stdout.trim()) as JsonRecord)
+			: undefined;
+	} catch {
+		details = undefined;
+	}
+	return {
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name ?? entry.id}.`,
+		details,
+		output: commandOutput(result),
+	};
+}
+
+export async function installMarketplaceEntry(
+	args?: Record<string, unknown>,
+	options: { spawnCommand?: SpawnCommand } = {},
+): Promise<MarketplaceInstallResult> {
+	const entry = readInstallInput(args);
+	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
+	if (entry.type === "mcp") {
+		// Validate marketplace args before handing them to the CLI-backed installer.
+		buildMarketplaceMcpInput(entry.install.args ?? []);
+		const { command, argsPrefix } = resolveClineInvocation();
+		const result = await spawnCommand(command, [
+			...argsPrefix,
+			"mcp",
+			"install",
+			"--yes",
+			"--json",
+			...(entry.install.args ?? []),
+		]);
+		if (result.exitCode !== 0) {
+			const output = commandOutput(result);
+			throw new Error(
+				`MCP install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+			);
+		}
+		let details: JsonRecord | undefined;
+		try {
+			details = result.stdout.trim()
+				? (JSON.parse(result.stdout.trim()) as JsonRecord)
+				: undefined;
+		} catch {
+			details = undefined;
+		}
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "installed",
+			message: `Installed ${entry.name ?? entry.id}.`,
+			details,
+			output: commandOutput(result),
+		};
+	}
+	if (entry.type === "skill") {
+		return installSkill(entry, spawnCommand);
+	}
+	if (entry.type === "plugin") {
+		return installPlugin(entry, spawnCommand);
+	}
+	throw new Error(`Unsupported marketplace entry type: ${entry.type}`);
+}
+
+export async function uninstallMarketplaceEntry(
+	args?: Record<string, unknown>,
+	options: { spawnCommand?: SpawnCommand } = {},
+): Promise<MarketplaceInstallResult> {
+	const entry = readInstallInput(args);
+	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
+	let mcpDetails: JsonRecord | undefined;
+	const result = await uninstallCoreMarketplaceEntry(
+		entry satisfies MarketplaceEntryInput,
+		{
+			deleteMcpServer: (name) => {
+				mcpDetails = deleteMcpServer(name);
+			},
+			spawnCommand: (command, commandArgs) =>
+				spawnCommand(command, commandArgs),
+		},
+	);
+	return {
+		...(result satisfies MarketplaceActionResult),
+		details: mcpDetails ? { mcp: mcpDetails } : undefined,
+	};
+}
+
+export async function installMarketplaceEntryFromCatalog(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	const requested = readInstallRequest(args);
+	const catalog = await (options.loadCatalog ?? fetchMarketplaceCatalog)();
+	const entry = readCatalogEntries(catalog).find(
+		(candidate) =>
+			candidate.id === requested.id && candidate.type === requested.type,
+	);
+	if (!entry) {
+		throw new Error(
+			`Marketplace entry ${requested.type}:${requested.id} was not found in the catalog.`,
+		);
+	}
+	return installMarketplaceEntry(
+		{ entry },
+		{ spawnCommand: options.spawnCommand },
+	);
+}
+
+export async function uninstallMarketplaceEntryFromCatalog(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	const requested = readInstallRequest(args);
+	const catalog = await (options.loadCatalog ?? fetchMarketplaceCatalog)();
+	const entry = readCatalogEntries(catalog).find(
+		(candidate) =>
+			candidate.id === requested.id && candidate.type === requested.type,
+	);
+	if (!entry) {
+		throw new Error(
+			`Marketplace entry ${requested.type}:${requested.id} was not found in the catalog.`,
+		);
+	}
+	return uninstallMarketplaceEntry(
+		{ entry },
+		{ spawnCommand: options.spawnCommand },
+	);
+}
+
+export function listMarketplaceInstalledEntries(
+	args?: Record<string, unknown>,
+	inventory?: JsonRecord,
+): MarketplaceInstallStatusResult {
+	const entries = readInstallInputList(args);
+	const installedKeys = entries
+		.filter((entry) => isMarketplaceEntryInstalled(entry, inventory))
+		.map(marketplaceEntryKey);
+	return { installedKeys };
+}
+
+export async function installMarketplaceEntryForDesktopCommand(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	return installMarketplaceEntryFromCatalog(args, options);
+}
+
+export async function uninstallMarketplaceEntryForDesktopCommand(
+	args?: Record<string, unknown>,
+	options: {
+		spawnCommand?: SpawnCommand;
+		loadCatalog?: CatalogLoader;
+	} = {},
+): Promise<MarketplaceInstallResult> {
+	return uninstallMarketplaceEntryFromCatalog(args, options);
+}
diff --git a/apps/examples/desktop-app/sidecar/mcp.ts b/apps/examples/desktop-app/sidecar/mcp.ts
new file mode 100644
index 0000000..a2b84f5
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/mcp.ts
@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from "node:fs";
+import { updateMcpSettingsFileSync } from "@cline/core";
+import { resolveMcpSettingsPath } from "@cline/shared/storage";
+import type { JsonRecord } from "./types";
+
+export function readMcpServersResponse(): JsonRecord {
+	const settingsPath = resolveMcpSettingsPath();
+	if (!existsSync(settingsPath)) {
+		return { settingsPath, hasSettingsFile: false, servers: [] };
+	}
+	const parsed = JSON.parse(readFileSync(settingsPath, "utf8")) as JsonRecord;
+	const servers = parsed.mcpServers as JsonRecord | undefined;
+	const entries = Object.entries(servers ?? {}).map(([name, body]) => {
+		const record = body as JsonRecord;
+		const transport =
+			record.transport && typeof record.transport === "object"
+				? (record.transport as JsonRecord)
+				: undefined;
+		const transportType = String(
+			transport?.type ?? record.transportType ?? record.type ?? "stdio",
+		).trim();
+		return {
+			name,
+			transportType,
+			disabled: record.disabled === true,
+			command:
+				typeof transport?.command === "string"
+					? transport.command
+					: typeof record.command === "string"
+						? record.command
+						: undefined,
+			args: Array.isArray(transport?.args)
+				? transport.args
+				: Array.isArray(record.args)
+					? record.args
+					: undefined,
+			cwd:
+				typeof transport?.cwd === "string"
+					? transport.cwd
+					: typeof record.cwd === "string"
+						? record.cwd
+						: undefined,
+			env:
+				transport?.env && typeof transport.env === "object"
+					? transport.env
+					: record.env && typeof record.env === "object"
+						? record.env
+						: undefined,
+			url:
+				typeof transport?.url === "string"
+					? transport.url
+					: typeof record.url === "string"
+						? record.url
+						: undefined,
+			headers:
+				transport?.headers && typeof transport.headers === "object"
+					? transport.headers
+					: record.headers && typeof record.headers === "object"
+						? record.headers
+						: undefined,
+			metadata: record.metadata,
+		};
+	});
+	return { settingsPath, hasSettingsFile: true, servers: entries };
+}
+
+export function writeMcpServersMap(servers: JsonRecord): void {
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		settings.mcpServers = servers;
+	});
+}
+
+export function ensureMcpSettingsFile(): string {
+	const path = resolveMcpSettingsPath();
+	if (!existsSync(path)) {
+		writeMcpServersMap({});
+	}
+	return path;
+}
+
+export function setMcpServerDisabled(
+	name: string,
+	disabled: boolean,
+): JsonRecord {
+	// Hold the cross-process lock across read-modify-write so a concurrent writer
+	// (the extension, the CLI) cannot clobber this change.
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+			{}) as JsonRecord;
+		const current = servers[name];
+		if (!current || typeof current !== "object") {
+			throw new Error(`unknown MCP server: ${name}`);
+		}
+		servers[name] = { ...(current as JsonRecord), disabled };
+		settings.mcpServers = servers;
+	});
+	return readMcpServersResponse();
+}
+
+export function upsertMcpServer(input: JsonRecord): JsonRecord {
+	const name = String(input.name ?? "").trim();
+	if (!name) throw new Error("server name is required");
+	const previousName = String(
+		input.previousName ?? input.previous_name ?? "",
+	).trim();
+	const transportType = String(
+		input.transportType ?? input.transport_type ?? "",
+	).trim();
+	const next: JsonRecord =
+		transportType === "stdio"
+			? {
+					transport: {
+						type: "stdio",
+						command: input.command,
+						args: input.args,
+						cwd: input.cwd,
+						env: input.env,
+					},
+					disabled: input.disabled === true,
+				}
+			: {
+					transport: {
+						type: transportType === "sse" ? "sse" : "streamableHttp",
+						url: input.url,
+						headers: input.headers,
+					},
+					disabled: input.disabled === true,
+				};
+	// Hold the cross-process lock across read-modify-write so a concurrent writer
+	// cannot clobber this upsert.
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+			{}) as JsonRecord;
+		if (previousName && previousName !== name) {
+			delete servers[previousName];
+		}
+		servers[name] = next;
+		settings.mcpServers = servers;
+	});
+	return readMcpServersResponse();
+}
+
+export function deleteMcpServer(name: string): JsonRecord {
+	if (!name) throw new Error("server name is required");
+	// Hold the cross-process lock across read-modify-write so a concurrent writer
+	// cannot resurrect the deleted server from a stale snapshot.
+	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
+			{}) as JsonRecord;
+		delete servers[name];
+		settings.mcpServers = servers;
+	});
+	return readMcpServersResponse();
+}
diff --git a/apps/examples/desktop-app/sidecar/paths.ts b/apps/examples/desktop-app/sidecar/paths.ts
new file mode 100644
index 0000000..7b407eb
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/paths.ts
@@ -0,0 +1,156 @@
+import { execFileSync } from "node:child_process";
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { resolveSessionDataDir } from "@cline/shared/storage";
+import type { JsonRecord } from "./types";
+
+// ---------------------------------------------------------------------------
+// Workspace root
+// ---------------------------------------------------------------------------
+
+export function resolveWorkspaceRoot(launchCwd: string): string {
+	const cwd = resolve(launchCwd);
+	try {
+		const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			cwd,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		})
+			.trim()
+			.replace(/[\\/]+$/, "");
+		return root || cwd;
+	} catch {
+		return cwd;
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Shared session data directories
+// ---------------------------------------------------------------------------
+
+export function sharedSessionDataDir(): string {
+	return process.env.CLINE_SESSION_DATA_DIR?.trim() || resolveSessionDataDir();
+}
+
+export function sharedSessionArtifactPath(
+	sessionId: string,
+	suffix: string,
+): string {
+	return join(sharedSessionDataDir(), sessionId, `${sessionId}.${suffix}`);
+}
+
+export function sharedSessionMessagesPath(sessionId: string): string {
+	return sharedSessionArtifactPath(sessionId, "messages.json");
+}
+
+export function sharedSessionMessagesWritePath(sessionId: string): string {
+	return sharedSessionMessagesPath(sessionId);
+}
+
+// ---------------------------------------------------------------------------
+// Tool approval directory (kept for file cleanup compatibility)
+// ---------------------------------------------------------------------------
+
+export function toolApprovalDir(): string {
+	return (
+		process.env.CLINE_TOOL_APPROVAL_DIR?.trim() ||
+		join(sharedSessionDataDir(), "tool-approvals")
+	);
+}
+
+// ---------------------------------------------------------------------------
+// MCP settings
+// ---------------------------------------------------------------------------
+
+export function resolveMcpSettingsPath(): string {
+	return (
+		process.env.CLINE_MCP_SETTINGS_PATH?.trim() ||
+		join(homedir(), ".cline", "data", "settings", "cline_mcp_settings.json")
+	);
+}
+
+// ---------------------------------------------------------------------------
+// Session log paths (kanban-style)
+// ---------------------------------------------------------------------------
+
+function kanbanDataRoot(): string {
+	return (
+		process.env.CLINE_KANBAN_DATA_DIR?.trim() ||
+		join(homedir(), ".cline", "apps", "kanban")
+	);
+}
+
+export function sessionLogPath(sessionId: string): string {
+	return join(kanbanDataRoot(), "sessions", `${sessionId}.jsonl`);
+}
+
+// ---------------------------------------------------------------------------
+// Session ID helpers
+// ---------------------------------------------------------------------------
+
+export function rootSessionIdFrom(sessionId: string): string {
+	return sessionId.split("__")[0] || sessionId;
+}
+
+// ---------------------------------------------------------------------------
+// Artifact discovery
+// ---------------------------------------------------------------------------
+
+export function findArtifactUnderDir(
+	dir: string,
+	fileName: string,
+	maxDepth: number,
+): string | null {
+	if (!existsSync(dir)) {
+		return null;
+	}
+	const stack: Array<{ dir: string; depth: number }> = [{ dir, depth: 0 }];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current) {
+			break;
+		}
+		for (const entry of readdirSync(current.dir, { withFileTypes: true })) {
+			const path = join(current.dir, entry.name);
+			if (entry.isFile() && entry.name === fileName) {
+				return path;
+			}
+			if (entry.isDirectory() && current.depth < maxDepth) {
+				stack.push({ dir: path, depth: current.depth + 1 });
+			}
+		}
+	}
+	return null;
+}
+
+// ---------------------------------------------------------------------------
+// Session manifest read/write
+// ---------------------------------------------------------------------------
+
+export function readSessionManifest(sessionId: string): JsonRecord | null {
+	const path = join(sharedSessionDataDir(), sessionId, `${sessionId}.json`);
+	if (!existsSync(path)) {
+		return null;
+	}
+	try {
+		return JSON.parse(readFileSync(path, "utf8")) as JsonRecord;
+	} catch {
+		return null;
+	}
+}
+
+export function writeSessionManifest(
+	sessionId: string,
+	manifest: JsonRecord,
+): void {
+	const path = join(sharedSessionDataDir(), sessionId, `${sessionId}.json`);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
diff --git a/apps/examples/desktop-app/sidecar/server.test.ts b/apps/examples/desktop-app/sidecar/server.test.ts
new file mode 100644
index 0000000..7fc9c4d
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/server.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it, vi } from "vitest";
+import { createFetchHandler } from "./server";
+import type { SidecarContext } from "./types";
+
+function createTestServer() {
+	return {
+		port: 3126,
+		upgrade: vi.fn(() => true),
+	};
+}
+
+function createHandler(onShutdown = vi.fn()) {
+	return createFetchHandler({} as SidecarContext, onShutdown);
+}
+
+describe("sidecar HTTP origin checks", () => {
+	it("rejects cross-origin shutdown preflight requests", async () => {
+		const server = createTestServer();
+		const response = await createHandler()(
+			new Request("http://127.0.0.1:3126/shutdown", {
+				method: "OPTIONS",
+				headers: {
+					origin: "https://attacker.example",
+					"access-control-request-method": "POST",
+				},
+			}),
+			server,
+		);
+
+		expect(response?.status).toBe(403);
+		expect(response?.headers.get("access-control-allow-origin")).toBeNull();
+	});
+
+	it("rejects cross-origin shutdown POST requests", async () => {
+		const onShutdown = vi.fn();
+		const server = createTestServer();
+		const response = await createHandler(onShutdown)(
+			new Request("http://127.0.0.1:3126/shutdown", {
+				method: "POST",
+				headers: {
+					origin: "https://attacker.example",
+				},
+			}),
+			server,
+		);
+
+		expect(response?.status).toBe(403);
+		expect(onShutdown).not.toHaveBeenCalled();
+	});
+
+	it("rejects cross-origin websocket upgrades", async () => {
+		const server = createTestServer();
+		const response = await createHandler()(
+			new Request("http://127.0.0.1:3126/transport", {
+				headers: {
+					origin: "https://attacker.example",
+				},
+			}),
+			server,
+		);
+
+		expect(response?.status).toBe(404);
+		expect(server.upgrade).not.toHaveBeenCalled();
+	});
+
+	it("allows desktop webview origins in preflight responses", async () => {
+		const server = createTestServer();
+		const response = await createHandler()(
+			new Request("http://127.0.0.1:3126/api/marketplace/catalog", {
+				method: "OPTIONS",
+				headers: {
+					origin: "tauri://localhost",
+					"access-control-request-method": "GET",
+				},
+			}),
+			server,
+		);
+
+		expect(response?.status).toBe(204);
+		expect(response?.headers.get("access-control-allow-origin")).toBe(
+			"tauri://localhost",
+		);
+	});
+});
diff --git a/apps/examples/desktop-app/sidecar/server.ts b/apps/examples/desktop-app/sidecar/server.ts
new file mode 100644
index 0000000..6150540
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/server.ts
@@ -0,0 +1,246 @@
+import type { DesktopTransportRequest } from "../webview/lib/desktop-transport";
+import { handleCommand } from "./commands";
+import { sendEvent } from "./context";
+import { fetchMarketplaceCatalog } from "./marketplace";
+import {
+	BunRuntime,
+	SIDECAR_MODE,
+	SIDECAR_PORT,
+	type SidecarContext,
+	type SidecarWebSocketClient,
+} from "./types";
+
+type SidecarServer = {
+	port: number;
+	upgrade(req: Request): boolean;
+};
+
+const TRUSTED_BROWSER_ORIGINS = new Set([
+	"tauri://localhost",
+	"http://tauri.localhost",
+	"https://tauri.localhost",
+	"http://localhost:3125",
+	"http://127.0.0.1:3125",
+]);
+
+const JSON_HEADERS = {
+	"content-type": "application/json",
+};
+
+function readOrigin(req: Request): string | undefined {
+	const origin = req.headers.get("origin")?.trim();
+	return origin ? origin : undefined;
+}
+
+function isTrustedRequestOrigin(req: Request): boolean {
+	const origin = readOrigin(req);
+	return !origin || TRUSTED_BROWSER_ORIGINS.has(origin);
+}
+
+function corsHeaders(req: Request): Record<string, string> {
+	const origin = readOrigin(req);
+	return {
+		"access-control-allow-headers": "accept, content-type",
+		"access-control-allow-methods": "GET, POST, OPTIONS",
+		...(origin && TRUSTED_BROWSER_ORIGINS.has(origin)
+			? {
+					"access-control-allow-origin": origin,
+					vary: "Origin",
+				}
+			: {}),
+	};
+}
+
+function jsonHeaders(req: Request): Record<string, string> {
+	return {
+		...JSON_HEADERS,
+		...corsHeaders(req),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// JSON response helper
+// ---------------------------------------------------------------------------
+
+function jsonResponse(
+	id: string,
+	ok: boolean,
+	result?: unknown,
+	error?: string,
+): string {
+	return JSON.stringify({ type: "response", id, ok, result, error });
+}
+
+function createJsonResponse(
+	req: Request,
+	body: unknown,
+	status = 200,
+): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: jsonHeaders(req),
+	});
+}
+
+const EMPTY_MARKETPLACE_CATALOG = {
+	version: 1,
+	counts: {
+		total: 0,
+		plugins: 0,
+		skills: 0,
+		mcps: 0,
+	},
+	tags: [],
+	entries: [],
+};
+
+// ---------------------------------------------------------------------------
+// Bun HTTP + WebSocket server
+// ---------------------------------------------------------------------------
+
+export function startServer(
+	ctx: SidecarContext,
+	preferredPort: number = SIDECAR_PORT,
+	onShutdown?: (reason?: string) => Promise<void>,
+): { port: number } {
+	if (!BunRuntime) {
+		throw new Error("sidecar must be run with Bun");
+	}
+
+	let server: SidecarServer | undefined;
+	let lastError: unknown;
+
+	// Try the preferred port first, then fall back to OS-assigned port (0).
+	const candidates = [preferredPort, 0];
+	for (const candidate of candidates) {
+		try {
+			server = BunRuntime.serve({
+				hostname: "127.0.0.1",
+				port: candidate,
+				fetch: createFetchHandler(ctx, onShutdown),
+				websocket: createWebSocketHandler(ctx),
+			}) as SidecarServer;
+			break;
+		} catch (error) {
+			lastError = error;
+		}
+	}
+
+	if (!server) {
+		throw lastError ?? new Error("Failed to start sidecar server");
+	}
+
+	return { port: server.port };
+}
+
+export function createFetchHandler(
+	_ctx: SidecarContext,
+	onShutdown?: (reason?: string) => Promise<void>,
+) {
+	return async (req: Request, server: SidecarServer) => {
+		const url = new URL(req.url);
+
+		if (req.method === "OPTIONS") {
+			if (!isTrustedRequestOrigin(req)) {
+				return new Response(null, { status: 403 });
+			}
+			return new Response(null, { status: 204, headers: corsHeaders(req) });
+		}
+
+		if (url.pathname === "/health") {
+			return new Response(
+				JSON.stringify({
+					ok: true,
+					mode: SIDECAR_MODE,
+					pid: process.pid,
+				}),
+				{ headers: jsonHeaders(req) },
+			);
+		}
+
+		if (
+			url.pathname === "/transport" &&
+			isTrustedRequestOrigin(req) &&
+			server.upgrade(req)
+		) {
+			return undefined;
+		}
+
+		if (url.pathname === "/api/marketplace/catalog") {
+			try {
+				return createJsonResponse(req, await fetchMarketplaceCatalog());
+			} catch (error) {
+				return createJsonResponse(req, {
+					...EMPTY_MARKETPLACE_CATALOG,
+					error:
+						error instanceof Error
+							? error.message
+							: "Failed to fetch marketplace catalog",
+				});
+			}
+		}
+
+		if (url.pathname === "/shutdown" && req.method === "POST") {
+			if (!isTrustedRequestOrigin(req)) {
+				return new Response(JSON.stringify({ ok: false }), {
+					status: 403,
+					headers: jsonHeaders(req),
+				});
+			}
+			queueMicrotask(() => {
+				void onShutdown?.("code_sidecar_shutdown_endpoint")
+					.catch((error) => {
+						process.stderr.write(
+							`sidecar shutdown failed: ${
+								error instanceof Error ? error.message : String(error)
+							}\n`,
+						);
+					})
+					.finally(() => process.exit(0));
+			});
+			return new Response(JSON.stringify({ ok: true }), {
+				headers: jsonHeaders(req),
+			});
+		}
+
+		return new Response("Not found", { status: 404 });
+	};
+}
+
+function createWebSocketHandler(ctx: SidecarContext) {
+	return {
+		open(ws: SidecarWebSocketClient) {
+			ctx.wsClients.add(ws);
+			sendEvent(ctx, "host_ready", {
+				pid: process.pid,
+				mode: SIDECAR_MODE,
+			});
+		},
+		async message(ws: SidecarWebSocketClient, raw: string) {
+			let request: DesktopTransportRequest;
+			try {
+				request = JSON.parse(String(raw)) as DesktopTransportRequest;
+			} catch {
+				ws.send(
+					jsonResponse(
+						"",
+						false,
+						undefined,
+						"invalid desktop transport payload",
+					),
+				);
+				return;
+			}
+			try {
+				const result = await handleCommand(ctx, request.command, request.args);
+				ws.send(jsonResponse(request.id, true, result));
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				ws.send(jsonResponse(request.id, false, undefined, message));
+			}
+		},
+		close(ws: SidecarWebSocketClient) {
+			ctx.wsClients.delete(ws);
+		},
+	};
+}
diff --git a/apps/examples/desktop-app/sidecar/session-data/artifacts.ts b/apps/examples/desktop-app/sidecar/session-data/artifacts.ts
new file mode 100644
index 0000000..1a6ec35
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/session-data/artifacts.ts
@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { JsonRecord } from "../types";
+import { parseF64Value, parseU64Value } from "./common";
+
+function resolveGlobalHookLogPath(): string {
+	const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim();
+	if (envPath) return envPath;
+	const dataDir =
+		process.env.CLINE_DATA_DIR?.trim() ||
+		join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".cline", "data");
+	return join(dataDir, "logs", "hooks.jsonl");
+}
+
+export async function readSessionHooks(
+	sessionId: string,
+	limit = 300,
+): Promise<unknown[]> {
+	const path = resolveGlobalHookLogPath();
+	if (!existsSync(path)) {
+		return [];
+	}
+	const raw = await readFile(path, "utf8");
+	const max = Math.max(1, limit);
+	const out: JsonRecord[] = [];
+	let lineEnd = raw.length;
+	for (let index = raw.length - 1; index >= -1; index -= 1) {
+		if (index >= 0 && raw.charCodeAt(index) !== 10) {
+			continue;
+		}
+		const line = raw.slice(index + 1, lineEnd).replace(/\r$/, "");
+		lineEnd = index;
+		if (!line.trim()) {
+			continue;
+		}
+		try {
+			const value = JSON.parse(line) as JsonRecord;
+
+			// Filter to events belonging to this session.
+			const rootSessionId =
+				value.sessionContext &&
+				typeof value.sessionContext === "object" &&
+				typeof (value.sessionContext as JsonRecord).rootSessionId === "string"
+					? ((value.sessionContext as JsonRecord).rootSessionId as string)
+					: undefined;
+			const eventSessionId =
+				typeof value.sessionId === "string" ? value.sessionId : undefined;
+			if (
+				rootSessionId !== sessionId &&
+				eventSessionId !== sessionId &&
+				value.taskId !== sessionId
+			) {
+				continue;
+			}
+
+			const hookName =
+				(typeof value.hookName === "string" && value.hookName) ||
+				(typeof value.hook_event_name === "string" && value.hook_event_name) ||
+				(typeof value.event === "string" && value.event) ||
+				"";
+			if (!hookName) {
+				continue;
+			}
+			const usage =
+				(value.turn &&
+				typeof value.turn === "object" &&
+				(value.turn as JsonRecord).usage &&
+				typeof (value.turn as JsonRecord).usage === "object"
+					? ((value.turn as JsonRecord).usage as JsonRecord)
+					: undefined) ||
+				(value.usage && typeof value.usage === "object"
+					? (value.usage as JsonRecord)
+					: undefined) ||
+				(value.turn_usage && typeof value.turn_usage === "object"
+					? (value.turn_usage as JsonRecord)
+					: undefined);
+			out.push({
+				ts: typeof value.ts === "string" ? value.ts : "",
+				hookName,
+				agentId: value.agent_id,
+				taskId: value.taskId ?? value.conversation_id,
+				parentAgentId: value.parent_agent_id,
+				iteration: parseU64Value(value.iteration),
+				toolName:
+					(value.tool_call &&
+						typeof value.tool_call === "object" &&
+						(value.tool_call as JsonRecord).name) ||
+					(value.tool_result &&
+						typeof value.tool_result === "object" &&
+						(value.tool_result as JsonRecord).name),
+				toolInput:
+					(value.tool_call &&
+						typeof value.tool_call === "object" &&
+						(value.tool_call as JsonRecord).input) ||
+					(value.tool_result &&
+						typeof value.tool_result === "object" &&
+						(value.tool_result as JsonRecord).input),
+				toolOutput:
+					value.tool_result && typeof value.tool_result === "object"
+						? (value.tool_result as JsonRecord).output
+						: undefined,
+				toolError:
+					value.tool_result && typeof value.tool_result === "object"
+						? (value.tool_result as JsonRecord).error
+						: undefined,
+				inputTokens:
+					parseU64Value(usage?.inputTokens) ??
+					parseU64Value(usage?.input_tokens) ??
+					parseU64Value(usage?.prompt_tokens),
+				outputTokens:
+					parseU64Value(usage?.outputTokens) ??
+					parseU64Value(usage?.output_tokens) ??
+					parseU64Value(usage?.completion_tokens),
+				totalCost:
+					parseF64Value(usage?.totalCost) ??
+					parseF64Value(usage?.total_cost) ??
+					parseF64Value(usage?.cost),
+			});
+			if (out.length >= max) {
+				break;
+			}
+		} catch {
+			// Ignore malformed lines.
+		}
+	}
+	return out.reverse();
+}
diff --git a/apps/examples/desktop-app/sidecar/session-data/common.ts b/apps/examples/desktop-app/sidecar/session-data/common.ts
new file mode 100644
index 0000000..4900a69
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/session-data/common.ts
@@ -0,0 +1,250 @@
+import { formatDisplayUserInput } from "@cline/shared";
+import { readSessionManifest } from "../paths";
+import type { JsonRecord } from "../types";
+
+export function normalizeSessionTitle(
+	title?: string | null,
+): string | undefined {
+	const trimmed = title?.trim();
+	return trimmed ? formatDisplayUserInput(trimmed).slice(0, 120) : undefined;
+}
+
+export function parseTimestamp(value?: string | number | null): number {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return value;
+	}
+	const trimmed = typeof value === "string" ? value.trim() : "";
+	if (!trimmed) {
+		return Number.NEGATIVE_INFINITY;
+	}
+	const maybeEpoch = Number(trimmed);
+	if (Number.isFinite(maybeEpoch)) {
+		if (/^\d{10}$/.test(trimmed)) {
+			return maybeEpoch * 1000;
+		}
+		return maybeEpoch;
+	}
+	const parsed = new Date(trimmed).getTime();
+	return Number.isNaN(parsed) ? Number.NEGATIVE_INFINITY : parsed;
+}
+
+export function compareSessionRecordsByStartedAtDesc(
+	left: JsonRecord,
+	right: JsonRecord,
+): number {
+	const timeDelta =
+		parseTimestamp(right.startedAt as string | number | undefined) -
+		parseTimestamp(left.startedAt as string | number | undefined);
+	if (timeDelta !== 0) {
+		return timeDelta;
+	}
+	const leftId = String(left.sessionId ?? "");
+	const rightId = String(right.sessionId ?? "");
+	return rightId.localeCompare(leftId);
+}
+
+export function stringifyMessageContent(value: unknown): string {
+	if (typeof value === "string") {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		const parts: string[] = [];
+		for (const block of value) {
+			if (typeof block === "string") {
+				if (block.trim()) {
+					parts.push(block);
+				}
+				continue;
+			}
+			if (!block || typeof block !== "object") {
+				continue;
+			}
+			const record = block as JsonRecord;
+			const blockType = typeof record.type === "string" ? record.type : "";
+			const piece =
+				blockType === "text"
+					? String(record.text ?? "")
+					: blockType === "thinking"
+						? String(record.thinking ?? "")
+						: blockType === "tool_use"
+							? `[tool] ${String(record.name ?? "tool_call")}`
+							: blockType === "tool_result"
+								? `[tool_result]\n${stringifyMessageContent(record.content)}`
+								: blockType === "image"
+									? "[image]"
+									: blockType === "redacted_thinking"
+										? "[redacted_thinking]"
+										: typeof record.text === "string"
+											? record.text
+											: "";
+			if (piece.trim()) {
+				parts.push(piece);
+			}
+		}
+		return parts.join("\n");
+	}
+	if (value && typeof value === "object") {
+		const record = value as JsonRecord;
+		if (typeof record.text === "string") {
+			return record.text;
+		}
+	}
+	return "";
+}
+
+function titleFromPrompt(prompt?: string | null): string | undefined {
+	const normalized = normalizeSessionTitle(prompt ?? undefined);
+	if (!normalized) {
+		return undefined;
+	}
+	return normalized.split("\n")[0]?.trim().slice(0, 70) || undefined;
+}
+
+function titleFromMessages(messages: unknown[]): string | undefined {
+	for (const role of ["user", "assistant"] as const) {
+		for (const rawMessage of messages) {
+			if (!rawMessage || typeof rawMessage !== "object") {
+				continue;
+			}
+			const message = rawMessage as JsonRecord;
+			if (message.role !== role) {
+				continue;
+			}
+			const text = normalizeSessionTitle(
+				stringifyMessageContent(message.content),
+			);
+			if (!text) {
+				continue;
+			}
+			return text.split("\n")[0]?.trim().slice(0, 70) || undefined;
+		}
+	}
+	return undefined;
+}
+
+export function derivePromptFromMessages(
+	messages: unknown[],
+): string | undefined {
+	for (const message of messages) {
+		if (!message || typeof message !== "object") {
+			continue;
+		}
+		const record = message as JsonRecord;
+		if (record.role !== "user") {
+			continue;
+		}
+		const metadata =
+			record.metadata && typeof record.metadata === "object"
+				? (record.metadata as JsonRecord)
+				: undefined;
+		if (
+			typeof metadata?.kind === "string" &&
+			metadata.kind === "recovery_notice"
+		) {
+			continue;
+		}
+		const content = stringifyMessageContent(record.content);
+		if (content.trim()) {
+			return content.trim();
+		}
+	}
+	return undefined;
+}
+
+export function resolveSessionListTitle(options: {
+	sessionId: string;
+	metadata?: unknown;
+	prompt?: string | null;
+	messages?: unknown[];
+}): string {
+	const metadataTitle =
+		options.metadata && typeof options.metadata === "object"
+			? normalizeSessionTitle(
+					(options.metadata as JsonRecord).title as string | undefined,
+				)
+			: undefined;
+	if (metadataTitle) {
+		return metadataTitle.slice(0, 70);
+	}
+	const promptTitle = titleFromPrompt(options.prompt);
+	if (promptTitle) {
+		return promptTitle;
+	}
+	const messageTitle = options.messages
+		? titleFromMessages(options.messages)
+		: undefined;
+	if (messageTitle) {
+		return messageTitle;
+	}
+	return `Session ${options.sessionId.slice(-6)}`;
+}
+
+export function readSessionMetadataTitle(
+	sessionId: string,
+): string | undefined {
+	const metadata = readSessionManifest(sessionId)?.metadata;
+	if (!metadata || typeof metadata !== "object") {
+		return undefined;
+	}
+	return normalizeSessionTitle(
+		(metadata as JsonRecord).title as string | undefined,
+	);
+}
+
+export function parseU64Value(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+		return Math.trunc(value);
+	}
+	if (typeof value === "string") {
+		const parsed = Number.parseInt(value, 10);
+		if (Number.isFinite(parsed) && parsed >= 0) {
+			return parsed;
+		}
+	}
+	return undefined;
+}
+
+export function parseF64Value(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+		return value;
+	}
+	if (typeof value === "string") {
+		const parsed = Number.parseFloat(value);
+		if (Number.isFinite(parsed) && parsed >= 0) {
+			return parsed;
+		}
+	}
+	return undefined;
+}
+
+export function normalizeChatFinishStatus(status?: string): string {
+	const normalized = status?.trim().toLowerCase() || "";
+	if (!normalized) {
+		return "completed";
+	}
+	if (
+		normalized.includes("cancel") ||
+		normalized.includes("abort") ||
+		normalized.includes("interrupt")
+	) {
+		return "cancelled";
+	}
+	if (normalized.includes("fail") || normalized.includes("error")) {
+		return "failed";
+	}
+	if (normalized.includes("run") || normalized.includes("start")) {
+		return "running";
+	}
+	if (
+		normalized.includes("complete") ||
+		normalized.includes("done") ||
+		normalized.includes("stop") ||
+		normalized.includes("mistake_limit") ||
+		normalized.includes("mistake-limit") ||
+		normalized.includes("max_iteration") ||
+		normalized.includes("max-iteration")
+	) {
+		return "completed";
+	}
+	return "idle";
+}
diff --git a/apps/examples/desktop-app/sidecar/session-data/discovery.ts b/apps/examples/desktop-app/sidecar/session-data/discovery.ts
new file mode 100644
index 0000000..6c3a87b
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/session-data/discovery.ts
@@ -0,0 +1,192 @@
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { SqliteSessionStore } from "@cline/core";
+import { readSessionManifest, sharedSessionDataDir } from "../paths";
+import type { JsonRecord } from "../types";
+import {
+	compareSessionRecordsByStartedAtDesc,
+	derivePromptFromMessages,
+	resolveSessionListTitle,
+} from "./common";
+import { readPersistedChatMessages } from "./messages";
+
+/**
+ * Minimal context shape required by discoverChatSessions so both the host
+ * backend and the sidecar can call it without pulling in CLI-specific code.
+ */
+export type DiscoveryChatContext = {
+	liveSessions: Map<
+		string,
+		{
+			busy: boolean;
+			prompt?: string;
+			title?: string;
+			messages: unknown[];
+			status: string;
+			config: JsonRecord;
+			startedAt: number;
+			endedAt?: number;
+		}
+	>;
+};
+
+function trimKnownString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	return trimmed.toLowerCase() === "unknown" ? undefined : trimmed;
+}
+
+export function discoverChatSessions(
+	ctx: DiscoveryChatContext,
+	limit = 300,
+): unknown[] {
+	const out: JsonRecord[] = [];
+	const store = new SqliteSessionStore();
+	for (const [sessionId, session] of ctx.liveSessions.entries()) {
+		if (!session.busy && !session.prompt && session.messages.length === 0) {
+			continue;
+		}
+		const prompt = session.prompt ?? derivePromptFromMessages(session.messages);
+		const resolvedTitle = resolveSessionListTitle({
+			sessionId,
+			metadata: session.title ? { title: session.title } : undefined,
+			prompt,
+			messages: session.messages,
+		});
+		out.push({
+			sessionId,
+			status: session.status,
+			provider: session.config.provider ?? "",
+			model: session.config.model ?? "",
+			cwd: session.config.cwd ?? session.config.workspaceRoot ?? "",
+			workspaceRoot: session.config.workspaceRoot ?? "",
+			prompt,
+			startedAt: String(session.startedAt),
+			endedAt: session.endedAt ? String(session.endedAt) : undefined,
+			metadata: { title: resolvedTitle },
+		});
+	}
+
+	const base = sharedSessionDataDir();
+	if (existsSync(base)) {
+		for (const entry of readdirSync(base, { withFileTypes: true })) {
+			if (!entry.isDirectory()) {
+				continue;
+			}
+			const sessionId = entry.name.trim();
+			if (!sessionId || out.some((item) => item.sessionId === sessionId)) {
+				continue;
+			}
+			// Skip subagent / team-task child sessions — they are shown
+			// under their parent, not as top-level sidebar entries.
+			if (sessionId.includes("__teamtask__") || sessionId.includes("__sub__")) {
+				continue;
+			}
+			if (!store.get(sessionId)) {
+				try {
+					rmSync(join(base, sessionId), { recursive: true, force: true });
+				} catch {
+					// Ignore cleanup failures and keep orphaned artifacts hidden.
+				}
+				continue;
+			}
+			const manifest = readSessionManifest(sessionId) ?? {};
+			// Skip sessions explicitly marked as subagent.
+			if (manifest.source === "subagent") {
+				continue;
+			}
+			const provider = trimKnownString(manifest.provider);
+			const model = trimKnownString(manifest.model);
+			if (!provider || !model) {
+				continue;
+			}
+			const messages = readPersistedChatMessages(sessionId) ?? [];
+			if (messages.length === 0) {
+				continue;
+			}
+			const metadata =
+				manifest.metadata && typeof manifest.metadata === "object"
+					? { ...(manifest.metadata as JsonRecord) }
+					: undefined;
+			const prompt = derivePromptFromMessages(messages);
+			const resolvedTitle = resolveSessionListTitle({
+				sessionId,
+				metadata,
+				prompt,
+				messages,
+			});
+			out.push({
+				sessionId,
+				status: "completed",
+				provider,
+				model,
+				cwd: manifest.cwd ?? "",
+				workspaceRoot:
+					manifest.workspace_root ??
+					manifest.workspaceRoot ??
+					manifest.cwd ??
+					"",
+				prompt,
+				startedAt: String(
+					manifest.started_at ?? manifest.startedAt ?? Date.now(),
+				),
+				endedAt:
+					(manifest.ended_at ?? manifest.endedAt)
+						? String(manifest.ended_at ?? manifest.endedAt)
+						: undefined,
+				metadata: {
+					...(metadata ?? {}),
+					title: resolvedTitle,
+				},
+			});
+		}
+	}
+
+	out.sort(compareSessionRecordsByStartedAtDesc);
+	return out.slice(0, Math.max(1, limit));
+}
+
+export function mergeDiscoveredSessionLists(
+	chat: unknown[],
+	cli: unknown[],
+	limit: number,
+): unknown[] {
+	const merged = new Map<string, unknown>();
+	for (const item of [...chat, ...cli]) {
+		if (!item || typeof item !== "object") {
+			continue;
+		}
+		const sessionId = String(
+			(item as JsonRecord).sessionId ?? (item as JsonRecord).session_id ?? "",
+		).trim();
+		if (!sessionId || merged.has(sessionId)) {
+			continue;
+		}
+		const normalized = item as JsonRecord;
+		merged.set(sessionId, {
+			...normalized,
+			sessionId,
+			startedAt:
+				normalized.startedAt ?? normalized.started_at ?? String(Date.now()),
+			endedAt: normalized.endedAt ?? normalized.ended_at,
+			workspaceRoot:
+				normalized.workspaceRoot ??
+				normalized.workspace_root ??
+				normalized.cwd ??
+				"",
+		});
+	}
+	return Array.from(merged.values())
+		.sort((left, right) =>
+			compareSessionRecordsByStartedAtDesc(
+				left as JsonRecord,
+				right as JsonRecord,
+			),
+		)
+		.slice(0, limit);
+}
diff --git a/apps/examples/desktop-app/sidecar/session-data/messages.ts b/apps/examples/desktop-app/sidecar/session-data/messages.ts
new file mode 100644
index 0000000..e4cffe9
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/session-data/messages.ts
@@ -0,0 +1,542 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import {
+	readSessionManifest,
+	sharedSessionMessagesPath,
+	sharedSessionMessagesWritePath,
+} from "../paths";
+import type { JsonRecord, SidecarContext } from "../types";
+import {
+	parseF64Value,
+	parseU64Value,
+	stringifyMessageContent,
+} from "./common";
+
+type ChatTurnResult = {
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	};
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+};
+
+const nowMs = () => Date.now();
+
+function readMessageMetadata(message: JsonRecord): JsonRecord | undefined {
+	return message.metadata && typeof message.metadata === "object"
+		? (message.metadata as JsonRecord)
+		: undefined;
+}
+
+function resolveDisplayRole(
+	role: string,
+	metadata: JsonRecord | undefined,
+): string {
+	const displayRole =
+		typeof metadata?.displayRole === "string"
+			? metadata.displayRole.trim().toLowerCase()
+			: "";
+	if (
+		displayRole === "system" ||
+		displayRole === "status" ||
+		displayRole === "error"
+	) {
+		return displayRole;
+	}
+	return role;
+}
+
+function extractStoredMessageMeta(message: JsonRecord): JsonRecord | undefined {
+	const metadata = readMessageMetadata(message);
+	if (!metadata) {
+		return undefined;
+	}
+	const hookEventName =
+		typeof metadata.kind === "string" ? "history_notice" : undefined;
+	const messageKind =
+		typeof metadata.kind === "string" ? metadata.kind : undefined;
+	const displayRole =
+		typeof metadata.displayRole === "string" ? metadata.displayRole : undefined;
+	const reason =
+		typeof metadata.reason === "string" ? metadata.reason : undefined;
+	if (!hookEventName && !messageKind && !displayRole && !reason) {
+		return undefined;
+	}
+	return {
+		hookEventName,
+		messageKind,
+		displayRole,
+		reason,
+	};
+}
+
+function extractMessageUsageMeta(message: JsonRecord): JsonRecord | undefined {
+	const metrics =
+		message.metrics && typeof message.metrics === "object"
+			? (message.metrics as JsonRecord)
+			: undefined;
+	const modelInfo =
+		message.modelInfo && typeof message.modelInfo === "object"
+			? (message.modelInfo as JsonRecord)
+			: undefined;
+	const inputTokens = parseU64Value(metrics?.inputTokens);
+	const outputTokens = parseU64Value(metrics?.outputTokens);
+	const cacheReadTokens = parseU64Value(metrics?.cacheReadTokens);
+	const cacheWriteTokens = parseU64Value(metrics?.cacheWriteTokens);
+	const totalCost = parseF64Value(metrics?.cost);
+	const providerId =
+		(typeof message.providerId === "string" && message.providerId) ||
+		(typeof modelInfo?.provider === "string" ? modelInfo.provider : undefined);
+	const modelId =
+		(typeof message.modelId === "string" && message.modelId) ||
+		(typeof modelInfo?.id === "string" ? modelInfo.id : undefined);
+	if (
+		inputTokens === undefined &&
+		outputTokens === undefined &&
+		cacheReadTokens === undefined &&
+		cacheWriteTokens === undefined &&
+		totalCost === undefined &&
+		!providerId &&
+		!modelId
+	) {
+		return undefined;
+	}
+	return {
+		inputTokens,
+		outputTokens,
+		cacheReadTokens,
+		cacheWriteTokens,
+		totalCost,
+		providerId,
+		modelId,
+	};
+}
+
+function trimNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export function readPersistedChatMessages(sessionId: string): unknown[] | null {
+	const path = sharedSessionMessagesPath(sessionId);
+	if (!existsSync(path)) {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as
+			| { messages?: unknown[] }
+			| unknown[];
+		if (Array.isArray(parsed)) {
+			return parsed;
+		}
+		return Array.isArray(parsed.messages) ? parsed.messages : [];
+	} catch {
+		return null;
+	}
+}
+
+export function persistUsageInMessages(
+	messages: unknown[],
+	config: JsonRecord,
+	result: ChatTurnResult,
+): unknown[] {
+	const next = [...messages];
+	let assistantIndex = -1;
+	for (let i = next.length - 1; i >= 0; i -= 1) {
+		const item = next[i];
+		if (!item || typeof item !== "object") {
+			continue;
+		}
+		if ((item as JsonRecord).role === "assistant") {
+			assistantIndex = i;
+			break;
+		}
+	}
+	if (assistantIndex < 0) {
+		return next;
+	}
+
+	const assistantMessage = next[assistantIndex];
+	if (!assistantMessage || typeof assistantMessage !== "object") {
+		return next;
+	}
+
+	const record = { ...(assistantMessage as JsonRecord) };
+	const metrics =
+		record.metrics && typeof record.metrics === "object"
+			? { ...(record.metrics as JsonRecord) }
+			: {};
+	const inputTokens = result.usage?.inputTokens ?? result.inputTokens;
+	const outputTokens = result.usage?.outputTokens ?? result.outputTokens;
+	const cacheReadTokens = result.usage?.cacheReadTokens;
+	const cacheWriteTokens = result.usage?.cacheWriteTokens;
+	const totalCost = result.usage?.totalCost ?? result.totalCost;
+	if (typeof inputTokens === "number") {
+		metrics.inputTokens = inputTokens;
+	}
+	if (typeof outputTokens === "number") {
+		metrics.outputTokens = outputTokens;
+	}
+	if (typeof cacheReadTokens === "number") {
+		metrics.cacheReadTokens = cacheReadTokens;
+	}
+	if (typeof cacheWriteTokens === "number") {
+		metrics.cacheWriteTokens = cacheWriteTokens;
+	}
+	if (
+		typeof totalCost === "number" &&
+		Number.isFinite(totalCost) &&
+		totalCost >= 0
+	) {
+		metrics.cost = totalCost;
+	}
+	record.metrics = metrics;
+	const modelInfo =
+		record.modelInfo && typeof record.modelInfo === "object"
+			? { ...(record.modelInfo as JsonRecord) }
+			: {};
+	const modelId =
+		trimNonEmptyString(modelInfo.id) ?? trimNonEmptyString(config.model);
+	const providerId =
+		trimNonEmptyString(modelInfo.provider) ??
+		trimNonEmptyString(config.provider);
+	delete record.providerId;
+	delete record.modelId;
+	if (modelId && providerId) {
+		record.modelInfo = {
+			...modelInfo,
+			id: modelId,
+			provider: providerId,
+		};
+	}
+	if (!record.ts) {
+		record.ts = nowMs();
+	}
+	next[assistantIndex] = record;
+	return next;
+}
+
+function buildToolPayloadJson(
+	toolName: string,
+	input: unknown,
+	result: unknown,
+	isError: boolean,
+): string {
+	return JSON.stringify({
+		toolName,
+		input,
+		result,
+		isError,
+	});
+}
+
+function normalizeRole(role: unknown): string {
+	switch (role) {
+		case "user":
+		case "assistant":
+		case "tool":
+		case "system":
+		case "status":
+		case "error":
+			return String(role);
+		default:
+			return "assistant";
+	}
+}
+
+type StoredCheckpointEntry = {
+	ref: string;
+	createdAt: number;
+	runCount: number;
+	kind?: "stash" | "commit";
+};
+
+function readCheckpointEntriesByRunCount(
+	sessionId: string,
+): Map<number, StoredCheckpointEntry> {
+	const metadata = readSessionManifest(sessionId)?.metadata;
+	if (!metadata || typeof metadata !== "object") {
+		return new Map();
+	}
+	const checkpoint = (metadata as JsonRecord).checkpoint;
+	if (!checkpoint || typeof checkpoint !== "object") {
+		return new Map();
+	}
+	const history = (checkpoint as JsonRecord).history;
+	if (!Array.isArray(history)) {
+		return new Map();
+	}
+	const entries = new Map<number, StoredCheckpointEntry>();
+	for (const item of history) {
+		if (!item || typeof item !== "object") {
+			continue;
+		}
+		const entry = item as JsonRecord;
+		if (
+			typeof entry.ref !== "string" ||
+			typeof entry.createdAt !== "number" ||
+			typeof entry.runCount !== "number"
+		) {
+			continue;
+		}
+		entries.set(entry.runCount, {
+			ref: entry.ref,
+			createdAt: entry.createdAt,
+			runCount: entry.runCount,
+			kind:
+				entry.kind === "stash" || entry.kind === "commit"
+					? entry.kind
+					: undefined,
+		});
+	}
+	return entries;
+}
+
+export async function readSessionMessages(
+	ctx: Pick<SidecarContext, "liveSessions">,
+	sessionId: string,
+	maxMessages = 800,
+): Promise<unknown[]> {
+	const persisted = readPersistedChatMessages(sessionId);
+	const messages =
+		persisted && persisted.length > 0
+			? persisted
+			: (ctx.liveSessions.get(sessionId)?.messages ?? []);
+	const max = Math.max(1, maxMessages);
+	const start = Math.max(0, messages.length - max);
+	const baseTs = nowMs() - messages.length;
+	const out: JsonRecord[] = [];
+	const checkpointsByRunCount = readCheckpointEntriesByRunCount(sessionId);
+	const pendingToolMessages = new Map<string, [number, string, unknown]>();
+	let nextCreatedAt = baseTs;
+	let userRunCount = 0;
+
+	for (let idx = start; idx < messages.length; idx += 1) {
+		const rawMessage = messages[idx];
+		if (!rawMessage || typeof rawMessage !== "object") {
+			continue;
+		}
+		const message = rawMessage as JsonRecord;
+		let textMeta = extractMessageUsageMeta(message);
+		const storedMeta = extractStoredMessageMeta(message);
+		if (storedMeta) {
+			textMeta = { ...(textMeta ?? {}), ...storedMeta };
+		}
+		const role = resolveDisplayRole(
+			normalizeRole(message.role),
+			readMessageMetadata(message),
+		);
+		const metadata = readMessageMetadata(message);
+		const isRecoveryNotice =
+			typeof metadata?.kind === "string" && metadata.kind === "recovery_notice";
+		if (role === "user" && !isRecoveryNotice) {
+			userRunCount += 1;
+			const checkpoint = checkpointsByRunCount.get(userRunCount);
+			if (checkpoint) {
+				textMeta = {
+					...(textMeta ?? {}),
+					checkpoint,
+				};
+			}
+		}
+		const messageIdBase =
+			(typeof message.id === "string" && message.id.trim()) ||
+			`history_message_${idx}`;
+		const contentBlocks = Array.isArray(message.content)
+			? (message.content as unknown[])
+			: null;
+
+		if (!contentBlocks) {
+			const content = stringifyMessageContent(message.content);
+			if (!content.trim()) {
+				continue;
+			}
+			out.push({
+				id: messageIdBase,
+				sessionId,
+				role,
+				content,
+				createdAt: nextCreatedAt++,
+				meta: textMeta,
+			});
+			continue;
+		}
+
+		const textParts: string[] = [];
+		const reasoningParts: string[] = [];
+		let reasoningRedacted = false;
+		let textSegmentIndex = 0;
+		const outStartIndex = out.length;
+		const flushTextParts = () => {
+			if (textParts.length === 0) {
+				return;
+			}
+			const joined = textParts.join("\n");
+			textParts.length = 0;
+			if (!joined.trim()) {
+				return;
+			}
+			out.push({
+				id: `${messageIdBase}_text_${textSegmentIndex}`,
+				sessionId,
+				role,
+				content: joined,
+				createdAt: nextCreatedAt++,
+				meta: textMeta,
+			});
+			textSegmentIndex += 1;
+			textMeta = undefined;
+		};
+
+		for (let blockIdx = 0; blockIdx < contentBlocks.length; blockIdx += 1) {
+			const block = contentBlocks[blockIdx];
+			if (!block || typeof block !== "object") {
+				const line = stringifyMessageContent(block);
+				if (line.trim()) {
+					textParts.push(line);
+				}
+				continue;
+			}
+			const record = block as JsonRecord;
+			const blockType = typeof record.type === "string" ? record.type : "";
+			if (blockType === "tool_use") {
+				flushTextParts();
+				const toolName =
+					typeof record.name === "string" ? record.name : "tool_call";
+				const toolUseId = typeof record.id === "string" ? record.id : "";
+				const input = record.input ?? null;
+				const outIndex = out.length;
+				out.push({
+					id: `${messageIdBase}_tool_use_${blockIdx}`,
+					sessionId,
+					role: "tool",
+					content: buildToolPayloadJson(toolName, input, null, false),
+					createdAt: nextCreatedAt++,
+					meta: {
+						toolName,
+						hookEventName: "history_tool_use",
+					},
+				});
+				if (toolUseId.trim()) {
+					pendingToolMessages.set(toolUseId, [outIndex, toolName, input]);
+				}
+				continue;
+			}
+			if (blockType === "tool_result") {
+				flushTextParts();
+				const toolUseId =
+					typeof record.tool_use_id === "string" ? record.tool_use_id : "";
+				const result = record.content ?? null;
+				const isError = Boolean(record.is_error);
+				const existing = pendingToolMessages.get(toolUseId);
+				if (existing) {
+					const [outIndex, toolName, input] = existing;
+					const target = out[outIndex];
+					if (target) {
+						target.content = buildToolPayloadJson(
+							toolName,
+							input,
+							result,
+							isError,
+						);
+						target.meta = {
+							toolName,
+							hookEventName: "history_tool_result",
+						};
+					}
+					pendingToolMessages.delete(toolUseId);
+				} else {
+					out.push({
+						id: `${messageIdBase}_tool_result_${blockIdx}`,
+						sessionId,
+						role: "tool",
+						content: buildToolPayloadJson("tool_result", null, result, isError),
+						createdAt: nextCreatedAt++,
+						meta: {
+							toolName: "tool_result",
+							hookEventName: "history_tool_result",
+						},
+					});
+				}
+				continue;
+			}
+			if (blockType === "thinking") {
+				const thinking =
+					typeof record.thinking === "string" ? record.thinking : "";
+				if (thinking.trim()) {
+					reasoningParts.push(thinking);
+				}
+				continue;
+			}
+			if (blockType === "redacted_thinking") {
+				reasoningRedacted = true;
+				continue;
+			}
+			const line = stringifyMessageContent(block);
+			if (line.trim()) {
+				textParts.push(line);
+			}
+		}
+
+		flushTextParts();
+		if (reasoningParts.length > 0 || reasoningRedacted) {
+			const reasoning = reasoningParts.join("\n").trim();
+			const target = out
+				.slice(outStartIndex)
+				.find((item) => item.role === role);
+			if (target) {
+				if (reasoning) {
+					target.reasoning = reasoning;
+				}
+				if (reasoningRedacted) {
+					target.reasoningRedacted = true;
+				}
+			} else {
+				out.push({
+					id: `${messageIdBase}_reasoning`,
+					sessionId,
+					role,
+					content: "",
+					reasoning: reasoning || undefined,
+					reasoningRedacted: reasoningRedacted || undefined,
+					createdAt: nextCreatedAt++,
+					meta: textMeta,
+				});
+				textMeta = undefined;
+			}
+		}
+		if (textMeta && out[outStartIndex]) {
+			out[outStartIndex].meta = {
+				...(typeof out[outStartIndex].meta === "object"
+					? (out[outStartIndex].meta as JsonRecord)
+					: {}),
+				...textMeta,
+			};
+		}
+	}
+
+	return out;
+}
+
+export function persistSessionMessages(
+	sessionId: string,
+	persistedMessages: unknown[],
+) {
+	const writePath = sharedSessionMessagesWritePath(sessionId);
+	mkdirSync(dirname(writePath), { recursive: true });
+	writeFileSync(
+		writePath,
+		JSON.stringify(
+			{
+				messages: persistedMessages,
+				ts: nowMs(),
+			},
+			null,
+			2,
+		),
+	);
+}
diff --git a/apps/examples/desktop-app/sidecar/session-data/search.ts b/apps/examples/desktop-app/sidecar/session-data/search.ts
new file mode 100644
index 0000000..076e730
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/session-data/search.ts
@@ -0,0 +1,47 @@
+import { getFileIndex } from "@cline/core";
+import type { SidecarContext } from "../types";
+
+export function searchWorkspaceFiles(
+	ctx: Pick<SidecarContext, "workspaceRoot">,
+	args?: Record<string, unknown>,
+): Promise<string[]> {
+	const root =
+		typeof args?.workspaceRoot === "string" && args.workspaceRoot.trim()
+			? args.workspaceRoot.trim()
+			: ctx.workspaceRoot;
+	const query =
+		typeof args?.query === "string" ? args.query.trim().toLowerCase() : "";
+	const limit =
+		typeof args?.limit === "number" && Number.isFinite(args.limit)
+			? Math.max(1, Math.min(50, Math.trunc(args.limit)))
+			: 10;
+	const rankPath = (path: string) => {
+		if (!query) {
+			return 3;
+		}
+		const lower = path.toLowerCase();
+		if (lower.startsWith(query)) {
+			return 0;
+		}
+		if (lower.includes(`/${query}`)) {
+			return 1;
+		}
+		if (lower.includes(query)) {
+			return 2;
+		}
+		return Number.POSITIVE_INFINITY;
+	};
+	return getFileIndex(root).then((index) =>
+		Array.from(index)
+			.sort((a, b) => a.localeCompare(b))
+			.map((path) => ({ path, rank: rankPath(path) }))
+			.filter((item) => Number.isFinite(item.rank))
+			.sort((left, right) =>
+				left.rank !== right.rank
+					? left.rank - right.rank
+					: left.path.localeCompare(right.path),
+			)
+			.slice(0, limit)
+			.map((item) => item.path),
+	);
+}
diff --git a/apps/examples/desktop-app/sidecar/types.ts b/apps/examples/desktop-app/sidecar/types.ts
new file mode 100644
index 0000000..a57483e
--- /dev/null
+++ b/apps/examples/desktop-app/sidecar/types.ts
@@ -0,0 +1,118 @@
+import type {
+	AgentToolContext,
+	ClineCore,
+	HubServer,
+	NodeHubClient,
+	ToolApprovalResult,
+} from "@cline/core";
+
+export type JsonRecord = Record<string, unknown>;
+
+export type ChatTurnAttachments = {
+	userImages?: string[];
+	userFiles?: Array<{ name: string; content: string }>;
+};
+
+export type ChatSessionCommandRequest = {
+	action:
+		| "start"
+		| "attach"
+		| "send"
+		| "stop"
+		| "abort"
+		| "fork"
+		| "reset"
+		| "restore_checkpoint"
+		| "pending_prompts"
+		| "steer_prompt"
+		| "update_pending_prompt"
+		| "remove_pending_prompt";
+	sessionId?: string;
+	prompt?: string;
+	promptId?: string;
+	checkpointRunCount?: number;
+	delivery?: "queue" | "steer";
+	config?: JsonRecord;
+	attachments?: ChatTurnAttachments;
+};
+
+export type PromptInQueue = {
+	id: string;
+	prompt: string;
+	steer: boolean;
+	attachmentCount?: number;
+};
+
+export type LiveSession = {
+	config: JsonRecord;
+	messages: unknown[];
+	promptsInQueue: PromptInQueue[];
+	busy: boolean;
+	startedAt: number;
+	endedAt?: number;
+	status: string;
+	prompt?: string;
+	title?: string;
+	attachedViaHub?: boolean;
+};
+
+export type ToolApprovalRequestItem = {
+	requestId: string;
+	sessionId: string;
+	createdAt: string;
+	toolCallId: string;
+	toolName: string;
+	input?: unknown;
+	iteration?: number;
+	agentId?: string;
+	conversationId?: string;
+};
+
+export type PendingToolApproval = {
+	item: ToolApprovalRequestItem;
+	resolve: (result: ToolApprovalResult) => void;
+};
+
+export type AskQuestionRequestItem = {
+	requestId: string;
+	createdAt: string;
+	question: string;
+	options: string[];
+	context?: Pick<
+		AgentToolContext,
+		"agentId" | "conversationId" | "iteration" | "metadata"
+	>;
+};
+
+export type PendingAskQuestion = {
+	item: AskQuestionRequestItem;
+	resolve: (answer: string) => void;
+	reject: (error: Error) => void;
+	timeoutId?: ReturnType<typeof setTimeout>;
+};
+
+export type SidecarWebSocketClient = {
+	send: (message: string) => void;
+	close?: () => void;
+};
+
+export type SidecarContext = {
+	liveSessions: Map<string, LiveSession>;
+	streamIndices: Map<string, number>;
+	wsClients: Set<SidecarWebSocketClient>;
+	pendingApprovals: Map<string, PendingToolApproval>;
+	pendingQuestions: Map<string, PendingAskQuestion>;
+	sessionManager: ClineCore | null;
+	hubClient: NodeHubClient | null;
+	hubServer: HubServer | null;
+	workspaceRoot: string;
+	unsubscribeSessionEvents: (() => void) | null;
+};
+export type BunRuntimeApi = {
+	serve: (options: unknown) => { port: number; stop?: () => void };
+};
+
+export const BunRuntime = (globalThis as { Bun?: BunRuntimeApi }).Bun;
+
+export const SIDECAR_PORT = Number(process.env.CLINE_SIDECAR_PORT) || 3126;
+export const SIDECAR_MODE = "sidecar";
diff --git a/apps/examples/desktop-app/src-tauri/Cargo.lock b/apps/examples/desktop-app/src-tauri/Cargo.lock
new file mode 100644
index 0000000..1776ed6
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/Cargo.lock
@@ -0,0 +1,5241 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "ashpd"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f3f79755c74fd155000314eb349864caa787c6592eace6c6882dad873d9c39"
+dependencies = [
+ "async-fs",
+ "async-net",
+ "enumflags2",
+ "futures-channel",
+ "futures-util",
+ "rand",
+ "raw-window-handle",
+ "serde",
+ "serde_repr",
+ "url",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "zbus",
+]
+
+[[package]]
+name = "async-broadcast"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-fs"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
+dependencies = [
+ "async-lock",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "async-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-net"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"
+dependencies = [
+ "async-io",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "async-process"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
+dependencies = [
+ "async-channel",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix",
+]
+
+[[package]]
+name = "async-recursion"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-signal"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "atk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b"
+dependencies = [
+ "atk-sys",
+ "glib",
+ "libc",
+]
+
+[[package]]
+name = "atk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cairo-rs"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2"
+dependencies = [
+ "bitflags 2.11.0",
+ "cairo-sys-rs",
+ "glib",
+ "libc",
+ "once_cell",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "camino"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "cargo_toml"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374b7c592d9c00c1f4972ea58390ac6b18cbb6ab79011f3bdc90a0b82ca06b77"
+dependencies = [
+ "serde",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfb"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
+dependencies = [
+ "byteorder",
+ "fnv",
+ "uuid",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "cline-app"
+version = "0.1.0"
+dependencies = [
+ "rfd",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core-graphics"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation",
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cssparser"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae61cf9c0abb83bd659dab65b7e4e38d8236824c85f0f804f173567bda257d2"
+dependencies = [
+ "cssparser-macros",
+ "dtoa-short",
+ "itoa",
+ "phf",
+ "smallvec",
+]
+
+[[package]]
+name = "cssparser-macros"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ctor"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "352d39c2f7bef1d6ad73db6f5160efcaed66d94ef8c6c573a8410c00bf909a98"
+dependencies = [
+ "ctor-proc-macro",
+ "dtor",
+]
+
+[[package]]
+name = "ctor-proc-macro"
+version = "0.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
+
+[[package]]
+name = "darling"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dbus"
+version = "0.9.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b942602992bb7acfd1f51c49811c58a610ef9181b6e66f3e519d79b540a3bf73"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dlib"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "dlopen2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
+dependencies = [
+ "dlopen2_derive",
+ "libc",
+ "once_cell",
+ "winapi",
+]
+
+[[package]]
+name = "dlopen2_derive"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dom_query"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521e380c0c8afb8d9a1e83a1822ee03556fc3e3e7dbc1fd30be14e37f9cb3f89"
+dependencies = [
+ "bit-set",
+ "cssparser",
+ "foldhash 0.2.0",
+ "html5ever",
+ "precomputed-hash",
+ "selectors",
+ "tendril",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "dpi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dtoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
+
+[[package]]
+name = "dtoa-short"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
+dependencies = [
+ "dtoa",
+]
+
+[[package]]
+name = "dtor"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1057d6c64987086ff8ed0fd3fbf377a6b7d205cc7715868cd401705f715cbe4"
+dependencies = [
+ "dtor-proc-macro",
+]
+
+[[package]]
+name = "dtor-proc-macro"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "embed-resource"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55a075fc573c64510038d7ee9abc7990635863992f83ebc52c8b433b8411a02e"
+dependencies = [
+ "cc",
+ "memchr",
+ "rustc_version",
+ "toml 0.9.12+spec-1.1.0",
+ "vswhom",
+ "winreg",
+]
+
+[[package]]
+name = "embed_plist"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
+
+[[package]]
+name = "endi"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
+
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+ "serde",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "erased-serde"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e8918065695684b2b0702da20382d5ae6065cf3327bc2d6436bd49a71ce9f3"
+dependencies = [
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "field-offset"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+dependencies = [
+ "memoffset",
+ "rustc_version",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "gdk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
+dependencies = [
+ "cairo-rs",
+ "gdk-pixbuf",
+ "gdk-sys",
+ "gio",
+ "glib",
+ "libc",
+ "pango",
+]
+
+[[package]]
+name = "gdk-pixbuf"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
+dependencies = [
+ "gdk-pixbuf-sys",
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "gdk-pixbuf-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gdk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
+dependencies = [
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkwayland-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkx11"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe"
+dependencies = [
+ "gdk",
+ "gdkx11-sys",
+ "gio",
+ "glib",
+ "libc",
+ "x11",
+]
+
+[[package]]
+name = "gdkx11-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "libc",
+ "system-deps",
+ "x11",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "gio"
+version = "0.18.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "gio-sys",
+ "glib",
+ "libc",
+ "once_cell",
+ "pin-project-lite",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "gio-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+ "winapi",
+]
+
+[[package]]
+name = "glib"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5"
+dependencies = [
+ "bitflags 2.11.0",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-task",
+ "futures-util",
+ "gio-sys",
+ "glib-macros",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "memchr",
+ "once_cell",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "glib-macros"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro-crate 2.0.2",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "glib-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "gobject-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a"
+dependencies = [
+ "atk",
+ "cairo-rs",
+ "field-offset",
+ "futures-channel",
+ "gdk",
+ "gdk-pixbuf",
+ "gio",
+ "glib",
+ "gtk-sys",
+ "gtk3-macros",
+ "libc",
+ "pango",
+ "pkg-config",
+]
+
+[[package]]
+name = "gtk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414"
+dependencies = [
+ "atk-sys",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk3-macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d"
+dependencies = [
+ "proc-macro-crate 1.3.1",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "html5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1054432bae2f14e0061e33d23402fbaa67a921d319d56adc6bcf887ddad1cbc2"
+dependencies = [
+ "log",
+ "markup5ever",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hyper"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "http",
+ "http-body",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "pin-utils",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ico"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
+dependencies = [
+ "byteorder",
+ "png 0.17.16",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "infer"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7"
+dependencies = [
+ "cfb",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "iri-string"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "javascriptcore-rs"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc"
+dependencies = [
+ "bitflags 1.3.2",
+ "glib",
+ "javascriptcore-rs-sys",
+]
+
+[[package]]
+name = "javascriptcore-rs-sys"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "js-sys"
+version = "0.3.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dc6f6450b3f6d4ed5b16327f38fed626d375a886159ca555bd7822c0c3a5a6"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863726d7afb6bc2590eeff7135d923545e5e964f004c2ccf8716c25e70a86f08"
+dependencies = [
+ "jsonptr",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "jsonptr"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dea2b27dd239b2556ed7a25ba842fe47fd602e7fc7433c2a8d6106d4d9edd70"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "keyboard-types"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a"
+dependencies = [
+ "bitflags 2.11.0",
+ "serde",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libappindicator"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a"
+dependencies = [
+ "glib",
+ "gtk",
+ "gtk-sys",
+ "libappindicator-sys",
+ "log",
+]
+
+[[package]]
+name = "libappindicator-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf"
+dependencies = [
+ "gtk-sys",
+ "libloading",
+ "once_cell",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "libdbus-sys"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
+dependencies = [
+ "bitflags 2.11.0",
+ "libc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "markup5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
+dependencies = [
+ "log",
+ "tendril",
+ "web_atoms",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "muda"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae8844f63b5b118e334e205585b8c5c17b984121dbdb179d44aeb087ffad3cb"
+dependencies = [
+ "crossbeam-channel",
+ "dpi",
+ "gtk",
+ "keyboard-types",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ndk"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
+dependencies = [
+ "bitflags 2.11.0",
+ "jni-sys",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ndk-sys"
+version = "0.6.0+11769913"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
+dependencies = [
+ "jni-sys",
+]
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
+name = "num-conv"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+dependencies = [
+ "proc-macro-crate 3.4.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+ "objc2-exception-helper",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-cloud-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.0",
+ "dispatch2",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.11.0",
+ "dispatch2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-location"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-exception-helper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-ui-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-location",
+ "objc2-core-text",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "objc2-user-notifications",
+]
+
+[[package]]
+name = "objc2-user-notifications"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-web-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "ordered-stream"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "pango"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4"
+dependencies = [
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+ "pango-sys",
+]
+
+[[package]]
+name = "pango-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+ "serde",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "plist"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07"
+dependencies = [
+ "base64 0.22.1",
+ "indexmap 2.13.0",
+ "quick-xml 0.38.4",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.0",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "pollster"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+dependencies = [
+ "once_cell",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24"
+dependencies = [
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+dependencies = [
+ "toml_edit 0.23.10+spec-1.0.0",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.39.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958f21e8e7ceb5a1aa7fa87fab28e7c75976e0bfe7e23ff069e0a260f894067d"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+]
+
+[[package]]
+name = "rfd"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef2bee61e6cffa4635c72d7d81a84294e28f0930db0ddcb0f66d10244674ebed"
+dependencies = [
+ "ashpd",
+ "block2",
+ "dispatch2",
+ "js-sys",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "pollster",
+ "raw-window-handle",
+ "urlencoding",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.11.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
+dependencies = [
+ "dyn-clone",
+ "indexmap 1.9.3",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "selectors"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
+dependencies = [
+ "bitflags 2.11.0",
+ "cssparser",
+ "derive_more",
+ "log",
+ "new_debug_unreachable",
+ "phf",
+ "phf_codegen",
+ "precomputed-hash",
+ "rustc-hash",
+ "servo_arc",
+ "smallvec",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-untagged"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.13.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serialize-to-javascript"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5"
+dependencies = [
+ "serde",
+ "serde_json",
+ "serialize-to-javascript-impl",
+]
+
+[[package]]
+name = "serialize-to-javascript-impl"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "servo_arc"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "170fb83ab34de17dc69aa7c67482b22218ddb85da56546f9bd6b929e32a05930"
+dependencies = [
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+
+[[package]]
+name = "siphasher"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "softbuffer"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3"
+dependencies = [
+ "bytemuck",
+ "js-sys",
+ "ndk",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "raw-window-handle",
+ "redox_syscall",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "soup3"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f"
+dependencies = [
+ "futures-channel",
+ "gio",
+ "glib",
+ "libc",
+ "soup3-sys",
+]
+
+[[package]]
+name = "soup3-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "string_cache"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901"
+dependencies = [
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared",
+ "precomputed-hash",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "swift-rs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057c98e2e852d51fdcfca832aac7b571f6b351ad159f9eda5db1655f8d0c4d7"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml 0.8.2",
+ "version-compare",
+]
+
+[[package]]
+name = "tao"
+version = "0.35.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33f7f9e486ade65fcf1e45c440f9236c904f5c1002cdc7fc6ae582777345ce4"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "core-foundation",
+ "core-graphics",
+ "crossbeam-channel",
+ "dbus",
+ "dispatch2",
+ "dlopen2",
+ "dpi",
+ "gdkwayland-sys",
+ "gdkx11-sys",
+ "gtk",
+ "jni",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-sys",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "once_cell",
+ "parking_lot",
+ "percent-encoding",
+ "raw-window-handle",
+ "tao-macros",
+ "unicode-segmentation",
+ "url",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "tao-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tauri"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93bd86d231f0a8138f11a02a584769fe4b703dc36ae133d783228dbc4801405"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "cookie",
+ "dirs",
+ "dunce",
+ "embed_plist",
+ "getrandom 0.3.4",
+ "glob",
+ "gtk",
+ "heck 0.5.0",
+ "http",
+ "jni",
+ "libc",
+ "log",
+ "mime",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "percent-encoding",
+ "plist",
+ "raw-window-handle",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "serialize-to-javascript",
+ "swift-rs",
+ "tauri-build",
+ "tauri-macros",
+ "tauri-runtime",
+ "tauri-runtime-wry",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tokio",
+ "tray-icon",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "window-vibrancy",
+ "windows",
+]
+
+[[package]]
+name = "tauri-build"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a318b234cc2dea65f575467bafcfb76286bce228ebc3778e337d61d03213007"
+dependencies = [
+ "anyhow",
+ "cargo_toml",
+ "dirs",
+ "glob",
+ "heck 0.5.0",
+ "json-patch",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "tauri-winres",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-codegen"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd11644962add2549a60b7e7c6800f17d7020156e02f516021d8103e80cc528"
+dependencies = [
+ "base64 0.22.1",
+ "brotli",
+ "ico",
+ "json-patch",
+ "plist",
+ "png 0.17.16",
+ "proc-macro2",
+ "quote",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2",
+ "syn 2.0.117",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-macros"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed9d3742a37a355d2e47c9af924e9fbc112abb76f9835d35d4780e318419502"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "tauri-codegen",
+ "tauri-utils",
+]
+
+[[package]]
+name = "tauri-runtime"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fef478ba1d2ac21c2d528740b24d0cb315e1e8b1111aae53fafac34804371fc"
+dependencies = [
+ "cookie",
+ "dpi",
+ "gtk",
+ "http",
+ "jni",
+ "objc2",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "raw-window-handle",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows",
+]
+
+[[package]]
+name = "tauri-runtime-wry"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3989df2ae1c476404fe0a2e8ffc4cfbde97e51efd613c2bb5355fbc9ab52cf0"
+dependencies = [
+ "gtk",
+ "http",
+ "jni",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "softbuffer",
+ "tao",
+ "tauri-runtime",
+ "tauri-utils",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows",
+ "wry",
+]
+
+[[package]]
+name = "tauri-utils"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d57200389a2f82b4b0a40ae29ca19b6978116e8f4d4e974c3234ce40c0ffbdec"
+dependencies = [
+ "anyhow",
+ "brotli",
+ "cargo_metadata",
+ "ctor",
+ "dom_query",
+ "dunce",
+ "glob",
+ "http",
+ "infer",
+ "json-patch",
+ "log",
+ "memchr",
+ "phf",
+ "plist",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde_json",
+ "serde_with",
+ "swift-rs",
+ "thiserror 2.0.18",
+ "toml 0.9.12+spec-1.1.0",
+ "url",
+ "urlpattern",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-winres"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1087b111fe2b005e42dbdc1990fc18593234238d47453b0c99b7de1c9ab2c1e0"
+dependencies = [
+ "dunce",
+ "embed-resource",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.1",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tendril"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4790fc369d5a530f4b544b094e31388b9b3a37c0f4652ade4505945f5660d24"
+dependencies = [
+ "new_debug_unreachable",
+ "utf-8",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.49.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "socket2",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
+dependencies = [
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "indexmap 2.13.0",
+ "serde_core",
+ "serde_spanned 1.0.4",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.14",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.13.0",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
+dependencies = [
+ "indexmap 2.13.0",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.10+spec-1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
+dependencies = [
+ "indexmap 2.13.0",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "winnow 0.7.14",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.9+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+dependencies = [
+ "winnow 0.7.14",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags 2.11.0",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tray-icon"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15edbb0d80583e85ee8df283410038e17314df5cba30da2087a54a85216c0773"
+dependencies = [
+ "crossbeam-channel",
+ "dirs",
+ "libappindicator",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "uds_windows"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
+dependencies = [
+ "memoffset",
+ "tempfile",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "unic-char-property"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+dependencies = [
+ "unic-char-range",
+]
+
+[[package]]
+name = "unic-char-range"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+
+[[package]]
+name = "unic-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+
+[[package]]
+name = "unic-ucd-ident"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e230a37c0381caa9219d67cf063aa3a375ffed5bf541a452db16e744bdab6987"
+dependencies = [
+ "unic-char-property",
+ "unic-char-range",
+ "unic-ucd-version",
+]
+
+[[package]]
+name = "unic-ucd-version"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+dependencies = [
+ "unic-common",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "urlpattern"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70acd30e3aa1450bc2eece896ce2ad0d178e9c079493819301573dae3c37ba6d"
+dependencies = [
+ "regex",
+ "serde",
+ "unic-ucd-ident",
+ "url",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+dependencies = [
+ "getrandom 0.4.1",
+ "js-sys",
+ "serde_core",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version-compare"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vswhom"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b"
+dependencies = [
+ "libc",
+ "vswhom-sys",
+]
+
+[[package]]
+name = "vswhom-sys"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60722a937f594b7fde9adb894d7c092fc1bb6612897c46368d18e7a20208eff2"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a89f4650b770e4521aa6573724e2aed4704372151bd0de9d16a3bbabb87441a"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac8c6395094b6b91c4af293f4c79371c163f9a6f56184d2c9a85f5a95f3950"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3fabce6159dc20728033842636887e4877688ae94382766e00b180abac9d60"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de0e091bdb824da87dc01d967388880d017a0a9bc4f3bdc0d86ee9f9336e3bb5"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.13.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.0",
+ "hashbrown 0.15.5",
+ "indexmap 2.13.0",
+ "semver",
+]
+
+[[package]]
+name = "wayland-backend"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa75f400b7f719bcd68b3f47cd939ba654cedeef690f486db71331eec4c6a406"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix",
+ "scoped-tls",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab51d9f7c071abeee76007e2b742499e535148035bb835f97aaed1338cf516c3"
+dependencies = [
+ "bitflags 2.11.0",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b23b5df31ceff1328f06ac607591d5ba360cf58f90c8fad4ac8d3a55a3c4aec7"
+dependencies = [
+ "bitflags 2.11.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c86287151a309799b821ca709b7345a048a2956af05957c89cb824ab919fa4e3"
+dependencies = [
+ "proc-macro2",
+ "quick-xml 0.39.2",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374f6b70e8e0d6bf9461a32988fd553b59ff630964924dad6e4a4eb6bd538d17"
+dependencies = [
+ "dlib",
+ "log",
+ "pkg-config",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "705eceb4ce901230f8625bd1d665128056ccbe4b7408faa625eec1ba80f59a97"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web_atoms"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7cff6eef815df1834fd250e3a2ff436044d82a9f1bc1980ca1dbdf07effc538"
+dependencies = [
+ "phf",
+ "phf_codegen",
+ "string_cache",
+ "string_cache_codegen",
+]
+
+[[package]]
+name = "webkit2gtk"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-rs",
+ "gdk",
+ "gdk-sys",
+ "gio",
+ "gio-sys",
+ "glib",
+ "glib-sys",
+ "gobject-sys",
+ "gtk",
+ "gtk-sys",
+ "javascriptcore-rs",
+ "libc",
+ "once_cell",
+ "soup3",
+ "webkit2gtk-sys",
+]
+
+[[package]]
+name = "webkit2gtk-sys"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-sys-rs",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "javascriptcore-rs-sys",
+ "libc",
+ "pkg-config",
+ "soup3-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "webview2-com"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
+dependencies = [
+ "webview2-com-macros",
+ "webview2-com-sys",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-implement",
+ "windows-interface",
+]
+
+[[package]]
+name = "webview2-com-macros"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "webview2-com-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
+dependencies = [
+ "thiserror 2.0.18",
+ "windows",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "window-vibrancy"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9bec5a31f3f9362f2258fd0e9c9dd61a9ca432e7306cc78c444258f0dce9a9c"
+dependencies = [
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "windows-sys 0.59.0",
+ "windows-version",
+]
+
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core 0.61.2",
+ "windows-future",
+ "windows-link 0.1.3",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-version"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.13.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.0",
+ "indexmap 2.13.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.13.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "wry"
+version = "0.55.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186f9871daa55fd9c016578b810d149de58367113db7fb72b462d2323ce19514"
+dependencies = [
+ "base64 0.22.1",
+ "block2",
+ "cookie",
+ "crossbeam-channel",
+ "dirs",
+ "dom_query",
+ "dpi",
+ "dunce",
+ "gdkx11",
+ "gtk",
+ "http",
+ "javascriptcore-rs",
+ "jni",
+ "libc",
+ "ndk",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "sha2",
+ "soup3",
+ "tao-macros",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webkit2gtk-sys",
+ "webview2-com",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "x11"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zbus"
+version = "5.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca82f95dbd3943a40a53cfded6c2d0a2ca26192011846a1810c4256ef92c60bc"
+dependencies = [
+ "async-broadcast",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "async-process",
+ "async-recursion",
+ "async-task",
+ "async-trait",
+ "blocking",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-lite",
+ "hex",
+ "libc",
+ "ordered-stream",
+ "rustix",
+ "serde",
+ "serde_repr",
+ "tracing",
+ "uds_windows",
+ "uuid",
+ "windows-sys 0.61.2",
+ "winnow 0.7.14",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "5.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897e79616e84aac4b2c46e9132a4f63b93105d54fe8c0e8f6bffc21fa8d49222"
+dependencies = [
+ "proc-macro-crate 3.4.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zbus_names",
+ "zvariant",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zbus_names"
+version = "4.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f"
+dependencies = [
+ "serde",
+ "winnow 0.7.14",
+ "zvariant",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zvariant"
+version = "5.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5708299b21903bbe348e94729f22c49c55d04720a004aa350f1f9c122fd2540b"
+dependencies = [
+ "endi",
+ "enumflags2",
+ "serde",
+ "url",
+ "winnow 0.7.14",
+ "zvariant_derive",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "5.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b59b012ebe9c46656f9cc08d8da8b4c726510aef12559da3e5f1bf72780752c"
+dependencies = [
+ "proc-macro-crate 3.4.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_utils"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.117",
+ "winnow 0.7.14",
+]
diff --git a/apps/examples/desktop-app/src-tauri/Cargo.toml b/apps/examples/desktop-app/src-tauri/Cargo.toml
new file mode 100644
index 0000000..ee3168d
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "cline-app"
+version = "0.1.0"
+edition = "2021"
+
+[build-dependencies]
+tauri-build = { version = "2.0.0", features = [] }
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tauri = { version = "2.11.1", features = [] }
+rfd = "0.15"
+
+[features]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]
diff --git a/apps/examples/desktop-app/src-tauri/build.rs b/apps/examples/desktop-app/src-tauri/build.rs
new file mode 100644
index 0000000..d860e1e
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}
diff --git a/apps/examples/desktop-app/src-tauri/entitlements.plist b/apps/examples/desktop-app/src-tauri/entitlements.plist
new file mode 100644
index 0000000..327636b
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/entitlements.plist
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<!-- Bun/JavaScriptCore requires JIT + shared executable memory under the hardened runtime -->
+	<key>com.apple.security.cs.allow-jit</key>
+	<true/>
+	<key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+	<true/>
+	<key>com.apple.security.cs.disable-library-validation</key>
+	<true/>
+</dict>
+</plist>
diff --git a/apps/examples/desktop-app/src-tauri/icons/128x128.png b/apps/examples/desktop-app/src-tauri/icons/128x128.png
new file mode 100644
index 0000000..6c1fedb
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/128x128.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/128x128@2x.png b/apps/examples/desktop-app/src-tauri/icons/128x128@2x.png
new file mode 100644
index 0000000..9918d3e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/128x128@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/32x32.png b/apps/examples/desktop-app/src-tauri/icons/32x32.png
new file mode 100644
index 0000000..40cfd21
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/32x32.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/64x64.png b/apps/examples/desktop-app/src-tauri/icons/64x64.png
new file mode 100644
index 0000000..e72ee52
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/64x64.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square107x107Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square107x107Logo.png
new file mode 100644
index 0000000..f424931
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square107x107Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square142x142Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square142x142Logo.png
new file mode 100644
index 0000000..7feb46d
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square142x142Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square150x150Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square150x150Logo.png
new file mode 100644
index 0000000..87e9660
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square150x150Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square284x284Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square284x284Logo.png
new file mode 100644
index 0000000..b362692
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square284x284Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square30x30Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square30x30Logo.png
new file mode 100644
index 0000000..d315fb5
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square30x30Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square310x310Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square310x310Logo.png
new file mode 100644
index 0000000..aac2db1
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square310x310Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square44x44Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square44x44Logo.png
new file mode 100644
index 0000000..edae92f
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square44x44Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square71x71Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square71x71Logo.png
new file mode 100644
index 0000000..625772a
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square71x71Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/Square89x89Logo.png b/apps/examples/desktop-app/src-tauri/icons/Square89x89Logo.png
new file mode 100644
index 0000000..0039537
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/Square89x89Logo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/StoreLogo.png b/apps/examples/desktop-app/src-tauri/icons/StoreLogo.png
new file mode 100644
index 0000000..bce6784
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/StoreLogo.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml
new file mode 100644
index 0000000..2ffbf24
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <background android:drawable="@color/ic_launcher_background"/>
+</adaptive-icon>
\ No newline at end of file
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000..7d3abd6
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher_foreground.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..359101f
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher_round.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher_round.png
new file mode 100644
index 0000000..a4067b1
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-hdpi/ic_launcher_round.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000..e80688a
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher_foreground.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..28ffc5e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher_round.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher_round.png
new file mode 100644
index 0000000..5a99fa6
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-mdpi/ic_launcher_round.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..1e659bd
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_foreground.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..293bdc2
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_round.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..a7f4a1e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_round.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..4277dc7
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..279e480
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_round.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..15869d6
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_round.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000..2651698
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..ce1ff92
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_round.png b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..d45bca0
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_round.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/android/values/ic_launcher_background.xml b/apps/examples/desktop-app/src-tauri/icons/android/values/ic_launcher_background.xml
new file mode 100644
index 0000000..ea9c223
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/icons/android/values/ic_launcher_background.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="ic_launcher_background">#fff</color>
+</resources>
\ No newline at end of file
diff --git a/apps/examples/desktop-app/src-tauri/icons/icon.icns b/apps/examples/desktop-app/src-tauri/icons/icon.icns
new file mode 100644
index 0000000..6fe189e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/icon.icns differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/icon.ico b/apps/examples/desktop-app/src-tauri/icons/icon.ico
new file mode 100644
index 0000000..ea0e465
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/icon.ico differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/icon.png b/apps/examples/desktop-app/src-tauri/icons/icon.png
new file mode 100644
index 0000000..f7bc15f
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/icon.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@1x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@1x.png
new file mode 100644
index 0000000..1cd8007
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@1x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@2x-1.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@2x-1.png
new file mode 100644
index 0000000..c7fdf3e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@2x-1.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@2x.png
new file mode 100644
index 0000000..c7fdf3e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@3x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@3x.png
new file mode 100644
index 0000000..17cfed0
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-20x20@3x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@1x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@1x.png
new file mode 100644
index 0000000..5ce3f70
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@1x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@2x-1.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@2x-1.png
new file mode 100644
index 0000000..2916f39
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@2x-1.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@2x.png
new file mode 100644
index 0000000..2916f39
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@3x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@3x.png
new file mode 100644
index 0000000..63f0115
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-29x29@3x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@1x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@1x.png
new file mode 100644
index 0000000..c7fdf3e
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@1x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@2x-1.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@2x-1.png
new file mode 100644
index 0000000..27b8f20
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@2x-1.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@2x.png
new file mode 100644
index 0000000..27b8f20
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@3x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@3x.png
new file mode 100644
index 0000000..3f1758b
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-40x40@3x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-512@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-512@2x.png
new file mode 100644
index 0000000..1f27085
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-512@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-60x60@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-60x60@2x.png
new file mode 100644
index 0000000..3f1758b
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-60x60@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-60x60@3x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-60x60@3x.png
new file mode 100644
index 0000000..5c8824b
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-60x60@3x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-76x76@1x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-76x76@1x.png
new file mode 100644
index 0000000..d51a686
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-76x76@1x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-76x76@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-76x76@2x.png
new file mode 100644
index 0000000..3c05746
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-76x76@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-83.5x83.5@2x.png b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-83.5x83.5@2x.png
new file mode 100644
index 0000000..da04f4d
Binary files /dev/null and b/apps/examples/desktop-app/src-tauri/icons/ios/AppIcon-83.5x83.5@2x.png differ
diff --git a/apps/examples/desktop-app/src-tauri/src/main.rs b/apps/examples/desktop-app/src-tauri/src/main.rs
new file mode 100644
index 0000000..40afdb6
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/src/main.rs
@@ -0,0 +1,523 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread;
+use std::time::Duration;
+use tauri::{Manager, RunEvent, State};
+
+#[derive(Clone)]
+struct AppContext {
+    launch_cwd: String,
+    workspace_root: String,
+}
+
+#[derive(Default)]
+struct DesktopBackendState {
+    ws_endpoint: Mutex<Option<String>>,
+    process: Mutex<Option<Child>>,
+    shutting_down: Mutex<bool>,
+}
+
+impl DesktopBackendState {
+    fn is_shutting_down(&self) -> bool {
+        self.shutting_down
+            .lock()
+            .map(|guard| *guard)
+            .unwrap_or(true)
+    }
+
+    fn stop(&self) {
+        if let Ok(mut guard) = self.shutting_down.lock() {
+            *guard = true;
+        }
+
+        if let Ok(endpoint_guard) = self.ws_endpoint.lock() {
+            if let Some(endpoint) = endpoint_guard.as_ref() {
+                request_desktop_backend_shutdown(endpoint);
+            }
+        }
+
+        if let Ok(mut process_guard) = self.process.lock() {
+            if let Some(child) = process_guard.as_mut() {
+                for _ in 0..30 {
+                    match child.try_wait() {
+                        Ok(Some(_)) => break,
+                        Ok(None) => thread::sleep(Duration::from_millis(100)),
+                        Err(_) => break,
+                    }
+                }
+                match child.try_wait() {
+                    Ok(Some(_)) => {}
+                    Ok(None) => {
+                        let _ = child.kill();
+                        let _ = child.wait();
+                    }
+                    Err(_) => {
+                        let _ = child.kill();
+                        let _ = child.wait();
+                    }
+                }
+            }
+            *process_guard = None;
+        }
+
+        if let Ok(mut endpoint_guard) = self.ws_endpoint.lock() {
+            *endpoint_guard = None;
+        }
+    }
+}
+
+impl Drop for DesktopBackendState {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DesktopBackendReadyLine {
+    #[serde(rename = "type")]
+    line_type: String,
+    endpoint: Option<String>,
+    ws_endpoint: Option<String>,
+    pid: Option<u64>,
+    mode: Option<String>,
+}
+
+fn resolve_workspace_root(launch_cwd: &str) -> String {
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(launch_cwd)
+        .arg("rev-parse")
+        .arg("--show-toplevel")
+        .output();
+
+    match output {
+        Ok(result) if result.status.success() => {
+            let value = String::from_utf8_lossy(&result.stdout).trim().to_string();
+            if value.is_empty() {
+                launch_cwd.to_string()
+            } else {
+                value
+            }
+        }
+        _ => launch_cwd.to_string(),
+    }
+}
+
+fn request_desktop_backend_shutdown(endpoint: &str) {
+    let trimmed = endpoint.trim();
+    if trimmed.is_empty() {
+        return;
+    }
+    let base = trimmed.strip_suffix('/').unwrap_or(trimmed);
+    let url = format!("{base}/shutdown");
+    let timeout_seconds = "2";
+
+    #[cfg(target_os = "windows")]
+    {
+        let _ = Command::new("powershell")
+            .args([
+                "-NoProfile",
+                "-Command",
+                &format!(
+                    "try {{ Invoke-WebRequest -UseBasicParsing -Method Post -Uri '{}' -TimeoutSec {} | Out-Null }} catch {{ }}",
+                    url.replace('\'', "''"),
+                    timeout_seconds
+                ),
+            ])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let _ = Command::new("curl")
+            .args([
+                "-fsS",
+                "--connect-timeout",
+                timeout_seconds,
+                "--max-time",
+                timeout_seconds,
+                "-X",
+                "POST",
+                &url,
+            ])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+    }
+}
+
+fn resolve_desktop_backend_script_path(context: &AppContext) -> Option<PathBuf> {
+    let launch_cwd = PathBuf::from(&context.launch_cwd);
+    let candidates = [
+        PathBuf::from(&context.workspace_root)
+            .join("apps")
+            .join("examples")
+            .join("desktop-app")
+            .join("sidecar")
+            .join("index.ts"),
+        launch_cwd.join("sidecar").join("index.ts"),
+        launch_cwd
+            .parent()
+            .map(|parent| parent.join("sidecar").join("index.ts"))
+            .unwrap_or_else(|| PathBuf::from("")),
+        launch_cwd
+            .join("apps")
+            .join("examples")
+            .join("desktop-app")
+            .join("sidecar")
+            .join("index.ts"),
+    ];
+    candidates.into_iter().find(|path| path.exists())
+}
+
+fn desktop_backend_binary_names() -> Vec<String> {
+    let extension = if cfg!(windows) { ".exe" } else { "" };
+    let bundled_name = format!("code-sidecar{extension}");
+    let target_triple = option_env!("TAURI_ENV_TARGET_TRIPLE").unwrap_or("").trim();
+    if target_triple.is_empty() {
+        return vec![bundled_name];
+    }
+
+    vec![
+        bundled_name,
+        format!("code-sidecar-{target_triple}{extension}"),
+    ]
+}
+
+fn resolve_desktop_backend_binary_path(context: &AppContext) -> Option<PathBuf> {
+    if cfg!(debug_assertions) {
+        return None;
+    }
+    let explicit = std::env::var("CLINE_CODE_SIDECAR_BIN")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .map(PathBuf::from);
+    let current_exe = std::env::current_exe().ok();
+    let mut candidates = Vec::new();
+    if let Some(path) = explicit {
+        candidates.push(path);
+    }
+
+    for binary_name in desktop_backend_binary_names() {
+        candidates.push(
+            PathBuf::from(&context.workspace_root)
+                .join("apps")
+                .join("examples")
+                .join("desktop-app")
+                .join("src-tauri")
+                .join("bin")
+                .join(&binary_name),
+        );
+        if let Some(path) = current_exe
+            .as_ref()
+            .and_then(|path| path.parent().map(|parent| parent.join(&binary_name)))
+        {
+            candidates.push(path);
+        }
+        if let Some(path) = current_exe.as_ref().and_then(|path| {
+            path.parent()
+                .and_then(|parent| parent.parent())
+                .map(|parent| parent.join("Resources").join(&binary_name))
+        }) {
+            candidates.push(path);
+        }
+    }
+
+    candidates.into_iter().find(|path| path.exists())
+}
+
+fn ensure_desktop_backend_started(
+    state: &Arc<DesktopBackendState>,
+    context: &AppContext,
+) -> Result<(), String> {
+    if state.is_shutting_down() {
+        return Ok(());
+    }
+
+    {
+        let mut process_guard = state
+            .process
+            .lock()
+            .map_err(|_| "failed to lock desktop backend process state")?;
+        if let Some(existing) = process_guard.as_mut() {
+            match existing.try_wait() {
+                Ok(None) => {
+                    if state
+                        .ws_endpoint
+                        .lock()
+                        .ok()
+                        .and_then(|value| value.as_ref().cloned())
+                        .map(|value| !value.trim().is_empty())
+                        .unwrap_or(false)
+                    {
+                        return Ok(());
+                    }
+                }
+                Ok(Some(_)) | Err(_) => {
+                    *process_guard = None;
+                    if let Ok(mut endpoint_guard) = state.ws_endpoint.lock() {
+                        *endpoint_guard = None;
+                    }
+                }
+            }
+        }
+    }
+
+    let mut command = if let Some(binary_path) = resolve_desktop_backend_binary_path(context) {
+        let mut command = Command::new(binary_path);
+        command.current_dir(&context.workspace_root);
+        command
+    } else if let Some(script_path) = resolve_desktop_backend_script_path(context) {
+        let mut command = Command::new("bun");
+        command
+            .arg("run")
+            .arg(script_path.to_string_lossy().to_string())
+            .current_dir(&context.workspace_root);
+        command
+    } else {
+        return Err(format!(
+            "desktop backend sidecar not found. checked binary/script under workspace_root={} and launch_cwd={}",
+            context.workspace_root, context.launch_cwd
+        ));
+    };
+
+    let mut child = command
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("failed to start desktop backend sidecar: {e}"))?;
+
+    let stdout = child
+        .stdout
+        .take()
+        .ok_or_else(|| "failed to capture desktop backend stdout".to_string())?;
+    let stderr = child
+        .stderr
+        .take()
+        .ok_or_else(|| "failed to capture desktop backend stderr".to_string())?;
+
+    let state_for_stdout = state.clone();
+    thread::spawn(move || {
+        let mut reader = BufReader::new(stdout);
+        let mut line = String::new();
+        loop {
+            line.clear();
+            let Ok(bytes) = reader.read_line(&mut line) else {
+                break;
+            };
+            if bytes == 0 {
+                break;
+            }
+            let trimmed = line.trim();
+            if trimmed.is_empty() {
+                continue;
+            }
+            if let Ok(parsed) = serde_json::from_str::<DesktopBackendReadyLine>(trimmed) {
+                if parsed.line_type == "ready" {
+                    if let Some(endpoint) = parsed.ws_endpoint.or(parsed.endpoint) {
+                        if let Ok(mut endpoint_guard) = state_for_stdout.ws_endpoint.lock() {
+                            *endpoint_guard = Some(endpoint);
+                        }
+                    }
+                    continue;
+                }
+            }
+            eprintln!("[desktop-backend] {trimmed}");
+        }
+        if let Ok(mut endpoint_guard) = state_for_stdout.ws_endpoint.lock() {
+            *endpoint_guard = None;
+        }
+    });
+
+    thread::spawn(move || {
+        let reader = BufReader::new(stderr);
+        for line in reader.lines() {
+            match line {
+                Ok(text) if !text.trim().is_empty() => {
+                    eprintln!("[desktop-backend:err] {}", text.trim());
+                }
+                _ => {}
+            }
+        }
+    });
+
+    let mut process_guard = state
+        .process
+        .lock()
+        .map_err(|_| "failed to lock desktop backend process state")?;
+    *process_guard = Some(child);
+    Ok(())
+}
+
+fn resolve_mcp_settings_path() -> Result<PathBuf, String> {
+    if let Ok(value) = std::env::var("CLINE_MCP_SETTINGS_PATH") {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() {
+            return Ok(PathBuf::from(trimmed));
+        }
+    }
+    let home = std::env::var("HOME").map_err(|_| "HOME is not set".to_string())?;
+    Ok(PathBuf::from(home)
+        .join(".cline")
+        .join("data")
+        .join("settings")
+        .join("cline_mcp_settings.json"))
+}
+
+fn open_path_with_default_app(path: &Path) -> Result<(), String> {
+    #[cfg(target_os = "macos")]
+    {
+        let status = Command::new("open")
+            .arg(path)
+            .status()
+            .map_err(|e| format!("failed to open path: {e}"))?;
+        if status.success() {
+            return Ok(());
+        }
+        return Err(format!("open command exited with status {status}"));
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        let path_arg = path.to_string_lossy().to_string();
+        let status = Command::new("cmd")
+            .args(["/C", "start", "", &path_arg])
+            .status()
+            .map_err(|e| format!("failed to open path: {e}"))?;
+        if status.success() {
+            return Ok(());
+        }
+        return Err(format!("start command exited with status {status}"));
+    }
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    {
+        let status = Command::new("xdg-open")
+            .arg(path)
+            .status()
+            .map_err(|e| format!("failed to open path: {e}"))?;
+        if status.success() {
+            return Ok(());
+        }
+        return Err(format!("xdg-open command exited with status {status}"));
+    }
+
+    #[allow(unreachable_code)]
+    Err("opening files is not supported on this platform".to_string())
+}
+
+#[tauri::command]
+fn get_desktop_backend_endpoint(
+    backend_state: State<'_, Arc<DesktopBackendState>>,
+    context: State<'_, AppContext>,
+) -> Result<String, String> {
+    ensure_desktop_backend_started(backend_state.inner(), context.inner())?;
+    for _ in 0..50 {
+        if let Some(endpoint) = backend_state
+            .ws_endpoint
+            .lock()
+            .ok()
+            .and_then(|value| value.as_ref().cloned())
+            .filter(|value| !value.trim().is_empty())
+        {
+            return Ok(endpoint);
+        }
+        thread::sleep(Duration::from_millis(100));
+    }
+    Err("desktop backend endpoint not ready".to_string())
+}
+
+#[tauri::command]
+fn pick_workspace_directory(initial_path: Option<String>) -> Option<String> {
+    let mut dialog = rfd::FileDialog::new();
+    if let Some(path) = initial_path
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+    {
+        dialog = dialog.set_directory(path);
+    }
+    dialog
+        .pick_folder()
+        .map(|path| path.to_string_lossy().to_string())
+}
+
+#[tauri::command]
+fn open_mcp_settings_file() -> Result<String, String> {
+    let settings_path = resolve_mcp_settings_path()?;
+    if !settings_path.exists() {
+        if let Some(parent) = settings_path.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("failed creating MCP settings directory: {e}"))?;
+        }
+        let initial = serde_json::json!({
+            "mcpServers": {}
+        });
+        let mut body = serde_json::to_vec_pretty(&initial)
+            .map_err(|e| format!("failed encoding MCP settings: {e}"))?;
+        body.push(b'\n');
+        fs::write(&settings_path, body)
+            .map_err(|e| format!("failed writing MCP settings file: {e}"))?;
+    }
+    open_path_with_default_app(&settings_path)?;
+    Ok(settings_path.to_string_lossy().to_string())
+}
+
+fn main() {
+    let desktop_backend = Arc::new(DesktopBackendState::default());
+    let launch_cwd = std::env::current_dir()
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_else(|_| ".".to_string());
+    let workspace_root = resolve_workspace_root(&launch_cwd);
+    let app_context = AppContext {
+        launch_cwd,
+        workspace_root,
+    };
+
+    tauri::Builder::default()
+        .manage(desktop_backend)
+        .manage(app_context)
+        .setup(|app| {
+            let app_context = app.state::<AppContext>().inner().clone();
+            let backend_state = app.state::<Arc<DesktopBackendState>>().inner().clone();
+            if let Err(error) = ensure_desktop_backend_started(&backend_state, &app_context) {
+                eprintln!("[desktop-backend] startup failed: {error}");
+            }
+            thread::spawn(move || loop {
+                thread::sleep(Duration::from_secs(5));
+                if backend_state.is_shutting_down() {
+                    break;
+                }
+                if let Err(error) = ensure_desktop_backend_started(&backend_state, &app_context) {
+                    eprintln!("[desktop-backend] health check failed: {error}");
+                }
+            });
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            get_desktop_backend_endpoint,
+            pick_workspace_directory,
+            open_mcp_settings_file
+        ])
+        .build(tauri::generate_context!())
+        .expect("error while building tauri app")
+        .run(|app_handle, event| match event {
+            RunEvent::ExitRequested { .. } | RunEvent::Exit => {
+                app_handle
+                    .state::<Arc<DesktopBackendState>>()
+                    .inner()
+                    .stop();
+            }
+            _ => {}
+        });
+}
diff --git a/apps/examples/desktop-app/src-tauri/tauri.conf.json b/apps/examples/desktop-app/src-tauri/tauri.conf.json
new file mode 100644
index 0000000..4fa9783
--- /dev/null
+++ b/apps/examples/desktop-app/src-tauri/tauri.conf.json
@@ -0,0 +1,42 @@
+{
+	"$schema": "https://schema.tauri.app/config/2",
+	"productName": "Cline Code",
+	"version": "0.0.1",
+	"identifier": "bot.cline.app",
+	"build": {
+		"beforeDevCommand": "bun run build:sidecar:bin && bun run dev:web",
+		"devUrl": "http://localhost:3125",
+		"beforeBuildCommand": "bun run build",
+		"frontendDist": "../webview/out"
+	},
+	"app": {
+		"windows": [
+			{
+				"label": "main",
+				"title": "Cline Code",
+				"width": 1500,
+				"height": 980,
+				"resizable": true
+			}
+		],
+		"security": {
+			"csp": null
+		}
+	},
+	"bundle": {
+		"active": true,
+		"targets": "all",
+		"externalBin": ["bin/code-sidecar"],
+		"icon": [
+			"icons/32x32.png",
+			"icons/128x128.png",
+			"icons/128x128@2x.png",
+			"icons/icon.icns",
+			"icons/icon.ico"
+		],
+		"macOS": {
+			"entitlements": "entitlements.plist",
+			"hardenedRuntime": true
+		}
+	}
+}
diff --git a/apps/examples/desktop-app/tsconfig.dev.json b/apps/examples/desktop-app/tsconfig.dev.json
new file mode 100644
index 0000000..5d748b8
--- /dev/null
+++ b/apps/examples/desktop-app/tsconfig.dev.json
@@ -0,0 +1,23 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"paths": {
+			"@/*": ["./*"],
+			"@cline/agents": ["../../../sdk/packages/agents/src/index.ts"],
+			"@cline/core": ["../../../sdk/packages/core/src/index.ts"],
+			"@cline/core/hub": ["../../../sdk/packages/core/src/hub/index.ts"],
+			"@cline/llms": ["../../../sdk/packages/llms/src/index.ts"],
+			"@cline/shared": ["../../../sdk/packages/shared/src/index.ts"],
+			"@cline/shared/storage": [
+				"../../../sdk/packages/shared/src/storage/index.ts"
+			],
+			"@cline/shared/db": ["../../../sdk/packages/shared/src/db/index.ts"],
+			"@cline/shared/*": [
+				"../../../sdk/packages/shared/src/*",
+				"../../../sdk/packages/shared/src/*/index.ts"
+			]
+		}
+	},
+	"include": ["sidecar/**/*.ts", "scripts/**/*.ts", "global.d.ts", "bun.mts"],
+	"exclude": ["node_modules", "webview"]
+}
diff --git a/apps/examples/desktop-app/tsconfig.json b/apps/examples/desktop-app/tsconfig.json
new file mode 100644
index 0000000..518b99d
--- /dev/null
+++ b/apps/examples/desktop-app/tsconfig.json
@@ -0,0 +1,45 @@
+{
+	"compilerOptions": {
+		"lib": ["dom", "dom.iterable", "esnext"],
+		"allowJs": true,
+		"target": "ES6",
+		"skipLibCheck": true,
+		"strict": true,
+		"noEmit": true,
+		"esModuleInterop": true,
+		"module": "esnext",
+		"moduleResolution": "bundler",
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"jsx": "react-jsx",
+		"incremental": true,
+		"plugins": [
+			{
+				"name": "next"
+			}
+		],
+		"paths": {
+			"@/*": ["./*"],
+			"@cline/agents": ["../../../sdk/packages/agents/src/index.ts"],
+			"@cline/core": ["../../../sdk/packages/core/src/index.ts"],
+			"@cline/core/hub": ["../../../sdk/packages/core/src/hub/index.ts"],
+			"@cline/llms": ["../../../sdk/packages/llms/src/index.ts"],
+			"@cline/shared": ["../../../sdk/packages/shared/src/index.ts"],
+			"@cline/shared/storage": [
+				"../../../sdk/packages/shared/src/storage/index.ts"
+			],
+			"@cline/shared/db": ["../../../sdk/packages/shared/src/db/index.ts"],
+			"@cline/shared/*": [
+				"../../../sdk/packages/shared/src/*",
+				"../../../sdk/packages/shared/src/*/index.ts"
+			]
+		}
+	},
+	"include": [
+		"**/*.ts",
+		"**/*.tsx",
+		".next/types/**/*.ts",
+		".next/dev/types/**/*.ts"
+	],
+	"exclude": ["node_modules"]
+}
diff --git a/apps/examples/desktop-app/vitest.config.ts b/apps/examples/desktop-app/vitest.config.ts
new file mode 100644
index 0000000..e92f387
--- /dev/null
+++ b/apps/examples/desktop-app/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+	},
+});
diff --git a/apps/examples/desktop-app/webview/app/api/marketplace/catalog/route.ts b/apps/examples/desktop-app/webview/app/api/marketplace/catalog/route.ts
new file mode 100644
index 0000000..b4738e3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/app/api/marketplace/catalog/route.ts
@@ -0,0 +1,41 @@
+const MARKETPLACE_CATALOG_URL =
+	process.env.CLINE_MARKETPLACE_CATALOG_URL?.trim() ||
+	"https://cline.github.io/marketplace/catalog.json";
+
+export const dynamic = "force-static";
+
+const EMPTY_MARKETPLACE_CATALOG = {
+	version: 1,
+	counts: {
+		total: 0,
+		plugins: 0,
+		skills: 0,
+		mcps: 0,
+	},
+	tags: [],
+	entries: [],
+};
+
+export async function GET() {
+	try {
+		const response = await fetch(MARKETPLACE_CATALOG_URL, {
+			headers: { Accept: "application/json" },
+		});
+		if (!response.ok) {
+			return Response.json({
+				...EMPTY_MARKETPLACE_CATALOG,
+				error:
+					`Failed to fetch marketplace catalog: ${response.status} ${response.statusText}`.trim(),
+			});
+		}
+		return Response.json(await response.json());
+	} catch (error) {
+		return Response.json({
+			...EMPTY_MARKETPLACE_CATALOG,
+			error:
+				error instanceof Error
+					? error.message
+					: "Failed to fetch marketplace catalog",
+		});
+	}
+}
diff --git a/apps/examples/desktop-app/webview/app/globals.css b/apps/examples/desktop-app/webview/app/globals.css
new file mode 100644
index 0000000..ad064d3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/app/globals.css
@@ -0,0 +1,337 @@
+@import "@fontsource-variable/schibsted-grotesk";
+@import "@fontsource/azeret-mono/latin.css";
+@import "tailwindcss";
+@import "tw-animate-css";
+
+@custom-variant dark (&:is(.dark *));
+
+:root {
+	--font-desktop-sans: "Schibsted Grotesk Variable";
+	--font-desktop-mono: "Azeret Mono";
+	--background: oklch(1 0 0);
+	--foreground: oklch(0.145 0 0);
+	--card: oklch(1 0 0);
+	--card-foreground: oklch(0.145 0 0);
+	--popover: oklch(1 0 0);
+	--popover-foreground: oklch(0.145 0 0);
+	--primary: oklch(0.75 0.12 165);
+	--primary-foreground: oklch(0.962 0.018 272.314);
+	--secondary: oklch(0.97 0 0);
+	--secondary-foreground: oklch(0.205 0 0);
+	--muted: oklch(0.97 0 0);
+	--muted-foreground: oklch(0.556 0 0);
+	--accent: oklch(0.97 0 0);
+	--accent-foreground: oklch(0.205 0 0);
+	--destructive: oklch(0.577 0.245 27.325);
+	--destructive-foreground: oklch(0.985 0 0);
+	--border: oklch(0.922 0 0);
+	--input: oklch(0.922 0 0);
+	--ring: oklch(0.708 0 0);
+	--chart-1: oklch(0.646 0.222 41.116);
+	--chart-2: oklch(0.6 0.118 184.704);
+	--chart-3: oklch(0.398 0.07 227.392);
+	--chart-4: oklch(0.828 0.189 84.429);
+	--chart-5: oklch(0.769 0.188 70.08);
+	--radius: 0.5rem;
+	--sidebar: oklch(0.985 0 0);
+	--sidebar-foreground: oklch(0.145 0 0);
+	--sidebar-primary: oklch(0.205 0 0);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.97 0 0);
+	--sidebar-accent-foreground: oklch(0.205 0 0);
+	--sidebar-border: oklch(0.922 0 0);
+	--sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+	--background: oklch(0.145 0 0);
+	--foreground: oklch(0.985 0 0);
+	--card: oklch(0.205 0 0);
+	--card-foreground: oklch(0.985 0 0);
+	--popover: oklch(0.205 0 0);
+	--popover-foreground: oklch(0.985 0 0);
+	--primary: oklch(0.75 0.12 165);
+	--primary-foreground: oklch(0.962 0.018 272.314);
+	--secondary: oklch(0.274 0.006 286.033);
+	--secondary-foreground: oklch(0.985 0 0);
+	--muted: oklch(0.269 0 0);
+	--muted-foreground: oklch(0.708 0 0);
+	--accent: oklch(0.269 0 0);
+	--accent-foreground: oklch(0.985 0 0);
+	--destructive: oklch(0.704 0.191 22.216);
+	--border: oklch(1 0 0 / 10%);
+	--input: oklch(1 0 0 / 15%);
+	--ring: oklch(0.556 0 0);
+	--chart-1: oklch(0.87 0 0);
+	--chart-2: oklch(0.556 0 0);
+	--chart-3: oklch(0.439 0 0);
+	--chart-4: oklch(0.371 0 0);
+	--chart-5: oklch(0.269 0 0);
+	--sidebar: oklch(0.205 0 0);
+	--sidebar-foreground: oklch(0.985 0 0);
+	--sidebar-primary: oklch(0.585 0.233 277.117);
+	--sidebar-primary-foreground: oklch(0.962 0.018 272.314);
+	--sidebar-accent: oklch(0.269 0 0);
+	--sidebar-accent-foreground: oklch(0.985 0 0);
+	--sidebar-border: oklch(1 0 0 / 10%);
+	--sidebar-ring: oklch(0.556 0 0);
+}
+
+@theme inline {
+	--font-sans: var(--font-desktop-sans), sans-serif;
+	--font-mono:
+		var(--font-desktop-mono), ui-monospace, "SFMono-Regular", Menlo, Consolas,
+		"Liberation Mono", monospace;
+	--font-weight-normal: 480;
+	--font-weight-medium: 560;
+	--font-weight-semibold: 640;
+	--font-weight-bold: 640;
+	--text-step-1: 12px;
+	--text-step-1--line-height: 16px;
+	--text-step-1--letter-spacing: 0.0025em;
+	--text-step-2: 14px;
+	--text-step-2--line-height: 20px;
+	--text-step-2--letter-spacing: 0em;
+	--text-step-3: 16px;
+	--text-step-3--line-height: 24px;
+	--text-step-3--letter-spacing: 0em;
+	--text-step-4: 18px;
+	--text-step-4--line-height: 26px;
+	--text-step-4--letter-spacing: -0.0025em;
+	--text-step-5: 20px;
+	--text-step-5--line-height: 28px;
+	--text-step-5--letter-spacing: -0.005em;
+	--text-step-6: 24px;
+	--text-step-6--line-height: 30px;
+	--text-step-6--letter-spacing: -0.00625em;
+	--text-step-7: 28px;
+	--text-step-7--line-height: 36px;
+	--text-step-7--letter-spacing: -0.0075em;
+	--text-step-8: 35px;
+	--text-step-8--line-height: 40px;
+	--text-step-8--letter-spacing: -0.01em;
+	--text-step-9: 60px;
+	--text-step-9--line-height: 60px;
+	--text-step-9--letter-spacing: -0.025em;
+	--text-xs: var(--text-step-1);
+	--text-xs--line-height: var(--text-step-1--line-height);
+	--text-xs--letter-spacing: var(--text-step-1--letter-spacing);
+	--text-sm: var(--text-step-2);
+	--text-sm--line-height: var(--text-step-2--line-height);
+	--text-sm--letter-spacing: var(--text-step-2--letter-spacing);
+	--text-base: var(--text-step-3);
+	--text-base--line-height: var(--text-step-3--line-height);
+	--text-base--letter-spacing: var(--text-step-3--letter-spacing);
+	--text-lg: var(--text-step-4);
+	--text-lg--line-height: var(--text-step-4--line-height);
+	--text-lg--letter-spacing: var(--text-step-4--letter-spacing);
+	--text-xl: var(--text-step-5);
+	--text-xl--line-height: var(--text-step-5--line-height);
+	--text-xl--letter-spacing: var(--text-step-5--letter-spacing);
+	--text-2xl: var(--text-step-6);
+	--text-2xl--line-height: var(--text-step-6--line-height);
+	--text-2xl--letter-spacing: var(--text-step-6--letter-spacing);
+	--text-3xl: var(--text-step-7);
+	--text-3xl--line-height: var(--text-step-7--line-height);
+	--text-3xl--letter-spacing: var(--text-step-7--letter-spacing);
+	--text-4xl: var(--text-step-8);
+	--text-4xl--line-height: var(--text-step-8--line-height);
+	--text-4xl--letter-spacing: var(--text-step-8--letter-spacing);
+	--text-6xl: var(--text-step-9);
+	--text-6xl--line-height: var(--text-step-9--line-height);
+	--text-6xl--letter-spacing: var(--text-step-9--letter-spacing);
+	--color-background: var(--background);
+	--color-foreground: var(--foreground);
+	--color-card: var(--card);
+	--color-card-foreground: var(--card-foreground);
+	--color-popover: var(--popover);
+	--color-popover-foreground: var(--popover-foreground);
+	--color-primary: var(--primary);
+	--color-primary-foreground: var(--primary-foreground);
+	--color-secondary: var(--secondary);
+	--color-secondary-foreground: var(--secondary-foreground);
+	--color-muted: var(--muted);
+	--color-muted-foreground: var(--muted-foreground);
+	--color-accent: var(--accent);
+	--color-accent-foreground: var(--accent-foreground);
+	--color-destructive: var(--destructive);
+	--color-destructive-foreground: var(--destructive-foreground);
+	--color-border: var(--border);
+	--color-input: var(--input);
+	--color-ring: var(--ring);
+	--color-chart-1: var(--chart-1);
+	--color-chart-2: var(--chart-2);
+	--color-chart-3: var(--chart-3);
+	--color-chart-4: var(--chart-4);
+	--color-chart-5: var(--chart-5);
+	--radius-sm: calc(var(--radius) - 4px);
+	--radius-md: calc(var(--radius) - 2px);
+	--radius-lg: var(--radius);
+	--radius-xl: calc(var(--radius) + 4px);
+	--color-sidebar: var(--sidebar);
+	--color-sidebar-foreground: var(--sidebar-foreground);
+	--color-sidebar-primary: var(--sidebar-primary);
+	--color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+	--color-sidebar-accent: var(--sidebar-accent);
+	--color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+	--color-sidebar-border: var(--sidebar-border);
+	--color-sidebar-ring: var(--sidebar-ring);
+}
+
+@layer base {
+	html,
+	body {
+		height: 100%;
+		min-height: 100vh;
+		overflow: hidden;
+	}
+	#__next {
+		height: 100%;
+	}
+	* {
+		@apply border-border outline-ring/50;
+	}
+	body {
+		@apply m-0 bg-background text-base font-normal text-foreground;
+	}
+}
+
+@layer components {
+	.markdown {
+		@apply leading-relaxed;
+	}
+	.markdown * {
+		@apply text-sm leading-relaxed;
+	}
+	.markdown + .markdown {
+		@apply mt-2;
+	}
+	.markdown p {
+		@apply my-2 first:mt-0 last:mb-0;
+	}
+	.markdown a {
+		@apply underline;
+	}
+	.markdown blockquote {
+		@apply border-l-2 border-border pl-3;
+	}
+	.markdown code {
+		@apply space-y-1 rounded bg-muted px-1 py-0.5;
+	}
+	.markdown h1 {
+		@apply text-lg font-bold;
+	}
+	.markdown h2,
+	.markdown h3 {
+		@apply text-lg font-semibold;
+	}
+	.markdown ul {
+		@apply list-disc space-y-1;
+	}
+	.markdown ol {
+		@apply list-decimal space-y-1;
+	}
+	.markdown li {
+		@apply ml-5;
+	}
+	.markdown pre {
+		@apply space-y-1 overflow-x-auto rounded bg-muted p-3;
+	}
+	.markdown div {
+		@apply space-y-1;
+	}
+}
+
+/* Custom scrollbar for dark theme */
+::-webkit-scrollbar {
+	width: 6px;
+	height: 6px;
+}
+
+::-webkit-scrollbar-track {
+	background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+	background: oklch(0.3 0.005 260);
+	border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+	background: oklch(0.4 0.005 260);
+}
+
+/* Selection color */
+::selection {
+	background: oklch(0.75 0.12 165 / 0.25);
+}
+
+/* Aurora background (components/ui/aurora-bg.tsx) */
+@keyframes aurora-drift {
+	0%,
+	100% {
+		transform: translate(0, 0) rotate(0deg) scale(1);
+	}
+	25% {
+		transform: translate(14%, -10%) rotate(18deg) scale(1.25);
+	}
+	50% {
+		transform: translate(-4%, 6%) rotate(-6deg) scale(1.05);
+	}
+	75% {
+		transform: translate(-12%, -4%) rotate(-16deg) scale(0.9);
+	}
+}
+
+/* Curtain ribbons: sway side-to-side while skewing and stretching, like an
+   aurora curtain rippling. Ribbons are bottom-anchored (transform-origin
+   bottom), so skew/scale fan out from the horizon. */
+@keyframes aurora-wave {
+	0%,
+	100% {
+		transform: translateX(0) skewX(0deg) scaleY(1);
+		opacity: 0.7;
+	}
+	20% {
+		transform: translateX(4%) skewX(8deg) scaleY(1.15);
+		opacity: 1;
+	}
+	45% {
+		transform: translateX(-3%) skewX(-10deg) scaleY(0.9);
+		opacity: 0.55;
+	}
+	70% {
+		transform: translateX(5%) skewX(12deg) scaleY(1.25);
+		opacity: 0.9;
+	}
+}
+
+/* Traveling wave: a 200%-wide striped sheet slides left by half its width,
+   looping seamlessly, while bobbing vertically — bands visibly roll across. */
+@keyframes aurora-flow {
+	0% {
+		transform: translateX(0) translateY(0) skewX(-6deg);
+	}
+	25% {
+		transform: translateX(-12.5%) translateY(-4%) skewX(4deg);
+	}
+	50% {
+		transform: translateX(-25%) translateY(2%) skewX(-3deg);
+	}
+	75% {
+		transform: translateX(-37.5%) translateY(-5%) skewX(6deg);
+	}
+	100% {
+		transform: translateX(-50%) translateY(0) skewX(-6deg);
+	}
+}
+
+@keyframes aurora-twinkle {
+	0%,
+	100% {
+		opacity: 0.15;
+	}
+	50% {
+		opacity: 1;
+	}
+}
diff --git a/apps/examples/desktop-app/webview/app/layout.tsx b/apps/examples/desktop-app/webview/app/layout.tsx
new file mode 100644
index 0000000..6e7cadc
--- /dev/null
+++ b/apps/examples/desktop-app/webview/app/layout.tsx
@@ -0,0 +1,41 @@
+import { Analytics } from "@vercel/analytics/next";
+import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+	title: "Agent Desktop",
+	description: "AI coding agent interface",
+	generator: "v0.app",
+	icons: {
+		icon: [
+			{
+				url: "/32x32.png",
+				media: "(prefers-color-scheme: light)",
+			},
+			{
+				url: "/32x32.png",
+				media: "(prefers-color-scheme: dark)",
+			},
+			{
+				url: "/icon.svg",
+				type: "image/svg+xml",
+			},
+		],
+		apple: "/icon.png",
+	},
+};
+
+export default function RootLayout({
+	children,
+}: Readonly<{
+	children: React.ReactNode;
+}>) {
+	return (
+		<html className="h-full" lang="en">
+			<body className="h-full min-h-screen font-sans antialiased">
+				{children}
+				<Analytics />
+			</body>
+		</html>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/app/page.tsx b/apps/examples/desktop-app/webview/app/page.tsx
new file mode 100644
index 0000000..209d0d3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/app/page.tsx
@@ -0,0 +1,1103 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { AgentHeader } from "@/components/agent-header";
+import { AgentSidebar } from "@/components/agent-sidebar";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import {
+	Sidebar,
+	SidebarInset,
+	SidebarProvider,
+	SidebarRail,
+} from "@/components/ui/sidebar";
+import { ChatInputBar } from "@/components/views/chat/chat-input-bar";
+import { ChatMessages } from "@/components/views/chat/chat-messages";
+import { DiffView } from "@/components/views/chat/diff-view";
+import { SessionsView } from "@/components/views/sessions/sessions-view";
+import { SettingsView } from "@/components/views/settings/settings-view";
+import { WorkspaceProvider } from "@/contexts/workspace-context";
+import type { PromptInQueue } from "@/hooks/chat-session/types";
+import { useChatSession } from "@/hooks/use-chat-session";
+import { useSessionHistory } from "@/hooks/use-session-history";
+import { toast } from "@/hooks/use-toast";
+import type { ChatSessionConfig } from "@/lib/chat-schema";
+import { desktopClient } from "@/lib/desktop-client";
+import {
+	getSessionMetadataTitle,
+	type SessionHistoryItem,
+	type SessionMetadata,
+} from "@/lib/session-history";
+import { syncHubTheme, watchSystemHubTheme } from "@/lib/theme";
+
+function makeThreadId(): string {
+	return `thread_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+}
+
+type Thread = {
+	id: string;
+	historySession?: SessionHistoryItem;
+};
+
+type WorkspaceSessionItem = {
+	cwd?: string;
+	workspaceRoot?: string;
+};
+
+function normalizeWorkspacePath(path: string): string {
+	const normalized = path.trim().replace(/[\\/]+$/, "");
+	if (!normalized) {
+		return "";
+	}
+	if (/^[A-Za-z]:/.test(normalized)) {
+		return normalized.toLowerCase();
+	}
+	return normalized;
+}
+
+function toThreadTitle(options: { title?: string; prompt?: string }): string {
+	const preferredTitle = options.title?.trim();
+	if (preferredTitle) {
+		return preferredTitle.slice(0, 70);
+	}
+	const line = options.prompt?.trim().split("\n")[0]?.trim();
+	if (line) return line.slice(0, 70);
+	return "New session";
+}
+
+export default function Home() {
+	const [view, setView] = useState<"chat" | "sessions" | "settings">("chat");
+	const [threads, setThreads] = useState<Thread[]>(() => [
+		{ id: makeThreadId() },
+	]);
+	const [activeThreadId, setActiveThreadId] = useState<string>(
+		() => threads[0]?.id,
+	);
+
+	useEffect(() => {
+		syncHubTheme();
+		return watchSystemHubTheme();
+	}, []);
+
+	const handleNewThread = useCallback(() => {
+		const id = makeThreadId();
+		setThreads((prev) => [...prev, { id }]);
+		setActiveThreadId(id);
+		setView("chat");
+	}, []);
+
+	const handleOpenSession = useCallback((session: SessionHistoryItem) => {
+		const threadId = `session_${session.sessionId}`;
+		setThreads((prev) => {
+			const existingIdx = prev.findIndex((item) => item.id === threadId);
+			if (existingIdx >= 0) {
+				const next = [...prev];
+				next[existingIdx] = {
+					...next[existingIdx],
+					historySession: session,
+				};
+				return next;
+			}
+			return [...prev, { id: threadId, historySession: session }];
+		});
+		setActiveThreadId(threadId);
+		setView("chat");
+	}, []);
+
+	const handleDeleteSession = useCallback(
+		(deletedSessionId: string, deletedThreadId?: string) => {
+			const historyThreadId = `session_${deletedSessionId}`;
+			const deletedWasActive =
+				activeThreadId === deletedThreadId ||
+				activeThreadId === historyThreadId;
+			const fallback = deletedWasActive ? { id: makeThreadId() } : null;
+			let emptyFallbackId: string | null = null;
+			setThreads((prev) => {
+				const next = prev.filter(
+					(thread) =>
+						thread.id !== deletedThreadId &&
+						thread.id !== historyThreadId &&
+						thread.historySession?.sessionId !== deletedSessionId,
+				);
+				if (fallback) {
+					return [...next, fallback];
+				}
+				if (next.length === 0) {
+					emptyFallbackId = makeThreadId();
+					return [{ id: emptyFallbackId }];
+				}
+				return next;
+			});
+			if (fallback) {
+				setActiveThreadId(fallback.id);
+				return;
+			}
+			if (emptyFallbackId) {
+				setActiveThreadId(emptyFallbackId);
+			}
+		},
+		[activeThreadId],
+	);
+
+	const handleUpdateSessionMetadata = useCallback(
+		(sessionId: string, metadata: SessionMetadata) => {
+			setThreads((prev) =>
+				prev.map((thread) => {
+					if (thread.historySession?.sessionId !== sessionId) {
+						return thread;
+					}
+					return {
+						...thread,
+						historySession: {
+							...thread.historySession,
+							metadata,
+						},
+					};
+				}),
+			);
+		},
+		[],
+	);
+
+	useEffect(() => {
+		return desktopClient.subscribe("session_deleted", (payload) => {
+			if (!payload || typeof payload !== "object") {
+				return;
+			}
+			const sessionId =
+				typeof (payload as { sessionId?: unknown }).sessionId === "string"
+					? (payload as { sessionId: string }).sessionId.trim()
+					: "";
+			if (!sessionId) {
+				return;
+			}
+			handleDeleteSession(sessionId);
+		});
+	}, [handleDeleteSession]);
+
+	const activeHistorySessionId =
+		threads.find((thread) => thread.id === activeThreadId)?.historySession
+			?.sessionId ?? null;
+	const activeThread =
+		threads.find((thread) => thread.id === activeThreadId) ?? threads[0];
+	const sessionHistory = useSessionHistory({
+		activeSessionId: activeHistorySessionId,
+		onDeleteSession: handleDeleteSession,
+		onOpenSession: handleOpenSession,
+		onUpdateSessionMetadata: handleUpdateSessionMetadata,
+	});
+
+	return (
+		<>
+			<SidebarProvider>
+				<div className="flex h-screen w-full overflow-hidden bg-background text-foreground">
+					<Sidebar
+						className="border-r border-sidebar-border"
+						collapsible="icon"
+					>
+						<AgentSidebar
+							activeSessionId={activeHistorySessionId}
+							onNewThread={handleNewThread}
+							sessionHistory={sessionHistory}
+							setView={setView}
+						/>
+						<SidebarRail />
+					</Sidebar>
+					<SidebarInset className="min-h-0 min-w-0 overflow-hidden">
+						{view === "sessions" ? (
+							<SessionsView
+								activeSessionId={activeHistorySessionId}
+								history={sessionHistory}
+							/>
+						) : activeThread ? (
+							<div className="flex min-h-0 flex-1 flex-col">
+								<ChatThreadPane
+									key={activeThread.id}
+									historySession={activeThread.historySession}
+									onUpdateSessionMetadata={handleUpdateSessionMetadata}
+									threadId={activeThread.id}
+									onDeleteSession={handleDeleteSession}
+									onNewThread={handleNewThread}
+									onOpenSession={handleOpenSession}
+								/>
+							</div>
+						) : null}
+					</SidebarInset>
+				</div>
+			</SidebarProvider>
+			{view === "settings" ? (
+				<div className="fixed inset-0 z-50 bg-background text-foreground">
+					<SettingsView onClose={() => setView("chat")} />
+				</div>
+			) : null}
+		</>
+	);
+}
+
+function ChatThreadPane({
+	threadId,
+	historySession,
+	onUpdateSessionMetadata,
+	onDeleteSession,
+	onNewThread,
+	onOpenSession,
+}: {
+	threadId: string;
+	historySession?: SessionHistoryItem;
+	onUpdateSessionMetadata?: (
+		sessionId: string,
+		metadata: SessionMetadata,
+	) => void;
+	onDeleteSession?: (sessionId: string, threadId?: string) => void;
+	onNewThread?: () => void;
+	onOpenSession?: (session: SessionHistoryItem) => void;
+}) {
+	const {
+		sessionId,
+		status,
+		chatTransportState,
+		chatTransportError,
+		isHydratingSession,
+		activeAssistantMessageId,
+		config,
+		messages,
+		error,
+		summary,
+		fileDiffs,
+		promptsInQueue,
+		pendingToolApprovals,
+		pendingAskQuestions,
+		setConfig,
+		sendPrompt,
+		steerPromptInQueue,
+		updatePromptInQueue,
+		removePromptInQueue,
+		approveToolApproval,
+		rejectToolApproval,
+		answerAskQuestion,
+		restoreCheckpoint,
+		forkSession,
+		reset,
+		abort,
+		hydrateSession,
+	} = useChatSession();
+	const [promptInput, setPromptInput] = useState("");
+	const [pendingAttachments, setPendingAttachments] = useState<File[]>([]);
+	const [showDiffView, setShowDiffView] = useState(false);
+	const [deletingSession, setDeletingSession] = useState(false);
+	const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
+	const [renamingSession, setRenamingSession] = useState(false);
+	const [manualTitle, setManualTitle] = useState("");
+	const [dismissedHistorySessionId, setDismissedHistorySessionId] = useState<
+		string | null
+	>(null);
+	const [gitBranch, setGitBranch] = useState("no-git");
+	const [providerCredentials, setProviderCredentials] = useState<
+		Record<string, { apiKey: string }>
+	>({});
+	const [providersLoaded, setProvidersLoaded] = useState(false);
+	const [workspaces, setWorkspaces] = useState<string[]>([]);
+	const [workspacesLoaded, setWorkspacesLoaded] = useState(false);
+	const hydratedSessionRef = useRef<string | null>(null);
+	const resetThreadRef = useRef<string | null>(null);
+	const manualTitleSessionRef = useRef<string | null>(null);
+	const workspaceRef = useRef({
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot,
+	});
+	workspaceRef.current = {
+		cwd: config.cwd,
+		workspaceRoot: config.workspaceRoot,
+	};
+
+	useEffect(() => {
+		let cancelled = false;
+
+		async function loadProviderCredentials() {
+			try {
+				const payload = await desktopClient.invoke<{
+					providers?: Array<{
+						id?: string;
+						apiKey?: string;
+						baseUrl?: string;
+					}>;
+				}>("list_provider_catalog");
+				if (cancelled) {
+					return;
+				}
+				const next: Record<string, { apiKey: string }> = {};
+				for (const provider of payload.providers ?? []) {
+					const id = provider.id?.trim();
+					if (!id) {
+						continue;
+					}
+					next[id] = {
+						apiKey: provider.apiKey?.trim() ?? "",
+					};
+				}
+				setProviderCredentials(next);
+			} catch {
+				// Keep current config if provider catalog cannot be read.
+			} finally {
+				if (!cancelled) setProvidersLoaded(true);
+			}
+		}
+
+		void loadProviderCredentials();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	useEffect(() => {
+		const selected = providerCredentials[config.provider];
+		if (!selected) {
+			return;
+		}
+		const nextApiKey = selected.apiKey;
+		if (config.apiKey === nextApiKey) {
+			return;
+		}
+		setConfig((prev) => ({
+			...prev,
+			apiKey: nextApiKey,
+		}));
+	}, [config.apiKey, config.provider, providerCredentials, setConfig]);
+
+	const getWorkspaceCwd = useCallback(
+		() =>
+			workspaceRef.current.cwd ||
+			workspaceRef.current.workspaceRoot ||
+			undefined,
+		[],
+	);
+
+	const refreshGitBranch = useCallback(async () => {
+		try {
+			const payload = await desktopClient.invoke<{ branch?: string }>(
+				"get_git_branch",
+				{
+					cwd: getWorkspaceCwd(),
+				},
+			);
+			const branch = payload?.branch?.trim();
+			setGitBranch(branch && branch.length > 0 ? branch : "no-git");
+		} catch {
+			setGitBranch("no-git");
+		}
+	}, [getWorkspaceCwd]);
+
+	const listGitBranches = useCallback(async (): Promise<{
+		current: string;
+		branches: string[];
+	}> => {
+		try {
+			const payload = await desktopClient.invoke<{
+				current?: string;
+				branches?: string[];
+			}>("list_git_branches", {
+				cwd: getWorkspaceCwd(),
+			});
+			const current = payload?.current?.trim() || "no-git";
+			const branches = Array.isArray(payload?.branches)
+				? payload.branches.filter((item) => item.trim().length > 0)
+				: [];
+			return { current, branches };
+		} catch {
+			return { current: "no-git", branches: [] };
+		}
+	}, [getWorkspaceCwd]);
+
+	const switchGitBranch = useCallback(
+		async (nextBranch: string): Promise<boolean> => {
+			try {
+				const payload = await desktopClient.invoke<{ branch?: string }>(
+					"checkout_git_branch",
+					{
+						cwd: getWorkspaceCwd(),
+						branch: nextBranch,
+					},
+				);
+				const branch = payload?.branch?.trim();
+				setGitBranch(branch && branch.length > 0 ? branch : "no-git");
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		[getWorkspaceCwd],
+	);
+
+	const listWorkspaces = useCallback(
+		async (preferredWorkspace?: string): Promise<string[]> => {
+			const roots = new Set<string>();
+			const preferred = (preferredWorkspace || "").trim();
+			if (preferred) {
+				roots.add(preferred);
+			}
+			const current = (
+				workspaceRef.current.workspaceRoot ||
+				workspaceRef.current.cwd ||
+				""
+			).trim();
+			if (current) {
+				roots.add(current);
+			}
+
+			try {
+				const discovered = await desktopClient
+					.invoke<WorkspaceSessionItem[]>("list_discovered_sessions", {
+						limit: 20,
+					})
+					.catch(() => []);
+
+				for (const session of discovered) {
+					const candidate = (session.workspaceRoot || session.cwd || "").trim();
+					if (candidate) {
+						roots.add(candidate);
+					}
+				}
+			} catch {
+				// Keep fallback to current workspace when history is unavailable.
+			}
+
+			return [...roots].sort((a, b) => a.localeCompare(b));
+		},
+		[],
+	);
+
+	const refreshWorkspaces = useCallback(
+		async (preferredWorkspace?: string) => {
+			try {
+				const results = await listWorkspaces(preferredWorkspace);
+				setWorkspaces((current) =>
+					current.length === results.length &&
+					current.every((workspace, index) => workspace === results[index])
+						? current
+						: results,
+				);
+			} finally {
+				setWorkspacesLoaded(true);
+			}
+		},
+		[listWorkspaces],
+	);
+
+	useEffect(() => {
+		void refreshWorkspaces();
+	}, [refreshWorkspaces]);
+
+	const switchWorkspace = useCallback(
+		async (workspacePath: string): Promise<boolean> => {
+			const nextWorkspace = workspacePath.trim();
+			if (!nextWorkspace) {
+				return false;
+			}
+			const normalizedNext = normalizeWorkspacePath(nextWorkspace);
+			const normalizedCurrent = normalizeWorkspacePath(
+				workspaceRef.current.workspaceRoot || workspaceRef.current.cwd || "",
+			);
+			if (normalizedNext === normalizedCurrent) {
+				return true;
+			}
+
+			setConfig((prev) => ({
+				...prev,
+				workspaceRoot: nextWorkspace,
+				cwd: nextWorkspace,
+			}));
+			setWorkspaces((prev) => {
+				const next = new Set(prev);
+				next.add(nextWorkspace);
+				return [...next].sort((a, b) => a.localeCompare(b));
+			});
+
+			// Fire git branch + workspace list refresh in the background
+			desktopClient
+				.invoke<{ branch?: string }>("get_git_branch", {
+					cwd: nextWorkspace,
+				})
+				.then((payload) => {
+					const branch = payload?.branch?.trim();
+					setGitBranch(branch && branch.length > 0 ? branch : "no-git");
+				})
+				.catch(() => {
+					setGitBranch("no-git");
+				});
+
+			// Re-fetch workspace list so the new root appears
+			void refreshWorkspaces(nextWorkspace);
+
+			return true;
+		},
+		[setConfig, refreshWorkspaces],
+	);
+
+	const pickWorkspaceDirectory = useCallback(
+		async (initialPath?: string): Promise<string | null> => {
+			try {
+				const selected = await desktopClient.invoke<string | null>(
+					"pick_workspace_directory",
+					{
+						initialPath: initialPath?.trim() || undefined,
+					},
+				);
+				if (typeof selected !== "string") {
+					return null;
+				}
+				const trimmed = selected.trim();
+				return trimmed.length > 0 ? trimmed : null;
+			} catch {
+				return null;
+			}
+		},
+		[],
+	);
+
+	useEffect(() => {
+		void refreshGitBranch();
+	}, [refreshGitBranch]);
+
+	useEffect(() => {
+		setDismissedHistorySessionId(null);
+	}, []);
+
+	useEffect(() => {
+		if (historySession) {
+			resetThreadRef.current = null;
+			const nextSessionId = historySession.sessionId;
+			const metadataTitle = getSessionMetadataTitle(historySession.metadata);
+			const hasSessionChanged = manualTitleSessionRef.current !== nextSessionId;
+			if (hasSessionChanged) {
+				manualTitleSessionRef.current = nextSessionId;
+				setManualTitle(metadataTitle);
+				return;
+			}
+			// Keep locally renamed title for this session unless metadata now contains one.
+			if (!manualTitle && metadataTitle) {
+				setManualTitle(metadataTitle);
+			}
+			return;
+		}
+		if (resetThreadRef.current === threadId) {
+			return;
+		}
+		resetThreadRef.current = threadId;
+		hydratedSessionRef.current = null;
+		manualTitleSessionRef.current = null;
+		setPromptInput("");
+		setPendingAttachments([]);
+		setManualTitle("");
+		void reset();
+	}, [historySession, manualTitle, reset, threadId]);
+
+	useEffect(() => {
+		if (!historySession) {
+			return;
+		}
+		if (hydratedSessionRef.current === historySession.sessionId) {
+			return;
+		}
+		hydratedSessionRef.current = historySession.sessionId;
+		setPromptInput("");
+		setPendingAttachments([]);
+		setManualTitle(getSessionMetadataTitle(historySession.metadata));
+		void hydrateSession(historySession);
+	}, [historySession, hydrateSession]);
+
+	const handleSend = useCallback(async () => {
+		const trimmed = promptInput.trim();
+		if (!trimmed && pendingAttachments.length === 0) {
+			return;
+		}
+		setPromptInput("");
+		const toSend = [...pendingAttachments];
+		setPendingAttachments([]);
+		await sendPrompt(trimmed, toSend);
+	}, [pendingAttachments, promptInput, sendPrompt]);
+
+	const handleReasoningChange = useCallback(
+		(next: Pick<ChatSessionConfig, "thinking" | "reasoningEffort">) => {
+			setConfig((prev) => {
+				if (
+					prev.thinking === next.thinking &&
+					prev.reasoningEffort === next.reasoningEffort
+				) {
+					return prev;
+				}
+				return {
+					...prev,
+					thinking: next.thinking,
+					reasoningEffort:
+						next.thinking === false ? undefined : next.reasoningEffort,
+				};
+			});
+		},
+		[setConfig],
+	);
+
+	const handleUndoQueuedPrompt = useCallback(
+		async (item: PromptInQueue) => {
+			const removed = await removePromptInQueue(item.id);
+			const prompt = removed?.prompt.trim();
+			if (!prompt) {
+				return;
+			}
+			const attachmentCount =
+				removed?.attachmentCount ?? item.attachmentCount ?? 0;
+			if (attachmentCount > 0) {
+				toast({
+					title: "Queued attachments removed",
+					description: "Reattach files before sending the restored message.",
+				});
+			}
+			setPromptInput((current) =>
+				current.trim().length > 0 ? `${current}\n\n${prompt}` : prompt,
+			);
+		},
+		[removePromptInQueue],
+	);
+	const handleApproveToolApproval = useCallback(
+		(requestId: string) => {
+			void approveToolApproval(requestId);
+		},
+		[approveToolApproval],
+	);
+	const handleRejectToolApproval = useCallback(
+		(requestId: string) => {
+			void rejectToolApproval(requestId);
+		},
+		[rejectToolApproval],
+	);
+	const handleAnswerAskQuestion = useCallback(
+		(requestId: string, answer: string) => {
+			void answerAskQuestion(requestId, answer);
+		},
+		[answerAskQuestion],
+	);
+
+	const handleForkSession = useCallback(async () => {
+		const result = await forkSession();
+		// Open the forked session as a new thread in the sidebar.
+		if (onOpenSession) {
+			const workspaceRoot = config.workspaceRoot;
+			const cwd = config.cwd ?? workspaceRoot;
+			const forkedHistorySession: SessionHistoryItem = {
+				sessionId: result.newSessionId,
+				status: "completed",
+				provider: config.provider,
+				model: config.model,
+				cwd,
+				workspaceRoot,
+				startedAt: new Date().toISOString(),
+				metadata: {
+					fork: {
+						forkedFromSessionId: result.forkedFromSessionId,
+						forkedAt: new Date().toISOString(),
+					},
+				},
+			};
+			onOpenSession(forkedHistorySession);
+		}
+	}, [config, forkSession, onOpenSession]);
+
+	const visibleHistorySession =
+		historySession?.sessionId &&
+		historySession.sessionId === dismissedHistorySessionId
+			? undefined
+			: historySession;
+	const hideDeletedSessionUi = Boolean(
+		dismissedHistorySessionId &&
+			(sessionId === dismissedHistorySessionId ||
+				historySession?.sessionId === dismissedHistorySessionId),
+	);
+	const activeSessionToDelete = hideDeletedSessionUi
+		? null
+		: (sessionId ?? visibleHistorySession?.sessionId ?? null);
+
+	const requestDeleteSession = useCallback(() => {
+		if (!activeSessionToDelete || deletingSession) {
+			return;
+		}
+		setDeleteConfirmOpen(true);
+	}, [activeSessionToDelete, deletingSession]);
+
+	const handleDeleteSession = useCallback(async () => {
+		if (!activeSessionToDelete || deletingSession) {
+			return;
+		}
+		setDeletingSession(true);
+		try {
+			console.error(
+				`[webview:delete] invoke delete_chat_session sessionId=${activeSessionToDelete}`,
+			);
+			const deleted = await desktopClient.invoke<boolean>(
+				"delete_chat_session",
+				{
+					sessionId: activeSessionToDelete,
+				},
+			);
+			console.error(
+				`[webview:delete] invoke result sessionId=${activeSessionToDelete} deleted=${deleted}`,
+			);
+			if (!deleted) {
+				toast({
+					variant: "destructive",
+					title: "Delete failed",
+					description: "The session could not be removed from local history.",
+				});
+				return;
+			}
+			setDismissedHistorySessionId(activeSessionToDelete);
+			setManualTitle("");
+			hydratedSessionRef.current = null;
+			manualTitleSessionRef.current = null;
+			window.dispatchEvent(
+				new CustomEvent("cline:session-deleted", {
+					detail: {
+						sessionId: activeSessionToDelete,
+					},
+				}),
+			);
+			onDeleteSession?.(activeSessionToDelete, threadId);
+			setPromptInput("");
+			setPendingAttachments([]);
+			setShowDiffView(false);
+			void reset();
+		} catch (error) {
+			console.error(
+				`[webview:delete] invoke error sessionId=${activeSessionToDelete} error=${error instanceof Error ? error.message : String(error)}`,
+			);
+			const description =
+				error instanceof Error
+					? error.message
+					: "The session could not be removed from local history.";
+			toast({
+				variant: "destructive",
+				title: "Delete failed",
+				description,
+			});
+		} finally {
+			setDeleteConfirmOpen(false);
+			setDeletingSession(false);
+		}
+	}, [
+		activeSessionToDelete,
+		deletingSession,
+		onDeleteSession,
+		reset,
+		threadId,
+	]);
+
+	const attachmentList = pendingAttachments.map((file, index) => ({
+		id: `${file.name}:${file.size}:${file.lastModified}:${index}`,
+		name: file.name,
+		isImage: file.type.startsWith("image/"),
+	}));
+
+	const firstUserMessage = messages.find(
+		(message) => message.role === "user",
+	)?.content;
+	const metadataTitle =
+		manualTitle || getSessionMetadataTitle(visibleHistorySession?.metadata);
+	const threadTitle = toThreadTitle({
+		title: hideDeletedSessionUi ? undefined : metadataTitle,
+		prompt: hideDeletedSessionUi
+			? undefined
+			: (visibleHistorySession?.prompt ?? firstUserMessage),
+	});
+	const hasDiffChanges = summary.additions + summary.deletions > 0;
+
+	const activeSessionForTitle = hideDeletedSessionUi
+		? null
+		: (sessionId ?? visibleHistorySession?.sessionId ?? null);
+	const displayedMessages = hideDeletedSessionUi ? [] : messages;
+	const displayedError = hideDeletedSessionUi ? null : error;
+	const displayedStatus = hideDeletedSessionUi ? "idle" : status;
+	const displayedSessionId = hideDeletedSessionUi ? null : sessionId;
+	const displayedIsSwitching = hideDeletedSessionUi
+		? false
+		: isHydratingSession;
+	const isWelcomeState =
+		displayedMessages.length === 0 && !displayedIsSwitching;
+
+	const handleRenameTitle = useCallback(
+		async (nextTitle: string) => {
+			if (!activeSessionForTitle || renamingSession) {
+				return;
+			}
+			setRenamingSession(true);
+			try {
+				await desktopClient.invoke("update_chat_session_title", {
+					sessionId: activeSessionForTitle,
+					title: nextTitle,
+				});
+				const normalizedTitle = nextTitle.trim();
+				setManualTitle(normalizedTitle);
+				onUpdateSessionMetadata?.(activeSessionForTitle, {
+					...(historySession?.metadata ?? {}),
+					title: normalizedTitle || undefined,
+				});
+				window.dispatchEvent(
+					new CustomEvent("cline:session-title-updated", {
+						detail: {
+							sessionId: activeSessionForTitle,
+							title: normalizedTitle,
+						},
+					}),
+				);
+			} finally {
+				setRenamingSession(false);
+			}
+		},
+		[
+			activeSessionForTitle,
+			historySession?.metadata,
+			onUpdateSessionMetadata,
+			renamingSession,
+		],
+	);
+
+	useEffect(() => {
+		if (!hasDiffChanges) {
+			setShowDiffView(false);
+		}
+	}, [hasDiffChanges]);
+
+	const resolvedWorkspaceRoot = config.workspaceRoot || config.cwd || "";
+	const workspaceContextValue = useMemo(
+		() => ({
+			workspaceRoot: resolvedWorkspaceRoot,
+			workspaces,
+			listWorkspaces,
+			refreshWorkspaces,
+			switchWorkspace,
+			pickWorkspaceDirectory,
+		}),
+		[
+			resolvedWorkspaceRoot,
+			workspaces,
+			listWorkspaces,
+			refreshWorkspaces,
+			switchWorkspace,
+			pickWorkspaceDirectory,
+		],
+	);
+
+	const isAppReady =
+		chatTransportState === "connected" && providersLoaded && workspacesLoaded;
+
+	if (!isAppReady) {
+		return (
+			<div className="flex h-full flex-1 flex-col items-center justify-center gap-3 bg-background text-foreground">
+				<div className="h-5 w-5 animate-spin rounded-full border-2 border-muted-foreground border-t-transparent" />
+				<p className="text-sm text-muted-foreground">
+					{chatTransportState === "unavailable"
+						? "Desktop backend unavailable"
+						: chatTransportState !== "connected"
+							? "Connecting..."
+							: "Loading..."}
+				</p>
+				{chatTransportError ? (
+					<p className="max-w-xl px-6 text-center text-xs text-muted-foreground">
+						{chatTransportError}
+					</p>
+				) : null}
+			</div>
+		);
+	}
+
+	return (
+		<WorkspaceProvider value={workspaceContextValue}>
+			<div className="grid h-full min-h-0 flex-1 grid-rows-[auto_minmax(0,1fr)_auto] overflow-hidden">
+				<div className="z-20">
+					<AgentHeader
+						canEditTitle={Boolean(activeSessionForTitle)}
+						canDeleteSession={Boolean(activeSessionToDelete)}
+						deletingSession={deletingSession}
+						diff={{
+							additions: summary.additions,
+							deletions: summary.deletions,
+						}}
+						onDeleteSession={requestDeleteSession}
+						onNewThread={onNewThread}
+						onOpenDiff={() => {
+							if (hasDiffChanges) {
+								setShowDiffView(true);
+							}
+						}}
+						onRenameTitle={handleRenameTitle}
+						renamingTitle={renamingSession}
+						showSessionActions={!isWelcomeState}
+						status={status}
+						title={threadTitle}
+					/>
+				</div>
+				<div className="h-full min-h-0 overflow-hidden">
+					{showDiffView ? (
+						<DiffView
+							fileDiffs={fileDiffs}
+							onClose={() => setShowDiffView(false)}
+						/>
+					) : (
+						<ChatMessages
+							onAnswerAskQuestion={handleAnswerAskQuestion}
+							onApproveToolApproval={handleApproveToolApproval}
+							onRejectToolApproval={handleRejectToolApproval}
+							onStartChat={(prompt) => {
+								setPromptInput(prompt);
+							}}
+							chatTransportState={chatTransportState}
+							error={displayedError}
+							messages={displayedMessages}
+							model={config.model}
+							onRestoreCheckpoint={(runCount) =>
+								void restoreCheckpoint(runCount)
+							}
+							onForkSession={handleForkSession}
+							pendingToolApprovals={pendingToolApprovals}
+							pendingAskQuestions={pendingAskQuestions}
+							provider={config.provider}
+							sessionId={displayedSessionId}
+							streamingMessageId={activeAssistantMessageId}
+							isSessionSwitching={displayedIsSwitching}
+							status={displayedStatus}
+						/>
+					)}
+				</div>
+				<div className="z-20 shrink-0">
+					<ChatInputBar
+						attachments={attachmentList}
+						onAbort={() => void abort()}
+						onAttachFiles={(files) => {
+							setPendingAttachments((prev) => {
+								const existing = new Set(
+									prev.map(
+										(file) => `${file.name}:${file.size}:${file.lastModified}`,
+									),
+								);
+								const next = [...prev];
+								for (const file of files) {
+									const key = `${file.name}:${file.size}:${file.lastModified}`;
+									if (!existing.has(key)) {
+										existing.add(key);
+										next.push(file);
+									}
+								}
+								return next;
+							});
+						}}
+						onListGitBranches={listGitBranches}
+						onRemoveAttachment={(id) => {
+							setPendingAttachments((prev) =>
+								prev.filter((file, index) => {
+									const fileId = `${file.name}:${file.size}:${file.lastModified}:${index}`;
+									return fileId !== id;
+								}),
+							);
+						}}
+						onSwitchGitBranch={switchGitBranch}
+						onRefreshGitBranch={() => void refreshGitBranch()}
+						onModelChange={(nextModel) =>
+							setConfig((prev) =>
+								prev.model === nextModel ? prev : { ...prev, model: nextModel },
+							)
+						}
+						onModeToggle={() =>
+							setConfig((prev) => ({
+								...prev,
+								mode: prev.mode === "plan" ? "act" : "plan",
+							}))
+						}
+						onPromptInputChange={setPromptInput}
+						onReasoningChange={handleReasoningChange}
+						onSteerPromptInQueue={(promptId) => {
+							void steerPromptInQueue(promptId);
+						}}
+						onEditPromptInQueue={(promptId, prompt) => {
+							void updatePromptInQueue(promptId, prompt);
+						}}
+						onUndoPromptInQueue={(item) => {
+							void handleUndoQueuedPrompt(item);
+						}}
+						onProviderChange={(nextProvider) =>
+							setConfig((prev) => {
+								const selected = providerCredentials[nextProvider];
+								const nextApiKey = selected?.apiKey ?? "";
+								if (
+									prev.provider === nextProvider &&
+									prev.apiKey === nextApiKey
+								) {
+									return prev;
+								}
+								return {
+									...prev,
+									provider: nextProvider,
+									apiKey: nextApiKey,
+								};
+							})
+						}
+						onReset={() => {
+							setPendingAttachments([]);
+							void reset();
+						}}
+						onSend={() => void handleSend()}
+						gitBranch={gitBranch}
+						model={config.model}
+						mode={config.mode}
+						promptsInQueue={promptsInQueue}
+						promptInput={promptInput}
+						provider={config.provider}
+						reasoningEffort={config.reasoningEffort}
+						status={status}
+						summary={summary}
+						thinking={config.thinking}
+					/>
+				</div>
+			</div>
+			<AlertDialog
+				open={deleteConfirmOpen}
+				onOpenChange={(open) => {
+					if (deletingSession) {
+						return;
+					}
+					if (!open) {
+						console.error(
+							`[webview:delete] cancelled sessionId=${activeSessionToDelete ?? "null"}`,
+						);
+					}
+					setDeleteConfirmOpen(open);
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete Session?</AlertDialogTitle>
+						<AlertDialogDescription>
+							This session will be removed from local history.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={deletingSession}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+							disabled={deletingSession}
+							onClick={() => void handleDeleteSession()}
+						>
+							{deletingSession ? "Deleting..." : "Delete"}
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</WorkspaceProvider>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components.json b/apps/examples/desktop-app/webview/components.json
new file mode 100644
index 0000000..6e57ca9
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components.json
@@ -0,0 +1,21 @@
+{
+	"$schema": "https://ui.shadcn.com/schema.json",
+	"style": "new-york",
+	"rsc": true,
+	"tsx": true,
+	"tailwind": {
+		"config": "",
+		"css": "app/globals.css",
+		"baseColor": "neutral",
+		"cssVariables": true,
+		"prefix": ""
+	},
+	"aliases": {
+		"components": "@/components",
+		"utils": "@/lib/utils",
+		"ui": "@/components/ui",
+		"lib": "@/lib",
+		"hooks": "@/hooks"
+	},
+	"iconLibrary": "lucide"
+}
diff --git a/apps/examples/desktop-app/webview/components/agent-header.tsx b/apps/examples/desktop-app/webview/components/agent-header.tsx
new file mode 100644
index 0000000..aa39509
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/agent-header.tsx
@@ -0,0 +1,200 @@
+"use client";
+
+import { MoreHorizontal, Plus, Trash2 } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import type { ChatSessionStatus } from "@/lib/chat-schema";
+import { cn } from "@/lib/utils";
+import { Button } from "./ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuTrigger,
+} from "./ui/dropdown-menu";
+import { Input } from "./ui/input";
+import { normalizeTitle } from "./utils";
+
+type AgentHeaderProps = {
+	title?: string;
+	canEditTitle?: boolean;
+	renamingTitle?: boolean;
+	onRenameTitle?: (nextTitle: string) => Promise<void> | void;
+	onNewThread?: () => void;
+	onDeleteSession?: () => void;
+	canDeleteSession?: boolean;
+	deletingSession?: boolean;
+	onOpenDiff?: () => void;
+	showSessionActions?: boolean;
+	status?: ChatSessionStatus;
+	diff?: {
+		additions: number;
+		deletions: number;
+	};
+};
+
+export function AgentHeader({
+	title,
+	canEditTitle,
+	renamingTitle,
+	onRenameTitle,
+	onNewThread,
+	onDeleteSession,
+	canDeleteSession,
+	deletingSession,
+	onOpenDiff,
+	showSessionActions = true,
+	status,
+	diff,
+}: AgentHeaderProps) {
+	const [isEditingTitle, setIsEditingTitle] = useState(false);
+	const [titleInput, setTitleInput] = useState("");
+	const additions = diff?.additions ?? 0;
+	const deletions = diff?.deletions ?? 0;
+	const hasChanges = additions + deletions > 0;
+	const threadTitle = useMemo(
+		() => normalizeTitle(title?.trim()) || "New Session",
+		[title],
+	);
+
+	useEffect(() => {
+		if (!isEditingTitle) {
+			setTitleInput(threadTitle);
+		}
+	}, [isEditingTitle, threadTitle]);
+
+	const submitTitle = async () => {
+		if (!onRenameTitle || renamingTitle) {
+			return;
+		}
+		const nextTitle = titleInput.trim();
+		if (nextTitle === threadTitle.trim()) {
+			setIsEditingTitle(false);
+			return;
+		}
+		setIsEditingTitle(false);
+		try {
+			await onRenameTitle(nextTitle);
+		} catch {
+			// Keep the existing title when update fails.
+		}
+	};
+
+	const triggerDeleteSession = () => onDeleteSession?.();
+
+	return (
+		<header className="flex h-12 items-center justify-between px-4">
+			{/* Left: thread title */}
+			<div className="flex items-center gap-2">
+				<span
+					className={cn(
+						"rounded w-2 h-2 font-mono",
+						status === "running"
+							? "bg-green-500"
+							: status === "failed"
+								? "bg-red-500"
+								: "bg-gray-500",
+					)}
+				/>
+				{isEditingTitle ? (
+					<form
+						className="m-0"
+						onSubmit={(event) => {
+							event.preventDefault();
+							void submitTitle();
+						}}
+					>
+						<Input
+							autoFocus
+							className="h-7 w-64 text-sm"
+							disabled={renamingTitle}
+							onBlur={() => {
+								void submitTitle();
+							}}
+							onChange={(event) => setTitleInput(event.target.value)}
+							onKeyDown={(event) => {
+								if (event.key === "Escape") {
+									event.preventDefault();
+									setTitleInput(threadTitle);
+									setIsEditingTitle(false);
+								}
+							}}
+							value={titleInput}
+						/>
+					</form>
+				) : (
+					<button
+						className={cn(
+							"text-sm font-medium text-foreground",
+							canEditTitle &&
+								"rounded px-1 py-0.5 transition-colors hover:bg-accent",
+						)}
+						disabled={!canEditTitle || renamingTitle}
+						onClick={() => {
+							if (!canEditTitle || renamingTitle) {
+								return;
+							}
+							setTitleInput(threadTitle);
+							setIsEditingTitle(true);
+						}}
+						type="button"
+					>
+						{threadTitle}
+					</button>
+				)}
+				<DropdownMenu>
+					<DropdownMenuTrigger asChild>
+						<Button
+							className="text-muted-foreground hover:text-foreground transition-colors"
+							id="show-more-btn"
+							variant="ghost"
+							size="icon-sm"
+							type="button"
+						>
+							<MoreHorizontal className="size-3" />
+						</Button>
+					</DropdownMenuTrigger>
+					<DropdownMenuContent align="start" className="w-44">
+						<DropdownMenuItem
+							className="text-destructive focus:text-destructive"
+							disabled={!canDeleteSession || deletingSession}
+							onClick={triggerDeleteSession}
+						>
+							<Trash2 className="size-4" />
+							<span>{deletingSession ? "Deleting..." : "Delete session"}</span>
+						</DropdownMenuItem>
+					</DropdownMenuContent>
+				</DropdownMenu>
+			</div>
+
+			{showSessionActions ? (
+				<div className="flex items-center gap-2">
+					<Button
+						className={cn(
+							"flex items-center gap-1 rounded-md bg-secondary px-2 py-1 text-xs font-mono transition-colors",
+							hasChanges
+								? "hover:bg-secondary/80"
+								: "cursor-default opacity-60",
+						)}
+						disabled={!hasChanges}
+						id="diff-stats"
+						onClick={() => onOpenDiff?.()}
+						size="sm"
+						type="button"
+						variant="secondary"
+					>
+						<span className="text-chart-2">+{additions}</span>
+						<span className="text-destructive">-{deletions}</span>
+					</Button>
+					<Button
+						className="flex items-center gap-1 rounded-md text-sm text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						onClick={() => onNewThread?.()}
+						size="icon-sm"
+						variant="ghost"
+					>
+						<Plus />
+					</Button>
+				</div>
+			) : null}
+		</header>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/agent-sidebar.tsx b/apps/examples/desktop-app/webview/components/agent-sidebar.tsx
new file mode 100644
index 0000000..8b87c54
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/agent-sidebar.tsx
@@ -0,0 +1,719 @@
+"use client";
+
+import {
+	ChevronDown,
+	Filter,
+	GitFork,
+	Loader2,
+	MessageSquare,
+	PanelLeftOpen,
+	Pencil,
+	Pin,
+	Plus,
+	Search,
+	Settings,
+	Trash2,
+} from "lucide-react";
+import {
+	type ReactNode,
+	useCallback,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+	ContextMenu,
+	ContextMenuContent,
+	ContextMenuItem,
+	ContextMenuTrigger,
+} from "@/components/ui/context-menu";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuRadioGroup,
+	DropdownMenuRadioItem,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { Input } from "@/components/ui/input";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { useSidebar } from "@/components/ui/sidebar";
+import { normalizeTitle } from "@/components/utils";
+import type {
+	SessionThread,
+	UseSessionHistoryResult,
+} from "@/hooks/use-session-history";
+import { formatCostUsd, formatTokenCount } from "@/hooks/use-session-history";
+import { cn } from "@/lib/utils";
+
+type Thread = SessionThread;
+
+const filterOptions = ["All", "Running", "Recent", "Pinned"] as const;
+type FilterOption = (typeof filterOptions)[number];
+const INITIAL_VISIBLE_THREAD_COUNT = 10;
+
+export function AgentSidebar({
+	onNewThread,
+	setView,
+	activeSessionId,
+	sessionHistory,
+}: {
+	onNewThread?: () => void;
+	setView: (view: "chat" | "sessions" | "settings") => void;
+	activeSessionId?: string | null;
+	sessionHistory: UseSessionHistoryResult;
+}) {
+	const { isMobile, setOpen, state } = useSidebar();
+	const isCollapsed = !isMobile && state === "collapsed";
+	const {
+		deleteThread: deleteHistoryThread,
+		forkThread: forkHistoryThread,
+		isLoadingHistory,
+		isLoadingMore,
+		loadMoreSessions,
+		mayHaveMoreSessions,
+		openThread: openHistoryThread,
+		pendingAction,
+		renameThread,
+		threads,
+		unreadSessionIds,
+	} = sessionHistory;
+	const activeThread = activeSessionId ?? "";
+	const [filter, setFilter] = useState<FilterOption>("All");
+	const [searchOpen, setSearchOpen] = useState(false);
+	const [searchQuery, setSearchQuery] = useState("");
+	const [showMoreCount, setShowMoreCount] = useState(
+		INITIAL_VISIBLE_THREAD_COUNT,
+	);
+	const [editingSessionId, setEditingSessionId] = useState<string | null>(null);
+	const [editingTitle, setEditingTitle] = useState("");
+	const [deleteConfirmThread, setDeleteConfirmThread] = useState<Thread | null>(
+		null,
+	);
+
+	useEffect(() => {
+		if (isCollapsed && searchOpen) {
+			setSearchOpen(false);
+		}
+	}, [isCollapsed, searchOpen]);
+
+	const filteredThreads = useMemo(() => {
+		let filtered = threads;
+		if (searchQuery) {
+			const q = searchQuery.toLowerCase();
+			filtered = filtered.filter(
+				(t) =>
+					t.title.toLowerCase().includes(q) ||
+					t.codebase.toLowerCase().includes(q),
+			);
+		}
+		switch (filter) {
+			case "Running":
+				return filtered.filter((t) => t.status === "running");
+			case "Recent":
+				return filtered.slice(0, 8);
+			case "Pinned":
+				return filtered.filter((t) => t.pinned);
+			default:
+				return filtered;
+		}
+	}, [filter, searchQuery, threads]);
+
+	const openThread = useCallback(
+		(threadId: string) => {
+			setView("chat");
+			openHistoryThread(threadId);
+		},
+		[openHistoryThread, setView],
+	);
+
+	const openNewThread = useCallback(() => {
+		setView("chat");
+		onNewThread?.();
+	}, [onNewThread, setView]);
+
+	const startRenameThread = useCallback((thread: Thread) => {
+		setEditingSessionId(thread.id);
+		setEditingTitle(normalizeTitle(thread.title));
+	}, []);
+
+	const cancelRenameThread = useCallback(() => {
+		setEditingSessionId(null);
+		setEditingTitle("");
+	}, []);
+
+	const commitRenameThread = useCallback(
+		async (thread: Thread) => {
+			const renamed = await renameThread(thread.id, editingTitle);
+			if (renamed) {
+				cancelRenameThread();
+			}
+		},
+		[cancelRenameThread, editingTitle, renameThread],
+	);
+
+	const forkThread = useCallback(
+		async (thread: Thread) => {
+			await forkHistoryThread(thread.id);
+		},
+		[forkHistoryThread],
+	);
+
+	const requestDeleteThread = useCallback((thread: Thread) => {
+		setDeleteConfirmThread(thread);
+	}, []);
+
+	const deleteThread = useCallback(
+		async (thread: Thread) => {
+			await deleteHistoryThread(thread.id);
+			setDeleteConfirmThread(null);
+		},
+		[deleteHistoryThread],
+	);
+
+	const pinnedThreads = useMemo(
+		() => filteredThreads.filter((t) => t.pinned),
+		[filteredThreads],
+	);
+	const sessionThreads = useMemo(
+		() => filteredThreads.filter((t) => !t.pinned),
+		[filteredThreads],
+	);
+	const displayedThreads = useMemo(
+		() =>
+			filter === "All"
+				? [...pinnedThreads, ...sessionThreads.slice(0, showMoreCount)]
+				: [...pinnedThreads, ...sessionThreads].slice(0, showMoreCount),
+		[filter, pinnedThreads, sessionThreads, showMoreCount],
+	);
+	const showShowMore =
+		sessionThreads.length > showMoreCount || mayHaveMoreSessions;
+
+	const filterMenu = (
+		<DropdownMenu>
+			<DropdownMenuTrigger asChild>
+				<Button
+					aria-label="Filter sessions"
+					className="m-0! inline-flex size-8 items-center justify-center rounded-md p-0! text-muted-foreground transition-colors hover:bg-sidebar-accent hover:text-sidebar-foreground"
+					variant="ghost"
+					size="icon"
+				>
+					<Filter className="size-3 stroke-2" />
+				</Button>
+			</DropdownMenuTrigger>
+			<DropdownMenuContent align="end" className="w-36">
+				<DropdownMenuRadioGroup
+					onValueChange={(value) => {
+						setFilter(value as FilterOption);
+						setShowMoreCount(INITIAL_VISIBLE_THREAD_COUNT);
+					}}
+					value={filter}
+				>
+					{filterOptions.map((opt) => (
+						<DropdownMenuRadioItem key={opt} value={opt}>
+							{opt}
+						</DropdownMenuRadioItem>
+					))}
+				</DropdownMenuRadioGroup>
+			</DropdownMenuContent>
+		</DropdownMenu>
+	);
+
+	return (
+		<>
+			<div className="flex h-full min-h-0 w-full min-w-0 shrink-0 flex-col overflow-hidden bg-sidebar text-sidebar-foreground">
+				<div className="mt-2 flex w-full min-w-0 flex-col gap-1">
+					<Button
+						className={cn(
+							"justify-start min-w-0",
+							isCollapsed && "mx-auto size-9 justify-center px-0",
+						)}
+						aria-label="New Session"
+						onClick={openNewThread}
+						title="New Session"
+						variant="sidebar"
+					>
+						{isCollapsed ? (
+							<MessageSquare className="size-4" />
+						) : (
+							<Plus className="size-4" />
+						)}
+						{!isCollapsed ? "New Session" : null}
+					</Button>
+					{isCollapsed ? (
+						<Button
+							aria-label="Expand sidebar"
+							className="mx-auto size-9 justify-center px-0"
+							onClick={() => setOpen(true)}
+							title="Expand sidebar"
+							type="button"
+							variant="sidebar"
+						>
+							<PanelLeftOpen className="size-4" />
+						</Button>
+					) : null}
+				</div>
+
+				{!isCollapsed ? (
+					<div className="flex w-full min-w-0 flex-col gap-1">
+						{searchOpen ? (
+							<div className="flex min-w-0 items-center gap-2 overflow-hidden rounded-md bg-sidebar-accent px-2 py-1.5">
+								<Search className="size-4 shrink-0" />
+								<Input
+									className="min-w-0 flex-1 bg-transparent text-sm text-sidebar-foreground outline-none placeholder:text-muted-foreground"
+									onBlur={() => {
+										if (!searchQuery) setSearchOpen(false);
+									}}
+									autoFocus={true}
+									onChange={(e) => setSearchQuery(e.target.value)}
+									placeholder="Search sessions..."
+									value={searchQuery}
+								/>
+							</div>
+						) : (
+							<Button
+								className="py-1.5 min-w-0"
+								onClick={() => setSearchOpen(true)}
+								title="Search sessions"
+								type="button"
+								variant="sidebarItem"
+							>
+								<Search className="size-4 shrink-0" />
+								<span>Search</span>
+							</Button>
+						)}
+					</div>
+				) : null}
+
+				{!isCollapsed ? (
+					<div className="mt-2 min-h-0 w-full flex-1">
+						<ScrollArea className="h-full min-h-0 w-full min-w-0">
+							<div className="flex min-w-0 flex-col gap-0.5 pb-3 px-3">
+								{isLoadingHistory && threads.length === 0 ? (
+									<div className="p-4 text-xs text-muted-foreground">
+										Loading session history...
+									</div>
+								) : (
+									<>
+										{displayedThreads.length > 0 && (
+											<ThreadSection
+												action={filterMenu}
+												label={filter === "All" ? "Sessions" : filter}
+												onClick={() => setView("sessions")}
+											>
+												{displayedThreads.map((thread) => (
+													<ThreadItem
+														editTitle={editingTitle}
+														editing={editingSessionId === thread.id}
+														isActive={activeThread === thread.id}
+														key={thread.id}
+														onCancelRename={cancelRenameThread}
+														onClick={() => openThread(thread.id)}
+														onCommitRename={() =>
+															void commitRenameThread(thread)
+														}
+														onDelete={() => requestDeleteThread(thread)}
+														onEditTitleChange={setEditingTitle}
+														onFork={() => void forkThread(thread)}
+														onRename={() => startRenameThread(thread)}
+														pendingAction={
+															pendingAction?.sessionId === thread.id
+																? pendingAction.action
+																: null
+														}
+														thread={thread}
+														unread={unreadSessionIds.has(thread.id)}
+													/>
+												))}
+											</ThreadSection>
+										)}
+
+										{displayedThreads.length === 0 && (
+											<div className="p-4 text-xs text-muted-foreground">
+												{searchQuery
+													? "No sessions match your search."
+													: "No sessions found in history."}
+											</div>
+										)}
+									</>
+								)}
+								{showShowMore && (
+									<Button
+										className="pl-0"
+										disabled={isLoadingMore}
+										onClick={() => {
+											const nextCount =
+												showMoreCount + INITIAL_VISIBLE_THREAD_COUNT;
+											setShowMoreCount(nextCount);
+											void loadMoreSessions(nextCount);
+										}}
+										type="button"
+										variant="sidebarText"
+									>
+										{isLoadingMore ? (
+											<>
+												<Loader2 className="size-3 animate-spin" />
+												Loading...
+											</>
+										) : (
+											<>
+												Show more
+												<ChevronDown className="size-3" />
+											</>
+										)}
+									</Button>
+								)}
+							</div>
+						</ScrollArea>
+					</div>
+				) : (
+					<div className="min-h-0 w-full flex-1" />
+				)}
+
+				<div className="shrink-0 px-2 py-3">
+					<Button
+						type="button"
+						variant="sidebarItem"
+						className={cn(
+							"justify-start min-w-0",
+							isCollapsed && "mx-auto size-9 justify-center px-0",
+						)}
+						onClick={() => setView("settings")}
+						title="Settings"
+					>
+						<Settings className="size-4" />
+						{!isCollapsed ? "Settings" : null}
+					</Button>
+				</div>
+			</div>
+			<AlertDialog
+				open={deleteConfirmThread !== null}
+				onOpenChange={(open) => {
+					if (!open && pendingAction?.action !== "delete") {
+						setDeleteConfirmThread(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete session?</AlertDialogTitle>
+						<AlertDialogDescription>
+							This removes "
+							{normalizeTitle(deleteConfirmThread?.title ?? "this session")}"
+							from local history.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={pendingAction?.action === "delete"}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+							disabled={
+								!deleteConfirmThread || pendingAction?.action === "delete"
+							}
+							onClick={(event) => {
+								event.preventDefault();
+								if (deleteConfirmThread) {
+									void deleteThread(deleteConfirmThread);
+								}
+							}}
+						>
+							{pendingAction?.action === "delete" ? (
+								<>
+									<Loader2 className="size-4 animate-spin" />
+									Deleting...
+								</>
+							) : (
+								"Delete"
+							)}
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</>
+	);
+}
+
+function ThreadSection({
+	label,
+	action,
+	onClick,
+	children,
+}: {
+	label: string;
+	action?: ReactNode;
+	onClick?: () => void;
+	children: ReactNode;
+}) {
+	return (
+		<div className={cn("mb-1 min-w-0")}>
+			<div className="flex h-9 w-full min-w-0 flex-nowrap items-center gap-1 text-sm font-medium text-muted-foreground">
+				<button
+					aria-label={`Open ${label} sessions view`}
+					className="flex min-w-0 flex-1 items-center self-stretch rounded-md pl-0 pr-2 text-left transition-colors hover:bg-sidebar-accent hover:text-sidebar-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+					onClick={onClick}
+					type="button"
+				>
+					<span className="block min-w-0 shrink truncate">{label}</span>
+				</button>
+				{action ? (
+					<div className="flex shrink-0 items-center">{action}</div>
+				) : null}
+			</div>
+			{children}
+		</div>
+	);
+}
+
+function ThreadItem({
+	thread,
+	editTitle,
+	editing,
+	isActive,
+	onClick,
+	onCancelRename,
+	onCommitRename,
+	onEditTitleChange,
+	onRename,
+	onFork,
+	onDelete,
+	pendingAction,
+	unread,
+}: {
+	thread: Thread;
+	editTitle: string;
+	editing: boolean;
+	isActive: boolean;
+	onClick: () => void;
+	onCancelRename: () => void;
+	onCommitRename: () => void;
+	onEditTitleChange: (title: string) => void;
+	onRename: () => void;
+	onFork: () => void;
+	onDelete: () => void;
+	pendingAction: "rename" | "fork" | "delete" | null;
+	unread: boolean;
+}) {
+	const tokenLabel = formatTokenCount(thread.inputTokens, thread.outputTokens);
+	const costLabel = formatCostUsd(thread.totalCostUsd);
+	const title = normalizeTitle(thread.title);
+	const pending = pendingAction !== null;
+	const statusDotClass = pending
+		? "bg-yellow-400"
+		: thread.status === "running"
+			? "bg-green-500"
+			: unread
+				? "bg-blue-500"
+				: "";
+	const infoItems: Array<[string, string | null | undefined]> = [
+		["ID", thread.id],
+		["Workspace", thread.codebase],
+		["Status", thread.status],
+		["Updated", thread.time],
+		["Provider", thread.provider],
+		["Model", thread.model],
+		["Tokens", tokenLabel],
+		["Cost", costLabel],
+	].filter((item): item is [string, string] => Boolean(item[1]));
+
+	if (editing) {
+		return (
+			<div
+				className={cn(
+					"grid h-8 w-full max-w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-1 overflow-hidden rounded-md px-2",
+					isActive
+						? "bg-sidebar-accent text-sidebar-accent-foreground"
+						: "text-sidebar-foreground/80",
+				)}
+			>
+				<EditableSessionTitle
+					disabled={pendingAction === "rename"}
+					onCancel={onCancelRename}
+					onChange={onEditTitleChange}
+					onCommit={onCommitRename}
+					value={editTitle}
+				/>
+				{pendingAction === "rename" ? (
+					<Loader2 className="size-3 shrink-0 animate-spin text-muted-foreground" />
+				) : null}
+			</div>
+		);
+	}
+
+	return (
+		<ContextMenu>
+			<HoverCard openDelay={250} closeDelay={100}>
+				<ContextMenuTrigger asChild>
+					<HoverCardTrigger asChild>
+						<button
+							className={cn(
+								"group grid h-8 w-full max-w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-2 overflow-hidden rounded-md px-2 text-left text-sm font-normal transition-colors",
+								isActive
+									? "bg-sidebar-accent text-sidebar-accent-foreground"
+									: "text-sidebar-foreground/80 hover:bg-sidebar-accent/50",
+							)}
+							disabled={pending}
+							onClick={onClick}
+							type="button"
+						>
+							<span className="block max-w-full min-w-0 overflow-hidden text-ellipsis whitespace-nowrap text-sm font-semibold leading-tight">
+								{title}
+							</span>
+							{thread.pinned ? (
+								<Pin
+									aria-label="Pinned"
+									className="size-3 shrink-0 text-muted-foreground"
+								/>
+							) : statusDotClass ? (
+								<span
+									aria-hidden="true"
+									className={cn("size-2 rounded-full", statusDotClass)}
+								/>
+							) : null}
+						</button>
+					</HoverCardTrigger>
+				</ContextMenuTrigger>
+				<HoverCardContent
+					align="start"
+					avoidCollisions={false}
+					className="w-72 p-3"
+					side="right"
+					sideOffset={8}
+				>
+					<div className="min-w-0 space-y-2">
+						<div className="truncate text-sm font-medium">{title}</div>
+						<div className="grid grid-cols-[72px_minmax(0,1fr)] gap-x-2 gap-y-1 text-xs">
+							{infoItems.map(([label, value]) => (
+								<div className="contents" key={label}>
+									<span className="text-muted-foreground">{label}</span>
+									<span className="min-w-0 truncate font-mono">{value}</span>
+								</div>
+							))}
+						</div>
+					</div>
+				</HoverCardContent>
+			</HoverCard>
+			<SessionContextMenuContent
+				onDelete={onDelete}
+				onFork={onFork}
+				onRename={onRename}
+				pendingAction={pendingAction}
+			/>
+		</ContextMenu>
+	);
+}
+
+function EditableSessionTitle({
+	value,
+	disabled,
+	onChange,
+	onCommit,
+	onCancel,
+}: {
+	value: string;
+	disabled: boolean;
+	onChange: (value: string) => void;
+	onCommit: () => void;
+	onCancel: () => void;
+}) {
+	const inputRef = useRef<HTMLInputElement>(null);
+
+	useEffect(() => {
+		const input = inputRef.current;
+		if (!input) {
+			return;
+		}
+		input.focus();
+		input.setSelectionRange(0, 0);
+		input.scrollLeft = 0;
+	}, []);
+
+	return (
+		<Input
+			ref={inputRef}
+			className="h-6 max-w-full min-w-0 bg-background px-1.5 py-0 text-sm"
+			disabled={disabled}
+			onBlur={() => {
+				if (!disabled) {
+					onCommit();
+				}
+			}}
+			onChange={(event) => onChange(event.target.value)}
+			onClick={(event) => event.stopPropagation()}
+			onKeyDown={(event) => {
+				if (event.key === "Enter") {
+					event.preventDefault();
+					onCommit();
+				}
+				if (event.key === "Escape") {
+					event.preventDefault();
+					onCancel();
+				}
+			}}
+			value={value}
+		/>
+	);
+}
+
+function SessionContextMenuContent({
+	onRename,
+	onFork,
+	onDelete,
+	pendingAction,
+}: {
+	onRename: () => void;
+	onFork: () => void;
+	onDelete: () => void;
+	pendingAction: "rename" | "fork" | "delete" | null;
+}) {
+	const pending = pendingAction !== null;
+	return (
+		<ContextMenuContent className="w-40">
+			<ContextMenuItem disabled={pending} onSelect={onRename}>
+				{pendingAction === "rename" ? (
+					<Loader2 className="size-4 animate-spin" />
+				) : (
+					<Pencil className="size-4" />
+				)}
+				{pendingAction === "rename" ? "Renaming..." : "Rename"}
+			</ContextMenuItem>
+			<ContextMenuItem disabled={pending} onSelect={onFork}>
+				{pendingAction === "fork" ? (
+					<Loader2 className="size-4 animate-spin" />
+				) : (
+					<GitFork className="size-4" />
+				)}
+				{pendingAction === "fork" ? "Forking..." : "Fork"}
+			</ContextMenuItem>
+			<ContextMenuItem
+				disabled={pending}
+				onSelect={onDelete}
+				variant="destructive"
+			>
+				{pendingAction === "delete" ? (
+					<Loader2 className="size-4 animate-spin" />
+				) : (
+					<Trash2 className="size-4" />
+				)}
+				{pendingAction === "delete" ? "Deleting..." : "Delete"}
+			</ContextMenuItem>
+		</ContextMenuContent>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/theme-provider.tsx b/apps/examples/desktop-app/webview/components/theme-provider.tsx
new file mode 100644
index 0000000..fb1bb6b
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/theme-provider.tsx
@@ -0,0 +1,10 @@
+"use client";
+
+import {
+	ThemeProvider as NextThemesProvider,
+	type ThemeProviderProps,
+} from "next-themes";
+
+export function ThemeProvider({ children, ...props }: ThemeProviderProps) {
+	return <NextThemesProvider {...props}>{children}</NextThemesProvider>;
+}
diff --git a/apps/examples/desktop-app/webview/components/ui/accordion.tsx b/apps/examples/desktop-app/webview/components/ui/accordion.tsx
new file mode 100644
index 0000000..7fa8fa3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/accordion.tsx
@@ -0,0 +1,66 @@
+"use client";
+
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+import { ChevronDownIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Accordion({
+	...props
+}: React.ComponentProps<typeof AccordionPrimitive.Root>) {
+	return <AccordionPrimitive.Root data-slot="accordion" {...props} />;
+}
+
+function AccordionItem({
+	className,
+	...props
+}: React.ComponentProps<typeof AccordionPrimitive.Item>) {
+	return (
+		<AccordionPrimitive.Item
+			data-slot="accordion-item"
+			className={cn("border-b last:border-b-0", className)}
+			{...props}
+		/>
+	);
+}
+
+function AccordionTrigger({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof AccordionPrimitive.Trigger>) {
+	return (
+		<AccordionPrimitive.Header className="flex">
+			<AccordionPrimitive.Trigger
+				data-slot="accordion-trigger"
+				className={cn(
+					"focus-visible:border-ring focus-visible:ring-ring/50 flex flex-1 items-start justify-between gap-4 rounded-md py-4 text-left text-sm font-medium transition-all outline-none hover:underline focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 [&[data-state=open]>svg]:rotate-180",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				<ChevronDownIcon className="text-muted-foreground pointer-events-none size-4 shrink-0 translate-y-0.5 transition-transform duration-200" />
+			</AccordionPrimitive.Trigger>
+		</AccordionPrimitive.Header>
+	);
+}
+
+function AccordionContent({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof AccordionPrimitive.Content>) {
+	return (
+		<AccordionPrimitive.Content
+			data-slot="accordion-content"
+			className="data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down overflow-hidden text-sm"
+			{...props}
+		>
+			<div className={cn("pt-0 pb-4", className)}>{children}</div>
+		</AccordionPrimitive.Content>
+	);
+}
+
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };
diff --git a/apps/examples/desktop-app/webview/components/ui/alert-dialog.tsx b/apps/examples/desktop-app/webview/components/ui/alert-dialog.tsx
new file mode 100644
index 0000000..2b02714
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/alert-dialog.tsx
@@ -0,0 +1,156 @@
+"use client";
+
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import type * as React from "react";
+import { buttonVariants } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function AlertDialog({
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Root>) {
+	return <AlertDialogPrimitive.Root data-slot="alert-dialog" {...props} />;
+}
+
+function AlertDialogTrigger({
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>) {
+	return (
+		<AlertDialogPrimitive.Trigger data-slot="alert-dialog-trigger" {...props} />
+	);
+}
+
+function AlertDialogPortal({
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Portal>) {
+	return (
+		<AlertDialogPrimitive.Portal data-slot="alert-dialog-portal" {...props} />
+	);
+}
+
+function AlertDialogOverlay({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>) {
+	return (
+		<AlertDialogPrimitive.Overlay
+			data-slot="alert-dialog-overlay"
+			className={cn(
+				"data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogContent({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Content>) {
+	return (
+		<AlertDialogPortal>
+			<AlertDialogOverlay />
+			<AlertDialogPrimitive.Content
+				data-slot="alert-dialog-content"
+				className={cn(
+					"bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
+					className,
+				)}
+				{...props}
+			/>
+		</AlertDialogPortal>
+	);
+}
+
+function AlertDialogHeader({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-header"
+			className={cn("flex flex-col gap-2 text-center sm:text-left", className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogFooter({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-footer"
+			className={cn(
+				"flex flex-col-reverse gap-2 sm:flex-row sm:justify-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogTitle({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Title>) {
+	return (
+		<AlertDialogPrimitive.Title
+			data-slot="alert-dialog-title"
+			className={cn("text-lg font-semibold", className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogDescription({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Description>) {
+	return (
+		<AlertDialogPrimitive.Description
+			data-slot="alert-dialog-description"
+			className={cn("text-muted-foreground text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogAction({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Action>) {
+	return (
+		<AlertDialogPrimitive.Action
+			className={cn(buttonVariants(), className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogCancel({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>) {
+	return (
+		<AlertDialogPrimitive.Cancel
+			className={cn(buttonVariants({ variant: "outline" }), className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	AlertDialog,
+	AlertDialogPortal,
+	AlertDialogOverlay,
+	AlertDialogTrigger,
+	AlertDialogContent,
+	AlertDialogHeader,
+	AlertDialogFooter,
+	AlertDialogTitle,
+	AlertDialogDescription,
+	AlertDialogAction,
+	AlertDialogCancel,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/alert.tsx b/apps/examples/desktop-app/webview/components/ui/alert.tsx
new file mode 100644
index 0000000..ecc8029
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/alert.tsx
@@ -0,0 +1,66 @@
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const alertVariants = cva(
+	"relative w-full rounded-lg border px-4 py-3 text-sm grid has-[>svg]:grid-cols-[calc(var(--spacing)*4)_1fr] grid-cols-[0_1fr] has-[>svg]:gap-x-3 gap-y-0.5 items-start [&>svg]:size-4 [&>svg]:translate-y-0.5 [&>svg]:text-current",
+	{
+		variants: {
+			variant: {
+				default: "bg-card text-card-foreground",
+				destructive:
+					"text-destructive bg-card [&>svg]:text-current *:data-[slot=alert-description]:text-destructive/90",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function Alert({
+	className,
+	variant,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>) {
+	return (
+		<div
+			data-slot="alert"
+			role="alert"
+			className={cn(alertVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-title"
+			className={cn(
+				"col-start-2 line-clamp-1 min-h-4 font-medium tracking-tight",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDescription({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-description"
+			className={cn(
+				"text-muted-foreground col-start-2 grid justify-items-start gap-1 text-sm [&_p]:leading-relaxed",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Alert, AlertTitle, AlertDescription };
diff --git a/apps/examples/desktop-app/webview/components/ui/aspect-ratio.tsx b/apps/examples/desktop-app/webview/components/ui/aspect-ratio.tsx
new file mode 100644
index 0000000..51fa2c6
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/aspect-ratio.tsx
@@ -0,0 +1,11 @@
+"use client";
+
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+
+function AspectRatio({
+	...props
+}: React.ComponentProps<typeof AspectRatioPrimitive.Root>) {
+	return <AspectRatioPrimitive.Root data-slot="aspect-ratio" {...props} />;
+}
+
+export { AspectRatio };
diff --git a/apps/examples/desktop-app/webview/components/ui/aurora-bg.tsx b/apps/examples/desktop-app/webview/components/ui/aurora-bg.tsx
new file mode 100644
index 0000000..dfe12f5
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/aurora-bg.tsx
@@ -0,0 +1,100 @@
+"use client";
+
+import { useMemo } from "react";
+
+interface Star {
+	left: string;
+	top: string;
+	size: number;
+	delay: string;
+	duration: string;
+	opacity: number;
+}
+
+// Big blurred gradient blobs that slowly drift/rotate to fake an aurora.
+// Each entry is [positionClasses, gradient, animationDuration, animationDelay].
+const BLOBS: Array<[string, string, string, string]> = [
+	[
+		"left-[-20%] bottom-[-40%] w-[70%] h-[80%]",
+		"radial-gradient(ellipse at center, oklch(0.55 0.2 278 / 0.55), transparent 70%)",
+		"16s",
+		"0s",
+	],
+	[
+		"left-[25%] bottom-[-50%] w-[60%] h-[90%]",
+		"radial-gradient(ellipse at center, oklch(0.65 0.19 200 / 0.4), transparent 70%)",
+		"22s",
+		"-6s",
+	],
+	[
+		"right-[-15%] bottom-[-40%] w-[65%] h-[85%]",
+		"radial-gradient(ellipse at center, oklch(0.6 0.18 310 / 0.5), transparent 70%)",
+		"19s",
+		"-12s",
+	],
+	[
+		"left-[10%] bottom-[-30%] w-[80%] h-[60%]",
+		"radial-gradient(ellipse at center, oklch(0.75 0.13 340 / 0.35), transparent 70%)",
+		"26s",
+		"-3s",
+	],
+];
+
+/**
+ * A decorative aurora background built entirely from CSS: blurred gradient
+ * blobs drifting on keyframe animations, plus twinkling star dots. No canvas,
+ * no WebGL, no per-frame JS. Absolutely positioned to fill its nearest
+ * positioned parent; pointer events pass through.
+ *
+ * Keyframes (`aurora-drift`, `aurora-twinkle`) live in app/globals.css.
+ */
+export function AuroraBackground({ starCount = 90 }: { starCount?: number }) {
+	// Random star field, generated once per mount.
+	const stars = useMemo<Star[]>(
+		() =>
+			Array.from({ length: starCount }, () => {
+				// Squared skew biases stars toward the bottom, where the glow lives.
+				const r = Math.random();
+				return {
+					left: `${Math.random() * 100}%`,
+					top: `${100 - (1 - r * r) * 45}%`,
+					size: Math.random() < 0.15 ? 3 : Math.random() < 0.5 ? 2 : 1,
+					delay: `${Math.random() * 4}s`,
+					duration: `${1.5 + Math.random() * 3.5}s`,
+					opacity: 0.3 + Math.random() * 0.6,
+				};
+			}),
+		[starCount],
+	);
+
+	return (
+		<div className="pointer-events-none absolute inset-0 overflow-hidden">
+			{BLOBS.map(([position, gradient, duration, delay], idx) => (
+				<div
+					key={`blob${idx}`}
+					className={`absolute blur-3xl animate-[aurora-drift_linear_infinite] ${position}`}
+					style={{
+						background: gradient,
+						animationDuration: duration,
+						animationDelay: delay,
+					}}
+				/>
+			))}
+			{stars.map((s, idx) => (
+				<span
+					key={`star${idx}`}
+					className="absolute rounded-none bg-[#b8f3ee] animate-[aurora-twinkle_ease-in-out_infinite]"
+					style={{
+						left: s.left,
+						top: s.top,
+						width: s.size,
+						height: s.size,
+						opacity: s.opacity,
+						animationDelay: s.delay,
+						animationDuration: s.duration,
+					}}
+				/>
+			))}
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/ui/avatar.tsx b/apps/examples/desktop-app/webview/components/ui/avatar.tsx
new file mode 100644
index 0000000..a03b6cf
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/avatar.tsx
@@ -0,0 +1,53 @@
+"use client";
+
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Avatar({
+	className,
+	...props
+}: React.ComponentProps<typeof AvatarPrimitive.Root>) {
+	return (
+		<AvatarPrimitive.Root
+			data-slot="avatar"
+			className={cn(
+				"relative flex size-8 shrink-0 overflow-hidden rounded-full",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarImage({
+	className,
+	...props
+}: React.ComponentProps<typeof AvatarPrimitive.Image>) {
+	return (
+		<AvatarPrimitive.Image
+			data-slot="avatar-image"
+			className={cn("aspect-square size-full", className)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarFallback({
+	className,
+	...props
+}: React.ComponentProps<typeof AvatarPrimitive.Fallback>) {
+	return (
+		<AvatarPrimitive.Fallback
+			data-slot="avatar-fallback"
+			className={cn(
+				"bg-muted flex size-full items-center justify-center rounded-full",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Avatar, AvatarImage, AvatarFallback };
diff --git a/apps/examples/desktop-app/webview/components/ui/badge.tsx b/apps/examples/desktop-app/webview/components/ui/badge.tsx
new file mode 100644
index 0000000..b2fee25
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/badge.tsx
@@ -0,0 +1,46 @@
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const badgeVariants = cva(
+	"inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden",
+	{
+		variants: {
+			variant: {
+				default:
+					"border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
+				secondary:
+					"border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
+				destructive:
+					"border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+				outline:
+					"text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function Badge({
+	className,
+	variant,
+	asChild = false,
+	...props
+}: React.ComponentProps<"span"> &
+	VariantProps<typeof badgeVariants> & { asChild?: boolean }) {
+	const Comp = asChild ? Slot : "span";
+
+	return (
+		<Comp
+			data-slot="badge"
+			className={cn(badgeVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+}
+
+export { Badge, badgeVariants };
diff --git a/apps/examples/desktop-app/webview/components/ui/breadcrumb.tsx b/apps/examples/desktop-app/webview/components/ui/breadcrumb.tsx
new file mode 100644
index 0000000..e390bd1
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/breadcrumb.tsx
@@ -0,0 +1,107 @@
+import { Slot } from "@radix-ui/react-slot";
+import { ChevronRight, MoreHorizontal } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Breadcrumb({ ...props }: React.ComponentProps<"nav">) {
+	return <nav aria-label="breadcrumb" data-slot="breadcrumb" {...props} />;
+}
+
+function BreadcrumbList({ className, ...props }: React.ComponentProps<"ol">) {
+	return (
+		<ol
+			data-slot="breadcrumb-list"
+			className={cn(
+				"text-muted-foreground flex flex-wrap items-center gap-1.5 text-sm break-words sm:gap-2.5",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function BreadcrumbItem({ className, ...props }: React.ComponentProps<"li">) {
+	return (
+		<li
+			data-slot="breadcrumb-item"
+			className={cn("inline-flex items-center gap-1.5", className)}
+			{...props}
+		/>
+	);
+}
+
+function BreadcrumbLink({
+	asChild,
+	className,
+	...props
+}: React.ComponentProps<"a"> & {
+	asChild?: boolean;
+}) {
+	const Comp = asChild ? Slot : "a";
+
+	return (
+		<Comp
+			data-slot="breadcrumb-link"
+			className={cn("hover:text-foreground transition-colors", className)}
+			{...props}
+		/>
+	);
+}
+
+function BreadcrumbPage({ className, ...props }: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="breadcrumb-page"
+			aria-current="page"
+			className={cn("text-foreground font-normal", className)}
+			{...props}
+		/>
+	);
+}
+
+function BreadcrumbSeparator({
+	children,
+	className,
+	...props
+}: React.ComponentProps<"li">) {
+	return (
+		<li
+			data-slot="breadcrumb-separator"
+			role="presentation"
+			aria-hidden="true"
+			className={cn("[&>svg]:size-3.5", className)}
+			{...props}
+		>
+			{children ?? <ChevronRight />}
+		</li>
+	);
+}
+
+function BreadcrumbEllipsis({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="breadcrumb-ellipsis"
+			role="presentation"
+			aria-hidden="true"
+			className={cn("flex size-9 items-center justify-center", className)}
+			{...props}
+		>
+			<MoreHorizontal className="size-4" />
+			<span className="sr-only">More</span>
+		</span>
+	);
+}
+
+export {
+	Breadcrumb,
+	BreadcrumbList,
+	BreadcrumbItem,
+	BreadcrumbLink,
+	BreadcrumbPage,
+	BreadcrumbSeparator,
+	BreadcrumbEllipsis,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/button-group.tsx b/apps/examples/desktop-app/webview/components/ui/button-group.tsx
new file mode 100644
index 0000000..f6e0374
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/button-group.tsx
@@ -0,0 +1,81 @@
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import { Separator } from "@/components/ui/separator";
+import { cn } from "@/lib/utils";
+
+const buttonGroupVariants = cva(
+	"flex w-fit items-stretch [&>*]:focus-visible:z-10 [&>*]:focus-visible:relative [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-md has-[>[data-slot=button-group]]:gap-2",
+	{
+		variants: {
+			orientation: {
+				horizontal:
+					"[&>*:not(:first-child)]:rounded-l-none [&>*:not(:first-child)]:border-l-0 [&>*:not(:last-child)]:rounded-r-none",
+				vertical:
+					"flex-col [&>*:not(:first-child)]:rounded-t-none [&>*:not(:first-child)]:border-t-0 [&>*:not(:last-child)]:rounded-b-none",
+			},
+		},
+		defaultVariants: {
+			orientation: "horizontal",
+		},
+	},
+);
+
+function ButtonGroup({
+	className,
+	orientation,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
+	return (
+		<div
+			data-slot="button-group"
+			data-orientation={orientation}
+			className={cn(buttonGroupVariants({ orientation }), className)}
+			{...props}
+		/>
+	);
+}
+
+function ButtonGroupText({
+	className,
+	asChild = false,
+	...props
+}: React.ComponentProps<"div"> & {
+	asChild?: boolean;
+}) {
+	const Comp = asChild ? Slot : "div";
+
+	return (
+		<Comp
+			className={cn(
+				"bg-muted flex items-center gap-2 rounded-md border px-4 text-sm font-medium shadow-xs [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ButtonGroupSeparator({
+	className,
+	orientation = "vertical",
+	...props
+}: React.ComponentProps<typeof Separator>) {
+	return (
+		<Separator
+			data-slot="button-group-separator"
+			orientation={orientation}
+			className={cn(
+				"bg-input relative !m-0 self-stretch data-[orientation=vertical]:h-auto",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	ButtonGroup,
+	ButtonGroupSeparator,
+	ButtonGroupText,
+	buttonGroupVariants,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/button.tsx b/apps/examples/desktop-app/webview/components/ui/button.tsx
new file mode 100644
index 0000000..3bdea33
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/button.tsx
@@ -0,0 +1,67 @@
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const buttonVariants = cva(
+	"inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md font-medium transition-all cursor-pointer disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-3 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+	{
+		variants: {
+			variant: {
+				default: "bg-primary text-primary-foreground hover:bg-primary/90",
+				destructive:
+					"bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+				outline:
+					"border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+				secondary:
+					"bg-secondary text-secondary-foreground hover:bg-secondary/80",
+				ghost:
+					"hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+				link: "text-primary underline-offset-4 hover:underline",
+				sidebar:
+					"w-full text-left gap-2 rounded-none text-sm font-medium text-muted-foreground transition-colors hover:bg-sidebar-accent hover:text-sidebar-foreground self-start",
+				sidebarItem:
+					"!h-auto w-full justify-start text-left gap-2 rounded-md px-3 py-2 text-sm font-medium text-muted-foreground transition-colors hover:bg-sidebar-accent hover:text-sidebar-foreground",
+				sidebarText:
+					"!h-auto justify-start gap-1 px-3 py-1.5 text-xs font-medium text-muted-foreground transition-colors hover:text-sidebar-foreground",
+			},
+			size: {
+				default: "h-9 px-4 py-2 has-[>svg]:px-3",
+				sm: "h-8 gap-1.5 px-3 has-[>svg]:px-2.5",
+				xs: "h-3 gap-1.5 px-3 has-[>svg]:size-3",
+				lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+				icon: "size-5",
+				"icon-sm": "size-3 p-1",
+				"icon-lg": "size-10",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+);
+
+function Button({
+	className,
+	variant,
+	size,
+	asChild = false,
+	...props
+}: React.ComponentProps<"button"> &
+	VariantProps<typeof buttonVariants> & {
+		asChild?: boolean;
+	}) {
+	const Comp = asChild ? Slot : "button";
+
+	return (
+		<Comp
+			className={cn(buttonVariants({ variant, size, className }))}
+			data-slot="button"
+			{...props}
+		/>
+	);
+}
+
+export { Button, buttonVariants };
diff --git a/apps/examples/desktop-app/webview/components/ui/calendar.tsx b/apps/examples/desktop-app/webview/components/ui/calendar.tsx
new file mode 100644
index 0000000..56f788c
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/calendar.tsx
@@ -0,0 +1,216 @@
+"use client";
+
+import {
+	ChevronDownIcon,
+	ChevronLeftIcon,
+	ChevronRightIcon,
+} from "lucide-react";
+import * as React from "react";
+import {
+	type DayButton,
+	DayPicker,
+	getDefaultClassNames,
+} from "react-day-picker";
+import { Button, buttonVariants } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function Calendar({
+	className,
+	classNames,
+	showOutsideDays = true,
+	captionLayout = "label",
+	buttonVariant = "ghost",
+	formatters,
+	components,
+	...props
+}: React.ComponentProps<typeof DayPicker> & {
+	buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+}) {
+	const defaultClassNames = getDefaultClassNames();
+
+	return (
+		<DayPicker
+			showOutsideDays={showOutsideDays}
+			className={cn(
+				"bg-background group/calendar p-3 [--cell-size:--spacing(8)] [[data-slot=card-content]_&]:bg-transparent [[data-slot=popover-content]_&]:bg-transparent",
+				String.raw`rtl:**:[.rdp-button\_next>svg]:rotate-180`,
+				String.raw`rtl:**:[.rdp-button\_previous>svg]:rotate-180`,
+				className,
+			)}
+			captionLayout={captionLayout}
+			formatters={{
+				formatMonthDropdown: (date) =>
+					date.toLocaleString("default", { month: "short" }),
+				...formatters,
+			}}
+			classNames={{
+				root: cn("w-fit", defaultClassNames.root),
+				months: cn(
+					"flex gap-4 flex-col md:flex-row relative",
+					defaultClassNames.months,
+				),
+				month: cn("flex flex-col w-full gap-4", defaultClassNames.month),
+				nav: cn(
+					"flex items-center gap-1 w-full absolute top-0 inset-x-0 justify-between",
+					defaultClassNames.nav,
+				),
+				button_previous: cn(
+					buttonVariants({ variant: buttonVariant }),
+					"size-(--cell-size) aria-disabled:opacity-50 p-0 select-none",
+					defaultClassNames.button_previous,
+				),
+				button_next: cn(
+					buttonVariants({ variant: buttonVariant }),
+					"size-(--cell-size) aria-disabled:opacity-50 p-0 select-none",
+					defaultClassNames.button_next,
+				),
+				month_caption: cn(
+					"flex items-center justify-center h-(--cell-size) w-full px-(--cell-size)",
+					defaultClassNames.month_caption,
+				),
+				dropdowns: cn(
+					"w-full flex items-center text-sm font-medium justify-center h-(--cell-size) gap-1.5",
+					defaultClassNames.dropdowns,
+				),
+				dropdown_root: cn(
+					"relative has-focus:border-ring border border-input shadow-xs has-focus:ring-ring/50 has-focus:ring-[3px] rounded-md",
+					defaultClassNames.dropdown_root,
+				),
+				dropdown: cn(
+					"absolute bg-popover inset-0 opacity-0",
+					defaultClassNames.dropdown,
+				),
+				caption_label: cn(
+					"select-none font-medium",
+					captionLayout === "label"
+						? "text-sm"
+						: "rounded-md pl-2 pr-1 flex items-center gap-1 text-sm h-8 [&>svg]:text-muted-foreground [&>svg]:size-3.5",
+					defaultClassNames.caption_label,
+				),
+				table: "w-full border-collapse",
+				weekdays: cn("flex", defaultClassNames.weekdays),
+				weekday: cn(
+					"text-muted-foreground rounded-md flex-1 font-normal text-[0.8rem] select-none",
+					defaultClassNames.weekday,
+				),
+				week: cn("flex w-full mt-2", defaultClassNames.week),
+				week_number_header: cn(
+					"select-none w-(--cell-size)",
+					defaultClassNames.week_number_header,
+				),
+				week_number: cn(
+					"text-[0.8rem] select-none text-muted-foreground",
+					defaultClassNames.week_number,
+				),
+				day: cn(
+					"relative w-full h-full p-0 text-center [&:first-child[data-selected=true]_button]:rounded-l-md [&:last-child[data-selected=true]_button]:rounded-r-md group/day aspect-square select-none",
+					defaultClassNames.day,
+				),
+				range_start: cn(
+					"rounded-l-md bg-accent",
+					defaultClassNames.range_start,
+				),
+				range_middle: cn("rounded-none", defaultClassNames.range_middle),
+				range_end: cn("rounded-r-md bg-accent", defaultClassNames.range_end),
+				today: cn(
+					"bg-accent text-accent-foreground rounded-md data-[selected=true]:rounded-none",
+					defaultClassNames.today,
+				),
+				outside: cn(
+					"text-muted-foreground aria-selected:text-muted-foreground",
+					defaultClassNames.outside,
+				),
+				disabled: cn(
+					"text-muted-foreground opacity-50",
+					defaultClassNames.disabled,
+				),
+				hidden: cn("invisible", defaultClassNames.hidden),
+				...classNames,
+			}}
+			components={{
+				Root: ({ className, rootRef, ...props }) => {
+					return (
+						<div
+							data-slot="calendar"
+							ref={rootRef}
+							className={cn(className)}
+							{...props}
+						/>
+					);
+				},
+				Chevron: ({ className, orientation, ...props }) => {
+					if (orientation === "left") {
+						return (
+							<ChevronLeftIcon className={cn("size-4", className)} {...props} />
+						);
+					}
+
+					if (orientation === "right") {
+						return (
+							<ChevronRightIcon
+								className={cn("size-4", className)}
+								{...props}
+							/>
+						);
+					}
+
+					return (
+						<ChevronDownIcon className={cn("size-4", className)} {...props} />
+					);
+				},
+				DayButton: CalendarDayButton,
+				WeekNumber: ({ children, ...props }) => {
+					return (
+						<td {...props}>
+							<div className="flex size-(--cell-size) items-center justify-center text-center">
+								{children}
+							</div>
+						</td>
+					);
+				},
+				...components,
+			}}
+			{...props}
+		/>
+	);
+}
+
+function CalendarDayButton({
+	className,
+	day,
+	modifiers,
+	...props
+}: React.ComponentProps<typeof DayButton>) {
+	const defaultClassNames = getDefaultClassNames();
+
+	const ref = React.useRef<HTMLButtonElement>(null);
+	React.useEffect(() => {
+		if (modifiers.focused) ref.current?.focus();
+	}, [modifiers.focused]);
+
+	return (
+		<Button
+			ref={ref}
+			variant="ghost"
+			size="icon"
+			data-day={day.date.toLocaleDateString()}
+			data-selected-single={
+				modifiers.selected &&
+				!modifiers.range_start &&
+				!modifiers.range_end &&
+				!modifiers.range_middle
+			}
+			data-range-start={modifiers.range_start}
+			data-range-end={modifiers.range_end}
+			data-range-middle={modifiers.range_middle}
+			className={cn(
+				"data-[selected-single=true]:bg-primary data-[selected-single=true]:text-primary-foreground data-[range-middle=true]:bg-accent data-[range-middle=true]:text-accent-foreground data-[range-start=true]:bg-primary data-[range-start=true]:text-primary-foreground data-[range-end=true]:bg-primary data-[range-end=true]:text-primary-foreground group-data-[focused=true]/day:border-ring group-data-[focused=true]/day:ring-ring/50 dark:hover:text-accent-foreground flex aspect-square size-auto w-full min-w-(--cell-size) flex-col gap-1 leading-none font-normal group-data-[focused=true]/day:relative group-data-[focused=true]/day:z-10 group-data-[focused=true]/day:ring-[3px] data-[range-end=true]:rounded-md data-[range-end=true]:rounded-r-md data-[range-middle=true]:rounded-none data-[range-start=true]:rounded-md data-[range-start=true]:rounded-l-md [&>span]:text-xs [&>span]:opacity-70",
+				defaultClassNames.day,
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Calendar, CalendarDayButton };
diff --git a/apps/examples/desktop-app/webview/components/ui/card.tsx b/apps/examples/desktop-app/webview/components/ui/card.tsx
new file mode 100644
index 0000000..fe7ed64
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/card.tsx
@@ -0,0 +1,92 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Card({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card"
+			className={cn(
+				"bg-card text-card-foreground flex flex-col gap-6 rounded-xl border py-6 shadow-sm",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-header"
+			className={cn(
+				"@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-2 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-title"
+			className={cn("leading-none font-semibold", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-description"
+			className={cn("text-muted-foreground text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-action"
+			className={cn(
+				"col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-content"
+			className={cn("px-6", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-footer"
+			className={cn("flex items-center px-6 [.border-t]:pt-6", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Card,
+	CardHeader,
+	CardFooter,
+	CardTitle,
+	CardAction,
+	CardDescription,
+	CardContent,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/carousel.tsx b/apps/examples/desktop-app/webview/components/ui/carousel.tsx
new file mode 100644
index 0000000..24a726d
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/carousel.tsx
@@ -0,0 +1,236 @@
+"use client";
+
+import useEmblaCarousel, {
+	type UseEmblaCarouselType,
+} from "embla-carousel-react";
+import { ArrowLeft, ArrowRight } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+
+type CarouselProps = {
+	opts?: CarouselOptions;
+	plugins?: CarouselPlugin;
+	orientation?: "horizontal" | "vertical";
+	setApi?: (api: CarouselApi) => void;
+};
+
+type CarouselContextProps = {
+	carouselRef: ReturnType<typeof useEmblaCarousel>[0];
+	api: ReturnType<typeof useEmblaCarousel>[1];
+	scrollPrev: () => void;
+	scrollNext: () => void;
+	canScrollPrev: boolean;
+	canScrollNext: boolean;
+} & CarouselProps;
+
+const CarouselContext = React.createContext<CarouselContextProps | null>(null);
+
+function useCarousel() {
+	const context = React.useContext(CarouselContext);
+
+	if (!context) {
+		throw new Error("useCarousel must be used within a <Carousel />");
+	}
+
+	return context;
+}
+
+function Carousel({
+	orientation = "horizontal",
+	opts,
+	setApi,
+	plugins,
+	className,
+	children,
+	...props
+}: React.ComponentProps<"section"> & CarouselProps) {
+	const [carouselRef, api] = useEmblaCarousel(
+		{
+			...opts,
+			axis: orientation === "horizontal" ? "x" : "y",
+		},
+		plugins,
+	);
+	const [canScrollPrev, setCanScrollPrev] = React.useState(false);
+	const [canScrollNext, setCanScrollNext] = React.useState(false);
+
+	const onSelect = React.useCallback((api: CarouselApi) => {
+		if (!api) return;
+		setCanScrollPrev(api.canScrollPrev());
+		setCanScrollNext(api.canScrollNext());
+	}, []);
+
+	const scrollPrev = React.useCallback(() => {
+		api?.scrollPrev();
+	}, [api]);
+
+	const scrollNext = React.useCallback(() => {
+		api?.scrollNext();
+	}, [api]);
+
+	const handleKeyDown = React.useCallback(
+		(event: React.KeyboardEvent<HTMLElement>) => {
+			if (event.key === "ArrowLeft") {
+				event.preventDefault();
+				scrollPrev();
+			} else if (event.key === "ArrowRight") {
+				event.preventDefault();
+				scrollNext();
+			}
+		},
+		[scrollPrev, scrollNext],
+	);
+
+	React.useEffect(() => {
+		if (!api || !setApi) return;
+		setApi(api);
+	}, [api, setApi]);
+
+	React.useEffect(() => {
+		if (!api) return;
+		onSelect(api);
+		api.on("reInit", onSelect);
+		api.on("select", onSelect);
+
+		return () => {
+			api?.off("select", onSelect);
+		};
+	}, [api, onSelect]);
+
+	return (
+		<CarouselContext.Provider
+			value={{
+				carouselRef,
+				api: api,
+				opts,
+				orientation:
+					orientation || (opts?.axis === "y" ? "vertical" : "horizontal"),
+				scrollPrev,
+				scrollNext,
+				canScrollPrev,
+				canScrollNext,
+			}}
+		>
+			<section
+				onKeyDownCapture={handleKeyDown}
+				className={cn("relative", className)}
+				data-slot="carousel"
+				{...props}
+			>
+				{children}
+			</section>
+		</CarouselContext.Provider>
+	);
+}
+
+function CarouselContent({ className, ...props }: React.ComponentProps<"div">) {
+	const { carouselRef, orientation } = useCarousel();
+
+	return (
+		<div
+			ref={carouselRef}
+			className="overflow-hidden"
+			data-slot="carousel-content"
+		>
+			<div
+				className={cn(
+					"flex",
+					orientation === "horizontal" ? "-ml-4" : "-mt-4 flex-col",
+					className,
+				)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function CarouselItem({ className, ...props }: React.ComponentProps<"div">) {
+	const { orientation } = useCarousel();
+
+	return (
+		<div
+			data-slot="carousel-item"
+			className={cn(
+				"min-w-0 shrink-0 grow-0 basis-full",
+				orientation === "horizontal" ? "pl-4" : "pt-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CarouselPrevious({
+	className,
+	variant = "outline",
+	size = "icon",
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { orientation, scrollPrev, canScrollPrev } = useCarousel();
+
+	return (
+		<Button
+			data-slot="carousel-previous"
+			variant={variant}
+			size={size}
+			className={cn(
+				"absolute size-8 rounded-full",
+				orientation === "horizontal"
+					? "top-1/2 -left-12 -translate-y-1/2"
+					: "-top-12 left-1/2 -translate-x-1/2 rotate-90",
+				className,
+			)}
+			disabled={!canScrollPrev}
+			onClick={scrollPrev}
+			{...props}
+		>
+			<ArrowLeft />
+			<span className="sr-only">Previous slide</span>
+		</Button>
+	);
+}
+
+function CarouselNext({
+	className,
+	variant = "outline",
+	size = "icon",
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { orientation, scrollNext, canScrollNext } = useCarousel();
+
+	return (
+		<Button
+			data-slot="carousel-next"
+			variant={variant}
+			size={size}
+			className={cn(
+				"absolute size-8 rounded-full",
+				orientation === "horizontal"
+					? "top-1/2 -right-12 -translate-y-1/2"
+					: "-bottom-12 left-1/2 -translate-x-1/2 rotate-90",
+				className,
+			)}
+			disabled={!canScrollNext}
+			onClick={scrollNext}
+			{...props}
+		>
+			<ArrowRight />
+			<span className="sr-only">Next slide</span>
+		</Button>
+	);
+}
+
+export {
+	type CarouselApi,
+	Carousel,
+	CarouselContent,
+	CarouselItem,
+	CarouselPrevious,
+	CarouselNext,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/chart.tsx b/apps/examples/desktop-app/webview/components/ui/chart.tsx
new file mode 100644
index 0000000..54ccccf
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/chart.tsx
@@ -0,0 +1,349 @@
+"use client";
+
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+
+import { cn } from "@/lib/utils";
+
+// Format: { THEME_NAME: CSS_SELECTOR }
+const THEMES = { light: "", dark: ".dark" } as const;
+
+export type ChartConfig = {
+	[k in string]: {
+		label?: React.ReactNode;
+		icon?: React.ComponentType;
+	} & (
+		| { color?: string; theme?: never }
+		| { color?: never; theme: Record<keyof typeof THEMES, string> }
+	);
+};
+
+type ChartContextProps = {
+	config: ChartConfig;
+};
+
+const ChartContext = React.createContext<ChartContextProps | null>(null);
+
+function useChart() {
+	const context = React.useContext(ChartContext);
+
+	if (!context) {
+		throw new Error("useChart must be used within a <ChartContainer />");
+	}
+
+	return context;
+}
+
+function ChartContainer({
+	id,
+	className,
+	children,
+	config,
+	...props
+}: React.ComponentProps<"div"> & {
+	config: ChartConfig;
+	children: React.ComponentProps<
+		typeof RechartsPrimitive.ResponsiveContainer
+	>["children"];
+}) {
+	const uniqueId = React.useId();
+	const chartId = `chart-${id || uniqueId.replace(/:/g, "")}`;
+
+	return (
+		<ChartContext.Provider value={{ config }}>
+			<div
+				data-slot="chart"
+				data-chart={chartId}
+				className={cn(
+					"[&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border flex aspect-video justify-center text-xs [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-hidden [&_.recharts-sector]:outline-hidden [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-surface]:outline-hidden",
+					className,
+				)}
+				{...props}
+			>
+				<ChartStyle id={chartId} config={config} />
+				<RechartsPrimitive.ResponsiveContainer>
+					{children}
+				</RechartsPrimitive.ResponsiveContainer>
+			</div>
+		</ChartContext.Provider>
+	);
+}
+
+const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
+	const colorConfig = Object.entries(config).filter(
+		([, config]) => config.theme || config.color,
+	);
+
+	if (!colorConfig.length) {
+		return null;
+	}
+
+	const cssText = Object.entries(THEMES)
+		.map(
+			([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig
+	.map(([key, itemConfig]) => {
+		const color =
+			itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
+			itemConfig.color;
+		return color ? `  --color-${key}: ${color};` : null;
+	})
+	.join("\n")}
+}
+`,
+		)
+		.join("\n");
+
+	return <style>{cssText}</style>;
+};
+
+const ChartTooltip = RechartsPrimitive.Tooltip;
+
+function ChartTooltipContent({
+	active,
+	payload,
+	className,
+	indicator = "dot",
+	hideLabel = false,
+	hideIndicator = false,
+	label,
+	labelFormatter,
+	labelClassName,
+	formatter,
+	color,
+	nameKey,
+	labelKey,
+}: React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
+	React.ComponentProps<"div"> & {
+		hideLabel?: boolean;
+		hideIndicator?: boolean;
+		indicator?: "line" | "dot" | "dashed";
+		nameKey?: string;
+		labelKey?: string;
+	}) {
+	const { config } = useChart();
+
+	const tooltipLabel = React.useMemo(() => {
+		if (hideLabel || !payload?.length) {
+			return null;
+		}
+
+		const [item] = payload;
+		const key = `${labelKey || item?.dataKey || item?.name || "value"}`;
+		const itemConfig = getPayloadConfigFromPayload(config, item, key);
+		const value =
+			!labelKey && typeof label === "string"
+				? config[label as keyof typeof config]?.label || label
+				: itemConfig?.label;
+
+		if (labelFormatter) {
+			return (
+				<div className={cn("font-medium", labelClassName)}>
+					{labelFormatter(value, payload)}
+				</div>
+			);
+		}
+
+		if (!value) {
+			return null;
+		}
+
+		return <div className={cn("font-medium", labelClassName)}>{value}</div>;
+	}, [
+		label,
+		labelFormatter,
+		payload,
+		hideLabel,
+		labelClassName,
+		config,
+		labelKey,
+	]);
+
+	if (!active || !payload?.length) {
+		return null;
+	}
+
+	const nestLabel = payload.length === 1 && indicator !== "dot";
+
+	return (
+		<div
+			className={cn(
+				"border-border/50 bg-background grid min-w-[8rem] items-start gap-1.5 rounded-lg border px-2.5 py-1.5 text-xs shadow-xl",
+				className,
+			)}
+		>
+			{!nestLabel ? tooltipLabel : null}
+			<div className="grid gap-1.5">
+				{payload.map((item, index) => {
+					const key = `${nameKey || item.name || item.dataKey || "value"}`;
+					const itemConfig = getPayloadConfigFromPayload(config, item, key);
+					const indicatorColor = color || item.payload.fill || item.color;
+
+					return (
+						<div
+							key={item.dataKey}
+							className={cn(
+								"[&>svg]:text-muted-foreground flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5",
+								indicator === "dot" && "items-center",
+							)}
+						>
+							{formatter && item?.value !== undefined && item.name ? (
+								formatter(item.value, item.name, item, index, item.payload)
+							) : (
+								<>
+									{itemConfig?.icon ? (
+										<itemConfig.icon />
+									) : (
+										!hideIndicator && (
+											<div
+												className={cn(
+													"shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)",
+													{
+														"h-2.5 w-2.5": indicator === "dot",
+														"w-1": indicator === "line",
+														"w-0 border-[1.5px] border-dashed bg-transparent":
+															indicator === "dashed",
+														"my-0.5": nestLabel && indicator === "dashed",
+													},
+												)}
+												style={
+													{
+														"--color-bg": indicatorColor,
+														"--color-border": indicatorColor,
+													} as React.CSSProperties
+												}
+											/>
+										)
+									)}
+									<div
+										className={cn(
+											"flex flex-1 justify-between leading-none",
+											nestLabel ? "items-end" : "items-center",
+										)}
+									>
+										<div className="grid gap-1.5">
+											{nestLabel ? tooltipLabel : null}
+											<span className="text-muted-foreground">
+												{itemConfig?.label || item.name}
+											</span>
+										</div>
+										{item.value && (
+											<span className="text-foreground font-mono font-medium tabular-nums">
+												{item.value.toLocaleString()}
+											</span>
+										)}
+									</div>
+								</>
+							)}
+						</div>
+					);
+				})}
+			</div>
+		</div>
+	);
+}
+
+const ChartLegend = RechartsPrimitive.Legend;
+
+function ChartLegendContent({
+	className,
+	hideIcon = false,
+	payload,
+	verticalAlign = "bottom",
+	nameKey,
+}: React.ComponentProps<"div"> &
+	Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+		hideIcon?: boolean;
+		nameKey?: string;
+	}) {
+	const { config } = useChart();
+
+	if (!payload?.length) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn(
+				"flex items-center justify-center gap-4",
+				verticalAlign === "top" ? "pb-3" : "pt-3",
+				className,
+			)}
+		>
+			{payload.map((item) => {
+				const key = `${nameKey || item.dataKey || "value"}`;
+				const itemConfig = getPayloadConfigFromPayload(config, item, key);
+
+				return (
+					<div
+						key={item.value}
+						className={
+							"[&>svg]:text-muted-foreground flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3"
+						}
+					>
+						{itemConfig?.icon && !hideIcon ? (
+							<itemConfig.icon />
+						) : (
+							<div
+								className="h-2 w-2 shrink-0 rounded-[2px]"
+								style={{
+									backgroundColor: item.color,
+								}}
+							/>
+						)}
+						{itemConfig?.label}
+					</div>
+				);
+			})}
+		</div>
+	);
+}
+
+// Helper to extract item config from a payload.
+function getPayloadConfigFromPayload(
+	config: ChartConfig,
+	payload: unknown,
+	key: string,
+) {
+	if (typeof payload !== "object" || payload === null) {
+		return undefined;
+	}
+
+	const payloadPayload =
+		"payload" in payload &&
+		typeof payload.payload === "object" &&
+		payload.payload !== null
+			? payload.payload
+			: undefined;
+
+	let configLabelKey: string = key;
+
+	if (
+		key in payload &&
+		typeof payload[key as keyof typeof payload] === "string"
+	) {
+		configLabelKey = payload[key as keyof typeof payload] as string;
+	} else if (
+		payloadPayload &&
+		key in payloadPayload &&
+		typeof payloadPayload[key as keyof typeof payloadPayload] === "string"
+	) {
+		configLabelKey = payloadPayload[
+			key as keyof typeof payloadPayload
+		] as string;
+	}
+
+	return configLabelKey in config
+		? config[configLabelKey]
+		: config[key as keyof typeof config];
+}
+
+export {
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+	ChartLegend,
+	ChartLegendContent,
+	ChartStyle,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/checkbox.tsx b/apps/examples/desktop-app/webview/components/ui/checkbox.tsx
new file mode 100644
index 0000000..8f1b7b1
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/checkbox.tsx
@@ -0,0 +1,32 @@
+"use client";
+
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import { CheckIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Checkbox({
+	className,
+	...props
+}: React.ComponentProps<typeof CheckboxPrimitive.Root>) {
+	return (
+		<CheckboxPrimitive.Root
+			data-slot="checkbox"
+			className={cn(
+				"peer border-input dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		>
+			<CheckboxPrimitive.Indicator
+				data-slot="checkbox-indicator"
+				className="flex items-center justify-center text-current transition-none"
+			>
+				<CheckIcon className="size-3.5" />
+			</CheckboxPrimitive.Indicator>
+		</CheckboxPrimitive.Root>
+	);
+}
+
+export { Checkbox };
diff --git a/apps/examples/desktop-app/webview/components/ui/collapsible.tsx b/apps/examples/desktop-app/webview/components/ui/collapsible.tsx
new file mode 100644
index 0000000..0551ffd
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/collapsible.tsx
@@ -0,0 +1,33 @@
+"use client";
+
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+
+function Collapsible({
+	...props
+}: React.ComponentProps<typeof CollapsiblePrimitive.Root>) {
+	return <CollapsiblePrimitive.Root data-slot="collapsible" {...props} />;
+}
+
+function CollapsibleTrigger({
+	...props
+}: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>) {
+	return (
+		<CollapsiblePrimitive.CollapsibleTrigger
+			data-slot="collapsible-trigger"
+			{...props}
+		/>
+	);
+}
+
+function CollapsibleContent({
+	...props
+}: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>) {
+	return (
+		<CollapsiblePrimitive.CollapsibleContent
+			data-slot="collapsible-content"
+			{...props}
+		/>
+	);
+}
+
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };
diff --git a/apps/examples/desktop-app/webview/components/ui/combobox.tsx b/apps/examples/desktop-app/webview/components/ui/combobox.tsx
new file mode 100644
index 0000000..f0a6ce4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/combobox.tsx
@@ -0,0 +1,309 @@
+"use client";
+
+import { Combobox as ComboboxPrimitive } from "@base-ui/react";
+import { CheckIcon, ChevronDownIcon, XIcon } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupInput,
+} from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+const Combobox = ComboboxPrimitive.Root;
+
+function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props) {
+	return <ComboboxPrimitive.Value data-slot="combobox-value" {...props} />;
+}
+
+function ComboboxTrigger({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Trigger.Props) {
+	return (
+		<ComboboxPrimitive.Trigger
+			className={cn("[&_svg:not([class*='size-'])]:size-4", className)}
+			data-slot="combobox-trigger"
+			{...props}
+		>
+			{children}
+			<ChevronDownIcon
+				className="text-muted-foreground pointer-events-none size-4"
+				data-slot="combobox-trigger-icon"
+			/>
+		</ComboboxPrimitive.Trigger>
+	);
+}
+
+function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props) {
+	return (
+		<ComboboxPrimitive.Clear
+			className={cn(className)}
+			data-slot="combobox-clear"
+			render={<InputGroupButton size="icon-xs" variant="ghost" />}
+			{...props}
+		>
+			<XIcon className="pointer-events-none" />
+		</ComboboxPrimitive.Clear>
+	);
+}
+
+function ComboboxInput({
+	className,
+	children,
+	disabled = false,
+	showTrigger = true,
+	showClear = false,
+	...props
+}: ComboboxPrimitive.Input.Props & {
+	showTrigger?: boolean;
+	showClear?: boolean;
+}) {
+	return (
+		<InputGroup className={cn("w-auto", className)}>
+			<ComboboxPrimitive.Input
+				render={<InputGroupInput disabled={disabled} />}
+				{...props}
+			/>
+			<InputGroupAddon align="inline-end">
+				{showTrigger && (
+					<InputGroupButton
+						asChild
+						className="group-has-data-[slot=combobox-clear]/input-group:hidden data-pressed:bg-transparent"
+						data-slot="input-group-button"
+						disabled={disabled}
+						size="icon-xs"
+						variant="ghost"
+					>
+						<ComboboxTrigger />
+					</InputGroupButton>
+				)}
+				{showClear && <ComboboxClear disabled={disabled} />}
+			</InputGroupAddon>
+			{children}
+		</InputGroup>
+	);
+}
+
+function ComboboxContent({
+	className,
+	side = "bottom",
+	sideOffset = 6,
+	align = "start",
+	alignOffset = 0,
+	anchor,
+	...props
+}: ComboboxPrimitive.Popup.Props &
+	Pick<
+		ComboboxPrimitive.Positioner.Props,
+		"side" | "align" | "sideOffset" | "alignOffset" | "anchor"
+	>) {
+	return (
+		<ComboboxPrimitive.Portal>
+			<ComboboxPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				anchor={anchor}
+				className="isolate z-50"
+				side={side}
+				sideOffset={sideOffset}
+			>
+				<ComboboxPrimitive.Popup
+					className={cn(
+						"bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 *:data-[slot=input-group]:bg-input/30 *:data-[slot=input-group]:border-input/30 group/combobox-content relative max-h-96 w-(--anchor-width) max-w-(--available-width) min-w-[calc(var(--anchor-width)+--spacing(7))] origin-(--transform-origin) overflow-hidden rounded-md shadow-md ring-1 duration-100 data-[chips=true]:min-w-(--anchor-width) *:data-[slot=input-group]:m-1 *:data-[slot=input-group]:mb-0 *:data-[slot=input-group]:h-8 *:data-[slot=input-group]:shadow-none",
+						className,
+					)}
+					data-chips={!!anchor}
+					data-slot="combobox-content"
+					{...props}
+				/>
+			</ComboboxPrimitive.Positioner>
+		</ComboboxPrimitive.Portal>
+	);
+}
+
+function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props) {
+	return (
+		<ComboboxPrimitive.List
+			className={cn(
+				"max-h-[min(calc(--spacing(96)---spacing(9)),calc(var(--available-height)---spacing(9)))] scroll-py-1 overflow-y-auto p-1 data-empty:p-0",
+				className,
+			)}
+			data-slot="combobox-list"
+			{...props}
+		/>
+	);
+}
+
+function ComboboxItem({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Item.Props) {
+	return (
+		<ComboboxPrimitive.Item
+			className={cn(
+				"data-highlighted:bg-accent data-highlighted:text-accent-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			data-slot="combobox-item"
+			{...props}
+		>
+			{children}
+			<ComboboxPrimitive.ItemIndicator
+				data-slot="combobox-item-indicator"
+				render={
+					<span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
+				}
+			>
+				<CheckIcon className="pointer-events-none size-4 pointer-coarse:size-5" />
+			</ComboboxPrimitive.ItemIndicator>
+		</ComboboxPrimitive.Item>
+	);
+}
+
+function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props) {
+	return (
+		<ComboboxPrimitive.Group
+			className={cn(className)}
+			data-slot="combobox-group"
+			{...props}
+		/>
+	);
+}
+
+function ComboboxLabel({
+	className,
+	...props
+}: ComboboxPrimitive.GroupLabel.Props) {
+	return (
+		<ComboboxPrimitive.GroupLabel
+			className={cn(
+				"text-muted-foreground px-2 py-1.5 text-xs pointer-coarse:px-3 pointer-coarse:py-2 pointer-coarse:text-sm",
+				className,
+			)}
+			data-slot="combobox-label"
+			{...props}
+		/>
+	);
+}
+
+function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props) {
+	return (
+		<ComboboxPrimitive.Collection data-slot="combobox-collection" {...props} />
+	);
+}
+
+function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props) {
+	return (
+		<ComboboxPrimitive.Empty
+			className={cn(
+				"text-muted-foreground hidden w-full justify-center py-2 text-center text-sm group-data-empty/combobox-content:flex",
+				className,
+			)}
+			data-slot="combobox-empty"
+			{...props}
+		/>
+	);
+}
+
+function ComboboxSeparator({
+	className,
+	...props
+}: ComboboxPrimitive.Separator.Props) {
+	return (
+		<ComboboxPrimitive.Separator
+			className={cn("bg-border -mx-1 my-1 h-px", className)}
+			data-slot="combobox-separator"
+			{...props}
+		/>
+	);
+}
+
+function ComboboxChips({
+	className,
+	...props
+}: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> &
+	ComboboxPrimitive.Chips.Props) {
+	return (
+		<ComboboxPrimitive.Chips
+			className={cn(
+				"dark:bg-input/30 border-input focus-within:border-ring focus-within:ring-ring/50 has-aria-invalid:ring-destructive/20 dark:has-aria-invalid:ring-destructive/40 has-aria-invalid:border-destructive dark:has-aria-invalid:border-destructive/50 flex min-h-9 flex-wrap items-center gap-1.5 rounded-md border bg-transparent bg-clip-padding px-2.5 py-1.5 text-sm shadow-xs transition-[color,box-shadow] focus-within:ring-[3px] has-aria-invalid:ring-[3px] has-data-[slot=combobox-chip]:px-1.5",
+				className,
+			)}
+			data-slot="combobox-chips"
+			{...props}
+		/>
+	);
+}
+
+function ComboboxChip({
+	className,
+	children,
+	showRemove = true,
+	...props
+}: ComboboxPrimitive.Chip.Props & {
+	showRemove?: boolean;
+}) {
+	return (
+		<ComboboxPrimitive.Chip
+			className={cn(
+				"bg-muted text-foreground flex h-[calc(--spacing(5.5))] w-fit items-center justify-center gap-1 rounded-sm px-1.5 text-xs font-medium whitespace-nowrap has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50 has-data-[slot=combobox-chip-remove]:pr-0",
+				className,
+			)}
+			data-slot="combobox-chip"
+			{...props}
+		>
+			{children}
+			{showRemove && (
+				<ComboboxPrimitive.ChipRemove
+					className="-ml-1 opacity-50 hover:opacity-100"
+					data-slot="combobox-chip-remove"
+					render={<Button size="icon-sm" variant="ghost" />}
+				>
+					<XIcon className="pointer-events-none" />
+				</ComboboxPrimitive.ChipRemove>
+			)}
+		</ComboboxPrimitive.Chip>
+	);
+}
+
+function ComboboxChipsInput({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Input.Props) {
+	return (
+		<ComboboxPrimitive.Input
+			className={cn("min-w-16 flex-1 outline-none", className)}
+			data-slot="combobox-chip-input"
+			{...props}
+		/>
+	);
+}
+
+function useComboboxAnchor() {
+	return React.useRef<HTMLDivElement | null>(null);
+}
+
+export {
+	Combobox,
+	ComboboxInput,
+	ComboboxContent,
+	ComboboxList,
+	ComboboxItem,
+	ComboboxGroup,
+	ComboboxLabel,
+	ComboboxCollection,
+	ComboboxEmpty,
+	ComboboxSeparator,
+	ComboboxChips,
+	ComboboxChip,
+	ComboboxChipsInput,
+	ComboboxTrigger,
+	ComboboxValue,
+	useComboboxAnchor,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/command.tsx b/apps/examples/desktop-app/webview/components/ui/command.tsx
new file mode 100644
index 0000000..c139b19
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/command.tsx
@@ -0,0 +1,183 @@
+"use client";
+
+import { Command as CommandPrimitive } from "cmdk";
+import { SearchIcon } from "lucide-react";
+import type * as React from "react";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { cn } from "@/lib/utils";
+
+function Command({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive>) {
+	return (
+		<CommandPrimitive
+			data-slot="command"
+			className={cn(
+				"bg-popover text-popover-foreground flex h-full w-full flex-col overflow-hidden rounded-md",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandDialog({
+	title = "Command Palette",
+	description = "Search for a command to run...",
+	children,
+	className,
+	showCloseButton = true,
+	...props
+}: React.ComponentProps<typeof Dialog> & {
+	title?: string;
+	description?: string;
+	className?: string;
+	showCloseButton?: boolean;
+}) {
+	return (
+		<Dialog {...props}>
+			<DialogHeader className="sr-only">
+				<DialogTitle>{title}</DialogTitle>
+				<DialogDescription>{description}</DialogDescription>
+			</DialogHeader>
+			<DialogContent
+				className={cn("overflow-hidden p-0", className)}
+				showCloseButton={showCloseButton}
+			>
+				<Command className="[&_[cmdk-group-heading]]:text-muted-foreground **:data-[slot=command-input-wrapper]:h-12 [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group]]:px-2 [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5">
+					{children}
+				</Command>
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+function CommandInput({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Input>) {
+	return (
+		<div
+			data-slot="command-input-wrapper"
+			className="flex h-9 items-center gap-2 border-b px-3"
+		>
+			<SearchIcon className="size-4 shrink-0 opacity-50" />
+			<CommandPrimitive.Input
+				data-slot="command-input"
+				className={cn(
+					"placeholder:text-muted-foreground flex h-10 w-full rounded-md bg-transparent py-3 text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50",
+					className,
+				)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function CommandList({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.List>) {
+	return (
+		<CommandPrimitive.List
+			data-slot="command-list"
+			className={cn(
+				"max-h-[300px] scroll-py-1 overflow-x-hidden overflow-y-auto",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandEmpty({
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Empty>) {
+	return (
+		<CommandPrimitive.Empty
+			data-slot="command-empty"
+			className="py-6 text-center text-sm"
+			{...props}
+		/>
+	);
+}
+
+function CommandGroup({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Group>) {
+	return (
+		<CommandPrimitive.Group
+			data-slot="command-group"
+			className={cn(
+				"text-foreground [&_[cmdk-group-heading]]:text-muted-foreground overflow-hidden p-1 [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Separator>) {
+	return (
+		<CommandPrimitive.Separator
+			data-slot="command-separator"
+			className={cn("bg-border -mx-1 h-px", className)}
+			{...props}
+		/>
+	);
+}
+
+function CommandItem({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Item>) {
+	return (
+		<CommandPrimitive.Item
+			data-slot="command-item"
+			className={cn(
+				"data-[selected=true]:bg-accent data-[selected=true]:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="command-shortcut"
+			className={cn(
+				"text-muted-foreground ml-auto text-xs tracking-widest",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Command,
+	CommandDialog,
+	CommandInput,
+	CommandList,
+	CommandEmpty,
+	CommandGroup,
+	CommandItem,
+	CommandShortcut,
+	CommandSeparator,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/context-menu.tsx b/apps/examples/desktop-app/webview/components/ui/context-menu.tsx
new file mode 100644
index 0000000..73d4fa1
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/context-menu.tsx
@@ -0,0 +1,252 @@
+"use client";
+
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function ContextMenu({
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Root>) {
+	return <ContextMenuPrimitive.Root data-slot="context-menu" {...props} />;
+}
+
+function ContextMenuTrigger({
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Trigger>) {
+	return (
+		<ContextMenuPrimitive.Trigger data-slot="context-menu-trigger" {...props} />
+	);
+}
+
+function ContextMenuGroup({
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Group>) {
+	return (
+		<ContextMenuPrimitive.Group data-slot="context-menu-group" {...props} />
+	);
+}
+
+function ContextMenuPortal({
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Portal>) {
+	return (
+		<ContextMenuPrimitive.Portal data-slot="context-menu-portal" {...props} />
+	);
+}
+
+function ContextMenuSub({
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Sub>) {
+	return <ContextMenuPrimitive.Sub data-slot="context-menu-sub" {...props} />;
+}
+
+function ContextMenuRadioGroup({
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>) {
+	return (
+		<ContextMenuPrimitive.RadioGroup
+			data-slot="context-menu-radio-group"
+			{...props}
+		/>
+	);
+}
+
+function ContextMenuSubTrigger({
+	className,
+	inset,
+	children,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+	inset?: boolean;
+}) {
+	return (
+		<ContextMenuPrimitive.SubTrigger
+			data-slot="context-menu-sub-trigger"
+			data-inset={inset}
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ChevronRightIcon className="ml-auto" />
+		</ContextMenuPrimitive.SubTrigger>
+	);
+}
+
+function ContextMenuSubContent({
+	className,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.SubContent>) {
+	return (
+		<ContextMenuPrimitive.SubContent
+			data-slot="context-menu-sub-content"
+			className={cn(
+				"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-context-menu-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ContextMenuContent({
+	className,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Content>) {
+	return (
+		<ContextMenuPrimitive.Portal>
+			<ContextMenuPrimitive.Content
+				data-slot="context-menu-content"
+				className={cn(
+					"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-h-(--radix-context-menu-content-available-height) min-w-[8rem] origin-(--radix-context-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border p-1 shadow-md",
+					className,
+				)}
+				{...props}
+			/>
+		</ContextMenuPrimitive.Portal>
+	);
+}
+
+function ContextMenuItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+	inset?: boolean;
+	variant?: "default" | "destructive";
+}) {
+	return (
+		<ContextMenuPrimitive.Item
+			data-slot="context-menu-item"
+			data-inset={inset}
+			data-variant={variant}
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:!text-destructive [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ContextMenuCheckboxItem({
+	className,
+	children,
+	checked,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>) {
+	return (
+		<ContextMenuPrimitive.CheckboxItem
+			data-slot="context-menu-checkbox-item"
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			checked={checked}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+				<ContextMenuPrimitive.ItemIndicator>
+					<CheckIcon className="size-4" />
+				</ContextMenuPrimitive.ItemIndicator>
+			</span>
+			{children}
+		</ContextMenuPrimitive.CheckboxItem>
+	);
+}
+
+function ContextMenuRadioItem({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.RadioItem>) {
+	return (
+		<ContextMenuPrimitive.RadioItem
+			data-slot="context-menu-radio-item"
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+				<ContextMenuPrimitive.ItemIndicator>
+					<CircleIcon className="size-2 fill-current" />
+				</ContextMenuPrimitive.ItemIndicator>
+			</span>
+			{children}
+		</ContextMenuPrimitive.RadioItem>
+	);
+}
+
+function ContextMenuLabel({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+	inset?: boolean;
+}) {
+	return (
+		<ContextMenuPrimitive.Label
+			data-slot="context-menu-label"
+			data-inset={inset}
+			className={cn(
+				"text-foreground px-2 py-1.5 text-sm font-medium data-[inset]:pl-8",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ContextMenuSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Separator>) {
+	return (
+		<ContextMenuPrimitive.Separator
+			data-slot="context-menu-separator"
+			className={cn("bg-border -mx-1 my-1 h-px", className)}
+			{...props}
+		/>
+	);
+}
+
+function ContextMenuShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="context-menu-shortcut"
+			className={cn(
+				"text-muted-foreground ml-auto text-xs tracking-widest",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	ContextMenu,
+	ContextMenuTrigger,
+	ContextMenuContent,
+	ContextMenuItem,
+	ContextMenuCheckboxItem,
+	ContextMenuRadioItem,
+	ContextMenuLabel,
+	ContextMenuSeparator,
+	ContextMenuShortcut,
+	ContextMenuGroup,
+	ContextMenuPortal,
+	ContextMenuSub,
+	ContextMenuSubContent,
+	ContextMenuSubTrigger,
+	ContextMenuRadioGroup,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/dialog.tsx b/apps/examples/desktop-app/webview/components/ui/dialog.tsx
new file mode 100644
index 0000000..41f4ae4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/dialog.tsx
@@ -0,0 +1,143 @@
+"use client";
+
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import { XIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Dialog({
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Root>) {
+	return <DialogPrimitive.Root data-slot="dialog" {...props} />;
+}
+
+function DialogTrigger({
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
+	return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
+}
+
+function DialogPortal({
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
+	return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
+}
+
+function DialogClose({
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Close>) {
+	return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
+}
+
+function DialogOverlay({
+	className,
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
+	return (
+		<DialogPrimitive.Overlay
+			data-slot="dialog-overlay"
+			className={cn(
+				"data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DialogContent({
+	className,
+	children,
+	showCloseButton = true,
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Content> & {
+	showCloseButton?: boolean;
+}) {
+	return (
+		<DialogPortal data-slot="dialog-portal">
+			<DialogOverlay />
+			<DialogPrimitive.Content
+				data-slot="dialog-content"
+				className={cn(
+					"bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				{showCloseButton && (
+					<DialogPrimitive.Close
+						data-slot="dialog-close"
+						className="ring-offset-background focus:ring-ring data-[state=open]:bg-accent data-[state=open]:text-muted-foreground absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4"
+					>
+						<XIcon />
+						<span className="sr-only">Close</span>
+					</DialogPrimitive.Close>
+				)}
+			</DialogPrimitive.Content>
+		</DialogPortal>
+	);
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="dialog-header"
+			className={cn("flex flex-col gap-2 text-center sm:text-left", className)}
+			{...props}
+		/>
+	);
+}
+
+function DialogFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="dialog-footer"
+			className={cn(
+				"flex flex-col-reverse gap-2 sm:flex-row sm:justify-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DialogTitle({
+	className,
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Title>) {
+	return (
+		<DialogPrimitive.Title
+			data-slot="dialog-title"
+			className={cn("text-lg leading-none font-semibold", className)}
+			{...props}
+		/>
+	);
+}
+
+function DialogDescription({
+	className,
+	...props
+}: React.ComponentProps<typeof DialogPrimitive.Description>) {
+	return (
+		<DialogPrimitive.Description
+			data-slot="dialog-description"
+			className={cn("text-muted-foreground text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Dialog,
+	DialogClose,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogOverlay,
+	DialogPortal,
+	DialogTitle,
+	DialogTrigger,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/drawer.tsx b/apps/examples/desktop-app/webview/components/ui/drawer.tsx
new file mode 100644
index 0000000..2508e90
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/drawer.tsx
@@ -0,0 +1,135 @@
+"use client";
+
+import type * as React from "react";
+import { Drawer as DrawerPrimitive } from "vaul";
+
+import { cn } from "@/lib/utils";
+
+function Drawer({
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Root>) {
+	return <DrawerPrimitive.Root data-slot="drawer" {...props} />;
+}
+
+function DrawerTrigger({
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Trigger>) {
+	return <DrawerPrimitive.Trigger data-slot="drawer-trigger" {...props} />;
+}
+
+function DrawerPortal({
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Portal>) {
+	return <DrawerPrimitive.Portal data-slot="drawer-portal" {...props} />;
+}
+
+function DrawerClose({
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Close>) {
+	return <DrawerPrimitive.Close data-slot="drawer-close" {...props} />;
+}
+
+function DrawerOverlay({
+	className,
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Overlay>) {
+	return (
+		<DrawerPrimitive.Overlay
+			data-slot="drawer-overlay"
+			className={cn(
+				"data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DrawerContent({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Content>) {
+	return (
+		<DrawerPortal data-slot="drawer-portal">
+			<DrawerOverlay />
+			<DrawerPrimitive.Content
+				data-slot="drawer-content"
+				className={cn(
+					"group/drawer-content bg-background fixed z-50 flex h-auto flex-col",
+					"data-[vaul-drawer-direction=top]:inset-x-0 data-[vaul-drawer-direction=top]:top-0 data-[vaul-drawer-direction=top]:mb-24 data-[vaul-drawer-direction=top]:max-h-[80vh] data-[vaul-drawer-direction=top]:rounded-b-lg data-[vaul-drawer-direction=top]:border-b",
+					"data-[vaul-drawer-direction=bottom]:inset-x-0 data-[vaul-drawer-direction=bottom]:bottom-0 data-[vaul-drawer-direction=bottom]:mt-24 data-[vaul-drawer-direction=bottom]:max-h-[80vh] data-[vaul-drawer-direction=bottom]:rounded-t-lg data-[vaul-drawer-direction=bottom]:border-t",
+					"data-[vaul-drawer-direction=right]:inset-y-0 data-[vaul-drawer-direction=right]:right-0 data-[vaul-drawer-direction=right]:w-3/4 data-[vaul-drawer-direction=right]:border-l data-[vaul-drawer-direction=right]:sm:max-w-sm",
+					"data-[vaul-drawer-direction=left]:inset-y-0 data-[vaul-drawer-direction=left]:left-0 data-[vaul-drawer-direction=left]:w-3/4 data-[vaul-drawer-direction=left]:border-r data-[vaul-drawer-direction=left]:sm:max-w-sm",
+					className,
+				)}
+				{...props}
+			>
+				<div className="bg-muted mx-auto mt-4 hidden h-2 w-[100px] shrink-0 rounded-full group-data-[vaul-drawer-direction=bottom]/drawer-content:block" />
+				{children}
+			</DrawerPrimitive.Content>
+		</DrawerPortal>
+	);
+}
+
+function DrawerHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="drawer-header"
+			className={cn(
+				"flex flex-col gap-0.5 p-4 group-data-[vaul-drawer-direction=bottom]/drawer-content:text-center group-data-[vaul-drawer-direction=top]/drawer-content:text-center md:gap-1.5 md:text-left",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DrawerFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="drawer-footer"
+			className={cn("mt-auto flex flex-col gap-2 p-4", className)}
+			{...props}
+		/>
+	);
+}
+
+function DrawerTitle({
+	className,
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Title>) {
+	return (
+		<DrawerPrimitive.Title
+			data-slot="drawer-title"
+			className={cn("text-foreground font-semibold", className)}
+			{...props}
+		/>
+	);
+}
+
+function DrawerDescription({
+	className,
+	...props
+}: React.ComponentProps<typeof DrawerPrimitive.Description>) {
+	return (
+		<DrawerPrimitive.Description
+			data-slot="drawer-description"
+			className={cn("text-muted-foreground text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Drawer,
+	DrawerPortal,
+	DrawerOverlay,
+	DrawerTrigger,
+	DrawerClose,
+	DrawerContent,
+	DrawerHeader,
+	DrawerFooter,
+	DrawerTitle,
+	DrawerDescription,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/dropdown-menu.tsx b/apps/examples/desktop-app/webview/components/ui/dropdown-menu.tsx
new file mode 100644
index 0000000..129ec40
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/dropdown-menu.tsx
@@ -0,0 +1,257 @@
+"use client";
+
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function DropdownMenu({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Root>) {
+	return <DropdownMenuPrimitive.Root data-slot="dropdown-menu" {...props} />;
+}
+
+function DropdownMenuPortal({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>) {
+	return (
+		<DropdownMenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />
+	);
+}
+
+function DropdownMenuTrigger({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>) {
+	return (
+		<DropdownMenuPrimitive.Trigger
+			data-slot="dropdown-menu-trigger"
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuContent({
+	className,
+	sideOffset = 4,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Content>) {
+	return (
+		<DropdownMenuPrimitive.Portal>
+			<DropdownMenuPrimitive.Content
+				data-slot="dropdown-menu-content"
+				sideOffset={sideOffset}
+				className={cn(
+					"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-h-(--radix-dropdown-menu-content-available-height) min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border p-1 shadow-md",
+					className,
+				)}
+				{...props}
+			/>
+		</DropdownMenuPrimitive.Portal>
+	);
+}
+
+function DropdownMenuGroup({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Group>) {
+	return (
+		<DropdownMenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />
+	);
+}
+
+function DropdownMenuItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+	inset?: boolean;
+	variant?: "default" | "destructive";
+}) {
+	return (
+		<DropdownMenuPrimitive.Item
+			data-slot="dropdown-menu-item"
+			data-inset={inset}
+			data-variant={variant}
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:!text-destructive [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuCheckboxItem({
+	className,
+	children,
+	checked,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>) {
+	return (
+		<DropdownMenuPrimitive.CheckboxItem
+			data-slot="dropdown-menu-checkbox-item"
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			checked={checked}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+				<DropdownMenuPrimitive.ItemIndicator>
+					<CheckIcon className="size-4" />
+				</DropdownMenuPrimitive.ItemIndicator>
+			</span>
+			{children}
+		</DropdownMenuPrimitive.CheckboxItem>
+	);
+}
+
+function DropdownMenuRadioGroup({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>) {
+	return (
+		<DropdownMenuPrimitive.RadioGroup
+			data-slot="dropdown-menu-radio-group"
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuRadioItem({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>) {
+	return (
+		<DropdownMenuPrimitive.RadioItem
+			data-slot="dropdown-menu-radio-item"
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+				<DropdownMenuPrimitive.ItemIndicator>
+					<CircleIcon className="size-2 fill-current" />
+				</DropdownMenuPrimitive.ItemIndicator>
+			</span>
+			{children}
+		</DropdownMenuPrimitive.RadioItem>
+	);
+}
+
+function DropdownMenuLabel({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+	inset?: boolean;
+}) {
+	return (
+		<DropdownMenuPrimitive.Label
+			data-slot="dropdown-menu-label"
+			data-inset={inset}
+			className={cn(
+				"px-2 py-1.5 text-sm font-medium data-[inset]:pl-8",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>) {
+	return (
+		<DropdownMenuPrimitive.Separator
+			data-slot="dropdown-menu-separator"
+			className={cn("bg-border -mx-1 my-1 h-px", className)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="dropdown-menu-shortcut"
+			className={cn(
+				"text-muted-foreground ml-auto text-xs tracking-widest",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuSub({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>) {
+	return <DropdownMenuPrimitive.Sub data-slot="dropdown-menu-sub" {...props} />;
+}
+
+function DropdownMenuSubTrigger({
+	className,
+	inset,
+	children,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+	inset?: boolean;
+}) {
+	return (
+		<DropdownMenuPrimitive.SubTrigger
+			data-slot="dropdown-menu-sub-trigger"
+			data-inset={inset}
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ChevronRightIcon className="ml-auto size-4" />
+		</DropdownMenuPrimitive.SubTrigger>
+	);
+}
+
+function DropdownMenuSubContent({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>) {
+	return (
+		<DropdownMenuPrimitive.SubContent
+			data-slot="dropdown-menu-sub-content"
+			className={cn(
+				"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	DropdownMenu,
+	DropdownMenuPortal,
+	DropdownMenuTrigger,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuLabel,
+	DropdownMenuItem,
+	DropdownMenuCheckboxItem,
+	DropdownMenuRadioGroup,
+	DropdownMenuRadioItem,
+	DropdownMenuSeparator,
+	DropdownMenuShortcut,
+	DropdownMenuSub,
+	DropdownMenuSubTrigger,
+	DropdownMenuSubContent,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/empty.tsx b/apps/examples/desktop-app/webview/components/ui/empty.tsx
new file mode 100644
index 0000000..32368bb
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/empty.tsx
@@ -0,0 +1,104 @@
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+function Empty({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="empty"
+			className={cn(
+				"flex min-w-0 flex-1 flex-col items-center justify-center gap-6 rounded-lg border-dashed p-6 text-center text-balance md:p-12",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function EmptyHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="empty-header"
+			className={cn(
+				"flex max-w-sm flex-col items-center gap-2 text-center",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const emptyMediaVariants = cva(
+	"flex shrink-0 items-center justify-center mb-2 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+	{
+		variants: {
+			variant: {
+				default: "bg-transparent",
+				icon: "bg-muted text-foreground flex size-10 shrink-0 items-center justify-center rounded-lg [&_svg:not([class*='size-'])]:size-6",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function EmptyMedia({
+	className,
+	variant = "default",
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>) {
+	return (
+		<div
+			data-slot="empty-icon"
+			data-variant={variant}
+			className={cn(emptyMediaVariants({ variant, className }))}
+			{...props}
+		/>
+	);
+}
+
+function EmptyTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="empty-title"
+			className={cn("text-lg font-medium tracking-tight", className)}
+			{...props}
+		/>
+	);
+}
+
+function EmptyDescription({ className, ...props }: React.ComponentProps<"p">) {
+	return (
+		<div
+			data-slot="empty-description"
+			className={cn(
+				"text-muted-foreground [&>a:hover]:text-primary text-sm/relaxed [&>a]:underline [&>a]:underline-offset-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function EmptyContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="empty-content"
+			className={cn(
+				"flex w-full max-w-sm min-w-0 flex-col items-center gap-4 text-sm text-balance",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Empty,
+	EmptyHeader,
+	EmptyTitle,
+	EmptyDescription,
+	EmptyContent,
+	EmptyMedia,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/field.tsx b/apps/examples/desktop-app/webview/components/ui/field.tsx
new file mode 100644
index 0000000..5ca32f1
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/field.tsx
@@ -0,0 +1,241 @@
+"use client";
+
+import { cva, type VariantProps } from "class-variance-authority";
+import { useMemo } from "react";
+import { Label } from "@/components/ui/label";
+import { Separator } from "@/components/ui/separator";
+import { cn } from "@/lib/utils";
+
+function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">) {
+	return (
+		<fieldset
+			data-slot="field-set"
+			className={cn(
+				"flex flex-col gap-6",
+				"has-[>[data-slot=checkbox-group]]:gap-3 has-[>[data-slot=radio-group]]:gap-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function FieldLegend({
+	className,
+	variant = "legend",
+	...props
+}: React.ComponentProps<"legend"> & { variant?: "legend" | "label" }) {
+	return (
+		<legend
+			data-slot="field-legend"
+			data-variant={variant}
+			className={cn(
+				"mb-3 font-medium",
+				"data-[variant=legend]:text-base",
+				"data-[variant=label]:text-sm",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function FieldGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="field-group"
+			className={cn(
+				"group/field-group @container/field-group flex w-full flex-col gap-7 data-[slot=checkbox-group]:gap-3 [&>[data-slot=field-group]]:gap-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const fieldVariants = cva(
+	"group/field flex w-full gap-3 data-[invalid=true]:text-destructive",
+	{
+		variants: {
+			orientation: {
+				vertical: ["flex-col [&>*]:w-full [&>.sr-only]:w-auto"],
+				horizontal: [
+					"flex-row items-center",
+					"[&>[data-slot=field-label]]:flex-auto",
+					"has-[>[data-slot=field-content]]:items-start has-[>[data-slot=field-content]]:[&>[role=checkbox],[role=radio]]:mt-px",
+				],
+				responsive: [
+					"flex-col [&>*]:w-full [&>.sr-only]:w-auto @md/field-group:flex-row @md/field-group:items-center @md/field-group:[&>*]:w-auto",
+					"@md/field-group:[&>[data-slot=field-label]]:flex-auto",
+					"@md/field-group:has-[>[data-slot=field-content]]:items-start @md/field-group:has-[>[data-slot=field-content]]:[&>[role=checkbox],[role=radio]]:mt-px",
+				],
+			},
+		},
+		defaultVariants: {
+			orientation: "vertical",
+		},
+	},
+);
+
+function Field({
+	className,
+	orientation = "vertical",
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof fieldVariants>) {
+	return (
+		<div
+			data-slot="field"
+			data-orientation={orientation}
+			className={cn(fieldVariants({ orientation }), className)}
+			{...props}
+		/>
+	);
+}
+
+function FieldContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="field-content"
+			className={cn(
+				"group/field-content flex flex-1 flex-col gap-1.5 leading-snug",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function FieldLabel({
+	className,
+	...props
+}: React.ComponentProps<typeof Label>) {
+	return (
+		<Label
+			data-slot="field-label"
+			className={cn(
+				"group/field-label peer/field-label flex w-fit gap-2 leading-snug group-data-[disabled=true]/field:opacity-50",
+				"has-[>[data-slot=field]]:w-full has-[>[data-slot=field]]:flex-col has-[>[data-slot=field]]:rounded-md has-[>[data-slot=field]]:border [&>*]:data-[slot=field]:p-4",
+				"has-data-[state=checked]:bg-primary/5 has-data-[state=checked]:border-primary dark:has-data-[state=checked]:bg-primary/10",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function FieldTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="field-label"
+			className={cn(
+				"flex w-fit items-center gap-2 text-sm leading-snug font-medium group-data-[disabled=true]/field:opacity-50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function FieldDescription({ className, ...props }: React.ComponentProps<"p">) {
+	return (
+		<p
+			data-slot="field-description"
+			className={cn(
+				"text-muted-foreground text-sm leading-normal font-normal group-has-[[data-orientation=horizontal]]/field:text-balance",
+				"last:mt-0 nth-last-2:-mt-1 [[data-variant=legend]+&]:-mt-1.5",
+				"[&>a:hover]:text-primary [&>a]:underline [&>a]:underline-offset-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function FieldSeparator({
+	children,
+	className,
+	...props
+}: React.ComponentProps<"div"> & {
+	children?: React.ReactNode;
+}) {
+	return (
+		<div
+			data-slot="field-separator"
+			data-content={!!children}
+			className={cn(
+				"relative -my-2 h-5 text-sm group-data-[variant=outline]/field-group:-mb-2",
+				className,
+			)}
+			{...props}
+		>
+			<Separator className="absolute inset-0 top-1/2" />
+			{children && (
+				<span
+					className="bg-background text-muted-foreground relative mx-auto block w-fit px-2"
+					data-slot="field-separator-content"
+				>
+					{children}
+				</span>
+			)}
+		</div>
+	);
+}
+
+function FieldError({
+	className,
+	children,
+	errors,
+	...props
+}: React.ComponentProps<"div"> & {
+	errors?: Array<{ message?: string } | undefined>;
+}) {
+	const content = useMemo(() => {
+		if (children) {
+			return children;
+		}
+
+		if (!errors) {
+			return null;
+		}
+
+		if (errors.length === 1 && errors[0]?.message) {
+			return errors[0].message;
+		}
+
+		return (
+			<ul className="ml-4 flex list-disc flex-col gap-1">
+				{errors.map((error) =>
+					error?.message ? <li key={error.message}>{error.message}</li> : null,
+				)}
+			</ul>
+		);
+	}, [children, errors]);
+
+	if (!content) {
+		return null;
+	}
+
+	return (
+		<div
+			role="alert"
+			data-slot="field-error"
+			className={cn("text-destructive text-sm font-normal", className)}
+			{...props}
+		>
+			{content}
+		</div>
+	);
+}
+
+export {
+	Field,
+	FieldLabel,
+	FieldDescription,
+	FieldError,
+	FieldGroup,
+	FieldLegend,
+	FieldSeparator,
+	FieldSet,
+	FieldContent,
+	FieldTitle,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/form.tsx b/apps/examples/desktop-app/webview/components/ui/form.tsx
new file mode 100644
index 0000000..22c13ee
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/form.tsx
@@ -0,0 +1,167 @@
+"use client";
+
+import type * as LabelPrimitive from "@radix-ui/react-label";
+import { Slot } from "@radix-ui/react-slot";
+import * as React from "react";
+import {
+	Controller,
+	type ControllerProps,
+	type FieldPath,
+	type FieldValues,
+	FormProvider,
+	useFormContext,
+	useFormState,
+} from "react-hook-form";
+import { Label } from "@/components/ui/label";
+import { cn } from "@/lib/utils";
+
+const Form = FormProvider;
+
+type FormFieldContextValue<
+	TFieldValues extends FieldValues = FieldValues,
+	TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,
+> = {
+	name: TName;
+};
+
+const FormFieldContext = React.createContext<FormFieldContextValue>(
+	{} as FormFieldContextValue,
+);
+
+const FormField = <
+	TFieldValues extends FieldValues = FieldValues,
+	TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,
+>({
+	...props
+}: ControllerProps<TFieldValues, TName>) => {
+	return (
+		<FormFieldContext.Provider value={{ name: props.name }}>
+			<Controller {...props} />
+		</FormFieldContext.Provider>
+	);
+};
+
+const useFormField = () => {
+	const fieldContext = React.useContext(FormFieldContext);
+	const itemContext = React.useContext(FormItemContext);
+	const { getFieldState } = useFormContext();
+	const formState = useFormState({ name: fieldContext.name });
+	const fieldState = getFieldState(fieldContext.name, formState);
+
+	if (!fieldContext) {
+		throw new Error("useFormField should be used within <FormField>");
+	}
+
+	const { id } = itemContext;
+
+	return {
+		id,
+		name: fieldContext.name,
+		formItemId: `${id}-form-item`,
+		formDescriptionId: `${id}-form-item-description`,
+		formMessageId: `${id}-form-item-message`,
+		...fieldState,
+	};
+};
+
+type FormItemContextValue = {
+	id: string;
+};
+
+const FormItemContext = React.createContext<FormItemContextValue>(
+	{} as FormItemContextValue,
+);
+
+function FormItem({ className, ...props }: React.ComponentProps<"div">) {
+	const id = React.useId();
+
+	return (
+		<FormItemContext.Provider value={{ id }}>
+			<div
+				data-slot="form-item"
+				className={cn("grid gap-2", className)}
+				{...props}
+			/>
+		</FormItemContext.Provider>
+	);
+}
+
+function FormLabel({
+	className,
+	...props
+}: React.ComponentProps<typeof LabelPrimitive.Root>) {
+	const { error, formItemId } = useFormField();
+
+	return (
+		<Label
+			data-slot="form-label"
+			data-error={!!error}
+			className={cn("data-[error=true]:text-destructive", className)}
+			htmlFor={formItemId}
+			{...props}
+		/>
+	);
+}
+
+function FormControl({ ...props }: React.ComponentProps<typeof Slot>) {
+	const { error, formItemId, formDescriptionId, formMessageId } =
+		useFormField();
+
+	return (
+		<Slot
+			data-slot="form-control"
+			id={formItemId}
+			aria-describedby={
+				!error
+					? `${formDescriptionId}`
+					: `${formDescriptionId} ${formMessageId}`
+			}
+			aria-invalid={!!error}
+			{...props}
+		/>
+	);
+}
+
+function FormDescription({ className, ...props }: React.ComponentProps<"p">) {
+	const { formDescriptionId } = useFormField();
+
+	return (
+		<p
+			data-slot="form-description"
+			id={formDescriptionId}
+			className={cn("text-muted-foreground text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function FormMessage({ className, ...props }: React.ComponentProps<"p">) {
+	const { error, formMessageId } = useFormField();
+	const body = error ? String(error?.message ?? "") : props.children;
+
+	if (!body) {
+		return null;
+	}
+
+	return (
+		<p
+			data-slot="form-message"
+			id={formMessageId}
+			className={cn("text-destructive text-sm", className)}
+			{...props}
+		>
+			{body}
+		</p>
+	);
+}
+
+export {
+	useFormField,
+	Form,
+	FormItem,
+	FormLabel,
+	FormControl,
+	FormDescription,
+	FormMessage,
+	FormField,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/hover-card.tsx b/apps/examples/desktop-app/webview/components/ui/hover-card.tsx
new file mode 100644
index 0000000..4433bad
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/hover-card.tsx
@@ -0,0 +1,44 @@
+"use client";
+
+import * as HoverCardPrimitive from "@radix-ui/react-hover-card";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function HoverCard({
+	...props
+}: React.ComponentProps<typeof HoverCardPrimitive.Root>) {
+	return <HoverCardPrimitive.Root data-slot="hover-card" {...props} />;
+}
+
+function HoverCardTrigger({
+	...props
+}: React.ComponentProps<typeof HoverCardPrimitive.Trigger>) {
+	return (
+		<HoverCardPrimitive.Trigger data-slot="hover-card-trigger" {...props} />
+	);
+}
+
+function HoverCardContent({
+	className,
+	align = "center",
+	sideOffset = 4,
+	...props
+}: React.ComponentProps<typeof HoverCardPrimitive.Content>) {
+	return (
+		<HoverCardPrimitive.Portal data-slot="hover-card-portal">
+			<HoverCardPrimitive.Content
+				data-slot="hover-card-content"
+				align={align}
+				sideOffset={sideOffset}
+				className={cn(
+					"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-64 origin-(--radix-hover-card-content-transform-origin) rounded-md border p-4 shadow-md outline-hidden",
+					className,
+				)}
+				{...props}
+			/>
+		</HoverCardPrimitive.Portal>
+	);
+}
+
+export { HoverCard, HoverCardTrigger, HoverCardContent };
diff --git a/apps/examples/desktop-app/webview/components/ui/input-group.tsx b/apps/examples/desktop-app/webview/components/ui/input-group.tsx
new file mode 100644
index 0000000..4af6f44
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/input-group.tsx
@@ -0,0 +1,160 @@
+"use client";
+
+import { cva, type VariantProps } from "class-variance-authority";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { cn } from "@/lib/utils";
+
+function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="input-group"
+			className={cn(
+				"group/input-group border-input dark:bg-input/30 relative flex w-full items-center rounded-md border shadow-xs transition-[color,box-shadow] outline-none",
+				"h-9 has-[>textarea]:h-auto",
+
+				// Variants based on alignment.
+				"has-[>[data-align=inline-start]]:[&>input]:pl-2",
+				"has-[>[data-align=inline-end]]:[&>input]:pr-2",
+				"has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>[data-align=block-start]]:[&>input]:pb-3",
+				"has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-end]]:[&>input]:pt-3",
+
+				// Focus state.
+				"has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot=input-group-control]:focus-visible]:ring-[3px]",
+
+				// Error state.
+				"has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[[data-slot][aria-invalid=true]]:border-destructive dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40",
+
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const inputGroupAddonVariants = cva(
+	"text-muted-foreground flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium select-none [&>svg:not([class*='size-'])]:size-4 [&>kbd]:rounded-[calc(var(--radius)-5px)] group-data-[disabled=true]/input-group:opacity-50",
+	{
+		variants: {
+			align: {
+				"inline-start":
+					"order-first pl-3 has-[>button]:ml-[-0.45rem] has-[>kbd]:ml-[-0.35rem]",
+				"inline-end":
+					"order-last pr-3 has-[>button]:mr-[-0.4rem] has-[>kbd]:mr-[-0.35rem]",
+				"block-start":
+					"order-first w-full justify-start px-3 pt-3 [.border-b]:pb-3 group-has-[>input]/input-group:pt-2.5",
+				"block-end":
+					"order-last w-full justify-start px-3 pb-3 [.border-t]:pt-3 group-has-[>input]/input-group:pb-2.5",
+			},
+		},
+		defaultVariants: {
+			align: "inline-start",
+		},
+	},
+);
+
+function InputGroupAddon({
+	className,
+	align = "inline-start",
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
+	return (
+		<div
+			data-slot="input-group-addon"
+			data-align={align}
+			className={cn(inputGroupAddonVariants({ align }), className)}
+			{...props}
+		/>
+	);
+}
+
+const inputGroupButtonVariants = cva(
+	"text-sm shadow-none flex gap-2 items-center",
+	{
+		variants: {
+			size: {
+				xs: "h-6 gap-1 px-2 rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-3.5 has-[>svg]:px-2",
+				sm: "h-8 px-2.5 gap-1.5 rounded-md has-[>svg]:px-2.5",
+				"icon-xs":
+					"size-6 rounded-[calc(var(--radius)-5px)] p-0 has-[>svg]:p-0",
+				"icon-sm": "size-8 p-0 has-[>svg]:p-0",
+			},
+		},
+		defaultVariants: {
+			size: "xs",
+		},
+	},
+);
+
+function InputGroupButton({
+	className,
+	type = "button",
+	variant = "ghost",
+	size = "xs",
+	...props
+}: Omit<React.ComponentProps<typeof Button>, "size"> &
+	VariantProps<typeof inputGroupButtonVariants>) {
+	return (
+		<Button
+			type={type}
+			data-size={size}
+			variant={variant}
+			className={cn(inputGroupButtonVariants({ size }), className)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
+	return (
+		<span
+			className={cn(
+				"text-muted-foreground flex items-center gap-2 text-sm [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupInput({
+	className,
+	...props
+}: React.ComponentProps<"input">) {
+	return (
+		<Input
+			data-slot="input-group-control"
+			className={cn(
+				"flex-1 rounded-none border-0 bg-transparent shadow-none focus-visible:ring-0 dark:bg-transparent",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupTextarea({
+	className,
+	...props
+}: React.ComponentProps<"textarea">) {
+	return (
+		<Textarea
+			data-slot="input-group-control"
+			className={cn(
+				"flex-1 resize-none rounded-none border-0 bg-transparent py-3 shadow-none focus-visible:ring-0 dark:bg-transparent",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupText,
+	InputGroupInput,
+	InputGroupTextarea,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/input-otp.tsx b/apps/examples/desktop-app/webview/components/ui/input-otp.tsx
new file mode 100644
index 0000000..5977c3d
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/input-otp.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import { OTPInput, OTPInputContext } from "input-otp";
+import { MinusIcon } from "lucide-react";
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function InputOTP({
+	className,
+	containerClassName,
+	...props
+}: React.ComponentProps<typeof OTPInput> & {
+	containerClassName?: string;
+}) {
+	return (
+		<OTPInput
+			data-slot="input-otp"
+			containerClassName={cn(
+				"flex items-center gap-2 has-disabled:opacity-50",
+				containerClassName,
+			)}
+			className={cn("disabled:cursor-not-allowed", className)}
+			{...props}
+		/>
+	);
+}
+
+function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="input-otp-group"
+			className={cn("flex items-center", className)}
+			{...props}
+		/>
+	);
+}
+
+function InputOTPSlot({
+	index,
+	className,
+	...props
+}: React.ComponentProps<"div"> & {
+	index: number;
+}) {
+	const inputOTPContext = React.useContext(OTPInputContext);
+	const { char, hasFakeCaret, isActive } = inputOTPContext?.slots[index] ?? {};
+
+	return (
+		<div
+			data-slot="input-otp-slot"
+			data-active={isActive}
+			className={cn(
+				"data-[active=true]:border-ring data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:ring-destructive/20 dark:data-[active=true]:aria-invalid:ring-destructive/40 aria-invalid:border-destructive data-[active=true]:aria-invalid:border-destructive dark:bg-input/30 border-input relative flex h-9 w-9 items-center justify-center border-y border-r text-sm shadow-xs transition-all outline-none first:rounded-l-md first:border-l last:rounded-r-md data-[active=true]:z-10 data-[active=true]:ring-[3px]",
+				className,
+			)}
+			{...props}
+		>
+			{char}
+			{hasFakeCaret && (
+				<div className="pointer-events-none absolute inset-0 flex items-center justify-center">
+					<div className="animate-caret-blink bg-foreground h-4 w-px duration-1000" />
+				</div>
+			)}
+		</div>
+	);
+}
+
+function InputOTPSeparator({ ...props }: React.ComponentProps<"div">) {
+	return (
+		<div data-slot="input-otp-separator" aria-hidden="true" {...props}>
+			<MinusIcon />
+		</div>
+	);
+}
+
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };
diff --git a/apps/examples/desktop-app/webview/components/ui/input.tsx b/apps/examples/desktop-app/webview/components/ui/input.tsx
new file mode 100644
index 0000000..1ff9fd7
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/input.tsx
@@ -0,0 +1,21 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+	return (
+		<input
+			type={type}
+			data-slot="input"
+			className={cn(
+				"file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+				"focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
+				"aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Input };
diff --git a/apps/examples/desktop-app/webview/components/ui/item.tsx b/apps/examples/desktop-app/webview/components/ui/item.tsx
new file mode 100644
index 0000000..580d3f4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/item.tsx
@@ -0,0 +1,191 @@
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+import { Separator } from "@/components/ui/separator";
+import { cn } from "@/lib/utils";
+
+function ItemGroup({ className, ...props }: React.ComponentProps<"ul">) {
+	return (
+		<ul
+			data-slot="item-group"
+			className={cn("group/item-group flex flex-col", className)}
+			{...props}
+		/>
+	);
+}
+
+function ItemSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof Separator>) {
+	return (
+		<Separator
+			data-slot="item-separator"
+			orientation="horizontal"
+			className={cn("my-0", className)}
+			{...props}
+		/>
+	);
+}
+
+const itemVariants = cva(
+	"group/item flex items-center border border-transparent text-sm rounded-md transition-colors [a&]:hover:bg-accent/50 [a&]:transition-colors duration-100 flex-wrap outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
+	{
+		variants: {
+			variant: {
+				default: "bg-transparent",
+				outline: "border-border",
+				muted: "bg-muted/50",
+			},
+			size: {
+				default: "p-4 gap-4 ",
+				sm: "py-3 px-4 gap-2.5",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+);
+
+function Item({
+	className,
+	variant = "default",
+	size = "default",
+	asChild = false,
+	...props
+}: React.ComponentProps<"div"> &
+	VariantProps<typeof itemVariants> & { asChild?: boolean }) {
+	const Comp = asChild ? Slot : "div";
+	return (
+		<Comp
+			data-slot="item"
+			data-variant={variant}
+			data-size={size}
+			className={cn(itemVariants({ variant, size, className }))}
+			{...props}
+		/>
+	);
+}
+
+const itemMediaVariants = cva(
+	"flex shrink-0 items-center justify-center gap-2 group-has-[[data-slot=item-description]]/item:self-start [&_svg]:pointer-events-none group-has-[[data-slot=item-description]]/item:translate-y-0.5",
+	{
+		variants: {
+			variant: {
+				default: "bg-transparent",
+				icon: "size-8 border rounded-sm bg-muted [&_svg:not([class*='size-'])]:size-4",
+				image:
+					"size-10 rounded-sm overflow-hidden [&_img]:size-full [&_img]:object-cover",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function ItemMedia({
+	className,
+	variant = "default",
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>) {
+	return (
+		<div
+			data-slot="item-media"
+			data-variant={variant}
+			className={cn(itemMediaVariants({ variant, className }))}
+			{...props}
+		/>
+	);
+}
+
+function ItemContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="item-content"
+			className={cn(
+				"flex flex-1 flex-col gap-1 [&+[data-slot=item-content]]:flex-none",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ItemTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="item-title"
+			className={cn(
+				"flex w-fit items-center gap-2 text-sm leading-snug font-medium",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ItemDescription({ className, ...props }: React.ComponentProps<"p">) {
+	return (
+		<p
+			data-slot="item-description"
+			className={cn(
+				"text-muted-foreground line-clamp-2 text-sm leading-normal font-normal text-balance",
+				"[&>a:hover]:text-primary [&>a]:underline [&>a]:underline-offset-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ItemActions({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="item-actions"
+			className={cn("flex items-center gap-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function ItemHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="item-header"
+			className={cn(
+				"flex basis-full items-center justify-between gap-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ItemFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="item-footer"
+			className={cn(
+				"flex basis-full items-center justify-between gap-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Item,
+	ItemMedia,
+	ItemContent,
+	ItemActions,
+	ItemGroup,
+	ItemSeparator,
+	ItemTitle,
+	ItemDescription,
+	ItemHeader,
+	ItemFooter,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/kbd.tsx b/apps/examples/desktop-app/webview/components/ui/kbd.tsx
new file mode 100644
index 0000000..c737c92
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/kbd.tsx
@@ -0,0 +1,28 @@
+import { cn } from "@/lib/utils";
+
+function Kbd({ className, ...props }: React.ComponentProps<"kbd">) {
+	return (
+		<kbd
+			data-slot="kbd"
+			className={cn(
+				"bg-muted w-fit text-muted-foreground pointer-events-none inline-flex h-5 min-w-5 items-center justify-center gap-1 rounded-sm px-1 font-sans text-xs font-medium select-none",
+				"[&_svg:not([class*='size-'])]:size-3",
+				"[[data-slot=tooltip-content]_&]:bg-background/20 [[data-slot=tooltip-content]_&]:text-background dark:[[data-slot=tooltip-content]_&]:bg-background/10",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function KbdGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<kbd
+			data-slot="kbd-group"
+			className={cn("inline-flex items-center gap-1", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Kbd, KbdGroup };
diff --git a/apps/examples/desktop-app/webview/components/ui/label.tsx b/apps/examples/desktop-app/webview/components/ui/label.tsx
new file mode 100644
index 0000000..be983a3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/label.tsx
@@ -0,0 +1,24 @@
+"use client";
+
+import * as LabelPrimitive from "@radix-ui/react-label";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Label({
+	className,
+	...props
+}: React.ComponentProps<typeof LabelPrimitive.Root>) {
+	return (
+		<LabelPrimitive.Root
+			data-slot="label"
+			className={cn(
+				"flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Label };
diff --git a/apps/examples/desktop-app/webview/components/ui/markdown.tsx b/apps/examples/desktop-app/webview/components/ui/markdown.tsx
new file mode 100644
index 0000000..b719161
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/markdown.tsx
@@ -0,0 +1,45 @@
+import { marked } from "marked";
+import { memo, useMemo } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+const MemoizedMarkdownBlock = memo(
+	({ content }: { content: string }) => {
+		return (
+			<div className="markdown">
+				<ReactMarkdown remarkPlugins={[remarkGfm]}>{content}</ReactMarkdown>
+			</div>
+		);
+	},
+	(prevProps, nextProps) => {
+		if (prevProps.content !== nextProps.content) return false;
+		return true;
+	},
+);
+
+MemoizedMarkdownBlock.displayName = "MemoizedMarkdownBlock";
+
+export function parseMarkdownIntoBlocks(markdown: string): string[] {
+	const tokens = marked.lexer(markdown);
+	return tokens.map((token) => token.raw);
+}
+
+export const MemoizedMarkdown = memo(
+	({ content, id }: { content: string; id: string }) => {
+		const blocks = useMemo(() => parseMarkdownIntoBlocks(content), [content]);
+		const occurrences = new Map<string, number>();
+
+		return blocks.map((block) => {
+			const occurrence = (occurrences.get(block) ?? 0) + 1;
+			occurrences.set(block, occurrence);
+			return (
+				<MemoizedMarkdownBlock
+					content={block}
+					key={`${id}-block_${occurrence}-${block}`}
+				/>
+			);
+		});
+	},
+);
+
+MemoizedMarkdown.displayName = "MemoizedMarkdown";
diff --git a/apps/examples/desktop-app/webview/components/ui/menubar.tsx b/apps/examples/desktop-app/webview/components/ui/menubar.tsx
new file mode 100644
index 0000000..23c7690
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/menubar.tsx
@@ -0,0 +1,276 @@
+"use client";
+
+import * as MenubarPrimitive from "@radix-ui/react-menubar";
+import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Menubar({
+	className,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Root>) {
+	return (
+		<MenubarPrimitive.Root
+			className={cn(
+				"bg-background flex h-9 items-center gap-1 rounded-md border p-1 shadow-xs",
+				className,
+			)}
+			data-slot="menubar"
+			{...props}
+		/>
+	);
+}
+
+function MenubarMenu({
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Menu>) {
+	return <MenubarPrimitive.Menu data-slot="menubar-menu" {...props} />;
+}
+
+function MenubarGroup({
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Group>) {
+	return <MenubarPrimitive.Group data-slot="menubar-group" {...props} />;
+}
+
+function MenubarPortal({
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Portal>) {
+	return <MenubarPrimitive.Portal data-slot="menubar-portal" {...props} />;
+}
+
+function MenubarRadioGroup({
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.RadioGroup>) {
+	return (
+		<MenubarPrimitive.RadioGroup data-slot="menubar-radio-group" {...props} />
+	);
+}
+
+function MenubarTrigger({
+	className,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Trigger>) {
+	return (
+		<MenubarPrimitive.Trigger
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground flex items-center rounded-sm px-2 py-1 text-sm font-medium outline-hidden select-none",
+				className,
+			)}
+			data-slot="menubar-trigger"
+			{...props}
+		/>
+	);
+}
+
+function MenubarContent({
+	className,
+	align = "start",
+	alignOffset = -4,
+	sideOffset = 8,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Content>) {
+	return (
+		<MenubarPortal>
+			<MenubarPrimitive.Content
+				align={align}
+				alignOffset={alignOffset}
+				className={cn(
+					"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[12rem] origin-(--radix-menubar-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-md",
+					className,
+				)}
+				data-slot="menubar-content"
+				sideOffset={sideOffset}
+				{...props}
+			/>
+		</MenubarPortal>
+	);
+}
+
+function MenubarItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Item> & {
+	inset?: boolean;
+	variant?: "default" | "destructive";
+}) {
+	return (
+		<MenubarPrimitive.Item
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:!text-destructive [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			data-inset={inset}
+			data-slot="menubar-item"
+			data-variant={variant}
+			{...props}
+		/>
+	);
+}
+
+function MenubarCheckboxItem({
+	className,
+	children,
+	checked,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.CheckboxItem>) {
+	return (
+		<MenubarPrimitive.CheckboxItem
+			checked={checked}
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-xs py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			data-slot="menubar-checkbox-item"
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+				<MenubarPrimitive.ItemIndicator>
+					<CheckIcon className="size-4" />
+				</MenubarPrimitive.ItemIndicator>
+			</span>
+			{children}
+		</MenubarPrimitive.CheckboxItem>
+	);
+}
+
+function MenubarRadioItem({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.RadioItem>) {
+	return (
+		<MenubarPrimitive.RadioItem
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-xs py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			data-slot="menubar-radio-item"
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+				<MenubarPrimitive.ItemIndicator>
+					<CircleIcon className="size-2 fill-current" />
+				</MenubarPrimitive.ItemIndicator>
+			</span>
+			{children}
+		</MenubarPrimitive.RadioItem>
+	);
+}
+
+function MenubarLabel({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Label> & {
+	inset?: boolean;
+}) {
+	return (
+		<MenubarPrimitive.Label
+			className={cn(
+				"px-2 py-1.5 text-sm font-medium data-[inset]:pl-8",
+				className,
+			)}
+			data-inset={inset}
+			data-slot="menubar-label"
+			{...props}
+		/>
+	);
+}
+
+function MenubarSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Separator>) {
+	return (
+		<MenubarPrimitive.Separator
+			className={cn("bg-border -mx-1 my-1 h-px", className)}
+			data-slot="menubar-separator"
+			{...props}
+		/>
+	);
+}
+
+function MenubarShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			className={cn(
+				"text-muted-foreground ml-auto text-xs tracking-widest",
+				className,
+			)}
+			data-slot="menubar-shortcut"
+			{...props}
+		/>
+	);
+}
+
+function MenubarSub({
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.Sub>) {
+	return <MenubarPrimitive.Sub data-slot="menubar-sub" {...props} />;
+}
+
+function MenubarSubTrigger({
+	className,
+	inset,
+	children,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.SubTrigger> & {
+	inset?: boolean;
+}) {
+	return (
+		<MenubarPrimitive.SubTrigger
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-none select-none data-[inset]:pl-8",
+				className,
+			)}
+			data-inset={inset}
+			data-slot="menubar-sub-trigger"
+			{...props}
+		>
+			{children}
+			<ChevronRightIcon className="ml-auto h-4 w-4" />
+		</MenubarPrimitive.SubTrigger>
+	);
+}
+
+function MenubarSubContent({
+	className,
+	...props
+}: React.ComponentProps<typeof MenubarPrimitive.SubContent>) {
+	return (
+		<MenubarPrimitive.SubContent
+			className={cn(
+				"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-menubar-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg",
+				className,
+			)}
+			data-slot="menubar-sub-content"
+			{...props}
+		/>
+	);
+}
+
+export {
+	Menubar,
+	MenubarPortal,
+	MenubarMenu,
+	MenubarTrigger,
+	MenubarContent,
+	MenubarGroup,
+	MenubarSeparator,
+	MenubarLabel,
+	MenubarItem,
+	MenubarShortcut,
+	MenubarCheckboxItem,
+	MenubarRadioGroup,
+	MenubarRadioItem,
+	MenubarSub,
+	MenubarSubTrigger,
+	MenubarSubContent,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/navigation-menu.tsx b/apps/examples/desktop-app/webview/components/ui/navigation-menu.tsx
new file mode 100644
index 0000000..2ca9cd1
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/navigation-menu.tsx
@@ -0,0 +1,164 @@
+import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu";
+import { cva } from "class-variance-authority";
+import { ChevronDownIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function NavigationMenu({
+	className,
+	children,
+	viewport = true,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Root> & {
+	viewport?: boolean;
+}) {
+	return (
+		<NavigationMenuPrimitive.Root
+			data-slot="navigation-menu"
+			data-viewport={viewport}
+			className={cn(
+				"group/navigation-menu relative flex max-w-max flex-1 items-center justify-center",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			{viewport && <NavigationMenuViewport />}
+		</NavigationMenuPrimitive.Root>
+	);
+}
+
+function NavigationMenuList({
+	className,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.List>) {
+	return (
+		<NavigationMenuPrimitive.List
+			data-slot="navigation-menu-list"
+			className={cn(
+				"group flex flex-1 list-none items-center justify-center gap-1",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function NavigationMenuItem({
+	className,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Item>) {
+	return (
+		<NavigationMenuPrimitive.Item
+			data-slot="navigation-menu-item"
+			className={cn("relative", className)}
+			{...props}
+		/>
+	);
+}
+
+const navigationMenuTriggerStyle = cva(
+	"group inline-flex h-9 w-max items-center justify-center rounded-md bg-background px-4 py-2 text-sm font-medium hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground disabled:pointer-events-none disabled:opacity-50 data-[state=open]:hover:bg-accent data-[state=open]:text-accent-foreground data-[state=open]:focus:bg-accent data-[state=open]:bg-accent/50 focus-visible:ring-ring/50 outline-none transition-[color,box-shadow] focus-visible:ring-[3px] focus-visible:outline-1",
+);
+
+function NavigationMenuTrigger({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Trigger>) {
+	return (
+		<NavigationMenuPrimitive.Trigger
+			data-slot="navigation-menu-trigger"
+			className={cn(navigationMenuTriggerStyle(), "group", className)}
+			{...props}
+		>
+			{children}{" "}
+			<ChevronDownIcon
+				className="relative top-[1px] ml-1 size-3 transition duration-300 group-data-[state=open]:rotate-180"
+				aria-hidden="true"
+			/>
+		</NavigationMenuPrimitive.Trigger>
+	);
+}
+
+function NavigationMenuContent({
+	className,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Content>) {
+	return (
+		<NavigationMenuPrimitive.Content
+			data-slot="navigation-menu-content"
+			className={cn(
+				"data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 top-0 left-0 w-full p-2 pr-2.5 md:absolute md:w-auto",
+				"group-data-[viewport=false]/navigation-menu:bg-popover group-data-[viewport=false]/navigation-menu:text-popover-foreground group-data-[viewport=false]/navigation-menu:data-[state=open]:animate-in group-data-[viewport=false]/navigation-menu:data-[state=closed]:animate-out group-data-[viewport=false]/navigation-menu:data-[state=closed]:zoom-out-95 group-data-[viewport=false]/navigation-menu:data-[state=open]:zoom-in-95 group-data-[viewport=false]/navigation-menu:data-[state=open]:fade-in-0 group-data-[viewport=false]/navigation-menu:data-[state=closed]:fade-out-0 group-data-[viewport=false]/navigation-menu:top-full group-data-[viewport=false]/navigation-menu:mt-1.5 group-data-[viewport=false]/navigation-menu:overflow-hidden group-data-[viewport=false]/navigation-menu:rounded-md group-data-[viewport=false]/navigation-menu:border group-data-[viewport=false]/navigation-menu:shadow group-data-[viewport=false]/navigation-menu:duration-200 **:data-[slot=navigation-menu-link]:focus:ring-0 **:data-[slot=navigation-menu-link]:focus:outline-none",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function NavigationMenuViewport({
+	className,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Viewport>) {
+	return (
+		<div className="absolute top-full left-0 isolate z-50 flex justify-center">
+			<NavigationMenuPrimitive.Viewport
+				data-slot="navigation-menu-viewport"
+				className={cn(
+					"origin-top-center bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border shadow md:w-[var(--radix-navigation-menu-viewport-width)]",
+					className,
+				)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function NavigationMenuLink({
+	className,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Link>) {
+	return (
+		<NavigationMenuPrimitive.Link
+			data-slot="navigation-menu-link"
+			className={cn(
+				"data-[active=true]:focus:bg-accent data-[active=true]:hover:bg-accent data-[active=true]:bg-accent/50 data-[active=true]:text-accent-foreground hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus-visible:ring-ring/50 [&_svg:not([class*='text-'])]:text-muted-foreground flex flex-col gap-1 rounded-sm p-2 text-sm transition-all outline-none focus-visible:ring-[3px] focus-visible:outline-1 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function NavigationMenuIndicator({
+	className,
+	...props
+}: React.ComponentProps<typeof NavigationMenuPrimitive.Indicator>) {
+	return (
+		<NavigationMenuPrimitive.Indicator
+			data-slot="navigation-menu-indicator"
+			className={cn(
+				"data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in top-full z-[1] flex h-1.5 items-end justify-center overflow-hidden",
+				className,
+			)}
+			{...props}
+		>
+			<div className="bg-border relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm shadow-md" />
+		</NavigationMenuPrimitive.Indicator>
+	);
+}
+
+export {
+	NavigationMenu,
+	NavigationMenuList,
+	NavigationMenuItem,
+	NavigationMenuContent,
+	NavigationMenuTrigger,
+	NavigationMenuLink,
+	NavigationMenuIndicator,
+	NavigationMenuViewport,
+	navigationMenuTriggerStyle,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/pagination.tsx b/apps/examples/desktop-app/webview/components/ui/pagination.tsx
new file mode 100644
index 0000000..23a712f
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/pagination.tsx
@@ -0,0 +1,125 @@
+import {
+	ChevronLeftIcon,
+	ChevronRightIcon,
+	MoreHorizontalIcon,
+} from "lucide-react";
+import type * as React from "react";
+import { type Button, buttonVariants } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function Pagination({ className, ...props }: React.ComponentProps<"nav">) {
+	return (
+		<nav
+			aria-label="pagination"
+			data-slot="pagination"
+			className={cn("mx-auto flex w-full justify-center", className)}
+			{...props}
+		/>
+	);
+}
+
+function PaginationContent({
+	className,
+	...props
+}: React.ComponentProps<"ul">) {
+	return (
+		<ul
+			data-slot="pagination-content"
+			className={cn("flex flex-row items-center gap-1", className)}
+			{...props}
+		/>
+	);
+}
+
+function PaginationItem({ ...props }: React.ComponentProps<"li">) {
+	return <li data-slot="pagination-item" {...props} />;
+}
+
+type PaginationLinkProps = {
+	isActive?: boolean;
+} & Pick<React.ComponentProps<typeof Button>, "size"> &
+	React.ComponentProps<"a">;
+
+function PaginationLink({
+	className,
+	isActive,
+	size = "icon",
+	...props
+}: PaginationLinkProps) {
+	return (
+		<a
+			aria-current={isActive ? "page" : undefined}
+			data-slot="pagination-link"
+			data-active={isActive}
+			className={cn(
+				buttonVariants({
+					variant: isActive ? "outline" : "ghost",
+					size,
+				}),
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function PaginationPrevious({
+	className,
+	...props
+}: React.ComponentProps<typeof PaginationLink>) {
+	return (
+		<PaginationLink
+			aria-label="Go to previous page"
+			size="default"
+			className={cn("gap-1 px-2.5 sm:pl-2.5", className)}
+			{...props}
+		>
+			<ChevronLeftIcon />
+			<span className="hidden sm:block">Previous</span>
+		</PaginationLink>
+	);
+}
+
+function PaginationNext({
+	className,
+	...props
+}: React.ComponentProps<typeof PaginationLink>) {
+	return (
+		<PaginationLink
+			aria-label="Go to next page"
+			size="default"
+			className={cn("gap-1 px-2.5 sm:pr-2.5", className)}
+			{...props}
+		>
+			<span className="hidden sm:block">Next</span>
+			<ChevronRightIcon />
+		</PaginationLink>
+	);
+}
+
+function PaginationEllipsis({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			aria-hidden
+			data-slot="pagination-ellipsis"
+			className={cn("flex size-9 items-center justify-center", className)}
+			{...props}
+		>
+			<MoreHorizontalIcon className="size-4" />
+			<span className="sr-only">More pages</span>
+		</span>
+	);
+}
+
+export {
+	Pagination,
+	PaginationContent,
+	PaginationLink,
+	PaginationItem,
+	PaginationPrevious,
+	PaginationNext,
+	PaginationEllipsis,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/popover.tsx b/apps/examples/desktop-app/webview/components/ui/popover.tsx
new file mode 100644
index 0000000..f9c2046
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/popover.tsx
@@ -0,0 +1,48 @@
+"use client";
+
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Popover({
+	...props
+}: React.ComponentProps<typeof PopoverPrimitive.Root>) {
+	return <PopoverPrimitive.Root data-slot="popover" {...props} />;
+}
+
+function PopoverTrigger({
+	...props
+}: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
+	return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />;
+}
+
+function PopoverContent({
+	className,
+	align = "center",
+	sideOffset = 4,
+	...props
+}: React.ComponentProps<typeof PopoverPrimitive.Content>) {
+	return (
+		<PopoverPrimitive.Portal>
+			<PopoverPrimitive.Content
+				data-slot="popover-content"
+				align={align}
+				sideOffset={sideOffset}
+				className={cn(
+					"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 origin-(--radix-popover-content-transform-origin) rounded-md border p-4 shadow-md outline-hidden",
+					className,
+				)}
+				{...props}
+			/>
+		</PopoverPrimitive.Portal>
+	);
+}
+
+function PopoverAnchor({
+	...props
+}: React.ComponentProps<typeof PopoverPrimitive.Anchor>) {
+	return <PopoverPrimitive.Anchor data-slot="popover-anchor" {...props} />;
+}
+
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };
diff --git a/apps/examples/desktop-app/webview/components/ui/progress.tsx b/apps/examples/desktop-app/webview/components/ui/progress.tsx
new file mode 100644
index 0000000..331bb66
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/progress.tsx
@@ -0,0 +1,31 @@
+"use client";
+
+import * as ProgressPrimitive from "@radix-ui/react-progress";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Progress({
+	className,
+	value,
+	...props
+}: React.ComponentProps<typeof ProgressPrimitive.Root>) {
+	return (
+		<ProgressPrimitive.Root
+			data-slot="progress"
+			className={cn(
+				"bg-primary/20 relative h-2 w-full overflow-hidden rounded-full",
+				className,
+			)}
+			{...props}
+		>
+			<ProgressPrimitive.Indicator
+				data-slot="progress-indicator"
+				className="bg-primary h-full w-full flex-1 transition-all"
+				style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
+			/>
+		</ProgressPrimitive.Root>
+	);
+}
+
+export { Progress };
diff --git a/apps/examples/desktop-app/webview/components/ui/radio-group.tsx b/apps/examples/desktop-app/webview/components/ui/radio-group.tsx
new file mode 100644
index 0000000..635bb2a
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/radio-group.tsx
@@ -0,0 +1,45 @@
+"use client";
+
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+import { CircleIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function RadioGroup({
+	className,
+	...props
+}: React.ComponentProps<typeof RadioGroupPrimitive.Root>) {
+	return (
+		<RadioGroupPrimitive.Root
+			data-slot="radio-group"
+			className={cn("grid gap-3", className)}
+			{...props}
+		/>
+	);
+}
+
+function RadioGroupItem({
+	className,
+	...props
+}: React.ComponentProps<typeof RadioGroupPrimitive.Item>) {
+	return (
+		<RadioGroupPrimitive.Item
+			data-slot="radio-group-item"
+			className={cn(
+				"border-input text-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 aspect-square size-4 shrink-0 rounded-full border shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		>
+			<RadioGroupPrimitive.Indicator
+				data-slot="radio-group-indicator"
+				className="relative flex items-center justify-center"
+			>
+				<CircleIcon className="fill-primary absolute top-1/2 left-1/2 size-2 -translate-x-1/2 -translate-y-1/2" />
+			</RadioGroupPrimitive.Indicator>
+		</RadioGroupPrimitive.Item>
+	);
+}
+
+export { RadioGroup, RadioGroupItem };
diff --git a/apps/examples/desktop-app/webview/components/ui/resizable.tsx b/apps/examples/desktop-app/webview/components/ui/resizable.tsx
new file mode 100644
index 0000000..a095006
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/resizable.tsx
@@ -0,0 +1,56 @@
+"use client";
+
+import { GripVerticalIcon } from "lucide-react";
+import type * as React from "react";
+import * as ResizablePrimitive from "react-resizable-panels";
+
+import { cn } from "@/lib/utils";
+
+function ResizablePanelGroup({
+	className,
+	...props
+}: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) {
+	return (
+		<ResizablePrimitive.PanelGroup
+			data-slot="resizable-panel-group"
+			className={cn(
+				"flex h-full w-full data-[panel-group-direction=vertical]:flex-col",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ResizablePanel({
+	...props
+}: React.ComponentProps<typeof ResizablePrimitive.Panel>) {
+	return <ResizablePrimitive.Panel data-slot="resizable-panel" {...props} />;
+}
+
+function ResizableHandle({
+	withHandle,
+	className,
+	...props
+}: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+	withHandle?: boolean;
+}) {
+	return (
+		<ResizablePrimitive.PanelResizeHandle
+			data-slot="resizable-handle"
+			className={cn(
+				"bg-border focus-visible:ring-ring relative flex w-px items-center justify-center after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:ring-1 focus-visible:ring-offset-1 focus-visible:outline-hidden data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:translate-x-0 data-[panel-group-direction=vertical]:after:-translate-y-1/2 [&[data-panel-group-direction=vertical]>div]:rotate-90",
+				className,
+			)}
+			{...props}
+		>
+			{withHandle && (
+				<div className="bg-border z-10 flex h-4 w-3 items-center justify-center rounded-xs border">
+					<GripVerticalIcon className="size-2.5" />
+				</div>
+			)}
+		</ResizablePrimitive.PanelResizeHandle>
+	);
+}
+
+export { ResizablePanelGroup, ResizablePanel, ResizableHandle };
diff --git a/apps/examples/desktop-app/webview/components/ui/scroll-area.tsx b/apps/examples/desktop-app/webview/components/ui/scroll-area.tsx
new file mode 100644
index 0000000..fa1fe50
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/scroll-area.tsx
@@ -0,0 +1,58 @@
+"use client";
+
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function ScrollArea({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.Root>) {
+	return (
+		<ScrollAreaPrimitive.Root
+			className={cn("relative", className)}
+			data-slot="scroll-area"
+			{...props}
+		>
+			<ScrollAreaPrimitive.Viewport
+				className="focus-visible:ring-ring/50 size-full rounded-[inherit] [scrollbar-width:none] [-ms-overflow-style:none] [&::-webkit-scrollbar]:hidden transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:outline-1"
+				data-slot="scroll-area-viewport"
+			>
+				{children}
+			</ScrollAreaPrimitive.Viewport>
+			<ScrollBar className="opacity-0 pointer-events-none" />
+			<ScrollAreaPrimitive.Corner className="hidden" />
+		</ScrollAreaPrimitive.Root>
+	);
+}
+
+function ScrollBar({
+	className,
+	orientation = "vertical",
+	...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>) {
+	return (
+		<ScrollAreaPrimitive.ScrollAreaScrollbar
+			className={cn(
+				"flex touch-none p-px transition-colors select-none",
+				orientation === "vertical" &&
+					"h-full w-2.5 border-l border-l-transparent",
+				orientation === "horizontal" &&
+					"h-2.5 flex-col border-t border-t-transparent",
+				className,
+			)}
+			data-slot="scroll-area-scrollbar"
+			orientation={orientation}
+			{...props}
+		>
+			<ScrollAreaPrimitive.ScrollAreaThumb
+				className="bg-border relative flex-1 rounded-full"
+				data-slot="scroll-area-thumb"
+			/>
+		</ScrollAreaPrimitive.ScrollAreaScrollbar>
+	);
+}
+
+export { ScrollArea, ScrollBar };
diff --git a/apps/examples/desktop-app/webview/components/ui/select.tsx b/apps/examples/desktop-app/webview/components/ui/select.tsx
new file mode 100644
index 0000000..eb93d6f
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/select.tsx
@@ -0,0 +1,185 @@
+"use client";
+
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Select({
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Root>) {
+	return <SelectPrimitive.Root data-slot="select" {...props} />;
+}
+
+function SelectGroup({
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Group>) {
+	return <SelectPrimitive.Group data-slot="select-group" {...props} />;
+}
+
+function SelectValue({
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Value>) {
+	return <SelectPrimitive.Value data-slot="select-value" {...props} />;
+}
+
+function SelectTrigger({
+	className,
+	size = "default",
+	children,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+	size?: "sm" | "default";
+}) {
+	return (
+		<SelectPrimitive.Trigger
+			data-slot="select-trigger"
+			data-size={size}
+			className={cn(
+				"border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 dark:hover:bg-input/50 flex w-fit items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<SelectPrimitive.Icon asChild>
+				<ChevronDownIcon className="size-4 opacity-50" />
+			</SelectPrimitive.Icon>
+		</SelectPrimitive.Trigger>
+	);
+}
+
+function SelectContent({
+	className,
+	children,
+	position = "popper",
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Content>) {
+	return (
+		<SelectPrimitive.Portal>
+			<SelectPrimitive.Content
+				data-slot="select-content"
+				className={cn(
+					"bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
+					position === "popper" &&
+						"data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+					className,
+				)}
+				position={position}
+				{...props}
+			>
+				<SelectScrollUpButton />
+				<SelectPrimitive.Viewport
+					className={cn(
+						"p-1",
+						position === "popper" &&
+							"h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1",
+					)}
+				>
+					{children}
+				</SelectPrimitive.Viewport>
+				<SelectScrollDownButton />
+			</SelectPrimitive.Content>
+		</SelectPrimitive.Portal>
+	);
+}
+
+function SelectLabel({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Label>) {
+	return (
+		<SelectPrimitive.Label
+			data-slot="select-label"
+			className={cn("text-muted-foreground px-2 py-1.5 text-xs", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectItem({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Item>) {
+	return (
+		<SelectPrimitive.Item
+			data-slot="select-item"
+			className={cn(
+				"focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+				className,
+			)}
+			{...props}
+		>
+			<span className="absolute right-2 flex size-3.5 items-center justify-center">
+				<SelectPrimitive.ItemIndicator>
+					<CheckIcon className="size-4" />
+				</SelectPrimitive.ItemIndicator>
+			</span>
+			<SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+		</SelectPrimitive.Item>
+	);
+}
+
+function SelectSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Separator>) {
+	return (
+		<SelectPrimitive.Separator
+			data-slot="select-separator"
+			className={cn("bg-border pointer-events-none -mx-1 my-1 h-px", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectScrollUpButton({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) {
+	return (
+		<SelectPrimitive.ScrollUpButton
+			data-slot="select-scroll-up-button"
+			className={cn(
+				"flex cursor-default items-center justify-center py-1",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronUpIcon className="size-4" />
+		</SelectPrimitive.ScrollUpButton>
+	);
+}
+
+function SelectScrollDownButton({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>) {
+	return (
+		<SelectPrimitive.ScrollDownButton
+			data-slot="select-scroll-down-button"
+			className={cn(
+				"flex cursor-default items-center justify-center py-1",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronDownIcon className="size-4" />
+		</SelectPrimitive.ScrollDownButton>
+	);
+}
+
+export {
+	Select,
+	SelectContent,
+	SelectGroup,
+	SelectItem,
+	SelectLabel,
+	SelectScrollDownButton,
+	SelectScrollUpButton,
+	SelectSeparator,
+	SelectTrigger,
+	SelectValue,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/separator.tsx b/apps/examples/desktop-app/webview/components/ui/separator.tsx
new file mode 100644
index 0000000..50f035f
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/separator.tsx
@@ -0,0 +1,28 @@
+"use client";
+
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Separator({
+	className,
+	orientation = "horizontal",
+	decorative = true,
+	...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+	return (
+		<SeparatorPrimitive.Root
+			data-slot="separator"
+			decorative={decorative}
+			orientation={orientation}
+			className={cn(
+				"bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Separator };
diff --git a/apps/examples/desktop-app/webview/components/ui/sheet.tsx b/apps/examples/desktop-app/webview/components/ui/sheet.tsx
new file mode 100644
index 0000000..899652a
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/sheet.tsx
@@ -0,0 +1,139 @@
+"use client";
+
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+import { XIcon } from "lucide-react";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive.Root>) {
+	return <SheetPrimitive.Root data-slot="sheet" {...props} />;
+}
+
+function SheetTrigger({
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Trigger>) {
+	return <SheetPrimitive.Trigger data-slot="sheet-trigger" {...props} />;
+}
+
+function SheetClose({
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Close>) {
+	return <SheetPrimitive.Close data-slot="sheet-close" {...props} />;
+}
+
+function SheetPortal({
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Portal>) {
+	return <SheetPrimitive.Portal data-slot="sheet-portal" {...props} />;
+}
+
+function SheetOverlay({
+	className,
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Overlay>) {
+	return (
+		<SheetPrimitive.Overlay
+			data-slot="sheet-overlay"
+			className={cn(
+				"data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SheetContent({
+	className,
+	children,
+	side = "right",
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Content> & {
+	side?: "top" | "right" | "bottom" | "left";
+}) {
+	return (
+		<SheetPortal>
+			<SheetOverlay />
+			<SheetPrimitive.Content
+				data-slot="sheet-content"
+				className={cn(
+					"bg-background data-[state=open]:animate-in data-[state=closed]:animate-out fixed z-50 flex flex-col gap-4 shadow-lg transition ease-in-out data-[state=closed]:duration-300 data-[state=open]:duration-500",
+					side === "right" &&
+						"data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right inset-y-0 right-0 h-full w-3/4 border-l sm:max-w-sm",
+					side === "left" &&
+						"data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left inset-y-0 left-0 h-full w-3/4 border-r sm:max-w-sm",
+					side === "top" &&
+						"data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top inset-x-0 top-0 h-auto border-b",
+					side === "bottom" &&
+						"data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom inset-x-0 bottom-0 h-auto border-t",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				<SheetPrimitive.Close className="ring-offset-background focus:ring-ring data-[state=open]:bg-secondary absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none">
+					<XIcon className="size-4" />
+					<span className="sr-only">Close</span>
+				</SheetPrimitive.Close>
+			</SheetPrimitive.Content>
+		</SheetPortal>
+	);
+}
+
+function SheetHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sheet-header"
+			className={cn("flex flex-col gap-1.5 p-4", className)}
+			{...props}
+		/>
+	);
+}
+
+function SheetFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sheet-footer"
+			className={cn("mt-auto flex flex-col gap-2 p-4", className)}
+			{...props}
+		/>
+	);
+}
+
+function SheetTitle({
+	className,
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Title>) {
+	return (
+		<SheetPrimitive.Title
+			data-slot="sheet-title"
+			className={cn("text-foreground font-semibold", className)}
+			{...props}
+		/>
+	);
+}
+
+function SheetDescription({
+	className,
+	...props
+}: React.ComponentProps<typeof SheetPrimitive.Description>) {
+	return (
+		<SheetPrimitive.Description
+			data-slot="sheet-description"
+			className={cn("text-muted-foreground text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Sheet,
+	SheetTrigger,
+	SheetClose,
+	SheetContent,
+	SheetHeader,
+	SheetFooter,
+	SheetTitle,
+	SheetDescription,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/sidebar.tsx b/apps/examples/desktop-app/webview/components/ui/sidebar.tsx
new file mode 100644
index 0000000..4ce36cc
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/sidebar.tsx
@@ -0,0 +1,862 @@
+"use client";
+
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import { PanelLeftIcon } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Separator } from "@/components/ui/separator";
+import {
+	Sheet,
+	SheetContent,
+	SheetDescription,
+	SheetHeader,
+	SheetTitle,
+} from "@/components/ui/sheet";
+import { Skeleton } from "@/components/ui/skeleton";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { useIsMobile } from "@/hooks/use-mobile";
+import { cn } from "@/lib/utils";
+
+const SIDEBAR_COOKIE_NAME = "sidebar_state";
+const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7;
+const SIDEBAR_WIDTH = 256;
+const SIDEBAR_WIDTH_MOBILE = "18rem";
+const SIDEBAR_WIDTH_ICON = "3rem";
+const SIDEBAR_KEYBOARD_SHORTCUT = "b";
+const SIDEBAR_WIDTH_COOKIE_NAME = "sidebar_width";
+const SIDEBAR_MIN_WIDTH = 224;
+const SIDEBAR_MAX_WIDTH = 560;
+
+function clampSidebarWidth(value: number): number {
+	return Math.min(SIDEBAR_MAX_WIDTH, Math.max(SIDEBAR_MIN_WIDTH, value));
+}
+
+function setCookieValue(name: string, value: string | number | boolean): void {
+	const cookie = `${encodeURIComponent(name)}=${encodeURIComponent(
+		String(value),
+	)}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`;
+	const cookieStore = (
+		globalThis as {
+			cookieStore?: {
+				set(options: {
+					name: string;
+					value: string;
+					path: string;
+					expires: number;
+				}): Promise<void>;
+			};
+		}
+	).cookieStore;
+	if (cookieStore) {
+		void cookieStore.set({
+			name,
+			value: String(value),
+			path: "/",
+			expires: Date.now() + SIDEBAR_COOKIE_MAX_AGE * 1000,
+		});
+		return;
+	}
+	const cookieSetter = Object.getOwnPropertyDescriptor(
+		Document.prototype,
+		"cookie",
+	)?.set;
+	cookieSetter?.call(document, cookie);
+}
+
+function getCookieValue(name: string): string | null {
+	if (typeof document === "undefined") {
+		return null;
+	}
+	const encoded = `${encodeURIComponent(name)}=`;
+	const found = document.cookie
+		.split(";")
+		.map((part) => part.trim())
+		.find((part) => part.startsWith(encoded));
+	if (!found) {
+		return null;
+	}
+	return decodeURIComponent(found.slice(encoded.length));
+}
+
+type SidebarContextProps = {
+	state: "expanded" | "collapsed";
+	open: boolean;
+	setOpen: (open: boolean | ((open: boolean) => boolean)) => void;
+	desktopWidth: number;
+	setDesktopWidth: (width: number) => void;
+	openMobile: boolean;
+	setOpenMobile: (open: boolean | ((open: boolean) => boolean)) => void;
+	isMobile: boolean;
+	toggleSidebar: () => void;
+};
+
+const SidebarContext = React.createContext<SidebarContextProps | null>(null);
+
+function useSidebar() {
+	const context = React.useContext(SidebarContext);
+	if (!context) {
+		throw new Error("useSidebar must be used within a SidebarProvider.");
+	}
+
+	return context;
+}
+
+function SidebarProvider({
+	defaultOpen = true,
+	open: openProp,
+	onOpenChange: setOpenProp,
+	className,
+	style,
+	children,
+	...props
+}: React.ComponentProps<"div"> & {
+	defaultOpen?: boolean;
+	open?: boolean;
+	onOpenChange?: (open: boolean) => void;
+}) {
+	const isMobile = useIsMobile();
+	const [openMobile, setOpenMobile] = React.useState(false);
+	const [desktopWidth, setDesktopWidthState] =
+		React.useState<number>(SIDEBAR_WIDTH);
+
+	// Read persisted width from cookie after hydration to avoid mismatch
+	React.useEffect(() => {
+		const cookieValue = getCookieValue(SIDEBAR_WIDTH_COOKIE_NAME);
+		const parsedWidth = Number(cookieValue);
+		if (Number.isFinite(parsedWidth)) {
+			setDesktopWidthState(clampSidebarWidth(parsedWidth));
+		}
+	}, []);
+
+	// This is the internal state of the sidebar.
+	// We use openProp and setOpenProp for control from outside the component.
+	const [_open, _setOpen] = React.useState(defaultOpen);
+	const open = openProp ?? _open;
+	const setOpen = React.useCallback(
+		(value: boolean | ((value: boolean) => boolean)) => {
+			const openState = typeof value === "function" ? value(open) : value;
+			if (setOpenProp) {
+				setOpenProp(openState);
+			} else {
+				_setOpen(openState);
+			}
+
+			setCookieValue(SIDEBAR_COOKIE_NAME, openState);
+		},
+		[setOpenProp, open],
+	);
+
+	// Helper to toggle the sidebar.
+	const toggleSidebar = React.useCallback(() => {
+		return isMobile ? setOpenMobile((open) => !open) : setOpen((open) => !open);
+	}, [isMobile, setOpen]);
+
+	const setDesktopWidth = React.useCallback((width: number) => {
+		const next = clampSidebarWidth(width);
+		setDesktopWidthState(next);
+		setCookieValue(SIDEBAR_WIDTH_COOKIE_NAME, next);
+	}, []);
+
+	// Adds a keyboard shortcut to toggle the sidebar.
+	React.useEffect(() => {
+		const handleKeyDown = (event: KeyboardEvent) => {
+			if (
+				event.key === SIDEBAR_KEYBOARD_SHORTCUT &&
+				(event.metaKey || event.ctrlKey)
+			) {
+				event.preventDefault();
+				toggleSidebar();
+			}
+		};
+
+		window.addEventListener("keydown", handleKeyDown);
+		return () => window.removeEventListener("keydown", handleKeyDown);
+	}, [toggleSidebar]);
+
+	// We add a state so that we can do data-state="expanded" or "collapsed".
+	// This makes it easier to style the sidebar with Tailwind classes.
+	const state = open ? "expanded" : "collapsed";
+
+	const contextValue = React.useMemo<SidebarContextProps>(
+		() => ({
+			state,
+			open,
+			setOpen,
+			desktopWidth,
+			setDesktopWidth,
+			isMobile,
+			openMobile,
+			setOpenMobile,
+			toggleSidebar,
+		}),
+		[
+			state,
+			open,
+			setOpen,
+			desktopWidth,
+			setDesktopWidth,
+			isMobile,
+			openMobile,
+			toggleSidebar,
+		],
+	);
+
+	return (
+		<SidebarContext.Provider value={contextValue}>
+			<TooltipProvider delayDuration={0}>
+				<div
+					data-slot="sidebar-wrapper"
+					style={
+						{
+							"--sidebar-width": `${desktopWidth}px`,
+							"--sidebar-width-icon": SIDEBAR_WIDTH_ICON,
+							...style,
+						} as React.CSSProperties
+					}
+					className={cn(
+						"group/sidebar-wrapper has-data-[variant=inset]:bg-sidebar flex min-h-svh w-full",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+				</div>
+			</TooltipProvider>
+		</SidebarContext.Provider>
+	);
+}
+
+function Sidebar({
+	side = "left",
+	variant = "sidebar",
+	collapsible = "offcanvas",
+	className,
+	children,
+	...props
+}: React.ComponentProps<"div"> & {
+	side?: "left" | "right";
+	variant?: "sidebar" | "floating" | "inset";
+	collapsible?: "offcanvas" | "icon" | "none";
+}) {
+	const { isMobile, state, openMobile, setOpenMobile } = useSidebar();
+
+	if (collapsible === "none") {
+		return (
+			<div
+				data-slot="sidebar"
+				className={cn(
+					"bg-sidebar text-sidebar-foreground flex h-full w-(--sidebar-width) flex-col",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		);
+	}
+
+	if (isMobile) {
+		return (
+			<Sheet open={openMobile} onOpenChange={setOpenMobile} {...props}>
+				<SheetContent
+					data-sidebar="sidebar"
+					data-slot="sidebar"
+					data-mobile="true"
+					className="bg-sidebar text-sidebar-foreground w-(--sidebar-width) p-0 [&>button]:hidden"
+					style={
+						{
+							"--sidebar-width": SIDEBAR_WIDTH_MOBILE,
+						} as React.CSSProperties
+					}
+					side={side}
+				>
+					<SheetHeader className="sr-only">
+						<SheetTitle>Sidebar</SheetTitle>
+						<SheetDescription>Displays the mobile sidebar.</SheetDescription>
+					</SheetHeader>
+					<div className="flex h-full w-full flex-col">{children}</div>
+				</SheetContent>
+			</Sheet>
+		);
+	}
+
+	return (
+		<div
+			className="group peer text-sidebar-foreground hidden md:block"
+			data-state={state}
+			data-collapsible={state === "collapsed" ? collapsible : ""}
+			data-variant={variant}
+			data-side={side}
+			data-slot="sidebar"
+		>
+			{/* This is what handles the sidebar gap on desktop */}
+			<div
+				data-slot="sidebar-gap"
+				className={cn(
+					"relative w-(--sidebar-width) bg-transparent transition-[width] duration-200 ease-linear",
+					"group-data-[collapsible=offcanvas]:w-0",
+					"group-data-[side=right]:rotate-180",
+					variant === "floating" || variant === "inset"
+						? "group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4)))]"
+						: "group-data-[collapsible=icon]:w-(--sidebar-width-icon)",
+				)}
+			/>
+			<div
+				data-slot="sidebar-container"
+				className={cn(
+					"fixed inset-y-0 z-10 hidden h-svh w-(--sidebar-width) transition-[left,right,width] duration-200 ease-linear md:flex",
+					side === "left"
+						? "left-0 group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]"
+						: "right-0 group-data-[collapsible=offcanvas]:right-[calc(var(--sidebar-width)*-1)]",
+					// Adjust the padding for floating and inset variants.
+					variant === "floating" || variant === "inset"
+						? "p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4))+2px)]"
+						: "group-data-[collapsible=icon]:w-(--sidebar-width-icon) group-data-[side=left]:border-r group-data-[side=right]:border-l",
+					className,
+				)}
+				{...props}
+			>
+				<div
+					data-sidebar="sidebar"
+					data-slot="sidebar-inner"
+					className="bg-sidebar group-data-[variant=floating]:border-sidebar-border flex h-full w-full flex-col group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:border group-data-[variant=floating]:shadow-sm"
+				>
+					{children}
+				</div>
+			</div>
+		</div>
+	);
+}
+
+function SidebarTrigger({
+	className,
+	onClick,
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { toggleSidebar } = useSidebar();
+
+	return (
+		<Button
+			data-sidebar="trigger"
+			data-slot="sidebar-trigger"
+			variant="ghost"
+			size="icon"
+			className={cn("size-7", className)}
+			onClick={(event) => {
+				onClick?.(event);
+				toggleSidebar();
+			}}
+			{...props}
+		>
+			<PanelLeftIcon />
+			<span className="sr-only">Toggle Sidebar</span>
+		</Button>
+	);
+}
+
+function SidebarRail({ className, ...props }: React.ComponentProps<"button">) {
+	const { setOpen, setDesktopWidth, desktopWidth } = useSidebar();
+	const didDragRef = React.useRef(false);
+
+	const handlePointerDown = React.useCallback(
+		(event: React.PointerEvent<HTMLButtonElement>) => {
+			if (event.button !== 0) {
+				return;
+			}
+			event.preventDefault();
+			const sidebarRoot = event.currentTarget.closest(
+				'[data-slot="sidebar"]',
+			) as HTMLElement | null;
+			const side = sidebarRoot?.dataset.side === "right" ? "right" : "left";
+			const startX = event.clientX;
+			const startWidth = desktopWidth;
+			didDragRef.current = false;
+			setOpen(true);
+
+			const previousCursor = document.body.style.cursor;
+			const previousUserSelect = document.body.style.userSelect;
+			document.body.style.cursor = "ew-resize";
+			document.body.style.userSelect = "none";
+
+			const handlePointerMove = (moveEvent: PointerEvent) => {
+				const delta =
+					side === "left"
+						? moveEvent.clientX - startX
+						: startX - moveEvent.clientX;
+				if (Math.abs(delta) > 2) {
+					didDragRef.current = true;
+				}
+				setDesktopWidth(startWidth + delta);
+			};
+
+			const cleanup = () => {
+				document.body.style.cursor = previousCursor;
+				document.body.style.userSelect = previousUserSelect;
+				window.removeEventListener("pointermove", handlePointerMove);
+				window.removeEventListener("pointerup", cleanup);
+			};
+
+			window.addEventListener("pointermove", handlePointerMove);
+			window.addEventListener("pointerup", cleanup);
+		},
+		[desktopWidth, setDesktopWidth, setOpen],
+	);
+
+	const handleClick = React.useCallback(() => {
+		if (didDragRef.current) {
+			didDragRef.current = false;
+			return;
+		}
+		setOpen((open) => !open);
+	}, [setOpen]);
+
+	return (
+		<button
+			data-sidebar="rail"
+			data-slot="sidebar-rail"
+			aria-label="Toggle Sidebar"
+			tabIndex={-1}
+			onClick={handleClick}
+			onPointerDown={handlePointerDown}
+			title="Drag to resize or click to toggle sidebar"
+			className={cn(
+				"hover:after:bg-sidebar-border absolute inset-y-0 z-20 hidden w-4 -translate-x-1/2 transition-all ease-linear group-data-[side=left]:-right-4 group-data-[side=right]:left-0 after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] sm:flex",
+				"in-data-[side=left]:cursor-w-resize in-data-[side=right]:cursor-e-resize",
+				"[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize",
+				"hover:group-data-[collapsible=offcanvas]:bg-sidebar group-data-[collapsible=offcanvas]:translate-x-0 group-data-[collapsible=offcanvas]:after:left-full",
+				"[[data-side=left][data-collapsible=offcanvas]_&]:-right-2",
+				"[[data-side=right][data-collapsible=offcanvas]_&]:-left-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarInset({ className, ...props }: React.ComponentProps<"main">) {
+	return (
+		<main
+			data-slot="sidebar-inset"
+			className={cn(
+				"bg-background relative flex w-full flex-1 flex-col",
+				"md:peer-data-[variant=inset]:m-2 md:peer-data-[variant=inset]:ml-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow-sm md:peer-data-[variant=inset]:peer-data-[state=collapsed]:ml-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarInput({
+	className,
+	...props
+}: React.ComponentProps<typeof Input>) {
+	return (
+		<Input
+			data-slot="sidebar-input"
+			data-sidebar="input"
+			className={cn("bg-background h-8 w-full shadow-none", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sidebar-header"
+			data-sidebar="header"
+			className={cn("flex flex-col gap-2 p-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sidebar-footer"
+			data-sidebar="footer"
+			className={cn("flex flex-col gap-2 p-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof Separator>) {
+	return (
+		<Separator
+			data-slot="sidebar-separator"
+			data-sidebar="separator"
+			className={cn("bg-sidebar-border mx-2 w-auto", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sidebar-content"
+			data-sidebar="content"
+			className={cn(
+				"flex min-h-0 flex-1 flex-col gap-2 overflow-auto group-data-[collapsible=icon]:overflow-hidden",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sidebar-group"
+			data-sidebar="group"
+			className={cn("relative flex w-full min-w-0 flex-col p-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarGroupLabel({
+	className,
+	asChild = false,
+	...props
+}: React.ComponentProps<"div"> & { asChild?: boolean }) {
+	const Comp = asChild ? Slot : "div";
+
+	return (
+		<Comp
+			data-slot="sidebar-group-label"
+			data-sidebar="group-label"
+			className={cn(
+				"text-sidebar-foreground/70 ring-sidebar-ring flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium outline-hidden transition-[margin,opacity] duration-200 ease-linear focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
+				"group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarGroupAction({
+	className,
+	asChild = false,
+	...props
+}: React.ComponentProps<"button"> & { asChild?: boolean }) {
+	const Comp = asChild ? Slot : "button";
+
+	return (
+		<Comp
+			data-slot="sidebar-group-action"
+			data-sidebar="group-action"
+			className={cn(
+				"text-sidebar-foreground ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground absolute top-3.5 right-3 flex aspect-square w-5 items-center justify-center rounded-md p-0 outline-hidden transition-transform focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
+				// Increases the hit area of the button on mobile.
+				"after:absolute after:-inset-2 md:after:hidden",
+				"group-data-[collapsible=icon]:hidden",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarGroupContent({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sidebar-group-content"
+			data-sidebar="group-content"
+			className={cn("w-full text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">) {
+	return (
+		<ul
+			data-slot="sidebar-menu"
+			data-sidebar="menu"
+			className={cn("flex w-full min-w-0 flex-col gap-1", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">) {
+	return (
+		<li
+			data-slot="sidebar-menu-item"
+			data-sidebar="menu-item"
+			className={cn("group/menu-item relative", className)}
+			{...props}
+		/>
+	);
+}
+
+const sidebarMenuButtonVariants = cva(
+	"peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-hidden ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-data-[sidebar=menu-action]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:size-8! group-data-[collapsible=icon]:p-2! [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
+	{
+		variants: {
+			variant: {
+				default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
+				outline:
+					"bg-background shadow-[0_0_0_1px_hsl(var(--sidebar-border))] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_hsl(var(--sidebar-accent))]",
+			},
+			size: {
+				default: "h-8 text-sm",
+				sm: "h-7 text-xs",
+				lg: "h-12 text-sm group-data-[collapsible=icon]:p-0!",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+);
+
+function SidebarMenuButton({
+	asChild = false,
+	isActive = false,
+	variant = "default",
+	size = "default",
+	tooltip,
+	className,
+	...props
+}: React.ComponentProps<"button"> & {
+	asChild?: boolean;
+	isActive?: boolean;
+	tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>) {
+	const Comp = asChild ? Slot : "button";
+	const { isMobile, state } = useSidebar();
+
+	const button = (
+		<Comp
+			data-slot="sidebar-menu-button"
+			data-sidebar="menu-button"
+			data-size={size}
+			data-active={isActive}
+			className={cn(sidebarMenuButtonVariants({ variant, size }), className)}
+			{...props}
+		/>
+	);
+
+	if (!tooltip) {
+		return button;
+	}
+
+	if (typeof tooltip === "string") {
+		tooltip = {
+			children: tooltip,
+		};
+	}
+
+	return (
+		<Tooltip>
+			<TooltipTrigger asChild>{button}</TooltipTrigger>
+			<TooltipContent
+				side="right"
+				align="center"
+				hidden={state !== "collapsed" || isMobile}
+				{...tooltip}
+			/>
+		</Tooltip>
+	);
+}
+
+function SidebarMenuAction({
+	className,
+	asChild = false,
+	showOnHover = false,
+	...props
+}: React.ComponentProps<"button"> & {
+	asChild?: boolean;
+	showOnHover?: boolean;
+}) {
+	const Comp = asChild ? Slot : "button";
+
+	return (
+		<Comp
+			data-slot="sidebar-menu-action"
+			data-sidebar="menu-action"
+			className={cn(
+				"text-sidebar-foreground ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground peer-hover/menu-button:text-sidebar-accent-foreground absolute top-1.5 right-1 flex aspect-square w-5 items-center justify-center rounded-md p-0 outline-hidden transition-transform focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
+				// Increases the hit area of the button on mobile.
+				"after:absolute after:-inset-2 md:after:hidden",
+				"peer-data-[size=sm]/menu-button:top-1",
+				"peer-data-[size=default]/menu-button:top-1.5",
+				"peer-data-[size=lg]/menu-button:top-2.5",
+				"group-data-[collapsible=icon]:hidden",
+				showOnHover &&
+					"peer-data-[active=true]/menu-button:text-sidebar-accent-foreground group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 md:opacity-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarMenuBadge({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="sidebar-menu-badge"
+			data-sidebar="menu-badge"
+			className={cn(
+				"text-sidebar-foreground pointer-events-none absolute right-1 flex h-5 min-w-5 items-center justify-center rounded-md px-1 text-xs font-medium tabular-nums select-none",
+				"peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[active=true]/menu-button:text-sidebar-accent-foreground",
+				"peer-data-[size=sm]/menu-button:top-1",
+				"peer-data-[size=default]/menu-button:top-1.5",
+				"peer-data-[size=lg]/menu-button:top-2.5",
+				"group-data-[collapsible=icon]:hidden",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarMenuSkeleton({
+	className,
+	showIcon = false,
+	...props
+}: React.ComponentProps<"div"> & {
+	showIcon?: boolean;
+}) {
+	// Random width between 50 to 90%.
+	const width = React.useMemo(() => {
+		return `${Math.floor(Math.random() * 40) + 50}%`;
+	}, []);
+
+	return (
+		<div
+			data-slot="sidebar-menu-skeleton"
+			data-sidebar="menu-skeleton"
+			className={cn("flex h-8 items-center gap-2 rounded-md px-2", className)}
+			{...props}
+		>
+			{showIcon && (
+				<Skeleton
+					className="size-4 rounded-md"
+					data-sidebar="menu-skeleton-icon"
+				/>
+			)}
+			<Skeleton
+				className="h-4 max-w-(--skeleton-width) flex-1"
+				data-sidebar="menu-skeleton-text"
+				style={
+					{
+						"--skeleton-width": width,
+					} as React.CSSProperties
+				}
+			/>
+		</div>
+	);
+}
+
+function SidebarMenuSub({ className, ...props }: React.ComponentProps<"ul">) {
+	return (
+		<ul
+			data-slot="sidebar-menu-sub"
+			data-sidebar="menu-sub"
+			className={cn(
+				"border-sidebar-border mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l px-2.5 py-0.5",
+				"group-data-[collapsible=icon]:hidden",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarMenuSubItem({
+	className,
+	...props
+}: React.ComponentProps<"li">) {
+	return (
+		<li
+			data-slot="sidebar-menu-sub-item"
+			data-sidebar="menu-sub-item"
+			className={cn("group/menu-sub-item relative", className)}
+			{...props}
+		/>
+	);
+}
+
+function SidebarMenuSubButton({
+	asChild = false,
+	size = "md",
+	isActive = false,
+	className,
+	...props
+}: React.ComponentProps<"a"> & {
+	asChild?: boolean;
+	size?: "sm" | "md";
+	isActive?: boolean;
+}) {
+	const Comp = asChild ? Slot : "a";
+
+	return (
+		<Comp
+			data-slot="sidebar-menu-sub-button"
+			data-sidebar="menu-sub-button"
+			data-size={size}
+			data-active={isActive}
+			className={cn(
+				"text-sidebar-foreground ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground active:bg-sidebar-accent active:text-sidebar-accent-foreground [&>svg]:text-sidebar-accent-foreground flex h-7 min-w-0 -translate-x-px items-center gap-2 overflow-hidden rounded-md px-2 outline-hidden focus-visible:ring-2 disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
+				"data-[active=true]:bg-sidebar-accent data-[active=true]:text-sidebar-accent-foreground",
+				size === "sm" && "text-xs",
+				size === "md" && "text-sm",
+				"group-data-[collapsible=icon]:hidden",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Sidebar,
+	SidebarContent,
+	SidebarFooter,
+	SidebarGroup,
+	SidebarGroupAction,
+	SidebarGroupContent,
+	SidebarGroupLabel,
+	SidebarHeader,
+	SidebarInput,
+	SidebarInset,
+	SidebarMenu,
+	SidebarMenuAction,
+	SidebarMenuBadge,
+	SidebarMenuButton,
+	SidebarMenuItem,
+	SidebarMenuSkeleton,
+	SidebarMenuSub,
+	SidebarMenuSubButton,
+	SidebarMenuSubItem,
+	SidebarProvider,
+	SidebarRail,
+	SidebarSeparator,
+	SidebarTrigger,
+	useSidebar,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/skeleton.tsx b/apps/examples/desktop-app/webview/components/ui/skeleton.tsx
new file mode 100644
index 0000000..eded6ce
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/skeleton.tsx
@@ -0,0 +1,13 @@
+import { cn } from "@/lib/utils";
+
+function Skeleton({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="skeleton"
+			className={cn("bg-accent animate-pulse rounded-md", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Skeleton };
diff --git a/apps/examples/desktop-app/webview/components/ui/slider.tsx b/apps/examples/desktop-app/webview/components/ui/slider.tsx
new file mode 100644
index 0000000..837f319
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/slider.tsx
@@ -0,0 +1,69 @@
+"use client";
+
+import * as SliderPrimitive from "@radix-ui/react-slider";
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Slider({
+	className,
+	defaultValue,
+	value,
+	min = 0,
+	max = 100,
+	...props
+}: React.ComponentProps<typeof SliderPrimitive.Root>) {
+	const _values = React.useMemo(
+		() =>
+			Array.isArray(value)
+				? value
+				: Array.isArray(defaultValue)
+					? defaultValue
+					: [min, max],
+		[value, defaultValue, min, max],
+	);
+	const thumbKeyCounts = new Map<string, number>();
+
+	return (
+		<SliderPrimitive.Root
+			data-slot="slider"
+			defaultValue={defaultValue}
+			value={value}
+			min={min}
+			max={max}
+			className={cn(
+				"relative flex w-full touch-none items-center select-none data-[disabled]:opacity-50 data-[orientation=vertical]:h-full data-[orientation=vertical]:min-h-44 data-[orientation=vertical]:w-auto data-[orientation=vertical]:flex-col",
+				className,
+			)}
+			{...props}
+		>
+			<SliderPrimitive.Track
+				data-slot="slider-track"
+				className={
+					"bg-muted relative grow overflow-hidden rounded-full data-[orientation=horizontal]:h-1.5 data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-1.5"
+				}
+			>
+				<SliderPrimitive.Range
+					data-slot="slider-range"
+					className={
+						"bg-primary absolute data-[orientation=horizontal]:h-full data-[orientation=vertical]:w-full"
+					}
+				/>
+			</SliderPrimitive.Track>
+			{_values.map((thumbValue) => {
+				const valueKey = String(thumbValue);
+				const occurrence = (thumbKeyCounts.get(valueKey) ?? 0) + 1;
+				thumbKeyCounts.set(valueKey, occurrence);
+				return (
+					<SliderPrimitive.Thumb
+						data-slot="slider-thumb"
+						key={`${valueKey}-${occurrence}`}
+						className="border-primary ring-ring/50 block size-4 shrink-0 rounded-full border bg-white shadow-sm transition-[color,box-shadow] hover:ring-4 focus-visible:ring-4 focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-50"
+					/>
+				);
+			})}
+		</SliderPrimitive.Root>
+	);
+}
+
+export { Slider };
diff --git a/apps/examples/desktop-app/webview/components/ui/sonner.tsx b/apps/examples/desktop-app/webview/components/ui/sonner.tsx
new file mode 100644
index 0000000..b08c2e8
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/sonner.tsx
@@ -0,0 +1,25 @@
+"use client";
+
+import { useTheme } from "next-themes";
+import { Toaster as Sonner, type ToasterProps } from "sonner";
+
+const Toaster = ({ ...props }: ToasterProps) => {
+	const { theme = "system" } = useTheme();
+
+	return (
+		<Sonner
+			theme={theme as ToasterProps["theme"]}
+			className="toaster group"
+			style={
+				{
+					"--normal-bg": "var(--popover)",
+					"--normal-text": "var(--popover-foreground)",
+					"--normal-border": "var(--border)",
+				} as React.CSSProperties
+			}
+			{...props}
+		/>
+	);
+};
+
+export { Toaster };
diff --git a/apps/examples/desktop-app/webview/components/ui/spinner.tsx b/apps/examples/desktop-app/webview/components/ui/spinner.tsx
new file mode 100644
index 0000000..884069e
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/spinner.tsx
@@ -0,0 +1,16 @@
+import { Loader2Icon } from "lucide-react";
+
+import { cn } from "@/lib/utils";
+
+function Spinner({ className, ...props }: React.ComponentProps<"svg">) {
+	return (
+		<Loader2Icon
+			role="status"
+			aria-label="Loading"
+			className={cn("size-4 animate-spin", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Spinner };
diff --git a/apps/examples/desktop-app/webview/components/ui/switch.tsx b/apps/examples/desktop-app/webview/components/ui/switch.tsx
new file mode 100644
index 0000000..8cd98d1
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/switch.tsx
@@ -0,0 +1,31 @@
+"use client";
+
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Switch({
+	className,
+	...props
+}: React.ComponentProps<typeof SwitchPrimitive.Root>) {
+	return (
+		<SwitchPrimitive.Root
+			data-slot="switch"
+			className={cn(
+				"peer cursor-pointer data-[state=checked]:bg-primary/20 data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-foreground/20 shadow-xs transition-all outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		>
+			<SwitchPrimitive.Thumb
+				data-slot="switch-thumb"
+				className={
+					"bg-foreground/50 dark:data-[state=unchecked]:bg-foreground dark:data-[state=checked]:bg-primary-foreground pointer-events-none block size-4 rounded-full ring-0 transition-transform data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0"
+				}
+			/>
+		</SwitchPrimitive.Root>
+	);
+}
+
+export { Switch };
diff --git a/apps/examples/desktop-app/webview/components/ui/table.tsx b/apps/examples/desktop-app/webview/components/ui/table.tsx
new file mode 100644
index 0000000..15e26cf
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/table.tsx
@@ -0,0 +1,116 @@
+"use client";
+
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Table({ className, ...props }: React.ComponentProps<"table">) {
+	return (
+		<div
+			data-slot="table-container"
+			className="relative w-full overflow-x-auto"
+		>
+			<table
+				data-slot="table"
+				className={cn("w-full caption-bottom text-sm", className)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function TableHeader({ className, ...props }: React.ComponentProps<"thead">) {
+	return (
+		<thead
+			data-slot="table-header"
+			className={cn("[&_tr]:border-b", className)}
+			{...props}
+		/>
+	);
+}
+
+function TableBody({ className, ...props }: React.ComponentProps<"tbody">) {
+	return (
+		<tbody
+			data-slot="table-body"
+			className={cn("[&_tr:last-child]:border-0", className)}
+			{...props}
+		/>
+	);
+}
+
+function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">) {
+	return (
+		<tfoot
+			data-slot="table-footer"
+			className={cn(
+				"bg-muted/50 border-t font-medium [&>tr]:last:border-b-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableRow({ className, ...props }: React.ComponentProps<"tr">) {
+	return (
+		<tr
+			data-slot="table-row"
+			className={cn(
+				"hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableHead({ className, ...props }: React.ComponentProps<"th">) {
+	return (
+		<th
+			data-slot="table-head"
+			className={cn(
+				"text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableCell({ className, ...props }: React.ComponentProps<"td">) {
+	return (
+		<td
+			data-slot="table-cell"
+			className={cn(
+				"p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableCaption({
+	className,
+	...props
+}: React.ComponentProps<"caption">) {
+	return (
+		<caption
+			data-slot="table-caption"
+			className={cn("text-muted-foreground mt-4 text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Table,
+	TableHeader,
+	TableBody,
+	TableFooter,
+	TableHead,
+	TableRow,
+	TableCell,
+	TableCaption,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/tabs.tsx b/apps/examples/desktop-app/webview/components/ui/tabs.tsx
new file mode 100644
index 0000000..49731f6
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/tabs.tsx
@@ -0,0 +1,66 @@
+"use client";
+
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Tabs({
+	className,
+	...props
+}: React.ComponentProps<typeof TabsPrimitive.Root>) {
+	return (
+		<TabsPrimitive.Root
+			data-slot="tabs"
+			className={cn("flex flex-col gap-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function TabsList({
+	className,
+	...props
+}: React.ComponentProps<typeof TabsPrimitive.List>) {
+	return (
+		<TabsPrimitive.List
+			data-slot="tabs-list"
+			className={cn(
+				"bg-muted text-muted-foreground inline-flex h-9 w-fit items-center justify-center rounded-lg p-[3px]",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TabsTrigger({
+	className,
+	...props
+}: React.ComponentProps<typeof TabsPrimitive.Trigger>) {
+	return (
+		<TabsPrimitive.Trigger
+			data-slot="tabs-trigger"
+			className={cn(
+				"data-[state=active]:bg-background dark:data-[state=active]:text-foreground focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 text-foreground dark:text-muted-foreground inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-2 py-1 text-sm font-medium whitespace-nowrap transition-[color,box-shadow] focus-visible:ring-[3px] focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:shadow-sm [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TabsContent({
+	className,
+	...props
+}: React.ComponentProps<typeof TabsPrimitive.Content>) {
+	return (
+		<TabsPrimitive.Content
+			data-slot="tabs-content"
+			className={cn("flex-1 outline-none", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent };
diff --git a/apps/examples/desktop-app/webview/components/ui/textarea.tsx b/apps/examples/desktop-app/webview/components/ui/textarea.tsx
new file mode 100644
index 0000000..70e5b64
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/textarea.tsx
@@ -0,0 +1,18 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
+	return (
+		<textarea
+			data-slot="textarea"
+			className={cn(
+				"border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 flex field-sizing-content min-h-16 w-full rounded-md border bg-transparent px-3 py-2 text-base shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Textarea };
diff --git a/apps/examples/desktop-app/webview/components/ui/toast.tsx b/apps/examples/desktop-app/webview/components/ui/toast.tsx
new file mode 100644
index 0000000..832b6ae
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/toast.tsx
@@ -0,0 +1,129 @@
+"use client";
+
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { cva, type VariantProps } from "class-variance-authority";
+import { X } from "lucide-react";
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const ToastProvider = ToastPrimitives.Provider;
+
+const ToastViewport = React.forwardRef<
+	React.ElementRef<typeof ToastPrimitives.Viewport>,
+	React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
+>(({ className, ...props }, ref) => (
+	<ToastPrimitives.Viewport
+		ref={ref}
+		className={cn(
+			"fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]",
+			className,
+		)}
+		{...props}
+	/>
+));
+ToastViewport.displayName = ToastPrimitives.Viewport.displayName;
+
+const toastVariants = cva(
+	"group pointer-events-auto relative flex w-full items-center justify-between space-x-4 overflow-hidden rounded-md border p-6 pr-8 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full",
+	{
+		variants: {
+			variant: {
+				default: "border bg-background text-foreground",
+				destructive:
+					"destructive group border-destructive bg-destructive text-destructive-foreground",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+const Toast = React.forwardRef<
+	React.ElementRef<typeof ToastPrimitives.Root>,
+	React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> &
+		VariantProps<typeof toastVariants>
+>(({ className, variant, ...props }, ref) => {
+	return (
+		<ToastPrimitives.Root
+			ref={ref}
+			className={cn(toastVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+});
+Toast.displayName = ToastPrimitives.Root.displayName;
+
+const ToastAction = React.forwardRef<
+	React.ElementRef<typeof ToastPrimitives.Action>,
+	React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
+>(({ className, ...props }, ref) => (
+	<ToastPrimitives.Action
+		ref={ref}
+		className={cn(
+			"inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium ring-offset-background transition-colors hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive",
+			className,
+		)}
+		{...props}
+	/>
+));
+ToastAction.displayName = ToastPrimitives.Action.displayName;
+
+const ToastClose = React.forwardRef<
+	React.ElementRef<typeof ToastPrimitives.Close>,
+	React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
+>(({ className, ...props }, ref) => (
+	<ToastPrimitives.Close
+		ref={ref}
+		className={cn(
+			"absolute right-2 top-2 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-2 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600",
+			className,
+		)}
+		toast-close=""
+		{...props}
+	>
+		<X className="h-4 w-4" />
+	</ToastPrimitives.Close>
+));
+ToastClose.displayName = ToastPrimitives.Close.displayName;
+
+const ToastTitle = React.forwardRef<
+	React.ElementRef<typeof ToastPrimitives.Title>,
+	React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
+>(({ className, ...props }, ref) => (
+	<ToastPrimitives.Title
+		ref={ref}
+		className={cn("text-sm font-semibold", className)}
+		{...props}
+	/>
+));
+ToastTitle.displayName = ToastPrimitives.Title.displayName;
+
+const ToastDescription = React.forwardRef<
+	React.ElementRef<typeof ToastPrimitives.Description>,
+	React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
+>(({ className, ...props }, ref) => (
+	<ToastPrimitives.Description
+		ref={ref}
+		className={cn("text-sm opacity-90", className)}
+		{...props}
+	/>
+));
+ToastDescription.displayName = ToastPrimitives.Description.displayName;
+
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+
+export {
+	type ToastProps,
+	type ToastActionElement,
+	ToastProvider,
+	ToastViewport,
+	Toast,
+	ToastTitle,
+	ToastDescription,
+	ToastClose,
+	ToastAction,
+};
diff --git a/apps/examples/desktop-app/webview/components/ui/toaster.tsx b/apps/examples/desktop-app/webview/components/ui/toaster.tsx
new file mode 100644
index 0000000..a2afcb4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/toaster.tsx
@@ -0,0 +1,31 @@
+"use client";
+
+import {
+	Toast,
+	ToastClose,
+	ToastDescription,
+	ToastProvider,
+	ToastTitle,
+	ToastViewport,
+} from "@/components/ui/toast";
+import { useToast } from "@/hooks/use-toast";
+
+export function Toaster() {
+	const { toasts } = useToast();
+
+	return (
+		<ToastProvider>
+			{toasts.map(({ id, title, description, action, ...props }) => (
+				<Toast key={id} {...props}>
+					<div className="grid gap-1">
+						{title && <ToastTitle>{title}</ToastTitle>}
+						{description && <ToastDescription>{description}</ToastDescription>}
+					</div>
+					{action}
+					<ToastClose />
+				</Toast>
+			))}
+			<ToastViewport />
+		</ToastProvider>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/ui/toggle-group.tsx b/apps/examples/desktop-app/webview/components/ui/toggle-group.tsx
new file mode 100644
index 0000000..6d775c8
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/toggle-group.tsx
@@ -0,0 +1,72 @@
+"use client";
+
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import type { VariantProps } from "class-variance-authority";
+import * as React from "react";
+import { toggleVariants } from "@/components/ui/toggle";
+import { cn } from "@/lib/utils";
+
+const ToggleGroupContext = React.createContext<
+	VariantProps<typeof toggleVariants>
+>({
+	size: "default",
+	variant: "default",
+});
+
+function ToggleGroup({
+	className,
+	variant,
+	size,
+	children,
+	...props
+}: React.ComponentProps<typeof ToggleGroupPrimitive.Root> &
+	VariantProps<typeof toggleVariants>) {
+	return (
+		<ToggleGroupPrimitive.Root
+			data-slot="toggle-group"
+			data-variant={variant}
+			data-size={size}
+			className={cn(
+				"group/toggle-group flex w-fit items-center rounded-md data-[variant=outline]:shadow-xs",
+				className,
+			)}
+			{...props}
+		>
+			<ToggleGroupContext.Provider value={{ variant, size }}>
+				{children}
+			</ToggleGroupContext.Provider>
+		</ToggleGroupPrimitive.Root>
+	);
+}
+
+function ToggleGroupItem({
+	className,
+	children,
+	variant,
+	size,
+	...props
+}: React.ComponentProps<typeof ToggleGroupPrimitive.Item> &
+	VariantProps<typeof toggleVariants>) {
+	const context = React.useContext(ToggleGroupContext);
+
+	return (
+		<ToggleGroupPrimitive.Item
+			data-slot="toggle-group-item"
+			data-variant={context.variant || variant}
+			data-size={context.size || size}
+			className={cn(
+				toggleVariants({
+					variant: context.variant || variant,
+					size: context.size || size,
+				}),
+				"min-w-0 flex-1 shrink-0 rounded-none shadow-none first:rounded-l-md last:rounded-r-md focus:z-10 focus-visible:z-10 data-[variant=outline]:border-l-0 data-[variant=outline]:first:border-l",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+		</ToggleGroupPrimitive.Item>
+	);
+}
+
+export { ToggleGroup, ToggleGroupItem };
diff --git a/apps/examples/desktop-app/webview/components/ui/toggle.tsx b/apps/examples/desktop-app/webview/components/ui/toggle.tsx
new file mode 100644
index 0000000..91cdcee
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/toggle.tsx
@@ -0,0 +1,47 @@
+"use client";
+
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const toggleVariants = cva(
+	"inline-flex items-center cursor-pointer justify-center gap-2 rounded-md text-sm font-medium hover:bg-muted hover:text-muted-foreground disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 [&_svg]:shrink-0 focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] outline-none transition-[color,box-shadow] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive whitespace-nowrap",
+	{
+		variants: {
+			variant: {
+				default: "bg-transparent",
+				outline:
+					"border border-input bg-transparent shadow-xs hover:bg-accent hover:text-accent-foreground",
+			},
+			size: {
+				default: "h-9 px-2 min-w-9",
+				sm: "h-8 px-1.5 min-w-8",
+				lg: "h-10 px-2.5 min-w-10",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+);
+
+function Toggle({
+	className,
+	variant,
+	size,
+	...props
+}: React.ComponentProps<typeof TogglePrimitive.Root> &
+	VariantProps<typeof toggleVariants>) {
+	return (
+		<TogglePrimitive.Root
+			data-slot="toggle"
+			className={cn(toggleVariants({ variant, size, className }))}
+			{...props}
+		/>
+	);
+}
+
+export { Toggle, toggleVariants };
diff --git a/apps/examples/desktop-app/webview/components/ui/tooltip.tsx b/apps/examples/desktop-app/webview/components/ui/tooltip.tsx
new file mode 100644
index 0000000..1018c00
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/tooltip.tsx
@@ -0,0 +1,61 @@
+"use client";
+
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function TooltipProvider({
+	delayDuration = 0,
+	...props
+}: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
+	return (
+		<TooltipPrimitive.Provider
+			data-slot="tooltip-provider"
+			delayDuration={delayDuration}
+			{...props}
+		/>
+	);
+}
+
+function Tooltip({
+	...props
+}: React.ComponentProps<typeof TooltipPrimitive.Root>) {
+	return (
+		<TooltipProvider>
+			<TooltipPrimitive.Root data-slot="tooltip" {...props} />
+		</TooltipProvider>
+	);
+}
+
+function TooltipTrigger({
+	...props
+}: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
+	return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+}
+
+function TooltipContent({
+	className,
+	sideOffset = 0,
+	children,
+	...props
+}: React.ComponentProps<typeof TooltipPrimitive.Content>) {
+	return (
+		<TooltipPrimitive.Portal>
+			<TooltipPrimitive.Content
+				data-slot="tooltip-content"
+				sideOffset={sideOffset}
+				className={cn(
+					"bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				<TooltipPrimitive.Arrow className="bg-foreground fill-foreground z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]" />
+			</TooltipPrimitive.Content>
+		</TooltipPrimitive.Portal>
+	);
+}
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
diff --git a/apps/examples/desktop-app/webview/components/ui/use-mobile.tsx b/apps/examples/desktop-app/webview/components/ui/use-mobile.tsx
new file mode 100644
index 0000000..0a89231
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/use-mobile.tsx
@@ -0,0 +1,21 @@
+import * as React from "react";
+
+const MOBILE_BREAKPOINT = 768;
+
+export function useIsMobile() {
+	const [isMobile, setIsMobile] = React.useState<boolean | undefined>(
+		undefined,
+	);
+
+	React.useEffect(() => {
+		const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+		const onChange = () => {
+			setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+		};
+		mql.addEventListener("change", onChange);
+		setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+		return () => mql.removeEventListener("change", onChange);
+	}, []);
+
+	return !!isMobile;
+}
diff --git a/apps/examples/desktop-app/webview/components/ui/use-toast.ts b/apps/examples/desktop-app/webview/components/ui/use-toast.ts
new file mode 100644
index 0000000..7997c77
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/ui/use-toast.ts
@@ -0,0 +1,191 @@
+"use client";
+
+// Inspired by react-hot-toast library
+import * as React from "react";
+
+import type { ToastActionElement, ToastProps } from "@/components/ui/toast";
+
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+
+type ToasterToast = ToastProps & {
+	id: string;
+	title?: React.ReactNode;
+	description?: React.ReactNode;
+	action?: ToastActionElement;
+};
+
+const actionTypes = {
+	ADD_TOAST: "ADD_TOAST",
+	UPDATE_TOAST: "UPDATE_TOAST",
+	DISMISS_TOAST: "DISMISS_TOAST",
+	REMOVE_TOAST: "REMOVE_TOAST",
+} as const;
+
+let count = 0;
+
+function genId() {
+	count = (count + 1) % Number.MAX_SAFE_INTEGER;
+	return count.toString();
+}
+
+type ActionType = typeof actionTypes;
+
+type Action =
+	| {
+			type: ActionType["ADD_TOAST"];
+			toast: ToasterToast;
+	  }
+	| {
+			type: ActionType["UPDATE_TOAST"];
+			toast: Partial<ToasterToast>;
+	  }
+	| {
+			type: ActionType["DISMISS_TOAST"];
+			toastId?: ToasterToast["id"];
+	  }
+	| {
+			type: ActionType["REMOVE_TOAST"];
+			toastId?: ToasterToast["id"];
+	  };
+
+interface State {
+	toasts: ToasterToast[];
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>();
+
+const addToRemoveQueue = (toastId: string) => {
+	if (toastTimeouts.has(toastId)) {
+		return;
+	}
+
+	const timeout = setTimeout(() => {
+		toastTimeouts.delete(toastId);
+		dispatch({
+			type: "REMOVE_TOAST",
+			toastId: toastId,
+		});
+	}, TOAST_REMOVE_DELAY);
+
+	toastTimeouts.set(toastId, timeout);
+};
+
+export const reducer = (state: State, action: Action): State => {
+	switch (action.type) {
+		case "ADD_TOAST":
+			return {
+				...state,
+				toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+			};
+
+		case "UPDATE_TOAST":
+			return {
+				...state,
+				toasts: state.toasts.map((t) =>
+					t.id === action.toast.id ? { ...t, ...action.toast } : t,
+				),
+			};
+
+		case "DISMISS_TOAST": {
+			const { toastId } = action;
+
+			// ! Side effects ! - This could be extracted into a dismissToast() action,
+			// but I'll keep it here for simplicity
+			if (toastId) {
+				addToRemoveQueue(toastId);
+			} else {
+				state.toasts.forEach((toast) => {
+					addToRemoveQueue(toast.id);
+				});
+			}
+
+			return {
+				...state,
+				toasts: state.toasts.map((t) =>
+					t.id === toastId || toastId === undefined
+						? {
+								...t,
+								open: false,
+							}
+						: t,
+				),
+			};
+		}
+		case "REMOVE_TOAST":
+			if (action.toastId === undefined) {
+				return {
+					...state,
+					toasts: [],
+				};
+			}
+			return {
+				...state,
+				toasts: state.toasts.filter((t) => t.id !== action.toastId),
+			};
+	}
+};
+
+const listeners: Array<(state: State) => void> = [];
+
+let memoryState: State = { toasts: [] };
+
+function dispatch(action: Action) {
+	memoryState = reducer(memoryState, action);
+	listeners.forEach((listener) => {
+		listener(memoryState);
+	});
+}
+
+type Toast = Omit<ToasterToast, "id">;
+
+function toast({ ...props }: Toast) {
+	const id = genId();
+
+	const update = (props: ToasterToast) =>
+		dispatch({
+			type: "UPDATE_TOAST",
+			toast: { ...props, id },
+		});
+	const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+
+	dispatch({
+		type: "ADD_TOAST",
+		toast: {
+			...props,
+			id,
+			open: true,
+			onOpenChange: (open) => {
+				if (!open) dismiss();
+			},
+		},
+	});
+
+	return {
+		id: id,
+		dismiss,
+		update,
+	};
+}
+
+function useToast() {
+	const [state, setState] = React.useState<State>(memoryState);
+
+	React.useEffect(() => {
+		listeners.push(setState);
+		return () => {
+			const index = listeners.indexOf(setState);
+			if (index > -1) {
+				listeners.splice(index, 1);
+			}
+		};
+	}, []);
+
+	return {
+		...state,
+		toast,
+		dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+	};
+}
+
+export { useToast, toast };
diff --git a/apps/examples/desktop-app/webview/components/utils.ts b/apps/examples/desktop-app/webview/components/utils.ts
new file mode 100644
index 0000000..376ede4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/utils.ts
@@ -0,0 +1,6 @@
+import { formatDisplayUserInput } from "@cline/shared/browser";
+
+export function normalizeTitle(title?: string): string {
+	if (!title?.trim()) return "";
+	return formatDisplayUserInput(title);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/chat/chat-input-bar.tsx b/apps/examples/desktop-app/webview/components/views/chat/chat-input-bar.tsx
new file mode 100644
index 0000000..c74eba9
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/chat/chat-input-bar.tsx
@@ -0,0 +1,1368 @@
+"use client";
+
+import {
+	ArrowUp,
+	Brain,
+	Check,
+	ChevronDown,
+	CircleStop,
+	Coins,
+	Mic,
+	Paperclip,
+	Pencil,
+	RotateCcw,
+	Undo2,
+	X,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+	Combobox,
+	ComboboxContent,
+	ComboboxEmpty,
+	ComboboxInput,
+	ComboboxItem,
+	ComboboxList,
+} from "@/components/ui/combobox";
+import { useWorkspace } from "@/contexts/workspace-context";
+import type { PromptInQueue } from "@/hooks/chat-session/types";
+import type { ChatSessionConfig, ChatSessionStatus } from "@/lib/chat-schema";
+import { desktopClient } from "@/lib/desktop-client";
+import {
+	readModelSelectionStorageFromWindow,
+	writeModelSelectionStorageToWindow,
+} from "@/lib/model-selection";
+import { normalizeProviderId } from "@/lib/provider-id";
+import {
+	loadProviderModelCatalog,
+	loadProviderModels,
+} from "@/lib/provider-model-catalog";
+import { cn } from "@/lib/utils";
+import { WorkspaceSelector } from "./workspace-selector";
+
+type ActiveMention = {
+	start: number;
+	end: number;
+	query: string;
+};
+
+type ActiveSlash = {
+	slashIndex: number;
+	query: string;
+};
+
+type SlashCommand = {
+	name: string;
+	description?: string;
+};
+
+const BUILTIN_SLASH_COMMANDS: SlashCommand[] = [
+	{
+		name: "fork",
+		description: "Create a copy of the current session into a new session",
+	},
+	{ name: "team", description: "Start the task with an agent team" },
+];
+
+const FALLBACK_PROVIDER_MODELS: Record<string, string[]> = {
+	cline: ["anthropic/claude-sonnet-4.6"],
+	anthropic: ["claude-sonnet-4-6"],
+	"openai-native": ["gpt-5.5"],
+	openrouter: ["anthropic/claude-sonnet-4.6"],
+	gemini: ["gemini-3-pro-latest"],
+};
+
+const FALLBACK_PROVIDER_REASONING_MODELS: Record<string, string[]> = {
+	cline: ["anthropic/claude-sonnet-4.6"],
+	anthropic: ["claude-sonnet-4-6"],
+	"openai-native": ["gpt-5.5"],
+	openrouter: ["anthropic/claude-sonnet-4.6"],
+	gemini: ["gemini-3-pro-latest"],
+};
+
+type ReasoningEffort = NonNullable<ChatSessionConfig["reasoningEffort"]>;
+type ReasoningEffortOption = {
+	label: string;
+	value: "none" | ReasoningEffort;
+};
+
+const DEFAULT_REASONING_EFFORT: ReasoningEffortOption = {
+	label: "Low",
+	value: "low",
+};
+
+const EFFORT_LEVELS: ReasoningEffortOption[] = [
+	{ label: "None", value: "none" },
+	DEFAULT_REASONING_EFFORT,
+	{ label: "Medium", value: "medium" },
+	{ label: "High", value: "high" },
+	{ label: "Extra", value: "xhigh" },
+];
+const PROMPT_INPUT_COLLAPSED_ROWS = 1;
+const PROMPT_INPUT_FOCUSED_ROWS = 5;
+
+function resolveEffortIndex(
+	thinking: ChatSessionConfig["thinking"],
+	reasoningEffort: ChatSessionConfig["reasoningEffort"],
+): number {
+	if (thinking === false) {
+		return 0;
+	}
+	const index = EFFORT_LEVELS.findIndex(
+		(option) => option.value === reasoningEffort,
+	);
+	return index >= 0 ? index : 1;
+}
+
+function buildReasoningConfig(
+	option: ReasoningEffortOption,
+): Pick<ChatSessionConfig, "thinking" | "reasoningEffort"> {
+	if (option.value === "none") {
+		return { thinking: false, reasoningEffort: undefined };
+	}
+	return { thinking: true, reasoningEffort: option.value };
+}
+
+function hasReasoningCapability(
+	providerReasoningModels: Record<string, string[]>,
+	provider: string,
+	model: string,
+): boolean {
+	const normalizedProvider = normalizeProviderId(provider);
+	return (
+		providerReasoningModels[normalizedProvider] ??
+		providerReasoningModels[provider] ??
+		[]
+	).includes(model);
+}
+
+function getActiveMention(input: string, cursor: number): ActiveMention | null {
+	if (cursor < 0 || cursor > input.length) {
+		return null;
+	}
+	const left = input.slice(0, cursor);
+	const atIndex = left.lastIndexOf("@");
+	if (atIndex === -1) {
+		return null;
+	}
+	const before = atIndex === 0 ? "" : left[atIndex - 1];
+	if (before && !/\s/.test(before)) {
+		return null;
+	}
+	const mentionBody = left.slice(atIndex + 1);
+	if (!/^[^\s@]*$/.test(mentionBody)) {
+		return null;
+	}
+	return {
+		start: atIndex,
+		end: cursor,
+		query: mentionBody,
+	};
+}
+
+function getActiveSlash(input: string, cursor: number): ActiveSlash | null {
+	if (cursor < 0 || cursor > input.length) {
+		return null;
+	}
+	const left = input.slice(0, cursor);
+	const slashIndex = left.lastIndexOf("/");
+	if (slashIndex === -1) {
+		return null;
+	}
+	// Slash must be at the start or preceded by whitespace.
+	if (slashIndex > 0 && !/\s/.test(left[slashIndex - 1] ?? "")) {
+		return null;
+	}
+	const query = left.slice(slashIndex + 1);
+	// No whitespace allowed inside the query — once the user typed a space
+	// the slash command has been committed.
+	if (/\s/.test(query)) {
+		return null;
+	}
+	// Don't open slash mode if there's already a completed slash command earlier in the input.
+	const firstSlashCommandRegex = /(^|\s)\/[a-zA-Z0-9_.-]+\s/;
+	const textBeforeCurrentSlash = input.slice(0, slashIndex);
+	if (firstSlashCommandRegex.test(textBeforeCurrentSlash)) {
+		return null;
+	}
+	return { slashIndex, query };
+}
+
+type ChatInputBarProps = {
+	status: ChatSessionStatus;
+	provider: string;
+	model: string;
+	mode: "act" | "plan";
+	thinking: ChatSessionConfig["thinking"];
+	reasoningEffort: ChatSessionConfig["reasoningEffort"];
+	gitBranch: string;
+	promptInput: string;
+	onPromptInputChange: (value: string) => void;
+	onProviderChange: (provider: string) => void;
+	onModelChange: (model: string) => void;
+	onModeToggle: () => void;
+	onReasoningChange: (
+		next: Pick<ChatSessionConfig, "thinking" | "reasoningEffort">,
+	) => void;
+	onRefreshGitBranch: () => void;
+	onListGitBranches: () => Promise<{ current: string; branches: string[] }>;
+	onSwitchGitBranch: (branch: string) => Promise<boolean>;
+	onSend: () => void;
+	onAbort: () => void;
+	onReset: () => void;
+	promptsInQueue: PromptInQueue[];
+	attachments: Array<{ id: string; name: string; isImage: boolean }>;
+	onAttachFiles: (files: File[]) => void;
+	onRemoveAttachment: (id: string) => void;
+	onSteerPromptInQueue: (promptId: string) => Promise<void> | void;
+	onEditPromptInQueue: (
+		promptId: string,
+		prompt: string,
+	) => Promise<void> | void;
+	onUndoPromptInQueue: (item: PromptInQueue) => Promise<void> | void;
+	summary: {
+		toolCalls: number;
+		tokensIn: number;
+		tokensOut: number;
+	};
+};
+
+export function ChatInputBar({
+	status,
+	provider,
+	model,
+	mode,
+	thinking,
+	reasoningEffort,
+	gitBranch,
+	promptInput,
+	onPromptInputChange,
+	onProviderChange,
+	onModelChange,
+	onModeToggle,
+	onReasoningChange,
+	onRefreshGitBranch,
+	onListGitBranches,
+	onSwitchGitBranch,
+	onSend,
+	onAbort,
+	onReset,
+	promptsInQueue,
+	attachments,
+	onAttachFiles,
+	onRemoveAttachment,
+	onSteerPromptInQueue,
+	onEditPromptInQueue,
+	onUndoPromptInQueue,
+	summary,
+}: ChatInputBarProps) {
+	const {
+		workspaceRoot,
+		workspaces,
+		refreshWorkspaces: onRefreshWorkspaces,
+		switchWorkspace: onSwitchWorkspace,
+		pickWorkspaceDirectory: onPickWorkspaceDirectory,
+	} = useWorkspace();
+	const isBusy =
+		status === "starting" || status === "running" || status === "stopping";
+	const hasDraft = promptInput.trim().length > 0 || attachments.length > 0;
+
+	const [modelSupportsReasoning, setModelSupportsReasoning] = useState(() =>
+		hasReasoningCapability(FALLBACK_PROVIDER_REASONING_MODELS, provider, model),
+	);
+	const canSend = hasDraft;
+	const fileInputRef = useRef<HTMLInputElement | null>(null);
+	const promptInputRef = useRef<HTMLTextAreaElement | null>(null);
+	const [promptInputFocused, setPromptInputFocused] = useState(false);
+	const [cursorIndex, setCursorIndex] = useState(() => promptInput.length);
+	const [mentionOpen, setMentionOpen] = useState(false);
+	const [activeMention, setActiveMention] = useState<ActiveMention | null>(
+		null,
+	);
+	const [mentionFiles, setMentionFiles] = useState<string[]>([]);
+	const [mentionLoading, setMentionLoading] = useState(false);
+	const [mentionSelectedIndex, setMentionSelectedIndex] = useState(0);
+	const mentionResultsCacheRef = useRef(new Map<string, string[]>());
+	const mentionLastRequestKeyRef = useRef<string | null>(null);
+
+	// ---- Slash command state ----
+	const [slashOpen, setSlashOpen] = useState(false);
+	const [activeSlash, setActiveSlash] = useState<ActiveSlash | null>(null);
+	const [slashCommands, setSlashCommands] = useState<SlashCommand[]>(
+		BUILTIN_SLASH_COMMANDS,
+	);
+	const [slashLoading, setSlashLoading] = useState(false);
+	const [slashSelectedIndex, setSlashSelectedIndex] = useState(0);
+	const slashCommandsLoadedRef = useRef(false);
+	const [editingQueuedPromptId, setEditingQueuedPromptId] = useState<
+		string | null
+	>(null);
+	const [editingQueuedPromptValue, setEditingQueuedPromptValue] = useState("");
+	const [queueActionPendingId, setQueueActionPendingId] = useState<
+		string | null
+	>(null);
+
+	const tokensSummary = useMemo(() => {
+		const total = summary.tokensIn + summary.tokensOut;
+		if (total === 0) {
+			return undefined;
+		}
+		return `${total.toLocaleString()} tokens`;
+	}, [summary.tokensIn, summary.tokensOut]);
+	const effortIndex = useMemo(
+		() => resolveEffortIndex(thinking, reasoningEffort),
+		[reasoningEffort, thinking],
+	);
+	const effortLabel = modelSupportsReasoning
+		? (EFFORT_LEVELS[effortIndex]?.label ?? "Low")
+		: "None";
+	const handleEffortCycle = useCallback(() => {
+		if (!modelSupportsReasoning) {
+			return;
+		}
+		const nextOption = EFFORT_LEVELS[(effortIndex + 1) % EFFORT_LEVELS.length];
+		if (!nextOption) {
+			return;
+		}
+		onReasoningChange(buildReasoningConfig(nextOption));
+	}, [effortIndex, modelSupportsReasoning, onReasoningChange]);
+
+	useEffect(() => {
+		if (!modelSupportsReasoning) {
+			if (thinking !== false || reasoningEffort !== undefined) {
+				onReasoningChange({ thinking: false, reasoningEffort: undefined });
+			}
+			return;
+		}
+		if (thinking === undefined && reasoningEffort === undefined) {
+			onReasoningChange(buildReasoningConfig(DEFAULT_REASONING_EFFORT));
+		}
+	}, [modelSupportsReasoning, onReasoningChange, reasoningEffort, thinking]);
+
+	const startQueuedPromptEdit = useCallback((item: PromptInQueue) => {
+		setEditingQueuedPromptId(item.id);
+		setEditingQueuedPromptValue(item.prompt);
+	}, []);
+
+	const cancelQueuedPromptEdit = useCallback(() => {
+		setEditingQueuedPromptId(null);
+		setEditingQueuedPromptValue("");
+	}, []);
+
+	const submitQueuedPromptEdit = useCallback(
+		async (item: PromptInQueue) => {
+			const nextPrompt = editingQueuedPromptValue.trim();
+			if (!nextPrompt || queueActionPendingId) {
+				return;
+			}
+			setQueueActionPendingId(item.id);
+			try {
+				await onEditPromptInQueue(item.id, nextPrompt);
+				cancelQueuedPromptEdit();
+			} finally {
+				setQueueActionPendingId(null);
+			}
+		},
+		[
+			cancelQueuedPromptEdit,
+			editingQueuedPromptValue,
+			onEditPromptInQueue,
+			queueActionPendingId,
+		],
+	);
+
+	const triggerQueuedPromptAction = useCallback(
+		async (item: PromptInQueue, action: "steer" | "undo") => {
+			if (queueActionPendingId) {
+				return;
+			}
+			setQueueActionPendingId(item.id);
+			try {
+				if (action === "steer") {
+					await onSteerPromptInQueue(item.id);
+				} else {
+					await onUndoPromptInQueue(item);
+				}
+			} finally {
+				setQueueActionPendingId(null);
+			}
+		},
+		[onSteerPromptInQueue, onUndoPromptInQueue, queueActionPendingId],
+	);
+
+	useEffect(() => {
+		setCursorIndex((prev) => Math.min(prev, promptInput.length));
+	}, [promptInput.length]);
+
+	useEffect(() => {
+		if (
+			editingQueuedPromptId &&
+			!promptsInQueue.some((item) => item.id === editingQueuedPromptId)
+		) {
+			cancelQueuedPromptEdit();
+		}
+	}, [cancelQueuedPromptEdit, editingQueuedPromptId, promptsInQueue]);
+
+	useEffect(() => {
+		const nextMention = getActiveMention(promptInput, cursorIndex);
+		setActiveMention(nextMention);
+		setMentionOpen(nextMention !== null);
+	}, [promptInput, cursorIndex]);
+
+	useEffect(() => {
+		if (!mentionOpen || !activeMention) {
+			setMentionFiles([]);
+			setMentionLoading(false);
+			setMentionSelectedIndex(0);
+			return;
+		}
+
+		const requestKey = `${workspaceRoot}::${activeMention.query}`;
+		if (mentionLastRequestKeyRef.current === requestKey) {
+			return;
+		}
+		mentionLastRequestKeyRef.current = requestKey;
+		const cached = mentionResultsCacheRef.current.get(requestKey);
+		if (cached) {
+			setMentionFiles(cached);
+			setMentionSelectedIndex(0);
+			setMentionLoading(false);
+			return;
+		}
+
+		let cancelled = false;
+		const timeoutId = window.setTimeout(async () => {
+			if (mentionFiles.length === 0) {
+				setMentionLoading(true);
+			}
+			try {
+				const results = await desktopClient.invoke<string[]>(
+					"search_workspace_files",
+					{
+						workspaceRoot,
+						query: activeMention.query,
+						limit: 10,
+					},
+				);
+				if (cancelled) {
+					return;
+				}
+				const nextResults = Array.isArray(results) ? results : [];
+				mentionResultsCacheRef.current.set(requestKey, nextResults);
+				setMentionFiles(nextResults);
+				setMentionSelectedIndex(0);
+			} catch {
+				if (cancelled) {
+					return;
+				}
+				if (mentionFiles.length === 0) {
+					setMentionFiles([]);
+				}
+			} finally {
+				if (!cancelled) {
+					setMentionLoading(false);
+				}
+			}
+		}, 120);
+
+		return () => {
+			cancelled = true;
+			window.clearTimeout(timeoutId);
+		};
+	}, [activeMention, mentionOpen, workspaceRoot, mentionFiles.length]);
+
+	const insertMentionFile = useCallback(
+		(filePath: string) => {
+			if (!activeMention) {
+				return;
+			}
+			const nextValue =
+				`${promptInput.slice(0, activeMention.start)}@${filePath} ` +
+				promptInput.slice(activeMention.end);
+			onPromptInputChange(nextValue);
+			setMentionOpen(false);
+			const nextCursor = activeMention.start + filePath.length + 2;
+			requestAnimationFrame(() => {
+				const input = promptInputRef.current;
+				if (!input) {
+					return;
+				}
+				input.focus();
+				input.setSelectionRange(nextCursor, nextCursor);
+				setCursorIndex(nextCursor);
+			});
+		},
+		[activeMention, onPromptInputChange, promptInput],
+	);
+
+	// ---- Slash command effects ----
+
+	// Detect slash mode from current input + cursor position.
+	useEffect(() => {
+		const nextSlash = getActiveSlash(promptInput, cursorIndex);
+		setActiveSlash(nextSlash);
+		setSlashOpen(nextSlash !== null);
+	}, [promptInput, cursorIndex]);
+
+	// Reset selection index when slash menu opens/closes.
+	useEffect(() => {
+		if (!slashOpen) {
+			setSlashSelectedIndex(0);
+		}
+	}, [slashOpen]);
+
+	// Lazily load workflow commands from the sidecar the first time the slash
+	// menu opens, then merge with the built-in commands.
+	useEffect(() => {
+		if (!slashOpen || slashCommandsLoadedRef.current) {
+			return;
+		}
+		slashCommandsLoadedRef.current = true;
+		let cancelled = false;
+		setSlashLoading(true);
+		desktopClient
+			.invoke<{
+				workflows?: Array<{ id: string; name: string }>;
+			}>("list_user_instruction_configs")
+			.then((response: { workflows?: Array<{ id: string; name: string }> }) => {
+				if (cancelled) return;
+				const workflows = Array.isArray(response?.workflows)
+					? response.workflows
+					: [];
+				const workflowCommands: SlashCommand[] = workflows.map(
+					(w: { id: string; name: string }) => ({
+						name: w.name.toLowerCase().replace(/\s+/g, "-"),
+						description: "Workflow command",
+					}),
+				);
+				const builtinNames = new Set(BUILTIN_SLASH_COMMANDS.map((c) => c.name));
+				const dedupedWorkflows = workflowCommands.filter(
+					(c) => !builtinNames.has(c.name),
+				);
+				setSlashCommands([...BUILTIN_SLASH_COMMANDS, ...dedupedWorkflows]);
+			})
+			.catch(() => {
+				// Keep built-in commands on error.
+			})
+			.finally(() => {
+				if (!cancelled) setSlashLoading(false);
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [slashOpen]);
+
+	// Filtered slash commands based on the current query.
+	const filteredSlashCommands = useMemo(() => {
+		if (!slashOpen) return [];
+		const query = (activeSlash?.query ?? "").trim().toLowerCase();
+		if (!query) {
+			return slashCommands.slice(0, 10);
+		}
+		return slashCommands
+			.filter((cmd) => cmd.name.toLowerCase().includes(query))
+			.sort((a, b) => {
+				const aStarts = a.name.toLowerCase().startsWith(query);
+				const bStarts = b.name.toLowerCase().startsWith(query);
+				if (aStarts && !bStarts) return -1;
+				if (!aStarts && bStarts) return 1;
+				return a.name.localeCompare(b.name);
+			})
+			.slice(0, 10);
+	}, [slashOpen, activeSlash?.query, slashCommands]);
+
+	const insertSlashCommandItem = useCallback(
+		(commandName: string) => {
+			if (!activeSlash) return;
+			const nextValue = `${promptInput.slice(0, activeSlash.slashIndex)}/${commandName} `;
+			onPromptInputChange(nextValue);
+			setSlashOpen(false);
+			const nextCursor = activeSlash.slashIndex + commandName.length + 2;
+			requestAnimationFrame(() => {
+				const input = promptInputRef.current;
+				if (!input) return;
+				input.focus();
+				input.setSelectionRange(nextCursor, nextCursor);
+				setCursorIndex(nextCursor);
+			});
+		},
+		[activeSlash, onPromptInputChange, promptInput],
+	);
+
+	return (
+		<div className="border-t border-border bg-card">
+			{/* Input area */}
+			<div className="px-4 py-3">
+				{promptsInQueue.length > 0 && (
+					<div className="mb-3 rounded-lg border border-border bg-background/70 p-2">
+						<div className="mb-2 flex items-center justify-between gap-2">
+							<div className="text-[11px] font-medium text-foreground">
+								Queued for upcoming turns
+							</div>
+							<div className="text-[10px] text-muted-foreground">
+								Steer runs first on the next turn
+							</div>
+						</div>
+						<div className="flex flex-col gap-1.5">
+							{promptsInQueue.map((item, index) => {
+								const isEditing = editingQueuedPromptId === item.id;
+								const isPending = queueActionPendingId === item.id;
+								const hasAttachments = (item.attachmentCount ?? 0) > 0;
+								return (
+									<div
+										className={cn(
+											"flex items-start justify-between gap-3 rounded-md border px-2.5 py-2",
+											item.steer
+												? "border-amber-300/60 bg-amber-500/8"
+												: "border-border/70 bg-muted/30",
+										)}
+										key={item.id}
+									>
+										<div className="min-w-0 flex-1">
+											<div className="mb-1 flex items-center gap-2 text-[10px] uppercase tracking-wide text-muted-foreground">
+												<span>
+													{item.steer ? "Steer" : `Queue ${index + 1}`}
+												</span>
+												{item.steer ? (
+													<span className="rounded-full bg-amber-500/15 px-1.5 py-0.5 text-[9px] font-medium text-amber-700">
+														Next turn
+													</span>
+												) : null}
+												{hasAttachments ? (
+													<span>
+														{item.attachmentCount} attachment
+														{item.attachmentCount === 1 ? "" : "s"}
+													</span>
+												) : null}
+											</div>
+											{isEditing ? (
+												<textarea
+													className="min-h-16 w-full resize-y rounded-md border border-border bg-background px-2 py-1.5 text-xs leading-4 text-foreground outline-none focus:border-primary/50 focus:ring-1 focus:ring-primary/20"
+													disabled={isPending}
+													onChange={(event) =>
+														setEditingQueuedPromptValue(event.target.value)
+													}
+													onKeyDown={(event) => {
+														if (event.key === "Escape") {
+															event.preventDefault();
+															cancelQueuedPromptEdit();
+														}
+														if (event.key === "Enter" && !event.shiftKey) {
+															event.preventDefault();
+															void submitQueuedPromptEdit(item);
+														}
+													}}
+													rows={3}
+													value={editingQueuedPromptValue}
+												/>
+											) : (
+												<div className="line-clamp-2 whitespace-pre-wrap break-words text-xs text-foreground">
+													{item.prompt}
+												</div>
+											)}
+										</div>
+										<div className="flex shrink-0 items-center gap-1">
+											{isEditing ? (
+												<>
+													<button
+														className="inline-flex items-center gap-1 rounded-md border border-border px-2 py-1 text-[11px] text-muted-foreground transition-colors hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
+														disabled={
+															isPending ||
+															editingQueuedPromptValue.trim().length === 0
+														}
+														onClick={() => void submitQueuedPromptEdit(item)}
+														type="button"
+													>
+														<Check className="h-3 w-3" />
+														Save
+													</button>
+													<button
+														className="inline-flex items-center gap-1 rounded-md border border-border px-2 py-1 text-[11px] text-muted-foreground transition-colors hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
+														disabled={isPending}
+														onClick={cancelQueuedPromptEdit}
+														type="button"
+													>
+														<X className="h-3 w-3" />
+														Cancel
+													</button>
+												</>
+											) : (
+												<>
+													{!item.steer ? (
+														<button
+															className="rounded-md border border-border px-2 py-1 text-[11px] text-muted-foreground transition-colors hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
+															disabled={isPending}
+															onClick={() =>
+																void triggerQueuedPromptAction(item, "steer")
+															}
+															type="button"
+														>
+															Steer
+														</button>
+													) : (
+														<div className="px-1 text-[10px] text-amber-700">
+															Steering
+														</div>
+													)}
+													<button
+														className="inline-flex items-center gap-1 rounded-md border border-border px-2 py-1 text-[11px] text-muted-foreground transition-colors hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
+														disabled={isPending}
+														onClick={() => startQueuedPromptEdit(item)}
+														type="button"
+													>
+														<Pencil className="h-3 w-3" />
+														Edit
+													</button>
+													<button
+														className="inline-flex items-center gap-1 rounded-md border border-border px-2 py-1 text-[11px] text-muted-foreground transition-colors hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
+														disabled={isPending}
+														onClick={() =>
+															void triggerQueuedPromptAction(item, "undo")
+														}
+														type="button"
+													>
+														<Undo2 className="h-3 w-3" />
+														Undo
+													</button>
+												</>
+											)}
+										</div>
+									</div>
+								);
+							})}
+						</div>
+					</div>
+				)}
+				<div className="relative">
+					{slashOpen && (
+						<div className="absolute inset-x-0 bottom-full z-50 mb-1 max-h-56 overflow-y-auto rounded-lg border border-border bg-popover p-1 shadow-xl">
+							{filteredSlashCommands.length === 0 ? (
+								<div className="px-3 py-2 text-xs text-muted-foreground">
+									{slashLoading
+										? "Loading commands..."
+										: "No matching commands"}
+								</div>
+							) : (
+								<>
+									{filteredSlashCommands.map((cmd, index) => (
+										<button
+											className={cn(
+												"flex w-full flex-col rounded-md px-3 py-2 text-left text-xs transition-colors",
+												index === slashSelectedIndex
+													? "bg-accent text-foreground"
+													: "text-muted-foreground hover:bg-accent hover:text-foreground",
+											)}
+											key={cmd.name}
+											onClick={() => insertSlashCommandItem(cmd.name)}
+											type="button"
+										>
+											<span className="font-medium">/{cmd.name}</span>
+											{cmd.description && (
+												<span className="text-[10px] opacity-70">
+													{cmd.description}
+												</span>
+											)}
+										</button>
+									))}
+									{slashLoading && (
+										<div className="px-3 py-1 text-[10px] text-muted-foreground">
+											Loading...
+										</div>
+									)}
+								</>
+							)}
+						</div>
+					)}
+					{mentionOpen && (
+						<div className="absolute inset-x-0 bottom-full z-50 mb-1 max-h-56 overflow-y-auto rounded-lg border border-border bg-popover p-1 shadow-xl">
+							{mentionFiles.length === 0 ? (
+								<div className="px-3 py-2 text-xs text-muted-foreground">
+									{mentionLoading ? "Searching files..." : "No matching files"}
+								</div>
+							) : (
+								<>
+									{mentionFiles.map((filePath, index) => (
+										<button
+											className={cn(
+												"block w-full rounded-md px-3 py-2 text-left text-xs transition-colors",
+												index === mentionSelectedIndex
+													? "bg-accent text-foreground"
+													: "text-muted-foreground hover:bg-accent hover:text-foreground",
+											)}
+											key={filePath}
+											onClick={() => insertMentionFile(filePath)}
+											type="button"
+										>
+											{filePath}
+										</button>
+									))}
+									{mentionLoading && (
+										<div className="px-3 py-1 text-[10px] text-muted-foreground">
+											Updating...
+										</div>
+									)}
+								</>
+							)}
+						</div>
+					)}
+					<div className="flex items-end gap-2 rounded-lg border border-border bg-background px-3 py-2.5 transition-all focus-within:border-primary/50 focus-within:ring-1 focus-within:ring-primary/20">
+						<textarea
+							className="max-h-60 min-h-5 flex-1 resize-none overflow-y-auto bg-transparent text-sm leading-5 text-foreground placeholder:text-muted-foreground outline-none"
+							onChange={(e) => {
+								onPromptInputChange(e.target.value);
+								setCursorIndex(
+									e.target.selectionStart ?? e.target.value.length,
+								);
+							}}
+							onClick={(e) =>
+								setCursorIndex(
+									e.currentTarget.selectionStart ?? promptInput.length,
+								)
+							}
+							onBlur={() => setPromptInputFocused(false)}
+							onFocus={() => setPromptInputFocused(true)}
+							onKeyDown={(e) => {
+								// Slash command menu takes priority when open.
+								if (slashOpen && filteredSlashCommands.length > 0) {
+									if (e.key === "ArrowDown") {
+										e.preventDefault();
+										setSlashSelectedIndex(
+											(prev) => (prev + 1) % filteredSlashCommands.length,
+										);
+										return;
+									}
+									if (e.key === "ArrowUp") {
+										e.preventDefault();
+										setSlashSelectedIndex(
+											(prev) =>
+												(prev - 1 + filteredSlashCommands.length) %
+												filteredSlashCommands.length,
+										);
+										return;
+									}
+									if (e.key === "Enter" || e.key === "Tab") {
+										e.preventDefault();
+										const selected = filteredSlashCommands[slashSelectedIndex];
+										if (selected) {
+											insertSlashCommandItem(selected.name);
+										}
+										return;
+									}
+								}
+								if (slashOpen && e.key === "Escape") {
+									e.preventDefault();
+									setSlashOpen(false);
+									return;
+								}
+								if (mentionOpen && mentionFiles.length > 0) {
+									if (e.key === "ArrowDown") {
+										e.preventDefault();
+										setMentionSelectedIndex(
+											(prev) => (prev + 1) % mentionFiles.length,
+										);
+										return;
+									}
+									if (e.key === "ArrowUp") {
+										e.preventDefault();
+										setMentionSelectedIndex(
+											(prev) =>
+												(prev - 1 + mentionFiles.length) % mentionFiles.length,
+										);
+										return;
+									}
+									if (e.key === "Enter" || e.key === "Tab") {
+										e.preventDefault();
+										insertMentionFile(mentionFiles[mentionSelectedIndex]);
+										return;
+									}
+								}
+								if (mentionOpen && e.key === "Escape") {
+									e.preventDefault();
+									setMentionOpen(false);
+									return;
+								}
+								if (e.key === "Enter" && !e.shiftKey) {
+									e.preventDefault();
+									if (canSend) {
+										onSend();
+									}
+								}
+							}}
+							onKeyUp={(e) =>
+								setCursorIndex(
+									e.currentTarget.selectionStart ?? promptInput.length,
+								)
+							}
+							placeholder={
+								isBusy
+									? "Agent is working... submit to queue another message"
+									: "Enter your question or type / for commands or @ for context"
+							}
+							ref={promptInputRef}
+							rows={
+								promptInputFocused
+									? PROMPT_INPUT_FOCUSED_ROWS
+									: PROMPT_INPUT_COLLAPSED_ROWS
+							}
+							value={promptInput}
+						/>
+					</div>
+				</div>
+				{attachments.length > 0 && (
+					<div className="mt-2 flex flex-wrap gap-1.5">
+						{attachments.map((attachment) => (
+							<span
+								className="inline-flex items-center gap-1 rounded-full border border-border bg-muted px-2 py-1 text-xs text-foreground"
+								key={attachment.id}
+							>
+								{attachment.isImage ? "image:" : "file:"} {attachment.name}
+								<button
+									className="rounded-sm p-0.5 text-muted-foreground hover:bg-accent hover:text-foreground"
+									onClick={() => onRemoveAttachment(attachment.id)}
+									type="button"
+								>
+									<X className="h-3 w-3" />
+								</button>
+							</span>
+						))}
+					</div>
+				)}
+			</div>
+
+			{/* Controls row */}
+			<div className="flex items-center justify-between px-4 pb-2">
+				<div className="flex items-center gap-1">
+					<button
+						className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						onClick={() => fileInputRef.current?.click()}
+						type="button"
+					>
+						<Paperclip className="h-4 w-4" />
+					</button>
+					<input
+						accept="*/*"
+						className="hidden"
+						multiple
+						onChange={(event) => {
+							const files = Array.from(event.target.files ?? []);
+							if (files.length > 0) {
+								onAttachFiles(files);
+							}
+							event.currentTarget.value = "";
+						}}
+						ref={fileInputRef}
+						type="file"
+					/>
+
+					<ModelSelector
+						isBusy={isBusy}
+						model={model}
+						onModelChange={onModelChange}
+						onModelSupportsReasoningChange={setModelSupportsReasoning}
+						onProviderChange={onProviderChange}
+						provider={provider}
+					/>
+				</div>
+
+				<div className="flex items-center gap-1">
+					<button
+						className="hidden rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						type="button"
+					>
+						<Mic className="h-4 w-4" />
+					</button>
+					{isBusy && (
+						<button
+							className="rounded-full bg-foreground p-1.5 text-background hover:bg-foreground/80 transition-colors"
+							onClick={onAbort}
+							type="button"
+						>
+							<CircleStop className="h-4 w-4" />
+						</button>
+					)}
+					{(!isBusy || canSend) && (
+						<button
+							className="rounded-full bg-foreground p-1.5 text-background hover:bg-foreground/80 transition-colors disabled:cursor-not-allowed disabled:opacity-60"
+							disabled={!canSend}
+							onClick={onSend}
+							type="button"
+						>
+							<ArrowUp className="h-4 w-4" />
+						</button>
+					)}
+				</div>
+			</div>
+
+			{/* Status bar */}
+			<div className="flex items-center justify-between border-t border-border px-4 py-1.5 text-[11px] text-muted-foreground">
+				<div className="flex items-center gap-3">
+					<StatusItem
+						label={mode === "act" ? "Act" : "Plan"}
+						onClick={onModeToggle}
+					/>
+					<StatusItem
+						disabled={!modelSupportsReasoning}
+						icon={Brain}
+						label={effortLabel}
+						onClick={handleEffortCycle}
+					/>
+					{tokensSummary && (
+						<StatusItem icon={Coins} label={tokensSummary} hasOption={false} />
+					)}
+				</div>
+				{/* GIT BRANCH */}
+				<div className="flex items-center gap-3">
+					<WorkspaceSelector
+						currentBranch={gitBranch}
+						onListGitBranches={onListGitBranches}
+						onRefreshWorkspaces={onRefreshWorkspaces}
+						onPickWorkspaceDirectory={onPickWorkspaceDirectory}
+						onSwitchGitBranch={onSwitchGitBranch}
+						onSwitchWorkspace={onSwitchWorkspace}
+						workspaces={workspaces}
+						workspaceRoot={workspaceRoot}
+					/>
+					<button
+						className="hidden items-center gap-1 hover:text-foreground transition-colors"
+						onClick={onRefreshGitBranch}
+						type="button"
+					>
+						<RotateCcw className="h-3 w-3" />
+					</button>
+					<button
+						className="hidden items-center gap-1 hover:text-foreground transition-colors"
+						onClick={onReset}
+						type="button"
+					>
+						<RotateCcw className="h-4 w-4" />
+					</button>
+				</div>
+			</div>
+		</div>
+	);
+}
+
+function ModelSelector({
+	provider,
+	model,
+	isBusy,
+	onProviderChange,
+	onModelChange,
+	onModelSupportsReasoningChange,
+}: {
+	provider: string;
+	model: string;
+	isBusy: boolean;
+	onProviderChange: (provider: string) => void;
+	onModelChange: (model: string) => void;
+	onModelSupportsReasoningChange: (supportsReasoning: boolean) => void;
+}) {
+	const normalizedProvider = normalizeProviderId(provider);
+	const [providerModels, setProviderModels] = useState<
+		Record<string, string[]>
+	>(FALLBACK_PROVIDER_MODELS);
+	const [providerReasoningModels, setProviderReasoningModels] = useState<
+		Record<string, string[]>
+	>(FALLBACK_PROVIDER_REASONING_MODELS);
+	const [enabledProviderIds, setEnabledProviderIds] = useState<string[]>([]);
+	const [lastSelection, setLastSelection] = useState(() =>
+		readModelSelectionStorageFromWindow(),
+	);
+	const visibleProviderModels = useMemo(() => {
+		const next: Record<string, string[]> = {};
+		for (const providerId of enabledProviderIds) {
+			next[providerId] = providerModels[providerId] ?? [];
+		}
+		return next;
+	}, [enabledProviderIds, providerModels]);
+	const providers = useMemo(
+		() => Object.keys(visibleProviderModels),
+		[visibleProviderModels],
+	);
+	const rememberedLastProvider = lastSelection.lastProvider.trim();
+	const resolvedProvider = useMemo(() => {
+		if (providers.length === 0) {
+			return "";
+		}
+		const rememberedProvider = normalizeProviderId(rememberedLastProvider);
+		if (normalizedProvider && providers.includes(normalizedProvider)) {
+			return normalizedProvider;
+		}
+		if (rememberedProvider && providers.includes(rememberedProvider)) {
+			return rememberedProvider;
+		}
+		return providers[0] ?? "";
+	}, [normalizedProvider, providers, rememberedLastProvider]);
+	const modelsForProvider = useMemo(
+		() => visibleProviderModels[resolvedProvider] ?? [],
+		[resolvedProvider, visibleProviderModels],
+	);
+	const resolvedModel = useMemo(() => {
+		if (modelsForProvider.length === 0) {
+			return "";
+		}
+		const rememberedModel =
+			lastSelection.lastModelByProvider[resolvedProvider] ??
+			lastSelection.lastModelByProvider[rememberedLastProvider];
+		if (model && modelsForProvider.includes(model)) {
+			return model;
+		}
+		if (rememberedModel && modelsForProvider.includes(rememberedModel)) {
+			return rememberedModel;
+		}
+		return modelsForProvider[0] ?? "";
+	}, [
+		lastSelection.lastModelByProvider,
+		model,
+		modelsForProvider,
+		rememberedLastProvider,
+		resolvedProvider,
+	]);
+
+	useEffect(() => {
+		let cancelled = false;
+
+		async function loadCatalog() {
+			try {
+				const payload = await loadProviderModelCatalog();
+				if (cancelled) {
+					return;
+				}
+				setProviderModels(payload.providerModels);
+				setProviderReasoningModels(payload.providerReasoningModels);
+				setEnabledProviderIds((current) => {
+					const nextProviderIds = new Set(payload.enabledProviderIds);
+					if (normalizedProvider) {
+						nextProviderIds.add(normalizedProvider);
+					}
+					for (const providerId of current) {
+						if (providerId in payload.providerModels) {
+							nextProviderIds.add(providerId);
+						}
+					}
+					return Array.from(nextProviderIds);
+				});
+			} catch {
+				// Keep local fallback values when provider catalog is unavailable.
+			}
+		}
+
+		void loadCatalog();
+		return () => {
+			cancelled = true;
+		};
+	}, [normalizedProvider]);
+
+	useEffect(() => {
+		if (!normalizedProvider) {
+			return;
+		}
+		if ((providerModels[normalizedProvider] ?? []).length > 0) {
+			return;
+		}
+
+		let cancelled = false;
+
+		async function loadModelsForProvider() {
+			try {
+				const models = await loadProviderModels(normalizedProvider);
+				if (cancelled || models.length === 0) {
+					return;
+				}
+				const modelIds = models.map((entry) => entry.id);
+				const reasoningModelIds = models
+					.filter((entry) => entry.supportsReasoning)
+					.map((entry) => entry.id);
+				setProviderModels((current) => ({
+					...current,
+					[normalizedProvider]: modelIds,
+				}));
+				setProviderReasoningModels((current) => ({
+					...current,
+					[normalizedProvider]: reasoningModelIds,
+				}));
+				setEnabledProviderIds((current) =>
+					current.includes(normalizedProvider)
+						? current
+						: [...current, normalizedProvider],
+				);
+			} catch {
+				// Keep existing values when provider-specific model loading fails.
+			}
+		}
+
+		void loadModelsForProvider();
+		return () => {
+			cancelled = true;
+		};
+	}, [normalizedProvider, providerModels]);
+
+	useEffect(() => {
+		setLastSelection((prev) => {
+			if (!normalizedProvider || !model) {
+				return prev;
+			}
+			if (
+				prev.lastProvider === normalizedProvider &&
+				prev.lastModelByProvider[normalizedProvider] === model
+			) {
+				return prev;
+			}
+			return {
+				lastProvider: normalizedProvider,
+				lastModelByProvider: {
+					...prev.lastModelByProvider,
+					[normalizedProvider]: model,
+				},
+			};
+		});
+	}, [model, normalizedProvider]);
+
+	useEffect(() => {
+		try {
+			writeModelSelectionStorageToWindow(lastSelection);
+		} catch {
+			// Ignore localStorage persistence failures.
+		}
+	}, [lastSelection]);
+
+	useEffect(() => {
+		if (providers.length === 0) {
+			return;
+		}
+		if (resolvedProvider && resolvedProvider !== normalizedProvider) {
+			onProviderChange(resolvedProvider);
+		}
+		if (resolvedModel && resolvedModel !== model) {
+			onModelChange(resolvedModel);
+		}
+	}, [
+		model,
+		onModelChange,
+		onProviderChange,
+		normalizedProvider,
+		providers,
+		resolvedModel,
+		resolvedProvider,
+	]);
+
+	useEffect(() => {
+		onModelSupportsReasoningChange(
+			hasReasoningCapability(
+				providerReasoningModels,
+				normalizedProvider,
+				model,
+			),
+		);
+	}, [
+		model,
+		onModelSupportsReasoningChange,
+		normalizedProvider,
+		providerReasoningModels,
+	]);
+
+	return (
+		<div className="flex items-center gap-1 text-xxs">
+			<Combobox
+				items={providers}
+				onValueChange={(value) => {
+					if (!value) {
+						return;
+					}
+					onProviderChange(value);
+					const rememberedModel = lastSelection.lastModelByProvider[value];
+					const providerModelIds = visibleProviderModels[value] ?? [];
+					if (
+						rememberedModel &&
+						providerModelIds.includes(rememberedModel) &&
+						rememberedModel !== model
+					) {
+						onModelChange(rememberedModel);
+						return;
+					}
+					const firstModel = providerModelIds[0];
+					if (firstModel && firstModel !== model) {
+						onModelChange(firstModel);
+					}
+				}}
+				value={resolvedProvider}
+			>
+				<ComboboxInput
+					className="h-7 text-xxs"
+					disabled={isBusy || providers.length === 0}
+					readOnly
+					showClear={false}
+					showTrigger
+				/>
+				<ComboboxContent>
+					<ComboboxEmpty>No providers found.</ComboboxEmpty>
+					<ComboboxList>
+						{(item) => (
+							<ComboboxItem className="text-xxs" key={item} value={item}>
+								{item}
+							</ComboboxItem>
+						)}
+					</ComboboxList>
+				</ComboboxContent>
+			</Combobox>
+
+			<Combobox
+				items={modelsForProvider}
+				onValueChange={(value) => {
+					if (!value) {
+						return;
+					}
+					onModelChange(value);
+				}}
+				value={resolvedModel}
+			>
+				<ComboboxInput
+					className="h-7"
+					disabled={isBusy || modelsForProvider.length === 0}
+					readOnly
+					showClear={false}
+					showTrigger
+				/>
+				<ComboboxContent>
+					<ComboboxEmpty>No models found.</ComboboxEmpty>
+					<ComboboxList>
+						{(item) => (
+							<ComboboxItem className="text-xxs" key={item} value={item}>
+								{item}
+							</ComboboxItem>
+						)}
+					</ComboboxList>
+				</ComboboxContent>
+			</Combobox>
+		</div>
+	);
+}
+
+function StatusItem({
+	icon: Icon,
+	label,
+	onClick,
+	disabled,
+	hasOption = true,
+}: {
+	icon?: React.ComponentType<{ className?: string }>;
+	label: string;
+	onClick?: () => void;
+	disabled?: boolean;
+	hasOption?: boolean;
+}) {
+	return (
+		<button
+			className={cn(
+				"flex items-center gap-1 transition-colors",
+				disabled ? "cursor-not-allowed opacity-60" : "hover:text-foreground",
+			)}
+			disabled={disabled}
+			onClick={onClick}
+			type="button"
+		>
+			{Icon ? <Icon className="h-3 w-3" /> : null}
+			<span>{label}</span>
+			{hasOption ? <ChevronDown className="h-2.5 w-2.5" /> : null}
+		</button>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/chat/chat-messages.tsx b/apps/examples/desktop-app/webview/components/views/chat/chat-messages.tsx
new file mode 100644
index 0000000..cf7a816
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/chat/chat-messages.tsx
@@ -0,0 +1,1446 @@
+"use client";
+
+import {
+	AlertCircle,
+	Bot,
+	BrainIcon,
+	Check,
+	ChevronDown,
+	ChevronRight,
+	Clock3,
+	Copy,
+	FileEdit,
+	FileIcon,
+	FileSearch,
+	Loader2,
+	MessagesSquare,
+	Search,
+	ShieldAlert,
+	SplitIcon,
+	SquareTerminalIcon,
+	UndoIcon,
+} from "lucide-react";
+import {
+	memo,
+	useCallback,
+	useEffect,
+	useLayoutEffect,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import { toast } from "@/hooks/use-toast";
+import type { ChatMessage, ChatSessionStatus } from "@/lib/chat-schema";
+import { parseApplyPatchInput } from "@/lib/session-diff";
+import { cn } from "@/lib/utils";
+import { MemoizedMarkdown } from "../../ui/markdown";
+import { normalizeTitle } from "../../utils";
+import { WelcomeScreen } from "./welcome-chat";
+
+type ChatMessagesProps = {
+	sessionId: string | null;
+	status: ChatSessionStatus;
+	chatTransportState?:
+		| "connecting"
+		| "reconnecting"
+		| "connected"
+		| "unavailable";
+	isSessionSwitching?: boolean;
+	provider: string;
+	model: string;
+	messages: ChatMessage[];
+	error: string | null;
+	streamingMessageId?: string | null;
+	pendingToolApprovals: ToolApprovalRequestItem[];
+	pendingAskQuestions: AskQuestionRequestItem[];
+	onApproveToolApproval: (requestId: string) => void | Promise<void>;
+	onRejectToolApproval: (requestId: string) => void | Promise<void>;
+	onAnswerAskQuestion: (
+		requestId: string,
+		answer: string,
+	) => void | Promise<void>;
+	onRestoreCheckpoint?: (runCount: number) => void | Promise<void>;
+	onForkSession?: () => void | Promise<void>;
+	onStartChat?: (prompt: string) => void;
+};
+
+type ToolApprovalRequestItem = {
+	requestId: string;
+	sessionId: string;
+	createdAt: string;
+	toolCallId: string;
+	toolName: string;
+	input?: unknown;
+	iteration?: number;
+	agentId?: string;
+	conversationId?: string;
+};
+
+type AskQuestionRequestItem = {
+	requestId: string;
+	createdAt: string;
+	question: string;
+	options: string[];
+	context?: {
+		agentId?: string;
+		conversationId?: string;
+		iteration?: number;
+	};
+};
+
+const IS_DEBUG = process.env.NODE_ENV === "test";
+const STICKY_BOTTOM_THRESHOLD_PX = 24;
+const SCROLL_TO_BOTTOM_BUTTON_THRESHOLD_PX = 120;
+
+function ChatMessagesImpl({
+	sessionId: _sessionId,
+	status,
+	chatTransportState = "connecting",
+	isSessionSwitching = false,
+	provider,
+	model,
+	messages,
+	error,
+	streamingMessageId = null,
+	pendingToolApprovals,
+	pendingAskQuestions,
+	onApproveToolApproval,
+	onRejectToolApproval,
+	onAnswerAskQuestion,
+	onRestoreCheckpoint,
+	onForkSession,
+	onStartChat,
+}: ChatMessagesProps) {
+	const scrollAreaRef = useRef<HTMLDivElement | null>(null);
+	const shouldStickToBottomRef = useRef(true);
+	const hasMessages = messages.length > 0;
+	const lastErrorMessage = [...messages]
+		.reverse()
+		.find((message) => message.role === "error");
+	const shouldShowErrorBanner =
+		Boolean(error) && (!lastErrorMessage || lastErrorMessage.content !== error);
+	const [showSwitchTransition, setShowSwitchTransition] = useState(false);
+	const [showScrollToBottom, setShowScrollToBottom] = useState(false);
+	const [toolApprovalActions, setToolApprovalActions] = useState<
+		Record<string, "approving" | "rejecting">
+	>({});
+	const [toolApprovalErrors, setToolApprovalErrors] = useState<
+		Record<string, string>
+	>({});
+	const [askQuestionActions, setAskQuestionActions] = useState<
+		Record<string, string>
+	>({});
+	const [askQuestionErrors, setAskQuestionErrors] = useState<
+		Record<string, string>
+	>({});
+	const [checkpointActions, setCheckpointActions] = useState<
+		Record<string, "undoing">
+	>({});
+	const [checkpointErrors, setCheckpointErrors] = useState<
+		Record<string, string>
+	>({});
+	const [copiedMessageId, setCopiedMessageId] = useState<string | null>(null);
+	const [forkingMessageId, setForkingMessageId] = useState<string | null>(null);
+	const [forkErrors, setForkErrors] = useState<Record<string, string>>({});
+	const showIdleDetails =
+		!hasMessages && !isSessionSwitching && !showSwitchTransition;
+
+	const getViewport = useCallback(() => {
+		return scrollAreaRef.current;
+	}, []);
+
+	const scrollToBottom = useCallback(
+		(behavior: ScrollBehavior = "smooth") => {
+			const viewport = getViewport();
+			if (!viewport) {
+				return;
+			}
+			shouldStickToBottomRef.current = true;
+			viewport.scrollTo({ top: viewport.scrollHeight, behavior });
+			setShowScrollToBottom((prev) => (prev ? false : prev));
+		},
+		[getViewport],
+	);
+
+	useEffect(() => {
+		if (!isSessionSwitching) {
+			setShowSwitchTransition((prev) => (prev ? false : prev));
+			return;
+		}
+		const timer = window.setTimeout(() => {
+			setShowSwitchTransition((prev) => (prev ? prev : true));
+		}, 180);
+		return () => {
+			window.clearTimeout(timer);
+		};
+	}, [isSessionSwitching]);
+
+	useEffect(() => {
+		const viewport = getViewport();
+		if (!viewport) {
+			return;
+		}
+
+		const updateScrollToBottomVisibility = () => {
+			const distanceFromBottom =
+				viewport.scrollHeight - viewport.scrollTop - viewport.clientHeight;
+			shouldStickToBottomRef.current =
+				distanceFromBottom <= STICKY_BOTTOM_THRESHOLD_PX;
+			const shouldShow =
+				distanceFromBottom > SCROLL_TO_BOTTOM_BUTTON_THRESHOLD_PX;
+			setShowScrollToBottom((prev) =>
+				prev === shouldShow ? prev : shouldShow,
+			);
+		};
+
+		updateScrollToBottomVisibility();
+		viewport.addEventListener("scroll", updateScrollToBottomVisibility);
+
+		return () => {
+			viewport.removeEventListener("scroll", updateScrollToBottomVisibility);
+		};
+	}, [getViewport]);
+
+	useLayoutEffect(() => {
+		if (!shouldStickToBottomRef.current) {
+			return;
+		}
+		scrollToBottom("auto");
+	}, [scrollToBottom]);
+
+	useEffect(() => {
+		const activeRequestIds = new Set(
+			pendingToolApprovals.map((item) => item.requestId),
+		);
+		setToolApprovalActions((prev) => pruneRequestMap(prev, activeRequestIds));
+		setToolApprovalErrors((prev) => pruneRequestMap(prev, activeRequestIds));
+	}, [pendingToolApprovals]);
+
+	useEffect(() => {
+		const activeRequestIds = new Set(
+			pendingAskQuestions.map((item) => item.requestId),
+		);
+		setAskQuestionActions((prev) => pruneRequestMap(prev, activeRequestIds));
+		setAskQuestionErrors((prev) => pruneRequestMap(prev, activeRequestIds));
+	}, [pendingAskQuestions]);
+
+	const handleToolApprovalDecision = useCallback(
+		async (
+			requestId: string,
+			action: "approving" | "rejecting",
+			fn: (requestId: string) => void | Promise<void>,
+		) => {
+			setToolApprovalActions((prev) => ({ ...prev, [requestId]: action }));
+			setToolApprovalErrors((prev) => {
+				if (!prev[requestId]) {
+					return prev;
+				}
+				const next = { ...prev };
+				delete next[requestId];
+				return next;
+			});
+			try {
+				await Promise.resolve(fn(requestId));
+			} catch (err) {
+				const message =
+					err instanceof Error ? err.message : "Could not submit decision.";
+				setToolApprovalErrors((prev) => ({ ...prev, [requestId]: message }));
+			} finally {
+				setToolApprovalActions((prev) => {
+					if (!prev[requestId]) {
+						return prev;
+					}
+					const next = { ...prev };
+					delete next[requestId];
+					return next;
+				});
+			}
+		},
+		[],
+	);
+
+	const handleAskQuestionAnswer = useCallback(
+		async (requestId: string, answer: string) => {
+			setAskQuestionActions((prev) => ({ ...prev, [requestId]: answer }));
+			setAskQuestionErrors((prev) => {
+				if (!prev[requestId]) return prev;
+				const next = { ...prev };
+				delete next[requestId];
+				return next;
+			});
+			try {
+				await Promise.resolve(onAnswerAskQuestion(requestId, answer));
+			} catch (err) {
+				const message =
+					err instanceof Error ? err.message : "Could not submit answer.";
+				setAskQuestionErrors((prev) => ({ ...prev, [requestId]: message }));
+			} finally {
+				setAskQuestionActions((prev) => {
+					if (!prev[requestId]) return prev;
+					const next = { ...prev };
+					delete next[requestId];
+					return next;
+				});
+			}
+		},
+		[onAnswerAskQuestion],
+	);
+
+	const handleCopyMessage = useCallback(
+		async (messageId: string, text: string) => {
+			try {
+				await navigator.clipboard.writeText(text);
+				setCopiedMessageId(messageId);
+				window.setTimeout(() => {
+					setCopiedMessageId((current) =>
+						current === messageId ? null : current,
+					);
+				}, 1600);
+			} catch {
+				toast({
+					variant: "destructive",
+					title: "Copy failed",
+					description: "The message could not be copied to the clipboard.",
+				});
+			}
+		},
+		[],
+	);
+
+	const handleRestoreCheckpoint = useCallback(
+		async (messageId: string, runCount: number) => {
+			if (!onRestoreCheckpoint) {
+				return;
+			}
+			setCheckpointActions((prev) => ({ ...prev, [messageId]: "undoing" }));
+			setCheckpointErrors((prev) => {
+				if (!prev[messageId]) {
+					return prev;
+				}
+				const next = { ...prev };
+				delete next[messageId];
+				return next;
+			});
+			try {
+				await Promise.resolve(onRestoreCheckpoint(runCount));
+			} catch (err) {
+				const message =
+					err instanceof Error ? err.message : "Could not restore checkpoint.";
+				setCheckpointErrors((prev) => ({ ...prev, [messageId]: message }));
+			} finally {
+				setCheckpointActions((prev) => {
+					if (!prev[messageId]) {
+						return prev;
+					}
+					const next = { ...prev };
+					delete next[messageId];
+					return next;
+				});
+			}
+		},
+		[onRestoreCheckpoint],
+	);
+
+	const handleForkSession = useCallback(
+		async (messageId: string) => {
+			if (!onForkSession) {
+				return;
+			}
+			setForkingMessageId(messageId);
+			setForkErrors((prev) => {
+				if (!prev[messageId]) {
+					return prev;
+				}
+				const next = { ...prev };
+				delete next[messageId];
+				return next;
+			});
+			try {
+				await Promise.resolve(onForkSession());
+			} catch (err) {
+				const message =
+					err instanceof Error ? err.message : "Could not fork session.";
+				setForkErrors((prev) => ({ ...prev, [messageId]: message }));
+			} finally {
+				setForkingMessageId((current) =>
+					current === messageId ? null : current,
+				);
+			}
+		},
+		[onForkSession],
+	);
+
+	return (
+		<div className="relative h-full min-h-0 min-w-0">
+			<div
+				className="h-full min-h-0 min-w-0 overflow-x-hidden overflow-y-auto"
+				ref={scrollAreaRef}
+			>
+				<div className="relative mx-auto w-full h-full min-w-0 max-w-full overflow-x-hidden px-6 py-6">
+					{showIdleDetails ? (
+						<WelcomeScreen
+							provider={provider}
+							model={model}
+							onStartChat={onStartChat ?? (() => {})}
+							quickActions={[]}
+						/>
+					) : (
+						<div className="flex h-full w-full min-w-0 flex-col gap-2 overflow-x-hidden">
+							{pendingToolApprovals.length > 0 ? (
+								<ToolApprovalPanel
+									items={pendingToolApprovals}
+									onApprove={(requestId) =>
+										handleToolApprovalDecision(
+											requestId,
+											"approving",
+											onApproveToolApproval,
+										)
+									}
+									onReject={(requestId) =>
+										handleToolApprovalDecision(
+											requestId,
+											"rejecting",
+											onRejectToolApproval,
+										)
+									}
+									pendingActions={toolApprovalActions}
+									requestErrors={toolApprovalErrors}
+								/>
+							) : null}
+							{pendingAskQuestions.length > 0 ? (
+								<AskQuestionPanel
+									items={pendingAskQuestions}
+									onAnswer={(requestId, answer) =>
+										handleAskQuestionAnswer(requestId, answer)
+									}
+									pendingActions={askQuestionActions}
+									requestErrors={askQuestionErrors}
+								/>
+							) : null}
+							{messages.map((message) => (
+								<MessageBubble
+									isStreaming={streamingMessageId === message.id}
+									key={message.id}
+									message={message}
+									onCopyRawText={() =>
+										void handleCopyMessage(message.id, message.content)
+									}
+									onRestoreCheckpoint={(runCount) =>
+										void handleRestoreCheckpoint(message.id, runCount)
+									}
+									restoreDisabled={
+										!onRestoreCheckpoint ||
+										status === "starting" ||
+										status === "running" ||
+										status === "stopping" ||
+										isSessionSwitching
+									}
+									restoreError={checkpointErrors[message.id]}
+									restorePending={checkpointActions[message.id] === "undoing"}
+									wasCopied={copiedMessageId === message.id}
+									onForkSession={
+										onForkSession
+											? () => void handleForkSession(message.id)
+											: undefined
+									}
+									forkPending={forkingMessageId === message.id}
+									forkError={forkErrors[message.id]}
+								/>
+							))}
+						</div>
+					)}
+					{showSwitchTransition ? (
+						hasMessages ? (
+							<div className="pointer-events-none absolute right-6 top-6 z-20 rounded-full border border-border/70 bg-background/90 px-3 py-1.5 text-xs text-muted-foreground shadow-sm backdrop-blur-[1px]">
+								<div className="flex items-center gap-1.5">
+									<Loader2 className="h-3.5 w-3.5 animate-spin" />
+									Switching session...
+								</div>
+							</div>
+						) : (
+							<div className="rounded-xl border border-border/70 bg-card p-4">
+								<div className="mb-3 flex items-center gap-2 text-sm text-muted-foreground">
+									<Loader2 className="h-4 w-4 animate-spin" />
+									Loading session...
+								</div>
+								<div className="space-y-3">
+									<div className="h-4 w-2/5 animate-pulse rounded bg-muted/70" />
+									<div className="h-4 w-4/5 animate-pulse rounded bg-muted/70" />
+									<div className="h-4 w-3/5 animate-pulse rounded bg-muted/70" />
+								</div>
+							</div>
+						)
+					) : null}
+					{status === "starting" && !isSessionSwitching ? (
+						<div className="mt-4 flex items-center gap-2 text-sm text-muted-foreground">
+							<Loader2 className="h-4 w-4 animate-spin" />
+							Thinking...
+						</div>
+					) : null}
+					{chatTransportState !== "connected" && !shouldShowErrorBanner ? (
+						<div className="mt-4 flex items-center gap-2 text-xs text-muted-foreground">
+							<Loader2 className="h-3.5 w-3.5 animate-spin" />
+							{chatTransportState === "reconnecting"
+								? "Reconnecting chat..."
+								: chatTransportState === "unavailable"
+									? "Chat backend unavailable"
+									: "Connecting chat..."}
+						</div>
+					) : null}
+					{shouldShowErrorBanner ? (
+						<div className="mt-4 rounded-md border border-destructive/40 bg-destructive/10 p-3 text-sm text-destructive">
+							{error}
+						</div>
+					) : null}
+				</div>
+			</div>
+			{showScrollToBottom ? (
+				<Button
+					className="absolute bottom-4 right-4 z-20 size-9 rounded-full shadow-sm"
+					onClick={() => scrollToBottom("smooth")}
+					size="icon"
+					type="button"
+					variant="secondary"
+				>
+					<ChevronDown className="size-4" />
+					<span className="sr-only">Scroll to bottom</span>
+				</Button>
+			) : null}
+		</div>
+	);
+}
+
+export const ChatMessages = memo(ChatMessagesImpl);
+
+function formatApprovalTimestamp(raw: string): string {
+	const parsed = new Date(raw);
+	if (Number.isNaN(parsed.getTime())) {
+		return "Pending now";
+	}
+	return parsed.toLocaleString();
+}
+
+function formatApprovalInput(input: unknown): string {
+	if (input == null) {
+		return "{}";
+	}
+	if (typeof input === "string") {
+		return input;
+	}
+	try {
+		return JSON.stringify(input, null, 2);
+	} catch {
+		return String(input);
+	}
+}
+
+function ToolApprovalPanel({
+	items,
+	pendingActions,
+	requestErrors,
+	onApprove,
+	onReject,
+}: {
+	items: ToolApprovalRequestItem[];
+	pendingActions: Record<string, "approving" | "rejecting">;
+	requestErrors: Record<string, string>;
+	onApprove: (requestId: string) => void;
+	onReject: (requestId: string) => void;
+}) {
+	return (
+		<section className="rounded-xl border border-amber-400/40 bg-amber-500/5 p-3">
+			<div className="flex items-center gap-2 text-sm font-medium text-foreground">
+				<ShieldAlert className="h-4 w-4 text-amber-500" />
+				Tool approval required
+			</div>
+			<p className="mt-1 text-xs text-muted-foreground">
+				Review each tool call and approve or reject it before execution.
+			</p>
+			<div className="mt-3 flex flex-col gap-2">
+				{items.map((item) => {
+					const pendingAction = pendingActions[item.requestId];
+					const isPending = Boolean(pendingAction);
+					const error = requestErrors[item.requestId];
+					return (
+						<div
+							className="rounded-lg border border-border/80 bg-background/70 p-3"
+							key={item.requestId}
+						>
+							<div className="flex items-center justify-between gap-2">
+								<div className="text-sm font-medium text-foreground">
+									{item.toolName}
+								</div>
+								<div className="inline-flex items-center gap-1 text-[11px] text-muted-foreground">
+									<Clock3 className="h-3 w-3" />
+									{formatApprovalTimestamp(item.createdAt)}
+								</div>
+							</div>
+							<div className="mt-1 text-[11px] text-muted-foreground">
+								Request {item.requestId}
+								{item.iteration != null ? ` · Iteration ${item.iteration}` : ""}
+							</div>
+							<pre className="mt-2 max-h-44 max-w-full overflow-x-hidden overflow-y-auto whitespace-pre-wrap wrap-break-word rounded-md border border-border/70 bg-background p-2 text-xs text-muted-foreground">
+								{formatApprovalInput(item.input)}
+							</pre>
+							{error ? (
+								<div className="mt-2 text-xs text-destructive">{error}</div>
+							) : null}
+							<div className="mt-2 flex items-center gap-2">
+								<Button
+									disabled={isPending}
+									onClick={() => onApprove(item.requestId)}
+									size="sm"
+									type="button"
+									variant="default"
+								>
+									{pendingAction === "approving" ? (
+										<>
+											<Loader2 className="mr-1 h-3.5 w-3.5 animate-spin" />
+											Approving...
+										</>
+									) : (
+										"Approve"
+									)}
+								</Button>
+								<Button
+									disabled={isPending}
+									onClick={() => onReject(item.requestId)}
+									size="sm"
+									type="button"
+									variant="outline"
+								>
+									{pendingAction === "rejecting" ? (
+										<>
+											<Loader2 className="mr-1 h-3.5 w-3.5 animate-spin" />
+											Rejecting...
+										</>
+									) : (
+										"Reject"
+									)}
+								</Button>
+							</div>
+						</div>
+					);
+				})}
+			</div>
+		</section>
+	);
+}
+
+function AskQuestionPanel({
+	items,
+	pendingActions,
+	requestErrors,
+	onAnswer,
+}: {
+	items: AskQuestionRequestItem[];
+	pendingActions: Record<string, string>;
+	requestErrors: Record<string, string>;
+	onAnswer: (requestId: string, answer: string) => void;
+}) {
+	return (
+		<section className="rounded-xl border border-blue-400/40 bg-blue-500/5 p-3">
+			<div className="flex items-center gap-2 text-sm font-medium text-foreground">
+				<MessagesSquare className="h-4 w-4 text-blue-500" />
+				Follow-up question
+			</div>
+			<p className="mt-1 text-xs text-muted-foreground">
+				Choose one option to continue the current agent turn.
+			</p>
+			<div className="mt-3 flex flex-col gap-2">
+				{items.map((item) => {
+					const pendingAnswer = pendingActions[item.requestId];
+					const isPending = Boolean(pendingAnswer);
+					const error = requestErrors[item.requestId];
+					return (
+						<div
+							className="rounded-lg border border-border/80 bg-background/70 p-3"
+							key={item.requestId}
+						>
+							<div className="flex items-center justify-between gap-2">
+								<div className="text-sm font-medium text-foreground">
+									{item.question}
+								</div>
+								<div className="inline-flex items-center gap-1 text-[11px] text-muted-foreground">
+									<Clock3 className="h-3 w-3" />
+									{formatApprovalTimestamp(item.createdAt)}
+								</div>
+							</div>
+							<div className="mt-1 text-[11px] text-muted-foreground">
+								Request {item.requestId}
+								{item.context?.iteration != null
+									? ` · Iteration ${item.context.iteration}`
+									: ""}
+							</div>
+							{error ? (
+								<div className="mt-2 text-xs text-destructive">{error}</div>
+							) : null}
+							<div className="mt-3 flex flex-wrap items-center gap-2">
+								{item.options.map((option) => (
+									<Button
+										disabled={isPending}
+										key={option}
+										onClick={() => onAnswer(item.requestId, option)}
+										size="sm"
+										type="button"
+										variant="outline"
+									>
+										{pendingAnswer === option ? (
+											<>
+												<Loader2 className="mr-1 h-3.5 w-3.5 animate-spin" />
+												Sending...
+											</>
+										) : (
+											option
+										)}
+									</Button>
+								))}
+							</div>
+						</div>
+					);
+				})}
+			</div>
+		</section>
+	);
+}
+
+function MessageBubble({
+	message,
+	isStreaming = false,
+	onCopyRawText,
+	onRestoreCheckpoint,
+	restoreDisabled = false,
+	restorePending = false,
+	restoreError,
+	wasCopied = false,
+	onForkSession,
+	forkPending = false,
+	forkError,
+}: {
+	message: ChatMessage;
+	isStreaming?: boolean;
+	onCopyRawText?: () => void;
+	onRestoreCheckpoint?: (runCount: number) => void;
+	restoreDisabled?: boolean;
+	restorePending?: boolean;
+	restoreError?: string;
+	wasCopied?: boolean;
+	onForkSession?: () => void;
+	forkPending?: boolean;
+	forkError?: string;
+}) {
+	const isUser = message.role === "user";
+	const isError = message.role === "error";
+	const checkpoint = message.meta?.checkpoint;
+	const shouldRenderAssistantActions =
+		message.role === "assistant" &&
+		!isStreaming &&
+		!isError &&
+		Boolean(onCopyRawText || onForkSession);
+	const shouldRenderUserActions =
+		isUser && Boolean(onCopyRawText || checkpoint);
+	const keepUserActionsVisible = restorePending || Boolean(restoreError);
+	const keepAssistantActionsVisible = forkPending || Boolean(forkError);
+	const hiddenActionButtonsClassName =
+		"pointer-events-none opacity-0 transition-opacity group-hover:pointer-events-auto group-hover:opacity-100 group-focus-within:pointer-events-auto group-focus-within:opacity-100";
+
+	if (message.role === "tool") {
+		return <ToolMessageBlock message={message} />;
+	}
+
+	const normalizedContent = normalizeTitle(message.content);
+	const reasoningContent = message.reasoning?.trim() || "";
+
+	return (
+		<div
+			className={cn(
+				"flex min-w-0",
+				isUser ? "justify-end" : "w-full justify-start",
+			)}
+		>
+			<div
+				className={cn(
+					"group max-w-full min-w-0 wrap-break-word text-sm",
+					isUser && "flex max-w-[50%] flex-col items-end gap-1",
+					!isUser && "flex flex-col items-start gap-2 overflow-hidden",
+					!isUser && !isError && "text-foreground",
+					isError &&
+						"bg-destructive/10 border border-destructive/40 text-destructive",
+				)}
+			>
+				<div
+					className={cn(
+						"max-w-full min-w-0 space-y-2 overflow-hidden wrap-break-word",
+						isUser && "rounded-sm bg-card p-2 text-foreground/80",
+					)}
+				>
+					{isStreaming && message.role === "assistant" ? (
+						<>
+							{reasoningContent || message.reasoningRedacted ? (
+								<ReasoningBlock
+									content={reasoningContent}
+									redacted={message.reasoningRedacted === true}
+								/>
+							) : null}
+							<div className="whitespace-pre-wrap wrap-break-word leading-relaxed">
+								{normalizedContent || " "}
+							</div>
+						</>
+					) : (
+						<>
+							{reasoningContent || message.reasoningRedacted ? (
+								<ReasoningBlock
+									content={reasoningContent}
+									redacted={message.reasoningRedacted === true}
+								/>
+							) : null}
+
+							<div className="my-1 ml-3 min-w-0 max-w-full overflow-x-hidden wrap-break-word **:max-w-full [&_code]:whitespace-pre-wrap [&_code]:wrap-break-word [&_pre]:overflow-x-hidden [&_pre]:whitespace-pre-wrap [&_pre]:wrap-break-word">
+								<MemoizedMarkdown
+									content={normalizedContent || " "}
+									id={message.id}
+								/>
+							</div>
+						</>
+					)}
+				</div>
+				{shouldRenderUserActions ? (
+					<div className="space-y-1">
+						<div className="flex h-6 items-center justify-end">
+							<div
+								className={cn(
+									"flex items-center justify-end gap-2",
+									keepUserActionsVisible
+										? "pointer-events-auto opacity-100"
+										: hiddenActionButtonsClassName,
+								)}
+							>
+								{onCopyRawText ? (
+									<Button
+										className="h-6 px-2 text-xs text-muted-foreground hover:text-foreground"
+										aria-label={
+											wasCopied ? "Copied user message" : "Copy user message"
+										}
+										onClick={onCopyRawText}
+										size="sm"
+										title={wasCopied ? "Copied" : "Copy message"}
+										type="button"
+										variant="ghost"
+									>
+										{wasCopied ? (
+											<Check className="h-3.5 w-3.5" />
+										) : (
+											<Copy className="h-3.5 w-3.5" />
+										)}
+									</Button>
+								) : null}
+								{checkpoint ? (
+									<Button
+										className="h-6 px-2 text-xs text-muted-foreground hover:text-foreground"
+										aria-label="Restore checkpoint"
+										disabled={restoreDisabled || restorePending}
+										onClick={() => onRestoreCheckpoint?.(checkpoint.runCount)}
+										size="sm"
+										title="Restore checkpoint"
+										type="button"
+										variant="ghost"
+									>
+										{restorePending ? (
+											<Loader2 className="h-3.5 w-3.5 animate-spin" />
+										) : (
+											<UndoIcon className="h-3.5 w-3.5" />
+										)}
+									</Button>
+								) : null}
+							</div>
+						</div>
+						{restoreError ? (
+							<div className="text-right text-xs text-destructive">
+								{restoreError}
+							</div>
+						) : null}
+					</div>
+				) : null}
+				{shouldRenderAssistantActions ? (
+					<div className="flex h-6 items-center hidden">
+						<div
+							className={cn(
+								"flex items-center gap-0",
+								keepAssistantActionsVisible
+									? "pointer-events-auto opacity-100"
+									: hiddenActionButtonsClassName,
+							)}
+						>
+							{onCopyRawText ? (
+								<Button
+									className="h-6 gap-1.5 px-2 text-[11px] text-muted-foreground hover:text-foreground"
+									aria-label={
+										wasCopied
+											? "Copied assistant message"
+											: "Copy assistant message"
+									}
+									onClick={onCopyRawText}
+									size="sm"
+									title={wasCopied ? "Copied" : "Copy raw assistant output"}
+									type="button"
+									variant="ghost"
+								>
+									{wasCopied ? (
+										<Check className="h-3 w-3" />
+									) : (
+										<Copy className="h-3 w-3" />
+									)}
+								</Button>
+							) : null}
+							{onForkSession ? (
+								<Button
+									className="h-6 gap-1.5 px-2 text-[11px] text-muted-foreground hover:text-foreground"
+									aria-label="Fork session"
+									disabled={forkPending}
+									onClick={onForkSession}
+									size="sm"
+									title="Fork session - copy full message history into a new session"
+									type="button"
+									variant="ghost"
+								>
+									{forkPending ? (
+										<Loader2 className="h-3 w-3 animate-spin" />
+									) : (
+										<SplitIcon className="h-3 w-3" />
+									)}
+								</Button>
+							) : null}
+							{forkError ? (
+								<span className="text-[11px] text-destructive">
+									{forkError}
+								</span>
+							) : null}
+						</div>
+					</div>
+				) : null}
+			</div>
+		</div>
+	);
+}
+
+function ReasoningBlock({
+	content,
+	redacted,
+}: {
+	content: string;
+	redacted: boolean;
+}) {
+	const [expanded, setExpanded] = useState(false);
+	const displayContent = content || (redacted ? "[redacted]" : "");
+	if (!displayContent) {
+		return null;
+	}
+
+	return (
+		<div className="my-2">
+			<Button
+				className="h-auto min-h-0 max-w-full justify-start gap-2 whitespace-normal px-0 py-1 text-left text-sm font-medium text-foreground/70 hover:bg-transparent hover:text-foreground dark:hover:bg-transparent dark:hover:text-foreground"
+				onClick={() => setExpanded((current) => !current)}
+				type="button"
+				variant="ghost"
+			>
+				<BrainIcon className="size-4" />
+				Thinking
+			</Button>
+			{expanded ? (
+				<div className="mt-1.5 whitespace-pre-wrap rounded-lg border border-border/70 bg-muted/30 p-3 text-sm leading-relaxed text-muted-foreground">
+					{displayContent}
+				</div>
+			) : null}
+		</div>
+	);
+}
+
+type ToolPayload = {
+	toolName?: string;
+	input?: unknown;
+	result?: unknown;
+	isError?: boolean;
+};
+
+type ToolSummary = {
+	label: string;
+	details: string[];
+	diff?: {
+		additions: number;
+		deletions: number;
+	};
+};
+
+function pruneRequestMap<T extends string>(
+	prev: Record<string, T>,
+	activeRequestIds: Set<string>,
+): Record<string, T> {
+	let hasRemoved = false;
+	const next: Record<string, T> = {};
+	for (const [requestId, value] of Object.entries(prev)) {
+		if (activeRequestIds.has(requestId)) {
+			next[requestId] = value;
+			continue;
+		}
+		hasRemoved = true;
+	}
+	return hasRemoved ? next : prev;
+}
+
+function parseJsonString(value: string): unknown {
+	try {
+		return JSON.parse(value) as unknown;
+	} catch {
+		return value;
+	}
+}
+
+function normalizeDisplayValue(value: unknown): unknown {
+	if (typeof value !== "string") {
+		return value;
+	}
+	const trimmed = value.trim();
+	if (
+		(trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+		(trimmed.startsWith("[") && trimmed.endsWith("]"))
+	) {
+		return parseJsonString(trimmed);
+	}
+	return value;
+}
+
+function formatToolValue(value: unknown): string {
+	const normalized = normalizeDisplayValue(value);
+	if (normalized == null) {
+		return "";
+	}
+	if (typeof normalized === "string") {
+		return normalized;
+	}
+	if (
+		typeof normalized === "object" &&
+		"error" in normalized &&
+		typeof normalized.error === "string"
+	) {
+		return normalized.error;
+	}
+	try {
+		return JSON.stringify(normalized, null, 2);
+	} catch {
+		return String(normalized);
+	}
+}
+
+function parseToolPayload(raw: string): ToolPayload | null {
+	try {
+		return JSON.parse(raw) as ToolPayload;
+	} catch {
+		return null;
+	}
+}
+
+function classifyTool(
+	toolName: string,
+): "exploration" | "file-edit" | "bash" | "spawn" | "tool" {
+	const normalized = toolName.toLowerCase();
+	if (
+		[
+			"search",
+			"search_codebase",
+			"file-read",
+			"file_read",
+			"read_files",
+			"web-fetch",
+			"web_fetch",
+			"fetch_web_content",
+			"skills",
+		].includes(normalized)
+	)
+		return "exploration";
+	if (
+		["editor", "edit_file", "edit", "apply_patch", "apply-patch"].includes(
+			normalized,
+		)
+	)
+		return "file-edit";
+	if (["bash", "run_commands"].includes(normalized)) return "bash";
+	if (["spawn_agent", "spawn-agent", "spawn_agent_tool"].includes(normalized))
+		return "spawn";
+	return "tool";
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value as Record<string, unknown>;
+}
+
+function asStringArray(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value.filter(
+		(item): item is string => typeof item === "string" && item.length > 0,
+	);
+}
+
+/**
+ * read_files accepts many input shapes: { files: [{ path }] }, { files: path },
+ * { file_paths: [...] }, { paths: [...] }, a bare request, an array, or a string.
+ */
+function extractReadFilePaths(input: unknown): string[] {
+	const out: string[] = [];
+	const push = (value: unknown) => {
+		if (typeof value === "string" && value.length > 0) {
+			out.push(value);
+			return;
+		}
+		const record = asRecord(value);
+		if (record && typeof record.path === "string" && record.path.length > 0) {
+			out.push(record.path);
+		}
+	};
+	const record = asRecord(input);
+	const candidates =
+		record?.files ?? record?.file_paths ?? record?.paths ?? record ?? input;
+	if (Array.isArray(candidates)) {
+		for (const candidate of candidates) {
+			push(candidate);
+		}
+	} else {
+		push(candidates);
+	}
+	return out;
+}
+
+/**
+ * run_commands entries can be shell strings or structured { command, args }.
+ */
+function extractCommands(input: unknown): string[] {
+	const inputObject = asRecord(input);
+	const raw = Array.isArray(inputObject?.commands)
+		? inputObject.commands
+		: typeof inputObject?.command === "string"
+			? [inputObject.command]
+			: typeof input === "string"
+				? [input]
+				: [];
+	const out: string[] = [];
+	for (const entry of raw) {
+		if (typeof entry === "string" && entry.length > 0) {
+			out.push(entry);
+			continue;
+		}
+		const record = asRecord(entry);
+		if (record && typeof record.command === "string") {
+			const args = asStringArray(record.args);
+			out.push([record.command, ...args].join(" "));
+		}
+	}
+	return out;
+}
+
+function toDisplayPath(path: string): string {
+	const parts = path.split(/[\\/]/);
+	return parts.at(-1) || path;
+}
+
+function parseDiffCounts(
+	value: unknown,
+): { additions: number; deletions: number } | null {
+	if (typeof value !== "string") return null;
+	const lines = value.split("\n");
+	let additions = 0;
+	let deletions = 0;
+
+	for (const line of lines) {
+		if (/^\+\d+:/.test(line)) additions += 1;
+		if (/^-\d+:/.test(line)) deletions += 1;
+	}
+
+	if (additions === 0 && deletions === 0) return null;
+	return { additions, deletions };
+}
+
+function pluralize(
+	count: number,
+	singular: string,
+	plural = `${singular}s`,
+): string {
+	return `${count} ${count === 1 ? singular : plural}`;
+}
+
+function buildToolSummary(
+	toolName: string,
+	input: unknown,
+	result: unknown,
+	inProgress: boolean,
+): ToolSummary {
+	const normalized = toolName.toLowerCase();
+	const inputObject = asRecord(input);
+
+	if (["read_files", "file_read", "file-read"].includes(normalized)) {
+		const files = extractReadFilePaths(input);
+		if (files.length > 0) {
+			return {
+				label: `${inProgress ? "Reading" : "Read"} ${pluralize(files.length, "file")}`,
+				details: files.map(
+					(file) => `${inProgress ? "Reading" : "Read"} ${toDisplayPath(file)}`,
+				),
+			};
+		}
+	}
+
+	if (["search_codebase", "search"].includes(normalized)) {
+		const queries = asStringArray(inputObject?.queries);
+		if (queries.length > 0) {
+			return {
+				label: `${inProgress ? "Exploring" : "Explored"} ${pluralize(queries.length, "search")}`,
+				details: queries.map((query) => query),
+			};
+		}
+	}
+
+	if (["run_commands", "bash"].includes(normalized)) {
+		const commands = extractCommands(input);
+		if (commands.length > 0) {
+			return {
+				label: `${inProgress ? "Running" : "Ran"} ${pluralize(commands.length, "command")}`,
+				details: commands.map((command) => command.trim()),
+			};
+		}
+	}
+
+	if (["fetch_web_content", "web_fetch", "web-fetch"].includes(normalized)) {
+		const requests = Array.isArray(inputObject?.requests)
+			? inputObject.requests
+			: [];
+		const urls = requests
+			.map((request) => {
+				const requestObject = asRecord(request);
+				return typeof requestObject?.url === "string"
+					? requestObject.url
+					: null;
+			})
+			.filter((url): url is string => Boolean(url));
+		if (urls.length > 0) {
+			return {
+				label: `${inProgress ? "Exploring" : "Explored"} ${pluralize(urls.length, "link")}`,
+				details: urls.map(
+					(url) => `${inProgress ? "Fetching" : "Fetched"} ${url}`,
+				),
+			};
+		}
+	}
+
+	if (["apply_patch", "apply-patch"].includes(normalized)) {
+		const patchText =
+			typeof input === "string"
+				? input
+				: typeof inputObject?.input === "string"
+					? inputObject.input
+					: "";
+		const fileDiffs = patchText ? parseApplyPatchInput(patchText) : [];
+		if (fileDiffs.length > 0) {
+			const additions = fileDiffs.reduce((sum, d) => sum + d.additions, 0);
+			const deletions = fileDiffs.reduce((sum, d) => sum + d.deletions, 0);
+			return {
+				label: `${inProgress ? "Editing" : "Edited"} ${pluralize(fileDiffs.length, "file")}`,
+				diff: { additions, deletions },
+				details: fileDiffs.map(
+					(d) =>
+						`${inProgress ? "Editing" : "Edited"} ${toDisplayPath(d.path)} +${d.additions} -${d.deletions}`,
+				),
+			};
+		}
+		return {
+			label: inProgress ? "Applying patch" : "Applied patch",
+			details: [],
+		};
+	}
+
+	if (["editor", "edit_file", "edit"].includes(normalized)) {
+		// Current editor schema has no `command`; derive it from the input shape.
+		const command =
+			typeof inputObject?.command === "string"
+				? inputObject.command
+				: inputObject?.insert_line != null
+					? "insert"
+					: typeof inputObject?.old_text === "string"
+						? "str_replace"
+						: typeof inputObject?.new_text === "string"
+							? "create"
+							: "edit";
+		const path =
+			typeof inputObject?.path === "string"
+				? toDisplayPath(inputObject.path)
+				: "file";
+		const diff = parseDiffCounts(asRecord(result)?.result);
+		const action = inProgress
+			? command === "str_replace"
+				? "Editing"
+				: command === "create"
+					? "Creating"
+					: command === "insert"
+						? "Inserting"
+						: "Editing"
+			: command === "str_replace"
+				? "Edited"
+				: command === "create"
+					? "Created"
+					: command === "insert"
+						? "Inserted"
+						: "Edited";
+		// The label already carries all the information; no expandable details.
+		const detail = `${action} ${path}`;
+		if (diff) {
+			return { label: detail, diff, details: [] };
+		}
+		return { label: detail, details: [] };
+	}
+
+	const query =
+		typeof asRecord(result)?.query === "string"
+			? (asRecord(result)?.query as string)
+			: "";
+	const fallback =
+		query || (inProgress ? `Running ${toolName}` : toolName) || "Tool";
+	return { label: fallback, details: [fallback] };
+}
+
+function buildToolSummaryFromMeta(
+	toolName: string,
+	kind: "exploration" | "file-edit" | "bash" | "spawn" | "tool",
+	inProgress: boolean,
+): ToolSummary {
+	if (kind === "exploration") {
+		return { label: inProgress ? "Exploring" : "Explored", details: [] };
+	}
+	if (kind === "file-edit") {
+		return { label: inProgress ? "Editing" : "Edited", details: [] };
+	}
+	if (kind === "bash") {
+		return {
+			label: inProgress ? "Running command" : "Ran command",
+			details: [],
+		};
+	}
+	if (kind === "spawn") {
+		return {
+			label: inProgress ? "Spawning agent" : "Spawned agent",
+			details: [],
+		};
+	}
+	return { label: inProgress ? `Running ${toolName}` : toolName, details: [] };
+}
+
+function ToolMessageBlock({ message }: { message: ChatMessage }) {
+	const [expanded, setExpanded] = useState(false);
+	const payload = parseToolPayload(message.content);
+	const toolName = message.meta?.toolName || payload?.toolName || "tool";
+	const hookEventName = message.meta?.hookEventName;
+	const inProgress =
+		hookEventName === "tool_call_start" ||
+		hookEventName === "history_tool_use" ||
+		(Boolean(payload) && payload?.result == null && !payload?.isError);
+	const kind = classifyTool(toolName);
+	const isFileRead = ["read_files", "file_read", "file-read"].includes(
+		toolName.toLowerCase(),
+	);
+	const Icon = isFileRead
+		? FileIcon
+		: kind === "exploration"
+			? Search
+			: kind === "file-edit"
+				? FileEdit
+				: kind === "bash"
+					? SquareTerminalIcon
+					: kind === "spawn"
+						? Bot
+						: FileSearch;
+	const summary = payload
+		? buildToolSummary(toolName, payload.input, payload.result, inProgress)
+		: buildToolSummaryFromMeta(toolName, kind, inProgress);
+	const details = summary.details;
+	const inputPreview =
+		IS_DEBUG && payload ? formatToolValue(payload.input) : "";
+	const resultPreview = payload?.isError ? formatToolValue(payload.result) : "";
+	const hasExpandedSections =
+		details.length > 0 || Boolean(inputPreview || resultPreview);
+
+	return (
+		<div className="my-2 flex w-full min-w-0 justify-start">
+			<div
+				className={cn("min-w-0 max-w-full overflow-hidden rounded-xl text-sm")}
+			>
+				<Button
+					className="h-auto min-h-0 max-w-full justify-start gap-2 whitespace-normal px-0 py-1 text-left text-sm font-medium text-primary hover:bg-transparent hover:text-primary/80 dark:hover:bg-transparent dark:hover:text-primary/80"
+					onClick={() => setExpanded((current) => !current)}
+					type="button"
+					variant="ghost"
+				>
+					{payload?.isError ? (
+						<AlertCircle className="size-4 text-destructive/80" />
+					) : (
+						<Icon className="size-4" />
+					)}
+					<span className="min-w-0 wrap-break-word">{summary.label}</span>
+					{summary.diff ? (
+						<span className="shrink-0 font-mono text-xs">
+							<span className="text-chart-2">+{summary.diff.additions}</span>{" "}
+							<span className="text-destructive">
+								-{summary.diff.deletions}
+							</span>
+						</span>
+					) : null}
+					{hasExpandedSections ? (
+						<span className="shrink-0 text-muted-foreground">
+							{expanded ? (
+								<ChevronDown className="size-4" />
+							) : (
+								<ChevronRight className="size-4" />
+							)}
+						</span>
+					) : null}
+				</Button>
+				{expanded ? (
+					<div className="mt-1.5 min-w-0 max-w-full overflow-x-hidden pl-8 text-sm text-muted-foreground">
+						{hasExpandedSections ? (
+							<div className="space-y-1">
+								{details.map((detail) => (
+									<div
+										className="wrap-break-word"
+										key={`${message.id}_${detail}`}
+									>
+										{detail}
+									</div>
+								))}
+							</div>
+						) : null}
+						{inputPreview ? (
+							<div className="space-y-1">
+								<div className="text-xxs uppercase tracking-wide text-muted-foreground/80">
+									Input
+								</div>
+								<pre className="max-h-52 max-w-full overflow-x-hidden overflow-y-auto whitespace-pre-wrap wrap-break-word rounded-md border border-border/70 bg-background/60 p-2 text-sm leading-relaxed text-foreground">
+									{inputPreview}
+								</pre>
+							</div>
+						) : null}
+						{resultPreview ? (
+							payload?.isError ? (
+								<div className="mt-1">
+									<span className="text-destructive">{resultPreview}</span>
+								</div>
+							) : (
+								<div className="space-y-1">
+									<pre className="max-h-64 max-w-full overflow-x-hidden overflow-y-auto whitespace-pre-wrap wrap-break-word rounded-md border border-border/70 bg-background/60 p-2 text-sm leading-relaxed text-foreground">
+										{resultPreview}
+									</pre>
+								</div>
+							)
+						) : null}
+					</div>
+				) : null}
+			</div>
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/chat/diff-view.tsx b/apps/examples/desktop-app/webview/components/views/chat/diff-view.tsx
new file mode 100644
index 0000000..31e0fef
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/chat/diff-view.tsx
@@ -0,0 +1,200 @@
+"use client";
+
+import { ChevronDown, ChevronRight, Minus, Plus, X } from "lucide-react";
+import { useMemo, useState } from "react";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import type { SessionFileDiff } from "@/lib/session-diff";
+import { cn } from "@/lib/utils";
+
+type DiffViewProps = {
+	fileDiffs: SessionFileDiff[];
+	onClose: () => void;
+};
+
+export function DiffView({ fileDiffs, onClose }: DiffViewProps) {
+	const [collapsedFiles, setCollapsedFiles] = useState<Set<string>>(new Set());
+
+	const _totals = useMemo(
+		() =>
+			fileDiffs.reduce(
+				(acc, file) => {
+					acc.additions += file.additions;
+					acc.deletions += file.deletions;
+					return acc;
+				},
+				{ additions: 0, deletions: 0 },
+			),
+		[fileDiffs],
+	);
+
+	const toggleFileCollapse = (filename: string) => {
+		setCollapsedFiles((prev) => {
+			const next = new Set(prev);
+			if (next.has(filename)) {
+				next.delete(filename);
+			} else {
+				next.add(filename);
+			}
+			return next;
+		});
+	};
+
+	return (
+		<div className="flex flex-1 flex-col overflow-hidden">
+			<div className="flex h-10 items-center justify-between border-b border-border bg-card px-4">
+				<div className="flex items-center gap-3">
+					<span className="text-xs font-medium text-foreground">
+						Uncommitted changes
+					</span>
+					<span className="rounded bg-secondary px-1.5 py-0.5 text-[10px] font-mono text-muted-foreground">
+						Files: {fileDiffs.length}
+					</span>
+				</div>
+
+				<div className="flex items-center gap-2 text-xs font-mono">
+					{" "}
+					<button
+						aria-label="Close diff view"
+						className="rounded-md p-1 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						onClick={onClose}
+						type="button"
+					>
+						<X className="h-4 w-4" />
+					</button>
+				</div>
+			</div>
+
+			<ScrollArea className="flex-1">
+				{fileDiffs.length === 0 ? (
+					<div className="flex h-full items-center justify-center px-4 py-16 text-sm text-muted-foreground">
+						No file changes in this session yet.
+					</div>
+				) : (
+					<div className="flex flex-col">
+						{fileDiffs.map((file) => (
+							<DiffFileSection
+								collapsed={collapsedFiles.has(file.path)}
+								file={file}
+								key={file.path}
+								onToggle={() => toggleFileCollapse(file.path)}
+							/>
+						))}
+					</div>
+				)}
+			</ScrollArea>
+		</div>
+	);
+}
+
+function DiffFileSection({
+	file,
+	collapsed,
+	onToggle,
+}: {
+	file: SessionFileDiff;
+	collapsed: boolean;
+	onToggle: () => void;
+}) {
+	return (
+		<div className="border-b border-border">
+			<button
+				className="flex w-full items-center gap-2 bg-card/80 px-4 py-2 text-left hover:bg-accent/50 transition-colors"
+				onClick={onToggle}
+				type="button"
+			>
+				{collapsed ? (
+					<ChevronRight className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+				) : (
+					<ChevronDown className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+				)}
+				<span className="min-w-0 flex-1 truncate font-mono text-xs text-foreground">
+					{file.path}
+				</span>
+				<span className="shrink-0 font-mono text-[11px] text-primary">
+					+{file.additions}
+				</span>
+				<span className="shrink-0 font-mono text-[11px] text-destructive">
+					-{file.deletions}
+				</span>
+			</button>
+
+			{!collapsed && (
+				<div className="space-y-2 border-t border-border bg-card/40 px-4 py-3">
+					{file.hunks.length === 0 ? (
+						<p className="text-xs text-muted-foreground">
+							No hunk details available.
+						</p>
+					) : (
+						file.hunks.map((hunk) => (
+							<DiffHunk
+								hunk={hunk}
+								key={`${file.path}-${hunk.oldStart}-${hunk.newStart}-${hunk.old.length}-${hunk.new.length}`}
+							/>
+						))
+					)}
+				</div>
+			)}
+		</div>
+	);
+}
+
+function DiffHunk({ hunk }: { hunk: SessionFileDiff["hunks"][number] }) {
+	const oldLines = hunk.old.length > 0 ? hunk.old.split("\n") : [];
+	const newLines = hunk.new.length > 0 ? hunk.new.split("\n") : [];
+	const oldOccurrences = new Map<string, number>();
+	const oldLineEntries = oldLines.map((line, offset) => {
+		const occurrence = (oldOccurrences.get(line) ?? 0) + 1;
+		oldOccurrences.set(line, occurrence);
+		return {
+			key: `old-${hunk.oldStart + offset}-${occurrence}-${line}`,
+			line,
+			lineNumber: hunk.oldStart + offset,
+		};
+	});
+	const newOccurrences = new Map<string, number>();
+	const newLineEntries = newLines.map((line, offset) => {
+		const occurrence = (newOccurrences.get(line) ?? 0) + 1;
+		newOccurrences.set(line, occurrence);
+		return {
+			key: `new-${hunk.newStart + offset}-${occurrence}-${line}`,
+			line,
+			lineNumber: hunk.newStart + offset,
+		};
+	});
+
+	return (
+		<div className="overflow-x-auto rounded-md border border-border bg-background font-mono text-[11px] leading-5">
+			{oldLineEntries.map((entry) => (
+				<div className="flex bg-destructive/10" key={entry.key}>
+					<span className="hidden w-12 shrink-0 select-none items-center justify-end border-r border-border px-2 text-muted-foreground/40 sm:flex">
+						{entry.lineNumber}
+					</span>
+					<span className="flex w-6 shrink-0 items-center justify-center text-destructive">
+						<Minus className="h-2.5 w-2.5" />
+					</span>
+					<span className="min-w-0 flex-1 whitespace-pre px-2 text-destructive/90">
+						{entry.line || " "}
+					</span>
+				</div>
+			))}
+			{newLineEntries.map((entry) => (
+				<div className="flex bg-primary/10" key={entry.key}>
+					<span className="hidden w-12 shrink-0 select-none items-center justify-end border-r border-border px-2 text-muted-foreground/40 sm:flex">
+						{entry.lineNumber}
+					</span>
+					<span className="flex w-6 shrink-0 items-center justify-center text-primary">
+						<Plus className="h-2.5 w-2.5" />
+					</span>
+					<span className="min-w-0 flex-1 whitespace-pre px-2 text-primary">
+						{entry.line || " "}
+					</span>
+				</div>
+			))}
+			{oldLines.length === 0 && newLines.length === 0 && (
+				<div className={cn("px-3 py-2 text-xs text-muted-foreground")}>
+					No line diff content.
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx b/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx
new file mode 100644
index 0000000..4da8462
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx
@@ -0,0 +1,200 @@
+"use client";
+
+import { Check, FolderOpen } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { AuroraBackground } from "@/components/ui/aurora-bg";
+import {
+	Command,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+} from "@/components/ui/command";
+import { Label } from "@/components/ui/label";
+import { useWorkspace } from "@/contexts/workspace-context";
+
+interface QuickAction {
+	id: string;
+	label: string;
+	description: string;
+	prompt: string;
+}
+
+function normalizeWorkspacePath(path: string): string {
+	const normalized = path.trim().replace(/[\\/]+$/, "");
+	if (!normalized) {
+		return "";
+	}
+	if (/^[A-Za-z]:/.test(normalized)) {
+		return normalized.toLowerCase();
+	}
+	return normalized;
+}
+function toWorkspaceName(path: string): string {
+	const trimmed = path.trim().replace(/[\\/]+$/, "");
+	if (!trimmed) return "workspace";
+	const parts = trimmed.split(/[\\/]/);
+	return parts[parts.length - 1] || "workspace";
+}
+
+function formatWorkspaceLabel(workspacePath: string): string {
+	const trimmed = workspacePath.trim();
+	if (!trimmed) return workspacePath;
+	const unixHome = trimmed.match(/^\/Users\/[^/]+\/(.*)$/);
+	if (unixHome) return unixHome[1] ? `~/${unixHome[1]}` : "~";
+	const linuxHome = trimmed.match(/^\/home\/[^/]+\/(.*)$/);
+	if (linuxHome) return linuxHome[1] ? `~/${linuxHome[1]}` : "~";
+	const windowsHome = trimmed.match(/^[A-Za-z]:\\Users\\[^\\]+\\(.*)$/);
+	if (windowsHome) {
+		const tail = windowsHome[1]?.replaceAll("\\", "/") || "";
+		return tail ? `~/${tail}` : "~";
+	}
+	return workspacePath;
+}
+
+export function WelcomeScreen({
+	quickActions,
+}: {
+	provider: string;
+	model: string;
+	onStartChat: (prompt: string) => void;
+	quickActions: QuickAction[];
+}) {
+	const { workspaceRoot, workspaces, refreshWorkspaces, switchWorkspace } =
+		useWorkspace();
+	const [switchingWorkspace, setSwitchingWorkspace] = useState(false);
+	const availableWorkspaces = useMemo(() => {
+		const next = new Map<string, string>();
+		const register = (path: string) => {
+			const trimmed = path.trim();
+			if (!trimmed) {
+				return;
+			}
+			next.set(normalizeWorkspacePath(trimmed), trimmed);
+		};
+		register(workspaceRoot);
+		for (const workspacePath of workspaces) {
+			register(workspacePath);
+		}
+		return [...next.values()];
+	}, [workspaceRoot, workspaces]);
+
+	useEffect(() => {
+		void refreshWorkspaces();
+	}, [refreshWorkspaces]);
+
+	const handleSelectWorkspace = useCallback(
+		async (path: string) => {
+			if (
+				normalizeWorkspacePath(path) ===
+					normalizeWorkspacePath(workspaceRoot) ||
+				switchingWorkspace
+			)
+				return;
+			setSwitchingWorkspace(true);
+			await switchWorkspace(path);
+			setSwitchingWorkspace(false);
+		},
+		[workspaceRoot, switchWorkspace, switchingWorkspace],
+	);
+
+	const handleQuickAction = (action: QuickAction) => {
+		// TODO: wire up quick action prompt to chat input
+		void action;
+	};
+
+	return (
+		<div className="flex flex-1 flex-col items-center overflow-hidden bg-background">
+			<AuroraBackground />
+			<div className="relative z-10 flex w-full max-w-3xl flex-1 flex-col items-center px-6 py-12">
+				<div className="mb-8 flex flex-col items-center">
+					<h1 className="text-balance text-center text-3xl font-bold tracking-tight text-foreground">
+						What can I do for you?
+					</h1>
+					<p className="mt-2 text-balance text-center text-muted-foreground">
+						Let's explore, edit, and ship code together!
+					</p>
+				</div>
+
+				{/* Workspace selector */}
+				<div className="mb-8 w-full max-w-md">
+					<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+						Workspace
+					</Label>
+					<Command className="rounded-xl border border-border bg-card">
+						<CommandInput placeholder="Search workspaces..." />
+						<CommandList>
+							<CommandEmpty>No workspaces found.</CommandEmpty>
+							<CommandGroup>
+								{availableWorkspaces.map((wsPath) => {
+									const isActive =
+										normalizeWorkspacePath(wsPath) ===
+										normalizeWorkspacePath(workspaceRoot);
+									return (
+										<CommandItem
+											key={wsPath}
+											value={wsPath}
+											onSelect={() => {
+												void handleSelectWorkspace(wsPath);
+											}}
+											disabled={switchingWorkspace}
+											className="gap-3 py-2.5"
+										>
+											<div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-secondary">
+												<FolderOpen className="h-3.5 w-3.5 text-muted-foreground" />
+											</div>
+											<div className="min-w-0 flex-1">
+												<div className="flex items-center gap-2">
+													<p className="truncate text-sm font-medium text-foreground">
+														{toWorkspaceName(wsPath)}
+													</p>
+													{isActive && (
+														<span className="rounded-full bg-primary/20 px-1.5 py-0.5 text-[10px] font-medium text-primary">
+															Active
+														</span>
+													)}
+												</div>
+												<p className="truncate text-xs text-muted-foreground">
+													{formatWorkspaceLabel(wsPath)}
+												</p>
+											</div>
+											{isActive && (
+												<Check className="ml-auto h-4 w-4 text-primary" />
+											)}
+										</CommandItem>
+									);
+								})}
+							</CommandGroup>
+						</CommandList>
+					</Command>
+				</div>
+
+				{/* Quick actions */}
+				<div className="mb-8 w-full">
+					<div className="grid grid-cols-2 gap-3 sm:grid-cols-3">
+						{quickActions?.map((action) => {
+							return (
+								<button
+									type="button"
+									key={action.id}
+									onClick={() => handleQuickAction(action)}
+									className="group flex flex-col items-start gap-2 rounded-xl border border-border bg-card/50 p-4 text-left transition-all hover:border-primary/30 hover:bg-card"
+								>
+									<div>
+										<p className="text-sm font-medium text-foreground">
+											{action.label}
+										</p>
+										<p className="mt-0.5 text-xs text-muted-foreground line-clamp-2">
+											{action.description}
+										</p>
+									</div>
+								</button>
+							);
+						})}
+					</div>
+				</div>
+			</div>
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/chat/workspace-selector.tsx b/apps/examples/desktop-app/webview/components/views/chat/workspace-selector.tsx
new file mode 100644
index 0000000..c564d51
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/chat/workspace-selector.tsx
@@ -0,0 +1,442 @@
+"use client";
+
+import { Check, FolderCode, GitBranch, Plus, Search } from "lucide-react";
+import { useMemo, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { cn } from "@/lib/utils";
+
+function formatWorkspacePath(path: string): string {
+	const unixHome = path.match(/^\/Users\/[^/]+\/(.*)$/);
+	if (unixHome) return unixHome[1] ? `~/${unixHome[1]}` : "~";
+	const linuxHome = path.match(/^\/home\/[^/]+\/(.*)$/);
+	if (linuxHome) return linuxHome[1] ? `~/${linuxHome[1]}` : "~";
+	const windowsHome = path.match(/^[A-Za-z]:\\Users\\[^\\]+\\(.*)$/);
+	if (windowsHome) {
+		const tail = windowsHome[1]?.replaceAll("\\", "/") || "";
+		return tail ? `~/${tail}` : "~";
+	}
+	return path;
+}
+
+function normalizeWorkspacePath(path: string): string {
+	const normalized = path.trim().replace(/[\\/]+$/, "");
+	if (!normalized) {
+		return "";
+	}
+	if (/^[A-Za-z]:/.test(normalized)) {
+		return normalized.toLowerCase();
+	}
+	return normalized;
+}
+
+export function WorkspaceSelector({
+	currentBranch,
+	workspaceRoot,
+	onListGitBranches,
+	workspaces,
+	onRefreshWorkspaces,
+	onSwitchGitBranch,
+	onSwitchWorkspace,
+	onPickWorkspaceDirectory,
+	onCreateGitBranch,
+}: {
+	currentBranch: string;
+	workspaceRoot: string;
+	onListGitBranches: () => Promise<{ current: string; branches: string[] }>;
+	workspaces: string[];
+	onRefreshWorkspaces: () => Promise<void>;
+	onSwitchGitBranch: (branch: string) => Promise<boolean>;
+	onSwitchWorkspace: (workspacePath: string) => Promise<boolean>;
+	onPickWorkspaceDirectory?: (initialPath?: string) => Promise<string | null>;
+	onCreateGitBranch?: (branchName: string) => Promise<boolean>;
+}) {
+	const [open, setOpen] = useState(false);
+	const [search, setSearch] = useState("");
+	const [branches, setBranches] = useState<string[]>([]);
+	const [loadingBranches, setLoadingBranches] = useState(false);
+	const [switching, setSwitching] = useState(false);
+	const [switchingWorkspace, setSwitchingWorkspace] = useState(false);
+	const [pickingWorkspace, setPickingWorkspace] = useState(false);
+	const [showWorkspacePathInput, setShowWorkspacePathInput] = useState(false);
+	const [workspacePathInput, setWorkspacePathInput] = useState("");
+	const [showCreateBranch, setShowCreateBranch] = useState(false);
+	const [newBranchName, setNewBranchName] = useState("");
+
+	const workspaceName = useMemo(() => {
+		const trimmed = workspaceRoot.trim().replace(/[\\/]+$/, "");
+		if (!trimmed) {
+			return "workspace";
+		}
+		const parts = trimmed.split(/[\\/]/);
+		return parts[parts.length - 1] || "workspace";
+	}, [workspaceRoot]);
+	const normalizedWorkspaceRoot = useMemo(
+		() => normalizeWorkspacePath(workspaceRoot),
+		[workspaceRoot],
+	);
+
+	const openMenu = async () => {
+		setOpen(true);
+		setSearch("");
+		setShowWorkspacePathInput(false);
+		setWorkspacePathInput("");
+		setShowCreateBranch(false);
+		setNewBranchName("");
+		setLoadingBranches(true);
+		try {
+			const [branchPayload] = await Promise.all([
+				onListGitBranches(),
+				onRefreshWorkspaces(),
+			]);
+			setBranches(branchPayload.branches);
+		} finally {
+			setLoadingBranches(false);
+		}
+	};
+
+	const handleSelectBranch = async (branch: string) => {
+		if (branch === currentBranch || switching) {
+			setOpen(false);
+			setSearch("");
+			setShowWorkspacePathInput(false);
+			setWorkspacePathInput("");
+			return;
+		}
+		setSwitching(true);
+		const switched = await onSwitchGitBranch(branch);
+		setSwitching(false);
+		if (switched) {
+			setOpen(false);
+			setSearch("");
+		}
+	};
+
+	const handleWorkspaceSelect = async (nextWorkspacePath: string) => {
+		const next = nextWorkspacePath.trim();
+		if (
+			!next ||
+			normalizeWorkspacePath(next) === normalizedWorkspaceRoot ||
+			switchingWorkspace
+		) {
+			return;
+		}
+		setSwitchingWorkspace(true);
+		const switched = await onSwitchWorkspace(next);
+		setSwitchingWorkspace(false);
+		if (switched) {
+			setOpen(false);
+			setSearch("");
+		}
+	};
+
+	const handleSwitchWorkspacePath = async () => {
+		if (pickingWorkspace || switchingWorkspace) {
+			return;
+		}
+		if (onPickWorkspaceDirectory) {
+			setPickingWorkspace(true);
+			try {
+				const picked = await onPickWorkspaceDirectory(workspaceRoot);
+				if (picked?.trim()) {
+					await handleWorkspaceSelect(picked.trim());
+				}
+			} finally {
+				setPickingWorkspace(false);
+			}
+			return;
+		}
+		setShowWorkspacePathInput(true);
+		setWorkspacePathInput(workspaceRoot);
+	};
+
+	const handleSubmitWorkspacePath = () => {
+		const proposed = workspacePathInput.trim();
+		if (!proposed) {
+			return;
+		}
+		void handleWorkspaceSelect(proposed);
+	};
+
+	const handleCreateBranch = async () => {
+		const branchName = newBranchName.trim().replace(/\s+/g, "-");
+		if (!branchName) return;
+		if (branches.some((b) => b === branchName)) return;
+
+		setSwitching(true);
+		const success = onCreateGitBranch
+			? await onCreateGitBranch(branchName)
+			: await onSwitchGitBranch(branchName);
+		setSwitching(false);
+		if (success) {
+			setBranches((prev) => [...prev, branchName]);
+			setNewBranchName("");
+			setShowCreateBranch(false);
+			setOpen(false);
+			setSearch("");
+		}
+	};
+
+	const filteredBranches = branches.filter((b) =>
+		b.toLowerCase().includes(search.toLowerCase()),
+	);
+
+	const filteredWorkspaces = workspaces.filter((w) =>
+		w.toLowerCase().includes(search.toLowerCase()),
+	);
+
+	return (
+		<div className="relative">
+			<Button
+				variant="ghost"
+				className="flex items-center gap-1 h-auto px-1 py-0.5 hover:text-foreground transition-colors"
+				disabled={switching}
+				id="git-branch-btn"
+				onClick={() => {
+					if (open) {
+						setOpen(false);
+						setSearch("");
+						setShowCreateBranch(false);
+						setNewBranchName("");
+						return;
+					}
+					void openMenu();
+				}}
+			>
+				<GitBranch className="size-3" />
+				<span className="max-w-20 truncate">{workspaceName}</span>
+				<span className="text-muted-foreground/60">/</span>
+				<span className="max-w-20 truncate">{currentBranch}</span>
+			</Button>
+
+			{open && (
+				<>
+					<Button
+						variant="ghost"
+						aria-label="Close menu"
+						className="fixed inset-0 z-40 cursor-default h-auto rounded-none opacity-0"
+						onClick={() => {
+							setOpen(false);
+							setShowWorkspacePathInput(false);
+							setWorkspacePathInput("");
+							setShowCreateBranch(false);
+							setNewBranchName("");
+							setSearch("");
+						}}
+					/>
+					<div className="absolute bottom-full right-0 z-50 mb-2 w-72 rounded-lg border border-border bg-popover shadow-xl">
+						{/* Search */}
+						<div className="p-2 border-b border-border">
+							<div className="flex items-center gap-2 rounded-md bg-background px-2.5 py-1.5">
+								<Search className="size-3 text-muted-foreground shrink-0" />
+								{/* eslint-disable-next-line jsx-a11y/no-autofocus */}
+								<Input
+									autoFocus
+									value={search}
+									onChange={(e) => setSearch(e.target.value)}
+									placeholder="Search workspaces & branches"
+									className="flex-1 h-auto border-0 bg-transparent px-0 py-0 text-xs shadow-none focus-visible:ring-0"
+								/>
+							</div>
+						</div>
+
+						{loadingBranches ? (
+							<div className="px-3 py-4 text-xs text-muted-foreground">
+								Loading...
+							</div>
+						) : (
+							<>
+								{/* Workspaces section */}
+								<div className="p-1.5 border-b border-border">
+									<div className="px-2 py-1 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">
+										Workspaces
+									</div>
+									<div className="flex flex-col gap-0.5 max-h-28 overflow-y-auto">
+										{filteredWorkspaces.length === 0 ? (
+											<div className="px-2 py-2 text-xs text-muted-foreground">
+												No workspaces found
+											</div>
+										) : (
+											filteredWorkspaces.map((wp) => {
+												const isActive =
+													normalizeWorkspacePath(wp) ===
+													normalizedWorkspaceRoot;
+												return (
+													<Button
+														variant="ghost"
+														key={wp}
+														disabled={switchingWorkspace}
+														onClick={() => {
+															void handleWorkspaceSelect(wp);
+														}}
+														className={cn(
+															"flex items-center justify-between h-auto rounded-md p-2 text-left w-full",
+															isActive ? "bg-accent" : "hover:bg-accent/50",
+														)}
+													>
+														<div className="flex items-center gap-2 min-w-0 w-full">
+															<FolderCode className="mt-0.5 size-3 shrink-0 text-muted-foreground" />
+															<span className="text-xs text-foreground truncate inline-flex">
+																{formatWorkspacePath(wp)}
+															</span>
+														</div>
+														{isActive && (
+															<Check className="h-3 w-3 text-foreground shrink-0 ml-2" />
+														)}
+													</Button>
+												);
+											})
+										)}
+									</div>
+									<Button
+										variant="ghost"
+										onClick={() => {
+											void handleSwitchWorkspacePath();
+										}}
+										disabled={switchingWorkspace || pickingWorkspace}
+										size="sm"
+										className="justify-start w-full mt-0.5 text-xs text-muted-foreground"
+									>
+										{pickingWorkspace
+											? "Opening folder picker..."
+											: "Switch workspace path..."}
+									</Button>
+									{showWorkspacePathInput ? (
+										<div className="mt-1 flex items-center gap-1">
+											<Input
+												autoFocus
+												value={workspacePathInput}
+												onChange={(event) =>
+													setWorkspacePathInput(event.target.value)
+												}
+												onKeyDown={(event) => {
+													if (event.key === "Enter") {
+														event.preventDefault();
+														handleSubmitWorkspacePath();
+													}
+													if (event.key === "Escape") {
+														event.preventDefault();
+														setShowWorkspacePathInput(false);
+														setWorkspacePathInput("");
+													}
+												}}
+												placeholder="/path/to/workspace"
+												className="h-7 text-xs"
+											/>
+											<Button
+												size="sm"
+												variant="secondary"
+												onClick={handleSubmitWorkspacePath}
+												disabled={switchingWorkspace}
+												className="h-7 px-2 text-xs"
+											>
+												Go
+											</Button>
+										</div>
+									) : null}
+								</div>
+
+								{/* Branches section */}
+								<div className="p-1.5">
+									<div className="px-2 py-1 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">
+										Branches
+									</div>
+									<div className="flex flex-col gap-0.5 max-h-36 overflow-y-auto">
+										{filteredBranches.length === 0 ? (
+											<div className="px-2 py-2 text-xs text-muted-foreground">
+												No branches found
+											</div>
+										) : (
+											filteredBranches.map((branch) => (
+												<Button
+													variant="ghost"
+													key={branch}
+													disabled={switching}
+													onClick={() => {
+														void handleSelectBranch(branch);
+													}}
+													className={cn(
+														"flex items-start gap-2 h-auto rounded-md px-2 py-2 text-left",
+														currentBranch === branch
+															? "bg-accent"
+															: "hover:bg-accent/50",
+													)}
+												>
+													<GitBranch className="mt-0.5 size-3 shrink-0 text-muted-foreground" />
+													<div className="flex-1 min-w-0">
+														<div className="flex items-center gap-2">
+															<span className="text-xs font-medium text-foreground truncate">
+																{branch}
+															</span>
+															{currentBranch === branch && (
+																<Check className="h-3 w-3 text-foreground ml-auto shrink-0" />
+															)}
+														</div>
+													</div>
+												</Button>
+											))
+										)}
+									</div>
+								</div>
+
+								{/* Create branch */}
+								<div className="border-t border-border p-1.5">
+									{showCreateBranch ? (
+										<div className="flex flex-col gap-2 p-2">
+											{/* eslint-disable-next-line jsx-a11y/no-autofocus */}
+											<Input
+												autoFocus
+												value={newBranchName}
+												onChange={(e) => setNewBranchName(e.target.value)}
+												onKeyDown={(e) => {
+													if (e.key === "Enter") void handleCreateBranch();
+													if (e.key === "Escape") {
+														setShowCreateBranch(false);
+														setNewBranchName("");
+													}
+												}}
+												placeholder="Branch name"
+												className="h-8 text-xs"
+											/>
+											<div className="flex items-center gap-2">
+												<Button
+													onClick={() => void handleCreateBranch()}
+													disabled={!newBranchName.trim() || switching}
+													size="sm"
+													className="flex-1 text-xs"
+												>
+													Create
+												</Button>
+												<Button
+													variant="outline"
+													size="sm"
+													onClick={() => {
+														setShowCreateBranch(false);
+														setNewBranchName("");
+													}}
+													className="flex-1 text-xs text-muted-foreground"
+												>
+													Cancel
+												</Button>
+											</div>
+										</div>
+									) : (
+										<Button
+											variant="ghost"
+											onClick={() => setShowCreateBranch(true)}
+											size="sm"
+											className="justify-start w-full text-xs text-muted-foreground"
+										>
+											<Plus className="size-3" />
+											Create and checkout new branch...
+										</Button>
+									)}
+								</div>
+							</>
+						)}
+					</div>
+				</>
+			)}
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/marketplace-view.tsx b/apps/examples/desktop-app/webview/components/views/marketplace-view.tsx
new file mode 100644
index 0000000..e5df0c4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/marketplace-view.tsx
@@ -0,0 +1,1011 @@
+import {
+	ExternalLink,
+	Puzzle,
+	Search,
+	Server,
+	Star,
+	Trash2,
+	Zap,
+} from "lucide-react";
+import {
+	type CSSProperties,
+	type MouseEvent,
+	type ReactNode,
+	useEffect,
+	useMemo,
+	useState,
+} from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Spinner } from "@/components/ui/spinner";
+import { desktopClient } from "@/lib/desktop-client";
+import {
+	fetchMarketplaceCatalog,
+	type MarketplaceCatalog,
+	type MarketplaceEntry,
+	type MarketplacePrimitiveType,
+	type MarketplaceTag,
+} from "@/lib/marketplace";
+import { cn } from "@/lib/utils";
+import { CommandBadge, PageFrame, PageHeader } from "./page-layout";
+
+type EntryActionState =
+	| { status: "idle" }
+	| { status: "installing" }
+	| { status: "uninstalling" }
+	| {
+			status: "installed";
+			message: string;
+	  }
+	| {
+			status: "uninstalled";
+			message: string;
+	  }
+	| { status: "failed"; message: string };
+
+type MarketplaceInstallResult = {
+	status: "installed" | "uninstalled";
+	message: string;
+	output?: string;
+};
+
+type MarketplaceInstallStatusResult = {
+	installedKeys: string[];
+};
+
+type InstalledStatusState = "loading" | "ready";
+
+const INSTALL_TIMEOUT_MS = 300_000;
+const CODE_FONT_STYLE: CSSProperties = {
+	fontFamily:
+		'"Azeret Mono", ui-monospace, "SFMono-Regular", Menlo, Consolas, "Liberation Mono", monospace',
+};
+
+const primitivePageDetails = {
+	mcp: {
+		title: "MCP Servers",
+		description:
+			"Install Model Context Protocol servers into this CLI environment.",
+		emptyInstalled: "No MCP servers installed.",
+		emptyCatalog: "No MCP servers match the current filters.",
+		icon: Server,
+	},
+	skill: {
+		title: "Skills",
+		description: "Install skills globally for Cline.",
+		emptyInstalled: "No skills installed.",
+		emptyCatalog: "No skills match the current filters.",
+		icon: Zap,
+	},
+	plugin: {
+		title: "Plugins",
+		description: "Install plugins into this CLI environment.",
+		emptyInstalled: "No plugins installed.",
+		emptyCatalog: "No plugins match the current filters.",
+		icon: Puzzle,
+	},
+} satisfies Record<
+	MarketplacePrimitiveType,
+	{
+		title: string;
+		description: string;
+		emptyInstalled: string;
+		emptyCatalog: string;
+		icon: typeof Server;
+	}
+>;
+
+const primitiveCommands = {
+	mcp: "cline mcp install",
+	plugin: "cline plugin install",
+	skill: "cline skill add",
+} satisfies Record<MarketplacePrimitiveType, string>;
+
+export type MarketplaceLocalInstalledItem = {
+	key: string;
+	matchValues: string[];
+	render: () => ReactNode;
+	renderMatchedBadges?: () => ReactNode;
+	renderMatchedControls?: () => ReactNode;
+	renderMatchedDetails?: () => ReactNode;
+	renderMatchedMeta?: () => ReactNode;
+};
+
+function entryKey(entry: Pick<MarketplaceEntry, "id" | "type">): string {
+	return `${entry.type}:${entry.id}`;
+}
+
+function compareFeaturedEntries(
+	left: MarketplaceEntry,
+	right: MarketplaceEntry,
+): number {
+	return Number(Boolean(right.featured)) - Number(Boolean(left.featured));
+}
+
+function normalizeMatchValue(value: string): string {
+	return value.trim().toLowerCase();
+}
+
+function entryMatchValues(entry: MarketplaceEntry): Set<string> {
+	return new Set(
+		[entry.id, entry.name, ...entry.install.args]
+			.map(normalizeMatchValue)
+			.filter(Boolean),
+	);
+}
+
+function entryMatchesLocalItem(
+	entry: MarketplaceEntry,
+	item: MarketplaceLocalInstalledItem,
+): boolean {
+	const entryValues = entryMatchValues(entry);
+	return item.matchValues
+		.map(normalizeMatchValue)
+		.filter(Boolean)
+		.some((value) => entryValues.has(value));
+}
+
+function entrySearchText(
+	entry: MarketplaceEntry,
+	tagLabels: Map<string, string>,
+): string {
+	return [
+		entry.name,
+		entry.tagline,
+		entry.description,
+		entry.type,
+		...entry.tags.map((tag) => tagLabels.get(tag) ?? tag),
+	]
+		.join(" ")
+		.toLowerCase();
+}
+
+function actionMessage(
+	state: EntryActionState | undefined,
+): string | undefined {
+	if (
+		state?.status === "installed" ||
+		state?.status === "uninstalled" ||
+		state?.status === "failed"
+	) {
+		return state.message;
+	}
+	return undefined;
+}
+
+function EntryDetails({
+	actionState,
+	entry,
+}: {
+	actionState: EntryActionState | undefined;
+	entry: MarketplaceEntry;
+}) {
+	const requiredEnv =
+		entry.install.env?.filter((env) => env.required !== false) ?? [];
+	const optionalEnv =
+		entry.install.env?.filter((env) => env.required === false) ?? [];
+	const hasSetupDetails =
+		requiredEnv.length > 0 ||
+		optionalEnv.length > 0 ||
+		Boolean(entry.install.notes) ||
+		actionState?.status === "failed";
+
+	if (!hasSetupDetails) {
+		return null;
+	}
+
+	return (
+		<div className="grid gap-3 border-t pt-3" data-marketplace-entry-details>
+			{requiredEnv.length > 0 || optionalEnv.length > 0 ? (
+				<div className="rounded-lg border border-amber-500/30 bg-amber-500/10 p-3">
+					<p className="text-sm font-medium text-amber-800 dark:text-amber-200">
+						Environment setup needed
+					</p>
+					<p className="mt-1 text-xs leading-5 text-amber-800/80 dark:text-amber-100/80">
+						Add these values to your Cline/plugin environment after install.
+					</p>
+					<div className="mt-3 grid gap-2">
+						{[...requiredEnv, ...optionalEnv].map((env) => (
+							<div
+								key={env.name}
+								className="rounded-md border border-amber-500/20 bg-background/60 p-2"
+							>
+								<div className="flex items-center justify-between gap-2">
+									<code className="font-mono text-xs font-semibold">
+										<span style={CODE_FONT_STYLE}>{env.name}</span>
+									</code>
+									<Badge variant="outline">
+										{env.required === false ? "Optional" : "Required"}
+									</Badge>
+								</div>
+								{env.description ? (
+									<p className="mt-1 text-xs text-muted-foreground">
+										{env.description}
+									</p>
+								) : null}
+								{env.url ? (
+									<a
+										className="mt-1 inline-flex items-center gap-1 text-xs text-primary hover:underline"
+										href={env.url}
+										rel="noreferrer"
+										target="_blank"
+									>
+										Get value
+										<ExternalLink className="size-3" />
+									</a>
+								) : null}
+							</div>
+						))}
+					</div>
+				</div>
+			) : null}
+
+			{entry.install.notes ? (
+				<p className="rounded-lg border bg-muted/30 p-3 text-xs leading-5 text-muted-foreground">
+					{entry.install.notes}
+				</p>
+			) : null}
+
+			{actionState?.status === "failed" ? (
+				<div className="max-h-44 overflow-auto rounded-lg border border-destructive/40 bg-destructive/10 p-3 text-sm text-destructive">
+					{actionState.message}
+				</div>
+			) : null}
+		</div>
+	);
+}
+
+function MarketplaceEntryCard({
+	actionState,
+	entry,
+	expanded,
+	installed,
+	installedStatusReady,
+	onInstall,
+	onToggleExpanded,
+	onUninstall,
+	matchedLocalItems = [],
+	showFeatured = true,
+	showTags = true,
+	sourceLabel,
+	tagLabels,
+}: {
+	actionState: EntryActionState | undefined;
+	entry: MarketplaceEntry;
+	expanded: boolean;
+	installed: boolean;
+	installedStatusReady: boolean;
+	onInstall: (entry: MarketplaceEntry) => void;
+	onToggleExpanded: (entry: MarketplaceEntry) => void;
+	onUninstall: (entry: MarketplaceEntry) => void;
+	matchedLocalItems?: MarketplaceLocalInstalledItem[];
+	showFeatured?: boolean;
+	showTags?: boolean;
+	sourceLabel?: string;
+	tagLabels: Map<string, string>;
+}) {
+	const EntryIcon = primitivePageDetails[entry.type].icon;
+	const busy =
+		actionState?.status === "installing" ||
+		actionState?.status === "uninstalling";
+	const setupNeeded = Boolean(entry.install.env?.length);
+	const hasExpandableDetails =
+		setupNeeded ||
+		Boolean(entry.install.notes) ||
+		actionState?.status === "failed";
+	const inlineMessage = actionMessage(actionState);
+	const handleActionClick = (event: MouseEvent<HTMLButtonElement>) => {
+		event.stopPropagation();
+		if (installed) {
+			onUninstall(entry);
+			return;
+		}
+		onInstall(entry);
+	};
+	const actionLabel = !installedStatusReady
+		? "Checking..."
+		: actionState?.status === "installing"
+			? "Installing..."
+			: actionState?.status === "uninstalling"
+				? "Uninstalling..."
+				: installed
+					? "Uninstall"
+					: "Install";
+	const statusMessage = inlineMessage ? (
+		<output
+			className={cn(
+				"text-xs",
+				actionState?.status === "failed"
+					? "text-destructive"
+					: "text-muted-foreground",
+			)}
+		>
+			{inlineMessage}
+		</output>
+	) : setupNeeded ? (
+		<span className="text-xs text-amber-700 dark:text-amber-300">
+			Requires setup after install
+		</span>
+	) : null;
+	const actionButton = (
+		<Button
+			disabled={!installedStatusReady || busy}
+			onClick={handleActionClick}
+			size="sm"
+			type="button"
+			variant={installed ? "destructive" : "default"}
+		>
+			{busy || !installedStatusReady ? <Spinner /> : null}
+			{installed && !busy ? <Trash2 className="size-4" /> : null}
+			{actionLabel}
+		</Button>
+	);
+	const content = (
+		<>
+			{!installed ? (
+				<div
+					className="absolute top-4 right-4"
+					data-marketplace-entry-interactive
+				>
+					{actionButton}
+				</div>
+			) : null}
+			<div className="min-w-0">
+				<div className="flex min-w-0 items-start justify-between gap-2">
+					<div
+						className={cn(
+							"flex min-w-0 flex-1 items-center gap-2",
+							!installed && "pr-24",
+						)}
+					>
+						<EntryIcon className="h-4 w-4 shrink-0 text-primary" />
+						<h2 className="min-w-0 truncate text-sm font-semibold text-foreground">
+							{entry.name}
+						</h2>
+						{showFeatured && entry.featured ? (
+							<Badge className="border border-violet-500/20 bg-violet-500/10 text-violet-700 dark:text-violet-300">
+								<Star className="fill-current" />
+								Featured
+							</Badge>
+						) : null}
+					</div>
+					<div className="flex shrink-0 flex-wrap items-center justify-end gap-2">
+						{sourceLabel ? (
+							<Badge
+								variant="outline"
+								className="shrink-0 text-muted-foreground"
+							>
+								{sourceLabel}
+							</Badge>
+						) : null}
+						{matchedLocalItems.map((item) =>
+							item.renderMatchedBadges ? (
+								<span className="contents" key={`${item.key}:badges`}>
+									{item.renderMatchedBadges()}
+								</span>
+							) : null,
+						)}
+						{matchedLocalItems.map((item) =>
+							item.renderMatchedControls ? (
+								<span
+									className="contents"
+									data-marketplace-entry-interactive
+									key={`${item.key}:controls`}
+								>
+									{item.renderMatchedControls()}
+								</span>
+							) : null,
+						)}
+					</div>
+				</div>
+				{matchedLocalItems.some((item) => item.renderMatchedMeta) ? (
+					<div className="mt-1 grid gap-1">
+						{matchedLocalItems.map((item) =>
+							item.renderMatchedMeta ? (
+								<div key={`${item.key}:meta`}>{item.renderMatchedMeta()}</div>
+							) : null,
+						)}
+					</div>
+				) : null}
+			</div>
+
+			<div className="flex flex-col gap-3 sm:flex-row sm:items-stretch sm:justify-between">
+				<div className="grid min-w-0 flex-1 gap-2">
+					{showTags && entry.tags.length > 0 ? (
+						<div className="flex flex-wrap gap-1.5">
+							{entry.tags.slice(0, 5).map((tag) => (
+								<Badge
+									key={tag}
+									variant="outline"
+									className="max-w-full text-muted-foreground"
+								>
+									<span className="truncate">{tagLabels.get(tag) ?? tag}</span>
+								</Badge>
+							))}
+						</div>
+					) : null}
+
+					<p className="line-clamp-2 text-xs leading-5 text-muted-foreground">
+						{entry.description}
+					</p>
+					{statusMessage}
+				</div>
+
+				{installed ? (
+					<div className="flex shrink-0 flex-col items-start gap-1 sm:items-end sm:justify-end">
+						{actionButton}
+					</div>
+				) : null}
+			</div>
+
+			{matchedLocalItems.some((item) => item.renderMatchedDetails) ? (
+				<div className="grid gap-2" data-marketplace-entry-details>
+					{matchedLocalItems.map((item) =>
+						item.renderMatchedDetails ? (
+							<div key={item.key}>{item.renderMatchedDetails()}</div>
+						) : null,
+					)}
+				</div>
+			) : null}
+
+			{expanded && hasExpandableDetails ? (
+				<EntryDetails actionState={actionState} entry={entry} />
+			) : null}
+		</>
+	);
+
+	if (!hasExpandableDetails) {
+		return (
+			<div className="relative grid gap-2 rounded-lg border bg-card p-4 text-left transition-colors hover:bg-accent/20">
+				{content}
+			</div>
+		);
+	}
+
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: The card contains a nested action button, so the wrapper cannot be a native button.
+		<div
+			aria-expanded={expanded}
+			aria-label={`${expanded ? "Collapse" : "Expand"} ${entry.name}`}
+			className="relative grid cursor-pointer gap-2 rounded-lg border bg-card p-4 text-left transition-colors hover:bg-accent/20 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-none"
+			onClick={(event) => {
+				if (
+					event.target instanceof HTMLElement &&
+					event.target.closest(
+						"[data-marketplace-entry-details], [data-marketplace-entry-interactive]",
+					)
+				) {
+					return;
+				}
+				onToggleExpanded(entry);
+			}}
+			onKeyDown={(event) => {
+				if (event.target !== event.currentTarget) {
+					return;
+				}
+				if (event.key === "Enter" || event.key === " ") {
+					event.preventDefault();
+					onToggleExpanded(entry);
+				}
+			}}
+			role="button"
+			tabIndex={0}
+		>
+			{content}
+		</div>
+	);
+}
+
+function TagButton({
+	active,
+	count,
+	onClick,
+	tag,
+}: {
+	active: boolean;
+	count: number;
+	onClick: () => void;
+	tag: MarketplaceTag;
+}) {
+	return (
+		<Button
+			aria-pressed={active}
+			onClick={onClick}
+			size="sm"
+			type="button"
+			variant={active ? "default" : "outline"}
+		>
+			<span className="truncate">{tag.label}</span>
+			<span className="rounded bg-background/30 px-1.5 py-0.5 text-xs">
+				{count}
+			</span>
+		</Button>
+	);
+}
+
+function MarketplaceSection({
+	actionStates,
+	emptyMessage,
+	entries,
+	expandedEntryKey,
+	headerContent,
+	installedEntryKeys,
+	installedStatusReady,
+	localOnlyInstalledItems = [],
+	matchedLocalItemsByEntryKey,
+	onInstall,
+	onToggleExpanded,
+	onUninstall,
+	showFeaturedBadges = true,
+	showEntryTags = true,
+	sourceLabel,
+	tagLabels,
+	title,
+}: {
+	actionStates: Map<string, EntryActionState>;
+	emptyMessage: string;
+	entries: MarketplaceEntry[];
+	expandedEntryKey: string | null;
+	headerContent?: ReactNode;
+	installedEntryKeys: Set<string>;
+	installedStatusReady: boolean;
+	localOnlyInstalledItems?: MarketplaceLocalInstalledItem[];
+	matchedLocalItemsByEntryKey?: Map<string, MarketplaceLocalInstalledItem[]>;
+	onInstall: (entry: MarketplaceEntry) => void;
+	onToggleExpanded: (entry: MarketplaceEntry) => void;
+	onUninstall: (entry: MarketplaceEntry) => void;
+	showFeaturedBadges?: boolean;
+	showEntryTags?: boolean;
+	sourceLabel?: string;
+	tagLabels: Map<string, string>;
+	title: string;
+}) {
+	const totalCount = entries.length + localOnlyInstalledItems.length;
+	return (
+		<section className="grid gap-3">
+			<div className="flex items-center justify-between gap-3">
+				<h2 className="text-base font-semibold text-foreground">{title}</h2>
+				<span className="text-sm text-muted-foreground">{totalCount}</span>
+			</div>
+			{headerContent}
+			{totalCount > 0 ? (
+				<div className="grid gap-3">
+					{localOnlyInstalledItems.map((item) => item.render())}
+					{entries.map((entry) => {
+						const key = entryKey(entry);
+						return (
+							<MarketplaceEntryCard
+								actionState={actionStates.get(key)}
+								entry={entry}
+								expanded={expandedEntryKey === key}
+								installed={installedEntryKeys.has(key)}
+								installedStatusReady={installedStatusReady}
+								key={key}
+								onInstall={onInstall}
+								onToggleExpanded={onToggleExpanded}
+								onUninstall={onUninstall}
+								matchedLocalItems={matchedLocalItemsByEntryKey?.get(key) ?? []}
+								showFeatured={showFeaturedBadges}
+								showTags={showEntryTags}
+								sourceLabel={sourceLabel}
+								tagLabels={tagLabels}
+							/>
+						);
+					})}
+				</div>
+			) : (
+				<div className="rounded-lg border border-dashed bg-card p-6 text-center text-sm text-muted-foreground">
+					{emptyMessage}
+				</div>
+			)}
+		</section>
+	);
+}
+
+export function MarketplaceView({
+	chrome = "page",
+	installedItems,
+	onInstalledItemsChanged,
+	primitive,
+}: {
+	chrome?: "page" | "embedded";
+	installedItems?: MarketplaceLocalInstalledItem[];
+	onInstalledItemsChanged?: () => void | Promise<void>;
+	primitive: MarketplacePrimitiveType;
+}) {
+	const [catalog, setCatalog] = useState<MarketplaceCatalog | null>(null);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [query, setQuery] = useState("");
+	const [selectedTag, setSelectedTag] = useState<string | null>(null);
+	const [expandedEntryKey, setExpandedEntryKey] = useState<string | null>(null);
+	const [installedEntryKeys, setInstalledEntryKeys] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const [actionStates, setActionStates] = useState<
+		Map<string, EntryActionState>
+	>(() => new Map());
+	const [installedStatusState, setInstalledStatusState] =
+		useState<InstalledStatusState>("loading");
+
+	useEffect(() => {
+		let cancelled = false;
+		void (async () => {
+			try {
+				if (!cancelled) {
+					setInstalledStatusState("loading");
+				}
+				const nextCatalog = await fetchMarketplaceCatalog();
+				if (!cancelled) {
+					setCatalog(nextCatalog);
+					setErrorMessage(null);
+				}
+				try {
+					const response =
+						await desktopClient.invoke<MarketplaceInstallStatusResult>(
+							"list_marketplace_installed_entries",
+							{ entries: nextCatalog.entries },
+						);
+					if (!cancelled) {
+						setInstalledEntryKeys(new Set(response.installedKeys));
+						setInstalledStatusState("ready");
+					}
+				} catch {
+					if (!cancelled) {
+						setInstalledStatusState("ready");
+					}
+				}
+			} catch (error) {
+				if (!cancelled) {
+					setErrorMessage(
+						error instanceof Error ? error.message : String(error),
+					);
+					setInstalledStatusState("ready");
+				}
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	const pageDetails = primitivePageDetails[primitive];
+	const PageIcon = pageDetails.icon;
+	const tagLabels = useMemo(
+		() => new Map(catalog?.tags.map((tag) => [tag.id, tag.label]) ?? []),
+		[catalog?.tags],
+	);
+
+	const primitiveEntries = useMemo(
+		() =>
+			(catalog?.entries.filter((entry) => entry.type === primitive) ?? []).sort(
+				compareFeaturedEntries,
+			),
+		[catalog?.entries, primitive],
+	);
+
+	const queryFilteredEntries = useMemo(() => {
+		const normalizedQuery = query.trim().toLowerCase();
+		return primitiveEntries.filter((entry) => {
+			return (
+				normalizedQuery.length === 0 ||
+				entrySearchText(entry, tagLabels).includes(normalizedQuery)
+			);
+		});
+	}, [primitiveEntries, query, tagLabels]);
+
+	const installedEntries = useMemo(
+		() =>
+			queryFilteredEntries.filter((entry) =>
+				installedEntryKeys.has(entryKey(entry)),
+			),
+		[queryFilteredEntries, installedEntryKeys],
+	);
+
+	const marketplaceEntriesBeforeTag = useMemo(
+		() =>
+			queryFilteredEntries.filter(
+				(entry) => !installedEntryKeys.has(entryKey(entry)),
+			),
+		[queryFilteredEntries, installedEntryKeys],
+	);
+
+	const tagCounts = useMemo(() => {
+		const counts = new Map<string, number>();
+		for (const entry of marketplaceEntriesBeforeTag) {
+			for (const tag of entry.tags) {
+				counts.set(tag, (counts.get(tag) ?? 0) + 1);
+			}
+		}
+		return counts;
+	}, [marketplaceEntriesBeforeTag]);
+
+	const primitiveTags = useMemo(
+		() =>
+			(catalog?.tags ?? []).filter((tag) => (tagCounts.get(tag.id) ?? 0) > 0),
+		[catalog?.tags, tagCounts],
+	);
+
+	const catalogEntries = useMemo(
+		() =>
+			marketplaceEntriesBeforeTag.filter(
+				(entry) => !selectedTag || entry.tags.includes(selectedTag),
+			),
+		[marketplaceEntriesBeforeTag, selectedTag],
+	);
+
+	const matchedLocalItemsByEntryKey = useMemo(() => {
+		const matched = new Map<string, MarketplaceLocalInstalledItem[]>();
+		for (const item of installedItems ?? []) {
+			for (const entry of installedEntries) {
+				const key = entryKey(entry);
+				if (!entryMatchesLocalItem(entry, item)) {
+					continue;
+				}
+				const items = matched.get(key) ?? [];
+				items.push(item);
+				matched.set(key, items);
+			}
+		}
+		return matched;
+	}, [installedEntries, installedItems]);
+
+	const matchedLocalItemKeys = useMemo(() => {
+		const matched = new Set<string>();
+		const installedMarketplaceEntries = primitiveEntries.filter((entry) =>
+			installedEntryKeys.has(entryKey(entry)),
+		);
+		for (const item of installedItems ?? []) {
+			if (
+				installedMarketplaceEntries.some((entry) =>
+					entryMatchesLocalItem(entry, item),
+				)
+			) {
+				matched.add(item.key);
+			}
+		}
+		return matched;
+	}, [installedEntryKeys, installedItems, primitiveEntries]);
+
+	const localOnlyInstalledItems = useMemo(() => {
+		const normalizedQuery = query.trim().toLowerCase();
+		return (installedItems ?? []).filter((item) => {
+			if (matchedLocalItemKeys.has(item.key)) {
+				return false;
+			}
+			return (
+				normalizedQuery.length === 0 ||
+				item.matchValues
+					.map(normalizeMatchValue)
+					.some((value) => value.includes(normalizedQuery))
+			);
+		});
+	}, [installedItems, matchedLocalItemKeys, query]);
+
+	const installedStatusReady = installedStatusState === "ready";
+
+	const marketplaceTagFilters =
+		primitiveTags.length > 0 ? (
+			<div className="flex flex-col gap-2 md:flex-row md:items-center md:justify-between">
+				<div className="flex gap-2 overflow-x-auto pb-1">
+					{primitiveTags.map((tag) => (
+						<TagButton
+							active={selectedTag === tag.id}
+							count={tagCounts.get(tag.id) ?? 0}
+							key={tag.id}
+							onClick={() =>
+								setSelectedTag((current) =>
+									current === tag.id ? null : tag.id,
+								)
+							}
+							tag={tag}
+						/>
+					))}
+				</div>
+				<div className="flex min-h-8 shrink-0 items-center gap-2 text-sm text-muted-foreground">
+					<span className="font-medium text-foreground">
+						{catalogEntries.length}
+					</span>
+					<span>{catalogEntries.length === 1 ? "result" : "results"}</span>
+					{selectedTag ? (
+						<Button
+							onClick={() => setSelectedTag(null)}
+							size="sm"
+							type="button"
+							variant="ghost"
+						>
+							Clear filters
+						</Button>
+					) : null}
+				</div>
+			</div>
+		) : null;
+
+	const setEntryState = (entry: MarketplaceEntry, state: EntryActionState) => {
+		const key = entryKey(entry);
+		setActionStates((current) => {
+			const next = new Map(current);
+			next.set(key, state);
+			return next;
+		});
+	};
+
+	const markEntryInstalled = (entry: MarketplaceEntry) => {
+		setInstalledEntryKeys((current) => new Set(current).add(entryKey(entry)));
+	};
+
+	const markEntryUninstalled = (entry: MarketplaceEntry) => {
+		setInstalledEntryKeys((current) => {
+			const next = new Set(current);
+			next.delete(entryKey(entry));
+			return next;
+		});
+	};
+
+	const toggleExpanded = (entry: MarketplaceEntry) => {
+		const key = entryKey(entry);
+		setExpandedEntryKey((current) => (current === key ? null : key));
+	};
+
+	const installEntry = async (entry: MarketplaceEntry) => {
+		const key = entryKey(entry);
+		const currentState = actionStates.get(key);
+		if (
+			currentState?.status === "installing" ||
+			currentState?.status === "uninstalling"
+		) {
+			return;
+		}
+		setExpandedEntryKey(key);
+		setEntryState(entry, { status: "installing" });
+		try {
+			const result = await desktopClient.invoke<MarketplaceInstallResult>(
+				"install_marketplace_entry",
+				{ entry },
+				{ timeoutMs: INSTALL_TIMEOUT_MS },
+			);
+			setEntryState(entry, {
+				status: "installed",
+				message: result.message,
+			});
+			markEntryInstalled(entry);
+			await onInstalledItemsChanged?.();
+		} catch (error) {
+			setEntryState(entry, {
+				status: "failed",
+				message: error instanceof Error ? error.message : String(error),
+			});
+		}
+	};
+
+	const uninstallEntry = async (entry: MarketplaceEntry) => {
+		const key = entryKey(entry);
+		const currentState = actionStates.get(key);
+		if (
+			currentState?.status === "installing" ||
+			currentState?.status === "uninstalling"
+		) {
+			return;
+		}
+		setExpandedEntryKey(key);
+		setEntryState(entry, { status: "uninstalling" });
+		try {
+			const result = await desktopClient.invoke<MarketplaceInstallResult>(
+				"uninstall_marketplace_entry",
+				{ entry },
+				{ timeoutMs: INSTALL_TIMEOUT_MS },
+			);
+			setEntryState(entry, {
+				status: "uninstalled",
+				message: result.message,
+			});
+			markEntryUninstalled(entry);
+			await onInstalledItemsChanged?.();
+		} catch (error) {
+			setEntryState(entry, {
+				status: "failed",
+				message: error instanceof Error ? error.message : String(error),
+			});
+		}
+	};
+
+	const content = (
+		<div className="grid gap-6">
+			{chrome === "page" ? (
+				<PageHeader
+					description={pageDetails.description}
+					icon={PageIcon}
+					title={pageDetails.title}
+					meta={<CommandBadge>{primitiveCommands[primitive]}</CommandBadge>}
+					actions={
+						catalog?.generatedAt ? (
+							<p className="text-xs text-muted-foreground">
+								Updated{" "}
+								{new Intl.DateTimeFormat(undefined, {
+									month: "short",
+									day: "numeric",
+									year: "numeric",
+								}).format(new Date(catalog.generatedAt))}
+							</p>
+						) : null
+					}
+				/>
+			) : null}
+
+			{!catalog && !errorMessage ? (
+				<div className="flex min-h-80 items-center justify-center rounded-lg border bg-card text-sm text-muted-foreground">
+					<Spinner className="mr-2" />
+					Loading marketplace...
+				</div>
+			) : null}
+
+			{catalog && !installedStatusReady ? (
+				<div className="flex min-h-80 items-center justify-center rounded-lg border bg-card text-sm text-muted-foreground">
+					<Spinner className="mr-2" />
+					Checking installed status...
+				</div>
+			) : null}
+
+			{errorMessage ? (
+				<div className="rounded-lg border border-destructive/40 bg-destructive/10 p-4 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			) : null}
+
+			{catalog && installedStatusReady ? (
+				<div className="grid gap-6">
+					<div className="grid gap-3">
+						<div className="flex flex-col gap-3 md:flex-row md:items-center">
+							<div className="relative block flex-1">
+								<Search className="pointer-events-none absolute left-2.5 top-1/2 size-4 -translate-y-1/2 text-muted-foreground" />
+								<Input
+									aria-label={`Search ${pageDetails.title}`}
+									className="h-10 pl-8"
+									onChange={(event) => setQuery(event.target.value)}
+									placeholder={`Search ${pageDetails.title.toLowerCase()}`}
+									value={query}
+								/>
+							</div>
+						</div>
+					</div>
+
+					<MarketplaceSection
+						actionStates={actionStates}
+						emptyMessage={pageDetails.emptyInstalled}
+						entries={installedEntries}
+						expandedEntryKey={expandedEntryKey}
+						installedEntryKeys={installedEntryKeys}
+						installedStatusReady={installedStatusReady}
+						localOnlyInstalledItems={localOnlyInstalledItems}
+						matchedLocalItemsByEntryKey={matchedLocalItemsByEntryKey}
+						onInstall={installEntry}
+						onToggleExpanded={toggleExpanded}
+						onUninstall={uninstallEntry}
+						showFeaturedBadges={false}
+						showEntryTags={false}
+						sourceLabel="Marketplace"
+						tagLabels={tagLabels}
+						title="Installed"
+					/>
+
+					<MarketplaceSection
+						actionStates={actionStates}
+						emptyMessage={pageDetails.emptyCatalog}
+						entries={catalogEntries}
+						expandedEntryKey={expandedEntryKey}
+						headerContent={marketplaceTagFilters}
+						installedEntryKeys={installedEntryKeys}
+						installedStatusReady={installedStatusReady}
+						onInstall={installEntry}
+						onToggleExpanded={toggleExpanded}
+						onUninstall={uninstallEntry}
+						tagLabels={tagLabels}
+						title="Marketplace"
+					/>
+				</div>
+			) : null}
+		</div>
+	);
+
+	return chrome === "embedded" ? content : <PageFrame>{content}</PageFrame>;
+}
diff --git a/apps/examples/desktop-app/webview/components/views/page-layout.tsx b/apps/examples/desktop-app/webview/components/views/page-layout.tsx
new file mode 100644
index 0000000..5d6497e
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/page-layout.tsx
@@ -0,0 +1,111 @@
+import type { ComponentType, ReactNode } from "react";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+type PageFrameProps = {
+	children: ReactNode;
+	className?: string;
+	contentClassName?: string;
+};
+
+export function PageFrame({
+	children,
+	className,
+	contentClassName,
+}: PageFrameProps) {
+	return (
+		<ScrollArea className="h-full">
+			<div
+				className={cn(
+					"px-18 py-10 max-[1200px]:px-8 max-[720px]:px-4 max-[720px]:py-5",
+					className,
+				)}
+			>
+				<div className={cn("max-w-[86rem]", contentClassName)}>{children}</div>
+			</div>
+		</ScrollArea>
+	);
+}
+
+type PageHeaderProps = {
+	actions?: ReactNode;
+	className?: string;
+	description?: ReactNode;
+	icon?: ComponentType<{ className?: string }>;
+	meta?: ReactNode;
+	title: ReactNode;
+};
+
+export function PageHeader({
+	actions,
+	className,
+	description,
+	icon: Icon,
+	meta,
+	title,
+}: PageHeaderProps) {
+	return (
+		<section
+			className={cn(
+				"mb-8 flex items-start justify-between gap-6 max-[860px]:flex-col max-[860px]:items-stretch",
+				className,
+			)}
+		>
+			<div className="min-w-0">
+				<div className="flex min-w-0 items-center gap-3">
+					{Icon ? <Icon className="size-8 shrink-0 text-primary" /> : null}
+					<h1 className="truncate text-[32px] font-semibold leading-[1.15] tracking-normal text-foreground">
+						{title}
+					</h1>
+					{meta}
+				</div>
+				{description ? (
+					<p className="mt-3 max-w-2xl text-[15px] leading-6 text-muted-foreground">
+						{description}
+					</p>
+				) : null}
+			</div>
+			{actions ? (
+				<div className="flex shrink-0 flex-wrap items-center justify-end gap-2 max-[860px]:justify-start">
+					{actions}
+				</div>
+			) : null}
+		</section>
+	);
+}
+
+type PageEmptyStateProps = {
+	children: ReactNode;
+	className?: string;
+};
+
+export function PageEmptyState({ children, className }: PageEmptyStateProps) {
+	return (
+		<div
+			className={cn(
+				"rounded-lg border border-dashed border-border bg-card px-5 py-4 text-sm leading-6 text-muted-foreground",
+				className,
+			)}
+		>
+			{children}
+		</div>
+	);
+}
+
+type CommandBadgeProps = {
+	children: ReactNode;
+	className?: string;
+};
+
+export function CommandBadge({ children, className }: CommandBadgeProps) {
+	return (
+		<span
+			className={cn(
+				"rounded-md border border-border bg-background px-2 py-0.5 font-mono text-xs text-muted-foreground",
+				className,
+			)}
+		>
+			{children}
+		</span>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/sessions/sessions-view.tsx b/apps/examples/desktop-app/webview/components/views/sessions/sessions-view.tsx
new file mode 100644
index 0000000..571c99e
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/sessions/sessions-view.tsx
@@ -0,0 +1,550 @@
+"use client";
+
+import {
+	ArrowUpDown,
+	Check,
+	Filter,
+	Folder,
+	GitFork,
+	Loader2,
+	MoreHorizontal,
+	Pencil,
+	Search,
+	Trash2,
+	X,
+} from "lucide-react";
+import { useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuCheckboxItem,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuItem,
+	DropdownMenuLabel,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Input } from "@/components/ui/input";
+import {
+	basenamePath,
+	formatCostUsd,
+	formatRelativeTime,
+	parseTimestamp,
+	type SessionThread,
+	type UseSessionHistoryResult,
+} from "@/hooks/use-session-history";
+import type { SessionHistoryItem } from "@/lib/session-history";
+import { cn } from "@/lib/utils";
+
+type SessionsViewProps = {
+	activeSessionId?: string | null;
+	history: UseSessionHistoryResult;
+};
+
+function statusTone(status?: string): string {
+	if (status === "running") return "bg-green-500";
+	if (status === "completed") return "bg-emerald-400";
+	if (status === "failed") return "bg-destructive";
+	if (status === "cancelled") return "bg-yellow-500";
+	return "bg-muted-foreground";
+}
+
+function modelLabel(thread: SessionThread): string {
+	if (thread.provider && thread.model) {
+		return `${thread.provider}:${thread.model}`;
+	}
+	return thread.model || thread.provider || "No model";
+}
+
+function tokensLabel(thread: SessionThread): string {
+	if (thread.inputTokens == null && thread.outputTokens == null) {
+		return "-";
+	}
+	return `${thread.inputTokens ?? 0}/${thread.outputTokens ?? 0}`;
+}
+
+function sessionFilterDetails(
+	thread: SessionThread,
+	session?: SessionHistoryItem,
+): string[] {
+	const workspacePath = session?.workspaceRoot || session?.cwd || "";
+	const workspace = workspacePath ? basenamePath(workspacePath) : "";
+	return [
+		workspace ? `workspace:${workspace}` : undefined,
+		thread.status ? `status:${thread.status}` : undefined,
+		thread.provider ? `provider:${thread.provider}` : undefined,
+		thread.model ? `model:${thread.model}` : undefined,
+	].filter((detail): detail is string => Boolean(detail));
+}
+
+function sortTimestamp(session?: SessionHistoryItem) {
+	const timestamp = parseTimestamp(session?.endedAt || session?.startedAt);
+	return Number.isFinite(timestamp) ? timestamp : 0;
+}
+
+export function SessionsView({ activeSessionId, history }: SessionsViewProps) {
+	const [query, setQuery] = useState("");
+	const [sessionFilters, setSessionFilters] = useState<string[]>([]);
+	const [sortDirection, setSortDirection] = useState<"newest" | "oldest">(
+		"newest",
+	);
+	const [editingSessionId, setEditingSessionId] = useState<string | null>(null);
+	const [editingTitle, setEditingTitle] = useState("");
+	const [deleteCandidate, setDeleteCandidate] = useState<SessionThread | null>(
+		null,
+	);
+
+	const filterOptions = useMemo(
+		() =>
+			Array.from(
+				new Set(
+					history.threads.flatMap((thread) =>
+						sessionFilterDetails(thread, history.sessionById.get(thread.id)),
+					),
+				),
+			).sort((a, b) => a.localeCompare(b)),
+		[history.sessionById, history.threads],
+	);
+
+	const filteredThreads = useMemo(() => {
+		const normalizedQuery = query.trim().toLowerCase();
+		const selected = new Set(sessionFilters);
+		const filtered = history.threads.filter((thread) => {
+			const session = history.sessionById.get(thread.id);
+			const details = sessionFilterDetails(thread, session);
+			const matchesFilters =
+				selected.size === 0 || details.some((detail) => selected.has(detail));
+			if (!matchesFilters) {
+				return false;
+			}
+			if (!normalizedQuery) {
+				return true;
+			}
+			const searchable = [
+				thread.title,
+				thread.codebase,
+				thread.provider,
+				thread.model,
+				session?.workspaceRoot,
+				session?.cwd,
+			]
+				.filter(Boolean)
+				.join(" ")
+				.toLowerCase();
+			return searchable.includes(normalizedQuery);
+		});
+		return [...filtered].sort((a, b) => {
+			const aTime = sortTimestamp(history.sessionById.get(a.id));
+			const bTime = sortTimestamp(history.sessionById.get(b.id));
+			return sortDirection === "newest" ? bTime - aTime : aTime - bTime;
+		});
+	}, [
+		history.sessionById,
+		history.threads,
+		query,
+		sessionFilters,
+		sortDirection,
+	]);
+
+	const toggleFilter = (detail: string, checked: boolean) => {
+		setSessionFilters((current) => {
+			if (checked) {
+				return current.includes(detail) ? current : [...current, detail];
+			}
+			return current.filter((item) => item !== detail);
+		});
+	};
+
+	const startRename = (thread: SessionThread) => {
+		setEditingSessionId(thread.id);
+		setEditingTitle(thread.title);
+	};
+
+	const cancelRename = () => {
+		setEditingSessionId(null);
+		setEditingTitle("");
+	};
+
+	const submitRename = async (thread: SessionThread) => {
+		const renamed = await history.renameThread(thread.id, editingTitle);
+		if (renamed) {
+			cancelRename();
+		}
+	};
+
+	const confirmDelete = async () => {
+		if (!deleteCandidate) {
+			return;
+		}
+		const deleted = await history.deleteThread(deleteCandidate.id);
+		if (deleted) {
+			setDeleteCandidate(null);
+		}
+	};
+
+	return (
+		<div className="flex h-full min-h-0 flex-col overflow-hidden bg-background text-foreground">
+			<header className="flex shrink-0 items-center justify-between gap-4 border-b px-6 py-4">
+				<div className="min-w-0">
+					<h1 className="text-lg font-semibold leading-tight">Sessions</h1>
+					<p className="mt-1 text-sm text-muted-foreground">
+						Recent sessions across clients and workspaces.
+					</p>
+				</div>
+				<div className="flex min-w-0 items-center gap-2">
+					<div className="relative min-w-44 max-w-72 flex-1">
+						<Search className="-translate-y-1/2 pointer-events-none absolute left-2.5 top-1/2 size-4 text-muted-foreground" />
+						<Input
+							aria-label="Search sessions"
+							className="h-8 pl-8"
+							onChange={(event) => setQuery(event.target.value)}
+							placeholder="Search"
+							value={query}
+						/>
+					</div>
+					<DropdownMenu>
+						<DropdownMenuTrigger asChild>
+							<Button
+								aria-label="Sort sessions"
+								className="h-8 rounded-md px-2.5"
+								size="sm"
+								title="Sort sessions"
+								type="button"
+								variant="outline"
+							>
+								<ArrowUpDown className="size-4" />
+							</Button>
+						</DropdownMenuTrigger>
+						<DropdownMenuContent align="end" sideOffset={6}>
+							<DropdownMenuItem onClick={() => setSortDirection("newest")}>
+								{sortDirection === "newest" ? "Newest first" : "Newest first"}
+							</DropdownMenuItem>
+							<DropdownMenuItem onClick={() => setSortDirection("oldest")}>
+								{sortDirection === "oldest" ? "Oldest first" : "Oldest first"}
+							</DropdownMenuItem>
+						</DropdownMenuContent>
+					</DropdownMenu>
+					<DropdownMenu>
+						<DropdownMenuTrigger asChild>
+							<Button
+								aria-label="Filter sessions"
+								className="h-8 rounded-md px-2.5"
+								size="sm"
+								title="Filter sessions"
+								type="button"
+								variant={sessionFilters.length > 0 ? "default" : "outline"}
+							>
+								<Filter className="size-4" />
+							</Button>
+						</DropdownMenuTrigger>
+						<DropdownMenuContent align="end" className="max-h-72 w-72">
+							<DropdownMenuGroup>
+								<DropdownMenuLabel>Filter sessions</DropdownMenuLabel>
+								{sessionFilters.length > 0 ? (
+									<>
+										<DropdownMenuItem onClick={() => setSessionFilters([])}>
+											Clear filters
+										</DropdownMenuItem>
+										<DropdownMenuSeparator />
+									</>
+								) : null}
+								{filterOptions.length === 0 ? (
+									<DropdownMenuItem disabled>
+										No filters available
+									</DropdownMenuItem>
+								) : (
+									filterOptions.map((detail) => (
+										<DropdownMenuCheckboxItem
+											checked={sessionFilters.includes(detail)}
+											key={detail}
+											onCheckedChange={(checked) =>
+												toggleFilter(detail, checked === true)
+											}
+										>
+											<span className="truncate" title={detail}>
+												{detail}
+											</span>
+										</DropdownMenuCheckboxItem>
+									))
+								)}
+							</DropdownMenuGroup>
+						</DropdownMenuContent>
+					</DropdownMenu>
+				</div>
+			</header>
+
+			<section className="min-h-0 flex-1 overflow-auto px-6 py-5">
+				<div className="min-w-240 overflow-hidden rounded-lg border bg-card">
+					<div className="grid grid-cols-[minmax(14rem,1.35fr)_minmax(9rem,0.8fr)_minmax(12rem,1fr)_7rem_5rem_6rem_2.5rem] gap-x-4 bg-muted/40 px-4 py-3 text-sm font-medium text-muted-foreground">
+						<span>Session</span>
+						<span>Workspace</span>
+						<span>Model</span>
+						<span>Tokens</span>
+						<span>Cost</span>
+						<span>Updated</span>
+						<span />
+					</div>
+					<div>
+						{history.isLoadingHistory && history.threads.length === 0 ? (
+							<div className="flex items-center gap-2 border-t px-4 py-8 text-sm text-muted-foreground">
+								<Loader2 className="size-4 animate-spin" />
+								Loading session history...
+							</div>
+						) : null}
+						{!history.isLoadingHistory && filteredThreads.length === 0 ? (
+							<div className="border-t px-4 py-8 text-sm text-muted-foreground">
+								{history.threads.length === 0
+									? "No sessions yet."
+									: "No sessions match the current filters."}
+							</div>
+						) : null}
+						{filteredThreads.map((thread) => {
+							const session = history.sessionById.get(thread.id);
+							const isEditing = editingSessionId === thread.id;
+							const isPending = history.pendingAction?.sessionId === thread.id;
+							const pendingKind = isPending
+								? history.pendingAction?.action
+								: null;
+							const workspace = session?.workspaceRoot || session?.cwd || "";
+							const updated = formatRelativeTime(
+								session?.endedAt || session?.startedAt,
+							);
+							return (
+								<div
+									className={cn(
+										"grid min-h-14 grid-cols-[minmax(14rem,1.35fr)_minmax(9rem,0.8fr)_minmax(12rem,1fr)_7rem_5rem_6rem_2.5rem] items-center gap-x-4 border-t px-4 py-3 text-sm transition-colors",
+										activeSessionId === thread.id
+											? "bg-accent/50"
+											: "hover:bg-accent/30",
+									)}
+									key={thread.id}
+								>
+									{isEditing ? (
+										<form
+											className="col-span-6 grid grid-cols-[minmax(14rem,1.35fr)_minmax(9rem,0.8fr)_minmax(12rem,1fr)_7rem_5rem_6rem] items-center gap-x-4"
+											onSubmit={(event) => {
+												event.preventDefault();
+												void submitRename(thread);
+											}}
+										>
+											<div className="col-span-2 flex min-w-0 items-center gap-2">
+												<Input
+													aria-label={`Rename ${thread.title}`}
+													autoFocus
+													className="h-8"
+													disabled={pendingKind === "rename"}
+													onChange={(event) =>
+														setEditingTitle(event.target.value)
+													}
+													onKeyDown={(event) => {
+														if (event.key === "Escape") {
+															event.preventDefault();
+															cancelRename();
+														}
+													}}
+													value={editingTitle}
+												/>
+												<Button
+													aria-label="Save title"
+													className="h-8 rounded-md px-2.5"
+													disabled={
+														pendingKind === "rename" || !editingTitle.trim()
+													}
+													size="sm"
+													type="submit"
+												>
+													{pendingKind === "rename" ? (
+														<Loader2 className="size-4 animate-spin" />
+													) : (
+														<Check className="size-4" />
+													)}
+												</Button>
+												<Button
+													aria-label="Cancel rename"
+													className="h-8 rounded-md px-2.5"
+													disabled={pendingKind === "rename"}
+													onClick={cancelRename}
+													size="sm"
+													type="button"
+													variant="outline"
+												>
+													<X className="size-4" />
+												</Button>
+											</div>
+											<span className="truncate text-muted-foreground">
+												{modelLabel(thread)}
+											</span>
+											<span className="text-muted-foreground">
+												{tokensLabel(thread)}
+											</span>
+											<span className="text-muted-foreground">
+												{formatCostUsd(thread.totalCostUsd) ?? "-"}
+											</span>
+											<span className="text-muted-foreground">
+												{updated || thread.time}
+											</span>
+										</form>
+									) : (
+										<button
+											className="col-span-6 grid cursor-pointer select-text grid-cols-[minmax(14rem,1.35fr)_minmax(9rem,0.8fr)_minmax(12rem,1fr)_7rem_5rem_6rem] items-center gap-x-4 border-0 bg-transparent p-0 text-left font-inherit text-inherit focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-default"
+											disabled={Boolean(pendingKind)}
+											onClick={() => {
+												if (pendingKind) {
+													return;
+												}
+												// Don't open the session when the user is selecting text.
+												if (window.getSelection()?.toString()) {
+													return;
+												}
+												history.openThread(thread.id);
+											}}
+											type="button"
+										>
+											<span className="flex min-w-0 items-center gap-3 font-semibold">
+												<span
+													className={cn(
+														"size-1.5 shrink-0 rounded-full",
+														statusTone(thread.status),
+													)}
+												/>
+												<span className="truncate">{thread.title}</span>
+											</span>
+											<span className="flex min-w-0 items-center gap-2 text-muted-foreground">
+												<Folder className="size-3.5 shrink-0" />
+												<span className="truncate" title={workspace}>
+													{workspace ? basenamePath(workspace) : "No workspace"}
+												</span>
+											</span>
+											<span className="truncate text-muted-foreground">
+												{modelLabel(thread)}
+											</span>
+											<span className="text-muted-foreground">
+												{tokensLabel(thread)}
+											</span>
+											<span className="text-muted-foreground">
+												{formatCostUsd(thread.totalCostUsd) ?? "-"}
+											</span>
+											<span className="text-muted-foreground">
+												{updated || thread.time}
+											</span>
+										</button>
+									)}
+									<DropdownMenu>
+										<DropdownMenuTrigger asChild>
+											<button
+												aria-label={`Session actions for ${thread.title}`}
+												className="grid size-7 place-items-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+												disabled={Boolean(pendingKind)}
+												type="button"
+											>
+												{pendingKind ? (
+													<Loader2 className="size-4 animate-spin" />
+												) : (
+													<MoreHorizontal className="size-4" />
+												)}
+											</button>
+										</DropdownMenuTrigger>
+										<DropdownMenuContent align="end" sideOffset={6}>
+											<DropdownMenuItem onClick={() => startRename(thread)}>
+												<Pencil className="size-4" />
+												Rename
+											</DropdownMenuItem>
+											<DropdownMenuItem
+												onClick={() => void history.forkThread(thread.id)}
+											>
+												<GitFork className="size-4" />
+												Fork
+											</DropdownMenuItem>
+											<DropdownMenuSeparator />
+											<DropdownMenuItem
+												onClick={() => setDeleteCandidate(thread)}
+												variant="destructive"
+											>
+												<Trash2 className="size-4" />
+												Delete
+											</DropdownMenuItem>
+										</DropdownMenuContent>
+									</DropdownMenu>
+								</div>
+							);
+						})}
+						{history.mayHaveMoreSessions ? (
+							<div className="border-t px-4 py-3">
+								<Button
+									className="h-8 rounded-md px-3 text-xs"
+									disabled={history.isLoadingMore}
+									onClick={() =>
+										void history.loadMoreSessions(history.threads.length + 100)
+									}
+									type="button"
+									variant="outline"
+								>
+									{history.isLoadingMore ? (
+										<Loader2 className="size-3.5 animate-spin" />
+									) : null}
+									Load more
+								</Button>
+							</div>
+						) : null}
+					</div>
+				</div>
+			</section>
+
+			<AlertDialog
+				open={deleteCandidate !== null}
+				onOpenChange={(open) => {
+					if (!open && history.pendingAction?.action !== "delete") {
+						setDeleteCandidate(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete session?</AlertDialogTitle>
+						<AlertDialogDescription>
+							This removes "{deleteCandidate?.title ?? "this session"}" from
+							local history.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel
+							disabled={history.pendingAction?.action === "delete"}
+						>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+							disabled={
+								!deleteCandidate || history.pendingAction?.action === "delete"
+							}
+							onClick={(event) => {
+								event.preventDefault();
+								void confirmDelete();
+							}}
+						>
+							{history.pendingAction?.action === "delete" ? (
+								<>
+									<Loader2 className="size-4 animate-spin" />
+									Deleting...
+								</>
+							) : (
+								"Delete"
+							)}
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/account-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/account-view.tsx
new file mode 100644
index 0000000..139cb9f
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/account-view.tsx
@@ -0,0 +1,578 @@
+"use client";
+
+import type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+} from "@cline/core";
+import {
+	AlertCircle,
+	Building,
+	CreditCard,
+	ExternalLink,
+	Loader2,
+	LogOut,
+	Plus,
+	Receipt,
+	RefreshCw,
+} from "lucide-react";
+import Link from "next/link";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { desktopClient } from "@/lib/desktop-client";
+import { cn } from "@/lib/utils";
+
+function normalizeAccountViewError(error: unknown): Error {
+	const message = error instanceof Error ? error.message : String(error);
+	if (message.includes("unsupported desktop command: cline_account")) {
+		return new Error(
+			"The desktop sidecar is running an older build that does not support account commands. Restart the sidecar or reload the app, then try again.",
+		);
+	}
+	return error instanceof Error ? error : new Error(message);
+}
+
+// ---------------------------------------------------------------------------
+// Data fetching helpers via sidecar command
+// ---------------------------------------------------------------------------
+
+async function fetchAccountUser(): Promise<ClineAccountUser> {
+	return await desktopClient.invoke<ClineAccountUser>("cline_account", {
+		action: "clineAccount",
+		operation: "fetchMe",
+	});
+}
+
+async function fetchAccountBalance(): Promise<ClineAccountBalance> {
+	return await desktopClient.invoke<ClineAccountBalance>("cline_account", {
+		action: "clineAccount",
+		operation: "fetchBalance",
+	});
+}
+
+async function fetchAccountOrganizations(): Promise<
+	ClineAccountOrganization[]
+> {
+	return await desktopClient.invoke<ClineAccountOrganization[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchUserOrganizations",
+		},
+	);
+}
+
+async function fetchOrganizationBalance(
+	organizationId: string,
+): Promise<ClineAccountOrganizationBalance> {
+	return await desktopClient.invoke<ClineAccountOrganizationBalance>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchOrganizationBalance",
+			organizationId,
+		},
+	);
+}
+
+async function fetchUsageTransactions(): Promise<
+	ClineAccountUsageTransaction[]
+> {
+	return await desktopClient.invoke<ClineAccountUsageTransaction[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchUsageTransactions",
+		},
+	);
+}
+
+async function fetchOrganizationUsageTransactions(
+	organizationId: string,
+	memberId?: string,
+): Promise<ClineAccountOrganizationUsageTransaction[]> {
+	return await desktopClient.invoke<ClineAccountOrganizationUsageTransaction[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchOrganizationUsageTransactions",
+			organizationId,
+			...(memberId?.trim() ? { memberId: memberId.trim() } : {}),
+		},
+	);
+}
+
+async function fetchPaymentTransactions(): Promise<
+	ClineAccountPaymentTransaction[]
+> {
+	return await desktopClient.invoke<ClineAccountPaymentTransaction[]>(
+		"cline_account",
+		{
+			action: "clineAccount",
+			operation: "fetchPaymentTransactions",
+		},
+	);
+}
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+export function AccountView() {
+	const [activeTab, setActiveTab] = useState<"overview" | "usage" | "billing">(
+		"overview",
+	);
+
+	// Overview data
+	const [user, setUser] = useState<ClineAccountUser | null>(null);
+	const [balance, setBalance] = useState<ClineAccountBalance | null>(null);
+	const [organizationBalance, setOrganizationBalance] =
+		useState<ClineAccountOrganizationBalance | null>(null);
+	const [organizations, setOrganizations] = useState<
+		ClineAccountOrganization[]
+	>([]);
+	const [overviewLoading, setOverviewLoading] = useState(true);
+	const [overviewError, setOverviewError] = useState<string | null>(null);
+
+	// Usage data
+	const [usageTransactions, setUsageTransactions] = useState<
+		ClineAccountUsageTransaction[]
+	>([]);
+	const [usageLoading, setUsageLoading] = useState(false);
+	const [usageError, setUsageError] = useState<string | null>(null);
+	const [usageLoaded, setUsageLoaded] = useState(false);
+	const usageGenerationRef = useRef(0);
+
+	// Billing data
+	const [paymentTransactions, setPaymentTransactions] = useState<
+		ClineAccountPaymentTransaction[]
+	>([]);
+	const [billingLoading, setBillingLoading] = useState(false);
+	const [billingError, setBillingError] = useState<string | null>(null);
+	const [billingLoaded, setBillingLoaded] = useState(false);
+	const activeOrganization = organizations.find((org) => org.active) ?? null;
+
+	// -- Overview fetch --
+	const loadOverview = useCallback(async () => {
+		setOverviewLoading(true);
+		setOverviewError(null);
+		try {
+			const [userData, balanceData, orgsData] = await Promise.all([
+				fetchAccountUser(),
+				fetchAccountBalance(),
+				fetchAccountOrganizations(),
+			]);
+			const nextActiveOrganization =
+				orgsData.find((organization) => organization.active) ?? null;
+			const organizationBalanceData = nextActiveOrganization
+				? await fetchOrganizationBalance(nextActiveOrganization.organizationId)
+				: null;
+			setUser(userData);
+			setBalance(balanceData);
+			setOrganizationBalance(organizationBalanceData);
+			setOrganizations(orgsData);
+		} catch (err) {
+			const message = normalizeAccountViewError(err).message;
+			setOverviewError(message);
+		} finally {
+			setOverviewLoading(false);
+		}
+	}, []);
+
+	useEffect(() => {
+		void loadOverview();
+	}, [loadOverview]);
+
+	// -- Usage fetch (lazy on tab switch) --
+	const loadUsage = useCallback(async () => {
+		const generation = usageGenerationRef.current;
+		setUsageLoading(true);
+		setUsageError(null);
+		try {
+			const data = activeOrganization
+				? await fetchOrganizationUsageTransactions(
+						activeOrganization.organizationId,
+						activeOrganization.memberId,
+					)
+				: await fetchUsageTransactions();
+			if (usageGenerationRef.current !== generation) return;
+			setUsageTransactions(data);
+			setUsageLoaded(true);
+		} catch (err) {
+			if (usageGenerationRef.current !== generation) return;
+			const message = normalizeAccountViewError(err).message;
+			setUsageError(message);
+		} finally {
+			if (usageGenerationRef.current === generation) {
+				setUsageLoading(false);
+			}
+		}
+	}, [activeOrganization]);
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: we need to reset usage state when the organization changes
+	useEffect(() => {
+		usageGenerationRef.current += 1;
+		setUsageTransactions([]);
+		setUsageLoaded(false);
+		setUsageError(null);
+	}, [activeOrganization?.organizationId]);
+
+	useEffect(() => {
+		if (activeTab === "usage" && !usageLoaded) {
+			void loadUsage();
+		}
+	}, [activeTab, usageLoaded, loadUsage]);
+
+	// -- Billing fetch (lazy on tab switch) --
+	const loadBilling = useCallback(async () => {
+		setBillingLoading(true);
+		setBillingError(null);
+		try {
+			const data = await fetchPaymentTransactions();
+			setPaymentTransactions(data);
+			setBillingLoaded(true);
+		} catch (err) {
+			const message = normalizeAccountViewError(err).message;
+			setBillingError(message);
+		} finally {
+			setBillingLoading(false);
+		}
+	}, []);
+
+	useEffect(() => {
+		if (activeTab === "billing" && !billingLoaded) {
+			void loadBilling();
+		}
+	}, [activeTab, billingLoaded, loadBilling]);
+
+	// -- Formatters --
+
+	const formatDate = (dateStr: string) => {
+		return new Date(dateStr).toLocaleDateString("en-US", {
+			month: "short",
+			day: "numeric",
+			year: "numeric",
+		});
+	};
+
+	const formatTime = (dateStr: string) => {
+		return new Date(dateStr).toLocaleTimeString("en-US", {
+			hour: "numeric",
+			minute: "2-digit",
+		});
+	};
+
+	const formatCreditBalance = (value: number, decimalPlaces = 2) => {
+		return new Intl.NumberFormat("en-US", {
+			minimumFractionDigits: decimalPlaces,
+			maximumFractionDigits: decimalPlaces,
+		}).format(value / 1_000_000);
+	};
+
+	const displayedBalance = activeOrganization
+		? (organizationBalance?.balance ?? balance?.balance ?? null)
+		: (balance?.balance ?? null);
+
+	const tabs = ["overview", "usage", "billing"] as const;
+
+	// -- Shared error / loading UI --
+
+	const renderError = (message: string, onRetry: () => void) => (
+		<div className="flex flex-col items-center justify-center gap-3 py-12 text-center">
+			<AlertCircle className="h-8 w-8 text-destructive" />
+			<p className="text-sm text-muted-foreground max-w-md">{message}</p>
+			<button
+				type="button"
+				onClick={onRetry}
+				className="flex items-center gap-2 rounded-lg border border-border px-3.5 py-2 text-sm font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+			>
+				<RefreshCw className="h-4 w-4" />
+				Retry
+			</button>
+		</div>
+	);
+
+	const renderLoading = () => (
+		<div className="flex items-center justify-center py-12">
+			<Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+		</div>
+	);
+
+	return (
+		<ScrollArea className="h-full">
+			<div className="mx-auto max-w-3xl px-8 py-6">
+				{/* Header */}
+				<div className="mb-6 flex items-center justify-between">
+					<h2 className="text-lg font-semibold text-foreground">Account</h2>
+					<button
+						type="button"
+						className="flex items-center gap-2 rounded-lg border border-border px-3.5 py-2 text-sm font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+					>
+						<LogOut className="h-4 w-4" />
+						Sign Out
+					</button>
+				</div>
+
+				{/* Tabs */}
+				<div className="mb-6 flex items-center gap-0 border-b border-border">
+					{tabs.map((tab) => (
+						<button
+							key={tab}
+							type="button"
+							onClick={() => setActiveTab(tab)}
+							className={cn(
+								"relative px-4 py-2.5 text-sm font-medium capitalize transition-colors",
+								activeTab === tab
+									? "text-foreground"
+									: "text-muted-foreground hover:text-foreground",
+							)}
+						>
+							{tab}
+							{activeTab === tab && (
+								<span className="absolute inset-x-0 -bottom-px h-0.5 bg-foreground" />
+							)}
+						</button>
+					))}
+				</div>
+
+				{/* Overview Tab */}
+				{activeTab === "overview" && (
+					<div className="flex flex-col gap-6">
+						{overviewLoading && renderLoading()}
+						{overviewError && renderError(overviewError, loadOverview)}
+						{!overviewLoading && !overviewError && user && (
+							<>
+								{/* User Profile Card */}
+								<div className="rounded-lg border border-border p-5">
+									<div className="flex items-start gap-4">
+										<div className="flex h-16 w-16 shrink-0 items-center justify-center rounded-full bg-primary/20 text-2xl font-bold text-primary">
+											{user.displayName?.charAt(0) ??
+												user.email?.charAt(0) ??
+												"?"}
+										</div>
+										<div className="min-w-0 flex-1">
+											<h3 className="text-base font-semibold text-foreground">
+												{user.displayName || user.email}
+											</h3>
+											<p className="mt-0.5 text-sm text-muted-foreground">
+												{user.email}
+											</p>
+											<p className="mt-2 text-xs text-muted-foreground">
+												Member since {formatDate(user.createdAt)}
+											</p>
+										</div>
+										<Link
+											href="https://app.cline.bot/dashboard"
+											target="_blank"
+											rel="noopener noreferrer"
+											className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+										>
+											<ExternalLink className="h-4 w-4" />
+										</Link>
+									</div>
+								</div>
+
+								{/* Balance Card */}
+								{displayedBalance !== null && (
+									<div className="rounded-lg border border-border p-5">
+										<div className="flex items-center justify-between mb-4">
+											<div className="flex items-center gap-3">
+												<CreditCard className="h-5 w-5 text-primary" />
+												<h3 className="text-sm font-semibold text-foreground">
+													{activeOrganization
+														? `${activeOrganization.name} Balance`
+														: "Credits Balance"}
+												</h3>
+											</div>
+											<Link
+												href="https://app.cline.bot/dashboard/organization?tab=credits&redirect=true"
+												target="_blank"
+												rel="noopener noreferrer"
+												className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+											>
+												<Plus className="h-3.5 w-3.5" />
+												Credit
+											</Link>
+										</div>
+										<div className="flex items-baseline gap-2">
+											<span className="text-3xl font-bold text-foreground">
+												${formatCreditBalance(displayedBalance)}
+											</span>
+										</div>
+										{activeOrganization && balance && (
+											<p className="mt-2 text-xs text-muted-foreground">
+												Personal account: {formatCreditBalance(balance.balance)}{" "}
+												credits
+											</p>
+										)}
+									</div>
+								)}
+
+								{/* Organizations */}
+								<div className="rounded-lg border border-border p-5">
+									<div className="flex items-center justify-between mb-4">
+										<div className="flex items-center gap-3">
+											<Building className="h-5 w-5 text-muted-foreground" />
+											<h3 className="text-sm font-semibold text-foreground">
+												Organizations
+											</h3>
+										</div>
+										<Link
+											href="https://app.cline.bot/onboarding?step=1"
+											target="_blank"
+											rel="noopener noreferrer"
+											className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+										>
+											<Plus className="h-3.5 w-3.5" />
+											Create
+										</Link>
+									</div>
+									{organizations.length === 0 ? (
+										<p className="text-sm text-muted-foreground">
+											No organizations yet.
+										</p>
+									) : (
+										<div className="flex flex-col gap-2">
+											{organizations.map((org) => (
+												<div
+													key={org.organizationId}
+													className="flex items-center gap-3 rounded-lg border border-border px-4 py-3 transition-colors hover:bg-accent/20"
+												>
+													<div className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg bg-secondary text-sm font-bold text-foreground">
+														{org.name.charAt(0)}
+													</div>
+													<div className="min-w-0 flex-1">
+														<p className="text-sm font-medium text-foreground">
+															{org.name}
+														</p>
+														<p className="text-xs text-muted-foreground capitalize">
+															{org.roles.join(", ")}
+														</p>
+													</div>
+													{org.active && (
+														<span className="rounded-full bg-primary/20 px-2 py-0.5 text-xs font-medium text-primary">
+															Active
+														</span>
+													)}
+												</div>
+											))}
+										</div>
+									)}
+								</div>
+							</>
+						)}
+					</div>
+				)}
+
+				{/* Usage Tab */}
+				{activeTab === "usage" && (
+					<div>
+						<p className="mb-6 text-sm text-muted-foreground">
+							{activeOrganization
+								? `Recent API usage and token consumption for ${activeOrganization.name}.`
+								: "Recent API usage and token consumption across all providers."}
+						</p>
+						{usageLoading && renderLoading()}
+						{usageError && renderError(usageError, loadUsage)}
+						{!usageLoading &&
+							!usageError &&
+							usageLoaded &&
+							(usageTransactions.length === 0 ? (
+								<p className="py-8 text-center text-sm text-muted-foreground">
+									No usage transactions yet.
+								</p>
+							) : (
+								<div className="rounded-lg border border-border overflow-hidden">
+									<div className="grid grid-cols-[1fr_auto_auto_auto] gap-4 border-b border-border bg-secondary/50 px-4 py-2.5 text-xs font-medium text-muted-foreground">
+										<span>Model</span>
+										<span className="text-right">Tokens</span>
+										<span className="text-right">Credits</span>
+										<span className="text-right">Time</span>
+									</div>
+									<div className="divide-y divide-border">
+										{usageTransactions.map((tx) => (
+											<div
+												key={tx.id}
+												className="grid grid-cols-[1fr_auto_auto_auto] gap-4 px-4 py-3 text-sm transition-colors hover:bg-accent/20"
+											>
+												<div className="min-w-0">
+													<p className="font-medium text-foreground truncate">
+														{tx.aiModelName}
+													</p>
+													<p className="text-xs text-muted-foreground">
+														{tx.aiInferenceProviderName}
+													</p>
+												</div>
+												<div className="text-right text-muted-foreground">
+													{tx.totalTokens.toLocaleString()}
+												</div>
+												<div className="text-right text-foreground font-medium">
+													{formatCreditBalance(tx.creditsUsed)}
+												</div>
+												<div className="text-right text-xs text-muted-foreground">
+													<p>{formatDate(tx.createdAt)}</p>
+													<p>{formatTime(tx.createdAt)}</p>
+												</div>
+											</div>
+										))}
+									</div>
+								</div>
+							))}
+					</div>
+				)}
+
+				{/* Billing Tab */}
+				{activeTab === "billing" && (
+					<div>
+						<p className="mb-6 text-sm text-muted-foreground">
+							Payment history and credit purchases.
+						</p>
+						{billingLoading && renderLoading()}
+						{billingError && renderError(billingError, loadBilling)}
+						{!billingLoading &&
+							!billingError &&
+							billingLoaded &&
+							(paymentTransactions.length === 0 ? (
+								<p className="py-8 text-center text-sm text-muted-foreground">
+									No payment transactions yet.
+								</p>
+							) : (
+								<div className="rounded-lg border border-border overflow-hidden">
+									<div className="grid grid-cols-[1fr_auto_auto] gap-4 border-b border-border bg-secondary/50 px-4 py-2.5 text-xs font-medium text-muted-foreground">
+										<span>Date</span>
+										<span className="text-right">Amount</span>
+										<span className="text-right">Credits</span>
+									</div>
+									<div className="divide-y divide-border">
+										{paymentTransactions.map((tx) => (
+											<div
+												key={`${tx.paidAt}-${tx.amountCents}-${tx.credits}`}
+												className="grid grid-cols-[1fr_auto_auto] gap-4 px-4 py-3 text-sm transition-colors hover:bg-accent/20"
+											>
+												<div className="flex items-center gap-3">
+													<Receipt className="h-4 w-4 text-muted-foreground" />
+													<span className="text-foreground">
+														{formatDate(tx.paidAt)}
+													</span>
+												</div>
+												<div className="text-right text-foreground font-medium">
+													${(tx.amountCents / 100).toFixed(2)}
+												</div>
+												<div className="text-right text-primary font-medium">
+													+{formatCreditBalance(tx.credits)}
+												</div>
+											</div>
+										))}
+									</div>
+								</div>
+							))}
+					</div>
+				)}
+			</div>
+		</ScrollArea>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/add-provider.tsx b/apps/examples/desktop-app/webview/components/views/settings/add-provider.tsx
new file mode 100644
index 0000000..6778380
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/add-provider.tsx
@@ -0,0 +1,529 @@
+"use client";
+
+import {
+	ArrowLeft,
+	ChevronDown,
+	Copy,
+	Eye,
+	EyeOff,
+	Plus,
+	Trash2,
+	X,
+} from "lucide-react";
+import { useMemo, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+const CAPABILITY_OPTIONS = [
+	"streaming",
+	"tools",
+	"reasoning",
+	"vision",
+	"prompt-cache",
+] as const;
+
+type Capability = (typeof CAPABILITY_OPTIONS)[number];
+
+export interface AddProviderPayload {
+	providerId: string;
+	name: string;
+	baseUrl: string;
+	apiKey?: string;
+	headers?: Record<string, string>;
+	timeoutMs?: number;
+	models: string[];
+	defaultModelId?: string;
+	modelsSourceUrl?: string;
+	capabilities?: Capability[];
+}
+
+interface NewProviderForm {
+	providerId: string;
+	name: string;
+	models: string[];
+	defaultModel: string;
+	apiKey: string;
+	baseUrl: string;
+	modelsSourceUrl: string;
+	headers: Record<string, string>;
+	timeoutMs: string;
+	capabilities: Capability[];
+}
+
+export function AddProviderContent({
+	onBack,
+	onSave,
+	existingProviderIds,
+}: {
+	onBack: () => void;
+	onSave: (payload: AddProviderPayload) => Promise<void>;
+	existingProviderIds: string[];
+}) {
+	const [form, setForm] = useState<NewProviderForm>({
+		providerId: "",
+		name: "",
+		models: [],
+		defaultModel: "",
+		apiKey: "",
+		baseUrl: "",
+		modelsSourceUrl: "",
+		headers: {},
+		timeoutMs: "",
+		capabilities: ["streaming", "tools"],
+	});
+	const [modelInput, setModelInput] = useState("");
+	const [showApiKey, setShowApiKey] = useState(false);
+	const [showAdvanced, setShowAdvanced] = useState(false);
+	const [saving, setSaving] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+
+	const normalizedProviderId = useMemo(
+		() => form.providerId.trim().toLowerCase().replace(/\s+/g, "-"),
+		[form.providerId],
+	);
+
+	const duplicateProviderId =
+		existingProviderIds.includes(normalizedProviderId);
+	const hasManualModels = form.models.length > 0;
+	const hasModelsSource = form.modelsSourceUrl.trim().length > 0;
+	const canSave =
+		normalizedProviderId.length > 0 &&
+		form.name.trim().length > 0 &&
+		form.baseUrl.trim().length > 0 &&
+		(hasManualModels || hasModelsSource) &&
+		!duplicateProviderId;
+
+	const handleAddModel = (e: React.KeyboardEvent<HTMLInputElement>) => {
+		if ((e.key === "Enter" || e.key === ",") && modelInput.trim()) {
+			e.preventDefault();
+			const value = modelInput.trim().replace(/,/g, "");
+			if (value && !form.models.includes(value)) {
+				setForm((prev) => ({
+					...prev,
+					models: [...prev.models, value],
+					defaultModel: prev.defaultModel || value,
+				}));
+			}
+			setModelInput("");
+		} else if (e.key === "Backspace" && !modelInput && form.models.length > 0) {
+			setForm((prev) => ({
+				...prev,
+				models: prev.models.slice(0, -1),
+			}));
+		}
+	};
+
+	const removeModel = (model: string) => {
+		setForm((prev) => {
+			const nextModels = prev.models.filter((m) => m !== model);
+			return {
+				...prev,
+				models: nextModels,
+				defaultModel:
+					prev.defaultModel === model
+						? (nextModels[0] ?? "")
+						: prev.defaultModel,
+			};
+		});
+	};
+
+	const toggleCapability = (cap: Capability) => {
+		setForm((prev) => ({
+			...prev,
+			capabilities: prev.capabilities.includes(cap)
+				? prev.capabilities.filter((c) => c !== cap)
+				: [...prev.capabilities, cap],
+		}));
+	};
+
+	const addHeader = () => {
+		setForm((prev) => ({ ...prev, headers: { ...prev.headers, "": "" } }));
+	};
+
+	const updateHeaderKey = (oldKey: string, newKey: string, idx: number) => {
+		const entries = Object.entries(form.headers);
+		const next: Record<string, string> = {};
+		entries.forEach(([key, value], index) => {
+			next[index === idx ? newKey : key] = value;
+		});
+		if (oldKey !== newKey) {
+			delete next[oldKey];
+		}
+		setForm((prev) => ({ ...prev, headers: next }));
+	};
+
+	const updateHeaderValue = (key: string, value: string) => {
+		setForm((prev) => ({
+			...prev,
+			headers: { ...prev.headers, [key]: value },
+		}));
+	};
+
+	const removeHeader = (key: string) => {
+		const next = { ...form.headers };
+		delete next[key];
+		setForm((prev) => ({ ...prev, headers: next }));
+	};
+
+	const handleSave = async () => {
+		if (!canSave || saving) {
+			return;
+		}
+		setSaving(true);
+		setError(null);
+		try {
+			await onSave({
+				providerId: normalizedProviderId,
+				name: form.name.trim(),
+				baseUrl: form.baseUrl.trim(),
+				apiKey: form.apiKey.trim() || undefined,
+				headers: Object.fromEntries(
+					Object.entries(form.headers)
+						.map(([key, value]) => [key.trim(), value])
+						.filter(([key]) => key.length > 0),
+				),
+				timeoutMs:
+					form.timeoutMs.trim().length > 0
+						? Number.parseInt(form.timeoutMs.trim(), 10)
+						: undefined,
+				models: form.models,
+				defaultModelId: form.defaultModel || form.models[0],
+				modelsSourceUrl: form.modelsSourceUrl.trim() || undefined,
+				capabilities:
+					form.capabilities.length > 0 ? form.capabilities : undefined,
+			});
+		} catch (saveError) {
+			setError(
+				saveError instanceof Error ? saveError.message : String(saveError),
+			);
+		} finally {
+			setSaving(false);
+		}
+	};
+
+	return (
+		<ScrollArea className="h-full">
+			<div className="mx-auto max-w-3xl px-8 py-6">
+				<div className="mb-6 flex items-center gap-3">
+					<Button
+						onClick={onBack}
+						className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						aria-label="Back to providers"
+					>
+						<ArrowLeft className="h-4 w-4" />
+					</Button>
+					<h2 className="text-lg font-semibold text-foreground">
+						Add Provider
+					</h2>
+				</div>
+
+				<div className="flex flex-col gap-6">
+					<div className="rounded-lg border border-border p-5">
+						<h3 className="mb-4 text-sm font-semibold text-foreground">
+							OpenAI-Compatible Provider
+						</h3>
+						<div className="grid grid-cols-1 gap-4 md:grid-cols-2">
+							<div>
+								<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+									Provider ID
+								</Label>
+								<input
+									type="text"
+									value={form.providerId}
+									onChange={(e) =>
+										setForm((prev) => ({ ...prev, providerId: e.target.value }))
+									}
+									placeholder="my-provider"
+									className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+								/>
+								<p className="mt-1.5 text-xs text-muted-foreground">
+									Lowercase ID used in provider registry.
+								</p>
+								{duplicateProviderId ? (
+									<p className="mt-1 text-xs text-destructive">
+										This provider ID already exists.
+									</p>
+								) : null}
+							</div>
+							<div>
+								<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+									Provider Name
+								</Label>
+								<input
+									type="text"
+									value={form.name}
+									onChange={(e) =>
+										setForm((prev) => ({ ...prev, name: e.target.value }))
+									}
+									placeholder="My Provider"
+									className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+								/>
+							</div>
+						</div>
+					</div>
+
+					<div className="rounded-lg border border-border p-5">
+						<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+							Base URL
+						</Label>
+						<input
+							type="url"
+							value={form.baseUrl}
+							onChange={(e) =>
+								setForm((prev) => ({ ...prev, baseUrl: e.target.value }))
+							}
+							placeholder="https://api.example.com/v1"
+							className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+						/>
+					</div>
+
+					<div className="rounded-lg border border-border p-5">
+						<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+							Model Source URL (Optional)
+						</Label>
+						<input
+							type="url"
+							value={form.modelsSourceUrl}
+							onChange={(e) =>
+								setForm((prev) => ({
+									...prev,
+									modelsSourceUrl: e.target.value,
+								}))
+							}
+							placeholder="https://api.example.com/v1/models"
+							className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+						/>
+						<p className="mt-1.5 text-xs text-muted-foreground">
+							Supported JSON: OpenAI `/models` shape with a `data` array, or a
+							direct model array.
+						</p>
+					</div>
+
+					<div className="rounded-lg border border-border p-5">
+						<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+							Models
+						</Label>
+						<div className="flex min-h-11 flex-wrap content-start gap-1.5 rounded-lg border border-border bg-input px-3 py-2 focus-within:ring-1 focus-within:ring-ring">
+							{form.models.map((model) => (
+								<span
+									key={model}
+									className="inline-flex items-center gap-1 rounded-md bg-primary/10 px-2 py-1 text-xs font-medium text-primary"
+								>
+									<span className="font-mono">{model}</span>
+									<Button
+										onClick={() => removeModel(model)}
+										className="text-primary/60 hover:text-primary transition-colors"
+										aria-label={`Remove ${model}`}
+									>
+										<X className="h-3 w-3" />
+									</Button>
+								</span>
+							))}
+							<input
+								type="text"
+								value={modelInput}
+								onChange={(e) => setModelInput(e.target.value)}
+								onKeyDown={handleAddModel}
+								placeholder={
+									form.models.length === 0
+										? "Type model ID and press Enter"
+										: ""
+								}
+								className="min-w-35 flex-1 bg-transparent text-sm text-foreground placeholder:text-muted-foreground/50 outline-none"
+							/>
+						</div>
+						<p className="mt-1.5 text-xs text-muted-foreground">
+							Add at least one model or set a Model Source URL.
+						</p>
+					</div>
+
+					{form.models.length > 1 ? (
+						<div className="rounded-lg border border-border p-5">
+							<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+								Default Model
+							</Label>
+							<select
+								value={form.defaultModel}
+								onChange={(e) =>
+									setForm((prev) => ({ ...prev, defaultModel: e.target.value }))
+								}
+								className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground outline-none focus:ring-1 focus:ring-ring"
+							>
+								{form.models.map((model) => (
+									<option key={model} value={model}>
+										{model}
+									</option>
+								))}
+							</select>
+						</div>
+					) : null}
+
+					<div className="rounded-lg border border-border p-5">
+						<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+							API Key (Optional)
+						</Label>
+						<div className="relative">
+							<input
+								type={showApiKey ? "text" : "password"}
+								value={form.apiKey}
+								onChange={(e) =>
+									setForm((prev) => ({ ...prev, apiKey: e.target.value }))
+								}
+								placeholder="sk-..."
+								className="w-full rounded-lg border border-border bg-input px-3 py-2 pr-20 font-mono text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+							/>
+							<div className="absolute right-2 top-1/2 flex -translate-y-1/2 items-center gap-1">
+								<Button
+									onClick={() => setShowApiKey(!showApiKey)}
+									className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+									aria-label={showApiKey ? "Hide API key" : "Show API key"}
+								>
+									{showApiKey ? (
+										<EyeOff className="h-4 w-4" />
+									) : (
+										<Eye className="h-4 w-4" />
+									)}
+								</Button>
+								<Button
+									onClick={() => navigator.clipboard.writeText(form.apiKey)}
+									className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+									aria-label="Copy API key"
+								>
+									<Copy className="h-4 w-4" />
+								</Button>
+							</div>
+						</div>
+					</div>
+
+					<div className="rounded-lg border border-border p-5">
+						<Label className="mb-3 block text-xs font-medium text-muted-foreground">
+							Capabilities
+						</Label>
+						<div className="flex flex-wrap gap-2">
+							{CAPABILITY_OPTIONS.map((cap) => (
+								<Button
+									key={cap}
+									onClick={() => toggleCapability(cap)}
+									className={cn(
+										"rounded-lg border px-3 py-1.5 text-xs font-medium transition-all",
+										form.capabilities.includes(cap)
+											? "border-primary/40 bg-primary/10 text-primary"
+											: "border-border bg-card text-muted-foreground hover:border-muted-foreground/50 hover:text-foreground",
+									)}
+								>
+									{cap.replace(/-/g, " ")}
+								</Button>
+							))}
+						</div>
+					</div>
+
+					<div className="rounded-lg border border-border overflow-hidden">
+						<Button
+							onClick={() => setShowAdvanced(!showAdvanced)}
+							className="flex w-full items-center justify-between px-5 py-4 text-sm font-medium text-foreground hover:bg-accent/30 transition-colors"
+						>
+							Advanced Settings
+							<ChevronDown
+								className={cn(
+									"h-4 w-4 text-muted-foreground transition-transform",
+									showAdvanced && "rotate-180",
+								)}
+							/>
+						</Button>
+
+						{showAdvanced ? (
+							<div className="border-t border-border px-5 py-5 flex flex-col gap-5">
+								<div>
+									<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+										Timeout (ms)
+									</Label>
+									<input
+										type="number"
+										value={form.timeoutMs}
+										onChange={(e) =>
+											setForm((prev) => ({
+												...prev,
+												timeoutMs: e.target.value,
+											}))
+										}
+										placeholder="30000"
+										className="w-full rounded-lg border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+									/>
+								</div>
+
+								<div>
+									<Label className="mb-2 block text-xs font-medium text-muted-foreground">
+										Custom Headers
+									</Label>
+									<div className="flex flex-col gap-2">
+										{Object.entries(form.headers).map(([key, value], idx) => (
+											<div key={key} className="flex items-center gap-2">
+												<input
+													type="text"
+													value={key}
+													onChange={(e) =>
+														updateHeaderKey(key, e.target.value, idx)
+													}
+													placeholder="Header name"
+													className="flex-1 rounded-lg border border-border bg-input px-3 py-2 font-mono text-xs text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+												/>
+												<input
+													type="text"
+													value={value}
+													onChange={(e) =>
+														updateHeaderValue(key, e.target.value)
+													}
+													placeholder="Value"
+													className="flex-1 rounded-lg border border-border bg-input px-3 py-2 font-mono text-xs text-foreground placeholder:text-muted-foreground/50 outline-none focus:ring-1 focus:ring-ring"
+												/>
+												<Button
+													onClick={() => removeHeader(key)}
+													className="rounded-md p-2 text-muted-foreground hover:text-destructive transition-colors"
+													aria-label="Remove header"
+												>
+													<Trash2 className="h-4 w-4" />
+												</Button>
+											</div>
+										))}
+										<Button
+											onClick={addHeader}
+											className="flex items-center gap-1.5 rounded-md px-2 py-1.5 text-xs font-medium text-muted-foreground hover:text-foreground transition-colors w-fit"
+										>
+											<Plus className="h-3 w-3" />
+											Add Header
+										</Button>
+									</div>
+								</div>
+							</div>
+						) : null}
+					</div>
+
+					{error ? <p className="text-sm text-destructive">{error}</p> : null}
+
+					<div className="flex items-center justify-end gap-3 pt-2">
+						<Button
+							onClick={onBack}
+							className="rounded-lg border border-border px-4 py-2 text-sm font-medium text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						>
+							Cancel
+						</Button>
+						<Button
+							onClick={() => void handleSave()}
+							disabled={!canSave || saving}
+							className={cn(
+								"rounded-lg px-4 py-2 text-sm font-medium transition-colors",
+								canSave && !saving
+									? "bg-primary text-primary-foreground hover:bg-primary/90"
+									: "bg-muted text-muted-foreground cursor-not-allowed",
+							)}
+						>
+							{saving ? "Saving..." : "Add Provider"}
+						</Button>
+					</div>
+				</div>
+			</div>
+		</ScrollArea>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/channels-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/channels-view.tsx
new file mode 100644
index 0000000..cab1e55
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/channels-view.tsx
@@ -0,0 +1,642 @@
+"use client";
+
+import { Circle, Plus, RefreshCw, Trash2 } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button, buttonVariants } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { desktopClient } from "@/lib/desktop-client";
+import { cn } from "@/lib/utils";
+import {
+	CommandBadge,
+	PageEmptyState,
+	PageFrame,
+	PageHeader,
+} from "../page-layout";
+
+type ConnectorField = {
+	flag: string;
+	label: string;
+	placeholder?: string;
+	required?: boolean;
+	help?: string[];
+	initialValue?: string;
+	options?: Array<{ value: string; label: string; hint?: string }>;
+	includeWhen?: {
+		flag: string;
+		equals?: string;
+		notEquals?: string;
+	};
+};
+
+type ConnectorSecurityField = {
+	key: string;
+	label: string;
+	placeholder?: string;
+	help?: string[];
+	requiredMessage: string;
+};
+
+type ConnectorChannel = {
+	id: string;
+	name: string;
+	type: "polling" | "webhook" | "hybrid";
+	hint: string;
+	fields: ConnectorField[];
+	security?: {
+		prompt: string;
+		fields: ConnectorSecurityField[];
+	};
+};
+
+type ActiveConnector = {
+	id: string;
+	type: string;
+	pid: number;
+	hubUrl: string;
+	startedAt?: string;
+	applicationId?: string;
+	botUsername?: string;
+	userName?: string;
+	phoneNumberId?: string;
+	port?: number;
+	baseUrl?: string;
+	connectionMode?: string;
+};
+
+type ConnectorChannelsResponse = {
+	available: ConnectorChannel[];
+	active: ActiveConnector[];
+};
+
+type ConnectorFormState = {
+	channelId: string;
+	values: Record<string, string>;
+	securityEnabled: boolean;
+	securityValues: Record<string, string>;
+};
+
+function connectorName(
+	connector: ActiveConnector,
+	channels: ConnectorChannel[],
+): string {
+	return (
+		channels.find((channel) => channel.id === connector.type)?.name ??
+		connector.type
+	);
+}
+
+function connectorIdentity(connector: ActiveConnector): string {
+	if (connector.botUsername) {
+		return `@${connector.botUsername}`;
+	}
+	if (connector.userName) {
+		return connector.userName;
+	}
+	if (connector.applicationId) {
+		return connector.applicationId;
+	}
+	return `pid ${connector.pid}`;
+}
+
+function formatDateTime(value?: string): string {
+	if (!value) {
+		return "-";
+	}
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+}
+
+function isSecretField(
+	field: ConnectorField | ConnectorSecurityField,
+): boolean {
+	const label = field.label.toLowerCase();
+	const key =
+		"flag" in field ? field.flag.toLowerCase() : field.key.toLowerCase();
+	return (
+		label.includes("token") ||
+		label.includes("secret") ||
+		label.includes("key") ||
+		key.includes("token") ||
+		key.includes("secret") ||
+		key.includes("key")
+	);
+}
+
+function isMultilineField(field: ConnectorField): boolean {
+	const label = field.label.toLowerCase();
+	return label.includes("json") || field.flag.includes("credentials");
+}
+
+function shouldIncludeField(
+	field: ConnectorField,
+	values: Record<string, string>,
+): boolean {
+	const condition = field.includeWhen;
+	if (!condition) {
+		return true;
+	}
+	const value = values[condition.flag] ?? "";
+	if (condition.equals !== undefined && value !== condition.equals) {
+		return false;
+	}
+	if (condition.notEquals !== undefined && value === condition.notEquals) {
+		return false;
+	}
+	return true;
+}
+
+function initialValuesForChannel(
+	channel?: ConnectorChannel,
+): Record<string, string> {
+	const values: Record<string, string> = {};
+	for (const field of channel?.fields ?? []) {
+		if (field.initialValue) {
+			values[field.flag] = field.initialValue;
+		}
+	}
+	return values;
+}
+
+function createFormState(channels: ConnectorChannel[]): ConnectorFormState {
+	const channel = channels[0];
+	return {
+		channelId: channel?.id ?? "",
+		values: initialValuesForChannel(channel),
+		securityEnabled: false,
+		securityValues: {},
+	};
+}
+
+export function ChannelsContent() {
+	const [channels, setChannels] = useState<ConnectorChannel[]>([]);
+	const [activeConnectors, setActiveConnectors] = useState<ActiveConnector[]>(
+		[],
+	);
+	const [isLoading, setIsLoading] = useState(true);
+	const [busyChannel, setBusyChannel] = useState<string | null>(null);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [formState, setFormState] = useState<ConnectorFormState>({
+		channelId: "",
+		values: {},
+		securityEnabled: false,
+		securityValues: {},
+	});
+	const [formError, setFormError] = useState<string | null>(null);
+	const [removeTarget, setRemoveTarget] = useState<ActiveConnector | null>(
+		null,
+	);
+
+	const selectedChannel = useMemo(
+		() => channels.find((channel) => channel.id === formState.channelId),
+		[channels, formState.channelId],
+	);
+	const visibleFields = useMemo(() => {
+		const values = {
+			...initialValuesForChannel(selectedChannel),
+			...formState.values,
+		};
+		return (selectedChannel?.fields ?? []).filter((field) =>
+			shouldIncludeField(field, values),
+		);
+	}, [selectedChannel, formState.values]);
+
+	const applyResponse = useCallback((response: ConnectorChannelsResponse) => {
+		setChannels(response.available);
+		setActiveConnectors(response.active);
+		setFormState((prev) =>
+			prev.channelId ? prev : createFormState(response.available),
+		);
+	}, []);
+
+	const refreshChannels = useCallback(async () => {
+		setIsLoading(true);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<ConnectorChannelsResponse>(
+				"list_connector_channels",
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsLoading(false);
+		}
+	}, [applyResponse]);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refreshChannels();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refreshChannels]);
+
+	const openAddDialog = () => {
+		setFormState(createFormState(channels));
+		setFormError(null);
+		setDialogOpen(true);
+	};
+
+	const updateFieldValue = (flag: string, value: string) => {
+		setFormState((prev) => ({
+			...prev,
+			values: { ...prev.values, [flag]: value },
+		}));
+	};
+
+	const updateSecurityFieldValue = (key: string, value: string) => {
+		setFormState((prev) => ({
+			...prev,
+			securityValues: { ...prev.securityValues, [key]: value },
+		}));
+	};
+
+	const startConnector = async () => {
+		if (!selectedChannel) {
+			setFormError("Choose a channel");
+			return;
+		}
+		for (const field of selectedChannel.fields) {
+			if (!visibleFields.includes(field)) {
+				continue;
+			}
+			if (field.required && !formState.values[field.flag]?.trim()) {
+				setFormError(`${field.label} is required`);
+				return;
+			}
+		}
+		if (formState.securityEnabled && selectedChannel.security) {
+			for (const field of selectedChannel.security.fields) {
+				if (!formState.securityValues[field.key]?.trim()) {
+					setFormError(field.requiredMessage);
+					return;
+				}
+			}
+		}
+		setBusyChannel(selectedChannel.id);
+		setFormError(null);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<ConnectorChannelsResponse>(
+				"start_connector_channel",
+				{
+					channel: selectedChannel.id,
+					values: formState.values,
+					security: {
+						enabled: formState.securityEnabled,
+						values: formState.securityValues,
+					},
+				},
+			);
+			applyResponse(response);
+			setDialogOpen(false);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setFormError(message);
+		} finally {
+			setBusyChannel(null);
+		}
+	};
+
+	const stopConnector = async (connector: ActiveConnector) => {
+		setBusyChannel(connector.type);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<ConnectorChannelsResponse>(
+				"stop_connector_channel",
+				{ channel: connector.type },
+			);
+			applyResponse(response);
+			setRemoveTarget(null);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyChannel(null);
+		}
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description={`${activeConnectors.length} connected. Start and manage connector channels for Cline.`}
+				title="Channels"
+				meta={<CommandBadge>cline connect</CommandBadge>}
+				actions={
+					<>
+						<Button
+							disabled={isLoading}
+							onClick={() => void refreshChannels()}
+							size="sm"
+							type="button"
+							variant="outline"
+						>
+							<RefreshCw
+								className={cn("size-4", isLoading && "animate-spin")}
+							/>
+						</Button>
+						<Button
+							disabled={channels.length === 0}
+							onClick={openAddDialog}
+							size="sm"
+							type="button"
+						>
+							<Plus className="size-4" />
+							Add Channel
+						</Button>
+					</>
+				}
+			/>
+
+			{errorMessage ? (
+				<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			) : null}
+
+			{isLoading ? (
+				<PageEmptyState>Loading channels...</PageEmptyState>
+			) : activeConnectors.length === 0 ? (
+				<PageEmptyState>No channels connected.</PageEmptyState>
+			) : (
+				<section className="overflow-hidden rounded-lg border bg-card">
+					<div className="grid gap-2 p-2.5">
+						{activeConnectors.map((connector) => (
+							<div
+								className="grid gap-3 border bg-[color-mix(in_oklch,var(--background)_70%,var(--card))] p-3 md:grid-cols-[minmax(0,1fr)_auto] md:items-center"
+								key={connector.id}
+							>
+								<div className="min-w-0">
+									<div className="flex items-center gap-2">
+										<Circle className="size-2 fill-emerald-300 text-emerald-300" />
+										<p className="truncate text-[13px] font-semibold leading-tight">
+											{connectorName(connector, channels)}
+										</p>
+										<span className="rounded-md border bg-background px-1.5 py-0.5 text-[11px] text-muted-foreground">
+											{connectorIdentity(connector)}
+										</span>
+									</div>
+									<div className="mt-2 flex flex-wrap gap-1.5 text-[11px] text-muted-foreground">
+										<span className="rounded-md border bg-background px-1.5 py-0.5">
+											pid={connector.pid}
+										</span>
+										<span
+											className="max-w-full break-all rounded-md border bg-background px-1.5 py-0.5"
+											title={connector.hubUrl}
+										>
+											{connector.hubUrl}
+										</span>
+										{connector.baseUrl ? (
+											<span
+												className="max-w-full break-all rounded-md border bg-background px-1.5 py-0.5"
+												title={connector.baseUrl}
+											>
+												{connector.baseUrl}
+											</span>
+										) : null}
+										<span className="rounded-md border bg-background px-1.5 py-0.5">
+											{formatDateTime(connector.startedAt)}
+										</span>
+										{connector.connectionMode ? (
+											<span className="rounded-md border bg-background px-1.5 py-0.5">
+												{connector.connectionMode}
+											</span>
+										) : null}
+									</div>
+								</div>
+								<Button
+									disabled={busyChannel === connector.type}
+									onClick={() => setRemoveTarget(connector)}
+									size="sm"
+									type="button"
+									variant="outline"
+								>
+									<Trash2 className="size-4" />
+									Remove...
+								</Button>
+							</div>
+						))}
+					</div>
+				</section>
+			)}
+
+			<Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
+				<DialogContent className="max-h-[86vh] overflow-y-auto sm:max-w-xl">
+					<DialogHeader>
+						<DialogTitle>Add Channel</DialogTitle>
+						<DialogDescription>
+							Start a connector channel for Cline.
+						</DialogDescription>
+					</DialogHeader>
+					<div className="grid gap-4 py-2">
+						<div className="grid gap-2">
+							<Label>Channel</Label>
+							<Select
+								onValueChange={(value) => {
+									if (!value) {
+										return;
+									}
+									setFormState({
+										channelId: value,
+										values: initialValuesForChannel(
+											channels.find((channel) => channel.id === value),
+										),
+										securityEnabled: false,
+										securityValues: {},
+									});
+								}}
+								value={formState.channelId}
+							>
+								<SelectTrigger>
+									<SelectValue placeholder="Select channel" />
+								</SelectTrigger>
+								<SelectContent>
+									{channels.map((channel) => (
+										<SelectItem key={channel.id} value={channel.id}>
+											{channel.name}
+										</SelectItem>
+									))}
+								</SelectContent>
+							</Select>
+						</div>
+
+						{visibleFields.map((field) => (
+							<div className="grid gap-2" key={field.flag}>
+								<Label>
+									{field.label}
+									{field.required ? (
+										<span className="text-destructive"> *</span>
+									) : null}
+								</Label>
+								{field.options ? (
+									<Select
+										onValueChange={(value) => {
+											if (value) {
+												updateFieldValue(field.flag, value);
+											}
+										}}
+										value={
+											formState.values[field.flag] ?? field.initialValue ?? ""
+										}
+									>
+										<SelectTrigger>
+											<SelectValue placeholder={field.placeholder} />
+										</SelectTrigger>
+										<SelectContent>
+											{field.options.map((option) => (
+												<SelectItem key={option.value} value={option.value}>
+													{option.label}
+												</SelectItem>
+											))}
+										</SelectContent>
+									</Select>
+								) : isMultilineField(field) ? (
+									<Textarea
+										onChange={(event) =>
+											updateFieldValue(field.flag, event.target.value)
+										}
+										placeholder={field.placeholder}
+										rows={5}
+										value={formState.values[field.flag] ?? ""}
+									/>
+								) : (
+									<Input
+										onChange={(event) =>
+											updateFieldValue(field.flag, event.target.value)
+										}
+										placeholder={field.placeholder}
+										type={isSecretField(field) ? "password" : "text"}
+										value={formState.values[field.flag] ?? ""}
+									/>
+								)}
+							</div>
+						))}
+
+						{selectedChannel?.security ? (
+							<div className="grid gap-3 rounded-lg border p-3">
+								<div className="flex items-center justify-between gap-3">
+									<Label className="text-sm">Restrict access</Label>
+									<Switch
+										checked={formState.securityEnabled}
+										onCheckedChange={(checked: boolean) =>
+											setFormState((prev) => ({
+												...prev,
+												securityEnabled: checked,
+											}))
+										}
+									/>
+								</div>
+								{formState.securityEnabled
+									? selectedChannel.security.fields.map((field) => (
+											<div className="grid gap-2" key={field.key}>
+												<Label>{field.label}</Label>
+												<Input
+													onChange={(event) =>
+														updateSecurityFieldValue(
+															field.key,
+															event.target.value,
+														)
+													}
+													placeholder={field.placeholder}
+													type={isSecretField(field) ? "password" : "text"}
+													value={formState.securityValues[field.key] ?? ""}
+												/>
+											</div>
+										))
+									: null}
+							</div>
+						) : null}
+
+						{formError ? (
+							<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+								{formError}
+							</div>
+						) : null}
+					</div>
+					<DialogFooter>
+						<Button
+							disabled={busyChannel !== null}
+							onClick={() => setDialogOpen(false)}
+							type="button"
+							variant="outline"
+						>
+							Cancel
+						</Button>
+						<Button
+							disabled={busyChannel !== null || !selectedChannel}
+							onClick={() => void startConnector()}
+							type="button"
+						>
+							{busyChannel ? "Starting..." : "Add Channel"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+
+			<AlertDialog
+				open={removeTarget !== null}
+				onOpenChange={(open: boolean) => {
+					if (!open) {
+						setRemoveTarget(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Remove Channel</AlertDialogTitle>
+						<AlertDialogDescription>
+							Confirm that you want to stop the active{" "}
+							{removeTarget ? connectorName(removeTarget, channels) : "channel"}{" "}
+							channel for {removeTarget ? connectorIdentity(removeTarget) : ""}.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={busyChannel !== null}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={busyChannel !== null || !removeTarget}
+							onClick={() => {
+								if (removeTarget) {
+									void stopConnector(removeTarget);
+								}
+							}}
+							className={buttonVariants({ variant: "destructive" })}
+						>
+							Remove
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</PageFrame>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/extensions-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/extensions-view.tsx
new file mode 100644
index 0000000..beed8aa
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/extensions-view.tsx
@@ -0,0 +1,1769 @@
+"use client";
+
+import {
+	Bot,
+	Code,
+	FileText,
+	Play,
+	Puzzle,
+	RefreshCw,
+	Server,
+	Trash2,
+	TriangleAlert,
+	Wrench,
+	Zap,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Spinner } from "@/components/ui/spinner";
+import { Switch } from "@/components/ui/switch";
+import { desktopClient } from "@/lib/desktop-client";
+import type { MarketplacePrimitiveType } from "@/lib/marketplace";
+import { cn } from "@/lib/utils";
+import {
+	type MarketplaceLocalInstalledItem,
+	MarketplaceView,
+} from "../marketplace-view";
+import { CommandBadge, PageFrame, PageHeader } from "../page-layout";
+
+export type CustomizationSection =
+	| "Rules"
+	| "Hooks"
+	| "MCP"
+	| "Skills"
+	| "Agents"
+	| "Plugins"
+	| "Tools";
+
+const sectionDescriptions: Record<CustomizationSection, string> = {
+	Rules: "Review project and global rule files that shape Cline behavior.",
+	Hooks: "Inspect hook configuration and recent execution status.",
+	MCP: "Manage installed MCP servers and add new servers from the marketplace.",
+	Skills: "Manage installed skills and add new skills from the marketplace.",
+	Agents: "Review configured agents discovered from local settings.",
+	Plugins: "Manage installed plugins and add new plugins from the marketplace.",
+	Tools: "Inspect built-in tools and tools contributed by plugins.",
+};
+
+const sectionCommands: Record<CustomizationSection, string> = {
+	Rules: "cline config rules",
+	Hooks: "cline config hooks",
+	MCP: "cline mcp install",
+	Skills: "cline skill",
+	Agents: "cline config agents",
+	Plugins: "cline plugin",
+	Tools: "cline config tools",
+};
+
+type RuleItem = {
+	name: string;
+	instructions: string;
+	path: string;
+};
+
+type WorkflowItem = {
+	id: string;
+	name: string;
+	instructions: string;
+	path: string;
+};
+
+type SkillItem = {
+	name: string;
+	description?: string;
+	instructions: string;
+	path: string;
+};
+
+type CommandItem = {
+	id: string;
+	type: "workflow" | "skill";
+	name: string;
+	description?: string;
+	instructions: string;
+	path: string;
+	scope: ItemScope;
+};
+
+type ItemScope = "Global" | "Project";
+
+type AgentItem = {
+	name: string;
+	path: string;
+};
+
+type PluginItem = {
+	name: string;
+	path: string;
+	enabled: boolean;
+};
+
+type ToolItem = {
+	id: string;
+	name: string;
+	description?: string;
+	enabled: boolean;
+	source: string;
+	path?: string;
+	pluginName?: string;
+	headlessToolNames?: string[];
+};
+
+type HookItem = {
+	fileName: string;
+	hookEventName?: string;
+	path: string;
+};
+
+type SessionHookEvent = {
+	ts: string;
+	hookEventName: string;
+};
+
+type CliDiscoveredSession = {
+	sessionId: string;
+	startedAt: string;
+};
+
+type HookExecutionSummary = {
+	count: number;
+	lastTs: string | null;
+};
+
+type McpServer = {
+	name: string;
+	transportType: "stdio" | "sse" | "streamableHttp";
+	disabled: boolean;
+	command?: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	metadata?: unknown;
+};
+
+type McpServersResponse = {
+	settingsPath: string;
+	hasSettingsFile: boolean;
+	servers: McpServer[];
+};
+
+type LocalUninstallType = "mcp" | "skill" | "workflow" | "plugin";
+
+type LocalUninstallTarget = {
+	key: string;
+	type: LocalUninstallType;
+	id?: string;
+	name?: string;
+	path?: string;
+};
+
+type UserInstructionListsResponse = {
+	workspaceRoot: string;
+	rules: RuleItem[];
+	workflows: WorkflowItem[];
+	skills: SkillItem[];
+	agents: AgentItem[];
+	plugins: PluginItem[];
+	tools: ToolItem[];
+	hooks: HookItem[];
+	mcp: McpServersResponse;
+	warnings: string[];
+};
+
+const EMPTY_MCP_RESPONSE: McpServersResponse = {
+	settingsPath: "",
+	hasSettingsFile: false,
+	servers: [],
+};
+
+function asArray<T>(value: T[] | null | undefined): T[] {
+	return Array.isArray(value) ? value : [];
+}
+
+function normalizeInstructionListsResponse(
+	response: Partial<UserInstructionListsResponse> | null | undefined,
+): UserInstructionListsResponse {
+	return {
+		workspaceRoot:
+			typeof response?.workspaceRoot === "string" ? response.workspaceRoot : "",
+		rules: asArray(response?.rules),
+		workflows: asArray(response?.workflows),
+		skills: asArray(response?.skills),
+		agents: asArray(response?.agents),
+		plugins: asArray(response?.plugins),
+		tools: asArray(response?.tools),
+		hooks: asArray(response?.hooks),
+		mcp:
+			response?.mcp && typeof response.mcp === "object"
+				? {
+						settingsPath:
+							typeof response.mcp.settingsPath === "string"
+								? response.mcp.settingsPath
+								: "",
+						hasSettingsFile: Boolean(response.mcp.hasSettingsFile),
+						servers: asArray(response.mcp.servers),
+					}
+				: {
+						...EMPTY_MCP_RESPONSE,
+					},
+		warnings: asArray(response?.warnings),
+	};
+}
+
+const EXTENSION_LISTS_CACHE_TTL_MS = 60_000;
+const EXTENSION_HOOK_STATS_CACHE_TTL_MS = 30_000;
+
+let extensionListsCache:
+	| (UserInstructionListsResponse & {
+			fetchedAt: number;
+	  })
+	| null = null;
+
+let extensionHookStatsCache: {
+	hookExecutionByEvent: Record<string, HookExecutionSummary>;
+	hookExecutionSessionId: string | null;
+	fetchedAt: number;
+} | null = null;
+
+function hasFreshExtensionsListsCache(
+	cache: typeof extensionListsCache,
+	now: number,
+): cache is NonNullable<typeof extensionListsCache> {
+	return Boolean(
+		cache &&
+			now - cache.fetchedAt < EXTENSION_LISTS_CACHE_TTL_MS &&
+			Array.isArray(cache.tools) &&
+			cache.tools.length > 0,
+	);
+}
+
+function previewText(input: string, maxLength = 150): string {
+	const compact = input.replace(/\s+/g, " ").trim();
+	if (compact.length <= maxLength) {
+		return compact;
+	}
+	return `${compact.slice(0, maxLength).trimEnd()}...`;
+}
+
+function normalizePath(path: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+function getPathScope(path: string, workspaceRoot: string): ItemScope {
+	const normalizedRoot = normalizePath(workspaceRoot);
+	const normalized = normalizePath(path);
+	return normalizedRoot && normalized.startsWith(`${normalizedRoot}/`)
+		? "Project"
+		: "Global";
+}
+
+function ScopeBadge({ scope }: { scope: ItemScope }) {
+	return (
+		<Badge variant="outline" className="shrink-0 text-muted-foreground">
+			{scope}
+		</Badge>
+	);
+}
+
+function getLocalMarketplaceMatchValues(
+	...values: Array<string | undefined>
+): string[] {
+	const matchValues = new Set<string>();
+	for (const value of values) {
+		const normalized = value?.trim().replaceAll("\\", "/");
+		if (!normalized) {
+			continue;
+		}
+		matchValues.add(normalized);
+		const segments = normalized.split("/").filter(Boolean);
+		for (const segment of segments) {
+			matchValues.add(segment.replace(/\.[^.]+$/, ""));
+		}
+		for (let index = 0; index < segments.length - 1; index += 1) {
+			matchValues.add(`${segments[index]}/${segments[index + 1]}`);
+		}
+	}
+	return [...matchValues];
+}
+
+async function fetchUserInstructionLists(): Promise<UserInstructionListsResponse> {
+	const response = await desktopClient.invoke<
+		Partial<UserInstructionListsResponse>
+	>("list_user_instruction_configs");
+	return normalizeInstructionListsResponse(response);
+}
+
+function isUnsupportedDesktopCommand(error: unknown, command: string): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes(`unsupported desktop command: ${command}`);
+}
+
+export function CustomizationSectionView({
+	catalogPrimitive,
+	section = "Rules",
+	showTabs = false,
+}: {
+	catalogPrimitive?: MarketplacePrimitiveType;
+	section?: CustomizationSection;
+	showTabs?: boolean;
+}) {
+	const [activeTab, setActiveTab] = useState<CustomizationSection>(section);
+	const [isLoading, setIsLoading] = useState(
+		() => !hasFreshExtensionsListsCache(extensionListsCache, Date.now()),
+	);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [workspaceRoot, setWorkspaceRoot] = useState(
+		() => extensionListsCache?.workspaceRoot ?? "",
+	);
+	const [rules, setRules] = useState<RuleItem[]>(
+		() => extensionListsCache?.rules ?? [],
+	);
+	const [workflows, setWorkflows] = useState<WorkflowItem[]>(
+		() => extensionListsCache?.workflows ?? [],
+	);
+	const [skills, setSkills] = useState<SkillItem[]>(
+		() => extensionListsCache?.skills ?? [],
+	);
+	const [agents, setAgents] = useState<AgentItem[]>(
+		() => extensionListsCache?.agents ?? [],
+	);
+	const [plugins, setPlugins] = useState<PluginItem[]>(
+		() => extensionListsCache?.plugins ?? [],
+	);
+	const [tools, setTools] = useState<ToolItem[]>(
+		() => extensionListsCache?.tools ?? [],
+	);
+	const [hooks, setHooks] = useState<HookItem[]>(
+		() => extensionListsCache?.hooks ?? [],
+	);
+	const [mcp, setMcp] = useState<McpServersResponse>(
+		() => extensionListsCache?.mcp ?? EMPTY_MCP_RESPONSE,
+	);
+	const [warnings, setWarnings] = useState<string[]>(
+		() => extensionListsCache?.warnings ?? [],
+	);
+	const [hookExecutionByEvent, setHookExecutionByEvent] = useState<
+		Record<string, HookExecutionSummary>
+	>(() => extensionHookStatsCache?.hookExecutionByEvent ?? {});
+	const [hookExecutionSessionId, setHookExecutionSessionId] = useState<
+		string | null
+	>(() => extensionHookStatsCache?.hookExecutionSessionId ?? null);
+	const [hookExecutionLoading, setHookExecutionLoading] = useState(false);
+	const [togglingToolIds, setTogglingToolIds] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const [togglingPluginPaths, setTogglingPluginPaths] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const [localUninstallingKeys, setLocalUninstallingKeys] = useState<
+		Set<string>
+	>(() => new Set());
+	const [localActionMessages, setLocalActionMessages] = useState<
+		Map<string, { status: "success" | "failed"; message: string }>
+	>(() => new Map());
+
+	useEffect(() => {
+		setActiveTab(section);
+	}, [section]);
+
+	const refresh = useCallback(async (force = false) => {
+		const now = Date.now();
+		if (!force && hasFreshExtensionsListsCache(extensionListsCache, now)) {
+			setWorkspaceRoot(extensionListsCache.workspaceRoot);
+			setRules(extensionListsCache.rules);
+			setWorkflows(extensionListsCache.workflows);
+			setSkills(extensionListsCache.skills);
+			setAgents(extensionListsCache.agents);
+			setPlugins(extensionListsCache.plugins);
+			setTools(extensionListsCache.tools);
+			setHooks(extensionListsCache.hooks);
+			setMcp(extensionListsCache.mcp);
+			setWarnings(extensionListsCache.warnings);
+			setErrorMessage(null);
+			setIsLoading(false);
+			return;
+		}
+
+		setIsLoading(true);
+		setErrorMessage(null);
+		try {
+			const response = await fetchUserInstructionLists();
+			setWorkspaceRoot(response.workspaceRoot);
+			setRules(response.rules);
+			setWorkflows(response.workflows);
+			setSkills(response.skills);
+			setAgents(response.agents);
+			setPlugins(response.plugins);
+			setTools(response.tools);
+			setHooks(response.hooks);
+			setMcp(response.mcp);
+			setWarnings(response.warnings);
+			extensionListsCache = {
+				...response,
+				fetchedAt: Date.now(),
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsLoading(false);
+		}
+	}, []);
+
+	const loadHookExecutionStats = useCallback(async (force = false) => {
+		const now = Date.now();
+		if (
+			!force &&
+			extensionHookStatsCache &&
+			now - extensionHookStatsCache.fetchedAt <
+				EXTENSION_HOOK_STATS_CACHE_TTL_MS
+		) {
+			setHookExecutionByEvent(extensionHookStatsCache.hookExecutionByEvent);
+			setHookExecutionSessionId(extensionHookStatsCache.hookExecutionSessionId);
+			return;
+		}
+
+		setHookExecutionLoading(true);
+		try {
+			const sessions = await desktopClient.invoke<CliDiscoveredSession[]>(
+				"list_cli_sessions",
+				{
+					limit: 300,
+				},
+			);
+			const latestSession = (sessions ?? [])
+				.filter(
+					(session) =>
+						typeof session.sessionId === "string" &&
+						session.sessionId.trim().length > 0,
+				)
+				.sort((left, right) =>
+					(right.startedAt ?? "").localeCompare(left.startedAt ?? ""),
+				)[0];
+			if (!latestSession?.sessionId) {
+				setHookExecutionByEvent({});
+				setHookExecutionSessionId(null);
+				extensionHookStatsCache = {
+					hookExecutionByEvent: {},
+					hookExecutionSessionId: null,
+					fetchedAt: Date.now(),
+				};
+				return;
+			}
+
+			const events = await desktopClient.invoke<SessionHookEvent[]>(
+				"read_session_hooks",
+				{
+					sessionId: latestSession.sessionId,
+					limit: 5000,
+				},
+			);
+			const next: Record<string, HookExecutionSummary> = {};
+			for (const event of events ?? []) {
+				const hookName = event.hookEventName?.trim();
+				if (!hookName) {
+					continue;
+				}
+				const current = next[hookName] ?? {
+					count: 0,
+					lastTs: null,
+				};
+				current.count += 1;
+				if (event.ts && (!current.lastTs || event.ts > current.lastTs)) {
+					current.lastTs = event.ts;
+				}
+				next[hookName] = current;
+			}
+			setHookExecutionByEvent(next);
+			setHookExecutionSessionId(latestSession.sessionId);
+			extensionHookStatsCache = {
+				hookExecutionByEvent: next,
+				hookExecutionSessionId: latestSession.sessionId,
+				fetchedAt: Date.now(),
+			};
+		} catch {
+			// Keep existing execution status when lookup fails.
+		} finally {
+			setHookExecutionLoading(false);
+		}
+	}, []);
+
+	const applyResponse = useCallback(
+		(response: Partial<UserInstructionListsResponse>) => {
+			const normalizedResponse = normalizeInstructionListsResponse(response);
+			setWorkspaceRoot(normalizedResponse.workspaceRoot);
+			setRules(normalizedResponse.rules);
+			setWorkflows(normalizedResponse.workflows);
+			setSkills(normalizedResponse.skills);
+			setAgents(normalizedResponse.agents);
+			setPlugins(normalizedResponse.plugins);
+			setTools(normalizedResponse.tools);
+			setHooks(normalizedResponse.hooks);
+			setMcp(normalizedResponse.mcp);
+			setWarnings(normalizedResponse.warnings);
+			extensionListsCache = {
+				...normalizedResponse,
+				fetchedAt: Date.now(),
+			};
+		},
+		[],
+	);
+
+	const setToolEnabled = useCallback(
+		async (tool: ToolItem) => {
+			setTogglingToolIds((current) => new Set(current).add(tool.id));
+			setErrorMessage(null);
+			try {
+				const names = [tool.name, ...(tool.headlessToolNames ?? [])].filter(
+					Boolean,
+				);
+				if (names.length === 0) {
+					throw new Error("tool name is required");
+				}
+				let response: UserInstructionListsResponse | undefined;
+				try {
+					response = await desktopClient.invoke<UserInstructionListsResponse>(
+						"set_tool_disabled",
+						{
+							names,
+							disabled: tool.enabled,
+						},
+					);
+				} catch (error) {
+					if (!isUnsupportedDesktopCommand(error, "set_tool_disabled")) {
+						throw error;
+					}
+					for (const name of names) {
+						response = await desktopClient.invoke<UserInstructionListsResponse>(
+							"toggle_disabled_plugin_tool",
+							{ name },
+						);
+					}
+				}
+				if (!response) {
+					throw new Error(
+						"tool toggle did not return an updated extension list",
+					);
+				}
+				applyResponse(response);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setErrorMessage(message);
+			} finally {
+				setTogglingToolIds((current) => {
+					const next = new Set(current);
+					next.delete(tool.id);
+					return next;
+				});
+			}
+		},
+		[applyResponse],
+	);
+
+	const setPluginEnabled = useCallback(
+		async (plugin: PluginItem) => {
+			setTogglingPluginPaths((current) => new Set(current).add(plugin.path));
+			setErrorMessage(null);
+			try {
+				const response =
+					await desktopClient.invoke<UserInstructionListsResponse>(
+						"set_plugin_disabled",
+						{
+							path: plugin.path,
+							disabled: plugin.enabled,
+						},
+					);
+				applyResponse(response);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setErrorMessage(message);
+			} finally {
+				setTogglingPluginPaths((current) => {
+					const next = new Set(current);
+					next.delete(plugin.path);
+					return next;
+				});
+			}
+		},
+		[applyResponse],
+	);
+
+	const uninstallLocalPrimitive = useCallback(
+		async (target: LocalUninstallTarget) => {
+			if (localUninstallingKeys.has(target.key)) {
+				return;
+			}
+			setLocalUninstallingKeys((current) => new Set(current).add(target.key));
+			setLocalActionMessages((current) => {
+				const next = new Map(current);
+				next.delete(target.key);
+				return next;
+			});
+			setErrorMessage(null);
+			try {
+				const result = await desktopClient.invoke<{ message?: string }>(
+					"uninstall_local_primitive",
+					{
+						type: target.type,
+						id: target.id,
+						name: target.name,
+						path: target.path,
+					},
+				);
+				setLocalActionMessages((current) => {
+					const next = new Map(current);
+					next.set(target.key, {
+						status: "success",
+						message:
+							result.message ??
+							`Uninstalled ${target.name ?? target.id ?? target.path}.`,
+					});
+					return next;
+				});
+				await refresh(true);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setLocalActionMessages((current) => {
+					const next = new Map(current);
+					next.set(target.key, { status: "failed", message });
+					return next;
+				});
+				setErrorMessage(message);
+			} finally {
+				setLocalUninstallingKeys((current) => {
+					const next = new Set(current);
+					next.delete(target.key);
+					return next;
+				});
+			}
+		},
+		[localUninstallingKeys, refresh],
+	);
+
+	const formatExecutionTs = useCallback((value: string | null): string => {
+		if (!value) {
+			return "never";
+		}
+		const asNumber = Number(value);
+		const date = Number.isFinite(asNumber)
+			? new Date(asNumber)
+			: new Date(value);
+		if (Number.isNaN(date.getTime())) {
+			return value;
+		}
+		return date.toLocaleString();
+	}, []);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refresh(false);
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refresh]);
+
+	useEffect(() => {
+		if (activeTab !== "Hooks") {
+			return;
+		}
+		const timeoutId = window.setTimeout(() => {
+			void loadHookExecutionStats(false);
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [activeTab, loadHookExecutionStats]);
+
+	const tabs: CustomizationSection[] = [
+		"Rules",
+		"Hooks",
+		"Skills",
+		"Agents",
+		"Plugins",
+		"Tools",
+	];
+
+	const commandItems = useMemo<CommandItem[]>(() => {
+		const workflowItems: CommandItem[] = workflows.map((workflow) => ({
+			id: workflow.id,
+			type: "workflow",
+			name: workflow.name,
+			instructions: workflow.instructions,
+			path: workflow.path,
+			scope: getPathScope(workflow.path, workspaceRoot),
+		}));
+		const skillItems: CommandItem[] = skills.map((skill) => ({
+			id: normalizePath(skill.path).toLowerCase(),
+			type: "skill",
+			name: skill.name,
+			description: skill.description,
+			instructions: skill.instructions,
+			path: skill.path,
+			scope: getPathScope(skill.path, workspaceRoot),
+		}));
+		return [...workflowItems, ...skillItems].sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+	}, [skills, workflows, workspaceRoot]);
+
+	const { projectRules, globalRules } = useMemo(() => {
+		const normalizedRoot = normalizePath(workspaceRoot);
+		const project: RuleItem[] = [];
+		const global: RuleItem[] = [];
+		for (const rule of rules) {
+			const normalized = normalizePath(rule.path);
+			if (
+				normalizedRoot &&
+				normalized.startsWith(`${normalizedRoot}/`) &&
+				normalized.includes("/.clinerules/")
+			) {
+				project.push(rule);
+			} else {
+				global.push(rule);
+			}
+		}
+		return { projectRules: project, globalRules: global };
+	}, [rules, workspaceRoot]);
+
+	const { projectHooks, globalHooks } = useMemo(() => {
+		const normalizedRoot = normalizePath(workspaceRoot);
+		const project: HookItem[] = [];
+		const global: HookItem[] = [];
+		for (const hook of hooks) {
+			const normalized = normalizePath(hook.path);
+			if (
+				normalizedRoot &&
+				normalized.startsWith(`${normalizedRoot}/`) &&
+				normalized.includes("/.clinerules/hooks")
+			) {
+				project.push(hook);
+			} else {
+				global.push(hook);
+			}
+		}
+		return { projectHooks: project, globalHooks: global };
+	}, [hooks, workspaceRoot]);
+
+	const { projectPlugins, globalPlugins } = useMemo(() => {
+		const normalizedRoot = normalizePath(workspaceRoot);
+		const project: PluginItem[] = [];
+		const global: PluginItem[] = [];
+		for (const plugin of plugins) {
+			const normalized = normalizePath(plugin.path);
+			if (
+				normalizedRoot &&
+				normalized.startsWith(`${normalizedRoot}/`) &&
+				normalized.includes("/.cline/plugins")
+			) {
+				project.push(plugin);
+			} else {
+				global.push(plugin);
+			}
+		}
+		return { projectPlugins: project, globalPlugins: global };
+	}, [plugins, workspaceRoot]);
+
+	const builtinTools = useMemo(
+		() => tools.filter((tool) => tool.source === "builtin"),
+		[tools],
+	);
+	const pluginTools = useMemo(
+		() => tools.filter((tool) => tool.source !== "builtin"),
+		[tools],
+	);
+	const pluginToolsByPluginKey = useMemo(() => {
+		const grouped = new Map<string, ToolItem[]>();
+		for (const tool of pluginTools) {
+			const key = `${tool.pluginName ?? ""}:${tool.path ?? ""}`;
+			const existing = grouped.get(key) ?? [];
+			existing.push(tool);
+			grouped.set(key, existing);
+		}
+		for (const items of grouped.values()) {
+			items.sort((left, right) => left.name.localeCompare(right.name));
+		}
+		return grouped;
+	}, [pluginTools]);
+
+	const scopedPlugins = useMemo(
+		() => [
+			...globalPlugins.map((plugin) => ({
+				plugin,
+				scope: "Global" as ItemScope,
+			})),
+			...projectPlugins.map((plugin) => ({
+				plugin,
+				scope: "Project" as ItemScope,
+			})),
+		],
+		[globalPlugins, projectPlugins],
+	);
+
+	const scopedRules = useMemo(
+		() => [
+			...globalRules.map((rule) => ({ rule, scope: "Global" as ItemScope })),
+			...projectRules.map((rule) => ({ rule, scope: "Project" as ItemScope })),
+		],
+		[globalRules, projectRules],
+	);
+
+	const scopedHooks = useMemo(
+		() => [
+			...globalHooks.map((hook) => ({ hook, scope: "Global" as ItemScope })),
+			...projectHooks.map((hook) => ({ hook, scope: "Project" as ItemScope })),
+		],
+		[globalHooks, projectHooks],
+	);
+
+	const renderLocalActionMessage = (key: string) => {
+		const message = localActionMessages.get(key);
+		if (!message) {
+			return null;
+		}
+		return (
+			<output
+				className={cn(
+					"text-xs",
+					message.status === "failed"
+						? "text-destructive"
+						: "text-muted-foreground",
+				)}
+			>
+				{message.message}
+			</output>
+		);
+	};
+
+	const renderLocalActionRow = (target: LocalUninstallTarget) => {
+		const uninstalling = localUninstallingKeys.has(target.key);
+		return (
+			<div className="flex flex-wrap items-center justify-between gap-3">
+				<div className="min-h-5 text-xs text-muted-foreground">
+					{renderLocalActionMessage(target.key)}
+				</div>
+				<Button
+					disabled={uninstalling}
+					onClick={() => {
+						void uninstallLocalPrimitive(target);
+					}}
+					type="button"
+					variant="destructive"
+				>
+					{uninstalling ? <Spinner /> : <Trash2 className="size-4" />}
+					{uninstalling ? "Uninstalling..." : "Uninstall"}
+				</Button>
+			</div>
+		);
+	};
+
+	const renderSkillCard = (item: CommandItem) => {
+		const key = `${item.type}:${item.path}`;
+		return (
+			<div key={key} className="rounded-lg border border-border px-5 py-4">
+				<div className="flex items-center gap-3">
+					{item.type === "workflow" ? (
+						<Play className="h-4 w-4 shrink-0 text-primary" />
+					) : (
+						<Zap className="h-4 w-4 shrink-0 text-primary" />
+					)}
+					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+						{item.name}
+					</h3>
+					<ScopeBadge scope={item.scope} />
+					<Badge variant="outline" className="shrink-0 text-muted-foreground">
+						{item.type}
+					</Badge>
+				</div>
+				<p className="mt-2 ml-7 text-xs text-muted-foreground">
+					{item.description?.trim() || previewText(item.instructions)}
+				</p>
+				<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+					{item.path}
+				</p>
+				<div className="mt-3">
+					{renderLocalActionRow({
+						key,
+						type: item.type,
+						id: item.id,
+						name: item.name,
+						path: item.path,
+					})}
+				</div>
+			</div>
+		);
+	};
+
+	const renderSkillMatchedDetails = (item: CommandItem) => (
+		<div className="grid gap-1">
+			<p className="text-xs text-muted-foreground">
+				{item.description?.trim() || previewText(item.instructions)}
+			</p>
+			<p className="text-xs font-mono text-muted-foreground">{item.path}</p>
+		</div>
+	);
+
+	const renderPluginCard = ({
+		plugin,
+		scope,
+	}: {
+		plugin: PluginItem;
+		scope: ItemScope;
+	}) => {
+		const key = plugin.path;
+		return (
+			<div
+				key={plugin.path}
+				className="rounded-lg border border-border px-5 py-4"
+			>
+				<div className="flex items-center gap-3">
+					<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+						{plugin.name}
+					</h3>
+					<ScopeBadge scope={scope} />
+					<span className="text-xs text-muted-foreground">
+						{plugin.enabled ? "Enabled" : "Disabled"}
+					</span>
+					<Switch
+						checked={plugin.enabled}
+						onCheckedChange={() => {
+							void setPluginEnabled(plugin);
+						}}
+						disabled={togglingPluginPaths.has(plugin.path)}
+						aria-label={`Toggle ${plugin.name}`}
+					/>
+				</div>
+				<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+					{plugin.path}
+				</p>
+				<div className="mt-3 ml-7 flex flex-col gap-2">
+					{(
+						pluginToolsByPluginKey.get(`${plugin.name}:${plugin.path}`) ?? []
+					).map((tool) => {
+						const isToggling = togglingToolIds.has(tool.id);
+						return (
+							<div
+								key={tool.id}
+								className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+							>
+								<div className="min-w-0">
+									<p className="text-xs font-medium text-foreground">
+										{tool.name}
+									</p>
+									<p className="text-xs text-muted-foreground">
+										{tool.description?.trim() || "No description available."}
+									</p>
+								</div>
+								<div className="flex items-center gap-2">
+									<span className="text-xs text-muted-foreground">
+										{tool.enabled ? "Enabled" : "Disabled"}
+									</span>
+									<Switch
+										checked={tool.enabled}
+										onCheckedChange={() => {
+											void setToolEnabled(tool);
+										}}
+										disabled={isToggling || !plugin.enabled}
+										aria-label={`Toggle ${tool.name}`}
+									/>
+								</div>
+							</div>
+						);
+					})}
+					{(pluginToolsByPluginKey.get(`${plugin.name}:${plugin.path}`)
+						?.length ?? 0) === 0 && (
+						<p className="text-xs text-muted-foreground">
+							No plugin tools found.
+						</p>
+					)}
+				</div>
+				<div className="mt-3">
+					{renderLocalActionRow({
+						key,
+						type: "plugin",
+						id: plugin.name,
+						name: plugin.name,
+						path: plugin.path,
+					})}
+				</div>
+			</div>
+		);
+	};
+
+	const renderPluginMatchedControls = (plugin: PluginItem) => (
+		<>
+			<span className="text-xs text-muted-foreground">
+				{plugin.enabled ? "Enabled" : "Disabled"}
+			</span>
+			<Switch
+				checked={plugin.enabled}
+				onCheckedChange={() => {
+					void setPluginEnabled(plugin);
+				}}
+				disabled={togglingPluginPaths.has(plugin.path)}
+				aria-label={`Toggle ${plugin.name}`}
+			/>
+		</>
+	);
+
+	const renderPluginMatchedMeta = (plugin: PluginItem) => (
+		<p className="min-w-0 truncate text-xs font-mono text-muted-foreground">
+			{plugin.path}
+		</p>
+	);
+
+	const renderPluginMatchedDetails = (plugin: PluginItem) => {
+		const pluginTools =
+			pluginToolsByPluginKey.get(`${plugin.name}:${plugin.path}`) ?? [];
+		if (pluginTools.length === 0) {
+			return null;
+		}
+		return (
+			<div className="grid gap-2">
+				{pluginTools.map((tool) => {
+					const isToggling = togglingToolIds.has(tool.id);
+					return (
+						<div
+							key={tool.id}
+							className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+						>
+							<div className="min-w-0">
+								<p className="text-xs font-medium text-foreground">
+									{tool.name}
+								</p>
+								<p className="text-xs text-muted-foreground">
+									{tool.description?.trim() || "No description available."}
+								</p>
+							</div>
+							<div className="flex items-center gap-2">
+								<span className="text-xs text-muted-foreground">
+									{tool.enabled ? "Enabled" : "Disabled"}
+								</span>
+								<Switch
+									checked={tool.enabled}
+									onCheckedChange={() => {
+										void setToolEnabled(tool);
+									}}
+									disabled={isToggling || !plugin.enabled}
+									aria-label={`Toggle ${tool.name}`}
+								/>
+							</div>
+						</div>
+					);
+				})}
+			</div>
+		);
+	};
+
+	const renderMcpServerCard = (server: McpServer) => {
+		const key = server.name;
+		return (
+			<div
+				key={server.name}
+				className="rounded-lg border border-border px-5 py-4"
+			>
+				<div className="flex items-center gap-3">
+					<Server className="h-4 w-4 shrink-0 text-primary" />
+					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+						{server.name}
+					</h3>
+					<ScopeBadge scope="Global" />
+					<Badge variant="outline" className="shrink-0 text-muted-foreground">
+						{server.transportType}
+					</Badge>
+					<span className="text-xs text-muted-foreground">
+						{server.disabled ? "Disabled" : "Enabled"}
+					</span>
+				</div>
+				<p className="mt-2 ml-7 text-xs text-muted-foreground">
+					{server.url ??
+						([server.command, ...(server.args ?? [])]
+							.filter(Boolean)
+							.join(" ") ||
+							"No launch command configured.")}
+				</p>
+				{mcp.settingsPath ? (
+					<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+						{mcp.settingsPath}
+					</p>
+				) : null}
+				<div className="mt-3">
+					{renderLocalActionRow({
+						key,
+						type: "mcp",
+						id: server.name,
+						name: server.name,
+					})}
+				</div>
+			</div>
+		);
+	};
+
+	const renderMcpMatchedDetails = (server: McpServer) => (
+		<div className="grid gap-1">
+			<p className="text-xs text-muted-foreground">
+				{server.disabled ? "Disabled" : "Enabled"} locally
+				{server.transportType ? ` via ${server.transportType}` : ""}
+			</p>
+			{mcp.settingsPath ? (
+				<p className="text-xs font-mono text-muted-foreground">
+					{mcp.settingsPath}
+				</p>
+			) : null}
+		</div>
+	);
+
+	const installedCatalogLocalItems =
+		catalogPrimitive === "skill"
+			? commandItems.map(
+					(item): MarketplaceLocalInstalledItem => ({
+						key: `${item.type}:${item.path}`,
+						matchValues: getLocalMarketplaceMatchValues(
+							item.id,
+							item.name,
+							item.path,
+						),
+						render: () => renderSkillCard(item),
+						renderMatchedBadges: () => (
+							<>
+								<ScopeBadge scope={item.scope} />
+								<Badge
+									variant="outline"
+									className="shrink-0 text-muted-foreground"
+								>
+									{item.type}
+								</Badge>
+							</>
+						),
+						renderMatchedDetails: () => renderSkillMatchedDetails(item),
+					}),
+				)
+			: catalogPrimitive === "plugin"
+				? scopedPlugins.map(
+						(item): MarketplaceLocalInstalledItem => ({
+							key: item.plugin.path,
+							matchValues: getLocalMarketplaceMatchValues(
+								item.plugin.name,
+								item.plugin.path,
+							),
+							render: () => renderPluginCard(item),
+							renderMatchedBadges: () => <ScopeBadge scope={item.scope} />,
+							renderMatchedControls: () =>
+								renderPluginMatchedControls(item.plugin),
+							renderMatchedDetails:
+								(
+									pluginToolsByPluginKey.get(
+										`${item.plugin.name}:${item.plugin.path}`,
+									) ?? []
+								).length > 0
+									? () => renderPluginMatchedDetails(item.plugin)
+									: undefined,
+							renderMatchedMeta: () => renderPluginMatchedMeta(item.plugin),
+						}),
+					)
+				: catalogPrimitive === "mcp"
+					? mcp.servers.map(
+							(server): MarketplaceLocalInstalledItem => ({
+								key: server.name,
+								matchValues: getLocalMarketplaceMatchValues(server.name),
+								render: () => renderMcpServerCard(server),
+								renderMatchedBadges: () => (
+									<>
+										<ScopeBadge scope="Global" />
+										<Badge
+											variant="outline"
+											className="shrink-0 text-muted-foreground"
+										>
+											{server.transportType}
+										</Badge>
+									</>
+								),
+								renderMatchedDetails: () => renderMcpMatchedDetails(server),
+							}),
+						)
+					: null;
+	return (
+		<PageFrame>
+			<PageHeader
+				description={sectionDescriptions[activeTab]}
+				title={activeTab}
+				meta={<CommandBadge>{sectionCommands[activeTab]}</CommandBadge>}
+				actions={
+					<Button
+						variant="outline"
+						size="sm"
+						onClick={() => {
+							void refresh(true);
+							if (activeTab === "Hooks") {
+								void loadHookExecutionStats(true);
+							}
+						}}
+						disabled={isLoading}
+					>
+						<RefreshCw className={cn("h-4 w-4", isLoading && "animate-spin")} />
+					</Button>
+				}
+			/>
+
+			{showTabs ? (
+				<div className="mb-6 flex items-center gap-0 border-b border-border">
+					{tabs.map((tab) => (
+						<Button
+							key={tab}
+							variant="ghost"
+							onClick={() => setActiveTab(tab)}
+							className={cn(
+								"relative px-4 py-2.5 text-sm font-medium transition-colors",
+								activeTab === tab
+									? "text-foreground"
+									: "text-muted-foreground hover:text-foreground",
+							)}
+						>
+							{tab}
+							{activeTab === tab && (
+								<span className="absolute inset-x-0 -bottom-px h-0.5 bg-foreground" />
+							)}
+						</Button>
+					))}
+				</div>
+			) : null}
+
+			{errorMessage && (
+				<div className="mb-4 rounded-lg border border-destructive/40 bg-destructive/10 px-4 py-3 text-sm text-destructive">
+					Failed to load configuration lists: {errorMessage}
+				</div>
+			)}
+
+			{warnings.length > 0 && (
+				<div className="mb-4 rounded-lg border border-yellow-500/40 bg-yellow-500/10 px-4 py-3 text-sm text-yellow-700 dark:text-yellow-300">
+					<div className="mb-2 flex items-center gap-2 font-medium">
+						<TriangleAlert className="h-4 w-4" />
+						Partial results
+					</div>
+					<ul className="list-disc space-y-1 pl-5">
+						{warnings.map((warning) => (
+							<li key={warning}>{warning}</li>
+						))}
+					</ul>
+				</div>
+			)}
+
+			{catalogPrimitive ? (
+				<MarketplaceView
+					chrome="embedded"
+					installedItems={installedCatalogLocalItems ?? undefined}
+					onInstalledItemsChanged={() => refresh(true)}
+					primitive={catalogPrimitive}
+				/>
+			) : null}
+
+			{activeTab === "Rules" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Enabled rules discovered from configured workspace/global
+						directories.
+					</p>
+
+					<div className="grid gap-3">
+						<div className="flex items-center justify-between gap-3">
+							<h3 className="text-base font-semibold text-foreground">
+								Installed
+							</h3>
+							<span className="text-sm text-muted-foreground">
+								{scopedRules.length}
+							</span>
+						</div>
+						<div className="flex flex-col gap-2">
+							{scopedRules.map(({ rule, scope }) => (
+								<div
+									key={rule.path}
+									className="rounded-lg border border-border px-4 py-3"
+								>
+									<div className="flex items-center gap-3">
+										<FileText className="h-4 w-4 shrink-0 text-muted-foreground" />
+										<span className="flex-1 text-sm font-medium text-foreground">
+											{rule.name}
+										</span>
+										<ScopeBadge scope={scope} />
+									</div>
+									<p className="mt-2 text-xs text-muted-foreground">
+										{previewText(rule.instructions)}
+									</p>
+									<p className="mt-1 text-xs font-mono text-muted-foreground">
+										{rule.path}
+									</p>
+								</div>
+							))}
+							{scopedRules.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No rules found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Hooks" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Hook config files from workspace and global hook directories.
+					</p>
+					{hookExecutionLoading && hookExecutionSessionId && (
+						<p className="mb-4 text-xs text-muted-foreground">
+							Execution status is based on hook events in session{" "}
+							<span className="font-mono">{hookExecutionSessionId}</span>.
+						</p>
+					)}
+
+					<div className="grid gap-3">
+						<div className="flex items-center justify-between gap-3">
+							<h3 className="text-base font-semibold text-foreground">
+								Installed
+							</h3>
+							<span className="text-sm text-muted-foreground">
+								{scopedHooks.length}
+							</span>
+						</div>
+						<div className="flex flex-col gap-2">
+							{scopedHooks.map(({ hook, scope }) => (
+								<div
+									key={hook.path}
+									className="rounded-lg border border-border px-4 py-3"
+								>
+									<div className="flex items-center gap-3">
+										<Code className="h-4 w-4 shrink-0 text-muted-foreground" />
+										<span className="flex-1 text-sm font-mono text-foreground">
+											{hook.fileName}
+										</span>
+										<ScopeBadge scope={scope} />
+										{hook.hookEventName && (
+											<div className="flex items-center gap-2">
+												<span className="rounded border border-border px-2 py-0.5 text-xs text-muted-foreground">
+													{hook.hookEventName}
+												</span>
+												{(() => {
+													const stats =
+														hookExecutionByEvent[hook.hookEventName];
+													const executed = (stats?.count ?? 0) > 0;
+													return (
+														<span
+															className={cn(
+																"rounded border px-2 py-0.5 text-xs",
+																executed
+																	? "border-emerald-400/50 text-emerald-600 dark:text-emerald-400"
+																	: "border-border text-muted-foreground",
+															)}
+														>
+															{executed
+																? `${stats?.count ?? 0} executed`
+																: "never executed"}
+														</span>
+													);
+												})()}
+											</div>
+										)}
+									</div>
+									{hook.hookEventName ? (
+										<p className="mt-1 text-xs text-muted-foreground">
+											Last run:{" "}
+											{formatExecutionTs(
+												hookExecutionByEvent[hook.hookEventName]?.lastTs ??
+													null,
+											)}
+										</p>
+									) : null}
+									<p className="mt-1 text-xs font-mono text-muted-foreground">
+										{hook.path}
+									</p>
+								</div>
+							))}
+							{scopedHooks.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No hooks found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Skills" && !catalogPrimitive && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Skills can be invoked in chat with{" "}
+						<code className="rounded bg-secondary px-1.5 py-0.5 text-xs font-mono text-foreground">
+							/SKILL
+						</code>
+						.
+					</p>
+
+					<div className="flex flex-col gap-3">
+						{commandItems.map((item) => (
+							<div
+								key={`${item.type}:${item.path}`}
+								className="rounded-lg border border-border px-5 py-4"
+							>
+								<div className="flex items-center gap-3">
+									{item.type === "workflow" ? (
+										<Play className="h-4 w-4 shrink-0 text-primary" />
+									) : (
+										<Zap className="h-4 w-4 shrink-0 text-primary" />
+									)}
+									<h3 className="text-sm font-semibold text-foreground">
+										{item.name}
+									</h3>
+									<span className="rounded border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{item.type}
+									</span>
+								</div>
+								<p className="mt-2 ml-7 text-xs text-muted-foreground">
+									{item.description?.trim() || previewText(item.instructions)}
+								</p>
+								<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+									{item.path}
+								</p>
+							</div>
+						))}
+						{commandItems.length === 0 && (
+							<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+								No enabled skills or workflows found.
+							</p>
+						)}
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Agents" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Configured agents discovered from Documents and settings
+						directories.
+					</p>
+
+					<div className="flex flex-col gap-3">
+						{agents.map((agent) => (
+							<div
+								key={agent.path}
+								className="rounded-lg border border-border px-5 py-4"
+							>
+								<div className="flex items-center gap-3">
+									<Bot className="h-4 w-4 shrink-0 text-primary" />
+									<h3 className="text-sm font-semibold text-foreground">
+										{agent.name}
+									</h3>
+								</div>
+								<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+									{agent.path}
+								</p>
+							</div>
+						))}
+						{agents.length === 0 && (
+							<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+								No configured agents found.
+							</p>
+						)}
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Plugins" && !catalogPrimitive && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Plugins discovered from workspace and global plugin directories.
+					</p>
+
+					<div className="mb-6">
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Global Plugins
+						</h3>
+						<div className="flex flex-col gap-3">
+							{globalPlugins.map((plugin) => (
+								<div
+									key={plugin.path}
+									className="rounded-lg border border-border px-5 py-4"
+								>
+									<div className="flex items-center gap-3">
+										<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+										<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+											{plugin.name}
+										</h3>
+										<span className="text-xs text-muted-foreground">
+											{plugin.enabled ? "Enabled" : "Disabled"}
+										</span>
+										<Switch
+											checked={plugin.enabled}
+											onCheckedChange={() => {
+												void setPluginEnabled(plugin);
+											}}
+											disabled={togglingPluginPaths.has(plugin.path)}
+											aria-label={`Toggle ${plugin.name}`}
+										/>
+									</div>
+									<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+										{plugin.path}
+									</p>
+									<div className="mt-3 ml-7 flex flex-col gap-2">
+										{(
+											pluginToolsByPluginKey.get(
+												`${plugin.name}:${plugin.path}`,
+											) ?? []
+										).map((tool) => {
+											const isToggling = togglingToolIds.has(tool.id);
+											return (
+												<div
+													key={tool.id}
+													className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+												>
+													<div className="min-w-0">
+														<p className="text-xs font-medium text-foreground">
+															{tool.name}
+														</p>
+														<p className="text-xs text-muted-foreground">
+															{tool.description?.trim() ||
+																"No description available."}
+														</p>
+													</div>
+													<div className="flex items-center gap-2">
+														<span className="text-xs text-muted-foreground">
+															{tool.enabled ? "Enabled" : "Disabled"}
+														</span>
+														<Switch
+															checked={tool.enabled}
+															onCheckedChange={() => {
+																void setToolEnabled(tool);
+															}}
+															disabled={isToggling || !plugin.enabled}
+															aria-label={`Toggle ${tool.name}`}
+														/>
+													</div>
+												</div>
+											);
+										})}
+										{(pluginToolsByPluginKey.get(
+											`${plugin.name}:${plugin.path}`,
+										)?.length ?? 0) === 0 && (
+											<p className="text-xs text-muted-foreground">
+												No plugin tools found.
+											</p>
+										)}
+									</div>
+								</div>
+							))}
+							{globalPlugins.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No global plugins found.
+								</p>
+							)}
+						</div>
+					</div>
+
+					<div>
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Project Plugins
+						</h3>
+						<div className="flex flex-col gap-3">
+							{projectPlugins.map((plugin) => (
+								<div
+									key={plugin.path}
+									className="rounded-lg border border-border px-5 py-4"
+								>
+									<div className="flex items-center gap-3">
+										<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+										<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+											{plugin.name}
+										</h3>
+										<span className="text-xs text-muted-foreground">
+											{plugin.enabled ? "Enabled" : "Disabled"}
+										</span>
+										<Switch
+											checked={plugin.enabled}
+											onCheckedChange={() => {
+												void setPluginEnabled(plugin);
+											}}
+											disabled={togglingPluginPaths.has(plugin.path)}
+											aria-label={`Toggle ${plugin.name}`}
+										/>
+									</div>
+									<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+										{plugin.path}
+									</p>
+									<div className="mt-3 ml-7 flex flex-col gap-2">
+										{(
+											pluginToolsByPluginKey.get(
+												`${plugin.name}:${plugin.path}`,
+											) ?? []
+										).map((tool) => {
+											const isToggling = togglingToolIds.has(tool.id);
+											return (
+												<div
+													key={tool.id}
+													className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
+												>
+													<div className="min-w-0">
+														<p className="text-xs font-medium text-foreground">
+															{tool.name}
+														</p>
+														<p className="text-xs text-muted-foreground">
+															{tool.description?.trim() ||
+																"No description available."}
+														</p>
+													</div>
+													<div className="flex items-center gap-2">
+														<span className="text-xs text-muted-foreground">
+															{tool.enabled ? "Enabled" : "Disabled"}
+														</span>
+														<Switch
+															checked={tool.enabled}
+															onCheckedChange={() => {
+																void setToolEnabled(tool);
+															}}
+															disabled={isToggling || !plugin.enabled}
+															aria-label={`Toggle ${tool.name}`}
+														/>
+													</div>
+												</div>
+											);
+										})}
+										{(pluginToolsByPluginKey.get(
+											`${plugin.name}:${plugin.path}`,
+										)?.length ?? 0) === 0 && (
+											<p className="text-xs text-muted-foreground">
+												No plugin tools found.
+											</p>
+										)}
+									</div>
+								</div>
+							))}
+							{projectPlugins.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No project plugins found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+
+			{activeTab === "Tools" && (
+				<div>
+					<p className="mb-6 text-sm leading-relaxed text-muted-foreground">
+						Builtin tool groups and plugin-contributed tools available to the
+						runtime.
+					</p>
+
+					<div className="mb-6">
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Builtin Tools
+						</h3>
+						<div className="flex flex-col gap-3">
+							{builtinTools.map((tool) =>
+								(() => {
+									const isToggling = togglingToolIds.has(tool.id);
+									return (
+										<div
+											key={tool.id}
+											className="rounded-lg border border-border px-5 py-4"
+										>
+											<div className="flex items-center gap-3">
+												<Wrench className="h-4 w-4 shrink-0 text-primary" />
+												<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+													{tool.name}
+												</h3>
+												<span className="text-xs text-muted-foreground">
+													{tool.enabled ? "Enabled" : "Disabled"}
+												</span>
+												<Switch
+													checked={tool.enabled}
+													onCheckedChange={() => {
+														void setToolEnabled(tool);
+													}}
+													disabled={isToggling}
+													aria-label={`Toggle ${tool.name}`}
+												/>
+											</div>
+											<p className="mt-2 ml-7 text-xs text-muted-foreground">
+												{tool.description?.trim() ||
+													"No description available."}
+											</p>
+											{!!tool.headlessToolNames?.length && (
+												<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+													{tool.headlessToolNames.join(", ")}
+												</p>
+											)}
+										</div>
+									);
+								})(),
+							)}
+							{builtinTools.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No builtin tools found.
+								</p>
+							)}
+						</div>
+					</div>
+
+					<div>
+						<h3 className="mb-3 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+							Plugin Tools
+						</h3>
+						<div className="flex flex-col gap-3">
+							{pluginTools.map((tool) =>
+								(() => {
+									const isToggling = togglingToolIds.has(tool.id);
+									return (
+										<div
+											key={tool.id}
+											className="rounded-lg border border-border px-5 py-4"
+										>
+											<div className="flex items-center gap-3">
+												<Wrench className="h-4 w-4 shrink-0 text-primary" />
+												<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
+													{tool.name}
+												</h3>
+												{tool.pluginName && (
+													<span className="rounded border border-border px-2 py-0.5 text-xs text-muted-foreground">
+														plugin: {tool.pluginName}
+													</span>
+												)}
+												<span className="text-xs text-muted-foreground">
+													{tool.enabled ? "Enabled" : "Disabled"}
+												</span>
+												<Switch
+													checked={tool.enabled}
+													onCheckedChange={() => {
+														void setToolEnabled(tool);
+													}}
+													disabled={isToggling}
+													aria-label={`Toggle ${tool.name}`}
+												/>
+											</div>
+											<p className="mt-2 ml-7 text-xs text-muted-foreground">
+												{tool.description?.trim() ||
+													"No description available."}
+											</p>
+											{tool.path && (
+												<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
+													{tool.path}
+												</p>
+											)}
+										</div>
+									);
+								})(),
+							)}
+							{pluginTools.length === 0 && (
+								<p className="rounded-lg border border-dashed border-border px-4 py-3 text-sm text-muted-foreground">
+									No plugin tools found.
+								</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+		</PageFrame>
+	);
+}
+
+export function RulesView() {
+	return <CustomizationSectionView showTabs />;
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/mcp-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/mcp-view.tsx
new file mode 100644
index 0000000..62968d4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/mcp-view.tsx
@@ -0,0 +1,853 @@
+"use client";
+
+import { Circle, Minus, Pencil, Plus, RefreshCw, Trash2 } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { desktopClient } from "@/lib/desktop-client";
+import { cn } from "@/lib/utils";
+import { CommandBadge, PageFrame, PageHeader } from "../page-layout";
+
+type McpTransportType = "stdio" | "sse" | "streamableHttp";
+
+interface McpServer {
+	name: string;
+	transportType: McpTransportType;
+	disabled: boolean;
+	command?: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	metadata?: unknown;
+}
+
+interface McpServersResponse {
+	settingsPath: string;
+	hasSettingsFile: boolean;
+	servers: McpServer[];
+}
+
+interface McpServerUpsertInput {
+	name: string;
+	previousName?: string;
+	transportType: McpTransportType;
+	command?: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	disabled?: boolean;
+	metadata?: unknown;
+}
+
+type McpServerFormState = {
+	name: string;
+	previousName: string;
+	transportType: McpTransportType;
+	command: string;
+	argsText: string;
+	cwd: string;
+	envEntries: Array<{ id: string; key: string; value: string }>;
+	url: string;
+	headersText: string;
+	disabled: boolean;
+	metadataText: string;
+};
+
+function splitCsv(text: string): string[] {
+	return text
+		.split(",")
+		.map((value) => value.trim())
+		.filter((value) => value.length > 0);
+}
+
+function parseKeyValuePairs(text: string): Record<string, string> | undefined {
+	const pairs = splitCsv(text);
+	if (pairs.length === 0) {
+		return undefined;
+	}
+	const out: Record<string, string> = {};
+	for (const pair of pairs) {
+		const idx = pair.indexOf("=");
+		if (idx <= 0) {
+			continue;
+		}
+		const key = pair.slice(0, idx).trim();
+		const value = pair.slice(idx + 1).trim();
+		if (!key) {
+			continue;
+		}
+		out[key] = value;
+	}
+	return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function stringifyKeyValuePairs(input?: Record<string, string>): string {
+	if (!input) {
+		return "";
+	}
+	return Object.entries(input)
+		.map(([key, value]) => `${key}=${value}`)
+		.join(", ");
+}
+
+function stringifyRedactedKeyValuePairs(
+	input?: Record<string, string>,
+): string {
+	if (!input) {
+		return "";
+	}
+	return Object.keys(input)
+		.map((key) => `${key}=[REDACTED]`)
+		.join(", ");
+}
+
+function createEnvEntries(
+	input?: Record<string, string>,
+): Array<{ id: string; key: string; value: string }> {
+	if (!input || Object.keys(input).length === 0) {
+		return [{ id: crypto.randomUUID(), key: "", value: "" }];
+	}
+	return Object.entries(input).map(([key, value]) => ({
+		id: crypto.randomUUID(),
+		key,
+		value,
+	}));
+}
+
+function createServerFormState(existing?: McpServer): McpServerFormState {
+	return {
+		name: existing?.name ?? "",
+		previousName: existing?.name ?? "",
+		transportType: existing?.transportType ?? "stdio",
+		command: existing?.command ?? "",
+		argsText: existing?.args?.join(", ") ?? "",
+		cwd: existing?.cwd ?? "",
+		envEntries: createEnvEntries(existing?.env),
+		url: existing?.url ?? "",
+		headersText: stringifyKeyValuePairs(existing?.headers),
+		disabled: existing?.disabled ?? false,
+		metadataText:
+			existing?.metadata === undefined
+				? ""
+				: JSON.stringify(existing.metadata, null, 2),
+	};
+}
+
+export function McpServersContent() {
+	const [servers, setServers] = useState<McpServer[]>([]);
+	const [settingsPath, setSettingsPath] = useState("");
+	const [hasSettingsFile, setHasSettingsFile] = useState(false);
+	const [isLoading, setIsLoading] = useState(true);
+	const [isOpeningSettingsFile, setIsOpeningSettingsFile] = useState(false);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [busyServerName, setBusyServerName] = useState<string | null>(null);
+	const [editorOpen, setEditorOpen] = useState(false);
+	const [editorMode, setEditorMode] = useState<"create" | "edit">("create");
+	const [formState, setFormState] = useState<McpServerFormState>(() =>
+		createServerFormState(),
+	);
+	const [formErrorMessage, setFormErrorMessage] = useState<string | null>(null);
+	const [deleteTarget, setDeleteTarget] = useState<McpServer | null>(null);
+
+	const applyResponse = useCallback((response: McpServersResponse) => {
+		setServers(response.servers);
+		setSettingsPath(response.settingsPath);
+		setHasSettingsFile(response.hasSettingsFile);
+	}, []);
+
+	const refreshServers = useCallback(async () => {
+		setIsLoading(true);
+		setErrorMessage(null);
+		try {
+			const response =
+				await desktopClient.invoke<McpServersResponse>("list_mcp_servers");
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsLoading(false);
+		}
+	}, [applyResponse]);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refreshServers();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refreshServers]);
+
+	const toggleServer = async (server: McpServer, disabled: boolean) => {
+		setBusyServerName(server.name);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<McpServersResponse>(
+				"set_mcp_server_disabled",
+				{
+					name: server.name,
+					disabled,
+				},
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyServerName(null);
+		}
+	};
+
+	const upsertServer = async (input: McpServerUpsertInput) => {
+		setBusyServerName(input.previousName ?? input.name);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<McpServersResponse>(
+				"upsert_mcp_server",
+				{
+					input,
+				},
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+			throw error;
+		} finally {
+			setBusyServerName(null);
+		}
+	};
+
+	const deleteServer = async (serverName: string) => {
+		setBusyServerName(serverName);
+		setErrorMessage(null);
+		try {
+			const response = await desktopClient.invoke<McpServersResponse>(
+				"delete_mcp_server",
+				{
+					name: serverName,
+				},
+			);
+			applyResponse(response);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyServerName(null);
+		}
+	};
+
+	const buildServerInput = useCallback((form: McpServerFormState) => {
+		const name = form.name.trim();
+		if (!name) {
+			throw new Error("Server name is required.");
+		}
+		const env = form.envEntries.reduce<Record<string, string>>((acc, entry) => {
+			const key = entry.key.trim();
+			if (!key) {
+				return acc;
+			}
+			acc[key] = entry.value;
+			return acc;
+		}, {});
+		const metadataText = form.metadataText.trim();
+		const metadata =
+			metadataText.length > 0 ? JSON.parse(metadataText) : undefined;
+		if (form.transportType === "stdio") {
+			const command = form.command.trim();
+			if (!command) {
+				throw new Error("Command is required for stdio transport.");
+			}
+			const args = splitCsv(form.argsText);
+			return {
+				name,
+				previousName: form.previousName.trim() || undefined,
+				transportType: form.transportType,
+				command,
+				args: args.length > 0 ? args : undefined,
+				cwd: form.cwd.trim() || undefined,
+				env: Object.keys(env).length > 0 ? env : undefined,
+				disabled: form.disabled,
+				metadata,
+			} satisfies McpServerUpsertInput;
+		}
+		const url = form.url.trim();
+		if (!url) {
+			throw new Error("URL is required for sse and streamableHttp transport.");
+		}
+		return {
+			name,
+			previousName: form.previousName.trim() || undefined,
+			transportType: form.transportType,
+			url,
+			headers: parseKeyValuePairs(form.headersText),
+			disabled: form.disabled,
+			metadata,
+		} satisfies McpServerUpsertInput;
+	}, []);
+
+	const openCreateDialog = () => {
+		setEditorMode("create");
+		setFormState(createServerFormState());
+		setFormErrorMessage(null);
+		setEditorOpen(true);
+	};
+
+	const openEditDialog = (server: McpServer) => {
+		setEditorMode("edit");
+		setFormState(createServerFormState(server));
+		setFormErrorMessage(null);
+		setEditorOpen(true);
+	};
+
+	const handleSaveServer = async () => {
+		setFormErrorMessage(null);
+		try {
+			const input = buildServerInput(formState);
+			await upsertServer(input);
+			setEditorOpen(false);
+		} catch (error) {
+			setFormErrorMessage(
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	};
+
+	const openSettingsFile = async () => {
+		setIsOpeningSettingsFile(true);
+		setErrorMessage(null);
+		try {
+			const openedPath = await desktopClient.invoke<string>(
+				"open_mcp_settings_file",
+			);
+			if (openedPath.trim().length > 0) {
+				setSettingsPath(openedPath);
+				setHasSettingsFile(true);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setIsOpeningSettingsFile(false);
+		}
+	};
+
+	const sortedServers = useMemo(
+		() =>
+			[...servers].sort((a, b) =>
+				a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+			),
+		[servers],
+	);
+
+	const updateEnvEntry = (
+		id: string,
+		field: "key" | "value",
+		value: string,
+	) => {
+		setFormState((current) => ({
+			...current,
+			envEntries: current.envEntries.map((entry) =>
+				entry.id === id ? { ...entry, [field]: value } : entry,
+			),
+		}));
+	};
+
+	const addEnvEntry = () => {
+		setFormState((current) => ({
+			...current,
+			envEntries: [
+				...current.envEntries,
+				{ id: crypto.randomUUID(), key: "", value: "" },
+			],
+		}));
+	};
+
+	const removeEnvEntry = (id: string) => {
+		setFormState((current) => ({
+			...current,
+			envEntries:
+				current.envEntries.length === 1
+					? [{ id: crypto.randomUUID(), key: "", value: "" }]
+					: current.envEntries.filter((entry) => entry.id !== id),
+		}));
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description={
+					hasSettingsFile
+						? "Editing this list updates cline_mcp_settings.json."
+						: "No MCP settings file found yet. Add a server to create it."
+				}
+				title="MCP Servers"
+				meta={
+					<>
+						<CommandBadge>cline config mcp</CommandBadge>
+						<span className="rounded-md border border-border bg-background px-2 py-0.5 text-xs text-muted-foreground">
+							From settings file
+						</span>
+					</>
+				}
+				actions={
+					<>
+						<Button
+							variant="outline"
+							size="sm"
+							onClick={() => void refreshServers()}
+							disabled={isLoading}
+						>
+							<RefreshCw
+								className={cn("h-4 w-4", isLoading && "animate-spin")}
+							/>
+						</Button>
+						<Button size="sm" onClick={openCreateDialog}>
+							<Plus className="h-4 w-4" />
+							Add MCP Server
+						</Button>
+					</>
+				}
+			/>
+
+			<div className="mb-1 flex flex-wrap items-center gap-2 text-sm text-muted-foreground">
+				<span>MCP settings path:</span>
+				<Button
+					variant="link"
+					className="h-auto p-0 font-mono text-xs"
+					onClick={() => void openSettingsFile()}
+					disabled={isOpeningSettingsFile}
+				>
+					{settingsPath || "Open settings file"}
+				</Button>
+			</div>
+			{errorMessage && (
+				<div className="mb-4 rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			)}
+
+			{isLoading ? (
+				<div className="rounded-lg border border-border px-5 py-4 text-sm text-muted-foreground">
+					Loading MCP servers...
+				</div>
+			) : sortedServers.length === 0 ? (
+				<div className="rounded-lg border border-border px-5 py-4 text-sm text-muted-foreground">
+					No MCP servers configured.
+				</div>
+			) : (
+				<div className="flex flex-col gap-3">
+					{sortedServers.map((server) => {
+						const isBusy = busyServerName === server.name;
+						return (
+							<div
+								key={server.name}
+								className="rounded-lg border border-border px-5 py-4 transition-colors hover:bg-accent/20"
+							>
+								<div className="flex items-center gap-3">
+									<Circle
+										className={cn(
+											"h-2.5 w-2.5 shrink-0",
+											server.disabled
+												? "fill-muted-foreground/40 text-muted-foreground/40"
+												: "fill-primary text-primary",
+										)}
+									/>
+									<h3 className="text-sm font-semibold text-foreground">
+										{server.name}
+									</h3>
+									<span className="rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{server.transportType}
+									</span>
+									<div className="flex-1" />
+									<div className="flex items-center gap-1">
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Edit ${server.name}`}
+											onClick={() => openEditDialog(server)}
+											disabled={isBusy}
+										>
+											<Pencil className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Delete ${server.name}`}
+											onClick={() => setDeleteTarget(server)}
+											disabled={isBusy}
+										>
+											<Trash2 className="h-3.5 w-3.5" />
+										</Button>
+										<Switch
+											checked={!server.disabled}
+											onCheckedChange={(enabled) =>
+												toggleServer(server, !enabled)
+											}
+											disabled={isBusy}
+											aria-label={`Enable ${server.name}`}
+										/>
+									</div>
+								</div>
+
+								<div className="mt-2.5 ml-5.5 flex flex-col gap-1 text-xs text-muted-foreground">
+									{server.command && (
+										<p>
+											<span className="text-muted-foreground/70">Command:</span>{" "}
+											{server.command}
+										</p>
+									)}
+									{server.args && server.args.length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Args:</span>{" "}
+											{server.args.join(", ")}
+										</p>
+									)}
+									{server.cwd && (
+										<p>
+											<span className="text-muted-foreground/70">CWD:</span>{" "}
+											{server.cwd}
+										</p>
+									)}
+									{server.url && (
+										<p>
+											<span className="text-muted-foreground/70">URL:</span>{" "}
+											{server.url}
+										</p>
+									)}
+									{server.env && Object.keys(server.env).length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Env:</span>{" "}
+											{stringifyRedactedKeyValuePairs(server.env)}
+										</p>
+									)}
+									{server.headers && Object.keys(server.headers).length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Headers:</span>{" "}
+											{stringifyKeyValuePairs(server.headers)}
+										</p>
+									)}
+								</div>
+							</div>
+						);
+					})}
+				</div>
+			)}
+			<Dialog
+				open={editorOpen}
+				onOpenChange={(open) => {
+					setEditorOpen(open);
+					if (!open) {
+						setFormErrorMessage(null);
+					}
+				}}
+			>
+				<DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-2xl">
+					<DialogHeader>
+						<DialogTitle>
+							{editorMode === "edit" ? "Edit MCP Server" : "Add MCP Server"}
+						</DialogTitle>
+						<DialogDescription>
+							Update the MCP server stored in{" "}
+							<code className="font-mono">
+								{settingsPath || "cline_mcp_settings.json"}
+							</code>
+							.
+						</DialogDescription>
+					</DialogHeader>
+
+					<div className="grid gap-4">
+						<div className="grid gap-2">
+							<Label htmlFor="mcp-name">Server name</Label>
+							<Input
+								id="mcp-name"
+								value={formState.name}
+								onChange={(event) =>
+									setFormState((current) => ({
+										...current,
+										name: event.target.value,
+									}))
+								}
+								placeholder="github"
+							/>
+						</div>
+
+						<div className="grid gap-2">
+							<Label>Transport type</Label>
+							<Select
+								value={formState.transportType}
+								onValueChange={(value) =>
+									setFormState((current) => ({
+										...current,
+										transportType: value as McpTransportType,
+									}))
+								}
+							>
+								<SelectTrigger className="w-full">
+									<SelectValue placeholder="Select transport" />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="stdio">stdio</SelectItem>
+									<SelectItem value="sse">sse</SelectItem>
+									<SelectItem value="streamableHttp">streamableHttp</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+
+						{formState.transportType === "stdio" ? (
+							<>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-command">Command</Label>
+									<Input
+										id="mcp-command"
+										value={formState.command}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												command: event.target.value,
+											}))
+										}
+										placeholder="npx"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-args">Args</Label>
+									<Textarea
+										id="mcp-args"
+										value={formState.argsText}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												argsText: event.target.value,
+											}))
+										}
+										placeholder="-y, @modelcontextprotocol/server-github"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-cwd">Working directory</Label>
+									<Input
+										id="mcp-cwd"
+										value={formState.cwd}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												cwd: event.target.value,
+											}))
+										}
+										placeholder="/path/to/project"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<div className="flex items-center justify-between gap-3">
+										<Label>Environment variables</Label>
+										<Button
+											type="button"
+											variant="ghost"
+											size="sm"
+											onClick={addEnvEntry}
+										>
+											<Plus className="h-3.5 w-3.5" />
+										</Button>
+									</div>
+									<div className="flex flex-col gap-2">
+										{formState.envEntries.map((entry) => (
+											<div key={entry.id} className="flex items-center gap-2">
+												<Button
+													type="button"
+													variant="ghost"
+													size="icon-sm"
+													onClick={() => removeEnvEntry(entry.id)}
+													aria-label={`Remove env var ${entry.key || "row"}`}
+												>
+													<Minus className="h-3.5 w-3.5" />
+												</Button>
+												<Input
+													value={entry.key}
+													onChange={(event) =>
+														updateEnvEntry(entry.id, "key", event.target.value)
+													}
+													placeholder="KEY"
+												/>
+												<Input
+													type="password"
+													value={entry.value}
+													onChange={(event) =>
+														updateEnvEntry(
+															entry.id,
+															"value",
+															event.target.value,
+														)
+													}
+													placeholder="VALUE"
+												/>
+											</div>
+										))}
+									</div>
+								</div>
+							</>
+						) : (
+							<>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-url">Server URL</Label>
+									<Input
+										id="mcp-url"
+										value={formState.url}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												url: event.target.value,
+											}))
+										}
+										placeholder="https://example.com/mcp"
+									/>
+								</div>
+								<div className="grid gap-2">
+									<Label htmlFor="mcp-headers">Headers</Label>
+									<Textarea
+										id="mcp-headers"
+										value={formState.headersText}
+										onChange={(event) =>
+											setFormState((current) => ({
+												...current,
+												headersText: event.target.value,
+											}))
+										}
+										placeholder="Authorization=Bearer token"
+									/>
+								</div>
+							</>
+						)}
+
+						<div className="grid gap-2">
+							<Label htmlFor="mcp-metadata">Metadata JSON</Label>
+							<Textarea
+								id="mcp-metadata"
+								value={formState.metadataText}
+								onChange={(event) =>
+									setFormState((current) => ({
+										...current,
+										metadataText: event.target.value,
+									}))
+								}
+								placeholder='{"key":"value"}'
+							/>
+						</div>
+
+						<div className="flex items-center justify-between rounded-md border border-border px-3 py-2">
+							<div>
+								<p className="text-sm font-medium text-foreground">Enabled</p>
+								<p className="text-xs text-muted-foreground">
+									Disable the server without removing it from settings.
+								</p>
+							</div>
+							<Switch
+								checked={!formState.disabled}
+								onCheckedChange={(enabled) =>
+									setFormState((current) => ({
+										...current,
+										disabled: !enabled,
+									}))
+								}
+								aria-label="Enable MCP server"
+							/>
+						</div>
+
+						{formErrorMessage ? (
+							<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+								{formErrorMessage}
+							</div>
+						) : null}
+					</div>
+
+					<DialogFooter>
+						<Button
+							variant="outline"
+							onClick={() => setEditorOpen(false)}
+							disabled={busyServerName !== null}
+						>
+							Cancel
+						</Button>
+						<Button
+							onClick={() => void handleSaveServer()}
+							disabled={busyServerName !== null}
+						>
+							{busyServerName !== null
+								? "Saving..."
+								: editorMode === "edit"
+									? "Save changes"
+									: "Add server"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+
+			<AlertDialog
+				open={deleteTarget !== null}
+				onOpenChange={(open) => {
+					if (!open) {
+						setDeleteTarget(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete MCP Server</AlertDialogTitle>
+						<AlertDialogDescription>
+							{deleteTarget
+								? `Delete MCP server "${deleteTarget.name}" from settings?`
+								: "Delete this MCP server from settings?"}
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel disabled={busyServerName !== null}>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={busyServerName !== null || !deleteTarget}
+							onClick={() => {
+								if (deleteTarget) {
+									void deleteServer(deleteTarget.name);
+									setDeleteTarget(null);
+								}
+							}}
+						>
+							Delete
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+		</PageFrame>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/provider-list-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/provider-list-view.tsx
new file mode 100644
index 0000000..bf76812
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/provider-list-view.tsx
@@ -0,0 +1,640 @@
+"use client";
+
+import {
+	ArrowLeft,
+	ChevronRight,
+	Copy,
+	Eye,
+	EyeOff,
+	FileIcon,
+	ImageIcon,
+	Link as LinkIcon,
+	Loader2,
+	PlusCircle,
+	RefreshCw,
+	Search,
+	Star,
+	X,
+} from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Switch } from "@/components/ui/switch";
+import type {
+	Provider,
+	ProviderConfigField,
+	ProviderConfigFieldPrimitive,
+	ProviderSettingsUpdate,
+} from "@/lib/provider-schema";
+import { cn } from "@/lib/utils";
+
+// -----------------------------------------------------------
+// Provider LIST content (the grid of all providers)
+// -----------------------------------------------------------
+
+function getInitialConfigValues(
+	provider: Provider,
+): Record<string, ProviderConfigFieldPrimitive> {
+	const values: Record<string, ProviderConfigFieldPrimitive> = {
+		...(provider.configValues ?? {}),
+	};
+	if (provider.apiKey !== undefined && values.apiKey === undefined) {
+		values.apiKey = provider.apiKey;
+	}
+	if (provider.baseUrl !== undefined && values.baseUrl === undefined) {
+		values.baseUrl = provider.baseUrl;
+	}
+	for (const field of provider.configFields ?? []) {
+		if (values[field.path] === undefined && field.defaultValue !== undefined) {
+			values[field.path] = field.defaultValue;
+		}
+	}
+	return values;
+}
+
+function fieldValueToString(value: ProviderConfigFieldPrimitive | undefined) {
+	if (value === undefined || value === null) return "";
+	return String(value);
+}
+
+function coerceFieldValue(
+	field: ProviderConfigField,
+	value: string | boolean,
+): ProviderConfigFieldPrimitive {
+	if (field.type === "boolean") {
+		return Boolean(value);
+	}
+	if (typeof value === "boolean") {
+		return value;
+	}
+	if (field.type === "select") {
+		const option = field.options?.find((item) => String(item.value) === value);
+		if (option) {
+			return option.value;
+		}
+	}
+	const trimmed = value.trim();
+	if (trimmed.length === 0) {
+		return null;
+	}
+	if (field.type === "number") {
+		const parsed = Number(trimmed);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return trimmed;
+}
+
+export function ProviderListContent({
+	providers,
+	onToggle,
+	onConfigure,
+	onAddProvider,
+	selectedProviderId,
+	variant = "page",
+}: {
+	providers: Provider[];
+	onToggle: (id: string) => void;
+	onConfigure: (id: string) => void;
+	onAddProvider: () => void;
+	selectedProviderId?: string | null;
+	variant?: "page" | "panel";
+}) {
+	const [providerSearchOpen, setProviderSearchOpen] = useState(false);
+	const [providerSearch, setProviderSearch] = useState("");
+	const enabledProviderCount = providers.filter(
+		(provider) => provider.enabled,
+	).length;
+	const providerSearchQuery = providerSearch.trim().toLowerCase();
+	const filteredProviders = providerSearchQuery
+		? providers.filter((provider) =>
+				provider.name.toLowerCase().includes(providerSearchQuery),
+			)
+		: providers;
+	const isPanel = variant === "panel";
+
+	return (
+		<ScrollArea className="h-full">
+			<div
+				className={cn(
+					"py-10 max-[720px]:px-4 max-[720px]:py-5",
+					isPanel ? "px-8" : "px-18 max-[1200px]:px-8",
+				)}
+			>
+				<div
+					className={cn(
+						"mb-8 flex items-start justify-between gap-6 max-[860px]:flex-col max-[860px]:items-stretch",
+						isPanel ? "max-w-none" : "max-w-[42rem]",
+					)}
+				>
+					<div className="min-w-0">
+						<h1
+							className={cn(
+								"truncate font-semibold leading-[1.15] tracking-normal text-foreground",
+								isPanel ? "text-[24px]" : "text-[32px]",
+							)}
+						>
+							Model Providers
+						</h1>
+						<p className="mt-3 text-[15px] leading-6 text-muted-foreground">
+							{providers.length} available &middot; {enabledProviderCount}{" "}
+							enabled
+						</p>
+					</div>
+					<div className="flex shrink-0 items-center gap-2 max-[860px]:justify-start">
+						<Button
+							aria-label="Search providers"
+							className="size-8 rounded-md"
+							onClick={() => setProviderSearchOpen((open) => !open)}
+							size="icon-sm"
+							type="button"
+							variant={providerSearchOpen ? "default" : "secondary"}
+						>
+							<Search className="size-4" />
+						</Button>
+						<Button
+							className="h-8 rounded-md bg-foreground px-3 text-sm text-background hover:bg-foreground/90"
+							onClick={onAddProvider}
+							type="button"
+						>
+							<PlusCircle className="size-4" />
+							Add provider
+						</Button>
+					</div>
+				</div>
+
+				{providerSearchOpen ? (
+					<div className={cn("mb-4", isPanel ? "max-w-none" : "max-w-[42rem]")}>
+						<div className="flex h-9 items-center gap-2 rounded border bg-background px-3">
+							<Search className="size-4 shrink-0 text-muted-foreground" />
+							<Input
+								aria-label="Search model providers"
+								autoFocus
+								className="h-7 border-0 bg-transparent px-0 text-sm"
+								onChange={(event) => setProviderSearch(event.target.value)}
+								placeholder="Search providers"
+								value={providerSearch}
+							/>
+						</div>
+					</div>
+				) : null}
+
+				<div
+					className={cn(
+						"overflow-hidden",
+						isPanel ? "max-w-none" : "max-w-[42rem]",
+					)}
+				>
+					{filteredProviders.length === 0 ? (
+						<div className="border-b px-2 py-6 text-[15px] text-muted-foreground">
+							No providers match "{providerSearch.trim()}".
+						</div>
+					) : null}
+					{filteredProviders.map((prov) => (
+						<div
+							className={cn(
+								"flex min-h-11 items-center gap-4 border-b px-2 py-2 transition-colors hover:bg-accent/30",
+								selectedProviderId === prov.id && "bg-accent/45",
+							)}
+							key={prov.id}
+						>
+							<button
+								className="flex min-w-0 flex-1 items-center gap-3 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+								onClick={() => onConfigure(prov.id)}
+								type="button"
+							>
+								<p className="min-w-0 flex-1 truncate text-[17px] font-semibold text-foreground">
+									{prov.name}
+								</p>
+								<p className="shrink-0 text-[15px] text-muted-foreground">
+									{prov.models === null
+										? "Models load on demand"
+										: `${prov.models} model${prov.models !== 1 ? "s" : ""}`}
+								</p>
+							</button>
+							<Switch
+								aria-label={`Toggle ${prov.name}`}
+								checked={prov.enabled}
+								onCheckedChange={() => onToggle(prov.id)}
+							/>
+							<button
+								aria-label={`Configure ${prov.name}`}
+								className="grid size-7 shrink-0 place-items-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+								onClick={() => onConfigure(prov.id)}
+								type="button"
+							>
+								<ChevronRight className="size-4" />
+							</button>
+						</div>
+					))}
+				</div>
+			</div>
+		</ScrollArea>
+	);
+}
+
+export function ProviderDetailContent({
+	provider,
+	onBack,
+	onUpdate,
+	onLoadModels,
+	modelsLoading = false,
+	modelsError,
+	onOAuthLogin,
+	oauthLoginPending = false,
+	variant = "page",
+}: {
+	provider: Provider;
+	onBack: () => void;
+	onUpdate: (updates: ProviderSettingsUpdate) => void;
+	onLoadModels?: () => void;
+	modelsLoading?: boolean;
+	modelsError?: string | null;
+	onOAuthLogin?: () => void;
+	oauthLoginPending?: boolean;
+	variant?: "page" | "panel";
+}) {
+	const [shownSecrets, setShownSecrets] = useState<Record<string, boolean>>({});
+	const [localConfigValues, setLocalConfigValues] = useState<
+		Record<string, ProviderConfigFieldPrimitive>
+	>(() => getInitialConfigValues(provider));
+	const [modelSearchState, setModelSearchState] = useState<{
+		providerId: string;
+		value: string;
+	} | null>(null);
+	const [copiedModelState, setCopiedModelState] = useState<{
+		modelId: string;
+		providerId: string;
+	} | null>(null);
+	const copiedModelTimeoutRef = useRef<number | undefined>(undefined);
+
+	const configFields = provider.configFields ?? [];
+	const apiKeyValue = fieldValueToString(localConfigValues.apiKey);
+	const modelList = provider.modelList ?? [];
+	const modelSearch =
+		modelSearchState?.providerId === provider.id ? modelSearchState.value : "";
+	const copiedModelId =
+		copiedModelState?.providerId === provider.id
+			? copiedModelState.modelId
+			: null;
+	const modelSearchQuery = modelSearch.trim().toLowerCase();
+	const filteredModelList = modelSearchQuery
+		? modelList.filter(
+				(model) =>
+					model.name.toLowerCase().includes(modelSearchQuery) ||
+					model.id.toLowerCase().includes(modelSearchQuery),
+			)
+		: modelList;
+	const isPanel = variant === "panel";
+
+	useEffect(
+		() => () => {
+			if (copiedModelTimeoutRef.current !== undefined) {
+				window.clearTimeout(copiedModelTimeoutRef.current);
+			}
+		},
+		[],
+	);
+
+	const commitField = (
+		field: ProviderConfigField,
+		rawValue: string | boolean,
+	) => {
+		const value = coerceFieldValue(field, rawValue);
+		const nextConfigValues = {
+			...localConfigValues,
+			[field.path]: value,
+		};
+		setLocalConfigValues(nextConfigValues);
+
+		const updates: ProviderSettingsUpdate = {
+			configValues: { [field.path]: value },
+		};
+		if (field.path === "apiKey") {
+			updates.apiKey = fieldValueToString(value);
+		}
+		if (field.path === "baseUrl") {
+			updates.baseUrl = fieldValueToString(value);
+		}
+		onUpdate(updates);
+	};
+
+	const copyModelId = (modelId: string) => {
+		if (typeof navigator === "undefined" || !navigator.clipboard?.writeText) {
+			return;
+		}
+		void navigator.clipboard.writeText(modelId).then(() => {
+			setCopiedModelState({ modelId, providerId: provider.id });
+			if (copiedModelTimeoutRef.current !== undefined) {
+				window.clearTimeout(copiedModelTimeoutRef.current);
+			}
+			copiedModelTimeoutRef.current = window.setTimeout(
+				() => setCopiedModelState(null),
+				1600,
+			);
+		});
+	};
+
+	return (
+		<ScrollArea className="h-full">
+			<div
+				className={cn(
+					"py-10 max-[720px]:px-4 max-[720px]:py-5",
+					isPanel ? "px-6" : "px-18 max-[1200px]:px-8",
+				)}
+			>
+				{/* Back + title */}
+				<div className="mb-8 flex items-center gap-3">
+					<Button
+						aria-label={
+							isPanel ? "Close provider details" : "Back to providers"
+						}
+						className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+						onClick={onBack}
+						variant="ghost"
+					>
+						{isPanel ? (
+							<X className="h-4 w-4" />
+						) : (
+							<ArrowLeft className="h-4 w-4" />
+						)}
+					</Button>
+					<h1
+						className={cn(
+							"truncate font-semibold leading-[1.15] tracking-normal text-foreground",
+							isPanel ? "text-[24px]" : "text-[32px]",
+						)}
+					>
+						{provider.name}
+					</h1>
+				</div>
+
+				{configFields.length > 0 ? (
+					<section
+						className={cn("mb-8", isPanel ? "max-w-none" : "max-w-[86rem]")}
+					>
+						<div className="flex flex-col">
+							{configFields.map((field) => {
+								const value = localConfigValues[field.path];
+								const valueText = fieldValueToString(value);
+								const isSecret = field.type === "password" || field.secret;
+								const isShown = shownSecrets[field.path] ?? false;
+								return (
+									<div
+										className="grid min-h-18 grid-cols-[minmax(12rem,0.55fr)_minmax(16rem,0.45fr)] items-center gap-6 border-b py-4 max-[900px]:grid-cols-1 max-[900px]:gap-3"
+										key={field.path}
+									>
+										<header>
+											<h3 className="text-[17px] font-semibold text-foreground">
+												{field.label}
+											</h3>
+											{field.description ? (
+												<p className="mt-1 text-[15px] leading-relaxed text-muted-foreground">
+													{field.description}
+												</p>
+											) : null}
+										</header>
+										{field.type === "boolean" ? (
+											<div className="flex items-center justify-end">
+												<span className="text-sm text-muted-foreground">
+													{field.label}
+												</span>
+												<Switch
+													checked={Boolean(value)}
+													onCheckedChange={(checked) =>
+														commitField(field, checked)
+													}
+												/>
+											</div>
+										) : field.type === "select" ? (
+											<select
+												className="h-9 w-full rounded border border-border bg-background px-3 text-sm text-foreground outline-none focus:ring-1 focus:ring-ring"
+												onChange={(event) =>
+													commitField(field, event.target.value)
+												}
+												value={valueText}
+											>
+												<option value="">Not set</option>
+												{field.options?.map((option) => (
+													<option
+														key={String(option.value)}
+														value={String(option.value)}
+													>
+														{option.label}
+													</option>
+												))}
+											</select>
+										) : (
+											<div className="flex h-9 items-center gap-2 rounded border border-border bg-background px-3">
+												{field.type === "url" ? (
+													<LinkIcon className="h-4 w-4 shrink-0 text-muted-foreground" />
+												) : null}
+												<Input
+													className="h-7 flex-1 border-0 bg-transparent px-0 text-sm text-foreground outline-none placeholder:text-muted-foreground"
+													onBlur={() => commitField(field, valueText)}
+													onChange={(event) =>
+														setLocalConfigValues((current) => ({
+															...current,
+															[field.path]: event.target.value,
+														}))
+													}
+													placeholder={field.placeholder}
+													spellCheck={false}
+													type={
+														isSecret && !isShown
+															? "password"
+															: field.type === "number"
+																? "number"
+																: field.type === "url"
+																	? "url"
+																	: "text"
+													}
+													value={valueText}
+												/>
+												{isSecret ? (
+													<>
+														<Button
+															aria-label={
+																isShown ? "Hide secret" : "Show secret"
+															}
+															className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+															onClick={() =>
+																setShownSecrets((current) => ({
+																	...current,
+																	[field.path]: !isShown,
+																}))
+															}
+															variant="ghost"
+														>
+															{isShown ? (
+																<EyeOff className="h-4 w-4" />
+															) : (
+																<Eye className="h-4 w-4" />
+															)}
+														</Button>
+														<Button
+															aria-label={`Copy ${field.label}`}
+															className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+															onClick={() =>
+																navigator.clipboard.writeText(valueText)
+															}
+															variant="ghost"
+														>
+															<Copy className="h-4 w-4" />
+														</Button>
+													</>
+												) : null}
+											</div>
+										)}
+									</div>
+								);
+							})}
+						</div>
+					</section>
+				) : null}
+
+				{!apiKeyValue && !provider.oauthAccessTokenPresent && onOAuthLogin ? (
+					<div className="mb-8">
+						<Button
+							className="inline-flex items-center gap-2 w-full"
+							disabled={oauthLoginPending}
+							onClick={onOAuthLogin}
+							variant="default"
+						>
+							{oauthLoginPending ? (
+								<Loader2 className="h-4 w-4 animate-spin" />
+							) : null}
+							<span>Login via Browser</span>
+						</Button>
+					</div>
+				) : null}
+				{provider.oauthAccessTokenPresent ? (
+					<p className="mb-8 text-xs text-muted-foreground">
+						OAuth is connected. Manual credentials remain available when this
+						provider supports them.
+					</p>
+				) : null}
+
+				{/* Models section */}
+				<section
+					className={cn(
+						"overflow-hidden rounded-lg border",
+						isPanel ? "max-w-none" : "max-w-[46rem]",
+					)}
+				>
+					<div className="flex h-12 items-center justify-between bg-muted/40 px-4">
+						<h2 className="text-[17px] font-medium text-muted-foreground">
+							Models
+						</h2>
+						<div className="flex items-center gap-1">
+							<Search className="size-4 text-muted-foreground" />
+							<Button
+								aria-label="Refresh models"
+								className="rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors"
+								disabled={modelsLoading}
+								onClick={onLoadModels}
+								variant="ghost"
+							>
+								<RefreshCw
+									className={cn("size-3", modelsLoading && "animate-spin")}
+								/>
+							</Button>
+						</div>
+					</div>
+
+					{modelsError ? (
+						<div className="rounded-lg border border-border px-4 py-8 text-center">
+							<p className="text-sm text-destructive">{modelsError}</p>
+						</div>
+					) : modelList.length > 0 ? (
+						<div className="space-y-3">
+							<div className="mx-4 mt-4 flex items-center gap-2 rounded border border-border bg-background px-3 py-2">
+								<Search className="size-4 shrink-0 text-muted-foreground" />
+								<Input
+									aria-label="Search models"
+									className="h-7 flex-1 border-0 text-sm text-foreground placeholder:text-muted-foreground"
+									onChange={(event) =>
+										setModelSearchState({
+											providerId: provider.id,
+											value: event.target.value,
+										})
+									}
+									placeholder="Search models by name or ID"
+									spellCheck={false}
+									value={modelSearch}
+								/>
+							</div>
+							{filteredModelList.length > 0 ? (
+								<div className="max-h-125 overflow-y-scroll border-t">
+									{filteredModelList.map((model) => (
+										<div
+											className="group flex min-h-16 items-center gap-3 border-b px-4 py-3 transition-colors hover:bg-accent/30"
+											key={model.id}
+										>
+											<div className="min-w-0 flex-1 font-mono">
+												<div className="flex min-w-0 items-center gap-1.5 px-1 text-sm text-foreground">
+													<span className="truncate">{model.name}</span>
+													{/* Capability icons */}
+													{model.supportsAttachments && (
+														<div title="File Support">
+															<FileIcon className="h-3.5 w-3.5 text-muted-foreground" />
+														</div>
+													)}
+													{model.supportsVision && (
+														<div title="Image Support">
+															<ImageIcon className="h-3.5 w-3.5 text-muted-foreground" />
+														</div>
+													)}
+												</div>
+												<button
+													aria-label={`Copy model ID ${model.id}`}
+													className="mt-1 flex max-w-full items-center gap-1.5 px-1 text-left text-xs text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+													onClick={() => copyModelId(model.id)}
+													title="Copy model ID"
+													type="button"
+												>
+													<span className="min-w-0 truncate">{model.id}</span>
+													<Copy className="size-3 shrink-0" />
+													{copiedModelId === model.id ? (
+														<span className="shrink-0 text-foreground">
+															Copied
+														</span>
+													) : null}
+												</button>
+											</div>
+
+											{/* Action icons */}
+											<div className="flex items-center gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity">
+												<Button
+													aria-label={`Favorite ${model.name}`}
+													className="rounded-md p-1 text-muted-foreground hover:text-foreground transition-colors"
+													variant="ghost"
+												>
+													<Star className="h-3.5 w-3.5" />
+												</Button>
+											</div>
+										</div>
+									))}
+								</div>
+							) : (
+								<div className="rounded-lg border border-border px-4 py-8 text-center">
+									<p className="text-sm text-muted-foreground">
+										No models match "{modelSearch.trim()}".
+									</p>
+								</div>
+							)}
+						</div>
+					) : (
+						<div className="rounded-lg border border-border px-4 py-8 text-center">
+							<p className="text-sm text-muted-foreground">
+								{modelsLoading
+									? "Loading models..."
+									: "No models available. Click refresh to load models."}
+							</p>
+						</div>
+					)}
+				</section>
+			</div>
+		</ScrollArea>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx
new file mode 100644
index 0000000..01d9b46
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx
@@ -0,0 +1,1540 @@
+"use client";
+
+import {
+	Circle,
+	Eye,
+	Pause,
+	Pencil,
+	Play,
+	Plus,
+	RefreshCw,
+	Trash2,
+	Zap,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button, buttonVariants } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import {
+	Combobox,
+	ComboboxContent,
+	ComboboxEmpty,
+	ComboboxInput,
+	ComboboxItem,
+	ComboboxList,
+} from "@/components/ui/combobox";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { desktopClient } from "@/lib/desktop-client";
+import { readModelSelectionStorageFromWindow } from "@/lib/model-selection";
+import { normalizeProviderId } from "@/lib/provider-id";
+import {
+	loadProviderModelCatalog,
+	loadProviderModels,
+} from "@/lib/provider-model-catalog";
+import { cn } from "@/lib/utils";
+import {
+	CommandBadge,
+	PageEmptyState,
+	PageFrame,
+	PageHeader,
+} from "../page-layout";
+
+type DateTimeValue = number | string;
+
+interface RoutineSchedule {
+	scheduleId: string;
+	name: string;
+	cronPattern: string;
+	prompt: string;
+	provider?: string;
+	model?: string;
+	modelSelection?: {
+		providerId?: string;
+		modelId?: string;
+	};
+	mode: "act" | "plan" | "yolo";
+	workspaceRoot?: string;
+	cwd?: string;
+	systemPrompt?: string;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	maxParallel: number;
+	enabled: boolean;
+	createdAt: DateTimeValue;
+	updatedAt: DateTimeValue;
+	lastRunAt?: DateTimeValue;
+	nextRunAt?: DateTimeValue;
+	tags?: string[];
+}
+
+interface RoutineExecution {
+	executionId: string;
+	scheduleId: string;
+	sessionId?: string;
+	triggeredAt?: DateTimeValue;
+	startedAt?: DateTimeValue;
+	endedAt?: DateTimeValue;
+	timeoutAt?: DateTimeValue;
+	status?: string;
+	errorMessage?: string;
+}
+
+interface RoutineUpcomingRun {
+	scheduleId: string;
+	name: string;
+	nextRunAt: DateTimeValue;
+}
+
+interface RoutineOverviewResponse {
+	schedules: RoutineSchedule[];
+	activeExecutions: RoutineExecution[];
+	upcomingRuns: RoutineUpcomingRun[];
+	lastExecutions: RoutineExecution[];
+}
+
+const ROUTINE_OVERVIEW_CACHE_TTL_MS = 30_000;
+
+let routineOverviewCache:
+	| (RoutineOverviewResponse & {
+			fetchedAt: number;
+	  })
+	| null = null;
+
+async function fetchRoutineOverview(): Promise<RoutineOverviewResponse> {
+	const response = await desktopClient.invoke<RoutineOverviewResponse>(
+		"list_routine_schedules",
+	);
+	return {
+		schedules: response.schedules ?? [],
+		activeExecutions: response.activeExecutions ?? [],
+		upcomingRuns: response.upcomingRuns ?? [],
+		lastExecutions: response.lastExecutions ?? [],
+	};
+}
+
+interface ProcessContext {
+	workspaceRoot: string;
+	cwd: string;
+}
+
+const FALLBACK_PROVIDER_MODELS: Record<string, string[]> = {
+	cline: ["anthropic/claude-sonnet-4.6"],
+	anthropic: ["claude-sonnet-4-6"],
+	"openai-native": ["gpt-5.3-codex"],
+	openrouter: ["anthropic/claude-sonnet-4.6"],
+	gemini: ["gemini-2.5-pro"],
+};
+
+const WEEKDAY_OPTIONS = [
+	{ label: "Mon", value: "MON" },
+	{ label: "Tue", value: "TUE" },
+	{ label: "Wed", value: "WED" },
+	{ label: "Thu", value: "THU" },
+	{ label: "Fri", value: "FRI" },
+	{ label: "Sat", value: "SAT" },
+	{ label: "Sun", value: "SUN" },
+] as const;
+
+interface RoutineFormState {
+	name: string;
+	scheduleHour: string;
+	scheduleMinute: string;
+	scheduleDays: string[];
+	prompt: string;
+	provider: string;
+	model: string;
+	mode: "act" | "plan";
+	workspaceRoot: string;
+	cwd: string;
+	systemPrompt: string;
+	maxIterations: string;
+	timeoutSeconds: string;
+	maxParallel: string;
+	tags: string;
+	enabled: boolean;
+}
+
+function formatDateTime(value?: DateTimeValue | null): string {
+	if (value === undefined || value === null) {
+		return "-";
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			return "-";
+		}
+		const parsed = new Date(value);
+		return Number.isNaN(parsed.getTime()) ? "-" : parsed.toLocaleString();
+	}
+	const trimmed = value.trim();
+	if (trimmed.length === 0) {
+		return "-";
+	}
+	const parsed = new Date(trimmed);
+	if (Number.isNaN(parsed.getTime())) {
+		return trimmed;
+	}
+	return parsed.toLocaleString();
+}
+
+function formatScheduleModel(schedule: RoutineSchedule): string {
+	const provider =
+		schedule.modelSelection?.providerId?.trim() || schedule.provider?.trim();
+	const model =
+		schedule.modelSelection?.modelId?.trim() || schedule.model?.trim();
+	if (provider && model) {
+		return `${provider}/${model}`;
+	}
+	return model || provider || "-";
+}
+
+function getScheduleProviderModel(schedule: RoutineSchedule): {
+	provider: string;
+	model: string;
+} {
+	return {
+		provider:
+			schedule.modelSelection?.providerId?.trim() ||
+			schedule.provider?.trim() ||
+			"cline",
+		model:
+			schedule.modelSelection?.modelId?.trim() ||
+			schedule.model?.trim() ||
+			"openai/gpt-5.3-codex",
+	};
+}
+
+function formatExecutionResult(execution?: RoutineExecution): string {
+	if (!execution) {
+		return "-";
+	}
+	const status = execution.status?.trim() || "unknown";
+	const timestamp =
+		execution.endedAt ?? execution.startedAt ?? execution.triggeredAt;
+	const when = formatDateTime(timestamp);
+	return when === "-" ? status : `${status} at ${when}`;
+}
+
+function parseOptionalPositiveInt(text: string): number | undefined {
+	const trimmed = text.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	const value = Number.parseInt(trimmed, 10);
+	if (!Number.isFinite(value) || value <= 0) {
+		return undefined;
+	}
+	return value;
+}
+
+function parseTags(text: string): string[] | undefined {
+	const tags = text
+		.split(",")
+		.map((value) => value.trim())
+		.filter((value) => value.length > 0);
+	return tags.length > 0 ? tags : undefined;
+}
+
+function normalizeScheduleDays(days: string[]): string[] {
+	const selected = new Set(days);
+	return WEEKDAY_OPTIONS.map((option) => option.value).filter((value) =>
+		selected.has(value),
+	);
+}
+
+function buildCronPattern(
+	days: string[],
+	hour: string,
+	minute: string,
+): string {
+	const normalizedDays = normalizeScheduleDays(days);
+	if (normalizedDays.length === 0) {
+		return "";
+	}
+	const normalizedHour = Number.parseInt(hour, 10);
+	const normalizedMinute = Number.parseInt(minute, 10);
+	const cronHour = Number.isFinite(normalizedHour)
+		? Math.min(Math.max(normalizedHour, 0), 23)
+		: 9;
+	const cronMinute = Number.isFinite(normalizedMinute)
+		? Math.min(Math.max(normalizedMinute, 0), 59)
+		: 0;
+	if (normalizedDays.length === WEEKDAY_OPTIONS.length) {
+		return `${cronMinute} ${cronHour} * * *`;
+	}
+	return `${cronMinute} ${cronHour} * * ${normalizedDays.join(",")}`;
+}
+
+function expandCronDays(dayExpression: string | undefined): string[] {
+	const raw = dayExpression?.trim().toUpperCase();
+	if (!raw || raw === "*") {
+		return WEEKDAY_OPTIONS.map((option) => option.value);
+	}
+	const values = new Set<string>();
+	for (const part of raw.split(",")) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		const rangeMatch = /^([A-Z]{3})-([A-Z]{3})$/.exec(trimmed);
+		if (rangeMatch) {
+			const start = WEEKDAY_OPTIONS.findIndex(
+				(option) => option.value === rangeMatch[1],
+			);
+			const end = WEEKDAY_OPTIONS.findIndex(
+				(option) => option.value === rangeMatch[2],
+			);
+			if (start >= 0 && end >= start) {
+				for (let index = start; index <= end; index += 1) {
+					values.add(WEEKDAY_OPTIONS[index].value);
+				}
+			}
+			continue;
+		}
+		if (WEEKDAY_OPTIONS.some((option) => option.value === trimmed)) {
+			values.add(trimmed);
+		}
+	}
+	return normalizeScheduleDays([...values]);
+}
+
+function parseCronPattern(
+	cronPattern: string,
+): Pick<RoutineFormState, "scheduleHour" | "scheduleMinute" | "scheduleDays"> {
+	const parts = cronPattern.trim().split(/\s+/);
+	const minute = Number.parseInt(parts[0] ?? "", 10);
+	const hour = Number.parseInt(parts[1] ?? "", 10);
+	const days = expandCronDays(parts[4]);
+	return {
+		scheduleHour:
+			Number.isInteger(hour) && hour >= 0 && hour <= 23 ? String(hour) : "9",
+		scheduleMinute:
+			Number.isInteger(minute) && minute >= 0 && minute <= 59
+				? String(minute)
+				: "0",
+		scheduleDays: days.length > 0 ? days : ["MON", "TUE", "WED", "THU", "FRI"],
+	};
+}
+
+export function RoutineSchedulesContent() {
+	const [schedules, setSchedules] = useState<RoutineSchedule[]>(
+		() => routineOverviewCache?.schedules ?? [],
+	);
+	const [activeExecutions, setActiveExecutions] = useState<RoutineExecution[]>(
+		() => routineOverviewCache?.activeExecutions ?? [],
+	);
+	const [upcomingRuns, setUpcomingRuns] = useState<RoutineUpcomingRun[]>(
+		() => routineOverviewCache?.upcomingRuns ?? [],
+	);
+	const [lastExecutions, setLastExecutions] = useState<RoutineExecution[]>(
+		() => routineOverviewCache?.lastExecutions ?? [],
+	);
+	const [isLoading, setIsLoading] = useState(() => !routineOverviewCache);
+	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const [busyScheduleId, setBusyScheduleId] = useState<string | null>(null);
+	const [schedulePendingDelete, setSchedulePendingDelete] =
+		useState<RoutineSchedule | null>(null);
+	const [isCreateOpen, setIsCreateOpen] = useState(false);
+	const [editingSchedule, setEditingSchedule] =
+		useState<RoutineSchedule | null>(null);
+	const [isCreating, setIsCreating] = useState(false);
+	const [createFormError, setCreateFormError] = useState<string | null>(null);
+	const [providerModels, setProviderModels] = useState<
+		Record<string, string[]>
+	>(FALLBACK_PROVIDER_MODELS);
+	const [enabledProviderIds, setEnabledProviderIds] = useState<string[]>(() =>
+		Object.keys(FALLBACK_PROVIDER_MODELS),
+	);
+	const [lastModelSelection] = useState(() =>
+		readModelSelectionStorageFromWindow(),
+	);
+	const rememberedProvider = normalizeProviderId(
+		lastModelSelection.lastProvider,
+	);
+	const [createForm, setCreateForm] = useState<RoutineFormState>({
+		name: "",
+		scheduleHour: "9",
+		scheduleMinute: "0",
+		scheduleDays: ["MON", "TUE", "WED", "THU", "FRI"],
+		prompt: "Review PRs opened yesterday and summarize issues.",
+		provider: "cline",
+		model: "openai/gpt-5.3-codex",
+		mode: "act",
+		workspaceRoot: "",
+		cwd: "",
+		systemPrompt: "",
+		maxIterations: "",
+		timeoutSeconds: "",
+		maxParallel: "1",
+		tags: "",
+		enabled: true,
+	});
+
+	const visibleProviderModels = useMemo(() => {
+		if (enabledProviderIds.length === 0) {
+			return providerModels;
+		}
+		const next: Record<string, string[]> = {};
+		for (const providerId of enabledProviderIds) {
+			next[providerId] = providerModels[providerId] ?? [];
+		}
+		return next;
+	}, [enabledProviderIds, providerModels]);
+
+	const availableProviders = useMemo(
+		() => Object.keys(visibleProviderModels),
+		[visibleProviderModels],
+	);
+
+	const availableModelsForProvider = useMemo(
+		() => visibleProviderModels[createForm.provider] ?? [],
+		[createForm.provider, visibleProviderModels],
+	);
+
+	const cronPreview = useMemo(
+		() =>
+			buildCronPattern(
+				createForm.scheduleDays,
+				createForm.scheduleHour,
+				createForm.scheduleMinute,
+			),
+		[
+			createForm.scheduleDays,
+			createForm.scheduleHour,
+			createForm.scheduleMinute,
+		],
+	);
+
+	useEffect(() => {
+		let cancelled = false;
+
+		async function loadCatalog() {
+			try {
+				const payload = await loadProviderModelCatalog();
+				if (cancelled) {
+					return;
+				}
+				setProviderModels(payload.providerModels);
+				setEnabledProviderIds((current) => {
+					const nextProviderIds = new Set(payload.enabledProviderIds);
+					const normalizedCurrentProvider = normalizeProviderId(
+						createForm.provider,
+					);
+					if (normalizedCurrentProvider) {
+						nextProviderIds.add(normalizedCurrentProvider);
+					}
+					for (const providerId of current) {
+						if (providerId in payload.providerModels) {
+							nextProviderIds.add(providerId);
+						}
+					}
+					return Array.from(nextProviderIds);
+				});
+			} catch {
+				// Keep fallback values if provider catalog is unavailable.
+			}
+		}
+
+		void loadCatalog();
+		return () => {
+			cancelled = true;
+		};
+	}, [createForm.provider]);
+
+	useEffect(() => {
+		const normalizedProvider = normalizeProviderId(createForm.provider);
+		if (!normalizedProvider) {
+			return;
+		}
+		if ((providerModels[normalizedProvider] ?? []).length > 0) {
+			return;
+		}
+
+		let cancelled = false;
+
+		async function loadModelsForProvider() {
+			try {
+				const models = await loadProviderModels(normalizedProvider);
+				if (cancelled || models.length === 0) {
+					return;
+				}
+				setProviderModels((current) => ({
+					...current,
+					[normalizedProvider]: models.map((entry) => entry.id),
+				}));
+				setEnabledProviderIds((current) =>
+					current.includes(normalizedProvider)
+						? current
+						: [...current, normalizedProvider],
+				);
+			} catch {
+				// Keep existing values when provider-specific model loading fails.
+			}
+		}
+
+		void loadModelsForProvider();
+		return () => {
+			cancelled = true;
+		};
+	}, [createForm.provider, providerModels]);
+
+	useEffect(() => {
+		if (availableProviders.length === 0) {
+			return;
+		}
+		let nextSelection: { provider: string; model: string } | null = null;
+		const normalizedFormProvider = normalizeProviderId(createForm.provider);
+		if (!availableProviders.includes(normalizedFormProvider)) {
+			const nextProvider =
+				rememberedProvider && availableProviders.includes(rememberedProvider)
+					? rememberedProvider
+					: availableProviders[0];
+			const models = visibleProviderModels[nextProvider] ?? [];
+			const rememberedModel =
+				lastModelSelection.lastModelByProvider[nextProvider] ??
+				lastModelSelection.lastModelByProvider[lastModelSelection.lastProvider];
+			const nextModel =
+				rememberedModel && models.includes(rememberedModel)
+					? rememberedModel
+					: (models[0] ?? "");
+			nextSelection = { provider: nextProvider, model: nextModel };
+		} else {
+			const models = visibleProviderModels[normalizedFormProvider] ?? [];
+			if (models.length === 0 || models.includes(createForm.model)) {
+				return;
+			}
+			const rememberedModel =
+				lastModelSelection.lastModelByProvider[normalizedFormProvider] ??
+				lastModelSelection.lastModelByProvider[lastModelSelection.lastProvider];
+			const nextModel =
+				rememberedModel && models.includes(rememberedModel)
+					? rememberedModel
+					: models[0];
+			nextSelection = { provider: normalizedFormProvider, model: nextModel };
+		}
+
+		const timeoutId = window.setTimeout(() => {
+			setCreateForm((prev) => ({
+				...prev,
+				...nextSelection,
+			}));
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [
+		availableProviders,
+		createForm.model,
+		createForm.provider,
+		lastModelSelection.lastModelByProvider,
+		lastModelSelection.lastProvider,
+		rememberedProvider,
+		visibleProviderModels,
+	]);
+
+	const refreshSchedules = useCallback(
+		async (options?: { force?: boolean; showLoading?: boolean }) => {
+			const now = Date.now();
+			if (
+				!options?.force &&
+				routineOverviewCache &&
+				now - routineOverviewCache.fetchedAt < ROUTINE_OVERVIEW_CACHE_TTL_MS
+			) {
+				setSchedules(routineOverviewCache.schedules);
+				setActiveExecutions(routineOverviewCache.activeExecutions);
+				setUpcomingRuns(routineOverviewCache.upcomingRuns);
+				setLastExecutions(routineOverviewCache.lastExecutions);
+				setErrorMessage(null);
+				setIsLoading(false);
+				return;
+			}
+
+			if (options?.showLoading !== false) {
+				setIsLoading(true);
+			}
+			setErrorMessage(null);
+			try {
+				const response = await fetchRoutineOverview();
+				const schedules = response.schedules;
+				const activeExecutions = response.activeExecutions;
+				const upcomingRuns = response.upcomingRuns;
+				const lastExecutions = response.lastExecutions;
+				setSchedules(schedules);
+				setActiveExecutions(activeExecutions);
+				setUpcomingRuns(upcomingRuns);
+				setLastExecutions(lastExecutions);
+				routineOverviewCache = {
+					schedules,
+					activeExecutions,
+					upcomingRuns,
+					lastExecutions,
+					fetchedAt: now,
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setErrorMessage(message);
+			} finally {
+				setIsLoading(false);
+			}
+		},
+		[],
+	);
+
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			void refreshSchedules();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [refreshSchedules]);
+
+	const upsertScheduleEnabled = async (
+		schedule: RoutineSchedule,
+		enabled: boolean,
+	) => {
+		setBusyScheduleId(schedule.scheduleId);
+		setErrorMessage(null);
+		try {
+			if (enabled) {
+				await desktopClient.invoke("resume_routine_schedule", {
+					schedule_id: schedule.scheduleId,
+				});
+			} else {
+				await desktopClient.invoke("pause_routine_schedule", {
+					schedule_id: schedule.scheduleId,
+				});
+			}
+			await refreshSchedules({ force: true, showLoading: false });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyScheduleId(null);
+		}
+	};
+
+	const triggerSchedule = async (scheduleId: string) => {
+		setBusyScheduleId(scheduleId);
+		setErrorMessage(null);
+		try {
+			await desktopClient.invoke("trigger_routine_schedule", {
+				schedule_id: scheduleId,
+			});
+			await refreshSchedules({ force: true, showLoading: false });
+			window.setTimeout(() => {
+				void refreshSchedules({ force: true, showLoading: false });
+			}, 1_000);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyScheduleId(null);
+		}
+	};
+
+	const deleteSchedule = async (scheduleId: string) => {
+		setBusyScheduleId(scheduleId);
+		setErrorMessage(null);
+		try {
+			await desktopClient.invoke("delete_routine_schedule", {
+				schedule_id: scheduleId,
+			});
+			setSchedulePendingDelete(null);
+			await refreshSchedules({ force: true, showLoading: false });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setErrorMessage(message);
+		} finally {
+			setBusyScheduleId(null);
+		}
+	};
+
+	const openCreateDialog = async () => {
+		setEditingSchedule(null);
+		setErrorMessage(null);
+		setCreateFormError(null);
+		let context: ProcessContext = { workspaceRoot: "", cwd: "" };
+		try {
+			context = await desktopClient.invoke<ProcessContext>(
+				"get_process_context",
+			);
+		} catch {
+			// Use empty defaults when context lookup fails.
+		}
+		const preferredProvider =
+			rememberedProvider && availableProviders.includes(rememberedProvider)
+				? rememberedProvider
+				: (availableProviders[0] ?? "cline");
+		const modelsForProvider = visibleProviderModels[preferredProvider] ?? [];
+		const rememberedModel =
+			lastModelSelection.lastModelByProvider[preferredProvider] ??
+			lastModelSelection.lastModelByProvider[lastModelSelection.lastProvider];
+		const preferredModel =
+			rememberedModel && modelsForProvider.includes(rememberedModel)
+				? rememberedModel
+				: (modelsForProvider[0] ?? createForm.model);
+		setCreateForm({
+			name: "",
+			scheduleHour: "9",
+			scheduleMinute: "0",
+			scheduleDays: ["MON", "TUE", "WED", "THU", "FRI"],
+			prompt: "Review PRs opened yesterday and summarize issues.",
+			provider: preferredProvider,
+			model: preferredModel,
+			mode: "act",
+			workspaceRoot: context.workspaceRoot || context.cwd,
+			cwd: context.cwd || "",
+			systemPrompt: "",
+			maxIterations: "",
+			timeoutSeconds: "",
+			maxParallel: "1",
+			tags: "",
+			enabled: true,
+		});
+		setIsCreateOpen(true);
+	};
+
+	const openEditDialog = (schedule: RoutineSchedule) => {
+		const { provider, model } = getScheduleProviderModel(schedule);
+		const parsedCron = parseCronPattern(schedule.cronPattern);
+		setEditingSchedule(schedule);
+		setErrorMessage(null);
+		setCreateFormError(null);
+		setEnabledProviderIds((current) =>
+			current.includes(provider) ? current : [...current, provider],
+		);
+		setProviderModels((current) =>
+			current[provider]?.includes(model)
+				? current
+				: {
+						...current,
+						[provider]: [...(current[provider] ?? []), model],
+					},
+		);
+		setCreateForm({
+			name: schedule.name,
+			...parsedCron,
+			prompt: schedule.prompt,
+			provider,
+			model,
+			mode: schedule.mode === "plan" ? "plan" : "act",
+			workspaceRoot: schedule.workspaceRoot ?? "",
+			cwd: schedule.cwd ?? "",
+			systemPrompt: schedule.systemPrompt ?? "",
+			maxIterations:
+				typeof schedule.maxIterations === "number"
+					? String(schedule.maxIterations)
+					: "",
+			timeoutSeconds:
+				typeof schedule.timeoutSeconds === "number"
+					? String(schedule.timeoutSeconds)
+					: "",
+			maxParallel:
+				typeof schedule.maxParallel === "number"
+					? String(schedule.maxParallel)
+					: "1",
+			tags: schedule.tags?.join(",") ?? "",
+			enabled: schedule.enabled,
+		});
+		setIsCreateOpen(true);
+	};
+
+	const submitCreateForm = async () => {
+		const name = createForm.name.trim();
+		if (!name) {
+			setCreateFormError("Routine name is required.");
+			return;
+		}
+		const cronPattern = buildCronPattern(
+			createForm.scheduleDays,
+			createForm.scheduleHour,
+			createForm.scheduleMinute,
+		);
+		if (!cronPattern) {
+			setCreateFormError("Select at least one day and a valid time.");
+			return;
+		}
+		const prompt = createForm.prompt.trim();
+		if (!prompt) {
+			setCreateFormError("Prompt is required.");
+			return;
+		}
+		const workspaceRoot = createForm.workspaceRoot.trim();
+		if (!workspaceRoot) {
+			setCreateFormError("Workspace root is required.");
+			return;
+		}
+		setCreateFormError(null);
+		setIsCreating(true);
+		try {
+			const provider =
+				normalizeProviderId(createForm.provider) ||
+				availableProviders[0] ||
+				"cline";
+			const model =
+				createForm.model.trim() ||
+				(visibleProviderModels[provider] ?? [])[0] ||
+				"openai/gpt-5.3-codex";
+			const maxIterations = parseOptionalPositiveInt(createForm.maxIterations);
+			const timeoutSeconds = parseOptionalPositiveInt(
+				createForm.timeoutSeconds,
+			);
+			const maxParallel = parseOptionalPositiveInt(createForm.maxParallel) ?? 1;
+			const tags = parseTags(createForm.tags);
+			const command = editingSchedule
+				? "update_routine_schedule"
+				: "create_routine_schedule";
+			await desktopClient.invoke(command, {
+				...(editingSchedule
+					? { schedule_id: editingSchedule.scheduleId }
+					: undefined),
+				name,
+				cron_pattern: cronPattern,
+				prompt,
+				provider,
+				model,
+				mode: createForm.mode,
+				workspace_root: workspaceRoot,
+				cwd: createForm.cwd.trim() || undefined,
+				system_prompt: editingSchedule
+					? createForm.systemPrompt.trim() || null
+					: createForm.systemPrompt.trim() || undefined,
+				max_iterations: editingSchedule
+					? (maxIterations ?? null)
+					: maxIterations,
+				timeout_seconds: editingSchedule
+					? (timeoutSeconds ?? null)
+					: timeoutSeconds,
+				max_parallel: maxParallel,
+				enabled: createForm.enabled,
+				tags: tags ?? [],
+			});
+			await refreshSchedules({ force: true, showLoading: false });
+			setIsCreateOpen(false);
+			setEditingSchedule(null);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setCreateFormError(message);
+		} finally {
+			setIsCreating(false);
+		}
+	};
+
+	const executionBySchedule = useMemo(() => {
+		const map = new Map<string, RoutineExecution>();
+		for (const execution of activeExecutions) {
+			if (!execution.scheduleId) {
+				continue;
+			}
+			if (!map.has(execution.scheduleId)) {
+				map.set(execution.scheduleId, execution);
+			}
+		}
+		return map;
+	}, [activeExecutions]);
+
+	const lastExecutionBySchedule = useMemo(() => {
+		const map = new Map<string, RoutineExecution>();
+		for (const execution of lastExecutions) {
+			if (!execution.scheduleId) {
+				continue;
+			}
+			if (!map.has(execution.scheduleId)) {
+				map.set(execution.scheduleId, execution);
+			}
+		}
+		return map;
+	}, [lastExecutions]);
+
+	const sortedSchedules = useMemo(
+		() =>
+			[...schedules].sort((a, b) =>
+				a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+			),
+		[schedules],
+	);
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description="Scheduled jobs are run through the hub."
+				title="Schedules"
+				meta={<CommandBadge>cline schedule</CommandBadge>}
+				actions={
+					<>
+						<Button
+							variant="outline"
+							size="sm"
+							onClick={() => void refreshSchedules()}
+							disabled={isLoading}
+						>
+							<RefreshCw
+								className={cn("h-4 w-4", isLoading && "animate-spin")}
+							/>
+						</Button>
+						<Button size="sm" onClick={() => void openCreateDialog()}>
+							<Plus className="h-4 w-4" />
+							New Schedule
+						</Button>
+					</>
+				}
+			/>
+
+			{errorMessage && (
+				<div className="mb-4 rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+					{errorMessage}
+				</div>
+			)}
+
+			{isLoading ? (
+				<PageEmptyState>Loading schedules...</PageEmptyState>
+			) : sortedSchedules.length === 0 ? (
+				<PageEmptyState>
+					No schedules found. Create a schedule to run routines on a recurring
+					basis.
+				</PageEmptyState>
+			) : (
+				<div className="flex flex-col gap-3">
+					{sortedSchedules.map((schedule) => {
+						const isBusy = busyScheduleId === schedule.scheduleId;
+						const activeExecution = executionBySchedule.get(
+							schedule.scheduleId,
+						);
+						const lastExecution = lastExecutionBySchedule.get(
+							schedule.scheduleId,
+						);
+						const upcoming = upcomingRuns.find(
+							(item) => item.scheduleId === schedule.scheduleId,
+						);
+						return (
+							<div
+								key={schedule.scheduleId}
+								className="rounded-lg border border-border px-5 py-4 transition-colors hover:bg-accent/20"
+							>
+								<div className="flex items-center gap-3">
+									<Circle
+										className={cn(
+											"h-2.5 w-2.5 shrink-0",
+											schedule.enabled
+												? "fill-primary text-primary"
+												: "fill-muted-foreground/40 text-muted-foreground/40",
+										)}
+									/>
+									<h3 className="text-sm font-semibold text-foreground">
+										{schedule.name}
+									</h3>
+									<span className="rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{schedule.mode}
+									</span>
+									<span className="rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground">
+										{schedule.cronPattern}
+									</span>
+									<div className="flex-1" />
+									<div className="flex items-center gap-1">
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`View ${schedule.name}`}
+											onClick={() => {
+												window.alert(JSON.stringify(schedule, null, 2));
+											}}
+										>
+											<Eye className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Edit ${schedule.name}`}
+											onClick={() => openEditDialog(schedule)}
+											disabled={isBusy}
+										>
+											<Pencil className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Run ${schedule.name} now`}
+											onClick={() => void triggerSchedule(schedule.scheduleId)}
+											disabled={isBusy}
+										>
+											<Zap className="h-3.5 w-3.5" />
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={
+												schedule.enabled
+													? `Pause ${schedule.name}`
+													: `Resume ${schedule.name}`
+											}
+											onClick={() =>
+												void upsertScheduleEnabled(schedule, !schedule.enabled)
+											}
+											disabled={isBusy}
+										>
+											{schedule.enabled ? (
+												<Pause className="h-3.5 w-3.5" />
+											) : (
+												<Play className="h-3.5 w-3.5" />
+											)}
+										</Button>
+										<Button
+											variant="ghost"
+											size="icon-sm"
+											aria-label={`Delete ${schedule.name}`}
+											onClick={() => setSchedulePendingDelete(schedule)}
+											disabled={isBusy}
+										>
+											<Trash2 className="h-3.5 w-3.5" />
+										</Button>
+										<Switch
+											checked={schedule.enabled}
+											onCheckedChange={(checked) =>
+												void upsertScheduleEnabled(schedule, checked)
+											}
+											disabled={isBusy}
+											aria-label={`Enable ${schedule.name}`}
+										/>
+									</div>
+								</div>
+
+								<div className="mt-2.5 ml-5.5 flex flex-col gap-1 text-xs text-muted-foreground">
+									<p>
+										<span className="text-muted-foreground/70">ID:</span>{" "}
+										{schedule.scheduleId}
+									</p>
+									<p>
+										<span className="text-muted-foreground/70">Prompt:</span>{" "}
+										{schedule.prompt}
+									</p>
+									<p>
+										<span className="text-muted-foreground/70">Model:</span>{" "}
+										{formatScheduleModel(schedule)}
+									</p>
+									{schedule.workspaceRoot && (
+										<p>
+											<span className="text-muted-foreground/70">
+												Workspace:
+											</span>{" "}
+											{schedule.workspaceRoot}
+										</p>
+									)}
+									{schedule.cwd && (
+										<p>
+											<span className="text-muted-foreground/70">CWD:</span>{" "}
+											{schedule.cwd}
+										</p>
+									)}
+									<p>
+										<span className="text-muted-foreground/70">Last run:</span>{" "}
+										{formatDateTime(schedule.lastRunAt)}
+									</p>
+									<p>
+										<span className="text-muted-foreground/70">
+											Last result:
+										</span>{" "}
+										{formatExecutionResult(lastExecution)}
+									</p>
+									{lastExecution?.sessionId && (
+										<p>
+											<span className="text-muted-foreground/70">
+												Last session:
+											</span>{" "}
+											{lastExecution.sessionId}
+										</p>
+									)}
+									{lastExecution?.errorMessage && (
+										<p className="text-destructive">
+											<span className="text-muted-foreground/70">
+												Last error:
+											</span>{" "}
+											{lastExecution.errorMessage}
+										</p>
+									)}
+									<p>
+										<span className="text-muted-foreground/70">Next run:</span>{" "}
+										{formatDateTime(schedule.nextRunAt || upcoming?.nextRunAt)}
+									</p>
+									{activeExecution && (
+										<p>
+											<span className="text-muted-foreground/70">Active:</span>{" "}
+											{activeExecution.executionId} since{" "}
+											{formatDateTime(activeExecution.startedAt)}
+										</p>
+									)}
+									{schedule.tags && schedule.tags.length > 0 && (
+										<p>
+											<span className="text-muted-foreground/70">Tags:</span>{" "}
+											{schedule.tags.join(", ")}
+										</p>
+									)}
+								</div>
+							</div>
+						);
+					})}
+				</div>
+			)}
+			<AlertDialog
+				open={Boolean(schedulePendingDelete)}
+				onOpenChange={(open) => {
+					if (!open) {
+						setSchedulePendingDelete(null);
+					}
+				}}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete Routine</AlertDialogTitle>
+						<AlertDialogDescription>
+							This will delete "{schedulePendingDelete?.name ?? "this routine"}"
+							and remove future scheduled runs.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel
+							disabled={
+								schedulePendingDelete
+									? busyScheduleId === schedulePendingDelete.scheduleId
+									: false
+							}
+						>
+							Cancel
+						</AlertDialogCancel>
+						<AlertDialogAction
+							disabled={
+								!schedulePendingDelete ||
+								busyScheduleId === schedulePendingDelete.scheduleId
+							}
+							onClick={() => {
+								if (schedulePendingDelete) {
+									void deleteSchedule(schedulePendingDelete.scheduleId);
+								}
+							}}
+							className={buttonVariants({ variant: "destructive" })}
+						>
+							Delete
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
+			<Dialog
+				open={isCreateOpen}
+				onOpenChange={(open) => {
+					setIsCreateOpen(open);
+					if (!open) {
+						setCreateFormError(null);
+						setEditingSchedule(null);
+					}
+				}}
+			>
+				<DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-2xl">
+					<DialogHeader>
+						<DialogTitle>
+							{editingSchedule ? "Edit Routine" : "Create Routine"}
+						</DialogTitle>
+						<DialogDescription>
+							{editingSchedule
+								? "Update this scheduler routine."
+								: "Create a scheduler routine."}
+						</DialogDescription>
+					</DialogHeader>
+
+					<div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-name">Name</Label>
+							<Input
+								id="routine-name"
+								value={createForm.name}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										name: event.target.value,
+									}))
+								}
+								placeholder="Daily code review"
+							/>
+						</div>
+
+						<div className="sm:col-span-2 space-y-3">
+							<Label>Schedule</Label>
+							<div className="grid grid-cols-1 gap-3 rounded-md border border-border p-3 sm:grid-cols-2">
+								<div>
+									<Label htmlFor="routine-hour">Hour</Label>
+									<Select
+										value={createForm.scheduleHour}
+										onValueChange={(value) =>
+											setCreateForm((prev) => ({
+												...prev,
+												scheduleHour: value ?? prev.scheduleHour,
+											}))
+										}
+									>
+										<SelectTrigger className="w-full" id="routine-hour">
+											<SelectValue placeholder="Hour" />
+										</SelectTrigger>
+										<SelectContent>
+											{Array.from({ length: 24 }, (_, idx) => idx).map(
+												(hour) => (
+													<SelectItem key={`hour-${hour}`} value={`${hour}`}>
+														{hour.toString().padStart(2, "0")}
+													</SelectItem>
+												),
+											)}
+										</SelectContent>
+									</Select>
+								</div>
+								<div>
+									<Label htmlFor="routine-minute">Minute</Label>
+									<Select
+										value={createForm.scheduleMinute}
+										onValueChange={(value) =>
+											setCreateForm((prev) => ({
+												...prev,
+												scheduleMinute: value ?? prev.scheduleMinute,
+											}))
+										}
+									>
+										<SelectTrigger className="w-full" id="routine-minute">
+											<SelectValue placeholder="Minute" />
+										</SelectTrigger>
+										<SelectContent>
+											{Array.from({ length: 60 }, (_, minute) => minute).map(
+												(minute) => {
+													return (
+														<SelectItem
+															key={`minute-${minute}`}
+															value={`${minute}`}
+														>
+															{minute.toString().padStart(2, "0")}
+														</SelectItem>
+													);
+												},
+											)}
+										</SelectContent>
+									</Select>
+								</div>
+								<div className="sm:col-span-2">
+									<Label>Days of week</Label>
+									<div className="mt-2 grid grid-cols-2 gap-2 sm:grid-cols-4">
+										{WEEKDAY_OPTIONS.map((day) => {
+											const inputId = `routine-day-${day.value.toLowerCase()}`;
+											const checked = createForm.scheduleDays.includes(
+												day.value,
+											);
+											return (
+												<Label
+													className="flex items-center gap-2 rounded-md border border-border px-2 py-1.5 text-sm"
+													htmlFor={inputId}
+													key={day.value}
+												>
+													<Checkbox
+														checked={checked}
+														id={inputId}
+														onCheckedChange={(value) =>
+															setCreateForm((prev) => {
+																const nextSet = new Set(prev.scheduleDays);
+																if (value === true) {
+																	nextSet.add(day.value);
+																} else {
+																	nextSet.delete(day.value);
+																}
+																return {
+																	...prev,
+																	scheduleDays: normalizeScheduleDays([
+																		...nextSet,
+																	]),
+																};
+															})
+														}
+													/>
+													{day.label}
+												</Label>
+											);
+										})}
+									</div>
+								</div>
+								<div className="sm:col-span-2 rounded-md border border-border bg-muted/30 px-2 py-1.5 text-xs text-muted-foreground">
+									Cron:{" "}
+									<span className="font-mono text-foreground">
+										{cronPreview || "Select one or more days"}
+									</span>
+								</div>
+							</div>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-prompt">Prompt</Label>
+							<Textarea
+								id="routine-prompt"
+								value={createForm.prompt}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										prompt: event.target.value,
+									}))
+								}
+								rows={4}
+							/>
+						</div>
+
+						<div>
+							<Label>Provider</Label>
+							<Combobox
+								items={availableProviders}
+								onValueChange={(value) => {
+									if (!value) {
+										return;
+									}
+									const providerModelsForNext =
+										visibleProviderModels[value] ?? [];
+									const rememberedModel =
+										lastModelSelection.lastModelByProvider[value];
+									const nextModel =
+										rememberedModel &&
+										providerModelsForNext.includes(rememberedModel)
+											? rememberedModel
+											: (providerModelsForNext[0] ?? "");
+									setCreateForm((prev) => ({
+										...prev,
+										provider: value,
+										model: nextModel,
+									}));
+								}}
+								value={createForm.provider}
+							>
+								<ComboboxInput
+									className="h-9 w-full"
+									readOnly
+									showClear={false}
+									showTrigger
+								/>
+								<ComboboxContent>
+									<ComboboxEmpty>No providers found.</ComboboxEmpty>
+									<ComboboxList>
+										{(item) => (
+											<ComboboxItem key={item} value={item}>
+												{item}
+											</ComboboxItem>
+										)}
+									</ComboboxList>
+								</ComboboxContent>
+							</Combobox>
+						</div>
+
+						<div>
+							<Label>Model</Label>
+							<Combobox
+								items={availableModelsForProvider}
+								onValueChange={(value) => {
+									if (!value) {
+										return;
+									}
+									setCreateForm((prev) => ({ ...prev, model: value }));
+								}}
+								value={createForm.model}
+							>
+								<ComboboxInput
+									className="h-9 w-full"
+									readOnly
+									showClear={false}
+									showTrigger
+								/>
+								<ComboboxContent>
+									<ComboboxEmpty>No models found.</ComboboxEmpty>
+									<ComboboxList>
+										{(item) => (
+											<ComboboxItem key={item} value={item}>
+												{item}
+											</ComboboxItem>
+										)}
+									</ComboboxList>
+								</ComboboxContent>
+							</Combobox>
+						</div>
+
+						<div>
+							<Label>Mode</Label>
+							<Select
+								value={createForm.mode}
+								onValueChange={(value) =>
+									setCreateForm((prev) => ({
+										...prev,
+										mode: value === "plan" ? "plan" : "act",
+									}))
+								}
+							>
+								<SelectTrigger className="w-full">
+									<SelectValue placeholder="Select mode" />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="act">act</SelectItem>
+									<SelectItem value="plan">plan</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-workspace">Workspace root</Label>
+							<Input
+								id="routine-workspace"
+								value={createForm.workspaceRoot}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										workspaceRoot: event.target.value,
+									}))
+								}
+							/>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-cwd">CWD (optional)</Label>
+							<Input
+								id="routine-cwd"
+								value={createForm.cwd}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										cwd: event.target.value,
+									}))
+								}
+							/>
+						</div>
+
+						<div className="sm:col-span-2">
+							<Label htmlFor="routine-system-prompt">
+								System prompt (optional)
+							</Label>
+							<Textarea
+								id="routine-system-prompt"
+								value={createForm.systemPrompt}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										systemPrompt: event.target.value,
+									}))
+								}
+								rows={3}
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-max-iterations">
+								Max iterations (optional)
+							</Label>
+							<Input
+								id="routine-max-iterations"
+								value={createForm.maxIterations}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										maxIterations: event.target.value,
+									}))
+								}
+								placeholder="50"
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-timeout">
+								Timeout seconds (optional)
+							</Label>
+							<Input
+								id="routine-timeout"
+								value={createForm.timeoutSeconds}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										timeoutSeconds: event.target.value,
+									}))
+								}
+								placeholder="3600"
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-max-parallel">Max parallel</Label>
+							<Input
+								id="routine-max-parallel"
+								value={createForm.maxParallel}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										maxParallel: event.target.value,
+									}))
+								}
+								placeholder="1"
+							/>
+						</div>
+
+						<div>
+							<Label htmlFor="routine-tags">
+								Tags (comma-separated, optional)
+							</Label>
+							<Input
+								id="routine-tags"
+								value={createForm.tags}
+								onChange={(event) =>
+									setCreateForm((prev) => ({
+										...prev,
+										tags: event.target.value,
+									}))
+								}
+								placeholder="automation,review"
+							/>
+						</div>
+					</div>
+
+					{createFormError && (
+						<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+							{createFormError}
+						</div>
+					)}
+
+					<DialogFooter>
+						<Button
+							variant="outline"
+							onClick={() => setIsCreateOpen(false)}
+							disabled={isCreating}
+						>
+							Cancel
+						</Button>
+						<Button
+							onClick={() => void submitCreateForm()}
+							disabled={isCreating}
+						>
+							{isCreating
+								? editingSchedule
+									? "Saving..."
+									: "Creating..."
+								: editingSchedule
+									? "Save Changes"
+									: "Create Schedule"}
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+		</PageFrame>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/settings-patch.ts b/apps/examples/desktop-app/webview/components/views/settings/settings-patch.ts
new file mode 100644
index 0000000..4a02475
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/settings-patch.ts
@@ -0,0 +1,32 @@
+import type { ProviderConfigFieldPrimitive } from "@/lib/provider-schema";
+
+function assignSettingsPath(
+	target: Record<string, unknown>,
+	path: string,
+	value: ProviderConfigFieldPrimitive,
+) {
+	const segments = path.split(".").filter(Boolean);
+	if (segments.length === 0) return;
+	let cursor = target;
+	for (const segment of segments.slice(0, -1)) {
+		const existing = cursor[segment];
+		if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+			cursor[segment] = {};
+		}
+		cursor = cursor[segment] as Record<string, unknown>;
+	}
+	const last = segments.at(-1);
+	if (last) {
+		cursor[last] = value;
+	}
+}
+
+export function toSettingsPatch(
+	values: Record<string, ProviderConfigFieldPrimitive>,
+): Record<string, unknown> {
+	const settings: Record<string, unknown> = {};
+	for (const [path, value] of Object.entries(values)) {
+		assignSettingsPath(settings, path, value);
+	}
+	return settings;
+}
diff --git a/apps/examples/desktop-app/webview/components/views/settings/settings-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/settings-view.tsx
new file mode 100644
index 0000000..ebc222e
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/views/settings/settings-view.tsx
@@ -0,0 +1,521 @@
+import { X } from "lucide-react";
+import { useCallback, useEffect, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Switch } from "@/components/ui/switch";
+import { desktopClient } from "@/lib/desktop-client";
+import type {
+	Provider,
+	ProviderCatalogResponse,
+	ProviderModelsResponse,
+	ProviderSettingsUpdate,
+} from "@/lib/provider-schema";
+import {
+	type HubTheme,
+	readStoredHubTheme,
+	readSystemHubTheme,
+	setStoredHubTheme,
+} from "@/lib/theme";
+import { cn } from "@/lib/utils";
+import { PageFrame, PageHeader } from "../page-layout";
+import { AccountView } from "./account-view";
+import { AddProviderContent, type AddProviderPayload } from "./add-provider";
+import { ChannelsContent } from "./channels-view";
+import { CustomizationSectionView, RulesView } from "./extensions-view";
+import { McpServersContent } from "./mcp-view";
+import {
+	ProviderDetailContent,
+	ProviderListContent,
+} from "./provider-list-view";
+import { RoutineSchedulesContent } from "./routine-view";
+import { toSettingsPatch } from "./settings-patch";
+
+// -----------------------------------------------------------
+// Settings nav categories
+// -----------------------------------------------------------
+
+const navCategories = [
+	"General",
+	"Providers",
+	"MCP",
+	"Marketplace",
+	"Extensions",
+	"Channels",
+	"Schedules",
+	"Account",
+] as const;
+
+export type SettingsSection = (typeof navCategories)[number];
+
+const PROVIDER_CATALOG_CACHE_TTL_MS = 60_000;
+
+let providerCatalogCache: {
+	providers: Provider[];
+	fetchedAt: number;
+} | null = null;
+
+// -----------------------------------------------------------
+// Component
+// -----------------------------------------------------------
+
+export function SettingsView({
+	chrome = "full",
+	initialSection = "General",
+	onClose,
+	onNavigateSection,
+}: {
+	chrome?: "full" | "content";
+	initialSection?: SettingsSection;
+	onClose: () => void;
+	onNavigateSection?: (section: SettingsSection) => void;
+}) {
+	const [activeNav, setActiveNav] = useState<SettingsSection>(initialSection);
+	const [providers, setProviders] = useState<Provider[]>(
+		() => providerCatalogCache?.providers ?? [],
+	);
+	const [providersLoading, setProvidersLoading] = useState(
+		() => !providerCatalogCache,
+	);
+	const [providerCatalogError, setProviderCatalogError] = useState<
+		string | null
+	>(null);
+	const [modelsLoadingByProvider, setModelsLoadingByProvider] = useState<
+		Record<string, boolean>
+	>({});
+	const [modelsErrorByProvider, setModelsErrorByProvider] = useState<
+		Record<string, string | null>
+	>({});
+	const [oauthSigningProviderId, setOauthSigningProviderId] = useState<
+		string | null
+	>(null);
+	const [selectedProviderId, setSelectedProviderId] = useState<string | null>(
+		null,
+	);
+	const [addingProvider, setAddingProvider] = useState(false);
+
+	const setProvidersWithCache = useCallback(
+		(next: Provider[] | ((prev: Provider[]) => Provider[])) => {
+			setProviders((prev) => {
+				const resolved =
+					typeof next === "function"
+						? (next as (prev: Provider[]) => Provider[])(prev)
+						: next;
+				providerCatalogCache = {
+					providers: resolved,
+					fetchedAt: Date.now(),
+				};
+				return resolved;
+			});
+		},
+		[],
+	);
+
+	const loadProviderCatalog = useCallback(async () => {
+		const now = Date.now();
+		if (
+			providerCatalogCache &&
+			now - providerCatalogCache.fetchedAt < PROVIDER_CATALOG_CACHE_TTL_MS
+		) {
+			setProviders(providerCatalogCache.providers);
+			setProvidersLoading(false);
+			setProviderCatalogError(null);
+			return;
+		}
+
+		setProvidersLoading(true);
+		setProviderCatalogError(null);
+		try {
+			const payload = await desktopClient.invoke<ProviderCatalogResponse>(
+				"list_provider_catalog",
+			);
+			setProvidersWithCache(payload.providers);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			setProviderCatalogError(message);
+			setProviders([]);
+		} finally {
+			setProvidersLoading(false);
+		}
+	}, [setProvidersWithCache]);
+
+	useEffect(() => {
+		if (activeNav !== "Providers") {
+			return;
+		}
+		const timeoutId = window.setTimeout(() => {
+			void loadProviderCatalog();
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [activeNav, loadProviderCatalog]);
+
+	const persistProviderSettings = useCallback(
+		async (
+			id: string,
+			updates: {
+				enabled?: boolean;
+				apiKey?: string;
+				baseUrl?: string;
+				configValues?: ProviderSettingsUpdate["configValues"];
+			},
+		) => {
+			try {
+				await desktopClient.invoke("save_provider_settings", {
+					provider: id,
+					enabled: updates.enabled,
+					api_key: updates.apiKey,
+					base_url: updates.baseUrl,
+					settings: updates.configValues
+						? toSettingsPatch(updates.configValues)
+						: undefined,
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				window.alert(`Failed to save provider settings for ${id}: ${message}`);
+			}
+		},
+		[],
+	);
+
+	const toggleProvider = useCallback(
+		(id: string) => {
+			setProvidersWithCache((prev) =>
+				prev.map((p) => {
+					if (p.id !== id) {
+						return p;
+					}
+					const nextEnabled = !p.enabled;
+					void persistProviderSettings(id, { enabled: nextEnabled });
+					return { ...p, enabled: nextEnabled };
+				}),
+			);
+		},
+		[persistProviderSettings, setProvidersWithCache],
+	);
+
+	const updateProvider = useCallback(
+		(id: string, updates: ProviderSettingsUpdate) => {
+			setProvidersWithCache((prev) =>
+				prev.map((p) =>
+					p.id === id
+						? {
+								...p,
+								...updates,
+								configValues: updates.configValues
+									? {
+											...(p.configValues ?? {}),
+											...updates.configValues,
+										}
+									: p.configValues,
+							}
+						: p,
+				),
+			);
+			void persistProviderSettings(id, {
+				apiKey: updates.apiKey,
+				baseUrl: updates.baseUrl,
+				configValues: updates.configValues,
+			});
+		},
+		[persistProviderSettings, setProvidersWithCache],
+	);
+
+	const loadProviderModels = useCallback(
+		async (id: string) => {
+			setModelsLoadingByProvider((prev) => ({ ...prev, [id]: true }));
+			setModelsErrorByProvider((prev) => ({ ...prev, [id]: null }));
+			try {
+				const payload = await desktopClient.invoke<ProviderModelsResponse>(
+					"list_provider_models",
+					{
+						provider: id,
+					},
+				);
+				setProvidersWithCache((prev) =>
+					prev.map((provider) =>
+						provider.id === id
+							? {
+									...provider,
+									modelList: payload.models,
+									models: payload.models.length,
+								}
+							: provider,
+					),
+				);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				setModelsErrorByProvider((prev) => ({ ...prev, [id]: message }));
+			} finally {
+				setModelsLoadingByProvider((prev) => ({ ...prev, [id]: false }));
+			}
+		},
+		[setProvidersWithCache],
+	);
+
+	const selectedProvider = selectedProviderId
+		? (providers.find((p) => p.id === selectedProviderId) ?? null)
+		: null;
+
+	const usesOAuth = (provider: Provider) =>
+		provider.capabilities?.includes("oauth") ?? false;
+
+	const runOAuthProviderLogin = async (id: string) => {
+		setOauthSigningProviderId(id);
+		try {
+			const result = await desktopClient.invoke<{
+				provider: string;
+				accessToken: string;
+			}>("run_provider_oauth_login", {
+				provider: id,
+			});
+			setProvidersWithCache((prev) =>
+				prev.map((provider) =>
+					provider.id === id
+						? {
+								...provider,
+								enabled: true,
+								oauthAccessTokenPresent: result.accessToken.trim().length > 0,
+							}
+						: provider,
+				),
+			);
+			setSelectedProviderId(id);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			window.alert(`Failed to sign in to ${id}: ${message}`);
+		} finally {
+			setOauthSigningProviderId(null);
+		}
+	};
+
+	const openProviderDetail = (id: string) => {
+		setActiveNav("Providers");
+		onNavigateSection?.("Providers");
+		setSelectedProviderId(id);
+	};
+
+	useEffect(() => {
+		if (!selectedProviderId) {
+			return;
+		}
+		const selected = providers.find(
+			(provider) => provider.id === selectedProviderId,
+		);
+		if (!selected || (selected.modelList?.length ?? 0) > 0) {
+			return;
+		}
+		const timeoutId = window.setTimeout(() => {
+			void loadProviderModels(selectedProviderId);
+		}, 0);
+		return () => window.clearTimeout(timeoutId);
+	}, [loadProviderModels, providers, selectedProviderId]);
+
+	const backToProviderList = () => {
+		onNavigateSection?.("Providers");
+		setSelectedProviderId(null);
+		setAddingProvider(false);
+	};
+
+	const saveNewProvider = useCallback(
+		async (payload: AddProviderPayload) => {
+			await desktopClient.invoke("add_provider", {
+				provider_id: payload.providerId,
+				name: payload.name,
+				base_url: payload.baseUrl,
+				api_key: payload.apiKey,
+				headers: payload.headers,
+				timeout_ms: payload.timeoutMs,
+				models: payload.models,
+				default_model_id: payload.defaultModelId,
+				models_source_url: payload.modelsSourceUrl,
+				capabilities: payload.capabilities,
+			});
+			await loadProviderCatalog();
+			setAddingProvider(false);
+			setSelectedProviderId(payload.providerId);
+		},
+		[loadProviderCatalog],
+	);
+
+	const openAddProvider = () => {
+		onNavigateSection?.("Providers");
+		setSelectedProviderId(null);
+		setAddingProvider(true);
+	};
+
+	const selectSection = (section: SettingsSection) => {
+		setActiveNav(section);
+		onNavigateSection?.(section);
+		setSelectedProviderId(null);
+		setAddingProvider(false);
+	};
+
+	const providerContent = addingProvider ? (
+		<AddProviderContent
+			existingProviderIds={providers.map((provider) => provider.id)}
+			onBack={backToProviderList}
+			onSave={saveNewProvider}
+		/>
+	) : providersLoading ? (
+		<div className="flex h-full items-center justify-center">
+			<p className="text-sm text-muted-foreground">Loading providers...</p>
+		</div>
+	) : providerCatalogError ? (
+		<div className="flex h-full items-center justify-center">
+			<p className="max-w-xl px-4 text-center text-sm text-destructive">
+				Failed to load providers: {providerCatalogError}
+			</p>
+		</div>
+	) : selectedProvider ? (
+		<div className="grid h-full grid-cols-[minmax(24rem,0.95fr)_minmax(28rem,1.05fr)] overflow-hidden max-[1100px]:grid-cols-1 max-[1100px]:grid-rows-[minmax(24rem,0.9fr)_minmax(26rem,1fr)]">
+			<ProviderListContent
+				onAddProvider={openAddProvider}
+				onConfigure={openProviderDetail}
+				onToggle={toggleProvider}
+				providers={providers}
+				selectedProviderId={selectedProvider.id}
+				variant="panel"
+			/>
+			<aside className="min-h-0 overflow-hidden border-l bg-background max-[1100px]:border-l-0 max-[1100px]:border-t">
+				<ProviderDetailContent
+					modelsError={modelsErrorByProvider[selectedProvider.id] ?? null}
+					modelsLoading={modelsLoadingByProvider[selectedProvider.id] ?? false}
+					oauthLoginPending={oauthSigningProviderId === selectedProvider.id}
+					onBack={backToProviderList}
+					onLoadModels={() => void loadProviderModels(selectedProvider.id)}
+					onOAuthLogin={
+						usesOAuth(selectedProvider)
+							? () => void runOAuthProviderLogin(selectedProvider.id)
+							: undefined
+					}
+					onUpdate={(updates) => updateProvider(selectedProvider.id, updates)}
+					provider={selectedProvider}
+					variant="panel"
+				/>
+			</aside>
+		</div>
+	) : (
+		<ProviderListContent
+			onAddProvider={openAddProvider}
+			onConfigure={openProviderDetail}
+			onToggle={toggleProvider}
+			providers={providers}
+		/>
+	);
+
+	const content =
+		activeNav === "Providers" ? (
+			providerContent
+		) : activeNav === "MCP" ? (
+			<McpServersContent />
+		) : activeNav === "Marketplace" ? (
+			<CustomizationSectionView catalogPrimitive="mcp" section="MCP" />
+		) : activeNav === "Extensions" ? (
+			<RulesView />
+		) : activeNav === "Channels" ? (
+			<ChannelsContent />
+		) : activeNav === "Schedules" ? (
+			<RoutineSchedulesContent />
+		) : activeNav === "Account" ? (
+			<AccountView />
+		) : activeNav === "General" ? (
+			<GeneralSettingsContent />
+		) : (
+			<div className="flex h-full items-center justify-center">
+				<p className="text-sm text-muted-foreground">
+					{activeNav} settings coming soon.
+				</p>
+			</div>
+		);
+
+	if (chrome === "content") {
+		return (
+			<div className="h-full overflow-hidden bg-background">{content}</div>
+		);
+	}
+
+	return (
+		<div className="flex h-full flex-col overflow-hidden bg-background">
+			{/* Header bar */}
+			<div className="flex shrink-0 items-center justify-between border-b border-border px-6 py-3">
+				<h1 className="text-lg font-semibold text-foreground">Settings</h1>
+				<Button
+					aria-label="Close settings"
+					className="justify-start"
+					onClick={onClose}
+					variant="ghost"
+				>
+					<X className="size-3" />
+				</Button>
+			</div>
+
+			{/* Body */}
+			<div className="flex flex-1 overflow-hidden">
+				{/* Settings sidebar nav */}
+				<nav className="w-56 shrink-0 border-r border-border">
+					<ScrollArea className="h-full">
+						<div className="flex flex-col gap-0.5 p-3">
+							{navCategories.map((cat) => (
+								<Button
+									className={cn(
+										"justify-start",
+										activeNav === cat
+											? "bg-accent text-accent-foreground font-medium"
+											: "text-muted-foreground hover:bg-accent/50 hover:text-foreground",
+									)}
+									key={cat}
+									onClick={() => {
+										selectSection(cat);
+									}}
+									variant="ghost"
+								>
+									{cat}
+								</Button>
+							))}
+						</div>
+					</ScrollArea>
+				</nav>
+
+				{/* Content area */}
+				<div className="flex-1 overflow-hidden">{content}</div>
+			</div>
+		</div>
+	);
+}
+
+function GeneralSettingsContent() {
+	const [theme, setTheme] = useState<HubTheme>(() => {
+		if (typeof window === "undefined") return "light";
+		return readStoredHubTheme() ?? readSystemHubTheme();
+	});
+
+	const updateTheme = (darkModeEnabled: boolean) => {
+		const nextTheme = darkModeEnabled ? "dark" : "light";
+		setTheme(setStoredHubTheme(nextTheme));
+	};
+
+	return (
+		<PageFrame>
+			<PageHeader
+				description="Manage desktop preferences for this browser and CLI environment."
+				title="Settings"
+			/>
+			<section className="max-w-[86rem]">
+				<div className="flex min-h-20 items-center justify-between gap-5 border-b max-[720px]:flex-col max-[720px]:items-stretch max-[720px]:py-4">
+					<div>
+						<p className="text-[17px] font-semibold text-foreground">
+							Dark mode
+						</p>
+						<p className="mt-1 text-[15px] text-muted-foreground">
+							Keep the desktop interface in dark mode on this browser.
+						</p>
+					</div>
+					<Switch
+						aria-label="Dark mode"
+						checked={theme === "dark"}
+						onCheckedChange={updateTheme}
+					/>
+				</div>
+			</section>
+		</PageFrame>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/contexts/workspace-context.tsx b/apps/examples/desktop-app/webview/contexts/workspace-context.tsx
new file mode 100644
index 0000000..a238a92
--- /dev/null
+++ b/apps/examples/desktop-app/webview/contexts/workspace-context.tsx
@@ -0,0 +1,36 @@
+"use client";
+
+import { createContext, useContext } from "react";
+
+type WorkspaceContextValue = {
+	workspaceRoot: string;
+	workspaces: string[];
+	listWorkspaces: () => Promise<string[]>;
+	refreshWorkspaces: () => Promise<void>;
+	switchWorkspace: (workspacePath: string) => Promise<boolean>;
+	pickWorkspaceDirectory: (initialPath?: string) => Promise<string | null>;
+};
+
+const WorkspaceContext = createContext<WorkspaceContextValue | null>(null);
+
+export function WorkspaceProvider({
+	children,
+	value,
+}: {
+	children: React.ReactNode;
+	value: WorkspaceContextValue;
+}) {
+	return (
+		<WorkspaceContext.Provider value={value}>
+			{children}
+		</WorkspaceContext.Provider>
+	);
+}
+
+export function useWorkspace(): WorkspaceContextValue {
+	const ctx = useContext(WorkspaceContext);
+	if (!ctx) {
+		throw new Error("useWorkspace must be used within a WorkspaceProvider");
+	}
+	return ctx;
+}
diff --git a/apps/examples/desktop-app/webview/hooks/chat-session/attachments.ts b/apps/examples/desktop-app/webview/hooks/chat-session/attachments.ts
new file mode 100644
index 0000000..b955afb
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/chat-session/attachments.ts
@@ -0,0 +1,40 @@
+import type { SerializedAttachmentFile, SerializedAttachments } from "./types";
+
+async function readFileAsDataUrl(file: File): Promise<string> {
+	return await new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => {
+			const value = typeof reader.result === "string" ? reader.result : "";
+			resolve(value);
+		};
+		reader.onerror = () => {
+			reject(reader.error ?? new Error("failed reading file"));
+		};
+		reader.readAsDataURL(file);
+	});
+}
+
+export async function serializeAttachments(
+	files: File[],
+): Promise<SerializedAttachments> {
+	const userImages: string[] = [];
+	const userFiles: SerializedAttachmentFile[] = [];
+
+	for (const file of files) {
+		if (file.type.startsWith("image/")) {
+			const dataUrl = await readFileAsDataUrl(file);
+			if (dataUrl) {
+				userImages.push(dataUrl);
+			}
+			continue;
+		}
+
+		const content = await file.text();
+		userFiles.push({
+			name: file.name,
+			content,
+		});
+	}
+
+	return { userImages, userFiles };
+}
diff --git a/apps/examples/desktop-app/webview/hooks/chat-session/constants.ts b/apps/examples/desktop-app/webview/hooks/chat-session/constants.ts
new file mode 100644
index 0000000..3e047db
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/chat-session/constants.ts
@@ -0,0 +1,63 @@
+import type { ChatSessionConfig } from "@/lib/chat-schema";
+import { readModelSelectionStorageFromWindow } from "@/lib/model-selection";
+import { normalizeProviderId } from "@/lib/provider-id";
+
+export const CHAT_TRANSPORT_UNAVAILABLE_MESSAGE =
+	"Chat connection is unavailable. Reopen the app window to restore realtime chat.";
+export const CHAT_WS_ENDPOINT_RETRY_ATTEMPTS = 60;
+export const CHAT_WS_ENDPOINT_RETRY_DELAY_MS = 100;
+export const CHAT_WS_RECONNECT_BASE_DELAY_MS = 300;
+export const CHAT_WS_RECONNECT_MAX_DELAY_MS = 3000;
+export const CHAT_WS_REQUEST_TIMEOUT_MS = 120000;
+export const OAUTH_MANAGED_PROVIDERS = new Set([
+	"cline",
+	"oca",
+	"openai-codex",
+]);
+
+// Default Cline model — keep in sync with @cline/llms CLINE_DEFAULT_MODEL
+const CLINE_DEFAULT_MODEL = "anthropic/claude-sonnet-4.6";
+
+export const DEFAULT_CHAT_CONFIG: ChatSessionConfig = {
+	sessionId: undefined,
+	workspaceRoot: "",
+	cwd: "",
+	provider: "cline",
+	model: CLINE_DEFAULT_MODEL,
+	apiKey: process.env.CLINE_API_KEY || "",
+	mode: "act",
+	systemPrompt: undefined,
+	maxIterations: undefined,
+	thinking: undefined,
+	reasoningEffort: undefined,
+	enableTools: true,
+	enableSpawn: undefined,
+	enableTeams: undefined,
+	autoApproveTools: true,
+	missionStepInterval: undefined,
+	missionTimeIntervalMs: undefined,
+};
+
+export function getInitialChatConfig(): ChatSessionConfig {
+	const selection = readModelSelectionStorageFromWindow();
+	const rememberedProvider = normalizeProviderId(selection.lastProvider);
+	const rememberedModelForProvider = rememberedProvider
+		? (selection.lastModelByProvider[rememberedProvider] ??
+			selection.lastModelByProvider[selection.lastProvider.trim()])
+		: undefined;
+	const rememberedModelForDefaultProvider =
+		selection.lastModelByProvider[DEFAULT_CHAT_CONFIG.provider];
+	const provider = rememberedProvider || DEFAULT_CHAT_CONFIG.provider;
+	const model =
+		rememberedModelForProvider ||
+		(provider === DEFAULT_CHAT_CONFIG.provider
+			? rememberedModelForDefaultProvider
+			: undefined) ||
+		DEFAULT_CHAT_CONFIG.model;
+
+	return {
+		...DEFAULT_CHAT_CONFIG,
+		provider,
+		model,
+	};
+}
diff --git a/apps/examples/desktop-app/webview/hooks/chat-session/helpers.ts b/apps/examples/desktop-app/webview/hooks/chat-session/helpers.ts
new file mode 100644
index 0000000..b5cdb75
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/chat-session/helpers.ts
@@ -0,0 +1,190 @@
+import type {
+	ChatMessage,
+	ChatSessionConfig,
+	ChatSessionStatus,
+} from "@/lib/chat-schema";
+import type { SessionHistoryStatus } from "@/lib/session-history";
+import { OAUTH_MANAGED_PROVIDERS } from "./constants";
+
+type RpcMessageLike = {
+	role?: string;
+	content?: unknown;
+};
+
+export function makeId(prefix: string): string {
+	return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function stringifyRpcMessageContent(content: unknown): string {
+	if (typeof content === "string") {
+		return content;
+	}
+	if (Array.isArray(content)) {
+		const parts: string[] = [];
+		for (const block of content) {
+			if (typeof block === "string") {
+				if (block.trim()) {
+					parts.push(block);
+				}
+				continue;
+			}
+			if (!block || typeof block !== "object") {
+				continue;
+			}
+			const obj = block as Record<string, unknown>;
+			const text = obj.text;
+			if (typeof text === "string" && text.trim()) {
+				parts.push(text);
+			}
+		}
+		return parts.join("\n");
+	}
+	if (content && typeof content === "object") {
+		const obj = content as Record<string, unknown>;
+		const text = obj.text;
+		if (typeof text === "string") {
+			return text;
+		}
+	}
+	return "";
+}
+
+export function extractAssistantTextFromRpcMessages(messages: unknown): string {
+	return extractAssistantTurnDataFromRpcMessages(messages).text;
+}
+
+export function extractAssistantTurnDataFromRpcMessages(messages: unknown): {
+	text: string;
+	reasoning: string;
+	reasoningRedacted: boolean;
+} {
+	if (!Array.isArray(messages)) {
+		return { text: "", reasoning: "", reasoningRedacted: false };
+	}
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const message = messages[i] as RpcMessageLike;
+		if (message?.role !== "assistant") {
+			continue;
+		}
+		const reasoningParts: string[] = [];
+		let reasoningRedacted = false;
+		if (Array.isArray(message.content)) {
+			for (const block of message.content) {
+				if (!block || typeof block !== "object") {
+					continue;
+				}
+				const obj = block as Record<string, unknown>;
+				if (obj.type === "thinking") {
+					const thinking =
+						typeof obj.thinking === "string" ? obj.thinking.trim() : "";
+					if (thinking) {
+						reasoningParts.push(thinking);
+					}
+					continue;
+				}
+				if (obj.type === "redacted_thinking") {
+					reasoningRedacted = true;
+				}
+			}
+		}
+		return {
+			text: stringifyRpcMessageContent(message.content).trim(),
+			reasoning: reasoningParts.join("\n").trim(),
+			reasoningRedacted,
+		};
+	}
+	return { text: "", reasoning: "", reasoningRedacted: false };
+}
+
+export function buildToolPayloadString(options: {
+	toolName: string;
+	input: unknown;
+	output: unknown;
+	error?: string;
+}): string {
+	const { toolName, input, output, error } = options;
+	return JSON.stringify({
+		toolName,
+		input,
+		result: error ? error : output,
+		isError: Boolean(error),
+	});
+}
+
+export function normalizeRuntimeConfig(
+	config: ChatSessionConfig,
+): ChatSessionConfig {
+	const normalizedWorkspaceRoot = config.workspaceRoot.trim();
+	const normalizedCwd = (config.cwd?.trim() || normalizedWorkspaceRoot).trim();
+	const thinking = config.reasoningEffort ? true : config.thinking;
+	return {
+		...config,
+		workspaceRoot: normalizedWorkspaceRoot,
+		cwd: normalizedCwd || normalizedWorkspaceRoot,
+		thinking,
+		reasoningEffort: thinking === false ? undefined : config.reasoningEffort,
+		enableSpawn: false,
+		enableTeams: false,
+	};
+}
+
+export function resolveCredentialError(
+	config: ChatSessionConfig,
+): string | null {
+	const providerId = config.provider.trim().toLowerCase();
+	if (!providerId) {
+		return "Provider is required before starting a chat session.";
+	}
+	if (OAUTH_MANAGED_PROVIDERS.has(providerId)) {
+		return null;
+	}
+	if (config.apiKey.trim().length > 0) {
+		return null;
+	}
+	return `Missing API key for provider "${config.provider}". Add credentials in Settings, or switch providers.`;
+}
+
+function mapHistoryStatusToChatStatus(
+	status: SessionHistoryStatus,
+): ChatSessionStatus {
+	switch (status) {
+		case "running":
+			return "running";
+		case "completed":
+			return "completed";
+		case "failed":
+			return "failed";
+		case "cancelled":
+			return "cancelled";
+		default:
+			return "idle";
+	}
+}
+
+export function inferHydratedChatStatus(
+	fallback: SessionHistoryStatus,
+	messages: ChatMessage[],
+): ChatSessionStatus {
+	if (fallback === "failed") {
+		return "failed";
+	}
+	if (fallback === "cancelled") {
+		return "cancelled";
+	}
+	const meaningfulMessages = messages.filter((message) => {
+		if (message.role !== "user" && message.role !== "assistant") {
+			return false;
+		}
+		return message.content.trim().length > 0;
+	});
+	if (meaningfulMessages.length === 0) {
+		return mapHistoryStatusToChatStatus(fallback);
+	}
+	if (fallback === "running") {
+		const lastMeaningful = meaningfulMessages[meaningfulMessages.length - 1];
+		if (lastMeaningful?.role === "assistant") {
+			return "completed";
+		}
+	}
+	return mapHistoryStatusToChatStatus(fallback);
+}
diff --git a/apps/examples/desktop-app/webview/hooks/chat-session/types.ts b/apps/examples/desktop-app/webview/hooks/chat-session/types.ts
new file mode 100644
index 0000000..be4dcf3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/chat-session/types.ts
@@ -0,0 +1,136 @@
+import type { SessionHookEvent } from "@/lib/session-diff";
+
+export type ProcessContext = {
+	workspaceRoot: string;
+	cwd: string;
+};
+
+export type AgentChunkEvent = {
+	sessionId: string;
+	stream: string;
+	chunk: string;
+	ts: number;
+	index?: number;
+};
+
+export type ReasoningDeltaEvent = {
+	text?: string;
+	redacted?: boolean;
+};
+
+export type ToolCallStartEvent = {
+	toolCallId?: string;
+	toolName?: string;
+	input?: unknown;
+};
+
+export type ToolCallEndEvent = {
+	toolCallId?: string;
+	toolName?: string;
+	input?: unknown;
+	output?: unknown;
+	error?: string;
+	durationMs?: number;
+};
+
+export type ToolApprovalRequestItem = {
+	requestId: string;
+	sessionId: string;
+	createdAt: string;
+	toolCallId: string;
+	toolName: string;
+	input?: unknown;
+	iteration?: number;
+	agentId?: string;
+	conversationId?: string;
+};
+
+export type AskQuestionRequestItem = {
+	requestId: string;
+	createdAt: string;
+	question: string;
+	options: string[];
+	context?: {
+		agentId?: string;
+		conversationId?: string;
+		iteration?: number;
+		metadata?: Record<string, unknown>;
+	};
+};
+
+export type ChatApiResult = {
+	text: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		totalCost?: number;
+	};
+	iterations?: number;
+	finishReason?:
+		| "completed"
+		| "max_iterations"
+		| "aborted"
+		| "mistake_limit"
+		| "error";
+	toolCalls?: Array<{
+		name: string;
+		input?: unknown;
+		output?: unknown;
+		error?: string;
+		durationMs?: number;
+	}>;
+	messages?: unknown[];
+};
+
+export type ChatWsResponseEvent = {
+	type: "chat_response";
+	requestId: string;
+	response?: {
+		sessionId?: string;
+		result?: ChatApiResult;
+		ok?: boolean;
+		queued?: boolean;
+	};
+	error?: string;
+};
+
+export type ChatWsChunkEvent = {
+	type: "chat_event";
+	event: AgentChunkEvent;
+};
+
+export type ChatTransportState =
+	| "connecting"
+	| "reconnecting"
+	| "connected"
+	| "unavailable";
+
+export type CoreLogChunk = {
+	level?: string;
+	message?: string;
+	metadata?: unknown;
+};
+
+export type ChatSessionHookEvent = SessionHookEvent & {
+	inputTokens?: number;
+	outputTokens?: number;
+};
+
+export type SerializedAttachmentFile = {
+	name: string;
+	content: string;
+};
+
+export type SerializedAttachments = {
+	userImages: string[];
+	userFiles: SerializedAttachmentFile[];
+};
+
+export type PromptInQueue = {
+	id: string;
+	prompt: string;
+	steer: boolean;
+	attachmentCount?: number;
+};
diff --git a/apps/examples/desktop-app/webview/hooks/use-chat-session.ts b/apps/examples/desktop-app/webview/hooks/use-chat-session.ts
new file mode 100644
index 0000000..cf355eb
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/use-chat-session.ts
@@ -0,0 +1,1751 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { serializeAttachments } from "@/hooks/chat-session/attachments";
+import { getInitialChatConfig } from "@/hooks/chat-session/constants";
+import {
+	buildToolPayloadString,
+	extractAssistantTurnDataFromRpcMessages,
+	inferHydratedChatStatus,
+	makeId,
+	normalizeRuntimeConfig,
+	resolveCredentialError,
+} from "@/hooks/chat-session/helpers";
+import type {
+	AgentChunkEvent,
+	AskQuestionRequestItem,
+	ChatApiResult,
+	ChatSessionHookEvent,
+	ChatTransportState,
+	CoreLogChunk,
+	ProcessContext,
+	PromptInQueue,
+	ReasoningDeltaEvent,
+	ToolApprovalRequestItem,
+	ToolCallEndEvent,
+	ToolCallStartEvent,
+} from "@/hooks/chat-session/types";
+import {
+	type ChatMessage,
+	type ChatSessionConfig,
+	ChatSessionConfigSchema,
+	type ChatSessionStatus,
+} from "@/lib/chat-schema";
+import { desktopClient } from "@/lib/desktop-client";
+import {
+	buildSessionDiffState,
+	type SessionHookEvent,
+	EMPTY_DIFF_SUMMARY,
+	type SessionDiffSummary,
+	type SessionFileDiff,
+} from "@/lib/session-diff";
+import type {
+	SessionHistoryItem,
+	SessionHistoryStatus,
+} from "@/lib/session-history";
+
+export { DEFAULT_CHAT_CONFIG } from "@/hooks/chat-session/constants";
+
+const MAX_MESSAGES = 800;
+
+const RELEVANT_STREAMS = new Set([
+	"chat_text",
+	"chat_reasoning",
+	"chat_queued_prompt_start",
+	"chat_tool_call_start",
+	"chat_tool_call_end",
+	"chat_core_log",
+	"chat_usage",
+	"chat_done",
+]);
+
+const BUSY_STATUSES = new Set<ChatSessionStatus>([
+	"starting",
+	"running",
+	"stopping",
+]);
+
+// ---------------------------------------------------------------------------
+// Helpers (pure, no hooks)
+// ---------------------------------------------------------------------------
+
+function errorMessage(err: unknown): string {
+	return err instanceof Error ? err.message : String(err);
+}
+
+function makeErrorChatMessage(
+	sid: string | null,
+	content: string,
+): ChatMessage {
+	return {
+		id: makeId("error"),
+		sessionId: sid,
+		role: "error",
+		content,
+		createdAt: Date.now(),
+	};
+}
+
+function validateConfig(
+	config: ChatSessionConfig,
+):
+	| { parsed: ChatSessionConfig; error: null }
+	| { parsed: null; error: string } {
+	const runtimeConfig = normalizeRuntimeConfig(config);
+	const result = ChatSessionConfigSchema.safeParse(runtimeConfig);
+	if (!result.success) {
+		return {
+			parsed: null,
+			error: result.error.issues.map((i) => i.message).join(", "),
+		};
+	}
+	const credentialError = resolveCredentialError(result.data);
+	if (credentialError) {
+		return { parsed: null, error: credentialError };
+	}
+	return { parsed: result.data, error: null };
+}
+
+function sliceMessages(msgs: ChatMessage[]): ChatMessage[] {
+	return msgs.length > MAX_MESSAGES ? msgs.slice(-MAX_MESSAGES) : msgs;
+}
+
+function sortMessagesChronologically(messages: ChatMessage[]): ChatMessage[] {
+	return [...messages].sort((left, right) => {
+		if (left.createdAt !== right.createdAt) {
+			return left.createdAt - right.createdAt;
+		}
+		return left.id.localeCompare(right.id);
+	});
+}
+
+function chunkCreatedAt(payload: AgentChunkEvent): number {
+	const ts = payload.ts || Date.now();
+	const index = payload.index ?? 0;
+	return ts * 1000 + index;
+}
+
+function mergeHydratedMessagesWithLive(options: {
+	hydrated: ChatMessage[];
+	current: ChatMessage[];
+	sessionId: string;
+	hydrationStartedAt: number;
+}): ChatMessage[] {
+	const { hydrated, current, sessionId, hydrationStartedAt } = options;
+	const liveDuringHydration = current.filter(
+		(message) =>
+			message.sessionId === sessionId &&
+			message.createdAt >= hydrationStartedAt,
+	);
+	if (liveDuringHydration.length === 0) {
+		return hydrated;
+	}
+	const hydratedKeyCounts = new Map<string, number>();
+	for (const message of hydrated) {
+		const key = `${message.role}\u0000${message.content}\u0000${message.reasoning ?? ""}`;
+		hydratedKeyCounts.set(key, (hydratedKeyCounts.get(key) ?? 0) + 1);
+	}
+	const nonDuplicateLive = liveDuringHydration.filter((message) => {
+		const key = `${message.role}\u0000${message.content}\u0000${message.reasoning ?? ""}`;
+		const hydratedCount = hydratedKeyCounts.get(key) ?? 0;
+		if (hydratedCount > 0) {
+			if (hydratedCount === 1) {
+				hydratedKeyCounts.delete(key);
+			} else {
+				hydratedKeyCounts.set(key, hydratedCount - 1);
+			}
+			return false;
+		}
+		return true;
+	});
+	return sortMessagesChronologically([...hydrated, ...nonDuplicateLive]);
+}
+
+function updateMessageById(
+	messages: ChatMessage[],
+	id: string,
+	updater: (msg: ChatMessage) => ChatMessage,
+): ChatMessage[] {
+	let changed = false;
+	const next = messages.map((msg) => {
+		if (msg.id !== id) return msg;
+		changed = true;
+		return updater(msg);
+	});
+	return changed ? next : messages;
+}
+
+// ---------------------------------------------------------------------------
+// Core log dispatcher — avoids repeated if/else chains
+// ---------------------------------------------------------------------------
+
+const LOG_DISPATCH: Record<string, typeof console.info> = {
+	error: console.error,
+	warn: console.warn,
+	debug: console.debug,
+};
+
+function dispatchCoreLog(chunk: string): void {
+	let parsed: CoreLogChunk | undefined;
+	try {
+		parsed = JSON.parse(chunk) as CoreLogChunk;
+	} catch {
+		console.info("[core]", chunk);
+		return;
+	}
+	const level = parsed.level?.trim().toLowerCase() || "info";
+	const message = parsed.message?.trim() || chunk;
+	(LOG_DISPATCH[level] ?? console.info)("[core]", message, parsed.metadata);
+}
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+export function useChatSession() {
+	const [sessionId, setSessionId] = useState<string | null>(null);
+	const [status, setStatus] = useState<ChatSessionStatus>("idle");
+	const [isHydratingSession, setIsHydratingSession] = useState(false);
+	const [config, setConfig] = useState<ChatSessionConfig>(getInitialChatConfig);
+	const [messages, setMessages] = useState<ChatMessage[]>([]);
+	const [rawTranscript, setRawTranscript] = useState("");
+	const [error, setError] = useState<string | null>(null);
+	const [toolCalls, setToolCalls] = useState(0);
+	const [tokensIn, setTokensIn] = useState(0);
+	const [tokensOut, setTokensOut] = useState(0);
+	const [fileDiffs, setFileDiffs] = useState<SessionFileDiff[]>([]);
+	const [diffSummary, setDiffSummary] =
+		useState<SessionDiffSummary>(EMPTY_DIFF_SUMMARY);
+	const [activeAssistantMessageId, setActiveAssistantMessageId] = useState<
+		string | null
+	>(null);
+	const [hydratedHistorySessionId, setHydratedHistorySessionId] = useState<
+		string | null
+	>(null);
+	const [pendingToolApprovals, setPendingToolApprovals] = useState<
+		ToolApprovalRequestItem[]
+	>([]);
+	const [pendingAskQuestions, setPendingAskQuestions] = useState<
+		AskQuestionRequestItem[]
+	>([]);
+	const [promptsInQueue, setPromptsInQueue] = useState<PromptInQueue[]>([]);
+	const messagesRef = useRef<ChatMessage[]>([]);
+	const liveToolMessageIdsRef = useRef<Record<string, string>>({});
+	const liveToolInputsRef = useRef<Record<string, unknown>>({});
+	const activeSessionIdRef = useRef<string | null>(null);
+	const activeAssistantMessageIdRef = useRef<string | null>(null);
+	const lastStreamIndexBySessionRef = useRef<Record<string, number>>({});
+	const abortedRef = useRef(false);
+	const abortFallbackTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(
+		null,
+	);
+	const hydrationRequestIdRef = useRef(0);
+	const [chatTransportState, setChatTransportState] =
+		useState<ChatTransportState>(desktopClient.getTransportState());
+	const [chatTransportError, setChatTransportError] = useState<string | null>(
+		desktopClient.getTransportError(),
+	);
+	// ---- Ref syncs ----
+
+	useEffect(() => {
+		activeSessionIdRef.current = sessionId;
+	}, [sessionId]);
+	useEffect(() => {
+		activeAssistantMessageIdRef.current = activeAssistantMessageId;
+	}, [activeAssistantMessageId]);
+	useEffect(() => {
+		messagesRef.current = messages;
+	}, [messages]);
+
+	// ---- Shared state reset helpers ----
+
+	const clearLiveToolRefs = useCallback(() => {
+		liveToolMessageIdsRef.current = {};
+		liveToolInputsRef.current = {};
+	}, []);
+
+	const resetStreamDedupe = useCallback((targetSessionId?: string | null) => {
+		if (targetSessionId) {
+			delete lastStreamIndexBySessionRef.current[targetSessionId];
+			return;
+		}
+		lastStreamIndexBySessionRef.current = {};
+	}, []);
+
+	const clearAbortFallbackTimeout = useCallback(() => {
+		if (abortFallbackTimeoutRef.current) {
+			clearTimeout(abortFallbackTimeoutRef.current);
+			abortFallbackTimeoutRef.current = null;
+		}
+	}, []);
+
+	const resetCounters = useCallback(() => {
+		setToolCalls(0);
+		setTokensIn(0);
+		setTokensOut(0);
+		setFileDiffs([]);
+		setDiffSummary(EMPTY_DIFF_SUMMARY);
+	}, []);
+
+	const setErrorState = useCallback(
+		(msg: string, sid: string | null = null) => {
+			setError(msg);
+			setStatus("error");
+			setMessages((prev) =>
+				sliceMessages([...prev, makeErrorChatMessage(sid, msg)]),
+			);
+		},
+		[],
+	);
+
+	// ---- Data fetching ----
+
+	const postSession = useCallback(async (body: Record<string, unknown>) => {
+		return await desktopClient.invoke<{
+			sessionId?: string;
+			result?: ChatApiResult;
+			ok?: boolean;
+			queued?: boolean;
+			promptsInQueue?: PromptInQueue[];
+			prompt?: PromptInQueue;
+			updated?: boolean;
+			removed?: boolean;
+		}>("chat_session_command", { request: body });
+	}, []);
+
+	const refreshPromptsInQueue = useCallback(
+		async (targetSessionId: string | null) => {
+			if (!targetSessionId) {
+				setPromptsInQueue([]);
+				return;
+			}
+			try {
+				const payload = await postSession({
+					action: "pending_prompts",
+					sessionId: targetSessionId,
+				});
+				setPromptsInQueue(
+					Array.isArray(payload.promptsInQueue) ? payload.promptsInQueue : [],
+				);
+			} catch {
+				// Ignore queue refresh failures and keep the last known state.
+			}
+		},
+		[postSession],
+	);
+
+	const applyPromptsInQueue = useCallback((value: unknown) => {
+		if (!Array.isArray(value)) {
+			return;
+		}
+		setPromptsInQueue(value as PromptInQueue[]);
+	}, []);
+
+	const refreshSessionDiffSummary = useCallback(
+		async (targetSessionId: string) => {
+			try {
+				const events = await desktopClient.invoke<ChatSessionHookEvent[]>(
+					"read_session_hooks",
+					{ sessionId: targetSessionId, limit: MAX_MESSAGES },
+				);
+				const diffState = buildSessionDiffState(events);
+				setFileDiffs(diffState.fileDiffs);
+				setDiffSummary(diffState.summary);
+				setToolCalls(
+					events.filter(
+						(e) =>
+							e.hookEventName === "tool_call" || e.hookName === "tool_call",
+					).length,
+				);
+				setTokensIn(events.reduce((sum, e) => sum + (e.inputTokens ?? 0), 0));
+				setTokensOut(events.reduce((sum, e) => sum + (e.outputTokens ?? 0), 0));
+			} catch {
+				// Ignore in non-Tauri mode.
+			}
+		},
+		[],
+	);
+
+	// ---- Message helpers ----
+
+	const addMessage = useCallback((message: ChatMessage) => {
+		setMessages((prev) => sliceMessages([...prev, message]));
+	}, []);
+
+	const shouldApplyStreamChunk = useCallback((payload: AgentChunkEvent) => {
+		const index = payload.index;
+		if (typeof index !== "number") {
+			return true;
+		}
+		const previous = lastStreamIndexBySessionRef.current[payload.sessionId];
+		if (previous !== undefined && index <= previous) {
+			return false;
+		}
+		lastStreamIndexBySessionRef.current[payload.sessionId] = index;
+		return true;
+	}, []);
+
+	const materializeToolMessagesFromResult = useCallback(
+		(options: {
+			sessionId: string;
+			turnStartedAt: number;
+			toolCalls: NonNullable<ChatApiResult["toolCalls"]>;
+		}) => {
+			const { sessionId: targetSessionId, turnStartedAt, toolCalls } = options;
+			if (toolCalls.length === 0) return;
+			setMessages((prev) => {
+				const hasLive = prev.some(
+					(m) =>
+						m.sessionId === targetSessionId &&
+						m.role === "tool" &&
+						m.createdAt >= turnStartedAt,
+				);
+				if (hasLive) return prev;
+
+				const next = [...prev];
+				for (const call of toolCalls) {
+					next.push({
+						id: makeId("tool"),
+						sessionId: targetSessionId,
+						role: "tool",
+						content: JSON.stringify({
+							toolName: call.name,
+							input: call.input,
+							result: call.error ? call.error : call.output,
+							isError: Boolean(call.error),
+						}),
+						createdAt: turnStartedAt + next.length,
+						meta: { toolName: call.name, hookEventName: "tool_call_end" },
+					});
+				}
+				return sliceMessages(sortMessagesChronologically(next));
+			});
+		},
+		[],
+	);
+
+	const appendMessageContent = useCallback((id: string, chunk: string) => {
+		if (!chunk) return;
+		setMessages((prev) =>
+			updateMessageById(prev, id, (msg) => {
+				const existing = msg.content;
+				if (existing.endsWith(chunk)) return msg;
+				const content = chunk.startsWith(existing)
+					? chunk
+					: `${existing}${chunk}`;
+				return { ...msg, content };
+			}),
+		);
+	}, []);
+
+	const appendMessageReasoning = useCallback(
+		(id: string, chunk: string, redacted = false) => {
+			if (!chunk && !redacted) return;
+			setMessages((prev) =>
+				updateMessageById(prev, id, (msg) => {
+					const reasoningChunk = chunk || (redacted ? "[redacted]" : "");
+					const existing = msg.reasoning ?? "";
+					if (reasoningChunk && existing.endsWith(reasoningChunk)) {
+						return redacted && !msg.reasoningRedacted
+							? { ...msg, reasoningRedacted: true }
+							: msg;
+					}
+					return {
+						...msg,
+						reasoning: `${existing}${reasoningChunk}`,
+						reasoningRedacted: msg.reasoningRedacted || redacted,
+					};
+				}),
+			);
+		},
+		[],
+	);
+
+	// ---- Process context ----
+
+	const applyProcessContext = useCallback(async () => {
+		try {
+			const ctx = await desktopClient.invoke<ProcessContext>(
+				"get_process_context",
+			);
+			setConfig((prev) => ({
+				...prev,
+				workspaceRoot: ctx.workspaceRoot || ctx.cwd,
+				cwd: ctx.workspaceRoot || ctx.cwd,
+			}));
+		} catch {
+			// Ignore in non-Tauri mode.
+		}
+	}, []);
+
+	useEffect(() => {
+		void applyProcessContext();
+	}, [applyProcessContext]);
+
+	// ---- Diff / approval effects ----
+
+	useEffect(() => {
+		if (!sessionId) {
+			setFileDiffs([]);
+			setDiffSummary(EMPTY_DIFF_SUMMARY);
+			setPendingToolApprovals([]);
+			setPendingAskQuestions([]);
+			setPromptsInQueue([]);
+			return;
+		}
+		void refreshSessionDiffSummary(sessionId);
+		void refreshPromptsInQueue(sessionId);
+	}, [refreshPromptsInQueue, refreshSessionDiffSummary, sessionId]);
+
+	// Fallback for sessions with no tool events in the hook log (e.g. sessions
+	// recorded before tool_call/tool_result hook logging existed): rebuild the
+	// diff state from the tool messages themselves.
+	useEffect(() => {
+		if (!sessionId || fileDiffs.length > 0) {
+			return;
+		}
+		const events: SessionHookEvent[] = [];
+		for (const message of messages) {
+			if (message.sessionId !== sessionId || message.role !== "tool") {
+				continue;
+			}
+			let payload: {
+				toolName?: string;
+				input?: unknown;
+				result?: unknown;
+				isError?: boolean;
+			} | null = null;
+			try {
+				payload = JSON.parse(message.content);
+			} catch {
+				continue;
+			}
+			if (!payload?.toolName || payload.result == null || payload.isError) {
+				continue;
+			}
+			events.push({
+				hookName: "tool_result",
+				toolName: payload.toolName,
+				toolInput: payload.input,
+				toolOutput: payload.result,
+			});
+		}
+		if (events.length === 0) {
+			return;
+		}
+		const diffState = buildSessionDiffState(events);
+		if (diffState.fileDiffs.length === 0) {
+			return;
+		}
+		setFileDiffs(diffState.fileDiffs);
+		setDiffSummary(diffState.summary);
+	}, [sessionId, messages, fileDiffs.length]);
+
+	useEffect(() => {
+		const activeSessionId = sessionId;
+		if (!activeSessionId) {
+			setPendingToolApprovals([]);
+			return;
+		}
+
+		void desktopClient
+			.invoke<ToolApprovalRequestItem[]>("poll_tool_approvals", {
+				sessionId: activeSessionId,
+				limit: 20,
+			})
+			.then((pending) => setPendingToolApprovals(pending))
+			.catch(() => {});
+
+		return desktopClient.subscribe("tool_approval_state", (payload) => {
+			if (!payload || typeof payload !== "object") return;
+			const record = payload as {
+				sessionId?: string;
+				items?: ToolApprovalRequestItem[];
+			};
+			if (record.sessionId !== activeSessionId) return;
+			setPendingToolApprovals(Array.isArray(record.items) ? record.items : []);
+		});
+	}, [sessionId]);
+
+	useEffect(() => {
+		return desktopClient.subscribe("ask_question_requested", (payload) => {
+			if (!payload || typeof payload !== "object") return;
+			const item = payload as AskQuestionRequestItem;
+			if (!item.requestId || !item.question || !Array.isArray(item.options)) {
+				return;
+			}
+			setPendingAskQuestions((prev) => {
+				if (prev.some((existing) => existing.requestId === item.requestId)) {
+					return prev;
+				}
+				return [...prev, item];
+			});
+		});
+	}, []);
+
+	useEffect(() => {
+		return desktopClient.subscribe("ask_question_answered", (payload) => {
+			if (!payload || typeof payload !== "object") return;
+			const requestId = String(
+				(payload as { requestId?: unknown }).requestId ?? "",
+			).trim();
+			if (!requestId) return;
+			setPendingAskQuestions((prev) =>
+				prev.filter((item) => item.requestId !== requestId),
+			);
+		});
+	}, []);
+
+	useEffect(() => {
+		return desktopClient.subscribe("ask_question_cancelled", (payload) => {
+			if (!payload || typeof payload !== "object") return;
+			const requestId = String(
+				(payload as { requestId?: unknown }).requestId ?? "",
+			).trim();
+			if (!requestId) return;
+			setPendingAskQuestions((prev) =>
+				prev.filter((item) => item.requestId !== requestId),
+			);
+		});
+	}, []);
+
+	useEffect(() => {
+		return desktopClient.subscribe("prompts_in_queue_state", (payload) => {
+			if (!payload || typeof payload !== "object") return;
+			const record = payload as {
+				sessionId?: string;
+				items?: PromptInQueue[];
+			};
+			if (record.sessionId !== activeSessionIdRef.current) return;
+			setPromptsInQueue(Array.isArray(record.items) ? record.items : []);
+		});
+	}, []);
+
+	// ---- Incoming chunk handler ----
+
+	const handleIncomingChunk = useCallback(
+		(payload: AgentChunkEvent) => {
+			if (!RELEVANT_STREAMS.has(payload.stream)) return;
+			if (!shouldApplyStreamChunk(payload)) return;
+
+			const listeningSessionId = activeSessionIdRef.current;
+			if (!listeningSessionId || payload.sessionId !== listeningSessionId) {
+				return;
+			}
+			if (abortedRef.current) {
+				return;
+			}
+
+			if (payload.stream === "chat_queued_prompt_start") {
+				let parsed: { prompt?: string; attachmentCount?: number } = {};
+				try {
+					parsed = JSON.parse(payload.chunk) as {
+						prompt?: string;
+						attachmentCount?: number;
+					};
+				} catch {
+					parsed = { prompt: payload.chunk };
+				}
+				const prompt = parsed.prompt?.trim() ?? "";
+				const attachmentCount =
+					typeof parsed.attachmentCount === "number"
+						? parsed.attachmentCount
+						: 0;
+				const userLabel =
+					attachmentCount > 0
+						? `${prompt}${prompt.length > 0 ? "\n\n" : ""}[attached ${attachmentCount} file${attachmentCount === 1 ? "" : "s"}]`
+						: prompt;
+				activeAssistantMessageIdRef.current = null;
+				setActiveAssistantMessageId(null);
+				clearLiveToolRefs();
+				setStatus("running");
+				if (userLabel) {
+					setMessages((prev) => {
+						const lastVisible = [...prev]
+							.reverse()
+							.find(
+								(message) =>
+									message.sessionId === listeningSessionId &&
+									message.role !== "status",
+							);
+						if (
+							lastVisible?.role === "user" &&
+							lastVisible.content === userLabel
+						) {
+							return prev;
+						}
+						return sliceMessages([
+							...prev,
+							{
+								id: makeId("user"),
+								sessionId: listeningSessionId,
+								role: "user",
+								content: userLabel,
+								createdAt: chunkCreatedAt(payload),
+							},
+						]);
+					});
+				}
+				return;
+			}
+
+			// --- Text stream ---
+			if (payload.stream === "chat_text") {
+				let assistantId = activeAssistantMessageIdRef.current;
+				if (!assistantId) {
+					assistantId = makeId("assistant");
+					addMessage({
+						id: assistantId,
+						sessionId: listeningSessionId,
+						role: "assistant",
+						content: "",
+						createdAt: chunkCreatedAt(payload),
+					});
+					activeAssistantMessageIdRef.current = assistantId;
+					setActiveAssistantMessageId(assistantId);
+				}
+				appendMessageContent(assistantId, payload.chunk);
+				setRawTranscript((prev) => `${prev}${payload.chunk}`);
+				return;
+			}
+
+			if (payload.stream === "chat_reasoning") {
+				let assistantId = activeAssistantMessageIdRef.current;
+				if (!assistantId) {
+					assistantId = makeId("assistant");
+					addMessage({
+						id: assistantId,
+						sessionId: listeningSessionId,
+						role: "assistant",
+						content: "",
+						createdAt: chunkCreatedAt(payload),
+					});
+					activeAssistantMessageIdRef.current = assistantId;
+					setActiveAssistantMessageId(assistantId);
+				}
+				let parsed: ReasoningDeltaEvent = {};
+				try {
+					parsed = JSON.parse(payload.chunk) as ReasoningDeltaEvent;
+				} catch {
+					parsed = { text: payload.chunk };
+				}
+				appendMessageReasoning(
+					assistantId,
+					parsed.text ?? "",
+					parsed.redacted === true,
+				);
+				return;
+			}
+
+			// --- Core log ---
+			if (payload.stream === "chat_core_log") {
+				dispatchCoreLog(payload.chunk);
+				return;
+			}
+
+			if (payload.stream === "chat_usage") {
+				// Usage is still finalized from the send() response to avoid
+				// double-counting when both stream and response include it.
+				return;
+			}
+
+			if (payload.stream === "chat_done") {
+				clearLiveToolRefs();
+				return;
+			}
+
+			// --- Tool call start ---
+			if (payload.stream === "chat_tool_call_start") {
+				let parsed: ToolCallStartEvent = {};
+				try {
+					parsed = JSON.parse(payload.chunk) as ToolCallStartEvent;
+				} catch {
+					return;
+				}
+				const toolName = parsed.toolName ?? "unknown_tool";
+				const toolCallId = parsed.toolCallId ?? makeId("tool_call");
+				const messageId = makeId("tool");
+				liveToolMessageIdsRef.current[toolCallId] = messageId;
+				liveToolInputsRef.current[toolCallId] = parsed.input;
+				// Reset so text after this tool call gets a fresh assistant message
+				activeAssistantMessageIdRef.current = null;
+				setActiveAssistantMessageId(null);
+				addMessage({
+					id: messageId,
+					sessionId: listeningSessionId,
+					role: "tool",
+					content: buildToolPayloadString({
+						toolName,
+						input: parsed.input,
+						output: null,
+					}),
+					createdAt: chunkCreatedAt(payload),
+					meta: { toolName, hookEventName: "tool_call_start" },
+				});
+				setToolCalls((prev) => prev + 1);
+				return;
+			}
+
+			// --- Tool call end ---
+			let parsed: ToolCallEndEvent = {};
+			try {
+				parsed = JSON.parse(payload.chunk) as ToolCallEndEvent;
+			} catch {
+				return;
+			}
+			const toolName = parsed.toolName ?? "unknown_tool";
+			const toolCallId = parsed.toolCallId;
+			const messageId = toolCallId
+				? liveToolMessageIdsRef.current[toolCallId]
+				: undefined;
+			const toolInput =
+				parsed.input ??
+				(toolCallId ? liveToolInputsRef.current[toolCallId] : undefined);
+			const toolPayload = buildToolPayloadString({
+				toolName,
+				input: toolInput,
+				output: parsed.output,
+				error: parsed.error,
+			});
+			if (toolCallId) {
+				delete liveToolMessageIdsRef.current[toolCallId];
+				delete liveToolInputsRef.current[toolCallId];
+			}
+			if (messageId) {
+				// Single setMessages call replaces content + updates meta together.
+				setMessages((prev) =>
+					updateMessageById(prev, messageId, (msg) => ({
+						...msg,
+						content: toolPayload,
+						meta: { ...msg.meta, toolName, hookEventName: "tool_call_end" },
+					})),
+				);
+				return;
+			}
+			// Ignore unmatched tool end events so stale completions from the
+			// previous turn do not get rendered under a newer streaming turn.
+		},
+		[
+			addMessage,
+			appendMessageContent,
+			appendMessageReasoning,
+			clearLiveToolRefs,
+			shouldApplyStreamChunk,
+		],
+	);
+
+	// ---- Transport / event subscriptions ----
+
+	useEffect(() => {
+		const unsubscribeTransport = desktopClient.subscribeTransportState(
+			(state) => {
+				setChatTransportState(state);
+				setChatTransportError(desktopClient.getTransportError());
+			},
+		);
+		const unsubscribeEvents = desktopClient.subscribe(
+			"chat_event",
+			(payload) => {
+				if (payload && typeof payload === "object") {
+					handleIncomingChunk(payload as AgentChunkEvent);
+				}
+			},
+		);
+		return () => {
+			unsubscribeTransport();
+			unsubscribeEvents();
+		};
+	}, [handleIncomingChunk]);
+
+	useEffect(() => {
+		const unsubscribeStatus = desktopClient.subscribe(
+			"chat_session_status",
+			(payload) => {
+				if (!payload || typeof payload !== "object") {
+					return;
+				}
+				const record = payload as {
+					sessionId?: string;
+					status?: string;
+				};
+				const targetSessionId = record.sessionId?.trim();
+				if (
+					!targetSessionId ||
+					targetSessionId !== activeSessionIdRef.current
+				) {
+					return;
+				}
+				const nextStatus = record.status?.trim();
+				if (!nextStatus) {
+					return;
+				}
+				setStatus(nextStatus as ChatSessionStatus);
+			},
+		);
+		const unsubscribeEnded = desktopClient.subscribe(
+			"chat_session_ended",
+			(payload) => {
+				if (!payload || typeof payload !== "object") {
+					return;
+				}
+				const record = payload as {
+					sessionId?: string;
+					reason?: string;
+				};
+				const targetSessionId = record.sessionId?.trim();
+				if (
+					!targetSessionId ||
+					targetSessionId !== activeSessionIdRef.current
+				) {
+					return;
+				}
+				activeAssistantMessageIdRef.current = null;
+				setActiveAssistantMessageId(null);
+				clearLiveToolRefs();
+				setStatus((record.reason?.trim() || "idle") as ChatSessionStatus);
+			},
+		);
+		return () => {
+			unsubscribeStatus();
+			unsubscribeEnded();
+		};
+	}, [clearLiveToolRefs]);
+
+	// ---- Shared: start a new session via RPC ----
+
+	const startSession = useCallback(
+		async (validatedConfig: ChatSessionConfig): Promise<string> => {
+			const payload = await postSession({
+				action: "start",
+				config: validatedConfig,
+			});
+			const id = payload.sessionId;
+			if (!id) throw new Error("Missing session id from server");
+			setSessionId(id);
+			// Mark idle — not running — so the first sendPrompt is not queued.
+			// The status transitions to "starting"/"running" once a prompt is
+			// actually dispatched.
+			setStatus("idle");
+			setConfig(validatedConfig);
+			setHydratedHistorySessionId(null);
+			return id;
+		},
+		[postSession],
+	);
+
+	// ---- Actions ----
+
+	const start = useCallback(
+		async (nextConfig: ChatSessionConfig) => {
+			const validation = validateConfig(nextConfig);
+			if (!validation.parsed) {
+				setErrorState(validation.error);
+				return;
+			}
+			const parsed = validation.parsed;
+
+			setError(null);
+			setStatus("starting");
+			setIsHydratingSession(false);
+			abortedRef.current = false;
+			clearAbortFallbackTimeout();
+			setMessages([]);
+			setRawTranscript("");
+			resetCounters();
+			setConfig(parsed);
+			setHydratedHistorySessionId(null);
+			setPromptsInQueue([]);
+
+			try {
+				const id = await startSession(parsed);
+				addMessage({
+					id: makeId("status"),
+					sessionId: id,
+					role: "status",
+					content: `Session started: ${id}`,
+					createdAt: Date.now(),
+				});
+			} catch (err) {
+				setErrorState(errorMessage(err));
+			}
+		},
+		[
+			addMessage,
+			clearAbortFallbackTimeout,
+			resetCounters,
+			setErrorState,
+			startSession,
+		],
+	);
+
+	const sendPrompt = useCallback(
+		async (prompt: string, attachedFiles: File[] = []) => {
+			const trimmed = prompt.trim();
+			if (!trimmed && attachedFiles.length === 0) return;
+
+			setError(null);
+			setIsHydratingSession(false);
+			abortedRef.current = false;
+			clearAbortFallbackTimeout();
+			let activeSessionId = sessionId;
+
+			const validation = validateConfig(config);
+			if (!validation.parsed) {
+				setErrorState(validation.error, activeSessionId);
+				return;
+			}
+			const parsed = validation.parsed;
+
+			if (activeSessionId && hydratedHistorySessionId === activeSessionId) {
+				try {
+					activeSessionId = await startSession({
+						...parsed,
+						sessionId: activeSessionId,
+					});
+				} catch (err) {
+					setErrorState(errorMessage(err), activeSessionId);
+					return;
+				}
+			}
+
+			if (!activeSessionId) {
+				try {
+					activeSessionId = await startSession(parsed);
+				} catch (err) {
+					setErrorState(errorMessage(err));
+					return;
+				}
+			}
+
+			const now = Date.now();
+			const shouldQueue = Boolean(activeSessionId) && BUSY_STATUSES.has(status);
+			const serializedAttachments = await serializeAttachments(attachedFiles);
+			const hasAttachments =
+				serializedAttachments.userImages.length > 0 ||
+				serializedAttachments.userFiles.length > 0;
+
+			const userLabel = hasAttachments
+				? `${trimmed}${trimmed.length > 0 ? "\n\n" : ""}[attached ${attachedFiles.length} file${attachedFiles.length === 1 ? "" : "s"}]`
+				: trimmed;
+			const optimisticQueuedPromptId = shouldQueue
+				? makeId("queued_prompt")
+				: null;
+
+			if (!shouldQueue) {
+				addMessage({
+					id: makeId("user"),
+					sessionId: activeSessionId,
+					role: "user",
+					content: userLabel,
+					createdAt: now,
+				});
+				activeSessionIdRef.current = activeSessionId;
+				activeAssistantMessageIdRef.current = null;
+				setActiveAssistantMessageId(null);
+				clearLiveToolRefs();
+				setStatus("starting");
+			} else if (optimisticQueuedPromptId) {
+				setPromptsInQueue((prev) => [
+					...prev,
+					{
+						id: optimisticQueuedPromptId,
+						prompt: userLabel,
+						steer: false,
+					},
+				]);
+			}
+			try {
+				const payload = await postSession({
+					action: "send",
+					sessionId: activeSessionId,
+					prompt: trimmed,
+					delivery: shouldQueue ? "queue" : undefined,
+					config: parsed,
+					attachments: hasAttachments ? serializedAttachments : undefined,
+				});
+				if (payload.ok && payload.queued) {
+					applyPromptsInQueue(payload.promptsInQueue);
+					setStatus("running");
+					return;
+				}
+
+				const result = payload.result as ChatApiResult | undefined;
+				applyPromptsInQueue(payload.promptsInQueue);
+				if (abortedRef.current) {
+					setStatus("cancelled");
+					return;
+				}
+				const assistantText = (result?.text ?? "").trim();
+				const fallbackAssistantTurn = extractAssistantTurnDataFromRpcMessages(
+					result?.messages,
+				);
+				const resolvedAssistantText =
+					assistantText || fallbackAssistantTurn.text;
+				if (resolvedAssistantText) {
+					const assistantMessageId =
+						activeAssistantMessageIdRef.current ?? makeId("assistant");
+					activeAssistantMessageIdRef.current = assistantMessageId;
+					setActiveAssistantMessageId(assistantMessageId);
+					setMessages((prev) => {
+						const updated = updateMessageById(
+							prev,
+							assistantMessageId,
+							(msg) => ({ ...msg, content: resolvedAssistantText }),
+						);
+						if (updated !== prev) return updated;
+						return sliceMessages([
+							...prev,
+							{
+								id: assistantMessageId,
+								sessionId: activeSessionId,
+								role: "assistant" as const,
+								content: resolvedAssistantText,
+								reasoning: fallbackAssistantTurn.reasoning || undefined,
+								reasoningRedacted:
+									fallbackAssistantTurn.reasoningRedacted || undefined,
+								createdAt: now + 1,
+							},
+						]);
+					});
+				} else if (
+					fallbackAssistantTurn.reasoning ||
+					fallbackAssistantTurn.reasoningRedacted
+				) {
+					const assistantMessageId =
+						activeAssistantMessageIdRef.current ?? makeId("assistant");
+					activeAssistantMessageIdRef.current = assistantMessageId;
+					setActiveAssistantMessageId(assistantMessageId);
+					setMessages((prev) => {
+						const updated = updateMessageById(
+							prev,
+							assistantMessageId,
+							(msg) => ({
+								...msg,
+								reasoning: fallbackAssistantTurn.reasoning || msg.reasoning,
+								reasoningRedacted:
+									fallbackAssistantTurn.reasoningRedacted ||
+									msg.reasoningRedacted,
+							}),
+						);
+						if (updated !== prev) return updated;
+						return sliceMessages([
+							...prev,
+							{
+								id: assistantMessageId,
+								sessionId: activeSessionId,
+								role: "assistant" as const,
+								content: "",
+								reasoning: fallbackAssistantTurn.reasoning || undefined,
+								reasoningRedacted:
+									fallbackAssistantTurn.reasoningRedacted || undefined,
+								createdAt: now + 1,
+							},
+						]);
+					});
+				} else {
+					// Recovery: load canonical messages if transport missed result text.
+					try {
+						const historyMessages = await desktopClient.invoke<ChatMessage[]>(
+							"read_session_messages",
+							{ sessionId: activeSessionId, maxMessages: MAX_MESSAGES },
+						);
+						if (historyMessages.length > 0) {
+							setMessages(historyMessages);
+						}
+					} catch {
+						// Keep optimistic state if hydration read fails.
+					}
+				}
+				if (Array.isArray(result?.toolCalls) && result.toolCalls.length > 0) {
+					materializeToolMessagesFromResult({
+						sessionId: activeSessionId,
+						turnStartedAt: now,
+						toolCalls: result.toolCalls,
+					});
+				}
+
+				try {
+					const historyMessages = await desktopClient.invoke<ChatMessage[]>(
+						"read_session_messages",
+						{ sessionId: activeSessionId, maxMessages: MAX_MESSAGES },
+					);
+					if (historyMessages.length > 0) {
+						setMessages(historyMessages);
+					}
+				} catch {
+					// Keep optimistic state if canonical hydration fails.
+				}
+
+				// Token / cost bookkeeping
+				const inputTokens = result?.usage?.inputTokens ?? result?.inputTokens;
+				if (typeof inputTokens === "number") {
+					setTokensIn((prev) => prev + inputTokens);
+				}
+				const outputTokens =
+					result?.usage?.outputTokens ?? result?.outputTokens;
+				if (typeof outputTokens === "number") {
+					setTokensOut((prev) => prev + outputTokens);
+				}
+				const totalCost =
+					typeof result?.usage?.totalCost === "number"
+						? result.usage.totalCost
+						: undefined;
+				const assistantMessageId = activeAssistantMessageIdRef.current;
+				if (
+					assistantMessageId &&
+					(typeof inputTokens === "number" ||
+						typeof outputTokens === "number" ||
+						typeof totalCost === "number")
+				) {
+					setMessages((prev) =>
+						updateMessageById(prev, assistantMessageId, (msg) => ({
+							...msg,
+							meta: {
+								...(msg.meta ?? {}),
+								inputTokens:
+									typeof inputTokens === "number"
+										? inputTokens
+										: msg.meta?.inputTokens,
+								outputTokens:
+									typeof outputTokens === "number"
+										? outputTokens
+										: msg.meta?.outputTokens,
+								totalCost:
+									typeof totalCost === "number"
+										? totalCost
+										: msg.meta?.totalCost,
+								providerId: config.provider,
+								modelId: config.model,
+							},
+						})),
+					);
+				}
+
+				const hasQueuedFollowUps =
+					Array.isArray(payload.promptsInQueue) &&
+					payload.promptsInQueue.length > 0;
+				if (abortedRef.current) {
+					setStatus("cancelled");
+				} else if (result?.finishReason === "error") {
+					if (!resolvedAssistantText) {
+						const toolError = Array.isArray(result?.toolCalls)
+							? result.toolCalls.find((c) => c.error)?.error
+							: undefined;
+						addMessage(
+							makeErrorChatMessage(
+								activeSessionId,
+								toolError?.trim() ||
+									"Runtime turn failed before an assistant response was produced.",
+							),
+						);
+					}
+					setStatus("failed");
+				} else if (result?.finishReason === "aborted") {
+					setStatus("cancelled");
+				} else if (hasQueuedFollowUps) {
+					setStatus("running");
+				} else {
+					setStatus("completed");
+				}
+				void refreshSessionDiffSummary(activeSessionId);
+			} catch (err) {
+				if (abortedRef.current) {
+					setStatus("cancelled");
+					return;
+				}
+				if (optimisticQueuedPromptId) {
+					setPromptsInQueue((prev) =>
+						prev.filter((item) => item.id !== optimisticQueuedPromptId),
+					);
+				}
+				setErrorState(errorMessage(err), activeSessionId);
+			} finally {
+				clearAbortFallbackTimeout();
+				if (!shouldQueue) {
+					activeAssistantMessageIdRef.current = null;
+					setActiveAssistantMessageId(null);
+					clearLiveToolRefs();
+				}
+			}
+		},
+		[
+			addMessage,
+			applyPromptsInQueue,
+			clearAbortFallbackTimeout,
+			clearLiveToolRefs,
+			config,
+			hydratedHistorySessionId,
+			materializeToolMessagesFromResult,
+			refreshSessionDiffSummary,
+			sessionId,
+			setErrorState,
+			startSession,
+			status,
+			postSession,
+		],
+	);
+
+	const respondToolApproval = useCallback(
+		async (requestId: string, approved: boolean) => {
+			const activeSessionId = activeSessionIdRef.current;
+			if (!activeSessionId) return;
+			await desktopClient.invoke("respond_tool_approval", {
+				sessionId: activeSessionId,
+				requestId,
+				approved,
+				reason: approved
+					? undefined
+					: "Tool call rejected from desktop approval prompt",
+			});
+			setPendingToolApprovals((prev) =>
+				prev.filter((item) => item.requestId !== requestId),
+			);
+		},
+		[],
+	);
+
+	const approveToolApproval = useCallback(
+		(requestId: string) => respondToolApproval(requestId, true),
+		[respondToolApproval],
+	);
+
+	const rejectToolApproval = useCallback(
+		(requestId: string) => respondToolApproval(requestId, false),
+		[respondToolApproval],
+	);
+
+	const answerAskQuestion = useCallback(
+		async (requestId: string, answer: string) => {
+			await desktopClient.invoke("respond_ask_question", {
+				requestId,
+				answer,
+			});
+			setPendingAskQuestions((prev) =>
+				prev.filter((item) => item.requestId !== requestId),
+			);
+		},
+		[],
+	);
+
+	const restoreCheckpoint = useCallback(
+		async (checkpointRunCount: number) => {
+			const activeSessionId = activeSessionIdRef.current;
+			if (!activeSessionId) {
+				throw new Error("No active session to restore");
+			}
+			if (BUSY_STATUSES.has(status)) {
+				throw new Error("Wait for the current turn to finish before undoing");
+			}
+
+			clearAbortFallbackTimeout();
+			setError(null);
+			setIsHydratingSession(false);
+			activeAssistantMessageIdRef.current = null;
+			setActiveAssistantMessageId(null);
+			setPendingToolApprovals([]);
+			setPendingAskQuestions([]);
+			setPromptsInQueue([]);
+			clearLiveToolRefs();
+
+			const payload = (await postSession({
+				action: "restore_checkpoint",
+				sessionId: activeSessionId,
+				checkpointRunCount,
+				config,
+			})) as {
+				sessionId?: string;
+				messages?: ChatMessage[];
+			};
+			const nextSessionId =
+				typeof payload.sessionId === "string" ? payload.sessionId.trim() : "";
+			if (!nextSessionId) {
+				throw new Error("Checkpoint restore did not return a new session id");
+			}
+
+			const nextMessages = Array.isArray(payload.messages)
+				? (payload.messages as ChatMessage[])
+				: await desktopClient.invoke<ChatMessage[]>("read_session_messages", {
+						sessionId: nextSessionId,
+						maxMessages: MAX_MESSAGES,
+					});
+
+			setSessionId(nextSessionId);
+			activeSessionIdRef.current = nextSessionId;
+			setMessages(nextMessages);
+			setRawTranscript("");
+			setStatus(nextMessages.length > 0 ? "completed" : "idle");
+			resetCounters();
+			void refreshSessionDiffSummary(nextSessionId);
+			void refreshPromptsInQueue(nextSessionId);
+		},
+		[
+			clearAbortFallbackTimeout,
+			clearLiveToolRefs,
+			config,
+			postSession,
+			refreshPromptsInQueue,
+			refreshSessionDiffSummary,
+			resetCounters,
+			status,
+		],
+	);
+
+	const abort = useCallback(async () => {
+		if (!sessionId) return;
+		abortedRef.current = true;
+		setStatus("stopping");
+		clearAbortFallbackTimeout();
+		abortFallbackTimeoutRef.current = setTimeout(() => {
+			if (abortedRef.current) {
+				setStatus("cancelled");
+			}
+			abortFallbackTimeoutRef.current = null;
+		}, 2000);
+		try {
+			const response = await postSession({ action: "abort", sessionId });
+			if (!response.ok) {
+				abortedRef.current = false;
+				clearAbortFallbackTimeout();
+				setStatus("running");
+			}
+		} catch {
+			abortedRef.current = false;
+			clearAbortFallbackTimeout();
+			setStatus("running");
+		}
+	}, [clearAbortFallbackTimeout, postSession, sessionId]);
+
+	const reset = useCallback(async () => {
+		const activeSessionId = sessionId;
+		setSessionId(null);
+		setStatus("idle");
+		setIsHydratingSession(false);
+		abortedRef.current = false;
+		clearAbortFallbackTimeout();
+		setMessages([]);
+		setRawTranscript("");
+		setError(null);
+		resetCounters();
+		setConfig((prev) => ({
+			...prev,
+			sessionId: undefined,
+		}));
+		activeSessionIdRef.current = null;
+		activeAssistantMessageIdRef.current = null;
+		setActiveAssistantMessageId(null);
+		setHydratedHistorySessionId(null);
+		setPendingToolApprovals([]);
+		setPendingAskQuestions([]);
+		setPromptsInQueue([]);
+		clearLiveToolRefs();
+		if (activeSessionId) {
+			try {
+				await postSession({ action: "reset", sessionId: activeSessionId });
+			} catch {
+				// Best-effort reset path.
+			}
+		}
+	}, [
+		sessionId,
+		clearAbortFallbackTimeout,
+		postSession,
+		resetCounters,
+		clearLiveToolRefs,
+	]);
+
+	const hydrateSession = useCallback(
+		async (session: SessionHistoryItem) => {
+			const requestId = hydrationRequestIdRef.current + 1;
+			const hydrationStartedAt = Date.now();
+			hydrationRequestIdRef.current = requestId;
+			setError(null);
+			setStatus("starting");
+			setIsHydratingSession(true);
+			resetStreamDedupe(session.sessionId);
+			abortedRef.current = false;
+			clearAbortFallbackTimeout();
+			setSessionId(session.sessionId);
+			setConfig((prev) => ({
+				...prev,
+				sessionId: session.sessionId,
+				provider: session.provider || prev.provider,
+				model: session.model || prev.model,
+				workspaceRoot: session.workspaceRoot || prev.workspaceRoot,
+				cwd: session.workspaceRoot || session.cwd || prev.cwd,
+			}));
+			activeSessionIdRef.current = session.sessionId;
+			activeAssistantMessageIdRef.current = null;
+			setActiveAssistantMessageId(null);
+			setHydratedHistorySessionId(session.sessionId);
+			setPendingToolApprovals([]);
+			setPendingAskQuestions([]);
+			setPromptsInQueue([]);
+			clearLiveToolRefs();
+
+			const applyHydratedMessages = (
+				msgs: ChatMessage[],
+				sessionStatus: typeof session.status,
+			) => {
+				const mergedMessages = mergeHydratedMessagesWithLive({
+					hydrated: msgs,
+					current: messagesRef.current,
+					sessionId: session.sessionId,
+					hydrationStartedAt,
+				});
+				setMessages(mergedMessages);
+				setRawTranscript("");
+				resetCounters();
+				setStatus(inferHydratedChatStatus(sessionStatus, msgs));
+				void refreshSessionDiffSummary(session.sessionId);
+			};
+
+			try {
+				const historyMessages = await desktopClient.invoke<ChatMessage[]>(
+					"read_session_messages",
+					{ sessionId: session.sessionId, maxMessages: MAX_MESSAGES },
+				);
+				if (hydrationRequestIdRef.current !== requestId) return;
+				if (historyMessages.length > 0) {
+					void refreshPromptsInQueue(session.sessionId);
+					applyHydratedMessages(historyMessages, session.status);
+					setIsHydratingSession(false);
+				}
+
+				const attached = await desktopClient
+					.invoke<{
+						sessionId?: string;
+						status?: string;
+						provider?: string;
+						model?: string;
+						cwd?: string;
+						workspaceRoot?: string;
+						prompt?: string;
+					}>("chat_session_command", {
+						request: {
+							action: "attach",
+							sessionId: session.sessionId,
+							config: {
+								provider: session.provider,
+								model: session.model,
+								cwd: session.cwd,
+								workspaceRoot: session.workspaceRoot,
+							},
+						},
+					})
+					.catch((err) => {
+						if (historyMessages.length === 0) {
+							throw err;
+						}
+						setError(errorMessage(err));
+						return undefined;
+					});
+				if (hydrationRequestIdRef.current !== requestId) return;
+				setConfig((prev) => ({
+					...prev,
+					sessionId: session.sessionId,
+					provider: attached?.provider || session.provider || prev.provider,
+					model: attached?.model || session.model || prev.model,
+					workspaceRoot:
+						attached?.workspaceRoot ||
+						session.workspaceRoot ||
+						prev.workspaceRoot,
+					cwd:
+						attached?.cwd ||
+						attached?.workspaceRoot ||
+						session.workspaceRoot ||
+						session.cwd ||
+						prev.cwd,
+				}));
+
+				if (historyMessages.length > 0) {
+					setStatus(
+						inferHydratedChatStatus(
+							(attached?.status || session.status) as SessionHistoryStatus,
+							historyMessages,
+						),
+					);
+					return;
+				}
+
+				const synthesized: ChatMessage[] = [];
+				if (session.prompt?.trim()) {
+					synthesized.push({
+						id: makeId("history_user"),
+						sessionId: session.sessionId,
+						role: "user",
+						content: session.prompt.trim(),
+						createdAt: Date.now(),
+					});
+				}
+				void refreshPromptsInQueue(session.sessionId);
+				applyHydratedMessages(
+					synthesized,
+					(attached?.status || session.status) as SessionHistoryStatus,
+				);
+			} catch (err) {
+				if (hydrationRequestIdRef.current !== requestId) return;
+				const msg = errorMessage(err);
+				setError(msg);
+				setStatus("error");
+				setMessages([makeErrorChatMessage(session.sessionId, msg)]);
+			} finally {
+				if (hydrationRequestIdRef.current === requestId) {
+					setIsHydratingSession(false);
+				}
+			}
+		},
+		[
+			clearAbortFallbackTimeout,
+			clearLiveToolRefs,
+			refreshPromptsInQueue,
+			refreshSessionDiffSummary,
+			resetStreamDedupe,
+			resetCounters,
+		],
+	);
+
+	const forkSession = useCallback(async (): Promise<{
+		newSessionId: string;
+		forkedFromSessionId: string;
+		messages: ChatMessage[];
+	}> => {
+		const activeSessionId = activeSessionIdRef.current;
+		if (!activeSessionId) {
+			throw new Error("No active session to fork.");
+		}
+		if (BUSY_STATUSES.has(status)) {
+			throw new Error("Wait for the current turn to finish before forking.");
+		}
+		const payload = (await postSession({
+			action: "fork",
+			sessionId: activeSessionId,
+			config,
+		})) as {
+			sessionId?: string;
+			forkedFromSessionId?: string;
+			messages?: ChatMessage[];
+		};
+		const newSessionId =
+			typeof payload.sessionId === "string" ? payload.sessionId.trim() : "";
+		if (!newSessionId) {
+			throw new Error("Fork did not return a new session id.");
+		}
+		const forkedFromSessionId =
+			typeof payload.forkedFromSessionId === "string"
+				? payload.forkedFromSessionId
+				: activeSessionId;
+		const nextMessages = Array.isArray(payload.messages)
+			? (payload.messages as ChatMessage[])
+			: await desktopClient.invoke<ChatMessage[]>("read_session_messages", {
+					sessionId: newSessionId,
+					maxMessages: MAX_MESSAGES,
+				});
+		return { newSessionId, forkedFromSessionId, messages: nextMessages };
+	}, [config, postSession, status]);
+
+	const steerPromptInQueue = useCallback(
+		async (promptId: string) => {
+			const activeSessionId = activeSessionIdRef.current;
+			if (!activeSessionId || !promptId.trim()) {
+				return;
+			}
+			const payload = await postSession({
+				action: "steer_prompt",
+				sessionId: activeSessionId,
+				promptId,
+			});
+			setPromptsInQueue(
+				Array.isArray(payload.promptsInQueue) ? payload.promptsInQueue : [],
+			);
+		},
+		[postSession],
+	);
+
+	const updatePromptInQueue = useCallback(
+		async (promptId: string, prompt: string) => {
+			const activeSessionId = activeSessionIdRef.current;
+			if (!activeSessionId || !promptId.trim()) {
+				return;
+			}
+			const payload = await postSession({
+				action: "update_pending_prompt",
+				sessionId: activeSessionId,
+				promptId,
+				prompt,
+			});
+			setPromptsInQueue(
+				Array.isArray(payload.promptsInQueue) ? payload.promptsInQueue : [],
+			);
+		},
+		[postSession],
+	);
+
+	const removePromptInQueue = useCallback(
+		async (promptId: string): Promise<PromptInQueue | undefined> => {
+			const activeSessionId = activeSessionIdRef.current;
+			if (!activeSessionId || !promptId.trim()) {
+				return undefined;
+			}
+			const payload = await postSession({
+				action: "remove_pending_prompt",
+				sessionId: activeSessionId,
+				promptId,
+			});
+			setPromptsInQueue(
+				Array.isArray(payload.promptsInQueue) ? payload.promptsInQueue : [],
+			);
+			return payload.prompt;
+		},
+		[postSession],
+	);
+
+	const summary = useMemo(
+		() => ({
+			toolCalls,
+			tokensIn,
+			tokensOut,
+			additions: diffSummary.additions,
+			deletions: diffSummary.deletions,
+		}),
+		[
+			diffSummary.additions,
+			diffSummary.deletions,
+			tokensIn,
+			tokensOut,
+			toolCalls,
+		],
+	);
+
+	return {
+		sessionId,
+		status,
+		chatTransportState,
+		chatTransportError,
+		isHydratingSession,
+		activeAssistantMessageId,
+		config,
+		messages,
+		rawTranscript,
+		error,
+		summary,
+		fileDiffs,
+		promptsInQueue,
+		pendingToolApprovals,
+		pendingAskQuestions,
+		setConfig,
+		start,
+		hydrateSession,
+		sendPrompt,
+		steerPromptInQueue,
+		updatePromptInQueue,
+		removePromptInQueue,
+		approveToolApproval,
+		rejectToolApproval,
+		answerAskQuestion,
+		restoreCheckpoint,
+		forkSession,
+		abort,
+		stop: abort,
+		reset,
+	};
+}
diff --git a/apps/examples/desktop-app/webview/hooks/use-mobile.ts b/apps/examples/desktop-app/webview/hooks/use-mobile.ts
new file mode 100644
index 0000000..0a89231
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/use-mobile.ts
@@ -0,0 +1,21 @@
+import * as React from "react";
+
+const MOBILE_BREAKPOINT = 768;
+
+export function useIsMobile() {
+	const [isMobile, setIsMobile] = React.useState<boolean | undefined>(
+		undefined,
+	);
+
+	React.useEffect(() => {
+		const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+		const onChange = () => {
+			setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+		};
+		mql.addEventListener("change", onChange);
+		setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+		return () => mql.removeEventListener("change", onChange);
+	}, []);
+
+	return !!isMobile;
+}
diff --git a/apps/examples/desktop-app/webview/hooks/use-session-history.ts b/apps/examples/desktop-app/webview/hooks/use-session-history.ts
new file mode 100644
index 0000000..ccda264
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/use-session-history.ts
@@ -0,0 +1,1251 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeTitle } from "@/components/utils";
+import { toast } from "@/hooks/use-toast";
+import { desktopClient } from "@/lib/desktop-client";
+import type {
+	SessionHistoryItem,
+	SessionHistoryStatus,
+	SessionMetadata,
+} from "@/lib/session-history";
+import { getSessionMetadataTitle } from "@/lib/session-history";
+
+type CliDiscoveredSession = Omit<SessionHistoryItem, "status"> & {
+	status: string;
+};
+
+export interface SessionThread {
+	id: string;
+	title: string;
+	codebase: string;
+	time: string;
+	provider: string;
+	model: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCostUsd?: number;
+	status: SessionHistoryStatus;
+	pinned?: boolean;
+}
+
+type SessionHookEvent = {
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+};
+
+type SessionMessageMeta = {
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+	providerId?: string;
+	modelId?: string;
+};
+
+type SessionMessage = {
+	id?: string;
+	role?: string;
+	content?: string;
+	meta?: SessionMessageMeta;
+};
+
+type SessionTitleUpdatedEvent = CustomEvent<{
+	sessionId: string;
+	title: string;
+}>;
+
+type SessionDeletedEvent = CustomEvent<{
+	sessionId: string;
+}>;
+
+type SidecarSessionStateEvent = {
+	sessionId?: string;
+	status?: string;
+};
+
+type SidecarChatEvent = {
+	sessionId?: string;
+	stream?: string;
+};
+
+export type SessionPendingAction = {
+	sessionId: string;
+	action: "rename" | "fork" | "delete";
+} | null;
+
+export type UseSessionHistoryOptions = {
+	activeSessionId?: string | null;
+	onOpenSession?: (session: SessionHistoryItem) => void;
+	onDeleteSession?: (sessionId: string) => void;
+	onUpdateSessionMetadata?: (
+		sessionId: string,
+		metadata: SessionMetadata,
+	) => void;
+};
+
+const INITIAL_HISTORY_FETCH_LIMIT = 300;
+const HISTORY_REFRESH_INTERVAL_MS = 12_000;
+const MIN_EVENT_HISTORY_REFRESH_INTERVAL_MS = 2_000;
+const HISTORY_EVENT_REFRESH_DELAY_MS = 1_000;
+const HISTORY_FAST_REFRESH_DELAY_MS = 50;
+const HISTORY_TERMINAL_REFRESH_DELAY_MS = 250;
+
+export function parseTimestamp(value?: string): number {
+	if (!value) return Number.NEGATIVE_INFINITY;
+	const trimmed = value.trim();
+	const maybeEpoch = Number(trimmed);
+	if (Number.isFinite(maybeEpoch)) {
+		if (/^\d{10}$/.test(trimmed)) {
+			return maybeEpoch * 1000;
+		}
+		return maybeEpoch;
+	}
+	const parsed = new Date(trimmed).getTime();
+	return Number.isNaN(parsed) ? Number.NEGATIVE_INFINITY : parsed;
+}
+
+function compareSessionsByStartedAtDesc(
+	a: SessionHistoryItem,
+	b: SessionHistoryItem,
+): number {
+	const timeDelta = parseTimestamp(b.startedAt) - parseTimestamp(a.startedAt);
+	if (timeDelta !== 0) {
+		return timeDelta;
+	}
+	return b.sessionId.localeCompare(a.sessionId);
+}
+
+export function normalizeDiscoveredStatus(
+	status?: string,
+	prompt?: string,
+): SessionHistoryStatus {
+	const normalized = (status || "").toLowerCase();
+	const hasPrompt = Boolean(prompt?.trim());
+	if (normalized.includes("complete") || normalized.includes("done")) {
+		return "completed";
+	}
+	if (
+		normalized.includes("cancel") ||
+		normalized.includes("abort") ||
+		normalized.includes("interrupt")
+	) {
+		return "cancelled";
+	}
+	if (normalized.includes("fail") || normalized.includes("error")) {
+		return "failed";
+	}
+	if (normalized.includes("run") || normalized.includes("start")) {
+		return hasPrompt ? "running" : "idle";
+	}
+	if (normalized === "idle") return "idle";
+	return "idle";
+}
+
+function isTerminalHistoryStatus(status: SessionHistoryStatus): boolean {
+	return (
+		status === "completed" || status === "failed" || status === "cancelled"
+	);
+}
+
+export function formatRelativeTime(value?: string): string {
+	if (!value) return "just now";
+	const timestamp = parseTimestamp(value);
+	const date = Number.isFinite(timestamp)
+		? new Date(timestamp)
+		: new Date(value);
+	if (Number.isNaN(date.getTime())) return "";
+
+	const diffMs = Date.now() - date.getTime();
+	const minute = 60 * 1000;
+	const hour = 60 * minute;
+	const day = 24 * hour;
+
+	if (diffMs < minute) return "now";
+	if (diffMs < hour) return `${Math.max(1, Math.floor(diffMs / minute))}m`;
+	if (diffMs < day) return `${Math.max(1, Math.floor(diffMs / hour))}h`;
+	return `${Math.max(1, Math.floor(diffMs / day))}d`;
+}
+
+export function basenamePath(input?: string): string {
+	if (!input) return "workspace";
+	const trimmed = input.replace(/[\\/]+$/, "");
+	if (!trimmed) return "workspace";
+	const parts = trimmed.split(/[\\/]/);
+	return parts[parts.length - 1] || "workspace";
+}
+
+function toTitle(session: SessionHistoryItem): string {
+	const metadataTitle = getSessionMetadataTitle(session.metadata);
+	if (metadataTitle) {
+		return metadataTitle.slice(0, 70);
+	}
+	const line = normalizeTitle(session.prompt).trim().split("\n")[0]?.trim();
+	if (line) return line.slice(0, 70);
+	return `Session ${session.sessionId.slice(-6)}`;
+}
+
+function titleFromMessages(messages: SessionMessage[]): string | null {
+	for (const role of ["user", "assistant"] as const) {
+		for (const message of messages) {
+			if (message.role !== role) {
+				continue;
+			}
+			const content =
+				typeof message.content === "string" ? message.content : "";
+			const line = normalizeTitle(content).trim().split("\n")[0]?.trim();
+			if (line) {
+				return line.slice(0, 70);
+			}
+		}
+	}
+	return null;
+}
+
+function inferStatusFromMessages(
+	status: SessionHistoryStatus,
+	messages: SessionMessage[],
+): SessionHistoryStatus {
+	const meaningfulMessages = messages.filter((message) => {
+		if (message.role !== "user" && message.role !== "assistant") {
+			return false;
+		}
+		const content = typeof message.content === "string" ? message.content : "";
+		return content.trim().length > 0;
+	});
+	if (meaningfulMessages.length === 0) {
+		return status === "running" ? "running" : "idle";
+	}
+	const lastMeaningful = meaningfulMessages[meaningfulMessages.length - 1];
+	if (status === "failed" && lastMeaningful.role === "assistant") {
+		return "completed";
+	}
+	return status;
+}
+
+function toThread(session: SessionHistoryItem): SessionThread {
+	return {
+		id: session.sessionId,
+		title: toTitle(session),
+		codebase: basenamePath(session.workspaceRoot || session.cwd),
+		time: formatRelativeTime(session.endedAt || session.startedAt),
+		provider: session.provider || "",
+		model: session.model || "",
+		status: normalizeDiscoveredStatus(session.status, session.prompt),
+	};
+}
+
+function isKnownModelField(value?: string): boolean {
+	const trimmed = value?.trim().toLowerCase() ?? "";
+	return trimmed.length > 0 && trimmed !== "unknown";
+}
+
+function isValidHistorySession(session: SessionHistoryItem): boolean {
+	return (
+		Boolean(session.sessionId.trim()) &&
+		isKnownModelField(session.provider) &&
+		isKnownModelField(session.model)
+	);
+}
+
+export function formatTokenCount(
+	inputTokens?: number,
+	outputTokens?: number,
+): string | null {
+	const inCount = inputTokens ?? 0;
+	const outCount = outputTokens ?? 0;
+	const total = inCount + outCount;
+	if (total <= 0) {
+		return null;
+	}
+	if (total >= 1000) {
+		return `${(total / 1000).toFixed(total >= 10000 ? 0 : 1)}k`;
+	}
+	return `${total}`;
+}
+
+export function formatCostUsd(value?: number): string | null {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+		return null;
+	}
+	if (value < 0.01) {
+		return `$${value.toFixed(4)}`;
+	}
+	if (value < 1) {
+		return `$${value.toFixed(3)}`;
+	}
+	return `$${value.toFixed(2)}`;
+}
+
+function summarizeUsageFromMessages(messages: SessionMessage[]): {
+	inputTokens: number;
+	outputTokens: number;
+	totalCostUsd: number;
+} | null {
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let totalCostUsd = 0;
+	let hasUsage = false;
+
+	for (const message of messages) {
+		const meta = message.meta;
+		if (!meta) {
+			continue;
+		}
+		if (typeof meta.inputTokens === "number") {
+			inputTokens += meta.inputTokens;
+			hasUsage = true;
+		}
+		if (typeof meta.outputTokens === "number") {
+			outputTokens += meta.outputTokens;
+			hasUsage = true;
+		}
+		if (typeof meta.totalCost === "number") {
+			totalCostUsd += meta.totalCost;
+			hasUsage = true;
+		}
+	}
+
+	if (!hasUsage) {
+		return null;
+	}
+	return { inputTokens, outputTokens, totalCostUsd };
+}
+
+function areSessionsEquivalent(
+	current: SessionHistoryItem[],
+	next: SessionHistoryItem[],
+): boolean {
+	if (current.length !== next.length) {
+		return false;
+	}
+	for (let i = 0; i < current.length; i += 1) {
+		const a = current[i];
+		const b = next[i];
+		if (
+			a.sessionId !== b.sessionId ||
+			a.status !== b.status ||
+			a.startedAt !== b.startedAt ||
+			a.endedAt !== b.endedAt ||
+			a.prompt !== b.prompt ||
+			getSessionMetadataTitle(a.metadata) !==
+				getSessionMetadataTitle(b.metadata) ||
+			a.workspaceRoot !== b.workspaceRoot ||
+			a.cwd !== b.cwd ||
+			a.provider !== b.provider ||
+			a.model !== b.model
+		) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function areThreadsEquivalent(
+	current: SessionThread[],
+	next: SessionThread[],
+): boolean {
+	if (current.length !== next.length) {
+		return false;
+	}
+	for (let i = 0; i < current.length; i += 1) {
+		const a = current[i];
+		const b = next[i];
+		if (
+			a.id !== b.id ||
+			a.title !== b.title ||
+			a.codebase !== b.codebase ||
+			a.time !== b.time ||
+			a.provider !== b.provider ||
+			a.model !== b.model ||
+			a.inputTokens !== b.inputTokens ||
+			a.outputTokens !== b.outputTokens ||
+			a.totalCostUsd !== b.totalCostUsd ||
+			a.status !== b.status ||
+			a.pinned !== b.pinned
+		) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function updateThreadById(
+	current: SessionThread[],
+	threadId: string,
+	updater: (thread: SessionThread) => SessionThread,
+): SessionThread[] {
+	let changed = false;
+	const next = current.map((thread) => {
+		if (thread.id !== threadId) {
+			return thread;
+		}
+		const updated = updater(thread);
+		if (updated !== thread) {
+			changed = true;
+		}
+		return updated;
+	});
+	return changed ? next : current;
+}
+
+function updateSessionById(
+	current: SessionHistoryItem[],
+	sessionId: string,
+	updater: (session: SessionHistoryItem) => SessionHistoryItem,
+): SessionHistoryItem[] {
+	let changed = false;
+	const next = current.map((session) => {
+		if (session.sessionId !== sessionId) {
+			return session;
+		}
+		const updated = updater(session);
+		if (updated !== session) {
+			changed = true;
+		}
+		return updated;
+	});
+	return changed ? next : current;
+}
+
+function mergeDiscoveredSessions(
+	current: SessionHistoryItem[],
+	discovered: SessionHistoryItem[],
+): SessionHistoryItem[] {
+	if (current.length === 0) {
+		return discovered;
+	}
+	const currentById = new Map(
+		current.map((session) => [session.sessionId, session]),
+	);
+	return discovered.map((session) => {
+		const existing = currentById.get(session.sessionId);
+		if (!existing) {
+			return session;
+		}
+		const existingTitle = getSessionMetadataTitle(existing.metadata);
+		if (!existingTitle) {
+			return session;
+		}
+		const incomingTitle = getSessionMetadataTitle(session.metadata);
+		if (incomingTitle === existingTitle) {
+			return session;
+		}
+		return {
+			...session,
+			metadata: {
+				...(session.metadata ?? {}),
+				title: existingTitle,
+			},
+		};
+	});
+}
+
+export function useSessionHistory({
+	activeSessionId,
+	onOpenSession,
+	onDeleteSession,
+	onUpdateSessionMetadata,
+}: UseSessionHistoryOptions) {
+	const [sessions, setSessions] = useState<SessionHistoryItem[]>([]);
+	const [threads, setThreads] = useState<SessionThread[]>([]);
+	const [isLoadingHistory, setIsLoadingHistory] = useState(false);
+	const [isLoadingMore, setIsLoadingMore] = useState(false);
+	const [pendingAction, setPendingAction] =
+		useState<SessionPendingAction>(null);
+	const [unreadSessionIds, setUnreadSessionIds] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const fetchLimitRef = useRef(INITIAL_HISTORY_FETCH_LIMIT);
+	const usageLoadingRef = useRef<Set<string>>(new Set());
+	const usageHydratedStatusRef = useRef<Map<string, SessionHistoryStatus>>(
+		new Map(),
+	);
+	const titleLoadingRef = useRef<Set<string>>(new Set());
+	const messageHydratedStatusRef = useRef<Map<string, SessionHistoryStatus>>(
+		new Map(),
+	);
+	const sessionsRef = useRef<SessionHistoryItem[]>([]);
+	const threadsRef = useRef<SessionThread[]>([]);
+	const refreshTimeoutRef = useRef<number | null>(null);
+	const scheduledRefreshAtRef = useRef<number | null>(null);
+	const refreshPromiseRef = useRef<Promise<void> | null>(null);
+	const lastRefreshStartedAtRef = useRef(0);
+
+	useEffect(() => {
+		sessionsRef.current = sessions;
+	}, [sessions]);
+
+	useEffect(() => {
+		threadsRef.current = threads;
+	}, [threads]);
+
+	useEffect(() => {
+		if (!activeSessionId) {
+			return;
+		}
+		setUnreadSessionIds((current) => {
+			if (!current.has(activeSessionId)) {
+				return current;
+			}
+			const next = new Set(current);
+			next.delete(activeSessionId);
+			return next;
+		});
+	}, [activeSessionId]);
+
+	const refreshSessions = useCallback(async () => {
+		if (refreshPromiseRef.current) {
+			return refreshPromiseRef.current;
+		}
+
+		const refreshPromise = (async () => {
+			lastRefreshStartedAtRef.current = Date.now();
+			const limit = fetchLimitRef.current;
+			setIsLoadingHistory(true);
+			try {
+				const discovered = await desktopClient
+					.invoke<CliDiscoveredSession[]>("list_discovered_sessions", { limit })
+					.catch(() => []);
+				const topLevelSessions = discovered
+					.map((session) => {
+						const normalized: SessionHistoryItem = {
+							...session,
+							sessionId: String(session.sessionId ?? "").trim(),
+							status: normalizeDiscoveredStatus(session.status, session.prompt),
+							provider: session.provider || "",
+							model: session.model || "",
+							cwd: session.cwd || "",
+							workspaceRoot: session.workspaceRoot || session.cwd || "",
+							startedAt: String(session.startedAt ?? ""),
+							metadata:
+								session.metadata && typeof session.metadata === "object"
+									? (session.metadata as SessionMetadata)
+									: undefined,
+						};
+						return normalized;
+					})
+					.filter((session) => Boolean(session.sessionId))
+					.filter(isValidHistorySession)
+					.filter((session) => !session.isSubagent && !session.parentSessionId)
+					.sort(compareSessionsByStartedAtDesc);
+				const mergedSessions = mergeDiscoveredSessions(
+					sessionsRef.current,
+					topLevelSessions,
+				);
+
+				setSessions((current) =>
+					areSessionsEquivalent(current, mergedSessions)
+						? current
+						: mergedSessions,
+				);
+				const mapped = mergedSessions.map(toThread);
+				const metadataTitleById = new Map(
+					mergedSessions.map((session) => [
+						session.sessionId,
+						getSessionMetadataTitle(session.metadata),
+					]),
+				);
+				setThreads((current) => {
+					const existingById = new Map(
+						current.map((thread) => [thread.id, thread]),
+					);
+					const usageById = new Map(
+						current.map((thread) => [
+							thread.id,
+							{
+								inputTokens: thread.inputTokens,
+								outputTokens: thread.outputTokens,
+								totalCostUsd: thread.totalCostUsd,
+							},
+						]),
+					);
+					const next = mapped.map((thread) => {
+						const existing = existingById.get(thread.id);
+						const incomingMetadataTitle = metadataTitleById.get(thread.id);
+						const keepExistingTitle =
+							Boolean(existing) &&
+							!incomingMetadataTitle &&
+							!(existing?.title.startsWith("Session ") ?? true);
+						return {
+							...thread,
+							title:
+								keepExistingTitle && existing ? existing.title : thread.title,
+							...usageById.get(thread.id),
+						};
+					});
+					return areThreadsEquivalent(current, next) ? current : next;
+				});
+			} catch {
+				// Ignore in browser mode or when tauri command is unavailable.
+			} finally {
+				setIsLoadingHistory(false);
+			}
+		})();
+
+		refreshPromiseRef.current = refreshPromise;
+		try {
+			await refreshPromise;
+		} finally {
+			if (refreshPromiseRef.current === refreshPromise) {
+				refreshPromiseRef.current = null;
+			}
+		}
+	}, []);
+
+	const scheduleRefresh = useCallback(
+		(delayMs = 0, options: { force?: boolean } = {}) => {
+			const now = Date.now();
+			const minTarget = options.force
+				? now
+				: lastRefreshStartedAtRef.current +
+					MIN_EVENT_HISTORY_REFRESH_INTERVAL_MS;
+			const target = Math.max(now + delayMs, minTarget);
+			if (
+				refreshTimeoutRef.current !== null &&
+				scheduledRefreshAtRef.current !== null &&
+				scheduledRefreshAtRef.current <= target
+			) {
+				return;
+			}
+			if (refreshTimeoutRef.current !== null) {
+				window.clearTimeout(refreshTimeoutRef.current);
+			}
+			scheduledRefreshAtRef.current = target;
+			refreshTimeoutRef.current = window.setTimeout(
+				() => {
+					refreshTimeoutRef.current = null;
+					scheduledRefreshAtRef.current = null;
+					void refreshSessions();
+				},
+				Math.max(0, target - now),
+			);
+		},
+		[refreshSessions],
+	);
+
+	useEffect(() => {
+		let disposed = false;
+
+		const runRefresh = () => {
+			if (!disposed) {
+				scheduleRefresh(0, { force: true });
+			}
+		};
+
+		runRefresh();
+		const interval = window.setInterval(() => {
+			if (document.hidden) {
+				return;
+			}
+			runRefresh();
+		}, HISTORY_REFRESH_INTERVAL_MS);
+
+		return () => {
+			disposed = true;
+			window.clearInterval(interval);
+			if (refreshTimeoutRef.current !== null) {
+				window.clearTimeout(refreshTimeoutRef.current);
+				refreshTimeoutRef.current = null;
+				scheduledRefreshAtRef.current = null;
+			}
+		};
+	}, [scheduleRefresh]);
+
+	useEffect(() => {
+		const recent = sessions
+			.filter((session) => session.sessionId !== activeSessionId)
+			.slice(0, 4);
+		let cancelled = false;
+		const timer = window.setTimeout(() => {
+			for (const session of recent) {
+				if (cancelled) {
+					return;
+				}
+				const sessionId = session.sessionId;
+				if (!sessionId) {
+					continue;
+				}
+				if (usageLoadingRef.current.has(sessionId)) {
+					continue;
+				}
+				const existing = threadsRef.current.find(
+					(item) => item.id === sessionId,
+				);
+				const hasUsage =
+					existing?.inputTokens !== undefined ||
+					existing?.outputTokens !== undefined;
+				const lastHydratedStatus =
+					usageHydratedStatusRef.current.get(sessionId);
+				const shouldFetch =
+					!hasUsage ||
+					session.status === "running" ||
+					lastHydratedStatus !== session.status;
+				if (!shouldFetch) {
+					continue;
+				}
+				usageLoadingRef.current.add(sessionId);
+				void desktopClient
+					.invoke<SessionMessage[]>("read_session_messages", {
+						sessionId,
+						maxMessages: 1200,
+					})
+					.then(async (sessionMessages) => {
+						const usage = summarizeUsageFromMessages(sessionMessages);
+						if (!usage) {
+							const events = await desktopClient.invoke<SessionHookEvent[]>(
+								"read_session_hooks",
+								{
+									sessionId,
+									limit: 1200,
+								},
+							);
+							return {
+								inputTokens: events.reduce(
+									(sum, event) => sum + (event.inputTokens ?? 0),
+									0,
+								),
+								outputTokens: events.reduce(
+									(sum, event) => sum + (event.outputTokens ?? 0),
+									0,
+								),
+								totalCostUsd: events.reduce(
+									(sum, event) => sum + (event.totalCost ?? 0),
+									0,
+								),
+							};
+						}
+						return usage;
+					})
+					.then(({ inputTokens, outputTokens, totalCostUsd }) => {
+						setThreads((current) =>
+							updateThreadById(current, sessionId, (thread) => {
+								if (
+									thread.inputTokens === inputTokens &&
+									thread.outputTokens === outputTokens &&
+									thread.totalCostUsd === totalCostUsd
+								) {
+									return thread;
+								}
+								return { ...thread, inputTokens, outputTokens, totalCostUsd };
+							}),
+						);
+					})
+					.catch(() => {
+						if (!hasUsage) {
+							setThreads((current) =>
+								updateThreadById(current, sessionId, (thread) => {
+									if (
+										thread.inputTokens === 0 &&
+										thread.outputTokens === 0 &&
+										(thread.totalCostUsd ?? 0) === 0
+									) {
+										return thread;
+									}
+									return {
+										...thread,
+										inputTokens: 0,
+										outputTokens: 0,
+										totalCostUsd: 0,
+									};
+								}),
+							);
+						}
+					})
+					.finally(() => {
+						usageHydratedStatusRef.current.set(sessionId, session.status);
+						usageLoadingRef.current.delete(sessionId);
+					});
+			}
+		}, 800);
+		return () => {
+			cancelled = true;
+			window.clearTimeout(timer);
+		};
+	}, [activeSessionId, sessions]);
+
+	useEffect(() => {
+		const handleTitleUpdated = (event: Event) => {
+			const detail = (event as SessionTitleUpdatedEvent).detail;
+			const sessionId = detail?.sessionId?.trim();
+			if (!sessionId) {
+				return;
+			}
+			const nextTitle = detail.title.trim();
+			setSessions((current) =>
+				updateSessionById(current, sessionId, (session) => ({
+					...session,
+					metadata: {
+						...(session.metadata ?? {}),
+						title: nextTitle || undefined,
+					},
+				})),
+			);
+			setThreads((current) =>
+				updateThreadById(current, sessionId, (thread) => ({
+					...thread,
+					title: nextTitle || `Session ${sessionId.slice(-6)}`,
+				})),
+			);
+		};
+
+		const handleSessionDeleted = (event: Event) => {
+			const detail = (event as SessionDeletedEvent).detail;
+			const sessionId = detail?.sessionId?.trim();
+			if (!sessionId) {
+				return;
+			}
+			usageLoadingRef.current.delete(sessionId);
+			titleLoadingRef.current.delete(sessionId);
+			usageHydratedStatusRef.current.delete(sessionId);
+			messageHydratedStatusRef.current.delete(sessionId);
+			setSessions((current) =>
+				current.filter((session) => session.sessionId !== sessionId),
+			);
+			setThreads((current) =>
+				current.filter((thread) => thread.id !== sessionId),
+			);
+			scheduleRefresh(HISTORY_FAST_REFRESH_DELAY_MS, { force: true });
+		};
+
+		window.addEventListener(
+			"cline:session-title-updated",
+			handleTitleUpdated as EventListener,
+		);
+		window.addEventListener(
+			"cline:session-deleted",
+			handleSessionDeleted as EventListener,
+		);
+		const unsubscribeTransportDelete = desktopClient.subscribe(
+			"session_deleted",
+			(payload) => {
+				if (!payload || typeof payload !== "object") {
+					return;
+				}
+				const sessionId =
+					typeof (payload as { sessionId?: unknown }).sessionId === "string"
+						? (payload as { sessionId: string }).sessionId.trim()
+						: "";
+				if (!sessionId) {
+					return;
+				}
+				handleSessionDeleted(
+					new CustomEvent("cline:session-deleted", {
+						detail: { sessionId },
+					}),
+				);
+			},
+		);
+		const unsubscribeTransportStatus = desktopClient.subscribe(
+			"chat_session_status",
+			(payload) => {
+				if (!payload || typeof payload !== "object") {
+					return;
+				}
+				const record = payload as SidecarSessionStateEvent;
+				const sessionId = record.sessionId?.trim();
+				if (!sessionId) {
+					return;
+				}
+				const known = sessionsRef.current.some(
+					(session) => session.sessionId === sessionId,
+				);
+				const status = normalizeDiscoveredStatus(record.status);
+				if (!known) {
+					scheduleRefresh(HISTORY_EVENT_REFRESH_DELAY_MS);
+				} else if (isTerminalHistoryStatus(status)) {
+					scheduleRefresh(HISTORY_TERMINAL_REFRESH_DELAY_MS, {
+						force: true,
+					});
+				}
+				if (sessionId !== activeSessionId) {
+					setUnreadSessionIds((current) => {
+						const next = new Set(current);
+						next.add(sessionId);
+						return next;
+					});
+				}
+			},
+		);
+		const unsubscribeTransportEnded = desktopClient.subscribe(
+			"chat_session_ended",
+			(payload) => {
+				if (!payload || typeof payload !== "object") {
+					return;
+				}
+				const record = payload as SidecarSessionStateEvent;
+				if (record.sessionId?.trim()) {
+					scheduleRefresh(HISTORY_TERMINAL_REFRESH_DELAY_MS, {
+						force: true,
+					});
+					const sessionId = record.sessionId.trim();
+					if (sessionId !== activeSessionId) {
+						setUnreadSessionIds((current) => {
+							const next = new Set(current);
+							next.add(sessionId);
+							return next;
+						});
+					}
+				}
+			},
+		);
+		const unsubscribeTransportChatEvent = desktopClient.subscribe(
+			"chat_event",
+			(payload) => {
+				if (!payload || typeof payload !== "object") {
+					return;
+				}
+				const record = payload as SidecarChatEvent;
+				const sessionId = record.sessionId?.trim();
+				if (!sessionId) {
+					return;
+				}
+				const known = sessionsRef.current.some(
+					(session) => session.sessionId === sessionId,
+				);
+				if (!known) {
+					scheduleRefresh(HISTORY_EVENT_REFRESH_DELAY_MS);
+				}
+				if (sessionId !== activeSessionId) {
+					setUnreadSessionIds((current) => {
+						const next = new Set(current);
+						next.add(sessionId);
+						return next;
+					});
+				}
+			},
+		);
+		return () => {
+			window.removeEventListener(
+				"cline:session-title-updated",
+				handleTitleUpdated as EventListener,
+			);
+			window.removeEventListener(
+				"cline:session-deleted",
+				handleSessionDeleted as EventListener,
+			);
+			unsubscribeTransportDelete();
+			unsubscribeTransportStatus();
+			unsubscribeTransportEnded();
+			unsubscribeTransportChatEvent();
+		};
+	}, [activeSessionId, scheduleRefresh]);
+
+	useEffect(() => {
+		const recent = sessions
+			.filter((session) => session.sessionId !== activeSessionId)
+			.slice(0, 4);
+		let cancelled = false;
+		const timer = window.setTimeout(() => {
+			for (const session of recent) {
+				if (cancelled) {
+					return;
+				}
+				const sessionId = session.sessionId;
+				if (!sessionId) {
+					continue;
+				}
+				if (titleLoadingRef.current.has(sessionId)) {
+					continue;
+				}
+				const existing = threadsRef.current.find(
+					(item) => item.id === sessionId,
+				);
+				if (!existing) {
+					continue;
+				}
+				const lastHydratedStatus =
+					messageHydratedStatusRef.current.get(sessionId);
+				const shouldHydrateTitle = existing.title.startsWith("Session ");
+				const hasManualTitle = Boolean(
+					getSessionMetadataTitle(session.metadata),
+				);
+				const shouldHydrateStatus =
+					existing.status === "failed" ||
+					existing.status === "completed" ||
+					existing.status === "idle" ||
+					lastHydratedStatus !== session.status;
+				if ((!shouldHydrateTitle || hasManualTitle) && !shouldHydrateStatus) {
+					continue;
+				}
+				titleLoadingRef.current.add(sessionId);
+				void desktopClient
+					.invoke<SessionMessage[]>("read_session_messages", {
+						sessionId,
+						maxMessages: 80,
+					})
+					.then((messages) => {
+						const nextTitle = hasManualTitle
+							? null
+							: titleFromMessages(messages);
+						setThreads((current) =>
+							updateThreadById(current, sessionId, (thread) => {
+								const nextStatus = inferStatusFromMessages(
+									thread.status,
+									messages,
+								);
+								const title = nextTitle ?? thread.title;
+								if (title === thread.title && nextStatus === thread.status) {
+									return thread;
+								}
+								return { ...thread, title, status: nextStatus };
+							}),
+						);
+						setSessions((current) =>
+							updateSessionById(current, sessionId, (item) => {
+								const nextStatus = inferStatusFromMessages(
+									item.status,
+									messages,
+								);
+								if (nextStatus === item.status) {
+									return item;
+								}
+								return { ...item, status: nextStatus };
+							}),
+						);
+					})
+					.catch(() => {
+						// Ignore sessions that cannot be hydrated.
+					})
+					.finally(() => {
+						messageHydratedStatusRef.current.set(sessionId, session.status);
+						titleLoadingRef.current.delete(sessionId);
+					});
+			}
+		}, 1200);
+		return () => {
+			cancelled = true;
+			window.clearTimeout(timer);
+		};
+	}, [activeSessionId, sessions]);
+
+	const getSessionByThreadId = useCallback(
+		(threadId: string) =>
+			sessionsRef.current.find((session) => session.sessionId === threadId),
+		[],
+	);
+
+	const openThread = useCallback(
+		(threadId: string) => {
+			const session = getSessionByThreadId(threadId);
+			if (session) {
+				setUnreadSessionIds((current) => {
+					if (!current.has(threadId)) {
+						return current;
+					}
+					const next = new Set(current);
+					next.delete(threadId);
+					return next;
+				});
+				onOpenSession?.(session);
+			}
+		},
+		[getSessionByThreadId, onOpenSession],
+	);
+
+	const renameThread = useCallback(
+		async (threadId: string, title: string) => {
+			if (pendingAction?.action === "rename") {
+				return false;
+			}
+			const thread = threadsRef.current.find((item) => item.id === threadId);
+			const currentTitle = normalizeTitle(thread?.title ?? "");
+			const normalizedTitle = normalizeTitle(title).trim();
+			if (normalizedTitle === currentTitle) {
+				return true;
+			}
+			setPendingAction({ sessionId: threadId, action: "rename" });
+			try {
+				await desktopClient.invoke("update_chat_session_title", {
+					sessionId: threadId,
+					title: normalizedTitle,
+				});
+				const sourceSession = getSessionByThreadId(threadId);
+				const metadata = {
+					...(sourceSession?.metadata ?? {}),
+					title: normalizedTitle || undefined,
+				};
+				onUpdateSessionMetadata?.(threadId, metadata);
+				window.dispatchEvent(
+					new CustomEvent("cline:session-title-updated", {
+						detail: {
+							sessionId: threadId,
+							title: normalizedTitle,
+						},
+					}),
+				);
+				return true;
+			} catch (error) {
+				toast({
+					variant: "destructive",
+					title: "Rename failed",
+					description:
+						error instanceof Error
+							? error.message
+							: "The session title could not be updated.",
+				});
+				return false;
+			} finally {
+				setPendingAction(null);
+			}
+		},
+		[getSessionByThreadId, onUpdateSessionMetadata, pendingAction],
+	);
+
+	const forkThread = useCallback(
+		async (threadId: string) => {
+			const thread = threadsRef.current.find((item) => item.id === threadId);
+			if (!thread) {
+				return false;
+			}
+			const sourceSession = getSessionByThreadId(threadId);
+			setPendingAction({ sessionId: threadId, action: "fork" });
+			try {
+				const payload = await desktopClient.invoke<{
+					sessionId?: string;
+					forkedFromSessionId?: string;
+				}>("chat_session_command", {
+					request: {
+						action: "fork",
+						sessionId: threadId,
+						config: {
+							provider: sourceSession?.provider || thread.provider,
+							model: sourceSession?.model || thread.model,
+							cwd: sourceSession?.cwd || sourceSession?.workspaceRoot || "",
+							workspaceRoot:
+								sourceSession?.workspaceRoot || sourceSession?.cwd || "",
+						},
+					},
+				});
+				const newSessionId = payload.sessionId?.trim();
+				if (!newSessionId) {
+					throw new Error("Fork did not return a new session id.");
+				}
+				const forkedSession: SessionHistoryItem = {
+					sessionId: newSessionId,
+					status: "completed",
+					provider: sourceSession?.provider || thread.provider,
+					model: sourceSession?.model || thread.model,
+					cwd: sourceSession?.cwd || "",
+					workspaceRoot:
+						sourceSession?.workspaceRoot || sourceSession?.cwd || "",
+					startedAt: new Date().toISOString(),
+					metadata: {
+						fork: {
+							forkedFromSessionId: payload.forkedFromSessionId || threadId,
+							forkedAt: new Date().toISOString(),
+						},
+					},
+				};
+				scheduleRefresh(HISTORY_FAST_REFRESH_DELAY_MS);
+				onOpenSession?.(forkedSession);
+				return true;
+			} catch (error) {
+				toast({
+					variant: "destructive",
+					title: "Fork failed",
+					description:
+						error instanceof Error
+							? error.message
+							: "The session could not be forked.",
+				});
+				return false;
+			} finally {
+				setPendingAction(null);
+			}
+		},
+		[getSessionByThreadId, onOpenSession, scheduleRefresh],
+	);
+
+	const deleteThread = useCallback(
+		async (threadId: string) => {
+			setPendingAction({ sessionId: threadId, action: "delete" });
+			try {
+				console.error(
+					`[webview:delete] invoke delete_chat_session sessionId=${threadId}`,
+				);
+				const deleteResult = await desktopClient.invoke<
+					boolean | { deleted?: boolean }
+				>("delete_chat_session", {
+					sessionId: threadId,
+				});
+				const deleted =
+					typeof deleteResult === "boolean"
+						? deleteResult
+						: deleteResult.deleted === true;
+				console.error(
+					`[webview:delete] invoke result sessionId=${threadId} deleted=${deleted}`,
+				);
+				if (!deleted) {
+					throw new Error(
+						"The session could not be removed from local history.",
+					);
+				}
+				onDeleteSession?.(threadId);
+				window.dispatchEvent(
+					new CustomEvent("cline:session-deleted", {
+						detail: {
+							sessionId: threadId,
+						},
+					}),
+				);
+				return true;
+			} catch (error) {
+				toast({
+					variant: "destructive",
+					title: "Delete failed",
+					description:
+						error instanceof Error
+							? error.message
+							: "The session could not be removed from local history.",
+				});
+				return false;
+			} finally {
+				setPendingAction(null);
+			}
+		},
+		[onDeleteSession],
+	);
+
+	const loadMoreSessions = useCallback(
+		async (nextLimit: number) => {
+			if (fetchLimitRef.current >= nextLimit) {
+				return;
+			}
+			fetchLimitRef.current = nextLimit;
+			setIsLoadingMore(true);
+			try {
+				await refreshSessions();
+			} finally {
+				setIsLoadingMore(false);
+			}
+		},
+		[refreshSessions],
+	);
+
+	const mayHaveMoreSessions = sessions.length >= fetchLimitRef.current;
+	const sessionById = useMemo(
+		() => new Map(sessions.map((session) => [session.sessionId, session])),
+		[sessions],
+	);
+
+	return {
+		getSessionByThreadId,
+		isLoadingHistory,
+		isLoadingMore,
+		loadMoreSessions,
+		mayHaveMoreSessions,
+		openThread,
+		pendingAction,
+		refreshSessions,
+		renameThread,
+		deleteThread,
+		forkThread,
+		sessionById,
+		sessions,
+		threads,
+		unreadSessionIds,
+	};
+}
+
+export type UseSessionHistoryResult = ReturnType<typeof useSessionHistory>;
diff --git a/apps/examples/desktop-app/webview/hooks/use-toast.ts b/apps/examples/desktop-app/webview/hooks/use-toast.ts
new file mode 100644
index 0000000..7997c77
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/use-toast.ts
@@ -0,0 +1,191 @@
+"use client";
+
+// Inspired by react-hot-toast library
+import * as React from "react";
+
+import type { ToastActionElement, ToastProps } from "@/components/ui/toast";
+
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+
+type ToasterToast = ToastProps & {
+	id: string;
+	title?: React.ReactNode;
+	description?: React.ReactNode;
+	action?: ToastActionElement;
+};
+
+const actionTypes = {
+	ADD_TOAST: "ADD_TOAST",
+	UPDATE_TOAST: "UPDATE_TOAST",
+	DISMISS_TOAST: "DISMISS_TOAST",
+	REMOVE_TOAST: "REMOVE_TOAST",
+} as const;
+
+let count = 0;
+
+function genId() {
+	count = (count + 1) % Number.MAX_SAFE_INTEGER;
+	return count.toString();
+}
+
+type ActionType = typeof actionTypes;
+
+type Action =
+	| {
+			type: ActionType["ADD_TOAST"];
+			toast: ToasterToast;
+	  }
+	| {
+			type: ActionType["UPDATE_TOAST"];
+			toast: Partial<ToasterToast>;
+	  }
+	| {
+			type: ActionType["DISMISS_TOAST"];
+			toastId?: ToasterToast["id"];
+	  }
+	| {
+			type: ActionType["REMOVE_TOAST"];
+			toastId?: ToasterToast["id"];
+	  };
+
+interface State {
+	toasts: ToasterToast[];
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>();
+
+const addToRemoveQueue = (toastId: string) => {
+	if (toastTimeouts.has(toastId)) {
+		return;
+	}
+
+	const timeout = setTimeout(() => {
+		toastTimeouts.delete(toastId);
+		dispatch({
+			type: "REMOVE_TOAST",
+			toastId: toastId,
+		});
+	}, TOAST_REMOVE_DELAY);
+
+	toastTimeouts.set(toastId, timeout);
+};
+
+export const reducer = (state: State, action: Action): State => {
+	switch (action.type) {
+		case "ADD_TOAST":
+			return {
+				...state,
+				toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+			};
+
+		case "UPDATE_TOAST":
+			return {
+				...state,
+				toasts: state.toasts.map((t) =>
+					t.id === action.toast.id ? { ...t, ...action.toast } : t,
+				),
+			};
+
+		case "DISMISS_TOAST": {
+			const { toastId } = action;
+
+			// ! Side effects ! - This could be extracted into a dismissToast() action,
+			// but I'll keep it here for simplicity
+			if (toastId) {
+				addToRemoveQueue(toastId);
+			} else {
+				state.toasts.forEach((toast) => {
+					addToRemoveQueue(toast.id);
+				});
+			}
+
+			return {
+				...state,
+				toasts: state.toasts.map((t) =>
+					t.id === toastId || toastId === undefined
+						? {
+								...t,
+								open: false,
+							}
+						: t,
+				),
+			};
+		}
+		case "REMOVE_TOAST":
+			if (action.toastId === undefined) {
+				return {
+					...state,
+					toasts: [],
+				};
+			}
+			return {
+				...state,
+				toasts: state.toasts.filter((t) => t.id !== action.toastId),
+			};
+	}
+};
+
+const listeners: Array<(state: State) => void> = [];
+
+let memoryState: State = { toasts: [] };
+
+function dispatch(action: Action) {
+	memoryState = reducer(memoryState, action);
+	listeners.forEach((listener) => {
+		listener(memoryState);
+	});
+}
+
+type Toast = Omit<ToasterToast, "id">;
+
+function toast({ ...props }: Toast) {
+	const id = genId();
+
+	const update = (props: ToasterToast) =>
+		dispatch({
+			type: "UPDATE_TOAST",
+			toast: { ...props, id },
+		});
+	const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+
+	dispatch({
+		type: "ADD_TOAST",
+		toast: {
+			...props,
+			id,
+			open: true,
+			onOpenChange: (open) => {
+				if (!open) dismiss();
+			},
+		},
+	});
+
+	return {
+		id: id,
+		dismiss,
+		update,
+	};
+}
+
+function useToast() {
+	const [state, setState] = React.useState<State>(memoryState);
+
+	React.useEffect(() => {
+		listeners.push(setState);
+		return () => {
+			const index = listeners.indexOf(setState);
+			if (index > -1) {
+				listeners.splice(index, 1);
+			}
+		};
+	}, []);
+
+	return {
+		...state,
+		toast,
+		dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+	};
+}
+
+export { useToast, toast };
diff --git a/apps/examples/desktop-app/webview/lib/chat-schema.ts b/apps/examples/desktop-app/webview/lib/chat-schema.ts
new file mode 100644
index 0000000..6bbc25b
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/chat-schema.ts
@@ -0,0 +1,100 @@
+import { z } from "zod";
+
+export const ChatSessionConfigSchema = z.object({
+	sessionId: z.string().min(1).optional(),
+	workspaceRoot: z.string().min(1),
+	cwd: z.string().optional(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	mode: z.enum(["act", "plan"]).default("act"),
+	apiKey: z.string(),
+	systemPrompt: z.string().optional(),
+	rules: z.string().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	thinking: z.boolean().optional(),
+	reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]).optional(),
+	enableTools: z.boolean(),
+	enableSpawn: z.boolean().optional(),
+	enableTeams: z.boolean().optional(),
+	autoApproveTools: z.boolean().optional(),
+	missionStepInterval: z.number().int().positive().optional(),
+	missionTimeIntervalMs: z.number().int().positive().optional(),
+});
+
+export const ChatSessionStatusSchema = z.enum([
+	"idle",
+	"starting",
+	"running",
+	"stopping",
+	"completed",
+	"cancelled",
+	"failed",
+	"error",
+]);
+
+export const ChatMessageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"tool",
+	"system",
+	"status",
+	"error",
+]);
+
+export const ChatMessageSchema = z.object({
+	id: z.string().min(1),
+	sessionId: z.string().nullable(),
+	role: ChatMessageRoleSchema,
+	content: z.string(),
+	reasoning: z.string().optional(),
+	reasoningRedacted: z.boolean().optional(),
+	createdAt: z.number().int().nonnegative(),
+	meta: z
+		.object({
+			stream: z.enum(["stdout", "stderr"]).optional(),
+			toolName: z.string().optional(),
+			iteration: z.number().int().nonnegative().optional(),
+			agentId: z.string().optional(),
+			conversationId: z.string().optional(),
+			hookEventName: z.string().optional(),
+			messageKind: z.string().optional(),
+			displayRole: z.string().optional(),
+			reason: z.string().optional(),
+			inputTokens: z.number().int().nonnegative().optional(),
+			outputTokens: z.number().int().nonnegative().optional(),
+			totalCost: z.number().nonnegative().optional(),
+			providerId: z.string().optional(),
+			modelId: z.string().optional(),
+			checkpoint: z
+				.object({
+					ref: z.string(),
+					createdAt: z.number().int().nonnegative(),
+					runCount: z.number().int().positive(),
+					kind: z.enum(["stash", "commit"]).optional(),
+				})
+				.optional(),
+		})
+		.optional(),
+});
+
+export const ChatSummarySchema = z.object({
+	toolCalls: z.number().int().nonnegative(),
+	tokensIn: z.number().int().nonnegative(),
+	tokensOut: z.number().int().nonnegative(),
+});
+
+export const ChatViewStateSchema = z.object({
+	sessionId: z.string().nullable(),
+	status: ChatSessionStatusSchema,
+	config: ChatSessionConfigSchema,
+	messages: z.array(ChatMessageSchema),
+	rawTranscript: z.string(),
+	error: z.string().nullable(),
+	summary: ChatSummarySchema,
+});
+
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;
diff --git a/apps/examples/desktop-app/webview/lib/desktop-client.ts b/apps/examples/desktop-app/webview/lib/desktop-client.ts
new file mode 100644
index 0000000..d748339
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/desktop-client.ts
@@ -0,0 +1,341 @@
+"use client";
+
+import type {
+	DesktopTransportEvent,
+	DesktopTransportMessage,
+	DesktopTransportRequest,
+	DesktopTransportResponse,
+	DesktopTransportState,
+} from "@/lib/desktop-transport";
+
+// Lazily import the Tauri invoke API only when available. When running in
+// sidecar/web mode (without Tauri), this module may not exist or the bridge
+// may not be initialised, so we fall back to a hardcoded local WS endpoint.
+async function tryTauriInvoke<T>(
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<T> {
+	try {
+		const { invoke } = await import("@tauri-apps/api/core");
+		return await invoke<T>(command, args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Tauri invoke failed for ${command}: ${message}`);
+	}
+}
+
+/** Resolved once on first call; cached for subsequent calls. */
+let resolvedEndpointCache: string | null = null;
+
+/**
+ * Resolve the backend WebSocket endpoint.
+ *
+ * Priority order:
+ * 1. `window.__SIDECAR_WS_ENDPOINT__` — injected by the sidecar's HTML scaffold
+ *    or an integration test harness.
+ * 2. Tauri `get_desktop_backend_endpoint` command — used when running inside
+ *    the full Tauri app shell.
+ * 3. Fallback to `ws://127.0.0.1:3126/transport` — the sidecar's default port
+ *    when running in plain web/dev mode (`bun run dev:sidecar` + `bun run dev:web`).
+ */
+export async function resolveDesktopBackendWsEndpoint(): Promise<string> {
+	if (resolvedEndpointCache) return resolvedEndpointCache;
+
+	// 1. Explicit injection from sidecar or test harness.
+	const injected =
+		typeof window !== "undefined"
+			? (window as unknown as Record<string, unknown>).__SIDECAR_WS_ENDPOINT__
+			: undefined;
+	if (typeof injected === "string" && injected.trim()) {
+		resolvedEndpointCache = injected.trim();
+		return resolvedEndpointCache;
+	}
+
+	// 2. Tauri command (full desktop app).
+	if (isTauriAvailable()) {
+		const endpoint = await tryTauriInvoke<string>(
+			"get_desktop_backend_endpoint",
+		);
+		const trimmed = endpoint.trim();
+		if (trimmed) {
+			resolvedEndpointCache = trimmed;
+			return resolvedEndpointCache;
+		}
+		throw new Error("Tauri returned an empty desktop backend endpoint");
+	}
+
+	// 3. Default sidecar port for local dev mode without the Tauri bridge.
+	resolvedEndpointCache = "ws://127.0.0.1:3126/transport";
+	return resolvedEndpointCache;
+}
+
+export async function resolveDesktopBackendHttpEndpoint(): Promise<string> {
+	const wsEndpoint = await resolveDesktopBackendWsEndpoint();
+	const endpoint = new URL(wsEndpoint);
+	endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
+	if (endpoint.pathname.endsWith("/transport")) {
+		endpoint.pathname = endpoint.pathname.slice(0, -"/transport".length);
+	}
+	endpoint.search = "";
+	endpoint.hash = "";
+	return endpoint.toString().replace(/\/$/, "");
+}
+
+type PendingRequest = {
+	resolve: (value: unknown) => void;
+	reject: (error: Error) => void;
+	timeoutId: ReturnType<typeof setTimeout>;
+};
+
+type EventHandler = (payload: unknown) => void;
+type TransportStateHandler = (state: DesktopTransportState) => void;
+
+const REQUEST_TIMEOUT_MS = 120_000;
+const RECONNECT_BASE_DELAY_MS = 400;
+const RECONNECT_MAX_DELAY_MS = 4_000;
+// Commands that should be routed to Tauri's native invoke bridge instead of
+// the WebSocket transport — only applicable in the full Tauri app shell.
+// In sidecar/web mode these commands are handled by the sidecar over WebSocket.
+function isTauriAvailable(): boolean {
+	return typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+}
+
+const NATIVE_COMMANDS = new Set([
+	"pick_workspace_directory",
+	"open_mcp_settings_file",
+]);
+
+class DesktopClient {
+	private socket: WebSocket | null = null;
+	private connectPromise: Promise<void> | null = null;
+	private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private requestCounter = 0;
+	private pending = new Map<string, PendingRequest>();
+	private handlers = new Map<string, Set<EventHandler>>();
+	private transportStateHandlers = new Set<TransportStateHandler>();
+	private transportState: DesktopTransportState = "connecting";
+	private transportError: string | null = null;
+	private hasConnectedOnce = false;
+	private endpoint: string | null = null;
+
+	private setTransportState(next: DesktopTransportState) {
+		this.transportState = next;
+		for (const handler of this.transportStateHandlers) {
+			handler(next);
+		}
+	}
+
+	private async getBackendEndpoint(): Promise<string> {
+		if (this.endpoint?.trim()) {
+			return this.endpoint;
+		}
+		const endpoint = await resolveDesktopBackendWsEndpoint();
+		this.endpoint = endpoint;
+		return this.endpoint;
+	}
+
+	private rejectPending(errorMessage: string) {
+		for (const [requestId, pending] of this.pending.entries()) {
+			clearTimeout(pending.timeoutId);
+			this.pending.delete(requestId);
+			pending.reject(new Error(errorMessage));
+		}
+	}
+
+	private dispatchEvent(message: DesktopTransportEvent) {
+		const handlers = this.handlers.get(message.event.name);
+		if (!handlers || handlers.size === 0) {
+			return;
+		}
+		for (const handler of handlers) {
+			handler(message.event.payload);
+		}
+	}
+
+	private handleMessage(raw: string) {
+		let parsed: DesktopTransportMessage;
+		try {
+			parsed = JSON.parse(raw) as DesktopTransportMessage;
+		} catch {
+			return;
+		}
+
+		if (parsed.type === "event") {
+			this.dispatchEvent(parsed);
+			return;
+		}
+
+		const response = parsed as DesktopTransportResponse;
+		const pending = this.pending.get(response.id);
+		if (!pending) {
+			return;
+		}
+		clearTimeout(pending.timeoutId);
+		this.pending.delete(response.id);
+		if (!response.ok) {
+			pending.reject(new Error(response.error || "Desktop command failed"));
+			return;
+		}
+		pending.resolve(response.result);
+	}
+
+	private scheduleReconnect() {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+		}
+		const attempt = Math.max(this.pending.size, 1);
+		const delayMs = Math.min(
+			RECONNECT_BASE_DELAY_MS * 2 ** Math.min(attempt, 4),
+			RECONNECT_MAX_DELAY_MS,
+		);
+		this.reconnectTimer = setTimeout(() => {
+			void this.ensureConnected(true);
+		}, delayMs);
+	}
+
+	private async ensureConnected(isReconnect = false): Promise<void> {
+		if (
+			this.socket &&
+			(this.socket.readyState === WebSocket.OPEN ||
+				this.socket.readyState === WebSocket.CONNECTING)
+		) {
+			return;
+		}
+		if (this.connectPromise) {
+			return this.connectPromise;
+		}
+
+		this.setTransportState(
+			this.hasConnectedOnce || isReconnect ? "reconnecting" : "connecting",
+		);
+
+		this.connectPromise = (async () => {
+			const endpoint = await this.getBackendEndpoint();
+			await new Promise<void>((resolve, reject) => {
+				const socket = new WebSocket(endpoint);
+				this.socket = socket;
+				socket.onopen = () => {
+					this.hasConnectedOnce = true;
+					this.transportError = null;
+					this.setTransportState("connected");
+					resolve();
+				};
+				socket.onmessage = (event) => {
+					this.handleMessage(String(event.data));
+				};
+				socket.onerror = () => {
+					// Wait for onclose to reject or reconnect.
+				};
+				socket.onclose = () => {
+					if (this.socket === socket) {
+						this.socket = null;
+					}
+					if (this.transportState !== "connected") {
+						reject(
+							new Error(`Desktop backend transport unavailable at ${endpoint}`),
+						);
+						return;
+					}
+					this.setTransportState("reconnecting");
+					this.rejectPending("Desktop backend transport closed");
+					this.scheduleReconnect();
+				};
+			});
+		})()
+			.catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				this.transportError = message;
+				if (!this.hasConnectedOnce) {
+					this.setTransportState("unavailable");
+				}
+				throw error;
+			})
+			.finally(() => {
+				this.connectPromise = null;
+			});
+
+		return this.connectPromise;
+	}
+
+	async invoke<T>(command: string, args?: Record<string, unknown>): Promise<T> {
+		// Route native OS commands (directory picker, file opener) through Tauri
+		// only when running inside the full Tauri app shell. In sidecar/web mode
+		// these are handled by the sidecar over WebSocket.
+		if (NATIVE_COMMANDS.has(command) && isTauriAvailable()) {
+			return await tryTauriInvoke<T>(command, args);
+		}
+
+		await this.ensureConnected();
+		const socket = this.socket;
+		if (!socket || socket.readyState !== WebSocket.OPEN) {
+			throw new Error("Desktop backend transport unavailable");
+		}
+
+		const id = `desktop_${Date.now()}_${this.requestCounter++}`;
+		const request: DesktopTransportRequest = {
+			type: "command",
+			id,
+			command,
+			args,
+		};
+
+		return await new Promise<T>((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				const pending = this.pending.get(id);
+				if (!pending) {
+					return;
+				}
+				this.pending.delete(id);
+				pending.reject(
+					new Error(`Desktop command timed out waiting for ${command}`),
+				);
+			}, REQUEST_TIMEOUT_MS);
+			this.pending.set(id, {
+				resolve: (value) => resolve(value as T),
+				reject,
+				timeoutId,
+			});
+			socket.send(JSON.stringify(request));
+		});
+	}
+
+	subscribe(eventName: string, handler: EventHandler): () => void {
+		void this.ensureConnected(true).catch(() => {
+			// Keep UI functional enough to surface later retries.
+		});
+		const handlers = this.handlers.get(eventName) ?? new Set<EventHandler>();
+		handlers.add(handler);
+		this.handlers.set(eventName, handlers);
+		return () => {
+			const current = this.handlers.get(eventName);
+			if (!current) {
+				return;
+			}
+			current.delete(handler);
+			if (current.size === 0) {
+				this.handlers.delete(eventName);
+			}
+		};
+	}
+
+	subscribeTransportState(handler: TransportStateHandler): () => void {
+		this.transportStateHandlers.add(handler);
+		handler(this.transportState);
+		void this.ensureConnected(true).catch(() => {
+			// Ignore eager connect failures; commands will surface them.
+		});
+		return () => {
+			this.transportStateHandlers.delete(handler);
+		};
+	}
+
+	getTransportState(): DesktopTransportState {
+		return this.transportState;
+	}
+
+	getTransportError(): string | null {
+		return this.transportError;
+	}
+}
+
+export const desktopClient = new DesktopClient();
diff --git a/apps/examples/desktop-app/webview/lib/desktop-transport.ts b/apps/examples/desktop-app/webview/lib/desktop-transport.ts
new file mode 100644
index 0000000..10050ca
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/desktop-transport.ts
@@ -0,0 +1,39 @@
+export type DesktopTransportRequest = {
+	type: "command";
+	id: string;
+	command: string;
+	args?: Record<string, unknown>;
+};
+
+export type DesktopTransportResponse = {
+	type: "response";
+	id: string;
+	ok: boolean;
+	result?: unknown;
+	error?: string;
+};
+
+export type DesktopTransportEvent = {
+	type: "event";
+	event: {
+		name: string;
+		payload: unknown;
+	};
+};
+
+export type DesktopTransportMessage =
+	| DesktopTransportResponse
+	| DesktopTransportEvent;
+
+export type DesktopTransportState =
+	| "connecting"
+	| "reconnecting"
+	| "connected"
+	| "unavailable";
+
+export type DesktopBackendReadyPayload = {
+	endpoint: string;
+	wsEndpoint: string;
+	pid: number;
+	mode: "bun";
+};
diff --git a/apps/examples/desktop-app/webview/lib/marketplace.ts b/apps/examples/desktop-app/webview/lib/marketplace.ts
new file mode 100644
index 0000000..f9370c3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/marketplace.ts
@@ -0,0 +1,222 @@
+"use client";
+
+import { resolveDesktopBackendHttpEndpoint } from "@/lib/desktop-client";
+
+export type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
+
+export type MarketplaceTag = {
+	id: string;
+	label: string;
+	count: number;
+};
+
+export type MarketplaceEnvVar = {
+	name: string;
+	required?: boolean;
+	description?: string;
+	url?: string;
+};
+
+export type MarketplaceEntry = {
+	id: string;
+	type: MarketplacePrimitiveType;
+	name: string;
+	featured?: boolean;
+	tagline: string;
+	description: string;
+	tags: string[];
+	install: {
+		args: string[];
+		env?: MarketplaceEnvVar[];
+		notes?: string;
+		command: string;
+	};
+};
+
+export type MarketplaceCatalog = {
+	version: number;
+	generatedAt?: string;
+	baseUrl?: string;
+	counts: {
+		total: number;
+		plugins: number;
+		skills: number;
+		mcps: number;
+	};
+	tags: MarketplaceTag[];
+	entries: MarketplaceEntry[];
+};
+
+const MARKETPLACE_CATALOG_URL = "/api/marketplace/catalog";
+
+const EMPTY_CATALOG: MarketplaceCatalog = {
+	version: 1,
+	counts: {
+		total: 0,
+		plugins: 0,
+		skills: 0,
+		mcps: 0,
+	},
+	tags: [],
+	entries: [],
+};
+
+function isPrimitiveType(value: unknown): value is MarketplacePrimitiveType {
+	return value === "mcp" || value === "skill" || value === "plugin";
+}
+
+function toStringArray(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+function parseCount(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function parseEnv(value: unknown): MarketplaceEnvVar[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const env = value
+		.map((item): MarketplaceEnvVar | null => {
+			if (!item || typeof item !== "object") return null;
+			const candidate = item as Record<string, unknown>;
+			if (typeof candidate.name !== "string") return null;
+			const parsed: MarketplaceEnvVar = {
+				name: candidate.name,
+			};
+			if (typeof candidate.required === "boolean") {
+				parsed.required = candidate.required;
+			}
+			if (typeof candidate.description === "string") {
+				parsed.description = candidate.description;
+			}
+			if (typeof candidate.url === "string") {
+				parsed.url = candidate.url;
+			}
+			return parsed;
+		})
+		.filter((item): item is MarketplaceEnvVar => item !== null);
+	return env.length > 0 ? env : undefined;
+}
+
+export async function fetchMarketplaceCatalog(): Promise<MarketplaceCatalog> {
+	const urls = [MARKETPLACE_CATALOG_URL];
+	try {
+		const backendEndpoint = await resolveDesktopBackendHttpEndpoint();
+		urls.unshift(new URL(MARKETPLACE_CATALOG_URL, `${backendEndpoint}/`).href);
+	} catch {
+		// Fall back to the statically exported route when the sidecar is unavailable.
+	}
+
+	let data: unknown;
+	let lastError: unknown;
+	for (const url of urls) {
+		try {
+			const response = await fetch(url, {
+				headers: { Accept: "application/json" },
+			});
+			if (!response.ok) {
+				throw new Error(`Failed to fetch marketplace: ${response.status}`);
+			}
+			data = await response.json();
+			break;
+		} catch (error) {
+			lastError = error;
+		}
+	}
+
+	if (data === undefined) {
+		throw lastError instanceof Error
+			? lastError
+			: new Error("Failed to fetch marketplace");
+	}
+
+	const baseUrl = typeof data?.baseUrl === "string" ? data.baseUrl : undefined;
+	const rawCounts =
+		typeof data?.counts === "object" && data.counts !== null ? data.counts : {};
+
+	const tags: MarketplaceTag[] = Array.isArray(data?.tags)
+		? data.tags
+				.map((tag: unknown) => {
+					if (!tag || typeof tag !== "object") return null;
+					const candidate = tag as Record<string, unknown>;
+					if (
+						typeof candidate.id !== "string" ||
+						typeof candidate.label !== "string"
+					) {
+						return null;
+					}
+					return {
+						id: candidate.id,
+						label: candidate.label,
+						count: parseCount(candidate.count),
+					};
+				})
+				.filter(
+					(tag: MarketplaceTag | null): tag is MarketplaceTag => tag !== null,
+				)
+		: [];
+
+	const entries: MarketplaceEntry[] = Array.isArray(data?.entries)
+		? data.entries
+				.map((entry: unknown) => {
+					if (!entry || typeof entry !== "object") return null;
+					const candidate = entry as Record<string, unknown>;
+					const install =
+						typeof candidate.install === "object" && candidate.install !== null
+							? (candidate.install as Record<string, unknown>)
+							: {};
+					if (
+						typeof candidate.id !== "string" ||
+						!isPrimitiveType(candidate.type) ||
+						typeof candidate.name !== "string" ||
+						typeof candidate.tagline !== "string" ||
+						typeof candidate.description !== "string" ||
+						typeof install.command !== "string"
+					) {
+						return null;
+					}
+					return {
+						id: candidate.id,
+						type: candidate.type,
+						name: candidate.name,
+						featured:
+							typeof candidate.featured === "boolean"
+								? candidate.featured
+								: undefined,
+						tagline: candidate.tagline,
+						description: candidate.description,
+						tags: toStringArray(candidate.tags),
+						install: {
+							args: toStringArray(install.args),
+							command: install.command,
+							env: parseEnv(install.env),
+							notes:
+								typeof install.notes === "string" ? install.notes : undefined,
+						},
+					};
+				})
+				.filter(
+					(entry: MarketplaceEntry | null): entry is MarketplaceEntry =>
+						entry !== null && entry.install.args.length > 0,
+				)
+		: [];
+
+	return {
+		version: parseCount(data?.version) || EMPTY_CATALOG.version,
+		generatedAt:
+			typeof data?.generatedAt === "string" ? data.generatedAt : undefined,
+		baseUrl,
+		counts: {
+			total: parseCount(rawCounts.total) || entries.length,
+			plugins: parseCount(rawCounts.plugins),
+			skills: parseCount(rawCounts.skills),
+			mcps: parseCount(rawCounts.mcps),
+		},
+		tags,
+		entries,
+	};
+}
+
+export { EMPTY_CATALOG, MARKETPLACE_CATALOG_URL };
diff --git a/apps/examples/desktop-app/webview/lib/model-selection.ts b/apps/examples/desktop-app/webview/lib/model-selection.ts
new file mode 100644
index 0000000..1218433
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/model-selection.ts
@@ -0,0 +1,85 @@
+export const MODEL_SELECTION_STORAGE_KEY = "cline.code.model-selection.v1";
+
+export type ModelSelectionStorage = {
+	lastProvider: string;
+	lastModelByProvider: Record<string, string>;
+};
+
+function sanitizeStringRecord(value: unknown): Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return {};
+	}
+	return Object.fromEntries(
+		Object.entries(value).filter(
+			([key, entry]) =>
+				typeof key === "string" &&
+				typeof entry === "string" &&
+				entry.trim().length > 0,
+		),
+	);
+}
+
+export function parseModelSelectionStorage(
+	raw: string | null,
+): ModelSelectionStorage {
+	const empty: ModelSelectionStorage = {
+		lastProvider: "",
+		lastModelByProvider: {},
+	};
+	if (!raw) {
+		return empty;
+	}
+
+	try {
+		const parsed = JSON.parse(raw) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			return empty;
+		}
+
+		const shaped = parsed as {
+			lastProvider?: unknown;
+			lastModelByProvider?: unknown;
+		};
+
+		if ("lastProvider" in shaped || "lastModelByProvider" in shaped) {
+			return {
+				lastProvider:
+					typeof shaped.lastProvider === "string"
+						? shaped.lastProvider.trim()
+						: "",
+				lastModelByProvider: sanitizeStringRecord(shaped.lastModelByProvider),
+			};
+		}
+
+		return {
+			lastProvider: "",
+			lastModelByProvider: sanitizeStringRecord(parsed),
+		};
+	} catch {
+		return empty;
+	}
+}
+
+export function readModelSelectionStorageFromWindow(): ModelSelectionStorage {
+	if (typeof window === "undefined") {
+		return {
+			lastProvider: "",
+			lastModelByProvider: {},
+		};
+	}
+	return parseModelSelectionStorage(
+		window.localStorage.getItem(MODEL_SELECTION_STORAGE_KEY),
+	);
+}
+
+export function writeModelSelectionStorageToWindow(
+	value: ModelSelectionStorage,
+): void {
+	if (typeof window === "undefined") {
+		return;
+	}
+	window.localStorage.setItem(
+		MODEL_SELECTION_STORAGE_KEY,
+		JSON.stringify(value),
+	);
+}
diff --git a/apps/examples/desktop-app/webview/lib/provider-id.ts b/apps/examples/desktop-app/webview/lib/provider-id.ts
new file mode 100644
index 0000000..17c1104
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/provider-id.ts
@@ -0,0 +1,12 @@
+const PROVIDER_ID_ALIASES: Record<string, string> = {
+	openai: "openai-native",
+	google: "gemini",
+};
+
+export function normalizeProviderId(providerId: string): string {
+	const trimmed = providerId.trim();
+	if (!trimmed) {
+		return "";
+	}
+	return PROVIDER_ID_ALIASES[trimmed] ?? trimmed;
+}
diff --git a/apps/examples/desktop-app/webview/lib/provider-model-catalog.ts b/apps/examples/desktop-app/webview/lib/provider-model-catalog.ts
new file mode 100644
index 0000000..3041d1a
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/provider-model-catalog.ts
@@ -0,0 +1,68 @@
+"use client";
+
+import { desktopClient } from "@/lib/desktop-client";
+import type {
+	Provider,
+	ProviderCatalogResponse,
+	ProviderModel,
+	ProviderModelsResponse,
+} from "@/lib/provider-schema";
+
+export type ProviderModelCatalog = {
+	providers: Provider[];
+	enabledProviderIds: string[];
+	providerModels: Record<string, string[]>;
+	providerReasoningModels: Record<string, string[]>;
+};
+
+function toModelIds(models: ProviderModel[] | undefined): string[] {
+	return (models ?? []).map((model) => model.id);
+}
+
+function toReasoningModelIds(models: ProviderModel[] | undefined): string[] {
+	return (models ?? [])
+		.filter((model) => model.supportsReasoning)
+		.map((model) => model.id);
+}
+
+export function buildProviderModelCatalog(
+	providers: Provider[],
+): ProviderModelCatalog {
+	return {
+		providers,
+		enabledProviderIds: providers
+			.filter((provider) => provider.enabled)
+			.map((provider) => provider.id),
+		providerModels: Object.fromEntries(
+			providers.map((provider) => [
+				provider.id,
+				toModelIds(provider.modelList),
+			]),
+		),
+		providerReasoningModels: Object.fromEntries(
+			providers.map((provider) => [
+				provider.id,
+				toReasoningModelIds(provider.modelList),
+			]),
+		),
+	};
+}
+
+export async function loadProviderModelCatalog(): Promise<ProviderModelCatalog> {
+	const payload = await desktopClient.invoke<ProviderCatalogResponse>(
+		"list_provider_catalog",
+	);
+	return buildProviderModelCatalog(payload.providers ?? []);
+}
+
+export async function loadProviderModels(
+	providerId: string,
+): Promise<ProviderModel[]> {
+	const payload = await desktopClient.invoke<ProviderModelsResponse>(
+		"list_provider_models",
+		{
+			provider: providerId,
+		},
+	);
+	return payload.models ?? [];
+}
diff --git a/apps/examples/desktop-app/webview/lib/provider-schema.ts b/apps/examples/desktop-app/webview/lib/provider-schema.ts
new file mode 100644
index 0000000..495b74b
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/provider-schema.ts
@@ -0,0 +1,71 @@
+export interface ProviderModel {
+	id: string;
+	name: string;
+	supportsAttachments?: boolean;
+	supportsVision?: boolean;
+	supportsReasoning?: boolean;
+}
+
+export type ProviderConfigFieldType =
+	| "text"
+	| "password"
+	| "url"
+	| "number"
+	| "select"
+	| "boolean";
+
+export type ProviderConfigFieldPrimitive = string | number | boolean | null;
+
+export interface ProviderConfigFieldOption {
+	label: string;
+	value: Exclude<ProviderConfigFieldPrimitive, null>;
+}
+
+export interface ProviderConfigField {
+	path: string;
+	label: string;
+	type: ProviderConfigFieldType;
+	description?: string;
+	placeholder?: string;
+	required?: boolean;
+	secret?: boolean;
+	options?: ProviderConfigFieldOption[];
+	defaultValue?: ProviderConfigFieldPrimitive;
+}
+
+export interface Provider {
+	id: string;
+	name: string;
+	models: number | null;
+	color: string;
+	letter: string;
+	enabled: boolean;
+	apiKey?: string;
+	oauthAccessTokenPresent?: boolean;
+	baseUrl?: string;
+	docUrl?: string;
+	docLabel?: string;
+	defaultModelId?: string;
+	capabilities?: string[];
+	authDescription?: string;
+	baseUrlDescription?: string;
+	configFields?: ProviderConfigField[];
+	configValues?: Record<string, ProviderConfigFieldPrimitive>;
+	modelList?: ProviderModel[];
+}
+
+export interface ProviderSettingsUpdate {
+	apiKey?: string;
+	baseUrl?: string;
+	configValues?: Record<string, ProviderConfigFieldPrimitive>;
+}
+
+export interface ProviderCatalogResponse {
+	providers: Provider[];
+	settingsPath: string;
+}
+
+export interface ProviderModelsResponse {
+	providerId: string;
+	models: ProviderModel[];
+}
diff --git a/apps/examples/desktop-app/webview/lib/session-diff.ts b/apps/examples/desktop-app/webview/lib/session-diff.ts
new file mode 100644
index 0000000..02dcaa8
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/session-diff.ts
@@ -0,0 +1,513 @@
+export type SessionHookEvent = {
+	hookEventName?:
+		| "tool_call"
+		| "tool_result"
+		| "agent_end"
+		| "agent_error"
+		| "session_shutdown"
+		| string;
+	hookName?:
+		| "tool_call"
+		| "tool_result"
+		| "agent_end"
+		| "agent_error"
+		| "session_shutdown"
+		| string;
+	toolName?: string;
+	toolInput?: unknown;
+	toolOutput?: unknown;
+	toolError?: string;
+};
+
+export type SessionDiffHunk = {
+	oldStart: number;
+	newStart: number;
+	old: string;
+	new: string;
+};
+
+export type SessionFileDiff = {
+	path: string;
+	additions: number;
+	deletions: number;
+	hunks: SessionDiffHunk[];
+};
+
+export type SessionDiffSummary = {
+	additions: number;
+	deletions: number;
+};
+
+export type SessionDiffState = {
+	fileDiffs: SessionFileDiff[];
+	summary: SessionDiffSummary;
+};
+
+export const EMPTY_DIFF_SUMMARY: SessionDiffSummary = {
+	additions: 0,
+	deletions: 0,
+};
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (!value || typeof value !== "object") {
+		return null;
+	}
+	return value as Record<string, unknown>;
+}
+
+function toStringValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/**
+ * Tool outputs arrive in several shapes depending on the source: a plain
+ * record (live hook events), a JSON-encoded string, or a list of content
+ * blocks such as [{ type: "text", text: "<json>" }] (persisted history).
+ */
+function normalizeToolOutput(value: unknown): Record<string, unknown> | null {
+	if (typeof value === "string") {
+		try {
+			return asRecord(JSON.parse(value));
+		} catch {
+			return null;
+		}
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			const record = asRecord(entry);
+			if (!record) {
+				continue;
+			}
+			if (typeof record.text === "string") {
+				const inner = normalizeToolOutput(record.text);
+				if (inner) {
+					return inner;
+				}
+				continue;
+			}
+			return record;
+		}
+		return null;
+	}
+	return asRecord(value);
+}
+
+function getHookEventName(event: SessionHookEvent): string {
+	return event.hookEventName ?? event.hookName ?? "";
+}
+
+function countAddedLines(value: string | undefined): number {
+	if (!value) {
+		return 0;
+	}
+	return value.split("\n").filter((line) => line.length > 0).length;
+}
+
+function stripApplyPatchWrapperLines(lines: string[]): string[] {
+	const result: string[] = [];
+	let insidePatch = false;
+
+	for (const line of lines) {
+		if (line.startsWith("*** Begin Patch")) {
+			insidePatch = true;
+			result.push(line);
+			continue;
+		}
+		if (line === "*** End Patch") {
+			insidePatch = false;
+			result.push(line);
+			continue;
+		}
+
+		const isBashWrapperLine =
+			line.startsWith("%%bash") ||
+			line.startsWith("apply_patch") ||
+			line === "EOF" ||
+			line.startsWith("```");
+		if (isBashWrapperLine && !insidePatch) {
+			continue;
+		}
+
+		result.push(line);
+	}
+
+	return result;
+}
+
+export function parseApplyPatchInput(input: string): SessionFileDiff[] {
+	const lines = stripApplyPatchWrapperLines(
+		input.split("\n").map((line) => line.replace(/\r$/, "")),
+	);
+	const fileDiffs: SessionFileDiff[] = [];
+
+	let index = 0;
+	const findNextActionLine = (start: number): number => {
+		for (let i = start; i < lines.length; i += 1) {
+			const line = lines[i] ?? "";
+			if (
+				line.startsWith("*** Add File: ") ||
+				line.startsWith("*** Update File: ") ||
+				line.startsWith("*** Delete File: ") ||
+				line === "*** End Patch"
+			) {
+				return i;
+			}
+		}
+		return lines.length;
+	};
+
+	while (index < lines.length) {
+		const line = lines[index] ?? "";
+		if (line.startsWith("*** Add File: ")) {
+			const path = line.substring("*** Add File: ".length).trim();
+			const end = findNextActionLine(index + 1);
+			const addedLines: string[] = [];
+			for (let i = index + 1; i < end; i += 1) {
+				const bodyLine = lines[i] ?? "";
+				if (bodyLine.startsWith("+")) {
+					addedLines.push(bodyLine.slice(1));
+				}
+			}
+			fileDiffs.push({
+				path,
+				additions: addedLines.length,
+				deletions: 0,
+				hunks:
+					addedLines.length > 0
+						? [
+								{
+									oldStart: 1,
+									newStart: 1,
+									old: "",
+									new: addedLines.join("\n"),
+								},
+							]
+						: [],
+			});
+			index = end;
+			continue;
+		}
+
+		if (line.startsWith("*** Delete File: ")) {
+			const path = line.substring("*** Delete File: ".length).trim();
+			fileDiffs.push({
+				path,
+				additions: 0,
+				deletions: 0,
+				hunks: [],
+			});
+			index += 1;
+			continue;
+		}
+
+		if (line.startsWith("*** Update File: ")) {
+			const path = line.substring("*** Update File: ".length).trim();
+			const end = findNextActionLine(index + 1);
+
+			let additions = 0;
+			let deletions = 0;
+			let oldLineNo = 1;
+			let newLineNo = 1;
+			let activeHunk:
+				| {
+						oldStart: number;
+						newStart: number;
+						old: string[];
+						new: string[];
+				  }
+				| undefined;
+			const hunks: SessionDiffHunk[] = [];
+
+			const flushActiveHunk = () => {
+				if (!activeHunk) {
+					return;
+				}
+				hunks.push({
+					oldStart: activeHunk.oldStart,
+					newStart: activeHunk.newStart,
+					old: activeHunk.old.join("\n"),
+					new: activeHunk.new.join("\n"),
+				});
+				activeHunk = undefined;
+			};
+
+			for (let i = index + 1; i < end; i += 1) {
+				const bodyLine = lines[i] ?? "";
+				if (bodyLine.startsWith("@@")) {
+					flushActiveHunk();
+					continue;
+				}
+				if (bodyLine.startsWith("+")) {
+					additions += 1;
+					if (!activeHunk) {
+						activeHunk = {
+							oldStart: oldLineNo,
+							newStart: newLineNo,
+							old: [],
+							new: [],
+						};
+					}
+					activeHunk.new.push(bodyLine.slice(1));
+					newLineNo += 1;
+					continue;
+				}
+				if (bodyLine.startsWith("-")) {
+					deletions += 1;
+					if (!activeHunk) {
+						activeHunk = {
+							oldStart: oldLineNo,
+							newStart: newLineNo,
+							old: [],
+							new: [],
+						};
+					}
+					activeHunk.old.push(bodyLine.slice(1));
+					oldLineNo += 1;
+					continue;
+				}
+				if (bodyLine.startsWith(" ")) {
+					flushActiveHunk();
+					oldLineNo += 1;
+					newLineNo += 1;
+					continue;
+				}
+				if (bodyLine === "*** End of File") {
+					flushActiveHunk();
+				}
+			}
+			flushActiveHunk();
+
+			fileDiffs.push({
+				path,
+				additions,
+				deletions,
+				hunks,
+			});
+			index = end;
+			continue;
+		}
+
+		index += 1;
+	}
+
+	return fileDiffs;
+}
+
+function parseDiffFromEditorResult(
+	resultText: string,
+): Pick<SessionFileDiff, "additions" | "deletions" | "hunks"> {
+	const lines = resultText.split("\n");
+	const startIdx = lines.findIndex((line) => line.trim() === "```diff");
+	if (startIdx < 0) {
+		return { additions: 0, deletions: 0, hunks: [] };
+	}
+	const endIdx = lines.findIndex(
+		(line, idx) => idx > startIdx && line.trim() === "```",
+	);
+	const body = lines.slice(
+		startIdx + 1,
+		endIdx > startIdx ? endIdx : undefined,
+	);
+
+	const old: string[] = [];
+	const next: string[] = [];
+	let additions = 0;
+	let deletions = 0;
+	let oldStart: number | undefined;
+	let newStart: number | undefined;
+
+	for (const raw of body) {
+		const match = raw.match(/^([+-])(\d+):\s?(.*)$/);
+		if (!match) {
+			continue;
+		}
+
+		const op = match[1];
+		const lineNo = Number.parseInt(match[2], 10);
+		const text = match[3] ?? "";
+		if (op === "-") {
+			deletions += 1;
+			old.push(text);
+			oldStart = oldStart ?? lineNo;
+			continue;
+		}
+
+		additions += 1;
+		next.push(text);
+		newStart = newStart ?? lineNo;
+	}
+
+	if (additions + deletions === 0) {
+		return { additions: 0, deletions: 0, hunks: [] };
+	}
+
+	return {
+		additions,
+		deletions,
+		hunks: [
+			{
+				oldStart: oldStart ?? 1,
+				newStart: newStart ?? 1,
+				old: old.join("\n"),
+				new: next.join("\n"),
+			},
+		],
+	};
+}
+
+function parseEditorFileDiff(event: SessionHookEvent): SessionFileDiff | null {
+	if (
+		getHookEventName(event) !== "tool_result" ||
+		event.toolName !== "editor" ||
+		event.toolError
+	) {
+		return null;
+	}
+
+	const input = asRecord(event.toolInput);
+	const output = normalizeToolOutput(event.toolOutput);
+	if (!input || !output || output.success === false) {
+		return null;
+	}
+
+	// Current editor schema has no `command` field; derive the operation from
+	// the input shape (legacy `command` values still take precedence).
+	const command =
+		toStringValue(input.command) ??
+		(input.insert_line != null
+			? "insert"
+			: toStringValue(input.old_text) != null
+				? "str_replace"
+				: "create");
+	const pathFromInput = toStringValue(input.path);
+	const query = toStringValue(output.query);
+	const pathFromQuery = query?.includes(":")
+		? query.split(":").slice(1).join(":")
+		: undefined;
+	const path = pathFromInput || pathFromQuery;
+	if (!path) {
+		return null;
+	}
+
+	const resultText = toStringValue(output.result) ?? "";
+
+	if (command === "str_replace" && !resultText.startsWith("File created")) {
+		const parsed = parseDiffFromEditorResult(resultText);
+		return {
+			path,
+			additions: parsed.additions,
+			deletions: parsed.deletions,
+			hunks: parsed.hunks,
+		};
+	}
+
+	if (
+		command === "create" ||
+		command === "insert" ||
+		command === "str_replace"
+	) {
+		const newContent =
+			toStringValue(input.new_text) ??
+			toStringValue(input.file_text) ??
+			toStringValue(input.new_str) ??
+			"";
+		return {
+			path,
+			additions: countAddedLines(newContent),
+			deletions: 0,
+			hunks: newContent
+				? [
+						{
+							oldStart: 1,
+							newStart: 1,
+							old: "",
+							new: newContent,
+						},
+					]
+				: [],
+		};
+	}
+
+	return null;
+}
+
+function parseApplyPatchFileDiffs(event: SessionHookEvent): SessionFileDiff[] {
+	if (
+		getHookEventName(event) !== "tool_result" ||
+		event.toolName !== "apply_patch" ||
+		event.toolError
+	) {
+		return [];
+	}
+
+	const output = normalizeToolOutput(event.toolOutput);
+	if (!output || output.success === false) {
+		return [];
+	}
+
+	// apply_patch accepts either { input: string } or a raw patch string.
+	const patchInput =
+		toStringValue(event.toolInput) ??
+		toStringValue(asRecord(event.toolInput)?.input);
+	if (!patchInput) {
+		return [];
+	}
+
+	return parseApplyPatchInput(patchInput);
+}
+
+export function mergeToolDiffs(events: SessionHookEvent[]): SessionFileDiff[] {
+	const byPath = new Map<string, SessionFileDiff>();
+
+	for (const event of events) {
+		const diffs: SessionFileDiff[] = [];
+		const editorDiff = parseEditorFileDiff(event);
+		if (editorDiff) {
+			diffs.push(editorDiff);
+		}
+		diffs.push(...parseApplyPatchFileDiffs(event));
+		if (diffs.length === 0) {
+			continue;
+		}
+
+		for (const diff of diffs) {
+			const existing = byPath.get(diff.path);
+			if (!existing) {
+				byPath.set(diff.path, diff);
+				continue;
+			}
+
+			byPath.set(diff.path, {
+				...existing,
+				additions: existing.additions + diff.additions,
+				deletions: existing.deletions + diff.deletions,
+				hunks: [...existing.hunks, ...diff.hunks].slice(-30),
+			});
+		}
+	}
+
+	return Array.from(byPath.values());
+}
+
+export function summarizeFileDiffs(
+	fileDiffs: SessionFileDiff[],
+): SessionDiffSummary {
+	return fileDiffs.reduce(
+		(acc, fileDiff) => {
+			acc.additions += fileDiff.additions;
+			acc.deletions += fileDiff.deletions;
+			return acc;
+		},
+		{ ...EMPTY_DIFF_SUMMARY },
+	);
+}
+
+export function buildSessionDiffState(
+	events: SessionHookEvent[],
+): SessionDiffState {
+	const fileDiffs = mergeToolDiffs(events);
+	return {
+		fileDiffs,
+		summary: summarizeFileDiffs(fileDiffs),
+	};
+}
diff --git a/apps/examples/desktop-app/webview/lib/session-history.ts b/apps/examples/desktop-app/webview/lib/session-history.ts
new file mode 100644
index 0000000..95cecee
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/session-history.ts
@@ -0,0 +1,33 @@
+export type SessionHistoryStatus =
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "idle";
+
+export type SessionMetadata = {
+	title?: string;
+	[key: string]: unknown;
+};
+
+export interface SessionHistoryItem {
+	sessionId: string;
+	status: SessionHistoryStatus;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	parentSessionId?: string;
+	isSubagent?: boolean;
+	prompt?: string;
+	startedAt: string;
+	endedAt?: string;
+	metadata?: SessionMetadata;
+}
+
+export function getSessionMetadataTitle(metadata?: SessionMetadata): string {
+	if (!metadata) {
+		return "";
+	}
+	return typeof metadata.title === "string" ? metadata.title.trim() : "";
+}
diff --git a/apps/examples/desktop-app/webview/lib/theme.ts b/apps/examples/desktop-app/webview/lib/theme.ts
new file mode 100644
index 0000000..4c4a78c
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/theme.ts
@@ -0,0 +1,56 @@
+export const HUB_THEME_STORAGE_KEY = "cline-hub-theme";
+
+export type HubTheme = "light" | "dark";
+
+export function readStoredHubTheme(): HubTheme | null {
+	const stored = window.localStorage.getItem(HUB_THEME_STORAGE_KEY);
+	return stored === "light" || stored === "dark" ? stored : null;
+}
+
+export function readSystemHubTheme(): HubTheme {
+	const kind = document.body.dataset.vscodeThemeKind;
+	if (kind) {
+		return kind === "vscode-dark" || kind === "vscode-high-contrast"
+			? "dark"
+			: "light";
+	}
+	return window.matchMedia?.("(prefers-color-scheme: dark)").matches
+		? "dark"
+		: "light";
+}
+
+export function applyHubTheme(theme: HubTheme): HubTheme {
+	document.documentElement.classList.toggle("dark", theme === "dark");
+	document.documentElement.dataset.clineHubTheme = theme;
+	return theme;
+}
+
+export function syncHubTheme(): HubTheme {
+	return applyHubTheme(readStoredHubTheme() ?? readSystemHubTheme());
+}
+
+export function setStoredHubTheme(theme: HubTheme): HubTheme {
+	window.localStorage.setItem(HUB_THEME_STORAGE_KEY, theme);
+	return applyHubTheme(theme);
+}
+
+/**
+ * Follow OS light/dark changes while the user has no stored preference.
+ * Returns a cleanup function that removes the listener.
+ */
+export function watchSystemHubTheme(
+	onChange?: (theme: HubTheme) => void,
+): () => void {
+	const media = window.matchMedia?.("(prefers-color-scheme: dark)");
+	if (!media) {
+		return () => {};
+	}
+	const handle = () => {
+		if (readStoredHubTheme() !== null) {
+			return;
+		}
+		onChange?.(applyHubTheme(readSystemHubTheme()));
+	};
+	media.addEventListener("change", handle);
+	return () => media.removeEventListener("change", handle);
+}
diff --git a/apps/examples/desktop-app/webview/lib/utils.ts b/apps/examples/desktop-app/webview/lib/utils.ts
new file mode 100644
index 0000000..ac680b3
--- /dev/null
+++ b/apps/examples/desktop-app/webview/lib/utils.ts
@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}
diff --git a/apps/examples/desktop-app/webview/next.config.mjs b/apps/examples/desktop-app/webview/next.config.mjs
new file mode 100644
index 0000000..bd14e64
--- /dev/null
+++ b/apps/examples/desktop-app/webview/next.config.mjs
@@ -0,0 +1,23 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const workspaceRoot = path.join(__dirname, "../../../..");
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+	output: "export",
+	outputFileTracingRoot: workspaceRoot,
+	turbopack: {
+		root: workspaceRoot,
+	},
+	reactStrictMode: true,
+	typescript: {
+		ignoreBuildErrors: true,
+	},
+	images: {
+		unoptimized: true,
+	},
+};
+
+export default nextConfig;
diff --git a/apps/examples/desktop-app/webview/postcss.config.mjs b/apps/examples/desktop-app/webview/postcss.config.mjs
new file mode 100644
index 0000000..6ba14df
--- /dev/null
+++ b/apps/examples/desktop-app/webview/postcss.config.mjs
@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+	plugins: {
+		"@tailwindcss/postcss": {},
+	},
+};
+
+export default config;
diff --git a/apps/examples/desktop-app/webview/public/32x32.png b/apps/examples/desktop-app/webview/public/32x32.png
new file mode 100644
index 0000000..40cfd21
Binary files /dev/null and b/apps/examples/desktop-app/webview/public/32x32.png differ
diff --git a/apps/examples/desktop-app/webview/public/icon.png b/apps/examples/desktop-app/webview/public/icon.png
new file mode 100644
index 0000000..f7bc15f
Binary files /dev/null and b/apps/examples/desktop-app/webview/public/icon.png differ
diff --git a/apps/examples/desktop-app/webview/public/icon.svg b/apps/examples/desktop-app/webview/public/icon.svg
new file mode 100644
index 0000000..2a3908a
--- /dev/null
+++ b/apps/examples/desktop-app/webview/public/icon.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="92px" height="96px" viewBox="0 0 92 96" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Group Copy 2</title>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="icon-copy" transform="translate(-34, -40)" fill="#24292F">
+            <g id="Group-Copy-2" transform="translate(34, 40.5)">
+                <g id="Group-3-Copy-4" transform="translate(0, 0)">
+                    <path d="M65.4492701,16.3 C76.3374701,16.3 85.1635558,25.16479 85.1635558,36.1 L85.1635558,42.7 L90.9027661,54.1647464 C91.4694141,55.2966923 91.4668177,56.6300535 90.8957658,57.7597839 L85.1635558,69.1 L85.1635558,75.7 C85.1635558,86.63554 76.3374701,95.5 65.4492701,95.5 L26.0206986,95.5 C15.1328272,95.5 6.30641291,86.63554 6.30641291,75.7 L6.30641291,69.1 L0.448507752,57.7954874 C-0.14693501,56.6464093 -0.149634367,55.2802504 0.441262896,54.1288283 L6.30641291,42.7 L6.30641291,36.1 C6.30641291,25.16479 15.1328272,16.3 26.0206986,16.3 L65.4492701,16.3 Z M62.9301895,22 L29.189529,22 C19.8723267,22 12.3191987,29.5552188 12.3191987,38.875 L12.3191987,44.5 L7.44288578,53.9634655 C6.84794449,55.1180686 6.85066096,56.4896598 7.45017099,57.6418974 L12.3191987,67 L12.3191987,72.625 C12.3191987,81.9450625 19.8723267,89.5 29.189529,89.5 L62.9301895,89.5 C72.2476729,89.5 79.8005198,81.9450625 79.8005198,72.625 L79.8005198,67 L84.5682187,57.6061395 C85.1432011,56.473244 85.1458141,55.1345713 84.5752587,53.9994398 L79.8005198,44.5 L79.8005198,38.875 C79.8005198,29.5552188 72.2476729,22 62.9301895,22 Z" id="Combined-Shape" fill-rule="nonzero"></path>
+                    <circle id="Oval" cx="45.7349843" cy="11" r="11"></circle>
+                </g>
+                <rect id="Rectangle-Copy" stroke="#24292F" stroke-width="8" x="31" y="44.5" width="5" height="22" rx="2.5"></rect>
+                <rect id="Rectangle-Copy-2" stroke="#24292F" stroke-width="8" x="55" y="44.5" width="5" height="22" rx="2.5"></rect>
+            </g>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/apps/examples/desktop-app/webview/styles/globals.css b/apps/examples/desktop-app/webview/styles/globals.css
new file mode 100644
index 0000000..fd0cef5
--- /dev/null
+++ b/apps/examples/desktop-app/webview/styles/globals.css
@@ -0,0 +1,189 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "@fontsource-variable/schibsted-grotesk";
+@import "@fontsource/azeret-mono/latin.css";
+
+@custom-variant dark (&:is(.dark *));
+
+:root {
+	--font-desktop-sans: "Schibsted Grotesk Variable";
+	--font-desktop-mono: "Azeret Mono";
+	--background: oklch(1 0 0);
+	--foreground: oklch(0.145 0 0);
+	--card: oklch(1 0 0);
+	--card-foreground: oklch(0.145 0 0);
+	--popover: oklch(1 0 0);
+	--popover-foreground: oklch(0.145 0 0);
+	--primary: oklch(0.205 0 0);
+	--primary-foreground: oklch(0.985 0 0);
+	--secondary: oklch(0.97 0 0);
+	--secondary-foreground: oklch(0.205 0 0);
+	--muted: oklch(0.97 0 0);
+	--muted-foreground: oklch(0.556 0 0);
+	--accent: oklch(0.97 0 0);
+	--accent-foreground: oklch(0.205 0 0);
+	--destructive: oklch(0.577 0.245 27.325);
+	--destructive-foreground: oklch(0.577 0.245 27.325);
+	--border: oklch(0.922 0 0);
+	--input: oklch(0.922 0 0);
+	--ring: oklch(0.708 0 0);
+	--chart-1: oklch(0.646 0.222 41.116);
+	--chart-2: oklch(0.6 0.118 184.704);
+	--chart-3: oklch(0.398 0.07 227.392);
+	--chart-4: oklch(0.828 0.189 84.429);
+	--chart-5: oklch(0.769 0.188 70.08);
+	--radius: 0.625rem;
+	--sidebar: oklch(0.985 0 0);
+	--sidebar-foreground: oklch(0.145 0 0);
+	--sidebar-primary: oklch(0.205 0 0);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.97 0 0);
+	--sidebar-accent-foreground: oklch(0.205 0 0);
+	--sidebar-border: oklch(0.922 0 0);
+	--sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+	--background: oklch(0.145 0 0);
+	--foreground: oklch(0.985 0 0);
+	--card: oklch(0.145 0 0);
+	--card-foreground: oklch(0.985 0 0);
+	--popover: oklch(0.145 0 0);
+	--popover-foreground: oklch(0.985 0 0);
+	--primary: oklch(0.985 0 0);
+	--primary-foreground: oklch(0.205 0 0);
+	--secondary: oklch(0.269 0 0);
+	--secondary-foreground: oklch(0.985 0 0);
+	--muted: oklch(0.269 0 0);
+	--muted-foreground: oklch(0.708 0 0);
+	--accent: oklch(0.269 0 0);
+	--accent-foreground: oklch(0.985 0 0);
+	--destructive: oklch(0.396 0.141 25.723);
+	--destructive-foreground: oklch(0.637 0.237 25.331);
+	--border: oklch(0.269 0 0);
+	--input: oklch(0.269 0 0);
+	--ring: oklch(0.439 0 0);
+	--chart-1: oklch(0.488 0.243 264.376);
+	--chart-2: oklch(0.696 0.17 162.48);
+	--chart-3: oklch(0.769 0.188 70.08);
+	--chart-4: oklch(0.627 0.265 303.9);
+	--chart-5: oklch(0.645 0.246 16.439);
+	--sidebar: oklch(0.205 0 0);
+	--sidebar-foreground: oklch(0.985 0 0);
+	--sidebar-primary: oklch(0.488 0.243 264.376);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.269 0 0);
+	--sidebar-accent-foreground: oklch(0.985 0 0);
+	--sidebar-border: oklch(0.269 0 0);
+	--sidebar-ring: oklch(0.439 0 0);
+}
+
+@theme inline {
+	--font-sans: var(--font-desktop-sans), sans-serif;
+	--font-mono:
+		var(--font-desktop-mono), ui-monospace, "SFMono-Regular", Menlo, Consolas,
+		"Liberation Mono", monospace;
+	--font-weight-normal: 480;
+	--font-weight-medium: 560;
+	--font-weight-semibold: 640;
+	--font-weight-bold: 640;
+	--text-step-1: 12px;
+	--text-step-1--line-height: 16px;
+	--text-step-1--letter-spacing: 0.0025em;
+	--text-step-2: 14px;
+	--text-step-2--line-height: 20px;
+	--text-step-2--letter-spacing: 0em;
+	--text-step-3: 16px;
+	--text-step-3--line-height: 24px;
+	--text-step-3--letter-spacing: 0em;
+	--text-step-4: 18px;
+	--text-step-4--line-height: 26px;
+	--text-step-4--letter-spacing: -0.0025em;
+	--text-step-5: 20px;
+	--text-step-5--line-height: 28px;
+	--text-step-5--letter-spacing: -0.005em;
+	--text-step-6: 24px;
+	--text-step-6--line-height: 30px;
+	--text-step-6--letter-spacing: -0.00625em;
+	--text-step-7: 28px;
+	--text-step-7--line-height: 36px;
+	--text-step-7--letter-spacing: -0.0075em;
+	--text-step-8: 35px;
+	--text-step-8--line-height: 40px;
+	--text-step-8--letter-spacing: -0.01em;
+	--text-step-9: 60px;
+	--text-step-9--line-height: 60px;
+	--text-step-9--letter-spacing: -0.025em;
+	--text-xs: var(--text-step-1);
+	--text-xs--line-height: var(--text-step-1--line-height);
+	--text-xs--letter-spacing: var(--text-step-1--letter-spacing);
+	--text-sm: var(--text-step-2);
+	--text-sm--line-height: var(--text-step-2--line-height);
+	--text-sm--letter-spacing: var(--text-step-2--letter-spacing);
+	--text-base: var(--text-step-3);
+	--text-base--line-height: var(--text-step-3--line-height);
+	--text-base--letter-spacing: var(--text-step-3--letter-spacing);
+	--text-lg: var(--text-step-4);
+	--text-lg--line-height: var(--text-step-4--line-height);
+	--text-lg--letter-spacing: var(--text-step-4--letter-spacing);
+	--text-xl: var(--text-step-5);
+	--text-xl--line-height: var(--text-step-5--line-height);
+	--text-xl--letter-spacing: var(--text-step-5--letter-spacing);
+	--text-2xl: var(--text-step-6);
+	--text-2xl--line-height: var(--text-step-6--line-height);
+	--text-2xl--letter-spacing: var(--text-step-6--letter-spacing);
+	--text-3xl: var(--text-step-7);
+	--text-3xl--line-height: var(--text-step-7--line-height);
+	--text-3xl--letter-spacing: var(--text-step-7--letter-spacing);
+	--text-4xl: var(--text-step-8);
+	--text-4xl--line-height: var(--text-step-8--line-height);
+	--text-4xl--letter-spacing: var(--text-step-8--letter-spacing);
+	--text-6xl: var(--text-step-9);
+	--text-6xl--line-height: var(--text-step-9--line-height);
+	--text-6xl--letter-spacing: var(--text-step-9--letter-spacing);
+	--color-background: var(--background);
+	--color-foreground: var(--foreground);
+	--color-card: var(--card);
+	--color-card-foreground: var(--card-foreground);
+	--color-popover: var(--popover);
+	--color-popover-foreground: var(--popover-foreground);
+	--color-primary: var(--primary);
+	--color-primary-foreground: var(--primary-foreground);
+	--color-secondary: var(--secondary);
+	--color-secondary-foreground: var(--secondary-foreground);
+	--color-muted: var(--muted);
+	--color-muted-foreground: var(--muted-foreground);
+	--color-accent: var(--accent);
+	--color-accent-foreground: var(--accent-foreground);
+	--color-destructive: var(--destructive);
+	--color-destructive-foreground: var(--destructive-foreground);
+	--color-border: var(--border);
+	--color-input: var(--input);
+	--color-ring: var(--ring);
+	--color-chart-1: var(--chart-1);
+	--color-chart-2: var(--chart-2);
+	--color-chart-3: var(--chart-3);
+	--color-chart-4: var(--chart-4);
+	--color-chart-5: var(--chart-5);
+	--radius-sm: calc(var(--radius) - 4px);
+	--radius-md: calc(var(--radius) - 2px);
+	--radius-lg: var(--radius);
+	--radius-xl: calc(var(--radius) + 4px);
+	--color-sidebar: var(--sidebar);
+	--color-sidebar-foreground: var(--sidebar-foreground);
+	--color-sidebar-primary: var(--sidebar-primary);
+	--color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+	--color-sidebar-accent: var(--sidebar-accent);
+	--color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+	--color-sidebar-border: var(--sidebar-border);
+	--color-sidebar-ring: var(--sidebar-ring);
+}
+
+@layer base {
+	* {
+		@apply border-border outline-ring/50;
+	}
+	body {
+		@apply bg-background text-base font-normal text-foreground;
+	}
+}
diff --git a/apps/examples/desktop-app/webview/tsconfig.json b/apps/examples/desktop-app/webview/tsconfig.json
new file mode 100644
index 0000000..1a00a83
--- /dev/null
+++ b/apps/examples/desktop-app/webview/tsconfig.json
@@ -0,0 +1,28 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"paths": {
+			"@/*": ["./*"],
+			"@cline/agents": ["../../../../sdk/packages/agents/src/index.ts"],
+			"@cline/core": ["../../../../sdk/packages/core/src/index.ts"],
+			"@cline/llms": ["../../../../sdk/packages/llms/src/index.ts"],
+			"@cline/shared": ["../../../../sdk/packages/shared/src/index.ts"],
+			"@cline/shared/storage": [
+				"../../../../sdk/packages/shared/src/storage/index.ts"
+			],
+			"@cline/shared/db": ["../../../../sdk/packages/shared/src/db/index.ts"],
+			"@cline/shared/*": [
+				"../../../../sdk/packages/shared/src/*",
+				"../../../../sdk/packages/shared/src/*/index.ts"
+			]
+		}
+	},
+	"include": [
+		"next-env.d.ts",
+		"**/*.ts",
+		"**/*.tsx",
+		".next/types/**/*.ts",
+		".next/dev/types/**/*.ts"
+	],
+	"exclude": ["node_modules"]
+}
diff --git a/apps/examples/menubar/README.md b/apps/examples/menubar/README.md
new file mode 100644
index 0000000..1de7dd9
--- /dev/null
+++ b/apps/examples/menubar/README.md
@@ -0,0 +1,44 @@
+### Preview
+
+![Cline Hub Monitor preview](./assets/hub-monitor-preview.jpg)
+
+### Architecture Overview
+
+```
+Any Client (CLI, VS Code, agents)
+    │
+    │  ws://  ui.notify / ui.show_window commands
+    ▼
+Hub WebSocket Server (@cline/core/hub/server.ts)
+    │
+    │  broadcasts ui.notify / ui.show_window events to ALL subscribers
+    ▼
+Menu Bar Sidecar (apps/examples/menubar/sidecar/index.ts)  ← TypeScript/Bun process
+    │
+    │  JSON lines on stdout: hub_state / notification / ready
+    ▼
+Rust Tauri App (apps/examples/menubar/src-tauri/src/main.rs)
+    │
+    ├── Hub Monitor Window (ui/index.html)
+    │     ● Live hub status, uptime, clients, sessions
+    │     ● Running session tracker and inspector
+    │     ● Recent events and background-session launcher
+    │
+    │
+    ├── System Tray Icon with dynamic menu
+    │     ● Hub Connected — 3 clients, 2 sessions
+    │     ─────────────────
+    │     5 notifications
+    │     ─────────────────
+    │     Quit Cline Hub
+    │
+    └── Logs notifications to stderr (with severity)
+```
+
+### Dev Commands
+
+From `apps/examples/menubar/`:
+
+- `bun run dev:ui` - run only the Hub Monitor UI at `http://127.0.0.1:3466/` with preview data
+- `bun run dev` - run the full Tauri app with the real hub sidecar
+- `bun run typecheck` - TypeScript check
diff --git a/apps/examples/menubar/assets/hub-monitor-preview.jpg b/apps/examples/menubar/assets/hub-monitor-preview.jpg
new file mode 100644
index 0000000..0bd2fec
Binary files /dev/null and b/apps/examples/menubar/assets/hub-monitor-preview.jpg differ
diff --git a/apps/examples/menubar/package.json b/apps/examples/menubar/package.json
new file mode 100644
index 0000000..b95c3ff
--- /dev/null
+++ b/apps/examples/menubar/package.json
@@ -0,0 +1,24 @@
+{
+	"name": "@cline/menubar",
+	"version": "0.1.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev:ui": "python3 -m http.server 3466 --bind 127.0.0.1 --directory ui",
+		"dev": "tauri dev",
+		"build": "tauri build",
+		"build:sidecar:bin": "bun run scripts/build-sidecar-bin.ts",
+		"typecheck": "tsc --noEmit",
+		"clean": "rm -rf node_modules dist src-tauri/target"
+	},
+	"dependencies": {
+		"@cline/core": "workspace:*",
+		"@cline/shared": "workspace:*"
+	},
+	"devDependencies": {
+		"@tauri-apps/cli": "^2.0.0",
+		"@types/bun": "^1.3.10",
+		"@types/node": "^25.3.5",
+		"typescript": "^5.9.3"
+	}
+}
diff --git a/apps/examples/menubar/scripts/build-sidecar-bin.ts b/apps/examples/menubar/scripts/build-sidecar-bin.ts
new file mode 100644
index 0000000..f79bd13
--- /dev/null
+++ b/apps/examples/menubar/scripts/build-sidecar-bin.ts
@@ -0,0 +1,32 @@
+import { $ } from "bun";
+
+const resolveTargetTriple = async (): Promise<string> => {
+	const fromEnv = process.env.TAURI_ENV_TARGET_TRIPLE ?? process.env.TARGET;
+	if (fromEnv?.trim()) {
+		return fromEnv.trim();
+	}
+
+	const rustcVersion = await $`rustc -vV`.text();
+	const hostLine = rustcVersion
+		.split("\n")
+		.find((line) => line.startsWith("host: "));
+	const host = hostLine?.slice("host: ".length).trim();
+	if (!host) {
+		throw new Error("failed to resolve Rust host target triple");
+	}
+	return host;
+};
+
+const main = async () => {
+	const targetTriple = await resolveTargetTriple();
+	const extension = targetTriple.includes("windows") ? ".exe" : "";
+	const outfile = `./src-tauri/bin/menubar-sidecar-${targetTriple}${extension}`;
+
+	await $`mkdir -p src-tauri/bin`;
+	await $`bun build ./sidecar/index.ts --compile --outfile ${outfile}`;
+};
+
+main().catch((error: unknown) => {
+	console.error(error);
+	process.exitCode = 1;
+});
diff --git a/apps/examples/menubar/sidecar/index.ts b/apps/examples/menubar/sidecar/index.ts
new file mode 100644
index 0000000..cb79b1c
--- /dev/null
+++ b/apps/examples/menubar/sidecar/index.ts
@@ -0,0 +1,949 @@
+import process from "node:process";
+import { createInterface } from "node:readline";
+import {
+	ensureDetachedHubServer,
+	type HubServerDiscoveryRecord,
+	HubSessionClient,
+	HubUIClient,
+	Llms,
+	ProviderSettingsManager,
+	stopLocalHubServerGracefully,
+	toHubStatusUrl,
+} from "@cline/core";
+import type { HubUINotifyPayload, SessionRecord } from "@cline/shared";
+
+interface TrackedClient {
+	clientId: string;
+	displayName?: string;
+	clientType: string;
+	connectedAt: number;
+}
+
+interface TrackedSession {
+	sessionId: string;
+	status: string;
+	workspaceRoot: string;
+	cwd?: string;
+	createdAt: number;
+	updatedAt: number;
+	createdByClientId?: string;
+	title?: string;
+	provider?: string;
+	model?: string;
+	prompt?: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+	agentCount?: number;
+}
+
+interface ClientSummary {
+	label: string;
+	name: string;
+	sessionCount: number;
+}
+
+interface SessionSummary {
+	sessionId: string;
+	title: string;
+	status: string;
+	workspaceRoot: string;
+	workspaceName: string;
+	cwd?: string;
+	model?: string;
+	provider?: string;
+	createdAt: number;
+	updatedAt: number;
+	createdByClientId?: string;
+	prompt?: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalCost?: number;
+	agentCount: number;
+}
+
+interface EventRecord {
+	id: string;
+	title: string;
+	body: string;
+	severity: "info" | "success" | "warn" | "error";
+	timestamp: number;
+}
+
+type ClientSummaryGroup = {
+	label: string;
+	name: string;
+	sessionCount: number;
+	firstConnectedAt: number;
+};
+
+function isBundledDaemonEntryInvocation(): boolean {
+	const entryArg = process.argv[1]?.trim() ?? "";
+	const isBunEmbeddedEntry =
+		entryArg.includes("/$bunfs/") &&
+		(entryArg.endsWith("/entry.js") || entryArg.endsWith("/entry.ts"));
+	return (
+		process.argv.includes("--cline-hub-daemon") ||
+		isBunEmbeddedEntry ||
+		entryArg.endsWith("/daemon-entry.js") ||
+		entryArg.endsWith("/daemon-entry.ts") ||
+		entryArg === "daemon-entry.js" ||
+		entryArg === "daemon-entry.ts"
+	);
+}
+
+interface LastSessionContext {
+	workspaceRoot: string;
+	cwd?: string;
+	provider: string;
+	model: string;
+}
+
+interface ProviderLaunchAuth {
+	apiKey?: string;
+}
+
+interface SidecarCommand {
+	type: "new_chat" | "shutdown_hub" | "abort_session";
+	prompt?: string;
+	sessionId?: string;
+}
+
+function isVisibleClient(clientType: string): boolean {
+	return clientType !== "menubar-monitor";
+}
+
+function isActiveSession(
+	status: string | undefined,
+	participantCount?: number,
+): boolean {
+	const normalized = status?.trim().toLowerCase();
+	if (normalized !== "running" && normalized !== "idle") {
+		return false;
+	}
+	return typeof participantCount === "number" ? participantCount > 0 : true;
+}
+
+function emit(msg: Record<string, unknown>): void {
+	process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+
+function emitNotification(
+	title: string,
+	body: string,
+	severity: "info" | "warn" | "error" = "error",
+): void {
+	emit({
+		type: "notification",
+		title,
+		body,
+		severity,
+	});
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function basename(value: string | undefined): string {
+	const trimmed = value?.trim();
+	if (!trimmed) {
+		return "workspace";
+	}
+	const parts = trimmed.split(/[\\/]+/).filter(Boolean);
+	return parts.at(-1) ?? trimmed;
+}
+
+function shortSessionId(sessionId: string): string {
+	return sessionId.length > 10 ? sessionId.slice(0, 10) : sessionId;
+}
+
+function pushEvent(
+	events: EventRecord[],
+	title: string,
+	body: string,
+	severity: EventRecord["severity"] = "info",
+	timestamp = Date.now(),
+): void {
+	events.unshift({
+		id: `${timestamp}-${events.length}-${title}`,
+		title,
+		body,
+		severity,
+		timestamp,
+	});
+	if (events.length > 30) {
+		events.length = 30;
+	}
+}
+
+function metadataFor(
+	session: SessionRecord | Record<string, unknown>,
+): Record<string, unknown> {
+	return asRecord(session.metadata) ?? {};
+}
+
+function usageFor(
+	session: SessionRecord | Record<string, unknown>,
+): Record<string, unknown> {
+	return (
+		asRecord(session.aggregateUsage) ??
+		asRecord(session.usage) ??
+		asRecord(metadataFor(session).aggregateUsage) ??
+		asRecord(metadataFor(session).usage) ??
+		{}
+	);
+}
+
+function formatUptime(ms: number): string {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+	const days = Math.floor(totalSeconds / 86_400);
+	const hours = Math.floor((totalSeconds % 86_400) / 3_600);
+	const minutes = Math.floor((totalSeconds % 3_600) / 60);
+	const seconds = totalSeconds % 60;
+	if (days > 0) {
+		return `${days}d ${hours}h`;
+	}
+	if (hours > 0) {
+		return `${hours}h ${minutes}m`;
+	}
+	if (minutes > 0) {
+		return `${minutes}m ${seconds}s`;
+	}
+	return `${seconds}s`;
+}
+
+function formatClientLabel(clientType: string | undefined): string {
+	const normalized = clientType?.trim().toLowerCase() ?? "";
+	if (!normalized || normalized === "unknown") {
+		return "Client";
+	}
+	if (normalized.includes("cline")) {
+		return "Cline";
+	}
+	return normalized
+		.split(/[-_\s]+/)
+		.filter(Boolean)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ");
+}
+
+function formatClientName(client: TrackedClient): string {
+	return (
+		client.displayName?.trim() ||
+		client.clientType.trim() ||
+		client.clientId.trim() ||
+		"Unknown"
+	);
+}
+
+function summarizeClient(client: TrackedClient): {
+	key: string;
+	label: string;
+	name: string;
+} {
+	const normalizedType = client.clientType.trim().toLowerCase();
+	if (
+		normalizedType === "code-sidecar" ||
+		normalizedType === "code-sidecar-approvals" ||
+		normalizedType === "code-sidecar-list"
+	) {
+		return {
+			key: "code-app",
+			label: "Code App",
+			name: "Code App",
+		};
+	}
+	return {
+		key: client.clientId,
+		label: formatClientLabel(client.clientType),
+		name: formatClientName(client),
+	};
+}
+
+function sessionTitle(
+	session: SessionRecord | Record<string, unknown>,
+): string {
+	const raw = session as Record<string, unknown>;
+	const metadata = metadataFor(session);
+	const title = asString(metadata.title);
+	if (title) {
+		return title;
+	}
+	const prompt = asString(raw.prompt) ?? asString(metadata.prompt);
+	if (prompt) {
+		return prompt.length > 34 ? `${prompt.slice(0, 31)}...` : prompt;
+	}
+	return basename(asString(raw.workspaceRoot) ?? asString(raw.cwd));
+}
+
+function trackedSessionFrom(
+	session: SessionRecord | Record<string, unknown>,
+): TrackedSession | undefined {
+	const raw = session as Record<string, unknown>;
+	const sessionId = asString(raw.sessionId);
+	if (!sessionId) {
+		return undefined;
+	}
+	const metadata = metadataFor(session);
+	const usage = usageFor(session);
+	const createdAt =
+		asNumber(raw.createdAt) ??
+		asNumber(raw.startedAt) ??
+		asNumber(metadata.createdAt) ??
+		Date.now();
+	return {
+		sessionId,
+		status: asString(raw.status) ?? "running",
+		workspaceRoot: asString(raw.workspaceRoot) ?? asString(raw.cwd) ?? "",
+		cwd: asString(raw.cwd),
+		createdAt,
+		updatedAt:
+			asNumber(raw.updatedAt) ??
+			asNumber(raw.endedAt) ??
+			asNumber(metadata.updatedAt) ??
+			createdAt,
+		createdByClientId: asString(raw.createdByClientId),
+		title: sessionTitle(session),
+		provider: asString(raw.provider) ?? asString(metadata.provider),
+		model: asString(raw.model) ?? asString(metadata.model),
+		prompt: asString(raw.prompt) ?? asString(metadata.prompt),
+		inputTokens:
+			asNumber(usage.inputTokens) ??
+			asNumber(usage.input) ??
+			asNumber(usage.totalInputTokens),
+		outputTokens:
+			asNumber(usage.outputTokens) ??
+			asNumber(usage.output) ??
+			asNumber(usage.totalOutputTokens),
+		totalCost: asNumber(usage.totalCost) ?? asNumber(metadata.totalCost),
+		agentCount: Array.isArray(raw.participants)
+			? Math.max(1, raw.participants.length)
+			: 1,
+	};
+}
+
+function toSessionSummary(session: TrackedSession): SessionSummary {
+	return {
+		sessionId: session.sessionId,
+		title: session.title || basename(session.workspaceRoot),
+		status: session.status,
+		workspaceRoot: session.workspaceRoot,
+		workspaceName: basename(session.workspaceRoot || session.cwd),
+		cwd: session.cwd,
+		model: session.model,
+		provider: session.provider,
+		createdAt: session.createdAt,
+		updatedAt: session.updatedAt,
+		createdByClientId: session.createdByClientId,
+		prompt: session.prompt,
+		inputTokens: session.inputTokens,
+		outputTokens: session.outputTokens,
+		totalCost: session.totalCost,
+		agentCount: session.agentCount ?? 1,
+	};
+}
+
+function parseLastSessionContext(
+	session: SessionRecord | Record<string, unknown> | undefined,
+): LastSessionContext | undefined {
+	if (!session || typeof session !== "object") {
+		return undefined;
+	}
+	const metadata =
+		session.metadata && typeof session.metadata === "object"
+			? (session.metadata as Record<string, unknown>)
+			: {};
+	const workspaceRoot =
+		typeof session.workspaceRoot === "string"
+			? session.workspaceRoot.trim()
+			: "";
+	const provider =
+		typeof metadata.provider === "string" ? metadata.provider.trim() : "";
+	const model = typeof metadata.model === "string" ? metadata.model.trim() : "";
+	if (!workspaceRoot || !provider || !model) {
+		return undefined;
+	}
+	return {
+		workspaceRoot,
+		cwd:
+			typeof session.cwd === "string" && session.cwd.trim()
+				? session.cwd.trim()
+				: workspaceRoot,
+		provider,
+		model,
+	};
+}
+
+function resolveProviderLaunchAuth(
+	providerSettingsManager: ProviderSettingsManager,
+	providerId: string,
+): ProviderLaunchAuth {
+	const settings = providerSettingsManager.getProviderSettings(providerId);
+	const storedApiKey =
+		settings?.auth?.accessToken?.trim() ||
+		settings?.apiKey?.trim() ||
+		settings?.auth?.apiKey?.trim();
+	if (storedApiKey) {
+		return { apiKey: storedApiKey };
+	}
+
+	const provider = Llms.MODEL_COLLECTIONS_BY_PROVIDER_ID[providerId]?.provider;
+	const envKeys = provider?.env ?? [];
+	for (const key of envKeys) {
+		if (process.env[key]?.trim()) {
+			return {};
+		}
+	}
+
+	throw new Error(
+		`Provider "${providerId}" has no stored auth or configured environment key for background sessions.`,
+	);
+}
+
+async function main(): Promise<void> {
+	const workspaceRoot = process.cwd();
+	const providerSettingsManager = new ProviderSettingsManager();
+	// Discover or start a detached shared hub
+	let hubUrl: string;
+	let hubAuthToken: string;
+	try {
+		const hub = await ensureDetachedHubServer(workspaceRoot);
+		hubUrl = hub.url;
+		hubAuthToken = hub.authToken;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		emitNotification("Hub startup failed", msg, "error");
+		process.stderr.write(`[menubar-sidecar] hub error: ${msg}\n`);
+		process.exit(1);
+	}
+
+	emit({
+		type: "ready",
+		endpoint: hubUrl,
+		wsEndpoint: hubUrl,
+		pid: process.pid,
+	});
+
+	const uiClient = new HubUIClient({
+		address: hubUrl,
+		authToken: hubAuthToken,
+		clientType: "menubar-app",
+		displayName: "Cline Menu Bar App",
+	});
+	const sessionClient = new HubSessionClient({
+		address: hubUrl,
+		authToken: hubAuthToken,
+		clientType: "menubar-background-client",
+		displayName: "Cline Background Client",
+	});
+
+	await uiClient.connect();
+
+	const clients = new Map<string, TrackedClient>();
+	const sessions = new Map<string, TrackedSession>();
+	const events: EventRecord[] = [];
+	let lastSessionContext: LastSessionContext | undefined;
+	let hubStartedAt: string | undefined;
+
+	const syncHealthState = async (): Promise<void> => {
+		try {
+			const response = await fetch(toHubStatusUrl(hubUrl), {
+				headers: hubAuthToken
+					? { authorization: `Bearer ${hubAuthToken}` }
+					: undefined,
+			});
+			if (!response.ok) {
+				return;
+			}
+			const health =
+				(await response.json()) as Partial<HubServerDiscoveryRecord>;
+			hubStartedAt =
+				typeof health.startedAt === "string" ? health.startedAt : hubStartedAt;
+		} catch {
+			// best-effort health poll
+		}
+	};
+
+	const syncInitialState = async (): Promise<void> => {
+		const [knownClients, knownSessions] = await Promise.all([
+			uiClient.listClients(),
+			uiClient.listSessions(),
+		]);
+		clients.clear();
+		for (const client of knownClients) {
+			if (
+				typeof client.clientId !== "string" ||
+				!client.clientId ||
+				client.clientId === uiClient.getClientId() ||
+				!isVisibleClient(client.clientType)
+			) {
+				continue;
+			}
+			clients.set(client.clientId, {
+				clientId: client.clientId,
+				displayName: client.displayName,
+				clientType: client.clientType,
+				connectedAt: client.connectedAt,
+			});
+		}
+		sessions.clear();
+		for (const session of knownSessions) {
+			if (
+				typeof session.sessionId !== "string" ||
+				!session.sessionId ||
+				!isActiveSession(session.status, session.participants?.length)
+			) {
+				continue;
+			}
+			const tracked = trackedSessionFrom(session);
+			if (tracked) {
+				sessions.set(tracked.sessionId, tracked);
+			}
+		}
+		const mostRecentContext = [...knownSessions]
+			.sort((a, b) => b.updatedAt - a.updatedAt)
+			.map((session) => parseLastSessionContext(session))
+			.find((context): context is LastSessionContext => Boolean(context));
+		if (mostRecentContext) {
+			lastSessionContext = mostRecentContext;
+		}
+		pushEvent(
+			events,
+			"Hub monitor connected",
+			`${knownClients.length} clients and ${knownSessions.length} sessions discovered`,
+			"success",
+		);
+	};
+
+	function emitState(): void {
+		const sessionCounts = new Map<string, number>();
+		for (const session of sessions.values()) {
+			const clientId = session.createdByClientId?.trim();
+			if (!clientId) {
+				continue;
+			}
+			sessionCounts.set(clientId, (sessionCounts.get(clientId) ?? 0) + 1);
+		}
+		const groupedSummaries = new Map<string, ClientSummaryGroup>();
+		for (const client of Array.from(clients.values()).sort(
+			(a, b) => a.connectedAt - b.connectedAt,
+		)) {
+			const summary = summarizeClient(client);
+			const existing = groupedSummaries.get(summary.key);
+			if (existing) {
+				existing.sessionCount += sessionCounts.get(client.clientId) ?? 0;
+				existing.firstConnectedAt = Math.min(
+					existing.firstConnectedAt,
+					client.connectedAt,
+				);
+				continue;
+			}
+			groupedSummaries.set(summary.key, {
+				label: summary.label,
+				name: summary.name,
+				sessionCount: sessionCounts.get(client.clientId) ?? 0,
+				firstConnectedAt: client.connectedAt,
+			});
+		}
+		const clientSummaries: ClientSummary[] = Array.from(
+			groupedSummaries.values(),
+		)
+			.sort((a, b) => a.firstConnectedAt - b.firstConnectedAt)
+			.map(({ label, name, sessionCount }) => ({
+				label,
+				name,
+				sessionCount,
+			}));
+		emit({
+			type: "hub_state",
+			connected: true,
+			clients: Array.from(clients.values()),
+			sessions: Array.from(sessions.values()),
+			clientSummaries,
+			sessionSummaries: Array.from(sessions.values())
+				.sort((a, b) => b.updatedAt - a.updatedAt)
+				.map(toSessionSummary),
+			events,
+			lastWorkspaceRoot: lastSessionContext?.workspaceRoot,
+			hubStartedAt,
+			hubUptime: hubStartedAt
+				? formatUptime(Date.now() - Date.parse(hubStartedAt))
+				: undefined,
+		});
+	}
+
+	async function startBackgroundChat(prompt: string): Promise<void> {
+		const trimmedPrompt = prompt.trim();
+		if (!trimmedPrompt) {
+			return;
+		}
+		if (!lastSessionContext) {
+			emit({
+				type: "notification",
+				title: "New chat failed",
+				body: "No recent workspace and model context is available yet.",
+				severity: "error",
+			});
+			return;
+		}
+		try {
+			const cwd = lastSessionContext.cwd ?? lastSessionContext.workspaceRoot;
+			const launchAuth = resolveProviderLaunchAuth(
+				providerSettingsManager,
+				lastSessionContext.provider,
+			);
+			const started = await sessionClient.startRuntimeSession({
+				workspaceRoot: lastSessionContext.workspaceRoot,
+				cwd,
+				provider: lastSessionContext.provider,
+				model: lastSessionContext.model,
+				apiKey: launchAuth.apiKey,
+				enableTools: true,
+				enableSpawn: false,
+				enableTeams: true,
+				autoApproveTools: true,
+				source: "cline-menubar",
+				interactive: false,
+			});
+			await sessionClient.sendRuntimeSession(started.sessionId, {
+				config: {
+					workspaceRoot: lastSessionContext.workspaceRoot,
+					cwd,
+					provider: lastSessionContext.provider,
+					model: lastSessionContext.model,
+					apiKey: launchAuth.apiKey,
+					enableTools: true,
+					enableSpawn: false,
+					enableTeams: true,
+				},
+				prompt: trimmedPrompt,
+			});
+		} catch (error) {
+			emit({
+				type: "notification",
+				title: "New chat failed",
+				body: error instanceof Error ? error.message : String(error),
+				severity: "error",
+			});
+		}
+	}
+
+	async function shutdownHub(): Promise<void> {
+		try {
+			await stopLocalHubServerGracefully();
+		} catch (error) {
+			emit({
+				type: "notification",
+				title: "Hub shutdown failed",
+				body: error instanceof Error ? error.message : String(error),
+				severity: "error",
+			});
+		}
+	}
+
+	async function abortBackgroundSession(sessionId: string): Promise<void> {
+		const trimmedSessionId = sessionId.trim();
+		if (!trimmedSessionId) {
+			return;
+		}
+		try {
+			await sessionClient.abortRuntimeSession(trimmedSessionId);
+			pushEvent(
+				events,
+				"Session abort requested",
+				`Requested stop for ${shortSessionId(trimmedSessionId)}`,
+				"warn",
+			);
+			emitState();
+		} catch (error) {
+			emit({
+				type: "notification",
+				title: "Stop session failed",
+				body: error instanceof Error ? error.message : String(error),
+				severity: "error",
+			});
+		}
+	}
+
+	const stdin = createInterface({ input: process.stdin, terminal: false });
+	stdin.on("line", (line) => {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			return;
+		}
+		let command: SidecarCommand | undefined;
+		try {
+			command = JSON.parse(trimmed) as SidecarCommand;
+		} catch {
+			return;
+		}
+		if (command?.type === "new_chat") {
+			if (typeof command.prompt === "string") {
+				void startBackgroundChat(command.prompt);
+			}
+			return;
+		}
+		if (command?.type === "shutdown_hub") {
+			void shutdownHub();
+		}
+		if (command?.type === "abort_session") {
+			if (typeof command.sessionId === "string") {
+				void abortBackgroundSession(command.sessionId);
+			}
+		}
+	});
+
+	uiClient.subscribeUI({
+		onNotify(payload: HubUINotifyPayload) {
+			pushEvent(
+				events,
+				payload.title,
+				payload.body,
+				payload.severity === "error"
+					? "error"
+					: payload.severity === "warning"
+						? "warn"
+						: "info",
+			);
+			emit({
+				type: "notification",
+				title: payload.title,
+				body: payload.body,
+				severity: payload.severity ?? "info",
+			});
+		},
+		onClientRegistered(payload) {
+			const clientId =
+				typeof payload.clientId === "string" ? payload.clientId : undefined;
+			if (!clientId) return;
+			if (
+				clientId === uiClient.getClientId() ||
+				(typeof payload.clientType === "string" &&
+					!isVisibleClient(payload.clientType))
+			) {
+				return;
+			}
+			clients.set(clientId, {
+				clientId,
+				displayName:
+					typeof payload.displayName === "string"
+						? payload.displayName
+						: undefined,
+				clientType:
+					typeof payload.clientType === "string"
+						? payload.clientType
+						: "unknown",
+				connectedAt: Date.now(),
+			});
+			pushEvent(
+				events,
+				"Client connected",
+				`${formatClientLabel(typeof payload.clientType === "string" ? payload.clientType : "unknown")} joined the hub`,
+				"success",
+			);
+			emitState();
+		},
+		onClientDisconnected(payload) {
+			const clientId =
+				typeof payload.clientId === "string" ? payload.clientId : undefined;
+			if (!clientId) return;
+			const client = clients.get(clientId);
+			clients.delete(clientId);
+			pushEvent(
+				events,
+				"Client disconnected",
+				`${client?.displayName ?? client?.clientType ?? clientId} left the hub`,
+				"warn",
+			);
+			emitState();
+		},
+		onSessionCreated(payload) {
+			const session =
+				payload.session && typeof payload.session === "object"
+					? (payload.session as Record<string, unknown>)
+					: payload;
+			const context = parseLastSessionContext(session);
+			if (context) {
+				lastSessionContext = context;
+			}
+			const sessionId =
+				typeof session.sessionId === "string" ? session.sessionId : undefined;
+			if (!sessionId) return;
+			const status =
+				typeof session.status === "string" ? session.status : "running";
+			if (
+				!isActiveSession(
+					status,
+					Array.isArray(session.participants) ? session.participants.length : 1,
+				)
+			) {
+				sessions.delete(sessionId);
+				emitState();
+				return;
+			}
+			const tracked = trackedSessionFrom({ ...session, status });
+			if (!tracked) return;
+			sessions.set(sessionId, tracked);
+			pushEvent(
+				events,
+				`Started session "${tracked.title ?? shortSessionId(sessionId)}"`,
+				`${tracked.workspaceRoot || "workspace"} on ${tracked.model ?? "selected model"}`,
+				"success",
+				tracked.createdAt,
+			);
+			emitState();
+		},
+		onSessionUpdated(payload) {
+			const session =
+				payload.session && typeof payload.session === "object"
+					? (payload.session as Record<string, unknown>)
+					: payload;
+			const context = parseLastSessionContext(session);
+			if (context) {
+				lastSessionContext = context;
+			}
+			const sessionId =
+				typeof session.sessionId === "string" ? session.sessionId : undefined;
+			if (!sessionId) return;
+			const existing = sessions.get(sessionId);
+			const status =
+				typeof session.status === "string"
+					? session.status
+					: (existing?.status ?? "running");
+			const participantCount = Array.isArray(session.participants)
+				? session.participants.length
+				: undefined;
+			if (!isActiveSession(status, participantCount)) {
+				sessions.delete(sessionId);
+				emitState();
+				return;
+			}
+			if (existing) {
+				const previousStatus = existing.status;
+				existing.status = status;
+				existing.updatedAt =
+					asNumber(session.updatedAt) ??
+					asNumber(session.endedAt) ??
+					Date.now();
+				existing.title = sessionTitle(session);
+				existing.workspaceRoot =
+					typeof session.workspaceRoot === "string"
+						? session.workspaceRoot
+						: existing.workspaceRoot;
+				existing.cwd =
+					typeof session.cwd === "string" ? session.cwd : existing.cwd;
+				const metadata = metadataFor(session);
+				existing.provider =
+					asString(session.provider) ??
+					asString(metadata.provider) ??
+					existing.provider;
+				existing.model =
+					asString(session.model) ?? asString(metadata.model) ?? existing.model;
+				existing.createdByClientId =
+					typeof session.createdByClientId === "string"
+						? session.createdByClientId
+						: existing.createdByClientId;
+				sessions.set(sessionId, existing);
+				if (previousStatus !== status) {
+					pushEvent(
+						events,
+						`Session ${status}`,
+						`${existing.title ?? shortSessionId(sessionId)} changed from ${previousStatus}`,
+						status === "running"
+							? "success"
+							: status === "idle"
+								? "info"
+								: "warn",
+					);
+				}
+			} else {
+				const tracked = trackedSessionFrom({ ...session, status });
+				if (tracked) {
+					sessions.set(sessionId, tracked);
+				}
+			}
+			emitState();
+		},
+		onSessionDetached(payload) {
+			const session =
+				payload.session && typeof payload.session === "object"
+					? (payload.session as Record<string, unknown>)
+					: undefined;
+			const sessionId =
+				typeof session?.sessionId === "string"
+					? session.sessionId
+					: typeof payload.sessionId === "string"
+						? payload.sessionId
+						: undefined;
+			if (!sessionId) return;
+			const participantCount = Array.isArray(session?.participants)
+				? session.participants.length
+				: 0;
+			if (participantCount <= 0) {
+				const tracked = sessions.get(sessionId);
+				sessions.delete(sessionId);
+				pushEvent(
+					events,
+					"Session detached",
+					`${tracked?.title ?? shortSessionId(sessionId)} has no active participants`,
+					"warn",
+				);
+				emitState();
+			}
+		},
+	});
+
+	await syncInitialState();
+	await syncHealthState();
+	emitState();
+	const healthInterval = setInterval(() => {
+		void (async () => {
+			await syncHealthState();
+			emitState();
+		})();
+	}, 5_000);
+
+	// Keep process alive
+	process.on("SIGINT", () => {
+		clearInterval(healthInterval);
+		stdin.close();
+		sessionClient.close();
+		uiClient.close();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		clearInterval(healthInterval);
+		stdin.close();
+		sessionClient.close();
+		uiClient.close();
+		process.exit(0);
+	});
+
+	await new Promise<void>(() => {
+		// run forever
+	});
+}
+
+if (isBundledDaemonEntryInvocation()) {
+	await import("@cline/core/hub/daemon-entry");
+} else {
+	main().catch((err) => {
+		const msg = err instanceof Error ? err.message : String(err);
+		emitNotification("Menubar sidecar fatal error", msg, "error");
+		process.stderr.write(`[menubar-sidecar] fatal: ${msg}\n`);
+		process.exit(1);
+	});
+}
diff --git a/apps/examples/menubar/src-tauri/Cargo.lock b/apps/examples/menubar/src-tauri/Cargo.lock
new file mode 100644
index 0000000..5ca4d62
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/Cargo.lock
@@ -0,0 +1,4575 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "atk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b"
+dependencies = [
+ "atk-sys",
+ "glib",
+ "libc",
+]
+
+[[package]]
+name = "atk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cairo-rs"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2"
+dependencies = [
+ "bitflags 2.11.1",
+ "cairo-sys-rs",
+ "glib",
+ "libc",
+ "once_cell",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "camino"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "cargo_toml"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374b7c592d9c00c1f4972ea58390ac6b18cbb6ab79011f3bdc90a0b82ca06b77"
+dependencies = [
+ "serde",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfb"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
+dependencies = [
+ "byteorder",
+ "fnv",
+ "uuid",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "cline-menubar"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core-graphics"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation",
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cssparser"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae61cf9c0abb83bd659dab65b7e4e38d8236824c85f0f804f173567bda257d2"
+dependencies = [
+ "cssparser-macros",
+ "dtoa-short",
+ "itoa",
+ "phf",
+ "smallvec",
+]
+
+[[package]]
+name = "cssparser-macros"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ctor"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "352d39c2f7bef1d6ad73db6f5160efcaed66d94ef8c6c573a8410c00bf909a98"
+dependencies = [
+ "ctor-proc-macro",
+ "dtor",
+]
+
+[[package]]
+name = "ctor-proc-macro"
+version = "0.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
+
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dbus"
+version = "0.9.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b942602992bb7acfd1f51c49811c58a610ef9181b6e66f3e519d79b540a3bf73"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dlopen2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
+dependencies = [
+ "dlopen2_derive",
+ "libc",
+ "once_cell",
+ "winapi",
+]
+
+[[package]]
+name = "dlopen2_derive"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dom_query"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521e380c0c8afb8d9a1e83a1822ee03556fc3e3e7dbc1fd30be14e37f9cb3f89"
+dependencies = [
+ "bit-set",
+ "cssparser",
+ "foldhash 0.2.0",
+ "html5ever",
+ "precomputed-hash",
+ "selectors",
+ "tendril",
+]
+
+[[package]]
+name = "dpi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dtoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
+
+[[package]]
+name = "dtoa-short"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
+dependencies = [
+ "dtoa",
+]
+
+[[package]]
+name = "dtor"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1057d6c64987086ff8ed0fd3fbf377a6b7d205cc7715868cd401705f715cbe4"
+dependencies = [
+ "dtor-proc-macro",
+]
+
+[[package]]
+name = "dtor-proc-macro"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "embed-resource"
+version = "3.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63a1d0de4f2249aa0ff5884d7080814f446bb241a559af6c170a41e878ed2d45"
+dependencies = [
+ "cc",
+ "memchr",
+ "rustc_version",
+ "toml 0.9.12+spec-1.1.0",
+ "vswhom",
+ "winreg",
+]
+
+[[package]]
+name = "embed_plist"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "erased-serde"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec"
+dependencies = [
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "field-offset"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+dependencies = [
+ "memoffset",
+ "rustc_version",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "gdk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
+dependencies = [
+ "cairo-rs",
+ "gdk-pixbuf",
+ "gdk-sys",
+ "gio",
+ "glib",
+ "libc",
+ "pango",
+]
+
+[[package]]
+name = "gdk-pixbuf"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
+dependencies = [
+ "gdk-pixbuf-sys",
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "gdk-pixbuf-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gdk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
+dependencies = [
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkwayland-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkx11"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe"
+dependencies = [
+ "gdk",
+ "gdkx11-sys",
+ "gio",
+ "glib",
+ "libc",
+ "x11",
+]
+
+[[package]]
+name = "gdkx11-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "libc",
+ "system-deps",
+ "x11",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "gio"
+version = "0.18.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "gio-sys",
+ "glib",
+ "libc",
+ "once_cell",
+ "pin-project-lite",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "gio-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+ "winapi",
+]
+
+[[package]]
+name = "glib"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5"
+dependencies = [
+ "bitflags 2.11.1",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-task",
+ "futures-util",
+ "gio-sys",
+ "glib-macros",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "memchr",
+ "once_cell",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "glib-macros"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro-crate 2.0.2",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "glib-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "gobject-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a"
+dependencies = [
+ "atk",
+ "cairo-rs",
+ "field-offset",
+ "futures-channel",
+ "gdk",
+ "gdk-pixbuf",
+ "gio",
+ "glib",
+ "gtk-sys",
+ "gtk3-macros",
+ "libc",
+ "pango",
+ "pkg-config",
+]
+
+[[package]]
+name = "gtk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414"
+dependencies = [
+ "atk-sys",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk3-macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d"
+dependencies = [
+ "proc-macro-crate 1.3.1",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "html5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1054432bae2f14e0061e33d23402fbaa67a921d319d56adc6bcf887ddad1cbc2"
+dependencies = [
+ "log",
+ "markup5ever",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hyper"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "http",
+ "http-body",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ico"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
+dependencies = [
+ "byteorder",
+ "png 0.17.16",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png 0.18.1",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "infer"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7"
+dependencies = [
+ "cfb",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
+[[package]]
+name = "iri-string"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "javascriptcore-rs"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc"
+dependencies = [
+ "bitflags 1.3.2",
+ "glib",
+ "javascriptcore-rs-sys",
+]
+
+[[package]]
+name = "javascriptcore-rs-sys"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2964e92d1d9dc3364cae4d718d93f227e3abb088e747d92e0395bfdedf1c12ca"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863726d7afb6bc2590eeff7135d923545e5e964f004c2ccf8716c25e70a86f08"
+dependencies = [
+ "jsonptr",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "jsonptr"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dea2b27dd239b2556ed7a25ba842fe47fd602e7fc7433c2a8d6106d4d9edd70"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "keyboard-types"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a"
+dependencies = [
+ "bitflags 2.11.1",
+ "serde",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libappindicator"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a"
+dependencies = [
+ "glib",
+ "gtk",
+ "gtk-sys",
+ "libappindicator-sys",
+ "log",
+]
+
+[[package]]
+name = "libappindicator-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf"
+dependencies = [
+ "gtk-sys",
+ "libloading",
+ "once_cell",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.185"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
+
+[[package]]
+name = "libdbus-sys"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "markup5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
+dependencies = [
+ "log",
+ "tendril",
+ "web_atoms",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "muda"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae8844f63b5b118e334e205585b8c5c17b984121dbdb179d44aeb087ffad3cb"
+dependencies = [
+ "crossbeam-channel",
+ "dpi",
+ "gtk",
+ "keyboard-types",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ndk"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
+dependencies = [
+ "bitflags 2.11.1",
+ "jni-sys 0.3.1",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ndk-sys"
+version = "0.6.0+11769913"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
+dependencies = [
+ "jni-sys 0.3.1",
+]
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
+name = "num-conv"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+ "objc2-exception-helper",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-cloud-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.1",
+ "dispatch2",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.11.1",
+ "dispatch2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-location"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-exception-helper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-ui-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-location",
+ "objc2-core-text",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "objc2-user-notifications",
+]
+
+[[package]]
+name = "objc2-user-notifications"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-web-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "pango"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4"
+dependencies = [
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+ "pango-sys",
+]
+
+[[package]]
+name = "pango-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+ "serde",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "plist"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07"
+dependencies = [
+ "base64 0.22.1",
+ "indexmap 2.14.0",
+ "quick-xml",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.1",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+dependencies = [
+ "once_cell",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24"
+dependencies = [
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit 0.25.11+spec-1.1.0",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pxfm"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a041e753da8b807c9255f28de81879c78c876392ff2469cde94799b2896b9d"
+
+[[package]]
+name = "quick-xml"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
+dependencies = [
+ "dyn-clone",
+ "indexmap 1.9.3",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "selectors"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
+dependencies = [
+ "bitflags 2.11.1",
+ "cssparser",
+ "derive_more",
+ "log",
+ "new_debug_unreachable",
+ "phf",
+ "phf_codegen",
+ "precomputed-hash",
+ "rustc-hash",
+ "servo_arc",
+ "smallvec",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-untagged"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5414fad8e6907dbdd5bc441a50ae8d6e26151a03b1de04d89a5576de61d01f"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.14.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3db8978e608f1fe7357e211969fd9abdcae80bac1ba7a3369bb7eb6b404eb65"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serialize-to-javascript"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5"
+dependencies = [
+ "serde",
+ "serde_json",
+ "serialize-to-javascript-impl",
+]
+
+[[package]]
+name = "serialize-to-javascript-impl"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "servo_arc"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "170fb83ab34de17dc69aa7c67482b22218ddb85da56546f9bd6b929e32a05930"
+dependencies = [
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
+[[package]]
+name = "siphasher"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "softbuffer"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3"
+dependencies = [
+ "bytemuck",
+ "js-sys",
+ "ndk",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "raw-window-handle",
+ "redox_syscall",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "soup3"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f"
+dependencies = [
+ "futures-channel",
+ "gio",
+ "glib",
+ "libc",
+ "soup3-sys",
+]
+
+[[package]]
+name = "soup3-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "string_cache"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901"
+dependencies = [
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared",
+ "precomputed-hash",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "swift-rs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057c98e2e852d51fdcfca832aac7b571f6b351ad159f9eda5db1655f8d0c4d7"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml 0.8.2",
+ "version-compare",
+]
+
+[[package]]
+name = "tao"
+version = "0.35.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33f7f9e486ade65fcf1e45c440f9236c904f5c1002cdc7fc6ae582777345ce4"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "core-foundation",
+ "core-graphics",
+ "crossbeam-channel",
+ "dbus",
+ "dispatch2",
+ "dlopen2",
+ "dpi",
+ "gdkwayland-sys",
+ "gdkx11-sys",
+ "gtk",
+ "jni",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-sys",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "once_cell",
+ "parking_lot",
+ "percent-encoding",
+ "raw-window-handle",
+ "tao-macros",
+ "unicode-segmentation",
+ "url",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "tao-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tauri"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93bd86d231f0a8138f11a02a584769fe4b703dc36ae133d783228dbc4801405"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "cookie",
+ "dirs",
+ "dunce",
+ "embed_plist",
+ "getrandom 0.3.4",
+ "glob",
+ "gtk",
+ "heck 0.5.0",
+ "http",
+ "image",
+ "jni",
+ "libc",
+ "log",
+ "mime",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "percent-encoding",
+ "plist",
+ "raw-window-handle",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "serialize-to-javascript",
+ "swift-rs",
+ "tauri-build",
+ "tauri-macros",
+ "tauri-runtime",
+ "tauri-runtime-wry",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tokio",
+ "tray-icon",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "window-vibrancy",
+ "windows",
+]
+
+[[package]]
+name = "tauri-build"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a318b234cc2dea65f575467bafcfb76286bce228ebc3778e337d61d03213007"
+dependencies = [
+ "anyhow",
+ "cargo_toml",
+ "dirs",
+ "glob",
+ "heck 0.5.0",
+ "json-patch",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "tauri-winres",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-codegen"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd11644962add2549a60b7e7c6800f17d7020156e02f516021d8103e80cc528"
+dependencies = [
+ "base64 0.22.1",
+ "brotli",
+ "ico",
+ "json-patch",
+ "plist",
+ "png 0.17.16",
+ "proc-macro2",
+ "quote",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2",
+ "syn 2.0.117",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-macros"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed9d3742a37a355d2e47c9af924e9fbc112abb76f9835d35d4780e318419502"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "tauri-codegen",
+ "tauri-utils",
+]
+
+[[package]]
+name = "tauri-runtime"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fef478ba1d2ac21c2d528740b24d0cb315e1e8b1111aae53fafac34804371fc"
+dependencies = [
+ "cookie",
+ "dpi",
+ "gtk",
+ "http",
+ "jni",
+ "objc2",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "raw-window-handle",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows",
+]
+
+[[package]]
+name = "tauri-runtime-wry"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3989df2ae1c476404fe0a2e8ffc4cfbde97e51efd613c2bb5355fbc9ab52cf0"
+dependencies = [
+ "gtk",
+ "http",
+ "jni",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "softbuffer",
+ "tao",
+ "tauri-runtime",
+ "tauri-utils",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows",
+ "wry",
+]
+
+[[package]]
+name = "tauri-utils"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d57200389a2f82b4b0a40ae29ca19b6978116e8f4d4e974c3234ce40c0ffbdec"
+dependencies = [
+ "anyhow",
+ "brotli",
+ "cargo_metadata",
+ "ctor",
+ "dom_query",
+ "dunce",
+ "glob",
+ "http",
+ "infer",
+ "json-patch",
+ "log",
+ "memchr",
+ "phf",
+ "plist",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde_json",
+ "serde_with",
+ "swift-rs",
+ "thiserror 2.0.18",
+ "toml 0.9.12+spec-1.1.0",
+ "url",
+ "urlpattern",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-winres"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1087b111fe2b005e42dbdc1990fc18593234238d47453b0c99b7de1c9ab2c1e0"
+dependencies = [
+ "dunce",
+ "embed-resource",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "tendril"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4790fc369d5a530f4b544b094e31388b9b3a37c0f4652ade4505945f5660d24"
+dependencies = [
+ "new_debug_unreachable",
+ "utf-8",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.52.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "socket2",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
+dependencies = [
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.14.0",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.11+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+dependencies = [
+ "indexmap 2.14.0",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags 2.11.1",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tray-icon"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15edbb0d80583e85ee8df283410038e17314df5cba30da2087a54a85216c0773"
+dependencies = [
+ "crossbeam-channel",
+ "dirs",
+ "libappindicator",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
+[[package]]
+name = "typenum"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "unic-char-property"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+dependencies = [
+ "unic-char-range",
+]
+
+[[package]]
+name = "unic-char-range"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+
+[[package]]
+name = "unic-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+
+[[package]]
+name = "unic-ucd-ident"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e230a37c0381caa9219d67cf063aa3a375ffed5bf541a452db16e744bdab6987"
+dependencies = [
+ "unic-char-property",
+ "unic-char-range",
+ "unic-ucd-version",
+]
+
+[[package]]
+name = "unic-ucd-version"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+dependencies = [
+ "unic-common",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "urlpattern"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70acd30e3aa1450bc2eece896ce2ad0d178e9c079493819301573dae3c37ba6d"
+dependencies = [
+ "regex",
+ "serde",
+ "unic-ucd-ident",
+ "url",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
+dependencies = [
+ "getrandom 0.4.2",
+ "js-sys",
+ "serde_core",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version-compare"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vswhom"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b"
+dependencies = [
+ "libc",
+ "vswhom-sys",
+]
+
+[[package]]
+name = "vswhom-sys"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf938a0bacb0469e83c1e148908bd7d5a6010354cf4fb73279b7447422e3a89"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f371d383f2fb139252e0bfac3b81b265689bf45b6874af544ffa4c975ac1ebf8"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eeff24f84126c0ec2db7a449f0c2ec963c6a49efe0698c4242929da037ca28ed"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d08065faf983b2b80a79fd87d8254c409281cf7de75fc4b773019824196c904"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd04d9e306f1907bd13c6361b5c6bfc7b3b3c095ed3f8a9246390f8dbdee129"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.1",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f2dfbb17949fa2088e5d39408c48368947b86f7834484e87b73de55bc14d97d"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web_atoms"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7cff6eef815df1834fd250e3a2ff436044d82a9f1bc1980ca1dbdf07effc538"
+dependencies = [
+ "phf",
+ "phf_codegen",
+ "string_cache",
+ "string_cache_codegen",
+]
+
+[[package]]
+name = "webkit2gtk"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-rs",
+ "gdk",
+ "gdk-sys",
+ "gio",
+ "gio-sys",
+ "glib",
+ "glib-sys",
+ "gobject-sys",
+ "gtk",
+ "gtk-sys",
+ "javascriptcore-rs",
+ "libc",
+ "once_cell",
+ "soup3",
+ "webkit2gtk-sys",
+]
+
+[[package]]
+name = "webkit2gtk-sys"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-sys-rs",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "javascriptcore-rs-sys",
+ "libc",
+ "pkg-config",
+ "soup3-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "webview2-com"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
+dependencies = [
+ "webview2-com-macros",
+ "webview2-com-sys",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-implement",
+ "windows-interface",
+]
+
+[[package]]
+name = "webview2-com-macros"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "webview2-com-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
+dependencies = [
+ "thiserror 2.0.18",
+ "windows",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "window-vibrancy"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9bec5a31f3f9362f2258fd0e9c9dd61a9ca432e7306cc78c444258f0dce9a9c"
+dependencies = [
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "windows-sys 0.59.0",
+ "windows-version",
+]
+
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core 0.61.2",
+ "windows-future",
+ "windows-link 0.1.3",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-version"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+
+[[package]]
+name = "winnow"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "wry"
+version = "0.55.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186f9871daa55fd9c016578b810d149de58367113db7fb72b462d2323ce19514"
+dependencies = [
+ "base64 0.22.1",
+ "block2",
+ "cookie",
+ "crossbeam-channel",
+ "dirs",
+ "dom_query",
+ "dpi",
+ "dunce",
+ "gdkx11",
+ "gtk",
+ "http",
+ "javascriptcore-rs",
+ "jni",
+ "libc",
+ "ndk",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "sha2",
+ "soup3",
+ "tao-macros",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webkit2gtk-sys",
+ "webview2-com",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "x11"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/apps/examples/menubar/src-tauri/Cargo.toml b/apps/examples/menubar/src-tauri/Cargo.toml
new file mode 100644
index 0000000..32eef19
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "cline-menubar"
+version = "0.1.0"
+edition = "2021"
+
+[build-dependencies]
+tauri-build = { version = "2.0.0", features = [] }
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tauri = { version = "2.11.1", features = ["tray-icon", "image-png"] }
+
+[features]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]
diff --git a/apps/examples/menubar/src-tauri/build.rs b/apps/examples/menubar/src-tauri/build.rs
new file mode 100644
index 0000000..d860e1e
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}
diff --git a/apps/examples/menubar/src-tauri/icons/128x128.png b/apps/examples/menubar/src-tauri/icons/128x128.png
new file mode 100644
index 0000000..6c1fedb
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/128x128.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/128x128@2x.png b/apps/examples/menubar/src-tauri/icons/128x128@2x.png
new file mode 100644
index 0000000..9918d3e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/128x128@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/32x32.png b/apps/examples/menubar/src-tauri/icons/32x32.png
new file mode 100644
index 0000000..40cfd21
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/32x32.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/64x64.png b/apps/examples/menubar/src-tauri/icons/64x64.png
new file mode 100644
index 0000000..e72ee52
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/64x64.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square107x107Logo.png b/apps/examples/menubar/src-tauri/icons/Square107x107Logo.png
new file mode 100644
index 0000000..f424931
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square107x107Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square142x142Logo.png b/apps/examples/menubar/src-tauri/icons/Square142x142Logo.png
new file mode 100644
index 0000000..7feb46d
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square142x142Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square150x150Logo.png b/apps/examples/menubar/src-tauri/icons/Square150x150Logo.png
new file mode 100644
index 0000000..87e9660
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square150x150Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square284x284Logo.png b/apps/examples/menubar/src-tauri/icons/Square284x284Logo.png
new file mode 100644
index 0000000..b362692
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square284x284Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square30x30Logo.png b/apps/examples/menubar/src-tauri/icons/Square30x30Logo.png
new file mode 100644
index 0000000..d315fb5
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square30x30Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square310x310Logo.png b/apps/examples/menubar/src-tauri/icons/Square310x310Logo.png
new file mode 100644
index 0000000..aac2db1
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square310x310Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square44x44Logo.png b/apps/examples/menubar/src-tauri/icons/Square44x44Logo.png
new file mode 100644
index 0000000..edae92f
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square44x44Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square71x71Logo.png b/apps/examples/menubar/src-tauri/icons/Square71x71Logo.png
new file mode 100644
index 0000000..625772a
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square71x71Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/Square89x89Logo.png b/apps/examples/menubar/src-tauri/icons/Square89x89Logo.png
new file mode 100644
index 0000000..0039537
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/Square89x89Logo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/StoreLogo.png b/apps/examples/menubar/src-tauri/icons/StoreLogo.png
new file mode 100644
index 0000000..bce6784
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/StoreLogo.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml b/apps/examples/menubar/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml
new file mode 100644
index 0000000..2ffbf24
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <background android:drawable="@color/ic_launcher_background"/>
+</adaptive-icon>
\ No newline at end of file
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000..7d3abd6
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher_foreground.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..359101f
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher_round.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher_round.png
new file mode 100644
index 0000000..a4067b1
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-hdpi/ic_launcher_round.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000..e80688a
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher_foreground.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..28ffc5e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher_round.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher_round.png
new file mode 100644
index 0000000..5a99fa6
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-mdpi/ic_launcher_round.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..1e659bd
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_foreground.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..293bdc2
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_round.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..a7f4a1e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xhdpi/ic_launcher_round.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..4277dc7
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..279e480
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_round.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..15869d6
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxhdpi/ic_launcher_round.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000..2651698
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..ce1ff92
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_round.png b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..d45bca0
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/android/mipmap-xxxhdpi/ic_launcher_round.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/android/values/ic_launcher_background.xml b/apps/examples/menubar/src-tauri/icons/android/values/ic_launcher_background.xml
new file mode 100644
index 0000000..ea9c223
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/icons/android/values/ic_launcher_background.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="ic_launcher_background">#fff</color>
+</resources>
\ No newline at end of file
diff --git a/apps/examples/menubar/src-tauri/icons/icon.icns b/apps/examples/menubar/src-tauri/icons/icon.icns
new file mode 100644
index 0000000..6fe189e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/icon.icns differ
diff --git a/apps/examples/menubar/src-tauri/icons/icon.ico b/apps/examples/menubar/src-tauri/icons/icon.ico
new file mode 100644
index 0000000..ea0e465
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/icon.ico differ
diff --git a/apps/examples/menubar/src-tauri/icons/icon.png b/apps/examples/menubar/src-tauri/icons/icon.png
new file mode 100644
index 0000000..f7bc15f
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/icon.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@1x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@1x.png
new file mode 100644
index 0000000..1cd8007
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@1x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@2x-1.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@2x-1.png
new file mode 100644
index 0000000..c7fdf3e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@2x-1.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@2x.png
new file mode 100644
index 0000000..c7fdf3e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@3x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@3x.png
new file mode 100644
index 0000000..17cfed0
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-20x20@3x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@1x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@1x.png
new file mode 100644
index 0000000..5ce3f70
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@1x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@2x-1.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@2x-1.png
new file mode 100644
index 0000000..2916f39
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@2x-1.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@2x.png
new file mode 100644
index 0000000..2916f39
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@3x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@3x.png
new file mode 100644
index 0000000..63f0115
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-29x29@3x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@1x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@1x.png
new file mode 100644
index 0000000..c7fdf3e
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@1x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@2x-1.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@2x-1.png
new file mode 100644
index 0000000..27b8f20
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@2x-1.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@2x.png
new file mode 100644
index 0000000..27b8f20
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@3x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@3x.png
new file mode 100644
index 0000000..3f1758b
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-40x40@3x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-512@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-512@2x.png
new file mode 100644
index 0000000..1f27085
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-512@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-60x60@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-60x60@2x.png
new file mode 100644
index 0000000..3f1758b
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-60x60@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-60x60@3x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-60x60@3x.png
new file mode 100644
index 0000000..5c8824b
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-60x60@3x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-76x76@1x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-76x76@1x.png
new file mode 100644
index 0000000..d51a686
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-76x76@1x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-76x76@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-76x76@2x.png
new file mode 100644
index 0000000..3c05746
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-76x76@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/icons/ios/AppIcon-83.5x83.5@2x.png b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-83.5x83.5@2x.png
new file mode 100644
index 0000000..da04f4d
Binary files /dev/null and b/apps/examples/menubar/src-tauri/icons/ios/AppIcon-83.5x83.5@2x.png differ
diff --git a/apps/examples/menubar/src-tauri/src/main.rs b/apps/examples/menubar/src-tauri/src/main.rs
new file mode 100644
index 0000000..a166141
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/src/main.rs
@@ -0,0 +1,817 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use serde::{Deserialize, Serialize};
+use std::io::Write;
+use std::io::{BufRead, BufReader};
+use std::path::PathBuf;
+use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread;
+use std::time::Duration;
+use tauri::{
+    menu::{Menu, MenuItem, PredefinedMenuItem},
+    tray::{TrayIconBuilder, TrayIconEvent},
+    Manager,
+};
+
+const TRAY_ID: &str = "main";
+
+#[derive(Clone, Default, Serialize, Deserialize)]
+struct HubState {
+    connected: bool,
+    last_workspace_root: Option<String>,
+    hub_uptime: Option<String>,
+    last_error: Option<String>,
+    client_summaries: Vec<ClientSummary>,
+    session_summaries: Vec<SessionSummary>,
+    events: Vec<HubEventRecord>,
+    notifications: Vec<NotificationRecord>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ClientSummary {
+    label: String,
+    name: String,
+    session_count: usize,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct SessionSummary {
+    session_id: String,
+    title: String,
+    status: String,
+    workspace_root: String,
+    workspace_name: String,
+    cwd: Option<String>,
+    model: Option<String>,
+    provider: Option<String>,
+    created_at: u64,
+    updated_at: u64,
+    created_by_client_id: Option<String>,
+    prompt: Option<String>,
+    input_tokens: Option<u64>,
+    output_tokens: Option<u64>,
+    total_cost: Option<f64>,
+    agent_count: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct HubEventRecord {
+    id: String,
+    title: String,
+    body: String,
+    severity: String,
+    timestamp: u64,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+struct NotificationRecord {
+    title: String,
+    body: String,
+    severity: String,
+    timestamp: u64,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct SidecarMessage {
+    #[serde(rename = "type")]
+    msg_type: String,
+    ws_endpoint: Option<String>,
+    endpoint: Option<String>,
+    connected: Option<bool>,
+    clients: Option<Vec<serde_json::Value>>,
+    sessions: Option<Vec<serde_json::Value>>,
+    client_summaries: Option<Vec<ClientSummary>>,
+    session_summaries: Option<Vec<SessionSummary>>,
+    events: Option<Vec<HubEventRecord>>,
+    last_workspace_root: Option<String>,
+    hub_uptime: Option<String>,
+    title: Option<String>,
+    body: Option<String>,
+    severity: Option<String>,
+}
+
+struct AppState {
+    sidecar_process: Mutex<Option<Child>>,
+    hub_state: Mutex<HubState>,
+    last_hub_state_log: Mutex<Option<(bool, usize, usize)>>,
+    ws_endpoint: Mutex<Option<String>>,
+    app_handle: Mutex<Option<tauri::AppHandle>>,
+}
+
+impl AppState {
+    fn new() -> Self {
+        AppState {
+            sidecar_process: Mutex::new(None),
+            hub_state: Mutex::new(HubState::default()),
+            last_hub_state_log: Mutex::new(None),
+            ws_endpoint: Mutex::new(None),
+            app_handle: Mutex::new(None),
+        }
+    }
+}
+
+impl Drop for AppState {
+    fn drop(&mut self) {
+        if let Ok(mut guard) = self.sidecar_process.lock() {
+            if let Some(child) = guard.as_mut() {
+                let _ = child.kill();
+                let _ = child.wait();
+            }
+        }
+    }
+}
+
+fn current_timestamp_secs() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+fn push_notification(
+    state: &Arc<AppState>,
+    title: impl Into<String>,
+    body: impl Into<String>,
+    severity: impl Into<String>,
+    show_system: bool,
+) {
+    let title = title.into();
+    let body = body.into();
+    let severity = severity.into();
+    eprintln!("[notification/{severity}] {title}: {body}");
+    if let Ok(mut hub) = state.hub_state.lock() {
+        if severity.eq_ignore_ascii_case("error") {
+            hub.last_error = Some(format!("{title}: {body}"));
+            hub.connected = false;
+        }
+        hub.notifications.push(NotificationRecord {
+            title: title.clone(),
+            body: body.clone(),
+            severity: severity.clone(),
+            timestamp: current_timestamp_secs(),
+        });
+        if hub.notifications.len() > 50 {
+            let keep_from = hub.notifications.len() - 50;
+            hub.notifications.drain(0..keep_from);
+        }
+    }
+    if show_system {
+        show_system_notification(&title, &body);
+    }
+    refresh_tray_menu(state);
+}
+
+fn resolve_sidecar_script(workspace_root: &str, launch_cwd: &str) -> Option<PathBuf> {
+    let candidates = [
+        PathBuf::from(workspace_root)
+            .join("sdk")
+            .join("apps")
+            .join("examples")
+            .join("menubar")
+            .join("sidecar")
+            .join("index.ts"),
+        PathBuf::from(workspace_root)
+            .join("apps")
+            .join("examples")
+            .join("menubar")
+            .join("sidecar")
+            .join("index.ts"),
+        PathBuf::from(launch_cwd).join("sidecar").join("index.ts"),
+    ];
+    candidates.into_iter().find(|p| p.exists())
+}
+
+fn sidecar_binary_name() -> String {
+    let target_triple = option_env!("TAURI_ENV_TARGET_TRIPLE").unwrap_or("").trim();
+    if target_triple.is_empty() {
+        return "menubar-sidecar".to_string();
+    }
+
+    let extension = if cfg!(windows) { ".exe" } else { "" };
+    format!("menubar-sidecar-{target_triple}{extension}")
+}
+
+fn resolve_sidecar_binary(workspace_root: &str) -> Option<PathBuf> {
+    if cfg!(debug_assertions) {
+        return None;
+    }
+    let binary_name = sidecar_binary_name();
+    let current_exe = std::env::current_exe().ok();
+    let candidates = [
+        Some(
+            PathBuf::from(workspace_root)
+                .join("sdk")
+                .join("apps")
+                .join("examples")
+                .join("menubar")
+                .join("src-tauri")
+                .join("bin")
+                .join(&binary_name),
+        ),
+        Some(
+            PathBuf::from(workspace_root)
+                .join("apps")
+                .join("examples")
+                .join("menubar")
+                .join("src-tauri")
+                .join("bin")
+                .join(&binary_name),
+        ),
+        current_exe
+            .as_ref()
+            .and_then(|p| p.parent().map(|parent| parent.join(&binary_name))),
+        current_exe.as_ref().and_then(|p| {
+            p.parent()
+                .and_then(|parent| parent.parent())
+                .map(|parent| parent.join("Resources").join(&binary_name))
+        }),
+    ];
+    candidates.into_iter().flatten().find(|p| p.exists())
+}
+
+fn start_sidecar(
+    state: &Arc<AppState>,
+    workspace_root: &str,
+    launch_cwd: &str,
+) -> Result<(), String> {
+    {
+        let mut guard = state.sidecar_process.lock().map_err(|_| "lock error")?;
+        if let Some(child) = guard.as_mut() {
+            if matches!(child.try_wait(), Ok(None)) {
+                return Ok(());
+            }
+            *guard = None;
+        }
+    }
+
+    let mut cmd = if let Some(bin) = resolve_sidecar_binary(workspace_root) {
+        let mut c = Command::new(bin);
+        c.current_dir(workspace_root);
+        c
+    } else if let Some(script) = resolve_sidecar_script(workspace_root, launch_cwd) {
+        let mut c = Command::new("bun");
+        c.arg("--conditions=development")
+            .arg("run")
+            .arg(script.to_string_lossy().to_string())
+            .current_dir(workspace_root);
+        c
+    } else {
+        return Err(format!(
+            "menubar sidecar not found under workspace_root={workspace_root}"
+        ));
+    };
+
+    let mut child = cmd
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("failed to spawn sidecar: {e}"))?;
+
+    let stdout = child.stdout.take().ok_or("failed to capture stdout")?;
+    let stderr = child.stderr.take().ok_or("failed to capture stderr")?;
+
+    let state_for_stdout = state.clone();
+    thread::spawn(move || {
+        let reader = BufReader::new(stdout);
+        for line in reader.lines() {
+            let Ok(line) = line else { break };
+            let trimmed = line.trim();
+            if trimmed.is_empty() {
+                continue;
+            }
+            if let Ok(msg) = serde_json::from_str::<SidecarMessage>(trimmed) {
+                handle_sidecar_message(&state_for_stdout, msg, trimmed);
+            } else {
+                eprintln!("[menubar-sidecar] {trimmed}");
+                push_notification(
+                    &state_for_stdout,
+                    "Sidecar output",
+                    trimmed.to_string(),
+                    "warn",
+                    false,
+                );
+            }
+        }
+        if let Ok(mut ep) = state_for_stdout.ws_endpoint.lock() {
+            *ep = None;
+        }
+        push_notification(
+            &state_for_stdout,
+            "Sidecar stopped",
+            "The menubar sidecar exited or closed its output stream.",
+            "error",
+            false,
+        );
+    });
+
+    let state_for_stderr = state.clone();
+    thread::spawn(move || {
+        let reader = BufReader::new(stderr);
+        for line in reader.lines() {
+            if let Ok(text) = line {
+                let trimmed = text.trim();
+                if !trimmed.is_empty() {
+                    eprintln!("[menubar-sidecar:err] {trimmed}");
+                    push_notification(
+                        &state_for_stderr,
+                        "Sidecar error",
+                        trimmed.to_string(),
+                        "error",
+                        false,
+                    );
+                }
+            }
+        }
+    });
+
+    let mut guard = state.sidecar_process.lock().map_err(|_| "lock error")?;
+    *guard = Some(child);
+    Ok(())
+}
+
+fn handle_sidecar_message(state: &Arc<AppState>, msg: SidecarMessage, raw: &str) {
+    match msg.msg_type.as_str() {
+        "ready" => {
+            let url = msg.ws_endpoint.or(msg.endpoint);
+            if let Some(url) = url {
+                if let Ok(mut ep) = state.ws_endpoint.lock() {
+                    *ep = Some(url.clone());
+                }
+                eprintln!("[menubar-sidecar] ready at {url}");
+            }
+            if let Ok(mut hub) = state.hub_state.lock() {
+                hub.last_error = None;
+            }
+            refresh_tray_menu(state);
+        }
+        "hub_state" => {
+            let client_count = msg.clients.as_ref().map(|v| v.len()).unwrap_or(0);
+            let session_count = msg.sessions.as_ref().map(|v| v.len()).unwrap_or(0);
+            let connected = msg.connected.unwrap_or(false);
+            if let Ok(mut hub) = state.hub_state.lock() {
+                hub.connected = connected;
+                hub.client_summaries = msg.client_summaries.unwrap_or_default();
+                hub.session_summaries = msg.session_summaries.unwrap_or_default();
+                hub.events = msg.events.unwrap_or_default();
+                hub.last_workspace_root = msg
+                    .last_workspace_root
+                    .and_then(|value| if value.trim().is_empty() { None } else { Some(value) });
+                hub.hub_uptime = msg
+                    .hub_uptime
+                    .and_then(|value| if value.trim().is_empty() { None } else { Some(value) });
+                if connected {
+                    hub.last_error = None;
+                }
+            }
+            let should_log = {
+                let mut last = state
+                    .last_hub_state_log
+                    .lock()
+                    .unwrap_or_else(|p| p.into_inner());
+                let next = (connected, client_count, session_count);
+                if last.as_ref() == Some(&next) {
+                    false
+                } else {
+                    *last = Some(next);
+                    true
+                }
+            };
+            if should_log {
+                eprintln!(
+                    "[menubar-sidecar] hub_state: connected={connected} clients={client_count} sessions={session_count}"
+                );
+            }
+            refresh_tray_menu(state);
+        }
+        "notification" => {
+            let title = msg.title.unwrap_or_default();
+            let body = msg.body.unwrap_or_default();
+            let severity = msg.severity.unwrap_or_else(|| "info".to_string());
+            push_notification(state, title, body, severity, true);
+        }
+        _ => {
+            eprintln!("[menubar-sidecar] {raw}");
+            push_notification(
+                state,
+                "Sidecar message",
+                raw.to_string(),
+                "warn",
+                false,
+            );
+        }
+    }
+}
+
+fn escape_applescript(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('"', "\\\"")
+}
+
+fn show_system_notification(title: &str, body: &str) {
+    let escaped_title = escape_applescript(title);
+    let escaped_body = escape_applescript(body);
+    let script = format!(
+        "display notification \"{escaped_body}\" with title \"{escaped_title}\""
+    );
+    let _ = Command::new("osascript")
+        .arg("-e")
+        .arg(script)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn();
+}
+
+fn show_notification_details(title: &str, body: &str) {
+    let escaped_title = escape_applescript(title);
+    let escaped_body = escape_applescript(body);
+    let script = format!(
+        "display dialog \"{escaped_body}\" with title \"{escaped_title}\" buttons {{\"OK\"}} default button \"OK\""
+    );
+    let _ = Command::new("osascript")
+        .arg("-e")
+        .arg(script)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn();
+}
+
+fn prompt_for_new_chat(workspace_root: &str) -> Option<String> {
+    let escaped_workspace = escape_applescript(workspace_root);
+    let script = format!(
+        "text returned of (display dialog \"Start a background chat for:\\n{escaped_workspace}\" default answer \"\" with title \"New Chat\")"
+    );
+    let output = Command::new("osascript").arg("-e").arg(script).output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let prompt = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    if prompt.is_empty() {
+        None
+    } else {
+        Some(prompt)
+    }
+}
+
+fn send_sidecar_command(state: &Arc<AppState>, command: serde_json::Value) -> Result<(), String> {
+    let mut guard = state
+        .sidecar_process
+        .lock()
+        .map_err(|_| "failed to lock sidecar process".to_string())?;
+    let child = guard
+        .as_mut()
+        .ok_or_else(|| "menubar sidecar is not running".to_string())?;
+    let stdin = child
+        .stdin
+        .as_mut()
+        .ok_or_else(|| "menubar sidecar stdin is unavailable".to_string())?;
+    let payload = serde_json::to_string(&command)
+        .map_err(|error| format!("failed to serialize sidecar command: {error}"))?;
+    stdin
+        .write_all(payload.as_bytes())
+        .map_err(|error| format!("failed to write sidecar command: {error}"))?;
+    stdin
+        .write_all(b"\n")
+        .map_err(|error| format!("failed to flush sidecar command: {error}"))?;
+    stdin
+        .flush()
+        .map_err(|error| format!("failed to flush sidecar stdin: {error}"))?;
+    Ok(())
+}
+
+fn refresh_tray_menu(state: &Arc<AppState>) {
+    let app_handle = state
+        .app_handle
+        .lock()
+        .ok()
+        .and_then(|guard| guard.clone());
+    let Some(app_handle) = app_handle else {
+        return;
+    };
+    let hub_state = state
+        .hub_state
+        .lock()
+        .map(|hub| hub.clone())
+        .unwrap_or_default();
+    let Ok(menu) = build_tray_menu(&app_handle, &hub_state) else {
+        return;
+    };
+    if let Some(tray) = app_handle.tray_by_id(TRAY_ID) {
+        let _ = tray.set_menu(Some(menu));
+    }
+}
+
+fn build_tray_menu(
+    app: &tauri::AppHandle,
+    hub_state: &HubState,
+) -> tauri::Result<Menu<tauri::Wry>> {
+    let status_text = if hub_state.connected {
+        "Hub Connected".to_string()
+    } else if hub_state.last_error.is_some() {
+        "Hub: error".to_string()
+    } else {
+        "Hub: disconnected".to_string()
+    };
+
+    let status_item = MenuItem::with_id(app, "status", &status_text, false, None::<&str>)?;
+    let sep1 = PredefinedMenuItem::separator(app)?;
+    let mut items: Vec<Box<dyn tauri::menu::IsMenuItem<tauri::Wry>>> =
+        vec![Box::new(status_item), Box::new(sep1)];
+
+    if hub_state.connected {
+        if let Some(uptime) = hub_state.hub_uptime.as_ref() {
+            items.push(Box::new(MenuItem::with_id(
+                app,
+                "hub_uptime",
+                &format!("Uptime: {uptime}"),
+                false,
+                None::<&str>,
+            )?));
+        }
+        for (index, summary) in hub_state.client_summaries.iter().enumerate() {
+            let row_text = format!(
+                "{}: {}, Sessions: {}",
+                summary.label, summary.name, summary.session_count
+            );
+            items.push(Box::new(MenuItem::with_id(
+                app,
+                format!("client_summary_{index}"),
+                &row_text,
+                false,
+                None::<&str>,
+            )?));
+        }
+        items.push(Box::new(PredefinedMenuItem::separator(app)?));
+    }
+
+    if let Some(last_error) = hub_state.last_error.as_ref() {
+        let summary = if last_error.len() > 96 {
+            format!("Last Error: {}...", &last_error[..93])
+        } else {
+            format!("Last Error: {last_error}")
+        };
+        items.push(Box::new(MenuItem::with_id(
+            app,
+            "latest_error",
+            &summary,
+            true,
+            None::<&str>,
+        )?));
+        items.push(Box::new(PredefinedMenuItem::separator(app)?));
+    }
+
+    let new_chat_item = MenuItem::with_id(
+        app,
+        "new_chat",
+        "New Session",
+        hub_state.last_workspace_root.is_some(),
+        None::<&str>,
+    )?;
+    let open_dashboard_item =
+        MenuItem::with_id(app, "open_dashboard", "Open Dashboard", true, None::<&str>)?;
+    items.push(Box::new(open_dashboard_item));
+    items.push(Box::new(new_chat_item));
+    items.push(Box::new(PredefinedMenuItem::separator(app)?));
+
+    let notif_count = hub_state.notifications.len();
+    let notif_text = if notif_count == 0 {
+        "No notifications".to_string()
+    } else {
+        format!(
+            "{notif_count} notification{}",
+            if notif_count == 1 { "" } else { "s" }
+        )
+    };
+    let notif_item = MenuItem::with_id(
+        app,
+        "notifications",
+        &notif_text,
+        notif_count > 0,
+        None::<&str>,
+    )?;
+    let sep2 = PredefinedMenuItem::separator(app)?;
+    let quit_item = MenuItem::with_id(app, "quit", "Quit Cline Hub", true, None::<&str>)?;
+
+    items.push(Box::new(notif_item));
+    items.push(Box::new(sep2));
+    items.push(Box::new(quit_item));
+
+    let item_refs: Vec<&dyn tauri::menu::IsMenuItem<tauri::Wry>> =
+        items.iter().map(|item| item.as_ref()).collect();
+    Menu::with_items(app, &item_refs)
+}
+
+#[tauri::command]
+fn get_hub_state(state: tauri::State<'_, Arc<AppState>>) -> serde_json::Value {
+    let hub = state.hub_state.lock().unwrap_or_else(|p| p.into_inner());
+    serde_json::json!({
+        "connected": hub.connected,
+        "clientSummaries": hub.client_summaries,
+        "sessionSummaries": hub.session_summaries,
+        "events": hub.events,
+        "lastWorkspaceRoot": hub.last_workspace_root,
+        "hubUptime": hub.hub_uptime,
+        "lastError": hub.last_error,
+        "notificationCount": hub.notifications.len(),
+        "recentNotifications": &hub.notifications[hub.notifications.len().saturating_sub(10)..],
+    })
+}
+
+#[tauri::command]
+fn start_new_session(prompt: String, state: tauri::State<'_, Arc<AppState>>) -> Result<(), String> {
+    let prompt = prompt.trim().to_string();
+    if prompt.is_empty() {
+        return Err("Prompt cannot be empty".to_string());
+    }
+    send_sidecar_command(
+        state.inner(),
+        serde_json::json!({
+            "type": "new_chat",
+            "prompt": prompt,
+        }),
+    )
+}
+
+#[tauri::command]
+fn abort_session(
+    session_id: String,
+    state: tauri::State<'_, Arc<AppState>>,
+) -> Result<(), String> {
+    let session_id = session_id.trim().to_string();
+    if session_id.is_empty() {
+        return Err("Session id cannot be empty".to_string());
+    }
+    send_sidecar_command(
+        state.inner(),
+        serde_json::json!({
+            "type": "abort_session",
+            "sessionId": session_id,
+        }),
+    )
+}
+
+fn main() {
+    let app_state = Arc::new(AppState::new());
+    let launch_cwd = std::env::current_dir()
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_else(|_| ".".to_string());
+
+    let workspace_root = std::process::Command::new("git")
+        .args(["-C", &launch_cwd, "rev-parse", "--show-toplevel"])
+        .output()
+        .ok()
+        .filter(|o| o.status.success())
+        .and_then(|o| {
+            let s = String::from_utf8_lossy(&o.stdout).trim().to_string();
+            if s.is_empty() { None } else { Some(s) }
+        })
+        .unwrap_or_else(|| launch_cwd.clone());
+
+    let state_for_setup = app_state.clone();
+    let workspace_root_for_setup = workspace_root.clone();
+    let launch_cwd_for_setup = launch_cwd.clone();
+
+    let state_for_watchdog = app_state.clone();
+    let workspace_root_for_watchdog = workspace_root.clone();
+    let launch_cwd_for_watchdog = launch_cwd.clone();
+
+    tauri::Builder::default()
+        .manage(app_state)
+        .setup(move |app| {
+            if let Ok(mut app_handle) = state_for_setup.app_handle.lock() {
+                *app_handle = Some(app.handle().clone());
+            }
+            if let Err(e) = start_sidecar(
+                &state_for_setup,
+                &workspace_root_for_setup,
+                &launch_cwd_for_setup,
+            ) {
+                eprintln!("[menubar] sidecar start failed: {e}");
+                push_notification(
+                    &state_for_setup,
+                    "Sidecar start failed",
+                    e,
+                    "error",
+                    false,
+                );
+            }
+
+            thread::spawn(move || loop {
+                thread::sleep(Duration::from_secs(5));
+                if let Err(e) = start_sidecar(
+                    &state_for_watchdog,
+                    &workspace_root_for_watchdog,
+                    &launch_cwd_for_watchdog,
+                ) {
+                    eprintln!("[menubar] watchdog restart failed: {e}");
+                    push_notification(
+                        &state_for_watchdog,
+                        "Sidecar restart failed",
+                        e,
+                        "error",
+                        false,
+                    );
+                }
+            });
+
+            let hub_state = HubState::default();
+            let menu = build_tray_menu(app.handle(), &hub_state)?;
+
+            let _tray = TrayIconBuilder::with_id(TRAY_ID)
+                .icon(app.default_window_icon().cloned().unwrap_or_else(|| {
+                    tauri::image::Image::from_bytes(include_bytes!("../icons/32x32.png"))
+                        .expect("failed to load tray icon")
+                }))
+                .menu(&menu)
+                .show_menu_on_left_click(true)
+                .on_menu_event(|app, event| {
+                    match event.id().as_ref() {
+                        "quit" => {
+                            let state = app.state::<Arc<AppState>>();
+                            let _ = send_sidecar_command(
+                                state.inner(),
+                                serde_json::json!({
+                                    "type": "shutdown_hub",
+                                }),
+                            );
+                            thread::sleep(Duration::from_millis(300));
+                            app.exit(0);
+                        }
+                        "open_dashboard" => {
+                            if let Some(window) = app.get_webview_window("main") {
+                                let _ = window.show();
+                                let _ = window.set_focus();
+                            }
+                        }
+                        "latest_error" => {
+                            let state = app.state::<Arc<AppState>>();
+                            let error = {
+                                let hub = state.hub_state.lock().unwrap_or_else(|p| p.into_inner());
+                                hub.last_error.clone()
+                            };
+                            if let Some(error) = error {
+                                show_notification_details("Last Error", &error);
+                            }
+                        }
+                        "new_chat" => {
+                            let state = app.state::<Arc<AppState>>();
+                            let workspace_root = {
+                                let hub = state.hub_state.lock().unwrap_or_else(|p| p.into_inner());
+                                hub.last_workspace_root.clone()
+                            };
+                            let Some(workspace_root) = workspace_root else {
+                                show_notification_details(
+                                    "New Chat unavailable",
+                                    "No recent workspace is available yet.",
+                                );
+                                return;
+                            };
+                            let Some(prompt) = prompt_for_new_chat(&workspace_root) else {
+                                return;
+                            };
+                            if let Err(error) = send_sidecar_command(
+                                state.inner(),
+                                serde_json::json!({
+                                    "type": "new_chat",
+                                    "prompt": prompt,
+                                }),
+                            ) {
+                                show_notification_details("New Chat failed", &error);
+                            }
+                        }
+                        "notifications" => {
+                            let state = app.state::<Arc<AppState>>();
+                            let notification = {
+                                let mut hub =
+                                    state.hub_state.lock().unwrap_or_else(|p| p.into_inner());
+                                hub.notifications.pop()
+                            };
+                            if let Some(notification) = notification {
+                                show_notification_details(&notification.title, &notification.body);
+                                refresh_tray_menu(&state.inner().clone());
+                            }
+                        }
+                        _ => {}
+                    }
+                })
+                .on_tray_icon_event(|_tray, event| {
+                    if let TrayIconEvent::Click { .. } = event {
+                        // menu appears automatically via show_menu_on_left_click
+                    }
+                })
+                .build(app)?;
+
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            get_hub_state,
+            start_new_session,
+            abort_session
+        ])
+        .run(tauri::generate_context!())
+        .expect("error running menubar app");
+}
diff --git a/apps/examples/menubar/src-tauri/tauri.conf.json b/apps/examples/menubar/src-tauri/tauri.conf.json
new file mode 100644
index 0000000..1a3b331
--- /dev/null
+++ b/apps/examples/menubar/src-tauri/tauri.conf.json
@@ -0,0 +1,42 @@
+{
+	"$schema": "https://schema.tauri.app/config/2",
+	"productName": "Cline Hub",
+	"version": "0.0.0",
+	"identifier": "bot.cline.menubar",
+	"build": {
+		"beforeDevCommand": "bun run build:sidecar:bin",
+		"beforeBuildCommand": "bun run build:sidecar:bin",
+		"frontendDist": "../ui",
+		"beforeBundleCommand": "[ \"$(uname)\" = \"Darwin\" ] && [ -e ./target/release/bundle/macos/Cline\\ Hub.app ] && xattr -d com.apple.quarantine ./target/release/bundle/macos/Cline\\ Hub.app || true"
+	},
+	"app": {
+		"withGlobalTauri": true,
+		"windows": [
+			{
+				"label": "main",
+				"title": "Cline Hub Monitor",
+				"width": 1600,
+				"height": 900,
+				"minWidth": 1180,
+				"minHeight": 720,
+				"resizable": true,
+				"decorations": false
+			}
+		],
+		"security": {
+			"csp": null
+		}
+	},
+	"bundle": {
+		"active": true,
+		"targets": "all",
+		"externalBin": ["bin/menubar-sidecar"],
+		"icon": [
+			"icons/32x32.png",
+			"icons/128x128.png",
+			"icons/128x128@2x.png",
+			"icons/icon.icns",
+			"icons/icon.ico"
+		]
+	}
+}
diff --git a/apps/examples/menubar/tsconfig.json b/apps/examples/menubar/tsconfig.json
new file mode 100644
index 0000000..729a28c
--- /dev/null
+++ b/apps/examples/menubar/tsconfig.json
@@ -0,0 +1,35 @@
+{
+	"extends": "../../../sdk/packages/tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "dist",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"target": "ESNext",
+		"paths": {
+			"@cline/agents": ["../../../sdk/packages/agents/src/index.ts"],
+			"@cline/agents/*": [
+				"../../../sdk/packages/agents/src/*",
+				"../../../sdk/packages/agents/src/*/index.ts"
+			],
+			"@cline/core": ["../../../sdk/packages/core/src/index.ts"],
+			"@cline/core/hub/daemon-entry": [
+				"../../../sdk/packages/core/src/hub/daemon/entry.ts"
+			],
+			"@cline/core/*": [
+				"../../../sdk/packages/core/src/*",
+				"../../../sdk/packages/core/src/*/index.ts"
+			],
+			"@cline/llms": ["../../../sdk/packages/llms/src/index.ts"],
+			"@cline/shared": ["../../../sdk/packages/shared/src/index.ts"],
+			"@cline/shared/storage": [
+				"../../../sdk/packages/shared/src/storage/index.ts"
+			],
+			"@cline/shared/db": ["../../../sdk/packages/shared/src/db/index.ts"],
+			"@cline/shared/*": [
+				"../../../sdk/packages/shared/src/*",
+				"../../../sdk/packages/shared/src/*/index.ts"
+			]
+		}
+	},
+	"include": ["sidecar/**/*.ts"]
+}
diff --git a/apps/examples/menubar/ui/index.html b/apps/examples/menubar/ui/index.html
new file mode 100644
index 0000000..8bc5f00
--- /dev/null
+++ b/apps/examples/menubar/ui/index.html
@@ -0,0 +1,1341 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>Cline Hub Monitor</title>
+		<style>
+			:root {
+				color-scheme: dark;
+				--panel: rgba(18, 26, 35, 0.82);
+				--panel-strong: rgba(13, 19, 27, 0.92);
+				--panel-soft: rgba(255, 255, 255, 0.055);
+				--line: rgba(181, 213, 236, 0.18);
+				--line-strong: rgba(181, 213, 236, 0.3);
+				--text: #ecf3f8;
+				--muted: #aeb8c4;
+				--faint: #6f7d8a;
+				--green: #61d87d;
+				--blue: #63a9ff;
+				--amber: #e8a842;
+				--red: #ff615b;
+				--violet: #9b7dff;
+				--shadow: 0 28px 70px rgba(0, 0, 0, 0.48);
+				font-family:
+					Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+					"Segoe UI", sans-serif;
+			}
+
+			* {
+				box-sizing: border-box;
+			}
+
+			body {
+				margin: 0;
+				overflow: hidden;
+				color: var(--text);
+				background: #07111d;
+			}
+
+			button,
+			input {
+				font: inherit;
+			}
+
+			.desktop {
+				position: relative;
+				width: 100vw;
+				height: 100vh;
+				overflow: hidden;
+				background:
+					linear-gradient(180deg, rgba(7, 17, 31, 0.15), rgba(4, 9, 14, 0.86)),
+					radial-gradient(circle at 22% 14%, rgba(67, 112, 157, 0.55), transparent 33%),
+					linear-gradient(160deg, #15283d 0%, #09131e 48%, #05080d 100%);
+			}
+
+			.scene {
+				position: absolute;
+				z-index: 2;
+				top: var(--scene-y, 0px);
+				left: var(--scene-x, 0px);
+				width: 1600px;
+				height: 900px;
+				transform: scale(var(--scene-scale, 1));
+				transform-origin: 0 0;
+				overflow: hidden;
+			}
+
+			.desktop::before,
+			.desktop::after {
+				content: "";
+				position: absolute;
+				inset: auto -6vw 0;
+				height: 46vh;
+				z-index: 0;
+				pointer-events: none;
+			}
+
+			.desktop::before {
+				background:
+					linear-gradient(145deg, transparent 0 32%, rgba(5, 10, 15, 0.55) 33% 58%, transparent 59%),
+					linear-gradient(25deg, transparent 0 24%, rgba(9, 18, 25, 0.72) 25% 48%, transparent 49%),
+					linear-gradient(180deg, rgba(139, 166, 190, 0.13), rgba(2, 5, 8, 0.86));
+				filter: blur(1px);
+				transform: translateY(-10vh);
+			}
+
+			.desktop::after {
+				height: 36vh;
+				background:
+					linear-gradient(110deg, transparent 0 18%, rgba(2, 7, 11, 0.86) 19% 44%, transparent 45%),
+					linear-gradient(35deg, transparent 0 30%, rgba(0, 4, 7, 0.9) 31% 64%, transparent 65%),
+					linear-gradient(180deg, transparent, rgba(0, 0, 0, 0.92));
+			}
+
+			.system-bar {
+				position: relative;
+				z-index: 5;
+				display: flex;
+				align-items: center;
+				justify-content: space-between;
+				height: 38px;
+				padding: 0 24px;
+				width: 1600px;
+				color: rgba(255, 255, 255, 0.92);
+				background: rgba(6, 10, 16, 0.64);
+				backdrop-filter: blur(24px);
+				border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+				font-weight: 600;
+			}
+
+			.menu-left,
+			.menu-right {
+				display: flex;
+				align-items: center;
+				gap: 22px;
+				white-space: nowrap;
+			}
+
+			.apple-dot {
+				display: grid;
+				width: 20px;
+				height: 20px;
+				place-items: center;
+				border-radius: 8px;
+				background: rgba(255, 255, 255, 0.11);
+				color: #fff;
+				font-size: 13px;
+			}
+
+			.bar-icon {
+				display: grid;
+				width: 26px;
+				height: 24px;
+				place-items: center;
+				border-radius: 8px;
+				background: rgba(255, 255, 255, 0.1);
+				color: #f4f7fb;
+				font-size: 12px;
+			}
+
+			.stage {
+				position: relative;
+				z-index: 2;
+				width: 1600px;
+				height: 862px;
+				padding: 0;
+			}
+
+			.hub-card,
+			.inspector {
+				position: absolute;
+				border: 1px solid var(--line-strong);
+				background:
+					linear-gradient(180deg, rgba(255, 255, 255, 0.045), transparent 20%),
+					var(--panel);
+				box-shadow: var(--shadow);
+				backdrop-filter: blur(30px) saturate(135%);
+			}
+
+			.hub-card {
+				left: 304px;
+				top: 18px;
+				width: 414px;
+				border-radius: 14px;
+				padding: 18px;
+			}
+
+			.hub-card::before {
+				content: "";
+				position: absolute;
+				top: -16px;
+				left: 50%;
+				width: 30px;
+				height: 30px;
+				border-left: 1px solid var(--line-strong);
+				border-top: 1px solid var(--line-strong);
+				background: rgba(18, 26, 35, 0.78);
+				transform: translateX(-50%) rotate(45deg);
+			}
+
+			.inspector {
+				left: 740px;
+				top: 66px;
+				width: 804px;
+				border-radius: 12px;
+				overflow: hidden;
+			}
+
+			.card-top,
+			.inspector-top {
+				display: flex;
+				align-items: center;
+				justify-content: space-between;
+				gap: 16px;
+			}
+
+			.card-title,
+			.window-title {
+				font-size: 16px;
+				font-weight: 650;
+				letter-spacing: 0;
+			}
+
+			.status-pill {
+				display: inline-flex;
+				align-items: center;
+				gap: 8px;
+				height: 28px;
+				padding: 0 10px;
+				border: 1px solid rgba(97, 216, 125, 0.2);
+				border-radius: 8px;
+				background: rgba(97, 216, 125, 0.12);
+				color: var(--green);
+				font-size: 13px;
+				font-weight: 650;
+			}
+
+			.dot {
+				width: 10px;
+				height: 10px;
+				border-radius: 99px;
+				background: var(--faint);
+			}
+
+			.dot.green {
+				background: var(--green);
+				box-shadow: 0 0 18px rgba(97, 216, 125, 0.55);
+			}
+
+			.dot.blue {
+				background: var(--blue);
+				box-shadow: 0 0 18px rgba(99, 169, 255, 0.45);
+			}
+
+			.dot.amber {
+				background: var(--amber);
+				box-shadow: 0 0 18px rgba(232, 168, 66, 0.42);
+			}
+
+			.dot.red {
+				background: var(--red);
+				box-shadow: 0 0 18px rgba(255, 97, 91, 0.42);
+			}
+
+			.icon-button,
+			.window-button {
+				display: grid;
+				width: 30px;
+				height: 30px;
+				place-items: center;
+				border: 0;
+				border-radius: 8px;
+				color: #c8d1dc;
+				background: rgba(255, 255, 255, 0.055);
+			}
+
+			.metric-grid {
+				display: grid;
+				grid-template-columns: repeat(3, 1fr);
+				gap: 10px;
+				margin-top: 16px;
+				padding: 18px 16px;
+				border: 1px solid var(--line);
+				border-radius: 10px;
+				background: rgba(8, 14, 21, 0.38);
+			}
+
+			.metric {
+				display: grid;
+				grid-template-columns: 34px 1fr;
+				align-items: center;
+				gap: 10px;
+				min-width: 0;
+			}
+
+			.metric-icon {
+				display: grid;
+				width: 34px;
+				height: 34px;
+				place-items: center;
+				border-radius: 10px;
+				background: rgba(99, 169, 255, 0.12);
+				color: var(--blue);
+				font-weight: 800;
+			}
+
+			.metric:nth-child(1) .metric-icon {
+				background: rgba(97, 216, 125, 0.13);
+				color: var(--green);
+			}
+
+			.metric:nth-child(3) .metric-icon {
+				background: rgba(232, 168, 66, 0.13);
+				color: var(--amber);
+			}
+
+			.metric-value {
+				font-size: 25px;
+				line-height: 1;
+				font-weight: 760;
+			}
+
+			.metric-label,
+			.small-label {
+				color: var(--muted);
+				font-size: 13px;
+			}
+
+			.uptime {
+				margin-top: 4px;
+				padding: 12px;
+				border: 1px solid var(--line);
+				border-radius: 9px;
+				background: rgba(255, 255, 255, 0.035);
+			}
+
+			.uptime-row,
+			.section-title,
+			.list-row,
+			.event-row {
+				display: flex;
+				align-items: center;
+				justify-content: space-between;
+				gap: 12px;
+			}
+
+			.progress-track {
+				position: relative;
+				height: 5px;
+				margin-top: 14px;
+				border-radius: 99px;
+				background: rgba(160, 177, 195, 0.22);
+				overflow: hidden;
+			}
+
+			.progress-fill {
+				position: absolute;
+				inset: 0 auto 0 0;
+				width: 82%;
+				border-radius: inherit;
+				background: linear-gradient(90deg, #5edc7b, #91e0ff, #d6b34c);
+			}
+
+			.section {
+				margin-top: 18px;
+			}
+
+			.section-title {
+				margin-bottom: 10px;
+				color: #dce5ec;
+				font-size: 15px;
+				font-weight: 650;
+			}
+
+			.link {
+				border: 0;
+				background: transparent;
+				color: var(--blue);
+				font-size: 13px;
+				cursor: pointer;
+			}
+
+			.list,
+			.events {
+				display: grid;
+				gap: 8px;
+			}
+
+			.list-row,
+			.event-row {
+				min-height: 28px;
+				color: #e5edf5;
+				font-size: 14px;
+			}
+
+			.left-row {
+				display: flex;
+				align-items: center;
+				gap: 10px;
+				min-width: 0;
+			}
+
+			.truncate {
+				overflow: hidden;
+				text-overflow: ellipsis;
+				white-space: nowrap;
+			}
+
+			.row-muted {
+				color: var(--muted);
+				font-size: 13px;
+			}
+
+			.card-actions {
+				display: grid;
+				grid-template-columns: 1fr 1fr;
+				gap: 14px;
+				margin-top: 18px;
+				padding-top: 16px;
+				border-top: 1px solid var(--line);
+			}
+
+			.action {
+				height: 38px;
+				border: 1px solid var(--line);
+				border-radius: 8px;
+				color: #e7eff7;
+				background: rgba(255, 255, 255, 0.045);
+				cursor: pointer;
+			}
+
+			.action.primary {
+				border-color: rgba(99, 169, 255, 0.75);
+				background: linear-gradient(180deg, #54a6ff, #2d73dd);
+				box-shadow: inset 0 1px rgba(255, 255, 255, 0.28);
+			}
+
+			.inspector-top {
+				height: 52px;
+				padding: 0 16px;
+				border-bottom: 1px solid var(--line);
+				background: rgba(10, 16, 23, 0.55);
+			}
+
+			.window-controls {
+				display: flex;
+				align-items: center;
+				gap: 8px;
+			}
+
+			.session-head {
+				padding: 22px 24px 14px;
+			}
+
+			.session-title-row {
+				display: flex;
+				align-items: center;
+				gap: 12px;
+			}
+
+			.session-title {
+				font-size: 24px;
+				line-height: 1.1;
+				font-weight: 760;
+			}
+
+			.session-meta {
+				margin-top: 8px;
+				color: var(--muted);
+				font-size: 14px;
+			}
+
+			.tabs {
+				display: flex;
+				gap: 14px;
+				margin-top: 18px;
+			}
+
+			.tab {
+				display: inline-flex;
+				align-items: center;
+				height: 38px;
+				padding: 0 12px;
+				border: 1px solid transparent;
+				border-radius: 8px;
+				color: var(--muted);
+				background: transparent;
+				font-size: 13px;
+			}
+
+			.tab.active {
+				border-color: var(--line);
+				color: var(--text);
+				background: rgba(255, 255, 255, 0.055);
+			}
+
+			.inspector-body {
+				display: grid;
+				grid-template-columns: 180px minmax(280px, 1fr) 268px;
+				gap: 8px;
+				padding: 0 16px 16px;
+			}
+
+			.pane {
+				height: 420px;
+				border: 1px solid var(--line);
+				border-radius: 7px;
+				background: rgba(7, 12, 18, 0.42);
+				overflow: hidden;
+			}
+
+			.pane-title {
+				display: flex;
+				align-items: center;
+				justify-content: space-between;
+				height: 44px;
+				padding: 0 12px;
+				border-bottom: 1px solid rgba(181, 213, 236, 0.1);
+				background: rgba(255, 255, 255, 0.025);
+				font-size: 14px;
+				font-weight: 620;
+			}
+
+			.overview-content {
+				display: grid;
+				gap: 14px;
+				padding: 12px;
+			}
+
+			.kv-label {
+				color: var(--faint);
+				font-size: 12px;
+			}
+
+			.kv-value {
+				margin-top: 4px;
+				color: #e4ecf4;
+				font-size: 13px;
+				line-height: 1.35;
+				word-break: break-word;
+			}
+
+			.token-bar {
+				display: grid;
+				grid-template-columns: 1fr 1fr;
+				gap: 3px;
+				height: 5px;
+				margin-top: 8px;
+				border-radius: 99px;
+				overflow: hidden;
+				background: rgba(255, 255, 255, 0.1);
+			}
+
+			.token-bar span:first-child {
+				background: var(--green);
+			}
+
+			.token-bar span:last-child {
+				background: rgba(157, 126, 255, 0.8);
+			}
+
+			.agent-dots {
+				display: flex;
+				gap: 7px;
+				margin-top: 8px;
+			}
+
+			.agent-dot {
+				display: grid;
+				width: 22px;
+				height: 22px;
+				place-items: center;
+				border-radius: 99px;
+				color: #111821;
+				font-size: 11px;
+				font-weight: 800;
+				background: var(--amber);
+			}
+
+			.agent-dot:nth-child(2) {
+				background: var(--violet);
+			}
+
+			.agent-dot:nth-child(3) {
+				background: #49b9ef;
+			}
+
+			.agent-dot:nth-child(4) {
+				background: #f2cf62;
+			}
+
+			.transcript,
+			.timeline {
+				padding: 10px 12px 14px;
+			}
+
+			.transcript-row {
+				display: grid;
+				grid-template-columns: 54px 116px 1fr;
+				gap: 10px;
+				padding: 5px 0;
+				color: #c9d3de;
+				font-family: "SF Mono", "Cascadia Code", ui-monospace, monospace;
+				font-size: 12px;
+				line-height: 1.42;
+				white-space: nowrap;
+			}
+
+			.transcript-row span:last-child {
+				overflow: hidden;
+				text-overflow: ellipsis;
+				white-space: nowrap;
+			}
+
+			.role {
+				font-weight: 800;
+			}
+
+			.role.architect {
+				color: #72b8ff;
+			}
+
+			.role.security {
+				color: #eab85a;
+			}
+
+			.role.pragmatist {
+				color: #5edf78;
+			}
+
+			.role.skeptic {
+				color: #ac84ff;
+			}
+
+			.role.tool {
+				color: #76d794;
+			}
+
+			.stream-dot {
+				display: inline-block;
+				width: 7px;
+				height: 7px;
+				margin-right: 8px;
+				border-radius: 99px;
+				background: #ffd85f;
+				box-shadow: 0 0 12px rgba(255, 216, 95, 0.6);
+			}
+
+			.timeline-row {
+				position: relative;
+				display: grid;
+				grid-template-columns: 58px 18px 1fr;
+				gap: 9px;
+				min-height: 36px;
+				color: #cbd5df;
+				font-size: 12px;
+			}
+
+			.timeline-row::before {
+				content: "";
+				position: absolute;
+				top: 18px;
+				bottom: -18px;
+				left: 66px;
+				width: 1px;
+				background: rgba(181, 213, 236, 0.2);
+			}
+
+			.timeline-row:last-child::before {
+				display: none;
+			}
+
+			.timeline-node {
+				width: 10px;
+				height: 10px;
+				margin-top: 4px;
+				border: 2px solid rgba(176, 199, 218, 0.55);
+				border-radius: 99px;
+				background: #15202d;
+			}
+
+			.timeline-row.active .timeline-node {
+				border-color: var(--blue);
+				background: var(--blue);
+				box-shadow: 0 0 16px rgba(99, 169, 255, 0.7);
+			}
+
+			.inspector-footer {
+				display: grid;
+				grid-template-columns: 1fr 176px;
+				gap: 12px;
+				padding: 0 16px 18px;
+			}
+
+			.footer-stats {
+				display: grid;
+				grid-template-columns: repeat(5, 1fr);
+				border: 1px solid var(--line);
+				border-radius: 7px;
+				background: rgba(8, 13, 19, 0.48);
+			}
+
+			.stat {
+				min-width: 0;
+				padding: 13px 16px;
+				border-right: 1px solid var(--line);
+			}
+
+			.stat:last-child {
+				border-right: 0;
+			}
+
+			.stat-value {
+				margin-top: 6px;
+				font-size: 20px;
+				font-weight: 740;
+			}
+
+			.stat-sub {
+				margin-top: 3px;
+				color: var(--muted);
+				font-size: 12px;
+			}
+
+			.stat-sub.success {
+				color: var(--green);
+			}
+
+			.stat-sub.danger {
+				color: var(--red);
+			}
+
+			.stop {
+				border: 1px solid rgba(255, 97, 91, 0.62);
+				border-radius: 8px;
+				color: white;
+				background: linear-gradient(180deg, #ff625d, #ce3b34);
+				font-weight: 680;
+				cursor: pointer;
+			}
+
+			.preview-chip {
+				display: none;
+				margin-left: 8px;
+				padding: 3px 7px;
+				border-radius: 999px;
+				color: #1a2230;
+				background: #f2cf62;
+				font-size: 11px;
+				font-weight: 800;
+			}
+
+			.demo .preview-chip {
+				display: inline-flex;
+			}
+
+		</style>
+	</head>
+	<body>
+		<main class="desktop" data-tauri-drag-region>
+			<div class="scene" id="scene">
+				<header class="system-bar" data-tauri-drag-region>
+					<div class="menu-left">
+						<span class="apple-dot">C</span>
+						<span>Cline</span>
+						<span>File</span>
+						<span>Edit</span>
+						<span>View</span>
+						<span>Window</span>
+						<span>Help</span>
+					</div>
+					<div class="menu-right">
+						<span class="bar-icon">H</span>
+						<span>Wi-Fi</span>
+						<span>100%</span>
+						<span id="clock">Tue 9:41 AM</span>
+					</div>
+				</header>
+
+				<section class="stage">
+					<aside class="hub-card" id="hubCard">
+					<div class="card-top">
+						<div class="card-title">Cline Hub Monitor</div>
+						<div style="display: flex; align-items: center; gap: 10px">
+							<div class="status-pill" id="hubStatus">
+								<span class="dot green"></span>
+								<span>Hub Connected</span>
+							</div>
+							<button type="button" class="icon-button" title="Settings">s</button>
+						</div>
+					</div>
+
+					<div class="metric-grid">
+						<div class="metric">
+							<div class="metric-icon">C</div>
+							<div>
+								<div class="metric-value" id="clientCount">4</div>
+								<div class="metric-label">Clients</div>
+							</div>
+						</div>
+						<div class="metric">
+							<div class="metric-icon">S</div>
+							<div>
+								<div class="metric-value" id="sessionCount">6</div>
+								<div class="metric-label">Sessions</div>
+							</div>
+						</div>
+						<div class="metric">
+							<div class="metric-icon">R</div>
+							<div>
+								<div class="metric-value" id="runningCount">2</div>
+								<div class="metric-label">Running</div>
+							</div>
+						</div>
+					</div>
+
+					<div class="uptime">
+						<div class="uptime-row">
+							<div class="small-label">Hub Uptime</div>
+							<div class="small-label" id="uptime">3h 42m 18s</div>
+						</div>
+						<div class="progress-track"><div class="progress-fill"></div></div>
+					</div>
+
+					<div class="section">
+						<div class="section-title">
+							<span>Active Sessions</span>
+							<button type="button" class="link">View all</button>
+						</div>
+						<div class="list" id="clientList"></div>
+					</div>
+
+					<div class="section">
+						<div class="section-title">
+							<span>Recent Events</span>
+							<button type="button" class="link">View all</button>
+						</div>
+						<div class="events" id="eventList"></div>
+					</div>
+
+					<div class="card-actions">
+						<button type="button" class="action" id="openDashboard">Open Dashboard</button>
+						<button type="button" class="action primary" id="newSession">New Session</button>
+					</div>
+				</aside>
+
+				<section class="inspector" id="inspector">
+					<div class="inspector-top" data-tauri-drag-region>
+						<div class="window-title">Session Inspector</div>
+						<div class="window-controls">
+							<button type="button" class="window-button">-</button>
+							<button type="button" class="window-button">[]</button>
+							<button type="button" class="window-button">x</button>
+						</div>
+					</div>
+
+					<div class="session-head">
+						<div class="session-title-row">
+							<span class="dot green" id="sessionDot"></span>
+							<div class="session-title">
+								<span id="sessionTitle">refactor-auth</span>
+								<span class="preview-chip">Preview data</span>
+							</div>
+							<div class="status-pill" id="sessionStatus">Running</div>
+						</div>
+						<div class="session-meta" id="sessionMeta">
+							dev-studio - Started 8m ago - ID: sess_8f3c2a7d
+						</div>
+						<nav class="tabs">
+							<button type="button" class="tab active">Overview</button>
+							<button type="button" class="tab">Timeline</button>
+							<button type="button" class="tab">Files</button>
+							<button type="button" class="tab">Context</button>
+							<button type="button" class="tab">Settings</button>
+						</nav>
+					</div>
+
+					<div class="inspector-body">
+						<div class="pane">
+							<div class="pane-title">Overview</div>
+							<div class="overview-content" id="overview"></div>
+						</div>
+
+						<div class="pane">
+							<div class="pane-title">Live Transcript (preview)</div>
+							<div class="transcript" id="transcript"></div>
+						</div>
+
+						<div class="pane">
+							<div class="pane-title">
+								<span>Timeline</span>
+								<button type="button" class="link">View full timeline</button>
+							</div>
+							<div class="timeline" id="timeline"></div>
+						</div>
+					</div>
+
+					<div class="inspector-footer">
+						<div class="footer-stats">
+							<div class="stat">
+								<div class="small-label">Progress</div>
+								<div class="stat-value" id="progressValue">62%</div>
+								<div class="stat-sub" id="progressSub">12 / 19 tasks</div>
+							</div>
+							<div class="stat">
+								<div class="small-label">Tests</div>
+								<div class="stat-value" id="testsValue">24/24</div>
+								<div class="stat-sub success">Passing</div>
+							</div>
+							<div class="stat">
+								<div class="small-label">Files Changed</div>
+								<div class="stat-value" id="filesValue">8</div>
+								<div class="stat-sub success">+142 <span class="danger">-23</span></div>
+							</div>
+							<div class="stat">
+								<div class="small-label">Issues</div>
+								<div class="stat-value" id="issuesValue">0</div>
+								<div class="stat-sub">Open</div>
+							</div>
+							<div class="stat">
+								<div class="small-label">Duration</div>
+								<div class="stat-value" id="durationValue">8m 41s</div>
+								<div class="stat-sub">Elapsed</div>
+							</div>
+						</div>
+						<button type="button" class="stop" id="stopButton">Stop Session</button>
+					</div>
+					</section>
+				</section>
+			</div>
+		</main>
+
+		<script>
+			const sampleState = {
+				connected: true,
+				hubUptime: "3h 42m 18s",
+				clientSummaries: [
+					{ label: "Cline", name: "ara-mbp", sessionCount: 2 },
+					{ label: "Cline", name: "dev-studio", sessionCount: 2 },
+					{ label: "Runner", name: "ci-runner-01", sessionCount: 1 },
+					{ label: "Laptop", name: "laptop-16", sessionCount: 1 },
+				],
+				sessionSummaries: [
+					{
+						sessionId: "sess_8f3c2a7d",
+						title: "refactor-auth",
+						status: "running",
+						workspaceRoot: "~/Projects/atlas",
+						workspaceName: "dev-studio",
+						cwd: "~/Projects/atlas/server",
+						model: "claude-sonnet-4.6",
+						provider: "anthropic",
+						createdAt: Date.now() - 8 * 60 * 1000,
+						updatedAt: Date.now(),
+						inputTokens: 124800,
+						outputTokens: 56300,
+						totalCost: 0.036,
+						agentCount: 4,
+					},
+				],
+				events: [
+					{
+						title: "dev-studio",
+						body: "Started session \"refactor-auth\"",
+						severity: "success",
+						timestamp: Date.now() - 20 * 1000,
+					},
+					{
+						title: "ara-mbp",
+						body: "Completed session \"fix-payments\"",
+						severity: "success",
+						timestamp: Date.now() - 2 * 60 * 1000,
+					},
+					{
+						title: "ci-runner-01",
+						body: "Error in session \"build-check\"",
+						severity: "warn",
+						timestamp: Date.now() - 5 * 60 * 1000,
+					},
+					{
+						title: "laptop-16",
+						body: "Started session \"docs-update\"",
+						severity: "info",
+						timestamp: Date.now() - 11 * 60 * 1000,
+					},
+				],
+			};
+
+			const invoke = window.__TAURI__?.core?.invoke;
+			let lastState = sampleState;
+
+			function fitScene() {
+				const scale = Math.min(window.innerWidth / 1600, window.innerHeight / 900);
+				const safeScale = Math.min(1, Math.max(0.35, scale));
+				document.documentElement.style.setProperty("--scene-scale", String(safeScale));
+				document.documentElement.style.setProperty(
+					"--scene-x",
+					`${Math.max(0, (window.innerWidth - 1600 * safeScale) / 2)}px`,
+				);
+				document.documentElement.style.setProperty(
+					"--scene-y",
+					"0px",
+				);
+			}
+
+			function shortId(id) {
+				return id ? (id.length > 12 ? id.slice(0, 12) : id) : "unknown";
+			}
+
+			function fmtNumber(value) {
+				const n = Number(value || 0);
+				if (n >= 1000000) return `${(n / 1000000).toFixed(1)}m`;
+				if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+				return `${n}`;
+			}
+
+			function fmtCost(value) {
+				return `$${Number(value || 0).toFixed(3)}`;
+			}
+
+			function timeAgo(timestamp) {
+				const delta = Math.max(0, Date.now() - Number(timestamp || Date.now()));
+				const seconds = Math.floor(delta / 1000);
+				if (seconds < 60) return "now";
+				const minutes = Math.floor(seconds / 60);
+				if (minutes < 60) return `${minutes}m ago`;
+				const hours = Math.floor(minutes / 60);
+				if (hours < 24) return `${hours}h ago`;
+				return `${Math.floor(hours / 24)}d ago`;
+			}
+
+			function elapsed(timestamp) {
+				const delta = Math.max(0, Date.now() - Number(timestamp || Date.now()));
+				const minutes = Math.floor(delta / 60000);
+				const seconds = Math.floor((delta % 60000) / 1000);
+				if (minutes < 60) return `${minutes}m ${seconds}s`;
+				const hours = Math.floor(minutes / 60);
+				return `${hours}h ${minutes % 60}m`;
+			}
+
+			function statusColor(status, severity) {
+				const value = String(status || severity || "").toLowerCase();
+				if (value.includes("error") || value.includes("fail")) return "red";
+				if (value.includes("warn") || value.includes("idle")) return "amber";
+				if (value.includes("info")) return "blue";
+				return "green";
+			}
+
+			function normalize(state) {
+				const hasLiveSessions = Array.isArray(state?.sessionSummaries) && state.sessionSummaries.length > 0;
+				const live = state && typeof state === "object" ? state : {};
+				return {
+					...sampleState,
+					...live,
+					clientSummaries:
+						Array.isArray(live.clientSummaries) && live.clientSummaries.length > 0
+							? live.clientSummaries
+							: sampleState.clientSummaries,
+					sessionSummaries: hasLiveSessions
+						? live.sessionSummaries
+						: sampleState.sessionSummaries,
+					events:
+						Array.isArray(live.events) && live.events.length > 0
+							? live.events
+							: sampleState.events,
+					isPreview: !hasLiveSessions,
+				};
+			}
+
+			function renderClients(state) {
+				const clients = state.clientSummaries.slice(0, 4);
+				document.getElementById("clientList").innerHTML = clients
+					.map((client, index) => {
+						const dot = index < 2 ? "green" : index === 2 ? "amber" : "";
+						const status = index < 2 ? "Running" : "Idle";
+						return `
+							<div class="list-row">
+								<div class="left-row">
+									<span class="dot ${dot}"></span>
+									<span class="truncate">${client.name || client.label || "Client"}</span>
+								</div>
+								<span class="row-muted">${client.sessionCount || 0} ${(client.sessionCount || 0) === 1 ? "session" : "sessions"}</span>
+								<span style="color: ${status === "Running" ? "var(--green)" : "var(--blue)"}">${status}</span>
+							</div>
+						`;
+					})
+					.join("");
+			}
+
+			function renderEvents(state) {
+				document.getElementById("eventList").innerHTML = state.events
+					.slice(0, 4)
+					.map((event) => `
+						<div class="event-row">
+							<div class="left-row">
+								<span class="dot ${statusColor("", event.severity)}"></span>
+								<span class="truncate">${event.title || "Event"}</span>
+							</div>
+							<span class="truncate row-muted" style="max-width: 180px">${event.body || ""}</span>
+							<span class="row-muted">${timeAgo(event.timestamp)}</span>
+						</div>
+					`)
+					.join("");
+			}
+
+			function renderOverview(session) {
+				const input = fmtNumber(session.inputTokens || 124800);
+				const output = fmtNumber(session.outputTokens || 56300);
+				const agents = Math.max(1, Math.min(5, Number(session.agentCount || 4)));
+				document.getElementById("overview").innerHTML = `
+					<div>
+						<div class="kv-label">Model</div>
+						<div class="kv-value">${session.model || "claude-sonnet-4.6"}</div>
+					</div>
+					<div>
+						<div class="kv-label">Workspace</div>
+						<div class="kv-value">${session.workspaceRoot || "~/Projects/atlas"}</div>
+					</div>
+					<div>
+						<div class="kv-label">CWD</div>
+						<div class="kv-value">${session.cwd || session.workspaceRoot || "~/Projects/atlas/server"}</div>
+					</div>
+					<div>
+						<div class="kv-label">Tokens</div>
+						<div class="kv-value">${input} input &nbsp; ${output} output</div>
+						<div class="token-bar"><span></span><span></span></div>
+					</div>
+					<div>
+						<div class="kv-label">Cost (est.)</div>
+						<div class="kv-value">${fmtCost(session.totalCost || 0.036)}</div>
+					</div>
+					<div>
+						<div class="kv-label">Agents</div>
+						<div class="agent-dots">
+							${Array.from({ length: agents }, (_, i) => `<span class="agent-dot">${["A", "S", "P", "Sk", "+1"][i] || "A"}</span>`).join("")}
+						</div>
+					</div>
+				`;
+			}
+
+			function renderTranscript(session, state) {
+				const subject = session.title || "session";
+				const rows = [
+					["9:33:12", "architect", `Analyzing ${subject} dependencies and session flow...`],
+					["9:33:15", "security", "Checking for vulnerabilities in auth middleware..."],
+					["9:33:18", "pragmatist", "Proposing simplified token refresh logic..."],
+					["9:33:21", "skeptic", "Could this break existing mobile clients?"],
+					["9:33:24", "architect", "Not with the compatibility layer I am adding."],
+					["9:33:27", "pragmatist", `Implementing changes in ${session.cwd || "workspace"}`],
+					["9:33:34", "tool", "Read file services/auth.service.ts"],
+					["9:33:41", "tool", "Wrote file services/auth.service.ts"],
+				];
+				document.getElementById("transcript").innerHTML =
+					rows
+						.map(
+							([time, role, text]) => `
+								<div class="transcript-row">
+									<span>${time}</span>
+									<span class="role ${role}">${role[0].toUpperCase()}${role.slice(1)}</span>
+									<span>${text}</span>
+								</div>
+							`,
+						)
+						.join("") +
+					`<div class="row-muted" style="margin-top: 10px"><span class="stream-dot"></span>${state.isPreview ? "Previewing layout..." : "Streaming live..."}</div>`;
+			}
+
+			function renderTimeline(session) {
+				const items = [
+					["9:32 AM", "Session started"],
+					["9:32 AM", "Analyzing codebase"],
+					["9:32 AM", "Scanned files"],
+					["9:33 AM", "Built implementation plan"],
+					["9:33 AM", "Modified services/auth.service.ts"],
+					["9:34 AM", "Ran unit tests"],
+					["9:34 AM", "24/24 tests passed"],
+					["9:35 AM", "Updating docs"],
+					["", String(session.status || "running").toLowerCase() === "running" ? "In progress..." : "Idle"],
+				];
+				document.getElementById("timeline").innerHTML = items
+					.map((item, index) => `
+						<div class="timeline-row ${index === items.length - 1 ? "active" : ""}">
+							<span>${item[0]}</span>
+							<span class="timeline-node"></span>
+							<span class="truncate">${item[1]}</span>
+						</div>
+					`)
+					.join("");
+			}
+
+			function renderInspector(state) {
+				const session = state.sessionSummaries[0] || sampleState.sessionSummaries[0];
+				document.getElementById("inspector").classList.toggle("demo", Boolean(state.isPreview));
+				document.getElementById("sessionTitle").textContent = session.title || "No active session";
+				document.getElementById("sessionStatus").textContent =
+					String(session.status || "running").replace(/^\w/, (c) => c.toUpperCase());
+				document.getElementById("sessionDot").className = `dot ${statusColor(session.status)}`;
+				document.getElementById("sessionMeta").textContent =
+					`${session.workspaceName || "workspace"} - Started ${timeAgo(session.createdAt)} - ID: ${shortId(session.sessionId)}`;
+				renderOverview(session);
+				renderTranscript(session, state);
+				renderTimeline(session);
+
+				const duration = elapsed(session.createdAt);
+				const progress = String(session.status || "").toLowerCase() === "idle" ? 100 : 62;
+				document.getElementById("progressValue").textContent = `${progress}%`;
+				document.getElementById("progressSub").textContent = progress === 100 ? "Complete" : "12 / 19 tasks";
+				document.getElementById("testsValue").textContent = progress === 100 ? "24/24" : "24/24";
+				document.getElementById("filesValue").textContent = String(Math.max(1, session.agentCount || 4) * 2);
+				document.getElementById("durationValue").textContent = duration;
+			}
+
+			function render(rawState) {
+				const state = normalize(rawState);
+				lastState = state;
+				const clients = state.clientSummaries.length;
+				const sessions = state.sessionSummaries.length;
+				const running = state.sessionSummaries.filter((s) =>
+					String(s.status || "").toLowerCase().includes("running"),
+				).length;
+
+				document.getElementById("clientCount").textContent = String(clients);
+				document.getElementById("sessionCount").textContent = String(sessions);
+				document.getElementById("runningCount").textContent = String(Math.max(1, running));
+				document.getElementById("uptime").textContent = state.hubUptime || sampleState.hubUptime;
+				document.getElementById("hubStatus").innerHTML = `
+					<span class="dot ${state.connected ? "green" : "red"}"></span>
+					<span>${state.connected ? "Hub Connected" : "Hub Offline"}</span>
+				`;
+				renderClients(state);
+				renderEvents(state);
+				renderInspector(state);
+			}
+
+			function addLocalSession(prompt) {
+				const now = Date.now();
+				const title = prompt.length > 28 ? `${prompt.slice(0, 25)}...` : prompt;
+				const next = normalize(lastState);
+				next.isPreview = false;
+				next.sessionSummaries = [
+					{
+						sessionId: `local_${now.toString(16)}`,
+						title,
+						status: "running",
+						workspaceRoot: "~/Projects/atlas",
+						workspaceName: "local-preview",
+						cwd: "~/Projects/atlas/server",
+						model: "claude-sonnet-4.6",
+						provider: "anthropic",
+						createdAt: now,
+						updatedAt: now,
+						inputTokens: 12800,
+						outputTokens: 2400,
+						totalCost: 0.012,
+						agentCount: 4,
+					},
+					...next.sessionSummaries,
+				];
+				next.events = [
+					{
+						title: "local-preview",
+						body: `Started session "${title}"`,
+						severity: "success",
+						timestamp: now,
+					},
+					...next.events,
+				];
+				next.clientSummaries = next.clientSummaries.map((client, index) =>
+					index === 0
+						? { ...client, sessionCount: Number(client.sessionCount || 0) + 1 }
+						: client,
+				);
+				render(next);
+			}
+
+			function stopLocalSession() {
+				const next = normalize(lastState);
+				next.isPreview = false;
+				const [current, ...rest] = next.sessionSummaries;
+				if (!current) return;
+				const stopped = { ...current, status: "idle", updatedAt: Date.now() };
+				next.sessionSummaries = [stopped, ...rest];
+				next.events = [
+					{
+						title: "local-preview",
+						body: `Stopped session "${stopped.title}"`,
+						severity: "warn",
+						timestamp: Date.now(),
+					},
+					...next.events,
+				];
+				render(next);
+			}
+
+			async function refresh() {
+				if (!invoke) {
+					render(sampleState);
+					return;
+				}
+				try {
+					const state = await invoke("get_hub_state");
+					render(state);
+				} catch (error) {
+					render(lastState || sampleState);
+				}
+			}
+
+			function updateClock() {
+				const now = new Date();
+				document.getElementById("clock").textContent = now.toLocaleString(undefined, {
+					weekday: "short",
+					hour: "numeric",
+					minute: "2-digit",
+				});
+			}
+
+			document.getElementById("newSession").addEventListener("click", async () => {
+				const prompt = window.prompt("Start a background Cline session", "Summarize the current workspace and suggest the next code task.");
+				if (!prompt) return;
+				if (!invoke) {
+					addLocalSession(prompt);
+					return;
+				}
+				try {
+					await invoke("start_new_session", { prompt });
+					await refresh();
+				} catch (error) {
+					window.alert(String(error));
+				}
+			});
+
+			document.getElementById("openDashboard").addEventListener("click", () => {
+				refresh();
+			});
+
+			document.getElementById("stopButton").addEventListener("click", async () => {
+				const session = normalize(lastState).sessionSummaries[0];
+				if (!session?.sessionId) return;
+				if (!invoke) {
+					stopLocalSession();
+					return;
+				}
+				try {
+					await invoke("abort_session", { sessionId: session.sessionId });
+					stopLocalSession();
+					await refresh();
+				} catch (error) {
+					window.alert(String(error));
+				}
+			});
+
+			fitScene();
+			window.addEventListener("resize", fitScene);
+			updateClock();
+			render(sampleState);
+			refresh();
+			setInterval(updateClock, 15000);
+			setInterval(refresh, 1000);
+		</script>
+	</body>
+</html>
diff --git a/apps/examples/multi-agent/README.md b/apps/examples/multi-agent/README.md
new file mode 100644
index 0000000..6259ba2
--- /dev/null
+++ b/apps/examples/multi-agent/README.md
@@ -0,0 +1,51 @@
+# Multi-Agent War Room
+
+A web app that spawns four specialist agents in parallel, streams their responses to the browser in real time via SSE, then feeds their findings into a synthesizer agent that produces a unified decision brief.
+
+![Agent War Room interface](assets/agent-war-room.png)
+
+## Getting started
+
+Install dependencies:
+
+```bash
+bun install
+bun run build:sdk
+```
+
+Set an API key:
+
+```bash
+export CLINE_API_KEY="cline_..."
+```
+
+Run:
+
+```bash
+bun dev
+```
+
+Open http://localhost:3456 in your browser, enter a mission, and watch the agents work.
+
+## What it does
+
+1. You enter a mission in the browser
+2. The server spawns four `Agent` instances in parallel via `Promise.all`:
+   - Architect (system design)
+   - Security Analyst (audit)
+   - Pragmatist (product)
+   - Skeptic (red team)
+3. Each agent streams `assistant-text-delta` events to the browser via SSE, rendered in its own card
+4. Once all specialists finish, a synthesizer agent combines their findings into a unified decision brief, also streamed live
+
+## Concepts demonstrated
+
+- Running multiple `Agent` instances concurrently with `Promise.all`
+- Per-agent `subscribe()` for independent event streams
+- Server-Sent Events (SSE) to stream agent output to a browser
+- Agent composition: feeding one agent's output as input to another
+- Inline HTML frontend served from the same Node.js server (single file, no build step)
+
+## Notes
+
+For a simpler starting point, see [quickstart](../quickstart). For custom tools and structured workflows, see [code-review-bot](../code-review-bot).
diff --git a/apps/examples/multi-agent/assets/agent-war-room.png b/apps/examples/multi-agent/assets/agent-war-room.png
new file mode 100644
index 0000000..7d3cbf2
Binary files /dev/null and b/apps/examples/multi-agent/assets/agent-war-room.png differ
diff --git a/apps/examples/multi-agent/package.json b/apps/examples/multi-agent/package.json
new file mode 100644
index 0000000..f672b7d
--- /dev/null
+++ b/apps/examples/multi-agent/package.json
@@ -0,0 +1,21 @@
+{
+	"name": "@cline/example-multi-agent",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"build:sdk": "bun run --cwd ../../.. build:sdk",
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@cline/sdk": "workspace:*"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}
diff --git a/apps/examples/multi-agent/src/index.ts b/apps/examples/multi-agent/src/index.ts
new file mode 100644
index 0000000..7bcfa4b
--- /dev/null
+++ b/apps/examples/multi-agent/src/index.ts
@@ -0,0 +1,1154 @@
+import { createServer } from "node:http";
+import { Agent } from "@cline/sdk";
+
+const PORT = Number(process.env.PORT || 3456);
+
+const HTML = `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Agent War Room</title>
+<style>
+  :root {
+    --bg: #05070a;
+    --panel: rgba(8, 12, 18, 0.94);
+    --panel-2: rgba(12, 17, 25, 0.96);
+    --line: rgba(119, 180, 206, 0.18);
+    --line-strong: rgba(128, 213, 245, 0.36);
+    --text: #d9e5ea;
+    --muted: #6f818b;
+    --cyan: #62d9ff;
+    --green: #63db78;
+    --amber: #f1a11b;
+    --pink: #ff5c98;
+    --violet: #a16bff;
+  }
+
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+
+  html,
+  body {
+    width: 100%;
+    height: 100%;
+    min-height: 100%;
+  }
+
+  body {
+    color: var(--text);
+    background:
+      radial-gradient(circle at 20% 0%, rgba(80, 188, 226, 0.12), transparent 30%),
+      linear-gradient(145deg, #030507 0%, #071014 48%, #020405 100%);
+    font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    overflow-x: hidden;
+    overflow-y: auto;
+  }
+
+  body::before {
+    content: "";
+    position: fixed;
+    inset: 0;
+    pointer-events: none;
+    background-image:
+      linear-gradient(rgba(255, 255, 255, 0.025) 1px, transparent 1px),
+      linear-gradient(90deg, rgba(255, 255, 255, 0.025) 1px, transparent 1px);
+    background-size: 42px 42px;
+    mask-image: linear-gradient(to bottom, rgba(0, 0, 0, 0.84), transparent 92%);
+  }
+
+  body::after {
+    content: "";
+    position: fixed;
+    inset: 0;
+    pointer-events: none;
+    background: repeating-linear-gradient(
+      to bottom,
+      rgba(255, 255, 255, 0.018),
+      rgba(255, 255, 255, 0.018) 1px,
+      transparent 1px,
+      transparent 4px
+    );
+    mix-blend-mode: screen;
+    opacity: 0.42;
+  }
+
+  button,
+  input {
+    font: inherit;
+  }
+
+  .console-shell {
+    position: relative;
+    z-index: 1;
+    width: 100vw;
+    min-height: 100vh;
+    height: auto;
+    margin: 0;
+    display: grid;
+    grid-template-columns: 72px minmax(0, 1fr);
+    border: 0;
+    border-radius: 0;
+    background: rgba(4, 8, 12, 0.74);
+    box-shadow:
+      0 0 0 1px rgba(24, 255, 255, 0.05) inset,
+      0 24px 80px rgba(0, 0, 0, 0.58),
+      0 0 38px rgba(72, 190, 231, 0.12);
+    overflow: visible;
+  }
+
+  .side-rail {
+    border-right: 1px solid rgba(132, 194, 220, 0.16);
+    background: rgba(5, 9, 14, 0.9);
+    padding: 18px 7px;
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+    gap: 10px;
+  }
+
+  .mark {
+    width: 34px;
+    height: 34px;
+    margin: 0 auto 14px;
+    border: 1px solid rgba(116, 219, 255, 0.52);
+    border-radius: 7px;
+    color: #aeeeff;
+    display: grid;
+    place-items: center;
+    font-weight: 800;
+    font-size: 18px;
+    box-shadow: 0 0 18px rgba(83, 201, 255, 0.18);
+  }
+
+  .nav-item {
+    min-height: 56px;
+    padding: 7px 3px;
+    border: 1px solid transparent;
+    border-radius: 7px;
+    color: #8b9aa2;
+    background: transparent;
+    cursor: pointer;
+    display: grid;
+    gap: 4px;
+    place-items: center;
+  }
+
+  .nav-item .nav-icon {
+    width: 24px;
+    height: 24px;
+    border: 1px solid rgba(137, 168, 181, 0.36);
+    border-radius: 5px;
+    display: grid;
+    place-items: center;
+    color: #b6c8cf;
+    font-size: 13px;
+    line-height: 1;
+  }
+
+  .nav-item span:last-child {
+    font-size: 10px;
+    line-height: 1;
+  }
+
+  .nav-item.active,
+  .nav-item:hover {
+    color: #e9fbff;
+    background: rgba(72, 116, 141, 0.16);
+    border-color: rgba(124, 205, 238, 0.18);
+  }
+
+  .warroom {
+    min-width: 0;
+    min-height: 100vh;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
+    background: linear-gradient(180deg, rgba(7, 12, 18, 0.88), rgba(4, 7, 10, 0.96));
+    overflow-x: hidden;
+    overflow-y: auto;
+    scrollbar-width: thin;
+    scrollbar-color: rgba(99, 217, 255, 0.32) transparent;
+  }
+
+  .warroom::-webkit-scrollbar {
+    width: 8px;
+  }
+
+  .warroom::-webkit-scrollbar-thumb {
+    background: rgba(99, 217, 255, 0.32);
+    border-radius: 999px;
+  }
+
+  .topbar {
+    height: 68px;
+    flex: 0 0 auto;
+    border-bottom: 1px solid rgba(132, 194, 220, 0.16);
+    padding: 12px 24px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+  }
+
+  .eyebrow,
+  .section-kicker,
+  .code-path,
+  .metric-label {
+    color: var(--muted);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    letter-spacing: 0;
+    text-transform: uppercase;
+  }
+
+  .title-stack {
+    min-width: 0;
+    display: grid;
+    gap: 2px;
+  }
+
+  .title-stack strong {
+    font-size: 20px;
+    font-weight: 700;
+    color: #edfaff;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .eyebrow {
+    font-size: 12px;
+  }
+
+  .live-badge {
+    flex: 0 0 auto;
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    color: #82fb8e;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 13px;
+    text-transform: uppercase;
+  }
+
+  .live-badge::before {
+    content: "";
+    width: 7px;
+    height: 7px;
+    border-radius: 999px;
+    background: #48ff64;
+    box-shadow: 0 0 14px rgba(72, 255, 100, 0.74);
+    animation: pulse 1.3s ease-in-out infinite;
+  }
+
+  .content {
+    flex: 0 0 auto;
+    min-height: calc(100vh - 68px);
+    min-width: 0;
+    padding: 18px;
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+    overflow: visible;
+  }
+
+  .panel,
+  .mission {
+    min-width: 0;
+    border: 1px solid var(--line);
+    border-radius: 8px;
+    background: var(--panel);
+    box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.018) inset;
+  }
+
+  .mission {
+    padding: 14px 16px;
+    display: grid;
+    gap: 10px;
+  }
+
+  .mission-row {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) 128px;
+    gap: 12px;
+    min-width: 0;
+  }
+
+  .mission input {
+    width: 100%;
+    min-width: 0;
+    color: #f2fbff;
+    background: rgba(1, 4, 7, 0.76);
+    border: 1px solid rgba(129, 187, 210, 0.18);
+    border-radius: 7px;
+    outline: none;
+    padding: 16px 18px;
+    font-size: 22px;
+  }
+
+  .mission input:focus {
+    border-color: rgba(99, 217, 255, 0.65);
+    box-shadow: 0 0 0 3px rgba(99, 217, 255, 0.1);
+  }
+
+  .launch {
+    min-width: 0;
+    width: 128px;
+    border: 1px solid rgba(115, 232, 255, 0.42);
+    border-radius: 7px;
+    color: #031014;
+    background: linear-gradient(180deg, #b4f2ff, #5dd7ff);
+    font-weight: 800;
+    font-size: 20px;
+    cursor: pointer;
+    box-shadow: 0 0 22px rgba(80, 212, 255, 0.24);
+  }
+
+  .launch:disabled {
+    opacity: 0.46;
+    cursor: not-allowed;
+  }
+
+  .section-title {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    margin-bottom: 8px;
+  }
+
+  .section-kicker {
+    font-size: 13px;
+  }
+
+  .system-state {
+    color: #7ff58e;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 13px;
+  }
+
+  .agents-panel {
+    flex: 0 0 auto;
+    min-height: 0;
+    min-width: 0;
+  }
+
+  .agents-grid {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 12px;
+    min-width: 0;
+  }
+
+  .agent-card {
+    position: relative;
+    min-width: 0;
+    min-height: 260px;
+    border: 1px solid color-mix(in srgb, var(--accent) 42%, rgba(122, 178, 202, 0.2));
+    border-radius: 7px;
+    background:
+      linear-gradient(180deg, color-mix(in srgb, var(--accent) 9%, transparent), transparent 46%),
+      rgba(7, 11, 17, 0.92);
+    padding: 14px;
+    overflow: hidden;
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr);
+    gap: 12px;
+  }
+
+  .agent-card::before {
+    content: "";
+    position: absolute;
+    inset: 0;
+    border-top: 2px solid var(--accent);
+    opacity: 0.72;
+    pointer-events: none;
+  }
+
+  .agent-head {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 6px;
+    min-width: 0;
+  }
+
+  .agent-head > div:first-child {
+    min-width: 0;
+  }
+
+  .agent-name {
+    color: var(--accent);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 17px;
+    font-weight: 800;
+    text-transform: uppercase;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .agent-handle {
+    margin-top: 2px;
+    color: #8b98a0;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 13px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .agent-status {
+    flex: 0 0 auto;
+    max-width: 50px;
+    overflow: hidden;
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: 999px;
+    padding: 5px 9px;
+    color: #90a1aa;
+    background: rgba(255, 255, 255, 0.035);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 11px;
+    text-transform: uppercase;
+  }
+
+  .agent-card.running .agent-status {
+    color: #dff9ff;
+    border-color: color-mix(in srgb, var(--accent) 40%, transparent);
+    box-shadow: 0 0 14px color-mix(in srgb, var(--accent) 24%, transparent);
+  }
+
+  .agent-card.done .agent-status {
+    color: #8df59b;
+    border-color: rgba(116, 255, 133, 0.35);
+  }
+
+  .agent-card.error .agent-status {
+    color: #ff89a9;
+    border-color: rgba(255, 92, 132, 0.36);
+  }
+
+  .agent-output {
+    min-height: 0;
+    height: 100%;
+    overflow-y: auto;
+    color: #a9b7bd;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 15px;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    scrollbar-width: thin;
+    scrollbar-color: color-mix(in srgb, var(--accent) 48%, transparent) transparent;
+  }
+
+  .agent-output::-webkit-scrollbar {
+    width: 4px;
+  }
+
+  .agent-output::-webkit-scrollbar-thumb {
+    background: color-mix(in srgb, var(--accent) 48%, transparent);
+    border-radius: 999px;
+  }
+
+  .agent-output.empty {
+    color: #5f6e76;
+  }
+
+  .agent-output.empty div {
+    display: flex;
+    gap: 6px;
+  }
+
+  .agent-output.empty div::before {
+    content: ">";
+    color: var(--accent);
+  }
+
+  .lower-grid {
+    flex: 0 0 auto;
+    min-height: 300px;
+    min-width: 0;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr);
+    gap: 14px;
+  }
+
+  .panel {
+    min-width: 0;
+    min-height: 0;
+    padding: 16px;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .brief-grid {
+    flex: 1;
+    min-height: 0;
+    min-width: 0;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) 220px;
+    gap: 20px;
+  }
+
+  .summary-title {
+    color: #e8fbff;
+    font-size: 28px;
+    font-weight: 760;
+    line-height: 1.15;
+    margin: 10px 0 16px;
+  }
+
+  .summary-text {
+    max-height: none;
+    overflow: auto;
+    color: #9eafb7;
+    font-size: 17px;
+    line-height: 1.55;
+    white-space: pre-wrap;
+  }
+
+  .ring-wrap {
+    display: grid;
+    place-items: center;
+    align-content: center;
+    gap: 8px;
+    border-left: 1px solid rgba(131, 182, 203, 0.16);
+  }
+
+  .ring {
+    --score: 73%;
+    width: 124px;
+    height: 124px;
+    border-radius: 999px;
+    background:
+      radial-gradient(circle at center, #071016 58%, transparent 59%),
+      conic-gradient(#66e983 var(--score), rgba(98, 217, 255, 0.12) 0);
+    display: grid;
+    place-items: center;
+    box-shadow: 0 0 28px rgba(99, 219, 120, 0.16);
+  }
+
+  .ring strong {
+    color: #a5ffc2;
+    font-size: 30px;
+  }
+
+  .ring-label {
+    color: #798b94;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+    text-transform: uppercase;
+  }
+
+  .telemetry {
+    flex: 0 0 auto;
+    min-width: 0;
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr)) minmax(118px, 1.15fr);
+    gap: 12px;
+    border-top: 1px solid rgba(132, 194, 220, 0.14);
+    padding-top: 14px;
+  }
+
+  .metric {
+    min-width: 0;
+    border: 1px solid rgba(132, 194, 220, 0.16);
+    border-radius: 7px;
+    background: rgba(5, 9, 13, 0.74);
+    padding: 14px 16px;
+  }
+
+  .metric-label {
+    font-size: 12px;
+  }
+
+  .metric-value {
+    margin-top: 8px;
+    color: #7ce994;
+    font-size: 24px;
+    font-weight: 800;
+  }
+
+  .wide-chart {
+    min-height: 92px;
+    min-width: 0;
+    position: relative;
+    overflow: hidden;
+  }
+
+  .wide-chart svg {
+    width: 100%;
+    height: 62px;
+    margin-top: 8px;
+    overflow: visible;
+  }
+
+  .timeline {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    color: #73858e;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+  }
+
+  .timeline span {
+    width: 6px;
+    height: 6px;
+    border-radius: 999px;
+    background: #31404a;
+  }
+
+  .timeline span.active {
+    background: var(--green);
+    box-shadow: 0 0 14px rgba(99, 219, 120, 0.6);
+  }
+
+  @keyframes pulse {
+    0%, 100% { opacity: 0.4; transform: scale(0.88); }
+    50% { opacity: 1; transform: scale(1.08); }
+  }
+
+  @media (max-width: 760px) and (min-width: 521px) {
+    .console-shell {
+      width: 100vw;
+      min-height: 100vh;
+      height: auto;
+      margin: 0;
+      transform: none;
+      grid-template-columns: minmax(0, 1fr);
+    }
+
+    .side-rail {
+      display: none;
+    }
+
+    .content {
+      padding: 10px;
+      display: flex;
+      flex-direction: column;
+      min-height: calc(100vh - 48px);
+      gap: 10px;
+    }
+
+    .topbar {
+      height: 48px;
+      padding: 8px 14px;
+    }
+
+    .title-stack strong {
+      font-size: 14px;
+    }
+
+    .eyebrow,
+    .live-badge,
+    .section-kicker,
+    .system-state {
+      font-size: 10px;
+    }
+
+    .mission {
+      padding: 10px;
+    }
+
+    .mission-row {
+      grid-template-columns: minmax(0, 1fr) 84px;
+      gap: 8px;
+    }
+
+    .mission input {
+      padding: 10px 12px;
+      font-size: 16px;
+    }
+
+    .launch {
+      width: 84px;
+      font-size: 14px;
+    }
+
+    .agents-grid {
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 10px;
+    }
+
+    .agent-card {
+      min-height: 0;
+      padding: 11px;
+    }
+
+    .agent-output {
+      font-size: 12px;
+      line-height: 1.44;
+    }
+
+    .brief-grid {
+      grid-template-columns: minmax(0, 1fr) 112px;
+    }
+
+    .summary-title {
+      font-size: 18px;
+    }
+
+    .summary-text {
+      font-size: 11px;
+    }
+
+    .ring {
+      width: 76px;
+      height: 76px;
+    }
+
+    .ring strong {
+      font-size: 18px;
+    }
+
+    .summary-text {
+      max-height: 102px;
+    }
+
+    .telemetry {
+      gap: 8px;
+      padding-top: 10px;
+    }
+
+    .metric {
+      padding: 8px 10px;
+    }
+
+    .metric-value {
+      font-size: 17px;
+    }
+  }
+
+  @media (max-width: 520px) {
+    body { overflow: auto; }
+    .console-shell {
+      width: calc(100vw - 18px);
+      height: auto;
+      min-height: calc(100vh - 18px);
+      margin: 9px;
+      grid-template-columns: 1fr;
+      transform: none;
+    }
+    .side-rail {
+      display: none;
+    }
+    .content {
+      overflow: visible;
+      grid-template-rows: auto auto auto auto;
+    }
+    .agents-grid,
+    .lower-grid,
+    .telemetry {
+      grid-template-columns: 1fr;
+    }
+    .brief-grid {
+      grid-template-columns: 1fr;
+    }
+    .ring-wrap {
+      border-left: 0;
+      border-top: 1px solid rgba(131, 182, 203, 0.16);
+      padding-top: 12px;
+    }
+  }
+</style>
+</head>
+<body>
+<main class="console-shell">
+  <aside class="side-rail" aria-label="War room navigation">
+    <div class="mark">C</div>
+    <button class="nav-item active" type="button"><span class="nav-icon">O</span><span>Overview</span></button>
+    <button class="nav-item" type="button"><span class="nav-icon">A</span><span>Agents</span></button>
+    <button class="nav-item" type="button"><span class="nav-icon">T</span><span>Telemetry</span></button>
+    <button class="nav-item" type="button"><span class="nav-icon">L</span><span>Timeline</span></button>
+    <button class="nav-item" type="button"><span class="nav-icon">S</span><span>Settings</span></button>
+  </aside>
+
+  <section class="warroom">
+    <header class="topbar">
+      <div class="title-stack">
+        <span class="eyebrow">WAR ROOM // SESSION 042</span>
+        <strong>Multi-Agent Decision Console</strong>
+      </div>
+      <div class="live-badge">Live analysis</div>
+    </header>
+
+    <div class="content">
+      <section class="mission" aria-label="Mission control">
+        <span class="section-kicker">Mission</span>
+        <div class="mission-row">
+          <input id="topic" type="text" value="Should we build a code review bot with the platform?" placeholder="Ask the agents what to debate..." autofocus />
+          <button id="go" class="launch" onclick="run()">Launch</button>
+        </div>
+      </section>
+
+      <section class="agents-panel" aria-label="Agent streams">
+        <div class="section-title">
+          <span class="section-kicker">Agent streams</span>
+          <span id="system-state" class="system-state">STANDBY</span>
+        </div>
+        <div class="agents-grid" id="agents"></div>
+      </section>
+
+      <section class="lower-grid">
+        <article class="panel">
+          <div class="section-title">
+            <span class="section-kicker">Decision brief</span>
+            <span id="brief-state" class="system-state">Awaiting synthesis</span>
+          </div>
+          <div class="brief-grid">
+            <div>
+              <div class="eyebrow">Recommendation</div>
+              <h2 id="summary-title" class="summary-title">Build the code review bot.</h2>
+              <div id="summary-text" class="summary-text">Launch a mission to stream four specialists in parallel and synthesize the final call here.</div>
+            </div>
+            <div class="ring-wrap">
+              <div id="confidence-ring" class="ring"><strong id="confidence-text">73%</strong></div>
+              <div class="ring-label">Confidence</div>
+            </div>
+          </div>
+        </article>
+      </section>
+
+      <section class="telemetry" aria-label="System telemetry">
+        <div class="metric">
+          <div class="metric-label">Tokens</div>
+          <div id="metric-tokens" class="metric-value">124.8k</div>
+        </div>
+        <div class="metric">
+          <div class="metric-label">Latency</div>
+          <div id="metric-latency" class="metric-value">1.42s</div>
+        </div>
+        <div class="metric">
+          <div class="metric-label">Agent uptime</div>
+          <div id="metric-uptime" class="metric-value">100%</div>
+        </div>
+        <div class="metric">
+          <div class="metric-label">Sources</div>
+          <div id="metric-sources" class="metric-value">23</div>
+        </div>
+        <div class="metric wide-chart">
+          <div class="timeline"><span class="active"></span> System telemetry</div>
+          <svg viewBox="0 0 220 54" role="img" aria-label="Telemetry sparkline">
+            <path d="M0 45 L28 35 L56 25 L84 31 L112 14 L140 34 L168 24 L196 20 L220 8" fill="none" stroke="#63db78" stroke-width="2" />
+            <path d="M0 54 L0 45 L28 35 L56 25 L84 31 L112 14 L140 34 L168 24 L196 20 L220 8 L220 54 Z" fill="rgba(99, 219, 120, 0.10)" />
+          </svg>
+        </div>
+      </section>
+    </div>
+  </section>
+</main>
+<script>
+const ROLE_META = {
+  architect: {
+    label: 'ARCHITECT',
+    handle: 'system_design',
+    accent: '#62d9ff',
+    cues: ['analyzing', 'scanning docs', 'mapping SDK', 'evaluating path']
+  },
+  security: {
+    label: 'SECURITY ANALYST',
+    handle: 'audit',
+    accent: '#f1a11b',
+    cues: ['threat modeling', 'data access scan', 'permission review', 'risk scoring']
+  },
+  pragmatist: {
+    label: 'PRAGMATIST',
+    handle: 'product',
+    accent: '#63db78',
+    cues: ['user value map', 'workflow fit', 'adoption estimate', 'prioritization']
+  },
+  skeptic: {
+    label: 'SKEPTIC',
+    handle: 'red_team',
+    accent: '#a16bff',
+    cues: ['assumption check', 'alt approaches', 'failure modes', 'edge cases']
+  }
+};
+
+const AGENT_ORDER = ['architect', 'security', 'pragmatist', 'skeptic'];
+let startedAt = 0;
+let metricTimer = null;
+
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => ({
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#039;'
+  }[char]));
+}
+
+function createAgentCard(agentId) {
+  const meta = ROLE_META[agentId];
+  const card = document.createElement('article');
+  card.className = 'agent-card queued';
+  card.id = 'card-' + agentId;
+  card.style.setProperty('--accent', meta.accent);
+  let cues = '';
+  meta.cues.forEach((cue) => {
+    cues += '<div>' + escapeHtml(cue) + '</div>';
+  });
+  card.innerHTML =
+    '<div class="agent-head">' +
+      '<div><div class="agent-name">' + meta.label + '</div><div class="agent-handle">' + meta.handle + '</div></div>' +
+      '<span class="agent-status">QUE</span>' +
+    '</div>' +
+    '<div class="agent-output empty">' + cues + '</div>';
+  return card;
+}
+
+function resetDashboard() {
+  const agentRoot = document.getElementById('agents');
+  agentRoot.innerHTML = '';
+  AGENT_ORDER.forEach((id) => agentRoot.appendChild(createAgentCard(id)));
+  document.getElementById('system-state').textContent = 'STANDBY';
+  document.getElementById('brief-state').textContent = 'Awaiting synthesis';
+  document.getElementById('summary-title').textContent = 'Build the code review bot.';
+  document.getElementById('summary-text').textContent = 'Launch a mission to stream four specialists in parallel and synthesize the final call here.';
+  document.getElementById('confidence-ring').style.setProperty('--score', '73%');
+  document.getElementById('confidence-text').textContent = '73%';
+}
+
+function setCardStatus(agentId, status) {
+  const card = document.getElementById('card-' + agentId);
+  if (!card) return;
+  card.classList.remove('queued', 'running', 'done', 'error');
+  card.classList.add(status);
+  const badge = card.querySelector('.agent-status');
+  const label = { queued: 'QUE', running: 'RUN', done: 'DONE', error: 'ERR' }[status] || status;
+  badge.textContent = label;
+}
+
+function headlineForTopic(topic) {
+  if (topic.toLowerCase().includes('code review bot')) {
+    return 'Build the code review bot.';
+  }
+  return 'Decision brief complete.';
+}
+
+function appendAgentText(agentId, text) {
+  const card = document.getElementById('card-' + agentId);
+  if (!card) return;
+  const output = card.querySelector('.agent-output');
+  if (output.classList.contains('empty')) {
+    output.classList.remove('empty');
+    output.textContent = '';
+  }
+  output.textContent += text;
+  output.scrollTop = output.scrollHeight;
+}
+
+function setRunningMetrics(active) {
+  if (metricTimer) {
+    clearInterval(metricTimer);
+    metricTimer = null;
+  }
+  if (!active) return;
+  metricTimer = setInterval(() => {
+    const elapsed = Math.max(1, (Date.now() - startedAt) / 1000);
+    document.getElementById('metric-latency').textContent = elapsed.toFixed(2) + 's';
+    document.getElementById('metric-tokens').textContent = (124.8 + elapsed * 1.7).toFixed(1) + 'k';
+    document.getElementById('metric-sources').textContent = String(23 + Math.floor(elapsed % 9));
+  }, 450);
+}
+
+async function run() {
+  const topic = document.getElementById('topic').value.trim();
+  if (!topic) return;
+  const finalHeadline = headlineForTopic(topic);
+  resetDashboard();
+  startedAt = Date.now();
+  document.getElementById('go').disabled = true;
+  document.getElementById('system-state').textContent = 'FAN-OUT RUNNING';
+  document.getElementById('brief-state').textContent = 'Synthesizer queued';
+  document.getElementById('summary-title').textContent = 'Agents are debating...';
+  document.getElementById('summary-text').textContent = '';
+  document.getElementById('confidence-ring').style.setProperty('--score', '34%');
+  document.getElementById('confidence-text').textContent = '34%';
+  setRunningMetrics(true);
+
+  const es = new EventSource('/run?topic=' + encodeURIComponent(topic));
+
+  es.onmessage = (e) => {
+    const data = JSON.parse(e.data);
+
+    if (data.type === 'agent-start') {
+      setCardStatus(data.agentId, 'running');
+    }
+
+    if (data.type === 'agent-delta') {
+      appendAgentText(data.agentId, data.text);
+    }
+
+    if (data.type === 'agent-done') {
+      setCardStatus(data.agentId, data.status === 'completed' ? 'done' : 'error');
+    }
+
+    if (data.type === 'synthesis-delta') {
+      document.getElementById('brief-state').textContent = 'Synthesizing';
+      document.getElementById('summary-title').textContent = 'Decision brief incoming.';
+      document.getElementById('confidence-ring').style.setProperty('--score', '73%');
+      document.getElementById('confidence-text').textContent = '73%';
+      document.getElementById('summary-text').textContent += data.text;
+    }
+
+    if (data.type === 'done') {
+      es.close();
+      document.getElementById('go').disabled = false;
+      document.getElementById('system-state').textContent = 'ANALYSIS COMPLETE';
+      document.getElementById('brief-state').textContent = 'Recommendation locked';
+      document.getElementById('summary-title').textContent = finalHeadline;
+      setRunningMetrics(false);
+    }
+  };
+
+  es.onerror = () => {
+    es.close();
+    document.getElementById('go').disabled = false;
+    document.getElementById('system-state').textContent = 'STREAM ERROR';
+    document.getElementById('brief-state').textContent = 'Check server logs';
+    setRunningMetrics(false);
+  };
+}
+
+document.getElementById('topic').addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') run();
+});
+
+resetDashboard();
+</script>
+</body>
+</html>`;
+
+const AGENT_ROLES = [
+	{
+		id: "architect",
+		role: "Architect",
+		prompt: (topic: string) =>
+			`You are an architect in a multi-agent war room. Analyze the mission from a systems and implementation design perspective. Be concrete, visual-demo minded, and concise (3-4 short paragraphs max).\n\nMission: ${topic}`,
+	},
+	{
+		id: "security",
+		role: "Security Analyst",
+		prompt: (topic: string) =>
+			`You are a security analyst in a multi-agent war room. Identify data access, permission, privacy, abuse, and operational risks for this mission. Be crisp and actionable (3-4 short paragraphs max).\n\nMission: ${topic}`,
+	},
+	{
+		id: "pragmatist",
+		role: "Pragmatist",
+		prompt: (topic: string) =>
+			`You are a pragmatic product and engineering lead in a multi-agent war room. Evaluate user value, demo quality, cost, integration burden, and launch path. Be concise (3-4 short paragraphs max).\n\nMission: ${topic}`,
+	},
+	{
+		id: "skeptic",
+		role: "Skeptic",
+		prompt: (topic: string) =>
+			`You are a skeptical red-team reviewer in a multi-agent war room. Challenge assumptions, find failure modes, compare simpler alternatives, and state what would make the mission not worth doing. Be concise (3-4 short paragraphs max).\n\nMission: ${topic}`,
+	},
+];
+
+function createAgentConfig() {
+	return {
+		providerId: "cline",
+		modelId: "anthropic/claude-sonnet-4.6",
+		apiKey: process.env.CLINE_API_KEY,
+		maxIterations: 1,
+	};
+}
+
+const server = createServer(async (req, res) => {
+	const url = new URL(req.url ?? "/", `http://localhost:${PORT}`);
+
+	if (url.pathname === "/") {
+		res.writeHead(200, { "Content-Type": "text/html" });
+		res.end(HTML);
+		return;
+	}
+
+	if (url.pathname === "/run") {
+		const topic = url.searchParams.get("topic");
+		if (!topic) {
+			res.writeHead(400);
+			res.end("Missing topic");
+			return;
+		}
+
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+		});
+
+		const send = (data: Record<string, unknown>) => {
+			res.write(`data: ${JSON.stringify(data)}\n\n`);
+		};
+
+		const results = await runAgents(topic, send);
+
+		const synthesizer = new Agent(createAgentConfig());
+		synthesizer.subscribe((event) => {
+			if (event.type === "assistant-text-delta") {
+				send({ type: "synthesis-delta", text: event.text });
+			}
+		});
+
+		const findings = results
+			.map((r) => `## ${r.role}\n${r.output}`)
+			.join("\n\n");
+
+		await synthesizer.run(
+			`You are a synthesizer for a developer-console demo. Four specialists analyzed a mission. Produce a compact decision brief with a clear recommendation, confidence level, top risks, and immediate next steps. Use plain text with short labels, no markdown headings. Do not repeat their analyses verbatim; extract the key insights and make the result feel like a war-room verdict.\n\nMission: ${topic}\n\n${findings}`,
+		);
+
+		send({ type: "done" });
+		res.end();
+		return;
+	}
+
+	res.writeHead(404);
+	res.end("Not found");
+});
+
+interface AgentResult {
+	role: string;
+	output: string;
+	status: string;
+}
+
+async function runAgents(
+	topic: string,
+	send: (data: Record<string, unknown>) => void,
+): Promise<AgentResult[]> {
+	const promises = AGENT_ROLES.map(async (spec) => {
+		const agent = new Agent(createAgentConfig());
+
+		send({ type: "agent-start", agentId: spec.id, role: spec.role });
+
+		agent.subscribe((event) => {
+			if (event.type === "assistant-text-delta") {
+				send({ type: "agent-delta", agentId: spec.id, text: event.text });
+			}
+		});
+
+		const result = await agent.run(spec.prompt(topic));
+
+		send({
+			type: "agent-done",
+			agentId: spec.id,
+			status: result.status,
+		});
+
+		return {
+			role: spec.role,
+			output: result.outputText,
+			status: result.status,
+		};
+	});
+
+	return Promise.all(promises);
+}
+
+server.listen(PORT, () => {
+	console.log(`Multi-agent server running at http://localhost:${PORT}`);
+});
diff --git a/apps/examples/multi-agent/tsconfig.json b/apps/examples/multi-agent/tsconfig.json
new file mode 100644
index 0000000..9c69339
--- /dev/null
+++ b/apps/examples/multi-agent/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"outDir": "dist",
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true
+	},
+	"include": ["src"]
+}
diff --git a/apps/examples/quickstart/README.md b/apps/examples/quickstart/README.md
new file mode 100644
index 0000000..7beea90
--- /dev/null
+++ b/apps/examples/quickstart/README.md
@@ -0,0 +1,37 @@
+# Quickstart
+
+The simplest possible Cline SDK example. Creates one agent, sends a single prompt, and streams the response to stdout.
+
+## Getting started
+
+Use Node.js 22 or newer.
+
+Install dependencies:
+
+```bash
+bun install
+bun run build:sdk
+```
+
+Set an API key:
+
+```bash
+export CLINE_API_KEY="cline_..."
+```
+
+Run:
+
+```bash
+bun dev
+```
+
+## What it does
+
+1. Creates an `Agent` with a provider and model
+2. Subscribes to `assistant-text-delta` events to stream output
+3. Calls `agent.run()` with a prompt
+4. Prints token usage when done
+
+## Notes
+
+For an interactive terminal chat, see [cli-agent](../cli-agent). For custom tools and structured workflows, see [code-review-bot](../code-review-bot).
diff --git a/apps/examples/quickstart/package.json b/apps/examples/quickstart/package.json
new file mode 100644
index 0000000..630672c
--- /dev/null
+++ b/apps/examples/quickstart/package.json
@@ -0,0 +1,21 @@
+{
+	"name": "@cline/example-quickstart",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"build:sdk": "bun run --cwd ../../.. build:sdk",
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@cline/sdk": "workspace:*"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}
diff --git a/apps/examples/quickstart/src/index.ts b/apps/examples/quickstart/src/index.ts
new file mode 100644
index 0000000..5316f2d
--- /dev/null
+++ b/apps/examples/quickstart/src/index.ts
@@ -0,0 +1,19 @@
+import { Agent } from "@cline/sdk";
+
+const agent = new Agent({
+	providerId: "cline",
+	modelId: "anthropic/claude-sonnet-4.6",
+	apiKey: process.env.CLINE_API_KEY,
+	maxIterations: 1,
+});
+
+agent.subscribe((event) => {
+	if (event.type === "assistant-text-delta") {
+		process.stdout.write(event.text);
+	}
+});
+
+const result = await agent.run("Explain what an SDK is in two sentences.");
+console.log(
+	`\n\nDone (${result.iterations} iteration, ${result.usage.outputTokens} output tokens)`,
+);
diff --git a/apps/examples/quickstart/tsconfig.json b/apps/examples/quickstart/tsconfig.json
new file mode 100644
index 0000000..9c69339
--- /dev/null
+++ b/apps/examples/quickstart/tsconfig.json
@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"outDir": "dist",
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true
+	},
+	"include": ["src"]
+}
diff --git a/apps/examples/vscode/.vscode/launch.json b/apps/examples/vscode/.vscode/launch.json
new file mode 100644
index 0000000..8833696
--- /dev/null
+++ b/apps/examples/vscode/.vscode/launch.json
@@ -0,0 +1,29 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Run Extension",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}",
+				"--disable-extensions"
+			],
+			"preLaunchTask": "build-extension"
+		},
+		{
+			"name": "Run Extension (Dev Webview)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}",
+				"--disable-extensions"
+			],
+			"env": {
+				"VITE_DEV_SERVER_URL": "http://localhost:5173"
+			},
+			"preLaunchTask": "dev-all",
+			"postDebugTask": "kill-dev"
+		}
+	]
+}
diff --git a/apps/examples/vscode/.vscode/tasks.json b/apps/examples/vscode/.vscode/tasks.json
new file mode 100644
index 0000000..2eba1e3
--- /dev/null
+++ b/apps/examples/vscode/.vscode/tasks.json
@@ -0,0 +1,77 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "build-extension",
+			"type": "shell",
+			"command": "bun run build",
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"problemMatcher": ["$tsc"],
+			"options": {
+				"cwd": "${workspaceFolder}"
+			}
+		},
+		{
+			"label": "watch-extension",
+			"type": "shell",
+			"command": "bun run watch",
+			"isBackground": true,
+			"problemMatcher": {
+				"pattern": {
+					"regexp": "^.*$",
+					"file": 0,
+					"location": 0,
+					"message": 0
+				},
+				"background": {
+					"activeOnStart": true,
+					"beginsPattern": "^Bundled",
+					"endsPattern": "^\\s*extension\\.js"
+				}
+			},
+			"options": {
+				"cwd": "${workspaceFolder}"
+			}
+		},
+		{
+			"label": "dev-webview",
+			"type": "shell",
+			"command": "cd src/webview && bun run dev",
+			"isBackground": true,
+			"problemMatcher": {
+				"pattern": {
+					"regexp": "^.*$",
+					"file": 0,
+					"location": 0,
+					"message": 0
+				},
+				"background": {
+					"activeOnStart": true,
+					"beginsPattern": "VITE",
+					"endsPattern": "Local:"
+				}
+			},
+			"options": {
+				"cwd": "${workspaceFolder}"
+			}
+		},
+		{
+			"label": "dev-all",
+			"dependsOn": ["watch-extension", "dev-webview"],
+			"dependsOrder": "parallel",
+			"problemMatcher": []
+		},
+		{
+			"label": "kill-dev",
+			"type": "shell",
+			"command": "kill $(lsof -ti:5173) 2>/dev/null; exit 0",
+			"problemMatcher": [],
+			"presentation": {
+				"reveal": "silent"
+			}
+		}
+	]
+}
diff --git a/apps/examples/vscode/README.md b/apps/examples/vscode/README.md
new file mode 100644
index 0000000..774d3fe
--- /dev/null
+++ b/apps/examples/vscode/README.md
@@ -0,0 +1,32 @@
+# `apps/examples/vscode` (`@cline/vscode`)
+
+VS Code extension that opens a chat webview and runs Cline sessions over the RPC runtime.
+
+## What it does
+
+- Opens a webview panel via `Cline: Open Chat in Editor`.
+- Ensures a compatible owner-scoped RPC sidecar by running `cline rpc ensure --json`.
+- Starts/sends/aborts chat turns using RPC runtime methods (`StartRuntimeSession`, `SendRuntimeSession`, `AbortRuntimeSession`).
+- Streams runtime events into the webview for incremental assistant output.
+
+## Requirements
+
+- `cline` must already be installed and available on `PATH`.
+- A provider/model should be configured in Cline provider settings.
+
+## Development
+
+```bash
+# Build extension bundle
+bun -F @cline/vscode build
+
+# Typecheck
+bun -F @cline/vscode typecheck
+```
+
+To run locally in VS Code:
+
+1. Build the extension: `bun -F @cline/vscode build`.
+2. Open `apps/examples/vscode` in VS Code.
+3. Press `F5` to launch the Extension Development Host.
+4. Run command `Cline: Open Chat in Editor`.
diff --git a/apps/examples/vscode/package.json b/apps/examples/vscode/package.json
new file mode 100644
index 0000000..79ba79b
--- /dev/null
+++ b/apps/examples/vscode/package.json
@@ -0,0 +1,64 @@
+{
+	"name": "@cline/vscode",
+	"displayName": "Cline Chat",
+	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way. Backed by the Cline CLI runtime.",
+	"version": "0.0.0",
+	"private": true,
+	"publisher": "cline",
+	"icon": "src/webview/public/icon.png",
+	"license": "Apache-2.0",
+	"engines": {
+		"vscode": "^1.90.0"
+	},
+	"categories": [
+		"Other"
+	],
+	"main": "./dist/extension.js",
+	"contributes": {
+		"commands": [
+			{
+				"command": "clineVscode.openChat",
+				"title": "Cline: Open Chat in Editor"
+			}
+		],
+		"viewsContainers": {
+			"activitybar": [
+				{
+					"id": "cline",
+					"title": "Cline",
+					"icon": "src/webview/public/icon.svg"
+				}
+			]
+		},
+		"views": {
+			"cline": [
+				{
+					"type": "webview",
+					"id": "clineVscode.chatView",
+					"name": "Chat",
+					"icon": "src/webview/public/icon.svg"
+				}
+			]
+		}
+	},
+	"scripts": {
+		"build:webview": "cd ./src/webview && bun run build",
+		"build": "bun run build:webview && bun build ./src/extension.ts ./src/hub-daemon.ts --outdir ./dist --target=node --format=cjs --external=vscode --minify",
+		"watch": "bun build ./src/extension.ts ./src/hub-daemon.ts --outdir ./dist --target=node --format=cjs --external=vscode --minify --watch",
+		"typecheck": "tsc --noEmit",
+		"dev": "bun run watch"
+	},
+	"dependencies": {
+		"@ai-sdk/react": "^3.0.118",
+		"@cline/core": "workspace:*",
+		"@cline/llms": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"ai": "^6.0.116"
+	},
+	"devDependencies": {
+		"@types/node": "^25.3.5",
+		"@types/vscode": "^1.90.0",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.18"
+	}
+}
diff --git a/apps/examples/vscode/src/extension.ts b/apps/examples/vscode/src/extension.ts
new file mode 100644
index 0000000..792be5c
--- /dev/null
+++ b/apps/examples/vscode/src/extension.ts
@@ -0,0 +1,1615 @@
+import * as os from "node:os";
+import { basename, join } from "node:path";
+import {
+	type BasicLogger,
+	buildWorkspaceMetadata,
+	ClineCore,
+	captureExtensionActivated,
+	createConfiguredTelemetryService,
+	createLocalHubScheduleRuntimeHandlers,
+	ensureHubWebSocketServer,
+	type ITelemetryService,
+	Llms,
+	NodeHubClient,
+	type ProviderModel,
+	ProviderSettingsManager,
+	probeHubServer,
+	type RuntimeCapabilities,
+	readHubDiscovery,
+	rememberRecoverableLocalHubUrl,
+	resolveSharedHubOwnerContext,
+	type ToolPolicy,
+} from "@cline/core";
+import {
+	type AgentTool,
+	buildClineSystemPrompt,
+	createClineTelemetryServiceConfig,
+	createClineTelemetryServiceMetadata,
+} from "@cline/shared";
+import * as vscode from "vscode";
+import { displayName, version } from "../package.json";
+import { createVsCodeRuntimeCapabilities } from "./runtime-capabilities";
+import { createVscodeTelemetry } from "./telemetry";
+import type {
+	WebviewChatMessage,
+	WebviewInboundMessage,
+	WebviewOutboundMessage,
+	WebviewSessionSummary,
+} from "./webview-protocol";
+
+const SESSION_REFRESH_INTERVAL_MS = 4_000;
+const SESSION_HISTORY_LIMIT = 50;
+const HUB_DAEMON_TIMEOUT_MS = 8_000;
+const HUB_POLL_INTERVAL_MS = 200;
+const TERMINAL_SHELL_INTEGRATION_TIMEOUT_MS = 5_000;
+const TERMINAL_EXECUTION_TIMEOUT_MS = 120_000;
+const TERMINAL_OUTPUT_LIMIT = 1_000_000;
+const REFRESH_SESSION_EVENTS = new Set([
+	"session.created",
+	"session.updated",
+	"session.attached",
+	"session.detached",
+	"run.started",
+	"run.completed",
+	"run.failed",
+	"run.aborted",
+]);
+
+let extensionTelemetryHandle:
+	| ReturnType<typeof createVscodeTelemetry>
+	| undefined;
+
+export function activate(context: vscode.ExtensionContext): void {
+	const outputChannel = vscode.window.createOutputChannel("Cline");
+	extensionTelemetryHandle = createVscodeTelemetry({
+		extensionVersion: version,
+		clineType: displayName,
+		platform: vscode.env.appName,
+		platformVersion: vscode.version,
+	});
+	captureExtensionActivated(extensionTelemetryHandle.telemetry);
+	const sidebarProvider = new ClineChatViewProvider(
+		context.extensionUri,
+		outputChannel,
+		extensionTelemetryHandle.telemetry,
+	);
+	context.subscriptions.push(
+		outputChannel,
+		vscode.window.registerWebviewViewProvider(
+			"clineVscode.chatView",
+			sidebarProvider,
+			{ webviewOptions: { retainContextWhenHidden: true } },
+		),
+		vscode.commands.registerCommand("clineVscode.openChat", () => {
+			const panel = vscode.window.createWebviewPanel(
+				"clineChat",
+				"Cline Chat",
+				vscode.ViewColumn.One,
+				{
+					enableScripts: true,
+					retainContextWhenHidden: true,
+					localResourceRoots: [
+						vscode.Uri.joinPath(context.extensionUri, "dist", "webview"),
+					],
+				},
+			);
+			const controller = new CoreChatWebviewController(
+				panel.webview,
+				context.extensionUri,
+				outputChannel,
+				panel.onDidDispose,
+				extensionTelemetryHandle?.telemetry,
+			);
+			context.subscriptions.push(controller);
+		}),
+	);
+}
+
+export function deactivate(): Promise<void> {
+	const handle = extensionTelemetryHandle;
+	extensionTelemetryHandle = undefined;
+	if (!handle) return Promise.resolve();
+	return handle.flush().finally(() => handle.dispose());
+}
+
+class ClineChatViewProvider implements vscode.WebviewViewProvider {
+	constructor(
+		private readonly extensionUri: vscode.Uri,
+		private readonly outputChannel: vscode.OutputChannel,
+		private readonly sharedTelemetry?: ITelemetryService,
+	) {}
+
+	public resolveWebviewView(webviewView: vscode.WebviewView): void {
+		webviewView.webview.options = {
+			enableScripts: true,
+			localResourceRoots: [
+				vscode.Uri.joinPath(this.extensionUri, "dist", "webview"),
+			],
+		};
+		const controller = new CoreChatWebviewController(
+			webviewView.webview,
+			this.extensionUri,
+			this.outputChannel,
+			webviewView.onDidDispose,
+			this.sharedTelemetry,
+		);
+		webviewView.onDidDispose(() => controller.dispose());
+	}
+}
+
+type StartConfig = {
+	providerId: string;
+	modelId: string;
+	cwd: string;
+	workspaceRoot: string;
+	systemPrompt: string;
+	maxIterations?: number;
+	thinking?: boolean;
+	enableTools: boolean;
+	enableSpawnAgent: boolean;
+	enableAgentTeams: boolean;
+	teamName: string;
+	missionLogIntervalSteps: number;
+	missionLogIntervalMs: number;
+	checkpoint: { enabled: true };
+	mode: "act" | "plan";
+	apiKey: string;
+	autoApproveTools?: boolean;
+	logger: BasicLogger;
+	extensionContext?: import("@cline/shared").ExtensionContext;
+	extraTools?: AgentTool[];
+};
+
+type ProviderListItem = {
+	id: string;
+	name: string;
+	enabled: boolean;
+	defaultModelId?: string;
+};
+
+type HubEventEnvelope = {
+	event: string;
+	sessionId?: string;
+	payload?: Record<string, unknown>;
+};
+
+type HubResolution = {
+	url: string;
+	authToken?: string;
+};
+
+type LlmModelInfo = {
+	name?: string;
+	capabilities?: string[];
+	thinkingConfig?: unknown;
+};
+
+type WebviewSendConfig = {
+	provider?: string;
+	model?: string;
+	mode?: "act" | "plan";
+	systemPrompt?: string;
+	maxIterations?: number;
+	thinking?: boolean;
+	enableTools?: boolean;
+	enableSpawn?: boolean;
+	enableTeams?: boolean;
+	autoApproveTools?: boolean;
+};
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function stringifyContent(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+
+function parseSessionTimestamp(value: unknown): number | undefined {
+	const timestamp =
+		typeof value === "number"
+			? value
+			: typeof value === "string"
+				? Date.parse(value)
+				: Number.NaN;
+	return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+
+function wait(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readTerminalCommandInput(input: unknown): {
+	command: string;
+	cwd?: string;
+} {
+	if (typeof input === "string") {
+		return { command: input.trim() };
+	}
+	const record = asRecord(input);
+	const command =
+		typeof record?.command === "string" ? record.command.trim() : "";
+	const cwd = typeof record?.cwd === "string" ? record.cwd.trim() : "";
+	return {
+		command,
+		...(cwd ? { cwd } : {}),
+	};
+}
+
+async function waitForShellIntegration(
+	terminal: vscode.Terminal,
+	timeoutMs: number,
+): Promise<vscode.TerminalShellIntegration | undefined> {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < timeoutMs) {
+		if (terminal.shellIntegration) {
+			return terminal.shellIntegration;
+		}
+		await wait(100);
+	}
+	return terminal.shellIntegration;
+}
+
+async function readTerminalExecution(
+	execution: vscode.TerminalShellExecution,
+	abortSignal: AbortSignal | undefined,
+	onChange: ((update: unknown) => void) | undefined,
+): Promise<string> {
+	let output = "";
+	let outputSize = 0;
+	const timeout = AbortSignal.timeout(TERMINAL_EXECUTION_TIMEOUT_MS);
+	const abortPromise = new Promise<never>((_, reject) => {
+		const onAbort = () => reject(new Error("Command was aborted"));
+		const onTimeout = () =>
+			reject(
+				new Error(`Command timed out after ${TERMINAL_EXECUTION_TIMEOUT_MS}ms`),
+			);
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+		timeout.addEventListener("abort", onTimeout, { once: true });
+	});
+	const readPromise = (async () => {
+		for await (const chunk of execution.read()) {
+			onChange?.({ stream: "stdout", chunk });
+			outputSize += chunk.length;
+			if (output.length < TERMINAL_OUTPUT_LIMIT) {
+				output += chunk.slice(0, TERMINAL_OUTPUT_LIMIT - output.length);
+			}
+		}
+		if (outputSize > TERMINAL_OUTPUT_LIMIT) {
+			output += `\n\n[Output truncated: ${outputSize} characters total, showing first ${TERMINAL_OUTPUT_LIMIT} characters]`;
+		}
+		return output;
+	})();
+	return Promise.race([readPromise, abortPromise]);
+}
+
+function createVsCodeTerminalTool(defaultCwd: string): AgentTool {
+	return {
+		name: "vscode_terminal",
+		description:
+			"Run a shell command in the VS Code integrated terminal and return the captured terminal output when shell integration is available.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					description: "The shell command to run in the integrated terminal.",
+				},
+				cwd: {
+					type: "string",
+					description:
+						"Optional working directory. Defaults to the active workspace directory.",
+				},
+			},
+			required: ["command"],
+		},
+		async execute(input, context) {
+			const { command, cwd } = readTerminalCommandInput(input);
+			if (!command) {
+				throw new Error("command is required.");
+			}
+			const terminal = vscode.window.createTerminal({
+				name: "Cline",
+				cwd: cwd || defaultCwd,
+			});
+			terminal.show(true);
+			context.emitUpdate?.({ stream: "stdout", chunk: `$ ${command}\n` });
+
+			const shellIntegration = await waitForShellIntegration(
+				terminal,
+				TERMINAL_SHELL_INTEGRATION_TIMEOUT_MS,
+			);
+			if (!shellIntegration) {
+				terminal.sendText(command, true);
+				return [
+					"Command sent to the VS Code integrated terminal.",
+					"Shell integration was not available, so output could not be captured.",
+				].join("\n");
+			}
+
+			const execution = shellIntegration.executeCommand(command);
+			const output = await readTerminalExecution(
+				execution,
+				context.signal,
+				context.emitUpdate,
+			);
+			return output.trim() || "Command completed with no output.";
+		},
+	};
+}
+
+function readCheckpointEntriesByRunCount(
+	value: unknown,
+): Map<number, NonNullable<WebviewChatMessage["checkpoint"]>> {
+	const entries = new Map<
+		number,
+		NonNullable<WebviewChatMessage["checkpoint"]>
+	>();
+	const history = asRecord(value)?.history;
+	if (!Array.isArray(history)) return entries;
+
+	for (const item of history) {
+		const entry = asRecord(item);
+		if (!entry) continue;
+		const { ref, createdAt, runCount, kind } = entry;
+		if (
+			typeof ref !== "string" ||
+			typeof createdAt !== "number" ||
+			!Number.isFinite(createdAt) ||
+			typeof runCount !== "number" ||
+			!Number.isInteger(runCount) ||
+			runCount < 1
+		) {
+			continue;
+		}
+		const validKind = kind === "stash" || kind === "commit" ? kind : undefined;
+		entries.set(runCount, {
+			ref,
+			createdAt,
+			runCount,
+			...(validKind ? { kind: validKind } : {}),
+		});
+	}
+	return entries;
+}
+
+type PersistedMessage = {
+	id?: string;
+	role?: string;
+	content?:
+		| string
+		| Array<
+				| { type: "text"; text: string }
+				| { type: "reasoning"; text: string; redacted?: boolean }
+				| {
+						type: "tool-call";
+						toolCallId: string;
+						toolName: string;
+						input?: unknown;
+				  }
+				| {
+						type: "tool-result";
+						toolCallId: string;
+						toolName: string;
+						output?: unknown;
+						isError?: boolean;
+				  }
+		  >;
+};
+
+function mapPersistedMessagesToWebviewMessages(
+	messages: PersistedMessage[],
+	checkpointMetadata?: unknown,
+): WebviewChatMessage[] {
+	const checkpointsByRunCount =
+		readCheckpointEntriesByRunCount(checkpointMetadata);
+	let userRunCount = 0;
+
+	return messages.flatMap((message, messageIndex) => {
+		const messageKey = message.id ?? messageIndex;
+		const textParts: string[] = [];
+		const reasoningParts: string[] = [];
+		let reasoningRedacted = false;
+		const blocks: NonNullable<WebviewChatMessage["blocks"]> = [];
+		const toolEvents = new Map<
+			string,
+			NonNullable<WebviewChatMessage["toolEvents"]>[number]
+		>();
+
+		const parts = Array.isArray(message.content)
+			? message.content
+			: typeof message.content === "string" && message.content.trim()
+				? [{ type: "text" as const, text: message.content.trim() }]
+				: [];
+
+		for (const [partIndex, part] of parts.entries()) {
+			switch (part.type) {
+				case "text": {
+					const text = part.text.trim();
+					if (!text) break;
+					textParts.push(text);
+					blocks.push({
+						id: `${messageKey}:text:${partIndex}`,
+						type: "text",
+						text,
+					});
+					break;
+				}
+				case "reasoning": {
+					if (!part.text.trim()) break;
+					reasoningParts.push(part.text);
+					blocks.push({
+						id: `${messageKey}:reasoning:${partIndex}`,
+						type: "reasoning",
+						text: part.text,
+						redacted: part.redacted,
+					});
+					reasoningRedacted = reasoningRedacted || part.redacted === true;
+					break;
+				}
+				case "tool-call": {
+					const toolEvent = {
+						id: `${messageKey}:${part.toolCallId}`,
+						toolCallId: part.toolCallId,
+						name: part.toolName,
+						text: `Running ${part.toolName}...`,
+						state: "input-available" as const,
+						input: part.input,
+					};
+					toolEvents.set(part.toolCallId, toolEvent);
+					blocks.push({
+						id: `${messageKey}:tool:${part.toolCallId}`,
+						type: "tool",
+						toolEvent,
+					});
+					break;
+				}
+				case "tool-result": {
+					const existing = toolEvents.get(part.toolCallId);
+					const toolEvent = {
+						id: existing?.id ?? `${messageKey}:${part.toolCallId}`,
+						toolCallId: part.toolCallId,
+						name: part.toolName,
+						text: part.isError
+							? `${part.toolName} failed`
+							: `${part.toolName} completed`,
+						state: part.isError
+							? ("output-error" as const)
+							: ("output-available" as const),
+						input: existing?.input,
+						output: part.output,
+						error: part.isError ? stringifyContent(part.output) : undefined,
+					};
+					toolEvents.set(part.toolCallId, toolEvent);
+					const blockId = `${messageKey}:tool:${part.toolCallId}`;
+					const existingBlockIndex = blocks.findIndex(
+						(block) =>
+							block.type === "tool" &&
+							block.toolEvent.toolCallId === part.toolCallId,
+					);
+					if (existingBlockIndex >= 0) {
+						blocks[existingBlockIndex] = {
+							id: blockId,
+							type: "tool",
+							toolEvent,
+						};
+					} else {
+						blocks.push({ id: blockId, type: "tool", toolEvent });
+					}
+					break;
+				}
+			}
+		}
+
+		const text = textParts.join("\n");
+		const toolEventList = [...toolEvents.values()];
+		if (!text && reasoningParts.length === 0 && toolEventList.length === 0) {
+			return [];
+		}
+		const role =
+			message.role === "user"
+				? "user"
+				: message.role === "assistant"
+					? "assistant"
+					: "meta";
+		const checkpoint =
+			role === "user" ? checkpointsByRunCount.get(++userRunCount) : undefined;
+
+		return [
+			{
+				id: message.id || `history-${messageIndex}`,
+				role,
+				text,
+				reasoning:
+					reasoningParts.length > 0 ? reasoningParts.join("\n") : undefined,
+				reasoningRedacted: reasoningRedacted || undefined,
+				checkpoint,
+				toolEvents: toolEventList.length > 0 ? toolEventList : undefined,
+				blocks: blocks.length > 0 ? blocks : undefined,
+			},
+		];
+	});
+}
+
+class CoreChatWebviewController implements vscode.Disposable {
+	private readonly logger: BasicLogger;
+	private readonly disposables: vscode.Disposable[] = [];
+	private readonly providerSettingsManager = new ProviderSettingsManager();
+	private readonly telemetry: ITelemetryService;
+	private host: ClineCore | undefined;
+	private hubClient: NodeHubClient | undefined;
+	private stopHostSubscription: (() => void) | undefined;
+	private stopSessionRefreshInterval: (() => void) | undefined;
+	private stopSessionSubscription: (() => void) | undefined;
+	private sessionId: string | undefined;
+	private startConfig: StartConfig | undefined;
+	private hubUrl: string | undefined;
+	private hubAuthToken: string | undefined;
+	private sending = false;
+
+	constructor(
+		private readonly webview: vscode.Webview,
+		private readonly extensionUri: vscode.Uri,
+		outputChannel: vscode.OutputChannel,
+		onDidDispose?: vscode.Event<void>,
+		sharedTelemetry?: ITelemetryService,
+	) {
+		this.logger = createOutputChannelLogger(outputChannel);
+		this.disposables.push(
+			this.webview.onDidReceiveMessage((message: WebviewInboundMessage) => {
+				void this.handleMessage(message);
+			}),
+		);
+		if (onDidDispose) {
+			this.disposables.push(onDidDispose(() => this.dispose()));
+		}
+
+		if (sharedTelemetry) {
+			this.telemetry = sharedTelemetry;
+		} else {
+			const { telemetry } = createConfiguredTelemetryService(
+				createClineTelemetryServiceConfig({
+					metadata: createClineTelemetryServiceMetadata({
+						extension_version: version,
+						cline_type: displayName,
+						platform: vscode.env.appName,
+						platform_version: vscode.version,
+						os_type: os.platform(),
+						os_version: os.version(),
+					}),
+				}),
+			);
+			this.telemetry = telemetry;
+		}
+
+		void this.initializeWebview();
+	}
+
+	public dispose(): void {
+		this.stopEventStream();
+		this.stopSessionRefreshInterval?.();
+		this.stopSessionRefreshInterval = undefined;
+		this.stopHostSubscription?.();
+		this.stopHostSubscription = undefined;
+		this.hubClient?.close();
+		this.hubClient = undefined;
+		if (this.sessionId && this.host) {
+			void this.host.stop(this.sessionId).catch(() => undefined);
+		}
+		void this.host?.dispose("vscode_webview_dispose").catch(() => undefined);
+		this.host = undefined;
+		this.sessionId = undefined;
+		this.startConfig = undefined;
+		while (this.disposables.length > 0) {
+			this.disposables.pop()?.dispose();
+		}
+	}
+
+	private async handleMessage(message: WebviewInboundMessage): Promise<void> {
+		switch (message.type) {
+			case "ready":
+				return this.initialize();
+			case "loadModels":
+				return this.loadModels(message.providerId);
+			case "attachSession":
+				return this.attachSession(message.sessionId);
+			case "deleteSession":
+				return this.deleteSession(message.sessionId);
+			case "updateSessionMetadata":
+				return this.updateSessionMetadata(message.sessionId, message.metadata);
+			case "abort":
+				return this.abortTurn();
+			case "reset":
+				return this.resetSession();
+			case "forkSession":
+				return this.forkSession();
+			case "restore":
+				return this.restore(message.checkpointRunCount);
+			case "send":
+				return this.sendPrompt(
+					message.prompt,
+					message.config,
+					message.attachments,
+				);
+		}
+	}
+
+	private async initialize(): Promise<void> {
+		try {
+			await this.ensureHub();
+			await this.getSessionHost();
+			await this.post({ type: "status", text: "Cline is Ready" });
+			const defaults = this.resolveWorkspaceDefaults();
+			await this.post({ type: "defaults", defaults });
+			await this.loadProviders(defaults.provider);
+			await this.refreshSessions();
+			if (!this.stopSessionRefreshInterval) {
+				const interval = setInterval(() => {
+					void this.refreshSessions().catch(() => undefined);
+				}, SESSION_REFRESH_INTERVAL_MS);
+				this.stopSessionRefreshInterval = () => clearInterval(interval);
+			}
+		} catch (error) {
+			await this.postError(error);
+		}
+	}
+
+	private async ensureHub(): Promise<void> {
+		if (this.hubClient && this.hubUrl) {
+			try {
+				await this.hubClient.connect();
+				return;
+			} catch {
+				this.hubClient.close();
+				this.hubClient = undefined;
+				this.hubUrl = undefined;
+				this.hubAuthToken = undefined;
+			}
+		}
+
+		const hub = await this.discoverOrStartHub();
+		if (!hub) {
+			throw new Error("No compatible hub runtime is available.");
+		}
+		this.hubUrl = hub.url;
+		this.hubAuthToken = hub.authToken;
+
+		const defaults = this.resolveWorkspaceDefaults();
+		this.hubClient = new NodeHubClient({
+			url: this.hubUrl,
+			authToken: this.hubAuthToken,
+			clientType: "vscode",
+			displayName: "VS Code",
+			workspaceRoot: defaults.workspaceRoot,
+			cwd: defaults.cwd,
+		});
+		await this.hubClient.connect();
+		this.hubClient.subscribe((event) => {
+			void this.handleHubEvent(event as HubEventEnvelope);
+		});
+	}
+
+	private async discoverOrStartHub(): Promise<HubResolution | undefined> {
+		const owner = resolveSharedHubOwnerContext();
+
+		if (this.hubUrl) {
+			const healthy = await probeHubServer(this.hubUrl, {
+				authToken: this.hubAuthToken,
+			});
+			if (healthy?.url) {
+				return {
+					url: rememberRecoverableLocalHubUrl(healthy.url, this.hubAuthToken),
+					authToken: this.hubAuthToken,
+				};
+			}
+		}
+
+		const discovered = await this.probeDiscoveredHub(owner.discoveryPath);
+		if (discovered) return discovered;
+
+		await ensureHubWebSocketServer({
+			owner,
+			allowPortFallback: true,
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+
+		const deadline = Date.now() + HUB_DAEMON_TIMEOUT_MS;
+		while (Date.now() < deadline) {
+			const next = await this.probeDiscoveredHub(owner.discoveryPath);
+			if (next) return next;
+			await new Promise((resolve) => setTimeout(resolve, HUB_POLL_INTERVAL_MS));
+		}
+		return undefined;
+	}
+
+	private async probeDiscoveredHub(
+		discoveryPath: string,
+	): Promise<HubResolution | undefined> {
+		const discovery = await readHubDiscovery(discoveryPath);
+		if (!discovery?.url) return undefined;
+		const healthy = await probeHubServer(discovery.url, {
+			authToken: discovery.authToken,
+		});
+		return healthy?.url
+			? {
+					url: rememberRecoverableLocalHubUrl(healthy.url, discovery.authToken),
+					authToken: discovery.authToken,
+				}
+			: undefined;
+	}
+
+	private async initializeWebview(): Promise<void> {
+		try {
+			this.webview.html = await this.getWebviewHtml();
+		} catch (error) {
+			await this.postError(error);
+		}
+	}
+
+	private async getWebviewHtml(): Promise<string> {
+		const devServerUrl = process.env.VITE_DEV_SERVER_URL;
+		return devServerUrl
+			? this.getDevWebviewHtml(devServerUrl)
+			: this.getProductionWebviewHtml();
+	}
+
+	private getDevWebviewHtml(devServerUrl: string): string {
+		const url = new URL(devServerUrl);
+		const csp = [
+			"default-src 'none'",
+			`img-src ${this.webview.cspSource} data: ${devServerUrl}`,
+			`style-src ${this.webview.cspSource} 'unsafe-inline' ${devServerUrl}`,
+			`font-src ${this.webview.cspSource} ${devServerUrl}`,
+			`script-src 'unsafe-inline' ${devServerUrl}`,
+			`connect-src ${devServerUrl} ws://${url.host} ws://localhost:${url.port}`,
+		].join("; ");
+
+		return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta http-equiv="Content-Security-Policy" content="${csp}" />
+	<script type="module">
+		import RefreshRuntime from "${devServerUrl}/@react-refresh";
+		RefreshRuntime.injectIntoGlobalHook(window);
+		window.$RefreshReg$ = () => {};
+		window.$RefreshSig$ = () => (type) => type;
+		window.__vite_plugin_react_preamble_installed__ = true;
+	</script>
+	<script type="module" src="${devServerUrl}/@vite/client"></script>
+</head>
+<body>
+	<div id="root"></div>
+	<script type="module" src="${devServerUrl}/src/main.tsx"></script>
+</body>
+</html>`;
+	}
+
+	private async getProductionWebviewHtml(): Promise<string> {
+		const distDir = vscode.Uri.joinPath(this.extensionUri, "dist", "webview");
+		const indexPath = join(distDir.fsPath, "index.html");
+		const nonce = createNonce();
+		const buffer = await vscode.workspace.fs.readFile(
+			vscode.Uri.file(indexPath),
+		);
+
+		let html = Buffer.from(buffer)
+			.toString("utf8")
+			.replace(
+				/<(script|link)([^>]+?(?:src|href))="([^"]+)"([^>]*)>/g,
+				(_match, tag, attrPrefix, assetPath, suffix) => {
+					if (/^(?:https?:|data:)/.test(assetPath)) {
+						return `<${tag}${attrPrefix}="${assetPath}"${suffix}>`;
+					}
+					const normalizedAssetPath = assetPath.replace(/^\.?\//, "");
+					const assetUri = this.webview.asWebviewUri(
+						vscode.Uri.joinPath(distDir, normalizedAssetPath),
+					);
+					const nonceAttr = tag === "script" ? ` nonce="${nonce}"` : "";
+					return `<${tag}${nonceAttr}${attrPrefix}="${assetUri.toString()}"${suffix}>`;
+				},
+			);
+
+		const csp = [
+			"default-src 'none'",
+			`img-src ${this.webview.cspSource} data:`,
+			`style-src ${this.webview.cspSource} 'unsafe-inline'`,
+			`font-src ${this.webview.cspSource}`,
+			`script-src ${this.webview.cspSource} 'nonce-${nonce}'`,
+		].join("; ");
+
+		if (html.includes("<head>")) {
+			html = html.replace(
+				"<head>",
+				`<head>\n<meta http-equiv="Content-Security-Policy" content="${csp}" />`,
+			);
+		}
+		return html;
+	}
+
+	private resolveWorkspaceDefaults(): {
+		provider?: string;
+		model?: string;
+		workspaceRoot: string;
+		cwd: string;
+	} {
+		const folder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+		const cwd = folder ?? process.cwd();
+		const lastUsed = this.providerSettingsManager.getLastUsedProviderSettings();
+		return {
+			provider: lastUsed?.provider,
+			model: lastUsed?.model,
+			workspaceRoot: cwd,
+			cwd,
+		};
+	}
+
+	private async loadProviders(preferredProvider?: string): Promise<void> {
+		const state = this.providerSettingsManager.read();
+		const ids = Llms.getProviderIds().sort((a, b) => a.localeCompare(b));
+		const providers: ProviderListItem[] = (
+			await Promise.all(
+				ids.map(async (id) => {
+					const info = await Llms.getProvider(id);
+					return {
+						id,
+						name: info?.name ?? id,
+						enabled: Boolean(state.providers[id]?.settings),
+						defaultModelId: info?.defaultModelId,
+					};
+				}),
+			)
+		).filter((p) => p.enabled);
+		await this.post({ type: "providers", providers });
+
+		const selected =
+			(preferredProvider &&
+				providers.find((p) => p.id === preferredProvider)) ||
+			providers[0];
+		if (selected) {
+			await this.loadModels(selected.id);
+		}
+	}
+
+	private async loadModels(providerId: string): Promise<void> {
+		const provider = providerId.trim();
+		if (!provider) return;
+		const modelMap = (await Llms.getModelsForProvider(provider)) as Record<
+			string,
+			LlmModelInfo
+		>;
+		const models: ProviderModel[] = Object.entries(modelMap)
+			.sort(([a], [b]) => a.localeCompare(b))
+			.map(([modelId, info]) => ({
+				id: modelId,
+				name: info.name ?? modelId,
+				supportsAttachments: info.capabilities?.includes("files"),
+				supportsThinking:
+					Boolean(info.thinkingConfig) ||
+					info.capabilities?.includes("reasoning"),
+				supportsVision: info.capabilities?.includes("images"),
+			}));
+		await this.post({ type: "models", providerId: provider, models });
+	}
+
+	private async refreshSessions(): Promise<void> {
+		const host = await this.getSessionHost();
+		const sessions = (
+			await host.list(SESSION_HISTORY_LIMIT, {
+				hydrate: false,
+				includeManifestFallback: true,
+			})
+		)
+			.sort(
+				(a, b) =>
+					(parseSessionTimestamp(b.updatedAt) ?? 0) -
+					(parseSessionTimestamp(a.updatedAt) ?? 0),
+			)
+			.map(
+				(session): WebviewSessionSummary => ({
+					sessionId: session.sessionId,
+					title:
+						typeof session.metadata?.title === "string"
+							? session.metadata.title
+							: undefined,
+					status: session.status,
+					workspaceRoot: session.workspaceRoot,
+					updatedAt: parseSessionTimestamp(session.updatedAt),
+				}),
+			);
+		await this.post({ type: "sessions", sessions });
+	}
+
+	private async attachSession(sessionId: string): Promise<void> {
+		const trimmed = sessionId.trim();
+		if (!trimmed) {
+			await this.resetSession();
+			return;
+		}
+		const host = await this.getSessionHost();
+		const session = await host.get(trimmed);
+		if (!session) {
+			await this.post({
+				type: "status",
+				text: `Session ${trimmed} was not found.`,
+			});
+			return;
+		}
+		this.startEventStream(trimmed);
+		await this.hubClient?.command("session.attach", {
+			sessionId: trimmed,
+			role: "participant",
+			metadata: { source: "vscode-webview" },
+		});
+		const persistedMessages = (await host.readMessages(
+			trimmed,
+		)) as PersistedMessage[];
+		this.startConfig = await this.buildStartConfigFromSession(session);
+		await this.post({ type: "session_started", sessionId: trimmed });
+		await this.post({
+			type: "session_hydrated",
+			sessionId: trimmed,
+			status: session.status,
+			providerId: session.provider,
+			modelId: session.model,
+			messages: mapPersistedMessagesToWebviewMessages(
+				persistedMessages,
+				session.metadata?.checkpoint,
+			),
+		});
+		await this.post({
+			type: "status",
+			text:
+				session.status === "running"
+					? `Attached to ${trimmed} (running)`
+					: `Attached to ${trimmed}`,
+		});
+		await this.refreshSessions();
+	}
+
+	private async updateSessionMetadata(
+		sessionId: string,
+		metadata: Record<string, unknown>,
+	): Promise<void> {
+		const trimmed = sessionId.trim();
+		if (!trimmed) return;
+		const host = await this.getSessionHost();
+		await host.update(trimmed, { metadata });
+		await this.refreshSessions();
+	}
+
+	private async deleteSession(sessionId: string): Promise<void> {
+		const trimmed = sessionId.trim();
+		if (!trimmed) return;
+		const host = await this.getSessionHost();
+		const deleted = await host.delete(trimmed);
+		if (!deleted) {
+			await this.post({
+				type: "status",
+				text: `Session ${trimmed} not found.`,
+			});
+			return;
+		}
+		if (this.sessionId === trimmed) {
+			this.stopEventStream();
+			this.sessionId = undefined;
+			this.startConfig = undefined;
+			await this.post({ type: "reset_done" });
+		}
+		await this.refreshSessions();
+		await this.post({ type: "status", text: `Deleted session ${trimmed}` });
+	}
+
+	private async sendPrompt(
+		prompt: string,
+		config?: WebviewSendConfig,
+		attachments?: { userImages?: string[] },
+	): Promise<void> {
+		const trimmedPrompt = prompt.trim();
+		if (!trimmedPrompt && (attachments?.userImages?.length ?? 0) === 0) {
+			return;
+		}
+		if (this.sending) {
+			await this.post({
+				type: "status",
+				text: "A turn is already in progress.",
+			});
+			return;
+		}
+
+		this.sending = true;
+		try {
+			await this.ensureSession(config);
+			const host = await this.getSessionHost();
+			const activeSessionId = this.sessionId as string;
+			await host.send({
+				sessionId: activeSessionId,
+				prompt: trimmedPrompt,
+				userImages: attachments?.userImages,
+			});
+			await this.refreshSessions();
+		} catch (error) {
+			await this.postError(error);
+		} finally {
+			this.sending = false;
+		}
+	}
+
+	private buildExtensionContext(workspaceRoot: string, cwd: string) {
+		return {
+			client: { name: "cline-vscode", version },
+			workspace: {
+				rootPath: workspaceRoot,
+				cwd,
+				workspaceName: basename(cwd),
+				ide: "VS Code",
+				platform: os.platform(),
+			},
+			logger: this.logger,
+			telemetry: this.telemetry,
+		};
+	}
+
+	private async buildStartConfigFromSession(
+		session: NonNullable<Awaited<ReturnType<ClineCore["get"]>>>,
+	): Promise<StartConfig> {
+		const mode: "act" | "plan" =
+			session.metadata?.mode === "plan" ? "plan" : "act";
+		const explicitSystemPrompt =
+			typeof session.metadata?.systemPrompt === "string"
+				? session.metadata.systemPrompt
+				: undefined;
+		const resolvedSystemPrompt = await this.resolveSystemPrompt(
+			session.cwd,
+			session.provider,
+			explicitSystemPrompt,
+			mode,
+		);
+		return {
+			workspaceRoot: session.workspaceRoot,
+			cwd: session.cwd,
+			providerId: session.provider,
+			modelId: session.model,
+			mode,
+			apiKey: "",
+			systemPrompt: resolvedSystemPrompt,
+			maxIterations:
+				typeof session.metadata?.maxIterations === "number"
+					? session.metadata.maxIterations
+					: undefined,
+			thinking: session.metadata?.thinking === true,
+			enableTools: session.enableTools,
+			enableSpawnAgent: session.enableSpawn,
+			enableAgentTeams: session.enableTeams,
+			teamName: session.teamName ?? "vscode-chat",
+			missionLogIntervalSteps: 3,
+			missionLogIntervalMs: 120000,
+			checkpoint: { enabled: true },
+			autoApproveTools:
+				typeof session.metadata?.autoApproveTools === "boolean"
+					? session.metadata.autoApproveTools
+					: undefined,
+			logger: this.logger,
+			extensionContext: this.buildExtensionContext(
+				session.workspaceRoot,
+				session.cwd,
+			),
+		};
+	}
+
+	private async ensureSession(
+		config?: WebviewSendConfig,
+	): Promise<StartConfig> {
+		const defaults = this.resolveWorkspaceDefaults();
+		const providerId = Llms.normalizeProviderId(
+			config?.provider?.trim() || "cline",
+		);
+		const modelId = config?.model?.trim() || "openai/gpt-5.5";
+		const mode: "act" | "plan" = config?.mode === "plan" ? "plan" : "act";
+		const normalizedMaxIterations =
+			typeof config?.maxIterations === "number" && config.maxIterations > 0
+				? Math.floor(config.maxIterations)
+				: undefined;
+		const resolvedSystemPrompt = await this.resolveSystemPrompt(
+			defaults.cwd,
+			providerId,
+			config?.systemPrompt,
+			mode,
+		);
+		const startConfig: StartConfig = {
+			workspaceRoot: defaults.workspaceRoot,
+			cwd: defaults.cwd,
+			providerId,
+			modelId,
+			mode,
+			apiKey: "",
+			systemPrompt: resolvedSystemPrompt,
+			maxIterations: normalizedMaxIterations,
+			thinking: config?.thinking === true,
+			enableTools: config?.enableTools !== false,
+			enableSpawnAgent: config?.enableSpawn !== false,
+			enableAgentTeams: config?.enableTeams === true,
+			teamName: "vscode-chat",
+			missionLogIntervalSteps: 3,
+			missionLogIntervalMs: 120000,
+			checkpoint: { enabled: true },
+			autoApproveTools: config?.autoApproveTools !== false,
+			logger: this.logger,
+			extensionContext: this.buildExtensionContext(
+				defaults.workspaceRoot,
+				defaults.cwd,
+			),
+			extraTools: [createVsCodeTerminalTool(defaults.cwd)],
+		};
+
+		if (this.sessionId && this.startConfig) {
+			if (areStartConfigsEqual(this.startConfig, startConfig)) {
+				return this.startConfig;
+			}
+			await this.stopExistingSession();
+		}
+
+		const toolPolicies = createToolPolicies(startConfig);
+
+		const host = await this.getSessionHost();
+		const response = await host.start({
+			interactive: true,
+			config: startConfig,
+			toolPolicies,
+		});
+		const sessionId = response.sessionId.trim();
+		if (!sessionId) {
+			throw new Error("core runtime returned an empty session id");
+		}
+
+		this.sessionId = sessionId;
+		this.startConfig = startConfig;
+		this.startEventStream(sessionId);
+		await this.post({ type: "session_started", sessionId });
+		await this.refreshSessions();
+		return startConfig;
+	}
+
+	private async stopExistingSession(): Promise<void> {
+		if (this.sessionId && this.host) {
+			try {
+				await this.host.stop(this.sessionId);
+			} catch {
+				// best-effort cleanup before starting a replacement session
+			}
+		}
+		this.stopEventStream();
+		this.sessionId = undefined;
+		this.startConfig = undefined;
+	}
+
+	private startEventStream(sessionId: string): void {
+		this.stopEventStream();
+		this.sessionId = sessionId;
+		this.stopSessionSubscription = this.hubClient?.subscribe((event) => {
+			if (event.sessionId !== sessionId) return;
+			void this.forwardSessionHubEvent(event as HubEventEnvelope);
+		});
+	}
+
+	private async resolveSystemPrompt(
+		cwd: string,
+		providerId: string,
+		explicitSystemPrompt?: string,
+		mode: "act" | "plan" | "yolo" = "act",
+	): Promise<string> {
+		const metadata = await buildWorkspaceMetadata(cwd);
+		return buildClineSystemPrompt({
+			overridePrompt: explicitSystemPrompt,
+			ide: "VS Code",
+			mode,
+			workspaceRoot: cwd,
+			providerId,
+			workspaceName: basename(cwd),
+			metadata,
+			platform:
+				(typeof process !== "undefined" && process?.platform) || "unknown",
+		});
+	}
+
+	private async abortTurn(): Promise<void> {
+		if (!this.sessionId) return;
+		try {
+			const host = await this.getSessionHost();
+			await host.abort(this.sessionId);
+			await this.post({ type: "status", text: "Abort requested." });
+		} catch (error) {
+			await this.postError(error);
+		}
+	}
+
+	private async forkSession(): Promise<void> {
+		const forkedFromSessionId = this.sessionId;
+		if (!forkedFromSessionId) {
+			await this.post({
+				type: "fork_error",
+				text: "No active session to fork.",
+			});
+			return;
+		}
+		try {
+			const host = await this.getSessionHost();
+			const rawMessages = await host.readMessages(forkedFromSessionId);
+			if (rawMessages.length === 0) {
+				await this.post({
+					type: "fork_error",
+					text: "Cannot fork an empty session.",
+				});
+				return;
+			}
+			const sourceSession = await host.get(forkedFromSessionId);
+			const checkpointMetadata = sourceSession?.metadata?.checkpoint;
+			const forkMetadata: Record<string, unknown> = {
+				...(sourceSession?.metadata ?? {}),
+				fork: {
+					forkedFromSessionId,
+					forkedAt: new Date().toISOString(),
+					source: sourceSession?.source ?? "vscode",
+					...(checkpointMetadata !== undefined
+						? { checkpoints: checkpointMetadata }
+						: {}),
+				},
+			};
+			const forkStartConfig = sourceSession
+				? await this.buildStartConfigFromSession(sourceSession)
+				: this.startConfig;
+			if (!forkStartConfig) {
+				throw new Error("Could not resolve start config for fork.");
+			}
+			await this.stopExistingSession();
+			const response = await host.start({
+				interactive: true,
+				config: forkStartConfig,
+				toolPolicies: createToolPolicies(forkStartConfig),
+				initialMessages: rawMessages as import("@cline/llms").Message[],
+				sessionMetadata: forkMetadata,
+			});
+			const newSessionId = response.sessionId.trim();
+			if (!newSessionId) {
+				throw new Error("Fork did not return a session id.");
+			}
+			const newSession = await host.get(newSessionId);
+			this.sessionId = newSessionId;
+			this.startConfig = forkStartConfig;
+			this.startEventStream(newSessionId);
+			await this.post({ type: "session_started", sessionId: newSessionId });
+			await this.post({
+				type: "session_hydrated",
+				sessionId: newSessionId,
+				status: newSession?.status,
+				messages: mapPersistedMessagesToWebviewMessages(
+					rawMessages as PersistedMessage[],
+					newSession?.metadata?.checkpoint,
+				),
+			});
+			await this.post({
+				type: "fork_done",
+				forkedFromSessionId,
+				newSessionId,
+			});
+			await this.refreshSessions();
+		} catch (error) {
+			const text = error instanceof Error ? error.message : String(error);
+			await this.post({ type: "fork_error", text });
+		}
+	}
+
+	private async resetSession(): Promise<void> {
+		await this.stopExistingSession();
+		this.sending = false;
+		await this.post({ type: "reset_done" });
+		await this.refreshSessions();
+	}
+
+	private stopEventStream(): void {
+		this.stopSessionSubscription?.();
+		this.stopSessionSubscription = undefined;
+	}
+
+	private async getSessionHost(): Promise<ClineCore> {
+		if (!this.host) {
+			await this.ensureHub();
+			const defaults = this.resolveWorkspaceDefaults();
+			this.host = await ClineCore.create({
+				backendMode: "hub",
+				capabilities: this.createRuntimeCapabilities(),
+				hub: {
+					endpoint: this.hubUrl,
+					authToken: this.hubAuthToken,
+					clientType: "vscode",
+					displayName: "VS Code",
+					workspaceRoot: defaults.workspaceRoot,
+					cwd: defaults.cwd,
+				},
+				telemetry: this.telemetry,
+			});
+			this.stopHostSubscription = this.host.subscribe(() => {});
+		}
+		return this.host;
+	}
+
+	private createRuntimeCapabilities(): RuntimeCapabilities {
+		return createVsCodeRuntimeCapabilities({ ui: vscode.window });
+	}
+
+	private async restore(checkpointRunCount: number): Promise<void> {
+		const sourceSessionId = this.sessionId;
+		const startConfig = this.startConfig;
+		if (!sourceSessionId || !startConfig) {
+			await this.post({
+				type: "error",
+				text: "No active session to restore.",
+			});
+			return;
+		}
+		if (!Number.isInteger(checkpointRunCount) || checkpointRunCount < 1) {
+			await this.post({ type: "error", text: "Invalid checkpoint run count." });
+			return;
+		}
+		try {
+			const host = await this.getSessionHost();
+			const restored = await host.restore({
+				sessionId: sourceSessionId,
+				checkpointRunCount,
+				cwd: startConfig.cwd || startConfig.workspaceRoot,
+				restore: { messages: true, workspace: true },
+				start: {
+					interactive: true,
+					config: startConfig,
+					toolPolicies: createToolPolicies(startConfig),
+				},
+			});
+			const newSessionId = restored.sessionId?.trim() ?? "";
+			if (!newSessionId) {
+				throw new Error("Checkpoint restore did not return a session id.");
+			}
+			const newSession = await host.get(newSessionId);
+			await this.stopExistingSession();
+			this.sessionId = newSessionId;
+			this.startConfig = startConfig;
+			this.startEventStream(newSessionId);
+			await this.post({ type: "session_started", sessionId: newSessionId });
+			await this.post({
+				type: "session_hydrated",
+				sessionId: newSessionId,
+				status: newSession?.status,
+				providerId: newSession?.provider,
+				modelId: newSession?.model,
+				messages: mapPersistedMessagesToWebviewMessages(
+					(restored.messages ?? []) as PersistedMessage[],
+					newSession?.metadata?.checkpoint,
+				),
+			});
+			await this.post({
+				type: "status",
+				text: `Restored checkpoint ${checkpointRunCount}`,
+			});
+			await this.refreshSessions();
+		} catch (error) {
+			await this.postError(error);
+		}
+	}
+
+	private async handleHubEvent(event: HubEventEnvelope): Promise<void> {
+		const shouldRefreshSessions = REFRESH_SESSION_EVENTS.has(event.event);
+		if (!this.sessionId || event.sessionId !== this.sessionId) {
+			if (shouldRefreshSessions) {
+				void this.refreshSessions().catch(() => undefined);
+			}
+			return;
+		}
+		if (!this.stopSessionSubscription) {
+			await this.forwardSessionHubEvent(event);
+		}
+	}
+
+	private async forwardSessionHubEvent(event: HubEventEnvelope): Promise<void> {
+		if (!this.sessionId || event.sessionId !== this.sessionId) return;
+		const payload = asRecord(event.payload);
+		const shouldRefreshSessions = REFRESH_SESSION_EVENTS.has(event.event);
+
+		switch (event.event) {
+			case "assistant.delta":
+				await this.post({
+					type: "assistant_delta",
+					text: String(payload?.text ?? ""),
+				});
+				return;
+			case "reasoning.delta":
+				await this.post({
+					type: "reasoning_delta",
+					text: String(payload?.text ?? ""),
+					redacted: payload?.redacted === true,
+				});
+				return;
+			case "tool.started": {
+				const toolName =
+					typeof payload?.toolName === "string" ? payload.toolName : "tool";
+				await this.post({
+					type: "tool_event",
+					text: `Running ${toolName}...`,
+					event: {
+						toolCallId:
+							typeof payload?.toolCallId === "string"
+								? payload.toolCallId
+								: undefined,
+						toolName,
+						status: "running",
+						input: payload?.input,
+					},
+				});
+				return;
+			}
+			case "tool.finished": {
+				const toolName =
+					typeof payload?.toolName === "string" ? payload.toolName : "tool";
+				const error =
+					typeof payload?.error === "string" ? payload.error : undefined;
+				await this.post({
+					type: "tool_event",
+					text: error
+						? `${toolName} failed: ${error}`
+						: `${toolName} completed`,
+					event: {
+						toolCallId:
+							typeof payload?.toolCallId === "string"
+								? payload.toolCallId
+								: undefined,
+						toolName,
+						status: error ? "failed" : "completed",
+						output: payload?.output,
+						error,
+					},
+				});
+				return;
+			}
+			case "run.completed":
+			case "run.failed": {
+				const result = asRecord(payload?.result);
+				await this.post({
+					type: "turn_done",
+					finishReason:
+						typeof payload?.reason === "string"
+							? payload.reason
+							: event.event === "run.failed"
+								? "error"
+								: "completed",
+					iterations:
+						typeof result?.iterations === "number" ? result.iterations : 0,
+					usage: asRecord(result?.usage) as
+						| {
+								inputTokens?: number;
+								outputTokens?: number;
+								cacheCreationInputTokens?: number;
+								cacheReadInputTokens?: number;
+								totalCost?: number;
+						  }
+						| undefined,
+				});
+				if (shouldRefreshSessions) {
+					void this.refreshSessions().catch(() => undefined);
+				}
+				return;
+			}
+			case "run.aborted":
+				await this.post({
+					type: "turn_done",
+					finishReason: "aborted",
+					iterations: 0,
+				});
+				if (shouldRefreshSessions) {
+					void this.refreshSessions().catch(() => undefined);
+				}
+				return;
+		}
+		if (shouldRefreshSessions) {
+			void this.refreshSessions().catch(() => undefined);
+		}
+	}
+
+	private async post(message: WebviewOutboundMessage): Promise<void> {
+		await this.webview.postMessage(message);
+	}
+
+	private async postError(error: unknown): Promise<void> {
+		const text = error instanceof Error ? error.message : String(error);
+		await this.post({ type: "error", text });
+	}
+}
+
+/**
+ * Returns true if two StartConfigs represent the same session, meaning no
+ * restart is needed when the webview sends a new config.
+ *
+ * For extensionContext, only the identity fields (client name and user
+ * distinctId) are compared — logger and telemetry are object references that
+ * are never meaningfully different between two calls for the same user, and
+ * JSON.stringify is unsafe here because those objects contain functions and
+ * may have circular references.
+ */
+function areStartConfigsEqual(a: StartConfig, b: StartConfig): boolean {
+	return (
+		a.providerId === b.providerId &&
+		a.modelId === b.modelId &&
+		a.cwd === b.cwd &&
+		a.workspaceRoot === b.workspaceRoot &&
+		a.systemPrompt === b.systemPrompt &&
+		a.maxIterations === b.maxIterations &&
+		a.thinking === b.thinking &&
+		a.enableTools === b.enableTools &&
+		a.enableSpawnAgent === b.enableSpawnAgent &&
+		a.enableAgentTeams === b.enableAgentTeams &&
+		a.teamName === b.teamName &&
+		a.missionLogIntervalSteps === b.missionLogIntervalSteps &&
+		a.missionLogIntervalMs === b.missionLogIntervalMs &&
+		a.mode === b.mode &&
+		a.apiKey === b.apiKey &&
+		a.autoApproveTools === b.autoApproveTools &&
+		a.extensionContext?.client?.name === b.extensionContext?.client?.name &&
+		a.extensionContext?.user?.distinctId ===
+			b.extensionContext?.user?.distinctId
+	);
+}
+
+function createToolPolicies(config: StartConfig): Record<string, ToolPolicy> {
+	return {
+		"*": { autoApprove: config.autoApproveTools !== false },
+	};
+}
+
+function createNonce(): string {
+	const chars =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let nonce = "";
+	for (let index = 0; index < 32; index += 1) {
+		nonce += chars.charAt(Math.floor(Math.random() * chars.length));
+	}
+	return nonce;
+}
+
+function createOutputChannelLogger(
+	outputChannel: vscode.OutputChannel,
+): BasicLogger {
+	const write = (
+		level: "debug" | "info" | "warn" | "error",
+		message: string,
+		metadata?: Record<string, unknown>,
+	): void => {
+		outputChannel.appendLine(
+			`[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}${formatLogMetadata(metadata)}`,
+		);
+	};
+
+	return {
+		debug: (message, metadata) => write("debug", message, metadata),
+		log: (message, metadata) => {
+			const severity = metadata?.severity;
+			const level =
+				severity === "warn" ? "warn" : severity === "error" ? "error" : "info";
+			const { severity: _s, ...rest } = metadata ?? {};
+			write(level, message, Object.keys(rest).length > 0 ? rest : undefined);
+		},
+		error: (message, metadata) => write("error", message, metadata),
+	};
+}
+
+function formatLogMetadata(metadata?: Record<string, unknown>): string {
+	if (!metadata || Object.keys(metadata).length === 0) return "";
+	try {
+		return ` ${JSON.stringify(metadata)}`;
+	} catch {
+		return " [unserializable metadata]";
+	}
+}
diff --git a/apps/examples/vscode/src/hub-daemon.ts b/apps/examples/vscode/src/hub-daemon.ts
new file mode 100644
index 0000000..94845f8
--- /dev/null
+++ b/apps/examples/vscode/src/hub-daemon.ts
@@ -0,0 +1,109 @@
+import * as os from "node:os";
+import {
+	type ConfiguredTelemetryHandle,
+	createConfiguredTelemetryHandle,
+	createLocalHubScheduleRuntimeHandlers,
+	ensureHubWebSocketServer,
+	resolveSharedHubOwnerContext,
+} from "@cline/core/hub";
+import {
+	createClineTelemetryServiceConfig,
+	createClineTelemetryServiceMetadata,
+	type TelemetryMetadata,
+} from "@cline/shared";
+
+type DetachedHubDaemonConfig = {
+	workspaceRoot: string;
+	cwd: string;
+	systemPrompt: string;
+	defaultProviderId?: string;
+	defaultModelId?: string;
+	/**
+	 * Optional telemetry metadata forwarded by the spawning host. When
+	 * provided, the daemon constructs an `ITelemetryService` and threads it
+	 * into both the hub WebSocket server and the schedule runtime handlers
+	 * so workspace lifecycle telemetry (e.g. `workspace.initialized`,
+	 * `workspace.init_error`) gets emitted from sessions executed inside
+	 * this detached process. Without this, the daemon would still serve
+	 * traffic but workspace lifecycle events would never reach the
+	 * telemetry pipeline configured by the host.
+	 */
+	telemetryMetadata?: Partial<TelemetryMetadata>;
+};
+
+function parseConfig(argv: string[]): DetachedHubDaemonConfig {
+	const encoded = argv[2]?.trim();
+	if (!encoded) {
+		throw new Error("Missing detached hub daemon config payload.");
+	}
+	return JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+}
+
+/**
+ * Builds a telemetry handle for the detached hub daemon process from
+ * metadata forwarded by the host. Returns `undefined` when the host did
+ * not provide metadata (e.g. older host versions, manual launches), which
+ * preserves the current default of "no telemetry in the daemon". Defers
+ * to `createConfiguredTelemetryHandle` so the daemon and the in-process
+ * extension share one canonical lifecycle implementation.
+ */
+function createDaemonTelemetry(
+	metadata: Partial<TelemetryMetadata> | undefined,
+): ConfiguredTelemetryHandle | undefined {
+	if (!metadata || Object.keys(metadata).length === 0) {
+		return undefined;
+	}
+	const config = createClineTelemetryServiceConfig({
+		metadata: createClineTelemetryServiceMetadata({
+			extension_version: metadata.extension_version,
+			cline_type: metadata.cline_type,
+			platform: metadata.platform,
+			platform_version: metadata.platform_version,
+			os_type: metadata.os_type ?? os.platform(),
+			os_version: metadata.os_version ?? os.version(),
+			is_remote_workspace: metadata.is_remote_workspace,
+		}),
+	});
+	return createConfiguredTelemetryHandle(config);
+}
+
+async function main(): Promise<void> {
+	const config = parseConfig(process.argv);
+	const telemetryHandle = createDaemonTelemetry(config.telemetryMetadata);
+
+	const ensured = await ensureHubWebSocketServer({
+		owner: resolveSharedHubOwnerContext(),
+		runtimeHandlers: createLocalHubScheduleRuntimeHandlers({
+			telemetry: telemetryHandle?.telemetry,
+		}),
+		telemetry: telemetryHandle?.telemetry,
+	});
+
+	let closing = false;
+	const close = async () => {
+		if (closing) return;
+		closing = true;
+		try {
+			await ensured.server?.close();
+		} finally {
+			if (telemetryHandle) {
+				await telemetryHandle.flush();
+				await telemetryHandle.dispose();
+			}
+			process.exit(0);
+		}
+	};
+	process.once("SIGINT", () => {
+		void close();
+	});
+	process.once("SIGTERM", () => {
+		void close();
+	});
+}
+
+void main().catch((error) => {
+	process.stderr.write(
+		`[cline-vscode hub-daemon] ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
+	);
+	process.exit(1);
+});
diff --git a/apps/examples/vscode/src/runtime-capabilities.test.ts b/apps/examples/vscode/src/runtime-capabilities.test.ts
new file mode 100644
index 0000000..dbc6293
--- /dev/null
+++ b/apps/examples/vscode/src/runtime-capabilities.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	createVsCodeRuntimeCapabilities,
+	type VsCodeCapabilityUi,
+} from "./runtime-capabilities";
+
+describe("createVsCodeRuntimeCapabilities", () => {
+	it("registers askQuestion and approval handlers with VS Code UI behavior", async () => {
+		const showQuickPick = vi.fn(async () => "Use SDK");
+		const showInputBox = vi.fn(async () => "typed answer");
+		const showWarningMessage: VsCodeCapabilityUi["showWarningMessage"] = vi.fn(
+			async (_message, _options, ...items) => items[0],
+		);
+		const capabilities = createVsCodeRuntimeCapabilities({
+			ui: { showQuickPick, showInputBox, showWarningMessage },
+		});
+
+		expect(capabilities.toolExecutors?.askQuestion).toEqual(
+			expect.any(Function),
+		);
+		expect(capabilities.requestToolApproval).toEqual(expect.any(Function));
+
+		await expect(
+			capabilities.toolExecutors?.askQuestion?.(
+				"Which approach?",
+				["Use SDK", "Write custom"],
+				{ agentId: "agent", conversationId: "conv", iteration: 1 },
+			),
+		).resolves.toBe("Use SDK");
+		expect(showQuickPick).toHaveBeenCalledWith(["Use SDK", "Write custom"], {
+			placeHolder: "Which approach?",
+			ignoreFocusOut: true,
+		});
+
+		await expect(
+			capabilities.requestToolApproval?.({
+				sessionId: "session-1",
+				agentId: "agent",
+				conversationId: "conv",
+				iteration: 1,
+				toolCallId: "tool-call-1",
+				toolName: "run_commands",
+				input: { commands: ["echo hi"] },
+				policy: { autoApprove: false },
+			}),
+		).resolves.toEqual({ approved: true });
+		expect(showWarningMessage).toHaveBeenCalledWith(
+			"Allow run_commands to run?",
+			expect.objectContaining({
+				modal: true,
+				detail: expect.stringContaining("tool-call-1"),
+			}),
+			"Approve",
+			"Deny",
+		);
+
+		await expect(
+			capabilities.toolExecutors?.askQuestion?.("Freeform?", [], {
+				agentId: "agent",
+				conversationId: "conv",
+				iteration: 2,
+			}),
+		).resolves.toBe("typed answer");
+		expect(showInputBox).toHaveBeenCalledWith({
+			prompt: "Freeform?",
+			ignoreFocusOut: true,
+		});
+	});
+});
diff --git a/apps/examples/vscode/src/runtime-capabilities.ts b/apps/examples/vscode/src/runtime-capabilities.ts
new file mode 100644
index 0000000..d958305
--- /dev/null
+++ b/apps/examples/vscode/src/runtime-capabilities.ts
@@ -0,0 +1,106 @@
+import type {
+	RuntimeCapabilities,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@cline/core";
+
+type QuickPickOptions = {
+	placeHolder?: string;
+	ignoreFocusOut?: boolean;
+};
+
+type InputBoxOptions = {
+	prompt?: string;
+	ignoreFocusOut?: boolean;
+};
+
+type WarningMessageOptions = {
+	modal?: boolean;
+	detail?: string;
+};
+
+export type VsCodeCapabilityUi = {
+	showQuickPick: (
+		items: string[],
+		options?: QuickPickOptions,
+	) => Thenable<string | undefined> | Promise<string | undefined>;
+	showInputBox: (
+		options?: InputBoxOptions,
+	) => Thenable<string | undefined> | Promise<string | undefined>;
+	showWarningMessage: <T extends string>(
+		message: string,
+		options: WarningMessageOptions,
+		...items: T[]
+	) => Thenable<T | undefined> | Promise<T | undefined>;
+};
+
+function stringifyContent(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+
+function stringifyApprovalInput(input: unknown): string | undefined {
+	const text = stringifyContent(input).trim();
+	return text.length > 0 ? text : undefined;
+}
+
+export function createVsCodeRuntimeCapabilities(options: {
+	ui: VsCodeCapabilityUi;
+}): RuntimeCapabilities {
+	const { ui } = options;
+	const askQuestion = async (
+		question: string,
+		answerOptions?: string[],
+	): Promise<string> => {
+		const choices = (answerOptions ?? []).filter(
+			(option) => option.trim().length > 0,
+		);
+		if (choices.length > 0) {
+			const selected = await ui.showQuickPick(choices, {
+				placeHolder: question,
+				ignoreFocusOut: true,
+			});
+			return selected ?? "";
+		}
+		return (
+			(await ui.showInputBox({
+				prompt: question,
+				ignoreFocusOut: true,
+			})) ?? ""
+		);
+	};
+
+	const requestToolApproval = async (
+		request: ToolApprovalRequest,
+	): Promise<ToolApprovalResult> => {
+		const approve = "Approve";
+		const deny = "Deny";
+		const inputPreview = stringifyApprovalInput(request.input);
+		const selected = await ui.showWarningMessage(
+			`Allow ${request.toolName} to run?`,
+			{
+				modal: true,
+				detail: inputPreview
+					? `Tool call: ${request.toolCallId}\n${inputPreview}`
+					: `Tool call: ${request.toolCallId}`,
+			},
+			approve,
+			deny,
+		);
+		return selected === approve
+			? { approved: true }
+			: { approved: false, reason: "Denied by VS Code user" };
+	};
+
+	return {
+		toolExecutors: {
+			askQuestion,
+		},
+		requestToolApproval,
+	};
+}
diff --git a/apps/examples/vscode/src/telemetry.ts b/apps/examples/vscode/src/telemetry.ts
new file mode 100644
index 0000000..b322698
--- /dev/null
+++ b/apps/examples/vscode/src/telemetry.ts
@@ -0,0 +1,51 @@
+import * as os from "node:os";
+import {
+	type ConfiguredTelemetryHandle,
+	createConfiguredTelemetryHandle,
+} from "@cline/core";
+import {
+	createClineTelemetryServiceConfig,
+	createClineTelemetryServiceMetadata,
+} from "@cline/shared";
+
+export interface VscodeTelemetryOptions {
+	extensionVersion: string;
+	clineType: string;
+	platform: string;
+	platformVersion: string;
+	osType?: string;
+	osVersion?: string;
+	isRemoteWorkspace?: boolean;
+}
+
+/**
+ * Lifecycle bundle returned by {@link createVscodeTelemetry}. Identical to
+ * {@link ConfiguredTelemetryHandle}; aliased here so call sites in the
+ * extension can keep importing a host-named type.
+ */
+export type VscodeTelemetryHandle = ConfiguredTelemetryHandle;
+
+/**
+ * Centralizes VS Code telemetry service/provider creation. The host calls this
+ * once during `activate()` and shares the resulting `ITelemetryService` with
+ * core/hub/webview paths so a single provider lifecycle owns flushing and
+ * disposal on `deactivate()`. The flush/dispose closures themselves come from
+ * `createConfiguredTelemetryHandle` so the extension and the detached hub
+ * daemon share one canonical implementation of the lifecycle plumbing.
+ */
+export function createVscodeTelemetry(
+	options: VscodeTelemetryOptions,
+): VscodeTelemetryHandle {
+	const config = createClineTelemetryServiceConfig({
+		metadata: createClineTelemetryServiceMetadata({
+			extension_version: options.extensionVersion,
+			cline_type: options.clineType,
+			platform: options.platform,
+			platform_version: options.platformVersion,
+			os_type: options.osType ?? os.platform(),
+			os_version: options.osVersion ?? os.version(),
+			is_remote_workspace: options.isRemoteWorkspace,
+		}),
+	});
+	return createConfiguredTelemetryHandle(config);
+}
diff --git a/apps/examples/vscode/src/webview-protocol.ts b/apps/examples/vscode/src/webview-protocol.ts
new file mode 100644
index 0000000..9c8ccff
--- /dev/null
+++ b/apps/examples/vscode/src/webview-protocol.ts
@@ -0,0 +1,153 @@
+import type {
+	ChatMessage as CoreChatMessage,
+	ProviderListItem,
+	ProviderModel,
+} from "@cline/core";
+
+export type WebviewUsage = {
+	inputTokens?: number;
+	outputTokens?: number;
+	cacheCreationInputTokens?: number;
+	cacheReadInputTokens?: number;
+	totalCost?: number;
+};
+
+export type WebviewProviderModel = Pick<
+	ProviderModel,
+	"id" | "name" | "supportsReasoning"
+> & {
+	supportsThinking?: boolean;
+};
+
+export type WebviewToolEvent = {
+	toolCallId?: string;
+	toolName?: string;
+	status: "running" | "completed" | "failed";
+	input?: unknown;
+	output?: unknown;
+	error?: string;
+};
+
+export type WebviewChatMessageBlock =
+	| { id: string; type: "text"; text: string }
+	| { id: string; type: "reasoning"; text: string; redacted?: boolean }
+	| {
+			id: string;
+			type: "tool";
+			toolEvent: NonNullable<WebviewChatMessage["toolEvents"]>[number];
+	  };
+
+export type WebviewChatMessage = Omit<
+	CoreChatMessage,
+	"content" | "createdAt" | "meta" | "role" | "sessionId"
+> & {
+	role:
+		| Extract<CoreChatMessage["role"], "user" | "assistant" | "error">
+		| "meta";
+	text: string;
+	reasoning?: string;
+	reasoningRedacted?: boolean;
+	checkpoint?: NonNullable<CoreChatMessage["meta"]>["checkpoint"];
+	toolEvents?: Array<{
+		id: string;
+		toolCallId?: string;
+		name: string;
+		text: string;
+		state: "input-available" | "output-available" | "output-error";
+		input?: unknown;
+		output?: unknown;
+		error?: string;
+	}>;
+	blocks?: WebviewChatMessageBlock[];
+};
+
+export type WebviewConfig = {
+	provider?: string;
+	model?: string;
+	mode?: "act" | "plan";
+	systemPrompt?: string;
+	maxIterations?: number;
+	thinking?: boolean;
+	enableTools?: boolean;
+	enableSpawn?: boolean;
+	enableTeams?: boolean;
+	autoApproveTools?: boolean;
+};
+
+export type WebviewChatAttachments = {
+	userImages?: string[];
+};
+
+export type WebviewDefaults = {
+	provider?: string;
+	model?: string;
+	workspaceRoot: string;
+	cwd: string;
+};
+
+export type WebviewSessionSummary = {
+	sessionId: string;
+	title?: string;
+	status?: string;
+	workspaceRoot?: string;
+	updatedAt?: number;
+};
+
+export type WebviewInboundMessage =
+	| { type: "ready" }
+	| {
+			type: "send";
+			prompt: string;
+			config?: WebviewConfig;
+			attachments?: WebviewChatAttachments;
+	  }
+	| { type: "abort" }
+	| { type: "reset" }
+	| { type: "loadModels"; providerId: string }
+	| { type: "attachSession"; sessionId: string }
+	| { type: "deleteSession"; sessionId: string }
+	| {
+			type: "updateSessionMetadata";
+			sessionId: string;
+			metadata: Record<string, unknown>;
+	  }
+	| { type: "restore"; checkpointRunCount: number }
+	| { type: "forkSession" };
+
+export type WebviewOutboundMessage =
+	| { type: "status"; text: string }
+	| { type: "error"; text: string }
+	| { type: "session_started"; sessionId: string }
+	| {
+			type: "session_hydrated";
+			sessionId: string;
+			status?: string;
+			providerId?: string;
+			modelId?: string;
+			messages: WebviewChatMessage[];
+	  }
+	| { type: "assistant_delta"; text: string }
+	| { type: "reasoning_delta"; text: string; redacted?: boolean }
+	| { type: "tool_event"; text: string; event?: WebviewToolEvent }
+	| {
+			type: "turn_done";
+			finishReason: string;
+			iterations: number;
+			usage?: WebviewUsage;
+	  }
+	| {
+			type: "providers";
+			providers: Array<
+				Pick<ProviderListItem, "defaultModelId" | "enabled" | "id" | "name">
+			>;
+	  }
+	| { type: "models"; providerId: string; models: WebviewProviderModel[] }
+	| { type: "sessions"; sessions: WebviewSessionSummary[] }
+	| { type: "defaults"; defaults: WebviewDefaults }
+	| { type: "reset_done" }
+	| {
+			type: "fork_done";
+			forkedFromSessionId: string;
+			newSessionId: string;
+	  }
+	| { type: "fork_error"; text: string };
diff --git a/apps/examples/vscode/src/webview/.gitignore b/apps/examples/vscode/src/webview/.gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/apps/examples/vscode/src/webview/README.md b/apps/examples/vscode/src/webview/README.md
new file mode 100644
index 0000000..7dbf7eb
--- /dev/null
+++ b/apps/examples/vscode/src/webview/README.md
@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
diff --git a/apps/examples/vscode/src/webview/components.json b/apps/examples/vscode/src/webview/components.json
new file mode 100644
index 0000000..3860673
--- /dev/null
+++ b/apps/examples/vscode/src/webview/components.json
@@ -0,0 +1,25 @@
+{
+	"$schema": "https://ui.shadcn.com/schema.json",
+	"style": "base-nova",
+	"rsc": false,
+	"tsx": true,
+	"tailwind": {
+		"config": "",
+		"css": "src/index.css",
+		"baseColor": "neutral",
+		"cssVariables": true,
+		"prefix": ""
+	},
+	"iconLibrary": "lucide",
+	"rtl": false,
+	"aliases": {
+		"components": "@/components",
+		"utils": "@/lib/utils",
+		"ui": "@/components/ui",
+		"lib": "@/lib",
+		"hooks": "@/hooks"
+	},
+	"menuColor": "default",
+	"menuAccent": "subtle",
+	"registries": {}
+}
diff --git a/apps/examples/vscode/src/webview/eslint.config.js b/apps/examples/vscode/src/webview/eslint.config.js
new file mode 100644
index 0000000..dca2e85
--- /dev/null
+++ b/apps/examples/vscode/src/webview/eslint.config.js
@@ -0,0 +1,29 @@
+import js from "@eslint/js";
+import { defineConfig, globalIgnores } from "eslint/config";
+import reactHooks from "eslint-plugin-react-hooks";
+import reactRefresh from "eslint-plugin-react-refresh";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default defineConfig([
+	globalIgnores(["dist"]),
+	{
+		files: ["**/*.{ts,tsx}"],
+		extends: [
+			js.configs.recommended,
+			tseslint.configs.recommended,
+			reactHooks.configs.flat.recommended,
+			reactRefresh.configs.vite,
+		],
+		rules: {
+			"react-refresh/only-export-components": [
+				"warn",
+				{ allowConstantExport: true },
+			],
+		},
+		languageOptions: {
+			ecmaVersion: 2020,
+			globals: globals.browser,
+		},
+	},
+]);
diff --git a/apps/examples/vscode/src/webview/index.html b/apps/examples/vscode/src/webview/index.html
new file mode 100644
index 0000000..2a7e2b7
--- /dev/null
+++ b/apps/examples/vscode/src/webview/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>webview</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/apps/examples/vscode/src/webview/package.json b/apps/examples/vscode/src/webview/package.json
new file mode 100644
index 0000000..8a52eaf
--- /dev/null
+++ b/apps/examples/vscode/src/webview/package.json
@@ -0,0 +1,64 @@
+{
+	"name": "webview",
+	"private": true,
+	"version": "0.0.0",
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc -b && vite build",
+		"preview": "vite preview"
+	},
+	"dependencies": {
+		"@base-ui/react": "^1.3.0",
+		"@fontsource-variable/geist": "^5.2.8",
+		"@radix-ui/react-use-controllable-state": "^1.2.2",
+		"@rive-app/react-webgl2": "^4.27.2",
+		"@streamdown/cjk": "^1.0.3",
+		"@streamdown/code": "^1.1.1",
+		"@streamdown/math": "^1.0.2",
+		"@streamdown/mermaid": "^1.0.2",
+		"@tailwindcss/vite": "^4.2.1",
+		"@xyflow/react": "^12.10.1",
+		"ai": "^6.0.116",
+		"ansi-to-react": "^6.2.6",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"cmdk": "^1.1.1",
+		"embla-carousel-react": "^8.6.0",
+		"lucide-react": "^0.577.0",
+		"media-chrome": "^4.18.1",
+		"motion": "^12.38.0",
+		"nanoid": "^5.1.7",
+		"next-themes": "^0.4.6",
+		"react": "19.2.4",
+		"react-dom": "19.2.4",
+		"react-jsx-parser": "^2.4.1",
+		"recharts": "2.15.4",
+		"shadcn": "^4.0.8",
+		"shiki": "^4.0.2",
+		"sonner": "^2.0.7",
+		"streamdown": "^2.5.0",
+		"tailwind-merge": "^3.5.0",
+		"tokenlens": "^1.3.1",
+		"use-stick-to-bottom": "^1.1.3"
+	},
+	"devDependencies": {
+		"@eslint/js": "^9.39.4",
+		"@tailwindcss/postcss": "^4.2.0",
+		"@types/node": "^24.12.0",
+		"@types/react": "^19.2.14",
+		"@types/react-dom": "^19.2.3",
+		"@vitejs/plugin-react-swc": "^4.3.0",
+		"esbuild": "^0.27.0",
+		"eslint": "^9.39.4",
+		"eslint-plugin-react-hooks": "^7.0.1",
+		"eslint-plugin-react-refresh": "^0.5.2",
+		"globals": "^17.4.0",
+		"postcss": "^8.5",
+		"tailwindcss": "^4.2.1",
+		"tw-animate-css": "^1.4.0",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.56.1",
+		"vite": "^8.0.0"
+	}
+}
diff --git a/apps/examples/vscode/src/webview/public/32x32.png b/apps/examples/vscode/src/webview/public/32x32.png
new file mode 100644
index 0000000..40cfd21
Binary files /dev/null and b/apps/examples/vscode/src/webview/public/32x32.png differ
diff --git a/apps/examples/vscode/src/webview/public/favicon.svg b/apps/examples/vscode/src/webview/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/apps/examples/vscode/src/webview/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/apps/examples/vscode/src/webview/public/icon.ico b/apps/examples/vscode/src/webview/public/icon.ico
new file mode 100644
index 0000000..ea0e465
Binary files /dev/null and b/apps/examples/vscode/src/webview/public/icon.ico differ
diff --git a/apps/examples/vscode/src/webview/public/icon.png b/apps/examples/vscode/src/webview/public/icon.png
new file mode 100644
index 0000000..f7bc15f
Binary files /dev/null and b/apps/examples/vscode/src/webview/public/icon.png differ
diff --git a/apps/examples/vscode/src/webview/public/icon.svg b/apps/examples/vscode/src/webview/public/icon.svg
new file mode 100644
index 0000000..2a3908a
--- /dev/null
+++ b/apps/examples/vscode/src/webview/public/icon.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="92px" height="96px" viewBox="0 0 92 96" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Group Copy 2</title>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="icon-copy" transform="translate(-34, -40)" fill="#24292F">
+            <g id="Group-Copy-2" transform="translate(34, 40.5)">
+                <g id="Group-3-Copy-4" transform="translate(0, 0)">
+                    <path d="M65.4492701,16.3 C76.3374701,16.3 85.1635558,25.16479 85.1635558,36.1 L85.1635558,42.7 L90.9027661,54.1647464 C91.4694141,55.2966923 91.4668177,56.6300535 90.8957658,57.7597839 L85.1635558,69.1 L85.1635558,75.7 C85.1635558,86.63554 76.3374701,95.5 65.4492701,95.5 L26.0206986,95.5 C15.1328272,95.5 6.30641291,86.63554 6.30641291,75.7 L6.30641291,69.1 L0.448507752,57.7954874 C-0.14693501,56.6464093 -0.149634367,55.2802504 0.441262896,54.1288283 L6.30641291,42.7 L6.30641291,36.1 C6.30641291,25.16479 15.1328272,16.3 26.0206986,16.3 L65.4492701,16.3 Z M62.9301895,22 L29.189529,22 C19.8723267,22 12.3191987,29.5552188 12.3191987,38.875 L12.3191987,44.5 L7.44288578,53.9634655 C6.84794449,55.1180686 6.85066096,56.4896598 7.45017099,57.6418974 L12.3191987,67 L12.3191987,72.625 C12.3191987,81.9450625 19.8723267,89.5 29.189529,89.5 L62.9301895,89.5 C72.2476729,89.5 79.8005198,81.9450625 79.8005198,72.625 L79.8005198,67 L84.5682187,57.6061395 C85.1432011,56.473244 85.1458141,55.1345713 84.5752587,53.9994398 L79.8005198,44.5 L79.8005198,38.875 C79.8005198,29.5552188 72.2476729,22 62.9301895,22 Z" id="Combined-Shape" fill-rule="nonzero"></path>
+                    <circle id="Oval" cx="45.7349843" cy="11" r="11"></circle>
+                </g>
+                <rect id="Rectangle-Copy" stroke="#24292F" stroke-width="8" x="31" y="44.5" width="5" height="22" rx="2.5"></rect>
+                <rect id="Rectangle-Copy-2" stroke="#24292F" stroke-width="8" x="55" y="44.5" width="5" height="22" rx="2.5"></rect>
+            </g>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/apps/examples/vscode/src/webview/src/App.css b/apps/examples/vscode/src/webview/src/App.css
new file mode 100644
index 0000000..79bd2e6
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/App.css
@@ -0,0 +1,23 @@
+.app-shell {
+	min-height: 100vh;
+	display: grid;
+	grid-template-rows: minmax(0, 1fr) auto;
+	gap: 12px;
+}
+
+@media (max-width: 980px) {
+	.composer {
+		grid-template-columns: 1fr;
+	}
+
+	.composer__settings {
+		border-right: none;
+		border-bottom: 1px solid var(--border);
+	}
+}
+
+@media (max-width: 720px) {
+	.app-shell {
+		padding: 8px;
+	}
+}
diff --git a/apps/examples/vscode/src/webview/src/App.tsx b/apps/examples/vscode/src/webview/src/App.tsx
new file mode 100644
index 0000000..9d01eac
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/App.tsx
@@ -0,0 +1,8 @@
+import "./App.css";
+import Chat from "./Chat";
+
+function App() {
+	return <Chat />;
+}
+
+export default App;
diff --git a/apps/examples/vscode/src/webview/src/Chat.tsx b/apps/examples/vscode/src/webview/src/Chat.tsx
new file mode 100644
index 0000000..551cabc
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/Chat.tsx
@@ -0,0 +1,1251 @@
+"use client";
+
+import { GitBranchIcon, Loader2Icon, PlusIcon, Trash2Icon } from "lucide-react";
+import { nanoid } from "nanoid";
+import {
+	type MutableRefObject,
+	type ReactElement,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	Checkpoint,
+	CheckpointIcon,
+	CheckpointTrigger,
+} from "@/components/ai-elements/checkpoint";
+import {
+	Conversation,
+	ConversationContent,
+	ConversationScrollButton,
+} from "@/components/ai-elements/conversation";
+import {
+	Message,
+	MessageContent,
+	MessageResponse,
+} from "@/components/ai-elements/message";
+import { PromptInputProvider } from "@/components/ai-elements/prompt-input";
+import {
+	Reasoning,
+	ReasoningContent,
+	ReasoningTrigger,
+} from "@/components/ai-elements/reasoning";
+import {
+	Tool,
+	ToolContent,
+	ToolHeader,
+	ToolOutput,
+} from "@/components/ai-elements/tool";
+import TeamTasks, { type TeamToolEvent } from "@/components/TeamTasks";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+import type {
+	WebviewChatAttachments,
+	WebviewChatMessage,
+	WebviewChatMessageBlock,
+	WebviewDefaults,
+	WebviewOutboundMessage,
+	WebviewProviderModel,
+	WebviewSessionSummary,
+	WebviewToolEvent,
+} from "../../webview-protocol";
+import { Composer } from "./components/Composer";
+import { getVsCodeApi, postToHost } from "./vscode";
+
+type ChatMessage = WebviewChatMessage;
+type ChatMessageBlock = WebviewChatMessageBlock;
+type ToolEvent = NonNullable<WebviewChatMessage["toolEvents"]>[number];
+type ProviderOption = Extract<
+	WebviewOutboundMessage,
+	{ type: "providers" }
+>["providers"][number];
+type ModelSelectionStorage = {
+	lastProvider: string;
+	lastModelByProvider: Record<string, string>;
+};
+
+const EMPTY_SELECTION: ModelSelectionStorage = {
+	lastProvider: "",
+	lastModelByProvider: {},
+};
+
+function readModelSelection(): ModelSelectionStorage {
+	try {
+		const state = getVsCodeApi()?.getState() as
+			| { modelSelection?: ModelSelectionStorage }
+			| undefined;
+		if (state?.modelSelection) {
+			return state.modelSelection;
+		}
+	} catch {
+		// ignore persisted state issues in the webview
+	}
+	return EMPTY_SELECTION;
+}
+
+function writeModelSelection(selection: ModelSelectionStorage): void {
+	try {
+		const api = getVsCodeApi();
+		if (!api) {
+			return;
+		}
+		const state = (api.getState() as Record<string, unknown>) ?? {};
+		api.setState({ ...state, modelSelection: selection });
+	} catch {
+		// ignore persisted state issues in the webview
+	}
+}
+
+function parseMaxIterations(value: string): number | undefined {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function createMessage(
+	role: ChatMessage["role"],
+	text: string,
+	extra?: Partial<ChatMessage>,
+): ChatMessage {
+	return {
+		id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+		role,
+		text,
+		...extra,
+	};
+}
+
+function buildUserMessageLabel(
+	prompt: string,
+	attachments?: WebviewChatAttachments,
+	attachmentCount = 0,
+): string {
+	const resolvedCount =
+		attachmentCount || (attachments?.userImages?.length ?? 0);
+	if (resolvedCount === 0) {
+		return prompt;
+	}
+	return `${prompt}${prompt.length > 0 ? "\n\n" : ""}[attached ${resolvedCount} file${resolvedCount === 1 ? "" : "s"}]`;
+}
+
+function appendAssistantDelta(
+	current: ChatMessage[],
+	text: string,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	if (!text) {
+		return current;
+	}
+
+	const activeAssistantId = activeAssistantIdRef.current;
+	if (activeAssistantId) {
+		const targetIndex = current.findIndex(
+			(message) => message.id === activeAssistantId,
+		);
+		if (targetIndex >= 0) {
+			return current.map((message, index) =>
+				index === targetIndex
+					? {
+							...message,
+							text: `${message.text}${text}`,
+							blocks: appendTextBlock(message.blocks, text),
+						}
+					: message,
+			);
+		}
+	}
+
+	const lastMessage = current.at(-1);
+	if (lastMessage?.role === "assistant") {
+		activeAssistantIdRef.current = lastMessage.id;
+		return [
+			...current.slice(0, -1),
+			{
+				...lastMessage,
+				text: `${lastMessage.text}${text}`,
+				blocks: appendTextBlock(lastMessage.blocks, text),
+			},
+		];
+	}
+
+	const assistantMessage = createMessage("assistant", text, {
+		blocks: [{ id: nanoid(), type: "text", text }],
+	});
+	activeAssistantIdRef.current = assistantMessage.id;
+	return [...current, assistantMessage];
+}
+
+function appendTextBlock(
+	blocks: ChatMessageBlock[] | undefined,
+	text: string,
+): ChatMessageBlock[] {
+	const current = blocks ?? [];
+	const last = current.at(-1);
+	if (last?.type === "text") {
+		return current.map((block, index) =>
+			index === current.length - 1 && block.type === "text"
+				? { ...block, text: `${block.text}${text}` }
+				: block,
+		);
+	}
+	return [...current, { id: nanoid(), type: "text", text }];
+}
+
+function appendReasoningBlock(
+	blocks: ChatMessageBlock[] | undefined,
+	text: string,
+	redacted?: boolean,
+): ChatMessageBlock[] {
+	const current = blocks ?? [];
+	const last = current.at(-1);
+	if (last?.type === "reasoning") {
+		return current.map((block, index) =>
+			index === current.length - 1 && block.type === "reasoning"
+				? {
+						...block,
+						text: `${block.text}${text}`,
+						redacted: block.redacted || redacted,
+					}
+				: block,
+		);
+	}
+	return [...current, { id: nanoid(), type: "reasoning", text, redacted }];
+}
+
+function upsertToolBlock(
+	blocks: ChatMessageBlock[] | undefined,
+	toolEvent: ToolEvent,
+): ChatMessageBlock[] {
+	const current = blocks ?? [];
+	const existingIndex = current.findIndex(
+		(block) =>
+			block.type === "tool" &&
+			((block.toolEvent.toolCallId &&
+				toolEvent.toolCallId &&
+				block.toolEvent.toolCallId === toolEvent.toolCallId) ||
+				(!block.toolEvent.toolCallId &&
+					!toolEvent.toolCallId &&
+					block.toolEvent.name === toolEvent.name &&
+					block.toolEvent.state === "input-available" &&
+					toolEvent.state !== "input-available")),
+	);
+	if (existingIndex === -1) {
+		return [...current, { id: nanoid(), type: "tool", toolEvent }];
+	}
+	return current.map((block, index) =>
+		index === existingIndex && block.type === "tool"
+			? { ...block, toolEvent: { ...block.toolEvent, ...toolEvent } }
+			: block,
+	);
+}
+
+function appendReasoningDelta(
+	current: ChatMessage[],
+	text: string,
+	redacted: boolean | undefined,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	const reasoningChunk = text || (redacted ? "[redacted]" : "");
+	if (!reasoningChunk) {
+		return current;
+	}
+
+	const activeAssistantId = activeAssistantIdRef.current;
+	if (activeAssistantId) {
+		const targetIndex = current.findIndex(
+			(message) => message.id === activeAssistantId,
+		);
+		if (targetIndex >= 0) {
+			return current.map((message, index) =>
+				index === targetIndex
+					? {
+							...message,
+							reasoning: `${message.reasoning ?? ""}${reasoningChunk}`,
+							reasoningRedacted: message.reasoningRedacted || redacted,
+							blocks: appendReasoningBlock(
+								message.blocks,
+								reasoningChunk,
+								redacted,
+							),
+						}
+					: message,
+			);
+		}
+	}
+
+	const lastMessage = current.at(-1);
+	if (lastMessage?.role === "assistant") {
+		activeAssistantIdRef.current = lastMessage.id;
+		return [
+			...current.slice(0, -1),
+			{
+				...lastMessage,
+				reasoning: `${lastMessage.reasoning ?? ""}${reasoningChunk}`,
+				reasoningRedacted: lastMessage.reasoningRedacted || redacted,
+				blocks: appendReasoningBlock(
+					lastMessage.blocks,
+					reasoningChunk,
+					redacted,
+				),
+			},
+		];
+	}
+
+	const assistantMessage = createMessage("assistant", "", {
+		reasoning: reasoningChunk,
+		reasoningRedacted: redacted,
+		blocks: [
+			{ id: nanoid(), type: "reasoning", text: reasoningChunk, redacted },
+		],
+	});
+	activeAssistantIdRef.current = assistantMessage.id;
+	return [...current, assistantMessage];
+}
+
+type ToolResultEntry = {
+	query?: string;
+	result?: string;
+	success?: boolean;
+};
+
+function isToolResultArray(value: unknown): value is ToolResultEntry[] {
+	return (
+		Array.isArray(value) &&
+		value.length > 0 &&
+		typeof value[0] === "object" &&
+		value[0] !== null &&
+		"result" in value[0]
+	);
+}
+
+type ExpandedToolEvent = {
+	id: string;
+	name: string;
+	title: string;
+	state: ToolEvent["state"];
+	output: string;
+	error?: string;
+};
+
+function formatInputSummary(input: unknown): string {
+	if (input == null) {
+		return "";
+	}
+	if (typeof input === "string") {
+		return input;
+	}
+	if (typeof input === "object") {
+		const values = Object.values(input as Record<string, unknown>);
+		return values
+			.filter((v) => typeof v === "string" || typeof v === "number")
+			.map(String)
+			.join(" ");
+	}
+	return String(input);
+}
+
+function formatRawOutput(output: unknown, fallback: string): string {
+	if (output == null) {
+		return fallback;
+	}
+	if (typeof output === "string") {
+		return output;
+	}
+	return JSON.stringify(output, null, 2);
+}
+
+function expandToolEvent(toolEvent: ToolEvent): ExpandedToolEvent[] {
+	if (isToolResultArray(toolEvent.output)) {
+		return toolEvent.output.map((entry, index) => {
+			const query = entry.query ?? "";
+			const title = query ? `${toolEvent.name}: ${query}` : toolEvent.name;
+			const state: ToolEvent["state"] =
+				entry.success === false ? "output-error" : toolEvent.state;
+			const output =
+				entry.result ?? (entry.success === false ? "(failed)" : "(no output)");
+			const error =
+				entry.success === false ? (entry.result ?? "failed") : undefined;
+			return {
+				id: `${toolEvent.id}-${index}`,
+				name: toolEvent.name,
+				title,
+				state,
+				output,
+				error,
+			};
+		});
+	}
+
+	const inputSummary = formatInputSummary(toolEvent.input);
+	const title = inputSummary
+		? `${toolEvent.name}: ${inputSummary}`
+		: toolEvent.name;
+
+	return [
+		{
+			id: toolEvent.id,
+			name: toolEvent.name,
+			title,
+			state: toolEvent.state,
+			output:
+				toolEvent.error ?? formatRawOutput(toolEvent.output, toolEvent.text),
+			error: toolEvent.error,
+		},
+	];
+}
+
+function extractToolName(text: string): string {
+	const runningMatch = /^Running (.+)\.\.\.$/.exec(text);
+	if (runningMatch?.[1]) {
+		return runningMatch[1];
+	}
+	const terminalMatch = /^(.+?) (completed|failed:.*)$/.exec(text);
+	return terminalMatch?.[1] ?? "tool";
+}
+
+function deriveToolState(text: string): ToolEvent["state"] {
+	if (text.includes("failed:")) {
+		return "output-error";
+	}
+	if (text.endsWith("completed")) {
+		return "output-available";
+	}
+	return "input-available";
+}
+
+function mapToolEventState(
+	event?: WebviewToolEvent,
+	fallbackText?: string,
+): ToolEvent["state"] {
+	if (event?.status === "failed") {
+		return "output-error";
+	}
+	if (event?.status === "completed") {
+		return "output-available";
+	}
+	if (event?.status === "running") {
+		return "input-available";
+	}
+	return deriveToolState(fallbackText ?? "");
+}
+
+function upsertToolEvent(events: ToolEvent[], next: ToolEvent): ToolEvent[] {
+	const existingIndex = events.findIndex(
+		(event) =>
+			(event.toolCallId &&
+				next.toolCallId &&
+				event.toolCallId === next.toolCallId) ||
+			(!event.toolCallId &&
+				!next.toolCallId &&
+				event.name === next.name &&
+				event.state === "input-available" &&
+				next.state !== "input-available"),
+	);
+
+	if (existingIndex === -1) {
+		return [...events, next];
+	}
+
+	return events.map((event, index) =>
+		index === existingIndex
+			? {
+					...event,
+					text: next.text,
+					state: next.state,
+					output: next.output,
+					error: next.error,
+				}
+			: event,
+	);
+}
+
+function appendToolEvent(
+	current: ChatMessage[],
+	text: string,
+	event: WebviewToolEvent | undefined,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	const activeAssistantId = activeAssistantIdRef.current;
+	const toolEvent: ToolEvent = {
+		id: nanoid(),
+		toolCallId: event?.toolCallId,
+		name: event?.toolName ?? extractToolName(text),
+		state: mapToolEventState(event, text),
+		text,
+		input: event?.input,
+		output: event?.output,
+		error: event?.error,
+	};
+
+	if (activeAssistantId) {
+		return current.map((message) =>
+			message.id === activeAssistantId
+				? {
+						...message,
+						toolEvents: upsertToolEvent(message.toolEvents ?? [], toolEvent),
+						blocks: upsertToolBlock(message.blocks, toolEvent),
+					}
+				: message,
+		);
+	}
+
+	return [
+		...current,
+		createMessage("meta", text, {
+			toolEvents: [toolEvent],
+			blocks: [{ id: nanoid(), type: "tool", toolEvent }],
+		}),
+	];
+}
+
+function mergeHydratedMessagesWithLive(
+	hydrated: ChatMessage[],
+	current: ChatMessage[],
+): ChatMessage[] {
+	if (current.length === 0) {
+		return hydrated;
+	}
+	const next = [...hydrated];
+	for (const live of current) {
+		const last = next.at(-1);
+		if (live.role === "assistant" && last?.role === "assistant") {
+			next[next.length - 1] = {
+				...last,
+				text: `${last.text}${live.text}`,
+				reasoning:
+					`${last.reasoning ?? ""}${live.reasoning ?? ""}` || undefined,
+				reasoningRedacted:
+					last.reasoningRedacted || live.reasoningRedacted || undefined,
+				toolEvents: [...(last.toolEvents ?? []), ...(live.toolEvents ?? [])],
+				blocks: [...(last.blocks ?? []), ...(live.blocks ?? [])],
+			};
+			continue;
+		}
+		if (
+			live.role === "meta" &&
+			last?.role === "meta" &&
+			(live.toolEvents?.length ?? 0) > 0
+		) {
+			next[next.length - 1] = {
+				...last,
+				text: live.text || last.text,
+				toolEvents: [...(last.toolEvents ?? []), ...(live.toolEvents ?? [])],
+				blocks: [...(last.blocks ?? []), ...(live.blocks ?? [])],
+			};
+			continue;
+		}
+		next.push(live);
+	}
+	return next;
+}
+
+function renderToolEvent(
+	toolEvent: ToolEvent,
+	className: string,
+): ReactElement[] {
+	return expandToolEvent(toolEvent).map((expanded) => (
+		<Tool className={className} key={expanded.id}>
+			<ToolHeader
+				state={expanded.state}
+				title={expanded.title}
+				type="dynamic-tool"
+				toolName={expanded.name}
+			/>
+			<ToolContent>
+				<ToolOutput errorText={expanded.error} output={expanded.output} />
+			</ToolContent>
+		</Tool>
+	));
+}
+
+function legacyMessageBlocks(message: ChatMessage): ChatMessageBlock[] {
+	const blocks: ChatMessageBlock[] = [];
+	for (const toolEvent of message.toolEvents ?? []) {
+		blocks.push({ id: `legacy-tool-${toolEvent.id}`, type: "tool", toolEvent });
+	}
+	if (message.reasoning) {
+		blocks.push({
+			id: `legacy-reasoning-${message.id}`,
+			type: "reasoning",
+			text: message.reasoning,
+			redacted: message.reasoningRedacted,
+		});
+	}
+	if (message.text) {
+		blocks.push({
+			id: `legacy-text-${message.id}`,
+			type: "text",
+			text: message.text,
+		});
+	}
+	return blocks;
+}
+
+function renderMessageBlocks(
+	message: ChatMessage,
+	options: { isMeta?: boolean; sending?: boolean },
+): ReactElement[] {
+	const blocks = message.blocks?.length
+		? message.blocks
+		: legacyMessageBlocks(message);
+	return blocks.flatMap((block) => {
+		switch (block.type) {
+			case "tool":
+				if (block.toolEvent.name.startsWith("team_")) {
+					return [
+						<TeamTasks
+							className={options.isMeta ? "mt-3 w-full" : "mb-3 w-full"}
+							events={[block.toolEvent] as TeamToolEvent[]}
+							key={block.id}
+						/>,
+					];
+				}
+				return renderToolEvent(
+					block.toolEvent,
+					options.isMeta ? "mt-3" : "mb-3",
+				);
+			case "reasoning":
+				return [
+					<Reasoning
+						className={options.isMeta ? "mt-3" : "mb-3"}
+						defaultOpen={false}
+						key={block.id}
+					>
+						<ReasoningTrigger />
+						<ReasoningContent>{block.text}</ReasoningContent>
+					</Reasoning>,
+				];
+			case "text":
+				if (options.isMeta) {
+					return [
+						<pre className="whitespace-pre-wrap font-inherit" key={block.id}>
+							{block.text}
+						</pre>,
+					];
+				}
+				return [
+					<MessageContent key={block.id}>
+						<MessageResponse>{block.text}</MessageResponse>
+					</MessageContent>,
+				];
+		}
+		return [];
+	});
+}
+
+function finalizeAssistantTurn(
+	current: ChatMessage[],
+	finishReason: string,
+	iterations: number,
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+	},
+): ChatMessage[] {
+	return [
+		...current,
+		createMessage(
+			"meta",
+			`Done (${finishReason}) • iterations=${iterations} • input=${usage?.inputTokens ?? 0} output=${usage?.outputTokens ?? 0}`,
+		),
+	];
+}
+
+function formatSessionLabel(session: WebviewSessionSummary): string {
+	const title = session.title?.trim() || session.sessionId.slice(0, 12);
+	const status = session.status?.trim();
+	const workspaceName = session.workspaceRoot?.trim()
+		? session.workspaceRoot.trim().split("/").pop()
+		: undefined;
+	return [title, status ? `(${status})` : undefined, workspaceName]
+		.filter(Boolean)
+		.join(" • ");
+}
+
+function formatCheckpointTime(createdAt: number): string {
+	try {
+		return new Intl.DateTimeFormat(undefined, {
+			month: "short",
+			day: "numeric",
+			hour: "numeric",
+			minute: "2-digit",
+		}).format(new Date(createdAt));
+	} catch {
+		return "Checkpoint";
+	}
+}
+
+export default function Chat() {
+	const [messages, setMessages] = useState<ChatMessage[]>([]);
+	const [status, setStatus] = useState("Waiting for RPC initialization...");
+	const [sessionId, setSessionId] = useState<string>();
+	const [sending, setSending] = useState(false);
+	const [providers, setProviders] = useState<ProviderOption[]>([]);
+	const [modelsByProvider, setModelsByProvider] = useState<
+		Record<string, WebviewProviderModel[]>
+	>({});
+	const [defaults, setDefaults] = useState<WebviewDefaults>({
+		workspaceRoot: "",
+		cwd: "",
+	});
+	const [sessions, setSessions] = useState<WebviewSessionSummary[]>([]);
+	const [sessionTitleDraft, setSessionTitleDraft] = useState("");
+	const [lastSelection, setLastSelection] =
+		useState<ModelSelectionStorage>(readModelSelection);
+	const [provider, setProvider] = useState(() => lastSelection.lastProvider);
+	const [model, setModel] = useState(
+		() => lastSelection.lastModelByProvider[lastSelection.lastProvider] ?? "",
+	);
+	const [systemPrompt, setSystemPrompt] = useState("");
+	const [maxIterations, setMaxIterations] = useState("");
+	const [mode, setMode] = useState<"act" | "plan">("act");
+	const [thinking, setThinking] = useState(false);
+	const [enableTools, setEnableTools] = useState(true);
+	const [enableSpawn, setEnableSpawn] = useState(true);
+	const [enableTeams, setEnableTeams] = useState(false);
+	const [autoApproveTools, setAutoApproveTools] = useState(true);
+	const [modelSelectorOpen, setModelSelectorOpen] = useState(false);
+	const [titleEditing, setTitleEditing] = useState(false);
+	const [forking, setForking] = useState(false);
+	const [forkError, setForkError] = useState<string | null>(null);
+	const activeAssistantIdRef = useRef<string | undefined>(undefined);
+	const lastSelectionRef = useRef(lastSelection);
+	const sessionsRef = useRef(sessions);
+	const defaultsRef = useRef(defaults);
+
+	useEffect(() => {
+		sessionsRef.current = sessions;
+	}, [sessions]);
+
+	useEffect(() => {
+		defaultsRef.current = defaults;
+	}, [defaults]);
+
+	useEffect(() => {
+		const handleMessage = (event: MessageEvent<WebviewOutboundMessage>) => {
+			const message = event.data;
+			if (!message || typeof message !== "object" || !("type" in message)) {
+				return;
+			}
+
+			switch (message.type) {
+				case "status":
+					setStatus(message.text);
+					return;
+				case "error":
+					setStatus(`Error: ${message.text}`);
+					setSending(false);
+					activeAssistantIdRef.current = undefined;
+					setMessages((current) => {
+						if (current.length === 0) {
+							return current;
+						}
+						const nextText = `Error: ${message.text}`;
+						const last = current.at(-1);
+						if (last?.role === "error" && last.text === nextText) {
+							return current;
+						}
+						return [...current, createMessage("error", nextText)];
+					});
+					return;
+				case "defaults":
+					setDefaults(message.defaults);
+					if (message.defaults.provider) {
+						setProvider(message.defaults.provider);
+					}
+					if (message.defaults.model) {
+						setModel(message.defaults.model);
+					}
+					return;
+				case "sessions":
+					setSessions(message.sessions);
+					return;
+				case "providers":
+					setProviders(message.providers);
+					setProvider((current) => {
+						const currentProvider =
+							current && message.providers.some((item) => item.id === current)
+								? current
+								: "";
+						const savedProvider = readModelSelection().lastProvider;
+						const nextProvider =
+							currentProvider ||
+							(savedProvider &&
+							message.providers.some((item) => item.id === savedProvider)
+								? savedProvider
+								: "") ||
+							message.providers.find((item) => item.enabled)?.id ||
+							message.providers[0]?.id ||
+							"";
+						if (nextProvider) {
+							postToHost({ type: "loadModels", providerId: nextProvider });
+						}
+						return nextProvider;
+					});
+					return;
+				case "models":
+					setModelsByProvider((current) => ({
+						...current,
+						[message.providerId]: message.models,
+					}));
+					setModel((current) => {
+						if (current && message.models.some((item) => item.id === current)) {
+							return current;
+						}
+						const nextDefaults = defaultsRef.current;
+						if (
+							nextDefaults.provider === message.providerId &&
+							nextDefaults.model &&
+							message.models.some((item) => item.id === nextDefaults.model)
+						) {
+							return nextDefaults.model;
+						}
+						const saved = readModelSelection();
+						const rememberedModel =
+							saved.lastModelByProvider[message.providerId];
+						if (
+							rememberedModel &&
+							message.models.some((item) => item.id === rememberedModel)
+						) {
+							return rememberedModel;
+						}
+						return message.models[0]?.id || "";
+					});
+					return;
+				case "session_started":
+					setSessionId(message.sessionId);
+					setTitleEditing(false);
+					setSessionTitleDraft("");
+					return;
+				case "session_hydrated":
+					setSessionId(message.sessionId);
+					setSending(message.status === "running");
+					if (message.providerId) {
+						setProvider(message.providerId);
+					}
+					if (message.providerId && message.modelId) {
+						const nextSelection: ModelSelectionStorage = {
+							lastProvider: message.providerId,
+							lastModelByProvider: {
+								...lastSelectionRef.current.lastModelByProvider,
+								[message.providerId]: message.modelId,
+							},
+						};
+						lastSelectionRef.current = nextSelection;
+						setLastSelection(nextSelection);
+						writeModelSelection(nextSelection);
+						setModel(message.modelId);
+					}
+					setTitleEditing(false);
+					setSessionTitleDraft(
+						sessionsRef.current
+							.find((item) => item.sessionId === message.sessionId)
+							?.title?.trim() || "",
+					);
+					setMessages((current) => {
+						const merged =
+							message.status === "running"
+								? mergeHydratedMessagesWithLive(
+										message.messages as ChatMessage[],
+										current,
+									)
+								: (message.messages as ChatMessage[]);
+						activeAssistantIdRef.current =
+							message.status === "running"
+								? [...merged]
+										.reverse()
+										.find((item) => item.role === "assistant")?.id
+								: undefined;
+						return merged;
+					});
+					setStatus(
+						message.status === "running"
+							? `Attached to ${message.sessionId} (running)`
+							: `Attached to ${message.sessionId}`,
+					);
+					return;
+				case "assistant_delta":
+					setMessages((current) =>
+						appendAssistantDelta(current, message.text, activeAssistantIdRef),
+					);
+					return;
+				case "reasoning_delta":
+					setMessages((current) =>
+						appendReasoningDelta(
+							current,
+							message.text,
+							message.redacted,
+							activeAssistantIdRef,
+						),
+					);
+					return;
+				case "tool_event":
+					setMessages((current) =>
+						appendToolEvent(
+							current,
+							message.text,
+							message.event,
+							activeAssistantIdRef,
+						),
+					);
+					return;
+				case "turn_done":
+					setStatus(`Done (${message.finishReason})`);
+					setSending(false);
+					activeAssistantIdRef.current = undefined;
+					setMessages((current) =>
+						finalizeAssistantTurn(
+							current,
+							message.finishReason,
+							message.iterations,
+							message.usage,
+						),
+					);
+					return;
+				case "reset_done":
+					setSessionId(undefined);
+					setSending(false);
+					setTitleEditing(false);
+					setSessionTitleDraft("");
+					activeAssistantIdRef.current = undefined;
+					setStatus("Started a new chat session.");
+					setMessages([]);
+					return;
+				case "fork_done":
+					setForking(false);
+					setForkError(null);
+					setStatus(`Forked → new session ${message.newSessionId}`);
+					return;
+				case "fork_error":
+					setForking(false);
+					setForkError(message.text);
+					setStatus(`Fork failed: ${message.text}`);
+					return;
+			}
+		};
+
+		window.addEventListener("message", handleMessage);
+		postToHost({ type: "ready" });
+		return () => {
+			window.removeEventListener("message", handleMessage);
+		};
+	}, []);
+
+	useEffect(() => {
+		if (provider) {
+			postToHost({ type: "loadModels", providerId: provider });
+		}
+	}, [provider]);
+
+	useEffect(() => {
+		if (!provider || !model) {
+			return;
+		}
+		const previous = lastSelectionRef.current;
+		if (
+			previous.lastProvider === provider &&
+			previous.lastModelByProvider[provider] === model
+		) {
+			return;
+		}
+		const nextSelection: ModelSelectionStorage = {
+			lastProvider: provider,
+			lastModelByProvider: {
+				...previous.lastModelByProvider,
+				[provider]: model,
+			},
+		};
+		lastSelectionRef.current = nextSelection;
+		setLastSelection(nextSelection);
+		writeModelSelection(nextSelection);
+	}, [provider, model]);
+
+	const models = modelsByProvider[provider] ?? [];
+	const thinkingEnabled =
+		thinking &&
+		models.find((item) => item.id === model)?.supportsThinking === true;
+	const visibleMessages = useMemo(
+		() => messages.filter((message) => message.role !== "meta" || message.text),
+		[messages],
+	);
+	const sessionTitle =
+		sessionId &&
+		typeof sessions.find((item) => item.sessionId === sessionId)?.title ===
+			"string"
+			? sessions.find((item) => item.sessionId === sessionId)?.title?.trim() ||
+				""
+			: "";
+	const displayedSessionTitle = titleEditing ? sessionTitleDraft : sessionTitle;
+
+	const commitSessionTitle = () => {
+		if (!sessionId) {
+			setTitleEditing(false);
+			return;
+		}
+		const normalized = sessionTitleDraft.replace(/\s+/g, " ").trim();
+		setTitleEditing(false);
+		if (normalized === sessionTitle) {
+			return;
+		}
+		setSessionTitleDraft(normalized);
+		postToHost({
+			type: "updateSessionMetadata",
+			sessionId,
+			metadata: {
+				title: normalized,
+			},
+		});
+	};
+
+	return (
+		<PromptInputProvider>
+			<div className="relative flex h-screen flex-col overflow-hidden">
+				<div className="flex items-center justify-between border-b px-4 py-3">
+					<div className="min-w-0">
+						<p className="text-[11px] uppercase tracking-[0.18em] text-muted-foreground">
+							Cline
+						</p>
+					</div>
+					<div className="flex items-center gap-2">
+						{sessions.length > 0 ? (
+							<select
+								className="max-w-48 rounded-md border bg-background px-2 py-1 text-xs"
+								onChange={(event) => {
+									const nextSessionId = event.target.value;
+									if (!nextSessionId) {
+										postToHost({ type: "reset" });
+										setStatus("Resetting session...");
+										return;
+									}
+									setMessages([]);
+									setSending(false);
+									activeAssistantIdRef.current = undefined;
+									setStatus(`Attaching to ${nextSessionId}...`);
+									postToHost({
+										type: "attachSession",
+										sessionId: nextSessionId,
+									});
+								}}
+								value={sessionId ?? ""}
+							>
+								<option value="">New session</option>
+								{sessions.map((item) => (
+									<option key={item.sessionId} value={item.sessionId}>
+										{formatSessionLabel(item)}
+									</option>
+								))}
+							</select>
+						) : null}
+						{sessionId ? (
+							<input
+								className="min-w-0 max-w-56 rounded-md border bg-muted px-2 py-1 text-xs"
+								onBlur={commitSessionTitle}
+								onChange={(event) => setSessionTitleDraft(event.target.value)}
+								onFocus={() => {
+									setTitleEditing(true);
+									setSessionTitleDraft(sessionTitle);
+								}}
+								onKeyDown={(event) => {
+									if (event.key === "Enter") {
+										event.preventDefault();
+										commitSessionTitle();
+									}
+								}}
+								placeholder="Session title"
+								value={displayedSessionTitle}
+							/>
+						) : null}
+						{sessionId ? (
+							<Button
+								onClick={() => {
+									setStatus(`Deleting ${sessionId}...`);
+									postToHost({ type: "deleteSession", sessionId });
+								}}
+								size="icon-sm"
+								type="button"
+								variant="ghost"
+							>
+								<Trash2Icon className="size-4" />
+								<span className="sr-only">Delete session</span>
+							</Button>
+						) : null}
+						<Button
+							onClick={() => {
+								postToHost({ type: "reset" });
+								setStatus("Resetting session...");
+							}}
+							size="icon-sm"
+							type="button"
+							variant="ghost"
+						>
+							<PlusIcon className="size-4" />
+							<span className="sr-only">New chat</span>
+						</Button>
+					</div>
+				</div>
+				<Conversation className="min-h-0 flex-1">
+					<ConversationContent className="px-4 py-5">
+						{visibleMessages.length === 0 ? (
+							<div className="flex h-full items-center align-middle justify-center rounded-xl border border-dashed px-6 py-16 text-center text-sm text-muted-foreground">
+								How can I help you?
+							</div>
+						) : null}
+						{visibleMessages.map((message) => {
+							if (message.role === "meta" || message.role === "error") {
+								return (
+									<div
+										className={cn(
+											"w-full rounded-lg border px-4 py-3 text-sm",
+											message.role === "error"
+												? "border-destructive/40 bg-destructive/10 text-destructive"
+												: "bg-muted/40 text-muted-foreground",
+										)}
+										key={message.id}
+									>
+										{renderMessageBlocks(message, { isMeta: true })}
+									</div>
+								);
+							}
+
+							return (
+								<Message from={message.role} key={message.id}>
+									<div>
+										{renderMessageBlocks(message, { sending })}
+										{message.role === "user" && message.checkpoint ? (
+											<Checkpoint className="mt-1 justify-end">
+												<CheckpointTrigger
+													className="h-6 gap-1 px-2 text-[11px] text-muted-foreground hover:text-foreground"
+													disabled={sending}
+													onClick={() => {
+														if (message.checkpoint) {
+															postToHost({
+																type: "restore",
+																checkpointRunCount: message.checkpoint.runCount,
+															});
+														}
+													}}
+													tooltip={`Checkpoint from run ${message.checkpoint.runCount}`}
+													type="button"
+													variant="ghost"
+												>
+													<CheckpointIcon className="size-3" />
+													{formatCheckpointTime(message.checkpoint.createdAt)}
+												</CheckpointTrigger>
+											</Checkpoint>
+										) : null}
+										{message.role === "assistant" && !sending ? (
+											<div className="mt-1 flex items-center gap-1">
+												<Button
+													className="h-6 gap-1 px-2 text-[11px] text-muted-foreground hover:text-foreground"
+													disabled={forking}
+													onClick={() => {
+														setForking(true);
+														setForkError(null);
+														postToHost({ type: "forkSession" });
+													}}
+													size="sm"
+													title="Fork session — copy full message history into a new session"
+													type="button"
+													variant="ghost"
+												>
+													{forking ? (
+														<Loader2Icon className="size-3 animate-spin" />
+													) : (
+														<GitBranchIcon className="size-3" />
+													)}
+													Fork
+												</Button>
+												{forkError ? (
+													<span className="text-[11px] text-destructive">
+														{forkError}
+													</span>
+												) : null}
+											</div>
+										) : null}
+									</div>
+								</Message>
+							);
+						})}
+					</ConversationContent>
+					<ConversationScrollButton />
+				</Conversation>
+				<Composer
+					autoApproveTools={autoApproveTools}
+					enableSpawn={enableSpawn}
+					enableTeams={enableTeams}
+					enableTools={enableTools}
+					maxIterations={maxIterations}
+					model={model}
+					mode={mode}
+					modelSelectorOpen={modelSelectorOpen}
+					models={models}
+					onAbort={() => {
+						postToHost({ type: "abort" });
+						setStatus("Abort requested...");
+					}}
+					onAutoApproveToolsChange={setAutoApproveTools}
+					onEnableSpawnChange={setEnableSpawn}
+					onEnableTeamsChange={setEnableTeams}
+					onEnableToolsChange={setEnableTools}
+					onModeChange={setMode}
+					onMaxIterationsChange={setMaxIterations}
+					onModelChange={setModel}
+					onModelSelectorOpenChange={setModelSelectorOpen}
+					onProviderChange={(nextProvider) => {
+						setProvider(nextProvider);
+						const rememberedModel =
+							lastSelection.lastModelByProvider[nextProvider];
+						const providerModelIds = (modelsByProvider[nextProvider] ?? []).map(
+							(item) => item.id,
+						);
+						if (rememberedModel && providerModelIds.includes(rememberedModel)) {
+							setModel(rememberedModel);
+							return;
+						}
+						setModel("");
+					}}
+					onSend={({ prompt, attachments, attachmentCount }) => {
+						const assistantMessage = createMessage("assistant", "");
+						activeAssistantIdRef.current = assistantMessage.id;
+						setMessages((current) => [
+							...current,
+							createMessage(
+								"user",
+								buildUserMessageLabel(prompt, attachments, attachmentCount),
+							),
+							assistantMessage,
+						]);
+						setSending(true);
+						setStatus("Running...");
+						postToHost({
+							type: "send",
+							prompt,
+							attachments,
+							config: {
+								autoApproveTools,
+								enableSpawn,
+								enableTeams,
+								enableTools,
+								maxIterations: parseMaxIterations(maxIterations),
+								model: model || undefined,
+								mode,
+								provider: provider || undefined,
+								systemPrompt: systemPrompt.trim() || undefined,
+								thinking: thinkingEnabled,
+							},
+						});
+					}}
+					onSystemPromptChange={setSystemPrompt}
+					onThinkingChange={setThinking}
+					provider={provider}
+					providers={providers}
+					sending={sending}
+					status={status}
+					systemPrompt={systemPrompt}
+					thinking={thinkingEnabled}
+					workspaceRoot={defaults.workspaceRoot}
+				/>
+			</div>
+		</PromptInputProvider>
+	);
+}
diff --git a/apps/examples/vscode/src/webview/src/components/Composer.tsx b/apps/examples/vscode/src/webview/src/components/Composer.tsx
new file mode 100644
index 0000000..e99f4be
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/Composer.tsx
@@ -0,0 +1,523 @@
+import {
+	BrainIcon,
+	CheckIcon,
+	PaperclipIcon,
+	Settings2Icon,
+} from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import {
+	Attachment,
+	AttachmentPreview,
+	AttachmentRemove,
+	Attachments,
+} from "@/components/ai-elements/attachments";
+import {
+	ModelSelector,
+	ModelSelectorContent,
+	ModelSelectorEmpty,
+	ModelSelectorGroup,
+	ModelSelectorInput,
+	ModelSelectorItem,
+	ModelSelectorList,
+	ModelSelectorLogo,
+	ModelSelectorLogoGroup,
+	ModelSelectorName,
+	ModelSelectorTrigger,
+} from "@/components/ai-elements/model-selector";
+import type { PromptInputMessage } from "@/components/ai-elements/prompt-input";
+import {
+	PromptInput,
+	PromptInputBody,
+	PromptInputButton,
+	PromptInputFooter,
+	PromptInputHeader,
+	PromptInputSubmit,
+	PromptInputTextarea,
+	PromptInputTools,
+	usePromptInputAttachments,
+	usePromptInputController,
+} from "@/components/ai-elements/prompt-input";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import type {
+	WebviewChatAttachments,
+	WebviewOutboundMessage,
+	WebviewProviderModel,
+} from "../../../webview-protocol";
+
+type ProviderOption = Extract<
+	WebviewOutboundMessage,
+	{ type: "providers" }
+>["providers"][number];
+
+function PromptAttachmentsDisplay() {
+	const attachments = usePromptInputAttachments();
+
+	if (attachments.files.length === 0) {
+		return null;
+	}
+
+	return (
+		<Attachments variant="inline">
+			{attachments.files.map((attachment) => (
+				<Attachment
+					data={attachment}
+					key={attachment.id}
+					onRemove={() => attachments.remove(attachment.id)}
+				>
+					<AttachmentPreview />
+					<AttachmentRemove />
+				</Attachment>
+			))}
+		</Attachments>
+	);
+}
+
+function ComposerSettings({
+	autoApproveTools,
+	enableSpawn,
+	enableTeams,
+	model,
+	modelSelectorOpen,
+	models,
+	onAutoApproveToolsChange,
+	onEnableSpawnChange,
+	onEnableTeamsChange,
+	onModelChange,
+	onModelSelectorOpenChange,
+	onProviderChange,
+	provider,
+	providers,
+	workspaceRoot,
+}: {
+	autoApproveTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	enableTools: boolean;
+	maxIterations: string;
+	model: string;
+	modelSelectorOpen: boolean;
+	models: WebviewProviderModel[];
+	onAutoApproveToolsChange: (value: boolean) => void;
+	onEnableSpawnChange: (value: boolean) => void;
+	onEnableTeamsChange: (value: boolean) => void;
+	onEnableToolsChange: (value: boolean) => void;
+	onMaxIterationsChange: (value: string) => void;
+	onModelChange: (value: string) => void;
+	onModelSelectorOpenChange: (value: boolean) => void;
+	onProviderChange: (value: string) => void;
+	onSystemPromptChange: (value: string) => void;
+	provider: string;
+	providers: ProviderOption[];
+	systemPrompt: string;
+	workspaceRoot: string;
+}) {
+	const selectedProvider = providers.find((item) => item.id === provider);
+	const selectedModel =
+		models.find((item) => item.id === model) ?? models[0] ?? undefined;
+
+	return (
+		<div className="grid gap-3 bg-background/70 p-3">
+			<div className="grid gap-2 md:grid-cols-2">
+				<div className="grid gap-2">
+					<Label className="text-xs uppercase tracking-[0.16em] text-muted-foreground">
+						Provider
+					</Label>
+					<Select
+						onValueChange={(value) => {
+							if (value) {
+								onProviderChange(value);
+							}
+						}}
+						value={provider}
+					>
+						<SelectTrigger className="w-full">
+							<SelectValue placeholder="Select provider" />
+						</SelectTrigger>
+						<SelectContent>
+							{providers.map((item) => (
+								<SelectItem key={item.id} value={item.id}>
+									<div className="flex items-center gap-2">
+										{renderProviderLogo(item.id)}
+										<span>{item.name}</span>
+									</div>
+								</SelectItem>
+							))}
+						</SelectContent>
+					</Select>
+				</div>
+				<div className="grid gap-2">
+					<Label className="text-xs uppercase tracking-[0.16em] text-muted-foreground">
+						Model
+					</Label>
+					<ModelSelector
+						onOpenChange={onModelSelectorOpenChange}
+						open={modelSelectorOpen}
+					>
+						<ModelSelectorTrigger>
+							<Button className="w-full justify-between" variant="outline">
+								<div className="flex min-w-0 items-center gap-2">
+									{selectedProvider && renderProviderLogo(selectedProvider.id)}
+									<span className="truncate">
+										{selectedModel?.name || selectedModel?.id || "Select model"}
+									</span>
+								</div>
+							</Button>
+						</ModelSelectorTrigger>
+						<ModelSelectorContent>
+							<ModelSelectorInput placeholder="Search models..." />
+							<ModelSelectorList>
+								<ModelSelectorEmpty>No models found.</ModelSelectorEmpty>
+								<ModelSelectorGroup
+									heading={selectedProvider?.name || "Models"}
+								>
+									{models.map((item) => (
+										<ModelSelectorItem
+											key={item.id}
+											onSelect={() => {
+												onModelChange(item.id);
+												onModelSelectorOpenChange(false);
+											}}
+											value={item.id}
+										>
+											{selectedProvider &&
+												renderProviderLogo(selectedProvider.id)}
+											<ModelSelectorName>
+												{item.name || item.id}
+											</ModelSelectorName>
+											<ModelSelectorLogoGroup>
+												{selectedProvider &&
+													renderProviderLogo(selectedProvider.id)}
+											</ModelSelectorLogoGroup>
+											{model === item.id ? (
+												<CheckIcon className="ml-auto size-4" />
+											) : (
+												<div className="ml-auto size-4" />
+											)}
+										</ModelSelectorItem>
+									))}
+								</ModelSelectorGroup>
+							</ModelSelectorList>
+						</ModelSelectorContent>
+					</ModelSelector>
+				</div>
+			</div>
+			<div className="grid gap-2 md:grid-cols-2">
+				<div className="grid gap-2">
+					<Label
+						className="text-xs uppercase tracking-[0.16em] text-muted-foreground"
+						htmlFor="workspace-root"
+					>
+						Workspace
+					</Label>
+					<Input id="workspace-root" readOnly value={workspaceRoot} />
+				</div>
+			</div>
+			<div className="grid gap-2 md:grid-cols-2">
+				<Toggle
+					checked={enableSpawn}
+					label="Subagents"
+					onChange={onEnableSpawnChange}
+				/>
+				<Toggle
+					checked={enableTeams}
+					label="Agent Teams"
+					onChange={onEnableTeamsChange}
+				/>
+				<Toggle
+					checked={autoApproveTools}
+					label="Auto-approves"
+					onChange={onAutoApproveToolsChange}
+				/>
+			</div>
+		</div>
+	);
+}
+
+function renderProviderLogo(providerId: string) {
+	return (
+		<ModelSelectorLogo className="size-3.5" provider={providerId || "openai"} />
+	);
+}
+
+function Toggle({
+	checked,
+	label,
+	onChange,
+	disabled,
+}: {
+	checked: boolean;
+	label: string;
+	onChange: (value: boolean) => void;
+	disabled?: boolean;
+}) {
+	return (
+		<div className="flex items-center justify-between rounded-lg border bg-background/60 px-3 py-2">
+			<Label className="text-sm" htmlFor={label}>
+				{label}
+			</Label>
+			<Switch
+				checked={checked}
+				id={label}
+				onCheckedChange={(value) => onChange(value)}
+				disabled={disabled}
+			/>
+		</div>
+	);
+}
+
+export function Composer({
+	autoApproveTools,
+	enableSpawn,
+	enableTeams,
+	enableTools,
+	maxIterations,
+	model,
+	mode,
+	modelSelectorOpen,
+	models,
+	onAbort,
+	onAutoApproveToolsChange,
+	onEnableSpawnChange,
+	onEnableTeamsChange,
+	onEnableToolsChange,
+	onModeChange,
+	onMaxIterationsChange,
+	onModelChange,
+	onModelSelectorOpenChange,
+	onProviderChange,
+	onSend,
+	onSystemPromptChange,
+	onThinkingChange,
+	provider,
+	providers,
+	sending,
+	status,
+	systemPrompt,
+	thinking,
+	workspaceRoot,
+}: {
+	autoApproveTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	enableTools: boolean;
+	maxIterations: string;
+	model: string;
+	mode: "act" | "plan";
+	modelSelectorOpen: boolean;
+	models: WebviewProviderModel[];
+	onAbort: () => void;
+	onAutoApproveToolsChange: (value: boolean) => void;
+	onEnableSpawnChange: (value: boolean) => void;
+	onEnableTeamsChange: (value: boolean) => void;
+	onEnableToolsChange: (value: boolean) => void;
+	onModeChange: (value: "act" | "plan") => void;
+	onMaxIterationsChange: (value: string) => void;
+	onModelChange: (value: string) => void;
+	onModelSelectorOpenChange: (value: boolean) => void;
+	onProviderChange: (value: string) => void;
+	onSend: (input: {
+		prompt: string;
+		attachments?: WebviewChatAttachments;
+		attachmentCount: number;
+	}) => void;
+	onSystemPromptChange: (value: string) => void;
+	onThinkingChange: (value: boolean) => void;
+	provider: string;
+	providers: ProviderOption[];
+	sending: boolean;
+	status: string;
+	systemPrompt: string;
+	thinking: boolean;
+	workspaceRoot: string;
+}) {
+	const [settingsOpen, setSettingsOpen] = useState(false);
+	const controller = usePromptInputController();
+	const attachments = usePromptInputAttachments();
+	const selectedModel = models.find((item) => item.id === model);
+	const thinkingSupported = selectedModel?.supportsThinking === true;
+
+	return (
+		<div className="border-t bg-background">
+			<PromptInput
+				accept="image/*,.txt,.md,.json,.ts,.tsx,.js,.jsx"
+				globalDrop
+				className="[&>div]:border-0 rounded-none"
+				maxFiles={8}
+				multiple
+				onError={(error) => toast.error(error.message)}
+				onSubmit={async (message: PromptInputMessage) => {
+					const prompt = message.text.trim();
+					if (!prompt && !message.files.length) {
+						return;
+					}
+
+					let attachments: WebviewChatAttachments | undefined;
+					if (message.files.length > 0) {
+						const userImages = (
+							await Promise.all(
+								message.files.map((file) => toImageDataUrl(file.url)),
+							)
+						).filter((value): value is string => Boolean(value));
+						if (userImages.length > 0) {
+							attachments = { userImages };
+						}
+						if (userImages.length !== message.files.length) {
+							toast.warning(
+								"Only image attachments are currently sent in the VS Code chat runtime.",
+							);
+						}
+					}
+
+					if (!prompt && !attachments?.userImages?.length) {
+						return;
+					}
+
+					onSend({
+						prompt,
+						attachments,
+						attachmentCount: message.files.length,
+					});
+				}}
+			>
+				<PromptInputHeader>
+					<PromptAttachmentsDisplay />
+				</PromptInputHeader>
+				<PromptInputBody>
+					<PromptInputTextarea
+						disabled={status.includes("Failed")}
+						onChange={(event) =>
+							controller.textInput.setInput(event.target.value)
+						}
+						placeholder="Enter your question here..."
+						value={controller.textInput.value}
+						className="text-sm"
+					/>
+				</PromptInputBody>
+				<PromptInputFooter className="flex-col items-stretch gap-1 px-0">
+					{settingsOpen ? (
+						<ComposerSettings
+							autoApproveTools={autoApproveTools}
+							enableSpawn={enableSpawn}
+							enableTeams={enableTeams}
+							enableTools={enableTools}
+							maxIterations={maxIterations}
+							model={model}
+							modelSelectorOpen={modelSelectorOpen}
+							models={models}
+							onAutoApproveToolsChange={onAutoApproveToolsChange}
+							onEnableSpawnChange={onEnableSpawnChange}
+							onEnableTeamsChange={onEnableTeamsChange}
+							onEnableToolsChange={onEnableToolsChange}
+							onMaxIterationsChange={onMaxIterationsChange}
+							onModelChange={onModelChange}
+							onModelSelectorOpenChange={onModelSelectorOpenChange}
+							onProviderChange={onProviderChange}
+							onSystemPromptChange={onSystemPromptChange}
+							provider={provider}
+							providers={providers}
+							systemPrompt={systemPrompt}
+							workspaceRoot={workspaceRoot}
+						/>
+					) : null}
+					<div className="flex items-center justify-between gap-3">
+						<PromptInputTools className="shrink-0">
+							<PromptInputButton
+								onClick={() => attachments.openFileDialog()}
+								type="button"
+								variant="ghost"
+							>
+								<PaperclipIcon className="size-3" />
+							</PromptInputButton>
+							<PromptInputButton
+								onClick={() => setSettingsOpen((open) => !open)}
+								type="button"
+								variant={settingsOpen ? "default" : "ghost"}
+							>
+								<Settings2Icon className="size-3" />
+								<span>
+									{provider}:{model}
+								</span>
+							</PromptInputButton>
+							<PromptInputButton
+								disabled={!thinkingSupported}
+								onClick={() => onThinkingChange(!thinking)}
+								type="button"
+								variant={thinking ? "default" : "ghost"}
+							>
+								<BrainIcon className="size-3" />
+							</PromptInputButton>
+							<PromptInputButton
+								onClick={() => onModeChange(mode === "act" ? "plan" : "act")}
+								type="button"
+								variant={mode === "plan" ? "default" : "ghost"}
+							>
+								{mode}
+							</PromptInputButton>
+							<Badge
+								className="rounded-sm px-3 py-1 text-xs hidden"
+								variant={status.includes("Error") ? "destructive" : "secondary"}
+							>
+								{status}
+							</Badge>
+						</PromptInputTools>
+						<div className="flex items-center gap-2">
+							{sending ? (
+								<Button onClick={onAbort} type="button" variant="destructive">
+									Abort
+								</Button>
+							) : null}
+							<PromptInputSubmit
+								disabled={status.includes("Failed")}
+								status={sending ? "submitted" : "ready"}
+								variant="ghost"
+							/>
+						</div>
+					</div>
+				</PromptInputFooter>
+			</PromptInput>
+		</div>
+	);
+}
+
+async function toImageDataUrl(
+	url: string | undefined,
+): Promise<string | undefined> {
+	if (!url) {
+		return undefined;
+	}
+	if (url.startsWith("data:image/")) {
+		return url;
+	}
+	if (!url.startsWith("blob:")) {
+		return undefined;
+	}
+	try {
+		const response = await fetch(url);
+		const blob = await response.blob();
+		if (!blob.type.startsWith("image/")) {
+			return undefined;
+		}
+		return await new Promise((resolve) => {
+			const reader = new FileReader();
+			reader.onloadend = () => {
+				resolve(typeof reader.result === "string" ? reader.result : undefined);
+			};
+			reader.onerror = () => resolve(undefined);
+			reader.readAsDataURL(blob);
+		});
+	} catch {
+		return undefined;
+	}
+}
diff --git a/apps/examples/vscode/src/webview/src/components/TeamTasks.tsx b/apps/examples/vscode/src/webview/src/components/TeamTasks.tsx
new file mode 100644
index 0000000..c703177
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/TeamTasks.tsx
@@ -0,0 +1,241 @@
+"use client";
+
+import { UsersIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	Task,
+	TaskContent,
+	TaskItem,
+	TaskTrigger,
+} from "@/components/ai-elements/task";
+
+export type TeamToolEvent = {
+	id: string;
+	name: string;
+	state: "input-available" | "output-available" | "output-error";
+	input?: unknown;
+	output?: unknown;
+	error?: string;
+};
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asStringArray(value: unknown): string[] | undefined {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: undefined;
+}
+
+function prefixForState(state: TeamToolEvent["state"]): string {
+	if (state === "output-error") {
+		return "Failed";
+	}
+	if (state === "output-available") {
+		return "Done";
+	}
+	return "Running";
+}
+
+function summarizeTeamTool(event: TeamToolEvent): ReactNode {
+	const input = asRecord(event.input);
+	const output = asRecord(event.output);
+	const statePrefix = prefixForState(event.state);
+
+	switch (event.name) {
+		case "team_spawn_teammate":
+			return `${statePrefix} spawn teammate ${asString(input?.agentId) ?? asString(output?.agentId) ?? "agent"}`;
+		case "team_shutdown_teammate":
+			return `${statePrefix} shutdown teammate ${asString(input?.agentId) ?? asString(output?.agentId) ?? "agent"}`;
+		case "team_status":
+			return `${statePrefix} fetch team status`;
+		case "team_task": {
+			const action = asString(input?.action);
+			if (action === "create") {
+				return `${statePrefix} create task ${asString(output?.taskId) ?? ""}${asString(input?.title) ? `: ${asString(input?.title)}` : ""}`.trim();
+			}
+			if (action === "list") {
+				return `${statePrefix} list team tasks`;
+			}
+			if (action === "claim") {
+				return `${statePrefix} claim task ${asString(input?.taskId) ?? asString(output?.taskId) ?? ""}`.trim();
+			}
+			if (action === "complete") {
+				return `${statePrefix} complete task ${asString(input?.taskId) ?? asString(output?.taskId) ?? ""}`.trim();
+			}
+			if (action === "block") {
+				return `${statePrefix} block task ${asString(input?.taskId) ?? asString(output?.taskId) ?? ""}`.trim();
+			}
+			return `${statePrefix} update team task`;
+		}
+		case "team_run_task": {
+			const agentId =
+				asString(input?.agentId) ?? asString(output?.agentId) ?? "agent";
+			const mode = asString(output?.mode) ?? asString(input?.runMode);
+			const status = asString(output?.status);
+			const task = asString(input?.task);
+			const suffix = task ? `: ${task}` : "";
+			const action =
+				mode === "async" ? "queue" : status === "joined" ? "join" : "run";
+			const state = status ? ` (${status})` : "";
+			return `${statePrefix} ${action} task with ${agentId}${state}${suffix}`;
+		}
+		case "team_cancel_run":
+			return `${statePrefix} cancel run ${asString(input?.runId) ?? asString(output?.runId) ?? ""}`.trim();
+		case "team_list_runs":
+			return `${statePrefix} list teammate runs`;
+		case "team_await_run":
+			return `${statePrefix} await run ${asString(input?.runId) ?? ""}`.trim();
+		case "team_await_all_runs":
+			return `${statePrefix} await all active runs`;
+		case "team_send_message":
+			return `${statePrefix} message ${asString(input?.toAgentId) ?? asString(output?.toAgentId) ?? "agent"}${asString(input?.subject) ? `: ${asString(input?.subject)}` : ""}`;
+		case "team_broadcast":
+			return `${statePrefix} broadcast${asString(input?.subject) ? `: ${asString(input?.subject)}` : ""}`;
+		case "team_read_mailbox":
+			return `${statePrefix} read mailbox`;
+		case "team_mission_log":
+			return `${statePrefix} log ${asString(input?.kind) ?? "update"}${asString(input?.summary) ? `: ${asString(input?.summary)}` : ""}`;
+		case "team_cleanup":
+			return `${statePrefix} clean up team runtime`;
+		case "team_create_outcome":
+			return `${statePrefix} create outcome${asString(input?.title) ? `: ${asString(input?.title)}` : ""}`;
+		case "team_attach_outcome_fragment":
+			return `${statePrefix} attach fragment to ${asString(input?.section) ?? "section"}`;
+		case "team_review_outcome_fragment":
+			return `${statePrefix} ${input?.approved === false ? "reject" : "review"} fragment ${asString(input?.fragmentId) ?? ""}`.trim();
+		case "team_finalize_outcome":
+			return `${statePrefix} finalize outcome ${asString(input?.outcomeId) ?? asString(output?.outcomeId) ?? ""}`.trim();
+		case "team_list_outcomes":
+			return `${statePrefix} list outcomes`;
+		default:
+			return `${statePrefix} ${event.name.replace(/^team_/, "").replaceAll("_", " ")}`;
+	}
+}
+
+function describeTeamTool(event: TeamToolEvent): string | undefined {
+	if (event.error) {
+		return event.error;
+	}
+
+	const input = asRecord(event.input);
+	const output = asRecord(event.output);
+
+	switch (event.name) {
+		case "team_task": {
+			const action = asString(input?.action);
+			if (action === "create") {
+				return asString(input?.description);
+			}
+			if (action === "block") {
+				return asString(input?.reason);
+			}
+			if (action === "list") {
+				const tasks = Array.isArray(output?.tasks)
+					? output.tasks.length
+					: undefined;
+				return typeof tasks === "number"
+					? `${tasks} task${tasks === 1 ? "" : "s"}`
+					: undefined;
+			}
+			return undefined;
+		}
+		case "team_run_task":
+			return (
+				asString(output?.message) ??
+				asString(output?.runId) ??
+				asString(output?.text)
+			);
+		case "team_send_message":
+		case "team_broadcast":
+			return asString(input?.body);
+		case "team_mission_log":
+			return asString(input?.nextAction) ?? asString(input?.summary);
+		case "team_attach_outcome_fragment":
+			return asString(input?.content);
+		case "team_status": {
+			const members = Array.isArray(output?.members)
+				? output.members.length
+				: undefined;
+			const tasks = Array.isArray(output?.tasks)
+				? output.tasks.length
+				: undefined;
+			const runs = Array.isArray(output?.runs) ? output.runs.length : undefined;
+			const parts = [
+				typeof members === "number" ? `${members} members` : undefined,
+				typeof tasks === "number" ? `${tasks} tasks` : undefined,
+				typeof runs === "number" ? `${runs} runs` : undefined,
+			].filter(Boolean);
+			return parts.join(" • ") || undefined;
+		}
+		case "team_list_runs": {
+			const runs = Array.isArray(event.output) ? event.output : undefined;
+			if (!runs?.length) {
+				return "No runs";
+			}
+			return `${runs.length} run${runs.length === 1 ? "" : "s"}`;
+		}
+		case "team_read_mailbox": {
+			const messages = Array.isArray(event.output) ? event.output : undefined;
+			if (!messages?.length) {
+				return "No messages";
+			}
+			return `${messages.length} message${messages.length === 1 ? "" : "s"}`;
+		}
+		case "team_create_outcome": {
+			const sections = asStringArray(input?.requiredSections);
+			return sections?.length ? sections.join(", ") : undefined;
+		}
+		default:
+			return undefined;
+	}
+}
+
+export default function TeamTasks({
+	className,
+	defaultOpen = true,
+	events,
+	...props
+}: Omit<ComponentProps<typeof Task>, "children"> & {
+	events: TeamToolEvent[];
+}) {
+	if (events.length === 0) {
+		return null;
+	}
+
+	const title =
+		events.length === 1 ? "Team activity" : `Team activity (${events.length})`;
+
+	return (
+		<Task className={className} defaultOpen={defaultOpen} {...props}>
+			<TaskTrigger title={title}>
+				<div className="flex w-full cursor-pointer items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground">
+					<UsersIcon className="size-4" />
+					<p className="text-sm">{title}</p>
+				</div>
+			</TaskTrigger>
+			<TaskContent>
+				{events.map((event) => {
+					const description = describeTeamTool(event);
+					return (
+						<TaskItem className="space-y-1" key={event.id}>
+							<div>{summarizeTeamTool(event)}</div>
+							{description ? (
+								<div className="line-clamp-3 text-xs text-muted-foreground/90">
+									{description}
+								</div>
+							) : null}
+						</TaskItem>
+					);
+				})}
+			</TaskContent>
+		</Task>
+	);
+}
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/agent.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/agent.tsx
new file mode 100644
index 0000000..51b62c3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/agent.tsx
@@ -0,0 +1,141 @@
+"use client";
+
+import type { Tool } from "ai";
+import { BotIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { memo } from "react";
+import {
+	Accordion,
+	AccordionContent,
+	AccordionItem,
+	AccordionTrigger,
+} from "@/components/ui/accordion";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+import { CodeBlock } from "./code-block";
+
+export type AgentProps = ComponentProps<"div">;
+
+export const Agent = memo(({ className, ...props }: AgentProps) => (
+	<div
+		className={cn("not-prose w-full rounded-md border", className)}
+		{...props}
+	/>
+));
+
+export type AgentHeaderProps = ComponentProps<"div"> & {
+	name: string;
+	model?: string;
+};
+
+export const AgentHeader = memo(
+	({ className, name, model, ...props }: AgentHeaderProps) => (
+		<div
+			className={cn(
+				"flex w-full items-center justify-between gap-4 p-3",
+				className,
+			)}
+			{...props}
+		>
+			<div className="flex items-center gap-2">
+				<BotIcon className="size-4 text-muted-foreground" />
+				<span className="font-medium text-sm">{name}</span>
+				{model && (
+					<Badge className="font-mono text-xs" variant="secondary">
+						{model}
+					</Badge>
+				)}
+			</div>
+		</div>
+	),
+);
+
+export type AgentContentProps = ComponentProps<"div">;
+
+export const AgentContent = memo(
+	({ className, ...props }: AgentContentProps) => (
+		<div className={cn("space-y-4 p-4 pt-0", className)} {...props} />
+	),
+);
+
+export type AgentInstructionsProps = ComponentProps<"div"> & {
+	children: string;
+};
+
+export const AgentInstructions = memo(
+	({ className, children, ...props }: AgentInstructionsProps) => (
+		<div className={cn("space-y-2", className)} {...props}>
+			<span className="font-medium text-muted-foreground text-sm">
+				Instructions
+			</span>
+			<div className="rounded-md bg-muted/50 p-3 text-muted-foreground text-sm">
+				<p>{children}</p>
+			</div>
+		</div>
+	),
+);
+
+export type AgentToolsProps = ComponentProps<typeof Accordion>;
+
+export const AgentTools = memo(({ className, ...props }: AgentToolsProps) => (
+	<div className={cn("space-y-2", className)}>
+		<span className="font-medium text-muted-foreground text-sm">Tools</span>
+		<Accordion className="rounded-md border" {...props} />
+	</div>
+));
+
+export type AgentToolProps = ComponentProps<typeof AccordionItem> & {
+	tool: Tool;
+};
+
+export const AgentTool = memo(
+	({ className, tool, value, ...props }: AgentToolProps) => {
+		const schema =
+			"jsonSchema" in tool && tool.jsonSchema
+				? tool.jsonSchema
+				: tool.inputSchema;
+
+		return (
+			<AccordionItem
+				className={cn("border-b last:border-b-0", className)}
+				value={value}
+				{...props}
+			>
+				<AccordionTrigger className="px-3 py-2 text-sm hover:no-underline">
+					{tool.description ?? "No description"}
+				</AccordionTrigger>
+				<AccordionContent className="px-3 pb-3">
+					<div className="rounded-md bg-muted/50">
+						<CodeBlock code={JSON.stringify(schema, null, 2)} language="json" />
+					</div>
+				</AccordionContent>
+			</AccordionItem>
+		);
+	},
+);
+
+export type AgentOutputProps = ComponentProps<"div"> & {
+	schema: string;
+};
+
+export const AgentOutput = memo(
+	({ className, schema, ...props }: AgentOutputProps) => (
+		<div className={cn("space-y-2", className)} {...props}>
+			<span className="font-medium text-muted-foreground text-sm">
+				Output Schema
+			</span>
+			<div className="rounded-md bg-muted/50">
+				<CodeBlock code={schema} language="typescript" />
+			</div>
+		</div>
+	),
+);
+
+Agent.displayName = "Agent";
+AgentHeader.displayName = "AgentHeader";
+AgentContent.displayName = "AgentContent";
+AgentInstructions.displayName = "AgentInstructions";
+AgentTools.displayName = "AgentTools";
+AgentTool.displayName = "AgentTool";
+AgentOutput.displayName = "AgentOutput";
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/artifact.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/artifact.tsx
new file mode 100644
index 0000000..6005180
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/artifact.tsx
@@ -0,0 +1,148 @@
+"use client";
+
+import type { LucideIcon } from "lucide-react";
+import { XIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export type ArtifactProps = HTMLAttributes<HTMLDivElement>;
+
+export const Artifact = ({ className, ...props }: ArtifactProps) => (
+	<div
+		className={cn(
+			"flex flex-col overflow-hidden rounded-lg border bg-background shadow-sm",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ArtifactHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const ArtifactHeader = ({
+	className,
+	...props
+}: ArtifactHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b bg-muted/50 px-4 py-3",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ArtifactCloseProps = ComponentProps<typeof Button>;
+
+export const ArtifactClose = ({
+	className,
+	children,
+	size = "sm",
+	variant = "ghost",
+	...props
+}: ArtifactCloseProps) => (
+	<Button
+		className={cn(
+			"size-8 p-0 text-muted-foreground hover:text-foreground",
+			className,
+		)}
+		size={size}
+		type="button"
+		variant={variant}
+		{...props}
+	>
+		{children ?? <XIcon className="size-4" />}
+		<span className="sr-only">Close</span>
+	</Button>
+);
+
+export type ArtifactTitleProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const ArtifactTitle = ({ className, ...props }: ArtifactTitleProps) => (
+	<p
+		className={cn("font-medium text-foreground text-sm", className)}
+		{...props}
+	/>
+);
+
+export type ArtifactDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const ArtifactDescription = ({
+	className,
+	...props
+}: ArtifactDescriptionProps) => (
+	<p className={cn("text-muted-foreground text-sm", className)} {...props} />
+);
+
+export type ArtifactActionsProps = HTMLAttributes<HTMLDivElement>;
+
+export const ArtifactActions = ({
+	className,
+	...props
+}: ArtifactActionsProps) => (
+	<div className={cn("flex items-center gap-1", className)} {...props} />
+);
+
+export type ArtifactActionProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+	label?: string;
+	icon?: LucideIcon;
+};
+
+export const ArtifactAction = ({
+	tooltip,
+	label,
+	icon: Icon,
+	children,
+	className,
+	size = "sm",
+	variant = "ghost",
+	...props
+}: ArtifactActionProps) => {
+	const button = (
+		<Button
+			className={cn(
+				"size-8 p-0 text-muted-foreground hover:text-foreground",
+				className,
+			)}
+			size={size}
+			type="button"
+			variant={variant}
+			{...props}
+		>
+			{Icon ? <Icon className="size-4" /> : children}
+			<span className="sr-only">{label || tooltip}</span>
+		</Button>
+	);
+
+	if (tooltip) {
+		return (
+			<TooltipProvider>
+				<Tooltip>
+					<TooltipTrigger>{button}</TooltipTrigger>
+					<TooltipContent>
+						<p>{tooltip}</p>
+					</TooltipContent>
+				</Tooltip>
+			</TooltipProvider>
+		);
+	}
+
+	return button;
+};
+
+export type ArtifactContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const ArtifactContent = ({
+	className,
+	...props
+}: ArtifactContentProps) => (
+	<div className={cn("flex-1 overflow-auto p-4", className)} {...props} />
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/attachments.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/attachments.tsx
new file mode 100644
index 0000000..dcf2285
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/attachments.tsx
@@ -0,0 +1,425 @@
+"use client";
+
+import type { FileUIPart, SourceDocumentUIPart } from "ai";
+import {
+	FileTextIcon,
+	GlobeIcon,
+	ImageIcon,
+	Music2Icon,
+	PaperclipIcon,
+	VideoIcon,
+	XIcon,
+} from "lucide-react";
+import type { ComponentProps, HTMLAttributes, ReactNode } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { cn } from "@/lib/utils";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type AttachmentData =
+	| (FileUIPart & { id: string })
+	| (SourceDocumentUIPart & { id: string });
+
+export type AttachmentMediaCategory =
+	| "image"
+	| "video"
+	| "audio"
+	| "document"
+	| "source"
+	| "unknown";
+
+export type AttachmentVariant = "grid" | "inline" | "list";
+
+const mediaCategoryIcons: Record<AttachmentMediaCategory, typeof ImageIcon> = {
+	audio: Music2Icon,
+	document: FileTextIcon,
+	image: ImageIcon,
+	source: GlobeIcon,
+	unknown: PaperclipIcon,
+	video: VideoIcon,
+};
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+export const getMediaCategory = (
+	data: AttachmentData,
+): AttachmentMediaCategory => {
+	if (data.type === "source-document") {
+		return "source";
+	}
+
+	const mediaType = data.mediaType ?? "";
+
+	if (mediaType.startsWith("image/")) {
+		return "image";
+	}
+	if (mediaType.startsWith("video/")) {
+		return "video";
+	}
+	if (mediaType.startsWith("audio/")) {
+		return "audio";
+	}
+	if (mediaType.startsWith("application/") || mediaType.startsWith("text/")) {
+		return "document";
+	}
+
+	return "unknown";
+};
+
+export const getAttachmentLabel = (data: AttachmentData): string => {
+	if (data.type === "source-document") {
+		return data.title || data.filename || "Source";
+	}
+
+	const category = getMediaCategory(data);
+	return data.filename || (category === "image" ? "Image" : "Attachment");
+};
+
+const renderAttachmentImage = (
+	url: string,
+	filename: string | undefined,
+	isGrid: boolean,
+) =>
+	isGrid ? (
+		<img
+			alt={filename || "Image"}
+			className="size-full object-cover"
+			height={96}
+			src={url}
+			width={96}
+		/>
+	) : (
+		<img
+			alt={filename || "Image"}
+			className="size-full rounded object-cover"
+			height={20}
+			src={url}
+			width={20}
+		/>
+	);
+
+// ============================================================================
+// Contexts
+// ============================================================================
+
+interface AttachmentsContextValue {
+	variant: AttachmentVariant;
+}
+
+const AttachmentsContext = createContext<AttachmentsContextValue | null>(null);
+
+interface AttachmentContextValue {
+	data: AttachmentData;
+	mediaCategory: AttachmentMediaCategory;
+	onRemove?: () => void;
+	variant: AttachmentVariant;
+}
+
+const AttachmentContext = createContext<AttachmentContextValue | null>(null);
+
+// ============================================================================
+// Hooks
+// ============================================================================
+
+export const useAttachmentsContext = () =>
+	useContext(AttachmentsContext) ?? { variant: "grid" as const };
+
+export const useAttachmentContext = () => {
+	const ctx = useContext(AttachmentContext);
+	if (!ctx) {
+		throw new Error("Attachment components must be used within <Attachment>");
+	}
+	return ctx;
+};
+
+// ============================================================================
+// Attachments - Container
+// ============================================================================
+
+export type AttachmentsProps = HTMLAttributes<HTMLDivElement> & {
+	variant?: AttachmentVariant;
+};
+
+export const Attachments = ({
+	variant = "grid",
+	className,
+	children,
+	...props
+}: AttachmentsProps) => {
+	const contextValue = useMemo(() => ({ variant }), [variant]);
+
+	return (
+		<AttachmentsContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex items-start",
+					variant === "list" ? "flex-col gap-2" : "flex-wrap gap-2",
+					variant === "grid" && "ml-auto w-fit",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		</AttachmentsContext.Provider>
+	);
+};
+
+// ============================================================================
+// Attachment - Item
+// ============================================================================
+
+export type AttachmentProps = HTMLAttributes<HTMLDivElement> & {
+	data: AttachmentData;
+	onRemove?: () => void;
+};
+
+export const Attachment = ({
+	data,
+	onRemove,
+	className,
+	children,
+	...props
+}: AttachmentProps) => {
+	const { variant } = useAttachmentsContext();
+	const mediaCategory = getMediaCategory(data);
+
+	const contextValue = useMemo<AttachmentContextValue>(
+		() => ({ data, mediaCategory, onRemove, variant }),
+		[data, mediaCategory, onRemove, variant],
+	);
+
+	return (
+		<AttachmentContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"group relative",
+					variant === "grid" && "size-24 overflow-hidden rounded-lg",
+					variant === "inline" && [
+						"flex h-8 cursor-pointer select-none items-center gap-1.5",
+						"rounded-md border border-border px-1.5",
+						"font-medium text-sm transition-all",
+						"hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+					],
+					variant === "list" && [
+						"flex w-full items-center gap-3 rounded-lg border p-3",
+						"hover:bg-accent/50",
+					],
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		</AttachmentContext.Provider>
+	);
+};
+
+// ============================================================================
+// AttachmentPreview - Media preview
+// ============================================================================
+
+export type AttachmentPreviewProps = HTMLAttributes<HTMLDivElement> & {
+	fallbackIcon?: ReactNode;
+};
+
+export const AttachmentPreview = ({
+	fallbackIcon,
+	className,
+	...props
+}: AttachmentPreviewProps) => {
+	const { data, mediaCategory, variant } = useAttachmentContext();
+
+	const iconSize = variant === "inline" ? "size-3" : "size-4";
+
+	const renderIcon = (Icon: typeof ImageIcon) => (
+		<Icon className={cn(iconSize, "text-muted-foreground")} />
+	);
+
+	const renderContent = () => {
+		if (mediaCategory === "image" && data.type === "file" && data.url) {
+			return renderAttachmentImage(data.url, data.filename, variant === "grid");
+		}
+
+		if (mediaCategory === "video" && data.type === "file" && data.url) {
+			return <video className="size-full object-cover" muted src={data.url} />;
+		}
+
+		const Icon = mediaCategoryIcons[mediaCategory];
+		return fallbackIcon ?? renderIcon(Icon);
+	};
+
+	return (
+		<div
+			className={cn(
+				"flex shrink-0 items-center justify-center overflow-hidden",
+				variant === "grid" && "size-full bg-muted",
+				variant === "inline" && "size-5 rounded bg-background",
+				variant === "list" && "size-12 rounded bg-muted",
+				className,
+			)}
+			{...props}
+		>
+			{renderContent()}
+		</div>
+	);
+};
+
+// ============================================================================
+// AttachmentInfo - Name and type display
+// ============================================================================
+
+export type AttachmentInfoProps = HTMLAttributes<HTMLDivElement> & {
+	showMediaType?: boolean;
+};
+
+export const AttachmentInfo = ({
+	showMediaType = false,
+	className,
+	...props
+}: AttachmentInfoProps) => {
+	const { data, variant } = useAttachmentContext();
+	const label = getAttachmentLabel(data);
+
+	if (variant === "grid") {
+		return null;
+	}
+
+	return (
+		<div className={cn("min-w-0 flex-1", className)} {...props}>
+			<span className="block truncate">{label}</span>
+			{showMediaType && data.mediaType && (
+				<span className="block truncate text-muted-foreground text-xs">
+					{data.mediaType}
+				</span>
+			)}
+		</div>
+	);
+};
+
+// ============================================================================
+// AttachmentRemove - Remove button
+// ============================================================================
+
+export type AttachmentRemoveProps = ComponentProps<typeof Button> & {
+	label?: string;
+};
+
+export const AttachmentRemove = ({
+	label = "Remove",
+	className,
+	children,
+	...props
+}: AttachmentRemoveProps) => {
+	const { onRemove, variant } = useAttachmentContext();
+
+	const handleClick = useCallback(
+		(e: React.MouseEvent) => {
+			e.stopPropagation();
+			onRemove?.();
+		},
+		[onRemove],
+	);
+
+	if (!onRemove) {
+		return null;
+	}
+
+	return (
+		<Button
+			aria-label={label}
+			className={cn(
+				variant === "grid" && [
+					"absolute top-2 right-2 size-6 rounded-full p-0",
+					"bg-background/80 backdrop-blur-sm",
+					"opacity-0 transition-opacity group-hover:opacity-100",
+					"hover:bg-background",
+					"[&>svg]:size-3",
+				],
+				variant === "inline" && [
+					"size-5 rounded p-0",
+					"opacity-0 transition-opacity group-hover:opacity-100",
+					"[&>svg]:size-2.5",
+				],
+				variant === "list" && ["size-8 shrink-0 rounded p-0", "[&>svg]:size-4"],
+				className,
+			)}
+			onClick={handleClick}
+			type="button"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <XIcon />}
+			<span className="sr-only">{label}</span>
+		</Button>
+	);
+};
+
+// ============================================================================
+// AttachmentHoverCard - Hover preview
+// ============================================================================
+
+export type AttachmentHoverCardProps = ComponentProps<typeof HoverCard> & {
+	openDelay?: number;
+	closeDelay?: number;
+};
+
+export const AttachmentHoverCard = ({ ...props }: AttachmentHoverCardProps) => (
+	<HoverCard {...props} />
+);
+
+export type AttachmentHoverCardTriggerProps = ComponentProps<
+	typeof HoverCardTrigger
+>;
+
+export const AttachmentHoverCardTrigger = (
+	props: AttachmentHoverCardTriggerProps,
+) => <HoverCardTrigger {...props} />;
+
+export type AttachmentHoverCardContentProps = ComponentProps<
+	typeof HoverCardContent
+>;
+
+export const AttachmentHoverCardContent = ({
+	align = "start",
+	className,
+	...props
+}: AttachmentHoverCardContentProps) => (
+	<HoverCardContent
+		align={align}
+		className={cn("w-auto p-2", className)}
+		{...props}
+	/>
+);
+
+// ============================================================================
+// AttachmentEmpty - Empty state
+// ============================================================================
+
+export type AttachmentEmptyProps = HTMLAttributes<HTMLDivElement>;
+
+export const AttachmentEmpty = ({
+	className,
+	children,
+	...props
+}: AttachmentEmptyProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-center p-4 text-muted-foreground text-sm",
+			className,
+		)}
+		{...props}
+	>
+		{children ?? "No attachments"}
+	</div>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/audio-player.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/audio-player.tsx
new file mode 100644
index 0000000..8181f7f
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/audio-player.tsx
@@ -0,0 +1,255 @@
+"use client";
+
+import type { Experimental_SpeechResult as SpeechResult } from "ai";
+import {
+	MediaControlBar,
+	MediaController,
+	MediaDurationDisplay,
+	MediaMuteButton,
+	MediaPlayButton,
+	MediaSeekBackwardButton,
+	MediaSeekForwardButton,
+	MediaTimeDisplay,
+	MediaTimeRange,
+	MediaVolumeRange,
+} from "media-chrome/react";
+import type { ComponentProps, CSSProperties } from "react";
+import { Button } from "@/components/ui/button";
+import { ButtonGroup, ButtonGroupText } from "@/components/ui/button-group";
+import { cn } from "@/lib/utils";
+
+export type AudioPlayerProps = Omit<
+	ComponentProps<typeof MediaController>,
+	"audio"
+>;
+
+export const AudioPlayer = ({
+	children,
+	style,
+	...props
+}: AudioPlayerProps) => (
+	<MediaController
+		audio
+		data-slot="audio-player"
+		style={
+			{
+				"--media-background-color": "transparent",
+				"--media-button-icon-height": "1rem",
+				"--media-button-icon-width": "1rem",
+				"--media-control-background": "transparent",
+				"--media-control-hover-background": "var(--color-accent)",
+				"--media-control-padding": "0",
+				"--media-font": "var(--font-sans)",
+				"--media-font-size": "10px",
+				"--media-icon-color": "currentColor",
+				"--media-preview-time-background": "var(--color-background)",
+				"--media-preview-time-border-radius": "var(--radius-md)",
+				"--media-preview-time-text-shadow": "none",
+				"--media-primary-color": "var(--color-primary)",
+				"--media-range-bar-color": "var(--color-primary)",
+				"--media-range-track-background": "var(--color-secondary)",
+				"--media-secondary-color": "var(--color-secondary)",
+				"--media-text-color": "var(--color-foreground)",
+				"--media-tooltip-arrow-display": "none",
+				"--media-tooltip-background": "var(--color-background)",
+				"--media-tooltip-border-radius": "var(--radius-md)",
+				...style,
+			} as CSSProperties
+		}
+		{...props}
+	>
+		{children}
+	</MediaController>
+);
+
+export type AudioPlayerElementProps = Omit<ComponentProps<"audio">, "src"> &
+	(
+		| {
+				data: SpeechResult["audio"];
+		  }
+		| {
+				src: string;
+		  }
+	);
+
+export const AudioPlayerElement = ({ ...props }: AudioPlayerElementProps) => (
+	// oxlint-disable-next-line eslint-plugin-jsx-a11y(media-has-caption) -- audio player captions are provided by consumer
+	<audio
+		data-slot="audio-player-element"
+		slot="media"
+		src={
+			"src" in props
+				? props.src
+				: `data:${props.data.mediaType};base64,${props.data.base64}`
+		}
+		{...props}
+	/>
+);
+
+export type AudioPlayerControlBarProps = ComponentProps<typeof MediaControlBar>;
+
+export const AudioPlayerControlBar = ({
+	children,
+	...props
+}: AudioPlayerControlBarProps) => (
+	<MediaControlBar data-slot="audio-player-control-bar" {...props}>
+		<ButtonGroup orientation="horizontal">{children}</ButtonGroup>
+	</MediaControlBar>
+);
+
+export type AudioPlayerPlayButtonProps = ComponentProps<typeof MediaPlayButton>;
+
+export const AudioPlayerPlayButton = ({
+	className,
+	...props
+}: AudioPlayerPlayButtonProps) => (
+	<Button
+		size="icon-sm"
+		variant="outline"
+		render={
+			<MediaPlayButton
+				className={cn("bg-transparent", className)}
+				data-slot="audio-player-play-button"
+				{...props}
+			/>
+		}
+	></Button>
+);
+
+export type AudioPlayerSeekBackwardButtonProps = ComponentProps<
+	typeof MediaSeekBackwardButton
+>;
+
+export const AudioPlayerSeekBackwardButton = ({
+	seekOffset = 10,
+	...props
+}: AudioPlayerSeekBackwardButtonProps) => (
+	<Button
+		size="icon-sm"
+		variant="outline"
+		render={
+			<MediaSeekBackwardButton
+				data-slot="audio-player-seek-backward-button"
+				seekOffset={seekOffset}
+				{...props}
+			/>
+		}
+	></Button>
+);
+
+export type AudioPlayerSeekForwardButtonProps = ComponentProps<
+	typeof MediaSeekForwardButton
+>;
+
+export const AudioPlayerSeekForwardButton = ({
+	seekOffset = 10,
+	...props
+}: AudioPlayerSeekForwardButtonProps) => (
+	<Button
+		size="icon-sm"
+		variant="outline"
+		render={
+			<MediaSeekForwardButton
+				data-slot="audio-player-seek-forward-button"
+				seekOffset={seekOffset}
+				{...props}
+			/>
+		}
+	></Button>
+);
+
+export type AudioPlayerTimeDisplayProps = ComponentProps<
+	typeof MediaTimeDisplay
+>;
+
+export const AudioPlayerTimeDisplay = ({
+	className,
+	...props
+}: AudioPlayerTimeDisplayProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaTimeDisplay
+				className={cn("tabular-nums", className)}
+				data-slot="audio-player-time-display"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerTimeRangeProps = ComponentProps<typeof MediaTimeRange>;
+
+export const AudioPlayerTimeRange = ({
+	className,
+	...props
+}: AudioPlayerTimeRangeProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaTimeRange
+				className={cn("", className)}
+				data-slot="audio-player-time-range"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerDurationDisplayProps = ComponentProps<
+	typeof MediaDurationDisplay
+>;
+
+export const AudioPlayerDurationDisplay = ({
+	className,
+	...props
+}: AudioPlayerDurationDisplayProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaDurationDisplay
+				className={cn("tabular-nums", className)}
+				data-slot="audio-player-duration-display"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerMuteButtonProps = ComponentProps<typeof MediaMuteButton>;
+
+export const AudioPlayerMuteButton = ({
+	className,
+	...props
+}: AudioPlayerMuteButtonProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaMuteButton
+				className={cn("", className)}
+				data-slot="audio-player-mute-button"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
+
+export type AudioPlayerVolumeRangeProps = ComponentProps<
+	typeof MediaVolumeRange
+>;
+
+export const AudioPlayerVolumeRange = ({
+	className,
+	...props
+}: AudioPlayerVolumeRangeProps) => (
+	<ButtonGroupText
+		className="bg-transparent"
+		render={
+			<MediaVolumeRange
+				className={cn("", className)}
+				data-slot="audio-player-volume-range"
+				{...props}
+			/>
+		}
+	></ButtonGroupText>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/canvas.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/canvas.tsx
new file mode 100644
index 0000000..be0eb8c
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/canvas.tsx
@@ -0,0 +1,26 @@
+import type { ReactFlowProps } from "@xyflow/react";
+import { Background, ReactFlow } from "@xyflow/react";
+import type { ReactNode } from "react";
+
+import "@xyflow/react/dist/style.css";
+
+type CanvasProps = ReactFlowProps & {
+	children?: ReactNode;
+};
+
+const deleteKeyCode = ["Backspace", "Delete"];
+
+export const Canvas = ({ children, ...props }: CanvasProps) => (
+	<ReactFlow
+		deleteKeyCode={deleteKeyCode}
+		fitView
+		panOnDrag={false}
+		panOnScroll
+		selectionOnDrag={true}
+		zoomOnDoubleClick={false}
+		{...props}
+	>
+		<Background bgColor="var(--sidebar)" />
+		{children}
+	</ReactFlow>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/chain-of-thought.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/chain-of-thought.tsx
new file mode 100644
index 0000000..a668118
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/chain-of-thought.tsx
@@ -0,0 +1,222 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import type { LucideIcon } from "lucide-react";
+import { BrainIcon, ChevronDownIcon, DotIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, memo, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+interface ChainOfThoughtContextValue {
+	isOpen: boolean;
+	setIsOpen: (open: boolean) => void;
+}
+
+const ChainOfThoughtContext = createContext<ChainOfThoughtContextValue | null>(
+	null,
+);
+
+const useChainOfThought = () => {
+	const context = useContext(ChainOfThoughtContext);
+	if (!context) {
+		throw new Error(
+			"ChainOfThought components must be used within ChainOfThought",
+		);
+	}
+	return context;
+};
+
+export type ChainOfThoughtProps = ComponentProps<"div"> & {
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+};
+
+export const ChainOfThought = memo(
+	({
+		className,
+		open,
+		defaultOpen = false,
+		onOpenChange,
+		children,
+		...props
+	}: ChainOfThoughtProps) => {
+		const [isOpen, setIsOpen] = useControllableState({
+			defaultProp: defaultOpen,
+			onChange: onOpenChange,
+			prop: open,
+		});
+
+		const chainOfThoughtContext = useMemo(
+			() => ({ isOpen, setIsOpen }),
+			[isOpen, setIsOpen],
+		);
+
+		return (
+			<ChainOfThoughtContext.Provider value={chainOfThoughtContext}>
+				<div className={cn("not-prose w-full space-y-4", className)} {...props}>
+					{children}
+				</div>
+			</ChainOfThoughtContext.Provider>
+		);
+	},
+);
+
+export type ChainOfThoughtHeaderProps = ComponentProps<
+	typeof CollapsibleTrigger
+>;
+
+export const ChainOfThoughtHeader = memo(
+	({ className, children, ...props }: ChainOfThoughtHeaderProps) => {
+		const { isOpen, setIsOpen } = useChainOfThought();
+
+		return (
+			<Collapsible onOpenChange={setIsOpen} open={isOpen}>
+				<CollapsibleTrigger
+					className={cn(
+						"flex w-full items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground",
+						className,
+					)}
+					{...props}
+				>
+					<BrainIcon className="size-4" />
+					<span className="flex-1 text-left">
+						{children ?? "Chain of Thought"}
+					</span>
+					<ChevronDownIcon
+						className={cn(
+							"size-4 transition-transform",
+							isOpen ? "rotate-180" : "rotate-0",
+						)}
+					/>
+				</CollapsibleTrigger>
+			</Collapsible>
+		);
+	},
+);
+
+export type ChainOfThoughtStepProps = ComponentProps<"div"> & {
+	icon?: LucideIcon;
+	label: ReactNode;
+	description?: ReactNode;
+	status?: "complete" | "active" | "pending";
+};
+
+const stepStatusStyles = {
+	active: "text-foreground",
+	complete: "text-muted-foreground",
+	pending: "text-muted-foreground/50",
+};
+
+export const ChainOfThoughtStep = memo(
+	({
+		className,
+		icon: Icon = DotIcon,
+		label,
+		description,
+		status = "complete",
+		children,
+		...props
+	}: ChainOfThoughtStepProps) => (
+		<div
+			className={cn(
+				"flex gap-2 text-sm",
+				stepStatusStyles[status],
+				"fade-in-0 slide-in-from-top-2 animate-in",
+				className,
+			)}
+			{...props}
+		>
+			<div className="relative mt-0.5">
+				<Icon className="size-4" />
+				<div className="absolute top-7 bottom-0 left-1/2 -mx-px w-px bg-border" />
+			</div>
+			<div className="flex-1 space-y-2 overflow-hidden">
+				<div>{label}</div>
+				{description && (
+					<div className="text-muted-foreground text-xs">{description}</div>
+				)}
+				{children}
+			</div>
+		</div>
+	),
+);
+
+export type ChainOfThoughtSearchResultsProps = ComponentProps<"div">;
+
+export const ChainOfThoughtSearchResults = memo(
+	({ className, ...props }: ChainOfThoughtSearchResultsProps) => (
+		<div
+			className={cn("flex flex-wrap items-center gap-2", className)}
+			{...props}
+		/>
+	),
+);
+
+export type ChainOfThoughtSearchResultProps = ComponentProps<typeof Badge>;
+
+export const ChainOfThoughtSearchResult = memo(
+	({ className, children, ...props }: ChainOfThoughtSearchResultProps) => (
+		<Badge
+			className={cn("gap-1 px-2 py-0.5 font-normal text-xs", className)}
+			variant="secondary"
+			{...props}
+		>
+			{children}
+		</Badge>
+	),
+);
+
+export type ChainOfThoughtContentProps = ComponentProps<
+	typeof CollapsibleContent
+>;
+
+export const ChainOfThoughtContent = memo(
+	({ className, children, ...props }: ChainOfThoughtContentProps) => {
+		const { isOpen } = useChainOfThought();
+
+		return (
+			<Collapsible open={isOpen}>
+				<CollapsibleContent
+					className={cn(
+						"mt-2 space-y-3",
+						"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+				</CollapsibleContent>
+			</Collapsible>
+		);
+	},
+);
+
+export type ChainOfThoughtImageProps = ComponentProps<"div"> & {
+	caption?: string;
+};
+
+export const ChainOfThoughtImage = memo(
+	({ className, children, caption, ...props }: ChainOfThoughtImageProps) => (
+		<div className={cn("mt-2 space-y-2", className)} {...props}>
+			<div className="relative flex max-h-[22rem] items-center justify-center overflow-hidden rounded-lg bg-muted p-3">
+				{children}
+			</div>
+			{caption && <p className="text-muted-foreground text-xs">{caption}</p>}
+		</div>
+	),
+);
+
+ChainOfThought.displayName = "ChainOfThought";
+ChainOfThoughtHeader.displayName = "ChainOfThoughtHeader";
+ChainOfThoughtStep.displayName = "ChainOfThoughtStep";
+ChainOfThoughtSearchResults.displayName = "ChainOfThoughtSearchResults";
+ChainOfThoughtSearchResult.displayName = "ChainOfThoughtSearchResult";
+ChainOfThoughtContent.displayName = "ChainOfThoughtContent";
+ChainOfThoughtImage.displayName = "ChainOfThoughtImage";
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/checkpoint.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/checkpoint.tsx
new file mode 100644
index 0000000..ba0bc30
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/checkpoint.tsx
@@ -0,0 +1,73 @@
+"use client";
+
+import type { LucideProps } from "lucide-react";
+import { BookmarkIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { Button } from "@/components/ui/button";
+import { Separator } from "@/components/ui/separator";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export type CheckpointProps = HTMLAttributes<HTMLDivElement>;
+
+export const Checkpoint = ({
+	className,
+	children,
+	...props
+}: CheckpointProps) => (
+	<div
+		className={cn(
+			"flex items-center gap-0.5 overflow-hidden text-muted-foreground",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+		<Separator />
+	</div>
+);
+
+export type CheckpointIconProps = LucideProps;
+
+export const CheckpointIcon = ({
+	className,
+	children,
+	...props
+}: CheckpointIconProps) =>
+	children ?? (
+		<BookmarkIcon className={cn("size-4 shrink-0", className)} {...props} />
+	);
+
+export type CheckpointTriggerProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+};
+
+export const CheckpointTrigger = ({
+	children,
+	variant = "ghost",
+	size = "sm",
+	tooltip,
+	...props
+}: CheckpointTriggerProps) =>
+	tooltip ? (
+		<Tooltip>
+			<TooltipTrigger
+				render={
+					<Button size={size} type="button" variant={variant} {...props} />
+				}
+			>
+				{children}
+			</TooltipTrigger>
+			<TooltipContent align="start" side="bottom">
+				{tooltip}
+			</TooltipContent>
+		</Tooltip>
+	) : (
+		<Button size={size} type="button" variant={variant} {...props}>
+			{children}
+		</Button>
+	);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/code-block.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/code-block.tsx
new file mode 100644
index 0000000..770885b
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/code-block.tsx
@@ -0,0 +1,558 @@
+import { CheckIcon, CopyIcon } from "lucide-react";
+import type { ComponentProps, CSSProperties, HTMLAttributes } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import type {
+	BundledLanguage,
+	BundledTheme,
+	HighlighterGeneric,
+	ThemedToken,
+} from "shiki";
+import { createHighlighter } from "shiki";
+import { Button } from "@/components/ui/button";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { cn } from "@/lib/utils";
+
+// Shiki uses bitflags for font styles: 1=italic, 2=bold, 4=underline
+// oxlint-disable-next-line eslint(no-bitwise)
+const isItalic = (fontStyle: number | undefined) => fontStyle && fontStyle & 1;
+// oxlint-disable-next-line eslint(no-bitwise)
+const isBold = (fontStyle: number | undefined) => fontStyle && fontStyle & 2;
+const isUnderline = (fontStyle: number | undefined) =>
+	// oxlint-disable-next-line eslint(no-bitwise)
+	fontStyle && fontStyle & 4;
+
+// Transform tokens to include pre-computed keys to avoid noArrayIndexKey lint
+interface KeyedToken {
+	token: ThemedToken;
+	key: string;
+}
+interface KeyedLine {
+	tokens: KeyedToken[];
+	key: string;
+}
+
+const addKeysToTokens = (lines: ThemedToken[][]): KeyedLine[] =>
+	lines.map((line, lineIdx) => ({
+		key: `line-${lineIdx}`,
+		tokens: line.map((token, tokenIdx) => ({
+			key: `line-${lineIdx}-${tokenIdx}`,
+			token,
+		})),
+	}));
+
+// Token rendering component
+const TokenSpan = ({ token }: { token: ThemedToken }) => (
+	<span
+		className="dark:bg-(--shiki-dark-bg)! dark:text-(--shiki-dark)!"
+		style={
+			{
+				backgroundColor: token.bgColor,
+				color: token.color,
+				fontStyle: isItalic(token.fontStyle) ? "italic" : undefined,
+				fontWeight: isBold(token.fontStyle) ? "bold" : undefined,
+				textDecoration: isUnderline(token.fontStyle) ? "underline" : undefined,
+				...token.htmlStyle,
+			} as CSSProperties
+		}
+	>
+		{token.content}
+	</span>
+);
+
+// Line number styles using CSS counters
+const LINE_NUMBER_CLASSES = cn(
+	"block",
+	"before:content-[counter(line)]",
+	"before:inline-block",
+	"before:[counter-increment:line]",
+	"before:w-8",
+	"before:mr-4",
+	"before:text-right",
+	"before:text-muted-foreground/50",
+	"before:font-mono",
+	"before:select-none",
+);
+
+// Line rendering component
+const LineSpan = ({
+	keyedLine,
+	showLineNumbers,
+}: {
+	keyedLine: KeyedLine;
+	showLineNumbers: boolean;
+}) => (
+	<span className={showLineNumbers ? LINE_NUMBER_CLASSES : "block"}>
+		{keyedLine.tokens.length === 0
+			? "\n"
+			: keyedLine.tokens.map(({ token, key }) => (
+					<TokenSpan key={key} token={token} />
+				))}
+	</span>
+);
+
+// Types
+type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
+	code: string;
+	language: BundledLanguage;
+	showLineNumbers?: boolean;
+};
+
+interface TokenizedCode {
+	tokens: ThemedToken[][];
+	fg: string;
+	bg: string;
+}
+
+interface CodeBlockContextType {
+	code: string;
+}
+
+// Context
+const CodeBlockContext = createContext<CodeBlockContextType>({
+	code: "",
+});
+
+// Highlighter cache (singleton per language)
+const highlighterCache = new Map<
+	string,
+	Promise<HighlighterGeneric<BundledLanguage, BundledTheme>>
+>();
+
+// Token cache
+const tokensCache = new Map<string, TokenizedCode>();
+
+// Subscribers for async token updates
+const subscribers = new Map<string, Set<(result: TokenizedCode) => void>>();
+
+const getTokensCacheKey = (code: string, language: BundledLanguage) => {
+	const start = code.slice(0, 100);
+	const end = code.length > 100 ? code.slice(-100) : "";
+	return `${language}:${code.length}:${start}:${end}`;
+};
+
+const getHighlighter = (
+	language: BundledLanguage,
+): Promise<HighlighterGeneric<BundledLanguage, BundledTheme>> => {
+	const cached = highlighterCache.get(language);
+	if (cached) {
+		return cached;
+	}
+
+	const highlighterPromise = createHighlighter({
+		langs: [language],
+		themes: ["github-light", "github-dark"],
+	});
+
+	highlighterCache.set(language, highlighterPromise);
+	return highlighterPromise;
+};
+
+// Create raw tokens for immediate display while highlighting loads
+const createRawTokens = (code: string): TokenizedCode => ({
+	bg: "transparent",
+	fg: "inherit",
+	tokens: code.split("\n").map((line) =>
+		line === ""
+			? []
+			: [
+					{
+						color: "inherit",
+						content: line,
+					} as ThemedToken,
+				],
+	),
+});
+
+// Synchronous highlight with callback for async results
+export const highlightCode = (
+	code: string,
+	language: BundledLanguage,
+	// oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-callbacks)
+	callback?: (result: TokenizedCode) => void,
+): TokenizedCode | null => {
+	const tokensCacheKey = getTokensCacheKey(code, language);
+
+	// Return cached result if available
+	const cached = tokensCache.get(tokensCacheKey);
+	if (cached) {
+		return cached;
+	}
+
+	// Subscribe callback if provided
+	if (callback) {
+		if (!subscribers.has(tokensCacheKey)) {
+			subscribers.set(tokensCacheKey, new Set());
+		}
+		subscribers.get(tokensCacheKey)?.add(callback);
+	}
+
+	// Start highlighting in background - fire-and-forget async pattern
+	getHighlighter(language)
+		// oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-then)
+		.then((highlighter) => {
+			const availableLangs = highlighter.getLoadedLanguages();
+			const langToUse = availableLangs.includes(language) ? language : "text";
+
+			const result = highlighter.codeToTokens(code, {
+				lang: langToUse,
+				themes: {
+					dark: "github-dark",
+					light: "github-light",
+				},
+			});
+
+			const tokenized: TokenizedCode = {
+				bg: result.bg ?? "transparent",
+				fg: result.fg ?? "inherit",
+				tokens: result.tokens,
+			};
+
+			// Cache the result
+			tokensCache.set(tokensCacheKey, tokenized);
+
+			// Notify all subscribers
+			const subs = subscribers.get(tokensCacheKey);
+			if (subs) {
+				for (const sub of subs) {
+					sub(tokenized);
+				}
+				subscribers.delete(tokensCacheKey);
+			}
+		})
+		// oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-then), eslint-plugin-promise(prefer-await-to-callbacks)
+		.catch((error) => {
+			console.error("Failed to highlight code:", error);
+			subscribers.delete(tokensCacheKey);
+		});
+
+	return null;
+};
+
+const CodeBlockBody = memo(
+	({
+		tokenized,
+		showLineNumbers,
+		className,
+	}: {
+		tokenized: TokenizedCode;
+		showLineNumbers: boolean;
+		className?: string;
+	}) => {
+		const preStyle = useMemo(
+			() => ({
+				backgroundColor: tokenized.bg,
+				color: tokenized.fg,
+			}),
+			[tokenized.bg, tokenized.fg],
+		);
+
+		const keyedLines = useMemo(
+			() => addKeysToTokens(tokenized.tokens),
+			[tokenized.tokens],
+		);
+
+		return (
+			<pre
+				className={cn(
+					"dark:bg-(--shiki-dark-bg)! dark:text-(--shiki-dark)! m-0 p-4 text-sm",
+					className,
+				)}
+				style={preStyle}
+			>
+				<code
+					className={cn(
+						"font-mono text-sm",
+						showLineNumbers &&
+							"[counter-increment:line_0] [counter-reset:line]",
+					)}
+				>
+					{keyedLines.map((keyedLine) => (
+						<LineSpan
+							key={keyedLine.key}
+							keyedLine={keyedLine}
+							showLineNumbers={showLineNumbers}
+						/>
+					))}
+				</code>
+			</pre>
+		);
+	},
+	(prevProps, nextProps) =>
+		prevProps.tokenized === nextProps.tokenized &&
+		prevProps.showLineNumbers === nextProps.showLineNumbers &&
+		prevProps.className === nextProps.className,
+);
+
+CodeBlockBody.displayName = "CodeBlockBody";
+
+export const CodeBlockContainer = ({
+	className,
+	language,
+	style,
+	...props
+}: HTMLAttributes<HTMLDivElement> & { language: string }) => (
+	<div
+		className={cn(
+			"group relative w-full overflow-hidden rounded-sm border bg-background text-foreground",
+			className,
+		)}
+		data-language={language}
+		style={{
+			containIntrinsicSize: "auto 200px",
+			contentVisibility: "auto",
+			...style,
+		}}
+		{...props}
+	/>
+);
+
+export const CodeBlockHeader = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLDivElement>) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b bg-muted/80 px-3 py-2 text-muted-foreground text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export const CodeBlockTitle = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLDivElement>) => (
+	<div className={cn("flex items-center gap-2", className)} {...props}>
+		{children}
+	</div>
+);
+
+export const CodeBlockFilename = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLSpanElement>) => (
+	<span className={cn("font-mono", className)} {...props}>
+		{children}
+	</span>
+);
+
+export const CodeBlockActions = ({
+	children,
+	className,
+	...props
+}: HTMLAttributes<HTMLDivElement>) => (
+	<div
+		className={cn("-my-1 -mr-1 flex items-center gap-2", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export const CodeBlockContent = ({
+	code,
+	language,
+	showLineNumbers = false,
+}: {
+	code: string;
+	language: BundledLanguage;
+	showLineNumbers?: boolean;
+}) => {
+	// Memoized raw tokens for immediate display
+	const rawTokens = useMemo(() => createRawTokens(code), [code]);
+
+	// Synchronous cache lookup — avoids setState in effect for cached results
+	const syncTokens = useMemo(
+		() => highlightCode(code, language) ?? rawTokens,
+		[code, language, rawTokens],
+	);
+
+	// Async highlighting — keyed by identity-stable memo so stale tokens are
+	// discarded without reading a ref during render or setState in effect body.
+	const asyncKey = useMemo(() => ({ code, language }), [code, language]);
+	const [asyncState, setAsyncState] = useState<{
+		key: { code: string; language: string };
+		tokens: TokenizedCode | null;
+	}>({ key: asyncKey, tokens: null });
+
+	const asyncTokens = asyncState.key === asyncKey ? asyncState.tokens : null;
+
+	useEffect(() => {
+		let cancelled = false;
+
+		highlightCode(code, language, (result) => {
+			if (!cancelled) {
+				setAsyncState({ key: asyncKey, tokens: result });
+			}
+		});
+
+		return () => {
+			cancelled = true;
+		};
+	}, [code, language, asyncKey]);
+
+	const tokenized = asyncTokens ?? syncTokens;
+
+	return (
+		<div className="relative overflow-auto">
+			<CodeBlockBody showLineNumbers={showLineNumbers} tokenized={tokenized} />
+		</div>
+	);
+};
+
+export const CodeBlock = ({
+	code,
+	language,
+	showLineNumbers = false,
+	className,
+	children,
+	...props
+}: CodeBlockProps) => {
+	const contextValue = useMemo(() => ({ code }), [code]);
+
+	return (
+		<CodeBlockContext.Provider value={contextValue}>
+			<CodeBlockContainer className={className} language={language} {...props}>
+				{children}
+				<CodeBlockContent
+					code={code}
+					language={language}
+					showLineNumbers={showLineNumbers}
+				/>
+			</CodeBlockContainer>
+		</CodeBlockContext.Provider>
+	);
+};
+
+export type CodeBlockCopyButtonProps = ComponentProps<typeof Button> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const CodeBlockCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: CodeBlockCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { code } = useContext(CodeBlockContext);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			if (!isCopied) {
+				await navigator.clipboard.writeText(code);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			}
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [code, onCopy, onError, timeout, isCopied]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn("shrink-0", className)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={14} />}
+		</Button>
+	);
+};
+
+export type CodeBlockLanguageSelectorProps = ComponentProps<typeof Select>;
+
+export const CodeBlockLanguageSelector = (
+	props: CodeBlockLanguageSelectorProps,
+) => <Select {...props} />;
+
+export type CodeBlockLanguageSelectorTriggerProps = ComponentProps<
+	typeof SelectTrigger
+>;
+
+export const CodeBlockLanguageSelectorTrigger = ({
+	className,
+	...props
+}: CodeBlockLanguageSelectorTriggerProps) => (
+	<SelectTrigger
+		className={cn(
+			"h-7 border-none bg-transparent px-2 text-xs shadow-none",
+			className,
+		)}
+		size="sm"
+		{...props}
+	/>
+);
+
+export type CodeBlockLanguageSelectorValueProps = ComponentProps<
+	typeof SelectValue
+>;
+
+export const CodeBlockLanguageSelectorValue = (
+	props: CodeBlockLanguageSelectorValueProps,
+) => <SelectValue {...props} />;
+
+export type CodeBlockLanguageSelectorContentProps = ComponentProps<
+	typeof SelectContent
+>;
+
+export const CodeBlockLanguageSelectorContent = ({
+	align = "end",
+	...props
+}: CodeBlockLanguageSelectorContentProps) => (
+	<SelectContent align={align} {...props} />
+);
+
+export type CodeBlockLanguageSelectorItemProps = ComponentProps<
+	typeof SelectItem
+>;
+
+export const CodeBlockLanguageSelectorItem = (
+	props: CodeBlockLanguageSelectorItemProps,
+) => <SelectItem {...props} />;
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/commit.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/commit.tsx
new file mode 100644
index 0000000..84947a6
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/commit.tsx
@@ -0,0 +1,462 @@
+"use client";
+
+import {
+	CheckIcon,
+	CopyIcon,
+	FileIcon,
+	GitCommitIcon,
+	MinusIcon,
+	PlusIcon,
+} from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Avatar, AvatarFallback } from "@/components/ui/avatar";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+export type CommitProps = ComponentProps<typeof Collapsible>;
+
+export const Commit = ({ className, children, ...props }: CommitProps) => (
+	<Collapsible
+		className={cn("rounded-lg border bg-background", className)}
+		{...props}
+	>
+		{children}
+	</Collapsible>
+);
+
+export type CommitHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+
+export const CommitHeader = ({
+	className,
+	children,
+	...props
+}: CommitHeaderProps) => (
+	<CollapsibleTrigger
+		{...props}
+		render={
+			<div
+				className={cn(
+					"group flex cursor-pointer items-center justify-between gap-4 p-3 text-left transition-colors hover:opacity-80",
+					className,
+				)}
+			/>
+		}
+	>
+		{children}
+	</CollapsibleTrigger>
+);
+
+export type CommitHashProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitHash = ({
+	className,
+	children,
+	...props
+}: CommitHashProps) => (
+	<span className={cn("font-mono text-xs", className)} {...props}>
+		<GitCommitIcon className="mr-1 inline-block size-3" />
+		{children}
+	</span>
+);
+
+export type CommitMessageProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitMessage = ({
+	className,
+	children,
+	...props
+}: CommitMessageProps) => (
+	<span className={cn("font-medium text-sm", className)} {...props}>
+		{children}
+	</span>
+);
+
+export type CommitMetadataProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitMetadata = ({
+	className,
+	children,
+	...props
+}: CommitMetadataProps) => (
+	<div
+		className={cn(
+			"flex items-center gap-2 text-muted-foreground text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitSeparatorProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitSeparator = ({
+	className,
+	children,
+	...props
+}: CommitSeparatorProps) => (
+	<span className={className} {...props}>
+		{children ?? "•"}
+	</span>
+);
+
+export type CommitInfoProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitInfo = ({
+	className,
+	children,
+	...props
+}: CommitInfoProps) => (
+	<div className={cn("flex flex-1 flex-col", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type CommitAuthorProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitAuthor = ({
+	className,
+	children,
+	...props
+}: CommitAuthorProps) => (
+	<div className={cn("flex items-center", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type CommitAuthorAvatarProps = ComponentProps<typeof Avatar> & {
+	initials: string;
+};
+
+export const CommitAuthorAvatar = ({
+	initials,
+	className,
+	...props
+}: CommitAuthorAvatarProps) => (
+	<Avatar className={cn("size-8", className)} {...props}>
+		<AvatarFallback className="text-xs">{initials}</AvatarFallback>
+	</Avatar>
+);
+
+export type CommitTimestampProps = HTMLAttributes<HTMLTimeElement> & {
+	date: Date;
+};
+
+const relativeTimeFormat = new Intl.RelativeTimeFormat("en", {
+	numeric: "auto",
+});
+
+const formatRelativeDate = (date: Date) => {
+	const days = Math.round(
+		(date.getTime() - Date.now()) / (1000 * 60 * 60 * 24),
+	);
+	return relativeTimeFormat.format(days, "day");
+};
+
+export const CommitTimestamp = ({
+	date,
+	className,
+	children,
+	...props
+}: CommitTimestampProps) => {
+	const [formatted, setFormatted] = useState("");
+
+	const updateFormatted = useCallback(() => {
+		setFormatted(formatRelativeDate(date));
+	}, [date]);
+
+	useEffect(() => {
+		updateFormatted();
+	}, [updateFormatted]);
+
+	return (
+		<time
+			className={cn("text-xs", className)}
+			dateTime={date.toISOString()}
+			{...props}
+		>
+			{children ?? formatted}
+		</time>
+	);
+};
+
+export type CommitActionsProps = HTMLAttributes<HTMLDivElement>;
+
+const handleActionsClick = (e: React.MouseEvent) => e.stopPropagation();
+const handleActionsKeyDown = (e: React.KeyboardEvent) => e.stopPropagation();
+
+export const CommitActions = ({
+	className,
+	children,
+	...props
+}: CommitActionsProps) => (
+	// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+	<div
+		className={cn("flex items-center gap-1", className)}
+		onClick={handleActionsClick}
+		onKeyDown={handleActionsKeyDown}
+		role="group"
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitCopyButtonProps = ComponentProps<typeof Button> & {
+	hash: string;
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const CommitCopyButton = ({
+	hash,
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: CommitCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			if (!isCopied) {
+				await navigator.clipboard.writeText(hash);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			}
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [hash, onCopy, onError, timeout, isCopied]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn("size-7 shrink-0", className)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={14} />}
+		</Button>
+	);
+};
+
+export type CommitContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const CommitContent = ({
+	className,
+	children,
+	...props
+}: CommitContentProps) => (
+	<CollapsibleContent className={cn("border-t p-3", className)} {...props}>
+		{children}
+	</CollapsibleContent>
+);
+
+export type CommitFilesProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFiles = ({
+	className,
+	children,
+	...props
+}: CommitFilesProps) => (
+	<div className={cn("space-y-1", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type CommitFileProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFile = ({
+	className,
+	children,
+	...props
+}: CommitFileProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between gap-2 rounded px-2 py-1 text-sm hover:bg-muted/50",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitFileInfoProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFileInfo = ({
+	className,
+	children,
+	...props
+}: CommitFileInfoProps) => (
+	<div className={cn("flex min-w-0 items-center gap-2", className)} {...props}>
+		{children}
+	</div>
+);
+
+const fileStatusStyles = {
+	added: "text-green-600 dark:text-green-400",
+	deleted: "text-red-600 dark:text-red-400",
+	modified: "text-yellow-600 dark:text-yellow-400",
+	renamed: "text-blue-600 dark:text-blue-400",
+};
+
+const fileStatusLabels = {
+	added: "A",
+	deleted: "D",
+	modified: "M",
+	renamed: "R",
+};
+
+export type CommitFileStatusProps = HTMLAttributes<HTMLSpanElement> & {
+	status: "added" | "modified" | "deleted" | "renamed";
+};
+
+export const CommitFileStatus = ({
+	status,
+	className,
+	children,
+	...props
+}: CommitFileStatusProps) => (
+	<span
+		className={cn(
+			"font-medium font-mono text-xs",
+			fileStatusStyles[status],
+			className,
+		)}
+		{...props}
+	>
+		{children ?? fileStatusLabels[status]}
+	</span>
+);
+
+export type CommitFileIconProps = ComponentProps<typeof FileIcon>;
+
+export const CommitFileIcon = ({
+	className,
+	...props
+}: CommitFileIconProps) => (
+	<FileIcon
+		className={cn("size-3.5 shrink-0 text-muted-foreground", className)}
+		{...props}
+	/>
+);
+
+export type CommitFilePathProps = HTMLAttributes<HTMLSpanElement>;
+
+export const CommitFilePath = ({
+	className,
+	children,
+	...props
+}: CommitFilePathProps) => (
+	<span className={cn("truncate font-mono text-xs", className)} {...props}>
+		{children}
+	</span>
+);
+
+export type CommitFileChangesProps = HTMLAttributes<HTMLDivElement>;
+
+export const CommitFileChanges = ({
+	className,
+	children,
+	...props
+}: CommitFileChangesProps) => (
+	<div
+		className={cn(
+			"flex shrink-0 items-center gap-1 font-mono text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type CommitFileAdditionsProps = HTMLAttributes<HTMLSpanElement> & {
+	count: number;
+};
+
+export const CommitFileAdditions = ({
+	count,
+	className,
+	children,
+	...props
+}: CommitFileAdditionsProps) => {
+	if (count <= 0) {
+		return null;
+	}
+
+	return (
+		<span
+			className={cn("text-green-600 dark:text-green-400", className)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					<PlusIcon className="inline-block size-3" />
+					{count}
+				</>
+			)}
+		</span>
+	);
+};
+
+export type CommitFileDeletionsProps = HTMLAttributes<HTMLSpanElement> & {
+	count: number;
+};
+
+export const CommitFileDeletions = ({
+	count,
+	className,
+	children,
+	...props
+}: CommitFileDeletionsProps) => {
+	if (count <= 0) {
+		return null;
+	}
+
+	return (
+		<span
+			className={cn("text-red-600 dark:text-red-400", className)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					<MinusIcon className="inline-block size-3" />
+					{count}
+				</>
+			)}
+		</span>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/confirmation.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/confirmation.tsx
new file mode 100644
index 0000000..67af355
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/confirmation.tsx
@@ -0,0 +1,174 @@
+"use client";
+
+import type { ToolUIPart } from "ai";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Alert, AlertDescription } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+type ToolUIPartApproval =
+	| {
+			id: string;
+			approved?: never;
+			reason?: never;
+	  }
+	| {
+			id: string;
+			approved: boolean;
+			reason?: string;
+	  }
+	| {
+			id: string;
+			approved: true;
+			reason?: string;
+	  }
+	| {
+			id: string;
+			approved: true;
+			reason?: string;
+	  }
+	| {
+			id: string;
+			approved: false;
+			reason?: string;
+	  }
+	| undefined;
+
+interface ConfirmationContextValue {
+	approval: ToolUIPartApproval;
+	state: ToolUIPart["state"];
+}
+
+const ConfirmationContext = createContext<ConfirmationContextValue | null>(
+	null,
+);
+
+const useConfirmation = () => {
+	const context = useContext(ConfirmationContext);
+
+	if (!context) {
+		throw new Error("Confirmation components must be used within Confirmation");
+	}
+
+	return context;
+};
+
+export type ConfirmationProps = ComponentProps<typeof Alert> & {
+	approval?: ToolUIPartApproval;
+	state: ToolUIPart["state"];
+};
+
+export const Confirmation = ({
+	className,
+	approval,
+	state,
+	...props
+}: ConfirmationProps) => {
+	const contextValue = useMemo(() => ({ approval, state }), [approval, state]);
+
+	if (!approval || state === "input-streaming" || state === "input-available") {
+		return null;
+	}
+
+	return (
+		<ConfirmationContext.Provider value={contextValue}>
+			<Alert className={cn("flex flex-col gap-2", className)} {...props} />
+		</ConfirmationContext.Provider>
+	);
+};
+
+export type ConfirmationTitleProps = ComponentProps<typeof AlertDescription>;
+
+export const ConfirmationTitle = ({
+	className,
+	...props
+}: ConfirmationTitleProps) => (
+	<AlertDescription className={cn("inline", className)} {...props} />
+);
+
+export interface ConfirmationRequestProps {
+	children?: ReactNode;
+}
+
+export const ConfirmationRequest = ({ children }: ConfirmationRequestProps) => {
+	const { state } = useConfirmation();
+
+	// Only show when approval is requested
+	if (state !== "approval-requested") {
+		return null;
+	}
+
+	return children;
+};
+
+export interface ConfirmationAcceptedProps {
+	children?: ReactNode;
+}
+
+export const ConfirmationAccepted = ({
+	children,
+}: ConfirmationAcceptedProps) => {
+	const { approval, state } = useConfirmation();
+
+	// Only show when approved and in response states
+	if (
+		!approval?.approved ||
+		(state !== "approval-responded" &&
+			state !== "output-denied" &&
+			state !== "output-available")
+	) {
+		return null;
+	}
+
+	return children;
+};
+
+export interface ConfirmationRejectedProps {
+	children?: ReactNode;
+}
+
+export const ConfirmationRejected = ({
+	children,
+}: ConfirmationRejectedProps) => {
+	const { approval, state } = useConfirmation();
+
+	// Only show when rejected and in response states
+	if (
+		approval?.approved !== false ||
+		(state !== "approval-responded" &&
+			state !== "output-denied" &&
+			state !== "output-available")
+	) {
+		return null;
+	}
+
+	return children;
+};
+
+export type ConfirmationActionsProps = ComponentProps<"div">;
+
+export const ConfirmationActions = ({
+	className,
+	...props
+}: ConfirmationActionsProps) => {
+	const { state } = useConfirmation();
+
+	// Only show when approval is requested
+	if (state !== "approval-requested") {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn("flex items-center justify-end gap-2 self-end", className)}
+			{...props}
+		/>
+	);
+};
+
+export type ConfirmationActionProps = ComponentProps<typeof Button>;
+
+export const ConfirmationAction = (props: ConfirmationActionProps) => (
+	<Button className="h-8 px-3 text-sm" type="button" {...props} />
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/connection.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/connection.tsx
new file mode 100644
index 0000000..99a58bc
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/connection.tsx
@@ -0,0 +1,28 @@
+import type { ConnectionLineComponent } from "@xyflow/react";
+
+const HALF = 0.5;
+
+export const Connection: ConnectionLineComponent = ({
+	fromX,
+	fromY,
+	toX,
+	toY,
+}) => (
+	<g>
+		<path
+			className="animated"
+			d={`M${fromX},${fromY} C ${fromX + (toX - fromX) * HALF},${fromY} ${fromX + (toX - fromX) * HALF},${toY} ${toX},${toY}`}
+			fill="none"
+			stroke="var(--color-ring)"
+			strokeWidth={1}
+		/>
+		<circle
+			cx={toX}
+			cy={toY}
+			fill="#fff"
+			r={3}
+			stroke="var(--color-ring)"
+			strokeWidth={1}
+		/>
+	</g>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/context.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/context.tsx
new file mode 100644
index 0000000..05b48b1
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/context.tsx
@@ -0,0 +1,409 @@
+"use client";
+
+import type { LanguageModelUsage } from "ai";
+import type { ComponentProps } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { getUsage } from "tokenlens";
+import { Button } from "@/components/ui/button";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { Progress } from "@/components/ui/progress";
+import { cn } from "@/lib/utils";
+
+const PERCENT_MAX = 100;
+const ICON_RADIUS = 10;
+const ICON_VIEWBOX = 24;
+const ICON_CENTER = 12;
+const ICON_STROKE_WIDTH = 2;
+
+type ModelId = string;
+
+interface ContextSchema {
+	usedTokens: number;
+	maxTokens: number;
+	usage?: LanguageModelUsage;
+	modelId?: ModelId;
+}
+
+const ContextContext = createContext<ContextSchema | null>(null);
+
+const useContextValue = () => {
+	const context = useContext(ContextContext);
+
+	if (!context) {
+		throw new Error("Context components must be used within Context");
+	}
+
+	return context;
+};
+
+export type ContextProps = ComponentProps<typeof HoverCard> & ContextSchema;
+
+export const Context = ({
+	usedTokens,
+	maxTokens,
+	usage,
+	modelId,
+	...props
+}: ContextProps) => {
+	const contextValue = useMemo(
+		() => ({ maxTokens, modelId, usage, usedTokens }),
+		[maxTokens, modelId, usage, usedTokens],
+	);
+
+	return (
+		<ContextContext.Provider value={contextValue}>
+			<HoverCard closeDelay={0} openDelay={0} {...props} />
+		</ContextContext.Provider>
+	);
+};
+
+const ContextIcon = () => {
+	const { usedTokens, maxTokens } = useContextValue();
+	const circumference = 2 * Math.PI * ICON_RADIUS;
+	const usedPercent = usedTokens / maxTokens;
+	const dashOffset = circumference * (1 - usedPercent);
+
+	return (
+		<svg
+			aria-label="Model context usage"
+			height="20"
+			role="img"
+			style={{ color: "currentcolor" }}
+			viewBox={`0 0 ${ICON_VIEWBOX} ${ICON_VIEWBOX}`}
+			width="20"
+		>
+			<circle
+				cx={ICON_CENTER}
+				cy={ICON_CENTER}
+				fill="none"
+				opacity="0.25"
+				r={ICON_RADIUS}
+				stroke="currentColor"
+				strokeWidth={ICON_STROKE_WIDTH}
+			/>
+			<circle
+				cx={ICON_CENTER}
+				cy={ICON_CENTER}
+				fill="none"
+				opacity="0.7"
+				r={ICON_RADIUS}
+				stroke="currentColor"
+				strokeDasharray={`${circumference} ${circumference}`}
+				strokeDashoffset={dashOffset}
+				strokeLinecap="round"
+				strokeWidth={ICON_STROKE_WIDTH}
+				style={{ transform: "rotate(-90deg)", transformOrigin: "center" }}
+			/>
+		</svg>
+	);
+};
+
+export type ContextTriggerProps = ComponentProps<typeof Button>;
+
+export const ContextTrigger = ({ children, ...props }: ContextTriggerProps) => {
+	const { usedTokens, maxTokens } = useContextValue();
+	const usedPercent = usedTokens / maxTokens;
+	const renderedPercent = new Intl.NumberFormat("en-US", {
+		maximumFractionDigits: 1,
+		style: "percent",
+	}).format(usedPercent);
+
+	return (
+		<HoverCardTrigger>
+			{children ?? (
+				<Button type="button" variant="ghost" {...props}>
+					<span className="font-medium text-muted-foreground">
+						{renderedPercent}
+					</span>
+					<ContextIcon />
+				</Button>
+			)}
+		</HoverCardTrigger>
+	);
+};
+
+export type ContextContentProps = ComponentProps<typeof HoverCardContent>;
+
+export const ContextContent = ({
+	className,
+	...props
+}: ContextContentProps) => (
+	<HoverCardContent
+		className={cn("min-w-60 divide-y overflow-hidden p-0", className)}
+		{...props}
+	/>
+);
+
+export type ContextContentHeaderProps = ComponentProps<"div">;
+
+export const ContextContentHeader = ({
+	children,
+	className,
+	...props
+}: ContextContentHeaderProps) => {
+	const { usedTokens, maxTokens } = useContextValue();
+	const usedPercent = usedTokens / maxTokens;
+	const displayPct = new Intl.NumberFormat("en-US", {
+		maximumFractionDigits: 1,
+		style: "percent",
+	}).format(usedPercent);
+	const used = new Intl.NumberFormat("en-US", {
+		notation: "compact",
+	}).format(usedTokens);
+	const total = new Intl.NumberFormat("en-US", {
+		notation: "compact",
+	}).format(maxTokens);
+
+	return (
+		<div className={cn("w-full space-y-2 p-3", className)} {...props}>
+			{children ?? (
+				<>
+					<div className="flex items-center justify-between gap-3 text-xs">
+						<p>{displayPct}</p>
+						<p className="font-mono text-muted-foreground">
+							{used} / {total}
+						</p>
+					</div>
+					<div className="space-y-2">
+						<Progress className="bg-muted" value={usedPercent * PERCENT_MAX} />
+					</div>
+				</>
+			)}
+		</div>
+	);
+};
+
+export type ContextContentBodyProps = ComponentProps<"div">;
+
+export const ContextContentBody = ({
+	children,
+	className,
+	...props
+}: ContextContentBodyProps) => (
+	<div className={cn("w-full p-3", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type ContextContentFooterProps = ComponentProps<"div">;
+
+export const ContextContentFooter = ({
+	children,
+	className,
+	...props
+}: ContextContentFooterProps) => {
+	const { modelId, usage } = useContextValue();
+	const costUSD = modelId
+		? getUsage({
+				modelId,
+				usage: {
+					input: usage?.inputTokens ?? 0,
+					output: usage?.outputTokens ?? 0,
+				},
+			}).costUSD?.totalUSD
+		: undefined;
+	const totalCost = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(costUSD ?? 0);
+
+	return (
+		<div
+			className={cn(
+				"flex w-full items-center justify-between gap-3 bg-secondary p-3 text-xs",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					<span className="text-muted-foreground">Total cost</span>
+					<span>{totalCost}</span>
+				</>
+			)}
+		</div>
+	);
+};
+
+const TokensWithCost = ({
+	tokens,
+	costText,
+}: {
+	tokens?: number;
+	costText?: string;
+}) => (
+	<span>
+		{tokens === undefined
+			? "—"
+			: new Intl.NumberFormat("en-US", {
+					notation: "compact",
+				}).format(tokens)}
+		{costText ? (
+			<span className="ml-2 text-muted-foreground">• {costText}</span>
+		) : null}
+	</span>
+);
+
+export type ContextInputUsageProps = ComponentProps<"div">;
+
+export const ContextInputUsage = ({
+	className,
+	children,
+	...props
+}: ContextInputUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const inputTokens = usage?.inputTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!inputTokens) {
+		return null;
+	}
+
+	const inputCost = modelId
+		? getUsage({
+				modelId,
+				usage: { input: inputTokens, output: 0 },
+			}).costUSD?.totalUSD
+		: undefined;
+	const inputCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(inputCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Input</span>
+			<TokensWithCost costText={inputCostText} tokens={inputTokens} />
+		</div>
+	);
+};
+
+export type ContextOutputUsageProps = ComponentProps<"div">;
+
+export const ContextOutputUsage = ({
+	className,
+	children,
+	...props
+}: ContextOutputUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const outputTokens = usage?.outputTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!outputTokens) {
+		return null;
+	}
+
+	const outputCost = modelId
+		? getUsage({
+				modelId,
+				usage: { input: 0, output: outputTokens },
+			}).costUSD?.totalUSD
+		: undefined;
+	const outputCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(outputCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Output</span>
+			<TokensWithCost costText={outputCostText} tokens={outputTokens} />
+		</div>
+	);
+};
+
+export type ContextReasoningUsageProps = ComponentProps<"div">;
+
+export const ContextReasoningUsage = ({
+	className,
+	children,
+	...props
+}: ContextReasoningUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const reasoningTokens = usage?.outputTokenDetails?.reasoningTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!reasoningTokens) {
+		return null;
+	}
+
+	const reasoningCost = modelId
+		? getUsage({
+				modelId,
+				usage: { reasoningTokens },
+			}).costUSD?.totalUSD
+		: undefined;
+	const reasoningCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(reasoningCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Reasoning</span>
+			<TokensWithCost costText={reasoningCostText} tokens={reasoningTokens} />
+		</div>
+	);
+};
+
+export type ContextCacheUsageProps = ComponentProps<"div">;
+
+export const ContextCacheUsage = ({
+	className,
+	children,
+	...props
+}: ContextCacheUsageProps) => {
+	const { usage, modelId } = useContextValue();
+	const cacheTokens = usage?.inputTokenDetails?.cacheReadTokens ?? 0;
+
+	if (children) {
+		return children;
+	}
+
+	if (!cacheTokens) {
+		return null;
+	}
+
+	const cacheCost = modelId
+		? getUsage({
+				modelId,
+				usage: { cacheReads: cacheTokens, input: 0, output: 0 },
+			}).costUSD?.totalUSD
+		: undefined;
+	const cacheCostText = new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		style: "currency",
+	}).format(cacheCost ?? 0);
+
+	return (
+		<div
+			className={cn("flex items-center justify-between text-xs", className)}
+			{...props}
+		>
+			<span className="text-muted-foreground">Cache</span>
+			<TokensWithCost costText={cacheCostText} tokens={cacheTokens} />
+		</div>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/controls.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/controls.tsx
new file mode 100644
index 0000000..fdd119b
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/controls.tsx
@@ -0,0 +1,18 @@
+"use client";
+
+import { Controls as ControlsPrimitive } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+export type ControlsProps = ComponentProps<typeof ControlsPrimitive>;
+
+export const Controls = ({ className, ...props }: ControlsProps) => (
+	<ControlsPrimitive
+		className={cn(
+			"gap-px overflow-hidden rounded-md border bg-card p-1 shadow-none!",
+			"[&>button]:rounded-md [&>button]:border-none! [&>button]:bg-transparent! [&>button]:hover:bg-secondary!",
+			className,
+		)}
+		{...props}
+	/>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/conversation.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/conversation.tsx
new file mode 100644
index 0000000..0cbcc1c
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/conversation.tsx
@@ -0,0 +1,168 @@
+"use client";
+
+import type { UIMessage } from "ai";
+import { ArrowDownIcon, DownloadIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { useCallback } from "react";
+import { StickToBottom, useStickToBottomContext } from "use-stick-to-bottom";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+export type ConversationProps = ComponentProps<typeof StickToBottom>;
+
+export const Conversation = ({ className, ...props }: ConversationProps) => (
+	<StickToBottom
+		className={cn("relative flex-1 overflow-y-hidden", className)}
+		initial="smooth"
+		resize="smooth"
+		role="log"
+		{...props}
+	/>
+);
+
+export type ConversationContentProps = ComponentProps<
+	typeof StickToBottom.Content
+>;
+
+export const ConversationContent = ({
+	className,
+	...props
+}: ConversationContentProps) => (
+	<StickToBottom.Content
+		className={cn("flex flex-col gap-8 p-4", className)}
+		{...props}
+	/>
+);
+
+export type ConversationEmptyStateProps = ComponentProps<"div"> & {
+	title?: string;
+	description?: string;
+	icon?: React.ReactNode;
+};
+
+export const ConversationEmptyState = ({
+	className,
+	title = "No messages yet",
+	description = "Start a conversation to see messages here",
+	icon,
+	children,
+	...props
+}: ConversationEmptyStateProps) => (
+	<div
+		className={cn(
+			"flex size-full flex-col items-center justify-center gap-3 p-8 text-center",
+			className,
+		)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				{icon && <div className="text-muted-foreground">{icon}</div>}
+				<div className="space-y-1">
+					<h3 className="font-medium text-sm">{title}</h3>
+					{description && (
+						<p className="text-muted-foreground text-sm">{description}</p>
+					)}
+				</div>
+			</>
+		)}
+	</div>
+);
+
+export type ConversationScrollButtonProps = ComponentProps<typeof Button>;
+
+export const ConversationScrollButton = ({
+	className,
+	...props
+}: ConversationScrollButtonProps) => {
+	const { isAtBottom, scrollToBottom } = useStickToBottomContext();
+
+	const handleScrollToBottom = useCallback(() => {
+		scrollToBottom();
+	}, [scrollToBottom]);
+
+	return (
+		!isAtBottom && (
+			<Button
+				className={cn(
+					"absolute bottom-4 left-[50%] translate-x-[-50%] rounded-full dark:bg-background dark:hover:bg-muted",
+					className,
+				)}
+				onClick={handleScrollToBottom}
+				size="icon"
+				type="button"
+				variant="outline"
+				{...props}
+			>
+				<ArrowDownIcon className="size-4" />
+			</Button>
+		)
+	);
+};
+
+const getMessageText = (message: UIMessage): string =>
+	message.parts
+		.filter((part) => part.type === "text")
+		.map((part) => part.text)
+		.join("");
+
+export type ConversationDownloadProps = Omit<
+	ComponentProps<typeof Button>,
+	"onClick"
+> & {
+	messages: UIMessage[];
+	filename?: string;
+	formatMessage?: (message: UIMessage, index: number) => string;
+};
+
+const defaultFormatMessage = (message: UIMessage): string => {
+	const roleLabel =
+		message.role.charAt(0).toUpperCase() + message.role.slice(1);
+	return `**${roleLabel}:** ${getMessageText(message)}`;
+};
+
+export const messagesToMarkdown = (
+	messages: UIMessage[],
+	formatMessage: (
+		message: UIMessage,
+		index: number,
+	) => string = defaultFormatMessage,
+): string => messages.map((msg, i) => formatMessage(msg, i)).join("\n\n");
+
+export const ConversationDownload = ({
+	messages,
+	filename = "conversation.md",
+	formatMessage = defaultFormatMessage,
+	className,
+	children,
+	...props
+}: ConversationDownloadProps) => {
+	const handleDownload = useCallback(() => {
+		const markdown = messagesToMarkdown(messages, formatMessage);
+		const blob = new Blob([markdown], { type: "text/markdown" });
+		const url = URL.createObjectURL(blob);
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = filename;
+		document.body.append(link);
+		link.click();
+		link.remove();
+		URL.revokeObjectURL(url);
+	}, [messages, filename, formatMessage]);
+
+	return (
+		<Button
+			className={cn(
+				"absolute top-4 right-4 rounded-full dark:bg-background dark:hover:bg-muted",
+				className,
+			)}
+			onClick={handleDownload}
+			size="icon"
+			type="button"
+			variant="outline"
+			{...props}
+		>
+			{children ?? <DownloadIcon className="size-4" />}
+		</Button>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/edge.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/edge.tsx
new file mode 100644
index 0000000..76bf7dc
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/edge.tsx
@@ -0,0 +1,143 @@
+import type { EdgeProps, InternalNode, Node } from "@xyflow/react";
+import {
+	BaseEdge,
+	getBezierPath,
+	getSimpleBezierPath,
+	Position,
+	useInternalNode,
+} from "@xyflow/react";
+
+const Temporary = ({
+	id,
+	sourceX,
+	sourceY,
+	targetX,
+	targetY,
+	sourcePosition,
+	targetPosition,
+}: EdgeProps) => {
+	const [edgePath] = getSimpleBezierPath({
+		sourcePosition,
+		sourceX,
+		sourceY,
+		targetPosition,
+		targetX,
+		targetY,
+	});
+
+	return (
+		<BaseEdge
+			className="stroke-1 stroke-ring"
+			id={id}
+			path={edgePath}
+			style={{
+				strokeDasharray: "5, 5",
+			}}
+		/>
+	);
+};
+
+const getHandleCoordsByPosition = (
+	node: InternalNode<Node>,
+	handlePosition: Position,
+) => {
+	// Choose the handle type based on position - Left is for target, Right is for source
+	const handleType = handlePosition === Position.Left ? "target" : "source";
+
+	const handle = node.internals.handleBounds?.[handleType]?.find(
+		(h) => h.position === handlePosition,
+	);
+
+	if (!handle) {
+		return [0, 0] as const;
+	}
+
+	let offsetX = handle.width / 2;
+	let offsetY = handle.height / 2;
+
+	// this is a tiny detail to make the markerEnd of an edge visible.
+	// The handle position that gets calculated has the origin top-left, so depending which side we are using, we add a little offset
+	// when the handlePosition is Position.Right for example, we need to add an offset as big as the handle itself in order to get the correct position
+	switch (handlePosition) {
+		case Position.Left: {
+			offsetX = 0;
+			break;
+		}
+		case Position.Right: {
+			offsetX = handle.width;
+			break;
+		}
+		case Position.Top: {
+			offsetY = 0;
+			break;
+		}
+		case Position.Bottom: {
+			offsetY = handle.height;
+			break;
+		}
+		default: {
+			throw new Error(`Invalid handle position: ${handlePosition}`);
+		}
+	}
+
+	const x = node.internals.positionAbsolute.x + handle.x + offsetX;
+	const y = node.internals.positionAbsolute.y + handle.y + offsetY;
+
+	return [x, y] as const;
+};
+
+const getEdgeParams = (
+	source: InternalNode<Node>,
+	target: InternalNode<Node>,
+) => {
+	const sourcePos = Position.Right;
+	const [sx, sy] = getHandleCoordsByPosition(source, sourcePos);
+	const targetPos = Position.Left;
+	const [tx, ty] = getHandleCoordsByPosition(target, targetPos);
+
+	return {
+		sourcePos,
+		sx,
+		sy,
+		targetPos,
+		tx,
+		ty,
+	};
+};
+
+const Animated = ({ id, source, target, markerEnd, style }: EdgeProps) => {
+	const sourceNode = useInternalNode(source);
+	const targetNode = useInternalNode(target);
+
+	if (!(sourceNode && targetNode)) {
+		return null;
+	}
+
+	const { sx, sy, tx, ty, sourcePos, targetPos } = getEdgeParams(
+		sourceNode,
+		targetNode,
+	);
+
+	const [edgePath] = getBezierPath({
+		sourcePosition: sourcePos,
+		sourceX: sx,
+		sourceY: sy,
+		targetPosition: targetPos,
+		targetX: tx,
+		targetY: ty,
+	});
+
+	return (
+		<>
+			<BaseEdge id={id} markerEnd={markerEnd} path={edgePath} style={style} />
+			<circle fill="var(--primary)" r="4">
+				<animateMotion dur="2s" path={edgePath} repeatCount="indefinite" />
+			</circle>
+		</>
+	);
+};
+
+export const Edge = {
+	Animated,
+	Temporary,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/environment-variables.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/environment-variables.tsx
new file mode 100644
index 0000000..f6ba5ff
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/environment-variables.tsx
@@ -0,0 +1,324 @@
+"use client";
+
+import { CheckIcon, CopyIcon, EyeIcon, EyeOffIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import { cn } from "@/lib/utils";
+
+interface EnvironmentVariablesContextType {
+	showValues: boolean;
+	setShowValues: (show: boolean) => void;
+}
+
+// Default noop for context default value
+// oxlint-disable-next-line eslint(no-empty-function)
+const noop = () => {};
+
+const EnvironmentVariablesContext =
+	createContext<EnvironmentVariablesContextType>({
+		setShowValues: noop,
+		showValues: false,
+	});
+
+export type EnvironmentVariablesProps = HTMLAttributes<HTMLDivElement> & {
+	showValues?: boolean;
+	defaultShowValues?: boolean;
+	onShowValuesChange?: (show: boolean) => void;
+};
+
+export const EnvironmentVariables = ({
+	showValues: controlledShowValues,
+	defaultShowValues = false,
+	onShowValuesChange,
+	className,
+	children,
+	...props
+}: EnvironmentVariablesProps) => {
+	const [internalShowValues, setInternalShowValues] =
+		useState(defaultShowValues);
+	const showValues = controlledShowValues ?? internalShowValues;
+
+	const setShowValues = useCallback(
+		(show: boolean) => {
+			setInternalShowValues(show);
+			onShowValuesChange?.(show);
+		},
+		[onShowValuesChange],
+	);
+
+	const contextValue = useMemo(
+		() => ({ setShowValues, showValues }),
+		[setShowValues, showValues],
+	);
+
+	return (
+		<EnvironmentVariablesContext.Provider value={contextValue}>
+			<div
+				className={cn("rounded-lg border bg-background", className)}
+				{...props}
+			>
+				{children}
+			</div>
+		</EnvironmentVariablesContext.Provider>
+	);
+};
+
+export type EnvironmentVariablesHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariablesHeader = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariablesHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b px-4 py-3",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type EnvironmentVariablesTitleProps = HTMLAttributes<HTMLHeadingElement>;
+
+export const EnvironmentVariablesTitle = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariablesTitleProps) => (
+	<h3 className={cn("font-medium text-sm", className)} {...props}>
+		{children ?? "Environment Variables"}
+	</h3>
+);
+
+export type EnvironmentVariablesToggleProps = ComponentProps<typeof Switch>;
+
+export const EnvironmentVariablesToggle = ({
+	className,
+	...props
+}: EnvironmentVariablesToggleProps) => {
+	const { showValues, setShowValues } = useContext(EnvironmentVariablesContext);
+
+	return (
+		<div className={cn("flex items-center gap-2", className)}>
+			<span className="text-muted-foreground text-xs">
+				{showValues ? <EyeIcon size={14} /> : <EyeOffIcon size={14} />}
+			</span>
+			<Switch
+				aria-label="Toggle value visibility"
+				checked={showValues}
+				onCheckedChange={setShowValues}
+				{...props}
+			/>
+		</div>
+	);
+};
+
+export type EnvironmentVariablesContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariablesContent = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariablesContentProps) => (
+	<div className={cn("divide-y", className)} {...props}>
+		{children}
+	</div>
+);
+
+interface EnvironmentVariableContextType {
+	name: string;
+	value: string;
+}
+
+const EnvironmentVariableContext =
+	createContext<EnvironmentVariableContextType>({
+		name: "",
+		value: "",
+	});
+
+export type EnvironmentVariableGroupProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariableGroup = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableGroupProps) => (
+	<div className={cn("flex items-center gap-2", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type EnvironmentVariableNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const EnvironmentVariableName = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableNameProps) => {
+	const { name } = useContext(EnvironmentVariableContext);
+
+	return (
+		<span className={cn("font-mono text-sm", className)} {...props}>
+			{children ?? name}
+		</span>
+	);
+};
+
+export type EnvironmentVariableValueProps = HTMLAttributes<HTMLSpanElement>;
+
+export const EnvironmentVariableValue = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableValueProps) => {
+	const { value } = useContext(EnvironmentVariableContext);
+	const { showValues } = useContext(EnvironmentVariablesContext);
+
+	const displayValue = showValues
+		? value
+		: "•".repeat(Math.min(value.length, 20));
+
+	return (
+		<span
+			className={cn(
+				"font-mono text-muted-foreground text-sm",
+				!showValues && "select-none",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? displayValue}
+		</span>
+	);
+};
+
+export type EnvironmentVariableProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	value: string;
+};
+
+export const EnvironmentVariable = ({
+	name,
+	value,
+	className,
+	children,
+	...props
+}: EnvironmentVariableProps) => {
+	const envVarContextValue = useMemo(() => ({ name, value }), [name, value]);
+
+	return (
+		<EnvironmentVariableContext.Provider value={envVarContextValue}>
+			<div
+				className={cn(
+					"flex items-center justify-between gap-4 px-4 py-3",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<div className="flex items-center gap-2">
+							<EnvironmentVariableName />
+						</div>
+						<EnvironmentVariableValue />
+					</>
+				)}
+			</div>
+		</EnvironmentVariableContext.Provider>
+	);
+};
+
+export type EnvironmentVariableCopyButtonProps = ComponentProps<
+	typeof Button
+> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+	copyFormat?: "name" | "value" | "export";
+};
+
+export const EnvironmentVariableCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	copyFormat = "value",
+	children,
+	className,
+	...props
+}: EnvironmentVariableCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { name, value } = useContext(EnvironmentVariableContext);
+
+	const getTextToCopy = useCallback((): string => {
+		const formatMap = {
+			export: () => `export ${name}="${value}"`,
+			name: () => name,
+			value: () => value,
+		};
+		return formatMap[copyFormat]();
+	}, [name, value, copyFormat]);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			await navigator.clipboard.writeText(getTextToCopy());
+			setIsCopied(true);
+			onCopy?.();
+			timeoutRef.current = window.setTimeout(() => setIsCopied(false), timeout);
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [getTextToCopy, onCopy, onError, timeout]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn("size-6 shrink-0", className)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={12} />}
+		</Button>
+	);
+};
+
+export type EnvironmentVariableRequiredProps = ComponentProps<typeof Badge>;
+
+export const EnvironmentVariableRequired = ({
+	className,
+	children,
+	...props
+}: EnvironmentVariableRequiredProps) => (
+	<Badge className={cn("text-xs", className)} variant="secondary" {...props}>
+		{children ?? "Required"}
+	</Badge>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/file-tree.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/file-tree.tsx
new file mode 100644
index 0000000..1d7ebc1
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/file-tree.tsx
@@ -0,0 +1,307 @@
+"use client";
+
+import {
+	ChevronRightIcon,
+	FileIcon,
+	FolderIcon,
+	FolderOpenIcon,
+} from "lucide-react";
+import type { HTMLAttributes, ReactNode } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useMemo,
+	useState,
+} from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+interface FileTreeContextType {
+	expandedPaths: Set<string>;
+	togglePath: (path: string) => void;
+	selectedPath?: string;
+	onSelect?: (path: string) => void;
+}
+
+// Default noop for context default value
+// oxlint-disable-next-line eslint(no-empty-function)
+const noop = () => {};
+
+const FileTreeContext = createContext<FileTreeContextType>({
+	// oxlint-disable-next-line eslint-plugin-unicorn(no-new-builtin)
+	expandedPaths: new Set(),
+	togglePath: noop,
+});
+
+export type FileTreeProps = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+	expanded?: Set<string>;
+	defaultExpanded?: Set<string>;
+	selectedPath?: string;
+	onSelect?: (path: string) => void;
+	onExpandedChange?: (expanded: Set<string>) => void;
+};
+
+export const FileTree = ({
+	expanded: controlledExpanded,
+	defaultExpanded = new Set(),
+	selectedPath,
+	onSelect,
+	onExpandedChange,
+	className,
+	children,
+	...props
+}: FileTreeProps) => {
+	const [internalExpanded, setInternalExpanded] = useState(defaultExpanded);
+	const expandedPaths = controlledExpanded ?? internalExpanded;
+
+	const togglePath = useCallback(
+		(path: string) => {
+			const newExpanded = new Set(expandedPaths);
+			if (newExpanded.has(path)) {
+				newExpanded.delete(path);
+			} else {
+				newExpanded.add(path);
+			}
+			setInternalExpanded(newExpanded);
+			onExpandedChange?.(newExpanded);
+		},
+		[expandedPaths, onExpandedChange],
+	);
+
+	const contextValue = useMemo(
+		() => ({ expandedPaths, onSelect, selectedPath, togglePath }),
+		[expandedPaths, onSelect, selectedPath, togglePath],
+	);
+
+	return (
+		<FileTreeContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"rounded-lg border bg-background font-mono text-sm",
+					className,
+				)}
+				role="tree"
+				{...props}
+			>
+				<div className="p-2">{children}</div>
+			</div>
+		</FileTreeContext.Provider>
+	);
+};
+
+export type FileTreeIconProps = HTMLAttributes<HTMLSpanElement>;
+
+export const FileTreeIcon = ({
+	className,
+	children,
+	...props
+}: FileTreeIconProps) => (
+	<span className={cn("shrink-0", className)} {...props}>
+		{children}
+	</span>
+);
+
+export type FileTreeNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const FileTreeName = ({
+	className,
+	children,
+	...props
+}: FileTreeNameProps) => (
+	<span className={cn("truncate", className)} {...props}>
+		{children}
+	</span>
+);
+
+interface FileTreeFolderContextType {
+	path: string;
+	name: string;
+	isExpanded: boolean;
+}
+
+const FileTreeFolderContext = createContext<FileTreeFolderContextType>({
+	isExpanded: false,
+	name: "",
+	path: "",
+});
+
+export type FileTreeFolderProps = HTMLAttributes<HTMLDivElement> & {
+	path: string;
+	name: string;
+};
+
+export const FileTreeFolder = ({
+	path,
+	name,
+	className,
+	children,
+	...props
+}: FileTreeFolderProps) => {
+	const { expandedPaths, togglePath, selectedPath, onSelect } =
+		useContext(FileTreeContext);
+	const isExpanded = expandedPaths.has(path);
+	const isSelected = selectedPath === path;
+
+	const handleOpenChange = useCallback(() => {
+		togglePath(path);
+	}, [togglePath, path]);
+
+	const handleSelect = useCallback(() => {
+		onSelect?.(path);
+	}, [onSelect, path]);
+
+	const folderContextValue = useMemo(
+		() => ({ isExpanded, name, path }),
+		[isExpanded, name, path],
+	);
+
+	return (
+		<FileTreeFolderContext.Provider value={folderContextValue}>
+			<Collapsible onOpenChange={handleOpenChange} open={isExpanded}>
+				<div
+					className={cn("", className)}
+					role="treeitem"
+					tabIndex={0}
+					{...props}
+				>
+					<div
+						className={cn(
+							"flex w-full items-center gap-1 rounded px-2 py-1 text-left transition-colors hover:bg-muted/50",
+							isSelected && "bg-muted",
+						)}
+					>
+						<CollapsibleTrigger
+							render={
+								<button
+									className="flex shrink-0 cursor-pointer items-center border-none bg-transparent p-0"
+									type="button"
+								/>
+							}
+						>
+							<ChevronRightIcon
+								className={cn(
+									"size-4 shrink-0 text-muted-foreground transition-transform",
+									isExpanded && "rotate-90",
+								)}
+							/>
+						</CollapsibleTrigger>
+						<button
+							className="flex min-w-0 flex-1 cursor-pointer items-center gap-1 border-none bg-transparent p-0 text-left"
+							onClick={handleSelect}
+							type="button"
+						>
+							<FileTreeIcon>
+								{isExpanded ? (
+									<FolderOpenIcon className="size-4 text-blue-500" />
+								) : (
+									<FolderIcon className="size-4 text-blue-500" />
+								)}
+							</FileTreeIcon>
+							<FileTreeName>{name}</FileTreeName>
+						</button>
+					</div>
+					<CollapsibleContent>
+						<div className="ml-4 border-l pl-2">{children}</div>
+					</CollapsibleContent>
+				</div>
+			</Collapsible>
+		</FileTreeFolderContext.Provider>
+	);
+};
+
+interface FileTreeFileContextType {
+	path: string;
+	name: string;
+}
+
+const FileTreeFileContext = createContext<FileTreeFileContextType>({
+	name: "",
+	path: "",
+});
+
+export type FileTreeFileProps = HTMLAttributes<HTMLDivElement> & {
+	path: string;
+	name: string;
+	icon?: ReactNode;
+};
+
+export const FileTreeFile = ({
+	path,
+	name,
+	icon,
+	className,
+	children,
+	...props
+}: FileTreeFileProps) => {
+	const { selectedPath, onSelect } = useContext(FileTreeContext);
+	const isSelected = selectedPath === path;
+
+	const handleClick = useCallback(() => {
+		onSelect?.(path);
+	}, [onSelect, path]);
+
+	const handleKeyDown = useCallback(
+		(e: React.KeyboardEvent) => {
+			if (e.key === "Enter" || e.key === " ") {
+				onSelect?.(path);
+			}
+		},
+		[onSelect, path],
+	);
+
+	const fileContextValue = useMemo(() => ({ name, path }), [name, path]);
+
+	return (
+		<FileTreeFileContext.Provider value={fileContextValue}>
+			<div
+				className={cn(
+					"flex cursor-pointer items-center gap-1 rounded px-2 py-1 transition-colors hover:bg-muted/50",
+					isSelected && "bg-muted",
+					className,
+				)}
+				onClick={handleClick}
+				onKeyDown={handleKeyDown}
+				role="treeitem"
+				tabIndex={0}
+				{...props}
+			>
+				{children ?? (
+					<>
+						{/* Spacer for alignment */}
+						<span className="size-4 shrink-0" />
+						<FileTreeIcon>
+							{icon ?? <FileIcon className="size-4 text-muted-foreground" />}
+						</FileTreeIcon>
+						<FileTreeName>{name}</FileTreeName>
+					</>
+				)}
+			</div>
+		</FileTreeFileContext.Provider>
+	);
+};
+
+export type FileTreeActionsProps = HTMLAttributes<HTMLDivElement>;
+
+const stopPropagation = (e: React.SyntheticEvent) => e.stopPropagation();
+
+export const FileTreeActions = ({
+	className,
+	children,
+	...props
+}: FileTreeActionsProps) => (
+	// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+	<div
+		className={cn("ml-auto flex items-center gap-1", className)}
+		onClick={stopPropagation}
+		onKeyDown={stopPropagation}
+		role="group"
+		{...props}
+	>
+		{children}
+	</div>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/image.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/image.tsx
new file mode 100644
index 0000000..d7026dd
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/image.tsx
@@ -0,0 +1,24 @@
+import type { Experimental_GeneratedImage } from "ai";
+import { cn } from "@/lib/utils";
+
+export type ImageProps = Experimental_GeneratedImage & {
+	className?: string;
+	alt?: string;
+};
+
+export const Image = ({
+	base64,
+	uint8Array: _uint8Array,
+	mediaType,
+	...props
+}: ImageProps) => (
+	<img
+		{...props}
+		alt={props.alt}
+		className={cn(
+			"h-auto max-w-full overflow-hidden rounded-md",
+			props.className,
+		)}
+		src={`data:${mediaType};base64,${base64}`}
+	/>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/inline-citation.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/inline-citation.tsx
new file mode 100644
index 0000000..6063e4e
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/inline-citation.tsx
@@ -0,0 +1,298 @@
+"use client";
+
+import { ArrowLeftIcon, ArrowRightIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useState,
+} from "react";
+import { Badge } from "@/components/ui/badge";
+import type { CarouselApi } from "@/components/ui/carousel";
+import {
+	Carousel,
+	CarouselContent,
+	CarouselItem,
+} from "@/components/ui/carousel";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import { cn } from "@/lib/utils";
+
+export type InlineCitationProps = ComponentProps<"span">;
+
+export const InlineCitation = ({
+	className,
+	...props
+}: InlineCitationProps) => (
+	<span
+		className={cn("group inline items-center gap-1", className)}
+		{...props}
+	/>
+);
+
+export type InlineCitationTextProps = ComponentProps<"span">;
+
+export const InlineCitationText = ({
+	className,
+	...props
+}: InlineCitationTextProps) => (
+	<span
+		className={cn("transition-colors group-hover:bg-accent", className)}
+		{...props}
+	/>
+);
+
+export type InlineCitationCardProps = ComponentProps<typeof HoverCard>;
+
+export const InlineCitationCard = (props: InlineCitationCardProps) => (
+	<HoverCard closeDelay={0} openDelay={0} {...props} />
+);
+
+export type InlineCitationCardTriggerProps = ComponentProps<typeof Badge> & {
+	sources: string[];
+};
+
+export const InlineCitationCardTrigger = ({
+	sources,
+	className,
+	...props
+}: InlineCitationCardTriggerProps) => (
+	<HoverCardTrigger
+		render={
+			<Badge
+				className={cn("ml-1 rounded-full", className)}
+				variant="secondary"
+				{...props}
+			/>
+		}
+	>
+		{sources[0] ? (
+			<>
+				{new URL(sources[0]).hostname}{" "}
+				{sources.length > 1 && `+${sources.length - 1}`}
+			</>
+		) : (
+			"unknown"
+		)}
+	</HoverCardTrigger>
+);
+
+export type InlineCitationCardBodyProps = ComponentProps<"div">;
+
+export const InlineCitationCardBody = ({
+	className,
+	...props
+}: InlineCitationCardBodyProps) => (
+	<HoverCardContent className={cn("relative w-80 p-0", className)} {...props} />
+);
+
+const CarouselApiContext = createContext<CarouselApi | undefined>(undefined);
+
+const useCarouselApi = () => {
+	const context = useContext(CarouselApiContext);
+	return context;
+};
+
+export type InlineCitationCarouselProps = ComponentProps<typeof Carousel>;
+
+export const InlineCitationCarousel = ({
+	className,
+	children,
+	...props
+}: InlineCitationCarouselProps) => {
+	const [api, setApi] = useState<CarouselApi>();
+
+	return (
+		<CarouselApiContext.Provider value={api}>
+			<Carousel className={cn("w-full", className)} setApi={setApi} {...props}>
+				{children}
+			</Carousel>
+		</CarouselApiContext.Provider>
+	);
+};
+
+export type InlineCitationCarouselContentProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselContent = (
+	props: InlineCitationCarouselContentProps,
+) => <CarouselContent {...props} />;
+
+export type InlineCitationCarouselItemProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselItem = ({
+	className,
+	...props
+}: InlineCitationCarouselItemProps) => (
+	<CarouselItem
+		className={cn("w-full space-y-2 p-4 pl-8", className)}
+		{...props}
+	/>
+);
+
+export type InlineCitationCarouselHeaderProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselHeader = ({
+	className,
+	...props
+}: InlineCitationCarouselHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between gap-2 rounded-t-md bg-secondary p-2",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type InlineCitationCarouselIndexProps = ComponentProps<"div">;
+
+export const InlineCitationCarouselIndex = ({
+	children,
+	className,
+	...props
+}: InlineCitationCarouselIndexProps) => {
+	const api = useCarouselApi();
+	const [current, setCurrent] = useState(0);
+	const [count, setCount] = useState(0);
+
+	const syncState = useCallback(() => {
+		if (!api) {
+			return;
+		}
+		setCount(api.scrollSnapList().length);
+		setCurrent(api.selectedScrollSnap() + 1);
+	}, [api]);
+
+	useEffect(() => {
+		if (!api) {
+			return;
+		}
+
+		syncState();
+
+		api.on("select", syncState);
+
+		return () => {
+			api.off("select", syncState);
+		};
+	}, [api, syncState]);
+
+	return (
+		<div
+			className={cn(
+				"flex flex-1 items-center justify-end px-3 py-1 text-muted-foreground text-xs",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? `${current}/${count}`}
+		</div>
+	);
+};
+
+export type InlineCitationCarouselPrevProps = ComponentProps<"button">;
+
+export const InlineCitationCarouselPrev = ({
+	className,
+	...props
+}: InlineCitationCarouselPrevProps) => {
+	const api = useCarouselApi();
+
+	const handleClick = useCallback(() => {
+		if (api) {
+			api.scrollPrev();
+		}
+	}, [api]);
+
+	return (
+		<button
+			aria-label="Previous"
+			className={cn("shrink-0", className)}
+			onClick={handleClick}
+			type="button"
+			{...props}
+		>
+			<ArrowLeftIcon className="size-4 text-muted-foreground" />
+		</button>
+	);
+};
+
+export type InlineCitationCarouselNextProps = ComponentProps<"button">;
+
+export const InlineCitationCarouselNext = ({
+	className,
+	...props
+}: InlineCitationCarouselNextProps) => {
+	const api = useCarouselApi();
+
+	const handleClick = useCallback(() => {
+		if (api) {
+			api.scrollNext();
+		}
+	}, [api]);
+
+	return (
+		<button
+			aria-label="Next"
+			className={cn("shrink-0", className)}
+			onClick={handleClick}
+			type="button"
+			{...props}
+		>
+			<ArrowRightIcon className="size-4 text-muted-foreground" />
+		</button>
+	);
+};
+
+export type InlineCitationSourceProps = ComponentProps<"div"> & {
+	title?: string;
+	url?: string;
+	description?: string;
+};
+
+export const InlineCitationSource = ({
+	title,
+	url,
+	description,
+	className,
+	children,
+	...props
+}: InlineCitationSourceProps) => (
+	<div className={cn("space-y-1", className)} {...props}>
+		{title && (
+			<h4 className="truncate font-medium text-sm leading-tight">{title}</h4>
+		)}
+		{url && (
+			<p className="truncate break-all text-muted-foreground text-xs">{url}</p>
+		)}
+		{description && (
+			<p className="line-clamp-3 text-muted-foreground text-sm leading-relaxed">
+				{description}
+			</p>
+		)}
+		{children}
+	</div>
+);
+
+export type InlineCitationQuoteProps = ComponentProps<"blockquote">;
+
+export const InlineCitationQuote = ({
+	children,
+	className,
+	...props
+}: InlineCitationQuoteProps) => (
+	<blockquote
+		className={cn(
+			"border-muted border-l-2 pl-3 text-muted-foreground text-sm italic",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</blockquote>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/jsx-preview.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/jsx-preview.tsx
new file mode 100644
index 0000000..4810aa7
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/jsx-preview.tsx
@@ -0,0 +1,301 @@
+"use client";
+
+import { AlertCircle } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import type { TProps as JsxParserProps } from "react-jsx-parser";
+import JsxParser from "react-jsx-parser";
+import { cn } from "@/lib/utils";
+
+interface JSXPreviewContextValue {
+	jsx: string;
+	processedJsx: string;
+	isStreaming: boolean;
+	error: Error | null;
+	setError: (error: Error | null) => void;
+	setLastGoodJsx: (jsx: string) => void;
+	components: JsxParserProps["components"];
+	bindings: JsxParserProps["bindings"];
+	onErrorProp?: (error: Error) => void;
+}
+
+const JSXPreviewContext = createContext<JSXPreviewContextValue | null>(null);
+
+const TAG_REGEX = /<\/?([a-zA-Z][a-zA-Z0-9]*)\s*([^>]*?)(\/)?>/;
+
+export const useJSXPreview = () => {
+	const context = useContext(JSXPreviewContext);
+	if (!context) {
+		throw new Error("JSXPreview components must be used within JSXPreview");
+	}
+	return context;
+};
+
+const matchJsxTag = (code: string) => {
+	if (code.trim() === "") {
+		return null;
+	}
+
+	const match = code.match(TAG_REGEX);
+
+	if (!match || match.index === undefined) {
+		return null;
+	}
+
+	const [fullMatch, tagName, attributes, selfClosing] = match;
+
+	let type: "self-closing" | "closing" | "opening";
+	if (selfClosing) {
+		type = "self-closing";
+	} else if (fullMatch.startsWith("</")) {
+		type = "closing";
+	} else {
+		type = "opening";
+	}
+
+	return {
+		attributes: attributes.trim(),
+		endIndex: match.index + fullMatch.length,
+		startIndex: match.index,
+		tag: fullMatch,
+		tagName,
+		type,
+	};
+};
+
+const stripIncompleteTag = (text: string) => {
+	// Find the last '<' that isn't part of a complete tag
+	const lastOpen = text.lastIndexOf("<");
+	if (lastOpen === -1) {
+		return text;
+	}
+
+	const afterOpen = text.slice(lastOpen);
+	// If there's no closing '>' after the last '<', it's an incomplete tag
+	if (!afterOpen.includes(">")) {
+		return text.slice(0, lastOpen);
+	}
+
+	return text;
+};
+
+const completeJsxTag = (code: string) => {
+	const stack: string[] = [];
+	let result = "";
+	let currentPosition = 0;
+
+	while (currentPosition < code.length) {
+		const match = matchJsxTag(code.slice(currentPosition));
+		if (!match) {
+			// No more tags found, strip any trailing incomplete tag
+			result += stripIncompleteTag(code.slice(currentPosition));
+			break;
+		}
+		const { tagName, type, endIndex } = match;
+
+		// Include any text content before this tag
+		result += code.slice(currentPosition, currentPosition + endIndex);
+
+		if (type === "opening") {
+			stack.push(tagName);
+		} else if (type === "closing") {
+			stack.pop();
+		}
+
+		currentPosition += endIndex;
+	}
+
+	return (
+		result +
+		stack
+			.toReversed()
+			.map((tag) => `</${tag}>`)
+			.join("")
+	);
+};
+
+export type JSXPreviewProps = ComponentProps<"div"> & {
+	jsx: string;
+	isStreaming?: boolean;
+	components?: JsxParserProps["components"];
+	bindings?: JsxParserProps["bindings"];
+	onError?: (error: Error) => void;
+};
+
+export const JSXPreview = memo(
+	({
+		jsx,
+		isStreaming = false,
+		components,
+		bindings,
+		onError,
+		className,
+		children,
+		...props
+	}: JSXPreviewProps) => {
+		const [prevJsx, setPrevJsx] = useState(jsx);
+		const [error, setError] = useState<Error | null>(null);
+		const [_lastGoodJsx, setLastGoodJsx] = useState("");
+
+		// Clear error when jsx changes (derived state pattern)
+		if (jsx !== prevJsx) {
+			setPrevJsx(jsx);
+			setError(null);
+		}
+
+		const processedJsx = useMemo(
+			() => (isStreaming ? completeJsxTag(jsx) : jsx),
+			[jsx, isStreaming],
+		);
+
+		const contextValue = useMemo(
+			() => ({
+				bindings,
+				components,
+				error,
+				isStreaming,
+				jsx,
+				onErrorProp: onError,
+				processedJsx,
+				setError,
+				setLastGoodJsx,
+			}),
+			[bindings, components, error, isStreaming, jsx, onError, processedJsx],
+		);
+
+		return (
+			<JSXPreviewContext.Provider value={contextValue}>
+				<div className={cn("relative", className)} {...props}>
+					{children}
+				</div>
+			</JSXPreviewContext.Provider>
+		);
+	},
+);
+
+JSXPreview.displayName = "JSXPreview";
+
+export type JSXPreviewContentProps = Omit<ComponentProps<"div">, "children">;
+
+export const JSXPreviewContent = memo(
+	({ className, ...props }: JSXPreviewContentProps) => {
+		const {
+			processedJsx,
+			isStreaming,
+			components,
+			bindings,
+			setError,
+			setLastGoodJsx,
+			onErrorProp,
+		} = useJSXPreview();
+		const errorReportedRef = useRef<string | null>(null);
+		const lastGoodJsxRef = useRef("");
+		const [hadError, setHadError] = useState(false);
+
+		// Reset error tracking when jsx changes
+		useEffect(() => {
+			errorReportedRef.current = null;
+			setHadError(false);
+		}, []);
+
+		const handleError = useCallback(
+			(err: Error) => {
+				// Prevent duplicate error reports for the same jsx
+				if (errorReportedRef.current === processedJsx) {
+					return;
+				}
+				errorReportedRef.current = processedJsx;
+
+				// During streaming, suppress errors and fall back to last good JSX
+				if (isStreaming) {
+					setHadError(true);
+					return;
+				}
+
+				setError(err);
+				onErrorProp?.(err);
+			},
+			[processedJsx, isStreaming, onErrorProp, setError],
+		);
+
+		// Track the last JSX that rendered without error
+		useEffect(() => {
+			if (!errorReportedRef.current) {
+				lastGoodJsxRef.current = processedJsx;
+				setLastGoodJsx(processedJsx);
+			}
+		}, [processedJsx, setLastGoodJsx]);
+
+		// During streaming, if the current JSX errored, re-render with last good version
+		const displayJsx =
+			isStreaming && hadError ? lastGoodJsxRef.current : processedJsx;
+
+		return (
+			<div className={cn("jsx-preview-content", className)} {...props}>
+				<JsxParser
+					bindings={bindings}
+					components={components}
+					jsx={displayJsx}
+					onError={handleError}
+					renderInWrapper={false}
+				/>
+			</div>
+		);
+	},
+);
+
+JSXPreviewContent.displayName = "JSXPreviewContent";
+
+export type JSXPreviewErrorProps = ComponentProps<"div"> & {
+	children?: ReactNode | ((error: Error) => ReactNode);
+};
+
+const renderChildren = (
+	children: ReactNode | ((error: Error) => ReactNode),
+	error: Error,
+): ReactNode => {
+	if (typeof children === "function") {
+		return children(error);
+	}
+	return children;
+};
+
+export const JSXPreviewError = memo(
+	({ className, children, ...props }: JSXPreviewErrorProps) => {
+		const { error } = useJSXPreview();
+
+		if (!error) {
+			return null;
+		}
+
+		return (
+			<div
+				className={cn(
+					"flex items-center gap-2 rounded-md border border-destructive/50 bg-destructive/10 p-3 text-destructive text-sm",
+					className,
+				)}
+				{...props}
+			>
+				{children ? (
+					renderChildren(children, error)
+				) : (
+					<>
+						<AlertCircle className="size-4 shrink-0" />
+						<span>{error.message}</span>
+					</>
+				)}
+			</div>
+		);
+	},
+);
+
+JSXPreviewError.displayName = "JSXPreviewError";
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/message.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/message.tsx
new file mode 100644
index 0000000..2113d6f
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/message.tsx
@@ -0,0 +1,357 @@
+"use client";
+
+import { cjk } from "@streamdown/cjk";
+import { code } from "@streamdown/code";
+import { math } from "@streamdown/math";
+import { mermaid } from "@streamdown/mermaid";
+import type { UIMessage } from "ai";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes, ReactElement } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useState,
+} from "react";
+import { Streamdown } from "streamdown";
+import { Button } from "@/components/ui/button";
+import { ButtonGroup, ButtonGroupText } from "@/components/ui/button-group";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export type MessageProps = HTMLAttributes<HTMLDivElement> & {
+	from: UIMessage["role"];
+};
+
+export const Message = ({ className, from, ...props }: MessageProps) => (
+	<div
+		className={cn(
+			"group flex w-full flex-col gap-2",
+			from === "user" ? "is-user ml-auto justify-end" : "is-assistant",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type MessageContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const MessageContent = ({
+	children,
+	className,
+	...props
+}: MessageContentProps) => (
+	<div
+		className={cn(
+			"is-user:dark flex w-full flex-col gap-2 overflow-hidden text-sm",
+			"group-[.is-user]:ml-auto group-[.is-user]:rounded-lg group-[.is-user]:bg-secondary group-[.is-user]:px-4 group-[.is-user]:py-3 group-[.is-user]:text-foreground",
+			"group-[.is-assistant]:text-foreground",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type MessageActionsProps = ComponentProps<"div">;
+
+export const MessageActions = ({
+	className,
+	children,
+	...props
+}: MessageActionsProps) => (
+	<div className={cn("flex items-center gap-1", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type MessageActionProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+	label?: string;
+};
+
+export const MessageAction = ({
+	tooltip,
+	children,
+	label,
+	variant = "ghost",
+	size = "icon-sm",
+	...props
+}: MessageActionProps) => {
+	const button = (
+		<Button size={size} type="button" variant={variant} {...props}>
+			{children}
+			<span className="sr-only">{label || tooltip}</span>
+		</Button>
+	);
+
+	if (tooltip) {
+		return (
+			<TooltipProvider>
+				<Tooltip>
+					<TooltipTrigger>{button}</TooltipTrigger>
+					<TooltipContent>
+						<p>{tooltip}</p>
+					</TooltipContent>
+				</Tooltip>
+			</TooltipProvider>
+		);
+	}
+
+	return button;
+};
+
+interface MessageBranchContextType {
+	currentBranch: number;
+	totalBranches: number;
+	goToPrevious: () => void;
+	goToNext: () => void;
+	branches: ReactElement[];
+	setBranches: (branches: ReactElement[]) => void;
+}
+
+const MessageBranchContext = createContext<MessageBranchContextType | null>(
+	null,
+);
+
+const useMessageBranch = () => {
+	const context = useContext(MessageBranchContext);
+
+	if (!context) {
+		throw new Error(
+			"MessageBranch components must be used within MessageBranch",
+		);
+	}
+
+	return context;
+};
+
+export type MessageBranchProps = HTMLAttributes<HTMLDivElement> & {
+	defaultBranch?: number;
+	onBranchChange?: (branchIndex: number) => void;
+};
+
+export const MessageBranch = ({
+	defaultBranch = 0,
+	onBranchChange,
+	className,
+	...props
+}: MessageBranchProps) => {
+	const [currentBranch, setCurrentBranch] = useState(defaultBranch);
+	const [branches, setBranches] = useState<ReactElement[]>([]);
+
+	const handleBranchChange = useCallback(
+		(newBranch: number) => {
+			setCurrentBranch(newBranch);
+			onBranchChange?.(newBranch);
+		},
+		[onBranchChange],
+	);
+
+	const goToPrevious = useCallback(() => {
+		const newBranch =
+			currentBranch > 0 ? currentBranch - 1 : branches.length - 1;
+		handleBranchChange(newBranch);
+	}, [currentBranch, branches.length, handleBranchChange]);
+
+	const goToNext = useCallback(() => {
+		const newBranch =
+			currentBranch < branches.length - 1 ? currentBranch + 1 : 0;
+		handleBranchChange(newBranch);
+	}, [currentBranch, branches.length, handleBranchChange]);
+
+	const contextValue = useMemo<MessageBranchContextType>(
+		() => ({
+			branches,
+			currentBranch,
+			goToNext,
+			goToPrevious,
+			setBranches,
+			totalBranches: branches.length,
+		}),
+		[branches, currentBranch, goToNext, goToPrevious],
+	);
+
+	return (
+		<MessageBranchContext.Provider value={contextValue}>
+			<div
+				className={cn("grid w-full gap-2 [&>div]:pb-0", className)}
+				{...props}
+			/>
+		</MessageBranchContext.Provider>
+	);
+};
+
+export type MessageBranchContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const MessageBranchContent = ({
+	children,
+	...props
+}: MessageBranchContentProps) => {
+	const { currentBranch, setBranches, branches } = useMessageBranch();
+	const childrenArray = useMemo(
+		() => (Array.isArray(children) ? children : [children]),
+		[children],
+	);
+
+	// Use useEffect to update branches when they change
+	useEffect(() => {
+		if (branches.length !== childrenArray.length) {
+			setBranches(childrenArray);
+		}
+	}, [childrenArray, branches, setBranches]);
+
+	return childrenArray.map((branch, index) => (
+		<div
+			className={cn(
+				"grid gap-2 overflow-hidden [&>div]:pb-0",
+				index === currentBranch ? "block" : "hidden",
+			)}
+			key={branch.key}
+			{...props}
+		>
+			{branch}
+		</div>
+	));
+};
+
+export type MessageBranchSelectorProps = ComponentProps<typeof ButtonGroup>;
+
+export const MessageBranchSelector = ({
+	className,
+	...props
+}: MessageBranchSelectorProps) => {
+	const { totalBranches } = useMessageBranch();
+
+	// Don't render if there's only one branch
+	if (totalBranches <= 1) {
+		return null;
+	}
+
+	return (
+		<ButtonGroup
+			className={cn(
+				"[&>*:not(:first-child)]:rounded-l-md [&>*:not(:last-child)]:rounded-r-md",
+				className,
+			)}
+			orientation="horizontal"
+			{...props}
+		/>
+	);
+};
+
+export type MessageBranchPreviousProps = ComponentProps<typeof Button>;
+
+export const MessageBranchPrevious = ({
+	children,
+	...props
+}: MessageBranchPreviousProps) => {
+	const { goToPrevious, totalBranches } = useMessageBranch();
+
+	return (
+		<Button
+			aria-label="Previous branch"
+			disabled={totalBranches <= 1}
+			onClick={goToPrevious}
+			size="icon-sm"
+			type="button"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <ChevronLeftIcon size={14} />}
+		</Button>
+	);
+};
+
+export type MessageBranchNextProps = ComponentProps<typeof Button>;
+
+export const MessageBranchNext = ({
+	children,
+	...props
+}: MessageBranchNextProps) => {
+	const { goToNext, totalBranches } = useMessageBranch();
+
+	return (
+		<Button
+			aria-label="Next branch"
+			disabled={totalBranches <= 1}
+			onClick={goToNext}
+			size="icon-sm"
+			type="button"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <ChevronRightIcon size={14} />}
+		</Button>
+	);
+};
+
+export type MessageBranchPageProps = HTMLAttributes<HTMLSpanElement>;
+
+export const MessageBranchPage = ({
+	className,
+	...props
+}: MessageBranchPageProps) => {
+	const { currentBranch, totalBranches } = useMessageBranch();
+
+	return (
+		<ButtonGroupText
+			className={cn(
+				"border-none bg-transparent text-muted-foreground shadow-none",
+				className,
+			)}
+			{...props}
+		>
+			{currentBranch + 1} of {totalBranches}
+		</ButtonGroupText>
+	);
+};
+
+export type MessageResponseProps = ComponentProps<typeof Streamdown>;
+
+const streamdownPlugins = { cjk, code, math, mermaid };
+
+export const MessageResponse = memo(
+	({ className, ...props }: MessageResponseProps) => (
+		<Streamdown
+			className={cn(
+				"size-full [&>*:first-child]:mt-0 [&>*:last-child]:mb-0",
+				className,
+			)}
+			plugins={streamdownPlugins}
+			{...props}
+		/>
+	),
+	(prevProps, nextProps) =>
+		prevProps.children === nextProps.children &&
+		nextProps.isAnimating === prevProps.isAnimating,
+);
+
+MessageResponse.displayName = "MessageResponse";
+
+export type MessageToolbarProps = ComponentProps<"div">;
+
+export const MessageToolbar = ({
+	className,
+	children,
+	...props
+}: MessageToolbarProps) => (
+	<div
+		className={cn(
+			"mt-4 flex w-full items-center justify-between gap-4",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/mic-selector.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/mic-selector.tsx
new file mode 100644
index 0000000..338df9a
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/mic-selector.tsx
@@ -0,0 +1,373 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { ChevronsUpDownIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Command,
+	CommandEmpty,
+	CommandInput,
+	CommandItem,
+	CommandList,
+} from "@/components/ui/command";
+import {
+	Popover,
+	PopoverContent,
+	PopoverTrigger,
+} from "@/components/ui/popover";
+import { cn } from "@/lib/utils";
+
+const deviceIdRegex = /\(([\da-fA-F]{4}:[\da-fA-F]{4})\)$/;
+
+interface MicSelectorContextType {
+	data: MediaDeviceInfo[];
+	value: string | undefined;
+	onValueChange?: (value: string) => void;
+	open: boolean;
+	onOpenChange?: (open: boolean) => void;
+	width: number;
+	setWidth?: (width: number) => void;
+}
+
+const MicSelectorContext = createContext<MicSelectorContextType>({
+	data: [],
+	onOpenChange: undefined,
+	onValueChange: undefined,
+	open: false,
+	setWidth: undefined,
+	value: undefined,
+	width: 200,
+});
+
+export const useAudioDevices = () => {
+	const [devices, setDevices] = useState<MediaDeviceInfo[]>([]);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState<string | null>(null);
+	const [hasPermission, setHasPermission] = useState(false);
+
+	const loadDevicesWithoutPermission = useCallback(async () => {
+		try {
+			setLoading(true);
+			setError(null);
+
+			const deviceList = await navigator.mediaDevices.enumerateDevices();
+			const audioInputs = deviceList.filter(
+				(device) => device.kind === "audioinput",
+			);
+
+			setDevices(audioInputs);
+		} catch (caughtError) {
+			const message =
+				caughtError instanceof Error
+					? caughtError.message
+					: "Failed to get audio devices";
+
+			setError(message);
+			console.error("Error getting audio devices:", message);
+		} finally {
+			setLoading(false);
+		}
+	}, []);
+
+	const loadDevicesWithPermission = useCallback(async () => {
+		if (loading) {
+			return;
+		}
+
+		try {
+			setLoading(true);
+			setError(null);
+
+			const tempStream = await navigator.mediaDevices.getUserMedia({
+				audio: true,
+			});
+
+			for (const track of tempStream.getTracks()) {
+				track.stop();
+			}
+
+			const deviceList = await navigator.mediaDevices.enumerateDevices();
+			const audioInputs = deviceList.filter(
+				(device) => device.kind === "audioinput",
+			);
+
+			setDevices(audioInputs);
+			setHasPermission(true);
+		} catch (caughtError) {
+			const message =
+				caughtError instanceof Error
+					? caughtError.message
+					: "Failed to get audio devices";
+
+			setError(message);
+			console.error("Error getting audio devices:", message);
+		} finally {
+			setLoading(false);
+		}
+	}, [loading]);
+
+	useEffect(() => {
+		loadDevicesWithoutPermission();
+	}, [loadDevicesWithoutPermission]);
+
+	useEffect(() => {
+		const handleDeviceChange = () => {
+			if (hasPermission) {
+				loadDevicesWithPermission();
+			} else {
+				loadDevicesWithoutPermission();
+			}
+		};
+
+		navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
+
+		return () => {
+			navigator.mediaDevices.removeEventListener(
+				"devicechange",
+				handleDeviceChange,
+			);
+		};
+	}, [hasPermission, loadDevicesWithPermission, loadDevicesWithoutPermission]);
+
+	return {
+		devices,
+		error,
+		hasPermission,
+		loadDevices: loadDevicesWithPermission,
+		loading,
+	};
+};
+
+export type MicSelectorProps = ComponentProps<typeof Popover> & {
+	defaultValue?: string;
+	value?: string | undefined;
+	onValueChange?: (value: string | undefined) => void;
+	open?: boolean;
+	onOpenChange?: (open: boolean) => void;
+};
+
+export const MicSelector = ({
+	defaultValue,
+	value: controlledValue,
+	onValueChange: controlledOnValueChange,
+	defaultOpen = false,
+	open: controlledOpen,
+	onOpenChange: controlledOnOpenChange,
+	...props
+}: MicSelectorProps) => {
+	const [value, onValueChange] = useControllableState<string | undefined>({
+		defaultProp: defaultValue,
+		onChange: controlledOnValueChange,
+		prop: controlledValue,
+	});
+	const [open, onOpenChange] = useControllableState({
+		defaultProp: defaultOpen,
+		onChange: controlledOnOpenChange,
+		prop: controlledOpen,
+	});
+	const [width, setWidth] = useState(200);
+	const { devices, loading, hasPermission, loadDevices } = useAudioDevices();
+
+	useEffect(() => {
+		if (open && !hasPermission && !loading) {
+			loadDevices();
+		}
+	}, [open, hasPermission, loading, loadDevices]);
+
+	const contextValue = useMemo(
+		() => ({
+			data: devices,
+			onOpenChange,
+			onValueChange,
+			open,
+			setWidth,
+			value,
+			width,
+		}),
+		[devices, onOpenChange, onValueChange, open, value, width],
+	);
+
+	return (
+		<MicSelectorContext.Provider value={contextValue}>
+			<Popover {...props} onOpenChange={onOpenChange} open={open} />
+		</MicSelectorContext.Provider>
+	);
+};
+
+export type MicSelectorTriggerProps = ComponentProps<typeof Button>;
+
+export const MicSelectorTrigger = ({
+	children,
+	...props
+}: MicSelectorTriggerProps) => {
+	const { setWidth } = useContext(MicSelectorContext);
+	const ref = useRef<HTMLButtonElement>(null);
+
+	useEffect(() => {
+		// Create a ResizeObserver to detect width changes
+		const resizeObserver = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				const newWidth = (entry.target as HTMLElement).offsetWidth;
+				if (newWidth) {
+					setWidth?.(newWidth);
+				}
+			}
+		});
+
+		if (ref.current) {
+			resizeObserver.observe(ref.current);
+		}
+
+		// Clean up the observer when component unmounts
+		return () => {
+			resizeObserver.disconnect();
+		};
+	}, [setWidth]);
+
+	return (
+		<PopoverTrigger render={<Button variant="outline" {...props} ref={ref} />}>
+			{children}
+			<ChevronsUpDownIcon
+				className="shrink-0 text-muted-foreground"
+				size={16}
+			/>
+		</PopoverTrigger>
+	);
+};
+
+export type MicSelectorContentProps = ComponentProps<typeof Command> & {
+	popoverOptions?: ComponentProps<typeof PopoverContent>;
+};
+
+export const MicSelectorContent = ({
+	className,
+	popoverOptions,
+	...props
+}: MicSelectorContentProps) => {
+	const { width, onValueChange, value } = useContext(MicSelectorContext);
+
+	return (
+		<PopoverContent
+			className={cn("p-0", className)}
+			style={{ width }}
+			{...popoverOptions}
+		>
+			<Command onValueChange={onValueChange} value={value} {...props} />
+		</PopoverContent>
+	);
+};
+
+export type MicSelectorInputProps = ComponentProps<typeof CommandInput> & {
+	value?: string;
+	defaultValue?: string;
+	onValueChange?: (value: string) => void;
+};
+
+export const MicSelectorInput = ({ ...props }: MicSelectorInputProps) => (
+	<CommandInput placeholder="Search microphones..." {...props} />
+);
+
+export type MicSelectorListProps = Omit<
+	ComponentProps<typeof CommandList>,
+	"children"
+> & {
+	children: (devices: MediaDeviceInfo[]) => ReactNode;
+};
+
+export const MicSelectorList = ({
+	children,
+	...props
+}: MicSelectorListProps) => {
+	const { data } = useContext(MicSelectorContext);
+
+	return <CommandList {...props}>{children(data)}</CommandList>;
+};
+
+export type MicSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const MicSelectorEmpty = ({
+	children = "No microphone found.",
+	...props
+}: MicSelectorEmptyProps) => <CommandEmpty {...props}>{children}</CommandEmpty>;
+
+export type MicSelectorItemProps = ComponentProps<typeof CommandItem>;
+
+export const MicSelectorItem = (props: MicSelectorItemProps) => {
+	const { onValueChange, onOpenChange } = useContext(MicSelectorContext);
+
+	const handleSelect = useCallback(
+		(currentValue: string) => {
+			onValueChange?.(currentValue);
+			onOpenChange?.(false);
+		},
+		[onValueChange, onOpenChange],
+	);
+
+	return <CommandItem onSelect={handleSelect} {...props} />;
+};
+
+export type MicSelectorLabelProps = ComponentProps<"span"> & {
+	device: MediaDeviceInfo;
+};
+
+export const MicSelectorLabel = ({
+	device,
+	className,
+	...props
+}: MicSelectorLabelProps) => {
+	const matches = device.label.match(deviceIdRegex);
+
+	if (!matches) {
+		return (
+			<span className={className} {...props}>
+				{device.label}
+			</span>
+		);
+	}
+
+	const [, deviceId] = matches;
+	const name = device.label.replace(deviceIdRegex, "");
+
+	return (
+		<span className={className} {...props}>
+			<span>{name}</span>
+			<span className="text-muted-foreground"> ({deviceId})</span>
+		</span>
+	);
+};
+
+export type MicSelectorValueProps = ComponentProps<"span">;
+
+export const MicSelectorValue = ({
+	className,
+	...props
+}: MicSelectorValueProps) => {
+	const { data, value } = useContext(MicSelectorContext);
+	const currentDevice = data.find((d) => d.deviceId === value);
+
+	if (!currentDevice) {
+		return (
+			<span className={cn("flex-1 text-left", className)} {...props}>
+				Select microphone...
+			</span>
+		);
+	}
+
+	return (
+		<MicSelectorLabel
+			className={cn("flex-1 text-left", className)}
+			device={currentDevice}
+			{...props}
+		/>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/model-selector.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/model-selector.tsx
new file mode 100644
index 0000000..193d178
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/model-selector.tsx
@@ -0,0 +1,213 @@
+import type { ComponentProps, ReactNode } from "react";
+import {
+	Command,
+	CommandDialog,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+	CommandSeparator,
+	CommandShortcut,
+} from "@/components/ui/command";
+import {
+	Dialog,
+	DialogContent,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { cn } from "@/lib/utils";
+
+export type ModelSelectorProps = ComponentProps<typeof Dialog>;
+
+export const ModelSelector = (props: ModelSelectorProps) => (
+	<Dialog {...props} />
+);
+
+export type ModelSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+
+export const ModelSelectorTrigger = (props: ModelSelectorTriggerProps) => (
+	<DialogTrigger {...props} />
+);
+
+export type ModelSelectorContentProps = ComponentProps<typeof DialogContent> & {
+	title?: ReactNode;
+};
+
+export const ModelSelectorContent = ({
+	className,
+	children,
+	title = "Model Selector",
+	...props
+}: ModelSelectorContentProps) => (
+	<DialogContent
+		aria-describedby={undefined}
+		className={cn(
+			"outline! border-none! p-0 outline-border! outline-solid!",
+			className,
+		)}
+		{...props}
+	>
+		<DialogTitle className="sr-only">{title}</DialogTitle>
+		<Command className="**:data-[slot=command-input-wrapper]:h-auto">
+			{children}
+		</Command>
+	</DialogContent>
+);
+
+export type ModelSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+
+export const ModelSelectorDialog = (props: ModelSelectorDialogProps) => (
+	<CommandDialog {...props} />
+);
+
+export type ModelSelectorInputProps = ComponentProps<typeof CommandInput>;
+
+export const ModelSelectorInput = ({
+	className,
+	...props
+}: ModelSelectorInputProps) => (
+	<CommandInput className={cn("h-auto py-3.5", className)} {...props} />
+);
+
+export type ModelSelectorListProps = ComponentProps<typeof CommandList>;
+
+export const ModelSelectorList = (props: ModelSelectorListProps) => (
+	<CommandList {...props} />
+);
+
+export type ModelSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const ModelSelectorEmpty = (props: ModelSelectorEmptyProps) => (
+	<CommandEmpty {...props} />
+);
+
+export type ModelSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+
+export const ModelSelectorGroup = (props: ModelSelectorGroupProps) => (
+	<CommandGroup {...props} />
+);
+
+export type ModelSelectorItemProps = ComponentProps<typeof CommandItem>;
+
+export const ModelSelectorItem = (props: ModelSelectorItemProps) => (
+	<CommandItem {...props} />
+);
+
+export type ModelSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+
+export const ModelSelectorShortcut = (props: ModelSelectorShortcutProps) => (
+	<CommandShortcut {...props} />
+);
+
+export type ModelSelectorSeparatorProps = ComponentProps<
+	typeof CommandSeparator
+>;
+
+export const ModelSelectorSeparator = (props: ModelSelectorSeparatorProps) => (
+	<CommandSeparator {...props} />
+);
+
+export type ModelSelectorLogoProps = Omit<
+	ComponentProps<"img">,
+	"src" | "alt"
+> & {
+	provider:
+		| "moonshotai-cn"
+		| "lucidquery"
+		| "moonshotai"
+		| "zai-coding-plan"
+		| "alibaba"
+		| "xai"
+		| "vultr"
+		| "nvidia"
+		| "upstage"
+		| "groq"
+		| "github-copilot"
+		| "mistral"
+		| "vercel"
+		| "nebius"
+		| "deepseek"
+		| "alibaba-cn"
+		| "google-vertex-anthropic"
+		| "venice"
+		| "chutes"
+		| "cortecs"
+		| "github-models"
+		| "togetherai"
+		| "azure"
+		| "baseten"
+		| "huggingface"
+		| "opencode"
+		| "fastrouter"
+		| "google"
+		| "google-vertex"
+		| "cloudflare-workers-ai"
+		| "inception"
+		| "wandb"
+		| "openai"
+		| "zhipuai-coding-plan"
+		| "perplexity"
+		| "openrouter"
+		| "zenmux"
+		| "v0"
+		| "iflowcn"
+		| "synthetic"
+		| "deepinfra"
+		| "zhipuai"
+		| "submodel"
+		| "zai"
+		| "inference"
+		| "requesty"
+		| "morph"
+		| "lmstudio"
+		| "anthropic"
+		| "aihubmix"
+		| "fireworks-ai"
+		| "modelscope"
+		| "llama"
+		| "scaleway"
+		| "amazon-bedrock"
+		| "cerebras"
+		// oxlint-disable-next-line typescript-eslint(ban-types) -- intentional pattern for autocomplete-friendly string union
+		| (string & {});
+};
+
+export const ModelSelectorLogo = ({
+	provider,
+	className,
+	...props
+}: ModelSelectorLogoProps) => (
+	<img
+		{...props}
+		alt={`${provider} logo`}
+		className={cn("size-3 dark:invert", className)}
+		height={12}
+		src={`https://models.dev/logos/${provider}.svg`}
+		width={12}
+	/>
+);
+
+export type ModelSelectorLogoGroupProps = ComponentProps<"div">;
+
+export const ModelSelectorLogoGroup = ({
+	className,
+	...props
+}: ModelSelectorLogoGroupProps) => (
+	<div
+		className={cn(
+			"flex shrink-0 items-center -space-x-1 [&>img]:rounded-full [&>img]:bg-background [&>img]:p-px [&>img]:ring-1 dark:[&>img]:bg-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ModelSelectorNameProps = ComponentProps<"span">;
+
+export const ModelSelectorName = ({
+	className,
+	...props
+}: ModelSelectorNameProps) => (
+	<span className={cn("flex-1 truncate text-left", className)} {...props} />
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/node.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/node.tsx
new file mode 100644
index 0000000..b584069
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/node.tsx
@@ -0,0 +1,71 @@
+import { Handle, Position } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import {
+	Card,
+	CardAction,
+	CardContent,
+	CardDescription,
+	CardFooter,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import { cn } from "@/lib/utils";
+
+export type NodeProps = ComponentProps<typeof Card> & {
+	handles: {
+		target: boolean;
+		source: boolean;
+	};
+};
+
+export const Node = ({ handles, className, ...props }: NodeProps) => (
+	<Card
+		className={cn(
+			"node-container relative size-full h-auto w-sm gap-0 rounded-md p-0",
+			className,
+		)}
+		{...props}
+	>
+		{handles.target && <Handle position={Position.Left} type="target" />}
+		{handles.source && <Handle position={Position.Right} type="source" />}
+		{props.children}
+	</Card>
+);
+
+export type NodeHeaderProps = ComponentProps<typeof CardHeader>;
+
+export const NodeHeader = ({ className, ...props }: NodeHeaderProps) => (
+	<CardHeader
+		className={cn("gap-0.5 rounded-t-md border-b bg-secondary p-3!", className)}
+		{...props}
+	/>
+);
+
+export type NodeTitleProps = ComponentProps<typeof CardTitle>;
+
+export const NodeTitle = (props: NodeTitleProps) => <CardTitle {...props} />;
+
+export type NodeDescriptionProps = ComponentProps<typeof CardDescription>;
+
+export const NodeDescription = (props: NodeDescriptionProps) => (
+	<CardDescription {...props} />
+);
+
+export type NodeActionProps = ComponentProps<typeof CardAction>;
+
+export const NodeAction = (props: NodeActionProps) => <CardAction {...props} />;
+
+export type NodeContentProps = ComponentProps<typeof CardContent>;
+
+export const NodeContent = ({ className, ...props }: NodeContentProps) => (
+	<CardContent className={cn("p-3", className)} {...props} />
+);
+
+export type NodeFooterProps = ComponentProps<typeof CardFooter>;
+
+export const NodeFooter = ({ className, ...props }: NodeFooterProps) => (
+	<CardFooter
+		className={cn("rounded-b-md border-t bg-secondary p-3!", className)}
+		{...props}
+	/>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/open-in-chat.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/open-in-chat.tsx
new file mode 100644
index 0000000..52f9a4e
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/open-in-chat.tsx
@@ -0,0 +1,394 @@
+"use client";
+
+import {
+	ChevronDownIcon,
+	ExternalLinkIcon,
+	MessageCircleIcon,
+} from "lucide-react";
+import type { ComponentProps } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuLabel,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { cn } from "@/lib/utils";
+
+const providers = {
+	chatgpt: {
+		createUrl: (prompt: string) =>
+			`https://chatgpt.com/?${new URLSearchParams({
+				hints: "search",
+				prompt,
+			})}`,
+		icon: (
+			<svg
+				fill="currentColor"
+				role="img"
+				viewBox="0 0 24 24"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>OpenAI</title>
+				<path d="M22.2819 9.8211a5.9847 5.9847 0 0 0-.5157-4.9108 6.0462 6.0462 0 0 0-6.5098-2.9A6.0651 6.0651 0 0 0 4.9807 4.1818a5.9847 5.9847 0 0 0-3.9977 2.9 6.0462 6.0462 0 0 0 .7427 7.0966 5.98 5.98 0 0 0 .511 4.9107 6.051 6.051 0 0 0 6.5146 2.9001A5.9847 5.9847 0 0 0 13.2599 24a6.0557 6.0557 0 0 0 5.7718-4.2058 5.9894 5.9894 0 0 0 3.9977-2.9001 6.0557 6.0557 0 0 0-.7475-7.0729zm-9.022 12.6081a4.4755 4.4755 0 0 1-2.8764-1.0408l.1419-.0804 4.7783-2.7582a.7948.7948 0 0 0 .3927-.6813v-6.7369l2.02 1.1686a.071.071 0 0 1 .038.052v5.5826a4.504 4.504 0 0 1-4.4945 4.4944zm-9.6607-4.1254a4.4708 4.4708 0 0 1-.5346-3.0137l.142.0852 4.783 2.7582a.7712.7712 0 0 0 .7806 0l5.8428-3.3685v2.3324a.0804.0804 0 0 1-.0332.0615L9.74 19.9502a4.4992 4.4992 0 0 1-6.1408-1.6464zM2.3408 7.8956a4.485 4.485 0 0 1 2.3655-1.9728V11.6a.7664.7664 0 0 0 .3879.6765l5.8144 3.3543-2.0201 1.1685a.0757.0757 0 0 1-.071 0l-4.8303-2.7865A4.504 4.504 0 0 1 2.3408 7.872zm16.5963 3.8558L13.1038 8.364 15.1192 7.2a.0757.0757 0 0 1 .071 0l4.8303 2.7913a4.4944 4.4944 0 0 1-.6765 8.1042v-5.6772a.79.79 0 0 0-.407-.667zm2.0107-3.0231l-.142-.0852-4.7735-2.7818a.7759.7759 0 0 0-.7854 0L9.409 9.2297V6.8974a.0662.0662 0 0 1 .0284-.0615l4.8303-2.7866a4.4992 4.4992 0 0 1 6.6802 4.66zM8.3065 12.863l-2.02-1.1638a.0804.0804 0 0 1-.038-.0567V6.0742a4.4992 4.4992 0 0 1 7.3757-3.4537l-.142.0805L8.704 5.459a.7948.7948 0 0 0-.3927.6813zm1.0976-2.3654l2.602-1.4998 2.6069 1.4998v2.9994l-2.5974 1.4997-2.6067-1.4997Z" />
+			</svg>
+		),
+		title: "Open in ChatGPT",
+	},
+	claude: {
+		createUrl: (q: string) =>
+			`https://claude.ai/new?${new URLSearchParams({
+				q,
+			})}`,
+		icon: (
+			<svg
+				fill="currentColor"
+				role="img"
+				viewBox="0 0 12 12"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>Claude</title>
+				<path
+					clipRule="evenodd"
+					d="M2.3545 7.9775L4.7145 6.654L4.7545 6.539L4.7145 6.475H4.6L4.205 6.451L2.856 6.4145L1.6865 6.366L0.5535 6.305L0.268 6.2445L0 5.892L0.0275 5.716L0.2675 5.5555L0.6105 5.5855L1.3705 5.637L2.5095 5.716L3.3355 5.7645L4.56 5.892H4.7545L4.782 5.8135L4.715 5.7645L4.6635 5.716L3.4845 4.918L2.2085 4.074L1.5405 3.588L1.1785 3.3425L0.9965 3.1115L0.9175 2.6075L1.2455 2.2465L1.686 2.2765L1.7985 2.307L2.245 2.65L3.199 3.388L4.4445 4.3045L4.627 4.4565L4.6995 4.405L4.709 4.3685L4.627 4.2315L3.9495 3.0085L3.2265 1.7635L2.9045 1.2475L2.8195 0.938C2.78711 0.819128 2.76965 0.696687 2.7675 0.5735L3.1415 0.067L3.348 0L3.846 0.067L4.056 0.249L4.366 0.956L4.867 2.0705L5.6445 3.5855L5.8725 4.0345L5.994 4.4505L6.0395 4.578H6.1185V4.505L6.1825 3.652L6.301 2.6045L6.416 1.257L6.456 0.877L6.644 0.422L7.0175 0.176L7.3095 0.316L7.5495 0.6585L7.516 0.8805L7.373 1.806L7.0935 3.2575L6.9115 4.2285H7.0175L7.139 4.1075L7.6315 3.4545L8.4575 2.4225L8.8225 2.0125L9.2475 1.5605L9.521 1.345H10.0375L10.4175 1.9095L10.2475 2.4925L9.7155 3.166L9.275 3.737L8.643 4.587L8.248 5.267L8.2845 5.322L8.3785 5.312L9.8065 5.009L10.578 4.869L11.4985 4.7115L11.915 4.9055L11.9605 5.103L11.7965 5.5065L10.812 5.7495L9.6575 5.9805L7.938 6.387L7.917 6.402L7.9415 6.4325L8.716 6.5055L9.047 6.5235H9.858L11.368 6.636L11.763 6.897L12 7.216L11.9605 7.4585L11.353 7.7685L10.533 7.574L8.6185 7.119L7.9625 6.9545H7.8715V7.0095L8.418 7.5435L9.421 8.4485L10.6755 9.6135L10.739 9.9025L10.578 10.13L10.408 10.1055L9.3055 9.277L8.88 8.9035L7.917 8.0935H7.853V8.1785L8.075 8.503L9.2475 10.2635L9.3085 10.8035L9.2235 10.98L8.9195 11.0865L8.5855 11.0255L7.8985 10.063L7.191 8.9795L6.6195 8.008L6.5495 8.048L6.2125 11.675L6.0545 11.86L5.69 12L5.3865 11.7695L5.2255 11.396L5.3865 10.658L5.581 9.696L5.7385 8.931L5.8815 7.981L5.9665 7.665L5.9605 7.644L5.8905 7.653L5.1735 8.6365L4.0835 10.109L3.2205 11.0315L3.0135 11.1135L2.655 10.9285L2.6885 10.5975L2.889 10.303L4.083 8.785L4.803 7.844L5.268 7.301L5.265 7.222H5.2375L2.066 9.28L1.501 9.353L1.2575 9.125L1.288 8.752L1.4035 8.6305L2.3575 7.9745L2.3545 7.9775Z"
+					fillRule="evenodd"
+				/>
+			</svg>
+		),
+		title: "Open in Claude",
+	},
+	cursor: {
+		createUrl: (text: string) => {
+			const url = new URL("https://cursor.com/link/prompt");
+			url.searchParams.set("text", text);
+			return url.toString();
+		},
+		icon: (
+			<svg
+				version="1.1"
+				viewBox="0 0 466.73 532.09"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>Cursor</title>
+				<path
+					d="M457.43,125.94L244.42,2.96c-6.84-3.95-15.28-3.95-22.12,0L9.3,125.94c-5.75,3.32-9.3,9.46-9.3,16.11v247.99c0,6.65,3.55,12.79,9.3,16.11l213.01,122.98c6.84,3.95,15.28,3.95,22.12,0l213.01-122.98c5.75-3.32,9.3-9.46,9.3-16.11v-247.99c0-6.65-3.55-12.79-9.3-16.11h-.01ZM444.05,151.99l-205.63,356.16c-1.39,2.4-5.06,1.42-5.06-1.36v-233.21c0-4.66-2.49-8.97-6.53-11.31L24.87,145.67c-2.4-1.39-1.42-5.06,1.36-5.06h411.26c5.84,0,9.49,6.33,6.57,11.39h-.01Z"
+					fill="currentColor"
+				/>
+			</svg>
+		),
+		title: "Open in Cursor",
+	},
+	github: {
+		createUrl: (url: string) => url,
+		icon: (
+			<svg fill="currentColor" role="img" viewBox="0 0 24 24">
+				<title>GitHub</title>
+				<path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12" />
+			</svg>
+		),
+		title: "Open in GitHub",
+	},
+	scira: {
+		createUrl: (q: string) =>
+			`https://scira.ai/?${new URLSearchParams({
+				q,
+			})}`,
+		icon: (
+			<svg
+				fill="none"
+				height="934"
+				viewBox="0 0 910 934"
+				width="910"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>Scira AI</title>
+				<path
+					d="M647.664 197.775C569.13 189.049 525.5 145.419 516.774 66.8849C508.048 145.419 464.418 189.049 385.884 197.775C464.418 206.501 508.048 250.131 516.774 328.665C525.5 250.131 569.13 206.501 647.664 197.775Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M516.774 304.217C510.299 275.491 498.208 252.087 480.335 234.214C462.462 216.341 439.058 204.251 410.333 197.775C439.059 191.3 462.462 179.209 480.335 161.336C498.208 143.463 510.299 120.06 516.774 91.334C523.25 120.059 535.34 143.463 553.213 161.336C571.086 179.209 594.49 191.3 623.216 197.775C594.49 204.251 571.086 216.341 553.213 234.214C535.34 252.087 523.25 275.491 516.774 304.217Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M857.5 508.116C763.259 497.644 710.903 445.288 700.432 351.047C689.961 445.288 637.605 497.644 543.364 508.116C637.605 518.587 689.961 570.943 700.432 665.184C710.903 570.943 763.259 518.587 857.5 508.116Z"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="20"
+				/>
+				<path
+					d="M700.432 615.957C691.848 589.05 678.575 566.357 660.383 548.165C642.191 529.973 619.499 516.7 592.593 508.116C619.499 499.533 642.191 486.258 660.383 468.066C678.575 449.874 691.848 427.181 700.432 400.274C709.015 427.181 722.289 449.874 740.481 468.066C758.673 486.258 781.365 499.533 808.271 508.116C781.365 516.7 758.673 529.973 740.481 548.165C722.289 566.357 709.015 589.05 700.432 615.957Z"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="20"
+				/>
+				<path
+					d="M889.949 121.237C831.049 114.692 798.326 81.9698 791.782 23.0692C785.237 81.9698 752.515 114.692 693.614 121.237C752.515 127.781 785.237 160.504 791.782 219.404C798.326 160.504 831.049 127.781 889.949 121.237Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M791.782 196.795C786.697 176.937 777.869 160.567 765.16 147.858C752.452 135.15 736.082 126.322 716.226 121.237C736.082 116.152 752.452 107.324 765.16 94.6152C777.869 81.9065 786.697 65.5368 791.782 45.6797C796.867 65.5367 805.695 81.9066 818.403 94.6152C831.112 107.324 847.481 116.152 867.338 121.237C847.481 126.322 831.112 135.15 818.403 147.858C805.694 160.567 796.867 176.937 791.782 196.795Z"
+					fill="currentColor"
+					stroke="currentColor"
+					strokeLinejoin="round"
+					strokeWidth="8"
+				/>
+				<path
+					d="M760.632 764.337C720.719 814.616 669.835 855.1 611.872 882.692C553.91 910.285 490.404 924.255 426.213 923.533C362.022 922.812 298.846 907.419 241.518 878.531C184.19 849.643 134.228 808.026 95.4548 756.863C56.6815 705.7 30.1238 646.346 17.8129 583.343C5.50207 520.339 7.76433 455.354 24.4266 393.359C41.089 331.364 71.7099 274.001 113.947 225.658C156.184 177.315 208.919 139.273 268.117 114.442"
+					stroke="currentColor"
+					strokeLinecap="round"
+					strokeLinejoin="round"
+					strokeWidth="30"
+				/>
+			</svg>
+		),
+		title: "Open in Scira",
+	},
+	t3: {
+		createUrl: (q: string) =>
+			`https://t3.chat/new?${new URLSearchParams({
+				q,
+			})}`,
+		icon: <MessageCircleIcon />,
+		title: "Open in T3 Chat",
+	},
+	v0: {
+		createUrl: (q: string) =>
+			`https://v0.app?${new URLSearchParams({
+				q,
+			})}`,
+		icon: (
+			<svg
+				fill="currentColor"
+				viewBox="0 0 147 70"
+				xmlns="http://www.w3.org/2000/svg"
+			>
+				<title>v0</title>
+				<path d="M56 50.2031V14H70V60.1562C70 65.5928 65.5928 70 60.1562 70C57.5605 70 54.9982 68.9992 53.1562 67.1573L0 14H19.7969L56 50.2031Z" />
+				<path d="M147 56H133V23.9531L100.953 56H133V70H96.6875C85.8144 70 77 61.1856 77 50.3125V14H91V46.1562L123.156 14H91V0H127.312C138.186 0 147 8.81439 147 19.6875V56Z" />
+			</svg>
+		),
+		title: "Open in v0",
+	},
+};
+
+const OpenInContext = createContext<{ query: string } | undefined>(undefined);
+
+const useOpenInContext = () => {
+	const context = useContext(OpenInContext);
+	if (!context) {
+		throw new Error("OpenIn components must be used within an OpenIn provider");
+	}
+	return context;
+};
+
+export type OpenInProps = ComponentProps<typeof DropdownMenu> & {
+	query: string;
+};
+
+export const OpenIn = ({ query, ...props }: OpenInProps) => {
+	const contextValue = useMemo(() => ({ query }), [query]);
+
+	return (
+		<OpenInContext.Provider value={contextValue}>
+			<DropdownMenu {...props} />
+		</OpenInContext.Provider>
+	);
+};
+
+export type OpenInContentProps = ComponentProps<typeof DropdownMenuContent>;
+
+export const OpenInContent = ({ className, ...props }: OpenInContentProps) => (
+	<DropdownMenuContent
+		align="start"
+		className={cn("w-[240px]", className)}
+		{...props}
+	/>
+);
+
+export type OpenInItemProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInItem = (props: OpenInItemProps) => (
+	<DropdownMenuItem {...props} />
+);
+
+export type OpenInLabelProps = ComponentProps<typeof DropdownMenuLabel>;
+
+export const OpenInLabel = (props: OpenInLabelProps) => (
+	<DropdownMenuLabel {...props} />
+);
+
+export type OpenInSeparatorProps = ComponentProps<typeof DropdownMenuSeparator>;
+
+export const OpenInSeparator = (props: OpenInSeparatorProps) => (
+	<DropdownMenuSeparator {...props} />
+);
+
+export type OpenInTriggerProps = ComponentProps<typeof DropdownMenuTrigger>;
+
+export const OpenInTrigger = ({ children, ...props }: OpenInTriggerProps) => (
+	<DropdownMenuTrigger {...props}>
+		{children ?? (
+			<Button type="button" variant="outline">
+				Open in chat
+				<ChevronDownIcon className="size-4" />
+			</Button>
+		)}
+	</DropdownMenuTrigger>
+);
+
+export type OpenInChatGPTProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInChatGPT = (props: OpenInChatGPTProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.chatgpt.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.chatgpt.icon}</span>
+			<span className="flex-1">{providers.chatgpt.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInClaudeProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInClaude = (props: OpenInClaudeProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.claude.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.claude.icon}</span>
+			<span className="flex-1">{providers.claude.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInT3Props = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInT3 = (props: OpenInT3Props) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.t3.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.t3.icon}</span>
+			<span className="flex-1">{providers.t3.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInSciraProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInScira = (props: OpenInSciraProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.scira.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.scira.icon}</span>
+			<span className="flex-1">{providers.scira.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInv0Props = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInv0 = (props: OpenInv0Props) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.v0.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.v0.icon}</span>
+			<span className="flex-1">{providers.v0.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
+
+export type OpenInCursorProps = ComponentProps<typeof DropdownMenuItem>;
+
+export const OpenInCursor = (props: OpenInCursorProps) => {
+	const { query } = useOpenInContext();
+	return (
+		<DropdownMenuItem
+			{...props}
+			render={
+				// biome-ignore lint/a11y/useAnchorContent: content provided by DropdownMenuItem children
+				<a
+					className="flex items-center gap-2"
+					href={providers.cursor.createUrl(query)}
+					rel="noopener"
+					target="_blank"
+				/>
+			}
+		>
+			<span className="shrink-0">{providers.cursor.icon}</span>
+			<span className="flex-1">{providers.cursor.title}</span>
+			<ExternalLinkIcon className="size-4 shrink-0" />
+		</DropdownMenuItem>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/package-info.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/package-info.tsx
new file mode 100644
index 0000000..805f340
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/package-info.tsx
@@ -0,0 +1,239 @@
+"use client";
+
+import { ArrowRightIcon, MinusIcon, PackageIcon, PlusIcon } from "lucide-react";
+import type { HTMLAttributes } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+type ChangeType = "major" | "minor" | "patch" | "added" | "removed";
+
+interface PackageInfoContextType {
+	name: string;
+	currentVersion?: string;
+	newVersion?: string;
+	changeType?: ChangeType;
+}
+
+const PackageInfoContext = createContext<PackageInfoContextType>({
+	name: "",
+});
+
+export type PackageInfoHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoHeader = ({
+	className,
+	children,
+	...props
+}: PackageInfoHeaderProps) => (
+	<div
+		className={cn("flex items-center justify-between gap-2", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type PackageInfoNameProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoName = ({
+	className,
+	children,
+	...props
+}: PackageInfoNameProps) => {
+	const { name } = useContext(PackageInfoContext);
+
+	return (
+		<div className={cn("flex items-center gap-2", className)} {...props}>
+			<PackageIcon className="size-4 text-muted-foreground" />
+			<span className="font-medium font-mono text-sm">{children ?? name}</span>
+		</div>
+	);
+};
+
+const changeTypeStyles: Record<ChangeType, string> = {
+	added: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+	major: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
+	minor:
+		"bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
+	patch: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+	removed: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400",
+};
+
+const changeTypeIcons: Record<ChangeType, React.ReactNode> = {
+	added: <PlusIcon className="size-3" />,
+	major: <ArrowRightIcon className="size-3" />,
+	minor: <ArrowRightIcon className="size-3" />,
+	patch: <ArrowRightIcon className="size-3" />,
+	removed: <MinusIcon className="size-3" />,
+};
+
+export type PackageInfoChangeTypeProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoChangeType = ({
+	className,
+	children,
+	...props
+}: PackageInfoChangeTypeProps) => {
+	const { changeType } = useContext(PackageInfoContext);
+
+	if (!changeType) {
+		return null;
+	}
+
+	return (
+		<Badge
+			className={cn(
+				"gap-1 text-xs capitalize",
+				changeTypeStyles[changeType],
+				className,
+			)}
+			variant="secondary"
+			{...props}
+		>
+			{changeTypeIcons[changeType]}
+			{children ?? changeType}
+		</Badge>
+	);
+};
+
+export type PackageInfoVersionProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoVersion = ({
+	className,
+	children,
+	...props
+}: PackageInfoVersionProps) => {
+	const { currentVersion, newVersion } = useContext(PackageInfoContext);
+
+	if (!(currentVersion || newVersion)) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn(
+				"mt-2 flex items-center gap-2 font-mono text-muted-foreground text-sm",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? (
+				<>
+					{currentVersion && <span>{currentVersion}</span>}
+					{currentVersion && newVersion && (
+						<ArrowRightIcon className="size-3" />
+					)}
+					{newVersion && (
+						<span className="font-medium text-foreground">{newVersion}</span>
+					)}
+				</>
+			)}
+		</div>
+	);
+};
+
+export type PackageInfoProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	currentVersion?: string;
+	newVersion?: string;
+	changeType?: ChangeType;
+};
+
+export const PackageInfo = ({
+	name,
+	currentVersion,
+	newVersion,
+	changeType,
+	className,
+	children,
+	...props
+}: PackageInfoProps) => {
+	const contextValue = useMemo(
+		() => ({ changeType, currentVersion, name, newVersion }),
+		[changeType, currentVersion, name, newVersion],
+	);
+
+	return (
+		<PackageInfoContext.Provider value={contextValue}>
+			<div
+				className={cn("rounded-lg border bg-background p-4", className)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<PackageInfoHeader>
+							<PackageInfoName />
+							{changeType && <PackageInfoChangeType />}
+						</PackageInfoHeader>
+						{(currentVersion || newVersion) && <PackageInfoVersion />}
+					</>
+				)}
+			</div>
+		</PackageInfoContext.Provider>
+	);
+};
+
+export type PackageInfoDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const PackageInfoDescription = ({
+	className,
+	children,
+	...props
+}: PackageInfoDescriptionProps) => (
+	<p className={cn("mt-2 text-muted-foreground text-sm", className)} {...props}>
+		{children}
+	</p>
+);
+
+export type PackageInfoContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoContent = ({
+	className,
+	children,
+	...props
+}: PackageInfoContentProps) => (
+	<div className={cn("mt-3 border-t pt-3", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type PackageInfoDependenciesProps = HTMLAttributes<HTMLDivElement>;
+
+export const PackageInfoDependencies = ({
+	className,
+	children,
+	...props
+}: PackageInfoDependenciesProps) => (
+	<div className={cn("space-y-2", className)} {...props}>
+		<span className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
+			Dependencies
+		</span>
+		<div className="space-y-1">{children}</div>
+	</div>
+);
+
+export type PackageInfoDependencyProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	version?: string;
+};
+
+export const PackageInfoDependency = ({
+	name,
+	version,
+	className,
+	children,
+	...props
+}: PackageInfoDependencyProps) => (
+	<div
+		className={cn("flex items-center justify-between text-sm", className)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				<span className="font-mono text-muted-foreground">{name}</span>
+				{version && <span className="font-mono text-xs">{version}</span>}
+			</>
+		)}
+	</div>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/panel.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/panel.tsx
new file mode 100644
index 0000000..18e941c
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/panel.tsx
@@ -0,0 +1,15 @@
+import { Panel as PanelPrimitive } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+type PanelProps = ComponentProps<typeof PanelPrimitive>;
+
+export const Panel = ({ className, ...props }: PanelProps) => (
+	<PanelPrimitive
+		className={cn(
+			"m-4 overflow-hidden rounded-md border bg-card p-1",
+			className,
+		)}
+		{...props}
+	/>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/persona.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/persona.tsx
new file mode 100644
index 0000000..d77ef6b
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/persona.tsx
@@ -0,0 +1,306 @@
+"use client";
+
+import type { RiveParameters } from "@rive-app/react-webgl2";
+import {
+	useRive,
+	useStateMachineInput,
+	useViewModel,
+	useViewModelInstance,
+	useViewModelInstanceColor,
+} from "@rive-app/react-webgl2";
+import type { FC, ReactNode } from "react";
+import { memo, useEffect, useMemo, useRef, useState } from "react";
+import { cn } from "@/lib/utils";
+
+// Delays Rive initialization by one frame so that React Strict Mode's
+// immediate unmount cycle never creates a WebGL2 context. Only the
+// second (real) mount will initialise, avoiding context exhaustion.
+const useStrictModeSafeInit = () => {
+	const [ready, setReady] = useState(false);
+
+	useEffect(() => {
+		const id = requestAnimationFrame(() => setReady(true));
+		return () => {
+			cancelAnimationFrame(id);
+			setReady(false);
+		};
+	}, []);
+
+	return ready;
+};
+
+export type PersonaState =
+	| "idle"
+	| "listening"
+	| "thinking"
+	| "speaking"
+	| "asleep";
+
+interface PersonaProps {
+	state: PersonaState;
+	onLoad?: RiveParameters["onLoad"];
+	onLoadError?: RiveParameters["onLoadError"];
+	onReady?: () => void;
+	onPause?: RiveParameters["onPause"];
+	onPlay?: RiveParameters["onPlay"];
+	onStop?: RiveParameters["onStop"];
+	className?: string;
+	variant?: keyof typeof sources;
+}
+
+// The state machine name is always 'default' for Elements AI visuals
+const stateMachine = "default";
+
+const sources = {
+	command: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/command-2.0.riv",
+	},
+	glint: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/glint-2.0.riv",
+	},
+	halo: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/halo-2.0.riv",
+	},
+	mana: {
+		dynamicColor: false,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/mana-2.0.riv",
+	},
+	obsidian: {
+		dynamicColor: true,
+		hasModel: true,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/obsidian-2.0.riv",
+	},
+	opal: {
+		dynamicColor: false,
+		hasModel: false,
+		source:
+			"https://ejiidnob33g9ap1r.public.blob.vercel-storage.com/orb-1.2.riv",
+	},
+};
+
+const getCurrentTheme = (): "light" | "dark" => {
+	if (typeof window !== "undefined") {
+		if (document.documentElement.classList.contains("dark")) {
+			return "dark";
+		}
+		if (window.matchMedia?.("(prefers-color-scheme: dark)").matches) {
+			return "dark";
+		}
+	}
+	return "light";
+};
+
+const useTheme = (enabled: boolean) => {
+	const [theme, setTheme] = useState<"light" | "dark">(getCurrentTheme);
+
+	useEffect(() => {
+		// Skip if not enabled (avoids unnecessary observers for non-dynamic-color variants)
+		if (!enabled) {
+			return;
+		}
+
+		// Watch for classList changes
+		const observer = new MutationObserver(() => {
+			setTheme(getCurrentTheme());
+		});
+
+		observer.observe(document.documentElement, {
+			attributeFilter: ["class"],
+			attributes: true,
+		});
+
+		// Watch for OS-level theme changes
+		let mql: MediaQueryList | null = null;
+		const handleMediaChange = () => {
+			setTheme(getCurrentTheme());
+		};
+
+		if (window.matchMedia) {
+			mql = window.matchMedia("(prefers-color-scheme: dark)");
+			mql.addEventListener("change", handleMediaChange);
+		}
+
+		return () => {
+			observer.disconnect();
+			if (mql) {
+				mql.removeEventListener("change", handleMediaChange);
+			}
+		};
+	}, [enabled]);
+
+	return theme;
+};
+
+interface PersonaWithModelProps {
+	rive: ReturnType<typeof useRive>["rive"];
+	source: (typeof sources)[keyof typeof sources];
+	children: React.ReactNode;
+}
+
+const PersonaWithModel = memo(
+	({ rive, source, children }: PersonaWithModelProps) => {
+		const theme = useTheme(source.dynamicColor);
+		const viewModel = useViewModel(rive, { useDefault: true });
+		const viewModelInstance = useViewModelInstance(viewModel, {
+			rive,
+			useDefault: true,
+		});
+		const viewModelInstanceColor = useViewModelInstanceColor(
+			"color",
+			viewModelInstance,
+		);
+
+		useEffect(() => {
+			if (!(viewModelInstanceColor && source.dynamicColor)) {
+				return;
+			}
+
+			const [r, g, b] = theme === "dark" ? [255, 255, 255] : [0, 0, 0];
+			viewModelInstanceColor.setRgb(r, g, b);
+		}, [viewModelInstanceColor, theme, source.dynamicColor]);
+
+		return children;
+	},
+);
+
+PersonaWithModel.displayName = "PersonaWithModel";
+
+interface PersonaWithoutModelProps {
+	children: ReactNode;
+}
+
+const PersonaWithoutModel = memo(
+	({ children }: PersonaWithoutModelProps) => children,
+);
+
+PersonaWithoutModel.displayName = "PersonaWithoutModel";
+
+export const Persona: FC<PersonaProps> = memo(
+	({
+		variant = "obsidian",
+		state = "idle",
+		onLoad,
+		onLoadError,
+		onReady,
+		onPause,
+		onPlay,
+		onStop,
+		className,
+	}) => {
+		const source = sources[variant];
+
+		if (!source) {
+			throw new Error(`Invalid variant: ${variant}`);
+		}
+
+		// Stabilize callbacks to prevent useRive from reinitializing
+		const callbacksRef = useRef({
+			onLoad,
+			onLoadError,
+			onPause,
+			onPlay,
+			onReady,
+			onStop,
+		});
+
+		useEffect(() => {
+			callbacksRef.current = {
+				onLoad,
+				onLoadError,
+				onPause,
+				onPlay,
+				onReady,
+				onStop,
+			};
+		}, [onLoad, onLoadError, onPause, onPlay, onReady, onStop]);
+
+		const stableCallbacks = useMemo(
+			() => ({
+				onLoad: ((loadedRive) =>
+					callbacksRef.current.onLoad?.(
+						loadedRive,
+					)) as RiveParameters["onLoad"],
+				onLoadError: ((err) =>
+					callbacksRef.current.onLoadError?.(
+						err,
+					)) as RiveParameters["onLoadError"],
+				onPause: ((event) =>
+					callbacksRef.current.onPause?.(event)) as RiveParameters["onPause"],
+				onPlay: ((event) =>
+					callbacksRef.current.onPlay?.(event)) as RiveParameters["onPlay"],
+				onReady: () => callbacksRef.current.onReady?.(),
+				onStop: ((event) =>
+					callbacksRef.current.onStop?.(event)) as RiveParameters["onStop"],
+			}),
+			[],
+		);
+
+		// Delay initialisation by one frame to avoid creating (and leaking)
+		// a WebGL2 context during React Strict Mode's first throw-away mount.
+		const ready = useStrictModeSafeInit();
+
+		const { rive, RiveComponent } = useRive(
+			ready
+				? {
+						autoplay: true,
+						onLoad: stableCallbacks.onLoad,
+						onLoadError: stableCallbacks.onLoadError,
+						onPause: stableCallbacks.onPause,
+						onPlay: stableCallbacks.onPlay,
+						onRiveReady: stableCallbacks.onReady,
+						onStop: stableCallbacks.onStop,
+						src: source.source,
+						stateMachines: stateMachine,
+					}
+				: null,
+		);
+
+		const listeningInput = useStateMachineInput(
+			rive,
+			stateMachine,
+			"listening",
+		);
+		const thinkingInput = useStateMachineInput(rive, stateMachine, "thinking");
+		const speakingInput = useStateMachineInput(rive, stateMachine, "speaking");
+		const asleepInput = useStateMachineInput(rive, stateMachine, "asleep");
+
+		// Rive state machine inputs are mutable objects that must be set via direct
+		// property assignment — this is the intended Rive API, not a React anti-pattern.
+		useEffect(() => {
+			if (listeningInput) {
+				listeningInput.value = state === "listening";
+			}
+			if (thinkingInput) {
+				thinkingInput.value = state === "thinking";
+			}
+			if (speakingInput) {
+				speakingInput.value = state === "speaking";
+			}
+			if (asleepInput) {
+				asleepInput.value = state === "asleep";
+			}
+		}, [state, listeningInput, thinkingInput, speakingInput, asleepInput]);
+
+		const Component = source.hasModel ? PersonaWithModel : PersonaWithoutModel;
+
+		return (
+			<Component rive={rive} source={source}>
+				<RiveComponent className={cn("size-16 shrink-0", className)} />
+			</Component>
+		);
+	},
+);
+
+Persona.displayName = "Persona";
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/plan.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/plan.tsx
new file mode 100644
index 0000000..276af52
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/plan.tsx
@@ -0,0 +1,156 @@
+"use client";
+
+import { ChevronsUpDownIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardAction,
+	CardContent,
+	CardDescription,
+	CardFooter,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+import { Shimmer } from "./shimmer";
+
+interface PlanContextValue {
+	isStreaming: boolean;
+}
+
+const PlanContext = createContext<PlanContextValue | null>(null);
+
+const usePlan = () => {
+	const context = useContext(PlanContext);
+	if (!context) {
+		throw new Error("Plan components must be used within Plan");
+	}
+	return context;
+};
+
+export type PlanProps = ComponentProps<typeof Collapsible> & {
+	isStreaming?: boolean;
+};
+
+export const Plan = ({
+	className,
+	isStreaming = false,
+	children,
+	...props
+}: PlanProps) => {
+	const contextValue = useMemo(() => ({ isStreaming }), [isStreaming]);
+
+	return (
+		<PlanContext.Provider value={contextValue}>
+			<Collapsible
+				data-slot="plan"
+				{...props}
+				render={<Card className={cn("shadow-none", className)} />}
+			>
+				{children}
+			</Collapsible>
+		</PlanContext.Provider>
+	);
+};
+
+export type PlanHeaderProps = ComponentProps<typeof CardHeader>;
+
+export const PlanHeader = ({ className, ...props }: PlanHeaderProps) => (
+	<CardHeader
+		className={cn("flex items-start justify-between", className)}
+		data-slot="plan-header"
+		{...props}
+	/>
+);
+
+export type PlanTitleProps = Omit<
+	ComponentProps<typeof CardTitle>,
+	"children"
+> & {
+	children: string;
+};
+
+export const PlanTitle = ({ children, ...props }: PlanTitleProps) => {
+	const { isStreaming } = usePlan();
+
+	return (
+		<CardTitle data-slot="plan-title" {...props}>
+			{isStreaming ? <Shimmer>{children}</Shimmer> : children}
+		</CardTitle>
+	);
+};
+
+export type PlanDescriptionProps = Omit<
+	ComponentProps<typeof CardDescription>,
+	"children"
+> & {
+	children: string;
+};
+
+export const PlanDescription = ({
+	className,
+	children,
+	...props
+}: PlanDescriptionProps) => {
+	const { isStreaming } = usePlan();
+
+	return (
+		<CardDescription
+			className={cn("text-balance", className)}
+			data-slot="plan-description"
+			{...props}
+		>
+			{isStreaming ? <Shimmer>{children}</Shimmer> : children}
+		</CardDescription>
+	);
+};
+
+export type PlanActionProps = ComponentProps<typeof CardAction>;
+
+export const PlanAction = (props: PlanActionProps) => (
+	<CardAction data-slot="plan-action" {...props} />
+);
+
+export type PlanContentProps = ComponentProps<typeof CardContent>;
+
+export const PlanContent = (props: PlanContentProps) => (
+	<CollapsibleContent
+		render={<CardContent data-slot="plan-content" {...props} />}
+	></CollapsibleContent>
+);
+
+export type PlanFooterProps = ComponentProps<"div">;
+
+export const PlanFooter = (props: PlanFooterProps) => (
+	<CardFooter data-slot="plan-footer" {...props} />
+);
+
+export type PlanTriggerProps = Omit<
+	ComponentProps<typeof CollapsibleTrigger>,
+	"render"
+>;
+
+export const PlanTrigger = ({ className, ...props }: PlanTriggerProps) => (
+	<CollapsibleTrigger
+		{...props}
+		render={
+			<Button
+				className={cn("size-8", className)}
+				data-slot="plan-trigger"
+				size="icon"
+				variant="ghost"
+			/>
+		}
+	>
+		<ChevronsUpDownIcon className="size-4" />
+		<span className="sr-only">Toggle plan</span>
+	</CollapsibleTrigger>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/prompt-input.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/prompt-input.tsx
new file mode 100644
index 0000000..d67e24d
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/prompt-input.tsx
@@ -0,0 +1,1502 @@
+"use client";
+
+import type { ChatStatus, FileUIPart, SourceDocumentUIPart } from "ai";
+import {
+	CornerDownLeftIcon,
+	ImageIcon,
+	Monitor,
+	PaperclipIcon,
+	SquareIcon,
+	XIcon,
+} from "lucide-react";
+import { nanoid } from "nanoid";
+import type {
+	ChangeEvent,
+	ChangeEventHandler,
+	ClipboardEventHandler,
+	ComponentProps,
+	FormEvent,
+	FormEventHandler,
+	HTMLAttributes,
+	KeyboardEventHandler,
+	PropsWithChildren,
+	ReactNode,
+	RefObject,
+} from "react";
+import {
+	Children,
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	Command,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+	CommandSeparator,
+} from "@/components/ui/command";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import {
+	HoverCard,
+	HoverCardContent,
+	HoverCardTrigger,
+} from "@/components/ui/hover-card";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupTextarea,
+} from "@/components/ui/input-group";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Spinner } from "@/components/ui/spinner";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+const convertBlobUrlToDataUrl = async (url: string): Promise<string | null> => {
+	try {
+		const response = await fetch(url);
+		const blob = await response.blob();
+		// FileReader uses callback-based API, wrapping in Promise is necessary
+		// oxlint-disable-next-line eslint-plugin-promise(avoid-new)
+		return new Promise((resolve) => {
+			const reader = new FileReader();
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			reader.onloadend = () => resolve(reader.result as string);
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			reader.onerror = () => resolve(null);
+			reader.readAsDataURL(blob);
+		});
+	} catch {
+		return null;
+	}
+};
+
+const readFileAsDataUrl = async (file: File): Promise<string | null> =>
+	await new Promise((resolve) => {
+		const reader = new FileReader();
+		reader.onloadend = () => resolve((reader.result as string) ?? null);
+		reader.onerror = () => resolve(null);
+		reader.readAsDataURL(file);
+	});
+
+const captureScreenshot = async (): Promise<File | null> => {
+	if (
+		typeof navigator === "undefined" ||
+		!navigator.mediaDevices?.getDisplayMedia
+	) {
+		return null;
+	}
+
+	let stream: MediaStream | null = null;
+	const video = document.createElement("video");
+	video.muted = true;
+	video.playsInline = true;
+
+	try {
+		stream = await navigator.mediaDevices.getDisplayMedia({
+			audio: false,
+			video: true,
+		});
+
+		video.srcObject = stream;
+
+		// Video element uses callback-based API, wrapping in Promise is necessary
+		// oxlint-disable-next-line eslint-plugin-promise(avoid-new)
+		await new Promise<void>((resolve, reject) => {
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			video.onloadedmetadata = () => resolve();
+			// oxlint-disable-next-line eslint-plugin-unicorn(prefer-add-event-listener)
+			video.onerror = () => reject(new Error("Failed to load screen stream"));
+		});
+
+		await video.play();
+
+		const width = video.videoWidth;
+		const height = video.videoHeight;
+		if (!width || !height) {
+			return null;
+		}
+
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		const context = canvas.getContext("2d");
+		if (!context) {
+			return null;
+		}
+
+		context.drawImage(video, 0, 0, width, height);
+		// canvas.toBlob uses callback-based API, wrapping in Promise is necessary
+		// oxlint-disable-next-line eslint-plugin-promise(avoid-new)
+		const blob = await new Promise<Blob | null>((resolve) => {
+			canvas.toBlob(resolve, "image/png");
+		});
+		if (!blob) {
+			return null;
+		}
+
+		const timestamp = new Date()
+			.toISOString()
+			.replaceAll(/[:.]/g, "-")
+			.replace("T", "_")
+			.replace("Z", "");
+
+		return new File([blob], `screenshot-${timestamp}.png`, {
+			lastModified: Date.now(),
+			type: "image/png",
+		});
+	} finally {
+		if (stream) {
+			for (const track of stream.getTracks()) {
+				track.stop();
+			}
+		}
+		video.pause();
+		video.srcObject = null;
+	}
+};
+
+// ============================================================================
+// Provider Context & Types
+// ============================================================================
+
+export interface AttachmentsContext {
+	files: (FileUIPart & { id: string })[];
+	add: (files: File[] | FileList) => void;
+	remove: (id: string) => void;
+	clear: () => void;
+	openFileDialog: () => void;
+	fileInputRef: RefObject<HTMLInputElement | null>;
+}
+
+export interface TextInputContext {
+	value: string;
+	setInput: (v: string) => void;
+	clear: () => void;
+}
+
+export interface PromptInputControllerProps {
+	textInput: TextInputContext;
+	attachments: AttachmentsContext;
+	/** INTERNAL: Allows PromptInput to register its file textInput + "open" callback */
+	__registerFileInput: (
+		ref: RefObject<HTMLInputElement | null>,
+		open: () => void,
+	) => void;
+}
+
+const PromptInputController = createContext<PromptInputControllerProps | null>(
+	null,
+);
+const ProviderAttachmentsContext = createContext<AttachmentsContext | null>(
+	null,
+);
+
+export const usePromptInputController = () => {
+	const ctx = useContext(PromptInputController);
+	if (!ctx) {
+		throw new Error(
+			"Wrap your component inside <PromptInputProvider> to use usePromptInputController().",
+		);
+	}
+	return ctx;
+};
+
+// Optional variants (do NOT throw). Useful for dual-mode components.
+const useOptionalPromptInputController = () =>
+	useContext(PromptInputController);
+
+export const useProviderAttachments = () => {
+	const ctx = useContext(ProviderAttachmentsContext);
+	if (!ctx) {
+		throw new Error(
+			"Wrap your component inside <PromptInputProvider> to use useProviderAttachments().",
+		);
+	}
+	return ctx;
+};
+
+const useOptionalProviderAttachments = () =>
+	useContext(ProviderAttachmentsContext);
+
+export type PromptInputProviderProps = PropsWithChildren<{
+	initialInput?: string;
+}>;
+
+/**
+ * Optional global provider that lifts PromptInput state outside of PromptInput.
+ * If you don't use it, PromptInput stays fully self-managed.
+ */
+export const PromptInputProvider = ({
+	initialInput: initialTextInput = "",
+	children,
+}: PromptInputProviderProps) => {
+	// ----- textInput state
+	const [textInput, setTextInput] = useState(initialTextInput);
+	const clearInput = useCallback(() => setTextInput(""), []);
+
+	// ----- attachments state (global when wrapped)
+	const [attachmentFiles, setAttachmentFiles] = useState<
+		PromptInputAttachmentPart[]
+	>([]);
+	const fileInputRef = useRef<HTMLInputElement | null>(null);
+	// oxlint-disable-next-line eslint(no-empty-function)
+	const openRef = useRef<() => void>(() => {});
+
+	const add = useCallback((files: File[] | FileList) => {
+		const incoming = [...files];
+		if (incoming.length === 0) {
+			return;
+		}
+
+		setAttachmentFiles((prev) => [
+			...prev,
+			...incoming.map((file) => ({
+				filename: file.name,
+				id: nanoid(),
+				mediaType: file.type,
+				rawFile: file,
+				type: "file" as const,
+				url: URL.createObjectURL(file),
+			})),
+		]);
+	}, []);
+
+	const remove = useCallback((id: string) => {
+		setAttachmentFiles((prev) => {
+			const found = prev.find((f) => f.id === id);
+			if (found?.url) {
+				URL.revokeObjectURL(found.url);
+			}
+			return prev.filter((f) => f.id !== id);
+		});
+	}, []);
+
+	const clear = useCallback(() => {
+		setAttachmentFiles((prev) => {
+			for (const f of prev) {
+				if (f.url) {
+					URL.revokeObjectURL(f.url);
+				}
+			}
+			return [];
+		});
+	}, []);
+
+	// Keep a ref to attachments for cleanup on unmount (avoids stale closure)
+	const attachmentsRef = useRef(attachmentFiles);
+
+	useEffect(() => {
+		attachmentsRef.current = attachmentFiles;
+	}, [attachmentFiles]);
+
+	// Cleanup blob URLs on unmount to prevent memory leaks
+	useEffect(
+		() => () => {
+			for (const f of attachmentsRef.current) {
+				if (f.url) {
+					URL.revokeObjectURL(f.url);
+				}
+			}
+		},
+		[],
+	);
+
+	const openFileDialog = useCallback(() => {
+		openRef.current?.();
+	}, []);
+
+	const attachments = useMemo<AttachmentsContext>(
+		() => ({
+			add,
+			clear,
+			fileInputRef,
+			files: attachmentFiles,
+			openFileDialog,
+			remove,
+		}),
+		[attachmentFiles, add, remove, clear, openFileDialog],
+	);
+
+	const __registerFileInput = useCallback(
+		(ref: RefObject<HTMLInputElement | null>, open: () => void) => {
+			fileInputRef.current = ref.current;
+			openRef.current = open;
+		},
+		[],
+	);
+
+	const controller = useMemo<PromptInputControllerProps>(
+		() => ({
+			__registerFileInput,
+			attachments,
+			textInput: {
+				clear: clearInput,
+				setInput: setTextInput,
+				value: textInput,
+			},
+		}),
+		[textInput, clearInput, attachments, __registerFileInput],
+	);
+
+	return (
+		<PromptInputController.Provider value={controller}>
+			<ProviderAttachmentsContext.Provider value={attachments}>
+				{children}
+			</ProviderAttachmentsContext.Provider>
+		</PromptInputController.Provider>
+	);
+};
+
+// ============================================================================
+// Component Context & Hooks
+// ============================================================================
+
+const LocalAttachmentsContext = createContext<AttachmentsContext | null>(null);
+
+export const usePromptInputAttachments = () => {
+	// Prefer local context (inside PromptInput) as it has validation, fall back to provider
+	const provider = useOptionalProviderAttachments();
+	const local = useContext(LocalAttachmentsContext);
+	const context = local ?? provider;
+	if (!context) {
+		throw new Error(
+			"usePromptInputAttachments must be used within a PromptInput or PromptInputProvider",
+		);
+	}
+	return context;
+};
+
+// ============================================================================
+// Referenced Sources (Local to PromptInput)
+// ============================================================================
+
+export interface ReferencedSourcesContext {
+	sources: (SourceDocumentUIPart & { id: string })[];
+	add: (sources: SourceDocumentUIPart[] | SourceDocumentUIPart) => void;
+	remove: (id: string) => void;
+	clear: () => void;
+}
+
+export const LocalReferencedSourcesContext =
+	createContext<ReferencedSourcesContext | null>(null);
+
+export const usePromptInputReferencedSources = () => {
+	const ctx = useContext(LocalReferencedSourcesContext);
+	if (!ctx) {
+		throw new Error(
+			"usePromptInputReferencedSources must be used within a LocalReferencedSourcesContext.Provider",
+		);
+	}
+	return ctx;
+};
+
+export type PromptInputActionAddAttachmentsProps = ComponentProps<
+	typeof DropdownMenuItem
+> & {
+	label?: string;
+};
+
+export const PromptInputActionAddAttachments = ({
+	label = "Add photos or files",
+	...props
+}: PromptInputActionAddAttachmentsProps) => {
+	const attachments = usePromptInputAttachments();
+
+	const handleSelect = useCallback(
+		(
+			e: Parameters<
+				NonNullable<PromptInputActionAddAttachmentsProps["onSelect"]>
+			>[0],
+		) => {
+			e.preventDefault();
+			attachments.openFileDialog();
+		},
+		[attachments],
+	);
+
+	return (
+		<DropdownMenuItem {...props} onSelect={handleSelect}>
+			<ImageIcon className="mr-2 size-4" /> {label}
+		</DropdownMenuItem>
+	);
+};
+
+export type PromptInputActionAddScreenshotProps = ComponentProps<
+	typeof DropdownMenuItem
+> & {
+	label?: string;
+};
+
+export const PromptInputActionAddScreenshot = ({
+	label = "Take screenshot",
+	onSelect,
+	...props
+}: PromptInputActionAddScreenshotProps) => {
+	const attachments = usePromptInputAttachments();
+
+	const handleSelect = useCallback(
+		async (
+			event: Parameters<
+				NonNullable<PromptInputActionAddScreenshotProps["onSelect"]>
+			>[0],
+		) => {
+			onSelect?.(event);
+			if (event.defaultPrevented) {
+				return;
+			}
+
+			try {
+				const screenshot = await captureScreenshot();
+				if (screenshot) {
+					attachments.add([screenshot]);
+				}
+			} catch (error) {
+				if (
+					error instanceof DOMException &&
+					(error.name === "NotAllowedError" || error.name === "AbortError")
+				) {
+					return;
+				}
+				throw error;
+			}
+		},
+		[onSelect, attachments],
+	);
+
+	return (
+		<DropdownMenuItem {...props} onSelect={handleSelect}>
+			<Monitor className="mr-2 size-4" />
+			{label}
+		</DropdownMenuItem>
+	);
+};
+
+export interface PromptInputMessage {
+	text: string;
+	files: FileUIPart[];
+}
+
+type PromptInputAttachmentPart = FileUIPart & {
+	id: string;
+	rawFile?: File;
+};
+
+export type PromptInputProps = Omit<
+	HTMLAttributes<HTMLFormElement>,
+	"onSubmit" | "onError"
+> & {
+	// e.g., "image/*" or leave undefined for any
+	accept?: string;
+	multiple?: boolean;
+	// When true, accepts drops anywhere on document. Default false (opt-in).
+	globalDrop?: boolean;
+	// Render a hidden input with given name and keep it in sync for native form posts. Default false.
+	syncHiddenInput?: boolean;
+	// Minimal constraints
+	maxFiles?: number;
+	// bytes
+	maxFileSize?: number;
+	onError?: (err: {
+		code: "max_files" | "max_file_size" | "accept";
+		message: string;
+	}) => void;
+	onSubmit: (
+		message: PromptInputMessage,
+		event: FormEvent<HTMLFormElement>,
+	) => void | Promise<void>;
+};
+
+export const PromptInput = ({
+	className,
+	accept,
+	multiple,
+	globalDrop,
+	syncHiddenInput,
+	maxFiles,
+	maxFileSize,
+	onError,
+	onSubmit,
+	children,
+	...props
+}: PromptInputProps) => {
+	// Try to use a provider controller if present
+	const controller = useOptionalPromptInputController();
+	const usingProvider = !!controller;
+
+	// Refs
+	const inputRef = useRef<HTMLInputElement | null>(null);
+	const formRef = useRef<HTMLFormElement | null>(null);
+
+	// ----- Local attachments (only used when no provider)
+	const [items, setItems] = useState<PromptInputAttachmentPart[]>([]);
+	const files = usingProvider ? controller.attachments.files : items;
+
+	// ----- Local referenced sources (always local to PromptInput)
+	const [referencedSources, setReferencedSources] = useState<
+		(SourceDocumentUIPart & { id: string })[]
+	>([]);
+
+	// Keep a ref to files for cleanup on unmount (avoids stale closure)
+	const filesRef = useRef(files);
+
+	useEffect(() => {
+		filesRef.current = files;
+	}, [files]);
+
+	const openFileDialogLocal = useCallback(() => {
+		inputRef.current?.click();
+	}, []);
+
+	const matchesAccept = useCallback(
+		(f: File) => {
+			if (!accept || accept.trim() === "") {
+				return true;
+			}
+
+			const patterns = accept
+				.split(",")
+				.map((s) => s.trim())
+				.filter(Boolean);
+
+			return patterns.some((pattern) => {
+				if (pattern.endsWith("/*")) {
+					// e.g: image/* -> image/
+					const prefix = pattern.slice(0, -1);
+					return f.type.startsWith(prefix);
+				}
+				return f.type === pattern;
+			});
+		},
+		[accept],
+	);
+
+	const addLocal = useCallback(
+		(fileList: File[] | FileList) => {
+			const incoming = [...fileList];
+			const accepted = incoming.filter((f) => matchesAccept(f));
+			if (incoming.length && accepted.length === 0) {
+				onError?.({
+					code: "accept",
+					message: "No files match the accepted types.",
+				});
+				return;
+			}
+			const withinSize = (f: File) =>
+				maxFileSize ? f.size <= maxFileSize : true;
+			const sized = accepted.filter(withinSize);
+			if (accepted.length > 0 && sized.length === 0) {
+				onError?.({
+					code: "max_file_size",
+					message: "All files exceed the maximum size.",
+				});
+				return;
+			}
+
+			setItems((prev) => {
+				const capacity =
+					typeof maxFiles === "number"
+						? Math.max(0, maxFiles - prev.length)
+						: undefined;
+				const capped =
+					typeof capacity === "number" ? sized.slice(0, capacity) : sized;
+				if (typeof capacity === "number" && sized.length > capacity) {
+					onError?.({
+						code: "max_files",
+						message: "Too many files. Some were not added.",
+					});
+				}
+				const next: PromptInputAttachmentPart[] = [];
+				for (const file of capped) {
+					next.push({
+						filename: file.name,
+						id: nanoid(),
+						mediaType: file.type,
+						rawFile: file,
+						type: "file",
+						url: URL.createObjectURL(file),
+					});
+				}
+				return [...prev, ...next];
+			});
+		},
+		[matchesAccept, maxFiles, maxFileSize, onError],
+	);
+
+	const removeLocal = useCallback(
+		(id: string) =>
+			setItems((prev) => {
+				const found = prev.find((file) => file.id === id);
+				if (found?.url) {
+					URL.revokeObjectURL(found.url);
+				}
+				return prev.filter((file) => file.id !== id);
+			}),
+		[],
+	);
+
+	// Wrapper that validates files before calling provider's add
+	const addWithProviderValidation = useCallback(
+		(fileList: File[] | FileList) => {
+			const incoming = [...fileList];
+			const accepted = incoming.filter((f) => matchesAccept(f));
+			if (incoming.length && accepted.length === 0) {
+				onError?.({
+					code: "accept",
+					message: "No files match the accepted types.",
+				});
+				return;
+			}
+			const withinSize = (f: File) =>
+				maxFileSize ? f.size <= maxFileSize : true;
+			const sized = accepted.filter(withinSize);
+			if (accepted.length > 0 && sized.length === 0) {
+				onError?.({
+					code: "max_file_size",
+					message: "All files exceed the maximum size.",
+				});
+				return;
+			}
+
+			const currentCount = files.length;
+			const capacity =
+				typeof maxFiles === "number"
+					? Math.max(0, maxFiles - currentCount)
+					: undefined;
+			const capped =
+				typeof capacity === "number" ? sized.slice(0, capacity) : sized;
+			if (typeof capacity === "number" && sized.length > capacity) {
+				onError?.({
+					code: "max_files",
+					message: "Too many files. Some were not added.",
+				});
+			}
+
+			if (capped.length > 0) {
+				controller?.attachments.add(capped);
+			}
+		},
+		[matchesAccept, maxFileSize, maxFiles, onError, files.length, controller],
+	);
+
+	const clearAttachments = useCallback(
+		() =>
+			usingProvider
+				? controller?.attachments.clear()
+				: setItems((prev) => {
+						for (const file of prev) {
+							if (file.url) {
+								URL.revokeObjectURL(file.url);
+							}
+						}
+						return [];
+					}),
+		[usingProvider, controller],
+	);
+
+	const clearReferencedSources = useCallback(
+		() => setReferencedSources([]),
+		[],
+	);
+
+	const add = usingProvider ? addWithProviderValidation : addLocal;
+	const remove = usingProvider ? controller.attachments.remove : removeLocal;
+	const openFileDialog = usingProvider
+		? controller.attachments.openFileDialog
+		: openFileDialogLocal;
+
+	const clear = useCallback(() => {
+		clearAttachments();
+		clearReferencedSources();
+	}, [clearAttachments, clearReferencedSources]);
+
+	// Let provider know about our hidden file input so external menus can call openFileDialog()
+	useEffect(() => {
+		if (!usingProvider) {
+			return;
+		}
+		controller.__registerFileInput(inputRef, () => inputRef.current?.click());
+	}, [usingProvider, controller]);
+
+	// Note: File input cannot be programmatically set for security reasons
+	// The syncHiddenInput prop is no longer functional
+	useEffect(() => {
+		if (syncHiddenInput && inputRef.current && files.length === 0) {
+			inputRef.current.value = "";
+		}
+	}, [files, syncHiddenInput]);
+
+	// Attach drop handlers on nearest form and document (opt-in)
+	useEffect(() => {
+		const form = formRef.current;
+		if (!form) {
+			return;
+		}
+		if (globalDrop) {
+			// when global drop is on, let the document-level handler own drops
+			return;
+		}
+
+		const onDragOver = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+		};
+		const onDrop = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+			if (e.dataTransfer?.files && e.dataTransfer.files.length > 0) {
+				add(e.dataTransfer.files);
+			}
+		};
+		form.addEventListener("dragover", onDragOver);
+		form.addEventListener("drop", onDrop);
+		return () => {
+			form.removeEventListener("dragover", onDragOver);
+			form.removeEventListener("drop", onDrop);
+		};
+	}, [add, globalDrop]);
+
+	useEffect(() => {
+		if (!globalDrop) {
+			return;
+		}
+
+		const onDragOver = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+		};
+		const onDrop = (e: DragEvent) => {
+			if (e.dataTransfer?.types?.includes("Files")) {
+				e.preventDefault();
+			}
+			if (e.dataTransfer?.files && e.dataTransfer.files.length > 0) {
+				add(e.dataTransfer.files);
+			}
+		};
+		document.addEventListener("dragover", onDragOver);
+		document.addEventListener("drop", onDrop);
+		return () => {
+			document.removeEventListener("dragover", onDragOver);
+			document.removeEventListener("drop", onDrop);
+		};
+	}, [add, globalDrop]);
+
+	useEffect(
+		() => () => {
+			if (!usingProvider) {
+				for (const f of filesRef.current) {
+					if (f.url) {
+						URL.revokeObjectURL(f.url);
+					}
+				}
+			}
+		},
+		[usingProvider],
+	);
+
+	const handleChange: ChangeEventHandler<HTMLInputElement> = useCallback(
+		(event) => {
+			if (event.currentTarget.files) {
+				add(event.currentTarget.files);
+			}
+			// Reset input value to allow selecting files that were previously removed
+			event.currentTarget.value = "";
+		},
+		[add],
+	);
+
+	const attachmentsCtx = useMemo<AttachmentsContext>(
+		() => ({
+			add,
+			clear: clearAttachments,
+			fileInputRef: inputRef,
+			files: files.map((item) => ({ ...item, id: item.id })),
+			openFileDialog,
+			remove,
+		}),
+		[files, add, remove, clearAttachments, openFileDialog],
+	);
+
+	const refsCtx = useMemo<ReferencedSourcesContext>(
+		() => ({
+			add: (incoming: SourceDocumentUIPart[] | SourceDocumentUIPart) => {
+				const array = Array.isArray(incoming) ? incoming : [incoming];
+				setReferencedSources((prev) => [
+					...prev,
+					...array.map((s) => ({ ...s, id: nanoid() })),
+				]);
+			},
+			clear: clearReferencedSources,
+			remove: (id: string) => {
+				setReferencedSources((prev) => prev.filter((s) => s.id !== id));
+			},
+			sources: referencedSources,
+		}),
+		[referencedSources, clearReferencedSources],
+	);
+
+	const handleSubmit: FormEventHandler<HTMLFormElement> = useCallback(
+		async (event) => {
+			event.preventDefault();
+
+			const form = event.currentTarget;
+			const text = usingProvider
+				? controller.textInput.value
+				: (() => {
+						const formData = new FormData(form);
+						return (formData.get("message") as string) || "";
+					})();
+
+			// Reset form immediately after capturing text to avoid race condition
+			// where user input during async blob conversion would be lost
+			if (!usingProvider) {
+				form.reset();
+			}
+
+			try {
+				// Convert blob URLs to data URLs asynchronously
+				const convertedFiles: FileUIPart[] = await Promise.all(
+					(files as PromptInputAttachmentPart[]).map(
+						async ({ id: _id, rawFile, ...item }) => {
+							if (rawFile) {
+								const dataUrl = await readFileAsDataUrl(rawFile);
+								return {
+									...item,
+									url: dataUrl ?? item.url,
+								};
+							}
+							if (item.url?.startsWith("blob:")) {
+								const dataUrl = await convertBlobUrlToDataUrl(item.url);
+								// If conversion failed, keep the original blob URL
+								return {
+									...item,
+									url: dataUrl ?? item.url,
+								};
+							}
+							return item;
+						},
+					),
+				);
+
+				const result = onSubmit({ files: convertedFiles, text }, event);
+
+				// Handle both sync and async onSubmit
+				if (result instanceof Promise) {
+					try {
+						await result;
+						clear();
+						if (usingProvider) {
+							controller.textInput.clear();
+						}
+					} catch {
+						// Don't clear on error - user may want to retry
+					}
+				} else {
+					// Sync function completed without throwing, clear inputs
+					clear();
+					if (usingProvider) {
+						controller.textInput.clear();
+					}
+				}
+			} catch {
+				// Don't clear on error - user may want to retry
+			}
+		},
+		[usingProvider, controller, files, onSubmit, clear],
+	);
+
+	// Render with or without local provider
+	const inner = (
+		<>
+			<input
+				accept={accept}
+				aria-label="Upload files"
+				className="hidden"
+				multiple={multiple}
+				onChange={handleChange}
+				ref={inputRef}
+				title="Upload files"
+				type="file"
+			/>
+			<form
+				className={cn("w-full", className)}
+				onSubmit={handleSubmit}
+				ref={formRef}
+				{...props}
+			>
+				<InputGroup className="overflow-hidden">{children}</InputGroup>
+			</form>
+		</>
+	);
+
+	const withReferencedSources = (
+		<LocalReferencedSourcesContext.Provider value={refsCtx}>
+			{inner}
+		</LocalReferencedSourcesContext.Provider>
+	);
+
+	// Always provide LocalAttachmentsContext so children get validated add function
+	return (
+		<LocalAttachmentsContext.Provider value={attachmentsCtx}>
+			{withReferencedSources}
+		</LocalAttachmentsContext.Provider>
+	);
+};
+
+export type PromptInputBodyProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputBody = ({
+	className,
+	...props
+}: PromptInputBodyProps) => (
+	<div className={cn("contents", className)} {...props} />
+);
+
+export type PromptInputTextareaProps = ComponentProps<
+	typeof InputGroupTextarea
+>;
+
+export const PromptInputTextarea = ({
+	onChange,
+	onKeyDown,
+	className,
+	placeholder = "How can I help you?",
+	...props
+}: PromptInputTextareaProps) => {
+	const controller = useOptionalPromptInputController();
+	const attachments = usePromptInputAttachments();
+	const [isComposing, setIsComposing] = useState(false);
+
+	const handleKeyDown: KeyboardEventHandler<HTMLTextAreaElement> = useCallback(
+		(e) => {
+			// Call the external onKeyDown handler first
+			onKeyDown?.(e);
+
+			// If the external handler prevented default, don't run internal logic
+			if (e.defaultPrevented) {
+				return;
+			}
+
+			if (e.key === "Enter") {
+				if (isComposing || e.nativeEvent.isComposing) {
+					return;
+				}
+				if (e.shiftKey) {
+					return;
+				}
+				e.preventDefault();
+
+				// Check if the submit button is disabled before submitting
+				const { form } = e.currentTarget;
+				const submitButton = form?.querySelector(
+					'button[type="submit"]',
+				) as HTMLButtonElement | null;
+				if (submitButton?.disabled) {
+					return;
+				}
+
+				form?.requestSubmit();
+			}
+
+			// Remove last attachment when Backspace is pressed and textarea is empty
+			if (
+				e.key === "Backspace" &&
+				e.currentTarget.value === "" &&
+				attachments.files.length > 0
+			) {
+				e.preventDefault();
+				const lastAttachment = attachments.files.at(-1);
+				if (lastAttachment) {
+					attachments.remove(lastAttachment.id);
+				}
+			}
+		},
+		[onKeyDown, isComposing, attachments],
+	);
+
+	const handlePaste: ClipboardEventHandler<HTMLTextAreaElement> = useCallback(
+		(event) => {
+			const items = event.clipboardData?.items;
+
+			if (!items) {
+				return;
+			}
+
+			const files: File[] = [];
+
+			for (const item of items) {
+				if (item.kind === "file") {
+					const file = item.getAsFile();
+					if (file) {
+						files.push(file);
+					}
+				}
+			}
+
+			if (files.length > 0) {
+				event.preventDefault();
+				attachments.add(files);
+			}
+		},
+		[attachments],
+	);
+
+	const handleCompositionEnd = useCallback(() => setIsComposing(false), []);
+	const handleCompositionStart = useCallback(() => setIsComposing(true), []);
+
+	const controlledProps = controller
+		? {
+				onChange: (e: ChangeEvent<HTMLTextAreaElement>) => {
+					controller.textInput.setInput(e.currentTarget.value);
+					onChange?.(e);
+				},
+				value: controller.textInput.value,
+			}
+		: {
+				onChange,
+			};
+
+	return (
+		<InputGroupTextarea
+			className={cn("field-sizing-content max-h-48 min-h-16", className)}
+			name="message"
+			onCompositionEnd={handleCompositionEnd}
+			onCompositionStart={handleCompositionStart}
+			onKeyDown={handleKeyDown}
+			onPaste={handlePaste}
+			placeholder={placeholder}
+			{...props}
+			{...controlledProps}
+		/>
+	);
+};
+
+export type PromptInputHeaderProps = Omit<
+	ComponentProps<typeof InputGroupAddon>,
+	"align"
+>;
+
+export const PromptInputHeader = ({
+	className,
+	...props
+}: PromptInputHeaderProps) => (
+	<InputGroupAddon
+		align="block-end"
+		className={cn("order-first flex-wrap gap-1", className)}
+		{...props}
+	/>
+);
+
+export type PromptInputFooterProps = Omit<
+	ComponentProps<typeof InputGroupAddon>,
+	"align"
+>;
+
+export const PromptInputFooter = ({
+	className,
+	...props
+}: PromptInputFooterProps) => (
+	<InputGroupAddon
+		align="block-end"
+		className={cn("justify-between gap-1", className)}
+		{...props}
+	/>
+);
+
+export type PromptInputToolsProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTools = ({
+	className,
+	...props
+}: PromptInputToolsProps) => (
+	<div
+		className={cn("flex min-w-0 items-center gap-1", className)}
+		{...props}
+	/>
+);
+
+export type PromptInputButtonTooltip =
+	| string
+	| {
+			content: ReactNode;
+			shortcut?: string;
+			side?: ComponentProps<typeof TooltipContent>["side"];
+	  };
+
+export type PromptInputButtonProps = ComponentProps<typeof InputGroupButton> & {
+	tooltip?: PromptInputButtonTooltip;
+};
+
+export const PromptInputButton = ({
+	variant = "ghost",
+	className,
+	size,
+	tooltip,
+	...props
+}: PromptInputButtonProps) => {
+	const newSize =
+		size ?? (Children.count(props.children) > 1 ? "sm" : "icon-sm");
+
+	const button = (
+		<InputGroupButton
+			className={cn(className)}
+			size={newSize}
+			type="button"
+			variant={variant}
+			{...props}
+		/>
+	);
+
+	if (!tooltip) {
+		return button;
+	}
+
+	const tooltipContent =
+		typeof tooltip === "string" ? tooltip : tooltip.content;
+	const shortcut = typeof tooltip === "string" ? undefined : tooltip.shortcut;
+	const side = typeof tooltip === "string" ? "top" : (tooltip.side ?? "top");
+
+	return (
+		<Tooltip>
+			<TooltipTrigger>{button}</TooltipTrigger>
+			<TooltipContent side={side}>
+				{tooltipContent}
+				{shortcut && (
+					<span className="ml-2 text-muted-foreground">{shortcut}</span>
+				)}
+			</TooltipContent>
+		</Tooltip>
+	);
+};
+
+export type PromptInputActionMenuProps = ComponentProps<typeof DropdownMenu>;
+export const PromptInputActionMenu = (props: PromptInputActionMenuProps) => (
+	<DropdownMenu {...props} />
+);
+
+export type PromptInputActionMenuTriggerProps = PromptInputButtonProps;
+
+export const PromptInputActionMenuTrigger = ({
+	className,
+	children,
+	...props
+}: PromptInputActionMenuTriggerProps) => (
+	<DropdownMenuTrigger
+		render={<PromptInputButton className={className} {...props} />}
+	>
+		{children ?? <PaperclipIcon className="size-4" />}
+	</DropdownMenuTrigger>
+);
+
+export type PromptInputActionMenuContentProps = ComponentProps<
+	typeof DropdownMenuContent
+>;
+export const PromptInputActionMenuContent = ({
+	className,
+	...props
+}: PromptInputActionMenuContentProps) => (
+	<DropdownMenuContent align="start" className={cn(className)} {...props} />
+);
+
+export type PromptInputActionMenuItemProps = ComponentProps<
+	typeof DropdownMenuItem
+>;
+export const PromptInputActionMenuItem = ({
+	className,
+	...props
+}: PromptInputActionMenuItemProps) => (
+	<DropdownMenuItem className={cn(className)} {...props} />
+);
+
+// Note: Actions that perform side-effects (like opening a file dialog)
+// are provided in opt-in modules (e.g., prompt-input-attachments).
+
+export type PromptInputSubmitProps = ComponentProps<typeof InputGroupButton> & {
+	status?: ChatStatus;
+	onStop?: () => void;
+};
+
+export const PromptInputSubmit = ({
+	className,
+	variant = "default",
+	size = "icon-sm",
+	status,
+	onStop,
+	onClick,
+	children,
+	...props
+}: PromptInputSubmitProps) => {
+	const isGenerating = status === "submitted" || status === "streaming";
+
+	let Icon = <CornerDownLeftIcon className="size-3" />;
+
+	if (status === "submitted") {
+		Icon = <Spinner />;
+	} else if (status === "streaming") {
+		Icon = <SquareIcon className="size-3" />;
+	} else if (status === "error") {
+		Icon = <XIcon className="size-3" />;
+	}
+
+	const handleClick = useCallback(
+		(
+			e: Parameters<
+				NonNullable<ComponentProps<typeof InputGroupButton>["onClick"]>
+			>[0],
+		) => {
+			if (isGenerating && onStop) {
+				e.preventDefault();
+				onStop();
+				return;
+			}
+			onClick?.(e);
+		},
+		[isGenerating, onStop, onClick],
+	);
+
+	return (
+		<InputGroupButton
+			aria-label={isGenerating ? "Stop" : "Submit"}
+			className={cn(className)}
+			onClick={handleClick}
+			size={size}
+			type={isGenerating && onStop ? "button" : "submit"}
+			variant={variant}
+			{...props}
+		>
+			{children ?? Icon}
+		</InputGroupButton>
+	);
+};
+
+export type PromptInputSelectProps = ComponentProps<typeof Select>;
+
+export const PromptInputSelect = (props: PromptInputSelectProps) => (
+	<Select {...props} />
+);
+
+export type PromptInputSelectTriggerProps = ComponentProps<
+	typeof SelectTrigger
+>;
+
+export const PromptInputSelectTrigger = ({
+	className,
+	...props
+}: PromptInputSelectTriggerProps) => (
+	<SelectTrigger
+		className={cn(
+			"border-none bg-transparent font-medium text-muted-foreground shadow-none transition-colors",
+			"hover:bg-accent hover:text-foreground aria-expanded:bg-accent aria-expanded:text-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type PromptInputSelectContentProps = ComponentProps<
+	typeof SelectContent
+>;
+
+export const PromptInputSelectContent = ({
+	className,
+	...props
+}: PromptInputSelectContentProps) => (
+	<SelectContent className={cn(className)} {...props} />
+);
+
+export type PromptInputSelectItemProps = ComponentProps<typeof SelectItem>;
+
+export const PromptInputSelectItem = ({
+	className,
+	...props
+}: PromptInputSelectItemProps) => (
+	<SelectItem className={cn(className)} {...props} />
+);
+
+export type PromptInputSelectValueProps = ComponentProps<typeof SelectValue>;
+
+export const PromptInputSelectValue = ({
+	className,
+	...props
+}: PromptInputSelectValueProps) => (
+	<SelectValue className={cn(className)} {...props} />
+);
+
+export type PromptInputHoverCardProps = ComponentProps<typeof HoverCard> & {
+	openDelay?: number;
+	closeDelay?: number;
+};
+
+export const PromptInputHoverCard = ({
+	openDelay = 0,
+	closeDelay = 0,
+	...props
+}: PromptInputHoverCardProps) => (
+	<HoverCard closeDelay={closeDelay} openDelay={openDelay} {...props} />
+);
+
+export type PromptInputHoverCardTriggerProps = ComponentProps<
+	typeof HoverCardTrigger
+>;
+
+export const PromptInputHoverCardTrigger = (
+	props: PromptInputHoverCardTriggerProps,
+) => <HoverCardTrigger {...props} />;
+
+export type PromptInputHoverCardContentProps = ComponentProps<
+	typeof HoverCardContent
+>;
+
+export const PromptInputHoverCardContent = ({
+	align = "start",
+	...props
+}: PromptInputHoverCardContentProps) => (
+	<HoverCardContent align={align} {...props} />
+);
+
+export type PromptInputTabsListProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTabsList = ({
+	className,
+	...props
+}: PromptInputTabsListProps) => <div className={cn(className)} {...props} />;
+
+export type PromptInputTabProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTab = ({
+	className,
+	...props
+}: PromptInputTabProps) => <div className={cn(className)} {...props} />;
+
+export type PromptInputTabLabelProps = HTMLAttributes<HTMLHeadingElement>;
+
+export const PromptInputTabLabel = ({
+	className,
+	...props
+}: PromptInputTabLabelProps) => (
+	// Content provided via children in props
+	// oxlint-disable-next-line eslint-plugin-jsx-a11y(heading-has-content)
+	<h3
+		className={cn(
+			"mb-2 px-3 font-medium text-muted-foreground text-xs",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type PromptInputTabBodyProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTabBody = ({
+	className,
+	...props
+}: PromptInputTabBodyProps) => (
+	<div className={cn("space-y-1", className)} {...props} />
+);
+
+export type PromptInputTabItemProps = HTMLAttributes<HTMLDivElement>;
+
+export const PromptInputTabItem = ({
+	className,
+	...props
+}: PromptInputTabItemProps) => (
+	<div
+		className={cn(
+			"flex items-center gap-2 px-3 py-2 text-xs hover:bg-accent",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type PromptInputCommandProps = ComponentProps<typeof Command>;
+
+export const PromptInputCommand = ({
+	className,
+	...props
+}: PromptInputCommandProps) => <Command className={cn(className)} {...props} />;
+
+export type PromptInputCommandInputProps = ComponentProps<typeof CommandInput>;
+
+export const PromptInputCommandInput = ({
+	className,
+	...props
+}: PromptInputCommandInputProps) => (
+	<CommandInput className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandListProps = ComponentProps<typeof CommandList>;
+
+export const PromptInputCommandList = ({
+	className,
+	...props
+}: PromptInputCommandListProps) => (
+	<CommandList className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const PromptInputCommandEmpty = ({
+	className,
+	...props
+}: PromptInputCommandEmptyProps) => (
+	<CommandEmpty className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandGroupProps = ComponentProps<typeof CommandGroup>;
+
+export const PromptInputCommandGroup = ({
+	className,
+	...props
+}: PromptInputCommandGroupProps) => (
+	<CommandGroup className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandItemProps = ComponentProps<typeof CommandItem>;
+
+export const PromptInputCommandItem = ({
+	className,
+	...props
+}: PromptInputCommandItemProps) => (
+	<CommandItem className={cn(className)} {...props} />
+);
+
+export type PromptInputCommandSeparatorProps = ComponentProps<
+	typeof CommandSeparator
+>;
+
+export const PromptInputCommandSeparator = ({
+	className,
+	...props
+}: PromptInputCommandSeparatorProps) => (
+	<CommandSeparator className={cn(className)} {...props} />
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/queue.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/queue.tsx
new file mode 100644
index 0000000..c783cac
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/queue.tsx
@@ -0,0 +1,276 @@
+"use client";
+
+import { ChevronDownIcon, PaperclipIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+export interface QueueMessagePart {
+	type: string;
+	text?: string;
+	url?: string;
+	filename?: string;
+	mediaType?: string;
+}
+
+export interface QueueMessage {
+	id: string;
+	parts: QueueMessagePart[];
+}
+
+export interface QueueTodo {
+	id: string;
+	title: string;
+	description?: string;
+	status?: "pending" | "completed";
+}
+
+export type QueueItemProps = ComponentProps<"li">;
+
+export const QueueItem = ({ className, ...props }: QueueItemProps) => (
+	<li
+		className={cn(
+			"group flex flex-col gap-1 rounded-md px-3 py-1 text-sm transition-colors hover:bg-muted",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemIndicatorProps = ComponentProps<"span"> & {
+	completed?: boolean;
+};
+
+export const QueueItemIndicator = ({
+	completed = false,
+	className,
+	...props
+}: QueueItemIndicatorProps) => (
+	<span
+		className={cn(
+			"mt-0.5 inline-block size-2.5 rounded-full border",
+			completed
+				? "border-muted-foreground/20 bg-muted-foreground/10"
+				: "border-muted-foreground/50",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemContentProps = ComponentProps<"span"> & {
+	completed?: boolean;
+};
+
+export const QueueItemContent = ({
+	completed = false,
+	className,
+	...props
+}: QueueItemContentProps) => (
+	<span
+		className={cn(
+			"line-clamp-1 grow break-words",
+			completed
+				? "text-muted-foreground/50 line-through"
+				: "text-muted-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemDescriptionProps = ComponentProps<"div"> & {
+	completed?: boolean;
+};
+
+export const QueueItemDescription = ({
+	completed = false,
+	className,
+	...props
+}: QueueItemDescriptionProps) => (
+	<div
+		className={cn(
+			"ml-6 text-xs",
+			completed
+				? "text-muted-foreground/40 line-through"
+				: "text-muted-foreground",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type QueueItemActionsProps = ComponentProps<"div">;
+
+export const QueueItemActions = ({
+	className,
+	...props
+}: QueueItemActionsProps) => (
+	<div className={cn("flex gap-1", className)} {...props} />
+);
+
+export type QueueItemActionProps = Omit<
+	ComponentProps<typeof Button>,
+	"variant" | "size"
+>;
+
+export const QueueItemAction = ({
+	className,
+	...props
+}: QueueItemActionProps) => (
+	<Button
+		className={cn(
+			"size-auto rounded p-1 text-muted-foreground opacity-0 transition-opacity hover:bg-muted-foreground/10 hover:text-foreground group-hover:opacity-100",
+			className,
+		)}
+		size="icon"
+		type="button"
+		variant="ghost"
+		{...props}
+	/>
+);
+
+export type QueueItemAttachmentProps = ComponentProps<"div">;
+
+export const QueueItemAttachment = ({
+	className,
+	...props
+}: QueueItemAttachmentProps) => (
+	<div className={cn("mt-1 flex flex-wrap gap-2", className)} {...props} />
+);
+
+export type QueueItemImageProps = ComponentProps<"img">;
+
+export const QueueItemImage = ({
+	className,
+	...props
+}: QueueItemImageProps) => (
+	<img
+		alt=""
+		className={cn("h-8 w-8 rounded border object-cover", className)}
+		height={32}
+		width={32}
+		{...props}
+	/>
+);
+
+export type QueueItemFileProps = ComponentProps<"span">;
+
+export const QueueItemFile = ({
+	children,
+	className,
+	...props
+}: QueueItemFileProps) => (
+	<span
+		className={cn(
+			"flex items-center gap-1 rounded border bg-muted px-2 py-1 text-xs",
+			className,
+		)}
+		{...props}
+	>
+		<PaperclipIcon size={12} />
+		<span className="max-w-[100px] truncate">{children}</span>
+	</span>
+);
+
+export type QueueListProps = ComponentProps<typeof ScrollArea>;
+
+export const QueueList = ({
+	children,
+	className,
+	...props
+}: QueueListProps) => (
+	<ScrollArea className={cn("mt-2 -mb-1", className)} {...props}>
+		<div className="max-h-40 pr-4">
+			<ul>{children}</ul>
+		</div>
+	</ScrollArea>
+);
+
+// QueueSection - collapsible section container
+export type QueueSectionProps = ComponentProps<typeof Collapsible>;
+
+export const QueueSection = ({
+	className,
+	defaultOpen = true,
+	...props
+}: QueueSectionProps) => (
+	<Collapsible className={cn(className)} defaultOpen={defaultOpen} {...props} />
+);
+
+// QueueSectionTrigger - section header/trigger
+export type QueueSectionTriggerProps = ComponentProps<"button">;
+
+export const QueueSectionTrigger = ({
+	children,
+	className,
+	...props
+}: QueueSectionTriggerProps) => (
+	<CollapsibleTrigger
+		render={
+			<button
+				className={cn(
+					"group flex w-full items-center justify-between rounded-md bg-muted/40 px-3 py-2 text-left font-medium text-muted-foreground text-sm transition-colors hover:bg-muted",
+					className,
+				)}
+				type="button"
+				{...props}
+			/>
+		}
+	>
+		{children}
+	</CollapsibleTrigger>
+);
+
+// QueueSectionLabel - label content with icon and count
+export type QueueSectionLabelProps = ComponentProps<"span"> & {
+	count?: number;
+	label: string;
+	icon?: React.ReactNode;
+};
+
+export const QueueSectionLabel = ({
+	count,
+	label,
+	icon,
+	className,
+	...props
+}: QueueSectionLabelProps) => (
+	<span className={cn("flex items-center gap-2", className)} {...props}>
+		<ChevronDownIcon className="size-4 transition-transform group-data-[state=closed]:-rotate-90" />
+		{icon}
+		<span>
+			{count} {label}
+		</span>
+	</span>
+);
+
+// QueueSectionContent - collapsible content area
+export type QueueSectionContentProps = ComponentProps<
+	typeof CollapsibleContent
+>;
+
+export const QueueSectionContent = ({
+	className,
+	...props
+}: QueueSectionContentProps) => (
+	<CollapsibleContent className={cn(className)} {...props} />
+);
+
+export type QueueProps = ComponentProps<"div">;
+
+export const Queue = ({ className, ...props }: QueueProps) => (
+	<div
+		className={cn(
+			"flex flex-col gap-2 rounded-xl border border-border bg-background px-3 pt-2 pb-2 shadow-xs",
+			className,
+		)}
+		{...props}
+	/>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/reasoning.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/reasoning.tsx
new file mode 100644
index 0000000..75034d0
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/reasoning.tsx
@@ -0,0 +1,226 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { cjk } from "@streamdown/cjk";
+import { code } from "@streamdown/code";
+import { math } from "@streamdown/math";
+import { mermaid } from "@streamdown/mermaid";
+import { BrainIcon, ChevronDownIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Streamdown } from "streamdown";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+import { Shimmer } from "./shimmer";
+
+interface ReasoningContextValue {
+	isStreaming: boolean;
+	isOpen: boolean;
+	setIsOpen: (open: boolean) => void;
+	duration: number | undefined;
+}
+
+const ReasoningContext = createContext<ReasoningContextValue | null>(null);
+
+export const useReasoning = () => {
+	const context = useContext(ReasoningContext);
+	if (!context) {
+		throw new Error("Reasoning components must be used within Reasoning");
+	}
+	return context;
+};
+
+export type ReasoningProps = ComponentProps<typeof Collapsible> & {
+	isStreaming?: boolean;
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	duration?: number;
+};
+
+const AUTO_CLOSE_DELAY = 1000;
+const MS_IN_S = 1000;
+
+export const Reasoning = memo(
+	({
+		className,
+		isStreaming = false,
+		open,
+		defaultOpen,
+		onOpenChange,
+		duration: durationProp,
+		children,
+		...props
+	}: ReasoningProps) => {
+		const resolvedDefaultOpen = defaultOpen ?? isStreaming;
+		// Track if defaultOpen was explicitly set to false (to prevent auto-open)
+		const isExplicitlyClosed = defaultOpen === false;
+
+		const [isOpen, setIsOpen] = useControllableState<boolean>({
+			defaultProp: resolvedDefaultOpen,
+			onChange: onOpenChange,
+			prop: open,
+		});
+		const [duration, setDuration] = useControllableState<number | undefined>({
+			defaultProp: undefined,
+			prop: durationProp,
+		});
+
+		const hasEverStreamedRef = useRef(isStreaming);
+		const [hasAutoClosed, setHasAutoClosed] = useState(false);
+		const startTimeRef = useRef<number | null>(null);
+
+		// Track when streaming starts and compute duration
+		useEffect(() => {
+			if (isStreaming) {
+				hasEverStreamedRef.current = true;
+				if (startTimeRef.current === null) {
+					startTimeRef.current = Date.now();
+				}
+			} else if (startTimeRef.current !== null) {
+				setDuration(Math.ceil((Date.now() - startTimeRef.current) / MS_IN_S));
+				startTimeRef.current = null;
+			}
+		}, [isStreaming, setDuration]);
+
+		// Auto-open when streaming starts (unless explicitly closed)
+		useEffect(() => {
+			if (isStreaming && !isOpen && !isExplicitlyClosed) {
+				setIsOpen(true);
+			}
+		}, [isStreaming, isOpen, setIsOpen, isExplicitlyClosed]);
+
+		// Auto-close when streaming ends (once only, and only if it ever streamed)
+		useEffect(() => {
+			if (
+				hasEverStreamedRef.current &&
+				!isStreaming &&
+				isOpen &&
+				!hasAutoClosed
+			) {
+				const timer = setTimeout(() => {
+					setIsOpen(false);
+					setHasAutoClosed(true);
+				}, AUTO_CLOSE_DELAY);
+
+				return () => clearTimeout(timer);
+			}
+		}, [isStreaming, isOpen, setIsOpen, hasAutoClosed]);
+
+		const handleOpenChange = useCallback(
+			(newOpen: boolean) => {
+				setIsOpen(newOpen);
+			},
+			[setIsOpen],
+		);
+
+		const contextValue = useMemo(
+			() => ({ duration, isOpen, isStreaming, setIsOpen }),
+			[duration, isOpen, isStreaming, setIsOpen],
+		);
+
+		return (
+			<ReasoningContext.Provider value={contextValue}>
+				<Collapsible
+					className={cn("not-prose mb-4", className)}
+					onOpenChange={handleOpenChange}
+					open={isOpen}
+					{...props}
+				>
+					{children}
+				</Collapsible>
+			</ReasoningContext.Provider>
+		);
+	},
+);
+
+export type ReasoningTriggerProps = ComponentProps<
+	typeof CollapsibleTrigger
+> & {
+	getThinkingMessage?: (isStreaming: boolean, duration?: number) => ReactNode;
+};
+
+const defaultGetThinkingMessage = (isStreaming: boolean, duration?: number) => {
+	if (isStreaming || duration === 0) {
+		return <Shimmer duration={1}>Thinking...</Shimmer>;
+	}
+	if (duration === undefined) {
+		return <p>Thought for a few seconds</p>;
+	}
+	return <p>Thought for {duration} seconds</p>;
+};
+
+export const ReasoningTrigger = memo(
+	({
+		className,
+		children,
+		getThinkingMessage = defaultGetThinkingMessage,
+		...props
+	}: ReasoningTriggerProps) => {
+		const { isStreaming, isOpen, duration } = useReasoning();
+
+		return (
+			<CollapsibleTrigger
+				className={cn(
+					"flex w-full items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<BrainIcon className="size-4" />
+						{getThinkingMessage(isStreaming, duration)}
+						<ChevronDownIcon
+							className={cn(
+								"size-4 transition-transform",
+								isOpen ? "rotate-180" : "rotate-0",
+							)}
+						/>
+					</>
+				)}
+			</CollapsibleTrigger>
+		);
+	},
+);
+
+export type ReasoningContentProps = ComponentProps<
+	typeof CollapsibleContent
+> & {
+	children: string;
+};
+
+const streamdownPlugins = { cjk, code, math, mermaid };
+
+export const ReasoningContent = memo(
+	({ className, children, ...props }: ReasoningContentProps) => (
+		<CollapsibleContent
+			className={cn(
+				"mt-4 text-sm",
+				"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-muted-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+				className,
+			)}
+			{...props}
+		>
+			<Streamdown plugins={streamdownPlugins}>{children}</Streamdown>
+		</CollapsibleContent>
+	),
+);
+
+Reasoning.displayName = "Reasoning";
+ReasoningTrigger.displayName = "ReasoningTrigger";
+ReasoningContent.displayName = "ReasoningContent";
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/sandbox.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/sandbox.tsx
new file mode 100644
index 0000000..fb05575
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/sandbox.tsx
@@ -0,0 +1,127 @@
+"use client";
+
+import type { ToolUIPart } from "ai";
+import { ChevronDownIcon, Code } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { cn } from "@/lib/utils";
+
+import { getStatusBadge } from "./status-badge";
+
+export type SandboxRootProps = ComponentProps<typeof Collapsible>;
+
+export const Sandbox = ({ className, ...props }: SandboxRootProps) => (
+	<Collapsible
+		className={cn(
+			"not-prose group mb-4 w-full overflow-hidden rounded-md border",
+			className,
+		)}
+		defaultOpen
+		{...props}
+	/>
+);
+
+export interface SandboxHeaderProps {
+	title?: string;
+	state: ToolUIPart["state"];
+	className?: string;
+}
+
+export const SandboxHeader = ({
+	className,
+	title,
+	state,
+	...props
+}: SandboxHeaderProps) => (
+	<CollapsibleTrigger
+		className={cn(
+			"flex w-full items-center justify-between gap-4 p-3",
+			className,
+		)}
+		{...props}
+	>
+		<div className="flex items-center gap-2">
+			<Code className="size-4 text-muted-foreground" />
+			<span className="font-medium text-sm">{title}</span>
+			{getStatusBadge(state)}
+		</div>
+		<ChevronDownIcon className="size-4 text-muted-foreground transition-transform group-data-[state=open]:rotate-180" />
+	</CollapsibleTrigger>
+);
+
+export type SandboxContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const SandboxContent = ({
+	className,
+	...props
+}: SandboxContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SandboxTabsProps = ComponentProps<typeof Tabs>;
+
+export const SandboxTabs = ({ className, ...props }: SandboxTabsProps) => (
+	<Tabs className={cn("w-full gap-0", className)} {...props} />
+);
+
+export type SandboxTabsBarProps = ComponentProps<"div">;
+
+export const SandboxTabsBar = ({
+	className,
+	...props
+}: SandboxTabsBarProps) => (
+	<div
+		className={cn(
+			"flex w-full items-center border-border border-t border-b",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SandboxTabsListProps = ComponentProps<typeof TabsList>;
+
+export const SandboxTabsList = ({
+	className,
+	...props
+}: SandboxTabsListProps) => (
+	<TabsList
+		className={cn("h-auto rounded-none border-0 bg-transparent p-0", className)}
+		{...props}
+	/>
+);
+
+export type SandboxTabsTriggerProps = ComponentProps<typeof TabsTrigger>;
+
+export const SandboxTabsTrigger = ({
+	className,
+	...props
+}: SandboxTabsTriggerProps) => (
+	<TabsTrigger
+		className={cn(
+			"rounded-none border-0 border-transparent border-b-2 px-4 py-2 font-medium text-muted-foreground text-sm transition-colors data-[state=active]:border-primary data-[state=active]:bg-transparent data-[state=active]:text-foreground data-[state=active]:shadow-none",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SandboxTabContentProps = ComponentProps<typeof TabsContent>;
+
+export const SandboxTabContent = ({
+	className,
+	...props
+}: SandboxTabContentProps) => (
+	<TabsContent className={cn("mt-0 text-sm", className)} {...props} />
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/schema-display.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/schema-display.tsx
new file mode 100644
index 0000000..d547961
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/schema-display.tsx
@@ -0,0 +1,472 @@
+"use client";
+
+import { ChevronRightIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+interface SchemaParameter {
+	name: string;
+	type: string;
+	required?: boolean;
+	description?: string;
+	location?: "path" | "query" | "header";
+}
+
+interface SchemaProperty {
+	name: string;
+	type: string;
+	required?: boolean;
+	description?: string;
+	properties?: SchemaProperty[];
+	items?: SchemaProperty;
+}
+
+interface SchemaDisplayContextType {
+	method: HttpMethod;
+	path: string;
+	description?: string;
+	parameters?: SchemaParameter[];
+	requestBody?: SchemaProperty[];
+	responseBody?: SchemaProperty[];
+}
+
+const SchemaDisplayContext = createContext<SchemaDisplayContextType>({
+	method: "GET",
+	path: "",
+});
+
+const methodStyles: Record<HttpMethod, string> = {
+	DELETE: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
+	GET: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+	PATCH:
+		"bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
+	POST: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+	PUT: "bg-orange-100 text-orange-700 dark:bg-orange-900/30 dark:text-orange-400",
+};
+
+export type SchemaDisplayHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const SchemaDisplayHeader = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayHeaderProps) => (
+	<div
+		className={cn("flex items-center gap-3 border-b px-4 py-3", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type SchemaDisplayMethodProps = ComponentProps<typeof Badge>;
+
+export const SchemaDisplayMethod = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayMethodProps) => {
+	const { method } = useContext(SchemaDisplayContext);
+
+	return (
+		<Badge
+			className={cn("font-mono text-xs", methodStyles[method], className)}
+			variant="secondary"
+			{...props}
+		>
+			{children ?? method}
+		</Badge>
+	);
+};
+
+export type SchemaDisplayPathProps = HTMLAttributes<HTMLSpanElement>;
+
+export const SchemaDisplayPath = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayPathProps) => {
+	const { path } = useContext(SchemaDisplayContext);
+
+	// Highlight path parameters
+	const highlightedPath = path.replaceAll(
+		/\{([^}]+)\}/g,
+		'<span class="text-blue-600 dark:text-blue-400">{$1}</span>',
+	);
+
+	return (
+		<span
+			className={cn("font-mono text-sm", className)}
+			// oxlint-disable-next-line eslint-plugin-react(no-danger)
+			// biome-ignore lint/security/noDangerouslySetInnerHtml: content is sanitized highlighted syntax
+			dangerouslySetInnerHTML={{ __html: children ?? highlightedPath }}
+			{...props}
+		/>
+	);
+};
+
+export type SchemaDisplayDescriptionProps =
+	HTMLAttributes<HTMLParagraphElement>;
+
+export const SchemaDisplayDescription = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayDescriptionProps) => {
+	const { description } = useContext(SchemaDisplayContext);
+
+	return (
+		<p
+			className={cn(
+				"border-b px-4 py-3 text-muted-foreground text-sm",
+				className,
+			)}
+			{...props}
+		>
+			{children ?? description}
+		</p>
+	);
+};
+
+export type SchemaDisplayContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const SchemaDisplayContent = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayContentProps) => (
+	<div className={cn("divide-y", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type SchemaDisplayParameterProps = HTMLAttributes<HTMLDivElement> &
+	SchemaParameter;
+
+export const SchemaDisplayParameter = ({
+	name,
+	type,
+	required,
+	description,
+	location,
+	className,
+	...props
+}: SchemaDisplayParameterProps) => (
+	<div className={cn("px-4 py-3 pl-10", className)} {...props}>
+		<div className="flex items-center gap-2">
+			<span className="font-mono text-sm">{name}</span>
+			<Badge className="text-xs" variant="outline">
+				{type}
+			</Badge>
+			{location && (
+				<Badge className="text-xs" variant="secondary">
+					{location}
+				</Badge>
+			)}
+			{required && (
+				<Badge
+					className="bg-red-100 text-red-700 text-xs dark:bg-red-900/30 dark:text-red-400"
+					variant="secondary"
+				>
+					required
+				</Badge>
+			)}
+		</div>
+		{description && (
+			<p className="mt-1 text-muted-foreground text-sm">{description}</p>
+		)}
+	</div>
+);
+
+export type SchemaDisplayParametersProps = ComponentProps<typeof Collapsible>;
+
+export const SchemaDisplayParameters = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayParametersProps) => {
+	const { parameters } = useContext(SchemaDisplayContext);
+
+	return (
+		<Collapsible className={cn(className)} defaultOpen {...props}>
+			<CollapsibleTrigger className="group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50">
+				<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+				<span className="font-medium text-sm">Parameters</span>
+				<Badge className="ml-auto text-xs" variant="secondary">
+					{parameters?.length}
+				</Badge>
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="divide-y border-t">
+					{children ??
+						parameters?.map((param) => (
+							<SchemaDisplayParameter key={param.name} {...param} />
+						))}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
+
+export type SchemaDisplayPropertyProps = HTMLAttributes<HTMLDivElement> &
+	SchemaProperty & {
+		depth?: number;
+	};
+
+export const SchemaDisplayProperty = ({
+	name,
+	type,
+	required,
+	description,
+	properties,
+	items,
+	depth = 0,
+	className,
+	...props
+}: SchemaDisplayPropertyProps) => {
+	const hasChildren = properties || items;
+	const paddingLeft = 40 + depth * 16;
+
+	if (hasChildren) {
+		return (
+			<Collapsible defaultOpen={depth < 2}>
+				<CollapsibleTrigger
+					className={cn(
+						"group flex w-full items-center gap-2 py-3 text-left transition-colors hover:bg-muted/50",
+						className,
+					)}
+					style={{ paddingLeft }}
+				>
+					<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+					<span className="font-mono text-sm">{name}</span>
+					<Badge className="text-xs" variant="outline">
+						{type}
+					</Badge>
+					{required && (
+						<Badge
+							className="bg-red-100 text-red-700 text-xs dark:bg-red-900/30 dark:text-red-400"
+							variant="secondary"
+						>
+							required
+						</Badge>
+					)}
+				</CollapsibleTrigger>
+				{description && (
+					<p
+						className="pb-2 text-muted-foreground text-sm"
+						style={{ paddingLeft: paddingLeft + 24 }}
+					>
+						{description}
+					</p>
+				)}
+				<CollapsibleContent>
+					<div className="divide-y border-t">
+						{properties?.map((prop) => (
+							<SchemaDisplayProperty
+								key={prop.name}
+								{...prop}
+								depth={depth + 1}
+							/>
+						))}
+						{items && (
+							<SchemaDisplayProperty
+								{...items}
+								depth={depth + 1}
+								name={`${name}[]`}
+							/>
+						)}
+					</div>
+				</CollapsibleContent>
+			</Collapsible>
+		);
+	}
+
+	return (
+		<div
+			className={cn("py-3 pr-4", className)}
+			style={{ paddingLeft }}
+			{...props}
+		>
+			<div className="flex items-center gap-2">
+				{/* Spacer for alignment */}
+				<span className="size-4" />
+				<span className="font-mono text-sm">{name}</span>
+				<Badge className="text-xs" variant="outline">
+					{type}
+				</Badge>
+				{required && (
+					<Badge
+						className="bg-red-100 text-red-700 text-xs dark:bg-red-900/30 dark:text-red-400"
+						variant="secondary"
+					>
+						required
+					</Badge>
+				)}
+			</div>
+			{description && (
+				<p className="mt-1 pl-6 text-muted-foreground text-sm">{description}</p>
+			)}
+		</div>
+	);
+};
+
+export type SchemaDisplayRequestProps = ComponentProps<typeof Collapsible>;
+
+export const SchemaDisplayRequest = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayRequestProps) => {
+	const { requestBody } = useContext(SchemaDisplayContext);
+
+	return (
+		<Collapsible className={cn(className)} defaultOpen {...props}>
+			<CollapsibleTrigger className="group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50">
+				<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+				<span className="font-medium text-sm">Request Body</span>
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="border-t">
+					{children ??
+						requestBody?.map((prop) => (
+							<SchemaDisplayProperty key={prop.name} {...prop} depth={0} />
+						))}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
+
+export type SchemaDisplayResponseProps = ComponentProps<typeof Collapsible>;
+
+export const SchemaDisplayResponse = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayResponseProps) => {
+	const { responseBody } = useContext(SchemaDisplayContext);
+
+	return (
+		<Collapsible className={cn(className)} defaultOpen {...props}>
+			<CollapsibleTrigger className="group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50">
+				<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+				<span className="font-medium text-sm">Response</span>
+			</CollapsibleTrigger>
+			<CollapsibleContent>
+				<div className="border-t">
+					{children ??
+						responseBody?.map((prop) => (
+							<SchemaDisplayProperty key={prop.name} {...prop} depth={0} />
+						))}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
+
+export type SchemaDisplayProps = HTMLAttributes<HTMLDivElement> & {
+	method: HttpMethod;
+	path: string;
+	description?: string;
+	parameters?: SchemaParameter[];
+	requestBody?: SchemaProperty[];
+	responseBody?: SchemaProperty[];
+};
+
+export const SchemaDisplay = ({
+	method,
+	path,
+	description,
+	parameters,
+	requestBody,
+	responseBody,
+	className,
+	children,
+	...props
+}: SchemaDisplayProps) => {
+	const contextValue = useMemo(
+		() => ({
+			description,
+			method,
+			parameters,
+			path,
+			requestBody,
+			responseBody,
+		}),
+		[description, method, parameters, path, requestBody, responseBody],
+	);
+
+	return (
+		<SchemaDisplayContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"overflow-hidden rounded-lg border bg-background",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<SchemaDisplayHeader>
+							<div className="flex items-center gap-3">
+								<SchemaDisplayMethod />
+								<SchemaDisplayPath />
+							</div>
+						</SchemaDisplayHeader>
+						{description && <SchemaDisplayDescription />}
+						<SchemaDisplayContent>
+							{parameters && parameters.length > 0 && (
+								<SchemaDisplayParameters />
+							)}
+							{requestBody && requestBody.length > 0 && (
+								<SchemaDisplayRequest />
+							)}
+							{responseBody && responseBody.length > 0 && (
+								<SchemaDisplayResponse />
+							)}
+						</SchemaDisplayContent>
+					</>
+				)}
+			</div>
+		</SchemaDisplayContext.Provider>
+	);
+};
+
+export type SchemaDisplayBodyProps = HTMLAttributes<HTMLDivElement>;
+
+export const SchemaDisplayBody = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayBodyProps) => (
+	<div className={cn("divide-y", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type SchemaDisplayExampleProps = HTMLAttributes<HTMLPreElement>;
+
+export const SchemaDisplayExample = ({
+	className,
+	children,
+	...props
+}: SchemaDisplayExampleProps) => (
+	<pre
+		className={cn(
+			"mx-4 mb-4 overflow-auto rounded-md bg-muted p-4 font-mono text-sm",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</pre>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/shimmer.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/shimmer.tsx
new file mode 100644
index 0000000..5c4e9c8
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/shimmer.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import type { MotionProps } from "motion/react";
+import { motion } from "motion/react";
+import type { CSSProperties, ElementType, JSX } from "react";
+import { memo, useMemo } from "react";
+import { cn } from "@/lib/utils";
+
+type MotionHTMLProps = MotionProps & Record<string, unknown>;
+
+// Cache motion components at module level to avoid creating during render
+const motionComponentCache = new Map<
+	keyof JSX.IntrinsicElements,
+	React.ComponentType<MotionHTMLProps>
+>();
+
+const getMotionComponent = (element: keyof JSX.IntrinsicElements) => {
+	let component = motionComponentCache.get(element);
+	if (!component) {
+		component = motion.create(element);
+		motionComponentCache.set(element, component);
+	}
+	return component;
+};
+
+export interface TextShimmerProps {
+	children: string;
+	as?: ElementType;
+	className?: string;
+	duration?: number;
+	spread?: number;
+}
+
+const ShimmerComponent = ({
+	children,
+	as: Component = "p",
+	className,
+	duration = 2,
+	spread = 2,
+}: TextShimmerProps) => {
+	const MotionComponent = getMotionComponent(
+		Component as keyof JSX.IntrinsicElements,
+	);
+
+	const dynamicSpread = useMemo(
+		() => (children?.length ?? 0) * spread,
+		[children, spread],
+	);
+
+	return (
+		<MotionComponent
+			animate={{ backgroundPosition: "0% center" }}
+			className={cn(
+				"relative inline-block bg-[length:250%_100%,auto] bg-clip-text text-transparent",
+				"[--bg:linear-gradient(90deg,#0000_calc(50%-var(--spread)),var(--color-background),#0000_calc(50%+var(--spread)))] [background-repeat:no-repeat,padding-box]",
+				className,
+			)}
+			initial={{ backgroundPosition: "100% center" }}
+			style={
+				{
+					"--spread": `${dynamicSpread}px`,
+					backgroundImage:
+						"var(--bg), linear-gradient(var(--color-muted-foreground), var(--color-muted-foreground))",
+				} as CSSProperties
+			}
+			transition={{
+				duration,
+				ease: "linear",
+				repeat: Number.POSITIVE_INFINITY,
+			}}
+		>
+			{children}
+		</MotionComponent>
+	);
+};
+
+export const Shimmer = memo(ShimmerComponent);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/snippet.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/snippet.tsx
new file mode 100644
index 0000000..13668b6
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/snippet.tsx
@@ -0,0 +1,145 @@
+"use client";
+
+import { CheckIcon, CopyIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupInput,
+	InputGroupText,
+} from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+interface SnippetContextType {
+	code: string;
+}
+
+const SnippetContext = createContext<SnippetContextType>({
+	code: "",
+});
+
+export type SnippetProps = ComponentProps<typeof InputGroup> & {
+	code: string;
+};
+
+export const Snippet = ({
+	code,
+	className,
+	children,
+	...props
+}: SnippetProps) => {
+	const contextValue = useMemo(() => ({ code }), [code]);
+
+	return (
+		<SnippetContext.Provider value={contextValue}>
+			<InputGroup className={cn("font-mono", className)} {...props}>
+				{children}
+			</InputGroup>
+		</SnippetContext.Provider>
+	);
+};
+
+export type SnippetAddonProps = ComponentProps<typeof InputGroupAddon>;
+
+export const SnippetAddon = (props: SnippetAddonProps) => (
+	<InputGroupAddon {...props} />
+);
+
+export type SnippetTextProps = ComponentProps<typeof InputGroupText>;
+
+export const SnippetText = ({ className, ...props }: SnippetTextProps) => (
+	<InputGroupText
+		className={cn("pl-2 font-normal text-muted-foreground", className)}
+		{...props}
+	/>
+);
+
+export type SnippetInputProps = Omit<
+	ComponentProps<typeof InputGroupInput>,
+	"readOnly" | "value"
+>;
+
+export const SnippetInput = ({ className, ...props }: SnippetInputProps) => {
+	const { code } = useContext(SnippetContext);
+
+	return (
+		<InputGroupInput
+			className={cn("text-foreground", className)}
+			readOnly
+			value={code}
+			{...props}
+		/>
+	);
+};
+
+export type SnippetCopyButtonProps = ComponentProps<typeof InputGroupButton> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const SnippetCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: SnippetCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { code } = useContext(SnippetContext);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			if (!isCopied) {
+				await navigator.clipboard.writeText(code);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			}
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [code, onCopy, onError, timeout, isCopied]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<InputGroupButton
+			aria-label="Copy"
+			className={className}
+			onClick={copyToClipboard}
+			size="icon-sm"
+			title="Copy"
+			{...props}
+		>
+			{children ?? <Icon className="size-3.5" size={14} />}
+		</InputGroupButton>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/sources.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/sources.tsx
new file mode 100644
index 0000000..477d007
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/sources.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import { BookIcon, ChevronDownIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+export type SourcesProps = ComponentProps<"div">;
+
+export const Sources = ({ className, ...props }: SourcesProps) => (
+	<Collapsible
+		className={cn("not-prose mb-4 text-primary text-xs", className)}
+		{...props}
+	/>
+);
+
+export type SourcesTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+	count: number;
+};
+
+export const SourcesTrigger = ({
+	className,
+	count,
+	children,
+	...props
+}: SourcesTriggerProps) => (
+	<CollapsibleTrigger
+		className={cn("flex items-center gap-2", className)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				<p className="font-medium">Used {count} sources</p>
+				<ChevronDownIcon className="h-4 w-4" />
+			</>
+		)}
+	</CollapsibleTrigger>
+);
+
+export type SourcesContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const SourcesContent = ({
+	className,
+	...props
+}: SourcesContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"mt-3 flex w-fit flex-col gap-2",
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type SourceProps = ComponentProps<"a">;
+
+export const Source = ({ href, title, children, ...props }: SourceProps) => (
+	<a
+		className="flex items-center gap-2"
+		href={href}
+		rel="noreferrer"
+		target="_blank"
+		{...props}
+	>
+		{children ?? (
+			<>
+				<BookIcon className="h-4 w-4" />
+				<span className="block font-medium">{title}</span>
+			</>
+		)}
+	</a>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/speech-input.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/speech-input.tsx
new file mode 100644
index 0000000..b9ee555
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/speech-input.tsx
@@ -0,0 +1,323 @@
+"use client";
+
+import { MicIcon, SquareIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Spinner } from "@/components/ui/spinner";
+import { cn } from "@/lib/utils";
+
+interface SpeechRecognition extends EventTarget {
+	continuous: boolean;
+	interimResults: boolean;
+	lang: string;
+	start(): void;
+	stop(): void;
+	onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+	onend: ((this: SpeechRecognition, ev: Event) => void) | null;
+	onresult:
+		| ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void)
+		| null;
+	onerror:
+		| ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void)
+		| null;
+}
+
+interface SpeechRecognitionEvent extends Event {
+	results: SpeechRecognitionResultList;
+	resultIndex: number;
+}
+
+interface SpeechRecognitionResultList {
+	readonly length: number;
+	item(index: number): SpeechRecognitionResult;
+	[index: number]: SpeechRecognitionResult;
+}
+
+interface SpeechRecognitionResult {
+	readonly length: number;
+	item(index: number): SpeechRecognitionAlternative;
+	[index: number]: SpeechRecognitionAlternative;
+	isFinal: boolean;
+}
+
+interface SpeechRecognitionAlternative {
+	transcript: string;
+	confidence: number;
+}
+
+interface SpeechRecognitionErrorEvent extends Event {
+	error: string;
+}
+
+declare global {
+	interface Window {
+		SpeechRecognition: new () => SpeechRecognition;
+		webkitSpeechRecognition: new () => SpeechRecognition;
+	}
+}
+
+type SpeechInputMode = "speech-recognition" | "media-recorder" | "none";
+
+export type SpeechInputProps = ComponentProps<typeof Button> & {
+	onTranscriptionChange?: (text: string) => void;
+	/**
+	 * Callback for when audio is recorded using MediaRecorder fallback.
+	 * This is called in browsers that don't support the Web Speech API (Firefox, Safari).
+	 * The callback receives an audio Blob that should be sent to a transcription service.
+	 * Return the transcribed text, which will be passed to onTranscriptionChange.
+	 */
+	onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+	lang?: string;
+};
+
+const detectSpeechInputMode = (): SpeechInputMode => {
+	if (typeof window === "undefined") {
+		return "none";
+	}
+
+	if ("SpeechRecognition" in window || "webkitSpeechRecognition" in window) {
+		return "speech-recognition";
+	}
+
+	if ("MediaRecorder" in window && "mediaDevices" in navigator) {
+		return "media-recorder";
+	}
+
+	return "none";
+};
+
+export const SpeechInput = ({
+	className,
+	onTranscriptionChange,
+	onAudioRecorded,
+	lang = "en-US",
+	...props
+}: SpeechInputProps) => {
+	const [isListening, setIsListening] = useState(false);
+	const [isProcessing, setIsProcessing] = useState(false);
+	const [mode] = useState<SpeechInputMode>(detectSpeechInputMode);
+	const [isRecognitionReady, setIsRecognitionReady] = useState(false);
+	const recognitionRef = useRef<SpeechRecognition | null>(null);
+	const mediaRecorderRef = useRef<MediaRecorder | null>(null);
+	const streamRef = useRef<MediaStream | null>(null);
+	const audioChunksRef = useRef<Blob[]>([]);
+	const onTranscriptionChangeRef = useRef<
+		SpeechInputProps["onTranscriptionChange"]
+	>(onTranscriptionChange);
+	const onAudioRecordedRef =
+		useRef<SpeechInputProps["onAudioRecorded"]>(onAudioRecorded);
+
+	// Keep refs in sync
+	onTranscriptionChangeRef.current = onTranscriptionChange;
+	onAudioRecordedRef.current = onAudioRecorded;
+
+	// Initialize Speech Recognition when mode is speech-recognition
+	useEffect(() => {
+		if (mode !== "speech-recognition") {
+			return;
+		}
+
+		const SpeechRecognition =
+			window.SpeechRecognition || window.webkitSpeechRecognition;
+		const speechRecognition = new SpeechRecognition();
+
+		speechRecognition.continuous = true;
+		speechRecognition.interimResults = true;
+		speechRecognition.lang = lang;
+
+		const handleStart = () => {
+			setIsListening(true);
+		};
+
+		const handleEnd = () => {
+			setIsListening(false);
+		};
+
+		const handleResult = (event: Event) => {
+			const speechEvent = event as SpeechRecognitionEvent;
+			let finalTranscript = "";
+
+			for (
+				let i = speechEvent.resultIndex;
+				i < speechEvent.results.length;
+				i += 1
+			) {
+				const result = speechEvent.results[i];
+				if (result.isFinal) {
+					finalTranscript += result[0]?.transcript ?? "";
+				}
+			}
+
+			if (finalTranscript) {
+				onTranscriptionChangeRef.current?.(finalTranscript);
+			}
+		};
+
+		const handleError = () => {
+			setIsListening(false);
+		};
+
+		speechRecognition.addEventListener("start", handleStart);
+		speechRecognition.addEventListener("end", handleEnd);
+		speechRecognition.addEventListener("result", handleResult);
+		speechRecognition.addEventListener("error", handleError);
+
+		recognitionRef.current = speechRecognition;
+		setIsRecognitionReady(true);
+
+		return () => {
+			speechRecognition.removeEventListener("start", handleStart);
+			speechRecognition.removeEventListener("end", handleEnd);
+			speechRecognition.removeEventListener("result", handleResult);
+			speechRecognition.removeEventListener("error", handleError);
+			speechRecognition.stop();
+			recognitionRef.current = null;
+			setIsRecognitionReady(false);
+		};
+	}, [mode, lang]);
+
+	// Cleanup MediaRecorder and stream on unmount
+	useEffect(
+		() => () => {
+			if (mediaRecorderRef.current?.state === "recording") {
+				mediaRecorderRef.current.stop();
+			}
+			if (streamRef.current) {
+				for (const track of streamRef.current.getTracks()) {
+					track.stop();
+				}
+			}
+		},
+		[],
+	);
+
+	// Start MediaRecorder recording
+	const startMediaRecorder = useCallback(async () => {
+		if (!onAudioRecordedRef.current) {
+			return;
+		}
+
+		try {
+			const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+			streamRef.current = stream;
+			const mediaRecorder = new MediaRecorder(stream);
+			audioChunksRef.current = [];
+
+			const handleDataAvailable = (event: BlobEvent) => {
+				if (event.data.size > 0) {
+					audioChunksRef.current.push(event.data);
+				}
+			};
+
+			const handleStop = async () => {
+				for (const track of stream.getTracks()) {
+					track.stop();
+				}
+				streamRef.current = null;
+
+				const audioBlob = new Blob(audioChunksRef.current, {
+					type: "audio/webm",
+				});
+
+				if (audioBlob.size > 0 && onAudioRecordedRef.current) {
+					setIsProcessing(true);
+					try {
+						const transcript = await onAudioRecordedRef.current(audioBlob);
+						if (transcript) {
+							onTranscriptionChangeRef.current?.(transcript);
+						}
+					} catch {
+						// Error handling delegated to the onAudioRecorded caller
+					} finally {
+						setIsProcessing(false);
+					}
+				}
+			};
+
+			const handleError = () => {
+				setIsListening(false);
+				for (const track of stream.getTracks()) {
+					track.stop();
+				}
+				streamRef.current = null;
+			};
+
+			mediaRecorder.addEventListener("dataavailable", handleDataAvailable);
+			mediaRecorder.addEventListener("stop", handleStop);
+			mediaRecorder.addEventListener("error", handleError);
+
+			mediaRecorderRef.current = mediaRecorder;
+			mediaRecorder.start();
+			setIsListening(true);
+		} catch {
+			setIsListening(false);
+		}
+	}, []);
+
+	// Stop MediaRecorder recording
+	const stopMediaRecorder = useCallback(() => {
+		if (mediaRecorderRef.current?.state === "recording") {
+			mediaRecorderRef.current.stop();
+		}
+		setIsListening(false);
+	}, []);
+
+	const toggleListening = useCallback(() => {
+		if (mode === "speech-recognition" && recognitionRef.current) {
+			if (isListening) {
+				recognitionRef.current.stop();
+			} else {
+				recognitionRef.current.start();
+			}
+		} else if (mode === "media-recorder") {
+			if (isListening) {
+				stopMediaRecorder();
+			} else {
+				startMediaRecorder();
+			}
+		}
+	}, [mode, isListening, startMediaRecorder, stopMediaRecorder]);
+
+	// Determine if button should be disabled
+	const isDisabled =
+		mode === "none" ||
+		(mode === "speech-recognition" && !isRecognitionReady) ||
+		(mode === "media-recorder" && !onAudioRecorded) ||
+		isProcessing;
+
+	return (
+		<div className="relative inline-flex items-center justify-center">
+			{/* Animated pulse rings */}
+			{isListening &&
+				[0, 1, 2].map((index) => (
+					<div
+						className="absolute inset-0 animate-ping rounded-full border-2 border-red-400/30"
+						key={index}
+						style={{
+							animationDelay: `${index * 0.3}s`,
+							animationDuration: "2s",
+						}}
+					/>
+				))}
+
+			{/* Main record button */}
+			<Button
+				className={cn(
+					"relative z-10 rounded-full transition-all duration-300",
+					isListening
+						? "bg-destructive text-white hover:bg-destructive/80 hover:text-white"
+						: "bg-primary text-primary-foreground hover:bg-primary/80 hover:text-primary-foreground",
+					className,
+				)}
+				disabled={isDisabled}
+				onClick={toggleListening}
+				{...props}
+			>
+				{isProcessing && <Spinner />}
+				{!isProcessing && isListening && <SquareIcon className="size-4" />}
+				{!(isProcessing || isListening) && <MicIcon className="size-4" />}
+			</Button>
+		</div>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/stack-trace.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/stack-trace.tsx
new file mode 100644
index 0000000..42e15b6
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/stack-trace.tsx
@@ -0,0 +1,532 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import {
+	AlertTriangleIcon,
+	CheckIcon,
+	ChevronDownIcon,
+	CopyIcon,
+} from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	createContext,
+	memo,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+// Regex patterns for parsing stack traces
+const STACK_FRAME_WITH_PARENS_REGEX = /^at\s+(.+?)\s+\((.+):(\d+):(\d+)\)$/;
+const STACK_FRAME_WITHOUT_FN_REGEX = /^at\s+(.+):(\d+):(\d+)$/;
+const ERROR_TYPE_REGEX = /^(\w+Error|Error):\s*(.*)$/;
+const AT_PREFIX_REGEX = /^at\s+/;
+
+interface StackFrame {
+	raw: string;
+	functionName: string | null;
+	filePath: string | null;
+	lineNumber: number | null;
+	columnNumber: number | null;
+	isInternal: boolean;
+}
+
+interface ParsedStackTrace {
+	errorType: string | null;
+	errorMessage: string;
+	frames: StackFrame[];
+	raw: string;
+}
+
+interface StackTraceContextValue {
+	trace: ParsedStackTrace;
+	raw: string;
+	isOpen: boolean;
+	setIsOpen: (open: boolean) => void;
+	onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+}
+
+const StackTraceContext = createContext<StackTraceContextValue | null>(null);
+
+const useStackTrace = () => {
+	const context = useContext(StackTraceContext);
+	if (!context) {
+		throw new Error("StackTrace components must be used within StackTrace");
+	}
+	return context;
+};
+
+const parseStackFrame = (line: string): StackFrame => {
+	const trimmed = line.trim();
+
+	// Pattern: at functionName (filePath:line:column)
+	const withParensMatch = trimmed.match(STACK_FRAME_WITH_PARENS_REGEX);
+	if (withParensMatch) {
+		const [, functionName, filePath, lineNum, colNum] = withParensMatch;
+		const isInternal =
+			filePath.includes("node_modules") ||
+			filePath.startsWith("node:") ||
+			filePath.includes("internal/");
+		return {
+			columnNumber: colNum ? Number.parseInt(colNum, 10) : null,
+			filePath: filePath ?? null,
+			functionName: functionName ?? null,
+			isInternal,
+			lineNumber: lineNum ? Number.parseInt(lineNum, 10) : null,
+			raw: trimmed,
+		};
+	}
+
+	// Pattern: at filePath:line:column (no function name)
+	const withoutFnMatch = trimmed.match(STACK_FRAME_WITHOUT_FN_REGEX);
+	if (withoutFnMatch) {
+		const [, filePath, lineNum, colNum] = withoutFnMatch;
+		const isInternal =
+			(filePath?.includes("node_modules") ?? false) ||
+			(filePath?.startsWith("node:") ?? false) ||
+			(filePath?.includes("internal/") ?? false);
+		return {
+			columnNumber: colNum ? Number.parseInt(colNum, 10) : null,
+			filePath: filePath ?? null,
+			functionName: null,
+			isInternal,
+			lineNumber: lineNum ? Number.parseInt(lineNum, 10) : null,
+			raw: trimmed,
+		};
+	}
+
+	// Fallback: unparseable line
+	return {
+		columnNumber: null,
+		filePath: null,
+		functionName: null,
+		isInternal: trimmed.includes("node_modules") || trimmed.includes("node:"),
+		lineNumber: null,
+		raw: trimmed,
+	};
+};
+
+const parseStackTrace = (trace: string): ParsedStackTrace => {
+	const lines = trace.split("\n").filter((line) => line.trim());
+
+	if (lines.length === 0) {
+		return {
+			errorMessage: trace,
+			errorType: null,
+			frames: [],
+			raw: trace,
+		};
+	}
+
+	const firstLine = lines[0].trim();
+	let errorType: string | null = null;
+	let errorMessage = firstLine;
+
+	// Try to extract error type from "ErrorType: message" format
+	const errorMatch = firstLine.match(ERROR_TYPE_REGEX);
+	if (errorMatch) {
+		const [, type, msg] = errorMatch;
+		errorType = type;
+		errorMessage = msg || "";
+	}
+
+	// Parse stack frames (lines starting with "at")
+	const frames = lines
+		.slice(1)
+		.filter((line) => line.trim().startsWith("at "))
+		.map(parseStackFrame);
+
+	return {
+		errorMessage,
+		errorType,
+		frames,
+		raw: trace,
+	};
+};
+
+export type StackTraceProps = ComponentProps<"div"> & {
+	trace: string;
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+};
+
+export const StackTrace = memo(
+	({
+		trace,
+		className,
+		open,
+		defaultOpen = false,
+		onOpenChange,
+		onFilePathClick,
+		children,
+		...props
+	}: StackTraceProps) => {
+		const [isOpen, setIsOpen] = useControllableState({
+			defaultProp: defaultOpen,
+			onChange: onOpenChange,
+			prop: open,
+		});
+
+		const parsedTrace = useMemo(() => parseStackTrace(trace), [trace]);
+
+		const contextValue = useMemo(
+			() => ({
+				isOpen,
+				onFilePathClick,
+				raw: trace,
+				setIsOpen,
+				trace: parsedTrace,
+			}),
+			[parsedTrace, trace, isOpen, setIsOpen, onFilePathClick],
+		);
+
+		return (
+			<StackTraceContext.Provider value={contextValue}>
+				<div
+					className={cn(
+						"not-prose w-full overflow-hidden rounded-lg border bg-background font-mono text-sm",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+				</div>
+			</StackTraceContext.Provider>
+		);
+	},
+);
+
+export type StackTraceHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+
+export const StackTraceHeader = memo(
+	({ className, children, ...props }: StackTraceHeaderProps) => {
+		const { isOpen, setIsOpen } = useStackTrace();
+
+		return (
+			<Collapsible onOpenChange={setIsOpen} open={isOpen}>
+				<CollapsibleTrigger
+					{...props}
+					render={
+						<div
+							className={cn(
+								"flex w-full cursor-pointer items-center gap-3 p-3 text-left transition-colors hover:bg-muted/50",
+								className,
+							)}
+						/>
+					}
+				>
+					{children}
+				</CollapsibleTrigger>
+			</Collapsible>
+		);
+	},
+);
+
+export type StackTraceErrorProps = ComponentProps<"div">;
+
+export const StackTraceError = memo(
+	({ className, children, ...props }: StackTraceErrorProps) => (
+		<div
+			className={cn(
+				"flex flex-1 items-center gap-2 overflow-hidden",
+				className,
+			)}
+			{...props}
+		>
+			<AlertTriangleIcon className="size-4 shrink-0 text-destructive" />
+			{children}
+		</div>
+	),
+);
+
+export type StackTraceErrorTypeProps = ComponentProps<"span">;
+
+export const StackTraceErrorType = memo(
+	({ className, children, ...props }: StackTraceErrorTypeProps) => {
+		const { trace } = useStackTrace();
+
+		return (
+			<span
+				className={cn("shrink-0 font-semibold text-destructive", className)}
+				{...props}
+			>
+				{children ?? trace.errorType}
+			</span>
+		);
+	},
+);
+
+export type StackTraceErrorMessageProps = ComponentProps<"span">;
+
+export const StackTraceErrorMessage = memo(
+	({ className, children, ...props }: StackTraceErrorMessageProps) => {
+		const { trace } = useStackTrace();
+
+		return (
+			<span className={cn("truncate text-foreground", className)} {...props}>
+				{children ?? trace.errorMessage}
+			</span>
+		);
+	},
+);
+
+export type StackTraceActionsProps = ComponentProps<"div">;
+
+const handleActionsClick = (e: React.MouseEvent) => e.stopPropagation();
+const handleActionsKeyDown = (e: React.KeyboardEvent) => {
+	if (e.key === "Enter" || e.key === " ") {
+		e.stopPropagation();
+	}
+};
+
+export const StackTraceActions = memo(
+	({ className, children, ...props }: StackTraceActionsProps) => (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			className={cn("flex shrink-0 items-center gap-1", className)}
+			onClick={handleActionsClick}
+			onKeyDown={handleActionsKeyDown}
+			role="group"
+			{...props}
+		>
+			{children}
+		</div>
+	),
+);
+
+export type StackTraceCopyButtonProps = ComponentProps<typeof Button> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const StackTraceCopyButton = memo(
+	({
+		onCopy,
+		onError,
+		timeout = 2000,
+		className,
+		children,
+		...props
+	}: StackTraceCopyButtonProps) => {
+		const [isCopied, setIsCopied] = useState(false);
+		const timeoutRef = useRef<number>(0);
+		const { raw } = useStackTrace();
+
+		const copyToClipboard = useCallback(async () => {
+			if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+				onError?.(new Error("Clipboard API not available"));
+				return;
+			}
+
+			try {
+				await navigator.clipboard.writeText(raw);
+				setIsCopied(true);
+				onCopy?.();
+				timeoutRef.current = window.setTimeout(
+					() => setIsCopied(false),
+					timeout,
+				);
+			} catch (error) {
+				onError?.(error as Error);
+			}
+		}, [raw, onCopy, onError, timeout]);
+
+		useEffect(
+			() => () => {
+				window.clearTimeout(timeoutRef.current);
+			},
+			[],
+		);
+
+		const Icon = isCopied ? CheckIcon : CopyIcon;
+
+		return (
+			<Button
+				className={cn("size-7", className)}
+				onClick={copyToClipboard}
+				size="icon"
+				variant="ghost"
+				{...props}
+			>
+				{children ?? <Icon size={14} />}
+			</Button>
+		);
+	},
+);
+
+export type StackTraceExpandButtonProps = ComponentProps<"div">;
+
+export const StackTraceExpandButton = memo(
+	({ className, ...props }: StackTraceExpandButtonProps) => {
+		const { isOpen } = useStackTrace();
+
+		return (
+			<div
+				className={cn("flex size-7 items-center justify-center", className)}
+				{...props}
+			>
+				<ChevronDownIcon
+					className={cn(
+						"size-4 text-muted-foreground transition-transform",
+						isOpen ? "rotate-180" : "rotate-0",
+					)}
+				/>
+			</div>
+		);
+	},
+);
+
+export type StackTraceContentProps = ComponentProps<
+	typeof CollapsibleContent
+> & {
+	maxHeight?: number;
+};
+
+export const StackTraceContent = memo(
+	({
+		className,
+		maxHeight = 400,
+		children,
+		...props
+	}: StackTraceContentProps) => {
+		const { isOpen } = useStackTrace();
+
+		return (
+			<Collapsible open={isOpen}>
+				<CollapsibleContent
+					className={cn(
+						"overflow-auto border-t bg-muted/30",
+						"data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:animate-out data-[state=open]:animate-in",
+						className,
+					)}
+					style={{ maxHeight }}
+					{...props}
+				>
+					{children}
+				</CollapsibleContent>
+			</Collapsible>
+		);
+	},
+);
+
+export type StackTraceFramesProps = ComponentProps<"div"> & {
+	showInternalFrames?: boolean;
+};
+
+interface FilePathButtonProps {
+	frame: StackFrame;
+	onFilePathClick?: (
+		filePath: string,
+		lineNumber?: number,
+		columnNumber?: number,
+	) => void;
+}
+
+const FilePathButton = memo(
+	({ frame, onFilePathClick }: FilePathButtonProps) => {
+		const handleClick = useCallback(() => {
+			if (frame.filePath) {
+				onFilePathClick?.(
+					frame.filePath,
+					frame.lineNumber ?? undefined,
+					frame.columnNumber ?? undefined,
+				);
+			}
+		}, [frame, onFilePathClick]);
+
+		return (
+			<button
+				className={cn(
+					"underline decoration-dotted hover:text-primary",
+					onFilePathClick && "cursor-pointer",
+				)}
+				disabled={!onFilePathClick}
+				onClick={handleClick}
+				type="button"
+			>
+				{frame.filePath}
+				{frame.lineNumber !== null && `:${frame.lineNumber}`}
+				{frame.columnNumber !== null && `:${frame.columnNumber}`}
+			</button>
+		);
+	},
+);
+
+FilePathButton.displayName = "FilePathButton";
+
+export const StackTraceFrames = memo(
+	({
+		className,
+		showInternalFrames = true,
+		...props
+	}: StackTraceFramesProps) => {
+		const { trace, onFilePathClick } = useStackTrace();
+
+		const framesToShow = showInternalFrames
+			? trace.frames
+			: trace.frames.filter((f) => !f.isInternal);
+
+		return (
+			<div className={cn("space-y-1 p-3", className)} {...props}>
+				{framesToShow.map((frame) => (
+					<div
+						className={cn(
+							"text-xs",
+							frame.isInternal
+								? "text-muted-foreground/50"
+								: "text-foreground/90",
+						)}
+						key={frame.raw}
+					>
+						<span className="text-muted-foreground">at </span>
+						{frame.functionName && (
+							<span className={frame.isInternal ? "" : "text-foreground"}>
+								{frame.functionName}{" "}
+							</span>
+						)}
+						{frame.filePath && (
+							<>
+								<span className="text-muted-foreground">(</span>
+								<FilePathButton
+									frame={frame}
+									onFilePathClick={onFilePathClick}
+								/>
+								<span className="text-muted-foreground">)</span>
+							</>
+						)}
+						{!(frame.filePath || frame.functionName) && (
+							<span>{frame.raw.replace(AT_PREFIX_REGEX, "")}</span>
+						)}
+					</div>
+				))}
+				{framesToShow.length === 0 && (
+					<div className="text-muted-foreground text-xs">No stack frames</div>
+				)}
+			</div>
+		);
+	},
+);
+
+StackTrace.displayName = "StackTrace";
+StackTraceHeader.displayName = "StackTraceHeader";
+StackTraceError.displayName = "StackTraceError";
+StackTraceErrorType.displayName = "StackTraceErrorType";
+StackTraceErrorMessage.displayName = "StackTraceErrorMessage";
+StackTraceActions.displayName = "StackTraceActions";
+StackTraceCopyButton.displayName = "StackTraceCopyButton";
+StackTraceExpandButton.displayName = "StackTraceExpandButton";
+StackTraceContent.displayName = "StackTraceContent";
+StackTraceFrames.displayName = "StackTraceFrames";
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/status-badge.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/status-badge.tsx
new file mode 100644
index 0000000..e38514b
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/status-badge.tsx
@@ -0,0 +1,28 @@
+import {
+	CheckCircleIcon,
+	CircleIcon,
+	ClockIcon,
+	XCircleIcon,
+} from "lucide-react";
+import type { ReactNode } from "react";
+import { Badge } from "@/components/ui/badge";
+
+import type { ToolPart } from "./tool";
+
+const statusIcons: Record<ToolPart["state"], ReactNode | null> = {
+	"approval-requested": <ClockIcon className="size-4 text-yellow-600" />,
+	"approval-responded": <CheckCircleIcon className="size-4 text-blue-600" />,
+	"input-available": <ClockIcon className="size-4 animate-pulse" />,
+	"input-streaming": <CircleIcon className="size-4" />,
+	"output-available": <CheckCircleIcon className="size-4 text-green-600" />,
+	"output-denied": <XCircleIcon className="size-4 text-orange-600" />,
+	"output-error": <XCircleIcon className="size-4 text-red-600" />,
+};
+
+export function getStatusBadge(status: ToolPart["state"]) {
+	return (
+		<Badge className="gap-1.5 text-xs" variant="secondary">
+			{statusIcons[status]}
+		</Badge>
+	);
+}
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/suggestion.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/suggestion.tsx
new file mode 100644
index 0000000..2180a9a
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/suggestion.tsx
@@ -0,0 +1,54 @@
+"use client";
+
+import type { ComponentProps } from "react";
+import { useCallback } from "react";
+import { Button } from "@/components/ui/button";
+import { ScrollArea, ScrollBar } from "@/components/ui/scroll-area";
+import { cn } from "@/lib/utils";
+
+export type SuggestionsProps = ComponentProps<typeof ScrollArea>;
+
+export const Suggestions = ({
+	className,
+	children,
+	...props
+}: SuggestionsProps) => (
+	<ScrollArea className="w-full overflow-x-auto whitespace-nowrap" {...props}>
+		<div className={cn("flex w-max flex-nowrap items-center gap-2", className)}>
+			{children}
+		</div>
+		<ScrollBar className="hidden" orientation="horizontal" />
+	</ScrollArea>
+);
+
+export type SuggestionProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+	suggestion: string;
+	onClick?: (suggestion: string) => void;
+};
+
+export const Suggestion = ({
+	suggestion,
+	onClick,
+	className,
+	variant = "outline",
+	size = "sm",
+	children,
+	...props
+}: SuggestionProps) => {
+	const handleClick = useCallback(() => {
+		onClick?.(suggestion);
+	}, [onClick, suggestion]);
+
+	return (
+		<Button
+			className={cn("cursor-pointer rounded-full px-4", className)}
+			onClick={handleClick}
+			size={size}
+			type="button"
+			variant={variant}
+			{...props}
+		>
+			{children || suggestion}
+		</Button>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/task.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/task.tsx
new file mode 100644
index 0000000..5299590
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/task.tsx
@@ -0,0 +1,87 @@
+"use client";
+
+import { ChevronDownIcon, SearchIcon } from "lucide-react";
+import type { ComponentProps } from "react";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+export type TaskItemFileProps = ComponentProps<"div">;
+
+export const TaskItemFile = ({
+	children,
+	className,
+	...props
+}: TaskItemFileProps) => (
+	<div
+		className={cn(
+			"inline-flex items-center gap-1 rounded-md border bg-secondary px-1.5 py-0.5 text-foreground text-xs",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TaskItemProps = ComponentProps<"div">;
+
+export const TaskItem = ({ children, className, ...props }: TaskItemProps) => (
+	<div className={cn("text-muted-foreground text-sm", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type TaskProps = ComponentProps<typeof Collapsible>;
+
+export const Task = ({
+	defaultOpen = true,
+	className,
+	...props
+}: TaskProps) => (
+	<Collapsible className={cn(className)} defaultOpen={defaultOpen} {...props} />
+);
+
+export type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+	title: string;
+};
+
+export const TaskTrigger = ({
+	children,
+	className,
+	title,
+	...props
+}: TaskTriggerProps) => (
+	<CollapsibleTrigger className={cn("group", className)} {...props}>
+		{children ?? (
+			<div className="flex w-full cursor-pointer items-center gap-2 text-muted-foreground text-sm transition-colors hover:text-foreground">
+				<SearchIcon className="size-4" />
+				<p className="text-sm">{title}</p>
+				<ChevronDownIcon className="size-4 transition-transform group-data-[state=open]:rotate-180" />
+			</div>
+		)}
+	</CollapsibleTrigger>
+);
+
+export type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const TaskContent = ({
+	children,
+	className,
+	...props
+}: TaskContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+			className,
+		)}
+		{...props}
+	>
+		<div className="mt-4 space-y-2 border-muted border-l-2 pl-4">
+			{children}
+		</div>
+	</CollapsibleContent>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/terminal.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/terminal.tsx
new file mode 100644
index 0000000..7516e79
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/terminal.tsx
@@ -0,0 +1,273 @@
+"use client";
+
+import Ansi from "ansi-to-react";
+import { CheckIcon, CopyIcon, TerminalIcon, Trash2Icon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+interface TerminalContextType {
+	output: string;
+	isStreaming: boolean;
+	autoScroll: boolean;
+	onClear?: () => void;
+}
+
+const TerminalContext = createContext<TerminalContextType>({
+	autoScroll: true,
+	isStreaming: false,
+	output: "",
+});
+
+export type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalHeader = ({
+	className,
+	children,
+	...props
+}: TerminalHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-zinc-800 border-b px-4 py-2",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalTitle = ({
+	className,
+	children,
+	...props
+}: TerminalTitleProps) => (
+	<div
+		className={cn("flex items-center gap-2 text-sm text-zinc-400", className)}
+		{...props}
+	>
+		<TerminalIcon className="size-4" />
+		{children ?? "Terminal"}
+	</div>
+);
+
+export type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalStatus = ({
+	className,
+	children,
+	...props
+}: TerminalStatusProps) => {
+	const { isStreaming } = useContext(TerminalContext);
+
+	if (!isStreaming) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn("flex items-center gap-2 text-xs text-zinc-400", className)}
+			{...props}
+		>
+			{children}
+		</div>
+	);
+};
+
+export type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalActions = ({
+	className,
+	children,
+	...props
+}: TerminalActionsProps) => (
+	<div className={cn("flex items-center gap-1", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+	onCopy?: () => void;
+	onError?: (error: Error) => void;
+	timeout?: number;
+};
+
+export const TerminalCopyButton = ({
+	onCopy,
+	onError,
+	timeout = 2000,
+	children,
+	className,
+	...props
+}: TerminalCopyButtonProps) => {
+	const [isCopied, setIsCopied] = useState(false);
+	const timeoutRef = useRef<number>(0);
+	const { output } = useContext(TerminalContext);
+
+	const copyToClipboard = useCallback(async () => {
+		if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+			onError?.(new Error("Clipboard API not available"));
+			return;
+		}
+
+		try {
+			await navigator.clipboard.writeText(output);
+			setIsCopied(true);
+			onCopy?.();
+			timeoutRef.current = window.setTimeout(() => setIsCopied(false), timeout);
+		} catch (error) {
+			onError?.(error as Error);
+		}
+	}, [output, onCopy, onError, timeout]);
+
+	useEffect(
+		() => () => {
+			window.clearTimeout(timeoutRef.current);
+		},
+		[],
+	);
+
+	const Icon = isCopied ? CheckIcon : CopyIcon;
+
+	return (
+		<Button
+			className={cn(
+				"size-7 shrink-0 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100",
+				className,
+			)}
+			onClick={copyToClipboard}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Icon size={14} />}
+		</Button>
+	);
+};
+
+export type TerminalClearButtonProps = ComponentProps<typeof Button>;
+
+export const TerminalClearButton = ({
+	children,
+	className,
+	...props
+}: TerminalClearButtonProps) => {
+	const { onClear } = useContext(TerminalContext);
+
+	if (!onClear) {
+		return null;
+	}
+
+	return (
+		<Button
+			className={cn(
+				"size-7 shrink-0 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100",
+				className,
+			)}
+			onClick={onClear}
+			size="icon"
+			variant="ghost"
+			{...props}
+		>
+			{children ?? <Trash2Icon size={14} />}
+		</Button>
+	);
+};
+
+export type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalContent = ({
+	className,
+	children,
+	...props
+}: TerminalContentProps) => {
+	const { output, isStreaming, autoScroll } = useContext(TerminalContext);
+	const containerRef = useRef<HTMLDivElement>(null);
+
+	useEffect(() => {
+		if (autoScroll && containerRef.current) {
+			containerRef.current.scrollTop = containerRef.current.scrollHeight;
+		}
+	}, [autoScroll]);
+
+	return (
+		<div
+			className={cn(
+				"max-h-96 overflow-auto p-4 font-mono text-sm leading-relaxed",
+				className,
+			)}
+			ref={containerRef}
+			{...props}
+		>
+			{children ?? (
+				<pre className="whitespace-pre-wrap break-words">
+					<Ansi>{output}</Ansi>
+					{isStreaming && (
+						<span className="ml-0.5 inline-block h-4 w-2 animate-pulse bg-zinc-100" />
+					)}
+				</pre>
+			)}
+		</div>
+	);
+};
+
+export type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+	output: string;
+	isStreaming?: boolean;
+	autoScroll?: boolean;
+	onClear?: () => void;
+};
+
+export const Terminal = ({
+	output,
+	isStreaming = false,
+	autoScroll = true,
+	onClear,
+	className,
+	children,
+	...props
+}: TerminalProps) => {
+	const contextValue = useMemo(
+		() => ({ autoScroll, isStreaming, onClear, output }),
+		[autoScroll, isStreaming, onClear, output],
+	);
+
+	return (
+		<TerminalContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex flex-col overflow-hidden rounded-lg border bg-zinc-950 text-zinc-100",
+					className,
+				)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<TerminalHeader>
+							<TerminalTitle />
+							<div className="flex items-center gap-1">
+								<TerminalStatus />
+								<TerminalActions>
+									<TerminalCopyButton />
+									{onClear && <TerminalClearButton />}
+								</TerminalActions>
+							</div>
+						</TerminalHeader>
+						<TerminalContent />
+					</>
+				)}
+			</div>
+		</TerminalContext.Provider>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/test-results.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/test-results.tsx
new file mode 100644
index 0000000..900e107
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/test-results.tsx
@@ -0,0 +1,496 @@
+"use client";
+
+import {
+	CheckCircle2Icon,
+	ChevronRightIcon,
+	CircleDotIcon,
+	CircleIcon,
+	XCircleIcon,
+} from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+type TestStatus = "passed" | "failed" | "skipped" | "running";
+
+interface TestResultsSummary {
+	passed: number;
+	failed: number;
+	skipped: number;
+	total: number;
+	duration?: number;
+}
+
+interface TestResultsContextType {
+	summary?: TestResultsSummary;
+}
+
+const TestResultsContext = createContext<TestResultsContextType>({});
+
+const formatDuration = (ms: number) => {
+	if (ms < 1000) {
+		return `${ms}ms`;
+	}
+	return `${(ms / 1000).toFixed(2)}s`;
+};
+
+export type TestResultsHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsHeader = ({
+	className,
+	children,
+	...props
+}: TestResultsHeaderProps) => (
+	<div
+		className={cn(
+			"flex items-center justify-between border-b px-4 py-3",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TestResultsDurationProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestResultsDuration = ({
+	className,
+	children,
+	...props
+}: TestResultsDurationProps) => {
+	const { summary } = useContext(TestResultsContext);
+
+	if (!summary?.duration) {
+		return null;
+	}
+
+	return (
+		<span className={cn("text-muted-foreground text-sm", className)} {...props}>
+			{children ?? formatDuration(summary.duration)}
+		</span>
+	);
+};
+
+export type TestResultsSummaryProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsSummary = ({
+	className,
+	children,
+	...props
+}: TestResultsSummaryProps) => {
+	const { summary } = useContext(TestResultsContext);
+
+	if (!summary) {
+		return null;
+	}
+
+	return (
+		<div className={cn("flex items-center gap-3", className)} {...props}>
+			{children ?? (
+				<>
+					<Badge
+						className="gap-1 bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400"
+						variant="secondary"
+					>
+						<CheckCircle2Icon className="size-3" />
+						{summary.passed} passed
+					</Badge>
+					{summary.failed > 0 && (
+						<Badge
+							className="gap-1 bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400"
+							variant="secondary"
+						>
+							<XCircleIcon className="size-3" />
+							{summary.failed} failed
+						</Badge>
+					)}
+					{summary.skipped > 0 && (
+						<Badge
+							className="gap-1 bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400"
+							variant="secondary"
+						>
+							<CircleIcon className="size-3" />
+							{summary.skipped} skipped
+						</Badge>
+					)}
+				</>
+			)}
+		</div>
+	);
+};
+
+export type TestResultsProps = HTMLAttributes<HTMLDivElement> & {
+	summary?: TestResultsSummary;
+};
+
+export const TestResults = ({
+	summary,
+	className,
+	children,
+	...props
+}: TestResultsProps) => {
+	const contextValue = useMemo(() => ({ summary }), [summary]);
+
+	return (
+		<TestResultsContext.Provider value={contextValue}>
+			<div
+				className={cn("rounded-lg border bg-background", className)}
+				{...props}
+			>
+				{children ??
+					(summary && (
+						<TestResultsHeader>
+							<TestResultsSummary />
+							<TestResultsDuration />
+						</TestResultsHeader>
+					))}
+			</div>
+		</TestResultsContext.Provider>
+	);
+};
+
+export type TestResultsProgressProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsProgress = ({
+	className,
+	children,
+	...props
+}: TestResultsProgressProps) => {
+	const { summary } = useContext(TestResultsContext);
+
+	if (!summary) {
+		return null;
+	}
+
+	const passedPercent = (summary.passed / summary.total) * 100;
+	const failedPercent = (summary.failed / summary.total) * 100;
+
+	return (
+		<div className={cn("space-y-2", className)} {...props}>
+			{children ?? (
+				<>
+					<div className="flex h-2 overflow-hidden rounded-full bg-muted">
+						<div
+							className="bg-green-500 transition-all"
+							style={{ width: `${passedPercent}%` }}
+						/>
+						<div
+							className="bg-red-500 transition-all"
+							style={{ width: `${failedPercent}%` }}
+						/>
+					</div>
+					<div className="flex justify-between text-muted-foreground text-xs">
+						<span>
+							{summary.passed}/{summary.total} tests passed
+						</span>
+						<span>{passedPercent.toFixed(0)}%</span>
+					</div>
+				</>
+			)}
+		</div>
+	);
+};
+
+export type TestResultsContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestResultsContent = ({
+	className,
+	children,
+	...props
+}: TestResultsContentProps) => (
+	<div className={cn("space-y-2 p-4", className)} {...props}>
+		{children}
+	</div>
+);
+
+interface TestSuiteContextType {
+	name: string;
+	status: TestStatus;
+}
+
+const TestSuiteContext = createContext<TestSuiteContextType>({
+	name: "",
+	status: "passed",
+});
+
+const statusStyles: Record<TestStatus, string> = {
+	failed: "text-red-600 dark:text-red-400",
+	passed: "text-green-600 dark:text-green-400",
+	running: "text-blue-600 dark:text-blue-400",
+	skipped: "text-yellow-600 dark:text-yellow-400",
+};
+
+const statusIcons: Record<TestStatus, React.ReactNode> = {
+	failed: <XCircleIcon className="size-4" />,
+	passed: <CheckCircle2Icon className="size-4" />,
+	running: <CircleDotIcon className="size-4 animate-pulse" />,
+	skipped: <CircleIcon className="size-4" />,
+};
+
+const TestStatusIcon = ({ status }: { status: TestStatus }) => (
+	<span className={cn("shrink-0", statusStyles[status])}>
+		{statusIcons[status]}
+	</span>
+);
+
+export type TestSuiteProps = ComponentProps<typeof Collapsible> & {
+	name: string;
+	status: TestStatus;
+};
+
+export const TestSuite = ({
+	name,
+	status,
+	className,
+	children,
+	...props
+}: TestSuiteProps) => {
+	const contextValue = useMemo(() => ({ name, status }), [name, status]);
+
+	return (
+		<TestSuiteContext.Provider value={contextValue}>
+			<Collapsible className={cn("rounded-lg border", className)} {...props}>
+				{children}
+			</Collapsible>
+		</TestSuiteContext.Provider>
+	);
+};
+
+export type TestSuiteNameProps = ComponentProps<typeof CollapsibleTrigger>;
+
+export const TestSuiteName = ({
+	className,
+	children,
+	...props
+}: TestSuiteNameProps) => {
+	const { name, status } = useContext(TestSuiteContext);
+
+	return (
+		<CollapsibleTrigger
+			className={cn(
+				"group flex w-full items-center gap-2 px-4 py-3 text-left transition-colors hover:bg-muted/50",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronRightIcon className="size-4 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" />
+			<TestStatusIcon status={status} />
+			<span className="font-medium text-sm">{children ?? name}</span>
+		</CollapsibleTrigger>
+	);
+};
+
+export type TestSuiteStatsProps = HTMLAttributes<HTMLDivElement> & {
+	passed?: number;
+	failed?: number;
+	skipped?: number;
+};
+
+export const TestSuiteStats = ({
+	passed = 0,
+	failed = 0,
+	skipped = 0,
+	className,
+	children,
+	...props
+}: TestSuiteStatsProps) => (
+	<div
+		className={cn("ml-auto flex items-center gap-2 text-xs", className)}
+		{...props}
+	>
+		{children ?? (
+			<>
+				{passed > 0 && (
+					<span className="text-green-600 dark:text-green-400">
+						{passed} passed
+					</span>
+				)}
+				{failed > 0 && (
+					<span className="text-red-600 dark:text-red-400">
+						{failed} failed
+					</span>
+				)}
+				{skipped > 0 && (
+					<span className="text-yellow-600 dark:text-yellow-400">
+						{skipped} skipped
+					</span>
+				)}
+			</>
+		)}
+	</div>
+);
+
+export type TestSuiteContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const TestSuiteContent = ({
+	className,
+	children,
+	...props
+}: TestSuiteContentProps) => (
+	<CollapsibleContent className={cn("border-t", className)} {...props}>
+		<div className="divide-y">{children}</div>
+	</CollapsibleContent>
+);
+
+interface TestContextType {
+	name: string;
+	status: TestStatus;
+	duration?: number;
+}
+
+const TestContext = createContext<TestContextType>({
+	name: "",
+	status: "passed",
+});
+
+export type TestNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestName = ({ className, children, ...props }: TestNameProps) => {
+	const { name } = useContext(TestContext);
+
+	return (
+		<span className={cn("flex-1", className)} {...props}>
+			{children ?? name}
+		</span>
+	);
+};
+
+export type TestDurationProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestDuration = ({
+	className,
+	children,
+	...props
+}: TestDurationProps) => {
+	const { duration } = useContext(TestContext);
+
+	if (duration === undefined) {
+		return null;
+	}
+
+	return (
+		<span
+			className={cn("ml-auto text-muted-foreground text-xs", className)}
+			{...props}
+		>
+			{children ?? `${duration}ms`}
+		</span>
+	);
+};
+
+export type TestStatusProps = HTMLAttributes<HTMLSpanElement>;
+
+export const TestStatus = ({
+	className,
+	children,
+	...props
+}: TestStatusProps) => {
+	const { status } = useContext(TestContext);
+
+	return (
+		<span
+			className={cn("shrink-0", statusStyles[status], className)}
+			{...props}
+		>
+			{children ?? statusIcons[status]}
+		</span>
+	);
+};
+
+export type TestProps = HTMLAttributes<HTMLDivElement> & {
+	name: string;
+	status: TestStatus;
+	duration?: number;
+};
+
+export const Test = ({
+	name,
+	status,
+	duration,
+	className,
+	children,
+	...props
+}: TestProps) => {
+	const contextValue = useMemo(
+		() => ({ duration, name, status }),
+		[duration, name, status],
+	);
+
+	return (
+		<TestContext.Provider value={contextValue}>
+			<div
+				className={cn("flex items-center gap-2 px-4 py-2 text-sm", className)}
+				{...props}
+			>
+				{children ?? (
+					<>
+						<TestStatus />
+						<TestName />
+						{duration !== undefined && <TestDuration />}
+					</>
+				)}
+			</div>
+		</TestContext.Provider>
+	);
+};
+
+export type TestErrorProps = HTMLAttributes<HTMLDivElement>;
+
+export const TestError = ({
+	className,
+	children,
+	...props
+}: TestErrorProps) => (
+	<div
+		className={cn(
+			"mt-2 rounded-md bg-red-50 p-3 dark:bg-red-900/20",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type TestErrorMessageProps = HTMLAttributes<HTMLParagraphElement>;
+
+export const TestErrorMessage = ({
+	className,
+	children,
+	...props
+}: TestErrorMessageProps) => (
+	<p
+		className={cn(
+			"font-medium text-red-700 text-sm dark:text-red-400",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</p>
+);
+
+export type TestErrorStackProps = HTMLAttributes<HTMLPreElement>;
+
+export const TestErrorStack = ({
+	className,
+	children,
+	...props
+}: TestErrorStackProps) => (
+	<pre
+		className={cn(
+			"mt-2 overflow-auto font-mono text-red-600 text-xs dark:text-red-400",
+			className,
+		)}
+		{...props}
+	>
+		{children}
+	</pre>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/tool.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/tool.tsx
new file mode 100644
index 0000000..b9d04eb
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/tool.tsx
@@ -0,0 +1,159 @@
+import type { DynamicToolUIPart, ToolUIPart } from "ai";
+import {
+	FileCodeIcon,
+	MessagesSquareIcon,
+	PencilIcon,
+	TerminalIcon,
+	WrenchIcon,
+} from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { isValidElement } from "react";
+import { Badge } from "@/components/ui/badge";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+
+import { CodeBlock } from "./code-block";
+import { getStatusBadge } from "./status-badge";
+
+export type ToolProps = ComponentProps<typeof Collapsible>;
+
+export const Tool = ({ className, ...props }: ToolProps) => (
+	<Collapsible
+		className={cn("group not-prose mb-4 w-full rounded-sm border", className)}
+		{...props}
+	/>
+);
+
+export type ToolPart = ToolUIPart | DynamicToolUIPart;
+
+export type ToolHeaderProps = {
+	title?: string;
+	className?: string;
+} & (
+	| { type: ToolUIPart["type"]; state: ToolUIPart["state"]; toolName?: never }
+	| {
+			type: DynamicToolUIPart["type"];
+			state: DynamicToolUIPart["state"];
+			toolName: string;
+	  }
+);
+
+const toolIcons: Record<string, ReactNode> = {
+	run_commands: <TerminalIcon className="size-4" />,
+	read_files: <FileCodeIcon className="size-4" />,
+	editor: <PencilIcon className="size-4" />,
+	ask_question: <MessagesSquareIcon className="size-4" />,
+};
+
+const getToolBadge = (toolName: string) => {
+	return (
+		<Badge className="text-xs" variant="ghost">
+			{(toolName && toolIcons[toolName]) || <WrenchIcon className="size-4" />}
+		</Badge>
+	);
+};
+
+export const ToolHeader = ({
+	className,
+	title,
+	type,
+	state,
+	toolName,
+	...props
+}: ToolHeaderProps) => {
+	const toolNameParts = title?.split(":");
+	const _toolName = toolNameParts?.[0] || toolName;
+	const toolInput = toolNameParts?.[1];
+	const derivedName = _toolName || title || type.split("-").slice(1).join("-");
+
+	return (
+		<CollapsibleTrigger
+			className={cn(
+				"flex w-full overflow-hidden items-center justify-between gap-4 p-3 cursor-pointer",
+				className,
+			)}
+			{...props}
+		>
+			<div className="flex items-center gap-2 shrink-0">
+				{getToolBadge(derivedName)}
+				<span className="font-light text-muted-foreground text-sm truncated wrap-break-word ellipses">
+					{toolInput}
+				</span>
+				{getStatusBadge(state)}
+			</div>
+		</CollapsibleTrigger>
+	);
+};
+
+export type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const ToolContent = ({ className, ...props }: ToolContentProps) => (
+	<CollapsibleContent
+		className={cn(
+			"data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 space-y-4 p-1 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in overflow-hidden font-mono",
+			className,
+		)}
+		{...props}
+	/>
+);
+
+export type ToolInputProps = ComponentProps<"div"> & {
+	input: ToolPart["input"];
+};
+
+export const ToolInput = ({ className, input, ...props }: ToolInputProps) => (
+	<div className={cn("space-y-2 overflow-hidden", className)} {...props}>
+		<h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
+			Parameters
+		</h4>
+		<div className="rounded-md bg-muted/50">
+			<CodeBlock code={JSON.stringify(input, null, 2)} language="json" />
+		</div>
+	</div>
+);
+
+export type ToolOutputProps = ComponentProps<"div"> & {
+	output: ToolPart["output"];
+	errorText: ToolPart["errorText"];
+};
+
+export const ToolOutput = ({
+	className,
+	output,
+	errorText,
+	...props
+}: ToolOutputProps) => {
+	if (!(output || errorText)) {
+		return null;
+	}
+
+	let Output = <div>{output as ReactNode}</div>;
+
+	if (typeof output === "object" && !isValidElement(output)) {
+		Output = (
+			<CodeBlock code={JSON.stringify(output, null, 2)} language="json" />
+		);
+	} else if (typeof output === "string") {
+		Output = <CodeBlock code={output} language="json" />;
+	}
+
+	return (
+		<div className={cn("space-y-2", className)} {...props}>
+			<div
+				className={cn(
+					"overflow-auto rounded-md text-xs [&_table]:w-full max-h-20",
+					errorText
+						? "bg-destructive/10 text-destructive"
+						: "bg-muted/50 text-foreground",
+				)}
+			>
+				{errorText && <div>{errorText}</div>}
+				{Output}
+			</div>
+		</div>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/toolbar.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/toolbar.tsx
new file mode 100644
index 0000000..8e0dcb2
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/toolbar.tsx
@@ -0,0 +1,16 @@
+import { NodeToolbar, Position } from "@xyflow/react";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+type ToolbarProps = ComponentProps<typeof NodeToolbar>;
+
+export const Toolbar = ({ className, ...props }: ToolbarProps) => (
+	<NodeToolbar
+		className={cn(
+			"flex items-center gap-1 rounded-sm border bg-background p-1.5",
+			className,
+		)}
+		position={Position.Bottom}
+		{...props}
+	/>
+);
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/transcription.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/transcription.tsx
new file mode 100644
index 0000000..de586c0
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/transcription.tsx
@@ -0,0 +1,125 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import type { Experimental_TranscriptionResult as TranscriptionResult } from "ai";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { cn } from "@/lib/utils";
+
+type TranscriptionSegment = TranscriptionResult["segments"][number];
+
+interface TranscriptionContextValue {
+	segments: TranscriptionSegment[];
+	currentTime: number;
+	onTimeUpdate: (time: number) => void;
+	onSeek?: (time: number) => void;
+}
+
+const TranscriptionContext = createContext<TranscriptionContextValue | null>(
+	null,
+);
+
+const useTranscription = () => {
+	const context = useContext(TranscriptionContext);
+	if (!context) {
+		throw new Error(
+			"Transcription components must be used within Transcription",
+		);
+	}
+	return context;
+};
+
+export type TranscriptionProps = Omit<ComponentProps<"div">, "children"> & {
+	segments: TranscriptionSegment[];
+	currentTime?: number;
+	onSeek?: (time: number) => void;
+	children: (segment: TranscriptionSegment, index: number) => ReactNode;
+};
+
+export const Transcription = ({
+	segments,
+	currentTime: externalCurrentTime,
+	onSeek,
+	className,
+	children,
+	...props
+}: TranscriptionProps) => {
+	const [currentTime, setCurrentTime] = useControllableState({
+		defaultProp: 0,
+		onChange: onSeek,
+		prop: externalCurrentTime,
+	});
+
+	const contextValue = useMemo(
+		() => ({ currentTime, onSeek, onTimeUpdate: setCurrentTime, segments }),
+		[currentTime, onSeek, setCurrentTime, segments],
+	);
+
+	return (
+		<TranscriptionContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex flex-wrap gap-1 text-sm leading-relaxed",
+					className,
+				)}
+				data-slot="transcription"
+				{...props}
+			>
+				{segments
+					.filter((segment) => segment.text.trim())
+					.map((segment, index) => children(segment, index))}
+			</div>
+		</TranscriptionContext.Provider>
+	);
+};
+
+export type TranscriptionSegmentProps = ComponentProps<"button"> & {
+	segment: TranscriptionSegment;
+	index: number;
+};
+
+export const TranscriptionSegment = ({
+	segment,
+	index,
+	className,
+	onClick,
+	...props
+}: TranscriptionSegmentProps) => {
+	const { currentTime, onSeek } = useTranscription();
+
+	const isActive =
+		currentTime >= segment.startSecond && currentTime < segment.endSecond;
+	const isPast = currentTime >= segment.endSecond;
+
+	const handleClick = useCallback(
+		(event: React.MouseEvent<HTMLButtonElement>) => {
+			if (onSeek) {
+				onSeek(segment.startSecond);
+			}
+			onClick?.(event);
+		},
+		[onSeek, segment.startSecond, onClick],
+	);
+
+	return (
+		<button
+			className={cn(
+				"inline text-left",
+				isActive && "text-primary",
+				isPast && "text-muted-foreground",
+				!(isActive || isPast) && "text-muted-foreground/60",
+				onSeek && "cursor-pointer hover:text-foreground",
+				!onSeek && "cursor-default",
+				className,
+			)}
+			data-active={isActive}
+			data-index={index}
+			data-slot="transcription-segment"
+			onClick={handleClick}
+			type="button"
+			{...props}
+		>
+			{segment.text}
+		</button>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/voice-selector.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/voice-selector.tsx
new file mode 100644
index 0000000..d89d4fe
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/voice-selector.tsx
@@ -0,0 +1,533 @@
+"use client";
+
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import {
+	CircleSmallIcon,
+	MarsIcon,
+	MarsStrokeIcon,
+	NonBinaryIcon,
+	PauseIcon,
+	PlayIcon,
+	TransgenderIcon,
+	VenusAndMarsIcon,
+	VenusIcon,
+} from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Command,
+	CommandDialog,
+	CommandEmpty,
+	CommandGroup,
+	CommandInput,
+	CommandItem,
+	CommandList,
+	CommandSeparator,
+	CommandShortcut,
+} from "@/components/ui/command";
+import {
+	Dialog,
+	DialogContent,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import { Spinner } from "@/components/ui/spinner";
+import { cn } from "@/lib/utils";
+
+interface VoiceSelectorContextValue {
+	value: string | undefined;
+	setValue: (value: string | undefined) => void;
+	open: boolean;
+	setOpen: (open: boolean) => void;
+}
+
+const VoiceSelectorContext = createContext<VoiceSelectorContextValue | null>(
+	null,
+);
+
+export const useVoiceSelector = () => {
+	const context = useContext(VoiceSelectorContext);
+	if (!context) {
+		throw new Error(
+			"VoiceSelector components must be used within VoiceSelector",
+		);
+	}
+	return context;
+};
+
+export type VoiceSelectorProps = ComponentProps<typeof Dialog> & {
+	value?: string;
+	defaultValue?: string;
+	onValueChange?: (value: string | undefined) => void;
+};
+
+export const VoiceSelector = ({
+	value: valueProp,
+	defaultValue,
+	onValueChange,
+	open: openProp,
+	defaultOpen = false,
+	onOpenChange,
+	children,
+	...props
+}: VoiceSelectorProps) => {
+	const [value, setValue] = useControllableState({
+		defaultProp: defaultValue,
+		onChange: onValueChange,
+		prop: valueProp,
+	});
+
+	const [open, setOpen] = useControllableState({
+		defaultProp: defaultOpen,
+		prop: openProp,
+	});
+
+	const handleOpenChange = useCallback<
+		NonNullable<ComponentProps<typeof Dialog>["onOpenChange"]>
+	>(
+		(nextOpen, eventDetails) => {
+			setOpen(nextOpen);
+			onOpenChange?.(nextOpen, eventDetails);
+		},
+		[onOpenChange, setOpen],
+	);
+
+	const voiceSelectorContext = useMemo(
+		() => ({ open, setOpen, setValue, value }),
+		[value, setValue, open, setOpen],
+	);
+
+	return (
+		<VoiceSelectorContext.Provider value={voiceSelectorContext}>
+			<Dialog onOpenChange={handleOpenChange} open={open} {...props}>
+				{children}
+			</Dialog>
+		</VoiceSelectorContext.Provider>
+	);
+};
+
+export type VoiceSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+
+export const VoiceSelectorTrigger = (props: VoiceSelectorTriggerProps) => (
+	<DialogTrigger {...props} />
+);
+
+export type VoiceSelectorContentProps = ComponentProps<typeof DialogContent> & {
+	title?: ReactNode;
+};
+
+export const VoiceSelectorContent = ({
+	className,
+	children,
+	title = "Voice Selector",
+	...props
+}: VoiceSelectorContentProps) => (
+	<DialogContent
+		aria-describedby={undefined}
+		className={cn("p-0", className)}
+		{...props}
+	>
+		<DialogTitle className="sr-only">{title}</DialogTitle>
+		<Command className="**:data-[slot=command-input-wrapper]:h-auto">
+			{children}
+		</Command>
+	</DialogContent>
+);
+
+export type VoiceSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+
+export const VoiceSelectorDialog = (props: VoiceSelectorDialogProps) => (
+	<CommandDialog {...props} />
+);
+
+export type VoiceSelectorInputProps = ComponentProps<typeof CommandInput>;
+
+export const VoiceSelectorInput = ({
+	className,
+	...props
+}: VoiceSelectorInputProps) => (
+	<CommandInput className={cn("h-auto py-3.5", className)} {...props} />
+);
+
+export type VoiceSelectorListProps = ComponentProps<typeof CommandList>;
+
+export const VoiceSelectorList = (props: VoiceSelectorListProps) => (
+	<CommandList {...props} />
+);
+
+export type VoiceSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+
+export const VoiceSelectorEmpty = (props: VoiceSelectorEmptyProps) => (
+	<CommandEmpty {...props} />
+);
+
+export type VoiceSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+
+export const VoiceSelectorGroup = (props: VoiceSelectorGroupProps) => (
+	<CommandGroup {...props} />
+);
+
+export type VoiceSelectorItemProps = ComponentProps<typeof CommandItem>;
+
+export const VoiceSelectorItem = ({
+	className,
+	...props
+}: VoiceSelectorItemProps) => (
+	<CommandItem className={cn("px-4 py-2", className)} {...props} />
+);
+
+export type VoiceSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+
+export const VoiceSelectorShortcut = (props: VoiceSelectorShortcutProps) => (
+	<CommandShortcut {...props} />
+);
+
+export type VoiceSelectorSeparatorProps = ComponentProps<
+	typeof CommandSeparator
+>;
+
+export const VoiceSelectorSeparator = (props: VoiceSelectorSeparatorProps) => (
+	<CommandSeparator {...props} />
+);
+
+export type VoiceSelectorGenderProps = ComponentProps<"span"> & {
+	value?:
+		| "male"
+		| "female"
+		| "transgender"
+		| "androgyne"
+		| "non-binary"
+		| "intersex";
+};
+
+export const VoiceSelectorGender = ({
+	className,
+	value,
+	children,
+	...props
+}: VoiceSelectorGenderProps) => {
+	let icon: ReactNode | null = null;
+
+	switch (value) {
+		case "male": {
+			icon = <MarsIcon className="size-4" />;
+			break;
+		}
+		case "female": {
+			icon = <VenusIcon className="size-4" />;
+			break;
+		}
+		case "transgender": {
+			icon = <TransgenderIcon className="size-4" />;
+			break;
+		}
+		case "androgyne": {
+			icon = <MarsStrokeIcon className="size-4" />;
+			break;
+		}
+		case "non-binary": {
+			icon = <NonBinaryIcon className="size-4" />;
+			break;
+		}
+		case "intersex": {
+			icon = <VenusAndMarsIcon className="size-4" />;
+			break;
+		}
+		default: {
+			icon = <CircleSmallIcon className="size-4" />;
+		}
+	}
+
+	return (
+		<span className={cn("text-muted-foreground text-xs", className)} {...props}>
+			{children ?? icon}
+		</span>
+	);
+};
+
+export type VoiceSelectorAccentProps = ComponentProps<"span"> & {
+	value?:
+		| "american"
+		| "british"
+		| "australian"
+		| "canadian"
+		| "irish"
+		| "scottish"
+		| "indian"
+		| "south-african"
+		| "new-zealand"
+		| "spanish"
+		| "french"
+		| "german"
+		| "italian"
+		| "portuguese"
+		| "brazilian"
+		| "mexican"
+		| "argentinian"
+		| "japanese"
+		| "chinese"
+		| "korean"
+		| "russian"
+		| "arabic"
+		| "dutch"
+		| "swedish"
+		| "norwegian"
+		| "danish"
+		| "finnish"
+		| "polish"
+		| "turkish"
+		| "greek"
+		| string;
+};
+
+export const VoiceSelectorAccent = ({
+	className,
+	value,
+	children,
+	...props
+}: VoiceSelectorAccentProps) => {
+	let emoji: string | null = null;
+
+	switch (value) {
+		case "american": {
+			emoji = "🇺🇸";
+			break;
+		}
+		case "british": {
+			emoji = "🇬🇧";
+			break;
+		}
+		case "australian": {
+			emoji = "🇦🇺";
+			break;
+		}
+		case "canadian": {
+			emoji = "🇨🇦";
+			break;
+		}
+		case "irish": {
+			emoji = "🇮🇪";
+			break;
+		}
+		case "scottish": {
+			emoji = "🏴󠁧󠁢󠁳󠁣󠁴󠁿";
+			break;
+		}
+		case "indian": {
+			emoji = "🇮🇳";
+			break;
+		}
+		case "south-african": {
+			emoji = "🇿🇦";
+			break;
+		}
+		case "new-zealand": {
+			emoji = "🇳🇿";
+			break;
+		}
+		case "spanish": {
+			emoji = "🇪🇸";
+			break;
+		}
+		case "french": {
+			emoji = "🇫🇷";
+			break;
+		}
+		case "german": {
+			emoji = "🇩🇪";
+			break;
+		}
+		case "italian": {
+			emoji = "🇮🇹";
+			break;
+		}
+		case "portuguese": {
+			emoji = "🇵🇹";
+			break;
+		}
+		case "brazilian": {
+			emoji = "🇧🇷";
+			break;
+		}
+		case "mexican": {
+			emoji = "🇲🇽";
+			break;
+		}
+		case "argentinian": {
+			emoji = "🇦🇷";
+			break;
+		}
+		case "japanese": {
+			emoji = "🇯🇵";
+			break;
+		}
+		case "chinese": {
+			emoji = "🇨🇳";
+			break;
+		}
+		case "korean": {
+			emoji = "🇰🇷";
+			break;
+		}
+		case "russian": {
+			emoji = "🇷🇺";
+			break;
+		}
+		case "arabic": {
+			emoji = "🇸🇦";
+			break;
+		}
+		case "dutch": {
+			emoji = "🇳🇱";
+			break;
+		}
+		case "swedish": {
+			emoji = "🇸🇪";
+			break;
+		}
+		case "norwegian": {
+			emoji = "🇳🇴";
+			break;
+		}
+		case "danish": {
+			emoji = "🇩🇰";
+			break;
+		}
+		case "finnish": {
+			emoji = "🇫🇮";
+			break;
+		}
+		case "polish": {
+			emoji = "🇵🇱";
+			break;
+		}
+		case "turkish": {
+			emoji = "🇹🇷";
+			break;
+		}
+		case "greek": {
+			emoji = "🇬🇷";
+			break;
+		}
+		default: {
+			emoji = null;
+		}
+	}
+
+	return (
+		<span className={cn("text-muted-foreground text-xs", className)} {...props}>
+			{children ?? emoji}
+		</span>
+	);
+};
+
+export type VoiceSelectorAgeProps = ComponentProps<"span">;
+
+export const VoiceSelectorAge = ({
+	className,
+	...props
+}: VoiceSelectorAgeProps) => (
+	<span
+		className={cn("text-muted-foreground text-xs tabular-nums", className)}
+		{...props}
+	/>
+);
+
+export type VoiceSelectorNameProps = ComponentProps<"span">;
+
+export const VoiceSelectorName = ({
+	className,
+	...props
+}: VoiceSelectorNameProps) => (
+	<span
+		className={cn("flex-1 truncate text-left font-medium", className)}
+		{...props}
+	/>
+);
+
+export type VoiceSelectorDescriptionProps = ComponentProps<"span">;
+
+export const VoiceSelectorDescription = ({
+	className,
+	...props
+}: VoiceSelectorDescriptionProps) => (
+	<span className={cn("text-muted-foreground text-xs", className)} {...props} />
+);
+
+export type VoiceSelectorAttributesProps = ComponentProps<"div">;
+
+export const VoiceSelectorAttributes = ({
+	className,
+	children,
+	...props
+}: VoiceSelectorAttributesProps) => (
+	<div className={cn("flex items-center text-xs", className)} {...props}>
+		{children}
+	</div>
+);
+
+export type VoiceSelectorBulletProps = ComponentProps<"span">;
+
+export const VoiceSelectorBullet = ({
+	className,
+	...props
+}: VoiceSelectorBulletProps) => (
+	<span
+		aria-hidden="true"
+		className={cn("select-none text-border", className)}
+		{...props}
+	>
+		&bull;
+	</span>
+);
+
+export type VoiceSelectorPreviewProps = Omit<
+	ComponentProps<"button">,
+	"children"
+> & {
+	playing?: boolean;
+	loading?: boolean;
+	onPlay?: () => void;
+};
+
+export const VoiceSelectorPreview = ({
+	className,
+	playing,
+	loading,
+	onPlay,
+	onClick,
+	...props
+}: VoiceSelectorPreviewProps) => {
+	const handleClick = useCallback(
+		(event: React.MouseEvent<HTMLButtonElement>) => {
+			event.stopPropagation();
+			onClick?.(event);
+			onPlay?.();
+		},
+		[onClick, onPlay],
+	);
+
+	let icon = <PlayIcon className="size-3" />;
+
+	if (loading) {
+		icon = <Spinner className="size-3" />;
+	} else if (playing) {
+		icon = <PauseIcon className="size-3" />;
+	}
+
+	return (
+		<Button
+			aria-label={playing ? "Pause preview" : "Play preview"}
+			className={cn("size-6", className)}
+			disabled={loading}
+			onClick={handleClick}
+			size="icon-sm"
+			type="button"
+			variant="outline"
+			{...props}
+		>
+			{icon}
+		</Button>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ai-elements/web-preview.tsx b/apps/examples/vscode/src/webview/src/components/ai-elements/web-preview.tsx
new file mode 100644
index 0000000..fce2d60
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ai-elements/web-preview.tsx
@@ -0,0 +1,285 @@
+"use client";
+
+import { ChevronDownIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useMemo,
+	useState,
+} from "react";
+import { Button } from "@/components/ui/button";
+import {
+	Collapsible,
+	CollapsibleContent,
+	CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { Input } from "@/components/ui/input";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+export interface WebPreviewContextValue {
+	url: string;
+	setUrl: (url: string) => void;
+	consoleOpen: boolean;
+	setConsoleOpen: (open: boolean) => void;
+}
+
+const WebPreviewContext = createContext<WebPreviewContextValue | null>(null);
+
+const useWebPreview = () => {
+	const context = useContext(WebPreviewContext);
+	if (!context) {
+		throw new Error("WebPreview components must be used within a WebPreview");
+	}
+	return context;
+};
+
+export type WebPreviewProps = ComponentProps<"div"> & {
+	defaultUrl?: string;
+	onUrlChange?: (url: string) => void;
+};
+
+export const WebPreview = ({
+	className,
+	children,
+	defaultUrl = "",
+	onUrlChange,
+	...props
+}: WebPreviewProps) => {
+	const [url, setUrl] = useState(defaultUrl);
+	const [consoleOpen, setConsoleOpen] = useState(false);
+
+	const handleUrlChange = useCallback(
+		(newUrl: string) => {
+			setUrl(newUrl);
+			onUrlChange?.(newUrl);
+		},
+		[onUrlChange],
+	);
+
+	const contextValue = useMemo<WebPreviewContextValue>(
+		() => ({
+			consoleOpen,
+			setConsoleOpen,
+			setUrl: handleUrlChange,
+			url,
+		}),
+		[consoleOpen, handleUrlChange, url],
+	);
+
+	return (
+		<WebPreviewContext.Provider value={contextValue}>
+			<div
+				className={cn(
+					"flex size-full flex-col rounded-lg border bg-card",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+			</div>
+		</WebPreviewContext.Provider>
+	);
+};
+
+export type WebPreviewNavigationProps = ComponentProps<"div">;
+
+export const WebPreviewNavigation = ({
+	className,
+	children,
+	...props
+}: WebPreviewNavigationProps) => (
+	<div
+		className={cn("flex items-center gap-1 border-b p-2", className)}
+		{...props}
+	>
+		{children}
+	</div>
+);
+
+export type WebPreviewNavigationButtonProps = ComponentProps<typeof Button> & {
+	tooltip?: string;
+};
+
+export const WebPreviewNavigationButton = ({
+	onClick,
+	disabled,
+	tooltip,
+	children,
+	...props
+}: WebPreviewNavigationButtonProps) => (
+	<TooltipProvider>
+		<Tooltip>
+			<TooltipTrigger
+				render={
+					<Button
+						className="h-8 w-8 p-0 hover:text-foreground"
+						disabled={disabled}
+						onClick={onClick}
+						size="sm"
+						variant="ghost"
+						{...props}
+					/>
+				}
+			>
+				{children}
+			</TooltipTrigger>
+			<TooltipContent>
+				<p>{tooltip}</p>
+			</TooltipContent>
+		</Tooltip>
+	</TooltipProvider>
+);
+
+export type WebPreviewUrlProps = ComponentProps<typeof Input>;
+
+export const WebPreviewUrl = ({
+	value,
+	onChange,
+	onKeyDown,
+	...props
+}: WebPreviewUrlProps) => {
+	const { url, setUrl } = useWebPreview();
+	const [prevUrl, setPrevUrl] = useState(url);
+	const [inputValue, setInputValue] = useState(url);
+
+	// Sync input value with context URL when it changes externally (derived state pattern)
+	if (url !== prevUrl) {
+		setPrevUrl(url);
+		setInputValue(url);
+	}
+
+	const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+		setInputValue(event.target.value);
+		onChange?.(event);
+	};
+
+	const handleKeyDown = useCallback(
+		(event: React.KeyboardEvent<HTMLInputElement>) => {
+			if (event.key === "Enter") {
+				const target = event.target as HTMLInputElement;
+				setUrl(target.value);
+			}
+			onKeyDown?.(event);
+		},
+		[setUrl, onKeyDown],
+	);
+
+	return (
+		<Input
+			className="h-8 flex-1 text-sm"
+			onChange={onChange ?? handleChange}
+			onKeyDown={handleKeyDown}
+			placeholder="Enter URL..."
+			value={value ?? inputValue}
+			{...props}
+		/>
+	);
+};
+
+export type WebPreviewBodyProps = ComponentProps<"iframe"> & {
+	loading?: ReactNode;
+};
+
+export const WebPreviewBody = ({
+	className,
+	loading,
+	src,
+	...props
+}: WebPreviewBodyProps) => {
+	const { url } = useWebPreview();
+
+	return (
+		<div className="flex-1">
+			<iframe
+				className={cn("size-full", className)}
+				// oxlint-disable-next-line eslint-plugin-react(iframe-missing-sandbox)
+				sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-presentation"
+				src={(src ?? url) || undefined}
+				title="Preview"
+				{...props}
+			/>
+			{loading}
+		</div>
+	);
+};
+
+export type WebPreviewConsoleProps = ComponentProps<"div"> & {
+	logs?: {
+		level: "log" | "warn" | "error";
+		message: string;
+		timestamp: Date;
+	}[];
+};
+
+export const WebPreviewConsole = ({
+	className,
+	logs = [],
+	children,
+	...props
+}: WebPreviewConsoleProps) => {
+	const { consoleOpen, setConsoleOpen } = useWebPreview();
+
+	return (
+		<Collapsible
+			className={cn("border-t bg-muted/50 font-mono text-sm", className)}
+			onOpenChange={setConsoleOpen}
+			open={consoleOpen}
+			{...props}
+		>
+			<CollapsibleTrigger
+				render={
+					<Button
+						className="flex w-full items-center justify-between p-4 text-left font-medium hover:bg-muted/50"
+						variant="ghost"
+					/>
+				}
+			>
+				Console
+				<ChevronDownIcon
+					className={cn(
+						"h-4 w-4 transition-transform duration-200",
+						consoleOpen && "rotate-180",
+					)}
+				/>
+			</CollapsibleTrigger>
+			<CollapsibleContent
+				className={cn(
+					"px-4 pb-4",
+					"data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+				)}
+			>
+				<div className="max-h-48 space-y-1 overflow-y-auto">
+					{logs.length === 0 ? (
+						<p className="text-muted-foreground">No console output</p>
+					) : (
+						logs.map((log) => (
+							<div
+								className={cn(
+									"text-xs",
+									log.level === "error" && "text-destructive",
+									log.level === "warn" && "text-yellow-600",
+									log.level === "log" && "text-foreground",
+								)}
+								key={`${log.timestamp.getTime()}-${log.level}-${log.message}`}
+							>
+								<span className="text-muted-foreground">
+									{log.timestamp.toLocaleTimeString()}
+								</span>{" "}
+								{log.message}
+							</div>
+						))
+					)}
+					{children}
+				</div>
+			</CollapsibleContent>
+		</Collapsible>
+	);
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/accordion.tsx b/apps/examples/vscode/src/webview/src/components/ui/accordion.tsx
new file mode 100644
index 0000000..4f0489b
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/accordion.tsx
@@ -0,0 +1,77 @@
+import { Accordion as AccordionPrimitive } from "@base-ui/react/accordion";
+import { ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+function Accordion({ className, ...props }: AccordionPrimitive.Root.Props) {
+	return (
+		<AccordionPrimitive.Root
+			data-slot="accordion"
+			className={cn("flex w-full flex-col", className)}
+			{...props}
+		/>
+	);
+}
+
+function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props) {
+	return (
+		<AccordionPrimitive.Item
+			data-slot="accordion-item"
+			className={cn("not-last:border-b", className)}
+			{...props}
+		/>
+	);
+}
+
+function AccordionTrigger({
+	className,
+	children,
+	...props
+}: AccordionPrimitive.Trigger.Props) {
+	return (
+		<AccordionPrimitive.Header className="flex">
+			<AccordionPrimitive.Trigger
+				data-slot="accordion-trigger"
+				className={cn(
+					"group/accordion-trigger relative flex flex-1 items-start justify-between rounded-lg border border-transparent py-2.5 text-left text-sm font-medium transition-all outline-none hover:underline focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:after:border-ring aria-disabled:pointer-events-none aria-disabled:opacity-50 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 **:data-[slot=accordion-trigger-icon]:text-muted-foreground",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				<ChevronDownIcon
+					data-slot="accordion-trigger-icon"
+					className="pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden"
+				/>
+				<ChevronUpIcon
+					data-slot="accordion-trigger-icon"
+					className="pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline"
+				/>
+			</AccordionPrimitive.Trigger>
+		</AccordionPrimitive.Header>
+	);
+}
+
+function AccordionContent({
+	className,
+	children,
+	...props
+}: AccordionPrimitive.Panel.Props) {
+	return (
+		<AccordionPrimitive.Panel
+			data-slot="accordion-content"
+			className="overflow-hidden text-sm data-open:animate-accordion-down data-closed:animate-accordion-up"
+			{...props}
+		>
+			<div
+				className={cn(
+					"h-(--accordion-panel-height) pt-0 pb-2.5 data-ending-style:h-0 data-starting-style:h-0 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4",
+					className,
+				)}
+			>
+				{children}
+			</div>
+		</AccordionPrimitive.Panel>
+	);
+}
+
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/alert-dialog.tsx b/apps/examples/vscode/src/webview/src/components/ui/alert-dialog.tsx
new file mode 100644
index 0000000..a92c287
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/alert-dialog.tsx
@@ -0,0 +1,186 @@
+"use client";
+
+import { AlertDialog as AlertDialogPrimitive } from "@base-ui/react/alert-dialog";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function AlertDialog({ ...props }: AlertDialogPrimitive.Root.Props) {
+	return <AlertDialogPrimitive.Root data-slot="alert-dialog" {...props} />;
+}
+
+function AlertDialogTrigger({ ...props }: AlertDialogPrimitive.Trigger.Props) {
+	return (
+		<AlertDialogPrimitive.Trigger data-slot="alert-dialog-trigger" {...props} />
+	);
+}
+
+function AlertDialogPortal({ ...props }: AlertDialogPrimitive.Portal.Props) {
+	return (
+		<AlertDialogPrimitive.Portal data-slot="alert-dialog-portal" {...props} />
+	);
+}
+
+function AlertDialogOverlay({
+	className,
+	...props
+}: AlertDialogPrimitive.Backdrop.Props) {
+	return (
+		<AlertDialogPrimitive.Backdrop
+			data-slot="alert-dialog-overlay"
+			className={cn(
+				"fixed inset-0 isolate z-50 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogContent({
+	className,
+	size = "default",
+	...props
+}: AlertDialogPrimitive.Popup.Props & {
+	size?: "default" | "sm";
+}) {
+	return (
+		<AlertDialogPortal>
+			<AlertDialogOverlay />
+			<AlertDialogPrimitive.Popup
+				data-slot="alert-dialog-content"
+				data-size={size}
+				className={cn(
+					"group/alert-dialog-content fixed top-1/2 left-1/2 z-50 grid w-full -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-background p-4 ring-1 ring-foreground/10 duration-100 outline-none data-[size=default]:max-w-xs data-[size=sm]:max-w-xs data-[size=default]:sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+					className,
+				)}
+				{...props}
+			/>
+		</AlertDialogPortal>
+	);
+}
+
+function AlertDialogHeader({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-header"
+			className={cn(
+				"grid grid-rows-[auto_1fr] place-items-center gap-1.5 text-center has-data-[slot=alert-dialog-media]:grid-rows-[auto_auto_1fr] has-data-[slot=alert-dialog-media]:gap-x-4 sm:group-data-[size=default]/alert-dialog-content:place-items-start sm:group-data-[size=default]/alert-dialog-content:text-left sm:group-data-[size=default]/alert-dialog-content:has-data-[slot=alert-dialog-media]:grid-rows-[auto_1fr]",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogFooter({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-footer"
+			className={cn(
+				"-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 group-data-[size=sm]/alert-dialog-content:grid group-data-[size=sm]/alert-dialog-content:grid-cols-2 sm:flex-row sm:justify-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogMedia({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-dialog-media"
+			className={cn(
+				"mb-2 inline-flex size-10 items-center justify-center rounded-md bg-muted sm:group-data-[size=default]/alert-dialog-content:row-span-2 *:[svg:not([class*='size-'])]:size-6",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogTitle({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Title>) {
+	return (
+		<AlertDialogPrimitive.Title
+			data-slot="alert-dialog-title"
+			className={cn(
+				"text-base font-medium sm:group-data-[size=default]/alert-dialog-content:group-has-data-[slot=alert-dialog-media]/alert-dialog-content:col-start-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogDescription({
+	className,
+	...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Description>) {
+	return (
+		<AlertDialogPrimitive.Description
+			data-slot="alert-dialog-description"
+			className={cn(
+				"text-sm text-balance text-muted-foreground md:text-pretty *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogAction({
+	className,
+	...props
+}: React.ComponentProps<typeof Button>) {
+	return (
+		<Button
+			data-slot="alert-dialog-action"
+			className={cn(className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDialogCancel({
+	className,
+	variant = "outline",
+	size = "default",
+	...props
+}: AlertDialogPrimitive.Close.Props &
+	Pick<React.ComponentProps<typeof Button>, "variant" | "size">) {
+	return (
+		<AlertDialogPrimitive.Close
+			data-slot="alert-dialog-cancel"
+			className={cn(className)}
+			render={<Button variant={variant} size={size} />}
+			{...props}
+		/>
+	);
+}
+
+export {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogMedia,
+	AlertDialogOverlay,
+	AlertDialogPortal,
+	AlertDialogTitle,
+	AlertDialogTrigger,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/alert.tsx b/apps/examples/vscode/src/webview/src/components/ui/alert.tsx
new file mode 100644
index 0000000..394bf45
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/alert.tsx
@@ -0,0 +1,76 @@
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const alertVariants = cva(
+	"group/alert relative grid w-full gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*='size-'])]:size-4",
+	{
+		variants: {
+			variant: {
+				default: "bg-card text-card-foreground",
+				destructive:
+					"bg-card text-destructive *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function Alert({
+	className,
+	variant,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>) {
+	return (
+		<div
+			data-slot="alert"
+			role="alert"
+			className={cn(alertVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+}
+
+function AlertTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-title"
+			className={cn(
+				"font-medium group-has-[>svg]/alert:col-start-2 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertDescription({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-description"
+			className={cn(
+				"text-sm text-balance text-muted-foreground md:text-pretty [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AlertAction({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="alert-action"
+			className={cn("absolute top-2 right-2", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Alert, AlertTitle, AlertDescription, AlertAction };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/avatar.tsx b/apps/examples/vscode/src/webview/src/components/ui/avatar.tsx
new file mode 100644
index 0000000..85157c3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/avatar.tsx
@@ -0,0 +1,109 @@
+"use client";
+
+import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Avatar({
+	className,
+	size = "default",
+	...props
+}: AvatarPrimitive.Root.Props & {
+	size?: "default" | "sm" | "lg";
+}) {
+	return (
+		<AvatarPrimitive.Root
+			data-slot="avatar"
+			data-size={size}
+			className={cn(
+				"group/avatar relative flex size-8 shrink-0 rounded-full select-none after:absolute after:inset-0 after:rounded-full after:border after:border-border after:mix-blend-darken data-[size=lg]:size-10 data-[size=sm]:size-6 dark:after:mix-blend-lighten",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props) {
+	return (
+		<AvatarPrimitive.Image
+			data-slot="avatar-image"
+			className={cn(
+				"aspect-square size-full rounded-full object-cover",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarFallback({
+	className,
+	...props
+}: AvatarPrimitive.Fallback.Props) {
+	return (
+		<AvatarPrimitive.Fallback
+			data-slot="avatar-fallback"
+			className={cn(
+				"flex size-full items-center justify-center rounded-full bg-muted text-sm text-muted-foreground group-data-[size=sm]/avatar:text-xs",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarBadge({ className, ...props }: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="avatar-badge"
+			className={cn(
+				"absolute right-0 bottom-0 z-10 inline-flex items-center justify-center rounded-full bg-primary text-primary-foreground bg-blend-color ring-2 ring-background select-none",
+				"group-data-[size=sm]/avatar:size-2 group-data-[size=sm]/avatar:[&>svg]:hidden",
+				"group-data-[size=default]/avatar:size-2.5 group-data-[size=default]/avatar:[&>svg]:size-2",
+				"group-data-[size=lg]/avatar:size-3 group-data-[size=lg]/avatar:[&>svg]:size-2",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="avatar-group"
+			className={cn(
+				"group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-background",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function AvatarGroupCount({
+	className,
+	...props
+}: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="avatar-group-count"
+			className={cn(
+				"relative flex size-8 shrink-0 items-center justify-center rounded-full bg-muted text-sm text-muted-foreground ring-2 ring-background group-has-data-[size=lg]/avatar-group:size-10 group-has-data-[size=sm]/avatar-group:size-6 [&>svg]:size-4 group-has-data-[size=lg]/avatar-group:[&>svg]:size-5 group-has-data-[size=sm]/avatar-group:[&>svg]:size-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Avatar,
+	AvatarImage,
+	AvatarFallback,
+	AvatarGroup,
+	AvatarGroupCount,
+	AvatarBadge,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/badge.tsx b/apps/examples/vscode/src/webview/src/components/ui/badge.tsx
new file mode 100644
index 0000000..20f6061
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/badge.tsx
@@ -0,0 +1,52 @@
+import { mergeProps } from "@base-ui/react/merge-props";
+import { useRender } from "@base-ui/react/use-render";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+const badgeVariants = cva(
+	"group/badge inline-flex h-5 w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none [&>svg]:size-3!",
+	{
+		variants: {
+			variant: {
+				default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+				secondary:
+					"bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80",
+				destructive:
+					"bg-destructive/10 text-destructive focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:focus-visible:ring-destructive/40 [a]:hover:bg-destructive/20",
+				outline:
+					"border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground",
+				ghost:
+					"hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50",
+				link: "text-primary underline-offset-4 hover:underline",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function Badge({
+	className,
+	variant = "default",
+	render,
+	...props
+}: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>) {
+	return useRender({
+		defaultTagName: "span",
+		props: mergeProps<"span">(
+			{
+				className: cn(badgeVariants({ variant }), className),
+			},
+			props,
+		),
+		render,
+		state: {
+			slot: "badge",
+			variant,
+		},
+	});
+}
+
+export { Badge, badgeVariants };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/button-group.tsx b/apps/examples/vscode/src/webview/src/components/ui/button-group.tsx
new file mode 100644
index 0000000..9f81e3f
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/button-group.tsx
@@ -0,0 +1,87 @@
+import { mergeProps } from "@base-ui/react/merge-props";
+import { useRender } from "@base-ui/react/use-render";
+import { cva, type VariantProps } from "class-variance-authority";
+import { Separator } from "@/components/ui/separator";
+import { cn } from "@/lib/utils";
+
+const buttonGroupVariants = cva(
+	"flex w-fit items-stretch *:focus-visible:relative *:focus-visible:z-10 has-[>[data-slot=button-group]]:gap-2 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-lg [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1",
+	{
+		variants: {
+			orientation: {
+				horizontal:
+					"*:data-slot:rounded-r-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-r-lg! [&>[data-slot]~[data-slot]]:rounded-l-none [&>[data-slot]~[data-slot]]:border-l-0",
+				vertical:
+					"flex-col *:data-slot:rounded-b-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-b-lg! [&>[data-slot]~[data-slot]]:rounded-t-none [&>[data-slot]~[data-slot]]:border-t-0",
+			},
+		},
+		defaultVariants: {
+			orientation: "horizontal",
+		},
+	},
+);
+
+function ButtonGroup({
+	className,
+	orientation,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			role="group"
+			data-slot="button-group"
+			data-orientation={orientation}
+			className={cn(buttonGroupVariants({ orientation }), className)}
+			{...props}
+		/>
+	);
+}
+
+function ButtonGroupText({
+	className,
+	render,
+	...props
+}: useRender.ComponentProps<"div">) {
+	return useRender({
+		defaultTagName: "div",
+		props: mergeProps<"div">(
+			{
+				className: cn(
+					"flex items-center gap-2 rounded-lg border bg-muted px-2.5 text-sm font-medium [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+					className,
+				),
+			},
+			props,
+		),
+		render,
+		state: {
+			slot: "button-group-text",
+		},
+	});
+}
+
+function ButtonGroupSeparator({
+	className,
+	orientation = "vertical",
+	...props
+}: React.ComponentProps<typeof Separator>) {
+	return (
+		<Separator
+			data-slot="button-group-separator"
+			orientation={orientation}
+			className={cn(
+				"relative self-stretch bg-input data-horizontal:mx-px data-horizontal:w-auto data-vertical:my-px data-vertical:h-auto",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	ButtonGroup,
+	ButtonGroupSeparator,
+	ButtonGroupText,
+	buttonGroupVariants,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/button.tsx b/apps/examples/vscode/src/webview/src/components/ui/button.tsx
new file mode 100644
index 0000000..044ee24
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/button.tsx
@@ -0,0 +1,60 @@
+"use client";
+
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+const buttonVariants = cva(
+	"group/button cursor-pointer inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+	{
+		variants: {
+			variant: {
+				default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+				outline:
+					"border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+				secondary:
+					"bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+				ghost:
+					"hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50",
+				destructive:
+					"bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+				link: "text-primary underline-offset-4 hover:underline",
+			},
+			size: {
+				default:
+					"h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+				xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+				sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+				lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-3 has-data-[icon=inline-start]:pl-3",
+				icon: "size-8",
+				"icon-xs":
+					"size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+				"icon-sm":
+					"size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+				"icon-lg": "size-9",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+);
+
+function Button({
+	className,
+	variant = "default",
+	size = "default",
+	...props
+}: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>) {
+	return (
+		<ButtonPrimitive
+			data-slot="button"
+			className={cn(buttonVariants({ variant, size, className }))}
+			{...props}
+		/>
+	);
+}
+
+export { Button, buttonVariants };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/card.tsx b/apps/examples/vscode/src/webview/src/components/ui/card.tsx
new file mode 100644
index 0000000..022c8c6
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/card.tsx
@@ -0,0 +1,103 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Card({
+	className,
+	size = "default",
+	...props
+}: React.ComponentProps<"div"> & { size?: "default" | "sm" }) {
+	return (
+		<div
+			data-slot="card"
+			data-size={size}
+			className={cn(
+				"group/card flex flex-col gap-4 overflow-hidden rounded-xl bg-card py-4 text-sm text-card-foreground ring-1 ring-foreground/10 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-header"
+			className={cn(
+				"group/card-header @container/card-header grid auto-rows-min items-start gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto] [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-title"
+			className={cn(
+				"text-base leading-snug font-medium group-data-[size=sm]/card:text-sm",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-description"
+			className={cn("text-sm text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-action"
+			className={cn(
+				"col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-content"
+			className={cn("px-4 group-data-[size=sm]/card:px-3", className)}
+			{...props}
+		/>
+	);
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="card-footer"
+			className={cn(
+				"flex items-center rounded-b-xl border-t bg-muted/50 p-4 group-data-[size=sm]/card:p-3",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Card,
+	CardHeader,
+	CardFooter,
+	CardTitle,
+	CardAction,
+	CardDescription,
+	CardContent,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/carousel.tsx b/apps/examples/vscode/src/webview/src/components/ui/carousel.tsx
new file mode 100644
index 0000000..56a10e1
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/carousel.tsx
@@ -0,0 +1,241 @@
+import useEmblaCarousel, {
+	type UseEmblaCarouselType,
+} from "embla-carousel-react";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+
+type CarouselProps = {
+	opts?: CarouselOptions;
+	plugins?: CarouselPlugin;
+	orientation?: "horizontal" | "vertical";
+	setApi?: (api: CarouselApi) => void;
+};
+
+type CarouselContextProps = {
+	carouselRef: ReturnType<typeof useEmblaCarousel>[0];
+	api: ReturnType<typeof useEmblaCarousel>[1];
+	scrollPrev: () => void;
+	scrollNext: () => void;
+	canScrollPrev: boolean;
+	canScrollNext: boolean;
+} & CarouselProps;
+
+const CarouselContext = React.createContext<CarouselContextProps | null>(null);
+
+function useCarousel() {
+	const context = React.useContext(CarouselContext);
+
+	if (!context) {
+		throw new Error("useCarousel must be used within a <Carousel />");
+	}
+
+	return context;
+}
+
+function Carousel({
+	orientation = "horizontal",
+	opts,
+	setApi,
+	plugins,
+	className,
+	children,
+	...props
+}: React.ComponentProps<"div"> & CarouselProps) {
+	const [carouselRef, api] = useEmblaCarousel(
+		{
+			...opts,
+			axis: orientation === "horizontal" ? "x" : "y",
+		},
+		plugins,
+	);
+	const [canScrollPrev, setCanScrollPrev] = React.useState(false);
+	const [canScrollNext, setCanScrollNext] = React.useState(false);
+
+	const onSelect = React.useCallback((api: CarouselApi) => {
+		if (!api) return;
+		setCanScrollPrev(api.canScrollPrev());
+		setCanScrollNext(api.canScrollNext());
+	}, []);
+
+	const scrollPrev = React.useCallback(() => {
+		api?.scrollPrev();
+	}, [api]);
+
+	const scrollNext = React.useCallback(() => {
+		api?.scrollNext();
+	}, [api]);
+
+	const handleKeyDown = React.useCallback(
+		(event: React.KeyboardEvent<HTMLDivElement>) => {
+			if (event.key === "ArrowLeft") {
+				event.preventDefault();
+				scrollPrev();
+			} else if (event.key === "ArrowRight") {
+				event.preventDefault();
+				scrollNext();
+			}
+		},
+		[scrollPrev, scrollNext],
+	);
+
+	React.useEffect(() => {
+		if (!api || !setApi) return;
+		setApi(api);
+	}, [api, setApi]);
+
+	React.useEffect(() => {
+		if (!api) return;
+		onSelect(api);
+		api.on("reInit", onSelect);
+		api.on("select", onSelect);
+
+		return () => {
+			api?.off("select", onSelect);
+		};
+	}, [api, onSelect]);
+
+	return (
+		<CarouselContext.Provider
+			value={{
+				carouselRef,
+				api: api,
+				opts,
+				orientation:
+					orientation || (opts?.axis === "y" ? "vertical" : "horizontal"),
+				scrollPrev,
+				scrollNext,
+				canScrollPrev,
+				canScrollNext,
+			}}
+		>
+			{/* biome-ignore lint/a11y/useSemanticElements: section would break carousel structure */}
+			<div
+				onKeyDownCapture={handleKeyDown}
+				className={cn("relative", className)}
+				role="region"
+				aria-roledescription="carousel"
+				data-slot="carousel"
+				{...props}
+			>
+				{children}
+			</div>
+		</CarouselContext.Provider>
+	);
+}
+
+function CarouselContent({ className, ...props }: React.ComponentProps<"div">) {
+	const { carouselRef, orientation } = useCarousel();
+
+	return (
+		<div
+			ref={carouselRef}
+			className="overflow-hidden"
+			data-slot="carousel-content"
+		>
+			<div
+				className={cn(
+					"flex",
+					orientation === "horizontal" ? "-ml-4" : "-mt-4 flex-col",
+					className,
+				)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function CarouselItem({ className, ...props }: React.ComponentProps<"div">) {
+	const { orientation } = useCarousel();
+
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			role="group"
+			aria-roledescription="slide"
+			data-slot="carousel-item"
+			className={cn(
+				"min-w-0 shrink-0 grow-0 basis-full",
+				orientation === "horizontal" ? "pl-4" : "pt-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CarouselPrevious({
+	className,
+	variant = "outline",
+	size = "icon-sm",
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { orientation, scrollPrev, canScrollPrev } = useCarousel();
+
+	return (
+		<Button
+			data-slot="carousel-previous"
+			variant={variant}
+			size={size}
+			className={cn(
+				"absolute touch-manipulation rounded-full",
+				orientation === "horizontal"
+					? "top-1/2 -left-12 -translate-y-1/2"
+					: "-top-12 left-1/2 -translate-x-1/2 rotate-90",
+				className,
+			)}
+			disabled={!canScrollPrev}
+			onClick={scrollPrev}
+			{...props}
+		>
+			<ChevronLeftIcon />
+			<span className="sr-only">Previous slide</span>
+		</Button>
+	);
+}
+
+function CarouselNext({
+	className,
+	variant = "outline",
+	size = "icon-sm",
+	...props
+}: React.ComponentProps<typeof Button>) {
+	const { orientation, scrollNext, canScrollNext } = useCarousel();
+
+	return (
+		<Button
+			data-slot="carousel-next"
+			variant={variant}
+			size={size}
+			className={cn(
+				"absolute touch-manipulation rounded-full",
+				orientation === "horizontal"
+					? "top-1/2 -right-12 -translate-y-1/2"
+					: "-bottom-12 left-1/2 -translate-x-1/2 rotate-90",
+				className,
+			)}
+			disabled={!canScrollNext}
+			onClick={scrollNext}
+			{...props}
+		>
+			<ChevronRightIcon />
+			<span className="sr-only">Next slide</span>
+		</Button>
+	);
+}
+
+export {
+	type CarouselApi,
+	Carousel,
+	CarouselContent,
+	CarouselItem,
+	CarouselPrevious,
+	CarouselNext,
+	useCarousel,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/chart.tsx b/apps/examples/vscode/src/webview/src/components/ui/chart.tsx
new file mode 100644
index 0000000..dd4f0e9
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/chart.tsx
@@ -0,0 +1,355 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+
+import { cn } from "@/lib/utils";
+
+// Format: { THEME_NAME: CSS_SELECTOR }
+const THEMES = { light: "", dark: ".dark" } as const;
+
+export type ChartConfig = {
+	[k in string]: {
+		label?: React.ReactNode;
+		icon?: React.ComponentType;
+	} & (
+		| { color?: string; theme?: never }
+		| { color?: never; theme: Record<keyof typeof THEMES, string> }
+	);
+};
+
+type ChartContextProps = {
+	config: ChartConfig;
+};
+
+const ChartContext = React.createContext<ChartContextProps | null>(null);
+
+function useChart() {
+	const context = React.useContext(ChartContext);
+
+	if (!context) {
+		throw new Error("useChart must be used within a <ChartContainer />");
+	}
+
+	return context;
+}
+
+function ChartContainer({
+	id,
+	className,
+	children,
+	config,
+	...props
+}: React.ComponentProps<"div"> & {
+	config: ChartConfig;
+	children: React.ComponentProps<
+		typeof RechartsPrimitive.ResponsiveContainer
+	>["children"];
+}) {
+	const uniqueId = React.useId();
+	const chartId = `chart-${id || uniqueId.replace(/:/g, "")}`;
+
+	return (
+		<ChartContext.Provider value={{ config }}>
+			<div
+				data-slot="chart"
+				data-chart={chartId}
+				className={cn(
+					"flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-hidden [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border [&_.recharts-sector]:outline-hidden [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-surface]:outline-hidden",
+					className,
+				)}
+				{...props}
+			>
+				<ChartStyle id={chartId} config={config} />
+				<RechartsPrimitive.ResponsiveContainer>
+					{children}
+				</RechartsPrimitive.ResponsiveContainer>
+			</div>
+		</ChartContext.Provider>
+	);
+}
+
+const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
+	const colorConfig = Object.entries(config).filter(
+		([, config]) => config.theme || config.color,
+	);
+
+	if (!colorConfig.length) {
+		return null;
+	}
+
+	return (
+		<style
+			// biome-ignore lint/security/noDangerouslySetInnerHtml: acceptable use of dangerouslySetInnerHTML to inject dynamic styles based on theme configuration
+			dangerouslySetInnerHTML={{
+				__html: Object.entries(THEMES)
+					.map(
+						([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig
+	.map(([key, itemConfig]) => {
+		const color =
+			itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
+			itemConfig.color;
+		return color ? `  --color-${key}: ${color};` : null;
+	})
+	.join("\n")}
+}
+`,
+					)
+					.join("\n"),
+			}}
+		/>
+	);
+};
+
+const ChartTooltip = RechartsPrimitive.Tooltip;
+
+function ChartTooltipContent({
+	active,
+	payload,
+	className,
+	indicator = "dot",
+	hideLabel = false,
+	hideIndicator = false,
+	label,
+	labelFormatter,
+	labelClassName,
+	formatter,
+	color,
+	nameKey,
+	labelKey,
+}: React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
+	React.ComponentProps<"div"> & {
+		hideLabel?: boolean;
+		hideIndicator?: boolean;
+		indicator?: "line" | "dot" | "dashed";
+		nameKey?: string;
+		labelKey?: string;
+	}) {
+	const { config } = useChart();
+
+	const tooltipLabel = React.useMemo(() => {
+		if (hideLabel || !payload?.length) {
+			return null;
+		}
+
+		const [item] = payload;
+		const key = `${labelKey || item?.dataKey || item?.name || "value"}`;
+		const itemConfig = getPayloadConfigFromPayload(config, item, key);
+		const value =
+			!labelKey && typeof label === "string"
+				? config[label as keyof typeof config]?.label || label
+				: itemConfig?.label;
+
+		if (labelFormatter) {
+			return (
+				<div className={cn("font-medium", labelClassName)}>
+					{labelFormatter(value, payload)}
+				</div>
+			);
+		}
+
+		if (!value) {
+			return null;
+		}
+
+		return <div className={cn("font-medium", labelClassName)}>{value}</div>;
+	}, [
+		label,
+		labelFormatter,
+		payload,
+		hideLabel,
+		labelClassName,
+		config,
+		labelKey,
+	]);
+
+	if (!active || !payload?.length) {
+		return null;
+	}
+
+	const nestLabel = payload.length === 1 && indicator !== "dot";
+
+	return (
+		<div
+			className={cn(
+				"grid min-w-32 items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl",
+				className,
+			)}
+		>
+			{!nestLabel ? tooltipLabel : null}
+			<div className="grid gap-1.5">
+				{payload
+					.filter((item) => item.type !== "none")
+					.map((item, index) => {
+						const key = `${nameKey || item.name || item.dataKey || "value"}`;
+						const itemConfig = getPayloadConfigFromPayload(config, item, key);
+						const indicatorColor = color || item.payload.fill || item.color;
+
+						return (
+							<div
+								key={item.dataKey}
+								className={cn(
+									"flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground",
+									indicator === "dot" && "items-center",
+								)}
+							>
+								{formatter && item?.value !== undefined && item.name ? (
+									formatter(item.value, item.name, item, index, item.payload)
+								) : (
+									<>
+										{itemConfig?.icon ? (
+											<itemConfig.icon />
+										) : (
+											!hideIndicator && (
+												<div
+													className={cn(
+														"shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)",
+														{
+															"h-2.5 w-2.5": indicator === "dot",
+															"w-1": indicator === "line",
+															"w-0 border-[1.5px] border-dashed bg-transparent":
+																indicator === "dashed",
+															"my-0.5": nestLabel && indicator === "dashed",
+														},
+													)}
+													style={
+														{
+															"--color-bg": indicatorColor,
+															"--color-border": indicatorColor,
+														} as React.CSSProperties
+													}
+												/>
+											)
+										)}
+										<div
+											className={cn(
+												"flex flex-1 justify-between leading-none",
+												nestLabel ? "items-end" : "items-center",
+											)}
+										>
+											<div className="grid gap-1.5">
+												{nestLabel ? tooltipLabel : null}
+												<span className="text-muted-foreground">
+													{itemConfig?.label || item.name}
+												</span>
+											</div>
+											{item.value && (
+												<span className="font-mono font-medium text-foreground tabular-nums">
+													{item.value.toLocaleString()}
+												</span>
+											)}
+										</div>
+									</>
+								)}
+							</div>
+						);
+					})}
+			</div>
+		</div>
+	);
+}
+
+const ChartLegend = RechartsPrimitive.Legend;
+
+function ChartLegendContent({
+	className,
+	hideIcon = false,
+	payload,
+	verticalAlign = "bottom",
+	nameKey,
+}: React.ComponentProps<"div"> &
+	Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+		hideIcon?: boolean;
+		nameKey?: string;
+	}) {
+	const { config } = useChart();
+
+	if (!payload?.length) {
+		return null;
+	}
+
+	return (
+		<div
+			className={cn(
+				"flex items-center justify-center gap-4",
+				verticalAlign === "top" ? "pb-3" : "pt-3",
+				className,
+			)}
+		>
+			{payload
+				.filter((item) => item.type !== "none")
+				.map((item) => {
+					const key = `${nameKey || item.dataKey || "value"}`;
+					const itemConfig = getPayloadConfigFromPayload(config, item, key);
+
+					return (
+						<div
+							key={item.value}
+							className={cn(
+								"flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground",
+							)}
+						>
+							{itemConfig?.icon && !hideIcon ? (
+								<itemConfig.icon />
+							) : (
+								<div
+									className="h-2 w-2 shrink-0 rounded-[2px]"
+									style={{
+										backgroundColor: item.color,
+									}}
+								/>
+							)}
+							{itemConfig?.label}
+						</div>
+					);
+				})}
+		</div>
+	);
+}
+
+function getPayloadConfigFromPayload(
+	config: ChartConfig,
+	payload: unknown,
+	key: string,
+) {
+	if (typeof payload !== "object" || payload === null) {
+		return undefined;
+	}
+
+	const payloadPayload =
+		"payload" in payload &&
+		typeof payload.payload === "object" &&
+		payload.payload !== null
+			? payload.payload
+			: undefined;
+
+	let configLabelKey: string = key;
+
+	if (
+		key in payload &&
+		typeof payload[key as keyof typeof payload] === "string"
+	) {
+		configLabelKey = payload[key as keyof typeof payload] as string;
+	} else if (
+		payloadPayload &&
+		key in payloadPayload &&
+		typeof payloadPayload[key as keyof typeof payloadPayload] === "string"
+	) {
+		configLabelKey = payloadPayload[
+			key as keyof typeof payloadPayload
+		] as string;
+	}
+
+	return configLabelKey in config
+		? config[configLabelKey]
+		: config[key as keyof typeof config];
+}
+
+export {
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+	ChartLegend,
+	ChartLegendContent,
+	ChartStyle,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/checkbox.tsx b/apps/examples/vscode/src/webview/src/components/ui/checkbox.tsx
new file mode 100644
index 0000000..e58ed8d
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/checkbox.tsx
@@ -0,0 +1,27 @@
+"use client";
+
+import { Checkbox as CheckboxPrimitive } from "@base-ui/react/checkbox";
+import { CheckIcon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+function Checkbox({ className, ...props }: CheckboxPrimitive.Root.Props) {
+	return (
+		<CheckboxPrimitive.Root
+			data-slot="checkbox"
+			className={cn(
+				"peer relative flex size-4 shrink-0 items-center justify-center rounded-lg border border-input transition-colors outline-none group-has-disabled/field:opacity-50 after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground dark:data-checked:bg-primary",
+				className,
+			)}
+			{...props}
+		>
+			<CheckboxPrimitive.Indicator
+				data-slot="checkbox-indicator"
+				className="grid place-content-center text-current transition-none [&>svg]:size-3.5"
+			>
+				<CheckIcon />
+			</CheckboxPrimitive.Indicator>
+		</CheckboxPrimitive.Root>
+	);
+}
+
+export { Checkbox };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/collapsible.tsx b/apps/examples/vscode/src/webview/src/components/ui/collapsible.tsx
new file mode 100644
index 0000000..66478ec
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/collapsible.tsx
@@ -0,0 +1,21 @@
+"use client";
+
+import { Collapsible as CollapsiblePrimitive } from "@base-ui/react/collapsible";
+
+function Collapsible({ ...props }: CollapsiblePrimitive.Root.Props) {
+	return <CollapsiblePrimitive.Root data-slot="collapsible" {...props} />;
+}
+
+function CollapsibleTrigger({ ...props }: CollapsiblePrimitive.Trigger.Props) {
+	return (
+		<CollapsiblePrimitive.Trigger data-slot="collapsible-trigger" {...props} />
+	);
+}
+
+function CollapsibleContent({ ...props }: CollapsiblePrimitive.Panel.Props) {
+	return (
+		<CollapsiblePrimitive.Panel data-slot="collapsible-content" {...props} />
+	);
+}
+
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/combobox.tsx b/apps/examples/vscode/src/webview/src/components/ui/combobox.tsx
new file mode 100644
index 0000000..a382bda
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/combobox.tsx
@@ -0,0 +1,297 @@
+import { Combobox as ComboboxPrimitive } from "@base-ui/react";
+import { CheckIcon, ChevronDownIcon, XIcon } from "lucide-react";
+import * as React from "react";
+import { Button } from "@/components/ui/button";
+import {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupInput,
+} from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+const Combobox = ComboboxPrimitive.Root;
+
+function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props) {
+	return <ComboboxPrimitive.Value data-slot="combobox-value" {...props} />;
+}
+
+function ComboboxTrigger({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Trigger.Props) {
+	return (
+		<ComboboxPrimitive.Trigger
+			data-slot="combobox-trigger"
+			className={cn("[&_svg:not([class*='size-'])]:size-4", className)}
+			{...props}
+		>
+			{children}
+			<ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+		</ComboboxPrimitive.Trigger>
+	);
+}
+
+function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props) {
+	return (
+		<ComboboxPrimitive.Clear
+			data-slot="combobox-clear"
+			render={<InputGroupButton variant="ghost" size="icon-xs" />}
+			className={cn(className)}
+			{...props}
+		>
+			<XIcon className="pointer-events-none" />
+		</ComboboxPrimitive.Clear>
+	);
+}
+
+function ComboboxInput({
+	className,
+	children,
+	disabled = false,
+	showTrigger = true,
+	showClear = false,
+	...props
+}: ComboboxPrimitive.Input.Props & {
+	showTrigger?: boolean;
+	showClear?: boolean;
+}) {
+	return (
+		<InputGroup className={cn("w-auto", className)}>
+			<ComboboxPrimitive.Input
+				render={<InputGroupInput disabled={disabled} />}
+				{...props}
+			/>
+			<InputGroupAddon align="inline-end">
+				{showTrigger && (
+					<InputGroupButton
+						size="icon-xs"
+						variant="ghost"
+						render={<ComboboxTrigger />}
+						data-slot="input-group-button"
+						className="group-has-data-[slot=combobox-clear]/input-group:hidden data-pressed:bg-transparent"
+						disabled={disabled}
+					/>
+				)}
+				{showClear && <ComboboxClear disabled={disabled} />}
+			</InputGroupAddon>
+			{children}
+		</InputGroup>
+	);
+}
+
+function ComboboxContent({
+	className,
+	side = "bottom",
+	sideOffset = 6,
+	align = "start",
+	alignOffset = 0,
+	anchor,
+	...props
+}: ComboboxPrimitive.Popup.Props &
+	Pick<
+		ComboboxPrimitive.Positioner.Props,
+		"side" | "align" | "sideOffset" | "alignOffset" | "anchor"
+	>) {
+	return (
+		<ComboboxPrimitive.Portal>
+			<ComboboxPrimitive.Positioner
+				side={side}
+				sideOffset={sideOffset}
+				align={align}
+				alignOffset={alignOffset}
+				anchor={anchor}
+				className="isolate z-50"
+			>
+				<ComboboxPrimitive.Popup
+					data-slot="combobox-content"
+					data-chips={!!anchor}
+					className={cn(
+						"group/combobox-content relative max-h-(--available-height) w-(--anchor-width) max-w-(--available-width) min-w-[calc(var(--anchor-width)+--spacing(7))] origin-(--transform-origin) overflow-hidden rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[chips=true]:min-w-(--anchor-width) data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 *:data-[slot=input-group]:m-1 *:data-[slot=input-group]:mb-0 *:data-[slot=input-group]:h-8 *:data-[slot=input-group]:border-input/30 *:data-[slot=input-group]:bg-input/30 *:data-[slot=input-group]:shadow-none data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</ComboboxPrimitive.Positioner>
+		</ComboboxPrimitive.Portal>
+	);
+}
+
+function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props) {
+	return (
+		<ComboboxPrimitive.List
+			data-slot="combobox-list"
+			className={cn(
+				"no-scrollbar max-h-[min(calc(--spacing(72)---spacing(9)),calc(var(--available-height)---spacing(9)))] scroll-py-1 overflow-y-auto overscroll-contain p-1 data-empty:p-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxItem({
+	className,
+	children,
+	...props
+}: ComboboxPrimitive.Item.Props) {
+	return (
+		<ComboboxPrimitive.Item
+			data-slot="combobox-item"
+			className={cn(
+				"relative flex w-full cursor-default items-center gap-2 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none data-highlighted:bg-accent data-highlighted:text-accent-foreground not-data-[variant=destructive]:data-highlighted:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ComboboxPrimitive.ItemIndicator
+				render={
+					<span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
+				}
+			>
+				<CheckIcon className="pointer-events-none" />
+			</ComboboxPrimitive.ItemIndicator>
+		</ComboboxPrimitive.Item>
+	);
+}
+
+function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props) {
+	return (
+		<ComboboxPrimitive.Group
+			data-slot="combobox-group"
+			className={cn(className)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxLabel({
+	className,
+	...props
+}: ComboboxPrimitive.GroupLabel.Props) {
+	return (
+		<ComboboxPrimitive.GroupLabel
+			data-slot="combobox-label"
+			className={cn("px-2 py-1.5 text-xs text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props) {
+	return (
+		<ComboboxPrimitive.Collection data-slot="combobox-collection" {...props} />
+	);
+}
+
+function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props) {
+	return (
+		<ComboboxPrimitive.Empty
+			data-slot="combobox-empty"
+			className={cn(
+				"hidden w-full justify-center py-2 text-center text-sm text-muted-foreground group-data-empty/combobox-content:flex",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxSeparator({
+	className,
+	...props
+}: ComboboxPrimitive.Separator.Props) {
+	return (
+		<ComboboxPrimitive.Separator
+			data-slot="combobox-separator"
+			className={cn("-mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxChips({
+	className,
+	...props
+}: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> &
+	ComboboxPrimitive.Chips.Props) {
+	return (
+		<ComboboxPrimitive.Chips
+			data-slot="combobox-chips"
+			className={cn(
+				"flex min-h-8 flex-wrap items-center gap-1 rounded-lg border border-input bg-transparent bg-clip-padding px-2.5 py-1 text-sm transition-colors focus-within:border-ring focus-within:ring-3 focus-within:ring-ring/50 has-aria-invalid:border-destructive has-aria-invalid:ring-3 has-aria-invalid:ring-destructive/20 has-data-[slot=combobox-chip]:px-1 dark:bg-input/30 dark:has-aria-invalid:border-destructive/50 dark:has-aria-invalid:ring-destructive/40",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function ComboboxChip({
+	className,
+	children,
+	showRemove = true,
+	...props
+}: ComboboxPrimitive.Chip.Props & {
+	showRemove?: boolean;
+}) {
+	return (
+		<ComboboxPrimitive.Chip
+			data-slot="combobox-chip"
+			className={cn(
+				"flex h-[calc(--spacing(5.25))] w-fit items-center justify-center gap-1 rounded-sm bg-muted px-1.5 text-xs font-medium whitespace-nowrap text-foreground has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50 has-data-[slot=combobox-chip-remove]:pr-0",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			{showRemove && (
+				<ComboboxPrimitive.ChipRemove
+					render={<Button variant="ghost" size="icon-xs" />}
+					className="-ml-1 opacity-50 hover:opacity-100"
+					data-slot="combobox-chip-remove"
+				>
+					<XIcon className="pointer-events-none" />
+				</ComboboxPrimitive.ChipRemove>
+			)}
+		</ComboboxPrimitive.Chip>
+	);
+}
+
+function ComboboxChipsInput({
+	className,
+	...props
+}: ComboboxPrimitive.Input.Props) {
+	return (
+		<ComboboxPrimitive.Input
+			data-slot="combobox-chip-input"
+			className={cn("min-w-16 flex-1 outline-none", className)}
+			{...props}
+		/>
+	);
+}
+
+function useComboboxAnchor() {
+	return React.useRef<HTMLDivElement | null>(null);
+}
+
+export {
+	Combobox,
+	ComboboxInput,
+	ComboboxContent,
+	ComboboxList,
+	ComboboxItem,
+	ComboboxGroup,
+	ComboboxLabel,
+	ComboboxCollection,
+	ComboboxEmpty,
+	ComboboxSeparator,
+	ComboboxChips,
+	ComboboxChip,
+	ComboboxChipsInput,
+	ComboboxTrigger,
+	ComboboxValue,
+	useComboboxAnchor,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/command.tsx b/apps/examples/vscode/src/webview/src/components/ui/command.tsx
new file mode 100644
index 0000000..65c3d22
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/command.tsx
@@ -0,0 +1,192 @@
+"use client";
+
+import { Command as CommandPrimitive } from "cmdk";
+import { CheckIcon, SearchIcon } from "lucide-react";
+import type * as React from "react";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import { InputGroup, InputGroupAddon } from "@/components/ui/input-group";
+import { cn } from "@/lib/utils";
+
+function Command({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive>) {
+	return (
+		<CommandPrimitive
+			data-slot="command"
+			className={cn(
+				"flex size-full flex-col overflow-hidden rounded-xl! bg-popover p-1 text-popover-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandDialog({
+	title = "Command Palette",
+	description = "Search for a command to run...",
+	children,
+	className,
+	showCloseButton = false,
+	...props
+}: Omit<React.ComponentProps<typeof Dialog>, "children"> & {
+	title?: string;
+	description?: string;
+	className?: string;
+	showCloseButton?: boolean;
+	children: React.ReactNode;
+}) {
+	return (
+		<Dialog {...props}>
+			<DialogHeader className="sr-only">
+				<DialogTitle>{title}</DialogTitle>
+				<DialogDescription>{description}</DialogDescription>
+			</DialogHeader>
+			<DialogContent
+				className={cn(
+					"top-1/3 translate-y-0 overflow-hidden rounded-xl! p-0",
+					className,
+				)}
+				showCloseButton={showCloseButton}
+			>
+				{children}
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+function CommandInput({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Input>) {
+	return (
+		<div data-slot="command-input-wrapper" className="p-1 pb-0">
+			<InputGroup className="h-8! rounded-lg! border-input/30 bg-input/30 shadow-none! *:data-[slot=input-group-addon]:pl-2!">
+				<CommandPrimitive.Input
+					data-slot="command-input"
+					className={cn(
+						"w-full text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50",
+						className,
+					)}
+					{...props}
+				/>
+				<InputGroupAddon>
+					<SearchIcon className="size-4 shrink-0 opacity-50" />
+				</InputGroupAddon>
+			</InputGroup>
+		</div>
+	);
+}
+
+function CommandList({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.List>) {
+	return (
+		<CommandPrimitive.List
+			data-slot="command-list"
+			className={cn(
+				"no-scrollbar max-h-72 scroll-py-1 overflow-x-hidden overflow-y-auto outline-none",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandEmpty({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Empty>) {
+	return (
+		<CommandPrimitive.Empty
+			data-slot="command-empty"
+			className={cn("py-6 text-center text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function CommandGroup({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Group>) {
+	return (
+		<CommandPrimitive.Group
+			data-slot="command-group"
+			className={cn(
+				"overflow-hidden p-1 text-foreground **:[[cmdk-group-heading]]:px-2 **:[[cmdk-group-heading]]:py-1.5 **:[[cmdk-group-heading]]:text-xs **:[[cmdk-group-heading]]:font-medium **:[[cmdk-group-heading]]:text-muted-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function CommandSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Separator>) {
+	return (
+		<CommandPrimitive.Separator
+			data-slot="command-separator"
+			className={cn("-mx-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function CommandItem({
+	className,
+	children,
+	...props
+}: React.ComponentProps<typeof CommandPrimitive.Item>) {
+	return (
+		<CommandPrimitive.Item
+			data-slot="command-item"
+			className={cn(
+				"group/command-item relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none in-data-[slot=dialog-content]:rounded-lg! data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50 data-selected:bg-muted data-selected:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-selected:*:[svg]:text-foreground",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<CheckIcon className="ml-auto opacity-0 group-has-data-[slot=command-shortcut]/command-item:hidden group-data-[checked=true]/command-item:opacity-100" />
+		</CommandPrimitive.Item>
+	);
+}
+
+function CommandShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="command-shortcut"
+			className={cn(
+				"ml-auto text-xs tracking-widest text-muted-foreground group-data-selected/command-item:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Command,
+	CommandDialog,
+	CommandInput,
+	CommandList,
+	CommandEmpty,
+	CommandGroup,
+	CommandItem,
+	CommandShortcut,
+	CommandSeparator,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/dialog.tsx b/apps/examples/vscode/src/webview/src/components/ui/dialog.tsx
new file mode 100644
index 0000000..3fd2e1c
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/dialog.tsx
@@ -0,0 +1,155 @@
+"use client";
+
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+import { XIcon } from "lucide-react";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+function Dialog({ ...props }: DialogPrimitive.Root.Props) {
+	return <DialogPrimitive.Root data-slot="dialog" {...props} />;
+}
+
+function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props) {
+	return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
+}
+
+function DialogPortal({ ...props }: DialogPrimitive.Portal.Props) {
+	return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
+}
+
+function DialogClose({ ...props }: DialogPrimitive.Close.Props) {
+	return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
+}
+
+function DialogOverlay({
+	className,
+	...props
+}: DialogPrimitive.Backdrop.Props) {
+	return (
+		<DialogPrimitive.Backdrop
+			data-slot="dialog-overlay"
+			className={cn(
+				"fixed inset-0 isolate z-50 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DialogContent({
+	className,
+	children,
+	showCloseButton = true,
+	...props
+}: DialogPrimitive.Popup.Props & {
+	showCloseButton?: boolean;
+}) {
+	return (
+		<DialogPortal>
+			<DialogOverlay />
+			<DialogPrimitive.Popup
+				data-slot="dialog-content"
+				className={cn(
+					"fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-background p-4 text-sm ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+					className,
+				)}
+				{...props}
+			>
+				{children}
+				{showCloseButton && (
+					<DialogPrimitive.Close
+						data-slot="dialog-close"
+						render={
+							<Button
+								variant="ghost"
+								className="absolute top-2 right-2"
+								size="icon-sm"
+							/>
+						}
+					>
+						<XIcon />
+						<span className="sr-only">Close</span>
+					</DialogPrimitive.Close>
+				)}
+			</DialogPrimitive.Popup>
+		</DialogPortal>
+	);
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="dialog-header"
+			className={cn("flex flex-col gap-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function DialogFooter({
+	className,
+	showCloseButton = false,
+	children,
+	...props
+}: React.ComponentProps<"div"> & {
+	showCloseButton?: boolean;
+}) {
+	return (
+		<div
+			data-slot="dialog-footer"
+			className={cn(
+				"-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 sm:flex-row sm:justify-end",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			{showCloseButton && (
+				<DialogPrimitive.Close render={<Button variant="outline" />}>
+					Close
+				</DialogPrimitive.Close>
+			)}
+		</div>
+	);
+}
+
+function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props) {
+	return (
+		<DialogPrimitive.Title
+			data-slot="dialog-title"
+			className={cn("text-base leading-none font-medium", className)}
+			{...props}
+		/>
+	);
+}
+
+function DialogDescription({
+	className,
+	...props
+}: DialogPrimitive.Description.Props) {
+	return (
+		<DialogPrimitive.Description
+			data-slot="dialog-description"
+			className={cn(
+				"text-sm text-muted-foreground *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Dialog,
+	DialogClose,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogOverlay,
+	DialogPortal,
+	DialogTitle,
+	DialogTrigger,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/dropdown-menu.tsx b/apps/examples/vscode/src/webview/src/components/ui/dropdown-menu.tsx
new file mode 100644
index 0000000..ec6f757
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/dropdown-menu.tsx
@@ -0,0 +1,271 @@
+"use client";
+
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+import { CheckIcon, ChevronRightIcon } from "lucide-react";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+function DropdownMenu({ ...props }: MenuPrimitive.Root.Props) {
+	return <MenuPrimitive.Root data-slot="dropdown-menu" {...props} />;
+}
+
+function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props) {
+	return <MenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />;
+}
+
+function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props) {
+	return <MenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props} />;
+}
+
+function DropdownMenuContent({
+	align = "start",
+	alignOffset = 0,
+	side = "bottom",
+	sideOffset = 4,
+	className,
+	...props
+}: MenuPrimitive.Popup.Props &
+	Pick<
+		MenuPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<MenuPrimitive.Portal>
+			<MenuPrimitive.Positioner
+				className="isolate z-50 outline-none"
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+			>
+				<MenuPrimitive.Popup
+					data-slot="dropdown-menu-content"
+					className={cn(
+						"z-50 max-h-(--available-height) w-(--anchor-width) min-w-32 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 outline-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:overflow-hidden data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</MenuPrimitive.Positioner>
+		</MenuPrimitive.Portal>
+	);
+}
+
+function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props) {
+	return <MenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />;
+}
+
+function DropdownMenuLabel({
+	className,
+	inset,
+	...props
+}: MenuPrimitive.GroupLabel.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.GroupLabel
+			data-slot="dropdown-menu-label"
+			data-inset={inset}
+			className={cn(
+				"px-1.5 py-1 text-xs font-medium text-muted-foreground data-inset:pl-7",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: MenuPrimitive.Item.Props & {
+	inset?: boolean;
+	variant?: "default" | "destructive";
+}) {
+	return (
+		<MenuPrimitive.Item
+			data-slot="dropdown-menu-item"
+			data-inset={inset}
+			data-variant={variant}
+			className={cn(
+				"group/dropdown-menu-item relative flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props) {
+	return <MenuPrimitive.SubmenuRoot data-slot="dropdown-menu-sub" {...props} />;
+}
+
+function DropdownMenuSubTrigger({
+	className,
+	inset,
+	children,
+	...props
+}: MenuPrimitive.SubmenuTrigger.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.SubmenuTrigger
+			data-slot="dropdown-menu-sub-trigger"
+			data-inset={inset}
+			className={cn(
+				"flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-popup-open:bg-accent data-popup-open:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<ChevronRightIcon className="ml-auto" />
+		</MenuPrimitive.SubmenuTrigger>
+	);
+}
+
+function DropdownMenuSubContent({
+	align = "start",
+	alignOffset = -3,
+	side = "right",
+	sideOffset = 0,
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuContent>) {
+	return (
+		<DropdownMenuContent
+			data-slot="dropdown-menu-sub-content"
+			className={cn(
+				"w-auto min-w-[96px] rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+				className,
+			)}
+			align={align}
+			alignOffset={alignOffset}
+			side={side}
+			sideOffset={sideOffset}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuCheckboxItem({
+	className,
+	children,
+	checked,
+	inset,
+	...props
+}: MenuPrimitive.CheckboxItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.CheckboxItem
+			data-slot="dropdown-menu-checkbox-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			checked={checked}
+			{...props}
+		>
+			<span
+				className="pointer-events-none absolute right-2 flex items-center justify-center"
+				data-slot="dropdown-menu-checkbox-item-indicator"
+			>
+				<MenuPrimitive.CheckboxItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.CheckboxItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.CheckboxItem>
+	);
+}
+
+function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props) {
+	return (
+		<MenuPrimitive.RadioGroup
+			data-slot="dropdown-menu-radio-group"
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuRadioItem({
+	className,
+	children,
+	inset,
+	...props
+}: MenuPrimitive.RadioItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.RadioItem
+			data-slot="dropdown-menu-radio-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<span
+				className="pointer-events-none absolute right-2 flex items-center justify-center"
+				data-slot="dropdown-menu-radio-item-indicator"
+			>
+				<MenuPrimitive.RadioItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.RadioItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.RadioItem>
+	);
+}
+
+function DropdownMenuSeparator({
+	className,
+	...props
+}: MenuPrimitive.Separator.Props) {
+	return (
+		<MenuPrimitive.Separator
+			data-slot="dropdown-menu-separator"
+			className={cn("-mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function DropdownMenuShortcut({
+	className,
+	...props
+}: React.ComponentProps<"span">) {
+	return (
+		<span
+			data-slot="dropdown-menu-shortcut"
+			className={cn(
+				"ml-auto text-xs tracking-widest text-muted-foreground group-focus/dropdown-menu-item:text-accent-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	DropdownMenu,
+	DropdownMenuPortal,
+	DropdownMenuTrigger,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuLabel,
+	DropdownMenuItem,
+	DropdownMenuCheckboxItem,
+	DropdownMenuRadioGroup,
+	DropdownMenuRadioItem,
+	DropdownMenuSeparator,
+	DropdownMenuShortcut,
+	DropdownMenuSub,
+	DropdownMenuSubTrigger,
+	DropdownMenuSubContent,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/hover-card.tsx b/apps/examples/vscode/src/webview/src/components/ui/hover-card.tsx
new file mode 100644
index 0000000..2f7de14
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/hover-card.tsx
@@ -0,0 +1,60 @@
+"use client";
+
+import { PreviewCard as PreviewCardPrimitive } from "@base-ui/react/preview-card";
+
+import { cn } from "@/lib/utils";
+
+type HoverCardProps = PreviewCardPrimitive.Root.Props & {
+	openDelay?: number;
+	closeDelay?: number;
+};
+
+function HoverCard({
+	openDelay: _openDelay,
+	closeDelay: _closeDelay,
+	...props
+}: HoverCardProps) {
+	return <PreviewCardPrimitive.Root data-slot="hover-card" {...props} />;
+}
+
+function HoverCardTrigger({ ...props }: PreviewCardPrimitive.Trigger.Props) {
+	return (
+		<PreviewCardPrimitive.Trigger data-slot="hover-card-trigger" {...props} />
+	);
+}
+
+function HoverCardContent({
+	className,
+	side = "bottom",
+	sideOffset = 4,
+	align = "center",
+	alignOffset = 4,
+	...props
+}: PreviewCardPrimitive.Popup.Props &
+	Pick<
+		PreviewCardPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<PreviewCardPrimitive.Portal data-slot="hover-card-portal">
+			<PreviewCardPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+				className="isolate z-50"
+			>
+				<PreviewCardPrimitive.Popup
+					data-slot="hover-card-content"
+					className={cn(
+						"z-50 w-64 origin-(--transform-origin) rounded-lg bg-popover p-2.5 text-sm text-popover-foreground shadow-md ring-1 ring-foreground/10 outline-hidden duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</PreviewCardPrimitive.Positioner>
+		</PreviewCardPrimitive.Portal>
+	);
+}
+
+export { HoverCard, HoverCardTrigger, HoverCardContent };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/input-group.tsx b/apps/examples/vscode/src/webview/src/components/ui/input-group.tsx
new file mode 100644
index 0000000..b7d1d60
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/input-group.tsx
@@ -0,0 +1,158 @@
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { cn } from "@/lib/utils";
+
+function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		<div
+			data-slot="input-group"
+			role="group"
+			className={cn(
+				"group/input-group relative flex h-8 w-full min-w-0 items-center rounded-lg border border-input transition-colors outline-none in-data-[slot=combobox-content]:focus-within:border-inherit in-data-[slot=combobox-content]:focus-within:ring-0 has-disabled:bg-input/50 has-disabled:opacity-50 has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-3 has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot][aria-invalid=true]]:border-destructive has-[[data-slot][aria-invalid=true]]:ring-3 has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>textarea]:h-auto dark:bg-input/30 dark:has-disabled:bg-input/80 dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40 has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const inputGroupAddonVariants = cva(
+	"flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium text-muted-foreground select-none group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
+	{
+		variants: {
+			align: {
+				"inline-start":
+					"order-first pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem]",
+				"inline-end":
+					"order-last pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem]",
+				"block-start":
+					"order-first w-full justify-start px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2",
+				"block-end":
+					"order-last w-full justify-start px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2",
+			},
+		},
+		defaultVariants: {
+			align: "inline-start",
+		},
+	},
+);
+
+function InputGroupAddon({
+	className,
+	align = "inline-start",
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
+	return (
+		// biome-ignore lint/a11y/useSemanticElements: fieldset would break layout styling
+		// biome-ignore lint/a11y/useKeyWithClickEvents: click handler focuses input, not interactive
+		<div
+			role="group"
+			data-slot="input-group-addon"
+			data-align={align}
+			className={cn(inputGroupAddonVariants({ align }), className)}
+			onClick={(e) => {
+				if ((e.target as HTMLElement).closest("button")) {
+					return;
+				}
+				e.currentTarget.parentElement?.querySelector("input")?.focus();
+			}}
+			{...props}
+		/>
+	);
+}
+
+const inputGroupButtonVariants = cva(
+	"flex items-center gap-2 text-sm shadow-none",
+	{
+		variants: {
+			size: {
+				xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
+				sm: "",
+				"icon-xs":
+					"size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
+				"icon-sm": "size-8 p-0 has-[>svg]:p-0",
+			},
+		},
+		defaultVariants: {
+			size: "xs",
+		},
+	},
+);
+
+function InputGroupButton({
+	className,
+	type = "button",
+	variant = "ghost",
+	size = "xs",
+	...props
+}: Omit<React.ComponentProps<typeof Button>, "size" | "type"> &
+	VariantProps<typeof inputGroupButtonVariants> & {
+		type?: "button" | "submit" | "reset";
+	}) {
+	return (
+		<Button
+			type={type}
+			data-size={size}
+			variant={variant}
+			className={cn(inputGroupButtonVariants({ size }), className)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
+	return (
+		<span
+			className={cn(
+				"flex items-center gap-2 text-sm text-muted-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupInput({
+	className,
+	...props
+}: React.ComponentProps<"input">) {
+	return (
+		<Input
+			data-slot="input-group-control"
+			className={cn(
+				"flex-1 rounded-none border-0 bg-transparent shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function InputGroupTextarea({
+	className,
+	...props
+}: React.ComponentProps<"textarea">) {
+	return (
+		<Textarea
+			data-slot="input-group-control"
+			className={cn(
+				"flex-1 resize-none rounded-none border-0 bg-transparent py-2 shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	InputGroup,
+	InputGroupAddon,
+	InputGroupButton,
+	InputGroupText,
+	InputGroupInput,
+	InputGroupTextarea,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/input.tsx b/apps/examples/vscode/src/webview/src/components/ui/input.tsx
new file mode 100644
index 0000000..bd4587d
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/input.tsx
@@ -0,0 +1,20 @@
+import { Input as InputPrimitive } from "@base-ui/react/input";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+	return (
+		<InputPrimitive
+			type={type}
+			data-slot="input"
+			className={cn(
+				"h-8 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Input };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/label.tsx b/apps/examples/vscode/src/webview/src/components/ui/label.tsx
new file mode 100644
index 0000000..6e51bd3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/label.tsx
@@ -0,0 +1,19 @@
+/** biome-ignore-all lint/a11y/noLabelWithoutControl: component root */
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Label({ className, ...props }: React.ComponentProps<"label">) {
+	return (
+		<label
+			data-slot="label"
+			className={cn(
+				"flex items-center gap-2 text-base leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Label };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/menubar.tsx b/apps/examples/vscode/src/webview/src/components/ui/menubar.tsx
new file mode 100644
index 0000000..ac264aa
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/menubar.tsx
@@ -0,0 +1,281 @@
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+import { Menubar as MenubarPrimitive } from "@base-ui/react/menubar";
+import { CheckIcon } from "lucide-react";
+import type * as React from "react";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuGroup,
+	DropdownMenuItem,
+	DropdownMenuLabel,
+	DropdownMenuPortal,
+	DropdownMenuRadioGroup,
+	DropdownMenuSeparator,
+	DropdownMenuShortcut,
+	DropdownMenuSub,
+	DropdownMenuSubContent,
+	DropdownMenuSubTrigger,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { cn } from "@/lib/utils";
+
+function Menubar({ className, ...props }: MenubarPrimitive.Props) {
+	return (
+		<MenubarPrimitive
+			data-slot="menubar"
+			className={cn(
+				"flex h-8 items-center gap-0.5 rounded-lg border p-0.75",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarMenu({ ...props }: React.ComponentProps<typeof DropdownMenu>) {
+	return <DropdownMenu data-slot="menubar-menu" {...props} />;
+}
+
+function MenubarGroup({
+	...props
+}: React.ComponentProps<typeof DropdownMenuGroup>) {
+	return <DropdownMenuGroup data-slot="menubar-group" {...props} />;
+}
+
+function MenubarPortal({
+	...props
+}: React.ComponentProps<typeof DropdownMenuPortal>) {
+	return <DropdownMenuPortal data-slot="menubar-portal" {...props} />;
+}
+
+function MenubarTrigger({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuTrigger>) {
+	return (
+		<DropdownMenuTrigger
+			data-slot="menubar-trigger"
+			className={cn(
+				"flex items-center rounded-sm px-1.5 py-0.5 text-sm font-medium outline-hidden select-none hover:bg-muted aria-expanded:bg-muted",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarContent({
+	className,
+	align = "start",
+	alignOffset = -4,
+	sideOffset = 8,
+	...props
+}: React.ComponentProps<typeof DropdownMenuContent>) {
+	return (
+		<DropdownMenuContent
+			data-slot="menubar-content"
+			align={align}
+			alignOffset={alignOffset}
+			sideOffset={sideOffset}
+			className={cn(
+				"min-w-36 rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarItem({
+	className,
+	inset,
+	variant = "default",
+	...props
+}: React.ComponentProps<typeof DropdownMenuItem>) {
+	return (
+		<DropdownMenuItem
+			data-slot="menubar-item"
+			data-inset={inset}
+			data-variant={variant}
+			className={cn(
+				"group/menubar-item gap-1.5 rounded-md px-1.5 py-1 text-sm focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:opacity-50 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive!",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarCheckboxItem({
+	className,
+	children,
+	checked,
+	inset,
+	...props
+}: MenuPrimitive.CheckboxItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.CheckboxItem
+			data-slot="menubar-checkbox-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-1.5 pl-7 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+				className,
+			)}
+			checked={checked}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-1.5 flex size-4 items-center justify-center [&_svg:not([class*='size-'])]:size-4">
+				<MenuPrimitive.CheckboxItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.CheckboxItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.CheckboxItem>
+	);
+}
+
+function MenubarRadioGroup({
+	...props
+}: React.ComponentProps<typeof DropdownMenuRadioGroup>) {
+	return <DropdownMenuRadioGroup data-slot="menubar-radio-group" {...props} />;
+}
+
+function MenubarRadioItem({
+	className,
+	children,
+	inset,
+	...props
+}: MenuPrimitive.RadioItem.Props & {
+	inset?: boolean;
+}) {
+	return (
+		<MenuPrimitive.RadioItem
+			data-slot="menubar-radio-item"
+			data-inset={inset}
+			className={cn(
+				"relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-1.5 pl-7 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<span className="pointer-events-none absolute left-1.5 flex size-4 items-center justify-center [&_svg:not([class*='size-'])]:size-4">
+				<MenuPrimitive.RadioItemIndicator>
+					<CheckIcon />
+				</MenuPrimitive.RadioItemIndicator>
+			</span>
+			{children}
+		</MenuPrimitive.RadioItem>
+	);
+}
+
+function MenubarLabel({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof DropdownMenuLabel> & {
+	inset?: boolean;
+}) {
+	return (
+		<DropdownMenuLabel
+			data-slot="menubar-label"
+			data-inset={inset}
+			className={cn(
+				"px-1.5 py-1 text-sm font-medium data-inset:pl-7",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarSeparator({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuSeparator>) {
+	return (
+		<DropdownMenuSeparator
+			data-slot="menubar-separator"
+			className={cn("-mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarShortcut({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuShortcut>) {
+	return (
+		<DropdownMenuShortcut
+			data-slot="menubar-shortcut"
+			className={cn(
+				"ml-auto text-xs tracking-widest text-muted-foreground group-focus/menubar-item:text-accent-foreground",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarSub({
+	...props
+}: React.ComponentProps<typeof DropdownMenuSub>) {
+	return <DropdownMenuSub data-slot="menubar-sub" {...props} />;
+}
+
+function MenubarSubTrigger({
+	className,
+	inset,
+	...props
+}: React.ComponentProps<typeof DropdownMenuSubTrigger> & {
+	inset?: boolean;
+}) {
+	return (
+		<DropdownMenuSubTrigger
+			data-slot="menubar-sub-trigger"
+			data-inset={inset}
+			className={cn(
+				"gap-1.5 rounded-md px-1.5 py-1 text-sm focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-open:bg-accent data-open:text-accent-foreground [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function MenubarSubContent({
+	className,
+	...props
+}: React.ComponentProps<typeof DropdownMenuSubContent>) {
+	return (
+		<DropdownMenuSubContent
+			data-slot="menubar-sub-content"
+			className={cn(
+				"min-w-32 rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Menubar,
+	MenubarPortal,
+	MenubarMenu,
+	MenubarTrigger,
+	MenubarContent,
+	MenubarGroup,
+	MenubarSeparator,
+	MenubarLabel,
+	MenubarItem,
+	MenubarShortcut,
+	MenubarCheckboxItem,
+	MenubarRadioGroup,
+	MenubarRadioItem,
+	MenubarSub,
+	MenubarSubTrigger,
+	MenubarSubContent,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/native-select.tsx b/apps/examples/vscode/src/webview/src/components/ui/native-select.tsx
new file mode 100644
index 0000000..46aeea3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/native-select.tsx
@@ -0,0 +1,61 @@
+import { ChevronDownIcon } from "lucide-react";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+type NativeSelectProps = Omit<React.ComponentProps<"select">, "size"> & {
+	size?: "sm" | "default";
+};
+
+function NativeSelect({
+	className,
+	size = "default",
+	...props
+}: NativeSelectProps) {
+	return (
+		<div
+			className={cn(
+				"group/native-select relative w-fit has-[select:disabled]:opacity-50",
+				className,
+			)}
+			data-slot="native-select-wrapper"
+			data-size={size}
+		>
+			<select
+				data-slot="native-select"
+				data-size={size}
+				className="h-full w-full min-w-0 appearance-none rounded-lg border border-input bg-transparent py-1 pr-8 pl-2.5 text-sm transition-colors outline-none select-none selection:bg-primary selection:text-primary-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] data-[size=sm]:py-0.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40"
+				{...props}
+			/>
+			<ChevronDownIcon
+				className="pointer-events-none absolute top-1/2 right-2.5 size-4 -translate-y-1/2 text-muted-foreground select-none"
+				aria-hidden="true"
+				data-slot="native-select-icon"
+			/>
+		</div>
+	);
+}
+
+function NativeSelectOption({ ...props }: React.ComponentProps<"option">) {
+	return (
+		<option
+			data-slot="native-select-option"
+			className={cn("text-sm", props.className)}
+			{...props}
+		/>
+	);
+}
+
+function NativeSelectOptGroup({
+	className,
+	...props
+}: React.ComponentProps<"optgroup">) {
+	return (
+		<optgroup
+			data-slot="native-select-optgroup"
+			className={cn("text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/popover.tsx b/apps/examples/vscode/src/webview/src/components/ui/popover.tsx
new file mode 100644
index 0000000..53ece87
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/popover.tsx
@@ -0,0 +1,88 @@
+import { Popover as PopoverPrimitive } from "@base-ui/react/popover";
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Popover({ ...props }: PopoverPrimitive.Root.Props) {
+	return <PopoverPrimitive.Root data-slot="popover" {...props} />;
+}
+
+function PopoverTrigger({ ...props }: PopoverPrimitive.Trigger.Props) {
+	return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />;
+}
+
+function PopoverContent({
+	className,
+	align = "center",
+	alignOffset = 0,
+	side = "bottom",
+	sideOffset = 4,
+	...props
+}: PopoverPrimitive.Popup.Props &
+	Pick<
+		PopoverPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<PopoverPrimitive.Portal>
+			<PopoverPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+				className="isolate z-50"
+			>
+				<PopoverPrimitive.Popup
+					data-slot="popover-content"
+					className={cn(
+						"z-50 flex w-72 origin-(--transform-origin) flex-col gap-2.5 rounded-lg bg-popover p-2.5 text-sm text-popover-foreground shadow-md ring-1 ring-foreground/10 outline-hidden duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				/>
+			</PopoverPrimitive.Positioner>
+		</PopoverPrimitive.Portal>
+	);
+}
+
+function PopoverHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			data-slot="popover-header"
+			className={cn("flex flex-col gap-0.5 text-sm", className)}
+			{...props}
+		/>
+	);
+}
+
+function PopoverTitle({ className, ...props }: PopoverPrimitive.Title.Props) {
+	return (
+		<PopoverPrimitive.Title
+			data-slot="popover-title"
+			className={cn("font-medium", className)}
+			{...props}
+		/>
+	);
+}
+
+function PopoverDescription({
+	className,
+	...props
+}: PopoverPrimitive.Description.Props) {
+	return (
+		<PopoverPrimitive.Description
+			data-slot="popover-description"
+			className={cn("text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Popover,
+	PopoverContent,
+	PopoverDescription,
+	PopoverHeader,
+	PopoverTitle,
+	PopoverTrigger,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/progress.tsx b/apps/examples/vscode/src/webview/src/components/ui/progress.tsx
new file mode 100644
index 0000000..b32896f
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/progress.tsx
@@ -0,0 +1,81 @@
+import { Progress as ProgressPrimitive } from "@base-ui/react/progress";
+
+import { cn } from "@/lib/utils";
+
+function Progress({
+	className,
+	children,
+	value,
+	...props
+}: ProgressPrimitive.Root.Props) {
+	return (
+		<ProgressPrimitive.Root
+			value={value}
+			data-slot="progress"
+			className={cn("flex flex-wrap gap-3", className)}
+			{...props}
+		>
+			{children}
+			<ProgressTrack>
+				<ProgressIndicator />
+			</ProgressTrack>
+		</ProgressPrimitive.Root>
+	);
+}
+
+function ProgressTrack({ className, ...props }: ProgressPrimitive.Track.Props) {
+	return (
+		<ProgressPrimitive.Track
+			className={cn(
+				"relative flex h-1 w-full items-center overflow-x-hidden rounded-full bg-muted",
+				className,
+			)}
+			data-slot="progress-track"
+			{...props}
+		/>
+	);
+}
+
+function ProgressIndicator({
+	className,
+	...props
+}: ProgressPrimitive.Indicator.Props) {
+	return (
+		<ProgressPrimitive.Indicator
+			data-slot="progress-indicator"
+			className={cn("h-full bg-primary transition-all", className)}
+			{...props}
+		/>
+	);
+}
+
+function ProgressLabel({ className, ...props }: ProgressPrimitive.Label.Props) {
+	return (
+		<ProgressPrimitive.Label
+			className={cn("text-sm font-medium", className)}
+			data-slot="progress-label"
+			{...props}
+		/>
+	);
+}
+
+function ProgressValue({ className, ...props }: ProgressPrimitive.Value.Props) {
+	return (
+		<ProgressPrimitive.Value
+			className={cn(
+				"ml-auto text-sm text-muted-foreground tabular-nums",
+				className,
+			)}
+			data-slot="progress-value"
+			{...props}
+		/>
+	);
+}
+
+export {
+	Progress,
+	ProgressTrack,
+	ProgressIndicator,
+	ProgressLabel,
+	ProgressValue,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/radio-group.tsx b/apps/examples/vscode/src/webview/src/components/ui/radio-group.tsx
new file mode 100644
index 0000000..8c8aaf1
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/radio-group.tsx
@@ -0,0 +1,36 @@
+import { Radio as RadioPrimitive } from "@base-ui/react/radio";
+import { RadioGroup as RadioGroupPrimitive } from "@base-ui/react/radio-group";
+
+import { cn } from "@/lib/utils";
+
+function RadioGroup({ className, ...props }: RadioGroupPrimitive.Props) {
+	return (
+		<RadioGroupPrimitive
+			data-slot="radio-group"
+			className={cn("grid w-full gap-2", className)}
+			{...props}
+		/>
+	);
+}
+
+function RadioGroupItem({ className, ...props }: RadioPrimitive.Root.Props) {
+	return (
+		<RadioPrimitive.Root
+			data-slot="radio-group-item"
+			className={cn(
+				"group/radio-group-item peer relative flex aspect-square size-4 shrink-0 rounded-full border border-input outline-none after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground dark:data-checked:bg-primary",
+				className,
+			)}
+			{...props}
+		>
+			<RadioPrimitive.Indicator
+				data-slot="radio-group-indicator"
+				className="flex size-4 items-center justify-center"
+			>
+				<span className="absolute top-1/2 left-1/2 size-2 -translate-x-1/2 -translate-y-1/2 rounded-full bg-primary-foreground" />
+			</RadioPrimitive.Indicator>
+		</RadioPrimitive.Root>
+	);
+}
+
+export { RadioGroup, RadioGroupItem };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/scroll-area.tsx b/apps/examples/vscode/src/webview/src/components/ui/scroll-area.tsx
new file mode 100644
index 0000000..d4ee997
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/scroll-area.tsx
@@ -0,0 +1,52 @@
+import { ScrollArea as ScrollAreaPrimitive } from "@base-ui/react/scroll-area";
+
+import { cn } from "@/lib/utils";
+
+function ScrollArea({
+	className,
+	children,
+	...props
+}: ScrollAreaPrimitive.Root.Props) {
+	return (
+		<ScrollAreaPrimitive.Root
+			data-slot="scroll-area"
+			className={cn("relative", className)}
+			{...props}
+		>
+			<ScrollAreaPrimitive.Viewport
+				data-slot="scroll-area-viewport"
+				className="size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1"
+			>
+				{children}
+			</ScrollAreaPrimitive.Viewport>
+			<ScrollBar />
+			<ScrollAreaPrimitive.Corner />
+		</ScrollAreaPrimitive.Root>
+	);
+}
+
+function ScrollBar({
+	className,
+	orientation = "vertical",
+	...props
+}: ScrollAreaPrimitive.Scrollbar.Props) {
+	return (
+		<ScrollAreaPrimitive.Scrollbar
+			data-slot="scroll-area-scrollbar"
+			data-orientation={orientation}
+			orientation={orientation}
+			className={cn(
+				"flex touch-none p-px transition-colors select-none data-horizontal:h-2.5 data-horizontal:flex-col data-horizontal:border-t data-horizontal:border-t-transparent data-vertical:h-full data-vertical:w-2.5 data-vertical:border-l data-vertical:border-l-transparent",
+				className,
+			)}
+			{...props}
+		>
+			<ScrollAreaPrimitive.Thumb
+				data-slot="scroll-area-thumb"
+				className="relative flex-1 rounded-full bg-border"
+			/>
+		</ScrollAreaPrimitive.Scrollbar>
+	);
+}
+
+export { ScrollArea, ScrollBar };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/select.tsx b/apps/examples/vscode/src/webview/src/components/ui/select.tsx
new file mode 100644
index 0000000..942ad5f
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/select.tsx
@@ -0,0 +1,199 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+const Select = SelectPrimitive.Root;
+
+function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props) {
+	return (
+		<SelectPrimitive.Group
+			data-slot="select-group"
+			className={cn("scroll-my-1 p-1", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectValue({ className, ...props }: SelectPrimitive.Value.Props) {
+	return (
+		<SelectPrimitive.Value
+			data-slot="select-value"
+			className={cn("flex flex-1 text-left", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectTrigger({
+	className,
+	size = "default",
+	children,
+	...props
+}: SelectPrimitive.Trigger.Props & {
+	size?: "sm" | "default";
+}) {
+	return (
+		<SelectPrimitive.Trigger
+			data-slot="select-trigger"
+			data-size={size}
+			className={cn(
+				"flex w-fit items-center justify-between gap-1.5 rounded-lg border border-input bg-transparent py-2 pr-2 pl-2.5 text-sm whitespace-nowrap transition-colors outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-placeholder:text-muted-foreground data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-1.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			{children}
+			<SelectPrimitive.Icon
+				render={
+					<ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+				}
+			/>
+		</SelectPrimitive.Trigger>
+	);
+}
+
+function SelectContent({
+	className,
+	children,
+	side = "bottom",
+	sideOffset = 4,
+	align = "center",
+	alignOffset = 0,
+	alignItemWithTrigger = true,
+	...props
+}: SelectPrimitive.Popup.Props &
+	Pick<
+		SelectPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger"
+	>) {
+	return (
+		<SelectPrimitive.Portal>
+			<SelectPrimitive.Positioner
+				side={side}
+				sideOffset={sideOffset}
+				align={align}
+				alignOffset={alignOffset}
+				alignItemWithTrigger={alignItemWithTrigger}
+				className="isolate z-50"
+			>
+				<SelectPrimitive.Popup
+					data-slot="select-content"
+					data-align-trigger={alignItemWithTrigger}
+					className={cn(
+						"relative isolate z-50 max-h-(--available-height) w-(--anchor-width) min-w-36 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[align-trigger=true]:animate-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				>
+					<SelectScrollUpButton />
+					<SelectPrimitive.List>{children}</SelectPrimitive.List>
+					<SelectScrollDownButton />
+				</SelectPrimitive.Popup>
+			</SelectPrimitive.Positioner>
+		</SelectPrimitive.Portal>
+	);
+}
+
+function SelectLabel({
+	className,
+	...props
+}: SelectPrimitive.GroupLabel.Props) {
+	return (
+		<SelectPrimitive.GroupLabel
+			data-slot="select-label"
+			className={cn("px-1.5 py-1 text-xs text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectItem({
+	className,
+	children,
+	...props
+}: SelectPrimitive.Item.Props) {
+	return (
+		<SelectPrimitive.Item
+			data-slot="select-item"
+			className={cn(
+				"relative flex w-full cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+				className,
+			)}
+			{...props}
+		>
+			<SelectPrimitive.ItemText className="flex flex-1 shrink-0 gap-2 whitespace-nowrap">
+				{children}
+			</SelectPrimitive.ItemText>
+			<SelectPrimitive.ItemIndicator
+				render={
+					<span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
+				}
+			>
+				<CheckIcon className="pointer-events-none" />
+			</SelectPrimitive.ItemIndicator>
+		</SelectPrimitive.Item>
+	);
+}
+
+function SelectSeparator({
+	className,
+	...props
+}: SelectPrimitive.Separator.Props) {
+	return (
+		<SelectPrimitive.Separator
+			data-slot="select-separator"
+			className={cn("pointer-events-none -mx-1 my-1 h-px bg-border", className)}
+			{...props}
+		/>
+	);
+}
+
+function SelectScrollUpButton({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>) {
+	return (
+		<SelectPrimitive.ScrollUpArrow
+			data-slot="select-scroll-up-button"
+			className={cn(
+				"top-0 z-10 flex w-full cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronUpIcon />
+		</SelectPrimitive.ScrollUpArrow>
+	);
+}
+
+function SelectScrollDownButton({
+	className,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>) {
+	return (
+		<SelectPrimitive.ScrollDownArrow
+			data-slot="select-scroll-down-button"
+			className={cn(
+				"bottom-0 z-10 flex w-full cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+				className,
+			)}
+			{...props}
+		>
+			<ChevronDownIcon />
+		</SelectPrimitive.ScrollDownArrow>
+	);
+}
+
+export {
+	Select,
+	SelectContent,
+	SelectGroup,
+	SelectItem,
+	SelectLabel,
+	SelectScrollDownButton,
+	SelectScrollUpButton,
+	SelectSeparator,
+	SelectTrigger,
+	SelectValue,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/separator.tsx b/apps/examples/vscode/src/webview/src/components/ui/separator.tsx
new file mode 100644
index 0000000..d59473a
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/separator.tsx
@@ -0,0 +1,25 @@
+"use client";
+
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+
+import { cn } from "@/lib/utils";
+
+function Separator({
+	className,
+	orientation = "horizontal",
+	...props
+}: SeparatorPrimitive.Props) {
+	return (
+		<SeparatorPrimitive
+			data-slot="separator"
+			orientation={orientation}
+			className={cn(
+				"shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Separator };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/sonner.tsx b/apps/examples/vscode/src/webview/src/components/ui/sonner.tsx
new file mode 100644
index 0000000..ba46244
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/sonner.tsx
@@ -0,0 +1,43 @@
+import {
+	CircleCheckIcon,
+	InfoIcon,
+	Loader2Icon,
+	OctagonXIcon,
+	TriangleAlertIcon,
+} from "lucide-react";
+import { useTheme } from "next-themes";
+import { Toaster as Sonner, type ToasterProps } from "sonner";
+
+const Toaster = ({ ...props }: ToasterProps) => {
+	const { theme = "system" } = useTheme();
+
+	return (
+		<Sonner
+			theme={theme as ToasterProps["theme"]}
+			className="toaster group"
+			icons={{
+				success: <CircleCheckIcon className="size-4" />,
+				info: <InfoIcon className="size-4" />,
+				warning: <TriangleAlertIcon className="size-4" />,
+				error: <OctagonXIcon className="size-4" />,
+				loading: <Loader2Icon className="size-4 animate-spin" />,
+			}}
+			style={
+				{
+					"--normal-bg": "var(--popover)",
+					"--normal-text": "var(--popover-foreground)",
+					"--normal-border": "var(--border)",
+					"--border-radius": "var(--radius)",
+				} as React.CSSProperties
+			}
+			toastOptions={{
+				classNames: {
+					toast: "cn-toast",
+				},
+			}}
+			{...props}
+		/>
+	);
+};
+
+export { Toaster };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/spinner.tsx b/apps/examples/vscode/src/webview/src/components/ui/spinner.tsx
new file mode 100644
index 0000000..2c29440
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/spinner.tsx
@@ -0,0 +1,15 @@
+import { Loader2Icon } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+function Spinner({ className, ...props }: React.ComponentProps<"svg">) {
+	return (
+		<Loader2Icon
+			role="status"
+			aria-label="Loading"
+			className={cn("size-4 animate-spin", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Spinner };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/switch.tsx b/apps/examples/vscode/src/webview/src/components/ui/switch.tsx
new file mode 100644
index 0000000..6aba546
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/switch.tsx
@@ -0,0 +1,32 @@
+"use client";
+
+import { Switch as SwitchPrimitive } from "@base-ui/react/switch";
+
+import { cn } from "@/lib/utils";
+
+function Switch({
+	className,
+	size = "default",
+	...props
+}: SwitchPrimitive.Root.Props & {
+	size?: "sm" | "default";
+}) {
+	return (
+		<SwitchPrimitive.Root
+			data-slot="switch"
+			data-size={size}
+			className={cn(
+				"peer group/switch relative inline-flex shrink-0 items-center rounded-full border border-transparent transition-all outline-none after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-[size=default]:h-[18.4px] data-[size=default]:w-[32px] data-[size=sm]:h-[14px] data-[size=sm]:w-[24px] dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:bg-primary data-unchecked:bg-input dark:data-unchecked:bg-input/80 data-disabled:cursor-not-allowed data-disabled:opacity-50",
+				className,
+			)}
+			{...props}
+		>
+			<SwitchPrimitive.Thumb
+				data-slot="switch-thumb"
+				className="pointer-events-none block rounded-full bg-background ring-0 transition-transform group-data-[size=default]/switch:size-4 group-data-[size=sm]/switch:size-3 group-data-[size=default]/switch:data-checked:translate-x-[calc(100%-2px)] group-data-[size=sm]/switch:data-checked:translate-x-[calc(100%-2px)] dark:data-checked:bg-primary-foreground group-data-[size=default]/switch:data-unchecked:translate-x-0 group-data-[size=sm]/switch:data-unchecked:translate-x-0 dark:data-unchecked:bg-foreground"
+			/>
+		</SwitchPrimitive.Root>
+	);
+}
+
+export { Switch };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/table.tsx b/apps/examples/vscode/src/webview/src/components/ui/table.tsx
new file mode 100644
index 0000000..c607f39
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/table.tsx
@@ -0,0 +1,114 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Table({ className, ...props }: React.ComponentProps<"table">) {
+	return (
+		<div
+			data-slot="table-container"
+			className="relative w-full overflow-x-auto"
+		>
+			<table
+				data-slot="table"
+				className={cn("w-full caption-bottom text-sm", className)}
+				{...props}
+			/>
+		</div>
+	);
+}
+
+function TableHeader({ className, ...props }: React.ComponentProps<"thead">) {
+	return (
+		<thead
+			data-slot="table-header"
+			className={cn("[&_tr]:border-b", className)}
+			{...props}
+		/>
+	);
+}
+
+function TableBody({ className, ...props }: React.ComponentProps<"tbody">) {
+	return (
+		<tbody
+			data-slot="table-body"
+			className={cn("[&_tr:last-child]:border-0", className)}
+			{...props}
+		/>
+	);
+}
+
+function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">) {
+	return (
+		<tfoot
+			data-slot="table-footer"
+			className={cn(
+				"border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableRow({ className, ...props }: React.ComponentProps<"tr">) {
+	return (
+		<tr
+			data-slot="table-row"
+			className={cn(
+				"border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableHead({ className, ...props }: React.ComponentProps<"th">) {
+	return (
+		<th
+			data-slot="table-head"
+			className={cn(
+				"h-10 px-2 text-left align-middle font-medium whitespace-nowrap text-foreground [&:has([role=checkbox])]:pr-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableCell({ className, ...props }: React.ComponentProps<"td">) {
+	return (
+		<td
+			data-slot="table-cell"
+			className={cn(
+				"p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TableCaption({
+	className,
+	...props
+}: React.ComponentProps<"caption">) {
+	return (
+		<caption
+			data-slot="table-caption"
+			className={cn("mt-4 text-sm text-muted-foreground", className)}
+			{...props}
+		/>
+	);
+}
+
+export {
+	Table,
+	TableHeader,
+	TableBody,
+	TableFooter,
+	TableHead,
+	TableRow,
+	TableCell,
+	TableCaption,
+};
diff --git a/apps/examples/vscode/src/webview/src/components/ui/tabs.tsx b/apps/examples/vscode/src/webview/src/components/ui/tabs.tsx
new file mode 100644
index 0000000..63ea6e5
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/tabs.tsx
@@ -0,0 +1,82 @@
+"use client";
+
+import { Tabs as TabsPrimitive } from "@base-ui/react/tabs";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+
+function Tabs({
+	className,
+	orientation = "horizontal",
+	...props
+}: TabsPrimitive.Root.Props) {
+	return (
+		<TabsPrimitive.Root
+			data-slot="tabs"
+			data-orientation={orientation}
+			className={cn(
+				"group/tabs flex gap-2 data-horizontal:flex-col",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+const tabsListVariants = cva(
+	"group/tabs-list inline-flex w-fit items-center justify-center rounded-lg p-[3px] text-muted-foreground group-data-horizontal/tabs:h-8 group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col data-[variant=line]:rounded-none",
+	{
+		variants: {
+			variant: {
+				default: "bg-muted",
+				line: "gap-1 bg-transparent",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+);
+
+function TabsList({
+	className,
+	variant = "default",
+	...props
+}: TabsPrimitive.List.Props & VariantProps<typeof tabsListVariants>) {
+	return (
+		<TabsPrimitive.List
+			data-slot="tabs-list"
+			data-variant={variant}
+			className={cn(tabsListVariants({ variant }), className)}
+			{...props}
+		/>
+	);
+}
+
+function TabsTrigger({ className, ...props }: TabsPrimitive.Tab.Props) {
+	return (
+		<TabsPrimitive.Tab
+			data-slot="tabs-trigger"
+			className={cn(
+				"relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+				"group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent",
+				"data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground",
+				"after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+function TabsContent({ className, ...props }: TabsPrimitive.Panel.Props) {
+	return (
+		<TabsPrimitive.Panel
+			data-slot="tabs-content"
+			className={cn("flex-1 text-sm outline-none", className)}
+			{...props}
+		/>
+	);
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/textarea.tsx b/apps/examples/vscode/src/webview/src/components/ui/textarea.tsx
new file mode 100644
index 0000000..ed00973
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/textarea.tsx
@@ -0,0 +1,18 @@
+import type * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
+	return (
+		<textarea
+			data-slot="textarea"
+			className={cn(
+				"flex field-sizing-content min-h-16 w-full rounded-lg border border-input bg-transparent px-2.5 py-2 text-base transition-colors outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+				className,
+			)}
+			{...props}
+		/>
+	);
+}
+
+export { Textarea };
diff --git a/apps/examples/vscode/src/webview/src/components/ui/tooltip.tsx b/apps/examples/vscode/src/webview/src/components/ui/tooltip.tsx
new file mode 100644
index 0000000..eb05aca
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/components/ui/tooltip.tsx
@@ -0,0 +1,64 @@
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip";
+
+import { cn } from "@/lib/utils";
+
+function TooltipProvider({
+	delay = 0,
+	...props
+}: TooltipPrimitive.Provider.Props) {
+	return (
+		<TooltipPrimitive.Provider
+			data-slot="tooltip-provider"
+			delay={delay}
+			{...props}
+		/>
+	);
+}
+
+function Tooltip({ ...props }: TooltipPrimitive.Root.Props) {
+	return <TooltipPrimitive.Root data-slot="tooltip" {...props} />;
+}
+
+function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props) {
+	return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+}
+
+function TooltipContent({
+	className,
+	side = "top",
+	sideOffset = 4,
+	align = "center",
+	alignOffset = 0,
+	children,
+	...props
+}: TooltipPrimitive.Popup.Props &
+	Pick<
+		TooltipPrimitive.Positioner.Props,
+		"align" | "alignOffset" | "side" | "sideOffset"
+	>) {
+	return (
+		<TooltipPrimitive.Portal>
+			<TooltipPrimitive.Positioner
+				align={align}
+				alignOffset={alignOffset}
+				side={side}
+				sideOffset={sideOffset}
+				className="isolate z-50"
+			>
+				<TooltipPrimitive.Popup
+					data-slot="tooltip-content"
+					className={cn(
+						"z-50 inline-flex w-fit max-w-xs origin-(--transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+						className,
+					)}
+					{...props}
+				>
+					{children}
+					<TooltipPrimitive.Arrow className="z-50 size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground data-[side=bottom]:top-1 data-[side=inline-end]:top-1/2! data-[side=inline-end]:-left-1 data-[side=inline-end]:-translate-y-1/2 data-[side=inline-start]:top-1/2! data-[side=inline-start]:-right-1 data-[side=inline-start]:-translate-y-1/2 data-[side=left]:top-1/2! data-[side=left]:-right-1 data-[side=left]:-translate-y-1/2 data-[side=right]:top-1/2! data-[side=right]:-left-1 data-[side=right]:-translate-y-1/2 data-[side=top]:-bottom-2.5" />
+				</TooltipPrimitive.Popup>
+			</TooltipPrimitive.Positioner>
+		</TooltipPrimitive.Portal>
+	);
+}
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
diff --git a/apps/examples/vscode/src/webview/src/index.css b/apps/examples/vscode/src/webview/src/index.css
new file mode 100644
index 0000000..7d28da3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/index.css
@@ -0,0 +1,156 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+@import "@fontsource-variable/geist";
+
+@custom-variant dark (&:is(.dark *));
+
+:root {
+	--background: oklch(1 0 0);
+	--foreground: oklch(0.145 0 0);
+	--card: oklch(1 0 0);
+	--card-foreground: oklch(0.145 0 0);
+	--popover: oklch(1 0 0);
+	--popover-foreground: oklch(0.145 0 0);
+	--primary: oklch(0.205 0 0);
+	--primary-foreground: oklch(0.985 0 0);
+	--secondary: oklch(0.97 0 0);
+	--secondary-foreground: oklch(0.205 0 0);
+	--muted: oklch(0.97 0 0);
+	--muted-foreground: oklch(0.556 0 0);
+	--accent: oklch(0.97 0 0);
+	--accent-foreground: oklch(0.205 0 0);
+	--destructive: oklch(0.577 0.245 27.325);
+	--destructive-foreground: oklch(0.93 0 0);
+	--border: oklch(0.922 0 0);
+	--input: oklch(0.922 0 0);
+	--ring: oklch(0.708 0 0);
+	--chart-1: oklch(0.809 0.105 251.813);
+	--chart-2: oklch(0.623 0.214 259.815);
+	--chart-3: oklch(0.546 0.245 262.881);
+	--chart-4: oklch(0.488 0.243 264.376);
+	--chart-5: oklch(0.424 0.199 265.638);
+	--radius: 0.625rem;
+	--sidebar: oklch(0.985 0 0);
+	--sidebar-foreground: oklch(0.145 0 0);
+	--sidebar-primary: oklch(0.205 0 0);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.97 0 0);
+	--sidebar-accent-foreground: oklch(0.205 0 0);
+	--sidebar-border: oklch(0.922 0 0);
+	--sidebar-ring: oklch(0.708 0 0);
+}
+
+@theme inline {
+	--font-sans: "Geist Variable", sans-serif;
+	--font-mono: "Geist Mono", "Geist Mono Fallback";
+	--color-background: var(--background);
+	--color-foreground: var(--foreground);
+	--color-card: var(--card);
+	--color-card-foreground: var(--card-foreground);
+	--color-popover: var(--popover);
+	--color-popover-foreground: var(--popover-foreground);
+	--color-primary: var(--primary);
+	--color-primary-foreground: var(--primary-foreground);
+	--color-secondary: var(--secondary);
+	--color-secondary-foreground: var(--secondary-foreground);
+	--color-muted: var(--muted);
+	--color-muted-foreground: var(--muted-foreground);
+	--color-accent: var(--accent);
+	--color-accent-foreground: var(--accent-foreground);
+	--color-destructive: var(--destructive);
+	--color-destructive-foreground: var(--destructive-foreground);
+	--color-border: var(--border);
+	--color-input: var(--input);
+	--color-ring: var(--ring);
+	--color-chart-1: var(--chart-1);
+	--color-chart-2: var(--chart-2);
+	--color-chart-3: var(--chart-3);
+	--color-chart-4: var(--chart-4);
+	--color-chart-5: var(--chart-5);
+	--radius-sm: calc(var(--radius) - 4px);
+	--radius-md: calc(var(--radius) - 2px);
+	--radius-lg: var(--radius);
+	--radius-xl: calc(var(--radius) + 4px);
+	--color-sidebar: var(--sidebar);
+	--color-sidebar-foreground: var(--sidebar-foreground);
+	--color-sidebar-primary: var(--sidebar-primary);
+	--color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+	--color-sidebar-accent: var(--sidebar-accent);
+	--color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+	--color-sidebar-border: var(--sidebar-border);
+	--color-sidebar-ring: var(--sidebar-ring);
+	--radius-2xl: calc(var(--radius) * 1.8);
+	--radius-3xl: calc(var(--radius) * 2.2);
+	--radius-4xl: calc(var(--radius) * 2.6);
+}
+
+@layer base {
+	* {
+		@apply border-border outline-ring/50;
+	}
+	body {
+		@apply bg-background text-foreground;
+	}
+	html {
+		@apply font-sans;
+	}
+}
+
+/* Custom scrollbar for dark theme */
+::-webkit-scrollbar {
+	width: 6px;
+	height: 6px;
+}
+
+::-webkit-scrollbar-track {
+	background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+	background: oklch(0.3 0.005 260);
+	border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+	background: oklch(0.4 0.005 260);
+}
+
+/* Selection color */
+::selection {
+	background: oklch(0.75 0.12 165 / 0.25);
+}
+
+.dark {
+	--background: oklch(0.145 0 0);
+	--foreground: oklch(0.985 0 0);
+	--card: oklch(0.205 0 0);
+	--card-foreground: oklch(0.985 0 0);
+	--popover: oklch(0.205 0 0);
+	--popover-foreground: oklch(0.985 0 0);
+	--primary: oklch(0.922 0 0);
+	--primary-foreground: oklch(0.205 0 0);
+	--secondary: oklch(0.269 0 0);
+	--secondary-foreground: oklch(0.985 0 0);
+	--muted: oklch(0.269 0 0);
+	--muted-foreground: oklch(0.708 0 0);
+	--accent: oklch(0.269 0 0);
+	--accent-foreground: oklch(0.985 0 0);
+	--destructive: oklch(0.704 0.191 22.216);
+	--border: oklch(1 0 0 / 10%);
+	--input: oklch(1 0 0 / 15%);
+	--ring: oklch(0.556 0 0);
+	--chart-1: oklch(0.809 0.105 251.813);
+	--chart-2: oklch(0.623 0.214 259.815);
+	--chart-3: oklch(0.546 0.245 262.881);
+	--chart-4: oklch(0.488 0.243 264.376);
+	--chart-5: oklch(0.424 0.199 265.638);
+	--sidebar: oklch(0.205 0 0);
+	--sidebar-foreground: oklch(0.985 0 0);
+	--sidebar-primary: oklch(0.488 0.243 264.376);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.269 0 0);
+	--sidebar-accent-foreground: oklch(0.985 0 0);
+	--sidebar-border: oklch(1 0 0 / 10%);
+	--sidebar-ring: oklch(0.556 0 0);
+}
diff --git a/apps/examples/vscode/src/webview/src/lib/utils.ts b/apps/examples/vscode/src/webview/src/lib/utils.ts
new file mode 100644
index 0000000..ac680b3
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/lib/utils.ts
@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}
diff --git a/apps/examples/vscode/src/webview/src/main.tsx b/apps/examples/vscode/src/webview/src/main.tsx
new file mode 100644
index 0000000..78b7aff
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/main.tsx
@@ -0,0 +1,39 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import "./index.css";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import App from "./App.tsx";
+
+/**
+ * Sync the `dark` class on <html> with the VS Code theme.
+ * VS Code sets `data-vscode-theme-kind` on <body> to one of:
+ *   "vscode-light" | "vscode-dark" | "vscode-high-contrast" | "vscode-high-contrast-light"
+ */
+function syncTheme() {
+	const kind = document.body.dataset.vscodeThemeKind;
+	const isDark = kind === "vscode-dark" || kind === "vscode-high-contrast";
+	document.documentElement.classList.toggle("dark", isDark);
+}
+
+// Apply immediately
+syncTheme();
+
+// Re-apply whenever VS Code changes the theme attribute
+const observer = new MutationObserver(syncTheme);
+observer.observe(document.body, {
+	attributes: true,
+	attributeFilter: ["data-vscode-theme-kind"],
+});
+
+const root = document.getElementById("root");
+if (!root) {
+	throw new Error("Root element not found");
+}
+
+createRoot(root).render(
+	<StrictMode>
+		<TooltipProvider>
+			<App />
+		</TooltipProvider>
+	</StrictMode>,
+);
diff --git a/apps/examples/vscode/src/webview/src/vscode.ts b/apps/examples/vscode/src/webview/src/vscode.ts
new file mode 100644
index 0000000..5fbb294
--- /dev/null
+++ b/apps/examples/vscode/src/webview/src/vscode.ts
@@ -0,0 +1,35 @@
+import type {
+	WebviewInboundMessage,
+	WebviewOutboundMessage,
+} from "../../webview-protocol";
+
+type VsCodeApi = {
+	postMessage(message: WebviewInboundMessage): void;
+	getState(): unknown;
+	setState(state: unknown): void;
+};
+
+declare global {
+	interface Window {
+		acquireVsCodeApi?: () => VsCodeApi;
+	}
+}
+
+let cachedApi: VsCodeApi | undefined;
+
+export function getVsCodeApi(): VsCodeApi | undefined {
+	if (cachedApi) {
+		return cachedApi;
+	}
+	if (typeof window.acquireVsCodeApi !== "function") {
+		return undefined;
+	}
+	cachedApi = window.acquireVsCodeApi();
+	return cachedApi;
+}
+
+export function postToHost(message: WebviewInboundMessage): void {
+	getVsCodeApi()?.postMessage(message);
+}
+
+export type { WebviewOutboundMessage };
diff --git a/apps/examples/vscode/src/webview/tsconfig.app.json b/apps/examples/vscode/src/webview/tsconfig.app.json
new file mode 100644
index 0000000..82ffa16
--- /dev/null
+++ b/apps/examples/vscode/src/webview/tsconfig.app.json
@@ -0,0 +1,31 @@
+{
+	"compilerOptions": {
+		"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+		"target": "ES2023",
+		"useDefineForClassFields": true,
+		"lib": ["ES2023", "DOM", "DOM.Iterable"],
+		"module": "ESNext",
+		"types": ["vite/client"],
+		"skipLibCheck": true,
+
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+		"jsx": "react-jsx",
+
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"erasableSyntaxOnly": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true,
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	},
+	"include": ["src"]
+}
diff --git a/apps/examples/vscode/src/webview/tsconfig.json b/apps/examples/vscode/src/webview/tsconfig.json
new file mode 100644
index 0000000..44233c0
--- /dev/null
+++ b/apps/examples/vscode/src/webview/tsconfig.json
@@ -0,0 +1,12 @@
+{
+	"files": [],
+	"references": [
+		{ "path": "./tsconfig.app.json" },
+		{ "path": "./tsconfig.node.json" }
+	],
+	"compilerOptions": {
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	}
+}
diff --git a/apps/examples/vscode/src/webview/tsconfig.node.json b/apps/examples/vscode/src/webview/tsconfig.node.json
new file mode 100644
index 0000000..e75109e
--- /dev/null
+++ b/apps/examples/vscode/src/webview/tsconfig.node.json
@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+		"target": "ES2023",
+		"lib": ["ES2023"],
+		"module": "ESNext",
+		"types": ["node"],
+		"skipLibCheck": true,
+
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"erasableSyntaxOnly": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true
+	},
+	"include": ["vite.config.ts"]
+}
diff --git a/apps/examples/vscode/src/webview/vite.config.ts b/apps/examples/vscode/src/webview/vite.config.ts
new file mode 100644
index 0000000..4c2c32c
--- /dev/null
+++ b/apps/examples/vscode/src/webview/vite.config.ts
@@ -0,0 +1,29 @@
+import path from "node:path";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react-swc";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+	plugins: [react(), tailwindcss()],
+	resolve: {
+		alias: {
+			"@": path.resolve(__dirname, "./src"),
+		},
+		dedupe: ["react", "react-dom"],
+	},
+	base: "./",
+	server: {
+		cors: true,
+		headers: {
+			"Access-Control-Allow-Origin": "*",
+		},
+		hmr: {
+			host: "localhost",
+		},
+	},
+	build: {
+		outDir: "../../dist/webview",
+		emptyOutDir: true,
+		cssMinify: "esbuild",
+	},
+});
diff --git a/apps/examples/vscode/tsconfig.json b/apps/examples/vscode/tsconfig.json
new file mode 100644
index 0000000..87bf0d6
--- /dev/null
+++ b/apps/examples/vscode/tsconfig.json
@@ -0,0 +1,27 @@
+{
+	"extends": "../../tsconfig.apps.json",
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"types": ["node", "vscode"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true
+	},
+	"include": ["src/**/*"],
+	"exclude": [
+		"node_modules",
+		"dist",
+		"src/webview/**/*",
+		"src/cline-webview/**/*"
+	]
+}
diff --git a/apps/tsconfig.apps.json b/apps/tsconfig.apps.json
new file mode 100644
index 0000000..822098e
--- /dev/null
+++ b/apps/tsconfig.apps.json
@@ -0,0 +1,31 @@
+{
+	"compilerOptions": {
+		"paths": {
+			"@cline/agents": ["../sdk/packages/agents/src/index.ts"],
+			"@cline/agents/*": [
+				"../sdk/packages/agents/src/*",
+				"../sdk/packages/agents/src/*/index.ts"
+			],
+			"@cline/cline-hub": ["./cline-hub/src/server.ts"],
+			"@cline/core": ["../sdk/packages/core/src/index.ts"],
+			"@cline/core/hub/daemon-entry": [
+				"../sdk/packages/core/src/hub/daemon/entry.ts"
+			],
+			"@cline/core/*": [
+				"../sdk/packages/core/src/*",
+				"../sdk/packages/core/src/*/index.ts"
+			],
+			"@cline/core/telemetry": [
+				"../sdk/packages/core/src/services/telemetry/index.ts"
+			],
+			"@cline/llms": ["../sdk/packages/llms/src/index.ts"],
+			"@cline/shared": ["../sdk/packages/shared/src/index.ts"],
+			"@cline/shared/storage": ["../sdk/packages/shared/src/storage/index.ts"],
+			"@cline/shared/db": ["../sdk/packages/shared/src/db/index.ts"],
+			"@cline/shared/*": [
+				"../sdk/packages/shared/src/*",
+				"../sdk/packages/shared/src/*/index.ts"
+			]
+		}
+	}
+}
diff --git a/apps/vscode/.env.example b/apps/vscode/.env.example
new file mode 100644
index 0000000..375110f
--- /dev/null
+++ b/apps/vscode/.env.example
@@ -0,0 +1,134 @@
+# Cline Development Environment Variables
+# Copy this file to .env and fill in your actual values
+# Values should be obtained from 1Password shared vault for development
+
+# ============================================================================
+# DEVELOPMENT FLAGS
+# Recomend not changing these unless you know what you're doing they are set by the launch.json normally
+# ============================================================================
+# IS_DEV=true
+# CLINE_ENVIRONMENT=local
+
+# ============================================================================
+# POSTHOG TELEMETRY (Existing)
+# ============================================================================
+# Get these values from 1Password shared vault
+TELEMETRY_SERVICE_API_KEY=your-posthog-telemetry-api-key
+ERROR_SERVICE_API_KEY=your-posthog-error-tracking-api-key
+
+# ============================================================================
+# OPENTELEMETRY (Optional - for advanced telemetry)
+# ============================================================================
+# OpenTelemetry provides flexible telemetry collection with multiple export options
+# Can run alongside PostHog or independently
+# Primary focus: Logs (events), with optional metrics support
+
+# Enable OpenTelemetry (set to 1 to enable)
+# OTEL_TELEMETRY_ENABLED=1
+
+# Exporters: "console" for local debugging, "otlp" for remote collector
+# Logs are the primary signal (recommended)
+# OTEL_LOGS_EXPORTER=console
+# OTEL_METRICS_EXPORTER=otlp
+
+# OTLP Protocol: "grpc", "http/json", or "http/protobuf"
+# OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+
+# OTLP Endpoint (without /v1/logs or /v1/metrics path - auto-appended)
+# For gRPC: use "localhost:4317" (no http:// prefix)
+# For HTTP: use "http://localhost:4318"
+# OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
+
+# OTLP Headers (for authentication, e.g., bearer tokens)
+# OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token-here
+
+# Use insecure gRPC connections (for local testing only, NOT for production)
+# OTEL_EXPORTER_OTLP_INSECURE=true
+
+# Metric export interval in milliseconds (default: 60000)
+# OTEL_METRIC_EXPORT_INTERVAL=10000
+
+# Batch configuration for logs (optional)
+# OTEL_LOG_BATCH_SIZE=512              # Max logs per batch (default: 512)
+# OTEL_LOG_BATCH_TIMEOUT=5000          # Max wait time in ms (default: 5000)
+# OTEL_LOG_MAX_QUEUE_SIZE=2048         # Max queue size (default: 2048)
+
+# Enable detailed export diagnostics (for debugging)
+# TEL_DEBUG_DIAGNOSTICS=true
+
+# Advanced: Separate endpoints for metrics and logs (optional)
+# OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=http/protobuf
+# OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://metrics.example.com:4318
+# OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=grpc
+# OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=logs.example.com:4317
+
+# Example configurations:
+#
+# Console debugging (logs only):
+#   OTEL_TELEMETRY_ENABLED=true
+#   OTEL_LOGS_EXPORTER=console
+#   TEL_DEBUG_DIAGNOSTICS=true
+#
+# OTLP with gRPC (insecure, for local testing):
+#   OTEL_TELEMETRY_ENABLED=true
+#   OTEL_LOGS_EXPORTER=otlp
+#   OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+#   OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
+#   OTEL_EXPORTER_OTLP_INSECURE=true
+#   OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token
+#
+# OTLP with HTTP/JSON (production):
+#   OTEL_TELEMETRY_ENABLED=true
+#   OTEL_LOGS_EXPORTER=otlp
+#   OTEL_EXPORTER_OTLP_PROTOCOL=http/json
+#   OTEL_EXPORTER_OTLP_ENDPOINT=https://otel.example.com
+#   OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token
+
+# ============================================================================
+# OBJECT STORE CONFIGURATION
+# ============================================================================
+# TO ENABLE S3 OR R2 STORAGE, UNCOMMENT AND FILL IN THE FOLLOWING:
+# CLINE_STORAGE_ADAPTER="s3" # Options: "s3" or "r2"
+# CLINE_STORAGE_BUCKET="cline"
+# CLINE_STORAGE_ACCESS_KEY_ID="key"
+# CLINE_STORAGE_SECRET_ACCESS_KEY="secrets"
+# 
+# [OPTIONAL FIELDS FOR R2]
+# CLINE_STORAGE_ACCOUNT_ID = "account-id" 
+# Default R2 endpoint (if not set): "https://<CLINE_STORAGE_ACCOUNT_ID>.r2.cloudflarestorage.com"
+# CLINE_STORAGE_ENDPOINT = "http://localhost:8333"
+# 
+# [OPTIONAL FIELDS FOR S3]
+# CLINE_STORAGE_REGION = "us-west-1" # AWS Bucket Region (default: "us-east-1")
+# Default S3 endpoint (if not set): "https://s3.<CLINE_STORAGE_REGION>.amazonaws.com"
+# CLINE_STORAGE_ENDPOINT = "http://localhost:8333"
+# 
+# [OPTIONAL FIELDS FOR ALL STORAGE TYPES]
+# CLINE_STORAGE_SYNC_INTERVAL_MS = 30000 # Interval for sync worker in milliseconds
+# CLINE_STORAGE_SYNC_MAX_RETRIES = 5     # Max retries for failed sync operations
+# CLINE_STORAGE_SYNC_BATCH_SIZE = 10     # Number of files to sync in each batch
+# CLINE_STORAGE_SYNC_BACKFILL_ENABLED = false # Enable backfill of existing data on startup
+
+# ============================================================================
+# OPTIONAL DEVELOPMENT SETTINGS
+# ============================================================================
+# Uncomment and modify as needed for development
+
+# Multi-root workspace debugging
+# MULTI_ROOT_TRACE=true
+
+# gRPC recorder for testing
+# GRPC_RECORDER_ENABLED=true
+# GRPC_RECORDER_FILE_NAME=test-recording
+
+# Test mode
+# E2E_TEST=true
+# IS_TEST=true
+
+# ============================================================================
+# USAGE INSTRUCTIONS
+# ============================================================================
+# 1. Copy this file: cp .env.example .env
+# 2. Get PostHog keys from 1Password shared vault
+# 3. Update the values in .env
+# 4. The .env file is gitignored for security
diff --git a/apps/vscode/.vscode-test.mjs b/apps/vscode/.vscode-test.mjs
new file mode 100644
index 0000000..e509190
--- /dev/null
+++ b/apps/vscode/.vscode-test.mjs
@@ -0,0 +1,30 @@
+import { defineConfig } from "@vscode/test-cli"
+import path from "path"
+
+const vscodeTestVersion = process.env.VSCODE_TEST_VERSION ?? "stable"
+
+export default defineConfig({
+	files: [
+		"out/src/{core,test,utils,shared,integrations,hosts,services}/**/*.test.js",
+		"src/{core,test,utils,shared,integrations,hosts,services}/**/*.test.js",
+		// The bun unit suite (src/**/__tests__/* and src/test/services/**) runs under
+		// `bun test` (run-bun-unit-tests.ts) and imports `bun:test`, which this
+		// Node-based runner cannot load. Exclude it here.
+		"!out/src/**/__tests__/**/*.test.js",
+		"!out/src/test/services/**/*.test.js",
+		"!src/**/__tests__/**/*.test.js",
+		"!src/test/services/**/*.test.js",
+	],
+	mocha: {
+		ui: "bdd",
+		timeout: 20000, // Maximum time (in ms) that a test can run before failing
+		/** Set up alias path resolution during tests
+		 * @See {@link file://./test-setup.js}
+		 */
+		require: ["./test-setup.js"],
+	},
+	workspaceFolder: "test-workspace",
+	version: vscodeTestVersion,
+	extensionDevelopmentPath: path.resolve("./"),
+	launchArgs: ["--disable-extensions"],
+})
diff --git a/apps/vscode/.vscodeignore b/apps/vscode/.vscodeignore
new file mode 100644
index 0000000..642dfa9
--- /dev/null
+++ b/apps/vscode/.vscodeignore
@@ -0,0 +1,107 @@
+# Default
+.vscode/**
+.vscode-test/**
+.worktrees/**
+# Agent tooling, never shipped in the VSIX
+.agents/**
+.claude/**
+.cline/**
+.codex/**
+CLAUDE.local.md
+out/
+dist-standalone/
+node_modules/
+# Nested workspace-member node_modules (bun links these under each package).
+# Scoped to the sub-package dirs so it doesn't shadow the top-level
+# node_modules/@vscode/codicons re-include below.
+webview-ui/node_modules/**
+testing-platform/node_modules/**
+standalone/**/node_modules/**
+src/**
+standalone/**
+# Build/dev tooling and inputs — bundled into dist/extension.js, not needed in the VSIX.
+bunfig.toml
+esbuild.mjs
+knip.json
+biome.jsonc
+test-setup.js
+.env.example
+scripts/**
+proto/**
+testing-platform/**
+tests/**
+.gitignore
+.yarnrc
+esbuild.js
+vsc-extension-quickstart.md
+tsconfig*.json
+**/.eslintrc.json
+**/*.map
+**/*.ts
+**/.vscode-test.*
+eslint-rules/**
+.github/**
+.husky/**
+.env
+
+# sdk (separate monorepo with its own build/release pipeline)
+sdk/**
+
+# Source-of-truth for the marketplace README (the .vsix only ever sees the
+# README.md that scripts/marketplace-readme.mjs swaps into place). The backup
+# only exists if a publish aborts mid-swap; neither should ship in the .vsix.
+README.marketplace.md
+.README.github.bak
+package.json.backup
+
+# Custom
+**/demo.gif
+.nvmrc
+.gitattributes
+.prettierignore
+.husky/
+.github/
+eslint-rules/
+old_docs/
+evals/
+.codespellrc
+buf.yaml
+.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)
+webview-ui/src/**
+webview-ui/public/**
+webview-ui/index.html
+webview-ui/README.md
+webview-ui/package.json
+webview-ui/package-lock.json
+webview-ui/node_modules/**
+**/.gitignore
+
+# Ignore docs
+docs/**
+old_docs/**
+
+# Fix issue where codicons don't get packaged (https://github.com/microsoft/vscode-extension-samples/issues/692)
+!node_modules/@vscode/codicons/dist/codicon.css
+!node_modules/@vscode/codicons/dist/codicon.ttf
+
+# Include default themes JSON files used in getTheme
+!src/integrations/theme/default-themes/**
+
+# Include icons
+!assets/icons/**
+
+# Ignore E2E build files
+e2e-build.mjs
+e2e.vsix
+test-results/
+coverage/**
+webview-ui/coverage/**
+webview-ui/.vite-port
+
+# Ignore Storybook files
+**/*.stories.tsx
+*storybook.log
+storybook-static
+**/StorybookDecorator.tsx
diff --git a/apps/vscode/LICENSE b/apps/vscode/LICENSE
new file mode 100644
index 0000000..05ae14a
--- /dev/null
+++ b/apps/vscode/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Cline Bot Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/apps/vscode/README.marketplace.md b/apps/vscode/README.marketplace.md
new file mode 100644
index 0000000..be026e0
--- /dev/null
+++ b/apps/vscode/README.marketplace.md
@@ -0,0 +1,142 @@
+# Cline
+<div align="center">
+<table>
+<tbody>
+<td align="center">
+<a href="https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev" target="_blank"><strong>Download on VS Marketplace</strong></a>
+</td>
+<td align="center">
+<a href="https://discord.gg/cline" target="_blank"><strong>Discord</strong></a>
+</td>
+<td align="center">
+<a href="https://www.reddit.com/r/cline/" target="_blank"><strong>r/cline</strong></a>
+</td>
+<td align="center">
+<a href="https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop" target="_blank"><strong>Feature Requests</strong></a>
+</td>
+<td align="center">
+<a href="https://docs.cline.bot/getting-started/installing-cline" target="_blank"><strong>Getting Started</strong></a>
+</td>
+</tbody>
+</table>
+</div>
+
+Meet Cline, an AI assistant that can use your **CLI** a**N**d **E**ditor.
+
+Thanks to [Claude Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
+
+1. Enter your task and add images to convert mockups into functional apps or fix bugs with screenshots.
+2. Cline starts by analyzing your file structure & source code ASTs, running regex searches, and reading relevant files to get up to speed in existing projects. By carefully managing what information is added to context, Cline can provide valuable assistance even for large, complex projects without overwhelming the context window.
+3. Once Cline has the information he needs, he can:
+    - Create and edit files + monitor linter/compiler errors along the way, letting him proactively fix issues like missing imports and syntax errors on his own.
+    - Execute commands directly in your terminal and monitor their output as he works, letting him e.g., react to dev server issues after editing a file.
+    - For web development tasks, Cline can launch the site in a headless browser, click, type, scroll, and capture screenshots + console logs, allowing him to fix runtime errors and visual bugs.
+4. When a task is completed, Cline will present the result to you with a terminal command like `open -a "Google Chrome" index.html`, which you run with a click of a button.
+
+> [!TIP]
+> Follow [this guide](https://docs.cline.bot/features/customization/opening-cline-in-sidebar) to open Cline on the right side of your editor. This lets you use Cline side-by-side with your file explorer, and see how he changes your workspace more clearly.
+
+---
+
+<img align="right" width="340" src="https://github.com/user-attachments/assets/3cf21e04-7ce9-4d22-a7b9-ba2c595e88a4">
+
+### Use any API and Model
+
+Cline supports API providers like OpenRouter, 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 OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
+
+The extension also keeps track of total tokens and API usage cost for the entire task loop and individual requests, keeping you informed of spend every step of the way.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="left" width="370" src="https://github.com/user-attachments/assets/81be79a8-1fdb-4028-9129-5fe055e01e76">
+
+### Run Commands in Terminal
+
+Thanks to the new [shell integration updates in VSCode v1.93](https://code.visualstudio.com/updates/v1_93#_terminal-shell-integration-api), Cline can execute commands directly in your terminal and receive the output. This allows him to perform a wide range of tasks, from installing packages and running build scripts to deploying applications, managing databases, and executing tests, all while adapting to your dev environment & toolchain to get the job done right.
+
+For long running processes like dev servers, use the "Proceed While Running" button to let Cline continue in the task while the command runs in the background. As Cline works he’ll be notified of any new terminal output along the way, letting him react to issues that may come up, such as compile-time errors when editing files.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="right" width="400" src="https://github.com/user-attachments/assets/c5977833-d9b8-491e-90f9-05f9cd38c588">
+
+### Create and Edit Files
+
+Cline can create and edit files directly in your editor, presenting you a diff view of the changes. You can edit or revert Cline's changes directly in the diff view editor, or provide feedback in chat until you're satisfied with the result. Cline also monitors linter/compiler errors (missing imports, syntax errors, etc.) so he can fix issues that come up along the way on his own.
+
+All changes made by Cline are recorded in your file's Timeline, providing an easy way to track and revert modifications if needed.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="left" width="370" src="https://github.com/user-attachments/assets/bc2e85ba-dfeb-4fe6-9942-7cfc4703cbe5">
+
+### Use the Browser
+
+With Claude Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
+
+Try asking Cline to "test the app", and watch as he runs a command like `npm run dev`, launches your locally running dev server in a browser, and performs a series of tests to confirm that everything works. [See a demo here.](https://x.com/sdrzn/status/1850880547825823989)
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="right" width="350" src="https://github.com/user-attachments/assets/ac0efa14-5c1f-4c26-a42d-9d7c56f5fadd">
+
+### "add a tool that..."
+
+Thanks to the [Model Context Protocol](https://github.com/modelcontextprotocol), Cline can extend his capabilities through custom tools. While you can use [community-made servers](https://github.com/modelcontextprotocol/servers), Cline can instead create and install tools tailored to your specific workflow. Just ask Cline to "add a tool" and he will handle everything, from creating a new MCP server to installing it into the extension. These custom tools then become part of Cline's toolkit, ready to use in future tasks.
+
+-   "add a tool that fetches Jira tickets": Retrieve ticket ACs and put Cline to work
+-   "add a tool that manages AWS EC2s": Check server metrics and scale instances up or down
+-   "add a tool that pulls the latest PagerDuty incidents": Fetch details and ask Cline to fix bugs
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="left" width="360" src="https://github.com/user-attachments/assets/7fdf41e6-281a-4b4b-ac19-020b838b6970">
+
+### Add Context
+
+**`@url`:** Paste in a URL for the extension to fetch and convert to markdown, useful when you want to give Cline the latest docs
+
+**`@problems`:** Add workspace errors and warnings ('Problems' panel) for Cline to fix
+
+**`@file`:** Adds a file's contents so you don't have to waste API requests approving read file (+ type to search files)
+
+**`@folder`:** Adds folder's files all at once to speed up your workflow even more
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="right" width="350" src="https://github.com/user-attachments/assets/140c8606-d3bf-41b9-9a1f-4dbf0d4c90cb">
+
+### Checkpoints: Compare and Restore
+
+As Cline works through a task, the extension takes a snapshot of your workspace at each step. You can use the 'Compare' button to see a diff between the snapshot and your current workspace, and the 'Restore' button to roll back to that point.
+
+For example, when working with a local web server, you can use 'Restore Workspace Only' to quickly test different versions of your app, then use 'Restore Task and Workspace' when you find the version you want to continue building from. This lets you safely explore different approaches without losing progress.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+## Contributing
+
+To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.md) to learn the basics. You can also join our [Discord](https://discord.gg/cline) to chat with other contributors in the `#contributors` channel. If you're looking for full-time work, check out our open positions on our [careers page](https://cline.bot/join-us)!
+
+## Enterprise
+
+Get the same Cline experience with enterprise-grade controls: SSO (SAML/OIDC), global policies and configuration, observability with audit trails, private networking (VPC/private link), and self-hosted or on-prem deployments, and enterprise support. Learn more at our [enterprise page](https://cline.bot/enterprise) or [talk to us](https://cline.bot/contact-sales).
+
+
+## License
+
+[Apache 2.0 © 2026 Cline Bot Inc.](./LICENSE)
diff --git a/apps/vscode/README.md b/apps/vscode/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/apps/vscode/assets/icons/cline-bot.svg b/apps/vscode/assets/icons/cline-bot.svg
new file mode 100644
index 0000000..4253728
--- /dev/null
+++ b/apps/vscode/assets/icons/cline-bot.svg
@@ -0,0 +1,30 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata>
+<json>
+<![CDATA[
+{
+	"fontFamily": "cline-bot",
+	"majorVersion": 1,
+	"minorVersion": 0,
+	"fontURL": "https://cline.bot",
+	"designerURL": "https://cline.bot",
+	"licenseURL": "https://cline.bot",
+	"version": "Version 1.0",
+	"fontId": "cline-bot",
+	"psName": "cline-bot",
+	"subFamily": "Regular",
+	"fullName": "cline-bot",
+	"description": "Font generated by IcoMoon."
+}
+]]>
+</json>
+</metadata>
+<defs>
+<font id="cline-bot" horiz-adv-x="1024">
+<font-face units-per-em="1024" ascent="960" descent="-64" />
+<missing-glyph horiz-adv-x="1024" />
+<glyph unicode="&#x20;" horiz-adv-x="512" d="" />
+<glyph unicode="&#xe900;" glyph-name="cline" data-tags="cline" horiz-adv-x="977" d="M964.553 383.11l-60.285 121.406v69.495c0 115.545-92.939 209.321-207.647 209.321h-102.986c7.536 15.071 11.722 32.654 11.722 51.074 0 64.471-51.912 116.383-115.545 116.383s-115.545-51.912-115.545-116.383 4.186-35.166 11.722-51.074h-102.986c-114.708 0-207.647-93.776-207.647-209.321v-69.495l-61.959-121.406c-5.861-11.722-5.861-26.793 0-38.515l61.959-119.732v-69.495c0-115.545 92.939-209.321 207.647-209.321h415.294c114.708 0 207.647 93.776 207.647 209.321v69.495l60.285 119.732c5.861 11.722 5.861 25.956 0 38.515v0zM426.178 284.311c0-52.749-42.702-95.451-94.613-95.451s-94.613 42.702-94.613 95.451v169.132c0 52.749 42.702 95.451 94.613 95.451s94.613-42.702 94.613-95.451v-169.132zM731.787 284.311c0-52.749-42.702-95.451-94.613-95.451s-94.613 42.702-94.613 95.451v169.132c0 52.749 42.702 95.451 94.613 95.451s94.613-42.702 94.613-95.451v-169.132z" />
+</font></defs></svg>
\ No newline at end of file
diff --git a/apps/vscode/assets/icons/cline-bot.ttf b/apps/vscode/assets/icons/cline-bot.ttf
new file mode 100644
index 0000000..184030f
Binary files /dev/null and b/apps/vscode/assets/icons/cline-bot.ttf differ
diff --git a/apps/vscode/assets/icons/cline-bot.woff b/apps/vscode/assets/icons/cline-bot.woff
new file mode 100644
index 0000000..cefd0e8
Binary files /dev/null and b/apps/vscode/assets/icons/cline-bot.woff differ
diff --git a/apps/vscode/assets/icons/icon.png b/apps/vscode/assets/icons/icon.png
new file mode 100644
index 0000000..db6f1d8
Binary files /dev/null and b/apps/vscode/assets/icons/icon.png differ
diff --git a/apps/vscode/assets/icons/icon.svg b/apps/vscode/assets/icons/icon.svg
new file mode 100644
index 0000000..2a3908a
--- /dev/null
+++ b/apps/vscode/assets/icons/icon.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="92px" height="96px" viewBox="0 0 92 96" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Group Copy 2</title>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="icon-copy" transform="translate(-34, -40)" fill="#24292F">
+            <g id="Group-Copy-2" transform="translate(34, 40.5)">
+                <g id="Group-3-Copy-4" transform="translate(0, 0)">
+                    <path d="M65.4492701,16.3 C76.3374701,16.3 85.1635558,25.16479 85.1635558,36.1 L85.1635558,42.7 L90.9027661,54.1647464 C91.4694141,55.2966923 91.4668177,56.6300535 90.8957658,57.7597839 L85.1635558,69.1 L85.1635558,75.7 C85.1635558,86.63554 76.3374701,95.5 65.4492701,95.5 L26.0206986,95.5 C15.1328272,95.5 6.30641291,86.63554 6.30641291,75.7 L6.30641291,69.1 L0.448507752,57.7954874 C-0.14693501,56.6464093 -0.149634367,55.2802504 0.441262896,54.1288283 L6.30641291,42.7 L6.30641291,36.1 C6.30641291,25.16479 15.1328272,16.3 26.0206986,16.3 L65.4492701,16.3 Z M62.9301895,22 L29.189529,22 C19.8723267,22 12.3191987,29.5552188 12.3191987,38.875 L12.3191987,44.5 L7.44288578,53.9634655 C6.84794449,55.1180686 6.85066096,56.4896598 7.45017099,57.6418974 L12.3191987,67 L12.3191987,72.625 C12.3191987,81.9450625 19.8723267,89.5 29.189529,89.5 L62.9301895,89.5 C72.2476729,89.5 79.8005198,81.9450625 79.8005198,72.625 L79.8005198,67 L84.5682187,57.6061395 C85.1432011,56.473244 85.1458141,55.1345713 84.5752587,53.9994398 L79.8005198,44.5 L79.8005198,38.875 C79.8005198,29.5552188 72.2476729,22 62.9301895,22 Z" id="Combined-Shape" fill-rule="nonzero"></path>
+                    <circle id="Oval" cx="45.7349843" cy="11" r="11"></circle>
+                </g>
+                <rect id="Rectangle-Copy" stroke="#24292F" stroke-width="8" x="31" y="44.5" width="5" height="22" rx="2.5"></rect>
+                <rect id="Rectangle-Copy-2" stroke="#24292F" stroke-width="8" x="55" y="44.5" width="5" height="22" rx="2.5"></rect>
+            </g>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/apps/vscode/assets/icons/robot_panel_dark.png b/apps/vscode/assets/icons/robot_panel_dark.png
new file mode 100644
index 0000000..36c3776
Binary files /dev/null and b/apps/vscode/assets/icons/robot_panel_dark.png differ
diff --git a/apps/vscode/assets/icons/robot_panel_light.png b/apps/vscode/assets/icons/robot_panel_light.png
new file mode 100644
index 0000000..2f028e0
Binary files /dev/null and b/apps/vscode/assets/icons/robot_panel_light.png differ
diff --git a/apps/vscode/assets/icons/sleepy-cline.svg b/apps/vscode/assets/icons/sleepy-cline.svg
new file mode 100644
index 0000000..2cfa894
--- /dev/null
+++ b/apps/vscode/assets/icons/sleepy-cline.svg
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 512 535">
+  <!-- Generator: Adobe Illustrator 29.8.5, SVG Export Plug-In . SVG Version: 2.1.1 Build 2)  -->
+  <defs>
+    <style>
+      .st0 {
+        fill: #fff;
+      }
+    </style>
+  </defs>
+  <path class="st0" d="M500.6,300.5c-9-20.7-17.9-41.4-26.9-62.1-.7-2-.3-4.4-.3-6.4.4-9,1.1-18,1.4-27,2.8-28.4-6.5-58-25.2-79.6-15.1-18.1-36.6-30.7-59.6-35.5-8.1-1.8-16.6-1.6-25-2.1-10-.7-20-1-30-1.7,2-11.9,1-24.1-3.7-35.3-5.8-14.1-16.8-25.9-30.6-32.5-14.4-7-31.5-8.2-46.7-3.1-16,5.2-29.5,17-36.8,32.1-4.9,10-6.8,21.2-6.1,32.2-19.7-1-39.4-2.2-59.1-3.1-26.8.5-53,11.7-72,30.6-20.2,19.5-31.7,47-32.3,75-.5,9.3-1,18.7-1.5,28-.2,2.1,0,4.1-1.2,6-9.8,16.8-19.5,33.7-29.4,50.6-2.2,4.1-4.9,8-6.6,12.3-2,5.7-1.2,12.2,1.3,17.6,8.9,19.5,17.6,39.2,26.5,58.7.8,1.9,1.5,3.7,1.3,5.8-.6,10.3-1.1,20.7-1.7,31-1.5,21.2,3,42.6,13.5,61.1,8.8,15.8,21.6,29.4,37.1,38.9,13.9,8.7,29.7,13.9,46,15.4,72,3.9,144,7.7,216,11.5,20.1,1.8,40.8-2.8,58.5-12.5,18.8-10.1,34.2-26,44.1-44.9,6.5-12.6,10.5-26.4,11.7-40.5.7-12.4,1.2-24.7,2-37.1,0-3.3,1.9-5.5,3.3-8.2,6.6-11.8,13.5-23.4,20.1-35.2,3.7-6.9,8.1-13.4,11.6-20.4,3.2-6.1,3.2-13.5.3-19.7ZM218.5,316.5c-9.7,7.1-21.3,12.3-33.5,12.5-17.6,1-35.1-5.3-49-16-4.6-3.2-8.1-7.5-9.6-13,0-1.8-.7-3.6,1.7-3.8,4,1,7.9,2.6,12,3.5,22.8,5.6,47.6,5.9,71,4.8,6.5-.2,13-1.3,19.5-.9-2.7,5.6-7.1,9.2-12,12.9ZM276,449.7c-14,.5-28,.1-42-.2-2.1,0-4.3,0-6.4-.4-.9-2.1.6-3.2,1.7-4.8,4.8-5.9,11-11,18.7-12.4,8.4-1.6,16.5,1.2,23.5,5.5,4.7,3,9.2,6.3,12.6,10.8-2.6,1.1-5.3,1.4-8.1,1.4ZM390.4,319.4c-16.4,14.2-38.8,21.8-60.4,18.4-13.2-1.6-24.7-8.6-34.1-17.7-3-3-6.2-6.5-8.1-10.4.5-1,1.2-1.6,2.2-1.6,2.8-.2,5.7.7,8.5,1.1,16,2.9,32.3,4.9,48.5,5.5,14.3.4,28.2-.2,42.2-3.6,2.2-.6,3.7-.3,5.8.5-1.1,2.9-2.2,5.7-4.6,7.8Z"/>
+</svg>
\ No newline at end of file
diff --git a/apps/vscode/assets/icons/social/discord.svg b/apps/vscode/assets/icons/social/discord.svg
new file mode 100644
index 0000000..3f1ab3b
--- /dev/null
+++ b/apps/vscode/assets/icons/social/discord.svg
@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20.317 4.15557C18.7873 3.45369 17.147 2.93658 15.4319 2.6404C15.4007 2.63469 15.3695 2.64897 15.3534 2.67754C15.1424 3.05276 14.9087 3.54225 14.7451 3.927C12.9004 3.65083 11.0652 3.65083 9.25832 3.927C9.09465 3.5337 8.85248 3.05276 8.64057 2.67754C8.62449 2.64992 8.59328 2.63564 8.56205 2.6404C6.84791 2.93563 5.20756 3.45275 3.67693 4.15557C3.66368 4.16129 3.65233 4.17082 3.64479 4.18319C0.533392 8.83155 -0.31895 13.3657 0.0991801 17.8436C0.101072 17.8655 0.11337 17.8864 0.130398 17.8997C2.18321 19.4073 4.17171 20.3225 6.12328 20.9291C6.15451 20.9386 6.18761 20.9272 6.20748 20.9015C6.66913 20.2711 7.08064 19.6063 7.43348 18.9073C7.4543 18.8664 7.43442 18.8178 7.39186 18.8016C6.73913 18.554 6.1176 18.2521 5.51973 17.9093C5.47244 17.8816 5.46865 17.814 5.51216 17.7816C5.63797 17.6873 5.76382 17.5893 5.88396 17.4902C5.90569 17.4721 5.93598 17.4683 5.96153 17.4797C9.88928 19.273 14.1415 19.273 18.023 17.4797C18.0485 17.4674 18.0788 17.4712 18.1015 17.4893C18.2216 17.5883 18.3475 17.6873 18.4742 17.7816C18.5177 17.814 18.5149 17.8816 18.4676 17.9093C17.8697 18.2588 17.2482 18.554 16.5945 18.8006C16.552 18.8168 16.533 18.8664 16.5538 18.9073C16.9143 19.6054 17.3258 20.2701 17.7789 20.9005C17.7978 20.9272 17.8319 20.9386 17.8631 20.9291C19.8241 20.3225 21.8126 19.4073 23.8654 17.8997C23.8834 17.8864 23.8948 17.8664 23.8967 17.8445C24.3971 12.6676 23.0585 8.17064 20.3482 4.18414C20.3416 4.17082 20.3303 4.16129 20.317 4.15557ZM8.02002 15.117C6.8375 15.117 5.86313 14.0313 5.86313 12.6981C5.86313 11.3648 6.8186 10.2791 8.02002 10.2791C9.23087 10.2791 10.1958 11.3743 10.1769 12.6981C10.1769 14.0313 9.22141 15.117 8.02002 15.117ZM15.9947 15.117C14.8123 15.117 13.8379 14.0313 13.8379 12.6981C13.8379 11.3648 14.7933 10.2791 15.9947 10.2791C17.2056 10.2791 18.1705 11.3743 18.1516 12.6981C18.1516 14.0313 17.2056 15.117 15.9947 15.117Z" fill="#FAFAFA"/>
+</svg>
diff --git a/apps/vscode/assets/icons/social/github.svg b/apps/vscode/assets/icons/social/github.svg
new file mode 100644
index 0000000..143ce89
--- /dev/null
+++ b/apps/vscode/assets/icons/social/github.svg
@@ -0,0 +1,3 @@
+        <svg viewBox="0 0 24 24" fill="black" xmlns="http://www.w3.org/2000/svg">
+          <path d="M12 2C6.477 2 2 6.477 2 12C2 16.418 4.865 20.166 8.84 21.49C9.34 21.58 9.52 21.27 9.52 21C9.52 20.77 9.51 20.14 9.51 19.31C6.73 19.91 6.14 17.97 6.14 17.97C5.68 16.81 5.03 16.5 5.03 16.5C4.12 15.88 5.1 15.9 5.1 15.9C6.1 15.97 6.63 16.93 6.63 16.93C7.5 18.45 8.97 18 9.54 17.76C9.63 17.11 9.89 16.67 10.17 16.42C7.95 16.17 5.62 15.31 5.62 11.5C5.62 10.39 6 9.5 6.65 8.79C6.55 8.54 6.2 7.5 6.75 6.15C6.75 6.15 7.59 5.88 9.5 7.17C10.29 6.95 11.15 6.84 12 6.84C12.85 6.84 13.71 6.95 14.5 7.17C16.41 5.88 17.25 6.15 17.25 6.15C17.8 7.5 17.45 8.54 17.35 8.79C18 9.5 18.38 10.39 18.38 11.5C18.38 15.32 16.04 16.16 13.81 16.41C14.17 16.72 14.5 17.33 14.5 18.26C14.5 19.6 14.49 20.68 14.49 21C14.49 21.27 14.67 21.59 15.17 21.49C19.14 20.16 22 16.42 22 12C22 6.477 17.523 2 12 2Z" fill="white"/>
+        </svg>
\ No newline at end of file
diff --git a/apps/vscode/assets/icons/social/linkedin.svg b/apps/vscode/assets/icons/social/linkedin.svg
new file mode 100644
index 0000000..cab0d6c
--- /dev/null
+++ b/apps/vscode/assets/icons/social/linkedin.svg
@@ -0,0 +1,10 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_2001_1428)">
+<path d="M22.2234 0H1.77187C0.792187 0 0 0.773438 0 1.72969V22.2656C0 23.2219 0.792187 24 1.77187 24H22.2234C23.2031 24 24 23.2219 24 22.2703V1.72969C24 0.773438 23.2031 0 22.2234 0ZM7.12031 20.4516H3.55781V8.99531H7.12031V20.4516ZM5.33906 7.43438C4.19531 7.43438 3.27188 6.51094 3.27188 5.37187C3.27188 4.23281 4.19531 3.30937 5.33906 3.30937C6.47813 3.30937 7.40156 4.23281 7.40156 5.37187C7.40156 6.50625 6.47813 7.43438 5.33906 7.43438ZM20.4516 20.4516H16.8937V14.8828C16.8937 13.5562 16.8703 11.8453 15.0422 11.8453C13.1906 11.8453 12.9094 13.2937 12.9094 14.7891V20.4516H9.35625V8.99531H12.7687V10.5609H12.8156C13.2891 9.66094 14.4516 8.70938 16.1813 8.70938C19.7859 8.70938 20.4516 11.0813 20.4516 14.1656V20.4516Z" fill="#FAFAFA"/>
+</g>
+<defs>
+<clipPath id="clip0_2001_1428">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/apps/vscode/assets/icons/social/reddit.svg b/apps/vscode/assets/icons/social/reddit.svg
new file mode 100644
index 0000000..950e8ff
--- /dev/null
+++ b/apps/vscode/assets/icons/social/reddit.svg
@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M15.0512 4.07466C15.3113 5.17727 16.301 5.99866 17.4829 5.99866C18.8627 5.99866 19.9813 4.87965 19.9813 3.49933C19.9813 2.11902 18.8627 1 17.4829 1C16.2764 1 15.2703 1.85537 15.036 2.99314C13.0155 3.20991 11.4378 4.92417 11.4378 7.00167C11.4378 7.00636 11.4378 7.00988 11.4378 7.01456C9.24041 7.10713 7.23397 7.73284 5.641 8.72062C5.04949 8.26247 4.30688 7.98945 3.50102 7.98945C1.5672 7.98945 0 9.55725 0 11.4918C0 12.8955 0.824597 14.1048 2.01581 14.6637C2.13177 18.7297 6.56047 22 12.0082 22C17.4559 22 21.8905 18.7261 22.0006 14.6567C23.1824 14.0942 24 12.8885 24 11.493C24 9.55842 22.4328 7.99063 20.499 7.99063C19.6966 7.99063 18.9575 8.2613 18.3672 8.71594C16.7602 7.72113 14.7315 7.09541 12.5119 7.01222C12.5119 7.0087 12.5119 7.00636 12.5119 7.00285C12.5119 5.51473 13.6176 4.27971 15.0512 4.077V4.07466ZM5.50044 13.7146C5.559 12.4444 6.40234 11.4695 7.38272 11.4695C8.3631 11.4695 9.11274 12.4995 9.05417 13.7697C8.99561 15.0398 8.26354 15.5015 7.28199 15.5015C6.30044 15.5015 5.44187 14.9848 5.50044 13.7146ZM16.6348 11.4695C17.6164 11.4695 18.4597 12.4444 18.5171 13.7146C18.5757 14.9848 17.716 15.5015 16.7356 15.5015C15.7552 15.5015 15.022 15.041 14.9634 13.7697C14.9048 12.4995 15.6533 11.4695 16.6348 11.4695ZM15.4682 16.6533C15.6521 16.6721 15.7693 16.8631 15.6978 17.0341C15.0946 18.4766 13.6703 19.4901 12.0082 19.4901C10.3461 19.4901 8.92299 18.4766 8.31859 17.0341C8.24714 16.8631 8.36427 16.6721 8.54817 16.6533C9.62577 16.5444 10.7912 16.4846 12.0082 16.4846C13.2252 16.4846 14.3895 16.5444 15.4682 16.6533Z" fill="#FAFAFA"/>
+</svg>
diff --git a/apps/vscode/assets/icons/social/x.svg b/apps/vscode/assets/icons/social/x.svg
new file mode 100644
index 0000000..e7de1b6
--- /dev/null
+++ b/apps/vscode/assets/icons/social/x.svg
@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M18.3263 1.90393H21.6998L14.3297 10.3274L23 21.7899H16.2112L10.894 14.838L4.80995 21.7899H1.43443L9.31743 12.78L1 1.90393H7.96111L12.7674 8.25826L18.3263 1.90393ZM17.1423 19.7707H19.0116L6.94539 3.81706H4.93946L17.1423 19.7707Z" fill="#FAFAFA"/>
+</svg>
diff --git a/apps/vscode/biome.jsonc b/apps/vscode/biome.jsonc
new file mode 100644
index 0000000..a1abdd8
--- /dev/null
+++ b/apps/vscode/biome.jsonc
@@ -0,0 +1,204 @@
+{
+	"root": true,
+	"$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"defaultBranch": "main"
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on",
+				"useSortedAttributes": "on"
+			}
+		}
+	},
+	"linter": {
+		"enabled": true,
+		"domains": {
+			"react": "recommended"
+		},
+		// Ideally we would want to turn on all the rules that are currently off,
+		// keeping them off currently to make sure only changes on the migrations
+		// are included in the initial PR before we apply the format and lint changes.
+		// TODO: turn on all rules that are currently off if applicable.
+		// TODO: Remove --diagnostic-level=error from CI commands.
+		"rules": {
+			"recommended": true,
+			"correctness": {
+				"useExhaustiveDependencies": "info",
+				"noUndeclaredVariables": "off",
+				"noEmptyPattern": "info",
+				"useJsxKeyInIterable": "off",
+				"noInnerDeclarations": "off",
+				"useHookAtTopLevel": "info",
+				"useYield": "info",
+				"noConstructorReturn": "off",
+				"noInvalidPositionAtImportRule": "off",
+				"noSwitchDeclarations": "off",
+				"noUnusedImports": "error"
+			},
+			"a11y": "info",
+			"style": {
+				"useNodejsImportProtocol": "off",
+				"useImportType": "off",
+				"useBlockStatements": "off",
+				"useNamingConvention": "off",
+				"useThrowOnlyError": "info",
+				"useConsistentArrayType": "off",
+				"noParameterAssign": "off",
+				"useAsConstAssertion": "off",
+				"useDefaultParameterLast": "off",
+				"noNonNullAssertion": "info",
+				"useEnumInitializers": "off",
+				"useSelfClosingElements": "info",
+				"useSingleVarDeclarator": "off",
+				"useNumberNamespace": "off",
+				"noInferrableTypes": "off",
+				"useTemplate": "info",
+				"noUselessElse": "info"
+			},
+			"suspicious": {
+				"noDoubleEquals": "warn",
+				"noImplicitAnyLet": "info",
+				"noThenProperty": "off",
+				"noAsyncPromiseExecutor": "info",
+				"noImportAssign": "off",
+				"noExplicitAny": "info",
+				"noControlCharactersInRegex": "warn",
+				"noShadowRestrictedNames": "off",
+				"noArrayIndexKey": "info",
+				"noAssignInExpressions": "info",
+				"useIterableCallbackReturn": "info"
+			},
+			"complexity": {
+				"noUselessConstructor": "info",
+				"useOptionalChain": "info",
+				"noBannedTypes": "warn",
+				"useLiteralKeys": "info",
+				"noUselessCatch": "info",
+				"noUselessSwitchCase": "info",
+				"noStaticOnlyClass": "info"
+			},
+			"security": {
+				"noDangerouslySetInnerHtml": "info"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab",
+		"indentWidth": 4,
+		"lineWidth": 130,
+		"lineEnding": "lf",
+		"formatWithErrors": true
+	},
+	"css": {
+		"parser": {
+			"tailwindDirectives": true
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"semicolons": "asNeeded",
+			"arrowParentheses": "always",
+			"bracketSameLine": true,
+			"bracketSpacing": true,
+			"jsxQuoteStyle": "double",
+			"quoteProperties": "asNeeded",
+			"trailingCommas": "all"
+		}
+	},
+	"json": {
+		"formatter": {
+			"trailingCommas": "none",
+			"expand": "always"
+		}
+	},
+	"files": {
+		"ignoreUnknown": true,
+		"includes": [
+			"**",
+			// explicitly force files to be ignored by the scanner with !!
+			"!!**/dist",
+			"!!**/dist-*",
+			"!!**/out",
+			"!!**/evals",
+			"!!**/playwright",
+			"!!**/.vscode-test",
+			"!!**/test-results",
+			"!!**/coverage",
+			"!!**/node_modules",
+			"!!**/webview-ui/build",
+			"!!**/generated",
+			"!!**/proto",
+			"!!**/tests/specs",
+			"!!assets/icons/*.svg"
+		]
+	},
+	"plugins": [
+		"src/dev/grit/process-env.grit"
+	],
+	"overrides": [
+		{
+			"includes": [
+				"**",
+				"!!**/dist",
+				"!!**/hosts/vscode/**",
+				"!!**/test/**",
+				"!!**/*.test.ts",
+				"!!src/dev/**",
+				"!!src/extension.ts",
+				"!!src/integrations/git/commit-message-generator.ts",
+				"!!src/integrations/terminal/**",
+				"!!src/core/controller/ui/openWalkthrough.ts"
+			],
+			"plugins": [
+				"src/dev/grit/vscode-api.grit"
+			]
+		},
+		{
+			// Do not use console logging directly, use the Logger service instead.
+			"plugins": [
+				"src/dev/grit/console-log.grit"
+			],
+			"includes": [
+				"**",
+				"!!**/esbuild.*",
+				"!!**/*.mts",
+				"!!**/webview-ui/**",
+				"!!**/evals/**",
+				"!!**/standalone/**",
+				"!!**/cli/**",
+				"!!**/e2e/**",
+				"!!**/test/**",
+				"!!**/__tests__/**",
+				"!!**/*.test.ts",
+				"!!**/*.stories.ts",
+				"!!src/dev/**",
+				"!!**/*.mjs",
+				"!!**/*.js",
+				"!!**/scripts/**",
+				"!!**/*.tsx",
+				"!!**/testing-platform/**"
+			]
+		},
+		{
+			"includes": [
+				"**",
+				"!!src/core/storage/state-migrations.ts",
+				"!!src/core/storage/FileContextTracker.ts",
+				"!!src/core/context/context-tracking/FileContextTracker.ts",
+				"!!src/common.ts",
+				"!!src/services/logging/distinctId.ts",
+				"!!src/core/storage/utils/state-helpers.ts",
+				"!!src/extension.ts"
+			],
+			"plugins": [
+				"src/dev/grit/use-cache-service.grit"
+			]
+		}
+	]
+}
diff --git a/apps/vscode/buf.yaml b/apps/vscode/buf.yaml
new file mode 100644
index 0000000..53722cd
--- /dev/null
+++ b/apps/vscode/buf.yaml
@@ -0,0 +1,21 @@
+version: v2
+modules:
+    - path: proto
+      name: cline/cline/lint
+
+lint:
+    use:
+        - STANDARD
+
+    except: # Add exceptions for current patterns that contradict STANDARD settings
+        - RPC_PASCAL_CASE # rpcs are camel case (start with lowercase)
+        - RPC_REQUEST_RESPONSE_UNIQUE # request messages are not unique.
+        - RPC_REQUEST_STANDARD_NAME # request messages dont all end with Request
+        - RPC_RESPONSE_STANDARD_NAME # response messages dont all end with Response
+        - PACKAGE_VERSION_SUFFIX # package name does not contain version.
+        - ENUM_VALUE_PREFIX # enum values dont start with the enum name.
+        - ENUM_ZERO_VALUE_SUFFIX # first value does not have to be UNSPECIFIED.
+
+# breaking:
+#   use:
+#     - WIRE_JSON # Detect changes that break the json wire format (this is the minimum recommended level.)
diff --git a/apps/vscode/bunfig.toml b/apps/vscode/bunfig.toml
new file mode 100644
index 0000000..e47481b
--- /dev/null
+++ b/apps/vscode/bunfig.toml
@@ -0,0 +1,7 @@
+[test]
+# Module-substitution aliases for `bun test`. bun resolves tsconfig `paths`
+# (@/*, @core/*, @shared/*, …) and the real @cline/llms + @cline/shared dist
+# builds on its own; the preload only shadows `vscode` and `@cline/core` with
+# their unit-test stubs (mirrors vitest.config.ts resolve.alias). See
+# src/test/bun-test-preload.ts for details.
+preload = ["./src/test/bun-test-preload.ts"]
diff --git a/apps/vscode/esbuild.mjs b/apps/vscode/esbuild.mjs
new file mode 100644
index 0000000..bece869
--- /dev/null
+++ b/apps/vscode/esbuild.mjs
@@ -0,0 +1,195 @@
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import * as esbuild from "esbuild"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const production = process.argv.includes("--production") || process.env["IS_DEBUG_BUILD"] === "false"
+const watch = process.argv.includes("--watch")
+const standalone = process.argv.includes("--standalone")
+const e2eBuild = process.argv.includes("--e2e-build")
+const destDir = standalone ? "dist-standalone" : "dist"
+
+/**
+ * @type {import('esbuild').Plugin}
+ */
+const aliasResolverPlugin = {
+	name: "alias-resolver",
+	setup(build) {
+		const aliases = {
+			"@": path.resolve(__dirname, "src"),
+			"@core": path.resolve(__dirname, "src/core"),
+			"@integrations": path.resolve(__dirname, "src/integrations"),
+			"@services": path.resolve(__dirname, "src/services"),
+			"@shared": path.resolve(__dirname, "src/shared"),
+			"@utils": path.resolve(__dirname, "src/utils"),
+			"@packages": path.resolve(__dirname, "src/packages"),
+		}
+
+		// For each alias entry, create a resolver
+		Object.entries(aliases).forEach(([alias, aliasPath]) => {
+			const aliasRegex = new RegExp(`^${alias}($|/.*)`)
+			build.onResolve({ filter: aliasRegex }, (args) => {
+				const importPath = args.path.replace(alias, aliasPath)
+
+				// First, check if the path exists as is
+				if (fs.existsSync(importPath)) {
+					const stats = fs.statSync(importPath)
+					if (stats.isDirectory()) {
+						// If it's a directory, try to find index files
+						const extensions = [".ts", ".tsx", ".js", ".jsx"]
+						for (const ext of extensions) {
+							const indexFile = path.join(importPath, `index${ext}`)
+							if (fs.existsSync(indexFile)) {
+								return { path: indexFile }
+							}
+						}
+					} else {
+						// It's a file that exists, so return it
+						return { path: importPath }
+					}
+				}
+
+				// If the path doesn't exist, try appending extensions
+				const extensions = [".ts", ".tsx", ".js", ".jsx"]
+				for (const ext of extensions) {
+					const pathWithExtension = `${importPath}${ext}`
+					if (fs.existsSync(pathWithExtension)) {
+						return { path: pathWithExtension }
+					}
+				}
+
+				// If nothing worked, return the original path and let esbuild handle the error
+				return { path: importPath }
+			})
+		})
+	},
+}
+
+const esbuildProblemMatcherPlugin = {
+	name: "esbuild-problem-matcher",
+
+	setup(build) {
+		build.onStart(() => {
+			console.log("[watch] build started")
+		})
+		build.onEnd((result) => {
+			result.errors.forEach(({ text, location }) => {
+				console.error(`✘ [ERROR] ${text}`)
+				console.error(`    ${location.file}:${location.line}:${location.column}:`)
+			})
+			console.log("[watch] build finished")
+		})
+	},
+}
+
+const buildEnvVars = {
+	"import.meta.url": "_importMetaUrl",
+	"process.env.IS_STANDALONE": JSON.stringify(standalone ? "true" : "false"),
+}
+
+if (production) {
+	// IS_DEV is always disable in production builds.
+	buildEnvVars["process.env.IS_DEV"] = "false"
+}
+// Set the environment and telemetry env vars. The API key env vars need to be populated in the GitHub
+// workflows from the secrets.
+if (process.env.CLINE_ENVIRONMENT) {
+	buildEnvVars["process.env.CLINE_ENVIRONMENT"] = JSON.stringify(process.env.CLINE_ENVIRONMENT)
+}
+if (process.env.TELEMETRY_SERVICE_API_KEY) {
+	buildEnvVars["process.env.TELEMETRY_SERVICE_API_KEY"] = JSON.stringify(process.env.TELEMETRY_SERVICE_API_KEY)
+}
+if (process.env.ERROR_SERVICE_API_KEY) {
+	buildEnvVars["process.env.ERROR_SERVICE_API_KEY"] = JSON.stringify(process.env.ERROR_SERVICE_API_KEY)
+}
+
+// OpenTelemetry configuration (injected at build time from GitHub secrets)
+// These provide production defaults that can be overridden at runtime via environment variables
+if (process.env.OTEL_TELEMETRY_ENABLED) {
+	buildEnvVars["process.env.OTEL_TELEMETRY_ENABLED"] = JSON.stringify(process.env.OTEL_TELEMETRY_ENABLED)
+}
+if (process.env.OTEL_LOGS_EXPORTER) {
+	buildEnvVars["process.env.OTEL_LOGS_EXPORTER"] = JSON.stringify(process.env.OTEL_LOGS_EXPORTER)
+}
+if (process.env.OTEL_METRICS_EXPORTER) {
+	buildEnvVars["process.env.OTEL_METRICS_EXPORTER"] = JSON.stringify(process.env.OTEL_METRICS_EXPORTER)
+}
+if (process.env.OTEL_EXPORTER_OTLP_PROTOCOL) {
+	buildEnvVars["process.env.OTEL_EXPORTER_OTLP_PROTOCOL"] = JSON.stringify(process.env.OTEL_EXPORTER_OTLP_PROTOCOL)
+}
+if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+	buildEnvVars["process.env.OTEL_EXPORTER_OTLP_ENDPOINT"] = JSON.stringify(process.env.OTEL_EXPORTER_OTLP_ENDPOINT)
+}
+if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
+	buildEnvVars["process.env.OTEL_EXPORTER_OTLP_HEADERS"] = JSON.stringify(process.env.OTEL_EXPORTER_OTLP_HEADERS)
+}
+if (process.env.OTEL_METRIC_EXPORT_INTERVAL) {
+	buildEnvVars["process.env.OTEL_METRIC_EXPORT_INTERVAL"] = JSON.stringify(process.env.OTEL_METRIC_EXPORT_INTERVAL)
+}
+// Base configuration shared between extension and standalone builds
+const baseConfig = {
+	bundle: true,
+	minify: production,
+	sourcemap: !production,
+	logLevel: "silent",
+	define: buildEnvVars,
+	tsconfig: path.resolve(__dirname, "tsconfig.json"),
+	plugins: [
+		aliasResolverPlugin,
+		/* add to the end of plugins array */
+		esbuildProblemMatcherPlugin,
+	],
+	format: "cjs",
+	sourcesContent: false,
+	platform: "node",
+	banner: {
+		js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",
+	},
+}
+
+// Extension-specific configuration
+const extensionConfig = {
+	...baseConfig,
+	entryPoints: ["src/extension.ts"],
+	outfile: `${destDir}/extension.js`,
+	external: ["vscode"],
+}
+
+// Standalone-specific configuration
+const standaloneConfig = {
+	...baseConfig,
+	entryPoints: ["src/standalone/cline-core.ts"],
+	outfile: `${destDir}/cline-core.js`,
+	// These modules need to load files from the module directory at runtime,
+	// so they cannot be bundled.
+	external: ["vscode", "@grpc/reflection", "grpc-health-check", "better-sqlite3"],
+}
+
+// E2E build script configuration
+const e2eBuildConfig = {
+	...baseConfig,
+	entryPoints: ["src/test/e2e/utils/build.ts"],
+	outfile: `${destDir}/e2e-build.mjs`,
+	external: ["@vscode/test-electron", "execa"],
+	sourcemap: false,
+	plugins: [aliasResolverPlugin, esbuildProblemMatcherPlugin],
+}
+
+async function main() {
+	const config = standalone ? standaloneConfig : e2eBuild ? e2eBuildConfig : extensionConfig
+	const extensionCtx = await esbuild.context(config)
+	if (watch) {
+		await extensionCtx.watch()
+	} else {
+		await extensionCtx.rebuild()
+		await extensionCtx.dispose()
+	}
+}
+
+main().catch((e) => {
+	console.error(e)
+	process.exit(1)
+})
diff --git a/apps/vscode/knip.json b/apps/vscode/knip.json
new file mode 100644
index 0000000..ca3a541
--- /dev/null
+++ b/apps/vscode/knip.json
@@ -0,0 +1,34 @@
+{
+	"$schema": "https://unpkg.com/knip@5/schema.json",
+	"workspaces": {
+		".": {
+			"entry": [
+				"src/extension.ts",
+				"src/standalone/cline-core.ts",
+				"src/generated/hosts/standalone/protobus-server-setup.ts",
+				"src/generated/hosts/standalone/host-bridge-clients.ts",
+				"src/generated/hosts/vscode/protobus-services.ts",
+				"src/generated/hosts/vscode/hostbridge-grpc-service-config.ts",
+				"src/**/*.test.ts",
+				"src/**/__tests__/**/*.ts",
+				"src/test/**/*.ts"
+			],
+			"project": [
+				"src/**/*.ts"
+			]
+		},
+		"webview-ui": {
+			"entry": [
+				"src/services/grpc-client.ts",
+				"src/**/*.test.{ts,tsx}",
+				"src/**/*.spec.{ts,tsx}",
+				"src/**/__tests__/**/*.{ts,tsx}"
+			],
+			"project": [
+				"src/**/*.{ts,tsx}",
+				"*.ts"
+			],
+			"vite": true
+		}
+	}
+}
diff --git a/apps/vscode/package.json b/apps/vscode/package.json
new file mode 100644
index 0000000..3a6254a
--- /dev/null
+++ b/apps/vscode/package.json
@@ -0,0 +1,590 @@
+{
+	"name": "claude-dev",
+	"displayName": "Cline",
+	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
+	"version": "4.0.0",
+	"icon": "assets/icons/icon.png",
+	"engines": {
+		"vscode": "^1.84.0"
+	},
+	"author": {
+		"name": "Cline Bot Inc."
+	},
+	"license": "Apache-2.0",
+	"publisher": "saoudrizwan",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline"
+	},
+	"homepage": "https://cline.bot",
+	"categories": [
+		"AI",
+		"Chat",
+		"Programming Languages",
+		"Education",
+		"Snippets",
+		"Testing"
+	],
+	"keywords": [
+		"cline",
+		"claude",
+		"dev",
+		"mcp",
+		"openrouter",
+		"coding",
+		"agent",
+		"autonomous",
+		"chatgpt",
+		"sonnet",
+		"ai",
+		"llama"
+	],
+	"activationEvents": [
+		"onLanguage",
+		"onUri",
+		"onStartupFinished"
+	],
+	"main": "./dist/extension.js",
+	"contributes": {
+		"icons": {
+			"cline-icon": {
+				"description": "cline",
+				"default": {
+					"fontPath": "assets/icons/cline-bot.woff",
+					"fontCharacter": "\\e900"
+				}
+			}
+		},
+		"walkthroughs": [
+			{
+				"id": "ClineWalkthrough",
+				"title": "Meet Cline, your new coding partner",
+				"description": "Cline codes like a developer because it thinks like one. Here are 5 ways to put it to work:",
+				"steps": [
+					{
+						"id": "welcome",
+						"title": "Start with a Goal, Not Just a Prompt",
+						"description": "Tell Cline what you want to achieve. It plans, asks, and then codes, like a true partner.",
+						"media": {
+							"markdown": "walkthrough/step1.md"
+						}
+					},
+					{
+						"id": "learn",
+						"title": "Let Cline Learn Your Codebase",
+						"description": "Point Cline to your project. It builds understanding to make smart, context-aware changes.",
+						"media": {
+							"markdown": "walkthrough/step2.md"
+						}
+					},
+					{
+						"id": "advanced-features",
+						"title": "Always Use the Best AI Models",
+						"description": "Cline empowers you with State-of-the-Art AI, connecting to top models (Anthropic, Gemini, OpenAI & more).",
+						"media": {
+							"markdown": "walkthrough/step3.md"
+						}
+					},
+					{
+						"id": "mcp",
+						"title": "Extend with Powerful Tools (MCP)",
+						"description": "Connect to databases, APIs, and other external tools through MCP.",
+						"media": {
+							"markdown": "walkthrough/step4.md"
+						}
+					},
+					{
+						"id": "getting-started",
+						"title": "You're Always in Control",
+						"description": "Review Cline's plans and diffs. Approve changes before they happen. No surprises.",
+						"media": {
+							"markdown": "walkthrough/step5.md"
+						},
+						"content": {
+							"path": "walkthrough/step5.md"
+						}
+					}
+				]
+			}
+		],
+		"viewsContainers": {
+			"activitybar": [
+				{
+					"id": "claude-dev-ActivityBar",
+					"title": "Cline",
+					"icon": "assets/icons/icon.svg"
+				}
+			]
+		},
+		"views": {
+			"claude-dev-ActivityBar": [
+				{
+					"type": "webview",
+					"id": "claude-dev.SidebarProvider",
+					"name": "",
+					"icon": "assets/icons/icon.svg"
+				}
+			]
+		},
+		"commands": [
+			{
+				"command": "cline.plusButtonClicked",
+				"title": "New Task",
+				"icon": "$(add)"
+			},
+			{
+				"command": "cline.mcpButtonClicked",
+				"title": "MCP Servers",
+				"icon": "$(server)"
+			},
+			{
+				"command": "cline.marketplaceButtonClicked",
+				"title": "Customize",
+				"icon": "$(wrench)"
+			},
+			{
+				"command": "cline.historyButtonClicked",
+				"title": "History",
+				"icon": "$(history)"
+			},
+			{
+				"command": "cline.accountButtonClicked",
+				"title": "Account",
+				"icon": "$(account)"
+			},
+			{
+				"command": "cline.settingsButtonClicked",
+				"title": "Settings",
+				"icon": "$(settings-gear)"
+			},
+			{
+				"command": "cline.dev.createTestTasks",
+				"title": "Create Test Tasks",
+				"category": "Cline",
+				"when": "cline.isDevMode"
+			},
+			{
+				"command": "cline.dev.expireMcpOAuthTokens",
+				"title": "Expire MCP OAuth Tokens (for testing)",
+				"category": "Cline",
+				"when": "cline.isDevMode"
+			},
+			{
+				"command": "cline.addToChat",
+				"title": "Add to Cline",
+				"category": "Cline"
+			},
+			{
+				"command": "cline.addTerminalOutputToChat",
+				"title": "Add to Cline",
+				"category": "Cline"
+			},
+			{
+				"command": "cline.focusChatInput",
+				"title": "Jump to Chat Input",
+				"category": "Cline"
+			},
+			{
+				"command": "cline.generateGitCommitMessage",
+				"title": "Generate Commit Message with Cline",
+				"category": "Cline",
+				"icon": "$(cline-icon)"
+			},
+			{
+				"command": "cline.abortGitCommitMessage",
+				"title": "Generate Commit Message with Cline - Stop",
+				"category": "Cline",
+				"icon": "$(debug-stop)"
+			},
+			{
+				"command": "cline.explainCode",
+				"title": "Explain with Cline",
+				"category": "Cline"
+			},
+			{
+				"command": "cline.improveCode",
+				"title": "Improve with Cline",
+				"category": "Cline"
+			},
+			{
+				"command": "cline.jupyterGenerateCell",
+				"title": "Generate Jupyter Cell with Cline",
+				"category": "Cline",
+				"icon": "$(sparkle)"
+			},
+			{
+				"command": "cline.jupyterExplainCell",
+				"title": "Explain Jupyter Cell with Cline",
+				"category": "Cline",
+				"icon": "$(question)"
+			},
+			{
+				"command": "cline.jupyterImproveCell",
+				"title": "Improve Jupyter Cell with Cline",
+				"category": "Cline",
+				"icon": "$(lightbulb)"
+			},
+			{
+				"command": "cline.openWalkthrough",
+				"title": "Open Walkthrough",
+				"category": "Cline"
+			},
+			{
+				"command": "cline.reconstructTaskHistory",
+				"title": "Reconstruct Task History",
+				"category": "Cline"
+			}
+		],
+		"keybindings": [
+			{
+				"command": "cline.addToChat",
+				"key": "cmd+'",
+				"mac": "cmd+'",
+				"win": "ctrl+'",
+				"linux": "ctrl+'",
+				"when": "editorHasSelection"
+			},
+			{
+				"command": "cline.generateGitCommitMessage",
+				"when": "config.git.enabled && scmProvider == git"
+			},
+			{
+				"command": "cline.focusChatInput",
+				"key": "cmd+'",
+				"mac": "cmd+'",
+				"win": "ctrl+'",
+				"linux": "ctrl+'",
+				"when": "!editorHasSelection"
+			}
+		],
+		"menus": {
+			"view/title": [
+				{
+					"command": "cline.plusButtonClicked",
+					"group": "navigation@1",
+					"when": "view == claude-dev.SidebarProvider"
+				},
+				{
+					"command": "cline.marketplaceButtonClicked",
+					"group": "navigation@2",
+					"when": "view == claude-dev.SidebarProvider"
+				},
+				{
+					"command": "cline.historyButtonClicked",
+					"group": "navigation@3",
+					"when": "view == claude-dev.SidebarProvider"
+				},
+				{
+					"command": "cline.accountButtonClicked",
+					"group": "navigation@5",
+					"when": "view == claude-dev.SidebarProvider"
+				},
+				{
+					"command": "cline.settingsButtonClicked",
+					"group": "navigation@6",
+					"when": "view == claude-dev.SidebarProvider"
+				}
+			],
+			"editor/context": [
+				{
+					"command": "cline.addToChat",
+					"group": "navigation",
+					"when": "editorHasSelection"
+				}
+			],
+			"terminal/context": [
+				{
+					"command": "cline.addTerminalOutputToChat",
+					"group": "navigation"
+				}
+			],
+			"scm/title": [
+				{
+					"command": "cline.generateGitCommitMessage",
+					"group": "navigation",
+					"when": "config.git.enabled && scmProvider == git && !cline.isGeneratingCommit"
+				},
+				{
+					"command": "cline.abortGitCommitMessage",
+					"group": "navigation",
+					"when": "config.git.enabled && scmProvider == git && cline.isGeneratingCommit"
+				}
+			],
+			"notebook/toolbar": [
+				{
+					"command": "cline.jupyterGenerateCell",
+					"group": "navigation/add@1",
+					"when": "notebookType == 'jupyter-notebook'"
+				}
+			],
+			"notebook/cell/title": [
+				{
+					"command": "cline.jupyterExplainCell",
+					"group": "inline@1",
+					"when": "notebookType == 'jupyter-notebook'"
+				},
+				{
+					"command": "cline.jupyterImproveCell",
+					"group": "inline@2",
+					"when": "notebookType == 'jupyter-notebook'"
+				}
+			],
+			"commandPalette": [
+				{
+					"command": "cline.generateGitCommitMessage",
+					"when": "config.git.enabled && !cline.isGeneratingCommit"
+				},
+				{
+					"command": "cline.abortGitCommitMessage",
+					"when": "config.git.enabled && cline.isGeneratingCommit"
+				}
+			]
+		},
+		"configuration": {
+			"title": "Cline",
+			"properties": {}
+		}
+	},
+	"scripts": {
+		"vscode:prepublish": "bun run package",
+		"compile": "bun run check-types && bun run lint && bun esbuild.mjs",
+		"compile-standalone": "bun run check-types && bun run lint && bun esbuild.mjs --standalone",
+		"postcompile-standalone": "node scripts/package-standalone.mjs",
+		"dev": "bun run protos && bun run watch",
+		"watch": "bun run --parallel watch:esbuild watch:tsc",
+		"watch:esbuild": "bun esbuild.mjs --watch",
+		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
+		"package": "bun run check-types && bun run build:webview && bun run lint && bun esbuild.mjs --production",
+		"protos": "node scripts/build-proto.mjs",
+		"protos-python": "node scripts/build-python-proto.mjs",
+		"download-ripgrep": "node scripts/download-ripgrep.mjs",
+		"postprotos": "biome format --config-path ./biome.jsonc src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --no-errors-on-unmatched",
+		"clean:build": "rimraf dist dist-standalone webview-ui/build src/generated out/",
+		"clean:deps": "rimraf node_modules webview-ui/node_modules",
+		"clean:all": "bun run clean:build && bun run clean:deps",
+		"compile-tests": "node ./scripts/build-tests.js",
+		"watch-tests": "tsc -p . -w --outDir out",
+		"check-types": "bun run protos && bunx tsc --noEmit && cd webview-ui && bunx tsc --noEmit",
+		"lint": "biome lint --config-path ./biome.jsonc --no-errors-on-unmatched --files-ignore-unknown=true --diagnostic-level=error && bun run lint:proto",
+		"lint:proto": "bash ./scripts/proto-lint.sh",
+		"analyze:unused": "bunx --yes knip --config knip.json --include files,exports,types,enumMembers,duplicates",
+		"analyze:unused:prod": "bunx --yes knip --config knip.json --production --include files,exports,types,enumMembers,dependencies",
+		"analyze:unused:fix-exports": "node scripts/remove-unused-exports.mjs --apply",
+		"analyze:unused:fix-exports:dry": "node scripts/remove-unused-exports.mjs",
+		"format": "biome format --config-path ./biome.jsonc --changed --since main --no-errors-on-unmatched --files-ignore-unknown=true --diagnostic-level=error --semicolons=as-needed",
+		"format:fix": "biome check --config-path ./biome.jsonc --changed --since main --no-errors-on-unmatched --files-ignore-unknown=true --write --semicolons=as-needed",
+		"fix:all": "biome check --config-path ./biome.jsonc --no-errors-on-unmatched --files-ignore-unknown=true --write --diagnostic-level=error --unsafe --semicolons=as-needed",
+		"ci:check-all": "bun run --parallel check-types lint format",
+		"ci:build": "bun run protos && bun run build:webview && bun esbuild.mjs && bun run compile-tests",
+		"pretest": "bun run compile && bun run compile-tests && bun run compile-standalone && bun run lint",
+		"test": "bun run test:unit && bun run test:integration",
+		"test:integration": "bun run compile-tests && vscode-test",
+		"test:unit": "bun scripts/run-bun-unit-tests.ts",
+		"test:vitest": "vitest run --config vitest.config.ts",
+		"test:vitest:watch": "vitest --config vitest.config.ts",
+		"test:bun": "bun scripts/run-bun-tests.ts",
+		"test:bun:unit": "bun scripts/run-bun-unit-tests.ts",
+		"test:coverage": "bun run compile-tests && vscode-test --coverage",
+		"test:sca-server": "bun --watch scripts/test-standalone-core-api-server.ts",
+		"test:tp-orchestrator": "bun scripts/testing-platform-orchestrator.ts",
+		"dev:mcp-oauth-test-server": "bun src/dev/mcp-oauth-test-server/server.ts",
+		"e2e": "playwright test -c playwright.config.ts",
+		"test:e2e:build": "vsce package --no-dependencies --allow-package-secrets sendgrid --out dist/e2e.vsix",
+		"test:e2e": "playwright install && bun run test:e2e:build && node src/test/e2e/utils/build.mjs && playwright test",
+		"test:e2e:optimal": "bun run test:e2e:build && node src/test/e2e/utils/build.mjs && playwright test",
+		"test:e2e:ui": "bun scripts/interactive-playwright.ts",
+		"install:all": "bun install",
+		"dev:webview": "node scripts/clean-webview-vite-cache.mjs && cd webview-ui && bun run dev",
+		"build:webview": "bun run protos && cd webview-ui && bun run build",
+		"test:webview": "cd webview-ui && bun run test",
+		"publish:marketplace": "node scripts/publish-marketplace.mjs",
+		"publish:marketplace:prerelease": "node scripts/publish-marketplace.mjs --pre-release",
+		"publish:marketplace:nightly": "node ./scripts/publish-nightly.mjs",
+		"docs": "cd docs && bun run dev",
+		"docs:check-links": "cd docs && bun run check",
+		"docs:rename-file": "cd docs && bun run rename",
+		"report-issue": "node scripts/report-issue.js",
+		"storybook": "cd webview-ui && bun run storybook",
+		"eval:smoke:run": "bun evals/smoke-tests/run-smoke-tests.ts"
+	},
+	"lint-staged": {
+		"src/shared/storage/state-keys.ts": [
+			"node scripts/generate-state-proto.mjs",
+			"git add apps/vscode/proto/cline/state.proto"
+		],
+		"*": [
+			"biome check --write --staged --no-errors-on-unmatched --files-ignore-unknown=true --semicolons=as-needed"
+		]
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.14",
+		"@bufbuild/buf": "^1.54.0",
+		"@microsoft/tui-test": "0.0.1",
+		"@types/better-sqlite3": "^7.6.13",
+		"@types/chai": "^5.0.1",
+		"@types/clone-deep": "^4.0.4",
+		"@types/get-folder-size": "^3.0.4",
+		"@types/js-yaml": "^4.0.9",
+		"@types/mocha": "^10.0.7",
+		"@types/node": "20.x",
+		"@types/pdf-parse": "^1.1.4",
+		"@types/picomatch": "^4.0.2",
+		"@types/shell-quote": "^1.7.5",
+		"@types/should": "^11.2.0",
+		"@types/sinon": "^21.0.0",
+		"@types/turndown": "^5.0.5",
+		"@types/vscode": "1.84.0",
+		"@vscode/test-cli": "^0.0.12",
+		"@vscode/test-electron": "^2.5.2",
+		"@vscode/vsce": "^3.6.0",
+		"c8": "^10.1.3",
+		"chai": "^4.3.10",
+		"chalk": "5.6.2",
+		"dotenv": "^17.2.3",
+		"esbuild": "^0.25.0",
+		"glob": "^11.0.0",
+		"grpc-tools": "^1.13.0",
+		"lint-staged": "^16.1.0",
+		"minimatch": "^3.0.3",
+		"minimist": "^1.2.8",
+		"mocha": "^11.7.4",
+		"playwright": "^1.55.1",
+		"prebuild-install": "^7.1.3",
+		"protoc-gen-ts": "^0.8.7",
+		"rimraf": "^6.0.1",
+		"should": "^13.2.3",
+		"sinon": "^21.0.3",
+		"tar": "^7.5.2",
+		"tree-kill": "^1.2.2",
+		"ts-proto": "^2.6.1",
+		"tsconfig-paths": "^4.2.0",
+		"typescript": "^5.4.5",
+		"vitest": "^4.0.17"
+	},
+	"dependencies": {
+		"@anthropic-ai/sdk": "^0.37.0",
+		"@bufbuild/protobuf": "^2.2.5",
+		"@cline/agents": "workspace:*",
+		"@cline/core": "workspace:*",
+		"@cline/llms": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"@google/genai": "^1.30.0",
+		"@grpc/grpc-js": "^1.9.15",
+		"@grpc/proto-loader": "^0.7.13",
+		"@grpc/reflection": "^1.0.4",
+		"@modelcontextprotocol/sdk": "^1.25.1",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.56.0",
+		"@opentelemetry/core": "^2.1.0",
+		"@opentelemetry/exporter-logs-otlp-grpc": "^0.56.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",
+		"@opentelemetry/exporter-logs-otlp-proto": "^0.56.0",
+		"@opentelemetry/exporter-metrics-otlp-grpc": "^0.56.0",
+		"@opentelemetry/exporter-metrics-otlp-http": "^0.56.0",
+		"@opentelemetry/exporter-metrics-otlp-proto": "^0.56.0",
+		"@opentelemetry/exporter-prometheus": "^0.56.0",
+		"@opentelemetry/exporter-trace-otlp-http": "^0.56.0",
+		"@opentelemetry/instrumentation": "^0.205.0",
+		"@opentelemetry/instrumentation-http": "^0.205.0",
+		"@opentelemetry/resources": "^1.30.1",
+		"@opentelemetry/sdk-logs": "^0.56.0",
+		"@opentelemetry/sdk-metrics": "^1.30.1",
+		"@opentelemetry/sdk-node": "^0.56.0",
+		"@opentelemetry/sdk-trace-base": "^2.1.0",
+		"@opentelemetry/sdk-trace-node": "^1.30.1",
+		"@opentelemetry/semantic-conventions": "^1.37.0",
+		"@playwright/test": "^1.55.1",
+		"@streamparser/json": "^0.0.22",
+		"@tailwindcss/vite": "^4.1.14",
+		"@types/uuid": "^10.0.0",
+		"@vscode/codicons": "^0.0.36",
+		"archiver": "^7.0.1",
+		"aws4fetch": "^1.0.20",
+		"axios": "1.16.1",
+		"better-sqlite3": "^12.4.1",
+		"cheerio": "^1.0.0",
+		"chokidar": "^4.0.1",
+		"chrome-launcher": "^1.1.2",
+		"clone-deep": "^4.0.1",
+		"default-shell": "^2.2.0",
+		"diff": "8.0.4",
+		"exceljs": "^4.4.0",
+		"execa": "^9.5.2",
+		"fast-deep-equal": "^3.1.3",
+		"fzf": "^0.5.2",
+		"get-folder-size": "^5.0.0",
+		"globby": "^14.0.2",
+		"grpc-health-check": "^2.0.2",
+		"iconv-lite": "^0.6.3",
+		"ignore": "^7.0.3",
+		"image-size": "^2.0.2",
+		"isbinaryfile": "^5.0.2",
+		"js-yaml": "^4.1.1",
+		"jschardet": "^3.1.4",
+		"json5": "^2.2.3",
+		"jwt-decode": "^4.0.0",
+		"mammoth": "^1.11.0",
+		"nanoid": "^5.1.6",
+		"nice-grpc": "^2.1.12",
+		"nice-grpc-common": "^2.0.3",
+		"node-machine-id": "^1.1.12",
+		"open": "^10.1.2",
+		"open-graph-scraper": "^6.9.0",
+		"openai": "^6.21.0",
+		"os-name": "^6.0.0",
+		"p-mutex": "^1.0.0",
+		"p-timeout": "^6.1.4",
+		"p-wait-for": "^5.0.2",
+		"pdf-parse": "^1.1.1",
+		"picomatch": "^4.0.3",
+		"posthog-node": "^5.8.0",
+		"puppeteer-chromium-resolver": "^23.0.0",
+		"puppeteer-core": "^23.4.0",
+		"reconnecting-eventsource": "^1.6.4",
+		"serialize-error": "^11.0.3",
+		"shell-quote": "^1.8.3",
+		"simple-git": "3.36.0",
+		"strip-ansi": "^7.1.2",
+		"tailwindcss": "^4.1.14",
+		"ts-morph": "^25.0.1",
+		"turndown": "^7.2.0",
+		"ulid": "^2.4.0",
+		"undici": "^7.26.0",
+		"uuid": "^11.1.0",
+		"vscode-uri": "^3.1.0",
+		"zod": "^4.3.6"
+	},
+	"c8": {
+		"reporter": [
+			"lcov",
+			"html"
+		],
+		"exclude": [
+			"**/testing-platform/**",
+			"**/webview-ui/**",
+			"**/.vscode-test/**",
+			"**/node_modules/**",
+			"node_modules",
+			"**/dist-standalone/src/**",
+			"**/dist-standalone/vsce-extension/https:/**",
+			"**/dist-standalone/vsce-extension/**",
+			"**/dist-standalone/https:/**",
+			"**/dist-standalone/LIB/src/**",
+			"**/dist-standalone/pdfjs-dist/**",
+			"**/*.d.ts",
+			"**/*.{test,spec}.{js,jsx,ts,tsx,mjs,cjs}",
+			"**/__tests__/**",
+			"**/test/**",
+			"**/tests/**",
+			"**/.nyc_output/**",
+			"**/tests-results/**",
+			"src/test/**",
+			"**/src/xml/**",
+			"**/standalone/**",
+			"**/src/generated/**",
+			"dist"
+		],
+		"all": true,
+		"exclude-after-remap": true
+	}
+}
diff --git a/apps/vscode/playwright.config.ts b/apps/vscode/playwright.config.ts
new file mode 100644
index 0000000..cf64edd
--- /dev/null
+++ b/apps/vscode/playwright.config.ts
@@ -0,0 +1,31 @@
+import { defineConfig } from "@playwright/test"
+
+const isCI = !!process?.env?.CI
+const isWindow = process?.platform?.startsWith("win")
+
+export default defineConfig({
+	workers: 1,
+	retries: 1,
+	forbidOnly: isCI,
+	testDir: "src/test/e2e",
+	testMatch: /.*\.test\.ts/,
+	timeout: isCI || isWindow ? 60000 : 20000,
+	expect: {
+		timeout: isCI || isWindow ? 5000 : 2000,
+	},
+	fullyParallel: true,
+	reporter: isCI ? [["github"], ["list"]] : [["list"]],
+	use: {
+		video: "retain-on-failure",
+	},
+	projects: [
+		{
+			name: "setup test environment",
+			testMatch: /global\.setup\.ts/,
+		},
+		{
+			name: "e2e tests",
+			dependencies: ["setup test environment"],
+		},
+	],
+})
diff --git a/apps/vscode/proto/cline/account.proto b/apps/vscode/proto/cline/account.proto
new file mode 100644
index 0000000..92a272a
--- /dev/null
+++ b/apps/vscode/proto/cline/account.proto
@@ -0,0 +1,158 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Service for account-related operations
+service AccountService {
+  // Handles the user clicking the login link in the UI.
+  // Generates a secure nonce for state validation, stores it in secrets,
+  // and opens the authentication URL in the external browser.
+  rpc accountLoginClicked(EmptyRequest) returns (String);
+
+  // Handles the user clicking the logout button in the UI.
+  // Clears API keys and user state.
+  rpc accountLogoutClicked(EmptyRequest) returns (Empty);
+
+  // Subscribe to auth status update events (when authentication state changes)
+  rpc subscribeToAuthStatusUpdate(EmptyRequest) returns (stream AuthState);
+
+  // Handles authentication state changes from the Firebase context.
+  // Updates the user info in global state and returns the updated value.
+  rpc authStateChanged(AuthStateChangedRequest) returns (AuthState);
+
+  // Fetches all user credits data
+  // (balance, usage transactions, payment transactions)
+  rpc getUserCredits(EmptyRequest) returns (UserCreditsData);
+
+  rpc getOrganizationCredits(GetOrganizationCreditsRequest) returns (OrganizationCreditsData);
+
+  // Fetches all user organizations data
+  // Returns a list of UserOrganization objects
+  rpc getUserOrganizations(EmptyRequest) returns (UserOrganizationsResponse);
+
+  rpc setUserOrganization(UserOrganizationUpdateRequest) returns (Empty);
+
+  rpc openrouterAuthClicked(EmptyRequest) returns (Empty);
+
+  rpc requestyAuthClicked(StringRequest) returns (Empty);
+
+  rpc hicapAuthClicked(EmptyRequest) returns (Empty);
+
+  // Returns a link the webview can use to redirect back to the user's IDE.
+  rpc getRedirectUrl(EmptyRequest) returns (String);
+
+  // OpenAI Codex OAuth authentication
+  // Starts the OAuth flow and opens browser for user to sign in with ChatGPT Plus/Pro
+  rpc openAiCodexSignIn(EmptyRequest) returns (Empty);
+
+  // Signs out of OpenAI Codex and clears stored credentials
+  rpc openAiCodexSignOut(EmptyRequest) returns (Empty);
+
+  // Submits a spend limit increase request to the user's org admin.
+  // Called when the user hits a SPEND_LIMIT_EXCEEDED (429) error and clicks "Request Increase".
+  rpc submitLimitIncreaseRequest(EmptyRequest) returns (SubmitLimitIncreaseResponse);
+}
+
+message AuthStateChangedRequest {
+  Metadata metadata = 1;
+  UserInfo user = 2;
+}
+
+message AuthState {
+  optional UserInfo user = 1;
+}
+
+// User's information
+message UserInfo {
+  string uid = 1;
+  optional string display_name = 2;
+  optional string email = 3;
+  optional string photo_url = 4;
+  optional string app_base_url = 5; // Cline app base URL
+}
+
+message UserOrganization {
+  bool active = 1;
+  string member_id = 2;
+  string name = 3;
+  string organization_id = 4;
+  repeated string roles = 5; // ["admin", "member", "owner"]
+}
+
+message UserOrganizationsResponse {
+  repeated UserOrganization organizations = 1;
+}
+
+message UserOrganizationUpdateRequest {
+  optional string organization_id = 1;
+}
+
+message UserCreditsData {
+  UserCreditsBalance balance = 1;
+  repeated UsageTransaction usage_transactions = 2;
+  repeated PaymentTransaction payment_transactions = 3;
+}
+
+message GetOrganizationCreditsRequest {
+  string organization_id = 1;
+}
+
+message OrganizationCreditsData {
+  UserCreditsBalance balance = 1;
+  string organization_id = 2;
+  repeated OrganizationUsageTransaction usage_transactions = 3;
+}
+
+message UserCreditsBalance {
+  double current_balance = 1;
+}
+
+message UsageTransaction {
+  string ai_inference_provider_name = 1;
+  string ai_model_name = 2;
+  string ai_model_type_name = 3;
+  int32 completion_tokens = 4;
+  double cost_usd = 5;
+  string created_at = 6;
+  double credits_used = 7;
+  string generation_id = 8;
+  string organization_id = 9;
+  int32 prompt_tokens = 10;
+  int32 total_tokens = 11;
+  string user_id = 12;
+  string operation = 13;
+}
+
+// Response from a spend limit increase request submission
+message SubmitLimitIncreaseResponse {
+  bool success = 1;
+}
+
+message PaymentTransaction {
+  string paid_at = 1;
+  string creator_id = 2;
+  int32 amount_cents = 3;
+  double credits = 4;
+}
+
+message OrganizationUsageTransaction {
+  string ai_inference_provider_name = 1;
+  string ai_model_name = 2;
+  string ai_model_type_name = 3;
+  int32 completion_tokens = 4;
+  double cost_usd = 5;
+  string created_at = 6;
+  double credits_used = 7;
+  string generation_id = 8;
+  string organization_id = 9;
+  int32 prompt_tokens = 10;
+  int32 total_tokens = 11;
+  string user_id = 12;
+  string operation = 13;
+}
diff --git a/apps/vscode/proto/cline/browser.proto b/apps/vscode/proto/cline/browser.proto
new file mode 100644
index 0000000..7ba8ff2
--- /dev/null
+++ b/apps/vscode/proto/cline/browser.proto
@@ -0,0 +1,58 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service BrowserService {
+  rpc getBrowserConnectionInfo(EmptyRequest) returns (BrowserConnectionInfo);
+  rpc testBrowserConnection(StringRequest) returns (BrowserConnection);
+  rpc discoverBrowser(EmptyRequest) returns (BrowserConnection);
+  rpc getDetectedChromePath(EmptyRequest) returns (ChromePath);
+  rpc relaunchChromeDebugMode(EmptyRequest) returns (String);
+}
+
+message BrowserConnectionInfo {
+  bool is_connected = 1;
+  bool is_remote = 2;
+  optional string host = 3;
+}
+
+message BrowserConnection {
+  bool success = 1;
+  string message = 2;
+  optional string endpoint = 3;
+}
+
+message ChromePath {
+  string path = 1;
+  bool is_bundled = 2;
+}
+
+message Viewport {
+  int32 width = 1;
+  int32 height = 2;
+}
+
+message BrowserSettings {
+  Viewport viewport = 1;
+  optional string remote_browser_host = 2;
+  optional bool remote_browser_enabled = 3;
+  optional string chrome_executable_path = 4;
+  optional bool disable_tool_use = 5;
+  optional string custom_args = 6;
+}
+
+message UpdateBrowserSettingsRequest {
+  Metadata metadata = 1;
+  Viewport viewport = 2;
+  optional string remote_browser_host = 3;
+  optional bool remote_browser_enabled = 4;
+  optional string chrome_executable_path = 5;
+  optional bool disable_tool_use = 6;
+  optional string custom_args = 7;
+}
diff --git a/apps/vscode/proto/cline/checkpoints.proto b/apps/vscode/proto/cline/checkpoints.proto
new file mode 100644
index 0000000..d785f28
--- /dev/null
+++ b/apps/vscode/proto/cline/checkpoints.proto
@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service CheckpointsService {
+  rpc checkpointRestore(CheckpointRestoreRequest) returns (Empty);
+}
+
+message CheckpointRestoreRequest {
+  Metadata metadata = 1;
+  int64 number = 2;
+  string restore_type = 3;
+  optional int64 offset = 4;
+}
diff --git a/apps/vscode/proto/cline/commands.proto b/apps/vscode/proto/cline/commands.proto
new file mode 100644
index 0000000..ea5e8cb
--- /dev/null
+++ b/apps/vscode/proto/cline/commands.proto
@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Service for running IDE commands, for example context menu actions,
+// commands, etc.
+// In contrast to the rest of the ProtoBus services, these are
+// intended to be called by the IDE directly instead of through the webview,
+// because they are triggered by interactions in the IDE.
+service CommandsService {
+  rpc addToCline(CommandContext) returns (Empty);
+  rpc fixWithCline(CommandContext) returns (Empty);
+  rpc explainWithCline(CommandContext) returns (Empty);
+  rpc improveWithCline(CommandContext) returns (Empty);
+}
+
+message CommandContext {
+  // The absolute path of the current file.
+  optional string file_path = 1;
+  // The selected source text.
+  optional string selected_text = 2;
+  // The language identifier for the current file.
+  optional string language = 3;
+  // Any diagnostic problems for the current file.
+  repeated cline.Diagnostic diagnostics = 4;
+}
diff --git a/apps/vscode/proto/cline/common.proto b/apps/vscode/proto/cline/common.proto
new file mode 100644
index 0000000..83014ec
--- /dev/null
+++ b/apps/vscode/proto/cline/common.proto
@@ -0,0 +1,97 @@
+syntax = "proto3";
+
+package cline;
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+message Metadata {}
+
+message EmptyRequest {}
+
+message Empty {}
+
+message StringRequest {
+  string value = 2;
+}
+
+message StringArrayRequest {
+  repeated string value = 2;
+}
+
+message String {
+  string value = 1;
+}
+
+message Int64Request {
+  int64 value = 2;
+}
+
+message Int64 {
+  int64 value = 1;
+}
+
+message BytesRequest {
+  bytes value = 2;
+}
+
+message Bytes {
+  bytes value = 1;
+}
+
+message BooleanRequest {
+  bool value = 2;
+}
+
+message Boolean {
+  bool value = 1;
+}
+
+// the same as Boolean, but avoiding name conflicts
+message BooleanResponse {
+  bool value = 1;
+}
+
+message StringArray {
+  repeated string values = 1;
+}
+
+message StringArrays {
+  repeated string values1 = 1;
+  repeated string values2 = 2;
+}
+
+message KeyValuePair {
+  string key = 1;
+  string value = 2;
+}
+
+message FileDiagnostics {
+  string file_path = 1;
+  repeated Diagnostic diagnostics = 2;
+}
+
+message Diagnostic {
+  string message = 1;
+  DiagnosticRange range = 2;
+  DiagnosticSeverity severity = 3;
+  optional string source = 4;
+}
+
+message DiagnosticRange {
+  DiagnosticPosition start = 1;
+  DiagnosticPosition end = 2;
+}
+
+message DiagnosticPosition {
+  int32 line = 1;
+  int32 character = 2;
+}
+
+enum DiagnosticSeverity {
+  DIAGNOSTIC_ERROR = 0;
+  DIAGNOSTIC_WARNING = 1;
+  DIAGNOSTIC_INFORMATION = 2;
+  DIAGNOSTIC_HINT = 3;
+}
diff --git a/apps/vscode/proto/cline/file.proto b/apps/vscode/proto/cline/file.proto
new file mode 100644
index 0000000..de15470
--- /dev/null
+++ b/apps/vscode/proto/cline/file.proto
@@ -0,0 +1,346 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Service for file-related operations
+service FileService {
+  // Copies text to clipboard
+  rpc copyToClipboard(StringRequest) returns (Empty);
+
+  // Opens a file in the editor
+  rpc openFile(StringRequest) returns (Empty);
+
+  // Opens an image in the system viewer
+  rpc openImage(StringRequest) returns (Empty);
+
+  // Opens a mention (file, path, git commit, problem, terminal, or URL)
+  rpc openMention(StringRequest) returns (Empty);
+
+  // Deletes a rule file from either global or workspace rules directory
+  rpc deleteRuleFile(RuleFileRequest) returns (RuleFile);
+
+  // Creates a rule file from either global or workspace rules directory
+  rpc createRuleFile(RuleFileRequest) returns (RuleFile);
+
+  // Search git commits in the workspace
+  rpc searchCommits(StringRequest) returns (GitCommits);
+
+  // Select images and other files from the file system and returns as data URLs & paths respectively
+  rpc selectFiles(BooleanRequest) returns (StringArrays);
+
+  // Convert URIs to workspace-relative paths
+  rpc getRelativePaths(RelativePathsRequest) returns (RelativePaths);
+
+  // Search for files in the workspace with fuzzy matching
+  rpc searchFiles(FileSearchRequest) returns (FileSearchResults);
+
+  // Toggle a Cline rule (enable or disable)
+  rpc toggleClineRule(ToggleClineRuleRequest) returns (ToggleClineRules);
+
+  // Toggle a Cursor rule (enable or disable)
+  rpc toggleCursorRule(ToggleCursorRuleRequest) returns (ClineRulesToggles);
+
+  // Toggle a Windsurf rule (enable or disable)
+  rpc toggleWindsurfRule(ToggleWindsurfRuleRequest) returns (ClineRulesToggles);
+
+  // Toggle an Agents rule (enable or disable)
+  rpc toggleAgentsRule(ToggleAgentsRuleRequest) returns (ClineRulesToggles);
+
+  // Refreshes all rule toggles (Cline, External, and Workflows)
+  rpc refreshRules(EmptyRequest) returns (RefreshedRules);
+
+  // Opens a task's conversation history file on disk
+  rpc openDiskConversationHistory(StringRequest) returns (Empty);
+
+  // Toggles a workflow on or off
+  rpc toggleWorkflow(ToggleWorkflowRequest) returns (ClineRulesToggles);
+
+  // Check if file exists in the project
+  rpc ifFileExistsRelativePath(StringRequest) returns (BooleanResponse);
+
+  // Open a file in editor by a relative path
+  rpc openFileRelativePath(StringRequest) returns (Empty);
+
+  // Opens or creates a focus chain checklist markdown file for editing
+  rpc openFocusChainFile(StringRequest) returns (Empty);
+
+  // Refreshes all hook toggles (discovers hooks and their enabled state)
+  rpc refreshHooks(EmptyRequest) returns (HooksToggles);
+
+  // Toggles a hook on or off via chmod +x/-x
+  rpc toggleHook(ToggleHookRequest) returns (ToggleHookResponse);
+
+  // Creates a new hook from template
+  rpc createHook(CreateHookRequest) returns (CreateHookResponse);
+
+  // Deletes an existing hook file
+  rpc deleteHook(DeleteHookRequest) returns (DeleteHookResponse);
+
+  // Refreshes all skill toggles (discovers skills and their enabled state)
+  rpc refreshSkills(EmptyRequest) returns (RefreshedSkills);
+
+  // Toggles a skill on or off
+  rpc toggleSkill(ToggleSkillRequest) returns (SkillsToggles);
+
+  // Creates a new skill from template
+  rpc createSkillFile(CreateSkillRequest) returns (SkillsToggles);
+
+  // Deletes an existing skill directory
+  rpc deleteSkillFile(DeleteSkillRequest) returns (SkillsToggles);
+}
+
+// Response for refreshRules operation
+message RefreshedRules {
+  ClineRulesToggles global_cline_rules_toggles = 1;
+  ClineRulesToggles local_cline_rules_toggles = 2;
+  ClineRulesToggles local_cursor_rules_toggles = 3;
+  ClineRulesToggles local_windsurf_rules_toggles = 4;
+  ClineRulesToggles local_agents_rules_toggles = 5;
+  ClineRulesToggles local_workflow_toggles = 6;
+  ClineRulesToggles global_workflow_toggles = 7;
+}
+
+// Request to toggle a Windsurf rule
+message ToggleWindsurfRuleRequest {
+  Metadata metadata = 1;
+  string rule_path = 2; // Path to the rule file
+  bool enabled = 3; // Whether to enable or disable the rule
+}
+
+// Request to toggle an Agents rule
+message ToggleAgentsRuleRequest {
+  Metadata metadata = 1;
+  string rule_path = 2; // Path to the rule file
+  bool enabled = 3; // Whether to enable or disable the rule
+}
+
+// Request to convert a list of URIs to relative paths
+message RelativePathsRequest {
+  Metadata metadata = 1;
+  repeated string uris = 2;
+}
+
+// Response containing the converted relative paths
+message RelativePaths {
+  repeated string paths = 1;
+}
+
+// Enum for file search type filtering
+enum FileSearchType {
+  FILE = 0;
+  FOLDER = 1;
+}
+
+// Request for file search operations
+message FileSearchRequest {
+  Metadata metadata = 1;
+  string query = 2; // Search query string
+  optional string mentions_request_id = 3; // Optional request ID for tracking requests
+  optional int32 limit = 4; // Optional limit for results (default: 20)
+  optional FileSearchType selected_type = 5; // Optional selected type filter
+  optional string workspace_hint = 6; // Optional workspace name to search in
+}
+
+// Result for file search operations
+message FileSearchResults {
+  repeated FileInfo results = 1; // Array of file/folder results
+  optional string mentions_request_id = 2; // Echo of the request ID for tracking
+  // Machine-readable reason for an empty result list. Unset on success.
+  // Known values:
+  //   "workspace_not_ready"   - host project model not yet loaded; retry-able.
+  //   "workspace_unavailable" - no workspace path; configuration error.
+  //   "ripgrep_spawn_failed"  - rg binary failed to spawn or exited non-zero.
+  //   "results_truncated"     - result cap hit (reserved for Phase 2C).
+  //   "unknown"               - catch-all; see error_message.
+  optional string error_reason = 3;
+  // Optional human-readable detail; rendered as a subtitle in the picker UI.
+  optional string error_message = 4;
+}
+
+// File information structure for search results
+message FileInfo {
+  string path = 1; // Relative path from workspace root
+  string type = 2; // "file" or "folder"
+  optional string label = 3; // Display name (usually basename)
+  optional string workspace_name = 4; // Workspace this result came from
+}
+
+// Response for searchCommits
+message GitCommits {
+  repeated GitCommit commits = 1;
+}
+
+// Represents a Git commit
+message GitCommit {
+  string hash = 1;
+  string short_hash = 2;
+  string subject = 3;
+  string author = 4;
+  string date = 5;
+}
+
+// Unified request for all rule file operations
+message RuleFileRequest {
+  Metadata metadata = 1;
+  bool is_global = 2; // Common field for all operations
+  optional string rule_path = 3; // Path field for deleteRuleFile (optional)
+  optional string filename = 4; // Filename field for createRuleFile (optional)
+  optional string type = 5; // Type of the file to create (optional)
+}
+
+// Result for rule file operations with meaningful data only
+message RuleFile {
+  string file_path = 1; // Path to the rule file
+  string display_name = 2; // Filename for display purposes
+  bool already_exists = 3; // For createRuleFile, indicates if file already existed
+}
+
+// Enum for rule scope (local, global, or remote)
+enum RuleScope {
+  LOCAL = 0;
+  GLOBAL = 1;
+  REMOTE = 2;
+}
+
+// Request to toggle a Cline rule
+message ToggleClineRuleRequest {
+  Metadata metadata = 1;
+  RuleScope scope = 2; // Scope of the rule (local, global, or remote)
+  string rule_path = 3; // Path to the rule file
+  bool enabled = 4; // Whether to enable or disable the rule
+}
+
+// Maps from filepath to enabled/disabled status, matching app's ClineRulesToggles type
+message ClineRulesToggles {
+  map<string, bool> toggles = 1;
+}
+
+// Response for toggleClineRule operation
+message ToggleClineRules {
+  ClineRulesToggles global_cline_rules_toggles = 1;
+  ClineRulesToggles local_cline_rules_toggles = 2;
+  ClineRulesToggles remote_rules_toggles = 3;
+}
+
+// Request to toggle a Cursor rule
+message ToggleCursorRuleRequest {
+  Metadata metadata = 1;
+  string rule_path = 2; // Path to the rule file
+  bool enabled = 3; // Whether to enable or disable the rule
+}
+
+// Request to toggle a workflow on or off
+message ToggleWorkflowRequest {
+  Metadata metadata = 1;
+  string workflow_path = 2;
+  bool enabled = 3;
+  RuleScope scope = 4; // Scope of the workflow (local, global, or remote)
+}
+
+// Maps from hook name to enabled/disabled status
+message HookInfo {
+  string name = 1;
+  bool enabled = 2;
+  string absolute_path = 3;
+}
+
+message WorkspaceHooks {
+  string workspace_name = 1;
+  repeated HookInfo hooks = 2;
+}
+
+message HooksToggles {
+  repeated HookInfo global_hooks = 1;
+  repeated WorkspaceHooks workspace_hooks = 2;
+  bool is_windows = 3; // Whether the system is Windows (toggles disabled)
+}
+
+// Request to toggle a hook
+message ToggleHookRequest {
+  Metadata metadata = 1;
+  string hook_name = 2; // Name of the hook (e.g., "TaskStart")
+  bool is_global = 3; // Whether this is a global or workspace hook
+  bool enabled = 4; // Whether to enable (chmod +x) or disable (chmod -x)
+  optional string workspace_name = 5; // For multi-root workspaces, specifies which workspace
+}
+
+// Response for toggleHook operation
+message ToggleHookResponse {
+  HooksToggles hooks_toggles = 1;
+}
+
+// Request to create a hook
+message CreateHookRequest {
+  Metadata metadata = 1;
+  string hook_name = 2; // Name of the hook to create
+  bool is_global = 3; // Whether to create in global or workspace hooks directory
+  optional string workspace_name = 4; // For multi-root workspaces, specifies which workspace
+}
+
+// Response for createHook operation
+message CreateHookResponse {
+  HooksToggles hooks_toggles = 1;
+}
+
+// Request to delete a hook
+message DeleteHookRequest {
+  Metadata metadata = 1;
+  string hook_name = 2; // Name of the hook to delete
+  bool is_global = 3; // Whether this is a global or workspace hook
+  optional string workspace_name = 4; // For multi-root workspaces, specifies which workspace
+}
+
+// Response for deleteHook operation
+message DeleteHookResponse {
+  HooksToggles hooks_toggles = 1;
+}
+
+// Skill information structure
+message SkillInfo {
+  string name = 1; // Name of the skill (matches directory name)
+  string description = 2; // Description from SKILL.md frontmatter
+  string path = 3; // Full path to SKILL.md file (or "remote:<name>" for remote skills)
+  bool enabled = 4; // Whether the skill is enabled
+  bool always_enabled = 5; // Whether the skill is always enabled (remote only, user cannot toggle off)
+}
+
+// Response for refreshSkills operation
+message RefreshedSkills {
+  repeated SkillInfo global_skills = 1;
+  repeated SkillInfo local_skills = 2;
+}
+
+// Maps from skill path to enabled/disabled status
+message SkillsToggles {
+  map<string, bool> global_skills_toggles = 1;
+  map<string, bool> local_skills_toggles = 2;
+  map<string, bool> remote_skills_toggles = 3;
+}
+
+// Request to toggle a skill
+message ToggleSkillRequest {
+  Metadata metadata = 1;
+  string skill_path = 2; // Path to the skill directory
+  bool is_global = 3; // Whether this is a global or workspace skill
+  bool enabled = 4; // Whether to enable or disable the skill
+}
+
+// Request to create a skill
+message CreateSkillRequest {
+  Metadata metadata = 1;
+  string skill_name = 2; // Name of the skill to create
+  bool is_global = 3; // Whether to create in global or workspace skills directory
+}
+
+// Request to delete a skill
+message DeleteSkillRequest {
+  Metadata metadata = 1;
+  string skill_path = 2; // Path to the skill directory
+  bool is_global = 3; // Whether this is a global or workspace skill
+}
diff --git a/apps/vscode/proto/cline/hooks.proto b/apps/vscode/proto/cline/hooks.proto
new file mode 100644
index 0000000..9bca9bb
--- /dev/null
+++ b/apps/vscode/proto/cline/hooks.proto
@@ -0,0 +1,143 @@
+syntax = "proto3";
+
+package cline;
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Input message for all hooks
+message HookInput {
+  string cline_version = 1;
+  string hook_name = 2;
+  string timestamp = 3;
+  string task_id = 4;
+  repeated string workspace_roots = 5;
+  string user_id = 6;
+  HookModelContext model = 7;
+  oneof data {
+    PreToolUseData pre_tool_use = 10;
+    PostToolUseData post_tool_use = 11;
+    UserPromptSubmitData user_prompt_submit = 12;
+    TaskStartData task_start = 13;
+    TaskResumeData task_resume = 14;
+    TaskCancelData task_cancel = 15;
+    TaskCompleteData task_complete = 16;
+    PreCompactData pre_compact = 17;
+    NotificationData notification = 18;
+  }
+}
+
+message HookModelContext {
+  string provider = 1;
+  string slug = 2;
+}
+
+// Output message for all hooks
+message HookOutput {
+  string context_modification = 1;
+  bool cancel = 2;
+  string error_message = 3;
+}
+
+// Data for PreToolUse hook
+message PreToolUseData {
+  string tool_name = 1;
+  map<string, string> parameters = 2;
+}
+
+// Data for PostToolUse hook
+message PostToolUseData {
+  string tool_name = 1;
+  map<string, string> parameters = 2;
+  string result = 3;
+  bool success = 4;
+  int64 execution_time_ms = 5;
+}
+
+// Data for UserPromptSubmit hook
+message UserPromptSubmitData {
+  string prompt = 1;
+  repeated string attachments = 2;
+}
+
+// Data for Notification hook
+message NotificationData {
+  string event = 1;
+  string source = 2;
+  string message = 3;
+  bool waiting_for_user_input = 4;
+  string event_version = 5;
+  string event_id = 6;
+  bool message_truncated = 7;
+  string source_type = 8;
+  string source_id = 9;
+  bool requires_user_action = 10;
+  string severity = 11;
+}
+
+// Data for TaskStart hook
+message TaskStartData {
+  map<string, string> task_metadata = 1;
+}
+
+// Data for TaskResume hook
+message TaskResumeData {
+  map<string, string> task_metadata = 1;
+  map<string, string> previous_state = 2;
+}
+
+// Data for TaskCancel hook
+message TaskCancelData {
+  map<string, string> task_metadata = 1;
+}
+
+// Data for TaskComplete hook
+message TaskCompleteData {
+  map<string, string> task_metadata = 1;
+}
+
+// Data for PreCompact hook
+message PreCompactData {
+  // Task identification
+  string task_id = 1;
+  string ulid = 2;
+
+  // Context size information
+  int64 context_size = 3; // Number of messages in API conversation history
+
+  // Compaction strategy indicating how conversation history is managed:
+  // * auto-condense:                   AI-powered compression using summarize_task tool
+  // * standard-truncation-firstpair:   Keep only the original task (used during auto-condense)
+  // * standard-truncation-lasthalf:    Keep first pair + most recent 50% of conversation
+  // * standard-truncation-lastquarter: Keep first pair + most recent 25% of conversation (aggressive)
+  string compaction_strategy = 4;
+
+  // API request tracking
+  int64 previous_api_req_index = 5; // Index of last API request in clineMessages
+
+  // Token usage data from last API request
+  int64 tokens_in = 6;
+  int64 tokens_out = 7;
+  int64 tokens_in_cache = 8;
+  int64 tokens_out_cache = 9;
+
+  // Truncation information (if applicable)
+  int32 deleted_range_start = 10; // Start index of deleted conversation range
+  int32 deleted_range_end = 11; // End index of deleted conversation range
+
+  // Context JSON file path
+  // Path to a temporary JSON file containing the full API conversation history
+  // The file contains an array of message objects with role and content
+  // Hooks can read this file to analyze conversation contents before compaction
+  // This file will be automatically cleaned up after the hook completes
+  string context_json_path = 12;
+
+  // Context raw/formatted file path
+  // Path to a temporary text file containing the complete context window sent to the LLM
+  // This includes the system prompt, environment details, conversation history, and all formatting
+  // Represents the actual input the LLM receives (format varies by provider)
+  // Use this to analyze total context size, overhead, and exactly what the model sees
+  // This file will be automatically cleaned up after the hook completes
+  string context_raw_path = 13;
+}
diff --git a/apps/vscode/proto/cline/marketplace.proto b/apps/vscode/proto/cline/marketplace.proto
new file mode 100644
index 0000000..1c6173e
--- /dev/null
+++ b/apps/vscode/proto/cline/marketplace.proto
@@ -0,0 +1,106 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service MarketplaceService {
+  rpc getMarketplaceCatalog(EmptyRequest) returns (MarketplaceCatalog);
+  rpc listMarketplaceLocalInstalledEntries(EmptyRequest) returns (MarketplaceLocalInstalledEntries);
+  rpc listMarketplaceInstalledEntries(MarketplaceEntriesRequest) returns (MarketplaceInstalledEntries);
+  rpc installMarketplaceEntry(MarketplaceEntryRequest) returns (MarketplaceInstallResult);
+  rpc uninstallMarketplaceEntry(MarketplaceEntryRequest) returns (MarketplaceInstallResult);
+  rpc toggleMarketplaceLocalInstalledEntry(ToggleMarketplaceLocalInstalledEntryRequest) returns (MarketplaceLocalInstalledEntries);
+  rpc uninstallMarketplaceLocalInstalledEntry(MarketplaceLocalInstalledEntryRequest) returns (MarketplaceInstallResult);
+}
+
+message MarketplaceTag {
+  string label = 1;
+  optional string color = 2;
+}
+
+message MarketplaceCounts {
+  optional int32 tools = 1;
+  optional int32 prompts = 2;
+  optional int32 resources = 3;
+}
+
+message MarketplaceEnvVar {
+  string name = 1;
+  bool required = 2;
+  optional string description = 3;
+  optional string url = 4;
+}
+
+message MarketplaceInstall {
+  repeated string args = 1;
+  repeated MarketplaceEnvVar env = 2;
+  optional string command = 3;
+  optional string notes = 4;
+}
+
+message MarketplaceEntry {
+  string id = 1;
+  string type = 2;
+  string name = 3;
+  optional string tagline = 4;
+  optional string description = 5;
+  repeated string tags = 6;
+  repeated MarketplaceTag tag_objects = 7;
+  optional string author = 8;
+  optional string source_url = 9;
+  optional string homepage_url = 10;
+  optional MarketplaceCounts counts = 11;
+  optional MarketplaceInstall install = 12;
+}
+
+message MarketplaceCatalog {
+  repeated MarketplaceEntry entries = 1;
+}
+
+message MarketplaceEntriesRequest {
+  repeated MarketplaceEntry entries = 1;
+}
+
+message MarketplaceInstalledEntries {
+  repeated string installed_keys = 1;
+}
+
+message MarketplaceLocalInstalledEntry {
+  string id = 1;
+  string type = 2;
+  string name = 3;
+  optional string description = 4;
+  optional string path = 5;
+  optional string source = 6;
+  bool enabled = 7;
+}
+
+message MarketplaceLocalInstalledEntries {
+  repeated MarketplaceLocalInstalledEntry entries = 1;
+}
+
+message ToggleMarketplaceLocalInstalledEntryRequest {
+  MarketplaceLocalInstalledEntry entry = 1;
+  bool enabled = 2;
+}
+
+message MarketplaceLocalInstalledEntryRequest {
+  MarketplaceLocalInstalledEntry entry = 1;
+}
+
+message MarketplaceEntryRequest {
+  MarketplaceEntry entry = 1;
+}
+
+message MarketplaceInstallResult {
+  string id = 1;
+  string type = 2;
+  string status = 3;
+  string message = 4;
+  optional string output = 5;
+}
diff --git a/apps/vscode/proto/cline/mcp.proto b/apps/vscode/proto/cline/mcp.proto
new file mode 100644
index 0000000..7b7b290
--- /dev/null
+++ b/apps/vscode/proto/cline/mcp.proto
@@ -0,0 +1,111 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service McpService {
+  rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
+  rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
+  rpc addRemoteMcpServer(AddRemoteMcpServerRequest) returns (McpServers);
+  rpc restartMcpServer(StringRequest) returns (McpServers);
+  rpc deleteMcpServer(StringRequest) returns (McpServers);
+  rpc toggleToolAutoApprove(ToggleToolAutoApproveRequest) returns (McpServers);
+  rpc openMcpSettings(EmptyRequest) returns (Empty);
+  rpc authenticateMcpServer(StringRequest) returns (Empty);
+  rpc getLatestMcpServers(Empty) returns (McpServers);
+
+  // Subscribe to MCP server updates
+  rpc subscribeToMcpServers(EmptyRequest) returns (stream McpServers);
+}
+
+message ToggleMcpServerRequest {
+  Metadata metadata = 1;
+  string server_name = 2;
+  bool disabled = 3;
+}
+
+message UpdateMcpTimeoutRequest {
+  Metadata metadata = 1;
+  string server_name = 2;
+  int32 timeout = 3;
+}
+
+message AddRemoteMcpServerRequest {
+  Metadata metadata = 1;
+  string server_name = 2;
+  string server_url = 3;
+  optional string transport_type = 4;
+}
+
+message ToggleToolAutoApproveRequest {
+  Metadata metadata = 1;
+  string server_name = 2;
+  repeated string tool_names = 3;
+  bool auto_approve = 4;
+}
+
+message McpTool {
+  string name = 1;
+  optional string description = 2;
+  optional string input_schema = 3;
+  optional bool auto_approve = 4;
+}
+
+message McpResource {
+  string uri = 1;
+  string name = 2;
+  optional string mime_type = 3;
+  optional string description = 4;
+}
+
+message McpResourceTemplate {
+  string uri_template = 1;
+  string name = 2;
+  optional string mime_type = 3;
+  optional string description = 4;
+}
+
+message McpPromptArgument {
+  string name = 1;
+  optional string description = 2;
+  optional bool required = 3;
+}
+
+message McpPrompt {
+  string name = 1;
+  optional string title = 2;
+  optional string description = 3;
+  repeated McpPromptArgument arguments = 4;
+}
+
+enum McpServerStatus {
+  // Protobuf enums (in proto3) must have a zero value defined, which serves as the default if the field isn't explicitly set.
+  // To align with the required nature of the TypeScript type and avoid an unnecessary UNSPECIFIED state, we map one of the existing statuses to this zero value.
+  MCP_SERVER_STATUS_DISCONNECTED = 0; // default
+  MCP_SERVER_STATUS_CONNECTED = 1;
+  MCP_SERVER_STATUS_CONNECTING = 2;
+}
+
+message McpServer {
+  string name = 1;
+  string config = 2;
+  McpServerStatus status = 3;
+  optional string error = 4;
+  repeated McpTool tools = 5;
+  repeated McpResource resources = 6;
+  repeated McpResourceTemplate resource_templates = 7;
+  optional bool disabled = 8;
+  optional int32 timeout = 9;
+  optional bool oauth_required = 10;
+  optional string oauth_auth_status = 11;
+  repeated McpPrompt prompts = 12;
+}
+
+message McpServers {
+  repeated McpServer mcp_servers = 1;
+}
diff --git a/apps/vscode/proto/cline/models.proto b/apps/vscode/proto/cline/models.proto
new file mode 100644
index 0000000..95f2f30
--- /dev/null
+++ b/apps/vscode/proto/cline/models.proto
@@ -0,0 +1,800 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+import "google/protobuf/field_mask.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Service for model-related operations
+service ModelsService {
+  // Fetches available models from Ollama
+  rpc getOllamaModels(StringRequest) returns (StringArray);
+  // Fetches available models from LM Studio
+  rpc getLmStudioModels(StringRequest) returns (StringArray);
+  // Fetches available models from VS Code LM API
+  rpc getVsCodeLmModels(EmptyRequest) returns (VsCodeLmModelsArray);
+  // Refreshes and returns OpenRouter models
+  rpc refreshOpenRouterModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns recommended and free Cline models
+  rpc refreshClineRecommendedModelsRpc(EmptyRequest) returns (ClineRecommendedModelsResponse);
+  // Refreshes and returns Hugging Face models
+  rpc refreshHuggingFaceModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns OpenAI models
+  rpc refreshOpenAiModels(OpenAiModelsRequest) returns (StringArray);
+  // Refreshes and returns Requesty models
+  rpc refreshRequestyModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns Hicap models
+  rpc refreshHicapModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns LiteLLM models
+  rpc refreshLiteLlmModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Subscribe to OpenRouter models updates
+  rpc subscribeToOpenRouterModels(EmptyRequest) returns (stream OpenRouterCompatibleModelInfo);
+  // Subscribe to LiteLLM models updates
+  rpc subscribeToLiteLlmModels(EmptyRequest) returns (stream OpenRouterCompatibleModelInfo);
+  // Updates API configuration (legacy - uses combined configuration)
+  rpc updateApiConfigurationProto(UpdateApiConfigurationRequest) returns (Empty);
+  // Updates API configuration (new - uses separate options and secrets)
+  rpc updateApiConfiguration(UpdateApiConfigurationRequestNew) returns (Empty);
+  // Updates API configuration with partial values (only updates fields that are explicitly set)
+  rpc updateApiConfigurationPartial(UpdateApiConfigurationPartialRequest) returns (Empty);
+  // Refreshes and returns Groq models
+  rpc refreshGroqModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns Baseten models
+  rpc refreshBasetenModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Fetches available models from SAP AI Core
+  rpc getSapAiCoreModels(SapAiCoreModelsRequest) returns (SapAiCoreModelsResponse);
+  // Fetches available models from OCA
+  rpc refreshOcaModels(StringRequest) returns (OcaCompatibleModelInfo);
+  // Fetches available models from AIhubmix
+  rpc getAihubmixModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns Vercel AI Gateway models
+  rpc refreshVercelAiGatewayModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Lists providers available from the unified SDK-backed catalog
+  rpc listProviders(Empty) returns (ProviderListingsResponse);
+  // Resolves model metadata for a provider through the unified SDK-backed catalog
+  rpc resolveProviderModels(ResolveProviderModelsRequest) returns (ProviderModelsResponse);
+  // Resolves model metadata for a provider/model without refreshing model lists
+  rpc resolveModelInfo(ResolveModelInfoRequest) returns (ResolveModelInfoResponse);
+  // Reads redacted effective provider configuration
+  rpc readProviderConfig(StringRequest) returns (ProviderConfigResponse);
+  // Writes provider configuration fields and returns redacted effective configuration
+  rpc writeProviderConfig(WriteProviderConfigRequest) returns (ProviderConfigResponse);
+  // Commits a mode-specific model selection atomically with its model metadata
+  rpc commitModelSelection(CommitModelSelectionRequest) returns (Empty);
+}
+
+// List of VS Code LM models
+message VsCodeLmModelsArray {
+  repeated LanguageModelChatSelector models = 1;
+}
+
+// Structure representing a language model chat selector
+message LanguageModelChatSelector {
+  optional string vendor = 1;
+  optional string family = 2;
+  optional string version = 3;
+  optional string id = 4;
+}
+
+// Price tier for tiered pricing models
+message PriceTier {
+  int64 token_limit = 1; // Upper limit (inclusive) of input tokens for this price
+  double price = 2; // Price per million tokens for this tier
+}
+
+// Thinking configuration for models that support thinking/reasoning
+message ThinkingConfig {
+  optional int64 max_budget = 1; // Max allowed thinking budget tokens
+  optional double output_price = 2; // Output price per million tokens when budget > 0
+  repeated PriceTier output_price_tiers = 3; // Optional: Tiered output price when budget > 0
+}
+
+// Model tier for tiered pricing structures
+message ModelTier {
+  int64 context_window = 1;
+  optional double input_price = 2;
+  optional double output_price = 3;
+  optional double cache_writes_price = 4;
+  optional double cache_reads_price = 5;
+}
+
+// For OpenRouterCompatibleModelInfo structure in OpenRouterModels
+message OpenRouterModelInfo {
+  optional int64 max_tokens = 1;
+  optional int64 context_window = 2;
+  optional bool supports_images = 3;
+  bool supports_prompt_cache = 4;
+  optional double input_price = 5;
+  optional double output_price = 6;
+  optional double cache_writes_price = 7;
+  optional double cache_reads_price = 8;
+  optional string description = 9;
+  optional ThinkingConfig thinking_config = 10;
+  optional bool supports_global_endpoint = 11;
+  repeated ModelTier tiers = 12;
+  optional string name = 13;
+  optional double temperature = 14;
+  optional bool supports_reasoning = 15;
+  optional ApiFormat api_format = 16;
+}
+
+// Shared response message for model information
+message OpenRouterCompatibleModelInfo {
+  map<string, OpenRouterModelInfo> models = 1;
+}
+
+// Lightweight provider entry for the top-level model/provider picker.
+// Does not include the full model list; use resolveProviderModels for models.
+message ProviderListing {
+  string id = 1;
+  string name = 2;
+  optional string default_model_id = 3;
+  optional string family = 4;
+  optional string protocol = 5;
+  optional string auth_description = 6;
+  optional string base_url_description = 7;
+  bool allows_custom_model_ids = 8;
+
+  // SDK-driven hint for cost display. Values: "show" (default) or "hide".
+  // Sourced from `resolveProviderUsageCostDisplay(provider.metadata)` in
+  // `@cline/llms`. When "hide", consumers must suppress per-token pricing
+  // and total cost displays (matches the CLI's `shouldShowCliUsageCost`).
+  string usage_cost_display = 11;
+}
+
+message ProviderListingsResponse {
+  repeated ProviderListing providers = 1;
+}
+
+message ResolveProviderModelsRequest {
+  string provider_id = 1;
+  bool force_refresh = 2;
+  optional string request_id = 3;
+}
+
+message CatalogErrorInfo {
+  string kind = 1;
+  string message = 2;
+  optional string code = 3;
+  optional bool retryable = 4;
+}
+
+message ProviderModelsResponse {
+  string provider_id = 1;
+  string request_id = 2;
+  string config_fingerprint = 3;
+  int64 fetched_at = 4;
+  bool ok = 5;
+  map<string, OpenRouterModelInfo> models = 6;
+  optional string default_model_id = 7;
+  optional string source = 8;
+  optional CatalogErrorInfo error = 9;
+}
+
+message ResolveModelInfoRequest {
+  string provider_id = 1;
+  optional string model_id = 2;
+}
+
+message ResolveModelInfoResponse {
+  string provider_id = 1;
+  string model_id = 2;
+  optional OpenRouterModelInfo model_info = 3;
+  string source = 4;
+}
+
+message AwsProviderConfig {
+  optional string authentication = 1;
+  optional string profile = 2;
+  optional string access_key = 3;
+  int64 access_key_length = 4;
+  optional string secret_key = 5;
+  int64 secret_key_length = 6;
+  optional string session_token = 7;
+  int64 session_token_length = 8;
+  optional string endpoint = 9;
+  optional bool use_prompt_cache = 10;
+  optional string custom_model_base_id = 11;
+  optional bool use_cross_region_inference = 12;
+  optional bool use_global_inference = 13;
+}
+
+message GcpProviderConfig {
+  optional string project_id = 1;
+  optional string region = 2;
+}
+
+message ProviderConfigResponse {
+  string provider_id = 1;
+  optional string base_url = 2;
+  optional string api_line = 3;
+  map<string, string> headers = 4;
+  optional string region = 5;
+  int64 api_key_length = 6;
+  bool has_access_token = 7;
+  bool has_refresh_token = 8;
+  optional string account_id = 9;
+  optional CommittedModelSelection plan_selection = 10;
+  optional CommittedModelSelection act_selection = 11;
+  optional AwsProviderConfig aws = 12;
+  optional GcpProviderConfig gcp = 13;
+}
+
+message CommittedModelSelection {
+  string provider_id = 1;
+  string model_id = 2;
+  OpenRouterModelInfo model_info = 3;
+}
+
+message ProviderReasoningPatch {
+  optional bool enabled = 1;
+  optional string effort = 2; // "none" | "low" | "medium" | "high" | "xhigh"
+  optional int32 budget_tokens = 3;
+}
+
+message WriteProviderConfigPatch {
+  optional string api_key = 1;
+  optional string base_url = 2;
+  map<string, string> headers = 3;
+  optional string region = 4;
+  optional string api_line = 5;
+  optional string access_token = 6;
+  optional string refresh_token = 7;
+  optional string account_id = 8;
+  optional ProviderReasoningPatch reasoning = 9;
+  optional bool clear_headers = 10;
+  optional AwsProviderConfig aws = 11;
+  optional GcpProviderConfig gcp = 12;
+}
+
+message WriteProviderConfigRequest {
+  string provider_id = 1;
+  WriteProviderConfigPatch patch = 2;
+}
+
+message CommitModelSelectionRequest {
+  string provider_id = 1;
+  string mode = 2;
+  string model_id = 3;
+  OpenRouterModelInfo model_info = 4;
+}
+
+message ClineRecommendedModel {
+  string id = 1;
+  string name = 2;
+  string description = 3;
+  repeated string tags = 4;
+}
+
+message ClineRecommendedModelsResponse {
+  repeated ClineRecommendedModel recommended = 1;
+  repeated ClineRecommendedModel free = 2;
+  repeated ClineRecommendedModel cline_pass = 3;
+}
+
+// Request for fetching OpenAI models
+message OpenAiModelsRequest {
+  Metadata metadata = 1;
+  string base_url = 2;
+  string api_key = 3;
+}
+
+// Request for fetching SAP AI Core models
+message SapAiCoreModelsRequest {
+  Metadata metadata = 1;
+  string client_id = 2;
+  string client_secret = 3;
+  string base_url = 4;
+  string token_url = 5;
+  string resource_group = 6;
+}
+
+// SAP AI Core model with deployment information
+message SapAiCoreModelDeployment {
+  string model_name = 1;
+  string deployment_id = 2;
+}
+
+// Response for SAP AI Core models with orchestration availability
+message SapAiCoreModelsResponse {
+  repeated SapAiCoreModelDeployment deployments = 1;
+  bool orchestration_available = 2;
+}
+
+// API secrets (credentials, API keys)
+message ModelsApiSecrets {
+  optional string api_key = 1;
+  optional string cline_api_key = 2;
+  optional string lite_llm_api_key = 3;
+  optional string open_router_api_key = 4;
+  optional string aws_access_key = 5;
+  optional string aws_secret_key = 6;
+  optional string aws_session_token = 7;
+  optional string aws_bedrock_api_key = 8;
+  optional string open_ai_api_key = 9;
+  optional string ollama_api_key = 10;
+  optional string gemini_api_key = 11;
+  optional string open_ai_native_api_key = 12;
+  optional string deep_seek_api_key = 13;
+  optional string requesty_api_key = 14;
+  optional string together_api_key = 15;
+  optional string fireworks_api_key = 16;
+  optional string qwen_api_key = 17;
+  optional string doubao_api_key = 18;
+  optional string mistral_api_key = 19;
+  optional string nebius_api_key = 20;
+  optional string asksage_api_key = 21;
+  optional string xai_api_key = 22;
+  optional string sambanova_api_key = 23;
+  optional string cerebras_api_key = 24;
+  optional string sap_ai_core_client_id = 25;
+  optional string sap_ai_core_client_secret = 26;
+  optional string moonshot_api_key = 27;
+  optional string cline_account_id = 28;
+  optional string groq_api_key = 29;
+  optional string hugging_face_api_key = 30;
+  optional string huawei_cloud_maas_api_key = 31;
+  optional string baseten_api_key = 32;
+  optional string zai_api_key = 33;
+  optional string vercel_ai_gateway_api_key = 34;
+  optional string dify_api_key = 35;
+  optional string oca_api_key = 36;
+  optional string oca_refresh_token = 37;
+  optional string minimax_api_key = 38;
+  optional string aihubmix_api_key = 39;
+}
+
+// API configuration options (non-secret settings)
+message ModelsApiOptions {
+  // Global configuration fields (not mode-specific)
+  optional string ulid = 1;
+  optional string lite_llm_base_url = 2;
+  optional bool lite_llm_use_prompt_cache = 3;
+  map<string, string> open_ai_headers = 4;
+  optional string anthropic_base_url = 5;
+  optional string open_router_provider_sorting = 6;
+  optional string aws_region = 7;
+  optional bool aws_use_cross_region_inference = 8;
+  optional bool aws_bedrock_use_prompt_cache = 9;
+  optional bool aws_use_profile = 10;
+  optional string aws_profile = 11;
+  optional string aws_bedrock_endpoint = 12;
+  optional string claude_code_path = 13;
+  optional string vertex_project_id = 14;
+  optional string vertex_region = 15;
+  optional string open_ai_base_url = 16;
+  optional string ollama_base_url = 17;
+  optional string ollama_api_options_ctx_num = 18;
+  optional string lm_studio_base_url = 19;
+  optional string gemini_base_url = 20;
+  optional string requesty_base_url = 21;
+  optional int64 fireworks_model_max_completion_tokens = 22;
+  optional int64 fireworks_model_max_tokens = 23;
+  optional string azure_api_version = 24;
+  optional string qwen_api_line = 25;
+  optional string asksage_api_url = 26;
+  optional int64 request_timeout_ms = 27;
+  optional string sap_ai_resource_group = 28;
+  optional string sap_ai_core_token_url = 29;
+  optional string sap_ai_core_base_url = 30;
+  optional bool sap_ai_core_use_orchestration_mode = 31;
+  optional string moonshot_api_line = 32;
+  optional string aws_authentication = 33;
+  optional string zai_api_line = 34;
+  optional string lm_studio_max_tokens = 35;
+  optional string qwen_code_oauth_path = 36;
+  optional string dify_base_url = 37;
+  optional string oca_base_url = 38;
+  optional string oca_mode = 39;
+  optional bool aws_use_global_inference = 40;
+  optional string minimax_api_line = 41;
+  optional string aihubmix_base_url = 42;
+  optional string aihubmix_app_code = 43;
+  optional bool azure_identity = 44;
+
+  // Plan mode configurations
+  optional string plan_mode_api_provider = 100;
+  optional string plan_mode_api_model_id = 101;
+  optional int64 plan_mode_thinking_budget_tokens = 102;
+  optional string plan_mode_reasoning_effort = 103;
+  optional LanguageModelChatSelector plan_mode_vs_code_lm_model_selector = 104;
+  optional bool plan_mode_aws_bedrock_custom_selected = 105;
+  optional string plan_mode_aws_bedrock_custom_model_base_id = 106;
+  optional string plan_mode_open_router_model_id = 107;
+  optional OpenRouterModelInfo plan_mode_open_router_model_info = 108;
+  optional string plan_mode_open_ai_model_id = 109;
+  optional OpenAiCompatibleModelInfo plan_mode_open_ai_model_info = 110;
+  optional string plan_mode_ollama_model_id = 111;
+  optional string plan_mode_lm_studio_model_id = 112;
+  optional string plan_mode_lite_llm_model_id = 113;
+  optional LiteLLMModelInfo plan_mode_lite_llm_model_info = 114;
+  optional string plan_mode_requesty_model_id = 115;
+  optional OpenRouterModelInfo plan_mode_requesty_model_info = 116;
+  optional string plan_mode_together_model_id = 117;
+  optional string plan_mode_fireworks_model_id = 118;
+  optional string plan_mode_sap_ai_core_model_id = 119;
+  optional string plan_mode_sap_ai_core_deployment_id = 120;
+  optional string plan_mode_groq_model_id = 121;
+  optional OpenRouterModelInfo plan_mode_groq_model_info = 122;
+  optional string plan_mode_hugging_face_model_id = 123;
+  optional OpenRouterModelInfo plan_mode_hugging_face_model_info = 124;
+  optional string plan_mode_huawei_cloud_maas_model_id = 125;
+  optional OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 126;
+  optional string plan_mode_baseten_model_id = 127;
+  optional OpenRouterModelInfo plan_mode_baseten_model_info = 128;
+  optional string plan_mode_vercel_ai_gateway_model_id = 129;
+  optional OpenRouterModelInfo plan_mode_vercel_ai_gateway_model_info = 130;
+  optional string plan_mode_oca_model_id = 131;
+  optional OcaModelInfo plan_mode_oca_model_info = 132;
+  optional string plan_mode_aihubmix_model_id = 133;
+  optional OpenAiCompatibleModelInfo plan_mode_aihubmix_model_info = 134;
+  optional string plan_mode_cline_model_id = 135;
+  optional OpenRouterModelInfo plan_mode_cline_model_info = 136;
+  optional string plan_mode_cline_pass_model_id = 137;
+  optional OpenRouterModelInfo plan_mode_cline_pass_model_info = 138;
+
+  // Act mode configurations
+  optional string act_mode_api_provider = 200;
+  optional string act_mode_api_model_id = 201;
+  optional int64 act_mode_thinking_budget_tokens = 202;
+  optional string act_mode_reasoning_effort = 203;
+  optional LanguageModelChatSelector act_mode_vs_code_lm_model_selector = 204;
+  optional bool act_mode_aws_bedrock_custom_selected = 205;
+  optional string act_mode_aws_bedrock_custom_model_base_id = 206;
+  optional string act_mode_open_router_model_id = 207;
+  optional OpenRouterModelInfo act_mode_open_router_model_info = 208;
+  optional string act_mode_open_ai_model_id = 209;
+  optional OpenAiCompatibleModelInfo act_mode_open_ai_model_info = 210;
+  optional string act_mode_ollama_model_id = 211;
+  optional string act_mode_lm_studio_model_id = 212;
+  optional string act_mode_lite_llm_model_id = 213;
+  optional LiteLLMModelInfo act_mode_lite_llm_model_info = 214;
+  optional string act_mode_requesty_model_id = 215;
+  optional OpenRouterModelInfo act_mode_requesty_model_info = 216;
+  optional string act_mode_together_model_id = 217;
+  optional string act_mode_fireworks_model_id = 218;
+  optional string act_mode_sap_ai_core_model_id = 219;
+  optional string act_mode_sap_ai_core_deployment_id = 220;
+  optional string act_mode_groq_model_id = 221;
+  optional OpenRouterModelInfo act_mode_groq_model_info = 222;
+  optional string act_mode_hugging_face_model_id = 223;
+  optional OpenRouterModelInfo act_mode_hugging_face_model_info = 224;
+  optional string act_mode_huawei_cloud_maas_model_id = 225;
+  optional OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 226;
+  optional string act_mode_baseten_model_id = 227;
+  optional OpenRouterModelInfo act_mode_baseten_model_info = 228;
+  optional string act_mode_vercel_ai_gateway_model_id = 229;
+  optional OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 230;
+  optional string act_mode_oca_model_id = 231;
+  optional OcaModelInfo act_mode_oca_model_info = 232;
+  optional string act_mode_aihubmix_model_id = 233;
+  optional OpenAiCompatibleModelInfo act_mode_aihubmix_model_info = 234;
+  optional string act_mode_cline_model_id = 235;
+  optional OpenRouterModelInfo act_mode_cline_model_info = 236;
+  optional string act_mode_cline_pass_model_id = 237;
+  optional OpenRouterModelInfo act_mode_cline_pass_model_info = 238;
+}
+
+// Request for updating API configuration (legacy - uses combined configuration)
+message UpdateApiConfigurationRequest {
+  Metadata metadata = 1;
+  ModelsApiConfiguration api_configuration = 2;
+}
+
+// Combined API configuration containing both options and secrets
+message ApiConfiguration {
+  ModelsApiOptions options = 1;
+  ModelsApiSecrets secrets = 2;
+}
+
+// Request for updating API configuration (new - uses separate options and secrets)
+message UpdateApiConfigurationRequestNew {
+  Metadata metadata = 1;
+  ApiConfiguration updates = 2;
+
+  // Required field mask specifying which fields to update.
+  // Field paths use dot notation with camelCase field names:
+  // - "options.ulid" (for options fields)
+  // - "options.openAiHeaders" (for options fields)
+  // - "secrets.apiKey" (for secrets fields)
+  // - "secrets.openRouterApiKey" (for secrets fields)
+  repeated string update_mask = 3;
+}
+
+// Request for partially updating API configuration using FieldMask
+// Only fields specified in update_mask will be updated from api_configuration
+message UpdateApiConfigurationPartialRequest {
+  Metadata metadata = 1;
+
+  // The API configuration with values to update.
+  // Only fields listed in update_mask will be applied from this configuration.
+  ModelsApiConfiguration api_configuration = 2;
+
+  // Mask specifying which top-level fields from api_configuration to update.
+  // Field names should use camelCase (e.g., "apiKey", "planModeApiProvider").
+  // If a field is in the mask but not set in api_configuration, it will be cleared (set to undefined).
+  google.protobuf.FieldMask update_mask = 3;
+}
+
+// Model info for OCA (OpenAI-compatible) models exposed by the OCA provider
+message OcaModelInfo {
+  // Maximum completion tokens per request supported by this model
+  optional int64 max_tokens = 1;
+  // Total context window in tokens (input + output)
+  optional int64 context_window = 2;
+  // Whether the model supports image inputs
+  optional bool supports_images = 3;
+  // Whether prompt caching is supported for this model
+  bool supports_prompt_cache = 4;
+  // Price per million input tokens (USD unless otherwise specified by provider)
+  optional double input_price = 5;
+  // Price per million output tokens (USD unless otherwise specified by provider)
+  optional double output_price = 6;
+  // Thinking/reasoning configuration if the model supports it
+  optional ThinkingConfig thinking_config = 7;
+  // Price per million tokens for prompt cache writes
+  optional double cache_writes_price = 9;
+  // Price per million tokens for prompt cache reads
+  optional double cache_reads_price = 10;
+  // Human-readable model description
+  optional string description = 11;
+  // Recommended default temperature for this model
+  optional double temperature = 13;
+  // Optional survey content to display in the UI
+  optional string survey_content = 14;
+  // Identifier for the survey associated with this model
+  optional string survey_id = 15;
+  // Optional banner content (e.g., deprecation or promotion notes)
+  optional string banner = 16;
+  // Canonical model identifier as reported by OCA
+  string model_name = 17;
+  // The API format used by this model
+  optional ApiFormat api_format = 18;
+  // Supports reasoning
+  optional bool supports_reasoning = 19;
+  // reasoning effort options
+  repeated string reasoning_effort_options = 20;
+}
+
+// Aggregated OCA model catalog keyed by model identifier
+message OcaCompatibleModelInfo {
+  // key: canonical model id as reported by OCA (e.g., "openai/gpt-4o-mini")
+  // value: OcaModelInfo describing that model
+  map<string, OcaModelInfo> models = 1;
+  optional string error = 2;
+}
+
+enum ApiFormat {
+  ANTHROPIC_CHAT = 0;
+  GEMINI_CHAT = 1;
+  OPENAI_CHAT = 2;
+  R1_CHAT = 3;
+  OPENAI_RESPONSES = 4;
+  OPENAI_RESPONSES_WEBSOCKET_MODE = 5;
+}
+
+// Model info for OpenAI-compatible models
+message OpenAiCompatibleModelInfo {
+  optional int64 max_tokens = 1;
+  optional int64 context_window = 2;
+  optional bool supports_images = 3;
+  bool supports_prompt_cache = 4;
+  optional double input_price = 5;
+  optional double output_price = 6;
+  optional ThinkingConfig thinking_config = 7;
+  optional bool supports_global_endpoint = 8;
+  optional double cache_writes_price = 9;
+  optional double cache_reads_price = 10;
+  optional string description = 11;
+  repeated ModelTier tiers = 12;
+  optional double temperature = 13;
+  optional bool is_r1_format_required = 14;
+  optional ApiFormat api_format = 15;
+}
+
+// Model info for LiteLLM models
+message LiteLLMModelInfo {
+  optional int64 max_tokens = 1;
+  optional int64 context_window = 2;
+  optional bool supports_images = 3;
+  bool supports_prompt_cache = 4;
+  optional double input_price = 5;
+  optional double output_price = 6;
+  optional ThinkingConfig thinking_config = 7;
+  optional bool supports_global_endpoint = 8;
+  optional double cache_writes_price = 9;
+  optional double cache_reads_price = 10;
+  optional string description = 11;
+  repeated ModelTier tiers = 12;
+  optional double temperature = 13;
+  optional ApiFormat api_format = 14;
+  optional bool supports_reasoning = 15;
+}
+
+// Main ApiConfiguration message
+message ModelsApiConfiguration {
+  // Global configuration fields (not mode-specific)
+  optional string api_key = 1;
+  optional string cline_api_key = 2;
+  optional string ulid = 3;
+  optional string lite_llm_base_url = 4;
+  optional string lite_llm_api_key = 5;
+  optional bool lite_llm_use_prompt_cache = 6;
+  map<string, string> open_ai_headers = 7;
+  optional string anthropic_base_url = 8;
+  optional string open_router_api_key = 9;
+  optional string open_router_provider_sorting = 10;
+  optional string aws_access_key = 11;
+  optional string aws_secret_key = 12;
+  optional string aws_session_token = 13;
+  optional string aws_region = 14;
+  optional bool aws_use_cross_region_inference = 15;
+  optional bool aws_bedrock_use_prompt_cache = 16;
+  optional bool aws_use_profile = 17;
+  optional string aws_profile = 18;
+  optional string aws_bedrock_endpoint = 19;
+  optional string claude_code_path = 20;
+  optional string vertex_project_id = 21;
+  optional string vertex_region = 22;
+  optional string open_ai_base_url = 23;
+  optional string open_ai_api_key = 24;
+  optional string ollama_base_url = 25;
+  optional string ollama_api_options_ctx_num = 26;
+  optional string lm_studio_base_url = 27;
+  optional string gemini_api_key = 28;
+  optional string gemini_base_url = 29;
+  optional string open_ai_native_api_key = 30;
+  optional string deep_seek_api_key = 31;
+  optional string requesty_api_key = 32;
+  optional string requesty_base_url = 33;
+  optional string together_api_key = 34;
+  optional string fireworks_api_key = 35;
+  optional int64 fireworks_model_max_completion_tokens = 36;
+  optional int64 fireworks_model_max_tokens = 37;
+  optional string qwen_api_key = 38;
+  optional string doubao_api_key = 39;
+  optional string mistral_api_key = 40;
+  optional string azure_api_version = 41;
+  optional string qwen_api_line = 42;
+  optional string nebius_api_key = 43;
+  optional string asksage_api_url = 44;
+  optional string asksage_api_key = 45;
+  optional string xai_api_key = 46;
+  optional string sambanova_api_key = 47;
+  optional string cerebras_api_key = 48;
+  optional int64 request_timeout_ms = 49;
+  optional string sap_ai_core_client_id = 50;
+  optional string sap_ai_core_client_secret = 51;
+  optional string sap_ai_resource_group = 52;
+  optional string sap_ai_core_token_url = 53;
+  optional string sap_ai_core_base_url = 54;
+  optional bool sap_ai_core_use_orchestration_mode = 55;
+  optional string moonshot_api_key = 56;
+  optional string moonshot_api_line = 57;
+  optional string aws_authentication = 58;
+  optional string aws_bedrock_api_key = 59;
+  optional string cline_account_id = 60;
+  optional string groq_api_key = 61;
+  optional string hugging_face_api_key = 62;
+  optional string huawei_cloud_maas_api_key = 63;
+  optional string baseten_api_key = 64;
+  optional string ollama_api_key = 65;
+  optional string zai_api_key = 66;
+  optional string zai_api_line = 67;
+  optional string lm_studio_max_tokens = 68;
+  optional string vercel_ai_gateway_api_key = 69;
+  optional string qwen_code_oauth_path = 70;
+  optional string dify_api_key = 71;
+  optional string dify_base_url = 72;
+  optional string oca_base_url = 73;
+  optional string oca_api_key = 74;
+  optional string oca_refresh_token = 75;
+  optional string oca_mode = 76;
+  optional bool aws_use_global_inference = 77;
+  optional string minimax_api_key = 78;
+  optional string minimax_api_line = 79;
+  optional string hicap_model_id = 80;
+  optional string hicap_api_key = 81;
+  optional string aihubmix_api_key = 82;
+  optional string aihubmix_base_url = 83;
+  optional string aihubmix_app_code = 84;
+  optional string nous_research_api_key = 85;
+  optional bool azure_identity = 86;
+  optional string wandb_api_key = 87;
+
+  // Plan mode configurations
+  optional string plan_mode_api_provider = 100;
+  optional string plan_mode_api_model_id = 101;
+  optional int64 plan_mode_thinking_budget_tokens = 102;
+  optional string plan_mode_reasoning_effort = 103;
+  optional LanguageModelChatSelector plan_mode_vs_code_lm_model_selector = 104;
+  optional bool plan_mode_aws_bedrock_custom_selected = 105;
+  optional string plan_mode_aws_bedrock_custom_model_base_id = 106;
+  optional string plan_mode_open_router_model_id = 107;
+  optional OpenRouterModelInfo plan_mode_open_router_model_info = 108;
+  optional string plan_mode_open_ai_model_id = 109;
+  optional OpenAiCompatibleModelInfo plan_mode_open_ai_model_info = 110;
+  optional string plan_mode_ollama_model_id = 111;
+  optional string plan_mode_lm_studio_model_id = 112;
+  optional string plan_mode_lite_llm_model_id = 113;
+  optional LiteLLMModelInfo plan_mode_lite_llm_model_info = 114;
+  optional string plan_mode_requesty_model_id = 115;
+  optional OpenRouterModelInfo plan_mode_requesty_model_info = 116;
+  optional string plan_mode_together_model_id = 117;
+  optional string plan_mode_fireworks_model_id = 118;
+  optional string plan_mode_sap_ai_core_model_id = 119;
+  optional string plan_mode_sap_ai_core_deployment_id = 120;
+  optional string plan_mode_groq_model_id = 121;
+  optional OpenRouterModelInfo plan_mode_groq_model_info = 122;
+  optional string plan_mode_hugging_face_model_id = 123;
+  optional OpenRouterModelInfo plan_mode_hugging_face_model_info = 124;
+  optional string plan_mode_huawei_cloud_maas_model_id = 125;
+  optional OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 126;
+  optional string plan_mode_baseten_model_id = 127;
+  optional OpenRouterModelInfo plan_mode_baseten_model_info = 128;
+  optional string plan_mode_vercel_ai_gateway_model_id = 129;
+  optional OpenRouterModelInfo plan_mode_vercel_ai_gateway_model_info = 130;
+  optional string plan_mode_oca_model_id = 131;
+  optional OcaModelInfo plan_mode_oca_model_info = 132;
+  optional string plan_mode_oca_reasoning_effort = 133;
+  optional string plan_mode_hicap_model_id = 134;
+  optional OpenRouterModelInfo plan_mode_hicap_model_info = 135;
+  optional string plan_mode_aihubmix_model_id = 136;
+  optional OpenAiCompatibleModelInfo plan_mode_aihubmix_model_info = 137;
+  optional string plan_mode_nous_research_model_id = 138;
+  optional string gemini_plan_mode_thinking_level = 139;
+  optional string plan_mode_cline_model_id = 140;
+  optional OpenRouterModelInfo plan_mode_cline_model_info = 141;
+  optional string plan_mode_cline_pass_model_id = 142;
+  optional OpenRouterModelInfo plan_mode_cline_pass_model_info = 143;
+
+  // Act mode configurations
+  optional string act_mode_api_provider = 200;
+  optional string act_mode_api_model_id = 201;
+  optional int64 act_mode_thinking_budget_tokens = 202;
+  optional string act_mode_reasoning_effort = 203;
+  optional LanguageModelChatSelector act_mode_vs_code_lm_model_selector = 204;
+  optional bool act_mode_aws_bedrock_custom_selected = 205;
+  optional string act_mode_aws_bedrock_custom_model_base_id = 206;
+  optional string act_mode_open_router_model_id = 207;
+  optional OpenRouterModelInfo act_mode_open_router_model_info = 208;
+  optional string act_mode_open_ai_model_id = 209;
+  optional OpenAiCompatibleModelInfo act_mode_open_ai_model_info = 210;
+  optional string act_mode_ollama_model_id = 211;
+  optional string act_mode_lm_studio_model_id = 212;
+  optional string act_mode_lite_llm_model_id = 213;
+  optional LiteLLMModelInfo act_mode_lite_llm_model_info = 214;
+  optional string act_mode_requesty_model_id = 215;
+  optional OpenRouterModelInfo act_mode_requesty_model_info = 216;
+  optional string act_mode_together_model_id = 217;
+  optional string act_mode_fireworks_model_id = 218;
+  optional string act_mode_sap_ai_core_model_id = 219;
+  optional string act_mode_sap_ai_core_deployment_id = 220;
+  optional string act_mode_groq_model_id = 221;
+  optional OpenRouterModelInfo act_mode_groq_model_info = 222;
+  optional string act_mode_hugging_face_model_id = 223;
+  optional OpenRouterModelInfo act_mode_hugging_face_model_info = 224;
+  optional string act_mode_huawei_cloud_maas_model_id = 225;
+  optional OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 226;
+  optional string act_mode_baseten_model_id = 227;
+  optional OpenRouterModelInfo act_mode_baseten_model_info = 228;
+  optional string act_mode_vercel_ai_gateway_model_id = 229;
+  optional OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 230;
+  optional string act_mode_oca_model_id = 231;
+  optional OcaModelInfo act_mode_oca_model_info = 232;
+  optional string act_mode_oca_reasoning_effort = 233;
+  optional string act_mode_hicap_model_id = 234;
+  optional OpenRouterModelInfo act_mode_hicap_model_info = 235;
+  optional string act_mode_aihubmix_model_id = 236;
+  optional OpenAiCompatibleModelInfo act_mode_aihubmix_model_info = 237;
+  optional string act_mode_nous_research_model_id = 238;
+  optional string gemini_act_mode_thinking_level = 239;
+  optional string act_mode_cline_model_id = 240;
+  optional OpenRouterModelInfo act_mode_cline_model_info = 241;
+  optional string act_mode_cline_pass_model_id = 242;
+  optional OpenRouterModelInfo act_mode_cline_pass_model_info = 243;
+}
diff --git a/apps/vscode/proto/cline/oca_account.proto b/apps/vscode/proto/cline/oca_account.proto
new file mode 100644
index 0000000..2be87c8
--- /dev/null
+++ b/apps/vscode/proto/cline/oca_account.proto
@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Service for account-related operations
+service OcaAccountService {
+  // Handles the user clicking the login link in the UI.
+  // Generates a secure nonce for state validation, stores it in secrets,
+  // and opens the authentication URL in the external browser.
+  rpc ocaAccountLoginClicked(EmptyRequest) returns (String);
+
+  // Handles the user clicking the logout button in the UI.
+  // Clears API keys and user state.
+  rpc ocaAccountLogoutClicked(EmptyRequest) returns (Empty);
+
+  // Subscribe to auth status update events (when authentication state changes)
+  rpc ocaSubscribeToAuthStatusUpdate(EmptyRequest) returns (stream OcaAuthState);
+}
+
+message OcaAuthState {
+  optional OcaUserInfo user = 1;
+  optional string api_key = 2;
+}
+
+// User's information
+message OcaUserInfo {
+  string uid = 1;
+  optional string display_name = 2;
+  optional string email = 3;
+}
diff --git a/apps/vscode/proto/cline/remote_config.proto b/apps/vscode/proto/cline/remote_config.proto
new file mode 100644
index 0000000..47ca66a
--- /dev/null
+++ b/apps/vscode/proto/cline/remote_config.proto
@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+enum RemoteConfigType {
+  RULE = 0;
+  WORKFLOW = 1;
+  SKILL = 2;
+}
+
+message RemoteConfigSetting {
+  RemoteConfigType type = 1;
+  string name = 2;
+  string content = 3;
+  bool enabled = 4;
+  bool locked = 5;
+}
+
+message RemoteConfigSettingsResponse {
+  repeated RemoteConfigSetting settings = 1;
+}
+
+service RemoteConfigService {
+  rpc getRemoteConfigSettings(Empty) returns (RemoteConfigSettingsResponse);
+  rpc toggleRemoteConfigSetting(StringRequest) returns (RemoteConfigSetting);
+}
diff --git a/apps/vscode/proto/cline/slash.proto b/apps/vscode/proto/cline/slash.proto
new file mode 100644
index 0000000..120b3d3
--- /dev/null
+++ b/apps/vscode/proto/cline/slash.proto
@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// SlashService provides methods for managing slash commands
+service SlashService {
+  // Sends button click message
+  rpc reportBug(StringRequest) returns (Empty);
+  rpc condense(StringRequest) returns (Empty);
+
+  // Get available slash commands for autocomplete (used by CLI)
+  rpc getAvailableSlashCommands(EmptyRequest) returns (SlashCommandsResponse);
+}
+
+// Slash command definition for autocomplete
+message SlashCommandInfo {
+  string name = 1; // Command name without slash, e.g., "newtask", "smol"
+  string description = 2; // Human-readable description
+  string section = 3; // "default", "custom", or "cli"
+  bool cli_compatible = 4; // false for VS Code-only commands
+}
+
+// Response containing all available slash commands
+message SlashCommandsResponse {
+  repeated SlashCommandInfo commands = 1;
+}
diff --git a/apps/vscode/proto/cline/state.proto b/apps/vscode/proto/cline/state.proto
new file mode 100644
index 0000000..533ce19
--- /dev/null
+++ b/apps/vscode/proto/cline/state.proto
@@ -0,0 +1,490 @@
+syntax = "proto3";
+package cline;
+
+import "cline/browser.proto";
+import "cline/common.proto";
+import "cline/models.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service StateService {
+  rpc getLatestState(EmptyRequest) returns (State);
+  rpc updateTerminalConnectionTimeout(UpdateTerminalConnectionTimeoutRequest) returns (UpdateTerminalConnectionTimeoutResponse);
+  rpc updateTerminalReuseEnabled(BooleanRequest) returns (Empty);
+  rpc getAvailableTerminalProfiles(EmptyRequest) returns (TerminalProfiles);
+  rpc subscribeToState(EmptyRequest) returns (stream State);
+  rpc toggleFavoriteModel(StringRequest) returns (Empty);
+  rpc resetState(ResetStateRequest) returns (Empty);
+  rpc togglePlanActModeProto(TogglePlanActModeRequest) returns (Boolean);
+  rpc updateAutoApprovalSettings(AutoApprovalSettingsRequest) returns (Empty);
+  rpc updateSettings(UpdateSettingsRequest) returns (Empty);
+  rpc updateSettingsCli(UpdateSettingsRequestCli) returns (Empty);
+  rpc updateTaskSettings(UpdateTaskSettingsRequest) returns (Empty);
+  rpc updateTelemetrySetting(TelemetrySettingRequest) returns (Empty);
+  rpc captureOnboardingProgress(OnboardingProgressRequest) returns (Empty);
+  rpc setWelcomeViewCompleted(BooleanRequest) returns (Empty);
+  rpc updateInfoBannerVersion(Int64Request) returns (Empty);
+  rpc updateModelBannerVersion(Int64Request) returns (Empty);
+  rpc updateCliBannerVersion(Int64Request) returns (Empty);
+  rpc dismissBanner(StringRequest) returns (Empty);
+  rpc trackBannerEvent(TrackBannerEventRequest) returns (Empty);
+  rpc installClineCli(EmptyRequest) returns (Empty);
+  rpc checkCliInstallation(EmptyRequest) returns (Boolean);
+  rpc getProcessInfo(EmptyRequest) returns (ProcessInfo);
+  rpc flushPendingState(EmptyRequest) returns (Empty);
+  rpc refreshRemoteConfig(EmptyRequest) returns (Empty);
+  rpc testOtelConnection(EmptyRequest) returns (TestConnectionResult);
+  rpc testPromptUploading(EmptyRequest) returns (TestConnectionResult);
+}
+
+message AutoApprovalActions {
+  optional bool read_files = 1;
+  optional bool read_files_externally = 2;
+  optional bool edit_files = 3;
+  optional bool edit_files_externally = 4;
+  optional bool execute_safe_commands = 5;
+  optional bool execute_all_commands = 6;
+  optional bool use_browser = 7;
+  optional bool use_mcp = 8;
+}
+
+// Auto approval settings for task execution
+message AutoApprovalSettings {
+  int32 version = 1;
+  AutoApprovalActions actions = 2;
+  optional bool enable_notifications = 3;
+}
+
+// NOTE: Add the new secret fields under SECRETS_KEYS in src/shared/storage/state-keys.ts
+// and use the scripts/generate-state-proto.mjs script to regenerate this list.
+message Secrets {
+  optional string api_key = 1;
+  optional string cline_account_id = 2;
+  optional string open_router_api_key = 3;
+  optional string aws_access_key = 4;
+  optional string aws_secret_key = 5;
+  optional string aws_session_token = 6;
+  optional string aws_bedrock_api_key = 7;
+  optional string open_ai_api_key = 8;
+  optional string gemini_api_key = 9;
+  optional string open_ai_native_api_key = 10;
+  optional string ollama_api_key = 11;
+  optional string deep_seek_api_key = 12;
+  optional string requesty_api_key = 13;
+  optional string together_api_key = 14;
+  optional string fireworks_api_key = 15;
+  optional string qwen_api_key = 16;
+  optional string doubao_api_key = 17;
+  optional string mistral_api_key = 18;
+  optional string lite_llm_api_key = 19;
+  optional string auth_nonce = 20;
+  optional string asksage_api_key = 21;
+  optional string xai_api_key = 22;
+  optional string moonshot_api_key = 23;
+  optional string zai_api_key = 24;
+  optional string hugging_face_api_key = 25;
+  optional string nebius_api_key = 26;
+  optional string sambanova_api_key = 27;
+  optional string cerebras_api_key = 28;
+  optional string sap_ai_core_client_id = 29;
+  optional string sap_ai_core_client_secret = 30;
+  optional string groq_api_key = 31;
+  optional string huawei_cloud_maas_api_key = 32;
+  optional string baseten_api_key = 33;
+  optional string vercel_ai_gateway_api_key = 34;
+  optional string dify_api_key = 35;
+  optional string minimax_api_key = 36;
+  optional string hicap_api_key = 37;
+  optional string aihubmix_api_key = 38;
+  optional string nous_research_api_key = 39;
+  optional string remote_lite_llm_api_key = 40;
+  optional string oca_api_key = 41;
+  optional string oca_refresh_token = 42;
+  optional string mcp_o_auth_secrets = 43;
+  optional string cline_api_key = 44;
+  optional string openai_codex_oauth_credentials = 48;
+  optional string wandb_api_key = 50;
+}
+
+// NOTE: Add new fields under API_HANDLER_SETTINGS_FIELDS or USER_SETTINGS_FIELDS
+// in src/shared/storage/state-keys.ts and use the scripts/generate-state-proto.mjs
+// script to regenerate this list.
+message Settings {
+  reserved 144, 154, 176;
+  reserved "cline_web_tools_enabled", "enable_parallel_tool_calling", "double_check_completion_enabled";
+
+  optional string lite_llm_base_url = 1;
+  optional bool lite_llm_use_prompt_cache = 2;
+  optional string anthropic_base_url = 4;
+  optional string open_router_provider_sorting = 5;
+  optional string aws_region = 6;
+  optional bool aws_use_cross_region_inference = 7;
+  optional bool aws_use_global_inference = 8;
+  optional bool aws_bedrock_use_prompt_cache = 9;
+  optional string aws_authentication = 10;
+  optional bool aws_use_profile = 11;
+  optional string aws_profile = 12;
+  optional string aws_bedrock_endpoint = 13;
+  optional string claude_code_path = 14;
+  optional string vertex_project_id = 15;
+  optional string vertex_region = 16;
+  optional string open_ai_base_url = 17;
+  optional string ollama_base_url = 18;
+  optional string ollama_api_options_ctx_num = 19;
+  optional string lm_studio_base_url = 20;
+  optional string lm_studio_max_tokens = 21;
+  optional string gemini_base_url = 22;
+  optional string requesty_base_url = 23;
+  optional int32 fireworks_model_max_completion_tokens = 24;
+  optional int32 fireworks_model_max_tokens = 25;
+  optional string qwen_code_oauth_path = 26;
+  optional string azure_api_version = 27;
+  optional bool azure_identity = 28;
+  optional string qwen_api_line = 29;
+  optional string moonshot_api_line = 30;
+  optional string asksage_api_url = 31;
+  optional int32 request_timeout_ms = 32;
+  optional string sap_ai_resource_group = 33;
+  optional string sap_ai_core_token_url = 34;
+  optional string sap_ai_core_base_url = 35;
+  optional bool sap_ai_core_use_orchestration_mode = 36;
+  optional string dify_base_url = 37;
+  optional string zai_api_line = 38;
+  optional string oca_base_url = 39;
+  optional string minimax_api_line = 40;
+  optional string oca_mode = 41;
+  optional string aihubmix_base_url = 42;
+  optional string aihubmix_app_code = 43;
+  optional string plan_mode_api_model_id = 44;
+  optional int64 plan_mode_thinking_budget_tokens = 45;
+  optional string gemini_plan_mode_thinking_level = 46;
+  optional string plan_mode_reasoning_effort = 47;
+  optional string plan_mode_verbosity = 48;
+  optional LanguageModelChatSelector plan_mode_vs_code_lm_model_selector = 49;
+  optional bool plan_mode_aws_bedrock_custom_selected = 50;
+  optional string plan_mode_aws_bedrock_custom_model_base_id = 51;
+  optional string plan_mode_open_router_model_id = 52;
+  optional OpenRouterModelInfo plan_mode_open_router_model_info = 53;
+  optional string plan_mode_open_ai_model_id = 54;
+  optional OpenAiCompatibleModelInfo plan_mode_open_ai_model_info = 55;
+  optional string plan_mode_ollama_model_id = 56;
+  optional string plan_mode_lm_studio_model_id = 57;
+  optional string plan_mode_lite_llm_model_id = 58;
+  optional LiteLLMModelInfo plan_mode_lite_llm_model_info = 59;
+  optional string plan_mode_requesty_model_id = 60;
+  optional OpenRouterModelInfo plan_mode_requesty_model_info = 61;
+  optional string plan_mode_together_model_id = 62;
+  optional string plan_mode_fireworks_model_id = 63;
+  optional string plan_mode_sap_ai_core_model_id = 64;
+  optional string plan_mode_sap_ai_core_deployment_id = 65;
+  optional string plan_mode_groq_model_id = 66;
+  optional OpenRouterModelInfo plan_mode_groq_model_info = 67;
+  optional string plan_mode_baseten_model_id = 68;
+  optional OpenRouterModelInfo plan_mode_baseten_model_info = 69;
+  optional string plan_mode_hugging_face_model_id = 70;
+  optional OpenRouterModelInfo plan_mode_hugging_face_model_info = 71;
+  optional string plan_mode_huawei_cloud_maas_model_id = 72;
+  optional OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 73;
+  optional string plan_mode_oca_model_id = 74;
+  optional OcaModelInfo plan_mode_oca_model_info = 75;
+  optional string plan_mode_oca_reasoning_effort = 76;
+  optional string plan_mode_aihubmix_model_id = 77;
+  optional OpenAiCompatibleModelInfo plan_mode_aihubmix_model_info = 78;
+  optional string plan_mode_hicap_model_id = 79;
+  optional OpenRouterModelInfo plan_mode_hicap_model_info = 80;
+  optional string plan_mode_nous_research_model_id = 81;
+  optional string plan_mode_vercel_ai_gateway_model_id = 82;
+  optional OpenRouterModelInfo plan_mode_vercel_ai_gateway_model_info = 83;
+  optional string act_mode_api_model_id = 84;
+  optional int64 act_mode_thinking_budget_tokens = 85;
+  optional string gemini_act_mode_thinking_level = 86;
+  optional string act_mode_reasoning_effort = 87;
+  optional string act_mode_verbosity = 88;
+  optional LanguageModelChatSelector act_mode_vs_code_lm_model_selector = 89;
+  optional bool act_mode_aws_bedrock_custom_selected = 90;
+  optional string act_mode_aws_bedrock_custom_model_base_id = 91;
+  optional string act_mode_open_router_model_id = 92;
+  optional OpenRouterModelInfo act_mode_open_router_model_info = 93;
+  optional string act_mode_open_ai_model_id = 94;
+  optional OpenAiCompatibleModelInfo act_mode_open_ai_model_info = 95;
+  optional string act_mode_ollama_model_id = 96;
+  optional string act_mode_lm_studio_model_id = 97;
+  optional string act_mode_lite_llm_model_id = 98;
+  optional LiteLLMModelInfo act_mode_lite_llm_model_info = 99;
+  optional string act_mode_requesty_model_id = 100;
+  optional OpenRouterModelInfo act_mode_requesty_model_info = 101;
+  optional string act_mode_together_model_id = 102;
+  optional string act_mode_fireworks_model_id = 103;
+  optional string act_mode_sap_ai_core_model_id = 104;
+  optional string act_mode_sap_ai_core_deployment_id = 105;
+  optional string act_mode_groq_model_id = 106;
+  optional OpenRouterModelInfo act_mode_groq_model_info = 107;
+  optional string act_mode_baseten_model_id = 108;
+  optional OpenRouterModelInfo act_mode_baseten_model_info = 109;
+  optional string act_mode_hugging_face_model_id = 110;
+  optional OpenRouterModelInfo act_mode_hugging_face_model_info = 111;
+  optional string act_mode_huawei_cloud_maas_model_id = 112;
+  optional OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 113;
+  optional string act_mode_oca_model_id = 114;
+  optional OcaModelInfo act_mode_oca_model_info = 115;
+  optional string act_mode_oca_reasoning_effort = 116;
+  optional string act_mode_aihubmix_model_id = 117;
+  optional OpenAiCompatibleModelInfo act_mode_aihubmix_model_info = 118;
+  optional string act_mode_hicap_model_id = 119;
+  optional OpenRouterModelInfo act_mode_hicap_model_info = 120;
+  optional string act_mode_nous_research_model_id = 121;
+  optional string act_mode_vercel_ai_gateway_model_id = 122;
+  optional OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 123;
+  optional string plan_mode_api_provider = 124;
+  optional string act_mode_api_provider = 125;
+  optional string hicap_model_id = 126;
+  optional string lm_studio_model_id = 127;
+  optional AutoApprovalSettings auto_approval_settings = 128;
+  optional string global_cline_rules_toggles = 129;
+  optional string global_workflow_toggles = 130;
+  optional string global_skills_toggles = 131;
+  optional BrowserSettings browser_settings = 132;
+  optional string telemetry_setting = 133;
+  optional bool plan_act_separate_models_setting = 134;
+  optional bool enable_checkpoints_setting = 135;
+  optional int32 shell_integration_timeout = 136;
+  optional string default_terminal_profile = 137;
+  optional int32 max_consecutive_mistakes = 139;
+  optional bool yolo_mode_toggled = 142;
+  optional bool use_auto_condense = 143;
+  optional string preferred_language = 145;
+  optional PlanActMode mode = 147;
+  optional FocusChainSettings focus_chain_settings = 149;
+  optional string custom_prompt = 150;
+  optional bool hooks_enabled = 152;
+  optional bool subagents_enabled = 153;
+  optional bool background_edit_enabled = 155;
+  optional bool opt_out_of_remote_config = 157;
+  optional bool open_telemetry_enabled = 158;
+  optional string open_telemetry_metrics_exporter = 159;
+  optional string open_telemetry_logs_exporter = 160;
+  optional string open_telemetry_otlp_protocol = 161;
+  optional string open_telemetry_otlp_endpoint = 162;
+  optional string open_telemetry_otlp_metrics_protocol = 163;
+  optional string open_telemetry_otlp_metrics_endpoint = 164;
+  optional string open_telemetry_otlp_logs_protocol = 165;
+  optional string open_telemetry_otlp_logs_endpoint = 166;
+  optional int32 open_telemetry_metric_export_interval = 167;
+  optional bool open_telemetry_otlp_insecure = 168;
+  optional int32 open_telemetry_log_batch_size = 169;
+  optional int32 open_telemetry_log_batch_timeout = 170;
+  optional int32 open_telemetry_log_max_queue_size = 171;
+  optional bool worktrees_enabled = 172;
+  optional bool auto_approve_all_toggled = 174;
+  map<string, string> open_ai_headers = 177;
+  optional string plan_mode_cline_model_id = 178;
+  optional OpenRouterModelInfo plan_mode_cline_model_info = 179;
+  optional string act_mode_cline_model_id = 180;
+  optional OpenRouterModelInfo act_mode_cline_model_info = 181;
+  optional bool show_feature_tips = 182;
+  optional string plan_mode_cline_pass_model_id = 183;
+  optional OpenRouterModelInfo plan_mode_cline_pass_model_info = 184;
+  optional string act_mode_cline_pass_model_id = 185;
+  optional OpenRouterModelInfo act_mode_cline_pass_model_info = 186;
+}
+
+message State {
+  string state_json = 1;
+}
+
+message TerminalProfiles {
+  repeated TerminalProfile profiles = 1;
+}
+
+message TerminalProfile {
+  string id = 1;
+  string name = 2;
+  optional string path = 3;
+  optional string description = 4;
+}
+
+message TerminalProfileUpdateResponse {
+  int32 closed_count = 1;
+  int32 busy_terminals_count = 2;
+  bool has_busy_terminals = 3;
+}
+
+message TogglePlanActModeRequest {
+  Metadata metadata = 1;
+  PlanActMode mode = 2;
+  optional ChatContent chat_content = 3;
+}
+
+enum PlanActMode {
+  PLAN = 0;
+  ACT = 1;
+}
+
+enum OpenaiReasoningEffort {
+  LOW = 0;
+  MEDIUM = 1;
+  HIGH = 2;
+  reserved 3; // was MINIMAL
+}
+
+enum McpDisplayMode {
+  RICH = 0;
+  PLAIN = 1;
+  MARKDOWN = 2;
+}
+
+message ChatContent {
+  optional string message = 1;
+  repeated string images = 2;
+  repeated string files = 3;
+}
+
+message ResetStateRequest {
+  Metadata metadata = 1;
+  optional bool global = 2;
+}
+
+message AutoApprovalSettingsRequest {
+  Metadata metadata = 1;
+  int32 version = 2;
+  AutoApprovalActions actions = 3;
+  bool enable_notifications = 4;
+}
+
+enum TelemetrySettingEnum {
+  UNSET = 0;
+  ENABLED = 1;
+  DISABLED = 2;
+}
+
+message TelemetrySettingRequest {
+  Metadata metadata = 1;
+  TelemetrySettingEnum setting = 2;
+}
+
+// Browser settings for UpdateSettingsRequest
+message BrowserSettingsUpdate {
+  optional Viewport viewport = 1;
+  optional string remote_browser_host = 2;
+  optional bool remote_browser_enabled = 3;
+  optional string chrome_executable_path = 4;
+  optional bool disable_tool_use = 5;
+  optional string custom_args = 6;
+}
+
+message UpdateSettingsRequestCli {
+  Metadata metadata = 1;
+  optional Settings settings = 2;
+  optional Secrets secrets = 3;
+  optional string environment = 4;
+}
+
+message UpdateTaskSettingsRequest {
+  Metadata metadata = 1;
+  optional Settings settings = 2;
+  optional string task_id = 3;
+}
+
+// Message for updating settings
+message UpdateSettingsRequest {
+  reserved 15; // was openai_reasoning_effort (moved to mode-scoped reasoning effort)
+  reserved 23; // was dictation_settings (dictation removed)
+  reserved 32, 34, 35, 41;
+  reserved 38; // was skills_enabled (removed - now always enabled)
+  reserved 43; // was lazy_teammate_mode_enabled (removed)
+  reserved 12; // was terminal_output_line_limit (removed; SDK command output limits are character-based)
+  reserved "native_tool_call_enabled", "cline_web_tools_enabled", "enable_parallel_tool_calling", "double_check_completion_enabled";
+
+  Metadata metadata = 1;
+  optional ModelsApiConfiguration api_configuration = 2;
+  optional string telemetry_setting = 3;
+  optional bool plan_act_separate_models_setting = 4;
+  optional bool enable_checkpoints_setting = 5;
+  optional bool mcp_marketplace_enabled = 6;
+  optional int32 shell_integration_timeout = 8;
+  optional bool terminal_reuse_enabled = 9;
+  optional bool mcp_responses_collapsed = 10;
+  optional McpDisplayMode mcp_display_mode = 11;
+  optional PlanActMode mode = 13;
+  optional string preferred_language = 14;
+  reserved 16; // was strict_plan_mode_enabled (removed)
+  optional FocusChainSettings focus_chain_settings = 17;
+  optional bool use_auto_condense = 18;
+  optional string custom_prompt = 19;
+  optional BrowserSettingsUpdate browser_settings = 20;
+  optional string default_terminal_profile = 21;
+  optional bool yolo_mode_toggled = 22;
+  optional bool multi_root_enabled = 25;
+  optional bool hooks_enabled = 26;
+  optional string vscode_terminal_execution_mode = 27;
+  optional int32 max_consecutive_mistakes = 28;
+  optional bool subagents_enabled = 29;
+  optional int32 subagent_terminal_output_line_limit = 30;
+  optional string cline_env = 31;
+  optional OnboardingModelGroup onboarding_models = 33;
+  optional bool background_edit_enabled = 36;
+  optional string oca_reasoning_effort = 37;
+  optional bool opt_out_of_remote_config = 39;
+  optional bool worktrees_enabled = 40;
+  optional bool show_feature_tips = 42;
+  optional string compaction_strategy = 44;
+}
+
+message UpdateTerminalConnectionTimeoutRequest {
+  optional int32 timeout_ms = 1;
+}
+
+message FocusChainSettings {
+  bool enabled = 1;
+  int32 remind_cline_interval = 2;
+}
+
+message UpdateTerminalConnectionTimeoutResponse {
+  optional int32 timeout_ms = 1;
+}
+
+message ProcessInfo {
+  int32 process_id = 1;
+  optional string version = 2;
+  optional int64 uptime_ms = 3;
+}
+
+message OnboardingProgressRequest {
+  int32 step = 1;
+  optional string action = 2;
+  optional bool completed = 3;
+  optional string model_selected = 4;
+  optional string page = 5;
+  optional string page_variant = 6;
+  optional string user_type = 7;
+  optional int32 destination_step = 8;
+  optional string destination_page = 9;
+}
+
+message OnboardingModelGroup {
+  repeated OnboardingModel models = 1;
+}
+
+message OnboardingModel {
+  string id = 1;
+  string name = 2;
+  int32 score = 3;
+  int32 latency = 4;
+  string badge = 5;
+  string group = 6;
+  OpenRouterModelInfo info = 7;
+}
+
+message TrackBannerEventRequest {
+  string banner_id = 1;
+  string event_type = 2;
+}
+
+// Result of a connection test (OTEL, prompt uploading, etc.)
+message TestConnectionResult {
+  bool success = 1;
+  optional string message = 2;
+  optional string error = 3;
+}
diff --git a/apps/vscode/proto/cline/task.proto b/apps/vscode/proto/cline/task.proto
new file mode 100644
index 0000000..f18fc58
--- /dev/null
+++ b/apps/vscode/proto/cline/task.proto
@@ -0,0 +1,139 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+import "cline/state.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service TaskService {
+  // Cancels the currently running task
+  rpc cancelTask(EmptyRequest) returns (Empty);
+  // Cancels a queued prompt by ID
+  rpc cancelQueuedPrompt(StringRequest) returns (Empty);
+  // Cancels the currently running background command
+  rpc cancelBackgroundCommand(EmptyRequest) returns (Empty);
+  // Clears the current task
+  rpc clearTask(EmptyRequest) returns (Empty);
+  // Gets the total size of all tasks
+  rpc getTotalTasksSize(EmptyRequest) returns (Int64);
+  // Deletes multiple tasks with the given IDs
+  rpc deleteTasksWithIds(StringArrayRequest) returns (Empty);
+  // Creates a new task with the given text and optional images
+  rpc newTask(NewTaskRequest) returns (String);
+  // Shows a task with the specified ID
+  rpc showTaskWithId(StringRequest) returns (TaskResponse);
+  // Exports a task with the given ID to markdown
+  rpc exportTaskWithId(StringRequest) returns (Empty);
+  // Toggles the favorite status of a task
+  rpc toggleTaskFavorite(TaskFavoriteRequest) returns (Empty);
+  // Gets filtered task history
+  rpc getTaskHistory(GetTaskHistoryRequest) returns (TaskHistoryArray);
+  // Sends a response to a previous ask operation
+  rpc askResponse(AskResponseRequest) returns (Empty);
+  // Edits a previous user message, truncates following conversation, and regenerates
+  rpc editMessageAndRegenerate(EditMessageAndRegenerateRequest) returns (Empty);
+  // Records task feedback (thumbs up/down)
+  rpc taskFeedback(StringRequest) returns (Empty);
+  // Executes a quick win task with command and title
+  rpc executeQuickWin(ExecuteQuickWinRequest) returns (Empty);
+  // Deletes all task history
+  rpc deleteAllTaskHistory(EmptyRequest) returns (DeleteAllTaskHistoryCount);
+}
+
+// Request message for creating a new task
+message NewTaskRequest {
+  Metadata metadata = 1;
+  string text = 2;
+  repeated string images = 3;
+  repeated string files = 4;
+  optional Settings task_settings = 5;
+}
+
+// Request message for toggling task favorite status
+message TaskFavoriteRequest {
+  Metadata metadata = 1;
+  string task_id = 2;
+  bool is_favorited = 3;
+}
+
+// Response for task details
+message TaskResponse {
+  string id = 1;
+  string task = 2;
+  int64 ts = 3;
+  bool is_favorited = 4;
+  int64 size = 5;
+  double total_cost = 6;
+  int32 tokens_in = 7;
+  int32 tokens_out = 8;
+  int32 cache_writes = 9;
+  int32 cache_reads = 10;
+  string model_id = 11;
+}
+
+// Request for getting task history with filtering
+message GetTaskHistoryRequest {
+  Metadata metadata = 1;
+  bool favorites_only = 2;
+  string search_query = 3;
+  string sort_by = 4;
+  bool current_workspace_only = 5;
+  int32 limit = 6;
+  int32 offset = 7;
+}
+
+// Response for task history
+message TaskHistoryArray {
+  repeated TaskItem tasks = 1;
+  bool has_more = 2;
+}
+
+// Task item details for history list
+message TaskItem {
+  string id = 1;
+  string task = 2;
+  int64 ts = 3;
+  bool is_favorited = 4;
+  int64 size = 5;
+  double total_cost = 6;
+  int32 tokens_in = 7;
+  int32 tokens_out = 8;
+  int32 cache_writes = 9;
+  int32 cache_reads = 10;
+  string model_id = 11;
+}
+
+// Request for ask response operation
+message AskResponseRequest {
+  Metadata metadata = 1;
+  string response_type = 2;
+  string text = 3;
+  repeated string images = 4;
+  repeated string files = 5;
+}
+
+// Request for editing a past user message and regenerating the conversation after it
+message EditMessageAndRegenerateRequest {
+  Metadata metadata = 1;
+  int64 message_ts = 2;
+  string text = 3;
+  repeated string images = 4;
+  repeated string files = 5;
+  bool restore_workspace = 6;
+}
+
+// Request for executing a quick win task
+message ExecuteQuickWinRequest {
+  Metadata metadata = 1;
+  string command = 2;
+  string title = 3;
+}
+
+// Results returned when deleting all task history
+message DeleteAllTaskHistoryCount {
+  int32 tasks_deleted = 1;
+}
diff --git a/apps/vscode/proto/cline/ui.proto b/apps/vscode/proto/cline/ui.proto
new file mode 100644
index 0000000..f1bcb82
--- /dev/null
+++ b/apps/vscode/proto/cline/ui.proto
@@ -0,0 +1,308 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Enum for ClineMessage type
+enum ClineMessageType {
+  ASK = 0;
+  SAY = 1;
+}
+
+// Enum for ClineAsk types
+enum ClineAsk {
+  FOLLOWUP = 0;
+  PLAN_MODE_RESPOND = 1;
+  COMMAND = 2;
+  COMMAND_OUTPUT = 3;
+  COMPLETION_RESULT = 4;
+  TOOL = 5;
+  API_REQ_FAILED = 6;
+  RESUME_TASK = 7;
+  RESUME_COMPLETED_TASK = 8;
+  MISTAKE_LIMIT_REACHED = 9;
+  BROWSER_ACTION_LAUNCH = 10;
+  USE_MCP_SERVER = 11;
+  NEW_TASK = 12;
+  CONDENSE = 13;
+  REPORT_BUG = 14;
+  SUMMARIZE_TASK = 15;
+  ACT_MODE_RESPOND = 16;
+  USE_SUBAGENTS = 17;
+}
+
+// Enum for ClineSay types
+enum ClineSay {
+  TASK = 0;
+  ERROR = 1;
+  API_REQ_STARTED = 2;
+  API_REQ_FINISHED = 3;
+  TEXT = 4;
+  REASONING = 5;
+  COMPLETION_RESULT_SAY = 6;
+  USER_FEEDBACK = 7;
+  USER_FEEDBACK_DIFF = 8;
+  API_REQ_RETRIED = 9;
+  COMMAND_SAY = 10;
+  COMMAND_OUTPUT_SAY = 11;
+  TOOL_SAY = 12;
+  SHELL_INTEGRATION_WARNING = 13;
+  BROWSER_ACTION_LAUNCH_SAY = 14;
+  BROWSER_ACTION = 15;
+  BROWSER_ACTION_RESULT = 16;
+  MCP_SERVER_REQUEST_STARTED = 17;
+  MCP_SERVER_RESPONSE = 18;
+  MCP_NOTIFICATION = 19;
+  USE_MCP_SERVER_SAY = 20;
+  DIFF_ERROR = 21;
+  DELETED_API_REQS = 22;
+  CLINEIGNORE_ERROR = 23;
+  CHECKPOINT_CREATED = 24;
+  LOAD_MCP_DOCUMENTATION = 25;
+  INFO = 26;
+  TASK_PROGRESS = 27;
+  ERROR_RETRY = 28;
+  HOOK_STATUS = 30;
+  HOOK_OUTPUT_STREAM = 31;
+  COMMAND_PERMISSION_DENIED = 32;
+  CONDITIONAL_RULES_APPLIED = 33;
+  SUBAGENT_STATUS = 34;
+  USE_SUBAGENTS_SAY = 35;
+  SUBAGENT_USAGE = 36;
+}
+
+// Enum for ClineSayTool tool types
+enum ClineSayToolType {
+  EDITED_EXISTING_FILE = 0;
+  NEW_FILE_CREATED = 1;
+  READ_FILE = 2;
+  LIST_FILES_TOP_LEVEL = 3;
+  LIST_FILES_RECURSIVE = 4;
+  LIST_CODE_DEFINITION_NAMES = 5;
+  SEARCH_FILES = 6;
+  WEB_FETCH = 7;
+  FILE_DELETED = 8;
+}
+
+// Enum for browser actions
+enum BrowserAction {
+  LAUNCH = 0;
+  CLICK = 1;
+  TYPE = 2;
+  SCROLL_DOWN = 3;
+  SCROLL_UP = 4;
+  CLOSE = 5;
+}
+
+// Enum for MCP server request types
+enum McpServerRequestType {
+  USE_MCP_TOOL = 0;
+  ACCESS_MCP_RESOURCE = 1;
+}
+
+// Enum for API request cancel reasons
+enum ClineApiReqCancelReason {
+  STREAMING_FAILED = 0;
+  USER_CANCELLED = 1;
+  RETRIES_EXHAUSTED = 2;
+}
+
+// Message for conversation history deleted range
+message ConversationHistoryDeletedRange {
+  int32 start_index = 1;
+  int32 end_index = 2;
+}
+
+// Message for ClineSayTool
+message ClineSayTool {
+  ClineSayToolType tool = 1;
+  string path = 2;
+  string diff = 3;
+  string content = 4;
+  string regex = 5;
+  string file_pattern = 6;
+  bool operation_is_located_in_workspace = 7;
+}
+
+// Message for ClineSayBrowserAction
+message ClineSayBrowserAction {
+  BrowserAction action = 1;
+  string coordinate = 2;
+  string text = 3;
+}
+
+// Message for BrowserActionResult
+message BrowserActionResult {
+  string screenshot = 1;
+  string logs = 2;
+  string current_url = 3;
+  string current_mouse_position = 4;
+}
+
+// Message for ClineAskUseMcpServer
+message ClineAskUseMcpServer {
+  string server_name = 1;
+  McpServerRequestType type = 2;
+  string tool_name = 3;
+  string arguments = 4;
+  string uri = 5;
+}
+
+// Message for ClinePlanModeResponse
+message ClinePlanModeResponse {
+  string response = 1;
+  repeated string options = 2;
+  string selected = 3;
+}
+
+// Message for ClineAskQuestion
+message ClineAskQuestion {
+  string question = 1;
+  repeated string options = 2;
+  string selected = 3;
+}
+
+// Message for ClineAskNewTask
+message ClineAskNewTask {
+  string context = 1;
+}
+
+// Message for API request retry status
+message ApiReqRetryStatus {
+  int32 attempt = 1;
+  int32 max_attempts = 2;
+  int32 delay_sec = 3;
+  string error_snippet = 4;
+}
+
+// Message for ClineApiReqInfo
+message ClineApiReqInfo {
+  string request = 1;
+  int32 tokens_in = 2;
+  int32 tokens_out = 3;
+  int32 cache_writes = 4;
+  int32 cache_reads = 5;
+  double cost = 6;
+  ClineApiReqCancelReason cancel_reason = 7;
+  string streaming_failed_message = 8;
+  ApiReqRetryStatus retry_status = 9;
+}
+
+message ClineModelInfo {
+  string provider_id = 1;
+  string model_id = 2;
+}
+
+// Main ClineMessage type
+message ClineMessage {
+  int64 ts = 1;
+  ClineMessageType type = 2;
+  ClineAsk ask = 3;
+  ClineSay say = 4;
+  string text = 5;
+  string reasoning = 6;
+  repeated string images = 7;
+  repeated string files = 8;
+  bool partial = 9;
+  string last_checkpoint_hash = 10;
+  bool is_checkpoint_checked_out = 11;
+  bool is_operation_outside_workspace = 12;
+  int32 conversation_history_index = 13;
+  ConversationHistoryDeletedRange conversation_history_deleted_range = 14;
+
+  // Additional fields for specific ask/say types
+  ClineSayTool say_tool = 15;
+  ClineSayBrowserAction say_browser_action = 16;
+  BrowserActionResult browser_action_result = 17;
+  ClineAskUseMcpServer ask_use_mcp_server = 18;
+  ClinePlanModeResponse plan_mode_response = 19;
+  ClineAskQuestion ask_question = 20;
+  ClineAskNewTask ask_new_task = 21;
+  ClineApiReqInfo api_req_info = 22;
+  ClineModelInfo model_info = 23;
+
+  // Convergent-replica fields (see webview-message-state-design.md):
+  // seq = monotonic freshness (higher seq wins for the same ts/identity)
+  // epoch = conversation/replica fence (older epoch is dropped by the webview)
+  int64 seq = 24;
+  int64 epoch = 25;
+}
+
+message ShowWebviewEvent {
+  bool preserve_editor_focus = 1; // When true, webview should not steal focus from editor
+}
+
+message IntentEvent {
+  string action = 1;
+  string source = 2;
+  bool has_text = 3;
+  bool has_images = 4;
+  bool has_files = 5;
+  bool has_active_task = 6;
+  int32 text_length = 7;
+}
+
+// UiService provides methods for managing UI interactions
+service UiService {
+  // Scrolls to a specific settings section in the settings view
+  rpc scrollToSettings(StringRequest) returns (KeyValuePair);
+
+  // Sets the terminal execution mode (vscodeTerminal or backgroundExec)
+  rpc setTerminalExecutionMode(BooleanRequest) returns (KeyValuePair);
+
+  // Marks the current announcement as shown and returns whether an announcement should still be shown
+  rpc onDidShowAnnouncement(EmptyRequest) returns (Boolean);
+
+  // Subscribe to addToInput events (when user adds content via context menu)
+  rpc subscribeToAddToInput(EmptyRequest) returns (stream String);
+
+  // Subscribe to MCP button clicked events
+  rpc subscribeToMcpButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to customize button clicked events
+  rpc subscribeToMarketplaceButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to history button click events
+  rpc subscribeToHistoryButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to chat button clicked events (when the chat button is clicked in VSCode)
+  rpc subscribeToChatButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to account button click events
+  rpc subscribeToAccountButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to settings button clicked events
+  rpc subscribeToSettingsButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to worktrees button clicked events
+  rpc subscribeToWorktreesButtonClicked(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to partial message updates (streaming Cline messages as they're built)
+  rpc subscribeToPartialMessage(EmptyRequest) returns (stream ClineMessage);
+
+  // Initialize webview when it launches
+  rpc initializeWebview(EmptyRequest) returns (Empty);
+
+  // Subscribe to relinquish control events
+  rpc subscribeToRelinquishControl(EmptyRequest) returns (stream Empty);
+
+  // Subscribe to show webview events
+  rpc subscribeToShowWebview(EmptyRequest) returns (stream ShowWebviewEvent);
+
+  // Returns the HTML for the webview index page. This is only used by external clients, not by the vscode webview.
+  rpc getWebviewHtml(EmptyRequest) returns (String);
+
+  // Opens a URL in the default browser
+  rpc openUrl(StringRequest) returns (Empty);
+
+  // Opens the Cline walkthrough
+  rpc openWalkthrough(EmptyRequest) returns (Empty);
+
+  // Tracks intent signals before task creation or first model activity
+  rpc trackIntent(IntentEvent) returns (Empty);
+}
diff --git a/apps/vscode/proto/cline/web.proto b/apps/vscode/proto/cline/web.proto
new file mode 100644
index 0000000..272d464
--- /dev/null
+++ b/apps/vscode/proto/cline/web.proto
@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+service WebService {
+  rpc checkIsImageUrl(StringRequest) returns (IsImageUrl);
+  rpc fetchOpenGraphData(StringRequest) returns (OpenGraphData);
+  rpc openInBrowser(StringRequest) returns (Empty);
+}
+
+message IsImageUrl {
+  bool is_image = 1;
+  string url = 2;
+}
+
+message OpenGraphData {
+  string title = 1;
+  string description = 2;
+  string image = 3;
+  string url = 4;
+  string site_name = 5;
+  string type = 6;
+}
diff --git a/apps/vscode/proto/cline/worktree.proto b/apps/vscode/proto/cline/worktree.proto
new file mode 100644
index 0000000..4748f80
--- /dev/null
+++ b/apps/vscode/proto/cline/worktree.proto
@@ -0,0 +1,153 @@
+syntax = "proto3";
+
+package cline;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/cline";
+option java_multiple_files = true;
+option java_package = "bot.cline.proto";
+
+// Service for git worktree operations
+service WorktreeService {
+  // Lists all worktrees in the current repository
+  rpc listWorktrees(EmptyRequest) returns (WorktreeList);
+
+  // Creates a new worktree
+  rpc createWorktree(CreateWorktreeRequest) returns (WorktreeResult);
+
+  // Deletes an existing worktree
+  rpc deleteWorktree(DeleteWorktreeRequest) returns (WorktreeResult);
+
+  // Switches to a different worktree (opens in VS Code)
+  rpc switchWorktree(SwitchWorktreeRequest) returns (WorktreeResult);
+
+  // Gets available branches for creating worktrees
+  rpc getAvailableBranches(EmptyRequest) returns (BranchList);
+
+  // Gets suggested defaults for creating a new worktree (auto-generated branch name and path)
+  rpc getWorktreeDefaults(EmptyRequest) returns (WorktreeDefaults);
+
+  // Gets the status of .worktreeinclude file and .gitignore contents for creating one
+  rpc getWorktreeIncludeStatus(EmptyRequest) returns (WorktreeIncludeStatus);
+
+  // Creates a .worktreeinclude file with the provided content
+  rpc createWorktreeInclude(CreateWorktreeIncludeRequest) returns (WorktreeResult);
+
+  // Switches to a different branch in the current worktree (git checkout)
+  rpc checkoutBranch(CheckoutBranchRequest) returns (WorktreeResult);
+
+  // Merges a worktree's branch into the target branch and optionally deletes the worktree
+  rpc mergeWorktree(MergeWorktreeRequest) returns (MergeWorktreeResult);
+
+  // Tracks when the worktrees view is opened (for telemetry)
+  rpc trackWorktreeViewOpened(TrackWorktreeViewOpenedRequest) returns (Empty);
+}
+
+// Represents a single git worktree
+message Worktree {
+  string path = 1; // Absolute path to the worktree
+  string branch = 2; // Branch name (empty if detached)
+  string commit_hash = 3; // Current commit hash
+  bool is_current = 4; // Whether this is the current worktree
+  bool is_bare = 5; // Whether this is the bare repository
+  bool is_detached = 6; // Whether HEAD is detached
+  bool is_locked = 7; // Whether the worktree is locked
+  optional string lock_reason = 8; // Reason for lock if locked
+}
+
+// Response containing list of worktrees
+message WorktreeList {
+  repeated Worktree worktrees = 1;
+  bool is_git_repo = 2; // Whether the current workspace is a git repo
+  string error = 3; // Error message if any
+  bool is_multi_root = 4; // Whether multiple workspace folders are open (worktrees not supported)
+  bool is_subfolder = 5; // Whether workspace is a subfolder of a git repo (not at repo root)
+  string git_root_path = 6; // The actual git root path (useful when is_subfolder is true)
+}
+
+// Request to create a new worktree
+message CreateWorktreeRequest {
+  Metadata metadata = 1;
+  string path = 2; // Path for the new worktree
+  optional string branch = 3; // Branch name (creates new if doesn't exist)
+  optional string base_branch = 4; // Base branch for new branch creation
+  bool create_new_branch = 5; // Whether to create a new branch
+}
+
+// Request to delete a worktree
+message DeleteWorktreeRequest {
+  Metadata metadata = 1;
+  string path = 2; // Path of the worktree to delete
+  bool force = 3; // Force deletion even if dirty
+  bool delete_branch = 4; // Also delete the branch
+  string branch_name = 5; // Name of the branch to delete (required if delete_branch is true)
+}
+
+// Request to switch to a worktree
+message SwitchWorktreeRequest {
+  Metadata metadata = 1;
+  string path = 2; // Path of the worktree to switch to
+  bool new_window = 3; // Whether to open in a new window
+}
+
+// Result of worktree operations
+message WorktreeResult {
+  bool success = 1;
+  string message = 2; // Success or error message
+  optional Worktree worktree = 3; // The affected worktree (for create)
+}
+
+// List of available branches
+message BranchList {
+  repeated string local_branches = 1;
+  repeated string remote_branches = 2;
+  string current_branch = 3;
+}
+
+// Suggested defaults for creating a new worktree
+message WorktreeDefaults {
+  string suggested_branch = 1; // Auto-generated branch name like "worktree/cline-abc12"
+  string suggested_path = 2; // Path in Documents/Cline/Worktrees/<project>-<suffix>
+}
+
+// Status of .worktreeinclude file
+message WorktreeIncludeStatus {
+  bool exists = 1; // Whether .worktreeinclude exists
+  string gitignore_content = 2; // Content of .gitignore (for prefilling)
+  bool has_gitignore = 3; // Whether .gitignore exists
+}
+
+// Request to create .worktreeinclude file
+message CreateWorktreeIncludeRequest {
+  string content = 1; // Content for the .worktreeinclude file
+}
+
+// Request to checkout a branch in the current worktree
+message CheckoutBranchRequest {
+  Metadata metadata = 1;
+  string branch = 2; // Branch name to checkout
+}
+
+// Request to merge a worktree's branch into target branch
+message MergeWorktreeRequest {
+  Metadata metadata = 1;
+  string worktree_path = 2; // Path of the worktree to merge
+  string target_branch = 3; // Branch to merge into (e.g., "main")
+  bool delete_after_merge = 4; // Whether to delete the worktree after successful merge
+}
+
+// Result of merge operation
+message MergeWorktreeResult {
+  bool success = 1;
+  string message = 2; // Success or error message
+  bool has_conflicts = 3; // Whether merge resulted in conflicts
+  repeated string conflicting_files = 4; // List of files with conflicts
+  string source_branch = 5; // The branch that was merged
+  string target_branch = 6; // The branch merged into
+}
+
+// Request to track worktree view opened (for telemetry)
+message TrackWorktreeViewOpenedRequest {
+  string source = 1; // Where the view was opened from: "home_page" or "menu_bar"
+}
diff --git a/apps/vscode/proto/descriptor_set.pb b/apps/vscode/proto/descriptor_set.pb
new file mode 100644
index 0000000..17e4624
Binary files /dev/null and b/apps/vscode/proto/descriptor_set.pb differ
diff --git a/apps/vscode/proto/host/diff.proto b/apps/vscode/proto/host/diff.proto
new file mode 100644
index 0000000..43395d5
--- /dev/null
+++ b/apps/vscode/proto/host/diff.proto
@@ -0,0 +1,109 @@
+syntax = "proto3";
+
+package host;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/host";
+option java_multiple_files = true;
+option java_package = "bot.cline.host.proto";
+
+// Provides methods for diff views.
+service DiffService {
+  // Open the diff view/editor.
+  rpc openDiff(OpenDiffRequest) returns (OpenDiffResponse);
+
+  // Get the contents of the diff view.
+  rpc getDocumentText(GetDocumentTextRequest) returns (GetDocumentTextResponse);
+
+  // Replace a text selection in the diff.
+  rpc replaceText(ReplaceTextRequest) returns (ReplaceTextResponse);
+
+  rpc scrollDiff(ScrollDiffRequest) returns (ScrollDiffResponse);
+
+  // Truncate the diff document.
+  rpc truncateDocument(TruncateDocumentRequest) returns (TruncateDocumentResponse);
+
+  // Save the diff document.
+  rpc saveDocument(SaveDocumentRequest) returns (SaveDocumentResponse);
+
+  // Close all the diff editor windows/tabs.
+  // Any diff editors with unsaved content should not be closed.
+  rpc closeAllDiffs(CloseAllDiffsRequest) returns (CloseAllDiffsResponse);
+
+  // Display a diff view comparing before/after states for multiple files.
+  // Content is passed as in-memory data, not read from the file system.
+  rpc openMultiFileDiff(OpenMultiFileDiffRequest) returns (OpenMultiFileDiffResponse);
+}
+
+message OpenDiffRequest {
+  optional cline.Metadata metadata = 1;
+  // The absolute path of the document being edited.
+  optional string path = 2;
+  // The new content for the file.
+  optional string content = 3;
+}
+
+message OpenDiffResponse {
+  // A unique identifier for the diff view that was opened.
+  optional string diff_id = 1;
+}
+
+message GetDocumentTextRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+}
+
+message GetDocumentTextResponse {
+  optional string content = 1;
+}
+
+message ReplaceTextRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+  optional string content = 3;
+  optional int32 start_line = 4;
+  optional int32 end_line = 5;
+}
+
+message ReplaceTextResponse {}
+
+message ScrollDiffRequest {
+  optional string diff_id = 1;
+  optional int32 line = 2;
+}
+
+message ScrollDiffResponse {}
+
+message TruncateDocumentRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+  optional int32 end_line = 3;
+}
+
+message TruncateDocumentResponse {}
+
+message CloseAllDiffsRequest {}
+
+message CloseAllDiffsResponse {}
+
+message SaveDocumentRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+}
+
+message SaveDocumentResponse {}
+
+message OpenMultiFileDiffRequest {
+  optional string title = 1;
+  repeated ContentDiff diffs = 2;
+}
+
+message ContentDiff {
+  // The absolute file path.
+  optional string file_path = 1;
+  optional string left_content = 2;
+  optional string right_content = 3;
+}
+
+message OpenMultiFileDiffResponse {}
diff --git a/apps/vscode/proto/host/env.proto b/apps/vscode/proto/host/env.proto
new file mode 100644
index 0000000..a67d133
--- /dev/null
+++ b/apps/vscode/proto/host/env.proto
@@ -0,0 +1,75 @@
+syntax = "proto3";
+
+package host;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/host";
+option java_multiple_files = true;
+option java_package = "bot.cline.host.proto";
+
+// Provides methods for working with the user's environment.
+service EnvService {
+  // Writes text to the system clipboard.
+  rpc clipboardWriteText(cline.StringRequest) returns (cline.Empty);
+
+  // Reads text from the system clipboard.
+  rpc clipboardReadText(cline.EmptyRequest) returns (cline.String);
+
+  // Returns the name and version of the host IDE or environment.
+  rpc getHostVersion(cline.EmptyRequest) returns (GetHostVersionResponse);
+
+  // Returns a URI that will redirect to the host environment.
+  // e.g. vscode://saoudrizwan.claude-dev, idea://, pycharm://, etc.
+  // If the host does not support URIs it should return empty.
+  rpc getIdeRedirectUri(cline.EmptyRequest) returns (cline.String);
+
+  // Returns the telemetry settings of the host environment. This may return UNSUPPORTED
+  // if the host does not specify telemetry settings for the plugin.
+  rpc getTelemetrySettings(cline.EmptyRequest) returns (GetTelemetrySettingsResponse);
+
+  // Returns events when the telemetry settings change.
+  rpc subscribeToTelemetrySettings(cline.EmptyRequest) returns (stream TelemetrySettingsEvent);
+
+  // Initiates a graceful shutdown of the host bridge service.
+  rpc shutdown(cline.EmptyRequest) returns (cline.Empty);
+
+  // Logs a debug message to the host environment's log/output console.
+  rpc debugLog(cline.StringRequest) returns (cline.Empty);
+
+  // Opens an external URL in the default browser.
+  // In remote environments (VS Code Server, SSH, etc.), this routes the URL
+  // to the user's local machine to open in their local browser.
+  rpc openExternal(cline.StringRequest) returns (cline.Empty);
+}
+
+message GetHostVersionResponse {
+  // The name of the host platform, e.g VSCode, IntelliJ Ultimate Edition, etc.
+  optional string platform = 1;
+  // The version of the host platform, e.g. 1.103.0 for VSCode, or 2025.1.1.1 for JetBrains IDEs.
+  optional string version = 2;
+  // The type of the cline host environment, e.g. 'VSCode Extension', 'Cline for JetBrains', 'CLI'
+  // This is different from the platform because there are many JetBrains IDEs, but they all use the same
+  // plugin.
+  optional string cline_type = 3;
+  // The version of the cline host environment, e.g. 33.2.10 for extension, or 1.0.6 for JetBrains.
+  optional string cline_version = 4;
+  // The remote environment name when the host is connected to a remote workspace
+  // (for example `ssh-remote`, `dev-container`, or `codespaces`).
+  optional string remote_name = 5;
+}
+
+enum Setting {
+  UNSUPPORTED = 0; // This host does not support this setting.
+  ENABLED = 1;
+  DISABLED = 2;
+}
+message GetTelemetrySettingsResponse {
+  Setting is_enabled = 1;
+  optional string error_level = 2;
+}
+
+message TelemetrySettingsEvent {
+  Setting is_enabled = 1;
+  optional string error_level = 2;
+}
diff --git a/apps/vscode/proto/host/testing.proto b/apps/vscode/proto/host/testing.proto
new file mode 100644
index 0000000..3492a91
--- /dev/null
+++ b/apps/vscode/proto/host/testing.proto
@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+package host;
+
+option go_package = "github.com/cline/grpc-go/host";
+option java_multiple_files = true;
+option java_package = "bot.cline.host.proto";
+
+// This is for use in integration tests to get the contents of the webview.
+service TestingService {
+  rpc getWebviewHtml(GetWebviewHtmlRequest) returns (GetWebviewHtmlResponse);
+}
+
+message GetWebviewHtmlRequest {}
+
+message GetWebviewHtmlResponse {
+  optional string html = 1;
+}
diff --git a/apps/vscode/proto/host/window.proto b/apps/vscode/proto/host/window.proto
new file mode 100644
index 0000000..80f2ecc
--- /dev/null
+++ b/apps/vscode/proto/host/window.proto
@@ -0,0 +1,164 @@
+syntax = "proto3";
+
+package host;
+
+option go_package = "github.com/cline/grpc-go/host";
+option java_multiple_files = true;
+option java_package = "bot.cline.host.proto";
+
+// Provides methods for working with IDE windows and editors.
+service WindowService {
+  // Opens a text document in the IDE editor and returns editor information.
+  rpc showTextDocument(ShowTextDocumentRequest) returns (TextEditorInfo);
+
+  // Shows the open file dialogue / file picker.
+  rpc showOpenDialogue(ShowOpenDialogueRequest) returns (SelectedResources);
+
+  // Shows a notification.
+  rpc showMessage(ShowMessageRequest) returns (SelectedResponse);
+
+  // Prompts the user for input and returns the response.
+  rpc showInputBox(ShowInputBoxRequest) returns (ShowInputBoxResponse);
+
+  // Shows the file save dialogue / file picker.
+  rpc showSaveDialog(ShowSaveDialogRequest) returns (ShowSaveDialogResponse);
+
+  // Opens a file in the IDE.
+  rpc openFile(OpenFileRequest) returns (OpenFileResponse);
+
+  // Opens the host settings UI, optionally focusing a specific query/section.
+  rpc openSettings(OpenSettingsRequest) returns (OpenSettingsResponse);
+
+  // Returns the open tabs.
+  rpc getOpenTabs(GetOpenTabsRequest) returns (GetOpenTabsResponse);
+
+  // Returns the visible tabs.
+  rpc getVisibleTabs(GetVisibleTabsRequest) returns (GetVisibleTabsResponse);
+
+  // Returns information about the current editor
+  rpc getActiveEditor(GetActiveEditorRequest) returns (GetActiveEditorResponse);
+}
+
+message ShowTextDocumentRequest {
+  string path = 2;
+  optional ShowTextDocumentOptions options = 3;
+}
+
+// See https://code.visualstudio.com/api/references/vscode-api#TextDocumentShowOptions
+message ShowTextDocumentOptions {
+  optional bool preview = 1;
+  optional bool preserve_focus = 2;
+  optional int32 view_column = 3;
+}
+
+message TextEditorInfo {
+  string document_path = 1;
+  optional int32 view_column = 2;
+  bool is_active = 3;
+}
+
+message ShowOpenDialogueRequest {
+  optional bool can_select_many = 2;
+  optional string open_label = 3;
+  optional ShowOpenDialogueFilterOption filters = 4;
+}
+
+message ShowOpenDialogueFilterOption {
+  repeated string files = 1;
+}
+
+message SelectedResources {
+  repeated string paths = 1;
+}
+
+enum ShowMessageType {
+  ERROR = 0;
+  INFORMATION = 1;
+  WARNING = 2;
+}
+
+message ShowMessageRequest {
+  ShowMessageType type = 1;
+  string message = 2;
+  optional ShowMessageRequestOptions options = 3;
+}
+
+message ShowMessageRequestOptions {
+  repeated string items = 1;
+  optional bool modal = 2;
+  optional string detail = 3;
+}
+
+message SelectedResponse {
+  optional string selected_option = 1;
+}
+
+message ShowSaveDialogRequest {
+  optional ShowSaveDialogOptions options = 1;
+}
+
+message ShowSaveDialogOptions {
+  optional string default_path = 1;
+  // A map of file types to extensions, e.g
+  // "Text Files": { "extensions": ["txt", "md"] }
+  map<string, FileExtensionList> filters = 2;
+}
+
+message FileExtensionList {
+  // A list of file extension (without the dot).
+  repeated string extensions = 1;
+}
+
+message ShowSaveDialogResponse {
+  // If the user cancelled the dialog, this will be empty.
+  optional string selected_path = 1;
+}
+
+message ShowInputBoxRequest {
+  string title = 1;
+  optional string prompt = 2;
+  optional string value = 3;
+}
+
+message ShowInputBoxResponse {
+  optional string response = 1;
+}
+
+message OpenFileRequest {
+  string file_path = 1;
+}
+
+message OpenFileResponse {}
+
+message OpenSettingsRequest {
+  // Optional query to focus a particular settings section/key.
+  // This value is host-specific. In VS Code, it is passed directly as the
+  // Settings search query to the "workbench.action.openSettings" command.
+  // Examples (VS Code, see - https://code.visualstudio.com/docs/getstarted/settings#settings-editor-filters.):
+  // - "telemetry.telemetryLevel" → focuses the Telemetry Level setting
+  // - "@id:telemetry.telemetryLevel" → navigates by exact setting id
+  // - "@modified", "@ext:publisher.extension"
+  // - Plain keywords/categories
+  // If not provided the host opens the settings UI without specific focus.
+  optional string query = 1;
+}
+
+message OpenSettingsResponse {}
+
+message GetOpenTabsRequest {}
+
+message GetOpenTabsResponse {
+  repeated string paths = 1;
+}
+
+message GetVisibleTabsRequest {}
+
+message GetVisibleTabsResponse {
+  repeated string paths = 1;
+}
+
+message GetActiveEditorRequest {}
+
+message GetActiveEditorResponse {
+  optional string file_path = 1;
+}
diff --git a/apps/vscode/proto/host/workspace.proto b/apps/vscode/proto/host/workspace.proto
new file mode 100644
index 0000000..bd5381a
--- /dev/null
+++ b/apps/vscode/proto/host/workspace.proto
@@ -0,0 +1,132 @@
+syntax = "proto3";
+
+package host;
+
+import "cline/common.proto";
+
+option go_package = "github.com/cline/grpc-go/host";
+option java_multiple_files = true;
+option java_package = "bot.cline.host.proto";
+
+// Provides methods for working with workspaces/projects.
+service WorkspaceService {
+  // Returns a list of the top level directories of the workspace.
+  rpc getWorkspacePaths(GetWorkspacePathsRequest) returns (GetWorkspacePathsResponse);
+
+  // Saves an open document if it's open in the editor and has unsaved changes.
+  // Returns true if the document was saved, returns false if the document was not found, or did not
+  // need to be saved.
+  rpc saveOpenDocumentIfDirty(SaveOpenDocumentIfDirtyRequest) returns (SaveOpenDocumentIfDirtyResponse);
+
+  // Get diagnostics from the workspace.
+  rpc getDiagnostics(GetDiagnosticsRequest) returns (GetDiagnosticsResponse);
+
+  // Makes the problems panel/pane visible in the IDE and focuses it.
+  rpc openProblemsPanel(OpenProblemsPanelRequest) returns (OpenProblemsPanelResponse);
+
+  // Opens the IDE file explorer panel and selects a file or directory.
+  rpc openInFileExplorerPanel(OpenInFileExplorerPanelRequest) returns (OpenInFileExplorerPanelResponse);
+
+  // Opens and focuses the Cline sidebar panel in the host IDE.
+  rpc openClineSidebarPanel(OpenClineSidebarPanelRequest) returns (OpenClineSidebarPanelResponse);
+
+  // Opens and focuses the terminal panel.
+  rpc openTerminalPanel(OpenTerminalRequest) returns (OpenTerminalResponse);
+
+  // Executes a command in a new terminal
+  rpc executeCommandInTerminal(ExecuteCommandInTerminalRequest) returns (ExecuteCommandInTerminalResponse);
+
+  // Opens a folder/workspace in the IDE
+  rpc openFolder(OpenFolderRequest) returns (OpenFolderResponse);
+
+  // Searches workspace files/folders by name using the host's native index
+  // (e.g. IntelliJ FilenameIndex). Hosts that lack a fast index should leave
+  // this UNIMPLEMENTED so the caller can fall back to ripgrep.
+  rpc searchWorkspaceItems(SearchWorkspaceItemsRequest) returns (SearchWorkspaceItemsResponse);
+}
+
+message GetWorkspacePathsRequest {
+  // The unique ID for the workspace/project.
+  // This is currently optional in vscode. It is required in other environments where cline is running at
+  // the application level, and the user can open multiple projects.
+  optional string id = 1;
+}
+
+message GetWorkspacePathsResponse {
+  // The unique ID for the workspace/project.
+  optional string id = 1;
+  repeated string paths = 2;
+}
+
+message SaveOpenDocumentIfDirtyRequest {
+  optional string file_path = 2;
+}
+message SaveOpenDocumentIfDirtyResponse {
+  // Returns true if the document was saved.
+  optional bool was_saved = 1;
+}
+
+message GetDiagnosticsRequest {
+  optional cline.Metadata metadata = 1;
+}
+
+message GetDiagnosticsResponse {
+  repeated cline.FileDiagnostics file_diagnostics = 1;
+}
+
+// Request for host-side workspace search (files/folders) used by mentions autocomplete
+message SearchWorkspaceItemsRequest {
+  string query = 1; // Search query string
+  optional int32 limit = 2; // Optional limit for results (default decided by host)
+  // Optional selected type filter
+  enum SearchItemType {
+    FILE = 0;
+    FOLDER = 1;
+  }
+  optional SearchItemType selected_type = 3;
+  // Absolute path of the workspace/content root to scope the search to. In
+  // multi-root projects the caller invokes the RPC once per root and sets
+  // this so the host returns only files under that root and relativizes
+  // paths against it. Hosts that can't honor it should ignore it.
+  optional string workspace_path = 4;
+}
+
+// Response for host-side workspace search
+message SearchWorkspaceItemsResponse {
+  message SearchItem {
+    string path = 1; // Workspace-relative path using platform separators
+    SearchWorkspaceItemsRequest.SearchItemType type = 2;
+    optional string label = 3; // Optional display label (e.g., basename)
+  }
+  repeated SearchItem items = 1;
+}
+
+message OpenProblemsPanelRequest {}
+message OpenProblemsPanelResponse {}
+message OpenInFileExplorerPanelRequest {
+  string path = 1;
+}
+message OpenInFileExplorerPanelResponse {}
+message OpenClineSidebarPanelRequest {}
+message OpenClineSidebarPanelResponse {}
+message OpenTerminalRequest {}
+message OpenTerminalResponse {}
+
+// Execute a command in the terminal
+message ExecuteCommandInTerminalRequest {
+  string command = 1; // The command to execute
+}
+
+message ExecuteCommandInTerminalResponse {
+  bool success = 1; // Whether the command was successfully sent to the terminal
+}
+
+// Request to open a folder/workspace
+message OpenFolderRequest {
+  string path = 1; // The path to the folder to open
+  bool new_window = 2; // Whether to open in a new window
+}
+
+message OpenFolderResponse {
+  bool success = 1;
+}
diff --git a/apps/vscode/scripts/add-endpoints-to-jetbrains.sh b/apps/vscode/scripts/add-endpoints-to-jetbrains.sh
new file mode 100755
index 0000000..53e86be
--- /dev/null
+++ b/apps/vscode/scripts/add-endpoints-to-jetbrains.sh
@@ -0,0 +1,96 @@
+#!/bin/bash
+set -euo pipefail
+
+# Script to add endpoints.json to a JetBrains plugin ZIP for enterprise distribution
+# Usage: ./add-endpoints-to-jetbrains.sh <source.zip> <output.zip> <endpoints.json>
+
+if [ "$#" -ne 3 ]; then
+    echo "Error: Invalid number of arguments"
+    echo "Usage: $0 <source.zip> <output.zip> <endpoints.json>"
+    echo ""
+    echo "Example:"
+    echo "  $0 cline-jetbrains-3.55.0.zip cline-jetbrains-3.55.0-enterprise.zip endpoints.json"
+    exit 1
+fi
+
+SOURCE_ZIP="$1"
+OUTPUT_ZIP="$2"
+ENDPOINTS_JSON="$3"
+
+# Validate inputs
+if [ ! -f "$SOURCE_ZIP" ]; then
+    echo "Error: Source ZIP file not found: $SOURCE_ZIP"
+    exit 1
+fi
+
+if [ ! -f "$ENDPOINTS_JSON" ]; then
+    echo "Error: endpoints.json file not found: $ENDPOINTS_JSON"
+    exit 1
+fi
+
+# Validate endpoints.json is valid JSON
+if ! jq empty "$ENDPOINTS_JSON" 2>/dev/null; then
+    echo "Error: $ENDPOINTS_JSON is not valid JSON"
+    exit 1
+fi
+
+# Validate required fields exist
+REQUIRED_FIELDS=("appBaseUrl" "apiBaseUrl" "mcpBaseUrl")
+for field in "${REQUIRED_FIELDS[@]}"; do
+    if ! jq -e ".$field" "$ENDPOINTS_JSON" > /dev/null 2>&1; then
+        echo "Error: Missing required field '$field' in $ENDPOINTS_JSON"
+        exit 1
+    fi
+    
+    # Validate field is a non-empty string
+    value=$(jq -r ".$field" "$ENDPOINTS_JSON")
+    if [ -z "$value" ] || [ "$value" = "null" ]; then
+        echo "Error: Field '$field' must be a non-empty string"
+        exit 1
+    fi
+    
+    # Validate URL format (basic check)
+    if ! [[ "$value" =~ ^https?:// ]]; then
+        echo "Error: Field '$field' must be a valid URL (got: $value)"
+        exit 1
+    fi
+done
+
+echo "✓ Validated endpoints.json"
+
+# Create temp directory
+TEMP_DIR=$(mktemp -d)
+trap "rm -rf $TEMP_DIR" EXIT
+
+echo "Extracting JetBrains plugin ZIP..."
+unzip -q "$SOURCE_ZIP" -d "$TEMP_DIR"
+
+# Find the plugin lib directory (where the main JAR is located)
+# JetBrains plugins typically have a structure like: cline/lib/
+# We need to add endpoints.json to the root of the plugin directory
+PLUGIN_DIR="$TEMP_DIR/cline"
+if [ ! -d "$PLUGIN_DIR" ]; then
+    # Try to find any directory that looks like a plugin root
+    PLUGIN_DIR=$(find "$TEMP_DIR" -maxdepth 1 -type d ! -path "$TEMP_DIR" | head -n 1)
+    if [ -z "$PLUGIN_DIR" ] || [ ! -d "$PLUGIN_DIR" ]; then
+        echo "Warning: Could not find plugin directory, adding to ZIP root"
+        PLUGIN_DIR="$TEMP_DIR"
+    fi
+fi
+
+echo "Adding endpoints.json to plugin directory..."
+cp "$ENDPOINTS_JSON" "$PLUGIN_DIR/endpoints.json"
+
+# Repackage ZIP
+echo "Repackaging ZIP..."
+cd "$TEMP_DIR"
+zip -q -r "$(basename "$OUTPUT_ZIP")" .
+cd - > /dev/null
+
+# Move to final location
+mv "$TEMP_DIR/$(basename "$OUTPUT_ZIP")" "$OUTPUT_ZIP"
+
+echo "✓ Successfully created $OUTPUT_ZIP with bundled endpoints.json"
+echo ""
+echo "The package is ready for enterprise distribution."
+echo "When installed in JetBrains IDEs, Cline will automatically use the bundled configuration."
diff --git a/apps/vscode/scripts/add-endpoints-to-vsix.sh b/apps/vscode/scripts/add-endpoints-to-vsix.sh
new file mode 100755
index 0000000..b6d5e1f
--- /dev/null
+++ b/apps/vscode/scripts/add-endpoints-to-vsix.sh
@@ -0,0 +1,84 @@
+#!/bin/bash
+set -euo pipefail
+
+# Script to add endpoints.json to a VSIX package for enterprise distribution
+# Usage: ./add-endpoints-to-vsix.sh <source.vsix> <output.vsix> <endpoints.json>
+
+if [ "$#" -ne 3 ]; then
+    echo "Error: Invalid number of arguments"
+    echo "Usage: $0 <source.vsix> <output.vsix> <endpoints.json>"
+    echo ""
+    echo "Example:"
+    echo "  $0 cline-3.55.0.vsix cline-3.55.0-enterprise.vsix endpoints.json"
+    exit 1
+fi
+
+SOURCE_VSIX="$1"
+OUTPUT_VSIX="$2"
+ENDPOINTS_JSON="$3"
+
+# Validate inputs
+if [ ! -f "$SOURCE_VSIX" ]; then
+    echo "Error: Source VSIX file not found: $SOURCE_VSIX"
+    exit 1
+fi
+
+if [ ! -f "$ENDPOINTS_JSON" ]; then
+    echo "Error: endpoints.json file not found: $ENDPOINTS_JSON"
+    exit 1
+fi
+
+# Validate endpoints.json is valid JSON
+if ! jq empty "$ENDPOINTS_JSON" 2>/dev/null; then
+    echo "Error: $ENDPOINTS_JSON is not valid JSON"
+    exit 1
+fi
+
+# Validate required fields exist
+REQUIRED_FIELDS=("appBaseUrl" "apiBaseUrl" "mcpBaseUrl")
+for field in "${REQUIRED_FIELDS[@]}"; do
+    if ! jq -e ".$field" "$ENDPOINTS_JSON" > /dev/null 2>&1; then
+        echo "Error: Missing required field '$field' in $ENDPOINTS_JSON"
+        exit 1
+    fi
+    
+    # Validate field is a non-empty string
+    value=$(jq -r ".$field" "$ENDPOINTS_JSON")
+    if [ -z "$value" ] || [ "$value" = "null" ]; then
+        echo "Error: Field '$field' must be a non-empty string"
+        exit 1
+    fi
+    
+    # Validate URL format (basic check)
+    if ! [[ "$value" =~ ^https?:// ]]; then
+        echo "Error: Field '$field' must be a valid URL (got: $value)"
+        exit 1
+    fi
+done
+
+echo "✓ Validated endpoints.json"
+
+# Resolve absolute path for output file before changing directories
+OUTPUT_VSIX_ABS=$(cd "$(dirname "$OUTPUT_VSIX")" && pwd)/$(basename "$OUTPUT_VSIX")
+
+# Create temp directory
+TEMP_DIR=$(mktemp -d)
+trap "rm -rf $TEMP_DIR" EXIT
+
+echo "Extracting VSIX..."
+unzip -q "$SOURCE_VSIX" -d "$TEMP_DIR"
+
+# Copy endpoints.json to extension directory
+echo "Adding endpoints.json to extension/..."
+cp "$ENDPOINTS_JSON" "$TEMP_DIR/extension/endpoints.json"
+
+# Repackage VSIX
+echo "Repackaging VSIX..."
+cd "$TEMP_DIR"
+zip -q -r "$OUTPUT_VSIX_ABS" .
+cd - > /dev/null
+
+echo "✓ Successfully created $OUTPUT_VSIX with bundled endpoints.json"
+echo ""
+echo "The package is ready for enterprise distribution."
+echo "When installed, Cline will automatically use the bundled configuration."
diff --git a/apps/vscode/scripts/api-secrets-parser.mjs b/apps/vscode/scripts/api-secrets-parser.mjs
new file mode 100644
index 0000000..31a9eca
--- /dev/null
+++ b/apps/vscode/scripts/api-secrets-parser.mjs
@@ -0,0 +1,375 @@
+/**
+ * API Secrets Parser Module
+ *
+ * Parses the ApiHandlerSecrets TypeScript interface from src/shared/api.ts
+ * to automatically discover API key fields for all providers.
+ *
+ * This eliminates the need for manual maintenance of provider-to-API-key mappings.
+ */
+
+/**
+ * Parses the ApiHandlerSecrets interface from api.ts content
+ *
+ * @param {string} content - Content of api.ts file
+ * @returns {Object} Parsed API key fields with metadata
+ * @returns {Object.fields} - Map of field names to their metadata
+ * @returns {Object.fieldNames} - Array of all field names
+ */
+export function parseApiHandlerSecrets(content) {
+	// Find the ApiHandlerSecrets interface definition
+	const interfaceMatch = content.match(/export interface ApiHandlerSecrets \{([\s\S]*?)\}/m)
+
+	if (!interfaceMatch) {
+		throw new Error("Could not find ApiHandlerSecrets interface definition")
+	}
+
+	const interfaceContent = interfaceMatch[1]
+	const fields = {}
+	const fieldNames = []
+
+	// Match field definitions like: fieldName?: string // comment
+	const fieldMatches = interfaceContent.matchAll(/^\s*([a-zA-Z][a-zA-Z0-9_]*)\?\s*:\s*([^/\n]+)(?:\/\/\s*(.*))?$/gm)
+
+	for (const match of fieldMatches) {
+		const [, name, type, comment] = match
+
+		fields[name] = {
+			name,
+			type: type.trim(),
+			comment: comment?.trim() || "",
+			isSecret: true, // All fields in ApiHandlerSecrets are secrets
+		}
+
+		fieldNames.push(name)
+	}
+
+	return { fields, fieldNames }
+}
+
+/**
+ * Maps provider IDs to their required API key fields
+ *
+ * @param {Array<string>} providerIds - List of provider IDs from ApiProvider type
+ * @param {Object} apiSecretsFields - Parsed fields from ApiHandlerSecrets
+ * @returns {Object} Map of provider ID to array of API key field names
+ *
+ * Example output:
+ * {
+ *   "anthropic": ["apiKey"],
+ *   "bedrock": ["awsAccessKey", "awsSecretKey"],
+ *   "cerebras": ["cerebrasApiKey"],
+ *   ...
+ * }
+ */
+export function mapProviderToApiKeys(providerIds, apiSecretsFields) {
+	const providerApiKeyMap = {}
+
+	// Track which fields have been assigned to prevent duplicates
+	const assignedFields = new Set()
+
+	// First pass: Map provider-specific API key fields
+	for (const providerId of providerIds) {
+		const apiKeyFields = []
+
+		for (const fieldName of apiSecretsFields.fieldNames) {
+			if (assignedFields.has(fieldName)) {
+				continue
+			}
+
+			const providerFromField = extractProviderFromFieldName(fieldName)
+
+			if (providerFromField === providerId) {
+				apiKeyFields.push(fieldName)
+				assignedFields.add(fieldName)
+			}
+		}
+
+		if (apiKeyFields.length > 0) {
+			providerApiKeyMap[providerId] = apiKeyFields
+		}
+	}
+
+	// Second pass: Handle special cases and multi-key providers
+	applySpecialCaseMappings(providerApiKeyMap, apiSecretsFields, assignedFields)
+
+	return providerApiKeyMap
+}
+
+/**
+ * Determines the provider ID from an API key field name
+ * Uses pattern matching on common naming conventions
+ *
+ * @param {string} fieldName - API key field name (e.g., "cerebrasApiKey")
+ * @returns {string|null} Provider ID or null if not a provider-specific key
+ */
+export function extractProviderFromFieldName(fieldName) {
+	// Normalize field name to lowercase for matching
+	const lowerFieldName = fieldName.toLowerCase()
+
+	// SPECIAL CASES FIRST (before pattern matching)
+
+	// Special case: "apiKey" alone maps to "anthropic" (primary provider)
+	if (fieldName === "apiKey") {
+		return "anthropic"
+	}
+
+	// Special case: clineAccountId maps to "cline"
+	if (lowerFieldName === "clineaccountid") {
+		return "cline"
+	}
+
+	// Special case: authNonce is not provider-specific
+	if (lowerFieldName === "authnonce") {
+		return null
+	}
+
+	// Special case: Vertex fields (not in ApiHandlerSecrets but in ApiHandlerOptions)
+	if (lowerFieldName === "vertexprojectid" || lowerFieldName === "vertexregion") {
+		return "vertex"
+	}
+
+	// Pattern 1: AWS-specific fields (check before generic pattern to avoid false positives)
+	if (lowerFieldName.startsWith("aws")) {
+		// awsAccessKey, awsSecretKey, awsSessionToken, awsRegion -> bedrock
+		if (
+			lowerFieldName.includes("accesskey") ||
+			lowerFieldName.includes("secretkey") ||
+			lowerFieldName.includes("sessiontoken") ||
+			lowerFieldName.includes("region")
+		) {
+			return "bedrock"
+		}
+		// awsBedrockApiKey is explicitly bedrock
+		if (lowerFieldName.includes("bedrock")) {
+			return "bedrock"
+		}
+	}
+
+	// Pattern 2: Vertex-specific fields
+	if (lowerFieldName.startsWith("vertex")) {
+		return "vertex"
+	}
+
+	// Pattern 3: SAP AI Core fields
+	if (lowerFieldName.startsWith("sapaicore") || lowerFieldName.startsWith("sapai")) {
+		return "sapaicore"
+	}
+
+	// Pattern 4: Provider name in the middle (e.g., openAiNativeApiKey) - check before generic pattern
+	const providerPatterns = [
+		{ pattern: "openainative", providerId: "openai-native" },
+		{ pattern: "openrouter", providerId: "openrouter" },
+		{ pattern: "openai", providerId: "openai" },
+		{ pattern: "gemini", providerId: "gemini" },
+		{ pattern: "deepseek", providerId: "deepseek" },
+		{ pattern: "ollama", providerId: "ollama" },
+		{ pattern: "lmstudio", providerId: "lmstudio" },
+		{ pattern: "litellm", providerId: "litellm" },
+		{ pattern: "qwen", providerId: "qwen" },
+		{ pattern: "doubao", providerId: "doubao" },
+		{ pattern: "mistral", providerId: "mistral" },
+		{ pattern: "fireworks", providerId: "fireworks" },
+		{ pattern: "asksage", providerId: "asksage" },
+		{ pattern: "xai", providerId: "xai" },
+		{ pattern: "moonshot", providerId: "moonshot" },
+		{ pattern: "sambanova", providerId: "sambanova" },
+		{ pattern: "cerebras", providerId: "cerebras" },
+		{ pattern: "groq", providerId: "groq" },
+		{ pattern: "huggingface", providerId: "huggingface" },
+		{ pattern: "huawei", providerId: "huawei-cloud-maas" },
+		{ pattern: "baseten", providerId: "baseten" },
+		{ pattern: "vercel", providerId: "vercel-ai-gateway" },
+		{ pattern: "zai", providerId: "zai" },
+		{ pattern: "requesty", providerId: "requesty" },
+		{ pattern: "together", providerId: "together" },
+		{ pattern: "dify", providerId: "dify" },
+	]
+
+	for (const { pattern, providerId } of providerPatterns) {
+		if (lowerFieldName.includes(pattern)) {
+			return providerId
+		}
+	}
+
+	// Pattern 5: <provider>ApiKey format (most common) - checked LAST to avoid false positives
+	if (lowerFieldName.endsWith("apikey")) {
+		// Extract from ORIGINAL fieldName to preserve camelCase for normalization
+		const providerPart = fieldName.slice(0, -6) // Remove "ApiKey"
+		return normalizeProviderName(providerPart)
+	}
+
+	return null
+}
+
+/**
+ * Normalizes provider name extracted from field name to match provider ID format
+ *
+ * @param {string} providerPart - Provider part extracted from field name
+ * @returns {string} Normalized provider ID
+ */
+function normalizeProviderName(providerPart) {
+	// Handle camelCase to kebab-case conversion
+	const normalized = providerPart
+		.replace(/([A-Z])/g, "-$1")
+		.toLowerCase()
+		.replace(/^-/, "")
+
+	// Handle special cases
+	const specialCases = {
+		"open-router": "openrouter",
+		"open-ai-native": "openai-native",
+		"open-ai": "openai",
+		"lite-llm": "litellm",
+		"deep-seek": "deepseek",
+		"ask-sage": "asksage",
+		"hugging-face": "huggingface",
+		"huawei-cloud-maas": "huawei-cloud-maas",
+		"sap-ai-core": "sapaicore",
+		"vercel-ai-gateway": "vercel-ai-gateway",
+	}
+
+	return specialCases[normalized] || normalized
+}
+
+/**
+ * Applies special case mappings for complex provider relationships
+ *
+ * @param {Object} providerApiKeyMap - Current map being built
+ * @param {Object} apiSecretsFields - Parsed API secrets fields
+ * @param {Set<string>} assignedFields - Set of already assigned field names
+ */
+function applySpecialCaseMappings(providerApiKeyMap, apiSecretsFields, assignedFields) {
+	// Special case 1: Bedrock needs AWS fields (if not already assigned)
+	const awsFields = ["awsAccessKey", "awsSecretKey", "awsRegion"]
+	const bedrockFields = providerApiKeyMap["bedrock"] || []
+
+	for (const field of awsFields) {
+		if (apiSecretsFields.fieldNames.includes(field) && !bedrockFields.includes(field)) {
+			bedrockFields.push(field)
+			assignedFields.add(field)
+		}
+	}
+
+	// Optional: awsSessionToken for temporary credentials
+	if (apiSecretsFields.fieldNames.includes("awsSessionToken") && !bedrockFields.includes("awsSessionToken")) {
+		bedrockFields.push("awsSessionToken")
+		assignedFields.add("awsSessionToken")
+	}
+
+	if (bedrockFields.length > 0) {
+		providerApiKeyMap["bedrock"] = bedrockFields
+	}
+
+	// Special case 2: Vertex needs project ID and region
+	if (providerApiKeyMap["vertex"]) {
+		// Vertex typically uses application default credentials,
+		// but requires project ID and region configuration
+		// These are already captured if they exist in ApiHandlerSecrets
+	}
+
+	// Special case 3: SAP AI Core multi-key authentication
+	if (providerApiKeyMap["sapaicore"]) {
+		const sapFields = providerApiKeyMap["sapaicore"]
+		const requiredSapFields = ["sapAiCoreClientId", "sapAiCoreClientSecret"]
+
+		for (const field of requiredSapFields) {
+			if (apiSecretsFields.fieldNames.includes(field) && !sapFields.includes(field)) {
+				sapFields.push(field)
+				assignedFields.add(field)
+			}
+		}
+	}
+}
+
+/**
+ * Generates display name for an API key field
+ * Converts camelCase to Title Case with proper spacing
+ *
+ * @param {string} fieldName - API key field name
+ * @returns {string} Human-readable display name
+ */
+export function generateApiKeyDisplayName(fieldName) {
+	// Special cases for known abbreviations
+	const specialCases = {
+		apiKey: "API Key",
+		awsAccessKey: "AWS Access Key",
+		awsSecretKey: "AWS Secret Key",
+		awsSessionToken: "AWS Session Token",
+		awsRegion: "AWS Region",
+		awsBedrockApiKey: "AWS Bedrock API Key",
+		openRouterApiKey: "OpenRouter API Key",
+		openAiApiKey: "OpenAI API Key",
+		openAiNativeApiKey: "OpenAI Native API Key",
+		geminiApiKey: "Gemini API Key",
+		ollamaApiKey: "Ollama API Key",
+		deepSeekApiKey: "DeepSeek API Key",
+		liteLlmApiKey: "LiteLLM API Key",
+		qwenApiKey: "Qwen API Key",
+		doubaoApiKey: "Doubao API Key",
+		mistralApiKey: "Mistral API Key",
+		fireworksApiKey: "Fireworks API Key",
+		asksageApiKey: "AskSage API Key",
+		xaiApiKey: "X AI API Key",
+		moonshotApiKey: "Moonshot API Key",
+		sambanovaApiKey: "SambaNova API Key",
+		cerebrasApiKey: "Cerebras API Key",
+		groqApiKey: "Groq API Key",
+		huggingFaceApiKey: "Hugging Face API Key",
+		nebiusApiKey: "Nebius API Key",
+		basetenApiKey: "Baseten API Key",
+		vercelAiGatewayApiKey: "Vercel AI Gateway API Key",
+		zaiApiKey: "Z AI API Key",
+		requestyApiKey: "Requesty API Key",
+		togetherApiKey: "Together AI API Key",
+		difyApiKey: "Dify API Key",
+		clineAccountId: "Cline Account ID",
+		vertexProjectId: "Vertex Project ID",
+		vertexRegion: "Vertex Region",
+		sapAiCoreClientId: "SAP AI Core Client ID",
+		sapAiCoreClientSecret: "SAP AI Core Client Secret",
+		huaweiCloudMaasApiKey: "Huawei Cloud MaaS API Key",
+		hicapApiKey: "Hicap API Key",
+	}
+
+	if (specialCases[fieldName]) {
+		return specialCases[fieldName]
+	}
+
+	// Generic conversion: camelCase -> Title Case
+	return fieldName
+		.replace(/([A-Z])/g, " $1")
+		.replace(/^./, (str) => str.toUpperCase())
+		.trim()
+}
+
+/**
+ * Validates that all providers have at least one API key field mapped
+ *
+ * @param {Array<string>} providerIds - All provider IDs
+ * @param {Object} providerApiKeyMap - Generated mapping
+ * @returns {Object} Validation result with warnings for unmapped providers
+ */
+export function validateApiKeyMappings(providerIds, providerApiKeyMap) {
+	const unmappedProviders = []
+	const warnings = []
+
+	for (const providerId of providerIds) {
+		if (!providerApiKeyMap[providerId] || providerApiKeyMap[providerId].length === 0) {
+			// Some providers don't require API keys - they use alternative authentication:
+			const noKeyProviders = ["vscode-lm", "ollama", "lmstudio", "claude-code", "oca", "vertex", "qwen-code"]
+
+			if (!noKeyProviders.includes(providerId)) {
+				unmappedProviders.push(providerId)
+				warnings.push(`WARNING: Provider "${providerId}" has no API key fields mapped`)
+			}
+		}
+	}
+
+	return {
+		valid: unmappedProviders.length === 0,
+		unmappedProviders,
+		warnings,
+		totalProviders: providerIds.length,
+		mappedProviders: Object.keys(providerApiKeyMap).length,
+	}
+}
diff --git a/apps/vscode/scripts/build-proto.mjs b/apps/vscode/scripts/build-proto.mjs
new file mode 100755
index 0000000..56ad8d1
--- /dev/null
+++ b/apps/vscode/scripts/build-proto.mjs
@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+import chalk from "chalk"
+import { execFileSync, execSync } from "child_process"
+import fsSync from "fs"
+import * as fs from "fs/promises"
+import { globby } from "globby"
+import { createRequire } from "module"
+import os from "os"
+import * as path from "path"
+import { rmrf } from "./file-utils.mjs"
+import { main as generateHostBridgeClient } from "./generate-host-bridge-client.mjs"
+import { main as generateProtoBusSetup } from "./generate-protobus-setup.mjs"
+
+const require = createRequire(import.meta.url)
+const isWindows = process.platform === "win32"
+// Resolve the grpc-tools package root via its package.json (stable regardless of `main`), so we
+// can both locate the bundled protoc and re-run its install script when the binary is missing.
+const GRPC_TOOLS_DIR = path.dirname(require.resolve("grpc-tools/package.json"))
+const GRPC_TOOLS_PROTOC = path.join(GRPC_TOOLS_DIR, "bin", isWindows ? "protoc.exe" : "protoc")
+// Legacy compatibility: some older/local Windows setups provision protoc into tmp-protoc.
+// Prefer that path when present, but fall back to the grpc-tools bundled binary used by CI/npm installs.
+const LEGACY_WINDOWS_PROTOC = path.resolve("tmp-protoc/bin/protoc.exe")
+const PROTOC = isWindows && fsSync.existsSync(LEGACY_WINDOWS_PROTOC) ? LEGACY_WINDOWS_PROTOC : GRPC_TOOLS_PROTOC
+
+// `bun install` skips grpc-tools' `install` lifecycle script (`node-pre-gyp install`), so the prebuilt
+// protoc is never downloaded into bin/. When it's missing, run that same command here to fetch it.
+// grpc-tools depends on @mapbox/node-pre-gyp, which exposes the `node-pre-gyp` CLI.
+function resolveNodePreGypCli() {
+	const candidates = ["@mapbox/node-pre-gyp/bin/node-pre-gyp", "node-pre-gyp/bin/node-pre-gyp"]
+	for (const candidate of candidates) {
+		try {
+			// Resolve from the grpc-tools package (its direct dependency).
+			return require.resolve(candidate, { paths: [GRPC_TOOLS_DIR] })
+		} catch {
+			// Fall back to resolving from this script's location (covers hoisted installs).
+			try {
+				return require.resolve(candidate)
+			} catch {
+				// try the next candidate
+			}
+		}
+	}
+	return null
+}
+
+function ensureProtocBinary() {
+	console.warn(chalk.yellow(`protoc not found at ${GRPC_TOOLS_PROTOC}; downloading the grpc-tools prebuilt binary...`))
+	const nodePreGypCli = resolveNodePreGypCli()
+	if (!nodePreGypCli) {
+		console.error(
+			chalk.red(
+				`Could not resolve the node-pre-gyp CLI from ${GRPC_TOOLS_DIR}. Run \`bun install\`, then retry \`bun run protos\`.`,
+			),
+		)
+		process.exit(1)
+	}
+	try {
+		// Mirrors grpc-tools' `scripts.install` ("node-pre-gyp install"): downloads the prebuilt
+		// protoc for the current platform/arch into grpc-tools/bin.
+		execFileSync(process.execPath, [nodePreGypCli, "install"], { cwd: GRPC_TOOLS_DIR, stdio: "inherit" })
+	} catch (error) {
+		console.error(chalk.red(`Failed to download protoc via node-pre-gyp: ${error?.message ?? error}`))
+		process.exit(1)
+	}
+	if (!fsSync.existsSync(GRPC_TOOLS_PROTOC)) {
+		console.error(chalk.red(`protoc still not found at ${GRPC_TOOLS_PROTOC} after node-pre-gyp install.`))
+		process.exit(1)
+	}
+	console.log(chalk.green("✓ protoc binary installed."))
+}
+
+if (!fsSync.existsSync(PROTOC)) {
+	// PROTOC only differs from GRPC_TOOLS_PROTOC when the legacy Windows path exists, so a missing
+	// PROTOC always means the grpc-tools-bundled protoc needs to be fetched.
+	ensureProtocBinary()
+}
+
+const PROTO_DIR = path.resolve("proto")
+const TS_OUT_DIR = path.resolve("src/shared/proto")
+const GRPC_JS_OUT_DIR = path.resolve("src/generated/grpc-js")
+const NICE_JS_OUT_DIR = path.resolve("src/generated/nice-grpc")
+const DESCRIPTOR_OUT_DIR = path.resolve("dist-standalone/proto")
+
+// protoc invokes the ts-proto plugin as a child process, so it needs a path it can
+// directly execute. On POSIX the package's JS bin (with its shebang) works. On
+// Windows protoc cannot exec a bare .js or bun's `.bunx` shim ("%1 is not a valid
+// Win32 application"), and the package manager's `.cmd` shim location/name varies
+// (npm vs bun's hoisted store). To be package-manager-agnostic, generate a tiny
+// .cmd wrapper that runs the resolved plugin JS via `node`.
+function resolveTsProtoPlugin() {
+	const pluginJs = require.resolve("ts-proto/protoc-gen-ts_proto")
+	if (!isWindows) {
+		return pluginJs
+	}
+	const wrapperDir = path.resolve("dist-standalone")
+	fsSync.mkdirSync(wrapperDir, { recursive: true })
+	const wrapperPath = path.join(wrapperDir, "protoc-gen-ts_proto.cmd")
+	// %* forwards protoc's plugin args/stdio to the JS entry run under node.
+	fsSync.writeFileSync(wrapperPath, `@echo off\r\nnode "${pluginJs}" %*\r\n`)
+	return wrapperPath
+}
+
+const TS_PROTO_PLUGIN = resolveTsProtoPlugin()
+
+const TS_PROTO_OPTIONS = [
+	"env=both",
+	"esModuleInterop=true",
+	"outputServices=generic-definitions", // output generic ServiceDefinitions
+	"outputIndex=true", // output an index file for each package which exports all protos in the package.
+	"useOptionals=none", // scalar and message fields are required unless they are marked as optional.
+	"useDate=false", // Timestamp fields will not be automatically converted to Date.
+]
+
+async function main() {
+	await cleanup()
+	await compileProtos()
+	await generateProtoBusSetup()
+	await generateHostBridgeClient()
+}
+async function compileProtos() {
+	console.log(chalk.bold.blue("Compiling Protocol Buffers..."))
+
+	// Check for Apple Silicon compatibility before proceeding
+	checkAppleSiliconCompatibility()
+
+	// Create output directories if they don't exist
+	for (const dir of [TS_OUT_DIR, GRPC_JS_OUT_DIR, NICE_JS_OUT_DIR, DESCRIPTOR_OUT_DIR]) {
+		await fs.mkdir(dir, { recursive: true })
+	}
+
+	// Process all proto files
+	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR, realpath: true })
+	console.log(chalk.cyan(`Processing ${protoFiles.length} proto files from`), PROTO_DIR)
+
+	tsProtoc(TS_OUT_DIR, protoFiles, TS_PROTO_OPTIONS)
+	// grpc-js is used to generate service impls for the ProtoBus service.
+	tsProtoc(GRPC_JS_OUT_DIR, protoFiles, ["outputServices=grpc-js", ...TS_PROTO_OPTIONS])
+	// nice-js is used for the Host Bridge client impls because it uses promises.
+	tsProtoc(NICE_JS_OUT_DIR, protoFiles, ["outputServices=nice-grpc,useExactTypes=false", ...TS_PROTO_OPTIONS])
+
+	const descriptorFile = path.join(DESCRIPTOR_OUT_DIR, "descriptor_set.pb")
+	const descriptorProtocArgs = [
+		`--proto_path=${PROTO_DIR}`,
+		`--descriptor_set_out=${descriptorFile}`,
+		"--include_imports",
+		...protoFiles,
+	]
+	try {
+		log_verbose(chalk.cyan("Generating descriptor set..."))
+		log_verbose(`${PROTOC} ${descriptorProtocArgs.join(" ")}`)
+		execFileSync(PROTOC, descriptorProtocArgs, { stdio: "inherit" })
+	} catch (error) {
+		console.error(chalk.red("Error generating descriptor set for proto file:"), error)
+		process.exit(1)
+	}
+
+	log_verbose(chalk.green("Protocol Buffer code generation completed successfully."))
+	log_verbose(chalk.green(`TypeScript files generated in: ${TS_OUT_DIR}`))
+}
+
+function tsProtoc(outDir, protoFiles, protoOptions) {
+	const args = [
+		`--proto_path=${PROTO_DIR}`,
+		`--plugin=protoc-gen-ts_proto=${TS_PROTO_PLUGIN}`,
+		`--ts_proto_out=${outDir}`,
+		`--ts_proto_opt=${protoOptions.join(",")}`,
+		...protoFiles,
+	]
+	try {
+		log_verbose(chalk.cyan(`Generating TypeScript code in ${outDir} for:\n${protoFiles.join("\n")}...`))
+		log_verbose(`${PROTOC} ${args.join(" ")}`)
+		execFileSync(PROTOC, args, { stdio: "inherit" })
+	} catch (error) {
+		console.error(chalk.red("Error generating TypeScript for proto files:"), error)
+		process.exit(1)
+	}
+}
+
+async function cleanup() {
+	// Clean up existing generated files
+	log_verbose(chalk.cyan("Cleaning up existing generated TypeScript files..."))
+	await rmrf(TS_OUT_DIR)
+	await rmrf("src/generated")
+
+	// Clean up generated files that were moved.
+	await rmrf("src/standalone/services/host-grpc-client.ts")
+	await rmrf("src/standalone/server-setup.ts")
+	await rmrf("src/hosts/vscode/host-grpc-service-config.ts")
+	await rmrf("src/core/controller/grpc-service-config.ts")
+	const oldhostbridgefiles = [
+		"src/hosts/vscode/workspace/methods.ts",
+		"src/hosts/vscode/workspace/index.ts",
+		"src/hosts/vscode/diff/methods.ts",
+		"src/hosts/vscode/diff/index.ts",
+		"src/hosts/vscode/env/methods.ts",
+		"src/hosts/vscode/env/index.ts",
+		"src/hosts/vscode/window/methods.ts",
+		"src/hosts/vscode/window/index.ts",
+		"src/hosts/vscode/watch/methods.ts",
+		"src/hosts/vscode/watch/index.ts",
+		"src/hosts/vscode/uri/methods.ts",
+		"src/hosts/vscode/uri/index.ts",
+	]
+	const oldprotobusfiles = [
+		"src/core/controller/account/index.ts",
+		"src/core/controller/account/methods.ts",
+		"src/core/controller/browser/index.ts",
+		"src/core/controller/browser/methods.ts",
+		"src/core/controller/checkpoints/index.ts",
+		"src/core/controller/checkpoints/methods.ts",
+		"src/core/controller/file/index.ts",
+		"src/core/controller/file/methods.ts",
+		"src/core/controller/mcp/index.ts",
+		"src/core/controller/mcp/methods.ts",
+		"src/core/controller/models/index.ts",
+		"src/core/controller/models/methods.ts",
+		"src/core/controller/slash/index.ts",
+		"src/core/controller/slash/methods.ts",
+		"src/core/controller/state/index.ts",
+		"src/core/controller/state/methods.ts",
+		"src/core/controller/task/index.ts",
+		"src/core/controller/task/methods.ts",
+		"src/core/controller/ui/index.ts",
+		"src/core/controller/ui/methods.ts",
+		"src/core/controller/web/index.ts",
+		"src/core/controller/web/methods.ts",
+	]
+	for (const file of [...oldhostbridgefiles, ...oldprotobusfiles]) {
+		await rmrf(file)
+	}
+}
+
+// Check for Apple Silicon compatibility
+function checkAppleSiliconCompatibility() {
+	// Only run check on macOS
+	if (process.platform !== "darwin") {
+		return
+	}
+
+	// Check if running on Apple Silicon
+	const cpuArchitecture = os.arch()
+	if (cpuArchitecture === "arm64") {
+		try {
+			// Check if Rosetta is installed
+			const rosettaCheck = execSync('/usr/bin/pgrep oahd || echo "NOT_INSTALLED"').toString().trim()
+
+			if (rosettaCheck === "NOT_INSTALLED") {
+				console.log(chalk.yellow("Detected Apple Silicon (ARM64) architecture."))
+				console.log(
+					chalk.red("Rosetta 2 is NOT installed. The npm version of protoc is not compatible with Apple Silicon."),
+				)
+				console.log(chalk.cyan("Please install Rosetta 2 using the following command:"))
+				console.log(chalk.cyan("  softwareupdate --install-rosetta --agree-to-license"))
+				console.log(chalk.red("Aborting build process."))
+				process.exit(1)
+			}
+		} catch (_error) {
+			console.log(chalk.yellow("Could not determine Rosetta installation status. Proceeding anyway."))
+		}
+	}
+}
+
+function log_verbose(s) {
+	if (process.argv.includes("-v") || process.argv.includes("--verbose")) {
+		console.log(s)
+	}
+}
+
+// Run the main function
+main().catch((error) => {
+	console.error(chalk.red("Error:"), error)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/build-python-proto.mjs b/apps/vscode/scripts/build-python-proto.mjs
new file mode 100644
index 0000000..946eb66
--- /dev/null
+++ b/apps/vscode/scripts/build-python-proto.mjs
@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+
+import chalk from "chalk"
+import { execSync } from "child_process"
+import * as fs from "fs/promises"
+import { globby } from "globby"
+import * as path from "path"
+import { fileURLToPath } from "url"
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url))
+const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
+const PROTO_DIR = path.join(ROOT_DIR, "proto")
+const PY_OUT_DIR = path.join(ROOT_DIR, "src", "generated", "grpc-python")
+const PY_CLIENT_DIR = path.join(PY_OUT_DIR, "client")
+
+function hasCommand(cmd) {
+	try {
+		if (process.platform === "win32") {
+			execSync(`where ${cmd}`, { stdio: "pipe" })
+		} else {
+			execSync(`which ${cmd}`, { stdio: "pipe" })
+		}
+		return true
+	} catch {
+		return false
+	}
+}
+
+function resolvePython() {
+	// Allow override via env.PYTHON pointing to a specific interpreter
+	const envPy = process.env.PYTHON
+	if (envPy) {
+		try {
+			execSync(`"${envPy}" --version`, { stdio: "pipe" })
+			return envPy
+		} catch {
+			console.warn(chalk.yellow(`Warning: PYTHON override "${envPy}" is not usable, falling back to discovery.`))
+		}
+	}
+	const candidates = ["python3", "python"]
+	for (const c of candidates) {
+		if (hasCommand(c)) {
+			try {
+				execSync(`${c} --version`, { stdio: "pipe" })
+				return c
+			} catch {
+				// continue
+			}
+		}
+	}
+	return null
+}
+
+function checkGrpcTools(pythonExe) {
+	try {
+		execSync(`"${pythonExe}" -c "import grpc_tools"`, { stdio: "pipe" })
+		return true
+	} catch {
+		return false
+	}
+}
+
+async function ensureDir(dir) {
+	await fs.mkdir(dir, { recursive: true })
+}
+
+async function ensureInitPy(dir) {
+	try {
+		await fs.writeFile(path.join(dir, "__init__.py"), "", { flag: "wx" })
+	} catch {
+		// exists
+	}
+}
+
+/**
+ * Parse proto files to extract service names with their source file and package.
+ * Returns array of:
+ * { serviceName: string, serviceKey: string, protoPackage: "cline"|"host", moduleBase: string }
+ */
+async function parseServicesWithFiles(protoDir, protoFiles) {
+	const services = []
+	for (const relPath of protoFiles) {
+		const full = path.join(protoDir, relPath)
+		const content = await fs.readFile(full, "utf8")
+		const pkg = relPath.startsWith("host/") ? "host" : "cline"
+		const moduleBase = path.basename(relPath, ".proto")
+		const serviceRe = /service\s+(\w+Service)\s*\{([\s\S]*?)\}/g
+		for (const m of content.matchAll(serviceRe)) {
+			const serviceName = m[1] // e.g., TaskService
+			const serviceKey = serviceName.replace(/Service$/, "").toLowerCase() // task
+			const body = m[2]
+			const methodRe = /rpc\s+(\w+)\s*\((stream\s)?([\w.]+)\)\s*returns\s*\((stream\s)?([\w.]+)\)/g
+			const methods = []
+			for (const mm of body.matchAll(methodRe)) {
+				methods.push({
+					name: mm[1],
+					isRequestStreaming: !!mm[2],
+					requestType: mm[3],
+					isResponseStreaming: !!mm[4],
+					responseType: mm[5],
+				})
+			}
+			services.push({ serviceName, serviceKey, protoPackage: pkg, moduleBase, methods })
+		}
+	}
+	return services
+}
+
+function upperFirst(s) {
+	return s.length ? s[0].toUpperCase() + s.slice(1) : s
+}
+
+async function generateConnectionPy(outDir) {
+	const content = `# AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+# Generated by scripts/build-python-proto.mjs
+
+import grpc
+import time
+from typing import Optional
+
+class ConnectionManager:
+    def __init__(self, address: str, timeout: float = 30.0):
+        self.address = address
+        self.timeout = timeout
+        self._channel: Optional[grpc.Channel] = None
+
+    def connect(self) -> None:
+        if self._channel is not None:
+            return
+        self._channel = grpc.insecure_channel(self.address)
+        # Wait for channel to be ready within timeout
+        grpc.channel_ready_future(self._channel).result(timeout=self.timeout)
+
+    def disconnect(self) -> None:
+        if self._channel is not None:
+            self._channel.close()
+            self._channel = None
+
+    @property
+    def channel(self) -> Optional[grpc.Channel]:
+        return self._channel
+
+    def is_connected(self) -> bool:
+        return self._channel is not None
+`
+	await fs.mkdir(outDir, { recursive: true })
+	await fs.writeFile(path.join(outDir, "connection.py"), content)
+	await ensureInitPy(outDir)
+}
+
+async function generateClineClientPy(outDir, services) {
+	// Import per-service wrapper clients
+	const importLines = []
+	const seen = new Set()
+	for (const s of services) {
+		const fileBase = `${s.serviceKey}_client`
+		const className = `${s.serviceName.replace(/Service$/, "")}Client`
+		const importKey = `${fileBase}:${className}`
+		if (!seen.has(importKey)) {
+			importLines.push(`from .services.${fileBase} import ${className}`)
+			seen.add(importKey)
+		}
+	}
+
+	// Build wrapper initializations on connect (like Go New<Service>Client)
+	const initLines = services.map((s) => {
+		const shortName = s.serviceName.replace(/Service$/, "") // Task
+		const className = `${shortName}Client`
+		return `        self.${shortName} = ${className}(self._conn.channel)`
+	})
+
+	// Build attribute resets on disconnect
+	const nilLines = services.map((s) => {
+		const shortName = s.serviceName.replace(/Service$/, "")
+		return `        self.${shortName} = None`
+	})
+
+	const content = `# AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+# Generated by scripts/build-python-proto.mjs
+
+from typing import Optional
+
+import grpc
+from .connection import ConnectionManager
+${importLines.join("\n")}
+
+class ClineClient:
+    """
+    Unified Python client analogous to src/generated/grpc-go/client/ClineClient.
+
+    Usage:
+        client = ClineClient("localhost:17611")
+        client.connect()
+        # Call wrappers, e.g.: client.Task.SomeRpc(...)
+        client.disconnect()
+    """
+
+    def __init__(self, address: str, timeout: float = 30.0):
+        self._conn = ConnectionManager(address, timeout=timeout)
+        self._connected = False
+
+${services.map((s) => `        self.${s.serviceName.replace(/Service$/, "")}: Optional[object] = None`).join("\n")}
+
+    def connect(self) -> None:
+        if self._connected:
+            return
+        self._conn.connect()
+${initLines.join("\n")}
+        self._connected = True
+
+    def disconnect(self) -> None:
+        if not self._connected:
+            return
+        self._conn.disconnect()
+${nilLines.join("\n")}
+        self._connected = False
+
+    def is_connected(self) -> bool:
+        return self._connected
+
+    @property
+    def channel(self) -> Optional[grpc.Channel]:
+        return self._conn.channel
+`
+	const clientDir = outDir
+	await fs.mkdir(clientDir, { recursive: true })
+	await fs.writeFile(path.join(clientDir, "cline_client.py"), content)
+}
+
+async function generatePythonClient(protoDir, pyOutDir, clientDir, protoFiles) {
+	// Ensure package structure for client
+	await fs.mkdir(clientDir, { recursive: true })
+	await ensureInitPy(pyOutDir)
+	await ensureInitPy(clientDir)
+
+	const services = await parseServicesWithFiles(protoDir, protoFiles)
+
+	// connection.py
+	await generateConnectionPy(clientDir)
+
+	// services/ per-service wrappers (mirror Go client/services)
+	const servicesDir = path.join(clientDir, "services")
+	await fs.mkdir(servicesDir, { recursive: true })
+	await ensureInitPy(servicesDir)
+	await generateServiceClientsPy(servicesDir, services)
+
+	// cline_client.py (unified that composes service wrappers)
+	await generateClineClientPy(clientDir, services)
+}
+
+async function generateServiceClientsPy(outDir, services) {
+	await fs.mkdir(outDir, { recursive: true })
+	await ensureInitPy(outDir)
+
+	for (const s of services) {
+		const shortName = s.serviceName.replace(/Service$/, "") // Task
+		const className = `${shortName}Client`
+		const fileName = `${s.serviceKey}_client.py`
+
+		const aliasPb2 = `${s.protoPackage}_${s.moduleBase}_pb2`
+		const aliasGrpc = `${s.protoPackage}_${s.moduleBase}_pb2_grpc`
+
+		const methodLines = s.methods
+			.map((m) => {
+				const reqTypeName = m.requestType.split(".").pop()
+				const respTypeName = m.responseType.split(".").pop()
+				if (m.isResponseStreaming) {
+					return `
+    def ${m.name}(self, req):
+        """
+        Server-streaming RPC.
+        :param req: ${aliasPb2}.${reqTypeName}
+        :return: iterator of ${aliasPb2}.${respTypeName}
+        """
+        return self._stub.${m.name}(req)`
+				} else {
+					return `
+    def ${m.name}(self, req):
+        """
+        Unary RPC.
+        :param req: ${aliasPb2}.${reqTypeName}
+        :return: ${aliasPb2}.${respTypeName}
+        """
+        return self._stub.${m.name}(req)`
+				}
+			})
+			.join("\n")
+
+		const content = `# AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+# Generated by scripts/build-python-proto.mjs
+
+import grpc
+from ${s.protoPackage} import ${s.moduleBase}_pb2 as ${aliasPb2}
+from ${s.protoPackage} import ${s.moduleBase}_pb2_grpc as ${aliasGrpc}
+
+class ${className}:
+    def __init__(self, channel: grpc.Channel):
+        self._stub = ${aliasGrpc}.${s.serviceName}Stub(channel)
+${methodLines}
+`
+		await fs.writeFile(path.join(outDir, fileName), content)
+	}
+}
+
+async function generatePyproject(outDir) {
+	const content = `[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cline-grpc-python"
+version = "0.1.0"
+description = "Generated Python gRPC stubs and client wrappers for Cline protos"
+license = { text: "Apache-2.0" }
+requires-python = ">=3.9"
+dependencies = [
+  "grpcio>=1.56.0",
+  "protobuf>=4.21.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+`
+	await fs.writeFile(path.join(outDir, "pyproject.toml"), content)
+}
+
+async function main() {
+	console.log(chalk.cyan("Starting Python protobuf code generation..."))
+
+	// Verify proto dir exists
+	try {
+		const stat = await fs.stat(PROTO_DIR)
+		if (!stat.isDirectory()) {
+			console.error(chalk.red(`Proto directory is not a folder: ${PROTO_DIR}`))
+			process.exit(1)
+		}
+	} catch {
+		console.error(chalk.red(`Proto directory not found: ${PROTO_DIR}`))
+		process.exit(1)
+	}
+
+	// Resolve Python
+	const python = resolvePython()
+	if (!python) {
+		console.error(
+			chalk.red("Python not found on PATH. Please install Python 3 and ensure it is available (python3 or python)."),
+		)
+		process.exit(1)
+	}
+	console.log(chalk.green(`✓ Using Python executable: ${python}`))
+
+	// Check grpcio-tools
+	if (!checkGrpcTools(python)) {
+		console.error(chalk.red("Missing dependency: grpcio-tools"))
+		console.log(chalk.yellow("Install with:"))
+		console.log(chalk.yellow(`  ${python} -m pip install grpcio-tools --user --break-system-packages`))
+		process.exit(1)
+	}
+	console.log(chalk.green("✓ grpcio-tools available"))
+
+	// Discover proto files
+	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR })
+	if (!protoFiles.length) {
+		console.error(chalk.red("No .proto files found under ./proto"))
+		process.exit(1)
+	}
+	console.log(chalk.cyan(`Found ${protoFiles.length} proto files`))
+
+	// Ensure output directory
+	await ensureDir(PY_OUT_DIR)
+
+	// Build and run protoc command via grpc_tools
+	const quoted = (s) => `"${s}"`
+	const pythonCmd = quoted(python)
+	const cmd =
+		`${pythonCmd} -m grpc_tools.protoc ` +
+		`-I ${quoted(PROTO_DIR)} ` +
+		`--python_out=${quoted(PY_OUT_DIR)} ` +
+		`--grpc_python_out=${quoted(PY_OUT_DIR)} ` +
+		protoFiles.map((f) => quoted(f)).join(" ")
+
+	try {
+		console.log(chalk.cyan(`Generating Python code into ${PY_OUT_DIR}...`))
+		execSync(cmd, { cwd: ROOT_DIR, stdio: "inherit", env: process.env })
+	} catch (error) {
+		console.error(chalk.red("Error generating Python code:"), error?.message || error)
+		process.exit(1)
+	}
+
+	// Ensure package structure (__init__.py) for imports
+	await ensureInitPy(PY_OUT_DIR)
+	try {
+		const clineDir = path.join(PY_OUT_DIR, "cline")
+		const hostDir = path.join(PY_OUT_DIR, "host")
+		// These may or may not exist depending on which protos are present
+		await fs
+			.stat(clineDir)
+			.then(() => ensureInitPy(clineDir))
+			.catch(() => {})
+		await fs
+			.stat(hostDir)
+			.then(() => ensureInitPy(hostDir))
+			.catch(() => {})
+	} catch {
+		// ignore
+	}
+
+	// Generate Python client structure analogous to src/generated/grpc-go/client
+	await generatePythonClient(PROTO_DIR, PY_OUT_DIR, PY_CLIENT_DIR, protoFiles)
+
+	// Generate a minimal pyproject.toml in the generated output so it can be pip-installed if desired
+	await generatePyproject(PY_OUT_DIR)
+
+	console.log(chalk.green("✓ Python protobuf and client code generation completed successfully!"))
+	console.log(chalk.cyan(`Output directory: ${PY_OUT_DIR}`))
+	console.log(chalk.cyan(`Client directory: ${PY_CLIENT_DIR}`))
+	console.log(chalk.cyan(`PyProject: ${path.join(PY_OUT_DIR, "pyproject.toml")}`))
+	console.log(chalk.gray("Note: To import, add the output dir to your PYTHONPATH or pip install -e src/generated/grpc-python"))
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((err) => {
+		console.error(chalk.red("Unexpected error in build-python-proto.mjs:"), err)
+		process.exit(1)
+	})
+}
diff --git a/apps/vscode/scripts/build-tests.js b/apps/vscode/scripts/build-tests.js
new file mode 100755
index 0000000..65be229
--- /dev/null
+++ b/apps/vscode/scripts/build-tests.js
@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+const { execSync } = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const esbuild = require("esbuild")
+
+const watch = process.argv.includes("--watch")
+
+/**
+ * @type {import('esbuild').Plugin}
+ */
+const esbuildProblemMatcherPlugin = {
+	name: "esbuild-problem-matcher",
+
+	setup(build) {
+		build.onStart(() => {
+			console.log("[watch] build started")
+		})
+		build.onEnd((result) => {
+			result.errors.forEach(({ text, location }) => {
+				console.error(`✘ [ERROR] ${text}`)
+				console.error(`    ${location.file}:${location.line}:${location.column}:`)
+			})
+			console.log("[watch] build finished")
+		})
+	},
+}
+
+const srcConfig = {
+	bundle: true,
+	minify: false,
+	sourcemap: true,
+	sourcesContent: true,
+	logLevel: "silent",
+	entryPoints: ["src/packages/**/*.ts"],
+	outdir: "out/packages",
+	format: "cjs",
+	platform: "node",
+	define: {
+		"process.env.IS_TEST": "true",
+	},
+	external: ["vscode"],
+	plugins: [esbuildProblemMatcherPlugin],
+}
+
+async function main() {
+	const srcCtx = await esbuild.context(srcConfig)
+
+	if (watch) {
+		await srcCtx.watch()
+	} else {
+		await srcCtx.rebuild()
+
+		await srcCtx.dispose()
+	}
+}
+
+// tsc does not delete output for source/tests that were removed or are no longer
+// part of tsconfig.test.json. The VS Code test runner globs out/src/**/*.test.js,
+// so stale compiled tests can still run unless we clear the test build output first.
+fs.rmSync(path.join(__dirname, "..", "out", "src"), { recursive: true, force: true })
+fs.rmSync(path.join(__dirname, "..", "out", "packages"), { recursive: true, force: true })
+
+// Single source of truth for the test-runner split: any *.test.ts that imports
+// from "bun:test" is owned by the bun runner (scripts/run-bun-unit-tests.ts),
+// and any that imports from "vitest" is owned by the vitest runner (test:vitest,
+// see vitest.config.ts). Neither may be compiled into the Node-based
+// @vscode/test-cli `out/` tree: Node cannot load `bun:test`, and vitest suites
+// use vitest-only APIs/matchers (e.g. `toHaveBeenCalledWith`) that the mocha
+// runner does not provide. Generate a tsconfig that excludes them so the
+// integration compile only ever sees mocha-owned tests.
+const projectRoot = path.join(__dirname, "..")
+const nonMochaTestImport =
+	/from\s+["'](?:bun:test|vitest(?:\/[^"']*)?|@vitest\/[^"']*)["']/
+function collectNonMochaTestFiles(dir, acc) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name === "node_modules") continue
+		const full = path.join(dir, entry.name)
+		if (entry.isDirectory()) {
+			collectNonMochaTestFiles(full, acc)
+		} else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
+			if (nonMochaTestImport.test(fs.readFileSync(full, "utf-8"))) {
+				acc.push(path.relative(projectRoot, full).split(path.sep).join("/"))
+			}
+		}
+	}
+	return acc
+}
+const nonMochaOwnedTests = collectNonMochaTestFiles(path.join(projectRoot, "src"), [])
+// tsconfig.test.json is JSONC (contains comments); parse with json5 (a project dep).
+const JSON5 = require("json5")
+const baseTestConfig = JSON5.parse(fs.readFileSync(path.join(projectRoot, "tsconfig.test.json"), "utf-8"))
+baseTestConfig.exclude = [...(baseTestConfig.exclude ?? []), ...nonMochaOwnedTests]
+const generatedConfigPath = path.join(projectRoot, "tsconfig.test.generated.json")
+fs.writeFileSync(generatedConfigPath, JSON.stringify(baseTestConfig, null, "\t"))
+
+execSync(`tsc -p ${JSON.stringify(generatedConfigPath)} --outDir out`, { encoding: "utf-8" })
+
+main().catch((e) => {
+	console.error(e)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/clean-webview-vite-cache.mjs b/apps/vscode/scripts/clean-webview-vite-cache.mjs
new file mode 100644
index 0000000..bba1125
--- /dev/null
+++ b/apps/vscode/scripts/clean-webview-vite-cache.mjs
@@ -0,0 +1,6 @@
+import { rm } from "node:fs/promises"
+import path from "node:path"
+
+const viteCachePath = path.join(import.meta.dirname, "..", "webview-ui", "node_modules", ".vite")
+
+await rm(viteCachePath, { recursive: true, force: true })
diff --git a/apps/vscode/scripts/download-ripgrep.mjs b/apps/vscode/scripts/download-ripgrep.mjs
new file mode 100755
index 0000000..3709e6d
--- /dev/null
+++ b/apps/vscode/scripts/download-ripgrep.mjs
@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+/**
+ * Download ripgrep binaries for all target platforms
+ * This script downloads official ripgrep binaries from GitHub releases
+ * and extracts them to dist-standalone/ripgrep-binaries/
+ */
+
+import { exec } from "child_process"
+import fs from "fs"
+import https from "https"
+import path from "path"
+import { pipeline } from "stream/promises"
+import * as tar from "tar"
+import { promisify } from "util"
+import { createGunzip } from "zlib"
+
+const execAsync = promisify(exec)
+
+const RIPGREP_VERSION = "14.1.1"
+const OUTPUT_DIR = "dist-standalone/ripgrep-binaries"
+
+// Platform configurations
+const PLATFORMS = [
+	{
+		name: "darwin-x64",
+		archiveName: `ripgrep-${RIPGREP_VERSION}-x86_64-apple-darwin.tar.gz`,
+		url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-x86_64-apple-darwin.tar.gz`,
+		binaryPath: "rg",
+		isZip: false,
+	},
+	{
+		name: "darwin-arm64",
+		archiveName: `ripgrep-${RIPGREP_VERSION}-aarch64-apple-darwin.tar.gz`,
+		url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-aarch64-apple-darwin.tar.gz`,
+		binaryPath: "rg",
+		isZip: false,
+	},
+	{
+		name: "linux-x64",
+		archiveName: `ripgrep-${RIPGREP_VERSION}-x86_64-unknown-linux-musl.tar.gz`,
+		url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-x86_64-unknown-linux-musl.tar.gz`,
+		binaryPath: "rg",
+		isZip: false,
+	},
+	{
+		name: "linux-aarch64",
+		archiveName: `ripgrep-${RIPGREP_VERSION}-aarch64-unknown-linux-gnu.tar.gz`,
+		url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-aarch64-unknown-linux-gnu.tar.gz`,
+		binaryPath: "rg",
+		isZip: false,
+	},
+	{
+		name: "win-x64",
+		archiveName: `ripgrep-${RIPGREP_VERSION}-x86_64-pc-windows-msvc.zip`,
+		url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-x86_64-pc-windows-msvc.zip`,
+		binaryPath: "rg.exe",
+		isZip: true,
+	},
+]
+
+/**
+ * Download a file from a URL
+ */
+async function downloadFile(url, destPath) {
+	return new Promise((resolve, reject) => {
+		console.log(`  Downloading: ${url}`)
+		const file = fs.createWriteStream(destPath)
+
+		https
+			.get(url, (response) => {
+				if (response.statusCode === 302 || response.statusCode === 301) {
+					// Handle redirect
+					return downloadFile(response.headers.location, destPath).then(resolve).catch(reject)
+				}
+
+				if (response.statusCode !== 200) {
+					reject(new Error(`Failed to download: ${response.statusCode} ${response.statusMessage}`))
+					return
+				}
+
+				response.pipe(file)
+
+				file.on("finish", () => {
+					file.close()
+					resolve()
+				})
+			})
+			.on("error", (err) => {
+				fs.unlink(destPath, () => {}) // Delete the file on error
+				reject(err)
+			})
+
+		file.on("error", (err) => {
+			fs.unlink(destPath, () => {}) // Delete the file on error
+			reject(err)
+		})
+	})
+}
+
+/**
+ * Extract a tar.gz file
+ */
+async function extractTarGz(tarPath, destDir) {
+	console.log(`  Extracting tar.gz to: ${destDir}`)
+
+	return pipeline(
+		fs.createReadStream(tarPath),
+		createGunzip(),
+		tar.extract({
+			cwd: destDir,
+			strip: 1, // Remove the top-level directory from the archive
+		}),
+	)
+}
+
+/**
+ * Extract a zip file using unzip command
+ */
+async function extractZip(zipPath, destDir) {
+	console.log(`  Extracting zip to: ${destDir}`)
+
+	try {
+		// Use -o to overwrite existing files without prompting
+		await execAsync(`unzip -o -q "${zipPath}" -d "${destDir}"`)
+
+		// Find the extracted directory (usually ripgrep-VERSION-arch)
+		const items = fs.readdirSync(destDir)
+		const extractedDir = items.find((item) => item.startsWith("ripgrep-"))
+
+		if (extractedDir) {
+			// Move files from subdirectory to destDir
+			const subDir = path.join(destDir, extractedDir)
+			const files = fs.readdirSync(subDir)
+
+			for (const file of files) {
+				const srcPath = path.join(subDir, file)
+				const destPath = path.join(destDir, file)
+
+				// Remove destination if it exists (to avoid ENOTEMPTY error)
+				if (fs.existsSync(destPath)) {
+					const stats = fs.statSync(destPath)
+					if (stats.isDirectory()) {
+						fs.rmSync(destPath, { recursive: true, force: true })
+					} else {
+						fs.unlinkSync(destPath)
+					}
+				}
+
+				fs.renameSync(srcPath, destPath)
+			}
+
+			// Remove the now-empty subdirectory
+			fs.rmdirSync(subDir)
+		}
+	} catch (error) {
+		throw new Error(`Failed to extract zip: ${error.message}`)
+	}
+}
+
+/**
+ * Download and extract ripgrep for a specific platform
+ */
+async function downloadRipgrepForPlatform(platform) {
+	console.log(`\n📦 Processing ${platform.name}...`)
+
+	const platformDir = path.join(OUTPUT_DIR, platform.name)
+	const archivePath = path.join(OUTPUT_DIR, platform.archiveName)
+
+	// Create output directory
+	fs.mkdirSync(platformDir, { recursive: true })
+
+	try {
+		// Download
+		await downloadFile(platform.url, archivePath)
+		console.log(`  ✓ Downloaded`)
+
+		// Extract
+		if (platform.isZip) {
+			await extractZip(archivePath, platformDir)
+		} else {
+			await extractTarGz(archivePath, platformDir)
+		}
+		console.log(`  ✓ Extracted`)
+
+		// Verify the binary exists
+		const binaryPath = path.join(platformDir, platform.binaryPath)
+		if (!fs.existsSync(binaryPath)) {
+			throw new Error(`Binary not found at ${binaryPath}`)
+		}
+
+		// Make binary executable (Unix only)
+		if (!platform.isZip) {
+			fs.chmodSync(binaryPath, 0o755)
+		}
+		console.log(`  ✓ Binary ready: ${binaryPath}`)
+
+		// Clean up archive file
+		fs.unlinkSync(archivePath)
+		console.log(`  ✓ Cleaned up`)
+
+		return true
+	} catch (error) {
+		console.error(`  ✗ Failed: ${error.message}`)
+		throw error
+	}
+}
+
+/**
+ * Main function
+ */
+async function main() {
+	console.log("🚀 Ripgrep Binary Downloader")
+	console.log(`   Version: ${RIPGREP_VERSION}`)
+	console.log(`   Output: ${OUTPUT_DIR}`)
+
+	// Create output directory
+	fs.mkdirSync(OUTPUT_DIR, { recursive: true })
+
+	// Download for all platforms
+	const results = []
+	for (const platform of PLATFORMS) {
+		try {
+			await downloadRipgrepForPlatform(platform)
+			results.push({ platform: platform.name, success: true })
+		} catch (error) {
+			results.push({ platform: platform.name, success: false, error: error.message })
+		}
+	}
+
+	// Print summary
+	console.log("\n" + "=".repeat(50))
+	console.log("📊 Summary:")
+	console.log("=".repeat(50))
+
+	let successCount = 0
+	for (const result of results) {
+		const status = result.success ? "✅" : "❌"
+		console.log(`${status} ${result.platform}`)
+		if (result.success) {
+			successCount++
+		} else {
+			console.log(`   Error: ${result.error}`)
+		}
+	}
+
+	console.log("=".repeat(50))
+	console.log(`✓ ${successCount}/${PLATFORMS.length} platforms successful`)
+
+	if (successCount < PLATFORMS.length) {
+		process.exit(1)
+	}
+
+	console.log("\n✅ All ripgrep binaries downloaded successfully!")
+}
+
+// Run the script
+main().catch((error) => {
+	console.error("\n❌ Fatal error:", error)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/file-utils.mjs b/apps/vscode/scripts/file-utils.mjs
new file mode 100644
index 0000000..1fb4e3d
--- /dev/null
+++ b/apps/vscode/scripts/file-utils.mjs
@@ -0,0 +1,27 @@
+import * as fs from "fs/promises"
+import * as path from "path"
+/**
+ * Write `contents` to `filePath`, creating any necessary directories in `filePath`.
+ */
+export async function writeFileWithMkdirs(filePath, content) {
+	await fs.mkdir(path.dirname(filePath), { recursive: true })
+	await fs.writeFile(filePath, content)
+}
+
+export async function rmrf(path) {
+	await fs.rm(path, { force: true, recursive: true })
+}
+
+/**
+ * Remove an empty dir, do nothing if the directory doesn't exist or is not empty.
+ */
+export async function rmdir(path) {
+	try {
+		await fs.rmdir(path)
+	} catch (error) {
+		if (error.code !== "ENOTEMPTY" && error.code !== "ENOENT") {
+			// Only re-throw if it's not "not empty" or "doesn't exist"
+			throw error
+		}
+	}
+}
diff --git a/apps/vscode/scripts/find-dead-src.mjs b/apps/vscode/scripts/find-dead-src.mjs
new file mode 100644
index 0000000..fcdc5d0
--- /dev/null
+++ b/apps/vscode/scripts/find-dead-src.mjs
@@ -0,0 +1,129 @@
+// Dead-source finder: uses esbuild's own bundle reachability (the same analysis
+// that drives tree-shaking + minification mangling) to compute which src/ files
+// are reachable from BOTH shipped entry points:
+//   - src/extension.ts            (VS Code extension host)
+//   - src/standalone/cline-core.ts (standalone host used by JetBrains + CLI)
+//
+// A src/*.ts file that is NOT in the union of metafile inputs for those two
+// builds is unreachable from any shipped entry => dead (modulo dynamic import()
+// of computed specifiers, which esbuild surfaces separately).
+//
+// Run: node scripts/find-dead-src.mjs
+
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import * as esbuild from "esbuild"
+import { glob } from "glob"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const root = path.resolve(__dirname, "..")
+
+const aliases = {
+	"@": path.join(root, "src"),
+	"@core": path.join(root, "src/core"),
+	"@integrations": path.join(root, "src/integrations"),
+	"@services": path.join(root, "src/services"),
+	"@shared": path.join(root, "src/shared"),
+	"@utils": path.join(root, "src/utils"),
+	"@packages": path.join(root, "src/packages"),
+}
+
+const aliasResolverPlugin = {
+	name: "alias-resolver",
+	setup(build) {
+		for (const [alias, aliasPath] of Object.entries(aliases)) {
+			const aliasRegex = new RegExp(`^${alias}($|/.*)`)
+			build.onResolve({ filter: aliasRegex }, (args) => {
+				const importPath = args.path.replace(alias, aliasPath)
+				const exts = [".ts", ".tsx", ".js", ".jsx"]
+				if (fs.existsSync(importPath)) {
+					const stats = fs.statSync(importPath)
+					if (stats.isDirectory()) {
+						for (const ext of exts) {
+							const idx = path.join(importPath, `index${ext}`)
+							if (fs.existsSync(idx)) return { path: idx }
+						}
+					} else {
+						return { path: importPath }
+					}
+				}
+				for (const ext of exts) {
+					if (fs.existsSync(`${importPath}${ext}`)) return { path: `${importPath}${ext}` }
+				}
+				return undefined
+			})
+		}
+	},
+}
+
+const common = {
+	bundle: true,
+	minify: false,
+	sourcemap: false,
+	logLevel: "silent",
+	format: "cjs",
+	platform: "node",
+	metafile: true,
+	write: false,
+	absWorkingDir: root,
+	tsconfig: path.join(root, "tsconfig.json"),
+	packages: "external",
+	plugins: [aliasResolverPlugin],
+	define: { "process.env.IS_DEV": "false", "process.env.IS_TEST": "false" },
+	banner: { js: "const _importMetaUrl=require('url').pathToFileURL(__filename)" },
+}
+
+async function inputsFor(entry, external) {
+	const r = await esbuild.build({ ...common, entryPoints: [entry], external })
+	return new Set(Object.keys(r.metafile.inputs).filter((f) => f.startsWith("src/") && /\.tsx?$/.test(f)))
+}
+
+const ext = await inputsFor("src/extension.ts", ["vscode"])
+const standalone = await inputsFor("src/standalone/cline-core.ts", [
+	"vscode",
+	"@grpc/reflection",
+	"grpc-health-check",
+	"better-sqlite3",
+])
+const live = new Set([...ext, ...standalone])
+
+// Third consumer: the webview (webview-ui/) is a separate Vite/React build that
+// imports extension code ONLY from src/shared (via "@shared/*" alias or relative
+// "../src/shared/*" paths). Any src/shared file referenced from webview-ui/src is
+// therefore live even if the extension-host/standalone bundles don't reach it.
+// Conservatively mark every src/shared file mentioned by the webview as live.
+const webviewFiles = await glob("webview-ui/src/**/*.{ts,tsx}", { cwd: root })
+const sharedMentionedByWebview = new Set()
+for (const wf of webviewFiles) {
+	const text = fs.readFileSync(path.join(root, wf), "utf8")
+	// Match @shared/X or .../src/shared/X import specifiers and map to src/shared/X
+	const re = /(?:@shared\/|src\/shared\/)([A-Za-z0-9_./-]+)/g
+	let m
+	while ((m = re.exec(text))) {
+		const rel = m[1].replace(/\.(ts|tsx|js|jsx)$/, "")
+		for (const cand of [`src/shared/${rel}.ts`, `src/shared/${rel}.tsx`, `src/shared/${rel}/index.ts`]) {
+			if (fs.existsSync(path.join(root, cand))) sharedMentionedByWebview.add(cand)
+		}
+	}
+}
+for (const f of sharedMentionedByWebview) live.add(f)
+console.log(`src/shared files referenced by webview: ${sharedMentionedByWebview.size}`)
+
+// All non-test, non-.d.ts source files on disk.
+const allSrc = (await glob("src/**/*.{ts,tsx}", { cwd: root }))
+	.filter((f) => !/\.test\.tsx?$/.test(f))
+	.filter((f) => !f.endsWith(".d.ts"))
+	.filter((f) => !f.includes("/__tests__/"))
+	.filter((f) => !f.startsWith("src/test/"))
+	.filter((f) => !f.startsWith("src/generated/")) // generated host glue
+	.filter((f) => !f.startsWith("src/dev/")) // dev-only tooling
+
+const dead = allSrc.filter((f) => !live.has(f)).sort()
+
+console.log(`extension inputs: ${ext.size}`)
+console.log(`standalone inputs: ${standalone.size}`)
+console.log(`union live src files: ${live.size}`)
+console.log(`candidate dead files: ${dead.length}`)
+fs.writeFileSync("/tmp/dead-src.json", JSON.stringify(dead, null, "\t"))
+console.log("--- dead candidates written to /tmp/dead-src.json ---")
diff --git a/apps/vscode/scripts/generate-host-bridge-client.mjs b/apps/vscode/scripts/generate-host-bridge-client.mjs
new file mode 100755
index 0000000..81086f8
--- /dev/null
+++ b/apps/vscode/scripts/generate-host-bridge-client.mjs
@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+import chalk from "chalk"
+import * as path from "path"
+import { writeFileWithMkdirs } from "./file-utils.mjs"
+import { getFqn, loadServicesFromProtoDescriptor } from "./proto-utils.mjs"
+
+// Contains the interface definitions for the host bridge clients.
+const TYPES_FILE = path.resolve("src/generated/hosts/host-bridge-client-types.ts")
+// Contains the ExternalHostBridgeClientManager for the external host bridge clients (using nice-grpc).
+const EXTERNAL_CLIENT_FILE = path.resolve("src/generated/hosts/standalone/host-bridge-clients.ts")
+// Contains the handler map for the external host bridge clients (using the custom service registry).
+const VSCODE_CLIENT_FILE = path.resolve("src/generated/hosts/vscode/hostbridge-grpc-service-config.ts")
+
+/**
+ * Main function to generate the host bridge client
+ */
+export async function main() {
+	const { hostServices } = await loadServicesFromProtoDescriptor()
+
+	await generateTypesFile(hostServices)
+	await generateExternalClientFile(hostServices)
+	await generateVscodeClientFile(hostServices)
+
+	console.log(`Generated Host Bridge client files at:`)
+	console.log(`- ${TYPES_FILE}`)
+	console.log(`- ${EXTERNAL_CLIENT_FILE}`)
+	console.log(`- ${VSCODE_CLIENT_FILE}`)
+}
+
+/**
+ * Generate the client interfaces file.
+ */
+async function generateTypesFile(hostServices) {
+	const clientInterfaces = []
+	for (const [name, def] of Object.entries(hostServices)) {
+		const clientInterface = generateClientInterfaceType(name, def)
+		clientInterfaces.push(clientInterface)
+	}
+	const content = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by scripts/generate-host-bridge-client.mjs
+import * as proto from "@shared/proto/index"
+import { StreamingCallbacks } from "@hosts/host-provider-types"
+
+${clientInterfaces.join("\n\n")}
+`
+	// Write output file
+	await writeFileWithMkdirs(TYPES_FILE, content)
+}
+
+/**
+ * Generate a client interface for a service.
+ */
+function generateClientInterfaceType(serviceName, serviceDefinition) {
+	// Get the methods from the service definition
+	const methods = Object.entries(serviceDefinition.service)
+		.map(([methodName, methodDef]) => {
+			const requestType = getFqn(methodDef.requestType.type.name)
+			const responseType = getFqn(methodDef.responseType.type.name)
+
+			if (!methodDef.responseStream) {
+				// Generate unary method signature.
+				return `	${methodName}(request: ${requestType}): Promise<${responseType}>;`
+			}
+			// Generate streaming method signature.
+			return `	${methodName}(request: ${requestType}, callbacks: StreamingCallbacks<${responseType}>): () => void;`
+		})
+		.join("\n\n")
+
+	// Generate the interface
+	return `/**
+ * Interface for ${serviceName} client.
+ */
+export interface ${serviceName}ClientInterface {
+
+${methods}
+}`
+}
+
+/**
+ * Generate the external client implementations file.
+ */
+async function generateExternalClientFile(hostServices) {
+	// Generate imports
+	const imports = []
+	// Add imports for the interfaces
+	for (const [name, _def] of Object.entries(hostServices)) {
+		imports.push(`import { ${name}ClientInterface } from "@generated/hosts/host-bridge-client-types"`)
+	}
+	const clientImplementations = []
+	for (const [name, def] of Object.entries(hostServices)) {
+		clientImplementations.push(generateExternalClientSetup(name, def))
+	}
+
+	const content = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by scripts/generate-host-bridge-client.mjs
+import { asyncIteratorToCallbacks } from "@/standalone/utils"
+import * as niceGrpc from "@generated/nice-grpc/index"
+import { StreamingCallbacks } from "@hosts/host-provider-types"
+import * as proto from "@shared/proto/index"
+import { Channel, createClient } from "nice-grpc"
+import { BaseGrpcClient } from "@/hosts/external/grpc-types"
+
+${imports.join("\n")}
+
+${clientImplementations.join("\n\n")}
+`
+	// Write output file
+	await writeFileWithMkdirs(EXTERNAL_CLIENT_FILE, content)
+}
+
+/**
+ * Generate a client implementation class for a service
+ */
+function generateExternalClientSetup(serviceName, serviceDefinition) {
+	// Get the methods from the service definition
+	const methods = Object.entries(serviceDefinition.service)
+		.map(([methodName, methodDef]) => {
+			// Get fully qualified type names
+			const requestType = getFqn(methodDef.requestType.type.name)
+			const responseType = getFqn(methodDef.responseType.type.name)
+			const isStreamingResponse = methodDef.responseStream
+
+			if (!isStreamingResponse) {
+				return `    ${methodName}(request: ${requestType}): Promise<${responseType}> {
+      return this.makeRequest((client) => client.${methodName}(request))
+    }`
+			} else {
+				// Generate streaming method
+				return `  ${methodName}(
+		request: ${requestType},
+		callbacks: StreamingCallbacks<${responseType}>,
+	): () => void {
+		const client = this.getClient()
+		const abortController = new AbortController()
+		const stream: AsyncIterable<${responseType}> = client.${methodName}(request, {
+			signal: abortController.signal,
+		})
+		const wrappedCallbacks: StreamingCallbacks<${responseType}> = {
+			...callbacks,
+			onError: (error: any) => {
+				if (error?.code === "UNAVAILABLE") {
+					this.destroyClient()
+				}
+				callbacks.onError?.(error)
+			},
+		}
+		asyncIteratorToCallbacks(stream, wrappedCallbacks)
+		return () => {
+			abortController.abort()
+		}
+	}\n`
+			}
+		})
+		.join("\n")
+
+	// Generate the class
+	return `/**
+ * Type-safe client implementation for ${serviceName}.
+ */
+export class ${serviceName}ClientImpl 
+	extends BaseGrpcClient<niceGrpc.host.${serviceName}Client> 
+	implements ${serviceName}ClientInterface {
+
+	protected createClient(channel: Channel): niceGrpc.host.${serviceName}Client {
+		return createClient(niceGrpc.host.${serviceName}Definition, channel)
+	}
+
+${methods}
+}`
+}
+
+/**
+ * Generate the Vscode client setup file.
+ */
+async function generateVscodeClientFile(hostServices) {
+	const imports = []
+	const clientImplementations = []
+	const handlerMap = []
+	for (const [serviceName, serviceDefinition] of Object.entries(hostServices)) {
+		const name = serviceName.replace(/Service$/, "").toLowerCase()
+		for (const [methodName, _methodDef] of Object.entries(serviceDefinition.service)) {
+			imports.push(`import { ${methodName} } from "@/hosts/vscode/hostbridge/${name}/${methodName}"`)
+		}
+		imports.push("")
+
+		clientImplementations.push(generateVscodeClientImplementation(name, serviceDefinition))
+
+		handlerMap.push(`	"host.${serviceName}": {
+		requestHandler: ${name}ServiceRegistry.handleRequest,
+		streamingHandler: ${name}ServiceRegistry.handleStreamingRequest,
+	},`)
+	}
+
+	const content = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by scripts/generate-host-bridge-client.mjs
+import { createServiceRegistry } from "@hosts/vscode/hostbridge-grpc-service"
+import { HostServiceHandlerConfig } from "@hosts/vscode/hostbridge-grpc-handler"
+
+${imports.join("\n")}
+${clientImplementations.join("\n\n")}
+
+/**
+ * Map of host service names to their handler configurations
+ */
+export const hostServiceHandlers: Record<string, HostServiceHandlerConfig> = {
+${handlerMap.join("\n")}
+}
+`
+
+	// Write output file
+	await writeFileWithMkdirs(VSCODE_CLIENT_FILE, content)
+}
+
+function generateVscodeClientImplementation(serviceName, serviceDefinition) {
+	// Get the methods from the service definition
+	const name = serviceName.replace(/Service$/, "").toLowerCase()
+
+	const methods = Object.entries(serviceDefinition.service)
+		.map(([methodName, methodDef]) => {
+			// Get fully qualified type names
+			const isStreamingResponse = methodDef.responseStream
+			if (!isStreamingResponse) {
+				return `${name}ServiceRegistry.registerMethod("${methodName}", ${methodName})`
+			} else {
+				return `${name}ServiceRegistry.registerMethod("${methodName}", ${methodName}, { isStreaming: true })`
+			}
+		})
+		.join("\n")
+
+	// Generate the class
+	return `// Setup ${name} service registry
+const ${name}ServiceRegistry = createServiceRegistry("${name}")
+${methods}`
+}
+
+// Only run main if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((error) => {
+		console.error(chalk.red("Error:"), error)
+		process.exit(1)
+	})
+}
diff --git a/apps/vscode/scripts/generate-protobus-setup.mjs b/apps/vscode/scripts/generate-protobus-setup.mjs
new file mode 100755
index 0000000..6d1cc69
--- /dev/null
+++ b/apps/vscode/scripts/generate-protobus-setup.mjs
@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import path from "path"
+import { fileURLToPath } from "url"
+import { writeFileWithMkdirs } from "./file-utils.mjs"
+import { getFqn, loadServicesFromProtoDescriptor } from "./proto-utils.mjs"
+
+const WEBVIEW_CLIENTS_FILE = path.resolve("webview-ui/src/services/grpc-client.ts")
+const VSCODE_SERVICES_FILE = path.resolve("src/generated/hosts/vscode/protobus-services.ts")
+const VSCODE_SERVICE_TYPES_FILE = path.resolve("src/generated/hosts/vscode/protobus-service-types.ts")
+const STANDALONE_SERVER_SETUP_FILE = path.resolve("src/generated/hosts/standalone/protobus-server-setup.ts")
+
+const SCRIPT_NAME = path.relative(process.cwd(), fileURLToPath(import.meta.url))
+
+export async function main() {
+	const { protobusServices } = await loadServicesFromProtoDescriptor()
+	await generateWebviewProtobusClients(protobusServices)
+	await generateVscodeServiceTypes(protobusServices)
+	await generateVscodeProtobusServers(protobusServices)
+	await generateStandaloneProtobusServiceSetup(protobusServices)
+
+	console.log(`Generated ProtoBus files at:`)
+	console.log(`- ${WEBVIEW_CLIENTS_FILE}`)
+	console.log(`- ${VSCODE_SERVICE_TYPES_FILE}`)
+	console.log(`- ${VSCODE_SERVICES_FILE}`)
+	console.log(`- ${STANDALONE_SERVER_SETUP_FILE}`)
+}
+
+async function generateWebviewProtobusClients(protobusServices) {
+	const clients = []
+
+	for (const [serviceName, def] of Object.entries(protobusServices)) {
+		const rpcs = []
+		for (const [rpcName, rpc] of Object.entries(def.service)) {
+			const requestType = getFqn(rpc.requestType.type.name)
+			const responseType = getFqn(rpc.responseType.type.name)
+
+			if (rpc.requestStream) {
+				throw new Error("Request streaming is not supported")
+			}
+			if (!rpc.responseStream) {
+				rpcs.push(`    static async ${rpcName}(request: ${requestType}): Promise<${responseType}> {
+		return this.makeUnaryRequest("${rpcName}", request, ${requestType}.toJSON, ${responseType}.fromJSON)
+	}`)
+			} else {
+				rpcs.push(`    static ${rpcName}(request: ${requestType}, callbacks: Callbacks<${responseType}>): ()=>void {
+		return this.makeStreamingRequest("${rpcName}", request, ${requestType}.toJSON, ${responseType}.fromJSON, callbacks)
+	}`)
+			}
+		}
+		clients.push(`export class ${serviceName}Client extends ProtoBusClient {
+	static override serviceName: string = "cline.${serviceName}"
+${rpcs.join("\n")}
+}`)
+	}
+
+	// Create output file
+	const output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as proto from "@shared/proto/index"
+import { ProtoBusClient, Callbacks } from "./grpc-client-base"
+
+${clients.join("\n")}
+`
+	// Write output file
+	await writeFileWithMkdirs(WEBVIEW_CLIENTS_FILE, output)
+}
+
+/**
+ * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
+ */
+async function generateVscodeServiceTypes(protobusServices) {
+	const servers = []
+
+	for (const [serviceName, def] of Object.entries(protobusServices)) {
+		const domain = getDomainName(serviceName)
+		servers.push(`// ${domain} Service Handler Types`)
+		servers.push(`export type ${serviceName}Handlers = {`)
+		for (const [rpcName, rpc] of Object.entries(def.service)) {
+			const requestType = getFqn(rpc.requestType.type.name)
+			const responseType = getFqn(rpc.responseType.type.name)
+			if (rpc.requestStream) {
+				throw new Error("Request streaming is not supported")
+			}
+			if (!rpc.responseStream) {
+				servers.push(`     ${rpcName}:(controller: Controller, request: ${requestType}) => Promise<${responseType}>`)
+			} else {
+				servers.push(
+					`     ${rpcName}:(controller: Controller, request: ${requestType}, responseStream: StreamingResponseHandler<${responseType}>, requestId?: string) => Promise<void>`,
+				)
+			}
+		}
+		servers.push(`}\n`)
+	}
+
+	// Create output file
+	const output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as proto from "@shared/proto/index"
+import { Controller } from "@core/controller"
+import { StreamingResponseHandler } from "@/core/controller/grpc-handler"
+
+${servers.join("\n")}
+`
+	// Write output file
+	await writeFileWithMkdirs(VSCODE_SERVICE_TYPES_FILE, output)
+}
+
+/**
+ * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
+ */
+async function generateVscodeProtobusServers(protobusServices) {
+	const imports = []
+	const servers = []
+	const serviceMap = []
+	for (const [serviceName, def] of Object.entries(protobusServices)) {
+		const domain = getDomainName(serviceName)
+		const dir = getDirName(serviceName)
+		imports.push(`// ${domain} Service`)
+		servers.push(`const ${serviceName}Handlers: serviceTypes.${serviceName}Handlers = {`)
+		for (const [rpcName, _rpc] of Object.entries(def.service)) {
+			imports.push(`import { ${rpcName} } from "@core/controller/${dir}/${rpcName}"`)
+			servers.push(`    ${rpcName}: ${rpcName},`)
+		}
+		servers.push(`} \n`)
+		serviceMap.push(`    "cline.${serviceName}": ${serviceName}Handlers,`)
+		imports.push("")
+	}
+
+	// Create output file
+	const output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as serviceTypes from "@generated/hosts/vscode/protobus-service-types"
+
+${imports.join("\n")}
+${servers.join("\n")}
+export const serviceHandlers: Record<string, any> = {
+${serviceMap.join("\n")}
+}
+`
+	// Write output file
+	await writeFileWithMkdirs(VSCODE_SERVICES_FILE, output)
+}
+
+/**
+ * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
+ */
+async function generateStandaloneProtobusServiceSetup(protobusServices) {
+	const imports = []
+	const handlerSetup = []
+
+	for (const [name, def] of Object.entries(protobusServices)) {
+		const domain = getDomainName(name)
+		const dir = getDirName(name)
+		imports.push(`// ${domain} Service`)
+		handlerSetup.push(`    // ${domain} Service`)
+		handlerSetup.push(`    server.addService(cline.${name}Service, {`)
+		for (const [rpcName, rpc] of Object.entries(def.service)) {
+			imports.push(`import { ${rpcName} } from "@core/controller/${dir}/${rpcName}"`)
+			const requestType = "cline." + rpc.requestType.type.name
+			const responseType = "cline." + rpc.responseType.type.name
+			if (rpc.requestStream) {
+				throw new Error("Request streaming is not supported")
+			}
+			if (rpc.responseStream) {
+				handlerSetup.push(
+					`        ${rpcName}: wrapStreamingResponse<${requestType},${responseType}>(${rpcName}, controller),`,
+				)
+			} else {
+				handlerSetup.push(`         ${rpcName}: wrapper<${requestType},${responseType}>(${rpcName}, controller),`)
+			}
+		}
+		handlerSetup.push(`    });`)
+		imports.push("")
+		handlerSetup.push("")
+	}
+
+	// Create output file
+	const output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as grpc from "@grpc/grpc-js"
+import { cline } from "@generated/grpc-js"
+import { Controller } from "@core/controller"
+import { GrpcHandlerWrapper, GrpcStreamingResponseHandlerWrapper } from "@hosts/external/grpc-types"
+
+${imports.join("\n")}
+export function addProtobusServices(
+	server: grpc.Server,
+	controller: Controller,
+	wrapper: GrpcHandlerWrapper,
+	wrapStreamingResponse: GrpcStreamingResponseHandlerWrapper,
+): void {
+${handlerSetup.join("\n")}
+}
+`
+	// Write output file
+	await writeFileWithMkdirs(STANDALONE_SERVER_SETUP_FILE, output)
+}
+
+function getDomainName(serviceName) {
+	return serviceName.replace(/Service$/, "")
+}
+function getDirName(serviceName) {
+	const domain = getDomainName(serviceName)
+	return domain.charAt(0).toLowerCase() + domain.slice(1)
+}
+
+// Only run main if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((error) => {
+		console.error(chalk.red("Error:"), error)
+		process.exit(1)
+	})
+}
diff --git a/apps/vscode/scripts/generate-state-proto.mjs b/apps/vscode/scripts/generate-state-proto.mjs
new file mode 100644
index 0000000..32875fb
--- /dev/null
+++ b/apps/vscode/scripts/generate-state-proto.mjs
@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+/**
+ * Generates proto message definitions from TypeScript source of truth.
+ *
+ * This script reads the field definitions from src/shared/storage/state-keys.ts
+ * and generates the corresponding proto message definitions for Secrets and Settings.
+ *
+ * Usage: node scripts/generate-state-proto.mjs
+ *
+ * The generated proto content is written to proto/cline/state.proto,
+ * replacing only the Secrets and Settings messages while preserving
+ * the rest of the file (services, enums, other messages).
+ */
+
+import * as fs from "node:fs/promises"
+import { Project, SyntaxKind } from "ts-morph"
+
+const STATE_KEYS_PATH = "src/shared/storage/state-keys.ts"
+const STATE_PROTO_PATH = "proto/cline/state.proto"
+
+/**
+ * Convert field name to valid snake_case proto field name.
+ * Handles camelCase (apiKey -> api_key) and hyphens (openai-codex -> openai_codex).
+ */
+function toProtoFieldName(str) {
+	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`).replace(/-/g, "_")
+}
+
+// Fields that should use int64 instead of int32
+const INT64_FIELDS = new Set(["planModeThinkingBudgetTokens", "actModeThinkingBudgetTokens"])
+
+// Fields that should use double instead of int32
+const DOUBLE_FIELDS = new Set()
+
+/**
+ * Infer proto type from TypeScript type expression
+ * @param {string} typeText - The TypeScript type expression
+ * @param {string} [fieldName] - Optional field name for field-specific overrides
+ */
+function inferProtoType(typeText, fieldName) {
+	// Remove 'undefined' from union types
+	const cleanType = typeText
+		.replace(/\s*\|\s*undefined/g, "")
+		.replace(/undefined\s*\|\s*/g, "")
+		.trim()
+
+	// Handle common types
+	if (cleanType === "string") {
+		return "string"
+	}
+	if (cleanType === "boolean") {
+		return "bool"
+	}
+	if (cleanType === "number") {
+		// Some number fields need specific numeric types
+		if (fieldName && INT64_FIELDS.has(fieldName)) {
+			return "int64"
+		}
+		if (fieldName && DOUBLE_FIELDS.has(fieldName)) {
+			return "double"
+		}
+		return "int32"
+	}
+
+	// Handle Record<string, string> as map<string, string>
+	if (/Record\s*<\s*string\s*,\s*string\s*>/.test(cleanType)) {
+		return "map<string, string>"
+	}
+
+	// Handle specific known types that map to proto messages/enums
+	// Order matters! More specific types must come before generic ones
+	// (e.g., OpenAiCompatibleModelInfo before ModelInfo)
+	// Check known types BEFORE string literals, since types like `"act" as Mode`
+	// contain quotes but should map to proto enums
+	const knownTypes = [
+		// Specific model info types first
+		["OpenAiCompatibleModelInfo", "OpenAiCompatibleModelInfo"],
+		["LiteLLMModelInfo", "LiteLLMModelInfo"],
+		["OcaModelInfo", "OcaModelInfo"],
+		// Generic ModelInfo last (catches OpenRouterModelInfo, etc.)
+		["ModelInfo", "OpenRouterModelInfo"],
+		// Other types - order matters for substring matching
+		["AutoApprovalSettings", "AutoApprovalSettings"],
+		["BrowserSettings", "BrowserSettings"],
+		["FocusChainSettings", "FocusChainSettings"],
+		["OpenaiReasoningEffort", "OpenaiReasoningEffort"],
+		["PlanActMode", "PlanActMode"],
+		["ApiProvider", "string"],
+		["LanguageModelChatSelector", "LanguageModelChatSelector"], // Must come before "Mode" check
+	]
+
+	for (const [tsType, protoType] of knownTypes) {
+		if (cleanType.includes(tsType)) {
+			return protoType
+		}
+	}
+
+	// Check for Mode type separately with word boundary to avoid matching "VsCodeLmModelSelector"
+	// This handles TS `Mode` type which maps to proto `PlanActMode`
+	if (/\bMode\b/.test(cleanType)) {
+		return "PlanActMode"
+	}
+
+	// Handle specific string literal unions (treat as string)
+	// This comes after known types check since some types like `"act" as Mode` contain quotes
+	if (cleanType.includes('"') || cleanType.includes("'")) {
+		return "string"
+	}
+
+	// Default to string for complex types we can't map
+	return "string"
+}
+
+/**
+ * Parse the SECRETS_KEYS array from state-keys.ts
+ */
+function parseSecretsKeys(sourceFile) {
+	const secretsDecl = sourceFile.getVariableDeclaration("SECRETS_KEYS")
+	if (!secretsDecl) {
+		throw new Error("Could not find SECRETS_KEYS declaration")
+	}
+
+	let initializer = secretsDecl.getInitializer()
+	if (!initializer) {
+		throw new Error("SECRETS_KEYS has no initializer")
+	}
+
+	// Handle 'as const' expression
+	if (initializer.getKind() === SyntaxKind.AsExpression) {
+		initializer = initializer.getExpression()
+	}
+
+	if (initializer.getKind() !== SyntaxKind.ArrayLiteralExpression) {
+		throw new Error(`SECRETS_KEYS is not an array literal (got ${SyntaxKind[initializer.getKind()]})`)
+	}
+
+	const keys = []
+	for (const element of initializer.getElements()) {
+		const text = element.getText()
+		// Remove quotes and handle special prefixes
+		const key = text.replace(/^['"]|['"]$/g, "")
+		// Skip prefixed keys like "cline:clineAccountId"
+		if (!key.includes(":")) {
+			keys.push(key)
+		}
+	}
+
+	return keys
+}
+
+/**
+ * Parse field definitions from an object literal in state-keys.ts
+ */
+function parseFieldDefinitions(sourceFile, variableName) {
+	const decl = sourceFile.getVariableDeclaration(variableName)
+	if (!decl) {
+		throw new Error(`Could not find ${variableName} declaration`)
+	}
+
+	const initializer = decl.getInitializer()
+	if (!initializer) {
+		throw new Error(`${variableName} has no initializer`)
+	}
+
+	// Handle 'satisfies' expression
+	let objectLiteral = initializer
+	if (initializer.getKind() === SyntaxKind.SatisfiesExpression) {
+		objectLiteral = initializer.getExpression()
+	}
+
+	if (objectLiteral.getKind() !== SyntaxKind.ObjectLiteralExpression) {
+		throw new Error(`${variableName} is not an object literal`)
+	}
+
+	const fields = []
+	for (const prop of objectLiteral.getProperties()) {
+		if (prop.getKind() !== SyntaxKind.PropertyAssignment) {
+			continue
+		}
+
+		const name = prop.getName()
+		const propInit = prop.getInitializer()
+
+		if (!propInit || propInit.getKind() !== SyntaxKind.ObjectLiteralExpression) {
+			continue
+		}
+
+		// Get the 'default' property to infer the type
+		const defaultProp = propInit.getProperty("default")
+		if (!defaultProp) {
+			continue
+		}
+
+		let typeText = "string"
+		const defaultInit = defaultProp.getInitializer()
+		if (defaultInit) {
+			// Check for 'as' expression to get the type
+			if (defaultInit.getKind() === SyntaxKind.AsExpression) {
+				const typeNode = defaultInit.getTypeNode()
+				if (typeNode) {
+					typeText = typeNode.getText()
+				}
+			} else {
+				// Infer from literal
+				const text = defaultInit.getText()
+				if (text === "true" || text === "false") {
+					typeText = "boolean"
+				} else if (/^\d+$/.test(text)) {
+					typeText = "number"
+				} else if (/^\d+\.\d+$/.test(text)) {
+					typeText = "number"
+				}
+			}
+		}
+
+		fields.push({
+			name,
+			tsType: typeText,
+			protoType: inferProtoType(typeText, name),
+		})
+	}
+
+	return fields
+}
+
+/**
+ * Convert snake_case to camelCase for mapping proto fields back to TS keys
+ */
+function snakeToCamel(str) {
+	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
+}
+
+/**
+ * Normalize a property key to the camelCase form parsed from proto field names.
+ * Example: "openai-codex-oauth-credentials" -> "openaiCodexOauthCredentials".
+ * We do this before looking up existing field numbers so regenerated proto fields
+ * reuse their old numbers instead of being treated as new fields.
+ */
+function normalizePropertyNameForProtoLookup(fieldName) {
+	return snakeToCamel(toProtoFieldName(fieldName))
+}
+
+/**
+ * Fail fast when two distinct property keys collapse to the same normalized lookup key.
+ * Collisions make field-number preservation ambiguous and can cause proto renumbering.
+ */
+function assertNoNormalizedFieldNameCollisions(fields) {
+	const normalizedToOriginalNames = new Map()
+
+	for (const field of fields) {
+		const normalizedName = normalizePropertyNameForProtoLookup(field.name)
+		const names = normalizedToOriginalNames.get(normalizedName) ?? new Set()
+		names.add(field.name)
+		normalizedToOriginalNames.set(normalizedName, names)
+	}
+
+	for (const [normalizedName, names] of normalizedToOriginalNames) {
+		if (names.size > 1) {
+			const sortedNames = [...names].sort()
+			throw new Error(
+				`Field-name collision after proto normalization: ${sortedNames.join(", ")} all normalize to "${normalizedName}". Rename one field to keep proto field-number mapping unambiguous.`,
+			)
+		}
+	}
+}
+
+/**
+ * Parse field numbers from an existing proto message definition
+ * Returns a map of camelCase field names to their field numbers
+ */
+function parseProtoMessageFieldNumbers(protoContent, messageName) {
+	const fieldNumbers = {}
+
+	// Match the message block (handles single-level nesting for now)
+	const messageRegex = new RegExp(`message\\s+${messageName}\\s*\\{([^}]*(?:\\{[^}]*\\}[^}]*)*)\\}`, "s")
+	const match = protoContent.match(messageRegex)
+
+	if (!match) {
+		return fieldNumbers
+	}
+
+	const messageBody = match[1]
+
+	// Match field definitions: optional/required/repeated type name = number;
+	// Supports scalar/message types and map fields.
+	const fieldRegex = /(?:optional|required|repeated)?\s*(?:map<[^>]+>|[\w.]+)\s+(\w+)\s*=\s*(\d+)\s*;/g
+	const matches = messageBody.matchAll(fieldRegex)
+
+	for (const fieldMatch of matches) {
+		const snakeName = fieldMatch[1]
+		const fieldNum = Number.parseInt(fieldMatch[2], 10)
+		const camelName = snakeToCamel(snakeName)
+		fieldNumbers[camelName] = fieldNum
+	}
+
+	return fieldNumbers
+}
+
+/**
+ * Load field number mappings from existing proto file
+ */
+async function loadFieldNumbersFromProto() {
+	try {
+		const protoContent = await fs.readFile(STATE_PROTO_PATH, "utf-8")
+		const secrets = parseProtoMessageFieldNumbers(protoContent, "Secrets")
+		const settings = parseProtoMessageFieldNumbers(protoContent, "Settings")
+
+		console.log(`  Found ${Object.keys(secrets).length} existing Secrets fields`)
+		console.log(`  Found ${Object.keys(settings).length} existing Settings fields`)
+
+		return { Secrets: secrets, Settings: settings }
+	} catch {
+		// Proto file doesn't exist, start fresh
+		return { Secrets: {}, Settings: {} }
+	}
+}
+
+/**
+ * Assign field numbers, preserving existing assignments and adding new ones
+ */
+function assignFieldNumbers(fields, existingNumbers, startNumber = 1) {
+	const result = {}
+	let nextNumber = startNumber
+
+	assertNoNormalizedFieldNameCollisions(fields)
+
+	// Find the highest existing number
+	for (const num of Object.values(existingNumbers)) {
+		if (num >= nextNumber) {
+			nextNumber = num + 1
+		}
+	}
+
+	// Preserve existing assignments
+	for (const field of fields) {
+		// Normalize before lookup so keys like "openai-codex-oauth-credentials"
+		// reuse existing proto numbers instead of being treated as new fields.
+		const normalizedFieldName = normalizePropertyNameForProtoLookup(field.name)
+		const normalizedFieldNumber = existingNumbers[normalizedFieldName]
+		const rawFieldNumber = existingNumbers[field.name]
+
+		if (normalizedFieldNumber !== undefined && rawFieldNumber !== undefined && normalizedFieldNumber !== rawFieldNumber) {
+			throw new Error(
+				`Ambiguous proto field-number mapping for "${field.name}": normalized key "${normalizedFieldName}" -> ${normalizedFieldNumber}, raw key "${field.name}" -> ${rawFieldNumber}.`,
+			)
+		}
+
+		const existingFieldNumber = normalizedFieldNumber ?? rawFieldNumber
+		if (existingFieldNumber !== undefined) {
+			result[field.name] = existingFieldNumber
+		}
+	}
+
+	// Assign new numbers for new fields
+	for (const field of fields) {
+		if (result[field.name] === undefined) {
+			result[field.name] = nextNumber++
+		}
+	}
+
+	return result
+}
+
+/**
+ * Generate proto message definition
+ */
+function generateProtoMessage(messageName, fields, fieldNumbers) {
+	const lines = [`message ${messageName} {`]
+
+	// Sort fields by field number for consistent output
+	const sortedFields = [...fields].sort((a, b) => fieldNumbers[a.name] - fieldNumbers[b.name])
+
+	for (const field of sortedFields) {
+		const snakeName = toProtoFieldName(field.name)
+		const fieldNum = fieldNumbers[field.name]
+		// Map types cannot have the 'optional' modifier in proto3
+		const prefix = field.protoType.startsWith("map<") ? "" : "optional "
+		lines.push(`  ${prefix}${field.protoType} ${snakeName} = ${fieldNum};`)
+	}
+
+	lines.push("}")
+	return lines.join("\n")
+}
+
+/**
+ * Generate Secrets message from SECRETS_KEYS
+ */
+function generateSecretsMessage(secretsKeys, fieldNumbers) {
+	const fields = secretsKeys.map((key) => ({
+		name: key,
+		protoType: "string",
+	}))
+
+	return generateProtoMessage("Secrets", fields, fieldNumbers)
+}
+
+/**
+ * Replace a message in the proto file content
+ */
+function replaceMessage(protoContent, messageName, newMessageContent) {
+	// Match the message definition including nested braces
+	const messageRegex = new RegExp(`message\\s+${messageName}\\s*\\{[^}]*(?:\\{[^}]*\\}[^}]*)*\\}`, "g")
+
+	if (messageRegex.test(protoContent)) {
+		return protoContent.replace(messageRegex, newMessageContent)
+	}
+	// Message doesn't exist, append before the first message or at end
+	console.warn(`Warning: ${messageName} message not found in proto file, appending`)
+	return protoContent + "\n\n" + newMessageContent
+}
+
+async function main() {
+	console.log("Generating proto definitions from TypeScript source...")
+
+	// Parse TypeScript source
+	const project = new Project({
+		tsConfigFilePath: "tsconfig.json",
+	})
+	const sourceFile = project.addSourceFileAtPath(STATE_KEYS_PATH)
+
+	// Parse definitions
+	const secretsKeys = parseSecretsKeys(sourceFile)
+	console.log(`Found ${secretsKeys.length} secret keys`)
+
+	const apiHandlerFields = parseFieldDefinitions(sourceFile, "API_HANDLER_SETTINGS_FIELDS")
+	const userSettingsFields = parseFieldDefinitions(sourceFile, "USER_SETTINGS_FIELDS")
+	const settingsFields = [...apiHandlerFields, ...userSettingsFields]
+	console.log(`Found ${settingsFields.length} settings fields`)
+
+	// Load existing field numbers from proto file
+	const existingFieldNumbers = await loadFieldNumbersFromProto()
+
+	// Assign field numbers (preserving existing, adding new ones)
+	const secretsFieldNumbers = assignFieldNumbers(
+		secretsKeys.map((k) => ({ name: k })),
+		existingFieldNumbers.Secrets,
+		1,
+	)
+	const settingsFieldNumbers = assignFieldNumbers(settingsFields, existingFieldNumbers.Settings, 1)
+
+	// Generate messages
+	const secretsMessage = generateSecretsMessage(secretsKeys, secretsFieldNumbers)
+	const settingsMessage = generateProtoMessage("Settings", settingsFields, settingsFieldNumbers)
+
+	// Read existing proto file
+	let protoContent = await fs.readFile(STATE_PROTO_PATH, "utf-8")
+
+	// Replace messages
+	protoContent = replaceMessage(protoContent, "Secrets", secretsMessage)
+	protoContent = replaceMessage(protoContent, "Settings", settingsMessage)
+
+	// Write updated proto file
+	await fs.writeFile(STATE_PROTO_PATH, protoContent)
+	console.log(`Updated ${STATE_PROTO_PATH}`)
+
+	console.log("\nGeneration complete! Run 'bun run protos' to regenerate TypeScript from protos.")
+}
+
+main().catch((error) => {
+	console.error("Error:", error)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/generate-stubs.js b/apps/vscode/scripts/generate-stubs.js
new file mode 100644
index 0000000..c6058c0
--- /dev/null
+++ b/apps/vscode/scripts/generate-stubs.js
@@ -0,0 +1,110 @@
+const fs = require("fs")
+const path = require("path")
+const { Project, SyntaxKind } = require("ts-morph")
+
+function traverse(container, output, prefix = "") {
+	for (const node of container.getStatements()) {
+		const kind = node.getKind()
+
+		if (kind === SyntaxKind.ModuleDeclaration) {
+			const name = node.getName().replace(/^['"]|['"]$/g, "")
+			var fullPrefix
+			if (prefix) {
+				fullPrefix = `${prefix}.${name}`
+			} else {
+				fullPrefix = name
+			}
+			output.push(`${fullPrefix} = {};`)
+			const body = node.getBody()
+			if (body && body.getKind() === SyntaxKind.ModuleBlock) {
+				traverse(body, output, fullPrefix)
+			}
+		} else if (kind === SyntaxKind.FunctionDeclaration) {
+			const name = node.getName()
+			const params = node.getParameters().map((p, i) => sanitizeParam(p.getName(), i))
+			const typeNode = node.getReturnTypeNode()
+			const returnType = typeNode ? typeNode.getText() : ""
+			const ret = mapReturn(returnType)
+			output.push(
+				`${prefix}.${name} = function(${params.join(", ")}) { console.log('Called stubbed function: ${prefix}.${name}');  ${ret} };`,
+			)
+		} else if (kind === SyntaxKind.EnumDeclaration) {
+			const name = node.getName()
+			const members = node.getMembers().map((m) => m.getName())
+			output.push(`${prefix}.${name} = { ${members.map((m) => `${m}: 0`).join(", ")} };`)
+		} else if (kind === SyntaxKind.VariableStatement) {
+			for (const decl of node.getDeclarations()) {
+				const name = decl.getName()
+				output.push(`${prefix}.${name} = createStub("${prefix}.${name}");`)
+			}
+		} else if (kind === SyntaxKind.ClassDeclaration) {
+			const name = node.getName()
+			output.push(
+				`${prefix}.${name} = class { constructor(...args) {
+  console.log('Constructed stubbed class: new ${prefix}.${name}(', args, ')');
+  return createStub(${prefix}.${name});
+}};`,
+			)
+		} else if (kind === SyntaxKind.TypeAliasDeclaration || kind === SyntaxKind.InterfaceDeclaration) {
+			//console.log("Skipping", SyntaxKind[kind], node.getName())
+			// Skip interfaces and type aliases because they are only used at compile time by typescript.
+		} else {
+			console.log("Can't handle: ", SyntaxKind[kind])
+		}
+	}
+}
+
+function mapReturn(typeStr) {
+	if (!typeStr) {
+		return ""
+	}
+	if (typeStr.includes("void")) {
+		return ""
+	}
+	if (typeStr.includes("string")) {
+		return `return '';`
+	}
+	if (typeStr.includes("number")) {
+		return `return 0;`
+	}
+	if (typeStr.includes("boolean")) {
+		return `return false;`
+	}
+	if (typeStr.includes("[]")) {
+		return `return [];`
+	}
+	if (typeStr.includes("Thenable")) {
+		return `return Promise.resolve(null);`
+	}
+	return `return createStub("unknown");`
+}
+
+function sanitizeParam(name, index) {
+	return name || `arg${index}`
+}
+
+async function main() {
+	const inputPath = "node_modules/@types/vscode/index.d.ts"
+	const outputPath = "standalone/runtime-files/vscode/vscode-stubs.js"
+
+	const project = new Project()
+	const sourceFile = project.addSourceFileAtPath(inputPath)
+
+	const output = []
+	output.push("// GENERATED CODE -- DO NOT EDIT!")
+	output.push('console.log("Loading stubs...");')
+	output.push('const { createStub } = require("./stub-utils")')
+	traverse(sourceFile, output)
+	output.push("module.exports = vscode;")
+	output.push('console.log("Finished loading stubs");')
+
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+	fs.writeFileSync(outputPath, output.join("\n"))
+
+	console.log(`Wrote vscode SDK stubs to ${outputPath}`)
+}
+
+main().catch((err) => {
+	console.error(err)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/get-vscode-usages.sh b/apps/vscode/scripts/get-vscode-usages.sh
new file mode 100755
index 0000000..26f6fed
--- /dev/null
+++ b/apps/vscode/scripts/get-vscode-usages.sh
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -eu
+
+FILES=$(git ls-files src|grep -v test|grep -v vscode|grep -v extension.ts|grep -v evals|grep -v standalone|grep -v /dev/)
+DEST_DIR=dist-standalone
+SDK_DEST=$DEST_DIR/vscode-sdk-uses.txt
+CSS_DEST=$DEST_DIR/vscode-css-uses.txt
+TMP=/tmp/vscode-sdk-uses.txt.tmp
+mkdir -p $DEST_DIR
+
+if [[ ${1:-} == "-v" ]]; then
+  grep -Er --color=always 'vscode[?]?\.' $FILES
+fi
+
+{
+  grep -Ehr 'vscode[?]?\.' $FILES |
+  grep -Ev '//.*vscode' | # remove commented out code
+  grep -v vscode.commands.executeCommand | # executeCommand is handled separately
+  #grep -Ev '"vscode' | # remove command strings that get included because they start with vscode
+  sed 's|.*vscode|vscode|'| # remove everything before vscode.
+  sed 's|?||g' | # remove ? from vcode?.env?.foo
+  sed 's/[^a-zA-Z0-9_.?].*$//' | # remove everything after last identifier
+  grep -E '\.[a-z][^.]+$' | # remove types (last part of identifier should be lowercase)
+  cat > $TMP
+}
+{
+  grep -hr 'vscode.commands.executeCommand' $FILES |
+  perl -ne 'print if /["\x27"]/'  | # Remove occurrences where the command is not on the same line (line doesnt contain quote chars) :(
+  sed -n 's|.*\(vscode.commands.executeCommand[^,]*\).*|\1|p'| # Remove all params after the first one
+  sed 's|\(".*"\).*|\1)|'| # Close the parantheses
+  cat >> $TMP
+}
+
+# Count occurrences
+cat $TMP | sort | uniq -c | sort -n > $SDK_DEST
+rm $TMP
+
+echo Wrote uses of the vscode SDK to $(realpath $SDK_DEST)
+
+{
+grep -rh -- --vscode- webview-ui/build/ |
+sed 's/--vscode/\n--vscode/g' | # One var per line
+grep -- --vscode | # Remove lines that don't have vars.
+sed 's/[),"\\].*$//' | # remove from the end of the var name to the end of the line.
+sort | uniq > $CSS_DEST
+}
+echo Wrote vscode vars used to $(realpath $CSS_DEST)
diff --git a/apps/vscode/scripts/interactive-playwright.ts b/apps/vscode/scripts/interactive-playwright.ts
new file mode 100644
index 0000000..1da9c63
--- /dev/null
+++ b/apps/vscode/scripts/interactive-playwright.ts
@@ -0,0 +1,112 @@
+#!/usr/bin/env bun
+
+/**
+ * Interactive Playwright launcher for the Cline VS Code extension.
+ *
+ * Overview:
+ *  - Starts the mock Cline API server (from the e2e test fixtures).
+ *  - Downloads a stable build of VS Code (via @vscode/test-electron).
+ *  - Creates a temporary VS Code user profile directory.
+ *  - Installs and links the Cline extension (from dist/e2e.vsix and the dev path).
+ *  - Opens a test workspace and automatically reveals the Cline sidebar.
+ *  - Records **all gRPC calls** during the session for later inspection.
+ *  - Keeps VS Code running for manual interactive testing until the window is closed or Ctrl+C is pressed.
+ *  - Cleans up all resources (mock server, temp profile, Electron process) on exit.
+ *
+ * Usage:
+ *   1. (Optional) Build and install the e2e extension:
+ *        bun run test:e2e:build
+ *
+ *   2. From the repo root, start the interactive session:
+ *        bun run test:e2e:ui
+ *
+ *   3. VS Code will launch with the Cline extension loaded and gRPC recording enabled.
+ *
+ *   4. Interact with the extension manually.
+ *
+ *   5. Close the VS Code window or press Ctrl+C to end the session and trigger cleanup.
+ */
+
+import { downloadAndUnzipVSCode, SilentReporter } from "@vscode/test-electron"
+import { mkdtempSync } from "fs"
+import os from "os"
+import path from "path"
+import { _electron } from "playwright"
+import { ClineApiServerMock } from "../src/test/e2e/fixtures/server"
+import { E2ETestHelper } from "../src/test/e2e/utils/helpers"
+
+async function main() {
+	await ClineApiServerMock.startGlobalServer()
+
+	const userDataDir = mkdtempSync(path.join(os.tmpdir(), "vsce-interactive"))
+	const executablePath = await downloadAndUnzipVSCode("stable", undefined, new SilentReporter())
+
+	// launch VSCode
+	const app = await _electron.launch({
+		executablePath,
+		env: {
+			...process.env,
+			TEMP_PROFILE: "true",
+			E2E_TEST: "true",
+			CLINE_ENVIRONMENT: "local",
+			GRPC_RECORDER_ENABLED: "true",
+			GRPC_RECORDER_TESTS_FILTERS_ENABLED: "true",
+		},
+		args: [
+			"--no-sandbox",
+			"--disable-updates",
+			"--disable-workspace-trust",
+			"--disable-extensions",
+			"--skip-welcome",
+			"--skip-release-notes",
+			`--user-data-dir=${userDataDir}`,
+			`--install-extension=${path.join(E2ETestHelper.CODEBASE_ROOT_DIR, "dist", "e2e.vsix")}`,
+			`--extensionDevelopmentPath=${E2ETestHelper.CODEBASE_ROOT_DIR}`,
+			path.join(E2ETestHelper.E2E_TESTS_DIR, "fixtures", "workspace"),
+		],
+	})
+
+	const page = await app.firstWindow()
+
+	await E2ETestHelper.openClineSidebar(page)
+
+	console.log("VSCode with Cline extension is now running!")
+	console.log(`Temporary data directory on: ${userDataDir}`)
+	console.log("You can manually interact with the extension.")
+	console.log("Press Ctrl+C to close when done.")
+
+	async function teardown() {
+		console.log("Cleaning up resources...")
+		try {
+			await app?.close()
+			await ClineApiServerMock.stopGlobalServer?.()
+			await E2ETestHelper.rmForRetries(userDataDir, { recursive: true })
+		} catch (e) {
+			console.log(`We could teardown interactive playwright properly, error:${e}`)
+		}
+		console.log("Finished cleaning up resources...")
+	}
+
+	process.on("SIGINT", async () => {
+		await teardown()
+		process.exit(0)
+	})
+
+	process.on("SIGTERM", async () => {
+		await teardown()
+		process.exit(0)
+	})
+
+	const win = await app.firstWindow()
+	win.on("close", async () => {
+		console.log("VS Code window closed.")
+		await teardown()
+		process.exit(0)
+	})
+	process.stdin.resume()
+}
+
+main().catch((err) => {
+	console.error("Failed to start:", err)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/marketplace-readme.mjs b/apps/vscode/scripts/marketplace-readme.mjs
new file mode 100644
index 0000000..447e1a3
--- /dev/null
+++ b/apps/vscode/scripts/marketplace-readme.mjs
@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+// Swap README.md with README.marketplace.md so the VS Code Marketplace listing
+// (which is generated from the README baked into the .vsix at package time)
+// keeps the extension-focused content even after the repo's README.md is
+// repurposed as a multi-product landing page.
+//
+// The README files diverge in two directions:
+//   - README.md is what GitHub renders on the repo home page. We want this to
+//     cover the SDK, JetBrains plugin, CLI, and VS Code extension together.
+//   - README.marketplace.md is what users see on the VS Code Marketplace and
+//     inside the extension after install. It stays focused on the VS Code UX.
+//
+// vsce reads README.md from the extension root at `vsce package` / `vsce publish`
+// time and has no flag to point it elsewhere, so we copy README.marketplace.md
+// over README.md just before packaging and put the original back afterwards.
+//
+// swapIn is idempotent: if README.md already matches README.marketplace.md
+// (e.g., an outer wrapper has already swapped), it no-ops instead of erroring
+// on the backup file. This lets nested callers (ext-vscode-publish-stable.yml wrapping the whole
+// step, plus the individual npm scripts swapping internally) coexist safely.
+
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const projectRoot = path.join(__dirname, "..")
+
+const README_PATH = path.join(projectRoot, "README.md")
+const MARKETPLACE_PATH = path.join(projectRoot, "README.marketplace.md")
+const BACKUP_PATH = path.join(projectRoot, ".README.github.bak")
+
+function readFile(p) {
+	return fs.readFileSync(p, "utf-8")
+}
+
+export function swapIn() {
+	if (!fs.existsSync(MARKETPLACE_PATH)) {
+		throw new Error(`Missing ${MARKETPLACE_PATH}. The marketplace README must exist before publishing.`)
+	}
+	if (!fs.existsSync(README_PATH)) {
+		throw new Error(`Missing ${README_PATH}. Cannot swap in marketplace README.`)
+	}
+
+	if (readFile(README_PATH) === readFile(MARKETPLACE_PATH)) {
+		return { skipped: true }
+	}
+
+	if (fs.existsSync(BACKUP_PATH)) {
+		throw new Error(
+			`Stale backup at ${BACKUP_PATH}. A previous publish may have aborted before restoring README.md. ` +
+				`Move it back to README.md manually before retrying.`,
+		)
+	}
+
+	fs.copyFileSync(README_PATH, BACKUP_PATH)
+	fs.copyFileSync(MARKETPLACE_PATH, README_PATH)
+	return { skipped: false }
+}
+
+export function restore() {
+	if (!fs.existsSync(BACKUP_PATH)) {
+		return { skipped: true }
+	}
+	fs.copyFileSync(BACKUP_PATH, README_PATH)
+	fs.unlinkSync(BACKUP_PATH)
+	return { skipped: false }
+}
+
+const invokedAsCli = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(__filename)
+if (invokedAsCli) {
+	const cmd = process.argv[2]
+	try {
+		if (cmd === "swap-in") {
+			const result = swapIn()
+			console.log(result.skipped ? "marketplace-readme: already swapped, skipping" : "marketplace-readme: swapped in")
+		} else if (cmd === "restore") {
+			const result = restore()
+			console.log(result.skipped ? "marketplace-readme: no backup, skipping" : "marketplace-readme: restored")
+		} else {
+			console.error("Usage: marketplace-readme.mjs <swap-in|restore>")
+			process.exit(2)
+		}
+	} catch (err) {
+		console.error(`marketplace-readme: ${err.message}`)
+		process.exit(1)
+	}
+}
diff --git a/apps/vscode/scripts/package-standalone.mjs b/apps/vscode/scripts/package-standalone.mjs
new file mode 100755
index 0000000..c9dd9c6
--- /dev/null
+++ b/apps/vscode/scripts/package-standalone.mjs
@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+
+import archiver from "archiver"
+import { execSync } from "child_process"
+import fs from "fs"
+import { cp } from "fs/promises"
+import { glob } from "glob"
+import minimatch from "minimatch"
+import os from "os"
+import path from "path"
+import { rmrf } from "./file-utils.mjs"
+
+const BUILD_DIR = "dist-standalone"
+const BINARIES_DIR = `${BUILD_DIR}/binaries`
+const RUNTIME_DEPS_DIR = "standalone/runtime-files"
+const IS_DEBUG_BUILD = process.env.IS_DEBUG_BUILD === "true"
+
+// This should match the node version packaged with the JetBrains plugin.
+const TARGET_NODE_VERSION = "22.15.0"
+const TARGET_PLATFORMS = [
+	{ platform: "win32", arch: "x64", targetDir: "win-x64" },
+	{ platform: "darwin", arch: "x64", targetDir: "darwin-x64" },
+	{ platform: "darwin", arch: "arm64", targetDir: "darwin-arm64" },
+	{ platform: "linux", arch: "x64", targetDir: "linux-x64" },
+	{ platform: "linux", arch: "arm64", targetDir: "linux-aarch64" },
+]
+const SUPPORTED_BINARY_MODULES = ["better-sqlite3"]
+
+const UNIVERSAL_BUILD = !process.argv.includes("-s")
+const IS_VERBOSE = process.argv.includes("-v") || process.argv.includes("--verbose")
+
+async function main() {
+	await installNodeDependencies()
+	if (UNIVERSAL_BUILD) {
+		console.log("Building universal package for all platforms...")
+		await packageAllBinaryDeps()
+	} else {
+		console.log(`Building package for ${os.platform()}-${os.arch()}...`)
+	}
+	await zipDistribution()
+}
+
+async function installNodeDependencies() {
+	// Clean modules from any previous builds
+	await rmrf(path.join(BUILD_DIR, "node_modules"))
+	await rmrf(path.join(BINARIES_DIR))
+
+	await cpr(RUNTIME_DEPS_DIR, BUILD_DIR)
+
+	// This is an ISOLATED runtime install inside the standalone distribution
+	// directory (dist-standalone), driven by the "cline-core" runtime-files
+	// manifest — it is NOT part of the monorepo workspace install. TARGET_NODE_VERSION
+	// and the prebuild-install calls below target the Node ABI of the bundled
+	// runtime (matching the JetBrains-packaged Node), not the build tooling.
+	console.log("Running bun install in distribution directory...")
+	execSync("bun install", { stdio: "inherit", cwd: BUILD_DIR })
+
+	// Move the vscode directory into node_modules.
+	// It can't be installed using npm because it will create a symlink which cannot be unzipped correctly on windows.
+	fs.renameSync(`${BUILD_DIR}/vscode`, `${BUILD_DIR}/node_modules/vscode`)
+}
+
+/**
+ * Downloads prebuilt binaries for each platform for the modules that include binaries. It uses `npx prebuild-install`
+ * to download the binary.
+ *
+ * The modules are downloaded to dist-standalone/binaries/{os}-{platform}/.
+ * When cline-core is installed, the installer should use the correct module for the current platform.
+ */
+async function packageAllBinaryDeps() {
+	// Check for native .node modules.
+	const allNativeModules = await glob("**/*.node", { cwd: path.join(BUILD_DIR, "node_modules"), nodir: true })
+	const isAllowed = (path) => SUPPORTED_BINARY_MODULES.some((allowed) => path.includes(allowed))
+	const blocked = allNativeModules.filter((x) => !isAllowed(x))
+
+	if (blocked.length > 0) {
+		console.error(`Error: Native node modules cannot be included in the standalone distribution:\n\n${blocked.join("\n")}`)
+		console.error(
+			"\nThese modules must support prebuilt-install and be added to the supported list in scripts/package-standalone.mjs",
+		)
+		process.exit(1)
+	}
+
+	for (const module of SUPPORTED_BINARY_MODULES) {
+		console.log(`Installing binaries for ${module}...`)
+		const src = path.join(BUILD_DIR, "node_modules", module)
+		if (!fs.existsSync(src)) {
+			console.warn(`Warning: Trying to install binaries for the module '${module}', but it is not being used by cline.`)
+			continue
+		}
+
+		for (const { platform, arch, targetDir } of TARGET_PLATFORMS) {
+			const binaryDir = `${BINARIES_DIR}/${targetDir}/node_modules`
+			fs.mkdirSync(binaryDir, { recursive: true })
+
+			// Copy the module from the build dir
+			const dest = path.join(binaryDir, module)
+			await cpr(src, dest)
+
+			// Download the binary libs.
+			// `--target=${TARGET_NODE_VERSION}` selects the Node ABI of the bundled
+			// standalone runtime (NOT the bun/build tooling) so the prebuilt native
+			// `.node` binaries load in the Node that runs cline-core.
+			const v = IS_VERBOSE ? "--verbose" : ""
+			const cmd = `npx prebuild-install --platform=${platform} --arch=${arch} --target=${TARGET_NODE_VERSION} ${v}`
+			log_verbose(`${module}: ${cmd}`)
+			execSync(cmd, { cwd: dest, stdio: "inherit" })
+			log_verbose("")
+		}
+		// Remove the original module with the host platform binaries installed directly into node_modules.
+		log_verbose(`Cleaning up host version of ${module}`)
+		await rmrf(src)
+		log_verbose("")
+	}
+}
+
+async function zipDistribution() {
+	// Zip the build directory (excluding any pre-existing output zip).
+	const zipPath = path.join(BUILD_DIR, "standalone.zip")
+	const output = fs.createWriteStream(zipPath)
+	const startTime = Date.now()
+	const archive = archiver("zip", { zlib: { level: 6 } })
+
+	output.on("close", () => {
+		const endTime = Date.now()
+		const duration = (endTime - startTime) / 1000
+		console.log(`Created ${zipPath} (${(archive.pointer() / 1024 / 1024).toFixed(1)} MB) in ${duration.toFixed(2)} seconds`)
+	})
+	archive.on("warning", (err) => {
+		console.warn(`Warning: ${err}`)
+	})
+	archive.on("error", (err) => {
+		throw err
+	})
+
+	archive.pipe(output)
+	// Add all the files from the standalone build dir.
+	archive.glob("**/*", {
+		cwd: BUILD_DIR,
+		ignore: ["standalone.zip"],
+	})
+
+	// Exclude the same files as the VCE vscode extension packager.
+	// Also ignore the dist directory, the build directory for the extension.
+	const isIgnored = createIsIgnored(["dist/**"])
+
+	// Add the whole cline directory under "extension", except the for the ignored files.
+	archive.directory(process.cwd(), "extension", (entry) => {
+		if (isIgnored(entry.name)) {
+			//log_verbose("Ignoring", entry.name)
+			return false
+		}
+		return entry
+	})
+
+	console.log("Zipping package...")
+	await archive.finalize()
+}
+
+/**
+ * This is based on https://github.com/microsoft/vscode-vsce/blob/fafad8a63e9cf31179f918eb7a4eeb376834c904/src/package.ts#L1695
+ * because the .vscodeignore format is not compatible with the `ignore` npm module.
+ */
+function createIsIgnored(standaloneIgnores) {
+	const MinimatchOptions = { dot: true }
+	const defaultIgnore = [
+		".vscodeignore",
+		"package-lock.json",
+		"npm-debug.log",
+		"yarn.lock",
+		"yarn-error.log",
+		"npm-shrinkwrap.json",
+		".editorconfig",
+		".npmrc",
+		".yarnrc",
+		".gitattributes",
+		"*.todo",
+		"tslint.yaml",
+		".eslintrc*",
+		".babelrc*",
+		".prettierrc*",
+		"biome.json*",
+		".cz-config.js",
+		".commitlintrc*",
+		"webpack.config.js",
+		"ISSUE_TEMPLATE.md",
+		"CONTRIBUTING.md",
+		"PULL_REQUEST_TEMPLATE.md",
+		"CODE_OF_CONDUCT.md",
+		".github",
+		".travis.yml",
+		"appveyor.yml",
+		"**/.git",
+		"**/.git/**",
+		"**/*.vsix",
+		"**/.DS_Store",
+		"**/*.vsixmanifest",
+		"**/.vscode-test/**",
+		"**/.vscode-test-web/**",
+	]
+
+	const rawIgnore = fs.readFileSync(".vscodeignore", "utf8")
+
+	// Parse raw ignore by splitting output into lines and filtering out empty lines and comments
+	const parsedIgnore = rawIgnore
+		.split(/[\n\r]/)
+		.map((s) => s.trim())
+		.filter((s) => !!s)
+		.filter((i) => !/^\s*#/.test(i))
+
+	// Add '/**' to possible folder names
+	const expandedIgnore = [
+		...parsedIgnore,
+		...parsedIgnore.filter((i) => !/(^|\/)[^/]*\*[^/]*$/.test(i)).map((i) => (/\/$/.test(i) ? `${i}**` : `${i}/**`)),
+	]
+
+	// Combine with default ignore list
+	// Also ignore the dist directory- the build directory for the extension.
+	let allIgnore = [...defaultIgnore, ...expandedIgnore, ...standaloneIgnores]
+
+	// Map files need to be included in the debug build. Remove .map ignores when IS_DEBUG_BUILD is set
+	if (IS_DEBUG_BUILD) {
+		allIgnore = allIgnore.filter((pattern) => !pattern.endsWith(".map"))
+		console.log("Debug build: Including .map files in package")
+	}
+
+	// Split into ignore and negate list
+	const [ignore, negate] = allIgnore.reduce(
+		(r, e) => (!/^\s*!/.test(e) ? [[...r[0], e], r[1]] : [r[0], [...r[1], e]]),
+		[[], []],
+	)
+
+	function isIgnored(f) {
+		return (
+			ignore.some((i) => minimatch(f, i, MinimatchOptions)) &&
+			!negate.some((i) => minimatch(f, i.substr(1), MinimatchOptions))
+		)
+	}
+	return isIgnored
+}
+
+/* cp -r */
+async function cpr(source, dest) {
+	log_verbose(`Copying ${source} -> ${dest}`)
+	await cp(source, dest, {
+		recursive: true,
+		preserveTimestamps: true,
+		dereference: false, // preserve symlinks instead of following them
+	})
+}
+
+function log_verbose(...args) {
+	if (IS_VERBOSE) {
+		console.log(...args)
+	}
+}
+
+await main()
diff --git a/apps/vscode/scripts/proto-lint.sh b/apps/vscode/scripts/proto-lint.sh
new file mode 100755
index 0000000..b8192c5
--- /dev/null
+++ b/apps/vscode/scripts/proto-lint.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+set -u
+
+buf lint
+
+if ! buf format -w --exit-code; then
+  echo Proto files were formatted
+fi
+
+if grep -rn "rpc .*[A-Z][A-Z].*[(]" --include="*.proto"; then
+  # See https://github.com/cline/cline/pull/7054
+  echo Error: Proto RPC names cannot contain repeated capital letters
+  exit 1
+fi
+
diff --git a/apps/vscode/scripts/proto-shared-utils.mjs b/apps/vscode/scripts/proto-shared-utils.mjs
new file mode 100644
index 0000000..ebfc04e
--- /dev/null
+++ b/apps/vscode/scripts/proto-shared-utils.mjs
@@ -0,0 +1,66 @@
+import * as fs from "fs/promises"
+import * as path from "path"
+
+/**
+ * Parse proto files to extract service definitions
+ * @param {string[]} protoFilePaths - Array of proto file paths
+ * @param {string} protoDir - Base proto directory
+ * @returns {Promise<Object>} Services object with service definitions
+ */
+export async function parseProtoForServices(protoFilePaths, protoDir) {
+	const services = {}
+
+	for (const protoFilePath of protoFilePaths) {
+		const content = await fs.readFile(path.join(protoDir, protoFilePath), "utf8")
+		const serviceMatches = content.matchAll(/service\s+(\w+Service)\s*\{([\s\S]*?)\}/g)
+
+		// Determine proto package from file path
+		const protoPackage = protoFilePath.startsWith("host/") ? "host" : "cline"
+
+		for (const serviceMatch of serviceMatches) {
+			const serviceName = serviceMatch[1]
+			const serviceKey = serviceName.replace("Service", "").toLowerCase()
+			const serviceBody = serviceMatch[2]
+			const methodMatches = serviceBody.matchAll(
+				/rpc\s+(\w+)\s*\((stream\s)?([\w.]+)\)\s*returns\s*\((stream\s)?([\w.]+)\)/g,
+			)
+
+			const methods = []
+			for (const methodMatch of methodMatches) {
+				methods.push({
+					name: methodMatch[1],
+					requestType: methodMatch[3],
+					responseType: methodMatch[5],
+					isRequestStreaming: !!methodMatch[2],
+					isResponseStreaming: !!methodMatch[4],
+				})
+			}
+			services[serviceKey] = { name: serviceName, methods, protoPackage }
+		}
+	}
+	return services
+}
+
+/**
+ * Create service name map from parsed services
+ * @param {Object} services - Services object from parseProtoForServices
+ * @returns {Object} Service name map
+ */
+export function createServiceNameMap(services) {
+	const serviceNameMap = {}
+	for (const [serviceKey, serviceDef] of Object.entries(services)) {
+		const packagePrefix = serviceDef.protoPackage === "host" ? "host" : "cline"
+		serviceNameMap[serviceKey] = `${packagePrefix}.${serviceDef.name}`
+	}
+	return serviceNameMap
+}
+
+/**
+ * Log message only if verbose flag is set
+ * @param {string} message - Message to log
+ */
+export function logVerbose(message) {
+	if (process.argv.includes("-v") || process.argv.includes("--verbose")) {
+		console.log(message)
+	}
+}
diff --git a/apps/vscode/scripts/proto-utils.mjs b/apps/vscode/scripts/proto-utils.mjs
new file mode 100755
index 0000000..63550b8
--- /dev/null
+++ b/apps/vscode/scripts/proto-utils.mjs
@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import * as grpc from "@grpc/grpc-js"
+import * as protoLoader from "@grpc/proto-loader"
+import * as fs from "fs/promises"
+import * as path from "path"
+
+const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
+
+const typeNameToFQN = new Map()
+
+function addTypeNameToFqn(name, fqn) {
+	if (typeNameToFQN.has(name) && typeNameToFQN.get(name) !== fqn) {
+		throw new Error(`Proto type ${name} redefined (${fqn}).`)
+	}
+	typeNameToFQN.set(name, fqn)
+}
+// Get the fully qualified name for a proto type, e.g. getFqn('StringRequest') returns 'cline.StringRequest'
+export function getFqn(name) {
+	if (!typeNameToFQN.has(name)) {
+		throw Error(`No FQN for ${name}`)
+	}
+	return typeNameToFQN.get(name)
+}
+
+export async function getPackageDefinition() {
+	const descriptorBuffer = await fs.readFile(DESCRIPTOR_SET)
+	const options = { longs: Number } // Encode int64 fields as numbers
+	return protoLoader.loadFileDescriptorSetFromBuffer(descriptorBuffer, options)
+}
+
+export async function loadProtoDescriptorSet() {
+	const packageDefinition = await getPackageDefinition()
+	return grpc.loadPackageDefinition(packageDefinition)
+}
+
+export async function loadServicesFromProtoDescriptor() {
+	// Load service definitions from descriptor set
+	const proto = await loadProtoDescriptorSet()
+
+	// Extract host services and proto messages from the proto definition
+	const hostServices = {}
+	for (const [name, def] of Object.entries(proto.host)) {
+		if (def && "service" in def) {
+			hostServices[name] = def
+		} else {
+			addTypeNameToFqn(name, `proto.host.${name}`)
+		}
+	}
+	const protobusServices = {}
+	for (const [name, def] of Object.entries(proto.cline)) {
+		if (def && "service" in def) {
+			protobusServices[name] = def
+		} else {
+			addTypeNameToFqn(name, `proto.cline.${name}`)
+		}
+	}
+	return { protobusServices, hostServices }
+}
diff --git a/apps/vscode/scripts/publish-marketplace.mjs b/apps/vscode/scripts/publish-marketplace.mjs
new file mode 100644
index 0000000..74baef1
--- /dev/null
+++ b/apps/vscode/scripts/publish-marketplace.mjs
@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+// Wraps the marketplace publish flow (vsce + ovsx) so the .vsix gets packaged
+// with the marketplace-flavored README instead of the GitHub-flavored README.
+//
+// vsce reads README.md from the extension root at publish time and there's no
+// flag to point it elsewhere, so we swap README.marketplace.md into place
+// first and restore the original on the way out. The swap helper is
+// idempotent, so this is safe to run nested under another wrapper (e.g., the
+// CI step in .github/workflows/ext-vscode-publish-stable.yml that also packages a .vsix for the
+// GitHub release artifact before invoking this script).
+//
+// Usage:
+//   node scripts/publish-marketplace.mjs                  # release channel
+//   node scripts/publish-marketplace.mjs --pre-release    # pre-release channel
+
+import { execFileSync } from "node:child_process"
+import { restore, swapIn } from "./marketplace-readme.mjs"
+
+const isPrerelease = process.argv.includes("--pre-release")
+
+const result = swapIn()
+
+let interrupted = false
+const cleanupOnSignal = (exitCode) => () => {
+	interrupted = true
+	try {
+		if (!result.skipped) {
+			restore()
+		}
+	} catch (err) {
+		console.error(`marketplace-readme: failed to restore on signal: ${err.message}`)
+	}
+	process.exit(exitCode)
+}
+process.on("SIGINT", cleanupOnSignal(130))
+process.on("SIGTERM", cleanupOnSignal(143))
+
+try {
+	// --no-dependencies: the extension is fully esbuild-bundled into dist/extension.js,
+	// so vsce must not walk node_modules (the @cline/* workspace symlinks point out of
+	// the package and would drag the whole monorepo into the VSIX).
+	const vsceArgs = ["publish", "--no-dependencies", "--allow-package-secrets", "sendgrid"]
+	if (isPrerelease) {
+		vsceArgs.push("--pre-release")
+	}
+	execFileSync("vsce", vsceArgs, { stdio: "inherit" })
+
+	const ovsxArgs = ["ovsx", "publish", "--no-dependencies"]
+	if (isPrerelease) {
+		ovsxArgs.push("--pre-release")
+	}
+	execFileSync("npx", ovsxArgs, { stdio: "inherit" })
+} finally {
+	if (!interrupted && !result.skipped) {
+		restore()
+	}
+}
diff --git a/apps/vscode/scripts/publish-nightly.mjs b/apps/vscode/scripts/publish-nightly.mjs
new file mode 100755
index 0000000..f7b45cd
--- /dev/null
+++ b/apps/vscode/scripts/publish-nightly.mjs
@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+
+/**
+ * Nightly publish script for VS Code extension
+ * Converts package.json to testing version, packages, publishes, and restores
+ *
+ * This script:
+ * 1. Backs up the original package.json
+ * 2. Updates package.json with:
+ *    - New version (major.minor.timestamp format)
+ *    - Changes name to "cline-nightly"
+ *    - Changes displayName to "Cline (Nightly)"
+ * 3. Packages the extension as a .vsix file
+ * 4. Publishes to VS Code Marketplace (if VSCE_PAT is set)
+ * 5. Publishes to OpenVSX Registry (if OVSX_PAT is set)
+ * 6. Restores the original package.json
+ *
+ * Channels:
+ *   By default, the extension is published to the RELEASE channel of
+ *   `cline-nightly` (this is what the scheduled daily nightly workflow
+ *   uses). Pass --pre-release to instead publish to the pre-release
+ *   channel of `cline-nightly` (used for manual publishes from feature
+ *   branches that need tester opt-in via "Switch to Pre-Release Version").
+ *
+ *   Note on version ordering: because VS Code serves pre-release users
+ *   whichever version is highest across *both* channels, the pre-release
+ *   build only stays selected while its version number is greater than
+ *   the latest release nightly. Since both channels use
+ *   `major.minor.<unix-timestamp>`, the most recently published build
+ *   wins. When this script is used for a manual pre-release publish, the
+ *   scheduled release nightly workflow will eventually publish a newer
+ *   timestamp and pull pre-release users forward onto release — which is
+ *   the desired behavior once an experimental branch is abandoned, but
+ *   means ongoing previews require re-publishing from the branch at
+ *   least as often as the scheduled release nightly runs.
+ *
+ * Usage:
+ *   bun run publish:marketplace:nightly                    # release channel
+ *   bun run publish:marketplace:nightly -- --pre-release   # pre-release channel
+ *   bun run publish:marketplace:nightly -- --dry-run       # package only
+ *
+ * Environment variables:
+ *   VSCE_PAT  - Personal Access Token for VS Code Marketplace
+ *   OVSX_PAT  - Personal Access Token for OpenVSX Registry
+ *
+ * Dependencies:
+ *   - vsce (VS Code Extension Manager)
+ *   - ovsx (OpenVSX CLI)
+ */
+
+import { execFileSync, execSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { restore as restoreMarketplaceReadme, swapIn as swapInMarketplaceReadme } from "./marketplace-readme.mjs"
+
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+// ANSI color codes for console output
+const colors = {
+	reset: "\x1b[0m",
+	red: "\x1b[31m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+}
+
+// Logging utilities
+const log = {
+	info: (msg) => console.log(`${colors.green}[INFO]${colors.reset} ${msg}`),
+	warn: (msg) => console.log(`${colors.yellow}[WARN]${colors.reset} ${msg}`),
+	error: (msg) => console.error(`${colors.red}[ERROR]${colors.reset} ${msg}`),
+}
+
+// Configuration
+const config = {
+	// The name and display name for the nightly version
+	nightlyName: "cline-nightly",
+	originalName: "claude-dev",
+	nightlyDisplayName: "Cline (Nightly)",
+	projectRoot: path.join(__dirname, ".."),
+	get packageJsonPath() {
+		return path.join(this.projectRoot, "package.json")
+	},
+	get packageBackupPath() {
+		return path.join(this.projectRoot, "package.json.backup")
+	},
+	get distDir() {
+		return path.join(this.projectRoot, "dist")
+	},
+	get vsixPath() {
+		return path.join(this.distDir, "cline-nightly.vsix")
+	},
+	get nodeModulesPath() {
+		return path.join(this.projectRoot, "node_modules")
+	},
+	get originalWorkspaceLinkPath() {
+		return path.join(this.nodeModulesPath, this.originalName)
+	},
+	get nightlyWorkspaceLinkPath() {
+		return path.join(this.nodeModulesPath, this.nightlyName)
+	},
+}
+
+// Utility class for managing the publish process
+class NightlyPublisher {
+	constructor() {
+		this.originalPackageJson = null
+		this.hasBackup = false
+		this.didRenameWorkspaceLink = false
+		this.didCreateNightlyWorkspaceLink = false
+		this.didSwapMarketplaceReadme = false
+	}
+
+	/**
+	 * Resolve symlink target to an absolute path.
+	 */
+	resolveSymlinkTarget(linkPath) {
+		const target = fs.readlinkSync(linkPath)
+		return path.resolve(path.dirname(linkPath), target)
+	}
+
+	/**
+	 * Validate that a path is the expected workspace self-link to project root.
+	 */
+	isExpectedWorkspaceSelfLink(linkPath) {
+		try {
+			if (!fs.lstatSync(linkPath).isSymbolicLink()) {
+				return false
+			}
+
+			return this.resolveSymlinkTarget(linkPath) === path.resolve(config.projectRoot)
+		} catch {
+			return false
+		}
+	}
+
+	/**
+	 * Check if required dependencies are installed
+	 */
+	checkDependencies() {
+		const dependencies = [
+			{ name: "vsce", check: "vsce --version" },
+			{ name: "npx", check: "npx --version" },
+		]
+
+		const missing = []
+
+		for (const dep of dependencies) {
+			try {
+				execSync(dep.check, { stdio: "ignore" })
+			} catch {
+				missing.push(dep.name)
+			}
+		}
+
+		if (missing.length > 0) {
+			throw new Error(
+				`Missing required dependencies: ${missing.join(", ")}. Please install them before running this script.`,
+			)
+		}
+
+		log.info("All dependencies are installed")
+	}
+
+	/**
+	 * Check if a command exists
+	 */
+	commandExists(command) {
+		try {
+			execSync(`which ${command}`, { stdio: "ignore" })
+			return true
+		} catch {
+			return false
+		}
+	}
+
+	/**
+	 * Create backup of package.json
+	 */
+	backupPackageJson() {
+		if (!fs.existsSync(config.packageJsonPath)) {
+			throw new Error(`package.json not found at ${config.packageJsonPath}`)
+		}
+
+		log.info("Backing up original package.json")
+		this.originalPackageJson = fs.readFileSync(config.packageJsonPath, "utf-8")
+		fs.writeFileSync(config.packageBackupPath, this.originalPackageJson)
+		this.hasBackup = true
+	}
+
+	/**
+	 * Restore original package.json
+	 */
+	restorePackageJson() {
+		if (this.hasBackup && fs.existsSync(config.packageBackupPath)) {
+			log.info("Restoring original package.json")
+			fs.writeFileSync(config.packageJsonPath, this.originalPackageJson)
+			fs.unlinkSync(config.packageBackupPath)
+			this.hasBackup = false
+		}
+	}
+
+	/**
+	 * Keep workspace self-link consistent with package name during nightly packaging.
+	 *
+	 * The repo root is a workspace package ("."). When npm installs dependencies,
+	 * it creates a self-link at node_modules/<package-name>. Nightly packaging
+	 * changes package.json name from "claude-dev" to "cline-nightly". If we don't
+	 * align this link, vsce's dependency detection (`npm list --production`) fails
+	 * with ELSPROBLEMS (missing cline-nightly + extraneous claude-dev).
+	 */
+	reconcileWorkspaceSelfLinkForNightly() {
+		const originalPath = config.originalWorkspaceLinkPath
+		const nightlyPath = config.nightlyWorkspaceLinkPath
+
+		if (!fs.existsSync(config.nodeModulesPath)) {
+			log.warn("node_modules not found, skipping workspace self-link reconciliation")
+			return
+		}
+
+		if (fs.existsSync(nightlyPath)) {
+			if (!this.isExpectedWorkspaceSelfLink(nightlyPath)) {
+				throw new Error(
+					`Refusing to continue: unexpected path at ${nightlyPath}. Expected a workspace symlink to ${config.projectRoot}`,
+				)
+			}
+
+			log.info("Nightly workspace self-link already exists")
+			return
+		}
+
+		if (fs.existsSync(originalPath)) {
+			if (!this.isExpectedWorkspaceSelfLink(originalPath)) {
+				throw new Error(
+					`Refusing to continue: unexpected path at ${originalPath}. Expected a workspace symlink to ${config.projectRoot}`,
+				)
+			}
+
+			log.info(`Renaming workspace self-link: ${config.originalName} -> ${config.nightlyName}`)
+			fs.renameSync(originalPath, nightlyPath)
+			this.didRenameWorkspaceLink = true
+			return
+		}
+
+		// In some environments npm may not have created the workspace self-link yet.
+		// Create it explicitly so `npm list --production` can resolve the renamed
+		// package name during vsce dependency detection.
+		log.warn("Original workspace self-link not found, creating nightly workspace self-link")
+		fs.symlinkSync(config.projectRoot, nightlyPath, "dir")
+
+		if (!this.isExpectedWorkspaceSelfLink(nightlyPath)) {
+			throw new Error(`Failed to create expected workspace symlink at ${nightlyPath}`)
+		}
+
+		this.didCreateNightlyWorkspaceLink = true
+	}
+
+	/**
+	 * Restore workspace self-link after packaging.
+	 */
+	restoreWorkspaceSelfLink() {
+		if (!this.didRenameWorkspaceLink && !this.didCreateNightlyWorkspaceLink) {
+			return
+		}
+
+		const originalPath = config.originalWorkspaceLinkPath
+		const nightlyPath = config.nightlyWorkspaceLinkPath
+
+		if (fs.existsSync(nightlyPath) && !fs.existsSync(originalPath)) {
+			if (this.didRenameWorkspaceLink) {
+				if (!this.isExpectedWorkspaceSelfLink(nightlyPath)) {
+					throw new Error(
+						`Refusing to restore: unexpected path at ${nightlyPath}. Expected a workspace symlink to ${config.projectRoot}`,
+					)
+				}
+
+				log.info(`Restoring workspace self-link: ${config.nightlyName} -> ${config.originalName}`)
+				fs.renameSync(nightlyPath, originalPath)
+			} else if (this.didCreateNightlyWorkspaceLink) {
+				if (!this.isExpectedWorkspaceSelfLink(nightlyPath)) {
+					throw new Error(
+						`Refusing to remove: unexpected path at ${nightlyPath}. Expected a workspace symlink to ${config.projectRoot}`,
+					)
+				}
+
+				log.info(`Removing temporary workspace self-link: ${config.nightlyName}`)
+				fs.unlinkSync(nightlyPath)
+			}
+		}
+
+		this.didRenameWorkspaceLink = false
+		this.didCreateNightlyWorkspaceLink = false
+	}
+
+	/**
+	 * Swap README.marketplace.md into README.md so the .vsix is packaged with
+	 * the marketplace-flavored README. vsce reads README.md from disk at
+	 * `vsce package` time and there's no flag to redirect it.
+	 */
+	swapMarketplaceReadme() {
+		const result = swapInMarketplaceReadme()
+		this.didSwapMarketplaceReadme = !result.skipped
+		if (this.didSwapMarketplaceReadme) {
+			log.info("Swapped README.marketplace.md into README.md for packaging")
+		}
+	}
+
+	/**
+	 * Restore README.md if this publisher performed the swap.
+	 */
+	restoreMarketplaceReadme() {
+		if (!this.didSwapMarketplaceReadme) {
+			return
+		}
+		try {
+			restoreMarketplaceReadme()
+			log.info("Restored original README.md")
+		} catch (error) {
+			log.error(`Failed to restore README.md: ${error.message}`)
+		}
+		this.didSwapMarketplaceReadme = false
+	}
+
+	/**
+	 * Generate new version with timestamp
+	 * Format: major.minor.timestamp
+	 */
+	generateVersion(currentVersion) {
+		// Extract major.minor from current version (e.g., "3.27.1" -> "3.27")
+		const versionParts = currentVersion.split(".")
+		if (versionParts.length < 2) {
+			throw new Error(`Invalid version format: ${currentVersion}`)
+		}
+
+		const major = versionParts[0]
+		const minor = versionParts[1]
+		const timestamp = Math.floor(Date.now() / 1000)
+
+		return `${major}.${minor}.${timestamp}`
+	}
+
+	/**
+	 * Update package.json with nightly configuration
+	 */
+	updatePackageJson() {
+		// Replace any occurrences cline. or claude-dev with nightly name
+		const rawContent = fs.readFileSync(config.packageJsonPath, "utf-8")
+		const content = rawContent.replaceAll("claude-dev", config.nightlyName).replaceAll('"cline.', `"${config.nightlyName}.`)
+
+		const pkg = JSON.parse(content)
+		const currentVersion = pkg.version
+
+		if (!currentVersion) {
+			throw new Error("Could not read version from package.json")
+		}
+
+		log.info(`Current version: ${currentVersion}`)
+
+		const newVersion = this.generateVersion(currentVersion)
+		log.info(`New version: ${newVersion}`)
+
+		// Update package.json fields
+		pkg.version = newVersion
+		pkg.name = config.nightlyName
+		pkg.displayName = config.nightlyDisplayName
+		pkg.contributes.viewsContainers.activitybar.title = config.nightlyDisplayName
+
+		// Save updated package.json
+		log.info("Updating package.json for nightly build")
+		fs.writeFileSync(config.packageJsonPath, JSON.stringify(pkg, null, "\t"))
+
+		return newVersion
+	}
+
+	/**
+	 * Package the extension
+	 */
+	packageExtension(isPreRelease = false) {
+		// Ensure dist directory exists
+		if (!fs.existsSync(config.distDir)) {
+			fs.mkdirSync(config.distDir, { recursive: true })
+		}
+
+		log.info(`Packaging extension${isPreRelease ? " (pre-release)" : ""}`)
+
+		const args = [
+			"package",
+			...(isPreRelease ? ["--pre-release"] : []),
+			// The extension is fully esbuild-bundled, so vsce must not walk node_modules
+			// (the @cline/* workspace symlinks point outside the package).
+			"--no-dependencies",
+			"--no-update-package-json",
+			"--no-git-tag-version",
+			"--allow-package-secrets",
+			"sendgrid",
+			"--out",
+			config.vsixPath,
+		]
+
+		try {
+			execFileSync("vsce", args, {
+				stdio: "inherit",
+				cwd: config.projectRoot,
+			})
+			log.info(`Package created: ${config.vsixPath}`)
+		} catch (error) {
+			throw new Error(`Failed to package extension: ${error.message}`)
+		}
+	}
+
+	/**
+	 * Publish to VS Code Marketplace
+	 */
+	publishToVSCodeMarketplace(isPreRelease = false) {
+		const token = process.env.VSCE_PAT
+
+		if (!token) {
+			log.warn("VSCE_PAT not set, skipping VS Code Marketplace publish")
+			return false
+		}
+
+		log.info(`Publishing to VS Code Marketplace${isPreRelease ? " (pre-release channel)" : ""}`)
+
+		const args = [
+			"publish",
+			...(isPreRelease ? ["--pre-release"] : []),
+			"--no-git-tag-version",
+			"--packagePath",
+			config.vsixPath,
+		]
+
+		try {
+			execFileSync("vsce", args, {
+				env: { ...process.env, VSCE_PAT: token },
+				stdio: "inherit",
+				cwd: config.projectRoot,
+			})
+			log.info("Successfully published to VS Code Marketplace")
+			return true
+		} catch (error) {
+			throw new Error(`Failed to publish to VS Code Marketplace: ${error.message}`)
+		}
+	}
+
+	/**
+	 * Publish to OpenVSX Registry
+	 */
+	publishToOpenVSX(isPreRelease = false) {
+		const token = process.env.OVSX_PAT
+
+		if (!token) {
+			log.warn("OVSX_PAT not set, skipping OpenVSX Registry publish")
+			return false
+		}
+
+		log.info(`Publishing to OpenVSX Registry${isPreRelease ? " (pre-release channel)" : ""}`)
+
+		const args = [
+			"ovsx",
+			"publish",
+			...(isPreRelease ? ["--pre-release"] : []),
+			"--packagePath",
+			config.vsixPath,
+			"--pat",
+			token,
+		]
+
+		try {
+			execFileSync("npx", args, {
+				stdio: "inherit",
+				cwd: config.projectRoot,
+			})
+			log.info("Successfully published to OpenVSX Registry")
+			return true
+		} catch (error) {
+			throw new Error(`Failed to publish to OpenVSX Registry: ${error.message}`)
+		}
+	}
+
+	/**
+	 * Main execution flow
+	 */
+	async run({ isDryRun = false, isPreRelease = false } = {}) {
+		try {
+			const channelLabel = isPreRelease ? " (pre-release channel)" : " (release channel)"
+			log.info(`Starting nightly publish process${channelLabel}${isDryRun ? " (dry run)" : ""}`)
+
+			// Step 1: Check dependencies
+			this.checkDependencies()
+
+			// Step 2: Backup package.json
+			this.backupPackageJson()
+
+			// Step 3: Update package.json
+			const newVersion = this.updatePackageJson()
+
+			// Step 3.5: Keep npm workspace self-link aligned with nightly package name
+			this.reconcileWorkspaceSelfLinkForNightly()
+
+			// Step 3.6: Swap in marketplace README before packaging
+			this.swapMarketplaceReadme()
+
+			// Step 4: Package extension
+			this.packageExtension(isPreRelease)
+
+			// Step 5: Publish to marketplaces (skip if dry run)
+			let vsCodePublished = false
+			let openVSXPublished = false
+
+			if (isDryRun) {
+				log.info("Dry run mode: Skipping marketplace publishing")
+			} else {
+				vsCodePublished = this.publishToVSCodeMarketplace(isPreRelease)
+				openVSXPublished = this.publishToOpenVSX(isPreRelease)
+			}
+
+			// Summary
+			log.info(`Nightly publish process completed successfully${isDryRun ? " (dry run)" : ""}`)
+			log.info(`Package created for v${newVersion}: ${config.vsixPath}`)
+
+			if (!isDryRun && !vsCodePublished && !openVSXPublished) {
+				log.warn("Extension was packaged but not published to any marketplace")
+				log.warn("Set VSCE_PAT and/or OVSX_PAT environment variables to enable publishing")
+			}
+		} catch (error) {
+			log.error(`Publish failed: ${error.message}`)
+			process.exit(1)
+		} finally {
+			// Always restore workspace link first
+			this.restoreWorkspaceSelfLink()
+
+			// Always restore package.json
+			this.restorePackageJson()
+
+			// Always restore README.md
+			this.restoreMarketplaceReadme()
+		}
+	}
+}
+
+// Handle cleanup on process exit
+const publisher = new NightlyPublisher()
+
+process.on("exit", () => {
+	publisher.restoreWorkspaceSelfLink()
+	publisher.restorePackageJson()
+	publisher.restoreMarketplaceReadme()
+})
+
+process.on("SIGINT", () => {
+	log.info("\nInterrupted, cleaning up...")
+	publisher.restoreWorkspaceSelfLink()
+	publisher.restorePackageJson()
+	publisher.restoreMarketplaceReadme()
+	process.exit(130)
+})
+
+process.on("SIGTERM", () => {
+	log.info("\nTerminated, cleaning up...")
+	publisher.restoreWorkspaceSelfLink()
+	publisher.restorePackageJson()
+	publisher.restoreMarketplaceReadme()
+	process.exit(143)
+})
+
+// Parse command line arguments
+const args = process.argv.slice(2)
+const isDryRun = args.includes("--dry-run") || args.includes("-n")
+const isPreRelease = args.includes("--pre-release")
+const knownFlags = ["--dry-run", "-n", "--pre-release", "--help", "-h"]
+const unknownArgs = args.filter((a) => !knownFlags.includes(a))
+if (unknownArgs.length > 0) {
+	log.error(`Unknown argument(s): ${unknownArgs.join(", ")}. Run with --help for usage.`)
+	process.exit(1)
+}
+const showHelp = args.includes("--help") || args.includes("-h")
+
+if (showHelp) {
+	console.log(`
+Nightly publish script for VS Code extension
+
+Usage:
+  bun run publish:marketplace:nightly [options]
+
+Options:
+  --pre-release    Publish to the pre-release channel of cline-nightly.
+                   Default is the release channel (used by the scheduled
+                   nightly workflow).
+  --dry-run, -n    Run without actually publishing (package only)
+  --help, -h       Show this help message
+
+Environment variables:
+  VSCE_PAT         Personal Access Token for VS Code Marketplace
+  OVSX_PAT         Personal Access Token for OpenVSX Registry
+
+Examples:
+  bun run publish:marketplace:nightly                      # Release channel publish
+  bun run publish:marketplace:nightly -- --pre-release     # Pre-release channel publish
+  bun run publish:marketplace:nightly -- --dry-run         # Package only
+  VSCE_PAT="token" bun run publish:marketplace:nightly     # Publish to VS Code only
+`)
+	process.exit(0)
+}
+
+// Run the publisher
+publisher.run({ isDryRun, isPreRelease }).catch((error) => {
+	log.error(error.message)
+	process.exit(1)
+})
diff --git a/apps/vscode/scripts/report-issue.js b/apps/vscode/scripts/report-issue.js
new file mode 100644
index 0000000..93dd5d9
--- /dev/null
+++ b/apps/vscode/scripts/report-issue.js
@@ -0,0 +1,137 @@
+const { execSync } = require("child_process")
+const readline = require("readline")
+const os = require("os")
+
+const rl = readline.createInterface({
+	input: process.stdin,
+	output: process.stdout,
+})
+
+const ask = (question) => new Promise((resolve) => rl.question(`\n${question}`, resolve))
+
+const getClineVersion = () => {
+	try {
+		const extensions = execSync("code --list-extensions --show-versions").toString()
+		const clineMatch = extensions.match(/claude-dev@(\d+\.\d+\.\d+)/)
+		return clineMatch ? clineMatch[1] : "Not installed"
+	} catch (_err) {
+		return "Error getting version"
+	}
+}
+
+const collectSystemInfo = () => {
+	let cpuInfo = "N/A"
+	let memoryInfo = "N/A"
+	try {
+		if (process.platform === "darwin") {
+			cpuInfo = execSync("sysctl -n machdep.cpu.brand_string").toString().trim()
+			memoryInfo = execSync("sysctl -n hw.memsize").toString().trim()
+			memoryInfo = `${Math.round(parseInt(memoryInfo) / 1e9)} GB RAM`
+		} else {
+			// Linux specific commands
+			cpuInfo = execSync("lscpu").toString().split("\n").slice(0, 5).join("\n")
+			memoryInfo = execSync("free -h").toString()
+		}
+	} catch (_err) {
+		// Fallback for unsupported systems
+		cpuInfo = Array.from(new Set(os.cpus().map((c) => c.model))).join("\n")
+		memoryInfo = `${Math.round(os.totalmem() / 1e9)} GB RAM`
+	}
+
+	return {
+		cpuInfo,
+		memoryInfo,
+		os: `${os.arch()}; ${os.version()}`,
+		nodeVersion: execSync("node -v").toString().trim(),
+		npmVersion: execSync("npm -v").toString().trim(),
+		clineVersion: getClineVersion(),
+	}
+}
+
+const checkGitHubAuth = async () => {
+	try {
+		execSync("gh auth status", { stdio: "ignore" })
+		return true
+	} catch (_err) {
+		console.log("\nGitHub authentication required.")
+		console.log("\nPlease run the following command in your terminal to authenticate:")
+		console.log("\n  gh auth login\n")
+		console.log("After authenticating, run this script again.")
+		return false
+	}
+}
+
+const createIssueUrl = (systemInfo, issueTitle) => {
+	return (
+		`https://github.com/cline/cline/issues/new?template=bug_report.yml` +
+		`&title=${issueTitle}` +
+		`&operating-system=${systemInfo.os}` +
+		`&cline-version=${systemInfo.clineVersion}` +
+		`&system-info=${
+			`Node: ${systemInfo.nodeVersion}\n` +
+			`npm: ${systemInfo.npmVersion}\n` +
+			`CPU Info: ${systemInfo.cpuInfo}\n` +
+			`Free RAM: ${systemInfo.memoryInfo}`
+		}`
+	)
+}
+
+const openUrl = (url) => {
+	try {
+		switch (process.platform) {
+			case "darwin":
+				execSync(`open "${url}"`)
+				break
+			case "win32":
+				execSync(`start "" "${url}"`)
+				break
+			case "linux":
+				execSync(`xdg-open "${url}"`)
+				break
+			default:
+				console.log("\nPlease open this URL in your browser:")
+				console.log(url)
+		}
+	} catch (_err) {
+		console.log("\nFailed to open URL automatically. Please open this URL in your browser:")
+		console.log(url)
+	}
+}
+
+const submitIssue = async (issueTitle, systemInfo) => {
+	try {
+		const issueUrl = createIssueUrl(systemInfo, issueTitle)
+		console.log("\nOpening GitHub issue creation page in your browser...")
+		openUrl(issueUrl)
+	} catch (err) {
+		console.error("\nFailed to create issue URL:", err.message)
+	}
+}
+
+async function main() {
+	const consent = await ask("Do you consent to collect system data and submit a GitHub issue? (y/n): ")
+	if (consent.trim().toLowerCase() !== "y") {
+		console.log("\nAborted.")
+		rl.close()
+		return
+	}
+
+	console.log("Collecting system data...")
+	const systemInfo = collectSystemInfo()
+
+	const isAuthenticated = await checkGitHubAuth()
+	if (!isAuthenticated) {
+		rl.close()
+		return
+	}
+
+	const issueTitle = await ask("Enter the title for your issue: ")
+
+	await submitIssue(issueTitle, systemInfo)
+	rl.close()
+}
+
+main().catch((err) => {
+	console.error("\nAn error occurred:", err)
+	rl.close()
+})
diff --git a/apps/vscode/scripts/run-bun-tests.ts b/apps/vscode/scripts/run-bun-tests.ts
new file mode 100644
index 0000000..ecfd035
--- /dev/null
+++ b/apps/vscode/scripts/run-bun-tests.ts
@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+
+import { spawn } from "node:child_process"
+import path from "node:path"
+/**
+ * Runner for the SDK-adapter + model-catalog `bun test` suites (the same set
+ * `vitest.config.ts` covers; `test:vitest` runs them under vitest).
+ *
+ * Why a script instead of a bare `bun test <globs>`:
+ *
+ *  1. Curated include set. These suites are an explicit list (see
+ *     INCLUDE_PATTERNS, kept in sync with `vitest.config.ts` `test.include`),
+ *     not the whole tree, so the node-side unit and @vscode/test-cli suites are
+ *     not pulled in. `bun test`'s positional args don't expand `**` the way we
+ *     need, so we resolve the globs ourselves with bun's `Glob`.
+ *
+ *  2. One process per file. `bun test` runs all files in a single process by
+ *     default, so `mock.module(...)` registrations leak between files — suites
+ *     mocking the same specifier with different shapes (e.g.
+ *     `@/core/storage/StateManager`, `@cline/core`) clobber each other.
+ *     `--parallel` runs each file in its own worker process, giving each a fresh
+ *     module registry.
+ *
+ * Usage:
+ *   bun scripts/run-bun-tests.ts            # run the curated set, isolated
+ *   bun scripts/run-bun-tests.ts --list     # print the resolved file list only
+ */
+import { Glob } from "bun"
+
+// Mirror of vitest.config.ts `test.include`. Keep these in sync.
+const INCLUDE_PATTERNS = [
+	"src/sdk/**/*.test.ts",
+	"src/shared/vsCodeSelectorUtils.test.ts",
+	"src/core/storage/remote-config/**/*.test.ts",
+	"src/shared/model-catalog/provider-helpers.test.ts",
+	"src/core/controller/models/__tests__/providerCatalogHandlers.test.ts",
+	"src/core/controller/models/__tests__/providerSwitchNormalization.test.ts",
+	"src/core/controller/models/__tests__/resolveModelInfo.test.ts",
+	"src/core/controller/models/__tests__/providerCatalogSmoke.test.ts",
+	"src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts",
+]
+
+const projectRoot = path.resolve(import.meta.dir, "..")
+
+async function resolveFiles(): Promise<string[]> {
+	const seen = new Set<string>()
+	for (const pattern of INCLUDE_PATTERNS) {
+		const glob = new Glob(pattern)
+		for await (const match of glob.scan({ cwd: projectRoot, onlyFiles: true })) {
+			seen.add(match)
+		}
+	}
+	return [...seen].sort()
+}
+
+async function main(): Promise<void> {
+	const files = await resolveFiles()
+	if (files.length === 0) {
+		console.error("run-bun-tests: no test files matched the include patterns")
+		process.exit(1)
+	}
+
+	const passthrough = process.argv.slice(2)
+	if (passthrough.includes("--list")) {
+		console.log(files.join("\n"))
+		return
+	}
+
+	const args = ["test", "--parallel", ...passthrough.filter((arg) => arg !== "--list"), ...files]
+	const child = spawn("bun", args, { cwd: projectRoot, stdio: "inherit" })
+	child.on("exit", (code, signal) => {
+		if (signal) {
+			process.kill(process.pid, signal)
+			return
+		}
+		process.exit(code ?? 1)
+	})
+}
+
+void main()
diff --git a/apps/vscode/scripts/run-bun-unit-tests.ts b/apps/vscode/scripts/run-bun-unit-tests.ts
new file mode 100644
index 0000000..770fc85
--- /dev/null
+++ b/apps/vscode/scripts/run-bun-unit-tests.ts
@@ -0,0 +1,198 @@
+#!/usr/bin/env bun
+
+import path from "node:path"
+/**
+ * Runner for the node-side `bun test` unit suites.
+ *
+ * A test file belongs to this runner iff it imports from "bun:test" (files that
+ * need the real VS Code extension host import from "mocha" and run under
+ * @vscode/test-cli instead). We glob all `*.test.ts` and keep only the
+ * bun:test ones; the SDK/model-catalog suites listed in IGNORED run through
+ * `run-bun-tests.ts`, so they're skipped here to avoid double-running.
+ *
+ * Why one process per file: `bun test --parallel <allFiles>` reuses a pool of
+ * worker processes, and `mock.module(...)` registrations accumulate across files
+ * sharing a worker. Suites that mock the same specifier with different shapes
+ * (e.g. `@core/storage/disk`, `@cline/core`, `fs/promises`, `os`) then clobber
+ * each other and fail only at scale. Spawning one `bun test` process per file
+ * (bounded by a small concurrency pool, via `Bun.spawn`) gives each file a fresh
+ * module registry.
+ *
+ * Usage:
+ *   bun scripts/run-bun-unit-tests.ts            # run the suite, isolated
+ *   bun scripts/run-bun-unit-tests.ts --list     # print the resolved file list
+ *   bun scripts/run-bun-unit-tests.ts --all      # include ELECTRON_HOST_ONLY
+ *   bun scripts/run-bun-unit-tests.ts -c 6       # concurrency (default 4)
+ */
+import { Glob } from "bun"
+
+const projectRoot = path.resolve(import.meta.dir, "..")
+
+// A file runs under `bun test` iff it imports "bun:test"; mocha-owned files are
+// skipped by the import filter in resolveFiles().
+const INCLUDE_PATTERNS = ["src/**/*.test.ts"]
+const BUN_TEST_IMPORT = /from\s+["']bun:test["']/
+
+// SDK + model-catalog suites run through `run-bun-tests.ts`; skip them here so
+// they aren't run twice.
+const IGNORED = new Set<string>([
+	"src/core/controller/models/__tests__/providerCatalogHandlers.test.ts",
+	"src/core/controller/models/__tests__/providerCatalogSmoke.test.ts",
+	"src/core/controller/models/__tests__/providerSwitchNormalization.test.ts",
+	"src/core/controller/models/__tests__/resolveModelInfo.test.ts",
+	"src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts",
+])
+
+// Files that require the real VSCode Electron host (@vscode/test-cli). Excluded
+// by default; they continue to run under @vscode/test-cli.
+const ELECTRON_HOST_ONLY = new Set<string>([])
+
+async function resolveFiles(includeHostOnly: boolean): Promise<string[]> {
+	const seen = new Set<string>()
+	for (const pattern of INCLUDE_PATTERNS) {
+		const glob = new Glob(pattern)
+		for await (const match of glob.scan({ cwd: projectRoot, onlyFiles: true })) {
+			const normalized = match.split(path.sep).join("/")
+			if (IGNORED.has(normalized)) {
+				continue
+			}
+			if (!includeHostOnly && ELECTRON_HOST_ONLY.has(normalized)) {
+				continue
+			}
+			// Only bun-runner-owned files (those importing "bun:test"). Files still on
+			// the @vscode/test-cli Electron host import from "mocha" and are skipped.
+			const source = await Bun.file(path.join(projectRoot, normalized)).text()
+			if (!BUN_TEST_IMPORT.test(source)) {
+				continue
+			}
+			seen.add(normalized)
+		}
+	}
+	return [...seen].sort()
+}
+
+type FileResult = {
+	file: string
+	code: number
+	pass: number
+	fail: number
+	output: string
+}
+
+// `bun test` prints its summary as e.g. " 12 pass\n  0 fail".
+function parseCounts(output: string): { pass: number; fail: number } {
+	let pass = 0
+	let fail = 0
+	for (const m of output.matchAll(/^\s*(\d+)\s+pass\b/gm)) {
+		pass += Number(m[1])
+	}
+	for (const m of output.matchAll(/^\s*(\d+)\s+fail\b/gm)) {
+		fail += Number(m[1])
+	}
+	return { pass, fail }
+}
+
+const PER_FILE_TIMEOUT_MS = 120_000
+
+async function runOne(file: string): Promise<FileResult> {
+	const proc = Bun.spawn(["bun", "test", file], {
+		cwd: projectRoot,
+		stdout: "pipe",
+		stderr: "pipe",
+		env: { ...process.env, FORCE_COLOR: "0" },
+	})
+	// Guard against a single hung file stalling the whole pool: kill it after a
+	// generous per-file budget and surface it as a failure.
+	let timedOut = false
+	const timer = setTimeout(() => {
+		timedOut = true
+		proc.kill()
+	}, PER_FILE_TIMEOUT_MS)
+	const [stdout, stderr, code] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	])
+	clearTimeout(timer)
+	const output = stdout + stderr + (timedOut ? `\n[runner] TIMEOUT after ${PER_FILE_TIMEOUT_MS}ms — killed\n` : "")
+	const { pass, fail } = parseCounts(output)
+	// A nonzero exit with no parsed counts (load/parse error, timeout) must count
+	// as a failure so the gate cannot pass silently.
+	const effectiveFail = timedOut && fail === 0 ? Math.max(fail, 1) : fail
+	return { file, code, pass, fail: effectiveFail, output }
+}
+
+async function runPool(files: string[], concurrency: number): Promise<FileResult[]> {
+	const results: FileResult[] = []
+	let next = 0
+	const launch = async (): Promise<void> => {
+		while (next < files.length) {
+			const file = files[next++]
+			const result = await runOne(file)
+			results.push(result)
+			const failed = result.fail > 0 || result.code !== 0
+			const status = failed ? "FAIL" : "ok"
+			const counts = `${result.pass} pass / ${result.fail} fail`
+			process.stdout.write(`[${results.length}/${files.length}] ${status.padEnd(4)} ${counts.padEnd(20)} ${file}\n`)
+			if (failed) {
+				process.stdout.write(result.output.trimEnd() + "\n")
+			}
+		}
+	}
+	const workers: Promise<void>[] = []
+	for (let i = 0; i < Math.min(concurrency, files.length); i++) {
+		workers.push(launch())
+	}
+	await Promise.all(workers)
+	return results
+}
+
+function parseConcurrency(argv: string[]): number {
+	const flagIdx = argv.findIndex((a) => a === "-c" || a === "--concurrency")
+	if (flagIdx !== -1 && argv[flagIdx + 1]) {
+		const n = Number(argv[flagIdx + 1])
+		if (Number.isFinite(n) && n > 0) {
+			return Math.floor(n)
+		}
+	}
+	return 4
+}
+
+async function main(): Promise<void> {
+	const passthrough = process.argv.slice(2)
+	const includeHostOnly = passthrough.includes("--all")
+	const files = await resolveFiles(includeHostOnly)
+	if (files.length === 0) {
+		console.error("run-bun-unit-tests: no test files matched")
+		process.exit(1)
+	}
+
+	if (passthrough.includes("--list")) {
+		console.log(files.join("\n"))
+		return
+	}
+
+	const concurrency = parseConcurrency(passthrough)
+	const started = Date.now()
+	console.log(`Running ${files.length} unit test files, isolated (concurrency ${concurrency})…\n`)
+
+	const results = await runPool(files, concurrency)
+
+	const totalPass = results.reduce((sum, r) => sum + r.pass, 0)
+	const totalFail = results.reduce((sum, r) => sum + r.fail, 0)
+	const failedFiles = results.filter((r) => r.fail > 0 || r.code !== 0).sort((a, b) => a.file.localeCompare(b.file))
+	const elapsed = ((Date.now() - started) / 1000).toFixed(1)
+
+	console.log("\n──────────────────────────────────────────────")
+	console.log(`Files: ${results.length}   Pass: ${totalPass}   Fail: ${totalFail}   Time: ${elapsed}s`)
+	if (failedFiles.length > 0) {
+		console.log(`\nFailing files (${failedFiles.length}):`)
+		for (const r of failedFiles) {
+			console.log(`  ${r.file}  (${r.pass} pass / ${r.fail} fail, exit ${r.code})`)
+		}
+		process.exit(1)
+	}
+	console.log("All unit test files passed.")
+}
+
+void main()
diff --git a/apps/vscode/scripts/run-extension-host.sh b/apps/vscode/scripts/run-extension-host.sh
new file mode 100755
index 0000000..6fe9142
--- /dev/null
+++ b/apps/vscode/scripts/run-extension-host.sh
@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+
+SESSION="cline-dev"
+WORKSPACE="${CLINE_WORKSPACE:-$(cd "$(dirname "$0")/.." && pwd)}"
+ENVIRONMENT="${CLINE_ENVIRONMENT:-production}"
+
+cd "$WORKSPACE"
+
+# Export env vars -- tmux inherits them automatically
+export IS_DEV=true
+export DEV_WORKSPACE_FOLDER="$WORKSPACE"
+export CLINE_ENVIRONMENT="$ENVIRONMENT"
+if [ -f .env ]; then
+  set -a
+  source .env
+  set +a
+fi
+
+# Step 1: Build protos (everything depends on this)
+echo "Building protos..."
+bun run protos || { echo "Protos build failed"; exit 1; }
+
+# Step 2: Build webview once
+echo "Building webview..."
+bun run build:webview || { echo "Webview build failed"; exit 1; }
+
+# Step 3: Kill existing session if one is running
+tmux kill-session -t "$SESSION" 2>/dev/null
+true
+
+# Step 4: Create tmux session with 4 vertical panes
+#
+#   ┌────────────┬────────────┬────────────┬────────────┐
+#   │  esbuild   │    tsc     │  webview   │  ext host  │
+#   └────────────┴────────────┴────────────┴────────────┘
+
+echo "Starting tmux session..."
+tmux new-session -d -s "$SESSION" -c "$WORKSPACE"
+tmux split-window -h -t "$SESSION" -c "$WORKSPACE"
+tmux split-window -h -t "$SESSION:0.0" -c "$WORKSPACE"
+tmux split-window -h -t "$SESSION:0.2" -c "$WORKSPACE"
+tmux select-layout -t "$SESSION" even-horizontal
+
+# Ctrl+C kills the whole session
+tmux bind-key -T root C-c kill-session
+
+tmux send-keys -t "$SESSION:0.0" "bun run watch:esbuild" Enter
+tmux send-keys -t "$SESSION:0.1" "bun run watch:tsc" Enter
+tmux send-keys -t "$SESSION:0.2" "bun run dev:webview" Enter
+tmux send-keys -t "$SESSION:0.3" "while [ ! -f '$WORKSPACE/dist/extension.js' ]; do sleep 0.5; done && echo 'Launching Extension Host...' && code --extensionDevelopmentPath='$WORKSPACE' --disable-workspace-trust --disable-extension saoudrizwan.claude-dev --disable-extension saoudrizwan.cline-nightly '$WORKSPACE' && echo 'Extension Host launched.'" Enter
+
+# Attach to the session
+tmux attach-session -t "$SESSION"
+
+# Session ended -- run full cleanup
+tmux unbind-key -T root C-c 2>/dev/null
+# Kill watcher processes and their node children
+pkill -f "watch:esbuild|watch:tsc|dev:webview" 2>/dev/null
+pkill -f "esbuild.mjs --watch" 2>/dev/null
+pkill -f "tsc --noEmit --watch" 2>/dev/null
+pkill -f "vite.*/webview-ui" 2>/dev/null
+# Close the Extension Development Host window
+osascript -e '
+tell application "System Events"
+  tell process "Electron"
+    set windowList to every window whose title contains "Extension Development Host"
+    repeat with w in windowList
+      click button 1 of w
+    end repeat
+  end tell
+end tell' 2>/dev/null
+echo "Stopped"
diff --git a/apps/vscode/scripts/runclinecore.sh b/apps/vscode/scripts/runclinecore.sh
new file mode 100755
index 0000000..229d289
--- /dev/null
+++ b/apps/vscode/scripts/runclinecore.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+set -eu #x
+
+# This installs the cline-core app to the user's home directory,
+# and starts the service.
+
+if [[ "${1:-}" == "-h" ]]; then
+    ./scripts/test-hostbridge-server.ts &
+fi
+
+CORE_DIR=~/.cline/core
+INSTALL_DIR=$CORE_DIR/dev-instance/
+LOG_FILE=~/.cline/cline-core-service.log
+
+ZIP_FILE=standalone.zip
+ZIP=dist-standalone/${ZIP_FILE}
+
+# Remove old unpacked versions to force reinstall
+rm -rf $CORE_DIR/* || true
+
+mkdir -p $INSTALL_DIR
+cp $ZIP $INSTALL_DIR
+cd $INSTALL_DIR
+unp $ZIP_FILE > /dev/null
+
+pkill -f cline-core.js || true
+
+# Detect platform name using the same logic as ClineDirs.kt in the plugin.
+OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+ARCH=$(uname -m)
+
+if [[ "$OS" == "darwin" && "$ARCH" == "x86_64" ]]; then
+    PLATFORM_NAME="darwin-x64"
+elif [[ "$OS" == "darwin" && "$ARCH" == "arm64" ]]; then
+    PLATFORM_NAME="darwin-arm64"
+elif [[ "$OS" == *"mingw"* || "$OS" == *"cygwin"* || "$OS" == *"msys"* ]] && [[ "$ARCH" == "x86_64" || "$ARCH" == "amd64" ]]; then
+    # Note: This script requires a bash-compatible environment on Windows (Git Bash, MSYS2, Cygwin)
+    PLATFORM_NAME="win-x64"
+elif [[ "$OS" == "linux" && ("$ARCH" == "x86_64" || "$ARCH" == "amd64") ]]; then
+    PLATFORM_NAME="linux-x64"
+else
+    echo "Unsupported platform: $OS $ARCH"
+    exit 1
+fi
+
+BINARY_MODULES_DIR="./binaries/$PLATFORM_NAME/node_modules"
+
+echo pwd: $(pwd)
+set -x
+NODE_PATH=$BINARY_MODULES_DIR:./node_modules DEV_WORKSPACE_FOLDER=/tmp/ node --max-old-space-size=${NODE_MAX_OLD_SPACE_SIZE:-8192} --heapsnapshot-near-heap-limit=1 cline-core.js 2>&1 | tee $LOG_FILE
diff --git a/apps/vscode/scripts/test-hostbridge-server.ts b/apps/vscode/scripts/test-hostbridge-server.ts
new file mode 100755
index 0000000..2ab040e
--- /dev/null
+++ b/apps/vscode/scripts/test-hostbridge-server.ts
@@ -0,0 +1,192 @@
+#!/usr/bin/env bun
+import * as grpc from "@grpc/grpc-js"
+import { ReflectionService } from "@grpc/reflection"
+import * as health from "grpc-health-check"
+import * as os from "os"
+import { type DiffServiceServer, DiffServiceService } from "../src/generated/grpc-js/host/diff"
+import { type EnvServiceServer, EnvServiceService } from "../src/generated/grpc-js/host/env"
+import { type TestingServiceServer, TestingServiceService } from "../src/generated/grpc-js/host/testing"
+import { type WindowServiceServer, WindowServiceService } from "../src/generated/grpc-js/host/window"
+import { type WorkspaceServiceServer, WorkspaceServiceService } from "../src/generated/grpc-js/host/workspace"
+import { getPackageDefinition } from "./proto-utils.mjs"
+
+export async function startTestHostBridgeServer() {
+	const server = new grpc.Server()
+
+	// Set up health check
+	const healthImpl = new health.HealthImplementation({ "": "SERVING" })
+	healthImpl.addToServer(server)
+
+	// Add host bridge services using the mock implementations
+	server.addService(WorkspaceServiceService, createMockService<WorkspaceServiceServer>("WorkspaceService"))
+	server.addService(WindowServiceService, createMockService<WindowServiceServer>("WindowService"))
+	server.addService(EnvServiceService, createMockService<EnvServiceServer>("EnvService"))
+	server.addService(DiffServiceService, createMockService<DiffServiceServer>("DiffService"))
+	server.addService(TestingServiceService, createMockService<TestingServiceServer>("TestingService"))
+
+	// Load package definition for reflection service
+	const packageDefinition = await getPackageDefinition()
+	// Filter service names to only include host services
+	const hostBridgeServiceNames = Object.keys(packageDefinition).filter(
+		(name) => name.startsWith("host.") || name.startsWith("grpc.health"),
+	)
+	const reflection = new ReflectionService(packageDefinition, {
+		services: hostBridgeServiceNames,
+	})
+	reflection.addToServer(server)
+
+	const bindAddress = process.env.HOST_BRIDGE_ADDRESS || `127.0.0.1:26041`
+
+	server.bindAsync(bindAddress, grpc.ServerCredentials.createInsecure(), (err) => {
+		if (err) {
+			console.error(`Failed to bind test host bridge server to ${bindAddress}:`, err)
+			process.exit(1)
+		}
+		server.start()
+		console.log(`Test HostBridge gRPC server listening on ${bindAddress}`)
+	})
+}
+
+/**
+ * Creates a mock gRPC service implementation using Proxy
+ * @param serviceName Name of the service for logging
+ * @returns A proxy that implements the service interface
+ */
+function createMockService<T extends grpc.UntypedServiceImplementation>(serviceName: string): T {
+	const handler: ProxyHandler<T> = {
+		get(_target, prop) {
+			// Return a function that handles the gRPC call
+			return (call: any, callback: any) => {
+				console.log(`Hostbridge: ${serviceName}.${String(prop)} called with:`, call.request)
+
+				// Special cases that need specific return values
+				switch (prop) {
+					case "getWorkspacePaths":
+						const workspaceDir = process.env.TEST_HOSTBRIDGE_WORKSPACE_DIR || "/test-workspace"
+						callback(null, {
+							paths: [workspaceDir],
+						})
+						return
+
+					case "getMachineId":
+						callback(null, {
+							value: "fake-machine-id-" + os.hostname(),
+						})
+						return
+
+					case "getTelemetrySettings":
+						callback(null, {
+							isEnabled: 2, // Setting.DISABLED
+							errorLevel: "all",
+						})
+						return
+
+					case "clipboardReadText":
+						callback(null, {
+							value: "",
+						})
+						return
+
+					case "openExternal":
+						simulateOAuthBrowserCallback(call.request?.value || "")
+							.then(() => callback(null, {}))
+							.catch((error) => callback(error))
+						return
+
+					case "getWebviewHtml":
+						callback(null, {
+							html: "<html><body>Fake Webview</body></html>",
+						})
+						return
+
+					case "showTextDocument":
+						callback(null, {
+							document_path: call.request?.path || "",
+							view_column: 1,
+							is_active: true,
+						})
+						return
+
+					case "openDiff":
+						callback(null, {
+							diff_id: "fake-diff-" + Date.now(),
+						})
+						return
+
+					case "getDocumentText":
+						callback(null, {
+							content: "",
+						})
+						return
+
+					case "getOpenTabs":
+					case "getVisibleTabs":
+					case "showOpenDialogue":
+						callback(null, {
+							paths: [],
+						})
+						return
+
+					case "getDiagnostics":
+						callback(null, {
+							file_diagnostics: [],
+						})
+						return
+
+					// For streaming methods (like subscribeToTelemetrySettings)
+					case "subscribeToTelemetrySettings":
+						// Just end the stream immediately
+						call.end()
+						return
+				}
+
+				// Default: return empty object for all other methods
+				callback(null, {})
+			}
+		},
+	}
+
+	return new Proxy({} as T, handler)
+}
+
+async function simulateOAuthBrowserCallback(urlString: string): Promise<void> {
+	let url: URL
+	try {
+		url = new URL(urlString)
+	} catch {
+		return
+	}
+
+	if (!isLoopbackHost(url.hostname) || url.pathname !== "/api/v1/auth/authorize") {
+		return
+	}
+
+	const callbackUrl = url.searchParams.get("callback_url") ?? url.searchParams.get("redirect_uri")
+	if (!callbackUrl) {
+		return
+	}
+
+	const callback = new URL(callbackUrl)
+	if (!isLoopbackHost(callback.hostname) || callback.pathname !== "/auth") {
+		return
+	}
+
+	callback.searchParams.set("code", "test-personal-token")
+	callback.searchParams.set("provider", "cline")
+
+	const response = await fetch(callback.toString())
+	if (!response.ok) {
+		throw new Error(`Mock OAuth callback failed: ${response.status} ${response.statusText}`)
+	}
+}
+
+function isLoopbackHost(hostname: string): boolean {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"
+}
+
+if (require.main === module) {
+	startTestHostBridgeServer().catch((err) => {
+		console.error("Failed to start test host bridge server:", err)
+		process.exit(1)
+	})
+}
diff --git a/apps/vscode/scripts/test-standalone-core-api-server.ts b/apps/vscode/scripts/test-standalone-core-api-server.ts
new file mode 100644
index 0000000..0854c3d
--- /dev/null
+++ b/apps/vscode/scripts/test-standalone-core-api-server.ts
@@ -0,0 +1,186 @@
+#!/usr/bin/env bun
+
+/**
+ * Simple Cline gRPC Server
+ *
+ * This script provides a minimal way to run the Cline core gRPC service
+ * without requiring the full installation, while automatically mocking all external services. Simply run:
+ *
+ *   # One-time setup (generates protobuf files)
+ *	 bun run compile-standalone
+ *   bun run test:sca-server
+ *
+ * The following components are started automatically:
+ *   1. HostBridge test server
+ *   2. ClineApiServerMock (mock implementation of the Cline API)
+ *   3. SDK WorkOS device-auth flow, with WorkOS fetches mocked by testing-platform-workos-fetch-mock.cjs
+ *
+ * Environment Variables for Customization:
+ *   PROJECT_ROOT - Override project root directory (default: parent of scripts dir)
+ *   CLINE_DIST_DIR - Override distribution directory (default: PROJECT_ROOT/dist-standalone)
+ *   CLINE_CORE_FILE - Override core file name (default: cline-core.js)
+ *   PROTOBUS_PORT - gRPC server port (default: 26040)
+ *   HOSTBRIDGE_PORT - HostBridge server port (default: 26041)
+ *   WORKSPACE_DIR - Working directory (default: current directory)
+ *   E2E_TEST - Enable legacy mock auth mode (default: false)
+ *   CLINE_ENVIRONMENT - Environment setting (default: local)
+ *
+ * Ideal for local development, testing, or lightweight E2E scenarios.
+ */
+
+import * as fs from "node:fs"
+import { mkdtempSync, rmSync } from "node:fs"
+import * as os from "node:os"
+import { ChildProcess, execSync, spawn } from "child_process"
+import * as path from "path"
+import { ClineApiServerMock } from "../src/test/e2e/fixtures/server/index"
+
+const PROTOBUS_PORT = process.env.PROTOBUS_PORT || "26040"
+const HOSTBRIDGE_PORT = process.env.HOSTBRIDGE_PORT || "26041"
+const WORKSPACE_DIR = process.env.WORKSPACE_DIR || process.cwd()
+const E2E_TEST = process.env.E2E_TEST || "false"
+const CLINE_ENVIRONMENT = process.env.CLINE_ENVIRONMENT || "local"
+const USE_C8 = process.env.USE_C8 === "true"
+
+// Locate the standalone build directory and core file with flexible path resolution
+const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, "..")
+const distDir = process.env.CLINE_DIST_DIR || path.join(projectRoot, "dist-standalone")
+const clineCoreFile = process.env.CLINE_CORE_FILE || "cline-core.js"
+const coreFile = path.join(distDir, clineCoreFile)
+
+const childProcesses: ChildProcess[] = []
+
+async function main(): Promise<void> {
+	console.log("Starting Simple Cline gRPC Server...")
+	console.log(`Project Root: ${projectRoot}`)
+	console.log(`Workspace: ${WORKSPACE_DIR}`)
+	console.log(`ProtoBus Port: ${PROTOBUS_PORT}`)
+	console.log(`HostBridge Port: ${HOSTBRIDGE_PORT}`)
+
+	console.log(`Looking for standalone build at: ${coreFile}`)
+
+	if (!fs.existsSync(coreFile)) {
+		console.error(`Standalone build not found at: ${coreFile}`)
+		console.error("Available environment variables for customization:")
+		console.error("  PROJECT_ROOT - Override project root directory")
+		console.error("  CLINE_DIST_DIR - Override distribution directory")
+		console.error("  CLINE_CORE_FILE - Override core file name")
+		console.error("")
+		console.error("To build the standalone version, run: bun run compile-standalone")
+		process.exit(1)
+	}
+
+	try {
+		await ClineApiServerMock.startGlobalServer()
+		console.log("Cline API Server started in-process")
+	} catch (error) {
+		console.error("Failed to start Cline API Server:", error)
+		process.exit(1)
+	}
+
+	const extensionsDir = path.join(distDir, "vsce-extension")
+	const userDataDir = mkdtempSync(path.join(os.tmpdir(), "vsce"))
+	const clineTestWorkspace = mkdtempSync(path.join(os.tmpdir(), "cline-test-workspace-"))
+
+	console.log("Starting HostBridge test server...")
+	const hostbridge: ChildProcess = spawn("bun", [path.join(__dirname, "test-hostbridge-server.ts")], {
+		stdio: "inherit",
+		env: {
+			...process.env,
+			TEST_HOSTBRIDGE_WORKSPACE_DIR: clineTestWorkspace,
+			HOST_BRIDGE_ADDRESS: `127.0.0.1:${HOSTBRIDGE_PORT}`,
+		},
+	})
+	childProcesses.push(hostbridge)
+
+	console.log(`Temp user data dir: ${userDataDir}`)
+	console.log(`Temp extensions dir: ${extensionsDir}`)
+	// Extract standalone.zip if needed
+	const standaloneZipPath = path.join(distDir, "standalone.zip")
+	if (!fs.existsSync(standaloneZipPath)) {
+		console.error(`standalone.zip not found at: ${standaloneZipPath}`)
+		process.exit(1)
+	}
+
+	console.log("Extracting standalone.zip to extensions directory...")
+	try {
+		if (!fs.existsSync(extensionsDir)) {
+			execSync(`unzip -o -q "${standaloneZipPath}" -d "${extensionsDir}"`, { stdio: "inherit" })
+		}
+		console.log(`Successfully extracted standalone.zip to: ${extensionsDir}`)
+	} catch (error) {
+		console.error("Failed to extract standalone.zip:", error)
+		process.exit(1)
+	}
+
+	const covDir = path.join(projectRoot, `coverage/coverage-core-${PROTOBUS_PORT}`)
+
+	const workosFetchMockPath = path.join(projectRoot, "scripts", "testing-platform-workos-fetch-mock.cjs")
+	const baseArgs = ["--enable-source-maps", "--require", workosFetchMockPath, path.join(distDir, "cline-core.js")]
+
+	const c8Bin = path.join(projectRoot, "node_modules", ".bin", process.platform === "win32" ? "c8.cmd" : "c8")
+	const spawnCommand = USE_C8 ? c8Bin : "node"
+	const spawnArgs = USE_C8 ? ["--report-dir", covDir, "node", ...baseArgs] : baseArgs
+
+	console.log(`Starting Cline Core Service... (useC8=${USE_C8})`)
+
+	const coreService: ChildProcess = spawn(spawnCommand, spawnArgs, {
+		cwd: projectRoot,
+		env: {
+			...process.env,
+			NODE_PATH: "./node_modules",
+			DEV_WORKSPACE_FOLDER: WORKSPACE_DIR,
+			PROTOBUS_ADDRESS: `127.0.0.1:${PROTOBUS_PORT}`,
+			HOST_BRIDGE_ADDRESS: `localhost:${HOSTBRIDGE_PORT}`,
+			E2E_TEST,
+			CLINE_ENVIRONMENT,
+			CLINE_DIR: userDataDir,
+			INSTALL_DIR: extensionsDir,
+		},
+		stdio: "inherit",
+	})
+	childProcesses.push(coreService)
+
+	const shutdown = async () => {
+		console.log("\nShutting down services...")
+
+		while (childProcesses.length > 0) {
+			const child = childProcesses.pop()
+			if (child && !child.killed) child.kill("SIGINT")
+		}
+
+		await ClineApiServerMock.stopGlobalServer()
+
+		try {
+			rmSync(userDataDir, { recursive: true, force: true })
+			rmSync(clineTestWorkspace, { recursive: true, force: true })
+			console.log("Cleaned up temporary directories")
+		} catch (err) {
+			console.warn("Failed to cleanup temp directories:", err)
+		}
+
+		process.exit(0)
+	}
+
+	process.on("SIGINT", shutdown)
+	process.on("SIGTERM", shutdown)
+
+	coreService.on("exit", (code) => {
+		console.log(`Core service exited with code ${code}`)
+		shutdown()
+	})
+	hostbridge.on("exit", (code) => {
+		console.log(`HostBridge exited with code ${code}`)
+		shutdown()
+	})
+
+	console.log(`Cline gRPC Server is running on 127.0.0.1:${PROTOBUS_PORT}`)
+	console.log("Press Ctrl+C to stop")
+}
+
+if (require.main === module) {
+	main().catch((err) => {
+		console.error("Failed to start simple Cline server:", err)
+		process.exit(1)
+	})
+}
diff --git a/apps/vscode/scripts/testing-platform-orchestrator.ts b/apps/vscode/scripts/testing-platform-orchestrator.ts
new file mode 100644
index 0000000..10a0ac4
--- /dev/null
+++ b/apps/vscode/scripts/testing-platform-orchestrator.ts
@@ -0,0 +1,248 @@
+#!/usr/bin/env bun
+/**
+ * Test Orchestrator
+ *
+ * Automates server lifecycle for running spec files against the standalone server.
+ *
+ * Prerequisites:
+ *   Build standalone first: `bun run compile-standalone`
+ *
+ * Usage:
+ *   - Single file:   `bun run test:tp-orchestrator path/to/spec.json`
+ *   - All specs dir: `bun run test:tp-orchestrator tests/specs`
+ *
+ * Flags:
+ *   --server-logs        Show server logs (hidden by default)
+ *   --count=<number>     Repeat execution N times (default: 1)
+ *   --fix     			  Automatically update spec files with actual responses
+ *   --coverage     	  Generate integration test coverage information
+ *
+ */
+
+import { ChildProcess, spawn } from "child_process"
+import fs from "fs"
+import minimist from "minimist"
+import net from "net"
+import path from "path"
+import kill from "tree-kill"
+
+let showServerLogs = false
+let fix = false
+let coverage = false
+const WAIT_SERVER_DEFAULT_TIMEOUT = 60000
+const usedPorts = new Set<number>()
+
+/**
+ * Find an available TCP port within the given range [min, max].
+ *
+ * - Ports are allocated sequentially (starting at `min`) rather than randomly,
+ *   which avoids accidental reuse when running hundreds of tests in a row.
+ * - Each successfully allocated port is tracked in `usedPorts` to guarantee
+ *   it is never handed out again within the lifetime of this orchestrator.
+ * - Before returning, the function binds a temporary server to the port to
+ *   verify that the OS really considers it available, then immediately closes it.
+ *
+ * This approach makes the orchestrator much more robust on CI (e.g. GitHub Actions),
+ * where a just-terminated server may leave its socket in TIME_WAIT and cause
+ * flakiness if the same port is reallocated too soon.
+ */
+async function getAvailablePort(min = 20000, max = 49151): Promise<number> {
+	return new Promise((resolve, _) => {
+		const tryPort = (candidate?: number) => {
+			const port = candidate ?? Math.floor(Math.random() * (max - min + 1)) + min
+			if (usedPorts.has(port)) {
+				// already allocated in this run
+				return tryPort()
+			}
+			const server = net.createServer()
+			server.once("error", () => tryPort())
+			server.once("listening", () => {
+				server.close(() => {
+					usedPorts.add(port) // mark reserved
+					resolve(port)
+				})
+			})
+			server.listen(port, "127.0.0.1")
+		}
+		tryPort()
+	})
+}
+
+// Poll until a given TCP port on a host is accepting connections.
+async function waitForPort(port: number, host = "127.0.0.1", timeout = 10000): Promise<void> {
+	const start = Date.now()
+	const waitForPortSleepMs = 100
+	while (Date.now() - start < timeout) {
+		await new Promise((res) => setTimeout(res, waitForPortSleepMs))
+		try {
+			await new Promise<void>((resolve, reject) => {
+				const socket = net.connect(port, host, () => {
+					socket.destroy()
+					resolve()
+				})
+				socket.on("error", reject)
+			})
+			return
+		} catch {
+			// try again
+		}
+	}
+	throw new Error(`Timeout waiting for ${host}:${port}`)
+}
+
+async function startServer(): Promise<{ server: ChildProcess; grpcPort: string }> {
+	const grpcPort = (await getAvailablePort()).toString()
+	const hostbridgePort = (await getAvailablePort()).toString()
+
+	const server = spawn("bun", ["scripts/test-standalone-core-api-server.ts"], {
+		// When logs are hidden, ignore stdio instead of piping it without a reader:
+		// an unread pipe can fill and stall server startup/shutdown in CI.
+		stdio: showServerLogs ? "inherit" : "ignore",
+		env: {
+			...process.env,
+			PROTOBUS_PORT: grpcPort,
+			HOSTBRIDGE_PORT: hostbridgePort,
+			USE_C8: coverage ? "true" : "false",
+		},
+	})
+
+	try {
+		// Wait for either the server to become ready or fail on spawn error.
+		await Promise.race([
+			waitForPort(Number(grpcPort), "127.0.0.1", WAIT_SERVER_DEFAULT_TIMEOUT),
+			new Promise((_, reject) => server.once("error", reject)),
+			new Promise((_, reject) =>
+				server.once("exit", (code, signal) => reject(new Error(`Server exited before ready: ${code ?? signal}`))),
+			),
+		])
+	} catch (error) {
+		await stopServer(server)
+		throw error
+	}
+
+	return { server, grpcPort }
+}
+
+function stopServer(server: ChildProcess): Promise<void> {
+	return new Promise((resolve) => {
+		if (!server.pid || server.exitCode !== null || server.signalCode !== null) return resolve()
+
+		let settled = false
+		const finish = () => {
+			if (!settled) {
+				settled = true
+				resolve()
+			}
+		}
+
+		server.once("exit", finish)
+		kill(server.pid, "SIGINT", (err) => {
+			if (err) console.warn("Failed to kill server process:", err)
+		})
+		setTimeout(() => {
+			if (!settled && server.pid) {
+				kill(server.pid, "SIGKILL", finish)
+			}
+		}, 5000).unref()
+	})
+}
+
+function runTestingPlatform(specFile: string, grpcPort: string): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const testProcess = spawn("bun", ["index.ts", specFile, ...(fix ? ["--fix"] : [])], {
+			cwd: path.join(process.cwd(), "testing-platform"),
+			stdio: "inherit",
+			env: {
+				...process.env,
+				STANDALONE_GRPC_SERVER_PORT: grpcPort,
+			},
+		})
+
+		testProcess.once("error", reject)
+		testProcess.once("exit", (code) => {
+			code === 0 ? resolve() : reject(new Error(`Exit code ${code}`))
+		})
+	})
+}
+
+async function runSpec(specFile: string): Promise<void> {
+	const { server, grpcPort } = await startServer()
+	try {
+		await runTestingPlatform(specFile, grpcPort)
+		console.log(`✅ ${path.basename(specFile)} passed`)
+	} finally {
+		await stopServer(server)
+	}
+}
+
+function collectSpecFiles(inputPath: string): string[] {
+	const fullPath = path.resolve(inputPath)
+	if (!fs.existsSync(fullPath)) throw new Error(`Path does not exist: ${fullPath}`)
+
+	const stat = fs.statSync(fullPath)
+	if (stat.isDirectory()) {
+		return fs
+			.readdirSync(fullPath)
+			.filter((f) => f.endsWith(".json"))
+			.map((f) => path.join(fullPath, f))
+	}
+	if (fullPath.endsWith(".json")) return [fullPath]
+	throw new Error("Spec path must be a JSON file or a folder containing JSON files")
+}
+
+async function runAll(inputPath: string, count: number) {
+	const specFiles = collectSpecFiles(inputPath)
+	if (specFiles.length === 0) {
+		console.warn(`⚠️ No spec files found in ${inputPath}`)
+		return
+	}
+
+	let success = 0
+	let failure = 0
+	const totalStart = Date.now()
+
+	for (let i = 0; i < count; i++) {
+		console.log(`\n🔁 Run #${i + 1} of ${count}`)
+		for (const specFile of specFiles) {
+			try {
+				await runSpec(specFile)
+				success++
+			} catch (err) {
+				console.error(`❌ run #${i + 1}: ${path.basename(specFile)} failed:`, (err as Error).message)
+				failure++
+			}
+		}
+
+		if (failure > 0) process.exitCode = 1
+	}
+
+	console.log(`✅ Passed: ${success}`)
+	if (failure > 0) console.log(`❌ Failed: ${failure}`)
+	console.log(`📋 Total specs: ${specFiles.length} Total runs: ${specFiles.length * count}`)
+	console.log(`🏁 All runs completed in ${((Date.now() - totalStart) / 1000).toFixed(2)}s`)
+}
+
+async function main() {
+	const args = minimist(process.argv.slice(2), { default: { count: 1 } })
+	const inputPath = args._[0]
+	const count = Number(args.count)
+	showServerLogs = Boolean(args["server-logs"])
+	fix = Boolean(args["fix"])
+	coverage = Boolean(args["coverage"])
+
+	if (!inputPath) {
+		console.error(
+			"Usage: bun scripts/testing-platform-orchestrator.ts <spec-file-or-folder> [--count=N] [--server-logs] [--fix] [--coverage]",
+		)
+		process.exit(1)
+	}
+
+	await runAll(inputPath, count)
+}
+
+if (require.main === module) {
+	main().catch((err) => {
+		console.error("❌ Fatal error:", err)
+		process.exit(1)
+	})
+}
diff --git a/apps/vscode/scripts/testing-platform-workos-fetch-mock.cjs b/apps/vscode/scripts/testing-platform-workos-fetch-mock.cjs
new file mode 100644
index 0000000..8ed2d83
--- /dev/null
+++ b/apps/vscode/scripts/testing-platform-workos-fetch-mock.cjs
@@ -0,0 +1,56 @@
+// Preload used by the standalone testing platform.
+// It makes the SDK WorkOS device-auth flow deterministic and fully local while
+// leaving production auth code on the same device-auth path used by users.
+
+const originalFetch = globalThis.fetch?.bind(globalThis)
+
+const WORKOS_ORIGIN = "https://api.workos.com"
+const DEVICE_CODE = "test-device-code"
+const USER_CODE = "PTBC-TXTP"
+const ACCESS_TOKEN = "test-personal-token"
+const REFRESH_TOKEN = "test-personal-token_refresh"
+
+function jsonResponse(body, init = {}) {
+	return new Response(JSON.stringify(body), {
+		status: init.status ?? 200,
+		headers: { "Content-Type": "application/json", ...(init.headers ?? {}) },
+	})
+}
+
+function inputUrl(input) {
+	if (typeof input === "string") return input
+	if (input instanceof URL) return input.toString()
+	if (input && typeof input === "object" && "url" in input) return input.url
+	return String(input)
+}
+
+globalThis.fetch = async (input, init) => {
+	const urlString = inputUrl(input)
+	let url
+	try {
+		url = new URL(urlString)
+	} catch {
+		return originalFetch(input, init)
+	}
+
+	if (url.origin === WORKOS_ORIGIN && url.pathname === "/user_management/authorize/device") {
+		return jsonResponse({
+			device_code: DEVICE_CODE,
+			user_code: USER_CODE,
+			verification_uri: "https://login.workos.test/device",
+			verification_uri_complete: `https://login.workos.test/device?user_code=${USER_CODE}`,
+			expires_in: 300,
+			interval: 1,
+		})
+	}
+
+	if (url.origin === WORKOS_ORIGIN && url.pathname === "/user_management/authenticate") {
+		return jsonResponse({
+			access_token: ACCESS_TOKEN,
+			refresh_token: REFRESH_TOKEN,
+			token_type: "Bearer",
+		})
+	}
+
+	return originalFetch(input, init)
+}
diff --git a/apps/vscode/skills-lock.json b/apps/vscode/skills-lock.json
new file mode 100644
index 0000000..f46e11f
--- /dev/null
+++ b/apps/vscode/skills-lock.json
@@ -0,0 +1,11 @@
+{
+	"version": 1,
+	"skills": {
+		"cline-sdk": {
+			"source": "cline/sdk-skill",
+			"sourceType": "github",
+			"skillPath": "skill/cline-sdk/SKILL.md",
+			"computedHash": "ce565d78d5bd1c40075248a3a925b2059c5c024bfcdbbf1f55bf3440cae34144"
+		}
+	}
+}
diff --git a/apps/vscode/src/__tests__/config.test.ts b/apps/vscode/src/__tests__/config.test.ts
new file mode 100644
index 0000000..4494016
--- /dev/null
+++ b/apps/vscode/src/__tests__/config.test.ts
@@ -0,0 +1,705 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import * as actualOs from "os"
+import path from "path"
+import sinon from "sinon"
+
+// The SUT does `import * as os from "os"; os.homedir()`. Under bun, sinon's
+// `stub(os, "homedir")` on the test's own `os` binding does NOT propagate to the
+// SUT's namespace import, so inject a module-level homedir stub via mock.module
+// (the rest of `os` — tmpdir() etc. — keeps its real behavior).
+const homedirStub = sinon.stub()
+const osMockNamespace = { ...actualOs, homedir: homedirStub }
+const osMock = () => ({ ...osMockNamespace, default: osMockNamespace })
+mock.module("os", osMock)
+mock.module("node:os", osMock)
+
+import os from "os"
+import { ClineConfigurationError, ClineEndpoint, ClineEnv, Environment } from "../config"
+
+describe("ClineEndpoint configuration", () => {
+	let sandbox: sinon.SinonSandbox
+	let tempDir: string
+	let originalHomedir: typeof os.homedir
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+		tempDir = path.join(os.tmpdir(), `config-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir, { recursive: true })
+
+		// Create .cline directory
+		await fs.mkdir(path.join(tempDir, ".cline"), { recursive: true })
+
+		// Stub os.homedir to return our temp directory (via mock.module homedirStub)
+		originalHomedir = os.homedir
+		homedirStub.reset()
+		homedirStub.returns(tempDir)
+
+		// Reset the singleton state using internal method
+		;(ClineEndpoint as any)._instance = null
+		;(ClineEndpoint as any)._initialized = false
+		;(ClineEndpoint as any)._extensionFsPath = undefined
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+		// Reset singleton state
+		;(ClineEndpoint as any)._instance = null
+		;(ClineEndpoint as any)._initialized = false
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	describe("valid config parsing", () => {
+		it("should parse valid endpoints.json with all required fields", async () => {
+			const validConfig = {
+				appBaseUrl: "https://app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(validConfig), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("https://app.enterprise.com")
+			config.apiBaseUrl.should.equal("https://api.enterprise.com")
+			config.mcpBaseUrl.should.equal("https://mcp.enterprise.com")
+			config.environment.should.equal(Environment.selfHosted)
+		})
+
+		it("should work without endpoints.json (standard mode)", async () => {
+			// No endpoints.json file exists
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const config = ClineEndpoint.config
+			config.environment.should.not.equal(Environment.selfHosted)
+			// Should use production defaults
+			config.appBaseUrl.should.equal("https://app.cline.bot")
+			config.apiBaseUrl.should.equal("https://api.cline.bot")
+		})
+
+		it("should accept URLs with ports", async () => {
+			const validConfig = {
+				appBaseUrl: "http://localhost:3000",
+				apiBaseUrl: "http://localhost:7777",
+				mcpBaseUrl: "http://localhost:8080/mcp",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(validConfig), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("http://localhost:3000")
+			config.apiBaseUrl.should.equal("http://localhost:7777")
+			config.mcpBaseUrl.should.equal("http://localhost:8080/mcp")
+		})
+
+		it("should accept URLs with paths", async () => {
+			const validConfig = {
+				appBaseUrl: "https://proxy.enterprise.com/cline/app",
+				apiBaseUrl: "https://proxy.enterprise.com/cline/api",
+				mcpBaseUrl: "https://proxy.enterprise.com/cline/mcp",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(validConfig), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("https://proxy.enterprise.com/cline/app")
+		})
+	})
+
+	describe("invalid JSON handling", () => {
+		it("should throw ClineConfigurationError for invalid JSON syntax", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), "{ invalid json }", "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("Invalid JSON")
+			}
+		})
+
+		it("should throw ClineConfigurationError for truncated JSON", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), '{"appBaseUrl": "https://test.com"', "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("Invalid JSON")
+			}
+		})
+
+		it("should throw ClineConfigurationError for empty file", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), "", "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+			}
+		})
+
+		it("should throw ClineConfigurationError for non-object JSON", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), '"just a string"', "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must contain a JSON object")
+			}
+		})
+
+		it("should throw ClineConfigurationError for array JSON", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), "[]", "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				// Arrays pass the object check but fail on required fields
+				error.message.should.containEql("Missing required field")
+			}
+		})
+
+		it("should throw ClineConfigurationError for null JSON", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), "null", "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must contain a JSON object")
+			}
+		})
+	})
+
+	describe("missing required fields", () => {
+		it("should throw ClineConfigurationError when appBaseUrl is missing", async () => {
+			const config = {
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql('Missing required field "appBaseUrl"')
+			}
+		})
+
+		it("should throw ClineConfigurationError when apiBaseUrl is missing", async () => {
+			const config = {
+				appBaseUrl: "https://app.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql('Missing required field "apiBaseUrl"')
+			}
+		})
+
+		it("should throw ClineConfigurationError when mcpBaseUrl is missing", async () => {
+			const config = {
+				appBaseUrl: "https://app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql('Missing required field "mcpBaseUrl"')
+			}
+		})
+
+		it("should throw ClineConfigurationError when all fields are missing", async () => {
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), "{}", "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("Missing required field")
+			}
+		})
+
+		it("should throw ClineConfigurationError when field is null", async () => {
+			const config = {
+				appBaseUrl: null,
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql('Missing required field "appBaseUrl"')
+			}
+		})
+
+		it("should throw ClineConfigurationError when field is empty string", async () => {
+			const config = {
+				appBaseUrl: "",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("cannot be empty")
+			}
+		})
+
+		it("should throw ClineConfigurationError when field is whitespace only", async () => {
+			const config = {
+				appBaseUrl: "   ",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("cannot be empty")
+			}
+		})
+
+		it("should throw ClineConfigurationError when field is non-string", async () => {
+			const config = {
+				appBaseUrl: 12345,
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must be a string")
+			}
+		})
+	})
+
+	describe("invalid URL detection", () => {
+		it("should throw ClineConfigurationError for invalid URL format", async () => {
+			const config = {
+				appBaseUrl: "not-a-valid-url",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must be a valid URL")
+			}
+		})
+
+		it("should throw ClineConfigurationError for URL without protocol", async () => {
+			const config = {
+				appBaseUrl: "app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must be a valid URL")
+			}
+		})
+
+		it("should throw ClineConfigurationError for malformed URL", async () => {
+			const config = {
+				appBaseUrl: "https://",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must be a valid URL")
+			}
+		})
+
+		it("should include the invalid URL value in error message", async () => {
+			const invalidUrl = "definitely-not-a-url"
+			const config = {
+				appBaseUrl: invalidUrl,
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(tempDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql(invalidUrl)
+			}
+		})
+	})
+
+	describe("environment switching blocked in self-hosted mode", () => {
+		it("should throw error when trying to change environment in self-hosted mode", async () => {
+			const config = {
+				appBaseUrl: "https://app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			// Verify we're in self-hosted mode
+			ClineEndpoint.config.environment.should.equal(Environment.selfHosted)
+
+			// Try to change environment - should throw
+			try {
+				ClineEnv.setEnvironment("staging")
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.containEql("Cannot change environment in on-premise mode")
+			}
+		})
+
+		it("should throw error for all environment values in self-hosted mode", async () => {
+			const config = {
+				appBaseUrl: "https://app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const environments = ["staging", "local", "production", "anything"]
+			for (const env of environments) {
+				try {
+					ClineEnv.setEnvironment(env)
+					throw new Error(`Should have thrown for environment: ${env}`)
+				} catch (error: any) {
+					error.message.should.containEql("Cannot change environment in on-premise mode")
+				}
+			}
+		})
+
+		it("should allow environment switching in standard mode", async () => {
+			// No endpoints.json file - standard mode
+
+			await ClineEndpoint.initialize(tempDir)
+
+			// Verify we're NOT in self-hosted mode
+			ClineEndpoint.config.environment.should.not.equal(Environment.selfHosted)
+
+			// Should be able to change environment
+			ClineEnv.setEnvironment("staging")
+			ClineEnv.getEnvironment().environment.should.equal("staging")
+
+			ClineEnv.setEnvironment("local")
+			ClineEnv.getEnvironment().environment.should.equal("local")
+
+			ClineEnv.setEnvironment("production")
+			ClineEnv.getEnvironment().environment.should.equal("production")
+		})
+	})
+
+	describe("self-hosted mode behavior", () => {
+		it("should report selfHosted environment in self-hosted mode", async () => {
+			const config = {
+				appBaseUrl: "https://app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const envConfig = ClineEndpoint.config
+			envConfig.environment.should.equal(Environment.selfHosted)
+		})
+
+		it("should use custom endpoints from file", async () => {
+			const customConfig = {
+				appBaseUrl: "https://custom-app.internal",
+				apiBaseUrl: "https://custom-api.internal",
+				mcpBaseUrl: "https://custom-mcp.internal/v1",
+			}
+
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(customConfig), "utf8")
+
+			await ClineEndpoint.initialize(tempDir)
+
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("https://custom-app.internal")
+			config.apiBaseUrl.should.equal("https://custom-api.internal")
+			config.mcpBaseUrl.should.equal("https://custom-mcp.internal/v1")
+		})
+	})
+
+	describe("initialization behavior", () => {
+		it("should only initialize once", async () => {
+			await ClineEndpoint.initialize(tempDir)
+			ClineEndpoint.isInitialized().should.be.true()
+
+			// Second initialize should be a no-op
+			await ClineEndpoint.initialize(tempDir)
+			ClineEndpoint.isInitialized().should.be.true()
+		})
+
+		it("should throw error when accessing config before initialization", async () => {
+			// Already reset in beforeEach, so accessing should throw
+			try {
+				const _ = ClineEndpoint.config
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.containEql("not initialized")
+			}
+		})
+	})
+
+	describe("isSelfHosted() method", () => {
+		it("should return true when not initialized (safety fallback)", async () => {
+			// Reset singleton state - already done in beforeEach, not initialized
+			ClineEndpoint.isInitialized().should.be.false()
+			ClineEndpoint.isSelfHosted().should.be.true()
+		})
+
+		it("should return true when in self-hosted mode", async () => {
+			const config = {
+				appBaseUrl: "https://app.enterprise.com",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(config), "utf8")
+			await ClineEndpoint.initialize(tempDir)
+
+			ClineEndpoint.isSelfHosted().should.be.true()
+		})
+
+		it("should return false when in normal mode (no endpoints.json)", async () => {
+			// No endpoints.json file exists
+			await ClineEndpoint.initialize(tempDir)
+
+			ClineEndpoint.isSelfHosted().should.be.false()
+		})
+	})
+
+	describe("bundled endpoints.json behavior", () => {
+		let bundledDir: string
+		let setVscodeHostProviderMock: (mock: { extensionFsPath: string; globalStorageFsPath: string }) => void
+
+		beforeEach(async () => {
+			// Create a separate directory for bundled config
+			bundledDir = path.join(os.tmpdir(), `config-bundled-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+			await fs.mkdir(bundledDir, { recursive: true })
+
+			// Import HostProvider utilities
+			const hostProviderModule = await import("../test/host-provider-test-utils")
+			setVscodeHostProviderMock = hostProviderModule.setVscodeHostProviderMock
+		})
+
+		afterEach(async () => {
+			try {
+				await fs.rm(bundledDir, { recursive: true, force: true })
+			} catch {
+				// Ignore cleanup errors
+			}
+		})
+
+		it("should use bundled endpoints.json when available", async () => {
+			const bundledConfig = {
+				appBaseUrl: "https://bundled.enterprise.com",
+				apiBaseUrl: "https://bundled-api.enterprise.com",
+				mcpBaseUrl: "https://bundled-mcp.enterprise.com",
+			}
+
+			// Set up bundled config
+			await fs.writeFile(path.join(bundledDir, "endpoints.json"), JSON.stringify(bundledConfig), "utf8")
+
+			await ClineEndpoint.initialize(bundledDir)
+
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("https://bundled.enterprise.com")
+			config.apiBaseUrl.should.equal("https://bundled-api.enterprise.com")
+			config.mcpBaseUrl.should.equal("https://bundled-mcp.enterprise.com")
+			config.environment.should.equal(Environment.selfHosted)
+		})
+
+		it("should prefer bundled endpoints.json over user file", async () => {
+			const bundledConfig = {
+				appBaseUrl: "https://bundled.enterprise.com",
+				apiBaseUrl: "https://bundled-api.enterprise.com",
+				mcpBaseUrl: "https://bundled-mcp.enterprise.com",
+			}
+
+			const userConfig = {
+				appBaseUrl: "https://user.enterprise.com",
+				apiBaseUrl: "https://user-api.enterprise.com",
+				mcpBaseUrl: "https://user-mcp.enterprise.com",
+			}
+
+			// Set up both configs
+			await fs.writeFile(path.join(bundledDir, "endpoints.json"), JSON.stringify(bundledConfig), "utf8")
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(userConfig), "utf8")
+
+			await ClineEndpoint.initialize(bundledDir)
+
+			// Should use bundled config, not user config
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("https://bundled.enterprise.com")
+			config.apiBaseUrl.should.equal("https://bundled-api.enterprise.com")
+			config.mcpBaseUrl.should.equal("https://bundled-mcp.enterprise.com")
+		})
+
+		it("should fall back to user endpoints.json when bundled is not present", async () => {
+			const userConfig = {
+				appBaseUrl: "https://user.enterprise.com",
+				apiBaseUrl: "https://user-api.enterprise.com",
+				mcpBaseUrl: "https://user-mcp.enterprise.com",
+			}
+
+			// Only create user config, no bundled config
+			await fs.writeFile(path.join(tempDir, ".cline", "endpoints.json"), JSON.stringify(userConfig), "utf8")
+
+			await ClineEndpoint.initialize(bundledDir)
+
+			// Should use user config
+			const config = ClineEndpoint.config
+			config.appBaseUrl.should.equal("https://user.enterprise.com")
+			config.apiBaseUrl.should.equal("https://user-api.enterprise.com")
+			config.mcpBaseUrl.should.equal("https://user-mcp.enterprise.com")
+		})
+
+		it("should use standard mode when neither bundled nor user file exists", async () => {
+			// No config files at all
+
+			await ClineEndpoint.initialize(bundledDir)
+
+			// Should use production defaults
+			const config = ClineEndpoint.config
+			config.environment.should.not.equal(Environment.selfHosted)
+			config.appBaseUrl.should.equal("https://app.cline.bot")
+			config.apiBaseUrl.should.equal("https://api.cline.bot")
+		})
+
+		it("should throw ClineConfigurationError for invalid bundled file", async () => {
+			const invalidConfig = {
+				appBaseUrl: "not-a-url",
+				apiBaseUrl: "https://api.enterprise.com",
+				mcpBaseUrl: "https://mcp.enterprise.com",
+			}
+
+			// Set up invalid bundled config
+			await fs.writeFile(path.join(bundledDir, "endpoints.json"), JSON.stringify(invalidConfig), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(bundledDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("must be a valid URL")
+				error.message.should.containEql("bundled")
+			}
+		})
+
+		it("should throw ClineConfigurationError for invalid JSON in bundled file", async () => {
+			// Set up invalid JSON in bundled file
+			await fs.writeFile(path.join(bundledDir, "endpoints.json"), "{ invalid json }", "utf8")
+
+			try {
+				await ClineEndpoint.initialize(bundledDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("Invalid JSON")
+				error.message.should.containEql("bundled")
+			}
+		})
+
+		it("should indicate bundled source in error messages", async () => {
+			const incompleteConfig = {
+				appBaseUrl: "https://bundled.enterprise.com",
+				// Missing apiBaseUrl and mcpBaseUrl
+			}
+
+			await fs.writeFile(path.join(bundledDir, "endpoints.json"), JSON.stringify(incompleteConfig), "utf8")
+
+			try {
+				await ClineEndpoint.initialize(bundledDir)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.should.be.instanceof(ClineConfigurationError)
+				error.message.should.containEql("Missing required field")
+				error.message.should.containEql(path.join(bundledDir, "endpoints.json"))
+			}
+		})
+	})
+})
diff --git a/apps/vscode/src/common.ts b/apps/vscode/src/common.ts
new file mode 100644
index 0000000..fd9c4e7
--- /dev/null
+++ b/apps/vscode/src/common.ts
@@ -0,0 +1,192 @@
+import { WebviewProvider } from "./core/webview"
+import "./utils/path" // necessary to have access to String.prototype.toPosix
+
+import { setSdkLogger } from "@cline/core"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import type { StorageContext } from "@/shared/storage/storage-context"
+import { clearOnboardingModelsCache } from "./core/controller/models/getClineOnboardingModels"
+import { HookDiscoveryCache } from "./core/hooks/HookDiscoveryCache"
+import { HookProcessRegistry } from "./core/hooks/HookProcessRegistry"
+import { StateManager } from "./core/storage/StateManager"
+import { AgentConfigLoader } from "./core/task/tools/subagent/AgentConfigLoader"
+import { ExtensionRegistryInfo } from "./registry"
+import { registerVsCodeLmHandler } from "./sdk/vscode-lm/register-vscode-lm"
+import { ErrorService } from "./services/error"
+import { featureFlagsService } from "./services/feature-flags"
+import { getDistinctId } from "./services/logging/distinctId"
+import { telemetryService } from "./services/telemetry"
+import { PostHogClientProvider } from "./services/telemetry/providers/posthog/PostHogClientProvider"
+import { ClineTempManager } from "./services/temp"
+import { ShowMessageType } from "./shared/proto/host/window"
+import { syncWorker } from "./shared/services/worker/sync"
+import { getBlobStoreSettingsFromEnv } from "./shared/services/worker/worker"
+import { getLatestAnnouncementId } from "./utils/announcements"
+import { arePathsEqual } from "./utils/path"
+
+/**
+ * Performs intialization for Cline that is common to all platforms.
+ *
+ * @param context
+ * @returns The webview provider
+ * @throws ClineConfigurationError if endpoints.json exists but is invalid
+ */
+export async function initialize(storageContext: StorageContext): Promise<WebviewProvider> {
+	// Configure the shared Logging class to use HostProvider's output channels and debug logger
+	Logger.subscribe((msg: string) => HostProvider.get().logToChannel(msg)) // File system logging
+	Logger.subscribe((msg: string) => HostProvider.env.debugLog({ value: msg })) // Host debug logging
+
+	// Register the SDK early logger so diagnostic events from
+	// ProviderSettingsManager, RuntimeOAuthTokenManager, and Cline auth
+	// flow through Logger.debug → Cline output channel.
+	// These components operate before/outside of ClineCore sessions, so the
+	// session-scoped logger can't reach them.
+	setSdkLogger({
+		debug: (message) => Logger.debug(message),
+		log: (message) => Logger.log(message),
+		error: (message) => Logger.error(message),
+	})
+
+	// Initialize ClineEndpoint configuration (reads bundled and ~/.cline/endpoints.json if present)
+	// This must be done before any other code that calls ClineEnv.config()
+	// Throws ClineConfigurationError if config file exists but is invalid
+	const { ClineEndpoint } = await import("./config")
+	await ClineEndpoint.initialize(HostProvider.get().extensionFsPath)
+
+	try {
+		await StateManager.initialize(storageContext)
+	} catch (error) {
+		Logger.error("[Cline] CRITICAL: Failed to initialize StateManager:", error)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: "Failed to initialize storage. Please check logs for details or try restarting the client.",
+		})
+	}
+
+	// Register host-only SDK provider handlers (e.g. VS Code Language Model API),
+	// which depend on the `vscode` module and cannot live in the SDK package.
+	// Must run before any handler is built (standalone utilities or task loop).
+	registerVsCodeLmHandler()
+
+	// =============== External services ===============
+	await ErrorService.initialize()
+	// Initialize PostHog client provider (skip in self-hosted mode)
+	if (!ClineEndpoint.isSelfHosted()) {
+		PostHogClientProvider.getInstance()
+	}
+
+	// =============== Webview services ===============
+	const webview = HostProvider.get().createWebviewProvider()
+
+	const stateManager = StateManager.get()
+	// Non-blocking announcement check and display
+	showVersionUpdateAnnouncement(stateManager)
+	// Check if this workspace was opened from worktree quick launch
+	await checkWorktreeAutoOpen(stateManager)
+
+	// =============== Background sync and cleanup tasks ===============
+	// Use remote config blobStoreConfig if available, otherwise fall back to env vars
+	const blobStoreSettings = stateManager.getRemoteConfigSettings()?.blobStoreConfig ?? getBlobStoreSettingsFromEnv()
+	syncWorker().init({ ...blobStoreSettings, userDistinctId: getDistinctId() })
+	// Clean up old temp files in background (non-blocking) and start periodic cleanup every 24 hours
+	ClineTempManager.startPeriodicCleanup()
+
+	telemetryService.captureExtensionActivated()
+
+	return webview
+}
+
+async function showVersionUpdateAnnouncement(stateManager: StateManager) {
+	// Version checking for autoupdate notification
+	const currentVersion = ExtensionRegistryInfo.version
+	const previousVersion = stateManager.getGlobalStateKey("clineVersion")
+	// Perform post-update actions if necessary
+	try {
+		if (!previousVersion || currentVersion !== previousVersion) {
+			Logger.log(`Cline version changed: ${previousVersion} -> ${currentVersion}. First run or update detected.`)
+
+			// Check if there's a new announcement to show
+			const lastShownAnnouncementId = stateManager.getGlobalStateKey("lastShownAnnouncementId")
+			const latestAnnouncementId = getLatestAnnouncementId()
+
+			if (lastShownAnnouncementId !== latestAnnouncementId) {
+				// Show notification when there's a new announcement (major/minor updates or fresh installs)
+				const message = previousVersion
+					? `Cline has been updated to v${currentVersion}`
+					: `Welcome to Cline v${currentVersion}`
+				HostProvider.window.showMessage({
+					type: ShowMessageType.INFORMATION,
+					message,
+				})
+			}
+			// Always update the main version tracker for the next launch.
+			stateManager.setGlobalState("clineVersion", currentVersion)
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		Logger.error(`Error during post-update actions: ${errorMessage}, Stack trace: ${error.stack}`)
+	}
+}
+
+/**
+ * Checks if this workspace was opened from the worktree quick launch button.
+ * If so, opens the Cline sidebar and clears the state.
+ */
+async function checkWorktreeAutoOpen(stateManager: StateManager): Promise<void> {
+	try {
+		// Read directly from globalState (not StateManager cache) since this may have been
+		// set by another window right before this one opened
+		const worktreeAutoOpenPath = stateManager.getGlobalStateKey("worktreeAutoOpenPath")
+		if (!worktreeAutoOpenPath) {
+			return
+		}
+
+		// Get current workspace path
+		const workspacePaths = (await HostProvider.workspace.getWorkspacePaths({})).paths
+		if (workspacePaths.length === 0) {
+			return
+		}
+
+		const currentPath = workspacePaths[0]
+
+		// Check if current workspace matches the worktree path
+		if (arePathsEqual(currentPath, worktreeAutoOpenPath)) {
+			// Clear the state first to prevent re-triggering
+			stateManager.setGlobalState("worktreeAutoOpenPath", undefined)
+			// Open the Cline sidebar
+			await HostProvider.workspace.openClineSidebarPanel({})
+		}
+	} catch (error) {
+		Logger.error("Error checking worktree auto-open", error)
+	}
+}
+
+/**
+ * Performs cleanup when Cline is deactivated that is common to all platforms.
+ */
+export async function tearDown(): Promise<void> {
+	try {
+		AgentConfigLoader.getInstance()?.dispose()
+		PostHogClientProvider.getInstance().dispose()
+		telemetryService.dispose()
+		ErrorService.get().dispose()
+		featureFlagsService.dispose()
+		// Dispose all webview instances
+		await WebviewProvider.disposeAllInstances()
+		syncWorker().dispose()
+		clearOnboardingModelsCache()
+
+		// Kill any running hook processes to prevent zombies
+		await HookProcessRegistry.terminateAll()
+		// Clean up hook discovery cache
+		HookDiscoveryCache.getInstance().dispose()
+		// Stop periodic temp file cleanup
+		ClineTempManager.stopPeriodicCleanup()
+	} finally {
+		try {
+			await StateManager.get().flushPendingState()
+		} catch (error) {
+			Logger.error("[Cline] Failed to flush pending state during teardown:", error)
+		}
+	}
+}
diff --git a/apps/vscode/src/config.ts b/apps/vscode/src/config.ts
new file mode 100644
index 0000000..69e8413
--- /dev/null
+++ b/apps/vscode/src/config.ts
@@ -0,0 +1,349 @@
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import { Environment, type EnvironmentConfig } from "./shared/config-types"
+import { Logger } from "./shared/services/Logger"
+
+export { Environment } /**
+ * Schema for the endpoints.json configuration file used in on-premise deployments.
+ * All fields are required and must be valid URLs.
+ */
+
+interface EndpointsFileSchema {
+	appBaseUrl: string
+	apiBaseUrl: string
+	mcpBaseUrl: string
+}
+
+/**
+ * Error thrown when the Cline configuration file exists but is invalid.
+ * This error prevents Cline from starting to avoid misconfiguration in enterprise environments.
+ */
+export class ClineConfigurationError extends Error {
+	constructor(message: string) {
+		super(message)
+		this.name = "ClineConfigurationError"
+	}
+}
+
+class ClineEndpoint {
+	private static _instance: ClineEndpoint | null = null
+	private static _initialized = false
+	private static _extensionFsPath: string
+
+	// On-premise config loaded from file (null if not on-premise)
+	private onPremiseConfig: EndpointsFileSchema | null = null
+	private environment: Environment = Environment.production
+	// Track if config came from bundled file (enterprise distribution)
+	private isBundled = false
+
+	private constructor() {
+		// Set environment at module load. Use override if provided.
+		const _env = process?.env?.CLINE_ENVIRONMENT_OVERRIDE || process?.env?.CLINE_ENVIRONMENT
+		if (_env && Object.values(Environment).includes(_env as Environment)) {
+			this.environment = _env as Environment
+		}
+	}
+
+	/**
+	 * Initializes the ClineEndpoint singleton.
+	 * Must be called before any other methods.
+	 * Reads the endpoints.json file if it exists and validates its schema.
+	 *
+	 * @param extensionFsPath Path to the extension installation directory (for checking bundled endpoints.json)
+	 * @throws ClineConfigurationError if the endpoints.json file exists but is invalid
+	 */
+	public static async initialize(extensionFsPath: string): Promise<void> {
+		if (ClineEndpoint._initialized) {
+			return
+		}
+
+		ClineEndpoint._extensionFsPath = extensionFsPath
+		ClineEndpoint._instance = new ClineEndpoint()
+
+		// Try to load on-premise config from file
+		const endpointsConfig = await ClineEndpoint.loadEndpointsFile()
+		if (endpointsConfig) {
+			ClineEndpoint._instance.onPremiseConfig = endpointsConfig
+			Logger.log("Cline running in self-hosted mode with custom endpoints")
+		}
+
+		ClineEndpoint._initialized = true
+	}
+
+	/**
+	 * Returns true if the ClineEndpoint has been initialized.
+	 */
+	public static isInitialized(): boolean {
+		return ClineEndpoint._initialized
+	}
+
+	/**
+	 * Checks if Cline is running in self-hosted/on-premise mode.
+	 * @returns true if in selfHosted mode, or true if not initialized (safety fallback to prevent accidental external calls)
+	 */
+	public static isSelfHosted(): boolean {
+		// Safety fallback: if not initialized, treat as selfHosted
+		// to prevent accidental external service calls before configuration is loaded
+		if (!ClineEndpoint._initialized) {
+			return true
+		}
+		return ClineEndpoint.config.environment === Environment.selfHosted
+	}
+
+	/**
+	 * Returns true if the current configuration was loaded from a bundled endpoints.json file.
+	 * This indicates an enterprise distribution that should not auto-update.
+	 * @throws Error if not initialized
+	 */
+	public static isBundledConfig(): boolean {
+		if (!ClineEndpoint._initialized || !ClineEndpoint._instance) {
+			throw new Error("ClineEndpoint not initialized. Call ClineEndpoint.initialize() first.")
+		}
+		return ClineEndpoint._instance.isBundled
+	}
+
+	/**
+	 * Returns the singleton instance.
+	 * @throws Error if not initialized
+	 */
+	public static get instance(): ClineEndpoint {
+		if (!ClineEndpoint._initialized || !ClineEndpoint._instance) {
+			throw new Error("ClineEndpoint not initialized. Call ClineEndpoint.initialize() first.")
+		}
+		return ClineEndpoint._instance
+	}
+
+	/**
+	 * Static getter for convenient access to the current configuration.
+	 * @throws Error if not initialized
+	 */
+	public static get config(): EnvironmentConfig {
+		return ClineEndpoint.instance.config()
+	}
+
+	/**
+	 * Returns the path to the endpoints.json configuration file.
+	 * Located at ~/.cline/endpoints.json
+	 */
+	private static getEndpointsFilePath(): string {
+		return path.join(os.homedir(), ".cline", "endpoints.json")
+	}
+
+	/**
+	 * Returns the path to the bundled endpoints.json configuration file.
+	 * Located in the extension installation directory.
+	 */
+	private static getBundledEndpointsFilePath(): string {
+		return path.join(ClineEndpoint._extensionFsPath, "endpoints.json")
+	}
+
+	/**
+	 * Loads and validates the endpoints.json file.
+	 * Checks bundled location first, then falls back to user directory.
+	 * Priority: bundled endpoints.json → ~/.cline/endpoints.json → null (standard mode)
+	 * @returns The validated endpoints config, or null if no file exists
+	 * @throws ClineConfigurationError if a file exists but is invalid
+	 */
+	private static async loadEndpointsFile(): Promise<EndpointsFileSchema | null> {
+		// 1. Try bundled file
+		const bundledPath = ClineEndpoint.getBundledEndpointsFilePath()
+		try {
+			await fs.access(bundledPath)
+			// File exists, load and validate it
+			const fileContent = await fs.readFile(bundledPath, "utf8")
+			let data: unknown
+
+			try {
+				data = JSON.parse(fileContent)
+			} catch (parseError) {
+				throw new ClineConfigurationError(
+					`Invalid JSON in bundled endpoints configuration file (${bundledPath}): ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+				)
+			}
+
+			const config = ClineEndpoint.validateEndpointsSchema(data, bundledPath)
+			// Mark as bundled enterprise distribution
+			ClineEndpoint._instance!.isBundled = true
+			return config
+		} catch (error) {
+			if (error instanceof ClineConfigurationError) {
+				throw error
+			}
+			// Bundled file doesn't exist or is not accessible, try user file
+		}
+
+		// 2. Try ~/.cline/endpoints.json
+		const userPath = ClineEndpoint.getEndpointsFilePath()
+		try {
+			await fs.access(userPath)
+		} catch {
+			// File doesn't exist - not on-premise mode
+			return null
+		}
+
+		// File exists, must be valid or we fail
+		try {
+			const fileContent = await fs.readFile(userPath, "utf8")
+			let data: unknown
+
+			try {
+				data = JSON.parse(fileContent)
+			} catch (parseError) {
+				throw new ClineConfigurationError(
+					`Invalid JSON in user endpoints configuration file (${userPath}): ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+				)
+			}
+
+			return ClineEndpoint.validateEndpointsSchema(data, userPath)
+		} catch (error) {
+			if (error instanceof ClineConfigurationError) {
+				throw error
+			}
+			throw new ClineConfigurationError(
+				`Failed to read user endpoints configuration file (${userPath}): ${error instanceof Error ? error.message : String(error)}`,
+			)
+		}
+	}
+
+	/**
+	 * Validates that the provided data matches the EndpointsFileSchema.
+	 * All fields must be present and be valid URLs.
+	 *
+	 * @param data The parsed JSON data to validate
+	 * @param filePath The path to the file (for error messages)
+	 * @returns The validated EndpointsFileSchema
+	 * @throws ClineConfigurationError if validation fails
+	 */
+	private static validateEndpointsSchema(data: unknown, filePath: string): EndpointsFileSchema {
+		if (typeof data !== "object" || data === null) {
+			throw new ClineConfigurationError(`Endpoints configuration file (${filePath}) must contain a JSON object`)
+		}
+
+		const obj = data as Record<string, unknown>
+		const requiredFields = ["appBaseUrl", "apiBaseUrl", "mcpBaseUrl"] as const
+		const result: Partial<EndpointsFileSchema> = {}
+
+		for (const field of requiredFields) {
+			const value = obj[field]
+
+			if (value === undefined || value === null) {
+				throw new ClineConfigurationError(
+					`Missing required field "${field}" in endpoints configuration file (${filePath})`,
+				)
+			}
+
+			if (typeof value !== "string") {
+				throw new ClineConfigurationError(
+					`Field "${field}" in endpoints configuration file (${filePath}) must be a string`,
+				)
+			}
+
+			if (!value.trim()) {
+				throw new ClineConfigurationError(
+					`Field "${field}" in endpoints configuration file (${filePath}) cannot be empty`,
+				)
+			}
+
+			// Validate URL format
+			try {
+				new URL(value)
+			} catch {
+				throw new ClineConfigurationError(
+					`Field "${field}" in endpoints configuration file (${filePath}) must be a valid URL. Got: "${value}"`,
+				)
+			}
+
+			result[field] = value
+		}
+
+		return result as EndpointsFileSchema
+	}
+
+	/**
+	 * Returns the current environment configuration.
+	 */
+	public config(): EnvironmentConfig {
+		return this.getEnvironment()
+	}
+
+	/**
+	 * Sets the current environment.
+	 * @throws Error if in on-premise mode (environment switching is disabled)
+	 */
+	public setEnvironment(env: string) {
+		if (this.onPremiseConfig) {
+			throw new Error("Cannot change environment in on-premise mode. Endpoints are configured via ~/.cline/endpoints.json")
+		}
+
+		switch (env.toLowerCase()) {
+			case "staging":
+				this.environment = Environment.staging
+				break
+			case "local":
+				this.environment = Environment.local
+				break
+			default:
+				this.environment = Environment.production
+				break
+		}
+	}
+
+	/**
+	 * Returns the current environment configuration.
+	 * If running in on-premise mode, returns the custom endpoints.
+	 */
+	public getEnvironment(): EnvironmentConfig {
+		// On-premise mode: use custom endpoints from file
+		if (this.onPremiseConfig) {
+			return {
+				environment: Environment.selfHosted,
+				appBaseUrl: this.onPremiseConfig.appBaseUrl,
+				apiBaseUrl: this.onPremiseConfig.apiBaseUrl,
+				mcpBaseUrl: this.onPremiseConfig.mcpBaseUrl,
+			}
+		}
+
+		// Standard mode: use built-in environment URLs
+		switch (this.environment) {
+			case Environment.staging:
+				return {
+					environment: Environment.staging,
+					appBaseUrl: "https://staging-app.cline.bot",
+					apiBaseUrl: "https://core-api.staging.int.cline.bot",
+					mcpBaseUrl: "https://core-api.staging.int.cline.bot/v1/mcp",
+				}
+			case Environment.local:
+				return {
+					environment: Environment.local,
+					appBaseUrl: "http://localhost:3000",
+					apiBaseUrl: "http://localhost:7777",
+					mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+				}
+			default:
+				return {
+					environment: Environment.production,
+					appBaseUrl: "https://app.cline.bot",
+					apiBaseUrl: "https://api.cline.bot",
+					mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+				}
+		}
+	}
+}
+
+/**
+ * Singleton instance to access the current environment configuration.
+ * Usage:
+ * - ClineEnv.config() to get the current config.
+ * - ClineEnv.setEnvironment(Environment.local) to change the environment.
+ *
+ * IMPORTANT: ClineEndpoint.initialize() must be called before using ClineEnv.
+ */
+export const ClineEnv = {
+	config: () => ClineEndpoint.config,
+	setEnvironment: (env: string) => ClineEndpoint.instance.setEnvironment(env),
+	getEnvironment: () => ClineEndpoint.instance.getEnvironment(),
+}
+
+// Export the class for initialization
+export { ClineEndpoint }
diff --git a/apps/vscode/src/core/README.md b/apps/vscode/src/core/README.md
new file mode 100644
index 0000000..f289696
--- /dev/null
+++ b/apps/vscode/src/core/README.md
@@ -0,0 +1,11 @@
+# Core Architecture
+
+Extension entry point (extension.ts) -> webview -> controller -> task
+
+```tree
+core/
+├── webview/      # Manages webview lifecycle
+├── controller/   # Handles webview messages and task management
+├── task/         # Executes API requests and tool operations
+└── ...           # Additional components to help with context, parsing user/assistant messages, etc.
+```
diff --git a/apps/vscode/src/core/api/index.ts b/apps/vscode/src/core/api/index.ts
new file mode 100644
index 0000000..5f13dcd
--- /dev/null
+++ b/apps/vscode/src/core/api/index.ts
@@ -0,0 +1,23 @@
+import { ModelInfo } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+
+// buildApiHandler now routes inference through the Cline SDK. It lives in
+// apps/vscode/src/sdk/sdk-api-handler.ts and callers import it directly from
+// there. It is deliberately NOT re-exported here: this barrel is imported
+// widely for *types* only, and re-exporting a value from the SDK module would
+// pull the entire SDK/session-factory runtime graph into every type importer
+// at module-eval time (which can break extension activation). Keep this file
+// types-only.
+
+export interface ApiHandlerModel {
+	id: string
+	info: ModelInfo
+	providerId?: string
+}
+
+export interface ApiProviderInfo {
+	providerId: string
+	model: ApiHandlerModel
+	mode: Mode
+	customPrompt?: string // "compact"
+}
diff --git a/apps/vscode/src/core/context/context-tracking/ContextTrackerTypes.ts b/apps/vscode/src/core/context/context-tracking/ContextTrackerTypes.ts
new file mode 100644
index 0000000..8bc3db7
--- /dev/null
+++ b/apps/vscode/src/core/context/context-tracking/ContextTrackerTypes.ts
@@ -0,0 +1,32 @@
+// Type definitions for FileContextTracker
+export interface FileMetadataEntry {
+	path: string
+	record_state: "active" | "stale"
+	record_source: "read_tool" | "user_edited" | "cline_edited" | "file_mentioned"
+	cline_read_date: number | null
+	cline_edit_date: number | null
+	user_edit_date?: number | null
+}
+
+interface ModelMetadataEntry {
+	ts: number
+	model_id: string
+	model_provider_id: string
+	mode: string
+}
+
+interface EnvironmentMetadataEntry {
+	ts: number
+	os_name: string
+	os_version: string
+	os_arch: string
+	host_name: string
+	host_version: string
+	cline_version: string
+}
+
+export interface TaskMetadata {
+	files_in_context: FileMetadataEntry[]
+	model_usage: ModelMetadataEntry[]
+	environment_history: EnvironmentMetadataEntry[]
+}
diff --git a/apps/vscode/src/core/context/context-tracking/FileContextTracker.test.ts b/apps/vscode/src/core/context/context-tracking/FileContextTracker.test.ts
new file mode 100644
index 0000000..127ffdb
--- /dev/null
+++ b/apps/vscode/src/core/context/context-tracking/FileContextTracker.test.ts
@@ -0,0 +1,263 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import * as actualDiskModule from "@core/storage/disk"
+import { expect } from "chai"
+import * as actualChokidar from "chokidar"
+import * as path from "path"
+import * as sinon from "sinon"
+import * as vscode from "vscode"
+import { Controller } from "@/core/controller"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+import type { FileMetadataEntry, TaskMetadata } from "./ContextTrackerTypes"
+
+// bun loads real ESM, so sinon cannot stub the `@core/storage/disk` and
+// `chokidar` namespace exports ("ES Modules cannot be stubbed"). Inject
+// module-level sinon stubs via mock.module so the full sinon stub API keeps
+// working. (`vscode` is the writable unit-test stub, still sinon-stubbed below.)
+const getTaskMetadataStub: sinon.SinonStub = sinon.stub()
+const saveTaskMetadataStub: sinon.SinonStub = sinon.stub()
+const chokidarWatchStub: sinon.SinonStub = sinon.stub()
+const diskMock = () => ({
+	...actualDiskModule,
+	getTaskMetadata: getTaskMetadataStub,
+	saveTaskMetadata: saveTaskMetadataStub,
+})
+const chokidarNamespace = { ...actualChokidar, watch: chokidarWatchStub }
+const chokidarMock = () => ({ ...chokidarNamespace, default: chokidarNamespace })
+mock.module("@core/storage/disk", diskMock)
+mock.module("@/core/storage/disk", diskMock)
+mock.module("chokidar", chokidarMock)
+
+import { FileContextTracker } from "./FileContextTracker"
+
+describe("FileContextTracker", () => {
+	const filePath = "src/test-file.ts"
+	const taskId = "test-task-id"
+
+	let sandbox: sinon.SinonSandbox
+	let _mockWorkspace: sinon.SinonStub
+	let mockFileSystemWatcher: any
+	let tracker: FileContextTracker
+	let mockTaskMetadata: TaskMetadata
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		// Mock vscode workspace
+		_mockWorkspace = sandbox.stub(vscode.workspace, "workspaceFolders").value([
+			{
+				uri: {
+					fsPath: "/mock/workspace",
+				},
+			} as vscode.WorkspaceFolder,
+		])
+
+		// Mock chokidar file watcher
+		mockFileSystemWatcher = {
+			close: sandbox.stub().resolves(),
+			on: sandbox.stub(),
+		}
+		// Return the watcher itself for chaining
+		mockFileSystemWatcher.on.returns(mockFileSystemWatcher)
+
+		// Reset the module-level chokidar.watch stub to return our mock watcher
+		chokidarWatchStub.reset()
+		chokidarWatchStub.returns(mockFileSystemWatcher as any)
+
+		// Reset the module-level disk stubs
+		mockTaskMetadata = { files_in_context: [], model_usage: [], environment_history: [] }
+		getTaskMetadataStub.reset()
+		getTaskMetadataStub.resolves(mockTaskMetadata)
+		saveTaskMetadataStub.reset()
+		saveTaskMetadataStub.resolves()
+
+		setVscodeHostProviderMock()
+
+		// Create tracker instance
+		tracker = new FileContextTracker({} as Controller, taskId)
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it("should add a record when a file is read by a tool", async () => {
+		await tracker.trackFileContext(filePath, "read_tool")
+
+		// Verify getTaskMetadata was called
+		expect(getTaskMetadataStub.calledOnce).to.be.true
+		expect(getTaskMetadataStub.firstCall.args[0]).to.equal(taskId)
+
+		// Verify saveTaskMetadata was called with the correct data
+		expect(saveTaskMetadataStub.calledOnce).to.be.true
+
+		const savedMetadata = saveTaskMetadataStub.firstCall.args[1]
+		expect(savedMetadata.files_in_context.length).to.equal(1)
+
+		const fileEntry = savedMetadata.files_in_context[0]
+		expect(fileEntry.path).to.equal(filePath)
+		expect(fileEntry.record_state).to.equal("active")
+		expect(fileEntry.record_source).to.equal("read_tool")
+		expect(fileEntry.cline_read_date).to.be.a("number")
+		expect(fileEntry.cline_edit_date).to.be.null
+	})
+
+	it("should add a record when a file is edited by Cline", async () => {
+		await tracker.trackFileContext(filePath, "cline_edited")
+
+		// Verify saveTaskMetadata was called with the correct data
+		expect(saveTaskMetadataStub.calledOnce).to.be.true
+		const savedMetadata = saveTaskMetadataStub.firstCall.args[1]
+
+		// Check that we have at least one entry in files_in_context
+		expect(savedMetadata.files_in_context).to.be.an("array").that.is.not.empty
+
+		// Find the active entry for this file
+		const activeEntry = savedMetadata.files_in_context.find(
+			(entry: FileMetadataEntry) => entry.path === filePath && entry.record_state === "active",
+		)
+
+		// Assert that we found an active entry
+		expect(activeEntry).to.exist
+
+		// Now check the properties of the active entry
+		expect(activeEntry.path).to.equal(filePath)
+		expect(activeEntry.record_state).to.equal("active")
+		expect(activeEntry.record_source).to.equal("cline_edited")
+		expect(activeEntry.cline_read_date).to.be.a("number")
+		expect(activeEntry.cline_edit_date).to.be.a("number")
+	})
+
+	it("should add a record when a file is mentioned", async () => {
+		await tracker.trackFileContext(filePath, "file_mentioned")
+
+		// Verify saveTaskMetadata was called with the correct data
+		const savedMetadata = saveTaskMetadataStub.firstCall.args[1]
+		const fileEntry = savedMetadata.files_in_context[0]
+
+		expect(fileEntry.path).to.equal(filePath)
+		expect(fileEntry.record_state).to.equal("active")
+		expect(fileEntry.record_source).to.equal("file_mentioned")
+		expect(fileEntry.cline_read_date).to.be.a("number")
+		expect(fileEntry.cline_edit_date).to.be.null
+	})
+
+	it("should add a record when a file is edited by the user", async () => {
+		await tracker.trackFileContext(filePath, "user_edited")
+
+		// Verify saveTaskMetadata was called with the correct data
+		const savedMetadata = saveTaskMetadataStub.firstCall.args[1]
+		const fileEntry = savedMetadata.files_in_context[0]
+
+		expect(fileEntry.path).to.equal(filePath)
+		expect(fileEntry.record_state).to.equal("active")
+		expect(fileEntry.record_source).to.equal("user_edited")
+		expect(fileEntry.user_edit_date).to.be.a("number")
+
+		// Verify the file was added to recentlyModifiedFiles
+		const modifiedFiles = tracker.getAndClearRecentlyModifiedFiles()
+		expect(modifiedFiles).to.include(filePath)
+	})
+
+	it("should mark existing entries as stale when adding a new entry for the same file", async () => {
+		// Add an initial entry
+		mockTaskMetadata.files_in_context = [
+			{
+				path: filePath,
+				record_state: "active",
+				record_source: "read_tool",
+				cline_read_date: Date.now() - 1000, // 1 second ago
+				cline_edit_date: null,
+				user_edit_date: null,
+			},
+		]
+
+		// Track a new operation on the same file
+		await tracker.trackFileContext(filePath, "cline_edited")
+
+		// Verify the metadata now has two entries - one stale and one active
+		const savedMetadata = saveTaskMetadataStub.firstCall.args[1]
+		expect(savedMetadata.files_in_context.length).to.equal(2)
+
+		// First entry should be marked as stale
+		expect(savedMetadata.files_in_context[0].record_state).to.equal("stale")
+
+		// New entry should be active
+		const newEntry = savedMetadata.files_in_context[1]
+		expect(newEntry.record_state).to.equal("active")
+		expect(newEntry.record_source).to.equal("cline_edited")
+	})
+
+	it("should setup a file watcher for tracked files", async () => {
+		await tracker.trackFileContext(filePath, "read_tool")
+
+		// Verify chokidar.watch was called
+		expect(chokidarWatchStub.called).to.be.true
+
+		// Verify change listener was set up
+		expect(mockFileSystemWatcher.on.called).to.be.true
+	})
+
+	it("should track user edits when file watcher detects changes", async () => {
+		// First track the file to set up the watcher
+		await tracker.trackFileContext(filePath, "read_tool")
+
+		// Reset the stubs to check the next calls
+		getTaskMetadataStub.resetHistory()
+		saveTaskMetadataStub.resetHistory()
+
+		// Create a spy on trackFileContext to verify it's called with the right parameters
+		const trackFileContextSpy = sandbox.spy(tracker, "trackFileContext")
+
+		// Get the callback that was registered with chokidar "change" event
+		const callback = mockFileSystemWatcher.on.firstCall.args[1]
+
+		// Directly call the callback to simulate a file change event
+		callback(vscode.Uri.file(path.resolve("/mock/workspace", filePath)))
+
+		// Verify trackFileContext was called with the right parameters
+		expect(trackFileContextSpy.calledWith(filePath, "user_edited")).to.be.true
+
+		// Verify the file was added to recentlyModifiedFiles
+		const modifiedFiles = tracker.getAndClearRecentlyModifiedFiles()
+		expect(modifiedFiles).to.include(filePath)
+	})
+
+	it("should not track Cline edits as user edits", async () => {
+		// First track the file to set up the watcher
+		await tracker.trackFileContext(filePath, "read_tool")
+
+		// Mark the file as edited by Cline
+		tracker.markFileAsEditedByCline(filePath)
+
+		// Reset the stubs to check the next calls
+		getTaskMetadataStub.resetHistory()
+		saveTaskMetadataStub.resetHistory()
+
+		// Create a spy on trackFileContext to verify it's not called
+		const trackFileContextSpy = sandbox.spy(tracker, "trackFileContext")
+
+		// Get the callback that was registered with chokidar "change" event
+		const callback = mockFileSystemWatcher.on.firstCall.args[1]
+
+		// Directly call the callback to simulate a file change event
+		callback(vscode.Uri.file(path.resolve("/mock/workspace", filePath)))
+
+		// Verify trackFileContext was not called with user_edited
+		expect(trackFileContextSpy.calledWith(filePath, "user_edited")).to.be.false
+
+		// Verify the file was not added to recentlyModifiedFiles
+		const modifiedFiles = tracker.getAndClearRecentlyModifiedFiles()
+		expect(modifiedFiles).to.not.include(filePath)
+	})
+
+	it("should dispose file watchers when dispose is called", async () => {
+		// Track a file to set up the watcher
+		await tracker.trackFileContext(filePath, "read_tool")
+
+		// Call dispose
+		await tracker.dispose()
+
+		// Verify the watcher was closed
+		expect(mockFileSystemWatcher.close.called).to.be.true
+	})
+})
diff --git a/apps/vscode/src/core/context/context-tracking/FileContextTracker.ts b/apps/vscode/src/core/context/context-tracking/FileContextTracker.ts
new file mode 100644
index 0000000..78bd1e4
--- /dev/null
+++ b/apps/vscode/src/core/context/context-tracking/FileContextTracker.ts
@@ -0,0 +1,279 @@
+import { getTaskMetadata, saveTaskMetadata } from "@core/storage/disk"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import chokidar, { FSWatcher } from "chokidar"
+import * as path from "path"
+import { Controller } from "@/core/controller"
+import { Logger } from "@/shared/services/Logger"
+import { getCwd } from "@/utils/path"
+import type { FileMetadataEntry } from "./ContextTrackerTypes"
+
+// This class is responsible for tracking file operations that may result in stale context.
+// If a user modifies a file outside of Cline, the context may become stale and need to be updated.
+// We do not want Cline to reload the context every time a file is modified, so we use this class merely
+// to inform Cline that the change has occurred, and tell Cline to reload the file before making
+// any changes to it. This fixes an issue with diff editing, where Cline was unable to complete a diff edit.
+// a diff edit because the file was modified since Cline last read it.
+
+// FileContextTracker
+/**
+This class is responsible for tracking file operations.
+If the full contents of a file are passed to Cline via a tool, mention, or edit, the file is marked as active.
+If a file is modified outside of Cline, we detect and track this change to prevent stale context.
+This is used when restoring a task (non-git "checkpoint" restore), and mid-task.
+*/
+export class FileContextTracker {
+	private controller: Controller
+	readonly taskId: string
+
+	// File tracking and watching
+	private fileWatchers = new Map<string, FSWatcher>()
+	private recentlyModifiedFiles = new Set<string>()
+	private recentlyEditedByCline = new Set<string>()
+
+	constructor(controller: Controller, taskId: string) {
+		this.controller = controller
+		this.taskId = taskId
+	}
+
+	/**
+	 * File watchers are set up for each file that is tracked in the task metadata.
+	 */
+	async setupFileWatcher(filePath: string) {
+		// Only setup watcher if it doesn't already exist for this file
+		if (this.fileWatchers.has(filePath)) {
+			return
+		}
+
+		const cwd = await getCwd()
+		if (!cwd) {
+			Logger.info("No workspace folder available - cannot determine current working directory")
+			return
+		}
+
+		// Create a chokidar file watcher for this specific file
+		const resolvedFilePath = path.resolve(cwd, filePath)
+		const watcher = chokidar.watch(resolvedFilePath, {
+			persistent: true, // Keep process alive while watching
+			ignoreInitial: true, // Don't emit events for existing files on startup
+			atomic: true, // Handle atomic writes (editors that use temp files)
+			awaitWriteFinish: {
+				// Wait for writes to finish before emitting events
+				stabilityThreshold: 100, // Wait 100ms for file size to stabilize
+				pollInterval: 100, // Check every 100ms while waiting
+			},
+		})
+
+		// Track file changes
+		watcher.on("change", () => {
+			if (this.recentlyEditedByCline.has(filePath)) {
+				this.recentlyEditedByCline.delete(filePath) // This was an edit by Cline, no need to inform Cline
+			} else {
+				this.recentlyModifiedFiles.add(filePath) // This was a user edit, we will inform Cline
+				this.trackFileContext(filePath, "user_edited") // Update the task metadata with file tracking
+			}
+		})
+
+		// Store the watcher so we can dispose it later
+		this.fileWatchers.set(filePath, watcher)
+	}
+
+	/**
+	 * Tracks a file operation in metadata and sets up a watcher for the file
+	 * This is the main entry point for FileContextTracker and is called when a file is passed to Cline via a tool, mention, or edit.
+	 */
+	async trackFileContext(filePath: string, operation: "read_tool" | "user_edited" | "cline_edited" | "file_mentioned") {
+		try {
+			const cwd = await getCwd()
+			if (!cwd) {
+				Logger.info("No workspace folder available - cannot determine current working directory")
+				return
+			}
+
+			// Add file to metadata
+			await this.addFileToFileContextTracker(this.taskId, filePath, operation)
+
+			// Set up file watcher for this file
+			await this.setupFileWatcher(filePath)
+		} catch (error) {
+			Logger.error("Failed to track file operation:", error)
+		}
+	}
+
+	/**
+	 * Adds a file to the metadata tracker
+	 * This handles the business logic of determining if the file is new, stale, or active.
+	 * It also updates the metadata with the latest read/edit dates.
+	 */
+	async addFileToFileContextTracker(taskId: string, filePath: string, source: FileMetadataEntry["record_source"]) {
+		try {
+			const metadata = await getTaskMetadata(taskId)
+			const now = Date.now()
+
+			// Mark existing entries for this file as stale
+			metadata.files_in_context.forEach((entry) => {
+				if (entry.path === filePath && entry.record_state === "active") {
+					entry.record_state = "stale"
+				}
+			})
+
+			// Helper to get the latest date for a specific field and file
+			const getLatestDateForField = (path: string, field: keyof FileMetadataEntry): number | null => {
+				const relevantEntries = metadata.files_in_context
+					.filter((entry) => entry.path === path && entry[field])
+					.sort((a, b) => (b[field] as number) - (a[field] as number))
+
+				return relevantEntries.length > 0 ? (relevantEntries[0][field] as number) : null
+			}
+
+			const newEntry: FileMetadataEntry = {
+				path: filePath,
+				record_state: "active",
+				record_source: source,
+				cline_read_date: getLatestDateForField(filePath, "cline_read_date"),
+				cline_edit_date: getLatestDateForField(filePath, "cline_edit_date"),
+				user_edit_date: getLatestDateForField(filePath, "user_edit_date"),
+			}
+
+			switch (source) {
+				// user_edited: The user has edited the file
+				case "user_edited":
+					newEntry.user_edit_date = now
+					this.recentlyModifiedFiles.add(filePath)
+					break
+
+				// cline_edited: Cline has edited the file
+				case "cline_edited":
+					newEntry.cline_read_date = now
+					newEntry.cline_edit_date = now
+					break
+
+				// read_tool/file_mentioned: Cline has read the file via a tool or file mention
+				case "read_tool":
+				case "file_mentioned":
+					newEntry.cline_read_date = now
+					break
+			}
+
+			metadata.files_in_context.push(newEntry)
+			await saveTaskMetadata(taskId, metadata)
+		} catch (error) {
+			Logger.error("Failed to add file to metadata:", error)
+		}
+	}
+
+	/**
+	 * Returns (and then clears) the set of recently modified files
+	 */
+	getAndClearRecentlyModifiedFiles(): string[] {
+		const files = Array.from(this.recentlyModifiedFiles)
+		this.recentlyModifiedFiles.clear()
+		return files
+	}
+
+	/**
+	 * Marks a file as edited by Cline to prevent false positives in file watchers
+	 */
+	markFileAsEditedByCline(filePath: string): void {
+		this.recentlyEditedByCline.add(filePath)
+	}
+
+	/**
+	 * Disposes all file watchers
+	 */
+	async dispose(): Promise<void> {
+		const closePromises = Array.from(this.fileWatchers.values()).map((watcher) => watcher.close())
+		await Promise.all(closePromises)
+		this.fileWatchers.clear()
+	}
+
+	/**
+	 * Detects files that were edited by Cline or users after a specific message timestamp
+	 * This is used when restoring checkpoints to warn about potential file content mismatches
+	 */
+	async detectFilesEditedAfterMessage(messageTs: number, deletedMessages: ClineMessage[]): Promise<string[]> {
+		const editedFiles: string[] = []
+
+		try {
+			// Check task metadata for files that were edited by Cline or users after the message timestamp
+			const taskMetadata = await getTaskMetadata(this.taskId)
+
+			if (taskMetadata?.files_in_context) {
+				for (const fileEntry of taskMetadata.files_in_context) {
+					const clineEditedAfter = fileEntry.cline_edit_date && fileEntry.cline_edit_date > messageTs
+					const userEditedAfter = fileEntry.user_edit_date && fileEntry.user_edit_date > messageTs
+
+					if (clineEditedAfter || userEditedAfter) {
+						editedFiles.push(fileEntry.path)
+					}
+				}
+			}
+		} catch (error) {
+			Logger.error("Error checking file context metadata:", error)
+		}
+
+		// Also check deleted task messages for file operations
+		for (const message of deletedMessages) {
+			if (message.say === "tool" && message.text) {
+				try {
+					const toolData = JSON.parse(message.text)
+					if ((toolData.tool === "editedExistingFile" || toolData.tool === "newFileCreated") && toolData.path) {
+						if (!editedFiles.includes(toolData.path)) {
+							editedFiles.push(toolData.path)
+						}
+					}
+				} catch (error) {
+					Logger.error("Error checking task messages:", error)
+				}
+			}
+		}
+		return [...new Set(editedFiles)]
+	}
+
+	/**
+	 * Stores pending file context warning in workspace state so it persists across task reinitialization
+	 */
+	async storePendingFileContextWarning(files: string[]): Promise<void> {
+		try {
+			const key = `pendingFileContextWarning_${this.taskId}`
+			// NOTE: Using 'as any' because dynamic keys like pendingFileContextWarning_${taskId}
+			// are legitimate workspace state keys but don't fit the strict LocalStateKey type system
+			this.controller.stateManager.setWorkspaceState(key as any, files)
+		} catch (error) {
+			Logger.error("Error storing pending file context warning:", error)
+		}
+	}
+
+	/**
+	 * Retrieves pending file context warning from workspace state (without clearing it)
+	 */
+	async retrievePendingFileContextWarning(): Promise<string[] | undefined> {
+		try {
+			const key = `pendingFileContextWarning_${this.taskId}`
+			// NOTE: Using 'as any' because dynamic keys like pendingFileContextWarning_${taskId}
+			// are legitimate workspace state keys but don't fit the strict LocalStateKey type system
+			const files = this.controller.stateManager.getWorkspaceStateKey(key as any) as string[]
+			return files
+		} catch (error) {
+			Logger.error("Error retrieving pending file context warning:", error)
+		}
+		return undefined
+	}
+
+	/**
+	 * Retrieves and clears pending file context warning from workspace state
+	 */
+	async retrieveAndClearPendingFileContextWarning(): Promise<string[] | undefined> {
+		try {
+			const files = await this.retrievePendingFileContextWarning()
+			if (files) {
+				// NOTE: Using 'as any' because dynamic keys like pendingFileContextWarning_${taskId}
+				// are legitimate workspace state keys but don't fit the strict LocalStateKey type system
+				this.controller.stateManager.setWorkspaceState(`pendingFileContextWarning_${this.taskId}` as any, undefined)
+				return files
+			}
+		} catch (error) {
+			Logger.error("Error retrieving pending file context warning:", error)
+		}
+		return undefined
+	}
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/__tests__/frontmatter.test.ts b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/frontmatter.test.ts
new file mode 100644
index 0000000..f61290c
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/frontmatter.test.ts
@@ -0,0 +1,59 @@
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+import { parseYamlFrontmatter } from "../frontmatter"
+
+describe("parseYamlFrontmatter", () => {
+	it("returns original content when no frontmatter", () => {
+		const input = "Just text"
+		const result = parseYamlFrontmatter(input)
+		expect(result.hadFrontmatter).to.equal(false)
+		expect(result.data).to.deep.equal({})
+		expect(result.body).to.equal(input)
+	})
+
+	it("parses valid YAML frontmatter", () => {
+		const input = `---\npaths:\n  - "src/**"\n---\n\nHello`
+		const result = parseYamlFrontmatter(input)
+		expect(result.hadFrontmatter).to.equal(true)
+		expect(result.parseError).to.equal(undefined)
+		expect(result.data).to.deep.equal({ paths: ["src/**"] })
+		expect(result.body.trim()).to.equal("Hello")
+	})
+
+	it("fails open on malformed YAML", () => {
+		const input = `---\npaths: [invalid\n---\nBody`
+		const result = parseYamlFrontmatter(input)
+		expect(result.hadFrontmatter).to.equal(true)
+		expect(result.data).to.deep.equal({})
+		expect(result.body).to.equal(input)
+		expect(result.parseError).to.be.a("string")
+	})
+
+	it("rejects YAML custom tags (security: prevents unsafe deserialization)", () => {
+		// !!js/function is the classic RCE vector in js-yaml v3.
+		// With JSON_SCHEMA, any custom tag should be rejected.
+		const input = `---\nfoo: !!js/function 'function(){ return 1 }'\n---\nBody`
+		const result = parseYamlFrontmatter(input)
+		expect(result.hadFrontmatter).to.equal(true)
+		expect(result.data).to.deep.equal({})
+		expect(result.body).to.equal(input)
+		expect(result.parseError).to.be.a("string")
+	})
+
+	it("rejects !!python/object YAML tag", () => {
+		const input = `---\nfoo: !!python/object:os.system 'echo pwned'\n---\nBody`
+		const result = parseYamlFrontmatter(input)
+		expect(result.hadFrontmatter).to.equal(true)
+		expect(result.data).to.deep.equal({})
+		expect(result.parseError).to.be.a("string")
+	})
+
+	it("parses JSON-compatible YAML values correctly", () => {
+		const input = `---\ncount: 42\nenabled: true\ntags:\n  - "a"\n  - "b"\n---\nContent`
+		const result = parseYamlFrontmatter(input)
+		expect(result.hadFrontmatter).to.equal(true)
+		expect(result.parseError).to.equal(undefined)
+		expect(result.data).to.deep.equal({ count: 42, enabled: true, tags: ["a", "b"] })
+		expect(result.body.trim()).to.equal("Content")
+	})
+})
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/__tests__/rule-conditionals.test.ts b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/rule-conditionals.test.ts
new file mode 100644
index 0000000..2ceca9e
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/rule-conditionals.test.ts
@@ -0,0 +1,74 @@
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+import { evaluateRuleConditionals, extractPathLikeStrings } from "../rule-conditionals"
+
+describe("rule-conditionals", () => {
+	describe("evaluateRuleConditionals(paths)", () => {
+		it("treats missing paths as universal", () => {
+			const res = evaluateRuleConditionals({}, { paths: [] })
+			expect(res.passed).to.equal(true)
+		})
+
+		it("treats empty paths list in frontmatter as match-nothing (fail-closed)", () => {
+			const res = evaluateRuleConditionals({ paths: [] }, { paths: ["src/index.ts"] })
+			expect(res.passed).to.equal(false)
+		})
+
+		it("does not activate path-scoped rules with empty context", () => {
+			const res = evaluateRuleConditionals({ paths: ["src/**"] }, { paths: [] })
+			expect(res.passed).to.equal(false)
+		})
+
+		it("matches when any candidate path matches any glob", () => {
+			const res = evaluateRuleConditionals({ paths: ["src/**", "apps/**"] }, { paths: ["src/index.ts"] })
+			expect(res.passed).to.equal(true)
+			expect(res.matchedConditions.paths).to.deep.equal(["src/**"])
+		})
+
+		it("ignores invalid paths type (fail-open)", () => {
+			const res = evaluateRuleConditionals({ paths: "src/**" as any }, { paths: [] })
+			expect(res.passed).to.equal(true)
+		})
+	})
+
+	describe("extractPathLikeStrings", () => {
+		it("extracts basic relative paths", () => {
+			const res = extractPathLikeStrings("edit apps/web/src/App.tsx and packages/foo/src")
+			expect(res).to.deep.equal(["apps/web/src/App.tsx", "packages/foo/src"])
+		})
+
+		it("extracts simple filenames with extensions (no slashes)", () => {
+			const res = extractPathLikeStrings("Does foo.md exist? If not, create foo.md")
+			expect(res).to.deep.equal(["foo.md"])
+		})
+
+		it("does not extract bare words without an extension", () => {
+			const res = extractPathLikeStrings("Please create foo and then update bar")
+			expect(res).to.deep.equal([])
+		})
+
+		it("ignores URLs", () => {
+			const res = extractPathLikeStrings("see https://example.com/a/b and edit src/index.ts")
+			expect(res).to.deep.equal(["src/index.ts"])
+		})
+
+		it("ignores fenced code blocks", () => {
+			const text =
+				"Please update src/index.ts\n\n```ts\n// example code\nconst p = 'apps/web/src/App.tsx'\n// also: packages/foo/src\n```\n\nThanks!"
+			const res = extractPathLikeStrings(text)
+			expect(res).to.deep.equal(["src/index.ts"])
+		})
+
+		it("does not extract URLs inside code fences", () => {
+			const text = "```\nSee https://example.com/a/b and src/index.ts\n```\nBut edit docs/readme.md"
+			const res = extractPathLikeStrings(text)
+			expect(res).to.deep.equal(["docs/readme.md"])
+		})
+
+		it("extracts paths from stack traces (outside code fences)", () => {
+			const text = "Error: boom\n    at foo (src/index.ts:12:3)\n    at bar (apps/web/src/App.tsx:5:1)"
+			const res = extractPathLikeStrings(text)
+			expect(res).to.deep.equal(["src/index.ts", "apps/web/src/App.tsx"])
+		})
+	})
+})
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/__tests__/rule-loading.test.ts b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/rule-loading.test.ts
new file mode 100644
index 0000000..84359de
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/rule-loading.test.ts
@@ -0,0 +1,118 @@
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { getRuleFilesTotalContentWithMetadata } from "../rule-helpers"
+
+describe("rule loading with paths frontmatter", () => {
+	it("filters rules by evaluationContext.paths", async () => {
+		const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "cline-rules-test-"))
+		try {
+			const rulesDir = path.join(tmp, ".clinerules")
+			await fs.mkdir(rulesDir, { recursive: true })
+			await fs.writeFile(path.join(rulesDir, "universal.md"), "Always on")
+			await fs.writeFile(path.join(rulesDir, "scoped.md"), `---\npaths:\n  - "src/**"\n---\n\nOnly for src`)
+
+			const files = ["universal.md", "scoped.md"]
+			const toggles: Record<string, boolean> = {
+				[path.join(rulesDir, "universal.md")]: true,
+				[path.join(rulesDir, "scoped.md")]: true,
+			}
+
+			const res1 = await getRuleFilesTotalContentWithMetadata(files, rulesDir, toggles, {
+				evaluationContext: { paths: ["src/index.ts"] },
+			})
+			expect(res1.content).to.contain("universal.md")
+			expect(res1.content).to.contain("scoped.md")
+			expect(res1.content).to.not.contain("paths:")
+			expect(res1.activatedConditionalRules.map((r) => r.name)).to.include("global:scoped.md")
+
+			const res2 = await getRuleFilesTotalContentWithMetadata(files, rulesDir, toggles, {
+				evaluationContext: { paths: ["docs/readme.md"] },
+			})
+			expect(res2.content).to.contain("universal.md")
+			expect(res2.content).to.not.contain("scoped.md")
+		} finally {
+			await fs.rm(tmp, { recursive: true, force: true })
+		}
+	})
+
+	it("treats invalid YAML frontmatter as fail-open and preserves the raw frontmatter for the LLM", async () => {
+		const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "cline-rules-test-"))
+		try {
+			const rulesDir = path.join(tmp, ".clinerules")
+			await fs.mkdir(rulesDir, { recursive: true })
+			// Intentionally invalid YAML (unquoted '*' is a YAML alias indicator)
+			await fs.writeFile(
+				path.join(rulesDir, "invalid.md"),
+				`---\npaths: *\n---\n\nInvalid YAML, but should still be included`,
+			)
+
+			const files = ["invalid.md"]
+			const toggles: Record<string, boolean> = {
+				[path.join(rulesDir, "invalid.md")]: true,
+			}
+
+			const res = await getRuleFilesTotalContentWithMetadata(files, rulesDir, toggles, {
+				evaluationContext: { paths: ["src/index.ts"] },
+			})
+
+			// Fail-open: included even though frontmatter cannot be parsed.
+			expect(res.content).to.contain("invalid.md")
+			// Preserve raw frontmatter fence/content for the LLM.
+			expect(res.content).to.contain("---")
+			expect(res.content).to.contain("paths:")
+		} finally {
+			await fs.rm(tmp, { recursive: true, force: true })
+		}
+	})
+
+	it("treats paths: [] as match-nothing (fail-closed)", async () => {
+		const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "cline-rules-test-"))
+		try {
+			const rulesDir = path.join(tmp, ".clinerules")
+			await fs.mkdir(rulesDir, { recursive: true })
+			await fs.writeFile(path.join(rulesDir, "scoped-empty.md"), `---\npaths: []\n---\n\nShould never activate`)
+
+			const files = ["scoped-empty.md"]
+			const toggles: Record<string, boolean> = {
+				[path.join(rulesDir, "scoped-empty.md")]: true,
+			}
+
+			const res = await getRuleFilesTotalContentWithMetadata(files, rulesDir, toggles, {
+				evaluationContext: { paths: ["src/index.ts"] },
+			})
+
+			expect(res.content).to.not.contain("scoped-empty.md")
+		} finally {
+			await fs.rm(tmp, { recursive: true, force: true })
+		}
+	})
+
+	it("keeps activatedConditionalRules order stable (matches input file order)", async () => {
+		const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "cline-rules-test-"))
+		try {
+			const rulesDir = path.join(tmp, ".clinerules")
+			await fs.mkdir(rulesDir, { recursive: true })
+			await fs.writeFile(path.join(rulesDir, "a.md"), `---\npaths:\n  - "src/**"\n---\n\nA`)
+			await fs.writeFile(path.join(rulesDir, "b.md"), `---\npaths:\n  - "src/**"\n---\n\nB`)
+			await fs.writeFile(path.join(rulesDir, "c.md"), `---\npaths:\n  - "src/**"\n---\n\nC`)
+
+			const files = ["a.md", "b.md", "c.md"]
+			const toggles: Record<string, boolean> = {
+				[path.join(rulesDir, "a.md")]: true,
+				[path.join(rulesDir, "b.md")]: true,
+				[path.join(rulesDir, "c.md")]: true,
+			}
+
+			const res = await getRuleFilesTotalContentWithMetadata(files, rulesDir, toggles, {
+				evaluationContext: { paths: ["src/index.ts"] },
+			})
+
+			expect(res.activatedConditionalRules.map((r) => r.name)).to.deep.equal(files.map((f) => `global:${f}`))
+		} finally {
+			await fs.rm(tmp, { recursive: true, force: true })
+		}
+	})
+})
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/__tests__/skills.test.ts b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/skills.test.ts
new file mode 100644
index 0000000..6f2098c
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/__tests__/skills.test.ts
@@ -0,0 +1,837 @@
+/**
+ * Unit tests for skills utility functions
+ * Tests skill discovery, override resolution, toggle filtering, and content loading
+ */
+
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { expect } from "chai"
+import * as actualFsPromises from "fs/promises"
+import * as path from "path"
+import * as sinon from "sinon"
+
+import * as actualSkillDirectories from "@/core/storage/skill-directories"
+import { Logger } from "@/shared/services/Logger"
+import * as actualFsUtils from "@/utils/fs"
+
+// bun loads real ESM, so sinon cannot stub the `@utils/fs`,
+// `@core/storage/skill-directories`, or the `fs/promises` namespace exports
+// ("ES Modules cannot be stubbed"). Crucially, under bun `fs.promises` and the
+// `fs/promises` module are NOT the same object, so stubbing `fs.promises.X`
+// (which worked under mocha/ts-node) does not affect the SUT's
+// `import * as fs from "fs/promises"` bindings. Inject module-level sinon stubs
+// via bun's mock.module so the full sinon stub API (.withArgs/.resolves/etc.)
+// keeps working through the exact specifiers the SUT imports.
+const fileExistsAtPathStub = sinon.stub()
+const isDirectoryStub_ = sinon.stub()
+const getSkillsDirectoriesForScanStub = sinon.stub()
+const readdirStub_ = sinon.stub()
+const statStub_ = sinon.stub()
+const readFileStub_ = sinon.stub()
+const writeFileStub_ = sinon.stub()
+const fsUtilsMock = () => ({
+	...actualFsUtils,
+	fileExistsAtPath: fileExistsAtPathStub,
+	isDirectory: isDirectoryStub_,
+})
+const skillDirsMock = () => ({
+	...actualSkillDirectories,
+	getSkillsDirectoriesForScan: getSkillsDirectoriesForScanStub,
+})
+const fsPromisesMockNamespace = {
+	...actualFsPromises,
+	readdir: readdirStub_,
+	stat: statStub_,
+	readFile: readFileStub_,
+	writeFile: writeFileStub_,
+}
+const fsPromisesMock = () => ({ ...fsPromisesMockNamespace, default: fsPromisesMockNamespace })
+// The SUT imports via the `@utils/*` and `@core/*` tsconfig path aliases;
+// register both the `@/`-prefixed and bare-alias forms to be safe.
+mock.module("@utils/fs", fsUtilsMock)
+mock.module("@/utils/fs", fsUtilsMock)
+mock.module("@core/storage/skill-directories", skillDirsMock)
+mock.module("@/core/storage/skill-directories", skillDirsMock)
+mock.module("fs/promises", fsPromisesMock)
+mock.module("node:fs/promises", fsPromisesMock)
+
+import { parseYamlFrontmatter } from "../frontmatter"
+import {
+	discoverSkills,
+	getAvailableSkills,
+	getSkillContent,
+	parseRemoteSkillEntries,
+	setSkillDisabledInFrontmatter,
+	updateSkillMarkdownDisabledState,
+} from "../skills"
+
+describe("Skills Utility Functions", () => {
+	let sandbox: sinon.SinonSandbox
+	let fileExistsStub: sinon.SinonStub
+	let isDirectoryStub: sinon.SinonStub
+	let readdirStub: sinon.SinonStub
+	let statStub: sinon.SinonStub
+	let readFileStub: sinon.SinonStub
+
+	// Use path.join for OS-independent paths
+	const TEST_CWD = path.join("/test", "project")
+	const GLOBAL_SKILLS_DIR = path.join("/home", "user", ".cline", "skills")
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		// Stub Logger.warn to avoid noise in test output
+		sandbox.stub(Logger, "warn")
+
+		// Reset the module-level sinon stubs (injected via mock.module above) and
+		// re-point the per-test handles at them.
+		fileExistsAtPathStub.reset()
+		isDirectoryStub_.reset()
+		getSkillsDirectoriesForScanStub.reset()
+		readdirStub_.reset()
+		statStub_.reset()
+		readFileStub_.reset()
+		writeFileStub_.reset()
+		fileExistsStub = fileExistsAtPathStub
+		isDirectoryStub = isDirectoryStub_
+		readdirStub = readdirStub_
+		statStub = statStub_
+		readFileStub = readFileStub_
+
+		getSkillsDirectoriesForScanStub.returns([
+			{ path: path.join(TEST_CWD, ".clinerules", "skills"), source: "project" },
+			{ path: path.join(TEST_CWD, ".cline", "skills"), source: "project" },
+			{ path: path.join(TEST_CWD, ".claude", "skills"), source: "project" },
+			{ path: path.join(TEST_CWD, ".agents", "skills"), source: "project" },
+			{ path: GLOBAL_SKILLS_DIR, source: "global" },
+			{ path: path.join("/home", "user", ".agents", "skills"), source: "global" },
+		])
+
+		// Default: no directories exist
+		fileExistsStub.resolves(false)
+		isDirectoryStub.resolves(false)
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe("discoverSkills", () => {
+		it("should discover skills from global directory", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "my-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["my-skill"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: my-skill
+description: A test skill
+---
+Instructions here`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].name).to.equal("my-skill")
+			expect(skills[0].description).to.equal("A test skill")
+			expect(skills[0].source).to.equal("global")
+		})
+
+		it("should discover skills from project .clinerules/skills directory", async () => {
+			const projectSkillsDir = path.join(TEST_CWD, ".clinerules", "skills")
+			const skillDir = path.join(projectSkillsDir, "explaining-code")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(projectSkillsDir).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(projectSkillsDir).resolves(true)
+			readdirStub.withArgs(projectSkillsDir).resolves(["explaining-code"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: explaining-code
+description: Explains code with diagrams and analogies
+---
+Use analogies and ASCII diagrams when explaining code.`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].name).to.equal("explaining-code")
+			expect(skills[0].source).to.equal("project")
+		})
+
+		it("should discover skills from project .cline/skills directory", async () => {
+			const clineSkillsDir = path.join(TEST_CWD, ".cline", "skills")
+			const skillDir = path.join(clineSkillsDir, "debugging")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(clineSkillsDir).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(clineSkillsDir).resolves(true)
+			readdirStub.withArgs(clineSkillsDir).resolves(["debugging"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: debugging
+description: Debug code systematically
+---
+Use systematic debugging approaches.`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].name).to.equal("debugging")
+			expect(skills[0].source).to.equal("project")
+		})
+
+		it("should discover skills from project .claude/skills directory", async () => {
+			const claudeSkillsDir = path.join(TEST_CWD, ".claude", "skills")
+			const skillDir = path.join(claudeSkillsDir, "coding")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(claudeSkillsDir).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(claudeSkillsDir).resolves(true)
+			readdirStub.withArgs(claudeSkillsDir).resolves(["coding"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: coding
+description: Write clean code
+---
+Follow best practices.`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].name).to.equal("coding")
+			expect(skills[0].source).to.equal("project")
+		})
+
+		it("should discover skills from project .agents/skills directory", async () => {
+			const agentsSkillsDir = path.join(TEST_CWD, ".agents", "skills")
+			const skillDir = path.join(agentsSkillsDir, "testing")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(agentsSkillsDir).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(agentsSkillsDir).resolves(true)
+			readdirStub.withArgs(agentsSkillsDir).resolves(["testing"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: testing
+description: Write comprehensive tests
+---
+Always write tests.`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].name).to.equal("testing")
+			expect(skills[0].source).to.equal("project")
+		})
+
+		it("should handle empty skills directories gracefully", async () => {
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves([])
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+		})
+
+		it("should skip non-directory entries in skills folder", async () => {
+			const readmePath = path.join(GLOBAL_SKILLS_DIR, "README.md")
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "my-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["README.md", "my-skill"])
+			statStub.withArgs(readmePath).resolves({ isDirectory: () => false })
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: my-skill
+description: A skill
+---
+Content`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].name).to.equal("my-skill")
+		})
+
+		it("should skip skill directories without SKILL.md", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "incomplete-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["incomplete-skill"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			fileExistsStub.withArgs(skillMdPath).resolves(false)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+		})
+	})
+
+	describe("getAvailableSkills - Override Resolution", () => {
+		it("should override project skill with global skill of same name", async () => {
+			const globalSkillDir = path.join(GLOBAL_SKILLS_DIR, "coding")
+			const globalSkillMdPath = path.join(globalSkillDir, "SKILL.md")
+
+			// Setup global skill (higher priority)
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(globalSkillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["coding"])
+			statStub.withArgs(globalSkillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(globalSkillMdPath, "utf-8").resolves(`---
+name: coding
+description: Global coding skill
+---
+Global instructions`)
+
+			// Setup project skill with same name (lower priority)
+			const projectSkillsDir = path.join(TEST_CWD, ".clinerules", "skills")
+			const projectSkillDir = path.join(projectSkillsDir, "coding")
+			const projectSkillMdPath = path.join(projectSkillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(projectSkillsDir).resolves(true)
+			fileExistsStub.withArgs(projectSkillMdPath).resolves(true)
+			isDirectoryStub.withArgs(projectSkillsDir).resolves(true)
+			readdirStub.withArgs(projectSkillsDir).resolves(["coding"])
+			statStub.withArgs(projectSkillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(projectSkillMdPath, "utf-8").resolves(`---
+name: coding
+description: Project coding skill
+---
+Project instructions`)
+
+			const allSkills = await discoverSkills(TEST_CWD)
+			const skills = getAvailableSkills(allSkills)
+
+			expect(skills).to.have.lengthOf(1)
+			expect(skills[0].description).to.equal("Global coding skill")
+			expect(skills[0].source).to.equal("global")
+		})
+
+		it("should keep both skills when names are different", async () => {
+			const globalSkillDir = path.join(GLOBAL_SKILLS_DIR, "global-skill")
+			const globalSkillMdPath = path.join(globalSkillDir, "SKILL.md")
+
+			// Setup global skill
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(globalSkillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["global-skill"])
+			statStub.withArgs(globalSkillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(globalSkillMdPath, "utf-8").resolves(`---
+name: global-skill
+description: A global skill
+---
+Content`)
+
+			// Setup project skill with different name
+			const projectSkillsDir = path.join(TEST_CWD, ".clinerules", "skills")
+			const projectSkillDir = path.join(projectSkillsDir, "project-skill")
+			const projectSkillMdPath = path.join(projectSkillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(projectSkillsDir).resolves(true)
+			fileExistsStub.withArgs(projectSkillMdPath).resolves(true)
+			isDirectoryStub.withArgs(projectSkillsDir).resolves(true)
+			readdirStub.withArgs(projectSkillsDir).resolves(["project-skill"])
+			statStub.withArgs(projectSkillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(projectSkillMdPath, "utf-8").resolves(`---
+name: project-skill
+description: A project skill
+---
+Content`)
+
+			const allSkills = await discoverSkills(TEST_CWD)
+			const skills = getAvailableSkills(allSkills)
+
+			expect(skills).to.have.lengthOf(2)
+			const names = skills.map((s) => s.name)
+			expect(names).to.include("global-skill")
+			expect(names).to.include("project-skill")
+		})
+	})
+
+	describe("Metadata Validation", () => {
+		it("should reject skill with missing name field", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "bad-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["bad-skill"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+description: Missing name
+---
+Content`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+			sinon.assert.calledWithMatch(Logger.warn as sinon.SinonStub, /missing required 'name' field/)
+		})
+
+		it("should reject skill with missing description field", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "bad-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["bad-skill"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: bad-skill
+---
+Content`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+			sinon.assert.calledWithMatch(Logger.warn as sinon.SinonStub, /missing required 'description' field/)
+		})
+
+		it("should reject skill when name doesn't match directory name", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "my-dir")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["my-dir"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: different-name
+description: Mismatched name
+---
+Content`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+			sinon.assert.calledWithMatch(Logger.warn as sinon.SinonStub, /doesn't match directory/)
+		})
+
+		it("should handle malformed YAML frontmatter gracefully", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "bad-yaml")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["bad-yaml"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: [invalid yaml
+description: broken
+---
+Content`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+		})
+
+		it("should handle file without frontmatter", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "no-front")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["no-front"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`Just plain markdown content without frontmatter`)
+
+			const skills = await discoverSkills(TEST_CWD)
+
+			expect(skills).to.have.lengthOf(0)
+		})
+	})
+
+	describe("getSkillContent", () => {
+		it("should load full skill content with instructions", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "my-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["my-skill"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: my-skill
+description: Test skill
+---
+These are the detailed instructions.
+
+## Step 1
+Do this first.
+
+## Step 2
+Then do this.`)
+
+			const allSkills = await discoverSkills(TEST_CWD)
+			const availableSkills = getAvailableSkills(allSkills)
+			const content = await getSkillContent("my-skill", availableSkills)
+
+			expect(content).to.not.be.null
+			expect(content!.name).to.equal("my-skill")
+			expect(content!.instructions).to.include("These are the detailed instructions")
+			expect(content!.instructions).to.include("Step 1")
+			expect(content!.instructions).to.include("Step 2")
+		})
+
+		it("should return null for non-existent skill", async () => {
+			const content = await getSkillContent("non-existent", [])
+
+			expect(content).to.be.null
+		})
+
+		it("should trim whitespace from instructions", async () => {
+			const skillDir = path.join(GLOBAL_SKILLS_DIR, "my-skill")
+			const skillMdPath = path.join(skillDir, "SKILL.md")
+
+			fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			fileExistsStub.withArgs(skillMdPath).resolves(true)
+			isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+			readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["my-skill"])
+			statStub.withArgs(skillDir).resolves({ isDirectory: () => true })
+			readFileStub.withArgs(skillMdPath, "utf-8").resolves(`---
+name: my-skill
+description: Test
+---
+
+   Instructions with whitespace   
+
+`)
+
+			const allSkills = await discoverSkills(TEST_CWD)
+			const availableSkills = getAvailableSkills(allSkills)
+			const content = await getSkillContent("my-skill", availableSkills)
+
+			expect(content!.instructions).to.equal("Instructions with whitespace")
+		})
+	})
+
+	describe("Remote Skills", () => {
+		// entry.name must match frontmatter name (enforced by parseRemoteSkillEntries)
+		const makeEntry = (name: string, desc: string, body = "Instructions", alwaysEnabled = false) => ({
+			name,
+			alwaysEnabled,
+			contents: `---\nname: ${name}\ndescription: ${desc}\n---\n${body}`,
+		})
+
+		describe("parseRemoteSkillEntries", () => {
+			it("should return validated entries when entry.name matches frontmatter.name", () => {
+				const entries = [
+					{ name: "Deploy", alwaysEnabled: true, contents: `---\nname: Deploy\ndescription: CI/CD\n---\nBody` },
+				]
+				const result = parseRemoteSkillEntries(entries)
+				expect(result).to.have.lengthOf(1)
+				expect(result[0].name).to.equal("Deploy")
+				expect(result[0].description).to.equal("CI/CD")
+				expect(result[0].alwaysEnabled).to.equal(true)
+			})
+
+			it("should warn but still include entries where entry.name drifts from frontmatter.name", () => {
+				const entries = [
+					{
+						name: "entry-key",
+						alwaysEnabled: false,
+						contents: `---\nname: Different Name\ndescription: Desc\n---\nBody`,
+					},
+				]
+				const result = parseRemoteSkillEntries(entries)
+				expect(result).to.have.lengthOf(1)
+				expect(result[0].name).to.equal("Different Name")
+				sinon.assert.calledWithMatch(Logger.warn as sinon.SinonStub, /does not match frontmatter\.name/)
+			})
+
+			it("should skip entries with missing frontmatter name", () => {
+				const entries = [{ name: "bad", alwaysEnabled: false, contents: `---\ndescription: No name\n---\nContent` }]
+				const result = parseRemoteSkillEntries(entries)
+				expect(result).to.have.lengthOf(0)
+			})
+
+			it("should skip entries with missing frontmatter description", () => {
+				const entries = [{ name: "No Desc", alwaysEnabled: false, contents: `---\nname: No Desc\n---\nContent` }]
+				const result = parseRemoteSkillEntries(entries)
+				expect(result).to.have.lengthOf(0)
+			})
+
+			it("should handle empty array", () => {
+				expect(parseRemoteSkillEntries([])).to.have.lengthOf(0)
+			})
+
+			it("should include all entries with valid frontmatter even with drift", () => {
+				const entries = [
+					{ name: "Good", alwaysEnabled: false, contents: `---\nname: Good\ndescription: Valid\n---\nBody` },
+					{ name: "drift", alwaysEnabled: false, contents: `---\nname: Different\ndescription: Drifted\n---\nBody` },
+					{
+						name: "Also Good",
+						alwaysEnabled: true,
+						contents: `---\nname: Also Good\ndescription: Valid too\n---\nBody`,
+					},
+				]
+				const result = parseRemoteSkillEntries(entries)
+				expect(result).to.have.lengthOf(3)
+				expect(result[0].name).to.equal("Good")
+				expect(result[1].name).to.equal("Different")
+				expect(result[2].name).to.equal("Also Good")
+			})
+		})
+
+		describe("discoverSkills - remote skill discovery", () => {
+			it("should include remote skills from remote config", async () => {
+				const entries = [makeEntry("Deploy Pipeline", "Handles CI/CD deployment", "Deploy instructions")]
+				const skills = await discoverSkills(TEST_CWD, entries)
+
+				const remoteSkill = skills.find((s) => s.name === "Deploy Pipeline")
+				expect(remoteSkill).to.not.be.undefined
+				expect(remoteSkill!.path).to.equal("remote:Deploy Pipeline")
+				expect(remoteSkill!.source).to.equal("global")
+				expect(remoteSkill!.description).to.equal("Handles CI/CD deployment")
+			})
+
+			it("should use frontmatter.name as identity even when entry.name drifts", async () => {
+				const entries = [
+					{ name: "entry-key", alwaysEnabled: false, contents: `---\nname: Actual Name\ndescription: Desc\n---\nBody` },
+				]
+				const skills = await discoverSkills(TEST_CWD, entries)
+				const remoteSkill = skills.find((s) => s.path?.startsWith("remote:"))
+				expect(remoteSkill).to.not.be.undefined
+				expect(remoteSkill!.name).to.equal("Actual Name")
+				expect(remoteSkill!.path).to.equal("remote:Actual Name")
+			})
+
+			it("should skip remote skills with missing frontmatter name", async () => {
+				const entries = [{ name: "bad", alwaysEnabled: false, contents: `---\ndescription: No name\n---\nContent` }]
+				const skills = await discoverSkills(TEST_CWD, entries)
+				expect(skills.find((s) => s.path?.startsWith("remote:"))).to.be.undefined
+			})
+
+			it("should skip remote skills with missing frontmatter description", async () => {
+				const entries = [{ name: "No Desc", alwaysEnabled: false, contents: `---\nname: No Desc\n---\nContent` }]
+				const skills = await discoverSkills(TEST_CWD, entries)
+				expect(skills.find((s) => s.path?.startsWith("remote:"))).to.be.undefined
+			})
+
+			it("should handle empty and undefined entries gracefully", async () => {
+				for (const val of [[], undefined]) {
+					const skills = await discoverSkills(TEST_CWD, val)
+					expect(skills.filter((s) => s.path?.startsWith("remote:"))).to.have.lengthOf(0)
+				}
+			})
+		})
+
+		describe("Override resolution (remote > disk-global > project)", () => {
+			it("remote overrides disk-global skill of same name", async () => {
+				const entries = [makeEntry("coding", "Remote coding")]
+				const diskGlobalDir = path.join(GLOBAL_SKILLS_DIR, "coding")
+				const diskGlobalMd = path.join(diskGlobalDir, "SKILL.md")
+				fileExistsStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+				fileExistsStub.withArgs(diskGlobalMd).resolves(true)
+				isDirectoryStub.withArgs(GLOBAL_SKILLS_DIR).resolves(true)
+				readdirStub.withArgs(GLOBAL_SKILLS_DIR).resolves(["coding"])
+				statStub.withArgs(diskGlobalDir).resolves({ isDirectory: () => true })
+				readFileStub
+					.withArgs(diskGlobalMd, "utf-8")
+					.resolves(`---\nname: coding\ndescription: Disk global coding\n---\nDisk`)
+
+				const available = getAvailableSkills(await discoverSkills(TEST_CWD, entries))
+				expect(available).to.have.lengthOf(1)
+				expect(available[0].description).to.equal("Remote coding")
+				expect(available[0].path).to.equal("remote:coding")
+			})
+
+			it("remote overrides project skill of same name", async () => {
+				const entries = [makeEntry("coding", "Remote coding")]
+				const projDir = path.join(TEST_CWD, ".clinerules", "skills")
+				const projSkillDir = path.join(projDir, "coding")
+				const projMd = path.join(projSkillDir, "SKILL.md")
+				fileExistsStub.withArgs(projDir).resolves(true)
+				fileExistsStub.withArgs(projMd).resolves(true)
+				isDirectoryStub.withArgs(projDir).resolves(true)
+				readdirStub.withArgs(projDir).resolves(["coding"])
+				statStub.withArgs(projSkillDir).resolves({ isDirectory: () => true })
+				readFileStub.withArgs(projMd, "utf-8").resolves(`---\nname: coding\ndescription: Project coding\n---\nProject`)
+
+				const available = getAvailableSkills(await discoverSkills(TEST_CWD, entries))
+				expect(available).to.have.lengthOf(1)
+				expect(available[0].description).to.equal("Remote coding")
+				expect(available[0].path).to.equal("remote:coding")
+			})
+		})
+
+		describe("getSkillContent - remote skill content loading", () => {
+			it("should load content from provided entries for remote skills", async () => {
+				const entries = [makeEntry("Deploy Pipeline", "Deployment skill", "These are the deployment instructions.")]
+				const skill = {
+					name: "Deploy Pipeline",
+					description: "Deployment skill",
+					path: "remote:Deploy Pipeline",
+					source: "global" as const,
+				}
+				const content = await getSkillContent("Deploy Pipeline", [skill], entries)
+
+				expect(content).to.not.be.null
+				expect(content!.name).to.equal("Deploy Pipeline")
+				expect(content!.instructions).to.equal("These are the deployment instructions.")
+			})
+
+			it("should trim whitespace from remote skill instructions", async () => {
+				const entries = [makeEntry("Trim Skill", "Test", "\n   Instructions with whitespace   \n\n")]
+				const skill = { name: "Trim Skill", description: "Test", path: "remote:Trim Skill", source: "global" as const }
+				const content = await getSkillContent("Trim Skill", [skill], entries)
+				expect(content!.instructions).to.equal("Instructions with whitespace")
+			})
+
+			it("should return null if remote skill entry not found in entries", async () => {
+				const skill = { name: "Gone", description: "Removed", path: "remote:Gone", source: "global" as const }
+				const content = await getSkillContent("Gone", [skill], [])
+				expect(content).to.be.null
+			})
+
+			it("should not attempt disk read for remote skills", async () => {
+				const entries = [makeEntry("Remote Only", "Test", "Remote content")]
+				const skill = { name: "Remote Only", description: "Test", path: "remote:Remote Only", source: "global" as const }
+				await getSkillContent("Remote Only", [skill], entries)
+				sinon.assert.notCalled(readFileStub)
+			})
+		})
+	})
+})
+
+describe("updateSkillMarkdownDisabledState", () => {
+	it("adds disabled: true when disabling a skill with existing frontmatter", () => {
+		const input = ["---", "name: my-skill", "description: A skill", "---", "Body here"].join("\n")
+		const output = updateSkillMarkdownDisabledState(input, false)
+		expect(output).to.contain("disabled: true")
+		expect(output).to.contain("name: my-skill")
+		expect(output).to.contain("Body here")
+	})
+
+	it("removes disabled flag when enabling a previously-disabled skill", () => {
+		const input = ["---", "name: my-skill", "description: A skill", "disabled: true", "---", "Body"].join("\n")
+		const output = updateSkillMarkdownDisabledState(input, true)
+		expect(output).to.not.contain("disabled")
+		expect(output).to.contain("name: my-skill")
+		expect(output).to.contain("Body")
+	})
+
+	it("also clears a stale enabled: false when enabling", () => {
+		const input = ["---", "name: my-skill", "enabled: false", "---", "Body"].join("\n")
+		const output = updateSkillMarkdownDisabledState(input, true)
+		expect(output).to.not.contain("enabled: false")
+	})
+
+	it("drops the frontmatter block entirely when enabling leaves it empty", () => {
+		const input = ["---", "disabled: true", "---", "Body only"].join("\n")
+		const output = updateSkillMarkdownDisabledState(input, true)
+		expect(output).to.equal("Body only")
+	})
+
+	it("returns content unchanged when enabling a doc with no frontmatter", () => {
+		const input = "Just body, no frontmatter"
+		expect(updateSkillMarkdownDisabledState(input, true)).to.equal(input)
+	})
+
+	it("is idempotent: disabling an already-disabled skill keeps disabled: true once", () => {
+		const input = ["---", "name: s", "disabled: true", "---", "B"].join("\n")
+		const output = updateSkillMarkdownDisabledState(input, false)
+		expect(output.match(/disabled: true/g)).to.have.lengthOf(1)
+	})
+
+	// Frontmatter block whose YAML is genuinely invalid (asserted below). The
+	// `---` markers are well-formed so parseYamlFrontmatter detects frontmatter
+	// and then fails to parse it, exercising the parseError branch.
+	const MALFORMED_FRONTMATTER = ["---", "name: s", "description: : : bad", "  - nope", "---", "Body"].join("\n")
+
+	it("uses a fixture whose frontmatter YAML is actually invalid", () => {
+		// Guards the two tests below from rotting into false positives: if this
+		// fixture ever became valid YAML, updateSkillMarkdownDisabledState would
+		// take a different (rewriting) path and the "untouched" assertions could
+		// pass for the wrong reason.
+		const parsed = parseYamlFrontmatter(MALFORMED_FRONTMATTER)
+		expect(parsed.hadFrontmatter).to.be.true
+		expect(parsed.parseError, "fixture frontmatter should be invalid YAML").to.be.a("string")
+	})
+
+	it("leaves malformed-frontmatter files untouched when disabling (no double header)", () => {
+		// parseYamlFrontmatter fails open and returns the full original document
+		// as the body. Disabling must not prepend a second `---` block and corrupt
+		// the file.
+		const output = updateSkillMarkdownDisabledState(MALFORMED_FRONTMATTER, false)
+		expect(output).to.equal(MALFORMED_FRONTMATTER)
+		// Exactly one frontmatter opener/closer pair, not two.
+		expect(output.match(/^---$/gm)).to.have.lengthOf(2)
+	})
+
+	it("leaves malformed-frontmatter files untouched when enabling", () => {
+		expect(updateSkillMarkdownDisabledState(MALFORMED_FRONTMATTER, true)).to.equal(MALFORMED_FRONTMATTER)
+	})
+})
+
+describe("setSkillDisabledInFrontmatter", () => {
+	let sandbox: sinon.SinonSandbox
+	let readFileStub: sinon.SinonStub
+	let writeFileStub: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		sandbox.stub(Logger, "warn")
+		// Use the module-level fs/promises stubs (mock.module above) since under
+		// bun fs.promises !== the `fs/promises` module the SUT imports.
+		readFileStub_.reset()
+		writeFileStub_.reset()
+		readFileStub = readFileStub_
+		writeFileStub = writeFileStub_
+		writeFileStub.resolves()
+	})
+
+	afterEach(() => sandbox.restore())
+
+	it("writes disabled: true to the SKILL.md when disabling a disk skill", async () => {
+		const skillPath = path.join("/home", "user", ".cline", "skills", "s", "SKILL.md")
+		readFileStub.withArgs(skillPath, "utf-8").resolves(["---", "name: s", "description: d", "---", "Body"].join("\n"))
+
+		const ok = await setSkillDisabledInFrontmatter(skillPath, false)
+
+		expect(ok).to.be.true
+		sinon.assert.calledOnce(writeFileStub)
+		const written = writeFileStub.getCall(0).args[1] as string
+		expect(written).to.contain("disabled: true")
+	})
+
+	it("does not write for remote skills (no backing file)", async () => {
+		const ok = await setSkillDisabledInFrontmatter("remote:Some Skill", false)
+		expect(ok).to.be.false
+		sinon.assert.notCalled(readFileStub)
+		sinon.assert.notCalled(writeFileStub)
+	})
+
+	it("skips the write when content is unchanged", async () => {
+		const skillPath = path.join("/home", "user", ".cline", "skills", "s", "SKILL.md")
+		// Already disabled; disabling again yields identical content.
+		readFileStub.withArgs(skillPath, "utf-8").resolves(["---", "name: s", "disabled: true", "---", "B"].join("\n"))
+
+		const ok = await setSkillDisabledInFrontmatter(skillPath, false)
+
+		expect(ok).to.be.true
+		sinon.assert.notCalled(writeFileStub)
+	})
+})
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/cline-rules.ts b/apps/vscode/src/core/context/instructions/user-instructions/cline-rules.ts
new file mode 100644
index 0000000..3e430b5
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/cline-rules.ts
@@ -0,0 +1,34 @@
+import { synchronizeRuleToggles } from "@core/context/instructions/user-instructions/rule-helpers"
+import { ensureRulesDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import { ClineRulesToggles } from "@shared/cline-rules"
+import path from "path"
+import { Controller } from "@/core/controller"
+
+export async function refreshClineRulesToggles(
+	controller: Controller,
+	workingDirectory: string,
+): Promise<{
+	globalToggles: ClineRulesToggles
+	localToggles: ClineRulesToggles
+}> {
+	// Global toggles
+	const globalClineRulesToggles = controller.stateManager.getGlobalSettingsKey("globalClineRulesToggles")
+	const globalClineRulesFilePath = await ensureRulesDirectoryExists()
+	const updatedGlobalToggles = await synchronizeRuleToggles(globalClineRulesFilePath, globalClineRulesToggles)
+	controller.stateManager.setGlobalState("globalClineRulesToggles", updatedGlobalToggles)
+
+	// Local toggles
+	const localClineRulesToggles = controller.stateManager.getWorkspaceStateKey("localClineRulesToggles")
+	const localClineRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.clineRules)
+	const updatedLocalToggles = await synchronizeRuleToggles(localClineRulesFilePath, localClineRulesToggles, "", [
+		[".clinerules", "workflows"],
+		[".clinerules", "hooks"],
+		[".clinerules", "skills"],
+	])
+	controller.stateManager.setWorkspaceState("localClineRulesToggles", updatedLocalToggles)
+
+	return {
+		globalToggles: updatedGlobalToggles,
+		localToggles: updatedLocalToggles,
+	}
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/external-rules.ts b/apps/vscode/src/core/context/instructions/user-instructions/external-rules.ts
new file mode 100644
index 0000000..4f5c72d
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/external-rules.ts
@@ -0,0 +1,49 @@
+import { combineRuleToggles, synchronizeRuleToggles } from "@core/context/instructions/user-instructions/rule-helpers"
+import { GlobalFileNames } from "@core/storage/disk"
+import { ClineRulesToggles } from "@shared/cline-rules"
+import path from "path"
+import { Controller } from "@/core/controller"
+
+/**
+ * Refreshes the toggles for windsurf, cursor, and agents rules
+ */
+export async function refreshExternalRulesToggles(
+	controller: Controller,
+	workingDirectory: string,
+): Promise<{
+	windsurfLocalToggles: ClineRulesToggles
+	cursorLocalToggles: ClineRulesToggles
+	agentsLocalToggles: ClineRulesToggles
+}> {
+	// local windsurf toggles
+	const localWindsurfRulesToggles = controller.stateManager.getWorkspaceStateKey("localWindsurfRulesToggles")
+	const localWindsurfRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.windsurfRules)
+	const updatedLocalWindsurfToggles = await synchronizeRuleToggles(localWindsurfRulesFilePath, localWindsurfRulesToggles)
+	controller.stateManager.setWorkspaceState("localWindsurfRulesToggles", updatedLocalWindsurfToggles)
+
+	// local cursor toggles
+	const localCursorRulesToggles = controller.stateManager.getWorkspaceStateKey("localCursorRulesToggles")
+
+	// cursor has two valid locations for rules files, so we need to check both and combine
+	// synchronizeRuleToggles will drop whichever rules files are not in each given path, but combining the results will result in no data loss
+	let localCursorRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.cursorRulesDir)
+	const updatedLocalCursorToggles1 = await synchronizeRuleToggles(localCursorRulesFilePath, localCursorRulesToggles, ".mdc")
+
+	localCursorRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.cursorRulesFile)
+	const updatedLocalCursorToggles2 = await synchronizeRuleToggles(localCursorRulesFilePath, localCursorRulesToggles)
+
+	const updatedLocalCursorToggles = combineRuleToggles(updatedLocalCursorToggles1, updatedLocalCursorToggles2)
+	controller.stateManager.setWorkspaceState("localCursorRulesToggles", updatedLocalCursorToggles)
+
+	// local agents toggles
+	const localAgentsRulesToggles = controller.stateManager.getWorkspaceStateKey("localAgentsRulesToggles")
+	const localAgentsRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.agentsRulesFile)
+	const updatedLocalAgentsToggles = await synchronizeRuleToggles(localAgentsRulesFilePath, localAgentsRulesToggles)
+	controller.stateManager.setWorkspaceState("localAgentsRulesToggles", updatedLocalAgentsToggles)
+
+	return {
+		windsurfLocalToggles: updatedLocalWindsurfToggles,
+		cursorLocalToggles: updatedLocalCursorToggles,
+		agentsLocalToggles: updatedLocalAgentsToggles,
+	}
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/frontmatter.ts b/apps/vscode/src/core/context/instructions/user-instructions/frontmatter.ts
new file mode 100644
index 0000000..2d2d2c7
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/frontmatter.ts
@@ -0,0 +1,53 @@
+import * as yaml from "js-yaml"
+
+export type FrontmatterParseResult = {
+	data: Record<string, unknown>
+	/**
+	 * The markdown content after stripping the `--- frontmatter ---` block.
+	 *
+	 * Named `body` (rather than `content`) to make it clear this is the remaining
+	 * document body and to keep this helper generic for multiple consumers.
+	 */
+	body: string
+
+	/**
+	 * True when the input contained a frontmatter block, even if parsing failed.
+	 *
+	 * This allows callers to distinguish:
+	 * - "no frontmatter provided" (baseline behavior), vs
+	 * - "frontmatter was provided" (may have semantic meaning in future consumers).
+	 */
+	hadFrontmatter: boolean
+	/**
+	 * Present only when YAML frontmatter was detected but failed to parse.
+	 *
+	 * This helper is intentionally fail-open and does not log. Returning `parseError`
+	 * lets each caller decide whether to log, surface diagnostics, etc.
+	 */
+	parseError?: string
+}
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ *
+ * Behavior is intentionally fail-open:
+ * - If YAML fails to parse, returns data={} and body=original markdown.
+ * - If no frontmatter exists, returns data={} and body=original markdown.
+ */
+export function parseYamlFrontmatter(markdown: string): FrontmatterParseResult {
+	const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/
+	const match = markdown.match(frontmatterRegex)
+
+	if (!match) {
+		return { data: {}, body: markdown, hadFrontmatter: false }
+	}
+
+	const [, yamlContent, body] = match
+	try {
+		const data = (yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA }) as Record<string, unknown>) || {}
+		return { data, body, hadFrontmatter: true }
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		return { data: {}, body: markdown, hadFrontmatter: true, parseError: message }
+	}
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/rule-conditionals.ts b/apps/vscode/src/core/context/instructions/user-instructions/rule-conditionals.ts
new file mode 100644
index 0000000..ca79e8e
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/rule-conditionals.ts
@@ -0,0 +1,153 @@
+/**
+ * Rule frontmatter conditional evaluation.
+ *
+ * This module implements a small conditional "DSL" for Cline Rules YAML frontmatter.
+ * It is used to decide whether a rule should be activated for a given request context.
+ *
+ * Notes:
+ * - Unknown conditional keys are ignored for forward compatibility.
+ * - The `paths` conditional matches if any candidate path matches any glob pattern.
+ * - Candidate paths are expected to be workspace-root-relative POSIX paths.
+ */
+import picomatch from "picomatch"
+
+export type RuleEvaluationContext = {
+	/**
+	 * Candidate workspace-relative paths that represent the current request context.
+	 * These should be POSIX-style paths, relative to their workspace root.
+	 */
+	paths?: string[]
+}
+
+type MatchedConditions = Record<string, string[]>
+
+type ConditionalEvaluatorResult = {
+	passed: boolean
+	matched?: string[]
+}
+
+type ConditionalEvaluatorWithMatch = (frontmatterValue: unknown, context: RuleEvaluationContext) => ConditionalEvaluatorResult
+
+function toPosix(p: string): string {
+	return p.replace(/\\/g, "/")
+}
+
+function isNonEmptyStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every((v) => typeof v === "string" && v.length > 0)
+}
+
+const evaluatePathsConditional: ConditionalEvaluatorWithMatch = (frontmatterValue: unknown, context: RuleEvaluationContext) => {
+	// Invalid type -> ignore conditional (fail-open)
+	if (!isNonEmptyStringArray(frontmatterValue)) {
+		return { passed: true }
+	}
+
+	const patterns = frontmatterValue.map((p) => p.trim()).filter(Boolean)
+
+	// Policy:
+	// - `paths` omitted => universal (because this evaluator is never invoked)
+	// - `paths: []` (or `paths` that trims to no usable patterns) => match nothing (fail-closed)
+	//   This gives users an explicit way to disable a rule via frontmatter, while omission
+	//   remains the mechanism for "always on" rules.
+	if (patterns.length === 0) {
+		return { passed: false }
+	}
+
+	const candidatePaths = (context.paths || []).map((p) => toPosix(p)).filter(Boolean)
+	// Conservative: no evidence => do not activate path-scoped rules
+	if (candidatePaths.length === 0) {
+		return { passed: false }
+	}
+
+	const matchedPatterns: string[] = []
+
+	for (const pattern of patterns) {
+		const matcher = picomatch(pattern, { dot: true })
+		if (candidatePaths.some((candidate) => matcher(candidate))) {
+			matchedPatterns.push(pattern)
+		}
+	}
+
+	return { passed: matchedPatterns.length > 0, matched: matchedPatterns.length > 0 ? matchedPatterns : undefined }
+}
+
+const conditionalEvaluators: Record<string, ConditionalEvaluatorWithMatch> = {
+	paths: evaluatePathsConditional,
+}
+
+export function evaluateRuleConditionals(
+	frontmatter: Record<string, unknown>,
+	context: RuleEvaluationContext,
+): {
+	passed: boolean
+	matchedConditions: MatchedConditions
+} {
+	const matchedConditions: MatchedConditions = {}
+
+	for (const [key, value] of Object.entries(frontmatter)) {
+		const evaluator = conditionalEvaluators[key]
+		if (!evaluator) {
+			continue // unknown conditional: ignore
+		}
+
+		const result = evaluator(value, context)
+		if (!result.passed) {
+			return { passed: false, matchedConditions: {} }
+		}
+		if (result.matched && result.matched.length > 0) {
+			matchedConditions[key] = result.matched
+		}
+	}
+
+	return { passed: true, matchedConditions }
+}
+
+/**
+ * Extracts path-like strings from user text to help enable first-turn activation.
+ * This is intentionally heuristic and conservative.
+ */
+export function extractPathLikeStrings(text: string): string[] {
+	if (!text) return []
+
+	// 0) Strip fenced code blocks to avoid extracting paths from pasted code.
+	// This dramatically reduces false positives from snippets containing `foo/bar` or `a.b.c`.
+	// Note: We intentionally keep this simple and fail-open (if fences are unbalanced, we do nothing special).
+	const withoutCodeFences = text.replace(/```[\s\S]*?```/g, " ")
+
+	// 1) Remove URLs to avoid false positives.
+	const withoutUrls = withoutCodeFences.replace(/\b\w+:\/\/[^\s]+/g, " ")
+
+	// 2) Match tokens that look like paths.
+	//    - Either contain at least one slash (e.g. src/index.ts)
+	//    - Or look like a simple filename with an extension (e.g. foo.md)
+	//      (no slashes; conservative to reduce false positives).
+	const tokenRegex =
+		/(?:^|[\s([{"'`])((?:[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+\/?|[A-Za-z0-9_.-]+\.[A-Za-z0-9]{1,10}))(?=$|[\s)\]}"'`,.;:!?])/g
+	const matches: string[] = []
+	let match: RegExpExecArray | null
+	while ((match = tokenRegex.exec(withoutUrls))) {
+		const candidate = match[1]
+		if (!candidate) continue
+		// Normalize away leading ./
+		const normalized = candidate.startsWith("./") ? candidate.slice(2) : candidate
+		// Avoid absurdly long tokens
+		if (normalized.length > 300) continue
+		matches.push(normalized)
+	}
+
+	// De-dupe while preserving order
+	const seen = new Set<string>()
+	const result: string[] = []
+	for (const m of matches) {
+		const posix = m.replace(/\\/g, "/")
+		if (posix === "/" || posix.startsWith("/") || posix.includes("..")) {
+			// We only want repo/workspace-relative hints here.
+			continue
+		}
+		if (!seen.has(posix)) {
+			seen.add(posix)
+			result.push(posix)
+		}
+	}
+	return result
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/rule-helpers.ts b/apps/vscode/src/core/context/instructions/user-instructions/rule-helpers.ts
new file mode 100644
index 0000000..5b62e74
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/rule-helpers.ts
@@ -0,0 +1,467 @@
+import { ClineRulesToggles } from "@shared/cline-rules"
+import { GlobalInstructionsFile } from "@shared/remote-config/schema"
+import { fileExistsAtPath, isDirectory, readDirectory } from "@utils/fs"
+import fs from "fs/promises"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+import { parseYamlFrontmatter } from "./frontmatter"
+import { evaluateRuleConditionals, RuleEvaluationContext } from "./rule-conditionals"
+
+/**
+ * Recursively traverses directory and finds all files, including checking for optional whitelisted file extension
+ */
+async function readDirectoryRecursive(
+	directoryPath: string,
+	allowedFileExtension: string,
+	excludedPaths: string[][] = [],
+): Promise<string[]> {
+	try {
+		const entries = await readDirectory(directoryPath, excludedPaths)
+		const results: string[] = []
+		for (const entry of entries) {
+			if (allowedFileExtension !== "") {
+				const fileExtension = path.extname(entry)
+				if (fileExtension !== allowedFileExtension) {
+					continue
+				}
+			}
+			results.push(entry)
+		}
+		return results
+	} catch (error) {
+		Logger.error(`Error reading directory ${directoryPath}: ${error}`)
+		return []
+	}
+}
+
+/**
+ * Gets the up to date toggles
+ */
+export async function synchronizeRuleToggles(
+	rulesDirectoryPath: string,
+	currentToggles: ClineRulesToggles,
+	allowedFileExtension = "",
+	excludedPaths: string[][] = [],
+): Promise<ClineRulesToggles> {
+	// Create a copy of toggles to modify
+	const updatedToggles = { ...currentToggles }
+
+	try {
+		const pathExists = await fileExistsAtPath(rulesDirectoryPath)
+
+		if (pathExists) {
+			const isDir = await isDirectory(rulesDirectoryPath)
+
+			if (isDir) {
+				// DIRECTORY CASE
+				const filePaths = await readDirectoryRecursive(rulesDirectoryPath, allowedFileExtension, excludedPaths)
+				const existingRulePaths = new Set<string>()
+
+				for (const filePath of filePaths) {
+					const ruleFilePath = path.resolve(rulesDirectoryPath, filePath)
+					existingRulePaths.add(ruleFilePath)
+
+					const pathHasToggle = ruleFilePath in updatedToggles
+					if (!pathHasToggle) {
+						updatedToggles[ruleFilePath] = true
+					}
+				}
+
+				// Clean up toggles for non-existent files
+				for (const togglePath in updatedToggles) {
+					const pathExists = existingRulePaths.has(togglePath)
+					if (!pathExists) {
+						delete updatedToggles[togglePath]
+					}
+				}
+			} else {
+				// FILE CASE
+				// Add toggle for this file
+				const pathHasToggle = rulesDirectoryPath in updatedToggles
+				if (!pathHasToggle) {
+					updatedToggles[rulesDirectoryPath] = true
+				}
+
+				// Remove toggles for any other paths
+				for (const togglePath in updatedToggles) {
+					if (togglePath !== rulesDirectoryPath) {
+						delete updatedToggles[togglePath]
+					}
+				}
+			}
+		} else {
+			// PATH DOESN'T EXIST CASE
+			// Clear all toggles since the path doesn't exist
+			for (const togglePath in updatedToggles) {
+				delete updatedToggles[togglePath]
+			}
+		}
+	} catch (error) {
+		Logger.error(`Failed to synchronize rule toggles for path: ${rulesDirectoryPath}`, error)
+	}
+
+	return updatedToggles
+}
+
+/**
+ * Synchronizes remote rule toggles with current remote config
+ * Removes toggles for rules that no longer exist, adds defaults for new rules
+ */
+export function synchronizeRemoteRuleToggles(
+	remoteRules: GlobalInstructionsFile[],
+	currentToggles: ClineRulesToggles,
+): ClineRulesToggles {
+	const updatedToggles: ClineRulesToggles = {}
+
+	// Create set of current remote rule names
+	const existingRuleNames = new Set(remoteRules.map((rule) => rule.name))
+
+	// Keep toggles only for rules that still exist
+	for (const [ruleName, enabled] of Object.entries(currentToggles)) {
+		if (existingRuleNames.has(ruleName)) {
+			updatedToggles[ruleName] = enabled
+		}
+	}
+
+	// Add default toggles for new rules (default to enabled)
+	for (const rule of remoteRules) {
+		if (!(rule.name in updatedToggles)) {
+			updatedToggles[rule.name] = true
+		}
+	}
+
+	return updatedToggles
+}
+
+/**
+ * Certain project rules have more than a single location where rules are allowed to be stored
+ */
+export function combineRuleToggles(toggles1: ClineRulesToggles, toggles2: ClineRulesToggles): ClineRulesToggles {
+	return { ...toggles1, ...toggles2 }
+}
+
+/**
+ * Read the content of rules files
+ */
+const getRuleFilesTotalContent = async (rulesFilePaths: string[], basePath: string, toggles: ClineRulesToggles) => {
+	return (await getRuleFilesTotalContentWithMetadata(rulesFilePaths, basePath, toggles)).content
+}
+
+const LOCAL_RULE_PATHS = {
+	clineRules: ".clinerules",
+	workflows: ".clinerules/workflows",
+} as const
+
+type ActivatedConditionalRule = {
+	name: string
+	matchedConditions: Record<string, string[]>
+}
+
+type RuleFileController = {
+	stateManager: {
+		getGlobalSettingsKey(key: "globalWorkflowToggles" | "globalClineRulesToggles"): ClineRulesToggles
+		setGlobalState(key: "globalWorkflowToggles" | "globalClineRulesToggles", value: ClineRulesToggles): void
+		getWorkspaceStateKey(
+			key:
+				| "workflowToggles"
+				| "localCursorRulesToggles"
+				| "localWindsurfRulesToggles"
+				| "localAgentsRulesToggles"
+				| "localClineRulesToggles",
+		): ClineRulesToggles
+		setWorkspaceState(
+			key:
+				| "workflowToggles"
+				| "localCursorRulesToggles"
+				| "localWindsurfRulesToggles"
+				| "localAgentsRulesToggles"
+				| "localClineRulesToggles",
+			value: ClineRulesToggles,
+		): void
+	}
+}
+
+// Prefixes used to make activated conditional rule identifiers self-explanatory in the UI.
+// NOTE: These are display identifiers (not toggle keys).
+export const RULE_SOURCE_PREFIX = {
+	workspace: "workspace",
+	global: "global",
+	remote: "remote",
+} as const
+
+export type RuleLoadResult = {
+	content: string
+	activatedConditionalRules: ActivatedConditionalRule[]
+}
+
+/**
+ * Result type for rule loading functions that return formatted instructions.
+ * Used by getGlobalClineRules and getLocalClineRules.
+ */
+type RuleLoadResultWithInstructions = {
+	instructions?: string
+	activatedConditionalRules: ActivatedConditionalRule[]
+}
+
+export const getRuleFilesTotalContentWithMetadata = async (
+	rulesFilePaths: string[],
+	basePath: string,
+	toggles: ClineRulesToggles,
+	opts?: { evaluationContext?: RuleEvaluationContext; ruleNamePrefix?: keyof typeof RULE_SOURCE_PREFIX },
+): Promise<RuleLoadResult> => {
+	const evaluationContext = opts?.evaluationContext ?? {}
+	const prefix = RULE_SOURCE_PREFIX[opts?.ruleNamePrefix ?? "global"]
+
+	const parts = await Promise.all(
+		rulesFilePaths.map(async (filePath) => {
+			const ruleFilePath = path.resolve(basePath, filePath)
+			const ruleFilePathRelative = path.relative(basePath, ruleFilePath)
+
+			if (ruleFilePath in toggles && toggles[ruleFilePath] === false) {
+				return { contentPart: null, activatedRule: null }
+			}
+
+			const raw = (await fs.readFile(ruleFilePath, "utf8")).trim()
+			if (!raw) {
+				return { contentPart: null, activatedRule: null }
+			}
+			const { data, body, hadFrontmatter, parseError } = parseYamlFrontmatter(raw)
+			// YAML parse errors are treated as fail-open.
+			// NOTE: We intentionally preserve the raw frontmatter fence/content here so the LLM can still
+			// see the author's intended scoping (e.g., `paths:`) and reason about it, even if it cannot be
+			// evaluated reliably due to invalid YAML.
+			if (hadFrontmatter && parseError) {
+				return { contentPart: `${ruleFilePathRelative}\n${raw}`, activatedRule: null }
+			}
+
+			const { passed, matchedConditions } = evaluateRuleConditionals(data, evaluationContext)
+			if (!passed) {
+				return { contentPart: null, activatedRule: null }
+			}
+			const activatedRule =
+				hadFrontmatter && Object.keys(matchedConditions).length > 0
+					? { name: `${prefix}:${ruleFilePathRelative}`, matchedConditions }
+					: null
+
+			return { contentPart: `${ruleFilePathRelative}\n${body.trim()}`, activatedRule }
+		}),
+	)
+
+	return {
+		content: parts
+			.map((p) => p.contentPart)
+			.filter(Boolean)
+			.join("\n\n"),
+		activatedConditionalRules: parts
+			.map((p) => p.activatedRule)
+			.filter((rule): rule is ActivatedConditionalRule => rule !== null),
+	}
+}
+
+function getRemoteRulesTotalContentWithMetadata(
+	remoteRules: GlobalInstructionsFile[],
+	remoteToggles: ClineRulesToggles,
+	opts?: { evaluationContext?: RuleEvaluationContext },
+): RuleLoadResult {
+	const activatedConditionalRules: ActivatedConditionalRule[] = []
+	const evaluationContext = opts?.evaluationContext ?? {}
+	let combinedContent = ""
+
+	for (const rule of remoteRules) {
+		const isEnabled = rule.alwaysEnabled || remoteToggles[rule.name] !== false
+		if (!isEnabled) continue
+
+		const raw = (rule.contents || "").trim()
+		if (!raw) continue
+
+		const { data, body, hadFrontmatter, parseError } = parseYamlFrontmatter(raw)
+		if (hadFrontmatter && parseError) {
+			// Fail open: include entire raw contents
+			if (combinedContent) combinedContent += "\n\n"
+			combinedContent += `${rule.name}\n${raw}`
+			continue
+		}
+
+		const { passed, matchedConditions } = evaluateRuleConditionals(data, evaluationContext)
+		if (!passed) continue
+
+		if (hadFrontmatter && Object.keys(matchedConditions).length > 0) {
+			activatedConditionalRules.push({ name: `${RULE_SOURCE_PREFIX.remote}:${rule.name}`, matchedConditions })
+		}
+
+		if (combinedContent) combinedContent += "\n\n"
+		combinedContent += `${rule.name}\n${body.trim()}`
+	}
+
+	return { content: combinedContent, activatedConditionalRules }
+}
+
+/**
+ * Handles converting any directory into a file (specifically used for .clinerules and .clinerules/workflows)
+ * The old .clinerules file or .clinerules/workflows file will be renamed to a default filename
+ * Doesn't do anything if the dir already exists or doesn't exist
+ * Returns whether there are any uncaught errors
+ */
+async function ensureLocalClineDirExists(clinerulePath: string, defaultRuleFilename: string): Promise<boolean> {
+	try {
+		const exists = await fileExistsAtPath(clinerulePath)
+
+		if (exists && !(await isDirectory(clinerulePath))) {
+			// logic to convert .clinerules file into directory, and rename the rules file to {defaultRuleFilename}
+			const content = await fs.readFile(clinerulePath, "utf8")
+			const tempPath = clinerulePath + ".bak"
+			await fs.rename(clinerulePath, tempPath) // create backup
+			try {
+				await fs.mkdir(clinerulePath, { recursive: true })
+				await fs.writeFile(path.join(clinerulePath, defaultRuleFilename), content, "utf8")
+				await fs.unlink(tempPath).catch(() => {}) // delete backup
+
+				return false // conversion successful with no errors
+			} catch (_conversionError) {
+				// attempt to restore backup on conversion failure
+				try {
+					await fs.rm(clinerulePath, { recursive: true, force: true }).catch(() => {})
+					await fs.rename(tempPath, clinerulePath) // restore backup
+				} catch (_restoreError) {}
+				return true // in either case here we consider this an error
+			}
+		}
+		// exists and is a dir or doesn't exist, either of these cases we dont need to handle here
+		return false
+	} catch (_error) {
+		return true
+	}
+}
+
+/**
+ * Create a rule file or workflow file
+ */
+export const createRuleFile = async (isGlobal: boolean, filename: string, cwd: string, type: string) => {
+	try {
+		let filePath: string
+		if (isGlobal) {
+			const disk = require("@core/storage/disk") as {
+				ensureWorkflowsDirectoryExists: () => Promise<string>
+				ensureRulesDirectoryExists: () => Promise<string>
+			}
+			if (type === "workflow") {
+				const globalClineWorkflowFilePath = await disk.ensureWorkflowsDirectoryExists()
+				filePath = path.join(globalClineWorkflowFilePath, filename)
+			} else {
+				const globalClineRulesFilePath = await disk.ensureRulesDirectoryExists()
+				filePath = path.join(globalClineRulesFilePath, filename)
+			}
+		} else {
+			const localClineRulesFilePath = path.resolve(cwd, LOCAL_RULE_PATHS.clineRules)
+
+			const hasError = await ensureLocalClineDirExists(localClineRulesFilePath, "default-rules.md")
+			if (hasError === true) {
+				return { filePath: null, fileExists: false }
+			}
+
+			await fs.mkdir(localClineRulesFilePath, { recursive: true })
+
+			if (type === "workflow") {
+				const localWorkflowsFilePath = path.resolve(cwd, LOCAL_RULE_PATHS.workflows)
+
+				const hasError = await ensureLocalClineDirExists(localWorkflowsFilePath, "default-workflows.md")
+				if (hasError === true) {
+					return { filePath: null, fileExists: false }
+				}
+
+				await fs.mkdir(localWorkflowsFilePath, { recursive: true })
+
+				filePath = path.join(localWorkflowsFilePath, filename)
+			} else {
+				// clinerules file creation
+				filePath = path.join(localClineRulesFilePath, filename)
+			}
+		}
+
+		const fileExists = await fileExistsAtPath(filePath)
+
+		if (fileExists) {
+			return { filePath, fileExists }
+		}
+
+		await fs.writeFile(filePath, "", "utf8")
+
+		return { filePath, fileExists: false }
+	} catch (_error) {
+		return { filePath: null, fileExists: false }
+	}
+}
+
+/**
+ * Delete a rule file or workflow file
+ */
+export async function deleteRuleFile(
+	controller: RuleFileController,
+	rulePath: string,
+	isGlobal: boolean,
+	type: string,
+): Promise<{ success: boolean; message: string }> {
+	try {
+		// Check if file exists
+		const fileExists = await fileExistsAtPath(rulePath)
+		if (!fileExists) {
+			return {
+				success: false,
+				message: `File does not exist: ${rulePath}`,
+			}
+		}
+
+		// Delete the file from disk
+		await fs.rm(rulePath, { force: true })
+
+		// Get the filename for messages
+		const fileName = path.basename(rulePath)
+
+		// Update the appropriate toggles
+		if (isGlobal) {
+			if (type === "workflow") {
+				const toggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setGlobalState("globalWorkflowToggles", toggles)
+			} else {
+				const toggles = controller.stateManager.getGlobalSettingsKey("globalClineRulesToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setGlobalState("globalClineRulesToggles", toggles)
+			}
+		} else {
+			if (type === "workflow") {
+				const toggles = controller.stateManager.getWorkspaceStateKey("workflowToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setWorkspaceState("workflowToggles", toggles)
+			} else if (type === "cursor") {
+				const toggles = controller.stateManager.getWorkspaceStateKey("localCursorRulesToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setWorkspaceState("localCursorRulesToggles", toggles)
+			} else if (type === "windsurf") {
+				const toggles = controller.stateManager.getWorkspaceStateKey("localWindsurfRulesToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setWorkspaceState("localWindsurfRulesToggles", toggles)
+			} else if (type === "agents") {
+				const toggles = controller.stateManager.getWorkspaceStateKey("localAgentsRulesToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setWorkspaceState("localAgentsRulesToggles", toggles)
+			} else {
+				const toggles = controller.stateManager.getWorkspaceStateKey("localClineRulesToggles")
+				delete toggles[rulePath]
+				controller.stateManager.setWorkspaceState("localClineRulesToggles", toggles)
+			}
+		}
+
+		return {
+			success: true,
+			message: `File "${fileName}" deleted successfully`,
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		Logger.error(`Error deleting file: ${errorMessage}`, error)
+		return {
+			success: false,
+			message: `Failed to delete file.`,
+		}
+	}
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/skills.ts b/apps/vscode/src/core/context/instructions/user-instructions/skills.ts
new file mode 100644
index 0000000..c10c65b
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/skills.ts
@@ -0,0 +1,313 @@
+import { getSkillsDirectoriesForScan } from "@core/storage/skill-directories"
+import type { GlobalInstructionsFile } from "@shared/remote-config/schema"
+import type { SkillContent, SkillMetadata } from "@shared/skills"
+import { fileExistsAtPath, isDirectory } from "@utils/fs"
+import * as fs from "fs/promises"
+import * as yaml from "js-yaml"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+import { parseYamlFrontmatter } from "./frontmatter"
+
+/**
+ * Update the `disabled` frontmatter flag of a SKILL.md document.
+ *
+ * The SDK (which builds the model's skill list and the `skills` tool) reads a
+ * skill's enabled state from the SKILL.md frontmatter `disabled` field, not from
+ * the extension's UI toggle state. Toggling a skill in the VS Code sidebar must
+ * therefore also write this flag so the change is reflected for the model
+ * (ENG-1995). This mirrors the SDK's updateSkillMarkdownEnabledState but lives in
+ * the extension and uses js-yaml (the extension's frontmatter parser).
+ *
+ * - enabled=false → sets `disabled: true`.
+ * - enabled=true  → removes `disabled` (and a stale `enabled: false`), dropping
+ *   the frontmatter block entirely if it becomes empty.
+ *
+ * Returns the original content unchanged when enabling a document that has no
+ * frontmatter (nothing to clear).
+ */
+export function updateSkillMarkdownDisabledState(content: string, enabled: boolean): string {
+	const { data, body, hadFrontmatter, parseError } = parseYamlFrontmatter(content)
+
+	if (!hadFrontmatter && enabled) {
+		return content
+	}
+
+	// parseYamlFrontmatter fails open on malformed YAML: it returns data={} and
+	// body=<full original content> (frontmatter block included). Serializing here
+	// would prepend a second `---` block and corrupt the file, so leave it
+	// untouched and let the user fix the frontmatter.
+	if (parseError) {
+		return content
+	}
+
+	if (enabled) {
+		delete data.disabled
+		if (data.enabled === false) {
+			delete data.enabled
+		}
+		if (Object.keys(data).length === 0) {
+			return body
+		}
+		return serializeSkillFrontmatter(data, body)
+	}
+
+	data.disabled = true
+	return serializeSkillFrontmatter(data, body)
+}
+
+function serializeSkillFrontmatter(data: Record<string, unknown>, body: string): string {
+	const yamlText = yaml.dump(data, { schema: yaml.JSON_SCHEMA }).trimEnd()
+	return `---\n${yamlText}\n---\n${body}`
+}
+
+/**
+ * Persist a skill's enabled/disabled state to its SKILL.md frontmatter on disk.
+ * No-op (returns false) for remote skills, which have no backing file.
+ */
+export async function setSkillDisabledInFrontmatter(skillMdPath: string, enabled: boolean): Promise<boolean> {
+	if (!skillMdPath || skillMdPath.startsWith("remote:")) {
+		return false
+	}
+	try {
+		const content = await fs.readFile(skillMdPath, "utf-8")
+		const updated = updateSkillMarkdownDisabledState(content, enabled)
+		if (updated !== content) {
+			await fs.writeFile(skillMdPath, updated)
+		}
+		return true
+	} catch (error) {
+		Logger.warn(`Failed to update skill frontmatter at ${skillMdPath}:`, error)
+		return false
+	}
+}
+
+/**
+ * A remote skill entry after frontmatter validation.
+ * name is always frontmatter.name (canonical). A warning is logged if entry.name drifts.
+ */
+export interface ValidatedRemoteSkill {
+	name: string
+	description: string
+	alwaysEnabled: boolean
+	contents: string
+}
+
+/**
+ * Parse and validate remote skill entries from GlobalInstructionsFile[].
+ *
+ * Validates:
+ *  - frontmatter.name and frontmatter.description are present strings
+ *  - Warns if entry.name does not match frontmatter.name (drift)
+ *
+ * Returns only valid entries. Callers share this single validation point
+ * instead of duplicating frontmatter parsing.
+ */
+export function parseRemoteSkillEntries(entries: GlobalInstructionsFile[]): ValidatedRemoteSkill[] {
+	return entries
+		.map((entry) => {
+			const { data: frontmatter } = parseYamlFrontmatter(entry.contents)
+			if (!frontmatter.name || typeof frontmatter.name !== "string") return null
+			if (!frontmatter.description || typeof frontmatter.description !== "string") return null
+			// Warn on drift but use frontmatter.name as the canonical identity.
+			// The dashboard should keep entry.name in sync, but we don't reject on mismatch
+			// since that would silently hide org-configured skills from users.
+			if (entry.name !== frontmatter.name) {
+				Logger.warn(`Remote skill entry.name "${entry.name}" does not match frontmatter.name "${frontmatter.name}"`)
+			}
+			return {
+				name: frontmatter.name,
+				description: frontmatter.description as string,
+				alwaysEnabled: entry.alwaysEnabled,
+				contents: entry.contents,
+			}
+		})
+		.filter((e): e is NonNullable<typeof e> => e !== null)
+}
+
+/** Parse YAML frontmatter from markdown content (shared helper). */
+function parseFrontmatter(fileContent: string): { data: Record<string, unknown>; content: string } {
+	const result = parseYamlFrontmatter(fileContent)
+	if (result.parseError) {
+		Logger.warn("Failed to parse YAML frontmatter:", result.parseError)
+	}
+	return { data: result.data, content: result.body }
+}
+
+/**
+ * Scan a directory for skill subdirectories containing SKILL.md files.
+ */
+async function scanSkillsDirectory(dirPath: string, source: "global" | "project"): Promise<SkillMetadata[]> {
+	const skills: SkillMetadata[] = []
+
+	if (!(await fileExistsAtPath(dirPath)) || !(await isDirectory(dirPath))) {
+		return skills
+	}
+
+	try {
+		const entries = await fs.readdir(dirPath)
+
+		for (const entryName of entries) {
+			const entryPath = path.join(dirPath, entryName)
+			const stats = await fs.stat(entryPath).catch(() => null)
+			if (!stats?.isDirectory()) continue
+
+			const skill = await loadSkillMetadata(entryPath, source, entryName)
+			if (skill) {
+				skills.push(skill)
+			}
+		}
+	} catch (error: unknown) {
+		if (error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "EACCES") {
+			Logger.warn(`Permission denied reading skills directory: ${dirPath}`)
+		}
+	}
+
+	return skills
+}
+
+/**
+ * Load skill metadata from a skill directory.
+ */
+async function loadSkillMetadata(
+	skillDir: string,
+	source: "global" | "project",
+	skillName: string,
+): Promise<SkillMetadata | null> {
+	const skillMdPath = path.join(skillDir, "SKILL.md")
+	if (!(await fileExistsAtPath(skillMdPath))) return null
+
+	try {
+		const fileContent = await fs.readFile(skillMdPath, "utf-8")
+		const { data: frontmatter } = parseFrontmatter(fileContent)
+
+		// Validate required fields
+		if (!frontmatter.name || typeof frontmatter.name !== "string") {
+			Logger.warn(`Skill at ${skillDir} missing required 'name' field`)
+			return null
+		}
+		if (!frontmatter.description || typeof frontmatter.description !== "string") {
+			Logger.warn(`Skill at ${skillDir} missing required 'description' field`)
+			return null
+		}
+
+		// Name must match directory name per spec
+		if (frontmatter.name !== skillName) {
+			Logger.warn(`Skill name "${frontmatter.name}" doesn't match directory "${skillName}"`)
+			return null
+		}
+
+		return {
+			name: skillName,
+			description: frontmatter.description,
+			path: skillMdPath,
+			source,
+		}
+	} catch (error) {
+		Logger.warn(`Failed to load skill at ${skillDir}:`, error)
+		return null
+	}
+}
+
+/**
+ * Discover all skills from global (~/.cline/skills), remote config, and project directories.
+ *
+ * Precedence (highest wins on name collision via getAvailableSkills):
+ *   remote (enterprise) > disk-global (user personal) > project (workspace)
+ *
+ * This is achieved by the array order + getAvailableSkills iterating in reverse (last wins):
+ *   [project..., disk-global..., remote...]
+ */
+export async function discoverSkills(cwd: string, remoteSkillEntries?: GlobalInstructionsFile[]): Promise<SkillMetadata[]> {
+	const skills: SkillMetadata[] = []
+
+	const scanDirs = getSkillsDirectoriesForScan(cwd)
+
+	// Collect project and disk-global skills separately so we can insert remote between them
+	const projectSkills: SkillMetadata[] = []
+	const diskGlobalSkills: SkillMetadata[] = []
+
+	for (const dir of scanDirs) {
+		const dirSkills = await scanSkillsDirectory(dir.path, dir.source)
+		if (dir.source === "project") {
+			projectSkills.push(...dirSkills)
+		} else {
+			diskGlobalSkills.push(...dirSkills)
+		}
+	}
+
+	// Remote skills: validated via parseRemoteSkillEntries and keyed by frontmatter.name.
+	const remoteSkills: SkillMetadata[] = parseRemoteSkillEntries(remoteSkillEntries || []).map((entry) => ({
+		name: entry.name,
+		description: entry.description,
+		path: `remote:${entry.name}`,
+		source: "global" as const,
+	}))
+
+	// Insert in order: project → disk-global → remote
+	// getAvailableSkills iterates backwards so remote (last) wins, then disk-global, then project
+	skills.push(...projectSkills, ...diskGlobalSkills, ...remoteSkills)
+
+	return skills
+}
+
+/**
+ * Get available skills with override resolution (global > project).
+ */
+export function getAvailableSkills(skills: SkillMetadata[]): SkillMetadata[] {
+	const seen = new Set<string>()
+	const result: SkillMetadata[] = []
+
+	// Iterate backwards: global skills (added last) are seen first and take precedence
+	for (let i = skills.length - 1; i >= 0; i--) {
+		const skill = skills[i]
+		if (!seen.has(skill.name)) {
+			seen.add(skill.name)
+			result.unshift(skill)
+		}
+	}
+
+	return result
+}
+
+/**
+ * Get full skill content including instructions.
+ * For remote skills, pass remoteSkillEntries so content can be loaded without disk I/O.
+ */
+export async function getSkillContent(
+	skillName: string,
+	availableSkills: SkillMetadata[],
+	remoteSkillEntries?: GlobalInstructionsFile[],
+): Promise<SkillContent | null> {
+	const skill = availableSkills.find((s) => s.name === skillName)
+	if (!skill) return null
+
+	// Remote skills have no file on disk — retrieve content from the provided entries.
+	// Try entry.name first (fast path when dashboard is in sync), fall back to frontmatter match.
+	if (skill.path.startsWith("remote:")) {
+		let entry = (remoteSkillEntries || []).find((e) => e.name === skillName)
+		if (!entry) {
+			entry = (remoteSkillEntries || []).find((e) => {
+				const { data } = parseYamlFrontmatter(e.contents)
+				return typeof data.name === "string" && data.name === skillName
+			})
+		}
+		if (!entry) return null
+		const { body } = parseYamlFrontmatter(entry.contents)
+		return {
+			...skill,
+			instructions: body.trim(),
+		}
+	}
+
+	try {
+		const fileContent = await fs.readFile(skill.path, "utf-8")
+		const { content: body } = parseFrontmatter(fileContent)
+
+		return {
+			...skill,
+			instructions: body.trim(),
+		}
+	} catch {
+		return null
+	}
+}
diff --git a/apps/vscode/src/core/context/instructions/user-instructions/workflows.ts b/apps/vscode/src/core/context/instructions/user-instructions/workflows.ts
new file mode 100644
index 0000000..f743946
--- /dev/null
+++ b/apps/vscode/src/core/context/instructions/user-instructions/workflows.ts
@@ -0,0 +1,32 @@
+import { synchronizeRuleToggles } from "@core/context/instructions/user-instructions/rule-helpers"
+import { ensureWorkflowsDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import { ClineRulesToggles } from "@shared/cline-rules"
+import path from "path"
+import { Controller } from "@/core/controller"
+
+/**
+ * Refresh the workflow toggles
+ */
+export async function refreshWorkflowToggles(
+	controller: Controller,
+	workingDirectory: string,
+): Promise<{
+	globalWorkflowToggles: ClineRulesToggles
+	localWorkflowToggles: ClineRulesToggles
+}> {
+	// Global workflows
+	const globalWorkflowToggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles")
+	const globalClineWorkflowsFilePath = await ensureWorkflowsDirectoryExists()
+	const updatedGlobalWorkflowToggles = await synchronizeRuleToggles(globalClineWorkflowsFilePath, globalWorkflowToggles)
+	controller.stateManager.setGlobalState("globalWorkflowToggles", updatedGlobalWorkflowToggles)
+
+	const workflowRulesToggles = controller.stateManager.getWorkspaceStateKey("workflowToggles")
+	const workflowsDirPath = path.resolve(workingDirectory, GlobalFileNames.workflows)
+	const updatedWorkflowToggles = await synchronizeRuleToggles(workflowsDirPath, workflowRulesToggles)
+	controller.stateManager.setWorkspaceState("workflowToggles", updatedWorkflowToggles)
+
+	return {
+		globalWorkflowToggles: updatedGlobalWorkflowToggles,
+		localWorkflowToggles: updatedWorkflowToggles,
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/accountLoginClicked.ts b/apps/vscode/src/core/controller/account/accountLoginClicked.ts
new file mode 100644
index 0000000..4782f4b
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/accountLoginClicked.ts
@@ -0,0 +1,15 @@
+import { EmptyRequest, String } from "@shared/proto/cline/common"
+import { AuthService } from "@/sdk/auth-service"
+import { Controller } from "../index"
+
+/**
+ * Handles the user clicking the login link in the UI.
+ * Uses the SDK-backed AuthService to initiate the Cline OAuth flow.
+ * The SDK spawns a local callback server and opens the browser.
+ *
+ * @param controller The controller instance.
+ * @returns The login URL as a string.
+ */
+export async function accountLoginClicked(_controller: Controller, _: EmptyRequest): Promise<String> {
+	return await AuthService.getInstance().createAuthRequest()
+}
diff --git a/apps/vscode/src/core/controller/account/accountLogoutClicked.ts b/apps/vscode/src/core/controller/account/accountLogoutClicked.ts
new file mode 100644
index 0000000..bed6b75
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/accountLogoutClicked.ts
@@ -0,0 +1,15 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import type { Controller } from "../index"
+
+/**
+ * Handles the account logout action.
+ * Delegates to the SdkController which uses the SDK-backed AuthService.
+ * @param controller The controller instance
+ * @param _request The empty request object
+ * @returns Empty response
+ */
+export async function accountLogoutClicked(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	await controller.handleSignOut()
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/core/controller/account/authStateChanged.ts b/apps/vscode/src/core/controller/account/authStateChanged.ts
new file mode 100644
index 0000000..afedc5d
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/authStateChanged.ts
@@ -0,0 +1,23 @@
+import { AuthState, AuthStateChangedRequest } from "@shared/proto/cline/account"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Handles authentication state changes from the Firebase context.
+ * Updates the user info in global state and returns the updated value.
+ * @param controller The controller instance
+ * @param request The auth state change request
+ * @returns The updated user info
+ */
+export async function authStateChanged(controller: Controller, request: AuthStateChangedRequest): Promise<AuthState> {
+	try {
+		// Store the user info directly in global state
+		controller.stateManager.setGlobalState("userInfo", request.user)
+
+		// Return the same user info
+		return AuthState.create({ user: request.user })
+	} catch (error) {
+		Logger.error(`Failed to update auth state: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/getOrganizationCredits.ts b/apps/vscode/src/core/controller/account/getOrganizationCredits.ts
new file mode 100644
index 0000000..0554a86
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/getOrganizationCredits.ts
@@ -0,0 +1,57 @@
+import { GetOrganizationCreditsRequest, OrganizationCreditsData, OrganizationUsageTransaction } from "@shared/proto/cline/account"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Handles fetching all organization credits data (balance, usage, payments)
+ * @param controller The controller instance
+ * @param request Organization credits request
+ * @returns Organization credits data response
+ */
+export async function getOrganizationCredits(
+	controller: Controller,
+	request: GetOrganizationCreditsRequest,
+): Promise<OrganizationCreditsData> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		// Call the individual RPC variants in parallel
+		const [balanceData, usageTransactions] = await Promise.all([
+			controller.accountService.fetchOrganizationCreditsRPC(request.organizationId),
+			controller.accountService.fetchOrganizationUsageTransactionsRPC(request.organizationId),
+		])
+
+		// If balance call fails (returns undefined), throw an error
+		if (!balanceData) {
+			throw new Error("Failed to fetch organization credits data")
+		}
+
+		return OrganizationCreditsData.create({
+			balance: balanceData ? { currentBalance: balanceData.balance / 100 } : { currentBalance: 0 },
+			organizationId: balanceData?.organizationId || "",
+			usageTransactions:
+				usageTransactions?.map((tx: any) =>
+					OrganizationUsageTransaction.create({
+						aiInferenceProviderName: tx.aiInferenceProviderName,
+						aiModelName: tx.aiModelName,
+						aiModelTypeName: tx.aiModelTypeName,
+						completionTokens: tx.completionTokens,
+						costUsd: tx.costUsd,
+						createdAt: tx.createdAt,
+						creditsUsed: tx.creditsUsed,
+						generationId: tx.generationId,
+						organizationId: tx.organizationId,
+						promptTokens: tx.promptTokens,
+						totalTokens: tx.totalTokens,
+						userId: tx.userId,
+						operation: tx.operation,
+					}),
+				) || [],
+		})
+	} catch (error) {
+		Logger.error(`Failed to fetch organization credits data: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/getRedirectUrl.ts b/apps/vscode/src/core/controller/account/getRedirectUrl.ts
new file mode 100644
index 0000000..f74af82
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/getRedirectUrl.ts
@@ -0,0 +1,11 @@
+import { EmptyRequest, String } from "@shared/proto/cline/common"
+import { HostProvider } from "@/hosts/host-provider"
+import { Controller } from "../index"
+
+/**
+ * Constructs and returns a URL that will redirect to the user's IDE.
+ */
+export async function getRedirectUrl(_controller: Controller, _: EmptyRequest): Promise<String> {
+	const url = (await HostProvider.env.getIdeRedirectUri({})).value
+	return { value: url }
+}
diff --git a/apps/vscode/src/core/controller/account/getUserCredits.ts b/apps/vscode/src/core/controller/account/getUserCredits.ts
new file mode 100644
index 0000000..dd67639
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/getUserCredits.ts
@@ -0,0 +1,39 @@
+import { UserCreditsData } from "@shared/proto/cline/account"
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Handles fetching all user credits data (balance, usage, payments)
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns User credits data response
+ */
+export async function getUserCredits(controller: Controller, _request: EmptyRequest): Promise<UserCreditsData> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		// Call the individual RPC variants in parallel
+		const [balance, usageTransactions, paymentTransactions] = await Promise.all([
+			controller.accountService.fetchBalanceRPC(),
+			controller.accountService.fetchUsageTransactionsRPC(),
+			controller.accountService.fetchPaymentTransactionsRPC(),
+		])
+
+		// If either call fails (returns undefined), throw an error
+		if (balance === undefined) {
+			throw new Error("Failed to fetch user credits data")
+		}
+
+		return UserCreditsData.create({
+			balance: balance ? { currentBalance: balance.balance / 100 } : { currentBalance: 0 },
+			usageTransactions: usageTransactions,
+			paymentTransactions: paymentTransactions,
+		})
+	} catch (error) {
+		Logger.error(`Failed to fetch user credits data: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/getUserOrganizations.ts b/apps/vscode/src/core/controller/account/getUserOrganizations.ts
new file mode 100644
index 0000000..d159549
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/getUserOrganizations.ts
@@ -0,0 +1,35 @@
+import { UserOrganization, UserOrganizationsResponse } from "@shared/proto/cline/account"
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import type { Controller } from "../index"
+
+/**
+ * Handles fetching all user credits data (balance, usage, payments)
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns User credits data response
+ */
+export async function getUserOrganizations(controller: Controller, _request: EmptyRequest): Promise<UserOrganizationsResponse> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		// Fetch user organizations from the account service
+		const organizations = await controller.accountService.fetchUserOrganizationsRPC()
+
+		return UserOrganizationsResponse.create({
+			organizations:
+				organizations?.map((org: any) =>
+					UserOrganization.create({
+						active: org.active,
+						memberId: org.memberId,
+						name: org.name,
+						organizationId: org.organizationId,
+						roles: org.roles ? [...org.roles] : [],
+					}),
+				) || [],
+		})
+	} catch (error) {
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/hicapAuthClicked.ts b/apps/vscode/src/core/controller/account/hicapAuthClicked.ts
new file mode 100644
index 0000000..43579ae
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/hicapAuthClicked.ts
@@ -0,0 +1,18 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { HostProvider } from "@/hosts/host-provider"
+import { openExternal } from "@/utils/env"
+import { Controller } from ".."
+
+/**
+ * Initiates Hicap auth
+ */
+export async function hicapAuthClicked(_: Controller, __: EmptyRequest): Promise<Empty> {
+	const callbackUrl = await HostProvider.get().getCallbackUrl("/hicap")
+	const authUrl = new URL("https://dashboard.hicap.ai/setup")
+	authUrl.searchParams.set("application", "cline")
+	authUrl.searchParams.set("callback_url", callbackUrl)
+
+	await openExternal(authUrl.toString())
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/account/openAiCodexSignIn.ts b/apps/vscode/src/core/controller/account/openAiCodexSignIn.ts
new file mode 100644
index 0000000..f077d1f
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/openAiCodexSignIn.ts
@@ -0,0 +1,43 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { ShowMessageType } from "@shared/proto/host/window"
+import { HostProvider } from "@/hosts/host-provider"
+import { AuthService } from "@/sdk/auth-service"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Initiates OpenAI Codex OAuth authentication flow.
+ * Uses the SDK-backed AuthService which delegates to @cline/core's
+ * loginOpenAICodex() function.
+ */
+export async function openAiCodexSignIn(controller: Controller, _: EmptyRequest): Promise<Empty> {
+	try {
+		const authService = AuthService.getInstance()
+
+		// Start the OAuth flow in the background
+		authService
+			.openAiCodexLogin()
+			.then(async () => {
+				HostProvider.window.showMessage({
+					type: ShowMessageType.INFORMATION,
+					message: "Successfully signed in to OpenAI Codex",
+				})
+				await controller.postStateToWebview()
+			})
+			.catch((error) => {
+				Logger.error("[openAiCodexSignIn] OAuth flow failed:", error)
+				const errorMessage = error instanceof Error ? error.message : String(error)
+				if (!errorMessage.includes("timed out")) {
+					HostProvider.window.showMessage({
+						type: ShowMessageType.ERROR,
+						message: `OpenAI Codex sign in failed: ${errorMessage}`,
+					})
+				}
+			})
+	} catch (error) {
+		Logger.error("[openAiCodexSignIn] Failed to start OAuth flow:", error)
+		throw error
+	}
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/account/openAiCodexSignOut.ts b/apps/vscode/src/core/controller/account/openAiCodexSignOut.ts
new file mode 100644
index 0000000..753dfdd
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/openAiCodexSignOut.ts
@@ -0,0 +1,23 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { AuthService } from "@/sdk/auth-service"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Signs out of OpenAI Codex by clearing stored credentials.
+ * Uses the SDK-backed AuthService to clear provider settings.
+ */
+export async function openAiCodexSignOut(controller: Controller, _: EmptyRequest): Promise<Empty> {
+	try {
+		// Clear stored credentials via SDK-backed AuthService
+		await AuthService.getInstance().clearCodexCredentials()
+
+		// Update the state to reflect sign out
+		await controller.postStateToWebview()
+	} catch (error) {
+		Logger.error("[openAiCodexSignOut] Failed to sign out:", error)
+		throw error
+	}
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/account/openrouterAuthClicked.ts b/apps/vscode/src/core/controller/account/openrouterAuthClicked.ts
new file mode 100644
index 0000000..ebde0a1
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/openrouterAuthClicked.ts
@@ -0,0 +1,17 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { HostProvider } from "@/hosts/host-provider"
+import { openExternal } from "@/utils/env"
+import { Controller } from ".."
+
+/**
+ * Initiates OpenRouter auth
+ */
+export async function openrouterAuthClicked(_: Controller, __: EmptyRequest): Promise<Empty> {
+	const callbackUrl = await HostProvider.get().getCallbackUrl("/openrouter")
+	const authUrl = new URL("https://openrouter.ai/auth")
+	authUrl.searchParams.set("callback_url", callbackUrl)
+
+	await openExternal(authUrl.toString())
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/account/requestyAuthClicked.ts b/apps/vscode/src/core/controller/account/requestyAuthClicked.ts
new file mode 100644
index 0000000..ede2bee
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/requestyAuthClicked.ts
@@ -0,0 +1,25 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { HostProvider } from "@/hosts/host-provider"
+import { toRequestyServiceUrl } from "@/shared/clients/requesty"
+import { openExternal } from "@/utils/env"
+import { Controller } from ".."
+
+/**
+ * Initiates Requesty auth with optional custom base URL
+ */
+export async function requestyAuthClicked(_: Controller, req: StringRequest): Promise<Empty> {
+	const customBaseUrl = req.value || undefined
+	const callbackUrl = await HostProvider.get().getCallbackUrl("/requesty")
+	const baseUrl = toRequestyServiceUrl(customBaseUrl, "app")
+
+	if (!baseUrl) {
+		throw new Error("Invalid Requesty base URL")
+	}
+
+	const authUrl = new URL("oauth/authorize", baseUrl)
+	authUrl.searchParams.set("callback_url", callbackUrl)
+
+	await openExternal(authUrl.toString())
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/account/setUserOrganization.ts b/apps/vscode/src/core/controller/account/setUserOrganization.ts
new file mode 100644
index 0000000..2c419b8
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/setUserOrganization.ts
@@ -0,0 +1,24 @@
+import { UserOrganizationUpdateRequest } from "@shared/proto/cline/account"
+import { Empty } from "@shared/proto/cline/common"
+import { fetchRemoteConfig } from "@/core/storage/remote-config/fetch"
+import type { Controller } from "../index"
+
+/**
+ * Handles setting the user's active organization
+ * @param controller The controller instance
+ * @param request UserOrganization to set as active
+ * @returns Empty response
+ */
+export async function setUserOrganization(controller: Controller, request: UserOrganizationUpdateRequest): Promise<Empty> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+		// Switch to the specified organization using the account service
+		await controller.accountService.switchAccount(request.organizationId)
+		await fetchRemoteConfig(controller)
+		return {}
+	} catch (error) {
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/submitLimitIncreaseRequest.ts b/apps/vscode/src/core/controller/account/submitLimitIncreaseRequest.ts
new file mode 100644
index 0000000..502fa92
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/submitLimitIncreaseRequest.ts
@@ -0,0 +1,28 @@
+import { SubmitLimitIncreaseResponse } from "@shared/proto/cline/account"
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Submits a spend limit increase request to the user's org admin.
+ * Called when the user clicks "Request Increase" on the SpendLimitError component.
+ * @param controller The controller instance
+ * @param _request Empty request
+ * @returns SubmitLimitIncreaseResponse indicating success or failure
+ */
+export async function submitLimitIncreaseRequest(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<SubmitLimitIncreaseResponse> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		await controller.accountService.submitLimitIncreaseRequestRPC()
+		return SubmitLimitIncreaseResponse.create({ success: true })
+	} catch (error) {
+		Logger.error(`Failed to submit limit increase request: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/account/subscribeToAuthStatusUpdate.ts b/apps/vscode/src/core/controller/account/subscribeToAuthStatusUpdate.ts
new file mode 100644
index 0000000..e7987da
--- /dev/null
+++ b/apps/vscode/src/core/controller/account/subscribeToAuthStatusUpdate.ts
@@ -0,0 +1,13 @@
+import { AuthService } from "@/sdk/auth-service"
+import { AuthState, EmptyRequest } from "@/shared/proto/index.cline"
+import { Controller } from ".."
+import { StreamingResponseHandler } from "../grpc-handler"
+
+export async function subscribeToAuthStatusUpdate(
+	controller: Controller,
+	request: EmptyRequest,
+	responseStream: StreamingResponseHandler<AuthState>,
+	requestId?: string,
+): Promise<void> {
+	return AuthService.getInstance().subscribeToAuthStatusUpdate(controller, request, responseStream, requestId)
+}
diff --git a/apps/vscode/src/core/controller/browser/discoverBrowser.ts b/apps/vscode/src/core/controller/browser/discoverBrowser.ts
new file mode 100644
index 0000000..af44cd1
--- /dev/null
+++ b/apps/vscode/src/core/controller/browser/discoverBrowser.ts
@@ -0,0 +1,45 @@
+import { discoverChromeInstances } from "@services/browser/BrowserDiscovery"
+import { BrowserSession } from "@services/browser/BrowserSession"
+import { BrowserConnection } from "@shared/proto/cline/browser"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Controller } from "../index"
+
+/**
+ * Discover Chrome instances
+ * @param controller The controller instance
+ * @param request The request message
+ * @returns The browser connection result
+ */
+export async function discoverBrowser(controller: Controller, _request: EmptyRequest): Promise<BrowserConnection> {
+	try {
+		const discoveredHost = await discoverChromeInstances()
+
+		if (discoveredHost) {
+			// Don't update the remoteBrowserHost state when auto-discovering
+			// This way we don't override the user's preference
+
+			// Test the connection to get the endpoint
+			const browserSession = new BrowserSession(controller.stateManager)
+			const result = await browserSession.testConnection(discoveredHost)
+
+			return BrowserConnection.create({
+				success: true,
+				message: `Successfully discovered and connected to Chrome at ${discoveredHost}`,
+				endpoint: result.endpoint || "",
+			})
+		} else {
+			return BrowserConnection.create({
+				success: false,
+				message:
+					"No Chrome instances found. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
+				endpoint: "",
+			})
+		}
+	} catch (error) {
+		return BrowserConnection.create({
+			success: false,
+			message: `Error discovering browser: ${error instanceof Error ? error.message : String(error)}`,
+			endpoint: "",
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/browser/getBrowserConnectionInfo.ts b/apps/vscode/src/core/controller/browser/getBrowserConnectionInfo.ts
new file mode 100644
index 0000000..bc128d8
--- /dev/null
+++ b/apps/vscode/src/core/controller/browser/getBrowserConnectionInfo.ts
@@ -0,0 +1,47 @@
+import { BrowserConnectionInfo } from "@shared/proto/cline/browser"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../index"
+
+/**
+ * Get information about the current browser connection
+ * @param controller The controller instance
+ * @param request The request message
+ * @returns The browser connection info
+ */
+export async function getBrowserConnectionInfo(controller: Controller, _: EmptyRequest): Promise<BrowserConnectionInfo> {
+	try {
+		// Get browser settings from extension state
+		const browserSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
+
+		// Check if there's an active browser session by using the controller's handleWebviewMessage approach
+		// This is similar to what's done in controller/index.ts for the "getBrowserConnectionInfo" message
+		if (controller.task?.browserSession) {
+			// Access the browser session through the controller's task property
+			// Using indexer notation to access private property
+			const browserSession = controller.task.browserSession
+			const connectionInfo = browserSession.getConnectionInfo()
+
+			// Convert from BrowserSession.BrowserConnectionInfo to proto.BrowserConnectionInfo
+			return BrowserConnectionInfo.create({
+				isConnected: connectionInfo.isConnected,
+				isRemote: connectionInfo.isRemote,
+				host: connectionInfo.host || "", // Ensure host is never undefined
+			})
+		}
+
+		// Fallback to browser settings if no active browser session
+		return BrowserConnectionInfo.create({
+			isConnected: false,
+			isRemote: !!browserSettings.remoteBrowserEnabled,
+			host: browserSettings.remoteBrowserHost || "",
+		})
+	} catch (error: unknown) {
+		Logger.error("Error getting browser connection info:", error)
+		return BrowserConnectionInfo.create({
+			isConnected: false,
+			isRemote: false,
+			host: "",
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/browser/getDetectedChromePath.ts b/apps/vscode/src/core/controller/browser/getDetectedChromePath.ts
new file mode 100644
index 0000000..4a1771b
--- /dev/null
+++ b/apps/vscode/src/core/controller/browser/getDetectedChromePath.ts
@@ -0,0 +1,29 @@
+import { ChromePath } from "@shared/proto/cline/browser"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { BrowserSession } from "../../../services/browser/BrowserSession"
+import { Controller } from "../index"
+
+/**
+ * Get the detected Chrome executable path
+ * @param controller The controller instance
+ * @param request The empty request message
+ * @returns The detected Chrome path and whether it's bundled
+ */
+export async function getDetectedChromePath(controller: Controller, _: EmptyRequest): Promise<ChromePath> {
+	try {
+		const browserSession = new BrowserSession(controller.stateManager)
+		const result = await browserSession.getDetectedChromePath()
+
+		return ChromePath.create({
+			path: result.path,
+			isBundled: result.isBundled,
+		})
+	} catch (error) {
+		Logger.error("Error getting detected Chrome path:", error)
+		return ChromePath.create({
+			path: "",
+			isBundled: false,
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/browser/relaunchChromeDebugMode.ts b/apps/vscode/src/core/controller/browser/relaunchChromeDebugMode.ts
new file mode 100644
index 0000000..21c7258
--- /dev/null
+++ b/apps/vscode/src/core/controller/browser/relaunchChromeDebugMode.ts
@@ -0,0 +1,24 @@
+import { EmptyRequest, String as StringMessage } from "@shared/proto/cline/common"
+import { BrowserSession } from "../../../services/browser/BrowserSession"
+import { Controller } from "../index"
+
+/**
+ * Relaunch Chrome in debug mode
+ * @param controller The controller instance
+ * @param request The empty request message
+ * @returns The browser relaunch result as a string message
+ */
+export async function relaunchChromeDebugMode(controller: Controller, _: EmptyRequest): Promise<StringMessage> {
+	try {
+		const browserSession = new BrowserSession(controller.stateManager)
+
+		// Relaunch Chrome in debug mode
+		await browserSession.relaunchChromeDebugMode(controller)
+
+		// The actual result will be sent via the ProtoBus in the BrowserSession.relaunchChromeDebugMode method
+		// Here we just return a message as a placeholder
+		return { value: "Chrome relaunch initiated" }
+	} catch (error) {
+		throw new Error(`Error relaunching Chrome: ${error instanceof Error ? error.message : globalThis.String(error)}`)
+	}
+}
diff --git a/apps/vscode/src/core/controller/browser/testBrowserConnection.ts b/apps/vscode/src/core/controller/browser/testBrowserConnection.ts
new file mode 100644
index 0000000..1a3bca6
--- /dev/null
+++ b/apps/vscode/src/core/controller/browser/testBrowserConnection.ts
@@ -0,0 +1,61 @@
+import { discoverChromeInstances } from "@services/browser/BrowserDiscovery"
+import { BrowserSession } from "@services/browser/BrowserSession"
+import { BrowserConnection } from "@shared/proto/cline/browser"
+import { StringRequest } from "@shared/proto/cline/common"
+import { Controller } from "../index"
+
+/**
+ * Test connection to a browser instance
+ * @param controller The controller instance
+ * @param request The request message
+ * @returns The browser connection result
+ */
+export async function testBrowserConnection(controller: Controller, request: StringRequest): Promise<BrowserConnection> {
+	try {
+		const browserSession = new BrowserSession(controller.stateManager)
+		const text = request.value || ""
+
+		// If no text is provided, try auto-discovery
+		if (!text) {
+			try {
+				const discoveredHost = await discoverChromeInstances()
+				if (discoveredHost) {
+					// Test the connection to the discovered host
+					const result = await browserSession.testConnection(discoveredHost)
+					return BrowserConnection.create({
+						success: result.success,
+						message: `Auto-discovered and tested connection to Chrome at ${discoveredHost}: ${result.message}`,
+						endpoint: result.endpoint || "",
+					})
+				} else {
+					return BrowserConnection.create({
+						success: false,
+						message:
+							"No Chrome instances found on the network. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
+						endpoint: "",
+					})
+				}
+			} catch (error) {
+				return BrowserConnection.create({
+					success: false,
+					message: `Error during auto-discovery: ${error instanceof Error ? error.message : String(error)}`,
+					endpoint: "",
+				})
+			}
+		} else {
+			// Test the provided URL
+			const result = await browserSession.testConnection(text)
+			return BrowserConnection.create({
+				success: result.success,
+				message: result.message,
+				endpoint: result.endpoint || "",
+			})
+		}
+	} catch (error) {
+		return BrowserConnection.create({
+			success: false,
+			message: `Error testing connection: ${error instanceof Error ? error.message : String(error)}`,
+			endpoint: "",
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/checkpoints/checkpointRestore.ts b/apps/vscode/src/core/controller/checkpoints/checkpointRestore.ts
new file mode 100644
index 0000000..1e1a99c
--- /dev/null
+++ b/apps/vscode/src/core/controller/checkpoints/checkpointRestore.ts
@@ -0,0 +1,23 @@
+import { CheckpointRestoreRequest } from "@shared/proto/cline/checkpoints"
+import { Empty } from "@shared/proto/cline/common"
+import { ClineCheckpointRestore } from "../../../shared/WebviewMessage"
+import { Controller } from ".."
+
+export async function checkpointRestore(controller: Controller, request: CheckpointRestoreRequest): Promise<Empty> {
+	const sdkRestoreCheckpoint = (
+		controller as Controller & {
+			restoreCheckpoint?: (input: { checkpointRunCount: number; restoreType: ClineCheckpointRestore }) => Promise<void>
+		}
+	).restoreCheckpoint
+	if (sdkRestoreCheckpoint) {
+		if (request.number) {
+			await sdkRestoreCheckpoint.call(controller, {
+				checkpointRunCount: Number(request.number),
+				restoreType: request.restoreType as ClineCheckpointRestore,
+			})
+		}
+		return Empty.create({})
+	}
+
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/core/controller/commands/addToCline.ts b/apps/vscode/src/core/controller/commands/addToCline.ts
new file mode 100644
index 0000000..26b42f7
--- /dev/null
+++ b/apps/vscode/src/core/controller/commands/addToCline.ts
@@ -0,0 +1,46 @@
+import { getFileMentionFromPath } from "@/core/mentions"
+import { singleFileDiagnosticsToProblemsString } from "@/integrations/diagnostics"
+import { telemetryService } from "@/services/telemetry"
+import { CommandContext, Empty } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../index"
+import { sendAddToInputEvent } from "../ui/subscribeToAddToInput"
+
+// 'Add to Cline' context menu in editor and code action
+// Inserts the selected code into the chat.
+export async function addToCline(controller: Controller, request: CommandContext, notebookContext?: string): Promise<Empty> {
+	if (!request.selectedText?.trim() && !notebookContext) {
+		Logger.log("❌ No text selected and no notebook context - returning early")
+		return {}
+	}
+
+	const filePath = request.filePath || ""
+	const fileMention = await getFileMentionFromPath(filePath)
+
+	let input = `${fileMention}\n\`\`\`\n${request.selectedText}\n\`\`\``
+
+	// Add notebook context if provided (includes cell JSON)
+	if (notebookContext) {
+		Logger.log("Adding notebook context for enhanced editing")
+		input += `\n${notebookContext}`
+	}
+
+	if (request.diagnostics.length) {
+		const problemsString = await singleFileDiagnosticsToProblemsString(filePath, request.diagnostics)
+		input += `\nProblems:\n${problemsString}`
+	}
+
+	// Notebooks send immediately, regular adds just fill input
+	if (notebookContext && controller.task) {
+		await controller.task.handleWebviewAskResponse("messageResponse", input)
+	} else if (notebookContext) {
+		await controller.initTask(input)
+	} else {
+		await sendAddToInputEvent(input)
+	}
+
+	Logger.log("addToCline", request.selectedText, filePath, request.language)
+	telemetryService.captureButtonClick("codeAction_addToChat", controller.task?.ulid)
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/commands/explainWithCline.ts b/apps/vscode/src/core/controller/commands/explainWithCline.ts
new file mode 100644
index 0000000..e897594
--- /dev/null
+++ b/apps/vscode/src/core/controller/commands/explainWithCline.ts
@@ -0,0 +1,37 @@
+import { getFileMentionFromPath } from "@/core/mentions"
+import { HostProvider } from "@/hosts/host-provider"
+import { telemetryService } from "@/services/telemetry"
+import { CommandContext, Empty } from "@/shared/proto/index.cline"
+import { ShowMessageType } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../index"
+
+export async function explainWithCline(
+	controller: Controller,
+	request: CommandContext,
+	notebookContext?: string,
+): Promise<Empty> {
+	if (!request.selectedText?.trim() && !notebookContext) {
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message: "Please select some code to explain.",
+		})
+		return {}
+	}
+
+	const filePath = request.filePath || ""
+	const fileMention = await getFileMentionFromPath(filePath)
+	let prompt = `Explain the following code from ${fileMention}:
+\`\`\`${request.language}\n${request.selectedText}\n\`\`\``
+
+	// Add notebook context if provided (includes cell JSON)
+	if (notebookContext) {
+		Logger.log("Adding notebook context to explainWithCline task")
+		prompt += notebookContext
+	}
+
+	await controller.initTask(prompt)
+	telemetryService.captureButtonClick("codeAction_explainCode", controller.task?.ulid)
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/commands/fixWithCline.ts b/apps/vscode/src/core/controller/commands/fixWithCline.ts
new file mode 100644
index 0000000..ccfe348
--- /dev/null
+++ b/apps/vscode/src/core/controller/commands/fixWithCline.ts
@@ -0,0 +1,21 @@
+import { getFileMentionFromPath } from "@/core/mentions"
+import { singleFileDiagnosticsToProblemsString } from "@/integrations/diagnostics"
+import { telemetryService } from "@/services/telemetry"
+import { CommandContext, Empty } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../index"
+
+export async function fixWithCline(controller: Controller, request: CommandContext): Promise<Empty> {
+	const filePath = request.filePath || ""
+	const fileMention = await getFileMentionFromPath(filePath)
+	const problemsString = await singleFileDiagnosticsToProblemsString(filePath, request.diagnostics)
+
+	await controller.initTask(
+		`Fix the following code in ${fileMention}
+\`\`\`\n${request.selectedText}\n\`\`\`\n\nProblems:\n${problemsString}`,
+	)
+	Logger.log("fixWithCline", request.selectedText, request.filePath, request.language, problemsString)
+
+	telemetryService.captureButtonClick("codeAction_fixWithCline", controller.task?.ulid)
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/commands/improveWithCline.ts b/apps/vscode/src/core/controller/commands/improveWithCline.ts
new file mode 100644
index 0000000..e25ebb8
--- /dev/null
+++ b/apps/vscode/src/core/controller/commands/improveWithCline.ts
@@ -0,0 +1,46 @@
+import { getFileMentionFromPath } from "@/core/mentions"
+import { HostProvider } from "@/hosts/host-provider"
+import { telemetryService } from "@/services/telemetry"
+import { CommandContext, Empty } from "@/shared/proto/index.cline"
+import { ShowMessageType } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../index"
+
+export async function improveWithCline(
+	controller: Controller,
+	request: CommandContext,
+	notebookContext?: string,
+): Promise<Empty> {
+	if (!request.selectedText?.trim() && !notebookContext) {
+		Logger.log("❌ No text selected and no notebook context")
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message: "Please select some code to improve.",
+		})
+		return {}
+	}
+	const filePath = request.filePath || ""
+	const fileMention = await getFileMentionFromPath(filePath)
+	const hasSelectedText = request.selectedText?.trim()
+
+	// Build prompt
+	let prompt = hasSelectedText
+		? `Improve the following code from ${fileMention} (e.g., suggest refactorings, optimizations, or better practices):\n\`\`\`${request.language}\n${request.selectedText}\n\`\`\``
+		: `Improve the current code in the current notebook cell from ${fileMention}. Suggest refactorings, optimizations, or better practices based on the cell context.`
+
+	if (notebookContext) {
+		Logger.log("Adding notebook context to improveWithCline task")
+		prompt += `\n${notebookContext}`
+	}
+
+	// Send: notebooks go to existing task if available, non-notebooks always create new task
+	if (notebookContext && controller.task) {
+		await controller.task.handleWebviewAskResponse("messageResponse", prompt)
+	} else {
+		await controller.initTask(prompt)
+	}
+
+	telemetryService.captureButtonClick("codeAction_improveCode", controller.task?.ulid)
+
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/file/__tests__/ifFileExistsRelativePath.test.ts b/apps/vscode/src/core/controller/file/__tests__/ifFileExistsRelativePath.test.ts
new file mode 100644
index 0000000..64147b7
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/__tests__/ifFileExistsRelativePath.test.ts
@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { Controller } from "@core/controller"
+import { BooleanResponse, StringRequest } from "@shared/proto/cline/common"
+import * as actualPathUtils from "@utils/path"
+import { expect } from "chai"
+import * as sinon from "sinon"
+
+// bun loads real ESM, so sinon cannot stub the `@utils/path` namespace export
+// ("ES Modules cannot be stubbed"). Inject a module-level sinon stub via
+// mock.module so the full sinon stub API keeps working.
+const getWorkspacePathStub: sinon.SinonStub = sinon.stub()
+const pathUtilsMock = () => ({ ...actualPathUtils, getWorkspacePath: getWorkspacePathStub })
+mock.module("@utils/path", pathUtilsMock)
+mock.module("@/utils/path", pathUtilsMock)
+
+import { ifFileExistsRelativePath } from "../ifFileExistsRelativePath"
+
+describe("ifFileExistsRelativePath", () => {
+	let mockController: Controller
+
+	beforeEach(() => {
+		// Create a mock controller
+		mockController = {} as any
+
+		// Reset the module-level getWorkspacePath stub
+		getWorkspacePathStub.reset()
+	})
+
+	afterEach(() => {
+		getWorkspacePathStub.reset()
+	})
+
+	it("should return BooleanResponse with boolean value", async () => {
+		getWorkspacePathStub.resolves("/workspace")
+
+		const request = StringRequest.create({
+			value: "src/test.ts",
+		})
+
+		const result = await ifFileExistsRelativePath(mockController, request)
+
+		// The result should be a BooleanResponse object
+		expect(result).to.have.property("value")
+		expect(typeof result.value).to.equal("boolean")
+	})
+
+	it("should return false when no workspace path is available", async () => {
+		const noWorkspaceScenarios = [null, undefined]
+
+		for (const workspaceValue of noWorkspaceScenarios) {
+			getWorkspacePathStub.resolves(workspaceValue)
+
+			const request = StringRequest.create({
+				value: "src/test.ts",
+			})
+
+			const result = await ifFileExistsRelativePath(mockController, request)
+
+			expect(result).to.deep.equal(BooleanResponse.create({ value: false }))
+		}
+	})
+
+	it("should return false when path is invalid", async () => {
+		getWorkspacePathStub.resolves("/workspace")
+
+		const invalidPaths = ["", undefined]
+
+		for (const invalidPath of invalidPaths) {
+			const request = StringRequest.create({
+				value: invalidPath,
+			})
+
+			const result = await ifFileExistsRelativePath(mockController, request)
+
+			expect(result).to.deep.equal(BooleanResponse.create({ value: false }))
+		}
+	})
+
+	it("should handle valid relative paths correctly", async () => {
+		getWorkspacePathStub.resolves("/workspace")
+
+		// Test with valid workspace-relative paths only
+		const validPaths = ["src/file.ts", "./src/file.ts", "package.json", ".gitignore", "src/components/ui/Button/Button.tsx"]
+
+		for (const testPath of validPaths) {
+			const request = StringRequest.create({
+				value: testPath,
+			})
+
+			const result = await ifFileExistsRelativePath(mockController, request)
+
+			// Each should return a BooleanResponse
+			expect(result).to.have.property("value")
+			expect(typeof result.value).to.equal("boolean")
+		}
+
+		// Verify that getWorkspacePath was called for each path
+		expect(getWorkspacePathStub.callCount).to.equal(validPaths.length)
+	})
+})
diff --git a/apps/vscode/src/core/controller/file/__tests__/openFileRelativePath.test.ts b/apps/vscode/src/core/controller/file/__tests__/openFileRelativePath.test.ts
new file mode 100644
index 0000000..422e941
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/__tests__/openFileRelativePath.test.ts
@@ -0,0 +1,130 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { Controller } from "@core/controller"
+import * as actualOpenFileIntegration from "@integrations/misc/open-file"
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import * as actualPathUtils from "@utils/path"
+import { expect } from "chai"
+import * as path from "path"
+import * as sinon from "sinon"
+import { Logger } from "@/shared/services/Logger"
+
+// bun loads real ESM, so sinon cannot stub the `@integrations/misc/open-file`
+// and `@utils/path` namespace exports ("ES Modules cannot be stubbed"). Inject
+// module-level sinon stubs via mock.module so the full sinon stub API keeps
+// working. (`Logger` is a class with static methods and is still sinon-stubbed
+// directly below.)
+const openFileIntegrationStub: sinon.SinonStub = sinon.stub()
+const getWorkspacePathStub: sinon.SinonStub = sinon.stub()
+const openFileMock = () => ({ ...actualOpenFileIntegration, openFile: openFileIntegrationStub })
+const pathUtilsMock = () => ({ ...actualPathUtils, getWorkspacePath: getWorkspacePathStub })
+mock.module("@integrations/misc/open-file", openFileMock)
+mock.module("@utils/path", pathUtilsMock)
+mock.module("@/utils/path", pathUtilsMock)
+
+import { openFileRelativePath } from "../openFileRelativePath"
+
+describe("openFileRelativePath", () => {
+	let sandbox: sinon.SinonSandbox
+	let mockController: Controller
+	let consoleErrorStub: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		// Create a mock controller
+		mockController = {} as any
+
+		// Reset the module-level sinon stubs (injected via mock.module above)
+		openFileIntegrationStub.reset()
+		getWorkspacePathStub.reset()
+
+		// Stub console.error to prevent test output pollution
+		consoleErrorStub = sandbox.stub(Logger, "error")
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+		openFileIntegrationStub.reset()
+		getWorkspacePathStub.reset()
+	})
+
+	it("should return Empty response on successful execution", async () => {
+		getWorkspacePathStub.resolves("/workspace")
+
+		const request = StringRequest.create({
+			value: "src/test.ts",
+		})
+
+		const result = await openFileRelativePath(mockController, request)
+
+		expect(result).to.deep.equal(Empty.create())
+	})
+
+	it("should call openFileIntegration with absolute path when relative path is provided", async () => {
+		const workspacePath = "/workspace"
+		const relativePath = "src/components/Test.tsx"
+		const expectedAbsolutePath = path.resolve(workspacePath, relativePath)
+
+		getWorkspacePathStub.resolves(workspacePath)
+
+		const request = StringRequest.create({
+			value: relativePath,
+		})
+
+		await openFileRelativePath(mockController, request)
+
+		expect(openFileIntegrationStub.calledOnceWith(expectedAbsolutePath)).to.be.true
+	})
+
+	it("should not call openFileIntegration when path is invalid", async () => {
+		getWorkspacePathStub.resolves("/workspace")
+
+		const invalidPaths = ["", undefined]
+
+		for (const invalidPath of invalidPaths) {
+			const request = StringRequest.create({
+				value: invalidPath,
+			})
+
+			await openFileRelativePath(mockController, request)
+
+			expect(openFileIntegrationStub.called).to.be.false
+			openFileIntegrationStub.resetHistory()
+		}
+	})
+
+	it("should return Empty and log error when no workspace path is available", async () => {
+		const noWorkspaceScenarios = [null, undefined]
+
+		for (const workspaceValue of noWorkspaceScenarios) {
+			getWorkspacePathStub.resolves(workspaceValue)
+			consoleErrorStub.resetHistory()
+
+			const request = StringRequest.create({
+				value: "src/test.ts",
+			})
+
+			const result = await openFileRelativePath(mockController, request)
+
+			expect(result).to.deep.equal(Empty.create())
+			expect(consoleErrorStub.called).to.be.true
+			expect(openFileIntegrationStub.called).to.be.false
+		}
+	})
+
+	it("should handle nested directory paths", async () => {
+		const workspacePath = "/workspace"
+		const relativePath = "src/components/ui/Button/Button.tsx"
+		const expectedAbsolutePath = path.resolve(workspacePath, relativePath)
+
+		getWorkspacePathStub.resolves(workspacePath)
+
+		const request = StringRequest.create({
+			value: relativePath,
+		})
+
+		await openFileRelativePath(mockController, request)
+
+		expect(openFileIntegrationStub.calledOnceWith(expectedAbsolutePath)).to.be.true
+	})
+})
diff --git a/apps/vscode/src/core/controller/file/copyToClipboard.ts b/apps/vscode/src/core/controller/file/copyToClipboard.ts
new file mode 100644
index 0000000..0c60370
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/copyToClipboard.ts
@@ -0,0 +1,21 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { writeTextToClipboard } from "@/utils/env"
+import { Controller } from ".."
+
+/**
+ * Copies text to the system clipboard
+ * @param controller The controller instance
+ * @param request The request containing the text to copy
+ * @returns Empty response
+ */
+export async function copyToClipboard(_controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		if (request.value) {
+			await writeTextToClipboard(request.value)
+		}
+	} catch (error) {
+		Logger.error("Error copying to clipboard:", error)
+	}
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/file/createHook.ts b/apps/vscode/src/core/controller/file/createHook.ts
new file mode 100644
index 0000000..0005199
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/createHook.ts
@@ -0,0 +1,56 @@
+import { CreateHookRequest, CreateHookResponse } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import path from "path"
+import { HookDiscoveryCache } from "../../hooks/HookDiscoveryCache"
+import { getHookTemplate } from "../../hooks/templates"
+import { isValidHookType, resolveHooksDirectory, VALID_HOOK_TYPES } from "../../hooks/utils"
+import { Controller } from ".."
+import { refreshHooks } from "./refreshHooks"
+
+export async function createHook(
+	controller: Controller,
+	request: CreateHookRequest,
+	globalHooksDirOverride?: string,
+): Promise<CreateHookResponse> {
+	const { hookName, isGlobal, workspaceName } = request
+
+	// Validate hook name is one of the valid hook types
+	if (!isValidHookType(hookName)) {
+		throw new Error(`Invalid hook type: "${hookName}". Valid hook types are: ${VALID_HOOK_TYPES.join(", ")}`)
+	}
+
+	// Determine target directory
+	const hooksDir = await resolveHooksDirectory(isGlobal, workspaceName, globalHooksDirOverride)
+
+	// Ensure directory exists
+	await fs.mkdir(hooksDir, { recursive: true })
+
+	const hookFileName = process.platform === "win32" ? `${hookName}.ps1` : hookName
+	const hookPath = path.join(hooksDir, hookFileName)
+
+	// Check if already exists
+	try {
+		await fs.stat(hookPath)
+		throw new Error(`Hook ${hookName} already exists at ${hookPath}`)
+	} catch (error) {
+		// Good - file doesn't exist yet
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			throw error
+		}
+	}
+
+	// Get template content
+	const templateContent = getHookTemplate(hookName)
+
+	// Write file WITHOUT executable permissions (644) so hook is toggled off by default
+	// User can enable it later when they're ready
+	const mode = 0o644
+	await fs.writeFile(hookPath, templateContent, { mode })
+
+	// Invalidate hook discovery cache
+	await HookDiscoveryCache.getInstance().invalidateAll()
+
+	// Return updated hooks state
+	const hooksToggles = await refreshHooks(controller, undefined, globalHooksDirOverride)
+	return CreateHookResponse.create({ hooksToggles })
+}
diff --git a/apps/vscode/src/core/controller/file/createRuleFile.ts b/apps/vscode/src/core/controller/file/createRuleFile.ts
new file mode 100644
index 0000000..01222da
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/createRuleFile.ts
@@ -0,0 +1,75 @@
+import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
+import { createRuleFile as createRuleFileImpl } from "@core/context/instructions/user-instructions/rule-helpers"
+import { getWorkspaceBasename } from "@core/workspace"
+import { RuleFile, RuleFileRequest } from "@shared/proto/cline/file"
+import { refreshWorkflowToggles } from "@/core/context/instructions/user-instructions/workflows"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { getCwd, getDesktopDir } from "@/utils/path"
+import { Controller } from ".."
+import { openFile } from "./openFile"
+
+/**
+ * Creates a rule file in either global or workspace rules directory
+ * @param controller The controller instance
+ * @param request The request containing filename and isGlobal flag
+ * @returns Result with file path and display name
+ * @throws Error if operation fails
+ */
+export async function createRuleFile(controller: Controller, request: RuleFileRequest): Promise<RuleFile> {
+	if (
+		typeof request.isGlobal !== "boolean" ||
+		!request.filename ||
+		typeof request.filename !== "string" ||
+		!request.type ||
+		typeof request.type !== "string"
+	) {
+		Logger.error("createRuleFile: Missing or invalid parameters", {
+			isGlobal: typeof request.isGlobal === "boolean" ? request.isGlobal : `Invalid: ${typeof request.isGlobal}`,
+			filename: typeof request.filename === "string" ? request.filename : `Invalid: ${typeof request.filename}`,
+			type: typeof request.type === "string" ? request.type : `Invalid: ${typeof request.type}`,
+		})
+		throw new Error("Missing or invalid parameters")
+	}
+
+	const cwd = await getCwd(getDesktopDir())
+	const { filePath, fileExists } = await createRuleFileImpl(request.isGlobal, request.filename, cwd, request.type)
+
+	if (!filePath) {
+		throw new Error("Failed to create file.")
+	}
+
+	const fileTypeName = request.type === "workflow" ? "workflow" : "rule"
+
+	if (fileExists) {
+		const message = `${fileTypeName} file "${request.filename}" already exists.`
+		HostProvider.window.showMessage({
+			type: ShowMessageType.WARNING,
+			message,
+		})
+		// Still open it for editing
+		await openFile(controller, { value: filePath })
+	} else {
+		if (request.type === "workflow") {
+			await refreshWorkflowToggles(controller, cwd)
+		} else {
+			await refreshClineRulesToggles(controller, cwd)
+		}
+		await controller.postStateToWebview()
+
+		await openFile(controller, { value: filePath })
+
+		const message = `Created new ${request.isGlobal ? "global" : "workspace"} ${fileTypeName} file: ${request.filename}`
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message,
+		})
+	}
+
+	return RuleFile.create({
+		filePath: filePath,
+		displayName: getWorkspaceBasename(filePath, "Controller.createRuleFile"),
+		alreadyExists: fileExists,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/createSkillFile.ts b/apps/vscode/src/core/controller/file/createSkillFile.ts
new file mode 100644
index 0000000..1fa78cb
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/createSkillFile.ts
@@ -0,0 +1,109 @@
+import { ensureAgentSkillsDirectoryExists } from "@core/storage/disk"
+import { CreateSkillRequest, SkillsToggles } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { fileExistsAtPath } from "@/utils/fs"
+import { Controller } from ".."
+import { openFile } from "./openFile"
+
+const SKILL_TEMPLATE = `---
+name: {{SKILL_NAME}}
+description: Brief description of what this skill does
+---
+
+# {{SKILL_NAME}}
+
+Instructions for the AI agent...
+
+## Usage
+
+Describe when and how to use this skill.
+
+## Steps
+
+1. First step
+2. Second step
+3. Third step
+`
+
+/**
+ * Creates a new skill from template
+ * @param controller The controller instance
+ * @param request The request containing skill name and isGlobal flag
+ * @returns The updated skills toggles
+ */
+export async function createSkillFile(controller: Controller, request: CreateSkillRequest): Promise<SkillsToggles> {
+	const { skillName, isGlobal } = request
+
+	if (!skillName || typeof skillName !== "string" || typeof isGlobal !== "boolean") {
+		Logger.error("createSkillFile: Missing or invalid parameters", {
+			skillName: typeof skillName === "string" ? skillName : `Invalid: ${typeof skillName}`,
+			isGlobal: typeof isGlobal === "boolean" ? isGlobal : `Invalid: ${typeof isGlobal}`,
+		})
+		throw new Error("Missing or invalid parameters for createSkillFile")
+	}
+
+	// Validate skill name (must be valid directory name)
+	const sanitizedName = skillName.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase()
+	if (!sanitizedName) {
+		throw new Error("Invalid skill name")
+	}
+
+	let skillDir: string
+
+	if (isGlobal) {
+		// Create in ~/.agents/skills using the unified helper
+		const globalSkillsDir = await ensureAgentSkillsDirectoryExists({ isGlobal: true })
+		skillDir = path.join(globalSkillsDir, sanitizedName)
+	} else {
+		const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
+		const primaryWorkspace = workspacePaths.paths[0]
+		if (!primaryWorkspace) {
+			throw new Error("No workspace folder open")
+		}
+		// Create in .agents/skills using the unified helper
+		const localSkillsDir = await ensureAgentSkillsDirectoryExists({
+			isGlobal: false,
+			workspacePath: primaryWorkspace,
+		})
+		skillDir = path.join(localSkillsDir, sanitizedName)
+	}
+
+	// Check if skill already exists
+	if (await fileExistsAtPath(skillDir)) {
+		await HostProvider.window.showMessage({
+			type: ShowMessageType.WARNING,
+			message: `Skill "${sanitizedName}" already exists`,
+		})
+		// Return current toggles
+		const globalToggles = controller.stateManager.getGlobalSettingsKey("globalSkillsToggles") || {}
+		const localToggles = controller.stateManager.getWorkspaceStateKey("localSkillsToggles") || {}
+		return SkillsToggles.create({
+			globalSkillsToggles: globalToggles,
+			localSkillsToggles: localToggles,
+		})
+	}
+
+	// Create skill directory
+	await fs.mkdir(skillDir, { recursive: true })
+
+	// Create SKILL.md from template
+	const skillMdPath = path.join(skillDir, "SKILL.md")
+	const content = SKILL_TEMPLATE.replace(/\{\{SKILL_NAME\}\}/g, sanitizedName)
+	await fs.writeFile(skillMdPath, content, "utf-8")
+
+	// Open the file for editing
+	await openFile(controller, { value: skillMdPath })
+
+	// Return current toggles (new skill defaults to enabled)
+	const globalToggles = controller.stateManager.getGlobalSettingsKey("globalSkillsToggles") || {}
+	const localToggles = controller.stateManager.getWorkspaceStateKey("localSkillsToggles") || {}
+
+	return SkillsToggles.create({
+		globalSkillsToggles: globalToggles,
+		localSkillsToggles: localToggles,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/deleteHook.ts b/apps/vscode/src/core/controller/file/deleteHook.ts
new file mode 100644
index 0000000..4370469
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/deleteHook.ts
@@ -0,0 +1,33 @@
+import { DeleteHookRequest, DeleteHookResponse } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import { HookDiscoveryCache } from "../../hooks/HookDiscoveryCache"
+import { resolveExistingHookPath, resolveHooksDirectory } from "../../hooks/utils"
+import { Controller } from ".."
+import { refreshHooks } from "./refreshHooks"
+
+export async function deleteHook(
+	controller: Controller,
+	request: DeleteHookRequest,
+	globalHooksDirOverride?: string,
+): Promise<DeleteHookResponse> {
+	const { hookName, isGlobal, workspaceName } = request
+
+	// Determine hook path
+	const hooksDir = await resolveHooksDirectory(isGlobal, workspaceName, globalHooksDirOverride)
+	const hookPath = await resolveExistingHookPath(hooksDir, hookName)
+
+	// Verify hook exists before attempting deletion
+	if (!hookPath) {
+		throw new Error(`Hook ${hookName} does not exist in ${hooksDir}`)
+	}
+
+	// Delete the hook file
+	await fs.unlink(hookPath)
+
+	// Invalidate hook discovery cache
+	await HookDiscoveryCache.getInstance().invalidateAll()
+
+	// Return updated hooks state
+	const hooksToggles = await refreshHooks(controller, undefined, globalHooksDirOverride)
+	return DeleteHookResponse.create({ hooksToggles })
+}
diff --git a/apps/vscode/src/core/controller/file/deleteRuleFile.ts b/apps/vscode/src/core/controller/file/deleteRuleFile.ts
new file mode 100644
index 0000000..9a4b9fb
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/deleteRuleFile.ts
@@ -0,0 +1,59 @@
+import { deleteRuleFile as deleteRuleFileImpl } from "@core/context/instructions/user-instructions/rule-helpers"
+import { getWorkspaceBasename } from "@core/workspace"
+import { RuleFile, RuleFileRequest } from "@shared/proto/cline/file"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Deletes a rule file from either global or workspace rules directory
+ * @param controller The controller instance
+ * @param request The request containing rule path and isGlobal flag
+ * @returns Result with file path and display name
+ * @throws Error if operation fails
+ */
+export async function deleteRuleFile(controller: Controller, request: RuleFileRequest): Promise<RuleFile> {
+	if (
+		typeof request.isGlobal !== "boolean" ||
+		typeof request.rulePath !== "string" ||
+		!request.rulePath ||
+		!request.type ||
+		typeof request.type !== "string"
+	) {
+		Logger.error("deleteRuleFile: Missing or invalid parameters", {
+			isGlobal: typeof request.isGlobal === "boolean" ? request.isGlobal : `Invalid: ${typeof request.isGlobal}`,
+			rulePath: typeof request.rulePath === "string" ? request.rulePath : `Invalid: ${typeof request.rulePath}`,
+			type: typeof request.type === "string" ? request.type : `Invalid: ${typeof request.type}`,
+		})
+		throw new Error("Missing or invalid parameters")
+	}
+
+	const result = await deleteRuleFileImpl(controller, request.rulePath, request.isGlobal, request.type)
+
+	if (!result.success) {
+		throw new Error(result.message || "Failed to delete rule file")
+	}
+
+	// we refresh inside of the deleteRuleFileImpl(..) call
+	//await refreshClineRulesToggles(controller.context, cwd)
+	//await refreshExternalRulesToggles(controller.context, cwd)
+	//await refreshWorkflowToggles(controller.context, cwd)
+	await controller.postStateToWebview()
+
+	const fileName = getWorkspaceBasename(request.rulePath, "Controller.deleteRuleFile")
+
+	const fileTypeName = request.type === "workflow" ? "workflow" : "rule"
+
+	const message = `${fileTypeName} file "${fileName}" deleted successfully`
+	HostProvider.window.showMessage({
+		type: ShowMessageType.INFORMATION,
+		message,
+	})
+
+	return RuleFile.create({
+		filePath: request.rulePath,
+		displayName: fileName,
+		alreadyExists: false,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/deleteSkillFile.ts b/apps/vscode/src/core/controller/file/deleteSkillFile.ts
new file mode 100644
index 0000000..82d39ee
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/deleteSkillFile.ts
@@ -0,0 +1,63 @@
+import { DeleteSkillRequest, SkillsToggles } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import path from "path"
+import { Logger } from "@/shared/services/Logger"
+import { fileExistsAtPath } from "@/utils/fs"
+import { Controller } from ".."
+
+/**
+ * Deletes an existing skill directory
+ * @param controller The controller instance
+ * @param request The request containing skill path and isGlobal flag
+ * @returns The updated skills toggles
+ */
+export async function deleteSkillFile(controller: Controller, request: DeleteSkillRequest): Promise<SkillsToggles> {
+	const { skillPath, isGlobal } = request
+
+	if (!skillPath || typeof skillPath !== "string" || typeof isGlobal !== "boolean") {
+		Logger.error("deleteSkillFile: Missing or invalid parameters", {
+			skillPath: typeof skillPath === "string" ? skillPath : `Invalid: ${typeof skillPath}`,
+			isGlobal: typeof isGlobal === "boolean" ? isGlobal : `Invalid: ${typeof isGlobal}`,
+		})
+		throw new Error("Missing or invalid parameters for deleteSkillFile")
+	}
+
+	// Get the skill directory (skillPath points to SKILL.md, so get parent)
+	const skillDir = path.dirname(skillPath)
+
+	// Verify the path exists
+	if (!(await fileExistsAtPath(skillDir))) {
+		Logger.warn(`deleteSkillFile: Skill directory not found: ${skillDir}`)
+		// Return current toggles anyway
+		const globalToggles = controller.stateManager.getGlobalSettingsKey("globalSkillsToggles") || {}
+		const localToggles = controller.stateManager.getWorkspaceStateKey("localSkillsToggles") || {}
+		return SkillsToggles.create({
+			globalSkillsToggles: globalToggles,
+			localSkillsToggles: localToggles,
+		})
+	}
+
+	// Delete the skill directory
+	await fs.rm(skillDir, { recursive: true, force: true })
+
+	// Remove from toggles
+	let globalToggles = controller.stateManager.getGlobalSettingsKey("globalSkillsToggles") || {}
+	let localToggles = controller.stateManager.getWorkspaceStateKey("localSkillsToggles") || {}
+
+	if (isGlobal) {
+		const { [skillPath]: _, ...remaining } = globalToggles
+		globalToggles = remaining
+		controller.stateManager.setGlobalState("globalSkillsToggles", globalToggles)
+	} else {
+		const { [skillPath]: _, ...remaining } = localToggles
+		localToggles = remaining
+		controller.stateManager.setWorkspaceState("localSkillsToggles", localToggles)
+	}
+
+	await controller.postStateToWebview()
+
+	return SkillsToggles.create({
+		globalSkillsToggles: globalToggles,
+		localSkillsToggles: localToggles,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/getRelativePaths.ts b/apps/vscode/src/core/controller/file/getRelativePaths.ts
new file mode 100644
index 0000000..f060734
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/getRelativePaths.ts
@@ -0,0 +1,41 @@
+import { RelativePaths, RelativePathsRequest } from "@shared/proto/cline/file"
+import * as path from "path"
+import { URI } from "vscode-uri"
+import { Logger } from "@/shared/services/Logger"
+import { isDirectory } from "@/utils/fs"
+import { asRelativePath } from "@/utils/path"
+import { Controller } from ".."
+
+/**
+ * Converts a list of URIs to workspace-relative paths
+ * @param controller The controller instance
+ * @param request The request containing URIs to convert
+ * @returns Response with resolved relative paths
+ */
+export async function getRelativePaths(_controller: Controller, request: RelativePathsRequest): Promise<RelativePaths> {
+	const result = []
+	for (const uriString of request.uris) {
+		try {
+			result.push(await getRelativePath(uriString))
+		} catch (error) {
+			Logger.error(`Error calculating relative path for ${uriString}:`, error)
+		}
+	}
+	return RelativePaths.create({ paths: result })
+}
+
+async function getRelativePath(uriString: string): Promise<string> {
+	const filePath = URI.parse(uriString, true).fsPath
+	const relativePath = await asRelativePath(filePath)
+
+	// If the path is still absolute, it's outside the workspace
+	if (path.isAbsolute(relativePath)) {
+		throw new Error(`Dropped file ${relativePath} is outside the workspace.`)
+	}
+
+	let result = "/" + relativePath.replace(/\\/g, "/")
+	if (await isDirectory(filePath)) {
+		result += "/"
+	}
+	return result
+}
diff --git a/apps/vscode/src/core/controller/file/ifFileExistsRelativePath.ts b/apps/vscode/src/core/controller/file/ifFileExistsRelativePath.ts
new file mode 100644
index 0000000..9435989
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/ifFileExistsRelativePath.ts
@@ -0,0 +1,39 @@
+import { workspaceResolver } from "@core/workspace"
+import { BooleanResponse, StringRequest } from "@shared/proto/cline/common"
+import { getWorkspacePath } from "@utils/path"
+import * as fs from "fs"
+import { Controller } from ".."
+
+/**
+ * Check if a file exists in the project using a relative path
+ * @param controller The controller instance
+ * @param request The request containing the relative file path to check
+ * @returns BooleanResponse indicating whether the file exists
+ */
+export async function ifFileExistsRelativePath(_controller: Controller, request: StringRequest): Promise<BooleanResponse> {
+	const workspacePath = await getWorkspacePath()
+
+	if (!workspacePath) {
+		// If no workspace is open, return false
+		return BooleanResponse.create({ value: false })
+	}
+
+	if (!request.value) {
+		// If no path provided, return false
+		return BooleanResponse.create({ value: false })
+	}
+
+	// Resolve the relative path to absolute path
+	const resolvedPath = workspaceResolver.resolveWorkspacePath(
+		workspacePath,
+		request.value,
+		"Controller.ifFileExistsRelativePath",
+	)
+	const absolutePath = typeof resolvedPath === "string" ? resolvedPath : resolvedPath.absolutePath
+	// Check if the file exists
+	try {
+		return BooleanResponse.create({ value: fs.statSync(absolutePath).isFile() })
+	} catch {
+		return BooleanResponse.create({ value: false })
+	}
+}
diff --git a/apps/vscode/src/core/controller/file/openDiskConversationHistory.ts b/apps/vscode/src/core/controller/file/openDiskConversationHistory.ts
new file mode 100644
index 0000000..8db4231
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/openDiskConversationHistory.ts
@@ -0,0 +1,19 @@
+import { openFile as openFileIntegration } from "@integrations/misc/open-file"
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { Controller } from ".."
+/**
+ * Opens the api_conversation_history.json file for a task in the editor
+ * @param controller The controller instance
+ * @param request The request message containing the task ID in the 'value' field
+ * @returns Empty response
+ */
+export async function openDiskConversationHistory(_controller: Controller, request: StringRequest): Promise<Empty> {
+	if (request.value) {
+		const globalStoragePath = HostProvider.get().globalStorageFsPath
+		const taskConversationHistoryPath = path.join(globalStoragePath, "tasks", request.value, "api_conversation_history.json")
+		await openFileIntegration(taskConversationHistoryPath)
+	}
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/file/openFile.ts b/apps/vscode/src/core/controller/file/openFile.ts
new file mode 100644
index 0000000..b5e5a90
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/openFile.ts
@@ -0,0 +1,81 @@
+import { parseYamlFrontmatter } from "@core/context/instructions/user-instructions/frontmatter"
+import { StateManager } from "@core/storage/StateManager"
+import { openFile as openFileIntegration } from "@integrations/misc/open-file"
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { REMOTE_URI_SCHEME } from "@shared/remote-config/constants"
+import type { GlobalInstructionsFile } from "@shared/remote-config/schema"
+import { writeFile } from "@utils/fs"
+import * as os from "os"
+import * as path from "path"
+import { Controller } from ".."
+
+/**
+ * Opens a file in the editor
+ * @param controller The controller instance
+ * @param request The request message containing the file path in the 'value' field.
+ *                Supports special URI format for remote rules/workflows/skills:
+ *                - remote://rule/{ruleName}
+ *                - remote://workflow/{workflowName}
+ *                - remote://skill/{skillName}
+ * @returns Empty response
+ */
+export async function openFile(_controller: Controller, request: StringRequest): Promise<Empty> {
+	if (request.value) {
+		// Check for remote:// prefix for remote rules/workflows
+		if (request.value.startsWith(REMOTE_URI_SCHEME)) {
+			await openRemoteFile(request.value)
+		} else {
+			await openFileIntegration(request.value)
+		}
+	}
+	return Empty.create()
+}
+
+/**
+ * Opens a remote rule, workflow, or skill file by creating a temp file with its contents
+ * @param uri The remote URI in format: remote://rule/{name}, remote://workflow/{name}, or remote://skill/{name}
+ */
+async function openRemoteFile(uri: string): Promise<void> {
+	// Parse: remote://rule/{name}, remote://workflow/{name}, or remote://skill/{name}
+	const match = uri.match(/^remote:\/\/(rule|workflow|skill)\/(.+)$/)
+	if (!match) {
+		throw new Error(`Invalid remote file URI: ${uri}`)
+	}
+
+	const [, type, name] = match
+	const remoteConfig = StateManager.get().getRemoteConfigSettings()
+
+	// Look up content based on type
+	let items: GlobalInstructionsFile[] | undefined
+	if (type === "rule") {
+		items = remoteConfig.remoteGlobalRules
+	} else if (type === "workflow") {
+		items = remoteConfig.remoteGlobalWorkflows
+	} else {
+		items = remoteConfig.remoteGlobalSkills
+	}
+	// Try entry.name first (fast path), fall back to frontmatter.name for skills
+	// in case entry.name drifts from the frontmatter
+	let item = items?.find((r) => r.name === name)
+	if (!item && type === "skill") {
+		item = items?.find((r) => {
+			const { data } = parseYamlFrontmatter(r.contents)
+			return typeof data.name === "string" && data.name === name
+		})
+	}
+
+	if (!item?.contents) {
+		throw new Error(`Remote ${type} not found: ${name}`)
+	}
+
+	// Create temp file with read-only header comment
+	const header = `# ⚠️ READ-ONLY: This ${type} is managed by your organization.\n# Changes made here will not be saved.\n\n`
+	const content = header + item.contents
+
+	// Sanitize the name for use in filename (replace invalid characters)
+	const sanitizedName = name.replace(/[<>:"/\\|?*]/g, "_")
+	const tempPath = path.join(os.tmpdir(), `cline-remote-${type}-${sanitizedName}.md`)
+
+	await writeFile(tempPath, content)
+	await openFileIntegration(tempPath)
+}
diff --git a/apps/vscode/src/core/controller/file/openFileRelativePath.ts b/apps/vscode/src/core/controller/file/openFileRelativePath.ts
new file mode 100644
index 0000000..e02cec3
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/openFileRelativePath.ts
@@ -0,0 +1,36 @@
+import { workspaceResolver } from "@core/workspace"
+import { openFile as openFileIntegration } from "@integrations/misc/open-file"
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { getWorkspacePath } from "@utils/path"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Opens a file in the editor by a relative path
+ * @param controller The controller instance
+ * @param request The request message containing the relative file path in the 'value' field
+ * @returns Empty response
+ */
+export async function openFileRelativePath(_controller: Controller, request: StringRequest): Promise<Empty> {
+	const workspacePath = await getWorkspacePath()
+
+	if (!workspacePath) {
+		Logger.error("Error in openFileRelativePath: No workspace path available")
+		return Empty.create()
+	}
+
+	if (request.value) {
+		// Resolve the relative path to absolute path
+		const resolvedPath = workspaceResolver.resolveWorkspacePath(
+			workspacePath,
+			request.value,
+			"Controller.openFileRelativePath",
+		)
+		const absolutePath = typeof resolvedPath === "string" ? resolvedPath : resolvedPath.absolutePath
+
+		// Open the file using the existing integration
+		openFileIntegration(absolutePath)
+	}
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/file/openFocusChainFile.ts b/apps/vscode/src/core/controller/file/openFocusChainFile.ts
new file mode 100644
index 0000000..0523de1
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/openFocusChainFile.ts
@@ -0,0 +1,40 @@
+import { openFile as openFileIntegration } from "@integrations/misc/open-file"
+import { telemetryService } from "../../../services/telemetry"
+import { Empty, StringRequest } from "../../../shared/proto/cline/common"
+import { ensureFocusChainFile, extractFocusChainListFromText } from "../../task/focus-chain/file-utils"
+import { Controller } from ".."
+
+/**
+ * Opens or creates a focus chain checklist markdown file for editing
+ * The file is stored at <globalStorage>/tasks/<taskId>/focus_chain_taskid_<taskId>.md
+ */
+export async function openFocusChainFile(controller: Controller, request: StringRequest): Promise<Empty> {
+	if (!request.value) {
+		throw new Error("Task ID is required")
+	}
+
+	const taskId = request.value
+
+	// Get the current focus chain list from the task's most recent task_progress message
+	let initialFocusChainContent: string | undefined
+	const currentTask = controller.task
+	if (currentTask) {
+		// Get the task's message history and find the most recent task_progress message
+		// TODO - can we decouple this from ClineMessages?
+		const clineMessages = currentTask.messageStateHandler.getClineMessages()
+		const lastProgressMessage = clineMessages
+			.slice()
+			.reverse()
+			.find((m: any) => m.say === "task_progress")
+
+		if (lastProgressMessage && lastProgressMessage.text) {
+			initialFocusChainContent = extractFocusChainListFromText(lastProgressMessage.text) || undefined
+		}
+	}
+
+	const focusChainFilePath = await ensureFocusChainFile(taskId, initialFocusChainContent)
+	telemetryService.captureFocusChainListOpened(taskId)
+	await openFileIntegration(focusChainFilePath)
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/file/openImage.ts b/apps/vscode/src/core/controller/file/openImage.ts
new file mode 100644
index 0000000..4a89677
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/openImage.ts
@@ -0,0 +1,16 @@
+import { openImage as openImageIntegration } from "@integrations/misc/open-file"
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Opens an image in the system viewer
+ * @param controller The controller instance
+ * @param request The request message containing the image path or data URI in the 'value' field
+ * @returns Empty response
+ */
+export async function openImage(_controller: Controller, request: StringRequest): Promise<Empty> {
+	if (request.value) {
+		await openImageIntegration(request.value)
+	}
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/file/openMention.ts b/apps/vscode/src/core/controller/file/openMention.ts
new file mode 100644
index 0000000..d630172
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/openMention.ts
@@ -0,0 +1,14 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { openMention as coreOpenMention } from "../../mentions"
+import { Controller } from ".."
+
+/**
+ * Opens a mention (file path, problem, terminal, or URL)
+ * @param controller The controller instance
+ * @param request The string request containing the mention text
+ * @returns Empty response
+ */
+export async function openMention(_controller: Controller, request: StringRequest): Promise<Empty> {
+	coreOpenMention(request.value)
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/file/refreshHooks.ts b/apps/vscode/src/core/controller/file/refreshHooks.ts
new file mode 100644
index 0000000..ca99ec8
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/refreshHooks.ts
@@ -0,0 +1,85 @@
+import { HookInfo, HooksToggles, WorkspaceHooks } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { resolveExistingHookPath, VALID_HOOK_TYPES } from "../../hooks/utils"
+import { Controller } from ".."
+
+export async function refreshHooks(
+	_controller: Controller,
+	_request?: any,
+	globalHooksDirOverride?: string,
+): Promise<HooksToggles> {
+	const globalHooksDir = globalHooksDirOverride || path.join(os.homedir(), "Documents", "Cline", "Hooks")
+	const isWindows = process.platform === "win32"
+
+	// Collect global hooks
+	const globalHooks: HookInfo[] = []
+	for (const hookName of VALID_HOOK_TYPES) {
+		const hookPath = await resolveExistingHookPath(globalHooksDir, hookName)
+		if (hookPath) {
+			globalHooks.push(
+				HookInfo.create({
+					name: hookName,
+					enabled: await isExecutable(hookPath),
+					absolutePath: hookPath,
+				}),
+			)
+		}
+	}
+
+	// Collect workspace hooks from all workspace folders
+	const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
+	const workspaceHooksList: WorkspaceHooks[] = []
+
+	for (const workspacePath of workspacePaths.paths) {
+		const workspaceHooksDir = path.join(workspacePath, ".clinerules", "hooks")
+		const hooks: HookInfo[] = []
+
+		for (const hookName of VALID_HOOK_TYPES) {
+			const hookPath = await resolveExistingHookPath(workspaceHooksDir, hookName)
+			if (hookPath) {
+				hooks.push(
+					HookInfo.create({
+						name: hookName,
+						enabled: await isExecutable(hookPath),
+						absolutePath: hookPath,
+					}),
+				)
+			}
+		}
+
+		// Add all workspaces, even if they have no hooks yet
+		// This allows users to create their first hook via the dropdown
+		const workspaceName = path.basename(workspacePath)
+		workspaceHooksList.push(
+			WorkspaceHooks.create({
+				workspaceName,
+				hooks,
+			}),
+		)
+	}
+
+	return HooksToggles.create({
+		globalHooks,
+		workspaceHooks: workspaceHooksList,
+		isWindows,
+	})
+}
+
+async function isExecutable(filePath: string): Promise<boolean> {
+	if (process.platform === "win32") {
+		// On Windows, files are "enabled" if they exist
+		// TODO(PR-9552 follow-up): Replace this temporary file-exists behavior
+		// with JSON-backed cross-platform hook enablement state.
+		return true
+	}
+
+	try {
+		await fs.access(filePath, fs.constants.X_OK)
+		return true
+	} catch {
+		return false
+	}
+}
diff --git a/apps/vscode/src/core/controller/file/refreshRules.ts b/apps/vscode/src/core/controller/file/refreshRules.ts
new file mode 100644
index 0000000..71cc9bb
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/refreshRules.ts
@@ -0,0 +1,39 @@
+import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
+import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
+import { refreshWorkflowToggles } from "@core/context/instructions/user-instructions/workflows"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { RefreshedRules } from "@shared/proto/cline/file"
+import { Logger } from "@/shared/services/Logger"
+import { getCwd, getDesktopDir } from "@/utils/path"
+import type { Controller } from "../index"
+
+/**
+ * Refreshes all rule toggles (Cline, External, and Workflows)
+ * @param controller The controller instance
+ * @param _request The empty request
+ * @returns RefreshedRules containing updated toggles for all rule types
+ */
+export async function refreshRules(controller: Controller, _request: EmptyRequest): Promise<RefreshedRules> {
+	try {
+		const cwd = await getCwd(getDesktopDir())
+		const { globalToggles, localToggles } = await refreshClineRulesToggles(controller, cwd)
+		const { cursorLocalToggles, windsurfLocalToggles, agentsLocalToggles } = await refreshExternalRulesToggles(
+			controller,
+			cwd,
+		)
+		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(controller, cwd)
+
+		return RefreshedRules.create({
+			globalClineRulesToggles: { toggles: globalToggles },
+			localClineRulesToggles: { toggles: localToggles },
+			localCursorRulesToggles: { toggles: cursorLocalToggles },
+			localWindsurfRulesToggles: { toggles: windsurfLocalToggles },
+			localAgentsRulesToggles: { toggles: agentsLocalToggles },
+			localWorkflowToggles: { toggles: localWorkflowToggles },
+			globalWorkflowToggles: { toggles: globalWorkflowToggles },
+		})
+	} catch (error) {
+		Logger.error("Failed to refresh rules:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/file/refreshSkills.ts b/apps/vscode/src/core/controller/file/refreshSkills.ts
new file mode 100644
index 0000000..4efc8c6
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/refreshSkills.ts
@@ -0,0 +1,60 @@
+import { type CoreSettingsItem, createCoreSettingsService } from "@cline/core"
+import { parseRemoteSkillEntries } from "@core/context/instructions/user-instructions/skills"
+import { RefreshedSkills, SkillInfo } from "@shared/proto/cline/file"
+import { HostProvider } from "@/hosts/host-provider"
+import { Controller } from ".."
+
+function coreSkillToSkillInfo(skill: CoreSettingsItem): SkillInfo {
+	return SkillInfo.create({
+		name: skill.name,
+		description: skill.description ?? "",
+		path: skill.path,
+		enabled: skill.enabled !== false,
+	})
+}
+
+/**
+ * Refreshes all skill toggles (discovers skills and their enabled state)
+ */
+export async function refreshSkills(controller: Controller): Promise<RefreshedSkills> {
+	// Get workspace paths for local skills
+	const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
+	const primaryWorkspace = workspacePaths.paths[0]
+
+	const settingsSnapshot = await createCoreSettingsService().list({
+		workspaceRoot: primaryWorkspace,
+	})
+	const globalSkills = settingsSnapshot.skills
+		.filter((skill) => skill.source === "global" || skill.source === "global-plugin")
+		.map(coreSkillToSkillInfo)
+	const localSkills = settingsSnapshot.skills
+		.filter((skill) => skill.source === "workspace" || skill.source === "workspace-plugin")
+		.map(coreSkillToSkillInfo)
+
+	// Add remote skills from remote config.
+	// Precedence: remote (enterprise) > disk-global (user) > project (workspace).
+	// Remote entries are appended to globalSkills[] and split into the dedicated "Enterprise Skills"
+	// section by the UI. The toggle store distinguishes them by the "remote:" path prefix.
+	const remoteConfigSettings = controller.stateManager.getRemoteConfigSettings()
+	const remoteSkillsToggles = controller.stateManager.getGlobalStateKey("remoteSkillsToggles") || {}
+	const validatedRemoteSkills = parseRemoteSkillEntries(remoteConfigSettings.remoteGlobalSkills || [])
+
+	for (const entry of validatedRemoteSkills) {
+		const enabled = entry.alwaysEnabled || remoteSkillsToggles[entry.name] !== false
+
+		globalSkills.push(
+			SkillInfo.create({
+				name: entry.name,
+				description: entry.description,
+				path: `remote:${entry.name}`,
+				enabled,
+				alwaysEnabled: entry.alwaysEnabled,
+			}),
+		)
+	}
+
+	return RefreshedSkills.create({
+		globalSkills,
+		localSkills,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/searchCommits.ts b/apps/vscode/src/core/controller/file/searchCommits.ts
new file mode 100644
index 0000000..3211b65
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/searchCommits.ts
@@ -0,0 +1,28 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { GitCommits } from "@shared/proto/cline/file"
+import { searchCommits as searchCommitsUtil } from "@utils/git"
+import { getWorkspacePath } from "@utils/path"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Searches for git commits in the workspace repository
+ * @param controller The controller instance
+ * @param request The request message containing the search query in the 'value' field
+ * @returns GitCommits containing the matching commits
+ */
+export async function searchCommits(_controller: Controller, request: StringRequest): Promise<GitCommits> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return GitCommits.create({ commits: [] })
+	}
+
+	try {
+		const commits = await searchCommitsUtil(request.value || "", cwd)
+
+		return GitCommits.create({ commits })
+	} catch (error) {
+		Logger.error(`Error searching commits: ${JSON.stringify(error)}`)
+		return GitCommits.create({ commits: [] })
+	}
+}
diff --git a/apps/vscode/src/core/controller/file/searchFiles.ts b/apps/vscode/src/core/controller/file/searchFiles.ts
new file mode 100644
index 0000000..afc854d
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/searchFiles.ts
@@ -0,0 +1,174 @@
+import {
+	type FileSearchSource,
+	RipgrepError,
+	type SearchWorkspaceFilesResult,
+	searchWorkspaceFiles,
+	searchWorkspaceFilesMultiroot,
+} from "@services/search/file-search"
+
+import { telemetryService } from "@services/telemetry"
+import { FileSearchRequest, FileSearchResults, FileSearchType } from "@shared/proto/cline/file"
+import { convertSearchResultsToProtoFileInfos } from "@shared/proto-conversions/file/search-result-conversion"
+import { type FsInfo, getFsInfo } from "@utils/fs-info"
+import { getWorkspacePath } from "@utils/path"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+// error_reason values surfaced on FileSearchResults; see proto/cline/file.proto.
+const ERROR_REASON_WORKSPACE_UNAVAILABLE = "workspace_unavailable"
+const ERROR_REASON_RIPGREP_SPAWN_FAILED = "ripgrep_spawn_failed"
+const ERROR_REASON_UNKNOWN = "unknown"
+
+function classifyError(error: unknown): { errorReason: string; errorMessage: string } {
+	const errorMessage = error instanceof Error ? error.message : String(error)
+	if (error instanceof RipgrepError) {
+		const firstStderrLine = error.stderr ? error.stderr.trim().split("\n", 1)[0] : ""
+		return {
+			errorReason: ERROR_REASON_RIPGREP_SPAWN_FAILED,
+			errorMessage: firstStderrLine || errorMessage,
+		}
+	}
+	return { errorReason: ERROR_REASON_UNKNOWN, errorMessage }
+}
+
+// Fire-and-forget the FS-class lookup + telemetry capture. The picker awaits
+// the searchFiles response, so we must not block it on a slow/hung mount —
+// `getFsInfo` does a `realpath` and a `mount`/`stat -f` that, even with the
+// outer timeout in fs-info, can still cost seconds on a stale network FS.
+function captureWithFsContext(fsContextPath: string | undefined, capture: (fsContext: FsInfo) => void | Promise<void>): void {
+	getFsInfo(fsContextPath)
+		.then(capture)
+		.catch((err) => Logger.warn(`searchFiles: telemetry capture failed: ${err}`))
+}
+
+/**
+ * Searches for files in the workspace with fuzzy matching
+ * @param controller The controller instance
+ * @param request The request containing search query, and optionally a mentionsRequestId and workspace_hint
+ * @returns Results containing matching files/folders
+ */
+export async function searchFiles(controller: Controller, request: FileSearchRequest): Promise<FileSearchResults> {
+	// Best-effort path used for FS-class telemetry. Declared in the function
+	// scope so the catch block can also reference it. When the request carries
+	// a workspaceHint we tag against the matched root; for cross-root searches
+	// (no hint) we fall back to the primary root, since attributing one event
+	// to "the root that mattered" is impossible without per-root events.
+	let fsContextPath: string | undefined
+
+	try {
+		// Map enum to string for the search service
+		let selectedTypeString: "file" | "folder" | undefined
+		if (request.selectedType === FileSearchType.FILE) {
+			selectedTypeString = "file"
+		} else if (request.selectedType === FileSearchType.FOLDER) {
+			selectedTypeString = "folder"
+		}
+
+		// Extract hint, ensure workspaceManager is ready, check for multiroot
+		const workspaceHint = request.workspaceHint
+		const workspaceManager = await controller.ensureWorkspaceManager()
+		const hasMultirootSupport = workspaceManager && workspaceManager.getRoots()?.length > 0
+
+		let searchResult: SearchWorkspaceFilesResult
+
+		if (hasMultirootSupport) {
+			// Tag the actually-searched root, not always the primary —
+			// otherwise an SSHFS secondary root looks like a fast primary
+			// in dashboards. searchWorkspaceFilesMultiroot resolves the hint
+			// the same way (by name).
+			const hintedRoot = workspaceHint
+				? (workspaceManager.getRootByName(workspaceHint) ??
+					workspaceManager.getRoots().find((r) => r.path === workspaceHint))
+				: undefined
+			fsContextPath = hintedRoot?.path ?? workspaceManager.getRoots()[0]?.path
+			searchResult = await searchWorkspaceFilesMultiroot(
+				request.query || "",
+				workspaceManager,
+				request.limit || 20,
+				selectedTypeString,
+				workspaceHint,
+			)
+		} else {
+			// Legacy single workspace search
+			const workspacePath = await getWorkspacePath()
+
+			if (!workspacePath) {
+				Logger.error("Error in searchFiles: No workspace path available")
+				telemetryService.captureMentionFailed("folder", "workspace_unavailable", "No workspace path available")
+				return {
+					results: [],
+					mentionsRequestId: request.mentionsRequestId,
+					errorReason: ERROR_REASON_WORKSPACE_UNAVAILABLE,
+					errorMessage: "No workspace path available",
+				}
+			}
+
+			fsContextPath = workspacePath
+			// Call file search service with query from request
+			searchResult = await searchWorkspaceFiles(
+				request.query || "",
+				workspacePath,
+				request.limit || 20, // Use default limit of 20 if not specified
+				selectedTypeString,
+			)
+		}
+
+		const searchSource: FileSearchSource = searchResult.source
+
+		// Convert search results to proto FileInfo objects using the conversion function
+		const protoResults = convertSearchResultsToProtoFileInfos(searchResult.items)
+
+		// Track search results telemetry
+		// Determine search type for telemetry
+		let searchType: "file" | "folder" | "all" = "all"
+		if (request.selectedType === FileSearchType.FILE) {
+			searchType = "file"
+		} else if (request.selectedType === FileSearchType.FOLDER) {
+			searchType = "folder"
+		}
+
+		captureWithFsContext(fsContextPath, (fsContext) =>
+			telemetryService.captureMentionSearchResults(
+				request.query || "",
+				protoResults.length,
+				searchType,
+				protoResults.length === 0,
+				fsContext,
+				searchSource,
+			),
+		)
+
+		// Return successful results
+		return { results: protoResults, mentionsRequestId: request.mentionsRequestId }
+	} catch (error) {
+		const { errorReason, errorMessage } = classifyError(error)
+		Logger.error(`Error in searchFiles (errorReason=${errorReason}):`, error)
+
+		const mentionType =
+			request.selectedType === FileSearchType.FILE
+				? "file"
+				: request.selectedType === FileSearchType.FOLDER
+					? "folder"
+					: "folder" // Default to folder for "all" searches
+
+		const errorType: "ripgrep_spawn_failed" | "permission_denied" | "unknown" =
+			errorReason === ERROR_REASON_RIPGREP_SPAWN_FAILED
+				? "ripgrep_spawn_failed"
+				: error instanceof Error && error.message.includes("permission")
+					? "permission_denied"
+					: "unknown"
+
+		// fsContextPath may be unset if we threw before resolving the workspace;
+		// getFsInfo handles undefined and returns the unknown sentinel.
+		captureWithFsContext(fsContextPath, (fsContext) =>
+			telemetryService.captureMentionFailed(mentionType, errorType, errorMessage, fsContext),
+		)
+
+		return {
+			results: [],
+			mentionsRequestId: request.mentionsRequestId,
+			errorReason,
+			errorMessage,
+		}
+	}
+}
diff --git a/apps/vscode/src/core/controller/file/selectFiles.ts b/apps/vscode/src/core/controller/file/selectFiles.ts
new file mode 100644
index 0000000..0ccdf6b
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/selectFiles.ts
@@ -0,0 +1,21 @@
+import { selectFiles as selectFilesIntegration } from "@integrations/misc/process-files"
+import { BooleanRequest, StringArrays } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Prompts the user to select images from the file system and returns them as data URLs
+ * @param controller The controller instance
+ * @param request Boolean request, with the value defining whether this model supports images
+ * @returns Two arrays of image data URLs and other file paths
+ */
+export async function selectFiles(_controller: Controller, request: BooleanRequest): Promise<StringArrays> {
+	try {
+		const { images, files } = await selectFilesIntegration(request.value)
+		return StringArrays.create({ values1: images, values2: files })
+	} catch (error) {
+		Logger.error("Error selecting images & files:", error)
+		// Return empty array on error
+		return StringArrays.create({ values1: [], values2: [] })
+	}
+}
diff --git a/apps/vscode/src/core/controller/file/toggleAgentsRule.ts b/apps/vscode/src/core/controller/file/toggleAgentsRule.ts
new file mode 100644
index 0000000..eef4575
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleAgentsRule.ts
@@ -0,0 +1,34 @@
+import type { ToggleAgentsRuleRequest } from "@shared/proto/cline/file"
+import { ClineRulesToggles } from "@shared/proto/cline/file"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Toggles an Agents rule (enable or disable)
+ * @param controller The controller instance
+ * @param request The toggle request
+ * @returns The updated Agents rule toggles
+ */
+export async function toggleAgentsRule(controller: Controller, request: ToggleAgentsRuleRequest): Promise<ClineRulesToggles> {
+	const { rulePath, enabled } = request
+
+	if (!rulePath || typeof enabled !== "boolean") {
+		Logger.error("toggleAgentsRule: Missing or invalid parameters", {
+			rulePath,
+			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
+		})
+		throw new Error("Missing or invalid parameters for toggleAgentsRule")
+	}
+
+	// Update the toggle in workspace state
+	const toggles = controller.stateManager.getWorkspaceStateKey("localAgentsRulesToggles")
+	toggles[rulePath] = enabled
+	controller.stateManager.setWorkspaceState("localAgentsRulesToggles", toggles)
+
+	// Get the current state to return in the response
+	const agentsToggles = controller.stateManager.getWorkspaceStateKey("localAgentsRulesToggles")
+
+	return ClineRulesToggles.create({
+		toggles: agentsToggles,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/toggleClineRule.ts b/apps/vscode/src/core/controller/file/toggleClineRule.ts
new file mode 100644
index 0000000..d5bc14b
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleClineRule.ts
@@ -0,0 +1,68 @@
+import { getWorkspaceBasename } from "@core/workspace"
+import type { ToggleClineRuleRequest } from "@shared/proto/cline/file"
+import { RuleScope, ToggleClineRules } from "@shared/proto/cline/file"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Toggles a Cline rule (enable or disable)
+ * @param controller The controller instance
+ * @param request The toggle request
+ * @returns The updated Cline rule toggles
+ */
+export async function toggleClineRule(controller: Controller, request: ToggleClineRuleRequest): Promise<ToggleClineRules> {
+	const { scope, rulePath, enabled } = request
+
+	if (!rulePath || typeof enabled !== "boolean" || scope === undefined) {
+		Logger.error("toggleClineRule: Missing or invalid parameters", {
+			rulePath,
+			scope,
+			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
+		})
+		throw new Error("Missing or invalid parameters for toggleClineRule")
+	}
+
+	// Handle the three different scopes
+	switch (scope) {
+		case RuleScope.GLOBAL: {
+			const toggles = controller.stateManager.getGlobalSettingsKey("globalClineRulesToggles")
+			toggles[rulePath] = enabled
+			controller.stateManager.setGlobalState("globalClineRulesToggles", toggles)
+			break
+		}
+		case RuleScope.LOCAL: {
+			const toggles = controller.stateManager.getWorkspaceStateKey("localClineRulesToggles")
+			toggles[rulePath] = enabled
+			controller.stateManager.setWorkspaceState("localClineRulesToggles", toggles)
+			break
+		}
+		case RuleScope.REMOTE: {
+			const toggles = controller.stateManager.getGlobalStateKey("remoteRulesToggles")
+			toggles[rulePath] = enabled
+			controller.stateManager.setGlobalState("remoteRulesToggles", toggles)
+			break
+		}
+		default:
+			throw new Error(`Invalid scope: ${scope}`)
+	}
+
+	// Track rule toggle telemetry with current task context
+	if (controller.task?.ulid) {
+		// Extract just the filename for privacy (no full paths)
+		const ruleFileName = getWorkspaceBasename(rulePath, "Controller.toggleClineRule")
+		const isGlobal = scope === RuleScope.GLOBAL
+		telemetryService.captureClineRuleToggled(controller.task.ulid, ruleFileName, enabled, isGlobal)
+	}
+
+	// Get the current state to return in the response
+	const globalToggles = controller.stateManager.getGlobalSettingsKey("globalClineRulesToggles")
+	const localToggles = controller.stateManager.getWorkspaceStateKey("localClineRulesToggles")
+	const remoteToggles = controller.stateManager.getGlobalStateKey("remoteRulesToggles")
+
+	return ToggleClineRules.create({
+		globalClineRulesToggles: { toggles: globalToggles },
+		localClineRulesToggles: { toggles: localToggles },
+		remoteRulesToggles: { toggles: remoteToggles },
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/toggleCursorRule.ts b/apps/vscode/src/core/controller/file/toggleCursorRule.ts
new file mode 100644
index 0000000..6d48700
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleCursorRule.ts
@@ -0,0 +1,34 @@
+import type { ToggleCursorRuleRequest } from "@shared/proto/cline/file"
+import { ClineRulesToggles } from "@shared/proto/cline/file"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Toggles a Cursor rule (enable or disable)
+ * @param controller The controller instance
+ * @param request The toggle request
+ * @returns The updated Cursor rule toggles
+ */
+export async function toggleCursorRule(controller: Controller, request: ToggleCursorRuleRequest): Promise<ClineRulesToggles> {
+	const { rulePath, enabled } = request
+
+	if (!rulePath || typeof enabled !== "boolean") {
+		Logger.error("toggleCursorRule: Missing or invalid parameters", {
+			rulePath,
+			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
+		})
+		throw new Error("Missing or invalid parameters for toggleCursorRule")
+	}
+
+	// Update the toggles in workspace state
+	const toggles = controller.stateManager.getWorkspaceStateKey("localCursorRulesToggles")
+	toggles[rulePath] = enabled
+	controller.stateManager.setWorkspaceState("localCursorRulesToggles", toggles)
+
+	// Get the current state to return in the response
+	const cursorToggles = controller.stateManager.getWorkspaceStateKey("localCursorRulesToggles")
+
+	return ClineRulesToggles.create({
+		toggles: cursorToggles,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/toggleHook.ts b/apps/vscode/src/core/controller/file/toggleHook.ts
new file mode 100644
index 0000000..2372193
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleHook.ts
@@ -0,0 +1,41 @@
+import { ToggleHookRequest, ToggleHookResponse } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import { HookDiscoveryCache } from "../../hooks/HookDiscoveryCache"
+import { resolveExistingHookPath, resolveHooksDirectory } from "../../hooks/utils"
+import { Controller } from ".."
+import { refreshHooks } from "./refreshHooks"
+
+export async function toggleHook(
+	controller: Controller,
+	request: ToggleHookRequest,
+	globalHooksDirOverride?: string,
+): Promise<ToggleHookResponse> {
+	const { hookName, isGlobal, enabled, workspaceName } = request
+
+	// Determine hook path
+	const hooksDir = await resolveHooksDirectory(isGlobal, workspaceName, globalHooksDirOverride)
+	const hookPath = await resolveExistingHookPath(hooksDir, hookName)
+
+	// Verify hook exists
+	if (!hookPath) {
+		throw new Error(`Hook ${hookName} does not exist in ${hooksDir}`)
+	}
+
+	// On Windows, we can't use chmod, so we just return the current state
+	// without modifying the file. The frontend will disable the toggle.
+	// TODO(PR-9552 follow-up): Replace this temporary behavior with a
+	// JSON-backed cross-platform enabled/disabled hook state.
+	if (process.platform !== "win32") {
+		// Toggle executable bit (Unix-like systems only)
+		// TODO(PR-9552 follow-up): Revisit chmod-driven enablement semantics
+		// once cross-platform JSON-backed state is implemented.
+		await fs.chmod(hookPath, enabled ? 0o755 : 0o644)
+	}
+
+	// Invalidate cache
+	await HookDiscoveryCache.getInstance().invalidateAll()
+
+	// Return updated state
+	const hooksToggles = await refreshHooks(controller, undefined, globalHooksDirOverride)
+	return ToggleHookResponse.create({ hooksToggles })
+}
diff --git a/apps/vscode/src/core/controller/file/toggleSkill.ts b/apps/vscode/src/core/controller/file/toggleSkill.ts
new file mode 100644
index 0000000..66477a2
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleSkill.ts
@@ -0,0 +1,57 @@
+import { setSkillDisabledInFrontmatter } from "@core/context/instructions/user-instructions/skills"
+import { SkillsToggles, ToggleSkillRequest } from "@shared/proto/cline/file"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Toggles a skill on or off
+ * @param controller The controller instance
+ * @param request The request containing the skill path and enabled state
+ * @returns The updated skills toggles
+ */
+export async function toggleSkill(controller: Controller, request: ToggleSkillRequest): Promise<SkillsToggles> {
+	const { skillPath, isGlobal, enabled } = request
+
+	if (!skillPath || typeof enabled !== "boolean" || typeof isGlobal !== "boolean") {
+		Logger.error("toggleSkill: Missing or invalid parameters", {
+			skillPath,
+			isGlobal,
+			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
+		})
+		throw new Error("Missing or invalid parameters for toggleSkill")
+	}
+
+	let globalToggles = controller.stateManager.getGlobalSettingsKey("globalSkillsToggles") || {}
+	let localToggles = controller.stateManager.getWorkspaceStateKey("localSkillsToggles") || {}
+
+	let remoteToggles = controller.stateManager.getGlobalStateKey("remoteSkillsToggles") || {}
+
+	// Remote skills are identified by a "remote:" path prefix. They use a separate toggle store
+	// keyed by skill name (the part after "remote:") rather than the file path.
+	if (skillPath.startsWith("remote:")) {
+		const name = skillPath.replace("remote:", "")
+		remoteToggles = { ...remoteToggles, [name]: enabled }
+		controller.stateManager.setGlobalState("remoteSkillsToggles", remoteToggles)
+	} else if (isGlobal) {
+		globalToggles = { ...globalToggles, [skillPath]: enabled }
+		controller.stateManager.setGlobalState("globalSkillsToggles", globalToggles)
+	} else {
+		localToggles = { ...localToggles, [skillPath]: enabled }
+		controller.stateManager.setWorkspaceState("localSkillsToggles", localToggles)
+	}
+
+	// Persist the enabled state to the SKILL.md frontmatter as well. The SDK
+	// builds the model's skill list / `skills` tool from the frontmatter
+	// `disabled` flag, not from the extension's UI toggle state, so without this
+	// write a skill toggled off in the sidebar would still be offered to the
+	// model (ENG-1995). The helper is a no-op for remote skills (no backing file).
+	await setSkillDisabledInFrontmatter(skillPath, enabled)
+
+	await controller.postStateToWebview()
+
+	return SkillsToggles.create({
+		globalSkillsToggles: globalToggles,
+		localSkillsToggles: localToggles,
+		remoteSkillsToggles: remoteToggles,
+	})
+}
diff --git a/apps/vscode/src/core/controller/file/toggleWindsurfRule.ts b/apps/vscode/src/core/controller/file/toggleWindsurfRule.ts
new file mode 100644
index 0000000..8fefd23
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleWindsurfRule.ts
@@ -0,0 +1,30 @@
+import type { ToggleWindsurfRuleRequest } from "@shared/proto/cline/file"
+import { ClineRulesToggles } from "@shared/proto/cline/file"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Toggles a Windsurf rule (enable or disable)
+ * @param controller The controller instance
+ * @param request The toggle request
+ * @returns The updated Windsurf rule toggles
+ */
+export async function toggleWindsurfRule(controller: Controller, request: ToggleWindsurfRuleRequest): Promise<ClineRulesToggles> {
+	const { rulePath, enabled } = request
+
+	if (!rulePath || typeof enabled !== "boolean") {
+		Logger.error("toggleWindsurfRule: Missing or invalid parameters", {
+			rulePath,
+			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
+		})
+		throw new Error("Missing or invalid parameters for toggleWindsurfRule")
+	}
+
+	// Update the toggles
+	const toggles = controller.stateManager.getWorkspaceStateKey("localWindsurfRulesToggles")
+	toggles[rulePath] = enabled
+	controller.stateManager.setWorkspaceState("localWindsurfRulesToggles", toggles)
+
+	// Return the toggles directly
+	return ClineRulesToggles.create({ toggles: toggles })
+}
diff --git a/apps/vscode/src/core/controller/file/toggleWorkflow.ts b/apps/vscode/src/core/controller/file/toggleWorkflow.ts
new file mode 100644
index 0000000..9ded0ab
--- /dev/null
+++ b/apps/vscode/src/core/controller/file/toggleWorkflow.ts
@@ -0,0 +1,53 @@
+import { ClineRulesToggles, RuleScope, ToggleWorkflowRequest } from "@shared/proto/cline/file"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Toggles a workflow on or off
+ * @param controller The controller instance
+ * @param request The request containing the workflow path and enabled state
+ * @returns The updated workflow toggles
+ */
+export async function toggleWorkflow(controller: Controller, request: ToggleWorkflowRequest): Promise<ClineRulesToggles> {
+	const { workflowPath, enabled, scope } = request
+
+	if (!workflowPath || typeof enabled !== "boolean" || scope === undefined) {
+		Logger.error("toggleWorkflow: Missing or invalid parameters", {
+			workflowPath,
+			scope,
+			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
+		})
+		throw new Error("Missing or invalid parameters for toggleWorkflow")
+	}
+
+	// Handle the three different scopes
+	let toggles: Record<string, boolean>
+
+	switch (scope) {
+		case RuleScope.GLOBAL: {
+			toggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles")
+			toggles[workflowPath] = enabled
+			controller.stateManager.setGlobalState("globalWorkflowToggles", toggles)
+			break
+		}
+		case RuleScope.LOCAL: {
+			toggles = controller.stateManager.getWorkspaceStateKey("workflowToggles")
+			toggles[workflowPath] = enabled
+			controller.stateManager.setWorkspaceState("workflowToggles", toggles)
+			break
+		}
+		case RuleScope.REMOTE: {
+			toggles = controller.stateManager.getGlobalStateKey("remoteWorkflowToggles")
+			toggles[workflowPath] = enabled
+			controller.stateManager.setGlobalState("remoteWorkflowToggles", toggles)
+			break
+		}
+		default:
+			throw new Error(`Invalid scope: ${scope}`)
+	}
+
+	await controller.postStateToWebview()
+
+	// Return the updated toggles
+	return ClineRulesToggles.create({ toggles: toggles })
+}
diff --git a/apps/vscode/src/core/controller/grpc-handler.test.ts b/apps/vscode/src/core/controller/grpc-handler.test.ts
new file mode 100644
index 0000000..903a944
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-handler.test.ts
@@ -0,0 +1,416 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import { Controller } from "@core/controller"
+import { serviceHandlers } from "@generated/hosts/vscode/protobus-services"
+import { GrpcCancel, GrpcRequest } from "@shared/WebviewMessage"
+import { expect } from "chai"
+import * as sinon from "sinon"
+import { getRequestRegistry, handleGrpcRequest, handleGrpcRequestCancel } from "./grpc-handler"
+
+describe("grpc-handler", () => {
+	let sandbox: sinon.SinonSandbox
+	let mockController: Controller
+	let mockPostMessageToWebview: sinon.SinonStub
+
+	let mockUnaryHandler: sinon.SinonStub
+	let mockUnaryFailingHandler: sinon.SinonStub
+	let mockStreamingHandler: sinon.SinonStub
+	let mockStreamingFailingHandler: sinon.SinonStub
+
+	const serviceName = "cline.TestService"
+	const mockResponse = { result: "result-1234" }
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		// Create a mock controller
+		mockController = {} as any
+		mockPostMessageToWebview = sandbox.stub().resolves()
+
+		// Create mock service handlers
+		mockUnaryHandler = sandbox.stub().resolves(mockResponse)
+		mockStreamingHandler = sandbox.stub().resolves()
+		mockUnaryFailingHandler = sandbox.stub().rejects(new Error("Test error unary"))
+		mockStreamingFailingHandler = sandbox.stub().rejects(new Error("Stream error"))
+		serviceHandlers[serviceName] = {
+			testUnary: mockUnaryHandler,
+			testUnaryFailing: mockUnaryFailingHandler,
+			testStreaming: mockStreamingHandler,
+			testStreamingFailing: mockStreamingFailingHandler,
+		}
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe("handleGrpcRequest", () => {
+		describe("Unary requests", () => {
+			it("should handle successful unary requests", async () => {
+				const request: GrpcRequest = {
+					service: serviceName,
+					method: "testUnary",
+					message: { input: "test" },
+					request_id: "test-123",
+					is_streaming: false,
+				}
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the handler was called
+				expect(mockUnaryHandler.calledOnce).to.be.true
+				expect(mockUnaryHandler.firstCall.args[0]).to.equal(mockController)
+				expect(mockUnaryHandler.firstCall.args[1]).to.deep.equal({ input: "test" })
+
+				// Verify the response was sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+				const sentMessage = mockPostMessageToWebview.firstCall.args[0]
+				expect(sentMessage).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: mockResponse,
+						request_id: "test-123",
+					},
+				})
+			})
+
+			it("should handle errors in unary requests", async () => {
+				const request: GrpcRequest = {
+					service: serviceName,
+					method: "testUnaryFailing",
+					message: { input: "test" },
+					request_id: "test-456",
+					is_streaming: false,
+				}
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the error response was sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+				const sentMessage = mockPostMessageToWebview.firstCall.args[0]
+				expect(sentMessage).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						error: "Test error unary",
+						request_id: "test-456",
+						is_streaming: false,
+					},
+				})
+			})
+
+			it("should handle unknown service errors", async () => {
+				const request: GrpcRequest = {
+					service: "UnknownService",
+					method: "someMethod",
+					message: {},
+					request_id: "test-789",
+					is_streaming: false,
+				}
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the error response was sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+				const sentMessage = mockPostMessageToWebview.firstCall.args[0]
+				expect(sentMessage.type).to.equal("grpc_response")
+				expect(sentMessage.grpc_response?.error).to.include("Unknown service: UnknownService")
+				expect(sentMessage.grpc_response?.request_id).to.equal("test-789")
+			})
+
+			it("should handle unknown method errors", async () => {
+				const request: GrpcRequest = {
+					service: serviceName,
+					method: "unknownMethod",
+					message: {},
+					request_id: "test-999",
+					is_streaming: false,
+				}
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the error response was sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+				const sentMessage = mockPostMessageToWebview.firstCall.args[0]
+				expect(sentMessage.type).to.equal("grpc_response")
+				expect(sentMessage.grpc_response?.error).to.include("Unknown rpc: cline.TestService.unknownMethod")
+				expect(sentMessage.grpc_response?.request_id).to.equal("test-999")
+			})
+		})
+		describe("Streaming requests", () => {
+			it("should handle successful streaming requests", async () => {
+				// Set up a streaming handler that sends multiple responses
+				const request: GrpcRequest = {
+					service: serviceName,
+					method: "testStreaming",
+					message: { input: "stream" },
+					request_id: "stream-123",
+					is_streaming: true,
+				}
+
+				// Reset the mock and set up the handler using callsFake
+				mockStreamingHandler.reset()
+				mockStreamingHandler.callsFake(
+					async (_controller: any, _message: any, responseStream: any, _requestId: string) => {
+						// Simulate streaming multiple messages
+						await responseStream({ value: 1 }, false, 0)
+						await responseStream({ value: 2 }, false, 1)
+						await responseStream({ value: 3 }, true, 2) // Last message
+					},
+				)
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the handler was called
+				expect(mockStreamingHandler.calledOnce).to.be.true
+				expect(mockStreamingHandler.firstCall.args[0]).to.equal(mockController)
+				expect(mockStreamingHandler.firstCall.args[1]).to.deep.equal({ input: "stream" })
+				expect(mockStreamingHandler.firstCall.args[3]).to.equal("stream-123")
+
+				// Verify all streaming responses were sent
+				expect(mockPostMessageToWebview.callCount).to.equal(3)
+
+				// Check all responses
+				expect(mockPostMessageToWebview.firstCall.args[0]).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: { value: 1 },
+						request_id: "stream-123",
+						is_streaming: true,
+						sequence_number: 0,
+					},
+				})
+				expect(mockPostMessageToWebview.secondCall.args[0]).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: { value: 2 },
+						request_id: "stream-123",
+						is_streaming: true,
+						sequence_number: 1,
+					},
+				})
+				expect(mockPostMessageToWebview.thirdCall.args[0]).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: { value: 3 },
+						request_id: "stream-123",
+						is_streaming: false, // Last message has is_streaming: false
+						sequence_number: 2,
+					},
+				})
+			})
+
+			it("should handle errors in streaming requests", async () => {
+				const request: GrpcRequest = {
+					service: serviceName,
+					method: "testStreamingFailing",
+					message: { input: "stream" },
+					request_id: "stream-456",
+					is_streaming: true,
+				}
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the error response was sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+				const sentMessage = mockPostMessageToWebview.firstCall.args[0]
+				expect(sentMessage).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						error: "Stream error",
+						request_id: "stream-456",
+						is_streaming: false,
+					},
+				})
+			})
+
+			it("should handle streaming with message, error, then another message", async () => {
+				// This test simulates a scenario where:
+				// 1. First message is sent successfully
+				// 2. An error occurs
+				// 3. Another message is attempted (which should not be sent after error)
+
+				const request: GrpcRequest = {
+					service: serviceName,
+					method: "testStreaming",
+					message: { input: "stream-with-error" },
+					request_id: "stream-error-mid",
+					is_streaming: true,
+				}
+
+				// Reset the mock and set up the handler to throw an error after being called
+				mockStreamingHandler.reset()
+				mockStreamingHandler.callsFake(
+					async (_controller: any, _message: any, responseStream: any, _requestId: string) => {
+						// Send first message successfully
+						await responseStream({ value: "first" }, false, 0)
+						// Throw an error
+						throw new Error("Mid-stream error")
+					},
+				)
+
+				await handleGrpcRequest(mockController, mockPostMessageToWebview, request)
+
+				// Verify the handler was called
+				expect(mockStreamingHandler.calledOnce).to.be.true
+
+				// Verify that we got the first message and then the error
+				expect(mockPostMessageToWebview.callCount).to.equal(2)
+
+				// Check first message was sent successfully
+				expect(mockPostMessageToWebview.firstCall.args[0]).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: { value: "first" },
+						request_id: "stream-error-mid",
+						is_streaming: true,
+						sequence_number: 0,
+					},
+				})
+
+				// Check error response was sent
+				expect(mockPostMessageToWebview.secondCall.args[0]).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						error: "Mid-stream error",
+						request_id: "stream-error-mid",
+						is_streaming: false,
+					},
+				})
+
+				// Try to send another message after the error (simulating what might happen
+				// if the handler tried to continue after an error)
+				const responseStream = mockStreamingHandler.firstCall.args[2]
+
+				// This should still work as the responseStream function is still valid
+				await responseStream({ value: "after-error" }, false, 1)
+
+				// Verify we now have 3 total calls (first message, error, after-error message)
+				expect(mockPostMessageToWebview.callCount).to.equal(3)
+
+				// Verify the message after error was still sent
+				// (In a real scenario, the handler would have stopped due to the error,
+				// but this tests that the responseStream function itself still works)
+				expect(mockPostMessageToWebview.thirdCall.args[0]).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: { value: "after-error" },
+						request_id: "stream-error-mid",
+						is_streaming: true,
+						sequence_number: 1,
+					},
+				})
+			})
+		})
+
+		describe("handleGrpcRequestCancel", () => {
+			it("should cancel an active request", async () => {
+				// Register a request in the registry
+				const registry = getRequestRegistry()
+				const cleanupStub = sandbox.stub()
+				registry.registerRequest("cancel-123", cleanupStub)
+
+				const cancelRequest: GrpcCancel = {
+					request_id: "cancel-123",
+				}
+
+				await handleGrpcRequestCancel(mockPostMessageToWebview, cancelRequest)
+
+				// Verify the cleanup was called
+				expect(cleanupStub.calledOnce).to.be.true
+
+				// Verify the cancellation confirmation was sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+				const sentMessage = mockPostMessageToWebview.firstCall.args[0]
+				expect(sentMessage).to.deep.equal({
+					type: "grpc_response",
+					grpc_response: {
+						message: { cancelled: true },
+						request_id: "cancel-123",
+						is_streaming: false,
+					},
+				})
+
+				// Verify the request was removed from the registry
+				expect(registry.hasRequest("cancel-123")).to.be.false
+			})
+
+			it("should handle cancellation of non-existent request", async () => {
+				const cancelRequest: GrpcCancel = {
+					request_id: "non-existent",
+				}
+
+				await handleGrpcRequestCancel(mockPostMessageToWebview, cancelRequest)
+
+				// Verify no message was sent (request not found)
+				expect(mockPostMessageToWebview.called).to.be.false
+			})
+
+			it("should handle cleanup errors gracefully", async () => {
+				// Register a request with a failing cleanup
+				const registry = getRequestRegistry()
+				const cleanupStub = sandbox.stub().throws(new Error("Cleanup failed"))
+				registry.registerRequest("cancel-error", cleanupStub)
+
+				const cancelRequest: GrpcCancel = {
+					request_id: "cancel-error",
+				}
+
+				// Should not throw
+				await handleGrpcRequestCancel(mockPostMessageToWebview, cancelRequest)
+
+				// Verify the cleanup was attempted
+				expect(cleanupStub.calledOnce).to.be.true
+
+				// Verify the cancellation confirmation was still sent
+				expect(mockPostMessageToWebview.calledOnce).to.be.true
+
+				// Verify the request was removed despite the error
+				expect(registry.hasRequest("cancel-error")).to.be.false
+			})
+		})
+
+		describe("Concurrent requests", () => {
+			it("should handle concurrent requests", async () => {
+				// Set up handlers
+				mockUnaryHandler.resolves({ result: "unary" })
+				mockStreamingHandler.callsFake(async (_controller: any, _message: any, responseStream: any) => {
+					await responseStream({ value: "stream1" }, false, 0)
+					await responseStream({ value: "stream2" }, true, 1)
+				})
+
+				// Send multiple requests concurrently
+				const requests = [
+					handleGrpcRequest(mockController, mockPostMessageToWebview, {
+						service: serviceName,
+						method: "testUnary",
+						message: { id: 1 },
+						request_id: "concurrent-1",
+						is_streaming: false,
+					}),
+					handleGrpcRequest(mockController, mockPostMessageToWebview, {
+						service: serviceName,
+						method: "testStreaming",
+						message: { id: 2 },
+						request_id: "concurrent-2",
+						is_streaming: true,
+					}),
+					handleGrpcRequest(mockController, mockPostMessageToWebview, {
+						service: serviceName,
+						method: "testUnary",
+						message: { id: 3 },
+						request_id: "concurrent-3",
+						is_streaming: false,
+					}),
+				]
+
+				await Promise.all(requests)
+
+				// Verify all handlers were called
+				expect(mockUnaryHandler.callCount).to.equal(2)
+				expect(mockStreamingHandler.callCount).to.equal(1)
+
+				// Verify all responses were sent (2 unary + 2 streaming)
+				expect(mockPostMessageToWebview.callCount).to.equal(4)
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/core/controller/grpc-handler.ts b/apps/vscode/src/core/controller/grpc-handler.ts
new file mode 100644
index 0000000..88e89da
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-handler.ts
@@ -0,0 +1,203 @@
+import { Controller } from "@core/controller/index"
+import { serviceHandlers } from "@generated/hosts/vscode/protobus-services"
+import { GrpcRecorderBuilder } from "@/core/controller/grpc-recorder/grpc-recorder.builder"
+import { GrpcRequestRegistry } from "@/core/controller/grpc-request-registry"
+import { ExtensionMessage } from "@/shared/ExtensionMessage"
+import { Logger } from "@/shared/services/Logger"
+import { GrpcCancel, GrpcRequest } from "@/shared/WebviewMessage"
+
+/**
+ * Type definition for a streaming response handler
+ */
+export type StreamingResponseHandler<TResponse> = (
+	response: TResponse,
+	isLast?: boolean,
+	sequenceNumber?: number,
+) => Promise<void>
+
+export type PostMessageToWebview = (message: ExtensionMessage) => Thenable<boolean | undefined>
+
+/**
+ * Creates a middleware wrapper for recording gRPC requests and responses
+ */
+function withRecordingMiddleware(postMessage: PostMessageToWebview, controller: Controller): PostMessageToWebview {
+	return async (response: ExtensionMessage) => {
+		if (response?.grpc_response) {
+			try {
+				GrpcRecorderBuilder.getRecorder(controller).recordResponse(
+					response.grpc_response.request_id,
+					response.grpc_response,
+				)
+			} catch (e) {
+				Logger.warn("Failed to record gRPC response:", e)
+			}
+		}
+		return postMessage(response)
+	}
+}
+
+/**
+ * Records gRPC request with error handling
+ */
+function recordRequest(request: GrpcRequest, controller: Controller): void {
+	try {
+		GrpcRecorderBuilder.getRecorder(controller).recordRequest(request)
+	} catch (e) {
+		Logger.warn("Failed to record gRPC request:", e)
+	}
+}
+
+/**
+ * Handles a gRPC request from the webview.
+ */
+export async function handleGrpcRequest(
+	controller: Controller,
+	postMessageToWebview: PostMessageToWebview,
+	request: GrpcRequest,
+): Promise<void> {
+	recordRequest(request, controller)
+
+	// Create recording middleware wrapper
+	const postMessageWithRecording = withRecordingMiddleware(postMessageToWebview, controller)
+
+	if (request.is_streaming) {
+		await handleStreamingRequest(controller, postMessageWithRecording, request)
+	} else {
+		await handleUnaryRequest(controller, postMessageWithRecording, request)
+	}
+}
+
+/**
+ * Handles a gRPC unary request from the webview.
+ *
+ * Calls the handler using the service and method name, and then posts the result back to the webview.
+ */
+async function handleUnaryRequest(
+	controller: Controller,
+	postMessageToWebview: PostMessageToWebview,
+	request: GrpcRequest,
+): Promise<void> {
+	try {
+		// Get the service handler from the config
+		const handler = getHandler(request.service, request.method)
+		// Handle unary request
+		const response = await handler(controller, request.message)
+		// Send response to the webview
+		await postMessageToWebview({
+			type: "grpc_response",
+			grpc_response: {
+				message: response,
+				request_id: request.request_id,
+			},
+		})
+	} catch (error) {
+		// Send error response
+		Logger.log("Protobus error:", error)
+		await postMessageToWebview({
+			type: "grpc_response",
+			grpc_response: {
+				error: error instanceof Error ? error.message : String(error),
+				request_id: request.request_id,
+				is_streaming: false,
+			},
+		})
+	}
+}
+
+/**
+ * Handle a streaming gRPC request from the webview.
+ *
+ * Calls the handler using the service and method name, and creates a streaming response handler
+ * which posts results back to the webview.
+ */
+async function handleStreamingRequest(
+	controller: Controller,
+	postMessageToWebview: PostMessageToWebview,
+	request: GrpcRequest,
+): Promise<void> {
+	// Create a response stream function
+	const responseStream: StreamingResponseHandler<any> = async (
+		response: any,
+		isLast: boolean = false,
+		sequenceNumber?: number,
+	) => {
+		await postMessageToWebview({
+			type: "grpc_response",
+			grpc_response: {
+				message: response,
+				request_id: request.request_id,
+				is_streaming: !isLast,
+				sequence_number: sequenceNumber,
+			},
+		})
+	}
+
+	try {
+		// Get the service handler from the config
+		const handler = getHandler(request.service, request.method)
+
+		// Handle streaming request and pass the requestId to all streaming handlers
+		await handler(controller, request.message, responseStream, request.request_id)
+
+		// Don't send a final message here - the stream should stay open for future updates
+		// The stream will be closed when the client disconnects or when the service explicitly ends it
+	} catch (error) {
+		// Send error response
+		Logger.log("Protobus error:", error)
+		await postMessageToWebview({
+			type: "grpc_response",
+			grpc_response: {
+				error: error instanceof Error ? error.message : String(error),
+				request_id: request.request_id,
+				is_streaming: false,
+			},
+		})
+	}
+}
+
+/**
+ * Handles a gRPC request cancellation from the webview.
+ * @param controller The controller instance
+ * @param request The cancellation request
+ */
+export async function handleGrpcRequestCancel(postMessageToWebview: PostMessageToWebview, request: GrpcCancel) {
+	const cancelled = requestRegistry.cancelRequest(request.request_id)
+
+	if (cancelled) {
+		// Send a cancellation confirmation
+		await postMessageToWebview({
+			type: "grpc_response",
+			grpc_response: {
+				message: { cancelled: true },
+				request_id: request.request_id,
+				is_streaming: false,
+			},
+		})
+	} else {
+		Logger.log(`[DEBUG] Request not found for cancellation: ${request.request_id}`)
+	}
+}
+
+// Registry to track active gRPC requests and their cleanup functions
+const requestRegistry = new GrpcRequestRegistry()
+
+/**
+ * Get the request registry instance
+ * This allows other parts of the code to access the registry
+ */
+export function getRequestRegistry(): GrpcRequestRegistry {
+	return requestRegistry
+}
+
+function getHandler(serviceName: string, methodName: string): any {
+	// Get the service handler from the config
+	const serviceConfig = serviceHandlers[serviceName]
+	if (!serviceConfig) {
+		throw new Error(`Unknown service: ${serviceName}`)
+	}
+	const handler = serviceConfig[methodName]
+	if (!handler) {
+		throw new Error(`Unknown rpc: ${serviceName}.${methodName}`)
+	}
+	return handler
+}
diff --git a/apps/vscode/src/core/controller/grpc-recorder/__tests__/grpc-recorder.builder.test.ts b/apps/vscode/src/core/controller/grpc-recorder/__tests__/grpc-recorder.builder.test.ts
new file mode 100644
index 0000000..4bdd332
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/__tests__/grpc-recorder.builder.test.ts
@@ -0,0 +1,50 @@
+import { describe, it } from "bun:test"
+import "should"
+import { GrpcRecorderNoops } from "@/core/controller/grpc-recorder/grpc-recorder"
+import { GrpcRecorderBuilder } from "@/core/controller/grpc-recorder/grpc-recorder.builder"
+import { LogFileHandler } from "@/core/controller/grpc-recorder/log-file-handler"
+
+describe("GrpcRecorderBuilder", () => {
+	describe("when not enabling", () => {
+		it("should return GrpcRecorderNoops when enableIf is false", () => {
+			const builder = new GrpcRecorderBuilder()
+			const recorder = builder.enableIf(false).build()
+
+			recorder.should.be.instanceOf(GrpcRecorderNoops)
+		})
+
+		it("should return GrpcRecorderNoops when enableIf is false even with log file handler", () => {
+			const builder = new GrpcRecorderBuilder()
+			const logFileHandler = new LogFileHandler()
+			const recorder = builder.withLogFileHandler(logFileHandler).enableIf(false).build()
+
+			recorder.should.be.instanceOf(GrpcRecorderNoops)
+		})
+	})
+
+	describe("GrpcRecorderNoops functionality", () => {
+		it("should have no-op methods that don't throw errors", () => {
+			const recorder = new GrpcRecorderNoops()
+
+			recorder.recordRequest({
+				request_id: "test-id",
+				service: "TestService",
+				method: "testMethod",
+				message: {},
+				is_streaming: false,
+			})
+
+			recorder.recordResponse("test-id", {
+				request_id: "test-id",
+				message: {},
+			})
+
+			recorder.recordError("test-id", "test error")
+
+			const sessionLog = recorder.getSessionLog()
+			sessionLog.should.have.property("startTime").which.is.a.String()
+			sessionLog.should.have.property("entries").which.is.an.Array()
+			sessionLog.entries.should.have.length(0)
+		})
+	})
+})
diff --git a/apps/vscode/src/core/controller/grpc-recorder/__tests__/grpc-recorder.test.ts b/apps/vscode/src/core/controller/grpc-recorder/__tests__/grpc-recorder.test.ts
new file mode 100644
index 0000000..05cbf2a
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/__tests__/grpc-recorder.test.ts
@@ -0,0 +1,215 @@
+import { beforeAll, describe, it } from "bun:test"
+import { GrpcRecorder, IRecorder } from "@core/controller/grpc-recorder/grpc-recorder"
+import { expect } from "chai"
+import { ExtensionMessage } from "@/shared/ExtensionMessage"
+import { GrpcRequest } from "@/shared/WebviewMessage"
+
+describe("grpc-recorder", () => {
+	let recorder: IRecorder
+
+	beforeAll(async () => {
+		recorder = GrpcRecorder.builder()
+			.withFilters((req: GrpcRequest) => req.service === "the-unwanted-service")
+			.enableIf(true)
+			.build()
+	})
+
+	describe("GrpcRecorder", () => {
+		it("matches multiple request, response and stats", async () => {
+			interface UseCase {
+				request: GrpcRequest
+				response: ExtensionMessage["grpc_response"]
+				expectedStatus: string
+			}
+			const requestResponseUseCases: UseCase[] = [
+				{
+					request: {
+						service: "the-service",
+						method: "the-method",
+						message: "the-message",
+						request_id: "request-id-1",
+						is_streaming: false,
+					},
+					response: {
+						request_id: "request-id-1",
+						message: "the-message-response",
+						error: "",
+					},
+					expectedStatus: "completed",
+				},
+				{
+					request: {
+						service: "streaming-service",
+						method: "stream-method",
+						message: { data: "streaming-data", count: 42 },
+						request_id: "request-id-2",
+						is_streaming: true,
+					},
+					response: {
+						request_id: "request-id-2",
+						message: { streamData: "chunk-1" },
+						error: "",
+						is_streaming: true,
+						sequence_number: 1,
+					},
+					expectedStatus: "completed",
+				},
+				{
+					request: {
+						service: "another-service",
+						method: "another-method",
+						message: { complex: { nested: "object", array: [1, 2, 3] } },
+						request_id: "request-id-3",
+						is_streaming: false,
+					},
+					response: {
+						request_id: "request-id-3",
+						message: "",
+						error: "Something went wrong",
+					},
+					expectedStatus: "error",
+				},
+			]
+
+			const initialExpectedStatus = "pending"
+
+			requestResponseUseCases.forEach((us: UseCase, index: number) => {
+				recorder.recordRequest(us.request)
+
+				let sessionLog = recorder.getSessionLog()
+				expect(sessionLog.entries).length(index + 1, `unexpected request_id: ${us.request.request_id}`)
+
+				expect(sessionLog.entries[index]).to.include({
+					service: us.request.service,
+					method: us.request.method,
+					isStreaming: us.request.is_streaming,
+					requestId: us.request.request_id,
+					status: initialExpectedStatus,
+				})
+
+				if (us.response) {
+					recorder.recordResponse(us.request.request_id, us.response)
+				}
+				sessionLog = recorder.getSessionLog()
+
+				expect(sessionLog.entries[index].status).equal(us.expectedStatus)
+				expect(sessionLog.entries[index].response).to.deep.include({
+					error: us.response?.error,
+				})
+			})
+
+			const sessionLog = recorder.getSessionLog()
+			expect(sessionLog.stats).to.include({
+				totalRequests: 3,
+				pendingRequests: 0,
+				completedRequests: 2,
+				errorRequests: 1,
+			})
+
+			recorder.recordRequest({
+				service: "the-unwanted-service",
+				method: "the-method",
+				message: "the-message",
+				request_id: "request-id-1",
+				is_streaming: false,
+			})
+
+			expect(sessionLog.entries).length(3)
+		})
+
+		it("using default filtering should filter out unwanted requests", async () => {
+			const customRecorder = GrpcRecorder.builder()
+				.withFilters(
+					(req) => req.is_streaming,
+					(req) => ["cline.UiService", "cline.McpService", "cline.WebService"].includes(req.service),
+				)
+				.enableIf(true)
+				.build()
+			const unwantedServices = ["cline.UiService", "cline.McpService", "cline.WebService"]
+			unwantedServices.forEach((us) => {
+				customRecorder.recordRequest({
+					service: us,
+					method: "the-method",
+					message: "the-message",
+					request_id: "request-id-1",
+					is_streaming: false,
+				})
+			})
+			let sessionLog = customRecorder.getSessionLog()
+			expect(sessionLog.entries).length(0)
+			customRecorder.recordRequest({
+				service: "streaming-request",
+				method: "the-method",
+				message: "the-message",
+				request_id: "request-id-1",
+				is_streaming: true,
+			})
+			sessionLog = customRecorder.getSessionLog()
+			expect(sessionLog.entries).length(0)
+		})
+
+		it("cleanupSyntheticEntries removes synthetic entries from session log", async () => {
+			const testRecorder = GrpcRecorder.builder().enableIf(true).build()
+
+			// Add regular request
+			testRecorder.recordRequest({
+				service: "regular-service",
+				method: "regular-method",
+				message: "regular-message",
+				request_id: "regular-id",
+				is_streaming: false,
+			})
+
+			// Add synthetic request
+			testRecorder.recordRequest(
+				{
+					service: "synthetic-service",
+					method: "synthetic-method",
+					message: "synthetic-message",
+					request_id: "synthetic-id",
+					is_streaming: false,
+				},
+				true, // synthetic = true
+			)
+
+			let sessionLog = testRecorder.getSessionLog()
+			expect(sessionLog.entries).length(2)
+
+			testRecorder.cleanupSyntheticEntries()
+
+			sessionLog = testRecorder.getSessionLog()
+			expect(sessionLog.entries).length(1)
+			expect(sessionLog.entries[0].requestId).equal("regular-id")
+		})
+
+		it("recordResponse executes post-record hooks", async () => {
+			let hookExecuted = false
+			let hookEntry: any = null
+
+			const mockHook = async (entry: any) => {
+				hookExecuted = true
+				hookEntry = entry
+			}
+
+			const testRecorder = GrpcRecorder.builder().withPostRecordHooks(mockHook).enableIf(true).build()
+
+			testRecorder.recordRequest({
+				service: "test-service",
+				method: "test-method",
+				message: "test-message",
+				request_id: "test-id",
+				is_streaming: false,
+			})
+
+			testRecorder.recordResponse("test-id", {
+				request_id: "test-id",
+				message: "response-message",
+				error: "",
+			})
+
+			expect(hookExecuted).to.be.true
+			expect(hookEntry).to.not.be.null
+			expect(hookEntry.requestId).equal("test-id")
+		})
+	})
+})
diff --git a/apps/vscode/src/core/controller/grpc-recorder/__tests__/log-file-handler.test.ts b/apps/vscode/src/core/controller/grpc-recorder/__tests__/log-file-handler.test.ts
new file mode 100644
index 0000000..84200af
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/__tests__/log-file-handler.test.ts
@@ -0,0 +1,19 @@
+import { beforeAll, describe, it } from "bun:test"
+import { expect } from "chai"
+import { LogFileHandler } from "@/core/controller/grpc-recorder/log-file-handler"
+
+describe("log-file-handler", () => {
+	let logHandler: LogFileHandler
+
+	beforeAll(async () => {
+		logHandler = new LogFileHandler()
+		expect(logHandler.getFilePath()).not.empty
+	})
+
+	describe("LogFileHandler", () => {
+		it("returns file name with timestamp when env var not set", () => {
+			const result = logHandler.getFileName()
+			expect(result).to.contains("grpc_recorded_session")
+		})
+	})
+})
diff --git a/apps/vscode/src/core/controller/grpc-recorder/__tests__/test-hooks.test.ts b/apps/vscode/src/core/controller/grpc-recorder/__tests__/test-hooks.test.ts
new file mode 100644
index 0000000..a34f6e2
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/__tests__/test-hooks.test.ts
@@ -0,0 +1,69 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import { Controller } from "@core/controller"
+import { IRecorder } from "@core/controller/grpc-recorder/grpc-recorder"
+import { GrpcRecorderBuilder } from "@core/controller/grpc-recorder/grpc-recorder.builder"
+import { testHooks } from "@core/controller/grpc-recorder/test-hooks"
+import { GrpcLogEntry } from "@core/controller/grpc-recorder/types"
+import * as sinon from "sinon"
+
+describe("test-hooks", () => {
+	let cleanupSyntheticEntriesStub: sinon.SinonStub
+	let recordRequestStub: sinon.SinonStub
+	let recordResponseStub: sinon.SinonStub
+	let getRecorderStub: sinon.SinonStub
+
+	beforeEach(() => {
+		cleanupSyntheticEntriesStub = sinon.stub()
+		recordRequestStub = sinon.stub()
+		recordResponseStub = sinon.stub()
+
+		const mockRecorder: IRecorder = {
+			cleanupSyntheticEntries: cleanupSyntheticEntriesStub,
+			recordRequest: recordRequestStub,
+			recordResponse: recordResponseStub,
+			recordError: sinon.stub(),
+			getSessionLog: sinon.stub().returns({ startTime: "", entries: [] }),
+		}
+
+		getRecorderStub = sinon.stub(GrpcRecorderBuilder, "getRecorder").returns(mockRecorder)
+	})
+
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	it("should return an array of post-record hooks", () => {
+		const mockController = {} as Controller
+		const hooks = testHooks(mockController)
+
+		hooks.should.be.an.Array()
+		hooks.should.have.length(1)
+		hooks[0].should.be.a.Function()
+	})
+
+	it("should execute hook and call recorder methods", async () => {
+		const mockController = {
+			getStateToPostToWebview: sinon.stub().returns({}),
+		} as any as Controller
+
+		const hooks = testHooks(mockController)
+
+		const mockEntry: GrpcLogEntry = {
+			requestId: "test-request-id",
+			service: "TestService",
+			method: "testMethod",
+			isStreaming: false,
+			request: { message: {} },
+			status: "pending",
+		}
+
+		await hooks[0](mockEntry)
+
+		// Validate sinon stub calls
+		sinon.assert.calledWith(getRecorderStub, mockController)
+		sinon.assert.calledOnce(cleanupSyntheticEntriesStub)
+		sinon.assert.calledOnce(recordRequestStub)
+		sinon.assert.calledOnce(recordResponseStub)
+	})
+})
diff --git a/apps/vscode/src/core/controller/grpc-recorder/grpc-recorder.builder.ts b/apps/vscode/src/core/controller/grpc-recorder/grpc-recorder.builder.ts
new file mode 100644
index 0000000..29f9b4c
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/grpc-recorder.builder.ts
@@ -0,0 +1,114 @@
+import { GrpcPostRecordHook, GrpcRequestFilter } from "@core/controller/grpc-recorder/types"
+import { Controller } from "@/core/controller"
+import { GrpcRecorder, GrpcRecorderNoops, IRecorder } from "@/core/controller/grpc-recorder/grpc-recorder"
+import { LogFileHandler, LogFileHandlerNoops } from "@/core/controller/grpc-recorder/log-file-handler"
+import { testHooks } from "@/core/controller/grpc-recorder/test-hooks"
+
+/**
+ * A builder class for constructing a gRPC recorder instance.
+ *
+ * This class follows the Builder pattern, allowing consumers
+ * to configure logging behavior and control whether recording
+ * is enabled or disabled before creating a final `IRecorder`.
+ */
+export class GrpcRecorderBuilder {
+	private fileHandler: LogFileHandler | null = null
+	private enabled: boolean = true
+	private filters: GrpcRequestFilter[] = []
+	private hooks: GrpcPostRecordHook[] = []
+
+	public withLogFileHandler(handler: LogFileHandler): this {
+		this.fileHandler = handler
+		return this
+	}
+
+	public enableIf(condition: boolean): this {
+		this.enabled = condition
+		return this
+	}
+
+	public withFilters(...filters: GrpcRequestFilter[]): this {
+		this.filters.push(...filters)
+		return this
+	}
+
+	public withPostRecordHooks(...hooks: GrpcPostRecordHook[]): this {
+		this.hooks.push(...hooks)
+		return this
+	}
+
+	// Initialize the recorder as a singleton
+	private static recorder: IRecorder
+
+	/**
+	 * Gets or creates the GrpcRecorder instance
+	 */
+	static getRecorder(controller: Controller): IRecorder {
+		if (!GrpcRecorderBuilder.recorder) {
+			GrpcRecorderBuilder.recorder = GrpcRecorder.builder()
+				.enableIf(process.env.GRPC_RECORDER_ENABLED === "true" && process.env.CLINE_ENVIRONMENT === "local")
+				.withLogFileHandler(new LogFileHandler())
+				.build(controller)
+		}
+		return GrpcRecorderBuilder.recorder
+	}
+
+	public build(controller?: Controller): IRecorder {
+		if (!this.enabled) {
+			return new GrpcRecorderNoops()
+		}
+
+		let filters: GrpcRequestFilter[] = filtersFromEnv()
+		if (this.filters.length > 0) {
+			filters = filters.concat(this.filters)
+		}
+
+		let hooks: GrpcPostRecordHook[] = hooksFromEnv(controller)
+		if (this.hooks.length > 0) {
+			hooks = hooks.concat(this.hooks)
+		}
+
+		const handler = this.fileHandler ?? new LogFileHandlerNoops()
+		return new GrpcRecorder(handler, filters, hooks)
+	}
+}
+
+function filtersFromEnv(): GrpcRequestFilter[] {
+	const filters: GrpcRequestFilter[] = []
+
+	if (process.env.GRPC_RECORDER_TESTS_FILTERS_ENABLED === "true") {
+		filters.push(...testFilters())
+	}
+
+	return filters
+}
+
+function testFilters(): GrpcRequestFilter[] {
+	/*
+	 * Ignores streaming messages and unwanted services messages
+	 * that record more than expected.
+	 */
+	return [
+		(req) => req.is_streaming,
+		(req) => ["cline.UiService", "cline.McpService", "cline.WebService"].includes(req.service),
+		(req) =>
+			[
+				"refreshOpenRouterModels",
+				"getAvailableTerminalProfiles",
+				"showTaskWithId",
+				"deleteTasksWithIds",
+				"getTotalTasksSize",
+				"cancelTask",
+			].includes(req.method),
+	]
+}
+
+function hooksFromEnv(controller?: Controller): GrpcPostRecordHook[] {
+	const hooks: GrpcPostRecordHook[] = []
+
+	if (controller && process.env.GRPC_RECORDER_TESTS_FILTERS_ENABLED === "true") {
+		hooks.push(...testHooks(controller))
+	}
+
+	return hooks
+}
diff --git a/apps/vscode/src/core/controller/grpc-recorder/grpc-recorder.ts b/apps/vscode/src/core/controller/grpc-recorder/grpc-recorder.ts
new file mode 100644
index 0000000..cd05749
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/grpc-recorder.ts
@@ -0,0 +1,226 @@
+import { GrpcResponse } from "@shared/ExtensionMessage"
+import { GrpcRequest } from "@shared/WebviewMessage"
+import { GrpcRecorderBuilder } from "@/core/controller/grpc-recorder/grpc-recorder.builder"
+import { ILogFileHandler } from "@/core/controller/grpc-recorder/log-file-handler"
+import {
+	GrpcLogEntry,
+	GrpcPostRecordHook,
+	GrpcRequestFilter,
+	GrpcSessionLog,
+	SessionStats,
+} from "@/core/controller/grpc-recorder/types"
+import { Logger } from "@/shared/services/Logger"
+
+export class GrpcRecorderNoops implements IRecorder {
+	recordRequest(_request: GrpcRequest): void {}
+	recordResponse(_requestId: string, _response: GrpcResponse): void {}
+	recordError(_requestId: string, _error: string): void {}
+	getSessionLog(): GrpcSessionLog {
+		return {
+			startTime: "",
+			entries: [],
+		}
+	}
+	cleanupSyntheticEntries(): void {}
+}
+
+export interface IRecorder {
+	recordRequest(request: GrpcRequest, synthetic?: boolean): void
+	recordResponse(requestId: string, response: GrpcResponse): void
+	recordError(requestId: string, error: string): void
+	getSessionLog(): GrpcSessionLog
+	cleanupSyntheticEntries(): void
+}
+
+/**
+ * Default implementation of a gRPC recorder.
+ *
+ * Responsibilities:
+ * - Records requests, responses, and errors.
+ * - Tracks request/response lifecycle, including duration and status.
+ * - Maintains a session log of all recorded entries.
+ * - Persists logs asynchronously through a file handler.
+ */
+export class GrpcRecorder implements IRecorder {
+	private sessionLog: GrpcSessionLog
+	private pendingRequests: Map<string, { entry: GrpcLogEntry; startTime: number }> = new Map()
+
+	constructor(
+		private fileHandler: ILogFileHandler,
+		private requestFilters: GrpcRequestFilter[] = [],
+		private postRecordHooks: GrpcPostRecordHook[] = [],
+	) {
+		this.sessionLog = {
+			startTime: new Date().toISOString(),
+			entries: [],
+		}
+
+		this.fileHandler.initialize(this.sessionLog).catch((error) => {
+			Logger.error("Failed to initialize gRPC log file:", error)
+		})
+	}
+
+	public static builder(): GrpcRecorderBuilder {
+		return new GrpcRecorderBuilder()
+	}
+
+	/**
+	 * Records a gRPC request.
+	 *
+	 * - Stores the request as a "pending" log entry.
+	 * - Tracks the request start time for later duration calculation.
+	 * - Persists the log asynchronously.
+	 *
+	 * @param request - The incoming gRPC request.
+	 */
+	public recordRequest(request: GrpcRequest, synthetic: boolean = false): void {
+		if (this.shouldFilter(request)) {
+			return
+		}
+
+		const entry: GrpcLogEntry = {
+			requestId: request.request_id,
+			service: request.service,
+			method: request.method,
+			isStreaming: request.is_streaming || false,
+			request: {
+				message: request.message,
+			},
+			status: "pending",
+			meta: { synthetic },
+		}
+
+		this.pendingRequests.set(request.request_id, {
+			entry,
+			startTime: Date.now(),
+		})
+
+		this.sessionLog.entries.push(entry)
+		this.flushLogAsync()
+	}
+
+	public getSessionLog(): GrpcSessionLog {
+		return this.sessionLog
+	}
+
+	/**
+	 * Records a gRPC response for a given request.
+	 *
+	 * - Looks up the pending request entry.
+	 * - Updates the entry with response data, status, and duration.
+	 * - Removes the request from pending if it's not streaming.
+	 * - Recomputes session stats.
+	 * - Persists the log asynchronously.
+	 *
+	 * @param requestId - The ID of the request being responded to.
+	 * @param response - The corresponding gRPC response.
+	 */
+	public recordResponse(requestId: string, response: GrpcResponse): void {
+		const pendingRequest = this.pendingRequests.get(requestId)
+
+		if (!pendingRequest) {
+			Logger.warn(`No pending request found for response with ID: ${requestId}`)
+			return
+		}
+
+		const { entry, startTime } = pendingRequest
+
+		entry.response = {
+			message: response?.message ? response.message : undefined,
+			error: response?.error,
+			isStreaming: response?.is_streaming,
+			sequenceNumber: response?.sequence_number,
+		}
+
+		entry.duration = Date.now() - startTime
+		entry.status = response?.error ? "error" : "completed"
+
+		if (!response?.is_streaming) {
+			this.pendingRequests.delete(requestId)
+		}
+
+		this.sessionLog.stats = this.getStats()
+
+		this.flushLogAsync()
+
+		this.runHooks(entry).catch((e) => Logger.error("Post-record hook failed:", e))
+	}
+
+	private async runHooks(entry: GrpcLogEntry): Promise<void> {
+		if (entry.meta?.synthetic) return
+		for (const hook of this.postRecordHooks) {
+			await hook(entry)
+		}
+	}
+
+	public cleanupSyntheticEntries(): void {
+		// Remove synthetic entries from session log
+		this.sessionLog.entries = this.sessionLog.entries.filter((entry) => !entry.meta?.synthetic)
+
+		// clean up from pending requests if needed
+		for (const [requestId, pendingRequest] of this.pendingRequests.entries()) {
+			if (pendingRequest.entry.meta?.synthetic) {
+				this.pendingRequests.delete(requestId)
+			}
+		}
+
+		this.sessionLog.stats = this.getStats()
+		this.flushLogAsync()
+	}
+
+	/**
+	 * Records an error for a given request.
+	 *
+	 * - Marks the request as failed.
+	 * - Records the error message and request duration.
+	 * - Removes it from the pending requests.
+	 * - Persists the log asynchronously.
+	 *
+	 * @param requestId - The ID of the request that errored.
+	 * @param error - Error message.
+	 */
+	public recordError(requestId: string, error: string): void {
+		const pendingRequest = this.pendingRequests.get(requestId)
+		if (!pendingRequest) {
+			Logger.warn(`No pending request found for error with ID: ${requestId}`)
+			return
+		}
+
+		const { entry, startTime } = pendingRequest
+
+		entry.response = {
+			error: error,
+		}
+		entry.duration = Date.now() - startTime
+		entry.status = "error"
+
+		this.pendingRequests.delete(requestId)
+		this.flushLogAsync()
+	}
+
+	private flushLogAsync(): void {
+		setImmediate(() => {
+			this.fileHandler.write(this.sessionLog).catch((error) => {
+				Logger.error("Failed to flush gRPC log:", error)
+			})
+		})
+	}
+
+	public getStats(): SessionStats {
+		const totalRequests = this.sessionLog.entries.length
+		const pendingRequests = this.sessionLog.entries.filter((e) => e.status === "pending").length
+		const completedRequests = this.sessionLog.entries.filter((e) => e.status === "completed").length
+		const errorRequests = this.sessionLog.entries.filter((e) => e.status === "error").length
+
+		return {
+			totalRequests,
+			pendingRequests,
+			completedRequests,
+			errorRequests,
+		}
+	}
+
+	private shouldFilter(request: GrpcRequest): boolean {
+		return this.requestFilters.some((filter) => filter(request))
+	}
+}
diff --git a/apps/vscode/src/core/controller/grpc-recorder/log-file-handler.ts b/apps/vscode/src/core/controller/grpc-recorder/log-file-handler.ts
new file mode 100644
index 0000000..6d139b5
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/log-file-handler.ts
@@ -0,0 +1,57 @@
+import { writeFile } from "@utils/fs"
+import fs from "fs/promises"
+import * as path from "path"
+import { GrpcSessionLog } from "@/core/controller/grpc-recorder/types"
+
+const LOG_FILE_PREFIX = "grpc_recorded_session"
+
+export class LogFileHandlerNoops implements ILogFileHandler {
+	async initialize(_initialData: GrpcSessionLog): Promise<void> {}
+	async write(_sessionLog: GrpcSessionLog): Promise<void> {}
+}
+
+export interface ILogFileHandler {
+	initialize(initialData: GrpcSessionLog): Promise<void>
+	write(sessionLog: GrpcSessionLog): Promise<void>
+}
+
+/**
+ * Default implementation of `ILogFileHandler` that persists logs to disk.
+ *
+ * - Creates a log file inside the workspace `tests/specs` folder.
+ * - Uses a timestamped filename by default, unless overridden by an env var.
+ * - Saves logs in JSON format.
+ */
+export class LogFileHandler implements ILogFileHandler {
+	private logFilePath: string
+
+	constructor() {
+		const fileName = this.getFileName()
+		const workspaceFolder = process.env.DEV_WORKSPACE_FOLDER ?? process.cwd()
+		const folderPath = path.join(workspaceFolder, "tests", "specs")
+		this.logFilePath = path.join(folderPath, fileName)
+	}
+
+	public getFilePath(): string {
+		return this.logFilePath
+	}
+
+	public getFileName(): string {
+		const envFileName = path.basename(process.env.GRPC_RECORDER_FILE_NAME || "").replace(/[^a-zA-Z0-9-_]/g, "_")
+		if (envFileName && envFileName.trim().length > 0) {
+			return `${LOG_FILE_PREFIX}_${envFileName}.json`
+		}
+
+		const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+		return `${LOG_FILE_PREFIX}_${timestamp}.json`
+	}
+
+	public async initialize(initialData: GrpcSessionLog): Promise<void> {
+		await fs.mkdir(path.dirname(this.logFilePath), { recursive: true })
+		await writeFile(this.logFilePath, JSON.stringify(initialData, null, 2), "utf8")
+	}
+
+	public async write(sessionLog: GrpcSessionLog): Promise<void> {
+		await writeFile(this.logFilePath, JSON.stringify(sessionLog, null, 2), "utf8")
+	}
+}
diff --git a/apps/vscode/src/core/controller/grpc-recorder/test-hooks.ts b/apps/vscode/src/core/controller/grpc-recorder/test-hooks.ts
new file mode 100644
index 0000000..e5d3a98
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/test-hooks.ts
@@ -0,0 +1,38 @@
+import { Controller } from "@/core/controller"
+import { GrpcRecorderBuilder } from "@/core/controller/grpc-recorder/grpc-recorder.builder"
+import { GrpcPostRecordHook } from "@/core/controller/grpc-recorder/types"
+import { getLatestState } from "@/core/controller/state/getLatestState"
+
+// Add 50ms delay by default to ensure we get the latest state
+const TEST_HOOK_LATEST_STATE_DELAY = 50
+
+export function testHooks(controller: Controller): GrpcPostRecordHook[] {
+	return [
+		async (entry) => {
+			GrpcRecorderBuilder.getRecorder(controller).cleanupSyntheticEntries()
+
+			await new Promise((resolve) => setTimeout(resolve, TEST_HOOK_LATEST_STATE_DELAY))
+
+			const requestId = entry.requestId
+
+			// Record synthetic "getLatestState" request
+			GrpcRecorderBuilder.getRecorder(controller).recordRequest(
+				{
+					service: "cline.StateService",
+					method: "getLatestState",
+					message: {},
+					request_id: requestId,
+					is_streaming: false,
+				},
+				true,
+			)
+
+			const state = await getLatestState(controller, {})
+
+			GrpcRecorderBuilder.getRecorder(controller).recordResponse(requestId, {
+				request_id: requestId,
+				message: state,
+			})
+		},
+	]
+}
diff --git a/apps/vscode/src/core/controller/grpc-recorder/types.ts b/apps/vscode/src/core/controller/grpc-recorder/types.ts
new file mode 100644
index 0000000..e947fb7
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-recorder/types.ts
@@ -0,0 +1,37 @@
+import { GrpcRequest } from "@/shared/WebviewMessage"
+
+export type GrpcPostRecordHook = (entry: GrpcLogEntry, controller?: any) => Promise<void> | void
+
+export type GrpcRequestFilter = (request: GrpcRequest) => boolean
+
+export interface GrpcLogEntry {
+	requestId: string
+	service: string
+	method: string
+	isStreaming: boolean
+	request: {
+		message: any
+	}
+	response?: {
+		message?: any
+		error?: string
+		isStreaming?: boolean
+		sequenceNumber?: number
+	}
+	duration?: number
+	status: "pending" | "completed" | "error"
+	meta?: { synthetic?: boolean }
+}
+
+export interface SessionStats {
+	totalRequests: number
+	pendingRequests: number
+	completedRequests: number
+	errorRequests: number
+}
+
+export interface GrpcSessionLog {
+	startTime: string
+	stats?: SessionStats
+	entries: GrpcLogEntry[]
+}
diff --git a/apps/vscode/src/core/controller/grpc-request-registry.ts b/apps/vscode/src/core/controller/grpc-request-registry.ts
new file mode 100644
index 0000000..5c72c2f
--- /dev/null
+++ b/apps/vscode/src/core/controller/grpc-request-registry.ts
@@ -0,0 +1,123 @@
+import { Logger } from "@/shared/services/Logger"
+import { StreamingResponseHandler } from "./grpc-handler"
+
+/**
+ * Information about a registered gRPC request
+ */
+export interface RequestInfo {
+	/**
+	 * Function to clean up resources when the request is cancelled or completed
+	 */
+	cleanup: () => void
+
+	/**
+	 * Optional metadata about the request
+	 */
+	metadata?: any
+
+	/**
+	 * Timestamp when the request was registered
+	 */
+	timestamp: Date
+
+	/**
+	 * The streaming response handler for this request
+	 */
+	responseStream?: StreamingResponseHandler<any>
+}
+
+/**
+ * Registry for managing gRPC request lifecycles
+ * This class provides a centralized way to track active requests and their cleanup functions
+ */
+export class GrpcRequestRegistry {
+	/**
+	 * Map of request IDs to request information
+	 */
+	private activeRequests = new Map<string, RequestInfo>()
+
+	/**
+	 * Register a new request with its cleanup function
+	 * @param requestId The unique ID of the request
+	 * @param cleanup Function to clean up resources when the request is cancelled
+	 * @param metadata Optional metadata about the request
+	 * @param responseStream Optional streaming response handler
+	 */
+	public registerRequest(
+		requestId: string,
+		cleanup: () => void,
+		metadata?: any,
+		responseStream?: StreamingResponseHandler<any>,
+	): void {
+		this.activeRequests.set(requestId, {
+			cleanup,
+			metadata,
+			timestamp: new Date(),
+			responseStream,
+		})
+	}
+
+	/**
+	 * Cancel a request and clean up its resources
+	 * @param requestId The ID of the request to cancel
+	 * @returns True if the request was found and cancelled, false otherwise
+	 */
+	public cancelRequest(requestId: string): boolean {
+		const requestInfo = this.activeRequests.get(requestId)
+		if (!requestInfo) {
+			return false
+		}
+		try {
+			requestInfo.cleanup()
+		} catch (error) {
+			Logger.error(`Error cleaning up request ${requestId}:`, error)
+		}
+		this.activeRequests.delete(requestId)
+		return true
+	}
+
+	/**
+	 * Get information about a request
+	 * @param requestId The ID of the request
+	 * @returns The request information, or undefined if not found
+	 */
+	public getRequestInfo(requestId: string): RequestInfo | undefined {
+		return this.activeRequests.get(requestId)
+	}
+
+	/**
+	 * Check if a request exists in the registry
+	 * @param requestId The ID of the request
+	 * @returns True if the request exists, false otherwise
+	 */
+	public hasRequest(requestId: string): boolean {
+		return this.activeRequests.has(requestId)
+	}
+
+	/**
+	 * Get all active requests
+	 * @returns An array of [requestId, requestInfo] pairs
+	 */
+	public getAllRequests(): [string, RequestInfo][] {
+		return Array.from(this.activeRequests.entries())
+	}
+
+	/**
+	 * Clean up stale requests that have been active for too long
+	 * @param maxAgeMs Maximum age in milliseconds before a request is considered stale
+	 * @returns The number of requests that were cleaned up
+	 */
+	public cleanupStaleRequests(maxAgeMs: number): number {
+		const now = new Date()
+		let cleanedCount = 0
+
+		for (const [requestId, info] of this.activeRequests.entries()) {
+			if (now.getTime() - info.timestamp.getTime() > maxAgeMs) {
+				this.cancelRequest(requestId)
+				cleanedCount++
+			}
+		}
+
+		return cleanedCount
+	}
+}
diff --git a/apps/vscode/src/core/controller/index.ts b/apps/vscode/src/core/controller/index.ts
new file mode 100644
index 0000000..11f3843
--- /dev/null
+++ b/apps/vscode/src/core/controller/index.ts
@@ -0,0 +1,7 @@
+// Replaces classic src/core/controller/index.ts (see origin/main)
+//
+// The Controller class is now provided by the SDK adapter layer.
+// All gRPC handler modules in this directory continue to work as the
+// thunking layer between the webview and the SDK.
+
+export { Controller } from "@/sdk/SdkController"
diff --git a/apps/vscode/src/core/controller/marketplace/__tests__/installMarketplaceEntry.test.ts b/apps/vscode/src/core/controller/marketplace/__tests__/installMarketplaceEntry.test.ts
new file mode 100644
index 0000000..fc80882
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/__tests__/installMarketplaceEntry.test.ts
@@ -0,0 +1,51 @@
+import { afterEach, describe, it, mock } from "bun:test"
+import * as assert from "assert"
+import sinon from "sinon"
+import type { Controller } from "../../index"
+
+const installMarketplaceEntryFromCatalogStub: sinon.SinonStub = sinon.stub()
+const marketplaceHelpersMock = () => ({
+	installMarketplaceEntryFromCatalog: installMarketplaceEntryFromCatalogStub,
+})
+
+mock.module("../marketplace-helpers", marketplaceHelpersMock)
+mock.module("./marketplace-helpers", marketplaceHelpersMock)
+
+describe("installMarketplaceEntry", () => {
+	afterEach(() => {
+		installMarketplaceEntryFromCatalogStub.reset()
+	})
+
+	it("reconciles the MCP hub after installing an MCP marketplace entry", async () => {
+		const { installMarketplaceEntry } = await import("../installMarketplaceEntry")
+		const reconcileMcpServersFromSettingsRPC = sinon.stub().resolves([])
+		const invalidateUserInstructionService = sinon.stub().resolves()
+		const controller = {
+			mcpHub: { reconcileMcpServersFromSettingsRPC },
+			invalidateUserInstructionService,
+		} as unknown as Controller
+		installMarketplaceEntryFromCatalogStub.resolves({
+			id: "chrome-devtools",
+			type: "mcp",
+			status: "installed",
+		})
+
+		await installMarketplaceEntry(controller, {
+			entry: {
+				id: "chrome-devtools",
+				type: "mcp",
+				name: "Chrome DevTools",
+				install: {
+					args: ["chrome-devtools", "--", "npx", "chrome-devtools-mcp@1.2.0"],
+					env: [],
+				},
+				tags: [],
+				tagObjects: [],
+			},
+		})
+
+		assert.equal(installMarketplaceEntryFromCatalogStub.callCount, 1)
+		assert.equal(reconcileMcpServersFromSettingsRPC.callCount, 1)
+		assert.equal(invalidateUserInstructionService.callCount, 0)
+	})
+})
diff --git a/apps/vscode/src/core/controller/marketplace/getMarketplaceCatalog.ts b/apps/vscode/src/core/controller/marketplace/getMarketplaceCatalog.ts
new file mode 100644
index 0000000..4e6a853
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/getMarketplaceCatalog.ts
@@ -0,0 +1,8 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import type { MarketplaceCatalog } from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { fetchMarketplaceCatalog } from "./marketplace-helpers"
+
+export async function getMarketplaceCatalog(_controller: Controller, _request: EmptyRequest): Promise<MarketplaceCatalog> {
+	return fetchMarketplaceCatalog()
+}
diff --git a/apps/vscode/src/core/controller/marketplace/installMarketplaceEntry.ts b/apps/vscode/src/core/controller/marketplace/installMarketplaceEntry.ts
new file mode 100644
index 0000000..e9cdfad
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/installMarketplaceEntry.ts
@@ -0,0 +1,20 @@
+import { type MarketplaceEntryRequest, MarketplaceInstallResult } from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { installMarketplaceEntryFromCatalog } from "./marketplace-helpers"
+
+export async function installMarketplaceEntry(
+	controller: Controller,
+	request: MarketplaceEntryRequest,
+): Promise<MarketplaceInstallResult> {
+	if (!request.entry) {
+		throw new Error("Marketplace entry is required.")
+	}
+	const result = await installMarketplaceEntryFromCatalog(request.entry)
+	if (request.entry.type === "mcp") {
+		await controller.mcpHub?.reconcileMcpServersFromSettingsRPC()
+	}
+	if (request.entry.type === "skill" || request.entry.type === "plugin") {
+		await controller.invalidateUserInstructionService()
+	}
+	return result
+}
diff --git a/apps/vscode/src/core/controller/marketplace/listMarketplaceInstalledEntries.ts b/apps/vscode/src/core/controller/marketplace/listMarketplaceInstalledEntries.ts
new file mode 100644
index 0000000..43ad580
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/listMarketplaceInstalledEntries.ts
@@ -0,0 +1,10 @@
+import type { MarketplaceEntriesRequest, MarketplaceInstalledEntries } from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { listInstalledMarketplaceEntries } from "./marketplace-helpers"
+
+export async function listMarketplaceInstalledEntries(
+	controller: Controller,
+	request: MarketplaceEntriesRequest,
+): Promise<MarketplaceInstalledEntries> {
+	return listInstalledMarketplaceEntries(controller, request.entries)
+}
diff --git a/apps/vscode/src/core/controller/marketplace/listMarketplaceLocalInstalledEntries.ts b/apps/vscode/src/core/controller/marketplace/listMarketplaceLocalInstalledEntries.ts
new file mode 100644
index 0000000..7c19520
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/listMarketplaceLocalInstalledEntries.ts
@@ -0,0 +1,11 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import type { MarketplaceLocalInstalledEntries } from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { listLocalMarketplaceInstalledEntries } from "./marketplace-helpers"
+
+export async function listMarketplaceLocalInstalledEntries(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<MarketplaceLocalInstalledEntries> {
+	return listLocalMarketplaceInstalledEntries(controller)
+}
diff --git a/apps/vscode/src/core/controller/marketplace/marketplace-helpers.ts b/apps/vscode/src/core/controller/marketplace/marketplace-helpers.ts
new file mode 100644
index 0000000..5cd6fbb
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/marketplace-helpers.ts
@@ -0,0 +1,635 @@
+import { spawn } from "node:child_process"
+import { createHash } from "node:crypto"
+import { existsSync, readFileSync } from "node:fs"
+import { homedir, platform } from "node:os"
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path"
+import {
+	disablePluginMcpServersInSettings,
+	discoverPluginModulePaths,
+	installMcpServer,
+	installPlugin,
+	isMarketplaceSkillInstalled,
+	type MarketplaceActionResult,
+	type MarketplaceEntryInput,
+	type MarketplacePrimitiveType,
+	parseMcpInstallArgs,
+	readGlobalSettings,
+	resolvePluginConfigSearchPaths,
+	setDisabledPlugin,
+	syncPluginMcpServersToSettings,
+	uninstallMarketplaceEntry as uninstallCoreMarketplaceEntry,
+	uninstallPlugin,
+} from "@cline/core"
+import { deleteSkillFile } from "@core/controller/file/deleteSkillFile"
+import { refreshSkills } from "@core/controller/file/refreshSkills"
+import { toggleSkill } from "@core/controller/file/toggleSkill"
+import { resolveActiveModelIdFromApiConfiguration } from "@core/controller/models/taskApiModel"
+import { DeleteSkillRequest, ToggleSkillRequest } from "@shared/proto/cline/file"
+import {
+	MarketplaceCatalog,
+	MarketplaceEntry,
+	MarketplaceInstalledEntries,
+	MarketplaceInstallResult,
+	MarketplaceLocalInstalledEntries,
+	MarketplaceLocalInstalledEntry,
+	MarketplaceLocalInstalledEntryRequest,
+	ToggleMarketplaceLocalInstalledEntryRequest,
+} from "@shared/proto/cline/marketplace"
+import { HostProvider } from "@/hosts/host-provider"
+import type { Controller } from "../index"
+
+type MarketplaceType = "mcp" | "skill" | "plugin"
+
+type SpawnResult = {
+	exitCode: number
+	stdout: string
+	stderr: string
+}
+
+const MARKETPLACE_CATALOG_URL = "https://cline.github.io/marketplace/catalog.json"
+const OFFICIAL_PLUGINS_REPO = "https://github.com/cline/plugins.git"
+const INSTALL_COMMAND_TIMEOUT_MS = 120_000
+const MAX_OUTPUT_CHARS = 12_000
+const SECRET_PATTERN =
+	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i
+const SECRET_KEY_VALUE_PATTERN =
+	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi
+const SECRET_BEARER_VALUE_PATTERN = /((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi
+const SECRET_AUTHORIZATION_VALUE_PATTERN = /((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi
+
+function isMarketplaceType(value: string): value is MarketplaceType {
+	return value === "mcp" || value === "skill" || value === "plugin"
+}
+
+function asStringArray(value: unknown): string[] {
+	return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+}
+
+function sanitizeEntry(raw: unknown): MarketplaceEntry | undefined {
+	if (!raw || typeof raw !== "object") return undefined
+	const record = raw as Record<string, unknown>
+	const id = typeof record.id === "string" ? record.id.trim() : ""
+	const type = typeof record.type === "string" ? record.type.trim() : ""
+	const name = typeof record.name === "string" ? record.name.trim() : id
+	if (!id || !isMarketplaceType(type) || !name) return undefined
+	const install = record.install && typeof record.install === "object" ? (record.install as Record<string, unknown>) : undefined
+	return MarketplaceEntry.create({
+		id,
+		type,
+		name,
+		tagline: typeof record.tagline === "string" ? record.tagline : undefined,
+		description: typeof record.description === "string" ? record.description : undefined,
+		tags: asStringArray(record.tags),
+		author: typeof record.author === "string" ? record.author : undefined,
+		sourceUrl: typeof record.sourceUrl === "string" ? record.sourceUrl : undefined,
+		homepageUrl: typeof record.homepageUrl === "string" ? record.homepageUrl : undefined,
+		install: install
+			? {
+					args: asStringArray(install.args),
+					env: Array.isArray(install.env)
+						? install.env
+								.map((item) => {
+									if (!item || typeof item !== "object") return undefined
+									const env = item as Record<string, unknown>
+									if (typeof env.name !== "string") return undefined
+									return {
+										name: env.name,
+										required: env.required === true,
+										description: typeof env.description === "string" ? env.description : undefined,
+										url: typeof env.url === "string" ? env.url : undefined,
+									}
+								})
+								.filter((item): item is NonNullable<typeof item> => item !== undefined)
+						: [],
+					command: typeof install.command === "string" ? install.command : undefined,
+					notes: typeof install.notes === "string" ? install.notes : undefined,
+				}
+			: undefined,
+	})
+}
+
+export async function fetchMarketplaceCatalog(): Promise<MarketplaceCatalog> {
+	const response = await fetch(MARKETPLACE_CATALOG_URL, {
+		headers: { Accept: "application/json" },
+	})
+	if (!response.ok) {
+		throw new Error(`Failed to fetch marketplace catalog: ${response.status} ${response.statusText}`.trim())
+	}
+	const json = (await response.json()) as Record<string, unknown>
+	const entries = Array.isArray(json.entries)
+		? json.entries.map(sanitizeEntry).filter((entry): entry is MarketplaceEntry => entry !== undefined)
+		: []
+	return MarketplaceCatalog.create({ entries })
+}
+
+function normalizeMatchValue(value: string | undefined): string {
+	return (value ?? "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+}
+
+function marketplaceKey(entry: MarketplaceEntry): string {
+	return `${entry.type}:${entry.id}`
+}
+
+function getEntryArgs(entry: MarketplaceEntry): string[] {
+	return entry.install?.args ?? []
+}
+
+function isMcpInstalled(controller: Controller, entry: MarketplaceEntry): boolean {
+	if (entry.type !== "mcp") return false
+	const [name] = getEntryArgs(entry)
+	const candidates = new Set([normalizeMatchValue(name), normalizeMatchValue(entry.id), normalizeMatchValue(entry.name)])
+	candidates.delete("")
+	return (controller.mcpHub?.getServers() ?? []).some((server) => candidates.has(normalizeMatchValue(server.name)))
+}
+
+function hashSource(source: string): string {
+	return createHash("sha256").update(source).digest("hex").slice(0, 12)
+}
+
+function resolveClineHome(): string {
+	return process.env.CLINE_DIR?.trim() || join(homedir(), ".cline")
+}
+
+function sanitizeSegment(value: string): string {
+	const sanitized = value
+		.replace(/^@/, "")
+		.replace(/[^a-zA-Z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, 80)
+	return sanitized || "plugin"
+}
+
+function isOfficialPluginInstalled(entry: MarketplaceEntry): boolean {
+	if (entry.type !== "plugin") return false
+	const [source] = getEntryArgs(entry)
+	if (!source || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(source.trim())) return false
+	const sourceKey = `official:${OFFICIAL_PLUGINS_REPO}#plugins/${source.trim()}`
+	const installPath = join(
+		resolveClineHome(),
+		"plugins",
+		"_installed",
+		"official",
+		`${sanitizeSegment(source)}-${hashSource(sourceKey)}`,
+	)
+	return existsSync(installPath)
+}
+
+function isSkillInstalled(entry: MarketplaceEntry): boolean {
+	if (entry.type !== "skill") return false
+	return isMarketplaceSkillInstalled(toCoreMarketplaceEntry(entry))
+}
+
+export function listInstalledMarketplaceEntries(
+	controller: Controller,
+	entries: MarketplaceEntry[],
+): MarketplaceInstalledEntries {
+	return MarketplaceInstalledEntries.create({
+		installedKeys: entries
+			.filter((entry) => isMcpInstalled(controller, entry) || isSkillInstalled(entry) || isOfficialPluginInstalled(entry))
+			.map(marketplaceKey),
+	})
+}
+
+function redactOutput(value: string): string {
+	return value
+		.split(/\r?\n/)
+		.map((line) => {
+			if (!SECRET_PATTERN.test(line)) return line
+			return line
+				.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
+				.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
+				.replace(/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi, "$1 [redacted]")
+				.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
+				.replace(
+					/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
+					"$1[redacted]",
+				)
+		})
+		.join("\n")
+		.slice(-MAX_OUTPUT_CHARS)
+}
+
+function quoteCommandPart(value: string): string {
+	if (value === "") return '""'
+	if (/^[a-zA-Z0-9_./:=@%+,-]+$/.test(value)) return value
+	return JSON.stringify(value)
+}
+
+function formatCommand(command: string, args: string[]): string {
+	return [command, ...args].map((part) => quoteCommandPart(redactOutput(part).trim())).join(" ")
+}
+
+function extractJsonErrorMessage(value: unknown): string | undefined {
+	if (typeof value === "string") return value.trim() || undefined
+	if (!value || typeof value !== "object") return undefined
+	if (Array.isArray(value)) {
+		return value.map(extractJsonErrorMessage).filter(Boolean).join("\n") || undefined
+	}
+	const record = value as Record<string, unknown>
+	for (const key of ["message", "error", "details", "detail", "reason", "stderr", "stdout"]) {
+		const message = extractJsonErrorMessage(record[key])
+		if (message) return message
+	}
+	return undefined
+}
+
+function parseJsonErrorMessage(output: string): string | undefined {
+	const trimmed = output.trim()
+	if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) return undefined
+	try {
+		return extractJsonErrorMessage(JSON.parse(trimmed))
+	} catch {
+		return undefined
+	}
+}
+
+function commandOutput(result: SpawnResult): string | undefined {
+	const stdout = redactOutput(result.stdout).trim()
+	const stderr = redactOutput(result.stderr).trim()
+	const parsedMessages = [stdout, stderr].map(parseJsonErrorMessage).filter((message): message is string => Boolean(message))
+	if (parsedMessages.length > 0) return parsedMessages.join("\n")
+	const parts = [stderr ? `stderr:\n${stderr}` : undefined, stdout ? `stdout:\n${stdout}` : undefined].filter(
+		(part): part is string => Boolean(part),
+	)
+	return parts.join("\n\n") || undefined
+}
+
+async function runCommand(command: string, args: string[]): Promise<SpawnResult> {
+	return new Promise((resolveResult, reject) => {
+		let settled = false
+		let timedOut = false
+		const child = spawn(command, args, {
+			env: process.env,
+			shell: platform() === "win32",
+			stdio: ["ignore", "pipe", "pipe"],
+			windowsHide: true,
+		})
+		let stdout = ""
+		let stderr = ""
+		const forceKillTimeout = setTimeout(() => {
+			if (!settled) child.kill("SIGKILL")
+		}, INSTALL_COMMAND_TIMEOUT_MS + 5_000)
+		const timeout = setTimeout(() => {
+			timedOut = true
+			stderr += `\nTimed out after ${INSTALL_COMMAND_TIMEOUT_MS / 1000}s.`
+			child.kill("SIGTERM")
+		}, INSTALL_COMMAND_TIMEOUT_MS)
+		forceKillTimeout.unref?.()
+		timeout.unref?.()
+		child.stdout?.on("data", (chunk) => {
+			stdout += String(chunk)
+			if (stdout.length > MAX_OUTPUT_CHARS * 2) stdout = stdout.slice(-MAX_OUTPUT_CHARS)
+		})
+		child.stderr?.on("data", (chunk) => {
+			stderr += String(chunk)
+			if (stderr.length > MAX_OUTPUT_CHARS * 2) stderr = stderr.slice(-MAX_OUTPUT_CHARS)
+		})
+		child.once("error", reject)
+		child.once("close", (code, signal) => {
+			settled = true
+			clearTimeout(timeout)
+			clearTimeout(forceKillTimeout)
+			resolveResult({
+				exitCode: timedOut ? 124 : (code ?? (signal === "SIGINT" ? 130 : 1)),
+				stdout,
+				stderr,
+			})
+		})
+	})
+}
+
+function installMcpMarketplaceEntry(entry: MarketplaceEntry, args: string[]): MarketplaceInstallResult {
+	const parsed = parseMcpInstallArgs(args)
+	const result = installMcpServer(parsed)
+	return MarketplaceInstallResult.create({
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name || entry.id}.`,
+		output: result.warnings.join("\n") || undefined,
+	})
+}
+
+async function installPluginMarketplaceEntry(entry: MarketplaceEntry, args: string[]): Promise<MarketplaceInstallResult> {
+	const [source] = args
+	if (!source) throw new Error("Marketplace plugin install args must start with a plugin source.")
+	const result = await installPlugin({ source })
+	const warnings = result.mcpSyncFailures.map(
+		(failure) => `Failed to sync plugin MCP servers for ${failure.pluginName ?? failure.pluginPath}: ${failure.message}`,
+	)
+	return MarketplaceInstallResult.create({
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name || entry.id}.`,
+		output: [`Path: ${result.installPath}`, ...warnings].join("\n"),
+	})
+}
+
+async function installSkillMarketplaceEntry(entry: MarketplaceEntry, args: string[]): Promise<MarketplaceInstallResult> {
+	const command = "npx"
+	const commandArgs = ["-y", "skills@latest", "add", ...args, "-g", "-a", "cline", "-y"]
+	const displayCommand = formatCommand(command, commandArgs)
+	let result: SpawnResult
+	try {
+		result = await runCommand(command, commandArgs)
+	} catch (error) {
+		throw new Error(
+			`Failed to start ${entry.name || entry.id} install command:\n${displayCommand}\n${
+				error instanceof Error ? error.message : String(error)
+			}`,
+		)
+	}
+	const output = commandOutput(result)
+	if (result.exitCode !== 0) {
+		throw new Error(
+			`${entry.name || entry.id} install failed with exit code ${result.exitCode}.\nCommand:\n${displayCommand}${
+				output ? `\n\n${output}` : ""
+			}`,
+		)
+	}
+	return MarketplaceInstallResult.create({
+		id: entry.id,
+		type: entry.type,
+		status: "installed",
+		message: `Installed ${entry.name || entry.id}.`,
+		output,
+	})
+}
+
+export async function installMarketplaceEntryFromCatalog(entry: MarketplaceEntry): Promise<MarketplaceInstallResult> {
+	const args = getEntryArgs(entry)
+	if (args.length === 0) throw new Error("Marketplace install args are required.")
+	if (entry.type === "mcp") return installMcpMarketplaceEntry(entry, args)
+	if (entry.type === "plugin") return installPluginMarketplaceEntry(entry, args)
+	return installSkillMarketplaceEntry(entry, args)
+}
+
+function toCoreMarketplaceEntry(entry: MarketplaceEntry): MarketplaceEntryInput {
+	if (entry.type !== "mcp" && entry.type !== "skill" && entry.type !== "plugin") {
+		throw new Error(`Unsupported marketplace entry type: ${entry.type}`)
+	}
+	return {
+		id: entry.id,
+		type: entry.type as MarketplacePrimitiveType,
+		name: entry.name,
+		install: {
+			args: getEntryArgs(entry),
+		},
+	}
+}
+
+function toProtoMarketplaceInstallResult(result: MarketplaceActionResult): MarketplaceInstallResult {
+	return MarketplaceInstallResult.create({
+		id: result.id,
+		type: result.type,
+		status: result.status,
+		message: result.message,
+		output: result.output,
+	})
+}
+
+export async function uninstallMarketplaceEntryFromCatalog(
+	controller: Controller,
+	entry: MarketplaceEntry,
+): Promise<MarketplaceInstallResult> {
+	const workspaceRoot = await getWorkspacePath()
+	const result = await uninstallCoreMarketplaceEntry(toCoreMarketplaceEntry(entry), {
+		deleteMcpServer: async (name) => {
+			await controller.mcpHub?.deleteServerRPC(name)
+		},
+		workspaceRoot,
+	})
+	return toProtoMarketplaceInstallResult(result)
+}
+
+function readPackageName(packageJsonPath: string): string | undefined {
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { name?: unknown }
+		return typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name.trim() : undefined
+	} catch {
+		return undefined
+	}
+}
+
+function isPathWithin(parentPath: string, childPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath))
+	return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath))
+}
+
+function isGlobalClinePath(filePath: string | undefined): boolean {
+	if (!filePath || filePath.startsWith("remote:")) return false
+	return [resolveClineHome(), join(homedir(), ".agents", "skills")].some((root) => isPathWithin(root, filePath))
+}
+
+function getPluginDisplayName(filePath: string, searchRoot: string): string {
+	let current = dirname(filePath)
+	const root = resolve(searchRoot)
+	while (isPathWithin(root, current)) {
+		const packageJsonPath = join(current, "package.json")
+		if (existsSync(packageJsonPath)) {
+			const packageName = readPackageName(packageJsonPath)
+			if (packageName) return packageName
+			break
+		}
+		const parent = resolve(current, "..")
+		if (parent === current) break
+		current = parent
+	}
+	return basename(filePath, extname(filePath))
+}
+
+async function listPluginLocalEntries(): Promise<MarketplaceLocalInstalledEntry[]> {
+	const workspacePath = HostProvider.isInitialized() ? (await HostProvider.workspace.getWorkspacePaths({})).paths[0] : undefined
+	const roots = resolvePluginConfigSearchPaths(workspacePath).filter((directory) => existsSync(directory))
+	const disabledPlugins = new Set(readGlobalSettings().disabledPlugins ?? [])
+	const entries: MarketplaceLocalInstalledEntry[] = []
+	for (const root of roots) {
+		for (const pluginPath of discoverPluginModulePaths(root)) {
+			entries.push(
+				MarketplaceLocalInstalledEntry.create({
+					id: pluginPath,
+					type: "plugin",
+					name: getPluginDisplayName(pluginPath, root),
+					path: pluginPath,
+					source: isGlobalClinePath(pluginPath) ? "global" : "workspace",
+					enabled: !disabledPlugins.has(pluginPath),
+				}),
+			)
+		}
+	}
+	return entries
+}
+
+export async function listLocalMarketplaceInstalledEntries(controller: Controller): Promise<MarketplaceLocalInstalledEntries> {
+	const mcpEntries = (controller.mcpHub?.getServers() ?? []).map((server) =>
+		MarketplaceLocalInstalledEntry.create({
+			id: server.name,
+			type: "mcp",
+			name: server.name,
+			description: server.status,
+			enabled: server.disabled !== true,
+		}),
+	)
+	const refreshedSkills = await refreshSkills(controller)
+	const skillEntries = [
+		...refreshedSkills.globalSkills.map((skill) =>
+			MarketplaceLocalInstalledEntry.create({
+				id: skill.name,
+				type: "skill",
+				name: skill.name,
+				description: skill.description,
+				path: skill.path,
+				source: skill.path.startsWith("remote:") ? "remote" : "global",
+				enabled: skill.enabled,
+			}),
+		),
+		...refreshedSkills.localSkills.map((skill) =>
+			MarketplaceLocalInstalledEntry.create({
+				id: skill.name,
+				type: "skill",
+				name: skill.name,
+				description: skill.description,
+				path: skill.path,
+				source: isGlobalClinePath(skill.path) ? "global" : "workspace",
+				enabled: skill.enabled,
+			}),
+		),
+	]
+	const pluginEntries = await listPluginLocalEntries()
+	return MarketplaceLocalInstalledEntries.create({ entries: [...mcpEntries, ...skillEntries, ...pluginEntries] })
+}
+
+async function getWorkspacePath(): Promise<string | undefined> {
+	return HostProvider.isInitialized() ? (await HostProvider.workspace.getWorkspacePaths({})).paths[0] : undefined
+}
+
+function getActiveProviderAndModel(controller: Controller): { providerId?: string; modelId?: string } {
+	const mode = controller.stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
+	const apiConfiguration = controller.stateManager.getApiConfiguration()
+	const providerId = mode === "plan" ? apiConfiguration.planModeApiProvider : apiConfiguration.actModeApiProvider
+	const modelId = resolveActiveModelIdFromApiConfiguration(apiConfiguration, mode)
+	return { providerId, modelId }
+}
+
+async function togglePluginLocalEntry(
+	controller: Controller,
+	entry: MarketplaceLocalInstalledEntry,
+	enabled: boolean,
+): Promise<void> {
+	if (!entry.path) throw new Error("Plugin path is required.")
+	if (!enabled) {
+		disablePluginMcpServersInSettings({ pluginPaths: [entry.path] })
+		setDisabledPlugin(entry.path, true)
+		return
+	}
+
+	const workspacePath = await getWorkspacePath()
+	const { providerId, modelId } = getActiveProviderAndModel(controller)
+	const ownedMcpMutations = disablePluginMcpServersInSettings({ pluginPaths: [entry.path] })
+	const result = await syncPluginMcpServersToSettings({
+		pluginPaths: [entry.path],
+		cwd: workspacePath,
+		workspacePath,
+		providerId,
+		modelId,
+	})
+	if (ownedMcpMutations.length > 0 && result.failures.length > 0) {
+		throw new Error(
+			`Failed to sync plugin MCP servers: ${result.failures
+				.map((failure) => `${failure.pluginName ?? failure.pluginPath}: ${failure.message}`)
+				.join("; ")}`,
+		)
+	}
+	setDisabledPlugin(entry.path, false)
+}
+
+export async function toggleLocalMarketplaceInstalledEntry(
+	controller: Controller,
+	request: ToggleMarketplaceLocalInstalledEntryRequest,
+): Promise<MarketplaceLocalInstalledEntries> {
+	const { entry, enabled } = request
+	if (!entry) throw new Error("Installed marketplace entry is required.")
+	if (entry.type === "mcp") {
+		const name = entry.name || entry.id
+		if (!name) throw new Error("MCP server name is required.")
+		await controller.mcpHub?.toggleServerDisabledRPC(name, !enabled)
+		return listLocalMarketplaceInstalledEntries(controller)
+	}
+	if (entry.type === "skill") {
+		await toggleSkill(
+			controller,
+			ToggleSkillRequest.create({
+				skillPath: entry.path || entry.id,
+				isGlobal: entry.source === "global",
+				enabled,
+			}),
+		)
+		return listLocalMarketplaceInstalledEntries(controller)
+	}
+	if (entry.type === "plugin") {
+		await togglePluginLocalEntry(controller, entry, enabled)
+		await controller.invalidateUserInstructionService()
+		return listLocalMarketplaceInstalledEntries(controller)
+	}
+	throw new Error(`Marketplace toggle is not supported for ${entry.type}.`)
+}
+
+export async function uninstallLocalMarketplaceInstalledEntry(
+	controller: Controller,
+	request: MarketplaceLocalInstalledEntryRequest,
+): Promise<MarketplaceInstallResult> {
+	const { entry } = request
+	if (!entry) throw new Error("Installed marketplace entry is required.")
+	const name = entry.name || entry.id
+	if (entry.type === "mcp") {
+		if (!name) throw new Error("MCP server name is required.")
+		await controller.mcpHub?.deleteServerRPC(name)
+		return MarketplaceInstallResult.create({
+			id: entry.id,
+			type: entry.type,
+			status: "uninstalled",
+			message: `Uninstalled ${name}.`,
+		})
+	}
+	if (entry.type === "skill") {
+		if (entry.path?.startsWith("remote:")) {
+			throw new Error("Remote-managed skills cannot be uninstalled from Customize.")
+		}
+		if (!entry.path) throw new Error("Skill path is required for uninstall.")
+		await deleteSkillFile(
+			controller,
+			DeleteSkillRequest.create({
+				skillPath: entry.path,
+				isGlobal: entry.source === "global",
+			}),
+		)
+		await controller.invalidateUserInstructionService()
+		return MarketplaceInstallResult.create({
+			id: entry.id,
+			type: entry.type,
+			status: "uninstalled",
+			message: `Uninstalled ${name || entry.id}.`,
+		})
+	}
+	if (entry.type === "plugin") {
+		const workspaceRoot = await getWorkspacePath()
+		const result = await uninstallPlugin({
+			name: entry.path ? undefined : name,
+			path: entry.path,
+			workspaceRoot,
+		})
+		await controller.invalidateUserInstructionService()
+		return MarketplaceInstallResult.create({
+			id: entry.id,
+			type: entry.type,
+			status: "uninstalled",
+			message: `Uninstalled ${result.name}.`,
+			output: [`Path: ${result.installPath}`, ...result.removedPaths.map((path) => `Removed: ${path}`)].join("\n"),
+		})
+	}
+	throw new Error(`Marketplace uninstall is not supported for ${entry.type}.`)
+}
diff --git a/apps/vscode/src/core/controller/marketplace/toggleMarketplaceLocalInstalledEntry.ts b/apps/vscode/src/core/controller/marketplace/toggleMarketplaceLocalInstalledEntry.ts
new file mode 100644
index 0000000..69a7485
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/toggleMarketplaceLocalInstalledEntry.ts
@@ -0,0 +1,13 @@
+import type {
+	MarketplaceLocalInstalledEntries,
+	ToggleMarketplaceLocalInstalledEntryRequest,
+} from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { toggleLocalMarketplaceInstalledEntry } from "./marketplace-helpers"
+
+export async function toggleMarketplaceLocalInstalledEntry(
+	controller: Controller,
+	request: ToggleMarketplaceLocalInstalledEntryRequest,
+): Promise<MarketplaceLocalInstalledEntries> {
+	return toggleLocalMarketplaceInstalledEntry(controller, request)
+}
diff --git a/apps/vscode/src/core/controller/marketplace/uninstallMarketplaceEntry.ts b/apps/vscode/src/core/controller/marketplace/uninstallMarketplaceEntry.ts
new file mode 100644
index 0000000..e663fbb
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/uninstallMarketplaceEntry.ts
@@ -0,0 +1,17 @@
+import { type MarketplaceEntryRequest, MarketplaceInstallResult } from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { uninstallMarketplaceEntryFromCatalog } from "./marketplace-helpers"
+
+export async function uninstallMarketplaceEntry(
+	controller: Controller,
+	request: MarketplaceEntryRequest,
+): Promise<MarketplaceInstallResult> {
+	if (!request.entry) {
+		throw new Error("Marketplace entry is required.")
+	}
+	const result = await uninstallMarketplaceEntryFromCatalog(controller, request.entry)
+	if (request.entry.type === "skill" || request.entry.type === "plugin") {
+		await controller.invalidateUserInstructionService()
+	}
+	return result
+}
diff --git a/apps/vscode/src/core/controller/marketplace/uninstallMarketplaceLocalInstalledEntry.ts b/apps/vscode/src/core/controller/marketplace/uninstallMarketplaceLocalInstalledEntry.ts
new file mode 100644
index 0000000..f9f7b7d
--- /dev/null
+++ b/apps/vscode/src/core/controller/marketplace/uninstallMarketplaceLocalInstalledEntry.ts
@@ -0,0 +1,10 @@
+import type { MarketplaceInstallResult, MarketplaceLocalInstalledEntryRequest } from "@shared/proto/cline/marketplace"
+import type { Controller } from "../index"
+import { uninstallLocalMarketplaceInstalledEntry } from "./marketplace-helpers"
+
+export async function uninstallMarketplaceLocalInstalledEntry(
+	controller: Controller,
+	request: MarketplaceLocalInstalledEntryRequest,
+): Promise<MarketplaceInstallResult> {
+	return uninstallLocalMarketplaceInstalledEntry(controller, request)
+}
diff --git a/apps/vscode/src/core/controller/mcp/addRemoteMcpServer.ts b/apps/vscode/src/core/controller/mcp/addRemoteMcpServer.ts
new file mode 100644
index 0000000..9f262c2
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/addRemoteMcpServer.ts
@@ -0,0 +1,34 @@
+import type { AddRemoteMcpServerRequest } from "@shared/proto/cline/mcp"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertMcpServersToProtoMcpServers } from "@/shared/proto-conversions/mcp/mcp-server-conversion"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Adds a new remote MCP server via gRPC
+ * @param controller The controller instance
+ * @param request The request containing server name and URL
+ * @returns An array of McpServer objects
+ */
+export async function addRemoteMcpServer(controller: Controller, request: AddRemoteMcpServerRequest): Promise<McpServers> {
+	try {
+		// Validate required fields
+		if (!request.serverName) {
+			throw new Error("Server name is required")
+		}
+		if (!request.serverUrl) {
+			throw new Error("Server URL is required")
+		}
+
+		// Call the McpHub method to add the remote server
+		const servers = await controller.mcpHub?.addRemoteServer(request.serverName, request.serverUrl, request.transportType)
+
+		const protoServers = convertMcpServersToProtoMcpServers(servers)
+
+		return McpServers.create({ mcpServers: protoServers })
+	} catch (error) {
+		Logger.error(`Failed to add remote MCP server ${request.serverName}:`, error)
+
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/authenticateMcpServer.ts b/apps/vscode/src/core/controller/mcp/authenticateMcpServer.ts
new file mode 100644
index 0000000..76d6d6d
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/authenticateMcpServer.ts
@@ -0,0 +1,27 @@
+import type { StringRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Initiates OAuth authentication for an MCP server
+ * @param controller The controller instance
+ * @param request The request containing server name
+ * @returns Empty response
+ */
+export async function authenticateMcpServer(controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		const serverName = request.value
+		if (!serverName) {
+			throw new Error("Server name is required")
+		}
+
+		// Call the McpHub method to initiate OAuth
+		await controller.mcpHub?.initiateOAuth(serverName)
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error(`Failed to initiate OAuth for MCP server:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/deleteMcpServer.ts b/apps/vscode/src/core/controller/mcp/deleteMcpServer.ts
new file mode 100644
index 0000000..5fb96cf
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/deleteMcpServer.ts
@@ -0,0 +1,26 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { Logger } from "@/shared/services/Logger"
+import { convertMcpServersToProtoMcpServers } from "../../../shared/proto-conversions/mcp/mcp-server-conversion"
+import type { Controller } from "../index"
+
+/**
+ * Deletes an MCP server
+ * @param controller The controller instance
+ * @param request The delete server request
+ * @returns The list of remaining MCP servers after deletion
+ */
+export async function deleteMcpServer(controller: Controller, request: StringRequest): Promise<McpServers> {
+	try {
+		// Call the RPC variant to delete the server and get updated server list
+		const mcpServers = (await controller.mcpHub?.deleteServerRPC(request.value)) || []
+
+		// Convert application types to protobuf types
+		const protoServers = convertMcpServersToProtoMcpServers(mcpServers)
+
+		return McpServers.create({ mcpServers: protoServers })
+	} catch (error) {
+		Logger.error(`Failed to delete MCP server: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/getLatestMcpServers.ts b/apps/vscode/src/core/controller/mcp/getLatestMcpServers.ts
new file mode 100644
index 0000000..f1bc50e
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/getLatestMcpServers.ts
@@ -0,0 +1,26 @@
+import type { Empty } from "@shared/proto/cline/common"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertMcpServersToProtoMcpServers } from "@/shared/proto-conversions/mcp/mcp-server-conversion"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * RPC handler for getting the latest MCP servers
+ * @param controller The controller instance
+ * @param _request Empty request
+ * @returns McpServers response with list of all MCP servers
+ */
+export async function getLatestMcpServers(controller: Controller, _request: Empty): Promise<McpServers> {
+	try {
+		// Get sorted servers from mcpHub using the RPC variant
+		const mcpServers = (await controller.mcpHub?.getLatestMcpServersRPC()) || []
+
+		// Convert to proto format
+		const protoServers = convertMcpServersToProtoMcpServers(mcpServers)
+
+		return McpServers.create({ mcpServers: protoServers })
+	} catch (error) {
+		Logger.error("Error fetching latest MCP servers:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/openMcpSettings.ts b/apps/vscode/src/core/controller/mcp/openMcpSettings.ts
new file mode 100644
index 0000000..fab5abc
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/openMcpSettings.ts
@@ -0,0 +1,17 @@
+import { openFile as openFileIntegration } from "@integrations/misc/open-file"
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Opens the MCP settings file in the editor
+ * @param controller The controller instance
+ * @param _request Empty request
+ * @returns Empty response
+ */
+export async function openMcpSettings(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	const mcpSettingsFilePath = await controller.mcpHub?.getMcpSettingsFilePath()
+	if (mcpSettingsFilePath) {
+		await openFileIntegration(mcpSettingsFilePath)
+	}
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/mcp/restartMcpServer.ts b/apps/vscode/src/core/controller/mcp/restartMcpServer.ts
new file mode 100644
index 0000000..4fb27ae
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/restartMcpServer.ts
@@ -0,0 +1,25 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertMcpServersToProtoMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Restarts an MCP server connection
+ * @param controller The controller instance
+ * @param request The request containing the server name
+ * @returns The updated list of MCP servers
+ */
+export async function restartMcpServer(controller: Controller, request: StringRequest): Promise<McpServers> {
+	try {
+		const mcpServers = await controller.mcpHub?.restartConnectionRPC(request.value)
+
+		// Convert from McpServer[] to ProtoMcpServer[] ensuring all required fields are set
+		const protoServers = convertMcpServersToProtoMcpServers(mcpServers)
+
+		return McpServers.create({ mcpServers: protoServers })
+	} catch (error) {
+		Logger.error(`Failed to restart MCP server ${request.value}:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/subscribeToMcpServers.ts b/apps/vscode/src/core/controller/mcp/subscribeToMcpServers.ts
new file mode 100644
index 0000000..a17742c
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/subscribeToMcpServers.ts
@@ -0,0 +1,77 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertMcpServersToProtoMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active subscriptions
+const activeMcpServersSubscriptions = new Set<StreamingResponseHandler<McpServers>>()
+
+/**
+ * Subscribe to MCP servers events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToMcpServers(
+	controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<McpServers>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeMcpServersSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeMcpServersSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "mcpServers_subscription" }, responseStream)
+	}
+
+	// Send initial state if available
+	if (controller.mcpHub) {
+		const mcpServers = controller.mcpHub.getServers()
+		if (mcpServers.length > 0) {
+			try {
+				const protoServers = McpServers.create({
+					mcpServers: convertMcpServersToProtoMcpServers(mcpServers),
+				})
+				await responseStream(
+					protoServers,
+					false, // Not the last message
+				)
+			} catch (error) {
+				Logger.error("Error sending initial MCP servers:", error)
+				activeMcpServersSubscriptions.delete(responseStream)
+			}
+		}
+	}
+}
+
+/**
+ * Send an MCP servers update to all active subscribers
+ * @param mcpServers The MCP servers to send
+ */
+export async function sendMcpServersUpdate(mcpServers: McpServers): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeMcpServersSubscriptions).map(async (responseStream) => {
+		try {
+			await responseStream(
+				mcpServers,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending MCP servers update:", error)
+			// Remove the subscription if there was an error
+			activeMcpServersSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/mcp/toggleMcpServer.ts b/apps/vscode/src/core/controller/mcp/toggleMcpServer.ts
new file mode 100644
index 0000000..99084e8
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/toggleMcpServer.ts
@@ -0,0 +1,25 @@
+import type { ToggleMcpServerRequest } from "@shared/proto/cline/mcp"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { Logger } from "@/shared/services/Logger"
+import { convertMcpServersToProtoMcpServers } from "../../../shared/proto-conversions/mcp/mcp-server-conversion"
+import type { Controller } from "../index"
+
+/**
+ * Toggles an MCP server's enabled/disabled status
+ * @param controller The controller instance
+ * @param request The request containing server ID and disabled status
+ * @returns A response indicating success or failure
+ */
+export async function toggleMcpServer(controller: Controller, request: ToggleMcpServerRequest): Promise<McpServers> {
+	try {
+		const mcpServers = await controller.mcpHub?.toggleServerDisabledRPC(request.serverName, request.disabled)
+
+		// Convert from McpServer[] to ProtoMcpServer[] ensuring all required fields are set
+		const protoServers = convertMcpServersToProtoMcpServers(mcpServers)
+
+		return McpServers.create({ mcpServers: protoServers })
+	} catch (error) {
+		Logger.error(`Failed to toggle MCP server ${request.serverName}:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/toggleToolAutoApprove.ts b/apps/vscode/src/core/controller/mcp/toggleToolAutoApprove.ts
new file mode 100644
index 0000000..cd83c64
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/toggleToolAutoApprove.ts
@@ -0,0 +1,25 @@
+import type { ToggleToolAutoApproveRequest } from "@shared/proto/cline/mcp"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertMcpServersToProtoMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Toggles auto-approve setting for MCP server tools
+ * @param controller The controller instance
+ * @param request The toggle tool auto-approve request
+ * @returns Updated list of MCP servers
+ */
+export async function toggleToolAutoApprove(controller: Controller, request: ToggleToolAutoApproveRequest): Promise<McpServers> {
+	try {
+		// Call the RPC variant that returns the servers directly
+		const mcpServers =
+			(await controller.mcpHub?.toggleToolAutoApproveRPC(request.serverName, request.toolNames, request.autoApprove)) || []
+
+		// Convert application types to proto types
+		return McpServers.create({ mcpServers: convertMcpServersToProtoMcpServers(mcpServers) })
+	} catch (error) {
+		Logger.error(`Failed to toggle tool auto-approve for ${request.serverName}:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/mcp/updateMcpTimeout.ts b/apps/vscode/src/core/controller/mcp/updateMcpTimeout.ts
new file mode 100644
index 0000000..2fd9ec6
--- /dev/null
+++ b/apps/vscode/src/core/controller/mcp/updateMcpTimeout.ts
@@ -0,0 +1,27 @@
+import { McpServers, UpdateMcpTimeoutRequest } from "@shared/proto/cline/mcp"
+import { convertMcpServersToProtoMcpServers } from "@/shared/proto-conversions/mcp/mcp-server-conversion"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Updates the timeout configuration for an MCP server.
+ * @param controller - The Controller instance
+ * @param request - Contains server name and timeout value
+ * @returns Array of updated McpServer objects
+ */
+export async function updateMcpTimeout(controller: Controller, request: UpdateMcpTimeoutRequest): Promise<McpServers> {
+	try {
+		if (request.serverName && typeof request.serverName === "string" && typeof request.timeout === "number") {
+			const mcpServers = await controller.mcpHub?.updateServerTimeoutRPC(request.serverName, request.timeout)
+			const convertedMcpServers = convertMcpServersToProtoMcpServers(mcpServers)
+			Logger.log("convertedMcpServers", convertedMcpServers)
+			return McpServers.create({ mcpServers: convertedMcpServers })
+		} else {
+			Logger.error("Server name and timeout are required")
+			throw new Error("Server name and timeout are required")
+		}
+	} catch (error) {
+		Logger.error(`Failed to update timeout for server ${request.serverName}:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/__tests__/handleClinePassProviderSelection.test.ts b/apps/vscode/src/core/controller/models/__tests__/handleClinePassProviderSelection.test.ts
new file mode 100644
index 0000000..2b318ff
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/handleClinePassProviderSelection.test.ts
@@ -0,0 +1,60 @@
+import * as assert from "assert"
+import { afterEach, beforeEach, describe, it } from "mocha"
+import sinon from "sinon"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../../index"
+import { clearOrganizationForClinePassProviderSelection } from "../handleClinePassProviderSelection"
+
+describe("clearOrganizationForClinePassProviderSelection", () => {
+	let sandbox: sinon.SinonSandbox
+	let switchAccount: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		switchAccount = sandbox.stub().resolves()
+		sandbox.stub(Logger, "debug")
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	function createController(): Controller {
+		return {
+			accountService: { switchAccount },
+		} as unknown as Controller
+	}
+
+	it("does nothing when ClinePass is not selected", async () => {
+		await clearOrganizationForClinePassProviderSelection(createController(), {
+			planModeApiProvider: "cline",
+			actModeApiProvider: "openrouter",
+		})
+
+		assert.strictEqual(switchAccount.callCount, 0)
+	})
+
+	it("switches to the personal account when ClinePass is selected", async () => {
+		await clearOrganizationForClinePassProviderSelection(createController(), {
+			planModeApiProvider: "cline-pass",
+			actModeApiProvider: "openrouter",
+		})
+
+		assert.strictEqual(switchAccount.callCount, 1)
+		assert.strictEqual(switchAccount.firstCall.args[0], null)
+	})
+
+	it("logs and swallows account switch failures", async () => {
+		const error = new Error("not signed in")
+		switchAccount.rejects(error)
+
+		await clearOrganizationForClinePassProviderSelection(createController(), {
+			planModeApiProvider: "cline",
+			actModeApiProvider: "cline-pass",
+		})
+
+		assert.strictEqual(switchAccount.callCount, 1)
+		assert.strictEqual(switchAccount.firstCall.args[0], null)
+		assert.ok((Logger.debug as sinon.SinonStub).calledOnce)
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/__tests__/providerCatalogHandlers.test.ts b/apps/vscode/src/core/controller/models/__tests__/providerCatalogHandlers.test.ts
new file mode 100644
index 0000000..4964054
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/providerCatalogHandlers.test.ts
@@ -0,0 +1,297 @@
+import type { ApiConfiguration } from "@shared/api"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import type { EffectiveProviderConfig, ProviderCatalog, ProviderConfigStore } from "@/sdk/model-catalog/contracts"
+import { computeConfigFingerprint } from "@/sdk/model-catalog/fingerprint"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import { ApiFormat, OpenRouterModelInfo } from "@/shared/proto/cline/models"
+import type { ProviderCatalogController } from "../providerCatalogShared"
+
+type TestStateManager = {
+	setGlobalStateBatch: ReturnType<typeof vi.fn>
+	flushPendingState?: ReturnType<typeof vi.fn<() => Promise<void>>>
+	getApiConfiguration?: ReturnType<typeof vi.fn<() => ApiConfiguration | undefined>>
+}
+
+function makeStore(config: EffectiveProviderConfig): ProviderConfigStore {
+	return {
+		read: vi.fn(() => config),
+		readSelection: vi.fn(() => undefined),
+		subscribe: vi.fn(() => ({ dispose: vi.fn() })),
+		write: vi.fn(() => config),
+		commitSelection: vi.fn(),
+	}
+}
+
+function makeCatalog(): ProviderCatalog {
+	return {
+		listProviders: vi.fn(async () => []),
+		invalidateProviderListings: vi.fn(),
+		resolveModels: vi.fn(),
+		peekModels: vi.fn(),
+		subscribe: vi.fn(() => ({ dispose: vi.fn() })),
+	}
+}
+
+function makeController(
+	store: ProviderConfigStore,
+	catalog: ProviderCatalog,
+	stateManager?: TestStateManager,
+	handleApiConfigurationChanged?: ReturnType<typeof vi.fn<(previous: ApiConfiguration, next: ApiConfiguration) => void>>,
+): ProviderCatalogController {
+	return {
+		getProviderConfigStore: () => store,
+		getProviderCatalog: () => catalog,
+		...(stateManager ? { stateManager } : {}),
+		...(handleApiConfigurationChanged ? { handleApiConfigurationChanged } : {}),
+	}
+}
+
+describe("provider model catalog handlers", () => {
+	afterEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("listProviders returns provider listings from the catalog singleton", async () => {
+		const { listProviders } = await import("../listProviders")
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+		const catalog = makeCatalog()
+		vi.mocked(catalog.listProviders).mockResolvedValue([
+			{
+				id: providerId,
+				name: "DeepSeek",
+				defaultModelId: "deepseek-v4-flash",
+				protocol: "openai-chat",
+				authDescription: "DeepSeek models",
+				allowsCustomModelIds: false,
+				usageCostDisplay: "show",
+			},
+		])
+		const controller = makeController(store, catalog)
+
+		const response = await listProviders(controller, {})
+
+		expect(response.providers).toEqual([
+			{
+				id: "deepseek",
+				name: "DeepSeek",
+				defaultModelId: "deepseek-v4-flash",
+				family: undefined,
+				protocol: "openai-chat",
+				authDescription: "DeepSeek models",
+				baseUrlDescription: undefined,
+				allowsCustomModelIds: false,
+				usageCostDisplay: "show",
+			},
+		])
+		expect(catalog.listProviders).toHaveBeenCalledTimes(1)
+	})
+
+	it("resolveProviderModels returns full protobuf model metadata and request id", async () => {
+		const { resolveProviderModels } = await import("../resolveProviderModels")
+		const providerId = parseProviderId("deepseek")
+		const fingerprint = computeConfigFingerprint(providerId, { providerId, apiKey: "secret" })
+		const store = makeStore({ providerId, apiKey: "secret" })
+		const catalog = makeCatalog()
+		vi.mocked(catalog.resolveModels).mockResolvedValue({
+			ok: true,
+			providerId,
+			configFingerprint: fingerprint,
+			models: new Map([
+				[
+					"deepseek-v4-flash",
+					{
+						name: "DeepSeek V4 Flash",
+						maxTokens: 123,
+						contextWindow: 456,
+						supportsImages: true,
+						supportsPromptCache: true,
+						supportsReasoning: true,
+						inputPrice: 1,
+						outputPrice: 2,
+						cacheWritesPrice: 3,
+						cacheReadsPrice: 4,
+						description: "rich metadata",
+						temperature: 0.2,
+						apiFormat: ApiFormat.OPENAI_CHAT,
+					},
+				],
+			]),
+			defaultModelId: "deepseek-v4-flash",
+			source: "sdk-dynamic",
+			fetchedAt: 99,
+		})
+		const controller = makeController(store, catalog)
+
+		const response = await resolveProviderModels(controller, {
+			providerId: "deepseek",
+			forceRefresh: true,
+			requestId: "req-1",
+		})
+
+		expect(response.requestId).toBe("req-1")
+		expect(response.configFingerprint).toBe(fingerprint)
+		expect(response.models["deepseek-v4-flash"]).toMatchObject({
+			name: "DeepSeek V4 Flash",
+			maxTokens: 123,
+			contextWindow: 456,
+			supportsImages: true,
+			supportsPromptCache: true,
+			supportsReasoning: true,
+			temperature: 0.2,
+			apiFormat: ApiFormat.OPENAI_CHAT,
+		})
+		expect(catalog.resolveModels).toHaveBeenCalledWith(providerId, { forceRefresh: true })
+	})
+
+	it("readProviderConfig redacts secrets", async () => {
+		const { readProviderConfig } = await import("../readProviderConfig")
+		const providerId = parseProviderId("cline")
+		const store = makeStore({
+			providerId,
+			apiKey: "SECRET_SENTINEL_API_KEY",
+			baseUrl: "https://api.example.com/v1",
+			auth: { accessToken: "SECRET_SENTINEL_ACCESS", refreshToken: "SECRET_SENTINEL_REFRESH", accountId: "acct-1" },
+		})
+		const controller = makeController(store, makeCatalog())
+
+		const response = await readProviderConfig(controller, { value: "cline" })
+
+		expect(response).toMatchObject({
+			providerId: "cline",
+			baseUrl: "https://api.example.com/v1",
+			apiKeyLength: "SECRET_SENTINEL_API_KEY".length,
+			hasAccessToken: true,
+			hasRefreshToken: true,
+			accountId: "acct-1",
+		})
+		expect(JSON.stringify(response)).not.toContain("SECRET_SENTINEL")
+	})
+
+	it("writeProviderConfig writes a patch and returns redacted updated config", async () => {
+		const { writeProviderConfig } = await import("../writeProviderConfig")
+		const providerId = parseProviderId("ollama")
+		const updatedConfig: EffectiveProviderConfig = {
+			providerId,
+			apiKey: "SECRET_SENTINEL_OLLAMA",
+			baseUrl: "http://localhost:11434/v1",
+		}
+		const store = makeStore(updatedConfig)
+		const controller = makeController(store, makeCatalog())
+
+		const response = await writeProviderConfig(controller, {
+			providerId: "ollama",
+			patch: { apiKey: "SECRET_SENTINEL_OLLAMA", baseUrl: "http://localhost:11434/v1", headers: {} },
+		})
+
+		expect(store.write).toHaveBeenCalledWith(providerId, {
+			apiKey: "SECRET_SENTINEL_OLLAMA",
+			baseUrl: "http://localhost:11434/v1",
+		})
+		expect(response.apiKeyLength).toBe("SECRET_SENTINEL_OLLAMA".length)
+		expect(JSON.stringify(response)).not.toContain("SECRET_SENTINEL")
+	})
+
+	it("writeProviderConfig can explicitly clear headers", async () => {
+		const { writeProviderConfig } = await import("../writeProviderConfig")
+		const providerId = parseProviderId("openai")
+		const updatedConfig: EffectiveProviderConfig = {
+			providerId,
+			headers: {},
+		}
+		const store = makeStore(updatedConfig)
+		const controller = makeController(store, makeCatalog())
+
+		await writeProviderConfig(controller, {
+			providerId: "openai",
+			patch: { headers: {}, clearHeaders: true },
+		})
+
+		expect(store.write).toHaveBeenCalledWith(providerId, { headers: {} })
+	})
+
+	it("commitModelSelection validates mode and commits the full selection envelope", async () => {
+		const { commitModelSelection } = await import("../commitModelSelection")
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+		const stateManager: TestStateManager = {
+			setGlobalStateBatch: vi.fn(),
+			flushPendingState: vi.fn(async () => undefined),
+		}
+		const controller = makeController(store, makeCatalog(), stateManager)
+
+		await commitModelSelection(controller, {
+			providerId: "deepseek",
+			mode: "act",
+			modelId: "deepseek-v4-flash",
+			modelInfo: OpenRouterModelInfo.create({
+				name: "DeepSeek V4 Flash",
+				contextWindow: 456,
+				supportsPromptCache: true,
+				apiFormat: ApiFormat.OPENAI_CHAT,
+			}),
+		})
+
+		expect(store.commitSelection).toHaveBeenCalledWith(providerId, "act", {
+			providerId,
+			modelId: "deepseek-v4-flash",
+			modelInfo: expect.objectContaining({
+				name: "DeepSeek V4 Flash",
+				contextWindow: 456,
+				supportsPromptCache: true,
+				apiFormat: ApiFormat.OPENAI_CHAT,
+			}),
+		})
+		expect(stateManager.setGlobalStateBatch).toHaveBeenCalledWith({
+			actModeApiProvider: "deepseek",
+			actModeApiModelId: "deepseek-v4-flash",
+		})
+		expect(stateManager.flushPendingState).toHaveBeenCalledTimes(1)
+	})
+
+	it("commitModelSelection reports provider changes when config is initialized", async () => {
+		const { commitModelSelection } = await import("../commitModelSelection")
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+		const stateManager: TestStateManager = {
+			setGlobalStateBatch: vi.fn(),
+			flushPendingState: vi.fn(async () => undefined),
+			getApiConfiguration: vi
+				.fn<() => ApiConfiguration | undefined>()
+				.mockReturnValueOnce(undefined)
+				.mockReturnValueOnce({ actModeApiProvider: "deepseek" }),
+		}
+		const handleApiConfigurationChanged = vi.fn<(previous: ApiConfiguration, next: ApiConfiguration) => void>()
+		const controller = makeController(store, makeCatalog(), stateManager, handleApiConfigurationChanged)
+
+		await commitModelSelection(controller, {
+			providerId: "deepseek",
+			mode: "act",
+			modelId: "deepseek-v4-flash",
+			modelInfo: OpenRouterModelInfo.create({
+				name: "DeepSeek V4 Flash",
+				apiFormat: ApiFormat.OPENAI_CHAT,
+			}),
+		})
+
+		expect(handleApiConfigurationChanged).toHaveBeenCalledWith({}, { actModeApiProvider: "deepseek" })
+		expect(stateManager.flushPendingState).toHaveBeenCalledTimes(1)
+	})
+
+	it("commitModelSelection rejects invalid mode", async () => {
+		const { commitModelSelection } = await import("../commitModelSelection")
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+		const controller = makeController(store, makeCatalog())
+
+		await expect(
+			commitModelSelection(controller, {
+				providerId: "deepseek",
+				mode: "invalid",
+				modelId: "deepseek-v4-flash",
+				modelInfo: OpenRouterModelInfo.create({ supportsPromptCache: true }),
+			}),
+		).rejects.toThrow('mode must be "plan" or "act"')
+		expect(store.commitSelection).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/__tests__/providerCatalogSmoke.test.ts b/apps/vscode/src/core/controller/models/__tests__/providerCatalogSmoke.test.ts
new file mode 100644
index 0000000..5cfbab3
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/providerCatalogSmoke.test.ts
@@ -0,0 +1,89 @@
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"
+import { StateManager } from "@/core/storage/StateManager"
+import { createProviderCatalog } from "@/sdk/model-catalog/catalog"
+import type { ProviderCatalog, ProviderConfigStore } from "@/sdk/model-catalog/contracts"
+import { createProviderConfigStore } from "@/sdk/model-catalog/store"
+import { Empty, StringRequest } from "@/shared/proto/cline/common"
+import { CommitModelSelectionRequest } from "@/shared/proto/cline/models"
+import { createStorageContext } from "@/shared/storage/storage-context"
+import { commitModelSelection } from "../commitModelSelection"
+import { listProviders } from "../listProviders"
+import type { ProviderCatalogController } from "../providerCatalogShared"
+import { readProviderConfig } from "../readProviderConfig"
+import { resolveProviderModels } from "../resolveProviderModels"
+
+vi.mock("@/services/logging/distinctId", () => ({
+	initializeDistinctId: vi.fn(async () => undefined),
+}))
+
+describe("provider model catalog backend smoke", () => {
+	let clineDir: string
+	let store: ProviderConfigStore
+	let catalog: ProviderCatalog
+	let controller: ProviderCatalogController
+	let originalClineDir: string | undefined
+
+	beforeAll(async () => {
+		clineDir = await fs.mkdtemp(path.join(os.tmpdir(), "cline-provider-catalog-smoke-"))
+		originalClineDir = process.env.CLINE_DIR
+		process.env.CLINE_DIR = clineDir
+		await StateManager.initialize(createStorageContext({ clineDir, workspacePath: clineDir }))
+		store = createProviderConfigStore()
+		catalog = createProviderCatalog(store)
+		controller = {
+			getProviderConfigStore: () => store,
+			getProviderCatalog: () => catalog,
+		}
+	})
+
+	afterAll(async () => {
+		await StateManager.get().flushPendingState()
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR
+		} else {
+			process.env.CLINE_DIR = originalClineDir
+		}
+		await StateManager.get().reInitialize()
+		await fs.rm(clineDir, { recursive: true, force: true })
+	})
+
+	it("lists providers, resolves DeepSeek models, and round-trips committed selection", async () => {
+		const providers = await listProviders(controller, Empty.create())
+		expect(providers.providers.length).toBeGreaterThanOrEqual(4)
+		expect(providers.providers.some((provider) => provider.id === "deepseek")).toBe(true)
+
+		const models = await resolveProviderModels(controller, {
+			providerId: "deepseek",
+			forceRefresh: false,
+			requestId: "smoke-request",
+		})
+		expect(models.ok).toBe(true)
+		expect(models.requestId).toBe("smoke-request")
+		expect(Object.keys(models.models).length).toBeGreaterThanOrEqual(4)
+
+		const modelId = models.defaultModelId || Object.keys(models.models)[0]
+		expect(modelId).toBeTruthy()
+		const modelInfo = models.models[modelId]
+		expect(modelInfo).toBeDefined()
+
+		await commitModelSelection(
+			controller,
+			CommitModelSelectionRequest.create({
+				providerId: "deepseek",
+				mode: "act",
+				modelId,
+				modelInfo,
+			}),
+		)
+
+		const config = await readProviderConfig(controller, StringRequest.create({ value: "deepseek" }))
+		expect(config.providerId).toBe("deepseek")
+		expect(config.actSelection?.providerId).toBe("deepseek")
+		expect(config.actSelection?.modelId).toBe(modelId)
+		expect(config.actSelection?.modelInfo).toEqual(modelInfo)
+		expect(JSON.stringify(config)).not.toContain("SECRET")
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/__tests__/providerSwitchNormalization.test.ts b/apps/vscode/src/core/controller/models/__tests__/providerSwitchNormalization.test.ts
new file mode 100644
index 0000000..c143cac
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/providerSwitchNormalization.test.ts
@@ -0,0 +1,113 @@
+import { MODEL_COLLECTIONS_BY_PROVIDER_ID } from "@cline/llms"
+import { describe, expect, it, vi } from "vitest"
+import type { EffectiveProviderConfig, ProviderConfigStore } from "@/sdk/model-catalog/contracts"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import { normalizeProviderSwitchModel } from "../providerSwitchNormalization"
+
+function makeStore(config: EffectiveProviderConfig): ProviderConfigStore {
+	return {
+		read: vi.fn(() => config),
+		readSelection: vi.fn(() => undefined),
+		subscribe: vi.fn(() => ({ dispose: vi.fn() })),
+		write: vi.fn(() => config),
+		commitSelection: vi.fn(),
+	}
+}
+
+describe("normalizeProviderSwitchModel", () => {
+	it("uses the SDK default when switching to DeepSeek with a stale Anthropic model id", () => {
+		const providerId = parseProviderId("deepseek")
+		const defaultModelId = MODEL_COLLECTIONS_BY_PROVIDER_ID.deepseek.provider.defaultModelId
+		const store = makeStore({ providerId })
+
+		const normalized = normalizeProviderSwitchModel(
+			store,
+			{ actModeApiProvider: "anthropic", actModeApiModelId: "claude-sonnet-4-5-20250929" },
+			{ actModeApiProvider: "deepseek", actModeApiModelId: undefined },
+		)
+
+		expect(normalized.actModeApiProvider).toBe("deepseek")
+		expect(normalized.actModeApiModelId).toBe(defaultModelId)
+	})
+
+	it("uses the SDK default when switching to Gemini with a stale DeepSeek model id", () => {
+		const providerId = parseProviderId("gemini")
+		const store = makeStore({ providerId })
+
+		const normalized = normalizeProviderSwitchModel(
+			store,
+			{ actModeApiProvider: "deepseek", actModeApiModelId: "deepseek-v4-flash" },
+			{ actModeApiProvider: "gemini", actModeApiModelId: undefined },
+		)
+
+		expect(normalized.actModeApiProvider).toBe("gemini")
+		// The Gemini SDK manifest currently has a provider default that is not in
+		// the generated model catalog. Provider-switch normalization must match the
+		// model picker/catalog default instead of writing the invalid manifest value.
+		expect(MODEL_COLLECTIONS_BY_PROVIDER_ID.gemini.provider.defaultModelId).toBe("gemma-4-26b")
+		expect(normalized.actModeApiModelId).toBe("gemini-3.5-flash")
+	})
+
+	it("restores a previously committed DeepSeek selection before falling back to SDK default", () => {
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+		vi.mocked(store.readSelection).mockReturnValue({
+			providerId,
+			modelId: "deepseek-v4-pro",
+			modelInfo: { name: "DeepSeek V4 Pro", contextWindow: 1_000_000, supportsPromptCache: true },
+		})
+
+		const normalized = normalizeProviderSwitchModel(
+			store,
+			{ actModeApiProvider: "anthropic", actModeApiModelId: "claude-sonnet-4-5-20250929" },
+			{ actModeApiProvider: "deepseek", actModeApiModelId: undefined },
+		)
+
+		expect(normalized.actModeApiModelId).toBe("deepseek-v4-pro")
+	})
+
+	it("keeps an already valid DeepSeek model id", () => {
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+
+		const normalized = normalizeProviderSwitchModel(
+			store,
+			{ actModeApiProvider: "anthropic", actModeApiModelId: "deepseek-v4-flash" },
+			{ actModeApiProvider: "deepseek", actModeApiModelId: undefined },
+		)
+
+		expect(normalized.actModeApiModelId).toBe("deepseek-v4-flash")
+		expect(store.readSelection).not.toHaveBeenCalled()
+	})
+
+	it("does not change model id when switching to a provider the SDK does not know", () => {
+		// A custom/unregistered provider has no SDK catalog to resolve against, so
+		// the generic model-id slot is left untouched.
+		const providerId = parseProviderId("my-custom-provider")
+		const store = makeStore({ providerId })
+
+		const normalized = normalizeProviderSwitchModel(
+			store,
+			{ actModeApiProvider: "deepseek", actModeApiModelId: "deepseek-v4-flash" },
+			{ actModeApiProvider: "my-custom-provider" as never },
+		)
+
+		expect(normalized).toEqual({ actModeApiProvider: "my-custom-provider" })
+		expect(store.readSelection).not.toHaveBeenCalled()
+	})
+
+	it("normalizes plan mode independently", () => {
+		const providerId = parseProviderId("deepseek")
+		const defaultModelId = MODEL_COLLECTIONS_BY_PROVIDER_ID.deepseek.provider.defaultModelId
+		const store = makeStore({ providerId })
+
+		const normalized = normalizeProviderSwitchModel(
+			store,
+			{ planModeApiProvider: "anthropic", planModeApiModelId: "claude-sonnet-4-5-20250929" },
+			{ planModeApiProvider: "deepseek", planModeApiModelId: undefined },
+		)
+
+		expect(normalized.planModeApiProvider).toBe("deepseek")
+		expect(normalized.planModeApiModelId).toBe(defaultModelId)
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts b/apps/vscode/src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts
new file mode 100644
index 0000000..132cc11
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts
@@ -0,0 +1,76 @@
+import * as sdkCore from "@cline/core"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { ClineEnv } from "@/config"
+import { refreshClineRecommendedModels, resetClineRecommendedModelsCacheForTests } from "../refreshClineRecommendedModels"
+
+// The HTTP fetch + normalization + offline fallback lives in the SDK
+// (`@cline/core` `fetchClineRecommendedModels`). These tests cover the
+// extension-side wrapper: delegation to the SDK and in-memory caching. There is
+// intentionally no feature-flag gate here; onboarding must not race against the
+// remote-config cache and accidentally keep the hardcoded fallback list.
+
+describe("refreshClineRecommendedModels", () => {
+	beforeEach(() => {
+		resetClineRecommendedModelsCacheForTests()
+		// ClineEnv is not initialized in the unit-test environment; the wrapper
+		// passes its apiBaseUrl to the SDK, so provide a stable stub.
+		vi.spyOn(ClineEnv, "config").mockReturnValue({ apiBaseUrl: "https://api.cline-test.bot" } as ReturnType<
+			typeof ClineEnv.config
+		>)
+	})
+
+	afterEach(() => {
+		resetClineRecommendedModelsCacheForTests()
+		vi.restoreAllMocks()
+	})
+
+	it("delegates to the SDK fetch", async () => {
+		const sdkResult = {
+			recommended: [{ id: "anthropic/claude-sonnet-4.6", name: "Claude Sonnet 4.6", description: "Remote", tags: ["NEW"] }],
+			free: [{ id: "z-ai/glm-5", name: "GLM 5", description: "Remote free", tags: [] }],
+			clinePass: [],
+		}
+		const sdkSpy = vi.spyOn(sdkCore, "fetchClineRecommendedModels").mockResolvedValue(sdkResult)
+
+		const result = await refreshClineRecommendedModels()
+
+		expect(sdkSpy).toHaveBeenCalledTimes(1)
+		expect(result).toEqual(sdkResult)
+	})
+
+	it("uses the in-memory cache after a populated upstream result", async () => {
+		const sdkResult = {
+			recommended: [{ id: "google/gemini-3.1-pro-preview", name: "Gemini 3.1 Pro", description: "Remote", tags: ["NEW"] }],
+			free: [],
+			clinePass: [],
+		}
+		const sdkSpy = vi.spyOn(sdkCore, "fetchClineRecommendedModels").mockResolvedValue(sdkResult)
+
+		const firstResult = await refreshClineRecommendedModels()
+		const secondResult = await refreshClineRecommendedModels()
+
+		expect(sdkSpy).toHaveBeenCalledTimes(1)
+		expect(secondResult).toEqual(firstResult)
+	})
+
+	it("does not cache the SDK fallback result", async () => {
+		const sdkFallbackClone = structuredClone(sdkCore.FALLBACK_CLINE_RECOMMENDED_MODELS)
+		const sdkSpy = vi
+			.spyOn(sdkCore, "fetchClineRecommendedModels")
+			.mockResolvedValueOnce(sdkFallbackClone)
+			.mockResolvedValueOnce({
+				recommended: [
+					{ id: "anthropic/claude-sonnet-4.6", name: "Claude Sonnet 4.6", description: "Remote", tags: ["NEW"] },
+				],
+				free: [],
+				clinePass: [],
+			})
+
+		const firstResult = await refreshClineRecommendedModels()
+		const secondResult = await refreshClineRecommendedModels()
+
+		expect(sdkSpy).toHaveBeenCalledTimes(2)
+		expect(firstResult).toEqual(sdkCore.FALLBACK_CLINE_RECOMMENDED_MODELS)
+		expect(secondResult).not.toEqual(sdkCore.FALLBACK_CLINE_RECOMMENDED_MODELS)
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/__tests__/refreshGroqModels.test.ts b/apps/vscode/src/core/controller/models/__tests__/refreshGroqModels.test.ts
new file mode 100644
index 0000000..fbad592
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/refreshGroqModels.test.ts
@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { refreshGroqModels } from "../refreshGroqModels"
+
+const mocks = vi.hoisted(() => ({
+	axiosGet: vi.fn(),
+	captureProviderApiError: vi.fn(),
+	getModelsCache: vi.fn(),
+	getProviderCollectionSync: vi.fn(),
+	getSecretKey: vi.fn(),
+	setModelsCache: vi.fn(),
+	writeFile: vi.fn(),
+}))
+
+vi.mock("@cline/llms", () => ({
+	getProviderCollectionSync: mocks.getProviderCollectionSync,
+}))
+
+vi.mock("@core/storage/disk", () => ({
+	GlobalFileNames: {
+		groqModels: "groq_models.json",
+	},
+	ensureCacheDirectoryExists: vi.fn(async () => "/tmp/cline-cache"),
+}))
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: {
+		get: () => ({
+			getModelsCache: mocks.getModelsCache,
+			setModelsCache: mocks.setModelsCache,
+		}),
+	},
+}))
+
+vi.mock("@/services/telemetry", () => ({
+	telemetryService: {
+		captureProviderApiError: mocks.captureProviderApiError,
+	},
+}))
+
+vi.mock("@/shared/net", () => ({
+	getAxiosSettings: () => ({}),
+}))
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+	},
+}))
+
+vi.mock("@utils/fs", () => ({
+	fileExistsAtPath: vi.fn(async () => false),
+}))
+
+vi.mock("axios", () => ({
+	default: {
+		get: mocks.axiosGet,
+		isAxiosError: vi.fn(() => false),
+	},
+}))
+
+vi.mock("fs/promises", () => ({
+	default: {
+		readFile: vi.fn(),
+		writeFile: mocks.writeFile,
+	},
+}))
+
+describe("refreshGroqModels", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mocks.getModelsCache.mockReturnValue(null)
+		mocks.getProviderCollectionSync.mockReturnValue({ models: {} })
+		mocks.getSecretKey.mockReturnValue("gsk_test_key")
+		mocks.axiosGet.mockResolvedValue({
+			data: {
+				data: [
+					{
+						id: "groq-new-chat-model",
+						object: "model",
+						active: true,
+						max_completion_tokens: 4096,
+						context_window: 8192,
+						owned_by: "Groq",
+					},
+				],
+			},
+		})
+	})
+
+	it("defaults cache pricing for live models missing SDK catalog metadata", async () => {
+		const controller = {
+			stateManager: {
+				getSecretKey: mocks.getSecretKey,
+			},
+			task: {
+				ulid: "task-1",
+			},
+		} as unknown as Parameters<typeof refreshGroqModels>[0]
+
+		const models = await refreshGroqModels(controller)
+
+		expect(models["groq-new-chat-model"]).toMatchObject({
+			maxTokens: 4096,
+			contextWindow: 8192,
+			cacheWritesPrice: 0,
+			cacheReadsPrice: 0,
+			description: "Groq model with 8,192 token context window",
+		})
+		expect(mocks.captureProviderApiError).not.toHaveBeenCalled()
+		expect(mocks.setModelsCache).toHaveBeenCalledWith("groq", expect.objectContaining(models))
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/__tests__/resolveModelInfo.test.ts b/apps/vscode/src/core/controller/models/__tests__/resolveModelInfo.test.ts
new file mode 100644
index 0000000..2b95fbd
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/__tests__/resolveModelInfo.test.ts
@@ -0,0 +1,294 @@
+import { describe, expect, it, vi } from "vitest"
+import type {
+	EffectiveProviderConfig,
+	ModelInfo,
+	ProviderCatalog,
+	ProviderConfigStore,
+	ProviderId,
+	ProviderModelsResult,
+} from "@/sdk/model-catalog/contracts"
+import { computeConfigFingerprint } from "@/sdk/model-catalog/fingerprint"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import type { ProviderCatalogController } from "../providerCatalogShared"
+
+function fingerprint(providerId: ProviderId): ReturnType<typeof computeConfigFingerprint> {
+	return computeConfigFingerprint(providerId, { providerId })
+}
+
+function makeStore(config: EffectiveProviderConfig): ProviderConfigStore {
+	return {
+		read: vi.fn(() => config),
+		readSelection: vi.fn(() => undefined),
+		subscribe: vi.fn(() => ({ dispose: vi.fn() })),
+		write: vi.fn(() => config),
+		commitSelection: vi.fn(),
+	}
+}
+
+function makeCatalog(): ProviderCatalog {
+	return {
+		listProviders: vi.fn(async () => []),
+		invalidateProviderListings: vi.fn(),
+		resolveModels: vi.fn(async (providerId) => ({
+			ok: true as const,
+			providerId,
+			configFingerprint: fingerprint(providerId),
+			models: new Map<string, ModelInfo>(),
+			defaultModelId: "",
+			source: "sdk-dynamic" as const,
+			fetchedAt: 0,
+		})),
+		peekModels: vi.fn(() => undefined),
+		subscribe: vi.fn(() => ({ dispose: vi.fn() })),
+	}
+}
+
+function makeController(store: ProviderConfigStore, catalog: ProviderCatalog): ProviderCatalogController {
+	return {
+		getProviderConfigStore: () => store,
+		getProviderCatalog: () => catalog,
+	}
+}
+
+function peekResult(providerId: string, entries: Array<[string, ModelInfo]>, defaultModelId: string): ProviderModelsResult {
+	return {
+		ok: true,
+		providerId: parseProviderId(providerId),
+		configFingerprint: fingerprint(parseProviderId(providerId)),
+		models: new Map(entries),
+		defaultModelId,
+		source: "sdk-dynamic" as const,
+		fetchedAt: 0,
+	}
+}
+
+describe("resolveModelInfo", () => {
+	it("returns committed-selection source when a matching selection exists", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const providerId = parseProviderId("deepseek")
+		const store = makeStore({ providerId })
+		vi.mocked(store.readSelection).mockImplementation((_, mode) =>
+			mode === "act"
+				? {
+						providerId,
+						modelId: "deepseek-v4-pro",
+						modelInfo: { name: "Committed Pro", supportsPromptCache: true, contextWindow: 999_999 },
+					}
+				: undefined,
+		)
+		const catalog = makeCatalog()
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "deepseek",
+			modelId: "deepseek-v4-pro",
+		})
+
+		expect(response.source).toBe("committed-selection")
+		expect(response.modelId).toBe("deepseek-v4-pro")
+		expect(response.modelInfo?.contextWindow).toBe(999_999)
+		expect(catalog.peekModels).not.toHaveBeenCalled()
+		expect(catalog.resolveModels).not.toHaveBeenCalled()
+	})
+
+	it("returns sdk-known-models from a populated catalog peek", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("deepseek") })
+		const catalog = makeCatalog()
+		vi.mocked(catalog.peekModels).mockReturnValue(
+			peekResult(
+				"deepseek",
+				[
+					["deepseek-v4-pro", { name: "DeepSeek V4 Pro", supportsPromptCache: false, contextWindow: 1_000_000 }],
+					["deepseek-v4-flash", { name: "DeepSeek V4 Flash", supportsPromptCache: false, contextWindow: 1_000_000 }],
+				],
+				"deepseek-v4-flash",
+			),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "deepseek",
+			modelId: "deepseek-v4-pro",
+		})
+
+		expect(response.source).toBe("sdk-known-models")
+		expect(response.modelId).toBe("deepseek-v4-pro")
+		expect(response.modelInfo?.contextWindow).toBe(1_000_000)
+		expect(catalog.resolveModels).not.toHaveBeenCalled()
+	})
+
+	it("returns sdk-default when the requested id is missing but the catalog has a default", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("deepseek") })
+		const catalog = makeCatalog()
+		vi.mocked(catalog.peekModels).mockReturnValue(
+			peekResult(
+				"deepseek",
+				[["deepseek-v4-flash", { name: "DeepSeek V4 Flash", supportsPromptCache: false, contextWindow: 1_000_000 }]],
+				"deepseek-v4-flash",
+			),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "deepseek",
+			modelId: "claude-sonnet-4-5-20250929",
+		})
+
+		expect(response.source).toBe("sdk-default")
+		expect(response.modelId).toBe("deepseek-v4-flash")
+		expect(response.modelInfo?.contextWindow).toBe(1_000_000)
+		expect(catalog.resolveModels).not.toHaveBeenCalled()
+	})
+
+	it("returns sdk-default when the request omits a model id and the catalog has a default", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("deepseek") })
+		const catalog = makeCatalog()
+		vi.mocked(catalog.peekModels).mockReturnValue(
+			peekResult(
+				"deepseek",
+				[["deepseek-v4-flash", { name: "DeepSeek V4 Flash", supportsPromptCache: false, contextWindow: 1_000_000 }]],
+				"deepseek-v4-flash",
+			),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "deepseek",
+		})
+
+		expect(response.source).toBe("sdk-default")
+		expect(response.modelId).toBe("deepseek-v4-flash")
+		expect(response.modelInfo?.contextWindow).toBe(1_000_000)
+	})
+
+	it("awaits the catalog when the peek is empty and surfaces the resolved info", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("deepseek") })
+		const catalog = makeCatalog()
+		// peek returns undefined (default). resolveModels returns a
+		// populated catalog. The handler should await resolveModels and
+		// pick from its result rather than returning unknown.
+		vi.mocked(catalog.resolveModels).mockResolvedValue(
+			peekResult(
+				"deepseek",
+				[["deepseek-v4-pro", { name: "DeepSeek V4 Pro", supportsPromptCache: false, contextWindow: 1_000_000 }]],
+				"deepseek-v4-pro",
+			),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "deepseek",
+			modelId: "deepseek-v4-pro",
+		})
+
+		expect(response.source).toBe("sdk-known-models")
+		expect(response.modelId).toBe("deepseek-v4-pro")
+		expect(response.modelInfo?.contextWindow).toBe(1_000_000)
+		expect(catalog.resolveModels).toHaveBeenCalledTimes(1)
+	})
+
+	it("returns unknown when both the peek and resolveModels yield nothing", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("deepseek") })
+		const catalog = makeCatalog()
+		// Default peek mock returns undefined; default resolveModels mock
+		// returns an empty catalog with no default model.
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "deepseek",
+			modelId: "deepseek-v4-pro",
+		})
+
+		expect(response).toMatchObject({
+			providerId: "deepseek",
+			modelId: "deepseek-v4-pro",
+			source: "unknown",
+		})
+		expect(response.modelInfo).toBeUndefined()
+		expect(catalog.resolveModels).toHaveBeenCalledTimes(1)
+	})
+
+	it("does not coerce a custom OpenAI Compatible model id to the catalog default", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("openai") })
+		const catalog = makeCatalog()
+		// The openai-compatible catalog only knows gpt-4o. A user-entered custom
+		// model id must NOT be replaced with that default — the requested id is
+		// authoritative for custom-model-id providers.
+		vi.mocked(catalog.peekModels).mockReturnValue(
+			peekResult("openai", [["gpt-4o", { name: "GPT-4o", supportsPromptCache: false, contextWindow: 128_000 }]], "gpt-4o"),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "openai",
+			modelId: "my-custom-model-xyz",
+		})
+
+		expect(response.modelId).toBe("my-custom-model-xyz")
+		expect(response.source).toBe("unknown")
+		expect(response.modelInfo).toBeUndefined()
+	})
+
+	it("resolves a free model id from the cline-pass catalog without coercing to the default", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("cline-pass") })
+		const catalog = makeCatalog()
+		// The cline-pass catalog carries the endpoint's clinePass bucket plus the
+		// Cline free models (zero-priced, OpenRouter-style ids without the
+		// cline-pass/ prefix). Selecting a free model must not be replaced by the
+		// default pass model.
+		vi.mocked(catalog.peekModels).mockReturnValue(
+			peekResult(
+				"cline-pass",
+				[
+					["cline-pass/glm-5.1", { name: "GLM 5.1", supportsPromptCache: false, contextWindow: 200_000 }],
+					["kwaipilot/kat-coder-pro", { name: "KAT Coder Pro", supportsPromptCache: false, contextWindow: 256_000 }],
+				],
+				"cline-pass/glm-5.1",
+			),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "cline-pass",
+			modelId: "kwaipilot/kat-coder-pro",
+		})
+
+		expect(response.modelId).toBe("kwaipilot/kat-coder-pro")
+		expect(response.source).toBe("sdk-known-models")
+	})
+
+	it("still honors a custom-provider model id that does match the catalog", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("openai") })
+		const catalog = makeCatalog()
+		vi.mocked(catalog.peekModels).mockReturnValue(
+			peekResult("openai", [["gpt-4o", { name: "GPT-4o", supportsPromptCache: false, contextWindow: 128_000 }]], "gpt-4o"),
+		)
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "openai",
+			modelId: "gpt-4o",
+		})
+
+		expect(response.source).toBe("sdk-known-models")
+		expect(response.modelId).toBe("gpt-4o")
+		expect(response.modelInfo?.contextWindow).toBe(128_000)
+	})
+
+	it("returns unknown for an unknown provider without throwing", async () => {
+		const { resolveModelInfo } = await import("../resolveModelInfo")
+		const store = makeStore({ providerId: parseProviderId("not-real-provider") })
+		const catalog = makeCatalog()
+
+		const response = await resolveModelInfo(makeController(store, catalog), {
+			providerId: "not-real-provider",
+			modelId: "whatever",
+		})
+
+		expect(response).toMatchObject({
+			providerId: "not-real-provider",
+			modelId: "whatever",
+			source: "unknown",
+		})
+		expect(response.modelInfo).toBeUndefined()
+	})
+})
diff --git a/apps/vscode/src/core/controller/models/commitModelSelection.ts b/apps/vscode/src/core/controller/models/commitModelSelection.ts
new file mode 100644
index 0000000..26be87e
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/commitModelSelection.ts
@@ -0,0 +1,38 @@
+import { toLegacyApiProvider } from "@/shared/model-catalog/provider-helpers"
+import { Empty } from "@/shared/proto/cline/common"
+import { CommitModelSelectionRequest } from "@/shared/proto/cline/models"
+import { getProviderModelIdKey } from "@/shared/storage/provider-keys"
+import {
+	hasProviderCatalogStateController,
+	type ProviderCatalogController,
+	parseModeRequest,
+	parseProviderIdRequest,
+	toModelSelection,
+} from "./providerCatalogShared"
+
+export async function commitModelSelection(
+	controller: ProviderCatalogController,
+	request: CommitModelSelectionRequest,
+): Promise<Empty> {
+	const providerId = parseProviderIdRequest(request.providerId)
+	const mode = parseModeRequest(request.mode)
+	const selection = toModelSelection(request, providerId)
+	const previousApiConfiguration = hasProviderCatalogStateController(controller)
+		? controller.stateManager.getApiConfiguration?.()
+		: undefined
+	controller.getProviderConfigStore().commitSelection(providerId, mode, selection)
+
+	if (hasProviderCatalogStateController(controller)) {
+		controller.stateManager.setGlobalStateBatch({
+			[`${mode}ModeApiProvider`]: providerId,
+			[getProviderModelIdKey(toLegacyApiProvider(providerId.toString()), mode)]: selection.modelId,
+		})
+		await controller.stateManager.flushPendingState?.()
+		const nextApiConfiguration = controller.stateManager.getApiConfiguration?.()
+		if (nextApiConfiguration) {
+			controller.handleApiConfigurationChanged?.(previousApiConfiguration ?? {}, nextApiConfiguration)
+		}
+	}
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/models/getAihubmixModels.ts b/apps/vscode/src/core/controller/models/getAihubmixModels.ts
new file mode 100644
index 0000000..06e65f8
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/getAihubmixModels.ts
@@ -0,0 +1,74 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import axios from "axios"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Fetches available models from AIhubmix
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing the AIhubmix models
+ */
+export async function getAihubmixModels(_controller: Controller, _request: EmptyRequest): Promise<OpenRouterCompatibleModelInfo> {
+	try {
+		const response = await axios.get("https://aihubmix.com/call/mdl_info_platform?tag=coding", getAxiosSettings())
+
+		if (!response.data?.success || !Array.isArray(response.data?.data)) {
+			Logger.error("Invalid response from AIhubmix API:", response.data)
+			return OpenRouterCompatibleModelInfo.create({ models: {} })
+		}
+		// 原始数据为数组，不能直接复用为 map；需构造独立的 modelsMap
+		const modelsArray = response.data.data as any[]
+		const modelsMap: Record<string, OpenRouterModelInfo> = {}
+
+		for (const modelData of modelsArray) {
+			if (!modelData.model || typeof modelData.model !== "string") {
+				continue
+			}
+
+			// 检查是否支持图像
+			const supportsImages =
+				modelData.modalities?.includes("vision") ||
+				modelData.modalities?.includes("image") ||
+				modelData.features?.includes("vision") ||
+				false
+
+			// 检查是否支持思维链
+			const supportsThinking = modelData.features?.includes("thinking") || false
+
+			// 检查是否支持缓存：cache_ratio 非1 或 读价与输入价不同
+			const pricing = modelData.pricing || {}
+			const supportsPromptCache =
+				(modelData.cache_ratio !== undefined && modelData.cache_ratio !== 1) ||
+				(pricing.cache_read !== undefined && pricing.input !== undefined && pricing.cache_read !== pricing.input)
+
+			const modelId = modelData.model
+			modelsMap[modelId] = OpenRouterModelInfo.create({
+				maxTokens: modelData.max_output ?? 8192,
+				contextWindow: modelData.context_window ?? 128000,
+				supportsImages: supportsImages,
+				supportsPromptCache: supportsPromptCache,
+				inputPrice: pricing.input ?? 0,
+				outputPrice: pricing.output ?? 0,
+				cacheWritesPrice: pricing.cache_write ?? 0,
+				cacheReadsPrice: pricing.cache_read ?? 0,
+				description: modelData.desc_en || modelData.desc || "",
+				thinkingConfig: supportsThinking
+					? modelData.thinking_config
+						? modelData.thinking_config
+						: undefined
+					: undefined,
+				supportsGlobalEndpoint: modelData.supports_global_endpoint ?? undefined,
+				tiers: [],
+			})
+		}
+
+		Logger.log(`Fetched ${Object.keys(modelsMap).length} AIhubmix models`)
+		return OpenRouterCompatibleModelInfo.create({ models: modelsMap })
+	} catch (error) {
+		Logger.error("Failed to fetch AIhubmix models:", error)
+		return OpenRouterCompatibleModelInfo.create({ models: {} })
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/getClineOnboardingModels.ts b/apps/vscode/src/core/controller/models/getClineOnboardingModels.ts
new file mode 100644
index 0000000..7d6d691
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/getClineOnboardingModels.ts
@@ -0,0 +1,64 @@
+import { featureFlagsService } from "@/services/feature-flags"
+import { CLINE_ONBOARDING_MODELS } from "@/shared/cline/onboarding"
+import { OnboardingModel, OnboardingModelGroup } from "@/shared/proto/cline/state"
+
+type OnboardingModelOverride = OnboardingModel & { hidden?: boolean }
+
+let cached: OnboardingModelGroup | null = null
+
+export function getClineOnboardingModels(): OnboardingModelGroup {
+	if (cached) {
+		return cached
+	}
+
+	const remoteOverrides = featureFlagsService.getOnboardingOverrides()
+	const models = [...CLINE_ONBOARDING_MODELS]
+
+	// Apply remote overrides if available
+	if (remoteOverrides) {
+		for (const [id, override] of Object.entries(remoteOverrides) as [string, OnboardingModelOverride][]) {
+			if (override.hidden) {
+				for (let i = models.length - 1; i >= 0; i--) {
+					if (models[i].id === id) {
+						models.splice(i, 1)
+					}
+				}
+			} else {
+				let found = false
+				for (let i = 0; i < models.length; i++) {
+					if (models[i].id === id) {
+						models[i] = mergeModelWithOverride(models[i], override)
+						found = true
+					}
+				}
+
+				if (!found) {
+					models.push(mergeModelWithOverride(undefined, override))
+				}
+			}
+		}
+	}
+
+	cached = { models }
+	return cached
+}
+
+function mergeModelWithOverride(baseModel: OnboardingModel | undefined, override: OnboardingModelOverride): OnboardingModel {
+	const baseInfo = baseModel?.info
+	const overrideInfo = override.info
+
+	// Merge info with proper defaults
+	const mergedInfo = {
+		...baseInfo,
+		...overrideInfo,
+		supportsPromptCache: overrideInfo?.supportsPromptCache ?? baseInfo?.supportsPromptCache ?? false,
+		tiers: overrideInfo?.tiers ?? baseInfo?.tiers ?? [],
+	}
+
+	// Return merged model, using base as foundation if available
+	return baseModel ? { ...baseModel, ...override, info: mergedInfo } : { ...override, info: mergedInfo }
+}
+
+export function clearOnboardingModelsCache(): void {
+	cached = null
+}
diff --git a/apps/vscode/src/core/controller/models/getLmStudioModels.ts b/apps/vscode/src/core/controller/models/getLmStudioModels.ts
new file mode 100644
index 0000000..a64039a
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/getLmStudioModels.ts
@@ -0,0 +1,29 @@
+import { StringArray, type StringRequest } from "@shared/proto/cline/common"
+import { fetch } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from ".."
+
+/**
+ * Fetches available models from LM Studio
+ * @param controller The controller instance
+ * @param request The request containing the base URL (optional)
+ * @returns Array of model names
+ */
+export async function getLmStudioModels(_controller: Controller, request: StringRequest): Promise<StringArray> {
+	try {
+		const baseUrl = request.value || "http://localhost:1234"
+		if (!URL.canParse(baseUrl)) {
+			return StringArray.create({ values: [] })
+		}
+		const endpoint = new URL("api/v0/models", baseUrl)
+
+		const response = await fetch(endpoint.href)
+		const data = await response.json()
+		const models = data?.data?.map((m: unknown) => JSON.stringify(m)) || []
+
+		return StringArray.create({ values: models })
+	} catch (error) {
+		Logger.error("Failed to fetch LM Studio models:", error)
+		return StringArray.create({ values: [] })
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/getOllamaModels.ts b/apps/vscode/src/core/controller/models/getOllamaModels.ts
new file mode 100644
index 0000000..ee015d6
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/getOllamaModels.ts
@@ -0,0 +1,28 @@
+import { StringArray, StringRequest } from "@shared/proto/cline/common"
+import axios from "axios"
+import { getAxiosSettings } from "@/shared/net"
+import { Controller } from ".."
+
+/**
+ * Fetches available models from Ollama
+ * @param controller The controller instance
+ * @param request The request containing the base URL (optional)
+ * @returns Array of model names
+ */
+export async function getOllamaModels(_controller: Controller, request: StringRequest): Promise<StringArray> {
+	try {
+		const baseUrl = request.value || "http://localhost:11434"
+
+		if (!URL.canParse(baseUrl)) {
+			return StringArray.create({ values: [] })
+		}
+
+		const response = await axios.get(`${baseUrl}/api/tags`, getAxiosSettings())
+		const modelsArray = response.data?.models?.map((model: any) => model.name) || []
+		const models = [...new Set<string>(modelsArray)].sort()
+
+		return StringArray.create({ values: models })
+	} catch (_error) {
+		return StringArray.create({ values: [] })
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/getSapAiCoreModels.ts b/apps/vscode/src/core/controller/models/getSapAiCoreModels.ts
new file mode 100644
index 0000000..8676248
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/getSapAiCoreModels.ts
@@ -0,0 +1,151 @@
+import axios from "axios"
+import { getAxiosSettings } from "@/shared/net"
+import { SapAiCoreModelDeployment, SapAiCoreModelsRequest, SapAiCoreModelsResponse } from "@/shared/proto/cline/models"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+interface Token {
+	access_token: string
+	expires_in: number
+	scope: string
+	jti: string
+	token_type: string
+	expires_at: number
+}
+
+interface Deployment {
+	id: string
+	name: string
+}
+
+/**
+ * Authenticates with SAP AI Core and returns an access token
+ * @param clientId SAP AI Core client ID
+ * @param clientSecret SAP AI Core client secret
+ * @param tokenUrl SAP AI Core token URL
+ * @returns Promise<Token> Access token with metadata
+ */
+async function getToken(clientId: string, clientSecret: string, tokenUrl: string): Promise<Token> {
+	const payload = new URLSearchParams({
+		grant_type: "client_credentials",
+		client_id: clientId,
+		client_secret: clientSecret,
+	})
+
+	const url = tokenUrl.replace(/\/+$/, "") + "/oauth/token"
+	const response = await axios.post(url, payload, {
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		...getAxiosSettings(),
+	})
+	const token = response.data as Token
+	token.expires_at = Date.now() + token.expires_in * 1000
+	return token
+}
+
+/**
+ * Fetches deployments and orchestration availability from SAP AI Core deployments
+ * @param accessToken Access token for authentication
+ * @param baseUrl SAP AI Core base URL
+ * @param resourceGroup SAP AI Core resource group
+ * @returns Promise<{deployments: Deployment[], orchestrationAvailable: boolean}> Deployments and orchestration availability
+ */
+async function fetchAiCoreDeploymentsAndOrchestration(
+	accessToken: string,
+	baseUrl: string,
+	resourceGroup: string,
+): Promise<{ deployments: Deployment[]; orchestrationAvailable: boolean }> {
+	if (!accessToken) {
+		return { deployments: [], orchestrationAvailable: false }
+	}
+
+	const headers = {
+		Authorization: `Bearer ${accessToken}`,
+		"AI-Resource-Group": resourceGroup || "default",
+		"Content-Type": "application/json",
+		"AI-Client-Type": "Cline",
+	}
+
+	const url = `${baseUrl}/v2/lm/deployments?$top=10000&$skip=0`
+
+	try {
+		const response = await axios.get(url, { headers, ...getAxiosSettings() })
+		const allDeployments = response.data.resources
+
+		// Filter running deployments
+		const runningDeployments = allDeployments.filter((deployment: any) => deployment.targetStatus === "RUNNING")
+
+		// Check for orchestration deployment
+		const orchestrationAvailable = runningDeployments.some((deployment: any) => deployment.scenarioId === "orchestration")
+
+		// Extract deployments with model names and IDs
+		const deployments = runningDeployments
+			.map((deployment: any) => {
+				const model = deployment.details?.resources?.backend_details?.model
+				if (!model?.name || !model?.version) {
+					return null // Skip this row
+				}
+				return {
+					id: deployment.id,
+					name: `${model.name}:${model.version}`,
+				}
+			})
+			.filter((deployment: any) => deployment !== null)
+
+		return { deployments, orchestrationAvailable }
+	} catch (error) {
+		Logger.error("Error fetching deployments:", error)
+		throw new Error("Failed to fetch deployments")
+	}
+}
+
+/**
+ * Fetches available models from SAP AI Core deployments and orchestration availability
+ * @param controller The controller instance
+ * @param request The request containing SAP AI Core configuration
+ * @returns SapAiCoreModelsResponse with deployments and orchestration availability
+ */
+export async function getSapAiCoreModels(
+	controller: Controller,
+	request: SapAiCoreModelsRequest,
+): Promise<SapAiCoreModelsResponse> {
+	try {
+		// Check if required configuration is provided
+		if (!request.clientId || !request.clientSecret || !request.baseUrl) {
+			// Return empty response if configuration is incomplete
+			return SapAiCoreModelsResponse.create({
+				deployments: [],
+				orchestrationAvailable: false,
+			})
+		}
+
+		// Direct authentication and deployment/orchestration fetching
+		const token = await getToken(request.clientId, request.clientSecret, request.tokenUrl)
+		const { deployments, orchestrationAvailable } = await fetchAiCoreDeploymentsAndOrchestration(
+			token.access_token,
+			request.baseUrl,
+			request.resourceGroup,
+		)
+
+		// Create model-deployment pairs
+		const modelDeployments = deployments
+			.map((deployment) => {
+				const modelName = deployment.name.split(":")[0].toLowerCase()
+				return SapAiCoreModelDeployment.create({
+					modelName: modelName,
+					deploymentId: deployment.id,
+				})
+			})
+			.sort((a, b) => a.modelName.localeCompare(b.modelName))
+
+		return SapAiCoreModelsResponse.create({
+			deployments: modelDeployments,
+			orchestrationAvailable,
+		})
+	} catch (error) {
+		Logger.error("Error fetching SAP AI Core models:", error)
+		return SapAiCoreModelsResponse.create({
+			deployments: [],
+			orchestrationAvailable: false,
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/getVsCodeLmModels.ts b/apps/vscode/src/core/controller/models/getVsCodeLmModels.ts
new file mode 100644
index 0000000..78eb9ce
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/getVsCodeLmModels.ts
@@ -0,0 +1,25 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { VsCodeLmModelsArray } from "@shared/proto/cline/models"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { convertVsCodeNativeModelsToProtoModels } from "../../../shared/proto-conversions/models/vscode-lm-models-conversion"
+import { Controller } from ".."
+
+/**
+ * Fetches available models from VS Code LM API
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns Array of VS Code LM models
+ */
+export async function getVsCodeLmModels(_controller: Controller, _request: EmptyRequest): Promise<VsCodeLmModelsArray> {
+	try {
+		const models = await vscode.lm.selectChatModels({})
+
+		const protoModels = convertVsCodeNativeModelsToProtoModels(models || [])
+
+		return VsCodeLmModelsArray.create({ models: protoModels })
+	} catch (error) {
+		Logger.error("Error fetching VS Code LM models:", error)
+		return VsCodeLmModelsArray.create({ models: [] })
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/handleClinePassProviderSelection.ts b/apps/vscode/src/core/controller/models/handleClinePassProviderSelection.ts
new file mode 100644
index 0000000..71feeef
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/handleClinePassProviderSelection.ts
@@ -0,0 +1,29 @@
+import type { ApiConfiguration } from "@shared/api"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+export const CLINE_PASS_PROVIDER_ID = "cline-pass"
+
+/**
+ * ClinePass always uses the user's personal Cline account balance.
+ *
+ * This is intentionally best-effort: selecting the provider should still be
+ * saved even if the account switch fails.
+ */
+export async function clearOrganizationForClinePassProviderSelection(
+	controller: Controller,
+	apiConfiguration: Pick<ApiConfiguration, "planModeApiProvider" | "actModeApiProvider">,
+): Promise<void> {
+	if (
+		apiConfiguration.planModeApiProvider !== CLINE_PASS_PROVIDER_ID &&
+		apiConfiguration.actModeApiProvider !== CLINE_PASS_PROVIDER_ID
+	) {
+		return
+	}
+
+	try {
+		await controller.accountService.switchAccount(undefined)
+	} catch (error) {
+		Logger.debug("Failed to switch ClinePass to personal account", { error })
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/listProviders.ts b/apps/vscode/src/core/controller/models/listProviders.ts
new file mode 100644
index 0000000..c8a40f4
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/listProviders.ts
@@ -0,0 +1,10 @@
+import { Empty } from "@/shared/proto/cline/common"
+import { ProviderListingsResponse } from "@/shared/proto/cline/models"
+import { type ProviderCatalogController, toProviderListingProto } from "./providerCatalogShared"
+
+export async function listProviders(controller: ProviderCatalogController, _request: Empty): Promise<ProviderListingsResponse> {
+	const providers = await controller.getProviderCatalog().listProviders()
+	return ProviderListingsResponse.create({
+		providers: providers.map(toProviderListingProto),
+	})
+}
diff --git a/apps/vscode/src/core/controller/models/providerCatalogShared.ts b/apps/vscode/src/core/controller/models/providerCatalogShared.ts
new file mode 100644
index 0000000..9582d3d
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/providerCatalogShared.ts
@@ -0,0 +1,257 @@
+import type { ApiConfiguration, ModelInfo } from "@shared/api"
+import type {
+	EffectiveProviderConfig,
+	Mode,
+	ModelSelection,
+	ProviderCatalog,
+	ProviderConfigPatch,
+	ProviderConfigStore,
+	ProviderId,
+	ProviderListing,
+	ProviderModelsResult,
+} from "@/sdk/model-catalog/contracts"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import {
+	AwsProviderConfig,
+	CatalogErrorInfo,
+	CommitModelSelectionRequest,
+	CommittedModelSelection,
+	GcpProviderConfig,
+	OpenRouterModelInfo,
+	ProviderConfigResponse,
+	ProviderListing as ProviderListingProto,
+	ProviderModelsResponse,
+	WriteProviderConfigPatch,
+} from "@/shared/proto/cline/models"
+import { fromProtobufModelInfo, toProtobufModelInfo } from "@/shared/proto-conversions/models/typeConversion"
+import type { GlobalStateAndSettings } from "@/shared/storage/state-keys"
+
+export interface ProviderCatalogController {
+	getProviderConfigStore(): ProviderConfigStore
+	getProviderCatalog(): ProviderCatalog
+}
+
+export interface ProviderCatalogStateController extends ProviderCatalogController {
+	stateManager: {
+		setGlobalStateBatch(updates: Partial<GlobalStateAndSettings>): void
+		flushPendingState?(): Promise<void>
+		getApiConfiguration?(): ApiConfiguration
+	}
+	handleApiConfigurationChanged?(previous: ApiConfiguration, next: ApiConfiguration): void
+}
+
+export function hasProviderCatalogStateController(
+	controller: ProviderCatalogController,
+): controller is ProviderCatalogStateController {
+	const candidate = controller as { stateManager?: { setGlobalStateBatch?: unknown } }
+	return typeof candidate.stateManager?.setGlobalStateBatch === "function"
+}
+
+export function parseProviderIdRequest(rawProviderId: string | undefined, fieldName = "provider_id"): ProviderId {
+	const providerId = rawProviderId?.trim()
+	if (!providerId) {
+		throw new Error(`${fieldName} is required`)
+	}
+	return parseProviderId(providerId)
+}
+
+export function parseModeRequest(rawMode: string | undefined): Mode {
+	if (rawMode === "plan" || rawMode === "act") {
+		return rawMode
+	}
+	throw new Error('mode must be "plan" or "act"')
+}
+
+export function toProviderListingProto(listing: ProviderListing): ProviderListingProto {
+	return ProviderListingProto.create({
+		id: listing.id,
+		name: listing.name,
+		defaultModelId: listing.defaultModelId,
+		family: listing.family,
+		protocol: listing.protocol,
+		authDescription: listing.authDescription,
+		baseUrlDescription: listing.baseUrlDescription,
+		allowsCustomModelIds: listing.allowsCustomModelIds,
+		usageCostDisplay: listing.usageCostDisplay,
+	})
+}
+
+type ProviderModelsError = Extract<ProviderModelsResult, { ok: false }>["error"]
+
+function toCatalogErrorInfo(error: ProviderModelsError): CatalogErrorInfo {
+	return CatalogErrorInfo.create({
+		kind: error.kind,
+		message: error.message,
+		code: error.code,
+	})
+}
+
+function toProtobufModels(models: ReadonlyMap<string, ModelInfo>): Record<string, OpenRouterModelInfo> {
+	const result: Record<string, OpenRouterModelInfo> = {}
+	for (const [modelId, modelInfo] of models) {
+		result[modelId] = toProtobufModelInfo(modelInfo)
+	}
+	return result
+}
+
+function toCommittedModelSelectionProto(selection: ModelSelection | undefined): CommittedModelSelection | undefined {
+	if (!selection) {
+		return undefined
+	}
+	return CommittedModelSelection.create({
+		providerId: selection.providerId,
+		modelId: selection.modelId,
+		modelInfo: toProtobufModelInfo(selection.modelInfo),
+	})
+}
+
+function toRedactedAwsProviderConfigProto(aws: EffectiveProviderConfig["aws"]): AwsProviderConfig | undefined {
+	if (!aws) {
+		return undefined
+	}
+	return AwsProviderConfig.create({
+		authentication: aws.authentication,
+		profile: aws.profile,
+		accessKeyLength: aws.accessKey?.length ?? 0,
+		secretKeyLength: aws.secretKey?.length ?? 0,
+		sessionTokenLength: aws.sessionToken?.length ?? 0,
+		endpoint: aws.endpoint,
+		usePromptCache: aws.usePromptCache,
+		customModelBaseId: aws.customModelBaseId,
+		useCrossRegionInference: aws.useCrossRegionInference,
+		useGlobalInference: aws.useGlobalInference,
+	})
+}
+
+function toGcpProviderConfigPatch(protoPatch: WriteProviderConfigPatch): ProviderConfigPatch["gcp"] {
+	if (!protoPatch.gcp) {
+		return undefined
+	}
+	return {
+		...(protoPatch.gcp.projectId !== undefined ? { projectId: protoPatch.gcp.projectId } : {}),
+		...(protoPatch.gcp.region !== undefined ? { region: protoPatch.gcp.region } : {}),
+	}
+}
+
+function toRedactedGcpProviderConfigProto(gcp: EffectiveProviderConfig["gcp"]): GcpProviderConfig | undefined {
+	if (!gcp) {
+		return undefined
+	}
+	return GcpProviderConfig.create({
+		projectId: gcp.projectId,
+		region: gcp.region,
+	})
+}
+
+function toAwsProviderConfigPatch(protoPatch: WriteProviderConfigPatch): ProviderConfigPatch["aws"] {
+	if (!protoPatch.aws) {
+		return undefined
+	}
+	return {
+		...(protoPatch.aws.accessKey !== undefined ? { accessKey: protoPatch.aws.accessKey } : {}),
+		...(protoPatch.aws.secretKey !== undefined ? { secretKey: protoPatch.aws.secretKey } : {}),
+		...(protoPatch.aws.sessionToken !== undefined ? { sessionToken: protoPatch.aws.sessionToken } : {}),
+		...(protoPatch.aws.authentication !== undefined ? { authentication: protoPatch.aws.authentication } : {}),
+		...(protoPatch.aws.profile !== undefined ? { profile: protoPatch.aws.profile } : {}),
+		...(protoPatch.aws.usePromptCache !== undefined ? { usePromptCache: protoPatch.aws.usePromptCache } : {}),
+		...(protoPatch.aws.endpoint !== undefined ? { endpoint: protoPatch.aws.endpoint } : {}),
+		...(protoPatch.aws.customModelBaseId !== undefined ? { customModelBaseId: protoPatch.aws.customModelBaseId } : {}),
+		...(protoPatch.aws.useCrossRegionInference !== undefined
+			? { useCrossRegionInference: protoPatch.aws.useCrossRegionInference }
+			: {}),
+		...(protoPatch.aws.useGlobalInference !== undefined ? { useGlobalInference: protoPatch.aws.useGlobalInference } : {}),
+	}
+}
+
+export function toProviderModelsResponse(
+	providerId: ProviderId,
+	requestId: string,
+	result: ProviderModelsResult,
+): ProviderModelsResponse {
+	return ProviderModelsResponse.create({
+		providerId,
+		requestId,
+		configFingerprint: result.configFingerprint,
+		fetchedAt: result.fetchedAt,
+		ok: result.ok,
+		models: result.ok ? toProtobufModels(result.models) : {},
+		defaultModelId: result.ok ? result.defaultModelId : undefined,
+		source: result.ok ? result.source : undefined,
+		error: result.ok ? undefined : toCatalogErrorInfo(result.error),
+	})
+}
+
+export function toRedactedProviderConfigResponse(
+	config: EffectiveProviderConfig,
+	store?: ProviderConfigStore,
+): ProviderConfigResponse {
+	return ProviderConfigResponse.create({
+		providerId: config.providerId,
+		baseUrl: config.baseUrl,
+		apiLine: config.apiLine,
+		headers: config.headers ?? {},
+		region: config.region,
+		apiKeyLength: config.apiKey?.length ?? 0,
+		hasAccessToken: Boolean(config.auth?.accessToken),
+		hasRefreshToken: Boolean(config.auth?.refreshToken),
+		accountId: config.auth?.accountId,
+		planSelection: toCommittedModelSelectionProto(store?.readSelection(config.providerId, "plan")),
+		actSelection: toCommittedModelSelectionProto(store?.readSelection(config.providerId, "act")),
+		aws: toRedactedAwsProviderConfigProto(config.aws),
+		gcp: toRedactedGcpProviderConfigProto(config.gcp),
+	})
+}
+
+export function toProviderConfigPatch(protoPatch: WriteProviderConfigPatch | undefined): ProviderConfigPatch {
+	if (!protoPatch) {
+		throw new Error("patch is required")
+	}
+	return {
+		...(protoPatch.apiKey !== undefined ? { apiKey: protoPatch.apiKey } : {}),
+		...(protoPatch.baseUrl !== undefined ? { baseUrl: protoPatch.baseUrl } : {}),
+		...(protoPatch.clearHeaders
+			? { headers: {} }
+			: Object.keys(protoPatch.headers ?? {}).length > 0
+				? { headers: { ...protoPatch.headers } }
+				: {}),
+		...(protoPatch.region !== undefined ? { region: protoPatch.region } : {}),
+		...(protoPatch.apiLine !== undefined ? { apiLine: protoPatch.apiLine } : {}),
+		...(protoPatch.aws !== undefined ? { aws: toAwsProviderConfigPatch(protoPatch) } : {}),
+		...(protoPatch.gcp !== undefined ? { gcp: toGcpProviderConfigPatch(protoPatch) } : {}),
+		...(protoPatch.accessToken !== undefined || protoPatch.refreshToken !== undefined || protoPatch.accountId !== undefined
+			? {
+					auth: {
+						accessToken: protoPatch.accessToken,
+						refreshToken: protoPatch.refreshToken,
+						accountId: protoPatch.accountId,
+					},
+				}
+			: {}),
+		...(protoPatch.reasoning
+			? {
+					reasoning: {
+						...(protoPatch.reasoning.enabled !== undefined ? { enabled: protoPatch.reasoning.enabled } : {}),
+						...(protoPatch.reasoning.effort !== undefined ? { effort: protoPatch.reasoning.effort } : {}),
+						...(protoPatch.reasoning.budgetTokens !== undefined
+							? { budgetTokens: protoPatch.reasoning.budgetTokens }
+							: {}),
+					},
+				}
+			: {}),
+	}
+}
+
+export function toModelSelection(request: CommitModelSelectionRequest, providerId: ProviderId): ModelSelection {
+	const modelId = request.modelId.trim()
+	if (!modelId) {
+		throw new Error("model_id is required")
+	}
+	if (!request.modelInfo) {
+		throw new Error("model_info is required")
+	}
+	return {
+		providerId,
+		modelId,
+		modelInfo: fromProtobufModelInfo(request.modelInfo),
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/providerSwitchNormalization.ts b/apps/vscode/src/core/controller/models/providerSwitchNormalization.ts
new file mode 100644
index 0000000..4805dc7
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/providerSwitchNormalization.ts
@@ -0,0 +1,105 @@
+import { getGeneratedModelsForProvider, MODEL_COLLECTIONS_BY_PROVIDER_ID } from "@cline/llms"
+import type { Mode, ProviderConfigStore, ProviderId } from "@/sdk/model-catalog/contracts"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import { toSdkProviderId } from "@/sdk/model-catalog/sdk-provider-id"
+import type { ApiConfiguration, ApiProvider } from "@/shared/api"
+import { getProviderModelIdKey } from "@/shared/storage/provider-keys"
+
+type ProviderSwitchConfig = Partial<
+	Pick<ApiConfiguration, "planModeApiProvider" | "actModeApiProvider" | "planModeApiModelId" | "actModeApiModelId">
+>
+
+const modeFields = {
+	plan: {
+		provider: "planModeApiProvider",
+		modelId: "planModeApiModelId",
+	},
+	act: {
+		provider: "actModeApiProvider",
+		modelId: "actModeApiModelId",
+	},
+} as const
+
+function toProviderId(provider: ApiProvider | string | undefined): ProviderId | undefined {
+	const trimmed = provider?.trim()
+	return trimmed ? parseProviderId(trimmed) : undefined
+}
+
+function resolveProviderSwitchModelId(
+	store: ProviderConfigStore,
+	providerId: ProviderId,
+	mode: Mode,
+	currentModelId: string | undefined,
+): string {
+	const sdkProviderId = toSdkProviderId(providerId)
+	const generatedModels = getGeneratedModelsForProvider(sdkProviderId)
+	const collection = MODEL_COLLECTIONS_BY_PROVIDER_ID[sdkProviderId]
+	const collectionModels = collection?.models ?? {}
+	if (currentModelId && (generatedModels[currentModelId] || collectionModels[currentModelId])) {
+		return currentModelId
+	}
+
+	const selection = store.readSelection(providerId, mode)
+	if (selection?.modelId) {
+		return selection.modelId
+	}
+
+	const sdkDefaultModelId = collection?.provider.defaultModelId?.trim()
+	if (sdkDefaultModelId && (generatedModels[sdkDefaultModelId] || collectionModels[sdkDefaultModelId])) {
+		return sdkDefaultModelId
+	}
+
+	return Object.keys(generatedModels)[0] || Object.keys(collectionModels)[0] || ""
+}
+
+/**
+ * Keep generic legacy model-id slots coherent when switching to an SDK-catalog
+ * provider. DeepSeek currently stores its model id in `*ModeApiModelId`; without
+ * this normalization, switching Anthropic/Cline/etc. → DeepSeek can leave the
+ * generic slot pointing at a previous provider's model.
+ */
+export function normalizeProviderSwitchModel<T extends ProviderSwitchConfig>(
+	store: ProviderConfigStore,
+	previous: ProviderSwitchConfig,
+	next: T,
+): T {
+	const normalized: ProviderSwitchConfig = { ...next }
+
+	for (const [mode, fields] of Object.entries(modeFields) as [Mode, (typeof modeFields)[Mode]][]) {
+		const previousProvider = previous[fields.provider]
+		const nextProvider = (normalized[fields.provider] ?? previousProvider) as ApiProvider | undefined
+		if (!nextProvider || nextProvider === previousProvider) {
+			continue
+		}
+
+		const providerId = toProviderId(nextProvider)
+		if (!providerId) {
+			continue
+		}
+
+		// Only normalize providers that share the common `apiModelId` slot.
+		// Providers that maintain their own model-id field
+		// (planModeOpenRouterModelId, planModeOllamaModelId, …) are skipped
+		// here because their writers already produce coherent state and
+		// snapping the generic slot would clobber an unrelated value.
+		const genericModelKey = getProviderModelIdKey(nextProvider, mode)
+		if (genericModelKey !== fields.modelId) {
+			continue
+		}
+
+		// Only normalize providers the SDK actually knows about. For
+		// custom/unregistered providers there is no catalog to resolve
+		// against and no useful default to write here.
+		if (!MODEL_COLLECTIONS_BY_PROVIDER_ID[toSdkProviderId(providerId)]) {
+			continue
+		}
+
+		const currentModelId = (normalized[fields.modelId] ?? previous[fields.modelId]) as string | undefined
+		const resolvedModelId = resolveProviderSwitchModelId(store, providerId, mode, currentModelId)
+		if (resolvedModelId) {
+			normalized[fields.modelId] = resolvedModelId
+		}
+	}
+
+	return normalized as T
+}
diff --git a/apps/vscode/src/core/controller/models/readProviderConfig.ts b/apps/vscode/src/core/controller/models/readProviderConfig.ts
new file mode 100644
index 0000000..207bffb
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/readProviderConfig.ts
@@ -0,0 +1,12 @@
+import { StringRequest } from "@/shared/proto/cline/common"
+import { ProviderConfigResponse } from "@/shared/proto/cline/models"
+import { type ProviderCatalogController, parseProviderIdRequest, toRedactedProviderConfigResponse } from "./providerCatalogShared"
+
+export async function readProviderConfig(
+	controller: ProviderCatalogController,
+	request: StringRequest,
+): Promise<ProviderConfigResponse> {
+	const providerId = parseProviderIdRequest(request.value, "value")
+	const store = controller.getProviderConfigStore()
+	return toRedactedProviderConfigResponse(store.read(providerId), store)
+}
diff --git a/apps/vscode/src/core/controller/models/refreshBasetenModels.ts b/apps/vscode/src/core/controller/models/refreshBasetenModels.ts
new file mode 100644
index 0000000..9b44a1b
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshBasetenModels.ts
@@ -0,0 +1,304 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+import { getProviderCollectionSync } from "@cline/llms"
+import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import { ANTHROPIC_MAX_THINKING_BUDGET, ModelInfo } from "@shared/api"
+import { fileExistsAtPath } from "@utils/fs"
+import { parsePrice } from "@utils/model-utils"
+import axios from "axios"
+import { StateManager } from "@/core/storage/StateManager"
+import { adaptSdkModelInfo } from "@/sdk/model-catalog/shape-adapter"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Baseten's curated model catalog from the SDK. Used as a fallback
+ * when the live API fetch fails. Adapted to the extension `ModelInfo`
+ * shape so the shape matches what `models` is collecting.
+ */
+function getBasetenSdkModels(): Record<string, ModelInfo> {
+	const collection = getProviderCollectionSync("baseten")
+	if (!collection) {
+		return {}
+	}
+	const result: Record<string, ModelInfo> = {}
+	for (const [modelId, sdkInfo] of Object.entries(collection.models)) {
+		result[modelId] = adaptSdkModelInfo(sdkInfo)
+	}
+	return result
+}
+
+// Track pending refresh promise to prevent duplicate concurrent fetches
+let pendingRefresh: Promise<Record<string, ModelInfo>> | null = null
+
+/**
+ * Core function: Refreshes the Baseten models and returns application types
+ * @param controller The controller instance
+ * @returns Record of model ID to ModelInfo (application types)
+ */
+// TODO(sdk-consolidation): Live-fetches Baseten's /models endpoint and parses
+// live pricing + reasoning support into ModelInfo. The SDK has a generic
+// models-URL fetcher but it returns ids-only and (for providers with a
+// registered modelsSourceUrl) REPLACES the curated catalog rather than merging,
+// so a naive migration would regress metadata. See the detailed note in
+// refreshGroqModels.ts; share via the SDK + delete this handler + RPC once the
+// SDK supports rich/merged per-provider live models for all clients.
+export async function refreshBasetenModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	// Check in-memory cache first
+	const cache = StateManager.get().getModelsCache("baseten")
+	if (cache) {
+		return cache
+	}
+
+	// If a fetch is already in progress, return the same promise
+	if (pendingRefresh) {
+		return pendingRefresh
+	}
+
+	// Start new fetch and track the promise
+	pendingRefresh = (async () => {
+		try {
+			return await fetchAndCacheModels(controller)
+		} finally {
+			// Clear pending promise when done (success or error)
+			pendingRefresh = null
+		}
+	})()
+
+	return pendingRefresh
+}
+
+async function fetchAndCacheModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	const basetenModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.basetenModels)
+
+	// Get the Baseten API key from the controller's state
+	const basetenApiKey = controller.stateManager.getSecretKey("basetenApiKey")
+
+	const models: Record<string, Partial<ModelInfo> & { supportedFeatures?: string[] }> = {}
+	// The SDK catalog is Baseten's curated model list. Used here for
+	// pricing/capability defaults when the live API doesn't surface
+	// them, and as the offline fallback below when the API fetch fails.
+	const sdkModels = getBasetenSdkModels()
+	try {
+		if (basetenApiKey) {
+			// Ensure the API key is properly formatted
+			const cleanApiKey = basetenApiKey.trim()
+			if (!cleanApiKey) {
+				throw new Error("Invalid Baseten API key format")
+			}
+
+			const response = await axios.get("https://inference.baseten.co/v1/models", {
+				headers: {
+					Authorization: `Bearer ${cleanApiKey}`,
+					"Content-Type": "application/json",
+					"User-Agent": "Cline-VSCode-Extension",
+				},
+				timeout: 10000, // 10 second timeout
+				...getAxiosSettings(),
+			})
+
+			const rawModels = response?.data?.data
+
+			if (rawModels && Array.isArray(rawModels)) {
+				for (const rawModel of rawModels) {
+					// Filter out non-chat models and validate model capabilities
+					if (!isValidChatModel(rawModel)) {
+						continue
+					}
+
+					// SDK pricing/capability defaults for this model id, if any.
+					const staticModelInfo = sdkModels[rawModel.id]
+					const supportThinking = rawModel?.supported_features?.some(
+						(p: string) => p === "reasoning_effort" || p === "reasoning",
+					)
+
+					const modelInfo: Partial<ModelInfo> & { supportedFeatures?: string[] } = {
+						maxTokens: rawModel.max_completion_tokens || staticModelInfo?.maxTokens,
+						contextWindow: rawModel.context_length || staticModelInfo?.contextWindow,
+						supportsImages: false, // Baseten model APIs does not support image input
+						supportsPromptCache: staticModelInfo?.supportsPromptCache || false,
+						inputPrice: parsePrice(rawModel.pricing?.prompt) || staticModelInfo?.inputPrice || 0,
+						outputPrice: parsePrice(rawModel.pricing?.completion) || staticModelInfo?.outputPrice || 0,
+						cacheWritesPrice: staticModelInfo?.cacheWritesPrice || 0,
+						cacheReadsPrice: staticModelInfo?.cacheReadsPrice || 0,
+						description: generateModelDescription(rawModel, staticModelInfo),
+						supportedFeatures: rawModel.supported_features || [],
+						supportsReasoning: supportThinking || false,
+						// If thinking is supported, set maxBudget with a default value as a placeholder
+						// to ensure it has a valid thinkingConfig that lets the application know thinking is supported.
+						thinkingConfig: supportThinking ? { maxBudget: ANTHROPIC_MAX_THINKING_BUDGET } : undefined,
+					}
+
+					models[rawModel.id] = modelInfo
+				}
+			}
+			// Cache the fetched models to disk
+			await fs.writeFile(basetenModelsFilePath, JSON.stringify(models))
+		}
+
+		// If no API key is set or models is empty, throw an error to trigger fallback
+		if (Object.keys(models).length === 0) {
+			throw new Error("No Baseten API key set or no models fetched")
+		}
+	} catch (error) {
+		Logger.error("Error fetching Baseten models:", error)
+
+		// Provide more specific error messages
+		let errorMessage = "Unknown error occurred"
+		if (axios.isAxiosError(error)) {
+			if (error.response?.status === 401) {
+				errorMessage = "Invalid Baseten API key. Please check your API key in settings."
+			} else if (error.response?.status === 403) {
+				errorMessage = "Access forbidden. Please verify your Baseten API key has the correct permissions."
+			} else if (error.response?.status === 429) {
+				errorMessage = "Rate limit exceeded. Please try again later."
+			} else if (error.code === "ECONNABORTED") {
+				errorMessage = "Request timeout. Please check your internet connection."
+			} else {
+				errorMessage = `API request failed: ${error.response?.status || error.code || "Unknown error"}`
+			}
+		} else if (error instanceof Error) {
+			errorMessage = error.message
+		}
+
+		Logger.error("Baseten API Error:", errorMessage)
+
+		// If we failed to fetch models, try to read cached models first
+		const cachedModels = await readBasetenModels()
+		if (cachedModels && Object.keys(cachedModels).length > 0) {
+			// Use all cached models (no filtering)
+			for (const [modelId, modelInfo] of Object.entries(cachedModels)) {
+				models[modelId] = modelInfo
+			}
+		} else {
+			// Fall back to the SDK's curated Baseten catalog. Same shape
+			// the live-fetch path produces, just with no API response to
+			// merge.
+			for (const [modelId, modelInfo] of Object.entries(sdkModels)) {
+				models[modelId] = {
+					maxTokens: modelInfo.maxTokens,
+					contextWindow: modelInfo.contextWindow,
+					supportsImages: modelInfo.supportsImages,
+					supportsPromptCache: modelInfo.supportsPromptCache,
+					inputPrice: modelInfo.inputPrice,
+					outputPrice: modelInfo.outputPrice,
+					cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+					cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0,
+					description: modelInfo.description ?? `${modelId} model`,
+					supportsReasoning: modelInfo.supportsReasoning ?? false,
+					thinkingConfig: modelInfo.supportsReasoning ? { maxBudget: ANTHROPIC_MAX_THINKING_BUDGET } : undefined,
+				}
+			}
+		}
+	}
+
+	// Convert the Record<string, Partial<ModelInfo>> to Record<string, ModelInfo>
+	// by filling in any missing required fields with defaults
+	const typedModels: Record<string, ModelInfo> = {}
+	for (const [key, model] of Object.entries(models)) {
+		typedModels[key] = {
+			maxTokens: model.maxTokens ?? 8192,
+			contextWindow: model.contextWindow ?? 8192,
+			supportsImages: model.supportsImages ?? false,
+			supportsPromptCache: model.supportsPromptCache ?? false,
+			inputPrice: model.inputPrice ?? 0,
+			outputPrice: model.outputPrice ?? 0,
+			cacheWritesPrice: model.cacheWritesPrice ?? 0,
+			cacheReadsPrice: model.cacheReadsPrice ?? 0,
+			description: model.description ?? "",
+			tiers: model.tiers,
+			supportsReasoning: model.supportsReasoning || false,
+			thinkingConfig: model.supportsReasoning ? { maxBudget: ANTHROPIC_MAX_THINKING_BUDGET } : undefined,
+		}
+	}
+
+	// Store in StateManager's in-memory cache
+	StateManager.get().setModelsCache("baseten", typedModels)
+
+	return typedModels
+}
+
+/**
+ * Reads cached Baseten models from disk (application types)
+ */
+async function readBasetenModels(): Promise<Record<string, Partial<ModelInfo>> | undefined> {
+	const basetenModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.basetenModels)
+	const fileExists = await fileExistsAtPath(basetenModelsFilePath)
+	if (fileExists) {
+		try {
+			const fileContents = await fs.readFile(basetenModelsFilePath, "utf8")
+			return JSON.parse(fileContents)
+		} catch (error) {
+			Logger.error("Error reading cached Baseten models:", error)
+			return undefined
+		}
+	}
+	return undefined
+}
+
+/**
+ * Validates if a model is suitable for chat completions
+ */
+function isValidChatModel(rawModel: any): boolean {
+	// Filter out non-chat models (whisper, TTS, guard models, etc.)
+	if (rawModel.id.includes("whisper") || rawModel.id.includes("tts") || rawModel.id.includes("embedding")) {
+		return false
+	}
+
+	// Check if model supports chat completions
+	if (rawModel.object === "model" && rawModel.id) {
+		return true
+	}
+
+	return false
+}
+
+/**
+ * Generates a descriptive name for the model
+ */
+function generateModelDescription(rawModel: any, staticModelInfo?: any): string {
+	// Use static description if available and preferred
+	if (staticModelInfo?.description) {
+		return staticModelInfo.description
+	}
+
+	// Use API description if available
+	if (rawModel.description) {
+		const contextWindow = rawModel.context_length
+		const quantization = rawModel.quantization
+		const features = rawModel.supported_features || []
+
+		let description = rawModel.description
+
+		// Add technical details if available
+		const technicalDetails = []
+		if (contextWindow) {
+			technicalDetails.push(`${contextWindow.toLocaleString()} token context`)
+		}
+		if (quantization) {
+			technicalDetails.push(`${quantization} precision`)
+		}
+		if (features.length > 0) {
+			const featureList = features.join(", ")
+			technicalDetails.push(`supports ${featureList}`)
+		}
+
+		if (technicalDetails.length > 0) {
+			description += ` (${technicalDetails.join(", ")})`
+		}
+
+		return description
+	}
+
+	// Fallback: use name or model ID
+	const modelName = rawModel.name || rawModel.id
+	const contextWindow = rawModel.context_length
+	const ownedBy = rawModel.owned_by || "Baseten"
+
+	if (contextWindow) {
+		return `${ownedBy} ${modelName} with ${contextWindow.toLocaleString()} token context window`
+	}
+
+	return `${ownedBy} model: ${modelName}`
+}
diff --git a/apps/vscode/src/core/controller/models/refreshBasetenModelsRpc.ts b/apps/vscode/src/core/controller/models/refreshBasetenModelsRpc.ts
new file mode 100644
index 0000000..673e8cb
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshBasetenModelsRpc.ts
@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshBasetenModels } from "./refreshBasetenModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing Baseten models (protobuf types)
+ */
+export async function refreshBasetenModelsRpc(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshBasetenModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}
diff --git a/apps/vscode/src/core/controller/models/refreshClineRecommendedModels.ts b/apps/vscode/src/core/controller/models/refreshClineRecommendedModels.ts
new file mode 100644
index 0000000..efca784
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshClineRecommendedModels.ts
@@ -0,0 +1,70 @@
+import { FALLBACK_CLINE_RECOMMENDED_MODELS, fetchClineRecommendedModels } from "@cline/core"
+import { ClineEnv } from "@/config"
+import { fetch } from "@/shared/net"
+
+interface ClineRecommendedModelData {
+	id: string
+	name: string
+	description: string
+	tags: string[]
+}
+
+export interface ClineRecommendedModelsData {
+	recommended: ClineRecommendedModelData[]
+	free: ClineRecommendedModelData[]
+	clinePass?: ClineRecommendedModelData[]
+}
+
+const RECOMMENDED_MODELS_CACHE_TTL_MS = 60 * 60 * 1000
+
+let pendingRefresh: Promise<ClineRecommendedModelsData> | null = null
+let inMemoryCache: { data: ClineRecommendedModelsData; timestamp: number } | null = null
+
+export async function refreshClineRecommendedModels(): Promise<ClineRecommendedModelsData> {
+	if (inMemoryCache && Date.now() - inMemoryCache.timestamp <= RECOMMENDED_MODELS_CACHE_TTL_MS) {
+		return inMemoryCache.data
+	}
+
+	if (pendingRefresh) {
+		return pendingRefresh
+	}
+
+	pendingRefresh = (async () => {
+		try {
+			return await fetchAndCacheClineRecommendedModels()
+		} finally {
+			pendingRefresh = null
+		}
+	})()
+
+	return pendingRefresh
+}
+
+export function resetClineRecommendedModelsCacheForTests(): void {
+	pendingRefresh = null
+	inMemoryCache = null
+}
+
+function isFallbackRecommendedModels(data: ClineRecommendedModelsData): boolean {
+	return JSON.stringify(data) === JSON.stringify(FALLBACK_CLINE_RECOMMENDED_MODELS)
+}
+
+async function fetchAndCacheClineRecommendedModels(): Promise<ClineRecommendedModelsData> {
+	// Delegate the actual HTTP fetch + response normalization + offline fallback
+	// to the SDK so the CLI/JetBrains and the extension share one implementation.
+	// We pass the proxy-aware fetch (per .clinerules/network.md) and the
+	// extension's configured API base URL. On failure the SDK returns its own
+	// fallback list.
+	const result = await fetchClineRecommendedModels({
+		baseUrl: ClineEnv.config().apiBaseUrl,
+		fetchImpl: fetch,
+	})
+
+	// Only pin a populated, non-fallback result in memory for the full TTL; a
+	// transient failure (SDK returns a clone of its fallback) should be retried
+	// next call.
+	if ((result.recommended.length > 0 || result.free.length > 0) && !isFallbackRecommendedModels(result)) {
+		inMemoryCache = { data: result, timestamp: Date.now() }
+	}
+	return result
+}
diff --git a/apps/vscode/src/core/controller/models/refreshClineRecommendedModelsRpc.ts b/apps/vscode/src/core/controller/models/refreshClineRecommendedModelsRpc.ts
new file mode 100644
index 0000000..ebf2070
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshClineRecommendedModelsRpc.ts
@@ -0,0 +1,37 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { ClineRecommendedModel, ClineRecommendedModelsResponse } from "@shared/proto/cline/models"
+import type { Controller } from "../index"
+import { refreshClineRecommendedModels } from "./refreshClineRecommendedModels"
+
+export async function refreshClineRecommendedModelsRpc(
+	_controller: Controller,
+	_request: EmptyRequest,
+): Promise<ClineRecommendedModelsResponse> {
+	const models = await refreshClineRecommendedModels()
+	return ClineRecommendedModelsResponse.create({
+		recommended: models.recommended.map((model) =>
+			ClineRecommendedModel.create({
+				id: model.id,
+				name: model.name,
+				description: model.description,
+				tags: model.tags,
+			}),
+		),
+		free: models.free.map((model) =>
+			ClineRecommendedModel.create({
+				id: model.id,
+				name: model.name,
+				description: model.description,
+				tags: model.tags,
+			}),
+		),
+		clinePass: (models.clinePass ?? []).map((model) =>
+			ClineRecommendedModel.create({
+				id: model.id,
+				name: model.name,
+				description: model.description,
+				tags: model.tags,
+			}),
+		),
+	})
+}
diff --git a/apps/vscode/src/core/controller/models/refreshGroqModels.ts b/apps/vscode/src/core/controller/models/refreshGroqModels.ts
new file mode 100644
index 0000000..9cdbd2f
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshGroqModels.ts
@@ -0,0 +1,316 @@
+import { getProviderCollectionSync } from "@cline/llms"
+import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import { ModelInfo } from "@shared/api"
+import { fileExistsAtPath } from "@utils/fs"
+import axios from "axios"
+import fs from "fs/promises"
+import path from "path"
+import { StateManager } from "@/core/storage/StateManager"
+import { adaptSdkModelInfo } from "@/sdk/model-catalog/shape-adapter"
+import { telemetryService } from "@/services/telemetry"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Groq's curated catalog from the SDK, used as the static-pricing
+ * source for live API responses and as the offline fallback when the
+ * live fetch fails.
+ */
+function getGroqSdkModels(): Record<string, ModelInfo> {
+	const collection = getProviderCollectionSync("groq")
+	if (!collection) {
+		return {}
+	}
+	const result: Record<string, ModelInfo> = {}
+	for (const [modelId, sdkInfo] of Object.entries(collection.models)) {
+		result[modelId] = adaptSdkModelInfo(sdkInfo)
+	}
+	return result
+}
+
+// Track pending refresh promise to prevent duplicate concurrent fetches
+let pendingRefresh: Promise<Record<string, ModelInfo>> | null = null
+
+/**
+ * Core function: Refreshes the Groq models and returns application types
+ * @param controller The controller instance
+ * @returns Record of model ID to ModelInfo (application types)
+ */
+// TODO(sdk-consolidation): This handler live-fetches Groq's /models endpoint and
+// enriches each model with curated pricing/capabilities. The SDK HAS a generic
+// models-URL fetcher (sdk/packages/core/src/services/providers/model-source.ts
+// `fetchModelIdsFromSource` + `resolveModelsSourceUrl`), but it is NOT a drop-in
+// replacement:
+//   1. It returns model *ids only*; ids unknown to the curated catalog get
+//      placeholder ModelInfo (no real pricing/context/capabilities).
+//   2. Worse, `mergeKnownModels` treats a registered `modelsSourceUrl` as the
+//      "authoritative installed list" (Ollama/LM Studio semantics) and DISCARDS
+//      the bundled curated catalog when the live fetch returns results.
+// So simply registering `modelsSourceUrl` for Groq would regress rich model
+// metadata. Proper consolidation needs an SDK enhancement first: either a
+// merge-mode that layers live ids on top of the curated catalog, or a richer
+// per-provider fetch that parses full ModelInfo. Once the SDK supports that for
+// all clients (incl. CLI), delete this extension-only handler + its RPC.
+export async function refreshGroqModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	// Check in-memory cache first
+	const cache = StateManager.get().getModelsCache("groq")
+	if (cache) {
+		return cache
+	}
+
+	// If a fetch is already in progress, return the same promise
+	if (pendingRefresh) {
+		return pendingRefresh
+	}
+
+	// Start new fetch and track the promise
+	pendingRefresh = (async () => {
+		try {
+			return await fetchAndCacheModels(controller)
+		} finally {
+			// Clear pending promise when done (success or error)
+			pendingRefresh = null
+		}
+	})()
+
+	return pendingRefresh
+}
+
+async function fetchAndCacheModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	const groqModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.groqModels)
+
+	const groqApiKey = controller.stateManager.getSecretKey("groqApiKey")
+
+	let models: Record<string, Partial<ModelInfo>> = {}
+	const sdkModels = getGroqSdkModels()
+	try {
+		if (!groqApiKey) {
+			Logger.log("No Groq API key found, using SDK catalog as fallback")
+			// Don't throw an error, just use SDK catalog.
+			for (const [modelId, modelInfo] of Object.entries(sdkModels)) {
+				models[modelId] = {
+					maxTokens: modelInfo.maxTokens,
+					contextWindow: modelInfo.contextWindow,
+					supportsImages: modelInfo.supportsImages,
+					supportsPromptCache: modelInfo.supportsPromptCache,
+					inputPrice: modelInfo.inputPrice,
+					outputPrice: modelInfo.outputPrice,
+					cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+					cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0,
+					description: modelInfo.description ?? `${modelId} model`,
+				}
+			}
+		} else {
+			// Ensure the API key is properly formatted
+			const cleanApiKey = groqApiKey.trim()
+			if (!cleanApiKey.startsWith("gsk_")) {
+				throw new Error("Invalid Groq API key format. Groq API keys should start with 'gsk_'")
+			}
+
+			Logger.log("Fetching Groq models with API key:", cleanApiKey.substring(0, 10) + "...")
+
+			const response = await axios.get("https://api.groq.com/openai/v1/models", {
+				headers: {
+					Authorization: `Bearer ${cleanApiKey}`,
+					"Content-Type": "application/json",
+					"User-Agent": "Cline-VSCode-Extension",
+				},
+				timeout: 10000, // 10 second timeout
+				...getAxiosSettings(),
+			})
+
+			if (response.data?.data) {
+				const rawModels = response.data.data
+
+				for (const rawModel of rawModels) {
+					// Filter out non-chat models and validate model capabilities
+					if (!isValidChatModel(rawModel)) {
+						continue
+					}
+
+					// Check if we have static pricing information for this model
+					const staticModelInfo = sdkModels[rawModel.id as keyof typeof sdkModels]
+
+					const modelInfo: Partial<ModelInfo> = {
+						maxTokens: rawModel.max_completion_tokens || staticModelInfo?.maxTokens || 8192,
+						contextWindow: rawModel.context_window || staticModelInfo?.contextWindow || 8192,
+						supportsImages: detectImageSupport(rawModel, staticModelInfo),
+						supportsPromptCache: staticModelInfo?.supportsPromptCache || false,
+						inputPrice: staticModelInfo?.inputPrice || 0,
+						outputPrice: staticModelInfo?.outputPrice || 0,
+						cacheWritesPrice: staticModelInfo?.cacheWritesPrice || 0,
+						cacheReadsPrice: staticModelInfo?.cacheReadsPrice || 0,
+						description: generateModelDescription(rawModel, staticModelInfo),
+					}
+
+					models[rawModel.id] = modelInfo
+				}
+
+				await fs.writeFile(groqModelsFilePath, JSON.stringify(models))
+				Logger.log("Groq models fetched and saved", models)
+			} else {
+				Logger.error("Invalid response from Groq API")
+			}
+		}
+	} catch (error) {
+		Logger.error("Error fetching Groq models:", error)
+
+		// Provide more specific error messages
+		let errorMessage = "Unknown error occurred"
+		if (axios.isAxiosError(error)) {
+			if (error.response?.status === 401) {
+				errorMessage = "Invalid Groq API key. Please check your API key in settings."
+			} else if (error.response?.status === 403) {
+				errorMessage = "Access forbidden. Please verify your Groq API key has the correct permissions."
+			} else if (error.response?.status === 429) {
+				errorMessage = "Rate limit exceeded. Please try again later."
+			} else if (error.code === "ECONNABORTED") {
+				errorMessage = "Request timeout. Please check your internet connection."
+			} else {
+				errorMessage = `API request failed: ${error.response?.status || error.code || "Unknown error"}`
+			}
+		} else if (error instanceof Error) {
+			errorMessage = error.message
+		}
+
+		telemetryService.captureProviderApiError({
+			ulid: controller.task?.ulid || "",
+			errorMessage,
+			errorStatus: error.status,
+			model: "groq",
+		})
+
+		// If we failed to fetch models, try to read cached models first
+		const cachedModels = await readGroqModels()
+		if (cachedModels && Object.keys(cachedModels).length > 0) {
+			Logger.log("Using cached Groq models")
+			models = cachedModels
+		} else {
+			// Fall back to the SDK's curated Groq catalog.
+			Logger.log("Using SDK Groq catalog as fallback")
+			for (const [modelId, modelInfo] of Object.entries(sdkModels)) {
+				models[modelId] = {
+					maxTokens: modelInfo.maxTokens,
+					contextWindow: modelInfo.contextWindow,
+					supportsImages: modelInfo.supportsImages,
+					supportsPromptCache: modelInfo.supportsPromptCache,
+					inputPrice: modelInfo.inputPrice,
+					outputPrice: modelInfo.outputPrice,
+					cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+					cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0,
+					description: modelInfo.description ?? `${modelId} model`,
+				}
+			}
+		}
+	}
+
+	// Convert the Record<string, Partial<ModelInfo>> to Record<string, ModelInfo>
+	// by filling in any missing required fields with defaults
+	const typedModels: Record<string, ModelInfo> = {}
+	for (const [key, model] of Object.entries(models)) {
+		typedModels[key] = {
+			maxTokens: model.maxTokens ?? 8192,
+			contextWindow: model.contextWindow ?? 8192,
+			supportsImages: model.supportsImages ?? false,
+			supportsPromptCache: model.supportsPromptCache ?? false,
+			inputPrice: model.inputPrice ?? 0,
+			outputPrice: model.outputPrice ?? 0,
+			cacheWritesPrice: model.cacheWritesPrice ?? 0,
+			cacheReadsPrice: model.cacheReadsPrice ?? 0,
+			description: model.description ?? "",
+			tiers: model.tiers,
+		}
+	}
+
+	// Store in StateManager's in-memory cache
+	StateManager.get().setModelsCache("groq", typedModels)
+
+	return typedModels
+}
+
+/**
+ * Reads cached Groq models from disk (application types)
+ */
+async function readGroqModels(): Promise<Record<string, Partial<ModelInfo>> | undefined> {
+	const groqModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.groqModels)
+	const fileExists = await fileExistsAtPath(groqModelsFilePath)
+	if (fileExists) {
+		try {
+			const fileContents = await fs.readFile(groqModelsFilePath, "utf8")
+			return JSON.parse(fileContents)
+		} catch (error) {
+			Logger.error("Error reading cached Groq models:", error)
+			return undefined
+		}
+	}
+	return undefined
+}
+
+/**
+ * Validates if a model is suitable for chat completions
+ */
+function isValidChatModel(rawModel: any): boolean {
+	// Check if model is active (if the property exists)
+	if (Object.hasOwn(rawModel, "active") && !rawModel.active) {
+		return false
+	}
+	// Filter out non-chat models (whisper, TTS, guard models, etc.)
+	if (
+		rawModel.id.includes("whisper") ||
+		rawModel.id.includes("tts") ||
+		rawModel.id.includes("guard") ||
+		rawModel.id.includes("embedding") ||
+		rawModel.id.includes("moderation") ||
+		rawModel.id.includes("allam")
+	) {
+		return false
+	}
+
+	// Check if model supports chat completions
+	if (rawModel.object === "model" && rawModel.id) {
+		return true
+	}
+
+	return false
+}
+
+/**
+ * Detects if a model supports image input
+ */
+function detectImageSupport(rawModel: any, staticModelInfo?: any): boolean {
+	// Use static info if available
+	if (staticModelInfo?.supportsImages !== undefined) {
+		return staticModelInfo.supportsImages
+	}
+
+	// Detect based on model name patterns
+	const modelId = rawModel.id.toLowerCase()
+	if (modelId.includes("vision") || modelId.includes("maverick") || modelId.includes("scout")) {
+		return true
+	}
+
+	return false
+}
+
+/**
+ * Generates a descriptive name for the model
+ */
+function generateModelDescription(rawModel: any, staticModelInfo?: any): string {
+	// Use static description if available
+	if (staticModelInfo?.description) {
+		return staticModelInfo.description
+	}
+
+	// Generate description based on model characteristics
+	const modelId = rawModel.id
+	const contextWindow = rawModel.context_window || 8192
+	const ownedBy = rawModel.owned_by || "Unknown"
+
+	// Special handling for new models
+	if (modelId.includes("compound")) {
+		return `${ownedBy}'s ${modelId} model with ${contextWindow.toLocaleString()} token context window - Advanced compound architecture`
+	}
+
+	return `${ownedBy} model with ${contextWindow.toLocaleString()} token context window`
+}
diff --git a/apps/vscode/src/core/controller/models/refreshGroqModelsRpc.ts b/apps/vscode/src/core/controller/models/refreshGroqModelsRpc.ts
new file mode 100644
index 0000000..ecbe36e
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshGroqModelsRpc.ts
@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshGroqModels } from "./refreshGroqModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing Groq models (protobuf types)
+ */
+export async function refreshGroqModelsRpc(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshGroqModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}
diff --git a/apps/vscode/src/core/controller/models/refreshHicapModels.ts b/apps/vscode/src/core/controller/models/refreshHicapModels.ts
new file mode 100644
index 0000000..a275968
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshHicapModels.ts
@@ -0,0 +1,78 @@
+import { GlobalFileNames } from "@core/storage/disk"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import axios from "axios"
+import fs from "fs/promises"
+import path from "path"
+import { getAxiosSettings } from "@/shared/net"
+import { Controller } from ".."
+
+/**
+ * The raw model information returned by the Hicap API to list models
+ */
+interface HicapRawModelInfo {
+	id: string
+	object: string
+}
+
+/**
+ * Refreshes the Hicap models and returns the updated model list
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing the OpenRouter models
+ */
+// TODO(sdk-consolidation): Live-fetches Hicap's /models endpoint. The SDK's
+// generic models-URL fetcher returns ids-only and (for providers with a
+// registered modelsSourceUrl) REPLACES rather than merges the curated catalog,
+// so a naive migration would regress metadata. See the detailed note in
+// refreshGroqModels.ts; share via the SDK + delete this handler + RPC once the
+// SDK supports rich/merged per-provider live models for all clients (incl. CLI).
+export async function refreshHicapModels(controller: Controller, _request: EmptyRequest): Promise<OpenRouterCompatibleModelInfo> {
+	const hicapModelsFilePath = path.join(await ensureCacheDirectoryExists(controller), GlobalFileNames.hicapModels)
+
+	const models: Record<string, OpenRouterModelInfo> = {}
+	try {
+		// Get the Hicap API key from the controller's state
+		const hicapApiKey = controller.stateManager.getSecretKey("hicapApiKey")
+
+		const response = await axios.get("https://api.hicap.ai/v2/openai/models", {
+			headers: {
+				"api-key": hicapApiKey,
+			},
+			...getAxiosSettings(),
+		})
+
+		if (response.data?.data) {
+			const rawModels = response.data.data
+
+			for (const rawModel of rawModels as HicapRawModelInfo[]) {
+				models[rawModel.id] = {
+					maxTokens: -1,
+					contextWindow: 128_000,
+					supportsImages: true,
+					supportsPromptCache: true,
+					inputPrice: 0,
+					outputPrice: 0,
+					cacheWritesPrice: 0,
+					cacheReadsPrice: 0,
+					tiers: [],
+					description: "",
+				}
+			}
+		}
+		await fs.writeFile(hicapModelsFilePath, JSON.stringify(models))
+	} catch (_error) {
+		// If we failed to fetch models, keep whatever we have.
+	}
+
+	return OpenRouterCompatibleModelInfo.create({ models })
+}
+
+/**
+ * Ensures the cache directory exists and returns its path
+ */
+async function ensureCacheDirectoryExists(controller: Controller): Promise<string> {
+	const cacheDir = path.join(controller.context.globalStorageUri.fsPath, "cache")
+	await fs.mkdir(cacheDir, { recursive: true })
+	return cacheDir
+}
diff --git a/apps/vscode/src/core/controller/models/refreshHuggingFaceModels.ts b/apps/vscode/src/core/controller/models/refreshHuggingFaceModels.ts
new file mode 100644
index 0000000..e795f67
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshHuggingFaceModels.ts
@@ -0,0 +1,131 @@
+import { getProviderCollectionSync } from "@cline/llms"
+import type { ModelInfo } from "@shared/api"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import { fileExistsAtPath } from "@utils/fs"
+import axios from "axios"
+import fs from "fs/promises"
+import path from "path"
+import { ensureCacheDirectoryExists } from "@/core/storage/disk"
+import { adaptSdkModelInfo } from "@/sdk/model-catalog/shape-adapter"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Hugging Face's curated catalog from the SDK. Used to supply pricing
+ * and capability defaults for live models that match an SDK-known id,
+ * and as the offline fallback when neither the live fetch nor the disk
+ * cache yields anything.
+ */
+function getHuggingFaceSdkModels(): Record<string, ModelInfo> {
+	const collection = getProviderCollectionSync("huggingface")
+	if (!collection) {
+		return {}
+	}
+	const result: Record<string, ModelInfo> = {}
+	for (const [modelId, sdkInfo] of Object.entries(collection.models)) {
+		result[modelId] = adaptSdkModelInfo(sdkInfo)
+	}
+	return result
+}
+
+const huggingFaceModels = getHuggingFaceSdkModels()
+
+/**
+ * Refreshes the Hugging Face models and returns the updated model list
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing the Hugging Face models
+ */
+// TODO(sdk-consolidation): Live-fetches HuggingFace's /models endpoint. The
+// SDK's generic models-URL fetcher returns ids-only and (for providers with a
+// registered modelsSourceUrl) REPLACES rather than merges the curated catalog,
+// so a naive migration would regress metadata. See the detailed note in
+// refreshGroqModels.ts; share via the SDK + delete this handler + RPC once the
+// SDK supports rich/merged per-provider live models for all clients (incl. CLI).
+export async function refreshHuggingFaceModels(
+	_controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const huggingFaceModelsFilePath = path.join(await ensureCacheDirectoryExists(), "huggingface_models.json")
+
+	let models: Record<string, OpenRouterModelInfo> = {}
+
+	try {
+		// Fetch models from Hugging Face API
+		const response = await axios.get("https://router.huggingface.co/v1/models", {
+			timeout: 10000,
+			...getAxiosSettings(),
+		})
+
+		if (response.data?.data) {
+			const rawModels = response.data.data
+
+			// Transform HF models to OpenRouter-compatible format
+			for (const rawModel of rawModels) {
+				const providersList = rawModel.providers?.map((provider: { provider: string }) => provider.provider)?.join(", ")
+				const modelInfo = OpenRouterModelInfo.create({
+					maxTokens: 8192, // HF doesn't provide max_tokens, use default
+					contextWindow: 128_000, // FIXME: HF doesn't provide context window, use default
+					supportsImages: false, // Most models don't support images
+					supportsPromptCache: false,
+					inputPrice: 0, // Will be set based on providers
+					outputPrice: 0, // Will be set based on providers
+					cacheWritesPrice: 0,
+					cacheReadsPrice: 0,
+					description: `Available on providers: ${providersList || "unknown"}`,
+				})
+
+				// Add model-specific configurations if we have them in our static models
+				if (rawModel.id in huggingFaceModels) {
+					const staticModel = huggingFaceModels[rawModel.id as keyof typeof huggingFaceModels]
+					modelInfo.maxTokens = staticModel.maxTokens
+					modelInfo.contextWindow = staticModel.contextWindow
+					modelInfo.supportsImages = staticModel.supportsImages
+					modelInfo.supportsPromptCache = staticModel.supportsPromptCache
+					modelInfo.inputPrice = staticModel.inputPrice
+					modelInfo.outputPrice = staticModel.outputPrice
+					modelInfo.description = staticModel.description || modelInfo.description
+				}
+
+				models[rawModel.id] = modelInfo
+			}
+
+			// Save to cache
+			await fs.writeFile(huggingFaceModelsFilePath, JSON.stringify(models, null, 2))
+		}
+	} catch (error) {
+		Logger.error("Error fetching Hugging Face models:", error)
+
+		// Try to load from cache
+		try {
+			if (await fileExistsAtPath(huggingFaceModelsFilePath)) {
+				const cachedModels = await fs.readFile(huggingFaceModelsFilePath, "utf-8")
+				const parsedModels = JSON.parse(cachedModels)
+				models = parsedModels
+			}
+		} catch (cacheError) {
+			Logger.error("Error loading cached Hugging Face models:", cacheError)
+		}
+
+		// If no cache available, use static models as fallback
+		if (Object.keys(models).length === 0) {
+			for (const [modelId, modelInfo] of Object.entries(huggingFaceModels)) {
+				models[modelId] = OpenRouterModelInfo.create({
+					maxTokens: modelInfo.maxTokens,
+					contextWindow: modelInfo.contextWindow,
+					supportsImages: modelInfo.supportsImages,
+					supportsPromptCache: modelInfo.supportsPromptCache,
+					inputPrice: modelInfo.inputPrice,
+					outputPrice: modelInfo.outputPrice,
+					cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+					cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0,
+					description: modelInfo.description ?? "",
+				})
+			}
+		}
+	}
+
+	return OpenRouterCompatibleModelInfo.create({ models })
+}
diff --git a/apps/vscode/src/core/controller/models/refreshLiteLlmModels.ts b/apps/vscode/src/core/controller/models/refreshLiteLlmModels.ts
new file mode 100644
index 0000000..b399d67
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshLiteLlmModels.ts
@@ -0,0 +1,43 @@
+import type { ModelInfo } from "@shared/api"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { StateManager } from "@/core/storage/StateManager"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import { toProtobufModels } from "@/shared/proto-conversions/models/typeConversion"
+import { Logger } from "@/shared/services/Logger"
+import type { ProviderCatalogController } from "./providerCatalogShared"
+import { sendLiteLlmModelsEvent } from "./subscribeToLiteLlmModels"
+
+/**
+ * Core function: Refreshes the LiteLLM models and returns application types
+ * @param controller The controller instance
+ * @returns Record of model ID to ModelInfo (application types)
+ */
+export async function refreshLiteLlmModels(controller: ProviderCatalogController): Promise<Record<string, ModelInfo>> {
+	try {
+		const result = await controller.getProviderCatalog().resolveModels(parseProviderId("litellm"), { forceRefresh: true })
+		if (!result.ok) {
+			throw new Error(result.error.message)
+		}
+
+		const models: Record<string, ModelInfo> = Object.fromEntries(result.models)
+
+		// Store in StateManager's in-memory cache
+		StateManager.get().setModelsCache("liteLlm", models)
+
+		// Send event to subscribers
+		try {
+			await sendLiteLlmModelsEvent(
+				OpenRouterCompatibleModelInfo.create({
+					models: toProtobufModels(models),
+				}),
+			)
+		} catch (error) {
+			Logger.error("Error sending LiteLLM models event:", error)
+		}
+
+		return models
+	} catch (error) {
+		Logger.error("Error fetching LiteLLM models:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/refreshLiteLlmModelsRpc.ts b/apps/vscode/src/core/controller/models/refreshLiteLlmModelsRpc.ts
new file mode 100644
index 0000000..9bc3b4d
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshLiteLlmModelsRpc.ts
@@ -0,0 +1,21 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import type { Controller } from "../index"
+import { refreshLiteLlmModels } from "./refreshLiteLlmModels"
+
+/**
+ * Refreshes LiteLLM models and returns protobuf types for gRPC
+ * @param controller The controller instance
+ * @param request Empty request (unused but required for gRPC signature)
+ * @returns OpenRouterCompatibleModelInfo with protobuf types
+ */
+export async function refreshLiteLlmModelsRpc(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshLiteLlmModels(controller)
+	return OpenRouterCompatibleModelInfo.create({
+		models: toProtobufModels(models),
+	})
+}
diff --git a/apps/vscode/src/core/controller/models/refreshOcaModels.ts b/apps/vscode/src/core/controller/models/refreshOcaModels.ts
new file mode 100644
index 0000000..7843200
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshOcaModels.ts
@@ -0,0 +1,218 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { ApiFormat, OcaCompatibleModelInfo, OcaModelInfo } from "@shared/proto/cline/models"
+import axios from "axios"
+import { HostProvider } from "@/hosts/host-provider"
+import { OcaAuthService } from "@/services/auth/oca/OcaAuthService"
+import {
+	CHAT_COMPLETIONS_API,
+	DEFAULT_EXTERNAL_OCA_BASE_URL,
+	DEFAULT_INTERNAL_OCA_BASE_URL,
+	MESSAGES_API,
+	RESPONSES_API,
+} from "@/services/auth/oca/utils/constants"
+import { createOcaHeaders } from "@/services/auth/oca/utils/utils"
+import { getAxiosSettings } from "@/shared/net"
+import { ShowMessageType } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import { GlobalStateAndSettings } from "@/shared/storage/state-keys"
+import { Controller } from ".."
+
+/**
+ * Refreshes the Oca models and returns the updated model list
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing the Oca models
+ */
+export async function refreshOcaModels(controller: Controller, request: StringRequest): Promise<OcaCompatibleModelInfo> {
+	const parsePrice = (price: unknown) => {
+		if (price) {
+			return Number.parseFloat(String(price)) * 1_000_000
+		}
+		return undefined
+	}
+	const noModelsMessage = "No models found. Did you set up your OCA access (possibly through entitlements)?"
+	const models: Record<string, OcaModelInfo> = {}
+	let defaultModelId: string | undefined
+	const ocaAccessToken = await OcaAuthService.getInstance().getAuthToken()
+	if (!ocaAccessToken) {
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: "Not authenticated with OCA. Please sign in first.",
+		})
+		return OcaCompatibleModelInfo.create({ error: "Not authenticated with OCA" })
+	}
+	const ocaMode = controller.stateManager.getGlobalSettingsKey("ocaMode") || "internal"
+	const baseUrl = request.value || (ocaMode === "internal" ? DEFAULT_INTERNAL_OCA_BASE_URL : DEFAULT_EXTERNAL_OCA_BASE_URL)
+	const modelsUrl = `${baseUrl}/v1/model/info`
+	const headers = await createOcaHeaders(ocaAccessToken, "models-refresh")
+	try {
+		Logger.log(`Making refresh oca model request with customer opc-request-id: ${headers["opc-request-id"]}`)
+		const response = await axios.get(modelsUrl, { headers, ...getAxiosSettings() })
+		const responseModels = response.data?.data
+		if (Array.isArray(responseModels)) {
+			if (responseModels.length === 0) {
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: noModelsMessage,
+				})
+				return OcaCompatibleModelInfo.create({ error: noModelsMessage })
+			}
+			for (const model of responseModels) {
+				const modelId = model.litellm_params?.model
+				if (typeof modelId !== "string" || !modelId) {
+					continue
+				}
+				if (!defaultModelId) {
+					defaultModelId = modelId
+				}
+				const modelInfo = model.model_info ?? {}
+				const supportedApiList = Array.isArray(modelInfo.supported_api_list)
+					? modelInfo.supported_api_list
+					: [CHAT_COMPLETIONS_API]
+				const reasoningEffortOptions = Array.isArray(modelInfo.reasoning_effort_options)
+					? modelInfo.reasoning_effort_options
+					: []
+
+				let apiFormat: ApiFormat = ApiFormat.OPENAI_CHAT
+				if (supportsChatCompletions(supportedApiList)) {
+					apiFormat = ApiFormat.OPENAI_CHAT
+				} else if (supportsResponses(supportedApiList)) {
+					apiFormat = ApiFormat.OPENAI_RESPONSES
+				} else if (supportsMessages(supportedApiList)) {
+					apiFormat = ApiFormat.ANTHROPIC_CHAT
+				}
+
+				models[modelId] = OcaModelInfo.create({
+					maxTokens: model.litellm_params?.max_tokens || -1,
+					contextWindow: modelInfo.context_window,
+					supportsImages: modelInfo.supports_vision || false,
+					supportsPromptCache: modelInfo.supports_caching || false,
+					inputPrice: parsePrice(modelInfo.input_price) || 0,
+					outputPrice: parsePrice(modelInfo.output_price) || 0,
+					cacheWritesPrice: parsePrice(modelInfo.caching_price) || 0,
+					cacheReadsPrice: parsePrice(modelInfo.cached_price) || 0,
+					description: modelInfo.description,
+					thinkingConfig: modelInfo.thinking_config,
+					surveyContent: modelInfo.survey_content,
+					surveyId: modelInfo.survey_id,
+					temperature: modelInfo.temperature || 0,
+					banner: modelInfo.banner,
+					modelName: modelId,
+					apiFormat: apiFormat,
+					supportsReasoning: modelInfo.is_reasoning_model || false,
+					reasoningEffortOptions,
+				})
+			}
+			if (!defaultModelId || Object.keys(models).length === 0) {
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: noModelsMessage,
+				})
+				return OcaCompatibleModelInfo.create({ error: noModelsMessage })
+			}
+			Logger.log("OCA models fetched", models)
+
+			// Fetch current config to determine existing model selections
+			const apiConfiguration = controller.stateManager.getApiConfiguration()
+			const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+
+			const planModeSelectedModelId: string =
+				apiConfiguration?.planModeOcaModelId && models[apiConfiguration.planModeOcaModelId]
+					? apiConfiguration.planModeOcaModelId
+					: defaultModelId
+			const actModeSelectedModelId: string =
+				apiConfiguration?.actModeOcaModelId && models[apiConfiguration.actModeOcaModelId]
+					? apiConfiguration.actModeOcaModelId
+					: defaultModelId
+
+			let planModeOcaReasoningEffort: string | undefined
+			let actModeOcaReasoningEffort: string | undefined
+			if (
+				models[planModeSelectedModelId].supportsReasoning &&
+				models[planModeSelectedModelId].reasoningEffortOptions.length > 0
+			) {
+				planModeOcaReasoningEffort = apiConfiguration.planModeOcaReasoningEffort
+					? apiConfiguration.planModeOcaReasoningEffort
+					: models[planModeSelectedModelId].reasoningEffortOptions[0]
+			}
+			if (
+				models[actModeSelectedModelId].supportsReasoning &&
+				models[actModeSelectedModelId].reasoningEffortOptions.length > 0
+			) {
+				actModeOcaReasoningEffort = apiConfiguration.actModeOcaReasoningEffort
+					? apiConfiguration.actModeOcaReasoningEffort
+					: models[actModeSelectedModelId].reasoningEffortOptions[0]
+			}
+
+			// Build updates object based on plan/act mode setting
+			const updates: Partial<GlobalStateAndSettings> = {}
+
+			if (planActSeparateModelsSetting) {
+				if (currentMode === "plan") {
+					updates.planModeOcaModelId = planModeSelectedModelId
+					updates.planModeOcaModelInfo = models[planModeSelectedModelId]
+					updates.planModeOcaReasoningEffort = planModeOcaReasoningEffort
+				} else {
+					updates.actModeOcaModelId = actModeSelectedModelId
+					updates.actModeOcaModelInfo = models[actModeSelectedModelId]
+					updates.actModeOcaReasoningEffort = actModeOcaReasoningEffort
+				}
+			} else {
+				updates.planModeOcaModelId = planModeSelectedModelId
+				updates.planModeOcaModelInfo = models[planModeSelectedModelId]
+				updates.planModeOcaReasoningEffort = planModeOcaReasoningEffort
+				updates.actModeOcaModelId = actModeSelectedModelId
+				updates.actModeOcaModelInfo = models[actModeSelectedModelId]
+				updates.actModeOcaReasoningEffort = actModeOcaReasoningEffort
+			}
+
+			// Update state directly using batch method
+			controller.stateManager.setGlobalStateBatch(updates)
+
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: `Refreshed OCA models from ${baseUrl}`,
+			})
+			await controller.postStateToWebview?.()
+		} else {
+			Logger.error("Invalid response from OCA API")
+			const error = `Failed to fetch OCA models. Please check your configuration from ${baseUrl}`
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: error,
+			})
+			return OcaCompatibleModelInfo.create({ error })
+		}
+	} catch (err) {
+		let userMsg: string
+		if (err.response) {
+			// The request was made and the server responded with a status code that falls out of the range of 2xx
+			userMsg = `Did you set up your OCA access (possibly through entitlements)? OCA service returned ${err.response.status} ${err.response.statusText}.`
+		} else if (err.request) {
+			// The request was made but no response was received
+			userMsg = `Unable to access the OCA backend. Is your endpoint and proxy configured properly? Please see the troubleshooting guide.`
+		} else {
+			userMsg = err.message
+			Logger.error(userMsg, err)
+		}
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Error refreshing OCA models. ${userMsg} opc-request-id: ${headers["opc-request-id"]}`,
+		})
+		return OcaCompatibleModelInfo.create({ error: userMsg })
+	}
+	return OcaCompatibleModelInfo.create({ models })
+}
+
+function supportsChatCompletions(modelSupportedApiList: string[]): boolean {
+	return modelSupportedApiList.includes(CHAT_COMPLETIONS_API)
+}
+
+function supportsResponses(modelSupportedApiList: string[]): boolean {
+	return modelSupportedApiList.includes(RESPONSES_API)
+}
+
+function supportsMessages(modelSupportedApiList: string[]): boolean {
+	return modelSupportedApiList.includes(MESSAGES_API)
+}
diff --git a/apps/vscode/src/core/controller/models/refreshOpenAiModels.ts b/apps/vscode/src/core/controller/models/refreshOpenAiModels.ts
new file mode 100644
index 0000000..54ad873
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshOpenAiModels.ts
@@ -0,0 +1,46 @@
+import { StringArray } from "@shared/proto/cline/common"
+import { OpenAiModelsRequest } from "@shared/proto/cline/models"
+import type { AxiosRequestConfig } from "axios"
+import axios from "axios"
+import { parseProviderId } from "@/sdk/model-catalog/provider-id"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Fetches available models from the OpenAI API
+ * @param controller The controller instance
+ * @param request Request containing the base URL and API key
+ * @returns Array of model names
+ */
+export async function refreshOpenAiModels(controller: Controller, request: OpenAiModelsRequest): Promise<StringArray> {
+	try {
+		const providerConfig = controller.getProviderConfigStore().read(parseProviderId("openai"))
+		const baseUrl = request.baseUrl || providerConfig.baseUrl
+		const apiKey = request.apiKey || providerConfig.apiKey
+
+		if (!baseUrl) {
+			return StringArray.create({ values: [] })
+		}
+
+		if (!URL.canParse(baseUrl)) {
+			return StringArray.create({ values: [] })
+		}
+
+		const config: AxiosRequestConfig = {
+			headers: {
+				...(providerConfig.headers ?? {}),
+				...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+			},
+		}
+
+		const response = await axios.get(`${baseUrl}/models`, { ...config, ...getAxiosSettings() })
+		const modelsArray = response.data?.data?.map((model: any) => model.id) || []
+		const models = [...new Set<string>(modelsArray)]
+
+		return StringArray.create({ values: models })
+	} catch (error) {
+		Logger.error("Error fetching OpenAI models:", error)
+		return StringArray.create({ values: [] })
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/refreshOpenRouterModels.ts b/apps/vscode/src/core/controller/models/refreshOpenRouterModels.ts
new file mode 100644
index 0000000..b250a66
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshOpenRouterModels.ts
@@ -0,0 +1,337 @@
+import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import type { ModelInfo } from "@shared/api"
+import { GEMINI_FLASH_MAX_OUTPUT_TOKENS, isGeminiFlashModel } from "@utils/model-utils"
+import axios from "axios"
+import fs from "fs/promises"
+import path from "path"
+import { StateManager } from "@/core/storage/StateManager"
+import { ANTHROPIC_MAX_THINKING_BUDGET } from "@/shared/api"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from ".."
+
+type OpenRouterSupportedParams =
+	| "frequency_penalty"
+	| "include_reasoning"
+	| "logit_bias"
+	| "logprobs"
+	| "max_tokens"
+	| "min_p"
+	| "presence_penalty"
+	| "reasoning"
+	| "repetition_penalty"
+	| "response_format"
+	| "seed"
+	| "stop"
+	| "temperature"
+	| "tool_choice"
+	| "tools"
+	| "top_k"
+	| "top_logprobs"
+	| "top_p"
+
+/**
+ * The raw model information returned by the OpenRouter API to list models
+ * @link https://openrouter.ai/docs/overview/models
+ */
+interface OpenRouterRawModelInfo {
+	id: string
+	name: string
+	description: string | null
+	context_length: number | null
+	top_provider: {
+		max_completion_tokens: number | null
+		context_length: number | null
+		is_moderated: boolean | null
+	} | null
+	architecture: {
+		modality: string[]
+		input_modalities: string[]
+		output_modalities: string[]
+		tokenizer: string
+		instruct_type: string
+	} | null
+	pricing: {
+		prompt: string
+		completion: string
+		request: string
+		image: string
+		audio: string
+		web_search: string
+		internal_reasoning: string
+		input_cache_read: string
+		input_cache_write: string
+	} | null
+	supports_global_endpoint: boolean | null
+	tiers: any[] | null
+	supported_parameters?: OpenRouterSupportedParams[] | null
+}
+
+// Track pending refresh promise to prevent duplicate concurrent fetches
+let pendingRefresh: Promise<Record<string, ModelInfo>> | null = null
+
+/**
+ * Core function: Refreshes the OpenRouter models and returns application types
+ * @param controller The controller instance
+ * @returns Record of model ID to ModelInfo (application types)
+ */
+// TODO(sdk-consolidation): Live-fetches OpenRouter's /models endpoint with rich
+// per-model pricing/capability parsing (the most elaborate of these handlers).
+// The SDK has a generic models-URL fetcher and a models.dev live catalog, but
+// the generic fetcher is ids-only and (for providers with a registered
+// modelsSourceUrl) REPLACES rather than merges the curated catalog, so a naive
+// migration would regress metadata. See the detailed note in refreshGroqModels.ts.
+// Consolidate via the SDK (rich/merged live models for all clients incl. CLI),
+// then delete this handler + RPC. (Note: the "cline" provider model list
+// piggybacks on OpenRouter ids, so migrate both together.)
+export async function refreshOpenRouterModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	// Check in-memory cache first
+	const cache = StateManager.get().getModelsCache("openRouter")
+	if (cache) {
+		return cache
+	}
+
+	// If a fetch is already in progress, return the same promise
+	if (pendingRefresh) {
+		return pendingRefresh
+	}
+
+	// Start new fetch and track the promise
+	pendingRefresh = (async () => {
+		try {
+			return await fetchAndCacheModels(controller)
+		} finally {
+			// Clear pending promise when done (success or error)
+			pendingRefresh = null
+		}
+	})()
+
+	return pendingRefresh
+}
+
+async function fetchAndCacheModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	const openRouterModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.openRouterModels)
+
+	let models: Record<string, ModelInfo> = {}
+	try {
+		const response = await axios.get("https://openrouter.ai/api/v1/models", getAxiosSettings())
+
+		if (response.data?.data) {
+			const rawModels = response.data.data
+			const parsePrice = (price: any) => {
+				if (price) {
+					return Number.parseFloat(price) * 1_000_000
+				}
+				return undefined
+			}
+			for (const rawModel of rawModels as OpenRouterRawModelInfo[]) {
+				const supportThinking = rawModel.supported_parameters?.some((p) => p === "include_reasoning" || p === "reasoning")
+
+				const modelInfo: ModelInfo = {
+					name: rawModel.name,
+					maxTokens: rawModel.top_provider?.max_completion_tokens ?? 0,
+					contextWindow: rawModel.context_length ?? 0,
+					supportsImages: rawModel.architecture?.modality?.includes("image") ?? false,
+					supportsPromptCache: false,
+					inputPrice: parsePrice(rawModel.pricing?.prompt) ?? 0,
+					outputPrice: parsePrice(rawModel.pricing?.completion) ?? 0,
+					cacheWritesPrice: parsePrice(rawModel.pricing?.input_cache_write),
+					cacheReadsPrice: parsePrice(rawModel.pricing?.input_cache_read),
+					description: rawModel.description ?? "",
+					// If thinking is supported, set maxBudget with a default value as a placeholder
+					// to ensure it has a valid thinkingConfig that lets the application know thinking is supported.
+					thinkingConfig: supportThinking ? { maxBudget: ANTHROPIC_MAX_THINKING_BUDGET } : undefined,
+					supportsGlobalEndpoint: rawModel.supports_global_endpoint ?? undefined,
+					tiers: rawModel.tiers ?? undefined,
+				}
+
+				switch (rawModel.id) {
+					case "anthropic/claude-sonnet-4.6":
+					case "anthropic/claude-4.6-sonnet":
+					case "anthropic/claude-sonnet-4.5":
+					case "anthropic/claude-4.5-sonnet":
+					case "anthropic/claude-sonnet-4":
+						// NOTE: we artificially restrict the context window to 200k to keep costs low for users, and have a :1m model variant created below for users that want to use the full 1m.
+						modelInfo.contextWindow = 200_000
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 3.75
+						modelInfo.cacheReadsPrice = 0.3
+						break
+					case "anthropic/claude-3-7-sonnet":
+					case "anthropic/claude-3-7-sonnet:beta":
+					case "anthropic/claude-3.7-sonnet":
+					case "anthropic/claude-3.7-sonnet:beta":
+					case "anthropic/claude-3.7-sonnet:thinking":
+					case "anthropic/claude-3.5-sonnet":
+					case "anthropic/claude-3.5-sonnet:beta":
+						// NOTE: this needs to be synced with api.ts/openrouter default model info
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 3.75
+						modelInfo.cacheReadsPrice = 0.3
+						break
+					case "anthropic/claude-opus-4.6":
+					case "anthropic/claude-opus-4.7":
+						modelInfo.contextWindow = 200_000 // restrict to 200k, 1m variant created below
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 6.25
+						modelInfo.cacheReadsPrice = 0.5
+						break
+					case "anthropic/claude-fable-5":
+						modelInfo.contextWindow = 200_000 // restrict to 200k, 1m variant created below
+						modelInfo.supportsPromptCache = true
+						modelInfo.inputPrice = 10
+						modelInfo.outputPrice = 50
+						modelInfo.cacheWritesPrice = 12.5
+						modelInfo.cacheReadsPrice = 1
+						break
+					case "anthropic/claude-opus-4.5":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 6.25
+						modelInfo.cacheReadsPrice = 0.5
+						break
+					case "anthropic/claude-opus-4.1":
+					case "anthropic/claude-opus-4":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 18.75
+						modelInfo.cacheReadsPrice = 1.5
+						break
+					case "anthropic/claude-3.5-sonnet-20240620":
+					case "anthropic/claude-3.5-sonnet-20240620:beta":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 3.75
+						modelInfo.cacheReadsPrice = 0.3
+						break
+					case "anthropic/claude-haiku-4.5":
+					case "anthropic/claude-4.5-haiku":
+					case "anthropic/claude-3-5-haiku":
+					case "anthropic/claude-3-5-haiku:beta":
+					case "anthropic/claude-3-5-haiku-20241022":
+					case "anthropic/claude-3-5-haiku-20241022:beta":
+					case "anthropic/claude-3.5-haiku":
+					case "anthropic/claude-3.5-haiku:beta":
+					case "anthropic/claude-3.5-haiku-20241022":
+					case "anthropic/claude-3.5-haiku-20241022:beta":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 1.25
+						modelInfo.cacheReadsPrice = 0.1
+						break
+					case "anthropic/claude-3-opus":
+					case "anthropic/claude-3-opus:beta":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 18.75
+						modelInfo.cacheReadsPrice = 1.5
+						break
+					case "anthropic/claude-3-haiku":
+					case "anthropic/claude-3-haiku:beta":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 0.3
+						modelInfo.cacheReadsPrice = 0.03
+						break
+					case "deepseek/deepseek-chat":
+						modelInfo.supportsPromptCache = true
+						// DeepSeek-specific OpenRouter pricing override; the native DeepSeek
+						// provider is now sourced from the SDK provider catalog.
+						modelInfo.inputPrice = 0
+						modelInfo.cacheWritesPrice = 0.14
+						modelInfo.cacheReadsPrice = 0.014
+						break
+					case "x-ai/grok-3-beta":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheWritesPrice = 0.75
+						modelInfo.cacheReadsPrice = 0
+						break
+					case "moonshotai/kimi-k2":
+						// forcing kimi-k2 to use the together provider for full context and best throughput
+						modelInfo.inputPrice = 1
+						modelInfo.outputPrice = 3
+						modelInfo.contextWindow = 131_000
+						break
+					case "openai/gpt-5":
+					case "openai/gpt-5-chat":
+					case "openai/gpt-5-mini":
+					case "openai/gpt-5-nano":
+						modelInfo.maxTokens = 8_192 // 128000 breaks context window truncation
+						modelInfo.contextWindow = 272_000 // openrouter reports 400k but the input limit is actually 400k-128k
+						break
+					case "x-ai/grok-code-fast-1":
+						modelInfo.supportsPromptCache = true
+						modelInfo.cacheReadsPrice = 0.02
+						break
+					default:
+						if (rawModel.id.startsWith("openai/")) {
+							modelInfo.cacheReadsPrice = parsePrice(rawModel.pricing?.input_cache_read)
+							if (modelInfo.cacheReadsPrice) {
+								modelInfo.supportsPromptCache = true
+								modelInfo.cacheWritesPrice = parsePrice(rawModel.pricing?.input_cache_write)
+								// openrouter charges no cache write pricing for openAI models
+							}
+						} else if (rawModel.id.startsWith("google/")) {
+							modelInfo.cacheReadsPrice = parsePrice(rawModel.pricing?.input_cache_read)
+							if (modelInfo.cacheReadsPrice) {
+								modelInfo.supportsPromptCache = true
+								modelInfo.cacheWritesPrice = parsePrice(rawModel.pricing?.input_cache_write)
+							}
+						}
+						break
+				}
+
+				if (isGeminiFlashModel(rawModel.id)) {
+					modelInfo.maxTokens = Math.min(
+						modelInfo.maxTokens || GEMINI_FLASH_MAX_OUTPUT_TOKENS,
+						GEMINI_FLASH_MAX_OUTPUT_TOKENS,
+					)
+				}
+
+				models[rawModel.id] = modelInfo
+			}
+			// Save models and cache them in memory
+			await fs.writeFile(openRouterModelsFilePath, JSON.stringify(models))
+			Logger.log("OpenRouter models fetched and saved")
+		} else {
+			throw new Error("Invalid response data when fetching OpenRouter models")
+		}
+	} catch (error) {
+		Logger.error("Error fetching OpenRouter models:", error)
+
+		// If we failed to fetch models, try to read cached models
+		const cachedModels = await controller.readOpenRouterModels()
+		if (cachedModels) {
+			models = cachedModels
+		}
+	}
+
+	// Append stealth models if any
+	const finalModels = appendClineStealthModels(models)
+
+	// Store in StateManager's in-memory cache
+	StateManager.get().setModelsCache("openRouter", finalModels)
+
+	return finalModels
+}
+
+/**
+ * Stealth models are models that are compatible with the OpenRouter API but not listed on the OpenRouter website or API.
+ */
+const CLINE_STEALTH_MODELS: Record<string, ModelInfo> = {
+	"stealth/giga-potato": {
+		name: "Giga Potato",
+		maxTokens: 8192,
+		contextWindow: 224_000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "A stealth model for testing purposes. Not a real potato.",
+	},
+}
+
+function appendClineStealthModels(currentModels: Record<string, ModelInfo>): Record<string, ModelInfo> {
+	// Create a shallow clone of the current models to avoid mutating the original object
+	const cloned = { ...currentModels }
+	for (const [modelId, modelInfo] of Object.entries(CLINE_STEALTH_MODELS)) {
+		if (!cloned[modelId]) {
+			cloned[modelId] = modelInfo
+		}
+	}
+	return cloned
+}
diff --git a/apps/vscode/src/core/controller/models/refreshOpenRouterModelsRpc.ts b/apps/vscode/src/core/controller/models/refreshOpenRouterModelsRpc.ts
new file mode 100644
index 0000000..0824b00
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshOpenRouterModelsRpc.ts
@@ -0,0 +1,21 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import type { Controller } from "../index"
+import { refreshOpenRouterModels } from "./refreshOpenRouterModels"
+
+/**
+ * Refreshes OpenRouter models and returns protobuf types for gRPC
+ * @param controller The controller instance
+ * @param request Empty request (unused but required for gRPC signature)
+ * @returns OpenRouterCompatibleModelInfo with protobuf types
+ */
+export async function refreshOpenRouterModelsRpc(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshOpenRouterModels(controller)
+	return OpenRouterCompatibleModelInfo.create({
+		models: toProtobufModels(models),
+	})
+}
diff --git a/apps/vscode/src/core/controller/models/refreshRequestyModels.ts b/apps/vscode/src/core/controller/models/refreshRequestyModels.ts
new file mode 100644
index 0000000..9cd6387
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshRequestyModels.ts
@@ -0,0 +1,63 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import axios from "axios"
+import { toRequestyServiceUrl } from "@/shared/clients/requesty"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Refreshes the Requesty models and returns the updated model list
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing the Requesty models
+ */
+export async function refreshRequestyModels(controller: Controller, _: EmptyRequest): Promise<OpenRouterCompatibleModelInfo> {
+	const parsePrice = (price: any) => {
+		if (price) {
+			return parseFloat(price) * 1_000_000
+		}
+		return undefined
+	}
+
+	const models: Record<string, OpenRouterModelInfo> = {}
+	try {
+		const apiKey = controller.stateManager.getSecretKey("requestyApiKey")
+		const baseUrl = controller.stateManager.getGlobalSettingsKey("requestyBaseUrl")
+
+		const resolvedUrl = toRequestyServiceUrl(baseUrl)
+		const url = resolvedUrl != null ? new URL(`${resolvedUrl.pathname}/models`, resolvedUrl).toString() : undefined
+
+		if (url == null) {
+			throw new Error("URL is not valid.")
+		}
+
+		const headers = {
+			Authorization: `Bearer ${apiKey}`,
+		}
+		const response = await axios.get(url, { headers, ...getAxiosSettings() })
+		if (response.data?.data) {
+			for (const model of response.data.data) {
+				const modelInfo: OpenRouterModelInfo = OpenRouterModelInfo.create({
+					maxTokens: model.max_output_tokens || undefined,
+					contextWindow: model.context_window,
+					supportsImages: model.supports_vision || undefined,
+					supportsPromptCache: model.supports_caching || undefined,
+					inputPrice: parsePrice(model.input_price) || 0,
+					outputPrice: parsePrice(model.output_price) || 0,
+					cacheWritesPrice: parsePrice(model.caching_price) || 0,
+					cacheReadsPrice: parsePrice(model.cached_price) || 0,
+					description: model.description,
+				})
+				models[model.id] = modelInfo
+			}
+			Logger.log("Requesty models fetched", models)
+		} else {
+			Logger.error("Invalid response from Requesty API")
+		}
+	} catch (error) {
+		Logger.error("Error fetching Requesty models:", error)
+	}
+
+	return OpenRouterCompatibleModelInfo.create({ models })
+}
diff --git a/apps/vscode/src/core/controller/models/refreshVercelAiGatewayModels.ts b/apps/vscode/src/core/controller/models/refreshVercelAiGatewayModels.ts
new file mode 100644
index 0000000..712a7ea
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshVercelAiGatewayModels.ts
@@ -0,0 +1,195 @@
+import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import { ModelInfo } from "@shared/api"
+import { fileExistsAtPath } from "@utils/fs"
+import axios from "axios"
+import fs from "fs/promises"
+import path from "path"
+import { StateManager } from "@/core/storage/StateManager"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Derives thinkingConfig from model ID and tags.
+ * The Vercel API only provides a "reasoning" tag to indicate support,
+ * so we derive the specific configuration based on model patterns.
+ */
+function deriveThinkingConfig(modelId: string, tags?: string[]): ModelInfo["thinkingConfig"] {
+	if (!tags?.includes("reasoning")) {
+		return undefined
+	}
+
+	// Anthropic Claude models
+	if (modelId.startsWith("anthropic/claude")) {
+		return { maxBudget: 8192 }
+	}
+
+	// Google Gemini models
+	if (modelId.includes("gemini-3")) {
+		return {
+			maxBudget: 32767,
+			supportsThinkingLevel: true,
+			geminiThinkingLevel: "high",
+		}
+	}
+
+	// DeepSeek R1 models
+	if (modelId.startsWith("deepseek/deepseek-r1")) {
+		return { maxBudget: 8192 }
+	}
+
+	// OpenAI o-series reasoning models
+	if (modelId.startsWith("openai/o1") || modelId.startsWith("openai/o3")) {
+		return { maxBudget: 32000 }
+	}
+
+	// Qwen QwQ models (specific IDs to match OpenRouter)
+	if (modelId === "qwen/qwq-32b:free" || modelId === "qwen/qwq-32b") {
+		return { maxBudget: 32000 }
+	}
+
+	// Default for other reasoning models
+	return { maxBudget: 32000 }
+}
+
+/**
+ * Derives recommended temperature for specific model types.
+ * Returns undefined to use the default (0).
+ */
+function deriveTemperature(modelId: string): number | undefined {
+	// DeepSeek R1 and similar reasoning models recommend 0.7
+	// Use specific model IDs to match OpenRouter behavior
+	if (
+		modelId.startsWith("deepseek/deepseek-r1") ||
+		modelId === "perplexity/sonar-reasoning" ||
+		modelId === "qwen/qwq-32b:free" ||
+		modelId === "qwen/qwq-32b"
+	) {
+		return 0.7
+	}
+
+	// Gemini 3 models recommend temperature 1.0
+	if (modelId.startsWith("google/gemini-3")) {
+		return 1.0
+	}
+
+	return undefined
+}
+
+// Track pending refresh promise to prevent duplicate concurrent fetches
+let pendingRefresh: Promise<Record<string, ModelInfo>> | null = null
+
+/**
+ * Core function: Refreshes Vercel AI Gateway models and returns application types
+ * @param _controller The controller instance (unused)
+ * @returns Record of model ID to ModelInfo (application types)
+ */
+// TODO(sdk-consolidation): Live-fetches Vercel AI Gateway's /models endpoint and
+// parses live pricing/context/thinking config. The SDK's generic models-URL
+// fetcher returns ids-only and (for providers with a registered modelsSourceUrl)
+// REPLACES rather than merges the curated catalog, so a naive migration would
+// regress metadata. See the detailed note in refreshGroqModels.ts; share via the
+// SDK + delete this handler + RPC once the SDK supports rich/merged per-provider
+// live models for all clients (incl. CLI).
+export async function refreshVercelAiGatewayModels(_controller: Controller): Promise<Record<string, ModelInfo>> {
+	// Check in-memory cache first
+	const cache = StateManager.get().getModelsCache("vercel")
+	if (cache) {
+		return cache
+	}
+
+	// If a fetch is already in progress, return the same promise
+	if (pendingRefresh) {
+		return pendingRefresh
+	}
+
+	// Start new fetch and track the promise
+	pendingRefresh = (async () => {
+		try {
+			return await fetchAndCacheModels()
+		} finally {
+			// Clear pending promise when done (success or error)
+			pendingRefresh = null
+		}
+	})()
+
+	return pendingRefresh
+}
+
+async function fetchAndCacheModels(): Promise<Record<string, ModelInfo>> {
+	const vercelAiGatewayModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.vercelAiGatewayModels)
+
+	let models: Record<string, ModelInfo> = {}
+
+	try {
+		const response = await axios.get("https://ai-gateway.vercel.sh/v1/models?include_mappings=true", getAxiosSettings())
+
+		if (response.data?.data) {
+			const rawModels = response.data.data
+			const parsePrice = (price: any) => {
+				if (price) {
+					return Number.parseFloat(price) * 1_000_000
+				}
+				return undefined
+			}
+
+			for (const rawModel of rawModels) {
+				if (rawModel.type === "embedding") {
+					continue
+				}
+
+				const modelInfo: ModelInfo = {
+					maxTokens: rawModel.max_tokens ?? 0,
+					contextWindow: rawModel.context_window ?? 0,
+					inputPrice: parsePrice(rawModel.pricing?.input) ?? 0,
+					outputPrice: parsePrice(rawModel.pricing?.output) ?? 0,
+					cacheWritesPrice: parsePrice(rawModel.pricing?.input_cache_write) ?? 0,
+					cacheReadsPrice: parsePrice(rawModel.pricing?.input_cache_read) ?? 0,
+					supportsImages: true, // assume all models support images since vercel ai doesn't give this info
+					supportsPromptCache: !!(rawModel.pricing?.input_cache_read && rawModel.pricing?.input_cache_write),
+					description: rawModel.description ?? "",
+					thinkingConfig: deriveThinkingConfig(rawModel.id, rawModel.tags),
+					temperature: deriveTemperature(rawModel.id),
+				}
+
+				models[rawModel.id] = modelInfo
+			}
+
+			await fs.writeFile(vercelAiGatewayModelsFilePath, JSON.stringify(models))
+			Logger.log("Vercel AI Gateway models fetched and saved")
+		} else {
+			throw new Error("Invalid response from Vercel AI Gateway API")
+		}
+	} catch (error) {
+		Logger.error("Error fetching Vercel AI Gateway models:", error)
+
+		// If we failed to fetch models, try to read cached models
+		const cachedModels = await readVercelAiGatewayModels()
+		if (cachedModels) {
+			models = cachedModels
+		}
+	}
+
+	// Store in StateManager's in-memory cache
+	StateManager.get().setModelsCache("vercel", models)
+
+	return models
+}
+
+/**
+ * Reads cached Vercel AI Gateway models from disk (application types)
+ */
+async function readVercelAiGatewayModels(): Promise<Record<string, ModelInfo> | undefined> {
+	const vercelAiGatewayModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.vercelAiGatewayModels)
+	const fileExists = await fileExistsAtPath(vercelAiGatewayModelsFilePath)
+	if (fileExists) {
+		try {
+			const fileContents = await fs.readFile(vercelAiGatewayModelsFilePath, "utf8")
+			return JSON.parse(fileContents)
+		} catch (error) {
+			Logger.error("Error reading cached Vercel AI Gateway models:", error)
+			return undefined
+		}
+	}
+	return undefined
+}
diff --git a/apps/vscode/src/core/controller/models/refreshVercelAiGatewayModelsRpc.ts b/apps/vscode/src/core/controller/models/refreshVercelAiGatewayModelsRpc.ts
new file mode 100644
index 0000000..6b36b7b
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/refreshVercelAiGatewayModelsRpc.ts
@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshVercelAiGatewayModels } from "./refreshVercelAiGatewayModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing Vercel AI Gateway models (protobuf types)
+ */
+export async function refreshVercelAiGatewayModelsRpc(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshVercelAiGatewayModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}
diff --git a/apps/vscode/src/core/controller/models/resolveModelInfo.ts b/apps/vscode/src/core/controller/models/resolveModelInfo.ts
new file mode 100644
index 0000000..7893f6b
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/resolveModelInfo.ts
@@ -0,0 +1,129 @@
+import type { ProviderModelsResult } from "@/sdk/model-catalog/contracts"
+import { providerAllowsCustomModelIds } from "@/sdk/model-catalog/custom-model-ids"
+import { ResolveModelInfoRequest, ResolveModelInfoResponse } from "@/shared/proto/cline/models"
+import { toProtobufModelInfo } from "@/shared/proto-conversions/models/typeConversion"
+import { type ProviderCatalogController, parseProviderIdRequest } from "./providerCatalogShared"
+
+/**
+ * Resolve a single (provider, model) pair for the webview's status /
+ * summary surfaces (`useNormalizedApiConfiguration`, TaskHeader,
+ * context-window indicator, etc.).
+ *
+ * Resolution order:
+ *
+ *   1. Committed selection — the user's most-recently-chosen plan/act
+ *      selection in the provider config store. This is the source of
+ *      truth for dynamic-list providers (openrouter, openai-compatible,
+ *      ollama, lmstudio, requesty, litellm, …) where the picker writes
+ *      the live `ModelInfo` into the selection when the user commits.
+ *
+ *   2. Catalog peek — a non-fetching look-up of the catalog cache for
+ *      the provider's current effective config fingerprint. Hits when
+ *      the catalog has been populated for the current config, either
+ *      by the settings UI opening or by a prior call to this handler.
+ *
+ *   3. Awaited catalog resolve — if the peek misses, awaits
+ *      `catalog.resolveModels(providerId)` so the response carries
+ *      authoritative data the first time it is asked. The catalog has
+ *      in-flight dedup and a per-fingerprint cache, so subsequent
+ *      callers do not pay this cost again.
+ *
+ * If after all three steps neither the committed selection nor the
+ * SDK catalog has anything to say, the handler returns
+ * `source: "unknown"`. Webview consumers render that as a neutral
+ * placeholder rather than fabricating a model info.
+ */
+export async function resolveModelInfo(
+	controller: ProviderCatalogController,
+	request: ResolveModelInfoRequest,
+): Promise<ResolveModelInfoResponse> {
+	const providerId = parseProviderIdRequest(request.providerId)
+	const requestedModelId = request.modelId?.trim() || ""
+
+	const store = controller.getProviderConfigStore()
+	if (requestedModelId) {
+		const actSelection = store.readSelection(providerId, "act")
+		if (actSelection?.modelId === requestedModelId) {
+			return ResolveModelInfoResponse.create({
+				providerId,
+				modelId: actSelection.modelId,
+				modelInfo: toProtobufModelInfo(actSelection.modelInfo),
+				source: "committed-selection",
+			})
+		}
+
+		const planSelection = store.readSelection(providerId, "plan")
+		if (planSelection?.modelId === requestedModelId) {
+			return ResolveModelInfoResponse.create({
+				providerId,
+				modelId: planSelection.modelId,
+				modelInfo: toProtobufModelInfo(planSelection.modelInfo),
+				source: "committed-selection",
+			})
+		}
+	}
+
+	// Custom-model-id providers (openai-compatible, ollama, lmstudio, litellm)
+	// accept arbitrary user-supplied model ids that the SDK catalog does not
+	// list. For these, a catalog lookup must only count as a hit when it matches
+	// the requested id; an unrecognized id is the user's own model and must be
+	// preserved rather than replaced with the catalog default.
+	const allowCustomModelIds = providerAllowsCustomModelIds(providerId)
+
+	const catalog = controller.getProviderCatalog()
+	const cached = catalog.peekModels(providerId)
+	if (cached?.ok) {
+		const hit = pickFromCatalog(cached, requestedModelId, allowCustomModelIds)
+		if (hit) {
+			return ResolveModelInfoResponse.create({
+				providerId,
+				modelId: hit.modelId,
+				modelInfo: toProtobufModelInfo(hit.modelInfo),
+				source: hit.matchedRequested ? "sdk-known-models" : "sdk-default",
+			})
+		}
+	}
+
+	// Cache miss. Await a real resolve so the caller doesn't have to
+	// retry or race a warmer. The catalog dedup'\''s in-flight requests
+	// and caches the result, so the per-fingerprint cost is paid once.
+	const resolved = await catalog.resolveModels(providerId).catch(() => undefined)
+	if (resolved?.ok) {
+		const hit = pickFromCatalog(resolved, requestedModelId, allowCustomModelIds)
+		if (hit) {
+			return ResolveModelInfoResponse.create({
+				providerId,
+				modelId: hit.modelId,
+				modelInfo: toProtobufModelInfo(hit.modelInfo),
+				source: hit.matchedRequested ? "sdk-known-models" : "sdk-default",
+			})
+		}
+	}
+
+	return ResolveModelInfoResponse.create({
+		providerId,
+		modelId: requestedModelId,
+		source: "unknown",
+	})
+}
+
+function pickFromCatalog(
+	result: Extract<ProviderModelsResult, { ok: true }>,
+	requestedModelId: string,
+	allowCustomModelIds: boolean,
+) {
+	const matchedRequested = Boolean(requestedModelId) && result.models.has(requestedModelId)
+
+	// For custom-model-id providers, never substitute the catalog default for an
+	// unrecognized requested id — the user's id is authoritative.
+	if (allowCustomModelIds && requestedModelId && !matchedRequested) {
+		return undefined
+	}
+
+	const modelId = matchedRequested ? requestedModelId : result.defaultModelId
+	const modelInfo = modelId ? result.models.get(modelId) : undefined
+	if (!modelId || !modelInfo) {
+		return undefined
+	}
+	return { modelId, modelInfo, matchedRequested: requestedModelId === modelId }
+}
diff --git a/apps/vscode/src/core/controller/models/resolveProviderModels.ts b/apps/vscode/src/core/controller/models/resolveProviderModels.ts
new file mode 100644
index 0000000..f6559b5
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/resolveProviderModels.ts
@@ -0,0 +1,12 @@
+import { ProviderModelsResponse, ResolveProviderModelsRequest } from "@/shared/proto/cline/models"
+import { type ProviderCatalogController, parseProviderIdRequest, toProviderModelsResponse } from "./providerCatalogShared"
+
+export async function resolveProviderModels(
+	controller: ProviderCatalogController,
+	request: ResolveProviderModelsRequest,
+): Promise<ProviderModelsResponse> {
+	const providerId = parseProviderIdRequest(request.providerId)
+	const requestId = request.requestId?.trim() || crypto.randomUUID()
+	const result = await controller.getProviderCatalog().resolveModels(providerId, { forceRefresh: request.forceRefresh })
+	return toProviderModelsResponse(providerId, requestId, result)
+}
diff --git a/apps/vscode/src/core/controller/models/subscribeToLiteLlmModels.ts b/apps/vscode/src/core/controller/models/subscribeToLiteLlmModels.ts
new file mode 100644
index 0000000..f58f4f5
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/subscribeToLiteLlmModels.ts
@@ -0,0 +1,57 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active LiteLLM models subscriptions
+const activeLiteLlmModelsSubscriptions = new Set<StreamingResponseHandler<OpenRouterCompatibleModelInfo>>()
+
+/**
+ * Subscribe to LiteLLM models events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToLiteLlmModels(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<OpenRouterCompatibleModelInfo>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeLiteLlmModelsSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeLiteLlmModelsSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "liteLlmModels_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a LiteLLM models event to all active subscribers
+ * @param models The LiteLLM models to send
+ */
+export async function sendLiteLlmModelsEvent(models: OpenRouterCompatibleModelInfo): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeLiteLlmModelsSubscriptions).map(async (responseStream) => {
+		try {
+			await responseStream(
+				models,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending LiteLLM models event:", error)
+			// Remove the subscription if there was an error
+			activeLiteLlmModelsSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/models/subscribeToOpenRouterModels.ts b/apps/vscode/src/core/controller/models/subscribeToOpenRouterModels.ts
new file mode 100644
index 0000000..ee62eb2
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/subscribeToOpenRouterModels.ts
@@ -0,0 +1,58 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active OpenRouter models subscriptions
+const activeOpenRouterModelsSubscriptions = new Set<StreamingResponseHandler<OpenRouterCompatibleModelInfo>>()
+
+/**
+ * Subscribe to OpenRouter models events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToOpenRouterModels(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<OpenRouterCompatibleModelInfo>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeOpenRouterModelsSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeOpenRouterModelsSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "openRouterModels_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send an OpenRouter models event to all active subscribers
+ * @param models The OpenRouter models to send
+ */
+export async function sendOpenRouterModelsEvent(models: OpenRouterCompatibleModelInfo): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeOpenRouterModelsSubscriptions).map(async (responseStream) => {
+		try {
+			await responseStream(
+				models,
+				false, // Not the last message
+			)
+			Logger.log("[DEBUG] sending OpenRouter models event")
+		} catch (error) {
+			Logger.error("Error sending OpenRouter models event:", error)
+			// Remove the subscription if there was an error
+			activeOpenRouterModelsSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/models/taskApiModel.ts b/apps/vscode/src/core/controller/models/taskApiModel.ts
new file mode 100644
index 0000000..6a51525
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/taskApiModel.ts
@@ -0,0 +1,35 @@
+import type { ApiConfiguration, ApiProvider } from "@/shared/api"
+import { getProviderDefaultModelId, getProviderModelIdKey } from "@/shared/storage/provider-keys"
+import type { Mode } from "@/shared/storage/types"
+
+type TaskApiModel = {
+	getModel: () => { id: string }
+}
+
+function readString(config: ApiConfiguration, key: keyof ApiConfiguration): string | undefined {
+	const value = config[key]
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
+}
+
+export function resolveActiveModelIdFromApiConfiguration(config: ApiConfiguration, mode: Mode): string {
+	const provider = mode === "plan" ? config.planModeApiProvider : config.actModeApiProvider
+	const genericModelKey = mode === "plan" ? "planModeApiModelId" : "actModeApiModelId"
+
+	if (provider) {
+		const providerModelKey = getProviderModelIdKey(provider as ApiProvider, mode) as keyof ApiConfiguration
+		return (
+			readString(config, providerModelKey) ??
+			readString(config, genericModelKey) ??
+			getProviderDefaultModelId(provider as ApiProvider) ??
+			"unknown"
+		)
+	}
+
+	return readString(config, genericModelKey) ?? "unknown"
+}
+
+export function createTaskApiModelShim(modelId: string): TaskApiModel {
+	return {
+		getModel: () => ({ id: modelId }),
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/updateApiConfiguration.ts b/apps/vscode/src/core/controller/models/updateApiConfiguration.ts
new file mode 100644
index 0000000..82d540f
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/updateApiConfiguration.ts
@@ -0,0 +1,166 @@
+import { Empty } from "@shared/proto/cline/common"
+import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { ApiHandlerOptions, ApiProvider } from "@/shared/api"
+import { UpdateApiConfigurationRequestNew } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { Secrets } from "@/shared/storage/state-keys"
+import type { Controller } from "../index"
+import { clearOrganizationForClinePassProviderSelection } from "./handleClinePassProviderSelection"
+import { normalizeProviderSwitchModel } from "./providerSwitchNormalization"
+import { createTaskApiModelShim, resolveActiveModelIdFromApiConfiguration } from "./taskApiModel"
+
+/**
+ * Parses field mask paths into separate sets for options and secrets
+ * @param updateMask Array of field mask paths (e.g., ["options.ulid", "options.openAiHeaders", "secrets.apiKey"])
+ * @returns Object with options and secrets field name sets
+ */
+function parseFieldMask(updateMask: string[]): {
+	options: Set<string>
+	secrets: Set<string>
+} {
+	const options = new Set<string>()
+	const secrets = new Set<string>()
+
+	for (const path of updateMask) {
+		const [prefix, fieldName] = path.split(".", 2)
+		if (prefix === "options" && fieldName) {
+			options.add(fieldName)
+		} else if (prefix === "secrets" && fieldName) {
+			secrets.add(fieldName)
+		} else {
+			throw new Error(`Invalid field mask path: ${path}`)
+		}
+	}
+
+	return { options, secrets }
+}
+
+/**
+ * Gets the alternate mode field name (e.g., planModeX <-> actModeX)
+ * @param fieldName The field name to get alternate for
+ * @returns The alternate mode field name or null if not a mode-specific field
+ */
+function getAlternateModeField(fieldName: string): string | null {
+	if (fieldName.startsWith("planMode")) {
+		return fieldName.replace("planMode", "actMode")
+	}
+	if (fieldName.startsWith("actMode")) {
+		return fieldName.replace("actMode", "planMode")
+	}
+	return null
+}
+
+/**
+ * Updates API configuration using field mask
+ * @param controller The controller instance
+ * @param request The update API configuration request with field mask
+ * @returns Empty response
+ */
+export async function updateApiConfiguration(controller: Controller, request: UpdateApiConfigurationRequestNew): Promise<Empty> {
+	try {
+		const { updates, updateMask } = request
+
+		if (!updates) {
+			throw new Error("API configuration is required")
+		}
+
+		if (!updateMask || updateMask.length === 0) {
+			throw new Error("Update mask is required and must contain at least one path")
+		}
+
+		const { options: protoOptions, secrets: protoSecrets } = updates
+
+		// Parse the field mask to determine which fields to update
+		const { options: maskOptionsFields, secrets: maskSecretsFields } = parseFieldMask(updateMask)
+
+		// Process secrets based on field mask
+		const secrets: Partial<Secrets> = {}
+
+		if (protoSecrets && maskSecretsFields.size > 0) {
+			// Validate all masked fields exist
+			for (const fieldName of maskSecretsFields) {
+				if (!(fieldName in protoSecrets)) {
+					throw new Error(`Field "${fieldName}" specified in mask but not found in secrets`)
+				}
+			}
+			// Process entries that are in the mask
+			for (const [key, value] of Object.entries(protoSecrets)) {
+				if (maskSecretsFields.has(key)) {
+					secrets[key as keyof Secrets] = value
+				}
+			}
+		}
+
+		// Process options based on field mask
+		const options: Partial<ApiHandlerOptions> & { planModeApiProvider?: ApiProvider; actModeApiProvider?: ApiProvider } = {}
+		if (protoOptions && maskOptionsFields.size > 0) {
+			// Validate all masked fields exist
+			for (const fieldName of maskOptionsFields) {
+				if (!(fieldName in protoOptions)) {
+					throw new Error(`Field "${fieldName}" specified in mask but not found in options`)
+				}
+			}
+
+			// Check if mode-specific configurations should be kept separate
+			const separateModeConfigs = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+
+			// Process entries that are in the mask
+			for (const [key, value] of Object.entries(protoOptions)) {
+				if (maskOptionsFields.has(key)) {
+					// Handle enum conversions
+					if (key === "planModeApiProvider") {
+						options.planModeApiProvider = convertProtoToApiProvider(value)
+					} else if (key === "actModeApiProvider") {
+						options.actModeApiProvider = convertProtoToApiProvider(value)
+					} else {
+						options[key as keyof ApiHandlerOptions] = value
+					}
+
+					// If mode configs should be synced, also update the alternate mode field
+					if (!separateModeConfigs) {
+						const alternateField = getAlternateModeField(key)
+						if (alternateField) {
+							if (alternateField === "planModeApiProvider") {
+								options.planModeApiProvider = convertProtoToApiProvider(value)
+							} else if (alternateField === "actModeApiProvider") {
+								options.actModeApiProvider = convertProtoToApiProvider(value)
+							} else {
+								options[alternateField as keyof ApiHandlerOptions] = value
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Update storage using batch methods
+		if (Object.keys(secrets).length > 0) {
+			controller.stateManager.setSecretsBatch(secrets)
+		}
+		if (Object.keys(options).length > 0) {
+			controller.stateManager.setGlobalStateBatch(
+				normalizeProviderSwitchModel(
+					controller.getProviderConfigStore(),
+					controller.stateManager.getApiConfiguration(),
+					options,
+				),
+			)
+			await clearOrganizationForClinePassProviderSelection(controller, controller.stateManager.getApiConfiguration())
+		}
+
+		// Update the task's API model shim if there's an active task
+		if (controller.task) {
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+			const modelId = resolveActiveModelIdFromApiConfiguration(controller.stateManager.getApiConfiguration(), currentMode)
+			controller.task.api = createTaskApiModelShim(modelId)
+		}
+
+		// Post updated state to webview
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error(`Failed to update API configuration: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/updateApiConfigurationPartial.ts b/apps/vscode/src/core/controller/models/updateApiConfigurationPartial.ts
new file mode 100644
index 0000000..f78264d
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/updateApiConfigurationPartial.ts
@@ -0,0 +1,64 @@
+import { Empty } from "@shared/proto/cline/common"
+import { UpdateApiConfigurationPartialRequest } from "@shared/proto/cline/models"
+import { convertProtoToApiConfiguration } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+import { clearOrganizationForClinePassProviderSelection } from "./handleClinePassProviderSelection"
+import { normalizeProviderSwitchModel } from "./providerSwitchNormalization"
+import { createTaskApiModelShim, resolveActiveModelIdFromApiConfiguration } from "./taskApiModel"
+
+/**
+ * Updates API configuration with partial values using FieldMask
+ *
+ * Allows clients to update individual API configuration fields without
+ * overwriting the entire configuration. Only fields specified in the update_mask
+ * are updated from api_configuration.
+ *
+ * @param controller The controller instance
+ * @param request The partial update API configuration request with FieldMask
+ * @returns Empty response
+ */
+export async function updateApiConfigurationPartial(
+	controller: Controller,
+	request: UpdateApiConfigurationPartialRequest,
+): Promise<Empty> {
+	try {
+		// Validate request
+		if (!request.updateMask || request.updateMask.length === 0) {
+			throw new Error("update_mask is required and must contain at least one field")
+		}
+
+		if (!request.apiConfiguration) {
+			throw new Error("api_configuration is required")
+		}
+
+		// Get current config and convert new values from proto format
+		const currentConfig = controller.stateManager.getApiConfiguration()
+		const newConfigValues = convertProtoToApiConfiguration(request.apiConfiguration)
+
+		// Apply only the fields specified in the mask
+		const updatedConfig = { ...currentConfig }
+		for (const field of request.updateMask) {
+			;(updatedConfig as Record<string, any>)[field] = (newConfigValues as Record<string, any>)[field]
+		}
+		const normalizedConfig = normalizeProviderSwitchModel(controller.getProviderConfigStore(), currentConfig, updatedConfig)
+
+		// Update storage and task API model shim
+		controller.stateManager.setApiConfiguration(normalizedConfig)
+		await clearOrganizationForClinePassProviderSelection(controller, normalizedConfig)
+		if (controller.task) {
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+			const modelId = resolveActiveModelIdFromApiConfiguration(normalizedConfig, currentMode)
+			controller.task.api = createTaskApiModelShim(modelId)
+		}
+		controller.handleApiConfigurationChanged(currentConfig, normalizedConfig)
+
+		// Notify webview
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error(`Failed to update API configuration (partial): ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/updateApiConfigurationProto.ts b/apps/vscode/src/core/controller/models/updateApiConfigurationProto.ts
new file mode 100644
index 0000000..9ec3f8a
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/updateApiConfigurationProto.ts
@@ -0,0 +1,162 @@
+import { Empty } from "@shared/proto/cline/common"
+import type { UpdateApiConfigurationRequest } from "@shared/proto/cline/models"
+import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
+import {
+	fromProtobufLiteLLMModelInfo,
+	fromProtobufModelInfo,
+	fromProtobufOcaModelInfo,
+	fromProtobufOpenAiCompatibleModelInfo,
+} from "@shared/proto-conversions/models/typeConversion"
+import { OpenaiReasoningEffort } from "@shared/storage/types"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+import { clearOrganizationForClinePassProviderSelection } from "./handleClinePassProviderSelection"
+import { normalizeProviderSwitchModel } from "./providerSwitchNormalization"
+import { createTaskApiModelShim, resolveActiveModelIdFromApiConfiguration } from "./taskApiModel"
+
+/**
+ * Updates API configuration
+ * @param controller The controller instance
+ * @param request The update API configuration request
+ * @returns Empty response
+ */
+export async function updateApiConfigurationProto(
+	controller: Controller,
+	request: UpdateApiConfigurationRequest,
+): Promise<Empty> {
+	try {
+		if (!request.apiConfiguration) {
+			Logger.log("[APICONFIG: updateApiConfigurationProto] API configuration is required")
+			throw new Error("API configuration is required")
+		}
+
+		const protoApiConfiguration = request.apiConfiguration
+
+		const convertedApiConfigurationFromProto = {
+			...protoApiConfiguration,
+			// Convert proto ApiProvider enums to native string types
+			planModeApiProvider:
+				protoApiConfiguration.planModeApiProvider !== undefined
+					? convertProtoToApiProvider(protoApiConfiguration.planModeApiProvider!)
+					: undefined,
+			actModeApiProvider:
+				protoApiConfiguration.actModeApiProvider !== undefined
+					? convertProtoToApiProvider(protoApiConfiguration.actModeApiProvider!)
+					: undefined,
+
+			// Convert ModelInfo objects (empty arrays → undefined)
+			// Plan Mode
+			planModeOpenRouterModelInfo: protoApiConfiguration.planModeOpenRouterModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeOpenRouterModelInfo)
+				: undefined,
+			planModeClineModelInfo: protoApiConfiguration.planModeClineModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeClineModelInfo)
+				: undefined,
+			planModeClinePassModelInfo: protoApiConfiguration.planModeClinePassModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeClinePassModelInfo)
+				: undefined,
+			planModeOpenAiModelInfo: protoApiConfiguration.planModeOpenAiModelInfo
+				? fromProtobufOpenAiCompatibleModelInfo(protoApiConfiguration.planModeOpenAiModelInfo)
+				: undefined,
+			planModeHuggingFaceModelInfo: protoApiConfiguration.planModeHuggingFaceModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeHuggingFaceModelInfo)
+				: undefined,
+			planModeLiteLlmModelInfo: protoApiConfiguration.planModeLiteLlmModelInfo
+				? fromProtobufLiteLLMModelInfo(protoApiConfiguration.planModeLiteLlmModelInfo)
+				: undefined,
+			planModeRequestyModelInfo: protoApiConfiguration.planModeRequestyModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeRequestyModelInfo)
+				: undefined,
+			planModeGroqModelInfo: protoApiConfiguration.planModeGroqModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeGroqModelInfo)
+				: undefined,
+			planModeHuaweiCloudMaasModelInfo: protoApiConfiguration.planModeHuaweiCloudMaasModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeHuaweiCloudMaasModelInfo)
+				: undefined,
+			planModeBasetenModelInfo: protoApiConfiguration.planModeBasetenModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeBasetenModelInfo)
+				: undefined,
+			planModeVercelAiGatewayModelInfo: protoApiConfiguration.planModeVercelAiGatewayModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.planModeVercelAiGatewayModelInfo)
+				: undefined,
+			planModeOcaModelInfo: protoApiConfiguration.planModeOcaModelInfo
+				? fromProtobufOcaModelInfo(protoApiConfiguration.planModeOcaModelInfo)
+				: undefined,
+			planModeAihubmixModelInfo: protoApiConfiguration.planModeAihubmixModelInfo
+				? fromProtobufOpenAiCompatibleModelInfo(protoApiConfiguration.planModeAihubmixModelInfo)
+				: undefined,
+
+			// Act Mode
+			actModeOpenRouterModelInfo: protoApiConfiguration.actModeOpenRouterModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeOpenRouterModelInfo)
+				: undefined,
+			actModeClineModelInfo: protoApiConfiguration.actModeClineModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeClineModelInfo)
+				: undefined,
+			actModeClinePassModelInfo: protoApiConfiguration.actModeClinePassModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeClinePassModelInfo)
+				: undefined,
+			actModeOpenAiModelInfo: protoApiConfiguration.actModeOpenAiModelInfo
+				? fromProtobufOpenAiCompatibleModelInfo(protoApiConfiguration.actModeOpenAiModelInfo)
+				: undefined,
+			actModeLiteLlmModelInfo: protoApiConfiguration.actModeLiteLlmModelInfo
+				? fromProtobufLiteLLMModelInfo(protoApiConfiguration.actModeLiteLlmModelInfo)
+				: undefined,
+			actModeRequestyModelInfo: protoApiConfiguration.actModeRequestyModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeRequestyModelInfo)
+				: undefined,
+			actModeGroqModelInfo: protoApiConfiguration.actModeGroqModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeGroqModelInfo)
+				: undefined,
+			actModeHuggingFaceModelInfo: protoApiConfiguration.actModeHuggingFaceModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeHuggingFaceModelInfo)
+				: undefined,
+			actModeHuaweiCloudMaasModelInfo: protoApiConfiguration.actModeHuaweiCloudMaasModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeHuaweiCloudMaasModelInfo)
+				: undefined,
+			actModeBasetenModelInfo: protoApiConfiguration.actModeBasetenModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeBasetenModelInfo)
+				: undefined,
+			actModeVercelAiGatewayModelInfo: protoApiConfiguration.actModeVercelAiGatewayModelInfo
+				? fromProtobufModelInfo(protoApiConfiguration.actModeVercelAiGatewayModelInfo)
+				: undefined,
+			actModeOcaModelInfo: protoApiConfiguration.actModeOcaModelInfo
+				? fromProtobufOcaModelInfo(protoApiConfiguration.actModeOcaModelInfo)
+				: undefined,
+			actModeAihubmixModelInfo: protoApiConfiguration.actModeAihubmixModelInfo
+				? fromProtobufOpenAiCompatibleModelInfo(protoApiConfiguration.actModeAihubmixModelInfo)
+				: undefined,
+			geminiPlanModeThinkingLevel: protoApiConfiguration.geminiPlanModeThinkingLevel,
+			geminiActModeThinkingLevel: protoApiConfiguration.geminiActModeThinkingLevel,
+			planModeReasoningEffort: protoApiConfiguration.planModeReasoningEffort as OpenaiReasoningEffort | undefined,
+			actModeReasoningEffort: protoApiConfiguration.actModeReasoningEffort as OpenaiReasoningEffort | undefined,
+		}
+
+		const previousApiConfiguration = controller.stateManager.getApiConfiguration()
+		const normalizedApiConfiguration = normalizeProviderSwitchModel(
+			controller.getProviderConfigStore(),
+			previousApiConfiguration,
+			convertedApiConfigurationFromProto,
+		)
+
+		// Update the API configuration in storage
+		controller.stateManager.setApiConfiguration(normalizedApiConfiguration)
+		await clearOrganizationForClinePassProviderSelection(controller, normalizedApiConfiguration)
+
+		// Update the task's API handler if there's an active task
+		if (controller.task) {
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+			const modelId = resolveActiveModelIdFromApiConfiguration(normalizedApiConfiguration, currentMode)
+			controller.task.api = createTaskApiModelShim(modelId)
+		}
+		controller.handleApiConfigurationChanged(previousApiConfiguration, normalizedApiConfiguration)
+
+		// Post updated state to webview
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error(`Failed to update API configuration: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/models/writeProviderConfig.ts b/apps/vscode/src/core/controller/models/writeProviderConfig.ts
new file mode 100644
index 0000000..7bab0ec
--- /dev/null
+++ b/apps/vscode/src/core/controller/models/writeProviderConfig.ts
@@ -0,0 +1,17 @@
+import { ProviderConfigResponse, WriteProviderConfigRequest } from "@/shared/proto/cline/models"
+import {
+	type ProviderCatalogController,
+	parseProviderIdRequest,
+	toProviderConfigPatch,
+	toRedactedProviderConfigResponse,
+} from "./providerCatalogShared"
+
+export async function writeProviderConfig(
+	controller: ProviderCatalogController,
+	request: WriteProviderConfigRequest,
+): Promise<ProviderConfigResponse> {
+	const providerId = parseProviderIdRequest(request.providerId)
+	const store = controller.getProviderConfigStore()
+	const updated = store.write(providerId, toProviderConfigPatch(request.patch))
+	return toRedactedProviderConfigResponse(updated, store)
+}
diff --git a/apps/vscode/src/core/controller/ocaAccount/ocaAccountLoginClicked.ts b/apps/vscode/src/core/controller/ocaAccount/ocaAccountLoginClicked.ts
new file mode 100644
index 0000000..e6a13ba
--- /dev/null
+++ b/apps/vscode/src/core/controller/ocaAccount/ocaAccountLoginClicked.ts
@@ -0,0 +1,15 @@
+import { EmptyRequest, String as ProtoString } from "@shared/proto/cline/common"
+import { OcaAuthService } from "@/services/auth/oca/OcaAuthService"
+import { Controller } from "../index"
+
+/**
+ * Handles the user clicking the login link in the UI.
+ * Generates a secure nonce for state validation, stores it in secrets,
+ * and opens the authentication URL in the external browser.
+ *
+ * @param controller The controller instance.
+ * @returns The login URL as a string.
+ */
+export async function ocaAccountLoginClicked(_controller: Controller, _: EmptyRequest): Promise<ProtoString> {
+	return await OcaAuthService.getInstance().createAuthRequest()
+}
diff --git a/apps/vscode/src/core/controller/ocaAccount/ocaAccountLogoutClicked.ts b/apps/vscode/src/core/controller/ocaAccount/ocaAccountLogoutClicked.ts
new file mode 100644
index 0000000..d596dd4
--- /dev/null
+++ b/apps/vscode/src/core/controller/ocaAccount/ocaAccountLogoutClicked.ts
@@ -0,0 +1,14 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import type { Controller } from "../index"
+
+/**
+ * Handles the account logout action
+ * @param controller The controller instance
+ * @param _request The empty request object
+ * @returns Empty response
+ */
+export async function ocaAccountLogoutClicked(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	await controller.handleOcaSignOut()
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/core/controller/ocaAccount/ocaSubscribeToAuthStatusUpdate.ts b/apps/vscode/src/core/controller/ocaAccount/ocaSubscribeToAuthStatusUpdate.ts
new file mode 100644
index 0000000..7bbd06e
--- /dev/null
+++ b/apps/vscode/src/core/controller/ocaAccount/ocaSubscribeToAuthStatusUpdate.ts
@@ -0,0 +1,14 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OcaAuthState } from "@shared/proto/cline/oca_account"
+import { OcaAuthService } from "@/services/auth/oca/OcaAuthService"
+import { Controller } from ".."
+import { StreamingResponseHandler } from "../grpc-handler"
+
+export async function ocaSubscribeToAuthStatusUpdate(
+	_controller: Controller,
+	request: EmptyRequest,
+	responseStream: StreamingResponseHandler<OcaAuthState>,
+	requestId?: string,
+): Promise<void> {
+	return OcaAuthService.getInstance().subscribeToAuthStatusUpdate(request, responseStream, requestId)
+}
diff --git a/apps/vscode/src/core/controller/remoteConfig/getRemoteConfigSettings.ts b/apps/vscode/src/core/controller/remoteConfig/getRemoteConfigSettings.ts
new file mode 100644
index 0000000..03d25b0
--- /dev/null
+++ b/apps/vscode/src/core/controller/remoteConfig/getRemoteConfigSettings.ts
@@ -0,0 +1,30 @@
+import { Controller } from "@/sdk"
+import { Empty, RemoteConfigSetting, RemoteConfigSettingsResponse, RemoteConfigType } from "@/shared/proto/index.cline"
+
+export async function getRemoteConfigSettings(controller: Controller, _request: Empty): Promise<RemoteConfigSettingsResponse> {
+	const globalRules: RemoteConfigSetting[] = (controller.remoteConfig?.globalRules || []).map((rule) => ({
+		type: RemoteConfigType.RULE,
+		name: rule.name,
+		content: rule.contents,
+		enabled: true, // TODO: Implement actual enabled state when toggle support is wired up
+		locked: Boolean(rule.alwaysEnabled),
+	}))
+	const globalWorkflows: RemoteConfigSetting[] = (controller.remoteConfig?.globalWorkflows || []).map((workflow) => ({
+		type: RemoteConfigType.WORKFLOW,
+		name: workflow.name,
+		content: workflow.contents,
+		enabled: true, // TODO: Implement actual enabled state when toggle support is wired up
+		locked: Boolean(workflow.alwaysEnabled),
+	}))
+	const managedSkills: RemoteConfigSetting[] = (controller.remoteConfigBundle?.managedInstructions || [])
+		.filter((instruction) => instruction.kind === "skill")
+		.map((skill) => ({
+			type: RemoteConfigType.SKILL,
+			name: skill.name,
+			content: skill.contents,
+			enabled: true, // TODO: Implement actual enabled state when toggle support is wired up
+			locked: Boolean(skill.alwaysEnabled),
+		}))
+
+	return RemoteConfigSettingsResponse.create({ settings: [...globalRules, ...globalWorkflows, ...managedSkills] })
+}
diff --git a/apps/vscode/src/core/controller/remoteConfig/toggleRemoteConfigSetting.ts b/apps/vscode/src/core/controller/remoteConfig/toggleRemoteConfigSetting.ts
new file mode 100644
index 0000000..6d90b02
--- /dev/null
+++ b/apps/vscode/src/core/controller/remoteConfig/toggleRemoteConfigSetting.ts
@@ -0,0 +1,12 @@
+import { Controller } from "@/sdk"
+import { RemoteConfigSetting, StringRequest } from "@/shared/proto/index.cline"
+
+export async function toggleRemoteConfigSetting(_controller: Controller, _request: StringRequest): Promise<RemoteConfigSetting> {
+	// TODO(ENG): Toggling remote config settings is not implemented yet. The
+	// `enabled` flag is currently hardcoded to `true` in getRemoteConfigSettings,
+	// so there is no per-setting enabled state to flip. When this is wired up,
+	// look up the setting by name, persist the new enabled state, and return the
+	// updated RemoteConfigSetting. Until then, reject so the caller's request
+	// completes instead of hanging forever.
+	throw new Error("toggleRemoteConfigSetting is not implemented")
+}
diff --git a/apps/vscode/src/core/controller/slash/condense.test.ts b/apps/vscode/src/core/controller/slash/condense.test.ts
new file mode 100644
index 0000000..d10660d
--- /dev/null
+++ b/apps/vscode/src/core/controller/slash/condense.test.ts
@@ -0,0 +1,21 @@
+import { strict as assert } from "node:assert"
+import { StringRequest } from "@shared/proto/cline/common"
+import { describe, it, vi } from "vitest"
+import type { Controller } from ".."
+import { condense } from "./condense"
+
+describe("condense slash handler", () => {
+	it("runs controller compaction instead of answering the old condense prompt", async () => {
+		const compactTask = vi.fn().mockResolvedValue(undefined)
+		const handleWebviewAskResponse = vi.fn()
+		const controller = {
+			compactTask,
+			task: { handleWebviewAskResponse },
+		} as unknown as Controller
+
+		await condense(controller, StringRequest.create({ value: "compact" }))
+
+		assert.equal(compactTask.mock.calls.length, 1)
+		assert.equal(handleWebviewAskResponse.mock.calls.length, 0)
+	})
+})
diff --git a/apps/vscode/src/core/controller/slash/condense.ts b/apps/vscode/src/core/controller/slash/condense.ts
new file mode 100644
index 0000000..d14f2e7
--- /dev/null
+++ b/apps/vscode/src/core/controller/slash/condense.ts
@@ -0,0 +1,16 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import type { Controller } from ".."
+
+/**
+ * Condense / compact slash command logic.
+ *
+ * Runs a real SDK manual compaction over the active task's conversation
+ * (the same effect as the CLI's `/compact` / `/smol` command), instead of
+ * sending the literal text `/compact` to the model. The model does not treat
+ * `/compact` as a command, so the old behavior produced an improvised fake
+ * summary without actually compacting the context (CLINE-2503).
+ */
+export async function condense(controller: Controller, _request: StringRequest): Promise<Empty> {
+	await controller.compactTask()
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/slash/getAvailableSlashCommands.ts b/apps/vscode/src/core/controller/slash/getAvailableSlashCommands.ts
new file mode 100644
index 0000000..0e7e881
--- /dev/null
+++ b/apps/vscode/src/core/controller/slash/getAvailableSlashCommands.ts
@@ -0,0 +1,88 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { SlashCommandInfo, SlashCommandsResponse } from "@shared/proto/cline/slash"
+import { BASE_SLASH_COMMANDS } from "@/shared/slashCommands"
+import { Controller } from ".."
+
+/**
+ * Returns all available slash commands for autocomplete.
+ */
+export async function getAvailableSlashCommands(controller: Controller, _request: EmptyRequest): Promise<SlashCommandsResponse> {
+	const commands: SlashCommandInfo[] = []
+
+	// Add built-in commands
+	for (const cmd of [...BASE_SLASH_COMMANDS]) {
+		commands.push(
+			SlashCommandInfo.create({
+				name: cmd.name,
+				description: cmd.description,
+				section: "default",
+				cliCompatible: cmd.cliCompatible,
+			}),
+		)
+	}
+
+	// Get workflow toggles from state
+	const localWorkflowToggles = controller.stateManager.getWorkspaceStateKey("workflowToggles") ?? {}
+	const globalWorkflowToggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles") ?? {}
+	const remoteWorkflowToggles = controller.stateManager.getGlobalStateKey("remoteWorkflowToggles") ?? {}
+	const remoteConfigSettings = controller.stateManager.getRemoteConfigSettings()
+	const remoteWorkflows = remoteConfigSettings?.remoteGlobalWorkflows ?? []
+
+	// Track local workflow names to avoid duplicates from global
+	const localNames = new Set<string>()
+
+	// Add local workflows (enabled only)
+	for (const [path, enabled] of Object.entries(localWorkflowToggles)) {
+		if (enabled) {
+			const fileName = fullPathToFileName(path)
+			localNames.add(fileName)
+			commands.push(
+				SlashCommandInfo.create({
+					name: fileName,
+					description: `Custom workflow: ${fileName}`,
+					section: "custom",
+					cliCompatible: true,
+				}),
+			)
+		}
+	}
+
+	// Add global workflows (enabled only, skip if local exists with same name)
+	for (const [path, enabled] of Object.entries(globalWorkflowToggles)) {
+		if (enabled) {
+			const fileName = fullPathToFileName(path)
+			if (!localNames.has(fileName)) {
+				commands.push(
+					SlashCommandInfo.create({
+						name: fileName,
+						description: `Custom workflow: ${fileName}`,
+						section: "custom",
+						cliCompatible: true,
+					}),
+				)
+			}
+		}
+	}
+
+	// Add remote workflows that are enabled
+	for (const workflow of remoteWorkflows) {
+		const enabled = workflow.alwaysEnabled || remoteWorkflowToggles[workflow.name] !== false
+		if (enabled) {
+			commands.push(
+				SlashCommandInfo.create({
+					name: workflow.name,
+					description: `Remote workflow: ${workflow.name}`,
+					section: "custom",
+					cliCompatible: true,
+				}),
+			)
+		}
+	}
+
+	return SlashCommandsResponse.create({ commands })
+}
+
+function fullPathToFileName(path: string): string {
+	// e.g. replace /path/to/workflow.md with workflow.md
+	return path.replace(/^.*[/\\]/, "")
+}
diff --git a/apps/vscode/src/core/controller/slash/reportBug.ts b/apps/vscode/src/core/controller/slash/reportBug.ts
new file mode 100644
index 0000000..964acf1
--- /dev/null
+++ b/apps/vscode/src/core/controller/slash/reportBug.ts
@@ -0,0 +1,10 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Report bug slash command logic
+ */
+export async function reportBug(controller: Controller, _request: StringRequest): Promise<Empty> {
+	await controller.task?.handleWebviewAskResponse("yesButtonClicked")
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/captureOnboardingProgress.ts b/apps/vscode/src/core/controller/state/captureOnboardingProgress.ts
new file mode 100644
index 0000000..6293fc2
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/captureOnboardingProgress.ts
@@ -0,0 +1,31 @@
+import { Empty } from "@shared/proto/cline/common"
+import { OnboardingProgressRequest } from "@shared/proto/cline/state"
+import { Logger } from "@/shared/services/Logger"
+import { telemetryService } from "../../../services/telemetry"
+import type { Controller } from "../index"
+
+/**
+ * Captures the onboarding progress step
+ * @param controller The controller instance
+ * @param request The request containing the step number
+ * @returns Empty response
+ */
+export async function captureOnboardingProgress(_controller: Controller, request: OnboardingProgressRequest): Promise<Empty> {
+	try {
+		telemetryService.captureOnboardingProgress({
+			step: Number(request.step),
+			action: request.action,
+			page: request.page,
+			pageVariant: request.pageVariant,
+			userType: request.userType,
+			selectedModelId: request.modelSelected,
+			destinationStep: request.destinationStep,
+			destinationPage: request.destinationPage,
+			completed: !!request.completed,
+		})
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("Failed to set welcome view completed:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/checkCliInstallation.ts b/apps/vscode/src/core/controller/state/checkCliInstallation.ts
new file mode 100644
index 0000000..be19ab6
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/checkCliInstallation.ts
@@ -0,0 +1,17 @@
+import { Boolean } from "@shared/proto/cline/common"
+import { isClineCliInstalled } from "@/utils/cli-detector"
+import { Controller } from ".."
+
+/**
+ * Check if the Cline CLI is installed
+ * @param controller The controller instance
+ * @returns Boolean indicating if CLI is installed
+ */
+export async function checkCliInstallation(_controller: Controller): Promise<Boolean> {
+	try {
+		const isInstalled = await isClineCliInstalled()
+		return Boolean.create({ value: isInstalled })
+	} catch {
+		return Boolean.create({ value: false })
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/dismissBanner.ts b/apps/vscode/src/core/controller/state/dismissBanner.ts
new file mode 100644
index 0000000..a9b508b
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/dismissBanner.ts
@@ -0,0 +1,26 @@
+import { BannerService } from "@/services/banner/BannerService"
+import type { StringRequest } from "@/shared/proto/cline/common"
+import { Empty } from "@/shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from ".."
+
+/**
+ * Dismisses a banner and sends telemetry
+ * @param controller The controller instance
+ * @param request The request containing the banner ID to dismiss
+ * @returns Empty response
+ */
+export async function dismissBanner(controller: Controller, request: StringRequest): Promise<Empty> {
+	const bannerId = request.value
+
+	if (!bannerId) {
+		return {}
+	}
+	try {
+		await BannerService.get().dismissBanner(bannerId)
+		await controller.postStateToWebview()
+	} catch (error) {
+		Logger.error("Failed to dismiss banner:", error)
+	}
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/state/flushPendingState.ts b/apps/vscode/src/core/controller/state/flushPendingState.ts
new file mode 100644
index 0000000..5583b3d
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/flushPendingState.ts
@@ -0,0 +1,18 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Flush all pending state changes immediately to disk
+ * Bypasses the debounced persistence and forces immediate writes
+ */
+export async function flushPendingState(controller: Controller, request: EmptyRequest): Promise<Empty> {
+	try {
+		await controller.stateManager.flushPendingState()
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("[flushPendingState] Error flushing pending state:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/getAvailableTerminalProfiles.ts b/apps/vscode/src/core/controller/state/getAvailableTerminalProfiles.ts
new file mode 100644
index 0000000..61a0e45
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/getAvailableTerminalProfiles.ts
@@ -0,0 +1,19 @@
+import * as proto from "@/shared/proto"
+import { getAvailableTerminalProfiles as getTerminalProfilesFromShell } from "../../../utils/shell"
+import { Controller } from "../index"
+
+export async function getAvailableTerminalProfiles(
+	_controller: Controller,
+	_request: proto.cline.EmptyRequest,
+): Promise<proto.cline.TerminalProfiles> {
+	const profiles = getTerminalProfilesFromShell()
+
+	return proto.cline.TerminalProfiles.create({
+		profiles: profiles.map((profile) => ({
+			id: profile.id,
+			name: profile.name,
+			path: profile.path || "",
+			description: profile.description || "",
+		})),
+	})
+}
diff --git a/apps/vscode/src/core/controller/state/getLatestState.ts b/apps/vscode/src/core/controller/state/getLatestState.ts
new file mode 100644
index 0000000..b1d2788
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/getLatestState.ts
@@ -0,0 +1,22 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { State } from "@shared/proto/cline/state"
+import { Controller } from "../index"
+
+/**
+ * Get the latest extension state
+ * @param controller The controller instance
+ * @param request The empty request
+ * @returns The current extension state
+ */
+export async function getLatestState(controller: Controller, _: EmptyRequest): Promise<State> {
+	// Get the state using the existing method
+	const state = await controller.getStateToPostToWebview()
+
+	// Convert the state to a JSON string
+	const stateJson = JSON.stringify(state)
+
+	// Return the state as a JSON string
+	return State.create({
+		stateJson,
+	})
+}
diff --git a/apps/vscode/src/core/controller/state/getProcessInfo.ts b/apps/vscode/src/core/controller/state/getProcessInfo.ts
new file mode 100644
index 0000000..2d3a242
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/getProcessInfo.ts
@@ -0,0 +1,20 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { ProcessInfo } from "@shared/proto/cline/state"
+import { Controller } from ".."
+
+/**
+ * Gets process information including PID, version, and uptime
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns ProcessInfo with process details
+ */
+export async function getProcessInfo(controller: Controller, request: EmptyRequest): Promise<ProcessInfo> {
+	// Get the current state to access the version (same source as webview)
+	const state = await controller.getStateToPostToWebview()
+
+	return ProcessInfo.create({
+		processId: process.pid,
+		version: state.version || "unknown",
+		uptimeMs: Math.floor(process.uptime() * 1000), // Convert seconds to milliseconds
+	})
+}
diff --git a/apps/vscode/src/core/controller/state/getStateToPostToWebview.ts b/apps/vscode/src/core/controller/state/getStateToPostToWebview.ts
new file mode 100644
index 0000000..5e148e4
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/getStateToPostToWebview.ts
@@ -0,0 +1,184 @@
+// Extracted from classic src/core/controller/index.ts (see origin/main)
+//
+// Standalone function to build ExtensionState from a Controller instance.
+// This allows the SdkController to reuse the classic state-building logic
+// without inheriting the entire classic Controller implementation.
+
+import { readCompactionStrategyGlobally } from "@cline/core"
+import { getHooksEnabledSafe } from "@core/hooks/hooks-utils"
+import type { ExtensionState, Platform } from "@shared/ExtensionMessage"
+import { ClineEnv } from "@/config"
+import { ExtensionRegistryInfo } from "@/registry"
+import { BannerService } from "@/services/banner/BannerService"
+import { featureFlagsService } from "@/services/feature-flags"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { getLatestAnnouncementId } from "@/utils/announcements"
+import { getClineOnboardingModels } from "../models/getClineOnboardingModels"
+
+/**
+ * Builds the ExtensionState object to push to the webview.
+ * Extracted from the classic Controller.getStateToPostToWebview().
+ */
+export async function getStateToPostToWebview(controller: {
+	task?: any
+	stateManager: any
+	mcpHub?: any
+	backgroundCommandRunning?: boolean
+	backgroundCommandTaskId?: string
+	workspaceManager?: any
+	checkpointRestoreInput?: ExtensionState["checkpointRestoreInput"]
+}): Promise<ExtensionState> {
+	const stateManager = controller.stateManager
+
+	// Get API configuration from cache for immediate access
+	const onboardingModels = getClineOnboardingModels()
+	const apiConfiguration = stateManager.getApiConfiguration()
+	const lastShownAnnouncementId = stateManager.getGlobalStateKey("lastShownAnnouncementId")
+	const taskHistory = stateManager.getGlobalStateKey("taskHistory")
+	const autoApprovalSettings = stateManager.getGlobalSettingsKey("autoApprovalSettings")
+	const browserSettings = stateManager.getGlobalSettingsKey("browserSettings")
+	const preferredLanguage = stateManager.getGlobalSettingsKey("preferredLanguage")
+	const mode = stateManager.getGlobalSettingsKey("mode")
+	const yoloModeToggled = stateManager.getGlobalSettingsKey("yoloModeToggled")
+	const useAutoCondense = stateManager.getGlobalSettingsKey("useAutoCondense")
+	const compactionStrategy = readCompactionStrategyGlobally()
+	const subagentsEnabled = stateManager.getGlobalSettingsKey("subagentsEnabled")
+	const userInfo = stateManager.getGlobalStateKey("userInfo")
+	const mcpMarketplaceEnabled = stateManager.getGlobalStateKey("mcpMarketplaceEnabled")
+	const mcpDisplayMode = stateManager.getGlobalStateKey("mcpDisplayMode")
+	const telemetrySetting = stateManager.getGlobalSettingsKey("telemetrySetting")
+	const planActSeparateModelsSetting = stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+	const enableCheckpointsSetting = stateManager.getGlobalSettingsKey("enableCheckpointsSetting")
+	const globalClineRulesToggles = stateManager.getGlobalStateKey("globalClineRulesToggles")
+	const globalWorkflowToggles = stateManager.getGlobalStateKey("globalWorkflowToggles")
+	const globalSkillsToggles = stateManager.getGlobalStateKey("globalSkillsToggles")
+	const localSkillsToggles = stateManager.getWorkspaceStateKey("localSkillsToggles")
+	const remoteRulesToggles = stateManager.getGlobalStateKey("remoteRulesToggles")
+	const remoteWorkflowToggles = stateManager.getGlobalStateKey("remoteWorkflowToggles")
+	const shellIntegrationTimeout = stateManager.getGlobalSettingsKey("shellIntegrationTimeout")
+	const terminalReuseEnabled = stateManager.getGlobalStateKey("terminalReuseEnabled")
+	const vscodeTerminalExecutionMode = stateManager.getGlobalStateKey("vscodeTerminalExecutionMode")
+	const defaultTerminalProfile = stateManager.getGlobalSettingsKey("defaultTerminalProfile")
+	const isNewUser = stateManager.getGlobalStateKey("isNewUser")
+	const welcomeViewCompleted = !!stateManager.getGlobalStateKey("welcomeViewCompleted")
+
+	const customPrompt = stateManager.getGlobalSettingsKey("customPrompt")
+	const mcpResponsesCollapsed = stateManager.getGlobalStateKey("mcpResponsesCollapsed")
+	const maxConsecutiveMistakes = stateManager.getGlobalSettingsKey("maxConsecutiveMistakes")
+	const favoritedModelIds = stateManager.getGlobalStateKey("favoritedModelIds")
+	const lastDismissedInfoBannerVersion = stateManager.getGlobalStateKey("lastDismissedInfoBannerVersion") || 0
+	const lastDismissedModelBannerVersion = stateManager.getGlobalStateKey("lastDismissedModelBannerVersion") || 0
+	const lastDismissedCliBannerVersion = stateManager.getGlobalStateKey("lastDismissedCliBannerVersion") || 0
+	const dismissedBanners = stateManager.getGlobalStateKey("dismissedBanners")
+	const showFeatureTips = stateManager.getGlobalSettingsKey("showFeatureTips")
+
+	const localClineRulesToggles = stateManager.getWorkspaceStateKey("localClineRulesToggles")
+	const localWindsurfRulesToggles = stateManager.getWorkspaceStateKey("localWindsurfRulesToggles")
+	const localCursorRulesToggles = stateManager.getWorkspaceStateKey("localCursorRulesToggles")
+	const localAgentsRulesToggles = stateManager.getWorkspaceStateKey("localAgentsRulesToggles")
+	const workflowToggles = stateManager.getWorkspaceStateKey("workflowToggles")
+
+	const currentTaskItem = controller.task?.taskId
+		? (taskHistory || []).find((item: any) => item.id === controller.task?.taskId)
+		: undefined
+	const clineMessages = [...(controller.task?.messageStateHandler?.getClineMessages?.() || [])]
+	const checkpointRestoreInput = controller.checkpointRestoreInput
+
+	const processedTaskHistory = (taskHistory || [])
+		.filter((item: any) => item.ts && item.task)
+		.sort((a: any, b: any) => b.ts - a.ts)
+		.slice(0, 100)
+
+	const latestAnnouncementId = getLatestAnnouncementId()
+	const shouldShowAnnouncement = lastShownAnnouncementId !== latestAnnouncementId
+	const platform = process.platform as Platform
+	const distinctId = getDistinctId()
+	const version = ExtensionRegistryInfo.version
+	const clineConfig = ClineEnv.config()
+	const environment = clineConfig.environment
+	const banners = BannerService.get().getActiveBanners() ?? []
+	const welcomeBanners = BannerService.get().getWelcomeBanners() ?? []
+
+	// Check OpenAI Codex authentication status
+	let openAiCodexIsAuthenticated = false
+	try {
+		const { openAiCodexOAuthManager } = await import("@/integrations/openai-codex/oauth")
+		openAiCodexIsAuthenticated = await openAiCodexOAuthManager.isAuthenticated()
+	} catch {
+		// Codex OAuth not available
+	}
+
+	return {
+		version,
+		apiConfiguration,
+		currentTaskItem,
+		clineMessages,
+		checkpointRestoreInput,
+		autoApprovalSettings,
+		browserSettings,
+		preferredLanguage,
+		mode,
+		yoloModeToggled,
+		useAutoCondense,
+		compactionStrategy,
+		subagentsEnabled,
+		userInfo,
+		mcpMarketplaceEnabled,
+		mcpDisplayMode,
+		telemetrySetting,
+		planActSeparateModelsSetting,
+		enableCheckpointsSetting: enableCheckpointsSetting ?? true,
+		platform,
+		environment,
+		distinctId,
+		globalClineRulesToggles: globalClineRulesToggles || {},
+		localClineRulesToggles: localClineRulesToggles || {},
+		localWindsurfRulesToggles: localWindsurfRulesToggles || {},
+		localCursorRulesToggles: localCursorRulesToggles || {},
+		localAgentsRulesToggles: localAgentsRulesToggles || {},
+		localWorkflowToggles: workflowToggles || {},
+		globalWorkflowToggles: globalWorkflowToggles || {},
+		globalSkillsToggles: globalSkillsToggles || {},
+		localSkillsToggles: localSkillsToggles || {},
+		remoteRulesToggles,
+		remoteWorkflowToggles,
+		shellIntegrationTimeout,
+		terminalReuseEnabled,
+		vscodeTerminalExecutionMode,
+		defaultTerminalProfile,
+		isNewUser,
+		welcomeViewCompleted,
+		onboardingModels,
+		mcpResponsesCollapsed,
+		maxConsecutiveMistakes,
+		customPrompt,
+		taskHistory: processedTaskHistory,
+		shouldShowAnnouncement,
+		favoritedModelIds,
+		backgroundCommandRunning: controller.backgroundCommandRunning ?? false,
+		backgroundCommandTaskId: controller.backgroundCommandTaskId,
+		workspaceRoots: controller.workspaceManager?.getRoots?.() ?? [],
+		primaryRootIndex: controller.workspaceManager?.getPrimaryIndex?.() ?? 0,
+		isMultiRootWorkspace: (controller.workspaceManager?.getRoots?.()?.length ?? 0) > 1,
+		multiRootSetting: {
+			user: stateManager.getGlobalStateKey("multiRootEnabled"),
+			featureFlag: true,
+		},
+		worktreesEnabled: {
+			user: stateManager.getGlobalSettingsKey("worktreesEnabled"),
+			featureFlag: featureFlagsService.getWorktreesEnabled(),
+		},
+		hooksEnabled: getHooksEnabledSafe(stateManager.getGlobalSettingsKey("hooksEnabled")),
+		lastDismissedInfoBannerVersion,
+		lastDismissedModelBannerVersion,
+		remoteConfigSettings: stateManager.getRemoteConfigSettings?.(),
+		lastDismissedCliBannerVersion,
+		dismissedBanners,
+		backgroundEditEnabled: stateManager.getGlobalSettingsKey("backgroundEditEnabled"),
+		optOutOfRemoteConfig: stateManager.getGlobalSettingsKey("optOutOfRemoteConfig"),
+		showFeatureTips,
+		banners,
+		welcomeBanners,
+		openAiCodexIsAuthenticated,
+	} as ExtensionState
+}
diff --git a/apps/vscode/src/core/controller/state/installClineCli.ts b/apps/vscode/src/core/controller/state/installClineCli.ts
new file mode 100644
index 0000000..e8af262
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/installClineCli.ts
@@ -0,0 +1,39 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { ShowMessageType } from "@shared/proto/host/window"
+import { ExecuteCommandInTerminalRequest } from "@shared/proto/host/workspace"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Handles the installation of the Cline CLI tool
+ * @param controller The controller instance
+ * @param _request The empty request
+ * @returns Empty response
+ */
+export async function installClineCli(_controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	const installCommand = "npm install -g cline"
+
+	try {
+		// Use the HostProvider to execute the command in a terminal
+		// This works across different platforms (VSCode, JetBrains, etc.)
+		const response = await HostProvider.workspace.executeCommandInTerminal(
+			ExecuteCommandInTerminalRequest.create({
+				command: installCommand,
+			}),
+		)
+
+		if (!response.success) {
+			throw new Error("Failed to execute command in terminal")
+		}
+	} catch (error) {
+		Logger.error("Error executing CLI installation:", error)
+		await HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Failed to start CLI installation: ${error instanceof Error ? error.message : "Unknown error"}`,
+			options: { items: [] },
+		})
+	}
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/reasoningEffort.ts b/apps/vscode/src/core/controller/state/reasoningEffort.ts
new file mode 100644
index 0000000..c081b6f
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/reasoningEffort.ts
@@ -0,0 +1,29 @@
+import { OpenaiReasoningEffort as ProtoOpenaiReasoningEffort } from "@shared/proto/cline/state"
+import {
+	isOpenaiReasoningEffort,
+	normalizeOpenaiReasoningEffort as normalizeOpenaiReasoningEffortString,
+	OpenaiReasoningEffort,
+} from "@/shared/storage/types"
+
+export function normalizeOpenaiReasoningEffort(
+	effort: ProtoOpenaiReasoningEffort | OpenaiReasoningEffort | string,
+): OpenaiReasoningEffort {
+	if (isOpenaiReasoningEffort(effort)) {
+		return effort
+	}
+
+	if (typeof effort === "string") {
+		return normalizeOpenaiReasoningEffortString(effort)
+	}
+
+	switch (effort) {
+		case ProtoOpenaiReasoningEffort.LOW:
+			return "low"
+		case ProtoOpenaiReasoningEffort.MEDIUM:
+			return "medium"
+		case ProtoOpenaiReasoningEffort.HIGH:
+			return "high"
+		default:
+			return normalizeOpenaiReasoningEffortString()
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/refreshRemoteConfig.ts b/apps/vscode/src/core/controller/state/refreshRemoteConfig.ts
new file mode 100644
index 0000000..ebe4f5e
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/refreshRemoteConfig.ts
@@ -0,0 +1,15 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { fetchRemoteConfig } from "@/core/storage/remote-config/fetch"
+import { Controller } from ".."
+
+/**
+ * fetches the remote config
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns Empty response
+ */
+export async function refreshRemoteConfig(controller: Controller, _: EmptyRequest): Promise<Empty> {
+	await fetchRemoteConfig(controller)
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/resetState.ts b/apps/vscode/src/core/controller/state/resetState.ts
new file mode 100644
index 0000000..f855c1d
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/resetState.ts
@@ -0,0 +1,54 @@
+import { Empty } from "@shared/proto/cline/common"
+import { ResetStateRequest } from "@shared/proto/cline/state"
+import { resetGlobalState, resetWorkspaceState } from "@/core/storage/utils/state-helpers"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
+
+/**
+ * Resets the extension state to its defaults
+ * @param controller The controller instance
+ * @param request The reset state request containing the global flag
+ * @returns An empty response
+ */
+export async function resetState(controller: Controller, request: ResetStateRequest): Promise<Empty> {
+	try {
+		if (request.global) {
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: "Resetting global state...",
+			})
+			await resetGlobalState()
+		} else {
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: "Resetting workspace state...",
+			})
+			await resetWorkspaceState()
+		}
+
+		if (controller.task) {
+			controller.task.abortTask()
+			controller.task = undefined
+		}
+
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message: "State reset",
+		})
+		await controller.postStateToWebview()
+
+		await sendChatButtonClickedEvent()
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error("Error resetting state:", error)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Failed to reset state: ${error instanceof Error ? error.message : String(error)}`,
+		})
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/setWelcomeViewCompleted.ts b/apps/vscode/src/core/controller/state/setWelcomeViewCompleted.ts
new file mode 100644
index 0000000..c02480e
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/setWelcomeViewCompleted.ts
@@ -0,0 +1,25 @@
+import type { BooleanRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Sets the welcomeViewCompleted flag to the specified boolean value
+ * @param controller The controller instance
+ * @param request The boolean request containing the value to set
+ * @returns Empty response
+ */
+export async function setWelcomeViewCompleted(controller: Controller, request: BooleanRequest): Promise<Empty> {
+	try {
+		// Update the global state to set welcomeViewCompleted to the requested value
+		controller.stateManager.setGlobalState("welcomeViewCompleted", request.value)
+
+		await controller.postStateToWebview()
+
+		Logger.log(`Welcome view completed set to: ${request.value}`)
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("Failed to set welcome view completed:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/subscribeToState.ts b/apps/vscode/src/core/controller/state/subscribeToState.ts
new file mode 100644
index 0000000..2ecd25b
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/subscribeToState.ts
@@ -0,0 +1,90 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { State } from "@shared/proto/cline/state"
+import { telemetryService } from "@/services/telemetry"
+import { ExtensionState } from "@/shared/ExtensionMessage"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active state subscriptions
+const activeStateSubscriptions = new Set<StreamingResponseHandler<State>>()
+
+/**
+ * Subscribe to state updates
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToState(
+	controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<State>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeStateSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeStateSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "state_subscription" }, responseStream)
+	}
+
+	// Send the initial state
+	const initialState = await controller.getStateToPostToWebview()
+	const initialStateJson = JSON.stringify(initialState)
+
+	recordStateSizeTelemetry(Buffer.byteLength(initialStateJson, "utf8"))
+
+	try {
+		await responseStream(
+			{
+				stateJson: initialStateJson,
+			},
+			false, // Not the last message
+		)
+	} catch (error) {
+		Logger.error("Error sending initial state:", error)
+		activeStateSubscriptions.delete(responseStream)
+	}
+}
+
+/**
+ * Send a state update to all active subscribers
+ * @param state The state to send
+ */
+export async function sendStateUpdate(state: ExtensionState): Promise<void> {
+	let stateJson: string
+	try {
+		stateJson = JSON.stringify(state)
+	} catch (error) {
+		Logger.error("Error serializing state update:", error)
+		return
+	}
+
+	recordStateSizeTelemetry(Buffer.byteLength(stateJson, "utf8"))
+
+	// FIRE-AND-FORGET: do not await delivery to the webview (it may be hidden/reloaded/closed
+	// and postMessage can hang or resolve false). The webview reconciles convergently from
+	// whatever state snapshots it receives, gated by stateVersion/epoch.
+	for (const responseStream of activeStateSubscriptions) {
+		responseStream(
+			{
+				stateJson,
+			},
+			false, // Not the last message
+		).catch((error) => {
+			Logger.error("Error sending state update:", error)
+			activeStateSubscriptions.delete(responseStream)
+		})
+	}
+}
+
+function recordStateSizeTelemetry(sizeBytes: number): void {
+	telemetryService.captureGrpcResponseSize(sizeBytes, "cline.StateService", "subscribeToState")
+}
diff --git a/apps/vscode/src/core/controller/state/testOtelConnection.ts b/apps/vscode/src/core/controller/state/testOtelConnection.ts
new file mode 100644
index 0000000..b21f4b7
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/testOtelConnection.ts
@@ -0,0 +1,49 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { TestConnectionResult } from "@shared/proto/cline/state"
+import { REMOTE_CONFIG_OTEL_PROVIDER_ID } from "@/core/storage/remote-config/utils"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Tests the OpenTelemetry connection by sending a test log event
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns TestConnectionResult with success status and message
+ */
+export async function testOtelConnection(_controller: Controller, _: EmptyRequest): Promise<TestConnectionResult> {
+	try {
+		const providers = await telemetryService.getProviders()
+		const otelProvider = providers.find((p) => p.name === REMOTE_CONFIG_OTEL_PROVIDER_ID)
+
+		if (!otelProvider) {
+			return TestConnectionResult.create({
+				success: false,
+				error: "OpenTelemetry provider not configured",
+			})
+		}
+
+		otelProvider.log("cline.test.connection", {
+			test: true,
+			timestamp: new Date().toISOString(),
+			source: "remote_config_settings",
+		})
+
+		otelProvider.recordCounter("cline.test.connection", 1)
+
+		await otelProvider.forceFlush()
+
+		return TestConnectionResult.create({
+			success: true,
+			message: "Test log event sent successfully. Check your OTEL collector for the event.",
+		})
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		Logger.error("[TEST_OTEL_CONNECTION] Failed to send test event:", error)
+
+		return TestConnectionResult.create({
+			success: false,
+			error: errorMessage,
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/testPromptUploading.ts b/apps/vscode/src/core/controller/state/testPromptUploading.ts
new file mode 100644
index 0000000..639ea37
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/testPromptUploading.ts
@@ -0,0 +1,44 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { TestConnectionResult } from "@shared/proto/cline/state"
+import { Logger } from "@/shared/services/Logger"
+import { blobStorage } from "@/shared/storage/ClineBlobStorage"
+import { Controller } from ".."
+
+/**
+ * Tests the prompt uploading (blob storage) connection by uploading a test file
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns TestConnectionResult with success status and message
+ */
+export async function testPromptUploading(_controller: Controller, _: EmptyRequest): Promise<TestConnectionResult> {
+	try {
+		if (!blobStorage.isReady()) {
+			return TestConnectionResult.create({
+				success: false,
+				error: "Blob storage is not configured or not ready",
+			})
+		}
+
+		const testKey = `cline-test-${Date.now()}.json`
+		const testContent = JSON.stringify({
+			test: true,
+			timestamp: new Date().toISOString(),
+			source: "remote_config_settings",
+		})
+
+		await blobStorage._dangerousStore(testKey, testContent)
+
+		return TestConnectionResult.create({
+			success: true,
+			message: "Test file uploaded and verified successfully.",
+		})
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		Logger.error("[TEST_PROMPT_UPLOADING] Failed to test blob storage:", error)
+
+		return TestConnectionResult.create({
+			success: false,
+			error: errorMessage,
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/toggleFavoriteModel.ts b/apps/vscode/src/core/controller/state/toggleFavoriteModel.ts
new file mode 100644
index 0000000..868bbca
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/toggleFavoriteModel.ts
@@ -0,0 +1,41 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Toggles a model's favorite status
+ * @param controller The controller instance
+ * @param request The request containing the model ID to toggle
+ * @returns An empty response
+ */
+export async function toggleFavoriteModel(controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		if (!request.value) {
+			throw new Error("Model ID is required")
+		}
+
+		const modelId = request.value
+
+		const favoritedModelIds = controller.stateManager.getGlobalStateKey("favoritedModelIds")
+
+		// Toggle favorite status
+		const updatedFavorites = favoritedModelIds.includes(modelId)
+			? favoritedModelIds.filter((id) => id !== modelId)
+			: [...favoritedModelIds, modelId]
+
+		controller.stateManager.setGlobalState("favoritedModelIds", updatedFavorites)
+
+		// Capture telemetry for model favorite toggle
+		const isFavorited = !favoritedModelIds.includes(modelId)
+		telemetryService.captureModelFavoritesUsage(modelId, isFavorited)
+
+		// Post state to webview without changing any other configuration
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error(`Failed to toggle favorite status for model ${request.value}:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/togglePlanActModeProto.ts b/apps/vscode/src/core/controller/state/togglePlanActModeProto.ts
new file mode 100644
index 0000000..ff1f8ba
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/togglePlanActModeProto.ts
@@ -0,0 +1,35 @@
+import { Boolean } from "@shared/proto/cline/common"
+import { PlanActMode, TogglePlanActModeRequest } from "@shared/proto/cline/state"
+import { Mode } from "@shared/storage/types"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Toggles between Plan and Act modes
+ * @param controller The controller instance
+ * @param request The request containing the chat settings and optional chat content
+ * @returns An empty response
+ */
+export async function togglePlanActModeProto(controller: Controller, request: TogglePlanActModeRequest): Promise<Boolean> {
+	try {
+		let mode: Mode
+		if (request.mode === PlanActMode.PLAN) {
+			mode = "plan"
+		} else if (request.mode === PlanActMode.ACT) {
+			mode = "act"
+		} else {
+			throw new Error(`Invalid mode value: ${request.mode}`)
+		}
+		const chatContent = request.chatContent
+
+		// Call the existing controller implementation
+		const sentMessage = await controller.togglePlanActMode(mode, chatContent)
+
+		return Boolean.create({
+			value: sentMessage,
+		})
+	} catch (error) {
+		Logger.error("Failed to toggle Plan/Act mode:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/trackBannerEvent.ts b/apps/vscode/src/core/controller/state/trackBannerEvent.ts
new file mode 100644
index 0000000..ad21f0a
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/trackBannerEvent.ts
@@ -0,0 +1,28 @@
+import { BannerService } from "@/services/banner/BannerService"
+import { Empty } from "@/shared/proto/cline/common"
+import type { TrackBannerEventRequest } from "@/shared/proto/cline/state"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from ".."
+
+/**
+ * Tracks a banner event (e.g., dismiss, click)
+ * @param controller The controller instance
+ * @param request The request containing banner ID and event type
+ * @returns Empty response
+ */
+export async function trackBannerEvent(_controller: Controller, request: TrackBannerEventRequest): Promise<Empty> {
+	const { bannerId, eventType } = request
+	if (!bannerId) {
+		return {}
+	}
+	if (eventType !== "dismiss") {
+		Logger.error("Unsupported event type ", eventType)
+		return {}
+	}
+	try {
+		await BannerService.get().sendBannerEvent(bannerId, eventType)
+	} catch (error) {
+		Logger.error("Failed to track banner event:", error)
+	}
+	return {}
+}
diff --git a/apps/vscode/src/core/controller/state/updateAutoApprovalSettings.test.ts b/apps/vscode/src/core/controller/state/updateAutoApprovalSettings.test.ts
new file mode 100644
index 0000000..2449497
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateAutoApprovalSettings.test.ts
@@ -0,0 +1,107 @@
+import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
+import { AutoApprovalSettingsRequest } from "@shared/proto/cline/state"
+import { describe, expect, it, vi } from "vitest"
+import type { Controller } from ".."
+import { updateAutoApprovalSettings } from "./updateAutoApprovalSettings"
+
+function makeController(currentSettings = DEFAULT_AUTO_APPROVAL_SETTINGS, taskId?: string) {
+	const controller = {
+		task: taskId ? { taskId } : undefined,
+		getStateToPostToWebview: vi.fn(async () => ({
+			autoApprovalSettings: currentSettings,
+		})),
+		postStateToWebview: vi.fn(async () => undefined),
+		stateManager: {
+			setGlobalState: vi.fn(),
+			setTaskSettings: vi.fn(),
+		},
+	}
+
+	return controller as unknown as Controller & {
+		getStateToPostToWebview: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+		stateManager: {
+			setGlobalState: ReturnType<typeof vi.fn>
+			setTaskSettings: ReturnType<typeof vi.fn>
+		}
+	}
+}
+
+describe("updateAutoApprovalSettings", () => {
+	it("updates the active task override when auto-approval settings change", async () => {
+		const currentSettings = {
+			...DEFAULT_AUTO_APPROVAL_SETTINGS,
+			version: 1,
+			actions: {
+				...DEFAULT_AUTO_APPROVAL_SETTINGS.actions,
+				editFiles: false,
+			},
+		}
+		const controller = makeController(currentSettings, "task-1")
+
+		await updateAutoApprovalSettings(
+			controller,
+			AutoApprovalSettingsRequest.create({
+				version: 2,
+				actions: {
+					editFiles: true,
+				},
+			}),
+		)
+
+		const expectedSettings = {
+			...currentSettings,
+			version: 2,
+			actions: {
+				...currentSettings.actions,
+				editFiles: true,
+			},
+		}
+
+		expect(controller.stateManager.setGlobalState.mock.calls).toEqual([["autoApprovalSettings", expectedSettings]])
+		expect(controller.stateManager.setTaskSettings.mock.calls).toEqual([["task-1", "autoApprovalSettings", expectedSettings]])
+		expect(controller.postStateToWebview.mock.calls.length).toBe(1)
+	})
+
+	it("does not create a task override when no task is active", async () => {
+		const controller = makeController(DEFAULT_AUTO_APPROVAL_SETTINGS)
+
+		await updateAutoApprovalSettings(
+			controller,
+			AutoApprovalSettingsRequest.create({
+				version: DEFAULT_AUTO_APPROVAL_SETTINGS.version + 1,
+				actions: {
+					readFiles: false,
+				},
+			}),
+		)
+
+		expect(controller.stateManager.setGlobalState.mock.calls.length).toBe(1)
+		expect(controller.stateManager.setTaskSettings.mock.calls.length).toBe(0)
+		expect(controller.postStateToWebview.mock.calls.length).toBe(1)
+	})
+
+	it("ignores stale auto-approval settings versions", async () => {
+		const controller = makeController(
+			{
+				...DEFAULT_AUTO_APPROVAL_SETTINGS,
+				version: 3,
+			},
+			"task-1",
+		)
+
+		await updateAutoApprovalSettings(
+			controller,
+			AutoApprovalSettingsRequest.create({
+				version: 3,
+				actions: {
+					readFiles: false,
+				},
+			}),
+		)
+
+		expect(controller.stateManager.setGlobalState.mock.calls.length).toBe(0)
+		expect(controller.stateManager.setTaskSettings.mock.calls.length).toBe(0)
+		expect(controller.postStateToWebview.mock.calls.length).toBe(0)
+	})
+})
diff --git a/apps/vscode/src/core/controller/state/updateAutoApprovalSettings.ts b/apps/vscode/src/core/controller/state/updateAutoApprovalSettings.ts
new file mode 100644
index 0000000..2aadca6
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateAutoApprovalSettings.ts
@@ -0,0 +1,40 @@
+import { Empty } from "@shared/proto/cline/common"
+import { AutoApprovalSettingsRequest } from "@shared/proto/cline/state"
+import { Controller } from ".."
+
+/**
+ * Updates the auto approval settings
+ * @param controller The controller instance
+ * @param request The auto approval settings request
+ * @returns Empty response
+ */
+export async function updateAutoApprovalSettings(controller: Controller, request: AutoApprovalSettingsRequest): Promise<Empty> {
+	const currentSettings = (await controller.getStateToPostToWebview()).autoApprovalSettings
+	const incomingVersion = request.version
+	const currentVersion = currentSettings?.version ?? 1
+
+	// Only update if incoming version is higher
+	if (incomingVersion > currentVersion) {
+		// Merge with current settings to preserve unspecified fields
+		const settings = {
+			...currentSettings,
+			...(request.version !== undefined && { version: request.version }),
+			...(request.enableNotifications !== undefined && { enableNotifications: request.enableNotifications }),
+			actions: {
+				...currentSettings.actions,
+				...(request.actions
+					? Object.fromEntries(Object.entries(request.actions).filter(([_, v]) => v !== undefined))
+					: {}),
+			},
+		}
+
+		controller.stateManager.setGlobalState("autoApprovalSettings", settings)
+		if (controller.task?.taskId) {
+			controller.stateManager.setTaskSettings(controller.task.taskId, "autoApprovalSettings", settings)
+		}
+
+		await controller.postStateToWebview()
+	}
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/updateCliBannerVersion.ts b/apps/vscode/src/core/controller/state/updateCliBannerVersion.ts
new file mode 100644
index 0000000..3af0187
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateCliBannerVersion.ts
@@ -0,0 +1,18 @@
+import { Empty, Int64Request } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Updates the CLI banner version to hide it
+ * @param controller The controller instance
+ * @param request The request containing the version number
+ * @returns Empty response
+ */
+export async function updateCliBannerVersion(controller: Controller, request: Int64Request): Promise<Empty> {
+	// Save the banner version to global state to hide it
+	controller.stateManager.setGlobalState("lastDismissedCliBannerVersion", request.value ?? 1)
+
+	// Update webview
+	await controller.postStateToWebview()
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/updateInfoBannerVersion.ts b/apps/vscode/src/core/controller/state/updateInfoBannerVersion.ts
new file mode 100644
index 0000000..df92f0a
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateInfoBannerVersion.ts
@@ -0,0 +1,17 @@
+import { Empty, Int64Request } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Updates the info banner version to track which version the user has dismissed
+ * @param controller The controller instance
+ * @param request The request containing the version number
+ * @returns Empty response
+ */
+export async function updateInfoBannerVersion(controller: Controller, request: Int64Request): Promise<Empty> {
+	const version = Number(request.value)
+
+	controller.stateManager.setGlobalState("lastDismissedInfoBannerVersion", version)
+	await controller.postStateToWebview()
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/updateModelBannerVersion.ts b/apps/vscode/src/core/controller/state/updateModelBannerVersion.ts
new file mode 100644
index 0000000..4dc2d71
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateModelBannerVersion.ts
@@ -0,0 +1,17 @@
+import { Empty, Int64Request } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Updates the model banner version to track which version the user has dismissed
+ * @param controller The controller instance
+ * @param request The request containing the version number
+ * @returns Empty response
+ */
+export async function updateModelBannerVersion(controller: Controller, request: Int64Request): Promise<Empty> {
+	const version = Number(request.value)
+
+	controller.stateManager.setGlobalState("lastDismissedModelBannerVersion", version)
+	await controller.postStateToWebview()
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/updateSettings.ts b/apps/vscode/src/core/controller/state/updateSettings.ts
new file mode 100644
index 0000000..167caf4
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateSettings.ts
@@ -0,0 +1,285 @@
+import { setCompactionStrategyGlobally } from "@cline/core"
+import { Empty } from "@shared/proto/cline/common"
+import { PlanActMode, McpDisplayMode as ProtoMcpDisplayMode, UpdateSettingsRequest } from "@shared/proto/cline/state"
+import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { OpenaiReasoningEffort } from "@shared/storage/types"
+import { TelemetrySetting } from "@shared/TelemetrySetting"
+import { ClineEnv } from "@/config"
+import { fetchRemoteConfig } from "@/core/storage/remote-config/fetch"
+import { clearRemoteConfig } from "@/core/storage/remote-config/utils"
+import { McpDisplayMode } from "@/shared/McpDisplayMode"
+import { Logger } from "@/shared/services/Logger"
+import { telemetryService } from "../../../services/telemetry"
+import { BrowserSettings as SharedBrowserSettings } from "../../../shared/BrowserSettings"
+import { Controller } from ".."
+import { accountLogoutClicked } from "../account/accountLogoutClicked"
+import { normalizeProviderSwitchModel } from "../models/providerSwitchNormalization"
+import { createTaskApiModelShim, resolveActiveModelIdFromApiConfiguration } from "../models/taskApiModel"
+
+/**
+ * Updates multiple extension settings in a single request
+ * @param controller The controller instance
+ * @param request The request containing the settings to update
+ * @returns An empty response
+ */
+export async function updateSettings(controller: Controller, request: UpdateSettingsRequest): Promise<Empty> {
+	try {
+		if (request.clineEnv !== undefined && request.clineEnv !== "") {
+			ClineEnv.setEnvironment(request.clineEnv)
+			await accountLogoutClicked(controller, Empty.create())
+		}
+
+		if (request.apiConfiguration) {
+			const protoApiConfiguration = request.apiConfiguration
+
+			const convertedApiConfigurationFromProto = {
+				...protoApiConfiguration,
+				// Convert proto ApiProvider enums to native string types
+				planModeApiProvider: protoApiConfiguration.planModeApiProvider
+					? convertProtoToApiProvider(protoApiConfiguration.planModeApiProvider)
+					: undefined,
+				actModeApiProvider: protoApiConfiguration.actModeApiProvider
+					? convertProtoToApiProvider(protoApiConfiguration.actModeApiProvider)
+					: undefined,
+				planModeReasoningEffort: protoApiConfiguration.planModeReasoningEffort as OpenaiReasoningEffort | undefined,
+				actModeReasoningEffort: protoApiConfiguration.actModeReasoningEffort as OpenaiReasoningEffort | undefined,
+			}
+
+			const previousApiConfiguration = controller.stateManager.getApiConfiguration()
+			const normalizedApiConfiguration = normalizeProviderSwitchModel(
+				controller.getProviderConfigStore(),
+				previousApiConfiguration,
+				convertedApiConfigurationFromProto,
+			)
+
+			controller.stateManager.setApiConfiguration(normalizedApiConfiguration)
+
+			if (controller.task) {
+				const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+				const modelId = resolveActiveModelIdFromApiConfiguration(normalizedApiConfiguration, currentMode)
+				controller.task.api = createTaskApiModelShim(modelId)
+			}
+			controller.handleApiConfigurationChanged(previousApiConfiguration, normalizedApiConfiguration)
+		}
+
+		// Update telemetry setting
+		if (request.telemetrySetting) {
+			await controller.updateTelemetrySetting(request.telemetrySetting as TelemetrySetting)
+		}
+
+		// Update plan/act separate models setting
+		if (request.planActSeparateModelsSetting !== undefined) {
+			controller.stateManager.setGlobalState("planActSeparateModelsSetting", request.planActSeparateModelsSetting)
+		}
+
+		// Update checkpoints setting
+		if (request.enableCheckpointsSetting !== undefined) {
+			controller.stateManager.setGlobalState("enableCheckpointsSetting", request.enableCheckpointsSetting)
+		}
+
+		// Update MCP responses collapsed setting
+		if (request.mcpResponsesCollapsed !== undefined) {
+			controller.stateManager.setGlobalState("mcpResponsesCollapsed", request.mcpResponsesCollapsed)
+		}
+
+		// Update MCP display mode setting
+		if (request.mcpDisplayMode !== undefined) {
+			// Convert proto enum to string type
+			let displayMode: McpDisplayMode
+			switch (request.mcpDisplayMode) {
+				case ProtoMcpDisplayMode.RICH:
+					displayMode = "rich"
+					break
+				case ProtoMcpDisplayMode.PLAIN:
+					displayMode = "plain"
+					break
+				case ProtoMcpDisplayMode.MARKDOWN:
+					displayMode = "markdown"
+					break
+				default:
+					throw new Error(`Invalid MCP display mode value: ${request.mcpDisplayMode}`)
+			}
+			controller.stateManager.setGlobalState("mcpDisplayMode", displayMode)
+		}
+
+		if (request.mode !== undefined) {
+			const mode = request.mode === PlanActMode.PLAN ? "plan" : "act"
+			controller.stateManager.setGlobalState("mode", mode)
+		}
+
+		if (request.preferredLanguage !== undefined) {
+			controller.stateManager.setGlobalState("preferredLanguage", request.preferredLanguage)
+		}
+
+		// Update terminal timeout setting
+		if (request.shellIntegrationTimeout !== undefined) {
+			controller.stateManager.setGlobalState("shellIntegrationTimeout", Number(request.shellIntegrationTimeout))
+			controller.terminalManager?.setShellIntegrationTimeout(Number(request.shellIntegrationTimeout))
+		}
+
+		// Update terminal reuse setting
+		if (request.terminalReuseEnabled !== undefined) {
+			controller.stateManager.setGlobalState("terminalReuseEnabled", request.terminalReuseEnabled)
+			controller.terminalManager?.setTerminalReuseEnabled(!!request.terminalReuseEnabled)
+		}
+
+		if (request.vscodeTerminalExecutionMode !== undefined && request.vscodeTerminalExecutionMode !== "") {
+			controller.stateManager.setGlobalState(
+				"vscodeTerminalExecutionMode",
+				request.vscodeTerminalExecutionMode === "backgroundExec" ? "backgroundExec" : "vscodeTerminal",
+			)
+		}
+
+		// Update max consecutive mistakes
+		if (request.maxConsecutiveMistakes !== undefined) {
+			controller.stateManager.setGlobalState("maxConsecutiveMistakes", Number(request.maxConsecutiveMistakes))
+		}
+
+		if (request.hooksEnabled !== undefined) {
+			const wasEnabled = controller.stateManager.getGlobalSettingsKey("hooksEnabled") ?? true
+			const isEnabled = !!request.hooksEnabled
+			controller.stateManager.setGlobalState("hooksEnabled", isEnabled)
+			if (controller.task && wasEnabled !== isEnabled) {
+				telemetryService.captureFeatureToggle(controller.task.ulid, "hooks", isEnabled, controller.task.api.getModel().id)
+			}
+		}
+		// Update yolo mode setting
+		if (request.yoloModeToggled !== undefined) {
+			if (controller.task) {
+				telemetryService.captureYoloModeToggle(controller.task.ulid, request.yoloModeToggled)
+			}
+			controller.stateManager.setGlobalState("yoloModeToggled", request.yoloModeToggled)
+		}
+
+		// Update worktrees setting
+		if (request.worktreesEnabled !== undefined) {
+			controller.stateManager.setGlobalState("worktreesEnabled", request.worktreesEnabled)
+		}
+
+		// Update subagents setting
+		if (request.subagentsEnabled !== undefined) {
+			const wasEnabled = controller.stateManager.getGlobalSettingsKey("subagentsEnabled") ?? false
+			const isEnabled = !!request.subagentsEnabled
+			controller.stateManager.setGlobalState("subagentsEnabled", isEnabled)
+
+			// Capture telemetry when setting changes
+			if (wasEnabled !== isEnabled) {
+				telemetryService.captureSubagentToggle(isEnabled)
+			}
+		}
+
+		// Update auto-condense setting
+		if (request.useAutoCondense !== undefined) {
+			if (controller.task) {
+				telemetryService.captureAutoCondenseToggle(
+					controller.task.ulid,
+					request.useAutoCondense,
+					controller.task.api.getModel().id,
+				)
+			}
+			controller.stateManager.setGlobalState("useAutoCondense", request.useAutoCondense)
+		}
+
+		if (request.compactionStrategy !== undefined) {
+			const strategy = request.compactionStrategy
+			if (strategy !== "basic" && strategy !== "agentic") {
+				throw new Error(`Invalid compaction strategy value: ${strategy}`)
+			}
+			setCompactionStrategyGlobally(strategy)
+		}
+
+		// Update custom prompt choice
+		if (request.customPrompt !== undefined) {
+			const value = request.customPrompt === "compact" ? "compact" : undefined
+			controller.stateManager.setGlobalState("customPrompt", value)
+		}
+
+		// Update browser settings
+		if (request.browserSettings !== undefined) {
+			// Get current browser settings to preserve fields not in the request
+			const currentSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
+
+			// Convert from protobuf format to shared format, merging with existing settings
+			const newBrowserSettings: SharedBrowserSettings = {
+				...currentSettings, // Start with existing settings (and defaults)
+				viewport: {
+					// Apply updates from request
+					width: request.browserSettings.viewport?.width || currentSettings.viewport.width,
+					height: request.browserSettings.viewport?.height || currentSettings.viewport.height,
+				},
+				// Explicitly handle optional boolean and string fields from the request
+				remoteBrowserEnabled:
+					request.browserSettings.remoteBrowserEnabled === undefined
+						? currentSettings.remoteBrowserEnabled
+						: request.browserSettings.remoteBrowserEnabled,
+				remoteBrowserHost:
+					request.browserSettings.remoteBrowserHost === undefined
+						? currentSettings.remoteBrowserHost
+						: request.browserSettings.remoteBrowserHost,
+				chromeExecutablePath:
+					// If chromeExecutablePath is explicitly in the request (even as ""), use it.
+					// Otherwise, fall back to mergedWithDefaults.
+					"chromeExecutablePath" in request.browserSettings
+						? request.browserSettings.chromeExecutablePath
+						: currentSettings.chromeExecutablePath,
+				disableToolUse:
+					request.browserSettings.disableToolUse === undefined
+						? currentSettings.disableToolUse
+						: request.browserSettings.disableToolUse,
+				customArgs:
+					"customArgs" in request.browserSettings ? request.browserSettings.customArgs : currentSettings.customArgs,
+			}
+
+			// Update global state with new settings
+			controller.stateManager.setGlobalState("browserSettings", newBrowserSettings)
+		}
+
+		// Update default terminal profile
+		if (request.defaultTerminalProfile !== undefined) {
+			controller.stateManager.setGlobalState("defaultTerminalProfile", request.defaultTerminalProfile)
+			// Update the live terminal manager so new terminals use the new profile.
+			// Existing terminals are left open — they're keyed by effective shell
+			// and reused when compatible, or skipped when not.
+			controller.terminalManager?.setDefaultTerminalProfile(request.defaultTerminalProfile)
+		}
+
+		if (request.backgroundEditEnabled !== undefined) {
+			controller.stateManager.setGlobalState("backgroundEditEnabled", !!request.backgroundEditEnabled)
+		}
+
+		if (request.multiRootEnabled !== undefined) {
+			controller.stateManager.setGlobalState("multiRootEnabled", !!request.multiRootEnabled)
+		}
+
+		if (request.optOutOfRemoteConfig !== undefined) {
+			const hadOptedOut = controller.stateManager.getGlobalSettingsKey("optOutOfRemoteConfig")
+			const isOptingOut = !!request.optOutOfRemoteConfig
+			const isReenablingRemoteConfig = !isOptingOut && hadOptedOut
+
+			// Update now so any subsequent function can access the updated value
+			controller.stateManager.setGlobalState("optOutOfRemoteConfig", isOptingOut)
+
+			if (isOptingOut && !hadOptedOut) {
+				clearRemoteConfig()
+			} else if (isReenablingRemoteConfig) {
+				// Fire-and-forget: We don't need to await here
+				// The function catches any errors and posts the updated state to the webview
+				// The immediate state update below shows the user's intent (opted-in),
+				// and we apply the actual config afterwards without blocking the settings update
+				fetchRemoteConfig(controller)
+			}
+		}
+
+		if (request.showFeatureTips !== undefined) {
+			controller.stateManager.setGlobalState("showFeatureTips", request.showFeatureTips)
+		}
+
+		// Post updated state to webview
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error("Failed to update settings:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/updateSettingsCli.ts b/apps/vscode/src/core/controller/state/updateSettingsCli.ts
new file mode 100644
index 0000000..30699b9
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateSettingsCli.ts
@@ -0,0 +1,211 @@
+import { Empty } from "@shared/proto/cline/common"
+import { PlanActMode, UpdateSettingsRequestCli } from "@shared/proto/cline/state"
+import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
+import type { Settings } from "@shared/storage/state-keys"
+import { TelemetrySetting } from "@shared/TelemetrySetting"
+import { ClineEnv } from "@/config"
+import { Logger } from "@/shared/services/Logger"
+import { Mode } from "@/shared/storage/types"
+import { telemetryService } from "../../../services/telemetry"
+import { Controller } from ".."
+import { accountLogoutClicked } from "../account/accountLogoutClicked"
+import { createTaskApiModelShim, resolveActiveModelIdFromApiConfiguration } from "../models/taskApiModel"
+import { normalizeOpenaiReasoningEffort } from "./reasoningEffort"
+
+/**
+ * Updates multiple extension settings in a single request
+ * @param controller The controller instance
+ * @param request The request containing the settings to update
+ * @returns An empty response
+ */
+export async function updateSettingsCli(controller: Controller, request: UpdateSettingsRequestCli): Promise<Empty> {
+	const convertPlanActMode = (mode: PlanActMode): Mode => {
+		return mode === PlanActMode.PLAN ? "plan" : "act"
+	}
+
+	if (request.environment !== undefined) {
+		ClineEnv.setEnvironment(request.environment)
+		await accountLogoutClicked(controller, Empty.create())
+	}
+
+	if (request.settings) {
+		// Extract all special case fields that need dedicated handlers
+		// These should NOT be included in the batch update
+		const {
+			// Fields requiring conversion
+			autoApprovalSettings,
+			planModeReasoningEffort,
+			actModeReasoningEffort,
+			mode,
+			customPrompt,
+			planModeApiProvider,
+			actModeApiProvider,
+			// Fields requiring special logic (telemetry, merging, etc.)
+			telemetrySetting,
+			yoloModeToggled,
+			useAutoCondense,
+			worktreesEnabled,
+			subagentsEnabled,
+			browserSettings,
+			defaultTerminalProfile,
+			...simpleSettings
+		} = request.settings
+
+		// Batch update for simple pass-through fields
+		const filteredSettings: Partial<Settings> = Object.fromEntries(
+			Object.entries(simpleSettings).filter(([key, value]) => key !== "openaiReasoningEffort" && value !== undefined),
+		)
+
+		controller.stateManager.setGlobalStateBatch(filteredSettings)
+
+		Logger.log("autoApprovalSettings", controller.stateManager.getGlobalSettingsKey("autoApprovalSettings"))
+
+		// Handle fields requiring type conversion from generated protobuf types to application types
+		if (autoApprovalSettings) {
+			// Merge with current settings to preserve unspecified fields
+			const currentAutoApprovalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+			const mergedSettings = {
+				...currentAutoApprovalSettings,
+				...(autoApprovalSettings.version !== undefined && { version: autoApprovalSettings.version }),
+				...(autoApprovalSettings.enableNotifications !== undefined && {
+					enableNotifications: autoApprovalSettings.enableNotifications,
+				}),
+				actions: {
+					...currentAutoApprovalSettings.actions,
+					...(autoApprovalSettings.actions
+						? Object.fromEntries(Object.entries(autoApprovalSettings.actions).filter(([_, v]) => v !== undefined))
+						: {}),
+				},
+			}
+
+			controller.stateManager.setGlobalState("autoApprovalSettings", mergedSettings)
+		}
+
+		if (planModeReasoningEffort !== undefined) {
+			const converted = normalizeOpenaiReasoningEffort(planModeReasoningEffort)
+			controller.stateManager.setGlobalState("planModeReasoningEffort", converted)
+		}
+
+		if (actModeReasoningEffort !== undefined) {
+			const converted = normalizeOpenaiReasoningEffort(actModeReasoningEffort)
+			controller.stateManager.setGlobalState("actModeReasoningEffort", converted)
+		}
+
+		if (mode !== undefined) {
+			const converted = convertPlanActMode(mode)
+			controller.stateManager.setGlobalState("mode", converted)
+		}
+
+		if (customPrompt === "compact") {
+			controller.stateManager.setGlobalState("customPrompt", "compact")
+		}
+
+		if (planModeApiProvider !== undefined) {
+			const converted = convertProtoToApiProvider(planModeApiProvider)
+			controller.stateManager.setGlobalState("planModeApiProvider", converted)
+		}
+
+		if (actModeApiProvider !== undefined) {
+			const converted = convertProtoToApiProvider(actModeApiProvider)
+			controller.stateManager.setGlobalState("actModeApiProvider", converted)
+		}
+
+		if (controller.task) {
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+			const modelId = resolveActiveModelIdFromApiConfiguration(controller.stateManager.getApiConfiguration(), currentMode)
+			controller.task.api = createTaskApiModelShim(modelId)
+		}
+
+		// Update telemetry setting
+		if (telemetrySetting) {
+			await controller.updateTelemetrySetting(telemetrySetting as TelemetrySetting)
+		}
+
+		// Update yolo mode setting (requires telemetry)
+		if (yoloModeToggled !== undefined) {
+			if (controller.task) {
+				telemetryService.captureYoloModeToggle(controller.task.ulid, yoloModeToggled)
+			}
+			controller.stateManager.setGlobalState("yoloModeToggled", yoloModeToggled)
+		}
+
+		// Update auto-condense setting (requires telemetry)
+		if (useAutoCondense !== undefined) {
+			if (controller.task) {
+				telemetryService.captureAutoCondenseToggle(
+					controller.task.ulid,
+					useAutoCondense,
+					controller.task.api.getModel().id,
+				)
+			}
+			controller.stateManager.setGlobalState("useAutoCondense", useAutoCondense)
+		}
+
+		// Update worktrees setting
+		if (worktreesEnabled !== undefined) {
+			controller.stateManager.setGlobalState("worktreesEnabled", worktreesEnabled)
+		}
+
+		// Update subagents setting (requires telemetry on state change)
+		if (subagentsEnabled !== undefined) {
+			const wasEnabled = controller.stateManager.getGlobalSettingsKey("subagentsEnabled") ?? false
+			const isEnabled = !!subagentsEnabled
+			controller.stateManager.setGlobalState("subagentsEnabled", isEnabled)
+
+			if (wasEnabled !== isEnabled) {
+				telemetryService.captureSubagentToggle(isEnabled)
+			}
+		}
+
+		// Update browser settings (requires careful merging to avoid protobuf defaults)
+		if (browserSettings !== undefined) {
+			const currentSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
+
+			const newBrowserSettings = {
+				...currentSettings,
+				viewport: {
+					width: browserSettings.viewport?.width || currentSettings.viewport.width,
+					height: browserSettings.viewport?.height || currentSettings.viewport.height,
+				},
+				...(browserSettings.remoteBrowserEnabled !== undefined && {
+					remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
+				}),
+				...(browserSettings.remoteBrowserHost !== undefined && {
+					remoteBrowserHost: browserSettings.remoteBrowserHost,
+				}),
+				...(browserSettings.chromeExecutablePath !== undefined && {
+					chromeExecutablePath: browserSettings.chromeExecutablePath,
+				}),
+				...(browserSettings.disableToolUse !== undefined && {
+					disableToolUse: browserSettings.disableToolUse,
+				}),
+				...(browserSettings.customArgs !== undefined && {
+					customArgs: browserSettings.customArgs,
+				}),
+			}
+
+			controller.stateManager.setGlobalState("browserSettings", newBrowserSettings)
+		}
+
+		// Update default terminal profile
+		if (defaultTerminalProfile !== undefined && defaultTerminalProfile !== "") {
+			controller.stateManager.setGlobalState("defaultTerminalProfile", defaultTerminalProfile)
+			// Update the live terminal manager so new terminals use the new profile.
+			// Existing terminals are left open — they're keyed by effective shell
+			// and reused when compatible, or skipped when not.
+			controller.terminalManager?.setDefaultTerminalProfile(defaultTerminalProfile)
+		}
+	}
+
+	// Handle secrets updates
+	if (request.secrets) {
+		const filteredSecrets = Object.fromEntries(Object.entries(request.secrets).filter(([_, value]) => value !== undefined))
+
+		controller.stateManager.setSecretsBatch(filteredSecrets)
+	}
+
+	// Post updated state to webview
+	await controller.postStateToWebview()
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/updateTaskSettings.ts b/apps/vscode/src/core/controller/state/updateTaskSettings.ts
new file mode 100644
index 0000000..08889f3
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateTaskSettings.ts
@@ -0,0 +1,142 @@
+import { Empty } from "@shared/proto/cline/common"
+import { PlanActMode, UpdateTaskSettingsRequest } from "@shared/proto/cline/state"
+import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { Mode } from "@/shared/storage/types"
+import { Controller } from ".."
+import { normalizeOpenaiReasoningEffort } from "./reasoningEffort"
+
+/**
+ * Updates task-specific settings for the current task
+ * @param controller The controller instance
+ * @param request The request containing the task settings to update
+ * @returns An empty response
+ */
+export async function updateTaskSettings(controller: Controller, request: UpdateTaskSettingsRequest): Promise<Empty> {
+	const convertPlanActMode = (mode: PlanActMode): Mode => {
+		return mode === PlanActMode.PLAN ? "plan" : "act"
+	}
+
+	try {
+		// Get taskId from request first, otherwise fall back to current task
+		let taskId: string
+		if (request.taskId) {
+			taskId = request.taskId
+		} else {
+			// Use current task if no taskId is provided
+			if (!controller.task) {
+				throw new Error("No active task to update settings for")
+			}
+			taskId = controller.task.taskId
+		}
+
+		if (request.settings) {
+			// Extract all special case fields that need dedicated handlers
+			const {
+				// Fields requiring conversion
+				autoApprovalSettings,
+				planModeReasoningEffort,
+				actModeReasoningEffort,
+				mode,
+				customPrompt,
+				planModeApiProvider,
+				actModeApiProvider,
+				// Fields requiring special logic
+				browserSettings,
+				...simpleSettings
+			} = request.settings
+
+			// Batch update for simple pass-through fields
+			const filteredSettings: any = Object.fromEntries(
+				Object.entries(simpleSettings).filter(([key, value]) => key !== "openaiReasoningEffort" && value !== undefined),
+			)
+
+			controller.stateManager.setTaskSettingsBatch(taskId, filteredSettings)
+
+			// Handle fields requiring type conversion from generated protobuf types to application types
+			if (autoApprovalSettings) {
+				// Merge with current settings to preserve unspecified fields
+				const currentAutoApprovalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+				const mergedSettings = {
+					...currentAutoApprovalSettings,
+					...(autoApprovalSettings.version !== undefined && { version: autoApprovalSettings.version }),
+					...(autoApprovalSettings.enableNotifications !== undefined && {
+						enableNotifications: autoApprovalSettings.enableNotifications,
+					}),
+					actions: {
+						...currentAutoApprovalSettings.actions,
+						...(autoApprovalSettings.actions
+							? Object.fromEntries(Object.entries(autoApprovalSettings.actions).filter(([_, v]) => v !== undefined))
+							: {}),
+					},
+				}
+				controller.stateManager.setTaskSettings(taskId, "autoApprovalSettings", mergedSettings)
+			}
+
+			if (planModeReasoningEffort !== undefined) {
+				const converted = normalizeOpenaiReasoningEffort(planModeReasoningEffort)
+				controller.stateManager.setTaskSettings(taskId, "planModeReasoningEffort", converted)
+			}
+
+			if (actModeReasoningEffort !== undefined) {
+				const converted = normalizeOpenaiReasoningEffort(actModeReasoningEffort)
+				controller.stateManager.setTaskSettings(taskId, "actModeReasoningEffort", converted)
+			}
+
+			if (mode !== undefined) {
+				const converted = convertPlanActMode(mode)
+				controller.stateManager.setTaskSettings(taskId, "mode", converted)
+			}
+
+			if (customPrompt === "compact") {
+				controller.stateManager.setTaskSettings(taskId, "customPrompt", "compact")
+			}
+
+			if (planModeApiProvider !== undefined) {
+				const converted = convertProtoToApiProvider(planModeApiProvider)
+				controller.stateManager.setTaskSettings(taskId, "planModeApiProvider", converted)
+			}
+
+			if (actModeApiProvider !== undefined) {
+				const converted = convertProtoToApiProvider(actModeApiProvider)
+				controller.stateManager.setTaskSettings(taskId, "actModeApiProvider", converted)
+			}
+
+			// Update browser settings (requires careful merging to avoid protobuf defaults)
+			if (browserSettings !== undefined) {
+				const currentSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
+
+				const newBrowserSettings = {
+					...currentSettings,
+					viewport: {
+						width: browserSettings.viewport?.width || currentSettings.viewport.width,
+						height: browserSettings.viewport?.height || currentSettings.viewport.height,
+					},
+					...(browserSettings.remoteBrowserEnabled !== undefined && {
+						remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
+					}),
+					...(browserSettings.remoteBrowserHost !== undefined && {
+						remoteBrowserHost: browserSettings.remoteBrowserHost,
+					}),
+					...(browserSettings.chromeExecutablePath !== undefined && {
+						chromeExecutablePath: browserSettings.chromeExecutablePath,
+					}),
+					...(browserSettings.disableToolUse !== undefined && {
+						disableToolUse: browserSettings.disableToolUse,
+					}),
+					...(browserSettings.customArgs !== undefined && {
+						customArgs: browserSettings.customArgs,
+					}),
+				}
+
+				controller.stateManager.setTaskSettings(taskId, "browserSettings", newBrowserSettings)
+			}
+		}
+
+		// Post updated state to webview
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/state/updateTelemetrySetting.ts b/apps/vscode/src/core/controller/state/updateTelemetrySetting.ts
new file mode 100644
index 0000000..d04db82
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateTelemetrySetting.ts
@@ -0,0 +1,16 @@
+import { Empty } from "@shared/proto/cline/common"
+import { TelemetrySettingRequest } from "@shared/proto/cline/state"
+import { convertProtoTelemetrySettingToDomain } from "../../../shared/proto-conversions/state/telemetry-setting-conversion"
+import { Controller } from ".."
+
+/**
+ * Updates the telemetry setting
+ * @param controller The controller instance
+ * @param request The telemetry setting request
+ * @returns Empty response
+ */
+export async function updateTelemetrySetting(controller: Controller, request: TelemetrySettingRequest): Promise<Empty> {
+	const telemetrySetting = convertProtoTelemetrySettingToDomain(request.setting)
+	await controller.updateTelemetrySetting(telemetrySetting)
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/state/updateTerminalConnectionTimeout.ts b/apps/vscode/src/core/controller/state/updateTerminalConnectionTimeout.ts
new file mode 100644
index 0000000..67ae1ff
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateTerminalConnectionTimeout.ts
@@ -0,0 +1,17 @@
+import { UpdateTerminalConnectionTimeoutRequest, UpdateTerminalConnectionTimeoutResponse } from "@shared/proto/cline/state"
+import { Controller } from "../index"
+
+export async function updateTerminalConnectionTimeout(
+	controller: Controller,
+	request: UpdateTerminalConnectionTimeoutRequest,
+): Promise<UpdateTerminalConnectionTimeoutResponse> {
+	const timeoutMs = request.timeoutMs
+
+	// Update the terminal connection timeout setting in the state
+	controller.stateManager.setGlobalState("shellIntegrationTimeout", timeoutMs || 4000)
+
+	// Broadcast state update to all webviews
+	await controller.postStateToWebview()
+
+	return { timeoutMs }
+}
diff --git a/apps/vscode/src/core/controller/state/updateTerminalReuseEnabled.ts b/apps/vscode/src/core/controller/state/updateTerminalReuseEnabled.ts
new file mode 100644
index 0000000..b935cdd
--- /dev/null
+++ b/apps/vscode/src/core/controller/state/updateTerminalReuseEnabled.ts
@@ -0,0 +1,17 @@
+import * as proto from "@/shared/proto"
+import { Controller } from "../index"
+
+export async function updateTerminalReuseEnabled(
+	controller: Controller,
+	request: proto.cline.BooleanRequest,
+): Promise<proto.cline.Empty> {
+	const enabled = request.value
+
+	// Update the terminal reuse setting in the state
+	controller.stateManager.setGlobalState("terminalReuseEnabled", enabled)
+
+	// Broadcast state update to all webviews
+	await controller.postStateToWebview()
+
+	return proto.cline.Empty.create({})
+}
diff --git a/apps/vscode/src/core/controller/task/askResponse.ts b/apps/vscode/src/core/controller/task/askResponse.ts
new file mode 100644
index 0000000..86c3ab4
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/askResponse.ts
@@ -0,0 +1,46 @@
+import { Empty } from "@shared/proto/cline/common"
+import { AskResponseRequest } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import { ClineAskResponse } from "../../../shared/WebviewMessage"
+import { Controller } from ".."
+
+/**
+ * Handles a response from the webview for a previous ask operation
+ *
+ * @param controller The controller instance
+ * @param request The request containing response type, optional text and optional images
+ * @returns Empty response
+ */
+export async function askResponse(controller: Controller, request: AskResponseRequest): Promise<Empty> {
+	try {
+		if (!controller.task) {
+			Logger.warn("askResponse: No active task to receive response")
+			return Empty.create()
+		}
+
+		// Map the string responseType to the ClineAskResponse enum
+		let responseType: ClineAskResponse
+		switch (request.responseType) {
+			case "yesButtonClicked":
+				responseType = "yesButtonClicked"
+				break
+			case "noButtonClicked":
+				responseType = "noButtonClicked"
+				break
+			case "messageResponse":
+				responseType = "messageResponse"
+				break
+			default:
+				Logger.warn(`askResponse: Unknown response type: ${request.responseType}`)
+				return Empty.create()
+		}
+
+		// Call the task's handler for webview responses
+		await controller.task.handleWebviewAskResponse(responseType, request.text, request.images, request.files)
+
+		return Empty.create()
+	} catch (error) {
+		Logger.error("Error in askResponse handler:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/cancelBackgroundCommand.ts b/apps/vscode/src/core/controller/task/cancelBackgroundCommand.ts
new file mode 100644
index 0000000..7aaad7f
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/cancelBackgroundCommand.ts
@@ -0,0 +1,10 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+export async function cancelBackgroundCommand(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	const controllerWithCancel = controller as Controller & {
+		cancelBackgroundCommand: () => Promise<void>
+	}
+	await controllerWithCancel.cancelBackgroundCommand()
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/task/cancelQueuedPrompt.ts b/apps/vscode/src/core/controller/task/cancelQueuedPrompt.ts
new file mode 100644
index 0000000..65ad2b0
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/cancelQueuedPrompt.ts
@@ -0,0 +1,20 @@
+import { Empty, type StringRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Cancels a queued prompt for the active SDK session.
+ *
+ * @param controller The controller instance
+ * @param request The request containing the queued prompt ID
+ * @returns Empty response
+ */
+export async function cancelQueuedPrompt(controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		await controller.cancelQueuedPrompt(request.value)
+		return Empty.create()
+	} catch (error) {
+		Logger.error("Error in cancelQueuedPrompt handler:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/cancelTask.ts b/apps/vscode/src/core/controller/task/cancelTask.ts
new file mode 100644
index 0000000..c152efa
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/cancelTask.ts
@@ -0,0 +1,13 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Cancel the currently running task
+ * @param controller The controller instance
+ * @param _request The empty request
+ * @returns Empty response
+ */
+export async function cancelTask(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	await controller.cancelTask()
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/task/clearTask.ts b/apps/vscode/src/core/controller/task/clearTask.ts
new file mode 100644
index 0000000..d6ed2a8
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/clearTask.ts
@@ -0,0 +1,25 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Clears the current task
+ * @param controller The controller instance
+ * @param _request The empty request
+ * @returns Empty response
+ */
+export async function clearTask(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	const startedAt = Date.now()
+	await controller.clearTask()
+	const afterClearTask = Date.now()
+	await controller.postStateToWebview()
+	const totalElapsed = Date.now() - startedAt
+
+	if (totalElapsed > 250) {
+		Logger.warn(
+			`[TaskService.clearTask] took ${totalElapsed}ms (controller.clearTask=${afterClearTask - startedAt}ms, postStateToWebview=${Date.now() - afterClearTask}ms)`,
+		)
+	}
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/task/deleteAllTaskHistory.ts b/apps/vscode/src/core/controller/task/deleteAllTaskHistory.ts
new file mode 100644
index 0000000..6ec1ac2
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/deleteAllTaskHistory.ts
@@ -0,0 +1,18 @@
+import { DeleteAllTaskHistoryCount } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Deletes all task history, with an option to preserve favorites
+ * @param controller The controller instance
+ * @param request Request with option to preserve favorites
+ * @returns Results with count of deleted tasks
+ */
+export async function deleteAllTaskHistory(controller: Controller): Promise<DeleteAllTaskHistoryCount> {
+	try {
+		return await controller.deleteAllTaskHistory()
+	} catch (error) {
+		Logger.error("Error in deleteAllTaskHistory:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/deleteTasksWithIds.ts b/apps/vscode/src/core/controller/task/deleteTasksWithIds.ts
new file mode 100644
index 0000000..ab075c5
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/deleteTasksWithIds.ts
@@ -0,0 +1,60 @@
+import { Empty, StringArrayRequest } from "@shared/proto/cline/common"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Deletes tasks with the specified IDs
+ * @param controller The controller instance
+ * @param request The request containing an array of task IDs to delete
+ * @returns Empty response
+ * @throws Error if operation fails
+ */
+export async function deleteTasksWithIds(controller: Controller, request: StringArrayRequest): Promise<Empty> {
+	if (!request.value || request.value.length === 0) {
+		throw new Error("Missing task IDs")
+	}
+
+	const taskCount = request.value.length
+	const message =
+		taskCount === 1
+			? "Are you sure you want to delete this task? This action cannot be undone."
+			: `Are you sure you want to delete these ${taskCount} tasks? This action cannot be undone.`
+
+	const userChoice = await HostProvider.window.showMessage({
+		type: ShowMessageType.WARNING,
+		message,
+		options: { modal: true, items: ["Delete"] },
+	})
+
+	if (userChoice.selectedOption !== "Delete") {
+		return Empty.create()
+	}
+
+	for (const id of request.value) {
+		await deleteTaskWithId(controller, id)
+	}
+
+	return Empty.create()
+}
+
+/**
+ * Deletes a single task with the specified ID
+ * @param controller The controller instance
+ * @param id The task ID to delete
+ */
+async function deleteTaskWithId(controller: Controller, id: string): Promise<void> {
+	// Clear current task if it matches the ID being deleted
+	if (id === controller.task?.taskId) {
+		await controller.clearTask()
+		Logger.debug("cleared task")
+	}
+
+	// Remove task from state FIRST — this updates the in-memory cache
+	// immediately so the next postStateToWebview() sends the updated list.
+	await controller.deleteTaskFromState(id)
+
+	// Always update webview state so the history list and recents refresh
+	await controller.postStateToWebview()
+}
diff --git a/apps/vscode/src/core/controller/task/editMessageAndRegenerate.ts b/apps/vscode/src/core/controller/task/editMessageAndRegenerate.ts
new file mode 100644
index 0000000..8dac74e
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/editMessageAndRegenerate.ts
@@ -0,0 +1,24 @@
+import { Empty } from "@shared/proto/cline/common"
+import { EditMessageAndRegenerateRequest } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Edits a previous user message, truncates the conversation after that point,
+ * and starts a fresh turn from the edited message.
+ */
+export async function editMessageAndRegenerate(controller: Controller, request: EditMessageAndRegenerateRequest): Promise<Empty> {
+	try {
+		await controller.editMessageAndRegenerate({
+			messageTs: request.messageTs,
+			text: request.text,
+			images: request.images,
+			files: request.files,
+			restoreWorkspace: request.restoreWorkspace,
+		})
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("Error in editMessageAndRegenerate handler:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/executeQuickWin.ts b/apps/vscode/src/core/controller/task/executeQuickWin.ts
new file mode 100644
index 0000000..b25e18f
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/executeQuickWin.ts
@@ -0,0 +1,36 @@
+import { Empty } from "@shared/proto/cline/common"
+import { ExecuteQuickWinRequest } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Executes a quick win task with command and title
+ * @param controller The controller instance
+ * @param request The execute quick win request
+ * @returns Empty response
+ *
+ * @example
+ * // Usage from webview:
+ * import { TaskServiceClient } from "@/services/grpc-client"
+ * import { ExecuteQuickWinRequest } from "@shared/proto/cline/task"
+ *
+ * const request: ExecuteQuickWinRequest = {
+ *   command: "npm install",
+ *   title: "Install dependencies"
+ * }
+ *
+ * TaskServiceClient.executeQuickWin(request)
+ *   .then(() => Logger.log("Quick win executed successfully"))
+ *   .catch(error => Logger.error("Failed to execute quick win:", error))
+ */
+export async function executeQuickWin(controller: Controller, request: ExecuteQuickWinRequest): Promise<Empty> {
+	try {
+		const { command, title } = request
+		Logger.log(`Received executeQuickWin: command='${command}', title='${title}'`)
+		await controller.initTask(title)
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("Failed to execute quick win:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/exportTaskWithId.ts b/apps/vscode/src/core/controller/task/exportTaskWithId.ts
new file mode 100644
index 0000000..f684b06
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/exportTaskWithId.ts
@@ -0,0 +1,22 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Exports a task with the given ID to markdown
+ * @param controller The controller instance
+ * @param request The request containing the task ID in the value field
+ * @returns Empty response
+ */
+export async function exportTaskWithId(controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		if (request.value) {
+			await controller.exportTaskWithId(request.value)
+		}
+		return Empty.create()
+	} catch (error) {
+		// Log the error but allow it to propagate for proper gRPC error handling
+		Logger.error(`Error exporting task with ID ${request.value}:`, error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/getTaskHistory.ts b/apps/vscode/src/core/controller/task/getTaskHistory.ts
new file mode 100644
index 0000000..9daa10b
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/getTaskHistory.ts
@@ -0,0 +1,19 @@
+import { GetTaskHistoryRequest, TaskHistoryArray } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Gets filtered task history.
+ * Task history retrieval/filtering is delegated to the SDK-backed controller.
+ * @param controller The controller instance
+ * @param request Filter parameters for task history
+ * @returns TaskHistoryArray with filtered task list
+ */
+export async function getTaskHistory(controller: Controller, request: GetTaskHistoryRequest): Promise<TaskHistoryArray> {
+	try {
+		return await controller.getTaskHistory(request)
+	} catch (error) {
+		Logger.error("Error in getTaskHistory:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/getTotalTasksSize.ts b/apps/vscode/src/core/controller/task/getTotalTasksSize.ts
new file mode 100644
index 0000000..0c1694e
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/getTotalTasksSize.ts
@@ -0,0 +1,14 @@
+import { EmptyRequest, Int64 } from "@shared/proto/cline/common"
+import { getTotalTasksSize as calculateTotalTasksSize } from "../../../utils/storage"
+import { Controller } from ".."
+
+/**
+ * Gets the total size of all tasks including task data and checkpoints
+ * @param controller The controller instance
+ * @param _request The empty request
+ * @returns The total size as an Int64 value
+ */
+export async function getTotalTasksSize(_controller: Controller, _request: EmptyRequest): Promise<Int64> {
+	const totalSize = await calculateTotalTasksSize()
+	return { value: totalSize || 0 }
+}
diff --git a/apps/vscode/src/core/controller/task/newTask.ts b/apps/vscode/src/core/controller/task/newTask.ts
new file mode 100644
index 0000000..7431a5d
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/newTask.ts
@@ -0,0 +1,77 @@
+import { String } from "@shared/proto/cline/common"
+import { PlanActMode } from "@shared/proto/cline/state"
+import { NewTaskRequest } from "@shared/proto/cline/task"
+import { Settings } from "@shared/storage/state-keys"
+import { convertProtoToApiProvider } from "@/shared/proto-conversions/models/api-configuration-conversion"
+import { DEFAULT_BROWSER_SETTINGS } from "../../../shared/BrowserSettings"
+import { Controller } from ".."
+import { normalizeOpenaiReasoningEffort } from "../state/reasoningEffort"
+
+/**
+ * Creates a new task with the given text and optional images
+ * @param controller The controller instance
+ * @param request The new task request containing text and optional images, and optional task settings
+ * @returns Empty response
+ */
+export async function newTask(controller: Controller, request: NewTaskRequest): Promise<String> {
+	const convertPlanActMode = (mode: PlanActMode): string => {
+		return mode === PlanActMode.PLAN ? "plan" : "act"
+	}
+
+	const filteredTaskSettings: Partial<Settings> = Object.fromEntries(
+		Object.entries({
+			...request.taskSettings,
+			...(request.taskSettings?.autoApprovalSettings && {
+				autoApprovalSettings: (() => {
+					// Merge with global settings to ensure complete settings for new task
+					const globalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+					const incomingSettings = request.taskSettings.autoApprovalSettings
+					return {
+						...globalSettings,
+						...(incomingSettings.version !== undefined && { version: incomingSettings.version }),
+						...(incomingSettings.enableNotifications !== undefined && {
+							enableNotifications: incomingSettings.enableNotifications,
+						}),
+						actions: {
+							...globalSettings.actions,
+							...(incomingSettings.actions
+								? Object.fromEntries(Object.entries(incomingSettings.actions).filter(([_, v]) => v !== undefined))
+								: {}),
+						},
+					}
+				})(),
+			}),
+			...(request.taskSettings?.browserSettings && {
+				browserSettings: {
+					viewport: request.taskSettings.browserSettings.viewport || DEFAULT_BROWSER_SETTINGS.viewport,
+					remoteBrowserHost: request.taskSettings.browserSettings.remoteBrowserHost,
+					remoteBrowserEnabled: request.taskSettings.browserSettings.remoteBrowserEnabled,
+					chromeExecutablePath: request.taskSettings.browserSettings.chromeExecutablePath,
+					disableToolUse: request.taskSettings.browserSettings.disableToolUse,
+					customArgs: request.taskSettings.browserSettings.customArgs,
+				},
+			}),
+			...(request.taskSettings?.planModeReasoningEffort !== undefined && {
+				planModeReasoningEffort: normalizeOpenaiReasoningEffort(request.taskSettings.planModeReasoningEffort),
+			}),
+			...(request.taskSettings?.actModeReasoningEffort !== undefined && {
+				actModeReasoningEffort: normalizeOpenaiReasoningEffort(request.taskSettings.actModeReasoningEffort),
+			}),
+			...(request.taskSettings?.mode !== undefined && {
+				mode: convertPlanActMode(request.taskSettings.mode),
+			}),
+			...(request.taskSettings?.customPrompt === "compact" && {
+				customPrompt: "compact",
+			}),
+			...(request.taskSettings?.planModeApiProvider !== undefined && {
+				planModeApiProvider: convertProtoToApiProvider(request.taskSettings.planModeApiProvider),
+			}),
+			...(request.taskSettings?.actModeApiProvider !== undefined && {
+				actModeApiProvider: convertProtoToApiProvider(request.taskSettings.actModeApiProvider),
+			}),
+		}).filter(([_, value]) => value !== undefined),
+	)
+
+	const taskId = await controller.initTask(request.text, request.images, request.files, undefined, filteredTaskSettings)
+	return String.create({ value: taskId || "" })
+}
diff --git a/apps/vscode/src/core/controller/task/showTaskWithId.ts b/apps/vscode/src/core/controller/task/showTaskWithId.ts
new file mode 100644
index 0000000..d34b096
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/showTaskWithId.ts
@@ -0,0 +1,20 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { TaskResponse } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
+
+/**
+ * Shows a task with the specified ID by loading its messages from disk.
+ * Task lookup/loading is delegated to the SDK-backed controller.
+ */
+export async function showTaskWithId(controller: Controller, request: StringRequest): Promise<TaskResponse> {
+	try {
+		const response = await controller.showTaskWithId(request.value)
+		await sendChatButtonClickedEvent()
+		return response
+	} catch (error) {
+		Logger.error("Error in showTaskWithId:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/task/taskFeedback.ts b/apps/vscode/src/core/controller/task/taskFeedback.ts
new file mode 100644
index 0000000..17d86cf
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/taskFeedback.ts
@@ -0,0 +1,29 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Handles task feedback submission (thumbs up/down)
+ * @param controller The controller instance
+ * @param request The StringRequest containing the feedback type ("thumbs_up" or "thumbs_down") in the value field
+ * @returns Empty response
+ */
+export async function taskFeedback(controller: Controller, request: StringRequest): Promise<Empty> {
+	if (!request.value) {
+		Logger.warn("taskFeedback: Missing feedback type value")
+		return Empty.create()
+	}
+
+	try {
+		if (controller.task?.ulid) {
+			telemetryService.captureTaskFeedback(controller.task.ulid, request.value as any)
+		} else {
+			Logger.warn("taskFeedback: No active task to receive feedback")
+		}
+	} catch (error) {
+		Logger.error("Error in taskFeedback handler:", error)
+	}
+
+	return Empty.create()
+}
diff --git a/apps/vscode/src/core/controller/task/toggleTaskFavorite.ts b/apps/vscode/src/core/controller/task/toggleTaskFavorite.ts
new file mode 100644
index 0000000..af83780
--- /dev/null
+++ b/apps/vscode/src/core/controller/task/toggleTaskFavorite.ts
@@ -0,0 +1,19 @@
+import { Empty } from "@shared/proto/cline/common"
+import { TaskFavoriteRequest } from "@shared/proto/cline/task"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../"
+
+export async function toggleTaskFavorite(controller: Controller, request: TaskFavoriteRequest): Promise<Empty> {
+	if (!request.taskId) {
+		Logger.error(`[toggleTaskFavorite] Invalid request: taskId missing`)
+		return Empty.create({})
+	}
+
+	try {
+		await controller.toggleTaskFavorite(request.taskId, request.isFavorited)
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("Error in toggleTaskFavorite:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/getWebviewHtml.ts b/apps/vscode/src/core/controller/ui/getWebviewHtml.ts
new file mode 100644
index 0000000..4dddbc1
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/getWebviewHtml.ts
@@ -0,0 +1,14 @@
+import { EmptyRequest, String } from "@shared/proto/cline/common"
+import { WebviewProvider } from "@/core/webview"
+import type { Controller } from "../index"
+
+/**
+ * Returns the HTML content of the webview.
+ *
+ * This is only used by the standalone service. The Vscode extension gets the HTML directly from the webview when it
+ * resolved through `resolveWebviewView()`.
+ */
+export async function getWebviewHtml(_controller: Controller, _: EmptyRequest): Promise<String> {
+	const webview = WebviewProvider.getInstance()
+	return Promise.resolve(String.create({ value: webview.getHtmlContent() }))
+}
diff --git a/apps/vscode/src/core/controller/ui/initializeWebview.ts b/apps/vscode/src/core/controller/ui/initializeWebview.ts
new file mode 100644
index 0000000..6cad845
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/initializeWebview.ts
@@ -0,0 +1,222 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import { GlobalStateAndSettings } from "@/shared/storage/state-keys"
+import type { Controller } from "../index"
+import { refreshBasetenModels } from "../models/refreshBasetenModels"
+
+import { refreshGroqModels } from "../models/refreshGroqModels"
+import { refreshHicapModels } from "../models/refreshHicapModels"
+import { refreshLiteLlmModels } from "../models/refreshLiteLlmModels"
+import { refreshOpenRouterModels } from "../models/refreshOpenRouterModels"
+import { sendOpenRouterModelsEvent } from "../models/subscribeToOpenRouterModels"
+
+/**
+ * Initialize webview when it launches
+ * @param controller The controller instance
+ * @param request The empty request
+ * @returns Empty response
+ */
+export async function initializeWebview(controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	try {
+		// Post last cached models as soon as possible for immediate availability in the UI
+		const lastCachedModels = await controller.readOpenRouterModels()
+		if (lastCachedModels) {
+			sendOpenRouterModelsEvent(OpenRouterCompatibleModelInfo.create({ models: lastCachedModels }))
+		}
+
+		// Refresh OpenRouter models from API
+		refreshOpenRouterModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
+				// Update model info in state (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
+				const apiConfiguration = controller.stateManager.getApiConfiguration()
+				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+				const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+
+				if (planActSeparateModelsSetting) {
+					// Separate models: update only current mode
+					const modelIdField = currentMode === "plan" ? "planModeOpenRouterModelId" : "actModeOpenRouterModelId"
+					const modelInfoField = currentMode === "plan" ? "planModeOpenRouterModelInfo" : "actModeOpenRouterModelInfo"
+					const modelId = apiConfiguration[modelIdField]
+
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
+						await controller.postStateToWebview()
+					}
+				} else {
+					// Shared models: update both plan and act modes
+					const planModelId = apiConfiguration.planModeOpenRouterModelId
+					const actModelId = apiConfiguration.actModeOpenRouterModelId
+					const updates: Partial<GlobalStateAndSettings> = {}
+
+					// Update plan mode model info if we have a model ID
+					if (planModelId && models[planModelId]) {
+						updates.planModeOpenRouterModelInfo = models[planModelId]
+					}
+
+					// Update act mode model info if we have a model ID
+					if (actModelId && models[actModelId]) {
+						updates.actModeOpenRouterModelInfo = models[actModelId]
+					}
+
+					// Post state update if we updated any model info
+					if (Object.keys(updates).length > 0) {
+						controller.stateManager.setGlobalStateBatch(updates)
+						await controller.postStateToWebview()
+					}
+				}
+			}
+		})
+
+		refreshGroqModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
+				// Update model info in state for Groq (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
+				const apiConfiguration = controller.stateManager.getApiConfiguration()
+				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+				const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+
+				if (planActSeparateModelsSetting) {
+					// Separate models: update only current mode
+					const modelIdField = currentMode === "plan" ? "planModeGroqModelId" : "actModeGroqModelId"
+					const modelInfoField = currentMode === "plan" ? "planModeGroqModelInfo" : "actModeGroqModelInfo"
+					const modelId = apiConfiguration[modelIdField]
+
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
+						await controller.postStateToWebview()
+					}
+				} else {
+					// Shared models: update both plan and act modes
+					const planModelId = apiConfiguration.planModeGroqModelId
+					const actModelId = apiConfiguration.actModeGroqModelId
+					const updates: Partial<GlobalStateAndSettings> = {}
+
+					// Update plan mode model info if we have a model ID
+					if (planModelId && models[planModelId]) {
+						updates.planModeGroqModelInfo = models[planModelId]
+					}
+
+					// Update act mode model info if we have a model ID
+					if (actModelId && models[actModelId]) {
+						updates.actModeGroqModelInfo = models[actModelId]
+					}
+
+					// Post state update if we updated any model info
+					if (Object.keys(updates).length > 0) {
+						controller.stateManager.setGlobalStateBatch(updates)
+						await controller.postStateToWebview()
+					}
+				}
+			}
+		})
+
+		refreshBasetenModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
+				// Update model info in state for Baseten (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
+				const apiConfiguration = controller.stateManager.getApiConfiguration()
+				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+
+				const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+
+				if (planActSeparateModelsSetting) {
+					// Separate models: update only current mode
+					const modelIdField = currentMode === "plan" ? "planModeBasetenModelId" : "actModeBasetenModelId"
+					const modelInfoField = currentMode === "plan" ? "planModeBasetenModelInfo" : "actModeBasetenModelInfo"
+					const modelId = apiConfiguration[modelIdField]
+
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
+						await controller.postStateToWebview()
+					}
+				} else {
+					// Shared models: update both plan and act modes
+					const planModelId = apiConfiguration.planModeBasetenModelId
+					const actModelId = apiConfiguration.actModeBasetenModelId
+
+					// Update plan mode model info if we have a model ID
+					if (planModelId && models[planModelId]) {
+						controller.stateManager.setGlobalState("planModeBasetenModelInfo", models[planModelId])
+					}
+
+					// Update act mode model info if we have a model ID
+					if (actModelId && models[actModelId]) {
+						controller.stateManager.setGlobalState("actModeBasetenModelInfo", models[actModelId])
+					}
+
+					// Post state update if we updated any model info
+					if ((planModelId && models[planModelId]) || (actModelId && models[actModelId])) {
+						await controller.postStateToWebview()
+					}
+				}
+			}
+		})
+
+		// Refresh Hicap models from API
+		refreshHicapModels(controller, EmptyRequest.create()).then(async (response) => {
+			if (response && response.models) {
+				// Update model info in state (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
+				const apiConfiguration = controller.stateManager.getApiConfiguration()
+				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+				const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+
+				if (planActSeparateModelsSetting) {
+					// Separate models: update only current mode
+					const modelIdField = currentMode === "plan" ? "planModeHicapModelId" : "actModeHicapModelId"
+					const modelInfoField = currentMode === "plan" ? "planModeHicapModelInfo" : "actModeHicapModelInfo"
+					const modelId = apiConfiguration[modelIdField]
+
+					if (modelId && response.models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, response.models[modelId])
+						await controller.postStateToWebview()
+					}
+				} else {
+					// Shared models: update both plan and act modes
+					const planModelId = apiConfiguration.planModeHicapModelId
+					const actModelId = apiConfiguration.actModeHicapModelId
+					const updates: Partial<GlobalStateAndSettings> = {}
+
+					// Update plan mode model info if we have a model ID
+					if (planModelId && response.models[planModelId]) {
+						updates.planModeHicapModelInfo = response.models[planModelId]
+					}
+
+					// Update act mode model info if we have a model ID
+					if (actModelId && response.models[actModelId]) {
+						updates.actModeHicapModelInfo = response.models[actModelId]
+					}
+
+					// Post state update if we updated any model info
+					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
+						controller.stateManager.setGlobalStateBatch(updates)
+						await controller.postStateToWebview()
+					}
+				}
+			}
+		})
+
+		const liteLlmBaseUrl = controller.stateManager.getGlobalSettingsKey("liteLlmBaseUrl")
+		const liteLlmApiKey = controller.stateManager.getSecretKey("liteLlmApiKey")
+		if (liteLlmBaseUrl && liteLlmApiKey) {
+			await refreshLiteLlmModels(controller)
+		}
+
+		// GUI relies on model info to be up-to-date to provide the most accurate pricing, so we need to fetch the latest details on launch.
+		// We do this for all users since many users switch between api providers and if they were to switch back to openrouter it would be showing outdated model info if we hadn't retrieved the latest at this point
+		// (see normalizeApiConfiguration > openrouter)
+		// Prefetch OpenRouter models
+
+		// Initialize telemetry service with user's current setting
+		controller.getStateToPostToWebview().then((state) => {
+			const { telemetrySetting } = state
+			const isOptedIn = telemetrySetting !== "disabled"
+			telemetryService.updateTelemetryState(isOptedIn)
+		})
+
+		return Empty.create({})
+	} catch (error) {
+		Logger.error("Failed to initialize webview:", error)
+		// Return empty response even on error to not break the frontend
+		return Empty.create({})
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/onDidShowAnnouncement.ts b/apps/vscode/src/core/controller/ui/onDidShowAnnouncement.ts
new file mode 100644
index 0000000..7bdf218
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/onDidShowAnnouncement.ts
@@ -0,0 +1,24 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Boolean } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getLatestAnnouncementId } from "@/utils/announcements"
+import type { Controller } from "../index"
+
+/**
+ * Marks the current announcement as shown
+ *
+ * @param controller The controller instance
+ * @param _request The empty request (not used)
+ * @returns Boolean indicating announcement should no longer be shown
+ */
+export async function onDidShowAnnouncement(controller: Controller, _request: EmptyRequest): Promise<Boolean> {
+	try {
+		const latestAnnouncementId = getLatestAnnouncementId()
+		// Update the lastShownAnnouncementId to the current latestAnnouncementId
+		controller.stateManager.setGlobalState("lastShownAnnouncementId", latestAnnouncementId)
+		return Boolean.create({ value: false })
+	} catch (error) {
+		Logger.error("Failed to acknowledge announcement:", error)
+		return Boolean.create({ value: false })
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/openUrl.ts b/apps/vscode/src/core/controller/ui/openUrl.ts
new file mode 100644
index 0000000..effa291
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/openUrl.ts
@@ -0,0 +1,21 @@
+import type { StringRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { openUrlInBrowser } from "../../../utils/github-url-utils"
+import type { Controller } from "../index"
+
+/**
+ * Opens a URL in the default browser
+ * @param controller The controller instance
+ * @param request The URL to open
+ * @returns Empty response
+ */
+export async function openUrl(_controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		await openUrlInBrowser(request.value)
+		return Empty.create({})
+	} catch (error) {
+		Logger.error(`Failed to open URL: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/openWalkthrough.ts b/apps/vscode/src/core/controller/ui/openWalkthrough.ts
new file mode 100644
index 0000000..5abb231
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/openWalkthrough.ts
@@ -0,0 +1,27 @@
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Empty } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+import { ExtensionRegistryInfo } from "@/registry"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Opens the Cline walkthrough in VSCode
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns Empty response
+ */
+export async function openWalkthrough(_controller: Controller, _request: EmptyRequest): Promise<Empty> {
+	try {
+		await vscode.commands.executeCommand(
+			"workbench.action.openWalkthrough",
+			`saoudrizwan.${ExtensionRegistryInfo.name}#ClineWalkthrough`,
+		)
+		telemetryService.captureButtonClick("webview_openWalkthrough")
+		return Empty.create({})
+	} catch (error) {
+		Logger.error(`Failed to open walkthrough: ${error}`)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/scrollToSettings.ts b/apps/vscode/src/core/controller/ui/scrollToSettings.ts
new file mode 100644
index 0000000..108c4ef
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/scrollToSettings.ts
@@ -0,0 +1,15 @@
+import { KeyValuePair, StringRequest } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Executes a scroll to settings action
+ * @param controller The controller instance
+ * @param request The request containing the ID of the settings section to scroll to
+ * @returns KeyValuePair with action and value fields for the UI to process
+ */
+export async function scrollToSettings(_controller: Controller, request: StringRequest): Promise<KeyValuePair> {
+	return KeyValuePair.create({
+		key: "scrollToSettings",
+		value: request.value || "",
+	})
+}
diff --git a/apps/vscode/src/core/controller/ui/setTerminalExecutionMode.ts b/apps/vscode/src/core/controller/ui/setTerminalExecutionMode.ts
new file mode 100644
index 0000000..9723b6f
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/setTerminalExecutionMode.ts
@@ -0,0 +1,24 @@
+import { BooleanRequest, KeyValuePair } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+/**
+ * Sets the terminal execution mode
+ * @param controller The controller instance
+ * @param request The request containing whether to enable background execution
+ * @returns KeyValuePair with success status
+ */
+export async function setTerminalExecutionMode(controller: Controller, request: BooleanRequest): Promise<KeyValuePair> {
+	const enableBackgroundExec = request.value
+	const newMode = enableBackgroundExec ? "backgroundExec" : "vscodeTerminal"
+
+	// Update the global state
+	controller.stateManager.setGlobalState("vscodeTerminalExecutionMode", newMode)
+
+	// Post updated state to webview
+	await controller.postStateToWebview()
+
+	return KeyValuePair.create({
+		key: "terminalExecutionModeSet",
+		value: newMode,
+	})
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToAccountButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToAccountButtonClicked.ts
new file mode 100644
index 0000000..f84514c
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToAccountButtonClicked.ts
@@ -0,0 +1,56 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active account button clicked subscriptions
+const activeAccountButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to account button clicked events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The request ID for cleanup
+ */
+export async function subscribeToAccountButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeAccountButtonClickedSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeAccountButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "accountButtonClicked_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send an account button clicked event to all active subscribers
+ */
+export async function sendAccountButtonClickedEvent(): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeAccountButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			const event = Empty.create({})
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending accountButtonClicked event:", error)
+			// Remove the subscription if there was an error
+			activeAccountButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToAddToInput.ts b/apps/vscode/src/core/controller/ui/subscribeToAddToInput.ts
new file mode 100644
index 0000000..ed6d698
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToAddToInput.ts
@@ -0,0 +1,59 @@
+import type { EmptyRequest, String as ProtoString } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, type StreamingResponseHandler } from "../grpc-handler"
+import type { Controller } from "../index"
+
+// Keep track of active addToInput subscriptions
+const activeAddToInputSubscriptions = new Set<StreamingResponseHandler<ProtoString>>()
+
+/**
+ * Subscribe to addToInput events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToAddToInput(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<ProtoString>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeAddToInputSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeAddToInputSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "addToInput_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send an addToInput event to all active subscribers
+ * @param text The text to add to the input
+ */
+export async function sendAddToInputEvent(text: string): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeAddToInputSubscriptions).map(async (responseStream) => {
+		try {
+			const event: ProtoString = {
+				value: text,
+			}
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending addToInput event:", error)
+			// Remove the subscription if there was an error
+			activeAddToInputSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToChatButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToChatButtonClicked.ts
new file mode 100644
index 0000000..3b940c4
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToChatButtonClicked.ts
@@ -0,0 +1,56 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active chatButtonClicked subscriptions
+const activeChatButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to chatButtonClicked events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToChatButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeChatButtonClickedSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeChatButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "chatButtonClicked_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a chatButtonClicked event to all active subscribers
+ */
+export async function sendChatButtonClickedEvent(): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeChatButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			const event = Empty.create({})
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending chatButtonClicked event:", error)
+			// Remove the subscription if there was an error
+			activeChatButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToHistoryButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToHistoryButtonClicked.ts
new file mode 100644
index 0000000..5c24a1f
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToHistoryButtonClicked.ts
@@ -0,0 +1,56 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active history button clicked subscriptions
+const activeHistoryButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to history button clicked events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToHistoryButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeHistoryButtonClickedSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeHistoryButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "history_button_clicked_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a history button clicked event to all active subscribers
+ */
+export async function sendHistoryButtonClickedEvent(): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeHistoryButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			const event = Empty.create({})
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending history button clicked event:", error)
+			// Remove the subscription if there was an error
+			activeHistoryButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToMarketplaceButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToMarketplaceButtonClicked.ts
new file mode 100644
index 0000000..448659c
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToMarketplaceButtonClicked.ts
@@ -0,0 +1,41 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+const activeMarketplaceButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+export async function subscribeToMarketplaceButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	activeMarketplaceButtonClickedSubscriptions.add(responseStream)
+
+	const cleanup = () => {
+		activeMarketplaceButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	if (requestId) {
+		getRequestRegistry().registerRequest(
+			requestId,
+			cleanup,
+			{ type: "marketplaceButtonClicked_subscription" },
+			responseStream,
+		)
+	}
+}
+
+export async function sendMarketplaceButtonClickedEvent(): Promise<void> {
+	const promises = Array.from(activeMarketplaceButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			await responseStream(Empty.create({}), false)
+		} catch (error) {
+			Logger.error("Error sending marketplaceButtonClicked event:", error)
+			activeMarketplaceButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToMcpButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToMcpButtonClicked.ts
new file mode 100644
index 0000000..cb8484e
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToMcpButtonClicked.ts
@@ -0,0 +1,56 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active mcpButtonClicked subscriptions
+const activeMcpButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to mcpButtonClicked events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToMcpButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeMcpButtonClickedSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeMcpButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "mcpButtonClicked_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a mcpButtonClicked event to all active subscribers
+ */
+export async function sendMcpButtonClickedEvent(): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeMcpButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			const event = Empty.create({})
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending mcpButtonClicked event:", error)
+			// Remove the subscription if there was an error
+			activeMcpButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToPartialMessage.ts b/apps/vscode/src/core/controller/ui/subscribeToPartialMessage.ts
new file mode 100644
index 0000000..958e503
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToPartialMessage.ts
@@ -0,0 +1,70 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { ClineMessage } from "@shared/proto/cline/ui"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active partial message subscriptions (gRPC streams)
+const activePartialMessageSubscriptions = new Set<StreamingResponseHandler<ClineMessage>>()
+
+// Keep track of callback-based subscriptions (for CLI and other non-gRPC consumers)
+type PartialMessageCallback = (message: ClineMessage) => void
+const callbackSubscriptions = new Set<PartialMessageCallback>()
+
+/**
+ * Subscribe to partial message events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToPartialMessage(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<ClineMessage>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activePartialMessageSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activePartialMessageSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "partial_message_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a partial message event to all active subscribers
+ * @param partialMessage The ClineMessage to send
+ */
+export async function sendPartialMessageEvent(partialMessage: ClineMessage): Promise<void> {
+	// FIRE-AND-FORGET: do NOT await delivery to the webview. The webview can be hidden,
+	// reloaded, or closed, and VSCode's postMessage may hang or resolve false; awaiting it
+	// could stall the backend's turn loop on a dead consumer. Correctness does not depend on
+	// any single delivery arriving — the webview is a convergent replica that merges by id/seq
+	// and reconciles from full state.
+	for (const responseStream of activePartialMessageSubscriptions) {
+		responseStream(
+			partialMessage,
+			false, // Not the last message
+		).catch((error) => {
+			Logger.error("Error sending partial message event:", error)
+			// Remove the subscription if there was an error
+			activePartialMessageSubscriptions.delete(responseStream)
+		})
+	}
+
+	// Send to callback subscribers (synchronous)
+	for (const callback of callbackSubscriptions) {
+		try {
+			callback(partialMessage)
+		} catch (error) {
+			Logger.error("Error in partial message callback:", error)
+		}
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToRelinquishControl.ts b/apps/vscode/src/core/controller/ui/subscribeToRelinquishControl.ts
new file mode 100644
index 0000000..0e9998e
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToRelinquishControl.ts
@@ -0,0 +1,33 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active subscriptions
+const activeRelinquishControlSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to relinquish control events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToRelinquishControl(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeRelinquishControlSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeRelinquishControlSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "relinquish_control_subscription" }, responseStream)
+	}
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToSettingsButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToSettingsButtonClicked.ts
new file mode 100644
index 0000000..3cb0ebc
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToSettingsButtonClicked.ts
@@ -0,0 +1,52 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import type { Controller } from "../index"
+
+// Keep track of active settings button clicked subscriptions
+const activeSettingsButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to settings button clicked events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToSettingsButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeSettingsButtonClickedSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeSettingsButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "settings_button_clicked_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a settings button clicked event to all active subscribers
+ */
+export async function sendSettingsButtonClickedEvent(): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeSettingsButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			const event = Empty.create({})
+			await responseStream(event, false) // Not the last message
+		} catch (error) {
+			Logger.error("Error sending settings button clicked event:", error)
+			activeSettingsButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToShowWebview.ts b/apps/vscode/src/core/controller/ui/subscribeToShowWebview.ts
new file mode 100644
index 0000000..2dc68e7
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToShowWebview.ts
@@ -0,0 +1,58 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { ShowWebviewEvent } from "@shared/proto/cline/ui"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import type { Controller } from "../index"
+
+// Keep track of active show webview subscriptions
+const showWebviewSubscriptions = new Set<StreamingResponseHandler<ShowWebviewEvent>>()
+
+/**
+ * Subscribe to show webview events
+ * @param controller The controller instance
+ * @param request The show webview request containing preserveEditorFocus flag
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request
+ */
+export async function subscribeToShowWebview(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<ShowWebviewEvent>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	showWebviewSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		showWebviewSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(requestId, cleanup, { type: "show_webview_subscription" }, responseStream)
+	}
+}
+
+/**
+ * Send a show webview event to all active subscribers
+ * @param preserveEditorFocus When true, the webview should not steal focus from the editor
+ */
+export async function sendShowWebviewEvent(preserveEditorFocus: boolean = false): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(showWebviewSubscriptions).map(async (responseStream) => {
+		try {
+			const event = ShowWebviewEvent.create({ preserveEditorFocus })
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending show webview event:", error)
+			// Remove the subscription if there was an error
+			showWebviewSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/subscribeToWorktreesButtonClicked.ts b/apps/vscode/src/core/controller/ui/subscribeToWorktreesButtonClicked.ts
new file mode 100644
index 0000000..e81df41
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/subscribeToWorktreesButtonClicked.ts
@@ -0,0 +1,61 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+// Keep track of active worktrees button clicked subscriptions
+const activeWorktreesButtonClickedSubscriptions = new Set<StreamingResponseHandler<Empty>>()
+
+/**
+ * Subscribe to worktrees button clicked events
+ * @param controller The controller instance
+ * @param request The empty request
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request (passed by the gRPC handler)
+ */
+export async function subscribeToWorktreesButtonClicked(
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
+	requestId?: string,
+): Promise<void> {
+	// Add this subscription to the active subscriptions
+	activeWorktreesButtonClickedSubscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		activeWorktreesButtonClickedSubscriptions.delete(responseStream)
+	}
+
+	// Register the cleanup function with the request registry if we have a requestId
+	if (requestId) {
+		getRequestRegistry().registerRequest(
+			requestId,
+			cleanup,
+			{ type: "worktrees_button_clicked_subscription" },
+			responseStream,
+		)
+	}
+}
+
+/**
+ * Send a worktrees button clicked event to all active subscribers
+ */
+export async function sendWorktreesButtonClickedEvent(): Promise<void> {
+	// Send the event to all active subscribers
+	const promises = Array.from(activeWorktreesButtonClickedSubscriptions).map(async (responseStream) => {
+		try {
+			const event = Empty.create({})
+			await responseStream(
+				event,
+				false, // Not the last message
+			)
+		} catch (error) {
+			Logger.error("Error sending worktrees button clicked event:", error)
+			// Remove the subscription if there was an error
+			activeWorktreesButtonClickedSubscriptions.delete(responseStream)
+		}
+	})
+
+	await Promise.all(promises)
+}
diff --git a/apps/vscode/src/core/controller/ui/trackIntent.ts b/apps/vscode/src/core/controller/ui/trackIntent.ts
new file mode 100644
index 0000000..5f606ee
--- /dev/null
+++ b/apps/vscode/src/core/controller/ui/trackIntent.ts
@@ -0,0 +1,24 @@
+import { Empty } from "@shared/proto/cline/common"
+import type { IntentEvent } from "@shared/proto/cline/ui"
+import { telemetryService } from "@/services/telemetry"
+import type { Controller } from "../index"
+
+export async function trackIntent(_controller: Controller, request: IntentEvent): Promise<Empty> {
+	switch (request.action) {
+		case "new_task_clicked":
+			telemetryService.captureNewTaskClicked(request.source, request.hasActiveTask)
+			break
+		case "prompt_submitted":
+			telemetryService.capturePromptSubmitted({
+				source: request.source,
+				hasText: request.hasText,
+				hasImages: request.hasImages,
+				hasFiles: request.hasFiles,
+				hasActiveTask: request.hasActiveTask,
+				textLength: request.textLength,
+			})
+			break
+	}
+
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/core/controller/web/checkIsImageUrl.ts b/apps/vscode/src/core/controller/web/checkIsImageUrl.ts
new file mode 100644
index 0000000..9e49651
--- /dev/null
+++ b/apps/vscode/src/core/controller/web/checkIsImageUrl.ts
@@ -0,0 +1,30 @@
+import { detectImageUrl } from "@integrations/misc/link-preview"
+import { StringRequest } from "@shared/proto/cline/common"
+import { IsImageUrl } from "@shared/proto/cline/web"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../index"
+
+/**
+ * Checks if a URL is an image URL
+ * @param controller The controller instance
+ * @param request The request containing the URL to check
+ * @returns A result indicating if the URL is an image and the URL that was checked
+ */
+export async function checkIsImageUrl(_: Controller, request: StringRequest): Promise<IsImageUrl> {
+	try {
+		const url = request.value || ""
+		// Check if the URL is an image
+		const isImage = await detectImageUrl(url)
+
+		return IsImageUrl.create({
+			isImage,
+			url,
+		})
+	} catch (error) {
+		Logger.error(`Error checking if URL is an image: ${request.value}`, error)
+		return IsImageUrl.create({
+			isImage: false,
+			url: request.value || "",
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/web/fetchOpenGraphData.ts b/apps/vscode/src/core/controller/web/fetchOpenGraphData.ts
new file mode 100644
index 0000000..fac8734
--- /dev/null
+++ b/apps/vscode/src/core/controller/web/fetchOpenGraphData.ts
@@ -0,0 +1,27 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { OpenGraphData } from "@shared/proto/cline/web"
+import { Logger } from "@/shared/services/Logger"
+import { fetchOpenGraphData as fetchOGData } from "../../../integrations/misc/link-preview"
+import { convertDomainOpenGraphDataToProto } from "../../../shared/proto-conversions/web/open-graph-conversion"
+import { Controller } from ".."
+
+/**
+ * Fetches Open Graph metadata from a URL
+ * @param controller The controller instance
+ * @param request The request containing the URL to fetch metadata from
+ * @returns Promise resolving to OpenGraphData
+ */
+export async function fetchOpenGraphData(_controller: Controller, request: StringRequest): Promise<OpenGraphData> {
+	try {
+		const url = request.value || ""
+		// Fetch open graph data using the existing utility
+		const ogData = await fetchOGData(url)
+
+		// Convert domain model to proto model
+		return convertDomainOpenGraphDataToProto(ogData)
+	} catch (error) {
+		Logger.error(`Error fetching Open Graph data: ${request.value}`, error)
+		// Return empty OpenGraphData object
+		return OpenGraphData.create({})
+	}
+}
diff --git a/apps/vscode/src/core/controller/web/openInBrowser.ts b/apps/vscode/src/core/controller/web/openInBrowser.ts
new file mode 100644
index 0000000..6f21d33
--- /dev/null
+++ b/apps/vscode/src/core/controller/web/openInBrowser.ts
@@ -0,0 +1,22 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { openExternal } from "@utils/env"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Opens a URL in the user's default browser
+ * @param controller The controller instance
+ * @param request The URL to open
+ * @returns Empty response since the client doesn't need a return value
+ */
+export async function openInBrowser(_controller: Controller, request: StringRequest): Promise<Empty> {
+	try {
+		if (request.value) {
+			await openExternal(request.value)
+		}
+		return Empty.create()
+	} catch (error) {
+		Logger.error("Error opening URL in browser:", error)
+		return Empty.create()
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/checkoutBranch.ts b/apps/vscode/src/core/controller/worktree/checkoutBranch.ts
new file mode 100644
index 0000000..cc3dbdd
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/checkoutBranch.ts
@@ -0,0 +1,45 @@
+import { CheckoutBranchRequest, WorktreeResult } from "@shared/proto/cline/worktree"
+import { getWorkspacePath } from "@utils/path"
+import simpleGit from "simple-git"
+import { Controller } from ".."
+
+/**
+ * Checks out a branch in the current worktree (git checkout)
+ * @param controller The controller instance
+ * @param request The checkout branch request containing the branch name
+ * @returns WorktreeResult indicating success or failure
+ */
+export async function checkoutBranch(_controller: Controller, request: CheckoutBranchRequest): Promise<WorktreeResult> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return WorktreeResult.create({
+			success: false,
+			message: "No workspace folder found",
+		})
+	}
+
+	const { branch } = request
+
+	if (!branch) {
+		return WorktreeResult.create({
+			success: false,
+			message: "Branch name is required",
+		})
+	}
+
+	try {
+		const git = simpleGit(cwd)
+		await git.checkout(branch)
+
+		return WorktreeResult.create({
+			success: true,
+			message: `Switched to branch '${branch}'`,
+		})
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		return WorktreeResult.create({
+			success: false,
+			message: `Failed to checkout branch: ${errorMessage}`,
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/createWorktree.ts b/apps/vscode/src/core/controller/worktree/createWorktree.ts
new file mode 100644
index 0000000..f4be911
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/createWorktree.ts
@@ -0,0 +1,65 @@
+import { CreateWorktreeRequest, WorktreeResult } from "@shared/proto/cline/worktree"
+import { createWorktree as createWorktreeUtil, listWorktrees } from "@utils/git-worktree"
+import { getWorkspacePath } from "@utils/path"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Creates a new git worktree
+ * @param controller The controller instance
+ * @param request The request containing path and branch information
+ * @returns WorktreeResult with success status and created worktree info
+ */
+export async function createWorktree(_controller: Controller, request: CreateWorktreeRequest): Promise<WorktreeResult> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return WorktreeResult.create({
+			success: false,
+			message: "No workspace folder open",
+		})
+	}
+
+	try {
+		const result = await createWorktreeUtil(cwd, request.path, {
+			branch: request.branch,
+			baseBranch: request.baseBranch,
+			createNewBranch: request.createNewBranch,
+		})
+
+		// Track worktree creation with count of total worktrees
+		if (result.success) {
+			try {
+				const { worktrees } = await listWorktrees(cwd)
+				telemetryService.captureWorktreeCreated(true, worktrees.length)
+			} catch {
+				telemetryService.captureWorktreeCreated(true)
+			}
+		} else {
+			telemetryService.captureWorktreeCreated(false)
+		}
+
+		return WorktreeResult.create({
+			success: result.success,
+			message: result.message,
+			worktree: result.worktree
+				? {
+						path: result.worktree.path,
+						branch: result.worktree.branch,
+						commitHash: result.worktree.commitHash,
+						isCurrent: result.worktree.isCurrent,
+						isBare: result.worktree.isBare,
+						isDetached: result.worktree.isDetached,
+						isLocked: result.worktree.isLocked,
+						lockReason: result.worktree.lockReason,
+					}
+				: undefined,
+		})
+	} catch (error) {
+		Logger.error(`Error creating worktree: ${JSON.stringify(error)}`)
+		return WorktreeResult.create({
+			success: false,
+			message: error instanceof Error ? error.message : String(error),
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/createWorktreeInclude.ts b/apps/vscode/src/core/controller/worktree/createWorktreeInclude.ts
new file mode 100644
index 0000000..e0aa199
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/createWorktreeInclude.ts
@@ -0,0 +1,39 @@
+import { CreateWorktreeIncludeRequest, WorktreeResult } from "@shared/proto/cline/worktree"
+import { getWorkspacePath } from "@utils/path"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { Controller } from ".."
+
+/**
+ * Creates a .worktreeinclude file with the provided content
+ * @param controller The controller instance
+ * @param request The request containing the file content
+ * @returns WorktreeResult with success status
+ */
+export async function createWorktreeInclude(
+	_controller: Controller,
+	request: CreateWorktreeIncludeRequest,
+): Promise<WorktreeResult> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return WorktreeResult.create({
+			success: false,
+			message: "No workspace folder open",
+		})
+	}
+
+	try {
+		const filePath = path.join(cwd, ".worktreeinclude")
+		await fs.writeFile(filePath, request.content, "utf-8")
+
+		return WorktreeResult.create({
+			success: true,
+			message: "Created .worktreeinclude file",
+		})
+	} catch (error) {
+		return WorktreeResult.create({
+			success: false,
+			message: `Failed to create .worktreeinclude: ${error instanceof Error ? error.message : String(error)}`,
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/deleteWorktree.ts b/apps/vscode/src/core/controller/worktree/deleteWorktree.ts
new file mode 100644
index 0000000..5679926
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/deleteWorktree.ts
@@ -0,0 +1,58 @@
+import { DeleteWorktreeRequest, WorktreeResult } from "@shared/proto/cline/worktree"
+import { deleteWorktree as deleteWorktreeUtil } from "@utils/git-worktree"
+import { getWorkspacePath } from "@utils/path"
+import simpleGit from "simple-git"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Deletes an existing git worktree
+ * @param controller The controller instance
+ * @param request The request containing path and force flag
+ * @returns WorktreeResult with success status
+ */
+export async function deleteWorktree(_controller: Controller, request: DeleteWorktreeRequest): Promise<WorktreeResult> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return WorktreeResult.create({
+			success: false,
+			message: "No workspace folder open",
+		})
+	}
+
+	try {
+		const result = await deleteWorktreeUtil(cwd, request.path, request.force)
+
+		if (!result.success) {
+			return WorktreeResult.create({
+				success: result.success,
+				message: result.message,
+			})
+		}
+
+		// Delete the branch if requested
+		if (request.deleteBranch && request.branchName) {
+			try {
+				const git = simpleGit(cwd)
+				await git.deleteLocalBranch(request.branchName)
+			} catch {
+				// Branch deletion failed, but worktree was deleted successfully
+				return WorktreeResult.create({
+					success: true,
+					message: `${result.message}, but failed to delete branch '${request.branchName}'`,
+				})
+			}
+		}
+
+		return WorktreeResult.create({
+			success: result.success,
+			message: request.deleteBranch ? `${result.message} and deleted branch '${request.branchName}'` : result.message,
+		})
+	} catch (error) {
+		Logger.error(`Error deleting worktree: ${JSON.stringify(error)}`)
+		return WorktreeResult.create({
+			success: false,
+			message: error instanceof Error ? error.message : String(error),
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/getAvailableBranches.ts b/apps/vscode/src/core/controller/worktree/getAvailableBranches.ts
new file mode 100644
index 0000000..48acc24
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/getAvailableBranches.ts
@@ -0,0 +1,40 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { BranchList } from "@shared/proto/cline/worktree"
+import { getAvailableBranches as getAvailableBranchesUtil } from "@utils/git-worktree"
+import { getWorkspacePath } from "@utils/path"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Gets available branches for creating worktrees
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns BranchList containing local and remote branches
+ */
+export async function getAvailableBranches(_controller: Controller, _request: EmptyRequest): Promise<BranchList> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return BranchList.create({
+			localBranches: [],
+			remoteBranches: [],
+			currentBranch: "",
+		})
+	}
+
+	try {
+		const result = await getAvailableBranchesUtil(cwd)
+
+		return BranchList.create({
+			localBranches: result.localBranches,
+			remoteBranches: result.remoteBranches,
+			currentBranch: result.currentBranch,
+		})
+	} catch (error) {
+		Logger.error(`Error getting available branches: ${JSON.stringify(error)}`)
+		return BranchList.create({
+			localBranches: [],
+			remoteBranches: [],
+			currentBranch: "",
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/getWorktreeDefaults.ts b/apps/vscode/src/core/controller/worktree/getWorktreeDefaults.ts
new file mode 100644
index 0000000..6bb7583
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/getWorktreeDefaults.ts
@@ -0,0 +1,49 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { WorktreeDefaults } from "@shared/proto/cline/worktree"
+import { getWorkspacePath } from "@utils/path"
+import path from "path"
+import { getDocumentsPath } from "@/core/storage/disk"
+import { Controller } from ".."
+
+/**
+ * Generates a random suffix for worktree names
+ * Returns a 5-character alphanumeric string
+ */
+function generateRandomSuffix(): string {
+	const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
+	let result = ""
+	for (let i = 0; i < 5; i++) {
+		result += chars.charAt(Math.floor(Math.random() * chars.length))
+	}
+	return result
+}
+
+/**
+ * Gets suggested defaults for creating a new worktree
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns WorktreeDefaults with suggested branch name and path
+ */
+export async function getWorktreeDefaults(_controller: Controller, _request: EmptyRequest): Promise<WorktreeDefaults> {
+	const suffix = generateRandomSuffix()
+
+	// Generate suggested branch name
+	const suggestedBranch = `worktree/cline-${suffix}`
+
+	// Generate suggested path in Documents/Cline/Worktrees/<project-name>-<suffix>
+	const documentsPath = await getDocumentsPath()
+	const cwd = await getWorkspacePath()
+
+	// Get project name from workspace path
+	let projectName = "project"
+	if (cwd) {
+		projectName = path.basename(cwd)
+	}
+
+	const suggestedPath = path.join(documentsPath, "Cline", "Worktrees", `${projectName}-${suffix}`)
+
+	return WorktreeDefaults.create({
+		suggestedBranch,
+		suggestedPath,
+	})
+}
diff --git a/apps/vscode/src/core/controller/worktree/getWorktreeIncludeStatus.ts b/apps/vscode/src/core/controller/worktree/getWorktreeIncludeStatus.ts
new file mode 100644
index 0000000..d04fc97
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/getWorktreeIncludeStatus.ts
@@ -0,0 +1,48 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { WorktreeIncludeStatus } from "@shared/proto/cline/worktree"
+import { getWorkspacePath } from "@utils/path"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { Controller } from ".."
+
+/**
+ * Gets the status of .worktreeinclude file and .gitignore contents
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns WorktreeIncludeStatus with exists flag and gitignore content
+ */
+export async function getWorktreeIncludeStatus(_controller: Controller, _request: EmptyRequest): Promise<WorktreeIncludeStatus> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return WorktreeIncludeStatus.create({
+			exists: false,
+			hasGitignore: false,
+			gitignoreContent: "",
+		})
+	}
+
+	// Check if .worktreeinclude exists
+	let exists = false
+	try {
+		await fs.access(path.join(cwd, ".worktreeinclude"))
+		exists = true
+	} catch {
+		exists = false
+	}
+
+	// Read .gitignore content if it exists
+	let gitignoreContent = ""
+	let hasGitignore = false
+	try {
+		gitignoreContent = await fs.readFile(path.join(cwd, ".gitignore"), "utf-8")
+		hasGitignore = true
+	} catch {
+		hasGitignore = false
+	}
+
+	return WorktreeIncludeStatus.create({
+		exists,
+		hasGitignore,
+		gitignoreContent,
+	})
+}
diff --git a/apps/vscode/src/core/controller/worktree/listWorktrees.ts b/apps/vscode/src/core/controller/worktree/listWorktrees.ts
new file mode 100644
index 0000000..132c9b1
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/listWorktrees.ts
@@ -0,0 +1,89 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { WorktreeList } from "@shared/proto/cline/worktree"
+import { getGitRootPath, listWorktrees as listWorktreesUtil } from "@utils/git-worktree"
+import { arePathsEqual, getWorkspacePath } from "@utils/path"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Lists all git worktrees in the current repository
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns WorktreeList containing all worktrees
+ */
+export async function listWorktrees(_controller: Controller, _request: EmptyRequest): Promise<WorktreeList> {
+	// Check for multi-root workspace
+	const workspacePaths = (await HostProvider.workspace.getWorkspacePaths({})).paths
+	const isMultiRoot = workspacePaths.length > 1
+
+	if (isMultiRoot) {
+		return WorktreeList.create({
+			worktrees: [],
+			isGitRepo: false,
+			isMultiRoot: true,
+			isSubfolder: false,
+			gitRootPath: "",
+			error: "",
+		})
+	}
+
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return WorktreeList.create({
+			worktrees: [],
+			isGitRepo: false,
+			isMultiRoot: false,
+			isSubfolder: false,
+			gitRootPath: "",
+			error: "No workspace folder open",
+		})
+	}
+
+	// Check if workspace is a subfolder of a git repo (not at repo root)
+	const gitRootPath = await getGitRootPath(cwd)
+	const isSubfolder = gitRootPath !== null && !arePathsEqual(cwd, gitRootPath)
+
+	if (isSubfolder) {
+		return WorktreeList.create({
+			worktrees: [],
+			isGitRepo: true,
+			isMultiRoot: false,
+			isSubfolder: true,
+			gitRootPath: gitRootPath || "",
+			error: "",
+		})
+	}
+
+	try {
+		const result = await listWorktreesUtil(cwd)
+
+		return WorktreeList.create({
+			worktrees: result.worktrees.map((wt) => ({
+				path: wt.path,
+				branch: wt.branch,
+				commitHash: wt.commitHash,
+				isCurrent: wt.isCurrent,
+				isBare: wt.isBare,
+				isDetached: wt.isDetached,
+				isLocked: wt.isLocked,
+				lockReason: wt.lockReason,
+			})),
+			isGitRepo: result.isGitRepo,
+			isMultiRoot: false,
+			isSubfolder: false,
+			gitRootPath: gitRootPath || "",
+			error: result.error || "",
+		})
+	} catch (error) {
+		Logger.error(`Error listing worktrees: ${JSON.stringify(error)}`)
+		return WorktreeList.create({
+			worktrees: [],
+			isGitRepo: false,
+			isMultiRoot: false,
+			isSubfolder: false,
+			gitRootPath: "",
+			error: error instanceof Error ? error.message : String(error),
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/mergeWorktree.ts b/apps/vscode/src/core/controller/worktree/mergeWorktree.ts
new file mode 100644
index 0000000..3bbdd67
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/mergeWorktree.ts
@@ -0,0 +1,215 @@
+import { MergeWorktreeRequest, MergeWorktreeResult } from "@shared/proto/cline/worktree"
+import { listWorktrees } from "@utils/git-worktree"
+import { getWorkspacePath } from "@utils/path"
+import simpleGit from "simple-git"
+import { telemetryService } from "@/services/telemetry"
+import { Controller } from ".."
+
+/**
+ * Merges a worktree's branch into the target branch and optionally deletes the worktree
+ * @param controller The controller instance
+ * @param request The merge worktree request
+ * @returns MergeWorktreeResult indicating success, failure, or conflicts
+ */
+export async function mergeWorktree(_controller: Controller, request: MergeWorktreeRequest): Promise<MergeWorktreeResult> {
+	const cwd = await getWorkspacePath()
+	if (!cwd) {
+		return MergeWorktreeResult.create({
+			success: false,
+			message: "No workspace folder found",
+			hasConflicts: false,
+			conflictingFiles: [],
+		})
+	}
+
+	const { worktreePath, targetBranch, deleteAfterMerge } = request
+
+	if (!worktreePath) {
+		return MergeWorktreeResult.create({
+			success: false,
+			message: "Worktree path is required",
+			hasConflicts: false,
+			conflictingFiles: [],
+		})
+	}
+
+	if (!targetBranch) {
+		return MergeWorktreeResult.create({
+			success: false,
+			message: "Target branch is required",
+			hasConflicts: false,
+			conflictingFiles: [],
+		})
+	}
+
+	try {
+		// Find the worktree that has the target branch checked out
+		// This is where we need to perform the merge
+		const { worktrees } = await listWorktrees(cwd)
+		const targetWorktree = worktrees.find((w) => w.branch === targetBranch)
+
+		if (!targetWorktree) {
+			return MergeWorktreeResult.create({
+				success: false,
+				message: `Target branch '${targetBranch}' is not checked out in any worktree. Please checkout the branch first.`,
+				hasConflicts: false,
+				conflictingFiles: [],
+			})
+		}
+
+		// Use the target worktree's path for merge operations
+		const targetWorktreePath = targetWorktree.path
+		const git = simpleGit(targetWorktreePath)
+		const worktreeGit = simpleGit(worktreePath)
+
+		// Get the branch name of the worktree
+		let sourceBranch: string
+		try {
+			sourceBranch = await worktreeGit.revparse(["--abbrev-ref", "HEAD"])
+			sourceBranch = sourceBranch.trim()
+		} catch {
+			return MergeWorktreeResult.create({
+				success: false,
+				message: "Failed to get branch name from worktree",
+				hasConflicts: false,
+				conflictingFiles: [],
+			})
+		}
+
+		if (sourceBranch === "HEAD") {
+			return MergeWorktreeResult.create({
+				success: false,
+				message: "Cannot merge a detached HEAD worktree",
+				hasConflicts: false,
+				conflictingFiles: [],
+				sourceBranch,
+				targetBranch,
+			})
+		}
+
+		// Check for uncommitted changes in the source worktree
+		try {
+			const status = await worktreeGit.status()
+			if (!status.isClean()) {
+				return MergeWorktreeResult.create({
+					success: false,
+					message: `Worktree has uncommitted changes. Please commit or stash them first.`,
+					hasConflicts: false,
+					conflictingFiles: [],
+					sourceBranch,
+					targetBranch,
+				})
+			}
+		} catch {
+			// If status check fails, continue anyway
+		}
+
+		// Check for uncommitted changes in the target worktree
+		try {
+			const targetStatus = await git.status()
+			if (!targetStatus.isClean()) {
+				return MergeWorktreeResult.create({
+					success: false,
+					message: `Target worktree (${targetBranch}) has uncommitted changes. Please commit or stash them first.`,
+					hasConflicts: false,
+					conflictingFiles: [],
+					sourceBranch,
+					targetBranch,
+				})
+			}
+		} catch {
+			// If status check fails, continue anyway
+		}
+
+		// Attempt the merge in the target worktree (which already has targetBranch checked out)
+		try {
+			await git.merge([sourceBranch, "--no-edit"])
+		} catch (error) {
+			// Check if it's a merge conflict
+			try {
+				const diffResult = await git.diff(["--name-only", "--diff-filter=U"])
+				const conflictingFiles = diffResult
+					.trim()
+					.split("\n")
+					.filter((f) => f)
+
+				if (conflictingFiles.length > 0) {
+					// Abort the merge so we don't leave the repo in a conflicted state
+					try {
+						await git.merge(["--abort"])
+					} catch {
+						// Ignore abort errors
+					}
+
+					telemetryService.captureWorktreeMergeAttempted(false, true, deleteAfterMerge)
+					return MergeWorktreeResult.create({
+						success: false,
+						message: `Merge conflict detected. ${conflictingFiles.length} file(s) have conflicts.`,
+						hasConflicts: true,
+						conflictingFiles,
+						sourceBranch,
+						targetBranch,
+					})
+				}
+			} catch {
+				// If conflict check fails, return the original error
+			}
+
+			const errorMessage = error instanceof Error ? error.message : String(error)
+			telemetryService.captureWorktreeMergeAttempted(false, false, deleteAfterMerge)
+			return MergeWorktreeResult.create({
+				success: false,
+				message: `Merge failed: ${errorMessage}`,
+				hasConflicts: false,
+				conflictingFiles: [],
+				sourceBranch,
+				targetBranch,
+			})
+		}
+
+		// Delete worktree if requested
+		if (deleteAfterMerge) {
+			try {
+				await git.raw(["worktree", "remove", worktreePath, "--force"])
+			} catch (error) {
+				// Merge succeeded but deletion failed - still return success
+				const errorMessage = error instanceof Error ? error.message : String(error)
+				return MergeWorktreeResult.create({
+					success: true,
+					message: `Merged '${sourceBranch}' into '${targetBranch}' successfully, but failed to delete worktree: ${errorMessage}`,
+					hasConflicts: false,
+					conflictingFiles: [],
+					sourceBranch,
+					targetBranch,
+				})
+			}
+
+			// Optionally delete the branch too
+			try {
+				await git.deleteLocalBranch(sourceBranch)
+			} catch {
+				// Branch deletion is optional, don't fail if it doesn't work
+			}
+		}
+
+		telemetryService.captureWorktreeMergeAttempted(true, false, deleteAfterMerge)
+		return MergeWorktreeResult.create({
+			success: true,
+			message: deleteAfterMerge
+				? `Successfully merged '${sourceBranch}' into '${targetBranch}' and removed worktree`
+				: `Successfully merged '${sourceBranch}' into '${targetBranch}'`,
+			hasConflicts: false,
+			conflictingFiles: [],
+			sourceBranch,
+			targetBranch,
+		})
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		return MergeWorktreeResult.create({
+			success: false,
+			message: `Unexpected error: ${errorMessage}`,
+			hasConflicts: false,
+			conflictingFiles: [],
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/switchWorktree.ts b/apps/vscode/src/core/controller/worktree/switchWorktree.ts
new file mode 100644
index 0000000..a54fdf3
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/switchWorktree.ts
@@ -0,0 +1,46 @@
+import { SwitchWorktreeRequest, WorktreeResult } from "@shared/proto/cline/worktree"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from ".."
+
+/**
+ * Switches to a different worktree by opening it in VS Code
+ * @param controller The controller instance
+ * @param request The request containing the worktree path
+ * @returns WorktreeResult with success status
+ */
+export async function switchWorktree(controller: Controller, request: SwitchWorktreeRequest): Promise<WorktreeResult> {
+	try {
+		// Set state so Cline auto-opens when the worktree folder loads
+		controller.stateManager.setGlobalState("worktreeAutoOpenPath", request.path)
+
+		// When opening in current window, the window reloads immediately and StateManager's
+		// 500ms debounce won't complete. Flush to ensure state is persisted before reload.
+		if (!request.newWindow) {
+			await controller.stateManager.flushPendingState()
+		}
+
+		const result = await HostProvider.workspace.openFolder({
+			path: request.path,
+			newWindow: request.newWindow,
+		})
+
+		if (!result.success) {
+			return WorktreeResult.create({
+				success: false,
+				message: `Failed to open worktree at ${request.path}`,
+			})
+		}
+
+		return WorktreeResult.create({
+			success: true,
+			message: `Switched to worktree at ${request.path}`,
+		})
+	} catch (error) {
+		Logger.error(`Error switching worktree: ${JSON.stringify(error)}`)
+		return WorktreeResult.create({
+			success: false,
+			message: error instanceof Error ? error.message : String(error),
+		})
+	}
+}
diff --git a/apps/vscode/src/core/controller/worktree/trackWorktreeViewOpened.ts b/apps/vscode/src/core/controller/worktree/trackWorktreeViewOpened.ts
new file mode 100644
index 0000000..73c1b53
--- /dev/null
+++ b/apps/vscode/src/core/controller/worktree/trackWorktreeViewOpened.ts
@@ -0,0 +1,16 @@
+import { Empty } from "@shared/proto/cline/common"
+import { TrackWorktreeViewOpenedRequest } from "@shared/proto/cline/worktree"
+import { telemetryService } from "@/services/telemetry"
+import { Controller } from ".."
+
+/**
+ * Tracks when the worktrees view is opened (for telemetry)
+ * @param controller The controller instance
+ * @param request The request containing the source of the navigation
+ * @returns Empty response
+ */
+export async function trackWorktreeViewOpened(_controller: Controller, request: TrackWorktreeViewOpenedRequest): Promise<Empty> {
+	const source = request.source === "home_page" ? "home_page" : "menu_bar"
+	telemetryService.captureWorktreeViewOpened(source)
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/core/hooks/HookDiscoveryCache.ts b/apps/vscode/src/core/hooks/HookDiscoveryCache.ts
new file mode 100644
index 0000000..a9d82fe
--- /dev/null
+++ b/apps/vscode/src/core/hooks/HookDiscoveryCache.ts
@@ -0,0 +1,329 @@
+import { Logger } from "@/shared/services/Logger"
+import { telemetryService } from "../../services/telemetry"
+import { getAllHooksDirs } from "../storage/disk"
+import { HookFactory, Hooks } from "./hook-factory"
+
+type HookName = keyof Hooks
+
+/**
+ * Cached hook discovery results
+ */
+interface HookCacheEntry {
+	scriptPaths: string[] // Paths to hook scripts for this hook name
+	timestamp: number // When this was last scanned
+}
+
+/**
+ * Generic disposable interface for resource cleanup
+ */
+interface Disposable {
+	dispose(): void
+}
+
+/**
+ * Generic file watcher interface
+ */
+interface FileWatcher extends Disposable {
+	onDidCreate(listener: () => void): void
+	onDidChange(listener: () => void): void
+	onDidDelete(listener: () => void): void
+}
+
+/**
+ * Generic context interface for managing subscriptions
+ */
+interface ExtensionContext {
+	subscriptions: Disposable[]
+}
+
+/**
+ * Singleton cache for hook script discovery with lazy file system watching.
+ *
+ * Features:
+ * - Lazy watcher initialization (only when directories are accessed)
+ * - Per-directory caching
+ * - Automatic invalidation on file changes
+ * - Graceful error handling
+ * - Optional debug logging
+ */
+export class HookDiscoveryCache {
+	private static instance: HookDiscoveryCache | null = null
+
+	// Cache: hookName -> discovered script paths
+	private cache = new Map<HookName, HookCacheEntry>()
+
+	// Watchers: directory path -> file watcher
+	private watchers = new Map<string, FileWatcher>()
+
+	// Directories we've tried to watch (even if watcher creation failed)
+	private watchedDirs = new Set<string>()
+
+	// Currently scanning promises (to prevent concurrent scans)
+	private scanningPromises = new Map<HookName, Promise<string[]>>()
+
+	// For disposal
+	private context: ExtensionContext | null = null
+	private createFileWatcher: ((dir: string) => FileWatcher | null) | null = null
+	private disposed = false
+
+	// Debug logging (enabled via DEBUG_HOOKS env var)
+	private debug = process.env.DEBUG_HOOKS === "true"
+
+	private constructor() {}
+
+	static getInstance(): HookDiscoveryCache {
+		if (!HookDiscoveryCache.instance) {
+			HookDiscoveryCache.instance = new HookDiscoveryCache()
+		}
+		return HookDiscoveryCache.instance
+	}
+
+	/**
+	 * Initialize with extension context for proper cleanup
+	 */
+	initialize(
+		context: ExtensionContext,
+		createFileWatcher?: (dir: string) => FileWatcher | null,
+		onWorkspaceFoldersChanged?: (callback: () => void) => Disposable,
+	): void {
+		this.context = context
+		this.createFileWatcher = createFileWatcher || null
+
+		// Watch for workspace changes to invalidate cache (if callback provided)
+		if (onWorkspaceFoldersChanged) {
+			context.subscriptions.push(
+				onWorkspaceFoldersChanged(() => {
+					this.log("Workspace folders changed, invalidating cache")
+					this.invalidateAll()
+				}),
+			)
+		}
+	}
+
+	/**
+	 * Get cached hook scripts or scan if not cached
+	 */
+	async get(hookName: HookName): Promise<string[]> {
+		this.log(`Getting hooks for ${hookName}`)
+
+		const cached = this.cache.get(hookName)
+		const cacheHit = cached !== undefined
+
+		let scripts: string[]
+		let initiatedScan = false // Track if this caller initiated the scan
+
+		if (cacheHit) {
+			this.log(`Cache hit for ${hookName}: ${cached.scriptPaths.length} scripts`)
+			scripts = cached.scriptPaths
+		} else {
+			this.log(`Cache miss for ${hookName}, scanning...`)
+
+			// Check if scan is already in progress
+			const existingPromise = this.scanningPromises.get(hookName)
+			if (existingPromise) {
+				// Another caller is already scanning, reuse their promise
+				this.log(`Reusing existing scan for ${hookName}`)
+				scripts = await existingPromise
+			} else {
+				// This caller initiates the scan
+				initiatedScan = true
+				scripts = await this.scan(hookName)
+			}
+		}
+
+		// Only report telemetry if:
+		// 1. It was a cache hit, OR
+		// 2. This caller initiated the scan (not reusing another caller's promise)
+		if (cacheHit || initiatedScan) {
+			telemetryService.safeCapture(
+				() => telemetryService.captureHookCacheAccess(hookName, cacheHit),
+				"HookDiscoveryCache.get",
+			)
+		}
+
+		return scripts
+	}
+
+	/**
+	 * Scan for hook scripts and cache the result
+	 */
+	private async scan(hookName: HookName): Promise<string[]> {
+		// Check if a scan is already in progress for this hook
+		const existingPromise = this.scanningPromises.get(hookName)
+		if (existingPromise) {
+			this.log(`Already scanning ${hookName}, waiting for existing scan...`)
+			return existingPromise
+		}
+
+		// Create a new scan promise
+		const scanPromise = (async () => {
+			try {
+				// Get all current hooks directories
+				const hooksDirs = await getAllHooksDirs()
+				this.log(`Scanning ${hooksDirs.length} directories for ${hookName}`)
+
+				// Ensure watchers are set up for each directory (lazy initialization)
+				for (const dir of hooksDirs) {
+					this.ensureWatcher(dir)
+				}
+
+				// Scan each directory for this hook
+				const scriptPromises = hooksDirs.map((dir) => HookFactory.findHookInHooksDir(hookName, dir))
+
+				const results = await Promise.all(scriptPromises)
+				const scripts = results.filter((path): path is string => path !== undefined)
+
+				this.log(`Found ${scripts.length} scripts for ${hookName}`)
+
+				// Cache the result
+				this.cache.set(hookName, {
+					scriptPaths: scripts,
+					timestamp: Date.now(),
+				})
+
+				return scripts
+			} catch (error) {
+				Logger.error(`Error scanning for ${hookName} hooks:`, error)
+				// Return empty array on error - don't break the whole system
+				return []
+			} finally {
+				// Remove from scanning promises map
+				this.scanningPromises.delete(hookName)
+			}
+		})()
+
+		// Store the promise so concurrent calls can await it
+		this.scanningPromises.set(hookName, scanPromise)
+
+		return scanPromise
+	}
+
+	/**
+	 * Ensure a file watcher exists for the given directory
+	 */
+	private ensureWatcher(dir: string): void {
+		// Skip if already watching or tried to watch
+		if (this.watchedDirs.has(dir)) {
+			return
+		}
+
+		this.watchedDirs.add(dir)
+
+		if (!this.context) {
+			this.log(`No context available, skipping watcher for ${dir}`)
+			return
+		}
+
+		// If no watcher creation function provided, skip watching
+		if (!this.createFileWatcher) {
+			this.log(`No watcher creator available, skipping watcher for ${dir}`)
+			return
+		}
+
+		try {
+			// Create watcher using the provided function
+			const watcher = this.createFileWatcher(dir)
+
+			if (!watcher) {
+				this.log(`Watcher creation returned null for ${dir}`)
+				return
+			}
+
+			// Invalidate cache on any change
+			const invalidate = () => {
+				this.log(`File change detected in ${dir}, invalidating cache`)
+				this.invalidateDirectory(dir)
+			}
+
+			watcher.onDidCreate(invalidate)
+			watcher.onDidChange(invalidate)
+			watcher.onDidDelete(invalidate)
+
+			// Add to context subscriptions for proper cleanup
+			if (this.context) {
+				this.context.subscriptions.push(watcher)
+			}
+			this.watchers.set(dir, watcher)
+
+			this.log(`Created watcher for ${dir}`)
+		} catch (error) {
+			// Log but don't fail - directory might not exist yet
+			this.log(`Failed to create watcher for ${dir}: ${error}`)
+		}
+	}
+
+	/**
+	 * Invalidate all cached hooks that have scripts in this directory
+	 */
+	private invalidateDirectory(dir: string): void {
+		let invalidated = 0
+
+		for (const [hookName, entry] of this.cache) {
+			if (entry.scriptPaths.some((scriptPath) => scriptPath.startsWith(dir))) {
+				this.cache.delete(hookName)
+				invalidated++
+			}
+		}
+
+		this.log(`Invalidated ${invalidated} hooks for directory ${dir}`)
+	}
+
+	/**
+	 * Invalidate entire cache
+	 */
+	invalidateAll(): void {
+		const size = this.cache.size
+		this.cache.clear()
+		this.log(`Invalidated entire cache (${size} entries)`)
+	}
+
+	/**
+	 * Get cache statistics (for debugging/monitoring)
+	 */
+	getStats() {
+		return {
+			cacheSize: this.cache.size,
+			watcherCount: this.watchers.size,
+			watchedDirs: this.watchedDirs.size,
+		}
+	}
+
+	/**
+	 * Log debug message if debug mode is enabled
+	 */
+	private log(message: string): void {
+		if (this.debug) {
+			Logger.log(`[HookCache] ${message}`)
+		}
+	}
+
+	/**
+	 * Clean up resources
+	 */
+	dispose(): void {
+		if (this.disposed) {
+			return
+		}
+
+		this.log(`Disposing cache (${this.watchers.size} watchers)`)
+
+		for (const watcher of this.watchers.values()) {
+			watcher.dispose()
+		}
+
+		this.watchers.clear()
+		this.watchedDirs.clear()
+		this.cache.clear()
+		this.disposed = true
+	}
+
+	/**
+	 * Reset singleton instance (for testing)
+	 */
+	static resetForTesting(): void {
+		if (HookDiscoveryCache.instance) {
+			HookDiscoveryCache.instance.dispose()
+			HookDiscoveryCache.instance = null
+		}
+	}
+}
diff --git a/apps/vscode/src/core/hooks/HookError.ts b/apps/vscode/src/core/hooks/HookError.ts
new file mode 100644
index 0000000..3cf2f3c
--- /dev/null
+++ b/apps/vscode/src/core/hooks/HookError.ts
@@ -0,0 +1,123 @@
+/**
+ * Types of errors that can occur during hook execution
+ */
+enum HookErrorType {
+	/** Hook execution exceeded the timeout limit */
+	TIMEOUT = "timeout",
+	/** Hook output failed JSON validation */
+	VALIDATION = "validation",
+	/** Hook script execution failed (non-zero exit, crash, etc.) */
+	EXECUTION = "execution",
+	/** Hook was cancelled by user */
+	CANCELLATION = "cancellation",
+}
+
+/**
+ * Structured error information for hook failures.
+ * Provides both user-friendly messages and technical details.
+ */
+export interface HookErrorInfo {
+	/** Type of error that occurred */
+	type: HookErrorType
+	/** User-friendly error message */
+	message: string
+	/** Technical details for debugging (optional, shown in expansion) */
+	details?: string
+	/** Path to the hook script that failed */
+	scriptPath?: string
+	/** Exit code if available */
+	exitCode?: number
+	/** Stderr output if available */
+	stderr?: string
+}
+
+/**
+ * Error thrown during hook execution with structured information.
+ * This allows proper error handling without string parsing.
+ */
+export class HookExecutionError extends Error {
+	constructor(
+		public readonly errorInfo: HookErrorInfo,
+		message?: string,
+	) {
+		super(message || errorInfo.message)
+		this.name = "HookExecutionError"
+	}
+
+	/**
+	 * Check if an error is a HookExecutionError
+	 */
+	static isHookError(error: unknown): error is HookExecutionError {
+		return error instanceof HookExecutionError
+	}
+
+	/**
+	 * Create a timeout error
+	 */
+	static timeout(scriptPath: string, timeoutMs: number, stderr?: string, hookName?: string): HookExecutionError {
+		const hookPrefix = hookName ? `${hookName} hook` : "Hook"
+		return new HookExecutionError({
+			type: HookErrorType.TIMEOUT,
+			message: `${hookPrefix} execution timed out after ${timeoutMs}ms`,
+			details:
+				`The hook took longer than ${timeoutMs / 1000} seconds to complete.\n\n` +
+				`Common causes:\n` +
+				`• Infinite loop in hook script\n` +
+				`• Network request hanging without timeout\n` +
+				`• File I/O operation stuck\n` +
+				`• Heavy computation taking too long\n\n` +
+				`Recommendations:\n` +
+				`1. Check your hook script for infinite loops\n` +
+				`2. Add timeouts to network requests\n` +
+				`3. Use background jobs for long operations\n` +
+				`4. Test your hook script independently`,
+			scriptPath,
+			stderr,
+		})
+	}
+
+	/**
+	 * Create a validation error
+	 */
+	static validation(validationError: string, scriptPath: string, stdoutPreview: string): HookExecutionError {
+		return new HookExecutionError({
+			type: HookErrorType.VALIDATION,
+			message: "Hook output validation failed",
+			details: `${validationError}\n\nOutput preview:\n${stdoutPreview}`,
+			scriptPath,
+		})
+	}
+
+	/**
+	 * Create an execution error
+	 */
+	static execution(scriptPath: string, exitCode: number, stderr?: string, hookName?: string): HookExecutionError {
+		const hookPrefix = hookName ? `${hookName} hook` : "Hook script"
+		const message = `${hookPrefix} exited with code ${exitCode}`
+		return new HookExecutionError(
+			{
+				type: HookErrorType.EXECUTION,
+				message,
+				details: stderr ? `stderr:\n${stderr}` : undefined,
+				scriptPath,
+				exitCode,
+				stderr,
+			},
+			message,
+		)
+	}
+
+	/**
+	 * Create a cancellation error
+	 */
+	static cancellation(scriptPath: string, hookName?: string): HookExecutionError {
+		const hookPrefix = hookName ? `${hookName} hook` : "Hook"
+		return new HookExecutionError({
+			type: HookErrorType.CANCELLATION,
+			message: `${hookPrefix} execution was cancelled`,
+			details: "The hook was cancelled by the user before completion",
+			scriptPath,
+			exitCode: 130, // Standard SIGINT exit code
+		})
+	}
+}
diff --git a/apps/vscode/src/core/hooks/HookProcess.ts b/apps/vscode/src/core/hooks/HookProcess.ts
new file mode 100644
index 0000000..7627fd6
--- /dev/null
+++ b/apps/vscode/src/core/hooks/HookProcess.ts
@@ -0,0 +1,456 @@
+import { ChildProcess, spawn } from "child_process"
+import { EventEmitter } from "events"
+import { Logger } from "@/shared/services/Logger"
+import { resolveWindowsPowerShellExecutable } from "@/utils/powershell"
+import { HookProcessRegistry } from "./HookProcessRegistry"
+import { escapeShellPath } from "./shell-escape"
+
+// Maximum total output size (stdout + stderr combined)
+const MAX_HOOK_OUTPUT_SIZE = 1024 * 1024 // 1MB
+
+interface HookLaunchConfig {
+	command: string
+	args: string[]
+	shell: boolean
+	detached: boolean
+}
+
+const WINDOWS_HOOK_LAUNCHER_CACHE_TTL_MS = 5 * 60 * 1000
+
+let resolvedHookLauncherCommandPromise: Promise<string> | null = null
+let resolvedHookLauncherCommandExpiresAt = 0
+
+export function resetHookLaunchConfigCacheForTesting(): void {
+	resolvedHookLauncherCommandPromise = null
+	resolvedHookLauncherCommandExpiresAt = 0
+}
+
+function shouldRefreshWindowsLauncherCache(now: number): boolean {
+	return !resolvedHookLauncherCommandPromise || now >= resolvedHookLauncherCommandExpiresAt
+}
+
+/**
+ * Returns the process launch configuration for a hook script.
+ *
+ * On Windows, the PowerShell executable lookup is cached briefly so concurrent
+ * hook launches share the same in-flight resolution and avoid repeated process
+ * spawning.
+ *
+ * @param scriptPath Path to the hook script to launch.
+ * @param resolvePowerShellExecutable Windows only. Called at most once per
+ *   `WINDOWS_HOOK_LAUNCHER_CACHE_TTL_MS` window; subsequent concurrent or cached
+ *   calls reuse the shared result and ignore this parameter.
+ */
+export async function getHookLaunchConfig(
+	scriptPath: string,
+	resolvePowerShellExecutable: () => Promise<string> = resolveWindowsPowerShellExecutable,
+): Promise<HookLaunchConfig> {
+	if (process.platform === "win32") {
+		const now = Date.now()
+
+		if (shouldRefreshWindowsLauncherCache(now)) {
+			resolvedHookLauncherCommandPromise = resolvePowerShellExecutable().catch((error) => {
+				resolvedHookLauncherCommandPromise = null
+				resolvedHookLauncherCommandExpiresAt = 0
+				throw error
+			})
+			resolvedHookLauncherCommandExpiresAt = now + WINDOWS_HOOK_LAUNCHER_CACHE_TTL_MS
+		}
+
+		const powerShellExecutable = await resolvedHookLauncherCommandPromise!
+		return {
+			command: powerShellExecutable,
+			args: ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", scriptPath],
+			shell: false,
+			detached: false,
+		}
+	}
+
+	const escapedScriptPath = escapeShellPath(scriptPath)
+	return {
+		command: escapedScriptPath,
+		args: [],
+		shell: true,
+		detached: true,
+	}
+}
+
+/**
+ * HookProcess manages the execution of a hook script with streaming output capabilities.
+ * Similar to StandaloneTerminalProcess but specialized for hook execution.
+ *
+ * Key features:
+ * - Real-time stdout/stderr streaming via line events
+ * - Separate handling of visual output vs. JSON response
+ * - 30-second execution timeout
+ * - 1MB output size limit (prevents memory issues)
+ * - Process lifecycle management with abort support
+ */
+export class HookProcess extends EventEmitter {
+	private childProcess: ChildProcess | null = null
+	private buffer = ""
+	private fullOutput = ""
+	private lastRetrievedIndex = 0
+	private exitCode: number | null = null
+	private isCompleted = false
+	private timeoutHandle: NodeJS.Timeout | null = null // 30-second execution timeout
+
+	// Separate buffers for stdout and stderr
+	private stdoutBuffer = ""
+	private stderrBuffer = ""
+
+	// Output size tracking
+	private stdoutSize = 0
+	private stderrSize = 0
+	private outputTruncated = false
+
+	// Track registration state to prevent leaks and ensure cleanup
+	private isRegistered = false
+
+	constructor(
+		private readonly scriptPath: string,
+		private readonly timeoutMs: number = 30000,
+		private readonly abortSignal?: AbortSignal,
+		private readonly cwd?: string,
+	) {
+		super()
+	}
+
+	/**
+	 * Execute the hook script with the given JSON input
+	 * @param inputJson The JSON string to pass to the hook via stdin
+	 */
+	async run(inputJson: string): Promise<void> {
+		// Wrap in try/finally to guarantee cleanup even if errors occur
+		try {
+			return await new Promise((resolve, reject) => {
+				// Register this process for tracking
+				HookProcessRegistry.register(this)
+				this.isRegistered = true
+
+				// Check if already aborted
+				if (this.abortSignal?.aborted) {
+					this.safeUnregister()
+					reject(new Error("Hook execution cancelled"))
+					return
+				}
+
+				// Set up abort handler
+				const abortHandler = () => {
+					if (this.childProcess && !this.isCompleted) {
+						this.isCompleted = true // Mark as completed immediately
+
+						// Remove abort listener immediately to prevent double-rejection
+						if (this.abortSignal) {
+							this.abortSignal.removeEventListener("abort", abortHandler)
+						}
+
+						// Clean up execution timeout timer
+						if (this.timeoutHandle) {
+							clearTimeout(this.timeoutHandle)
+							this.timeoutHandle = null
+						}
+
+						// Unregister from active processes
+						this.safeUnregister()
+
+						// Kill the process (async, fire-and-forget)
+						if (this.childProcess.pid) {
+							this.childProcess.kill("SIGTERM")
+						}
+
+						// Reject immediately - don't wait for process to die
+						reject(new Error("Hook execution cancelled by user"))
+					}
+				}
+
+				if (this.abortSignal) {
+					this.abortSignal.addEventListener("abort", abortHandler, { once: true })
+				}
+
+				// Windows executes hooks with PowerShell directly.
+				// Unix executes hook files through the shell for shebang support.
+				void (async () => {
+					try {
+						const launchConfig = await getHookLaunchConfig(this.scriptPath)
+						this.childProcess = spawn(launchConfig.command, launchConfig.args, {
+							stdio: ["pipe", "pipe", "pipe"],
+							shell: launchConfig.shell,
+							detached: launchConfig.detached,
+							cwd: this.cwd, // Execute from the determined workspace root
+							windowsHide: true,
+						})
+
+						let didEmitEmptyLine = false
+
+						// Set up timeout
+						this.timeoutHandle = setTimeout(() => {
+							if (this.childProcess && !this.isCompleted) {
+								this.childProcess.kill("SIGTERM")
+								reject(
+									new Error(
+										`Hook execution timed out after ${this.timeoutMs}ms. The hook script at '${this.scriptPath}' took too long to complete.`,
+									),
+								)
+							}
+						}, this.timeoutMs)
+
+						// Handle stdout
+						this.childProcess.stdout?.on("data", (data) => {
+							const output = data.toString()
+							this.stdoutBuffer += output
+							this.handleOutput(output, didEmitEmptyLine, "stdout")
+							if (!didEmitEmptyLine && output) {
+								this.emit("line", "", "stdout") // Signal start of output
+								didEmitEmptyLine = true
+							}
+						})
+
+						// Handle stderr
+						this.childProcess.stderr?.on("data", (data) => {
+							const output = data.toString()
+							this.stderrBuffer += output
+							this.handleOutput(output, didEmitEmptyLine, "stderr")
+							if (!didEmitEmptyLine && output) {
+								this.emit("line", "", "stderr") // Signal start of output
+								didEmitEmptyLine = true
+							}
+						})
+
+						// Handle process completion
+						this.childProcess.on("close", (code, signal) => {
+							this.exitCode = code
+							this.isCompleted = true
+							this.emitRemainingBuffer()
+
+							// Unregister from active processes
+							this.safeUnregister()
+
+							// Clear execution timeout timer
+							if (this.timeoutHandle) {
+								clearTimeout(this.timeoutHandle)
+								this.timeoutHandle = null
+							}
+
+							// Remove abort listener
+							if (this.abortSignal) {
+								this.abortSignal.removeEventListener("abort", abortHandler)
+							}
+
+							this.emit("completed", code, signal)
+
+							if (code === 0) {
+								resolve()
+							} else {
+								reject(new Error(`Hook exited with code ${code}${signal ? `, signal ${signal}` : ""}`))
+							}
+						})
+
+						// Handle process errors
+						this.childProcess.on("error", (error) => {
+							// Unregister from active processes
+							this.safeUnregister()
+
+							if (this.timeoutHandle) {
+								clearTimeout(this.timeoutHandle)
+								this.timeoutHandle = null
+							}
+							// Remove abort listener
+							if (this.abortSignal) {
+								this.abortSignal.removeEventListener("abort", abortHandler)
+							}
+							this.emit("error", error)
+							reject(error)
+						})
+
+						// Send input to the process
+						try {
+							this.childProcess.stdin?.write(inputJson)
+							this.childProcess.stdin?.end()
+						} catch (error) {
+							reject(new Error(`Failed to write input to hook: ${error}`))
+						}
+					} catch (error) {
+						this.safeUnregister()
+						if (this.abortSignal) {
+							this.abortSignal.removeEventListener("abort", abortHandler)
+						}
+						reject(error)
+					}
+				})()
+			})
+		} finally {
+			// Guaranteed cleanup even if process setup fails or throws
+			this.safeUnregister()
+		}
+	}
+
+	/**
+	 * Safely unregister from the process registry.
+	 * This is idempotent and prevents double-unregistration issues.
+	 */
+	private safeUnregister(): void {
+		if (this.isRegistered) {
+			HookProcessRegistry.unregister(this)
+			this.isRegistered = false
+		}
+	}
+
+	/**
+	 * Handle output data and emit line events.
+	 * Enforces 1MB total output limit to prevent memory issues.
+	 */
+	private handleOutput(data: string, _didEmitEmptyLine: boolean, stream: "stdout" | "stderr"): void {
+		// Check output size limit
+		const dataSize = Buffer.byteLength(data)
+		const currentTotalSize = this.stdoutSize + this.stderrSize
+
+		if (currentTotalSize + dataSize > MAX_HOOK_OUTPUT_SIZE) {
+			if (!this.outputTruncated) {
+				this.outputTruncated = true
+				const truncationMsg = "\n\n[Output truncated: exceeded 1MB limit]"
+				this.emit("line", truncationMsg, stream)
+				Logger.warn(`[HookProcess] Output exceeded ${MAX_HOOK_OUTPUT_SIZE} bytes, truncating`)
+			}
+			return // Drop further output
+		}
+
+		// Track size by stream
+		if (stream === "stdout") {
+			this.stdoutSize += dataSize
+		} else {
+			this.stderrSize += dataSize
+		}
+
+		// Store full output
+		this.fullOutput += data
+
+		// Emit lines immediately
+		this.emitLines(data, stream)
+	}
+
+	/**
+	 * Emit complete lines from buffered output
+	 */
+	private emitLines(chunk: string, stream: "stdout" | "stderr"): void {
+		this.buffer += chunk
+		let lineEndIndex
+		while ((lineEndIndex = this.buffer.indexOf("\n")) !== -1) {
+			const line = this.buffer.slice(0, lineEndIndex).trimEnd()
+			this.emit("line", line, stream)
+			this.buffer = this.buffer.slice(lineEndIndex + 1)
+		}
+		this.lastRetrievedIndex = this.fullOutput.length - this.buffer.length
+	}
+
+	/**
+	 * Emit any remaining buffered output when process completes
+	 */
+	private emitRemainingBuffer(): void {
+		if (this.buffer) {
+			const remainingBuffer = this.buffer.trimEnd()
+			if (remainingBuffer) {
+				// Determine which stream this came from based on content
+				// This is a fallback; in practice, line events should capture most output
+				this.emit("line", remainingBuffer, "stdout")
+			}
+			this.buffer = ""
+			this.lastRetrievedIndex = this.fullOutput.length
+		}
+	}
+
+	/**
+	 * Get unretrieved output (for compatibility with terminal process interface)
+	 */
+	getUnretrievedOutput(): string {
+		const unretrieved = this.fullOutput.slice(this.lastRetrievedIndex)
+		this.lastRetrievedIndex = this.fullOutput.length
+		return unretrieved.trimEnd()
+	}
+
+	/**
+	 * Get the complete stdout buffer (for JSON parsing)
+	 */
+	getStdout(): string {
+		return this.stdoutBuffer
+	}
+
+	/**
+	 * Get the complete stderr buffer (for error reporting)
+	 */
+	getStderr(): string {
+		return this.stderrBuffer
+	}
+
+	/**
+	 * Get the exit code
+	 */
+	getExitCode(): number | null {
+		return this.exitCode
+	}
+
+	/**
+	 * Check if process has completed
+	 */
+	hasCompleted(): boolean {
+		return this.isCompleted
+	}
+
+	/**
+	 * Terminate the process and its entire process tree.
+	 * Uses process groups on Unix to kill child processes.
+	 * Implements graceful shutdown with 2-second timeout before force kill.
+	 */
+	async terminate(): Promise<void> {
+		if (!this.childProcess || this.isCompleted) {
+			// Still ensure unregistration even if process already completed
+			this.safeUnregister()
+			return
+		}
+
+		const pid = this.childProcess.pid
+		if (!pid) {
+			return
+		}
+
+		try {
+			// On Unix, kill process group (negative PID kills all children)
+			// On Windows, just kill the process (tree-kill would be better but adds dependency)
+			if (process.platform !== "win32") {
+				// Kill process group with SIGTERM for graceful shutdown
+				process.kill(-pid, "SIGTERM")
+			} else {
+				// On Windows, just kill the process
+				this.childProcess.kill("SIGTERM")
+			}
+
+			// Wait up to 2 seconds for graceful shutdown
+			const gracefulTimeout = new Promise((resolve) => setTimeout(resolve, 2000))
+			const processExit = new Promise((resolve) => {
+				this.childProcess?.once("exit", resolve)
+			})
+
+			await Promise.race([processExit, gracefulTimeout])
+
+			// Force kill if still running
+			if (!this.isCompleted) {
+				if (process.platform !== "win32") {
+					process.kill(-pid, "SIGKILL")
+				} else {
+					this.childProcess?.kill("SIGKILL")
+				}
+			}
+		} catch (error) {
+			// Process might already be dead, which is fine
+			Logger.debug(`[HookProcess] Error during termination: ${error}`)
+		} finally {
+			// Clear timeout regardless
+			if (this.timeoutHandle) {
+				clearTimeout(this.timeoutHandle)
+				this.timeoutHandle = null
+			}
+			// Ensure unregistration even if termination fails
+			this.safeUnregister()
+		}
+	}
+}
diff --git a/apps/vscode/src/core/hooks/HookProcessRegistry.ts b/apps/vscode/src/core/hooks/HookProcessRegistry.ts
new file mode 100644
index 0000000..b8aab54
--- /dev/null
+++ b/apps/vscode/src/core/hooks/HookProcessRegistry.ts
@@ -0,0 +1,64 @@
+import { Logger } from "@/shared/services/Logger"
+import { HookProcess } from "./HookProcess"
+
+/**
+ * Global registry for tracking active hook processes.
+ *
+ * Purpose:
+ * - Prevents zombie processes by tracking all running hooks
+ * - Enables cleanup on extension deactivation
+ * - Provides visibility into active hook executions
+ *
+ * Usage:
+ * - HookProcess automatically registers/unregisters itself
+ * - Extension deactivation calls terminateAll()
+ * - Can query active count for monitoring/debugging
+ */
+export class HookProcessRegistry {
+	private static activeProcesses = new Set<HookProcess>()
+
+	/**
+	 * Register a hook process as active.
+	 * Called by HookProcess when execution starts.
+	 */
+	static register(process: HookProcess): void {
+		HookProcessRegistry.activeProcesses.add(process)
+	}
+
+	/**
+	 * Unregister a hook process (completed or failed).
+	 * Called by HookProcess when execution ends.
+	 */
+	static unregister(process: HookProcess): void {
+		HookProcessRegistry.activeProcesses.delete(process)
+	}
+
+	/**
+	 * Terminate all active hook processes.
+	 * Called during extension deactivation to prevent zombie processes.
+	 */
+	static async terminateAll(): Promise<void> {
+		const processes = Array.from(HookProcessRegistry.activeProcesses)
+		if (processes.length > 0) {
+			Logger.log(`[HookProcessRegistry] Terminating ${processes.length} active hook process(es)`)
+			await Promise.all(processes.map((p) => p.terminate()))
+			HookProcessRegistry.activeProcesses.clear()
+		}
+	}
+
+	/**
+	 * Get the number of currently active hook processes.
+	 * Useful for monitoring and debugging.
+	 */
+	static getActiveCount(): number {
+		return HookProcessRegistry.activeProcesses.size
+	}
+
+	/**
+	 * Clear the registry (for testing only).
+	 * @internal
+	 */
+	static resetForTesting(): void {
+		HookProcessRegistry.activeProcesses.clear()
+	}
+}
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/README.md b/apps/vscode/src/core/hooks/__tests__/fixtures/README.md
new file mode 100644
index 0000000..1841abd
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/README.md
@@ -0,0 +1,175 @@
+# Hook Test Fixtures
+
+This directory contains pre-written hook scripts for testing the Cline hooks system.
+
+## Directory Structure
+
+```
+fixtures/
+├── hooks/
+│   ├── pretooluse/       # PreToolUse hook fixtures
+│   │   ├── success/      # Returns success immediately
+│   │   ├── blocking/     # Blocks tool execution
+│   │   ├── context-injection/  # Adds context with type prefix
+│   │   └── error/        # Exits with error code
+│   ├── posttooluse/      # PostToolUse hook fixtures
+│   │   ├── success/      # Returns success immediately
+│   │   └── error/        # Exits with error code
+│   └── template/         # Template for new hooks
+└── inputs/               # Sample input data (future)
+```
+
+## Using Fixtures in Tests
+
+### With loadFixture()
+
+The `loadFixture()` helper function copies a fixture to your test environment:
+
+```typescript
+import { loadFixture } from '../test-utils'
+
+it("should work with real hook", async () => {
+  const { getEnv } = setupHookTests()
+  
+  await loadFixture("hooks/pretooluse/success", getEnv().tempDir)
+  
+  const factory = new HookFactory()
+  const runner = await factory.create("PreToolUse")
+  const result = await runner.run(buildPreToolUseInput({ toolName: "test_tool" }))
+  
+  result.cancel.should.be.false()
+})
+```
+
+### Direct File Copy
+
+For more control, you can also manually copy fixture files.
+
+## Available Fixtures
+
+### PreToolUse Hooks
+
+#### `hooks/pretooluse/success`
+- **Returns**: `{ cancel: false, contextModification: "PreToolUse hook executed successfully", errorMessage: "" }`
+- **Use for**: Testing happy path scenarios
+
+#### `hooks/pretooluse/blocking`
+- **Returns**: `{ cancel: true, contextModification: "", errorMessage: "Tool execution blocked by hook" }`
+- **Use for**: Testing tool execution blocking
+
+#### `hooks/pretooluse/context-injection`
+- **Returns**: `{ cancel: false, contextModification: "WORKSPACE_RULES: Tool [toolName] requires review", errorMessage: "" }`
+- **Use for**: Testing context injection with type prefixes
+- **Note**: Dynamically includes tool name from input
+
+#### `hooks/pretooluse/error`
+- **Behavior**: Prints error to stderr and exits with code 1
+- **Use for**: Testing error handling
+
+### PostToolUse Hooks
+
+#### `hooks/posttooluse/success`
+- **Returns**: `{ cancel: false, contextModification: "PostToolUse hook executed successfully", errorMessage: "" }`
+- **Use for**: Testing PostToolUse execution
+
+#### `hooks/posttooluse/error`
+- **Behavior**: Prints error to stderr and exits with code 1
+- **Use for**: Testing error handling in PostToolUse
+
+### UserPromptSubmit Hooks
+
+#### `hooks/userpromptsubmit/success`
+- **Returns**: `{ cancel: false, contextModification: "Prompt approved", errorMessage: "" }`
+- **Use for**: Testing successful prompt submission
+
+#### `hooks/userpromptsubmit/blocking`
+- **Returns**: `{ cancel: true, contextModification: "", errorMessage: "Prompt violates policy" }`
+- **Use for**: Testing prompt submission blocking
+
+#### `hooks/userpromptsubmit/context-injection`
+- **Returns**: `{ cancel: false, contextModification: "CONTEXT_INJECTION: User is in plan mode", errorMessage: "" }`
+- **Use for**: Testing context injection into task request
+
+#### `hooks/userpromptsubmit/multiline`
+- **Returns**: `{ cancel: false, contextModification: "Line count: N", errorMessage: "" }`
+- **Use for**: Testing multiline prompt handling
+- **Note**: Dynamically counts newlines in the prompt
+
+#### `hooks/userpromptsubmit/large-prompt`
+- **Returns**: `{ cancel: false, contextModification: "Prompt size: N", errorMessage: "" }`
+- **Use for**: Testing large prompt handling
+- **Note**: Dynamically reports prompt character count
+
+#### `hooks/userpromptsubmit/special-chars`
+- **Returns**: `{ cancel: false, contextModification: "Special chars preserved" | "Missing special chars", errorMessage: "" }`
+- **Use for**: Testing special character preservation
+- **Note**: Checks for @, #, and $ characters
+
+#### `hooks/userpromptsubmit/empty-prompt`
+- **Returns**: `{ cancel: false, contextModification: "Prompt length: 0", errorMessage: "" }`
+- **Use for**: Testing empty prompt handling
+- **Note**: Safely handles undefined or empty prompts
+
+#### `hooks/userpromptsubmit/malformed-json`
+- **Behavior**: Outputs invalid JSON ("not valid json")
+- **Use for**: Testing malformed JSON error handling
+
+#### `hooks/userpromptsubmit/error`
+- **Behavior**: Prints error to stderr and exits with code 1
+- **Use for**: Testing error handling in UserPromptSubmit
+
+### TaskStart Hooks
+
+#### `hooks/taskstart/success`
+- **Returns**: `{ cancel: false, contextModification: "TaskStart hook executed successfully", errorMessage: "" }`
+- **Use for**: Testing TaskStart hook success path, allowing task to proceed
+
+#### `hooks/taskstart/blocking`
+- **Returns**: `{ cancel: true, contextModification: "", errorMessage: "Task execution blocked by hook" }`
+- **Use for**: Testing task blocking at start (e.g., policy enforcement)
+
+#### `hooks/taskstart/error`
+- **Behavior**: Prints error to stderr and exits with code 1
+- **Use for**: Testing error handling in TaskStart hooks
+
+## Platform Considerations
+
+Hooks run cross-platform, but runtime differs by OS:
+
+- **Linux/macOS**: executable hook files run directly (shebang/executable bit)
+- **Windows**: hooks execute through PowerShell; tests may use a small PowerShell bridge script that pipes stdin to a Node companion file
+
+### Creating New Fixtures
+
+1. Create a new directory under the appropriate hook type
+2. Add the hook script with shebang `#!/usr/bin/env node`
+3. Make executable: `chmod +x HookName`
+4. Update this README with the new fixture
+
+### Example: Creating a new fixture
+
+```bash
+# Create directory
+mkdir -p src/core/hooks/__tests__/fixtures/hooks/pretooluse/my-new-scenario
+
+# Create hook script
+cat > src/core/hooks/__tests__/fixtures/hooks/pretooluse/my-new-scenario/PreToolUse << 'EOF'
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "My custom context",
+  errorMessage: ""
+}));
+EOF
+
+# Make executable
+chmod +x src/core/hooks/__tests__/fixtures/hooks/pretooluse/my-new-scenario/PreToolUse
+```
+
+## Maintenance
+
+- Keep fixtures simple and focused on one scenario
+- Fixtures are Node.js scripts that work across platforms
+- Update this README when adding new fixtures
+- Remove obsolete fixtures and update references
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/posttooluse/error/PostToolUse b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/posttooluse/error/PostToolUse
new file mode 100755
index 0000000..c9ddd7a
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/posttooluse/error/PostToolUse
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.error("PostToolUse hook execution failed");
+process.exit(1);
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/posttooluse/success/PostToolUse b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/posttooluse/success/PostToolUse
new file mode 100755
index 0000000..54cfcc1
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/posttooluse/success/PostToolUse
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "PostToolUse hook executed successfully",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/blocking/PreToolUse b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/blocking/PreToolUse
new file mode 100755
index 0000000..0905f39
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/blocking/PreToolUse
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Tool execution blocked by hook"
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/context-injection/PreToolUse b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/context-injection/PreToolUse
new file mode 100755
index 0000000..9222dca
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/context-injection/PreToolUse
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const toolName = input.preToolUse?.toolName || 'unknown';
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: `WORKSPACE_RULES: Tool ${toolName} requires review`,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/error/PreToolUse b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/error/PreToolUse
new file mode 100755
index 0000000..f114a8c
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/error/PreToolUse
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.error("Hook execution failed");
+process.exit(1);
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/success/PreToolUse b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/success/PreToolUse
new file mode 100755
index 0000000..c50fbfd
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/pretooluse/success/PreToolUse
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "PreToolUse hook executed successfully",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/error/TaskCancel b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/error/TaskCancel
new file mode 100755
index 0000000..377c43c
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/error/TaskCancel
@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.error("Hook execution error");
+process.exit(1);
\ No newline at end of file
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-no-error/TaskCancel b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-no-error/TaskCancel
new file mode 100755
index 0000000..3287113
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-no-error/TaskCancel
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-with-error/TaskCancel b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-with-error/TaskCancel
new file mode 100755
index 0000000..f931c8f
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-with-error/TaskCancel
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "some error happened"
+}));
\ No newline at end of file
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-no-error/TaskCancel b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-no-error/TaskCancel
new file mode 100755
index 0000000..f18ffe5
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-no-error/TaskCancel
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  cancel: false,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-with-error/TaskCancel b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-with-error/TaskCancel
new file mode 100755
index 0000000..8d57f13
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-with-error/TaskCancel
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  cancel: false,
+  errorMessage: "some error happened"
+}));
\ No newline at end of file
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/context-injection/TaskComplete b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/context-injection/TaskComplete
new file mode 100755
index 0000000..11142c0
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/context-injection/TaskComplete
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "COMPLETED: " + input.taskComplete.taskMetadata.result,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/error/TaskComplete b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/error/TaskComplete
new file mode 100755
index 0000000..ead860e
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/error/TaskComplete
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.error("Hook execution error");
+process.exit(1);
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/success/TaskComplete b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/success/TaskComplete
new file mode 100755
index 0000000..5277138
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskcomplete/success/TaskComplete
@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TaskComplete hook executed successfully",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/context-deleted/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/context-deleted/TaskResume
new file mode 100755
index 0000000..3bf6934
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/context-deleted/TaskResume
@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const deleted = input.taskResume?.previousState?.conversationHistoryDeleted === 'true';
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: deleted
+    ? "TASK_CONTEXT: Some conversation history was truncated due to context window limits"
+    : "",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/context-injection/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/context-injection/TaskResume
new file mode 100755
index 0000000..d796e2c
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/context-injection/TaskResume
@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const taskId = input.taskResume?.taskMetadata?.taskId || 'unknown';
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: `WORKSPACE_RULES: Task ${taskId} resumed - review previous context`,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/error/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/error/TaskResume
new file mode 100755
index 0000000..1fea698
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/error/TaskResume
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.error("TaskResume hook encountered an error");
+process.exit(1);
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/long-pause/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/long-pause/TaskResume
new file mode 100755
index 0000000..326b72e
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/long-pause/TaskResume
@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastMessageTs = parseInt(input.taskResume?.previousState?.lastMessageTs || '0');
+const now = Date.now();
+const hoursAgo = Math.floor((now - lastMessageTs) / 3600000);
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hoursAgo >= 1
+    ? `TASK_CONTEXT: Task was paused ${hoursAgo} hours ago - you may need to re-familiarize yourself with the context`
+    : "",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/message-count/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/message-count/TaskResume
new file mode 100755
index 0000000..5d49dd9
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/message-count/TaskResume
@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const messageCount = parseInt(input.taskResume?.previousState?.messageCount || '0');
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: `TASK_CONTEXT: Resuming task with ${messageCount} previous messages`,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/recent-resume/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/recent-resume/TaskResume
new file mode 100755
index 0000000..4e04a20
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/recent-resume/TaskResume
@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastMessageTs = parseInt(input.taskResume?.previousState?.lastMessageTs || '0');
+const now = Date.now();
+const minutesAgo = Math.floor((now - lastMessageTs) / 60000);
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: minutesAgo < 5 
+    ? "TASK_CONTEXT: Recently paused task - context is still fresh"
+    : "",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/success/TaskResume b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/success/TaskResume
new file mode 100755
index 0000000..f4dfc66
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskresume/success/TaskResume
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TaskResume hook executed successfully",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/blocking/TaskStart b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/blocking/TaskStart
new file mode 100755
index 0000000..599c164
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/blocking/TaskStart
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Task execution blocked by hook"
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/error/TaskStart b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/error/TaskStart
new file mode 100755
index 0000000..ead860e
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/error/TaskStart
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.error("Hook execution error");
+process.exit(1);
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/success/TaskStart b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/success/TaskStart
new file mode 100755
index 0000000..4b901e8
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/taskstart/success/TaskStart
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TaskStart hook executed successfully",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/blocking/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/blocking/UserPromptSubmit
new file mode 100755
index 0000000..ebb5ea6
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/blocking/UserPromptSubmit
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Prompt violates policy"
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/context-injection/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/context-injection/UserPromptSubmit
new file mode 100755
index 0000000..33dc7f8
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/context-injection/UserPromptSubmit
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "CONTEXT_INJECTION: User is in plan mode",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/empty-prompt/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/empty-prompt/UserPromptSubmit
new file mode 100755
index 0000000..2ad83ab
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/empty-prompt/UserPromptSubmit
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const promptLength = typeof input.userPromptSubmit.prompt === 'string' ? input.userPromptSubmit.prompt.length : 0;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Prompt length: " + promptLength,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/error/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/error/UserPromptSubmit
new file mode 100755
index 0000000..ead860e
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/error/UserPromptSubmit
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.error("Hook execution error");
+process.exit(1);
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/large-prompt/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/large-prompt/UserPromptSubmit
new file mode 100755
index 0000000..c6673e5
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/large-prompt/UserPromptSubmit
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const size = input.userPromptSubmit.prompt.length;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Prompt size: " + size,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/malformed-json/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/malformed-json/UserPromptSubmit
new file mode 100755
index 0000000..9b20828
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/malformed-json/UserPromptSubmit
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+console.log("not valid json");
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/multiline/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/multiline/UserPromptSubmit
new file mode 100755
index 0000000..97a8cb3
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/multiline/UserPromptSubmit
@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lineCount = (input.userPromptSubmit.prompt.match(/\n/g) || []).length + 1;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Line count: " + lineCount,
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/special-chars/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/special-chars/UserPromptSubmit
new file mode 100755
index 0000000..d04803d
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/special-chars/UserPromptSubmit
@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const prompt = input.userPromptSubmit.prompt;
+const hasSpecialChars = prompt.includes("@") && prompt.includes("#") && prompt.includes("$");
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasSpecialChars ? "Special chars preserved" : "Missing special chars",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/success/UserPromptSubmit b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/success/UserPromptSubmit
new file mode 100755
index 0000000..7b36926
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/hooks/userpromptsubmit/success/UserPromptSubmit
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Prompt approved",
+  errorMessage: ""
+}));
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/template/HookName b/apps/vscode/src/core/hooks/__tests__/fixtures/template/HookName
new file mode 100755
index 0000000..08e2255
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/template/HookName
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+ * TEMPLATE HOOK SCRIPT
+ *
+ * This is a template for creating new hook fixtures.
+ * Copy this file to create a new fixture script.
+ *
+ * Customize the logic below to implement your specific hook behavior.
+ */
+
+try {
+  // Parse the input from stdin (what gets passed to the hook)
+  const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+
+  // Extract relevant input data
+  // For PreToolUse hooks:
+  const { toolName, parameters } = input.preToolUse || {};
+  // For PostToolUse hooks:
+  // const { toolName, parameters, result, success, executionTimeMs } = input.postToolUse || {};
+
+  // Common metadata (available in all hook types)
+  const { hookName: hookType, timestamp, taskId, workspaceRoots, userId } = input;
+
+  // Initialize output variables
+  let shouldContinue = true;
+  let contextModification = "";
+  let errorMessage = "";
+
+  // === CUSTOMIZE THIS LOGIC ===
+  // Implement your hook logic here
+
+  // Example: Simple success hook
+  contextModification = "TEMPLATE: Hook executed successfully";
+
+  // Example: Context injection based on tool name
+  if (toolName === "write_to_file") {
+    contextModification = "FILE_OPERATIONS: File modification operation";
+  } else if (toolName === "run_command") {
+    contextModification = "SYSTEM_OPERATIONS: Command execution operation";
+  }
+
+  // Example: Validation/blocking
+  // if (!parameters?.path) {
+  //   shouldContinue = false;
+  //   errorMessage = "ERROR: Tool requires a 'path' parameter";
+  // }
+
+  // === END CUSTOM LOGIC ===
+
+  // Return the standardized output format
+  console.log(JSON.stringify({
+    shouldContinue,
+    contextModification,
+    errorMessage
+  }));
+
+} catch (error) {
+  // Error handling - hooks should handle their own errors gracefully
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  console.log(JSON.stringify({
+    cancel: true,
+    contextModification: "",
+    errorMessage: `HOOK_ERROR: ${errorMessage}`
+  }));
+}
diff --git a/apps/vscode/src/core/hooks/__tests__/fixtures/template/README.md b/apps/vscode/src/core/hooks/__tests__/fixtures/template/README.md
new file mode 100644
index 0000000..2b82263
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/fixtures/template/README.md
@@ -0,0 +1,96 @@
+# Hook Template for New Fixtures
+
+This directory contains a template for creating new hook fixtures. When adding a new hook fixture, copy from this template and customize as needed.
+
+## Files in This Template
+
+- `HookName` - Hook script template (executable Node.js script)
+- `README.md` - This file
+
+## How to Create a New Fixture
+
+### Step 1: Choose the Scenario Type
+
+Decide what your hook fixture should test:
+- `success` - Returns success immediately
+- `blocking` - Blocks tool execution
+- `context-injection` - Adds context information
+- `error` - Exits with error code
+
+### Step 2: Create the Directory Structure
+
+```bash
+# Example for a new PreToolUse validation fixture
+mkdir -p src/core/hooks/__tests__/fixtures/hooks/pretooluse/validation/
+
+# Copy template file
+cp src/core/hooks/__tests__/fixtures/template/HookName src/core/hooks/__tests__/fixtures/hooks/pretooluse/validation/PreToolUse
+
+# Make executable
+chmod +x src/core/hooks/__tests__/fixtures/hooks/pretooluse/validation/PreToolUse
+```
+
+### Step 3: Customize the Hook Script
+
+Edit the new fixture file to implement your specific logic:
+
+```javascript
+#!/usr/bin/env node
+
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+
+// Extract relevant data
+const { toolName, parameters } = input.preToolUse;
+
+let shouldContinue = true;
+let contextModification = "";
+let errorMessage = "";
+
+// Your custom logic here
+if (!parameters || !parameters.path) {
+  shouldContinue = false;
+  errorMessage = "ERROR: Tool requires a 'path' parameter";
+} else {
+  contextModification = "VALIDATION: Basic input validation passed";
+}
+
+// Return standardized output
+console.log(JSON.stringify({
+  shouldContinue,
+  contextModification,
+  errorMessage
+}));
+```
+
+### Step 4: Update Documentation
+
+Add your new fixture to `fixtures/README.md` with:
+- Fixture path
+- What it returns
+- What it's used for testing
+- Any special behavior notes
+
+## Best Practices
+
+### Keep Fixtures Focused
+- Test one specific scenario per fixture
+- Use simple, easy-to-understand logic
+- Document complex behavior with comments
+
+### Platform Compatibility
+- Write portable Node.js code
+- These fixtures work via embedded shell (like git hooks)
+- Avoid platform-specific logic
+
+### Naming Conventions
+- Use UPPERCASE for context type prefixes (e.g., `WORKSPACE_RULES:`, `FILE_OPERATIONS:`)
+- Be descriptive about what the fixture tests
+- Follow existing naming patterns in other fixtures
+
+## Examples from Existing Fixtures
+
+See the existing fixtures for real-world examples:
+- `../hooks/pretooluse/success/` - Simple success case
+- `../hooks/pretooluse/blocking/` - How to block execution
+- `../hooks/pretooluse/context-injection/` - How to inject context
+- `../hooks/pretooluse/error/` - How to return errors
diff --git a/apps/vscode/src/core/hooks/__tests__/hook-factory.test.ts b/apps/vscode/src/core/hooks/__tests__/hook-factory.test.ts
new file mode 100644
index 0000000..35d7a92
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/hook-factory.test.ts
@@ -0,0 +1,689 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import path from "path"
+import sinon from "sinon"
+import { setDistinctId } from "@/services/logging/distinctId"
+import { HookFactory } from "../hook-factory"
+import { createHookTestEnv, HookTestEnv, stubHookDirs, withPlatform, writeHookScriptForPlatform } from "./test-utils"
+
+describe("Hook System", () => {
+	let tempDir: string
+	let sandbox: sinon.SinonSandbox
+	let hookTestEnv: HookTestEnv
+	const WINDOWS_HOOK_TEST_TIMEOUT_MS = 15000
+	const WINDOWS_TEST_TIMEOUT_MS = 10000
+
+	// Helper to write executable hook script
+	const writeHookScript = async (hookPath: string, nodeScript: string): Promise<void> => {
+		await writeHookScriptForPlatform(hookPath, nodeScript)
+	}
+
+	beforeEach(async () => {
+		if (process.platform === "win32") {
+		}
+		setDistinctId("test-id")
+		hookTestEnv = await createHookTestEnv()
+		tempDir = hookTestEnv.tempDir
+		sandbox = hookTestEnv.sandbox
+	})
+
+	afterEach(async () => {
+		await hookTestEnv.cleanup()
+	})
+
+	describe("NoOpRunner", () => {
+		it("should return success without executing anything when no hooks found", async () => {
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+	})
+
+	describe("StdioHookRunner", () => {
+		it(
+			"should execute workspace hook from its respective workspace root directory",
+			async () => {
+				if (process.platform === "win32") {
+				}
+
+				// Create a test hook script that outputs the current working directory
+				const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+				const hookScript = `#!/usr/bin/env node
+const input = require('fs').readFileSync(0, 'utf-8');
+// Output the current working directory
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "CWD: " + process.cwd()
+}))`
+
+				await writeHookScript(hookPath, hookScript)
+
+				// Test execution
+				const factory = new HookFactory()
+				const runner = await factory.create("PreToolUse")
+
+				const result = await runner.run({
+					taskId: "test-task",
+					preToolUse: {
+						toolName: "test_tool",
+						parameters: {},
+					},
+				})
+
+				result.cancel.should.be.false()
+				// The hook should execute from its workspace root (tempDir)
+				// Use fs.realpath to normalize paths (handles macOS /private prefix)
+				const cwdFromHook = result.contextModification?.replace("CWD: ", "")
+				const normalizedCwd = await fs.realpath(cwdFromHook)
+				const normalizedTempDir = await fs.realpath(tempDir)
+				normalizedCwd.should.equal(normalizedTempDir)
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it("should execute hook script and parse output", async () => {
+			// Create a test hook script
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+const input = require('fs').readFileSync(0, 'utf-8');
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TEST_CONTEXT: Added by hook"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			// Test execution
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("TEST_CONTEXT: Added by hook")
+		})
+
+		it("should handle script that blocks execution", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "Hook blocked execution"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.equal("Hook blocked execution")
+		})
+
+		it("should truncate large context modifications", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			// Create context larger than 50KB
+			const largeContext = "x".repeat(60000)
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "${largeContext}"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.contextModification?.length.should.be.lessThan(60000)
+			result.contextModification?.should.match(/truncated due to size limit/)
+		})
+
+		it("should handle script errors", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+process.exit(1)`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			try {
+				await runner.run({
+					taskId: "test-task",
+					preToolUse: {
+						toolName: "test_tool",
+						parameters: {},
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.match(/exited with code 1/)
+			}
+		})
+
+		it("should handle malformed JSON output", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+console.log("not valid json")`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			// When hook exits 0 but has malformed JSON, it returns success without context
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			// Hook succeeded (exit 0) but couldn't parse JSON, so returns success without context
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+
+		it("should pass hook input via stdin", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Received tool: " + input.preToolUse.toolName
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "my_test_tool",
+					parameters: {},
+				},
+			})
+
+			result.contextModification?.should.equal("Received tool: my_test_tool")
+		})
+	})
+
+	describe("PostToolUse Hook", () => {
+		it("should receive execution results", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PostToolUse")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Tool succeeded: " + input.postToolUse.success
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PostToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				postToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+					result: "success",
+					success: true,
+					executionTimeMs: 100,
+				},
+			})
+
+			result.contextModification?.should.equal("Tool succeeded: true")
+		})
+	})
+
+	describe("Hook Discovery", () => {
+		it("should generate Windows PowerShell bridge files with real newlines", async () => {
+			const hooksDir = path.join(tempDir, ".clinerules", "hooks")
+			const hookBasePath = path.join(hooksDir, "PreToolUse")
+
+			await withPlatform("win32", async () => {
+				await writeHookScript(hookBasePath, "#!/usr/bin/env node\nprocess.exit(0)")
+			})
+
+			const ps1Content = await fs.readFile(`${hookBasePath}.ps1`, "utf-8")
+			ps1Content.should.match(/\n\$scriptPath = Join-Path/)
+			ps1Content.should.not.match(/`n\$scriptPath/)
+		})
+
+		it("should resolve .ps1 hook on windows", async () => {
+			const hooksDir = path.join(tempDir, ".clinerules", "hooks")
+			const ps1Path = path.join(hooksDir, "PreToolUse.ps1")
+			await fs.writeFile(ps1Path, "Write-Output '{\"cancel\":false}'")
+
+			const found = await withPlatform("win32", async () => {
+				return await HookFactory.findHookInHooksDir("PreToolUse", hooksDir)
+			})
+
+			should.exist(found)
+			if (!found) {
+				throw new Error("Expected .ps1 hook to be resolved")
+			}
+			found.should.equal(ps1Path)
+		})
+
+		it("should ignore extensionless hook on windows and use .ps1 only", async () => {
+			const hooksDir = path.join(tempDir, ".clinerules", "hooks")
+			const extensionless = path.join(hooksDir, "PreToolUse")
+			const ps1Path = path.join(hooksDir, "PreToolUse.ps1")
+			await fs.writeFile(extensionless, "Write-Output '{\"cancel\":false}'")
+			await fs.writeFile(ps1Path, "Write-Output '{\"cancel\":false}'")
+
+			const found = await withPlatform("win32", async () => {
+				return await HookFactory.findHookInHooksDir("PreToolUse", hooksDir)
+			})
+
+			should.exist(found)
+			if (!found) {
+				throw new Error("Expected .ps1 hook to be resolved")
+			}
+			found.should.equal(ps1Path)
+		})
+
+		it("should ignore .ps1 hook on unix-like platforms", async () => {
+			const hooksDir = path.join(tempDir, ".clinerules", "hooks")
+			const ps1Path = path.join(hooksDir, "PreToolUse.ps1")
+			await fs.writeFile(ps1Path, "Write-Output '{\"cancel\":false}'")
+
+			const found = await withPlatform("linux", async () => {
+				return await HookFactory.findHookInHooksDir("PreToolUse", hooksDir)
+			})
+
+			should.not.exist(found)
+		})
+
+		it("should find executable hook", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({ cancel: false }))`
+
+			await fs.writeFile(hookPath, hookScript)
+			await fs.chmod(hookPath, 0o755)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			// Should find and execute the hook
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+
+		it("should not find non-executable file", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({ cancel: false }))`
+
+			// Write but don't make executable
+			await fs.writeFile(hookPath, hookScript)
+			// Explicitly remove executable permission
+			await fs.chmod(hookPath, 0o644)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			// Should return NoOpRunner
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			// NoOpRunner always returns success
+			result.cancel.should.be.false()
+		})
+
+		it("should handle missing hooks gracefully", async () => {
+			// No hook file created
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			// Should return NoOpRunner
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle expected ENOENT errors silently", async () => {
+			// No hook file exists - ENOENT is expected
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			// Should not throw, returns NoOpRunner
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+
+		it("should handle hook input with all parameters", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasConcreteModelContext = input.model?.provider === 'openai' && input.model?.slug === 'gpt-5';
+const hasAllFields = input.clineVersion && input.hookName && input.timestamp && 
+                     input.taskId && input.workspaceRoots !== undefined &&
+                     hasConcreteModelContext;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All fields present" : "Missing fields"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				model: {
+					provider: "openai",
+					slug: "gpt-5",
+				},
+				preToolUse: {
+					toolName: "test_tool",
+					parameters: { key: "value" },
+				},
+			})
+
+			result.contextModification?.should.equal("All fields present")
+		})
+	})
+
+	describe("Global Hooks", () => {
+		let globalHooksDir: string
+		let workspaceHooksDir: string
+
+		beforeEach(async () => {
+			// Create global hooks directory
+			globalHooksDir = path.join(tempDir, "global-hooks")
+			await fs.mkdir(globalHooksDir, { recursive: true })
+			workspaceHooksDir = path.join(tempDir, ".clinerules", "hooks")
+
+			// Mock getAllHooksDirs with deterministic test directories only.
+			// Avoid calling the real implementation, which may hit OS-specific
+			// filesystem resolution and add timing variance in CI.
+			stubHookDirs(sandbox, [globalHooksDir, workspaceHooksDir])
+		})
+
+		it("should execute both global and workspace hooks", async () => {
+			// Create global hook
+			const globalHookPath = path.join(globalHooksDir, "PreToolUse")
+			const globalHookScript = `#!/usr/bin/env node
+const input = require('fs').readFileSync(0, 'utf-8');
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "GLOBAL: Context added"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const workspaceHookScript = `#!/usr/bin/env node
+const input = require('fs').readFileSync(0, 'utf-8');
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "WORKSPACE: Context added"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			// Execute
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: { toolName: "test_tool", parameters: {} },
+			})
+
+			// Both contexts should be present (order not guaranteed)
+			result.cancel.should.be.false()
+			result.contextModification?.should.match(/GLOBAL: Context added/)
+			result.contextModification?.should.match(/WORKSPACE: Context added/)
+		})
+
+		it("should block execution if global hook blocks", async () => {
+			// Create blocking global hook
+			const globalHookPath = path.join(globalHooksDir, "PreToolUse")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "Global policy violation"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create allowing workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: { toolName: "test_tool", parameters: {} },
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.match(/Global policy violation/)
+		})
+
+		it("should work with only global hooks (no workspace hooks)", async () => {
+			// Create global hook only
+			const globalHookPath = path.join(globalHooksDir, "PreToolUse")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Global hook only"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: { toolName: "test_tool", parameters: {} },
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("Global hook only")
+		})
+
+		it("should block if workspace hook blocks even when global allows", async () => {
+			// Create allowing global hook
+			const globalHookPath = path.join(globalHooksDir, "PreToolUse")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Global allows"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create blocking workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "Workspace blocks"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: { toolName: "test_tool", parameters: {} },
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.match(/Workspace blocks/)
+			// Context from global should still be included
+			result.contextModification?.should.match(/Global allows/)
+		})
+
+		it("should combine error messages from global and workspace hooks", async () => {
+			// Create blocking global hook
+			const globalHookPath = path.join(globalHooksDir, "PreToolUse")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "Global error"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create blocking workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "PreToolUse")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "Workspace error"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PreToolUse")
+			const result = await runner.run({
+				taskId: "test-task",
+				preToolUse: { toolName: "test_tool", parameters: {} },
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.match(/Global error/)
+			result.errorMessage?.should.match(/Workspace error/)
+		})
+
+		it(
+			"should execute global hook from primary workspace root directory",
+			async () => {
+				if (process.platform === "win32") {
+				}
+
+				// Create a global hook script that outputs the current working directory
+				const globalHookPath = path.join(globalHooksDir, "PreToolUse")
+				const globalHookScript = `#!/usr/bin/env node
+const input = require('fs').readFileSync(0, 'utf-8');
+// Output the current working directory
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "CWD: " + process.cwd()
+}))`
+				await writeHookScript(globalHookPath, globalHookScript)
+
+				// Test execution
+				const factory = new HookFactory()
+				const runner = await factory.create("PreToolUse")
+
+				const result = await runner.run({
+					taskId: "test-task",
+					preToolUse: {
+						toolName: "test_tool",
+						parameters: {},
+					},
+				})
+
+				result.cancel.should.be.false()
+				// Global hooks should execute from the primary workspace root (tempDir)
+				// Use fs.realpath to normalize paths (handles macOS /private prefix)
+				const cwdFromHook = result.contextModification?.replace("CWD: ", "")
+				const normalizedCwd = await fs.realpath(cwdFromHook)
+				const normalizedTempDir = await fs.realpath(tempDir)
+				normalizedCwd.should.equal(normalizedTempDir)
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it("should work with global PostToolUse hooks", async () => {
+			// Create global PostToolUse hook
+			const globalHookPath = path.join(globalHooksDir, "PostToolUse")
+			const globalHookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Global observed: " + input.postToolUse.success
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("PostToolUse")
+			const result = await runner.run({
+				taskId: "test-task",
+				postToolUse: {
+					toolName: "test_tool",
+					parameters: {},
+					result: "success",
+					success: true,
+					executionTimeMs: 100,
+				},
+			})
+
+			result.contextModification?.should.equal("Global observed: true")
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/hookprocess.test.ts b/apps/vscode/src/core/hooks/__tests__/hookprocess.test.ts
new file mode 100644
index 0000000..024b862
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/hookprocess.test.ts
@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import { getHookLaunchConfig, resetHookLaunchConfigCacheForTesting } from "../HookProcess"
+import { withPlatform } from "./test-utils"
+
+function createDeferred<T>() {
+	let resolve!: (value: T | PromiseLike<T>) => void
+	let reject!: (reason?: unknown) => void
+	const promise = new Promise<T>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+
+	return { promise, resolve, reject }
+}
+
+describe("HookProcess", () => {
+	beforeEach(() => {
+		resetHookLaunchConfigCacheForTesting()
+	})
+
+	afterEach(() => {
+		resetHookLaunchConfigCacheForTesting()
+	})
+
+	it("uses resolved PowerShell executable and expected Windows launch args", async () => {
+		const resolvedExecutable = "C:\\Program Files\\PowerShell\\7\\pwsh.exe"
+
+		await withPlatform("win32", async () => {
+			const config = await getHookLaunchConfig(
+				"C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1",
+				async () => resolvedExecutable,
+			)
+
+			config.command.should.equal(resolvedExecutable)
+			config.args.should.deepEqual([
+				"-NoProfile",
+				"-NonInteractive",
+				"-ExecutionPolicy",
+				"Bypass",
+				"-File",
+				"C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1",
+			])
+			config.shell.should.equal(false)
+			config.detached.should.equal(false)
+		})
+	})
+
+	it("keeps Unix launch behavior unchanged", async () => {
+		await withPlatform("linux", async () => {
+			const config = await getHookLaunchConfig("/tmp/.clinerules/hooks/PreToolUse")
+			config.args.should.deepEqual([])
+			config.shell.should.equal(true)
+			config.detached.should.equal(true)
+		})
+	})
+
+	it("surfaces resolver failures", async () => {
+		await withPlatform("win32", async () => {
+			try {
+				await getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1", async () => {
+					throw new Error("resolver failed")
+				})
+				throw new Error("Expected getHookLaunchConfig to throw")
+			} catch (error: any) {
+				error.message.should.match(/resolver failed/)
+			}
+		})
+	})
+
+	it("uses PowerShell on Windows", async () => {
+		await withPlatform("win32", async () => {
+			const ps1Path = "C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1"
+			const resolvedExecutable = "C:\\Program Files\\PowerShell\\7\\pwsh.exe"
+
+			let resolverCallCount = 0
+
+			const config = await getHookLaunchConfig(ps1Path, async () => {
+				resolverCallCount += 1
+				return resolvedExecutable
+			})
+
+			config.command.should.equal(resolvedExecutable)
+			config.args.should.deepEqual(["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", ps1Path])
+			resolverCallCount.should.equal(1)
+		})
+	})
+
+	it("coalesces concurrent Windows launcher resolution into a single in-flight resolver call", async () => {
+		await withPlatform("win32", async () => {
+			const resolvedExecutable = "C:\\Program Files\\PowerShell\\7\\pwsh.exe"
+			const resolverGate = createDeferred<void>()
+			let resolverCallCount = 0
+
+			const resolver = async () => {
+				resolverCallCount += 1
+				await resolverGate.promise
+				return resolvedExecutable
+			}
+
+			const launchRequests = [
+				getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1", resolver),
+				getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\PostToolUse.ps1", resolver),
+				getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\TaskResume.ps1", resolver),
+			]
+
+			await Promise.resolve()
+			resolverCallCount.should.equal(1)
+
+			resolverGate.resolve()
+
+			const configs = await Promise.all(launchRequests)
+
+			resolverCallCount.should.equal(1)
+			configs.map((config) => config.command).should.deepEqual([resolvedExecutable, resolvedExecutable, resolvedExecutable])
+			configs.map((config) => config.shell).should.deepEqual([false, false, false])
+		})
+	})
+
+	it("clears failed launcher cache so later calls can recover", async () => {
+		await withPlatform("win32", async () => {
+			let resolverCallCount = 0
+
+			const flakyResolver = async () => {
+				resolverCallCount += 1
+				if (resolverCallCount === 1) {
+					throw new Error("initial resolver failure")
+				}
+				return "C:\\Program Files\\PowerShell\\7\\pwsh.exe"
+			}
+
+			try {
+				await getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1", flakyResolver)
+				throw new Error("Expected first call to fail")
+			} catch (error: any) {
+				error.message.should.match(/initial resolver failure/)
+			}
+
+			const recoveredConfig = await getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1", flakyResolver)
+
+			recoveredConfig.command.should.equal("C:\\Program Files\\PowerShell\\7\\pwsh.exe")
+			resolverCallCount.should.equal(2)
+		})
+	})
+
+	it("refreshes cached Windows launcher resolution after cache TTL expires", async () => {
+		await withPlatform("win32", async () => {
+			const originalDateNow = Date.now
+			const fakeNowValues = [1_000, 301_005]
+			Date.now = () => fakeNowValues.shift() ?? 301_006
+
+			let resolverCallCount = 0
+			const resolvedExecutables = [
+				"C:\\Program Files\\PowerShell\\7\\pwsh.exe",
+				"C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+			]
+
+			try {
+				const firstConfig = await getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\PreToolUse.ps1", async () => {
+					resolverCallCount += 1
+					return resolvedExecutables.shift() || "unexpected"
+				})
+
+				const secondConfig = await getHookLaunchConfig("C:\\workspace\\.clinerules\\hooks\\TaskResume.ps1", async () => {
+					resolverCallCount += 1
+					return resolvedExecutables.shift() || "unexpected"
+				})
+
+				firstConfig.command.should.equal("C:\\Program Files\\PowerShell\\7\\pwsh.exe")
+				secondConfig.command.should.equal("C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe")
+				resolverCallCount.should.equal(2)
+			} finally {
+				Date.now = originalDateNow
+			}
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/hooks-utils.test.ts b/apps/vscode/src/core/hooks/__tests__/hooks-utils.test.ts
new file mode 100644
index 0000000..f579431
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/hooks-utils.test.ts
@@ -0,0 +1,35 @@
+import { describe, it } from "bun:test"
+import "should"
+import { getHooksEnabledSafe } from "../hooks-utils"
+import { withPlatform } from "./test-utils"
+
+describe("hooks-utils", () => {
+	describe("getHooksEnabledSafe", () => {
+		it("returns false when user setting is false", () => {
+			getHooksEnabledSafe(false).should.be.false()
+		})
+
+		it("returns true when user setting is true", () => {
+			getHooksEnabledSafe(true).should.be.true()
+		})
+
+		it("is stable across repeated calls", () => {
+			for (let i = 0; i < 5; i++) {
+				getHooksEnabledSafe(true).should.be.true()
+			}
+		})
+
+		it("returns true for undefined", () => {
+			getHooksEnabledSafe(undefined).should.be.true()
+		})
+
+		it("does not depend on process.platform in current implementation", async () => {
+			await withPlatform("win32", () => {
+				getHooksEnabledSafe(true).should.be.true()
+			})
+			await withPlatform("linux", () => {
+				getHooksEnabledSafe(true).should.be.true()
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/setup.ts b/apps/vscode/src/core/hooks/__tests__/setup.ts
new file mode 100644
index 0000000..1154b64
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/setup.ts
@@ -0,0 +1,117 @@
+import { afterEach, beforeEach } from "bun:test"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import sinon from "sinon"
+import { StateManager } from "../../storage/StateManager"
+import { createHooksDirectory } from "./test-utils"
+
+/**
+ * Test environment containing temp directories and cleanup functions.
+ */
+export interface HookTestEnvironment {
+	/** Temporary directory for this test */
+	tempDir: string
+	/** Array of hooks directories (.clinerules/hooks paths) */
+	hooksDirs: string[]
+	/** Cleanup function to remove temp directories */
+	cleanup: () => Promise<void>
+}
+
+/**
+ * Creates a fresh test environment with temp directories.
+ * Automatically creates .clinerules/hooks structure.
+ *
+ * @returns Test environment with cleanup function
+ *
+ * @example
+ * const env = await createHookTestEnvironment()
+ * // Use env.tempDir, env.hooksDirs in tests
+ * await env.cleanup() // Clean up after tests
+ */
+export async function createHookTestEnvironment(): Promise<HookTestEnvironment> {
+	const tempDir = path.join(os.tmpdir(), `hook-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+
+	await fs.mkdir(tempDir, { recursive: true })
+
+	const hooksDir = await createHooksDirectory(tempDir)
+
+	return {
+		tempDir,
+		hooksDirs: [hooksDir],
+		cleanup: async () => {
+			try {
+				await fs.rm(tempDir, { recursive: true, force: true })
+			} catch (error: any) {
+				// Only ignore ENOENT (already deleted), log other errors
+				if (error.code !== "ENOENT") {
+					console.warn(`Cleanup warning for ${tempDir}:`, error.message)
+				}
+			}
+		},
+	}
+}
+
+/**
+ * Standard setup for hook tests. Returns accessor to environment.
+ * Use in describe() blocks for automatic setup/teardown.
+ *
+ * @returns Object with getEnv() method to access test environment
+ *
+ * @example
+ * describe("My Hook Tests", () => {
+ *   const { getEnv } = setupHookTests()
+ *
+ *   it("should do something", async () => {
+ *     const env = getEnv()
+ *     // env.tempDir is ready to use
+ *   })
+ * })
+ */
+export function setupHookTests(): {
+	getEnv: () => HookTestEnvironment
+} {
+	let env: HookTestEnvironment
+	let sandbox: sinon.SinonSandbox
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+		env = await createHookTestEnvironment()
+
+		// Mock StateManager to return test workspace
+		mockStateManager(sandbox, [env.tempDir])
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+		await env.cleanup()
+	})
+
+	return {
+		getEnv: () => {
+			if (!env) {
+				throw new Error("Test environment not initialized. Called getEnv() outside of test?")
+			}
+			return env
+		},
+	}
+}
+
+/**
+ * Mocks StateManager to return test workspace roots.
+ * Useful for testing hook discovery across multiple workspace roots.
+ *
+ * @param sandbox Sinon sandbox for cleanup
+ * @param workspaceRoots Array of workspace root paths
+ *
+ * @example
+ * const sandbox = sinon.createSandbox()
+ * mockStateManager(sandbox, ["/path/to/workspace1", "/path/to/workspace2"])
+ * // StateManager.get().getGlobalStateKey("workspaceRoots") now returns mocked roots
+ * sandbox.restore() // Clean up after tests
+ */
+export function mockStateManager(sandbox: sinon.SinonSandbox, workspaceRoots: string[]): void {
+	sandbox.stub(StateManager, "get").returns({
+		getGlobalStateKey: () => workspaceRoots.map((rootPath) => ({ path: rootPath })),
+	} as any)
+}
diff --git a/apps/vscode/src/core/hooks/__tests__/shell-escape.test.ts b/apps/vscode/src/core/hooks/__tests__/shell-escape.test.ts
new file mode 100644
index 0000000..1f84038
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/shell-escape.test.ts
@@ -0,0 +1,285 @@
+import { afterAll, beforeAll, describe, it } from "bun:test"
+import "should"
+import { escapeShellPath } from "../shell-escape"
+
+describe("Shell Path Escaping", () => {
+	const originalPlatform = process.platform
+
+	// Helper to temporarily set platform
+	const setPlatform = (platform: NodeJS.Platform) => {
+		Object.defineProperty(process, "platform", {
+			value: platform,
+			writable: true,
+			configurable: true,
+		})
+	}
+
+	// Restore platform after tests
+	afterAll(() => {
+		Object.defineProperty(process, "platform", {
+			value: originalPlatform,
+			writable: true,
+			configurable: true,
+		})
+	})
+
+	describe("Unix/Linux/macOS path escaping", () => {
+		beforeAll(() => {
+			setPlatform("darwin") // macOS, but same escaping as Linux
+		})
+
+		it("should handle paths without special characters", () => {
+			const path = "/Users/user/Documents/Cline/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Documents/Cline/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with spaces", () => {
+			const path = "/Users/user/My Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/My Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with multiple spaces", () => {
+			const path = "/Users/user/My Test   Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/My Test   Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with single quotes", () => {
+			const path = "/Users/user/Test's Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			// Single quote is escaped as '\'' (close quote, escaped quote, open quote)
+			escaped.should.equal("'/Users/user/Test'\\''s Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with multiple single quotes", () => {
+			const path = "/Users/user/Test's Project's Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Test'\\''s Project'\\''s Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with double quotes", () => {
+			const path = '/Users/user/Test "Quoted" Project/Hooks/PreToolUse'
+			const escaped = escapeShellPath(path)
+			// Double quotes are safe inside single quotes
+			escaped.should.equal("'/Users/user/Test \"Quoted\" Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with special shell characters", () => {
+			const path = "/Users/user/Test$Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			// Special characters like $ are safe inside single quotes
+			escaped.should.equal("'/Users/user/Test$Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with backticks", () => {
+			const path = "/Users/user/Test`Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			// Backticks are safe inside single quotes
+			escaped.should.equal("'/Users/user/Test`Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with parentheses", () => {
+			const path = "/Users/user/Test (Project)/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Test (Project)/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with ampersands", () => {
+			const path = "/Users/user/Test & Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Test & Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with semicolons", () => {
+			const path = "/Users/user/Test;Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Test;Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with pipes", () => {
+			const path = "/Users/user/Test|Project/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Test|Project/Hooks/PreToolUse'")
+		})
+
+		it("should handle global hooks directory with spaces", () => {
+			const path = "/Users/user name/Documents/Cline/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user name/Documents/Cline/Hooks/PreToolUse'")
+		})
+
+		it("should handle workspace hooks with spaces in root", () => {
+			const path = "/Users/user/My Example Project/.clinerules/hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/My Example Project/.clinerules/hooks/PreToolUse'")
+		})
+
+		it("should handle paths with newlines (edge case)", () => {
+			const path = "/Users/user/Test\nProject/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			// Newlines are safe inside single quotes
+			escaped.should.equal("'/Users/user/Test\nProject/Hooks/PreToolUse'")
+		})
+
+		it("should handle paths with tabs", () => {
+			const path = "/Users/user/Test\tProject/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Test\tProject/Hooks/PreToolUse'")
+		})
+	})
+
+	describe("Windows path escaping", () => {
+		beforeAll(() => {
+			setPlatform("win32")
+		})
+
+		it("should handle paths without special characters", () => {
+			const path = "C:\\Users\\user\\Documents\\Cline\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user\\Documents\\Cline\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with spaces", () => {
+			const path = "C:\\Users\\user\\My Project\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user\\My Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with multiple spaces", () => {
+			const path = "C:\\Users\\user\\My Test   Project\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user\\My Test   Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with double quotes", () => {
+			const path = 'C:\\Users\\user\\Test "Quoted" Project\\Hooks\\PreToolUse'
+			const escaped = escapeShellPath(path)
+			// Double quotes are escaped by doubling them
+			escaped.should.equal('"C:\\Users\\user\\Test ""Quoted"" Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with backslashes before quotes", () => {
+			const path = 'C:\\Users\\user\\Test\\"Project\\Hooks\\PreToolUse'
+			const escaped = escapeShellPath(path)
+			// Backslash before quote needs to be doubled, then quote is doubled
+			escaped.should.equal('"C:\\Users\\user\\Test\\\\""Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with single quotes", () => {
+			const path = "C:\\Users\\user\\Test's Project\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			// Single quotes are safe inside double quotes on Windows
+			escaped.should.equal('"C:\\Users\\user\\Test\'s Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with special characters", () => {
+			const path = "C:\\Users\\user\\Test$Project\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			// Most special characters are safe inside double quotes on Windows
+			escaped.should.equal('"C:\\Users\\user\\Test$Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with parentheses", () => {
+			const path = "C:\\Users\\user\\Test (Project)\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user\\Test (Project)\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle paths with ampersands", () => {
+			const path = "C:\\Users\\user\\Test & Project\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user\\Test & Project\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle global hooks directory with spaces", () => {
+			const path = "C:\\Users\\user name\\Documents\\Cline\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user name\\Documents\\Cline\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle workspace hooks with spaces in root", () => {
+			const path = "C:\\Users\\user\\My Example Project\\.clinerules\\hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\user\\My Example Project\\.clinerules\\hooks\\PreToolUse"')
+		})
+
+		it("should handle UNC paths with spaces", () => {
+			const path = "\\\\server\\share\\My Project\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"\\\\server\\share\\My Project\\Hooks\\PreToolUse"')
+		})
+	})
+
+	describe("Real-world scenarios", () => {
+		it("should handle typical macOS global hooks path with space in username", () => {
+			setPlatform("darwin")
+			const path = "/Users/John Doe/Documents/Cline/Hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/John Doe/Documents/Cline/Hooks/PreToolUse'")
+		})
+
+		it("should handle typical Windows global hooks path with space in username", () => {
+			setPlatform("win32")
+			const path = "C:\\Users\\John Doe\\Documents\\Cline\\Hooks\\PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal('"C:\\Users\\John Doe\\Documents\\Cline\\Hooks\\PreToolUse"')
+		})
+
+		it("should handle workspace with company name and spaces", () => {
+			setPlatform("darwin")
+			const path = "/Users/user/Projects/ACME Corp Project/.clinerules/hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Projects/ACME Corp Project/.clinerules/hooks/PreToolUse'")
+		})
+
+		it("should handle workspace with version numbers and spaces", () => {
+			setPlatform("darwin")
+			const path = "/Users/user/Projects/My Project v2.0/.clinerules/hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Projects/My Project v2.0/.clinerules/hooks/PreToolUse'")
+		})
+
+		it("should handle workspace with mixed special characters", () => {
+			setPlatform("darwin")
+			const path = "/Users/user/Projects/Test's (New) Project v2.0/.clinerules/hooks/PreToolUse"
+			const escaped = escapeShellPath(path)
+			escaped.should.equal("'/Users/user/Projects/Test'\\''s (New) Project v2.0/.clinerules/hooks/PreToolUse'")
+		})
+	})
+
+	describe("Multi-root workspace scenarios", () => {
+		it("should handle multiple roots with spaces (macOS)", () => {
+			setPlatform("darwin")
+			const roots = [
+				"/Users/user/My Frontend Project/.clinerules/hooks/PreToolUse",
+				"/Users/user/My Backend Project/.clinerules/hooks/PreToolUse",
+				"/Users/user/Shared Utils/.clinerules/hooks/PreToolUse",
+			]
+
+			const escaped = roots.map(escapeShellPath)
+			escaped.should.deepEqual([
+				"'/Users/user/My Frontend Project/.clinerules/hooks/PreToolUse'",
+				"'/Users/user/My Backend Project/.clinerules/hooks/PreToolUse'",
+				"'/Users/user/Shared Utils/.clinerules/hooks/PreToolUse'",
+			])
+		})
+
+		it("should handle multiple roots with spaces (Windows)", () => {
+			setPlatform("win32")
+			const roots = [
+				"C:\\Users\\user\\My Frontend Project\\.clinerules\\hooks\\PreToolUse",
+				"C:\\Users\\user\\My Backend Project\\.clinerules\\hooks\\PreToolUse",
+				"C:\\Users\\user\\Shared Utils\\.clinerules\\hooks\\PreToolUse",
+			]
+
+			const escaped = roots.map(escapeShellPath)
+			escaped.should.deepEqual([
+				'"C:\\Users\\user\\My Frontend Project\\.clinerules\\hooks\\PreToolUse"',
+				'"C:\\Users\\user\\My Backend Project\\.clinerules\\hooks\\PreToolUse"',
+				'"C:\\Users\\user\\Shared Utils\\.clinerules\\hooks\\PreToolUse"',
+			])
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/taskcancel.test.ts b/apps/vscode/src/core/hooks/__tests__/taskcancel.test.ts
new file mode 100644
index 0000000..b6d5c48
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/taskcancel.test.ts
@@ -0,0 +1,581 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import path from "path"
+import sinon from "sinon"
+import { HookFactory } from "../hook-factory"
+import { createHookTestEnv, HookTestEnv, loadFixture, stubHookDirs, writeHookScriptForPlatform } from "./test-utils"
+
+describe("TaskCancel Hook", () => {
+	let tempDir: string
+	let sandbox: sinon.SinonSandbox
+	let getEnv: () => { tempDir: string }
+	let hookTestEnv: HookTestEnv
+
+	const writeHookScript = async (hookPath: string, nodeScript: string): Promise<void> => {
+		await writeHookScriptForPlatform(hookPath, nodeScript)
+	}
+
+	beforeEach(async () => {
+		hookTestEnv = await createHookTestEnv()
+		tempDir = hookTestEnv.tempDir
+		sandbox = hookTestEnv.sandbox
+
+		getEnv = () => ({ tempDir })
+	})
+
+	afterEach(async () => {
+		await hookTestEnv.cleanup()
+	})
+
+	describe("Hook Input Format", () => {
+		it("should receive task metadata with completionStatus", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const metadata = input.taskCancel.taskMetadata;
+const hasAllFields = metadata.taskId && metadata.ulid && metadata.completionStatus;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "Test passed" : "Missing metadata",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			// Note: contextModification is ignored for TaskCancel hooks
+		})
+
+		it("should handle 'abandoned' completion status", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const status = input.taskCancel.taskMetadata.completionStatus;
+// Verify we can read the status (for logging purposes)
+if (status !== "abandoned") {
+  process.exit(1);
+}
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "abandoned",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			// Note: contextModification is ignored for TaskCancel hooks
+		})
+
+		it("should receive all common hook input fields", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasAllFields = input.clineVersion && input.hookName === 'TaskCancel' && 
+                     input.timestamp && input.taskId && 
+                     input.workspaceRoots !== undefined &&
+                     input.model && input.model.provider && input.model.slug;
+// Exit with error if fields are missing (for test verification)
+if (!hasAllFields) {
+  process.exit(1);
+}
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			// Note: contextModification is ignored for TaskCancel hooks
+		})
+	})
+
+	describe("Fire-and-Forget Behavior", () => {
+		it("should ignore contextModification regardless of content", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "This is a context modification that should be ignored",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result1 = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			// Hook returns contextModification, but it's completely ignored (fire-and-forget)
+			result1.cancel.should.be.false()
+			result1.contextModification?.should.equal("This is a context modification that should be ignored")
+
+			// Update hook to return different contextModification
+			const hookScript2 = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Different context that is also ignored",
+  errorMessage: ""
+}))`
+			await writeHookScript(hookPath, hookScript2)
+
+			const result2 = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			// Both results behave identically - contextModification has no effect
+			result2.cancel.should.be.false()
+			result2.contextModification?.should.equal("Different context that is also ignored")
+			// The key point: both executions succeeded with cancel: false
+			// The contextModification value is different but behavior is identical (fire-and-forget)
+		})
+
+		it("should succeed regardless of hook return value", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+// Note: contextModification is ignored for TaskCancel hooks
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			// TaskCancel is fire-and-forget, so it always reports success
+			result.cancel.should.be.false()
+		})
+
+		it("should return error message when hook returns cancel: true", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Hook tried to block cancellation"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			// Hook result includes cancel: true and errorMessage
+			// In abortTask(), the errorMessage will be surfaced to the user via this.say("error", ...)
+			// but cancellation will still proceed (fire-and-forget behavior)
+			result.cancel.should.be.true()
+			result.errorMessage?.should.equal("Hook tried to block cancellation")
+		})
+
+		it("should execute without errors for cleanup purposes", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const status = input.taskCancel.taskMetadata.completionStatus;
+// Hook can perform cleanup/logging based on status
+// Note: contextModification is ignored for TaskCancel hooks
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should surface hook errors to the user", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+console.error("Hook execution error");
+process.exit(1);`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			// TaskCancel hook errors should throw (they will be caught and surfaced in abortTask)
+			try {
+				await runner.run({
+					taskId: "test-task-id",
+					taskCancel: {
+						taskMetadata: {
+							taskId: "test-task-id",
+							ulid: "test-ulid",
+							completionStatus: "cancelled",
+						},
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.match(/TaskCancel.*exited with code 1/)
+			}
+		})
+
+		it("should handle malformed JSON output from hook", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const hookScript = `#!/usr/bin/env node
+console.log("not valid json")`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			// When hook exits 0 but has malformed JSON, it returns success without context
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			// Hook succeeded (exit 0) but couldn't parse JSON, so returns success without context
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+	})
+
+	describe("Global and Workspace Hooks", () => {
+		let globalHooksDir: string
+		let workspaceHooksDir: string
+
+		beforeEach(async () => {
+			// Create global hooks directory
+			globalHooksDir = path.join(tempDir, "global-hooks")
+			await fs.mkdir(globalHooksDir, { recursive: true })
+			workspaceHooksDir = path.join(tempDir, ".clinerules", "hooks")
+
+			// Use deterministic hook directories to avoid test flakiness.
+			stubHookDirs(sandbox, [globalHooksDir, workspaceHooksDir])
+		})
+
+		it("should execute both global and workspace TaskCancel hooks", async () => {
+			// Create global hook
+			const globalHookPath = path.join(globalHooksDir, "TaskCancel")
+			const globalHookScript = `#!/usr/bin/env node
+// Note: contextModification is ignored for TaskCancel hooks
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const workspaceHookScript = `#!/usr/bin/env node
+// Note: contextModification is ignored for TaskCancel hooks
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			// Both hooks executed successfully
+		})
+
+		it("should execute both hooks with different completion statuses", async () => {
+			const globalHookPath = path.join(globalHooksDir, "TaskCancel")
+			const globalHookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+// Can perform cleanup based on completion status
+// Note: contextModification is ignored for TaskCancel hooks
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskCancel")
+			const workspaceHookScript = `#!/usr/bin/env node
+// Note: contextModification is ignored for TaskCancel hooks
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "",
+  errorMessage: ""
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "abandoned",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			// Both hooks executed successfully
+		})
+	})
+
+	describe("No Hook Behavior", () => {
+		it("should succeed when no hook exists", async () => {
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Fixture-Based Tests", () => {
+		it("should handle cancel: true with no error message", async () => {
+			await loadFixture("hooks/taskcancel/false-no-error", getEnv().tempDir)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.equal("")
+			// In abortTask(), no error is surfaced since errorMessage is empty
+			// Cancellation still proceeds (fire-and-forget)
+		})
+
+		it("should handle cancel: true with error message", async () => {
+			await loadFixture("hooks/taskcancel/false-with-error", getEnv().tempDir)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.equal("some error happened")
+			// In abortTask(), the errorMessage WILL be surfaced to user via this.say("error", ...)
+			// Cancellation still proceeds (fire-and-forget)
+		})
+
+		it("should handle cancel: false with no error message", async () => {
+			await loadFixture("hooks/taskcancel/true-no-error", getEnv().tempDir)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.errorMessage?.should.equal("")
+			// Normal success case - no errors to surface
+		})
+
+		it("should handle cancel: false with error message", async () => {
+			await loadFixture("hooks/taskcancel/true-with-error", getEnv().tempDir)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskCancel: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						completionStatus: "cancelled",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.errorMessage?.should.equal("some error happened")
+			// In abortTask(), the errorMessage WILL be surfaced to user via this.say("error", ...)
+			// This is the scenario that was fixed - error messages are now displayed regardless of shouldContinue value
+			// Cancellation still proceeds (fire-and-forget)
+		})
+
+		it("should handle hook that exits with non-zero status code", async () => {
+			await loadFixture("hooks/taskcancel/error", getEnv().tempDir)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskCancel")
+
+			try {
+				await runner.run({
+					taskId: "test-task-id",
+					taskCancel: {
+						taskMetadata: {
+							taskId: "test-task-id",
+							ulid: "test-ulid",
+							completionStatus: "cancelled",
+						},
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.match(/TaskCancel.*exited with code 1/)
+				// In abortTask(), this error WILL be caught and surfaced to user via this.say("error", ...)
+				// Cancellation still proceeds (fire-and-forget)
+			}
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/taskcomplete.test.ts b/apps/vscode/src/core/hooks/__tests__/taskcomplete.test.ts
new file mode 100644
index 0000000..d2d8aee
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/taskcomplete.test.ts
@@ -0,0 +1,506 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import path from "path"
+import sinon from "sinon"
+import { HookOutput } from "../../../shared/proto/cline/hooks"
+import { HookFactory } from "../hook-factory"
+import { createHookTestEnv, HookTestEnv, stubHookDirs, withFixtureRunner, writeHookScriptForPlatform } from "./test-utils"
+
+describe("TaskComplete Hook", () => {
+	let tempDir: string
+	let sandbox: sinon.SinonSandbox
+	let getEnv: () => { tempDir: string }
+	let hookTestEnv: HookTestEnv
+	const getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+	const writeHookScript = async (hookPath: string, nodeScript: string): Promise<void> => {
+		await writeHookScriptForPlatform(hookPath, nodeScript)
+	}
+
+	beforeEach(async () => {
+		hookTestEnv = await createHookTestEnv()
+		tempDir = hookTestEnv.tempDir
+		sandbox = hookTestEnv.sandbox
+
+		getEnv = () => ({ tempDir })
+	})
+
+	afterEach(async () => {
+		await hookTestEnv.cleanup()
+	})
+
+	describe("Hook Input Format", () => {
+		it("should receive task metadata with result and command", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const metadata = input.taskComplete.taskMetadata;
+const hasAllFields = metadata.taskId && metadata.ulid && metadata.result;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All metadata present" : "Missing metadata",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Task completed successfully",
+						command: "npm start",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("All metadata present")
+		})
+
+		it("should handle completion without command", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const metadata = input.taskComplete.taskMetadata;
+const command = metadata.command || "";
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Command: '" + command + "'",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Task completed",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("Command: ''")
+		})
+
+		it("should receive all common hook input fields", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasAllFields = input.clineVersion && input.hookName === 'TaskComplete' && 
+                     input.timestamp && input.taskId && 
+                     input.workspaceRoots !== undefined &&
+                     input.model && input.model.provider && input.model.slug;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All fields present" : "Missing fields",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Test task",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("All fields present")
+		})
+
+		it("should receive result text for logging", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const result = input.taskComplete.taskMetadata.result;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Result length: " + result.length,
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "I've successfully completed the task by implementing all required features.",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("Result length: 75")
+		})
+	})
+
+	describe("Hook Behavior", () => {
+		it("should execute successfully and capture context modification", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TaskComplete hook executed successfully",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Test task",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("TaskComplete hook executed successfully")
+		})
+
+		it("should capture contextModification for logging even though task is complete", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TASK_COMPLETE: Task '" + input.taskComplete.taskMetadata.taskId + "' finished",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Build a todo app",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("TASK_COMPLETE: Task 'test-task-id' finished")
+		})
+
+		it("should not block task completion when hook returns cancel: true", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Hook tried to block completion"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Test task",
+						command: "",
+					},
+				},
+			})
+
+			// Hook can return cancel: true, but it's ignored (task is already complete)
+			// This is similar to TaskCancel behavior
+			result.cancel.should.be.true()
+			result.errorMessage?.should.equal("Hook tried to block completion")
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle hook script errors", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+console.error("Hook execution error");
+process.exit(1);`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			try {
+				await runner.run({
+					taskId: "test-task-id",
+					taskComplete: {
+						taskMetadata: {
+							taskId: "test-task-id",
+							ulid: "test-ulid",
+							result: "Test task",
+							command: "",
+						},
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.match(/TaskComplete.*exited with code 1/)
+			}
+		})
+
+		it("should handle malformed JSON output from hook", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const hookScript = `#!/usr/bin/env node
+console.log("not valid json")`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			// When hook exits 0 but has malformed JSON, it returns success without context
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Test task",
+						command: "",
+					},
+				},
+			})
+
+			// Hook succeeded (exit 0) but couldn't parse JSON, so returns success without context
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+	})
+
+	describe("Global and Workspace Hooks", () => {
+		let globalHooksDir: string
+		let workspaceHooksDir: string
+
+		beforeEach(async () => {
+			// Create global hooks directory
+			globalHooksDir = path.join(tempDir, "global-hooks")
+			await fs.mkdir(globalHooksDir, { recursive: true })
+			workspaceHooksDir = path.join(tempDir, ".clinerules", "hooks")
+
+			// Use deterministic hook directories to avoid test flakiness.
+			stubHookDirs(sandbox, [globalHooksDir, workspaceHooksDir])
+		})
+
+		it("should execute both global and workspace TaskComplete hooks", async () => {
+			// Create global hook
+			const globalHookPath = path.join(globalHooksDir, "TaskComplete")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "GLOBAL: Task complete",
+  errorMessage: ""
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "WORKSPACE: Task complete",
+  errorMessage: ""
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Test task",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.match(/GLOBAL: Task complete/)
+			result.contextModification?.should.match(/WORKSPACE: Task complete/)
+		})
+
+		it("should handle when global hook has error but workspace succeeds", async () => {
+			const globalHookPath = path.join(globalHooksDir, "TaskComplete")
+			const globalHookScript = `#!/usr/bin/env node
+console.error("Global hook error");
+process.exit(1);`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskComplete")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Workspace succeeded",
+  errorMessage: ""
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			// Both hooks run in parallel, if one fails the whole thing fails
+			try {
+				await runner.run({
+					taskId: "test-task-id",
+					taskComplete: {
+						taskMetadata: {
+							taskId: "test-task-id",
+							ulid: "test-ulid",
+							result: "Test task",
+							command: "",
+						},
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.match(/TaskComplete.*exited with code 1/)
+			}
+		})
+	})
+
+	describe("No Hook Behavior", () => {
+		it("should succeed when no hook exists", async () => {
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskComplete")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskComplete: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						result: "Test task",
+						command: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Fixture-Based Tests", () => {
+		it("should validate representative fixtures end-to-end", async () => {
+			const scenarios: Array<{
+				fixtureName: string
+				resultText: string
+				assert: (result: HookOutput) => void
+			}> = [
+				{
+					fixtureName: "success",
+					resultText: "Test task",
+					assert: (result: HookOutput) => {
+						result.cancel.should.be.false()
+						result.contextModification?.should.equal("TaskComplete hook executed successfully")
+					},
+				},
+				{
+					fixtureName: "context-injection",
+					resultText: "Build a todo app",
+					assert: (result: HookOutput) => {
+						result.cancel.should.be.false()
+						result.contextModification?.should.equal("COMPLETED: Build a todo app")
+					},
+				},
+			]
+
+			for (const scenario of scenarios) {
+				await withFixtureRunner(
+					"TaskComplete",
+					`hooks/taskcomplete/${scenario.fixtureName}`,
+					hookTestEnv,
+					async (runner) => {
+						const result = await runner.run({
+							taskId: "test-task-id",
+							taskComplete: {
+								taskMetadata: {
+									taskId: "test-task-id",
+									ulid: "test-ulid",
+									result: scenario.resultText,
+									command: "",
+								},
+							},
+						})
+
+						scenario.assert(result)
+					},
+				)
+			}
+		})
+
+		it("should preserve fixture-based failure behavior", async () => {
+			await withFixtureRunner("TaskComplete", "hooks/taskcomplete/error", hookTestEnv, async (runner) => {
+				try {
+					await runner.run({
+						taskId: "test-task-id",
+						taskComplete: {
+							taskMetadata: {
+								taskId: "test-task-id",
+								ulid: "test-ulid",
+								result: "Test task",
+								command: "",
+							},
+						},
+					})
+					throw new Error("Should have thrown")
+				} catch (error: unknown) {
+					getErrorMessage(error).should.match(/TaskComplete.*exited with code 1/)
+				}
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/taskresume.test.ts b/apps/vscode/src/core/hooks/__tests__/taskresume.test.ts
new file mode 100644
index 0000000..444bb0b
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/taskresume.test.ts
@@ -0,0 +1,681 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import path from "path"
+import sinon from "sinon"
+import { HookOutput } from "../../../shared/proto/cline/hooks"
+import { HookFactory } from "../hook-factory"
+import { createHookTestEnv, HookTestEnv, stubHookDirs, withFixtureRunner, writeHookScriptForPlatform } from "./test-utils"
+
+describe("TaskResume Hook", () => {
+	let tempDir: string
+	let sandbox: sinon.SinonSandbox
+	let hookTestEnv: HookTestEnv
+	const WINDOWS_HOOK_TEST_TIMEOUT_MS = 15000
+
+	type FixtureScenario = {
+		fixtureName: string
+		lastMessageTs: string
+		messageCount: string
+		conversationHistoryDeleted: string
+		assert: (result: HookOutput) => void
+	}
+
+	const getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+	const writeHookScript = async (hookPath: string, nodeScript: string): Promise<void> => {
+		await writeHookScriptForPlatform(hookPath, nodeScript)
+	}
+
+	beforeEach(async () => {
+		hookTestEnv = await createHookTestEnv()
+		tempDir = hookTestEnv.tempDir
+		sandbox = hookTestEnv.sandbox
+	})
+
+	afterEach(async () => {
+		await hookTestEnv.cleanup()
+	})
+
+	describe("Hook Input Format", () => {
+		it("should receive all required taskResume fields", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasRequiredFields = 
+  input.taskResume && 
+  input.taskResume.taskMetadata &&
+  input.taskResume.previousState &&
+  typeof input.taskResume.taskMetadata.taskId === 'string' &&
+  typeof input.taskResume.previousState.messageCount === 'string';
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasRequiredFields ? "All fields present" : "Missing fields"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: {
+						taskId: "test-task",
+						ulid: "test-ulid",
+					},
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("All fields present")
+		})
+
+		it("should receive all common hook input fields", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasAllFields = input.clineVersion && input.hookName && input.timestamp && 
+                     input.taskId && input.workspaceRoots !== undefined &&
+                     input.model && input.model.provider && input.model.slug;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All fields present" : "Missing fields"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.contextModification?.should.equal("All fields present")
+		})
+	})
+
+	describe("Time-Based Calculations", () => {
+		it(
+			"should correctly calculate minutes ago for recent resumes",
+			async () => {
+				if (process.platform === "win32") {
+				}
+
+				const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+				const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastTs = parseInt(input.taskResume.previousState.lastMessageTs);
+const now = Date.now();
+const minutesAgo = Math.floor((now - lastTs) / 60000);
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Minutes ago: " + minutesAgo
+}))`
+
+				await writeHookScript(hookPath, hookScript)
+
+				const factory = new HookFactory()
+				const runner = await factory.create("TaskResume")
+
+				// Test various time intervals
+				const testCases = [
+					{ offset: 2 * 60 * 1000, expected: 2 }, // 2 minutes
+					{ offset: 30 * 60 * 1000, expected: 30 }, // 30 minutes
+					{ offset: 90 * 60 * 1000, expected: 90 }, // 90 minutes
+				]
+
+				for (const { offset, expected } of testCases) {
+					const timestamp = Date.now() - offset
+					const result = await runner.run({
+						taskId: "test-task",
+						taskResume: {
+							taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+							previousState: {
+								lastMessageTs: timestamp.toString(),
+								messageCount: "5",
+								conversationHistoryDeleted: "false",
+							},
+						},
+					})
+
+					result.contextModification?.should.equal(`Minutes ago: ${expected}`)
+				}
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it(
+			"should handle very old timestamps (days ago)",
+			async () => {
+				if (process.platform === "win32") {
+				}
+
+				const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+				const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastTs = parseInt(input.taskResume.previousState.lastMessageTs);
+const now = Date.now();
+const daysAgo = Math.floor((now - lastTs) / (24 * 60 * 60 * 1000));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: daysAgo > 0 ? "Days ago: " + daysAgo : "Recent"
+}))`
+
+				await writeHookScript(hookPath, hookScript)
+
+				const factory = new HookFactory()
+				const runner = await factory.create("TaskResume")
+
+				// Test 7 days ago
+				const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000
+				const result = await runner.run({
+					taskId: "test-task",
+					taskResume: {
+						taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+						previousState: {
+							lastMessageTs: sevenDaysAgo.toString(),
+							messageCount: "5",
+							conversationHistoryDeleted: "false",
+						},
+					},
+				})
+
+				result.contextModification?.should.equal("Days ago: 7")
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it("should handle edge case: future timestamp", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastTs = parseInt(input.taskResume.previousState.lastMessageTs);
+const now = Date.now();
+const isFuture = lastTs > now;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: isFuture ? "Future timestamp detected" : "Normal timestamp"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const futureTimestamp = Date.now() + 60 * 60 * 1000 // 1 hour in future
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: futureTimestamp.toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.contextModification?.should.equal("Future timestamp detected")
+		})
+	})
+
+	describe("Message Count Analysis", () => {
+		it(
+			"should analyze message count thresholds",
+			async () => {
+				if (process.platform === "win32") {
+				}
+
+				const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+				const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const count = parseInt(input.taskResume.previousState.messageCount);
+let category;
+if (count < 5) category = "short";
+else if (count < 20) category = "medium";
+else category = "long";
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Conversation length: " + category + " (" + count + " messages)"
+}))`
+
+				await writeHookScript(hookPath, hookScript)
+
+				const factory = new HookFactory()
+				const runner = await factory.create("TaskResume")
+
+				const testCases = [
+					{ count: "2", expected: "short (2 messages)" },
+					{ count: "10", expected: "medium (10 messages)" },
+					{ count: "50", expected: "long (50 messages)" },
+				]
+
+				for (const { count, expected } of testCases) {
+					const result = await runner.run({
+						taskId: "test-task",
+						taskResume: {
+							taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+							previousState: {
+								lastMessageTs: Date.now().toString(),
+								messageCount: count,
+								conversationHistoryDeleted: "false",
+							},
+						},
+					})
+
+					result.contextModification?.should.equal(`Conversation length: ${expected}`)
+				}
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it("should handle zero message count", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const count = parseInt(input.taskResume.previousState.messageCount);
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: count === 0 ? "Empty conversation" : "Has messages"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "0",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.contextModification?.should.equal("Empty conversation")
+		})
+	})
+
+	describe("State Combination Analysis", () => {
+		it("should analyze combination of long pause and many messages", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastTs = parseInt(input.taskResume.previousState.lastMessageTs);
+const count = parseInt(input.taskResume.previousState.messageCount);
+const hoursAgo = Math.floor((Date.now() - lastTs) / (60 * 60 * 1000));
+const isStale = hoursAgo > 24 && count > 20;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: isStale ? "STALE_TASK: Long conversation paused for extended time" : "Active task"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const oneDayAgo = Date.now() - 25 * 60 * 60 * 1000
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: oneDayAgo.toString(),
+						messageCount: "30",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.contextModification?.should.equal("STALE_TASK: Long conversation paused for extended time")
+		})
+
+		it("should combine context deletion with other state", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const deleted = input.taskResume.previousState.conversationHistoryDeleted === 'true';
+const count = parseInt(input.taskResume.previousState.messageCount);
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: deleted && count > 10 
+    ? "CONTEXT_WARNING: Large conversation with truncated history" 
+    : "Normal state"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "25",
+						conversationHistoryDeleted: "true",
+					},
+				},
+			})
+
+			result.contextModification?.should.equal("CONTEXT_WARNING: Large conversation with truncated history")
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle malformed JSON output", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+console.log("not valid json")`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			// When hook exits 0 but has malformed JSON, it returns success without context
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			// Hook succeeded (exit 0) but couldn't parse JSON, so returns success without context
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+
+		it("should handle invalid timestamp gracefully", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastTs = parseInt(input.taskResume.previousState.lastMessageTs);
+const isValid = !isNaN(lastTs) && lastTs > 0;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: isValid ? "Valid timestamp" : "Invalid timestamp"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: "invalid",
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.contextModification?.should.equal("Invalid timestamp")
+		})
+	})
+
+	describe("Global and Workspace Hooks", () => {
+		let globalHooksDir: string
+		let workspaceHooksDir: string
+
+		beforeEach(async () => {
+			globalHooksDir = path.join(tempDir, "global-hooks")
+			await fs.mkdir(globalHooksDir, { recursive: true })
+			workspaceHooksDir = path.join(tempDir, ".clinerules", "hooks")
+
+			stubHookDirs(sandbox, [globalHooksDir, workspaceHooksDir])
+		})
+
+		it("should execute both global and workspace TaskResume hooks", async () => {
+			const globalHookPath = path.join(globalHooksDir, "TaskResume")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "GLOBAL: Task resumed"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "WORKSPACE: Task resumed"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.match(/GLOBAL: Task resumed/)
+			result.contextModification?.should.match(/WORKSPACE: Task resumed/)
+		})
+
+		it("should combine context modifications from both hooks with time analysis", async () => {
+			const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000
+
+			const globalHookPath = path.join(globalHooksDir, "TaskResume")
+			const globalHookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lastTs = parseInt(input.taskResume.previousState.lastMessageTs);
+const daysAgo = Math.floor((Date.now() - lastTs) / (24 * 60 * 60 * 1000));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "GLOBAL_POLICY: " + (daysAgo > 0 ? "Review task context" : "Continue")
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskResume")
+			const workspaceHookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const count = parseInt(input.taskResume.previousState.messageCount);
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "PROJECT_NOTE: " + count + " messages in history"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: oneDayAgo.toString(),
+						messageCount: "15",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.contextModification?.should.match(/GLOBAL_POLICY: Review task context/)
+			result.contextModification?.should.match(/PROJECT_NOTE: 15 messages in history/)
+		})
+	})
+
+	describe("No Hook Behavior", () => {
+		it("should allow resume when no hook exists", async () => {
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskResume")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				taskResume: {
+					taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+					previousState: {
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Fixture-Based Tests", () => {
+		it(
+			"should validate representative fixtures end-to-end",
+			async () => {
+				// Multiple fixture scenarios spawn child processes sequentially,
+				// which can easily exceed the default 2 s Mocha timeout.
+				const scenarios: FixtureScenario[] = [
+					{
+						fixtureName: "success",
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("TaskResume hook executed successfully")
+						},
+					},
+					{
+						fixtureName: "recent-resume",
+						lastMessageTs: (Date.now() - 2 * 60 * 1000).toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.match(/Recently paused task/)
+						},
+					},
+					{
+						fixtureName: "long-pause",
+						lastMessageTs: (Date.now() - 48 * 60 * 60 * 1000).toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.match(/paused 48 hours ago/)
+						},
+					},
+					{
+						fixtureName: "context-deleted",
+						lastMessageTs: Date.now().toString(),
+						messageCount: "50",
+						conversationHistoryDeleted: "true",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.match(/truncated/)
+						},
+					},
+					{
+						fixtureName: "message-count",
+						lastMessageTs: Date.now().toString(),
+						messageCount: "25",
+						conversationHistoryDeleted: "false",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("TASK_CONTEXT: Resuming task with 25 previous messages")
+						},
+					},
+					{
+						fixtureName: "context-injection",
+						lastMessageTs: Date.now().toString(),
+						messageCount: "5",
+						conversationHistoryDeleted: "false",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal(
+								"WORKSPACE_RULES: Task test-task resumed - review previous context",
+							)
+						},
+					},
+				]
+
+				for (const scenario of scenarios) {
+					await withFixtureRunner(
+						"TaskResume",
+						`hooks/taskresume/${scenario.fixtureName}`,
+						hookTestEnv,
+						async (runner) => {
+							const result = await runner.run({
+								taskId: "test-task",
+								taskResume: {
+									taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+									previousState: {
+										lastMessageTs: scenario.lastMessageTs,
+										messageCount: scenario.messageCount,
+										conversationHistoryDeleted: scenario.conversationHistoryDeleted,
+									},
+								},
+							})
+
+							scenario.assert(result)
+						},
+					)
+				}
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it("should preserve fixture-based failure behavior", async () => {
+			await withFixtureRunner("TaskResume", "hooks/taskresume/error", hookTestEnv, async (runner) => {
+				try {
+					await runner.run({
+						taskId: "test-task",
+						taskResume: {
+							taskMetadata: { taskId: "test-task", ulid: "test-ulid" },
+							previousState: {
+								lastMessageTs: Date.now().toString(),
+								messageCount: "5",
+								conversationHistoryDeleted: "false",
+							},
+						},
+					})
+					throw new Error("Should have thrown")
+				} catch (error: unknown) {
+					getErrorMessage(error).should.match(/exited with code 1/)
+				}
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/taskstart.test.ts b/apps/vscode/src/core/hooks/__tests__/taskstart.test.ts
new file mode 100644
index 0000000..e0ae516
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/taskstart.test.ts
@@ -0,0 +1,482 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import path from "path"
+import sinon from "sinon"
+import { HookOutput } from "../../../shared/proto/cline/hooks"
+import { HookFactory } from "../hook-factory"
+import { createHookTestEnv, HookTestEnv, stubHookDirs, withFixtureRunner, writeHookScriptForPlatform } from "./test-utils"
+
+describe("TaskStart Hook", () => {
+	let tempDir: string
+	let sandbox: sinon.SinonSandbox
+	let getEnv: () => { tempDir: string }
+	let hookTestEnv: HookTestEnv
+	const getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+	const writeHookScript = async (hookPath: string, nodeScript: string): Promise<void> => {
+		await writeHookScriptForPlatform(hookPath, nodeScript)
+	}
+
+	beforeEach(async () => {
+		hookTestEnv = await createHookTestEnv()
+		tempDir = hookTestEnv.tempDir
+		sandbox = hookTestEnv.sandbox
+
+		getEnv = () => ({ tempDir })
+	})
+
+	afterEach(async () => {
+		await hookTestEnv.cleanup()
+	})
+
+	describe("Hook Input Format", () => {
+		it("should receive task metadata from startTask", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const metadata = input.taskStart.taskMetadata;
+const hasAllFields = metadata.taskId && metadata.ulid && 'initialTask' in metadata;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All metadata present" : "Missing metadata",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Build a todo app",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("All metadata present")
+		})
+
+		it("should receive all common hook input fields", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasAllFields = input.clineVersion && input.hookName === 'TaskStart' && 
+                     input.timestamp && input.taskId && 
+                     input.workspaceRoots !== undefined &&
+                     input.model && input.model.provider && input.model.slug;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All fields present" : "Missing fields",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("All fields present")
+		})
+
+		it("should handle empty initialTask", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const initialTask = input.taskStart.taskMetadata.initialTask;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Task length: " + initialTask.length,
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("Task length: 0")
+		})
+	})
+
+	describe("Hook Behavior", () => {
+		it("should allow task to start when hook returns cancel: false", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TaskStart hook executed successfully",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("TaskStart hook executed successfully")
+		})
+
+		it("should block task when hook returns cancel: true", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Task execution blocked by hook"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.equal("Task execution blocked by hook")
+		})
+
+		it("should provide context modification even when not added to conversation", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "TASK_START: Task '" + input.taskStart.taskMetadata.initialTask + "' beginning",
+  errorMessage: ""
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Build a todo app",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("TASK_START: Task 'Build a todo app' beginning")
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle hook script errors", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+console.error("Hook execution error");
+process.exit(1);`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			try {
+				await runner.run({
+					taskId: "test-task-id",
+					taskStart: {
+						taskMetadata: {
+							taskId: "test-task-id",
+							ulid: "test-ulid",
+							initialTask: "Test task",
+						},
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.match(/TaskStart.*exited with code 1/)
+			}
+		})
+
+		it("should handle malformed JSON output from hook", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const hookScript = `#!/usr/bin/env node
+console.log("not valid json")`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			// When hook exits 0 but has malformed JSON, it returns success without context
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			// Hook succeeded (exit 0) but couldn't parse JSON, so returns success without context
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+	})
+
+	describe("Global and Workspace Hooks", () => {
+		let globalHooksDir: string
+		let workspaceHooksDir: string
+
+		beforeEach(async () => {
+			// Create global hooks directory
+			globalHooksDir = path.join(tempDir, "global-hooks")
+			await fs.mkdir(globalHooksDir, { recursive: true })
+			workspaceHooksDir = path.join(tempDir, ".clinerules", "hooks")
+
+			// Use deterministic hook directories to avoid test flakiness.
+			stubHookDirs(sandbox, [globalHooksDir, workspaceHooksDir])
+		})
+
+		it("should execute both global and workspace TaskStart hooks", async () => {
+			// Create global hook
+			const globalHookPath = path.join(globalHooksDir, "TaskStart")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "GLOBAL: Task starting",
+  errorMessage: ""
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "WORKSPACE: Task starting",
+  errorMessage: ""
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.match(/GLOBAL: Task starting/)
+			result.contextModification?.should.match(/WORKSPACE: Task starting/)
+		})
+
+		it("should block if global hook blocks", async () => {
+			const globalHookPath = path.join(globalHooksDir, "TaskStart")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Global policy blocks this task"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Workspace allows",
+  errorMessage: ""
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.match(/Global policy blocks this task/)
+		})
+
+		it("should block if workspace hook blocks even when global allows", async () => {
+			const globalHookPath = path.join(globalHooksDir, "TaskStart")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Global allows",
+  errorMessage: ""
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "TaskStart")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  contextModification: "",
+  errorMessage: "Workspace blocks"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.match(/Workspace blocks/)
+		})
+	})
+
+	describe("No Hook Behavior", () => {
+		it("should allow task when no hook exists", async () => {
+			const factory = new HookFactory()
+			const runner = await factory.create("TaskStart")
+
+			const result = await runner.run({
+				taskId: "test-task-id",
+				taskStart: {
+					taskMetadata: {
+						taskId: "test-task-id",
+						ulid: "test-ulid",
+						initialTask: "Test task",
+					},
+				},
+			})
+
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Fixture-Based Tests", () => {
+		it("should validate representative fixtures end-to-end", async () => {
+			const scenarios: Array<{ fixtureName: string; assert: (result: HookOutput) => void }> = [
+				{
+					fixtureName: "success",
+					assert: (result: HookOutput) => {
+						result.cancel.should.be.false()
+						result.contextModification?.should.equal("TaskStart hook executed successfully")
+					},
+				},
+				{
+					fixtureName: "blocking",
+					assert: (result: HookOutput) => {
+						result.cancel.should.be.true()
+						result.errorMessage?.should.equal("Task execution blocked by hook")
+					},
+				},
+			]
+
+			for (const scenario of scenarios) {
+				await withFixtureRunner("TaskStart", `hooks/taskstart/${scenario.fixtureName}`, hookTestEnv, async (runner) => {
+					const result = await runner.run({
+						taskId: "test-task-id",
+						taskStart: {
+							taskMetadata: {
+								taskId: "test-task-id",
+								ulid: "test-ulid",
+								initialTask: "Test task",
+							},
+						},
+					})
+
+					scenario.assert(result)
+				})
+			}
+		})
+
+		it("should preserve fixture-based failure behavior", async () => {
+			await withFixtureRunner("TaskStart", "hooks/taskstart/error", hookTestEnv, async (runner) => {
+				try {
+					await runner.run({
+						taskId: "test-task-id",
+						taskStart: {
+							taskMetadata: {
+								taskId: "test-task-id",
+								ulid: "test-ulid",
+								initialTask: "Test task",
+							},
+						},
+					})
+					throw new Error("Should have thrown")
+				} catch (error: unknown) {
+					getErrorMessage(error).should.match(/TaskStart.*exited with code 1/)
+				}
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/__tests__/test-utils.ts b/apps/vscode/src/core/hooks/__tests__/test-utils.ts
new file mode 100644
index 0000000..febd018
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/test-utils.ts
@@ -0,0 +1,647 @@
+import { spyOn } from "bun:test"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import should from "should"
+import sinon from "sinon"
+import { HostProvider } from "../../../hosts/host-provider"
+import { HookOutput } from "../../../shared/proto/cline/hooks"
+import { setVscodeHostProviderMock } from "../../../test/host-provider-test-utils"
+import * as diskModule from "../../storage/disk"
+import { StateManager } from "../../storage/StateManager"
+import { HookDiscoveryCache } from "../HookDiscoveryCache"
+import { HookFactory, Hooks, NamedHookInput } from "../hook-factory"
+
+// Define HookName locally since it's not exported from hook-factory
+type HookName = keyof Hooks
+
+export type HookTestEnv = {
+	tempDir: string
+	hooksDir: string
+	sandbox: sinon.SinonSandbox
+	cleanup: () => Promise<void>
+}
+
+async function removeTempDirWithRetry(tempDir: string): Promise<void> {
+	const maxAttempts = process.platform === "win32" ? 5 : 1
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+			return
+		} catch (error) {
+			const nodeError = error as NodeJS.ErrnoException
+			const isRetryableWindowsLock = process.platform === "win32" && nodeError?.code === "EBUSY"
+			if (!isRetryableWindowsLock || attempt === maxAttempts) {
+				throw error
+			}
+
+			// Give Windows a brief moment to release file handles from child processes.
+			await new Promise((resolve) => setTimeout(resolve, 100 * attempt))
+		}
+	}
+}
+
+export function resetHookCache(): void {
+	HookDiscoveryCache.resetForTesting()
+}
+
+export async function withPlatform<T>(platform: NodeJS.Platform, fn: () => Promise<T> | T): Promise<T> {
+	const originalPlatform = process.platform
+	Object.defineProperty(process, "platform", { value: platform, configurable: true })
+	try {
+		return await fn()
+	} finally {
+		Object.defineProperty(process, "platform", { value: originalPlatform, configurable: true })
+	}
+}
+
+export function hookFileName(hookName: string, platform: NodeJS.Platform = process.platform): string {
+	return platform === "win32" ? `${hookName}.ps1` : hookName
+}
+
+export function hookPath(hooksDir: string, hookName: string, platform: NodeJS.Platform = process.platform): string {
+	return path.join(hooksDir, hookFileName(hookName, platform))
+}
+
+// bun loads real ESM, so sinon cannot stub the `getAllHooksDirs` namespace
+// export ("ES Modules cannot be stubbed"). Use bun's spyOn, which can replace
+// ESM namespace bindings in place. The spy is tracked module-locally so the
+// per-env cleanup can restore it (the sandbox arg is retained for call-site
+// compatibility but is unused for this export).
+let hooksDirsSpy: ReturnType<typeof spyOn> | undefined
+
+export function stubHookDirs(_sandbox: sinon.SinonSandbox, dirs: string[]): ReturnType<typeof spyOn> {
+	if (!hooksDirsSpy) {
+		hooksDirsSpy = spyOn(diskModule, "getAllHooksDirs")
+	}
+	hooksDirsSpy.mockImplementation(async () => dirs)
+	return hooksDirsSpy
+}
+
+function restoreHookDirsSpy(): void {
+	hooksDirsSpy?.mockRestore()
+	hooksDirsSpy = undefined
+}
+
+export async function createHookTestEnv(): Promise<HookTestEnv> {
+	// Hook execution emits telemetry, which lazily constructs TelemetryService
+	// via HostProvider.env.getHostVersion(). Under mocha's single-process run an
+	// earlier suite left HostProvider initialized; bun's per-file isolation does
+	// not, so initialize it here (idempotent) to keep the telemetry path from
+	// throwing "HostProvider not setup".
+	if (!HostProvider.isInitialized()) {
+		setVscodeHostProviderMock()
+	}
+
+	const sandbox = sinon.createSandbox()
+	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "hook-test-"))
+	const hooksDir = await createHooksDirectory(tempDir)
+
+	sandbox.stub(StateManager, "get").returns({
+		getGlobalStateKey: (key: string) => {
+			if (key === "workspaceRoots") {
+				return [{ path: tempDir }]
+			}
+			if (key === "primaryRootIndex") {
+				return 0
+			}
+			return undefined
+		},
+	} as any)
+
+	resetHookCache()
+	stubHookDirs(sandbox, [hooksDir])
+
+	return {
+		tempDir,
+		hooksDir,
+		sandbox,
+		cleanup: async () => {
+			sandbox.restore()
+			restoreHookDirsSpy()
+			resetHookCache()
+			await removeTempDirWithRetry(tempDir)
+		},
+	}
+}
+
+/**
+ * Creates a hooks directory structure at the specified location.
+ *
+ * @param baseDir Base directory where .clinerules/hooks will be created
+ * @returns Path to the created hooks directory
+ *
+ * @example
+ * const hooksDir = await createHooksDirectory("/tmp/test")
+ * // Returns: "/tmp/test/.clinerules/hooks"
+ */
+export async function createHooksDirectory(baseDir: string): Promise<string> {
+	const hooksDir = path.join(baseDir, ".clinerules", "hooks")
+	await fs.mkdir(hooksDir, { recursive: true })
+	return hooksDir
+}
+
+/**
+ * Creates a test hook script with the specified output behavior.
+ *
+ * On Unix, this writes an executable `HookName` script with a shebang.
+ * On Windows, this writes both:
+ * - `HookName` (PowerShell bridge script)
+ * - `HookName.js` (Node implementation)
+ *
+ * This mirrors runtime behavior where Windows hooks execute via PowerShell.
+ *
+ * @param baseDir Base directory (typically tempDir from test environment)
+ * @param hookName Name of the hook (e.g., "PreToolUse", "PostToolUse")
+ * @param output The JSON output the hook should return
+ * @param options Optional configuration for hook behavior
+ * @returns Path to the created hook script
+ *
+ * @example
+ * // Create a simple success hook
+ * await createTestHook(tempDir, "PreToolUse", {
+ *   cancel: false,
+ *   contextModification: "TEST_CONTEXT"
+ * })
+ *
+ * @example
+ * // Create a hook that delays before responding
+ * await createTestHook(tempDir, "PreToolUse", {
+ *   cancel: false
+ * }, { delay: 100 })
+ *
+ * @example
+ * // Create a hook that exits with an error
+ * await createTestHook(tempDir, "PreToolUse", {
+ *   cancel: true
+ * }, { exitCode: 1 })
+ *
+ * @example
+ * // Create a hook with custom Node.js code
+ * await createTestHook(tempDir, "PreToolUse", {}, {
+ *   customNodeCode: "console.log('custom behavior'); process.exit(0);"
+ * })
+ */
+export async function createTestHook(
+	baseDir: string,
+	hookName: string,
+	output: Partial<HookOutput>,
+	options: {
+		delay?: number
+		exitCode?: number
+		malformedJson?: boolean
+		customNodeCode?: string
+		exitWithoutOutput?: boolean
+	} = {},
+): Promise<string> {
+	const hooksDir = await createHooksDirectory(baseDir)
+	const scriptContent = generateHookScript(output, options)
+
+	// Create hook scripts compatible with the active platform/runtime.
+	return writeShellHook(hooksDir, hookName, scriptContent)
+}
+
+/**
+ * Writes a hook script at a specific hook base path (without extension).
+ *
+ * - Unix/macOS: writes executable extensionless script directly
+ * - Windows: writes `<HookName>.ps1` + `<HookName>.js` companion script
+ */
+export async function writeHookScriptForPlatform(hookPath: string, nodeScript: string): Promise<void> {
+	if (process.platform === "win32") {
+		const jsPath = `${hookPath}.js`
+		const ps1Path = `${hookPath}.ps1`
+		const psBridge = buildPowerShellNodeBridge(process.execPath, path.basename(jsPath))
+
+		await fs.writeFile(jsPath, nodeScript)
+		await fs.writeFile(ps1Path, psBridge)
+		return
+	}
+
+	await fs.writeFile(hookPath, nodeScript)
+	await fs.chmod(hookPath, 0o755)
+}
+
+function buildPowerShellNodeBridge(nodePath: string, jsFileName: string): string {
+	const escapedNodePath = nodePath.replace(/'/g, "''")
+	const escapedJsFileName = jsFileName.replace(/'/g, "''")
+
+	return [
+		`$ErrorActionPreference = 'Stop'`,
+		`$scriptPath = Join-Path -Path $PSScriptRoot -ChildPath '${escapedJsFileName}'`,
+		`$inputData = [Console]::In.ReadToEnd()`,
+		`$inputData | & '${escapedNodePath}' $scriptPath`,
+		`if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE }`,
+		`exit 0`,
+	].join("\n")
+}
+
+/**
+ * Generates an executable Node.js script with shebang.
+ */
+function generateHookScript(
+	output: Partial<HookOutput>,
+	options: {
+		delay?: number
+		exitCode?: number
+		malformedJson?: boolean
+		customNodeCode?: string
+		exitWithoutOutput?: boolean
+	},
+): string {
+	let script = "#!/usr/bin/env node\n"
+
+	// If custom Node.js code is provided, use it directly
+	if (options.customNodeCode) {
+		return script + options.customNodeCode
+	}
+
+	// If exitWithoutOutput is true, just exit
+	if (options.exitWithoutOutput) {
+		return `${script}process.exit(0);\n`
+	}
+
+	if (options.delay) {
+		script += `setTimeout(() => {\n`
+	}
+
+	if (options.malformedJson) {
+		script += `  console.log("not valid json");\n`
+	} else {
+		script += `  console.log(JSON.stringify(${JSON.stringify(output)}));\n`
+	}
+
+	if (options.exitCode !== undefined) {
+		script += `  process.exit(${options.exitCode});\n`
+	}
+
+	if (options.delay) {
+		script += `}, ${options.delay});\n`
+	}
+
+	return script
+}
+
+/**
+ * Writes an executable hook script.
+ *
+ * Unix: writes executable script directly.
+ * Windows: writes a PowerShell bridge that pipes stdin to a Node companion script.
+ */
+async function writeShellHook(hooksDir: string, hookName: string, scriptContent: string): Promise<string> {
+	const scriptPath = path.join(hooksDir, hookName)
+	await writeHookScriptForPlatform(scriptPath, scriptContent)
+	return process.platform === "win32" ? `${scriptPath}.ps1` : scriptPath
+}
+
+/**
+ * Builds a complete HookInput object for PreToolUse testing.
+ *
+ * @param params Partial parameters to customize the input
+ * @returns Complete HookInput ready for runner.run()
+ *
+ * @example
+ * const input = buildPreToolUseInput({
+ *   toolName: "write_to_file",
+ *   parameters: { path: "test.ts", content: "test" }
+ * })
+ */
+export function buildPreToolUseInput(params: {
+	toolName: string
+	parameters?: Record<string, any>
+	taskId?: string
+}): NamedHookInput<"PreToolUse"> {
+	return {
+		taskId: params.taskId || "test-task-id",
+		preToolUse: {
+			toolName: params.toolName,
+			parameters: params.parameters || {},
+		},
+	}
+}
+
+/**
+ * Builds a complete HookInput object for PostToolUse testing.
+ *
+ * @param params Partial parameters to customize the input
+ * @returns Complete HookInput ready for runner.run()
+ *
+ * @example
+ * const input = buildPostToolUseInput({
+ *   toolName: "write_to_file",
+ *   result: "File created successfully",
+ *   success: true
+ * })
+ */
+export function buildPostToolUseInput(params: {
+	toolName: string
+	parameters?: Record<string, any>
+	result?: string
+	success?: boolean
+	executionTimeMs?: number
+	taskId?: string
+}): NamedHookInput<"PostToolUse"> {
+	return {
+		taskId: params.taskId || "test-task-id",
+		postToolUse: {
+			toolName: params.toolName,
+			parameters: params.parameters || {},
+			result: params.result || "",
+			success: params.success ?? true,
+			executionTimeMs: params.executionTimeMs ?? 100,
+		},
+	}
+}
+
+/**
+ * Assertion helper for HookOutput validation.
+ * Compares actual output against expected partial output.
+ *
+ * @param actual The actual hook output received
+ * @param expected The expected hook output (partial match)
+ *
+ * @example
+ * assertHookOutput(result, {
+ *   cancel: false,
+ *   contextModification: "Expected context"
+ * })
+ */
+export function assertHookOutput(actual: HookOutput, expected: Partial<HookOutput>): void {
+	if (expected.cancel !== undefined) {
+		if (actual.cancel !== expected.cancel) {
+			throw new Error(
+				`Hook output assertion failed for 'cancel':\n` +
+					`  Expected: ${expected.cancel}\n` +
+					`  Received: ${actual.cancel}\n` +
+					`  Full output: ${JSON.stringify(actual, null, 2)}`,
+			)
+		}
+	}
+
+	if (expected.contextModification !== undefined) {
+		if (actual.contextModification !== expected.contextModification) {
+			throw new Error(
+				`Hook output assertion failed for 'contextModification':\n` +
+					`  Expected: "${expected.contextModification}"\n` +
+					`  Received: "${actual.contextModification}"\n` +
+					`  Full output: ${JSON.stringify(actual, null, 2)}`,
+			)
+		}
+	}
+
+	if (expected.errorMessage !== undefined) {
+		if (actual.errorMessage !== expected.errorMessage) {
+			throw new Error(
+				`Hook output assertion failed for 'errorMessage':\n` +
+					`  Expected: "${expected.errorMessage}"\n` +
+					`  Received: "${actual.errorMessage}"\n` +
+					`  Full output: ${JSON.stringify(actual, null, 2)}`,
+			)
+		}
+	}
+}
+
+/**
+ * Type guard to check if a value is serializable (can be cloned).
+ * Prevents errors from attempting to clone non-serializable objects.
+ */
+function isSerializable(value: any): boolean {
+	if (value === null || value === undefined) {
+		return true
+	}
+
+	const type = typeof value
+	if (type === "string" || type === "number" || type === "boolean") {
+		return true
+	}
+
+	if (type === "object") {
+		// Check for non-serializable types
+		if (value instanceof Function || value instanceof RegExp || value instanceof Error) {
+			return false
+		}
+
+		// Check if it's an array or plain object
+		if (Array.isArray(value)) {
+			return value.every(isSerializable)
+		}
+
+		// For objects, check all values
+		return Object.values(value).every(isSerializable)
+	}
+
+	return false
+}
+
+/**
+ * Mock implementation of HookRunner for fast integration tests.
+ * Tracks calls and returns predefined responses without spawning processes.
+ *
+ * @example
+ * const mockRunner = new MockHookRunner("PreToolUse")
+ * mockRunner.setResponse({ cancel: false })
+ *
+ * const result = await mockRunner.run(input)
+ * mockRunner.assertCalled(1)
+ * mockRunner.assertCalledWith({ preToolUse: { toolName: "write_to_file" } })
+ */
+export class MockHookRunner<Name extends HookName> {
+	private response: HookOutput = {
+		cancel: false,
+		contextModification: "",
+		errorMessage: "",
+	}
+	public executionLog: Array<{ input: NamedHookInput<Name>; timestamp: number }> = []
+	public readonly hookName: Name
+
+	constructor(hookName: Name) {
+		this.hookName = hookName
+	}
+
+	/**
+	 * Set the response this mock should return.
+	 *
+	 * @param output The HookOutput to return on execution
+	 */
+	setResponse(output: Partial<HookOutput>): void {
+		this.response = {
+			cancel: output.cancel ?? false,
+			contextModification: output.contextModification ?? "",
+			errorMessage: output.errorMessage ?? "",
+		}
+	}
+
+	/**
+	 * Mock run method that records calls and returns preset response.
+	 * Does not use the actual HookRunner execution mechanism.
+	 */
+	async run(params: NamedHookInput<Name>): Promise<HookOutput> {
+		// Validate params are serializable
+		if (!isSerializable(params)) {
+			throw new Error(
+				`MockHookRunner: Cannot clone non-serializable input. ` +
+					`Ensure all input values are primitive types, arrays, or plain objects.`,
+			)
+		}
+
+		// Use structuredClone for deep copy (Node 17+)
+		// Falls back to JSON stringify/parse for older Node versions
+		let clonedInput: NamedHookInput<Name>
+		try {
+			clonedInput = structuredClone(params)
+		} catch {
+			// Fallback for older Node versions
+			clonedInput = JSON.parse(JSON.stringify(params))
+		}
+
+		this.executionLog.push({
+			input: clonedInput,
+			timestamp: Date.now(),
+		})
+
+		// Simulate async execution
+		await new Promise((resolve) => setTimeout(resolve, 1))
+
+		return this.response
+	}
+
+	/**
+	 * Assert this hook was called a specific number of times.
+	 *
+	 * @param times Expected number of calls
+	 */
+	assertCalled(times: number): void {
+		if (this.executionLog.length !== times) {
+			throw new Error(
+				`MockHookRunner call count assertion failed:\n` +
+					`  Expected: ${times} calls\n` +
+					`  Received: ${this.executionLog.length} calls\n` +
+					`  Execution log:\n${JSON.stringify(this.executionLog, null, 2)}`,
+			)
+		}
+	}
+
+	/**
+	 * Assert this hook was called with matching input.
+	 * Performs partial match on the input object using deep equality.
+	 * Property ordering does not affect equality checks.
+	 * Uses should.js's eql() for robust deep equality comparison.
+	 *
+	 * @param matcher Partial input to match against
+	 */
+	assertCalledWith(matcher: Partial<NamedHookInput<Name>>): void {
+		const matchingCalls = this.executionLog.filter((log) => {
+			return Object.keys(matcher).every((key) => {
+				const matcherValue = (matcher as any)[key]
+				const logValue = (log.input as any)[key]
+				// Use should.js's eql() for deep equality (handles property ordering)
+				try {
+					should(logValue).eql(matcherValue)
+					return true
+				} catch {
+					return false
+				}
+			})
+		})
+
+		if (matchingCalls.length === 0) {
+			throw new Error(
+				`MockHookRunner input assertion failed - no calls matched the expected input:\n` +
+					`  Expected input (partial): ${JSON.stringify(matcher, null, 2)}\n` +
+					`  Actual calls: ${JSON.stringify(this.executionLog, null, 2)}`,
+			)
+		}
+	}
+
+	/**
+	 * Reset all recorded calls and responses.
+	 */
+	reset(): void {
+		this.executionLog = []
+		this.response = {
+			cancel: false,
+			contextModification: "",
+			errorMessage: "",
+		}
+	}
+}
+
+/**
+ * Copies a fixture to the test environment.
+ *
+ * @param fixtureName Path to fixture relative to fixtures directory (e.g., "hooks/pretooluse/success")
+ * @param destDir Destination directory (typically tempDir from test environment)
+ *
+ * @example
+ * await loadFixture("hooks/pretooluse/success", tempDir)
+ * // Hook is now available at tempDir/.clinerules/hooks/PreToolUse
+ */
+export async function loadFixture(fixtureName: string, destDir: string): Promise<void> {
+	const fixturesDir = path.join(__dirname, "fixtures")
+	const sourcePath = path.join(fixturesDir, fixtureName)
+	const destHooksDir = await createHooksDirectory(destDir)
+
+	// Copy all files from the fixture directory to the destination
+	const files = await fs.readdir(sourcePath)
+	for (const file of files) {
+		const sourceFile = path.join(sourcePath, file)
+
+		if (process.platform === "win32") {
+			const sourceContent = await fs.readFile(sourceFile, "utf-8")
+			await writeHookScriptForPlatform(path.join(destHooksDir, file), sourceContent)
+		} else {
+			const destFile = path.join(destHooksDir, file)
+			await fs.copyFile(sourceFile, destFile)
+
+			// Set executable permission (not needed on Windows)
+			const stats = await fs.stat(sourceFile)
+			await fs.chmod(destFile, stats.mode)
+		}
+	}
+}
+
+/**
+ * Creates an isolated hook test environment, loads a fixture into it, creates a runner,
+ * and guarantees cleanup once the callback completes.
+ *
+ * This is useful for fixture suites that want to iterate through multiple scenarios
+ * without sharing hook directories, discovery cache state, or filesystem artifacts
+ * between scenarios.
+ */
+export async function withFixtureRunner<Name extends HookName, TResult>(
+	hookName: Name,
+	fixtureName: string,
+	callback: (runner: Awaited<ReturnType<HookFactory["create"]>>, env: HookTestEnv) => Promise<TResult>,
+): Promise<TResult>
+export async function withFixtureRunner<Name extends HookName, TResult>(
+	hookName: Name,
+	fixtureName: string,
+	env: HookTestEnv,
+	callback: (runner: Awaited<ReturnType<HookFactory["create"]>>, env: HookTestEnv) => Promise<TResult>,
+): Promise<TResult>
+export async function withFixtureRunner<Name extends HookName, TResult>(
+	hookName: Name,
+	fixtureName: string,
+	envOrCallback: HookTestEnv | ((runner: Awaited<ReturnType<HookFactory["create"]>>, env: HookTestEnv) => Promise<TResult>),
+	maybeCallback?: (runner: Awaited<ReturnType<HookFactory["create"]>>, env: HookTestEnv) => Promise<TResult>,
+): Promise<TResult> {
+	const usingExistingEnv = typeof envOrCallback !== "function"
+	const env = usingExistingEnv ? envOrCallback : await createHookTestEnv()
+	const runCallback = usingExistingEnv ? maybeCallback : envOrCallback
+	if (!runCallback) {
+		throw new Error("withFixtureRunner requires a callback")
+	}
+	try {
+		await fs.rm(env.hooksDir, { recursive: true, force: true })
+		await createHooksDirectory(env.tempDir)
+		resetHookCache()
+		await loadFixture(fixtureName, env.tempDir)
+		const factory = new HookFactory()
+		const runner = await factory.create(hookName)
+		return await runCallback(runner, env)
+	} finally {
+		if (!usingExistingEnv) {
+			await env.cleanup()
+		}
+	}
+}
diff --git a/apps/vscode/src/core/hooks/__tests__/user-prompt-submit.test.ts b/apps/vscode/src/core/hooks/__tests__/user-prompt-submit.test.ts
new file mode 100644
index 0000000..bf43b8f
--- /dev/null
+++ b/apps/vscode/src/core/hooks/__tests__/user-prompt-submit.test.ts
@@ -0,0 +1,494 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import path from "path"
+import sinon from "sinon"
+import { HookOutput } from "../../../shared/proto/cline/hooks"
+import { HookFactory } from "../hook-factory"
+import { createHookTestEnv, HookTestEnv, stubHookDirs, withFixtureRunner, writeHookScriptForPlatform } from "./test-utils"
+
+describe("UserPromptSubmit Hook", () => {
+	let tempDir: string
+	let sandbox: sinon.SinonSandbox
+	let hookTestEnv: HookTestEnv
+	const WINDOWS_HOOK_TEST_TIMEOUT_MS = 15000
+
+	type FixtureScenario = {
+		fixtureName: string
+		prompt: string
+		assert: (result: HookOutput) => void
+	}
+
+	const getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+	const writeHookScript = async (hookPath: string, nodeScript: string): Promise<void> => {
+		await writeHookScriptForPlatform(hookPath, nodeScript)
+	}
+
+	beforeEach(async () => {
+		hookTestEnv = await createHookTestEnv()
+		tempDir = hookTestEnv.tempDir
+		sandbox = hookTestEnv.sandbox
+	})
+
+	afterEach(async () => {
+		await hookTestEnv.cleanup()
+	})
+
+	describe("Hook Input Format", () => {
+		it("should receive prompt text from user content", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasPrompt = input.userPromptSubmit && typeof input.userPromptSubmit.prompt === 'string' && input.userPromptSubmit.prompt.length > 0;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasPrompt ? "Received prompt" : "Missing prompt"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Create a todo app",
+					attachments: [],
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.equal("Received prompt")
+		}, 5000)
+
+		it("should handle multiline prompts", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const lineCount = (input.userPromptSubmit.prompt.match(/\\n/g) || []).length + 1;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Line count: " + lineCount
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const multilinePrompt = "Line 1\nLine 2\nLine 3"
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: multilinePrompt,
+					attachments: [],
+				},
+			})
+
+			result.contextModification?.should.equal("Line count: 3")
+		})
+
+		it("should handle large prompts", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const size = input.userPromptSubmit.prompt.length;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Prompt size: " + size
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const largePrompt = "x".repeat(10000)
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: largePrompt,
+					attachments: [],
+				},
+			})
+
+			result.contextModification?.should.equal("Prompt size: 10000")
+		})
+
+		it("should receive all common hook input fields", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const hasAllFields = input.clineVersion && input.hookName && input.timestamp && 
+                     input.taskId && input.workspaceRoots !== undefined &&
+                     input.model && input.model.provider && input.model.slug;
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasAllFields ? "All fields present" : "Missing fields"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Test",
+					attachments: [],
+				},
+			})
+
+			result.contextModification?.should.equal("All fields present")
+		})
+	})
+
+	describe("Prompt Content Serialization", () => {
+		it("should handle empty prompt", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const promptData = input.userPromptSubmit;
+if (!promptData) {
+  console.log(JSON.stringify({
+    cancel: true,
+    errorMessage: "No userPromptSubmit data"
+  }));
+  process.exit(0);
+}
+const promptLength = typeof promptData.prompt === 'string' ? promptData.prompt.length : (promptData.prompt ? String(promptData.prompt).length : 0);
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Prompt length: " + promptLength
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "",
+					attachments: [],
+				},
+			})
+
+			result.contextModification?.should.equal("Prompt length: 0")
+		})
+
+		it("should preserve special characters in prompt", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const prompt = input.userPromptSubmit.prompt;
+const hasSpecialChars = prompt.includes("@") && prompt.includes("#") && prompt.includes("$");
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: hasSpecialChars ? "Special chars preserved" : "Missing special chars"
+}))`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Test @user #feature $cost",
+					attachments: [],
+				},
+			})
+
+			result.contextModification?.should.equal("Special chars preserved")
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle malformed JSON output from hook", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+console.log("not valid json")`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			// When hook exits 0 but has malformed JSON, it returns success without context
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Test",
+					attachments: [],
+				},
+			})
+
+			// Hook succeeded (exit 0) but couldn't parse JSON, so returns success without context
+			result.cancel.should.be.false()
+			;(result.contextModification === undefined || result.contextModification === "").should.be.true()
+		})
+
+		it("should handle hook script errors", async () => {
+			const hookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const hookScript = `#!/usr/bin/env node
+process.exit(1)`
+
+			await writeHookScript(hookPath, hookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			try {
+				await runner.run({
+					taskId: "test-task",
+					userPromptSubmit: {
+						prompt: "Test",
+						attachments: [],
+					},
+				})
+				throw new Error("Should have thrown")
+			} catch (error: unknown) {
+				getErrorMessage(error).should.match(/exited with code 1/)
+			}
+		})
+	})
+
+	describe("Global and Workspace Hooks", () => {
+		let globalHooksDir: string
+		let workspaceHooksDir: string
+
+		beforeEach(async () => {
+			// Create global hooks directory
+			globalHooksDir = path.join(tempDir, "global-hooks")
+			await fs.mkdir(globalHooksDir, { recursive: true })
+			workspaceHooksDir = path.join(tempDir, ".clinerules", "hooks")
+
+			// Use deterministic hook directories to avoid test flakiness from
+			// calling real directory discovery logic in CI.
+			stubHookDirs(sandbox, [globalHooksDir, workspaceHooksDir])
+		})
+
+		it("should execute both global and workspace UserPromptSubmit hooks", async () => {
+			// Create global hook
+			const globalHookPath = path.join(globalHooksDir, "UserPromptSubmit")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "GLOBAL: Prompt received"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "WORKSPACE: Prompt received"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Create a feature",
+					attachments: [],
+				},
+			})
+
+			result.cancel.should.be.false()
+			result.contextModification?.should.match(/GLOBAL: Prompt received/)
+			result.contextModification?.should.match(/WORKSPACE: Prompt received/)
+		})
+
+		it("should block if workspace hook blocks even when global allows", async () => {
+			// Create allowing global hook
+			const globalHookPath = path.join(globalHooksDir, "UserPromptSubmit")
+			const globalHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: false,
+  contextModification: "Global allows"
+}))`
+			await writeHookScript(globalHookPath, globalHookScript)
+
+			// Create blocking workspace hook
+			const workspaceHookPath = path.join(tempDir, ".clinerules", "hooks", "UserPromptSubmit")
+			const workspaceHookScript = `#!/usr/bin/env node
+console.log(JSON.stringify({
+  cancel: true,
+  errorMessage: "Workspace blocks"
+}))`
+			await writeHookScript(workspaceHookPath, workspaceHookScript)
+
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Create a feature",
+					attachments: [],
+				},
+			})
+
+			result.cancel.should.be.true()
+			result.errorMessage?.should.match(/Workspace blocks/)
+		})
+	})
+
+	describe("No Hook Behavior", () => {
+		it("should allow prompt when no hook exists", async () => {
+			// Don't create any hook
+			const factory = new HookFactory()
+			const runner = await factory.create("UserPromptSubmit")
+
+			const result = await runner.run({
+				taskId: "test-task",
+				userPromptSubmit: {
+					prompt: "Create a feature",
+					attachments: [],
+				},
+			})
+
+			// NoOpRunner always returns success
+			result.cancel.should.be.false()
+		})
+	})
+
+	describe("Fixture-Based Tests", () => {
+		// These tests demonstrate using pre-written fixtures from the fixtures directory
+		// Fixtures serve as both test data and examples for manual testing
+		const isWindows = process.platform === "win32"
+
+		it(
+			"should validate representative fixtures end-to-end",
+			async () => {
+				// Multiple fixture scenarios spawn child processes sequentially,
+				// which can easily exceed the default 2 s Mocha timeout.
+				const scenarios: FixtureScenario[] = [
+					{
+						fixtureName: "success",
+						prompt: "Create a feature",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("Prompt approved")
+						},
+					},
+					{
+						fixtureName: "blocking",
+						prompt: "Do something forbidden",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.true()
+							result.errorMessage?.should.equal("Prompt violates policy")
+						},
+					},
+					{
+						fixtureName: "context-injection",
+						prompt: "Build something",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("CONTEXT_INJECTION: User is in plan mode")
+						},
+					},
+					{
+						fixtureName: "multiline",
+						prompt: "Line 1\nLine 2\nLine 3",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("Line count: 3")
+						},
+					},
+					{
+						fixtureName: "special-chars",
+						prompt: "Test @user #feature $cost",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("Special chars preserved")
+						},
+					},
+					{
+						fixtureName: "empty-prompt",
+						prompt: "",
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("Prompt length: 0")
+						},
+					},
+				]
+
+				if (!isWindows) {
+					scenarios.push({
+						fixtureName: "large-prompt",
+						prompt: "x".repeat(10000),
+						assert: (result: HookOutput) => {
+							result.cancel.should.be.false()
+							result.contextModification?.should.equal("Prompt size: 10000")
+						},
+					})
+				}
+
+				for (const scenario of scenarios) {
+					await withFixtureRunner(
+						"UserPromptSubmit",
+						`hooks/userpromptsubmit/${scenario.fixtureName}`,
+						hookTestEnv,
+						async (runner) => {
+							const result = await runner.run({
+								taskId: "test-task",
+								userPromptSubmit: {
+									prompt: scenario.prompt,
+									attachments: [],
+								},
+							})
+
+							scenario.assert(result)
+						},
+					)
+				}
+			},
+			WINDOWS_HOOK_TEST_TIMEOUT_MS,
+		)
+
+		it("should cover malformed-json fixture path", async () => {
+			await withFixtureRunner("UserPromptSubmit", "hooks/userpromptsubmit/malformed-json", hookTestEnv, async (runner) => {
+				const malformedResult = await runner.run({
+					taskId: "test-task",
+					userPromptSubmit: {
+						prompt: "Test",
+						attachments: [],
+					},
+				})
+
+				malformedResult.cancel.should.be.false()
+				;(
+					malformedResult.contextModification === undefined || malformedResult.contextModification === ""
+				).should.be.true()
+			})
+		})
+
+		it("should cover failing fixture path", async () => {
+			await withFixtureRunner("UserPromptSubmit", "hooks/userpromptsubmit/error", hookTestEnv, async (runner) => {
+				try {
+					await runner.run({
+						taskId: "test-task",
+						userPromptSubmit: {
+							prompt: "Test",
+							attachments: [],
+						},
+					})
+					throw new Error("Should have thrown")
+				} catch (error: unknown) {
+					getErrorMessage(error).should.match(/exited with code 1/)
+				}
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/core/hooks/hook-factory.ts b/apps/vscode/src/core/hooks/hook-factory.ts
new file mode 100644
index 0000000..3ab6175
--- /dev/null
+++ b/apps/vscode/src/core/hooks/hook-factory.ts
@@ -0,0 +1,1014 @@
+import fs from "fs/promises"
+import path from "path"
+import { Logger } from "@/shared/services/Logger"
+import { version as clineVersion } from "../../../package.json"
+import { getDistinctId } from "../../services/logging/distinctId"
+import { telemetryService } from "../../services/telemetry"
+import {
+	HookInput,
+	HookModelContext,
+	HookOutput,
+	NotificationData,
+	PostToolUseData,
+	PreCompactData,
+	PreToolUseData,
+	TaskCancelData,
+	TaskCompleteData,
+	TaskResumeData,
+	TaskStartData,
+	UserPromptSubmitData,
+} from "../../shared/proto/cline/hooks"
+import { getAllHooksDirs } from "../storage/disk"
+import { StateManager } from "../storage/StateManager"
+import { HookExecutionError } from "./HookError"
+import { HookProcess } from "./HookProcess"
+
+// Hook execution timeout (30 seconds)
+const HOOK_EXECUTION_TIMEOUT_MS = 30000
+
+// Maximum size for context modification (to prevent prompt overflow)
+const MAX_CONTEXT_MODIFICATION_SIZE = 50000 // ~50KB
+
+// Exit code indicating cancellation/interruption (Unix SIGINT convention: 128 + signal 2)
+const EXIT_CODE_SIGINT = 130
+
+/**
+ * Validates hook output JSON structure.
+ * Ensures required fields are present and have correct types.
+ */
+function validateHookOutput(output: any): { valid: boolean; error?: string } {
+	// Check if deprecated shouldContinue field is present
+	if (output.shouldContinue !== undefined) {
+		return {
+			valid: false,
+			error:
+				"Invalid hook output: The 'shouldContinue' field has been removed.\n\n" +
+				"Use 'cancel: true' instead to trigger task cancellation.\n\n" +
+				"Migration guide:\n" +
+				"  Before: { shouldContinue: false, errorMessage: '...' }\n" +
+				"  After:  { cancel: true, errorMessage: '...' }\n\n" +
+				"Example valid response:\n" +
+				JSON.stringify(
+					{
+						cancel: false,
+						contextModification: "Optional context here",
+						errorMessage: "",
+					},
+					null,
+					2,
+				),
+		}
+	}
+
+	// cancel is optional, but if provided must be a boolean
+	if (output.cancel !== undefined && typeof output.cancel !== "boolean") {
+		return {
+			valid: false,
+			error:
+				"Invalid hook output: 'cancel' must be a boolean.\n\n" +
+				`Received type: ${typeof output.cancel}\n\n` +
+				"Example valid response:\n" +
+				JSON.stringify({ cancel: true, errorMessage: "Cancelling task" }, null, 2),
+		}
+	}
+
+	// contextModification is optional, but if provided must be a string
+	if (output.contextModification !== undefined && typeof output.contextModification !== "string") {
+		return {
+			valid: false,
+			error:
+				"Invalid hook output: 'contextModification' must be a string.\n\n" +
+				`Received type: ${typeof output.contextModification}\n\n` +
+				"Example valid response:\n" +
+				JSON.stringify({ contextModification: "Context here" }, null, 2),
+		}
+	}
+
+	// errorMessage is optional, but if provided must be a string
+	if (output.errorMessage !== undefined && typeof output.errorMessage !== "string") {
+		return {
+			valid: false,
+			error:
+				"Invalid hook output: 'errorMessage' must be a string.\n\n" +
+				`Received type: ${typeof output.errorMessage}\n\n` +
+				"Example valid response:\n" +
+				JSON.stringify({ cancel: true, errorMessage: "Error description" }, null, 2),
+		}
+	}
+
+	return { valid: true }
+}
+
+export interface Hooks {
+	PreToolUse: {
+		preToolUse: PreToolUseData
+	}
+	PostToolUse: {
+		postToolUse: PostToolUseData
+	}
+	UserPromptSubmit: {
+		userPromptSubmit: UserPromptSubmitData
+	}
+	TaskStart: {
+		taskStart: TaskStartData
+	}
+	TaskResume: {
+		taskResume: TaskResumeData
+	}
+	TaskCancel: {
+		taskCancel: TaskCancelData
+	}
+	TaskComplete: {
+		taskComplete: TaskCompleteData
+	}
+	Notification: {
+		notification: NotificationData
+	}
+	PreCompact: {
+		preCompact: PreCompactData
+	}
+}
+
+interface HookModelInputContext {
+	provider?: string
+	slug?: string
+}
+
+// The names of all supported hooks. Hooks[N] is the type of data the hook takes as input.
+type HookName = keyof Hooks
+
+/**
+ * The hook input parameters for a named hook. These are the parameters the caller must
+ * provide--the other common parameters like clineVersion and userId are handled by the
+ * hook system.
+ */
+export type NamedHookInput<Name extends HookName> = {
+	taskId: string
+	model?: HookModelInputContext
+} & Hooks[Name]
+
+// We look up HookRunner.exec via symbol so that the combined hook runner can call
+// exec on its sub-runners without completing a new set of parameters for each one.
+// See CombinedHookRunner[exec]
+const exec = Symbol()
+
+/**
+ * Runs a hook script and returns the result.
+ *
+ * Design: HookRunner is stateless and reusable. Each call to run() is independent
+ * and returns a fresh HookOutput. This design is appropriate because:
+ * - Hooks are executed on-demand per tool use
+ * - No need to maintain execution history within the runner
+ * - ToolExecutor creates new instances as needed
+ * - Results are immediately consumed and added to the conversation context
+ */
+export abstract class HookRunner<Name extends HookName> {
+	constructor(public readonly hookName: Name) {}
+
+	/**
+	 * Execute the hook with the given parameters.
+	 * This method is stateless and can be called multiple times safely.
+	 * @param params Hook-specific parameters (taskId, preToolUse/postToolUse data)
+	 * @returns The hook output containing shouldContinue, contextModification, and errorMessage
+	 */
+	async run(params: NamedHookInput<Name>): Promise<HookOutput> {
+		const input = HookInput.create(await this.completeParams(params))
+		return this[exec](input)
+	}
+
+	abstract [exec](params: HookInput): Promise<HookOutput>
+
+	/**
+	 * Completes the hook input by adding common metadata to caller-provided parameters.
+	 *
+	 * This method enriches the hook-specific input (like preToolUse or postToolUse data)
+	 * with standard information that all hooks receive:
+	 * - clineVersion: Current Cline extension version
+	 * - hookName: The type of hook being executed (e.g., "PreToolUse")
+	 * - timestamp: Execution time in milliseconds since epoch
+	 * - workspaceRoots: Array of workspace folder paths
+	 * - userId: Cline user ID, machine ID, or generated UUID
+	 *
+	 * This separation allows hook scripts to receive consistent metadata without
+	 * requiring callers to manually provide it each time.
+	 *
+	 * @param params The hook-specific input parameters (taskId + hook data)
+	 * @returns Complete HookInput ready to be serialized and sent to the hook script
+	 */
+	protected async completeParams(params: NamedHookInput<Name>): Promise<HookInput> {
+		const workspaceRoots =
+			StateManager.get()
+				.getGlobalStateKey("workspaceRoots")
+				?.map((root) => root.path) || []
+
+		const model: HookModelContext = {
+			provider: params.model?.provider?.trim() || "unknown",
+			slug: params.model?.slug?.trim() || "unknown",
+		}
+
+		return {
+			clineVersion,
+			hookName: this.hookName,
+			timestamp: Date.now().toString(),
+			workspaceRoots,
+			userId: getDistinctId(), // Always available: Cline User ID, machine ID, or generated UUID
+			...params,
+			model,
+		}
+	}
+}
+
+/**
+ * NoOpRunner is a null-object pattern implementation used when no hook scripts are found.
+ *
+ * Instead of returning null or requiring null checks everywhere, we return a NoOpRunner
+ * that always succeeds immediately without any side effects. This simplifies the calling
+ * code and ensures hooks are always optional/gracefully degraded.
+ *
+ * @template Name The type of hook this runner represents
+ */
+class NoOpRunner<Name extends HookName> extends HookRunner<Name> {
+	/**
+	 * Executes a no-op hook that always succeeds.
+	 * @param _ Hook input (ignored)
+	 * @returns A successful hook output (no cancellation)
+	 */
+	override async [exec](_: HookInput): Promise<HookOutput> {
+		// HookOutput is a protobuf-generated type with non-optional fields.
+		// Protobuf defaults: cancel=false, contextModification="", errorMessage=""
+		return HookOutput.create({ cancel: false })
+	}
+}
+
+/**
+ * Callback type for streaming hook output
+ */
+export type HookStreamCallback = (
+	line: string,
+	stream: "stdout" | "stderr",
+	meta?: {
+		source: "global" | "workspace"
+		scriptPath: string
+	},
+) => void
+
+/**
+ * Executes a hook script as a child process with real-time output streaming.
+ *
+ * Key features:
+ * - Spawns the hook script and communicates via stdin/stdout/stderr
+ * - Streams output line-by-line via callback for real-time UI updates
+ * - Enforces 30-second timeout (configurable via HOOK_EXECUTION_TIMEOUT_MS)
+ * - Supports cancellation via AbortSignal
+ * - Parses JSON output from stdout, attempting to extract it even if mixed with debug output
+ * - Truncates context modifications that exceed 50KB to prevent prompt overflow
+ * - Handles both successful and failed executions gracefully
+ * - Emits per-hook telemetry with source attribution (global or workspace)
+ *
+ * Error handling:
+ * - Treats hooks as "fail-open": only shouldContinue:false blocks tool execution
+ * - Hook script errors (non-zero exit) don't block tools, only explicit JSON response does
+ * - Timeout/cancellation errors are propagated to show "Failed" status in UI
+ *
+ * @template Name The type of hook this runner represents
+ */
+class StdioHookRunner<Name extends HookName> extends HookRunner<Name> {
+	constructor(
+		hookName: Name,
+		public readonly scriptPath: string,
+		private readonly source: "global" | "workspace",
+		private readonly streamCallback?: HookStreamCallback,
+		private readonly abortSignal?: AbortSignal,
+		private readonly taskId?: string,
+		private readonly toolName?: string,
+		private readonly cwd?: string,
+	) {
+		super(hookName)
+	}
+
+	override async [exec](input: HookInput): Promise<HookOutput> {
+		const startTime = performance.now()
+		const taskId = this.taskId // Local const for type narrowing in closures
+
+		// Capture telemetry at the start of individual hook execution
+		if (taskId) {
+			telemetryService.safeCapture(
+				() =>
+					telemetryService.captureHookExecution(taskId, this.hookName, "started", {
+						source: this.source,
+						toolName: this.toolName,
+					}),
+				"HookFactory.exec.started",
+			)
+		}
+
+		// Check if already aborted before starting
+		if (this.abortSignal?.aborted) {
+			throw HookExecutionError.cancellation(this.scriptPath)
+		}
+
+		// Serialize input to JSON
+		// NOTE: Proto3 by default omits empty strings (default values) from toJSON()
+		// To ensure hooks receive consistent data (e.g., {"prompt": ""} instead of {}),
+		// we manually construct the JSON object and explicitly include empty string fields
+		const jsonObj = HookInput.toJSON(input) as Record<string, any>
+
+		// Ensure empty prompt strings are preserved in UserPromptSubmit data
+		if (jsonObj.userPromptSubmit && jsonObj.userPromptSubmit.prompt === undefined) {
+			jsonObj.userPromptSubmit.prompt = ""
+		}
+
+		const inputJson = JSON.stringify(jsonObj)
+
+		// Create HookProcess for execution with streaming
+		const hookProcess = new HookProcess(this.scriptPath, HOOK_EXECUTION_TIMEOUT_MS, this.abortSignal, this.cwd)
+
+		// Set up streaming if callback is provided
+		if (this.streamCallback) {
+			const callback = this.streamCallback
+			hookProcess.on("line", (line: string, stream: "stdout" | "stderr") => {
+				// NOTE: HookProcess emits a synthetic empty line (""), used as a "start of output" marker.
+				// Preserve it for now so downstream can keep existing behavior.
+				callback(line, stream, {
+					source: this.source,
+					scriptPath: this.scriptPath,
+				})
+			})
+		}
+
+		try {
+			// Execute the hook and wait for completion
+			await hookProcess.run(inputJson)
+
+			// Get the complete stdout for JSON parsing
+			const stdout = hookProcess.getStdout()
+			const stderr = hookProcess.getStderr()
+			const exitCode = hookProcess.getExitCode()
+
+			// Try to parse JSON output
+			const parseJsonOutput = (): HookOutput | null => {
+				try {
+					const outputData = JSON.parse(stdout)
+
+					// Validate structure before creating HookOutput
+					const validation = validateHookOutput(outputData)
+					if (!validation.valid) {
+						// Return null to indicate parsing failed, let caller decide what to do based on exit code
+						return null
+					}
+
+					const output = HookOutput.fromJSON(outputData)
+
+					// Validate and truncate context modification if too large
+					if (output.contextModification && output.contextModification.length > MAX_CONTEXT_MODIFICATION_SIZE) {
+						Logger.warn(
+							`Hook ${this.hookName} returned contextModification of ${output.contextModification.length} bytes, ` +
+								`truncating to ${MAX_CONTEXT_MODIFICATION_SIZE} bytes`,
+						)
+						output.contextModification =
+							output.contextModification.slice(0, MAX_CONTEXT_MODIFICATION_SIZE) +
+							"\n\n[... context truncated due to size limit ...]"
+					}
+
+					return output
+				} catch (parseError) {
+					// Try to extract JSON from stdout (it might have debug output before/after)
+					// Scan from the end to find the last complete JSON object
+					// This handles cases where hooks output debug info before the actual JSON response
+
+					const lines = stdout.split("\n")
+					let jsonCandidate = ""
+					let braceCount = 0
+					let startCollecting = false
+
+					// Scan from the end to find the last complete JSON object
+					for (let i = lines.length - 1; i >= 0; i--) {
+						const line = lines[i].trimEnd()
+
+						// Count braces to track JSON object boundaries
+						for (let j = line.length - 1; j >= 0; j--) {
+							if (line[j] === "}") {
+								braceCount++
+								if (!startCollecting) {
+									startCollecting = true
+								}
+							} else if (line[j] === "{") {
+								braceCount--
+							}
+						}
+
+						if (startCollecting) {
+							jsonCandidate = line + "\n" + jsonCandidate
+						}
+
+						// If we've closed all braces, we have a complete JSON object
+						if (startCollecting && braceCount === 0) {
+							break
+						}
+					}
+
+					if (jsonCandidate.trim()) {
+						try {
+							// Trim everything before the first opening bracket
+							const trimmedCandidate = jsonCandidate.trim()
+							const firstBraceIndex = trimmedCandidate.indexOf("{")
+							const cleanedJson =
+								firstBraceIndex !== -1 ? trimmedCandidate.slice(firstBraceIndex) : trimmedCandidate
+
+							const outputData = JSON.parse(cleanedJson)
+
+							// Validate structure
+							const validation = validateHookOutput(outputData)
+							if (!validation.valid) {
+								// Return null to indicate parsing failed
+								return null
+							}
+
+							const output = HookOutput.fromJSON(outputData)
+
+							// Validate and truncate context modification if too large
+							if (output.contextModification && output.contextModification.length > MAX_CONTEXT_MODIFICATION_SIZE) {
+								Logger.warn(
+									`Hook ${this.hookName} returned contextModification of ${output.contextModification.length} bytes, ` +
+										`truncating to ${MAX_CONTEXT_MODIFICATION_SIZE} bytes`,
+								)
+								output.contextModification =
+									output.contextModification.slice(0, MAX_CONTEXT_MODIFICATION_SIZE) +
+									"\n\n[... context truncated due to size limit ...]"
+							}
+
+							return output
+						} catch (_extractError) {
+							// Couldn't extract valid JSON, return null
+							return null
+						}
+					}
+
+					// Couldn't parse JSON at all, return null
+					return null
+				}
+			}
+
+			const parsedOutput = parseJsonOutput()
+
+			// If we have valid JSON, honor it regardless of exit code
+			if (parsedOutput) {
+				const durationMs = performance.now() - startTime
+
+				// Log warning if non-zero exit but valid JSON (for developers)
+				if (exitCode !== 0) {
+					Logger.warn(`[Hook ${this.hookName}] Exited with code ${exitCode} but provided valid JSON response`)
+					if (stderr) {
+						Logger.warn(`[Hook ${this.hookName}] stderr: ${stderr}`)
+					}
+				}
+
+				// Capture success/cancellation telemetry
+				if (taskId) {
+					if (parsedOutput.cancel) {
+						telemetryService.safeCapture(
+							() =>
+								telemetryService.captureHookExecution(taskId, this.hookName, "completed", {
+									source: this.source,
+									toolName: this.toolName,
+									durationMs,
+									exitCode: exitCode ?? EXIT_CODE_SIGINT,
+									cancelRequested: true,
+									contextModified: !!parsedOutput.contextModification,
+									contextSize: parsedOutput.contextModification?.length,
+								}),
+							"HookFactory.exec.completed.cancel",
+						)
+					} else {
+						telemetryService.safeCapture(
+							() =>
+								telemetryService.captureHookExecution(taskId, this.hookName, "completed", {
+									source: this.source,
+									toolName: this.toolName,
+									durationMs,
+									exitCode: exitCode ?? 0,
+									cancelRequested: false,
+									contextModified: !!parsedOutput.contextModification,
+									contextSize: parsedOutput.contextModification?.length,
+								}),
+							"HookFactory.exec.completed.success",
+						)
+					}
+				}
+
+				return parsedOutput
+			}
+
+			// No valid JSON found
+			if (exitCode === 0) {
+				// Hook succeeded but didn't provide JSON - allow execution (no cancellation)
+				Logger.warn(`[Hook ${this.hookName}] Completed successfully but no JSON response found`)
+				const durationMs = performance.now() - startTime
+
+				// Capture success telemetry even without JSON
+				if (taskId) {
+					telemetryService.safeCapture(
+						() =>
+							telemetryService.captureHookExecution(taskId, this.hookName, "completed", {
+								source: this.source,
+								toolName: this.toolName,
+								durationMs,
+								exitCode: 0,
+								cancelRequested: false,
+								contextModified: false,
+							}),
+						"HookFactory.exec.completed.noJson",
+					)
+				}
+
+				return HookOutput.create({
+					cancel: false,
+				})
+			}
+			// Hook failed with non-zero exit - include hook name in error
+			throw HookExecutionError.execution(this.scriptPath, exitCode ?? 1, stderr, this.hookName)
+		} catch (error) {
+			const durationMs = performance.now() - startTime
+
+			// If it's already a HookExecutionError, re-throw it
+			if (HookExecutionError.isHookError(error)) {
+				// Capture failure telemetry based on error type
+				if (taskId) {
+					if (error.errorInfo.type === "cancellation") {
+						telemetryService.safeCapture(
+							() =>
+								telemetryService.captureHookExecution(taskId, this.hookName, "cancelled", {
+									source: this.source,
+									toolName: this.toolName,
+								}),
+							"HookFactory.exec.error.cancellation",
+						)
+					} else if (error.errorInfo.type === "timeout") {
+						telemetryService.safeCapture(
+							() =>
+								telemetryService.captureHookExecution(taskId, this.hookName, "failed", {
+									source: this.source,
+									toolName: this.toolName,
+									durationMs,
+									errorType: "timeout",
+									errorMessage: error.message,
+								}),
+							"HookFactory.exec.error.timeout",
+						)
+					} else {
+						telemetryService.safeCapture(
+							() =>
+								telemetryService.captureHookExecution(taskId, this.hookName, "failed", {
+									source: this.source,
+									toolName: this.toolName,
+									durationMs,
+									exitCode: error.errorInfo.exitCode ?? 1,
+									errorType: error.errorInfo.type as "execution" | "timeout" | "validation",
+									errorMessage: error.message,
+								}),
+							"HookFactory.exec.error.failed",
+						)
+					}
+				}
+				throw error
+			}
+
+			// Hook execution failed - categorize the error
+			const stderr = hookProcess.getStderr()
+			const exitCode = hookProcess.getExitCode()
+
+			// Check for timeout
+			if (error instanceof Error && error.message.includes("timed out")) {
+				if (taskId) {
+					telemetryService.safeCapture(
+						() =>
+							telemetryService.captureHookExecution(taskId, this.hookName, "failed", {
+								source: this.source,
+								toolName: this.toolName,
+								durationMs,
+								errorType: "timeout",
+								errorMessage: error.message,
+							}),
+						"HookFactory.exec.catch.timeout",
+					)
+				}
+				throw HookExecutionError.timeout(this.scriptPath, HOOK_EXECUTION_TIMEOUT_MS, stderr, this.hookName)
+			}
+
+			// Check for cancellation
+			if (error instanceof Error && error.message.includes("cancelled")) {
+				if (taskId) {
+					telemetryService.safeCapture(
+						() =>
+							telemetryService.captureHookExecution(taskId, this.hookName, "cancelled", {
+								source: this.source,
+								toolName: this.toolName,
+							}),
+						"HookFactory.exec.catch.cancelled",
+					)
+				}
+				throw HookExecutionError.cancellation(this.scriptPath, this.hookName)
+			}
+
+			// Generic execution error - include hook name
+			if (taskId) {
+				telemetryService.safeCapture(
+					() =>
+						telemetryService.captureHookExecution(taskId, this.hookName, "failed", {
+							source: this.source,
+							toolName: this.toolName,
+							durationMs,
+							exitCode: exitCode ?? 1,
+							errorType: "execution",
+							errorMessage: error instanceof Error ? error.message : String(error),
+						}),
+					"HookFactory.exec.catch.execution",
+				)
+			}
+			throw HookExecutionError.execution(this.scriptPath, exitCode ?? 1, stderr, this.hookName)
+		}
+	}
+}
+
+/**
+ * Combines multiple hook runners and executes them in parallel.
+ *
+ * Used in multi-root workspaces where both global hooks (from ~/Documents/Cline/Hooks/)
+ * and workspace-specific hooks (from each workspace's .clinerules/hooks/) exist for the
+ * same hook type.
+ *
+ * Behavior:
+ * - Executes all hooks concurrently using Promise.all
+ * - If ANY hook returns cancel: true, the merged result will have cancel: true
+ * - Concatenates all contextModification strings with double newlines
+ * - Concatenates all errorMessage strings with single newlines
+ *
+ * This means if ANY hook requests cancellation, the task will be cancelled.
+ * All hooks' context contributions are merged into the conversation.
+ *
+ * @template Name The type of hook this runner represents
+ */
+class CombinedHookRunner<Name extends HookName> extends HookRunner<Name> {
+	constructor(
+		hookName: Name,
+		private readonly runners: readonly HookRunner<Name>[],
+	) {
+		super(hookName)
+	}
+
+	override async [exec](input: HookInput): Promise<HookOutput> {
+		// Run all hooks in parallel
+		const results = await Promise.all(this.runners.map((runner) => runner[exec](input)))
+
+		// Merge results:
+		// - If any hook requests cancellation, set cancel to true
+		// - Combine context contributions from all hooks
+		// - Collect any error messages
+
+		const cancel = results.some((result) => result.cancel === true)
+		const contextModification = results
+			.map((result) => result.contextModification?.trim())
+			.filter((mod) => mod)
+			.join("\n\n")
+		const errorMessage = results
+			.map((result) => result.errorMessage?.trim())
+			.filter((msg) => msg)
+			.join("\n")
+
+		return HookOutput.create({
+			cancel,
+			contextModification,
+			errorMessage,
+		})
+	}
+}
+
+/**
+ * Checks if an error encountered during hook discovery is expected and can be safely ignored.
+ * Expected errors include file not found, permission denied, and invalid path components.
+ *
+ * @param error The error to check
+ * @returns true if this is an expected error that should be silently handled, false if it should be propagated
+ */
+function isExpectedHookError(error: unknown): boolean {
+	if (!(error instanceof Error)) {
+		return false
+	}
+
+	const nodeError = error as NodeJS.ErrnoException
+
+	// Expected: File doesn't exist (most common case)
+	if (nodeError.code === "ENOENT") {
+		return true
+	}
+
+	// Expected: Permission denied (file not executable or not readable)
+	// Note: This is expected because users may have hooks in .clinerules that they don't want to execute
+	if (nodeError.code === "EACCES") {
+		return true
+	}
+
+	// Expected: Not a directory (one of the path components isn't a directory)
+	if (nodeError.code === "ENOTDIR") {
+		return true
+	}
+
+	// All other errors (EIO, EMFILE, etc.) are unexpected and should be propagated
+	return false
+}
+
+export class HookFactory {
+	/**
+	 * Get information about discovered hooks including their script paths
+	 * @param hookName The type of hook to query
+	 * @returns Object containing array of script paths
+	 */
+	async getHookInfo<Name extends HookName>(
+		hookName: Name,
+	): Promise<{
+		scriptPaths: string[]
+	}> {
+		const { HookDiscoveryCache } = await import("./HookDiscoveryCache")
+		const scripts = await HookDiscoveryCache.getInstance().get(hookName)
+		return { scriptPaths: scripts }
+	}
+
+	/**
+	 * Check if any hook scripts exist for the given hook name
+	 * @returns true if at least one hook script exists, false otherwise
+	 */
+	async hasHook<Name extends HookName>(hookName: Name): Promise<boolean> {
+		const scripts = await HookFactory.findHookScripts(hookName)
+		return scripts.length > 0
+	}
+
+	/**
+	 * Create a hook runner without streaming support (backwards compatible)
+	 */
+	async create<Name extends HookName>(hookName: Name, taskId?: string, toolName?: string): Promise<HookRunner<Name>> {
+		return this.createWithStreaming(hookName, undefined, undefined, taskId, toolName)
+	}
+
+	/**
+	 * Create a hook runner with optional streaming callback and abort signal support.
+	 *
+	 * This is the primary factory method for creating hooks. It:
+	 * 1. Uses HookDiscoveryCache to find hook scripts (fast O(1) lookup after first scan)
+	 * 2. Creates StdioHookRunner instances for each discovered script
+	 * 3. Returns NoOpRunner if no scripts found (null-object pattern)
+	 * 4. Returns CombinedHookRunner if multiple scripts found (parallel execution)
+	 *
+	 * The streaming callback receives hook output line-by-line in real-time, allowing
+	 * the UI to display progress as the hook executes. The abort signal enables
+	 * cancellation of long-running hooks.
+	 *
+	 * @param hookName The type of hook to create (e.g., "PreToolUse", "PostToolUse")
+	 * @param streamCallback Optional callback for real-time output streaming
+	 * @param abortSignal Optional signal to cancel hook execution
+	 * @param taskId Optional task ID for telemetry context
+	 * @param toolName Optional tool name for telemetry context
+	 * @returns A HookRunner that executes the hook(s), or NoOpRunner if none found
+	 */
+	async createWithStreaming<Name extends HookName>(
+		hookName: Name,
+		streamCallback?: HookStreamCallback,
+		abortSignal?: AbortSignal,
+		taskId?: string,
+		toolName?: string,
+	): Promise<HookRunner<Name>> {
+		// Use cache for hook discovery instead of direct file system scan
+		const { HookDiscoveryCache } = await import("./HookDiscoveryCache")
+		const scripts = await HookDiscoveryCache.getInstance().get(hookName)
+
+		// Fetch hooks dirs once for source determination and telemetry
+		const hooksDirs = await getAllHooksDirs()
+
+		// Capture hook discovery telemetry
+		// Categorize scripts by location (global vs workspace)
+		const { globalCount, workspaceCount } = this.categorizeHookScripts(scripts, hooksDirs)
+		if (scripts.length > 0) {
+			telemetryService.safeCapture(
+				() => telemetryService.captureHookDiscovery(hookName, globalCount, workspaceCount),
+				"HookFactory.createWithStreaming.discovery",
+			)
+		}
+
+		// Get workspace roots for cwd determination
+		const stateManager = StateManager.get()
+		const workspaceRoots = stateManager.getGlobalStateKey("workspaceRoots")
+		const primaryRootIndex = stateManager.getGlobalStateKey("primaryRootIndex") ?? 0
+		const primaryCwd = workspaceRoots?.[primaryRootIndex]?.path
+
+		// Create runners with source and cwd determination for each script
+		// Global hooks run from primary workspace root
+		// Workspace-specific hooks run from their respective workspace root
+		const runners = scripts.map((script) => {
+			const source = this.determineScriptSource(script, hooksDirs)
+			const cwd = this.determineHookCwd(script, hooksDirs, workspaceRoots, primaryCwd)
+			return new StdioHookRunner(hookName, script, source, streamCallback, abortSignal, taskId, toolName, cwd)
+		})
+
+		if (runners.length === 0) {
+			return new NoOpRunner(hookName)
+		}
+		return runners.length === 1 ? runners[0] : new CombinedHookRunner(hookName, runners)
+	}
+
+	/**
+	 * Checks if a hooks directory is a global hooks directory.
+	 * Global hooks are located in paths containing "Cline/Hooks" or "cline/hooks".
+	 */
+	private static isGlobalHooksDir(dir: string): boolean {
+		return /[/\\][Cc]line[/\\][Hh]ooks/i.test(dir)
+	}
+
+	/**
+	 * Determines if a single script is from global or workspace location
+	 */
+	private determineScriptSource(scriptPath: string, hooksDirs: string[]): "global" | "workspace" {
+		const containingDir = hooksDirs.find((dir) => scriptPath.startsWith(dir))
+		if (containingDir && HookFactory.isGlobalHooksDir(containingDir)) {
+			return "global"
+		}
+		return "workspace" // Default to workspace if uncertain
+	}
+
+	/**
+	 * Determines the working directory for a hook script based on its location.
+	 *
+	 * - Global hooks (from ~/Documents/Cline/Hooks/): run from the primary workspace root
+	 * - Workspace hooks (from workspaceRoot/.clinerules/hooks/): run from that specific workspace root
+	 *
+	 * This ensures workspace-specific hooks can use relative paths that are meaningful
+	 * within their own workspace context.
+	 *
+	 * @param scriptPath The full path to the hook script
+	 * @param hooksDirs Array of all hooks directories
+	 * @param workspaceRoots Array of workspace root objects
+	 * @param primaryCwd The primary workspace root path (fallback)
+	 * @returns The working directory to use for this hook
+	 */
+	private determineHookCwd(
+		scriptPath: string,
+		hooksDirs: string[],
+		workspaceRoots: Array<{ path: string }> | undefined,
+		primaryCwd: string | undefined,
+	): string | undefined {
+		const containingDir = hooksDirs.find((dir) => scriptPath.startsWith(dir))
+
+		// If global hook, use primary workspace root
+		if (containingDir && HookFactory.isGlobalHooksDir(containingDir)) {
+			return primaryCwd
+		}
+
+		// If workspace hook, find which workspace root it belongs to
+		// Workspace hooks are at: workspaceRoot/.clinerules/hooks/
+		// So find the workspace root whose path is a prefix of the containing hooks dir
+		if (containingDir && workspaceRoots) {
+			const workspaceRoot = workspaceRoots.find((root) => containingDir.startsWith(root.path))
+			if (workspaceRoot) {
+				return workspaceRoot.path
+			}
+		}
+
+		// Fallback to primary cwd
+		return primaryCwd
+	}
+
+	/**
+	 * Categorizes hook scripts by their location (global vs workspace).
+	 * Global hooks are located in ~/Documents/Cline/Hooks/
+	 * Workspace hooks are located in workspace .clinerules/hooks/ directories
+	 *
+	 * @param scripts Array of hook script paths
+	 * @param hooksDirs Array of hooks directories (passed to avoid redundant fetches)
+	 * @returns Object with globalCount and workspaceCount
+	 */
+	private categorizeHookScripts(scripts: string[], hooksDirs: string[]): { globalCount: number; workspaceCount: number } {
+		if (scripts.length === 0) {
+			return { globalCount: 0, workspaceCount: 0 }
+		}
+
+		let globalCount = 0
+		let workspaceCount = 0
+
+		for (const script of scripts) {
+			const containingDir = hooksDirs.find((dir) => script.startsWith(dir))
+			if (containingDir && HookFactory.isGlobalHooksDir(containingDir)) {
+				globalCount++
+			} else {
+				workspaceCount++
+			}
+		}
+
+		return { globalCount, workspaceCount }
+	}
+
+	/**
+	 * @returns A list of paths to scripts for the given hook name.
+	 * Includes both global hooks (from ~/Documents/Cline/Hooks/) and workspace hooks
+	 * (from .clinerules/hooks/ in each workspace root).
+	 */
+	private static async findHookScripts(hookName: HookName): Promise<string[]> {
+		const hookScripts = []
+		for (const hooksDir of await getAllHooksDirs()) {
+			hookScripts.push(HookFactory.findHookInHooksDir(hookName, hooksDir))
+		}
+		const isDefined = (scriptPath: string | undefined): scriptPath is string => Boolean(scriptPath)
+		return (await Promise.all(hookScripts)).filter(isDefined)
+	}
+
+	/**
+	 * Finds the path to a hook in a .clinerules hooks directory.
+	 *
+	 * @param hookName the name of the hook to search for, for example 'PreToolUse'
+	 * @param hooksDir the .clinerules directory path to search
+	 * @returns the path to the hook to execute, or undefined if none found
+	 * @throws Error if an unexpected file system error occurs
+	 */
+	static async findHookInHooksDir(hookName: HookName, hooksDir: string): Promise<string | undefined> {
+		return process.platform === "win32"
+			? HookFactory.findWindowsHook(hookName, hooksDir)
+			: HookFactory.findUnixHook(hookName, hooksDir)
+	}
+
+	/**
+	 * Finds a hook on Windows by checking for a PowerShell hook file (`<HookName>.ps1`).
+	 *
+	 * Extensionless hooks are intentionally ignored on Windows.
+	 *
+	 * Why: Windows hooks execute via PowerShell (`powershell -File ...`).
+	 * The supported contract is an explicit PowerShell script file per hook type.
+	 *
+	 * @param hookName the name of the hook to search for
+	 * @param hooksDir the hooks directory path to search
+	 * @returns the path to the hook to execute, or undefined if none found
+	 * @throws Error if an unexpected file system error occurs
+	 */
+	private static async findWindowsHook(hookName: HookName, hooksDir: string): Promise<string | undefined> {
+		const powerShell = path.join(hooksDir, `${hookName}.ps1`)
+		const powerShellExists = await HookFactory.isHookFile(powerShell, hookName)
+
+		if (powerShellExists) {
+			return powerShell
+		}
+
+		return undefined
+	}
+
+	private static async isHookFile(candidate: string, hookName: HookName): Promise<boolean> {
+		try {
+			const stat = await fs.stat(candidate)
+			return stat.isFile()
+		} catch (error) {
+			HookFactory.handleHookDiscoveryError(error, hookName, candidate)
+			return false
+		}
+	}
+
+	/**
+	 * Finds a hook on Unix-like systems (Linux, macOS) by checking for an executable file.
+	 *
+	 * `.ps1` hook files are intentionally ignored on Unix platforms.
+	 *
+	 * Why: Unix hooks use executable-file semantics (bash scripts, binaries, etc.)
+	 * with canonical extensionless hook names.
+	 *
+	 * @param hookName the name of the hook to search for
+	 * @param hooksDir the .clinerules directory path to search
+	 * @returns the path to the hook to execute, or undefined if none found
+	 * @throws Error if an unexpected file system error occurs
+	 */
+	private static async findUnixHook(hookName: HookName, hooksDir: string): Promise<string | undefined> {
+		const candidate = path.join(hooksDir, hookName)
+
+		try {
+			const [stat, _] = await Promise.all([fs.stat(candidate), fs.access(candidate, fs.constants.X_OK)])
+			return stat.isFile() ? candidate : undefined
+		} catch (error) {
+			HookFactory.handleHookDiscoveryError(error, hookName, candidate)
+			// Expected errors (missing/non-executable hook) return no match.
+			return undefined
+		}
+	}
+
+	/**
+	 * Handles errors encountered during hook discovery.
+	 * Expected errors (file not found, permission denied, etc.) are silently ignored.
+	 * Unexpected errors are propagated with context.
+	 *
+	 * @param error the error that occurred
+	 * @param hookName the name of the hook being searched for
+	 * @param candidate the file path that was being checked
+	 * @throws Error if the error is unexpected
+	 */
+	private static handleHookDiscoveryError(error: unknown, hookName: HookName, candidate: string): void {
+		if (!isExpectedHookError(error)) {
+			throw new Error(
+				`Unexpected error while searching for hook '${hookName}' at '${candidate}': ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			)
+		}
+	}
+}
diff --git a/apps/vscode/src/core/hooks/hooks-utils.ts b/apps/vscode/src/core/hooks/hooks-utils.ts
new file mode 100644
index 0000000..5863f0a
--- /dev/null
+++ b/apps/vscode/src/core/hooks/hooks-utils.ts
@@ -0,0 +1,8 @@
+/**
+ * Computes the effective hooks-enabled state from persisted user setting.
+ *
+ * NOTE: This is the single choke point used by runtime and UI state shaping.
+ */
+export function getHooksEnabledSafe(userSetting: boolean | undefined): boolean {
+	return userSetting ?? true
+}
diff --git a/apps/vscode/src/core/hooks/shell-escape.ts b/apps/vscode/src/core/hooks/shell-escape.ts
new file mode 100644
index 0000000..c3b81a1
--- /dev/null
+++ b/apps/vscode/src/core/hooks/shell-escape.ts
@@ -0,0 +1,67 @@
+/**
+ * Platform-specific shell escaping utilities for hook script paths.
+ * Ensures paths with spaces and special characters work correctly when
+ * executed through a shell (shell: true in spawn).
+ */
+
+/**
+ * Escapes a path for safe use in a Windows shell command.
+ * Handles spaces, quotes, and other special characters.
+ *
+ * Windows shell (cmd.exe) rules:
+ * - Wrap path in double quotes
+ * - Escape double quotes by doubling them ("")
+ * - Backslashes before quotes need to be doubled
+ *
+ * @param path The file path to escape
+ * @returns The escaped path safe for Windows shell execution
+ */
+function escapeWindowsShellPath(path: string): string {
+	// Escape backslashes that precede quotes
+	let escaped = path.replace(/\\"/g, '\\\\"')
+	// Escape standalone double quotes by doubling them
+	escaped = escaped.replace(/"/g, '""')
+	// Wrap in double quotes
+	return `"${escaped}"`
+}
+
+/**
+ * Escapes a path for safe use in a Unix shell command (sh, bash, zsh).
+ * Handles spaces, quotes, apostrophes, and other special characters.
+ *
+ * Unix shell rules:
+ * - Wrap path in single quotes (safest for most characters)
+ * - Single quotes inside path are escaped as '\''
+ *   (close quote, escaped quote, open quote)
+ *
+ * @param path The file path to escape
+ * @returns The escaped path safe for Unix shell execution
+ */
+function escapeUnixShellPath(path: string): string {
+	// Replace single quotes with '\'' (close quote, escaped quote, open quote)
+	const escaped = path.replace(/'/g, "'\\''")
+	// Wrap in single quotes
+	return `'${escaped}'`
+}
+
+/**
+ * Escapes a file path for safe shell execution on any platform.
+ * This is critical when using spawn() with shell: true and paths that
+ * may contain spaces or special characters.
+ *
+ * Use cases:
+ * - Global hooks directory: ~/Documents/Cline/Hooks/
+ * - Workspace hooks: /path/to/My Project/.clinerules/hooks/
+ * - Multi-root workspaces: each root's .clinerules/hooks/
+ *
+ * Examples:
+ * - "/Users/user/My Project/hooks/PreToolUse" → "'/Users/user/My Project/hooks/PreToolUse'"
+ * - "C:\Users\user\My Project\hooks\PreToolUse" → '"C:\Users\user\My Project\hooks\PreToolUse"'
+ * - "/path/with 'quotes'/hooks/PreToolUse" → "'/path/with '\''quotes'\'' /hooks/PreToolUse'"
+ *
+ * @param path The file path to escape
+ * @returns The escaped path safe for shell execution on the current platform
+ */
+export function escapeShellPath(path: string): string {
+	return process.platform === "win32" ? escapeWindowsShellPath(path) : escapeUnixShellPath(path)
+}
diff --git a/apps/vscode/src/core/hooks/templates.ts b/apps/vscode/src/core/hooks/templates.ts
new file mode 100644
index 0000000..8d2f841
--- /dev/null
+++ b/apps/vscode/src/core/hooks/templates.ts
@@ -0,0 +1,494 @@
+/**
+ * Hook script templates for all supported hook types.
+ * On Unix, templates are Bash scripts with comprehensive examples.
+ * On Windows, templates are PowerShell scripts executed by the Windows hook runtime.
+ */
+
+export function getHookTemplate(hookName: string): string {
+	if (process.platform === "win32") {
+		return getWindowsPowerShellTemplate(hookName)
+	}
+
+	const templates: Record<string, string> = {
+		TaskStart: getTaskStartTemplate(),
+		TaskResume: getTaskResumeTemplate(),
+		TaskCancel: getTaskCancelTemplate(),
+		TaskComplete: getTaskCompleteTemplate(),
+		PreToolUse: getPreToolUseTemplate(),
+		PostToolUse: getPostToolUseTemplate(),
+		UserPromptSubmit: getUserPromptSubmitTemplate(),
+		Notification: getNotificationTemplate(),
+		PreCompact: getPreCompactTemplate(),
+	}
+
+	return templates[hookName] || getDefaultTemplate(hookName)
+}
+
+function getWindowsPowerShellTemplate(hookName: string): string {
+	return `# ${hookName} Hook
+# PowerShell template for Windows hook execution.
+
+try {
+    $rawInput = [Console]::In.ReadToEnd()
+    if ($rawInput) {
+        $null = $rawInput | ConvertFrom-Json
+    }
+} catch {
+    Write-Error "[${hookName}] Invalid JSON input: $($_.Exception.Message)"
+}
+
+@{
+    cancel = $false
+    contextModification = ""
+    errorMessage = ""
+} | ConvertTo-Json -Compress
+`
+}
+
+function getTaskStartTemplate(): string {
+	return `#!/bin/bash
+#
+# TaskStart Hook
+# 
+# Executes when a new task begins.
+# 
+# Input: { 
+#   taskId, 
+#   taskStart: { 
+#     taskMetadata: { taskId: string, ulid: string, initialTask: string } 
+#   }, 
+#   clineVersion, timestamp, ... 
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Log task start time
+# - Add context about environment or project state
+# - Check prerequisites before starting
+# - Notify external systems (Slack, issue trackers, etc.)
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TASK=$(echo "$INPUT" | jq -r '.taskStart.taskMetadata.initialTask')
+  TASK_ID=$(echo "$INPUT" | jq -r '.taskId')
+  TIMESTAMP=$(echo "$INPUT" | jq -r '.timestamp')
+else
+  # Fallback if jq is not available
+  TASK="<task>"
+  TASK_ID="<taskId>"
+  TIMESTAMP=$(date +%s%3N)
+fi
+
+# Example: Log task start
+echo "[TaskStart] Task started: $TASK" >&2
+echo "[TaskStart] Task ID: $TASK_ID" >&2
+
+# Example: Add context to the task
+TIMESTAMP_ISO=$(date -u -d @"$((TIMESTAMP/1000))" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date -u +"%Y-%m-%dT%H:%M:%SZ")
+CONTEXT_MOD="Note: Task started at $TIMESTAMP_ISO"
+
+# Return result as JSON (use jq to safely encode the variable, with a simple fallback)
+if command -v jq &> /dev/null; then
+  jq -n --arg ctx "$CONTEXT_MOD" '{"cancel":false,"contextModification":$ctx,"errorMessage":""}'
+else
+  ESCAPED_MOD=$(printf '%s' "$CONTEXT_MOD" | sed 's/\\\\/\\\\\\\\/g; s/"/\\\\"/g')
+  echo '{"cancel":false,"contextModification":"'"$ESCAPED_MOD"'","errorMessage":""}'
+fi
+`
+}
+
+function getTaskResumeTemplate(): string {
+	return `#!/bin/bash
+#
+# TaskResume Hook
+# 
+# Executes when a task is resumed after being interrupted.
+# 
+# Input: { 
+#   taskId, 
+#   taskResume: { 
+#     taskMetadata: { taskId: string, ulid: string },
+#     previousState: { lastMessageTs: string, messageCount: string, conversationHistoryDeleted: string }
+#   }, 
+#   clineVersion, timestamp, ... 
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Check for changes since task was paused
+# - Refresh context with latest project state
+# - Notify that work is resuming
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TASK_ID=$(echo "$INPUT" | jq -r '.taskResume.taskMetadata.taskId')
+  MSG_COUNT=$(echo "$INPUT" | jq -r '.taskResume.previousState.messageCount')
+else
+  TASK_ID="<taskId>"
+  MSG_COUNT="0"
+fi
+
+echo "[TaskResume] Resuming task: $TASK_ID (previous messages: $MSG_COUNT)" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getTaskCancelTemplate(): string {
+	return `#!/bin/bash
+#
+# TaskCancel Hook
+# 
+# Executes when a task is cancelled by the user.
+# 
+# Input: { 
+#   taskId, 
+#   taskCancel: { 
+#     taskMetadata: { taskId: string, ulid: string, completionStatus: string } 
+#   }, 
+#   clineVersion, timestamp, ... 
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Clean up temporary files or resources
+# - Notify external systems about cancellation
+# - Log cancellation for analytics
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TASK_ID=$(echo "$INPUT" | jq -r '.taskCancel.taskMetadata.taskId')
+  STATUS=$(echo "$INPUT" | jq -r '.taskCancel.taskMetadata.completionStatus')
+else
+  TASK_ID="<taskId>"
+  STATUS="cancelled"
+fi
+
+echo "[TaskCancel] Task cancelled: $TASK_ID (status: $STATUS)" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getTaskCompleteTemplate(): string {
+	return `#!/bin/bash
+#
+# TaskComplete Hook
+# 
+# Executes when a task completes successfully.
+# 
+# Input: { 
+#   taskId, 
+#   taskComplete: { 
+#     taskMetadata: { taskId: string, ulid: string, result: string, command: string } 
+#   }, 
+#   clineVersion, timestamp, ... 
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Run tests or validation
+# - Generate reports or summaries
+# - Notify stakeholders
+# - Trigger CI/CD pipelines
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TASK_ID=$(echo "$INPUT" | jq -r '.taskComplete.taskMetadata.taskId')
+  RESULT=$(echo "$INPUT" | jq -r '.taskComplete.taskMetadata.result')
+else
+  TASK_ID="<taskId>"
+  RESULT="<result>"
+fi
+
+echo "[TaskComplete] Task completed: $TASK_ID (result: $RESULT)" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getPreToolUseTemplate(): string {
+	return `#!/bin/bash
+#
+# PreToolUse Hook
+# 
+# Executes before any tool is used (read_file, write_to_file, execute_command, etc.)
+# 
+# Input: { taskId, preToolUse: { toolName: string, parameters: object }, ... }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Block dangerous operations
+# - Add safety checks before file modifications
+# - Log tool usage
+# - Validate parameters before execution
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TOOL=$(echo "$INPUT" | jq -r '.preToolUse.toolName')
+  COMMAND=$(echo "$INPUT" | jq -r '.preToolUse.parameters.command // empty')
+else
+  TOOL="<tool>"
+  COMMAND=""
+fi
+
+# Example: Block dangerous operations
+if [[ "$TOOL" == "execute_command" ]] && [[ "$COMMAND" == *"rm -rf /"* ]]; then
+  echo '{"cancel":true,"errorMessage":"Dangerous command blocked by PreToolUse hook"}'
+  exit 0
+fi
+
+# Example: Log tool usage
+echo "[PreToolUse] Tool about to execute: $TOOL" >&2
+
+# Allow execution
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getPostToolUseTemplate(): string {
+	return `#!/bin/bash
+#
+# PostToolUse Hook
+# 
+# Executes after any tool is used successfully or fails.
+# 
+# Input: { 
+#   taskId, 
+#   postToolUse: { 
+#     toolName: string, 
+#     parameters: object,
+#     result: string,
+#     success: boolean,
+#     executionTimeMs: number
+#   }, 
+#   ... 
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Audit tool usage
+# - Validate results
+# - Trigger follow-up actions
+# - Monitor performance
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TOOL=$(echo "$INPUT" | jq -r '.postToolUse.toolName')
+  SUCCESS=$(echo "$INPUT" | jq -r '.postToolUse.success')
+  DURATION=$(echo "$INPUT" | jq -r '.postToolUse.executionTimeMs')
+else
+  TOOL="<tool>"
+  SUCCESS="true"
+  DURATION="0"
+fi
+
+# Log tool completion
+STATUS="success"
+[[ "$SUCCESS" == "false" ]] && STATUS="failed"
+echo "[PostToolUse] Tool completed: $TOOL ($STATUS) in \${DURATION}ms" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getUserPromptSubmitTemplate(): string {
+	return `#!/bin/bash
+#
+# UserPromptSubmit Hook
+# 
+# Executes when the user submits a prompt to Cline.
+# 
+# Input: { taskId, userPromptSubmit: { prompt: string, attachments: string[] }, clineVersion, timestamp, ... }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Log user prompts for analytics
+# - Add context based on prompt content
+# - Validate or sanitize prompts
+# - Trigger external integrations
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  PROMPT=$(echo "$INPUT" | jq -r '.userPromptSubmit.prompt')
+  PROMPT_LENGTH=\${#PROMPT}
+else
+  PROMPT_LENGTH=0
+fi
+
+echo "[UserPromptSubmit] User submitted prompt (length: $PROMPT_LENGTH)" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getNotificationTemplate(): string {
+	return `#!/bin/bash
+#
+# Notification Hook
+#
+# Executes when Cline reaches a user-attention boundary or emits lifecycle notifications.
+#
+# Input: {
+#   taskId,
+#   notification: {
+#     event: string,
+#     source: string,
+#     message: string,
+#     waitingForUserInput: boolean,
+#     eventVersion: string,
+#     eventId: string,
+#     messageTruncated: boolean,
+#     sourceType: string,
+#     sourceId: string,
+#     requiresUserAction: boolean,
+#     severity: string
+#   },
+#   clineVersion,
+#   timestamp,
+#   ...
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+#
+# Typical events:
+# - user_attention (ask prompt requiring user input)
+# - task_complete (task reached completion)
+#
+# Notification hooks are observation-only:
+# - cancel is ignored by the caller
+# - contextModification is ignored by the caller
+# - hook failures are non-fatal
+
+INPUT=$(cat)
+
+if command -v jq &> /dev/null; then
+  EVENT=$(echo "$INPUT" | jq -r '.notification.event // "unknown"')
+  SOURCE=$(echo "$INPUT" | jq -r '.notification.source // "unknown"')
+  WAITING=$(echo "$INPUT" | jq -r '.notification.waitingForUserInput // false')
+  EVENT_VERSION=$(echo "$INPUT" | jq -r '.notification.eventVersion // "unknown"')
+  SOURCE_TYPE=$(echo "$INPUT" | jq -r '.notification.sourceType // "unknown"')
+  REQUIRES_ACTION=$(echo "$INPUT" | jq -r '.notification.requiresUserAction // false')
+  SEVERITY=$(echo "$INPUT" | jq -r '.notification.severity // "info"')
+else
+  EVENT="unknown"
+  SOURCE="unknown"
+  WAITING="false"
+  EVENT_VERSION="unknown"
+  SOURCE_TYPE="unknown"
+  REQUIRES_ACTION="false"
+  SEVERITY="info"
+fi
+
+echo "[Notification] event=$EVENT source=$SOURCE sourceType=$SOURCE_TYPE waitingForUserInput=$WAITING requiresUserAction=$REQUIRES_ACTION severity=$SEVERITY eventVersion=$EVENT_VERSION" >&2
+
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getPreCompactTemplate(): string {
+	return `#!/bin/bash
+#
+# PreCompact Hook
+# 
+# Executes before conversation context is compacted (to free up token space).
+# 
+# Input: { 
+#   taskId, 
+#   preCompact: { 
+#     taskId: string,
+#     ulid: string,
+#     contextSize: number,
+#     compactionStrategy: string,
+#     previousApiReqIndex: number,
+#     tokensIn: number,
+#     tokensOut: number,
+#     tokensInCache: number,
+#     tokensOutCache: number,
+#     deletedRangeStart: number,
+#     deletedRangeEnd: number,
+#     contextJsonPath: string,
+#     contextRawPath: string
+#   }, 
+#   ... 
+# }
+# Output: { cancel: boolean, contextModification?: string, errorMessage?: string }
+# 
+# Use cases:
+# - Archive important conversation parts
+# - Log compaction events
+# - Add summary before context is lost
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  CONTEXT_SIZE=$(echo "$INPUT" | jq -r '.preCompact.contextSize')
+  STRATEGY=$(echo "$INPUT" | jq -r '.preCompact.compactionStrategy')
+  TOKENS_IN=$(echo "$INPUT" | jq -r '.preCompact.tokensIn')
+  TOKENS_OUT=$(echo "$INPUT" | jq -r '.preCompact.tokensOut')
+else
+  CONTEXT_SIZE="<size>"
+  STRATEGY="<strategy>"
+  TOKENS_IN="<tokens>"
+  TOKENS_OUT="<tokens>"
+fi
+
+echo "[PreCompact] About to compact conversation (contextSize: $CONTEXT_SIZE, strategy: $STRATEGY, tokensIn: $TOKENS_IN, tokensOut: $TOKENS_OUT)" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
+
+function getDefaultTemplate(hookName: string): string {
+	return `#!/bin/bash
+#
+# ${hookName} Hook
+# 
+# Input: JSON via stdin
+# Output: JSON to stdout
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Parse input using jq (or fallback to basic parsing)
+if command -v jq &> /dev/null; then
+  TASK_ID=$(echo "$INPUT" | jq -r '.taskId')
+else
+  TASK_ID="<taskId>"
+fi
+
+# Your hook logic here
+echo "[${hookName}] Executed for task $TASK_ID" >&2
+
+# Return result
+echo '{"cancel":false,"contextModification":"","errorMessage":""}'
+`
+}
diff --git a/apps/vscode/src/core/hooks/utils.ts b/apps/vscode/src/core/hooks/utils.ts
new file mode 100644
index 0000000..e55f119
--- /dev/null
+++ b/apps/vscode/src/core/hooks/utils.ts
@@ -0,0 +1,114 @@
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { getCwd, getDesktopDir } from "@/utils/path"
+
+/**
+ * All valid hook types that can be created and executed by Cline.
+ * These hooks correspond to specific lifecycle events in the task execution process.
+ */
+export const VALID_HOOK_TYPES = [
+	"TaskStart",
+	"TaskResume",
+	"TaskCancel",
+	"TaskComplete",
+	"PreToolUse",
+	"PostToolUse",
+	"UserPromptSubmit",
+	"Notification",
+	"PreCompact",
+] as const
+
+/**
+ * Type representing a valid hook name
+ */
+export type HookType = (typeof VALID_HOOK_TYPES)[number]
+
+/**
+ * Validates if a given hook name is a valid hook type.
+ *
+ * @param hookName - The hook name to validate
+ * @returns True if the hook name is valid, false otherwise
+ */
+export function isValidHookType(hookName: string): hookName is HookType {
+	return VALID_HOOK_TYPES.includes(hookName as HookType)
+}
+
+/**
+ * Resolves the hooks directory path for either global or workspace hooks.
+ * Handles both single and multi-root workspaces.
+ *
+ * @param isGlobal - Whether to resolve the global hooks directory
+ * @param workspaceName - For multi-root workspaces, the name of the specific workspace
+ * @param globalHooksDirOverride - Optional override for global hooks directory (for testing)
+ * @returns The absolute path to the hooks directory
+ * @throws Error if the specified workspace cannot be found
+ */
+export async function resolveHooksDirectory(
+	isGlobal: boolean,
+	workspaceName?: string,
+	globalHooksDirOverride?: string,
+): Promise<string> {
+	if (isGlobal) {
+		return globalHooksDirOverride || path.join(os.homedir(), "Documents", "Cline", "Hooks")
+	}
+
+	// For workspace hooks, find the correct workspace
+	if (workspaceName) {
+		// Multi-root workspace: find the workspace with this name
+		const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
+		const targetWorkspace = workspacePaths.paths.find((p) => path.basename(p) === workspaceName)
+		if (!targetWorkspace) {
+			throw new Error(`Workspace "${workspaceName}" not found`)
+		}
+		return path.join(targetWorkspace, ".clinerules", "hooks")
+	}
+
+	// Single workspace: use getCwd
+	const cwd = await getCwd(getDesktopDir())
+	return path.join(cwd, ".clinerules", "hooks")
+}
+
+/**
+ * Resolves the active hook file path for a given hook name.
+ *
+ * Platform-specific filename rules are intentionally strict:
+ *
+ * On Windows, only PowerShell-native naming is supported:
+ * - <HookName>.ps1
+ *
+ * Why: Windows hooks execute via PowerShell (`powershell -File ...`).
+ * PowerShell cannot execute bash-style extensionless hook files as-is.
+ *
+ * On Unix-like platforms (Linux/macOS), only canonical extensionless names are considered:
+ * - <HookName>
+ *
+ * Why: Unix hooks are discovered/executed as native executable files
+ * (bash scripts, binaries, etc.) using executable-bit semantics.
+ * `.ps1` files are not part of the supported Unix hook contract.
+ *
+ * @param hooksDir Directory containing hook files
+ * @param hookName Hook type/name to resolve
+ * @returns Resolved absolute file path if present, otherwise undefined
+ */
+export async function resolveExistingHookPath(hooksDir: string, hookName: string): Promise<string | undefined> {
+	const candidates = process.platform === "win32" ? [path.join(hooksDir, `${hookName}.ps1`)] : [path.join(hooksDir, hookName)]
+
+	for (const candidate of candidates) {
+		if (await isRegularFile(candidate)) {
+			return candidate
+		}
+	}
+
+	return undefined
+}
+
+async function isRegularFile(filePath: string): Promise<boolean> {
+	try {
+		const stat = await fs.stat(filePath)
+		return stat.isFile()
+	} catch {
+		return false
+	}
+}
diff --git a/apps/vscode/src/core/ignore/ClineIgnoreController.test.ts b/apps/vscode/src/core/ignore/ClineIgnoreController.test.ts
new file mode 100644
index 0000000..a282322
--- /dev/null
+++ b/apps/vscode/src/core/ignore/ClineIgnoreController.test.ts
@@ -0,0 +1,293 @@
+import { after, beforeEach, describe, it } from "mocha"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { ClineIgnoreController } from "./ClineIgnoreController"
+import "should"
+
+describe("ClineIgnoreController", () => {
+	let tempDir: string
+	let controller: ClineIgnoreController
+
+	beforeEach(async () => {
+		// Create a temp directory for testing
+		tempDir = path.join(os.tmpdir(), `llm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir)
+
+		// Create default .clineignore file
+		await fs.writeFile(
+			path.join(tempDir, ".clineignore"),
+			[".env", "*.secret", "private/", "# This is a comment", "", "temp.*", "file-with-space-at-end.* ", "**/.git/**"].join(
+				"\n",
+			),
+		)
+
+		controller = new ClineIgnoreController(tempDir)
+		await controller.initialize()
+	})
+
+	after(async () => {
+		// Clean up temp directory
+		await fs.rm(tempDir, { recursive: true, force: true })
+	})
+
+	describe("Default Patterns", () => {
+		// it("should block access to common ignored files", async () => {
+		// 	const results = [
+		// 		controller.validateAccess(".env"),
+		// 		controller.validateAccess(".git/config"),
+		// 		controller.validateAccess("node_modules/package.json"),
+		// 	]
+		// 	results.forEach((result) => result.should.be.false())
+		// })
+
+		it("should allow access to regular files", async () => {
+			const results = [
+				controller.validateAccess("src/index.ts"),
+				controller.validateAccess("README.md"),
+				controller.validateAccess("package.json"),
+			]
+			results.forEach((result) => result.should.be.true())
+		})
+
+		it("should block access to .clineignore file", async () => {
+			const result = controller.validateAccess(".clineignore")
+			result.should.be.false()
+		})
+	})
+
+	describe("Custom Patterns", () => {
+		it("should block access to custom ignored patterns", async () => {
+			const results = [
+				controller.validateAccess("config.secret"),
+				controller.validateAccess("private/data.txt"),
+				controller.validateAccess("temp.json"),
+				controller.validateAccess("nested/deep/file.secret"),
+				controller.validateAccess("private/nested/deep/file.txt"),
+			]
+			results.forEach((result) => result.should.be.false())
+		})
+
+		it("should allow access to non-ignored files", async () => {
+			const results = [
+				controller.validateAccess("public/data.txt"),
+				controller.validateAccess("config.json"),
+				controller.validateAccess("src/temp/file.ts"),
+				controller.validateAccess("nested/deep/file.txt"),
+				controller.validateAccess("not-private/data.txt"),
+			]
+			results.forEach((result) => result.should.be.true())
+		})
+
+		it("should handle pattern edge cases", async () => {
+			await fs.writeFile(
+				path.join(tempDir, ".clineignore"),
+				["*.secret", "private/", "*.tmp", "data-*.json", "temp/*"].join("\n"),
+			)
+
+			controller = new ClineIgnoreController(tempDir)
+			await controller.initialize()
+
+			const results = [
+				controller.validateAccess("data-123.json"), // Should be false (wildcard)
+				controller.validateAccess("data.json"), // Should be true (doesn't match pattern)
+				controller.validateAccess("script.tmp"), // Should be false (extension match)
+			]
+
+			results[0].should.be.false() // data-123.json
+			results[1].should.be.true() // data.json
+			results[2].should.be.false() // script.tmp
+		})
+
+		// ToDo: handle negation patterns successfully
+
+		// it("should handle negation patterns", async () => {
+		// 	await fs.writeFile(
+		// 		path.join(tempDir, ".clineignore"),
+		// 		[
+		// 			"temp/*", // Ignore everything in temp
+		// 			"!temp/allowed/*", // But allow files in temp/allowed
+		// 			"docs/**/*.md", // Ignore all markdown files in docs
+		// 			"!docs/README.md", // Except README.md
+		// 			"!docs/CONTRIBUTING.md", // And CONTRIBUTING.md
+		// 			"assets/", // Ignore all assets
+		// 			"!assets/public/", // Except public assets
+		// 			"!assets/public/*.png", // Specifically allow PNGs in public assets
+		// 		].join("\n"),
+		// 	)
+
+		// 	controller = new ClineIgnoreController(tempDir)
+
+		// 	const results = [
+		// 		// Basic negation
+		// 		controller.validateAccess("temp/file.txt"), // Should be false (in temp/)
+		// 		controller.validateAccess("temp/allowed/file.txt"), // Should be true (negated)
+		// 		controller.validateAccess("temp/allowed/nested/file.txt"), // Should be true (negated with nested)
+
+		// 		// Multiple negations in same path
+		// 		controller.validateAccess("docs/guide.md"), // Should be false (matches docs/**/*.md)
+		// 		controller.validateAccess("docs/README.md"), // Should be true (negated)
+		// 		controller.validateAccess("docs/CONTRIBUTING.md"), // Should be true (negated)
+		// 		controller.validateAccess("docs/api/guide.md"), // Should be false (nested markdown)
+
+		// 		// Nested negations
+		// 		controller.validateAccess("assets/logo.png"), // Should be false (in assets/)
+		// 		controller.validateAccess("assets/public/logo.png"), // Should be true (negated and matches *.png)
+		// 		controller.validateAccess("assets/public/data.json"), // Should be true (in negated public/)
+		// 	]
+
+		// 	results[0].should.be.false() // temp/file.txt
+		// 	results[1].should.be.true() // temp/allowed/file.txt
+		// 	results[2].should.be.true() // temp/allowed/nested/file.txt
+		// 	results[3].should.be.false() // docs/guide.md
+		// 	results[4].should.be.true() // docs/README.md
+		// 	results[5].should.be.true() // docs/CONTRIBUTING.md
+		// 	results[6].should.be.false() // docs/api/guide.md
+		// 	results[7].should.be.false() // assets/logo.png
+		// 	results[8].should.be.true() // assets/public/logo.png
+		// 	results[9].should.be.true() // assets/public/data.json
+		// })
+
+		it("should handle comments in .clineignore", async () => {
+			// Create a new .clineignore with comments
+			await fs.writeFile(
+				path.join(tempDir, ".clineignore"),
+				["# Comment line", "*.secret", "private/", "temp.*"].join("\n"),
+			)
+
+			controller = new ClineIgnoreController(tempDir)
+			await controller.initialize()
+
+			const result = controller.validateAccess("test.secret")
+			result.should.be.false()
+		})
+	})
+
+	describe("Path Handling", () => {
+		it("should handle absolute paths and match ignore patterns", async () => {
+			// Test absolute path that should be allowed
+			const allowedPath = path.join(tempDir, "src/file.ts")
+			const allowedResult = controller.validateAccess(allowedPath)
+			allowedResult.should.be.true()
+
+			// Test absolute path that matches an ignore pattern (*.secret)
+			const ignoredPath = path.join(tempDir, "config.secret")
+			const ignoredResult = controller.validateAccess(ignoredPath)
+			ignoredResult.should.be.false()
+
+			// Test absolute path in ignored directory (private/)
+			const ignoredDirPath = path.join(tempDir, "private/data.txt")
+			const ignoredDirResult = controller.validateAccess(ignoredDirPath)
+			ignoredDirResult.should.be.false()
+		})
+
+		it("should handle relative paths and match ignore patterns", async () => {
+			// Test relative path that should be allowed
+			const allowedResult = controller.validateAccess("./src/file.ts")
+			allowedResult.should.be.true()
+
+			// Test relative path that matches an ignore pattern (*.secret)
+			const ignoredResult = controller.validateAccess("./config.secret")
+			ignoredResult.should.be.false()
+
+			// Test relative path in ignored directory (private/)
+			const ignoredDirResult = controller.validateAccess("./private/data.txt")
+			ignoredDirResult.should.be.false()
+		})
+
+		it("should normalize paths with backslashes", async () => {
+			const result = controller.validateAccess("src\\file.ts")
+			result.should.be.true()
+		})
+	})
+
+	describe("Batch Filtering", () => {
+		it("should filter an array of paths", async () => {
+			const paths = ["src/index.ts", ".env", "lib/utils.ts", ".git/config", "dist/bundle.js"]
+
+			const filtered = controller.filterPaths(paths)
+			filtered.should.deepEqual(["src/index.ts", "lib/utils.ts", "dist/bundle.js"])
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle invalid paths", async () => {
+			// Test with an invalid path containing null byte
+			const result = controller.validateAccess("\0invalid")
+			result.should.be.true()
+		})
+
+		it("should handle missing .clineignore gracefully", async () => {
+			// Create a new controller in a directory without .clineignore
+			const emptyDir = path.join(os.tmpdir(), `llm-test-empty-${Date.now()}`)
+			await fs.mkdir(emptyDir)
+
+			try {
+				const controller = new ClineIgnoreController(emptyDir)
+				await controller.initialize()
+				const result = controller.validateAccess("file.txt")
+				result.should.be.true()
+			} finally {
+				await fs.rm(emptyDir, { recursive: true, force: true })
+			}
+		})
+
+		it("should handle empty .clineignore", async () => {
+			await fs.writeFile(path.join(tempDir, ".clineignore"), "")
+
+			controller = new ClineIgnoreController(tempDir)
+			await controller.initialize()
+
+			const result = controller.validateAccess("regular-file.txt")
+			result.should.be.true()
+		})
+	})
+
+	describe("Include Directive", () => {
+		it("should load patterns from an included file", async () => {
+			// Create a .gitignore file with patterns "*.log" and "debug/"
+			await fs.writeFile(path.join(tempDir, ".gitignore"), ["*.log", "debug/"].join("\n"))
+
+			// Create a .clineignore file that includes .gitignore and adds an extra pattern "secret.txt"
+			await fs.writeFile(path.join(tempDir, ".clineignore"), ["!include .gitignore", "secret.txt"].join("\n"))
+
+			// Initialize the controller to load the updated .clineignore
+			controller = new ClineIgnoreController(tempDir)
+			await controller.initialize()
+
+			// "server.log" should be ignored due to the "*.log" pattern from .gitignore
+			controller.validateAccess("server.log").should.be.false()
+			// "debug/app.js" should be ignored due to the "debug/" pattern from .gitignore
+			controller.validateAccess("debug/app.js").should.be.false()
+			// "secret.txt" should be ignored as specified directly in .clineignore
+			controller.validateAccess("secret.txt").should.be.false()
+			// Other files should be allowed
+			controller.validateAccess("app.js").should.be.true()
+		})
+
+		it("should handle non-existent included file gracefully", async () => {
+			// Create a .clineignore file that includes a non-existent file
+			await fs.writeFile(path.join(tempDir, ".clineignore"), ["!include missing-file.txt"].join("\n"))
+
+			// Initialize the controller
+			controller = new ClineIgnoreController(tempDir)
+			await controller.initialize()
+
+			// Validate access to a regular file; it should be allowed because the missing include should not break everything
+			controller.validateAccess("regular-file.txt").should.be.true()
+		})
+
+		it("should handle non-existent included file gracefully alongside a valid pattern", async () => {
+			// Test with an include directive for a non-existent file alongside a valid pattern ("*.tmp")
+			await fs.writeFile(path.join(tempDir, ".clineignore"), ["!include non-existent.txt", "*.tmp"].join("\n"))
+
+			controller = new ClineIgnoreController(tempDir)
+			await controller.initialize()
+
+			// "file.tmp" should be ignored because of the "*.tmp" pattern
+			controller.validateAccess("file.tmp").should.be.false()
+			// Files that do not match "*.tmp" should be allowed
+			controller.validateAccess("file.log").should.be.true()
+		})
+	})
+})
diff --git a/apps/vscode/src/core/ignore/ClineIgnoreController.ts b/apps/vscode/src/core/ignore/ClineIgnoreController.ts
new file mode 100644
index 0000000..3dd6117
--- /dev/null
+++ b/apps/vscode/src/core/ignore/ClineIgnoreController.ts
@@ -0,0 +1,259 @@
+import { fileExistsAtPath } from "@utils/fs"
+import chokidar, { FSWatcher } from "chokidar"
+import fs from "fs/promises"
+import ignore, { Ignore } from "ignore"
+import path from "path"
+import { Logger } from "@/shared/services/Logger"
+
+export const LOCK_TEXT_SYMBOL = "\u{1F512}"
+
+/**
+ * Controls LLM access to files by enforcing ignore patterns.
+ * Designed to be instantiated once in Cline.ts and passed to file manipulation services.
+ * Uses the 'ignore' library to support standard .gitignore syntax in .clineignore files.
+ */
+export class ClineIgnoreController {
+	private cwd: string
+	private ignoreInstance: Ignore
+	private fileWatcher?: FSWatcher
+	clineIgnoreContent: string | undefined
+
+	constructor(cwd: string) {
+		this.cwd = cwd
+		this.ignoreInstance = ignore()
+		this.clineIgnoreContent = undefined
+	}
+
+	/**
+	 * Initialize the controller by loading custom patterns and setting up file watcher
+	 * Must be called after construction and before using the controller
+	 */
+	async initialize(): Promise<void> {
+		// Set up file watcher for .clineignore
+		this.setupFileWatcher()
+		await this.loadClineIgnore()
+	}
+
+	/**
+	 * Set up the file watcher for .clineignore changes
+	 */
+	private setupFileWatcher(): void {
+		const ignorePath = path.join(this.cwd, ".clineignore")
+
+		this.fileWatcher = chokidar.watch(ignorePath, {
+			persistent: true, // Keep the process running as long as files are being watched
+			ignoreInitial: true, // Don't fire 'add' events when discovering the file initially
+			awaitWriteFinish: {
+				// Wait for writes to finish before emitting events (handles chunked writes)
+				stabilityThreshold: 100, // Wait 100ms for file size to remain constant
+				pollInterval: 100, // Check file size every 100ms while waiting for stability
+			},
+			atomic: true, // Handle atomic writes where editors write to a temp file then rename
+		})
+
+		// Watch for file changes, creation, and deletion
+		this.fileWatcher.on("change", () => {
+			this.loadClineIgnore()
+		})
+
+		this.fileWatcher.on("add", () => {
+			this.loadClineIgnore()
+		})
+
+		this.fileWatcher.on("unlink", () => {
+			this.loadClineIgnore()
+		})
+
+		this.fileWatcher.on("error", (error) => {
+			Logger.error("Error watching .clineignore file:", error)
+		})
+	}
+
+	/**
+	 * Load custom patterns from .clineignore if it exists.
+	 * Supports "!include <filename>" to load additional ignore patterns from other files.
+	 */
+	private async loadClineIgnore(): Promise<void> {
+		try {
+			// Reset ignore instance to prevent duplicate patterns
+			this.ignoreInstance = ignore()
+			const ignorePath = path.join(this.cwd, ".clineignore")
+			if (await fileExistsAtPath(ignorePath)) {
+				const content = await fs.readFile(ignorePath, "utf8")
+				this.clineIgnoreContent = content
+				await this.processIgnoreContent(content)
+				this.ignoreInstance.add(".clineignore")
+			} else {
+				this.clineIgnoreContent = undefined
+			}
+		} catch (error) {
+			// Should never happen: reading file failed even though it exists
+			Logger.error("Unexpected error loading .clineignore:", error)
+		}
+	}
+
+	/**
+	 * Process ignore content and apply all ignore patterns
+	 */
+	private async processIgnoreContent(content: string): Promise<void> {
+		// Optimization: first check if there are any !include directives
+		if (!content.includes("!include ")) {
+			this.ignoreInstance.add(content)
+			return
+		}
+
+		// Process !include directives
+		const combinedContent = await this.processClineIgnoreIncludes(content)
+		this.ignoreInstance.add(combinedContent)
+	}
+
+	/**
+	 * Process !include directives and combine all included file contents
+	 */
+	private async processClineIgnoreIncludes(content: string): Promise<string> {
+		let combinedContent = ""
+		const lines = content.split(/\r?\n/)
+
+		for (const line of lines) {
+			const trimmedLine = line.trim()
+
+			if (!trimmedLine.startsWith("!include ")) {
+				combinedContent += "\n" + line
+				continue
+			}
+
+			// Process !include directive
+			const includedContent = await this.readIncludedFile(trimmedLine)
+			if (includedContent) {
+				combinedContent += "\n" + includedContent
+			}
+		}
+
+		return combinedContent
+	}
+
+	/**
+	 * Read content from an included file specified by !include directive
+	 */
+	private async readIncludedFile(includeLine: string): Promise<string | null> {
+		const includePath = includeLine.substring("!include ".length).trim()
+		const resolvedIncludePath = path.join(this.cwd, includePath)
+
+		if (!(await fileExistsAtPath(resolvedIncludePath))) {
+			Logger.debug(`[ClineIgnore] Included file not found: ${resolvedIncludePath}`)
+			return null
+		}
+
+		return await fs.readFile(resolvedIncludePath, "utf8")
+	}
+
+	/**
+	 * Check if a file should be accessible to the LLM
+	 * @param filePath - Path to check (relative to cwd)
+	 * @returns true if file is accessible, false if ignored
+	 */
+	validateAccess(filePath: string): boolean {
+		// Always allow access if .clineignore does not exist
+		if (!this.clineIgnoreContent) {
+			return true
+		}
+		try {
+			// Normalize path to be relative to cwd and use forward slashes
+			const absolutePath = path.resolve(this.cwd, filePath)
+			const relativePath = path.relative(this.cwd, absolutePath).toPosix()
+
+			// Ignore expects paths to be path.relative()'d
+			return !this.ignoreInstance.ignores(relativePath)
+		} catch (_error) {
+			// Logger.error(`Error validating access for ${filePath}:`, error)
+			// Ignore is designed to work with relative file paths, so will throw error for paths outside cwd. We are allowing access to all files outside cwd.
+			return true
+		}
+	}
+
+	/**
+	 * Check if a terminal command should be allowed to execute based on file access patterns
+	 * @param command - Terminal command to validate
+	 * @returns path of file that is being accessed if it is being accessed, undefined if command is allowed
+	 */
+	validateCommand(command: string): string | undefined {
+		// Always allow if no .clineignore exists
+		if (!this.clineIgnoreContent) {
+			return undefined
+		}
+
+		// Split command into parts and get the base command
+		const parts = command.trim().split(/\s+/)
+		const baseCommand = parts[0].toLowerCase()
+
+		// Commands that read file contents
+		const fileReadingCommands = [
+			// Unix commands
+			"cat",
+			"less",
+			"more",
+			"head",
+			"tail",
+			"grep",
+			"awk",
+			"sed",
+			// PowerShell commands and aliases
+			"get-content",
+			"gc",
+			"type",
+			"select-string",
+			"sls",
+		]
+
+		if (fileReadingCommands.includes(baseCommand)) {
+			// Check each argument that could be a file path
+			for (let i = 1; i < parts.length; i++) {
+				const arg = parts[i]
+				// Skip command flags/options (both Unix and PowerShell style)
+				if (arg.startsWith("-") || arg.startsWith("/")) {
+					continue
+				}
+				// Ignore PowerShell parameter names
+				if (arg.includes(":")) {
+					continue
+				}
+				// Validate file access
+				if (!this.validateAccess(arg)) {
+					return arg
+				}
+			}
+		}
+
+		return undefined
+	}
+
+	/**
+	 * Filter an array of paths, removing those that should be ignored
+	 * @param paths - Array of paths to filter (relative to cwd)
+	 * @returns Array of allowed paths
+	 */
+	filterPaths(paths: string[]): string[] {
+		try {
+			return paths
+				.map((p) => ({
+					path: p,
+					allowed: this.validateAccess(p),
+				}))
+				.filter((x) => x.allowed)
+				.map((x) => x.path)
+		} catch (error) {
+			Logger.error("Error filtering paths:", error)
+			return [] // Fail closed for security
+		}
+	}
+
+	/**
+	 * Clean up resources when the controller is no longer needed
+	 */
+	async dispose(): Promise<void> {
+		if (this.fileWatcher) {
+			await this.fileWatcher.close()
+			this.fileWatcher = undefined
+		}
+	}
+}
diff --git a/apps/vscode/src/core/locks/SqliteLockManager.ts b/apps/vscode/src/core/locks/SqliteLockManager.ts
new file mode 100644
index 0000000..a0c32ac
--- /dev/null
+++ b/apps/vscode/src/core/locks/SqliteLockManager.ts
@@ -0,0 +1,298 @@
+import Database from "better-sqlite3"
+import * as fs from "fs"
+import { existsSync, mkdirSync, unlinkSync } from "fs"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+import type { LockRow, SqliteLockManagerOptions } from "./types"
+export class SqliteLockManager {
+	private db!: Database.Database
+	private instanceAddress: string
+	private dbPath: string
+	private readonly STALE_LOCK_TIMEOUT = 1 * 60 * 1000 // 1 minute in milliseconds
+
+	constructor(options: SqliteLockManagerOptions) {
+		this.instanceAddress = options.instanceAddress
+		this.dbPath = options.dbPath
+
+		// Ensure the directory exists before creating the database
+		const dbDir = path.dirname(this.dbPath)
+		try {
+			mkdirSync(dbDir, { recursive: true })
+		} catch (error) {
+			Logger.error(`CRITICAL ERROR: Failed to create SQLite database directory ${dbDir}:`, error)
+			throw new Error(`Failed to create SQLite database directory: ${error}`)
+		}
+
+		try {
+			this.initializeDatabaseWithLockSync()
+		} catch (error) {
+			Logger.error(`CRITICAL ERROR: Failed to initialize SQLite database at ${this.dbPath}:`, error)
+			throw new Error(`Failed to initialize SQLite database: ${error}`)
+		}
+	}
+
+	private initializeDatabaseWithLockSync(): void {
+		const lockFile = `${this.dbPath}.lock`
+
+		// Clean up stale lock files first
+		this.cleanupStaleLockSync(lockFile)
+
+		try {
+			// Try to acquire exclusive file lock for database creation
+			let fd: number | null = null
+
+			try {
+				fd = fs.openSync(lockFile, "wx") // Exclusive creation - fails if file exists
+
+				// Write timestamp to lock file for stale lock detection
+				fs.writeFileSync(fd, Date.now().toString())
+
+				// Check if database already exists
+				const dbExists = existsSync(this.dbPath)
+
+				if (!dbExists) {
+					// Database doesn't exist, create it
+					this.db = new Database(this.dbPath)
+					this.initializeDatabase()
+				} else {
+					// Database exists, just open it
+					this.db = new Database(this.dbPath)
+				}
+			} finally {
+				// Always clean up the lock file
+				if (fd !== null) {
+					fs.closeSync(fd)
+				}
+				try {
+					unlinkSync(lockFile)
+				} catch {} // Ignore errors if file was already deleted
+			}
+		} catch (error: any) {
+			if (error.code === "EEXIST") {
+				// Another process is initializing the database, wait and retry
+				const delay = 100 + Math.random() * 100 // Add jitter
+				this.sleepSync(delay)
+				this.initializeDatabaseWithLockSync()
+				return
+			}
+			throw error
+		}
+	}
+
+	private sleepSync(ms: number) {
+		// Non-spinning, synchronous sleep using Atomics.wait
+		// Works in Node main thread (since v12.16+) and worker threads.
+		const sab = new SharedArrayBuffer(4)
+		const ia = new Int32Array(sab)
+		Atomics.wait(ia, 0, 0, Math.max(0, Math.floor(ms)))
+	}
+
+	private cleanupStaleLockSync(lockFile: string): void {
+		try {
+			if (!existsSync(lockFile)) {
+				return // Lock file doesn't exist, nothing to clean up
+			}
+
+			try {
+				const timestampStr = fs.readFileSync(lockFile, "utf8").trim()
+				const timestamp = parseInt(timestampStr, 10)
+
+				if (isNaN(timestamp) || Date.now() - timestamp > this.STALE_LOCK_TIMEOUT) {
+					// Stale lock, remove it
+					unlinkSync(lockFile)
+					Logger.warn(`Removed stale database lock file: ${lockFile}`)
+				}
+			} catch (readError) {
+				// If we can't read the timestamp, assume it's stale
+				unlinkSync(lockFile)
+				Logger.warn(`Removed unreadable database lock file: ${lockFile}`)
+			}
+		} catch (error: any) {
+			if (error.code !== "ENOENT") {
+				// Lock file doesn't exist, which is fine
+				Logger.warn(`Error checking lock file ${lockFile}:`, error)
+			}
+		}
+	}
+
+	private initializeDatabase() {
+		// Create the locks table with the unified schema (matches cli/pkg/common/schema.go)
+		this.db.exec(`
+			CREATE TABLE IF NOT EXISTS locks (
+				id INTEGER PRIMARY KEY,
+				held_by TEXT NOT NULL,
+				lock_type TEXT NOT NULL CHECK (lock_type IN ('file', 'instance', 'folder')),
+				lock_target TEXT NOT NULL,
+				locked_at INTEGER NOT NULL,
+				UNIQUE(lock_type, lock_target)
+			);
+		`)
+
+		// Create indexes for performance (matches cli/pkg/common/schema.go)
+		this.db.exec(`
+			CREATE INDEX IF NOT EXISTS idx_locks_held_by ON locks(held_by);
+			CREATE INDEX IF NOT EXISTS idx_locks_type ON locks(lock_type);
+			CREATE INDEX IF NOT EXISTS idx_locks_target ON locks(lock_target);
+		`)
+	}
+
+	/**
+	 * Register this instance in the locks table
+	 */
+	async registerInstance(data: { hostAddress: string }): Promise<void> {
+		const now = Date.now()
+
+		// Create instance lock entry
+		const insertLock = this.db.prepare(`
+			INSERT OR REPLACE INTO locks (held_by, lock_type, lock_target, locked_at)
+			VALUES (?, 'instance', ?, ?)
+		`)
+
+		insertLock.run(this.instanceAddress, data.hostAddress, now)
+	}
+
+	/**
+	 * Update the timestamp for this instance (touch)
+	 */
+	touchInstance(): void {
+		const now = Date.now()
+		const updateLock = this.db.prepare(`
+			UPDATE locks 
+			SET locked_at = ? 
+			WHERE held_by = ? AND lock_type = 'instance'
+		`)
+
+		updateLock.run(now, this.instanceAddress)
+	}
+
+	/**
+	 * Remove this instance from the locks table
+	 */
+	unregisterInstance(): void {
+		const deleteLock = this.db.prepare(`
+			DELETE FROM locks 
+			WHERE held_by = ? AND lock_type = 'instance'
+		`)
+
+		deleteLock.run(this.instanceAddress)
+	}
+
+	/**
+	 * Query the registry for any instance registered on the given port
+	 */
+	getInstanceByPort(port: number): { instanceAddress: string; hostAddress: string } | null {
+		const query = this.db.prepare(`
+			SELECT held_by, lock_target 
+			FROM locks 
+			WHERE lock_type = 'instance' 
+			AND (held_by LIKE '%:' || ? OR lock_target LIKE '%:' || ?)
+		`)
+
+		const result = query.get(port, port) as { held_by: string; lock_target: string } | undefined
+
+		if (result) {
+			return {
+				instanceAddress: result.held_by,
+				hostAddress: result.lock_target,
+			}
+		}
+
+		return null
+	}
+
+	/**
+	 * Remove a specific instance entry from the registry
+	 */
+	removeInstanceByAddress(instanceAddress: string): void {
+		const deleteLock = this.db.prepare(`
+			DELETE FROM locks 
+			WHERE held_by = ? AND lock_type = 'instance'
+		`)
+
+		deleteLock.run(instanceAddress)
+	}
+
+	/**
+	 * Check if another instance has a conflicting folder lock
+	 */
+	async getFolderLockByTarget(lockTarget: string): Promise<LockRow | null> {
+		const query = this.db.prepare(`
+			SELECT * FROM locks 
+			WHERE lock_type = 'folder' 
+			AND lock_target = ? 
+		`)
+
+		const result = query.get(lockTarget) as LockRow | undefined
+		return result || null
+	}
+
+	/**
+	 * Release a folder lock
+	 */
+	releaseFolderLockByTarget(heldBy: string, lockTarget: string): void {
+		const deleteLock = this.db.prepare(`
+			DELETE FROM locks 
+			WHERE held_by = ? AND lock_type = 'folder' AND lock_target = ?
+		`)
+
+		// swap instance address in place of taskID
+		heldBy = this.instanceAddress
+		deleteLock.run(heldBy, lockTarget)
+	}
+
+	/**
+	 * Register a folder lock
+	 * @returns null if lock was successfully acquired, or the conflicting LockRow if lock already exists
+	 */
+	async registerFolderLock(heldBy: string, lockTarget: string): Promise<LockRow | null> {
+		const now = Date.now()
+		const insertLock = this.db.prepare(`
+			INSERT OR IGNORE INTO locks (held_by, lock_type, lock_target, locked_at)
+			VALUES (?, 'folder', ?, ?)
+		`)
+
+		// swap instance address in place of taskID
+		heldBy = this.instanceAddress
+		const insertedCount = insertLock.run(this.instanceAddress, lockTarget, now).changes
+
+		if (insertedCount > 0) {
+			return null // lock acquired
+		} else {
+			const existingLock = await this.getFolderLockByTarget(lockTarget)
+			if (existingLock && existingLock.held_by === heldBy) {
+				return null // existing lock is held by the same task
+			}
+			// existing lock held by other task, return the conflicting lock
+			return await this.getFolderLockByTarget(lockTarget)
+		}
+	}
+
+	/**
+	 * Clean up folder locks that are held by tasks whose instances no longer exist.
+	 * This removes locks where held_by doesn't exist in any instance-type lock.
+	 */
+	cleanupOrphanedFolderLocks(): void {
+		const deleteOrphans = this.db.prepare(`
+			DELETE FROM locks 
+			WHERE lock_type = 'folder' 
+			AND held_by NOT IN (
+				SELECT DISTINCT held_by 
+				FROM locks 
+				WHERE lock_type = 'instance'
+			)
+		`)
+
+		const deletedCount = deleteOrphans.run().changes
+
+		if (deletedCount > 0) {
+			Logger.log(`Cleaned up ${deletedCount} orphaned folder lock(s)`)
+		}
+	}
+
+	/**
+	 * Close the database connection
+	 */
+	close(): void {
+		this.db.close()
+	}
+}
diff --git a/apps/vscode/src/core/locks/types.ts b/apps/vscode/src/core/locks/types.ts
new file mode 100644
index 0000000..0cef6a1
--- /dev/null
+++ b/apps/vscode/src/core/locks/types.ts
@@ -0,0 +1,14 @@
+type LockType = "file" | "instance" | "folder"
+
+export interface LockRow {
+	id: number
+	held_by: string
+	lock_type: LockType
+	lock_target: string // varies by type: file path, host address, or folder path
+	locked_at: number
+}
+
+export interface SqliteLockManagerOptions {
+	dbPath: string
+	instanceAddress: string // cline core address
+}
diff --git a/apps/vscode/src/core/mentions/index.test.ts b/apps/vscode/src/core/mentions/index.test.ts
new file mode 100644
index 0000000..2a89956
--- /dev/null
+++ b/apps/vscode/src/core/mentions/index.test.ts
@@ -0,0 +1,473 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import { FileContextTracker } from "@core/context/context-tracking/FileContextTracker"
+import * as extractTextModule from "@integrations/misc/extract-text"
+import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
+import * as gitModule from "@utils/git"
+import { expect } from "chai"
+import * as fs from "fs"
+import * as isBinaryFileModule from "isbinaryfile"
+import * as path from "path"
+import * as sinon from "sinon"
+import { HostProvider } from "@/hosts/host-provider"
+import * as terminalModule from "@/hosts/vscode/terminal/get-latest-output"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+import { parseMentions } from "."
+
+describe("parseMentions", () => {
+	let sandbox: sinon.SinonSandbox
+	let urlContentFetcherStub: sinon.SinonStubbedInstance<UrlContentFetcher>
+	let fileContextTrackerStub: sinon.SinonStubbedInstance<FileContextTracker>
+	let fsStatStub: sinon.SinonStub
+	let fsReaddirStub: sinon.SinonStub
+	let extractTextStub: sinon.SinonStub
+	let isBinaryFileStub: sinon.SinonStub
+	let getLatestTerminalOutputStub: sinon.SinonStub
+	let getWorkingStateStub: sinon.SinonStub
+	let getCommitInfoStub: sinon.SinonStub
+	let showMessageStub: sinon.SinonStub
+
+	const cwd = "/test/project"
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		setVscodeHostProviderMock()
+		// Create stubs for dependencies
+		urlContentFetcherStub = {
+			launchBrowser: sandbox.stub().resolves(),
+			closeBrowser: sandbox.stub().resolves(),
+			urlToMarkdown: sandbox.stub().resolves("# Example Website\n\nContent here"),
+		} as any
+
+		fileContextTrackerStub = {
+			trackFileContext: sandbox.stub().resolves(),
+		} as any
+
+		// Stub file system operations using fs.promises
+		fsStatStub = sandbox.stub(fs.promises, "stat")
+		fsReaddirStub = sandbox.stub(fs.promises, "readdir")
+
+		// Stub other modules
+		extractTextStub = sandbox.stub(extractTextModule, "extractTextFromFile")
+		isBinaryFileStub = sandbox.stub(isBinaryFileModule, "isBinaryFile")
+		getLatestTerminalOutputStub = sandbox.stub(terminalModule, "getLatestTerminalOutput")
+		getWorkingStateStub = sandbox.stub(gitModule, "getWorkingState")
+		getCommitInfoStub = sandbox.stub(gitModule, "getCommitInfo")
+		showMessageStub = sandbox.stub(HostProvider.window, "showMessage")
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe("File mentions", () => {
+		it("should handle simple file mention", async () => {
+			const text = "Check @/src/index.ts for details"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.resolves("console.log('Hello World');")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub, fileContextTrackerStub)
+
+			const expectedOutput = `Check 'src/index.ts' (see below for file content) for details
+
+<file_content path="src/index.ts">
+console.log('Hello World');
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+			expect(fileContextTrackerStub.trackFileContext.calledWith("src/index.ts", "file_mentioned")).to.be.true
+		})
+
+		it("should handle quoted file paths with spaces", async () => {
+			const text = 'Open @"/path with spaces/file.txt"'
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.resolves("console.log('Hello World');")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Open 'path with spaces/file.txt' (see below for file content)
+
+<file_content path="path with spaces/file.txt">
+console.log('Hello World');
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+
+		it("should handle binary files", async () => {
+			const text = "Check @/image.png"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(true)
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Check 'image.png' (see below for file content)
+
+<file_content path="image.png">
+(Binary file, unable to display content)
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+
+		it("should handle file read errors", async () => {
+			const text = "Check @/missing.txt"
+
+			fsStatStub.rejects(new Error("ENOENT: no such file or directory"))
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Check 'missing.txt' (see below for file content)
+
+<file_content path="missing.txt">
+Error fetching content: Failed to access path "missing.txt": ENOENT: no such file or directory
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+	})
+
+	describe("Folder mentions", () => {
+		it("should handle folder mention", async () => {
+			const text = "Look in @/src/ folder"
+
+			fsStatStub.resolves({ isFile: () => false, isDirectory: () => true })
+			fsReaddirStub.resolves([
+				{ name: "index.ts", isFile: () => true, isDirectory: () => false },
+				{ name: "utils", isFile: () => false, isDirectory: () => true },
+				{ name: "README.md", isFile: () => true, isDirectory: () => false },
+			])
+
+			// Set up file content stubs
+			isBinaryFileStub.resolves(false)
+			extractTextStub.withArgs(path.resolve(cwd, "src/index.ts")).resolves("export const main = () => {};")
+			extractTextStub.withArgs(path.resolve(cwd, "src/README.md")).resolves("# Source Code")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Look in 'src/' (see below for folder content) folder
+
+<folder_content path="src/">
+├── index.ts
+├── utils/
+└── README.md
+
+<file_content path="src/index.ts">
+export const main = () => {};
+</file_content>
+
+<file_content path="src/README.md">
+# Source Code
+</file_content>
+</folder_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+	})
+
+	describe("URL mentions", () => {
+		it("should handle URL mention", async () => {
+			const text = "Visit @https://example.com for info"
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Visit 'https://example.com' (see below for site content) for info
+
+<url_content url="https://example.com">
+# Example Website
+
+Content here
+</url_content>`
+
+			expect(result).to.equal(expectedOutput)
+			expect(urlContentFetcherStub.launchBrowser.called).to.be.true
+			expect(urlContentFetcherStub.urlToMarkdown.calledWith("https://example.com")).to.be.true
+			expect(urlContentFetcherStub.closeBrowser.called).to.be.true
+		})
+
+		it("should handle browser launch errors", async () => {
+			const text = "Visit @https://example.com"
+
+			urlContentFetcherStub.launchBrowser.rejects(new Error("Browser launch failed"))
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Visit 'https://example.com' (see below for site content)
+
+<url_content url="https://example.com">
+Error fetching content: Browser launch failed
+</url_content>`
+
+			expect(result).to.equal(expectedOutput)
+			expect(showMessageStub.called).to.be.true
+		})
+
+		it("should handle URL fetch errors", async () => {
+			const text = "Visit @https://example.com"
+
+			urlContentFetcherStub.urlToMarkdown.rejects(new Error("Network error"))
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Visit 'https://example.com' (see below for site content)
+
+<url_content url="https://example.com">
+Error fetching content: Network error
+</url_content>`
+
+			expect(result).to.equal(expectedOutput)
+			expect(showMessageStub.called).to.be.true
+		})
+	})
+
+	describe("Special mentions", () => {
+		it("should handle @terminal mention", async () => {
+			const text = "See @terminal output"
+
+			getLatestTerminalOutputStub.resolves("$ npm test\nAll tests passed!")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `See Terminal Output (see below for output) output
+
+<terminal_output>
+$ npm test
+All tests passed!
+</terminal_output>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+
+		it("should handle @git-changes mention", async () => {
+			const text = "Review @git-changes"
+
+			getWorkingStateStub.resolves("M  src/index.ts\nA  src/new-file.ts")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Review Working directory changes (see below for details)
+
+<git_working_state>
+M  src/index.ts
+A  src/new-file.ts
+</git_working_state>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+
+		it("should handle git commit hash mention", async () => {
+			const text = "See commit @abcdef1234567890"
+
+			getCommitInfoStub.resolves("commit abcdef1234567890\nAuthor: Test\nDate: 2024-01-01\n\nInitial commit")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `See commit Git commit 'abcdef1234567890' (see below for commit info)
+
+<git_commit hash="abcdef1234567890">
+commit abcdef1234567890
+Author: Test
+Date: 2024-01-01
+
+Initial commit
+</git_commit>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+	})
+
+	describe("Multiple mentions", () => {
+		it("should handle multiple mentions in order", async () => {
+			const text = "Check @/file1.txt and @/file2.txt"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.withArgs(path.resolve(cwd, "file1.txt")).resolves("Content 1")
+			extractTextStub.withArgs(path.resolve(cwd, "file2.txt")).resolves("Content 2")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Check 'file1.txt' (see below for file content) and 'file2.txt' (see below for file content)
+
+<file_content path="file1.txt">
+Content 1
+</file_content>
+
+<file_content path="file2.txt">
+Content 2
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+
+		it("should handle duplicate mentions only once", async () => {
+			const text = "Check @/file.txt and again @/file.txt"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.resolves("Content")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Check 'file.txt' (see below for file content) and again 'file.txt' (see below for file content)
+
+<file_content path="file.txt">
+Content
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+
+		it("should handle mixed mention types", async () => {
+			const text = "Check @/file.txt, and @https://example.com"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.resolves("File content")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Check 'file.txt' (see below for file content), and 'https://example.com' (see below for site content)
+
+<file_content path="file.txt">
+File content
+</file_content>
+
+<url_content url="https://example.com">
+# Example Website
+
+Content here
+</url_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+	})
+
+	describe("Error handling", () => {
+		it("should handle errors for each mention type gracefully", async () => {
+			const text = "@/error.txt @terminal @git-changes @abc1234567"
+
+			fsStatStub.rejects(new Error("File error"))
+			getLatestTerminalOutputStub.rejects(new Error("Terminal error"))
+			getWorkingStateStub.rejects(new Error("Git state error"))
+			getCommitInfoStub.rejects(new Error("Commit error"))
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `'error.txt' (see below for file content) Terminal Output (see below for output) Working directory changes (see below for details) Git commit 'abc1234567' (see below for commit info)
+
+<file_content path="error.txt">
+Error fetching content: Failed to access path "error.txt": File error
+</file_content>
+
+<terminal_output>
+Error fetching terminal output: Terminal error
+</terminal_output>
+
+<git_working_state>
+Error fetching working state: Git state error
+</git_working_state>
+
+<git_commit hash="abc1234567">
+Error fetching commit info: Commit error
+</git_commit>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+	})
+
+	describe("Edge cases", () => {
+		it("should handle text with no mentions", async () => {
+			const text = "This is plain text without any mentions"
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			expect(result).to.equal(text)
+		})
+
+		it("should handle empty text", async () => {
+			const result = await parseMentions("", cwd, urlContentFetcherStub)
+
+			expect(result).to.equal("")
+		})
+
+		it("should handle mentions with trailing punctuation", async () => {
+			const text = "Check @/file.txt!"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.resolves("Content")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub)
+
+			const expectedOutput = `Check 'file.txt' (see below for file content)!
+
+<file_content path="file.txt">
+Content
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+		})
+	})
+
+	describe("Multiroot workspace mentions", () => {
+		let workspaceManagerStub: any
+
+		beforeEach(() => {
+			// Create a mock multiroot workspace manager
+			workspaceManagerStub = {
+				getRoots: sandbox.stub().returns([
+					{ name: "frontend", path: "/test/frontend" },
+					{ name: "backend", path: "/test/backend" },
+				]),
+				getRootByName: sandbox.stub().callsFake((name: string) => {
+					const roots = [
+						{ name: "frontend", path: "/test/frontend" },
+						{ name: "backend", path: "/test/backend" },
+					]
+					return roots.find((r) => r.name === name)
+				}),
+			}
+		})
+
+		it("should handle workspace-prefixed file mention", async () => {
+			const text = "Check @frontend:/src/index.ts"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.resolves("console.log('Frontend');")
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub, fileContextTrackerStub, workspaceManagerStub)
+
+			const expectedOutput = `Check 'frontend:src/index.ts' (see below for file content)
+
+<file_content path="src/index.ts" workspace="frontend">
+console.log('Frontend');
+</file_content>`
+
+			expect(result).to.equal(expectedOutput)
+			expect(fileContextTrackerStub.trackFileContext.calledWith("src/index.ts", "file_mentioned")).to.be.true
+		})
+
+		it("should handle file in multiple workspaces without hint", async () => {
+			const text = "Check @/config.json"
+
+			fsStatStub.resolves({ isFile: () => true, isDirectory: () => false })
+			isBinaryFileStub.resolves(false)
+			extractTextStub.withArgs(path.resolve("/test/frontend", "config.json")).resolves('{"env": "dev"}')
+			extractTextStub.withArgs(path.resolve("/test/backend", "config.json")).resolves('{"env": "prod"}')
+
+			const result = await parseMentions(text, cwd, urlContentFetcherStub, fileContextTrackerStub, workspaceManagerStub)
+
+			// Should include both files with workspace annotations
+			expect(result).to.include('workspace="frontend"')
+			expect(result).to.include('workspace="backend"')
+			expect(result).to.include('{"env": "dev"}')
+			expect(result).to.include('{"env": "prod"}')
+		})
+	})
+})
diff --git a/apps/vscode/src/core/mentions/index.ts b/apps/vscode/src/core/mentions/index.ts
new file mode 100644
index 0000000..0d59595
--- /dev/null
+++ b/apps/vscode/src/core/mentions/index.ts
@@ -0,0 +1,450 @@
+import { diagnosticsToProblemsString } from "@integrations/diagnostics"
+import { extractTextFromFile } from "@integrations/misc/extract-text"
+import { openFile } from "@integrations/misc/open-file"
+import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
+import { telemetryService } from "@services/telemetry"
+import { mentionRegexGlobal } from "@shared/context-mentions"
+import { WorkspaceRoot } from "@shared/multi-root/types"
+import { openExternal } from "@utils/env"
+import { getCommitInfo, getWorkingState } from "@utils/git"
+import fs from "fs/promises"
+import { isBinaryFile } from "isbinaryfile"
+import * as path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { getLatestTerminalOutput } from "@/hosts/vscode/terminal/get-latest-output"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { DiagnosticSeverity } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { isDirectory } from "@/utils/fs"
+import { getCwd } from "@/utils/path"
+import { FileContextTracker } from "../context/context-tracking/FileContextTracker"
+import type { WorkspaceRootManager } from "../workspace"
+
+export async function openMention(mention?: string): Promise<void> {
+	if (!mention) {
+		return
+	}
+
+	const cwd = await getCwd()
+	if (!cwd) {
+		return
+	}
+
+	if (isFileMention(mention)) {
+		const relPath = getFilePathFromMention(mention)
+		const absPath = path.resolve(cwd, relPath)
+		if (await isDirectory(absPath)) {
+			await HostProvider.workspace.openInFileExplorerPanel({ path: absPath })
+		} else {
+			openFile(absPath)
+		}
+	} else if (mention === "problems") {
+		await HostProvider.workspace.openProblemsPanel({})
+	} else if (mention === "terminal") {
+		await HostProvider.workspace.openTerminalPanel({})
+	} else if (mention.startsWith("http")) {
+		await openExternal(mention)
+	}
+}
+
+export async function getFileMentionFromPath(filePath: string) {
+	const cwd = await getCwd()
+	if (!cwd) {
+		return "@/" + filePath
+	}
+	const relativePath = path.relative(cwd, filePath)
+	return "@/" + relativePath
+}
+
+export async function parseMentions(
+	text: string,
+	cwd: string,
+	urlContentFetcher: UrlContentFetcher,
+	fileContextTracker?: FileContextTracker,
+	workspaceManager?: WorkspaceRootManager,
+): Promise<string> {
+	const mentions: Set<string> = new Set()
+	let parsedText = text.replace(mentionRegexGlobal, (match, mention) => {
+		mentions.add(mention)
+		if (mention.startsWith("http")) {
+			return `'${mention}' (see below for site content)`
+		} else if (isFileMention(mention)) {
+			const mentionPath = getFilePathFromMention(mention)
+			const workspaceHint = getWorkspaceHintFromMention(mention)
+			// For workspace-prefixed mentions, include the workspace name in the same format the model uses for tool calls
+			if (workspaceHint) {
+				return mentionPath.endsWith("/")
+					? `'${workspaceHint}:${mentionPath}' (see below for folder content)`
+					: `'${workspaceHint}:${mentionPath}' (see below for file content)`
+			}
+			return mentionPath.endsWith("/")
+				? `'${mentionPath}' (see below for folder content)`
+				: `'${mentionPath}' (see below for file content)`
+		} else if (mention === "problems") {
+			return `Workspace Problems (see below for diagnostics)`
+		} else if (mention === "terminal") {
+			return `Terminal Output (see below for output)`
+		} else if (mention === "git-changes") {
+			return `Working directory changes (see below for details)`
+		} else if (/^[a-f0-9]{7,40}$/.test(mention)) {
+			return `Git commit '${mention}' (see below for commit info)`
+		}
+		return match
+	})
+
+	const urlMention = Array.from(mentions).find((mention) => mention.startsWith("http"))
+	let launchBrowserError: Error | undefined
+	if (urlMention) {
+		try {
+			await urlContentFetcher.launchBrowser()
+		} catch (error) {
+			launchBrowserError = error
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Error fetching content for ${urlMention}: ${error.message}`,
+			})
+		}
+	}
+
+	// Filter out duplicate mentions while preserving order
+	const uniqueMentions = Array.from(new Set(mentions))
+
+	for (const mention of uniqueMentions) {
+		// Safety guard: skip a bare "/" mention. This can surface from parsed strings or tool output and would resolve to the
+		// workspace root. Expanding it would scan the entire project, inflate context, and can trigger recursive loops.
+		// If root-level expansion is ever desired, gate it behind an explicit syntax (e.g. "@root" or "@folder:/")
+		// and enforce strict size/.clineignore limits instead.
+		if (mention === "/") {
+			continue
+		}
+
+		if (mention.startsWith("http")) {
+			let result: string
+			if (launchBrowserError) {
+				result = `Error fetching content: ${launchBrowserError.message}`
+				// Track failed URL mention
+				telemetryService.captureMentionFailed("url", "network_error", launchBrowserError?.message || "")
+			} else {
+				try {
+					const markdown = await urlContentFetcher.urlToMarkdown(mention)
+					result = markdown
+					// Track successful URL mention
+					telemetryService.captureMentionUsed("url", markdown.length)
+				} catch (error) {
+					HostProvider.window.showMessage({
+						type: ShowMessageType.ERROR,
+						message: `Error fetching content for ${mention}: ${error.message}`,
+					})
+					result = `Error fetching content: ${error.message}`
+					// Track failed URL mention
+					telemetryService.captureMentionFailed("url", "network_error", error.message)
+				}
+			}
+			parsedText += `\n\n<url_content url="${mention}">\n${result}\n</url_content>`
+		} else if (isFileMention(mention)) {
+			const mentionPath = getFilePathFromMention(mention)
+			const mentionType = mention.endsWith("/") ? "folder" : "file"
+			const workspaceHint = getWorkspaceHintFromMention(mention)
+
+			const isMultiRoot = workspaceManager && workspaceManager.getRoots().length > 1
+			if (isMultiRoot && !workspaceHint) {
+				// Parallel search across all workspaces
+				const workspaceRoots = workspaceManager.getRoots()
+				const searchPromises = workspaceRoots.map(async (root: WorkspaceRoot) => {
+					try {
+						const content = await getFileOrFolderContent(mentionPath, root.path)
+						return {
+							workspaceName: root.name || path.basename(root.path),
+							content,
+							success: true,
+						}
+					} catch (error) {
+						return {
+							workspaceName: root.name || path.basename(root.path),
+							content: null,
+							success: false,
+							error: error.message,
+						}
+					}
+				})
+
+				const results = await Promise.all(searchPromises)
+				const successfulResults = results.filter((r) => r.success && r.content)
+
+				if (successfulResults.length === 0) {
+					const errorMsg = `File not found in any workspace. Searched: ${results.map((r) => r.workspaceName).join(", ")}`
+					if (mention.endsWith("/")) {
+						parsedText += `\n\n<folder_content path="${mentionPath}">\nError fetching content: ${errorMsg}\n</folder_content>`
+					} else {
+						parsedText += `\n\n<file_content path="${mentionPath}">\nError fetching content: ${errorMsg}\n</file_content>`
+					}
+					telemetryService.captureMentionFailed(mentionType, "not_found", errorMsg)
+				} else if (successfulResults.length === 1) {
+					// Found in exactly one workspace
+					const result = successfulResults[0]
+					if (mention.endsWith("/")) {
+						parsedText += `\n\n<folder_content path="${mentionPath}" workspace="${result.workspaceName}">\n${result.content}\n</folder_content>`
+					} else {
+						parsedText += `\n\n<file_content path="${mentionPath}" workspace="${result.workspaceName}">\n${result.content}\n</file_content>`
+						if (fileContextTracker) {
+							await fileContextTracker.trackFileContext(mentionPath, "file_mentioned")
+						}
+					}
+					telemetryService.captureMentionUsed(mentionType, result.content!.length)
+				} else {
+					// Found in multiple workspaces - include all candidates with workspace name
+					for (const result of successfulResults) {
+						if (mention.endsWith("/")) {
+							parsedText += `\n\n<folder_content path="${mentionPath}" workspace="${result.workspaceName}">\n${result.content}\n</folder_content>`
+						} else {
+							parsedText += `\n\n<file_content path="${mentionPath}" workspace="${result.workspaceName}">\n${result.content}\n</file_content>`
+						}
+					}
+					const totalLength = successfulResults.reduce((sum, r) => sum + (r.content?.length || 0), 0)
+					telemetryService.captureMentionUsed(mentionType, totalLength)
+				}
+			} else if (isMultiRoot && workspaceHint) {
+				// Search only in specified workspace
+				const targetRoot = workspaceManager.getRootByName(workspaceHint)
+				if (!targetRoot) {
+					const errorMsg = `Workspace '${workspaceHint}' not found`
+					if (mention.endsWith("/")) {
+						parsedText += `\n\n<folder_content path="${mentionPath}" workspace="${workspaceHint}">\nError fetching content: ${errorMsg}\n</folder_content>`
+					} else {
+						parsedText += `\n\n<file_content path="${mentionPath}" workspace="${workspaceHint}">\nError fetching content: ${errorMsg}\n</file_content>`
+					}
+					telemetryService.captureMentionFailed(mentionType, "not_found", errorMsg)
+				} else {
+					try {
+						const content = await getFileOrFolderContent(mentionPath, targetRoot.path)
+						if (mention.endsWith("/")) {
+							parsedText += `\n\n<folder_content path="${mentionPath}" workspace="${workspaceHint}">\n${content}\n</folder_content>`
+						} else {
+							parsedText += `\n\n<file_content path="${mentionPath}" workspace="${workspaceHint}">\n${content}\n</file_content>`
+							if (fileContextTracker) {
+								await fileContextTracker.trackFileContext(mentionPath, "file_mentioned")
+							}
+						}
+						telemetryService.captureMentionUsed(mentionType, content.length)
+					} catch (error) {
+						if (mention.endsWith("/")) {
+							parsedText += `\n\n<folder_content path="${mentionPath}" workspace="${workspaceHint}">\nError fetching content: ${error.message}\n</folder_content>`
+						} else {
+							parsedText += `\n\n<file_content path="${mentionPath}" workspace="${workspaceHint}">\nError fetching content: ${error.message}\n</file_content>`
+						}
+						let errorType: "not_found" | "permission_denied" | "unknown" = "unknown"
+						if (error.message.includes("ENOENT") || error.message.includes("Failed to access")) {
+							errorType = "not_found"
+						} else if (error.message.includes("EACCES") || error.message.includes("permission")) {
+							errorType = "permission_denied"
+						}
+						telemetryService.captureMentionFailed(mentionType, errorType, error.message)
+					}
+				}
+			} else {
+				// Legacy single workspace mode
+				try {
+					const content = await getFileOrFolderContent(mentionPath, cwd)
+					if (mention.endsWith("/")) {
+						parsedText += `\n\n<folder_content path="${mentionPath}">\n${content}\n</folder_content>`
+					} else {
+						parsedText += `\n\n<file_content path="${mentionPath}">\n${content}\n</file_content>`
+						if (fileContextTracker) {
+							await fileContextTracker.trackFileContext(mentionPath, "file_mentioned")
+						}
+					}
+					telemetryService.captureMentionUsed(mentionType, content.length)
+				} catch (error) {
+					if (mention.endsWith("/")) {
+						parsedText += `\n\n<folder_content path="${mentionPath}">\nError fetching content: ${error.message}\n</folder_content>`
+					} else {
+						parsedText += `\n\n<file_content path="${mentionPath}">\nError fetching content: ${error.message}\n</file_content>`
+					}
+					let errorType: "not_found" | "permission_denied" | "unknown" = "unknown"
+					if (error.message.includes("ENOENT") || error.message.includes("Failed to access")) {
+						errorType = "not_found"
+					} else if (error.message.includes("EACCES") || error.message.includes("permission")) {
+						errorType = "permission_denied"
+					}
+					telemetryService.captureMentionFailed(mentionType, errorType, error.message)
+				}
+			}
+		} else if (mention === "problems") {
+			try {
+				const problems = await getWorkspaceProblems()
+				parsedText += `\n\n<workspace_diagnostics>\n${problems}\n</workspace_diagnostics>`
+				// Track successful problems mention
+				telemetryService.captureMentionUsed("problems", problems.length)
+			} catch (error) {
+				parsedText += `\n\n<workspace_diagnostics>\nError fetching diagnostics: ${error.message}\n</workspace_diagnostics>`
+				// Track failed problems mention
+				telemetryService.captureMentionFailed("problems", "unknown", error.message)
+			}
+		} else if (mention === "terminal") {
+			try {
+				const terminalOutput = await getLatestTerminalOutput()
+				parsedText += `\n\n<terminal_output>\n${terminalOutput}\n</terminal_output>`
+				// Track successful terminal mention
+				telemetryService.captureMentionUsed("terminal", terminalOutput.length)
+			} catch (error) {
+				parsedText += `\n\n<terminal_output>\nError fetching terminal output: ${error.message}\n</terminal_output>`
+				// Track failed terminal mention
+				telemetryService.captureMentionFailed("terminal", "unknown", error.message)
+			}
+		} else if (mention === "git-changes") {
+			try {
+				const workingState = await getWorkingState(cwd)
+				parsedText += `\n\n<git_working_state>\n${workingState}\n</git_working_state>`
+				// Track successful git-changes mention
+				telemetryService.captureMentionUsed("git-changes", workingState.length)
+			} catch (error) {
+				parsedText += `\n\n<git_working_state>\nError fetching working state: ${error.message}\n</git_working_state>`
+				// Track failed git-changes mention
+				telemetryService.captureMentionFailed("git-changes", "unknown", error.message)
+			}
+		} else if (/^[a-f0-9]{7,40}$/.test(mention)) {
+			try {
+				const commitInfo = await getCommitInfo(mention, cwd)
+				parsedText += `\n\n<git_commit hash="${mention}">\n${commitInfo}\n</git_commit>`
+				// Track successful commit mention
+				telemetryService.captureMentionUsed("commit", commitInfo.length)
+			} catch (error) {
+				parsedText += `\n\n<git_commit hash="${mention}">\nError fetching commit info: ${error.message}\n</git_commit>`
+				// Track failed commit mention
+				telemetryService.captureMentionFailed("commit", "unknown", error.message)
+			}
+		}
+	}
+
+	if (urlMention) {
+		try {
+			await urlContentFetcher.closeBrowser()
+		} catch (error) {
+			Logger.error(`Error closing browser: ${error.message}`)
+		}
+	}
+
+	return parsedText
+}
+
+async function getFileOrFolderContent(mentionPath: string, cwd: string): Promise<string> {
+	const absPath = path.resolve(cwd, mentionPath)
+
+	try {
+		const stats = await fs.stat(absPath)
+
+		if (stats.isFile()) {
+			const isBinary = await isBinaryFile(absPath).catch(() => false)
+			if (isBinary) {
+				return "(Binary file, unable to display content)"
+			}
+			const content = await extractTextFromFile(absPath)
+			return content
+		} else if (stats.isDirectory()) {
+			const entries = await fs.readdir(absPath, { withFileTypes: true })
+			let folderContent = ""
+			const fileContentPromises: Promise<string | undefined>[] = []
+			entries.forEach((entry, index) => {
+				const isLast = index === entries.length - 1
+				const linePrefix = isLast ? "└── " : "├── "
+				if (entry.isFile()) {
+					folderContent += `${linePrefix}${entry.name}\n`
+					const filePath = path.join(mentionPath, entry.name)
+					const absoluteFilePath = path.resolve(absPath, entry.name)
+					// const relativeFilePath = path.relative(cwd, absoluteFilePath);
+					fileContentPromises.push(
+						(async () => {
+							try {
+								const isBinary = await isBinaryFile(absoluteFilePath).catch(() => false)
+								if (isBinary) {
+									return undefined
+								}
+								const content = await extractTextFromFile(absoluteFilePath)
+								return `<file_content path="${filePath.toPosix()}">\n${content}\n</file_content>`
+							} catch (_error) {
+								return undefined
+							}
+						})(),
+					)
+				} else if (entry.isDirectory()) {
+					folderContent += `${linePrefix}${entry.name}/\n`
+					// not recursively getting folder contents
+				} else {
+					folderContent += `${linePrefix}${entry.name}\n`
+				}
+			})
+			const fileContents = (await Promise.all(fileContentPromises)).filter((content) => content)
+			return `${folderContent}\n${fileContents.join("\n\n")}`.trim()
+		} else {
+			return `(Failed to read contents of ${mentionPath})`
+		}
+	} catch (error) {
+		throw new Error(`Failed to access path "${mentionPath}": ${error.message}`)
+	}
+}
+
+async function getWorkspaceProblems(): Promise<string> {
+	const response = await HostProvider.workspace.getDiagnostics({})
+	if (response.fileDiagnostics.length === 0) {
+		return "No errors or warnings detected."
+	}
+	return diagnosticsToProblemsString(response.fileDiagnostics, [
+		DiagnosticSeverity.DIAGNOSTIC_ERROR,
+		DiagnosticSeverity.DIAGNOSTIC_WARNING,
+	])
+}
+
+/**
+ * Parse a workspace mention to extract workspace hint and path
+ * @param mention The raw mention string (e.g., "workspace:name/path/to/file")
+ * @returns Object with workspaceHint and path, or null if not a workspace mention
+ */
+function parseWorkspaceMention(mention: string): { workspaceHint: string; path: string } | null {
+	// Match workspace:name/path or workspace:"name/path with spaces"
+	const workspaceMatch = mention.match(/^([\w-]+):(.+)$/)
+	if (!workspaceMatch) {
+		return null
+	}
+
+	const [, workspaceHint, pathPart] = workspaceMatch
+
+	// Check if it's actually a URL (has ://)
+	if (mention.includes("://")) {
+		return null
+	}
+
+	// Remove quotes from path if present
+	const quotedPathMatch = pathPart.match(/^"(.*)"$/)
+	const cleanPath = quotedPathMatch ? quotedPathMatch[1] : pathPart
+
+	return { workspaceHint, path: cleanPath }
+}
+
+function isFileMention(mention: string): boolean {
+	// Check for workspace-prefixed mentions first
+	if (parseWorkspaceMention(mention)) {
+		return true
+	}
+	// Check for regular file mentions
+	return mention.startsWith("/") || mention.startsWith('"/')
+}
+
+function getFilePathFromMention(mention: string): string {
+	// Check for workspace-prefixed mentions first
+	const workspaceMention = parseWorkspaceMention(mention)
+	if (workspaceMention) {
+		// Return path without leading slash (already cleaned)
+		return workspaceMention.path.startsWith("/") ? workspaceMention.path.slice(1) : workspaceMention.path
+	}
+
+	// Remove quotes
+	const match = mention.match(/^"(.*)"$/)
+	const filePath = match ? match[1] : mention
+	// Remove leading slash
+	return filePath.slice(1)
+}
+
+function getWorkspaceHintFromMention(mention: string): string | undefined {
+	const workspaceMention = parseWorkspaceMention(mention)
+	return workspaceMention?.workspaceHint
+}
diff --git a/apps/vscode/src/core/prompts/__tests__/toolSpecificMissingParamErrors.test.ts b/apps/vscode/src/core/prompts/__tests__/toolSpecificMissingParamErrors.test.ts
new file mode 100644
index 0000000..117fd15
--- /dev/null
+++ b/apps/vscode/src/core/prompts/__tests__/toolSpecificMissingParamErrors.test.ts
@@ -0,0 +1,67 @@
+import { describe, it } from "bun:test"
+import "should"
+import { formatResponse } from "../responses"
+
+describe("formatResponse.replaceInFileMissingDiffError", () => {
+	it("should include the file path in the error message", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("src/index.ts")
+		result.should.containEql("src/index.ts")
+	})
+
+	it("should mention that the diff parameter was empty", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("src/index.ts")
+		result.should.containEql("'diff' parameter was empty")
+	})
+
+	it("should include the SEARCH/REPLACE block format", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("src/index.ts")
+		result.should.containEql("<<<<<<< SEARCH")
+		result.should.containEql("=======")
+		result.should.containEql(">>>>>>> REPLACE")
+	})
+
+	it("should include rules about exact matching", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("src/index.ts")
+		result.should.containEql("match existing file content exactly")
+	})
+
+	it("should suggest using read_file if unsure", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("src/index.ts")
+		result.should.containEql("read_file")
+	})
+
+	it("should NOT include the generic toolUseInstructionsReminder", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("src/index.ts")
+		result.should.not.containEql("Reminder: Instructions for Tool Use")
+	})
+
+	it("should work with different file paths", () => {
+		const result = formatResponse.replaceInFileMissingDiffError("components/App.tsx")
+		result.should.containEql("components/App.tsx")
+	})
+})
+
+describe("formatResponse.executeCommandMissingCommandError", () => {
+	it("should mention that the command parameter was empty", () => {
+		const result = formatResponse.executeCommandMissingCommandError()
+		result.should.containEql("'command' parameter was empty")
+	})
+
+	it("should include a concrete XML example", () => {
+		const result = formatResponse.executeCommandMissingCommandError()
+		result.should.containEql("<execute_command>")
+		result.should.containEql("<command>")
+		result.should.containEql("</command>")
+		result.should.containEql("</execute_command>")
+	})
+
+	it("should include requires_approval in the example", () => {
+		const result = formatResponse.executeCommandMissingCommandError()
+		result.should.containEql("<requires_approval>")
+	})
+
+	it("should NOT include the generic toolUseInstructionsReminder", () => {
+		const result = formatResponse.executeCommandMissingCommandError()
+		result.should.not.containEql("Reminder: Instructions for Tool Use")
+	})
+})
diff --git a/apps/vscode/src/core/prompts/__tests__/writeToFileMissingContentError.test.ts b/apps/vscode/src/core/prompts/__tests__/writeToFileMissingContentError.test.ts
new file mode 100644
index 0000000..7538fa6
--- /dev/null
+++ b/apps/vscode/src/core/prompts/__tests__/writeToFileMissingContentError.test.ts
@@ -0,0 +1,127 @@
+import { describe, it } from "bun:test"
+import "should"
+import { formatResponse } from "../responses"
+
+describe("formatResponse.writeToFileMissingContentError", () => {
+	describe("first failure (tier 1)", () => {
+		it("should include the file path in the error message", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.containEql("src/index.ts")
+		})
+
+		it("should include the base error explanation", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.containEql("'content' parameter was empty")
+			result.should.containEql("output token limits")
+		})
+
+		it("should include helpful suggestions", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.containEql("Suggestions")
+			result.should.containEql("replace_in_file")
+			result.should.containEql("skeleton")
+		})
+
+		it("should include the tool use instructions reminder", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.containEql("Reminder: Instructions for Tool Use")
+		})
+
+		it("should mention breaking down the task into smaller steps", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.containEql("breaking down the task into smaller steps")
+		})
+
+		it("should suggest using replace_in_file for existing files", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.containEql("prefer replace_in_file to make targeted edits")
+		})
+
+		it("should not include CRITICAL language on first failure", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1)
+			result.should.not.containEql("CRITICAL")
+		})
+
+		it("should work with different file paths", () => {
+			const result = formatResponse.writeToFileMissingContentError("components/MyComponent.tsx", 1)
+			result.should.containEql("components/MyComponent.tsx")
+		})
+	})
+
+	describe("second failure (tier 2)", () => {
+		it("should indicate this is the 2nd failed attempt", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 2)
+			result.should.containEql("2nd failed attempt")
+		})
+
+		it("should strongly suggest alternative approaches", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 2)
+			result.should.containEql("must use a different strategy")
+			result.should.containEql("Recommended approaches")
+		})
+
+		it("should tell model not to retry full write again", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 2)
+			result.should.containEql("Do NOT attempt to write the full file content")
+		})
+
+		it("should not include CRITICAL language on second failure", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 2)
+			result.should.not.containEql("CRITICAL")
+		})
+	})
+
+	describe("third+ failure (tier 3)", () => {
+		it("should include CRITICAL language on third failure", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 3)
+			result.should.containEql("CRITICAL")
+			result.should.containEql("3 times in a row")
+		})
+
+		it("should tell model to NOT retry write_to_file", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 3)
+			result.should.containEql("do NOT retry write_to_file")
+		})
+
+		it("should include required action strategies", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 3)
+			result.should.containEql("Required action")
+			result.should.containEql("replace_in_file")
+			result.should.containEql("50-100 lines")
+		})
+
+		it("should show correct count for higher failure counts", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 5)
+			result.should.containEql("5 times in a row")
+		})
+	})
+
+	describe("context window awareness", () => {
+		it("should include context warning when usage exceeds 50%", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1, 60)
+			result.should.containEql("60% full")
+			result.should.containEql("MUST use a strategy that produces smaller outputs")
+		})
+
+		it("should not include context warning when usage is 50% or below", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1, 50)
+			result.should.not.containEql("% full")
+		})
+
+		it("should not include context warning when percent is undefined", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1, undefined)
+			result.should.not.containEql("% full")
+		})
+
+		it("should show high context window usage correctly", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 1, 85)
+			result.should.containEql("85% full")
+		})
+
+		it("should include context warning in tier 3 messages", () => {
+			const result = formatResponse.writeToFileMissingContentError("src/index.ts", 3, 75)
+			result.should.containEql("75% full")
+			result.should.containEql("CRITICAL")
+		})
+	})
+})
diff --git a/apps/vscode/src/core/prompts/responses.ts b/apps/vscode/src/core/prompts/responses.ts
new file mode 100644
index 0000000..ea8b6e7
--- /dev/null
+++ b/apps/vscode/src/core/prompts/responses.ts
@@ -0,0 +1,382 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import * as diff from "diff"
+import * as path from "path"
+import { Mode } from "@/shared/storage/types"
+import { ClineIgnoreController, LOCK_TEXT_SYMBOL } from "../ignore/ClineIgnoreController"
+
+const CONTEXT_WINDOW_WARNING_THRESHOLD_PERCENT = 50
+
+export const formatResponse = {
+	duplicateFileReadNotice: () =>
+		`[[NOTE] This file read has been removed to save space in the context window. Refer to the latest file read for the most up to date version of this file.]`,
+
+	contextTruncationNotice: () =>
+		`[NOTE] Some previous conversation history with the user has been removed to maintain optimal context window length. The initial user task has been retained for continuity, while intermediate conversation history has been removed. Keep this in mind as you continue assisting the user. Pay special attention to the user's latest messages.`,
+
+	processFirstUserMessageForTruncation: () => {
+		return "[Continue assisting the user!]"
+	},
+
+	condense: () =>
+		`The user has accepted the condensed conversation summary you generated. This summary covers important details of the historical conversation with the user which has been truncated.\n<explicit_instructions type="condense_response">It's crucial that you respond by ONLY asking the user what you should work on next. You should NOT take any initiative or make any assumptions about continuing with work. For example you should NOT suggest file changes or attempt to read any files.\nWhen asking the user what you should work on next, you can reference information in the summary which was just generated. However, you should NOT reference information outside of what's contained in the summary for this response. Keep this response CONCISE.</explicit_instructions>`,
+
+	toolDenied: () => `The user denied this operation.`,
+
+	toolError: (error?: string) => `The tool execution failed with the following error:\n<error>\n${error}\n</error>`,
+
+	clineIgnoreError: (path: string) =>
+		`Access to ${path} is blocked by the .clineignore file settings. You must try to continue in the task without using this file, or ask the user to update the .clineignore file.`,
+
+	permissionDeniedError: (reason: string) =>
+		`Command execution blocked by CLINE_COMMAND_PERMISSIONS: ${reason}. You must try a different approach or ask the user to update the permission settings.`,
+
+	noToolsUsed: (usingNativeToolCalls: boolean) =>
+		`[ERROR] You did not use a tool in your previous response! Please retry with a tool use.
+
+${usingNativeToolCalls ? "" : toolUseInstructionsReminder}
+
+# Next Steps
+
+If you have completed the user's task, use the attempt_completion tool. 
+If you require additional information from the user, use the ask_followup_question tool. 
+Otherwise, if you have not completed the task and do not need additional information, then proceed with the next step of the task. 
+(This is an automated message, so do not respond to it conversationally.)`,
+
+	tooManyMistakes: (feedback?: string) =>
+		`You seem to be having trouble proceeding. The user has provided the following feedback to help guide you:\n<feedback>\n${feedback}\n</feedback>`,
+
+	missingToolParameterError: (paramName: string) =>
+		`Missing value for required parameter '${paramName}'. Please retry with complete response.\n\n${toolUseInstructionsReminder}`,
+
+	/**
+	 * Specialized error for write_to_file when the 'content' parameter is missing.
+	 * Provides progressive guidance based on how many times this has happened consecutively,
+	 * and includes token budget awareness to help the model understand output constraints.
+	 */
+	writeToFileMissingContentError: (relPath: string, consecutiveFailures: number, contextUsagePercent?: number): string => {
+		const baseError = `Failed to write to '${relPath}': The 'content' parameter was empty. This typically happens when the file content is too large to generate in a single response, or when output token limits are reached before the content parameter is fully written.`
+
+		const contextWarning =
+			contextUsagePercent !== undefined && contextUsagePercent > CONTEXT_WINDOW_WARNING_THRESHOLD_PERCENT
+				? `\n\nWarning: Context window is ${contextUsagePercent}% full. The remaining output budget may be insufficient for large file writes. You MUST use a strategy that produces smaller outputs.`
+				: ""
+
+		if (consecutiveFailures >= 3) {
+			// After 3+ failures, be very directive — stop trying write_to_file entirely
+			return (
+				`${baseError}${contextWarning}\n\n` +
+				`CRITICAL: You have failed to write this file ${consecutiveFailures} times in a row. You MUST change your approach — do NOT retry write_to_file for this file again.\n\n` +
+				`Required action — choose ONE of these strategies:\n` +
+				`1. **Create an empty file first, then use replace_in_file** to add content in small sections (recommended)\n` +
+				`2. **Break the file into multiple smaller files** if architecturally appropriate\n` +
+				`3. **Write a minimal skeleton** using write_to_file (just imports, class/function signatures, no implementations), then use replace_in_file to fill in each section one at a time\n\n` +
+				`Each replace_in_file call should add no more than 50-100 lines of content at a time.`
+			)
+		}
+		if (consecutiveFailures >= 2) {
+			// After 2 failures, strongly suggest alternative approaches
+			return (
+				`${baseError}${contextWarning}\n\n` +
+				`This is your ${consecutiveFailures}${consecutiveFailures === 2 ? "nd" : "rd"} failed attempt. The file content is likely too large to generate in one response. You must use a different strategy:\n\n` +
+				`Recommended approaches:\n` +
+				`1. **Use write_to_file with a minimal skeleton** (just the structure — imports, class/function signatures, no implementations), then use replace_in_file to fill in each section incrementally\n` +
+				`2. **Use replace_in_file with smaller chunks** — if the file already exists, make targeted edits instead of rewriting the entire file\n` +
+				`3. **Break the task into smaller steps** — write one function or section at a time\n\n` +
+				`Do NOT attempt to write the full file content in a single write_to_file call again.`
+			)
+		}
+		// First failure — provide helpful guidance
+		return (
+			`${baseError}${contextWarning}\n\n` +
+			`Suggestions:\n` +
+			`- If the file is large, try breaking down the task into smaller steps. Write a skeleton first, then fill in sections using replace_in_file.\n` +
+			`- If the file already exists, prefer replace_in_file to make targeted edits instead of rewriting the entire file.\n` +
+			`- Ensure the 'content' parameter contains the complete file content before closing the tool tag.\n\n` +
+			toolUseInstructionsReminder
+		)
+	},
+
+	replaceInFileMissingDiffError: (relPath: string): string => {
+		return (
+			`Failed to edit '${relPath}': The 'diff' parameter was empty.\n\n` +
+			`The diff parameter must contain SEARCH/REPLACE blocks in this format:\n` +
+			"<<<<<<< SEARCH\n" +
+			"exact lines to find\n" +
+			"=======\n" +
+			"replacement lines\n" +
+			">>>>>>> REPLACE\n\n" +
+			`Rules:\n` +
+			`- The SEARCH block must match existing file content exactly (including whitespace and indentation)\n` +
+			`- You can include multiple SEARCH/REPLACE blocks in a single diff parameter\n` +
+			`- If you're unsure of the exact content, use read_file first to see the current file`
+		)
+	},
+
+	executeCommandMissingCommandError: (): string => {
+		return (
+			"The 'command' parameter was empty. Provide the shell command to execute.\n\n" +
+			"Example:\n" +
+			"<execute_command>\n" +
+			"<command>cd /path && python -m pytest tests/</command>\n" +
+			"<requires_approval>false</requires_approval>\n" +
+			"</execute_command>"
+		)
+	},
+
+	invalidMcpToolArgumentError: (serverName: string, toolName: string) =>
+		`Invalid JSON argument used with ${serverName} for ${toolName}. Please retry with a properly formatted JSON argument.`,
+
+	toolResult: (
+		text: string,
+		images?: string[],
+		fileString?: string,
+	): string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam> => {
+		const toolResultOutput = []
+
+		if (!(images && images.length > 0) && !fileString) {
+			return text
+		}
+
+		const textBlock: Anthropic.TextBlockParam = { type: "text", text }
+		toolResultOutput.push(textBlock)
+
+		if (images && images.length > 0) {
+			const imageBlocks: Anthropic.ImageBlockParam[] = formatImagesIntoBlocks(images)
+			toolResultOutput.push(...imageBlocks)
+		}
+
+		if (fileString) {
+			const fileBlock: Anthropic.TextBlockParam = { type: "text", text: fileString }
+			toolResultOutput.push(fileBlock)
+		}
+
+		return toolResultOutput
+	},
+
+	imageBlocks: (images?: string[]): Anthropic.ImageBlockParam[] => {
+		return formatImagesIntoBlocks(images)
+	},
+
+	formatFilesList: (
+		absolutePath: string,
+		files: string[],
+		didHitLimit: boolean,
+		clineIgnoreController?: ClineIgnoreController,
+	): string => {
+		const sorted = files
+			.map((file) => {
+				// convert absolute path to relative path
+				const relativePath = path.relative(absolutePath, file).toPosix()
+				return file.endsWith("/") ? relativePath + "/" : relativePath
+			})
+			// Sort so files are listed under their respective directories to make it clear what files are children of what directories. Since we build file list top down, even if file list is truncated it will show directories that cline can then explore further.
+			.sort((a, b) => {
+				const aParts = a.split("/") // only works if we use toPosix first
+				const bParts = b.split("/")
+				for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {
+					if (aParts[i] !== bParts[i]) {
+						// If one is a directory and the other isn't at this level, sort the directory first
+						if (i + 1 === aParts.length && i + 1 < bParts.length) {
+							return -1
+						}
+						if (i + 1 === bParts.length && i + 1 < aParts.length) {
+							return 1
+						}
+						// Otherwise, sort alphabetically
+						return aParts[i].localeCompare(bParts[i], undefined, {
+							numeric: true,
+							sensitivity: "base",
+						})
+					}
+				}
+				// If all parts are the same up to the length of the shorter path,
+				// the shorter one comes first
+				return aParts.length - bParts.length
+			})
+
+		const clineIgnoreParsed = clineIgnoreController
+			? sorted.map((filePath) => {
+					// path is relative to absolute path, not cwd
+					// validateAccess expects either path relative to cwd or absolute path
+					// otherwise, for validating against ignore patterns like "assets/icons", we would end up with just "icons", which would result in the path not being ignored.
+					const absoluteFilePath = path.resolve(absolutePath, filePath)
+					const isIgnored = !clineIgnoreController.validateAccess(absoluteFilePath)
+					if (isIgnored) {
+						return LOCK_TEXT_SYMBOL + " " + filePath
+					}
+
+					return filePath
+				})
+			: sorted
+
+		if (didHitLimit) {
+			return `${clineIgnoreParsed.join(
+				"\n",
+			)}\n\n(File list truncated. Use list_files on specific subdirectories if you need to explore further.)`
+		}
+		if (clineIgnoreParsed.length === 0 || (clineIgnoreParsed.length === 1 && clineIgnoreParsed[0] === "")) {
+			return "No files found."
+		}
+		return clineIgnoreParsed.join("\n")
+	},
+
+	createPrettyPatch: (filename = "file", oldStr?: string, newStr?: string) => {
+		// strings cannot be undefined or diff throws exception
+		const patch = diff.createPatch(filename.toPosix(), oldStr || "", newStr || "")
+		const lines = patch.split("\n")
+		const prettyPatchLines = lines.slice(4)
+		return prettyPatchLines.join("\n")
+	},
+
+	taskResumption: (
+		mode: Mode,
+		agoText: string,
+		cwd: string,
+		wasRecent: boolean | 0 | undefined,
+		responseText?: string,
+		hasPendingFileContextWarnings?: boolean,
+	): [string, string] => {
+		const taskResumptionMessage = `[TASK RESUMPTION] ${
+			mode === "plan"
+				? `This task was interrupted ${agoText}. The conversation may have been incomplete. Be aware that the project state may have changed since then. The current working directory is now '${cwd.toPosix()}'.\n\nNote: If you previously attempted a tool use that the user did not provide a result for, you should assume the tool use was not successful. However you are in PLAN MODE, so rather than continuing the task, you must respond to the user's message.`
+				: `This task was interrupted ${agoText}. It may or may not be complete, so please reassess the task context. Be aware that the project state may have changed since then. The current working directory is now '${cwd.toPosix()}'. If the task has not been completed, retry the last step before interruption and proceed with completing the task.\n\nNote: If you previously attempted a tool use that the user did not provide a result for, you should assume the tool use was not successful and assess whether you should retry. If the last tool was a browser_action, the browser has been closed and you must launch a new browser if needed.`
+		}${
+			wasRecent && !hasPendingFileContextWarnings
+				? "\n\nIMPORTANT: If the last tool use was a replace_in_file or write_to_file that was interrupted, the file was reverted back to its original state before the interrupted edit, and you do NOT need to re-read the file as you already have its up-to-date contents."
+				: ""
+		}`
+
+		const userResponseMessage = `${
+			responseText
+				? `${mode === "plan" ? "New message to respond to with plan_mode_respond tool (be sure to provide your response in the <response> parameter)" : "New instructions for task continuation"}:\n<user_message>\n${responseText}\n</user_message>`
+				: mode === "plan"
+					? "(The user did not provide a new message. Consider asking them how they'd like you to proceed, or suggest to them to switch to Act mode to continue with the task.)"
+					: ""
+		}`
+
+		return [taskResumptionMessage, userResponseMessage]
+	},
+
+	planModeInstructions: () => {
+		return `In this mode you should focus on information gathering, asking questions, and architecting a solution. Once you have a plan, use the plan_mode_respond tool to engage in a conversational back and forth with the user. Do not use the plan_mode_respond tool until you've gathered all the information you need e.g. with read_file or ask_followup_question.
+(Remember: If it seems the user wants you to use tools only available in Act Mode, you should ask the user to "toggle to Act mode" (use those words) - they will have to manually do this themselves with the Plan/Act toggle button below. You do not have the ability to switch to Act Mode yourself, and must wait for the user to do it themselves once they are satisfied with the plan. You also cannot present an option to toggle to Act mode, as this will be something you need to direct the user to do manually themselves.)`
+	},
+
+	fileEditWithUserChanges: (
+		relPath: string,
+		userEdits: string,
+		autoFormattingEdits: string | undefined,
+		finalContent: string | undefined,
+		newProblemsMessage: string | undefined,
+	) =>
+		`The user made the following updates to your content:\n\n${userEdits}\n\n` +
+		(autoFormattingEdits
+			? `The user's editor also applied the following auto-formatting to your content:\n\n${autoFormattingEdits}\n\n(Note: Pay close attention to changes such as single quotes being converted to double quotes, semicolons being removed or added, long lines being broken into multiple lines, adjusting indentation style, adding/removing trailing commas, etc. This will help you ensure future SEARCH/REPLACE operations to this file are accurate.)\n\n`
+			: "") +
+		`The updated content, which includes both your original modifications and the additional edits, has been successfully saved to ${relPath.toPosix()}. Here is the full, updated content of the file that was saved:\n\n` +
+		`<final_file_content path="${relPath.toPosix()}">\n${finalContent}\n</final_file_content>\n\n` +
+		`Please note:\n` +
+		`1. You do not need to re-write the file with these changes, as they have already been applied.\n` +
+		`2. Proceed with the task using this updated file content as the new baseline.\n` +
+		`3. If the user's edits have addressed part of the task or changed the requirements, adjust your approach accordingly.` +
+		`4. IMPORTANT: For any future changes to this file, use the final_file_content shown above as your reference. This content reflects the current state of the file, including both user edits and any auto-formatting (e.g., if you used single quotes but the formatter converted them to double quotes). Always base your SEARCH/REPLACE operations on this final version to ensure accuracy.\n` +
+		`${newProblemsMessage}`,
+
+	fileEditWithoutUserChanges: (
+		relPath: string,
+		autoFormattingEdits: string | undefined,
+		finalContent: string | undefined,
+		newProblemsMessage: string | undefined,
+	) =>
+		`The content was successfully saved to ${relPath.toPosix()}.\n\n` +
+		(autoFormattingEdits
+			? `Along with your edits, the user's editor applied the following auto-formatting to your content:\n\n${autoFormattingEdits}\n\n(Note: Pay close attention to changes such as single quotes being converted to double quotes, semicolons being removed or added, long lines being broken into multiple lines, adjusting indentation style, adding/removing trailing commas, etc. This will help you ensure future SEARCH/REPLACE operations to this file are accurate.)\n\n`
+			: "") +
+		`Here is the full, updated content of the file that was saved:\n\n` +
+		`<final_file_content path="${relPath.toPosix()}">\n${finalContent}\n</final_file_content>\n\n` +
+		`IMPORTANT: For any future changes to this file, use the final_file_content shown above as your reference. This content reflects the current state of the file, including any auto-formatting (e.g., if you used single quotes but the formatter converted them to double quotes). Always base your SEARCH/REPLACE operations on this final version to ensure accuracy.\n\n` +
+		`${newProblemsMessage}`,
+
+	diffError: (relPath: string, originalContent: string | undefined) =>
+		`This is likely because the SEARCH block content doesn't match exactly with what's in the file, or if you used multiple SEARCH/REPLACE blocks they may not have been in the order they appear in the file. (Please also ensure that when using the replace_in_file tool, Do NOT add extra characters to the markers (e.g., ------- SEARCH> is INVALID). Do NOT forget to use the closing +++++++ REPLACE marker. Do NOT modify the marker format in any way. Malformed XML will cause complete tool failure and break the entire editing process.)\n\n` +
+		`The file was reverted to its original state:\n\n` +
+		`<file_content path="${relPath.toPosix()}">\n${originalContent}\n</file_content>\n\n` +
+		`Now that you have the latest state of the file, try the operation again with fewer, more precise SEARCH blocks. For large files especially, it may be prudent to try to limit yourself to <5 SEARCH/REPLACE blocks at a time, then wait for the user to respond with the result of the operation before following up with another replace_in_file call to make additional edits.\n(If you run into this error 3 times in a row, you may use the write_to_file tool as a fallback.)`,
+
+	toolAlreadyUsed: (toolName: string) =>
+		`Tool [${toolName}] was not executed because a tool has already been used in this message. Only one tool may be used per message. You must assess the first tool's result before proceeding to use the next tool.`,
+
+	repeatedToolCall: (toolName: string, count: number) =>
+		`Tool [${toolName}] has been called ${count} times consecutively with identical arguments. This is not making progress. Please use a different tool or different arguments instead of repeating the same call.`,
+
+	clineIgnoreInstructions: (content: string) =>
+		`# .clineignore\n\n(The following is provided by a root-level .clineignore file where the user has specified files and directories that should not be accessed. When using list_files, you'll notice a ${LOCK_TEXT_SYMBOL} next to files that are blocked. Attempting to access the file's contents e.g. through read_file will result in an error.)\n\n${content}\n.clineignore`,
+
+	clineRulesGlobalDirectoryInstructions: (globalClineRulesFilePath: string, content: string) =>
+		`# .clinerules/\n\nThe following is provided by a global .clinerules/ directory, located at ${globalClineRulesFilePath.toPosix()}, where the user has specified instructions for all working directories:\n\n${content}`,
+
+	clineRulesLocalDirectoryInstructions: (cwd: string, content: string) =>
+		`# .clinerules/\n\nThe following is provided by a root-level .clinerules/ directory where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	clineRulesLocalFileInstructions: (cwd: string, content: string) =>
+		`# .clinerules\n\nThe following is provided by a root-level .clinerules file where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	windsurfRulesLocalFileInstructions: (cwd: string, content: string) =>
+		`# .windsurfrules\n\nThe following is provided by a root-level .windsurfrules file where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	cursorRulesLocalFileInstructions: (cwd: string, content: string) =>
+		`# .cursorrules\n\nThe following is provided by a root-level .cursorrules file where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	cursorRulesLocalDirectoryInstructions: (cwd: string, content: string) =>
+		`# .cursor/rules\n\nThe following is provided by a root-level .cursor/rules directory where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	agentsRulesLocalFileInstructions: (cwd: string, content: string) =>
+		`# AGENTS.md\n\nThe following is provided by AGENTS.md files found recursively throughout this working directory (${cwd.toPosix()}) where the user has specified instructions. Nested AGENTS.md will be combined below, and you should only apply the instructions for each AGENTS.md file that is directly applicable to the current task, i.e. if you are reading or writing to a file in that directory.\n\n${content}`,
+
+	fileContextWarning: (editedFiles: string[]): string => {
+		const fileCount = editedFiles.length
+		const fileVerb = fileCount === 1 ? "file has" : "files have"
+		const fileDemonstrativePronoun = fileCount === 1 ? "this file" : "these files"
+		const filePersonalPronoun = fileCount === 1 ? "it" : "they"
+
+		return (
+			`<explicit_instructions>\nCRITICAL FILE STATE ALERT: ${fileCount} ${fileVerb} been externally modified since your last interaction. Your cached understanding of ${fileDemonstrativePronoun} is now stale and unreliable. Before making ANY modifications to ${fileDemonstrativePronoun}, you must execute read_file to obtain the current state, as ${filePersonalPronoun} may contain completely different content than what you expect:\n` +
+			`${editedFiles.map((file) => ` ${path.resolve(file).toPosix()}`).join("\n")}\n` +
+			`Failure to re-read before editing will result in replace_in_file edit errors, requiring subsequent attempts and wasting tokens. You DO NOT need to re-read these files after subsequent edits, unless instructed to do so.\n</explicit_instructions>`
+		)
+	},
+}
+
+// to avoid circular dependency
+const formatImagesIntoBlocks = (images?: string[]): Anthropic.ImageBlockParam[] => {
+	return images
+		? images.map((dataUrl) => {
+				// data:image/png;base64,base64string
+				const [rest, base64] = dataUrl.split(",")
+				const mimeType = rest.split(":")[1].split(";")[0]
+				return {
+					type: "image",
+					source: {
+						type: "base64",
+						media_type: mimeType,
+						data: base64,
+					},
+				} as Anthropic.ImageBlockParam
+			})
+		: []
+}
+
+const toolUseInstructionsReminder = `# Reminder: Instructions for Tool Use
+Tool uses are formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</tool_name>
+For example:
+<attempt_completion>
+<result>
+I have completed the task...
+</result>
+</attempt_completion>
+Always adhere to this format for all tool uses to ensure proper parsing and execution.`
diff --git a/apps/vscode/src/core/storage/StateManager.ts b/apps/vscode/src/core/storage/StateManager.ts
new file mode 100644
index 0000000..028d5fe
--- /dev/null
+++ b/apps/vscode/src/core/storage/StateManager.ts
@@ -0,0 +1,899 @@
+import type { ApiConfiguration, ModelInfo } from "@shared/api"
+import {
+	ApiHandlerSettingsKeys,
+	type GlobalState,
+	type GlobalStateAndSettings,
+	type GlobalStateAndSettingsKey,
+	isSecretKey,
+	isSettingsKey,
+	type LocalState,
+	type LocalStateKey,
+	type RemoteConfigFields,
+	type SecretKey,
+	SecretKeys,
+	type Secrets,
+	type Settings,
+	type SettingsKey,
+} from "@shared/storage/state-keys"
+import type { StorageContext } from "@shared/storage/storage-context"
+import { FSWatcher } from "chokidar"
+import { initializeDistinctId } from "@/services/logging/distinctId"
+import { Logger } from "@/shared/services/Logger"
+import { AgentConfigLoader } from "../task/tools/subagent/AgentConfigLoader"
+import { readTaskSettingsFromStorage, writeTaskSettingsToStorage } from "./disk"
+import { STATE_MANAGER_NOT_INITIALIZED } from "./error-messages"
+import { filterAllowedRemoteConfigFields } from "./remote-config/utils"
+import { readGlobalStateFromStorage, readSecretsFromStorage, readWorkspaceStateFromStorage } from "./utils/state-helpers"
+export interface PersistenceErrorEvent {
+	error: Error
+}
+
+/**
+ * In-memory state manager for fast state access.
+ * Provides immediate reads/writes with async disk persistence.
+ *
+ * All persistent storage is backed by file-based stores via StorageContext.
+ * This is shared across all platforms (VSCode, CLI, JetBrains).
+ *
+ * MULTI-INSTANCE BEHAVIOR:
+ * StateManager reads from disk ONLY during initialize(). After that, all reads come from
+ * the in-memory cache. Writes update both the cache and disk, but other running instances
+ * won't see those changes because they don't re-read from disk.
+ *
+ * This means: If you have multiple VS Code windows open, each has its own StateManager
+ * instance with its own cache. Changing a setting (like plan/act mode) in Window A writes
+ * to disk, but Window B keeps using its cached value. Window B only sees the change after
+ * restart (when it re-initializes from disk).
+ *
+ * This is intentional for performance (avoids constant disk reads) and provides natural
+ * isolation between concurrent instances. Task-specific state is independent anyway since
+ * each window typically runs different tasks.
+ */
+export class StateManager {
+	private static instance: StateManager | null = null
+
+	private globalStateCache: GlobalStateAndSettings = {} as GlobalStateAndSettings
+	private taskStateCache: Partial<Settings> = {}
+	private sessionOverrideCache: Partial<Settings> = {}
+	private remoteConfigCache: Partial<RemoteConfigFields> = {} as RemoteConfigFields
+	private secretsCache: Secrets = {} as Secrets
+	private workspaceStateCache: LocalState = {} as LocalState
+
+	/**
+	 * File-backed storage context. All reads/writes to persistent state go through here.
+	 * Do NOT access VSCode's ExtensionContext for storage — use this instead.
+	 */
+	private storage: StorageContext
+	private isInitialized = false
+
+	// Cache TTL: 1 hour - long enough to prevent duplicate fetches, short enough to see new models
+	private readonly MODEL_CACHE_TTL_MS = 60 * 60 * 1000
+
+	// In-memory model info cache (not persisted to disk)
+	// These are for dynamic providers that fetch models from APIs
+	private modelInfoCache: {
+		openRouterModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		groqModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		basetenModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		huggingFaceModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		requestyModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		huaweiCloudMaasModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		hicapModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		aihubmixModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		liteLlmModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+		vercelModels: { data: Record<string, ModelInfo>; timestamp: number } | null
+	} = {
+		openRouterModels: null,
+		groqModels: null,
+		basetenModels: null,
+		huggingFaceModels: null,
+		requestyModels: null,
+		huaweiCloudMaasModels: null,
+		hicapModels: null,
+		aihubmixModels: null,
+		liteLlmModels: null,
+		vercelModels: null,
+	}
+
+	// Debounced persistence state
+	private pendingGlobalState = new Set<GlobalStateAndSettingsKey>()
+	private pendingTaskState = new Map<string, Set<SettingsKey>>()
+	private pendingSecrets = new Set<SecretKey>()
+	private pendingWorkspaceState = new Set<LocalStateKey>()
+	private persistenceTimeout: NodeJS.Timeout | null = null
+	private readonly PERSISTENCE_DELAY_MS = 500
+	private taskHistoryWatcher: FSWatcher | null = null
+
+	// Callback for persistence errors
+	onPersistenceError?: (event: PersistenceErrorEvent) => void
+
+	// Callback to sync external state changes with the UI client
+	onSyncExternalChange?: () => void | Promise<void>
+
+	private constructor(storage: StorageContext) {
+		this.storage = storage
+	}
+
+	/**
+	 * Initialize the cache by loading data from the file-backed StorageContext.
+	 */
+	public static async initialize(storage: StorageContext): Promise<StateManager> {
+		if (!StateManager.instance) {
+			StateManager.instance = new StateManager(storage)
+		}
+
+		if (StateManager.instance.isInitialized) {
+			throw new Error("StateManager has already been initialized.")
+		}
+
+		try {
+			await initializeDistinctId(storage)
+
+			// Load all extension state from file-backed stores
+			const globalState = await readGlobalStateFromStorage(storage.globalState)
+			const secrets = readSecretsFromStorage(storage.secrets)
+			const workspaceState = readWorkspaceStateFromStorage(storage.workspaceState)
+
+			// Populate the cache with all extension state and secrets fields
+			// Use populate method to avoid triggering persistence during initialization
+			StateManager.instance.populateCache(globalState, secrets, workspaceState)
+
+			StateManager.instance.isInitialized = true
+
+			await AgentConfigLoader.getInstance().ready()
+		} catch (error) {
+			Logger.error("[StateManager] Failed to initialize:", error)
+			throw error
+		}
+
+		return StateManager.instance
+	}
+
+	public static get(): StateManager {
+		if (!StateManager.instance) {
+			throw new Error("StateManager has not been initialized")
+		}
+		return StateManager.instance
+	}
+
+	/**
+	 * Register callbacks for state manager events
+	 */
+	public registerCallbacks(callbacks: {
+		onPersistenceError?: (event: PersistenceErrorEvent) => void | Promise<void>
+		onSyncExternalChange?: () => void | Promise<void>
+	}): void {
+		if (callbacks.onPersistenceError) {
+			this.onPersistenceError = callbacks.onPersistenceError
+		}
+		if (callbacks.onSyncExternalChange) {
+			this.onSyncExternalChange = callbacks.onSyncExternalChange
+		}
+	}
+
+	/**
+	 * Set method for global state keys - updates cache immediately and schedules debounced persistence
+	 */
+	setGlobalState<K extends keyof GlobalStateAndSettings>(key: K, value: GlobalStateAndSettings[K]): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for instant access
+		this.globalStateCache[key] = value
+
+		// Add to pending persistence set and schedule debounced write
+		this.pendingGlobalState.add(key)
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Batch set method for global state keys - updates cache immediately and schedules debounced persistence
+	 */
+	setGlobalStateBatch(updates: Partial<GlobalStateAndSettings>): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache in one go
+		// Using object.assign to because typescript is not able to infer the type of the updates object when using Object.entries
+		Object.assign(this.globalStateCache, updates)
+
+		// Then track the keys for persistence
+		Object.keys(updates).forEach((key) => {
+			this.pendingGlobalState.add(key as GlobalStateAndSettingsKey)
+		})
+
+		// Schedule debounced persistence
+		this.scheduleDebouncedPersistence()
+	}
+
+	private setRemoteConfigState(updates: Partial<GlobalStateAndSettings>): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache in one go
+		this.remoteConfigCache = {
+			...this.remoteConfigCache,
+			...filterAllowedRemoteConfigFields(updates),
+		}
+	}
+
+	/**
+	 * Set method for task settings keys - updates cache immediately and schedules debounced persistence
+	 */
+	setTaskSettings<K extends keyof Settings>(taskId: string, key: K, value: Settings[K]): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for instant access
+		this.taskStateCache[key] = value
+
+		// Add to pending persistence set and schedule debounced write
+		if (!this.pendingTaskState.has(taskId)) {
+			this.pendingTaskState.set(taskId, new Set())
+		}
+		this.pendingTaskState.get(taskId)?.add(key)
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Batch set method for task settings keys - updates cache immediately and schedules debounced persistence
+	 */
+	setTaskSettingsBatch(taskId: string, updates: Partial<Settings>): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache in one go
+		Object.assign(this.taskStateCache, updates)
+
+		// Then track the keys for persistence
+		if (!this.pendingTaskState.has(taskId)) {
+			this.pendingTaskState.set(taskId, new Set())
+		}
+		Object.keys(updates).forEach((key) => {
+			this.pendingTaskState.get(taskId)?.add(key as SettingsKey)
+		})
+
+		// Schedule debounced persistence
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Load task settings from disk into cache
+	 */
+	async loadTaskSettings(taskId: string): Promise<void> {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		try {
+			const taskSettings = await readTaskSettingsFromStorage(taskId)
+			// Populate task cache with loaded settings
+			Object.assign(this.taskStateCache, taskSettings)
+		} catch (error) {
+			// If reading fails, just use empty cache
+			Logger.error("[StateManager] Failed to load task settings, defaulting to globally selected settings.", error)
+		}
+	}
+
+	/**
+	 * Clear task settings cache - ensures pending changes are persisted first
+	 */
+	async clearTaskSettings(): Promise<void> {
+		// If there are pending task settings, persist them first
+		if (this.pendingTaskState.size > 0) {
+			try {
+				// Persist pending task state immediately
+				await this.persistTaskStateBatch(this.pendingTaskState)
+				// Clear pending set after successful persistence
+				this.pendingTaskState.clear()
+			} catch (error) {
+				Logger.error("[StateManager] Failed to persist task settings before clearing:", error)
+			}
+		}
+
+		this.taskStateCache = {}
+		this.pendingTaskState.clear()
+	}
+
+	/**
+	 * Set method for secret keys - updates cache immediately and schedules debounced persistence
+	 */
+	setSecret<K extends keyof Secrets>(key: K, value: Secrets[K]): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for instant access
+		this.secretsCache[key] = value
+
+		// Add to pending persistence set and schedule debounced write
+		this.pendingSecrets.add(key)
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Batch set method for secret keys - updates cache immediately and schedules debounced persistence
+	 */
+	setSecretsBatch(updates: Partial<Secrets>): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for all keys
+		Object.entries(updates).forEach(([key, value]) => {
+			// Skip unchanged values as we don't want to trigger unnecessary
+			// writes & incorrectly fire an onDidChange events.
+			const current = this.secretsCache[key as keyof Secrets]
+			if (current === value) {
+				return
+			}
+			this.secretsCache[key as keyof Secrets] = value
+			this.pendingSecrets.add(key as SecretKey)
+		})
+
+		// Schedule debounced persistence
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Set method for workspace state keys - updates cache immediately and schedules debounced persistence
+	 */
+	setWorkspaceState<K extends keyof LocalState>(key: K, value: LocalState[K]): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for instant access
+		this.workspaceStateCache[key] = value
+
+		// Add to pending persistence set and schedule debounced write
+		this.pendingWorkspaceState.add(key)
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Batch set method for workspace state keys - updates cache immediately and schedules debounced persistence
+	 */
+	setWorkspaceStateBatch(updates: Partial<LocalState>): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for all keys
+		Object.entries(updates).forEach(([key, value]) => {
+			this.workspaceStateCache[key as keyof LocalState] = value
+			this.pendingWorkspaceState.add(key as LocalStateKey)
+		})
+
+		// Schedule debounced persistence
+		this.scheduleDebouncedPersistence()
+	}
+
+	/**
+	 * Set a session-scoped override for a settings key.
+	 * Session overrides are in-memory only and are NEVER persisted to disk.
+	 * They take precedence after remote config but before task-specific and global settings.
+	 *
+	 * Use this for CLI flags like --yolo that should apply for the current
+	 * process lifetime only, without modifying the user's saved settings.
+	 */
+	setSessionOverride<K extends keyof Settings>(key: K, value: Settings[K]): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		this.sessionOverrideCache[key] = value
+	}
+
+	/**
+	 * Set method for remote config field - updates cache immediately (no persistence)
+	 * Remote config is read-only from the extension's perspective and only stored in memory
+	 */
+	setRemoteConfigField<K extends keyof RemoteConfigFields>(key: K, value: RemoteConfigFields[K]): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Update cache immediately for instant access (no persistence needed)
+		this.remoteConfigCache[key] = value
+	}
+
+	/**
+	 * Get method for remote config settings - returns cache immediately (no persistence)
+	 * Remote config is read-only from the extension's perspective and only stored in memory
+	 */
+	getRemoteConfigSettings(): Partial<RemoteConfigFields> {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		return this.remoteConfigCache
+	}
+
+	/**
+	 * Clear remote config cache
+	 * Used when switching organizations or when remote config is no longer applicable
+	 */
+	clearRemoteConfig(): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		this.remoteConfigCache = {} as GlobalStateAndSettings
+	}
+
+	/**
+	 * Atomically replace the entire remote config cache.
+	 * Use this instead of clearRemoteConfig() + setRemoteConfigField() loops
+	 * to avoid a window where the cache is empty and concurrent readers get stale data.
+	 */
+	replaceRemoteConfig(newCache: Partial<RemoteConfigFields>): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		this.remoteConfigCache = { ...newCache }
+	}
+
+	/**
+	 * Set models cache for a specific provider (in-memory only, not persisted)
+	 */
+	setModelsCache(
+		provider:
+			| "openRouter"
+			| "groq"
+			| "baseten"
+			| "huggingFace"
+			| "requesty"
+			| "huaweiCloudMaas"
+			| "hicap"
+			| "aihubmix"
+			| "liteLlm"
+			| "vercel",
+		models: Record<string, ModelInfo>,
+	): void {
+		const cacheKey = `${provider}Models` as keyof typeof this.modelInfoCache
+		this.modelInfoCache[cacheKey] = { data: models, timestamp: Date.now() }
+	}
+
+	getModelsCache(
+		provider:
+			| "openRouter"
+			| "groq"
+			| "baseten"
+			| "huggingFace"
+			| "requesty"
+			| "huaweiCloudMaas"
+			| "hicap"
+			| "aihubmix"
+			| "liteLlm"
+			| "vercel",
+	): Record<string, ModelInfo> | null {
+		const cacheKey = `${provider}Models` as keyof typeof this.modelInfoCache
+		const cached = this.modelInfoCache[cacheKey]
+
+		if (!cached) {
+			return null
+		}
+
+		// Check if cache has expired
+		if (Date.now() - cached.timestamp > this.MODEL_CACHE_TTL_MS) {
+			this.modelInfoCache[cacheKey] = null
+			return null
+		}
+
+		return cached.data
+	}
+
+	/**
+	 * Get model info by provider and model ID (from in-memory cache)
+	 */
+	getModelInfo(
+		provider:
+			| "openRouter"
+			| "groq"
+			| "baseten"
+			| "huggingFace"
+			| "requesty"
+			| "huaweiCloudMaas"
+			| "hicap"
+			| "aihubmix"
+			| "liteLlm",
+		modelId: string,
+	): ModelInfo | undefined {
+		const cacheKey = `${provider}Models` as keyof typeof this.modelInfoCache
+		const cached = this.modelInfoCache[cacheKey]
+
+		if (!cached) {
+			return undefined
+		}
+
+		// Check if cache has expired
+		if (Date.now() - cached.timestamp > this.MODEL_CACHE_TTL_MS) {
+			this.modelInfoCache[cacheKey] = null
+			return undefined
+		}
+
+		return cached.data[modelId]
+	}
+
+	/**
+	 * Convenience method for getting API configuration
+	 * Ensures cache is initialized if not already done
+	 */
+	getApiConfiguration(): ApiConfiguration {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Construct API configuration from cached component keys
+		return this.constructApiConfigurationFromCache()
+	}
+
+	/**
+	 * Convenience method for setting API configuration
+	 * Automatically categorizes keys based on STATE_DEFINITION and SecretKeys
+	 */
+	setApiConfiguration(apiConfiguration: ApiConfiguration): void {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+
+		// Automatically categorize the API configuration keys
+		const { settingsUpdates, secretsUpdates } = Object.entries(apiConfiguration).reduce(
+			(acc, [key, value]) => {
+				if (key === undefined || value === undefined) {
+					return acc // Skip undefined values
+				}
+
+				if (isSecretKey(key)) {
+					// This is a secret key
+					acc.secretsUpdates[key as keyof Secrets] = value as any
+				} else if (isSettingsKey(key)) {
+					// This is a settings key
+					acc.settingsUpdates[key as keyof Settings] = value as any
+				}
+
+				return acc
+			},
+			{ settingsUpdates: {} as Partial<Settings>, secretsUpdates: {} as Partial<Secrets> },
+		)
+
+		// Batch update settings (stored in global state)
+		if (Object.keys(settingsUpdates).length > 0) {
+			this.setRemoteConfigState(settingsUpdates)
+			this.setGlobalStateBatch(settingsUpdates)
+		}
+
+		// Batch update secrets
+		if (Object.keys(secretsUpdates).length > 0) {
+			this.setSecretsBatch(secretsUpdates)
+		}
+	}
+
+	/**
+	 * Get method for global settings keys - reads from in-memory cache
+	 * Precedence: remote config > session override > task settings > global settings
+	 */
+	getGlobalSettingsKey<K extends keyof Settings>(key: K): Settings[K] {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		if (this.remoteConfigCache[key] !== undefined) {
+			return this.remoteConfigCache[key] as Settings[K]
+		}
+		if (this.sessionOverrideCache[key] !== undefined) {
+			return this.sessionOverrideCache[key] as Settings[K]
+		}
+		if (this.taskStateCache[key] !== undefined) {
+			return this.taskStateCache[key]
+		}
+		return this.globalStateCache[key]
+	}
+
+	/**
+	 * Get method for global state keys - reads from in-memory cache
+	 */
+	getGlobalStateKey<K extends keyof GlobalState>(key: K): GlobalState[K] {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		if (this.remoteConfigCache[key] !== undefined) {
+			return this.remoteConfigCache[key] as GlobalState[K]
+		}
+		return this.globalStateCache[key]
+	}
+
+	/**
+	 * Get method for secret keys - reads from in-memory cache
+	 */
+	getSecretKey<K extends keyof Secrets>(key: K): Secrets[K] {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		return this.secretsCache[key]
+	}
+
+	/**
+	 * Get method for workspace state keys - reads from in-memory cache
+	 */
+	getWorkspaceStateKey<K extends keyof LocalState>(key: K): LocalState[K] {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		return this.workspaceStateCache[key]
+	}
+
+	/**
+	 * Reinitialize the state manager by clearing all state and reloading from disk
+	 * Used for error recovery when write operations fail
+	 */
+	async reInitialize(currentTaskId?: string): Promise<void> {
+		if (this.persistenceTimeout) {
+			await this.persistPendingState()
+		}
+		// Clear all cached data and pending state
+		this.dispose()
+
+		// Reinitialize from the same storage context
+		await StateManager.initialize(this.storage)
+
+		// If there's an active task, reload its settings
+		if (currentTaskId) {
+			await this.loadTaskSettings(currentTaskId)
+		}
+	}
+
+	/**
+	 * Dispose of the state manager
+	 */
+	private dispose(): void {
+		if (this.persistenceTimeout) {
+			clearTimeout(this.persistenceTimeout)
+			this.persistenceTimeout = null
+		}
+		// Close file watcher if active
+		if (this.taskHistoryWatcher) {
+			this.taskHistoryWatcher.close()
+			this.taskHistoryWatcher = null
+		}
+
+		this.pendingGlobalState.clear()
+		this.pendingSecrets.clear()
+		this.pendingWorkspaceState.clear()
+		this.pendingTaskState.clear()
+
+		this.globalStateCache = {} as GlobalStateAndSettings
+		this.secretsCache = {} as Secrets
+		this.workspaceStateCache = {} as LocalState
+		this.taskStateCache = {}
+		this.remoteConfigCache = {} as GlobalStateAndSettings
+		this.sessionOverrideCache = {}
+
+		this.isInitialized = false
+	}
+
+	/**
+	 * Private method to persist all pending state changes
+	 * Returns early if nothing is pending
+	 */
+	private async persistPendingState(): Promise<void> {
+		// Early return if nothing to persist
+		if (
+			this.pendingGlobalState.size === 0 &&
+			this.pendingSecrets.size === 0 &&
+			this.pendingWorkspaceState.size === 0 &&
+			this.pendingTaskState.size === 0
+		) {
+			return
+		}
+
+		// Execute all persistence operations in parallel
+		await Promise.all([
+			this.persistGlobalStateBatch(this.pendingGlobalState),
+			this.persistSecretsBatch(this.pendingSecrets),
+			this.persistWorkspaceStateBatch(this.pendingWorkspaceState),
+			this.persistTaskStateBatch(this.pendingTaskState),
+		])
+
+		// Clear pending sets after successful persistence
+		this.pendingGlobalState.clear()
+		this.pendingSecrets.clear()
+		this.pendingWorkspaceState.clear()
+		this.pendingTaskState.clear()
+	}
+
+	/**
+	 * Flush all pending state changes immediately to disk
+	 * Bypasses the debounced persistence and forces immediate writes
+	 */
+	public async flushPendingState(): Promise<void> {
+		// Cancel any pending timeout
+		if (this.persistenceTimeout) {
+			clearTimeout(this.persistenceTimeout)
+			this.persistenceTimeout = null
+		}
+
+		// Execute persistence immediately
+		await this.persistPendingState()
+	}
+
+	/**
+	 * Schedule debounced persistence - simple timeout-based persistence
+	 */
+	private scheduleDebouncedPersistence(): void {
+		// Clear existing timeout if one is pending
+		if (this.persistenceTimeout) {
+			clearTimeout(this.persistenceTimeout)
+		}
+
+		// Schedule a new timeout to persist pending changes
+		this.persistenceTimeout = setTimeout(async () => {
+			try {
+				await this.persistPendingState()
+				this.persistenceTimeout = null
+			} catch (error) {
+				Logger.error("[StateManager] Failed to persist pending changes:", error)
+				this.persistenceTimeout = null
+
+				// Call persistence error callback for error recovery
+				this.onPersistenceError?.({ error: error })
+			}
+		}, this.PERSISTENCE_DELAY_MS)
+	}
+
+	/**
+	 * Persist global state keys to the file-backed store.
+	 * Uses setBatch for efficiency (single disk write).
+	 */
+	private async persistGlobalStateBatch(keys: Set<GlobalStateAndSettingsKey>): Promise<void> {
+		// Separate taskHistory (goes to its own file) from regular global state
+		const regularEntries: Record<string, any> = {}
+
+		for (const key of keys) {
+			if (key === "taskHistory") {
+			} else {
+				regularEntries[key] = this.globalStateCache[key]
+			}
+		}
+
+		// Batch write all regular keys in a single disk operation
+		if (Object.keys(regularEntries).length > 0) {
+			this.storage.globalStateBackingStore.setBatch(regularEntries)
+		}
+	}
+
+	/**
+	 * Private method to batch persist task state keys with a single write operation
+	 */
+	private async persistTaskStateBatch(pendingTaskStates: Map<string, Set<SettingsKey>>): Promise<void> {
+		if (pendingTaskStates.size === 0) {
+			return
+		}
+		// Persist each task's settings
+		await Promise.all(
+			Array.from(pendingTaskStates.entries()).map(([taskId, keys]) => {
+				if (keys.size === 0) {
+					return Promise.resolve()
+				}
+				const settingsToWrite: Record<string, any> = {}
+				for (const key of keys) {
+					const value = this.taskStateCache[key]
+					if (value !== undefined) {
+						settingsToWrite[key] = value
+					}
+				}
+				return writeTaskSettingsToStorage(taskId, settingsToWrite)
+			}),
+		)
+	}
+
+	/**
+	 * Persist secrets to the file-backed store.
+	 * Uses setBatch for efficiency (single disk write).
+	 */
+	private async persistSecretsBatch(keys: Set<SecretKey>): Promise<void> {
+		const entries: Record<string, string | undefined> = {}
+		for (const key of keys) {
+			const value = this.secretsCache[key]
+			entries[key] = value || undefined // Convert empty strings to undefined (delete)
+		}
+		this.storage.secrets.setBatch(entries)
+	}
+
+	/**
+	 * Persist workspace state to the file-backed store.
+	 * Uses setBatch for efficiency (single disk write).
+	 */
+	private async persistWorkspaceStateBatch(keys: Set<LocalStateKey>): Promise<void> {
+		const entries: Record<string, any> = {}
+		for (const key of keys) {
+			entries[key] = this.workspaceStateCache[key]
+		}
+		this.storage.workspaceState.setBatch(entries)
+	}
+
+	/**
+	 * Private method to populate cache with all extension state without triggering persistence
+	 * Used during initialization
+	 */
+	private populateCache(globalState: GlobalState, secrets: Secrets, workspaceState: LocalState): void {
+		Object.assign(this.globalStateCache, globalState)
+		Object.assign(this.secretsCache, secrets)
+		Object.assign(this.workspaceStateCache, workspaceState)
+	}
+
+	/**
+	 * Helper to get a setting value with override support
+	 * Precedence: remote config > session override > task settings > global settings
+	 */
+	private getSettingWithOverride<K extends keyof Settings>(key: K): Settings[K] {
+		const remoteValue = this.remoteConfigCache[key]
+		if (remoteValue !== undefined) {
+			return remoteValue
+		}
+		if (this.sessionOverrideCache[key] !== undefined) {
+			return this.sessionOverrideCache[key]
+		}
+		const taskValue = this.taskStateCache[key]
+		if (taskValue !== undefined) {
+			return taskValue
+		}
+		return this.globalStateCache[key]
+	}
+
+	/**
+	 * Helper to get a secret value
+	 */
+	private getSecret<K extends keyof Secrets>(key: K): Secrets[K] {
+		return this.secretsCache[key]
+	}
+
+	/**
+	 * Construct API configuration from cached component keys
+	 */
+	private constructApiConfigurationFromCache(): ApiConfiguration {
+		// Build secrets object
+		const secrets = Object.fromEntries(SecretKeys.map((key) => [key, this.getSecret(key)])) as Secrets
+
+		// Preserve legacy fallback behavior for LiteLLM API key:
+		// if a remoteLiteLlmApiKey is set (via remote config), it should
+		// take precedence over the local liteLlmApiKey.
+		const remoteLiteLlmApiKey = this.secretsCache.remoteLiteLlmApiKey
+		if (remoteLiteLlmApiKey !== undefined && remoteLiteLlmApiKey !== null && remoteLiteLlmApiKey !== "") {
+			secrets.liteLlmApiKey = remoteLiteLlmApiKey
+		}
+
+		// Build API handler settings object with task override support
+		const settings = Object.fromEntries(ApiHandlerSettingsKeys.map((key) => [key, this.getSettingWithOverride(key)]))
+
+		return {
+			...secrets,
+			...settings,
+		} satisfies ApiConfiguration
+	}
+
+	/**
+	 * Get all global state entries (for debugging/inspection)
+	 */
+	public getAllGlobalStateEntries(): Record<string, unknown> {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		return { ...this.globalStateCache }
+	}
+
+	/**
+	 * Get all workspace state entries (for debugging/inspection)
+	 */
+	public getAllWorkspaceStateEntries(): Record<string, unknown> {
+		if (!this.isInitialized) {
+			throw new Error(STATE_MANAGER_NOT_INITIALIZED)
+		}
+		return { ...this.workspaceStateCache }
+	}
+}
diff --git a/apps/vscode/src/core/storage/__tests__/disk.test.ts b/apps/vscode/src/core/storage/__tests__/disk.test.ts
new file mode 100644
index 0000000..e1a8f4e
--- /dev/null
+++ b/apps/vscode/src/core/storage/__tests__/disk.test.ts
@@ -0,0 +1,283 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, mock } from "bun:test"
+import "should"
+import * as actualFsUtils from "@utils/fs"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import sinon from "sinon"
+import { HostProvider } from "@/hosts/host-provider"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+
+// bun loads real ESM, so sinon cannot stub the `@utils/fs` namespace export
+// ("ES Modules cannot be stubbed"). Inject a module-level sinon stub for
+// `isDirectory` via mock.module so the full sinon stub API keeps working. It
+// defaults to the real implementation; only the error-propagation test overrides
+// it. Register both the alias form and the SUT's relative form.
+const realIsDirectory = actualFsUtils.isDirectory
+const isDirectoryStub: sinon.SinonStub = sinon.stub()
+const fsUtilsMock = () => ({ ...actualFsUtils, isDirectory: isDirectoryStub })
+mock.module("@utils/fs", fsUtilsMock)
+mock.module("@/utils/fs", fsUtilsMock)
+
+import { getAllHooksDirs, getWorkspaceHooksDirs, setRuntimeHooksDir } from "../disk"
+import { StateManager } from "../StateManager"
+
+describe("disk - hooks functionality", () => {
+	let sandbox: sinon.SinonSandbox
+	let tempDir: string
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+		// Default the module-level isDirectory stub to the real implementation;
+		// individual tests override it as needed.
+		isDirectoryStub.reset()
+		isDirectoryStub.callsFake((...args: unknown[]) => (realIsDirectory as (...a: unknown[]) => Promise<boolean>)(...args))
+		tempDir = path.join(os.tmpdir(), `disk-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir, { recursive: true })
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+		setRuntimeHooksDir(undefined)
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch (_error) {
+			// Ignore cleanup errors
+		}
+	})
+
+	describe("getWorkspaceHooksDirs", () => {
+		it("should return empty array when no workspace roots exist", async () => {
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => undefined,
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(0)
+		})
+
+		it("should return empty array when workspace roots is empty array", async () => {
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(0)
+		})
+
+		it("should return empty array when no hooks directories exist", async () => {
+			// Create workspace root without hooks directory
+			const workspaceRoot = path.join(tempDir, "workspace1")
+			await fs.mkdir(workspaceRoot, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(0)
+		})
+
+		it("should return hooks directory when it exists", async () => {
+			// Create workspace root with hooks directory
+			const workspaceRoot = path.join(tempDir, "workspace1")
+			const hooksDir = path.join(workspaceRoot, ".clinerules", "hooks")
+			await fs.mkdir(hooksDir, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(1)
+			result[0].should.equal(hooksDir)
+		})
+
+		it("should not return hooks directory if it's a file instead of directory", async () => {
+			// Create workspace root with hooks as a file (not directory)
+			const workspaceRoot = path.join(tempDir, "workspace1")
+			const hooksPath = path.join(workspaceRoot, ".clinerules", "hooks")
+			await fs.mkdir(path.dirname(hooksPath), { recursive: true })
+			await fs.writeFile(hooksPath, "not a directory")
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(0)
+		})
+
+		it("should return multiple hooks directories for multi-root workspace", async () => {
+			// Create multiple workspace roots with hooks directories
+			const workspaceRoot1 = path.join(tempDir, "workspace1")
+			const workspaceRoot2 = path.join(tempDir, "workspace2")
+			const hooksDir1 = path.join(workspaceRoot1, ".clinerules", "hooks")
+			const hooksDir2 = path.join(workspaceRoot2, ".clinerules", "hooks")
+
+			await fs.mkdir(hooksDir1, { recursive: true })
+			await fs.mkdir(hooksDir2, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot1 }, { path: workspaceRoot2 }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(2)
+			result.should.containEql(hooksDir1)
+			result.should.containEql(hooksDir2)
+		})
+
+		it("should return only existing hooks directories in multi-root workspace", async () => {
+			// Create multiple workspace roots, but only some have hooks directories
+			const workspaceRoot1 = path.join(tempDir, "workspace1")
+			const workspaceRoot2 = path.join(tempDir, "workspace2")
+			const workspaceRoot3 = path.join(tempDir, "workspace3")
+			const hooksDir1 = path.join(workspaceRoot1, ".clinerules", "hooks")
+			const hooksDir3 = path.join(workspaceRoot3, ".clinerules", "hooks")
+
+			await fs.mkdir(hooksDir1, { recursive: true })
+			await fs.mkdir(workspaceRoot2, { recursive: true }) // No hooks dir
+			await fs.mkdir(hooksDir3, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot1 }, { path: workspaceRoot2 }, { path: workspaceRoot3 }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(2)
+			result.should.containEql(hooksDir1)
+			result.should.containEql(hooksDir3)
+			result.should.not.containEql(path.join(workspaceRoot2, ".clinerules", "hooks"))
+		})
+
+		it("should propagate errors when checking directory fails", async () => {
+			const workspaceRoot = path.join(tempDir, "workspace1")
+			await fs.mkdir(workspaceRoot, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot }],
+			} as any)
+
+			// Stub isDirectory to throw an error
+			isDirectoryStub.rejects(new Error("Permission denied"))
+
+			// Should propagate the error
+			try {
+				await getWorkspaceHooksDirs()
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.equal("Permission denied")
+			}
+		})
+
+		it("should use correct path joining for hooks directory", async () => {
+			const workspaceRoot = path.join(tempDir, "workspace1")
+			const expectedHooksDir = path.join(workspaceRoot, ".clinerules", "hooks")
+			await fs.mkdir(expectedHooksDir, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRoot }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result[0].should.equal(expectedHooksDir)
+			// Verify it uses the correct path separator for the platform
+			result[0].should.match(/\.clinerules[\\/]hooks$/)
+		})
+
+		it("should handle workspace roots with trailing slashes", async () => {
+			const workspaceRoot = path.join(tempDir, "workspace1")
+			const workspaceRootWithSlash = workspaceRoot + path.sep
+			const hooksDir = path.join(workspaceRoot, ".clinerules", "hooks")
+			await fs.mkdir(hooksDir, { recursive: true })
+
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [{ path: workspaceRootWithSlash }],
+			} as any)
+
+			const result = await getWorkspaceHooksDirs()
+			result.should.be.an.Array()
+			result.length.should.equal(1)
+			result[0].should.equal(hooksDir)
+		})
+	})
+
+	describe("getAllHooksDirs", () => {
+		it("should include the runtime hooks directory when it exists", async () => {
+			const runtimeHooksDir = path.join(tempDir, "runtime-hooks")
+			await fs.mkdir(runtimeHooksDir, { recursive: true })
+
+			sandbox.stub(os, "homedir").returns(tempDir)
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [],
+			} as any)
+
+			isDirectoryStub.callsFake(async (targetPath: string) => targetPath === runtimeHooksDir)
+
+			setRuntimeHooksDir(runtimeHooksDir)
+
+			const result = await getAllHooksDirs()
+			result.should.containEql(runtimeHooksDir)
+		})
+
+		it("should not include the runtime hooks directory when it does not exist", async () => {
+			const runtimeHooksDir = path.join(tempDir, "missing-runtime-hooks")
+
+			sandbox.stub(os, "homedir").returns(tempDir)
+			sandbox.stub(StateManager, "get").returns({
+				getGlobalStateKey: () => [],
+			} as any)
+
+			isDirectoryStub.resolves(false)
+
+			setRuntimeHooksDir(runtimeHooksDir)
+
+			const result = await getAllHooksDirs()
+			result.should.not.containEql(runtimeHooksDir)
+		})
+	})
+})
+
+describe("disk - atomic writes", () => {
+	let sandbox: sinon.SinonSandbox
+	let testGlobalStorageDir: string
+
+	// Setup HostProvider for tests with real temp directory
+	beforeAll(async () => {
+		// Create a real temp directory for the tests
+		testGlobalStorageDir = path.join(os.tmpdir(), `cline-test-storage-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(testGlobalStorageDir, { recursive: true })
+
+		// Initialize HostProvider with the real temp directory
+		setVscodeHostProviderMock({
+			globalStorageFsPath: testGlobalStorageDir,
+		})
+	})
+
+	afterAll(async () => {
+		HostProvider.reset()
+
+		// Clean up temp directory
+		try {
+			await fs.rm(testGlobalStorageDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+	})
+})
diff --git a/apps/vscode/src/core/storage/__tests__/fetchRemoteConfig.test.ts b/apps/vscode/src/core/storage/__tests__/fetchRemoteConfig.test.ts
new file mode 100644
index 0000000..3e4c686
--- /dev/null
+++ b/apps/vscode/src/core/storage/__tests__/fetchRemoteConfig.test.ts
@@ -0,0 +1,389 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import * as actualDiskStorage from "@core/storage/disk"
+import * as actualRemoteConfigUtils from "@core/storage/remote-config/utils"
+import * as assert from "assert"
+import sinon from "sinon"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { AuthService } from "@/services/auth/AuthService"
+
+// bun loads real ESM, so sinon cannot stub the `@core/storage/disk` and
+// `@core/storage/remote-config/utils` namespace exports ("ES Modules cannot be
+// stubbed"). Inject module-level sinon stubs via mock.module so the full sinon
+// stub API keeps working. `AuthService`/`ClineAccountService` statics and the
+// `accountService` instance method are still sinon-stubbed directly below.
+const isRemoteConfigEnabledStub: sinon.SinonStub = sinon.stub()
+const applyRemoteConfigStub: sinon.SinonStub = sinon.stub()
+const clearRemoteConfigStub: sinon.SinonStub = sinon.stub()
+const writeRemoteConfigToCacheStub: sinon.SinonStub = sinon.stub()
+const readRemoteConfigFromCacheStub: sinon.SinonStub = sinon.stub()
+const deleteRemoteConfigFromCacheStub: sinon.SinonStub = sinon.stub()
+const diskMock = () => ({
+	...actualDiskStorage,
+	writeRemoteConfigToCache: writeRemoteConfigToCacheStub,
+	readRemoteConfigFromCache: readRemoteConfigFromCacheStub,
+	deleteRemoteConfigFromCache: deleteRemoteConfigFromCacheStub,
+})
+const utilsMock = () => ({
+	...actualRemoteConfigUtils,
+	isRemoteConfigEnabled: isRemoteConfigEnabledStub,
+	applyRemoteConfig: applyRemoteConfigStub,
+	clearRemoteConfig: clearRemoteConfigStub,
+})
+// Register both the alias form (this test's imports) and the relative form the
+// SUT (remote-config/fetch.ts) uses, since bun's mock.module matches specifiers.
+mock.module("@core/storage/disk", diskMock)
+mock.module("@/core/storage/disk", diskMock)
+mock.module("../disk", diskMock)
+mock.module("@core/storage/remote-config/utils", utilsMock)
+mock.module("@/core/storage/remote-config/utils", utilsMock)
+mock.module("./utils", utilsMock)
+
+import * as remoteConfigFetch from "@core/storage/remote-config/fetch"
+
+describe("fetchRemoteConfig", () => {
+	let sandbox: sinon.SinonSandbox
+	let accountService: ClineAccountService
+	let authServiceStub: Partial<AuthService>
+	let fetchUserRemoteConfigStub: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		authServiceStub = {}
+		sandbox.stub(AuthService, "getInstance").returns(authServiceStub as AuthService)
+		accountService = new ClineAccountService()
+		sandbox.stub(ClineAccountService, "getInstance").returns(accountService)
+		fetchUserRemoteConfigStub = sandbox.stub(accountService, "fetchUserRemoteConfig")
+
+		// Reset and (re)configure the module-level sinon stubs injected above.
+		isRemoteConfigEnabledStub.reset()
+		applyRemoteConfigStub.reset()
+		clearRemoteConfigStub.reset()
+		writeRemoteConfigToCacheStub.reset()
+		readRemoteConfigFromCacheStub.reset()
+		deleteRemoteConfigFromCacheStub.reset()
+		isRemoteConfigEnabledStub.returns(true)
+		applyRemoteConfigStub.resolves()
+		writeRemoteConfigToCacheStub.resolves()
+		readRemoteConfigFromCacheStub.resolves({ version: "v1" })
+		deleteRemoteConfigFromCacheStub.resolves()
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it("switches org when not in the chosen org", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-current",
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: '{"version":"v1"}',
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub().resolves() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.strictEqual(controller.accountService.switchAccount.callCount, 1)
+		assert.strictEqual(controller.accountService.switchAccount.firstCall.args[0], "org-target")
+		assert.ok(applyRemoteConfigStub.calledOnce)
+	})
+
+	it("skips switchAccount when already in the chosen org", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-target",
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: '{"version":"v1"}',
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.strictEqual(controller.accountService.switchAccount.callCount, 0)
+		assert.ok(applyRemoteConfigStub.calledOnce)
+	})
+
+	it("uses discoveredValue inline and skips org-level config fetch", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-target",
+			getAuthToken: () => Promise.resolve("token"),
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: '{"version":"v1"}',
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.ok(applyRemoteConfigStub.calledOnce)
+		// writeRemoteConfigToCache is called with the parsed config, proving inline parse succeeded.
+		// If it had fallen through to fetchRemoteConfigForOrganization, it would need getAuthToken
+		// and make an HTTP call — but no axios stub is set up, so the test would fail.
+		assert.ok(writeRemoteConfigToCacheStub.calledOnce)
+	})
+
+	it("falls back to org-level fetch when discoveredValue fails to parse", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-target",
+			getAuthToken: () => Promise.resolve(null),
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: "not valid json{{{",
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		// Parse failed → fetchRemoteConfigForOrganization → no auth → cache fallback
+		assert.ok(readRemoteConfigFromCacheStub.called)
+		assert.ok(applyRemoteConfigStub.calledOnce)
+	})
+
+	it("does not switch org when resolve fails", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-current",
+			getAuthToken: () => Promise.resolve(null),
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: "not valid json{{{",
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		// Both inline parse and org-level fetch fail (no auth → no fetch), cache is empty
+		readRemoteConfigFromCacheStub.resolves(undefined)
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		// Config resolution failed — user should stay in their current org
+		assert.strictEqual(controller.accountService.switchAccount.callCount, 0)
+		assert.ok(clearRemoteConfigStub.called)
+		assert.strictEqual(applyRemoteConfigStub.callCount, 0)
+	})
+
+	it("falls back to next locally-allowed org when backend org is opted-out", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-3",
+			getAuthToken: () => Promise.resolve("token"),
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-1",
+			value: '{"version":"v1"}',
+			organizations: [
+				{ organizationId: "org-1", name: "Org 1" },
+				{ organizationId: "org-2", name: "Org 2" },
+				{ organizationId: "org-3", name: "Org 3" },
+			],
+		})
+		isRemoteConfigEnabledStub.reset()
+		isRemoteConfigEnabledStub.withArgs("org-1").returns(false)
+		isRemoteConfigEnabledStub.withArgs("org-2").returns(false)
+		isRemoteConfigEnabledStub.withArgs("org-3").returns(true)
+		// Fallback org has no discoveredValue, so it will go through fetchRemoteConfigForOrganization
+		// which needs auth → will fall back to cache
+		readRemoteConfigFromCacheStub.resolves({ version: "v1" })
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub().resolves() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.ok(applyRemoteConfigStub.calledOnce)
+	})
+
+	it("clears remote config when all orgs are locally opted-out", async () => {
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-1",
+			value: '{"version":"v1"}',
+			organizations: [
+				{ organizationId: "org-1", name: "Org 1" },
+				{ organizationId: "org-2", name: "Org 2" },
+			],
+		})
+		isRemoteConfigEnabledStub.reset()
+		isRemoteConfigEnabledStub.returns(false)
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.ok(clearRemoteConfigStub.called)
+		assert.strictEqual(controller.accountService.switchAccount.callCount, 0)
+		assert.strictEqual(applyRemoteConfigStub.callCount, 0)
+	})
+
+	it("calls clearRemoteConfig when discovery returns no qualifying org", async () => {
+		fetchUserRemoteConfigStub.resolves(undefined)
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.ok(clearRemoteConfigStub.called)
+		assert.strictEqual(controller.accountService.switchAccount.callCount, 0)
+		assert.strictEqual(applyRemoteConfigStub.callCount, 0)
+	})
+
+	it("clears remote config when isRemoteConfigEnabled toggled off mid-flight", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-target",
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: '{"version":"v1"}',
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		isRemoteConfigEnabledStub.reset()
+		isRemoteConfigEnabledStub.onFirstCall().returns(true)
+		isRemoteConfigEnabledStub.onSecondCall().returns(false)
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		assert.ok(writeRemoteConfigToCacheStub.calledOnce)
+		assert.ok(clearRemoteConfigStub.called)
+		assert.strictEqual(applyRemoteConfigStub.callCount, 0)
+	})
+
+	it("preserves existing config on unexpected network error", async () => {
+		fetchUserRemoteConfigStub.rejects(new Error("network failure"))
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub() },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		// Transient errors should NOT clear existing remote config
+		assert.strictEqual(clearRemoteConfigStub.callCount, 0)
+		assert.strictEqual(controller.postStateToWebview.callCount, 0)
+	})
+
+	it("preserves existing config when switchAccount rejects", async () => {
+		Object.assign(authServiceStub, {
+			getActiveOrganizationId: () => "org-current",
+		})
+
+		fetchUserRemoteConfigStub.resolves({
+			organizationId: "org-target",
+			value: '{"version":"v1"}',
+			organizations: [{ organizationId: "org-target", name: "Target Org" }],
+		})
+
+		const controller = {
+			accountService: { switchAccount: sandbox.stub().rejects(new Error("switch failed")) },
+			stateManager: {
+				getApiConfiguration: sandbox.stub().returns({ planModeApiProvider: "cline", actModeApiProvider: "cline" }),
+				setSecret: sandbox.stub(),
+			},
+			mcpHub: {},
+			postStateToWebview: sandbox.stub(),
+		}
+
+		await remoteConfigFetch.fetchRemoteConfig(controller as any)
+
+		// switchAccount failure should NOT clear existing remote config
+		assert.strictEqual(clearRemoteConfigStub.callCount, 0)
+		assert.strictEqual(applyRemoteConfigStub.callCount, 0)
+	})
+})
diff --git a/apps/vscode/src/core/storage/__tests__/remote-config-skills.test.ts b/apps/vscode/src/core/storage/__tests__/remote-config-skills.test.ts
new file mode 100644
index 0000000..a0dc2d3
--- /dev/null
+++ b/apps/vscode/src/core/storage/__tests__/remote-config-skills.test.ts
@@ -0,0 +1,170 @@
+/**
+ * Unit tests for remote skill handling in remote-config/utils.ts
+ * Covers: transformRemoteConfigToStateShape and toggle synchronisation logic.
+ */
+
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+import { synchronizeRemoteRuleToggles } from "@/core/context/instructions/user-instructions/rule-helpers"
+import { parseRemoteSkillEntries } from "@/core/context/instructions/user-instructions/skills"
+import { transformRemoteConfigToStateShape } from "@/core/storage/remote-config/utils"
+import type { RemoteConfig } from "@/shared/remote-config/schema"
+
+function makeConfig(globalSkills: RemoteConfig["globalSkills"]): RemoteConfig {
+	return { version: "v1", globalSkills }
+}
+
+function makeSKILLMd(name: string, description: string, body = "Instructions here."): string {
+	return `---\nname: ${name}\ndescription: ${description}\n---\n${body}`
+}
+
+describe("transformRemoteConfigToStateShape - globalSkills", () => {
+	it("maps globalSkills to remoteGlobalSkills", () => {
+		const entries = [{ name: "My Skill", alwaysEnabled: false, contents: makeSKILLMd("My Skill", "Desc") }]
+		const result = transformRemoteConfigToStateShape(makeConfig(entries))
+		expect(result.remoteGlobalSkills).to.deep.equal(entries)
+	})
+
+	it("does not set remoteGlobalSkills when globalSkills is undefined", () => {
+		const result = transformRemoteConfigToStateShape({ version: "v1" })
+		expect(result.remoteGlobalSkills).to.be.undefined
+	})
+
+	it("sets remoteGlobalSkills to [] when globalSkills is []", () => {
+		const result = transformRemoteConfigToStateShape(makeConfig([]))
+		expect(result.remoteGlobalSkills).to.deep.equal([])
+	})
+
+	it("preserves alwaysEnabled flag", () => {
+		const entries = [
+			{ name: "Locked", alwaysEnabled: true, contents: makeSKILLMd("Locked", "Desc") },
+			{ name: "Free", alwaysEnabled: false, contents: makeSKILLMd("Free", "Desc") },
+		]
+		const result = transformRemoteConfigToStateShape(makeConfig(entries))
+		expect(result.remoteGlobalSkills![0].alwaysEnabled).to.equal(true)
+		expect(result.remoteGlobalSkills![1].alwaysEnabled).to.equal(false)
+	})
+})
+
+describe("synchronizeRemoteRuleToggles - remote skill toggle sync", () => {
+	it("adds new toggle entries defaulting to true", () => {
+		const result = synchronizeRemoteRuleToggles([{ name: "Deploy", alwaysEnabled: false, contents: "" }], {})
+		expect(result["Deploy"]).to.equal(true)
+	})
+
+	it("preserves existing toggle values", () => {
+		const result = synchronizeRemoteRuleToggles([{ name: "Deploy", alwaysEnabled: false, contents: "" }], { Deploy: false })
+		expect(result["Deploy"]).to.equal(false)
+	})
+
+	it("removes stale toggle entries", () => {
+		const result = synchronizeRemoteRuleToggles([{ name: "New", alwaysEnabled: false, contents: "" }], {
+			Old: true,
+			New: false,
+		})
+		expect(result["Old"]).to.be.undefined
+		expect(result["New"]).to.equal(false)
+	})
+
+	it("returns empty object when no skills", () => {
+		const result = synchronizeRemoteRuleToggles([], { Ghost: true })
+		expect(result).to.deep.equal({})
+	})
+
+	it("handles multiple skills", () => {
+		const entries = [
+			{ name: "A", alwaysEnabled: true, contents: "" },
+			{ name: "B", alwaysEnabled: false, contents: "" },
+		]
+		const result = synchronizeRemoteRuleToggles(entries, { A: false, D: true })
+		expect(result["A"]).to.equal(false)
+		expect(result["B"]).to.equal(true)
+		expect(result["D"]).to.be.undefined
+	})
+})
+
+describe("applyRemoteConfig uses parseRemoteSkillEntries", () => {
+	it("validates entry.name matches frontmatter.name", () => {
+		const validated = parseRemoteSkillEntries([
+			{ name: "Deploy", alwaysEnabled: false, contents: makeSKILLMd("Deploy", "Desc") },
+		])
+		expect(validated).to.have.lengthOf(1)
+		expect(validated[0].name).to.equal("Deploy")
+	})
+
+	it("warns but includes entries where entry.name drifts from frontmatter.name", () => {
+		const validated = parseRemoteSkillEntries([
+			{ name: "entry-key", alwaysEnabled: false, contents: makeSKILLMd("Actual Name", "Desc") },
+		])
+		expect(validated).to.have.lengthOf(1)
+		expect(validated[0].name).to.equal("Actual Name")
+	})
+
+	it("filters entries with missing frontmatter name", () => {
+		const validated = parseRemoteSkillEntries([
+			{ name: "x", alwaysEnabled: false, contents: `---\ndescription: No name\n---\nBody` },
+			{ name: "y", alwaysEnabled: false, contents: "No frontmatter" },
+		])
+		expect(validated).to.have.lengthOf(0)
+	})
+
+	it("filters entries where frontmatter.name is not a string", () => {
+		const validated = parseRemoteSkillEntries([
+			{ name: "x", alwaysEnabled: false, contents: `---\nname: 123\ndescription: Desc\n---\nBody` },
+		])
+		expect(validated).to.have.lengthOf(0)
+	})
+
+	it("passes through multiple valid entries", () => {
+		const validated = parseRemoteSkillEntries([
+			{ name: "Skill One", alwaysEnabled: true, contents: makeSKILLMd("Skill One", "Desc") },
+			{ name: "Skill Two", alwaysEnabled: false, contents: makeSKILLMd("Skill Two", "Desc") },
+		])
+		expect(validated).to.have.lengthOf(2)
+		expect(validated[0].name).to.equal("Skill One")
+		expect(validated[1].name).to.equal("Skill Two")
+	})
+})
+
+describe("alwaysEnabled enforcement in toggle sync", () => {
+	function syncWithAlwaysEnabled(
+		entries: { name: string; alwaysEnabled: boolean; contents: string }[],
+		currentToggles: Record<string, boolean>,
+	) {
+		const validated = parseRemoteSkillEntries(entries)
+		const synced = synchronizeRemoteRuleToggles(validated, currentToggles)
+
+		// Enforce alwaysEnabled (mirrors applyRemoteConfig logic)
+		for (const entry of validated) {
+			if (entry.alwaysEnabled && synced[entry.name] === false) {
+				synced[entry.name] = true
+			}
+		}
+
+		return synced
+	}
+
+	it("overrides stale false toggle when admin sets alwaysEnabled", () => {
+		const entries = [{ name: "Deploy", alwaysEnabled: true, contents: makeSKILLMd("Deploy", "Desc") }]
+		const result = syncWithAlwaysEnabled(entries, { Deploy: false })
+		expect(result["Deploy"]).to.equal(true)
+	})
+
+	it("does not override false toggle when alwaysEnabled is false", () => {
+		const entries = [{ name: "Deploy", alwaysEnabled: false, contents: makeSKILLMd("Deploy", "Desc") }]
+		const result = syncWithAlwaysEnabled(entries, { Deploy: false })
+		expect(result["Deploy"]).to.equal(false)
+	})
+
+	it("keeps true toggle unchanged when alwaysEnabled is true", () => {
+		const entries = [{ name: "Deploy", alwaysEnabled: true, contents: makeSKILLMd("Deploy", "Desc") }]
+		const result = syncWithAlwaysEnabled(entries, { Deploy: true })
+		expect(result["Deploy"]).to.equal(true)
+	})
+
+	it("new alwaysEnabled skill defaults to true", () => {
+		const entries = [{ name: "New Skill", alwaysEnabled: true, contents: makeSKILLMd("New Skill", "Desc") }]
+		const result = syncWithAlwaysEnabled(entries, {})
+		expect(result["New Skill"]).to.equal(true)
+	})
+})
diff --git a/apps/vscode/src/core/storage/__tests__/syncRemoteMcpServers.test.ts b/apps/vscode/src/core/storage/__tests__/syncRemoteMcpServers.test.ts
new file mode 100644
index 0000000..b69bc4f
--- /dev/null
+++ b/apps/vscode/src/core/storage/__tests__/syncRemoteMcpServers.test.ts
@@ -0,0 +1,274 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import sinon from "sinon"
+
+import { syncRemoteMcpServersToSettings } from "../remote-config/syncRemoteMcpServers"
+
+describe("syncRemoteMcpServersToSettings", () => {
+	let sandbox: sinon.SinonSandbox
+	let tempDir: string
+	let settingsPath: string
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+		tempDir = path.join(os.tmpdir(), `mcp-sync-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir, { recursive: true })
+		settingsPath = path.join(tempDir, "cline_mcp_settings.json")
+
+		await fs.writeFile(settingsPath, JSON.stringify({ mcpServers: {} }, null, 2))
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	const writeSettings = async (mcpServers: Record<string, any>) => {
+		await fs.writeFile(settingsPath, JSON.stringify({ mcpServers }, null, 2))
+	}
+
+	const readSettings = async () => {
+		const content = await fs.readFile(settingsPath, "utf-8")
+		return JSON.parse(content)
+	}
+
+	describe("adding remote servers", () => {
+		it("should add a new remote server with remoteConfigured marker", async () => {
+			await syncRemoteMcpServersToSettings([{ name: "test-server", url: "https://example.com/mcp" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers["test-server"].should.have.property("url", "https://example.com/mcp")
+			result.mcpServers["test-server"].should.have.property("remoteConfigured", true)
+			result.mcpServers["test-server"].should.have.property("type", "streamableHttp")
+			result.mcpServers["test-server"].should.have.property("disabled", false)
+		})
+
+		it("should preserve user settings and tag existing server with remoteConfigured marker", async () => {
+			await writeSettings({
+				"test-server": {
+					url: "https://example.com/mcp",
+					type: "streamableHttp",
+					disabled: true, // user disabled it
+					autoApprove: ["some-tool"],
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "test-server", url: "https://example.com/mcp" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers["test-server"].disabled.should.equal(true)
+			result.mcpServers["test-server"].autoApprove.should.deepEqual(["some-tool"])
+			result.mcpServers["test-server"].remoteConfigured.should.equal(true)
+		})
+
+		it("should preserve nested transport remote server settings when matching remote config", async () => {
+			await writeSettings({
+				"test-server": {
+					transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+					disabled: true,
+					autoApprove: ["some-tool"],
+					remoteConfigured: true,
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "test-server", url: "https://example.com/mcp" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers["test-server"].transport.should.deepEqual({
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+			})
+			result.mcpServers["test-server"].url.should.equal("https://example.com/mcp")
+			result.mcpServers["test-server"].disabled.should.equal(true)
+			result.mcpServers["test-server"].autoApprove.should.deepEqual(["some-tool"])
+			result.mcpServers["test-server"].remoteConfigured.should.equal(true)
+		})
+
+		it("should add multiple remote servers", async () => {
+			await writeSettings({})
+
+			await syncRemoteMcpServersToSettings(
+				[
+					{ name: "server-a", url: "https://a.example.com" },
+					{ name: "server-b", url: "https://b.example.com" },
+				],
+				settingsPath,
+			)
+
+			const result = await readSettings()
+			Object.keys(result.mcpServers).should.have.length(2)
+			result.mcpServers["server-a"].url.should.equal("https://a.example.com")
+			result.mcpServers["server-b"].url.should.equal("https://b.example.com")
+		})
+
+		it("should not affect existing non-remote servers", async () => {
+			await writeSettings({
+				"local-server": {
+					command: "node",
+					args: ["server.js"],
+					type: "stdio",
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "remote-server", url: "https://example.com" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers.should.have.property("local-server")
+			result.mcpServers["local-server"].command.should.equal("node")
+			result.mcpServers.should.have.property("remote-server")
+		})
+	})
+
+	describe("removing remote servers", () => {
+		it("should remove a server marked remoteConfigured when no longer in remote config", async () => {
+			await writeSettings({
+				"old-server": {
+					url: "https://old.example.com",
+					type: "streamableHttp",
+					remoteConfigured: true,
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers.should.not.have.property("old-server")
+		})
+
+		it("should not remove nested transport remote server when URL still matches remote config", async () => {
+			await writeSettings({
+				"keep-server": {
+					transport: { type: "streamableHttp", url: "https://keep.example.com" },
+					remoteConfigured: true,
+					disabled: true,
+					autoApprove: ["tool-a"],
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "keep-server", url: "https://keep.example.com" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers.should.have.property("keep-server")
+			result.mcpServers["keep-server"].transport.url.should.equal("https://keep.example.com")
+			result.mcpServers["keep-server"].disabled.should.equal(true)
+			result.mcpServers["keep-server"].autoApprove.should.deepEqual(["tool-a"])
+		})
+
+		it("should NOT remove a server without remoteConfigured marker", async () => {
+			await writeSettings({
+				"user-server": {
+					url: "https://user.example.com",
+					type: "streamableHttp",
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers.should.have.property("user-server")
+		})
+
+		it("should only remove the server that was removed from remote config", async () => {
+			await writeSettings({
+				"keep-server": {
+					url: "https://keep.example.com",
+					type: "streamableHttp",
+					remoteConfigured: true,
+				},
+				"remove-server": {
+					url: "https://remove.example.com",
+					type: "streamableHttp",
+					remoteConfigured: true,
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "keep-server", url: "https://keep.example.com" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers.should.have.property("keep-server")
+			result.mcpServers.should.not.have.property("remove-server")
+		})
+
+		it("should handle removing all remote servers at once", async () => {
+			await writeSettings({
+				"server-a": { url: "https://a.com", type: "streamableHttp", remoteConfigured: true },
+				"server-b": { url: "https://b.com", type: "streamableHttp", remoteConfigured: true },
+				"local-server": { command: "node", type: "stdio" },
+			})
+
+			await syncRemoteMcpServersToSettings([], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers.should.not.have.property("server-a")
+			result.mcpServers.should.not.have.property("server-b")
+			result.mcpServers.should.have.property("local-server")
+		})
+	})
+
+	describe("upgrade from old format (no remoteConfigured marker)", () => {
+		it("should add remoteConfigured marker to existing server matching remote config", async () => {
+			await writeSettings({
+				"legacy-server": {
+					url: "https://legacy.example.com",
+					type: "streamableHttp",
+					disabled: false,
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "legacy-server", url: "https://legacy.example.com" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers["legacy-server"].remoteConfigured.should.equal(true)
+		})
+	})
+
+	describe("edge cases", () => {
+		it("should handle empty settings file with no mcpServers key", async () => {
+			await fs.writeFile(settingsPath, JSON.stringify({}, null, 2))
+
+			await syncRemoteMcpServersToSettings([{ name: "new-server", url: "https://new.example.com" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers["new-server"].url.should.equal("https://new.example.com")
+			result.mcpServers["new-server"].remoteConfigured.should.equal(true)
+		})
+
+		it("should handle server with same name but different URL", async () => {
+			await writeSettings({
+				"my-server": {
+					url: "https://old-url.example.com",
+					type: "streamableHttp",
+					remoteConfigured: true,
+				},
+			})
+
+			await syncRemoteMcpServersToSettings([{ name: "my-server", url: "https://new-url.example.com" }], settingsPath)
+
+			const result = await readSettings()
+			result.mcpServers["my-server"].url.should.equal("https://new-url.example.com")
+			result.mcpServers["my-server"].remoteConfigured.should.equal(true)
+		})
+
+		it("should record the post-write McpHub fingerprint when an McpHub is provided", async () => {
+			await writeSettings({})
+
+			const mockMcpHub = {
+				recordSettingsFingerprint: sandbox.stub(),
+			}
+
+			await syncRemoteMcpServersToSettings([{ name: "test", url: "https://test.com" }], settingsPath, mockMcpHub as any)
+
+			mockMcpHub.recordSettingsFingerprint.calledOnce.should.be.true()
+			const result = await readSettings()
+			result.mcpServers["test"].url.should.equal("https://test.com")
+			result.mcpServers["test"].remoteConfigured.should.equal(true)
+		})
+	})
+})
diff --git a/apps/vscode/src/core/storage/disk.ts b/apps/vscode/src/core/storage/disk.ts
new file mode 100644
index 0000000..b7e5b13
--- /dev/null
+++ b/apps/vscode/src/core/storage/disk.ts
@@ -0,0 +1,347 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import { TaskMetadata } from "@core/context/context-tracking/ContextTrackerTypes"
+import { RemoteConfig } from "@shared/remote-config/schema"
+import { GlobalState, Settings } from "@shared/storage/state-keys"
+import { fileExistsAtPath, isDirectory } from "@utils/fs"
+import fs from "fs/promises"
+import os from "os"
+import * as path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import { getDocumentsPath } from "./documents-path"
+import { StateManager } from "./StateManager"
+
+export { getDocumentsPath } from "./documents-path"
+
+export { getSkillsDirectoriesForScan, type SkillsScanDirectory } from "./skill-directories"
+
+export const GlobalFileNames = {
+	apiConversationHistory: "api_conversation_history.json",
+	contextHistory: "context_history.json",
+	uiMessages: "ui_messages.json",
+	clineRecommendedModels: "cline_recommended_models.json",
+	openRouterModels: "openrouter_models.json",
+	vercelAiGatewayModels: "vercel_ai_gateway_models.json",
+	groqModels: "groq_models.json",
+	basetenModels: "baseten_models.json",
+	hicapModels: "hicap_models.json",
+	mcpSettings: "cline_mcp_settings.json",
+	clineRules: ".clinerules",
+	workflows: ".clinerules/workflows",
+	hooksDir: ".clinerules/hooks",
+	clineruleSkillsDir: ".clinerules/skills",
+	clineSkillsDir: ".cline/skills",
+	claudeSkillsDir: ".claude/skills",
+	agentsSkillsDir: ".agents/skills",
+	cursorRulesDir: ".cursor/rules",
+	cursorRulesFile: ".cursorrules",
+	windsurfRules: ".windsurfrules",
+	agentsRulesFile: "AGENTS.md",
+	taskMetadata: "task_metadata.json",
+	remoteConfig: (orgId: string) => `remote_config_${orgId}.json`,
+}
+
+/**
+ * Returns the cross-platform path to the Cline home directory (~/.cline).
+ * This works on macOS, Linux, and Windows:
+ * - macOS: /Users/username/.cline
+ * - Linux: /home/username/.cline
+ * - Windows: C:\Users\username\.cline
+ *
+ * This is intended to eventually replace ~/Documents/Cline as the global config location.
+ */
+function getClineHomePath(): string {
+	return path.join(os.homedir(), ".cline")
+}
+
+export async function ensureTaskDirectoryExists(taskId: string): Promise<string> {
+	return getGlobalStorageDir("tasks", taskId)
+}
+
+export async function ensureRulesDirectoryExists(): Promise<string> {
+	const userDocumentsPath = await getDocumentsPath()
+	const clineRulesDir = path.join(userDocumentsPath, "Cline", "Rules")
+	try {
+		await fs.mkdir(clineRulesDir, { recursive: true })
+	} catch (_error) {
+		return path.join(os.homedir(), "Documents", "Cline", "Rules") // in case creating a directory in documents fails for whatever reason (e.g. permissions) - this is fine because we will fail gracefully with a path that does not exist
+	}
+	return clineRulesDir
+}
+
+export async function ensureWorkflowsDirectoryExists(): Promise<string> {
+	const userDocumentsPath = await getDocumentsPath()
+	const clineWorkflowsDir = path.join(userDocumentsPath, "Cline", "Workflows")
+	try {
+		await fs.mkdir(clineWorkflowsDir, { recursive: true })
+	} catch (_error) {
+		return path.join(os.homedir(), "Documents", "Cline", "Workflows") // in case creating a directory in documents fails for whatever reason (e.g. permissions) - this is fine because we will fail gracefully with a path that does not exist
+	}
+	return clineWorkflowsDir
+}
+
+export async function ensureMcpServersDirectoryExists(): Promise<string> {
+	const userDocumentsPath = await getDocumentsPath()
+	const mcpServersDir = path.join(userDocumentsPath, "Cline", "MCP")
+	try {
+		await fs.mkdir(mcpServersDir, { recursive: true })
+	} catch (_error) {
+		return path.join(os.homedir(), "Documents", "Cline", "MCP") // in case creating a directory in documents fails for whatever reason (e.g. permissions) - this is fine since this path is only ever used in the system prompt
+	}
+	return mcpServersDir
+}
+
+export async function ensureHooksDirectoryExists(): Promise<string> {
+	const userDocumentsPath = await getDocumentsPath()
+	const clineHooksDir = path.join(userDocumentsPath, "Cline", "Hooks")
+	try {
+		await fs.mkdir(clineHooksDir, { recursive: true })
+	} catch (_error) {
+		return path.join(os.homedir(), "Documents", "Cline", "Hooks") // in case creating a directory in documents fails for whatever reason (e.g. permissions) - this is fine because we will fail gracefully with a path that does not exist
+	}
+	return clineHooksDir
+}
+
+/**
+ * Returns the global skills directory path (~/.cline/skills) without creating it.
+ */
+function getClineSkillsDirectoryPath(): string {
+	return path.join(getClineHomePath(), "skills")
+}
+
+function getAgentSkillsDirectoryPath(): string {
+	return path.join(os.homedir(), ".agents", "skills")
+}
+
+/**
+ * Returns the global agent skills directory path (~/.agents/skills).
+ * Creates the directory if it doesn't exist.
+ * This is the opinionated location for new global skills.
+ */
+export async function ensureAgentSkillsDirectoryExists(options: { isGlobal: boolean; workspacePath?: string }): Promise<string> {
+	const agentSkillsDir = options.isGlobal
+		? getAgentSkillsDirectoryPath()
+		: path.join(options.workspacePath ?? "", GlobalFileNames.agentsSkillsDir)
+	try {
+		await fs.mkdir(agentSkillsDir, { recursive: true })
+	} catch (_error) {
+		// Fallback - return the path even if mkdir fails, we'll fail gracefully later
+		return agentSkillsDir
+	}
+	return agentSkillsDir
+}
+
+export async function ensureSettingsDirectoryExists(): Promise<string> {
+	return getGlobalStorageDir("settings")
+}
+
+/**
+ * Gets the path to the MCP settings file, creating it if it doesn't exist
+ * @param settingsDirectoryPath Path to the settings directory
+ * @returns Path to the MCP settings file
+ */
+export async function getMcpSettingsFilePath(settingsDirectoryPath: string): Promise<string> {
+	const mcpSettingsFilePath = path.join(settingsDirectoryPath, GlobalFileNames.mcpSettings)
+	const tempPath = `${mcpSettingsFilePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`
+	try {
+		await fs.writeFile(tempPath, JSON.stringify({ mcpServers: {} }, null, 2), { encoding: "utf8", flag: "wx" })
+		// Hard-linking publishes the fully-written temp file without overwriting an
+		// existing settings file. EEXIST means another process won the create race.
+		await fs.link(tempPath, mcpSettingsFilePath)
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
+			throw error
+		}
+	} finally {
+		await fs.unlink(tempPath).catch(() => {})
+	}
+	return mcpSettingsFilePath
+}
+
+export async function getSavedApiConversationHistory(taskId: string): Promise<Anthropic.MessageParam[]> {
+	const filePath = path.join(await ensureTaskDirectoryExists(taskId), GlobalFileNames.apiConversationHistory)
+	const fileExists = await fileExistsAtPath(filePath)
+	if (fileExists) {
+		return JSON.parse(await fs.readFile(filePath, "utf8"))
+	}
+	return []
+}
+
+export async function getTaskMetadata(taskId: string): Promise<TaskMetadata> {
+	const filePath = path.join(await ensureTaskDirectoryExists(taskId), GlobalFileNames.taskMetadata)
+	try {
+		if (await fileExistsAtPath(filePath)) {
+			return JSON.parse(await fs.readFile(filePath, "utf8"))
+		}
+	} catch (error) {
+		Logger.error("Failed to read task metadata:", error)
+	}
+	return { files_in_context: [], model_usage: [], environment_history: [] }
+}
+
+export async function saveTaskMetadata(taskId: string, metadata: TaskMetadata) {
+	try {
+		const taskDir = await ensureTaskDirectoryExists(taskId)
+		const filePath = path.join(taskDir, GlobalFileNames.taskMetadata)
+		await fs.writeFile(filePath, JSON.stringify(metadata, null, 2))
+	} catch (error) {
+		Logger.error("Failed to save task metadata:", error)
+	}
+}
+
+export async function ensureCacheDirectoryExists(): Promise<string> {
+	return getGlobalStorageDir("cache")
+}
+
+async function getGlobalStorageDir(...subdirs: string[]) {
+	const fullPath = path.resolve(HostProvider.get().globalStorageFsPath, ...subdirs)
+	await fs.mkdir(fullPath, { recursive: true })
+	return fullPath
+}
+
+export async function readTaskSettingsFromStorage(taskId: string): Promise<Partial<GlobalState>> {
+	try {
+		const taskDirectoryFilePath = await ensureTaskDirectoryExists(taskId)
+		const settingsFilePath = path.join(taskDirectoryFilePath, "settings.json")
+
+		if (await fileExistsAtPath(settingsFilePath)) {
+			const settingsContent = await fs.readFile(settingsFilePath, "utf8")
+			return JSON.parse(settingsContent)
+		}
+
+		// Return empty object if settings file doesn't exist (new task)
+		return {}
+	} catch (error) {
+		Logger.error("[Disk] Failed to read task settings:", error)
+		throw error
+	}
+}
+
+export async function writeTaskSettingsToStorage(taskId: string, settings: Partial<Settings>) {
+	try {
+		const taskDirectoryFilePath = await ensureTaskDirectoryExists(taskId)
+		const settingsFilePath = path.join(taskDirectoryFilePath, "settings.json")
+
+		let existingSettings = {}
+		if (await fileExistsAtPath(settingsFilePath)) {
+			const existingSettingsContent = await fs.readFile(settingsFilePath, "utf8")
+			existingSettings = JSON.parse(existingSettingsContent)
+		}
+
+		const updatedSettings = { ...existingSettings, ...settings }
+		await fs.writeFile(settingsFilePath, JSON.stringify(updatedSettings, null, 2))
+	} catch (error) {
+		Logger.error("[Disk] Failed to write task settings:", error)
+		throw error
+	}
+}
+
+export async function readRemoteConfigFromCache(organizationId: string): Promise<RemoteConfig | undefined> {
+	try {
+		const remoteConfigFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.remoteConfig(organizationId))
+		const fileExists = await fileExistsAtPath(remoteConfigFilePath)
+		if (fileExists) {
+			const fileContents = await fs.readFile(remoteConfigFilePath, "utf8")
+			return JSON.parse(fileContents)
+		}
+		return undefined
+	} catch (error) {
+		Logger.error("Failed to read remote config from cache:", error)
+		return undefined
+	}
+}
+
+export async function writeRemoteConfigToCache(organizationId: string, config: RemoteConfig): Promise<void> {
+	try {
+		const remoteConfigFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.remoteConfig(organizationId))
+		await fs.writeFile(remoteConfigFilePath, JSON.stringify(config))
+	} catch (error) {
+		Logger.error("Failed to write remote config to cache:", error)
+	}
+}
+
+export async function deleteRemoteConfigFromCache(organizationId: string): Promise<void> {
+	try {
+		const remoteConfigFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.remoteConfig(organizationId))
+		const fileExists = await fileExistsAtPath(remoteConfigFilePath)
+		if (fileExists) {
+			await fs.unlink(remoteConfigFilePath)
+		}
+	} catch (error) {
+		Logger.error("Failed to delete remote config from cache:", error)
+	}
+}
+
+/**
+ * Gets the path to the global hooks directory if it exists.
+ * Returns undefined if the directory doesn't exist.
+ */
+async function getGlobalHooksDir(): Promise<string | undefined> {
+	const globalHooksDir = await ensureHooksDirectoryExists()
+	return (await isDirectory(globalHooksDir)) ? globalHooksDir : undefined
+}
+
+let runtimeHooksDir: string | undefined
+
+/**
+ * Sets a runtime hooks directory, typically passed via the --hooks-dir CLI flag.
+ * This directory is included alongside global and workspace hooks directories
+ * when discovering hooks.
+ */
+export function setRuntimeHooksDir(dir: string | undefined): void {
+	runtimeHooksDir = dir
+}
+
+/**
+ * Gets the paths to all hooks directories to search for hooks, including:
+ * 1. The runtime hooks directory (if set via --hooks-dir CLI flag)
+ * 2. The global hooks directory (if it exists)
+ * 3. Each workspace root's .clinerules/hooks directory (if they exist)
+ *
+ * Note: Hooks from different directories may be executed concurrently.
+ * No execution order is guaranteed between hooks from different directories.
+ * A workspace may not use hooks, and the resulting array will be empty. A
+ * multi-root workspace may have multiple hooks directories.
+ */
+export async function getAllHooksDirs(): Promise<string[]> {
+	const hooksDirs: string[] = []
+
+	// Add runtime hooks directory (set by --hooks-dir CLI flag)
+	if (runtimeHooksDir && (await isDirectory(runtimeHooksDir))) {
+		hooksDirs.push(runtimeHooksDir)
+	}
+
+	// Add global hooks directory (if it exists)
+	const globalHooksDir = await getGlobalHooksDir()
+	if (globalHooksDir) {
+		hooksDirs.push(globalHooksDir)
+	}
+
+	// Add workspace hooks directories
+	const workspaceHooksDirs = await getWorkspaceHooksDirs()
+	hooksDirs.push(...workspaceHooksDirs)
+
+	return hooksDirs
+}
+
+/**
+ * Gets the paths to the workspace's .clinerules/hooks directories to search for
+ * hooks. A workspace may not use hooks, and the resulting array will be empty. A
+ * multi-root workspace may have multiple hooks directories.
+ */
+export async function getWorkspaceHooksDirs(): Promise<string[]> {
+	const workspaceRootPaths =
+		StateManager.get()
+			.getGlobalStateKey("workspaceRoots")
+			?.map((root) => root.path) || []
+
+	return (
+		await Promise.all(
+			workspaceRootPaths.map(async (workspaceRootPath) => {
+				// Look for a .clinerules/hooks folder in this workspace root.
+				const candidate = path.join(workspaceRootPath, GlobalFileNames.hooksDir)
+				return (await isDirectory(candidate)) ? candidate : undefined
+			}),
+		)
+	).filter((path): path is string => Boolean(path))
+}
diff --git a/apps/vscode/src/core/storage/documents-path.ts b/apps/vscode/src/core/storage/documents-path.ts
new file mode 100644
index 0000000..c0e46c8
--- /dev/null
+++ b/apps/vscode/src/core/storage/documents-path.ts
@@ -0,0 +1,40 @@
+import { execa } from "@packages/execa"
+import os from "os"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+
+export async function getDocumentsPath(): Promise<string> {
+	if (process.platform === "win32") {
+		try {
+			const { stdout: docsPath } = await execa("powershell", [
+				"-NoProfile", // Ignore user's PowerShell profile(s)
+				"-Command",
+				"[System.Environment]::GetFolderPath([System.Environment+SpecialFolder]::MyDocuments)",
+			])
+			const trimmedPath = docsPath.trim()
+			if (trimmedPath) {
+				return trimmedPath
+			}
+		} catch (_err) {
+			Logger.error("Failed to retrieve Windows Documents path. Falling back to homedir/Documents.")
+		}
+	} else if (process.platform === "linux") {
+		try {
+			// First check if xdg-user-dir exists
+			await execa("which", ["xdg-user-dir"])
+
+			// If it exists, try to get XDG documents path
+			const { stdout } = await execa("xdg-user-dir", ["DOCUMENTS"])
+			const trimmedPath = stdout.trim()
+			if (trimmedPath) {
+				return trimmedPath
+			}
+		} catch {
+			// Log error but continue to fallback
+			Logger.error("Failed to retrieve XDG Documents path. Falling back to homedir/Documents.")
+		}
+	}
+
+	// Default fallback for all platforms
+	return path.join(os.homedir(), "Documents")
+}
\ No newline at end of file
diff --git a/apps/vscode/src/core/storage/error-messages.ts b/apps/vscode/src/core/storage/error-messages.ts
new file mode 100644
index 0000000..515b3aa
--- /dev/null
+++ b/apps/vscode/src/core/storage/error-messages.ts
@@ -0,0 +1 @@
+export const STATE_MANAGER_NOT_INITIALIZED = "StateManager must be initialized before attempting to access state."
diff --git a/apps/vscode/src/core/storage/remote-config/fetch.ts b/apps/vscode/src/core/storage/remote-config/fetch.ts
new file mode 100644
index 0000000..25f8dff
--- /dev/null
+++ b/apps/vscode/src/core/storage/remote-config/fetch.ts
@@ -0,0 +1,300 @@
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios"
+import { Controller } from "@/core/controller"
+import { CLINE_PASS_PROVIDER_ID } from "@/core/controller/models/handleClinePassProviderSelection"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { buildBasicClineHeaders } from "@/services/EnvUtils"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { ConfiguredAPIKeys } from "@/shared/storage/state-keys"
+import { ClineEnv } from "../../../config"
+import { AuthService } from "../../../services/auth/AuthService"
+import { CLINE_API_ENDPOINT } from "../../../shared/cline/api"
+import { APIKeySchema, type APIKeySettings, RemoteConfig, RemoteConfigSchema } from "../../../shared/remote-config/schema"
+import { deleteRemoteConfigFromCache, readRemoteConfigFromCache, writeRemoteConfigToCache } from "../disk"
+import { applyRemoteConfig, clearRemoteConfig, isRemoteConfigEnabled } from "./utils"
+
+/**
+ * Parses API keys from a JSON string response
+ * @param value The JSON string containing API keys
+ * @returns Parsed API key settings object
+ */
+function parseApiKeys(value: string): APIKeySettings {
+	try {
+		if (!value) {
+			return {}
+		}
+		return APIKeySchema.parse(JSON.parse(value))
+	} catch (err) {
+		Logger.error(`Failed to parse providers api keys`, err)
+		return {}
+	}
+}
+
+/**
+ * Helper function to make authenticated requests to the Cline API
+ * @param endpoint The API endpoint path (with {id} placeholder if needed)
+ * @param organizationId The organization ID to replace in the endpoint
+ * @returns The response data on success
+ * @throws Error if the request fails or returns an error
+ */
+async function makeAuthenticatedRequest<T>(endpoint: string, organizationId: string): Promise<T> {
+	const authService = AuthService.getInstance()
+
+	// Get authentication token
+	const authToken = await authService.getAuthToken()
+	if (!authToken) {
+		throw new Error("No Cline account auth token found")
+	}
+
+	// Construct URL by replacing {id} placeholder with organizationId
+	const apiEndpoint = endpoint.replace("{id}", organizationId)
+	const url = new URL(apiEndpoint, ClineEnv.config().apiBaseUrl).toString()
+
+	// Make authenticated request
+	const requestConfig: AxiosRequestConfig = {
+		headers: {
+			Authorization: `Bearer ${authToken}`,
+			"Content-Type": "application/json",
+			...(await buildBasicClineHeaders()),
+		},
+		...getAxiosSettings(),
+	}
+
+	const response: AxiosResponse<{
+		data?: T
+		error: string
+		success: boolean
+	}> = await axios.request({
+		url,
+		method: "GET",
+		...requestConfig,
+	})
+
+	// Validate response status
+	const status = response.status
+	if (status < 200 || status >= 300) {
+		throw new Error(`Request to ${apiEndpoint} failed with status ${status}`)
+	}
+
+	// Validate response structure
+	if (!response.data || !response.data.success) {
+		throw new Error(`API error: ${response.data?.error || "Unknown error"}`)
+	}
+
+	// Extract and return data
+	const data = response.data.data
+	if (!data) {
+		throw new Error(`No data returned from ${apiEndpoint}`)
+	}
+
+	return data
+}
+
+/**
+ * Fetches remote configuration for a specific organization from the API.
+ * Falls back to cached config if the request fails.
+ *
+ * @param organizationId The organization ID to fetch config for
+ * @returns RemoteConfig if enabled, undefined if disabled or not found
+ */
+async function fetchRemoteConfigForOrganization(organizationId: string): Promise<RemoteConfig | undefined> {
+	try {
+		// Fetch config data using helper
+		const configData = await makeAuthenticatedRequest<{ value: string; enabled: boolean }>(
+			CLINE_API_ENDPOINT.REMOTE_CONFIG,
+			organizationId,
+		)
+
+		// Check if config is enabled
+		if (!configData.enabled) {
+			// Clear the remote config from the on-disk cache if it exists
+			await deleteRemoteConfigFromCache(organizationId)
+			return undefined
+		}
+
+		// Parse the JSON-encoded Value field
+		const parsedConfig = JSON.parse(configData.value)
+
+		// Validate against schema
+		const validatedConfig = RemoteConfigSchema.parse(parsedConfig)
+
+		return validatedConfig
+	} catch (error) {
+		Logger.error(`Failed to fetch remote config for organization ${organizationId}:`, error)
+
+		// Try to fall back to cached config
+		const cachedConfig = await readRemoteConfigFromCache(organizationId)
+		if (cachedConfig) {
+			try {
+				// Validate cached config against schema
+				const validatedCachedConfig = RemoteConfigSchema.parse(cachedConfig)
+				return validatedCachedConfig
+			} catch (validationError) {
+				// Cache validation failed - log and continue
+				Logger.error(`Cached config validation failed for organization ${organizationId}:`, validationError)
+			}
+		}
+
+		return undefined
+	}
+}
+
+/**
+ * Fetches API keys for a specific organization from the API.
+ *
+ * @param organizationId The organization ID to fetch API keys for
+ * @returns Record of API keys (e.g., { litellm: "key" }) or undefined if fetch fails
+ */
+async function fetchApiKeysForOrganization(organizationId: string): Promise<APIKeySettings> {
+	try {
+		// Fetch API keys string using helper
+		const response = await makeAuthenticatedRequest<{ providerApiKeys: string }>(CLINE_API_ENDPOINT.API_KEYS, organizationId)
+
+		// Parse and return API keys
+		return parseApiKeys(response?.providerApiKeys)
+	} catch (error) {
+		Logger.error(`Failed to fetch API keys for organization ${organizationId}:`, error)
+		return {}
+	}
+}
+
+async function discoverRemoteConfigOrg(): Promise<{ organizationId: string; discoveredValue?: string } | undefined> {
+	const accountService = ClineAccountService.getInstance()
+
+	const discovery = await accountService.fetchUserRemoteConfig()
+	if (!discovery) {
+		return undefined
+	}
+
+	if (isRemoteConfigEnabled(discovery.organizationId)) {
+		return { organizationId: discovery.organizationId, discoveredValue: discovery.value }
+	}
+
+	if (discovery.organizations) {
+		for (const org of discovery.organizations) {
+			if (org.organizationId === discovery.organizationId) {
+				continue
+			}
+			if (isRemoteConfigEnabled(org.organizationId)) {
+				return { organizationId: org.organizationId }
+			}
+		}
+	}
+
+	return undefined
+}
+
+function parseDiscoveredConfig(value: string, organizationId: string): RemoteConfig | undefined {
+	try {
+		return RemoteConfigSchema.parse(JSON.parse(value))
+	} catch (error) {
+		Logger.warn(`Failed to parse discovered config for org ${organizationId}, will re-fetch`, error)
+		return undefined
+	}
+}
+
+async function resolveRemoteConfig(organizationId: string, discoveredValue?: string): Promise<RemoteConfig | undefined> {
+	if (discoveredValue) {
+		const config = parseDiscoveredConfig(discoveredValue, organizationId)
+		if (config) {
+			return config
+		}
+	}
+	return fetchRemoteConfigForOrganization(organizationId)
+}
+
+function isClinePassSelected(controller: Controller): boolean {
+	const apiConfiguration = controller.stateManager.getApiConfiguration()
+
+	return (
+		apiConfiguration.planModeApiProvider === CLINE_PASS_PROVIDER_ID ||
+		apiConfiguration.actModeApiProvider === CLINE_PASS_PROVIDER_ID
+	)
+}
+
+/**
+ * Discovers the target org, resolves its remote config, switches org if needed,
+ * fetches API keys, and applies the config. Clears remote config when no
+ * qualifying org is found or config resolution returns nothing.
+ *
+ * @param controller The controller instance
+ * @returns RemoteConfig if found and applied, undefined otherwise
+ */
+async function ensureUserInOrgWithRemoteConfig(controller: Controller): Promise<RemoteConfig | undefined> {
+	const authService = AuthService.getInstance()
+
+	if (isClinePassSelected(controller)) {
+		clearRemoteConfig()
+		controller.postStateToWebview()
+		return undefined
+	}
+
+	const discovered = await discoverRemoteConfigOrg()
+
+	if (!discovered) {
+		clearRemoteConfig()
+		controller.postStateToWebview()
+		return undefined
+	}
+
+	const { organizationId, discoveredValue } = discovered
+
+	const remoteConfig = await resolveRemoteConfig(organizationId, discoveredValue)
+
+	if (!remoteConfig) {
+		clearRemoteConfig()
+		controller.postStateToWebview()
+		return undefined
+	}
+
+	// Switch org only after we know we have a valid config to apply.
+	if (authService.getActiveOrganizationId() !== organizationId) {
+		await controller.accountService.switchAccount(organizationId)
+	}
+
+	const configuredApiKeys: ConfiguredAPIKeys = {}
+	const hasConfiguredProviders = remoteConfig.providerSettings && Object.keys(remoteConfig.providerSettings).length > 0
+	if (hasConfiguredProviders) {
+		const apiKeys = await fetchApiKeysForOrganization(organizationId)
+		if (remoteConfig.providerSettings?.LiteLLM) {
+			if (apiKeys.litellm) {
+				configuredApiKeys["litellm"] = true
+				controller.stateManager.setSecret("remoteLiteLlmApiKey", apiKeys.litellm)
+			} else {
+				controller.stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+			}
+		} else {
+			controller.stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+		}
+	} else {
+		controller.stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+	}
+
+	await writeRemoteConfigToCache(organizationId, remoteConfig)
+	if (isRemoteConfigEnabled(organizationId)) {
+		await applyRemoteConfig(remoteConfig, configuredApiKeys, controller.mcpHub)
+	} else {
+		clearRemoteConfig()
+	}
+	controller.postStateToWebview()
+
+	return remoteConfig
+}
+
+/**
+ * Main entry point for fetching remote configuration.
+ * Called periodically to ensure users stay in organizations with remote
+ * configuration enabled.
+ *
+ * Catches all exceptions and logs them without clearing existing config,
+ * so transient failures do not drop remote-config-enforced settings.
+ *
+ * @param controller The controller instance
+ */
+export async function fetchRemoteConfig(controller: Controller) {
+	try {
+		await ensureUserInOrgWithRemoteConfig(controller)
+	} catch (error) {
+		Logger.error("Failed to fetch remote config", error)
+	}
+}
diff --git a/apps/vscode/src/core/storage/remote-config/sdk-control-plane.test.ts b/apps/vscode/src/core/storage/remote-config/sdk-control-plane.test.ts
new file mode 100644
index 0000000..6c83614
--- /dev/null
+++ b/apps/vscode/src/core/storage/remote-config/sdk-control-plane.test.ts
@@ -0,0 +1,5 @@
+// Intentionally empty.
+// The Vitest coverage for SdkRemoteConfigControlPlane lives in
+// src/sdk/sdk-remote-config-control-plane.test.ts so VS Code's Mocha integration
+// runner does not try to require Vitest in a CommonJS test host.
+export {}
diff --git a/apps/vscode/src/core/storage/remote-config/sdk-control-plane.ts b/apps/vscode/src/core/storage/remote-config/sdk-control-plane.ts
new file mode 100644
index 0000000..4408c67
--- /dev/null
+++ b/apps/vscode/src/core/storage/remote-config/sdk-control-plane.ts
@@ -0,0 +1,254 @@
+import type { RemoteConfigBundle } from "@cline/shared"
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios"
+import { ClineEnv } from "@/config"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { AuthService } from "@/services/auth/AuthService"
+import { buildBasicClineHeaders } from "@/services/EnvUtils"
+import { CLINE_API_ENDPOINT } from "@/shared/cline/api"
+import { getAxiosSettings } from "@/shared/net"
+import { APIKeySchema, type APIKeySettings, type RemoteConfig, RemoteConfigSchema } from "@/shared/remote-config/schema"
+import { Logger } from "@/shared/services/Logger"
+import type { ConfiguredAPIKeys } from "@/shared/storage/state-keys"
+import { deleteRemoteConfigFromCache, readRemoteConfigFromCache, writeRemoteConfigToCache } from "../disk"
+import { isRemoteConfigEnabled } from "./utils"
+
+export interface SdkRemoteConfigControlPlaneController {
+	accountService: { switchAccount(organizationId: string): Promise<unknown> }
+	stateManager: { setSecret(key: "remoteLiteLlmApiKey", value: string | undefined): unknown }
+}
+
+interface RemoteConfigControlPlaneFetchInput {
+	workspacePath: string
+	rootPath?: string
+	context?: unknown
+	logger?: unknown
+	signal?: AbortSignal
+	now?: number
+}
+
+interface RemoteConfigManagedInstructionFile {
+	id: string
+	name: string
+	kind: "skill"
+	contents: string
+	alwaysEnabled?: boolean
+}
+
+export interface SdkRemoteConfigBundle extends RemoteConfigBundle {
+	remoteConfig?: RemoteConfigBundle["remoteConfig"] & RemoteConfig
+}
+
+function parseApiKeys(value: string): APIKeySettings {
+	try {
+		if (!value) {
+			return {}
+		}
+		return APIKeySchema.parse(JSON.parse(value))
+	} catch (err) {
+		Logger.error("Failed to parse providers api keys", err)
+		return {}
+	}
+}
+
+async function makeAuthenticatedRequest<T>(endpoint: string, organizationId: string): Promise<T> {
+	const authService = AuthService.getInstance()
+	const authToken = await authService.getAuthToken()
+	if (!authToken) {
+		throw new Error("No Cline account auth token found")
+	}
+
+	const apiEndpoint = endpoint.replace("{id}", organizationId)
+	const url = new URL(apiEndpoint, ClineEnv.config().apiBaseUrl).toString()
+	const requestConfig: AxiosRequestConfig = {
+		headers: {
+			Authorization: `Bearer ${authToken}`,
+			"Content-Type": "application/json",
+			...(await buildBasicClineHeaders()),
+		},
+		...getAxiosSettings(),
+	}
+
+	const response: AxiosResponse<{ data?: T; error: string; success: boolean }> = await axios.request({
+		url,
+		method: "GET",
+		...requestConfig,
+	})
+
+	if (response.status < 200 || response.status >= 300) {
+		throw new Error(`Request to ${apiEndpoint} failed with status ${response.status}`)
+	}
+	if (!response.data || !response.data.success) {
+		throw new Error(`API error: ${response.data?.error || "Unknown error"}`)
+	}
+	if (!response.data.data) {
+		throw new Error(`No data returned from ${apiEndpoint}`)
+	}
+	return response.data.data
+}
+
+async function fetchRemoteConfigForOrganization(organizationId: string): Promise<RemoteConfig | undefined> {
+	try {
+		const configData = await makeAuthenticatedRequest<{ value: string; enabled: boolean }>(
+			CLINE_API_ENDPOINT.REMOTE_CONFIG,
+			organizationId,
+		)
+		if (!configData.enabled) {
+			await deleteRemoteConfigFromCache(organizationId)
+			return undefined
+		}
+		return RemoteConfigSchema.parse(JSON.parse(configData.value))
+	} catch (error) {
+		Logger.error(`Failed to fetch remote config for organization ${organizationId}:`, error)
+		const cachedConfig = await readRemoteConfigFromCache(organizationId)
+		if (cachedConfig) {
+			try {
+				return RemoteConfigSchema.parse(cachedConfig)
+			} catch (validationError) {
+				Logger.error(`Cached config validation failed for organization ${organizationId}:`, validationError)
+			}
+		}
+		return undefined
+	}
+}
+
+async function fetchApiKeysForOrganization(organizationId: string): Promise<APIKeySettings> {
+	try {
+		const response = await makeAuthenticatedRequest<{ providerApiKeys: string }>(CLINE_API_ENDPOINT.API_KEYS, organizationId)
+		return parseApiKeys(response?.providerApiKeys)
+	} catch (error) {
+		Logger.error(`Failed to fetch API keys for organization ${organizationId}:`, error)
+		return {}
+	}
+}
+
+function parseDiscoveredConfig(value: string, organizationId: string): RemoteConfig | undefined {
+	try {
+		return RemoteConfigSchema.parse(JSON.parse(value))
+	} catch (error) {
+		Logger.warn(`Failed to parse discovered config for org ${organizationId}, will re-fetch`, error)
+		return undefined
+	}
+}
+
+function skillsToManagedInstructions(remoteConfig: RemoteConfig): RemoteConfigManagedInstructionFile[] {
+	return (remoteConfig.globalSkills ?? []).map((skill, index) => ({
+		id: `remote-config:skill:${index}:${skill.name}`,
+		name: skill.name,
+		kind: "skill",
+		contents: skill.contents,
+		alwaysEnabled: skill.alwaysEnabled,
+	}))
+}
+
+export class SdkRemoteConfigControlPlane {
+	readonly name = "cline-extension-remote-config"
+	private lastConfiguredKeys: ConfiguredAPIKeys = {}
+	private lastRemoteConfig: RemoteConfig | undefined
+	private explicitNoConfig = false
+
+	constructor(private readonly controller: SdkRemoteConfigControlPlaneController) {}
+
+	getLastConfiguredKeys(): ConfiguredAPIKeys {
+		return this.lastConfiguredKeys
+	}
+
+	getLastRemoteConfig(): RemoteConfig | undefined {
+		return this.lastRemoteConfig
+	}
+
+	wasExplicitNoConfig(): boolean {
+		return this.explicitNoConfig
+	}
+
+	async fetchBundle(_input: RemoteConfigControlPlaneFetchInput): Promise<SdkRemoteConfigBundle | undefined> {
+		this.explicitNoConfig = false
+		this.lastConfiguredKeys = {}
+		this.lastRemoteConfig = undefined
+
+		const discovered = await this.discoverRemoteConfigOrg()
+		if (!discovered) {
+			this.explicitNoConfig = true
+			return undefined
+		}
+
+		const { organizationId, discoveredValue } = discovered
+		const remoteConfig = await this.resolveRemoteConfig(organizationId, discoveredValue)
+		if (!remoteConfig) {
+			this.explicitNoConfig = true
+			return undefined
+		}
+
+		const authService = AuthService.getInstance()
+		if (authService.getActiveOrganizationId() !== organizationId) {
+			await this.controller.accountService.switchAccount(organizationId)
+		}
+
+		this.lastConfiguredKeys = await this.configureRemoteApiKeys(organizationId, remoteConfig)
+		await writeRemoteConfigToCache(organizationId, remoteConfig)
+		this.lastRemoteConfig = remoteConfig
+
+		return {
+			source: this.name,
+			version: remoteConfig.version,
+			remoteConfig: remoteConfig as SdkRemoteConfigBundle["remoteConfig"],
+			managedInstructions: skillsToManagedInstructions(remoteConfig),
+			metadata: { organizationId },
+		}
+	}
+
+	private async discoverRemoteConfigOrg(): Promise<{ organizationId: string; discoveredValue?: string } | undefined> {
+		const accountService = ClineAccountService.getInstance()
+		const discovery = await accountService.fetchUserRemoteConfig()
+		if (!discovery) {
+			return undefined
+		}
+
+		if (isRemoteConfigEnabled(discovery.organizationId)) {
+			return { organizationId: discovery.organizationId, discoveredValue: discovery.value }
+		}
+
+		if (discovery.organizations) {
+			for (const org of discovery.organizations) {
+				if (org.organizationId === discovery.organizationId) {
+					continue
+				}
+				if (isRemoteConfigEnabled(org.organizationId)) {
+					return { organizationId: org.organizationId }
+				}
+			}
+		}
+
+		return undefined
+	}
+
+	private async resolveRemoteConfig(organizationId: string, discoveredValue?: string): Promise<RemoteConfig | undefined> {
+		if (discoveredValue) {
+			const config = parseDiscoveredConfig(discoveredValue, organizationId)
+			if (config) {
+				return config
+			}
+		}
+		return fetchRemoteConfigForOrganization(organizationId)
+	}
+
+	private async configureRemoteApiKeys(organizationId: string, remoteConfig: RemoteConfig): Promise<ConfiguredAPIKeys> {
+		const configuredApiKeys: ConfiguredAPIKeys = {}
+		const hasConfiguredProviders = remoteConfig.providerSettings && Object.keys(remoteConfig.providerSettings).length > 0
+		if (hasConfiguredProviders) {
+			const apiKeys = await fetchApiKeysForOrganization(organizationId)
+			if (remoteConfig.providerSettings?.LiteLLM) {
+				if (apiKeys.litellm) {
+					configuredApiKeys.litellm = true
+					this.controller.stateManager.setSecret("remoteLiteLlmApiKey", apiKeys.litellm)
+				} else {
+					this.controller.stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+				}
+			} else {
+				this.controller.stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+			}
+		} else {
+			this.controller.stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+		}
+		return configuredApiKeys
+	}
+}
diff --git a/apps/vscode/src/core/storage/remote-config/sdk-refresh.ts b/apps/vscode/src/core/storage/remote-config/sdk-refresh.ts
new file mode 100644
index 0000000..1eadb48
--- /dev/null
+++ b/apps/vscode/src/core/storage/remote-config/sdk-refresh.ts
@@ -0,0 +1,70 @@
+import * as fs from "node:fs/promises"
+import * as os from "node:os"
+import * as path from "node:path"
+import { prepareRemoteConfigCoreIntegration } from "@cline/core"
+import { Controller } from "@/sdk/SdkController"
+import { Logger } from "@/shared/services/Logger"
+import type { ConfiguredAPIKeys } from "@/shared/storage/state-keys"
+import { SdkRemoteConfigControlPlane } from "./sdk-control-plane"
+import { applyRemoteConfig, clearRemoteConfig } from "./utils"
+
+export interface RefreshSdkRemoteConfigOptions {
+	workspacePath?: string
+	rootPath?: string
+}
+
+async function ensureGlobalRemoteConfigWorkspacePath(): Promise<string> {
+	const clineDir = process.env.CLINE_DIR || path.join(os.homedir(), ".cline")
+	const workspacePath = path.join(clineDir, "data", "remote-config-workspace")
+	await fs.mkdir(workspacePath, { recursive: true })
+	return workspacePath
+}
+
+async function getRemoteConfigWorkspacePath(workspacePath?: string): Promise<string> {
+	const trimmed = workspacePath?.trim()
+	if (trimmed) {
+		return trimmed
+	}
+	return ensureGlobalRemoteConfigWorkspacePath()
+}
+
+export async function refreshSdkRemoteConfig(controller: Controller, options: RefreshSdkRemoteConfigOptions = {}): Promise<void> {
+	const controlPlane = new SdkRemoteConfigControlPlane(controller)
+	const workspacePath = await getRemoteConfigWorkspacePath(options.workspacePath)
+
+	try {
+		const integration = await prepareRemoteConfigCoreIntegration({
+			workspacePath,
+			rootPath: options.rootPath,
+			controlPlane,
+			useCachedBundle: false,
+		})
+
+		const remoteConfig = controlPlane.getLastRemoteConfig()
+		if (!remoteConfig) {
+			clearRemoteConfig()
+			await controller.setRemoteConfigCoreIntegration(undefined)
+			await controller.postStateToWebview()
+			return
+		}
+
+		await controller.setRemoteConfigCoreIntegration(integration)
+
+		try {
+			const configuredKeys: ConfiguredAPIKeys = controlPlane.getLastConfiguredKeys()
+			await applyRemoteConfig(remoteConfig, configuredKeys, controller.mcpHub)
+		} catch (bridgeError) {
+			Logger.error("[RemoteConfig] SDK refresh succeeded but classic bridge application failed:", bridgeError)
+		}
+
+		await controller.postStateToWebview()
+	} catch (error) {
+		if (controlPlane.wasExplicitNoConfig()) {
+			clearRemoteConfig()
+			await controller.setRemoteConfigCoreIntegration(undefined)
+			await controller.postStateToWebview()
+			return
+		}
+		Logger.error("[RemoteConfig] Failed to refresh SDK remote config; keeping previous config:", error)
+	}
+}
diff --git a/apps/vscode/src/core/storage/remote-config/syncRemoteMcpServers.ts b/apps/vscode/src/core/storage/remote-config/syncRemoteMcpServers.ts
new file mode 100644
index 0000000..187dab4
--- /dev/null
+++ b/apps/vscode/src/core/storage/remote-config/syncRemoteMcpServers.ts
@@ -0,0 +1,103 @@
+import { RemoteMCPServer } from "@shared/remote-config/schema"
+import { updateMcpSettingsFile } from "@/services/mcp/settingsLock"
+import { Logger } from "@/shared/services/Logger"
+
+type McpSettingsFingerprintRecorder = {
+	recordSettingsFingerprint(servers: Record<string, unknown>): void
+}
+
+function getConfiguredServerUrl(server: Record<string, unknown>): string | undefined {
+	if (typeof server.url === "string") {
+		return server.url
+	}
+	const transport = server.transport
+	if (transport && typeof transport === "object" && !Array.isArray(transport)) {
+		const url = (transport as Record<string, unknown>).url
+		return typeof url === "string" ? url : undefined
+	}
+	return undefined
+}
+
+/**
+ * Synchronizes remote MCP servers from remote config to the local MCP settings file
+ * This allows admins to centrally configure MCP servers that are automatically deployed to users
+ *
+ * Uses the `remoteConfigured: true` marker in the settings file to track which servers
+ * were added by remote config. This survives extension restarts (unlike in-memory state)
+ * and ensures proper cleanup when servers are removed from remote config.
+ *
+ * Handles:
+ * - Removing servers marked as `remoteConfigured` that are no longer in the remote config
+ * - Adding new servers from remote config with the `remoteConfigured` marker
+ * - Preventing duplicates when re-adding servers
+ *
+ * @param remoteMCPServers Array of remote MCP servers from remote config
+ * @param settingsPath Path to the MCP settings file
+ * @param mcpHub Optional McpHub instance to set flag preventing watcher triggers
+ */
+export async function syncRemoteMcpServersToSettings(
+	remoteMCPServers: RemoteMCPServer[],
+	settingsPath: string,
+	mcpHub?: McpSettingsFingerprintRecorder,
+): Promise<void> {
+	try {
+		// Hold the cross-process lock across the whole read-modify-write so a
+		// concurrent writer (CLI, another window, an OAuth handshake) cannot drop
+		// this sync's changes from a stale snapshot. Only writers need the lock;
+		// reads rely on atomic rename to always see a complete file.
+		const config = await updateMcpSettingsFile(settingsPath, (current) => {
+			const config = current as Record<string, any>
+			const servers = config.mcpServers as Record<string, any>
+
+			// Remove servers marked as remoteConfigured that are no longer in the new remote config list.
+			// This uses the persistent `remoteConfigured` marker in the settings file instead of
+			// in-memory state, so it works correctly across extension restarts.
+			for (const [serverName, serverConfig] of Object.entries(servers)) {
+				const server = serverConfig as Record<string, unknown>
+				if (server.remoteConfigured === true) {
+					const configuredUrl = getConfiguredServerUrl(server)
+					const stillInRemoteConfig = remoteMCPServers.some(
+						(remoteServer) => remoteServer.name === serverName && remoteServer.url === configuredUrl,
+					)
+					if (!stillInRemoteConfig) {
+						delete servers[serverName]
+					}
+				}
+			}
+
+			// Add/update servers from new remote config
+			for (const server of remoteMCPServers) {
+				// Check if server with same name and URL already exists to skip duplicates
+				const existingServer = servers[server.name]
+				if (existingServer && getConfiguredServerUrl(existingServer) === server.url) {
+					if (!existingServer.remoteConfigured) {
+						existingServer.remoteConfigured = true
+					}
+					// Keep the historical top-level URL field for remote-configured
+					// servers so older sync/UI code can identify the managed server
+					// without needing to understand nested SDK transport shape.
+					if (!existingServer.url) {
+						existingServer.url = server.url
+					}
+					continue
+				}
+
+				// Add or update the server with remoteConfigured marker
+				servers[server.name] = {
+					url: server.url,
+					type: "streamableHttp",
+					disabled: false,
+					autoApprove: [],
+					remoteConfigured: true,
+				}
+			}
+			config.mcpServers = servers
+			return config
+		})
+		if (mcpHub) {
+			mcpHub.recordSettingsFingerprint(config.mcpServers)
+		}
+	} catch (error) {
+		Logger.error("[RemoteConfig] Failed to sync remote MCP servers:", error)
+	}
+}
diff --git a/apps/vscode/src/core/storage/remote-config/utils.ts b/apps/vscode/src/core/storage/remote-config/utils.ts
new file mode 100644
index 0000000..31ca257
--- /dev/null
+++ b/apps/vscode/src/core/storage/remote-config/utils.ts
@@ -0,0 +1,436 @@
+import { synchronizeRemoteRuleToggles } from "@core/context/instructions/user-instructions/rule-helpers"
+import { parseRemoteSkillEntries } from "@core/context/instructions/user-instructions/skills"
+import type { RemoteConfig, S3AccessKeySettings } from "@shared/remote-config/schema"
+import { ConfiguredAPIKeys, GlobalStateAndSettings, RemoteConfigFields } from "@shared/storage/state-keys"
+import { AuthService } from "@/services/auth/AuthService"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { type McpHub } from "@/services/mcp/McpHub"
+import { telemetryService } from "@/services/telemetry"
+import { OpenTelemetryClientProvider } from "@/services/telemetry/providers/opentelemetry/OpenTelemetryClientProvider"
+import { OpenTelemetryTelemetryProvider } from "@/services/telemetry/providers/opentelemetry/OpenTelemetryTelemetryProvider"
+import { type TelemetryService } from "@/services/telemetry/TelemetryService"
+import { ApiProvider } from "@/shared/api"
+import { isOpenTelemetryConfigValid, remoteConfigToOtelConfig } from "@/shared/services/config/otel-config"
+import { Logger } from "@/shared/services/Logger"
+import { syncWorker } from "@/shared/services/worker/sync"
+import { BlobStoreSettings } from "@/shared/storage"
+import { StateManager } from "../StateManager"
+import { syncRemoteMcpServersToSettings } from "./syncRemoteMcpServers"
+
+function accessSettingsToBlobStorage(type: BlobStoreSettings["adapterType"], settings: S3AccessKeySettings): BlobStoreSettings {
+	return {
+		adapterType: type,
+		accessKeyId: settings.accessKeyId,
+		secretAccessKey: settings.secretAccessKey,
+		region: settings.region,
+		bucket: settings.bucket,
+		endpoint: settings.endpoint,
+		accountId: settings.accountId,
+		intervalMs: settings.intervalMs,
+		maxRetries: settings.maxRetries,
+		batchSize: settings.batchSize,
+		maxQueueSize: settings.maxQueueSize,
+		maxFailedAgeMs: settings.maxFailedAgeMs,
+		backfillEnabled: settings.backfillEnabled,
+	}
+}
+
+/**
+ * Transforms RemoteConfig schema to RemoteConfigFields shape
+ * @param remoteConfig The remote configuration object
+ * @returns Partial<RemoteConfigFields> containing only the fields present in remote config
+ */
+export function transformRemoteConfigToStateShape(remoteConfig: RemoteConfig): Partial<RemoteConfigFields> {
+	const transformed: Partial<RemoteConfigFields> = {}
+
+	// Map top-level settings
+	if (remoteConfig.telemetryEnabled !== undefined) {
+		transformed.telemetrySetting = remoteConfig.telemetryEnabled ? "enabled" : "disabled"
+	}
+	if (remoteConfig.mcpMarketplaceEnabled !== undefined) {
+		transformed.mcpMarketplaceEnabled = remoteConfig.mcpMarketplaceEnabled
+	}
+	if (remoteConfig.allowedMCPServers !== undefined) {
+		transformed.allowedMCPServers = remoteConfig.allowedMCPServers
+	}
+	if (remoteConfig.blockPersonalRemoteMCPServers !== undefined) {
+		transformed.blockPersonalRemoteMCPServers = remoteConfig.blockPersonalRemoteMCPServers
+	}
+	if (remoteConfig.remoteMCPServers !== undefined) {
+		transformed.remoteMCPServers = remoteConfig.remoteMCPServers
+	}
+	if (remoteConfig.yoloModeAllowed !== undefined) {
+		// only set the yoloModeToggled field if yolo mode is not allowed. Otherwise, we let the user toggle it.
+		if (remoteConfig.yoloModeAllowed === false) {
+			transformed.yoloModeToggled = false
+		}
+	}
+
+	// Map OpenTelemetry settings
+	if (remoteConfig.openTelemetryEnabled !== undefined) {
+		transformed.openTelemetryEnabled = remoteConfig.openTelemetryEnabled
+	}
+	if (remoteConfig.openTelemetryMetricsExporter !== undefined) {
+		transformed.openTelemetryMetricsExporter = remoteConfig.openTelemetryMetricsExporter
+	}
+	if (remoteConfig.openTelemetryLogsExporter !== undefined) {
+		transformed.openTelemetryLogsExporter = remoteConfig.openTelemetryLogsExporter
+	}
+	if (remoteConfig.openTelemetryOtlpProtocol !== undefined) {
+		transformed.openTelemetryOtlpProtocol = remoteConfig.openTelemetryOtlpProtocol
+	}
+	if (remoteConfig.openTelemetryOtlpEndpoint !== undefined) {
+		transformed.openTelemetryOtlpEndpoint = remoteConfig.openTelemetryOtlpEndpoint
+	}
+	if (remoteConfig.openTelemetryOtlpMetricsProtocol !== undefined) {
+		transformed.openTelemetryOtlpMetricsProtocol = remoteConfig.openTelemetryOtlpMetricsProtocol
+	}
+	if (remoteConfig.openTelemetryOtlpMetricsEndpoint !== undefined) {
+		transformed.openTelemetryOtlpMetricsEndpoint = remoteConfig.openTelemetryOtlpMetricsEndpoint
+	}
+	if (remoteConfig.openTelemetryOtlpLogsProtocol !== undefined) {
+		transformed.openTelemetryOtlpLogsProtocol = remoteConfig.openTelemetryOtlpLogsProtocol
+	}
+	if (remoteConfig.openTelemetryOtlpLogsEndpoint !== undefined) {
+		transformed.openTelemetryOtlpLogsEndpoint = remoteConfig.openTelemetryOtlpLogsEndpoint
+	}
+	if (remoteConfig.openTelemetryMetricExportInterval !== undefined) {
+		transformed.openTelemetryMetricExportInterval = remoteConfig.openTelemetryMetricExportInterval
+	}
+	if (remoteConfig.openTelemetryOtlpInsecure !== undefined) {
+		transformed.openTelemetryOtlpInsecure = remoteConfig.openTelemetryOtlpInsecure
+	}
+	if (remoteConfig.openTelemetryLogBatchSize !== undefined) {
+		transformed.openTelemetryLogBatchSize = remoteConfig.openTelemetryLogBatchSize
+	}
+	if (remoteConfig.openTelemetryLogBatchTimeout !== undefined) {
+		transformed.openTelemetryLogBatchTimeout = remoteConfig.openTelemetryLogBatchTimeout
+	}
+	if (remoteConfig.openTelemetryLogMaxQueueSize !== undefined) {
+		transformed.openTelemetryLogMaxQueueSize = remoteConfig.openTelemetryLogMaxQueueSize
+	}
+	if (remoteConfig.openTelemetryOtlpHeaders !== undefined) {
+		transformed.openTelemetryOtlpHeaders = remoteConfig.openTelemetryOtlpHeaders
+	}
+	if (remoteConfig.openTelemetryOtlpMetricsHeaders !== undefined) {
+		transformed.otlpMetricsHeaders = remoteConfig.openTelemetryOtlpMetricsHeaders
+	}
+	if (remoteConfig.openTelemetryOtlpLogsHeaders !== undefined) {
+		transformed.otlpLogsHeaders = remoteConfig.openTelemetryOtlpLogsHeaders
+	}
+
+	// Map provider settings
+	const providers: ApiProvider[] = []
+
+	// Map OpenAiCompatible provider settings
+	const openAiSettings = remoteConfig.providerSettings?.OpenAiCompatible
+	if (openAiSettings) {
+		transformed.planModeApiProvider = "openai"
+		transformed.actModeApiProvider = "openai"
+		providers.push("openai")
+
+		if (openAiSettings.openAiBaseUrl !== undefined) {
+			transformed.openAiBaseUrl = openAiSettings.openAiBaseUrl
+		}
+		if (openAiSettings.openAiHeaders !== undefined) {
+			transformed.openAiHeaders = openAiSettings.openAiHeaders
+		}
+		if (openAiSettings.azureApiVersion !== undefined) {
+			transformed.azureApiVersion = openAiSettings.azureApiVersion
+		}
+		if (openAiSettings.azureIdentity !== undefined) {
+			transformed.azureIdentity = openAiSettings.azureIdentity
+		}
+	}
+
+	// Map AwsBedrock provider settings
+	const awsBedrockSettings = remoteConfig.providerSettings?.AwsBedrock
+	if (awsBedrockSettings) {
+		transformed.planModeApiProvider = "bedrock"
+		transformed.actModeApiProvider = "bedrock"
+		providers.push("bedrock")
+
+		if (awsBedrockSettings.awsRegion !== undefined) {
+			transformed.awsRegion = awsBedrockSettings.awsRegion
+		}
+		if (awsBedrockSettings.awsUseCrossRegionInference !== undefined) {
+			transformed.awsUseCrossRegionInference = awsBedrockSettings.awsUseCrossRegionInference
+		}
+		if (awsBedrockSettings.awsUseGlobalInference !== undefined) {
+			transformed.awsUseGlobalInference = awsBedrockSettings.awsUseGlobalInference
+		}
+		if (awsBedrockSettings.awsBedrockUsePromptCache !== undefined) {
+			transformed.awsBedrockUsePromptCache = awsBedrockSettings.awsBedrockUsePromptCache
+		}
+		if (awsBedrockSettings.awsBedrockEndpoint !== undefined) {
+			transformed.awsBedrockEndpoint = awsBedrockSettings.awsBedrockEndpoint
+		}
+	}
+
+	const clineSettings = remoteConfig.providerSettings?.Cline
+	if (clineSettings) {
+		transformed.planModeApiProvider = "cline"
+		transformed.actModeApiProvider = "cline"
+		providers.push("cline")
+	}
+
+	// Map LiteLLM provider settings
+	const liteLlmSettings = remoteConfig.providerSettings?.LiteLLM
+	if (liteLlmSettings) {
+		transformed.planModeApiProvider = "litellm"
+		transformed.actModeApiProvider = "litellm"
+		providers.push("litellm")
+
+		if (liteLlmSettings.baseUrl !== undefined) {
+			transformed.liteLlmBaseUrl = liteLlmSettings.baseUrl
+		}
+	}
+
+	// Map Vertex provider settings
+	const vertexSettings = remoteConfig.providerSettings?.Vertex
+	if (vertexSettings) {
+		transformed.planModeApiProvider = "vertex"
+		transformed.actModeApiProvider = "vertex"
+		providers.push("vertex")
+
+		if (vertexSettings.vertexProjectId !== undefined) {
+			transformed.vertexProjectId = vertexSettings.vertexProjectId
+		}
+		if (vertexSettings.vertexRegion !== undefined) {
+			transformed.vertexRegion = vertexSettings.vertexRegion
+		}
+	}
+
+	const anthropicSettings = remoteConfig.providerSettings?.Anthropic
+	if (anthropicSettings) {
+		transformed.planModeApiProvider = "anthropic"
+		transformed.actModeApiProvider = "anthropic"
+		providers.push("anthropic")
+
+		if (anthropicSettings.baseUrl) {
+			transformed.anthropicBaseUrl = anthropicSettings.baseUrl
+		}
+	}
+
+	// This line needs to stay here, it is order dependent on the above code checking the configured providers
+	if (providers.length > 0) {
+		transformed.remoteConfiguredProviders = providers
+	}
+
+	// Map global rules, workflows, and skills
+	if (remoteConfig.globalRules !== undefined) {
+		transformed.remoteGlobalRules = remoteConfig.globalRules
+	}
+	if (remoteConfig.globalWorkflows !== undefined) {
+		transformed.remoteGlobalWorkflows = remoteConfig.globalWorkflows
+	}
+	if (remoteConfig.globalSkills !== undefined) {
+		transformed.remoteGlobalSkills = remoteConfig.globalSkills
+	}
+
+	if (remoteConfig.enterpriseTelemetry?.promptUploading) {
+		const promptUplaoding = remoteConfig.enterpriseTelemetry.promptUploading
+		if (promptUplaoding.type === "s3_access_keys" && promptUplaoding.s3AccessSettings) {
+			transformed.blobStoreConfig = accessSettingsToBlobStorage("s3", promptUplaoding.s3AccessSettings)
+		} else if (promptUplaoding.type === "r2_access_keys" && promptUplaoding.r2AccessSettings) {
+			transformed.blobStoreConfig = accessSettingsToBlobStorage("r2", promptUplaoding.r2AccessSettings)
+		} else if (promptUplaoding.type === "azure_access_keys" && promptUplaoding.azureAccessSettings) {
+			transformed.blobStoreConfig = accessSettingsToBlobStorage("azure", promptUplaoding.azureAccessSettings)
+		}
+	}
+
+	return transformed
+}
+
+export const REMOTE_CONFIG_OTEL_PROVIDER_ID = "OpenTelemetryRemoteConfiguredProvider"
+async function applyRemoteOTELConfig(transformed: Partial<RemoteConfigFields>, telemetryService: TelemetryService) {
+	try {
+		const otelConfig = remoteConfigToOtelConfig(transformed)
+		if (isOpenTelemetryConfigValid(otelConfig)) {
+			const client = new OpenTelemetryClientProvider(otelConfig)
+
+			if (client.meterProvider || client.loggerProvider) {
+				telemetryService.addProvider(
+					await new OpenTelemetryTelemetryProvider(client.meterProvider, client.loggerProvider, {
+						name: REMOTE_CONFIG_OTEL_PROVIDER_ID,
+						bypassUserSettings: true,
+					}).initialize(),
+				)
+			}
+		}
+	} catch (err) {
+		Logger.error("[REMOTE CONFIG DEBUG] Failed to apply remote OTEL config", err)
+	}
+}
+
+async function applyRemoteSyncQueueConfig(transformed: Partial<RemoteConfigFields>) {
+	try {
+		const blobStoreConfig = transformed.blobStoreConfig
+		if (!blobStoreConfig) {
+			return
+		}
+
+		syncWorker().init({ ...blobStoreConfig, userDistinctId: getDistinctId() })
+	} catch (err) {
+		Logger.error("[REMOTE CONFIG DEBUG] Failed to apply remote sync queue config", err)
+	}
+}
+
+export function clearRemoteConfig() {
+	try {
+		const stateManager = StateManager.get()
+
+		stateManager.clearRemoteConfig()
+		telemetryService.removeProvider(REMOTE_CONFIG_OTEL_PROVIDER_ID)
+		// the remote config cline rules toggle state is stored in global state
+		stateManager.setGlobalState("remoteRulesToggles", {})
+		stateManager.setGlobalState("remoteWorkflowToggles", {})
+		stateManager.setGlobalState("remoteSkillsToggles", {})
+
+		// clear secrets
+		stateManager.setSecret("remoteLiteLlmApiKey", undefined)
+	} catch (err) {
+		Logger.error("[REMOTE CONFIG] Failed to clear remote config", err)
+	}
+}
+
+/**
+ * Applies remote config to the StateManager's remote config cache
+ * @param remoteConfig The remote configuration object to apply
+ * @param mcpHub McpHub instance to prevent watcher triggers during sync
+ */
+export async function applyRemoteConfig(
+	remoteConfig: RemoteConfig,
+	configuredKeys: ConfiguredAPIKeys,
+	mcpHub: McpHub,
+): Promise<void> {
+	const stateManager = StateManager.get()
+	// If no remote config provided, clear the cache and relevant state
+	if (!remoteConfig) {
+		clearRemoteConfig()
+		return
+	}
+
+	// Save previousRemoteMCPServers before clearing cache, this is needed for next sync to detect removals)
+	const previousRemoteMCPServers = stateManager.getRemoteConfigSettings().previousRemoteMCPServers
+
+	// Transform remote config to state shape
+	// These are then set to the remote config cache in the StateManager
+	// We need to ensure the cache is checked for new fields
+	const transformed = transformRemoteConfigToStateShape(remoteConfig)
+
+	// Synchronize toggle state
+	const currentRuleToggles = stateManager.getGlobalStateKey("remoteRulesToggles") || {}
+	const currentWorkflowToggles = stateManager.getGlobalStateKey("remoteWorkflowToggles") || {}
+
+	const syncedRuleToggles = synchronizeRemoteRuleToggles(remoteConfig.globalRules || [], currentRuleToggles)
+	const syncedWorkflowToggles = synchronizeRemoteRuleToggles(remoteConfig.globalWorkflows || [], currentWorkflowToggles)
+
+	// Remote skills use shared validation (entry.name must match frontmatter.name)
+	const currentSkillToggles = stateManager.getGlobalStateKey("remoteSkillsToggles") || {}
+	const validatedSkillEntries = parseRemoteSkillEntries(remoteConfig.globalSkills || [])
+	const syncedSkillToggles = synchronizeRemoteRuleToggles(validatedSkillEntries, currentSkillToggles)
+
+	// Enforce alwaysEnabled: override any stale false toggles for skills the admin has locked on.
+	// This ensures the toggle store is the single source of truth — both the UI and handler agree.
+	for (const entry of validatedSkillEntries) {
+		if (entry.alwaysEnabled && syncedSkillToggles[entry.name] === false) {
+			syncedSkillToggles[entry.name] = true
+		}
+	}
+
+	stateManager.setGlobalState("remoteRulesToggles", syncedRuleToggles)
+	stateManager.setGlobalState("remoteWorkflowToggles", syncedWorkflowToggles)
+	stateManager.setGlobalState("remoteSkillsToggles", syncedSkillToggles)
+
+	telemetryService.removeProvider(REMOTE_CONFIG_OTEL_PROVIDER_ID)
+
+	// If the existing configured provider is valid, don't update it
+	const apiConfiguration = stateManager.getApiConfiguration()
+	if (isProviderValid(apiConfiguration.actModeApiProvider, transformed)) {
+		transformed.actModeApiProvider = apiConfiguration.actModeApiProvider
+	}
+	if (isProviderValid(apiConfiguration.planModeApiProvider, transformed)) {
+		transformed.planModeApiProvider = apiConfiguration.planModeApiProvider
+	}
+
+	// Build the full new cache and swap atomically to avoid a window where
+	// concurrent readers (e.g., UseSkillToolHandler) see an empty cache.
+	const newCache: Partial<RemoteConfigFields> = { ...transformed, configuredApiKeys: configuredKeys }
+	if (previousRemoteMCPServers !== undefined) {
+		newCache.previousRemoteMCPServers = previousRemoteMCPServers
+	}
+	stateManager.replaceRemoteConfig(newCache)
+
+	applyRemoteSyncQueueConfig(transformed)
+
+	// Always sync remote MCP servers when remote config is active.
+	// The sync function uses the persistent `remoteConfigured` marker in the settings file
+	// to identify which servers were added by remote config. This means:
+	// - Servers no longer in remoteMCPServers but marked `remoteConfigured: true` get removed
+	// - New servers get added with the `remoteConfigured: true` marker
+	// - No dependency on in-memory state that would be lost across restarts
+	try {
+		const serversToSync = remoteConfig.remoteMCPServers ?? []
+		const settingsPath = await mcpHub.getMcpSettingsFilePath()
+		await syncRemoteMcpServersToSettings(serversToSync, settingsPath, mcpHub)
+		stateManager.setRemoteConfigField("previousRemoteMCPServers", serversToSync)
+	} catch (error) {
+		Logger.error("[RemoteConfig] Failed to sync remote MCP servers to settings:", error)
+		// Continue with other config application even if MCP sync fails
+	}
+	await applyRemoteOTELConfig(transformed, telemetryService)
+}
+
+const isProviderValid = (provider?: ApiProvider, remoteConfig?: Partial<RemoteConfigFields>) => {
+	const remoteConfiguredProviders =
+		remoteConfig?.remoteConfiguredProviders ?? StateManager.get().getRemoteConfigSettings().remoteConfiguredProviders
+	if (!remoteConfiguredProviders || !remoteConfiguredProviders.length) {
+		return true
+	}
+
+	return provider && remoteConfiguredProviders.includes(provider)
+}
+
+/**
+ * Receives a config and returns the subset of fields that can be overriden in the cache
+ */
+export function filterAllowedRemoteConfigFields(config: Partial<GlobalStateAndSettings>): Partial<GlobalStateAndSettings> {
+	const updatedFields: Partial<GlobalStateAndSettings> = {}
+
+	const actModeApiProvider = config.actModeApiProvider
+	if (isProviderValid(actModeApiProvider)) {
+		updatedFields.actModeApiProvider = actModeApiProvider
+	}
+
+	const planModeApiProvider = config.planModeApiProvider
+	if (isProviderValid(planModeApiProvider)) {
+		updatedFields.planModeApiProvider = planModeApiProvider
+	}
+
+	return updatedFields
+}
+
+const canDisableRemoteConfig = (orgId: string) => {
+	// Check if they're an admin/owner
+	const authService = AuthService.getInstance()
+	const userOrgs = authService.getUserOrganizations()
+
+	if (!userOrgs) {
+		return false
+	}
+
+	const org = userOrgs.find((org) => org.organizationId === orgId)
+	const isAdminOrOwner = org?.roles?.some((role) => role === "admin" || role === "owner")
+
+	return isAdminOrOwner
+}
+
+export const isRemoteConfigEnabled = (orgId: string) => {
+	const stateManager = StateManager.get()
+	const hasOptedOut = stateManager.getGlobalSettingsKey("optOutOfRemoteConfig")
+
+	const isDisabled = hasOptedOut && canDisableRemoteConfig(orgId)
+
+	return !isDisabled
+}
diff --git a/apps/vscode/src/core/storage/skill-directories.ts b/apps/vscode/src/core/storage/skill-directories.ts
new file mode 100644
index 0000000..2426b66
--- /dev/null
+++ b/apps/vscode/src/core/storage/skill-directories.ts
@@ -0,0 +1,41 @@
+import os from "os"
+import * as path from "path"
+
+const SKILL_DIRECTORY_NAMES = {
+	clineruleSkillsDir: ".clinerules/skills",
+	clineSkillsDir: ".cline/skills",
+	claudeSkillsDir: ".claude/skills",
+	agentsSkillsDir: ".agents/skills",
+} as const
+
+export type SkillsScanDirectory = {
+	path: string
+	source: "project" | "global"
+}
+
+function getClineHomePath(): string {
+	return path.join(os.homedir(), ".cline")
+}
+
+function getClineSkillsDirectoryPath(): string {
+	return path.join(getClineHomePath(), "skills")
+}
+
+function getAgentSkillsDirectoryPath(): string {
+	return path.join(os.homedir(), ".agents", "skills")
+}
+
+/**
+ * Returns the list of skills directories to scan without creating them.
+ * Order is project directories first, then global directories.
+ */
+export function getSkillsDirectoriesForScan(cwd: string): SkillsScanDirectory[] {
+	return [
+		{ path: path.join(cwd, SKILL_DIRECTORY_NAMES.clineruleSkillsDir), source: "project" },
+		{ path: path.join(cwd, SKILL_DIRECTORY_NAMES.clineSkillsDir), source: "project" },
+		{ path: path.join(cwd, SKILL_DIRECTORY_NAMES.claudeSkillsDir), source: "project" },
+		{ path: path.join(cwd, SKILL_DIRECTORY_NAMES.agentsSkillsDir), source: "project" },
+		{ path: getClineSkillsDirectoryPath(), source: "global" },
+		{ path: getAgentSkillsDirectoryPath(), source: "global" },
+	]
+}
diff --git a/apps/vscode/src/core/storage/state-migrations.ts b/apps/vscode/src/core/storage/state-migrations.ts
new file mode 100644
index 0000000..e4a3076
--- /dev/null
+++ b/apps/vscode/src/core/storage/state-migrations.ts
@@ -0,0 +1,233 @@
+import fs from "fs/promises"
+import path from "path"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { ensureRulesDirectoryExists } from "./disk"
+
+export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionContext) {
+	// Keys to migrate from workspace storage back to global storage
+	const keysToMigrate = [
+		// Core settings
+		"apiProvider",
+		"apiModelId",
+		"thinkingBudgetTokens",
+		"reasoningEffort",
+		"vsCodeLmModelSelector",
+
+		// Provider-specific model keys
+		"awsBedrockCustomSelected",
+		"awsBedrockCustomModelBaseId",
+		"openRouterModelId",
+		"openRouterModelInfo",
+		"openAiModelId",
+		"openAiModelInfo",
+		"ollamaModelId",
+		"lmStudioModelId",
+		"liteLlmModelId",
+		"liteLlmModelInfo",
+		"requestyModelId",
+		"requestyModelInfo",
+		"togetherModelId",
+		"fireworksModelId",
+		"sapAiCoreModelId",
+		"groqModelId",
+		"groqModelInfo",
+		"huggingFaceModelId",
+		"huggingFaceModelInfo",
+
+		// Previous mode settings
+		"previousModeApiProvider",
+		"previousModeModelId",
+		"previousModeModelInfo",
+		"previousModeVsCodeLmModelSelector",
+		"previousModeThinkingBudgetTokens",
+		"previousModeReasoningEffort",
+		"previousModeAwsBedrockCustomSelected",
+		"previousModeAwsBedrockCustomModelBaseId",
+		"previousModeSapAiCoreModelId",
+	]
+
+	for (const key of keysToMigrate) {
+		// Use raw workspace state since these keys shouldn't be in workspace storage
+		const workspaceValue = await context.workspaceState.get(key)
+		const globalValue = await context.globalState.get(key)
+
+		if (workspaceValue !== undefined && globalValue === undefined) {
+			Logger.log(`[Storage Migration] migrating key: ${key} to global storage. Current value: ${workspaceValue}`)
+
+			// Move to global storage using raw VSCode method to avoid type errors
+			await context.globalState.update(key, workspaceValue)
+			// Remove from workspace storage
+			await context.workspaceState.update(key, undefined)
+			const newWorkspaceValue = await context.workspaceState.get(key)
+
+			Logger.log(`[Storage Migration] migrated key: ${key} to global storage. Current value: ${newWorkspaceValue}`)
+		}
+	}
+}
+
+export async function migrateTaskHistoryToFile(_context: vscode.ExtensionContext) {
+	// TODO migrate to sdk location
+}
+
+export async function migrateCustomInstructionsToGlobalRules(context: vscode.ExtensionContext) {
+	try {
+		const customInstructions = (await context.globalState.get("customInstructions")) as string | undefined
+
+		if (customInstructions?.trim()) {
+			Logger.log("Migrating custom instructions to global Cline rules...")
+
+			// Create global .clinerules directory if it doesn't exist
+			const globalRulesDir = await ensureRulesDirectoryExists()
+
+			// Use a fixed filename for custom instructions
+			const migrationFileName = "custom_instructions.md"
+			const migrationFilePath = path.join(globalRulesDir, migrationFileName)
+
+			try {
+				// Check if file already exists to determine if we should append
+				let existingContent = ""
+				try {
+					existingContent = await fs.readFile(migrationFilePath, "utf8")
+				} catch (_readError) {
+					// File doesn't exist, which is fine
+				}
+
+				// Append or create the file with custom instructions
+				const contentToWrite = existingContent
+					? `${existingContent}\n\n---\n\n${customInstructions.trim()}`
+					: customInstructions.trim()
+
+				await fs.writeFile(migrationFilePath, contentToWrite)
+				Logger.log(`Successfully ${existingContent ? "appended to" : "created"} migration file: ${migrationFilePath}`)
+			} catch (fileError) {
+				Logger.error("Failed to write migration file:", fileError)
+				return
+			}
+
+			// Remove customInstructions from global state only after successful file creation
+			await context.globalState.update("customInstructions", undefined)
+			Logger.log("Successfully migrated custom instructions to global Cline rules")
+		}
+	} catch (error) {
+		Logger.error("Failed to migrate custom instructions to global rules:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}
+
+export async function migrateWelcomeViewCompleted(context: vscode.ExtensionContext) {
+	try {
+		// Check if welcomeViewCompleted is already set
+		const welcomeViewCompleted = context.globalState.get("welcomeViewCompleted")
+
+		if (welcomeViewCompleted === undefined) {
+			Logger.log("Migrating welcomeViewCompleted setting...")
+
+			// Fetch API keys directly from secrets
+			const apiKey = await context.secrets.get("apiKey")
+			const openRouterApiKey = await context.secrets.get("openRouterApiKey")
+			const clineAccountId = await context.secrets.get("clineAccountId")
+			const openAiApiKey = await context.secrets.get("openAiApiKey")
+			const ollamaApiKey = await context.secrets.get("ollamaApiKey")
+			const liteLlmApiKey = await context.secrets.get("liteLlmApiKey")
+			const geminiApiKey = await context.secrets.get("geminiApiKey")
+			const openAiNativeApiKey = await context.secrets.get("openAiNativeApiKey")
+			const deepSeekApiKey = await context.secrets.get("deepSeekApiKey")
+			const requestyApiKey = await context.secrets.get("requestyApiKey")
+			const togetherApiKey = await context.secrets.get("togetherApiKey")
+			const qwenApiKey = await context.secrets.get("qwenApiKey")
+			const doubaoApiKey = await context.secrets.get("doubaoApiKey")
+			const mistralApiKey = await context.secrets.get("mistralApiKey")
+			const asksageApiKey = await context.secrets.get("asksageApiKey")
+			const xaiApiKey = await context.secrets.get("xaiApiKey")
+			const sambanovaApiKey = await context.secrets.get("sambanovaApiKey")
+			const sapAiCoreClientId = await context.secrets.get("sapAiCoreClientId")
+			const difyApiKey = await context.secrets.get("difyApiKey")
+			const hicapApiKey = await context.secrets.get("hicapApiKey")
+			// OpenAI Codex OAuth credentials
+			const openAiCodexCredentials = await context.secrets.get("openai-codex-oauth-credentials")
+
+			// Fetch configuration values from global state
+			const awsRegion = context.globalState.get("awsRegion")
+			const vertexProjectId = context.globalState.get("vertexProjectId")
+			const planModeOllamaModelId = context.globalState.get("planModeOllamaModelId")
+			const planModeLmStudioModelId = context.globalState.get("planModeLmStudioModelId")
+			const actModeOllamaModelId = context.globalState.get("actModeOllamaModelId")
+			const actModeLmStudioModelId = context.globalState.get("actModeLmStudioModelId")
+			const planModeVsCodeLmModelSelector = context.globalState.get("planModeVsCodeLmModelSelector")
+			const actModeVsCodeLmModelSelector = context.globalState.get("actModeVsCodeLmModelSelector")
+
+			// This is the original logic used for checking if the welcome view should be shown
+			// It was located in the ExtensionStateContextProvider
+			const hasKey = [
+				apiKey,
+				openRouterApiKey,
+				awsRegion,
+				vertexProjectId,
+				openAiApiKey,
+				ollamaApiKey,
+				planModeOllamaModelId,
+				planModeLmStudioModelId,
+				actModeOllamaModelId,
+				actModeLmStudioModelId,
+				liteLlmApiKey,
+				geminiApiKey,
+				openAiNativeApiKey,
+				deepSeekApiKey,
+				requestyApiKey,
+				togetherApiKey,
+				qwenApiKey,
+				doubaoApiKey,
+				mistralApiKey,
+				planModeVsCodeLmModelSelector,
+				actModeVsCodeLmModelSelector,
+				clineAccountId,
+				asksageApiKey,
+				xaiApiKey,
+				sambanovaApiKey,
+				sapAiCoreClientId,
+				difyApiKey,
+				hicapApiKey,
+				openAiCodexCredentials,
+			].some((key) => key !== undefined)
+
+			// Set welcomeViewCompleted based on whether user has keys
+			await context.globalState.update("welcomeViewCompleted", hasKey)
+
+			Logger.log(`Migration: Set welcomeViewCompleted to ${hasKey} based on existing API keys`)
+		}
+	} catch (error) {
+		Logger.error("Failed to migrate welcomeViewCompleted:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}
+
+export async function cleanupMcpMarketplaceCatalogFromGlobalState(context: vscode.ExtensionContext) {
+	try {
+		// Check if mcpMarketplaceCatalog exists in global state
+		const mcpMarketplaceCatalog = await context.globalState.get("mcpMarketplaceCatalog")
+
+		if (mcpMarketplaceCatalog !== undefined) {
+			Logger.log("Cleaning up mcpMarketplaceCatalog from global state...")
+
+			// Delete it from global state
+			await context.globalState.update("mcpMarketplaceCatalog", undefined)
+
+			Logger.log("Successfully removed mcpMarketplaceCatalog from global state")
+		}
+	} catch (error) {
+		Logger.error("Failed to cleanup mcpMarketplaceCatalog from global state:", error)
+		// Continue execution - cleanup failure shouldn't break extension startup
+	}
+}
+
+export async function cleanupOldApiKey(context: vscode.ExtensionContext) {
+	try {
+		// Old API Keys were introduced in March 2025 and later replaced with tokens
+		// Now that we have new API keys that are prefixed with `sk_`,
+		// we need to clean up the old ones to free the secret storage
+		await context.secrets.delete("clineApiKey")
+	} catch (error) {
+		Logger.error("Failed to cleanup old clineApiKey", error)
+	}
+}
diff --git a/apps/vscode/src/core/storage/utils/state-helpers.ts b/apps/vscode/src/core/storage/utils/state-helpers.ts
new file mode 100644
index 0000000..38fa091
--- /dev/null
+++ b/apps/vscode/src/core/storage/utils/state-helpers.ts
@@ -0,0 +1,119 @@
+import { ApiProvider } from "@shared/api"
+import type { ClineFileStorage } from "@shared/storage/ClineFileStorage"
+import {
+	applyTransform,
+	GlobalStateAndSettingKeys,
+	GlobalStateAndSettings,
+	getDefaultValue,
+	isAsyncProperty,
+	isComputedProperty,
+	LocalState,
+	LocalStateKeys,
+	SecretKeys,
+	Secrets,
+} from "@shared/storage/state-keys"
+import { Logger } from "@/shared/services/Logger"
+import { ClineMemento } from "@/shared/storage"
+import { StateManager } from "../StateManager"
+
+// ─── File-backed storage readers (used by StateManager) ────────────────────
+
+/**
+ * Read secrets from a ClineFileStorage instance.
+ */
+export function readSecretsFromStorage(store: ClineFileStorage<string>): Secrets {
+	return SecretKeys.reduce((acc, key) => {
+		acc[key] = store.get(key)
+		return acc
+	}, {} as Secrets)
+}
+
+/**
+ * Read workspace state from a ClineFileStorage instance.
+ */
+export function readWorkspaceStateFromStorage(store: ClineFileStorage): LocalState {
+	return LocalStateKeys.reduce((acc, key) => {
+		acc[key] = store.get(key) || {}
+		return acc
+	}, {} as LocalState)
+}
+
+/**
+ * Read global state from a ClineFileStorage instance.
+ */
+export async function readGlobalStateFromStorage(store: ClineMemento): Promise<GlobalStateAndSettings> {
+	try {
+		// Batch read all state values in a single optimized pass
+		const stateValues = new Map<string, any>()
+		for (const key of GlobalStateAndSettingKeys) {
+			const value = store.get(key as string)
+			stateValues.set(key, value)
+		}
+
+		const result = {} as any
+
+		for (const key of GlobalStateAndSettingKeys) {
+			const stateKey = key as keyof GlobalStateAndSettings
+			let value = stateValues.get(stateKey)
+
+			if (isAsyncProperty(stateKey)) {
+				continue
+			}
+			if (isComputedProperty(stateKey)) {
+				continue
+			}
+			if (value === undefined) {
+				const defaultValue = getDefaultValue(stateKey)
+				if (defaultValue !== undefined) {
+					value = defaultValue
+				}
+			}
+			if (value !== undefined) {
+				value = applyTransform(stateKey, value)
+			}
+			result[stateKey] = value
+		}
+
+		await handleComputedProperties(result, stateValues)
+
+		return result as GlobalStateAndSettings
+	} catch (error) {
+		Logger.error("[StateHelpers] Failed to read global state from storage:", error)
+		throw error
+	}
+}
+
+// ─── Legacy readers (for VSCode migration — reads from ExtensionContext) ────
+
+/**
+ * Handle properties that require computed logic
+ */
+async function handleComputedProperties(result: any, stateValues: Map<string, any>): Promise<void> {
+	// 1. API Provider logic - set defaults based on existing values
+	const defaultApiProvider: ApiProvider = "openrouter"
+	result.planModeApiProvider = result.planModeApiProvider || defaultApiProvider
+	result.actModeApiProvider = result.actModeApiProvider || defaultApiProvider
+
+	// 2. Plan/Act separate models setting with special logic
+	const planActSeparateModelsSettingRaw = stateValues.get("planActSeparateModelsSetting")
+	if (planActSeparateModelsSettingRaw === true || planActSeparateModelsSettingRaw === false) {
+		result.planActSeparateModelsSetting = planActSeparateModelsSettingRaw
+	} else {
+		// Default to false when not explicitly set
+		result.planActSeparateModelsSetting = false
+	}
+}
+
+export async function resetWorkspaceState() {
+	const stateManager = StateManager.get()
+	LocalStateKeys.map((key) => stateManager.setWorkspaceState(key, {}))
+	await stateManager.reInitialize()
+}
+
+export async function resetGlobalState() {
+	// TODO: Reset all workspace states?
+	const stateManager = StateManager.get()
+	GlobalStateAndSettingKeys.map((key) => stateManager.setGlobalState(key, undefined))
+	SecretKeys.map((key) => stateManager.setSecret(key, undefined))
+	await stateManager.reInitialize()
+}
diff --git a/apps/vscode/src/core/task/focus-chain/file-utils.ts b/apps/vscode/src/core/task/focus-chain/file-utils.ts
new file mode 100644
index 0000000..ed5bfa1
--- /dev/null
+++ b/apps/vscode/src/core/task/focus-chain/file-utils.ts
@@ -0,0 +1,77 @@
+import { isFocusChainItem } from "@shared/focus-chain-utils"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { ensureTaskDirectoryExists } from "../../storage/disk"
+
+/**
+ * Generate the standard file path for a task's focusChain markdown file
+ */
+function getFocusChainFilePath(taskDir: string, taskId: string): string {
+	return path.join(taskDir, `focus_chain_taskid_${taskId}.md`)
+}
+
+/**
+ * Create the standard markdown content structure for a focusChain file
+ */
+function createFocusChainMarkdownContent(taskId: string, focusChainList: string): string {
+	return `# Focus Chain List for Task ${taskId}
+
+<!-- Edit this markdown file to update your focus chain list -->
+<!-- Use the format: - [ ] for incomplete items and - [x] for completed items -->
+
+${focusChainList}
+
+<!-- Save this file and the focus chain list will be updated in the task -->`
+}
+
+/**
+ * Extract focusChain items from text content (markdown or message text)
+ * Returns array of lines that match focusChain item format
+ */
+function extractFocusChainItemsFromText(text: string): string[] {
+	const lines = text.split("\n")
+	return lines.filter((line) => {
+		const trimmed = line.trim()
+		return isFocusChainItem(trimmed)
+	})
+}
+
+/**
+ * Extract focusChain items and return as joined string, or null if no items found
+ */
+export function extractFocusChainListFromText(text: string): string | null {
+	const focusChainLines = extractFocusChainItemsFromText(text)
+	return focusChainLines.length > 0 ? focusChainLines.join("\n") : null
+}
+
+/**
+ * Ensure a focusChain file exists, creating it with provided content if it doesn't exist
+ * Returns the file path
+ */
+export async function ensureFocusChainFile(taskId: string, initialFocusChainContent?: string): Promise<string> {
+	const taskDir = await ensureTaskDirectoryExists(taskId)
+	const focusChainFilePath = getFocusChainFilePath(taskDir, taskId)
+
+	// Check if file exists
+	let fileExists = false
+	try {
+		await fs.access(focusChainFilePath)
+		fileExists = true
+	} catch {
+		// File doesn't exist
+	}
+
+	// Create file if it doesn't exist
+	if (!fileExists) {
+		const focusChainContent =
+			initialFocusChainContent ||
+			`- [ ] Example checklist item
+- [ ] Another checklist item
+- [x] Completed example item`
+
+		const fileContent = createFocusChainMarkdownContent(taskId, focusChainContent)
+		await fs.writeFile(focusChainFilePath, fileContent, "utf8")
+	}
+
+	return focusChainFilePath
+}
diff --git a/apps/vscode/src/core/task/tools/subagent/AgentConfigLoader.ts b/apps/vscode/src/core/task/tools/subagent/AgentConfigLoader.ts
new file mode 100644
index 0000000..5267f25
--- /dev/null
+++ b/apps/vscode/src/core/task/tools/subagent/AgentConfigLoader.ts
@@ -0,0 +1,355 @@
+import { parseYamlFrontmatter } from "@core/context/instructions/user-instructions/frontmatter"
+import { Logger } from "@shared/services/Logger"
+import { ClineDefaultTool, setDynamicToolUseNames } from "@shared/tools"
+import chokidar, { type FSWatcher } from "chokidar"
+import fs from "fs/promises"
+import os from "os"
+import * as path from "path"
+import { z } from "zod"
+import { buildSubagentToolName } from "./SubagentToolName"
+
+/** Default Directory for agent configurations: ~/Documents/Cline/Agents */
+const AGENTS_CONFIG_DIRECTORY_NAME = "Agents"
+const SUBAGENT_DYNAMIC_TOOL_NAMESPACE = "subagent"
+
+const AgentBaseConfigSchema = z.object({
+	name: z.string().trim().min(1),
+	description: z.string().trim().min(1),
+	tools: z.array(z.nativeEnum(ClineDefaultTool)).default([]),
+	skills: z.array(z.string().trim().min(1)).optional(),
+	modelId: z.string().trim().min(1).optional(),
+	systemPrompt: z.string().trim().min(1),
+})
+
+const AgentConfigFrontmatterSchema = z.object({
+	name: z.string().trim().min(1),
+	description: z.string().trim().min(1),
+	modelId: z.string().trim().min(1).optional(),
+	tools: z.union([z.string(), z.array(z.string())]).optional(),
+	skills: z.union([z.string(), z.array(z.string())]).optional(),
+})
+
+export type AgentBaseConfig = z.infer<typeof AgentBaseConfigSchema>
+
+function normalizeToolName(toolName: string): ClineDefaultTool {
+	const trimmed = toolName.trim()
+	if (!trimmed) {
+		throw new Error("Tool name cannot be empty.")
+	}
+
+	const asDefaultTool = trimmed as ClineDefaultTool
+	if (Object.values(ClineDefaultTool).includes(asDefaultTool)) {
+		return asDefaultTool
+	}
+
+	throw new Error(
+		`Unknown tool '${trimmed}'. Expected a ClineDefaultTool value (for example: read_file, list_files, search_files).`,
+	)
+}
+
+function parseTools(tools: string | string[] | undefined): ClineDefaultTool[] {
+	if (!tools) {
+		return []
+	}
+
+	const rawTools = Array.isArray(tools) ? tools : tools.split(",")
+	if (rawTools.length === 0) {
+		return []
+	}
+
+	return Array.from(new Set(rawTools.map(normalizeToolName)))
+}
+
+function normalizeSkillName(skillName: string): string {
+	const trimmed = skillName.trim()
+	if (!trimmed) {
+		throw new Error("Skill name cannot be empty.")
+	}
+	return trimmed
+}
+
+function parseSkills(skills: string | string[] | undefined): string[] | undefined {
+	if (skills === undefined) {
+		return undefined
+	}
+
+	const rawSkills = Array.isArray(skills) ? skills : skills.split(",")
+	return Array.from(new Set(rawSkills.map(normalizeSkillName)))
+}
+
+function parseAgentConfigFromYaml(content: string): AgentBaseConfig {
+	const { data, body, hadFrontmatter, parseError } = parseYamlFrontmatter(content)
+	if (parseError) {
+		throw new Error(`Failed to parse YAML frontmatter: ${parseError}`)
+	}
+	if (!hadFrontmatter) {
+		throw new Error("Missing YAML frontmatter block in agent config file.")
+	}
+
+	const parsedFrontmatter = AgentConfigFrontmatterSchema.parse(data)
+	const systemPrompt = body.trim()
+	if (!systemPrompt) {
+		throw new Error("Missing system prompt body in agent config file.")
+	}
+
+	return AgentBaseConfigSchema.parse({
+		name: parsedFrontmatter.name,
+		description: parsedFrontmatter.description,
+		modelId: parsedFrontmatter.modelId,
+		tools: parseTools(parsedFrontmatter.tools),
+		skills: parseSkills(parsedFrontmatter.skills),
+		systemPrompt,
+	}) as AgentBaseConfig
+}
+
+function getAgentsConfigPath(homeDir = os.homedir()): string {
+	return path.join(homeDir, "Documents", "Cline", AGENTS_CONFIG_DIRECTORY_NAME)
+}
+
+function normalizeAgentName(name: string): string {
+	return name.trim().toLowerCase()
+}
+
+function isYamlFile(filePath: string): boolean {
+	return /\.(yaml|yml)$/i.test(filePath)
+}
+
+async function readAgentConfigsFromDisk(homeDir = os.homedir()): Promise<Map<string, AgentBaseConfig>> {
+	const agentsDirectoryPath = getAgentsConfigPath(homeDir)
+	const configs = new Map<string, AgentBaseConfig>()
+
+	try {
+		const entries = await fs.readdir(agentsDirectoryPath, { withFileTypes: true })
+		const yamlFiles = entries
+			.filter((entry) => entry.isFile())
+			.map((entry) => entry.name)
+			.filter(isYamlFile)
+			.sort((a, b) => a.localeCompare(b))
+		Logger.debug(`[AgentConfigLoader] Found ${yamlFiles.length} YAML file(s).`)
+
+		await Promise.all(
+			yamlFiles.map(async (fileName) => {
+				const filePath = path.join(agentsDirectoryPath, fileName)
+				try {
+					const content = await fs.readFile(filePath, "utf8")
+					const parsed = parseAgentConfigFromYaml(content)
+					Logger.debug(`[AgentConfigLoader] Loaded agent config '${fileName}'`, parsed)
+					configs.set(normalizeAgentName(parsed.name), parsed)
+				} catch (error) {
+					Logger.error(`[AgentConfigLoader] Failed to parse agent config '${fileName}'`, error)
+				}
+			}),
+		)
+
+		return configs
+	} catch (error) {
+		const nodeError = error as NodeJS.ErrnoException
+		if (nodeError.code === "ENOENT") {
+			return configs
+		}
+		Logger.error("[AgentConfigLoader] Failed to read agent configs from disk", error)
+		throw error
+	}
+}
+
+export type AgentConfigChangeListener = (configs: ReadonlyMap<string, AgentBaseConfig>, error?: Error) => void
+
+export class AgentConfigLoader {
+	private static instance?: AgentConfigLoader
+
+	private readonly homeDir: string
+	private readonly directoryPath: string
+	private readonly initialLoadPromise: Promise<void>
+	private watcher?: FSWatcher
+	private cachedConfigs = new Map<string, AgentBaseConfig>()
+	private cachedAgentToolNames = new Map<string, string>()
+	private cachedToolNameToAgentName = new Map<string, string>()
+	private listeners = new Set<AgentConfigChangeListener>()
+
+	private constructor(homeDir = os.homedir()) {
+		this.homeDir = homeDir
+		this.directoryPath = getAgentsConfigPath(homeDir)
+		this.initialLoadPromise = this.load()
+			.then(() => undefined)
+			.catch((error) => {
+				Logger.error("[AgentConfigLoader] Failed to load initial agent configs", error)
+			})
+			.finally(() =>
+				this.watch().catch((error) => Logger.error("[AgentConfigLoader] Failed to start watching agent configs", error)),
+			)
+	}
+
+	public static getInstance(homeDir = os.homedir()): AgentConfigLoader {
+		if (!AgentConfigLoader.instance) {
+			AgentConfigLoader.instance = new AgentConfigLoader(homeDir)
+		}
+		return AgentConfigLoader.instance
+	}
+
+	/**
+	 * Test-only helper to clear singleton state between unit tests.
+	 */
+	public static async resetInstanceForTests(): Promise<void> {
+		if (!AgentConfigLoader.instance) {
+			return
+		}
+
+		await AgentConfigLoader.instance.dispose()
+		AgentConfigLoader.instance = undefined
+	}
+
+	public getConfigPath(): string {
+		return this.directoryPath
+	}
+
+	public async ready(): Promise<void> {
+		await this.initialLoadPromise
+	}
+
+	public getCachedConfig(subagentName?: string): AgentBaseConfig | undefined {
+		if (!subagentName?.trim()) {
+			return undefined
+		}
+		return this.cachedConfigs.get(normalizeAgentName(subagentName))
+	}
+
+	public getAllCachedConfigs(): ReadonlyMap<string, AgentBaseConfig> {
+		return new Map(this.cachedConfigs)
+	}
+
+	public getAllCachedConfigsWithToolNames(): Array<{ toolName: string; config: AgentBaseConfig }> {
+		const result: Array<{ toolName: string; config: AgentBaseConfig }> = []
+		for (const [normalizedName, config] of this.cachedConfigs.entries()) {
+			const toolName = this.cachedAgentToolNames.get(normalizedName)
+			if (toolName) {
+				result.push({ toolName, config })
+			}
+		}
+		return result
+	}
+
+	public resolveSubagentNameForTool(toolName?: string): string | undefined {
+		if (!toolName?.trim()) {
+			return undefined
+		}
+
+		const normalizedName = this.cachedToolNameToAgentName.get(toolName.trim())
+		if (!normalizedName) {
+			return undefined
+		}
+
+		return this.cachedConfigs.get(normalizedName)?.name
+	}
+
+	public isDynamicSubagentTool(toolName?: string): boolean {
+		if (!toolName?.trim()) {
+			return false
+		}
+		return this.cachedToolNameToAgentName.has(toolName.trim())
+	}
+
+	public async load(): Promise<ReadonlyMap<string, AgentBaseConfig>> {
+		const configs = await readAgentConfigsFromDisk(this.homeDir)
+		this.cachedConfigs = configs
+		this.rebuildDynamicToolMappings()
+		Logger.debug(`[AgentConfigLoader] Loaded ${configs.size} agent config(s) from disk.`)
+		return this.getAllCachedConfigs()
+	}
+
+	public async watch(listener?: AgentConfigChangeListener): Promise<void> {
+		if (listener) {
+			this.listeners.add(listener)
+		}
+
+		if (this.watcher) {
+			return
+		}
+
+		this.watcher = chokidar.watch(this.directoryPath, {
+			persistent: true,
+			ignoreInitial: true,
+			awaitWriteFinish: {
+				stabilityThreshold: 300,
+				pollInterval: 100,
+			},
+		})
+
+		this.watcher
+			.on("add", (filePath) => {
+				if (isYamlFile(filePath)) {
+					void this.reloadAndNotify()
+				}
+			})
+			.on("change", (filePath) => {
+				if (isYamlFile(filePath)) {
+					void this.reloadAndNotify()
+				}
+			})
+			.on("unlink", (filePath) => {
+				if (isYamlFile(filePath)) {
+					void this.reloadAndNotify()
+				}
+			})
+			.on("error", (error) => {
+				const watcherError = error instanceof Error ? error : new Error(String(error))
+				Logger.error("[AgentConfigLoader] Failed to watch agent configs directory", watcherError)
+				this.notify(this.cachedConfigs, watcherError)
+			})
+	}
+
+	public unwatch(listener: AgentConfigChangeListener): void {
+		this.listeners.delete(listener)
+	}
+
+	public async dispose(): Promise<void> {
+		if (!this.watcher) {
+			return
+		}
+
+		await this.watcher.close()
+		this.watcher = undefined
+	}
+
+	private async reloadAndNotify(): Promise<void> {
+		try {
+			await this.load()
+			this.notify(this.cachedConfigs)
+		} catch (error) {
+			const parseError = error instanceof Error ? error : new Error(String(error))
+			Logger.error("[AgentConfigLoader] Failed to reload agent configs", parseError)
+			this.notify(this.cachedConfigs, parseError)
+		}
+	}
+
+	private notify(configs: ReadonlyMap<string, AgentBaseConfig>, error?: Error): void {
+		for (const listener of this.listeners) {
+			listener(new Map(configs), error)
+		}
+	}
+
+	private rebuildDynamicToolMappings(): void {
+		const sortedConfigs = Array.from(this.cachedConfigs.entries()).sort((a, b) => a[0].localeCompare(b[0]))
+		const usedToolNames = new Set<string>()
+		const agentToolNames = new Map<string, string>()
+		const toolNameToAgentName = new Map<string, string>()
+
+		for (const [normalizedName, config] of sortedConfigs) {
+			const baseName = buildSubagentToolName(config.name)
+			let candidate = baseName
+			let suffix = 2
+			while (usedToolNames.has(candidate)) {
+				const suffixText = `_${suffix++}`
+				const maxBaseLength = Math.max(1, 64 - suffixText.length)
+				candidate = `${baseName.slice(0, maxBaseLength)}${suffixText}`
+			}
+
+			usedToolNames.add(candidate)
+			agentToolNames.set(normalizedName, candidate)
+			toolNameToAgentName.set(candidate, normalizedName)
+		}
+
+		this.cachedAgentToolNames = agentToolNames
+		this.cachedToolNameToAgentName = toolNameToAgentName
+		setDynamicToolUseNames(SUBAGENT_DYNAMIC_TOOL_NAMESPACE, Array.from(toolNameToAgentName.keys()))
+	}
+}
diff --git a/apps/vscode/src/core/task/tools/subagent/SubagentToolName.ts b/apps/vscode/src/core/task/tools/subagent/SubagentToolName.ts
new file mode 100644
index 0000000..0775982
--- /dev/null
+++ b/apps/vscode/src/core/task/tools/subagent/SubagentToolName.ts
@@ -0,0 +1,41 @@
+const SUBAGENT_TOOL_NAME_PREFIX = "use_subagent_"
+const SUBAGENT_TOOL_NAME_MAX_LENGTH = 64
+
+function sanitizeAgentName(name: string): string {
+	return name
+		.trim()
+		.toLowerCase()
+		.replace(/[^a-z0-9_]+/g, "_")
+		.replace(/_+/g, "_")
+		.replace(/^_+|_+$/g, "")
+}
+
+function hashString(value: string): string {
+	let hash = 2166136261
+	for (let i = 0; i < value.length; i++) {
+		hash ^= value.charCodeAt(i)
+		hash = Math.imul(hash, 16777619)
+	}
+	return (hash >>> 0).toString(36)
+}
+
+function trimToolNameToMax(value: string): string {
+	if (value.length <= SUBAGENT_TOOL_NAME_MAX_LENGTH) {
+		return value
+	}
+	return value.slice(0, SUBAGENT_TOOL_NAME_MAX_LENGTH)
+}
+
+export function buildSubagentToolName(agentName: string): string {
+	const sanitized = sanitizeAgentName(agentName) || "agent"
+	const hashSuffix = hashString(agentName).slice(0, 6)
+	const base = `${SUBAGENT_TOOL_NAME_PREFIX}${sanitized}`
+
+	if (base.length <= SUBAGENT_TOOL_NAME_MAX_LENGTH) {
+		return base
+	}
+
+	const maxBodyLength = SUBAGENT_TOOL_NAME_MAX_LENGTH - SUBAGENT_TOOL_NAME_PREFIX.length - hashSuffix.length - 1
+	const body = sanitized.slice(0, Math.max(1, maxBodyLength))
+	return trimToolNameToMax(`${SUBAGENT_TOOL_NAME_PREFIX}${body}_${hashSuffix}`)
+}
diff --git a/apps/vscode/src/core/webview/WebviewProvider.ts b/apps/vscode/src/core/webview/WebviewProvider.ts
new file mode 100644
index 0000000..a1c4522
--- /dev/null
+++ b/apps/vscode/src/core/webview/WebviewProvider.ts
@@ -0,0 +1,233 @@
+import path from "node:path"
+import { Controller } from "@core/controller/index"
+import axios from "axios"
+import { readFile } from "fs/promises"
+import { HostProvider } from "@/hosts/host-provider"
+import { ClineExtensionContext } from "@/shared/cline"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { getNonce } from "./getNonce"
+
+export abstract class WebviewProvider {
+	private static instance: WebviewProvider | null = null
+	controller: Controller
+
+	constructor(readonly context: ClineExtensionContext) {
+		WebviewProvider.instance = this
+
+		// Create controller with cache service
+		this.controller = new Controller(context)
+	}
+
+	async dispose() {
+		await this.controller.dispose()
+		WebviewProvider.instance = null
+	}
+
+	public static getInstance(): WebviewProvider {
+		if (!WebviewProvider.instance) {
+			throw new Error("WebviewProvider instance not initialized. Make sure to create a WebviewProvider instance first.")
+		}
+		return WebviewProvider.instance
+	}
+
+	public static getVisibleInstance(): WebviewProvider | undefined {
+		return WebviewProvider.instance?.isVisible() ? WebviewProvider.instance : undefined
+	}
+
+	public static async disposeAllInstances() {
+		if (WebviewProvider.instance) {
+			await WebviewProvider.instance.dispose()
+		}
+	}
+
+	/**
+	 * Converts a local filesystem path to a URL that can be used within the webview.
+	 *
+	 * @param path - The local path to convert
+	 * @returns A URL that can be used within the webview
+	 */
+	abstract getWebviewUrl(path: string): string
+
+	/**
+	 * Gets the Content Security Policy source for the webview.
+	 *
+	 * @returns The CSP source string to be used in the webview's Content-Security-Policy
+	 */
+	abstract getCspSource(): string
+
+	/**
+	 * Checks if the webview is currently visible to the user.
+	 *
+	 * @returns True if the webview is visible, false otherwise
+	 */
+	abstract isVisible(): boolean
+
+	/**
+	 * Defines and returns the HTML that should be rendered within the webview panel.
+	 *
+	 * @remarks This is also the place where references to the React webview build files
+	 * are created and inserted into the webview HTML.
+	 *
+	 * @returns A template string literal containing the HTML that should be
+	 * rendered within the webview panel
+	 */
+	public getHtmlContent(): string {
+		// Get the local path to main script run in the webview,
+		// then convert it to a url we can use in the webview.
+		// The JS file from the React build output
+		const scriptUrl = this.getExtensionUrl("webview-ui", "build", "assets", "index.js")
+
+		// The CSS file from the React build output. The webview's own index.css
+		// @imports @vscode/codicons, so the codicon @font-face + codicon.ttf are
+		// bundled into these build assets — no separate codicons <link> needed.
+		const stylesUrl = this.getExtensionUrl("webview-ui", "build", "assets", "index.css")
+
+		// Use a nonce to only allow a specific script to be run.
+		/*
+				content security policy of your webview to only allow scripts that have a specific nonce
+				create a content security policy meta tag so that only loading scripts with a nonce is allowed
+				As your extension grows you will likely want to add custom styles, fonts, and/or images to your webview. If you do, you will need to update the content security policy meta tag to explicitly allow for these resources. E.g.
+								<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource}; font-src ${webview.cspSource}; img-src ${webview.cspSource} https:; script-src 'nonce-${nonce}';">
+		- 'unsafe-inline' is required for styles due to vscode-webview-toolkit's dynamic style injection
+		- since we pass base64 images to the webview, we need to specify img-src ${webview.cspSource} data:;
+
+				in meta tag we add nonce attribute: A cryptographic nonce (only used once) to allow scripts. The server must generate a unique nonce value each time it transmits a policy. It is critical to provide a nonce that cannot be guessed as bypassing a resource's policy is otherwise trivial.
+				*/
+		const nonce = getNonce()
+
+		// Tip: Install the es6-string-html VS Code extension to enable code highlighting below
+		return /*html*/ `
+			<!DOCTYPE html>
+			<html lang="en">
+				<head>
+				<meta charset="utf-8">
+				<meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no">
+				<meta name="theme-color" content="#000000">
+				<link rel="stylesheet" type="text/css" href="${stylesUrl}">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none';
+					connect-src https://*.posthog.com https://*.cline.bot; 
+					font-src ${this.getCspSource()} data:; 
+					style-src ${this.getCspSource()} 'unsafe-inline'; 
+					img-src ${this.getCspSource()} https: data:; 
+					script-src 'nonce-${nonce}' 'unsafe-eval';">
+				<title>Cline</title>
+			</head>
+			<body>
+				<noscript>You need to enable JavaScript to run this app.</noscript>
+				<div id="root"></div>
+				<script type="module" nonce="${nonce}" src="${scriptUrl}"></script>
+			</body>
+		</html>
+		`
+	}
+
+	/**
+	 * Reads the Vite dev server port from the generated port file to avoid conflicts
+	 * Returns a Promise that resolves to the port number
+	 * If the file doesn't exist or can't be read, it resolves to the default port
+	 */
+	private getDevServerPort(): Promise<number> {
+		const DEFAULT_PORT = 25463
+
+		const portFilePath = path.join(__dirname, "..", "webview-ui", ".vite-port")
+
+		return readFile(portFilePath, "utf8")
+			.then((portFile) => {
+				const port = Number.parseInt(portFile.trim()) || DEFAULT_PORT
+				Logger.info(`[getDevServerPort] Using dev server port ${port} from .vite-port file`)
+
+				return port
+			})
+			.catch((_err) => {
+				Logger.warn(
+					`[getDevServerPort] Port file not found or couldn't be read at ${portFilePath}, using default port: ${DEFAULT_PORT}`,
+				)
+				return DEFAULT_PORT
+			})
+	}
+
+	/**
+	 * Connects to the local Vite dev server to allow HMR, with fallback to the bundled assets
+	 *
+	 * @param webview A reference to the extension webview
+	 * @returns A template string literal containing the HTML that should be
+	 * rendered within the webview panel
+	 */
+	protected async getHMRHtmlContent(): Promise<string> {
+		const localPort = await this.getDevServerPort()
+		const localServerUrl = `127.0.0.1:${localPort}`
+
+		// Check if local dev server is running.
+		try {
+			await axios.get(`http://${localServerUrl}`)
+		} catch (_error) {
+			// Only show the error message when in development mode.
+			if (process.env.IS_DEV) {
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message:
+						"Cline: Local webview dev server is not running, HMR will not work. Please run 'bun run dev:webview' before launching the extension to enable HMR. Using bundled assets.",
+				})
+			}
+
+			return this.getHtmlContent()
+		}
+
+		const nonce = getNonce()
+		const stylesUrl = this.getExtensionUrl("webview-ui", "build", "assets", "index.css")
+
+		const scriptEntrypoint = "src/main.tsx"
+		const scriptUrl = `http://${localServerUrl}/${scriptEntrypoint}`
+
+		const reactRefresh = /*html*/ `
+			<script nonce="${nonce}" type="module">
+				import RefreshRuntime from "http://${localServerUrl}/@react-refresh"
+				RefreshRuntime.injectIntoGlobalHook(window)
+				window.$RefreshReg$ = () => {}
+				window.$RefreshSig$ = () => (type) => type
+				window.__vite_plugin_react_preamble_installed__ = true
+			</script>
+		`
+
+		const csp = [
+			"default-src 'none'",
+			`font-src ${this.getCspSource()}`,
+			`style-src ${this.getCspSource()} 'unsafe-inline' https://* http://${localServerUrl} http://0.0.0.0:${localPort}`,
+			`img-src ${this.getCspSource()} https: data:`,
+			`script-src 'unsafe-eval' https://* http://${localServerUrl} http://0.0.0.0:${localPort} 'nonce-${nonce}'`,
+			`connect-src https://* ws://${localServerUrl} ws://0.0.0.0:${localPort} http://${localServerUrl} http://0.0.0.0:${localPort}`,
+		]
+
+		return /*html*/ `
+			<!DOCTYPE html>
+			<html lang="en">
+				<head>
+					<meta charset="utf-8">
+					<meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no">
+					<meta http-equiv="Content-Security-Policy" content="${csp.join("; ")}">
+					<link rel="stylesheet" type="text/css" href="${stylesUrl}">
+					<title>Cline</title>
+				</head>
+				<body>
+					<div id="root"></div>
+					${reactRefresh}
+					<script type="module" src="${scriptUrl}"></script>
+				</body>
+			</html>
+		`
+	}
+	/**
+	 * A helper function which will get the webview URL of a given file or resource in the extension directory.
+	 *
+	 * @remarks This URL can be used within a webview's HTML as a link to the
+	 * given file/resource.
+	 *
+	 * @param pathList An array of strings representing the path to a file/resource in the extension directory.
+	 * @returns A URL pointing to the file/resource
+	 */
+	private getExtensionUrl(...pathList: string[]): string {
+		const assetPath = path.resolve(HostProvider.get().extensionFsPath, ...pathList)
+		return this.getWebviewUrl(assetPath)
+	}
+}
diff --git a/apps/vscode/src/core/webview/getNonce.ts b/apps/vscode/src/core/webview/getNonce.ts
new file mode 100644
index 0000000..b92871b
--- /dev/null
+++ b/apps/vscode/src/core/webview/getNonce.ts
@@ -0,0 +1,16 @@
+/**
+ * A helper function that returns a unique alphanumeric identifier called a nonce.
+ *
+ * @remarks This function is primarily used to help enforce content security
+ * policies for resources/scripts being executed in a webview context.
+ *
+ * @returns A nonce
+ */
+export function getNonce() {
+	let text = ""
+	const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+	for (let i = 0; i < 32; i++) {
+		text += possible.charAt(Math.floor(Math.random() * possible.length))
+	}
+	return text
+}
diff --git a/apps/vscode/src/core/webview/index.ts b/apps/vscode/src/core/webview/index.ts
new file mode 100644
index 0000000..0adbcfb
--- /dev/null
+++ b/apps/vscode/src/core/webview/index.ts
@@ -0,0 +1 @@
+export { WebviewProvider } from "./WebviewProvider"
diff --git a/apps/vscode/src/core/workspace/MigrationReporter.ts b/apps/vscode/src/core/workspace/MigrationReporter.ts
new file mode 100644
index 0000000..ddbdef9
--- /dev/null
+++ b/apps/vscode/src/core/workspace/MigrationReporter.ts
@@ -0,0 +1,167 @@
+/**
+ * Handles formatting and presentation of workspace migration reports
+ *
+ * Separated from WorkspaceResolver to follow Single Responsibility Principle.
+ * This class focuses purely on report generation and formatting.
+ */
+
+/**
+ * Tracks path resolution usage for migration planning
+ */
+export interface UsageStats {
+	count: number
+	examples: string[]
+	lastUsed: Date
+}
+
+/**
+ * Configuration options for report generation
+ */
+interface ReportOptions {
+	includeExamples?: boolean
+	includeHighUsage?: boolean
+	highUsageThreshold?: number
+	sortByUsage?: boolean
+}
+
+/**
+ * Handles generation and formatting of migration reports
+ */
+export class MigrationReporter {
+	private readonly defaultOptions: Required<ReportOptions> = {
+		includeExamples: true,
+		includeHighUsage: true,
+		highUsageThreshold: 100,
+		sortByUsage: true,
+	}
+
+	/**
+	 * Generate a comprehensive migration report from usage statistics
+	 * @param usageMap - Map of component names to their usage statistics
+	 * @param traceEnabled - Whether tracing is currently enabled
+	 * @param options - Optional configuration for report generation
+	 * @returns Formatted migration report string
+	 */
+	generateReport(usageMap: Map<string, UsageStats>, traceEnabled: boolean, options: ReportOptions = {}): string {
+		const config = { ...this.defaultOptions, ...options }
+		const entries = this.prepareEntries(usageMap, config.sortByUsage)
+
+		let report = this.generateHeader(entries.length, traceEnabled)
+		report += this.generateComponentDetails(entries, config)
+		report += this.generateSummary(entries)
+
+		if (config.includeHighUsage) {
+			report += this.generateHighUsageSection(entries, config.highUsageThreshold)
+		}
+
+		return report
+	}
+
+	/**
+	 * Generate a simplified summary report
+	 * @param usageMap - Map of component names to their usage statistics
+	 * @returns Brief summary string
+	 */
+	generateSummary(entries: Array<[string, UsageStats]>): string {
+		const totalCalls = entries.reduce((sum, [_, stats]) => sum + stats.count, 0)
+
+		let summary = `\n=== Summary ===\n`
+		summary += `Total path resolution calls: ${totalCalls}\n`
+
+		return summary
+	}
+
+	/**
+	 * Prepare and optionally sort the usage entries
+	 */
+	private prepareEntries(usageMap: Map<string, UsageStats>, sortByUsage: boolean): Array<[string, UsageStats]> {
+		const entries = Array.from(usageMap.entries())
+
+		if (sortByUsage) {
+			return entries.sort((a, b) => b[1].count - a[1].count)
+		}
+
+		return entries
+	}
+
+	/**
+	 * Generate the report header section
+	 */
+	private generateHeader(componentCount: number, traceEnabled: boolean): string {
+		let header = "=== Multi-Root Migration Report ===\n"
+		header += `Total components using single-root: ${componentCount}\n`
+		header += `Trace enabled: ${traceEnabled}\n\n`
+		return header
+	}
+
+	/**
+	 * Generate detailed component usage information
+	 */
+	private generateComponentDetails(entries: Array<[string, UsageStats]>, config: Required<ReportOptions>): string {
+		let details = ""
+
+		entries.forEach(([context, stats]) => {
+			details += `${context}:\n`
+			details += `  Calls: ${stats.count}\n`
+			details += `  Last used: ${stats.lastUsed.toISOString()}\n`
+
+			if (config.includeExamples && stats.examples.length > 0) {
+				details += `  Example paths:\n`
+				stats.examples.forEach((ex) => {
+					details += `    - "${ex}"\n`
+				})
+			}
+			details += "\n"
+		})
+
+		return details
+	}
+
+	/**
+	 * Generate high-usage components section
+	 */
+	private generateHighUsageSection(entries: Array<[string, UsageStats]>, threshold: number): string {
+		const highUsageComponents = entries
+			.filter(([_, stats]) => stats.count > threshold)
+			.map(([context, stats]) => ({ context, count: stats.count }))
+
+		if (highUsageComponents.length === 0) {
+			return ""
+		}
+
+		let section = `\n=== High-Usage Components ===\n`
+		section += `(Operations with >${threshold} calls)\n`
+		highUsageComponents.forEach((h) => {
+			section += `  - ${h.context}: ${h.count} calls\n`
+		})
+
+		return section
+	}
+
+	/**
+	 * Generate a JSON representation of the usage data
+	 * @param usageMap - Map of component names to their usage statistics
+	 * @returns JSON string representation
+	 */
+	generateJsonReport(usageMap: Map<string, UsageStats>): string {
+		const data = Object.fromEntries(usageMap)
+		return JSON.stringify(data, null, 2)
+	}
+
+	/**
+	 * Generate a CSV representation of the usage data
+	 * @param usageMap - Map of component names to their usage statistics
+	 * @returns CSV string representation
+	 */
+	generateCsvReport(usageMap: Map<string, UsageStats>): string {
+		const entries = Array.from(usageMap.entries())
+		let csv = "Component,Calls,LastUsed,ExamplePaths\n"
+
+		entries.forEach(([context, stats]) => {
+			const examples = stats.examples.join("; ")
+			csv += `"${context}",${stats.count},"${stats.lastUsed.toISOString()}","${examples}"\n`
+		})
+
+		return csv
+	}
+}
diff --git a/apps/vscode/src/core/workspace/WorkspacePathAdapter.ts b/apps/vscode/src/core/workspace/WorkspacePathAdapter.ts
new file mode 100644
index 0000000..fb14f44
--- /dev/null
+++ b/apps/vscode/src/core/workspace/WorkspacePathAdapter.ts
@@ -0,0 +1,232 @@
+/**
+ * WorkspacePathAdapter - Utility for resolving paths in single or multi-workspace environments
+ *
+ * This adapter provides a unified interface for path resolution that works with both
+ * single-root (legacy) and multi-root workspace configurations. It encapsulates the
+ * logic for determining which workspace a path belongs to and resolving relative paths
+ * to their absolute equivalents.
+ */
+
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+import { resolveWorkspacePath } from "./WorkspaceResolver"
+import type { WorkspaceRootManager } from "./WorkspaceRootManager"
+
+export interface WorkspaceAdapterConfig {
+	cwd: string
+	isMultiRootEnabled?: boolean
+	workspaceManager?: WorkspaceRootManager
+}
+
+export class WorkspacePathAdapter {
+	constructor(private config: WorkspaceAdapterConfig) {}
+
+	/**
+	 * Resolves a path using either single-root or multi-root logic
+	 *
+	 * @param relativePath - The path to resolve (can be relative or absolute)
+	 * @param workspaceHint - Optional hint for which workspace to use (name or path)
+	 * @returns The resolved absolute path
+	 */
+	resolvePath(relativePath: string, workspaceHint?: string): string {
+		// Single-root mode (backward compatible)
+		if (!this.config.isMultiRootEnabled || !this.config.workspaceManager) {
+			return resolveWorkspacePath(this.config.cwd, relativePath, "WorkspacePathAdapter") as string
+		}
+
+		// Multi-root mode
+		const manager = this.config.workspaceManager as WorkspaceRootManager
+
+		// If absolute path, find which workspace it belongs to
+		if (path.isAbsolute(relativePath)) {
+			// Already absolute, just validate it belongs to a workspace
+			const root = manager.resolvePathToRoot(relativePath)
+			if (!root) {
+				// Path doesn't belong to any workspace, but return it anyway
+				Logger.warn(`[WorkspacePathAdapter] Absolute path ${relativePath} doesn't belong to any workspace`)
+			}
+			return relativePath
+		}
+
+		// If hint provided, try to use that workspace
+		if (workspaceHint) {
+			// Try by name first
+			let root = manager.getRootByName(workspaceHint)
+
+			// If not found by name, try to find a root that contains the hint path
+			if (!root) {
+				const roots = manager.getRoots()
+				root = roots.find((r) => r.path === workspaceHint || r.path.includes(workspaceHint))
+			}
+
+			if (root) {
+				// If no relative path specified, return the workspace root itself
+				if (!relativePath) {
+					return root.path
+				}
+				return path.join(root.path, relativePath)
+			}
+
+			Logger.warn(`[WorkspacePathAdapter] Workspace hint '${workspaceHint}' not found, using primary workspace`)
+		}
+
+		// Default to primary workspace
+		const primaryRoot = manager.getPrimaryRoot()
+		if (primaryRoot) {
+			// If no relative path specified, return the workspace root itself
+			if (!relativePath) {
+				return primaryRoot.path
+			}
+			return path.join(primaryRoot.path, relativePath)
+		}
+
+		// Fallback to cwd if no roots (shouldn't happen, but defensive)
+		Logger.warn(`[WorkspacePathAdapter] No workspace roots found, falling back to cwd`)
+		return resolveWorkspacePath(this.config.cwd, relativePath, "WorkspacePathAdapter-fallback") as string
+	}
+
+	/**
+	 * Gets all possible paths for a relative path across all workspaces
+	 * Useful for search operations or when checking if a file exists in any workspace
+	 *
+	 * @param relativePath - The relative path to resolve
+	 * @returns Array of absolute paths, one for each workspace
+	 */
+	getAllPossiblePaths(relativePath: string): string[] {
+		// Single-root mode
+		if (!this.config.isMultiRootEnabled || !this.config.workspaceManager) {
+			return [resolveWorkspacePath(this.config.cwd, relativePath, "WorkspacePathAdapter-getAllPaths") as string]
+		}
+
+		// Multi-root mode
+		const manager = this.config.workspaceManager as WorkspaceRootManager
+		return manager.getRoots().map((root) => path.join(root.path, relativePath))
+	}
+
+	/**
+	 * Determines which workspace a given absolute path belongs to
+	 *
+	 * @param absolutePath - The absolute path to check
+	 * @returns The workspace root that contains this path, or undefined if not in any workspace
+	 */
+	getWorkspaceForPath(absolutePath: string): { name: string; path: string } | undefined {
+		// Single-root mode
+		if (!this.config.isMultiRootEnabled || !this.config.workspaceManager) {
+			// In single-root, check if path is within cwd
+			if (absolutePath.startsWith(this.config.cwd)) {
+				return {
+					name: path.basename(this.config.cwd),
+					path: this.config.cwd,
+				}
+			}
+			return undefined
+		}
+
+		// Multi-root mode
+		const manager = this.config.workspaceManager as WorkspaceRootManager
+		const root = manager.resolvePathToRoot(absolutePath)
+		if (root) {
+			return {
+				name: root.name || path.basename(root.path),
+				path: root.path,
+			}
+		}
+
+		return undefined
+	}
+
+	/**
+	 * Gets the relative path from the appropriate workspace root
+	 *
+	 * @param absolutePath - The absolute path to make relative
+	 * @returns The relative path from its workspace root, or the original path if not in a workspace
+	 */
+	getRelativePath(absolutePath: string): string {
+		// Single-root mode
+		if (!this.config.isMultiRootEnabled || !this.config.workspaceManager) {
+			if (absolutePath.startsWith(this.config.cwd)) {
+				return path.relative(this.config.cwd, absolutePath)
+			}
+			return absolutePath
+		}
+
+		// Multi-root mode
+		const manager = this.config.workspaceManager as WorkspaceRootManager
+		const relativePath = manager.getRelativePathFromRoot(absolutePath)
+		return relativePath || absolutePath
+	}
+
+	/**
+	 * Checks if multi-root mode is enabled
+	 *
+	 * @returns True if multi-root mode is enabled and configured
+	 */
+	isMultiRootEnabled(): boolean {
+		return !!(this.config.isMultiRootEnabled && this.config.workspaceManager)
+	}
+
+	/**
+	 * Gets all workspace roots
+	 *
+	 * @returns Array of workspace root information
+	 */
+	getWorkspaceRoots(): Array<{ name: string; path: string }> {
+		// Single-root mode
+		if (!this.config.isMultiRootEnabled || !this.config.workspaceManager) {
+			return [
+				{
+					name: path.basename(this.config.cwd),
+					path: this.config.cwd,
+				},
+			]
+		}
+
+		// Multi-root mode
+		const manager = this.config.workspaceManager as WorkspaceRootManager
+		return manager.getRoots().map((root) => ({
+			name: root.name || path.basename(root.path),
+			path: root.path,
+		}))
+	}
+
+	/**
+	 * Gets the primary workspace root
+	 *
+	 * @returns The primary workspace root information
+	 */
+	getPrimaryWorkspace(): { name: string; path: string } {
+		// Single-root mode
+		if (!this.config.isMultiRootEnabled || !this.config.workspaceManager) {
+			return {
+				name: path.basename(this.config.cwd),
+				path: this.config.cwd,
+			}
+		}
+
+		// Multi-root mode
+		const manager = this.config.workspaceManager as WorkspaceRootManager
+		const primaryRoot = manager.getPrimaryRoot()
+		if (primaryRoot) {
+			return {
+				name: primaryRoot.name || path.basename(primaryRoot.path),
+				path: primaryRoot.path,
+			}
+		}
+
+		// Fallback (shouldn't happen)
+		return {
+			name: path.basename(this.config.cwd),
+			path: this.config.cwd,
+		}
+	}
+}
+
+/**
+ * Factory function to create a WorkspacePathAdapter
+ *
+ * @param config - The task configuration
+ * @returns A new WorkspacePathAdapter instance
+ */
+export function createWorkspacePathAdapter(config: WorkspaceAdapterConfig): WorkspacePathAdapter {
+	return new WorkspacePathAdapter(config)
+}
diff --git a/apps/vscode/src/core/workspace/WorkspaceResolver.ts b/apps/vscode/src/core/workspace/WorkspaceResolver.ts
new file mode 100644
index 0000000..d81404f
--- /dev/null
+++ b/apps/vscode/src/core/workspace/WorkspaceResolver.ts
@@ -0,0 +1,336 @@
+/**
+ * Workspace path resolution with migration tracing for multi-workspace support
+ *
+ * Phase 0: Acts as a tracer to identify all single-root path operations
+ * Phase 1+: Will handle multi-root path resolution
+ */
+
+import { WorkspaceRoot } from "@shared/multi-root/types"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+import { MigrationReporter, type UsageStats } from "./MigrationReporter"
+import { parseWorkspaceInlinePath } from "./utils/parseWorkspaceInlinePath"
+import { WorkspacePathAdapter } from "./WorkspacePathAdapter"
+
+/**
+ * Maximum number of example paths to store per component for debugging purposes.
+ * This limit prevents excessive memory usage while providing enough examples
+ * to understand usage patterns during migration analysis.
+ */
+const MAX_EXAMPLE_PATHS = 5
+
+export class WorkspaceResolver {
+	private usageMap = new Map<string, UsageStats>()
+	private traceEnabled = process.env.MULTI_ROOT_TRACE === "true" || process.env.NODE_ENV === "development"
+
+	/**
+	 * Track usage statistics for a given context and path
+	 * @param context - Component/handler name for tracking usage
+	 * @param examplePath - The path to track as an example
+	 */
+	private trackUsage(context: string, examplePath: string): void {
+		const stats = this.usageMap.get(context) || {
+			count: 0,
+			examples: [],
+			lastUsed: new Date(),
+		}
+
+		stats.count++
+		stats.lastUsed = new Date()
+
+		// Keep up to MAX_EXAMPLE_PATHS example paths for debugging
+		if (stats.examples.length < MAX_EXAMPLE_PATHS && !stats.examples.includes(examplePath)) {
+			stats.examples.push(examplePath)
+		}
+
+		this.usageMap.set(context, stats)
+	}
+
+	/**
+	 * Phase 0: Traces single-root path resolution for migration planning
+	 * Phase 1+: Will resolve path against multiple workspace roots
+	 *
+	 * @param cwdOrRoots - Current working directory (Phase 0) or array of workspace roots (Phase 1+)
+	 * @param relativePath - The relative path to resolve
+	 * @param context - Component/handler name for tracking usage
+	 * @returns Absolute path (Phase 0) or object with path and root (Phase 1+)
+	 */
+	resolveWorkspacePath(
+		cwdOrRoots: string | WorkspaceRoot[],
+		relativePath: string,
+		context?: string,
+	): string | { absolutePath: string; root: WorkspaceRoot } {
+		// Phase 0: Single-root tracer mode
+		if (typeof cwdOrRoots === "string") {
+			return this.resolveSingleRootPath(cwdOrRoots, relativePath, context)
+		}
+
+		// Phase 1+: Multi-root resolution
+		return this.resolveMultiRootPath(cwdOrRoots, relativePath)
+	}
+
+	/**
+	 * Resolves a path against a single workspace root (Phase 0)
+	 *
+	 * @param cwd - Current working directory
+	 * @param relativePath - The relative path to resolve
+	 * @param context - Component/handler name for tracking usage
+	 * @returns Absolute path
+	 */
+	private resolveSingleRootPath(cwd: string, relativePath: string, context?: string): string {
+		// Track usage for migration planning
+		if (context) {
+			this.trackUsage(context, relativePath)
+
+			if (this.traceEnabled) {
+				Logger.debug(`[MULTI-ROOT-TRACE] ${context}: resolving "${relativePath}" against "${cwd}"`)
+			}
+		}
+
+		return path.resolve(cwd, relativePath)
+	}
+
+	/**
+	 * Resolves a path against multiple workspace roots (Phase 1+)
+	 *
+	 * @param workspaceRoots - Array of workspace roots
+	 * @param relativePath - The relative path to resolve
+	 * @returns Object with absolute path and matching root
+	 */
+	private resolveMultiRootPath(
+		workspaceRoots: WorkspaceRoot[],
+		relativePath: string,
+	): { absolutePath: string; root: WorkspaceRoot } {
+		// Handle absolute paths
+		if (path.isAbsolute(relativePath)) {
+			return this.resolveAbsolutePath(workspaceRoots, relativePath)
+		}
+
+		// Handle relative paths
+		return this.resolveRelativePath(workspaceRoots, relativePath)
+	}
+
+	/**
+	 * Resolves an absolute path against workspace roots
+	 *
+	 * @param workspaceRoots - Array of workspace roots
+	 * @param absolutePath - The absolute path to resolve
+	 * @returns Object with absolute path and matching root
+	 */
+	private resolveAbsolutePath(
+		workspaceRoots: WorkspaceRoot[],
+		absolutePath: string,
+	): { absolutePath: string; root: WorkspaceRoot } {
+		const matchingRoot = workspaceRoots.find((root) => absolutePath.startsWith(root.path))
+		return {
+			absolutePath,
+			root: matchingRoot || workspaceRoots[0], // fallback to primary
+		}
+	}
+
+	/**
+	 * Resolves a relative path against workspace roots
+	 *
+	 * @param workspaceRoots - Array of workspace roots
+	 * @param relativePath - The relative path to resolve
+	 * @returns Object with absolute path and matching root
+	 */
+	private resolveRelativePath(
+		workspaceRoots: WorkspaceRoot[],
+		relativePath: string,
+	): { absolutePath: string; root: WorkspaceRoot } {
+		// Check which roots have this relative path
+		const candidateRoots: WorkspaceRoot[] = []
+		for (const root of workspaceRoots) {
+			// const testPath = path.join(root.path, relativePath)
+			// In Phase 1, check if path exists
+			// For now, just add all roots as candidates
+			candidateRoots.push(root)
+		}
+
+		return this.selectBestRoot(workspaceRoots, candidateRoots, relativePath)
+	}
+
+	/**
+	 * Selects the best root from candidate roots using disambiguation logic
+	 *
+	 * @param workspaceRoots - All available workspace roots
+	 * @param candidateRoots - Candidate roots that could contain the path
+	 * @param relativePath - The relative path being resolved
+	 * @returns Object with absolute path and selected root
+	 */
+	private selectBestRoot(
+		workspaceRoots: WorkspaceRoot[],
+		candidateRoots: WorkspaceRoot[],
+		relativePath: string,
+	): { absolutePath: string; root: WorkspaceRoot } {
+		// Disambiguation logic (simplified for Phase 0)
+		if (candidateRoots.length === 0) {
+			// Path doesn't exist in any root, use primary
+			return {
+				absolutePath: path.resolve(workspaceRoots[0].path, relativePath),
+				root: workspaceRoots[0],
+			}
+		}
+
+		if (candidateRoots.length === 1) {
+			// Unambiguous
+			return {
+				absolutePath: path.resolve(candidateRoots[0].path, relativePath),
+				root: candidateRoots[0],
+			}
+		}
+
+		// Multiple matches - need disambiguation
+		// Phase 2: This will trigger UI picker
+		// For now, use primary root if it's a candidate, otherwise first match
+		const primaryRoot = workspaceRoots[0]
+		const selectedRoot = candidateRoots.find((r) => r.path === primaryRoot.path) || candidateRoots[0]
+
+		return {
+			absolutePath: path.resolve(selectedRoot.path, relativePath),
+			root: selectedRoot,
+		}
+	}
+
+	/**
+	 * Get migration report showing all single-root usage patterns
+	 * Currently this function is mainly called by the vscode debugger
+	 */
+	getMigrationReport(): string {
+		const reporter = new MigrationReporter()
+		return reporter.generateReport(this.usageMap, this.traceEnabled)
+	}
+
+	/**
+	 * Get raw usage statistics for external analysis
+	 * @returns Map of component names to their usage statistics
+	 */
+	getUsageStats(): Map<string, UsageStats> {
+		return new Map(this.usageMap)
+	}
+
+	/**
+	 * Clear usage statistics (useful for testing)
+	 */
+	clearUsageStats(): void {
+		this.usageMap.clear()
+	}
+
+	/**
+	 * Export usage data as JSON for analysis
+	 */
+	exportUsageData(): Record<string, UsageStats> {
+		return Object.fromEntries(this.usageMap)
+	}
+
+	/**
+	 * Phase 0: Instance method for getting basename with tracking
+	 * Phase 1+: Will handle basename for multi-workspace paths
+	 *
+	 * @param filePath - The file path to get basename from
+	 * @param context - Component/handler name for tracking usage
+	 * @returns The basename of the path
+	 */
+	getBasename(filePath: string, context?: string): string {
+		// Track usage for migration planning
+		if (!context?.length) {
+			return path.basename(filePath)
+		}
+		this.trackUsage(context, filePath)
+
+		// Phase 0: Just wrap existing behavior
+		const result = path.basename(filePath)
+
+		if (this.traceEnabled) {
+			Logger.debug(`[MULTI-ROOT-TRACE] ${context}: getting basename for "${filePath}"`)
+		}
+
+		return result
+	}
+}
+
+// Export singleton instance
+export const workspaceResolver = new WorkspaceResolver()
+
+/**
+ * Result type for multi-root workspace path resolution
+ */
+export interface WorkspacePathResult {
+	absolutePath: string
+	displayPath: string
+	resolvedPath: string
+}
+
+/**
+ * Configuration for workspace path resolution
+ */
+export interface WorkspaceConfig {
+	cwd: string
+	isMultiRootEnabled?: boolean
+	workspaceManager?: any
+}
+
+/**
+ * Enhanced workspace path resolution that handles both single and multi-root workspaces
+ *
+ * @param cwdOrConfig - Either a string (for backward compatibility) or a config object
+ * @param relativePath - The relative path to resolve
+ * @param context - Component/handler name for tracking usage
+ * @returns Either a string (for backward compatibility) or a WorkspacePathResult object
+ */
+export function resolveWorkspacePath(
+	cwdOrConfig: string | WorkspaceConfig,
+	relativePath: string,
+	context?: string,
+): string | WorkspacePathResult {
+	// Backward compatibility: if first param is a string, return string
+	if (typeof cwdOrConfig === "string") {
+		return workspaceResolver.resolveWorkspacePath(cwdOrConfig, relativePath, context) as string
+	}
+
+	// New behavior: handle multi-root workspaces
+	const config = cwdOrConfig
+
+	// If multi-root is enabled and we have a workspace manager
+	if (config.isMultiRootEnabled && config.workspaceManager) {
+		// Parse workspace hint from the path (e.g., @frontend:src/index.ts)
+		const { workspaceHint, relPath: parsedPath } = parseWorkspaceInlinePath(relativePath)
+
+		// Create adapter for multi-workspace path resolution
+		const adapter = new WorkspacePathAdapter({
+			cwd: config.cwd,
+			isMultiRootEnabled: true,
+			workspaceManager: config.workspaceManager,
+		})
+
+		// Resolve to the correct workspace root
+		const absolutePath = adapter.resolvePath(parsedPath, workspaceHint)
+
+		// Build display path with workspace hint if present
+		const displayPath = workspaceHint ? `@${workspaceHint}:${parsedPath}` : parsedPath
+
+		return {
+			absolutePath,
+			displayPath,
+			resolvedPath: parsedPath,
+		}
+	}
+
+	// Fallback to single-workspace behavior
+	const absolutePath = workspaceResolver.resolveWorkspacePath(config.cwd, relativePath, context) as string
+
+	return {
+		absolutePath,
+		displayPath: relativePath,
+		resolvedPath: relativePath,
+	}
+}
+
+/**
+ * Phase 0: Convenience function for path.basename with tracking
+ * This is what we'll use to replace existing path.basename() calls
+ */
+export function getWorkspaceBasename(filePath: string, context?: string): string {
+	return workspaceResolver.getBasename(filePath, context)
+}
diff --git a/apps/vscode/src/core/workspace/WorkspaceRootManager.ts b/apps/vscode/src/core/workspace/WorkspaceRootManager.ts
new file mode 100644
index 0000000..221d26f
--- /dev/null
+++ b/apps/vscode/src/core/workspace/WorkspaceRootManager.ts
@@ -0,0 +1,249 @@
+/**
+ * WorkspaceRootManager - Central manager for multi-workspace operations
+ * This class handles workspace root resolution, path mapping, and workspace context
+ */
+
+import { VcsType, WorkspaceRoot } from "@shared/multi-root/types"
+import { execa } from "execa"
+import * as path from "path"
+import { getGitRemoteUrls, getLatestGitCommitHash } from "../../utils/git"
+
+export interface WorkspaceContext {
+	workspaceRoots: WorkspaceRoot[]
+	primaryRoot: WorkspaceRoot
+	currentRoot?: WorkspaceRoot
+}
+
+export class WorkspaceRootManager {
+	private roots: WorkspaceRoot[] = []
+	private primaryIndex = 0
+
+	constructor(roots: WorkspaceRoot[] = [], primaryIndex = 0) {
+		this.roots = roots
+		this.primaryIndex = Math.min(primaryIndex, Math.max(0, roots.length - 1))
+	}
+
+	/**
+	 * Initialize from a single cwd for backward compatibility
+	 */
+	static async fromLegacyCwd(cwd: string): Promise<WorkspaceRootManager> {
+		const vcs = await WorkspaceRootManager.detectVcs(cwd)
+		const gitHash = vcs === VcsType.Git ? await getLatestGitCommitHash(cwd) : null
+		const commitHash = gitHash === null ? undefined : gitHash
+
+		const root: WorkspaceRoot = {
+			path: cwd,
+			name: path.basename(cwd),
+			vcs,
+			commitHash,
+		}
+
+		return new WorkspaceRootManager([root], 0)
+	}
+
+	/**
+	 * Detect version control system for a directory
+	 */
+	private static async detectVcs(dirPath: string): Promise<VcsType> {
+		try {
+			// Check for Git
+			await execa("git", ["rev-parse", "--git-dir"], { cwd: dirPath })
+			return VcsType.Git
+		} catch {
+			// Not a git repo
+		}
+
+		try {
+			// Check for Mercurial
+			await execa("hg", ["root"], { cwd: dirPath })
+			return VcsType.Mercurial
+		} catch {
+			// Not a mercurial repo
+		}
+
+		return VcsType.None
+	}
+
+	/**
+	 * Get all workspace roots
+	 */
+	getRoots(): WorkspaceRoot[] {
+		return [...this.roots]
+	}
+
+	/**
+	 * Get the primary workspace root
+	 */
+	getPrimaryRoot(): WorkspaceRoot | undefined {
+		return this.roots[this.primaryIndex]
+	}
+
+	/**
+	 * Get the primary workspace root index
+	 */
+	getPrimaryIndex(): number {
+		return this.primaryIndex
+	}
+
+	/**
+	 * Set the primary workspace root by index
+	 */
+	setPrimaryIndex(index: number): void {
+		if (index >= 0 && index < this.roots.length) {
+			this.primaryIndex = index
+		}
+	}
+
+	/**
+	 * Find the workspace root that contains the given absolute path
+	 */
+	resolvePathToRoot(absolutePath: string): WorkspaceRoot | undefined {
+		// Sort roots by path length (longest first) to handle nested workspaces
+		const sortedRoots = [...this.roots].sort((a, b) => b.path.length - a.path.length)
+
+		for (const root of sortedRoots) {
+			if (absolutePath.startsWith(root.path)) {
+				return root
+			}
+		}
+
+		return undefined
+	}
+
+	/**
+	 * Find workspace root by name
+	 */
+	getRootByName(name: string): WorkspaceRoot | undefined {
+		return this.roots.find((r) => r.name === name)
+	}
+
+	/**
+	 * Get workspace root by index
+	 */
+	getRootByIndex(index: number): WorkspaceRoot | undefined {
+		return this.roots[index]
+	}
+
+	/**
+	 * Check if a path is within any workspace root
+	 */
+	isPathInWorkspace(absolutePath: string): boolean {
+		return this.resolvePathToRoot(absolutePath) !== undefined
+	}
+
+	/**
+	 * Get relative path from workspace root
+	 */
+	getRelativePathFromRoot(absolutePath: string, root?: WorkspaceRoot): string | undefined {
+		const targetRoot = root || this.resolvePathToRoot(absolutePath)
+		if (!targetRoot) {
+			return undefined
+		}
+
+		return path.relative(targetRoot.path, absolutePath)
+	}
+
+	/**
+	 * Create workspace context for tool execution
+	 */
+	createContext(currentRoot?: WorkspaceRoot): WorkspaceContext {
+		return {
+			workspaceRoots: this.getRoots(),
+			primaryRoot: this.getPrimaryRoot()!,
+			currentRoot: currentRoot || this.getPrimaryRoot(),
+		}
+	}
+
+	/**
+	 * Serialize for storage
+	 */
+	toJSON(): { roots: WorkspaceRoot[]; primaryIndex: number } {
+		return {
+			roots: this.roots,
+			primaryIndex: this.primaryIndex,
+		}
+	}
+
+	/**
+	 * Deserialize from storage
+	 */
+	static fromJSON(data: { roots: WorkspaceRoot[]; primaryIndex: number }): WorkspaceRootManager {
+		return new WorkspaceRootManager(data.roots, data.primaryIndex)
+	}
+
+	/**
+	 * Get a summary string for display
+	 */
+	getSummary(): string {
+		if (this.roots.length === 0) {
+			return "No workspace roots configured"
+		}
+
+		if (this.roots.length === 1) {
+			return `Single workspace: ${this.roots[0].name || this.roots[0].path}`
+		}
+
+		const primary = this.getPrimaryRoot()
+		return `Multi-workspace (${this.roots.length} roots)\nPrimary: ${primary?.name || primary?.path}\nAdditional: ${this.roots
+			.filter((_, i) => i !== this.primaryIndex)
+			.map((r) => r.name || path.basename(r.path))
+			.join(", ")}`
+	}
+
+	/**
+	 * Check if this is a single-root workspace (for backward compatibility)
+	 */
+	isSingleRoot(): boolean {
+		return this.roots.length === 1
+	}
+
+	/**
+	 * Get the single root if this is a single-root workspace
+	 * Throws if multiple roots exist
+	 */
+	getSingleRoot(): WorkspaceRoot {
+		if (this.roots.length !== 1) {
+			throw new Error(`Expected single root, but found ${this.roots.length} roots`)
+		}
+		return this.roots[0]
+	}
+
+	/**
+	 * Update commit hashes for all Git repositories
+	 */
+	async updateCommitHashes(): Promise<void> {
+		for (const root of this.roots) {
+			if (root.vcs === VcsType.Git) {
+				const gitHash = await getLatestGitCommitHash(root.path)
+				root.commitHash = gitHash === null ? undefined : gitHash
+			}
+		}
+	}
+
+	/**
+	 * Build workspaces JSON structure for environment details
+	 */
+	async buildWorkspacesJson(): Promise<string | null> {
+		const workspaces: Record<string, { hint: string; associatedRemoteUrls?: string[]; latestGitCommitHash?: string }> = {}
+
+		// Process all workspace roots
+		for (const root of this.roots) {
+			const hint = root.name || path.basename(root.path)
+			const gitRemotes = await getGitRemoteUrls(root.path)
+			const gitCommitHash = await getLatestGitCommitHash(root.path)
+
+			workspaces[root.path] = {
+				hint,
+				...(gitRemotes.length > 0 && { associatedRemoteUrls: gitRemotes }),
+				...(gitCommitHash && { latestGitCommitHash: gitCommitHash }),
+			}
+		}
+
+		// Only return JSON if there's content to feed the env details
+		if (Object.keys(workspaces).length === 0) {
+			return null
+		}
+
+		return JSON.stringify({ workspaces }, null, 2)
+	}
+}
diff --git a/apps/vscode/src/core/workspace/__tests__/WorkspacePathAdapter.test.ts b/apps/vscode/src/core/workspace/__tests__/WorkspacePathAdapter.test.ts
new file mode 100644
index 0000000..2951195
--- /dev/null
+++ b/apps/vscode/src/core/workspace/__tests__/WorkspacePathAdapter.test.ts
@@ -0,0 +1,216 @@
+/**
+ * Unit tests for WorkspacePathAdapter
+ * Tests the core functionality of path resolution in single and multi-root workspaces
+ */
+
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import { VcsType, WorkspaceRoot } from "@shared/multi-root/types"
+import { expect } from "chai"
+import * as path from "path"
+import * as sinon from "sinon"
+import { createWorkspacePathAdapter, WorkspacePathAdapter } from "../WorkspacePathAdapter"
+import { WorkspaceRootManager } from "../WorkspaceRootManager"
+import "@utils/path"
+import { Logger } from "@/shared/services/Logger"
+
+describe("WorkspacePathAdapter", () => {
+	let consoleWarnStub: sinon.SinonStub
+
+	beforeEach(() => {
+		consoleWarnStub = sinon.stub(Logger, "warn")
+	})
+
+	afterEach(() => {
+		consoleWarnStub.restore()
+	})
+
+	describe("Single-Root Mode", () => {
+		const testCwd = "/test/workspace"
+		let adapter: WorkspacePathAdapter
+
+		beforeEach(() => {
+			adapter = new WorkspacePathAdapter({
+				cwd: testCwd,
+				isMultiRootEnabled: false,
+			})
+		})
+
+		it("should resolve relative paths", () => {
+			const result = adapter.resolvePath("src/file.ts")
+			expect(result).to.equal(path.resolve(testCwd, "src/file.ts"))
+		})
+
+		it("should handle absolute paths", () => {
+			const absolutePath = "/absolute/path/file.ts"
+			const result = adapter.resolvePath(absolutePath)
+			expect(result).to.equal(path.resolve(testCwd, absolutePath))
+		})
+
+		it("should get workspace for path within cwd", () => {
+			const workspace = adapter.getWorkspaceForPath("/test/workspace/src/file.ts")
+			expect(workspace).to.deep.equal({
+				name: "workspace",
+				path: testCwd,
+			})
+		})
+
+		it("should return undefined for path outside cwd", () => {
+			const workspace = adapter.getWorkspaceForPath("/other/path/file.ts")
+			expect(workspace).to.be.undefined
+		})
+
+		it("should get relative path from cwd", () => {
+			const result = adapter.getRelativePath("/test/workspace/src/file.ts")
+			expect(result.toPosix()).to.equal("src/file.ts")
+		})
+
+		it("should return single workspace root", () => {
+			const roots = adapter.getWorkspaceRoots()
+			expect(roots).to.have.length(1)
+			expect(roots[0]).to.deep.equal({
+				name: "workspace",
+				path: testCwd,
+			})
+		})
+
+		it("should report multi-root as disabled", () => {
+			expect(adapter.isMultiRootEnabled()).to.be.false
+		})
+	})
+
+	describe("Multi-Root Mode", () => {
+		const roots: WorkspaceRoot[] = [
+			{ path: "/workspace/frontend", name: "frontend", vcs: VcsType.Git },
+			{ path: "/workspace/backend", name: "backend", vcs: VcsType.Git },
+			{ path: "/workspace/shared", name: "shared", vcs: VcsType.None },
+		]
+		let adapter: WorkspacePathAdapter
+		let mockManager: WorkspaceRootManager
+
+		beforeEach(() => {
+			mockManager = new WorkspaceRootManager(roots, 0)
+			adapter = new WorkspacePathAdapter({
+				cwd: "/workspace/frontend",
+				isMultiRootEnabled: true,
+				workspaceManager: mockManager,
+			})
+		})
+
+		it("should resolve path with workspace hint by name", () => {
+			const result = adapter.resolvePath("src/index.ts", "backend")
+			expect(result.toPosix()).to.equal("/workspace/backend/src/index.ts")
+		})
+
+		it("should resolve path with workspace hint by path", () => {
+			const result = adapter.resolvePath("src/index.ts", "/workspace/shared")
+			expect(result.toPosix()).to.equal("/workspace/shared/src/index.ts")
+		})
+
+		it("should default to primary workspace without hint", () => {
+			const result = adapter.resolvePath("src/index.ts")
+			expect(result.toPosix()).to.equal("/workspace/frontend/src/index.ts")
+		})
+
+		it("should handle absolute paths belonging to a workspace", () => {
+			const absolutePath = "/workspace/backend/src/api.ts"
+			const result = adapter.resolvePath(absolutePath)
+			expect(result).to.equal(absolutePath)
+		})
+
+		it("should warn for absolute paths outside workspaces", () => {
+			const absolutePath = "/other/path/file.ts"
+			const result = adapter.resolvePath(absolutePath)
+
+			expect(result).to.equal(absolutePath)
+			expect(consoleWarnStub.calledOnce).to.be.true
+			expect(consoleWarnStub.firstCall.args[0]).to.include("doesn't belong to any workspace")
+		})
+
+		it("should get all possible paths across workspaces", () => {
+			const paths = adapter.getAllPossiblePaths("src/config.ts")
+			expect(paths).to.have.length(3)
+			// Normalize each path for cross-platform comparison
+			const normalizedPaths = paths.map((p) => p.toPosix())
+			expect(normalizedPaths).to.deep.equal([
+				"/workspace/frontend/src/config.ts",
+				"/workspace/backend/src/config.ts",
+				"/workspace/shared/src/config.ts",
+			])
+		})
+
+		it("should identify workspace for path", () => {
+			const workspace = adapter.getWorkspaceForPath("/workspace/backend/src/api.ts")
+			expect(workspace).to.deep.equal({
+				name: "backend",
+				path: "/workspace/backend",
+			})
+		})
+
+		it("should get relative path from appropriate workspace", () => {
+			const result = adapter.getRelativePath("/workspace/backend/src/api.ts")
+			expect(result.toPosix()).to.equal("src/api.ts")
+		})
+
+		it("should return all workspace roots", () => {
+			const workspaceRoots = adapter.getWorkspaceRoots()
+			expect(workspaceRoots).to.have.length(3)
+			expect(workspaceRoots[0].name).to.equal("frontend")
+			expect(workspaceRoots[1].name).to.equal("backend")
+			expect(workspaceRoots[2].name).to.equal("shared")
+		})
+
+		it("should get primary workspace", () => {
+			const primary = adapter.getPrimaryWorkspace()
+			expect(primary).to.deep.equal({
+				name: "frontend",
+				path: "/workspace/frontend",
+			})
+		})
+
+		it("should warn for invalid workspace hint", () => {
+			const result = adapter.resolvePath("src/file.ts", "nonexistent")
+
+			expect(result.toPosix()).to.equal("/workspace/frontend/src/file.ts") // Falls back to primary
+			expect(consoleWarnStub.calledOnce).to.be.true
+			expect(consoleWarnStub.firstCall.args[0]).to.include("not found")
+		})
+	})
+
+	describe("Edge Cases", () => {
+		it("should handle empty workspace manager gracefully", () => {
+			const mockManager = new WorkspaceRootManager([], 0)
+			const adapter = new WorkspacePathAdapter({
+				cwd: "/fallback",
+				isMultiRootEnabled: true,
+				workspaceManager: mockManager,
+			})
+
+			const result = adapter.resolvePath("src/file.ts")
+			expect(result.toPosix()).to.include("/fallback/src/file.ts")
+			expect(consoleWarnStub.called).to.be.true
+		})
+
+		it("should handle paths with special characters", () => {
+			const adapter = new WorkspacePathAdapter({
+				cwd: "/test/workspace",
+				isMultiRootEnabled: false,
+			})
+
+			const specialPath = "src/file with spaces & symbols!.ts"
+			const result = adapter.resolvePath(specialPath)
+			expect(result).to.equal(path.resolve("/test/workspace", specialPath))
+		})
+	})
+
+	describe("Factory Function", () => {
+		it("should create adapter using factory function", () => {
+			const adapter = createWorkspacePathAdapter({
+				cwd: "/test/workspace",
+				isMultiRootEnabled: false,
+			})
+
+			expect(adapter).to.be.instanceOf(WorkspacePathAdapter)
+			expect(adapter.isMultiRootEnabled()).to.be.false
+		})
+	})
+})
diff --git a/apps/vscode/src/core/workspace/__tests__/WorkspaceResolver.test.ts b/apps/vscode/src/core/workspace/__tests__/WorkspaceResolver.test.ts
new file mode 100644
index 0000000..dae7c43
--- /dev/null
+++ b/apps/vscode/src/core/workspace/__tests__/WorkspaceResolver.test.ts
@@ -0,0 +1,206 @@
+/**
+ * Unit tests for WorkspaceResolver
+ * These tests ensure behavior preservation during refactoring
+ */
+
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import { VcsType, WorkspaceRoot } from "@shared/multi-root/types"
+import { expect } from "chai"
+import * as path from "path"
+import * as sinon from "sinon"
+import { Logger } from "@/shared/services/Logger"
+import { WorkspaceResolver } from "../WorkspaceResolver"
+
+describe("WorkspaceResolver", () => {
+	let resolver: WorkspaceResolver
+	let loggerStub: sinon.SinonStub
+	let originalEnv: string | undefined
+
+	beforeEach(() => {
+		resolver = new WorkspaceResolver()
+		loggerStub = sinon.stub(Logger, "debug")
+		originalEnv = process.env.MULTI_ROOT_TRACE
+	})
+
+	afterEach(() => {
+		loggerStub.restore()
+		process.env.MULTI_ROOT_TRACE = originalEnv
+		resolver.clearUsageStats()
+	})
+
+	describe("resolveWorkspacePath - Single Root Mode", () => {
+		const testCwd = "/test/workspace"
+		const testRelativePath = "src/file.ts"
+		const expectedAbsolutePath = path.resolve(testCwd, testRelativePath)
+
+		it("should resolve path without context", () => {
+			const result = resolver.resolveWorkspacePath(testCwd, testRelativePath)
+			expect(result).to.equal(expectedAbsolutePath)
+		})
+
+		it("should resolve path with context and track usage", () => {
+			const context = "TestComponent"
+			const result = resolver.resolveWorkspacePath(testCwd, testRelativePath, context)
+
+			expect(result).to.equal(expectedAbsolutePath)
+
+			// Verify usage tracking
+			const usageStats = resolver.getUsageStats()
+			expect(usageStats.has(context)).to.be.true
+
+			const stats = usageStats.get(context)!
+			expect(stats.count).to.equal(1)
+			expect(stats.examples).to.include(testRelativePath)
+		})
+
+		it("should track multiple calls to same context", () => {
+			const context = "TestComponent"
+
+			resolver.resolveWorkspacePath(testCwd, "file1.ts", context)
+			resolver.resolveWorkspacePath(testCwd, "file2.ts", context)
+			resolver.resolveWorkspacePath(testCwd, "file1.ts", context) // duplicate
+
+			const usageStats = resolver.getUsageStats()
+			const stats = usageStats.get(context)!
+
+			expect(stats.count).to.equal(3)
+			expect(stats.examples).to.have.length(2) // no duplicates in examples
+			expect(stats.examples).to.include("file1.ts")
+			expect(stats.examples).to.include("file2.ts")
+		})
+
+		it("should not log when tracing is disabled", () => {
+			process.env.MULTI_ROOT_TRACE = "false"
+			process.env.NODE_ENV = "production"
+
+			resolver.resolveWorkspacePath(testCwd, testRelativePath, "TestComponent")
+
+			expect(loggerStub.called).to.be.false
+		})
+
+		it("should handle absolute paths correctly", () => {
+			const absolutePath = "/absolute/path/file.ts"
+			const result = resolver.resolveWorkspacePath(testCwd, absolutePath)
+
+			expect(result).to.equal(path.resolve(testCwd, absolutePath))
+		})
+
+		it("should handle empty relative path", () => {
+			const result = resolver.resolveWorkspacePath(testCwd, "")
+			expect(result).to.equal(path.resolve(testCwd))
+		})
+
+		it("should handle relative paths with .. navigation", () => {
+			const relativePath = "../other/file.ts"
+			const result = resolver.resolveWorkspacePath(testCwd, relativePath)
+			expect(result).to.equal(path.resolve(testCwd, relativePath))
+		})
+	})
+
+	describe("resolveWorkspacePath - Multi Root Mode", () => {
+		const workspaceRoots: WorkspaceRoot[] = [
+			{ path: "/workspace/primary", name: "primary", vcs: VcsType.Git },
+			{ path: "/workspace/secondary", name: "secondary", vcs: VcsType.Git },
+		]
+
+		it("should handle absolute paths in multi-root mode", () => {
+			const absolutePath = "/workspace/primary/src/file.ts"
+			const result = resolver.resolveWorkspacePath(workspaceRoots, absolutePath)
+
+			expect(result).to.be.an("object")
+			expect((result as any).absolutePath).to.equal(absolutePath)
+			expect((result as any).root).to.equal(workspaceRoots[0])
+		})
+
+		it("should fallback to primary root for unmatched absolute paths", () => {
+			const absolutePath = "/other/path/file.ts"
+			const result = resolver.resolveWorkspacePath(workspaceRoots, absolutePath)
+
+			expect(result).to.be.an("object")
+			expect((result as any).absolutePath).to.equal(absolutePath)
+			expect((result as any).root).to.equal(workspaceRoots[0])
+		})
+
+		it("should resolve relative paths against primary root", () => {
+			const relativePath = "src/file.ts"
+			const result = resolver.resolveWorkspacePath(workspaceRoots, relativePath)
+
+			expect(result).to.be.an("object")
+			expect((result as any).absolutePath).to.equal(path.resolve(workspaceRoots[0].path, relativePath))
+			expect((result as any).root).to.equal(workspaceRoots[0])
+		})
+
+		it("should handle empty workspace roots array", () => {
+			// This should throw an error or handle gracefully
+			expect(() => {
+				resolver.resolveWorkspacePath([], "src/file.ts")
+			}).to.throw()
+		})
+	})
+
+	describe("getBasename", () => {
+		const testFilePath = "/path/to/file.ts"
+		const expectedBasename = "file.ts"
+
+		it("should return basename without context", () => {
+			const result = resolver.getBasename(testFilePath)
+			expect(result).to.equal(expectedBasename)
+		})
+
+		it("should return basename with context and track usage", () => {
+			const context = "TestComponent"
+			const result = resolver.getBasename(testFilePath, context)
+
+			expect(result).to.equal(expectedBasename)
+
+			// Verify usage tracking
+			const usageStats = resolver.getUsageStats()
+			expect(usageStats.has(context)).to.be.true
+
+			const stats = usageStats.get(context)!
+			expect(stats.count).to.equal(1)
+			expect(stats.examples).to.include(testFilePath)
+		})
+	})
+
+	describe("Usage Statistics Management", () => {
+		it("should track usage statistics correctly", () => {
+			resolver.resolveWorkspacePath("/test", "file1.ts", "Component1")
+			resolver.resolveWorkspacePath("/test", "file2.ts", "Component1")
+			resolver.getBasename("/test/file3.ts", "Component2")
+
+			const usageStats = resolver.getUsageStats()
+			expect(usageStats.size).to.equal(2)
+
+			const component1Stats = usageStats.get("Component1")!
+			expect(component1Stats.count).to.equal(2)
+			expect(component1Stats.examples).to.have.length(2)
+
+			const component2Stats = usageStats.get("Component2")!
+			expect(component2Stats.count).to.equal(1)
+			expect(component2Stats.examples).to.have.length(1)
+		})
+	})
+
+	describe("Edge Cases", () => {
+		it("should handle null/undefined inputs gracefully", () => {
+			// These should not throw
+			expect(() => resolver.resolveWorkspacePath("/test", "")).to.not.throw()
+			expect(() => resolver.getBasename("")).to.not.throw()
+		})
+
+		it("should handle special characters in paths", () => {
+			const specialPath = "src/file with spaces & symbols!.ts"
+			const result = resolver.resolveWorkspacePath("/test", specialPath, "Component")
+
+			expect(result).to.equal(path.resolve("/test", specialPath))
+		})
+
+		it("should handle very long paths", () => {
+			const longPath = "a/".repeat(100) + "file.ts"
+			const result = resolver.resolveWorkspacePath("/test", longPath, "Component")
+
+			expect(result).to.equal(path.resolve("/test", longPath))
+		})
+	})
+})
diff --git a/apps/vscode/src/core/workspace/__tests__/parseWorkspaceInlinePath.test.ts b/apps/vscode/src/core/workspace/__tests__/parseWorkspaceInlinePath.test.ts
new file mode 100644
index 0000000..9850960
--- /dev/null
+++ b/apps/vscode/src/core/workspace/__tests__/parseWorkspaceInlinePath.test.ts
@@ -0,0 +1,162 @@
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+import {
+	addWorkspaceHint,
+	hasWorkspaceHint,
+	parseMultipleWorkspacePaths,
+	parseWorkspaceInlinePath,
+	removeWorkspaceHint,
+} from "../../../core/workspace/utils/parseWorkspaceInlinePath"
+
+describe("parseWorkspaceInlinePath", () => {
+	describe("basic parsing", () => {
+		it("should parse path with workspace hint", () => {
+			const result = parseWorkspaceInlinePath("@frontend:src/index.ts")
+			expect(result).to.deep.equal({
+				workspaceHint: "frontend",
+				relPath: "src/index.ts",
+			})
+		})
+
+		it("should parse path without workspace hint", () => {
+			const result = parseWorkspaceInlinePath("src/index.ts")
+			expect(result).to.deep.equal({
+				workspaceHint: undefined,
+				relPath: "src/index.ts",
+			})
+		})
+
+		it("should handle workspace names with hyphens", () => {
+			const result = parseWorkspaceInlinePath("@my-frontend-app:package.json")
+			expect(result).to.deep.equal({
+				workspaceHint: "my-frontend-app",
+				relPath: "package.json",
+			})
+		})
+
+		it("should handle workspace names with underscores", () => {
+			const result = parseWorkspaceInlinePath("@backend_service:src/main.py")
+			expect(result).to.deep.equal({
+				workspaceHint: "backend_service",
+				relPath: "src/main.py",
+			})
+		})
+
+		it("should handle paths with multiple colons", () => {
+			const result = parseWorkspaceInlinePath("@backend:src/config:prod.json")
+			expect(result).to.deep.equal({
+				workspaceHint: "backend",
+				relPath: "src/config:prod.json",
+			})
+		})
+
+		it("should treat bare workspace hint as root path", () => {
+			const result = parseWorkspaceInlinePath("@backend:")
+			expect(result).to.deep.equal({
+				workspaceHint: "backend",
+				relPath: "",
+			})
+		})
+
+		it("should trim whitespace", () => {
+			const result = parseWorkspaceInlinePath("@ frontend : src/index.ts ")
+			expect(result).to.deep.equal({
+				workspaceHint: "frontend",
+				relPath: "src/index.ts",
+			})
+		})
+	})
+
+	describe("edge cases", () => {
+		it("should handle empty string", () => {
+			const result = parseWorkspaceInlinePath("")
+			expect(result).to.deep.equal({
+				workspaceHint: undefined,
+				relPath: "",
+			})
+		})
+
+		it("should handle null/undefined", () => {
+			const result = parseWorkspaceInlinePath(null as any)
+			expect(result).to.deep.equal({
+				workspaceHint: undefined,
+				relPath: "",
+			})
+		})
+
+		it("should handle @ without colon", () => {
+			const result = parseWorkspaceInlinePath("@frontend")
+			expect(result).to.deep.equal({
+				workspaceHint: undefined,
+				relPath: "@frontend",
+			})
+		})
+
+		it("should handle colon without @", () => {
+			const result = parseWorkspaceInlinePath("frontend:src/index.ts")
+			expect(result).to.deep.equal({
+				workspaceHint: undefined,
+				relPath: "frontend:src/index.ts",
+			})
+		})
+
+		it("should handle @ at the end", () => {
+			const result = parseWorkspaceInlinePath("src/index.ts@")
+			expect(result).to.deep.equal({
+				workspaceHint: undefined,
+				relPath: "src/index.ts@",
+			})
+		})
+	})
+
+	describe("hasWorkspaceHint", () => {
+		it("should return true for paths with hints", () => {
+			expect(hasWorkspaceHint("@frontend:src/index.ts")).to.be.true
+			expect(hasWorkspaceHint("@backend:package.json")).to.be.true
+		})
+
+		it("should return false for paths without hints", () => {
+			expect(hasWorkspaceHint("src/index.ts")).to.be.false
+			expect(hasWorkspaceHint("@frontend")).to.be.false
+			expect(hasWorkspaceHint("frontend:src")).to.be.false
+		})
+	})
+
+	describe("addWorkspaceHint", () => {
+		it("should add hint to path without hint", () => {
+			const result = addWorkspaceHint("frontend", "src/index.ts")
+			expect(result).to.equal("@frontend:src/index.ts")
+		})
+
+		it("should replace existing hint", () => {
+			const result = addWorkspaceHint("backend", "@frontend:src/index.ts")
+			expect(result).to.equal("@backend:src/index.ts")
+		})
+	})
+
+	describe("removeWorkspaceHint", () => {
+		it("should remove hint from path with hint", () => {
+			const result = removeWorkspaceHint("@frontend:src/index.ts")
+			expect(result).to.equal("src/index.ts")
+		})
+
+		it("should return original path if no hint", () => {
+			const result = removeWorkspaceHint("src/index.ts")
+			expect(result).to.equal("src/index.ts")
+		})
+	})
+
+	describe("parseMultipleWorkspacePaths", () => {
+		it("should parse multiple paths", () => {
+			const paths = ["@frontend:src/index.ts", "package.json", "@backend:src/server.js"]
+
+			const results = parseMultipleWorkspacePaths(paths)
+
+			expect(results).to.deep.equal([
+				{ workspaceHint: "frontend", relPath: "src/index.ts" },
+				{ workspaceHint: undefined, relPath: "package.json" },
+				{ workspaceHint: "backend", relPath: "src/server.js" },
+			])
+		})
+	})
+})
diff --git a/apps/vscode/src/core/workspace/index.ts b/apps/vscode/src/core/workspace/index.ts
new file mode 100644
index 0000000..6e4123b
--- /dev/null
+++ b/apps/vscode/src/core/workspace/index.ts
@@ -0,0 +1,9 @@
+/**
+ * Workspace module exports for multi-workspace support
+ */
+
+// Export workspace path parsing utilities
+export { getWorkspaceBasename, workspaceResolver } from "./WorkspaceResolver"
+export { WorkspaceRootManager } from "./WorkspaceRootManager"
+// Re-export convenience function at module level for easier imports
+// Usage: import { resolveWorkspacePath } from "@core/workspace"
diff --git a/apps/vscode/src/core/workspace/utils/parseWorkspaceInlinePath.ts b/apps/vscode/src/core/workspace/utils/parseWorkspaceInlinePath.ts
new file mode 100644
index 0000000..9e6201a
--- /dev/null
+++ b/apps/vscode/src/core/workspace/utils/parseWorkspaceInlinePath.ts
@@ -0,0 +1,100 @@
+/**
+ * parseWorkspaceInlinePath - Utility for parsing workspace-prefixed paths
+ *
+ * This utility extracts workspace hints from paths using the @workspace:path syntax.
+ * This allows tools to target specific workspaces in multi-root environments.
+ *
+ * Examples:
+ *   "@frontend:src/index.ts" -> { workspaceHint: "frontend", relPath: "src/index.ts" }
+ *   "@backend:package.json" -> { workspaceHint: "backend", relPath: "package.json" }
+ *   "src/index.ts" -> { workspaceHint: undefined, relPath: "src/index.ts" }
+ *   "@my-app:src/components/Button.tsx" -> { workspaceHint: "my-app", relPath: "src/components/Button.tsx" }
+ */
+
+export interface ParsedWorkspacePath {
+	/**
+	 * The workspace hint extracted from the path (if any)
+	 * This can be a workspace name or partial path to match
+	 */
+	workspaceHint?: string
+
+	/**
+	 * The relative path after removing the workspace prefix
+	 */
+	relPath: string
+}
+
+/**
+ * Parse a path that may contain a workspace hint prefix
+ *
+ * @param value - The input path that may contain @workspace: prefix
+ * @returns Parsed result with optional workspace hint and the relative path
+ */
+export function parseWorkspaceInlinePath(value: string): ParsedWorkspacePath {
+	// Handle null/undefined/empty inputs
+	if (!value) {
+		return { workspaceHint: undefined, relPath: value || "" }
+	}
+
+	// Regex to match @workspace:path pattern
+	// Captures:
+	// - Group 1: workspace name (anything except colon)
+	// - Group 2: the path after the colon
+	const match = value.match(/^@([^:]+):(.*)$/)
+
+	if (match) {
+		const [, workspaceHint, relPath] = match
+		return {
+			workspaceHint: workspaceHint.trim(),
+			relPath: relPath.trim(),
+		}
+	}
+
+	// No workspace hint found, return original value as relative path
+	return { workspaceHint: undefined, relPath: value }
+}
+
+/**
+ * Check if a path contains a workspace hint
+ *
+ * @param value - The path to check
+ * @returns True if the path contains a workspace hint
+ */
+export function hasWorkspaceHint(value: string): boolean {
+	return /^@[^:]+:/.test(value)
+}
+
+/**
+ * Add a workspace hint to a path
+ *
+ * @param workspaceName - The workspace name to add as hint
+ * @param path - The relative path
+ * @returns The path with workspace hint prefix
+ */
+export function addWorkspaceHint(workspaceName: string, path: string): string {
+	// Remove any existing hint first
+	const { relPath } = parseWorkspaceInlinePath(path)
+	return `@${workspaceName}:${relPath}`
+}
+
+/**
+ * Remove workspace hint from a path if present
+ *
+ * @param value - The path that may contain a workspace hint
+ * @returns The path without workspace hint
+ */
+export function removeWorkspaceHint(value: string): string {
+	const { relPath } = parseWorkspaceInlinePath(value)
+	return relPath
+}
+
+/**
+ * Parse multiple paths that may contain workspace hints
+ * Useful for batch operations
+ *
+ * @param paths - Array of paths that may contain workspace hints
+ * @returns Array of parsed results
+ */
+export function parseMultipleWorkspacePaths(paths: string[]): ParsedWorkspacePath[] {
+	return paths.map((path) => parseWorkspaceInlinePath(path))
+}
diff --git a/apps/vscode/src/dev/commands/tasks.ts b/apps/vscode/src/dev/commands/tasks.ts
new file mode 100644
index 0000000..68996fd
--- /dev/null
+++ b/apps/vscode/src/dev/commands/tasks.ts
@@ -0,0 +1,336 @@
+import { Controller } from "@core/controller"
+import { ClineMessage } from "@shared/ExtensionMessage"
+import { HistoryItem } from "@shared/HistoryItem"
+import * as fs from "fs/promises"
+import * as path from "path"
+import * as vscode from "vscode"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Registers development-only commands for task manipulation.
+ * These are only activated in development mode.
+ */
+export function registerTaskCommands(controller: Controller): vscode.Disposable[] {
+	return [
+		vscode.commands.registerCommand("cline.dev.expireMcpOAuthTokens", async () => {
+			try {
+				// OAuth tokens live in the shared MCP settings file (per-server
+				// `oauth.tokens`). Invalidate each access_token so the next request
+				// gets a 401 and the MCP SDK exercises the refresh_token flow.
+				const settingsPath = await controller.mcpHub.getMcpSettingsFilePath()
+				const content = JSON.parse(await fs.readFile(settingsPath, "utf-8"))
+				const servers = (content?.mcpServers ?? {}) as Record<string, { oauth?: { tokens?: { access_token?: string } } }>
+				let expiredCount = 0
+
+				for (const [name, server] of Object.entries(servers)) {
+					if (server?.oauth?.tokens?.access_token) {
+						server.oauth.tokens.access_token = "expired-by-dev-command"
+						expiredCount++
+						Logger.log(`[Dev] Invalidated access token for server: ${name}`)
+					}
+				}
+
+				if (expiredCount === 0) {
+					vscode.window.showInformationMessage("No MCP OAuth tokens found - no servers are authenticated")
+					return
+				}
+
+				await fs.writeFile(settingsPath, JSON.stringify(content, null, 2))
+
+				const action = await vscode.window.showInformationMessage(
+					`Expired ${expiredCount} MCP OAuth token(s). Reload window to test token refresh flow.`,
+					"Reload Window",
+					"Cancel",
+				)
+
+				if (action === "Reload Window") {
+					vscode.commands.executeCommand("workbench.action.reloadWindow")
+				}
+			} catch (error) {
+				vscode.window.showErrorMessage(`Failed to expire tokens: ${error}`)
+				Logger.error("[Dev] Error expiring MCP OAuth tokens:", error)
+			}
+		}),
+		vscode.commands.registerCommand("cline.dev.createTestTasks", async () => {
+			const count = (
+				await HostProvider.window.showInputBox({
+					title: "Test Tasks",
+					prompt: "How many test tasks to create?",
+					value: "10",
+				})
+			).response
+
+			if (count === undefined) {
+				return
+			}
+
+			const tasksCount = parseInt(count)
+			const globalStoragePath = HostProvider.get().globalStorageFsPath
+			const tasksDir = path.join(globalStoragePath, "tasks")
+
+			vscode.window.withProgress(
+				{
+					location: vscode.ProgressLocation.Notification,
+					title: `Creating ${tasksCount} test tasks...`,
+					cancellable: false,
+				},
+				async (progress) => {
+					for (let i = 0; i < tasksCount; i++) {
+						// Generate a timestamp to ensure unique IDs
+						const timestamp = Date.now() + i
+						const taskId = `${timestamp}`
+						const taskDir = path.join(tasksDir, taskId)
+
+						await fs.mkdir(taskDir, { recursive: true })
+
+						// Generate a task prompt
+						const taskName = getRandomTaskName(i)
+
+						// Create realistic message sequence
+						const messages = createRealisticMessageSequence(timestamp, taskName, i)
+
+						// Create API conversation history file
+						await fs.writeFile(
+							path.join(taskDir, "api_conversation_history.json"),
+							JSON.stringify(
+								[
+									{
+										role: "user",
+										content: [{ type: "text", text: `<task>\n${taskName}\n</task>` }],
+									},
+									{
+										role: "assistant",
+										content: [
+											{
+												type: "text",
+												text: `I'll help you ${taskName.toLowerCase()}. Let me break this down into steps.`,
+											},
+										],
+									},
+								],
+								null,
+								2,
+							),
+						)
+
+						// Create UI messages file with realistic message sequence
+						await fs.writeFile(path.join(taskDir, "ui_messages.json"), JSON.stringify(messages, null, 2))
+
+						// Create history item to be shown in the HistoryView
+						const historyItem: HistoryItem = {
+							id: taskId,
+							ts: timestamp,
+							task: taskName,
+							tokensIn: Math.floor(100 + Math.random() * 900), // Random token count from 100-1000
+							tokensOut: Math.floor(200 + Math.random() * 1800), // Random token count from 200-2000
+							cacheWrites: i % 3 === 0 ? Math.floor(50 + Math.random() * 150) : undefined, // Only add cache writes to every 3rd task
+							cacheReads: i % 3 === 0 ? Math.floor(20 + Math.random() * 80) : undefined, // Only add cache reads to every 3rd task
+							totalCost: Number((0.0001 + Math.random() * 0.01).toFixed(5)), // Random cost from $0.0001 to $0.0101
+							size: 1024 * 1024, // 1MB
+						}
+
+						// Update task history in global state
+						await controller.updateTaskHistory(historyItem)
+
+						progress.report({ increment: 100 / tasksCount })
+					}
+
+					// Update the UI to show the new tasks
+					await controller.postStateToWebview()
+
+					const message = `Created ${tasksCount} test tasks`
+					HostProvider.window.showMessage({
+						type: ShowMessageType.INFORMATION,
+						message,
+					})
+				},
+			)
+		}),
+	]
+}
+
+/**
+ * Creates a realistic sequence of messages that would occur in a typical task
+ */
+function createRealisticMessageSequence(baseTimestamp: number, taskPrompt: string, taskIndex: number): ClineMessage[] {
+	// Use an incrementing timestamp to ensure messages appear in sequence
+	let timestamp = baseTimestamp
+	const getNextTimestamp = () => {
+		timestamp += 1000 // Add 1 second between messages
+		return timestamp
+	}
+
+	// Variables to make different test tasks look unique
+	const fileName = getRandomFileName(taskIndex)
+	const commitHash = `commit${taskIndex}${Math.floor(Math.random() * 1000000).toString(16)}`
+
+	// Create a realistic message sequence
+	const messages: ClineMessage[] = [
+		// Initial task message - uses "say" with "text" which is the format used in Cline.ts
+		{
+			ts: baseTimestamp,
+			type: "say",
+			say: "text",
+			text: taskPrompt,
+		},
+
+		// API request started
+		{
+			ts: getNextTimestamp(),
+			type: "say",
+			say: "api_req_started",
+			text: JSON.stringify({
+				request: `<task>\n${taskPrompt}\n</task>`,
+				tokensIn: Math.floor(100 + Math.random() * 200),
+				tokensOut: Math.floor(300 + Math.random() * 500),
+			}),
+		},
+
+		// Reasoning message
+		{
+			ts: getNextTimestamp(),
+			type: "say",
+			say: "reasoning",
+			text: `I'll approach this task by breaking it down into manageable steps. First, I'll analyze the requirements, then create a plan, and finally implement the solution systematically.`,
+		},
+
+		// Text response
+		{
+			ts: getNextTimestamp(),
+			type: "say",
+			say: "text",
+			text: `I'll help you with this task. Let me start by creating the necessary files and implementing the core functionality.`,
+		},
+	]
+
+	// Add task-specific messages based on index modulo to create variety
+	const messageType = taskIndex % 5
+
+	if (messageType === 0 || messageType === 2) {
+		// Tool use - file operations
+		messages.push({
+			ts: getNextTimestamp(),
+			type: "say",
+			say: "tool",
+			text: JSON.stringify({
+				tool: "newFileCreated",
+				path: fileName,
+				content: `// Sample code for ${taskPrompt}`,
+			}),
+		})
+	}
+
+	if (messageType === 1 || messageType === 3) {
+		// Command execution
+		messages.push(
+			{
+				ts: getNextTimestamp(),
+				type: "ask",
+				ask: "command",
+				text: `ls -la`,
+			},
+			{
+				ts: getNextTimestamp(),
+				type: "say",
+				say: "command_output",
+				text: `total 24\ndrwxr-xr-x 3 user staff 96 Mar 10 12:34 .\ndrwxr-xr-x 8 user staff 256 Mar 10 12:30 ..\n-rw-r--r-- 1 user staff 158 Mar 10 12:34 ${fileName}`,
+			},
+		)
+	}
+
+	if (messageType === 2 || messageType === 4) {
+		// Browser actions
+		messages.push(
+			{
+				ts: getNextTimestamp(),
+				type: "ask",
+				ask: "browser_action_launch",
+				text: `https://example.com`,
+			},
+			{
+				ts: getNextTimestamp(),
+				type: "say",
+				say: "browser_action_result",
+				text: JSON.stringify({
+					logs: "Page loaded successfully",
+					screenshot:
+						"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+				}),
+			},
+			{
+				ts: getNextTimestamp(),
+				type: "say",
+				say: "browser_action",
+				text: JSON.stringify({
+					action: "close",
+				}),
+			},
+		)
+	}
+
+	// Add checkpoint
+	messages.push({
+		ts: getNextTimestamp(),
+		type: "say",
+		say: "checkpoint_created",
+		lastCheckpointHash: commitHash,
+	})
+
+	// Add completion result (all tasks end with this)
+	messages.push({
+		ts: getNextTimestamp(),
+		type: "say",
+		say: "completion_result",
+		text: `I've completed the task to ${taskPrompt.toLowerCase()}. The implementation includes all the required functionality and meets the specifications. ${"x".repeat(1024 * 1024)}`, // 1MB file
+		lastCheckpointHash: commitHash,
+	})
+
+	return messages
+}
+
+/**
+ * Returns a random task name for test data
+ */
+function getRandomTaskName(index: number): string {
+	const tasks = [
+		"Create a simple todo application",
+		"Build a weather forecast widget",
+		"Implement a markdown parser",
+		"Design a responsive landing page",
+		"Develop a currency converter",
+		"Create a file upload component",
+		"Build a data visualization dashboard",
+		"Implement a search functionality",
+		"Create a user authentication system",
+		"Design a dark mode toggle",
+		"Build a countdown timer",
+		"Create a drag and drop interface",
+		"Implement form validation",
+		"Design a multi-step wizard",
+		"Create a notification system",
+	]
+
+	return tasks[index % tasks.length] + ` (Test ${index + 1})`
+}
+
+/**
+ * Returns a random file name for test data
+ */
+function getRandomFileName(index: number): string {
+	const files = [
+		"index.html",
+		"styles.css",
+		"script.js",
+		"app.jsx",
+		"main.ts",
+		"utils.py",
+		"config.json",
+		"server.js",
+		"data.csv",
+		"README.md",
+	]
+
+	return files[index % files.length]
+}
diff --git a/apps/vscode/src/dev/debug-harness/README.md b/apps/vscode/src/dev/debug-harness/README.md
new file mode 100644
index 0000000..2c8b76c
--- /dev/null
+++ b/apps/vscode/src/dev/debug-harness/README.md
@@ -0,0 +1,471 @@
+# Debug Harness
+
+An HTTP-controlled debug server for the Cline VSCode extension. Provides
+programmatic access to:
+
+- **Extension host debugging** (Node.js): breakpoints, evaluate, step, pause/resume via CDP
+- **Webview debugging** (Chrome): breakpoints, evaluate via CDP
+- **UI automation**: click, type, screenshot, open sidebar via Playwright
+- **Sourcemap resolution**: set breakpoints by original source file + line
+- **Data isolation**: separate `~/.cline2` profile so debugee doesn't interfere with debugger
+- **OAuth testing**: browser URL capture, token inspection, callback simulation
+
+Designed to be driven from an agentic loop via `curl` commands.
+
+## Quick Start
+
+```bash
+# Terminal 1: Start the debug harness server
+bun src/dev/debug-harness/server.ts --auto-launch --skip-build
+
+# Terminal 2: Interact via curl
+curl localhost:19229/api -d '{"method":"status"}'
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+```
+
+## Server Options
+
+```
+bun src/dev/debug-harness/server.ts [options]
+
+Options:
+  --skip-build        Skip building extension/webview (use existing dist/)
+  --auto-launch       Automatically launch VSCode on startup
+  --workspace PATH    Workspace directory to open (default: /tmp/cline-debug-workspace)
+  --port PORT         Server port (default: 19229)
+  --cline-dir PATH    Override the debugee's CLINE_DIR (default: ~/.cline2)
+```
+
+## Full Build + Launch (first time)
+
+```bash
+# This builds protos, extension (unminified+sourcemaps), webview (unminified+sourcemaps),
+# downloads VSCode, launches it, and connects CDP to the extension host.
+bun src/dev/debug-harness/server.ts --auto-launch
+```
+
+## Data Isolation
+
+The debugee runs with `CLINE_DIR=~/.cline2` by default, keeping its data
+separate from your real `~/.cline`. This prevents:
+
+- Logging out of the debugger when the debugee logs out
+- Task history, API keys, and settings leaking between instances
+- State corruption from shared secrets.json
+
+The isolated CLINE_DIR is reported in `status()` and `launch()` responses:
+
+```bash
+curl localhost:19229/api -d '{"method":"status"}'
+# → { "clineDir": "/Users/you/.cline2", ... }
+```
+
+To use a different directory: `--cline-dir /tmp/test-cline-dir`
+
+## Browser Capture & OAuth Testing
+
+When the debug harness launches VSCode, it sets `CLINE_CAPTURE_BROWSER=1`
+which intercepts all `openExternal()` calls in the debugee. Instead of
+opening a real browser, URLs are:
+
+1. **Logged to disk** at `$CLINE_DIR/data/debug-captured-urls.jsonl`
+2. **POSTed in real-time** to the debug harness server at `/captured-url`
+3. **Queryable** via the `oauth.captured_urls` API method
+
+### OAuth API
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `oauth.captured_urls` | `{clear?}` | Get URLs the debugee tried to open (captured by browser interception) |
+| `oauth.read_stored_token` | | Read auth token presence from debugee's secrets.json |
+| `oauth.simulate_callback` | `{path, code?, state?, provider?, token?}` | Build a vscode:// callback URI (for MCP/provider OAuth) |
+| `oauth.read_captured_urls_file` | | Read the on-disk JSONL file of captured URLs |
+
+### Testing Cline OAuth (login flow)
+
+The Cline OAuth flow uses the SDK's local callback server. When the user
+clicks "Login", the SDK:
+
+1. Starts a local HTTP server on a random port
+2. Calls `openExternal(authorizationUrl)` — which we capture
+3. The user authenticates in the browser — which we need to simulate
+4. The provider redirects to the local callback server with `?code=...`
+5. The SDK captures the code and exchanges it for tokens
+
+**To test this flow:**
+
+```bash
+# 1. Click "Login" in the debugee's sidebar
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+# Dismiss overlays first (see "Dismissing Promotional Overlays" below)
+curl localhost:19229/api -d '{"method":"ui.locator","params":{"text":"Login to Cline","frame":"sidebar","action":"click"}}'
+
+# 2. Check captured URLs to find the authorization URL
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+# → { "urls": [{ "url": "https://api.cline.bot/auth/authorize?callback_url=http://127.0.0.1:PORT/..." }] }
+
+# 3. The authorization URL has a callback_url pointing to the SDK's local server.
+#    To complete the flow, you need to either:
+#    a. Open the authorization URL in a real browser (it will redirect back
+#       to the SDK's local callback server automatically)
+#    b. Simulate the redirect by extracting the callback_url and making
+#       a curl request to it with a code parameter:
+curl "http://127.0.0.1:PORT/auth/callback?code=TEST_CODE" 2>/dev/null
+
+# 4. Verify the token was stored
+curl localhost:19229/api -d '{"method":"oauth.read_stored_token"}'
+# → { "found": true, "hasAccountId": true, "keys": ["cline:clineAccountId"] }
+
+# 5. Take a screenshot to verify the UI shows authenticated state
+curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+```
+
+### Testing MCP OAuth
+
+MCP servers that require OAuth use a different flow: the browser redirects
+to a `vscode://` URI handled by the extension's URI handler. The auth provider
+(e.g. Linear) decides the `code`; for end-to-end testing, pair this with the
+local MCP OAuth test server (`bun run dev:mcp-oauth-test-server`, see
+`src/dev/mcp-oauth-test-server/README.md`), which mints real codes/tokens.
+
+```bash
+# 1. Trigger MCP OAuth (e.g., click "Authenticate" button for a server)
+# 2. Check captured URLs for the authorization URL
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+#    The authorize URL contains redirect_uri=vscode://saoudrizwan.claude-dev/mcp-auth/callback/HASH
+
+# 3. Get a real authorization code from the auth server, e.g. by following the
+#    captured authorize URL (the test server auto-approves and 302s to the
+#    vscode:// callback carrying ?code=...&state=...):
+curl -s -D - -o /dev/null "<captured-authorize-url>" | grep -i '^location:'
+
+# 4. DELIVER the vscode:// callback to the extension. VSCode only routes real
+#    vscode:// URIs to the registered handler, which the harness can't
+#    synthesize — and the extension host is ESM, so you can't require() the
+#    handler module. Instead, call the __clineHandleUri hook (see below):
+curl localhost:19229/api -d '{
+  "method": "ext.evaluate",
+  "params": {
+    "awaitPromise": true,
+    "expression": "globalThis.__clineHandleUri(\"vscode://saoudrizwan.claude-dev/mcp-auth/callback/HASH?code=REAL_CODE&state=SAVED_STATE\")"
+  }
+}'
+
+# 5. Verify tokens were stored
+curl localhost:19229/api -d '{"method":"oauth.read_stored_token"}'
+```
+
+> **`globalThis.__clineHandleUri(url)` — debug-only URI delivery hook.**
+> Registered in `src/extension.ts` during activation, **only** when
+> `CLINE_CAPTURE_BROWSER` is set (which the harness always sets), so it never
+> ships in production. It calls the same `SharedUriHandler.handleUri(url)` that
+> VSCode's real `registerUriHandler` invokes, returning a `Promise<boolean>`
+> (pass `awaitPromise: true`). Use it for any `vscode://` callback — MCP,
+> OpenRouter, `/auth`, etc. `oauth.simulate_callback` only *builds* the URI; this
+> hook actually *delivers* it.
+
+
+### Testing Provider OAuth (OpenRouter, etc.)
+
+```bash
+# 1. Trigger provider login (e.g., "Get OpenRouter API Key" button)
+# 2. Check captured URLs
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+# 3. Simulate the redirect callback
+curl localhost:19229/api -d '{
+  "method": "oauth.simulate_callback",
+  "params": {"path": "/openrouter", "code": "TEST_CODE"}
+}'
+```
+
+## Practical Tips
+
+### Dismissing Promotional Overlays
+
+On fresh launches, one or more full-screen promo overlays may appear and
+block all sidebar interactions. **Always dismiss them immediately after
+opening the sidebar**, before any other interaction.
+
+```bash
+# Open sidebar first
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+# Dismiss ALL overlays (may need to run twice for multiple overlays)
+curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+```
+
+### Navigating Between Views Using Commands
+
+Instead of trying to find and click small icons in the sidebar header,
+use VSCode commands via the command palette. These are registered in
+`src/registry.ts`:
+
+| Command | What it opens |
+|---------|--------------|
+| `cline.accountButtonClicked` | Account / sign-in view |
+| `cline.historyButtonClicked` | Task history view |
+| `cline.settingsButtonClicked` | Settings view |
+| `cline.mcpButtonClicked` | MCP servers view |
+| `cline.plusButtonClicked` | New task (chat view) |
+| `cline.worktreesButtonClicked` | Worktrees view |
+
+```bash
+# Navigate to account view
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+
+# Navigate to history view
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.historyButtonClicked"}}'
+
+# Navigate to settings view
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.settingsButtonClicked"}}'
+
+# Navigate to MCP view
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.mcpButtonClicked"}}'
+
+# Start a new task (return to chat view)
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.plusButtonClicked"}}'
+```
+
+### Typical Session Workflow
+
+```bash
+# 1. Launch (if not using --auto-launch)
+curl localhost:19229/api -d '{"method":"launch","params":{"skipBuild":true}}'
+
+# 2. Open sidebar and dismiss overlays
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+
+# 3. Check status (verify CLINE_DIR, browser capture, etc.)
+curl localhost:19229/api -d '{"method":"status"}'
+
+# 4. Navigate to the view you need
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+
+# 5. Interact and verify
+curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+
+# 6. For OAuth flows, check captured URLs
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+
+# 7. When done, shut down
+curl localhost:19229/api -d '{"method":"shutdown"}'
+```
+
+## API
+
+All commands are sent as `POST /api` with JSON body `{"method": "...", "params": {...}}`.
+
+Responses: `{"result": {...}}` on success, `{"error": "..."}` on failure.
+
+Convenience endpoints:
+- `GET /health` — `{"status": "ok"}`
+- `GET /status` — Full harness status
+- `POST /captured-url` — Internal: receives captured browser URLs from debugee
+
+### Lifecycle
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `launch` | `{workspace?, skipBuild?}` | Build + launch VSCode |
+| `shutdown` | | Close VSCode and CDP connections |
+| `status` | | Current state of all components |
+| `connect_webview` | | Connect CDP to the webview (call after sidebar is open) |
+
+### Extension Host Debugging (Node.js)
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `ext.set_breakpoint` | `{file, line, column?, condition?}` | Set breakpoint by source file (sourcemap-resolved) |
+| `ext.set_breakpoint_raw` | `{url?, urlRegex?, scriptId?, lineNumber, columnNumber?, condition?}` | Set breakpoint with raw CDP params |
+| `ext.remove_breakpoint` | `{breakpointId}` | Remove a breakpoint |
+| `ext.evaluate` | `{expression, callFrameId?}` | Evaluate expression (at breakpoint or global) |
+| `ext.pause` | | Pause execution |
+| `ext.resume` | | Resume execution |
+| `ext.step_over` | | Step over |
+| `ext.step_into` | | Step into |
+| `ext.step_out` | | Step out |
+| `ext.call_stack` | | Get call stack (when paused) |
+| `ext.scripts` | `{filter?}` | List loaded scripts |
+| `ext.source_files` | | List source files from sourcemap |
+| `ext.get_properties` | `{objectId}` | Get object properties |
+| `ext.get_script_source` | `{scriptId}` | Get script source text |
+
+### Webview Debugging (Chrome)
+
+Call `connect_webview` first after the sidebar is open (only needed for breakpoints/stepping).
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `web.set_breakpoint` | `{url, line, column?, condition?}` | Set breakpoint by URL pattern |
+| `web.remove_breakpoint` | `{breakpointId}` | Remove a breakpoint |
+| `web.evaluate` | `{expression, callFrameId?}` | Evaluate in sidebar (Playwright) or at breakpoint (CDP) |
+| `web.post_message` | `{message}` | Send a postMessage to the extension host via exposed vsCodeApi |
+| `web.pause` | | Pause |
+| `web.resume` | | Resume |
+| `web.step_over/into/out` | | Stepping |
+
+### UI Automation (Playwright)
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `ui.screenshot` | `{fullPage?}` | Take screenshot → returns `{path}` (use `read_file` on the path, don't `open` the file) |
+| `ui.sidebar_screenshot` | | Screenshot focused on sidebar → returns `{path}` |
+| `ui.click` | `{selector, frame?, delay?}` | Click element (`frame: "sidebar"` for webview) |
+| `ui.fill` | `{selector, text, frame?}` | Fill input |
+| `ui.press` | `{key}` | Press key (e.g., "Enter", "Meta+Shift+p") |
+| `ui.type` | `{text, delay?}` | Type text |
+| `ui.open_sidebar` | | Open the Cline sidebar |
+| `ui.frames` | | List all frames |
+| `ui.wait_for_selector` | `{selector, frame?, timeout?}` | Wait for element |
+| `ui.command_palette` | `{command}` | Open command palette and run command |
+| `ui.get_text` | `{selector, frame?}` | Get element text |
+| `ui.locator` | `{role?, name?, testId?, text?, frame?, action?, value?}` | Rich Playwright locator (auto-retries with frame refresh for sidebar) |
+| `ui.react_input` | `{text, selector?, clear?, submit?}` | Set React-controlled textarea value via `execCommand('insertText')` |
+| `ui.send_message` | `{text, images?, files?, responseType?}` | Send a chat message bypassing the textarea (via gRPC postMessage) |
+
+### OAuth & Browser Capture
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `oauth.captured_urls` | `{clear?}` | Get URLs the debugee tried to open in a browser |
+| `oauth.read_stored_token` | | Check auth token presence in debugee's secrets.json |
+| `oauth.simulate_callback` | `{path, code?, state?, provider?, token?}` | Build a vscode:// callback URI for MCP/provider OAuth (does NOT deliver it) |
+| `oauth.read_captured_urls_file` | | Read on-disk JSONL log of captured URLs |
+
+To actually **deliver** a `vscode://` callback to the extension, call the
+debug-only hook via `ext.evaluate` (with `awaitPromise: true`):
+`globalThis.__clineHandleUri("vscode://saoudrizwan.claude-dev/...?code=...&state=...")`.
+It invokes the same `SharedUriHandler.handleUri` as VSCode's real URI handler
+and is registered only when `CLINE_CAPTURE_BROWSER` is set (never in prod). See
+"Testing MCP OAuth" above.
+
+### Combined
+
+| Method | Params | Description |
+|--------|--------|-------------|
+| `wait_for_pause` | `{timeout?}` | Block until any debuggee hits a breakpoint |
+
+## Example Workflows
+
+### 1. Set a breakpoint and observe execution
+
+```bash
+curl localhost:19229/api -d '{
+  "method": "ext.set_breakpoint",
+  "params": {"file": "src/extension.ts", "line": 25}
+}'
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"wait_for_pause","params":{"timeout":10000}}'
+curl localhost:19229/api -d '{"method":"ext.call_stack"}'
+curl localhost:19229/api -d '{"method":"ext.resume"}'
+```
+
+### 2. Test OAuth login flow
+
+```bash
+# Dismiss overlays, then click Login
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+curl localhost:19229/api -d '{"method":"ui.locator","params":{"text":"Login to Cline","frame":"sidebar","action":"click"}}'
+
+# Check what URL was captured
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+
+# The URL contains callback_url=http://127.0.0.1:PORT/...
+# Open it in a real browser to complete auth, or simulate:
+# (extract the port from the captured URL first)
+curl "http://127.0.0.1:PORT/callback?code=real_or_test_code"
+
+# Verify token stored
+curl localhost:19229/api -d '{"method":"oauth.read_stored_token"}'
+```
+
+### 3. Navigate to Account view and check auth state
+
+```bash
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+```
+
+## How It Works
+
+1. **Build**: esbuild bundles `src/extension.ts` → `dist/extension.js` (unminified, with
+   sourcemaps). Vite builds `webview-ui/` → `webview-ui/build/` (unminified, inline sourcemaps).
+
+2. **Launch**: Uses `@vscode/test-electron` to download VSCode, then Playwright's
+   `_electron.launch()` to start it with `--inspect-extensions=9230` for Node.js inspector
+   access and `--extensionDevelopmentPath` to load our extension.
+
+3. **Data Isolation**: Sets `CLINE_DIR=~/.cline2` in the debugee's environment, ensuring
+   the debugee uses a completely separate data directory from the user's real `~/.cline`.
+   The `createStorageContext()` function in `src/shared/storage/storage-context.ts` reads
+   this environment variable to determine where to store globalState.json, secrets.json,
+   task history, and workspace state.
+
+4. **Browser Capture**: Sets `CLINE_CAPTURE_BROWSER=1` and `CLINE_DEBUG_HARNESS_PORT=19229`
+   in the debugee's environment. When `openExternal()` is called in `src/utils/env.ts`, it
+   checks for `CLINE_CAPTURE_BROWSER` and, if set, logs the URL to a JSONL file and POSTs
+   it to the debug harness server instead of opening a real browser. This is essential for
+   testing OAuth flows without a visible browser.
+
+5. **Extension CDP**: Connects to the extension host's V8 inspector via WebSocket on port 9230.
+   Enables `Debugger` and `Runtime` domains. Tracks `scriptParsed` events and `paused`/`resumed`
+   state.
+
+6. **Sourcemap Resolution**: When setting breakpoints by source file, reads `dist/extension.js.map`
+   and resolves the original file + line to the generated (bundled) file + line using VLQ-decoded
+   sourcemap mappings.
+
+7. **Webview CDP**: After the sidebar loads, creates a Playwright CDP session for the webview
+   frame, enabling debugger commands. Falls back to `frame.evaluate()` for expression evaluation.
+
+8. **UI Automation**: Playwright's Page/Frame APIs provide click, fill, type, screenshot, locator
+   queries, and more. The sidebar webview is accessed as a Frame within the VSCode window.
+
+## Caveats
+
+**⚠️ Data Isolation**: The debugee uses `~/.cline2` by default. If you need to test with
+existing data from your real `~/.cline`, copy it: `cp -r ~/.cline ~/.cline2`. Be aware that
+secrets (API keys, auth tokens) will be shared if you do this.
+
+**⚠️ "Introducing Cline Kanban" overlay**: On fresh launches, a full-screen promo overlay may
+appear in the sidebar. It blocks all interactions and makes screenshots useless. **Dismiss it
+immediately after opening the sidebar**, before doing anything else:
+```bash
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+```
+
+**Screenshots**: `ui.screenshot` and `ui.sidebar_screenshot` save PNG files to `/tmp/cline-debug/`
+and return `{path}` in the response. **Do NOT `open` the file** — on macOS this launches Preview.app
+which covers the VSCode window. Use `read_file` on the returned path to examine the image.
+
+**OAuth with real providers**: The browser capture only intercepts the URL that the debugee tries
+to open. For Cline OAuth, the SDK's local callback server is still running and will accept
+redirects. For provider OAuth (OpenRouter, MCP), you need to simulate the `vscode://` callback
+URI — see the OAuth testing section above.
+
+**Cline OAuth with invalid codes**: If you simulate the OAuth callback with a fake code, the
+SDK's token exchange will fail (the provider won't recognize the code). You need either a real
+authorization code (obtained by completing the flow in a browser) or a way to mock the token
+exchange endpoint.
+
+## Troubleshooting
+
+**"Inspector not available on port 9230"**: The extension host hasn't started yet. Wait longer
+or check that the extension built correctly.
+
+**"Sidebar frame not found"**: The Cline sidebar isn't open. Use `ui.open_sidebar` first.
+
+**"Webview CDP not connected"**: Call `connect_webview` after the sidebar is open. If it fails,
+webview breakpoints aren't available, but `web.evaluate` still works via Playwright.
+
+**Sourcemap resolution fails**: Use `ext.source_files` to see what paths the sourcemap contains,
+then use `ext.set_breakpoint_raw` with a `urlRegex` pattern.
+
+**Screenshots directory**: Saved to `/tmp/cline-debug/` (configurable via SCREENSHOT_DIR).
+
+**Debugee still uses ~/.cline**: Check that `CLINE_DIR` appears in the `status()` response.
+If it's missing, the debugee may have been launched before the harness set the env var.
+Shutdown and relaunch.
\ No newline at end of file
diff --git a/apps/vscode/src/dev/debug-harness/server.ts b/apps/vscode/src/dev/debug-harness/server.ts
new file mode 100644
index 0000000..6e707dc
--- /dev/null
+++ b/apps/vscode/src/dev/debug-harness/server.ts
@@ -0,0 +1,1613 @@
+#!/usr/bin/env bun
+
+/**
+ * Debug Harness Server
+ *
+ * Launches VSCode with the Cline extension in debug mode and provides
+ * an HTTP API for:
+ *   - Extension host debugging (breakpoints, evaluate, stepping) via CDP
+ *   - Webview debugging (breakpoints, evaluate, stepping) via CDP
+ *   - UI automation (click, type, screenshot) via Playwright
+ *
+ * Usage:
+ *   bun src/dev/debug-harness/server.ts [options]
+ *
+ * Options:
+ *   --skip-build        Skip building extension/webview
+ *   --auto-launch       Automatically launch VSCode on startup
+ *   --workspace PATH    Workspace directory to open
+ *   --port PORT         Server port (default: 19229)
+ *   --launch-timeout MS Playwright _electron.launch timeout (default: 120000)
+ *   --no-browser-capture  Let openExternal() open real browser windows (for interactive OAuth)
+ *
+ * Env:
+ *   VSCODE_TEST_VERSION  Debugee VSCode version to download (default: 1.103.0; the
+ *                        bundled Playwright cannot drive the Electron in the latest
+ *                        "stable"). Set to "stable" or a pinned x.y.z to override.
+ *
+ * Then send commands:
+ *   curl localhost:19229/api -d '{"method":"launch"}'
+ *   curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+ *   curl localhost:19229/api -d '{"method":"ext.set_breakpoint","params":{"file":"src/extension.ts","line":42}}'
+ */
+
+import { type ExecSyncOptions, execSync } from "node:child_process"
+import fs from "node:fs"
+import http from "node:http"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { downloadAndUnzipVSCode, SilentReporter } from "@vscode/test-electron"
+import { _electron, type CDPSession, type ElectronApplication, type Frame, type Page } from "playwright"
+import WebSocket from "ws"
+
+const __script_dir = typeof __dirname !== "undefined" ? __dirname : path.dirname(fileURLToPath(import.meta.url))
+
+// ============================================================
+// Configuration
+// ============================================================
+
+const args = process.argv.slice(2)
+function getArg(name: string): string | undefined {
+	const idx = args.indexOf(name)
+	return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : undefined
+}
+
+const PORT = Number.parseInt(getArg("--port") || "19229", 10)
+const EXT_INSPECT_PORT = 9230
+// Playwright's _electron.launch() resolves once it controls the Electron main
+// process. A cold launch (first-run profile init, slow CI/VM) can exceed the old
+// 60s default, so allow more headroom and let it be overridden.
+const LAUNCH_TIMEOUT_MS = Number.parseInt(getArg("--launch-timeout") || "120000", 10)
+const PROJECT_ROOT = path.resolve(__script_dir, "..", "..", "..")
+const SCREENSHOT_DIR = path.join(os.tmpdir(), "cline-debug")
+const DEFAULT_WORKSPACE = path.join(os.tmpdir(), "cline-debug-workspace")
+const DEFAULT_CLINE_DIR = path.join(os.homedir(), ".cline2") // Separate profile from user's ~/.cline
+const SKIP_BUILD = args.includes("--skip-build")
+const AUTO_LAUNCH = args.includes("--auto-launch")
+const BROWSER_CAPTURE = !args.includes("--no-browser-capture")
+const WORKSPACE_ARG = getArg("--workspace")
+const CLINE_DIR_ARG = getArg("--cline-dir") // Override the isolated CLINE_DIR
+
+// ============================================================
+// VLQ Sourcemap Decoder
+// ============================================================
+
+const VLQ_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+const VLQ_MAP: Record<string, number> = {}
+for (let i = 0; i < VLQ_CHARS.length; i++) VLQ_MAP[VLQ_CHARS[i]] = i
+
+function decodeVLQ(encoded: string): number[] {
+	const result: number[] = []
+	let shift = 0,
+		value = 0
+	for (const c of encoded) {
+		let digit = VLQ_MAP[c]
+		if (digit === undefined) continue
+		const cont = digit & 32
+		digit &= 31
+		value += digit << shift
+		if (cont) {
+			shift += 5
+		} else {
+			result.push(value & 1 ? -(value >> 1) : value >> 1)
+			value = 0
+			shift = 0
+		}
+	}
+	return result
+}
+
+interface SourceMapJSON {
+	sources: string[]
+	mappings: string
+	sourceRoot?: string
+}
+
+/**
+ * Given a sourcemap and an original source file + line, find the generated position.
+ * Returns null if no mapping is found.
+ */
+function resolveSourceMapPosition(
+	mapJson: SourceMapJSON,
+	sourceFile: string,
+	targetLine: number, // 1-indexed
+): { line: number; column: number } | null {
+	// Find source index - try exact match first, then suffix match
+	let srcIdx = mapJson.sources.indexOf(sourceFile)
+	if (srcIdx === -1) {
+		srcIdx = mapJson.sources.findIndex(
+			(s) => s.endsWith(sourceFile) || sourceFile.endsWith(s) || s.endsWith("/" + sourceFile),
+		)
+	}
+	if (srcIdx === -1) return null
+
+	const targetLine0 = targetLine - 1 // Convert to 0-indexed
+	const lines = mapJson.mappings.split(";")
+	let genCol = 0,
+		srcFile = 0,
+		srcLine = 0,
+		srcCol = 0
+	let bestMatch: { line: number; column: number } | null = null
+	let bestDist = Number.POSITIVE_INFINITY
+
+	for (let genLine = 0; genLine < lines.length; genLine++) {
+		genCol = 0
+		if (!lines[genLine]) continue
+		const segments = lines[genLine].split(",")
+		for (const seg of segments) {
+			if (!seg) continue
+			const d = decodeVLQ(seg)
+			genCol += d[0]
+			if (d.length >= 4) {
+				srcFile += d[1]
+				srcLine += d[2]
+				srcCol += d[3]
+				if (srcFile === srcIdx) {
+					const dist = Math.abs(srcLine - targetLine0)
+					if (dist < bestDist) {
+						bestDist = dist
+						bestMatch = { line: genLine + 1, column: genCol + 1 }
+					}
+					if (srcLine === targetLine0) {
+						return { line: genLine + 1, column: genCol + 1 }
+					}
+				}
+			}
+		}
+	}
+
+	// Return closest match if within 3 lines
+	if (bestMatch && bestDist <= 3) return bestMatch
+	return null
+}
+
+/**
+ * List all source files referenced in a sourcemap.
+ */
+function listSourceMapFiles(mapJson: SourceMapJSON): string[] {
+	return mapJson.sources.map((s) => {
+		if (mapJson.sourceRoot) return mapJson.sourceRoot + s
+		return s
+	})
+}
+
+// ============================================================
+// CDP Client - WebSocket wrapper for Chrome DevTools Protocol
+// ============================================================
+
+interface ScriptInfo {
+	scriptId: string
+	url: string
+	sourceMapURL?: string
+	startLine: number
+	endLine: number
+}
+
+class CdpClient {
+	private ws: WebSocket | null = null
+	private nextId = 1
+	private pending = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>()
+	private listeners = new Map<string, Set<(params: any) => void>>()
+
+	public paused = false
+	public lastPauseInfo: any = null
+	public scripts = new Map<string, ScriptInfo>()
+	public name: string
+
+	constructor(name: string) {
+		this.name = name
+	}
+
+	async connect(wsUrl: string): Promise<void> {
+		return new Promise((resolve, reject) => {
+			const ws = new WebSocket(wsUrl)
+			ws.on("open", () => {
+				this.ws = ws
+				resolve()
+			})
+			ws.on("error", (e: Error) => {
+				if (!this.ws) reject(e)
+			})
+			ws.on("close", () => {
+				this.ws = null
+			})
+			ws.on("message", (raw: WebSocket.Data) => {
+				const msg = JSON.parse(raw.toString())
+				if (msg.id !== undefined) {
+					const p = this.pending.get(msg.id)
+					if (p) {
+						this.pending.delete(msg.id)
+						if (msg.error) p.reject(new Error(JSON.stringify(msg.error)))
+						else p.resolve(msg.result)
+					}
+				} else if (msg.method) {
+					const hs = this.listeners.get(msg.method)
+					if (hs) hs.forEach((h) => h(msg.params))
+				}
+			})
+		})
+	}
+
+	async send(method: string, params: Record<string, any> = {}): Promise<any> {
+		if (!this.ws) throw new Error(`CDP [${this.name}] not connected`)
+		const id = this.nextId++
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, { resolve, reject })
+			this.ws!.send(JSON.stringify({ id, method, params }))
+			setTimeout(() => {
+				if (this.pending.has(id)) {
+					this.pending.delete(id)
+					reject(new Error(`CDP [${this.name}] timeout: ${method}`))
+				}
+			}, 30000)
+		})
+	}
+
+	on(event: string, handler: (params: any) => void): void {
+		if (!this.listeners.has(event)) this.listeners.set(event, new Set())
+		this.listeners.get(event)!.add(handler)
+	}
+
+	off(event: string, handler: (params: any) => void): void {
+		this.listeners.get(event)?.delete(handler)
+	}
+
+	get connected(): boolean {
+		return this.ws !== null
+	}
+
+	close(): void {
+		this.ws?.close()
+		this.ws = null
+		this.pending.clear()
+		this.scripts.clear()
+	}
+
+	/** Enable debugger and track scripts + pause events */
+	async enableDebugger(): Promise<void> {
+		await this.send("Debugger.enable", { maxScriptsCacheSize: 10000000 })
+		await this.send("Runtime.enable")
+
+		this.on("Debugger.scriptParsed", (params: any) => {
+			if (params.url) {
+				this.scripts.set(params.scriptId, {
+					scriptId: params.scriptId,
+					url: params.url,
+					sourceMapURL: params.sourceMapURL,
+					startLine: params.startLine || 0,
+					endLine: params.endLine || 0,
+				})
+			}
+		})
+
+		this.on("Debugger.paused", (params: any) => {
+			this.paused = true
+			this.lastPauseInfo = params
+			log(`[${this.name}] PAUSED: ${params.reason}`)
+		})
+
+		this.on("Debugger.resumed", () => {
+			this.paused = false
+			this.lastPauseInfo = null
+			log(`[${this.name}] RESUMED`)
+		})
+	}
+}
+
+// ============================================================
+// Debug Harness - Main orchestrator
+// ============================================================
+
+class DebugHarness {
+	private app: ElectronApplication | null = null
+	private page: Page | null = null
+	private sidebarFrame: Frame | null = null
+	private extCdp = new CdpClient("ext-host")
+	private webCdp: CdpClient | null = null
+	private webCdpSession: CDPSession | null = null // Playwright CDP session fallback
+	private screenshotCounter = 0
+	private extSourceMap: SourceMapJSON | null = null
+	private clineDir: string = DEFAULT_CLINE_DIR // The CLINE_DIR used for the debugee
+
+	// Pause waiters - resolved when any debuggee hits a breakpoint
+	private pauseWaiters: { resolve: (info: any) => void; timer: NodeJS.Timeout }[] = []
+
+	// Browser URL capture - stores URLs that the debugee tried to open (instead of opening a real browser)
+	private capturedUrls: { timestamp: number; url: string }[] = []
+
+	// ────────────────────────────────────────────
+	// Lifecycle
+	// ────────────────────────────────────────────
+
+	async launch(opts: { workspace?: string; skipBuild?: boolean } = {}): Promise<any> {
+		if (this.app) return { status: "already_running" }
+
+		const workspace = opts.workspace || WORKSPACE_ARG || DEFAULT_WORKSPACE
+		fs.mkdirSync(workspace, { recursive: true })
+		fs.mkdirSync(SCREENSHOT_DIR, { recursive: true })
+
+		// Build
+		if (!opts.skipBuild && !SKIP_BUILD) {
+			log("Building extension (unminified, with sourcemaps)...")
+			const execOpts: ExecSyncOptions = { cwd: PROJECT_ROOT, stdio: "inherit", env: { ...process.env, IS_DEV: "true" } }
+			execSync("bun run protos", execOpts)
+			execSync("bun esbuild.mjs", execOpts)
+			log("Building webview (unminified, with inline sourcemaps)...")
+			execSync("cd webview-ui && bunx vite build -- --dev-build", execOpts)
+		}
+
+		// Verify build output exists
+		const extJs = path.join(PROJECT_ROOT, "dist", "extension.js")
+		if (!fs.existsSync(extJs)) {
+			throw new Error(`Extension not built: ${extJs} not found. Run without --skip-build.`)
+		}
+
+		// Load extension sourcemap for breakpoint resolution
+		const mapFile = extJs + ".map"
+		if (fs.existsSync(mapFile)) {
+			try {
+				this.extSourceMap = JSON.parse(fs.readFileSync(mapFile, "utf-8"))
+				log(`Loaded extension sourcemap (${this.extSourceMap!.sources.length} source files)`)
+			} catch (e: any) {
+				log(`Warning: Could not load sourcemap: ${e.message}`)
+			}
+		}
+
+		// Download VSCode binary. Default to a version whose Electron the bundled
+		// Playwright can drive (the very latest "stable" can ship an Electron newer
+		// than playwright supports, making _electron.launch() hang). Override with
+		// VSCODE_TEST_VERSION (e.g. "stable" or a pinned x.y.z).
+		log("Ensuring VSCode binary is available...")
+		const vscodeVersion = process.env.VSCODE_TEST_VERSION || "1.103.0"
+		const executablePath = await downloadAndUnzipVSCode(vscodeVersion, undefined, new SilentReporter())
+		log(`VSCode binary: ${executablePath}`)
+
+		// Resolve the CLINE_DIR for the debugee (separate from debugger's ~/.cline)
+		this.clineDir = CLINE_DIR_ARG || DEFAULT_CLINE_DIR
+		fs.mkdirSync(this.clineDir, { recursive: true })
+		fs.mkdirSync(path.join(this.clineDir, "data"), { recursive: true })
+		log(`Debugee CLINE_DIR: ${this.clineDir}`)
+
+		// Clear any previously captured URLs
+		this.capturedUrls = []
+		// Also clear the captured URLs file on disk
+		const captureFile = path.join(this.clineDir, "data", "debug-captured-urls.jsonl")
+		try {
+			fs.unlinkSync(captureFile)
+		} catch {}
+
+		// Create temp user data dir to avoid interfering with real VSCode profile
+		const userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "cline-debug-profile-"))
+		log(`User data dir: ${userDataDir}`)
+
+		// Launch VSCode with Playwright
+		log("Launching VSCode...")
+		try {
+			this.app = await _electron.launch({
+				executablePath,
+				args: [
+					`--inspect-extensions=${EXT_INSPECT_PORT}`,
+					`--extensionDevelopmentPath=${PROJECT_ROOT}`,
+					"--disable-extensions",
+					"--disable-workspace-trust",
+					"--no-sandbox",
+					"--disable-updates",
+					"--skip-welcome",
+					"--skip-release-notes",
+					// Headless/VM GPU stacks crash the renderer's GPU process
+					// ("Exiting GPU process during initialization" /
+					// "CreateCommandBuffer kTransientFailure"), which can kill the window
+					// before Playwright finishes attaching and trip the launch timeout.
+					// Force software rendering for a stable debugee.
+					"--disable-gpu",
+					"--disable-gpu-compositing",
+					"--disable-software-rasterizer",
+					"--disable-dev-shm-usage",
+					`--user-data-dir=${userDataDir}`,
+					workspace,
+				],
+				env: {
+					...process.env,
+					IS_DEV: "true",
+					TEMP_PROFILE: "true",
+					DEV_WORKSPACE_FOLDER: PROJECT_ROOT,
+					CLINE_ENVIRONMENT: "production",
+					// ── Data isolation: use separate profile from user's ~/.cline ──
+					CLINE_DIR: this.clineDir,
+					// ── Browser capture: intercept openExternal() for OAuth testing unless explicitly disabled ──
+					CLINE_CAPTURE_BROWSER: BROWSER_CAPTURE ? "1" : "0",
+					CLINE_DEBUG_HARNESS_PORT: String(PORT),
+				},
+				timeout: LAUNCH_TIMEOUT_MS,
+			})
+		} catch (e: any) {
+			// Best-effort: kill the orphaned Electron so a retry isn't blocked by a
+			// half-launched instance, and so Playwright stops emitting late rejections
+			// on the dead CDP transport.
+			await this.app?.close().catch(() => {})
+			this.app = null
+			throw new Error(`Failed to launch VSCode: ${e.message}`)
+		}
+
+		// Wait for first window (firstWindow() already waits internally)
+		log("Waiting for first window...")
+		try {
+			this.page = await this.app.firstWindow()
+			log("VSCode window ready")
+		} catch (e: any) {
+			await this.app.close().catch(() => {})
+			this.app = null
+			throw new Error(`VSCode window did not appear: ${e.message}`)
+		}
+
+		// Connect to extension host inspector (Node.js CDP)
+		await this.connectExtensionCdp()
+
+		// Wait briefly for the extension to activate, then find the sidebar
+		log("Waiting for extension activation...")
+		await sleep(1000)
+
+		return {
+			status: "launched",
+			workspace,
+			extCdpConnected: this.extCdp.connected,
+			screenshotDir: SCREENSHOT_DIR,
+			clineDir: this.clineDir,
+			browserCapture: BROWSER_CAPTURE,
+		}
+	}
+
+	private async connectExtensionCdp(): Promise<void> {
+		log("Connecting to extension host inspector...")
+		const wsUrl = await this.waitForInspector(EXT_INSPECT_PORT, 30000)
+		await this.extCdp.connect(wsUrl)
+		await this.extCdp.enableDebugger()
+
+		// Wire pause events to waiters
+		this.extCdp.on("Debugger.paused", (params: any) => {
+			this.resolvePauseWaiters({ target: "extension", ...this.formatPauseInfo(params) })
+		})
+
+		log("Extension host CDP connected")
+	}
+
+	async connectWebview(): Promise<any> {
+		if (!this.page) throw new Error("VSCode not running")
+
+		// First find the sidebar frame via Playwright
+		const sidebar = await this.findSidebar()
+		if (!sidebar) return { error: "Sidebar frame not found" }
+
+		// Try creating a CDP session for the sidebar frame
+		try {
+			// Try via Playwright's newCDPSession with the frame
+			this.webCdpSession = await this.page.context().newCDPSession(sidebar as any)
+			await this.webCdpSession.send("Debugger.enable")
+			await this.webCdpSession.send("Runtime.enable")
+
+			this.webCdpSession.on("Debugger.paused", (params: any) => {
+				log("[webview] PAUSED:", params.reason)
+				this.resolvePauseWaiters({ target: "webview", ...this.formatPauseInfo(params) })
+			})
+
+			log("Webview CDP session connected via Playwright")
+			return { status: "connected", method: "playwright_cdp" }
+		} catch (e: any) {
+			log(`Playwright CDP session failed: ${e.message}`)
+			log("Webview debugging via CDP not available. Use web.evaluate for expression evaluation.")
+			return { status: "partial", method: "playwright_frame_only", note: e.message }
+		}
+	}
+
+	private async waitForInspector(port: number, timeout: number): Promise<string> {
+		const start = Date.now()
+		while (Date.now() - start < timeout) {
+			try {
+				const res = await fetch(`http://127.0.0.1:${port}/json`)
+				const targets: any[] = (await res.json()) as any[]
+				for (const t of targets) {
+					if (t.webSocketDebuggerUrl) return t.webSocketDebuggerUrl
+				}
+			} catch {}
+			await sleep(500)
+		}
+		throw new Error(`Inspector not available on port ${port} after ${timeout}ms`)
+	}
+
+	private async findSidebar(forceRefresh = false): Promise<Frame | null> {
+		// Validate cached reference - check both detached AND that it's still responsive
+		if (!forceRefresh && this.sidebarFrame && !this.sidebarFrame.isDetached()) {
+			try {
+				// Verify the frame is still alive by attempting a lightweight operation
+				await this.sidebarFrame.title()
+				return this.sidebarFrame
+			} catch {
+				// Frame reference is stale, clear and re-discover
+				this.sidebarFrame = null
+			}
+		}
+
+		this.sidebarFrame = null
+		if (!this.page) return null
+
+		const start = Date.now()
+		while (Date.now() - start < 30000) {
+			for (const frame of this.page.frames()) {
+				if (frame.isDetached()) continue
+				try {
+					const title = await frame.title()
+					if (title.startsWith("Cline")) {
+						this.sidebarFrame = frame
+						return frame
+					}
+				} catch {}
+			}
+			await sleep(500)
+		}
+		return null
+	}
+
+	async shutdown(): Promise<any> {
+		this.extCdp.close()
+		this.webCdp?.close()
+		try {
+			await this.webCdpSession?.detach()
+		} catch {}
+		this.webCdpSession = null
+		if (this.app) {
+			try {
+				await this.app.close()
+			} catch {}
+			this.app = null
+		}
+		this.page = null
+		this.sidebarFrame = null
+		this.webCdp = null
+		return { status: "shutdown" }
+	}
+
+	// ────────────────────────────────────────────
+	// Extension Host Debugging
+	// ────────────────────────────────────────────
+
+	async extSetBreakpoint(params: { file: string; line: number; column?: number; condition?: string }): Promise<any> {
+		const absPath = path.isAbsolute(params.file) ? params.file : path.resolve(PROJECT_ROOT, params.file)
+
+		// Strategy 1: If we have a sourcemap, resolve to the generated position
+		if (this.extSourceMap) {
+			const relPath = path.relative(PROJECT_ROOT, absPath)
+			// Try various path formats that esbuild might use in the sourcemap
+			const candidates = [relPath, "./" + relPath, absPath, "src/" + relPath.replace(/^src\//, "")]
+
+			for (const candidate of candidates) {
+				const pos = resolveSourceMapPosition(this.extSourceMap, candidate, params.line)
+				if (pos) {
+					log(`Sourcemap resolved: ${params.file}:${params.line} → dist/extension.js:${pos.line}:${pos.column}`)
+					const bundledUrl = `file://${path.join(PROJECT_ROOT, "dist", "extension.js")}`
+					const result = await this.extCdp.send("Debugger.setBreakpointByUrl", {
+						url: bundledUrl,
+						lineNumber: pos.line - 1,
+						columnNumber: pos.column - 1,
+						condition: params.condition || "",
+					})
+					return {
+						...result,
+						resolvedVia: "sourcemap",
+						originalFile: params.file,
+						originalLine: params.line,
+						generatedLine: pos.line,
+						generatedColumn: pos.column,
+					}
+				}
+			}
+			log(`Sourcemap: no mapping found for ${relPath}:${params.line}`)
+		}
+
+		// Strategy 2: Try setting by the original file URL directly (V8 may resolve sourcemaps)
+		const fileUrl = `file://${absPath}`
+		try {
+			const result = await this.extCdp.send("Debugger.setBreakpointByUrl", {
+				url: fileUrl,
+				lineNumber: params.line - 1,
+				columnNumber: params.column ? params.column - 1 : 0,
+				condition: params.condition || "",
+			})
+			return { ...result, resolvedVia: "direct_url" }
+		} catch (e: any) {
+			// Strategy 3: Try URL regex
+			const filename = path.basename(absPath)
+			const result = await this.extCdp.send("Debugger.setBreakpointByUrl", {
+				urlRegex: filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "$",
+				lineNumber: params.line - 1,
+				columnNumber: params.column ? params.column - 1 : 0,
+				condition: params.condition || "",
+			})
+			return { ...result, resolvedVia: "url_regex" }
+		}
+	}
+
+	async extSetBreakpointRaw(params: {
+		url?: string
+		urlRegex?: string
+		scriptId?: string
+		lineNumber: number
+		columnNumber?: number
+		condition?: string
+	}): Promise<any> {
+		if (params.scriptId) {
+			return this.extCdp.send("Debugger.setBreakpoint", {
+				location: {
+					scriptId: params.scriptId,
+					lineNumber: params.lineNumber - 1,
+					columnNumber: (params.columnNumber || 1) - 1,
+				},
+				condition: params.condition || "",
+			})
+		}
+		return this.extCdp.send("Debugger.setBreakpointByUrl", {
+			url: params.url,
+			urlRegex: params.urlRegex,
+			lineNumber: params.lineNumber - 1,
+			columnNumber: (params.columnNumber || 1) - 1,
+			condition: params.condition || "",
+		})
+	}
+
+	async extRemoveBreakpoint(params: { breakpointId: string }): Promise<void> {
+		await this.extCdp.send("Debugger.removeBreakpoint", { breakpointId: params.breakpointId })
+	}
+
+	async extEvaluate(params: { expression: string; callFrameId?: string }): Promise<any> {
+		if (params.callFrameId) {
+			return this.extCdp.send("Debugger.evaluateOnCallFrame", {
+				callFrameId: params.callFrameId,
+				expression: params.expression,
+				returnByValue: true,
+				generatePreview: true,
+			})
+		}
+		return this.extCdp.send("Runtime.evaluate", {
+			expression: params.expression,
+			returnByValue: true,
+			generatePreview: true,
+		})
+	}
+
+	async extPause(): Promise<void> {
+		await this.extCdp.send("Debugger.pause")
+	}
+	async extResume(): Promise<void> {
+		await this.extCdp.send("Debugger.resume")
+	}
+	async extStepOver(): Promise<void> {
+		await this.extCdp.send("Debugger.stepOver")
+	}
+	async extStepInto(): Promise<void> {
+		await this.extCdp.send("Debugger.stepInto")
+	}
+	async extStepOut(): Promise<void> {
+		await this.extCdp.send("Debugger.stepOut")
+	}
+
+	async extCallStack(): Promise<any> {
+		if (!this.extCdp.paused || !this.extCdp.lastPauseInfo) {
+			return { paused: false, error: "Extension host not paused" }
+		}
+		return {
+			paused: true,
+			reason: this.extCdp.lastPauseInfo.reason,
+			callFrames: this.extCdp.lastPauseInfo.callFrames?.map(formatCallFrame),
+		}
+	}
+
+	async extScripts(params: { filter?: string } = {}): Promise<any> {
+		const scripts = Array.from(this.extCdp.scripts.values())
+		const filter = params.filter?.toLowerCase()
+		const filtered = filter ? scripts.filter((s) => s.url.toLowerCase().includes(filter)) : scripts
+		return {
+			total: scripts.length,
+			shown: filtered.length,
+			scripts: filtered.slice(0, 100).map((s) => ({
+				scriptId: s.scriptId,
+				url: s.url,
+				hasSourceMap: !!s.sourceMapURL,
+			})),
+		}
+	}
+
+	async extSourceFiles(): Promise<any> {
+		if (!this.extSourceMap) {
+			return { error: "No sourcemap loaded. Build without --skip-build to generate sourcemaps." }
+		}
+		return {
+			sourceRoot: this.extSourceMap.sourceRoot || "",
+			files: listSourceMapFiles(this.extSourceMap),
+		}
+	}
+
+	async extGetProperties(params: { objectId: string; ownProperties?: boolean }): Promise<any> {
+		return this.extCdp.send("Runtime.getProperties", {
+			objectId: params.objectId,
+			ownProperties: params.ownProperties !== false,
+			generatePreview: true,
+		})
+	}
+
+	async extGetScriptSource(params: { scriptId: string }): Promise<any> {
+		return this.extCdp.send("Debugger.getScriptSource", { scriptId: params.scriptId })
+	}
+
+	// ────────────────────────────────────────────
+	// Webview Debugging
+	// ────────────────────────────────────────────
+
+	private getWebCdp(): CDPSession {
+		if (!this.webCdpSession) throw new Error("Webview CDP not connected. Call connect_webview first.")
+		return this.webCdpSession
+	}
+
+	async webSetBreakpoint(params: { url: string; line: number; column?: number; condition?: string }): Promise<any> {
+		return this.getWebCdp().send("Debugger.setBreakpointByUrl", {
+			urlRegex: params.url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+			lineNumber: params.line - 1,
+			columnNumber: params.column ? params.column - 1 : 0,
+			condition: params.condition || "",
+		})
+	}
+
+	async webRemoveBreakpoint(params: { breakpointId: string }): Promise<void> {
+		await this.getWebCdp().send("Debugger.removeBreakpoint", { breakpointId: params.breakpointId })
+	}
+
+	async webEvaluate(params: { expression: string; callFrameId?: string }): Promise<any> {
+		// For simple evaluation without breakpoints, use Playwright frame.evaluate
+		if (!params.callFrameId) {
+			const sidebar = await this.findSidebar()
+			if (sidebar) {
+				try {
+					const result = await sidebar.evaluate((expr: string) => {
+						return Function(`return (${expr})`)()
+					}, params.expression)
+					return { result: { type: typeof result, value: result } }
+				} catch (e: any) {
+					return { error: e.message }
+				}
+			}
+		}
+		// For evaluation at a breakpoint, use CDP
+		if (params.callFrameId) {
+			return this.getWebCdp().send("Debugger.evaluateOnCallFrame", {
+				callFrameId: params.callFrameId,
+				expression: params.expression,
+				returnByValue: true,
+				generatePreview: true,
+			})
+		}
+		return this.getWebCdp().send("Runtime.evaluate", {
+			expression: params.expression,
+			returnByValue: true,
+			generatePreview: true,
+		})
+	}
+
+	/**
+	 * Send a postMessage to the extension host via the webview's exposed vsCodeApi.
+	 * The vsCodeApi is exposed on window.__clineVsCodeApi by platform.config.ts.
+	 * This works even though acquireVsCodeApi() can only be called once.
+	 */
+	async webPostMessage(params: { message: any }): Promise<any> {
+		const sidebar = await this.findSidebar()
+		if (!sidebar) throw new Error("Sidebar not found")
+		try {
+			const result = await sidebar.evaluate((msg: any) => {
+				const api = (window as any).__clineVsCodeApi
+				if (!api) {
+					throw new Error(
+						"window.__clineVsCodeApi not found. " +
+							"The webview may not have loaded yet, or the extension was built without the debug bridge.",
+					)
+				}
+				api.postMessage(msg)
+				return { sent: true }
+			}, params.message)
+			return result
+		} catch (e: any) {
+			return { error: e.message }
+		}
+	}
+
+	async webPause(): Promise<void> {
+		await this.getWebCdp().send("Debugger.pause")
+	}
+	async webResume(): Promise<void> {
+		await this.getWebCdp().send("Debugger.resume")
+	}
+	async webStepOver(): Promise<void> {
+		await this.getWebCdp().send("Debugger.stepOver")
+	}
+	async webStepInto(): Promise<void> {
+		await this.getWebCdp().send("Debugger.stepInto")
+	}
+	async webStepOut(): Promise<void> {
+		await this.getWebCdp().send("Debugger.stepOut")
+	}
+
+	// ────────────────────────────────────────────
+	// UI Automation
+	// ────────────────────────────────────────────
+
+	async uiScreenshot(params: { fullPage?: boolean } = {}): Promise<any> {
+		if (!this.page) throw new Error("VSCode not running")
+		this.screenshotCounter++
+		const filePath = path.join(SCREENSHOT_DIR, `screenshot-${String(this.screenshotCounter).padStart(4, "0")}.png`)
+		await this.page.screenshot({ path: filePath, fullPage: params.fullPage })
+		log(`Screenshot saved: ${filePath}`)
+		return { path: filePath, counter: this.screenshotCounter }
+	}
+
+	async uiSidebarScreenshot(): Promise<any> {
+		const sidebar = await this.findSidebar()
+		if (!sidebar) throw new Error("Sidebar not found")
+		this.screenshotCounter++
+		const filePath = path.join(SCREENSHOT_DIR, `sidebar-${String(this.screenshotCounter).padStart(4, "0")}.png`)
+		// Take a full page screenshot - frame-level screenshots might not work on webviews
+		if (this.page) {
+			await this.page.screenshot({ path: filePath })
+		}
+		return { path: filePath, counter: this.screenshotCounter }
+	}
+
+	async uiClick(params: { selector: string; frame?: string; delay?: number }): Promise<void> {
+		const target = await this.getTarget(params.frame)
+		await target.click(params.selector, { delay: params.delay })
+	}
+
+	async uiFill(params: { selector: string; text: string; frame?: string }): Promise<void> {
+		const target = await this.getTarget(params.frame)
+		await target.fill(params.selector, params.text)
+	}
+
+	async uiPress(params: { key: string }): Promise<void> {
+		if (!this.page) throw new Error("VSCode not running")
+		await this.page.keyboard.press(params.key)
+	}
+
+	async uiType(params: { text: string; delay?: number }): Promise<void> {
+		if (!this.page) throw new Error("VSCode not running")
+		await this.page.keyboard.type(params.text, { delay: params.delay })
+	}
+
+	async uiOpenSidebar(): Promise<any> {
+		if (!this.page) throw new Error("VSCode not running")
+		try {
+			await this.page.getByRole("tab", { name: /Cline/ }).locator("a").click()
+		} catch {
+			// Activity bar might need a different approach
+			await this.page.keyboard.press("Meta+Shift+p")
+			await sleep(300)
+			await this.page.keyboard.type("Cline: Focus on Cline View")
+			await sleep(200)
+			await this.page.keyboard.press("Enter")
+		}
+		const sidebar = await this.findSidebar()
+		return { found: !!sidebar }
+	}
+
+	async uiFrames(): Promise<any> {
+		if (!this.page) throw new Error("VSCode not running")
+		const frames: { name: string; url: string; title: string; detached: boolean }[] = []
+		for (const f of this.page.frames()) {
+			try {
+				frames.push({
+					name: f.name(),
+					url: f.url(),
+					title: await f.title().catch(() => ""),
+					detached: f.isDetached(),
+				})
+			} catch {}
+		}
+		return { frames }
+	}
+
+	async uiWaitForSelector(params: { selector: string; frame?: string; timeout?: number }): Promise<void> {
+		const target = await this.getTarget(params.frame)
+		await target.waitForSelector(params.selector, { timeout: params.timeout || 10000 })
+	}
+
+	async uiCommandPalette(params: { command: string }): Promise<void> {
+		if (!this.page) throw new Error("VSCode not running")
+		await this.page.keyboard.press("Meta+Shift+p")
+		await sleep(500)
+		await this.page.keyboard.type(params.command)
+		await sleep(300)
+		await this.page.keyboard.press("Enter")
+	}
+
+	async uiGetText(params: { selector: string; frame?: string }): Promise<any> {
+		const target = await this.getTarget(params.frame)
+		const text = await target.textContent(params.selector)
+		return { text }
+	}
+
+	/**
+	 * Set text in a React-controlled textarea using execCommand('insertText').
+	 * This fires real InputEvent/input events that React's onChange handler processes,
+	 * unlike Playwright's fill() or nativeInputValueSetter which bypass React's
+	 * synthetic event system and fail after the first task.
+	 *
+	 * Params:
+	 *   selector - CSS selector for the textarea (default: '[data-testid="chat-input"]')
+	 *   text     - Text to insert
+	 *   clear    - Whether to clear existing content first (default: true)
+	 *   submit   - Whether to press Enter after typing (default: false)
+	 */
+	async uiReactInput(params: { selector?: string; text: string; clear?: boolean; submit?: boolean }): Promise<any> {
+		const sidebar = await this.findSidebar()
+		if (!sidebar) throw new Error("Sidebar not found")
+
+		const selector = params.selector || '[data-testid="chat-input"]'
+		const clear = params.clear !== false
+		const text = params.text
+
+		const result = await sidebar.evaluate(
+			({ selector, text, clear }: { selector: string; text: string; clear: boolean }) => {
+				const el = document.querySelector(selector) as HTMLTextAreaElement | null
+				if (!el) throw new Error(`Element not found: ${selector}`)
+
+				// Focus the element
+				el.focus()
+
+				// Clear existing content if requested
+				if (clear && el.value.length > 0) {
+					// Select all text and delete it
+					el.setSelectionRange(0, el.value.length)
+					document.execCommand("delete", false)
+				}
+
+				// Insert new text using execCommand which fires proper InputEvents
+				// that React's synthetic event system handles correctly
+				document.execCommand("insertText", false, text)
+
+				return { value: el.value, length: el.value.length }
+			},
+			{ selector, text, clear },
+		)
+
+		// Optionally submit by pressing Enter
+		if (params.submit && this.page) {
+			// Brief pause to let React process the input event
+			await sleep(100)
+			await this.page.keyboard.press("Enter")
+		}
+
+		return { ...result, submitted: !!params.submit }
+	}
+
+	/**
+	 * Send a chat message by directly invoking the webview's gRPC client.
+	 * This completely bypasses the textarea, avoiding all React state issues.
+	 * Works reliably regardless of how many tasks have been completed.
+	 *
+	 * For new tasks (no active conversation), sends via TaskServiceClient.newTask().
+	 * For active conversations, sends via TaskServiceClient.askResponse().
+	 */
+	async uiSendMessage(params: { text: string; images?: string[]; files?: string[]; responseType?: string }): Promise<any> {
+		const sidebar = await this.findSidebar()
+		if (!sidebar) throw new Error("Sidebar not found")
+
+		return sidebar.evaluate(
+			({
+				text,
+				images,
+				files,
+				responseType,
+			}: {
+				text: string
+				images: string[]
+				files: string[]
+				responseType?: string
+			}) => {
+				const api = (window as any).__clineVsCodeApi
+				if (!api) {
+					throw new Error("window.__clineVsCodeApi not found")
+				}
+
+				// Send as a gRPC request via postMessage, which the extension host
+				// processes through its ProtoBus handler. This is the same mechanism
+				// the webview uses internally.
+				if (responseType) {
+					// Responding to an ask (followup, resume, etc.)
+					api.postMessage({
+						type: "grpc_request",
+						grpc_request: {
+							service: "cline.TaskService",
+							method: "askResponse",
+							message: { responseType, text, images, files },
+							request_id: `debug-${Date.now()}`,
+							is_streaming: false,
+						},
+					})
+				} else {
+					// New task
+					api.postMessage({
+						type: "grpc_request",
+						grpc_request: {
+							service: "cline.TaskService",
+							method: "newTask",
+							message: { text, images, files },
+							request_id: `debug-${Date.now()}`,
+							is_streaming: false,
+						},
+					})
+				}
+
+				return { sent: true, method: responseType ? "askResponse" : "newTask" }
+			},
+			{
+				text: params.text,
+				images: params.images || [],
+				files: params.files || [],
+				responseType: params.responseType,
+			},
+		)
+	}
+
+	async uiLocator(params: {
+		role?: string
+		name?: string
+		testId?: string
+		text?: string
+		frame?: string
+		action?: "click" | "fill" | "text" | "visible" | "count"
+		value?: string
+	}): Promise<any> {
+		// Retry with frame re-discovery on failure for sidebar targets
+		const maxRetries = params.frame === "sidebar" ? 2 : 1
+		let lastError: Error | null = null
+
+		for (let attempt = 0; attempt < maxRetries; attempt++) {
+			try {
+				const forceRefresh = attempt > 0
+				const target = await this.getTarget(params.frame, forceRefresh)
+				let locator
+				if (params.testId) {
+					locator = target.getByTestId(params.testId)
+				} else if (params.role) {
+					locator = target.getByRole(params.role as any, params.name ? { name: params.name } : undefined)
+				} else if (params.text) {
+					locator = target.getByText(params.text)
+				} else {
+					throw new Error("Provide role, testId, or text")
+				}
+
+				switch (params.action) {
+					case "click":
+						await locator.click()
+						return { done: true }
+					case "fill":
+						await locator.fill(params.value || "")
+						return { done: true }
+					case "text":
+						return { text: await locator.textContent() }
+					case "visible":
+						return { visible: await locator.isVisible() }
+					case "count":
+						return { count: await locator.count() }
+					default:
+						return { visible: await locator.isVisible(), count: await locator.count() }
+				}
+			} catch (e: any) {
+				lastError = e
+				if (attempt < maxRetries - 1) {
+					log(`ui.locator attempt ${attempt + 1} failed (${e.message}), retrying with frame refresh...`)
+					this.sidebarFrame = null // Force re-discovery
+					await sleep(500)
+				}
+			}
+		}
+
+		throw lastError || new Error("ui.locator failed")
+	}
+
+	private async getTarget(frame?: string, forceRefresh = false): Promise<Page | Frame> {
+		if (!this.page) throw new Error("VSCode not running")
+		if (frame === "sidebar") {
+			const sb = await this.findSidebar(forceRefresh)
+			if (!sb) throw new Error("Sidebar not found")
+			return sb
+		}
+		return this.page
+	}
+
+	// ────────────────────────────────────────────
+	// Combined
+	// ────────────────────────────────────────────
+
+	async waitForPause(params: { timeout?: number } = {}): Promise<any> {
+		const timeout = params.timeout || 30000
+
+		// Check if already paused
+		if (this.extCdp.paused && this.extCdp.lastPauseInfo) {
+			return { target: "extension", ...this.formatPauseInfo(this.extCdp.lastPauseInfo) }
+		}
+
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pauseWaiters = this.pauseWaiters.filter((w) => w.timer !== timer)
+				reject(new Error(`wait_for_pause timed out after ${timeout}ms`))
+			}, timeout)
+
+			this.pauseWaiters.push({ resolve, timer })
+		})
+	}
+
+	private resolvePauseWaiters(info: any): void {
+		const waiters = this.pauseWaiters
+		this.pauseWaiters = []
+		for (const w of waiters) {
+			clearTimeout(w.timer)
+			w.resolve(info)
+		}
+	}
+
+	async status(): Promise<any> {
+		return {
+			running: !!this.app,
+			extCdpConnected: this.extCdp.connected,
+			extPaused: this.extCdp.paused,
+			extScriptsLoaded: this.extCdp.scripts.size,
+			webCdpConnected: !!this.webCdpSession,
+			sidebarFound: !!this.sidebarFrame && !this.sidebarFrame.isDetached(),
+			hasSourceMap: !!this.extSourceMap,
+			sourceMapFiles: this.extSourceMap?.sources.length || 0,
+			screenshotDir: SCREENSHOT_DIR,
+			projectRoot: PROJECT_ROOT,
+			clineDir: this.clineDir,
+			capturedUrls: this.capturedUrls.length,
+		}
+	}
+
+	// ────────────────────────────────────────────
+	// OAuth & Browser Capture
+	// ────────────────────────────────────────────
+
+	/**
+	 * Get URLs that the debugee tried to open in a browser (captured by
+	 * CLINE_CAPTURE_BROWSER). Each entry has a timestamp and URL.
+	 * Use this to inspect OAuth authorization URLs that were intercepted.
+	 *
+	 * Params:
+	 *   clear - Whether to clear the list after reading (default: false)
+	 */
+	oauthCapturedUrls(params: { clear?: boolean } = {}): any {
+		const urls = [...this.capturedUrls]
+		if (params.clear) this.capturedUrls = []
+		return { urls, count: urls.length }
+	}
+
+	/**
+	 * Read stored auth tokens from the debugee's secrets.json.
+	 * Useful for verifying that an OAuth flow successfully persisted tokens.
+	 */
+	oauthReadStoredToken(): any {
+		const secretsFile = path.join(this.clineDir, "data", "secrets.json")
+		if (!fs.existsSync(secretsFile)) {
+			return { found: false, path: secretsFile }
+		}
+		try {
+			const data = JSON.parse(fs.readFileSync(secretsFile, "utf-8"))
+			// Extract the Cline account ID and related auth info
+			const accountId = data["cline:clineAccountId"]
+			const mcpOAuth = data["mcpOAuthSecrets"]
+			return {
+				found: true,
+				path: secretsFile,
+				hasAccountId: !!accountId,
+				hasMcpOAuth: !!mcpOAuth,
+				// Don't return full token values for safety, just presence indicators
+				keys: Object.keys(data),
+			}
+		} catch (e: any) {
+			return { found: true, path: secretsFile, error: e.message }
+		}
+	}
+
+	/**
+	 * Simulate an OAuth callback by constructing a vscode:// URI and
+	 * injecting it into the debugee's extension host. This bypasses the
+	 * browser entirely — use with oauth.captured_urls to get the redirect
+	 * parameters from the captured authorization URL.
+	 *
+	 * For Cline OAuth: the SDK's local callback server captures the code
+	 * automatically. Use this ONLY for provider-specific callbacks (OpenRouter,
+	 * MCP, etc.) that use the vscode:// URI scheme.
+	 *
+	 * Params:
+	 *   path     - URI path (e.g., "/auth", "/openrouter", "/mcp-auth/callback/HASH")
+	 *   code     - Authorization code from the OAuth provider
+	 *   state    - OAuth state parameter (for MCP/OCA)
+	 *   provider - Provider name for /auth path (e.g., "cline", "oca")
+	 *   token    - Direct token for /auth path (overrides code)
+	 */
+	async oauthSimulateCallback(params: {
+		path: string
+		code?: string
+		state?: string
+		provider?: string
+		token?: string
+	}): Promise<any> {
+		if (!this.app) throw new Error("VSCode not running")
+
+		// Build the URI
+		const extensionId = "saoudrizwan.claude-dev"
+		const scheme = "vscode"
+		const searchParams = new URLSearchParams()
+		if (params.code) searchParams.set("code", params.code)
+		if (params.state) searchParams.set("state", params.state)
+		if (params.provider) searchParams.set("provider", params.provider)
+		if (params.token) {
+			// For /auth path, the extension reads refreshToken, idToken, or code
+			searchParams.set("refreshToken", params.token)
+		}
+		const queryString = searchParams.toString()
+		const uri = `${scheme}://${extensionId}${params.path}${queryString ? "?" + queryString : ""}`
+
+		log(`Simulating OAuth callback URI: ${uri}`)
+
+		// Use CDP to evaluate the URI handler in the extension host.
+		// This is equivalent to the browser redirecting to the vscode:// URI.
+		try {
+			// Method 1: Use the extension host's Runtime.evaluate to trigger the URI handler
+			const result = await this.extCdp.send("Runtime.evaluate", {
+				expression: `
+					(() => {
+						// The extension registers a URI handler via vscode.window.registerUriHandler.
+						// We can trigger it by dispatching a custom event or by calling
+						// the handler directly. However, the URI handler is managed by VSCode,
+						// so we need to use VSCode's command to open the URI.
+						//
+						// The most reliable way is to use the 'vscode.open' command,
+						// but that opens a browser. Instead, we can directly call the
+						// SharedUriHandler which is imported in extension.ts.
+						//
+						// For now, we'll note the URI and the agent should use
+						// ui.command_palette with "Cline: Handle URI" or similar.
+						return ${JSON.stringify(uri)}
+					})()
+				`,
+				returnByValue: true,
+			})
+
+			// Method 2: Use Playwright to navigate via the command palette
+			// We'll open the URI by typing it into VSCode's command palette
+			// Actually, the simplest way is to emit the URI event via the electron app
+			// _electron doesn't expose a direct URI handler, but we can use the window
+
+			return {
+				uri,
+				note:
+					"URI constructed. For callbacks that use the vscode:// scheme, " +
+					"you need to trigger the extension's URI handler. Options:\n" +
+					"1. For Cline OAuth (SDK local callback): the SDK captures the code " +
+					"automatically from its local HTTP server — no simulation needed.\n" +
+					"2. For MCP/provider OAuth: use 'ext.evaluate' to call " +
+					"SharedUriHandler.handleUri() directly, or use the command palette.",
+			}
+		} catch (e: any) {
+			return { uri, error: e.message }
+		}
+	}
+
+	/**
+	 * Read the captured URLs JSONL file from the debugee's CLINE_DIR.
+	 * This is the on-disk log of all URLs that openExternal() captured.
+	 * Use this if the real-time POST to /captured-url was missed.
+	 */
+	oauthReadCapturedUrlsFile(): any {
+		const captureFile = path.join(this.clineDir, "data", "debug-captured-urls.jsonl")
+		if (!fs.existsSync(captureFile)) {
+			return { found: false, path: captureFile }
+		}
+		try {
+			const content = fs.readFileSync(captureFile, "utf-8")
+			const entries = content
+				.trim()
+				.split("\n")
+				.filter((l) => l.trim())
+				.map((l) => JSON.parse(l))
+			return { found: true, path: captureFile, urls: entries, count: entries.length }
+		} catch (e: any) {
+			return { found: true, path: captureFile, error: e.message }
+		}
+	}
+
+	// ────────────────────────────────────────────
+	// Helpers
+	// ────────────────────────────────────────────
+
+	private formatPauseInfo(params: any): any {
+		return {
+			reason: params.reason,
+			hitBreakpoints: params.hitBreakpoints,
+			callFrames: params.callFrames?.slice(0, 10).map(formatCallFrame),
+		}
+	}
+
+	// ────────────────────────────────────────────
+	// Command Dispatch
+	// ────────────────────────────────────────────
+
+	async handleCommand(method: string, params: any): Promise<any> {
+		switch (method) {
+			// Lifecycle
+			case "launch":
+				return this.launch(params)
+			case "shutdown":
+				return this.shutdown()
+			case "status":
+				return this.status()
+			case "connect_webview":
+				return this.connectWebview()
+
+			// Extension host debugging
+			case "ext.set_breakpoint":
+				return this.extSetBreakpoint(params)
+			case "ext.set_breakpoint_raw":
+				return this.extSetBreakpointRaw(params)
+			case "ext.remove_breakpoint":
+				return this.extRemoveBreakpoint(params)
+			case "ext.evaluate":
+				return this.extEvaluate(params)
+			case "ext.pause":
+				return this.extPause()
+			case "ext.resume":
+				return this.extResume()
+			case "ext.step_over":
+				return this.extStepOver()
+			case "ext.step_into":
+				return this.extStepInto()
+			case "ext.step_out":
+				return this.extStepOut()
+			case "ext.call_stack":
+				return this.extCallStack()
+			case "ext.scripts":
+				return this.extScripts(params)
+			case "ext.source_files":
+				return this.extSourceFiles()
+			case "ext.get_properties":
+				return this.extGetProperties(params)
+			case "ext.get_script_source":
+				return this.extGetScriptSource(params)
+
+			// Webview debugging
+			case "web.set_breakpoint":
+				return this.webSetBreakpoint(params)
+			case "web.remove_breakpoint":
+				return this.webRemoveBreakpoint(params)
+			case "web.evaluate":
+				return this.webEvaluate(params)
+			case "web.post_message":
+				return this.webPostMessage(params)
+			case "web.pause":
+				return this.webPause()
+			case "web.resume":
+				return this.webResume()
+			case "web.step_over":
+				return this.webStepOver()
+			case "web.step_into":
+				return this.webStepInto()
+			case "web.step_out":
+				return this.webStepOut()
+
+			// UI automation
+			case "ui.screenshot":
+				return this.uiScreenshot(params)
+			case "ui.sidebar_screenshot":
+				return this.uiSidebarScreenshot()
+			case "ui.click":
+				return this.uiClick(params)
+			case "ui.fill":
+				return this.uiFill(params)
+			case "ui.press":
+				return this.uiPress(params)
+			case "ui.type":
+				return this.uiType(params)
+			case "ui.open_sidebar":
+				return this.uiOpenSidebar()
+			case "ui.frames":
+				return this.uiFrames()
+			case "ui.wait_for_selector":
+				return this.uiWaitForSelector(params)
+			case "ui.command_palette":
+				return this.uiCommandPalette(params)
+			case "ui.get_text":
+				return this.uiGetText(params)
+			case "ui.locator":
+				return this.uiLocator(params)
+			case "ui.react_input":
+				return this.uiReactInput(params)
+			case "ui.send_message":
+				return this.uiSendMessage(params)
+
+			// OAuth & Browser Capture
+			case "oauth.captured_urls":
+				return this.oauthCapturedUrls(params)
+			case "oauth.read_stored_token":
+				return this.oauthReadStoredToken()
+			case "oauth.simulate_callback":
+				return this.oauthSimulateCallback(params)
+			case "oauth.read_captured_urls_file":
+				return this.oauthReadCapturedUrlsFile()
+
+			// Combined
+			case "wait_for_pause":
+				return this.waitForPause(params)
+
+			default:
+				throw new Error(`Unknown method: ${method}`)
+		}
+	}
+}
+
+// ============================================================
+// Utilities
+// ============================================================
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((r) => setTimeout(r, ms))
+}
+
+async function waitUntil(pred: () => boolean, timeout: number, label: string): Promise<void> {
+	const start = Date.now()
+	while (!pred()) {
+		if (Date.now() - start > timeout) throw new Error(`Timed out waiting for ${label}`)
+		await sleep(200)
+	}
+}
+
+function formatCallFrame(f: any): any {
+	return {
+		callFrameId: f.callFrameId,
+		functionName: f.functionName || "(anonymous)",
+		url: f.url,
+		lineNumber: (f.location?.lineNumber ?? f.lineNumber ?? -1) + 1,
+		columnNumber: (f.location?.columnNumber ?? f.columnNumber ?? -1) + 1,
+		scopeChain: f.scopeChain?.map((s: any) => ({
+			type: s.type,
+			name: s.name,
+		})),
+	}
+}
+
+function log(...args: any[]): void {
+	const ts = new Date().toISOString().slice(11, 23)
+	console.log(`[${ts}]`, ...args)
+}
+
+// ============================================================
+// HTTP Server
+// ============================================================
+
+async function readBody(req: http.IncomingMessage): Promise<string> {
+	const chunks: Buffer[] = []
+	for await (const chunk of req) chunks.push(chunk as Buffer)
+	return Buffer.concat(chunks).toString()
+}
+
+const harness = new DebugHarness()
+
+const server = http.createServer(async (req, res) => {
+	res.setHeader("Access-Control-Allow-Origin", "*")
+	res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+	res.setHeader("Access-Control-Allow-Headers", "Content-Type")
+
+	if (req.method === "OPTIONS") {
+		res.writeHead(204)
+		res.end()
+		return
+	}
+
+	if (req.method === "GET" && req.url === "/health") {
+		res.writeHead(200, { "Content-Type": "application/json" })
+		res.end(JSON.stringify({ status: "ok", port: PORT }))
+		return
+	}
+
+	if (req.method === "GET" && req.url === "/status") {
+		try {
+			const status = await harness.handleCommand("status", {})
+			res.writeHead(200, { "Content-Type": "application/json" })
+			res.end(JSON.stringify(status, null, 2))
+		} catch (e: any) {
+			res.writeHead(500, { "Content-Type": "application/json" })
+			res.end(JSON.stringify({ error: e.message }))
+		}
+		return
+	}
+
+	// Endpoint for captured browser URLs (posted by the debugee's openExternal interception)
+	if (req.method === "POST" && req.url === "/captured-url") {
+		try {
+			const body = await readBody(req)
+			const entry = JSON.parse(body)
+			if (entry.url) {
+				harness["capturedUrls"].push({ timestamp: entry.timestamp || Date.now(), url: entry.url })
+				log(`[CaptureBrowser] Received URL: ${entry.url.slice(0, 120)}...`)
+			}
+			res.writeHead(200, { "Content-Type": "application/json" })
+			res.end(JSON.stringify({ captured: true }))
+		} catch (e: any) {
+			res.writeHead(400, { "Content-Type": "application/json" })
+			res.end(JSON.stringify({ error: e.message }))
+		}
+		return
+	}
+
+	if (req.method === "POST" && req.url === "/api") {
+		const startTime = Date.now()
+		try {
+			const body = await readBody(req)
+			const { method, params } = JSON.parse(body)
+			log(`→ ${method}`, params ? JSON.stringify(params).slice(0, 200) : "")
+			const result = await harness.handleCommand(method, params || {})
+			const elapsed = Date.now() - startTime
+			log(`← ${method} (${elapsed}ms)`)
+			res.writeHead(200, { "Content-Type": "application/json" })
+			res.end(JSON.stringify({ result }, null, 2))
+		} catch (e: any) {
+			const elapsed = Date.now() - startTime
+			log(`✘ (${elapsed}ms)`, e.message)
+			res.writeHead(500, { "Content-Type": "application/json" })
+			res.end(JSON.stringify({ error: e.message, stack: e.stack?.split("\n").slice(0, 5) }))
+		}
+		return
+	}
+
+	res.writeHead(404, { "Content-Type": "text/plain" })
+	res.end("Not found. Use POST /api or GET /health")
+})
+
+server.listen(PORT, "127.0.0.1", () => {
+	log(`Debug harness server listening on http://localhost:${PORT}`)
+	log(``)
+	log(`Quick start:`)
+	log(`  curl localhost:${PORT}/api -d '{"method":"launch"}'`)
+	log(`  curl localhost:${PORT}/api -d '{"method":"ui.open_sidebar"}'`)
+	log(`  curl localhost:${PORT}/api -d '{"method":"ui.screenshot"}'`)
+	log(`  curl localhost:${PORT}/api -d '{"method":"ext.set_breakpoint","params":{"file":"src/extension.ts","line":42}}'`)
+	log(`  curl localhost:${PORT}/api -d '{"method":"status"}'`)
+	log(``)
+
+	if (AUTO_LAUNCH) {
+		harness
+			.launch({
+				workspace: WORKSPACE_ARG || DEFAULT_WORKSPACE,
+				skipBuild: SKIP_BUILD,
+			})
+			.then((r) => log("Auto-launch complete:", r))
+			.catch((e: Error) => log("Auto-launch failed:", e.message))
+	}
+})
+
+// Graceful shutdown
+async function cleanShutdown() {
+	log("Shutting down...")
+	await harness.shutdown().catch(() => {})
+	server.close()
+	process.exit(0)
+}
+process.on("SIGINT", cleanShutdown)
+process.on("SIGTERM", cleanShutdown)
+
+// Keep the harness alive on stray async errors. A failed/aborted VSCode launch
+// (e.g. Playwright's _electron.launch timing out) can emit a late rejection on
+// the dead CDP transport AFTER we've already handled the launch error; without
+// this, the default behavior would crash the whole server and you'd have to
+// restart it just to retry. Log and keep serving so `launch` can be retried.
+process.on("unhandledRejection", (reason: unknown) => {
+	log("Unhandled rejection (ignored, server stays up):", reason instanceof Error ? reason.message : String(reason))
+})
+process.on("uncaughtException", (err: Error) => {
+	log("Uncaught exception (ignored, server stays up):", err.message)
+})
diff --git a/apps/vscode/src/dev/grit/console-log.grit b/apps/vscode/src/dev/grit/console-log.grit
new file mode 100644
index 0000000..3417725
--- /dev/null
+++ b/apps/vscode/src/dev/grit/console-log.grit
@@ -0,0 +1,4 @@
+`$fn($args)` where {
+	or { $fn <: `console.log`, $fn <: `console.debug`, $fn <: `console.error`, $fn <: `console.warn`, $fn <: `console.info` },
+	register_diagnostic(span=$fn, message="Use Logger service instead of direct console calls.")
+}
diff --git a/apps/vscode/src/dev/grit/process-env.grit b/apps/vscode/src/dev/grit/process-env.grit
new file mode 100644
index 0000000..db283cd
--- /dev/null
+++ b/apps/vscode/src/dev/grit/process-env.grit
@@ -0,0 +1,3 @@
+`const { $vars } = process.env` where {
+	register_diagnostic(span=$vars, message="Use process.env.VARIABLE_NAME directly instead of destructuring.")
+}
diff --git a/apps/vscode/src/dev/grit/use-cache-service.grit b/apps/vscode/src/dev/grit/use-cache-service.grit
new file mode 100644
index 0000000..63a224b
--- /dev/null
+++ b/apps/vscode/src/dev/grit/use-cache-service.grit
@@ -0,0 +1,12 @@
+`$fn($args)` where {
+	or {
+		$fn <: `context.globalState.get`,
+		$fn <: `context.globalState.update`,
+		$fn <: `context.workspaceState.get`,
+		$fn <: `context.workspaceState.update`,
+		$fn <: `context.secrets.get`,
+		$fn <: `context.secrets.store`,
+		$fn <: `context.secrets.delete`
+	},
+	register_diagnostic(span=$fn, message="Use CacheService instead.")
+}
diff --git a/apps/vscode/src/dev/grit/vscode-api.grit b/apps/vscode/src/dev/grit/vscode-api.grit
new file mode 100644
index 0000000..bec0d0e
--- /dev/null
+++ b/apps/vscode/src/dev/grit/vscode-api.grit
@@ -0,0 +1,117 @@
+or {
+	`$fn($args)` where {
+		or {
+			// File system operations
+			$fn <: `vscode.workspace.fs.stat`,
+			$fn <: `vscode.workspace.fs.writeFile`,
+			// Workspace operations
+			$fn <: `vscode.workspace.asRelativePath`,
+			$fn <: `vscode.workspace.getWorkspaceFolder`,
+			$fn <: `vscode.workspace.applyEdit`,
+			$fn <: `vscode.workspace.findFiles`,
+			$fn <: `vscode.workspace.openTextDocument`,
+			$fn <: `vscode.workspace.createFileSystemWatcher`,
+			$fn <: `vscode.workspace.onDidCreateFiles`,
+			$fn <: `vscode.workspace.onDidDeleteFiles`,
+			$fn <: `vscode.workspace.onDidRenameFiles`,
+			$fn <: `vscode.workspace.registerTextDocumentContentProvider`,
+			// Window operations
+			$fn <: `vscode.window.showTextDocument`,
+			$fn <: `vscode.window.onDidChangeActiveTextEditor`,
+			$fn <: `vscode.window.showErrorMessage`,
+			$fn <: `vscode.window.showInformationMessage`,
+			$fn <: `vscode.window.showWarningMessage`,
+			$fn <: `vscode.window.showInputBox`,
+			$fn <: `vscode.window.showOpenDialog`,
+			$fn <: `vscode.window.showSaveDialog`,
+			$fn <: `vscode.window.createTextEditorDecorationType`,
+			$fn <: `vscode.window.createOutputChannel`,
+			$fn <: `vscode.window.createWebviewPanel`,
+			$fn <: `vscode.window.registerWebviewViewProvider`,
+			$fn <: `vscode.window.registerUriHandler`,
+			//$fn <: `vscode.window.withProgress`,
+
+			// Environment operations
+			$fn <: `vscode.env.openExternal`,
+			$fn <: `vscode.env.clipboard.readText`,
+			$fn <: `vscode.env.clipboard.writeText`,
+			// Language operations
+			$fn <: `vscode.languages.onDidChangeDiagnostics`,
+			$fn <: `vscode.languages.registerCodeActionsProvider`,
+			$fn <: `vscode.languages.getDiagnostics`,
+			//$fn <: `vscode.lm.selectChatModels`,
+
+			// Debug operations
+			$fn <: `vscode.debug.onDidStartDebugSession`,
+			$fn <: `vscode.debug.onDidTerminateDebugSession`,
+			// Command operations
+			$fn <: `vscode.commands.registerCommand`,
+			// Note: executeCommand is handled separately with allowlist below
+
+			// Extension operations
+			$fn <: `vscode.extensions.getExtension`,
+			// Other operations
+			$fn <: `vscode.diff`,
+			//$fn <: `vscode.postMessage`,
+			$fn <: `vscode.Uri`,
+			// Text document operations
+			$fn <: `TextDocument.save`,
+			// Tab group operations
+			$fn <: `vscode.window.tabGroups.close`,
+			$fn <: `vscode.window.tabGroups.onDidChangeTabs`,
+			// Workspace text documents
+			$fn <: `vscode.workspace.textDocuments.find`
+		},
+		register_diagnostic(span=$fn, message="Replace this with methods from the host bridge provider or appropriate abstraction layer.")
+	},
+	// Block new vscode.commands.executeCommand usage (with allowlist for existing usage)
+	// This pattern matches executeCommand with any number of arguments using the spread operator
+	`vscode.commands.executeCommand($command, $...$args)` where {
+		not or {
+			// Allowed existing command strings
+			$command <: `"workbench.action.terminal.focus"`
+		},
+		register_diagnostic(span=$command, message="New usage of vscode.commands.executeCommand is not allowed. Replace this with methods from the host bridge provider.")
+	},
+	// Also handle executeCommand calls with no additional arguments
+	`vscode.commands.executeCommand($command)` where {
+		not or {
+			// Allowed existing command strings (single argument version)
+			$command <: `"workbench.action.terminal.focus"`
+		},
+		register_diagnostic(span=$command, message="New usage of vscode.commands.executeCommand is not allowed. Replace this with methods from the host bridge provider.")
+	},
+	// Property access patterns (nested properties)
+	`vscode.$method.$var` where {
+		or {
+			$var <: `workspaceFolders`,
+			$var <: `appRoot`,
+			$var <: `machineId`,
+			$var <: `uriScheme`,
+			$var <: `isTelemetryEnabled`,
+			$var <: `onDidChangeTelemetryEnabled`,
+			$var <: `all`,
+			$var <: `activeTextEditor`,
+			$var <: `visibleTextEditors`,
+			$var <: `activeTabGroup`
+		},
+		register_diagnostic(span=$var, message="Use appropriate HostProvider methods or abstraction layer instead.")
+	},
+	// Direct vscode property access patterns
+	`vscode.$property` where {
+		or { $property <: `version` },
+		register_diagnostic(span=$property, message="Use appropriate HostProvider methods or abstraction layer instead.")
+	},
+	// Special case for vscode.window.tabGroups.all
+	`vscode.window.tabGroups.all` where {
+		register_diagnostic(message="Use appropriate HostProvider methods or abstraction layer instead.")
+	},
+	// Special case for vscode.extensions.all
+	`vscode.extensions.all` where {
+		register_diagnostic(message="Use appropriate HostProvider methods or abstraction layer instead.")
+	},
+	// Block all vscode.env.* access (catches any property or method)
+	`vscode.env.$anything` where {
+		register_diagnostic(message="Use appropriate HostProvider methods or abstraction layer instead of vscode.env API.")
+	}
+}
diff --git a/apps/vscode/src/dev/mcp-oauth-test-server/README.md b/apps/vscode/src/dev/mcp-oauth-test-server/README.md
new file mode 100644
index 0000000..a53f063
--- /dev/null
+++ b/apps/vscode/src/dev/mcp-oauth-test-server/README.md
@@ -0,0 +1,122 @@
+# MCP OAuth Test Server
+
+A self-contained, **zero-dependency** (Node `http` only) server for exercising
+and debugging Cline's MCP OAuth flow locally.
+
+It plays both roles that a real remote MCP server + its OAuth provider play:
+
+1. **OAuth 2.0 Authorization Server** (RFC 8414 / RFC 7591 DCR / RFC 7636 PKCE):
+   - `GET /.well-known/oauth-protected-resource`
+   - `GET /.well-known/oauth-authorization-server`
+   - `POST /register` — Dynamic Client Registration
+   - `GET /authorize` — interactive **Approve / Deny** consent page
+   - `POST /token` — `authorization_code` + `refresh_token` grants
+2. **MCP StreamableHTTP resource server**:
+   - `POST /mcp` — returns `401 + WWW-Authenticate: Bearer resource_metadata="..."`
+     until authenticated (this is what triggers Cline's OAuth flow), then a
+     minimal `initialize` response.
+
+The endpoint shapes match what `@modelcontextprotocol/sdk` v1.25.x discovers.
+
+## Why
+
+Exercises MCP OAuth failure modes without a real remote server:
+
+- **State expiry** — Cline's `McpOAuthManager` enforces a state lifetime
+  (`MCP_OAUTH_STATE_EXPIRY_MS`). If the callback returns after the window, it's
+  rejected. Use `--slow-authorize` to push past it.
+- **Denial** — the consent page's Deny button (or `--auto-deny`) redirects back
+  with `error=access_denied`, so you can observe how Cline handles a denial.
+
+## Run interactively
+
+```bash
+cd apps/vscode
+bun run dev:mcp-oauth-test-server -- --verbose
+# or directly:
+bun src/dev/mcp-oauth-test-server/server.ts --verbose
+```
+
+On startup the server prints a **paste-ready `mcpServers` JSON fragment** (in
+the nested `transport` shape used by `cline_mcp_settings.json`) in addition to
+the banner — merge it under `mcpServers` in
+`~/.cline/data/settings/cline_mcp_settings.json`. Or add an MCP server
+(StreamableHTTP) in Cline by hand, pointing at:
+
+```
+http://127.0.0.1:7777/mcp
+```
+
+Click **Authenticate**. A browser opens the `/authorize` consent page where you
+can click **Approve** or **Deny**.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--port <n>` | Port to listen on (default `7777`, env `MCP_OAUTH_TEST_PORT`). `0` = OS-assigned random port. |
+| `--random-port` | Bind an OS-assigned random free port instead of `--port` |
+| `--instances <n>` | Start N independent servers, each on its own random port (implies `--random-port`). Use to add several MCP servers to Cline at once. |
+| `--auto-approve` | Skip consent; always approve |
+| `--auto-deny` | Skip consent; always deny (simulate "Deny" click) |
+| `--code-ttl <ms>` | Authorization-code lifetime (default `600000`). Set small to force expiry. |
+| `--slow-authorize <ms>` | Delay `/authorize` response (simulate a slow user) |
+| `--verbose`, `-v` | Log every request |
+| `--help`, `-h` | Show help |
+
+## Adding multiple servers at once
+
+Each instance binds its own random port and prints its `/mcp` endpoint. Add
+each one to Cline as a separate StreamableHTTP server to exercise concurrent
+OAuth flows / multiple authenticated servers:
+
+```bash
+bun src/dev/mcp-oauth-test-server/server.ts --instances 3 --verbose
+```
+
+Because OAuth state is keyed by **server name** in `cline_mcp_settings.json`,
+each Cline server entry gets its own independent tokens — even if two point at
+the same URL.
+
+## Reproducing specific bugs
+
+**"OAuth state expired" race** — make the user take longer than Cline's
+10-minute state window:
+
+```bash
+bun src/dev/mcp-oauth-test-server/server.ts --slow-authorize 605000 --verbose
+```
+
+**Denied redirect** — always deny so every redirect carries `access_denied`:
+
+```bash
+bun src/dev/mcp-oauth-test-server/server.ts --auto-deny --verbose
+```
+
+## Debug-harness integration
+
+The server can be driven from the debug harness without a real browser:
+
+- `TestServer`, `TestServerOptions`, and `parseArgs` are exported, so the
+  harness can `import` and start an instance in-process (the module only
+  auto-starts when run as the main script).
+- Under `CLINE_CAPTURE_BROWSER=1` (see `src/utils/env.ts`), the authorization URL
+  Cline tries to open is captured instead of launched. The harness `curl`s the
+  captured `/authorize` URL (append `decision=approve` or `decision=deny` to
+  skip the consent page) to get the `vscode://` callback, then delivers it to the
+  extension via `globalThis.__clineHandleUri(...)` (see the debug harness README,
+  "Testing MCP OAuth").
+
+## Manual flow (no browser, for scripting)
+
+```bash
+PORT=7777
+# 1. Discover
+curl -s localhost:$PORT/.well-known/oauth-authorization-server
+# 2. Register a client
+CID=$(curl -s -X POST localhost:$PORT/register -H 'Content-Type: application/json' \
+  -d '{"redirect_uris":["http://127.0.0.1:48801/cb"]}' \
+  | node -e "process.stdin.on('data',d=>console.log(JSON.parse(d).client_id))")
+# 3. Approve and capture the code from the redirect Location header
+#    (append &decision=approve to skip the HTML page)
+```
diff --git a/apps/vscode/src/dev/mcp-oauth-test-server/__tests__/frozzle.test.ts b/apps/vscode/src/dev/mcp-oauth-test-server/__tests__/frozzle.test.ts
new file mode 100644
index 0000000..d956037
--- /dev/null
+++ b/apps/vscode/src/dev/mcp-oauth-test-server/__tests__/frozzle.test.ts
@@ -0,0 +1,32 @@
+import { describe, it } from "mocha"
+import "should"
+import { frozzle } from "../server"
+
+// The `frozzle` tool's value is that its output can't be guessed without
+// calling it; these tests pin the exact transform so evals and the server stay
+// in sync. If you change frozzle(), update any eval fixtures that assert on it.
+describe("frozzle", () => {
+	it("reverses the string, swaps case, and wraps in guillemets", () => {
+		frozzle("Hello").should.equal("«OLLEh»")
+	})
+
+	it("leaves digits and spaces in place (only letter case is swapped)", () => {
+		frozzle("Frozzle Me 123").should.equal("«321 Em ELZZORf»")
+	})
+
+	it("handles empty input", () => {
+		frozzle("").should.equal("«»")
+	})
+
+	it("swaps each letter's case independently", () => {
+		frozzle("MixedCase").should.equal("«ESAcDEXIm»")
+	})
+
+	it("is invertible: re-frozzling the inner content restores the original", () => {
+		// frozzle = reverse + swapCase, both self-inverse, so applying the same
+		// transform to the unwrapped result returns the original input.
+		const original = "AbCdef 99"
+		const inner = frozzle(original).slice(1, -1) // strip « »
+		frozzle(inner).should.equal(`«${original}»`)
+	})
+})
diff --git a/apps/vscode/src/dev/mcp-oauth-test-server/server.ts b/apps/vscode/src/dev/mcp-oauth-test-server/server.ts
new file mode 100644
index 0000000..3cc4ef8
--- /dev/null
+++ b/apps/vscode/src/dev/mcp-oauth-test-server/server.ts
@@ -0,0 +1,844 @@
+#!/usr/bin/env node
+/**
+ * MCP OAuth Test Server
+ * =====================
+ *
+ * A self-contained, zero-dependency (Node `http` only) test server for
+ * exercising and debugging Cline's MCP OAuth flow locally, including failure
+ * modes such as:
+ *
+ *   - State expiry — the OAuth `state` times out before the callback returns
+ *     (e.g. a slow user, or a callback that arrives with a stale state).
+ *   - Denial — the user clicks "Deny" on the consent screen, so the redirect
+ *     comes back with `error=access_denied`.
+ *
+ * It plays BOTH roles that a real remote MCP server + its OAuth provider play:
+ *
+ *   1. OAuth 2.0 Authorization Server (RFC 8414 / RFC 7591 / RFC 7636 PKCE):
+ *        GET  /.well-known/oauth-protected-resource[/<path>]
+ *        GET  /.well-known/oauth-authorization-server[/<path>]
+ *        POST /register        (Dynamic Client Registration)
+ *        GET  /authorize       (consent screen — Approve / Deny)
+ *        POST /token           (authorization_code + refresh_token grants)
+ *
+ *   2. MCP StreamableHTTP resource server:
+ *        POST /mcp             (returns 401 + WWW-Authenticate until authed,
+ *                               then initialize + a `frozzle` tool)
+ *
+ * The `frozzle` tool exists so an eval can prove the OAuth'd MCP round-trip
+ * actually happened: its output is not derivable without calling the tool, so
+ * a correct "frozzle <text>" answer can't be hallucinated. See frozzle().
+ *
+ * The endpoint shapes match what `@modelcontextprotocol/sdk` v1.25.x discovers
+ * (see node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js).
+ *
+ * Fault-injection knobs (CLI flags / env) let us reproduce specific bugs:
+ *
+ *   --port <n>            Port to listen on (default 7777, env MCP_OAUTH_TEST_PORT)
+ *   --auto-approve        Skip the consent screen; always approve (default: off,
+ *                         shows an interactive Approve/Deny page)
+ *   --auto-deny           Skip the consent screen; always deny (redirect comes
+ *                         back with error=access_denied)
+ *   --code-ttl <ms>       How long an issued authorization code stays valid
+ *                         before /token rejects it (default 600000 = 10 min).
+ *                         Set small (e.g. 1000) to exercise expiry races.
+ *   --slow-authorize <ms> Delay before /authorize responds, to simulate a user
+ *                         who takes a long time on the consent screen (useful
+ *                         for exercising Cline's OAuth state-expiry window).
+ *   --verbose             Log every request.
+ *
+ * Run interactively:
+ *   cd apps/vscode
+ *   bun src/dev/mcp-oauth-test-server/server.ts --verbose
+ *
+ * Then add an MCP server to Cline pointing at:
+ *   http://127.0.0.1:7777/mcp   (type: streamableHttp)
+ *
+ * Click "Authenticate" in Cline; a browser opens the /authorize consent page.
+ */
+
+import crypto from "node:crypto"
+import http from "node:http"
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+interface TestServerOptions {
+	port: number
+	host: string
+	autoApprove: boolean
+	autoDeny: boolean
+	codeTtlMs: number
+	slowAuthorizeMs: number
+	verbose: boolean
+	/**
+	 * Number of independent server instances to start. When > 1, each instance
+	 * binds its own OS-assigned random port (the fixed `--port` can't be shared),
+	 * so you can add several distinct MCP servers to Cline at once and exercise
+	 * concurrent OAuth flows.
+	 */
+	instances: number
+	/**
+	 * Bind an OS-assigned random free port instead of the fixed `--port`.
+	 * Implied when `--instances` > 1. Also enabled by passing `--port 0`.
+	 */
+	randomPort: boolean
+}
+
+function parseArgs(argv: string[]): TestServerOptions {
+	const opts: TestServerOptions = {
+		port: Number(process.env.MCP_OAUTH_TEST_PORT) || 7777,
+		host: "127.0.0.1",
+		autoApprove: false,
+		autoDeny: false,
+		codeTtlMs: 10 * 60 * 1000,
+		slowAuthorizeMs: 0,
+		verbose: false,
+		instances: 1,
+		randomPort: false,
+	}
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i]
+		switch (arg) {
+			case "--port":
+				opts.port = Number(argv[++i])
+				break
+			case "--auto-approve":
+				opts.autoApprove = true
+				break
+			case "--auto-deny":
+				opts.autoDeny = true
+				break
+			case "--code-ttl":
+				opts.codeTtlMs = Number(argv[++i])
+				break
+			case "--slow-authorize":
+				opts.slowAuthorizeMs = Number(argv[++i])
+				break
+			case "--instances":
+				opts.instances = Number(argv[++i])
+				break
+			case "--random-port":
+			case "--random-ports":
+				opts.randomPort = true
+				break
+			case "--verbose":
+			case "-v":
+				opts.verbose = true
+				break
+			case "--help":
+			case "-h":
+				printUsageAndExit()
+				break
+			default:
+				console.error(`Unknown argument: ${arg}`)
+				printUsageAndExit(1)
+		}
+	}
+	if (opts.autoApprove && opts.autoDeny) {
+		console.error("Cannot set both --auto-approve and --auto-deny")
+		process.exit(1)
+	}
+	if (!Number.isInteger(opts.instances) || opts.instances < 1) {
+		console.error(`--instances must be a positive integer (got ${opts.instances})`)
+		process.exit(1)
+	}
+	// `--port 0` is a conventional request for an OS-assigned random port.
+	if (opts.port === 0) {
+		opts.randomPort = true
+	}
+	// Multiple instances can't share one fixed port, so each gets a random one.
+	if (opts.instances > 1) {
+		opts.randomPort = true
+	}
+	return opts
+}
+
+function printUsageAndExit(code = 0): never {
+	console.log(`MCP OAuth Test Server
+
+Usage: bun src/dev/mcp-oauth-test-server/server.ts [options]
+
+Options:
+  --port <n>            Port to listen on (default 7777; 0 = OS-assigned random)
+  --random-port         Bind an OS-assigned random free port instead of --port
+  --instances <n>       Start N independent servers, each on its own random
+                        port (implies --random-port). Use to add several MCP
+                        servers to Cline at once.
+  --auto-approve        Always approve authorization (no consent screen)
+  --auto-deny           Always deny authorization (simulate "Deny" click)
+  --code-ttl <ms>       Authorization code lifetime (default 600000)
+  --slow-authorize <ms> Delay /authorize response by <ms>
+  --verbose, -v         Log every request
+  --help, -h            Show this help
+
+Examples:
+  # Single server on the default fixed port
+  bun src/dev/mcp-oauth-test-server/server.ts --verbose
+
+  # Three servers on random ports, to test adding multiple at once
+  bun src/dev/mcp-oauth-test-server/server.ts --instances 3 --verbose
+`)
+	process.exit(code)
+}
+
+// ---------------------------------------------------------------------------
+// In-memory OAuth state
+// ---------------------------------------------------------------------------
+
+interface RegisteredClient {
+	client_id: string
+	client_secret?: string
+	redirect_uris: string[]
+	client_name?: string
+	token_endpoint_auth_method?: string
+}
+
+interface PendingAuthCode {
+	code: string
+	clientId: string
+	redirectUri: string
+	codeChallenge?: string
+	codeChallengeMethod?: string
+	/** OAuth `state` the client sent on /authorize — echoed back on redirect. */
+	state?: string
+	issuedAt: number
+	resource?: string
+}
+
+interface IssuedToken {
+	accessToken: string
+	refreshToken: string
+	clientId: string
+	issuedAt: number
+}
+
+class TestServer {
+	private readonly opts: TestServerOptions
+	private readonly clients = new Map<string, RegisteredClient>()
+	private readonly authCodes = new Map<string, PendingAuthCode>()
+	private readonly refreshTokens = new Map<string, IssuedToken>()
+	private server: http.Server | null = null
+	/**
+	 * The port actually bound. Differs from `opts.port` when `randomPort` is
+	 * set (the OS assigns it), and is the value every absolute URL we emit
+	 * (discovery metadata, redirect targets, the /mcp resource id) must use —
+	 * otherwise the SDK's redirect_uri / resource checks fail.
+	 */
+	private boundPort = 0
+
+	constructor(opts: TestServerOptions) {
+		this.opts = opts
+		this.boundPort = opts.port
+	}
+
+	private get baseUrl(): string {
+		return `http://${this.opts.host}:${this.boundPort}`
+	}
+
+	/** The port this server is actually listening on (resolved after start). */
+	get port(): number {
+		return this.boundPort
+	}
+
+	/** The MCP StreamableHTTP endpoint clients should connect to. */
+	get mcpEndpoint(): string {
+		return `${this.baseUrl}/mcp`
+	}
+
+	private log(...args: unknown[]): void {
+		if (this.opts.verbose) {
+			console.log("[mcp-oauth-test]", ...args)
+		}
+	}
+
+	/**
+	 * Start listening. Resolves once bound, so callers can read `.port`
+	 * (important when binding an OS-assigned random port).
+	 */
+	start(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.server = http.createServer((req, res) => {
+				this.handleRequest(req, res).catch((err) => {
+					console.error("[mcp-oauth-test] Unhandled error:", err)
+					if (!res.headersSent) {
+						this.json(res, 500, { error: "server_error", error_description: String(err) })
+					}
+				})
+			})
+			this.server.once("error", reject)
+			// `randomPort` → listen on 0 so the OS assigns a free port.
+			const listenPort = this.opts.randomPort ? 0 : this.opts.port
+			this.server.listen(listenPort, this.opts.host, () => {
+				const address = this.server?.address()
+				if (address && typeof address === "object") {
+					this.boundPort = address.port
+				}
+				console.log(`MCP OAuth Test Server listening on ${this.baseUrl}`)
+				console.log(`  MCP endpoint:   ${this.baseUrl}/mcp  (type: streamableHttp)`)
+				console.log(`  Authorize page: ${this.baseUrl}/authorize`)
+				const mode = this.opts.autoApprove ? "auto-approve" : this.opts.autoDeny ? "auto-deny" : "interactive consent"
+				console.log(`  Mode: ${mode}, code TTL: ${this.opts.codeTtlMs}ms`)
+				resolve()
+			})
+		})
+	}
+
+	stop(): void {
+		this.server?.close()
+		this.server = null
+	}
+
+	// ------------------------------------------------------------------ routing
+
+	private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+		const url = new URL(req.url || "/", this.baseUrl)
+		this.log(req.method, url.pathname + url.search)
+
+		// Discovery: protected-resource metadata (RFC 9728). The SDK probes both
+		// `/.well-known/oauth-protected-resource` and a path-suffixed variant.
+		if (url.pathname.startsWith("/.well-known/oauth-protected-resource")) {
+			return this.handleProtectedResourceMetadata(res)
+		}
+		// Discovery: authorization-server metadata (RFC 8414).
+		if (
+			url.pathname.startsWith("/.well-known/oauth-authorization-server") ||
+			url.pathname.startsWith("/.well-known/openid-configuration")
+		) {
+			return this.handleAuthServerMetadata(res)
+		}
+
+		switch (url.pathname) {
+			case "/register":
+				return this.handleRegister(req, res)
+			case "/authorize":
+				return this.handleAuthorize(url, res)
+			case "/token":
+				return this.handleToken(req, res)
+			case "/mcp":
+				return this.handleMcp(req, res)
+			case "/":
+				return this.text(res, 200, "MCP OAuth Test Server. See /mcp and /authorize.")
+			default:
+				return this.json(res, 404, { error: "not_found", path: url.pathname })
+		}
+	}
+
+	// ------------------------------------------------------------- discovery
+
+	private handleProtectedResourceMetadata(res: http.ServerResponse): void {
+		this.json(res, 200, {
+			resource: `${this.baseUrl}/mcp`,
+			authorization_servers: [this.baseUrl],
+			scopes_supported: ["mcp"],
+			bearer_methods_supported: ["header"],
+		})
+	}
+
+	private handleAuthServerMetadata(res: http.ServerResponse): void {
+		this.json(res, 200, {
+			issuer: this.baseUrl,
+			authorization_endpoint: `${this.baseUrl}/authorize`,
+			token_endpoint: `${this.baseUrl}/token`,
+			registration_endpoint: `${this.baseUrl}/register`,
+			response_types_supported: ["code"],
+			grant_types_supported: ["authorization_code", "refresh_token"],
+			code_challenge_methods_supported: ["S256"],
+			token_endpoint_auth_methods_supported: ["none", "client_secret_post"],
+			scopes_supported: ["mcp"],
+		})
+	}
+
+	// --------------------------------------------------- dynamic registration
+
+	private async handleRegister(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+		if (req.method !== "POST") {
+			return this.json(res, 405, { error: "method_not_allowed" })
+		}
+		const body = await this.readJsonBody(req)
+		const rawRedirectUris = body?.redirect_uris
+		const redirectUris: string[] = Array.isArray(rawRedirectUris)
+			? rawRedirectUris.filter((u): u is string => typeof u === "string")
+			: []
+		if (redirectUris.length === 0) {
+			return this.json(res, 400, { error: "invalid_redirect_uri", error_description: "redirect_uris required" })
+		}
+		const clientId = `client_${crypto.randomBytes(12).toString("hex")}`
+		const client: RegisteredClient = {
+			client_id: clientId,
+			redirect_uris: redirectUris,
+			client_name: asString(body?.client_name),
+			token_endpoint_auth_method: asString(body?.token_endpoint_auth_method) ?? "none",
+		}
+		this.clients.set(clientId, client)
+		this.log("Registered client", clientId, "redirect_uris:", redirectUris)
+		this.json(res, 201, {
+			client_id: clientId,
+			redirect_uris: redirectUris,
+			client_name: client.client_name,
+			token_endpoint_auth_method: client.token_endpoint_auth_method,
+			grant_types: ["authorization_code", "refresh_token"],
+			response_types: ["code"],
+		})
+	}
+
+	// ----------------------------------------------------------- authorize
+
+	private async handleAuthorize(url: URL, res: http.ServerResponse): Promise<void> {
+		const clientId = url.searchParams.get("client_id") || ""
+		const redirectUri = url.searchParams.get("redirect_uri") || ""
+		const state = url.searchParams.get("state") || undefined
+		const codeChallenge = url.searchParams.get("code_challenge") || undefined
+		const codeChallengeMethod = url.searchParams.get("code_challenge_method") || undefined
+		const resource = url.searchParams.get("resource") || undefined
+		const decision = url.searchParams.get("decision") // set when posting back from consent page
+
+		const client = this.clients.get(clientId)
+		if (!client) {
+			return this.text(res, 400, `Unknown client_id: ${clientId}`)
+		}
+		if (!client.redirect_uris.includes(redirectUri)) {
+			// This is the real-world failure when the registered redirect_uri no
+			// longer matches (e.g. loopback port changed). Surface it clearly.
+			return this.text(
+				res,
+				400,
+				`redirect_uri "${redirectUri}" is not registered for this client.\nRegistered: ${client.redirect_uris.join(", ")}`,
+			)
+		}
+
+		if (this.opts.slowAuthorizeMs > 0) {
+			this.log(`Delaying /authorize by ${this.opts.slowAuthorizeMs}ms`)
+			await delay(this.opts.slowAuthorizeMs)
+		}
+
+		// Decide approve/deny.
+		let approved: boolean
+		if (this.opts.autoApprove) {
+			approved = true
+		} else if (this.opts.autoDeny) {
+			approved = false
+		} else if (decision === "approve") {
+			approved = true
+		} else if (decision === "deny") {
+			approved = false
+		} else {
+			// Show the interactive consent screen.
+			return this.html(res, 200, this.renderConsentPage(url))
+		}
+
+		if (!approved) {
+			// RFC 6749 §4.1.2.1 — redirect back with error=access_denied.
+			const redirect = new URL(redirectUri)
+			redirect.searchParams.set("error", "access_denied")
+			redirect.searchParams.set("error_description", "The user denied the authorization request.")
+			if (state) {
+				redirect.searchParams.set("state", state)
+			}
+			this.log("User DENIED authorization, redirecting to", redirect.toString())
+			return this.redirect(res, redirect.toString())
+		}
+
+		// Approved: mint an authorization code bound to PKCE + redirect_uri.
+		const code = crypto.randomBytes(24).toString("hex")
+		this.authCodes.set(code, {
+			code,
+			clientId,
+			redirectUri,
+			codeChallenge,
+			codeChallengeMethod,
+			state,
+			issuedAt: Date.now(),
+			resource,
+		})
+		const redirect = new URL(redirectUri)
+		redirect.searchParams.set("code", code)
+		if (state) {
+			redirect.searchParams.set("state", state)
+		}
+		this.log("User APPROVED, redirecting to", redirect.toString())
+		this.redirect(res, redirect.toString())
+	}
+
+	// --------------------------------------------------------------- token
+
+	private async handleToken(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+		if (req.method !== "POST") {
+			return this.json(res, 405, { error: "method_not_allowed" })
+		}
+		const form = await this.readFormBody(req)
+		const grantType = form.get("grant_type")
+
+		if (grantType === "authorization_code") {
+			return this.handleAuthorizationCodeGrant(form, res)
+		}
+		if (grantType === "refresh_token") {
+			return this.handleRefreshTokenGrant(form, res)
+		}
+		return this.json(res, 400, { error: "unsupported_grant_type", error_description: String(grantType) })
+	}
+
+	private handleAuthorizationCodeGrant(form: URLSearchParams, res: http.ServerResponse): void {
+		const code = form.get("code") || ""
+		const redirectUri = form.get("redirect_uri") || ""
+		const codeVerifier = form.get("code_verifier") || ""
+
+		const pending = this.authCodes.get(code)
+		if (!pending) {
+			this.json(res, 400, { error: "invalid_grant", error_description: "Unknown or already-used code" })
+			return
+		}
+		// Codes are single-use.
+		this.authCodes.delete(code)
+
+		if (Date.now() - pending.issuedAt > this.opts.codeTtlMs) {
+			this.log("Authorization code expired")
+			this.json(res, 400, { error: "invalid_grant", error_description: "Authorization code expired" })
+			return
+		}
+		if (pending.redirectUri !== redirectUri) {
+			this.json(res, 400, { error: "invalid_grant", error_description: "redirect_uri mismatch" })
+			return
+		}
+		// Verify PKCE (S256).
+		if (pending.codeChallenge) {
+			const expected = base64UrlSha256(codeVerifier)
+			if (expected !== pending.codeChallenge) {
+				this.json(res, 400, { error: "invalid_grant", error_description: "PKCE verification failed" })
+				return
+			}
+		}
+
+		const token = this.issueToken(pending.clientId)
+		this.log("Issued tokens for client", pending.clientId)
+		this.json(res, 200, {
+			access_token: token.accessToken,
+			token_type: "Bearer",
+			expires_in: 3600,
+			refresh_token: token.refreshToken,
+			scope: "mcp",
+		})
+	}
+
+	private handleRefreshTokenGrant(form: URLSearchParams, res: http.ServerResponse): void {
+		const refreshToken = form.get("refresh_token") || ""
+		const existing = this.refreshTokens.get(refreshToken)
+		if (!existing) {
+			this.json(res, 400, { error: "invalid_grant", error_description: "Unknown refresh_token" })
+			return
+		}
+		this.refreshTokens.delete(refreshToken)
+		const token = this.issueToken(existing.clientId)
+		this.log("Refreshed tokens for client", existing.clientId)
+		this.json(res, 200, {
+			access_token: token.accessToken,
+			token_type: "Bearer",
+			expires_in: 3600,
+			refresh_token: token.refreshToken,
+			scope: "mcp",
+		})
+	}
+
+	private issueToken(clientId: string): IssuedToken {
+		const token: IssuedToken = {
+			accessToken: `at_${crypto.randomBytes(24).toString("hex")}`,
+			refreshToken: `rt_${crypto.randomBytes(24).toString("hex")}`,
+			clientId,
+			issuedAt: Date.now(),
+		}
+		this.refreshTokens.set(token.refreshToken, token)
+		return token
+	}
+
+	// ----------------------------------------------------------------- MCP
+
+	private async handleMcp(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+		const auth = req.headers.authorization
+		const hasBearer = typeof auth === "string" && auth.toLowerCase().startsWith("bearer ")
+
+		if (!hasBearer) {
+			// This is what triggers Cline's OAuth flow: 401 + WWW-Authenticate
+			// with a resource_metadata pointer (RFC 9728).
+			const metadataUrl = `${this.baseUrl}/.well-known/oauth-protected-resource`
+			res.setHeader("WWW-Authenticate", `Bearer resource_metadata="${metadataUrl}"`)
+			return this.json(res, 401, { error: "unauthorized", error_description: "Authentication required" })
+		}
+
+		// Authenticated: respond to a minimal MCP `initialize` so the connection
+		// succeeds and Cline shows the server as connected.
+		const body = await this.readJsonBody(req)
+		const id = body?.id ?? null
+		if (body?.method === "initialize") {
+			return this.json(res, 200, {
+				jsonrpc: "2.0",
+				id,
+				result: {
+					protocolVersion: "2024-11-05",
+					capabilities: { tools: {} },
+					serverInfo: { name: "mcp-oauth-test-server", version: "0.1.0" },
+				},
+			})
+		}
+
+		// Advertise the `frozzle` tool. Its description deliberately does NOT
+		// reveal what frozzling does, so a model cannot fabricate the result —
+		// the only way to produce a correct answer is to actually call the tool
+		// over MCP. This makes it a reliable end-to-end signal that the OAuth'd
+		// MCP connection works (vs. the model hallucinating an answer).
+		if (body?.method === "tools/list") {
+			return this.json(res, 200, {
+				jsonrpc: "2.0",
+				id,
+				result: {
+					tools: [
+						{
+							name: "frozzle",
+							description:
+								"Frozzle the given text and return its frozzled form. " +
+								"The frozzling transform is defined solely by this server; " +
+								"there is no way to compute the result without calling this tool.",
+							inputSchema: {
+								type: "object",
+								properties: {
+									text: { type: "string", description: "The text to frozzle." },
+								},
+								required: ["text"],
+							},
+						},
+					],
+				},
+			})
+		}
+
+		if (body?.method === "tools/call") {
+			const params = (body?.params ?? {}) as { name?: string; arguments?: Record<string, unknown> }
+			if (params.name === "frozzle") {
+				const text = typeof params.arguments?.text === "string" ? params.arguments.text : ""
+				const frozzled = frozzle(text)
+				this.log(`frozzle(${JSON.stringify(text)}) -> ${JSON.stringify(frozzled)}`)
+				return this.json(res, 200, {
+					jsonrpc: "2.0",
+					id,
+					result: {
+						content: [{ type: "text", text: frozzled }],
+					},
+				})
+			}
+			// Unknown tool.
+			return this.json(res, 200, {
+				jsonrpc: "2.0",
+				id,
+				result: {
+					isError: true,
+					content: [{ type: "text", text: `Unknown tool: ${String(params.name)}` }],
+				},
+			})
+		}
+
+		// Any other method: empty-ish OK so the SDK doesn't error out.
+		return this.json(res, 200, { jsonrpc: "2.0", id, result: {} })
+	}
+
+	// ----------------------------------------------------- consent HTML page
+
+	private renderConsentPage(url: URL): string {
+		const approveUrl = new URL(url.toString())
+		approveUrl.searchParams.set("decision", "approve")
+		const denyUrl = new URL(url.toString())
+		denyUrl.searchParams.set("decision", "deny")
+		const clientId = url.searchParams.get("client_id") || "(unknown)"
+		const redirectUri = url.searchParams.get("redirect_uri") || "(unknown)"
+		return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>MCP OAuth Test — Authorize</title>
+  <style>
+    body { font-family: system-ui, sans-serif; background: #1e1e1e; color: #ddd; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+    .card { background: #252526; border: 1px solid #3c3c3c; border-radius: 8px; padding: 32px; max-width: 480px; }
+    h1 { font-size: 1.3rem; margin-top: 0; }
+    code { background: #333; padding: 2px 6px; border-radius: 4px; font-size: 0.85em; word-break: break-all; }
+    .row { margin: 12px 0; }
+    .buttons { margin-top: 24px; display: flex; gap: 12px; }
+    a.btn { text-decoration: none; padding: 10px 20px; border-radius: 6px; font-weight: 600; }
+    a.approve { background: #2ea043; color: #fff; }
+    a.deny { background: #6e2222; color: #fff; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>Authorize Cline?</h1>
+    <p>The MCP OAuth Test Server is asking you to authorize this client.</p>
+    <div class="row">Client: <code>${escapeHtml(clientId)}</code></div>
+    <div class="row">Redirect: <code>${escapeHtml(redirectUri)}</code></div>
+    <div class="buttons">
+      <a class="btn approve" href="${escapeHtml(approveUrl.toString())}">Approve</a>
+      <a class="btn deny" href="${escapeHtml(denyUrl.toString())}">Deny</a>
+    </div>
+  </div>
+</body>
+</html>`
+	}
+
+	// --------------------------------------------------------------- helpers
+
+	private async readJsonBody(req: http.IncomingMessage): Promise<Record<string, unknown> | undefined> {
+		const raw = await readBody(req)
+		if (!raw) {
+			return undefined
+		}
+		try {
+			return JSON.parse(raw) as Record<string, unknown>
+		} catch {
+			return undefined
+		}
+	}
+
+	private async readFormBody(req: http.IncomingMessage): Promise<URLSearchParams> {
+		const raw = await readBody(req)
+		return new URLSearchParams(raw)
+	}
+
+	private json(res: http.ServerResponse, status: number, body: unknown): void {
+		const payload = JSON.stringify(body)
+		res.writeHead(status, { "Content-Type": "application/json" })
+		res.end(payload)
+	}
+
+	private text(res: http.ServerResponse, status: number, body: string): void {
+		res.writeHead(status, { "Content-Type": "text/plain" })
+		res.end(body)
+	}
+
+	private html(res: http.ServerResponse, status: number, body: string): void {
+		res.writeHead(status, { "Content-Type": "text/html" })
+		res.end(body)
+	}
+
+	private redirect(res: http.ServerResponse, location: string): void {
+		res.writeHead(302, { Location: location })
+		res.end()
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Module-level helpers
+// ---------------------------------------------------------------------------
+
+function readBody(req: http.IncomingMessage): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const chunks: Buffer[] = []
+		req.on("data", (chunk) => chunks.push(chunk as Buffer))
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")))
+		req.on("error", reject)
+	})
+}
+
+function base64UrlSha256(input: string): string {
+	return crypto.createHash("sha256").update(input).digest("base64url")
+}
+
+/**
+ * The "frozzle" transform exposed by the test server's MCP `frozzle` tool.
+ *
+ * The point of frozzling is that it is arbitrary and non-obvious: a model
+ * cannot guess or compute the result without actually calling the tool over
+ * the (OAuth-authenticated) MCP connection. So when an eval asks the agent to
+ * "frozzle <text>" and checks the answer, a correct result is proof the MCP
+ * round-trip really happened — not a hallucination.
+ *
+ * It is nonetheless deterministic, easy to verify at a glance, and invertible:
+ * reverse the string and swap the case of each letter (upper<->lower), then
+ * wrap in « » markers. e.g. frozzle("Hello") === "«OLLEh»".
+ */
+export function frozzle(text: string): string {
+	const swapped = [...text]
+		.reverse()
+		.map((ch) => {
+			const lower = ch.toLowerCase()
+			const upper = ch.toUpperCase()
+			if (ch === lower && ch !== upper) {
+				return upper // lowercase -> uppercase
+			}
+			if (ch === upper && ch !== lower) {
+				return lower // uppercase -> lowercase
+			}
+			return ch // non-letters unchanged
+		})
+		.join("")
+	return `«${swapped}»`
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" ? value : undefined
+}
+
+function escapeHtml(s: string): string {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;")
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+export { buildSettingsFragment, parseArgs, TestServer, type TestServerOptions }
+
+/**
+ * Build a paste-ready `mcpServers` fragment for cline_mcp_settings.json from a
+ * set of running test-server endpoints.
+ *
+ * Uses the nested `transport` shape the CLI/SDK writes (and the extension also
+ * accepts), so the output can be dropped straight into the settings file. When
+ * there are multiple endpoints the names are suffixed (`oauth-test-1`, …) since
+ * OAuth state is keyed by server name — distinct names get independent tokens.
+ */
+function buildSettingsFragment(endpoints: string[]): string {
+	const mcpServers: Record<string, unknown> = {}
+	endpoints.forEach((endpoint, index) => {
+		const name = endpoints.length === 1 ? "oauth-test" : `oauth-test-${index + 1}`
+		mcpServers[name] = {
+			transport: {
+				type: "streamableHttp",
+				url: endpoint,
+			},
+		}
+	})
+	return JSON.stringify({ mcpServers }, null, 2)
+}
+
+// Only auto-start when run directly (so this module can be imported by the
+// debug harness later without spawning a server).
+const isMain = process.argv[1] && /mcp-oauth-test-server[/\\]server\.(ts|js)$/.test(process.argv[1])
+if (isMain) {
+	const opts = parseArgs(process.argv.slice(2))
+	const servers: TestServer[] = []
+
+	void (async () => {
+		for (let i = 0; i < opts.instances; i++) {
+			const server = new TestServer(opts)
+			await server.start()
+			servers.push(server)
+		}
+		if (opts.instances > 1) {
+			console.log(`\nStarted ${opts.instances} MCP OAuth test servers.`)
+		}
+		// Emit a paste-ready settings fragment so you don't have to hand-write
+		// the JSON (handy with random ports / multiple instances).
+		console.log("\nPaste into ~/.cline/data/settings/cline_mcp_settings.json (merge under mcpServers):\n")
+		console.log(buildSettingsFragment(servers.map((server) => server.mcpEndpoint)))
+	})()
+
+	process.on("SIGINT", () => {
+		console.log("\nShutting down...")
+		for (const server of servers) {
+			server.stop()
+		}
+		process.exit(0)
+	})
+}
diff --git a/apps/vscode/src/exports/README.md b/apps/vscode/src/exports/README.md
new file mode 100644
index 0000000..d2b74e5
--- /dev/null
+++ b/apps/vscode/src/exports/README.md
@@ -0,0 +1,48 @@
+# Cline API
+
+The Cline extension exposes an API that can be used by other extensions. To use this API in your extension:
+
+1. Copy `src/extension-api/cline.d.ts` to your extension's source directory.
+2. Include `cline.d.ts` in your extension's compilation.
+3. Get access to the API with the following code:
+
+    ```ts
+    const clineExtension = vscode.extensions.getExtension<ClineAPI>("saoudrizwan.claude-dev")
+
+    if (!clineExtension?.isActive) {
+    	throw new Error("Cline extension is not activated")
+    }
+
+    const cline = clineExtension.exports
+
+    if (cline) {
+    	// Now you can use the API
+
+    	// Start a new task with an initial message
+    	await cline.startNewTask("Hello, Cline! Let's make a new project...")
+
+    	// Start a new task with an initial message and images
+    	await cline.startNewTask("Use this design language", ["data:image/webp;base64,..."])
+
+    	// Send a message to the current task
+    	await cline.sendMessage("Can you fix the @problems?")
+
+    	// Simulate pressing the primary button in the chat interface (e.g. 'Save' or 'Proceed While Running')
+    	await cline.pressPrimaryButton()
+
+    	// Simulate pressing the secondary button in the chat interface (e.g. 'Reject')
+    	await cline.pressSecondaryButton()
+    } else {
+    	console.error("Cline API is not available")
+    }
+    ```
+
+    **Note:** To ensure that the `saoudrizwan.claude-dev` extension is activated before your extension, add it to the `extensionDependencies` in your `package.json`:
+
+    ```json
+    "extensionDependencies": [
+        "saoudrizwan.claude-dev"
+    ]
+    ```
+
+For detailed information on the available methods and their usage, refer to the `cline.d.ts` file.
diff --git a/apps/vscode/src/exports/cline.d.ts b/apps/vscode/src/exports/cline.d.ts
new file mode 100644
index 0000000..85cd277
--- /dev/null
+++ b/apps/vscode/src/exports/cline.d.ts
@@ -0,0 +1,25 @@
+export interface ClineAPI {
+	/**
+	 * Starts a new task with an optional initial message and images.
+	 * @param task Optional initial task message.
+	 * @param images Optional array of image data URIs (e.g., "data:image/webp;base64,...").
+	 */
+	startNewTask(task?: string, images?: string[]): Promise<void>
+
+	/**
+	 * Sends a message to the current task.
+	 * @param message Optional message to send.
+	 * @param images Optional array of image data URIs (e.g., "data:image/webp;base64,...").
+	 */
+	sendMessage(message?: string, images?: string[]): Promise<void>
+
+	/**
+	 * Simulates pressing the primary button in the chat interface.
+	 */
+	pressPrimaryButton(): Promise<void>
+
+	/**
+	 * Simulates pressing the secondary button in the chat interface.
+	 */
+	pressSecondaryButton(): Promise<void>
+}
diff --git a/apps/vscode/src/exports/index.ts b/apps/vscode/src/exports/index.ts
new file mode 100644
index 0000000..70dd078
--- /dev/null
+++ b/apps/vscode/src/exports/index.ts
@@ -0,0 +1,42 @@
+import { Controller } from "@core/controller"
+import { sendChatButtonClickedEvent } from "@core/controller/ui/subscribeToChatButtonClicked"
+import { Logger } from "@/shared/services/Logger"
+import { ClineAPI } from "./cline"
+
+export function createClineAPI(sidebarController: Controller): ClineAPI {
+	const api: ClineAPI = {
+		startNewTask: async (task?: string, images?: string[]) => {
+			await sidebarController.clearTask()
+			await sidebarController.postStateToWebview()
+
+			await sendChatButtonClickedEvent()
+			await sidebarController.initTask(task, images)
+		},
+
+		sendMessage: async (message?: string, images?: string[]) => {
+			if (sidebarController.task) {
+				await sidebarController.task.handleWebviewAskResponse("messageResponse", message || "", images || [])
+			} else {
+				Logger.error("No active task to send message to")
+			}
+		},
+
+		pressPrimaryButton: async () => {
+			if (sidebarController.task) {
+				await sidebarController.task.handleWebviewAskResponse("yesButtonClicked", "", [])
+			} else {
+				Logger.error("No active task to press button for")
+			}
+		},
+
+		pressSecondaryButton: async () => {
+			if (sidebarController.task) {
+				await sidebarController.task.handleWebviewAskResponse("noButtonClicked", "", [])
+			} else {
+				Logger.error("No active task to press button for")
+			}
+		},
+	}
+
+	return api
+}
diff --git a/apps/vscode/src/extension.ts b/apps/vscode/src/extension.ts
new file mode 100644
index 0000000..641fb16
--- /dev/null
+++ b/apps/vscode/src/extension.ts
@@ -0,0 +1,762 @@
+// The module 'vscode' contains the VS Code extensibility API
+// Import the module and reference it with the alias vscode in your code below
+
+import assert from "node:assert"
+import { DIFF_VIEW_URI_SCHEME } from "@hosts/vscode/VscodeDiffViewProvider"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { sendAccountButtonClickedEvent } from "./core/controller/ui/subscribeToAccountButtonClicked"
+import { sendChatButtonClickedEvent } from "./core/controller/ui/subscribeToChatButtonClicked"
+import { sendHistoryButtonClickedEvent } from "./core/controller/ui/subscribeToHistoryButtonClicked"
+import { sendMarketplaceButtonClickedEvent } from "./core/controller/ui/subscribeToMarketplaceButtonClicked"
+import { sendMcpButtonClickedEvent } from "./core/controller/ui/subscribeToMcpButtonClicked"
+import { sendSettingsButtonClickedEvent } from "./core/controller/ui/subscribeToSettingsButtonClicked"
+import { sendWorktreesButtonClickedEvent } from "./core/controller/ui/subscribeToWorktreesButtonClicked"
+import { WebviewProvider } from "./core/webview"
+import { createClineAPI } from "./exports"
+import "./utils/path" // necessary to have access to String.prototype.toPosix
+import path from "node:path"
+import type { ExtensionContext } from "vscode"
+import { HostProvider } from "@/hosts/host-provider"
+import { vscodeHostBridgeClient } from "@/hosts/vscode/hostbridge/client/host-grpc-client"
+import { createStorageContext } from "@/shared/storage/storage-context"
+import { readTextFromClipboard, writeTextToClipboard } from "@/utils/env"
+import { initialize, tearDown } from "./common"
+import { addToCline } from "./core/controller/commands/addToCline"
+import { explainWithCline } from "./core/controller/commands/explainWithCline"
+import { fixWithCline } from "./core/controller/commands/fixWithCline"
+import { improveWithCline } from "./core/controller/commands/improveWithCline"
+import { sendAddToInputEvent } from "./core/controller/ui/subscribeToAddToInput"
+import { sendShowWebviewEvent } from "./core/controller/ui/subscribeToShowWebview"
+import { HookDiscoveryCache } from "./core/hooks/HookDiscoveryCache"
+import {
+	cleanupMcpMarketplaceCatalogFromGlobalState,
+	cleanupOldApiKey,
+	migrateCustomInstructionsToGlobalRules,
+	migrateTaskHistoryToFile,
+	migrateWelcomeViewCompleted,
+	migrateWorkspaceToGlobalStorage,
+} from "./core/storage/state-migrations"
+import { workspaceResolver } from "./core/workspace"
+import { findMatchingNotebookCell, getContextForCommand, showWebview } from "./hosts/vscode/commandUtils"
+import { abortCommitGeneration, generateCommitMsg } from "./hosts/vscode/commit-message-generator"
+import { registerClineOutputChannel } from "./hosts/vscode/hostbridge/env/debugLog"
+import {
+	disposeVscodeCommentReviewController,
+	getVscodeCommentReviewController,
+} from "./hosts/vscode/review/VscodeCommentReviewController"
+import { VscodeTerminalManager } from "./hosts/vscode/terminal/VscodeTerminalManager"
+import { VscodeDiffViewProvider } from "./hosts/vscode/VscodeDiffViewProvider"
+import { VscodeWebviewProvider } from "./hosts/vscode/VscodeWebviewProvider"
+import { exportVSCodeStorageToSharedFiles } from "./hosts/vscode/vscode-to-file-migration"
+import { ExtensionRegistryInfo } from "./registry"
+import { AuthService, LogoutReason } from "./sdk/auth-service"
+import { telemetryService } from "./services/telemetry"
+import { LG_TASK_URI_PATH, SharedUriHandler, TASK_URI_PATH } from "./services/uri/SharedUriHandler"
+import { ShowMessageType } from "./shared/proto/host/window"
+import { fileExistsAtPath } from "./utils/fs"
+
+// This method is called when the VS Code extension is activated.
+// NOTE: This is VS Code specific - services that should be registered
+// for all-platform should be registered in common.ts.
+export async function activate(context: vscode.ExtensionContext) {
+	const activationStartTime = performance.now()
+
+	// 1. Set up HostProvider for VSCode
+	// IMPORTANT: This must be done before any service can be registered
+	setupHostProvider(context)
+
+	// 2. Clean up legacy data patterns within VSCode's native storage.
+	// Moves workspace→global keys, task history→file, custom instructions→rules, etc.
+	// Must run BEFORE the file export so we copy clean state.
+	await cleanupLegacyVSCodeStorage(context)
+
+	// 3. One-time export of VSCode's native storage to shared file-backed stores.
+	// After this, all platforms (VSCode, CLI, JetBrains) read from ~/.cline/data/.
+	const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+	const storageContext = createStorageContext({ workspacePath })
+	await exportVSCodeStorageToSharedFiles(context, storageContext)
+
+	// 4. Register services and perform common initialization
+	// IMPORTANT: Must be done after host provider is setup and migrations are complete
+	const webview = (await initialize(storageContext)) as VscodeWebviewProvider
+
+	// 5. Register services and commands specific to VS Code
+	// Initialize hook discovery cache for performance optimization
+	HookDiscoveryCache.getInstance().initialize(
+		// biome-ignore lint/suspicious/noExplicitAny: Adapt VSCode ExtensionContext to generic interface
+		context as any,
+		(dir: string) => {
+			try {
+				const pattern = new vscode.RelativePattern(dir, "*")
+				const watcher = vscode.workspace.createFileSystemWatcher(pattern)
+				// Ensure watcher is disposed when extension is deactivated
+				context.subscriptions.push(watcher)
+				// Adapt VSCode FileSystemWatcher to generic interface
+				return {
+					onDidCreate: (listener: () => void) => watcher.onDidCreate(listener),
+					onDidChange: (listener: () => void) => watcher.onDidChange(listener),
+					onDidDelete: (listener: () => void) => watcher.onDidDelete(listener),
+					dispose: () => watcher.dispose(),
+				}
+			} catch {
+				return null
+			}
+		},
+		(callback: () => void) => {
+			// Adapt VSCode Disposable to generic interface
+			const disposable = vscode.workspace.onDidChangeWorkspaceFolders(callback)
+			context.subscriptions.push(disposable)
+			return disposable
+		},
+	)
+
+	context.subscriptions.push(
+		vscode.window.registerWebviewViewProvider(VscodeWebviewProvider.SIDEBAR_ID, webview, {
+			webviewOptions: { retainContextWhenHidden: true },
+		}),
+	)
+
+	// NOTE: Commands must be added to the internal registry before registering them with VSCode
+	const { commands } = ExtensionRegistryInfo
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.PlusButton, async () => {
+			const sidebarInstance = WebviewProvider.getInstance()
+			telemetryService.captureNewTaskClicked("activity_bar_plus", !!sidebarInstance.controller.task)
+			await sidebarInstance.controller.clearTask()
+			await sidebarInstance.controller.postStateToWebview()
+			await sendChatButtonClickedEvent()
+		}),
+	)
+	context.subscriptions.push(vscode.commands.registerCommand(commands.McpButton, () => sendMcpButtonClickedEvent()))
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.MarketplaceButton, () => sendMarketplaceButtonClickedEvent()),
+	)
+	context.subscriptions.push(vscode.commands.registerCommand(commands.SettingsButton, () => sendSettingsButtonClickedEvent()))
+	context.subscriptions.push(vscode.commands.registerCommand(commands.HistoryButton, () => sendHistoryButtonClickedEvent()))
+	context.subscriptions.push(vscode.commands.registerCommand(commands.AccountButton, () => sendAccountButtonClickedEvent()))
+	context.subscriptions.push(vscode.commands.registerCommand(commands.WorktreesButton, () => sendWorktreesButtonClickedEvent()))
+
+	/*
+	We use the text document content provider API to show the left side for diff view by creating a
+	virtual document for the original content. This makes it readonly so users know to edit the right
+	side if they want to keep their changes.
+
+	- This API allows you to create readonly documents in VSCode from arbitrary sources, and works by
+	claiming an uri-scheme for which your provider then returns text contents. The scheme must be
+	provided when registering a provider and cannot change afterwards.
+	- Note how the provider doesn't create uris for virtual documents - its role is to provide contents
+	 given such an uri. In return, content providers are wired into the open document logic so that
+	 providers are always considered.
+	https://code.visualstudio.com/api/extension-guides/virtual-documents
+	*/
+	const diffContentProvider = new (class implements vscode.TextDocumentContentProvider {
+		provideTextDocumentContent(uri: vscode.Uri): string {
+			return Buffer.from(uri.query, "base64").toString("utf-8")
+		}
+	})()
+	context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(DIFF_VIEW_URI_SCHEME, diffContentProvider))
+
+	const handleUri = async (uri: vscode.Uri) => {
+		const url = decodeURIComponent(uri.toString())
+		const uriPath = getUriPath(url)
+		const isTaskUri = uriPath === TASK_URI_PATH || uriPath === LG_TASK_URI_PATH
+
+		if (isTaskUri) {
+			await openClineSidebarForTaskUri()
+		}
+
+		let success = await SharedUriHandler.handleUri(url)
+
+		// Task deeplinks can race with first-time sidebar initialization.
+		if (!success && isTaskUri) {
+			await openClineSidebarForTaskUri()
+			success = await SharedUriHandler.handleUri(url)
+		}
+
+		if (!success) {
+			Logger.warn("Extension URI handler: Failed to process URI:", uri.toString())
+		}
+	}
+	context.subscriptions.push(vscode.window.registerUriHandler({ handleUri }))
+
+	// Debug-harness affordance: VSCode only delivers real vscode:// URIs to the
+	// registered handler above, which the harness can't synthesize. When running
+	// under browser-capture (debug harness) mode, expose the same handler on
+	// globalThis so the harness can deliver simulated OAuth callbacks via
+	// `ext.evaluate`. Gated on CLINE_CAPTURE_BROWSER so it never ships in prod.
+	if (process.env.CLINE_CAPTURE_BROWSER === "1" || process.env.CLINE_CAPTURE_BROWSER === "true") {
+		;(globalThis as Record<string, unknown>).__clineHandleUri = (url: string) => SharedUriHandler.handleUri(url)
+	}
+
+	// Register size testing commands in development mode
+	if (IS_DEV) {
+		vscode.commands.executeCommand("setContext", "cline.isDevMode", IS_DEV)
+		// Use dynamic import to avoid loading the module in production
+		import("./dev/commands/tasks")
+			.then((module) => {
+				const devTaskCommands = module.registerTaskCommands(webview.controller)
+				context.subscriptions.push(...devTaskCommands)
+				Logger.log("[Cline Dev] Dev mode activated & dev commands registered")
+			})
+			.catch((error) => {
+				Logger.log(`[Cline Dev] Failed to register dev commands: ${error}`)
+			})
+	}
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.TerminalOutput, async () => {
+			const terminal = vscode.window.activeTerminal
+			if (!terminal) {
+				return
+			}
+
+			// Save current clipboard content
+			const tempCopyBuffer = await readTextFromClipboard()
+
+			try {
+				// Copy the *existing* terminal selection (without selecting all)
+				await vscode.commands.executeCommand("workbench.action.terminal.copySelection")
+
+				// Get copied content
+				const terminalContents = (await readTextFromClipboard()).trim()
+
+				// Restore original clipboard content
+				await writeTextToClipboard(tempCopyBuffer)
+
+				if (!terminalContents) {
+					// No terminal content was copied (either nothing selected or some error)
+					return
+				}
+				// Ensure the sidebar view is visible but preserve editor focus
+				await showWebview(true)
+
+				await sendAddToInputEvent(`Terminal output:\n\`\`\`\n${terminalContents}\n\`\`\``)
+
+				Logger.log("addSelectedTerminalOutputToChat", terminalContents, terminal.name)
+			} catch (error) {
+				// Ensure clipboard is restored even if an error occurs
+				await writeTextToClipboard(tempCopyBuffer)
+				Logger.error("Error getting terminal contents:", error)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: "Failed to get terminal contents",
+				})
+			}
+		}),
+	)
+
+	// Register code action provider
+	context.subscriptions.push(
+		vscode.languages.registerCodeActionsProvider(
+			"*",
+			new (class implements vscode.CodeActionProvider {
+				public static readonly providedCodeActionKinds = [vscode.CodeActionKind.QuickFix, vscode.CodeActionKind.Refactor]
+
+				provideCodeActions(
+					document: vscode.TextDocument,
+					range: vscode.Range,
+					context: vscode.CodeActionContext,
+				): vscode.CodeAction[] {
+					const CONTEXT_LINES_TO_EXPAND = 3
+					const START_OF_LINE_CHAR_INDEX = 0
+					const LINE_COUNT_ADJUSTMENT_FOR_ZERO_INDEXING = 1
+
+					const actions: vscode.CodeAction[] = []
+					const editor = vscode.window.activeTextEditor // Get active editor for selection check
+
+					// Expand range to include surrounding 3 lines or use selection if broader
+					const selection = editor?.selection
+					let expandedRange = range
+					if (
+						editor &&
+						selection &&
+						!selection.isEmpty &&
+						selection.contains(range.start) &&
+						selection.contains(range.end)
+					) {
+						expandedRange = selection
+					} else {
+						expandedRange = new vscode.Range(
+							Math.max(0, range.start.line - CONTEXT_LINES_TO_EXPAND),
+							START_OF_LINE_CHAR_INDEX,
+							Math.min(
+								document.lineCount - LINE_COUNT_ADJUSTMENT_FOR_ZERO_INDEXING,
+								range.end.line + CONTEXT_LINES_TO_EXPAND,
+							),
+							document.lineAt(
+								Math.min(
+									document.lineCount - LINE_COUNT_ADJUSTMENT_FOR_ZERO_INDEXING,
+									range.end.line + CONTEXT_LINES_TO_EXPAND,
+								),
+							).text.length,
+						)
+					}
+
+					// Add to Cline (Always available)
+					const addAction = new vscode.CodeAction("Add to Cline", vscode.CodeActionKind.QuickFix)
+					addAction.command = {
+						command: commands.AddToChat,
+						title: "Add to Cline",
+						arguments: [expandedRange, context.diagnostics],
+					}
+					actions.push(addAction)
+
+					// Explain with Cline (Always available)
+					const explainAction = new vscode.CodeAction("Explain with Cline", vscode.CodeActionKind.RefactorExtract) // Using a refactor kind
+					explainAction.command = {
+						command: commands.ExplainCode,
+						title: "Explain with Cline",
+						arguments: [expandedRange],
+					}
+					actions.push(explainAction)
+
+					// Improve with Cline (Always available)
+					const improveAction = new vscode.CodeAction("Improve with Cline", vscode.CodeActionKind.RefactorRewrite) // Using a refactor kind
+					improveAction.command = {
+						command: commands.ImproveCode,
+						title: "Improve with Cline",
+						arguments: [expandedRange],
+					}
+					actions.push(improveAction)
+
+					// Fix with Cline (Only if diagnostics exist)
+					if (context.diagnostics.length > 0) {
+						const fixAction = new vscode.CodeAction("Fix with Cline", vscode.CodeActionKind.QuickFix)
+						fixAction.isPreferred = true
+						fixAction.command = {
+							command: commands.FixWithCline,
+							title: "Fix with Cline",
+							arguments: [expandedRange, context.diagnostics],
+						}
+						actions.push(fixAction)
+					}
+					return actions
+				}
+			})(),
+			{
+				providedCodeActionKinds: [
+					vscode.CodeActionKind.QuickFix,
+					vscode.CodeActionKind.RefactorExtract,
+					vscode.CodeActionKind.RefactorRewrite,
+				],
+			},
+		),
+	)
+
+	// Register the command handlers
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.AddToChat, async (range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) => {
+			const context = await getContextForCommand(range, diagnostics)
+			if (!context) {
+				return
+			}
+			await addToCline(context.controller, context.commandContext)
+		}),
+	)
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.FixWithCline, async (range: vscode.Range, diagnostics: vscode.Diagnostic[]) => {
+			const context = await getContextForCommand(range, diagnostics)
+			if (!context) {
+				return
+			}
+			await fixWithCline(context.controller, context.commandContext)
+		}),
+	)
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.ExplainCode, async (range: vscode.Range) => {
+			const context = await getContextForCommand(range)
+			if (!context) {
+				return
+			}
+			await explainWithCline(context.controller, context.commandContext)
+		}),
+	)
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.ImproveCode, async (range: vscode.Range) => {
+			const context = await getContextForCommand(range)
+			if (!context) {
+				return
+			}
+			await improveWithCline(context.controller, context.commandContext)
+		}),
+	)
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.FocusChatInput, async (preserveEditorFocus = false) => {
+			const webview = WebviewProvider.getInstance() as VscodeWebviewProvider
+
+			// Show the webview
+			const webviewView = webview.getWebview()
+			if (webviewView) {
+				if (preserveEditorFocus) {
+					// Only make webview visible without forcing focus
+					webviewView.show(false)
+				} else {
+					// Show and force focus (default behavior for explicit focus actions)
+					webviewView.show(true)
+				}
+			}
+
+			// Send show webview event with preserveEditorFocus flag
+			sendShowWebviewEvent(preserveEditorFocus)
+			telemetryService.captureButtonClick("command_focusChatInput", webview.controller?.task?.ulid)
+		}),
+	)
+
+	// Register Jupyter Notebook command handlers
+	const NOTEBOOK_EDIT_INSTRUCTIONS = `Special considerations for using replace_in_file on *.ipynb files:
+* Jupyter notebook files are JSON format with specific structure for source code cells
+* Source code in cells is stored as JSON string arrays ending with explicit \\n characters and commas
+* Always match the exact JSON format including quotes, commas, and escaped newlines.`
+
+	// Helper to get notebook context for Jupyter commands
+	async function getNotebookCommandContext(range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) {
+		const activeNotebook = vscode.window.activeNotebookEditor
+		if (!activeNotebook) {
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: "No active Jupyter notebook found. Please open a .ipynb file first.",
+			})
+			return null
+		}
+
+		const ctx = await getContextForCommand(range, diagnostics)
+		if (!ctx) {
+			return null
+		}
+
+		const filePath = ctx.commandContext.filePath || ""
+		let cellJson: string | null = null
+		if (activeNotebook.notebook.cellCount > 0) {
+			const cellIndex = activeNotebook.notebook.cellAt(activeNotebook.selection.start).index
+			cellJson = await findMatchingNotebookCell(filePath, cellIndex)
+		}
+
+		return { ...ctx, cellJson }
+	}
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			commands.JupyterGenerateCell,
+			async (range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) => {
+				const userPrompt = await showJupyterPromptInput(
+					"Generate Notebook Cell",
+					"Enter your prompt for generating notebook cell (press Enter to confirm & Esc to cancel)",
+				)
+				if (!userPrompt) return
+
+				const ctx = await getNotebookCommandContext(range, diagnostics)
+				if (!ctx) return
+
+				const notebookContext = `User prompt: ${userPrompt}
+Insert a new Jupyter notebook cell above or below the current cell based on user prompt.
+${NOTEBOOK_EDIT_INSTRUCTIONS}
+
+Current Notebook Cell Context (JSON, sanitized of image data):
+\`\`\`json
+${ctx.cellJson || "{}"}
+\`\`\``
+
+				await addToCline(ctx.controller, ctx.commandContext, notebookContext)
+			},
+		),
+	)
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			commands.JupyterExplainCell,
+			async (range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) => {
+				const ctx = await getNotebookCommandContext(range, diagnostics)
+				if (!ctx) return
+
+				const notebookContext = ctx.cellJson
+					? `\n\nCurrent Notebook Cell Context (JSON, sanitized of image data):\n\`\`\`json\n${ctx.cellJson}\n\`\`\``
+					: undefined
+
+				await explainWithCline(ctx.controller, ctx.commandContext, notebookContext)
+			},
+		),
+	)
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			commands.JupyterImproveCell,
+			async (range?: vscode.Range, diagnostics?: vscode.Diagnostic[]) => {
+				const userPrompt = await showJupyterPromptInput(
+					"Improve Notebook Cell",
+					"Enter your prompt for improving the current notebook cell (press Enter to confirm & Esc to cancel)",
+				)
+				if (!userPrompt) return
+
+				const ctx = await getNotebookCommandContext(range, diagnostics)
+				if (!ctx) return
+
+				const notebookContext = `User prompt: ${userPrompt}
+${NOTEBOOK_EDIT_INSTRUCTIONS}
+
+Current Notebook Cell Context (JSON, sanitized of image data):
+\`\`\`json
+${ctx.cellJson || "{}"}
+\`\`\``
+
+				await improveWithCline(ctx.controller, ctx.commandContext, notebookContext)
+			},
+		),
+	)
+
+	// Register the openWalkthrough command handler
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.Walkthrough, async () => {
+			await vscode.commands.executeCommand("workbench.action.openWalkthrough", `${context.extension.id}#ClineWalkthrough`)
+			telemetryService.captureButtonClick("command_openWalkthrough")
+		}),
+	)
+
+	// Register the generateGitCommitMessage command handler
+	context.subscriptions.push(
+		vscode.commands.registerCommand(commands.GenerateCommit, async (scm) => {
+			generateCommitMsg(webview.controller, scm)
+		}),
+		vscode.commands.registerCommand(commands.AbortCommit, () => {
+			abortCommitGeneration()
+		}),
+	)
+
+	// Listen for secrets changes (cross-window login/logout sync).
+	// NOTE: Credentials now live in providers.json (single source of truth).
+	// This listener catches legacy secrets.json writes from older windows and
+	// triggers a re-read from providers.json via restoreRefreshTokenAndRetrieveAuthInfo().
+	const unsubSecrets = storageContext.secrets.onDidChange((event) => {
+		if (event.key === "cline:clineAccountId") {
+			const secretValue = storageContext.secrets.get<string>(event.key)
+			const activeWebview = WebviewProvider.getVisibleInstance()
+			const controller = activeWebview?.controller
+
+			const authService = AuthService.getInstance(controller)
+			if (secretValue) {
+				// Secret was added or updated - restore auth info (login from another window)
+				authService?.restoreRefreshTokenAndRetrieveAuthInfo()
+			} else {
+				// Secret was removed - handle logout for all windows
+				authService?.handleDeauth(LogoutReason.CROSS_WINDOW_SYNC)
+			}
+		}
+	})
+	context.subscriptions.push({ dispose: unsubSecrets })
+
+	Logger.log(`[Cline] extension activated in ${performance.now() - activationStartTime} ms`)
+
+	return createClineAPI(webview.controller)
+}
+
+async function showJupyterPromptInput(title: string, placeholder: string): Promise<string | undefined> {
+	return new Promise((resolve) => {
+		const quickPick = vscode.window.createQuickPick()
+		quickPick.title = title
+		quickPick.placeholder = placeholder
+		quickPick.ignoreFocusOut = true
+
+		// Allow free text input
+		quickPick.canSelectMany = false
+
+		let userInput = ""
+
+		quickPick.onDidChangeValue((value) => {
+			userInput = value
+			// Update items to show the current input
+			if (value) {
+				quickPick.items = [
+					{
+						label: "$(check) Use this prompt",
+						detail: value,
+						alwaysShow: true,
+					},
+				]
+			} else {
+				quickPick.items = []
+			}
+		})
+
+		quickPick.onDidAccept(() => {
+			if (userInput) {
+				resolve(userInput)
+				quickPick.hide()
+			}
+		})
+
+		quickPick.onDidHide(() => {
+			if (!userInput) {
+				resolve(undefined)
+			}
+			quickPick.dispose()
+		})
+
+		quickPick.show()
+	})
+}
+
+function setupHostProvider(context: ExtensionContext) {
+	const outputChannel = registerClineOutputChannel(context)
+	outputChannel.appendLine("[Cline] Setting up VS Code host...")
+
+	const createWebview = () => new VscodeWebviewProvider(context)
+	const createDiffView = () => new VscodeDiffViewProvider()
+	const createCommentReview = () => getVscodeCommentReviewController()
+	const createTerminalManager = () => new VscodeTerminalManager()
+
+	const getCallbackUrl = async (path: string, _preferredPort?: number) => {
+		const scheme = vscode.env.uriScheme || "vscode"
+		const callbackUri = vscode.Uri.parse(`${scheme}://${context.extension.id}${path}`)
+
+		if (vscode.env.uiKind === vscode.UIKind.Web) {
+			// In VS Code Web (Codespaces, code serve-web), vscode:// URIs redirect to the
+			// desktop app instead of staying in the browser. Use asExternalUri to convert
+			// to a web-reachable HTTPS URL that routes back to the extension's URI handler.
+			const externalUri = await vscode.env.asExternalUri(callbackUri)
+			return externalUri.toString(true)
+		}
+
+		// In regular desktop VS Code, use the vscode:// URI protocol handler directly.
+		return callbackUri.toString(true)
+	}
+	HostProvider.initialize(
+		createWebview,
+		createDiffView,
+		createCommentReview,
+		createTerminalManager,
+		vscodeHostBridgeClient,
+		() => {}, // No-op logger, logging is handled via HostProvider.env.debugLog
+		getCallbackUrl,
+		getBinaryLocation,
+		context.extensionUri.fsPath,
+		context.globalStorageUri.fsPath,
+	)
+}
+
+function getUriPath(url: string): string | undefined {
+	try {
+		return new URL(url).pathname
+	} catch {
+		return undefined
+	}
+}
+
+async function openClineSidebarForTaskUri(): Promise<void> {
+	const sidebarWaitTimeoutMs = 3000
+	const sidebarWaitIntervalMs = 50
+
+	await vscode.commands.executeCommand(`${ExtensionRegistryInfo.views.Sidebar}.focus`)
+
+	const startedAt = Date.now()
+	while (Date.now() - startedAt < sidebarWaitTimeoutMs) {
+		if (WebviewProvider.getVisibleInstance()) {
+			return
+		}
+		await new Promise((resolve) => setTimeout(resolve, sidebarWaitIntervalMs))
+	}
+
+	Logger.warn("Task URI handling timed out waiting for Cline sidebar visibility")
+}
+
+async function getBinaryLocation(name: string): Promise<string> {
+	// The only binary currently supported is the rg binary from the VSCode installation.
+	if (!name.startsWith("rg")) {
+		throw new Error(`Binary '${name}' is not supported`)
+	}
+
+	const checkPath = async (pkgFolder: string) => {
+		const fullPathResult = workspaceResolver.resolveWorkspacePath(
+			vscode.env.appRoot,
+			path.join(pkgFolder, name),
+			"Services.ripgrep.getBinPath",
+		)
+		const fullPath = typeof fullPathResult === "string" ? fullPathResult : fullPathResult.absolutePath
+		return (await fileExistsAtPath(fullPath)) ? fullPath : undefined
+	}
+
+	// VS Code 1.122.0 (microsoft/vscode#317978 et al.) migrated from @vscode/ripgrep
+	// to @vscode/ripgrep-universal, which ships per-platform/arch subdirectories.
+	// Probe the new layout first; fall back to the legacy paths for ≤1.121.x.
+	const platformArch = `${process.platform}-${process.arch}`
+	const binPath =
+		(await checkPath(`node_modules/@vscode/ripgrep-universal/bin/${platformArch}/`)) ||
+		(await checkPath(`node_modules.asar.unpacked/@vscode/ripgrep-universal/bin/${platformArch}/`)) ||
+		(await checkPath("node_modules/@vscode/ripgrep/bin/")) ||
+		(await checkPath("node_modules/vscode-ripgrep/bin")) ||
+		(await checkPath("node_modules.asar.unpacked/vscode-ripgrep/bin/")) ||
+		(await checkPath("node_modules.asar.unpacked/@vscode/ripgrep/bin/"))
+	if (!binPath) {
+		throw new Error("Could not find ripgrep binary")
+	}
+	return binPath
+}
+
+// This method is called when your extension is deactivated
+export async function deactivate() {
+	// Dispose Non-VSCode-specific services
+	try {
+		await tearDown()
+	} finally {
+		// VSCode-specific services
+		disposeVscodeCommentReviewController()
+	}
+}
+
+// TODO: Find a solution for automatically removing DEV related content from production builds.
+//  This type of code is fine in production to keep. We just will want to remove it from production builds
+//  to bring down built asset sizes.
+//
+// This is a workaround to reload the extension when the source code changes
+// since vscode doesn't support hot reload for extensions
+const IS_DEV = process.env.IS_DEV === "true"
+const DEV_WORKSPACE_FOLDER = process.env.DEV_WORKSPACE_FOLDER
+
+// Set up development mode file watcher
+if (IS_DEV) {
+	assert(DEV_WORKSPACE_FOLDER, "DEV_WORKSPACE_FOLDER must be set in development")
+	const watcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(DEV_WORKSPACE_FOLDER, "src/**/*"))
+
+	watcher.onDidChange(({ scheme, path }) => {
+		Logger.info(`${scheme} ${path} changed. Reloading VSCode...`)
+
+		vscode.commands.executeCommand("workbench.action.reloadWindow")
+	})
+}
+
+// VSCode-specific storage migrations
+async function cleanupLegacyVSCodeStorage(context: ExtensionContext): Promise<void> {
+	try {
+		await cleanupOldApiKey(context)
+		// Migrate is not done if the new storage does not have the lastShownAnnouncementId flag
+		const hasMigrated = context.globalState.get("lastShownAnnouncementId")
+		if (hasMigrated !== undefined) {
+			return
+		}
+
+		Logger.info("[VS Code Storage Migrations] Starting")
+
+		// Migrate custom instructions to global Cline rules (one-time cleanup)
+		await migrateCustomInstructionsToGlobalRules(context)
+
+		// Migrate welcomeViewCompleted setting based on existing API keys (one-time cleanup)
+		await migrateWelcomeViewCompleted(context)
+
+		// Migrate workspace storage values back to global storage (reverting previous migration)
+		await migrateWorkspaceToGlobalStorage(context)
+
+		// Ensure taskHistory.json exists and migrate legacy state (runs once)
+		await migrateTaskHistoryToFile(context)
+
+		// Clean up MCP marketplace catalog from global state (moved to disk cache)
+		await cleanupMcpMarketplaceCatalogFromGlobalState(context)
+
+		// lastShownAnnouncementId will be set when announcement is shown
+		// after activation so we don't need to set it here.
+
+		Logger.info("[VS Code Storage Migrations] Completed")
+	} catch (error) {
+		Logger.warn(`[VS Code Storage Migrations] Failed${error instanceof Error ? `: ${error.message}` : ""}`)
+	}
+}
diff --git a/apps/vscode/src/hosts/external/AuthHandler.ts b/apps/vscode/src/hosts/external/AuthHandler.ts
new file mode 100644
index 0000000..f24d67b
--- /dev/null
+++ b/apps/vscode/src/hosts/external/AuthHandler.ts
@@ -0,0 +1,332 @@
+import type { IncomingMessage, Server, ServerResponse } from "node:http"
+import http from "node:http"
+import type { AddressInfo } from "node:net"
+import { SharedUriHandler } from "@/services/uri/SharedUriHandler"
+import { Logger } from "@/shared/services/Logger"
+import { HostProvider } from "../host-provider"
+
+const SERVER_TIMEOUT = 10 * 60 * 1000 // 10 minutes
+
+const PORT_RANGE_START = 48801
+const PORT_RANGE_END = 48811
+const PORTS: number[] = Array.from({ length: PORT_RANGE_END - PORT_RANGE_START + 1 }, (_, i) => PORT_RANGE_START + i)
+
+/**
+ * Handles OAuth authentication flow by creating a local server to receive tokens.
+ */
+export class AuthHandler {
+	private static instance: AuthHandler | null = null
+
+	private port = 0
+	private server: Server | null = null
+	private serverCreationPromise: Promise<void> | null = null
+	private timeoutId: NodeJS.Timeout | null = null
+	private enabled = false
+
+	private constructor() {}
+
+	/**
+	 * Gets the singleton instance of AuthHandler
+	 * @returns The singleton AuthHandler instance
+	 */
+	public static getInstance(): AuthHandler {
+		if (!AuthHandler.instance) {
+			AuthHandler.instance = new AuthHandler()
+		}
+		return AuthHandler.instance
+	}
+
+	public setEnabled(enabled: boolean): void {
+		this.enabled = enabled
+	}
+
+	public async getCallbackUrl(path = "", preferredPort?: number): Promise<string> {
+		if (!this.enabled) {
+			throw Error("AuthHandler was not enabled")
+		}
+
+		if (!this.server) {
+			// If server creation is already in progress, wait for it
+			if (this.serverCreationPromise) {
+				await this.serverCreationPromise
+			} else {
+				// Start server creation and track the promise
+				// Pass preferred port so we try to bind it first (preserves OAuth client registrations)
+				this.serverCreationPromise = this.createServer(preferredPort)
+				await this.serverCreationPromise
+			}
+		} else {
+			this.updateTimeout()
+		}
+
+		return `http://127.0.0.1:${this.port}${path}`
+	}
+
+	private async createServer(preferredPort?: number): Promise<void> {
+		return new Promise(async (resolve, reject) => {
+			try {
+				const server = http.createServer(this.handleRequest.bind(this))
+
+				// Build the port list: try preferred port first (if provided), then the normal range
+				const portsToTry = preferredPort ? [preferredPort, ...PORTS.filter((p) => p !== preferredPort)] : PORTS
+
+				// Try to bind on a port from the list
+				for (const port of portsToTry) {
+					try {
+						await this.tryListenOnPort(server, port)
+
+						const address = server.address()
+						if (!address) {
+							Logger.error("AuthHandler: Failed to get server address")
+							this.server = null
+							this.port = 0
+							this.serverCreationPromise = null
+							reject(new Error("Failed to get server address"))
+							return
+						}
+
+						// Get the assigned port and set up the server
+						this.port = (address as AddressInfo).port
+						this.server = server
+						Logger.log("AuthHandler: Server started on port", this.port)
+						this.updateTimeout()
+						this.serverCreationPromise = null
+
+						// Attach a general error logger for visibility after successful bind
+						server.on("error", (error) => {
+							Logger.error("AuthHandler: Server error", error)
+						})
+
+						resolve()
+						return
+					} catch (error) {
+						const err = error as NodeJS.ErrnoException
+						if (err?.code === "EADDRINUSE") {
+							Logger.warn(`AuthHandler: Port ${port} in use, trying next...`)
+							continue
+						}
+						Logger.error("AuthHandler: Server error", error)
+						this.server = null
+						this.port = 0
+						this.serverCreationPromise = null
+						reject(error)
+						return
+					}
+				}
+
+				// If we reach here, all ports in the range are occupied
+				Logger.error(`AuthHandler: No available port in range ${PORT_RANGE_START}-${PORT_RANGE_END}`)
+				this.server = null
+				this.port = 0
+				this.serverCreationPromise = null
+				reject(
+					new Error(`No available port found for local auth callback (tried ${PORT_RANGE_START}-${PORT_RANGE_END}).`),
+				)
+			} catch (error) {
+				Logger.error("AuthHandler: Failed to create server", error)
+				this.server = null
+				this.port = 0
+				this.serverCreationPromise = null
+				reject(error)
+			}
+		})
+	}
+
+	private tryListenOnPort(server: Server, port: number): Promise<void> {
+		return new Promise((resolve, reject) => {
+			const onError = (error: NodeJS.ErrnoException) => {
+				server.off("error", onError)
+				reject(error)
+			}
+			server.once("error", onError)
+			server.listen(port, "127.0.0.1", () => {
+				server.off("error", onError)
+				resolve()
+			})
+		})
+	}
+
+	private updateTimeout(): void {
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId)
+		}
+
+		this.timeoutId = setTimeout(() => this.stop(), SERVER_TIMEOUT)
+	}
+
+	private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+		Logger.log("AuthHandler: Received request", req.url)
+
+		if (!req.url) {
+			this.sendResponse(res, 404, "text/plain", "Not found")
+			return
+		}
+
+		try {
+			const fullUrl = `http://127.0.0.1:${this.port}${req.url}`
+
+			// Use SharedUriHandler directly - it handles all validation and processing
+			const success = await SharedUriHandler.handleUri(fullUrl)
+
+			// Try to get redirect URI, but don't fail if not implemented (CLI/JetBrains)
+			let redirectUri: string | undefined
+			try {
+				redirectUri = (await HostProvider.env.getIdeRedirectUri({})).value
+				Logger.log("AuthHandler: Got redirect URI:", redirectUri)
+			} catch (error) {
+				// CLI or JetBrains mode - redirect not available
+				Logger.log("AuthHandler: No redirect URI available (CLI/JetBrains mode)")
+				redirectUri = undefined
+			}
+
+			const html = createAuthSucceededHtml(redirectUri)
+
+			if (success) {
+				this.sendResponse(res, 200, "text/html", html)
+			} else {
+				this.sendResponse(res, 400, "text/plain", "Bad request")
+			}
+		} catch (error) {
+			Logger.error("AuthHandler: Error processing request", error)
+			this.sendResponse(res, 400, "text/plain", "Bad request")
+		} finally {
+			// Stop the server after handling any request (success or failure)
+			this.stop()
+		}
+	}
+
+	private sendResponse(res: ServerResponse, status: number, type: string, content: string): void {
+		res.writeHead(status, { "Content-Type": type })
+		res.end(content)
+	}
+
+	public stop(): void {
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId)
+			this.timeoutId = null
+		}
+
+		if (this.server) {
+			this.server.close()
+			this.server = null
+		}
+
+		this.serverCreationPromise = null
+		this.port = 0
+	}
+
+	public dispose(): void {
+		this.stop()
+	}
+}
+
+function createAuthSucceededHtml(redirectUri?: string): string {
+	const redirect = redirectUri ? `<script>setTimeout(() => { window.location.href = '${redirectUri}'; }, 1000);</script>` : ""
+	// Use "terminal" for CLI (no redirect), "IDE" for VSCode/JetBrains (with redirect)
+	const platform = redirectUri ? "IDE" : "terminal"
+
+	const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cline - Authentication Success</title>
+	${redirect}
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Azeret:wght@300;400;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Azeret', sans-serif;
+            background-color: #ffffff;
+            color: #333333;
+            height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            line-height: 1.25;
+        }
+        
+        .container {
+            text-align: center;
+            padding: 32px;
+            background-color: #f8f8f8;
+            border: 1px solid #e1e1e1;
+            border-radius: 6px;
+            max-width: 480px;
+            width: 90%;
+        }
+        
+        .checkmark {
+            width: 48px;
+            height: 48px;
+            border-radius: 50%;
+            background-color: #73c991;
+            margin: 0 auto 24px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        
+        .checkmark::after {
+            content: '✓';
+            font-size: 24px;
+            color: #ffffff;
+            font-weight: bold;
+        }
+        
+        h1 {
+            font-size: 1.5rem;
+            margin-bottom: 16px;
+            font-weight: 400;
+            color: #333333;
+        }
+        
+        p {
+            font-size: 0.875rem;
+            line-height: 1.5;
+            margin-bottom: 24px;
+            color: #666666;
+        }
+        
+        .countdown {
+            font-size: 0.8125rem;
+            color: #666666;
+            background-color: #ffffff;
+            border: 1px solid #d1d1d1;
+            padding: 8px 16px;
+            border-radius: 4px;
+            display: inline-block;
+        }
+        
+        @media (max-width: 480px) {
+            .container {
+                padding: 24px 16px;
+            }
+            
+            h1 {
+                font-size: 1.25rem;
+            }
+            
+            p {
+                font-size: 0.8125rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="checkmark"></div>
+        <h1>Authentication Successful</h1>
+        <p>Your authentication token has been securely sent back to your ${platform}. You can now return to your development environment to continue working.</p>
+        <div class="countdown">Feel free to close this window and continue in your ${platform}</div>
+    </div>
+</body>
+</html>`
+	return html
+}
diff --git a/apps/vscode/src/hosts/external/ExternalCommentReviewController.ts b/apps/vscode/src/hosts/external/ExternalCommentReviewController.ts
new file mode 100644
index 0000000..86fa558
--- /dev/null
+++ b/apps/vscode/src/hosts/external/ExternalCommentReviewController.ts
@@ -0,0 +1,60 @@
+import { CommentReviewController, type ReviewComment } from "@/integrations/editor/CommentReviewController"
+
+/**
+ * External (non-VS Code) implementation of CommentReviewController.
+ *
+ * This is a no-op implementation for platforms that don't support
+ * inline code comments (e.g., JetBrains, CLI).
+ */
+export class ExternalCommentReviewController extends CommentReviewController {
+	async ensureCommentsViewDisabled(): Promise<void> {
+		// No-op
+	}
+
+	addReviewComment(_comment: ReviewComment): void {
+		// No-op
+	}
+
+	startStreamingComment(
+		_filePath: string,
+		_startLine: number,
+		_endLine: number,
+		_relativePath?: string,
+		_fileContent?: string,
+		_revealComment?: boolean,
+	): void {
+		// No-op
+	}
+
+	appendToStreamingComment(_chunk: string): void {
+		// No-op
+	}
+
+	endStreamingComment(): void {
+		// No-op
+	}
+
+	addReviewComments(_comments: ReviewComment[]): void {
+		// No-op
+	}
+
+	clearAllComments(): void {
+		// No-op
+	}
+
+	clearCommentsForFile(_filePath: string): void {
+		// No-op
+	}
+
+	getThreadCount(): number {
+		return 0
+	}
+
+	async closeDiffViews(): Promise<void> {
+		// No-op
+	}
+
+	dispose(): void {
+		// No-op
+	}
+}
diff --git a/apps/vscode/src/hosts/external/ExternalDiffviewProvider.ts b/apps/vscode/src/hosts/external/ExternalDiffviewProvider.ts
new file mode 100644
index 0000000..dd67214
--- /dev/null
+++ b/apps/vscode/src/hosts/external/ExternalDiffviewProvider.ts
@@ -0,0 +1,106 @@
+import { status } from "@grpc/grpc-js"
+import { HostProvider } from "@/hosts/host-provider"
+import { DiffViewProvider } from "@/integrations/editor/DiffViewProvider"
+import { Logger } from "@/shared/services/Logger"
+
+export class ExternalDiffViewProvider extends DiffViewProvider {
+	private activeDiffEditorId: string | undefined
+
+	override async openDiffEditor(): Promise<void> {
+		if (!this.absolutePath) {
+			return
+		}
+		const response = await HostProvider.diff.openDiff({
+			path: this.absolutePath,
+			content: this.originalContent ?? "",
+		})
+		this.activeDiffEditorId = response.diffId
+	}
+
+	override async replaceText(
+		content: string,
+		rangeToReplace: { startLine: number; endLine: number },
+		_currentLine: number | undefined,
+	): Promise<void> {
+		if (!this.activeDiffEditorId) {
+			return
+		}
+		await HostProvider.diff.replaceText({
+			diffId: this.activeDiffEditorId,
+			content: content,
+			startLine: rangeToReplace.startLine,
+			endLine: rangeToReplace.endLine,
+		})
+	}
+
+	protected override async truncateDocument(lineNumber: number): Promise<void> {
+		if (!this.activeDiffEditorId) {
+			return
+		}
+		await HostProvider.diff.truncateDocument({
+			diffId: this.activeDiffEditorId,
+			endLine: lineNumber,
+		})
+	}
+
+	protected override async getDocumentLineCount(): Promise<number> {
+		const text = await this.getDocumentText()
+		if (!text) {
+			return 0
+		}
+		// Count lines: split by newline, but handle trailing newline correctly
+		const lines = text.split("\n")
+		// If text ends with newline, split creates an extra empty string at the end
+		// which represents the "line" after the final newline - this is correct line count
+		return lines.length
+	}
+
+	protected async saveDocument(): Promise<Boolean> {
+		if (!this.activeDiffEditorId) {
+			return false
+		}
+		try {
+			await HostProvider.diff.saveDocument({ diffId: this.activeDiffEditorId })
+			return true
+		} catch (err: any) {
+			if (err.code === status.NOT_FOUND) {
+				// This can happen when the task is reloaded or the diff editor is closed. So, don't
+				// consider it a real error.
+				Logger.log("Diff not found:", this.activeDiffEditorId)
+				return false
+			} else {
+				throw err
+			}
+		}
+	}
+
+	protected override async scrollEditorToLine(line: number): Promise<void> {
+		if (!this.activeDiffEditorId) {
+			return
+		}
+		await HostProvider.diff.scrollDiff({ diffId: this.activeDiffEditorId, line: line })
+	}
+
+	override async scrollAnimation(_startLine: number, _endLine: number): Promise<void> {}
+
+	protected override async getDocumentText(): Promise<string | undefined> {
+		if (!this.activeDiffEditorId) {
+			return undefined
+		}
+		try {
+			return (await HostProvider.diff.getDocumentText({ diffId: this.activeDiffEditorId })).content
+		} catch (err) {
+			Logger.log("Error getting contents of diff editor", err)
+			return undefined
+		}
+	}
+
+	protected override async closeAllDiffViews(): Promise<void> {
+		await HostProvider.diff.closeAllDiffs({})
+		this.activeDiffEditorId = undefined
+	}
+
+	protected override async resetDiffView(): Promise<void> {
+		this.activeDiffEditorId = undefined
+	}
+}
diff --git a/apps/vscode/src/hosts/external/ExternalWebviewProvider.ts b/apps/vscode/src/hosts/external/ExternalWebviewProvider.ts
new file mode 100644
index 0000000..1f937aa
--- /dev/null
+++ b/apps/vscode/src/hosts/external/ExternalWebviewProvider.ts
@@ -0,0 +1,18 @@
+import { WebviewProvider } from "@/core/webview"
+
+export class ExternalWebviewProvider extends WebviewProvider {
+	// This hostname cannot be changed without updating the external webview handler.
+	private RESOURCE_HOSTNAME: string = "internal.resources"
+
+	override getWebviewUrl(path: string) {
+		const url = new URL(`https://${this.RESOURCE_HOSTNAME}/`)
+		url.pathname = path
+		return url.toString()
+	}
+	override getCspSource() {
+		return `'self' https://${this.RESOURCE_HOSTNAME}`
+	}
+	override isVisible() {
+		return true
+	}
+}
diff --git a/apps/vscode/src/hosts/external/grpc-types.ts b/apps/vscode/src/hosts/external/grpc-types.ts
new file mode 100644
index 0000000..60818dd
--- /dev/null
+++ b/apps/vscode/src/hosts/external/grpc-types.ts
@@ -0,0 +1,88 @@
+import { Controller } from "@core/controller"
+import * as grpc from "@grpc/grpc-js"
+import { Channel, createChannel } from "nice-grpc"
+
+/**
+ * Type definition for a gRPC handler function.
+ * This represents a function that takes a Controller instance and a request object,
+ * and returns a Promise of the response type.
+ *
+ * @template TRequest - The type of the request object
+ * @template TResponse - The type of the response object
+ */
+export type GrpcHandler<TRequest, TResponse> = (controller: Controller, req: TRequest) => Promise<TResponse>
+
+export type GrpcStreamingResponseHandler<TRequest, TResponse> = (
+	controller: Controller,
+	req: TRequest,
+	streamResponseHandler: StreamingResponseWriter<TResponse>,
+	requestId?: string,
+) => Promise<void>
+
+/**
+ * Type definition for the wrapper function that converts a Promise-based handler
+ * to a gRPC callback-style handler.
+ *
+ * @template TRequest - The type of the request object
+ * @template TResponse - The type of the response object
+ */
+export type GrpcHandlerWrapper = <TRequest, TResponse>(
+	handler: GrpcHandler<TRequest, TResponse>,
+	controller: Controller,
+) => grpc.handleUnaryCall<TRequest, TResponse>
+
+export type GrpcStreamingResponseHandlerWrapper = <TRequest, TResponse>(
+	handler: GrpcStreamingResponseHandler<TRequest, TResponse>,
+	controller: Controller,
+) => grpc.handleServerStreamingCall<TRequest, TResponse>
+
+type StreamingResponseWriter<TResponse> = (response: TResponse, isLast?: boolean, sequenceNumber?: number) => Promise<void>
+
+/**
+ * Abstract base class for type-safe gRPC client implementations.
+ *
+ * Provides automatic connection management with lazy initialization and
+ * transparent reconnection on network failures. Ensures type safety through
+ * generic client typing and consistent error handling patterns.
+ *
+ * @template TClient - The specific gRPC client type (e.g., niceGrpc.host.DiffServiceClient)
+ */
+export abstract class BaseGrpcClient<TClient> {
+	private client: TClient | null = null
+	private channel: Channel | null = null
+	protected address: string
+
+	constructor(address: string) {
+		this.address = address
+	}
+
+	protected abstract createClient(channel: Channel): TClient
+
+	protected getClient(): TClient {
+		if (!this.client || !this.channel) {
+			const channelOptions = { "grpc.enable_http_proxy": 0 }
+			this.channel = createChannel(this.address, undefined, channelOptions)
+			this.client = this.createClient(this.channel)
+		}
+		return this.client
+	}
+
+	protected destroyClient(): void {
+		this.channel?.close()
+		this.client = null
+		this.channel = null
+	}
+
+	protected async makeRequest<T>(requestFn: (client: TClient) => Promise<T>): Promise<T> {
+		const client = this.getClient()
+
+		try {
+			return await requestFn(client)
+		} catch (error: any) {
+			if (error?.code === "UNAVAILABLE") {
+				this.destroyClient()
+			}
+			throw error
+		}
+	}
+}
diff --git a/apps/vscode/src/hosts/external/host-bridge-client-manager.ts b/apps/vscode/src/hosts/external/host-bridge-client-manager.ts
new file mode 100644
index 0000000..c36ad81
--- /dev/null
+++ b/apps/vscode/src/hosts/external/host-bridge-client-manager.ts
@@ -0,0 +1,34 @@
+import {
+	DiffServiceClientInterface,
+	EnvServiceClientInterface,
+	WindowServiceClientInterface,
+	WorkspaceServiceClientInterface,
+} from "@generated/hosts/host-bridge-client-types"
+import {
+	DiffServiceClientImpl,
+	EnvServiceClientImpl,
+	WindowServiceClientImpl,
+	WorkspaceServiceClientImpl,
+} from "@generated/hosts/standalone/host-bridge-clients"
+import { HostBridgeClientProvider } from "@/hosts/host-provider-types"
+import { HOSTBRIDGE_PORT } from "@/standalone/hostbridge-client"
+
+/**
+ * Manager to hold the gRPC clients for the host bridge. The clients should be re-used to avoid
+ * creating a new TCP connection every time a rpc is made.
+ */
+export class ExternalHostBridgeClientManager implements HostBridgeClientProvider {
+	workspaceClient: WorkspaceServiceClientInterface
+	envClient: EnvServiceClientInterface
+	windowClient: WindowServiceClientInterface
+	diffClient: DiffServiceClientInterface
+
+	constructor() {
+		const address = process.env.HOST_BRIDGE_ADDRESS || `localhost:${HOSTBRIDGE_PORT}`
+
+		this.workspaceClient = new WorkspaceServiceClientImpl(address)
+		this.envClient = new EnvServiceClientImpl(address)
+		this.windowClient = new WindowServiceClientImpl(address)
+		this.diffClient = new DiffServiceClientImpl(address)
+	}
+}
diff --git a/apps/vscode/src/hosts/host-provider-types.ts b/apps/vscode/src/hosts/host-provider-types.ts
new file mode 100644
index 0000000..d558e11
--- /dev/null
+++ b/apps/vscode/src/hosts/host-provider-types.ts
@@ -0,0 +1,25 @@
+import {
+	DiffServiceClientInterface,
+	EnvServiceClientInterface,
+	WindowServiceClientInterface,
+	WorkspaceServiceClientInterface,
+} from "@generated/hosts/host-bridge-client-types"
+
+/**
+ * Interface for host bridge client providers
+ */
+export interface HostBridgeClientProvider {
+	workspaceClient: WorkspaceServiceClientInterface
+	envClient: EnvServiceClientInterface
+	windowClient: WindowServiceClientInterface
+	diffClient: DiffServiceClientInterface
+}
+
+/**
+ * Callback interface for streaming requests
+ */
+export interface StreamingCallbacks<T = any> {
+	onResponse: (response: T) => void
+	onError?: (error: Error) => void
+	onComplete?: () => void
+}
diff --git a/apps/vscode/src/hosts/host-provider.ts b/apps/vscode/src/hosts/host-provider.ts
new file mode 100644
index 0000000..4630e02
--- /dev/null
+++ b/apps/vscode/src/hosts/host-provider.ts
@@ -0,0 +1,165 @@
+import { WebviewProvider } from "@/core/webview"
+import { CommentReviewController } from "@/integrations/editor/CommentReviewController"
+import { DiffViewProvider } from "@/integrations/editor/DiffViewProvider"
+import { ITerminalManager } from "@/integrations/terminal/types"
+import { HostBridgeClientProvider } from "./host-provider-types"
+/**
+ * Singleton class that manages host-specific providers for dependency injection.
+ *
+ * This system runs on two different platforms (VSCode extension and cline-core),
+ * so all the host-specific classes and properties are contained in here. The
+ * rest of the codebase can use the host provider interface to access platform-specific
+ * implementations in a platform-agnostic way.
+ *
+ * Usage:
+ * - Initialize once: HostProvider.initialize(webviewCreator, diffCreator, hostBridge)
+ * - Access HostBridge services: HostProvider.window.showMessage()
+ * - Access Host Provider factories: HostProvider.get().createDiffViewProvider()
+ */
+export class HostProvider {
+	private static instance: HostProvider | null = null
+
+	createWebviewProvider: WebviewProviderCreator
+	createDiffViewProvider: DiffViewProviderCreator
+	createCommentReviewController: CommentReviewControllerCreator
+	createTerminalManager: TerminalManagerCreator
+	hostBridge: HostBridgeClientProvider
+
+	// Logs to a user-visible output channel.
+	logToChannel: LogToChannel
+
+	// Returns a callback URL that will redirect to Cline.
+	// The path parameter specifies the route for the callback (e.g., "/auth", "/openrouter").
+	// The optional preferredPort parameter hints that the provider should try to bind
+	// this specific port first (used to preserve OAuth client registrations across sessions).
+	getCallbackUrl: (path: string, preferredPort?: number) => Promise<string>
+
+	// Returns the location of the binary `name`.
+	// Use `getBinaryLocation()` from utils/ts.ts instead of using
+	// this directly. The helper function correctly handles the file
+	// extension on Windows.
+	getBinaryLocation: (name: string) => Promise<string>
+
+	// The absolute file system path where the extension is installed.
+	// Use to this to get the location of extension assets.
+	extensionFsPath: string
+
+	// The absolute file system path where the extension can store global state.
+	globalStorageFsPath: string
+
+	// Private constructor to enforce singleton pattern
+	private constructor(
+		createWebviewProvider: WebviewProviderCreator,
+		createDiffViewProvider: DiffViewProviderCreator,
+		createCommentReviewController: CommentReviewControllerCreator,
+		createTerminalManager: TerminalManagerCreator,
+		hostBridge: HostBridgeClientProvider,
+		logToChannel: LogToChannel,
+		getCallbackUrl: (path: string, preferredPort?: number) => Promise<string>,
+		getBinaryLocation: (name: string) => Promise<string>,
+		extensionFsPath: string,
+		globalStorageFsPath: string,
+	) {
+		this.createWebviewProvider = createWebviewProvider
+		this.createDiffViewProvider = createDiffViewProvider
+		this.createCommentReviewController = createCommentReviewController
+		this.createTerminalManager = createTerminalManager
+		this.hostBridge = hostBridge
+		this.logToChannel = logToChannel
+		this.getCallbackUrl = getCallbackUrl
+		this.getBinaryLocation = getBinaryLocation
+		this.extensionFsPath = extensionFsPath
+		this.globalStorageFsPath = globalStorageFsPath
+	}
+
+	public static initialize(
+		webviewProviderCreator: WebviewProviderCreator,
+		diffViewProviderCreator: DiffViewProviderCreator,
+		commentReviewControllerCreator: CommentReviewControllerCreator,
+		terminalManagerCreator: TerminalManagerCreator,
+		hostBridgeProvider: HostBridgeClientProvider,
+		logToChannel: LogToChannel,
+		getCallbackUrl: (path: string, preferredPort?: number) => Promise<string>,
+		getBinaryLocation: (name: string) => Promise<string>,
+		extensionFsPath: string,
+		globalStorageFsPath: string,
+	): HostProvider {
+		if (HostProvider.instance) {
+			throw new Error("Host provider has already been initialized.")
+		}
+		HostProvider.instance = new HostProvider(
+			webviewProviderCreator,
+			diffViewProviderCreator,
+			commentReviewControllerCreator,
+			terminalManagerCreator,
+			hostBridgeProvider,
+			logToChannel,
+			getCallbackUrl,
+			getBinaryLocation,
+			extensionFsPath,
+			globalStorageFsPath,
+		)
+		return HostProvider.instance
+	}
+
+	/**
+	 * Gets the singleton instance
+	 */
+	public static get(): HostProvider {
+		if (!HostProvider.instance) {
+			throw new Error("HostProvider not setup. Call HostProvider.initialize() first.")
+		}
+		return HostProvider.instance
+	}
+
+	public static isInitialized(): boolean {
+		return !!HostProvider.instance
+	}
+
+	/**
+	 * Resets the HostProvider instance (primarily for testing)
+	 * This allows tests to reinitialize the HostProvider with different configurations
+	 */
+	public static reset(): void {
+		HostProvider.instance = null
+	}
+
+	public static get workspace() {
+		return HostProvider.get().hostBridge.workspaceClient
+	}
+
+	public static get env() {
+		return HostProvider.get().hostBridge.envClient
+	}
+
+	public static get window() {
+		return HostProvider.get().hostBridge.windowClient
+	}
+
+	public static get diff() {
+		return HostProvider.get().hostBridge.diffClient
+	}
+}
+
+/**
+ * A function that creates WebviewProvider instances
+ */
+export type WebviewProviderCreator = () => WebviewProvider
+
+/**
+ * A function that creates DiffViewProvider instances
+ */
+export type DiffViewProviderCreator = () => DiffViewProvider
+
+/**
+ * A function that creates CommentReviewController instances
+ */
+export type CommentReviewControllerCreator = () => CommentReviewController
+
+export type LogToChannel = (message: string) => void
+
+/**
+ * A function that creates TerminalManager instances
+ * Returns the platform-appropriate terminal manager (VSCode TerminalManager or StandaloneTerminalManager)
+ */
+export type TerminalManagerCreator = () => ITerminalManager
diff --git a/apps/vscode/src/hosts/vscode/DecorationController.ts b/apps/vscode/src/hosts/vscode/DecorationController.ts
new file mode 100644
index 0000000..6622131
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/DecorationController.ts
@@ -0,0 +1,78 @@
+import * as vscode from "vscode"
+
+const fadedOverlayDecorationType = vscode.window.createTextEditorDecorationType({
+	backgroundColor: "rgba(255, 255, 0, 0.1)",
+	opacity: "0.4",
+	isWholeLine: true,
+})
+
+const activeLineDecorationType = vscode.window.createTextEditorDecorationType({
+	backgroundColor: "rgba(255, 255, 0, 0.3)",
+	opacity: "1",
+	isWholeLine: true,
+	border: "1px solid rgba(255, 255, 0, 0.5)",
+})
+
+type DecorationType = "fadedOverlay" | "activeLine"
+
+export class DecorationController {
+	private decorationType: DecorationType
+	private editor: vscode.TextEditor
+	private ranges: vscode.Range[] = []
+
+	constructor(decorationType: DecorationType, editor: vscode.TextEditor) {
+		this.decorationType = decorationType
+		this.editor = editor
+	}
+
+	getDecoration() {
+		switch (this.decorationType) {
+			case "fadedOverlay":
+				return fadedOverlayDecorationType
+			case "activeLine":
+				return activeLineDecorationType
+		}
+	}
+
+	addLines(startIndex: number, numLines: number) {
+		// Guard against invalid inputs
+		if (startIndex < 0 || numLines <= 0) {
+			return
+		}
+
+		const lastRange = this.ranges[this.ranges.length - 1]
+		if (lastRange && lastRange.end.line === startIndex - 1) {
+			this.ranges[this.ranges.length - 1] = lastRange.with(undefined, lastRange.end.translate(numLines))
+		} else {
+			const endLine = startIndex + numLines - 1
+			this.ranges.push(new vscode.Range(startIndex, 0, endLine, Number.MAX_SAFE_INTEGER))
+		}
+
+		this.editor.setDecorations(this.getDecoration(), this.ranges)
+	}
+
+	clear() {
+		this.ranges = []
+		this.editor.setDecorations(this.getDecoration(), this.ranges)
+	}
+
+	updateOverlayAfterLine(line: number, totalLines: number) {
+		// Remove any existing ranges that start at or after the current line
+		this.ranges = this.ranges.filter((range) => range.end.line < line)
+
+		// Add a new range for all lines after the current line
+		if (line < totalLines - 1) {
+			this.ranges.push(
+				new vscode.Range(new vscode.Position(line + 1, 0), new vscode.Position(totalLines - 1, Number.MAX_SAFE_INTEGER)),
+			)
+		}
+
+		// Apply the updated decorations
+		this.editor.setDecorations(this.getDecoration(), this.ranges)
+	}
+
+	setActiveLine(line: number) {
+		this.ranges = [new vscode.Range(line, 0, line, Number.MAX_SAFE_INTEGER)]
+		this.editor.setDecorations(this.getDecoration(), this.ranges)
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/NotebookDiffView.ts b/apps/vscode/src/hosts/vscode/NotebookDiffView.ts
new file mode 100644
index 0000000..22fa61d
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/NotebookDiffView.ts
@@ -0,0 +1,119 @@
+import * as os from "os"
+import * as path from "path"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Handles Jupyter notebook diff views with cell-level rendering.
+ *
+ * Creates a temporary file with modified content and opens VS Code's native
+ * notebook diff view, which provides meaningful cell-level comparisons instead
+ * of raw JSON diffs.
+ */
+export class NotebookDiffView {
+	private tempModifiedUri?: vscode.Uri
+	private tempFileWatcher?: vscode.FileSystemWatcher
+
+	/**
+	 * Opens a notebook diff view for the given file.
+	 *
+	 * @param absolutePath Path to the notebook file
+	 * @param editor The active text editor containing modified content
+	 */
+	async open(absolutePath: string, editor: vscode.TextEditor): Promise<void> {
+		const uri = vscode.Uri.file(absolutePath)
+		const fileName = path.basename(uri.fsPath)
+
+		// Check if Jupyter extension is available
+		const jupyterExtension = vscode.extensions.getExtension("ms-toolsai.jupyter")
+		if (!jupyterExtension) {
+			vscode.window.showErrorMessage("Jupyter extension is required for notebook diffs.")
+			return
+		}
+
+		if (!jupyterExtension.isActive) {
+			await jupyterExtension.activate()
+		}
+
+		await this.createDiffView(uri, fileName, editor)
+	}
+
+	private async createDiffView(uri: vscode.Uri, fileName: string, editor: vscode.TextEditor): Promise<void> {
+		const tempDir = os.tmpdir()
+		const timestamp = Date.now()
+		const tempModifiedPath = path.join(tempDir, `cline-modified-${timestamp}-${fileName}`)
+
+		const currentContent = editor.document.getText()
+
+		// Validate JSON before creating notebook diff
+		try {
+			JSON.parse(currentContent)
+		} catch {
+			Logger.error(`Invalid JSON content for notebook file ${fileName}, skipping notebook diff view`)
+			return
+		}
+
+		await vscode.workspace.fs.writeFile(vscode.Uri.file(tempModifiedPath), new TextEncoder().encode(currentContent))
+
+		this.tempModifiedUri = vscode.Uri.file(tempModifiedPath)
+		this.setupFileWatcher(editor)
+
+		await vscode.commands.executeCommand(
+			"vscode.diff",
+			uri,
+			this.tempModifiedUri,
+			`${fileName}: Original ↔ Cline's Changes (Notebook)`,
+		)
+
+		// Brief delay to allow VS Code to render the notebook diff view
+		await new Promise((resolve) => setTimeout(resolve, 500))
+	}
+
+	private setupFileWatcher(editor: vscode.TextEditor): void {
+		if (!this.tempModifiedUri) {
+			return
+		}
+
+		const tempDir = path.dirname(this.tempModifiedUri.fsPath)
+		const tempFileName = path.basename(this.tempModifiedUri.fsPath)
+		this.tempFileWatcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(tempDir, tempFileName))
+
+		this.tempFileWatcher.onDidChange(async () => {
+			await this.syncToEditor(editor)
+		})
+	}
+
+	private async syncToEditor(editor: vscode.TextEditor): Promise<void> {
+		if (!this.tempModifiedUri || !editor.document) {
+			return
+		}
+
+		try {
+			const tempContent = await vscode.workspace.fs.readFile(this.tempModifiedUri)
+			const tempContentString = new TextDecoder().decode(tempContent)
+
+			const edit = new vscode.WorkspaceEdit()
+			const fullRange = new vscode.Range(0, 0, editor.document.lineCount, 0)
+			edit.replace(editor.document.uri, fullRange, tempContentString)
+			await vscode.workspace.applyEdit(edit)
+		} catch (error) {
+			Logger.error("Failed to sync temp file to editor:", error)
+		}
+	}
+
+	async cleanup(): Promise<void> {
+		if (this.tempFileWatcher) {
+			this.tempFileWatcher.dispose()
+			this.tempFileWatcher = undefined
+		}
+
+		if (this.tempModifiedUri) {
+			try {
+				await vscode.workspace.fs.delete(this.tempModifiedUri)
+			} catch (error) {
+				Logger.error(`Failed to cleanup temporary file: ${error}`)
+			}
+			this.tempModifiedUri = undefined
+		}
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/VscodeDiffViewProvider.ts b/apps/vscode/src/hosts/vscode/VscodeDiffViewProvider.ts
new file mode 100644
index 0000000..ee5ee3b
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/VscodeDiffViewProvider.ts
@@ -0,0 +1,268 @@
+import { DiffViewProvider } from "@integrations/editor/DiffViewProvider"
+import * as path from "path"
+import * as vscode from "vscode"
+import { DecorationController } from "@/hosts/vscode/DecorationController"
+import { NotebookDiffView } from "@/hosts/vscode/NotebookDiffView"
+import { Logger } from "@/shared/services/Logger"
+import { arePathsEqual } from "@/utils/path"
+
+export const DIFF_VIEW_URI_SCHEME = "cline-diff"
+
+export class VscodeDiffViewProvider extends DiffViewProvider {
+	private activeDiffEditor?: vscode.TextEditor
+
+	private fadedOverlayController?: DecorationController
+	private activeLineController?: DecorationController
+	private notebookDiffView?: NotebookDiffView
+
+	override async openDiffEditor(): Promise<void> {
+		if (!this.absolutePath) {
+			throw new Error("No file path set")
+		}
+
+		// if the file was already open, close it (must happen after showing the diff view since if it's the only tab the column will close)
+		this.documentWasOpen = false
+		// close the tab if it's open (it's already been saved)
+		const tabs = vscode.window.tabGroups.all
+			.flatMap((tg) => tg.tabs)
+			.filter((tab) => tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, this.absolutePath))
+		for (const tab of tabs) {
+			if (!tab.isDirty) {
+				try {
+					await vscode.window.tabGroups.close(tab)
+				} catch (error) {
+					Logger.warn("Tab close retry failed:", error.message)
+				}
+			}
+			this.documentWasOpen = true
+		}
+
+		const uri = vscode.Uri.file(this.absolutePath)
+		// If this diff editor is already open (ie if a previous write file was interrupted) then we should activate that instead of opening a new diff
+		const diffTab = vscode.window.tabGroups.all
+			.flatMap((group) => group.tabs)
+			.find(
+				(tab) =>
+					tab.input instanceof vscode.TabInputTextDiff &&
+					tab.input?.original?.scheme === DIFF_VIEW_URI_SCHEME &&
+					arePathsEqual(tab.input.modified.fsPath, uri.fsPath),
+			)
+
+		if (diffTab && diffTab.input instanceof vscode.TabInputTextDiff) {
+			// Use already open diff editor.
+			this.activeDiffEditor = await vscode.window.showTextDocument(diffTab.input.modified, {
+				preserveFocus: true,
+			})
+		} else {
+			// Open new diff editor.
+			this.activeDiffEditor = await new Promise<vscode.TextEditor>((resolve, reject) => {
+				const fileName = path.basename(uri.fsPath)
+				const fileExists = this.editType === "modify"
+				const disposable = vscode.window.onDidChangeActiveTextEditor((editor) => {
+					if (editor && arePathsEqual(editor.document.uri.fsPath, uri.fsPath)) {
+						disposable.dispose()
+						resolve(editor)
+					}
+				})
+				vscode.commands.executeCommand(
+					"vscode.diff",
+					vscode.Uri.parse(
+						`${DIFF_VIEW_URI_SCHEME}:${fileName.replace(/%/g, "%25").replace(/#/g, "%23").replace(/\?/g, "%3F")}`,
+					).with({
+						query: Buffer.from(this.originalContent ?? "").toString("base64"),
+					}),
+					uri,
+					`${fileName}: ${fileExists ? "Original ↔ Cline's Changes" : "New File"} (Editable)`,
+					{
+						preserveFocus: true,
+					},
+				)
+				// This may happen on very slow machines ie project idx
+				setTimeout(() => {
+					disposable.dispose()
+					reject(new Error("Failed to open diff editor, please try again..."))
+				}, 10_000)
+			})
+		}
+
+		this.fadedOverlayController = new DecorationController("fadedOverlay", this.activeDiffEditor)
+		this.activeLineController = new DecorationController("activeLine", this.activeDiffEditor)
+		// Apply faded overlay to all lines initially
+		this.fadedOverlayController.addLines(0, this.activeDiffEditor.document.lineCount)
+	}
+
+	override async replaceText(
+		content: string,
+		rangeToReplace: { startLine: number; endLine: number },
+		currentLine: number | undefined,
+	): Promise<void> {
+		if (!this.activeDiffEditor || !this.activeDiffEditor.document) {
+			throw new Error("User closed text editor, unable to edit file...")
+		}
+
+		// Place cursor at the beginning of the diff editor to keep it out of the way of the stream animation
+		const beginningOfDocument = new vscode.Position(0, 0)
+		this.activeDiffEditor.selection = new vscode.Selection(beginningOfDocument, beginningOfDocument)
+
+		// Replace the text in the diff editor document.
+		const document = this.activeDiffEditor?.document
+		const replacingToEnd = rangeToReplace.endLine >= document.lineCount
+		const edit = new vscode.WorkspaceEdit()
+		const range = new vscode.Range(rangeToReplace.startLine, 0, rangeToReplace.endLine, 0)
+		edit.replace(document.uri, range, content)
+		await vscode.workspace.applyEdit(edit)
+
+		// VS Code can normalize trailing newlines on full-document replacements.
+		// Only fix up when replacing to the end to avoid touching untouched content.
+		if (replacingToEnd) {
+			const desiredTrailingNewlines = countTrailingNewlines(content)
+			const actualTrailingNewlines = countTrailingNewlines(document.getText())
+			const newlineDelta = desiredTrailingNewlines - actualTrailingNewlines
+
+			if (newlineDelta > 0) {
+				const fixEdit = new vscode.WorkspaceEdit()
+				fixEdit.insert(document.uri, document.lineAt(document.lineCount - 1).range.end, "\n".repeat(newlineDelta))
+				await vscode.workspace.applyEdit(fixEdit)
+			} else if (newlineDelta < 0) {
+				const fixEdit = new vscode.WorkspaceEdit()
+				const startLine = Math.max(0, document.lineCount + newlineDelta)
+				fixEdit.delete(document.uri, new vscode.Range(startLine, 0, document.lineCount, 0))
+				await vscode.workspace.applyEdit(fixEdit)
+			}
+		}
+
+		if (currentLine !== undefined) {
+			// Update decorations for the entire changed section
+			this.activeLineController?.setActiveLine(currentLine)
+			this.fadedOverlayController?.updateOverlayAfterLine(currentLine, document.lineCount)
+		}
+	}
+
+	override async scrollEditorToLine(line: number): Promise<void> {
+		if (!this.activeDiffEditor) {
+			return
+		}
+		const scrollLine = line + 4
+		this.activeDiffEditor.revealRange(new vscode.Range(scrollLine, 0, scrollLine, 0), vscode.TextEditorRevealType.InCenter)
+	}
+
+	override async scrollAnimation(startLine: number, endLine: number): Promise<void> {
+		if (!this.activeDiffEditor) {
+			return
+		}
+		const totalLines = endLine - startLine
+		const numSteps = 10 // Adjust this number to control animation speed
+		const stepSize = Math.max(1, Math.floor(totalLines / numSteps))
+
+		// Create and await the smooth scrolling animation
+		for (let line = startLine; line <= endLine; line += stepSize) {
+			this.activeDiffEditor.revealRange(new vscode.Range(line, 0, line, 0), vscode.TextEditorRevealType.InCenter)
+			await new Promise((resolve) => setTimeout(resolve, 16)) // ~60fps
+		}
+	}
+
+	override async truncateDocument(lineNumber: number): Promise<void> {
+		if (!this.activeDiffEditor) {
+			return
+		}
+		const document = this.activeDiffEditor.document
+		if (lineNumber < document.lineCount) {
+			const edit = new vscode.WorkspaceEdit()
+			edit.delete(document.uri, new vscode.Range(lineNumber, 0, document.lineCount, 0))
+			await vscode.workspace.applyEdit(edit)
+		}
+	}
+
+	protected override async onFinalUpdate(): Promise<void> {
+		// Clear all decorations at the end of streaming
+		this.fadedOverlayController?.clear()
+		this.activeLineController?.clear()
+	}
+
+	protected override async getDocumentLineCount(): Promise<number> {
+		return this.activeDiffEditor?.document.lineCount ?? 0
+	}
+
+	protected override async getDocumentText(): Promise<string | undefined> {
+		if (!this.activeDiffEditor || !this.activeDiffEditor.document) {
+			return undefined
+		}
+		return this.activeDiffEditor.document.getText()
+	}
+
+	protected override async saveDocument(): Promise<Boolean> {
+		if (!this.activeDiffEditor) {
+			return false
+		}
+		if (!this.activeDiffEditor.document.isDirty) {
+			return false
+		}
+		await this.activeDiffEditor.document.save()
+		return true
+	}
+
+	protected async closeAllDiffViews(): Promise<void> {
+		// Close all the cline diff views.
+		const tabs = vscode.window.tabGroups.all
+			.flatMap((tg) => tg.tabs)
+			.filter((tab) => tab.input instanceof vscode.TabInputTextDiff && tab.input?.original?.scheme === DIFF_VIEW_URI_SCHEME)
+		for (const tab of tabs) {
+			// trying to close dirty views results in save popup
+			if (!tab.isDirty) {
+				try {
+					await vscode.window.tabGroups.close(tab)
+				} catch (error) {
+					Logger.warn("Tab close retry failed:", error.message)
+				}
+			}
+		}
+	}
+
+	protected override async resetDiffView(): Promise<void> {
+		if (this.notebookDiffView) {
+			await this.notebookDiffView.cleanup()
+			this.notebookDiffView = undefined
+		}
+
+		this.activeDiffEditor = undefined
+		this.fadedOverlayController = undefined
+		this.activeLineController = undefined
+	}
+
+	protected override async switchToSpecializedEditor(): Promise<void> {
+		if (!this.isNotebookFile() || !this.activeDiffEditor || !this.absolutePath) {
+			return
+		}
+
+		try {
+			this.notebookDiffView = new NotebookDiffView()
+			await this.notebookDiffView.open(this.absolutePath, this.activeDiffEditor)
+		} catch (error) {
+			Logger.error("Failed to create notebook diff view:", error)
+		}
+	}
+
+	override async showFile(absolutePath: string): Promise<void> {
+		const uri = vscode.Uri.file(absolutePath)
+
+		if (this.isNotebookFile()) {
+			// Open with Jupyter notebook editor if available
+			const jupyterExtension = vscode.extensions.getExtension("ms-toolsai.jupyter")
+			if (jupyterExtension) {
+				await vscode.commands.executeCommand("vscode.openWith", uri, "jupyter-notebook")
+				return
+			}
+		}
+
+		// Default: open as text
+		await vscode.window.showTextDocument(uri, { preview: false })
+	}
+}
+
+function countTrailingNewlines(text: string): number {
+	let count = 0
+	for (let i = text.length - 1; i >= 0 && text[i] === "\n"; i -= 1) {
+		count += 1
+	}
+	return count
+}
diff --git a/apps/vscode/src/hosts/vscode/VscodeWebviewProvider.ts b/apps/vscode/src/hosts/vscode/VscodeWebviewProvider.ts
new file mode 100644
index 0000000..d372e8c
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/VscodeWebviewProvider.ts
@@ -0,0 +1,195 @@
+import { sendShowWebviewEvent } from "@core/controller/ui/subscribeToShowWebview"
+import { WebviewProvider } from "@core/webview"
+import * as vscode from "vscode"
+import { handleGrpcRequest, handleGrpcRequestCancel } from "@/core/controller/grpc-handler"
+import { HostProvider } from "@/hosts/host-provider"
+import { ExtensionRegistryInfo } from "@/registry"
+import { telemetryService } from "@/services/telemetry"
+import type { ExtensionMessage } from "@/shared/ExtensionMessage"
+import { Logger } from "@/shared/services/Logger"
+import { WebviewMessage } from "@/shared/WebviewMessage"
+
+/*
+https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
+https://github.com/KumarVariable/vscode-extension-sidebar-html/blob/master/src/customSidebarViewProvider.ts
+*/
+
+export class VscodeWebviewProvider extends WebviewProvider implements vscode.WebviewViewProvider {
+	// Used in package.json as the view's id. This value cannot be changed due to how vscode caches
+	// views based on their id, and updating the id would break existing instances of the extension.
+	public static readonly SIDEBAR_ID = ExtensionRegistryInfo.views.Sidebar
+
+	private webview?: vscode.WebviewView
+	private disposables: vscode.Disposable[] = []
+
+	override getWebviewUrl(path: string) {
+		if (!this.webview) {
+			throw new Error("Webview not initialized")
+		}
+		const uri = this.webview.webview.asWebviewUri(vscode.Uri.file(path))
+		return uri.toString()
+	}
+
+	override getCspSource() {
+		if (!this.webview) {
+			throw new Error("Webview not initialized")
+		}
+		return this.webview.webview.cspSource
+	}
+
+	override isVisible() {
+		return this.webview?.visible || false
+	}
+
+	public getWebview(): vscode.WebviewView | undefined {
+		return this.webview
+	}
+
+	/**
+	 * Initializes and sets up the webview when it's first created.
+	 *
+	 * @param webviewView - The sidebar webview view instance to be resolved
+	 * @returns A promise that resolves when the webview has been fully initialized
+	 */
+	public async resolveWebviewView(webviewView: vscode.WebviewView): Promise<void> {
+		this.webview = webviewView
+
+		webviewView.webview.options = {
+			// Allow scripts in the webview
+			enableScripts: true,
+			localResourceRoots: [vscode.Uri.file(HostProvider.get().extensionFsPath)],
+		}
+
+		webviewView.webview.html =
+			this.context.extensionMode === vscode.ExtensionMode.Development
+				? await this.getHMRHtmlContent()
+				: this.getHtmlContent()
+
+		// Sets up an event listener to listen for messages passed from the webview view context
+		// and executes code based on the message that is received
+		this.setWebviewMessageListener(webviewView.webview)
+		telemetryService.capturePanelOpened("sidebar_resolved")
+
+		// Logs show up in bottom panel > Debug Console
+		//Logger.log("registering listener")
+
+		// Listen for when the sidebar becomes visible
+		// https://github.com/microsoft/vscode-discussions/discussions/840
+
+		// onDidChangeVisibility is only available on the sidebar webview
+		// Otherwise WebviewView and WebviewPanel have all the same properties except for this visibility listener
+		// WebviewPanel is not currently used in the extension
+		webviewView.onDidChangeVisibility(
+			async () => {
+				if (this.webview?.visible) {
+					telemetryService.capturePanelOpened("sidebar_visible")
+					// View becoming visible should not steal editor focus.
+					await sendShowWebviewEvent(true)
+				}
+			},
+			null,
+			this.disposables,
+		)
+
+		// Listen for when the view is disposed
+		// This happens when the user closes the view or when the view is closed programmatically
+		webviewView.onDidDispose(
+			async () => {
+				await this.dispose()
+			},
+			null,
+			this.disposables,
+		)
+
+		// if the extension is starting a new session, clear previous task state
+		this.controller.clearTask()
+
+		Logger.log("[VscodeWebviewProvider] Webview view resolved")
+
+		// Title setting logic removed to allow VSCode to use the container title primarily.
+	}
+
+	/**
+	 * Sets up an event listener to listen for messages passed from the webview context and
+	 * executes code based on the message that is received.
+	 *
+	 * IMPORTANT: When passing methods as callbacks in JavaScript/TypeScript, the method's
+	 * 'this' context can be lost. This happens because the method is passed as a
+	 * standalone function reference, detached from its original object.
+	 *
+	 * The Problem:
+	 * Doing: webview.onDidReceiveMessage(this.controller.handleWebviewMessage)
+	 * Would cause 'this' inside handleWebviewMessage to be undefined or wrong,
+	 * leading to "TypeError: this.setUserInfo is not a function"
+	 *
+	 * The Solution:
+	 * We wrap the method call in an arrow function, which:
+	 * 1. Preserves the lexical scope's 'this' binding
+	 * 2. Ensures handleWebviewMessage is called as a method on the controller instance
+	 * 3. Maintains access to all controller methods and properties
+	 *
+	 * Alternative solutions could use .bind() or making handleWebviewMessage an arrow
+	 * function property, but this approach is clean and explicit.
+	 *
+	 * @param webview The webview instance to attach the message listener to
+	 */
+	private setWebviewMessageListener(webview: vscode.Webview) {
+		webview.onDidReceiveMessage(
+			(message) => {
+				this.handleWebviewMessage(message)
+			},
+			null,
+			this.disposables,
+		)
+	}
+
+	/**
+	 * Sets up an event listener to listen for messages passed from the webview context and
+	 * executes code based on the message that is received.
+	 *
+	 * @param webview A reference to the extension webview
+	 */
+	async handleWebviewMessage(message: WebviewMessage) {
+		const postMessageToWebview = (response: ExtensionMessage) => this.postMessageToWebview(response)
+
+		switch (message.type) {
+			case "grpc_request": {
+				if (message.grpc_request) {
+					await handleGrpcRequest(this.controller, postMessageToWebview, message.grpc_request)
+				}
+				break
+			}
+			case "grpc_request_cancel": {
+				if (message.grpc_request_cancel) {
+					await handleGrpcRequestCancel(postMessageToWebview, message.grpc_request_cancel)
+				}
+				break
+			}
+			default: {
+				Logger.error("Received unhandled WebviewMessage type:", JSON.stringify(message))
+			}
+		}
+	}
+
+	/**
+	 * Sends a message from the extension to the webview.
+	 *
+	 * @param message - The message to send to the webview
+	 * @returns A thenable that resolves to a boolean indicating success, or undefined if the webview is not available
+	 */
+	private async postMessageToWebview(message: ExtensionMessage): Promise<boolean | undefined> {
+		return this.webview?.webview.postMessage(message)
+	}
+
+	override async dispose() {
+		// WebviewView doesn't have a dispose method, it's managed by VSCode
+		// We just need to clean up our disposables
+		while (this.disposables.length) {
+			const x = this.disposables.pop()
+			if (x) {
+				x.dispose()
+			}
+		}
+		super.dispose()
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/__tests__/commit-message-generator.test.ts b/apps/vscode/src/hosts/vscode/__tests__/commit-message-generator.test.ts
new file mode 100644
index 0000000..4b76932
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/__tests__/commit-message-generator.test.ts
@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import "should"
+import sinon from "sinon"
+import * as actualGitUtils from "@/utils/git"
+
+// bun loads real ESM, so sinon cannot stub the `@/utils/git` namespace export
+// ("ES Modules cannot be stubbed"). Inject a module-level sinon stub for
+// `getGitDiff` via mock.module so the full sinon stub API keeps working.
+const getGitDiffStub: sinon.SinonStub = sinon.stub()
+const gitUtilsMock = () => ({ ...actualGitUtils, getGitDiff: getGitDiffStub })
+mock.module("@/utils/git", gitUtilsMock)
+mock.module("@utils/git", gitUtilsMock)
+
+import { getGitDiffStagedFirst } from "../commit-message-generator"
+
+describe("commit-message-generator", () => {
+	describe("getGitDiffStagedFirst", () => {
+		beforeEach(() => {
+			getGitDiffStub.reset()
+		})
+
+		afterEach(() => {
+			sinon.restore()
+			getGitDiffStub.reset()
+		})
+
+		it("should return staged changes when they exist", async () => {
+			const stub = getGitDiffStub
+			stub.withArgs("/repo", true).resolves("staged diff content")
+
+			const result = await getGitDiffStagedFirst("/repo")
+			result.should.equal("staged diff content")
+			stub.calledOnceWith("/repo", true).should.be.true()
+		})
+
+		it("should fall back to all changes when no staged changes exist", async () => {
+			const stub = getGitDiffStub
+			stub.withArgs("/repo", true).rejects(new Error("No changes in workspace for commit message"))
+			stub.withArgs("/repo", false).resolves("all diff content")
+
+			const result = await getGitDiffStagedFirst("/repo")
+			result.should.equal("all diff content")
+			stub.calledTwice.should.be.true()
+			stub.firstCall.args.should.deepEqual(["/repo", true])
+			stub.secondCall.args.should.deepEqual(["/repo", false])
+		})
+
+		it("should propagate error when both staged and all changes fail", async () => {
+			const stub = getGitDiffStub
+			stub.withArgs("/repo", true).rejects(new Error("No changes"))
+			stub.withArgs("/repo", false).rejects(new Error("No changes in workspace for commit message"))
+
+			let error: Error | undefined
+			try {
+				await getGitDiffStagedFirst("/repo")
+			} catch (e) {
+				error = e as Error
+			}
+			;(error !== undefined).should.be.true()
+			error!.message.should.equal("No changes in workspace for commit message")
+		})
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/__tests__/vscode-to-file-migration.test.ts b/apps/vscode/src/hosts/vscode/__tests__/vscode-to-file-migration.test.ts
new file mode 100644
index 0000000..1935a1c
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/__tests__/vscode-to-file-migration.test.ts
@@ -0,0 +1,732 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import { ClineFileStorage } from "@shared/storage/ClineFileStorage"
+import { createStorageContext, type StorageContext } from "@shared/storage/storage-context"
+import fs from "fs"
+import os from "os"
+import path from "path"
+import sinon from "sinon"
+import { getServerAuthHash } from "@/utils/mcpAuth"
+import { exportVSCodeStorageToSharedFiles } from "../vscode-to-file-migration"
+
+/**
+ * Create a minimal mock of VSCode's ExtensionContext for migration testing.
+ * Provides in-memory implementations of globalState, secrets, and workspaceState.
+ */
+function createMockVSCodeContext() {
+	const globalStateStore = new Map<string, any>()
+	const secretsStore = new Map<string, string>()
+	const workspaceStateStore = new Map<string, any>()
+
+	return {
+		globalState: {
+			get<T>(key: string): T | undefined {
+				return globalStateStore.get(key) as T | undefined
+			},
+			async update(key: string, value: any): Promise<void> {
+				if (value === undefined) {
+					globalStateStore.delete(key)
+				} else {
+					globalStateStore.set(key, value)
+				}
+			},
+			keys(): readonly string[] {
+				return Array.from(globalStateStore.keys())
+			},
+			setKeysForSync() {},
+		},
+		secrets: {
+			async get(key: string): Promise<string | undefined> {
+				return secretsStore.get(key)
+			},
+			async store(key: string, value: string): Promise<void> {
+				secretsStore.set(key, value)
+			},
+			async delete(key: string): Promise<void> {
+				secretsStore.delete(key)
+			},
+			onDidChange: () => ({ dispose: () => {} }),
+		},
+		workspaceState: {
+			get<T>(key: string): T | undefined {
+				return workspaceStateStore.get(key) as T | undefined
+			},
+			async update(key: string, value: any): Promise<void> {
+				if (value === undefined) {
+					workspaceStateStore.delete(key)
+				} else {
+					workspaceStateStore.set(key, value)
+				}
+			},
+			keys(): readonly string[] {
+				return Array.from(workspaceStateStore.keys())
+			},
+			setKeysForSync() {},
+		},
+		globalStorageUri: {
+			fsPath: "",
+		},
+		// Expose internal stores for test setup
+		_globalStateStore: globalStateStore,
+		_secretsStore: secretsStore,
+		_workspaceStateStore: workspaceStateStore,
+	}
+}
+
+describe("vscode-to-file-migration", () => {
+	let sandbox: sinon.SinonSandbox
+	let tempDir: string
+	let storageContext: StorageContext
+	let originalMcpSettingsPath: string | undefined
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH
+		tempDir = path.join(os.tmpdir(), `migration-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		fs.mkdirSync(tempDir, { recursive: true })
+		process.env.CLINE_MCP_SETTINGS_PATH = path.join(tempDir, "runtime-mcp-settings", "cline_mcp_settings.json")
+
+		storageContext = createStorageContext({
+			clineDir: tempDir,
+			workspacePath: tempDir,
+		})
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+		if (originalMcpSettingsPath === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath
+		}
+		try {
+			fs.rmSync(tempDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	describe("sentinel behavior", () => {
+		it("should migrate on first run (no sentinel)", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "act")
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.globalStateCount.should.be.greaterThan(0)
+			storageContext.globalState.get("mode")!.should.equal("act")
+			// Both sentinels should be written
+			storageContext.globalState.get("__vscodeMigrationVersion")!.should.equal(2)
+			storageContext.workspaceState.get("__vscodeMigrationVersion")!.should.equal(2)
+		})
+
+		it("should run only MCP settings migration when v1 storage export sentinels are already present", async () => {
+			storageContext.globalState.update("__vscodeMigrationVersion", 1)
+			storageContext.workspaceState.set("__vscodeMigrationVersion", 1)
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan")
+			mockCtx._workspaceStateStore.set("localClineRulesToggles", { "rule-1": true })
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({ mcpServers: { fromV1: { command: "node" } } }),
+			)
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.globalStateCount.should.equal(0)
+			result.secretsCount.should.equal(0)
+			result.workspaceStateCount.should.equal(0)
+			result.mcpServersAdded.should.equal(1)
+			;(storageContext.globalState.get("mode") === undefined).should.be.true()
+			;(storageContext.workspaceState.get("localClineRulesToggles") === undefined).should.be.true()
+			storageContext.globalState.get("__vscodeMigrationVersion")!.should.equal(2)
+			storageContext.workspaceState.get("__vscodeMigrationVersion")!.should.equal(2)
+		})
+
+		it("should skip everything when both sentinels are current version", async () => {
+			// Pre-set BOTH sentinels
+			storageContext.globalState.update("__vscodeMigrationVersion", 2)
+			storageContext.workspaceState.set("__vscodeMigrationVersion", 2)
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan")
+			mockCtx._workspaceStateStore.set("localClineRulesToggles", { "rule-1": true })
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.false()
+			result.globalStateCount.should.equal(0)
+			result.workspaceStateCount.should.equal(0)
+			result.mcpServersAdded.should.equal(0)
+			// Should NOT have the VSCode values — migration was skipped
+			const modeVal = storageContext.globalState.get("mode")
+			;(modeVal === undefined).should.be.true()
+		})
+
+		it("should skip everything when both sentinels are higher version", async () => {
+			storageContext.globalState.update("__vscodeMigrationVersion", 999)
+			storageContext.workspaceState.set("__vscodeMigrationVersion", 999)
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "act")
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.false()
+			result.globalStateCount.should.equal(0)
+			result.workspaceStateCount.should.equal(0)
+			result.mcpServersAdded.should.equal(0)
+		})
+
+		it("should re-run migration if sentinels are lower version", async () => {
+			storageContext.globalState.update("__vscodeMigrationVersion", 0)
+			storageContext.workspaceState.set("__vscodeMigrationVersion", 0)
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan")
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+		})
+
+		it("should migrate workspace state when globals already migrated (new workspace)", async () => {
+			// Simulate: globals+secrets already migrated, but this is a fresh workspace
+			storageContext.globalState.update("__vscodeMigrationVersion", 1)
+			// workspaceState has NO sentinel — this is a new workspace
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan") // should be skipped
+			mockCtx._secretsStore.set("apiKey", "sk-test") // should be skipped
+			mockCtx._workspaceStateStore.set("localClineRulesToggles", { "rule-1": true })
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			// Global state and secrets should NOT have been migrated
+			result.globalStateCount.should.equal(0)
+			result.secretsCount.should.equal(0)
+			// Workspace state SHOULD have been migrated
+			result.workspaceStateCount.should.equal(1)
+			const stored = storageContext.workspaceState.get("localClineRulesToggles") as any
+			stored.should.deepEqual({ "rule-1": true })
+			// Workspace sentinel should now be set
+			storageContext.workspaceState.get("__vscodeMigrationVersion")!.should.equal(2)
+		})
+
+		it("should migrate globals when workspace already migrated", async () => {
+			// Edge case: workspace was somehow migrated but globals were not
+			storageContext.workspaceState.set("__vscodeMigrationVersion", 1)
+			// globalState has NO sentinel
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan")
+			mockCtx._workspaceStateStore.set("localClineRulesToggles", { "rule-1": true }) // should be skipped
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			// Global state SHOULD have been migrated
+			result.globalStateCount.should.be.greaterThan(0)
+			storageContext.globalState.get("mode")!.should.equal("plan")
+			// Workspace state should NOT have been migrated
+			result.workspaceStateCount.should.equal(0)
+			// Global sentinel should now be set
+			storageContext.globalState.get("__vscodeMigrationVersion")!.should.equal(2)
+		})
+	})
+
+	describe("global state migration", () => {
+		it("should migrate global state keys", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan")
+			mockCtx._globalStateStore.set("yoloModeToggled", true)
+			mockCtx._globalStateStore.set("enableCheckpointsSetting", false)
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			storageContext.globalState.get("mode")!.should.equal("plan")
+			storageContext.globalState.get("yoloModeToggled")!.should.equal(true)
+			storageContext.globalState.get("enableCheckpointsSetting")!.should.equal(false)
+		})
+
+		it("should NOT overwrite existing file store values", async () => {
+			// Pre-populate the file store with a value
+			storageContext.globalState.update("mode", "act")
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan") // VSCode has different value
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.skippedExisting.should.be.greaterThan(0)
+			// File store value should be preserved, NOT overwritten
+			storageContext.globalState.get("mode")!.should.equal("act")
+		})
+
+		it("should skip undefined values", async () => {
+			const mockCtx = createMockVSCodeContext()
+			// Don't set anything — all keys will be undefined
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.globalStateCount.should.equal(0)
+		})
+
+		it("should skip taskHistory (it has its own file)", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("taskHistory", [{ id: "old", ts: 123 }])
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			// taskHistory should NOT be in the file store
+			const val = storageContext.globalState.get("taskHistory")
+			;(val === undefined).should.be.true()
+		})
+	})
+
+	describe("legacy MCP settings migration", () => {
+		function sharedMcpSettingsPath() {
+			return process.env.CLINE_MCP_SETTINGS_PATH!
+		}
+
+		function readSharedMcpSettings() {
+			return JSON.parse(fs.readFileSync(sharedMcpSettingsPath(), "utf8"))
+		}
+
+		it("writes to the runtime MCP settings resolver path rather than storage.dataDir", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({ mcpServers: { overrideTarget: { command: "node" } } }),
+			)
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.mcpServersAdded.should.equal(1)
+			fs.existsSync(sharedMcpSettingsPath()).should.be.true()
+			fs.existsSync(path.join(storageContext.dataDir, "settings", "cline_mcp_settings.json")).should.be.false()
+			readSharedMcpSettings().mcpServers.overrideTarget.should.deepEqual({
+				transport: { type: "stdio", command: "node" },
+			})
+		})
+
+		it("skips a legacy source that resolves to the shared MCP settings file", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const sharedSettingsDir = path.dirname(sharedMcpSettingsPath())
+			fs.mkdirSync(sharedSettingsDir, { recursive: true })
+			mockCtx.globalStorageUri.fsPath = path.dirname(sharedSettingsDir)
+			fs.writeFileSync(sharedMcpSettingsPath(), JSON.stringify({ mcpServers: { alreadyShared: { command: "node" } } }))
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.mcpServersAdded.should.equal(0)
+			const tombstone = storageContext.globalState.get("__vscodeLegacyMcpSettingsMigration") as any
+			;(tombstone?.sources?.vscodeGlobalStorage === undefined).should.be.true()
+			const settings = readSharedMcpSettings()
+			settings.mcpServers.alreadyShared.should.deepEqual({ command: "node" })
+		})
+
+		it("uses the MCP settings lock when writing migrated servers", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({ mcpServers: { lockedServer: { command: "node" } } }),
+			)
+
+			const sharedSettingsPath = sharedMcpSettingsPath()
+			const lockDir = `${sharedSettingsPath}.lock`
+			fs.mkdirSync(lockDir, { recursive: true })
+			fs.writeFileSync(path.join(lockDir, "owner.test"), "test")
+			const freshMtime = new Date()
+			fs.utimesSync(lockDir, freshMtime, freshMtime)
+
+			const migration = exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+			await new Promise((resolve) => setTimeout(resolve, 75))
+			;(fs.existsSync(sharedSettingsPath) === false).should.be.true()
+			fs.rmSync(lockDir, { recursive: true, force: true })
+
+			const result = await migration
+			result.mcpServersAdded.should.equal(1)
+			const settings = readSharedMcpSettings()
+			settings.mcpServers.lockedServer.should.deepEqual({ transport: { type: "stdio", command: "node" } })
+		})
+
+		it("merges missing legacy MCP servers from VSCode globalStorage without overwriting shared settings", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({
+					mcpServers: {
+						existing: { command: "legacy-existing", args: ["old"] },
+						stdioLegacy: { command: "node", args: ["server.js"], env: { API_KEY: "abc" } },
+					},
+				}),
+			)
+
+			const sharedSettingsDir = path.dirname(sharedMcpSettingsPath())
+			fs.mkdirSync(sharedSettingsDir, { recursive: true })
+			fs.writeFileSync(
+				sharedMcpSettingsPath(),
+				JSON.stringify({
+					mcpServers: {
+						existing: {
+							transport: { type: "stdio", command: "shared-existing" },
+							disabled: true,
+						},
+					},
+				}),
+			)
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.mcpServersAdded.should.equal(1)
+			result.mcpServersSkippedExisting.should.equal(1)
+			const settings = readSharedMcpSettings()
+			settings.mcpServers.existing.should.deepEqual({
+				transport: { type: "stdio", command: "shared-existing" },
+				disabled: true,
+			})
+			settings.mcpServers.stdioLegacy.should.deepEqual({
+				transport: { type: "stdio", command: "node", args: ["server.js"], env: { API_KEY: "abc" } },
+			})
+		})
+
+		it("preserves top-level URL for migrated remote-configured URL servers", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({
+					mcpServers: {
+						managed: {
+							url: "https://managed.example.com/mcp",
+							type: "streamableHttp",
+							remoteConfigured: true,
+							disabled: true,
+							autoApprove: ["tool-a"],
+						},
+					},
+				}),
+			)
+
+			await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			readSharedMcpSettings().mcpServers.managed.should.deepEqual({
+				transport: { type: "streamableHttp", url: "https://managed.example.com/mcp" },
+				disabled: true,
+				autoApprove: ["tool-a"],
+				remoteConfigured: true,
+				url: "https://managed.example.com/mcp",
+			})
+		})
+
+		it("upgrades legacy transportType and OAuth secret format into SDK MCP settings format", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+			const serverUrl = "https://linear.example.com/mcp"
+			const serverHash = getServerAuthHash("linear", serverUrl)
+
+			mockCtx._secretsStore.set(
+				"mcpOAuthSecrets",
+				JSON.stringify({
+					[serverHash]: {
+						tokens: { access_token: "old-token", refresh_token: "refresh" },
+						tokens_saved_at: 123456,
+						client_info: { client_id: "client-id" },
+						code_verifier: "verifier",
+						redirect_url_at_registration: "http://127.0.0.1:1456/mcp/oauth/callback",
+					},
+				}),
+			)
+
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({
+					mcpServers: {
+						linear: {
+							transportType: "http",
+							url: serverUrl,
+							headers: { Authorization: "Bearer static" },
+							disabled: false,
+							timeout: 30,
+						},
+					},
+				}),
+			)
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.mcpServersAdded.should.equal(1)
+			const settings = readSharedMcpSettings()
+			settings.mcpServers.linear.should.deepEqual({
+				transport: {
+					type: "streamableHttp",
+					url: serverUrl,
+					headers: { Authorization: "Bearer static" },
+				},
+				disabled: false,
+				timeout: 30,
+				oauth: {
+					clientInformation: { client_id: "client-id" },
+					tokens: { access_token: "old-token", refresh_token: "refresh" },
+					codeVerifier: "verifier",
+					redirectUrl: "http://127.0.0.1:1456/mcp/oauth/callback",
+					lastAuthenticatedAt: 123456,
+				},
+			})
+		})
+
+		it("writes source tombstones and does not re-import a deleted migrated server", async () => {
+			const mockCtx = createMockVSCodeContext()
+			const extensionStorage = path.join(tempDir, "vscode-global-storage")
+			mockCtx.globalStorageUri.fsPath = extensionStorage
+			fs.mkdirSync(path.join(extensionStorage, "settings"), { recursive: true })
+			fs.writeFileSync(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+				JSON.stringify({ mcpServers: { oneShot: { command: "node" } } }),
+			)
+
+			await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+			const settingsPath = sharedMcpSettingsPath()
+			fs.writeFileSync(settingsPath, JSON.stringify({ mcpServers: {} }))
+
+			const second = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			second.mcpServersAdded.should.equal(0)
+			const settings = readSharedMcpSettings()
+			;(settings.mcpServers.oneShot === undefined).should.be.true()
+			const tombstone = storageContext.globalState.get("__vscodeLegacyMcpSettingsMigration") as any
+			tombstone.sources.vscodeGlobalStorage.path.should.equal(
+				path.join(extensionStorage, "settings", "cline_mcp_settings.json"),
+			)
+		})
+	})
+
+	describe("secrets migration", () => {
+		it("should migrate secret keys", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._secretsStore.set("apiKey", "sk-test-123")
+			mockCtx._secretsStore.set("openRouterApiKey", "or-test-456")
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.secretsCount.should.equal(2)
+			storageContext.secrets.get("apiKey")!.should.equal("sk-test-123")
+			storageContext.secrets.get("openRouterApiKey")!.should.equal("or-test-456")
+		})
+
+		it("should NOT overwrite existing secrets in file store", async () => {
+			storageContext.secrets.set("apiKey", "existing-key")
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._secretsStore.set("apiKey", "vscode-key")
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.skippedExisting.should.be.greaterThan(0)
+			storageContext.secrets.get("apiKey")!.should.equal("existing-key")
+		})
+
+		it("should skip empty string secrets", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._secretsStore.set("apiKey", "")
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.secretsCount.should.equal(0)
+		})
+
+		it("should continue even if a single secret read fails", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._secretsStore.set("openRouterApiKey", "or-key-123")
+
+			// Make one secret read fail
+			const origGet = mockCtx.secrets.get.bind(mockCtx.secrets)
+			mockCtx.secrets.get = async (key: string) => {
+				if (key === "apiKey") {
+					throw new Error("Simulated secret read error")
+				}
+				return origGet(key)
+			}
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.secretsCount.should.equal(1)
+			storageContext.secrets.get("openRouterApiKey")!.should.equal("or-key-123")
+		})
+	})
+
+	describe("workspace state migration", () => {
+		it("should migrate workspace state keys", async () => {
+			const toggles = { "rule-1": true, "rule-2": false }
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._workspaceStateStore.set("localClineRulesToggles", toggles)
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			result.workspaceStateCount.should.equal(1)
+			const stored = storageContext.workspaceState.get("localClineRulesToggles") as any
+			stored.should.deepEqual(toggles)
+		})
+
+		it("should NOT overwrite existing workspace state", async () => {
+			const existingToggles = { "rule-existing": true }
+			storageContext.workspaceState.set("localClineRulesToggles", existingToggles)
+
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._workspaceStateStore.set("localClineRulesToggles", { "rule-vscode": true })
+
+			const result = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+
+			result.migrated.should.be.true()
+			const stored = storageContext.workspaceState.get("localClineRulesToggles") as any
+			stored.should.deepEqual(existingToggles)
+		})
+	})
+
+	describe("error handling", () => {
+		it("should NOT write sentinel if migration throws", async () => {
+			const mockCtx = createMockVSCodeContext()
+
+			// Stub setBatch to throw an error
+			sandbox.stub(storageContext.globalState, "setBatch").callsFake(() => {
+				throw new Error("Simulated disk write error")
+			})
+
+			mockCtx._globalStateStore.set("mode", "act")
+			mockCtx._globalStateStore.set("yoloModeToggled", true)
+			mockCtx._globalStateStore.set("enableCheckpointsSetting", true)
+
+			try {
+				await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+				throw new Error("Should have thrown")
+			} catch (error: any) {
+				error.message.should.equal("Simulated disk write error")
+			}
+
+			// Sentinel should NOT be written
+			const sentinel = storageContext.globalState.get("__vscodeMigrationVersion")
+			;(sentinel === undefined).should.be.true()
+		})
+	})
+
+	describe("idempotency", () => {
+		it("should produce same result when run twice", async () => {
+			const mockCtx = createMockVSCodeContext()
+			mockCtx._globalStateStore.set("mode", "plan")
+			mockCtx._secretsStore.set("apiKey", "sk-test")
+
+			// First run
+			const result1 = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+			result1.migrated.should.be.true()
+
+			// Second run — should be skipped due to sentinel
+			const result2 = await exportVSCodeStorageToSharedFiles(mockCtx as any, storageContext)
+			result2.migrated.should.be.false()
+			result2.globalStateCount.should.equal(0)
+
+			// Values should still be correct
+			storageContext.globalState.get("mode")!.should.equal("plan")
+			storageContext.secrets.get("apiKey")!.should.equal("sk-test")
+		})
+	})
+})
+
+describe("createStorageContext", () => {
+	let tempDir: string
+
+	beforeEach(() => {
+		tempDir = path.join(os.tmpdir(), `storage-ctx-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+	})
+
+	afterEach(() => {
+		try {
+			fs.rmSync(tempDir, { recursive: true, force: true })
+		} catch {
+			// Ignore
+		}
+	})
+
+	it("should create all three stores", () => {
+		const ctx = createStorageContext({ clineDir: tempDir, workspacePath: "/fake/workspace" })
+
+		ctx.globalState.should.be.instanceOf(ClineFileStorage)
+		ctx.secrets.should.be.instanceOf(ClineFileStorage)
+		ctx.workspaceState.should.be.instanceOf(ClineFileStorage)
+	})
+
+	it("should create directories", () => {
+		const ctx = createStorageContext({ clineDir: tempDir, workspacePath: "/fake/workspace" })
+
+		fs.existsSync(ctx.dataDir).should.be.true()
+		fs.existsSync(ctx.workspaceStoragePath).should.be.true()
+	})
+
+	it("should produce deterministic workspace hashes", () => {
+		const ctx1 = createStorageContext({ clineDir: tempDir, workspacePath: "/some/project" })
+		const ctx2 = createStorageContext({ clineDir: tempDir, workspacePath: "/some/project" })
+
+		ctx1.workspaceStoragePath.should.equal(ctx2.workspaceStoragePath)
+	})
+
+	it("should produce different hashes for different workspaces", () => {
+		const ctx1 = createStorageContext({ clineDir: tempDir, workspacePath: "/project-a" })
+		const ctx2 = createStorageContext({ clineDir: tempDir, workspacePath: "/project-b" })
+
+		ctx1.workspaceStoragePath.should.not.equal(ctx2.workspaceStoragePath)
+	})
+
+	it("should use explicit workspaceStorageDir when provided", () => {
+		const explicitDir = path.join(tempDir, "explicit-ws")
+		const ctx = createStorageContext({
+			clineDir: tempDir,
+			workspacePath: "/ignored",
+			workspaceStorageDir: explicitDir,
+		})
+
+		ctx.workspaceStoragePath.should.equal(explicitDir)
+	})
+
+	it("should store and retrieve values correctly", () => {
+		const ctx = createStorageContext({ clineDir: tempDir, workspacePath: "/test" })
+
+		ctx.globalState.update("testKey", "testValue")
+		ctx.globalState.get("testKey")!.should.equal("testValue")
+
+		ctx.secrets.set("secretKey", "secretValue")
+		ctx.secrets.get("secretKey")!.should.equal("secretValue")
+
+		ctx.workspaceState.set("wsKey", { toggle: true })
+		const ws = ctx.workspaceState.get("wsKey") as any
+		ws.toggle.should.equal(true)
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/commandUtils.ts b/apps/vscode/src/hosts/vscode/commandUtils.ts
new file mode 100644
index 0000000..c1dc2c3
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/commandUtils.ts
@@ -0,0 +1,107 @@
+import * as fs from "fs/promises"
+import * as vscode from "vscode"
+import { sanitizeCellForLLM } from "@/integrations/misc/notebook-utils"
+import { ExtensionRegistryInfo } from "@/registry"
+import { CommandContext } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { Controller } from "../../core/controller"
+import { WebviewProvider } from "../../core/webview"
+import { convertVscodeDiagnostics } from "./hostbridge/workspace/getDiagnostics"
+
+/**
+ * Finds the notebook cell that contains the selected text and returns its JSON representation
+ * @param filePath Path to the .ipynb file
+ * @param notebookCell The cell index from the active notebook editor
+ * @returns JSON string of the matching cell, or null if no match found
+ */
+export async function findMatchingNotebookCell(filePath: string, notebookCell?: number): Promise<string | null> {
+	try {
+		// Read the notebook file directly
+		const notebookContent = await fs.readFile(filePath, "utf8")
+		const notebook = JSON.parse(notebookContent)
+
+		if (!notebook.cells || !Array.isArray(notebook.cells)) {
+			Logger.log("Invalid notebook structure: no cells array found")
+			return null
+		}
+
+		Logger.log(`Loaded notebook with ${notebook.cells.length} cells`)
+
+		if (typeof notebookCell === "number" && notebookCell >= 0 && notebookCell < notebook.cells.length) {
+			Logger.log(`Using provided notebook cell number ${notebookCell}`)
+			// Get a reference to the specific cell object
+			const cellToProcess = notebook.cells[notebookCell]
+
+			// Sanitize the cell outputs (truncate images, keep text outputs)
+			return sanitizeCellForLLM(cellToProcess)
+		}
+
+		Logger.log("No valid notebook cell number provided")
+		return null
+	} catch (error) {
+		Logger.error("Error in findMatchingNotebookCell:", error)
+		return null
+	}
+}
+
+/**
+ * Gets the context needed for VSCode commands that interact with the editor
+ * @param range Optional range to use instead of current selection
+ * @param vscodeDiagnostics Optional diagnostics to include
+ * @returns Context object with controller, selected text, file info, and problems
+ */
+export async function getContextForCommand(
+	range?: vscode.Range,
+	vscodeDiagnostics?: vscode.Diagnostic[],
+	options?: {
+		/**
+		 * When true, the editor keeps focus when showing the sidebar webview.
+		 * Use this for non-interruptive flows (e.g. copy terminal output to Cline).
+		 */
+		preserveEditorFocus?: boolean
+	},
+): Promise<
+	| undefined
+	| {
+			controller: Controller
+			commandContext: CommandContext
+	  }
+> {
+	const activeWebview = await showWebview(options?.preserveEditorFocus ?? false)
+	// Use the controller from the active instance
+	const controller = activeWebview.controller
+
+	const editor = vscode.window.activeTextEditor
+	if (!editor) {
+		// Fallback for notebooks with no cells (no text editor active)
+		const activeNotebook = vscode.window.activeNotebookEditor
+		if (!activeNotebook) {
+			return
+		}
+		const filePath = activeNotebook.notebook.uri.fsPath
+		const diagnostics = convertVscodeDiagnostics(vscodeDiagnostics || [])
+		return { controller, commandContext: { selectedText: "", filePath, diagnostics, language: "" } }
+	}
+	// Use provided range if available, otherwise use current selection
+	// (vscode command passes an argument in the first param by default, so we need to ensure it's a Range object)
+	const textRange = range instanceof vscode.Range ? range : editor.selection
+	const selectedText = editor.document.getText(textRange)
+
+	const filePath = editor.document.uri.fsPath
+	const language = editor.document.languageId
+	const diagnostics = convertVscodeDiagnostics(vscodeDiagnostics || [])
+	const commandContext: CommandContext = {
+		selectedText,
+		filePath,
+		diagnostics,
+		language,
+	}
+
+	return { controller, commandContext }
+}
+
+export async function showWebview(preserveEditorFocus: boolean = true): Promise<WebviewProvider> {
+	await vscode.commands.executeCommand(ExtensionRegistryInfo.commands.FocusChatInput, preserveEditorFocus)
+
+	return WebviewProvider.getInstance()
+}
diff --git a/apps/vscode/src/hosts/vscode/commit-message-generator.ts b/apps/vscode/src/hosts/vscode/commit-message-generator.ts
new file mode 100644
index 0000000..b499da1
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/commit-message-generator.ts
@@ -0,0 +1,278 @@
+import * as path from "path"
+import * as vscode from "vscode"
+import { Controller } from "@/core/controller"
+import { HostProvider } from "@/hosts/host-provider"
+import { buildApiHandler } from "@/sdk/sdk-api-handler"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { getGitDiff } from "@/utils/git"
+
+/**
+ * Git commit message generator module
+ */
+
+/**
+ * Gets git diff prioritizing staged changes. If staged changes exist, returns only those.
+ * Falls back to all changes when nothing is staged.
+ */
+export async function getGitDiffStagedFirst(cwd: string): Promise<string> {
+	try {
+		return await getGitDiff(cwd, true)
+	} catch {
+		return await getGitDiff(cwd, false)
+	}
+}
+
+let commitGenerationAbortController: AbortController | undefined
+
+type GitRepositoryInputBox = {
+	value: string
+}
+
+type GitRepository = {
+	rootUri: vscode.Uri
+	inputBox: GitRepositoryInputBox
+}
+
+type GitApi = {
+	repositories: GitRepository[]
+	getRepository(uri: vscode.Uri): GitRepository | null | undefined
+}
+
+type GitExtensionExports = {
+	getAPI(version: 1): GitApi
+}
+
+type RepoSelectionItem = {
+	label: string
+	description: string
+	repo: GitRepository | null
+}
+
+const PROMPT = {
+	system: "You are a helpful assistant that generates informative git commit messages based on git diffs output. Skip preamble and remove all backticks surrounding the commit message.",
+	user: "Notes from developer (ignore if not relevant): {{USER_CURRENT_INPUT}}",
+	instruction: `Based on the provided git diff, generate a concise and descriptive commit message.
+
+The commit message should:
+1. Has a short title (50-72 characters)
+2. The commit message should adhere to the conventional commit format
+3. Describe what was changed and why
+4. Be clear and informative`,
+}
+
+export async function generateCommitMsg(controller: Controller, scm?: vscode.SourceControl) {
+	try {
+		const gitExtension = vscode.extensions.getExtension<GitExtensionExports>("vscode.git")?.exports
+		if (!gitExtension) {
+			throw new Error("Git extension not found")
+		}
+
+		const git = gitExtension.getAPI(1)
+		if (git.repositories.length === 0) {
+			throw new Error("No Git repositories available")
+		}
+
+		// If scm is provided, then the user specified one repository by clicking the "Source Control" menu button
+		if (scm?.rootUri) {
+			const repository = git.getRepository(scm.rootUri)
+
+			if (!repository) {
+				throw new Error("Repository not found for provided SCM")
+			}
+
+			await generateCommitMsgForRepository(controller, repository)
+			return
+		}
+
+		await orchestrateWorkspaceCommitMsgGeneration(controller, git.repositories)
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `[Commit Generation Failed] ${errorMessage}`,
+		})
+	}
+}
+
+async function orchestrateWorkspaceCommitMsgGeneration(controller: Controller, repos: GitRepository[]) {
+	const reposWithChanges = await filterForReposWithChanges(repos)
+
+	if (reposWithChanges.length === 0) {
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message: "No changes found in any workspace repositories",
+		})
+		return
+	}
+
+	if (reposWithChanges.length === 1) {
+		// Only one repo with changes, generate for it
+		const repo = reposWithChanges[0]
+		await generateCommitMsgForRepository(controller, repo)
+		return
+	}
+
+	const selection = await promptRepoSelection(reposWithChanges)
+
+	if (!selection) {
+		// User cancelled
+		return
+	}
+
+	if (selection.repo === null) {
+		// Generate for all repositories with changes
+		for (const repo of reposWithChanges) {
+			try {
+				await generateCommitMsgForRepository(controller, repo)
+			} catch (error) {
+				Logger.error(`Failed to generate commit message for ${repo.rootUri.fsPath}:`, error)
+			}
+		}
+	} else {
+		// Generate for selected repository
+		await generateCommitMsgForRepository(controller, selection.repo)
+	}
+}
+
+async function filterForReposWithChanges(repos: GitRepository[]): Promise<GitRepository[]> {
+	const reposWithChanges: GitRepository[] = []
+
+	// Check which repositories have changes (prefer staged, fall back to all)
+	for (const repo of repos) {
+		try {
+			const gitDiff = await getGitDiffStagedFirst(repo.rootUri.fsPath)
+			if (gitDiff) {
+				reposWithChanges.push(repo)
+			}
+		} catch {
+			// Skip repositories with errors (no changes, etc.)
+		}
+	}
+	return reposWithChanges
+}
+
+async function promptRepoSelection(repos: GitRepository[]): Promise<RepoSelectionItem | undefined> {
+	// Multiple repos with changes - ask user to choose
+	const repoItems: RepoSelectionItem[] = repos.map((repo) => ({
+		label: repo.rootUri.fsPath.split(path.sep).pop() || repo.rootUri.fsPath,
+		description: repo.rootUri.fsPath,
+		repo,
+	}))
+
+	repoItems.unshift({
+		label: "$(git-commit) Generate for all repositories with changes",
+		description: `Generate commit messages for ${repos.length} repositories`,
+		repo: null,
+	})
+
+	return await vscode.window.showQuickPick(repoItems, {
+		placeHolder: "Select repository for commit message generation",
+	})
+}
+
+async function generateCommitMsgForRepository(controller: Controller, repository: GitRepository) {
+	const inputBox = repository.inputBox
+	const repoPath = repository.rootUri.fsPath
+	const gitDiff = await getGitDiffStagedFirst(repoPath)
+
+	if (!gitDiff) {
+		throw new Error(`No changes in repository ${repoPath.split(path.sep).pop() || "repository"} for commit message`)
+	}
+
+	await vscode.window.withProgress(
+		{
+			location: vscode.ProgressLocation.SourceControl,
+			title: `Generating commit message for ${repoPath.split(path.sep).pop() || "repository"}...`,
+			cancellable: true,
+		},
+		() => performCommitMsgGeneration(controller, gitDiff, inputBox),
+	)
+}
+
+async function performCommitMsgGeneration(controller: Controller, gitDiff: string, inputBox: GitRepositoryInputBox) {
+	try {
+		vscode.commands.executeCommand("setContext", "cline.isGeneratingCommit", true)
+
+		const prompts = [PROMPT.instruction]
+
+		const currentInput = inputBox.value?.trim() || ""
+		if (currentInput) {
+			prompts.push(PROMPT.user.replace("{{USER_CURRENT_INPUT}}", currentInput))
+		}
+
+		const truncatedDiff = gitDiff.length > 5000 ? `${gitDiff.substring(0, 5000)}\n\n[Diff truncated due to size]` : gitDiff
+		prompts.push(truncatedDiff)
+
+		const prompt = prompts.join("\n\n")
+
+		// Get the current API configuration
+		// Set to use Act mode for now by default
+		const apiConfiguration = controller.stateManager.getApiConfiguration()
+		const currentMode = "act"
+
+		// Build the API handler. Commit message generation is a fast one-shot
+		// transform that doesn't need extended thinking; disabling reasoning also
+		// avoids sending both reasoning.effort and reasoning.max_tokens, which
+		// some providers (e.g. OpenRouter) reject.
+		const apiHandler = buildApiHandler(apiConfiguration, currentMode, { disableReasoning: true })
+
+		// Create a system prompt
+		const systemPrompt = PROMPT.system
+
+		// Create a message for the API
+		const messages = [{ role: "user" as const, content: prompt }]
+
+		commitGenerationAbortController = new AbortController()
+		const stream = apiHandler.createMessage(systemPrompt, messages)
+
+		let response = ""
+		let streamError: string | undefined
+		for await (const chunk of stream) {
+			commitGenerationAbortController.signal.throwIfAborted()
+			if (chunk.type === "text") {
+				response += chunk.text
+				inputBox.value = extractCommitMessage(response)
+			} else if (chunk.type === "done" && chunk.success === false) {
+				// The SDK stream finished with a provider/auth error. Capture it so
+				// we can surface the real reason instead of a generic empty response.
+				streamError = chunk.error
+			}
+		}
+
+		if (!inputBox.value) {
+			if (streamError) {
+				throw new Error(streamError)
+			}
+			throw new Error(
+				"The model returned an empty response. Check that the selected provider and model are configured correctly.",
+			)
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Failed to generate commit message: ${errorMessage}`,
+		})
+	} finally {
+		vscode.commands.executeCommand("setContext", "cline.isGeneratingCommit", false)
+	}
+}
+
+export function abortCommitGeneration() {
+	commitGenerationAbortController?.abort()
+	vscode.commands.executeCommand("setContext", "cline.isGeneratingCommit", false)
+}
+
+/**
+ * Extracts the commit message from the AI response
+ * @param str String containing the AI response
+ * @returns The extracted commit message
+ */
+function extractCommitMessage(str: string): string {
+	// Remove any markdown formatting or extra text
+	return str
+		.trim()
+		.replace(/^```[^\n]*\n?|```$/g, "")
+		.trim()
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge-grpc-handler.ts b/apps/vscode/src/hosts/vscode/hostbridge-grpc-handler.ts
new file mode 100644
index 0000000..bcbd0fe
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge-grpc-handler.ts
@@ -0,0 +1,175 @@
+import { GrpcRequestRegistry } from "@core/controller/grpc-request-registry"
+import { hostServiceHandlers } from "@generated/hosts/vscode/hostbridge-grpc-service-config"
+import { StreamingCallbacks } from "@/hosts/host-provider-types"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Type definition for a streaming response handler
+ */
+export type StreamingResponseHandler = (response: any, isLast?: boolean, sequenceNumber?: number) => Promise<void>
+
+// Registry to track active gRPC requests and their cleanup functions
+const requestRegistry = new GrpcRequestRegistry()
+
+/**
+ * Handles gRPC requests for the host bridge.
+ */
+export class GrpcHandler {
+	constructor() {}
+
+	/**
+	 * Handle a gRPC request for the host bridge.
+	 * @param service The service name
+	 * @param method The method name
+	 * @param message The request message
+	 * @param requestId The request ID for response correlation
+	 * @param streamingCallbacks Optional callbacks for streaming responses
+	 * @returns For unary requests: the response message or error. For streaming requests: a cancel function.
+	 */
+	async handleRequest<T = any>(
+		service: string,
+		method: string,
+		request: any,
+		requestId: string,
+		streamingCallbacks?: StreamingCallbacks<T>,
+	): Promise<any | (() => void)> {
+		if (!streamingCallbacks) {
+			return this.handleUnaryRequest(service, method, request)
+		}
+
+		// If streaming callbacks are provided, handle as a streaming request
+		let completionCalled = false
+
+		// Create a response handler that will call the client's callbacks
+		const responseHandler: StreamingResponseHandler = async (response, isLast = false, _sequenceNumber) => {
+			try {
+				// Call the client's onResponse callback with the response
+				streamingCallbacks.onResponse(response)
+
+				// If this is the last response, call the onComplete callback
+				if (isLast && streamingCallbacks.onComplete && !completionCalled) {
+					completionCalled = true
+					streamingCallbacks.onComplete()
+				}
+			} catch (error) {
+				// If there's an error in the callback, call the onError callback
+				if (streamingCallbacks.onError) {
+					streamingCallbacks.onError(error instanceof Error ? error : new Error(String(error)))
+				}
+			}
+		}
+
+		// Register the response handler with the registry
+		requestRegistry.registerRequest(
+			requestId,
+			() => {
+				Logger.log(`[DEBUG] Cleaning up streaming request: ${requestId}`)
+				if (streamingCallbacks.onComplete && !completionCalled) {
+					completionCalled = true
+					streamingCallbacks.onComplete()
+				}
+			},
+			{ type: "streaming_request", service, method },
+			responseHandler,
+		)
+
+		// Call the streaming handler directly
+		try {
+			await this.handleStreamingRequest(service, method, request, requestId)
+		} catch (error) {
+			if (streamingCallbacks.onError) {
+				streamingCallbacks.onError(error instanceof Error ? error : new Error(String(error)))
+			}
+		}
+
+		// Return a function to cancel the stream
+		return () => {
+			Logger.log(`[DEBUG] Cancelling streaming request: ${requestId}`)
+			this.cancelRequest(requestId)
+		}
+	}
+
+	private async handleUnaryRequest(service: string, method: string, request: any): Promise<any> {
+		const serviceConfig = this.getServiceHandlerConfig(service)
+		const response = await serviceConfig.requestHandler(method, request)
+		return response
+	}
+
+	/**
+	 * Cancel a gRPC request
+	 * @param requestId The request ID to cancel
+	 * @returns True if the request was found and cancelled, false otherwise
+	 */
+	public async cancelRequest(requestId: string): Promise<boolean> {
+		const requestInfo = requestRegistry.getRequestInfo(requestId)
+		if (!requestInfo) {
+			return false
+		}
+
+		const cancelled = requestRegistry.cancelRequest(requestId)
+		if (!cancelled) {
+			Logger.log(`[DEBUG] Request not found for cancellation: ${requestId}`)
+			return false
+		}
+		if (requestInfo.responseStream) {
+			try {
+				// Send cancellation confirmation using the registered response handler
+				await requestInfo.responseStream({ cancelled: true }, true /* isLast */)
+			} catch (e) {
+				Logger.error(`Error sending cancellation response for ${requestId}:`, e)
+			}
+		}
+		return true
+	}
+
+	/**
+	 * Handle a streaming gRPC request
+	 * @param service The service name
+	 * @param method The method name
+	 * @param message The request message
+	 * @param requestId The request ID for response correlation
+	 */
+	private async handleStreamingRequest(service: string, method: string, message: any, requestId: string): Promise<void> {
+		const serviceConfig = this.getServiceHandlerConfig(service)
+
+		// Check if the service supports streaming
+		if (!serviceConfig.streamingHandler) {
+			throw new Error(`Service ${service} does not support streaming`)
+		}
+
+		// Get the registered response handler from the registry
+		const requestInfo = requestRegistry.getRequestInfo(requestId)
+		if (!requestInfo || !requestInfo.responseStream) {
+			throw new Error(`No response handler registered for request: ${requestId}`)
+		}
+
+		// Use the registered response handler
+		const responseStream = requestInfo.responseStream
+
+		// Handle streaming request and pass the requestId to all streaming handlers
+		await serviceConfig.streamingHandler(method, message, responseStream, requestId)
+
+		// Don't send a final message here - the stream should stay open for future updates
+		// The stream will be closed when the client disconnects or when the service explicitly ends it
+	}
+
+	private getServiceHandlerConfig(serviceName: string): HostServiceHandlerConfig {
+		if (!(serviceName in hostServiceHandlers)) {
+			throw new Error(`Unknown service: ${serviceName}`)
+		}
+		return hostServiceHandlers[serviceName]
+	}
+}
+
+/**
+ * Configuration for a host service handler
+ */
+export interface HostServiceHandlerConfig {
+	requestHandler: (method: string, message: any) => Promise<any>
+	streamingHandler: (
+		method: string,
+		message: any,
+		responseStream: StreamingResponseHandler,
+		requestId?: string,
+	) => Promise<void>
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge-grpc-service.ts b/apps/vscode/src/hosts/vscode/hostbridge-grpc-service.ts
new file mode 100644
index 0000000..daa8dc5
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge-grpc-service.ts
@@ -0,0 +1,137 @@
+import { StreamingResponseHandler } from "./hostbridge-grpc-handler"
+
+/**
+ * Generic type for service method handlers
+ */
+export type ServiceMethodHandler = (message: any) => Promise<any>
+
+/**
+ * Type for streaming method handlers
+ */
+export type StreamingMethodHandler = (message: any, responseStream: StreamingResponseHandler, requestId?: string) => Promise<void>
+
+/**
+ * Method metadata including streaming information
+ */
+export interface MethodMetadata {
+	isStreaming: boolean
+}
+
+/**
+ * Generic service registry for gRPC services
+ */
+class ServiceRegistry {
+	private serviceName: string
+	private methodRegistry: Record<string, ServiceMethodHandler> = {}
+	private streamingMethodRegistry: Record<string, StreamingMethodHandler> = {}
+	private methodMetadata: Record<string, MethodMetadata> = {}
+
+	/**
+	 * Create a new service registry
+	 * @param serviceName The name of the service (used for logging)
+	 */
+	constructor(serviceName: string) {
+		this.serviceName = serviceName
+	}
+
+	/**
+	 * Register a method handler
+	 * @param methodName The name of the method to register
+	 * @param handler The handler function for the method
+	 * @param metadata Optional metadata about the method
+	 */
+	registerMethod(methodName: string, handler: ServiceMethodHandler | StreamingMethodHandler, metadata?: MethodMetadata): void {
+		const isStreaming = metadata?.isStreaming || false
+
+		if (isStreaming) {
+			this.streamingMethodRegistry[methodName] = handler as StreamingMethodHandler
+		} else {
+			this.methodRegistry[methodName] = handler as ServiceMethodHandler
+		}
+
+		this.methodMetadata[methodName] = { isStreaming, ...metadata }
+	}
+
+	/**
+	 * Check if a method is a streaming method
+	 * @param method The method name
+	 * @returns True if the method is a streaming method
+	 */
+	isStreamingMethod(method: string): boolean {
+		return this.methodMetadata[method]?.isStreaming || false
+	}
+
+	/**
+	 * Get a streaming method handler
+	 * @param method The method name
+	 * @returns The streaming method handler or undefined if not found
+	 */
+	getStreamingHandler(method: string): StreamingMethodHandler | undefined {
+		return this.streamingMethodRegistry[method]
+	}
+
+	/**
+	 * Handle a service request
+	 * @param method The method name
+	 * @param message The request message
+	 * @returns The response message
+	 */
+	async handleRequest(method: string, message: any): Promise<any> {
+		const handler = this.methodRegistry[method]
+
+		if (!handler) {
+			if (this.isStreamingMethod(method)) {
+				throw new Error(`Method ${method} is a streaming method and should be handled with handleStreamingRequest`)
+			}
+			throw new Error(`Unknown ${this.serviceName} method: ${method}`)
+		}
+
+		return handler(message)
+	}
+
+	/**
+	 * Handle a streaming service request
+	 * @param method The method name
+	 * @param message The request message
+	 * @param responseStream The streaming response handler
+	 * @param requestId The request ID for correlation and cleanup
+	 */
+	async handleStreamingRequest(
+		method: string,
+		message: any,
+		responseStream: StreamingResponseHandler,
+		requestId?: string,
+	): Promise<void> {
+		const handler = this.streamingMethodRegistry[method]
+
+		if (!handler) {
+			if (this.methodRegistry[method]) {
+				throw new Error(`Method ${method} is not a streaming method and should be handled with handleRequest`)
+			}
+			throw new Error(`Unknown ${this.serviceName} streaming method: ${method}`)
+		}
+
+		await handler(message, responseStream, requestId)
+	}
+}
+
+/**
+ * Create a service registry factory function
+ * @param serviceName The name of the service
+ * @returns An object with register and handle functions
+ */
+export function createServiceRegistry(serviceName: string) {
+	const registry = new ServiceRegistry(serviceName)
+
+	return {
+		registerMethod: (methodName: string, handler: ServiceMethodHandler | StreamingMethodHandler, metadata?: MethodMetadata) =>
+			registry.registerMethod(methodName, handler, metadata),
+
+		handleRequest: (method: string, message: any) => registry.handleRequest(method, message),
+
+		handleStreamingRequest: (method: string, message: any, responseStream: StreamingResponseHandler, requestId?: string) =>
+			registry.handleStreamingRequest(method, message, responseStream, requestId),
+
+		isStreamingMethod: (method: string) => registry.isStreamingMethod(method),
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/client/host-grpc-client-base.ts b/apps/vscode/src/hosts/vscode/hostbridge/client/host-grpc-client-base.ts
new file mode 100644
index 0000000..60ee301
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/client/host-grpc-client-base.ts
@@ -0,0 +1,101 @@
+import { v4 as uuidv4 } from "uuid"
+import { StreamingCallbacks } from "@/hosts/host-provider-types"
+import { GrpcHandler } from "@/hosts/vscode/hostbridge-grpc-handler"
+import { Logger } from "@/shared/services/Logger"
+
+// Generic type for any protobuf service definition
+export type ProtoService = {
+	name: string
+	fullName: string
+	methods: {
+		[key: string]: {
+			name: string
+			requestType: any
+			responseType: any
+			requestStream: boolean
+			responseStream: boolean
+			options: any
+		}
+	}
+}
+
+// Define a unified client type that handles both unary and streaming methods
+export type GrpcClientType<T extends ProtoService> = {
+	[K in keyof T["methods"]]: T["methods"][K]["responseStream"] extends true
+		? (
+				request: InstanceType<T["methods"][K]["requestType"]>,
+				options: StreamingCallbacks<InstanceType<T["methods"][K]["responseType"]>>,
+			) => () => void // Returns a cancel function
+		: (request: InstanceType<T["methods"][K]["requestType"]>) => Promise<InstanceType<T["methods"][K]["responseType"]>>
+}
+
+// Create a client for any protobuf service with inferred types
+export function createGrpcClient<T extends ProtoService>(service: T): GrpcClientType<T> {
+	const client = {} as GrpcClientType<T>
+	const grpcHandler = new GrpcHandler()
+
+	Object.values(service.methods).forEach((method) => {
+		// Use lowercase method name as the key in the client object
+		const methodKey = method.name.charAt(0).toLowerCase() + method.name.slice(1)
+
+		// Streaming method implementation
+		if (method.responseStream) {
+			client[methodKey as keyof GrpcClientType<T>] = ((
+				request: any,
+				options: StreamingCallbacks<InstanceType<typeof method.responseType>>,
+			) => {
+				// Use handleRequest with streaming callbacks
+				const requestId = uuidv4()
+
+				// We need to await the promise and then return the cancel function
+				return (async () => {
+					try {
+						const result = await grpcHandler.handleRequest<InstanceType<typeof method.responseType>>(
+							service.fullName,
+							methodKey,
+							request,
+							requestId,
+							options,
+						)
+
+						// If the result is a function, it's the cancel function
+						if (typeof result === "function") {
+							return result
+						} else {
+							// This shouldn't happen, but just in case
+							Logger.error(`Expected cancel function but got response object for streaming request: ${requestId}`)
+							return () => {}
+						}
+					} catch (error) {
+						Logger.error(`Error in streaming request: ${error}`)
+						if (options.onError) {
+							options.onError(error instanceof Error ? error : new Error(String(error)))
+						}
+						return () => {}
+					}
+				})()
+			}) as any
+		} else {
+			// Unary method implementation
+			client[methodKey as keyof GrpcClientType<T>] = ((request: any) => {
+				return new Promise(async (resolve, reject) => {
+					const requestId = uuidv4()
+					try {
+						const response = await grpcHandler.handleRequest(service.fullName, methodKey, request, requestId)
+
+						// Check if the response is a function (streaming)
+						if (typeof response === "function") {
+							// This shouldn't happen for unary requests
+							throw new Error("Received streaming response for unary request")
+						}
+						resolve(response)
+					} catch (e) {
+						Logger.log(`[DEBUG] gRPC host ERR to ${service.fullName}.${methodKey} req:${requestId} err:${e}`)
+						reject(e)
+					}
+				})
+			}) as any
+		}
+	})
+	return client
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/client/host-grpc-client.ts b/apps/vscode/src/hosts/vscode/hostbridge/client/host-grpc-client.ts
new file mode 100644
index 0000000..9fde529
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/client/host-grpc-client.ts
@@ -0,0 +1,10 @@
+import { createGrpcClient } from "@hosts/vscode/hostbridge/client/host-grpc-client-base"
+import * as host from "@shared/proto/index.host"
+import { HostBridgeClientProvider } from "@/hosts/host-provider-types"
+
+export const vscodeHostBridgeClient: HostBridgeClientProvider = {
+	workspaceClient: createGrpcClient(host.WorkspaceServiceDefinition),
+	envClient: createGrpcClient(host.EnvServiceDefinition),
+	windowClient: createGrpcClient(host.WindowServiceDefinition),
+	diffClient: createGrpcClient(host.DiffServiceDefinition),
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/closeAllDiffs.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/closeAllDiffs.ts
new file mode 100644
index 0000000..5470eea
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/closeAllDiffs.ts
@@ -0,0 +1,5 @@
+import { CloseAllDiffsRequest, CloseAllDiffsResponse } from "@/shared/proto/index.host"
+
+export async function closeAllDiffs(_request: CloseAllDiffsRequest): Promise<CloseAllDiffsResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/getDocumentText.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/getDocumentText.ts
new file mode 100644
index 0000000..f32f5dc
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/getDocumentText.ts
@@ -0,0 +1,5 @@
+import { GetDocumentTextRequest, GetDocumentTextResponse } from "@/shared/proto/index.host"
+
+export async function getDocumentText(_request: GetDocumentTextRequest): Promise<GetDocumentTextResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/openDiff.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/openDiff.ts
new file mode 100644
index 0000000..850fc52
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/openDiff.ts
@@ -0,0 +1,5 @@
+import { OpenDiffRequest, OpenDiffResponse } from "@/shared/proto/index.host"
+
+export async function openDiff(_request: OpenDiffRequest): Promise<OpenDiffResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/openMultiFileDiff.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/openMultiFileDiff.ts
new file mode 100644
index 0000000..fecd7d1
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/openMultiFileDiff.ts
@@ -0,0 +1,33 @@
+import path from "path"
+import * as vscode from "vscode"
+import { OpenMultiFileDiffRequest, OpenMultiFileDiffResponse } from "@/shared/proto/index.host"
+import { getCwd } from "@/utils/path"
+import { DIFF_VIEW_URI_SCHEME } from "../../VscodeDiffViewProvider"
+
+export async function openMultiFileDiff(request: OpenMultiFileDiffRequest): Promise<OpenMultiFileDiffResponse> {
+	const cwd = await getCwd()
+	await vscode.commands.executeCommand(
+		"vscode.changes",
+		request.title,
+		request.diffs.map((diff) => {
+			const file = vscode.Uri.file(diff.filePath || "")
+			const relativePath = path.relative(cwd, diff.filePath || "")
+			const left = diff.leftContent ?? ""
+			const right = diff.rightContent ?? ""
+			return [
+				file,
+				vscode.Uri.parse(`${DIFF_VIEW_URI_SCHEME}:${relativePath}`).with({
+					query: Buffer.from(left).toString("base64"),
+				}),
+				vscode.Uri.parse(`${DIFF_VIEW_URI_SCHEME}:${relativePath}`).with({
+					query: Buffer.from(right).toString("base64"),
+				}),
+			]
+		}),
+	)
+
+	// Hide the bottom panel to give more room for the diff view
+	vscode.commands.executeCommand("workbench.action.closePanel")
+
+	return {}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/replaceText.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/replaceText.ts
new file mode 100644
index 0000000..c2e81e5
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/replaceText.ts
@@ -0,0 +1,5 @@
+import { ReplaceTextRequest, ReplaceTextResponse } from "@/shared/proto/index.host"
+
+export async function replaceText(_request: ReplaceTextRequest): Promise<ReplaceTextResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/saveDocument.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/saveDocument.ts
new file mode 100644
index 0000000..db163be
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/saveDocument.ts
@@ -0,0 +1,5 @@
+import { SaveDocumentRequest, SaveDocumentResponse } from "@/shared/proto/index.host"
+
+export async function saveDocument(_request: SaveDocumentRequest): Promise<SaveDocumentResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/scrollDiff.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/scrollDiff.ts
new file mode 100644
index 0000000..658cdb6
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/scrollDiff.ts
@@ -0,0 +1,5 @@
+import { ScrollDiffRequest, ScrollDiffResponse } from "@/shared/proto/index.host"
+
+export async function scrollDiff(_request: ScrollDiffRequest): Promise<ScrollDiffResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/diff/truncateDocument.ts b/apps/vscode/src/hosts/vscode/hostbridge/diff/truncateDocument.ts
new file mode 100644
index 0000000..1867983
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/diff/truncateDocument.ts
@@ -0,0 +1,5 @@
+import { TruncateDocumentRequest, TruncateDocumentResponse } from "@/shared/proto/index.host"
+
+export async function truncateDocument(_request: TruncateDocumentRequest): Promise<TruncateDocumentResponse> {
+	throw new Error("diffService is not supported. Use the VscodeDiffViewProvider.")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/clipboardReadText.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/clipboardReadText.ts
new file mode 100644
index 0000000..f218418
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/clipboardReadText.ts
@@ -0,0 +1,7 @@
+import { EmptyRequest, String } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+
+export async function clipboardReadText(_: EmptyRequest): Promise<String> {
+	const text = await vscode.env.clipboard.readText()
+	return String.create({ value: text })
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/clipboardWriteText.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/clipboardWriteText.ts
new file mode 100644
index 0000000..a1d45f8
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/clipboardWriteText.ts
@@ -0,0 +1,7 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+
+export async function clipboardWriteText(request: StringRequest): Promise<Empty> {
+	await vscode.env.clipboard.writeText(request.value)
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/debugLog.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/debugLog.ts
new file mode 100644
index 0000000..e972218
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/debugLog.ts
@@ -0,0 +1,16 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+
+const CLINE_OUTPUT_CHANNEL = vscode.window.createOutputChannel("Cline")
+
+// Appends a log message to all Cline output channels.
+export async function debugLog(request: StringRequest): Promise<Empty> {
+	CLINE_OUTPUT_CHANNEL.appendLine(request.value)
+	return Empty.create({})
+}
+
+// Register the Cline output channel within the VSCode extension context.
+export function registerClineOutputChannel(context: vscode.ExtensionContext): vscode.OutputChannel {
+	context.subscriptions.push(CLINE_OUTPUT_CHANNEL)
+	return CLINE_OUTPUT_CHANNEL
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/getHostVersion.test.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/getHostVersion.test.ts
new file mode 100644
index 0000000..8e809fe
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/getHostVersion.test.ts
@@ -0,0 +1,50 @@
+import { afterEach, describe, it } from "mocha"
+import { strict as assert } from "assert"
+import * as sinon from "sinon"
+import * as vscode from "vscode"
+import { ExtensionRegistryInfo } from "@/registry"
+import { ClineClient } from "@/shared/cline"
+import { getHostVersion } from "./getHostVersion"
+
+describe("Hostbridge - Env - getHostVersion", () => {
+	const sandbox = sinon.createSandbox()
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it("preserves known remote workspace names", async () => {
+		const cases = ["ssh-remote", "dev-container", "codespaces"]
+
+		for (const remoteName of cases) {
+			const remoteNameStub = sandbox.stub(vscode.env, "remoteName")
+			remoteNameStub.get(() => remoteName)
+
+			const response = await getHostVersion({} as any)
+
+			assert.strictEqual(response.platform, vscode.env.appName)
+			assert.strictEqual(response.version, vscode.version)
+			assert.strictEqual(response.clineType, ClineClient.VSCode)
+			assert.strictEqual(response.clineVersion, ExtensionRegistryInfo.version)
+			assert.strictEqual(response.remoteName, remoteName)
+
+			remoteNameStub.restore()
+		}
+	})
+
+	it("normalizes empty remote workspace names to undefined", async () => {
+		sandbox.stub(vscode.env, "remoteName").get(() => "")
+
+		const response = await getHostVersion({} as any)
+
+		assert.strictEqual(response.remoteName, undefined)
+	})
+
+	it("keeps local workspaces without a remoteName", async () => {
+		sandbox.stub(vscode.env, "remoteName").get(() => undefined)
+
+		const response = await getHostVersion({} as any)
+
+		assert.strictEqual(response.remoteName, undefined)
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/getHostVersion.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/getHostVersion.ts
new file mode 100644
index 0000000..b9710aa
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/getHostVersion.ts
@@ -0,0 +1,20 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+import { ExtensionRegistryInfo } from "@/registry"
+import { ClineClient } from "@/shared/cline"
+import { GetHostVersionResponse } from "@/shared/proto/index.host"
+
+export async function getHostVersion(_: EmptyRequest): Promise<GetHostVersionResponse> {
+	return {
+		platform: vscode.env.appName,
+		version: vscode.version,
+		clineType: ClineClient.VSCode,
+		clineVersion: ExtensionRegistryInfo.version,
+		// vscode.env.remoteName is a non-empty string when connected to a remote workspace
+		// (e.g. "ssh-remote", "dev-container", "codespaces") and undefined otherwise.
+		// We coerce falsy values (undefined, null, "") to undefined so the proto optional
+		// field is absent for local workspaces. An empty string is treated as local — the
+		// safe direction (false negative rather than false positive).
+		remoteName: vscode.env.remoteName || undefined,
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/getIdeRedirectUri.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/getIdeRedirectUri.ts
new file mode 100644
index 0000000..3a573cb
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/getIdeRedirectUri.ts
@@ -0,0 +1,13 @@
+import { EmptyRequest, String } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+
+export async function getIdeRedirectUri(_: EmptyRequest): Promise<String> {
+	if (vscode.env.uiKind === vscode.UIKind.Web) {
+		// In VS Code Web (code serve-web), the auth callback is handled by an HTTP server
+		// (AuthHandler). Returning empty here means the success page won't try to redirect
+		// to a vscode:// URI (which would open the desktop app instead of the web tab).
+		return { value: "" }
+	}
+	const uriScheme = vscode.env.uriScheme || "vscode"
+	return { value: `${uriScheme}://saoudrizwan.claude-dev` }
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/getTelemetrySettings.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/getTelemetrySettings.ts
new file mode 100644
index 0000000..95e741a
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/getTelemetrySettings.ts
@@ -0,0 +1,15 @@
+import * as vscode from "vscode"
+import { ErrorSettings } from "@/services/error"
+import { EmptyRequest } from "@/shared/proto/index.cline"
+import { GetTelemetrySettingsResponse, Setting } from "@/shared/proto/index.host"
+
+export async function getTelemetrySettings(_: EmptyRequest): Promise<GetTelemetrySettingsResponse> {
+	const config = vscode.workspace.getConfiguration("telemetry")
+	const errorLevel = config?.get<ErrorSettings["level"]>("telemetryLevel") || "all"
+
+	if (vscode.env.isTelemetryEnabled) {
+		return { isEnabled: Setting.ENABLED, errorLevel }
+	} else {
+		return { isEnabled: Setting.DISABLED, errorLevel }
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/openExternal.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/openExternal.ts
new file mode 100644
index 0000000..d3c6841
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/openExternal.ts
@@ -0,0 +1,8 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import * as vscode from "vscode"
+
+export async function openExternal(request: StringRequest): Promise<Empty> {
+	const uri = vscode.Uri.parse(request.value)
+	await vscode.env.openExternal(uri) // ← Routes to local browser in remote setups!
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/shutdown.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/shutdown.ts
new file mode 100644
index 0000000..5feec37
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/shutdown.ts
@@ -0,0 +1,9 @@
+import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+
+export async function shutdown(request: EmptyRequest): Promise<Empty> {
+	// VSCode extensions cannot shutdown the host process (VSCode itself)
+	// This is a no-op that just returns success
+	// The shutdown RPC is primarily used by standalone cline-core instances
+	// to tell their paired host bridge processes to shut down
+	return Empty.create({})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/env/subscribeToTelemetrySettings.ts b/apps/vscode/src/hosts/vscode/hostbridge/env/subscribeToTelemetrySettings.ts
new file mode 100644
index 0000000..eddd445
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/env/subscribeToTelemetrySettings.ts
@@ -0,0 +1,18 @@
+import * as vscode from "vscode"
+import { StreamingResponseHandler } from "@/hosts/vscode/hostbridge-grpc-handler"
+import { EmptyRequest } from "@/shared/proto/index.cline"
+import { Setting } from "@/shared/proto/index.host"
+
+/**
+ * Subscribe to changes to the telemetry settings.
+ */
+export async function subscribeToTelemetrySettings(
+	_: EmptyRequest,
+	responseStream: StreamingResponseHandler,
+	_requestId?: string,
+): Promise<void> {
+	vscode.env.onDidChangeTelemetryEnabled((isTelemetryEnabled) => {
+		const event = { isEnabled: isTelemetryEnabled ? Setting.ENABLED : Setting.DISABLED }
+		responseStream(event, false)
+	})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/testing/getWebviewHtml.ts b/apps/vscode/src/hosts/vscode/hostbridge/testing/getWebviewHtml.ts
new file mode 100644
index 0000000..8e5583d
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/testing/getWebviewHtml.ts
@@ -0,0 +1,5 @@
+import { GetWebviewHtmlRequest, GetWebviewHtmlResponse } from "@/shared/proto/index.host"
+
+export async function getWebviewHtml(_: GetWebviewHtmlRequest): Promise<GetWebviewHtmlResponse> {
+	throw new Error("Unimplemented")
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/getActiveEditor.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/getActiveEditor.ts
new file mode 100644
index 0000000..684e1f8
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/getActiveEditor.ts
@@ -0,0 +1,8 @@
+import * as vscode from "vscode"
+
+import { GetActiveEditorRequest, GetActiveEditorResponse } from "@/shared/proto/index.host"
+
+export async function getActiveEditor(_: GetActiveEditorRequest): Promise<GetActiveEditorResponse> {
+	const filePath = vscode.window.activeTextEditor?.document.uri.fsPath
+	return { filePath }
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/getOpenTabs.test.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/getOpenTabs.test.ts
new file mode 100644
index 0000000..a57ff30
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/getOpenTabs.test.ts
@@ -0,0 +1,183 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import { strict as assert } from "assert"
+import * as fs from "fs/promises"
+import * as os from "os"
+import pWaitFor from "p-wait-for"
+import * as path from "path"
+import * as vscode from "vscode"
+import { getOpenTabs } from "@/hosts/vscode/hostbridge/window/getOpenTabs"
+import { GetOpenTabsRequest } from "@/shared/proto/host/window"
+
+describe("Hostbridge - Window - getOpenTabs", () => {
+	async function createAndOpenTestDocument(name: string, column: vscode.ViewColumn): Promise<void> {
+		const content = `// Test file ${name}\nconsole.log('Hello from file ${name}');`
+
+		// Create an untitled document with a custom name
+		const uri = vscode.Uri.parse(`untitled:test-file-${name}.js`)
+
+		const doc = await vscode.workspace.openTextDocument(uri)
+
+		// Set the content
+		const edit = new vscode.WorkspaceEdit()
+		edit.insert(uri, new vscode.Position(0, 0), content)
+		await vscode.workspace.applyEdit(edit)
+
+		await vscode.window.showTextDocument(doc, {
+			viewColumn: column,
+			preview: false,
+		})
+	}
+
+	async function waitForAllTabsClosed(): Promise<void> {
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+		// Wait for tabs to actually close (Windows can be slow to process this)
+		await pWaitFor(
+			async () => {
+				const request = GetOpenTabsRequest.create({})
+				const response = await getOpenTabs(request)
+				return response.paths.length === 0
+			},
+			{
+				timeout: 5000,
+				interval: 50,
+			},
+		)
+	}
+
+	beforeEach(async () => {
+		// Clean up any existing editors and wait for cleanup to complete
+		await waitForAllTabsClosed()
+	})
+
+	afterEach(async () => {
+		// Clean up test documents and editors
+		await waitForAllTabsClosed()
+	})
+
+	it("should return empty array when no tabs are open", async () => {
+		// beforeEach already ensures no tabs are open
+		const request = GetOpenTabsRequest.create({})
+		const response = await getOpenTabs(request)
+
+		assert.strictEqual(
+			response.paths.length,
+			0,
+			`Should return empty array when no tabs are open. Found: ${JSON.stringify(response.paths)}`,
+		)
+	})
+
+	it("should return paths of open text document tabs", async () => {
+		// Open the documents in editors (this creates the tabs)
+		await createAndOpenTestDocument("open-tabs-1", vscode.ViewColumn.One)
+		await createAndOpenTestDocument("open-tabs-2", vscode.ViewColumn.Two)
+
+		// Wait for tabs to be fully created
+		await pWaitFor(
+			async () => {
+				const request = GetOpenTabsRequest.create({})
+				const response = await getOpenTabs(request)
+				console.log(
+					`[DEBUG] Waiting for 2 tabs, currently found ${response.paths.length}: ${JSON.stringify(response.paths)}`,
+				)
+				return response.paths.length === 2
+			},
+			{
+				timeout: 8000,
+				interval: 50,
+			},
+		)
+
+		const request = GetOpenTabsRequest.create({})
+		const response = await getOpenTabs(request)
+
+		// Should have 2 tabs open
+		assert.strictEqual(
+			response.paths.length,
+			2,
+			`Expected 2 tabs, got ${response.paths.length}. Found tabs: ${JSON.stringify(response.paths)}`,
+		)
+	})
+
+	it("should return all open tabs even when multiple files are opened in the same ViewColumn", async () => {
+		// Open all documents in the same column (only the last one will be visible, but all are open as tabs)
+		await createAndOpenTestDocument("same-column-1", vscode.ViewColumn.One)
+		await createAndOpenTestDocument("same-column-2", vscode.ViewColumn.One)
+		await createAndOpenTestDocument("same-column-3", vscode.ViewColumn.One)
+
+		// Wait for tabs to be fully created
+		await pWaitFor(
+			async () => {
+				const request = GetOpenTabsRequest.create({})
+				const response = await getOpenTabs(request)
+				console.log(
+					`[DEBUG] Waiting for 3 tabs, currently found ${response.paths.length}: ${JSON.stringify(response.paths)}`,
+				)
+				return response.paths.length === 3
+			},
+			{
+				timeout: 8000,
+				interval: 50,
+			},
+		)
+
+		const request = GetOpenTabsRequest.create({})
+		const response = await getOpenTabs(request)
+
+		// Should have all 3 tabs open, even though only 1 is visible
+		assert.strictEqual(
+			response.paths.length,
+			3,
+			`Expected 3 open tabs, got ${response.paths.length}. Found: ${JSON.stringify(response.paths)}`,
+		)
+	})
+
+	it("should return all tabs including deleted files", async () => {
+		// Create a temporary file on disk
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vscode-test-"))
+		const testFilePath = path.join(tempDir, "test-file.js")
+		await fs.writeFile(testFilePath, "console.log('test file');")
+
+		// Open the file as a tab
+		const document = await vscode.workspace.openTextDocument(testFilePath)
+		await vscode.window.showTextDocument(document, { preview: false })
+
+		// Also open an untitled document
+		await createAndOpenTestDocument("includes-deleted", vscode.ViewColumn.One)
+
+		// Wait for tabs to be created
+		await pWaitFor(
+			async () => {
+				const request = GetOpenTabsRequest.create({})
+				const response = await getOpenTabs(request)
+				console.log(
+					`[DEBUG] Waiting for 2 tabs (temp file + untitled), currently found ${response.paths.length}: ${JSON.stringify(response.paths)}`,
+				)
+				return response.paths.length === 2
+			},
+			{
+				timeout: 8000,
+				interval: 50,
+			},
+		)
+
+		// Delete the file from disk
+		await fs.unlink(testFilePath)
+
+		// Get open tabs - should still return both tabs
+		const request = GetOpenTabsRequest.create({})
+		const response = await getOpenTabs(request)
+
+		// Should still have 2 tabs (host bridge returns all tabs regardless of file existence)
+		assert.strictEqual(
+			response.paths.length,
+			2,
+			`Host bridge should return all tabs including deleted files. Found tabs: ${JSON.stringify(response.paths)}`,
+		)
+		try {
+			// Clean up temp directory
+			await fs.rm(tempDir, { recursive: true })
+		} catch (error) {
+			console.error(error)
+		}
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/getOpenTabs.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/getOpenTabs.ts
new file mode 100644
index 0000000..2b1a1e3
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/getOpenTabs.ts
@@ -0,0 +1,11 @@
+import { TabInputText, window } from "vscode"
+import { GetOpenTabsRequest, GetOpenTabsResponse } from "@/shared/proto/host/window"
+
+export async function getOpenTabs(_: GetOpenTabsRequest): Promise<GetOpenTabsResponse> {
+	const openTabPaths = window.tabGroups.all
+		.flatMap((group) => group.tabs)
+		.map((tab) => (tab.input as TabInputText)?.uri?.fsPath)
+		.filter(Boolean)
+
+	return GetOpenTabsResponse.create({ paths: openTabPaths ?? [] })
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/getVisibleTabs.test.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/getVisibleTabs.test.ts
new file mode 100644
index 0000000..6cd5671
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/getVisibleTabs.test.ts
@@ -0,0 +1,191 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import { strict as assert } from "assert"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import * as vscode from "vscode"
+import { getVisibleTabs } from "@/hosts/vscode/hostbridge/window/getVisibleTabs"
+import { GetVisibleTabsRequest } from "@/shared/proto/host/window"
+
+describe("Hostbridge - Window - getVisibleTabs", () => {
+	/**
+	 * Helper function to create and open a test document in a specific column
+	 */
+	async function createAndOpenTestDocument(fileNumber: number, column: vscode.ViewColumn): Promise<void> {
+		const content = `// Test file ${fileNumber}\nconsole.log('Hello from file ${fileNumber}');`
+
+		// Create an untitled document with a custom name
+		const uri = vscode.Uri.parse(`untitled:test-file-${fileNumber}.js`)
+
+		const doc = await vscode.workspace.openTextDocument(uri)
+
+		// Set the content
+		const edit = new vscode.WorkspaceEdit()
+		edit.insert(uri, new vscode.Position(0, 0), content)
+		await vscode.workspace.applyEdit(edit)
+
+		await vscode.window.showTextDocument(doc, {
+			viewColumn: column,
+			preview: false,
+		})
+	}
+
+	beforeEach(async () => {
+		// Clean up any existing editors
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+	})
+
+	afterEach(async () => {
+		// Clean up test documents and editors
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+	})
+
+	it("should return empty array when no visible editors are open", async () => {
+		// Ensure no editors are open
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+
+		const request = GetVisibleTabsRequest.create({})
+		const response = await getVisibleTabs(request)
+
+		assert.strictEqual(
+			response.paths.length,
+			0,
+			`Should return empty array when no visible editors are open. Found tabs: ${JSON.stringify(response.paths)}`,
+		)
+	})
+
+	it("should return paths of visible text editors", async () => {
+		// Open the first document in an editor (this makes it visible)
+		await createAndOpenTestDocument(1, vscode.ViewColumn.One)
+
+		// Wait a bit for editor to be fully created
+		await new Promise((resolve) => setTimeout(resolve, 100))
+
+		const request = GetVisibleTabsRequest.create({})
+		const response = await getVisibleTabs(request)
+
+		// Should have 1 visible editor
+		assert.strictEqual(
+			response.paths.length,
+			1,
+			`Expected 1 visible editor, got ${response.paths.length}. Found: ${JSON.stringify(response.paths)}`,
+		)
+
+		// Open the second document in a different column (both should now be visible)
+		await createAndOpenTestDocument(2, vscode.ViewColumn.Two)
+
+		// Wait a bit for editor to be fully created
+		await new Promise((resolve) => setTimeout(resolve, 100))
+
+		const response2 = await getVisibleTabs(request)
+
+		// Should have 2 visible editors
+		assert.strictEqual(
+			response2.paths.length,
+			2,
+			`Expected 2 visible editors, got ${response2.paths.length}. Found: ${JSON.stringify(response2.paths)}`,
+		)
+	})
+
+	it("should only return visible editors, not all open tabs", async () => {
+		// Open all documents in the same column (only the last one will be visible)
+		await createAndOpenTestDocument(1, vscode.ViewColumn.One)
+		await createAndOpenTestDocument(2, vscode.ViewColumn.One)
+		await createAndOpenTestDocument(3, vscode.ViewColumn.One)
+
+		// Wait a bit for editors to be fully created
+		await new Promise((resolve) => setTimeout(resolve, 100))
+
+		const request = GetVisibleTabsRequest.create({})
+		const response = await getVisibleTabs(request)
+
+		// Should have only 1 visible editor (the last one opened in the same column)
+		assert.strictEqual(
+			response.paths.length,
+			1,
+			`Expected 1 visible editor, got ${response.paths.length}. Found: ${JSON.stringify(response.paths)}`,
+		)
+
+		// Verify that we have the correct number of visible text editors
+		const actualVisibleEditors = vscode.window.visibleTextEditors.length
+		assert.strictEqual(
+			response.paths.length,
+			actualVisibleEditors,
+			`Response should match actual visible editors count: ${actualVisibleEditors}`,
+		)
+	})
+
+	it("should return only visible editors from multiple columns with multiple files", async () => {
+		// Open multiple documents in column one (only the last one will be visible in that column)
+		await createAndOpenTestDocument(1, vscode.ViewColumn.One)
+		await createAndOpenTestDocument(2, vscode.ViewColumn.One)
+		await createAndOpenTestDocument(3, vscode.ViewColumn.One)
+
+		// Open multiple documents in column two (only the last one will be visible in that column)
+		await createAndOpenTestDocument(4, vscode.ViewColumn.Two)
+		await createAndOpenTestDocument(5, vscode.ViewColumn.Two)
+
+		// Wait a bit for editors to be fully created
+		await new Promise((resolve) => setTimeout(resolve, 100))
+
+		const request = GetVisibleTabsRequest.create({})
+		const response = await getVisibleTabs(request)
+
+		// Should have only 2 visible editors (one from each column, despite having 5 total open tabs)
+		assert.strictEqual(
+			response.paths.length,
+			2,
+			`Expected 2 visible editors, got ${response.paths.length}. Found: ${JSON.stringify(response.paths)}`,
+		)
+
+		// Verify that we have the correct number of visible text editors
+		const actualVisibleEditors = vscode.window.visibleTextEditors.length
+		assert.strictEqual(
+			response.paths.length,
+			actualVisibleEditors,
+			`Response should match actual visible editors count: ${actualVisibleEditors}`,
+		)
+	})
+
+	it("should return all visible tabs including deleted files)", async () => {
+		// Create a temporary file on disk
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "cline-test-"))
+		const testFilePath = path.join(tempDir, "test-file-to-delete.txt")
+		await fs.writeFile(testFilePath, "This file will be deleted")
+
+		// Open the real file
+		const fileUri = vscode.Uri.file(testFilePath)
+		const fileDoc = await vscode.workspace.openTextDocument(fileUri)
+		await vscode.window.showTextDocument(fileDoc, { viewColumn: vscode.ViewColumn.One, preview: false })
+
+		// Also open an untitled document
+		const untitledUri = vscode.Uri.parse("untitled:preserved-file.js")
+		const untitledDoc = await vscode.workspace.openTextDocument(untitledUri)
+		const edit = new vscode.WorkspaceEdit()
+		edit.insert(untitledUri, new vscode.Position(0, 0), "// This untitled file should be preserved")
+		await vscode.workspace.applyEdit(edit)
+		await vscode.window.showTextDocument(untitledDoc, { viewColumn: vscode.ViewColumn.Two, preview: false })
+
+		// Wait for editors to be fully created
+		await new Promise((resolve) => setTimeout(resolve, 100))
+
+		// Verify both files are initially visible
+		const request = GetVisibleTabsRequest.create({})
+		let response = await getVisibleTabs(request)
+		assert.strictEqual(response.paths.length, 2, "Should initially have 2 visible tabs")
+
+		// Delete the real file from disk (but keep the editor open)
+		await fs.unlink(testFilePath)
+
+		// Get visible tabs again - should still return both tabs
+		response = await getVisibleTabs(request)
+		assert.strictEqual(
+			response.paths.length,
+			2,
+			`Host bridge should return all tabs including deleted files. Found: ${JSON.stringify(response.paths)}`,
+		)
+
+		// Clean up temp directory
+		await fs.rm(tempDir, { recursive: true }).catch(() => {})
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/getVisibleTabs.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/getVisibleTabs.ts
new file mode 100644
index 0000000..13be4f7
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/getVisibleTabs.ts
@@ -0,0 +1,8 @@
+import { window } from "vscode"
+import { GetVisibleTabsRequest, GetVisibleTabsResponse } from "@/shared/proto/host/window"
+
+export async function getVisibleTabs(_: GetVisibleTabsRequest): Promise<GetVisibleTabsResponse> {
+	const visibleTabPaths = window.visibleTextEditors?.map((editor) => editor.document?.uri?.fsPath).filter(Boolean)
+
+	return GetVisibleTabsResponse.create({ paths: visibleTabPaths ?? [] })
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/openFile.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/openFile.ts
new file mode 100644
index 0000000..7e3be70
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/openFile.ts
@@ -0,0 +1,7 @@
+import * as vscode from "vscode"
+import { OpenFileRequest, OpenFileResponse } from "@/shared/proto/host/window"
+
+export async function openFile(request: OpenFileRequest): Promise<OpenFileResponse> {
+	await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(request.filePath))
+	return OpenFileResponse.create({})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/openSettings.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/openSettings.ts
new file mode 100644
index 0000000..038e1f4
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/openSettings.ts
@@ -0,0 +1,8 @@
+import * as vscode from "vscode"
+import { OpenSettingsRequest, OpenSettingsResponse } from "@/shared/proto/host/window"
+
+export async function openSettings(request: OpenSettingsRequest): Promise<OpenSettingsResponse> {
+	// VS Code can be queried to focus a specific setting section
+	await vscode.commands.executeCommand("workbench.action.openSettings", request.query ?? undefined)
+	return OpenSettingsResponse.create({})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/showInputBox.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/showInputBox.ts
new file mode 100644
index 0000000..623ae81
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/showInputBox.ts
@@ -0,0 +1,11 @@
+import * as vscode from "vscode"
+import { ShowInputBoxRequest, ShowInputBoxResponse } from "@/shared/proto/index.host"
+
+export async function showInputBox(request: ShowInputBoxRequest): Promise<ShowInputBoxResponse> {
+	const response = await vscode.window.showInputBox({
+		title: request.title,
+		prompt: request.prompt,
+		value: request.value,
+	})
+	return ShowInputBoxResponse.create({ response })
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/showMessage.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/showMessage.ts
new file mode 100644
index 0000000..91d1a2a
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/showMessage.ts
@@ -0,0 +1,26 @@
+import { window } from "vscode"
+import { SelectedResponse, ShowMessageRequest, ShowMessageType } from "@/shared/proto/index.host"
+
+const DEFAULT_OPTIONS = { modal: false, items: [] } as const
+
+export async function showMessage(request: ShowMessageRequest): Promise<SelectedResponse> {
+	const { message, type, options } = request
+	const { modal, detail, items } = { ...DEFAULT_OPTIONS, ...options }
+	const option = { modal, detail }
+
+	let selectedOption: string | undefined
+
+	switch (type) {
+		case ShowMessageType.ERROR:
+			selectedOption = await window.showErrorMessage(message, option, ...items)
+			break
+		case ShowMessageType.WARNING:
+			selectedOption = await window.showWarningMessage(message, option, ...items)
+			break
+		default:
+			selectedOption = await window.showInformationMessage(message, option, ...items)
+			break
+	}
+
+	return SelectedResponse.create({ selectedOption })
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/showOpenDialogue.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/showOpenDialogue.ts
new file mode 100644
index 0000000..2dd58eb
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/showOpenDialogue.ts
@@ -0,0 +1,27 @@
+import * as vscode from "vscode"
+import { SelectedResources, ShowOpenDialogueRequest } from "@/shared/proto/host/window"
+
+export async function showOpenDialogue(request: ShowOpenDialogueRequest): Promise<SelectedResources> {
+	const options: vscode.OpenDialogOptions = {}
+
+	if (request.canSelectMany !== undefined) {
+		options.canSelectMany = request.canSelectMany
+	}
+
+	if (request.openLabel !== undefined) {
+		options.openLabel = request.openLabel
+	}
+
+	if (request.filters?.files) {
+		options.filters = {
+			Files: request.filters.files,
+		}
+	}
+
+	const selectedResources = await vscode.window.showOpenDialog(options)
+
+	// Convert back to path format
+	return SelectedResources.create({
+		paths: selectedResources ? selectedResources.map((uri) => uri.fsPath) : [],
+	})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/showSaveDialog.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/showSaveDialog.ts
new file mode 100644
index 0000000..2634e8d
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/showSaveDialog.ts
@@ -0,0 +1,25 @@
+import { SaveDialogOptions, Uri, window } from "vscode"
+import { ShowSaveDialogRequest, ShowSaveDialogResponse } from "@/shared/proto/index.host"
+
+export async function showSaveDialog(request: ShowSaveDialogRequest): Promise<ShowSaveDialogResponse> {
+	const { options } = request
+
+	const vscodeOptions: SaveDialogOptions = {}
+
+	if (options?.defaultPath) {
+		vscodeOptions.defaultUri = Uri.file(options.defaultPath)
+	}
+
+	if (options?.filters && Object.keys(options.filters).length > 0) {
+		vscodeOptions.filters = {}
+		Object.entries(options.filters).forEach(([name, extensionList]) => {
+			vscodeOptions.filters![name] = extensionList.extensions
+		})
+	}
+
+	const selectedUri = await window.showSaveDialog(vscodeOptions)
+
+	return ShowSaveDialogResponse.create({
+		selectedPath: selectedUri?.fsPath,
+	})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/window/showTextDocument.ts b/apps/vscode/src/hosts/vscode/hostbridge/window/showTextDocument.ts
new file mode 100644
index 0000000..eb70b34
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/window/showTextDocument.ts
@@ -0,0 +1,46 @@
+import * as vscode from "vscode"
+import { ShowTextDocumentRequest, TextEditorInfo } from "@/shared/proto/host/window"
+import { arePathsEqual } from "@/utils/path"
+
+export async function showTextDocument(request: ShowTextDocumentRequest): Promise<TextEditorInfo> {
+	// Convert file path to URI
+	const uri = vscode.Uri.file(request.path)
+
+	// Check if the document is already open in a tab group that's not in the active editor's column.
+	//  If it is, then close it (if not dirty) so that we don't duplicate tabs
+	try {
+		for (const group of vscode.window.tabGroups.all) {
+			const existingTab = group.tabs.find(
+				(tab) => tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, uri.fsPath),
+			)
+			if (existingTab) {
+				const activeColumn = vscode.window.activeTextEditor?.viewColumn
+				const tabColumn = vscode.window.tabGroups.all.find((group) => group.tabs.includes(existingTab))?.viewColumn
+				if (activeColumn && activeColumn !== tabColumn && !existingTab.isDirty) {
+					await vscode.window.tabGroups.close(existingTab)
+				}
+				break
+			}
+		}
+	} catch {} // not essential, sometimes tab operations fail
+
+	const options: vscode.TextDocumentShowOptions = {}
+
+	if (request.options?.preview !== undefined) {
+		options.preview = request.options.preview
+	}
+	if (request.options?.preserveFocus !== undefined) {
+		options.preserveFocus = request.options.preserveFocus
+	}
+	if (request.options?.viewColumn !== undefined) {
+		options.viewColumn = request.options.viewColumn
+	}
+
+	const editor = await vscode.window.showTextDocument(uri, options)
+
+	return TextEditorInfo.create({
+		documentPath: editor.document.uri.fsPath,
+		viewColumn: editor.viewColumn,
+		isActive: vscode.window.activeTextEditor === editor,
+	})
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/executeCommandInTerminal.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/executeCommandInTerminal.ts
new file mode 100644
index 0000000..e6b4a2b
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/executeCommandInTerminal.ts
@@ -0,0 +1,41 @@
+import { ExecuteCommandInTerminalRequest, ExecuteCommandInTerminalResponse } from "@shared/proto/host/workspace"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Executes a command in a new terminal
+ * @param request The request containing the command to execute
+ * @returns Response indicating success
+ */
+export async function executeCommandInTerminal(
+	request: ExecuteCommandInTerminalRequest,
+): Promise<ExecuteCommandInTerminalResponse> {
+	try {
+		// Create terminal with fixed options
+		const terminalOptions: vscode.TerminalOptions = {
+			name: "Cline",
+			iconPath: new vscode.ThemeIcon("cline-icon"),
+			env: {
+				CLINE_ACTIVE: "true",
+			},
+		}
+
+		// Create a new terminal
+		const terminal = vscode.window.createTerminal(terminalOptions)
+
+		// Show the terminal to the user
+		terminal.show()
+
+		// Send the command to the terminal
+		terminal.sendText(request.command, true)
+
+		return ExecuteCommandInTerminalResponse.create({
+			success: true,
+		})
+	} catch (error) {
+		Logger.error("Error executing command in terminal:", error)
+		return ExecuteCommandInTerminalResponse.create({
+			success: false,
+		})
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/getDiagnostics.test.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/getDiagnostics.test.ts
new file mode 100644
index 0000000..d0837c5
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/getDiagnostics.test.ts
@@ -0,0 +1,197 @@
+import { describe, it } from "mocha"
+import { expect } from "chai"
+import * as vscode from "vscode"
+import { DiagnosticSeverity } from "@/shared/proto/index.cline"
+import { convertToFileDiagnostics, convertVscodeDiagnostics } from "./getDiagnostics"
+
+describe("getDiagnostics conversion functions", () => {
+	describe("convertToFileDiagnostics", () => {
+		it("should return empty array when no diagnostics are provided", () => {
+			const vscodeDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = []
+
+			const result = convertToFileDiagnostics(vscodeDiagnostics)
+
+			expect(result).to.deep.equal([])
+		})
+
+		it("should skip files with empty diagnostics arrays", () => {
+			const vscodeDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = [
+				[vscode.Uri.file("/path/to/file1.ts"), []],
+				[
+					vscode.Uri.file("/path/to/file2.ts"),
+					[new vscode.Diagnostic(new vscode.Range(0, 0, 0, 10), "Error message", vscode.DiagnosticSeverity.Error)],
+				],
+			]
+
+			const result = convertToFileDiagnostics(vscodeDiagnostics)
+
+			expect(result).to.deep.equal([
+				{
+					filePath: "/path/to/file2.ts",
+					diagnostics: [
+						{
+							message: "Error message",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							source: undefined,
+						},
+					],
+				},
+			])
+		})
+
+		it("should convert multiple files with diagnostics", () => {
+			const vscodeDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = [
+				[
+					vscode.Uri.file("/path/to/file1.ts"),
+					[new vscode.Diagnostic(new vscode.Range(0, 0, 0, 10), "Error in file1", vscode.DiagnosticSeverity.Error)],
+				],
+				[
+					vscode.Uri.file("/path/to/file2.ts"),
+					[new vscode.Diagnostic(new vscode.Range(5, 5, 5, 15), "Warning in file2", vscode.DiagnosticSeverity.Warning)],
+				],
+			]
+
+			const result = convertToFileDiagnostics(vscodeDiagnostics)
+
+			expect(result).to.deep.equal([
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							message: "Error in file1",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							source: undefined,
+						},
+					],
+				},
+				{
+					filePath: "/path/to/file2.ts",
+					diagnostics: [
+						{
+							message: "Warning in file2",
+							range: {
+								start: { line: 5, character: 5 },
+								end: { line: 5, character: 15 },
+							},
+							severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+							source: undefined,
+						},
+					],
+				},
+			])
+		})
+	})
+
+	describe("convertVscodeDiagnostics", () => {
+		it("should convert empty array", () => {
+			const vscodeDiagnostics: vscode.Diagnostic[] = []
+
+			const result = convertVscodeDiagnostics(vscodeDiagnostics)
+
+			expect(result).to.deep.equal([])
+		})
+
+		it("should convert error diagnostic with source", () => {
+			const vscodeDiagnostic = new vscode.Diagnostic(
+				new vscode.Range(10, 5, 10, 20),
+				"Type error",
+				vscode.DiagnosticSeverity.Error,
+			)
+			vscodeDiagnostic.source = "typescript"
+
+			const result = convertVscodeDiagnostics([vscodeDiagnostic])
+
+			expect(result).to.deep.equal([
+				{
+					message: "Type error",
+					range: {
+						start: { line: 10, character: 5 },
+						end: { line: 10, character: 20 },
+					},
+					severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+					source: "typescript",
+				},
+			])
+		})
+
+		it("should convert all severity types correctly", () => {
+			const diagnostics = [
+				new vscode.Diagnostic(new vscode.Range(0, 0, 0, 10), "Error", vscode.DiagnosticSeverity.Error),
+				new vscode.Diagnostic(new vscode.Range(1, 0, 1, 10), "Warning", vscode.DiagnosticSeverity.Warning),
+				new vscode.Diagnostic(new vscode.Range(2, 0, 2, 10), "Information", vscode.DiagnosticSeverity.Information),
+				new vscode.Diagnostic(new vscode.Range(3, 0, 3, 10), "Hint", vscode.DiagnosticSeverity.Hint),
+			]
+
+			const result = convertVscodeDiagnostics(diagnostics)
+
+			expect(result).to.deep.equal([
+				{
+					message: "Error",
+					range: {
+						start: { line: 0, character: 0 },
+						end: { line: 0, character: 10 },
+					},
+					severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+					source: undefined,
+				},
+				{
+					message: "Warning",
+					range: {
+						start: { line: 1, character: 0 },
+						end: { line: 1, character: 10 },
+					},
+					severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+					source: undefined,
+				},
+				{
+					message: "Information",
+					range: {
+						start: { line: 2, character: 0 },
+						end: { line: 2, character: 10 },
+					},
+					severity: DiagnosticSeverity.DIAGNOSTIC_INFORMATION,
+					source: undefined,
+				},
+				{
+					message: "Hint",
+					range: {
+						start: { line: 3, character: 0 },
+						end: { line: 3, character: 10 },
+					},
+					severity: DiagnosticSeverity.DIAGNOSTIC_HINT,
+					source: undefined,
+				},
+			])
+		})
+
+		it("should handle diagnostic without source", () => {
+			const vscodeDiagnostic = new vscode.Diagnostic(
+				new vscode.Range(0, 0, 0, 10),
+				"Simple error",
+				vscode.DiagnosticSeverity.Error,
+			)
+
+			const result = convertVscodeDiagnostics([vscodeDiagnostic])
+
+			expect(result).to.deep.equal([
+				{
+					message: "Simple error",
+					range: {
+						start: { line: 0, character: 0 },
+						end: { line: 0, character: 10 },
+					},
+					severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+					source: undefined,
+				},
+			])
+		})
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/getDiagnostics.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/getDiagnostics.ts
new file mode 100644
index 0000000..b8404cc
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/getDiagnostics.ts
@@ -0,0 +1,68 @@
+import * as vscode from "vscode"
+import { GetDiagnosticsRequest, GetDiagnosticsResponse } from "@/shared/proto/host/workspace"
+import { Diagnostic, DiagnosticSeverity, FileDiagnostics } from "@/shared/proto/index.cline"
+import "@/utils/path" // for String.prototype.toPosix
+import { Logger } from "@/shared/services/Logger"
+
+export async function getDiagnostics(_request: GetDiagnosticsRequest): Promise<GetDiagnosticsResponse> {
+	// Get all diagnostics from VS Code
+	const vscodeAllDiagnostics = vscode.languages.getDiagnostics()
+
+	const fileDiagnostics = convertToFileDiagnostics(vscodeAllDiagnostics)
+
+	return { fileDiagnostics }
+}
+
+export function convertToFileDiagnostics(vscodeAllDiagnostics: [vscode.Uri, vscode.Diagnostic[]][]): FileDiagnostics[] {
+	const result = []
+	for (const [uri, diagnostics] of vscodeAllDiagnostics) {
+		if (diagnostics.length > 0) {
+			result.push(
+				FileDiagnostics.create({
+					filePath: uri.fsPath.toPosix(),
+					diagnostics: convertVscodeDiagnostics(diagnostics),
+				}),
+			)
+		}
+	}
+	return result
+}
+
+export function convertVscodeDiagnostics(vscodeDiagnostics: vscode.Diagnostic[]): Diagnostic[] {
+	return vscodeDiagnostics.map(convertVscodeDiagnostic)
+}
+
+function convertVscodeDiagnostic(vscodeDiagnostic: vscode.Diagnostic): Diagnostic {
+	return {
+		message: vscodeDiagnostic.message,
+		range: {
+			start: {
+				line: vscodeDiagnostic.range.start.line,
+				character: vscodeDiagnostic.range.start.character,
+			},
+			end: {
+				line: vscodeDiagnostic.range.end.line,
+				character: vscodeDiagnostic.range.end.character,
+			},
+		},
+		severity: convertSeverity(vscodeDiagnostic.severity),
+		source: vscodeDiagnostic.source,
+	}
+}
+
+// Convert VS Code severity to proto severity
+function convertSeverity(vscodeSeverity: vscode.DiagnosticSeverity): DiagnosticSeverity {
+	switch (vscodeSeverity) {
+		case vscode.DiagnosticSeverity.Error:
+			return DiagnosticSeverity.DIAGNOSTIC_ERROR
+		case vscode.DiagnosticSeverity.Warning:
+			return DiagnosticSeverity.DIAGNOSTIC_WARNING
+		case vscode.DiagnosticSeverity.Information:
+			return DiagnosticSeverity.DIAGNOSTIC_INFORMATION
+		case vscode.DiagnosticSeverity.Hint:
+			return DiagnosticSeverity.DIAGNOSTIC_HINT
+		default:
+			Logger.warn("Unhandled vscode severity", vscodeSeverity)
+			return DiagnosticSeverity.DIAGNOSTIC_ERROR
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/getWorkspacePaths.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/getWorkspacePaths.ts
new file mode 100644
index 0000000..6cbe1c8
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/getWorkspacePaths.ts
@@ -0,0 +1,6 @@
+import * as vscode from "vscode"
+import { GetWorkspacePathsRequest, GetWorkspacePathsResponse } from "@/shared/proto/index.host"
+export async function getWorkspacePaths(_: GetWorkspacePathsRequest): Promise<GetWorkspacePathsResponse> {
+	const paths = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath) ?? []
+	return GetWorkspacePathsResponse.create({ paths: paths })
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/openClineSidebarPanel.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openClineSidebarPanel.ts
new file mode 100644
index 0000000..cc804c7
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openClineSidebarPanel.ts
@@ -0,0 +1,8 @@
+import * as vscode from "vscode"
+import { ExtensionRegistryInfo } from "@/registry"
+import { OpenClineSidebarPanelRequest, OpenClineSidebarPanelResponse } from "@/shared/proto/index.host"
+
+export async function openClineSidebarPanel(_: OpenClineSidebarPanelRequest): Promise<OpenClineSidebarPanelResponse> {
+	await vscode.commands.executeCommand(`${ExtensionRegistryInfo.views.Sidebar}.focus`)
+	return {}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/openFolder.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openFolder.ts
new file mode 100644
index 0000000..53eb85b
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openFolder.ts
@@ -0,0 +1,14 @@
+import * as vscode from "vscode"
+import { OpenFolderRequest, OpenFolderResponse } from "@/shared/proto/host/workspace"
+import { Logger } from "@/shared/services/Logger"
+
+export async function openFolder(request: OpenFolderRequest): Promise<OpenFolderResponse> {
+	try {
+		const uri = vscode.Uri.file(request.path)
+		await vscode.commands.executeCommand("vscode.openFolder", uri, { forceNewWindow: request.newWindow })
+		return OpenFolderResponse.create({ success: true })
+	} catch (error) {
+		Logger.error("Failed to open folder:", error)
+		return OpenFolderResponse.create({ success: false })
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/openInFileExplorerPanel.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openInFileExplorerPanel.ts
new file mode 100644
index 0000000..c006488
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openInFileExplorerPanel.ts
@@ -0,0 +1,8 @@
+import * as vscode from "vscode"
+
+import { OpenInFileExplorerPanelRequest, OpenInFileExplorerPanelResponse } from "@/shared/proto/index.host"
+
+export async function openInFileExplorerPanel(request: OpenInFileExplorerPanelRequest): Promise<OpenInFileExplorerPanelResponse> {
+	vscode.commands.executeCommand("revealInExplorer", vscode.Uri.file(request.path || ""))
+	return {}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/openProblemsPanel.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openProblemsPanel.ts
new file mode 100644
index 0000000..ac718f5
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openProblemsPanel.ts
@@ -0,0 +1,7 @@
+import * as vscode from "vscode"
+import { OpenProblemsPanelRequest, OpenProblemsPanelResponse } from "@/shared/proto/index.host"
+
+export async function openProblemsPanel(_: OpenProblemsPanelRequest): Promise<OpenProblemsPanelResponse> {
+	vscode.commands.executeCommand("workbench.actions.view.problems")
+	return {}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/openTerminalPanel.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openTerminalPanel.ts
new file mode 100644
index 0000000..dd008c3
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/openTerminalPanel.ts
@@ -0,0 +1,7 @@
+import * as vscode from "vscode"
+import { OpenTerminalRequest, OpenTerminalResponse } from "@/shared/proto/index.host"
+
+export async function openTerminalPanel(_: OpenTerminalRequest): Promise<OpenTerminalResponse> {
+	vscode.commands.executeCommand("workbench.action.terminal.focus")
+	return {}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty.test.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty.test.ts
new file mode 100644
index 0000000..14fdc4f
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty.test.ts
@@ -0,0 +1,187 @@
+import { after, before, beforeEach, describe, it } from "mocha"
+import { expect } from "chai"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import * as vscode from "vscode"
+import { saveOpenDocumentIfDirty } from "@/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty"
+import { SaveOpenDocumentIfDirtyRequest } from "@/shared/proto/index.host"
+
+describe("saveOpenDocumentIfDirty Integration Test", () => {
+	let testWorkspaceRoot: string
+	let testFilePath: string
+	let testFileUri: vscode.Uri
+
+	before(async () => {
+		// Use a temporary directory for tests
+		testWorkspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "cline-test-"))
+
+		// Create a test file path
+		testFilePath = path.join(testWorkspaceRoot, "test-save-document.txt")
+		testFileUri = vscode.Uri.file(testFilePath)
+	})
+
+	after(async () => {
+		// Clean up: close all editors and delete test directory
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+		try {
+			await fs.rm(testWorkspaceRoot, { recursive: true, force: true })
+		} catch (_error) {
+			// Directory might not exist, ignore
+		}
+	})
+
+	beforeEach(async () => {
+		// Close all editors before each test
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+	})
+
+	it("should save a dirty document and return wasSaved: true", async () => {
+		// Create a test file with initial content
+		await fs.writeFile(testFilePath, "Initial content")
+
+		// Open the document in VSCode
+		const document = await vscode.workspace.openTextDocument(testFileUri)
+		const editor = await vscode.window.showTextDocument(document)
+
+		// Make the document dirty by editing it
+		await editor.edit((editBuilder) => {
+			editBuilder.insert(new vscode.Position(0, 0), "Modified ")
+		})
+
+		// Verify the document is dirty
+		expect(document.isDirty).to.be.true
+
+		// Call saveOpenDocumentIfDirty
+		const request = SaveOpenDocumentIfDirtyRequest.create({
+			filePath: testFilePath,
+		})
+		const response = await saveOpenDocumentIfDirty(request)
+
+		// Verify the response
+		expect(response.wasSaved).to.be.true
+
+		// Verify the document is no longer dirty
+		expect(document.isDirty).to.be.false
+
+		// Verify the file content was saved
+		const savedContent = await fs.readFile(testFilePath, "utf-8")
+		expect(savedContent).to.equal("Modified Initial content")
+	})
+
+	it("should not save a clean document and return empty response", async () => {
+		// Create a test file
+		await fs.writeFile(testFilePath, "Clean content")
+
+		// Open the document in VSCode
+		const document = await vscode.workspace.openTextDocument(testFileUri)
+		await vscode.window.showTextDocument(document)
+
+		// Verify the document is not dirty
+		expect(document.isDirty).to.be.false
+
+		// Call saveOpenDocumentIfDirty
+		const request = SaveOpenDocumentIfDirtyRequest.create({
+			filePath: testFilePath,
+		})
+		const response = await saveOpenDocumentIfDirty(request)
+
+		// Verify the response
+		expect(response.wasSaved).to.be.undefined
+
+		// Verify the document is still not dirty
+		expect(document.isDirty).to.be.false
+	})
+
+	it("should return empty response when document is not open", async () => {
+		// Ensure no documents are open
+		await vscode.commands.executeCommand("workbench.action.closeAllEditors")
+
+		// Call saveOpenDocumentIfDirty with a non-existent file
+		const request = SaveOpenDocumentIfDirtyRequest.create({
+			filePath: path.join(testWorkspaceRoot, "non-existent-file.txt"),
+		})
+		const response = await saveOpenDocumentIfDirty(request)
+
+		// Verify the response
+		expect(response.wasSaved).to.be.undefined
+	})
+
+	it("should handle multiple open documents and save only the specified one", async () => {
+		// Create multiple test files
+		const testFile1 = path.join(testWorkspaceRoot, "test-file-1.txt")
+		const testFile2 = path.join(testWorkspaceRoot, "test-file-2.txt")
+		const testFile3 = path.join(testWorkspaceRoot, "test-file-3.txt")
+
+		await fs.writeFile(testFile1, "File 1 content")
+		await fs.writeFile(testFile2, "File 2 content")
+		await fs.writeFile(testFile3, "File 3 content")
+
+		try {
+			// Open all documents
+			const doc1 = await vscode.workspace.openTextDocument(vscode.Uri.file(testFile1))
+			const doc2 = await vscode.workspace.openTextDocument(vscode.Uri.file(testFile2))
+			const doc3 = await vscode.workspace.openTextDocument(vscode.Uri.file(testFile3))
+
+			// Edit all documents to make them dirty
+			const editor1 = await vscode.window.showTextDocument(doc1)
+			await editor1.edit((editBuilder) => {
+				editBuilder.insert(new vscode.Position(0, 0), "Modified ")
+			})
+
+			const editor2 = await vscode.window.showTextDocument(doc2)
+			await editor2.edit((editBuilder) => {
+				editBuilder.insert(new vscode.Position(0, 0), "Modified ")
+			})
+
+			const editor3 = await vscode.window.showTextDocument(doc3)
+			await editor3.edit((editBuilder) => {
+				editBuilder.insert(new vscode.Position(0, 0), "Modified ")
+			})
+
+			// Verify all documents are dirty
+			expect(doc1.isDirty).to.be.true
+			expect(doc2.isDirty).to.be.true
+			expect(doc3.isDirty).to.be.true
+
+			// Save only the second document
+			const request = SaveOpenDocumentIfDirtyRequest.create({
+				filePath: testFile2,
+			})
+			const response = await saveOpenDocumentIfDirty(request)
+
+			// Verify the response
+			expect(response.wasSaved).to.be.true
+
+			// Verify only doc2 was saved
+			expect(doc1.isDirty).to.be.true
+			expect(doc2.isDirty).to.be.false
+			expect(doc3.isDirty).to.be.true
+
+			// Verify the file content
+			const savedContent = await fs.readFile(testFile2, "utf-8")
+			expect(savedContent).to.equal("Modified File 2 content")
+		} finally {
+			// Clean up
+			await fs.unlink(testFile1).catch(() => {})
+			await fs.unlink(testFile2).catch(() => {})
+			await fs.unlink(testFile3).catch(() => {})
+		}
+	})
+
+	it("should handle empty file path gracefully", async () => {
+		const request = SaveOpenDocumentIfDirtyRequest.create({
+			filePath: "",
+		})
+		const response = await saveOpenDocumentIfDirty(request)
+
+		expect(response.wasSaved).to.be.undefined
+	})
+
+	it("should handle undefined file path gracefully", async () => {
+		const request = SaveOpenDocumentIfDirtyRequest.create({})
+		const response = await saveOpenDocumentIfDirty(request)
+
+		expect(response.wasSaved).to.be.undefined
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty.ts
new file mode 100644
index 0000000..1cc92a6
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/saveOpenDocumentIfDirty.ts
@@ -0,0 +1,12 @@
+import { arePathsEqual } from "@utils/path"
+import * as vscode from "vscode"
+import { SaveOpenDocumentIfDirtyRequest, SaveOpenDocumentIfDirtyResponse } from "@/shared/proto/index.host"
+
+export async function saveOpenDocumentIfDirty(request: SaveOpenDocumentIfDirtyRequest): Promise<SaveOpenDocumentIfDirtyResponse> {
+	const existingDocument = vscode.workspace.textDocuments.find((doc) => arePathsEqual(doc.uri.fsPath, request.filePath))
+	if (existingDocument && existingDocument.isDirty) {
+		await existingDocument.save()
+		return { wasSaved: true }
+	}
+	return {}
+}
diff --git a/apps/vscode/src/hosts/vscode/hostbridge/workspace/searchWorkspaceItems.ts b/apps/vscode/src/hosts/vscode/hostbridge/workspace/searchWorkspaceItems.ts
new file mode 100644
index 0000000..6735777
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/hostbridge/workspace/searchWorkspaceItems.ts
@@ -0,0 +1,5 @@
+import { SearchWorkspaceItemsRequest, SearchWorkspaceItemsResponse } from "@/shared/proto/host/workspace"
+
+export async function searchWorkspaceItems(_request: SearchWorkspaceItemsRequest): Promise<SearchWorkspaceItemsResponse> {
+	throw new Error("searchWorkspaceItems is not implemented on the VS Code host")
+}
diff --git a/apps/vscode/src/hosts/vscode/mcp-settings-legacy-migration.ts b/apps/vscode/src/hosts/vscode/mcp-settings-legacy-migration.ts
new file mode 100644
index 0000000..f66ff0d
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/mcp-settings-legacy-migration.ts
@@ -0,0 +1,378 @@
+import { existsSync, readFileSync } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { getDocumentsPath } from "@/core/storage/documents-path"
+import type * as vscode from "vscode"
+import { updateMcpSettingsFile } from "@/services/mcp/settingsLock"
+import type { StorageContext } from "@/shared/storage/storage-context"
+import { Logger } from "@/shared/services/Logger"
+import { getServerAuthHash } from "@/utils/mcpAuth"
+import { arePathsEqual } from "@/utils/path"
+
+const MCP_SETTINGS_FILE_NAME = "cline_mcp_settings.json"
+const MCP_SETTINGS_MIGRATION_KEY = "__vscodeLegacyMcpSettingsMigration"
+
+type JsonRecord = Record<string, unknown>
+
+export interface LegacyMcpSettingsMigrationResult {
+	migrated: boolean
+	sourcesChecked: number
+	sourcesMigrated: number
+	serversAdded: number
+	serversSkippedExisting: number
+	serversSkippedInvalid: number
+}
+
+interface LegacyMcpSource {
+	id: string
+	path: string
+}
+
+interface PreparedLegacyMcpSource {
+	source: LegacyMcpSource
+	servers: Record<string, JsonRecord>
+	skippedInvalid: number
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function readJsonRecord(filePath: string): JsonRecord | undefined {
+	try {
+		if (!existsSync(filePath)) {
+			return undefined
+		}
+		const parsed = JSON.parse(readFileSync(filePath, "utf8")) as unknown
+		return isRecord(parsed) ? parsed : undefined
+	} catch (error) {
+		Logger.warn(`[Migration] Failed to read legacy MCP settings from ${filePath}:`, error)
+		return undefined
+	}
+}
+
+function getServers(settings: JsonRecord | undefined): JsonRecord {
+	const servers = settings?.mcpServers
+	return isRecord(servers) ? servers : {}
+}
+
+function mapLegacyTransportType(value: unknown): "stdio" | "sse" | "streamableHttp" | undefined {
+	if (value === "stdio" || value === "sse" || value === "streamableHttp") {
+		return value
+	}
+	if (value === "http") {
+		return "streamableHttp"
+	}
+	return undefined
+}
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) {
+		return undefined
+	}
+	const strings = value.filter((item): item is string => typeof item === "string")
+	return strings.length === value.length ? strings : undefined
+}
+
+function normalizeStringRecord(value: unknown): Record<string, string> | undefined {
+	if (!isRecord(value)) {
+		return undefined
+	}
+	const entries = Object.entries(value)
+	if (!entries.every(([, entryValue]) => typeof entryValue === "string")) {
+		return undefined
+	}
+	return Object.fromEntries(entries) as Record<string, string>
+}
+
+function compactRecord(record: JsonRecord): JsonRecord {
+	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined))
+}
+
+function normalizeOauthState(value: unknown): JsonRecord | undefined {
+	if (!isRecord(value)) {
+		return undefined
+	}
+	const normalized = compactRecord({
+		clientInformation: isRecord(value.clientInformation) ? value.clientInformation : undefined,
+		tokens: isRecord(value.tokens) ? value.tokens : undefined,
+		codeVerifier: typeof value.codeVerifier === "string" ? value.codeVerifier : undefined,
+		discoveryState: isRecord(value.discoveryState) ? value.discoveryState : undefined,
+		redirectUrl: typeof value.redirectUrl === "string" ? value.redirectUrl : undefined,
+		lastError: typeof value.lastError === "string" ? value.lastError : undefined,
+		lastAuthenticatedAt: typeof value.lastAuthenticatedAt === "number" ? value.lastAuthenticatedAt : undefined,
+	})
+	return Object.keys(normalized).length > 0 ? normalized : undefined
+}
+
+function normalizeLegacyOAuthSecret(value: unknown): JsonRecord | undefined {
+	if (!isRecord(value)) {
+		return undefined
+	}
+	const normalized = compactRecord({
+		clientInformation: isRecord(value.client_info) ? value.client_info : undefined,
+		tokens: isRecord(value.tokens) ? value.tokens : undefined,
+		codeVerifier: typeof value.code_verifier === "string" ? value.code_verifier : undefined,
+		redirectUrl: typeof value.redirect_url_at_registration === "string" ? value.redirect_url_at_registration : undefined,
+		lastAuthenticatedAt: typeof value.tokens_saved_at === "number" ? value.tokens_saved_at : undefined,
+	})
+	return Object.keys(normalized).length > 0 ? normalized : undefined
+}
+
+function getUrlForAuthHash(registration: JsonRecord): string | undefined {
+	const transport = isRecord(registration.transport) ? registration.transport : registration
+	return typeof transport.url === "string" ? transport.url : undefined
+}
+
+export function normalizeLegacyMcpServer(
+	value: unknown,
+	legacyOAuthSecrets: JsonRecord | undefined,
+	serverName: string,
+): JsonRecord | undefined {
+	if (!isRecord(value)) {
+		return undefined
+	}
+
+	const source = isRecord(value.transport) ? { ...value.transport, ...value } : { ...value }
+	delete source.transport
+
+	const explicitType = mapLegacyTransportType(source.type)
+	const transportType = mapLegacyTransportType(source.transportType)
+	const resolvedType = explicitType ?? transportType ?? (typeof source.command === "string" ? "stdio" : undefined)
+
+	let transport: JsonRecord | undefined
+	if (resolvedType === "stdio" && typeof source.command === "string" && source.command.trim()) {
+		transport = compactRecord({
+			type: "stdio",
+			command: source.command,
+			args: normalizeStringArray(source.args),
+			cwd: typeof source.cwd === "string" && source.cwd.trim() ? source.cwd : undefined,
+			env: normalizeStringRecord(source.env),
+		})
+	} else {
+		const urlType = resolvedType ?? "sse"
+		if ((urlType === "sse" || urlType === "streamableHttp") && typeof source.url === "string") {
+			transport = compactRecord({
+				type: urlType,
+				url: source.url,
+				headers: normalizeStringRecord(source.headers),
+			})
+		}
+	}
+
+	if (!transport) {
+		return undefined
+	}
+
+	const normalized: JsonRecord = compactRecord({
+		transport,
+		disabled: typeof source.disabled === "boolean" ? source.disabled : undefined,
+		metadata: isRecord(source.metadata) ? source.metadata : undefined,
+	})
+
+	const autoApprove = normalizeStringArray(source.autoApprove)
+	if (autoApprove) {
+		normalized.autoApprove = autoApprove
+	}
+	if (typeof source.timeout === "number") {
+		normalized.timeout = source.timeout
+	}
+	if (typeof source.remoteConfigured === "boolean") {
+		normalized.remoteConfigured = source.remoteConfigured
+	}
+	// Remote-config sync historically keys URL-based remote servers by a top-level
+	// `url`. Keep that compatibility field on migrated remote-configured servers
+	// so the next sync does not delete/recreate them and lose user state.
+	if (source.remoteConfigured === true && typeof transport.url === "string") {
+		normalized.url = transport.url
+	}
+
+	const inlineOAuth = normalizeOauthState(source.oauth)
+	const serverUrl = getUrlForAuthHash(normalized)
+	const legacyOAuth =
+		serverUrl && legacyOAuthSecrets
+			? normalizeLegacyOAuthSecret(legacyOAuthSecrets[getServerAuthHash(serverName, serverUrl)])
+			: undefined
+	const oauth = inlineOAuth ?? legacyOAuth
+	if (oauth) {
+		normalized.oauth = oauth
+	}
+
+	return normalized
+}
+
+function parseLegacyOAuthSecrets(raw: string | undefined): JsonRecord | undefined {
+	if (!raw) {
+		return undefined
+	}
+	try {
+		const parsed = JSON.parse(raw) as unknown
+		return isRecord(parsed) ? parsed : undefined
+	} catch (error) {
+		Logger.warn("[Migration] Failed to parse legacy MCP OAuth secrets:", error)
+		return undefined
+	}
+}
+
+async function readLegacyOAuthSecrets(
+	vscodeContext: vscode.ExtensionContext,
+	storage: StorageContext,
+): Promise<JsonRecord | undefined> {
+	let vscodeSecrets: JsonRecord | undefined
+	try {
+		vscodeSecrets = parseLegacyOAuthSecrets(await vscodeContext.secrets.get("mcpOAuthSecrets"))
+	} catch (error) {
+		Logger.warn("[Migration] Failed to read legacy MCP OAuth secrets from VSCode storage:", error)
+	}
+	const fileBackedSecrets = parseLegacyOAuthSecrets(storage.secrets.get("mcpOAuthSecrets"))
+	if (!vscodeSecrets) {
+		return fileBackedSecrets
+	}
+	if (!fileBackedSecrets) {
+		return vscodeSecrets
+	}
+	return { ...vscodeSecrets, ...fileBackedSecrets }
+}
+
+export async function getLegacyMcpSettingsSources(vscodeContext: vscode.ExtensionContext): Promise<LegacyMcpSource[]> {
+	const sources: LegacyMcpSource[] = []
+	const extensionStorageDir = vscodeContext.globalStorageUri?.fsPath
+	if (extensionStorageDir) {
+		sources.push({
+			id: "vscodeGlobalStorage",
+			path: path.join(extensionStorageDir, "settings", MCP_SETTINGS_FILE_NAME),
+		})
+	}
+	const documentsDir = await getDocumentsPath()
+	sources.push({
+		id: "documentsClineMcp",
+		path: path.join(documentsDir, "Cline", "MCP", MCP_SETTINGS_FILE_NAME),
+	})
+	return sources
+}
+
+export function getSharedMcpSettingsPath(storage: StorageContext): string {
+	const explicitPath = process.env.CLINE_MCP_SETTINGS_PATH?.trim()
+	if (explicitPath) {
+		return explicitPath
+	}
+	const explicitDataDir = process.env.CLINE_DATA_DIR?.trim()
+	if (explicitDataDir) {
+		return path.join(explicitDataDir, "settings", MCP_SETTINGS_FILE_NAME)
+	}
+	const clineDir = process.env.CLINE_DIR?.trim() || path.join(os.homedir(), ".cline")
+	return path.join(clineDir, "data", "settings", MCP_SETTINGS_FILE_NAME)
+}
+
+function readMigrationState(storage: StorageContext): JsonRecord {
+	const value = storage.globalState.get(MCP_SETTINGS_MIGRATION_KEY)
+	return isRecord(value) ? value : {}
+}
+
+function writeMigrationState(storage: StorageContext, state: JsonRecord): void {
+	storage.globalState.update(MCP_SETTINGS_MIGRATION_KEY, state)
+}
+
+function prepareLegacySource(
+	source: LegacyMcpSource,
+	legacyOAuthSecrets: JsonRecord | undefined,
+): PreparedLegacyMcpSource | undefined {
+	if (!existsSync(source.path)) {
+		return undefined
+	}
+	const legacySettings = readJsonRecord(source.path)
+	if (!legacySettings) {
+		return undefined
+	}
+	const servers: Record<string, JsonRecord> = {}
+	let skippedInvalid = 0
+	for (const [serverName, serverValue] of Object.entries(getServers(legacySettings))) {
+		const normalized = normalizeLegacyMcpServer(serverValue, legacyOAuthSecrets, serverName)
+		if (!normalized) {
+			skippedInvalid++
+			continue
+		}
+		servers[serverName] = normalized
+	}
+	return { source, servers, skippedInvalid }
+}
+
+export async function migrateLegacyMcpSettings(
+	vscodeContext: vscode.ExtensionContext,
+	storage: StorageContext,
+): Promise<LegacyMcpSettingsMigrationResult> {
+	const result: LegacyMcpSettingsMigrationResult = {
+		migrated: false,
+		sourcesChecked: 0,
+		sourcesMigrated: 0,
+		serversAdded: 0,
+		serversSkippedExisting: 0,
+		serversSkippedInvalid: 0,
+	}
+
+	const migrationState = readMigrationState(storage)
+	const migratedSources = isRecord(migrationState.sources) ? migrationState.sources : {}
+	const sharedSettingsPath = getSharedMcpSettingsPath(storage)
+	const legacyOAuthSecrets = await readLegacyOAuthSecrets(vscodeContext, storage)
+	const preparedSources: PreparedLegacyMcpSource[] = []
+
+	for (const source of await getLegacyMcpSettingsSources(vscodeContext)) {
+		result.sourcesChecked++
+		if (migratedSources[source.id] || arePathsEqual(source.path, sharedSettingsPath)) {
+			continue
+		}
+		const prepared = prepareLegacySource(source, legacyOAuthSecrets)
+		if (!prepared) {
+			continue
+		}
+		preparedSources.push(prepared)
+		result.serversSkippedInvalid += prepared.skippedInvalid
+	}
+
+	if (preparedSources.length > 0) {
+		const mergeResult = await updateMcpSettingsFile(sharedSettingsPath, (settings) => {
+			const existingServersValue = settings.mcpServers
+			const servers = isRecord(existingServersValue) ? { ...existingServersValue } : {}
+			let serversAdded = 0
+			let serversSkippedExisting = 0
+			let sourcesMigrated = 0
+
+			for (const prepared of preparedSources) {
+				let sourceAdded = 0
+				for (const [serverName, serverConfig] of Object.entries(prepared.servers)) {
+					if (Object.hasOwn(servers, serverName)) {
+						serversSkippedExisting++
+						continue
+					}
+					servers[serverName] = serverConfig
+					serversAdded++
+					sourceAdded++
+				}
+				if (sourceAdded > 0) {
+					sourcesMigrated++
+				}
+			}
+
+			settings.mcpServers = servers
+			return { serversAdded, serversSkippedExisting, sourcesMigrated }
+		})
+
+		result.serversAdded += mergeResult.serversAdded
+		result.serversSkippedExisting += mergeResult.serversSkippedExisting
+		result.sourcesMigrated += mergeResult.sourcesMigrated
+
+		for (const prepared of preparedSources) {
+			migratedSources[prepared.source.id] = {
+				path: prepared.source.path,
+				migratedAt: Date.now(),
+			}
+		}
+		result.migrated = true
+	}
+
+	if (result.migrated) {
+		writeMigrationState(storage, { sources: migratedSources })
+	}
+
+	return result
+}
diff --git a/apps/vscode/src/hosts/vscode/review/VscodeCommentReviewController.ts b/apps/vscode/src/hosts/vscode/review/VscodeCommentReviewController.ts
new file mode 100644
index 0000000..61b844a
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/review/VscodeCommentReviewController.ts
@@ -0,0 +1,308 @@
+import * as vscode from "vscode"
+import { CommentReviewController, type ReviewComment } from "@/integrations/editor/CommentReviewController"
+import { Logger } from "@/shared/services/Logger"
+import { DIFF_VIEW_URI_SCHEME } from "../VscodeDiffViewProvider"
+
+/**
+ * Cline's GitHub avatar URL
+ */
+const CLINE_AVATAR_URL = "https://avatars.githubusercontent.com/u/184127137"
+
+/**
+ * VS Code implementation of CommentReviewController.
+ *
+ * Uses VS Code's Comment API to create inline comment threads on files.
+ * Comments appear in VS Code's Comments Panel and inline in editors.
+ */
+export class VscodeCommentReviewController extends CommentReviewController implements vscode.Disposable {
+	private commentController: vscode.CommentController
+	private threads: Map<string, vscode.CommentThread> = new Map()
+
+	/** The currently streaming comment thread */
+	private streamingThread: vscode.CommentThread | null = null
+	private streamingContent = ""
+
+	constructor() {
+		super()
+		// Create the comment controller
+		this.commentController = vscode.comments.createCommentController("cline-ai-review", "Cline AI Review")
+	}
+
+	/**
+	 * Ensure the comments.openView setting is set to "never" to prevent
+	 * the Comments panel from auto-opening when comments are added.
+	 */
+	async ensureCommentsViewDisabled(): Promise<void> {
+		const config = vscode.workspace.getConfiguration("comments")
+		const currentValue = config.get<string>("openView")
+		if (currentValue !== "never") {
+			await config.update("openView", "never", vscode.ConfigurationTarget.Global)
+		}
+	}
+
+	/**
+	 * Add a review comment to a file
+	 */
+	addReviewComment(comment: ReviewComment): void {
+		// Use virtual diff URI if relativePath and fileContent are provided
+		// This allows comments to attach to the diff view's virtual documents
+		let uri: vscode.Uri
+		if (comment.relativePath && comment.fileContent !== undefined) {
+			uri = vscode.Uri.parse(`${DIFF_VIEW_URI_SCHEME}:${comment.relativePath}`).with({
+				query: Buffer.from(comment.fileContent).toString("base64"),
+			})
+		} else {
+			uri = vscode.Uri.file(comment.filePath)
+		}
+		const range = new vscode.Range(
+			new vscode.Position(comment.startLine, 0),
+			new vscode.Position(comment.endLine, Number.MAX_SAFE_INTEGER),
+		)
+
+		// Create the comment object
+		const commentObj: vscode.Comment = {
+			body: new vscode.MarkdownString(comment.comment),
+			mode: vscode.CommentMode.Preview,
+			author: {
+				name: "Cline",
+				iconPath: vscode.Uri.parse(CLINE_AVATAR_URL),
+			},
+		}
+
+		// Create the thread
+		const thread = this.commentController.createCommentThread(uri, range, [commentObj])
+
+		// Configure thread
+		thread.canReply = false
+		thread.collapsibleState = vscode.CommentThreadCollapsibleState.Expanded
+
+		// Store for later management
+		const threadKey = this.getThreadKey(comment.filePath, comment.startLine, comment.endLine)
+		this.threads.set(threadKey, thread)
+	}
+
+	/**
+	 * Start a streaming review comment - creates the thread immediately with placeholder text
+	 * @param revealComment - If true, opens the document and scrolls to show the comment (default: false)
+	 */
+	startStreamingComment(
+		filePath: string,
+		startLine: number,
+		endLine: number,
+		relativePath?: string,
+		fileContent?: string,
+		revealComment = false,
+	): void {
+		// Use virtual diff URI if relativePath and fileContent are provided
+		let uri: vscode.Uri
+		if (relativePath && fileContent !== undefined) {
+			uri = vscode.Uri.parse(`${DIFF_VIEW_URI_SCHEME}:${relativePath}`).with({
+				query: Buffer.from(fileContent).toString("base64"),
+			})
+		} else {
+			uri = vscode.Uri.file(filePath)
+		}
+		const range = new vscode.Range(new vscode.Position(startLine, 0), new vscode.Position(endLine, Number.MAX_SAFE_INTEGER))
+
+		// Create with placeholder
+		const commentObj: vscode.Comment = {
+			body: new vscode.MarkdownString("_Thinking..._"),
+			mode: vscode.CommentMode.Preview,
+			author: {
+				name: "Cline",
+				iconPath: vscode.Uri.parse(CLINE_AVATAR_URL),
+			},
+		}
+
+		// Create the thread
+		const thread = this.commentController.createCommentThread(uri, range, [commentObj])
+		thread.canReply = false
+		thread.collapsibleState = vscode.CommentThreadCollapsibleState.Expanded
+
+		// Store for streaming updates
+		this.streamingThread = thread
+		this.streamingContent = ""
+
+		// Store for later management
+		const threadKey = this.getThreadKey(filePath, startLine, endLine)
+		this.threads.set(threadKey, thread)
+
+		// Open the virtual document and scroll to show the comment in center (only if requested)
+		if (revealComment) {
+			this.revealCommentInDocument(thread)
+		}
+	}
+
+	/**
+	 * Open the document containing the comment and scroll to show it in center.
+	 * This is used during streaming to show each comment as it's added.
+	 */
+	private async revealCommentInDocument(thread: vscode.CommentThread): Promise<void> {
+		try {
+			// Open the document (works with virtual URIs)
+			const doc = await vscode.workspace.openTextDocument(thread.uri)
+
+			// Show the document and scroll to the comment
+			// Use the start of the range so the comment appears in center (not the code block)
+			const commentPosition = new vscode.Range(thread.range.start, thread.range.start)
+			const editor = await vscode.window.showTextDocument(doc, {
+				selection: commentPosition,
+				preserveFocus: false,
+				preview: true,
+			})
+
+			// Reveal with the start position in center so the comment bubble is visible
+			editor.revealRange(commentPosition, vscode.TextEditorRevealType.InCenter)
+		} catch (error) {
+			// Ignore errors - this is not critical
+			Logger.error("[VscodeCommentReviewController] Error revealing comment:", error)
+		}
+	}
+
+	/**
+	 * Append text to the currently streaming comment
+	 */
+	appendToStreamingComment(chunk: string): void {
+		if (!this.streamingThread) {
+			return
+		}
+
+		this.streamingContent += chunk
+
+		// Update the comment body - reassigning comments triggers VS Code to refresh the UI
+		const commentObj: vscode.Comment = {
+			body: new vscode.MarkdownString(this.streamingContent || "_Thinking..._"),
+			mode: vscode.CommentMode.Preview,
+			author: {
+				name: "Cline",
+				iconPath: vscode.Uri.parse(CLINE_AVATAR_URL),
+			},
+		}
+		// Create a new array to ensure VS Code detects the change
+		this.streamingThread.comments = [...[commentObj]]
+	}
+
+	/**
+	 * End the current streaming comment
+	 */
+	endStreamingComment(): void {
+		if (!this.streamingThread) {
+			return
+		}
+
+		// Finalize with trimmed content
+		const finalContent = this.streamingContent.trim() || "_No comment generated_"
+		const commentObj: vscode.Comment = {
+			body: new vscode.MarkdownString(finalContent),
+			mode: vscode.CommentMode.Preview,
+			author: {
+				name: "Cline",
+				iconPath: vscode.Uri.parse(CLINE_AVATAR_URL),
+			},
+		}
+		this.streamingThread.comments = [commentObj]
+
+		// Clear streaming state
+		this.streamingThread = null
+		this.streamingContent = ""
+	}
+
+	/**
+	 * Add multiple review comments at once
+	 */
+	addReviewComments(comments: ReviewComment[]): void {
+		comments.forEach((comment) => this.addReviewComment(comment))
+	}
+
+	/**
+	 * Clear all review comments
+	 */
+	clearAllComments(): void {
+		for (const thread of this.threads.values()) {
+			thread.dispose()
+		}
+		this.threads.clear()
+	}
+
+	/**
+	 * Clear comments for a specific file
+	 */
+	clearCommentsForFile(filePath: string): void {
+		const keysToRemove: string[] = []
+		for (const [key, thread] of this.threads.entries()) {
+			if (key.startsWith(filePath + ":")) {
+				thread.dispose()
+				keysToRemove.push(key)
+			}
+		}
+		for (const key of keysToRemove) {
+			this.threads.delete(key)
+		}
+	}
+
+	/**
+	 * Get the number of active comment threads
+	 */
+	getThreadCount(): number {
+		return this.threads.size
+	}
+
+	private getThreadKey(filePath: string, startLine: number, endLine: number): string {
+		return `${filePath}:${startLine}:${endLine}`
+	}
+
+	/**
+	 * Close all tabs that use the cline-diff URI scheme (both diff views and regular text documents)
+	 */
+	async closeDiffViews(): Promise<void> {
+		const tabs = vscode.window.tabGroups.all
+			.flatMap((tg) => tg.tabs)
+			.filter((tab) => {
+				// Check for diff view tabs
+				if (tab.input instanceof vscode.TabInputTextDiff && tab.input?.original?.scheme === DIFF_VIEW_URI_SCHEME) {
+					return true
+				}
+				// Check for regular text document tabs with cline-diff scheme (opened during comment reveal)
+				if (tab.input instanceof vscode.TabInputText && tab.input?.uri?.scheme === DIFF_VIEW_URI_SCHEME) {
+					return true
+				}
+				return false
+			})
+		for (const tab of tabs) {
+			try {
+				await vscode.window.tabGroups.close(tab)
+			} catch (error) {
+				// Tab might already be closed
+				Logger.warn("Failed to close diff tab:", error)
+			}
+		}
+	}
+
+	dispose(): void {
+		this.clearAllComments()
+		this.commentController.dispose()
+	}
+}
+
+// Singleton instance for the extension
+let instance: VscodeCommentReviewController | undefined
+
+/**
+ * Get or create the VscodeCommentReviewController singleton
+ */
+export function getVscodeCommentReviewController(): VscodeCommentReviewController {
+	if (!instance) {
+		instance = new VscodeCommentReviewController()
+	}
+	return instance
+}
+
+/**
+ * Dispose the VscodeCommentReviewController singleton
+ */
+export function disposeVscodeCommentReviewController(): void {
+	if (instance) {
+		instance.dispose()
+		instance = undefined
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalManager.test.ts b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalManager.test.ts
new file mode 100644
index 0000000..ad61569
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalManager.test.ts
@@ -0,0 +1,68 @@
+import assert from "node:assert/strict"
+import { afterEach, beforeEach, describe, it } from "mocha"
+import * as sinon from "sinon"
+import * as vscode from "vscode"
+import { VscodeTerminalManager } from "./VscodeTerminalManager"
+import { TerminalInfo, TerminalRegistry } from "./VscodeTerminalRegistry"
+
+function createNeverEndingStream(): AsyncIterable<string> {
+	return {
+		async *[Symbol.asyncIterator]() {
+			await new Promise(() => {})
+		},
+	}
+}
+
+describe("VscodeTerminalManager", () => {
+	let sandbox: sinon.SinonSandbox
+	let manager: VscodeTerminalManager
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox({ useFakeTimers: true })
+		manager = new VscodeTerminalManager()
+	})
+
+	afterEach(() => {
+		manager.disposeAll()
+		sandbox.restore()
+	})
+
+	it("returns after timing out a reused terminal cwd command", async () => {
+		const targetCwd = "/tmp/cline-target"
+		const executeCommandStub = sandbox.stub().returns({
+			read: () => createNeverEndingStream(),
+		})
+		const terminalInfo: TerminalInfo = {
+			id: 1,
+			busy: false,
+			lastCommand: "",
+			lastActive: Date.now(),
+			terminal: {
+				shellIntegration: {
+					cwd: vscode.Uri.file("/tmp/cline-original"),
+					executeCommand: executeCommandStub,
+				},
+			} as unknown as vscode.Terminal,
+		}
+		const getAllTerminalsStub = sandbox.stub(TerminalRegistry, "getAllTerminals").returns([terminalInfo])
+
+		let didResolve = false
+		const terminalPromise = manager.getOrCreateTerminal(targetCwd).then((terminal) => {
+			didResolve = true
+			return terminal
+		})
+
+		await sandbox.clock.tickAsync(4999)
+		assert.equal(didResolve, false)
+
+		await sandbox.clock.tickAsync(1)
+		const terminal = await terminalPromise
+
+		assert.equal(terminal, terminalInfo)
+		assert.equal(terminalInfo.busy, false)
+		assert.equal(terminalInfo.pendingCwdChange, undefined)
+		assert.equal(terminalInfo.cwdResolved, undefined)
+		assert.equal(getAllTerminalsStub.called, true)
+		assert.equal(executeCommandStub.calledOnceWith(`cd "${targetCwd}"`), true)
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalManager.ts b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalManager.ts
new file mode 100644
index 0000000..495d318
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalManager.ts
@@ -0,0 +1,493 @@
+import { arePathsEqual } from "@utils/path"
+import { getShell, getShellForProfile } from "@utils/shell"
+import pWaitFor from "p-wait-for"
+import * as vscode from "vscode"
+import {
+	TerminalInfo as ITerminalInfo,
+	ITerminalManager,
+	TerminalProcessResultPromise as ITerminalProcessResultPromise,
+} from "@/integrations/terminal/types"
+import { Logger } from "@/shared/services/Logger"
+import { mergePromise, VscodeTerminalProcess } from "./VscodeTerminalProcess"
+import { TerminalInfo, TerminalRegistry } from "./VscodeTerminalRegistry"
+
+const CWD_COMMAND_TIMEOUT_MS = 5000
+const CWD_STATE_TIMEOUT_MS = 1000
+
+/*
+TerminalManager:
+- Creates/reuses terminals
+- Runs commands via runCommand(), returning a TerminalProcess
+- Handles shell integration events
+
+TerminalProcess extends EventEmitter and implements Promise:
+- Emits 'line' events with output while promise is pending
+- process.continue() resolves promise and stops event emission
+- Allows real-time output handling or background execution
+
+getUnretrievedOutput() fetches latest output for ongoing commands
+
+Enables flexible command execution:
+- Await for completion
+- Listen to real-time events
+- Continue execution in background
+- Retrieve missed output later
+
+Notes:
+- it turns out some shellIntegration APIs are available on cursor, although not on older versions of vscode
+- "By default, the shell integration script should automatically activate on supported shells launched from VS Code."
+Supported shells:
+Linux/macOS: bash, fish, pwsh, zsh
+Windows: pwsh
+
+
+Example:
+
+const terminalManager = new TerminalManager(context);
+
+// Run a command
+const process = terminalManager.runCommand('npm install', '/path/to/project');
+
+process.on('line', (line) => {
+	Logger.log(line);
+});
+
+// To wait for the process to complete naturally:
+await process;
+
+// Or to continue execution even if the command is still running:
+process.continue();
+
+// Later, if you need to get the unretrieved output:
+const unretrievedOutput = terminalManager.getUnretrievedOutput(terminalId);
+Logger.log('Unretrieved output:', unretrievedOutput);
+
+Resources:
+- https://github.com/microsoft/vscode/issues/226655
+- https://code.visualstudio.com/updates/v1_93#_terminal-shell-integration-api
+- https://code.visualstudio.com/docs/terminal/shell-integration
+- https://code.visualstudio.com/api/references/vscode-api#Terminal
+- https://github.com/microsoft/vscode-extension-samples/blob/main/terminal-sample/src/extension.ts
+- https://github.com/microsoft/vscode-extension-samples/blob/main/shell-integration-sample/src/extension.ts
+*/
+
+/*
+The new shellIntegration API gives us access to terminal command execution output handling.
+However, we don't update our VSCode type definitions or engine requirements to maintain compatibility
+with older VSCode versions. Users on older versions will automatically fall back to using sendText
+for terminal command execution.
+Interestingly, some environments like Cursor enable these APIs even without the latest VSCode engine.
+This approach allows us to leverage advanced features when available while ensuring broad compatibility.
+*/
+declare module "vscode" {
+	// https://github.com/microsoft/vscode/blob/f0417069c62e20f3667506f4b7e53ca0004b4e3e/src/vscode-dts/vscode.d.ts#L7442
+	interface Terminal {
+		shellIntegration?: {
+			cwd?: vscode.Uri
+			executeCommand?: (command: string) => {
+				read: () => AsyncIterable<string>
+			}
+		}
+	}
+	// https://github.com/microsoft/vscode/blob/f0417069c62e20f3667506f4b7e53ca0004b4e3e/src/vscode-dts/vscode.d.ts#L10794
+	interface Window {
+		onDidStartTerminalShellExecution?: (
+			listener: (e: any) => any,
+			thisArgs?: any,
+			disposables?: vscode.Disposable[],
+		) => vscode.Disposable
+	}
+}
+
+export class VscodeTerminalManager implements ITerminalManager {
+	private terminalIds: Set<number> = new Set()
+	private processes: Map<number, VscodeTerminalProcess> = new Map()
+	private disposables: vscode.Disposable[] = []
+	private shellIntegrationTimeout = 4000
+	private terminalReuseEnabled = true
+	private terminalOutputLineLimit = 500
+	private defaultTerminalProfile = "default"
+
+	/**
+	 * Resolve a terminal's stored shellPath to an effective path.
+	 * Terminals created with the "default" profile have shellPath=undefined;
+	 * this resolves that to the actual default shell (e.g. /bin/zsh on macOS)
+	 * so we can compare apples-to-apples when deciding whether a terminal
+	 * is compatible with the current profile setting.
+	 */
+	private static effectiveShellPath(shellPath: string | undefined): string {
+		return shellPath ?? getShell()
+	}
+
+	constructor() {
+		let disposable: vscode.Disposable | undefined
+		try {
+			disposable = (vscode.window as vscode.Window).onDidStartTerminalShellExecution?.(async (e) => {
+				// Creating a read stream here results in a more consistent output. This is most obvious when running the `date` command.
+				e?.execution?.read()
+			})
+		} catch (_error) {
+			// Logger.error("Error setting up onDidEndTerminalShellExecution", error)
+		}
+		if (disposable) {
+			this.disposables.push(disposable)
+		}
+
+		// Add a listener for terminal state changes to detect CWD updates
+		try {
+			const stateChangeDisposable = vscode.window.onDidChangeTerminalState((terminal) => {
+				const terminalInfo = this.findTerminalInfoByTerminal(terminal)
+				if (terminalInfo && terminalInfo.pendingCwdChange && terminalInfo.cwdResolved) {
+					// Check if CWD has been updated to match the expected path
+					if (this.isCwdMatchingExpected(terminalInfo)) {
+						const resolver = terminalInfo.cwdResolved.resolve
+						terminalInfo.pendingCwdChange = undefined
+						terminalInfo.cwdResolved = undefined
+						resolver()
+					}
+				}
+			})
+			this.disposables.push(stateChangeDisposable)
+		} catch (error) {
+			Logger.error("Error setting up onDidChangeTerminalState", error)
+		}
+	}
+
+	//Find a TerminalInfo by its VSCode Terminal instance
+	private findTerminalInfoByTerminal(terminal: vscode.Terminal): TerminalInfo | undefined {
+		const terminals = TerminalRegistry.getAllTerminals()
+		return terminals.find((t) => t.terminal === terminal)
+	}
+
+	//Check if a terminal's CWD matches its expected pending change
+	private isCwdMatchingExpected(terminalInfo: TerminalInfo): boolean {
+		if (!terminalInfo.pendingCwdChange) {
+			return false
+		}
+
+		const currentCwd = terminalInfo.terminal.shellIntegration?.cwd?.fsPath
+		const targetCwd = vscode.Uri.file(terminalInfo.pendingCwdChange).fsPath
+
+		if (!currentCwd) {
+			return false
+		}
+
+		return arePathsEqual(currentCwd, targetCwd)
+	}
+
+	private async drainCommandOutput(output: AsyncIterable<string>): Promise<void> {
+		for await (const _chunk of output) {
+			// Drain the stream so shell integration can report command completion.
+		}
+	}
+
+	// VS Code shell integration sometimes finishes the internal `cd` command without
+	// reporting completion through the execution stream. Timeout this setup step so
+	// the user's actual command is still sent instead of leaving the chat stuck.
+	private async runCwdChangeCommand(terminalInfo: TerminalInfo, cwd: string): Promise<boolean> {
+		const command = `cd "${cwd}"`
+		const shellIntegration = terminalInfo.terminal.shellIntegration
+
+		if (!shellIntegration?.executeCommand) {
+			terminalInfo.terminal.sendText(command, true)
+			Logger.warn(
+				`[TerminalManager] Shell integration executeCommand is unavailable while changing terminal ${terminalInfo.id} cwd. Proceeding after ${CWD_COMMAND_TIMEOUT_MS}ms.`,
+			)
+			await new Promise((resolve) => setTimeout(resolve, CWD_COMMAND_TIMEOUT_MS))
+			return true
+		}
+
+		let timeout: NodeJS.Timeout | undefined
+		let didTimeOut = false
+
+		try {
+			const execution = shellIntegration.executeCommand(command)
+			await Promise.race([
+				this.drainCommandOutput(execution.read()),
+				new Promise<void>((resolve) => {
+					timeout = setTimeout(() => {
+						didTimeOut = true
+						Logger.warn(
+							`[TerminalManager] Timed out waiting ${CWD_COMMAND_TIMEOUT_MS}ms for terminal ${terminalInfo.id} to run cd "${cwd}". Proceeding with requested command.`,
+						)
+						resolve()
+					}, CWD_COMMAND_TIMEOUT_MS)
+				}),
+			])
+		} catch (error) {
+			Logger.warn(`[TerminalManager] Failed to observe terminal ${terminalInfo.id} cwd command completion`, error)
+			return true
+		} finally {
+			if (timeout) {
+				clearTimeout(timeout)
+			}
+		}
+
+		return didTimeOut
+	}
+
+	runCommand(terminalInfo: ITerminalInfo, command: string): ITerminalProcessResultPromise {
+		// Cast to VSCode-specific TerminalInfo for internal use
+		// Using unknown as intermediate cast due to structural differences between ITerminal and vscode.Terminal
+		const vscodeTerminalInfo = terminalInfo as unknown as TerminalInfo
+		Logger.log(`[TerminalManager] Running command on terminal ${vscodeTerminalInfo.id}: "${command}"`)
+		Logger.log(`[TerminalManager] Terminal ${vscodeTerminalInfo.id} busy state before: ${vscodeTerminalInfo.busy}`)
+
+		vscodeTerminalInfo.busy = true
+		vscodeTerminalInfo.lastCommand = command
+		const process = new VscodeTerminalProcess()
+		this.processes.set(vscodeTerminalInfo.id, process)
+
+		process.once("completed", () => {
+			Logger.log(`[TerminalManager] Terminal ${vscodeTerminalInfo.id} completed, setting busy to false`)
+			vscodeTerminalInfo.busy = false
+		})
+
+		// if shell integration is not available, remove terminal so it does not get reused as it may be running a long-running process
+		process.once("no_shell_integration", () => {
+			Logger.log(`no_shell_integration received for terminal ${vscodeTerminalInfo.id}`)
+			// Remove the terminal so we can't reuse it (in case it's running a long-running process)
+			TerminalRegistry.removeTerminal(vscodeTerminalInfo.id)
+			this.terminalIds.delete(vscodeTerminalInfo.id)
+			this.processes.delete(vscodeTerminalInfo.id)
+		})
+
+		const promise = new Promise<void>((resolve, reject) => {
+			process.once("continue", () => {
+				resolve()
+			})
+			process.once("error", (error) => {
+				Logger.error(`Error in terminal ${vscodeTerminalInfo.id}:`, error)
+				reject(error)
+			})
+		})
+
+		// if shell integration is already active, run the command immediately
+		if (vscodeTerminalInfo.terminal.shellIntegration) {
+			process.waitForShellIntegration = false
+			process.run(vscodeTerminalInfo.terminal, command)
+		} else {
+			// docs recommend waiting 3s for shell integration to activate
+			Logger.log(
+				`[TerminalManager Test] Waiting for shell integration for terminal ${vscodeTerminalInfo.id} with timeout ${this.shellIntegrationTimeout}ms`,
+			)
+			pWaitFor(() => vscodeTerminalInfo.terminal.shellIntegration !== undefined, {
+				timeout: this.shellIntegrationTimeout,
+			})
+				.then(() => {
+					Logger.log(
+						`[TerminalManager Test] Shell integration activated for terminal ${vscodeTerminalInfo.id} within timeout.`,
+					)
+				})
+				.catch((err) => {
+					Logger.warn(
+						`[TerminalManager Test] Shell integration timed out or failed for terminal ${vscodeTerminalInfo.id}: ${err.message}`,
+					)
+				})
+				.finally(() => {
+					Logger.log(`[TerminalManager Test] Proceeding with command execution for terminal ${vscodeTerminalInfo.id}.`)
+					const existingProcess = this.processes.get(vscodeTerminalInfo.id)
+					if (existingProcess && existingProcess.waitForShellIntegration) {
+						existingProcess.waitForShellIntegration = false
+						existingProcess.run(vscodeTerminalInfo.terminal, command)
+					}
+				})
+		}
+
+		return mergePromise(process, promise)
+	}
+
+	async getOrCreateTerminal(cwd: string): Promise<ITerminalInfo> {
+		const terminals = TerminalRegistry.getAllTerminals()
+		const expectedShellPath =
+			this.defaultTerminalProfile !== "default" ? getShellForProfile(this.defaultTerminalProfile) : undefined
+		// Resolve effective shell for comparison (so "default" and "zsh" match on macOS)
+		const effectiveExpected = VscodeTerminalManager.effectiveShellPath(expectedShellPath)
+
+		// Find available terminal from our pool first (created for this task)
+		Logger.log(`[TerminalManager] Looking for terminal in cwd: ${cwd}`)
+		Logger.log(`[TerminalManager] Available terminals: ${terminals.length}`)
+
+		const matchingTerminal = terminals.find((t) => {
+			if (t.busy) {
+				Logger.log(`[TerminalManager] Terminal ${t.id} is busy, skipping`)
+				return false
+			}
+			// Check if effective shell path matches current configuration
+			if (VscodeTerminalManager.effectiveShellPath(t.shellPath) !== effectiveExpected) {
+				return false
+			}
+			const terminalCwd = t.terminal.shellIntegration?.cwd // one of cline's commands could have changed the cwd of the terminal
+			if (!terminalCwd) {
+				Logger.log(`[TerminalManager] Terminal ${t.id} has no cwd, skipping`)
+				return false
+			}
+			const matches = arePathsEqual(vscode.Uri.file(cwd).fsPath, terminalCwd.fsPath)
+			Logger.log(`[TerminalManager] Terminal ${t.id} cwd: ${terminalCwd.fsPath}, matches: ${matches}`)
+			return matches
+		})
+		if (matchingTerminal) {
+			Logger.log(`[TerminalManager] Found matching terminal ${matchingTerminal.id} in correct cwd`)
+			this.terminalIds.add(matchingTerminal.id)
+			// Cast to ITerminalInfo for interface compatibility
+			return matchingTerminal as unknown as ITerminalInfo
+		}
+
+		// If no non-busy terminal in the current working dir exists and terminal reuse is enabled, try to find any non-busy terminal regardless of CWD
+		if (this.terminalReuseEnabled) {
+			const availableTerminal = terminals.find(
+				(t) => !t.busy && VscodeTerminalManager.effectiveShellPath(t.shellPath) === effectiveExpected,
+			)
+			if (availableTerminal) {
+				availableTerminal.busy = true
+
+				// Set up promise and tracking for CWD change
+				const cwdPromise = new Promise<void>((resolve, reject) => {
+					availableTerminal.pendingCwdChange = cwd
+					availableTerminal.cwdResolved = { resolve, reject }
+				})
+
+				try {
+					const didCwdCommandTimeOut = await this.runCwdChangeCommand(availableTerminal, cwd)
+
+					// Add a small delay to ensure terminal is ready after cd
+					if (!didCwdCommandTimeOut) {
+						await new Promise((resolve) => setTimeout(resolve, 100))
+					}
+
+					// Either resolve immediately if CWD already updated or wait for event/timeout
+					if (this.isCwdMatchingExpected(availableTerminal)) {
+						if (availableTerminal.cwdResolved) {
+							availableTerminal.cwdResolved.resolve()
+						}
+					} else if (!didCwdCommandTimeOut) {
+						await Promise.race([cwdPromise, new Promise((resolve) => setTimeout(resolve, CWD_STATE_TIMEOUT_MS))])
+					}
+				} finally {
+					availableTerminal.pendingCwdChange = undefined
+					availableTerminal.cwdResolved = undefined
+					availableTerminal.busy = false
+				}
+				this.terminalIds.add(availableTerminal.id)
+				// Cast to ITerminalInfo for interface compatibility
+				return availableTerminal as unknown as ITerminalInfo
+			}
+		}
+
+		// If all terminals are busy or don't match shell profile, create a new one with the configured shell
+		const newTerminalInfo = TerminalRegistry.createTerminal(cwd, expectedShellPath)
+		this.terminalIds.add(newTerminalInfo.id)
+		// Cast to ITerminalInfo for interface compatibility
+		return newTerminalInfo as unknown as ITerminalInfo
+	}
+
+	getTerminals(busy: boolean): { id: number; lastCommand: string }[] {
+		return Array.from(this.terminalIds)
+			.map((id) => TerminalRegistry.getTerminal(id))
+			.filter((t): t is TerminalInfo => t !== undefined && t.busy === busy)
+			.map((t) => ({ id: t.id, lastCommand: t.lastCommand }))
+	}
+
+	getUnretrievedOutput(terminalId: number): string {
+		if (!this.terminalIds.has(terminalId)) {
+			return ""
+		}
+		const process = this.processes.get(terminalId)
+		return process ? process.getUnretrievedOutput() : ""
+	}
+
+	isProcessHot(terminalId: number): boolean {
+		const process = this.processes.get(terminalId)
+		return process ? process.isHot : false
+	}
+
+	disposeAll() {
+		// for (const info of this.terminals) {
+		// 	//info.terminal.dispose() // dont want to dispose terminals when task is aborted
+		// }
+		this.terminalIds.clear()
+		this.processes.clear()
+		this.disposables.forEach((disposable) => disposable.dispose())
+		this.disposables = []
+	}
+
+	setShellIntegrationTimeout(timeout: number): void {
+		this.shellIntegrationTimeout = timeout
+	}
+
+	setTerminalReuseEnabled(enabled: boolean): void {
+		this.terminalReuseEnabled = enabled
+	}
+
+	public processOutput(outputLines: string[], overrideLimit?: number): string {
+		const limit = overrideLimit !== undefined ? overrideLimit : this.terminalOutputLineLimit
+		if (outputLines.length > limit) {
+			const halfLimit = Math.floor(limit / 2)
+			const start = outputLines.slice(0, halfLimit)
+			const end = outputLines.slice(outputLines.length - halfLimit)
+			return `${start.join("\n")}\n... (output truncated) ...\n${end.join("\n")}`.trim()
+		}
+		return outputLines.join("\n").trim()
+	}
+
+	setDefaultTerminalProfile(profileId: string): void {
+		// Just update the profile setting. We don't close existing terminals —
+		// they stay open and are reusable if the user switches back. New
+		// terminals created by getOrCreateTerminal() will use the new profile,
+		// and existing terminals with a different effective shell are simply
+		// skipped during reuse matching.
+		this.defaultTerminalProfile = profileId
+	}
+
+	/**
+	 * Filters terminals based on a provided criteria function
+	 * @param filterFn Function that accepts TerminalInfo and returns boolean
+	 * @returns Array of terminals that match the criteria
+	 */
+	filterTerminals(filterFn: (terminal: TerminalInfo) => boolean): TerminalInfo[] {
+		const terminals = TerminalRegistry.getAllTerminals()
+		return terminals.filter(filterFn)
+	}
+
+	/**
+	 * Closes terminals that match the provided criteria
+	 * @param filterFn Function that accepts TerminalInfo and returns boolean for terminals to close
+	 * @param force If true, closes even busy terminals (with warning)
+	 * @returns Number of terminals closed
+	 */
+	closeTerminals(filterFn: (terminal: TerminalInfo) => boolean, force = false): number {
+		const terminalsToClose = this.filterTerminals(filterFn)
+		let closedCount = 0
+
+		for (const terminalInfo of terminalsToClose) {
+			// Skip busy terminals unless force is true
+			if (terminalInfo.busy && !force) {
+				continue
+			}
+
+			// Remove from our tracking
+			if (this.terminalIds.has(terminalInfo.id)) {
+				this.terminalIds.delete(terminalInfo.id)
+			}
+			this.processes.delete(terminalInfo.id)
+
+			// Dispose the actual terminal
+			terminalInfo.terminal.dispose()
+
+			// Remove from registry
+			TerminalRegistry.removeTerminal(terminalInfo.id)
+
+			closedCount++
+		}
+
+		return closedCount
+	}
+
+	/**
+	 * Forces closure of all terminals (including busy ones)
+	 * @returns Number of terminals closed
+	 */
+	closeAllTerminals(): number {
+		return this.closeTerminals(() => true, true)
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalProcess.test.ts b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalProcess.test.ts
new file mode 100644
index 0000000..1d79ae8
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalProcess.test.ts
@@ -0,0 +1,442 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+import "should"
+import * as sinon from "sinon"
+import * as vscode from "vscode"
+import { VscodeTerminalProcess } from "./VscodeTerminalProcess"
+import { TerminalRegistry } from "./VscodeTerminalRegistry"
+
+declare module "vscode" {
+	// https://github.com/microsoft/vscode/blob/f0417069c62e20f3667506f4b7e53ca0004b4e3e/src/vscode-dts/vscode.d.ts#L7442
+	interface Terminal {
+		shellIntegration?: {
+			cwd?: vscode.Uri
+			executeCommand?: (command: string) => {
+				read: () => AsyncIterable<string>
+			}
+		}
+	}
+}
+
+// Create a mock stream for simulating terminal output - this is only used for tests
+// that need controlled output which can't be guaranteed with real terminals
+function createMockStream(lines: string[] = ["test-command", "line1", "line2", "line3"]) {
+	return {
+		async *[Symbol.asyncIterator]() {
+			for (const line of lines) {
+				yield line + "\n"
+			}
+		},
+	}
+}
+
+describe("TerminalProcess (Integration Tests)", () => {
+	let process: VscodeTerminalProcess
+	let sandbox: sinon.SinonSandbox
+	let createdTerminals: vscode.Terminal[] = []
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox({ useFakeTimers: true })
+		setVscodeHostProviderMock()
+		process = new VscodeTerminalProcess()
+	})
+
+	afterEach(() => {
+		// Restore sandbox, which restores timers and all Sinon fakes
+		sandbox.restore()
+		// Remove any event listeners left on the TerminalProcess
+		process.removeAllListeners()
+		// Dispose all terminals created during the test
+		createdTerminals.forEach((t) => {
+			t.dispose()
+		})
+		createdTerminals = []
+	})
+
+	describe("Real terminal tests", () => {
+		// This test works with or without shell integration
+		it("should create and run a command in a real terminal", async () => {
+			// Create a real VS Code terminal for testing
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Spy on emit to verify behavior
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Run a simple command
+			const runPromise = process.run(terminal, "echo test")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
+
+			// Verify that the continue event was emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+		})
+
+		it("should execute and capture events from a simple command", async () => {
+			// Create a real VS Code terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Spy on emit to verify line events
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Run a command that produces predictable output
+			const runPromise = process.run(terminal, "echo 'Line 1' && echo 'Line 2'")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
+
+			// Check that the events were emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+		})
+
+		it("should execute a command that lists files", async () => {
+			// Create a real VS Code terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Spy on emit to verify behavior
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Run a command that lists files
+			const runPromise = process.run(terminal, "ls -la")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
+
+			// Verify that the continue event was emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+		})
+
+		it("should handle a longer running command", async () => {
+			// Create a real terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Spy on emit to verify behavior
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Un-fake timers temporarily for this test since we need real timing
+			sandbox.clock.restore()
+
+			// Run a command that sleeps for a short period
+			await process.run(terminal, "sleep 0.5 && echo 'Done sleeping'")
+
+			// Verify that the continue and completed events were emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+
+			// Restore fake timers for other tests
+			sandbox.useFakeTimers()
+		})
+
+		it("should execute a command with arguments", async () => {
+			// Create a real VS Code terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Spy on emit to verify line events
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Run a command that produces predictable output
+			const runPromise = process.run(terminal, "echo 'Line 1' 'Line 2'")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
+
+			// Check that the events were emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+		})
+
+		it("should execute a command with quotes", async () => {
+			// Create a real VS Code terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Spy on emit to verify line events
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Run a command that produces predictable output
+			const runPromise = process.run(terminal, "echo \"Line 1\" && echo 'Line 2'")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
+
+			// Check that the events were emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+		})
+	})
+
+	// Test that specifically checks for no shell integration
+	it("should handle terminals without shell integration", async () => {
+		// Create a real terminal without explicitly providing shell integration
+		const terminal = vscode.window.createTerminal({ name: "Test Terminal" })
+		createdTerminals.push(terminal)
+
+		// Stub the shellIntegration getter to return undefined for this test
+		sandbox.stub(terminal, "shellIntegration").get(() => undefined)
+
+		// Stub the sendText method to verify it's called
+		const sendTextStub = sandbox.stub(terminal, "sendText")
+
+		// Spy on the emit function to verify events
+		const emitSpy = sandbox.spy(process, "emit")
+
+		// Run the command - this returns a promise
+		const runPromise = process.run(terminal, "test-command")
+
+		// Advance the fake timer by 3 seconds to trigger the setTimeout
+		await sandbox.clock.tickAsync(3000)
+
+		// Now wait for the promise to resolve
+		await runPromise
+
+		// Check that the correct methods were called and events emitted
+		sendTextStub.calledWith("test-command", true).should.be.true()
+		;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+		;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+
+		// This event should be emitted for terminals without shell integration
+		;(emitSpy as sinon.SinonSpy).calledWith("no_shell_integration").should.be.true()
+	})
+
+	// The following tests require shell integration and controlled terminal output
+	describe("Shell integration tests", () => {
+		// We'll mock the terminal run process and TerminalProcess for these tests
+		it("should emit completed and continue events when command finishes", async () => {
+			// Create a terminal to ensure proper interface, but we'll use mocking under the hood
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Create a mock implementation of executeCommand
+			const mockExecuteCommand = sandbox.stub().returns({
+				read: () => createMockStream(["echo test", "test output"]),
+			})
+
+			// Create a fake shell integration object
+			const mockShellIntegration = {
+				executeCommand: mockExecuteCommand,
+			}
+
+			// Stub terminal.shellIntegration to return our mock
+			sandbox.stub(terminal, "shellIntegration").get(() => mockShellIntegration)
+
+			// Spy on emit to verify behavior
+			const emitSpy = sandbox.spy(process, "emit")
+
+			// Run the command
+			await process.run(terminal, "echo test")
+
+			// Verify the executeCommand was called with the right command
+			mockExecuteCommand.calledWith("echo test").should.be.true()
+
+			// Check that the events were emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
+		})
+	})
+
+	// Tests with controlled output
+	describe("Controlled output tests", () => {
+		it("should emit line events for each line of output", async () => {
+			// Create a terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Mock the shell integration with controlled output
+			const mockExecuteCommand = sandbox.stub().returns({
+				read: () => createMockStream(["test-command", "line1", "line2", "line3"]),
+			})
+
+			// Create a mock shell integration object and stub the getter
+			sandbox.stub(terminal, "shellIntegration").get(() => ({
+				executeCommand: mockExecuteCommand,
+			}))
+
+			const emitSpy = sandbox.spy(process, "emit")
+
+			await process.run(terminal, "test-command")
+
+			// Check that line events were emitted for each line
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "line1").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "line2").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "line3").should.be.true()
+		})
+
+		it("should properly handle process hot state (e.g. compiling)", async () => {
+			// Create a terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Mock the shell integration
+			const mockExecuteCommand = sandbox.stub().returns({
+				read: () => createMockStream(["compiling..."]),
+			})
+
+			// Create a mock shell integration object and stub the getter
+			sandbox.stub(terminal, "shellIntegration").get(() => ({
+				executeCommand: mockExecuteCommand,
+			}))
+
+			// Spy on global setTimeout
+			const setTimeoutSpy = sandbox.spy(global, "setTimeout")
+
+			await process.run(terminal, "build command")
+
+			// Move time forward enough to schedule
+			sandbox.clock.tick(100)
+
+			// Expect a 15-second (>= 10000ms) hot timeout, since it saw "compiling"
+			const foundCompilingTimeout = setTimeoutSpy.args.filter((args) => args[1] && args[1] >= 10000)
+			foundCompilingTimeout.length.should.be.greaterThan(0)
+		})
+
+		it("should handle standard commands with normal hot timeout", async () => {
+			// Create a terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Mock the shell integration
+			const mockExecuteCommand = sandbox.stub().returns({
+				read: () => createMockStream(["some normal output"]),
+			})
+
+			// Create a mock shell integration object and stub the getter
+			sandbox.stub(terminal, "shellIntegration").get(() => ({
+				executeCommand: mockExecuteCommand,
+			}))
+
+			const setTimeoutSpy = sandbox.spy(global, "setTimeout")
+
+			await process.run(terminal, "standard command")
+			sandbox.clock.tick(100)
+
+			// Expect a short hot timeout (<= 5000)
+			const foundNormalTimeout = setTimeoutSpy.args.filter((args) => args[1] && args[1] <= 5000)
+			foundNormalTimeout.length.should.be.greaterThan(0)
+
+			// Also check that "completed" eventually emits
+			const emitSpy = sandbox.spy(process, "emit")
+			await process.run(terminal, "another command")
+			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
+		})
+
+		it("should correctly filter command echoes based on current implementation", async () => {
+			// Create a terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Mock the shell integration
+			const mockExecuteCommand = sandbox.stub().returns({
+				read: () =>
+					createMockStream([
+						"test-command", // This should be filtered (command contains this exactly)
+						"test command", // This should NOT be filtered (doesn't match exactly)
+						"other output",
+					]),
+			})
+
+			// Create a mock shell integration object and stub the getter
+			sandbox.stub(terminal, "shellIntegration").get(() => ({
+				executeCommand: mockExecuteCommand,
+			}))
+
+			const emitSpy = sandbox.spy(process, "emit")
+
+			await process.run(terminal, "test-command")
+
+			// Check that "test-command" was filtered out but "test command" was not
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "test command").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "other output").should.be.true()
+			// This should never be called because it should be filtered
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "test-command").should.be.false()
+		})
+
+		it("should handle npm run commands", async () => {
+			// Create a terminal
+			const terminal = TerminalRegistry.createTerminal().terminal
+			createdTerminals.push(terminal)
+
+			// Mock the shell integration
+			const mockExecuteCommand = sandbox.stub().returns({
+				read: () => createMockStream(["npm run build", "> project@1.0.0 build", "> tsc", "files built successfully"]),
+			})
+
+			// Create a mock shell integration object and stub the getter
+			sandbox.stub(terminal, "shellIntegration").get(() => ({
+				executeCommand: mockExecuteCommand,
+			}))
+
+			const emitSpy = sandbox.spy(process, "emit")
+
+			await process.run(terminal, "npm run build")
+
+			// The "npm run build" line should be filtered, but the rest should be emitted
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "> project@1.0.0 build").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "> tsc").should.be.true()
+			;(emitSpy as sinon.SinonSpy).calledWith("line", "files built successfully").should.be.true()
+		})
+	})
+
+	// The following tests are shared with the unit tests to ensure consistent behavior
+	it("should emit line for remaining buffer when emitRemainingBufferIfListening is called", () => {
+		// Access private properties via type assertion
+		const processAny = process as any
+		processAny.buffer = "test buffer content"
+		processAny.isListening = true
+
+		const emitSpy = sandbox.spy(process, "emit")
+		processAny.emitRemainingBufferIfListening()
+		;(emitSpy as sinon.SinonSpy).calledWith("line", "test buffer content").should.be.true()
+		processAny.buffer.should.equal("")
+	})
+
+	it("should remove prompt characters from the last line of output", () => {
+		const processAny = process as any
+
+		processAny.removeLastLineArtifacts("line 1\nline 2 %").should.equal("line 1\nline 2")
+		processAny.removeLastLineArtifacts("line 1\nline 2 $").should.equal("line 1\nline 2")
+		processAny.removeLastLineArtifacts("line 1\nline 2 #").should.equal("line 1\nline 2")
+		processAny.removeLastLineArtifacts("line 1\nline 2 >").should.equal("line 1\nline 2")
+	})
+
+	it("should process buffer and emit lines when newline characters are found", () => {
+		const processAny = process as any
+		const emitSpy = sandbox.spy(process, "emit")
+
+		processAny.emitIfEol("line 1\nline 2\nline 3")
+		;(emitSpy as sinon.SinonSpy).calledWith("line", "line 1").should.be.true()
+		;(emitSpy as sinon.SinonSpy).calledWith("line", "line 2").should.be.true()
+		processAny.buffer.should.equal("line 3")
+
+		processAny.emitIfEol(" continued\n")
+		;(emitSpy as sinon.SinonSpy).calledWith("line", "line 3 continued").should.be.true()
+		processAny.buffer.should.equal("")
+	})
+})
diff --git a/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalProcess.ts b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalProcess.ts
new file mode 100644
index 0000000..f13f4a8
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalProcess.ts
@@ -0,0 +1,357 @@
+import { TerminalOutputFailureReason, telemetryService } from "@services/telemetry"
+import { EventEmitter } from "events"
+import * as vscode from "vscode"
+import { stripAnsi } from "@/hosts/vscode/terminal/ansiUtils"
+import { getLatestTerminalOutput } from "@/hosts/vscode/terminal/get-latest-output"
+import {
+	isCompilingOutput,
+	MAX_FULL_OUTPUT_SIZE,
+	MAX_UNRETRIEVED_LINES,
+	PROCESS_HOT_TIMEOUT_COMPILING,
+	PROCESS_HOT_TIMEOUT_NORMAL,
+	TRUNCATE_KEEP_LINES,
+} from "@/integrations/terminal/constants"
+import type { ITerminalProcess, TerminalCompletionDetails, TerminalProcessEvents } from "@/integrations/terminal/types"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * VscodeTerminalProcess - Manages command execution in VSCode's integrated terminal.
+ *
+ * This class handles command execution using VSCode's shell integration API.
+ * It processes VSCode-specific escape sequences and streams output through events.
+ *
+ * Implements ITerminalProcess interface for polymorphic usage with CommandExecutor.
+ *
+ * Events:
+ * - 'line': Emitted for each line of output
+ * - 'completed': Emitted when the process completes
+ * - 'continue': Emitted when continue() is called
+ * - 'error': Emitted on process errors
+ * - 'no_shell_integration': Emitted when shell integration is not available
+ */
+export class VscodeTerminalProcess extends EventEmitter<TerminalProcessEvents> implements ITerminalProcess {
+	waitForShellIntegration = true
+	private isListening = true
+	private buffer = ""
+	private fullOutput = ""
+	private lastRetrievedIndex = 0
+	isHot = false
+	private hotTimer: NodeJS.Timeout | null = null
+	private exitCode: number | null | undefined = undefined
+	private signal: NodeJS.Signals | null = null
+
+	async run(terminal: vscode.Terminal, command: string) {
+		this.exitCode = undefined
+		this.signal = null
+
+		// When command does not produce any output, we can assume the shell integration API failed and as a fallback return the current terminal contents
+		const returnCurrentTerminalContents = async () => {
+			try {
+				const terminalSnapshot = await getLatestTerminalOutput()
+				if (terminalSnapshot && terminalSnapshot.trim()) {
+					const fallbackMessage = `The command's output could not be captured due to some technical issue, however it has been executed successfully. Here's the current terminal's content to help you get the command's output:\n\n${terminalSnapshot}`
+					this.emit("line", fallbackMessage)
+				}
+			} catch (error) {
+				Logger.error("Error capturing terminal output:", error)
+			}
+		}
+
+		if (terminal.shellIntegration && terminal.shellIntegration.executeCommand) {
+			// Track that we're using shell integration
+			const execution = terminal.shellIntegration.executeCommand(command)
+			const stream = execution.read()
+			// todo: need to handle errors
+			let isFirstChunk = true
+			let didOutputNonCommand = false
+			let didEmitEmptyLine = false
+
+			for await (let data of stream) {
+				// Parse shell integration completion markers when present.
+				// Sequence format: ]633;D;<exitCode>
+				const completionMatches = [...data.matchAll(/\]633;D(?:;(-?\d+))?/g)]
+				const latestCompletionMatch = completionMatches[completionMatches.length - 1]
+				if (latestCompletionMatch?.[1] !== undefined) {
+					const parsedExitCode = Number.parseInt(latestCompletionMatch[1], 10)
+					if (Number.isInteger(parsedExitCode)) {
+						this.exitCode = parsedExitCode
+					}
+				}
+
+				// 1. Process chunk and remove artifacts
+				if (isFirstChunk) {
+					/*
+					The first chunk we get from this stream needs to be processed to be more human readable, ie remove vscode's custom escape sequences and identifiers, removing duplicate first char bug, etc.
+					*/
+
+					// bug where sometimes the command output makes its way into vscode shell integration metadata
+					/*
+					]633 is a custom sequence number used by VSCode shell integration:
+					- OSC 633 ; A ST - Mark prompt start
+					- OSC 633 ; B ST - Mark prompt end
+					- OSC 633 ; C ST - Mark pre-execution (start of command output)
+					- OSC 633 ; D [; <exitcode>] ST - Mark execution finished with optional exit code
+					- OSC 633 ; E ; <commandline> [; <nonce>] ST - Explicitly set command line with optional nonce
+					*/
+					// if you print this data you might see something like "eecho hello worldo hello world;5ba85d14-e92a-40c4-b2fd-71525581eeb0]633;C" but this is actually just a bunch of escape sequences, ignore up to the first ;C
+					/* ddateb15026-6a64-40db-b21f-2a621a9830f0]633;CTue Sep 17 06:37:04 EDT 2024 % ]633;D;0]633;P;Cwd=/Users/saoud/Repositories/test */
+					// Gets output between ]633;C (command start) and ]633;D (command end)
+					const outputBetweenSequences = this.removeLastLineArtifacts(
+						data.match(/\]633;C([\s\S]*?)\]633;D/)?.[1] || "",
+					).trim()
+
+					// Once we've retrieved any potential output between sequences, we can remove everything up to end of the last sequence
+					// https://code.visualstudio.com/docs/terminal/shell-integration#_vs-code-custom-sequences-osc-633-st
+					const vscodeSequenceRegex = /\x1b\]633;.[^\x07]*\x07/g
+					const lastMatch = [...data.matchAll(vscodeSequenceRegex)].pop()
+					if (lastMatch && lastMatch.index !== undefined) {
+						data = data.slice(lastMatch.index + lastMatch[0].length)
+					}
+					// Place output back after removing vscode sequences
+					if (outputBetweenSequences) {
+						data = outputBetweenSequences + "\n" + data
+					}
+					// remove ansi
+					data = stripAnsi(data)
+					// Split data by newlines
+					const lines = data ? data.split("\n") : []
+					// Remove non-human readable characters from the first line
+					if (lines.length > 0) {
+						lines[0] = lines[0].replace(/[^\x20-\x7E]/g, "")
+					}
+					// Check for duplicated first character that might be a terminal artifact
+					// But skip this check for known syntax characters like {, [, ", etc.
+					if (
+						lines.length > 0 &&
+						lines[0].length >= 2 &&
+						lines[0][0] === lines[0][1] &&
+						!["[", "{", '"', "'", "<", "("].includes(lines[0][0])
+					) {
+						lines[0] = lines[0].slice(1)
+					}
+					// Only remove specific terminal artifacts from line beginnings while preserving JSON syntax
+					if (lines.length > 0) {
+						// This regex only removes common terminal artifacts (%, $, >, #) and invisible control chars
+						// but preserves important syntax chars like {, [, ", etc.
+						lines[0] = lines[0].replace(/^[\x00-\x1F%$>#\s]*/, "")
+					}
+					if (lines.length > 1) {
+						lines[1] = lines[1].replace(/^[\x00-\x1F%$>#\s]*/, "")
+					}
+					// Join lines back
+					data = lines.join("\n")
+					isFirstChunk = false
+				} else {
+					data = stripAnsi(data)
+				}
+
+				// Ctrl+C detection: if user presses Ctrl+C, treat as command terminated
+				if (data.includes("^C") || data.includes("\u0003")) {
+					if (this.hotTimer) {
+						clearTimeout(this.hotTimer)
+					}
+					this.isHot = false
+					break
+				}
+
+				// first few chunks could be the command being echoed back, so we must ignore
+				// note this means that 'echo' commands won't work
+				if (!didOutputNonCommand) {
+					const lines = data.split("\n")
+					for (let i = 0; i < lines.length; i++) {
+						if (command.includes(lines[i].trim())) {
+							lines.splice(i, 1)
+							i-- // Adjust index after removal
+						} else {
+							didOutputNonCommand = true
+							break
+						}
+					}
+					data = lines.join("\n")
+				}
+
+				// 2. Set isHot depending on the command
+				// Set to hot to stall API requests until terminal is cool again
+				this.isHot = true
+				if (this.hotTimer) {
+					clearTimeout(this.hotTimer)
+				}
+				// these markers indicate the command is some kind of local dev server recompiling the app, which we want to wait for output of before sending request to cline
+				const isCompiling = isCompilingOutput(data)
+				this.hotTimer = setTimeout(
+					() => {
+						this.isHot = false
+					},
+					isCompiling ? PROCESS_HOT_TIMEOUT_COMPILING : PROCESS_HOT_TIMEOUT_NORMAL,
+				)
+
+				// For non-immediately returning commands we want to show loading spinner right away but this wouldn't happen until it emits a line break, so as soon as we get any output we emit "" to let webview know to show spinner
+				// This is only done for the sake of unblocking the UI, in case there may be some time before the command emits a full line
+				if (!didEmitEmptyLine && !this.fullOutput && data) {
+					this.emit("line", "") // empty line to indicate start of command output stream
+					didEmitEmptyLine = true
+				}
+
+				this.fullOutput += data
+
+				// Cap fullOutput at MAX_FULL_OUTPUT_SIZE to prevent memory exhaustion
+				if (this.fullOutput.length > MAX_FULL_OUTPUT_SIZE) {
+					// Keep last half of max size
+					this.fullOutput = this.fullOutput.slice(-MAX_FULL_OUTPUT_SIZE / 2)
+					// Reset lastRetrievedIndex since we truncated the beginning
+					this.lastRetrievedIndex = 0
+				}
+
+				if (this.isListening) {
+					this.emitIfEol(data)
+					this.lastRetrievedIndex = this.fullOutput.length - this.buffer.length
+				}
+			}
+
+			this.emitRemainingBufferIfListening()
+
+			// the command process is finished, let's check the output to see if we need to use the terminal capture fallback
+			if (!this.fullOutput.trim()) {
+				// No output captured via shell integration, trying fallback
+				telemetryService.captureTerminalOutputFailure(TerminalOutputFailureReason.TIMEOUT, "vscode")
+				await returnCurrentTerminalContents()
+				// Check if fallback worked
+				const terminalSnapshot = await getLatestTerminalOutput()
+				if (terminalSnapshot && terminalSnapshot.trim()) {
+					telemetryService.captureTerminalExecution(true, "vscode", "clipboard")
+				} else {
+					telemetryService.captureTerminalExecution(false, "vscode", "none")
+				}
+			} else {
+				// Shell integration worked
+				telemetryService.captureTerminalExecution(true, "vscode", "shell_integration")
+			}
+
+			// for now we don't want this delaying requests since we don't send diagnostics automatically anymore (previous: "even though the command is finished, we still want to consider it 'hot' in case so that api request stalls to let diagnostics catch up")
+			// to explain this further, before we would send workspace diagnostics automatically with each request, but now we only send new diagnostics after file edits, so there's no need to wait for a bit after commands run to let diagnostics catch up
+			if (this.hotTimer) {
+				clearTimeout(this.hotTimer)
+			}
+			this.isHot = false
+
+			this.emit("completed", this.getCompletionDetails())
+			this.emit("continue")
+		} else {
+			// no shell integration detected, we'll fallback to running the command and capturing the terminal's output after some time
+			telemetryService.captureTerminalOutputFailure(TerminalOutputFailureReason.NO_SHELL_INTEGRATION, "vscode")
+			terminal.sendText(command, true)
+
+			// wait 3 seconds for the command to run
+			await new Promise((resolve) => setTimeout(resolve, 3000))
+
+			// For terminals without shell integration, also try to capture terminal content
+			await returnCurrentTerminalContents()
+			// Check if clipboard fallback worked
+			const terminalSnapshot = await getLatestTerminalOutput()
+			if (terminalSnapshot && terminalSnapshot.trim()) {
+				telemetryService.captureTerminalExecution(true, "vscode", "clipboard")
+			} else {
+				telemetryService.captureTerminalExecution(false, "vscode", "none")
+			}
+			// For terminals without shell integration, we can't know when the command completes
+			// So we'll just emit the continue event after a delay
+			this.emit("completed", this.getCompletionDetails())
+			this.emit("continue")
+			this.emit("no_shell_integration")
+			// setTimeout(() => {
+			// 	Logger.log(`Emitting continue after delay for terminal`)
+			// 	// can't emit completed since we don't if the command actually completed, it could still be running server
+			// }, 500) // Adjust this delay as needed
+		}
+	}
+
+	// Inspired by https://github.com/sindresorhus/execa/blob/main/lib/transform/split.js
+	private emitIfEol(chunk: string) {
+		this.buffer += chunk
+		let lineEndIndex: number
+		while ((lineEndIndex = this.buffer.indexOf("\n")) !== -1) {
+			const line = this.buffer.slice(0, lineEndIndex).trimEnd() // removes trailing \r
+			// Remove \r if present (for Windows-style line endings)
+			// if (line.endsWith("\r")) {
+			// 	line = line.slice(0, -1)
+			// }
+			this.emit("line", line)
+			this.buffer = this.buffer.slice(lineEndIndex + 1)
+		}
+	}
+
+	private emitRemainingBufferIfListening() {
+		if (this.buffer && this.isListening) {
+			const remainingBuffer = this.removeLastLineArtifacts(this.buffer)
+			if (remainingBuffer) {
+				this.emit("line", remainingBuffer)
+			}
+			this.buffer = ""
+			this.lastRetrievedIndex = this.fullOutput.length
+		}
+	}
+
+	continue() {
+		this.emitRemainingBufferIfListening()
+		this.isListening = false
+		this.removeAllListeners("line")
+		this.emit("continue")
+	}
+
+	/**
+	 * Get output that hasn't been retrieved yet.
+	 * Truncates if output is too large to prevent context window overflow.
+	 * @returns The unretrieved output (truncated if necessary)
+	 */
+	getUnretrievedOutput(): string {
+		const unretrieved = this.fullOutput.slice(this.lastRetrievedIndex)
+		this.lastRetrievedIndex = this.fullOutput.length
+
+		// Truncate if too many lines to prevent context overflow
+		const lines = unretrieved.split("\n")
+		if (lines.length > MAX_UNRETRIEVED_LINES) {
+			const first = lines.slice(0, TRUNCATE_KEEP_LINES)
+			const last = lines.slice(-TRUNCATE_KEEP_LINES)
+			const skipped = lines.length - first.length - last.length
+			return this.removeLastLineArtifacts([...first, `\n... (${skipped} lines truncated) ...\n`, ...last].join("\n"))
+		}
+
+		return this.removeLastLineArtifacts(unretrieved)
+	}
+
+	getCompletionDetails(): TerminalCompletionDetails {
+		return {
+			exitCode: this.exitCode,
+			signal: this.signal,
+		}
+	}
+
+	// some processing to remove artifacts like '%' at the end of the buffer (it seems that since vsode uses % at the beginning of newlines in terminal, it makes its way into the stream)
+	// This modification will remove '%', '$', '#', or '>' followed by optional whitespace
+	removeLastLineArtifacts(output: string) {
+		const lines = output.trimEnd().split("\n")
+		if (lines.length > 0) {
+			const lastLine = lines[lines.length - 1]
+			// Remove prompt characters and trailing whitespace from the last line
+			lines[lines.length - 1] = lastLine.replace(/[%$#>]\s*$/, "")
+		}
+		return lines.join("\n").trimEnd()
+	}
+}
+
+export type TerminalProcessResultPromise = VscodeTerminalProcess & Promise<void>
+
+// Similar to execa's ResultPromise, this lets us create a mixin of both a TerminalProcess and a Promise: https://github.com/sindresorhus/execa/blob/main/lib/methods/promise.js
+export function mergePromise(process: VscodeTerminalProcess, promise: Promise<void>): TerminalProcessResultPromise {
+	const nativePromisePrototype = (async () => {})().constructor.prototype
+	const descriptors = ["then", "catch", "finally"].map(
+		(property) => [property, Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)] as const,
+	)
+	for (const [property, descriptor] of descriptors) {
+		if (descriptor) {
+			const value = descriptor.value.bind(promise)
+			Reflect.defineProperty(process, property, { ...descriptor, value })
+		}
+	}
+	return process as TerminalProcessResultPromise
+}
diff --git a/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalRegistry.ts b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalRegistry.ts
new file mode 100644
index 0000000..56f956a
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/VscodeTerminalRegistry.ts
@@ -0,0 +1,85 @@
+import * as vscode from "vscode"
+
+export interface TerminalInfo {
+	terminal: vscode.Terminal
+	busy: boolean
+	lastCommand: string
+	id: number
+	shellPath?: string
+	lastActive: number
+	pendingCwdChange?: string
+	cwdResolved?: {
+		resolve: () => void
+		reject: (error: Error) => void
+	}
+}
+
+// Although vscode.window.terminals provides a list of all open terminals, there's no way to know whether they're busy or not (exitStatus does not provide useful information for most commands). In order to prevent creating too many terminals, we need to keep track of terminals through the life of the extension, as well as session specific terminals for the life of a task (to get latest unretrieved output).
+// Since we have promises keeping track of terminal processes, we get the added benefit of keep track of busy terminals even after a task is closed.
+export class TerminalRegistry {
+	private static terminals: TerminalInfo[] = []
+	private static nextTerminalId = 1
+
+	static createTerminal(cwd?: string | vscode.Uri | undefined, shellPath?: string): TerminalInfo {
+		const terminalOptions: vscode.TerminalOptions = {
+			cwd,
+			name: "Cline",
+			iconPath: new vscode.ThemeIcon("cline-icon"),
+			env: {
+				CLINE_ACTIVE: "true",
+				// Override $SHELL to match the selected shell profile so that
+				// child processes (make, npm scripts, etc.) that read $SHELL
+				// see the correct value instead of the user's login shell.
+				...(shellPath ? { SHELL: shellPath } : {}),
+			},
+		}
+
+		// If a specific shell path is provided, use it
+		if (shellPath) {
+			terminalOptions.shellPath = shellPath
+		}
+
+		const terminal = vscode.window.createTerminal(terminalOptions)
+		TerminalRegistry.nextTerminalId++
+		const newInfo: TerminalInfo = {
+			terminal,
+			busy: false,
+			lastCommand: "",
+			id: TerminalRegistry.nextTerminalId,
+			shellPath,
+			lastActive: Date.now(),
+		}
+		TerminalRegistry.terminals.push(newInfo)
+		return newInfo
+	}
+
+	static getTerminal(id: number): TerminalInfo | undefined {
+		const terminalInfo = TerminalRegistry.terminals.find((t) => t.id === id)
+		if (terminalInfo && TerminalRegistry.isTerminalClosed(terminalInfo.terminal)) {
+			TerminalRegistry.removeTerminal(id)
+			return undefined
+		}
+		return terminalInfo
+	}
+
+	static updateTerminal(id: number, updates: Partial<TerminalInfo>) {
+		const terminal = TerminalRegistry.getTerminal(id)
+		if (terminal) {
+			Object.assign(terminal, updates)
+		}
+	}
+
+	static removeTerminal(id: number) {
+		TerminalRegistry.terminals = TerminalRegistry.terminals.filter((t) => t.id !== id)
+	}
+
+	static getAllTerminals(): TerminalInfo[] {
+		TerminalRegistry.terminals = TerminalRegistry.terminals.filter((t) => !TerminalRegistry.isTerminalClosed(t.terminal))
+		return TerminalRegistry.terminals
+	}
+
+	// The exit status of the terminal will be undefined while the terminal is active. (This value is set when onDidCloseTerminal is fired.)
+	private static isTerminalClosed(terminal: vscode.Terminal): boolean {
+		return terminal.exitStatus !== undefined
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/terminal/ansiUtils.ts b/apps/vscode/src/hosts/vscode/terminal/ansiUtils.ts
new file mode 100644
index 0000000..4550f1f
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/ansiUtils.ts
@@ -0,0 +1,14 @@
+function ansiRegex({ onlyFirst = false } = {}) {
+	// Valid string terminator sequences are BEL, ESC\, and 0x9c
+	const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)"
+	const pattern = [
+		`[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
+		"(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+	].join("|")
+
+	return new RegExp(pattern, onlyFirst ? undefined : "g")
+}
+
+export function stripAnsi(string: string): string {
+	return string.replace(ansiRegex(), "")
+}
diff --git a/apps/vscode/src/hosts/vscode/terminal/get-latest-output.ts b/apps/vscode/src/hosts/vscode/terminal/get-latest-output.ts
new file mode 100644
index 0000000..f08ce1a
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/terminal/get-latest-output.ts
@@ -0,0 +1,46 @@
+import { readTextFromClipboard, writeTextToClipboard } from "@utils/env"
+import * as vscode from "vscode"
+
+/**
+ * Gets the contents of the active terminal
+ * @returns The terminal contents as a string
+ */
+export async function getLatestTerminalOutput(): Promise<string> {
+	// Store original clipboard content to restore later
+	const originalClipboard = await readTextFromClipboard()
+
+	try {
+		// Select terminal content
+		await vscode.commands.executeCommand("workbench.action.terminal.selectAll")
+
+		// Copy selection to clipboard
+		await vscode.commands.executeCommand("workbench.action.terminal.copySelection")
+
+		// Clear the selection
+		await vscode.commands.executeCommand("workbench.action.terminal.clearSelection")
+
+		// Get terminal contents from clipboard
+		let terminalContents = (await readTextFromClipboard()).trim()
+
+		// Check if there's actually a terminal open
+		if (terminalContents === originalClipboard) {
+			return ""
+		}
+
+		// Clean up command separation
+		const lines = terminalContents.split("\n")
+		const lastLine = lines.pop()?.trim()
+		if (lastLine) {
+			let i = lines.length - 1
+			while (i >= 0 && !lines[i].trim().startsWith(lastLine)) {
+				i--
+			}
+			terminalContents = lines.slice(Math.max(i, 0)).join("\n")
+		}
+
+		return terminalContents
+	} finally {
+		// Restore original clipboard content
+		await writeTextToClipboard(originalClipboard)
+	}
+}
diff --git a/apps/vscode/src/hosts/vscode/vscode-to-file-migration.ts b/apps/vscode/src/hosts/vscode/vscode-to-file-migration.ts
new file mode 100644
index 0000000..f7aece3
--- /dev/null
+++ b/apps/vscode/src/hosts/vscode/vscode-to-file-migration.ts
@@ -0,0 +1,239 @@
+/**
+ * One-time migration from VSCode's ExtensionContext storage to file-backed stores.
+ *
+ * VSCode historically stored global state, workspace state, and secrets via the
+ * ExtensionContext API (backed by SQLite under ~/.vscode/). This module migrates
+ * that data to the shared file-backed stores in ~/.cline/data/ so all platforms
+ * (VSCode, CLI, JetBrains) share the same persistence layer.
+ *
+ * ## Migration semantics
+ *
+ * - **Two independent sentinels** control migration:
+ *   - `__migrationVersion` in the file-backed `globalState` gates global state + secrets.
+ *   - `__migrationVersion` in the file-backed `workspaceState` gates per-workspace state.
+ *   This ensures that when a new workspace is opened for the first time, its workspace
+ *   state is still migrated even though globals+secrets were already exported previously.
+ *
+ * - **Merge strategy: file-backed store wins.** If a key already exists in the
+ *   file store (e.g. because CLI or JetBrains wrote it), we do NOT overwrite.
+ *   This prevents the migration from clobbering newer data written by another client.
+ *
+ * - VSCode storage is NOT cleared after migration. This ensures safe downgrade:
+ *   if the user rolls back to an older extension version that doesn't know about
+ *   file-backed stores, the old code path still works.
+ *
+ * - taskHistory is NOT migrated here. It uses its own file-based storage
+ *   at {globalStorageFsPath}/state/taskHistory.json. Note that for VSCode,
+ *   globalStorageFsPath is still the VSCode-managed path (not ~/.cline/data/),
+ *   so task history is NOT yet shared across clients.
+ *
+ *   TODO: Migrate taskHistory.json and task data files ({globalStorageFsPath}/tasks/)
+ *   to ~/.cline/data/ so that tasks created in VSCode are visible in CLI/JetBrains
+ *   and vice versa. See also: checkpoints at {globalStorageFsPath}/checkpoints/.
+ */
+
+import type * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { GlobalStateAndSettingKeys, LocalStateKeys, SecretKeys } from "@/shared/storage/state-keys"
+import type { StorageContext } from "@/shared/storage/storage-context"
+import { migrateLegacyMcpSettings } from "./mcp-settings-legacy-migration"
+
+/** Version 1 exported VSCode memento/secrets/workspace state to file-backed stores. */
+const FILE_BACKED_STORAGE_EXPORT_VERSION = 1
+
+/** Version 2 imports legacy MCP settings files into the shared SDK/CLI settings path. */
+const MCP_SETTINGS_MIGRATION_VERSION = 2
+
+/** Bump this when adding new migration steps. */
+const CURRENT_MIGRATION_VERSION = MCP_SETTINGS_MIGRATION_VERSION
+
+/** Sentinel key written to both globalState and workspaceState to track migration independently. */
+const MIGRATION_VERSION_KEY = "__vscodeMigrationVersion"
+
+/**
+ * Keys that should NOT be migrated from VSCode storage.
+ * These are either:
+ * - async/computed (taskHistory has its own file)
+ * - ephemeral/transient
+ */
+const SKIP_GLOBAL_STATE_KEYS = new Set<string>([
+	"taskHistory", // Already file-based in tasks/taskHistory.json
+])
+
+export interface MigrationResult {
+	migrated: boolean
+	globalStateCount: number
+	secretsCount: number
+	workspaceStateCount: number
+	skippedExisting: number
+	mcpServersAdded: number
+	mcpServersSkippedExisting: number
+}
+
+/**
+ * Run the one-time migration from VSCode ExtensionContext storage to file-backed stores.
+ *
+ * Safe to call on every startup — it checks sentinels and returns immediately
+ * if migration has already been completed at the current version.
+ *
+ * Global state and secrets share one sentinel (in globalState file store).
+ * Workspace state has its own sentinel (in workspaceState file store) so that
+ * each new workspace gets migrated independently.
+ *
+ * @param vscodeContext The VSCode ExtensionContext (source of truth for legacy data)
+ * @param storage The file-backed StorageContext (destination)
+ * @returns Summary of what was migrated
+ */
+export async function exportVSCodeStorageToSharedFiles(
+	vscodeContext: vscode.ExtensionContext,
+	storage: StorageContext,
+): Promise<MigrationResult> {
+	const result: MigrationResult = {
+		migrated: false,
+		globalStateCount: 0,
+		secretsCount: 0,
+		workspaceStateCount: 0,
+		skippedExisting: 0,
+		mcpServersAdded: 0,
+		mcpServersSkippedExisting: 0,
+	}
+
+	// Check sentinels independently
+	const globalVersion = storage.globalState.get<number>(MIGRATION_VERSION_KEY)
+	const workspaceVersion = storage.workspaceState.get<number>(MIGRATION_VERSION_KEY)
+
+	const needGlobalMigration = globalVersion === undefined || globalVersion < FILE_BACKED_STORAGE_EXPORT_VERSION
+	const needWorkspaceMigration = workspaceVersion === undefined || workspaceVersion < FILE_BACKED_STORAGE_EXPORT_VERSION
+	const needMcpSettingsMigration = globalVersion === undefined || globalVersion < MCP_SETTINGS_MIGRATION_VERSION
+
+	if (!needGlobalMigration && !needWorkspaceMigration && !needMcpSettingsMigration) {
+		Logger.info(
+			`[Migration] File-backed stores already current (global: v${globalVersion}, workspace: v${workspaceVersion}), skipping.`,
+		)
+		return result
+	}
+
+	Logger.info(
+		`[Migration] Starting VSCode → file-backed migration (global: ${globalVersion ?? "none"}, workspace: ${workspaceVersion ?? "none"}, target: ${CURRENT_MIGRATION_VERSION})`,
+	)
+
+	try {
+		// ─── 0. Migrate legacy MCP settings files (if needed) ───────────
+		if (needMcpSettingsMigration) {
+			const mcpMigration = await migrateLegacyMcpSettings(vscodeContext, storage)
+			result.mcpServersAdded = mcpMigration.serversAdded
+			result.mcpServersSkippedExisting = mcpMigration.serversSkippedExisting
+		}
+
+		// ─── 1. Migrate global state + secrets (if needed) ─────────────
+		if (needGlobalMigration) {
+			// Batch global state keys
+			const globalStateBatch: Record<string, any> = {}
+			for (const key of GlobalStateAndSettingKeys) {
+				if (SKIP_GLOBAL_STATE_KEYS.has(key)) {
+					continue
+				}
+
+				const vscodeValue = vscodeContext.globalState.get(key)
+				if (vscodeValue === undefined) {
+					continue
+				}
+
+				const existingFileValue = storage.globalState.get(key)
+				if (existingFileValue !== undefined) {
+					result.skippedExisting++
+					continue
+				}
+
+				globalStateBatch[key] = vscodeValue
+				result.globalStateCount++
+			}
+
+			// Add sentinel to batch. This advances straight to CURRENT because the
+			// v2 MCP migration already ran above when needed.
+			globalStateBatch[MIGRATION_VERSION_KEY] = CURRENT_MIGRATION_VERSION
+
+			// Write all global state in one operation
+			storage.globalState.setBatch(globalStateBatch)
+
+			// Batch secrets
+			const secretsBatch: Record<string, string> = {}
+			for (const key of SecretKeys) {
+				try {
+					const vscodeValue = await vscodeContext.secrets.get(key)
+					if (vscodeValue === undefined || vscodeValue === "") {
+						continue
+					}
+
+					const existingFileValue = storage.secrets.get(key)
+					if (existingFileValue !== undefined && existingFileValue !== "") {
+						result.skippedExisting++
+						continue
+					}
+
+					secretsBatch[key] = vscodeValue
+					result.secretsCount++
+				} catch (error) {
+					Logger.error(`[Migration] Failed to read secret '${key}' from VSCode:`, error)
+				}
+			}
+
+			// Write all secrets in one operation
+			storage.secrets.setBatch(secretsBatch)
+		}
+
+		// ─── 2. Migrate workspace state (if needed) ────────────────────
+		if (needWorkspaceMigration) {
+			// Batch workspace state keys
+			const workspaceStateBatch: Record<string, any> = {}
+			for (const key of LocalStateKeys) {
+				const vscodeValue = vscodeContext.workspaceState.get(key)
+				if (vscodeValue === undefined) {
+					continue
+				}
+
+				const existingFileValue = storage.workspaceState.get(key)
+				if (existingFileValue !== undefined) {
+					result.skippedExisting++
+					continue
+				}
+
+				workspaceStateBatch[key] = vscodeValue
+				result.workspaceStateCount++
+			}
+
+			// Add sentinel to batch. This advances straight to CURRENT because any
+			// global v2-only migrations already ran above when needed.
+			workspaceStateBatch[MIGRATION_VERSION_KEY] = CURRENT_MIGRATION_VERSION
+
+			// Write all workspace state in one operation
+			storage.workspaceState.setBatch(workspaceStateBatch)
+		}
+
+		// If the original v1 export was already complete, still advance sentinels
+		// for this workspace after the v2 MCP migration attempt so future startups
+		// don't re-run it. New workspaces still have no workspace sentinel and will
+		// get their v1 workspace-state export when first opened.
+		if (!needGlobalMigration && needMcpSettingsMigration) {
+			storage.globalState.update(MIGRATION_VERSION_KEY, CURRENT_MIGRATION_VERSION)
+		}
+		if (!needWorkspaceMigration && needMcpSettingsMigration) {
+			storage.workspaceState.set(MIGRATION_VERSION_KEY, CURRENT_MIGRATION_VERSION)
+		}
+
+		result.migrated = needGlobalMigration || needWorkspaceMigration || needMcpSettingsMigration || result.mcpServersAdded > 0
+
+		Logger.info(
+			`[Migration] Complete: ${result.globalStateCount} global state keys, ` +
+				`${result.secretsCount} secrets, ${result.workspaceStateCount} workspace state keys migrated. ` +
+				`${result.skippedExisting} keys skipped (already in file store). ` +
+				`Legacy MCP migration added ${result.mcpServersAdded} server(s), skipped ${result.mcpServersSkippedExisting} existing server(s).`,
+		)
+	} catch (error) {
+		Logger.error("[Migration] Fatal error during VSCode → file-backed migration:", error)
+		// Don't write sentinel on failure — migration will retry next startup
+		throw error
+	}
+
+	return result
+}
diff --git a/apps/vscode/src/integrations/diagnostics/__tests__/index.test.ts b/apps/vscode/src/integrations/diagnostics/__tests__/index.test.ts
new file mode 100644
index 0000000..c4be90a
--- /dev/null
+++ b/apps/vscode/src/integrations/diagnostics/__tests__/index.test.ts
@@ -0,0 +1,547 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { DiagnosticSeverity, FileDiagnostics } from "@shared/proto/index.cline"
+import { expect } from "chai"
+import * as sinon from "sinon"
+import * as actualPathUtils from "@/utils/path"
+
+// bun loads real ESM, so sinon cannot stub the `@/utils/path` namespace export
+// ("ES Modules cannot be stubbed"). Inject a module-level sinon stub for
+// `getCwd` via mock.module so the full sinon stub API keeps working.
+const getCwdStub: sinon.SinonStub = sinon.stub()
+const pathUtilsMock = () => ({ ...actualPathUtils, getCwd: getCwdStub })
+mock.module("@/utils/path", pathUtilsMock)
+mock.module("@utils/path", pathUtilsMock)
+
+import { diagnosticsToProblemsString, getNewDiagnostics } from "../"
+
+describe("Diagnostics Tests", () => {
+	describe("getNewDiagnostics", () => {
+		it("should return empty array when both old and new diagnostics are empty", () => {
+			const oldDiagnostics: FileDiagnostics[] = []
+			const newDiagnostics: FileDiagnostics[] = []
+
+			const result = getNewDiagnostics(oldDiagnostics, newDiagnostics)
+
+			expect(result).to.deep.equal([])
+		})
+
+		it("should return all diagnostics when old diagnostics is empty", () => {
+			const oldDiagnostics: FileDiagnostics[] = []
+			const newDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file1",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+
+			const result = getNewDiagnostics(oldDiagnostics, newDiagnostics)
+
+			expect(result).to.deep.equal(newDiagnostics)
+		})
+
+		it("should return empty array when new diagnostics is empty", () => {
+			const oldDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file1",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const newDiagnostics: FileDiagnostics[] = []
+
+			const result = getNewDiagnostics(oldDiagnostics, newDiagnostics)
+
+			expect(result).to.deep.equal([])
+		})
+
+		it("should return only new diagnostics not present in old diagnostics", () => {
+			const oldDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Old error",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const newDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Old error",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+							message: "New warning",
+							range: {
+								start: { line: 5, character: 5 },
+								end: { line: 5, character: 15 },
+							},
+						},
+					],
+				},
+			]
+
+			const result = getNewDiagnostics(oldDiagnostics, newDiagnostics)
+
+			expect(result).to.have.lengthOf(1)
+			expect(result[0].filePath).to.equal("/path/to/file1.ts")
+			expect(result[0].diagnostics).to.have.lengthOf(1)
+			expect(result[0].diagnostics[0].message).to.equal("New warning")
+		})
+
+		it("should handle multiple files correctly", () => {
+			const oldDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file1",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const newDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file1",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+				{
+					filePath: "/path/to/file2.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file2",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+
+			const result = getNewDiagnostics(oldDiagnostics, newDiagnostics)
+
+			expect(result).to.have.lengthOf(1)
+			expect(result[0].filePath).to.equal("/path/to/file2.ts")
+		})
+
+		it("should handle diagnostics with source and code properties", () => {
+			const oldDiagnostics: FileDiagnostics[] = []
+			const newDiagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/path/to/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Type error",
+							source: "typescript",
+							range: {
+								start: { line: 10, character: 5 },
+								end: { line: 10, character: 20 },
+							},
+						},
+					],
+				},
+			]
+
+			const result = getNewDiagnostics(oldDiagnostics, newDiagnostics)
+
+			expect(result).to.deep.equal(newDiagnostics)
+		})
+	})
+
+	describe("diagnosticsToProblemsString", () => {
+		beforeEach(() => {
+			getCwdStub.reset()
+			getCwdStub.resolves("/workspace")
+		})
+
+		afterEach(() => {
+			sinon.restore()
+			getCwdStub.reset()
+		})
+
+		it("should return empty string when diagnostics array is empty", async () => {
+			const diagnostics: FileDiagnostics[] = []
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("")
+		})
+
+		it("should return empty string when no diagnostics match the severity filter", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+							message: "Warning message",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("")
+		})
+
+		it("should format error diagnostics correctly with line numbers", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Type error",
+							range: {
+								start: { line: 9, character: 5 },
+								end: { line: 9, character: 20 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("src/file1.ts\n- [Error] Line 10: Type error")
+		})
+
+		it("should handle diagnostics without range information", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "File-level error",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("src/file1.ts\n- [Error] Line 1: File-level error")
+		})
+
+		it("should handle diagnostics with missing start property in range", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error with partial range",
+							range: {} as any, // Simulating missing start property
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("src/file1.ts\n- [Error] Line : Error with partial range")
+		})
+
+		it("should include source information when available", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Type error",
+							source: "typescript",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("src/file1.ts\n- [typescript Error] Line 1: Type error")
+		})
+
+		it("should handle multiple severities", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error message",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+							message: "Warning message",
+							range: {
+								start: { line: 5, character: 0 },
+								end: { line: 5, character: 10 },
+							},
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_INFORMATION,
+							message: "Info message",
+							range: {
+								start: { line: 10, character: 0 },
+								end: { line: 10, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR, DiagnosticSeverity.DIAGNOSTIC_WARNING]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("src/file1.ts\n- [Error] Line 1: Error message\n- [Warning] Line 6: Warning message")
+		})
+
+		it("should handle multiple files", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file1",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+				{
+					filePath: "/workspace/src/file2.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error in file2",
+							range: {
+								start: { line: 5, character: 0 },
+								end: { line: 5, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal(
+				"src/file1.ts\n- [Error] Line 1: Error in file1\n\nsrc/file2.ts\n- [Error] Line 6: Error in file2",
+			)
+		})
+
+		it("should handle absolute paths outside workspace", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/other/path/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error outside workspace",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal("../other/path/file1.ts\n- [Error] Line 1: Error outside workspace")
+		})
+
+		it("should handle all diagnostic severity types", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error",
+							range: { start: { line: 0, character: 0 }, end: { line: 0, character: 10 } },
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+							message: "Warning",
+							range: { start: { line: 1, character: 0 }, end: { line: 1, character: 10 } },
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_INFORMATION,
+							message: "Information",
+							range: { start: { line: 2, character: 0 }, end: { line: 2, character: 10 } },
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_HINT,
+							message: "Hint",
+							range: { start: { line: 3, character: 0 }, end: { line: 3, character: 10 } },
+						},
+					],
+				},
+			]
+			const severities = [
+				DiagnosticSeverity.DIAGNOSTIC_ERROR,
+				DiagnosticSeverity.DIAGNOSTIC_WARNING,
+				DiagnosticSeverity.DIAGNOSTIC_INFORMATION,
+				DiagnosticSeverity.DIAGNOSTIC_HINT,
+			]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			expect(result).to.equal(
+				"src/file1.ts\n- [Error] Line 1: Error\n- [Warning] Line 2: Warning\n- [Information] Line 3: Information\n- [Hint] Line 4: Hint",
+			)
+		})
+
+		it("should handle edge case with line number 0", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error on first line",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+					],
+				},
+			]
+			const severities = [DiagnosticSeverity.DIAGNOSTIC_ERROR]
+
+			const result = await diagnosticsToProblemsString(diagnostics, severities)
+
+			// Line 0 should be displayed as Line 1 (1-indexed)
+			expect(result).to.equal("src/file1.ts\n- [Error] Line 1: Error on first line")
+		})
+
+		it("should include all diagnostics when severities is undefined", async () => {
+			const diagnostics: FileDiagnostics[] = [
+				{
+					filePath: "/workspace/src/file1.ts",
+					diagnostics: [
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_ERROR,
+							message: "Error message",
+							range: {
+								start: { line: 0, character: 0 },
+								end: { line: 0, character: 10 },
+							},
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_WARNING,
+							message: "Warning message",
+							range: {
+								start: { line: 1, character: 0 },
+								end: { line: 1, character: 10 },
+							},
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_INFORMATION,
+							message: "Info message",
+							range: {
+								start: { line: 2, character: 0 },
+								end: { line: 2, character: 10 },
+							},
+						},
+						{
+							severity: DiagnosticSeverity.DIAGNOSTIC_HINT,
+							message: "Hint message",
+							range: {
+								start: { line: 3, character: 0 },
+								end: { line: 3, character: 10 },
+							},
+						},
+					],
+				},
+			]
+
+			// Call without severities parameter (undefined)
+			const result = await diagnosticsToProblemsString(diagnostics)
+
+			// Should include all diagnostics regardless of severity
+			expect(result).to.equal(
+				"src/file1.ts\n- [Error] Line 1: Error message\n- [Warning] Line 2: Warning message\n- [Information] Line 3: Info message\n- [Hint] Line 4: Hint message",
+			)
+		})
+	})
+})
diff --git a/apps/vscode/src/integrations/diagnostics/index.ts b/apps/vscode/src/integrations/diagnostics/index.ts
new file mode 100644
index 0000000..e099fa8
--- /dev/null
+++ b/apps/vscode/src/integrations/diagnostics/index.ts
@@ -0,0 +1,77 @@
+import deepEqual from "fast-deep-equal"
+import * as path from "path"
+import { Diagnostic, DiagnosticSeverity, FileDiagnostics } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { getCwd } from "@/utils/path"
+
+export function getNewDiagnostics(oldDiagnostics: FileDiagnostics[], newDiagnostics: FileDiagnostics[]): FileDiagnostics[] {
+	const oldMap = new Map<string, Diagnostic[]>()
+	for (const diag of oldDiagnostics) {
+		oldMap.set(diag.filePath, diag.diagnostics)
+	}
+
+	const newProblems: FileDiagnostics[] = []
+	for (const newDiags of newDiagnostics) {
+		const oldDiags = oldMap.get(newDiags.filePath) || []
+		const newProblemsForFile = newDiags.diagnostics.filter(
+			(newDiag) => !oldDiags.some((oldDiag) => deepEqual(oldDiag, newDiag)),
+		)
+
+		if (newProblemsForFile.length > 0) {
+			newProblems.push({ filePath: newDiags.filePath, diagnostics: newProblemsForFile })
+		}
+	}
+
+	return newProblems
+}
+
+// will return empty string if no problems with the given severity are found
+export async function diagnosticsToProblemsString(
+	diagnostics: FileDiagnostics[],
+	severities?: DiagnosticSeverity[],
+): Promise<string> {
+	const results = []
+	for (const fileDiagnostics of diagnostics) {
+		const problems = fileDiagnostics.diagnostics.filter((d) => !severities || severities.includes(d.severity))
+		const problemString = await singleFileDiagnosticsToProblemsString(fileDiagnostics.filePath, problems)
+		if (problemString) {
+			results.push(problemString)
+		}
+	}
+	return results.join("\n\n")
+}
+
+export async function singleFileDiagnosticsToProblemsString(filePath: string, diagnostics: Diagnostic[]): Promise<string> {
+	if (!diagnostics.length) {
+		return ""
+	}
+	const cwd = await getCwd()
+	const relPath = path.relative(cwd, filePath).toPosix()
+	let result = `${relPath}`
+
+	for (const diagnostic of diagnostics) {
+		const label = severityToString(diagnostic.severity)
+		// Lines are 0-indexed
+		const line = diagnostic.range?.start ? `${diagnostic.range.start.line + 1}` : ""
+
+		const source = diagnostic.source ? `${diagnostic.source} ` : ""
+		result += `\n- [${source}${label}] Line ${line}: ${diagnostic.message}`
+	}
+	return result
+}
+
+function severityToString(severity: DiagnosticSeverity): string {
+	switch (severity) {
+		case DiagnosticSeverity.DIAGNOSTIC_ERROR:
+			return "Error"
+		case DiagnosticSeverity.DIAGNOSTIC_WARNING:
+			return "Warning"
+		case DiagnosticSeverity.DIAGNOSTIC_INFORMATION:
+			return "Information"
+		case DiagnosticSeverity.DIAGNOSTIC_HINT:
+			return "Hint"
+		default:
+			Logger.warn("Unhandled diagnostic severity level:", severity)
+			return "Diagnostic"
+	}
+}
diff --git a/apps/vscode/src/integrations/editor/CommentReviewController.ts b/apps/vscode/src/integrations/editor/CommentReviewController.ts
new file mode 100644
index 0000000..a106f5b
--- /dev/null
+++ b/apps/vscode/src/integrations/editor/CommentReviewController.ts
@@ -0,0 +1,94 @@
+/**
+ * Represents a review comment from the AI
+ */
+export interface ReviewComment {
+	/** Absolute path to the file */
+	filePath: string
+	/** 0-indexed start line of the code this comment applies to */
+	startLine: number
+	/** 0-indexed end line of the code this comment applies to */
+	endLine: number
+	/** The comment text (supports markdown) */
+	comment: string
+	/** Optional label for the comment type */
+	label?: string
+	/** Relative path for virtual URI (e.g., "src/file.ts") */
+	relativePath?: string
+	/** File content for virtual URI (encoded in query string) */
+	fileContent?: string
+}
+
+/**
+ * Abstract base class for managing AI code review comments.
+ *
+ * This controller:
+ * - Creates inline comment threads on files at specific line ranges
+ * - Displays AI-generated review comments with markdown support
+ * - Manages the lifecycle of all comment threads
+ *
+ * Platform-specific implementations handle the actual UI rendering.
+ */
+export abstract class CommentReviewController {
+	/**
+	 * Ensure the comments view won't auto-open when comments are added
+	 */
+	abstract ensureCommentsViewDisabled(): Promise<void>
+
+	/**
+	 * Add a review comment to a file
+	 */
+	abstract addReviewComment(comment: ReviewComment): void
+
+	/**
+	 * Start a streaming review comment - creates the thread immediately with placeholder text
+	 * @param revealComment - If true, opens the document and scrolls to show the comment
+	 */
+	abstract startStreamingComment(
+		filePath: string,
+		startLine: number,
+		endLine: number,
+		relativePath?: string,
+		fileContent?: string,
+		revealComment?: boolean,
+	): void
+
+	/**
+	 * Append text to the currently streaming comment
+	 */
+	abstract appendToStreamingComment(chunk: string): void
+
+	/**
+	 * End the current streaming comment
+	 */
+	abstract endStreamingComment(): void
+
+	/**
+	 * Add multiple review comments at once
+	 */
+	abstract addReviewComments(comments: ReviewComment[]): void
+
+	/**
+	 * Clear all review comments
+	 */
+	abstract clearAllComments(): void
+
+	/**
+	 * Clear comments for a specific file
+	 */
+	abstract clearCommentsForFile(filePath: string): void
+
+	/**
+	 * Get the number of active comment threads
+	 */
+	abstract getThreadCount(): number
+
+	/**
+	 * Close all diff views associated with comments
+	 */
+	abstract closeDiffViews(): Promise<void>
+
+	/**
+	 * Dispose of all resources
+	 */
+	abstract dispose(): void
+}
diff --git a/apps/vscode/src/integrations/editor/DiffViewProvider.ts b/apps/vscode/src/integrations/editor/DiffViewProvider.ts
new file mode 100644
index 0000000..83af0d2
--- /dev/null
+++ b/apps/vscode/src/integrations/editor/DiffViewProvider.ts
@@ -0,0 +1,509 @@
+import { formatResponse } from "@core/prompts/responses"
+import { workspaceResolver } from "@core/workspace"
+import { createDirectoriesForFile } from "@utils/fs"
+import { getCwd } from "@utils/path"
+import * as diff from "diff"
+import * as fs from "fs/promises"
+import * as iconv from "iconv-lite"
+import { HostProvider } from "@/hosts/host-provider"
+import { diagnosticsToProblemsString, getNewDiagnostics } from "@/integrations/diagnostics"
+import { DiagnosticSeverity, FileDiagnostics } from "@/shared/proto/index.cline"
+import { Logger } from "@/shared/services/Logger"
+import { detectEncoding } from "../misc/extract-text"
+import { sanitizeNotebookForLLM } from "../misc/notebook-utils"
+import { openFile } from "../misc/open-file"
+
+export abstract class DiffViewProvider {
+	editType?: "create" | "modify" | "delete"
+	isEditing = false
+	originalContent: string | undefined
+	private createdDirs: string[] = []
+	protected documentWasOpen = false
+	private preDiagnostics: FileDiagnostics[] = []
+	protected relPath?: string
+	protected absolutePath?: string
+	protected fileEncoding: string = "utf8"
+	private streamedLines: string[] = []
+	private newContent?: string
+
+	constructor() {}
+
+	public async open(relPath: string, options?: { displayPath?: string }): Promise<void> {
+		this.isEditing = true
+		const cwd = await getCwd()
+		const absolutePathResolved = workspaceResolver.resolveWorkspacePath(cwd, relPath, "DiffViewProvider.open.absolutePath")
+		this.absolutePath = typeof absolutePathResolved === "string" ? absolutePathResolved : absolutePathResolved.absolutePath
+		this.relPath = options?.displayPath ?? relPath
+		const fileExists = this.editType === "modify"
+
+		// if the file is already open, ensure it's not dirty before getting its contents
+		if (fileExists) {
+			await HostProvider.workspace.saveOpenDocumentIfDirty({
+				filePath: this.absolutePath!,
+			})
+
+			const fileBuffer = await fs.readFile(this.absolutePath)
+			this.fileEncoding = await detectEncoding(fileBuffer)
+			this.originalContent = iconv.decode(fileBuffer, this.fileEncoding)
+		} else {
+			this.originalContent = ""
+			this.fileEncoding = "utf8"
+		}
+		// for new files, create any necessary directories and keep track of new directories to delete if the user denies the operation
+		this.createdDirs = await createDirectoriesForFile(this.absolutePath)
+		// make sure the file exists before we open it
+		if (!fileExists) {
+			await fs.writeFile(this.absolutePath, "")
+		}
+		// get diagnostics before editing the file, we'll compare to diagnostics after editing to see if cline needs to fix anything
+		this.preDiagnostics = (await HostProvider.workspace.getDiagnostics({})).fileDiagnostics
+		await this.openDiffEditor()
+		await this.scrollEditorToLine(0)
+		this.streamedLines = []
+	}
+
+	/**
+	 * Opens a diff editor or viewer for the current file.
+	 *
+	 * Called automatically by the `open` method after ensuring the file exists and
+	 * creating any necessary directories.
+	 *
+	 * @returns A promise that resolves when the diff editor is open and ready
+	 */
+	protected abstract openDiffEditor(): Promise<void>
+
+	/**
+	 * Scrolls the diff editor to reveal a specific line.
+	 *
+	 * It's used during streaming updates to keep the user's view focused on the changing content.
+	 *
+	 * @param line The 0-based line number to scroll to
+	 */
+	protected abstract scrollEditorToLine(line: number): Promise<void>
+
+	/**
+	 * Creates a smooth scrolling animation between two lines in the diff editor.
+	 *
+	 * It's typically used when updates contain many lines, to help the user visually track the flow
+	 * of significant changes in the document.
+	 *
+	 * @param startLine The 0-based line number to begin the animation from
+	 * @param endLine The 0-based line number to animate to
+	 */
+	protected abstract scrollAnimation(startLine: number, endLine: number): Promise<void>
+
+	/**
+	 * Removes content from the specified line to the end of the document.
+	 * Called after the final update is received.
+	 */
+	protected abstract truncateDocument(lineNumber: number): Promise<void>
+
+	/**
+	 * Returns the current line count of the document being edited.
+	 * Used for boundary validation before calling truncateDocument.
+	 */
+	protected abstract getDocumentLineCount(): Promise<number>
+
+	/**
+	 * Safely truncates the document, ensuring the line number is within bounds.
+	 * This prevents errors on hosts that strictly validate line numbers (e.g., JetBrains via gRPC).
+	 */
+	private async safelyTruncateDocument(lineNumber: number): Promise<void> {
+		const lineCount = await this.getDocumentLineCount()
+		// Only truncate if there's content beyond the specified line
+		if (lineNumber < lineCount) {
+			await this.truncateDocument(lineNumber)
+		}
+	}
+
+	/**
+	 * Get the contents of the diff editor document.
+	 *
+	 * Returns undefined if the diff editor was closed.
+	 */
+	protected abstract getDocumentText(): Promise<string | undefined>
+
+	/**
+	 * Get any new diagnostic problems that appeared after applying the diff.
+	 *
+	 * Getting diagnostics before and after the file edit is a better approach than
+	 * automatically tracking problems in real-time. This method ensures we only
+	 * report new problems that are a direct result of this specific edit.
+	 * Since these are new problems resulting from Cline's edit, we know they're
+	 * directly related to the work he's doing. This eliminates the risk of Cline
+	 * going off-task or getting distracted by unrelated issues, which was a problem
+	 * with the previous auto-debug approach. Some users' machines may be slow to
+	 * update diagnostics, so this approach provides a good balance between automation
+	 * and avoiding potential issues where Cline might get stuck in loops due to
+	 * outdated problem information. If no new problems show up by the time the user
+	 * accepts the changes, they can always debug later using the '@problems' mention.
+	 * This way, Cline only becomes aware of new problems resulting from his edits
+	 * and can address them accordingly. If problems don't change immediately after
+	 * applying a fix, Cline won't be notified, which is generally fine since the
+	 * initial fix is usually correct and it may just take time for linters to catch up.
+	 */
+	private async getNewDiagnosticProblems(): Promise<string> {
+		// Get the diagnostics after changing the document.
+		const postDiagnostics = (await HostProvider.workspace.getDiagnostics({})).fileDiagnostics
+
+		const newProblems = getNewDiagnostics(this.preDiagnostics, postDiagnostics)
+		// Only including errors since warnings can be distracting (if user wants to fix warnings they can use the @problems mention)
+		// will be empty string if no errors
+		const problems = await diagnosticsToProblemsString(newProblems, [DiagnosticSeverity.DIAGNOSTIC_ERROR])
+		return problems
+	}
+
+	/**
+	 * Save the contents of the diff editor UI to the file.
+	 *
+	 * @returns true if the file was saved.
+	 */
+	protected abstract saveDocument(): Promise<Boolean>
+
+	/**
+	 * Closes all open diff views.
+	 */
+	protected abstract closeAllDiffViews(): Promise<void>
+
+	/**
+	 * Cleans up the diff view resources and resets internal state.
+	 */
+	protected abstract resetDiffView(): Promise<void>
+
+	/**
+	 * Switches to a specialized editor for specific file types after final content is available.
+	 * Called automatically by the `update` method when `isFinal` is true.
+	 *
+	 * For example, switches to Jupyter notebook editor for .ipynb files to provide
+	 * enhanced editing experience with proper notebook cell rendering.
+	 *
+	 * Default is no-op. Subclasses can override to provide specialized behavior.
+	 */
+	protected async switchToSpecializedEditor(): Promise<void> {
+		// Default no-op - subclasses can override if needed
+	}
+
+	private lastUpdateContentLength = -1
+	private lastUpdateTime = 0
+	private static readonly UPDATE_THROTTLE_MS = 100 // Throttle updates to max 10/second during streaming
+
+	async update(
+		accumulatedContent: string,
+		isFinal: boolean,
+		changeLocation?: { startLine: number; endLine: number; startChar: number; endChar: number },
+	) {
+		if (!this.isEditing) {
+			throw new Error("Not editing any file")
+		}
+
+		// Throttle updates during streaming to prevent performance issues with large files
+		// This is especially important for notebooks where streaming can trigger thousands of calls
+		if (!isFinal) {
+			const now = Date.now()
+			const contentLength = accumulatedContent.length
+			const timeSinceLastUpdate = now - this.lastUpdateTime
+
+			// Skip if: no content, content unchanged, or throttle period not elapsed
+			if (contentLength === 0 || contentLength === this.lastUpdateContentLength) {
+				return
+			}
+			if (timeSinceLastUpdate < DiffViewProvider.UPDATE_THROTTLE_MS) {
+				return // Throttle: too soon since last update
+			}
+
+			this.lastUpdateContentLength = contentLength
+			this.lastUpdateTime = now
+		}
+
+		// --- Fix to prevent duplicate BOM ---
+		// Strip potential BOM from incoming content. VS Code's `applyEdit` might implicitly handle the BOM
+		// when replacing from the start (0,0), and we want to avoid duplication.
+		// Final BOM is handled in `saveChanges`.
+		if (accumulatedContent.startsWith("\ufeff")) {
+			accumulatedContent = accumulatedContent.slice(1) // Remove the BOM character
+		}
+
+		this.newContent = accumulatedContent
+		const accumulatedLines = accumulatedContent.split("\n")
+		if (!isFinal) {
+			accumulatedLines.pop() // remove the last partial line only if it's not the final update
+		}
+		const diffLines = accumulatedLines.slice(this.streamedLines.length)
+
+		// Instead of animating each line, we'll update in larger chunks
+		const currentLine = this.streamedLines.length + diffLines.length - 1
+		if (currentLine >= 0) {
+			// Only proceed if we have new lines
+
+			// Replace all content up to the current line with accumulated lines
+			// This is necessary (as compared to inserting one line at a time) to handle cases where html tags
+			// on previous lines are auto closed for example
+			let contentToReplace = accumulatedLines.slice(0, currentLine + 1).join("\n")
+			if (!isFinal) {
+				// During streaming, add trailing newline for cursor positioning
+				contentToReplace += "\n"
+			}
+
+			// For the final update, replace the entire document to prevent concatenation
+			// when content doesn't end with a newline. Without this, replacing lines 0-N
+			// with content lacking a trailing newline causes line N+1's content to be
+			// directly appended to our content (e.g., "Hello World" + "# Old Header" becomes
+			// "Hello World# Old Header").
+			const endLine = isFinal ? await this.getDocumentLineCount() : currentLine + 1
+
+			const rangeToReplace = { startLine: 0, endLine }
+			await this.replaceText(contentToReplace, rangeToReplace, currentLine)
+
+			// Scroll to the actual change location if provided.
+			if (changeLocation) {
+				// We have the actual location of the change, scroll to it
+				const targetLine = changeLocation.startLine
+				await this.scrollEditorToLine(targetLine)
+			} else {
+				// Fallback to the old logic for non-replacement updates
+				if (diffLines.length <= 5) {
+					// For small changes, just jump directly to the line
+					await this.scrollEditorToLine(currentLine)
+				} else {
+					// For larger changes, create a quick scrolling animation
+					const startLine = this.streamedLines.length
+					const endLine = currentLine
+					await this.scrollAnimation(startLine, endLine)
+					// Ensure we end at the final line
+					await this.scrollEditorToLine(currentLine)
+				}
+			}
+		}
+
+		// Update the streamedLines with the new accumulated content
+		this.streamedLines = accumulatedLines
+		if (isFinal) {
+			// Handle any remaining lines if the new content is shorter than the original
+			await this.safelyTruncateDocument(this.streamedLines.length)
+			// Allow subclasses to perform cleanup (e.g., clearing decorations)
+			await this.onFinalUpdate()
+			// Switch to specialized editor for specific file types (e.g., Jupyter notebooks)
+			await this.switchToSpecializedEditor()
+		}
+	}
+
+	/**
+	 * Called after the final update is complete. Subclasses can override to perform cleanup.
+	 */
+	protected async onFinalUpdate(): Promise<void> {
+		// Default no-op
+	}
+
+	async showFile(absolutePath: string): Promise<void> {
+		await openFile(absolutePath, true)
+	}
+
+	/**
+	 * Replaces text in the diff editor with the specified content.
+	 *
+	 * This abstract method must be implemented by subclasses to handle the actual
+	 * text replacement in their specific diff editor implementation. It's called
+	 * during the streaming update process to progressively show changes.
+	 *
+	 * @param content The new content to insert into the document
+	 * @param rangeToReplace An object specifying the line range to replace
+	 * @param currentLine The current line number being edited, used for scroll positioning
+	 * @returns A promise that resolves when the text replacement is complete
+	 */
+	abstract replaceText(
+		content: string,
+		rangeToReplace: { startLine: number; endLine: number },
+		currentLine: number | undefined,
+	): Promise<void>
+
+	/**
+	 * Checks if the current file is a Jupyter notebook file.
+	 *
+	 * @returns true if the file has .ipynb extension
+	 */
+	protected isNotebookFile(): boolean {
+		return this.relPath?.toLowerCase().endsWith(".ipynb") ?? false
+	}
+
+	/**
+	 * Returns the original content sanitized for LLM context.
+	 * For notebooks, strips all outputs since they aren't needed for editing.
+	 */
+	getOriginalContentForLLM(): string | undefined {
+		if (this.originalContent === undefined) return undefined
+		return this.isNotebookFile() ? sanitizeNotebookForLLM(this.originalContent, true) : this.originalContent
+	}
+
+	async saveChanges(): Promise<{
+		newProblemsMessage: string | undefined
+		userEdits: string | undefined
+		autoFormattingEdits: string | undefined
+		finalContent: string | undefined
+	}> {
+		// get the contents before save operation which may do auto-formatting
+		const preSaveContent = await this.getDocumentText()
+
+		if (!this.relPath || !this.absolutePath || !this.newContent || preSaveContent === undefined) {
+			return {
+				newProblemsMessage: undefined,
+				userEdits: undefined,
+				autoFormattingEdits: undefined,
+				finalContent: undefined,
+			}
+		}
+
+		await this.saveDocument()
+		// get text after save in case there is any auto-formatting done by the editor
+		const postSaveContent = (await this.getDocumentText()) || ""
+
+		await this.showFile(this.absolutePath)
+		await this.closeAllDiffViews()
+
+		const newProblems = await this.getNewDiagnosticProblems()
+		const newProblemsMessage =
+			newProblems.length > 0 ? `\n\nNew problems detected after saving the file:\n${newProblems}` : ""
+
+		// If the edited content has different EOL characters, we don't want to show a diff with all the EOL differences.
+		const newContentEOL = this.newContent.includes("\r\n") ? "\r\n" : "\n"
+		const normalizedPreSaveContent = preSaveContent.replace(/\r\n|\n/g, newContentEOL).trimEnd() + newContentEOL // trimEnd to fix issue where editor adds in extra new line automatically
+		const normalizedPostSaveContent = postSaveContent.replace(/\r\n|\n/g, newContentEOL).trimEnd() + newContentEOL // this is the final content we return to the model to use as the new baseline for future edits
+		// just in case the new content has a mix of varying EOL characters
+		const normalizedNewContent = this.newContent.replace(/\r\n|\n/g, newContentEOL).trimEnd() + newContentEOL
+
+		let userEdits: string | undefined
+		if (normalizedPreSaveContent !== normalizedNewContent) {
+			// user made changes before approving edit. let the model know about user made changes (not including post-save auto-formatting changes)
+			userEdits = formatResponse.createPrettyPatch(this.relPath.toPosix(), normalizedNewContent, normalizedPreSaveContent)
+			// return { newProblemsMessage, userEdits, finalContent: normalizedPostSaveContent }
+		} else {
+			// no changes to cline's edits
+			// return { newProblemsMessage, userEdits: undefined, finalContent: normalizedPostSaveContent }
+		}
+
+		let autoFormattingEdits: string | undefined
+		if (normalizedPreSaveContent !== normalizedPostSaveContent) {
+			// auto-formatting was done by the editor
+			autoFormattingEdits = formatResponse.createPrettyPatch(
+				this.relPath.toPosix(),
+				normalizedPreSaveContent,
+				normalizedPostSaveContent,
+			)
+		}
+
+		// Strip notebook outputs to reduce context size (outputs aren't needed for editing)
+		const finalContent = this.isNotebookFile()
+			? sanitizeNotebookForLLM(normalizedPostSaveContent, true)
+			: normalizedPostSaveContent
+
+		return {
+			newProblemsMessage,
+			userEdits,
+			autoFormattingEdits,
+			finalContent,
+		}
+	}
+
+	async revertChanges(): Promise<void> {
+		if (!this.absolutePath || !this.isEditing) {
+			return
+		}
+		const fileExists = this.editType === "modify"
+
+		if (!fileExists) {
+			// This is a load-bearing save statement- even though the file is saved and then immediately deleted.
+			// In vscode, it will not close the diff editor correctly if the file is not saved.
+			await this.saveDocument()
+			await this.closeAllDiffViews()
+			await fs.rm(this.absolutePath, { force: true })
+			Logger.log(`File ${this.absolutePath} has been deleted.`)
+
+			// Remove only the directories we created, in reverse order
+			for (let i = this.createdDirs.length - 1; i >= 0; i--) {
+				try {
+					await fs.rmdir(this.createdDirs[i])
+					Logger.log(`Directory ${this.createdDirs[i]} has been deleted.`)
+				} catch (error) {
+					Logger.log(`Could not delete directory ${this.createdDirs[i]}`, error)
+				}
+			}
+		} else {
+			// revert document
+			// Apply the edit and save, since contents shouldn't have changed this won't show in local history unless of
+			// course the user made changes and saved during the edit.
+			const contents = (await this.getDocumentText()) || ""
+			const lineCount = (contents.match(/\n/g) || []).length + 1
+			await this.replaceText(this.originalContent ?? "", { startLine: 0, endLine: lineCount }, undefined)
+
+			await this.saveDocument()
+			Logger.log(`File ${this.absolutePath} has been reverted to its original content.`)
+			if (this.documentWasOpen) {
+				openFile(this.absolutePath, true)
+			}
+			await this.closeAllDiffViews()
+		}
+
+		// edit is done
+		await this.reset()
+	}
+
+	async scrollToFirstDiff() {
+		if (!this.isEditing) {
+			return
+		}
+		const currentContent = (await this.getDocumentText()) || ""
+		const diffs = diff.diffLines(this.originalContent || "", currentContent)
+		let lineCount = 0
+		for (const part of diffs) {
+			if (part.added || part.removed) {
+				// Found the first diff, scroll to it
+				this.scrollEditorToLine(lineCount)
+				return
+			}
+			if (!part.removed) {
+				lineCount += part.count || 0
+			}
+		}
+	}
+
+	async deleteFile(fileName: string) {
+		const fileLocation = this.absolutePath
+		if (!fileLocation?.endsWith(fileName) || !this.isEditing) {
+			return
+		}
+
+		// Close diff views before deleting the file
+		await this.closeAllDiffViews()
+
+		// Delete the file
+		try {
+			await fs.rm(fileLocation, { force: true })
+			Logger.log(`File ${fileLocation} has been deleted.`)
+		} catch (error) {
+			Logger.error(`Failed to delete file ${fileLocation}:`, error)
+		}
+
+		this.isEditing = false
+		this.newContent = undefined
+	}
+
+	// close editor if open?
+	async reset() {
+		this.isEditing = false
+		this.editType = undefined
+		this.absolutePath = undefined
+		this.relPath = undefined
+		this.preDiagnostics = []
+
+		this.originalContent = undefined
+		this.fileEncoding = "utf8"
+		this.documentWasOpen = false
+
+		this.streamedLines = []
+		this.createdDirs = []
+		this.newContent = undefined
+		this.lastUpdateContentLength = -1
+		this.lastUpdateTime = 0
+
+		await this.resetDiffView()
+	}
+}
diff --git a/apps/vscode/src/integrations/editor/__tests__/DiffViewProvider.test.ts b/apps/vscode/src/integrations/editor/__tests__/DiffViewProvider.test.ts
new file mode 100644
index 0000000..ba4756c
--- /dev/null
+++ b/apps/vscode/src/integrations/editor/__tests__/DiffViewProvider.test.ts
@@ -0,0 +1,511 @@
+import { describe, it } from "bun:test"
+import * as assert from "assert"
+import { DiffViewProvider } from "../DiffViewProvider"
+
+class TestBoundaryDiffViewProvider extends DiffViewProvider {
+	public documentText: string = ""
+	public truncatedAt: number | undefined
+
+	async openDiffEditor(): Promise<void> {}
+	async scrollEditorToLine(line: number): Promise<void> {}
+	async scrollAnimation(startLine: number, endLine: number): Promise<void> {}
+
+	async truncateDocument(lineNumber: number): Promise<void> {
+		this.truncatedAt = lineNumber
+		const lines = this.documentText.split("\n")
+		if (lineNumber < lines.length) {
+			this.documentText = lines.slice(0, lineNumber).join("\n")
+		}
+	}
+
+	async getDocumentLineCount(): Promise<number> {
+		return this.documentText.split("\n").length
+	}
+
+	async getDocumentText(): Promise<string | undefined> {
+		return this.documentText
+	}
+
+	async saveDocument(): Promise<boolean> {
+		return true
+	}
+	async closeAllDiffViews(): Promise<void> {}
+	async resetDiffView(): Promise<void> {}
+
+	async replaceText(
+		content: string,
+		rangeToReplace: { startLine: number; endLine: number },
+		currentLine: number | undefined,
+	): Promise<void> {
+		// Minimal implementation for update() to work
+		const lines = this.documentText.split("\n")
+
+		// Check if we're replacing to the end of the document
+		const replacingToEnd = rangeToReplace.endLine >= lines.length
+
+		const newLines = content.split("\n")
+
+		// Remove trailing empty line for proper splicing, BUT only when NOT replacing
+		// to the end of the document. When replacing to the end, keep the trailing
+		// empty string to preserve trailing newlines from the content.
+		if (!replacingToEnd && newLines[newLines.length - 1] === "") {
+			newLines.pop()
+		}
+
+		lines.splice(rangeToReplace.startLine, rangeToReplace.endLine - rangeToReplace.startLine, ...newLines)
+		this.documentText = lines.join("\n")
+	}
+
+	public setup(initialContent: string) {
+		this.isEditing = true
+		this.documentText = initialContent
+		this.originalContent = initialContent
+		this.truncatedAt = undefined
+	}
+}
+
+describe("DiffViewProvider Boundary Validation", () => {
+	it("should replace entire document on final update to prevent concatenation", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Start with multi-line content
+		provider.setup("line1\nline2\nline3\n")
+
+		// Update with content that has no trailing newline
+		// This previously caused "Hello World" + "line2" concatenation
+		await provider.update("Hello World", true)
+
+		const result = await provider.getDocumentText()
+		// Should be just "Hello World", not "Hello Worldline2\nline3\n"
+		assert.strictEqual(result, "Hello World")
+	})
+
+	it("safelyTruncateDocument should no-op when lineNumber >= lineCount", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("line1\nline2\nline3")
+		// lineCount is 3
+
+		// Access private method via any cast or just call update which calls it
+		// But update calls it with streamedLines.length.
+		// Let's use update to trigger it.
+
+		// If we update with same content, streamedLines.length will be 3.
+		// safelyTruncateDocument(3) should be called.
+		// 3 >= 3, so it should NOT call truncateDocument.
+
+		await provider.update("line1\nline2\nline3", true)
+
+		assert.strictEqual(provider.truncatedAt, undefined, "Should not have called truncateDocument")
+	})
+
+	it("final update replaces entire document so truncation is no-op", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("line1\nline2\nline3")
+
+		// Update with fewer lines
+		await provider.update("line1\n", true)
+
+		// With the fix, the final update replaces the entire document (0 to lineCount).
+		// So replaceText handles all the content, and truncation becomes unnecessary.
+		// The document should contain just "line1\n" and truncation should NOT be called
+		// because after replaceText, the document already has the correct content.
+
+		// Note: truncation might still be called but should be a no-op since document is already correct
+		assert.strictEqual(provider.documentText, "line1\n")
+	})
+
+	it("update() with shorter content replaces entire document", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("line1\nline2\nline3\nline4")
+
+		// Update with 2 lines
+		await provider.update("line1\nline2", true)
+
+		// With the fix, the final update replaces the entire document (0 to lineCount).
+		// The document should contain just "line1\nline2".
+
+		assert.strictEqual(provider.documentText, "line1\nline2")
+	})
+})
+
+describe("DiffViewProvider content finalization with isFinal=true", () => {
+	// Tests verifying that update(content, true) properly finalizes the document.
+	// This is the fix for the approval flow bug: FileProviderOperations now always
+	// passes isFinal=true to update() to ensure proper document finalization.
+
+	it("should handle large file with deleted lines (1000 -> 997 lines)", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original file has 1000 lines
+		const originalLines = Array.from({ length: 1000 }, (_, i) => `line${i + 1}`).join("\n")
+		provider.setup(originalLines)
+
+		// New content has 997 lines (simulating deleted lines 994-996)
+		const newContent = [
+			...Array.from({ length: 993 }, (_, i) => `line${i + 1}`),
+			"line997",
+			"line998",
+			"line999",
+			"line1000",
+		].join("\n")
+
+		// Update with isFinal=true ensures proper document finalization
+		// (full range replacement + truncation)
+		await provider.update(newContent, true)
+
+		const result = await provider.getDocumentText()
+		const resultLines = result?.split("\n") || []
+
+		// Should have exactly 997 lines matching newContent, no duplicates
+		assert.strictEqual(resultLines.length, 997, "Should have 997 lines")
+
+		// First lines should match
+		assert.strictEqual(resultLines[0], "line1")
+		assert.strictEqual(resultLines[992], "line993")
+
+		// Last 4 lines should be line997-line1000, not duplicated
+		assert.strictEqual(resultLines[993], "line997")
+		assert.strictEqual(resultLines[994], "line998")
+		assert.strictEqual(resultLines[995], "line999")
+		assert.strictEqual(resultLines[996], "line1000")
+	})
+
+	it("should handle simple content reduction (4 -> 2 lines)", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("line1\nline2\nline3\nline4")
+
+		await provider.update("newA\nnewB", true)
+
+		const result = await provider.getDocumentText()
+		// Should be just "newA\nnewB", not corrupted with old content
+		assert.strictEqual(result, "newA\nnewB")
+	})
+
+	it("should preserve trailing newline when reducing content", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("line1\nline2\nline3\n")
+
+		await provider.update("new1\nnew2\n", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "new1\nnew2\n", "Should preserve trailing newline")
+	})
+})
+
+describe("DiffViewProvider Update Throttling", () => {
+	// Tests for the throttling added in PR #8785 to prevent performance issues
+	// during streaming, especially with large files like notebooks.
+	//
+	// Note: The update() method processes complete lines during streaming.
+	// Content must contain newlines for replaceText to be called during streaming.
+	// Only the final line (without trailing newline) is deferred until isFinal=true.
+
+	class ThrottleTestDiffViewProvider extends DiffViewProvider {
+		public documentText: string = ""
+		public replaceTextCallCount = 0
+
+		async openDiffEditor(): Promise<void> {}
+		async scrollEditorToLine(_line: number): Promise<void> {}
+		async scrollAnimation(_startLine: number, _endLine: number): Promise<void> {}
+		async truncateDocument(_lineNumber: number): Promise<void> {}
+
+		async getDocumentLineCount(): Promise<number> {
+			return this.documentText.split("\n").length
+		}
+
+		async getDocumentText(): Promise<string | undefined> {
+			return this.documentText
+		}
+
+		async saveDocument(): Promise<boolean> {
+			return true
+		}
+		async closeAllDiffViews(): Promise<void> {}
+		async resetDiffView(): Promise<void> {}
+
+		async replaceText(
+			content: string,
+			_rangeToReplace: { startLine: number; endLine: number },
+			_currentLine: number | undefined,
+		): Promise<void> {
+			this.replaceTextCallCount++
+			this.documentText = content
+		}
+
+		public setup(initialContent: string) {
+			this.isEditing = true
+			this.documentText = initialContent
+			this.originalContent = initialContent
+			this.replaceTextCallCount = 0
+		}
+	}
+
+	it("should skip empty content during streaming", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial content\n")
+
+		await provider.update("", false) // empty, not final
+
+		assert.strictEqual(provider.replaceTextCallCount, 0, "Should not call replaceText for empty content")
+	})
+
+	it("should skip unchanged content length during streaming", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// First update with complete line goes through
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Second update with same length should be skipped
+		await provider.update("abcde\n", false) // same length (6)
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Should skip update with same content length")
+	})
+
+	it("should throttle rapid updates during streaming", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// First update with complete line goes through
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Rapid subsequent updates with increasing length should be throttled
+		await provider.update("line1\nab", false)
+		await provider.update("line1\nabc", false)
+		await provider.update("line1\nabcd", false)
+
+		// All should be throttled since they happen within 100ms
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Rapid updates should be throttled")
+	})
+
+	it("should allow update after throttle period", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// First update
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Wait for throttle period to elapse
+		await new Promise((resolve) => setTimeout(resolve, 110))
+
+		// Next update should go through
+		await provider.update("line1\nline2\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 2, "Update after throttle period should go through")
+	}, 500)
+
+	it("should always process final updates regardless of throttling", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// First update
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Final update should bypass throttling even with same length
+		await provider.update("line1\nend", true)
+		assert.strictEqual(provider.replaceTextCallCount, 2, "Final update should bypass throttling")
+	})
+
+	it("should process final update even with empty content", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial content\n")
+
+		// Empty final update still processes - it replaces with empty content
+		// (file cleared). The throttle check is bypassed for isFinal=true.
+		await provider.update("", true)
+
+		// Empty content splits to [""], which is still processed as a line
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Empty final update should be processed")
+	})
+
+	it("should process final update even with same content length", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// First update
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Final update with same length should still go through
+		await provider.update("abcde\n", true) // same length (6)
+		assert.strictEqual(provider.replaceTextCallCount, 2, "Final update should bypass length check")
+	})
+
+	it("should reset throttle state on reset()", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// First update
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Rapid update with larger content should be throttled
+		await provider.update("line1\nline2\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Should be throttled before reset")
+
+		// Reset clears throttle state
+		await provider.reset()
+
+		// Re-setup for next test
+		provider.setup("initial\n")
+
+		// Update immediately after reset should go through (throttle state cleared)
+		await provider.update("newcontent\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Update after reset should go through immediately")
+	}, 500)
+
+	it("should allow first update to go through immediately", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("initial\n")
+
+		// Very first update should always go through
+		await provider.update("content\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1, "First update should not be throttled")
+	})
+
+	it("should handle streaming simulation with many rapid updates", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("")
+
+		// Simulate rapid streaming with complete lines (like notebook editing)
+		// Each iteration adds a new line
+		for (let i = 1; i <= 100; i++) {
+			const content = Array.from({ length: i }, (_, j) => `line${j + 1}`).join("\n") + "\n"
+			await provider.update(content, false)
+		}
+
+		// Due to throttling, should have far fewer than 100 replaceText calls
+		// First call always happens, rest are throttled
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Should throttle rapid streaming updates")
+
+		// Wait for throttle to elapse
+		await new Promise((resolve) => setTimeout(resolve, 110))
+
+		// Next update goes through
+		const contentAfterWait = Array.from({ length: 100 }, (_, j) => `line${j + 1}`).join("\n") + "\nfinal line\n"
+		await provider.update(contentAfterWait, false)
+		assert.strictEqual(provider.replaceTextCallCount, 2, "Update after throttle should go through")
+
+		// Final update always goes through
+		await provider.update(contentAfterWait + "end", true)
+		assert.strictEqual(provider.replaceTextCallCount, 3, "Final update should go through")
+	}, 500)
+
+	it("should throttle by time regardless of content length changes", async () => {
+		const provider = new ThrottleTestDiffViewProvider()
+		provider.setup("")
+
+		// First update
+		await provider.update("line1\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1)
+
+		// Immediate update with longer content - still throttled by time
+		await provider.update("line1\nline2\nline3\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 1, "Should still throttle by time even with different length")
+
+		// Wait for throttle
+		await new Promise((resolve) => setTimeout(resolve, 110))
+
+		// Now should go through
+		await provider.update("line1\nline2\nline3\nline4\n", false)
+		assert.strictEqual(provider.replaceTextCallCount, 2, "Should update after throttle period")
+	}, 500)
+})
+
+describe("DiffViewProvider Newline Preservation", () => {
+	it("preserves trailing newline when content ends with newline", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original file has trailing newline
+		provider.setup("line1\nline2\n")
+
+		// New content also has trailing newline
+		await provider.update("new1\nnew2\n", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "new1\nnew2\n", "Trailing newline should be preserved")
+		assert.strictEqual(result?.endsWith("\n"), true)
+	})
+
+	it("does not add trailing newline when content does not end with newline", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original file has trailing newline
+		provider.setup("line1\nline2\n")
+
+		// New content does NOT have trailing newline
+		await provider.update("new1\nnew2", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "new1\nnew2", "Should not have trailing newline")
+		assert.strictEqual(result?.endsWith("\n"), false)
+	})
+
+	it("adds trailing newline when content ends with newline but original did not", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original file does NOT have trailing newline
+		provider.setup("line1\nline2")
+
+		// New content has trailing newline
+		await provider.update("new1\nnew2\n", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "new1\nnew2\n", "Should add trailing newline")
+		assert.strictEqual(result?.endsWith("\n"), true)
+	})
+
+	it("preserves no trailing newline when neither original nor new content has one", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original file does NOT have trailing newline
+		provider.setup("line1\nline2")
+
+		// New content also does NOT have trailing newline
+		await provider.update("new1\nnew2", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "new1\nnew2", "Should not have trailing newline")
+		assert.strictEqual(result?.endsWith("\n"), false)
+	})
+
+	it("handles shortening file while preserving trailing newline", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original: 10 lines with trailing newline
+		provider.setup("line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10\n")
+
+		// New: 3 lines with trailing newline
+		await provider.update("line1\nline2\nline3\n", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "line1\nline2\nline3\n", "Should shorten and preserve trailing newline")
+	})
+
+	it("handles lengthening file while preserving trailing newline", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		// Original: 3 lines with trailing newline
+		provider.setup("line1\nline2\nline3\n")
+
+		// New: 5 lines with trailing newline
+		await provider.update("line1\nline2\nline3\nline4\nline5\n", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "line1\nline2\nline3\nline4\nline5\n", "Should lengthen and preserve trailing newline")
+	})
+
+	it("handles single line content with trailing newline", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("old content\n")
+
+		await provider.update("Hello World\n", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "Hello World\n")
+	})
+
+	it("handles single line content without trailing newline", async () => {
+		const provider = new TestBoundaryDiffViewProvider()
+		provider.setup("old content\nline2\n")
+
+		await provider.update("Hello World", true)
+
+		const result = await provider.getDocumentText()
+		assert.strictEqual(result, "Hello World")
+	})
+})
diff --git a/apps/vscode/src/integrations/misc/extract-text.ts b/apps/vscode/src/integrations/misc/extract-text.ts
new file mode 100644
index 0000000..3b4a4bf
--- /dev/null
+++ b/apps/vscode/src/integrations/misc/extract-text.ts
@@ -0,0 +1,224 @@
+import ExcelJS from "exceljs"
+import fs from "fs/promises"
+import * as iconv from "iconv-lite"
+import { isBinaryFile } from "isbinaryfile"
+import * as chardet from "jschardet"
+import mammoth from "mammoth"
+import * as path from "path"
+// @ts-expect-error-next-line
+import pdf from "pdf-parse/lib/pdf-parse"
+import { truncateContent } from "@/shared/content-limits"
+import { Logger } from "@/shared/services/Logger"
+import { sanitizeNotebookForLLM } from "./notebook-utils"
+
+export async function detectEncoding(fileBuffer: Buffer, fileExtension?: string): Promise<string> {
+	const detected = chardet.detect(fileBuffer)
+	if (typeof detected === "string") {
+		return detected
+	}
+	if (detected && (detected as any).encoding) {
+		return (detected as any).encoding
+	}
+	if (fileExtension) {
+		const isBinary = await isBinaryFile(fileBuffer).catch(() => false)
+		if (isBinary) {
+			throw new Error(`Cannot read text for file type: ${fileExtension}`)
+		}
+	}
+	return "utf8"
+}
+
+export async function extractTextFromFile(filePath: string): Promise<string> {
+	try {
+		await fs.access(filePath)
+	} catch (_error) {
+		throw new Error(`File not found: ${filePath}`)
+	}
+
+	return callTextExtractionFunctions(filePath)
+}
+
+/**
+ * Expects the fs.access call to have already been performed prior to calling.
+ * Content is automatically truncated if it exceeds 400KB to prevent context overflow.
+ */
+async function callTextExtractionFunctions(filePath: string): Promise<string> {
+	const fileExtension = path.extname(filePath).toLowerCase()
+
+	let content: string
+
+	switch (fileExtension) {
+		case ".pdf":
+			content = await extractTextFromPDF(filePath)
+			break
+		case ".docx":
+			content = await extractTextFromDOCX(filePath)
+			break
+		case ".ipynb":
+			content = await extractTextFromIPYNB(filePath)
+			break
+		case ".xlsx":
+			content = await extractTextFromExcel(filePath)
+			break
+		default:
+			// Check file size with stat() first - faster than reading entire file for size check
+			const fileStat = await fs.stat(filePath)
+			if (fileStat.size > 20 * 1000 * 1024) {
+				// 20MB limit (20 * 1000 * 1024 bytes, decimal MB)
+				throw new Error(`File is too large to read into context.`)
+			}
+			const fileBuffer = await fs.readFile(filePath)
+			const encoding = await detectEncoding(fileBuffer, fileExtension)
+			content = iconv.decode(fileBuffer, encoding)
+	}
+
+	// Truncate content if it exceeds 400KB to prevent context overflow
+	return truncateContent(content)
+}
+
+async function extractTextFromPDF(filePath: string): Promise<string> {
+	const dataBuffer = await fs.readFile(filePath)
+	const data = await pdf(dataBuffer)
+	return data.text
+}
+
+async function extractTextFromDOCX(filePath: string): Promise<string> {
+	const result = await mammoth.extractRawText({ path: filePath })
+	return result.value
+}
+
+async function extractTextFromIPYNB(filePath: string): Promise<string> {
+	const fileBuffer = await fs.readFile(filePath)
+	const encoding = await detectEncoding(fileBuffer)
+	const data = iconv.decode(fileBuffer, encoding)
+
+	// Strip all outputs to reduce context size - outputs aren't needed for understanding
+	// notebook structure. For Jupyter commands, the specific cell's outputs are included
+	// separately via sanitizeCellForLLM which preserves text outputs.
+	return sanitizeNotebookForLLM(data, true)
+}
+
+/**
+ * Format the data inside Excel cells
+ */
+function formatCellValue(cell: ExcelJS.Cell): string {
+	const value = cell.value
+	if (value === null || value === undefined) {
+		return ""
+	}
+
+	// Handle error values (#DIV/0!, #N/A, etc.)
+	if (typeof value === "object" && "error" in value) {
+		return `[Error: ${value.error}]`
+	}
+
+	// Handle dates - ExcelJS can parse them as Date objects
+	if (value instanceof Date) {
+		return value.toISOString().split("T")[0] // Just the date part
+	}
+
+	// Handle rich text
+	if (typeof value === "object" && "richText" in value) {
+		return value.richText.map((rt) => rt.text).join("")
+	}
+
+	// Handle hyperlinks
+	if (typeof value === "object" && "text" in value && "hyperlink" in value) {
+		return `${value.text} (${value.hyperlink})`
+	}
+
+	// Handle formulas - get the calculated result
+	if (typeof value === "object" && "formula" in value) {
+		if ("result" in value && value.result !== undefined && value.result !== null) {
+			return value.result.toString()
+		}
+		return `[Formula: ${value.formula}]`
+	}
+
+	return value.toString()
+}
+
+/**
+ * Extract and format text from xlsx files
+ */
+async function extractTextFromExcel(filePath: string): Promise<string> {
+	const workbook = new ExcelJS.Workbook()
+	let excelText = ""
+
+	try {
+		await workbook.xlsx.readFile(filePath)
+
+		workbook.eachSheet((worksheet, _sheetId) => {
+			// Skip hidden sheets
+			if (worksheet.state === "hidden" || worksheet.state === "veryHidden") {
+				return
+			}
+
+			excelText += `--- Sheet: ${worksheet.name} ---\n`
+
+			worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
+				// Optional: limit processing for very large sheets
+				if (rowNumber > 50000) {
+					excelText += `[... truncated at row ${rowNumber} ...]\n`
+					return false
+				}
+
+				const rowTexts: string[] = []
+				let hasContent = false
+
+				row.eachCell({ includeEmpty: true }, (cell, _colNumber) => {
+					const cellText = formatCellValue(cell)
+					if (cellText.trim()) {
+						hasContent = true
+					}
+					rowTexts.push(cellText)
+				})
+
+				// Only add rows with actual content
+				if (hasContent) {
+					excelText += rowTexts.join("\t") + "\n"
+				}
+
+				return true
+			})
+
+			excelText += "\n" // Blank line between sheets
+		})
+
+		return excelText.trim()
+	} catch (error: any) {
+		Logger.error(`Error extracting text from Excel ${filePath}:`, error)
+		throw new Error(`Failed to extract text from Excel: ${error.message}`)
+	}
+}
+
+/**
+ * Helper function used to load file(s) and format them into a string
+ */
+export async function processFilesIntoText(files: string[]): Promise<string> {
+	const fileContentsPromises = files.map(async (filePath) => {
+		try {
+			// Check if file exists and is binary
+			//const isBinary = await isBinaryFile(filePath).catch(() => false)
+			//if (isBinary) {
+			//	return `<file_content path="${filePath.toPosix()}">\n(Binary file, unable to display content)\n</file_content>`
+			//}
+			const content = await extractTextFromFile(filePath)
+			return `<file_content path="${filePath.toPosix()}">\n${content}\n</file_content>`
+		} catch (error) {
+			Logger.error(`Error processing file ${filePath}:`, error)
+			return `<file_content path="${filePath.toPosix()}">\nError fetching content: ${error.message}\n</file_content>`
+		}
+	})
+
+	const fileContents = await Promise.all(fileContentsPromises)
+
+	const validFileContents = fileContents.filter((content) => content !== null).join("\n\n")
+
+	if (validFileContents) {
+		return `Files attached by the user:\n\n${validFileContents}`
+	}
+
+	// returns empty string if no files were loaded properly
+	return ""
+}
diff --git a/apps/vscode/src/integrations/misc/link-preview.ts b/apps/vscode/src/integrations/misc/link-preview.ts
new file mode 100644
index 0000000..6e8dd79
--- /dev/null
+++ b/apps/vscode/src/integrations/misc/link-preview.ts
@@ -0,0 +1,109 @@
+import axios from "axios"
+import ogs from "open-graph-scraper"
+import { fetch, getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+
+export interface OpenGraphData {
+	title?: string
+	description?: string
+	image?: string
+	url?: string
+	siteName?: string
+	type?: string
+}
+
+/**
+ * Fetches Open Graph metadata from a URL
+ * @param url The URL to fetch metadata from
+ * @returns Promise resolving to OpenGraphData
+ */
+export async function fetchOpenGraphData(url: string): Promise<OpenGraphData> {
+	try {
+		const options = {
+			url: url,
+			timeout: 5000,
+			headers: {
+				"user-agent": "Mozilla/5.0 (compatible; VSCodeExtension/1.0; +https://cline.bot)",
+			},
+			onlyGetOpenGraphInfo: false, // Get all metadata, not just Open Graph
+			fetchOptions: {
+				redirect: "follow", // Follow redirects
+			} as any,
+			fetch, // Use configured fetch with proxy support
+		}
+
+		const { result } = await ogs(options)
+
+		// Use type assertion to avoid TypeScript errors
+		const data = result as any
+
+		// Handle image URLs
+		let imageUrl = data.ogImage?.[0]?.url || data.twitterImage?.[0]?.url
+
+		// If the image URL is relative, make it absolute
+		if (imageUrl && (imageUrl.startsWith("/") || imageUrl.startsWith("./"))) {
+			try {
+				// Extract the base URL and make the relative URL absolute
+				const urlObj = new URL(url)
+				const baseUrl = `${urlObj.protocol}//${urlObj.hostname}`
+				imageUrl = new URL(imageUrl, baseUrl).href
+			} catch (error) {
+				Logger.error(`Error converting relative URL to absolute: ${imageUrl}`, error)
+			}
+		}
+
+		return {
+			title: data.ogTitle || data.twitterTitle || data.dcTitle || data.title || new URL(url).hostname,
+			description:
+				data.ogDescription ||
+				data.twitterDescription ||
+				data.dcDescription ||
+				data.description ||
+				"No description available",
+			image: imageUrl,
+			url: data.ogUrl || url,
+			siteName: data.ogSiteName || new URL(url).hostname,
+			type: data.ogType,
+		}
+	} catch (_error) {
+		// Return basic information based on the URL
+		try {
+			const urlObj = new URL(url)
+			return {
+				title: urlObj.hostname,
+				description: url,
+				url: url,
+				siteName: urlObj.hostname,
+			}
+		} catch {
+			return {
+				title: url,
+				description: url,
+				url: url,
+			}
+		}
+	}
+}
+
+/**
+ * Checks if a URL is an image by making a HEAD request and checking the content type
+ * @param url The URL to check
+ * @returns Promise resolving to boolean indicating if the URL is an image
+ */
+export async function detectImageUrl(url: string): Promise<boolean> {
+	try {
+		const response = await axios.head(url, {
+			headers: {
+				"User-Agent": "Mozilla/5.0 (compatible; VSCodeExtension/1.0; +https://cline.bot)",
+			},
+			timeout: 3000,
+			...getAxiosSettings(),
+		})
+
+		const contentType = response.headers["content-type"]
+		return !!contentType && typeof contentType === "string" && contentType.startsWith("image/")
+	} catch (_error) {
+		// If we can't determine, fall back to checking the file extension
+		return /\.(jpg|jpeg|png|gif|webp|bmp|svg|tiff|tif|avif)$/i.test(url)
+	}
+}
diff --git a/apps/vscode/src/integrations/misc/notebook-utils.ts b/apps/vscode/src/integrations/misc/notebook-utils.ts
new file mode 100644
index 0000000..4b844d1
--- /dev/null
+++ b/apps/vscode/src/integrations/misc/notebook-utils.ts
@@ -0,0 +1,87 @@
+/**
+ * Shared utilities for processing Jupyter notebooks for LLM context.
+ * Used by both the context menu commands (addToCline, etc.) and file reading (extract-text.ts).
+ */
+
+/**
+ * Image MIME types that should be truncated in notebook outputs
+ */
+const IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/svg+xml", "image/webp"]
+
+/**
+ * Sanitizes the outputs of a single notebook cell by truncating image data.
+ * Keeps text outputs intact for context, only replaces binary image data with placeholders.
+ *
+ * @param cell A notebook cell object
+ * @returns The cell with sanitized outputs
+ */
+function sanitizeCellOutputs(cell: Record<string, unknown>): Record<string, unknown> {
+	if (cell.cell_type !== "code" || !cell.outputs || !Array.isArray(cell.outputs)) {
+		return cell
+	}
+
+	const sanitizedOutputs = cell.outputs.map((output: Record<string, unknown>) => {
+		// Handle display_data and execute_result outputs with data field
+		if (output.data && typeof output.data === "object") {
+			const data = output.data as Record<string, unknown>
+			const sanitizedData = { ...data }
+
+			for (const mimeType of IMAGE_MIME_TYPES) {
+				if (mimeType in sanitizedData) {
+					sanitizedData[mimeType] = "[IMAGE DATA TRUNCATED]"
+				}
+			}
+
+			return { ...output, data: sanitizedData }
+		}
+		return output
+	})
+
+	return { ...cell, outputs: sanitizedOutputs }
+}
+
+/**
+ * Sanitizes a Jupyter notebook JSON for LLM context.
+ *
+ * @param jsonString The raw notebook JSON string
+ * @param stripAllOutputs If true, removes all outputs entirely. If false (default),
+ *                        only truncates image data while keeping text outputs.
+ *                        Use true for write responses where outputs aren't needed.
+ *                        Use false for reads where text outputs provide useful context.
+ * @returns Sanitized JSON string
+ */
+export function sanitizeNotebookForLLM(jsonString: string, stripAllOutputs = false): string {
+	try {
+		const notebook = JSON.parse(jsonString)
+
+		if (!notebook.cells || !Array.isArray(notebook.cells)) {
+			return jsonString
+		}
+
+		if (stripAllOutputs) {
+			notebook.cells = notebook.cells.map((cell: Record<string, unknown>) => ({
+				...cell,
+				outputs: cell.cell_type === "code" ? [] : cell.outputs,
+			}))
+		} else {
+			notebook.cells = notebook.cells.map((cell: Record<string, unknown>) => sanitizeCellOutputs(cell))
+		}
+
+		return JSON.stringify(notebook, null, 1)
+	} catch {
+		// If parsing fails, return original string
+		return jsonString
+	}
+}
+
+/**
+ * Sanitizes a single notebook cell object and returns it as a JSON string.
+ * Used by context menu commands that work with individual cells.
+ *
+ * @param cell A notebook cell object
+ * @returns JSON string of the sanitized cell
+ */
+export function sanitizeCellForLLM(cell: Record<string, unknown>): string {
+	const sanitized = sanitizeCellOutputs(cell)
+	return JSON.stringify(sanitized, null, 2)
+}
diff --git a/apps/vscode/src/integrations/misc/open-file.ts b/apps/vscode/src/integrations/misc/open-file.ts
new file mode 100644
index 0000000..b62d481
--- /dev/null
+++ b/apps/vscode/src/integrations/misc/open-file.ts
@@ -0,0 +1,44 @@
+import { writeFile } from "@utils/fs"
+import * as os from "os"
+import * as path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+
+export async function openImage(dataUri: string) {
+	const matches = dataUri.match(/^data:image\/([a-zA-Z]+);base64,(.+)$/)
+	if (!matches) {
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: "Invalid data URI format",
+		})
+		return
+	}
+	const [, format, base64Data] = matches
+	const imageBuffer = Buffer.from(base64Data, "base64")
+	const tempFilePath = path.join(os.tmpdir(), `temp_image_${Date.now()}.${format}`)
+	try {
+		await writeFile(tempFilePath, new Uint8Array(imageBuffer))
+		await HostProvider.window.openFile({
+			filePath: tempFilePath,
+		})
+	} catch (error) {
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Error opening image: ${error}`,
+		})
+	}
+}
+
+export async function openFile(absolutePath: string, preserveFocus: boolean = false, preview: boolean = false) {
+	try {
+		await HostProvider.window.showTextDocument({
+			path: absolutePath,
+			options: { preserveFocus, preview },
+		})
+	} catch (_error) {
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Could not open file!`,
+		})
+	}
+}
diff --git a/apps/vscode/src/integrations/misc/process-files.ts b/apps/vscode/src/integrations/misc/process-files.ts
new file mode 100644
index 0000000..f95c1a2
--- /dev/null
+++ b/apps/vscode/src/integrations/misc/process-files.ts
@@ -0,0 +1,118 @@
+import fs from "fs/promises"
+import sizeOf from "image-size"
+import * as path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Supports processing of images and other file types
+ * For models which don't support images, will not allow them to be selected
+ */
+export async function selectFiles(imagesAllowed: boolean): Promise<{ images: string[]; files: string[] }> {
+	const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "webp"] // supported by anthropic and openrouter
+	const OTHER_FILE_EXTENSIONS = ["xml", "json", "txt", "log", "md", "docx", "ipynb", "pdf", "xlsx", "csv"]
+
+	const showDialogueResponse = await HostProvider.window.showOpenDialogue({
+		canSelectMany: true,
+		openLabel: "Select",
+		filters: {
+			files: imagesAllowed ? [...IMAGE_EXTENSIONS, ...OTHER_FILE_EXTENSIONS] : OTHER_FILE_EXTENSIONS,
+		},
+	})
+
+	const filePaths = showDialogueResponse.paths
+
+	if (!filePaths || filePaths.length === 0) {
+		return { images: [], files: [] }
+	}
+
+	const processFilesPromises = filePaths.map(async (filePath) => {
+		const fileExtension = path.extname(filePath).toLowerCase().substring(1)
+
+		const isImage = IMAGE_EXTENSIONS.includes(fileExtension)
+
+		if (isImage) {
+			let buffer: Buffer
+			try {
+				// Read the file into a buffer first
+				buffer = await fs.readFile(filePath)
+				// Convert Node.js Buffer to Uint8Array
+				const uint8Array = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+				const dimensions = sizeOf(uint8Array) // Get dimensions from Uint8Array
+				if (dimensions.width! > 7680 || dimensions.height! > 7680) {
+					Logger.warn(`Image dimensions exceed 7500px, skipping: ${filePath}`)
+					HostProvider.window.showMessage({
+						type: ShowMessageType.ERROR,
+						message: `Image too large: ${path.basename(filePath)} was skipped (dimensions exceed 7500px).`,
+					})
+					return null
+				}
+			} catch (error) {
+				Logger.error(`Error reading file or getting dimensions for ${filePath}:`, error)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: `Could not read dimensions for ${path.basename(filePath)}, skipping.`,
+				})
+				return null
+			}
+
+			// If dimensions are valid, proceed to convert the existing buffer to base64
+			const base64 = buffer.toString("base64")
+			const mimeType = getMimeType(filePath)
+
+			return { type: "image", data: `data:${mimeType};base64,${base64}` }
+		}
+		// for standard models we will check the size of the file to ensure its not too large
+		try {
+			const stats = await fs.stat(filePath)
+			if (stats.size > 20 * 1000 * 1024) {
+				Logger.warn(`File too large, skipping: ${filePath}`)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: `File too large: ${path.basename(filePath)} was skipped (size exceeds 20MB).`,
+				})
+				return null
+			}
+		} catch (error) {
+			Logger.error(`Error checking file size for ${filePath}:`, error)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Could not check file size for ${path.basename(filePath)}, skipping.`,
+			})
+			return null
+		}
+		return { type: "file", data: filePath }
+	})
+
+	const dataUrlsWithNulls = await Promise.all(processFilesPromises)
+	const dataUrlsWithoutNulls = dataUrlsWithNulls.filter((item) => item !== null)
+
+	const images: string[] = []
+	const files: string[] = []
+
+	for (const item of dataUrlsWithoutNulls) {
+		if (item.type === "image") {
+			images.push(item.data)
+		} else {
+			files.push(item.data)
+		}
+	}
+
+	return { images, files }
+}
+
+function getMimeType(filePath: string): string {
+	const ext = path.extname(filePath).toLowerCase()
+	switch (ext) {
+		case ".png":
+			return "image/png"
+		case ".jpeg":
+		case ".jpg":
+			return "image/jpeg"
+		case ".webp":
+			return "image/webp"
+		default:
+			throw new Error(`Unsupported file type: ${ext}`)
+	}
+}
diff --git a/apps/vscode/src/integrations/openai-codex/oauth.ts b/apps/vscode/src/integrations/openai-codex/oauth.ts
new file mode 100644
index 0000000..c0914e6
--- /dev/null
+++ b/apps/vscode/src/integrations/openai-codex/oauth.ts
@@ -0,0 +1,811 @@
+import * as crypto from "crypto"
+import * as http from "http"
+import { URL } from "url"
+import { z } from "zod"
+import { StateManager } from "@/core/storage/StateManager"
+import { fetch } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * OpenAI Codex OAuth Configuration
+ *
+ * Based on the OpenAI Codex OAuth implementation:
+ * - ISSUER: https://auth.openai.com
+ * - Authorization endpoint: https://auth.openai.com/oauth/authorize
+ * - Token endpoint: https://auth.openai.com/oauth/token
+ * - Fixed callback port: 1455
+ * - Codex-specific params: codex_cli_simplified_flow=true, originator=cline
+ */
+const OPENAI_CODEX_OAUTH_CONFIG = {
+	authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
+	tokenEndpoint: "https://auth.openai.com/oauth/token",
+	clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+	redirectUri: "http://localhost:1455/auth/callback",
+	scopes: "openid profile email offline_access",
+	callbackPort: 1455,
+} as const
+
+type ProviderSettingsManager = {
+	getProviderSettings(providerId: string):
+		| {
+				provider?: string
+				auth?: {
+					accessToken?: string
+					refreshToken?: string
+					expiresAt?: number
+					accountId?: string
+					email?: string
+				}
+		  }
+		| undefined
+	saveProviderSettings(
+		settings: {
+			provider: string
+			auth?: {
+				accessToken?: string
+				refreshToken?: string
+				expiresAt?: number
+				accountId?: string
+				email?: string
+			}
+		},
+		options?: { tokenSource?: "manual" | "oauth" | "migration" },
+	): void
+}
+
+async function getSdkProviderSettingsManager(): Promise<ProviderSettingsManager | null> {
+	try {
+		const { getProviderSettingsManager } = await import("@/sdk/provider-migration")
+		return getProviderSettingsManager() as ProviderSettingsManager
+	} catch (error) {
+		Logger.warn("[openai-codex-oauth] SDK provider settings unavailable:", error)
+		return null
+	}
+}
+
+// Credentials schema
+const openAiCodexCredentialsSchema = z.object({
+	type: z.literal("openai-codex"),
+	access_token: z.string().min(1),
+	refresh_token: z.string().min(1),
+	// expires is in milliseconds since epoch
+	expires: z.number(),
+	email: z.string().optional(),
+	// ChatGPT account ID extracted from JWT claims (for ChatGPT-Account-Id header)
+	accountId: z.string().optional(),
+})
+
+type OpenAiCodexCredentials = z.infer<typeof openAiCodexCredentialsSchema>
+
+function providerSettingsToCredentials(
+	settings: NonNullable<ReturnType<ProviderSettingsManager["getProviderSettings"]>>,
+): OpenAiCodexCredentials | null {
+	const auth = settings.auth
+	if (!auth?.accessToken || !auth.refreshToken) {
+		return null
+	}
+
+	return openAiCodexCredentialsSchema.parse({
+		type: "openai-codex",
+		access_token: auth.accessToken,
+		refresh_token: auth.refreshToken,
+		// Older SDK-backed sign-ins wrote providers.json without expiresAt.
+		// Treat those credentials as expired so the next API request refreshes
+		// them and rewrites both storage locations with complete metadata.
+		expires: auth.expiresAt ?? 0,
+		email: auth.email,
+		accountId: auth.accountId,
+	})
+}
+
+async function loadCredentialsFromProviderSettings(): Promise<OpenAiCodexCredentials | null> {
+	try {
+		const manager = await getSdkProviderSettingsManager()
+		const settings = manager?.getProviderSettings("openai-codex")
+		return settings ? providerSettingsToCredentials(settings) : null
+	} catch (error) {
+		Logger.error("[openai-codex-oauth] Failed to load provider settings credentials:", error)
+		return null
+	}
+}
+
+async function saveCredentialsToProviderSettings(credentials: OpenAiCodexCredentials): Promise<void> {
+	const manager = await getSdkProviderSettingsManager()
+	if (!manager) {
+		return
+	}
+
+	const existing = manager.getProviderSettings("openai-codex")
+	manager.saveProviderSettings(
+		{
+			...(existing ?? { provider: "openai-codex" }),
+			provider: "openai-codex",
+			auth: {
+				...(existing?.auth ?? {}),
+				accessToken: credentials.access_token,
+				refreshToken: credentials.refresh_token,
+				expiresAt: credentials.expires,
+				accountId: credentials.accountId,
+				email: credentials.email,
+			},
+		},
+		{ tokenSource: "oauth" },
+	)
+}
+
+async function clearCredentialsFromProviderSettings(): Promise<void> {
+	const manager = await getSdkProviderSettingsManager()
+	if (!manager) {
+		return
+	}
+
+	const existing = manager.getProviderSettings("openai-codex")
+	if (!existing) {
+		return
+	}
+
+	manager.saveProviderSettings(
+		{
+			...existing,
+			provider: "openai-codex",
+			auth: undefined,
+		},
+		{ tokenSource: "manual" },
+	)
+}
+
+// Token response schema from OpenAI
+const tokenResponseSchema = z.object({
+	access_token: z.string(),
+	refresh_token: z.string().min(1).optional(),
+	id_token: z.string().optional(),
+	expires_in: z.number(),
+	email: z.string().optional(),
+	token_type: z.string().optional(),
+})
+
+/**
+ * JWT claims structure for extracting ChatGPT account ID
+ */
+interface IdTokenClaims {
+	chatgpt_account_id?: string
+	organizations?: Array<{ id: string }>
+	email?: string
+	"https://api.openai.com/auth"?: {
+		chatgpt_account_id?: string
+	}
+}
+
+/**
+ * Parse JWT claims from a token
+ * Returns undefined if the token is invalid or cannot be parsed
+ */
+function parseJwtClaims(token: string): IdTokenClaims | undefined {
+	const parts = token.split(".")
+	if (parts.length !== 3) return undefined
+	try {
+		// Use base64url decoding (Node.js Buffer handles this)
+		const payload = Buffer.from(parts[1], "base64url").toString("utf-8")
+		return JSON.parse(payload) as IdTokenClaims
+	} catch {
+		return undefined
+	}
+}
+
+/**
+ * Extract ChatGPT account ID from JWT claims
+ * Checks multiple locations:
+ * 1. Root-level chatgpt_account_id
+ * 2. Nested under https://api.openai.com/auth
+ * 3. First organization ID
+ */
+function extractAccountIdFromClaims(claims: IdTokenClaims): string | undefined {
+	return claims.chatgpt_account_id || claims["https://api.openai.com/auth"]?.chatgpt_account_id || claims.organizations?.[0]?.id
+}
+
+/**
+ * Extract ChatGPT account ID from token response
+ * Tries id_token first, then access_token
+ */
+function extractAccountId(tokens: { id_token?: string; access_token: string }): string | undefined {
+	// Try id_token first (more reliable source)
+	if (tokens.id_token) {
+		const claims = parseJwtClaims(tokens.id_token)
+		const accountId = claims && extractAccountIdFromClaims(claims)
+		if (accountId) return accountId
+	}
+	// Fall back to access_token
+	if (tokens.access_token) {
+		const claims = parseJwtClaims(tokens.access_token)
+		return claims ? extractAccountIdFromClaims(claims) : undefined
+	}
+	return undefined
+}
+
+class OpenAiCodexOAuthTokenError extends Error {
+	public readonly status?: number
+	public readonly errorCode?: string
+
+	constructor(message: string, opts?: { status?: number; errorCode?: string }) {
+		super(message)
+		this.name = "OpenAiCodexOAuthTokenError"
+		this.status = opts?.status
+		this.errorCode = opts?.errorCode
+	}
+
+	public isLikelyInvalidGrant(): boolean {
+		if (this.errorCode && /invalid_grant/i.test(this.errorCode)) {
+			return true
+		}
+		if (this.status === 400 || this.status === 401 || this.status === 403) {
+			return /invalid_grant|revoked|expired|invalid refresh/i.test(this.message)
+		}
+		return false
+	}
+}
+
+function parseOAuthErrorDetails(errorText: string): { errorCode?: string; errorMessage?: string } {
+	try {
+		const json: unknown = JSON.parse(errorText)
+		if (!json || typeof json !== "object") {
+			return {}
+		}
+
+		const obj = json as Record<string, unknown>
+		const errorField = obj.error
+
+		const errorCode: string | undefined =
+			typeof errorField === "string"
+				? errorField
+				: errorField && typeof errorField === "object" && typeof (errorField as Record<string, unknown>).type === "string"
+					? ((errorField as Record<string, unknown>).type as string)
+					: undefined
+
+		const errorDescription = obj.error_description
+		const errorMessageFromError =
+			errorField && typeof errorField === "object" ? (errorField as Record<string, unknown>).message : undefined
+
+		const errorMessage: string | undefined =
+			typeof errorDescription === "string"
+				? errorDescription
+				: typeof errorMessageFromError === "string"
+					? errorMessageFromError
+					: typeof obj.message === "string"
+						? obj.message
+						: undefined
+
+		return { errorCode, errorMessage }
+	} catch {
+		return {}
+	}
+}
+
+/**
+ * Generates a cryptographically random PKCE code verifier
+ * Must be 43-128 characters long using unreserved characters
+ */
+function generateCodeVerifier(): string {
+	const buffer = crypto.randomBytes(32)
+	return buffer.toString("base64url")
+}
+
+/**
+ * Generates the PKCE code challenge from the verifier using S256 method
+ */
+function generateCodeChallenge(verifier: string): string {
+	const hash = crypto.createHash("sha256").update(verifier).digest()
+	return hash.toString("base64url")
+}
+
+/**
+ * Generates a random state parameter for CSRF protection
+ */
+function generateState(): string {
+	return crypto.randomBytes(16).toString("hex")
+}
+
+/**
+ * Builds the authorization URL for OpenAI Codex OAuth flow
+ * Includes Codex-specific parameters per the implementation guide
+ */
+function buildAuthorizationUrl(codeChallenge: string, state: string): string {
+	const params = new URLSearchParams({
+		client_id: OPENAI_CODEX_OAUTH_CONFIG.clientId,
+		redirect_uri: OPENAI_CODEX_OAUTH_CONFIG.redirectUri,
+		scope: OPENAI_CODEX_OAUTH_CONFIG.scopes,
+		code_challenge: codeChallenge,
+		code_challenge_method: "S256",
+		response_type: "code",
+		state,
+		// Codex-specific parameters
+		codex_cli_simplified_flow: "true",
+		originator: "cline",
+	})
+
+	return `${OPENAI_CODEX_OAUTH_CONFIG.authorizationEndpoint}?${params.toString()}`
+}
+
+/**
+ * Exchanges the authorization code for tokens
+ * Important: Uses application/x-www-form-urlencoded (not JSON)
+ * Important: state must NOT be included in token exchange body
+ */
+async function exchangeCodeForTokens(code: string, codeVerifier: string): Promise<OpenAiCodexCredentials> {
+	// Per the implementation guide: use application/x-www-form-urlencoded
+	// and do NOT include state in the body (OpenAI returns error if included)
+	const body = new URLSearchParams({
+		grant_type: "authorization_code",
+		client_id: OPENAI_CODEX_OAUTH_CONFIG.clientId,
+		code,
+		redirect_uri: OPENAI_CODEX_OAUTH_CONFIG.redirectUri,
+		code_verifier: codeVerifier,
+	})
+
+	const response = await fetch(OPENAI_CODEX_OAUTH_CONFIG.tokenEndpoint, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+		},
+		body: body.toString(),
+		signal: AbortSignal.timeout(30000),
+	})
+
+	if (!response.ok) {
+		const errorText = await response.text()
+		throw new Error(`Token exchange failed: ${response.status} ${response.statusText} - ${errorText}`)
+	}
+
+	const data = await response.json()
+	const tokenResponse = tokenResponseSchema.parse(data)
+
+	if (!tokenResponse.refresh_token) {
+		throw new Error("Token exchange did not return a refresh_token")
+	}
+
+	// Per the implementation guide: expires is in milliseconds since epoch
+	const expiresAt = Date.now() + tokenResponse.expires_in * 1000
+
+	// Extract ChatGPT account ID from JWT claims
+	const accountId = extractAccountId({
+		id_token: tokenResponse.id_token,
+		access_token: tokenResponse.access_token,
+	})
+
+	return {
+		type: "openai-codex",
+		access_token: tokenResponse.access_token,
+		refresh_token: tokenResponse.refresh_token,
+		expires: expiresAt,
+		email: tokenResponse.email,
+		accountId,
+	}
+}
+
+/**
+ * Refreshes the access token using the refresh token
+ * Uses application/x-www-form-urlencoded (not JSON)
+ */
+async function refreshAccessToken(credentials: OpenAiCodexCredentials): Promise<OpenAiCodexCredentials> {
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		client_id: OPENAI_CODEX_OAUTH_CONFIG.clientId,
+		refresh_token: credentials.refresh_token,
+	})
+
+	const response = await fetch(OPENAI_CODEX_OAUTH_CONFIG.tokenEndpoint, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+		},
+		body: body.toString(),
+		signal: AbortSignal.timeout(30000),
+	})
+
+	if (!response.ok) {
+		const errorText = await response.text()
+		const { errorCode, errorMessage } = parseOAuthErrorDetails(errorText)
+		const details = errorMessage ? errorMessage : errorText
+		throw new OpenAiCodexOAuthTokenError(
+			`Token refresh failed: ${response.status} ${response.statusText}${details ? ` - ${details}` : ""}`,
+			{ status: response.status, errorCode },
+		)
+	}
+
+	const data = await response.json()
+	const tokenResponse = tokenResponseSchema.parse(data)
+
+	// Per the implementation guide: expires is in milliseconds since epoch
+	const expiresAt = Date.now() + tokenResponse.expires_in * 1000
+
+	// Extract new account ID from refreshed tokens, or preserve existing one
+	const newAccountId = extractAccountId({
+		id_token: tokenResponse.id_token,
+		access_token: tokenResponse.access_token,
+	})
+
+	return {
+		type: "openai-codex",
+		access_token: tokenResponse.access_token,
+		refresh_token: tokenResponse.refresh_token ?? credentials.refresh_token,
+		expires: expiresAt,
+		email: tokenResponse.email ?? credentials.email,
+		// Prefer newly extracted accountId, fall back to existing
+		accountId: newAccountId ?? credentials.accountId,
+	}
+}
+
+/**
+ * Checks if the credentials are expired (with 5 minute buffer)
+ * Per the implementation guide: expires is in milliseconds since epoch
+ */
+function isTokenExpired(credentials: OpenAiCodexCredentials): boolean {
+	const bufferMs = 5 * 60 * 1000 // 5 minutes buffer
+	return Date.now() >= credentials.expires - bufferMs
+}
+
+/**
+ * OpenAiCodexOAuthManager - Handles OAuth flow and token management
+ */
+class OpenAiCodexOAuthManager {
+	private credentials: OpenAiCodexCredentials | null = null
+	private refreshPromise: Promise<OpenAiCodexCredentials> | null = null
+	private pendingAuth: {
+		codeVerifier: string
+		state: string
+		server?: http.Server
+	} | null = null
+
+	/**
+	 * Force a refresh using the stored refresh token even if the access token is not expired.
+	 * Useful when the server invalidates an access token early.
+	 */
+	async forceRefreshAccessToken(): Promise<string | null> {
+		if (!this.credentials) {
+			await this.loadCredentials()
+		}
+
+		if (!this.credentials) {
+			return null
+		}
+
+		try {
+			// De-dupe concurrent refreshes
+			if (!this.refreshPromise) {
+				this.refreshPromise = refreshAccessToken(this.credentials)
+			}
+
+			const newCredentials = await this.refreshPromise
+			this.refreshPromise = null
+			await this.saveCredentials(newCredentials)
+			return newCredentials.access_token
+		} catch (error) {
+			this.refreshPromise = null
+			Logger.error("[openai-codex-oauth] Failed to force refresh token:", error)
+			if (error instanceof OpenAiCodexOAuthTokenError && error.isLikelyInvalidGrant()) {
+				Logger.log("[openai-codex-oauth] Refresh token appears invalid; clearing stored credentials")
+				await this.clearCredentials()
+			}
+			return null
+		}
+	}
+
+	/**
+	 * Load credentials from storage via StateManager.
+	 */
+	async loadCredentials(): Promise<OpenAiCodexCredentials | null> {
+		try {
+			const stateManager = StateManager.get()
+			const credentialsJson = stateManager.getSecretKey("openai-codex-oauth-credentials")
+
+			if (credentialsJson) {
+				const parsed = JSON.parse(credentialsJson)
+				this.credentials = openAiCodexCredentialsSchema.parse(parsed)
+				return this.credentials
+			}
+
+			this.credentials = await loadCredentialsFromProviderSettings()
+			return this.credentials
+		} catch (error) {
+			Logger.error("[openai-codex-oauth] Failed to load credentials:", error)
+			return null
+		}
+	}
+
+	/**
+	 * Save credentials to storage via StateManager
+	 */
+	async saveCredentials(credentials: OpenAiCodexCredentials): Promise<void> {
+		const stateManager = StateManager.get()
+		stateManager.setSecret("openai-codex-oauth-credentials", JSON.stringify(credentials))
+		await stateManager.flushPendingState()
+		await saveCredentialsToProviderSettings(credentials)
+		this.credentials = credentials
+	}
+
+	/**
+	 * Clear credentials from storage
+	 */
+	async clearCredentials(): Promise<void> {
+		const stateManager = StateManager.get()
+		stateManager.setSecret("openai-codex-oauth-credentials", undefined)
+		await stateManager.flushPendingState()
+		await clearCredentialsFromProviderSettings()
+		this.credentials = null
+	}
+
+	/**
+	 * Get a valid access token, refreshing if necessary
+	 */
+	async getAccessToken(): Promise<string | null> {
+		// Try to load credentials if not already loaded
+		if (!this.credentials) {
+			await this.loadCredentials()
+		}
+
+		if (!this.credentials) {
+			return null
+		}
+
+		// Check if token is expired and refresh if needed
+		if (isTokenExpired(this.credentials)) {
+			try {
+				// De-dupe concurrent refreshes
+				if (!this.refreshPromise) {
+					this.refreshPromise = refreshAccessToken(this.credentials)
+				}
+
+				const newCredentials = await this.refreshPromise
+				this.refreshPromise = null
+				await this.saveCredentials(newCredentials)
+			} catch (error) {
+				this.refreshPromise = null
+				Logger.error("[openai-codex-oauth] Failed to refresh token:", error)
+
+				// Only clear secrets when the refresh token is clearly invalid/revoked.
+				if (error instanceof OpenAiCodexOAuthTokenError && error.isLikelyInvalidGrant()) {
+					Logger.log("[openai-codex-oauth] Refresh token appears invalid; clearing stored credentials")
+					await this.clearCredentials()
+				}
+				return null
+			}
+		}
+
+		return this.credentials.access_token
+	}
+
+	/**
+	 * Get the user's email from credentials
+	 */
+	async getEmail(): Promise<string | null> {
+		if (!this.credentials) {
+			await this.loadCredentials()
+		}
+		return this.credentials?.email || null
+	}
+
+	/**
+	 * Get the ChatGPT account ID from credentials
+	 * Used for the ChatGPT-Account-Id header required by the Codex API
+	 */
+	async getAccountId(): Promise<string | null> {
+		if (!this.credentials) {
+			await this.loadCredentials()
+		}
+		return this.credentials?.accountId || null
+	}
+
+	/**
+	 * Check if the user has stored credentials (i.e. has completed auth).
+	 * This intentionally does NOT attempt a token refresh so that transient
+	 * network failures or expired-but-refreshable tokens don't cause the
+	 * CLI to bounce the user back to the onboarding flow.
+	 */
+	async isAuthenticated(): Promise<boolean> {
+		if (!this.credentials) {
+			await this.loadCredentials()
+		}
+		return this.credentials !== null
+	}
+
+	/**
+	 * Start the OAuth authorization flow
+	 * Returns the authorization URL to open in browser
+	 */
+	startAuthorizationFlow(): string {
+		// Cancel any existing authorization flow before starting a new one
+		this.cancelAuthorizationFlow()
+
+		const codeVerifier = generateCodeVerifier()
+		const codeChallenge = generateCodeChallenge(codeVerifier)
+		const state = generateState()
+
+		this.pendingAuth = {
+			codeVerifier,
+			state,
+		}
+
+		return buildAuthorizationUrl(codeChallenge, state)
+	}
+
+	/**
+	 * Start a local server to receive the OAuth callback
+	 * Returns a promise that resolves when authentication is complete
+	 */
+	async waitForCallback(): Promise<OpenAiCodexCredentials> {
+		if (!this.pendingAuth) {
+			throw new Error("No pending authorization flow")
+		}
+
+		// Close any existing server before starting a new one
+		if (this.pendingAuth.server) {
+			try {
+				this.pendingAuth.server.close()
+			} catch {
+				// Ignore errors when closing
+			}
+			this.pendingAuth.server = undefined
+		}
+
+		return new Promise((resolve, reject) => {
+			const server = http.createServer(async (req, res) => {
+				try {
+					const url = new URL(req.url || "", `http://localhost:${OPENAI_CODEX_OAUTH_CONFIG.callbackPort}`)
+
+					if (url.pathname !== "/auth/callback") {
+						res.writeHead(404)
+						res.end("Not Found")
+						return
+					}
+
+					const code = url.searchParams.get("code")
+					const state = url.searchParams.get("state")
+					const error = url.searchParams.get("error")
+
+					if (error) {
+						res.writeHead(400)
+						res.end(`Authentication failed: ${error}`)
+						reject(new Error(`OAuth error: ${error}`))
+						server.close()
+						return
+					}
+
+					if (!code || !state) {
+						res.writeHead(400)
+						res.end("Missing code or state parameter")
+						reject(new Error("Missing code or state parameter"))
+						server.close()
+						return
+					}
+
+					if (state !== this.pendingAuth?.state) {
+						res.writeHead(400)
+						res.end("State mismatch - possible CSRF attack")
+						reject(new Error("State mismatch"))
+						server.close()
+						return
+					}
+
+					try {
+						// Note: state is validated above but not passed to exchangeCodeForTokens
+						// per the implementation guide (OpenAI rejects it)
+						const credentials = await exchangeCodeForTokens(code, this.pendingAuth.codeVerifier)
+
+						await this.saveCredentials(credentials)
+
+						res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
+						res.end(`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Authentication Successful</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    color: #fff;
+  }
+  .container { text-align: center; padding: 48px; max-width: 420px; }
+  .icon {
+    width: 72px; height: 72px; margin: 0 auto 24px;
+    background: linear-gradient(135deg, #10a37f 0%, #1a7f64 100%);
+    border-radius: 50%;
+    display: flex; align-items: center; justify-content: center;
+  }
+  .icon svg { width: 36px; height: 36px; stroke: #fff; stroke-width: 3; fill: none; }
+  h1 { font-size: 24px; font-weight: 600; margin-bottom: 12px; }
+  p { font-size: 15px; color: rgba(255,255,255,0.7); line-height: 1.5; }
+  .closing { margin-top: 32px; font-size: 13px; color: rgba(255,255,255,0.5); }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="icon">
+    <svg viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg>
+  </div>
+  <h1>Authentication Successful</h1>
+  <p>You're now signed in to OpenAI Codex. You can close this window and return to your IDE.</p>
+  <p class="closing">This window will close automatically...</p>
+</div>
+<script>setTimeout(() => window.close(), 3000);</script>
+</body>
+</html>`)
+
+						this.pendingAuth = null
+						server.close()
+						resolve(credentials)
+					} catch (exchangeError) {
+						res.writeHead(500)
+						res.end(`Token exchange failed: ${exchangeError}`)
+						reject(exchangeError)
+						server.close()
+					}
+				} catch (err) {
+					res.writeHead(500)
+					res.end("Internal server error")
+					reject(err)
+					server.close()
+				}
+			})
+
+			server.on("error", (err: NodeJS.ErrnoException) => {
+				this.pendingAuth = null
+				if (err.code === "EADDRINUSE") {
+					reject(
+						new Error(
+							`Port ${OPENAI_CODEX_OAUTH_CONFIG.callbackPort} is already in use. ` +
+								`Please close any other applications using this port and try again.`,
+						),
+					)
+				} else {
+					reject(err)
+				}
+			})
+
+			// Set a timeout for the callback
+			const timeout = setTimeout(
+				() => {
+					server.close()
+					reject(new Error("Authentication timed out"))
+				},
+				5 * 60 * 1000,
+			) // 5 minutes
+
+			server.listen(OPENAI_CODEX_OAUTH_CONFIG.callbackPort, () => {
+				if (this.pendingAuth) {
+					this.pendingAuth.server = server
+				}
+			})
+
+			// Clear timeout when server closes
+			server.on("close", () => {
+				clearTimeout(timeout)
+			})
+		})
+	}
+
+	/**
+	 * Cancel any pending authorization flow
+	 */
+	cancelAuthorizationFlow(): void {
+		if (this.pendingAuth?.server) {
+			this.pendingAuth.server.close()
+		}
+		this.pendingAuth = null
+	}
+
+	/**
+	 * Get the current credentials (for display purposes)
+	 */
+	getCredentials(): OpenAiCodexCredentials | null {
+		return this.credentials
+	}
+}
+
+// Singleton instance
+export const openAiCodexOAuthManager = new OpenAiCodexOAuthManager()
diff --git a/apps/vscode/src/integrations/terminal/CommandOrchestrator.test.ts b/apps/vscode/src/integrations/terminal/CommandOrchestrator.test.ts
new file mode 100644
index 0000000..f4a2519
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/CommandOrchestrator.test.ts
@@ -0,0 +1,114 @@
+import { describe, it } from "mocha"
+import assert from "node:assert/strict"
+import { EventEmitter } from "events"
+import { orchestrateCommandExecution } from "./CommandOrchestrator"
+import type {
+	CommandExecutorCallbacks,
+	ITerminalManager,
+	ITerminalProcess,
+	OrchestrationResult,
+	TerminalCompletionDetails,
+	TerminalProcessEvents,
+	TerminalProcessResultPromise,
+} from "./types"
+
+class FakeTerminalProcess extends EventEmitter<TerminalProcessEvents> implements ITerminalProcess {
+	isHot = false
+	waitForShellIntegration = false
+	private readonly promise: Promise<void>
+	private resolvePromise!: () => void
+	private rejectPromise!: (error: Error) => void
+
+	constructor() {
+		super()
+		this.promise = new Promise<void>((resolve, reject) => {
+			this.resolvePromise = resolve
+			this.rejectPromise = reject
+		})
+	}
+
+	continue(): void {
+		this.emit("continue")
+		this.resolvePromise()
+	}
+
+	getUnretrievedOutput(): string {
+		return ""
+	}
+
+	getCompletionDetails(): TerminalCompletionDetails {
+		return {}
+	}
+
+	complete(details?: TerminalCompletionDetails): void {
+		this.emit("completed", details)
+		this.emit("continue")
+		this.resolvePromise()
+	}
+
+	fail(error: Error): void {
+		this.emit("error", error)
+		this.rejectPromise(error)
+	}
+
+	asResultPromise(): TerminalProcessResultPromise {
+		const processWithPromise = this as unknown as FakeTerminalProcess & Partial<TerminalProcessResultPromise>
+		processWithPromise.then = this.promise.then.bind(this.promise)
+		processWithPromise.catch = this.promise.catch.bind(this.promise)
+		processWithPromise.finally = this.promise.finally.bind(this.promise)
+		return processWithPromise as TerminalProcessResultPromise
+	}
+}
+
+function createCallbacks(): CommandExecutorCallbacks {
+	return {
+		say: async () => undefined,
+		ask: async () => ({ response: "messageResponse" }),
+		updateBackgroundCommandState: () => {},
+		updateClineMessage: async () => {},
+		getClineMessages: () => [],
+		addToUserMessageContent: () => {},
+	}
+}
+
+function createTerminalManager(): ITerminalManager {
+	return {
+		processOutput: (outputLines: string[]) => outputLines.join("\n"),
+	} as ITerminalManager
+}
+
+describe("CommandOrchestrator exit status messaging", () => {
+	it("reports non-zero exit codes as command failures", async () => {
+		const process = new FakeTerminalProcess()
+		const orchestrationPromise = orchestrateCommandExecution(
+			process.asResultPromise(),
+			createTerminalManager(),
+			createCallbacks(),
+			{ command: "false" },
+		)
+
+		process.complete({ exitCode: 2, signal: null })
+		const result: OrchestrationResult = await orchestrationPromise
+
+		assert.equal(result.completed, true)
+		assert.equal(result.exitCode, 2)
+		assert.match(result.result as string, /^Command failed with exit code 2\./)
+	})
+
+	it("reports successful command completion with explicit exit code", async () => {
+		const process = new FakeTerminalProcess()
+		const orchestrationPromise = orchestrateCommandExecution(
+			process.asResultPromise(),
+			createTerminalManager(),
+			createCallbacks(),
+			{ command: "echo ok" },
+		)
+
+		process.complete({ exitCode: 0, signal: null })
+		const result: OrchestrationResult = await orchestrationPromise
+
+		assert.equal(result.completed, true)
+		assert.equal(result.exitCode, 0)
+		assert.match(result.result as string, /^Command executed successfully \(exit code 0\)\./)
+	})
+})
diff --git a/apps/vscode/src/integrations/terminal/CommandOrchestrator.ts b/apps/vscode/src/integrations/terminal/CommandOrchestrator.ts
new file mode 100644
index 0000000..e77ca9a
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/CommandOrchestrator.ts
@@ -0,0 +1,685 @@
+/**
+ * CommandOrchestrator - Shared command execution orchestration logic.
+ *
+ * This module contains the common orchestration logic for command execution
+ * that is shared between VSCode and Standalone terminal modes. It handles:
+ * - Output buffering and chunking
+ * - User interaction (ask/say callbacks)
+ * - "Proceed While Running" behavior
+ * - Timeout handling
+ * - Result formatting
+ *
+ * The actual process spawning/management is handled by the TerminalProcess
+ * implementations (VscodeTerminalProcess, StandaloneTerminalProcess).
+ */
+
+import { setTimeout as setTimeoutPromise } from "node:timers/promises"
+import { formatResponse } from "@core/prompts/responses"
+import { processFilesIntoText } from "@integrations/misc/extract-text"
+import { TerminalHangStage, TerminalUserInterventionAction, telemetryService } from "@services/telemetry"
+import { ClineTempManager } from "@services/temp"
+import { COMMAND_CANCEL_TOKEN } from "@shared/ExtensionMessage"
+import * as fs from "fs"
+import { Logger } from "@/shared/services/Logger"
+import {
+	BUFFER_STUCK_TIMEOUT_MS,
+	CHUNK_BYTE_SIZE,
+	CHUNK_DEBOUNCE_MS,
+	CHUNK_LINE_COUNT,
+	COMPLETION_TIMEOUT_MS,
+	MAX_BYTES_BEFORE_FILE,
+	MAX_LINES_BEFORE_FILE,
+	SUMMARY_LINES_TO_KEEP,
+} from "./constants"
+import type {
+	CommandExecutorCallbacks,
+	ITerminalManager,
+	OrchestrationOptions,
+	OrchestrationResult,
+	TerminalCompletionDetails,
+	TerminalProcessResultPromise,
+} from "./types"
+
+/**
+ * Orchestrate command execution with shared logic for buffering, user interaction, and result formatting.
+ *
+ * @param process The terminal process (implements ITerminalProcess)
+ * @param terminalManager The terminal manager (for processOutput)
+ * @param callbacks The executor callbacks for UI interaction
+ * @param options Orchestration options
+ * @returns The orchestration result
+ */
+export async function orchestrateCommandExecution(
+	process: TerminalProcessResultPromise,
+	terminalManager: ITerminalManager,
+	callbacks: CommandExecutorCallbacks,
+	options: OrchestrationOptions,
+): Promise<OrchestrationResult> {
+	const {
+		timeoutSeconds,
+		onOutputLine,
+		showShellIntegrationSuggestion,
+		onProceedWhileRunning,
+		terminalType = "vscode",
+		suppressUserInteraction = false,
+	} = options
+
+	const say = async (
+		type: Parameters<CommandExecutorCallbacks["say"]>[0],
+		text?: Parameters<CommandExecutorCallbacks["say"]>[1],
+		images?: Parameters<CommandExecutorCallbacks["say"]>[2],
+		files?: Parameters<CommandExecutorCallbacks["say"]>[3],
+		partial?: Parameters<CommandExecutorCallbacks["say"]>[4],
+	): Promise<Awaited<ReturnType<CommandExecutorCallbacks["say"]>>> => {
+		if (suppressUserInteraction) {
+			return undefined
+		}
+
+		return callbacks.say(type, text, images, files, partial)
+	}
+
+	const ask = async (
+		type: Parameters<CommandExecutorCallbacks["ask"]>[0],
+		text?: Parameters<CommandExecutorCallbacks["ask"]>[1],
+		partial?: Parameters<CommandExecutorCallbacks["ask"]>[2],
+	): Promise<Awaited<ReturnType<CommandExecutorCallbacks["ask"]>> | undefined> => {
+		if (suppressUserInteraction) {
+			return undefined
+		}
+
+		return callbacks.ask(type, text, partial)
+	}
+
+	// Track command execution state
+	callbacks.updateBackgroundCommandState(true)
+
+	const clearCommandState = async () => {
+		callbacks.updateBackgroundCommandState(false)
+
+		// Mark the command message as completed
+		const clineMessages = callbacks.getClineMessages()
+		const lastCommandIndex = findLastIndex(clineMessages, (m) => m.ask === "command" || m.say === "command")
+		if (lastCommandIndex !== -1) {
+			await callbacks.updateClineMessage(lastCommandIndex, {
+				commandCompleted: true,
+			})
+		}
+	}
+
+	process.once("completed", clearCommandState)
+	process.once("error", clearCommandState)
+	process.catch(() => {
+		clearCommandState()
+	})
+
+	let userFeedback: { text?: string; images?: string[]; files?: string[] } | undefined
+	let didContinue = false
+	let didCancelViaUi = false
+	let backgroundTrackingResult: OrchestrationResult | null = null // Set when background tracking returns early
+
+	// Chunked terminal output buffering
+	let outputBuffer: string[] = []
+	let outputBufferSize = 0
+	let chunkTimer: NodeJS.Timeout | null = null
+
+	// Track if buffer gets stuck
+	let bufferStuckTimer: NodeJS.Timeout | null = null
+	let commandOutputAskSequence = 0
+	let pendingCommandOutputAskId: number | null = null
+	let releasePendingCommandOutputAsk: (() => void) | null = null
+
+	const clearPendingCommandOutputAsk = () => {
+		pendingCommandOutputAskId = null
+		releasePendingCommandOutputAsk = null
+	}
+
+	const releaseAnyPendingCommandOutputAsk = () => {
+		const release = releasePendingCommandOutputAsk
+		if (!release) {
+			return
+		}
+		callbacks.resolvePendingAsk?.("messageResponse")
+		release()
+	}
+
+	/**
+	 * Flush buffered output to the UI using ask() which waits for user response.
+	 * This is the key mechanism for "Proceed While Running" - when user clicks the button,
+	 * the ask() returns with response "yesButtonClicked".
+	 */
+	const flushBuffer = async (force = false) => {
+		if (outputBuffer.length === 0 && !force) {
+			return
+		}
+		const chunk = outputBuffer.join("\n")
+		outputBuffer = []
+		outputBufferSize = 0
+
+		if (!didContinue) {
+			// Start timer to detect if buffer gets stuck
+			bufferStuckTimer = setTimeout(() => {
+				telemetryService.captureTerminalHang(TerminalHangStage.BUFFER_STUCK, terminalType)
+				bufferStuckTimer = null
+			}, BUFFER_STUCK_TIMEOUT_MS)
+
+			try {
+				// Use ask() to present output and wait for user response
+				// This enables "Proceed While Running" button functionality
+				const interaction = await new Promise<Awaited<ReturnType<CommandExecutorCallbacks["ask"]>> | undefined>(
+					(resolve, reject) => {
+						const currentAskId = ++commandOutputAskSequence
+						pendingCommandOutputAskId = currentAskId
+
+						releasePendingCommandOutputAsk = () => {
+							if (pendingCommandOutputAskId !== currentAskId) {
+								return
+							}
+							clearPendingCommandOutputAsk()
+							resolve(undefined)
+						}
+
+						ask("command_output", chunk)
+							.then((result) => {
+								if (pendingCommandOutputAskId !== currentAskId) {
+									return
+								}
+								clearPendingCommandOutputAsk()
+								resolve(result)
+							})
+							.catch((error) => {
+								if (pendingCommandOutputAskId !== currentAskId) {
+									return
+								}
+								clearPendingCommandOutputAsk()
+								reject(error)
+							})
+					},
+				)
+				if (!interaction) {
+					return
+				}
+				const { response, text, images, files } = interaction
+
+				if (response === "yesButtonClicked") {
+					// Track when user clicks "Proceed While Running"
+					telemetryService.captureTerminalUserIntervention(
+						TerminalUserInterventionAction.PROCESS_WHILE_RUNNING,
+						terminalType,
+					)
+					// Proceed while running - but still capture user feedback if provided
+					if (text || (images && images.length > 0) || (files && files.length > 0)) {
+						userFeedback = { text, images, files }
+					}
+					didContinue = true
+
+					// Notify caller to start background command tracking
+					// Pass existing output lines so they can be written to the log file
+					// and send log file path to UI if tracking was started
+					if (onProceedWhileRunning) {
+						const trackingResult = onProceedWhileRunning(outputLines)
+
+						// Clear timers first
+						if (chunkTimer) {
+							clearTimeout(chunkTimer)
+							chunkTimer = null
+						}
+						if (completionTimer) {
+							clearTimeout(completionTimer)
+							completionTimer = null
+						}
+
+						// Set early return result BEFORE resuming the process
+						// This prevents the orchestrator's listener from processing new lines
+						const result = terminalManager.processOutput(outputLines)
+						const logMsg = trackingResult?.logFilePath ? `Log file: ${trackingResult.logFilePath}\n` : ""
+						const outputMsg = result.length > 0 ? `Output so far:\n${result}` : ""
+
+						backgroundTrackingResult = {
+							userRejected: false,
+							result: `Command is running in the background. You can proceed with other tasks.\n${logMsg}${outputMsg}`,
+							completed: false,
+							outputLines,
+						}
+
+						// Send log file message to UI BEFORE resuming the process
+						// This ensures the message appears before any new output lines
+						if (trackingResult?.logFilePath) {
+							await say("command_output", `\n📋 Output is being logged to: ${trackingResult.logFilePath}`)
+						}
+
+						// Now resume the process - any new lines will be handled by the background tracker
+						process.continue()
+						return
+					}
+
+					process.continue()
+				} else if (response === "noButtonClicked" && text === COMMAND_CANCEL_TOKEN) {
+					telemetryService.captureTerminalUserIntervention(TerminalUserInterventionAction.CANCELLED, terminalType)
+					// Set flags BEFORE resuming the process to prevent new lines from being processed
+					didCancelViaUi = true
+					userFeedback = undefined
+					didContinue = true
+					outputBuffer = []
+					outputBufferSize = 0
+					// Send cancellation message BEFORE resuming the process
+					// This ensures the message appears before any new output lines
+					await say("command_output", "Command cancelled")
+					// Now resume the process
+					process.continue()
+				} else {
+					userFeedback = { text, images, files }
+					didContinue = true
+					process.continue()
+					// If more output accumulated, flush again
+					if (outputBuffer.length > 0) {
+						await flushBuffer()
+					}
+				}
+			} catch {
+				Logger.error("Error while asking for command output")
+			} finally {
+				// Clear the stuck timer
+				if (bufferStuckTimer) {
+					clearTimeout(bufferStuckTimer)
+					bufferStuckTimer = null
+				}
+			}
+		} else {
+			// After "Proceed While Running": stream output directly to UI
+			await say("command_output", chunk)
+		}
+	}
+
+	const scheduleFlush = () => {
+		if (chunkTimer) {
+			clearTimeout(chunkTimer)
+		}
+		chunkTimer = setTimeout(async () => await flushBuffer(), CHUNK_DEBOUNCE_MS)
+	}
+
+	// Large output file-based logging state
+	let isWritingToFile = false
+	let largeOutputLogPath: string | null = null
+	let largeOutputLogStream: fs.WriteStream | null = null
+	let totalOutputBytes = 0
+	let totalLineCount = 0
+	let firstLines: string[] = [] // Keep first N lines for summary
+	let lastLines: string[] = [] // Keep last N lines for summary (circular buffer)
+
+	/**
+	 * Switch to file-based logging when output is too large.
+	 * This protects against memory exhaustion from commands with huge output.
+	 */
+	const switchToFileBased = async () => {
+		if (isWritingToFile) return
+
+		isWritingToFile = true
+
+		// FIRST: Flush any pending buffer to UI so the "writing to file" message appears at the end
+		if (outputBuffer.length > 0) {
+			const chunk = outputBuffer.join("\n")
+			outputBuffer = []
+			outputBufferSize = 0
+			if (!didContinue) {
+				// Use say() instead of ask() since we're transitioning to file mode
+				await say("command_output", chunk)
+			}
+		}
+
+		// Clear any pending flush timer
+		if (chunkTimer) {
+			clearTimeout(chunkTimer)
+			chunkTimer = null
+		}
+
+		// Set up file logging using ClineTempManager for proper cleanup
+		largeOutputLogPath = ClineTempManager.createTempFilePath("large-output")
+		largeOutputLogStream = fs.createWriteStream(largeOutputLogPath, { flags: "a" })
+
+		// Write all existing lines to file in a single batch to reduce I/O overhead
+		if (outputLines.length > 0) {
+			largeOutputLogStream.write(outputLines.join("\n") + "\n")
+		}
+
+		// Keep first N lines for summary
+		firstLines = outputLines.slice(0, SUMMARY_LINES_TO_KEEP)
+
+		// Keep last N lines for summary (will be updated as more lines come in)
+		lastLines = outputLines.slice(-SUMMARY_LINES_TO_KEEP)
+
+		// FINALLY: Notify user (now this will appear at the end after all buffered output)
+		await say(
+			"command_output",
+			`\n📋 Output is large (${outputLines.length} lines, ${Math.round(totalOutputBytes / 1024)}KB). Writing to: ${largeOutputLogPath}`,
+		)
+	}
+
+	/**
+	 * Clean up file-based logging resources.
+	 */
+	const cleanupFileBased = () => {
+		if (largeOutputLogStream) {
+			largeOutputLogStream.end()
+			largeOutputLogStream = null
+		}
+	}
+
+	const outputLines: string[] = []
+	process.on("line", async (line: string) => {
+		if (didCancelViaUi) {
+			return
+		}
+
+		// If background tracking is active, don't process lines here
+		// The background tracker's listener will handle them
+		if (backgroundTrackingResult) {
+			return
+		}
+
+		const lineBytes = Buffer.byteLength(line, "utf8")
+		totalOutputBytes += lineBytes
+		totalLineCount++
+
+		// Check if we should switch to file-based logging
+		if (!isWritingToFile && (outputLines.length >= MAX_LINES_BEFORE_FILE || totalOutputBytes >= MAX_BYTES_BEFORE_FILE)) {
+			await switchToFileBased()
+		}
+
+		if (isWritingToFile) {
+			// Write to file instead of keeping in memory
+			if (largeOutputLogStream) {
+				largeOutputLogStream.write(line + "\n")
+			}
+
+			// Update last lines circular buffer for summary
+			lastLines.push(line)
+			if (lastLines.length > SUMMARY_LINES_TO_KEEP) {
+				lastLines.shift()
+			}
+		} else {
+			// Normal behavior - keep in memory
+			outputLines.push(line)
+		}
+
+		// Notify caller about output line (for background command tracking)
+		if (onOutputLine) {
+			onOutputLine(line)
+		}
+
+		// Apply buffered streaming (only if not in file mode or still showing initial output)
+		if (!didContinue) {
+			if (!isWritingToFile) {
+				outputBuffer.push(line)
+				outputBufferSize += lineBytes
+				// Flush if buffer is large enough
+				if (outputBuffer.length >= CHUNK_LINE_COUNT || outputBufferSize >= CHUNK_BYTE_SIZE) {
+					await flushBuffer()
+				} else {
+					scheduleFlush()
+				}
+			}
+			// When in file mode, we've already notified the user, so don't keep buffering
+		} else {
+			// After "Proceed While Running" (without background tracking): stream output directly to UI
+			// But throttle if we're in file mode to avoid flooding UI
+			if (!isWritingToFile) {
+				await say("command_output", line)
+			}
+		}
+	})
+
+	let completed = false
+	let completionDetails: TerminalCompletionDetails | undefined
+	let completionTimer: NodeJS.Timeout | null = null
+
+	// Start timer to detect if waiting for completion takes too long
+	completionTimer = setTimeout(() => {
+		if (!completed) {
+			telemetryService.captureTerminalHang(TerminalHangStage.WAITING_FOR_COMPLETION, terminalType)
+			completionTimer = null
+		}
+	}, COMPLETION_TIMEOUT_MS)
+
+	process.once("completed", async (details?: TerminalCompletionDetails) => {
+		completed = true
+		completionDetails = details
+		// If command completed while command_output ask was pending, release it.
+		releaseAnyPendingCommandOutputAsk()
+		// Clear the completion timer
+		if (completionTimer) {
+			clearTimeout(completionTimer)
+			completionTimer = null
+		}
+		// Flush any remaining buffered output
+		if (!didContinue && outputBuffer.length > 0) {
+			if (chunkTimer) {
+				clearTimeout(chunkTimer)
+				chunkTimer = null
+			}
+			await flushBuffer(true)
+		}
+	})
+	process.once("error", () => {
+		releaseAnyPendingCommandOutputAsk()
+	})
+
+	process.once("no_shell_integration", async () => {
+		if (showShellIntegrationSuggestion) {
+			await say("shell_integration_warning_with_suggestion")
+		} else {
+			await say("shell_integration_warning")
+		}
+	})
+
+	// Handle timeout if specified, or wait for process to complete
+	if (!didCancelViaUi) {
+		if (timeoutSeconds) {
+			const timeoutPromise = new Promise<never>((_, reject) => {
+				setTimeout(() => {
+					reject(new Error("COMMAND_TIMEOUT"))
+				}, timeoutSeconds * 1000)
+			})
+
+			try {
+				await Promise.race([process, timeoutPromise])
+			} catch (error: any) {
+				if (error.message === "COMMAND_TIMEOUT") {
+					// Timeout triggers "Proceed While Running" behavior
+					didContinue = true
+					// Release any pending command_output ask before transitioning state.
+					releaseAnyPendingCommandOutputAsk()
+
+					// Clear all our timers first
+					if (chunkTimer) {
+						clearTimeout(chunkTimer)
+						chunkTimer = null
+					}
+					if (completionTimer) {
+						clearTimeout(completionTimer)
+						completionTimer = null
+					}
+
+					// If background tracking is available (standalone mode only), use it
+					// This writes output to a log file and detaches the command
+					if (onProceedWhileRunning) {
+						const trackingResult = onProceedWhileRunning(outputLines)
+
+						// Set early return result BEFORE resuming the process
+						// This prevents the orchestrator's listener from processing new lines
+						const result = terminalManager.processOutput(outputLines)
+						const logMsg = trackingResult?.logFilePath ? `Log file: ${trackingResult.logFilePath}\n` : ""
+						const outputMsg = result.length > 0 ? `Output so far:\n${result}` : ""
+
+						backgroundTrackingResult = {
+							userRejected: false,
+							result: `Command timed out after ${timeoutSeconds} seconds. Running in background.\n${logMsg}${outputMsg}`,
+							completed: false,
+							outputLines,
+						}
+
+						// Send log file message to UI BEFORE resuming the process
+						if (trackingResult?.logFilePath) {
+							await say(
+								"command_output",
+								`\n⏱️ Command timed out. Output is being logged to: ${trackingResult.logFilePath}`,
+							)
+						}
+
+						// Now resume the process - any new lines will be handled by the background tracker
+						process.continue()
+						// Clean up file-based logging if active before returning
+						cleanupFileBased()
+						return backgroundTrackingResult
+					}
+
+					// VSCode terminal mode: no background tracking available
+					// Just continue the process and return timeout result
+					process.continue()
+
+					// Process any output we captured before timeout
+					await setTimeoutPromise(50)
+					const result = terminalManager.processOutput(outputLines)
+
+					return {
+						userRejected: false,
+						result: `Command execution timed out after ${timeoutSeconds} seconds. ${result.length > 0 ? `\nOutput so far:\n${result}` : ""}`,
+						completed: false,
+						outputLines,
+					}
+				}
+
+				// Re-throw other errors
+				throw error
+			}
+		} else {
+			// No timeout - wait for process to complete
+			await process
+		}
+	}
+
+	// Check if we returned early due to background tracking
+	// This happens when user clicks "Proceed While Running" with background tracking enabled
+	if (backgroundTrackingResult) {
+		// Clean up file-based logging if active before returning
+		cleanupFileBased()
+		return backgroundTrackingResult
+	}
+
+	// Clear timer if process completes normally
+	if (completionTimer) {
+		clearTimeout(completionTimer)
+		completionTimer = null
+	}
+
+	// Wait for a short delay to ensure all messages are sent to the webview
+	await setTimeoutPromise(50)
+
+	// Clean up file-based logging if active
+	cleanupFileBased()
+
+	// Build result based on whether we used file-based logging
+	let result: string
+	let resultOutputLines: string[]
+
+	if (isWritingToFile) {
+		// Build summary from first and last lines
+		const skippedLines = totalLineCount - firstLines.length - lastLines.length
+		const summaryLines = [...firstLines, `\n... (${skippedLines} lines written to ${largeOutputLogPath}) ...\n`, ...lastLines]
+		result = terminalManager.processOutput(summaryLines)
+		resultOutputLines = summaryLines
+	} else {
+		result = terminalManager.processOutput(outputLines)
+		resultOutputLines = outputLines
+	}
+
+	if (didCancelViaUi) {
+		return {
+			userRejected: true,
+			result: formatResponse.toolResult(
+				`Command cancelled. ${result.length > 0 ? `\nOutput captured before cancellation:\n${result}` : ""}`,
+			),
+			completed: false,
+			outputLines: resultOutputLines,
+			logFilePath: largeOutputLogPath || undefined,
+			exitCode: completionDetails?.exitCode,
+			signal: completionDetails?.signal,
+		}
+	}
+
+	if (userFeedback) {
+		await say("user_feedback", userFeedback.text, userFeedback.images, userFeedback.files)
+
+		let fileContentString = ""
+		if (userFeedback.files && userFeedback.files.length > 0) {
+			fileContentString = await processFilesIntoText(userFeedback.files)
+		}
+
+		return {
+			userRejected: true,
+			result: formatResponse.toolResult(
+				`Command is still running in the user's terminal.${
+					result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
+				}\n\nThe user provided the following feedback:\n<feedback>\n${userFeedback.text}\n</feedback>`,
+				userFeedback.images,
+				fileContentString,
+			),
+			completed: false,
+			outputLines: resultOutputLines,
+			logFilePath: largeOutputLogPath || undefined,
+			exitCode: completionDetails?.exitCode,
+			signal: completionDetails?.signal,
+		}
+	}
+
+	if (completed) {
+		const exitCode = completionDetails?.exitCode
+		const signal = completionDetails?.signal
+		const hasExitCode = typeof exitCode === "number"
+		const logFileMsg = largeOutputLogPath ? `\nFull output saved to: ${largeOutputLogPath}` : ""
+		const statusMessage = hasExitCode
+			? exitCode === 0
+				? "Command executed successfully (exit code 0)."
+				: `Command failed with exit code ${exitCode}.`
+			: signal
+				? `Command terminated by signal ${signal}.`
+				: "Command executed."
+
+		Logger.debug(
+			`[CommandOrchestrator] resolved completed: exitCode=${exitCode} signal=${signal} lineCount=${totalLineCount} bytes=${totalOutputBytes} terminalType=${terminalType}`,
+		)
+
+		return {
+			userRejected: false,
+			result: `${statusMessage}${result.length > 0 ? `\nOutput:\n${result}` : ""}${logFileMsg}`,
+			completed: true,
+			outputLines: resultOutputLines,
+			logFilePath: largeOutputLogPath || undefined,
+			exitCode,
+			signal,
+		}
+	}
+	const logFileMsg = largeOutputLogPath ? `\nFull output saved to: ${largeOutputLogPath}` : ""
+	return {
+		userRejected: false,
+		result: `Command is still running in the user's terminal.${
+			result.length > 0 ? `\nHere's the output so far:\n${result}` : ""
+		}${logFileMsg}\n\nYou will be updated on the terminal status and new output in the future.`,
+		completed: false,
+		outputLines: resultOutputLines,
+		logFilePath: largeOutputLogPath || undefined,
+		exitCode: completionDetails?.exitCode,
+		signal: completionDetails?.signal,
+	}
+}
+
+/**
+ * Helper to find last index matching a predicate
+ */
+function findLastIndex<T>(array: T[], predicate: (item: T) => boolean): number {
+	for (let i = array.length - 1; i >= 0; i--) {
+		if (predicate(array[i])) {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/apps/vscode/src/integrations/terminal/__tests__/CommandOrchestrator.commandOutputAsk.test.ts b/apps/vscode/src/integrations/terminal/__tests__/CommandOrchestrator.commandOutputAsk.test.ts
new file mode 100644
index 0000000..3badeff
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/__tests__/CommandOrchestrator.commandOutputAsk.test.ts
@@ -0,0 +1,244 @@
+import { describe, it } from "bun:test"
+import assert from "node:assert/strict"
+import { EventEmitter } from "events"
+import { orchestrateCommandExecution } from "../CommandOrchestrator"
+import { CHUNK_DEBOUNCE_MS } from "../constants"
+import type {
+	CommandExecutorCallbacks,
+	ITerminalManager,
+	ITerminalProcess,
+	TerminalCompletionDetails,
+	TerminalProcessEvents,
+	TerminalProcessResultPromise,
+} from "../types"
+
+class FakeTerminalProcess extends EventEmitter<TerminalProcessEvents> implements ITerminalProcess {
+	isHot = false
+	waitForShellIntegration = false
+	private readonly promise: Promise<void>
+	private resolvePromise!: () => void
+	private rejectPromise!: (error: Error) => void
+
+	constructor() {
+		super()
+		this.promise = new Promise<void>((resolve, reject) => {
+			this.resolvePromise = resolve
+			this.rejectPromise = reject
+		})
+	}
+
+	continue(): void {
+		this.emit("continue")
+		this.resolvePromise()
+	}
+
+	getUnretrievedOutput(): string {
+		return ""
+	}
+
+	getCompletionDetails(): TerminalCompletionDetails {
+		return {}
+	}
+
+	complete(details?: TerminalCompletionDetails): void {
+		this.emit("completed", details)
+		this.emit("continue")
+		this.resolvePromise()
+	}
+
+	fail(error: Error): void {
+		this.emit("error", error)
+		this.rejectPromise(error)
+	}
+
+	asResultPromise(): TerminalProcessResultPromise {
+		const processWithPromise = this as unknown as FakeTerminalProcess & Partial<TerminalProcessResultPromise>
+		processWithPromise.then = this.promise.then.bind(this.promise)
+		processWithPromise.catch = this.promise.catch.bind(this.promise)
+		processWithPromise.finally = this.promise.finally.bind(this.promise)
+		return processWithPromise as TerminalProcessResultPromise
+	}
+}
+
+function createCallbacks(): CommandExecutorCallbacks {
+	return {
+		say: async () => undefined,
+		ask: async () => ({ response: "messageResponse" }),
+		updateBackgroundCommandState: () => {},
+		updateClineMessage: async () => {},
+		getClineMessages: () => [],
+		addToUserMessageContent: () => {},
+	}
+}
+
+function createTerminalManager(): ITerminalManager {
+	return {
+		processOutput: (outputLines: string[]) => outputLines.join("\n"),
+	} as ITerminalManager
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 300): Promise<void> {
+	const start = Date.now()
+	while (!predicate()) {
+		if (Date.now() - start > timeoutMs) {
+			throw new Error("Condition not met before timeout")
+		}
+		await new Promise((resolve) => setTimeout(resolve, 10))
+	}
+}
+
+describe("CommandOrchestrator command_output ask lifecycle", () => {
+	it("settles a pending command_output ask when the process completes", async () => {
+		const process = new FakeTerminalProcess()
+		let askCalls = 0
+		let askSettled = false
+		let resolvePendingAsk: ((value: { response: "messageResponse" }) => void) | null = null
+
+		const callbacks = createCallbacks()
+		callbacks.ask = async () => {
+			askCalls++
+			return new Promise<{ response: "messageResponse" }>((resolve) => {
+				resolvePendingAsk = resolve
+			}).finally(() => {
+				askSettled = true
+			})
+		}
+		callbacks.resolvePendingAsk = () => {
+			resolvePendingAsk?.({ response: "messageResponse" })
+		}
+
+		const orchestrationPromise = orchestrateCommandExecution(process.asResultPromise(), createTerminalManager(), callbacks, {
+			command: "echo test",
+		})
+
+		process.emit("line", "line one")
+		await new Promise((resolve) => setTimeout(resolve, CHUNK_DEBOUNCE_MS + 40))
+		assert.equal(askCalls, 1, "expected command_output ask after buffered output flush")
+
+		process.complete({ exitCode: 0, signal: null })
+		await orchestrationPromise
+
+		try {
+			await waitFor(() => askSettled, 500)
+			assert.equal(askSettled, true, "pending command_output ask should settle after process completion")
+		} finally {
+			;(resolvePendingAsk as ((value: { response: "messageResponse" }) => void) | null)?.({
+				response: "messageResponse",
+			})
+		}
+	})
+
+	it("settles a pending command_output ask when the process errors", async () => {
+		const process = new FakeTerminalProcess()
+		let askCalls = 0
+		let askSettled = false
+		let resolvePendingAsk: ((value: { response: "messageResponse" }) => void) | null = null
+
+		const callbacks = createCallbacks()
+		callbacks.ask = async () => {
+			askCalls++
+			return new Promise<{ response: "messageResponse" }>((resolve) => {
+				resolvePendingAsk = resolve
+			}).finally(() => {
+				askSettled = true
+			})
+		}
+		callbacks.resolvePendingAsk = () => {
+			resolvePendingAsk?.({ response: "messageResponse" })
+		}
+
+		const orchestrationPromise = orchestrateCommandExecution(process.asResultPromise(), createTerminalManager(), callbacks, {
+			command: "echo test",
+		})
+
+		process.emit("line", "line one")
+		await new Promise((resolve) => setTimeout(resolve, CHUNK_DEBOUNCE_MS + 40))
+		assert.equal(askCalls, 1, "expected command_output ask after buffered output flush")
+
+		process.fail(new Error("process failed"))
+		await assert.rejects(orchestrationPromise, /process failed/)
+
+		try {
+			await waitFor(() => askSettled, 500)
+			assert.equal(askSettled, true, "pending command_output ask should settle after process error")
+		} finally {
+			;(resolvePendingAsk as ((value: { response: "messageResponse" }) => void) | null)?.({
+				response: "messageResponse",
+			})
+		}
+	})
+
+	it("settles a pending command_output ask when execution transitions on timeout", async () => {
+		const process = new FakeTerminalProcess()
+		let askCalls = 0
+		let askSettled = false
+		let resolvePendingAsk: ((value: { response: "messageResponse" }) => void) | null = null
+
+		const callbacks = createCallbacks()
+		callbacks.ask = async () => {
+			askCalls++
+			return new Promise<{ response: "messageResponse" }>((resolve) => {
+				resolvePendingAsk = resolve
+			}).finally(() => {
+				askSettled = true
+			})
+		}
+		callbacks.resolvePendingAsk = () => {
+			resolvePendingAsk?.({ response: "messageResponse" })
+		}
+
+		const orchestrationPromise = orchestrateCommandExecution(process.asResultPromise(), createTerminalManager(), callbacks, {
+			command: "sleep 10",
+			timeoutSeconds: 0.3,
+		})
+
+		process.emit("line", "line one")
+		await new Promise((resolve) => setTimeout(resolve, CHUNK_DEBOUNCE_MS + 40))
+		assert.equal(askCalls, 1, "expected command_output ask after buffered output flush")
+		const result = await orchestrationPromise
+
+		try {
+			await waitFor(() => askSettled, 500)
+			assert.equal(askSettled, true, "pending command_output ask should settle after timeout transition")
+			assert.equal(result.completed, false)
+			assert.match(result.result as string, /Command execution timed out/)
+		} finally {
+			;(resolvePendingAsk as ((value: { response: "messageResponse" }) => void) | null)?.({
+				response: "messageResponse",
+			})
+		}
+	})
+
+	it("does not attempt to resolve the same pending ask twice across lifecycle events", async () => {
+		const process = new FakeTerminalProcess()
+		let askCalls = 0
+		let resolvePendingAsk: ((value: { response: "messageResponse" }) => void) | null = null
+		let resolvePendingAskCalls = 0
+
+		const callbacks = createCallbacks()
+		callbacks.ask = async () => {
+			askCalls++
+			return new Promise<{ response: "messageResponse" }>((resolve) => {
+				resolvePendingAsk = resolve
+			})
+		}
+		callbacks.resolvePendingAsk = () => {
+			resolvePendingAskCalls++
+			resolvePendingAsk?.({ response: "messageResponse" })
+		}
+
+		const orchestrationPromise = orchestrateCommandExecution(process.asResultPromise(), createTerminalManager(), callbacks, {
+			command: "echo test",
+		})
+
+		process.emit("line", "line one")
+		await new Promise((resolve) => setTimeout(resolve, CHUNK_DEBOUNCE_MS + 40))
+		assert.equal(askCalls, 1, "expected command_output ask after buffered output flush")
+
+		process.complete({ exitCode: 0, signal: null })
+		await orchestrationPromise
+
+		process.emit("error", new Error("late error event"))
+		assert.equal(resolvePendingAskCalls, 1, "pending ask should be released at most once")
+	})
+})
diff --git a/apps/vscode/src/integrations/terminal/constants.ts b/apps/vscode/src/integrations/terminal/constants.ts
new file mode 100644
index 0000000..b4bc952
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/constants.ts
@@ -0,0 +1,112 @@
+/**
+ * Terminal Constants
+ *
+ * Central location for all terminal-related constants.
+ * This makes it easy to understand and tune terminal behavior.
+ */
+
+// =============================================================================
+// Process "Hot" State Timeouts
+// =============================================================================
+// How long to wait after output before considering the process "cool"
+// This stalls API requests to let terminal output settle
+
+/** Normal timeout after last output (2 seconds) */
+export const PROCESS_HOT_TIMEOUT_NORMAL = 2_000
+
+/** Extended timeout for compilation/build commands (15 seconds) */
+export const PROCESS_HOT_TIMEOUT_COMPILING = 15_000
+
+// =============================================================================
+// Output Buffering (CommandOrchestrator)
+// =============================================================================
+// Controls how output is chunked and sent to the UI
+
+/** Lines to buffer before flushing to UI */
+export const CHUNK_LINE_COUNT = 20
+
+/** Bytes to buffer before flushing to UI */
+export const CHUNK_BYTE_SIZE = 2048 // 2KB
+
+/** Debounce time for buffer flush */
+export const CHUNK_DEBOUNCE_MS = 100
+
+/** Timeout to detect stuck buffer */
+export const BUFFER_STUCK_TIMEOUT_MS = 6000 // 6 seconds
+
+/** Timeout to detect stuck completion */
+export const COMPLETION_TIMEOUT_MS = 6000 // 6 seconds
+
+// =============================================================================
+// Large Output Protection
+// =============================================================================
+// Prevents memory exhaustion and context window overflow
+
+/** Switch to file-based logging after this many lines */
+export const MAX_LINES_BEFORE_FILE = 1000
+
+/** Switch to file-based logging after this many bytes */
+export const MAX_BYTES_BEFORE_FILE = 512 * 1024 // 512KB
+
+/** Lines to keep at start/end for summary when truncating */
+export const SUMMARY_LINES_TO_KEEP = 100
+
+/** Maximum size for fullOutput storage (memory protection) */
+export const MAX_FULL_OUTPUT_SIZE = 1024 * 1024 // 1MB
+
+/** Maximum lines to return from getUnretrievedOutput */
+export const MAX_UNRETRIEVED_LINES = 500
+
+/** Lines to keep at start/end when truncating unretrieved output */
+export const TRUNCATE_KEEP_LINES = 100
+
+// =============================================================================
+// Output Line Limits (processOutput)
+// =============================================================================
+// Controls truncation when returning output to AI
+
+/** Default max lines for command output */
+export const DEFAULT_TERMINAL_OUTPUT_LINE_LIMIT = 500
+
+// =============================================================================
+// Background Command Tracking
+// =============================================================================
+// Controls background command behavior for "Proceed While Running"
+
+/** Hard timeout for background commands to prevent zombie processes (10 minutes) */
+export const BACKGROUND_COMMAND_TIMEOUT_MS = 10 * 60 * 1000
+
+// =============================================================================
+// Compilation Detection Markers
+// =============================================================================
+// Used to detect if a command is compiling/building
+
+/** Markers that indicate compilation is starting */
+const COMPILING_MARKERS = ["compiling", "building", "bundling", "transpiling", "generating", "starting"]
+
+/** Markers that indicate compilation is done (nullify extended timeout) */
+const COMPILING_NULLIFIERS = [
+	"compiled",
+	"success",
+	"finish",
+	"complete",
+	"succeed",
+	"done",
+	"end",
+	"stop",
+	"exit",
+	"terminate",
+	"error",
+	"fail",
+]
+
+/**
+ * Check if terminal output indicates compilation/building.
+ * Matches markers anywhere in the output.
+ */
+export function isCompilingOutput(data: string): boolean {
+	const lowerData = data.toLowerCase()
+	const hasMarker = COMPILING_MARKERS.some((marker) => lowerData.includes(marker.toLowerCase()))
+	const hasNullifier = COMPILING_NULLIFIERS.some((nullifier) => lowerData.includes(nullifier.toLowerCase()))
+	return hasMarker && !hasNullifier
+}
diff --git a/apps/vscode/src/integrations/terminal/index.ts b/apps/vscode/src/integrations/terminal/index.ts
new file mode 100644
index 0000000..299acf8
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/index.ts
@@ -0,0 +1,27 @@
+/**
+ * Shared terminal module for both VSCode and Standalone environments.
+ *
+ * This module provides terminal management functionality that works across:
+ * - VSCode Extension (using VSCode's terminal API or background execution)
+ * - CLI (using StandaloneTerminalManager)
+ * - JetBrains (using StandaloneTerminalManager via cline-core)
+ *
+ * @example
+ * ```typescript
+ * import { StandaloneTerminalManager, ITerminalManager } from "@integrations/terminal"
+ *
+ * const manager: ITerminalManager = new StandaloneTerminalManager()
+ * const terminalInfo = await manager.getOrCreateTerminal("/path/to/cwd")
+ * const process = manager.runCommand(terminalInfo, "npm install")
+ *
+ * process.on("line", (line) => console.log(line))
+ * await process
+ * ```
+ */
+
+// Export unified command executor
+// Export command orchestrator (shared logic)
+// Export standalone terminal implementations
+export { StandaloneTerminalManager } from "./standalone/StandaloneTerminalManager"
+// Export all types from types.ts
+export type { ITerminalManager } from "./types"
diff --git a/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminal.ts b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminal.ts
new file mode 100644
index 0000000..6672833
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminal.ts
@@ -0,0 +1,123 @@
+/**
+ * StandaloneTerminal - A terminal wrapper for standalone environments.
+ *
+ * This class provides a terminal abstraction that works outside of VSCode,
+ * implementing the ITerminal interface for compatibility with the terminal manager.
+ */
+
+import type { ChildProcess } from "child_process"
+import { Logger } from "@/shared/services/Logger"
+import type { ITerminal, StandaloneTerminalOptions } from "../types"
+
+/**
+ * A standalone terminal implementation that doesn't depend on VSCode.
+ * Used in CLI and JetBrains environments.
+ */
+export class StandaloneTerminal implements ITerminal {
+	/** Terminal name */
+	name: string
+
+	/** Promise that resolves to the process ID */
+	processId: Promise<number | undefined>
+
+	/** Terminal creation options */
+	creationOptions: StandaloneTerminalOptions
+
+	/** Exit status (if terminal has exited) */
+	exitStatus: { code: number } | undefined
+
+	/** Terminal state */
+	state: { isInteractedWith: boolean }
+
+	/** Current working directory */
+	_cwd: string
+
+	/** Shell path */
+	_shellPath: string | undefined
+
+	/** Active child process */
+	_process: ChildProcess | null = null
+
+	/** Process ID of the active process */
+	_processId: number | null = null
+
+	/** Mock shell integration for compatibility */
+	shellIntegration: {
+		cwd: { fsPath: string }
+		executeCommand: (command: string) => {
+			read: () => AsyncGenerator<string, void, unknown>
+		}
+	}
+
+	constructor(options: StandaloneTerminalOptions = {}) {
+		this.name = options.name || `Terminal ${Math.floor(Math.random() * 10000)}`
+		this.processId = Promise.resolve(Math.floor(Math.random() * 100000))
+		this.creationOptions = options
+		this.exitStatus = undefined
+		this.state = { isInteractedWith: false }
+		this._cwd = options.cwd || process.cwd()
+		this._shellPath = options.shellPath
+
+		// Mock shell integration for compatibility
+		this.shellIntegration = {
+			cwd: { fsPath: this._cwd },
+			executeCommand: (_command: string) => {
+				// Return a mock execution object that the TerminalProcess expects
+				return {
+					read: async function* (): AsyncGenerator<string, void, unknown> {
+						// This will be handled by our StandaloneTerminalProcess
+						yield ""
+					},
+				}
+			},
+		}
+
+		Logger.log(`[StandaloneTerminal] Created terminal: ${this.name} in ${this._cwd}`)
+	}
+
+	/**
+	 * Send text to the terminal.
+	 * @param text The text to send
+	 * @param addNewLine Whether to add a newline (default: true)
+	 */
+	sendText(text: string, addNewLine: boolean = true): void {
+		Logger.log(`[StandaloneTerminal] sendText: ${text}`)
+
+		// If we have an active process, send input to it
+		if (this._process && !this._process.killed) {
+			try {
+				this._process.stdin?.write(text + (addNewLine ? "\n" : ""))
+			} catch (error) {
+				Logger.error(`[StandaloneTerminal] Error sending text to process:`, error)
+			}
+		} else {
+			// For compatibility with old behavior, we could spawn a new process
+			Logger.log(`[StandaloneTerminal] No active process to send text to`)
+		}
+	}
+
+	/**
+	 * Show the terminal (no-op in standalone mode).
+	 */
+	show(): void {
+		Logger.log(`[StandaloneTerminal] show: ${this.name}`)
+		this.state.isInteractedWith = true
+	}
+
+	/**
+	 * Hide the terminal (no-op in standalone mode).
+	 */
+	hide(): void {
+		Logger.log(`[StandaloneTerminal] hide: ${this.name}`)
+	}
+
+	/**
+	 * Dispose of the terminal and kill any running process.
+	 */
+	dispose(): void {
+		Logger.log(`[StandaloneTerminal] dispose: ${this.name}`)
+		if (this._process && !this._process.killed) {
+			this._process.kill("SIGTERM")
+		}
+	}
+}
diff --git a/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalManager.ts b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalManager.ts
new file mode 100644
index 0000000..34f3358
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalManager.ts
@@ -0,0 +1,619 @@
+/**
+ * StandaloneTerminalManager - Main terminal manager for standalone environments.
+ *
+ * This class provides the same interface as VSCode's TerminalManager but works
+ * in CLI and JetBrains environments by using subprocess management instead of
+ * VSCode's terminal API.
+ *
+ * Also handles background command tracking for "Proceed While Running" functionality:
+ * - Logs output to temp files for later retrieval
+ * - Tracks command status (running, completed, error, timed_out)
+ * - Implements 10-minute hard timeout to prevent zombie processes
+ * - Provides summary for environment details
+ */
+
+import { ClineTempManager } from "@services/temp"
+import * as fs from "fs"
+import { Logger } from "@/shared/services/Logger"
+import { BACKGROUND_COMMAND_TIMEOUT_MS, DEFAULT_TERMINAL_OUTPUT_LINE_LIMIT } from "../constants"
+import type { BackgroundCommand, ITerminalManager, TerminalInfo, TerminalProcessResultPromise } from "../types"
+import { StandaloneTerminalProcess } from "./StandaloneTerminalProcess"
+import { StandaloneTerminalRegistry } from "./StandaloneTerminalRegistry"
+
+// Re-export BackgroundCommand for backwards compatibility
+export type { BackgroundCommand }
+
+/**
+ * Helper function to merge a process with a promise for the TerminalProcessResultPromise type.
+ * This allows the returned object to be both awaitable and have event methods.
+ */
+function mergePromise(process: StandaloneTerminalProcess, promise: Promise<void>): TerminalProcessResultPromise {
+	const nativePromisePrototype = (async () => {})().constructor.prototype
+	const descriptors = ["then", "catch", "finally"].map((property) => [
+		property,
+		Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),
+	]) as [string, PropertyDescriptor][]
+
+	for (const [property, descriptor] of descriptors) {
+		if (descriptor) {
+			const value = (descriptor.value as Function).bind(promise)
+			Reflect.defineProperty(process, property, { ...descriptor, value })
+		}
+	}
+
+	// Ensure terminate() is accessible on the merged promise
+	// This allows Task.cancelBackgroundCommand() to kill the process
+	if (process.terminate && typeof process.terminate === "function") {
+		Object.defineProperty(process, "terminate", {
+			value: process.terminate.bind(process),
+			writable: false,
+			enumerable: false,
+			configurable: false,
+		})
+	}
+
+	return process as unknown as TerminalProcessResultPromise
+}
+
+/**
+ * Terminal manager for standalone (non-VSCode) environments.
+ * Implements ITerminalManager for compatibility with the Task class.
+ */
+export class StandaloneTerminalManager implements ITerminalManager {
+	/** Registry for tracking terminals */
+	private registry: StandaloneTerminalRegistry = new StandaloneTerminalRegistry()
+
+	/** Map of terminal ID to process */
+	private processes: Map<number, StandaloneTerminalProcess> = new Map()
+
+	/** Set of terminal IDs managed by this instance */
+	private terminalIds: Set<number> = new Set()
+
+	/** Timeout for shell integration (not used in standalone, but kept for interface compatibility) */
+	private shellIntegrationTimeout = 4000
+
+	/** Whether terminal reuse is enabled */
+	private terminalReuseEnabled = true
+
+	/** Maximum output lines to keep */
+	private terminalOutputLineLimit: number = DEFAULT_TERMINAL_OUTPUT_LINE_LIMIT
+
+	/** Default terminal profile */
+	private defaultTerminalProfile = "default"
+
+	// =========================================================================
+	// Background Command Tracking
+	// =========================================================================
+
+	/** Map of background command ID to command info */
+	private backgroundCommands: Map<string, BackgroundCommand> = new Map()
+
+	/** Map of background command ID to log file write stream */
+	private logStreams: Map<string, fs.WriteStream> = new Map()
+
+	/** Map of background command ID to timeout handle */
+	private backgroundTimeouts: Map<string, NodeJS.Timeout> = new Map()
+
+	/**
+	 * Run a command in the specified terminal.
+	 * @param terminalInfo The terminal to run the command in
+	 * @param command The command to execute
+	 * @returns A promise-like object that emits events and resolves on completion
+	 */
+	runCommand(terminalInfo: TerminalInfo, command: string): TerminalProcessResultPromise {
+		Logger.debug(`[StandaloneTerminalManager] runCommand terminalId=${terminalInfo.id}`)
+		terminalInfo.busy = true
+		terminalInfo.lastCommand = command
+
+		const process = new StandaloneTerminalProcess()
+		this.processes.set(terminalInfo.id, process)
+
+		process.once("completed", () => {
+			terminalInfo.busy = false
+		})
+
+		process.once("error", (_error: Error) => {
+			terminalInfo.busy = false
+		})
+
+		// Create promise for the process
+		const promise = new Promise<void>((resolve, reject) => {
+			process.once("continue", () => resolve())
+			process.once("error", (error: Error) => reject(error))
+		})
+
+		// Run the command immediately (no shell integration wait needed).
+		// process.run is async but intentionally not awaited. run() emits "error"
+		// for failures it catches itself; this guard handles any rejection that
+		// escapes without an "error" event, re-emitting it so the outer promise
+		// rejects instead of hanging forever.
+		process.run(terminalInfo.terminal, command).catch((error) => {
+			Logger.error(
+				`[StandaloneTerminalManager] process.run rejected for terminal ${terminalInfo.id}: ${(error as Error)?.message ?? String(error)}`,
+			)
+			process.emit("error", error instanceof Error ? error : new Error(String(error)))
+		})
+
+		// Return merged promise/process object
+		return mergePromise(process, promise)
+	}
+
+	/**
+	 * Get or create a terminal for the specified working directory.
+	 * @param cwd The working directory for the terminal
+	 * @returns The terminal info for an available terminal
+	 */
+	async getOrCreateTerminal(cwd: string): Promise<TerminalInfo> {
+		const terminals = this.registry.getAllTerminals()
+
+		// Find available terminal with matching CWD
+		const matchingTerminal = terminals.find((t) => {
+			if (t.busy) {
+				return false
+			}
+			return (t.terminal as any)._cwd === cwd
+		})
+
+		if (matchingTerminal) {
+			this.terminalIds.add(matchingTerminal.id)
+			return matchingTerminal
+		}
+
+		// Find any available terminal if reuse is enabled
+		if (this.terminalReuseEnabled) {
+			const availableTerminal = terminals.find((t) => !t.busy)
+			if (availableTerminal) {
+				// Change directory
+				await this.runCommand(availableTerminal, `cd "${cwd}"`)
+				;(availableTerminal.terminal as any)._cwd = cwd
+				if (availableTerminal.terminal.shellIntegration?.cwd) {
+					availableTerminal.terminal.shellIntegration.cwd.fsPath = cwd
+				}
+				this.terminalIds.add(availableTerminal.id)
+				return availableTerminal
+			}
+		}
+
+		// Create new terminal
+		const newTerminalInfo = this.registry.createTerminal({
+			cwd: cwd,
+			name: `Cline Terminal ${this.registry.size + 1}`,
+		})
+		this.terminalIds.add(newTerminalInfo.id)
+		return newTerminalInfo
+	}
+
+	/**
+	 * Get terminals filtered by busy state.
+	 * @param busy Whether to get busy or idle terminals
+	 * @returns Array of terminal info with id and last command
+	 */
+	getTerminals(busy: boolean): { id: number; lastCommand: string }[] {
+		const allTerminalIds = Array.from(this.terminalIds)
+
+		const terminals = allTerminalIds
+			.map((id) => this.registry.getTerminal(id))
+			.filter((t): t is TerminalInfo => {
+				if (t === undefined) {
+					return false
+				}
+				return t.busy === busy
+			})
+			.map((t) => ({ id: t.id, lastCommand: t.lastCommand }))
+
+		return terminals
+	}
+
+	/**
+	 * Get output that hasn't been retrieved yet from a terminal.
+	 * @param terminalId The terminal ID
+	 * @returns The unretrieved output string
+	 */
+	getUnretrievedOutput(terminalId: number): string {
+		if (!this.terminalIds.has(terminalId)) {
+			return ""
+		}
+		const process = this.processes.get(terminalId)
+		return process ? process.getUnretrievedOutput() : ""
+	}
+
+	/**
+	 * Check if a terminal's process is actively outputting.
+	 * @param terminalId The terminal ID
+	 * @returns Whether the process is hot
+	 */
+	isProcessHot(terminalId: number): boolean {
+		const process = this.processes.get(terminalId)
+		return process ? process.isHot : false
+	}
+
+	/**
+	 * Process output lines, potentially truncating if over limit.
+	 * @param outputLines Array of output lines
+	 * @param overrideLimit Optional limit override
+	 * @returns Processed output string
+	 */
+	processOutput(outputLines: string[], overrideLimit?: number): string {
+		const limit = overrideLimit !== undefined ? overrideLimit : this.terminalOutputLineLimit
+		if (outputLines.length > limit) {
+			const halfLimit = Math.floor(limit / 2)
+			const start = outputLines.slice(0, halfLimit)
+			const end = outputLines.slice(outputLines.length - halfLimit)
+			return `${start.join("\n")}\n... (output truncated) ...\n${end.join("\n")}`.trim()
+		}
+		return outputLines.join("\n").trim()
+	}
+
+	/**
+	 * Dispose of all terminals and clean up resources.
+	 */
+	disposeAll(): void {
+		// Dispose background commands first
+		this.disposeBackgroundCommands()
+
+		// Terminate all processes
+		for (const [_terminalId, process] of this.processes) {
+			if (process && process.terminate) {
+				process.terminate()
+			}
+		}
+
+		// Clear all tracking
+		this.terminalIds.clear()
+		this.processes.clear()
+
+		// Dispose all terminals
+		for (const terminalInfo of this.registry.getAllTerminals()) {
+			terminalInfo.terminal.dispose()
+		}
+
+		this.registry.clear()
+	}
+
+	/**
+	 * Set the timeout for waiting for shell integration.
+	 * @param timeout Timeout in milliseconds
+	 */
+	setShellIntegrationTimeout(timeout: number): void {
+		this.shellIntegrationTimeout = timeout
+	}
+
+	/**
+	 * Enable or disable terminal reuse.
+	 * @param enabled Whether to enable terminal reuse
+	 */
+	setTerminalReuseEnabled(enabled: boolean): void {
+		this.terminalReuseEnabled = enabled
+	}
+
+	/**
+	 * Set the default terminal profile.
+	 * @param profile The profile identifier
+	 * @returns Object with information about closed terminals and remaining busy terminals
+	 */
+	setDefaultTerminalProfile(profile: string): { closedCount: number; busyTerminals: TerminalInfo[] } {
+		const previousProfile = this.defaultTerminalProfile
+		this.defaultTerminalProfile = profile
+
+		// If profile changed, handle terminal cleanup like TerminalManager does
+		if (previousProfile !== profile) {
+			return this.handleTerminalProfileChange(profile)
+		}
+
+		return { closedCount: 0, busyTerminals: [] }
+	}
+
+	// Additional methods required for TerminalManager compatibility
+
+	/** Disposables array (for VSCode compatibility) */
+	disposables: any[] = []
+
+	/**
+	 * Find a TerminalInfo by its terminal instance.
+	 * @param terminal The terminal instance to find
+	 * @returns The terminal info or undefined
+	 */
+	findTerminalInfoByTerminal(terminal: any): TerminalInfo | undefined {
+		const terminals = this.registry.getAllTerminals()
+		return terminals.find((t) => t.terminal === terminal)
+	}
+
+	/**
+	 * Check if a terminal's CWD matches its expected pending change.
+	 * @param terminalInfo The terminal info to check
+	 * @returns Whether the CWD matches
+	 */
+	isCwdMatchingExpected(terminalInfo: TerminalInfo): boolean {
+		if (!(terminalInfo as any).pendingCwdChange) {
+			return false
+		}
+		const currentCwd = (terminalInfo.terminal as any)._cwd
+		const targetCwd = (terminalInfo as any).pendingCwdChange
+		return currentCwd === targetCwd
+	}
+
+	/**
+	 * Filter terminals based on a provided criteria function.
+	 * @param filterFn Function that accepts TerminalInfo and returns boolean
+	 * @returns Array of terminals that match the criteria
+	 */
+	filterTerminals(filterFn: (terminal: TerminalInfo) => boolean): TerminalInfo[] {
+		const terminals = this.registry.getAllTerminals()
+		return terminals.filter(filterFn)
+	}
+
+	/**
+	 * Close terminals that match the provided criteria.
+	 * @param filterFn Function that accepts TerminalInfo and returns boolean for terminals to close
+	 * @param force If true, closes even busy terminals
+	 * @returns Number of terminals closed
+	 */
+	closeTerminals(filterFn: (terminal: TerminalInfo) => boolean, force = false): number {
+		const terminalsToClose = this.filterTerminals(filterFn)
+		let closedCount = 0
+
+		for (const terminalInfo of terminalsToClose) {
+			if (terminalInfo.busy && !force) {
+				continue
+			}
+
+			this.terminalIds.delete(terminalInfo.id)
+			this.processes.delete(terminalInfo.id)
+			terminalInfo.terminal.dispose()
+			this.registry.removeTerminal(terminalInfo.id)
+			closedCount++
+		}
+
+		return closedCount
+	}
+
+	/**
+	 * Handle terminal management when the terminal profile changes.
+	 * @param newShellPath New shell path to use
+	 * @returns Object with information about closed terminals and remaining busy terminals
+	 */
+	handleTerminalProfileChange(newShellPath: string | undefined): {
+		closedCount: number
+		busyTerminals: TerminalInfo[]
+	} {
+		const closedCount = this.closeTerminals(
+			(terminal) => !terminal.busy && (terminal as any).shellPath !== newShellPath,
+			false,
+		)
+		const busyTerminals = this.filterTerminals((terminal) => terminal.busy && (terminal as any).shellPath !== newShellPath)
+		return { closedCount, busyTerminals }
+	}
+
+	/**
+	 * Force closure of all terminals (including busy ones).
+	 * @returns Number of terminals closed
+	 */
+	closeAllTerminals(): number {
+		return this.closeTerminals(() => true, true)
+	}
+
+	// =========================================================================
+	// Background Command Tracking Methods
+	// =========================================================================
+
+	/**
+	 * Track a command that will continue running in the background.
+	 * Called when user clicks "Proceed While Running".
+	 * Creates a log file and pipes output to it.
+	 * Sets up a 10-minute hard timeout to prevent zombie processes.
+	 *
+	 * @param process The terminal process to track
+	 * @param command The command string being executed
+	 * @param existingOutput Output lines already captured before tracking started
+	 * @returns The background command info with log file path
+	 */
+	trackBackgroundCommand(
+		process: TerminalProcessResultPromise,
+		command: string,
+		existingOutput: string[] = [],
+	): BackgroundCommand {
+		const id = `background-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+		// Use ClineTempManager for proper temp file management and cleanup
+		const logFilePath = ClineTempManager.createTempFilePath("background")
+
+		const backgroundCommand: BackgroundCommand = {
+			id,
+			command,
+			startTime: Date.now(),
+			status: "running",
+			logFilePath,
+			lineCount: existingOutput.length,
+			process,
+		}
+
+		// Create write stream for log file
+		const logStream = fs.createWriteStream(logFilePath, { flags: "a" })
+		this.logStreams.set(id, logStream)
+
+		// Write existing output that was captured before tracking started
+		if (existingOutput.length > 0) {
+			logStream.write(existingOutput.join("\n") + "\n")
+		}
+
+		// Pipe future process output to log file
+		process.on("line", (line: string) => {
+			backgroundCommand.lineCount++
+			logStream.write(line + "\n")
+		})
+
+		// Set up 10-minute hard timeout to prevent zombie processes
+		const timeoutId = setTimeout(() => {
+			if (backgroundCommand.status === "running") {
+				backgroundCommand.status = "timed_out"
+				logStream.write("\n[TIMEOUT] Process killed after 10 minutes\n")
+				logStream.end()
+
+				// Terminate the process if it has a terminate method
+				if (process && typeof (process as any).terminate === "function") {
+					;(process as any).terminate()
+				}
+			}
+		}, BACKGROUND_COMMAND_TIMEOUT_MS)
+		this.backgroundTimeouts.set(id, timeoutId)
+
+		// Listen for completion - clear timeout
+		process.on("completed", (details) => {
+			// Guard: Skip if already handled by timeout
+			if (backgroundCommand.status !== "running") {
+				return
+			}
+			const timeout = this.backgroundTimeouts.get(id)
+			if (timeout) {
+				clearTimeout(timeout)
+				this.backgroundTimeouts.delete(id)
+			}
+			const exitCode = details?.exitCode
+			const signal = details?.signal
+			if (typeof exitCode === "number") {
+				backgroundCommand.exitCode = exitCode
+			}
+
+			if ((typeof exitCode === "number" && exitCode !== 0) || signal) {
+				backgroundCommand.status = "error"
+				if (typeof exitCode === "number" && exitCode !== 0) {
+					logStream.write(`\n[EXIT_CODE] Process exited with code ${exitCode}\n`)
+				}
+				if (signal) {
+					logStream.write(`\n[SIGNAL] Process terminated by signal ${signal}\n`)
+				}
+			} else {
+				backgroundCommand.status = "completed"
+			}
+			logStream.end()
+		})
+
+		// Listen for errors - clear timeout
+		process.on("error", (error: Error) => {
+			// Guard: Skip if already handled by timeout
+			if (backgroundCommand.status !== "running") {
+				return
+			}
+			const timeout = this.backgroundTimeouts.get(id)
+			if (timeout) {
+				clearTimeout(timeout)
+				this.backgroundTimeouts.delete(id)
+			}
+			backgroundCommand.status = "error"
+			// Try to extract exit code from error message if available
+			const exitCodeMatch = error.message.match(/exit code (\d+)/)
+			if (exitCodeMatch) {
+				backgroundCommand.exitCode = Number.parseInt(exitCodeMatch[1], 10)
+			}
+			logStream.end()
+		})
+
+		this.backgroundCommands.set(id, backgroundCommand)
+		return backgroundCommand
+	}
+
+	/**
+	 * Get a specific background command by ID.
+	 */
+	getBackgroundCommand(id: string): BackgroundCommand | undefined {
+		return this.backgroundCommands.get(id)
+	}
+
+	/**
+	 * Get all tracked background commands.
+	 */
+	getAllBackgroundCommands(): BackgroundCommand[] {
+		return Array.from(this.backgroundCommands.values())
+	}
+
+	/**
+	 * Get only running background commands.
+	 */
+	getRunningBackgroundCommands(): BackgroundCommand[] {
+		return this.getAllBackgroundCommands().filter((c) => c.status === "running")
+	}
+
+	/**
+	 * Check if there are any active background commands.
+	 */
+	hasActiveBackgroundCommands(): boolean {
+		return this.getRunningBackgroundCommands().length > 0
+	}
+
+	/**
+	 * Cancel/terminate a specific background command.
+	 * @param id The background command ID to cancel
+	 * @returns true if cancelled, false if not found or already completed
+	 */
+	cancelBackgroundCommand(id: string): boolean {
+		const command = this.backgroundCommands.get(id)
+		if (!command || command.status !== "running") {
+			return false
+		}
+
+		// Clear timeout
+		const timeout = this.backgroundTimeouts.get(id)
+		if (timeout) {
+			clearTimeout(timeout)
+			this.backgroundTimeouts.delete(id)
+		}
+
+		// Close log stream
+		const logStream = this.logStreams.get(id)
+		if (logStream) {
+			logStream.write("\n[CANCELLED] Command cancelled by user\n")
+			logStream.end()
+			this.logStreams.delete(id)
+		}
+
+		// Terminate process
+		if (command.process && typeof (command.process as any).terminate === "function") {
+			;(command.process as any).terminate()
+		}
+
+		command.status = "error"
+		return true
+	}
+
+	/**
+	 * Get a summary string for environment details.
+	 * Shows running background commands with duration, line count, and log paths.
+	 */
+	getBackgroundCommandsSummary(): string {
+		const running = this.getRunningBackgroundCommands()
+		if (running.length === 0) {
+			return ""
+		}
+
+		const lines = [`# Background Commands (${running.length} running)`]
+		for (const c of running) {
+			const duration = Math.round((Date.now() - c.startTime) / 1000 / 60)
+			lines.push(`- ${c.command} (running ${duration}m, ${c.lineCount} lines, log: ${c.logFilePath})`)
+		}
+		return lines.join("\n")
+	}
+
+	/**
+	 * Clean up all background command resources.
+	 * Called when disposing the manager.
+	 */
+	disposeBackgroundCommands(): void {
+		// Clear all timeouts
+		for (const [_id, timeout] of this.backgroundTimeouts) {
+			clearTimeout(timeout)
+		}
+		this.backgroundTimeouts.clear()
+
+		// Close all log streams
+		for (const [_id, logStream] of this.logStreams) {
+			try {
+				logStream.end()
+			} catch (_error) {
+				// Ignore errors when closing log streams
+			}
+		}
+		this.logStreams.clear()
+
+		// Clear command tracking
+		this.backgroundCommands.clear()
+	}
+}
diff --git a/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalProcess.ts b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalProcess.ts
new file mode 100644
index 0000000..1cce002
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalProcess.ts
@@ -0,0 +1,364 @@
+/**
+ * StandaloneTerminalProcess - Manages command execution in standalone environments.
+ *
+ * This class handles subprocess management for terminal commands when running
+ * outside of VSCode (CLI, JetBrains). It spawns child processes and streams
+ * their output through events.
+ *
+ * Implements ITerminalProcess interface for polymorphic usage with CommandExecutor.
+ */
+
+import { telemetryService } from "@services/telemetry"
+import { ChildProcess, spawn } from "child_process"
+import { EventEmitter } from "events"
+import { Logger } from "@/shared/services/Logger"
+import { terminateProcessTree } from "@/utils/process-termination"
+
+import {
+	isCompilingOutput,
+	MAX_FULL_OUTPUT_SIZE,
+	MAX_UNRETRIEVED_LINES,
+	PROCESS_HOT_TIMEOUT_COMPILING,
+	PROCESS_HOT_TIMEOUT_NORMAL,
+	TRUNCATE_KEEP_LINES,
+} from "../constants"
+import type { ITerminal, ITerminalProcess, TerminalCompletionDetails, TerminalProcessEvents } from "../types"
+import { getShellArgs } from "./shellArgs"
+
+/**
+ * Manages the execution of a command in a standalone terminal environment.
+ * Extends EventEmitter to provide real-time output streaming.
+ *
+ * Implements ITerminalProcess for polymorphic usage with CommandExecutor.
+ *
+ * Events:
+ * - 'line': Emitted for each line of output
+ * - 'completed': Emitted when the process completes
+ * - 'continue': Emitted when continue() is called
+ * - 'error': Emitted on process errors
+ * - 'no_shell_integration': Emitted for compatibility (never actually emitted in standalone)
+ */
+export class StandaloneTerminalProcess extends EventEmitter<TerminalProcessEvents> implements ITerminalProcess {
+	/** We don't need to wait since we control the process directly */
+	waitForShellIntegration = false
+
+	/** Whether we're actively listening for output */
+	isListening = true
+
+	/** Buffer for incomplete lines */
+	private buffer = ""
+
+	/** Full output captured from the process */
+	private fullOutput = ""
+
+	/** Index of last retrieved output position */
+	private lastRetrievedIndex = 0
+
+	/** Whether the process is actively outputting */
+	isHot = false
+
+	/** Timer for tracking hot state */
+	private hotTimer: NodeJS.Timeout | null = null
+
+	/** The spawned child process */
+	private childProcess: ChildProcess | null = null
+
+	/** Exit code from the process */
+	private exitCode: number | null = null
+
+	/** Exit signal from the process */
+	private signal: NodeJS.Signals | null = null
+
+	/** Whether the process has completed */
+	private isCompleted = false
+
+	constructor() {
+		super()
+	}
+
+	/**
+	 * Run a command in the terminal.
+	 * @param terminal The terminal instance to run in
+	 * @param command The command to execute
+	 */
+	async run(terminal: ITerminal, command: string): Promise<void> {
+		// Get shell and working directory from terminal
+		const shell = (terminal as any)._shellPath || this.getDefaultShell()
+		const cwd = (terminal as any)._cwd || process.cwd()
+
+		// Prepare command for execution
+		const shellArgs = getShellArgs(shell, command)
+
+		Logger.debug(`[StandaloneTerminalProcess] spawning ${shell} in ${cwd}`)
+
+		try {
+			// Create shell options
+			const shellOptions: {
+				cwd: string
+				stdio: ["ignore", "pipe", "pipe"]
+				env: NodeJS.ProcessEnv
+				shell?: boolean
+			} = {
+				cwd: cwd,
+				stdio: ["ignore", "pipe", "pipe"], // Disable STDIN to prevent interactivity
+				env: {
+					...process.env,
+					// Set SHELL to match the shell we're actually spawning, not
+					// whatever the parent process inherited. This ensures child
+					// processes and scripts that inspect $SHELL see the correct value.
+					SHELL: shell,
+					TERM: "xterm-256color",
+					PAGER: "cat", // Prevent less from being used, reducing interactivity
+					EDITOR: process.env.EDITOR || "cat", // Set EDITOR if not already set
+					GIT_PAGER: "cat", // Prevent git from using less
+					SYSTEMD_PAGER: "", // Disable systemd pager
+					MANPAGER: "cat", // Disable man pager
+				},
+			}
+
+			// Enable the shell option for "cmd.exe" to prevent double quotes from being over escaped
+			if (shell.toLowerCase().includes("cmd")) {
+				shellOptions.shell = true
+
+				// windowsHide keeps a console-less parent from popping a window for
+				// the child (see the non-cmd branch); no-op on non-Windows.
+				this.childProcess = spawn("cmd.exe", shellArgs, { ...shellOptions, windowsHide: true })
+			} else {
+				// On Windows, detached:true without windowsHide:true allocates a new
+				// console for the child when the parent (cline-core launched by the
+				// IDE) has none, routing the child's stdio to that console instead
+				// of our pipes. Drop detached on win32 (tree-kill handles cleanup)
+				// and force windowsHide so the child stays attached to our pipes.
+				// windowsHide is a no-op on non-Windows platforms.
+				this.childProcess = spawn(shell, shellArgs, {
+					...shellOptions,
+					detached: process.platform !== "win32",
+					windowsHide: true,
+				})
+			}
+
+			Logger.debug(`[StandaloneTerminalProcess] spawned pid=${this.childProcess.pid ?? "<none>"}`)
+
+			// Track process state
+			let didEmitEmptyLine = false
+
+			// Handle stdout
+			this.childProcess.stdout?.on("data", (data: Buffer) => {
+				const output = data.toString()
+				this.handleOutput(output, didEmitEmptyLine)
+				if (!didEmitEmptyLine && output) {
+					this.emit("line", "") // Signal start of output
+					didEmitEmptyLine = true
+				}
+			})
+
+			// Handle stderr
+			this.childProcess.stderr?.on("data", (data: Buffer) => {
+				const output = data.toString()
+				this.handleOutput(output, didEmitEmptyLine)
+				if (!didEmitEmptyLine && output) {
+					this.emit("line", "")
+					didEmitEmptyLine = true
+				}
+			})
+
+			// Handle process completion
+			this.childProcess.on("close", (code: number | null, signal: NodeJS.Signals | null) => {
+				Logger.info(
+					`[StandaloneTerminalProcess] close: code=${code} signal=${signal} fullOutputLen=${this.fullOutput.length}`,
+				)
+				this.exitCode = code
+				this.signal = signal
+				this.isCompleted = true
+				this.emitRemainingBuffer()
+
+				// Clear hot timer
+				if (this.hotTimer) {
+					clearTimeout(this.hotTimer)
+					this.isHot = false
+				}
+
+				// Track terminal execution telemetry with exit code for failure diagnosis
+				const success = code === 0 || code === null
+				telemetryService.captureTerminalExecution(success, "standalone", "child_process", code)
+
+				this.emit("completed", { exitCode: this.exitCode, signal: this.signal })
+				this.emit("continue")
+			})
+
+			// Handle process errors (spawn failures)
+			this.childProcess.on("error", (error: Error) => {
+				Logger.error(`[StandaloneTerminalProcess] child error: ${error?.message ?? error}`)
+				// Track terminal execution error telemetry
+				// method: "child_process_error" already indicates spawn failure
+				telemetryService.captureTerminalExecution(false, "standalone", "child_process_error")
+				this.emit("error", error)
+			})
+
+			// Update terminal's process reference
+			;(terminal as any)._process = this.childProcess
+			;(terminal as any)._processId = this.childProcess.pid
+		} catch (error) {
+			Logger.error(`[StandaloneTerminalProcess] spawn threw synchronously: ${(error as Error)?.message ?? String(error)}`)
+			this.emit("error", error)
+		}
+	}
+
+	/**
+	 * Handle output from the process.
+	 * @param data The output data
+	 * @param _didEmitEmptyLine Whether we've already emitted an empty line
+	 */
+	private handleOutput(data: string, _didEmitEmptyLine: boolean): void {
+		// Set process as hot (actively outputting)
+		this.isHot = true
+		if (this.hotTimer) {
+			clearTimeout(this.hotTimer)
+		}
+
+		// Check for compilation markers to adjust hot timeout
+		const isCompiling = isCompilingOutput(data)
+		const hotTimeout = isCompiling ? PROCESS_HOT_TIMEOUT_COMPILING : PROCESS_HOT_TIMEOUT_NORMAL
+		this.hotTimer = setTimeout(() => {
+			this.isHot = false
+		}, hotTimeout)
+
+		// Store full output with size cap to prevent memory exhaustion
+		this.fullOutput += data
+
+		// Cap fullOutput at MAX_FULL_OUTPUT_SIZE to prevent memory exhaustion
+		if (this.fullOutput.length > MAX_FULL_OUTPUT_SIZE) {
+			// Keep last half of max size
+			this.fullOutput = this.fullOutput.slice(-MAX_FULL_OUTPUT_SIZE / 2)
+			// Reset lastRetrievedIndex since we truncated the beginning
+			this.lastRetrievedIndex = 0
+		}
+
+		if (this.isListening) {
+			this.emitLines(data)
+		}
+	}
+
+	/**
+	 * Emit lines from the buffer.
+	 * @param chunk The chunk of data to process
+	 */
+	private emitLines(chunk: string): void {
+		this.buffer += chunk
+		let lineEndIndex: number
+		while ((lineEndIndex = this.buffer.indexOf("\n")) !== -1) {
+			const line = this.buffer.slice(0, lineEndIndex).trimEnd()
+			this.emit("line", line)
+			this.buffer = this.buffer.slice(lineEndIndex + 1)
+		}
+	}
+
+	/**
+	 * Emit any remaining content in the buffer.
+	 */
+	private emitRemainingBuffer(): void {
+		if (this.buffer && this.isListening) {
+			const remainingBuffer = this.removeLastLineArtifacts(this.buffer)
+			if (remainingBuffer) {
+				this.emit("line", remainingBuffer)
+			}
+			this.buffer = ""
+			this.lastRetrievedIndex = this.fullOutput.length
+		}
+	}
+
+	/**
+	 * Continue execution without waiting for completion.
+	 * Emits "continue" event but keeps emitting "line" events for background tracking.
+	 *
+	 * Note: We intentionally do NOT call removeAllListeners("line") or set isListening=false
+	 * because background command tracking needs to continue receiving output lines
+	 * after the user clicks "Proceed While Running".
+	 */
+	continue(): void {
+		this.emitRemainingBuffer()
+		// Keep isListening = true so we continue emitting "line" events
+		// This is needed for background command tracking to log output to file
+		this.emit("continue")
+	}
+
+	/**
+	 * Get output that hasn't been retrieved yet.
+	 * Truncates if output is too large to prevent context window overflow.
+	 * @returns The unretrieved output (truncated if necessary)
+	 */
+	getUnretrievedOutput(): string {
+		const unretrieved = this.fullOutput.slice(this.lastRetrievedIndex)
+		this.lastRetrievedIndex = this.fullOutput.length
+
+		// Truncate if too many lines to prevent context overflow
+		const lines = unretrieved.split("\n")
+		if (lines.length > MAX_UNRETRIEVED_LINES) {
+			const first = lines.slice(0, TRUNCATE_KEEP_LINES)
+			const last = lines.slice(-TRUNCATE_KEEP_LINES)
+			const skipped = lines.length - first.length - last.length
+			return this.removeLastLineArtifacts([...first, `\n... (${skipped} lines truncated) ...\n`, ...last].join("\n"))
+		}
+
+		return this.removeLastLineArtifacts(unretrieved)
+	}
+
+	getCompletionDetails(): TerminalCompletionDetails {
+		return {
+			exitCode: this.exitCode,
+			signal: this.signal,
+		}
+	}
+
+	/**
+	 * Remove shell prompt artifacts from the end of output.
+	 * @param output The output to clean
+	 * @returns Cleaned output
+	 */
+	private removeLastLineArtifacts(output: string): string {
+		const lines = output.trimEnd().split("\n")
+		if (lines.length > 0) {
+			const lastLine = lines[lines.length - 1]
+			lines[lines.length - 1] = lastLine.replace(/[%$#>]\s*$/, "")
+		}
+		return lines.join("\n").trimEnd()
+	}
+
+	/**
+	 * Get the default shell for the current platform.
+	 * @returns The default shell path
+	 */
+	private getDefaultShell(): string {
+		if (process.platform === "win32") {
+			return process.env.COMSPEC || "cmd.exe"
+		}
+		return process.env.SHELL || "/bin/bash"
+	}
+
+	/**
+	 * Terminate the process and all its children.
+	 *
+	 * Uses terminateProcessTree utility which handles:
+	 * - Cross-platform process tree termination via tree-kill
+	 * - Graceful shutdown with SIGTERM
+	 * - SIGKILL fallback after 2 second timeout
+	 */
+	async terminate(): Promise<void> {
+		if (!this.childProcess || this.isCompleted) {
+			return
+		}
+
+		const pid = this.childProcess.pid
+		if (!pid) {
+			// Fallback: try to kill the process directly if PID is unavailable
+			this.childProcess.kill("SIGTERM")
+			return
+		}
+
+		await terminateProcessTree({
+			pid,
+			childProcess: this.childProcess,
+			isCompleted: () => this.isCompleted,
+		})
+	}
+}
diff --git a/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalRegistry.ts b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalRegistry.ts
new file mode 100644
index 0000000..7105c46
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/standalone/StandaloneTerminalRegistry.ts
@@ -0,0 +1,109 @@
+/**
+ * StandaloneTerminalRegistry - Manages terminal instances in standalone environments.
+ *
+ * This class tracks and manages multiple terminal instances, providing
+ * functionality to create, retrieve, update, and remove terminals.
+ */
+
+import { Logger } from "@/shared/services/Logger"
+import type { ITerminal, StandaloneTerminalOptions, TerminalInfo } from "../types"
+import { StandaloneTerminal } from "./StandaloneTerminal"
+
+/**
+ * Registry for tracking standalone terminal instances.
+ * Provides CRUD operations for terminal management.
+ */
+export class StandaloneTerminalRegistry {
+	/** Map of terminal ID to terminal info */
+	private terminals: Map<number, TerminalInfo> = new Map()
+
+	/** Next available terminal ID */
+	private nextId: number = 1
+
+	/**
+	 * Create a new terminal and register it.
+	 * @param options Terminal creation options
+	 * @returns The created terminal info
+	 */
+	createTerminal(options: StandaloneTerminalOptions = {}): TerminalInfo {
+		const terminal = new StandaloneTerminal(options)
+		const id = this.nextId++
+
+		const terminalInfo: TerminalInfo = {
+			id: id,
+			terminal: terminal as ITerminal,
+			busy: false,
+			lastCommand: "",
+			shellPath: options.shellPath,
+			lastActive: Date.now(),
+			pendingCwdChange: undefined,
+			cwdResolved: undefined,
+		}
+
+		this.terminals.set(id, terminalInfo)
+		Logger.log(`[StandaloneTerminalRegistry] Created terminal ${id}`)
+		return terminalInfo
+	}
+
+	/**
+	 * Get a terminal by ID.
+	 * @param id The terminal ID
+	 * @returns The terminal info or undefined if not found
+	 */
+	getTerminal(id: number): TerminalInfo | undefined {
+		return this.terminals.get(id)
+	}
+
+	/**
+	 * Get all registered terminals.
+	 * @returns Array of all terminal info objects
+	 */
+	getAllTerminals(): TerminalInfo[] {
+		return Array.from(this.terminals.values())
+	}
+
+	/**
+	 * Remove a terminal from the registry and dispose it.
+	 * @param id The terminal ID to remove
+	 */
+	removeTerminal(id: number): void {
+		const terminalInfo = this.terminals.get(id)
+		if (terminalInfo) {
+			terminalInfo.terminal.dispose()
+			this.terminals.delete(id)
+			Logger.log(`[StandaloneTerminalRegistry] Removed terminal ${id}`)
+		}
+	}
+
+	/**
+	 * Update a terminal's properties.
+	 * @param id The terminal ID
+	 * @param updates Partial terminal info to update
+	 */
+	updateTerminal(id: number, updates: Partial<TerminalInfo>): void {
+		const terminalInfo = this.terminals.get(id)
+		if (terminalInfo) {
+			Object.assign(terminalInfo, updates)
+		}
+	}
+
+	/**
+	 * Clear all terminals from the registry.
+	 */
+	clear(): void {
+		for (const terminalInfo of this.terminals.values()) {
+			terminalInfo.terminal.dispose()
+		}
+		this.terminals.clear()
+		this.nextId = 1
+		Logger.log(`[StandaloneTerminalRegistry] Cleared all terminals`)
+	}
+
+	/**
+	 * Get the count of registered terminals.
+	 * @returns Number of terminals
+	 */
+	get size(): number {
+		return this.terminals.size
+	}
+}
diff --git a/apps/vscode/src/integrations/terminal/standalone/__tests__/shellArgs.test.ts b/apps/vscode/src/integrations/terminal/standalone/__tests__/shellArgs.test.ts
new file mode 100644
index 0000000..04f4229
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/standalone/__tests__/shellArgs.test.ts
@@ -0,0 +1,63 @@
+import { describe, it } from "bun:test"
+import assert from "node:assert/strict"
+import { getShellArgs, unwrapPowerShell } from "../shellArgs"
+
+describe("unwrapPowerShell", () => {
+	it("strips a double-quoted powershell -Command wrapper", () => {
+		assert.equal(unwrapPowerShell(`powershell -Command "Write-Output 'hi'"`), "Write-Output 'hi'")
+	})
+
+	it("strips a single-quoted pwsh -Command wrapper", () => {
+		assert.equal(unwrapPowerShell(`pwsh -Command 'Get-Date'`), "Get-Date")
+	})
+
+	it("strips a powershell.exe -c wrapper", () => {
+		assert.equal(unwrapPowerShell(`powershell.exe -c "dir"`), "dir")
+	})
+
+	it("handles a nested-quote command without shredding inner quotes", () => {
+		const inner = `if (Test-Path 'CHANGELOG.md') { Remove-Item 'CHANGELOG.md' -Force }`
+		assert.equal(unwrapPowerShell(`powershell -Command "${inner}"`), inner)
+	})
+
+	it("returns a non-wrapped command verbatim", () => {
+		assert.equal(unwrapPowerShell(`Remove-Item -Path "x" -Force`), `Remove-Item -Path "x" -Force`)
+		assert.equal(unwrapPowerShell(`dir C:\\Users\\me\\file.log`), `dir C:\\Users\\me\\file.log`)
+	})
+
+	it("does not unwrap when content past the closing quote remains (avoids mis-rewrite)", () => {
+		// The body cannot contain the delimiter, so a second quoted token fails to match.
+		const input = `powershell -Command "foo" "bar"`
+		assert.equal(unwrapPowerShell(input), input)
+	})
+
+	it("does not unwrap a bare command that merely mentions powershell", () => {
+		assert.equal(unwrapPowerShell(`echo powershell -Command "x"`), `echo powershell -Command "x"`)
+	})
+})
+
+describe("getShellArgs", () => {
+	it("uses -NoProfile -NonInteractive -Command and unwraps for PowerShell on win32", () => {
+		assert.deepEqual(getShellArgs("powershell.exe", `Write-Output 'hi'`, "win32"), [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			"Write-Output 'hi'",
+		])
+		assert.deepEqual(getShellArgs("pwsh", `powershell -Command "dir"`, "win32"), [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			"dir",
+		])
+	})
+
+	it("uses /d /s /c for cmd on win32", () => {
+		assert.deepEqual(getShellArgs("cmd.exe", "echo hi", "win32"), ["/d", "/s", "/c", "echo hi"])
+	})
+
+	it("uses -c for POSIX shells off win32", () => {
+		assert.deepEqual(getShellArgs("/bin/bash", "echo hi", "linux"), ["-c", "echo hi"])
+		assert.deepEqual(getShellArgs("/bin/zsh", "echo hi", "darwin"), ["-c", "echo hi"])
+	})
+})
diff --git a/apps/vscode/src/integrations/terminal/standalone/shellArgs.ts b/apps/vscode/src/integrations/terminal/standalone/shellArgs.ts
new file mode 100644
index 0000000..a5ba8dd
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/standalone/shellArgs.ts
@@ -0,0 +1,44 @@
+/**
+ * Shell argument construction for the standalone terminal.
+ *
+ * Extracted into a pure module so the quoting/flag logic is unit-testable
+ * without spawning a process. Mirrors the shape of the canonical helper in
+ * `@cline/shared` (sdk/packages/shared/src/parse/shell.ts).
+ */
+
+/**
+ * Strip a redundant outer `powershell|pwsh [.exe] -Command|-c "…"` wrapper that
+ * LLMs sometimes emit. Without this we'd spawn powershell.exe with another
+ * powershell.exe as its -Command argument and the inner shell would receive
+ * quote-shredded args.
+ *
+ * Only unwraps when the entire string is exactly one quoted token whose body
+ * does not itself contain the delimiter; anything else is returned verbatim so
+ * the worst case is "no change" rather than an incorrect rewrite.
+ */
+export function unwrapPowerShell(command: string): string {
+	const match = command.match(/^\s*(?:powershell|pwsh)(?:\.exe)?\s+-(?:Command|c)\s+(["'])((?:(?!\1).)*)\1\s*$/i)
+	return match ? match[2] : command
+}
+
+/**
+ * Build the argument vector for invoking `command` through `shell`.
+ *
+ * The shell family is decided from the shell name. `platform` is injected
+ * (defaulting to the host) only so the win32-vs-posix branch is testable; it
+ * does not otherwise change behavior.
+ */
+export function getShellArgs(shell: string, command: string, platform: NodeJS.Platform = process.platform): string[] {
+	if (platform === "win32") {
+		if (shell.toLowerCase().includes("powershell") || shell.toLowerCase().includes("pwsh")) {
+			// -NoProfile silences user $PROFILE side effects that otherwise
+			// leak into the captured output; -NonInteractive avoids prompts.
+			return ["-NoProfile", "-NonInteractive", "-Command", unwrapPowerShell(command)]
+		}
+		return ["/d", "/s", "/c", command]
+	}
+	// Non-login shell (`-c`, no `-l`): the child inherits the parent's PATH via
+	// process.env, so login dotfiles are normally redundant. A GUI-launched IDE
+	// without a login PATH is the edge case to watch if a tool goes missing.
+	return ["-c", command]
+}
diff --git a/apps/vscode/src/integrations/terminal/types.ts b/apps/vscode/src/integrations/terminal/types.ts
new file mode 100644
index 0000000..877c97d
--- /dev/null
+++ b/apps/vscode/src/integrations/terminal/types.ts
@@ -0,0 +1,362 @@
+/**
+ * Shared terminal types and interfaces for both VSCode and Standalone terminal managers.
+ * These types ensure compatibility between the VSCode-based TerminalManager and
+ * the StandaloneTerminalManager used in CLI/JetBrains environments.
+ */
+
+import type { ClineToolResponseContent } from "@shared/messages"
+import type { EventEmitter } from "events"
+
+// =============================================================================
+// Terminal Process Types
+// =============================================================================
+
+/**
+ * Event types for terminal process
+ */
+export interface TerminalCompletionDetails {
+	/** Process exit code when available */
+	exitCode?: number | null
+	/** Termination signal when available */
+	signal?: NodeJS.Signals | null
+}
+
+export interface TerminalProcessEvents {
+	line: [line: string]
+	continue: []
+	completed: [details?: TerminalCompletionDetails]
+	error: [error: Error]
+	no_shell_integration: []
+}
+
+/**
+ * Interface for terminal process implementations.
+ * Both VscodeTerminalProcess and StandaloneTerminalProcess implement this interface.
+ *
+ * Events emitted:
+ * - 'line': Emitted for each line of output
+ * - 'completed': Emitted when the process completes
+ * - 'continue': Emitted when continue() is called
+ * - 'error': Emitted on process errors
+ * - 'no_shell_integration': Emitted when shell integration is not available (VSCode only)
+ */
+export interface ITerminalProcess extends EventEmitter<TerminalProcessEvents> {
+	/**
+	 * Whether the process is actively outputting (used to stall API requests)
+	 */
+	isHot: boolean
+
+	/**
+	 * Whether to wait for shell integration before running commands.
+	 * VSCode processes may need to wait, standalone processes don't.
+	 */
+	waitForShellIntegration: boolean
+
+	/**
+	 * Continue execution without waiting for completion.
+	 * Stops event emission and resolves the promise.
+	 * This is called when user clicks "Proceed While Running".
+	 */
+	continue(): void
+
+	/**
+	 * Get output that hasn't been retrieved yet.
+	 * @returns The unretrieved output
+	 */
+	getUnretrievedOutput(): string
+
+	/**
+	 * Get completion metadata for the most recent command execution.
+	 */
+	getCompletionDetails?(): TerminalCompletionDetails
+
+	/**
+	 * Terminate the process if it's still running.
+	 * Only available for standalone processes (child_process).
+	 * VSCode terminal processes cannot be terminated via this interface.
+	 *
+	 * May be async to allow for graceful shutdown with SIGKILL fallback.
+	 */
+	terminate?(): void | Promise<void>
+}
+
+// =============================================================================
+// Terminal Types
+// =============================================================================
+
+/**
+ * Represents a terminal instance with its metadata and state.
+ */
+export interface TerminalInfo {
+	/** Unique identifier for the terminal */
+	id: number
+	/** The underlying terminal instance */
+	terminal: ITerminal
+	/** Whether the terminal is currently executing a command */
+	busy: boolean
+	/** The last command executed in this terminal */
+	lastCommand: string
+	/** The shell path used by this terminal (e.g., /bin/bash, /bin/zsh) */
+	shellPath?: string
+	/** Timestamp of last activity */
+	lastActive: number
+	/** Pending CWD change path (used for tracking directory changes) */
+	pendingCwdChange?: string
+	/** Promise resolver for CWD change completion */
+	cwdResolved?: { resolve: () => void; reject: (err: Error) => void }
+}
+
+/**
+ * Minimal terminal interface that both VSCode terminals and standalone terminals implement.
+ */
+export interface ITerminal {
+	/** Terminal name */
+	name: string
+	/** Promise that resolves to the process ID */
+	processId: Promise<number | undefined>
+	/** Shell integration information (if available) */
+	shellIntegration?: {
+		cwd?: { fsPath: string }
+		executeCommand?: (command: string) => {
+			read: () => AsyncIterable<string>
+		}
+	}
+	/** Send text to the terminal */
+	sendText(text: string, addNewLine?: boolean): void
+	/** Show the terminal */
+	show(): void
+	/** Hide the terminal */
+	hide(): void
+	/** Dispose of the terminal */
+	dispose(): void
+}
+
+/**
+ * Promise-like interface for terminal process results.
+ * Combines Promise<void> with ITerminalProcess for flexible usage.
+ * This allows the process to be awaited while also providing access to events.
+ */
+export type TerminalProcessResultPromise = Promise<void> &
+	ITerminalProcess & {
+		/** Listen for line output events */
+		on(event: "line", listener: (line: string) => void): TerminalProcessResultPromise
+		/** Listen for completion event */
+		on(event: "completed", listener: (details?: TerminalCompletionDetails) => void): TerminalProcessResultPromise
+		/** Listen for continue event */
+		on(event: "continue", listener: () => void): TerminalProcessResultPromise
+		/** Listen for error events */
+		on(event: "error", listener: (error: Error) => void): TerminalProcessResultPromise
+		/** Listen for no shell integration event */
+		on(event: "no_shell_integration", listener: () => void): TerminalProcessResultPromise
+		/** Listen once for any event */
+		once(event: string, listener: (...args: any[]) => void): TerminalProcessResultPromise
+	}
+
+/**
+ * Interface for terminal managers (both VSCode and Standalone implementations).
+ * Defines the contract that both implementations must follow.
+ */
+export interface ITerminalManager {
+	/**
+	 * Run a command in the specified terminal.
+	 * @param terminalInfo The terminal to run the command in
+	 * @param command The command to execute
+	 * @returns A promise-like object that emits events and resolves on completion
+	 */
+	runCommand(terminalInfo: TerminalInfo, command: string): TerminalProcessResultPromise
+
+	/**
+	 * Get or create a terminal for the specified working directory.
+	 * @param cwd The working directory for the terminal
+	 * @returns The terminal info for an available terminal
+	 */
+	getOrCreateTerminal(cwd: string): Promise<TerminalInfo>
+
+	/**
+	 * Get terminals filtered by busy state.
+	 * @param busy Whether to get busy or idle terminals
+	 * @returns Array of terminal info with id and last command
+	 */
+	getTerminals(busy: boolean): { id: number; lastCommand: string }[]
+
+	/**
+	 * Get output that hasn't been retrieved yet from a terminal.
+	 * @param terminalId The terminal ID
+	 * @returns The unretrieved output string
+	 */
+	getUnretrievedOutput(terminalId: number): string
+
+	/**
+	 * Check if a terminal's process is actively outputting.
+	 * @param terminalId The terminal ID
+	 * @returns Whether the process is hot
+	 */
+	isProcessHot(terminalId: number): boolean
+
+	/**
+	 * Dispose of all terminals and clean up resources.
+	 */
+	disposeAll(): void
+
+	/**
+	 * Set the timeout for waiting for shell integration.
+	 * @param timeout Timeout in milliseconds
+	 */
+	setShellIntegrationTimeout(timeout: number): void
+
+	/**
+	 * Enable or disable terminal reuse.
+	 * @param enabled Whether to enable terminal reuse
+	 */
+	setTerminalReuseEnabled(enabled: boolean): void
+
+	/**
+	 * Set the default terminal profile.
+	 * @param profile The profile identifier
+	 */
+	setDefaultTerminalProfile(profile: string): void
+
+	/**
+	 * Process output lines, potentially truncating if over limit.
+	 * @param outputLines Array of output lines
+	 * @param overrideLimit Optional limit override
+	 * @returns Processed output string
+	 */
+	processOutput(outputLines: string[], overrideLimit?: number): string
+}
+
+/**
+ * Options for creating a standalone terminal.
+ */
+export interface StandaloneTerminalOptions {
+	/** Terminal name */
+	name?: string
+	/** Working directory */
+	cwd?: string
+	/** Shell path to use */
+	shellPath?: string
+}
+
+// =============================================================================
+// Background Command Types
+// =============================================================================
+
+/**
+ * Represents a command running in the background after user clicked "Proceed While Running".
+ * Used by StandaloneTerminalManager to track background commands.
+ */
+export interface BackgroundCommand {
+	/** Unique identifier for the background command */
+	id: string
+	/** The command string being executed */
+	command: string
+	/** Timestamp when the command started */
+	startTime: number
+	/** Current status of the command */
+	status: "running" | "completed" | "error" | "timed_out"
+	/** Path to the log file where output is being written */
+	logFilePath: string
+	/** Number of lines written to the log file */
+	lineCount: number
+	/** Exit code if the command completed or errored */
+	exitCode?: number
+	/** The terminal process running the command */
+	process: TerminalProcessResultPromise
+}
+
+// =============================================================================
+// Command Executor Types
+// =============================================================================
+
+/**
+ * Response from an ask() call
+ */
+interface AskResponse {
+	response: string // "yesButtonClicked" | "noButtonClicked" | "messageResponse"
+	text?: string
+	images?: string[]
+	files?: string[]
+}
+
+/**
+ * Callbacks for CommandExecutor to interact with Task state
+ * These are bound methods from the Task class that allow CommandExecutor
+ * to update UI and state without owning that state directly.
+ */
+export interface CommandExecutorCallbacks {
+	/** Display a message in the chat UI (non-blocking) */
+	say: (type: string, text?: string, images?: string[], files?: string[], partial?: boolean) => Promise<number | undefined>
+	/**
+	 * Ask the user a question and wait for response (blocking)
+	 * This is used for "Proceed While Running" flow where we need to wait for user input
+	 */
+	ask: (type: string, text?: string, partial?: boolean) => Promise<AskResponse>
+	/** Resolve the currently pending ask (if any). Used to release command_output waits on terminal lifecycle transitions. */
+	resolvePendingAsk?: (response: AskResponse["response"]) => void
+	/** Update the background command running state in the controller */
+	updateBackgroundCommandState: (running: boolean) => void
+	/**
+	 * Update a cline message by index
+	 * Supports updating commandCompleted status and/or text content
+	 */
+	updateClineMessage: (index: number, updates: { commandCompleted?: boolean; text?: string }) => Promise<void>
+	/** Get cline messages array */
+	getClineMessages: () => Array<{ ask?: string; say?: string; text?: string }>
+	/** Add content to user message for next API request */
+	addToUserMessageContent: (content: { type: string; text: string }) => void
+}
+
+// =============================================================================
+// Command Orchestrator Types
+// =============================================================================
+
+/**
+ * Options for command orchestration
+ */
+export interface OrchestrationOptions {
+	/** The command being executed */
+	command: string
+	/** Optional timeout in seconds */
+	timeoutSeconds?: number
+	/** Callback to track output lines for background command tracking */
+	onOutputLine?: (line: string) => void
+	/** Whether to show shell integration warning with suggestion */
+	showShellIntegrationSuggestion?: boolean
+	/**
+	 * Callback invoked when user clicks "Proceed While Running".
+	 * Used to start background command tracking in the terminal manager.
+	 * @param existingOutput The output lines captured so far (to write to log file)
+	 * @returns The log file path if tracking was started, undefined otherwise
+	 */
+	onProceedWhileRunning?: (existingOutput: string[]) => { logFilePath: string } | undefined
+	/**
+	 * The type of terminal being used for telemetry tracking.
+	 * Defaults to "vscode" for backward compatibility.
+	 */
+	terminalType?: "vscode" | "standalone"
+	/**
+	 * If true, suppresses command-output ask/say UI interactions.
+	 * Output is still collected and included in the final result.
+	 */
+	suppressUserInteraction?: boolean
+}
+
+/**
+ * Result of command orchestration
+ */
+export interface OrchestrationResult {
+	/** Whether the user rejected/cancelled the command */
+	userRejected: boolean
+	/** The result content to return */
+	result: ClineToolResponseContent
+	/** Whether the command completed */
+	completed: boolean
+	/** All output lines captured */
+	outputLines: string[]
+	/** Path to log file if output was too large and written to file */
+	logFilePath?: string
+	/** Process exit code when available */
+	exitCode?: number | null
+	/** Process termination signal when available */
+	signal?: NodeJS.Signals | null
+}
diff --git a/apps/vscode/src/packages/execa.ts b/apps/vscode/src/packages/execa.ts
new file mode 100644
index 0000000..398dede
--- /dev/null
+++ b/apps/vscode/src/packages/execa.ts
@@ -0,0 +1 @@
+export { execa } from "execa"
diff --git a/apps/vscode/src/registry.ts b/apps/vscode/src/registry.ts
new file mode 100644
index 0000000..c8edf76
--- /dev/null
+++ b/apps/vscode/src/registry.ts
@@ -0,0 +1,99 @@
+import { name, publisher, version } from "../package.json"
+import { HostProvider } from "./hosts/host-provider"
+
+const prefix = name === "claude-dev" ? "cline" : name
+
+/**
+ * List of commands with the name of the extension they are registered under.
+ * These should match the command IDs defined in package.json.
+ * For Nightly build, the publish script has updated all the commands to use the extension name as prefix.
+ * In production, all commands are registered under "cline" for consistency.
+ */
+const ClineCommands = {
+	PlusButton: prefix + ".plusButtonClicked",
+	McpButton: prefix + ".mcpButtonClicked",
+	MarketplaceButton: prefix + ".marketplaceButtonClicked",
+	SettingsButton: prefix + ".settingsButtonClicked",
+	HistoryButton: prefix + ".historyButtonClicked",
+	AccountButton: prefix + ".accountButtonClicked",
+	WorktreesButton: prefix + ".worktreesButtonClicked",
+	TerminalOutput: prefix + ".addTerminalOutputToChat",
+	AddToChat: prefix + ".addToChat",
+	FixWithCline: prefix + ".fixWithCline",
+	ExplainCode: prefix + ".explainCode",
+	ImproveCode: prefix + ".improveCode",
+	FocusChatInput: prefix + ".focusChatInput",
+	Walkthrough: prefix + ".openWalkthrough",
+	GenerateCommit: prefix + ".generateGitCommitMessage",
+	AbortCommit: prefix + ".abortGitCommitMessage",
+	ReconstructTaskHistory: prefix + ".reconstructTaskHistory",
+	// Jupyter Notebook commands
+	JupyterGenerateCell: prefix + ".jupyterGenerateCell",
+	JupyterExplainCell: prefix + ".jupyterExplainCell",
+	JupyterImproveCell: prefix + ".jupyterImproveCell",
+}
+
+/**
+ * IDs for the views registered by the extension.
+ * These should match the name + view IDs defined in package.json.
+ */
+const ClineViewIds = {
+	Sidebar: name + ".SidebarProvider",
+}
+
+/**
+ * The registry info for the extension, including its ID, name, version, commands, and views
+ * registered for the current host.
+ */
+export const ExtensionRegistryInfo = {
+	id: publisher + "." + name,
+	name,
+	version,
+	publisher,
+	commands: ClineCommands,
+	views: ClineViewIds,
+}
+
+export interface HostInfo {
+	/**
+	 * The name of the host platform, e.g VSCode, IntelliJ Ultimate Edition, etc.
+	 */
+	platform: string
+	/**
+	 * The operating system platform, e.g. linux, darwin, win32
+	 */
+	os: string
+	/**
+	 * The type of the cline host environment, e.g. 'VSCode Extension', 'Cline for JetBrains', 'CLI'
+	 * This is different from the platform because there are many JetBrains IDEs, but they all use the same
+	 * plugin.
+	 */
+	ide: string
+	/**
+	 * A distinct ID for this installation of the host client
+	 */
+	distinctId: string
+	/**
+	 * The version of the host platform, e.g. 1.103.0 for VSCode, or 2025.1.1.1 for JetBrains IDEs.
+	 */
+	hostVersion?: string
+	/**
+	 * The version of Cline that the host client is running
+	 */
+	extensionVersion: string
+}
+
+let hostInfo = null as HostInfo | null
+
+export const HostRegistryInfo = {
+	init: async (distinctId: string) => {
+		const host = await HostProvider.env.getHostVersion({})
+		const hostVersion = host.version
+		const extensionVersion = host.clineVersion || ExtensionRegistryInfo.version
+		const platform = host.platform || "unknown"
+		const os = process.platform || "unknown"
+		const ide = host.clineType || "unknown"
+		hostInfo = { hostVersion, extensionVersion, platform, os, ide, distinctId }
+	},
+	get: () => hostInfo,
+}
diff --git a/apps/vscode/src/sdk/SdkController.test.ts b/apps/vscode/src/sdk/SdkController.test.ts
new file mode 100644
index 0000000..e430996
--- /dev/null
+++ b/apps/vscode/src/sdk/SdkController.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest"
+import { isClineManagedProvider } from "@/shared/utils/cline"
+import { resolveWorkspaceRootPath } from "./workspace-root"
+
+describe("isClineManagedProvider", () => {
+	it("treats both Cline account providers as Cline providers", () => {
+		expect(isClineManagedProvider("cline")).toBe(true)
+		expect(isClineManagedProvider("cline-pass")).toBe(true)
+		expect(isClineManagedProvider("anthropic")).toBe(false)
+		expect(isClineManagedProvider(undefined)).toBe(false)
+	})
+})
+
+describe("resolveWorkspaceRootPath", () => {
+	it("uses the first non-empty workspace path when available", () => {
+		expect(resolveWorkspaceRootPath(["", "/workspace"], "/Users/tester/Desktop")).toBe("/workspace")
+	})
+
+	it("falls back to Desktop when no workspace folder is open", () => {
+		expect(resolveWorkspaceRootPath([], "/Users/tester/Desktop")).toBe("/Users/tester/Desktop")
+	})
+})
diff --git a/apps/vscode/src/sdk/SdkController.ts b/apps/vscode/src/sdk/SdkController.ts
new file mode 100644
index 0000000..3d7c76d
--- /dev/null
+++ b/apps/vscode/src/sdk/SdkController.ts
@@ -0,0 +1,1924 @@
+// Replaces classic src/core/controller/index.ts (see origin/main)
+//
+// The SDK-backed Controller. It provides the same interface as the classic
+// Controller but delegates session lifecycle (initTask, askResponse,
+// cancelTask, …) to the Cline SDK (@cline/core) and bridges SDK events to
+// the webview's gRPC streams.
+import * as fs from "node:fs/promises"
+import * as path from "node:path"
+import {
+	createUserInstructionConfigService,
+	getProviderAuthStorageId,
+	type PreparedRemoteConfigCoreIntegration,
+	resolveDefaultMcpSettingsPath,
+	type SessionHistoryRecord,
+	setTelemetryOptOutGlobally,
+	type UserInstructionConfigService,
+} from "@cline/core"
+import { formatDisplayUserInput, type RemoteConfig, type RemoteConfigBundle } from "@cline/shared"
+import type { ApiConfiguration, ModelInfo } from "@shared/api"
+import type { ChatContent } from "@shared/ChatContent"
+import { CLINE_ACCOUNT_AUTH_ERROR_MESSAGE } from "@shared/ClineAccount"
+import { mentionRegexGlobal } from "@shared/context-mentions"
+import type { ClineApiReqInfo, ClineMessage, ExtensionState } from "@shared/ExtensionMessage"
+import type { HistoryItem } from "@shared/HistoryItem"
+import { DeleteAllTaskHistoryCount, type GetTaskHistoryRequest, TaskHistoryArray, TaskResponse } from "@shared/proto/cline/task"
+import type { Settings } from "@shared/storage/state-keys"
+import type { Mode } from "@shared/storage/types"
+import type { TelemetrySetting } from "@shared/TelemetrySetting"
+import type { ClineCheckpointRestore } from "@shared/WebviewMessage"
+import { parseMentions } from "@/core/mentions"
+import { ensureMcpServersDirectoryExists } from "@/core/storage/disk"
+import { refreshSdkRemoteConfig } from "@/core/storage/remote-config/sdk-refresh"
+import { clearRemoteConfig } from "@/core/storage/remote-config/utils"
+import { StateManager } from "@/core/storage/StateManager"
+import type { WorkspaceRootManager } from "@/core/workspace/WorkspaceRootManager"
+import { HostProvider } from "@/hosts/host-provider"
+import type { ITerminalManager } from "@/integrations/terminal/types"
+import { ExtensionRegistryInfo } from "@/registry"
+import { OcaAuthService } from "@/services/auth/oca/OcaAuthService"
+import { UrlContentFetcher } from "@/services/browser/UrlContentFetcher"
+import { ClineError } from "@/services/error/ClineError"
+import { McpHub } from "@/services/mcp/McpHub"
+import { telemetryService } from "@/services/telemetry"
+import type { ClineExtensionContext } from "@/shared/cline"
+import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { isClineManagedProvider } from "@/shared/utils/cline"
+import { arePathsEqual, getDesktopDir } from "@/utils/path"
+import { ClineAccountService } from "./account-service"
+import { AuthService, LogoutReason } from "./auth-service"
+import { buildStartSessionInput, createHistoryItemFromSession } from "./cline-session-factory"
+import { MessageTranslatorState, reshapeErrorForWebview } from "./message-translator"
+import { createProviderCatalog } from "./model-catalog/catalog"
+import type { Disposable, ProviderCatalog, ProviderConfigChange, ProviderConfigStore } from "./model-catalog/contracts"
+import { parseProviderId } from "./model-catalog/provider-id"
+import { createProviderConfigStore } from "./model-catalog/store"
+import {
+	PROVIDER_FAILURE_ERROR_TYPE,
+	PROVIDER_FAILURE_PHASE,
+	type ProviderFailureTelemetry,
+	ProviderFailureTelemetryTurnGate,
+} from "./provider-failure-telemetry"
+import {
+	findVisibleCheckpointUserMessageByRun,
+	getCheckpointRunCountForMessage,
+	isVisibleCheckpointUserMessage,
+} from "./sdk-checkpoints"
+import { SdkCompactionCoordinator } from "./sdk-compaction-coordinator"
+import { SdkFollowupCoordinator } from "./sdk-followup-coordinator"
+import { SdkInteractionCoordinator } from "./sdk-interaction-coordinator"
+import { SdkMcpCoordinator } from "./sdk-mcp-coordinator"
+import { SdkMessageCoordinator, type SessionEventListener } from "./sdk-message-coordinator"
+import { SdkModeCoordinator } from "./sdk-mode-coordinator"
+import { SdkProviderChangeCoordinator } from "./sdk-provider-change-coordinator"
+import { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import { SdkSessionEventCoordinator } from "./sdk-session-event-coordinator"
+import { SdkSessionHistoryLoader } from "./sdk-session-history-loader"
+import { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import { SdkTaskControlCoordinator } from "./sdk-task-control-coordinator"
+import { SdkTaskHistory, sessionHistoryRecordToHistoryItem } from "./sdk-task-history"
+import { SdkTaskStartCoordinator } from "./sdk-task-start-coordinator"
+import { createVscodeSdkTelemetryHandle, type VscodeSdkTelemetryHandle } from "./sdk-telemetry"
+import { isToolAutoApproved } from "./sdk-tool-policies"
+import {
+	extractSdkUserText,
+	findSdkUserMessageIndexByOrdinal,
+	isSyntheticSdkUserMessage,
+	type SdkUserMessage,
+} from "./sdk-user-message-mapping"
+import { StatePostDebouncer } from "./state-post-debouncer"
+import { createTaskProxy, type TaskProxy } from "./task-proxy"
+import { syncTelemetrySettingFromSharedGlobalSettings } from "./telemetry-settings-sync"
+import { TurnStateTracker } from "./turn-state-tracker"
+import { VscodeSessionHost } from "./vscode-session-host"
+import { WebviewGrpcBridge } from "./webview-grpc-bridge"
+import { resolveWorkspaceRootPath } from "./workspace-root"
+
+/**
+ * Log a stub warning and return undefined.
+ */
+function stubWarn(name: string): void {
+	Logger.warn(`[SdkController] STUB: ${name} not yet implemented`)
+}
+
+function metadataNumber(metadata: SessionHistoryRecord["metadata"] | undefined, key: string): number | undefined {
+	const value = metadata?.[key]
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}
+
+function usesClineAccountAuth(providerId: string): boolean {
+	return getProviderAuthStorageId(providerId) === "cline"
+}
+
+function metadataBoolean(metadata: SessionHistoryRecord["metadata"] | undefined, key: string): boolean | undefined {
+	const value = metadata?.[key]
+	return typeof value === "boolean" ? value : undefined
+}
+
+function metadataString(metadata: SessionHistoryRecord["metadata"] | undefined, key: string): string | undefined {
+	const value = metadata?.[key]
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
+}
+
+function dateStringToTimestamp(value: string | null | undefined): number {
+	if (!value) {
+		return 0
+	}
+	const timestamp = Date.parse(value)
+	return Number.isFinite(timestamp) ? timestamp : 0
+}
+
+function historyItemToTaskResponse(item: HistoryItem): TaskResponse {
+	return TaskResponse.create({
+		id: item.id,
+		task: formatDisplayUserInput(item.task),
+		ts: item.ts,
+		isFavorited: item.isFavorited ?? false,
+		size: item.size ?? 0,
+		totalCost: item.totalCost ?? 0,
+		tokensIn: item.tokensIn ?? 0,
+		tokensOut: item.tokensOut ?? 0,
+		cacheWrites: item.cacheWrites ?? 0,
+		cacheReads: item.cacheReads ?? 0,
+	})
+}
+
+// ---------------------------------------------------------------------------
+// Controller
+// ---------------------------------------------------------------------------
+
+export class Controller {
+	// SDK session state and the coordinators that drive it.
+	private messageTranslatorState: MessageTranslatorState
+	private turnStateTracker!: TurnStateTracker
+	private messages: SdkMessageCoordinator
+	private sessions: SdkSessionLifecycle
+	private interactions: SdkInteractionCoordinator
+	private sessionConfigBuilder: SdkSessionConfigBuilder
+	private taskHistory: SdkTaskHistory
+	private mode: SdkModeCoordinator
+	private mcpTools: SdkMcpCoordinator
+	private providerChanges: SdkProviderChangeCoordinator
+	private followups: SdkFollowupCoordinator
+	private taskControl: SdkTaskControlCoordinator
+	private taskStart: SdkTaskStartCoordinator
+	private compaction: SdkCompactionCoordinator
+	private sessionEvents: SdkSessionEventCoordinator
+	private sessionHistory: SdkSessionHistoryLoader
+	private readonly sdkTelemetry: VscodeSdkTelemetryHandle
+	private readonly providerFailureTelemetryTurnGate = new ProviderFailureTelemetryTurnGate()
+	private readonly providerConfigStore: ProviderConfigStore
+	private readonly providerCatalog: ProviderCatalog
+	private readonly providerConfigStoreSubscription: Disposable
+	private providerConfigStatePostScheduled = false
+
+	// Debounces/coalesces postStateToWebview() calls — see StatePostDebouncer.
+	private static readonly STATE_POST_DEBOUNCE_MS = 50
+	private readonly statePostDebouncer: StatePostDebouncer
+
+	// Bridges SDK events to the webview's gRPC streams.
+	private grpcBridge: WebviewGrpcBridge
+
+	// Presents the Task interface that gRPC handlers expect, delegating to the
+	// active SDK session.
+	task?: TaskProxy
+
+	mcpHub: McpHub
+	accountService: ClineAccountService
+	authService: AuthService
+	ocaAuthService: OcaAuthService
+	readonly stateManager: StateManager
+
+	// Lazy terminal manager for foreground terminal execution.
+	// Concrete impl comes from HostProvider (VscodeTerminalManager in VSCode,
+	// StandaloneTerminalManager in cline-core / JetBrains).
+	// Created on first use; shared across all sessions in this Controller's lifetime.
+	private _terminalManager?: ITerminalManager
+
+	// Private state kept for stub compatibility
+	private backgroundCommandRunning = false
+	private backgroundCommandTaskId?: string
+	private pendingClineAuthRetryPrompt?: string
+	checkpointRestoreInput?: ExtensionState["checkpointRestoreInput"]
+
+	// Timer for periodic remote config fetching (enterprise policy enforcement)
+	private remoteConfigTimer?: NodeJS.Timeout
+	private remoteConfigCoreIntegration?: PreparedRemoteConfigCoreIntegration
+
+	// Watches user-instruction files (workflows/skills/rules), including those
+	// materialized by remote config under `.cline/remote-config/`. Used to expand
+	// `/workflow` and `/skill` slash commands into their instruction bodies before
+	// the prompt reaches the model — the same mechanism the CLI uses in
+	// `buildUserInputMessage`. The agent loop never auto-expands commands, so this
+	// host-side expansion is required. Created lazily (memoized as a promise to be
+	// race-free under concurrent first sends) and rebuilt if the workspace root
+	// changes.
+	private userInstructionService?: Promise<UserInstructionConfigService>
+	private userInstructionServiceRoot?: string
+	private isDisposed = false
+
+	get remoteConfig(): RemoteConfig | undefined {
+		return this.remoteConfigCoreIntegration?.prepared.bundle?.remoteConfig
+	}
+
+	get remoteConfigBundle(): RemoteConfigBundle | undefined {
+		return this.remoteConfigCoreIntegration?.prepared.bundle
+	}
+
+	constructor(readonly context: ClineExtensionContext) {
+		// StateManager must be initialized before creating the Controller
+		this.stateManager = StateManager.get()
+		syncTelemetrySettingFromSharedGlobalSettings(this.stateManager)
+		this.sdkTelemetry = createVscodeSdkTelemetryHandle()
+		this.statePostDebouncer = new StatePostDebouncer({
+			debounceMs: Controller.STATE_POST_DEBOUNCE_MS,
+			flush: () => this.flushStateToWebview(),
+		})
+		this.providerConfigStore = createProviderConfigStore()
+		this.providerCatalog = createProviderCatalog(this.providerConfigStore)
+		this.providerConfigStoreSubscription = this.providerConfigStore.subscribe((event) => {
+			this.handleProviderConfigChange(event)
+		})
+
+		// IMPORTANT: Use ~/.cline/data/settings/ for the settings directory,
+		// NOT ensureSettingsDirectoryExists() which returns the VSCode extension
+		// storage path (HostProvider.globalStorageFsPath/settings/). The MCP
+		// settings file lives at ~/.cline/data/settings/cline_mcp_settings.json
+		// (shared across VSCode, CLI, and JetBrains clients).
+		this.mcpHub = new McpHub(
+			() => ensureMcpServersDirectoryExists(),
+			async () => {
+				const settingsDir = path.dirname(resolveDefaultMcpSettingsPath())
+				await fs.mkdir(settingsDir, { recursive: true })
+				return settingsDir
+			},
+			ExtensionRegistryInfo.version,
+			telemetryService,
+		)
+
+		// Initialize SDK-backed auth and account services.
+		this.authService = AuthService.getInstance(this)
+		this.ocaAuthService = OcaAuthService.initialize(this)
+		this.accountService = ClineAccountService.getInstance()
+
+		// Initialize message translator state
+		this.messageTranslatorState = new MessageTranslatorState(undefined, () => this.getActiveProviderId())
+		// Authoritative UI-mode tracker, sharing the one id/seq/epoch authority.
+		this.turnStateTracker = new TurnStateTracker(this.messageTranslatorState.getMinter())
+		this.messages = new SdkMessageCoordinator({
+			getTask: () => this.task,
+			// Stamp seq/epoch on every message flowing to the webview from the shared authority.
+			getMinter: () => this.messageTranslatorState.getMinter(),
+		})
+		this.sessionHistory = new SdkSessionHistoryLoader()
+		this.sessionConfigBuilder = new SdkSessionConfigBuilder({
+			stateManager: this.stateManager,
+			emitHookMessage: (msg) => this.messages.emitHookMessage(msg),
+			onSwitchToActMode: () => {
+				this.mode.queueSwitchToActMode()
+			},
+			shouldStopAfterModeSwitch: () => this.mode.hasPendingModeChange(),
+			onConsecutiveMistakeLimitReached: (context) => this.interactions.handleConsecutiveMistakeLimitReached(context),
+		})
+		this.interactions = new SdkInteractionCoordinator({
+			messages: this.messages,
+			getSessionId: () => this.sessions.getActiveSession()?.sessionId ?? "",
+			postStateToWebview: () => this.postStateToWebview(),
+			// Share the single id/seq/epoch authority so interaction-minted ids (tool-approval
+			// asks, ask_question, user_feedback) never collide with translator-minted ids.
+			getMinter: () => this.messageTranslatorState.getMinter(),
+			setTurnPhase: (phase, anchorTs) => this.turnStateTracker.set(phase, anchorTs),
+			recordApprovedToolMessage: (toolCallId, messageTs) =>
+				this.messageTranslatorState.recordApprovedToolMessageTs(toolCallId, messageTs),
+			recordDeniedToolApproval: (toolCallId, toolName, reason) =>
+				this.messageTranslatorState.recordDeniedToolApproval(toolCallId, toolName, reason),
+			shouldAutoApproveTool: (request) => {
+				const autoApprovalSettings = this.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+				return autoApprovalSettings ? isToolAutoApproved(request.toolName, autoApprovalSettings, this.mcpHub) : false
+			},
+		})
+		this.sessions = new SdkSessionLifecycle({
+			mcpHub: this.mcpHub,
+			telemetry: this.sdkTelemetry.telemetry,
+			requestToolApproval: (request) => this.interactions.handleRequestToolApproval(request),
+			askQuestion: (question, options, context) => this.interactions.handleAskQuestion(question, options, context),
+			onSessionEvent: (event) => {
+				this.sessionEvents.handleSessionEvent(event).catch((err) => {
+					Logger.error("[SdkController] Failed to handle session event:", err)
+				})
+			},
+			getRemoteConfigIntegration: () => this.remoteConfigCoreIntegration,
+			getTerminalManager: () => {
+				if (!this._terminalManager) {
+					this._terminalManager = HostProvider.get().createTerminalManager()
+					this.applyTerminalSettings(this._terminalManager)
+					Logger.log(
+						`[SdkController] Created ${this._terminalManager.constructor.name} for foreground terminal execution`,
+					)
+				}
+				return this._terminalManager
+			},
+			onSendStart: () => {
+				this.beginProviderFailureTelemetryTurn()
+			},
+			onSendComplete: async () => {
+				await this.providerChanges.handleTurnComplete(this.mode)
+
+				this.postStateToWebview().catch((err) => {
+					Logger.error("[SdkController] Failed to post state after turn:", err)
+				})
+			},
+			onSendError: async (error, sessionId) => {
+				// A turn failed — the UI shows error recovery (Retry / Sign In / Add Credits).
+				this.turnStateTracker.set("error")
+				const errorMessage = error instanceof Error ? error.message : String(error)
+				const providerId = this.getSessionProviderId(sessionId) ?? this.getActiveProviderId()
+				const isClineAuthError =
+					isClineManagedProvider(providerId) &&
+					(errorMessage.includes(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE) ||
+						errorMessage.toLowerCase().includes("missing api key") ||
+						errorMessage.toLowerCase().includes("unauthorized"))
+
+				if (isClineAuthError) {
+					this.captureProviderFailure({
+						sessionId,
+						error,
+						providerId,
+						errorType: PROVIDER_FAILURE_ERROR_TYPE.AUTH,
+						failurePhase: PROVIDER_FAILURE_PHASE.PREFLIGHT,
+					})
+					this.emitClineAuthError()
+				} else if (isClineManagedProvider(providerId) && this.isClineBalanceError(errorMessage)) {
+					this.captureProviderFailure({
+						sessionId,
+						error,
+						providerId,
+						errorType: PROVIDER_FAILURE_ERROR_TYPE.BALANCE,
+						failurePhase: PROVIDER_FAILURE_PHASE.PREFLIGHT,
+					})
+					this.emitClineBalanceError(errorMessage)
+				} else {
+					this.captureProviderFailure({
+						sessionId,
+						error,
+						providerId,
+						errorType: PROVIDER_FAILURE_ERROR_TYPE.SEND_ERROR,
+						failurePhase: PROVIDER_FAILURE_PHASE.STREAMING,
+					})
+					this.messages.emitSessionEvents(
+						[
+							{
+								ts: Date.now(),
+								type: "say",
+								say: "error",
+								text: `Agent error: ${errorMessage}`,
+								partial: false,
+							},
+						],
+						{ type: "status", payload: { sessionId, status: "error" } },
+					)
+				}
+				this.postStateToWebview().catch(() => {})
+			},
+		})
+		this.taskHistory = new SdkTaskHistory({
+			mcpHub: this.mcpHub,
+			sessions: this.sessions,
+			legacyExtensionStorageDir: this.context.globalStorageUri.fsPath,
+			telemetry: telemetryService,
+			// History rendering mints ids from the shared authority so regenerated history ids
+			// never overlap live-session ids.
+			getMinter: () => this.messageTranslatorState.getMinter(),
+		})
+		this.mode = new SdkModeCoordinator({
+			stateManager: this.stateManager,
+			sessions: this.sessions,
+			interactions: this.interactions,
+			messages: this.messages,
+			sessionConfigBuilder: this.sessionConfigBuilder,
+			getTask: () => this.task,
+			getWorkspaceRoot: () => this.getWorkspaceRoot(),
+			loadInitialMessages: async (sdkHost, sessionId) =>
+				(await this.sessionHistory.loadInitialMessages(sdkHost, sessionId)) ?? [],
+			buildStartSessionInput,
+			emitClineAuthError: () => this.emitClineAuthErrorWithTelemetry(),
+			resetMessageTranslator: () => this.resetMessageTranslatorAndFence(),
+			postStateToWebview: () => this.postStateToWebview(),
+			getTurnPhase: () => this.turnStateTracker.currentPhase,
+			resolveContextMentions: (text) => this.resolveContextMentions(text),
+			onAutoContinueStarting: () => {
+				this.turnStateTracker.set("streaming")
+				this.messageTranslatorState.clearTurnOutcome()
+			},
+			onAutoContinueFailed: () => {
+				this.turnStateTracker.set("error")
+			},
+		})
+		this.mcpTools = new SdkMcpCoordinator({
+			stateManager: this.stateManager,
+			sessions: this.sessions,
+			messages: this.messages,
+			sessionConfigBuilder: this.sessionConfigBuilder,
+			getWorkspaceRoot: () => this.getWorkspaceRoot(),
+			loadInitialMessages: async (sdkHost, sessionId) =>
+				(await this.sessionHistory.loadInitialMessages(sdkHost, sessionId)) ?? [],
+			buildStartSessionInput,
+			postStateToWebview: () => this.postStateToWebview(),
+		})
+		this.providerChanges = new SdkProviderChangeCoordinator({
+			stateManager: this.stateManager,
+			sessions: this.sessions,
+			messages: this.messages,
+			sessionConfigBuilder: this.sessionConfigBuilder,
+			getTask: () => this.task,
+			getWorkspaceRoot: () => this.getWorkspaceRoot(),
+			loadInitialMessages: async (sdkHost, sessionId) =>
+				(await this.sessionHistory.loadInitialMessages(sdkHost, sessionId)) ?? [],
+			buildStartSessionInput,
+			postStateToWebview: () => this.postStateToWebview(),
+		})
+		this.followups = new SdkFollowupCoordinator({
+			stateManager: this.stateManager,
+			interactions: this.interactions,
+			sessions: this.sessions,
+			messages: this.messages,
+			taskHistory: this.taskHistory,
+			sessionConfigBuilder: this.sessionConfigBuilder,
+			waitForPendingModeRebuild: () => this.mode.waitForPendingRebuild(),
+			getTask: () => this.task,
+			createTempSessionHost: () => VscodeSessionHost.create({ mcpHub: this.mcpHub }),
+			getWorkspaceRoot: () => this.getWorkspaceRoot(),
+			loadInitialMessages: (sessionHost, taskId) => this.sessionHistory.loadInitialMessages(sessionHost, taskId),
+			buildStartSessionInput,
+			resolveContextMentions: (text) => this.resolveContextMentions(text),
+			isClineManagedProviderActive: () => this.isClineManagedProviderActive(),
+			emitClineAuthError: () => this.emitClineAuthErrorWithTelemetry(),
+			resetMessageTranslator: () => this.resetMessageTranslatorAndFence(),
+			postStateToWebview: () => this.postStateToWebview(),
+			onResumeFailed: () => {
+				this.turnStateTracker.set("error")
+			},
+		})
+		this.taskControl = new SdkTaskControlCoordinator({
+			sessions: this.sessions,
+			interactions: this.interactions,
+			messages: this.messages,
+			taskHistory: this.taskHistory,
+			getTask: () => this.task,
+			setTask: (task) => {
+				this.task = task
+			},
+			onAskResponse: (text, images, files) => this.askResponse(text, images, files),
+			resetMessageTranslator: () => this.resetMessageTranslatorAndFence(),
+			// Bump the epoch synchronously before abort so straggler events from the cancelled
+			// turn carry the old epoch and are dropped by the webview. The resumable phase is set
+			// in SdkController.cancelTask before this runs.
+			raiseCancelFence: () => {
+				this.messageTranslatorState.clearApprovedToolMessageTs()
+				this.messageTranslatorState.getMinter().bumpEpoch()
+			},
+			postStateToWebview: () => this.postStateToWebview(),
+		})
+		this.taskStart = new SdkTaskStartCoordinator({
+			stateManager: this.stateManager,
+			sessions: this.sessions,
+			messages: this.messages,
+			taskHistory: this.taskHistory,
+			sessionConfigBuilder: this.sessionConfigBuilder,
+			buildStartSessionInput,
+			createHistoryItemFromSession,
+			clearTask: async () => {
+				this.pendingClineAuthRetryPrompt = undefined
+				await this.taskControl.clearTask()
+			},
+			setTask: (task) => {
+				this.task = task
+			},
+			onAskResponse: (text, images, files) => this.askResponse(text, images, files),
+			onCancelTask: () => this.cancelTask(),
+			getWorkspaceRoot: () => this.getWorkspaceRoot(),
+			createTempSessionHost: () => VscodeSessionHost.create({ mcpHub: this.mcpHub }),
+			loadInitialMessages: (reader, taskId) => this.sessionHistory.loadInitialMessages(reader, taskId),
+			resolveContextMentions: (text) => this.resolveContextMentions(text),
+			isClineManagedProviderActive: () => this.isClineManagedProviderActive(),
+			emitClineAuthError: (task) => this.emitClineAuthErrorWithTelemetry(task),
+			captureProviderApiError: (event) => this.captureProviderFailure(event),
+			postStateToWebview: () => this.postStateToWebview(),
+		})
+		this.compaction = new SdkCompactionCoordinator({
+			stateManager: this.stateManager,
+			sessions: this.sessions,
+			messages: this.messages,
+			sessionConfigBuilder: this.sessionConfigBuilder,
+			getWorkspaceRoot: () => this.getWorkspaceRoot(),
+			postStateToWebview: () => this.postStateToWebview(),
+		})
+		this.sessionEvents = new SdkSessionEventCoordinator({
+			messageTranslatorState: this.messageTranslatorState,
+			sessions: this.sessions,
+			messages: this.messages,
+			mcpTools: this.mcpTools,
+			providerChanges: this.providerChanges,
+			mode: this.mode,
+			taskHistory: this.taskHistory,
+			stateManager: this.stateManager,
+			getTask: () => this.task,
+			postStateToWebview: () => this.postStateToWebview(),
+			setTurnPhase: (phase, anchorTs) => this.turnStateTracker.set(phase, anchorTs),
+			captureProviderApiError: (event) => this.captureProviderFailure(event),
+			beginProviderFailureTelemetryTurn: () => this.beginProviderFailureTelemetryTurn(),
+		})
+		// Subscribe to MCP tool list changes so we can restart the SDK session
+		// when servers are added/removed/reconnected. The SDK's DefaultSessionBuilder
+		// does not support dynamic MCP tools, so we must restart the session.
+		this.mcpHub.setToolListChangeCallback(() => this.mcpTools.handleToolListChanged())
+
+		// Initialize gRPC bridge
+		this.grpcBridge = new WebviewGrpcBridge(this.messageTranslatorState)
+
+		// Wire the bridge to the controller's getStateToPostToWebview()
+		// so state updates include messages, currentTaskItem, and task history
+		this.grpcBridge.setGetStateFn(() => this.getStateToPostToWebview())
+
+		// Register the bridge as a session event listener
+		this.onSessionEvent(this.grpcBridge.createListener())
+
+		// Restore auth state from secrets on startup, then start the remote
+		// config polling timer (enterprise policy enforcement). The timer must
+		// start after auth is restored so remote config can identify the user's
+		// organization and apply org-level policies.
+		this.authService
+			.restoreRefreshTokenAndRetrieveAuthInfo()
+			.then(() => {
+				this.startRemoteConfigTimer()
+			})
+			.catch((err) => {
+				Logger.error("[SdkController] Failed to restore auth state:", err)
+			})
+
+		Logger.log("[SdkController] Initialized with SDK adapter layer + gRPC bridge + auth services")
+	}
+
+	getProviderConfigStore(): ProviderConfigStore {
+		return this.providerConfigStore
+	}
+
+	getProviderCatalog(): ProviderCatalog {
+		return this.providerCatalog
+	}
+
+	invalidateProviderListings(): void {
+		this.providerCatalog.invalidateProviderListings()
+	}
+
+	private handleProviderConfigChange(event: ProviderConfigChange): void {
+		this.scheduleProviderConfigStatePost()
+
+		if (event.kind === "selection" && this.isSelectionForActiveModeProvider(event)) {
+			this.sessions
+				?.updateActiveSessionModel(event.selection.modelId)
+				.catch((error) => Logger.error("[SdkController] Failed to update active session model:", error))
+		}
+	}
+
+	handleApiConfigurationChanged(previous: ApiConfiguration, next: ApiConfiguration): void {
+		this.providerChanges.handleApiConfigurationChanged(previous, next)
+	}
+
+	private isSelectionForActiveModeProvider(event: Extract<ProviderConfigChange, { kind: "selection" }>): boolean {
+		try {
+			const modeValue = this.stateManager.getGlobalSettingsKey("mode")
+			const mode = modeValue === "plan" ? "plan" : "act"
+			if (event.mode !== mode) {
+				return false
+			}
+
+			const apiConfig = this.stateManager.getApiConfiguration()
+			const activeProvider = mode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider
+			return activeProvider === event.providerId.toString()
+		} catch {
+			return false
+		}
+	}
+
+	private scheduleProviderConfigStatePost(): void {
+		if (this.providerConfigStatePostScheduled) {
+			return
+		}
+
+		this.providerConfigStatePostScheduled = true
+		queueMicrotask(() => {
+			this.providerConfigStatePostScheduled = false
+			this.postStateToWebview().catch((error) => {
+				Logger.error("[SdkController] Failed to post state after provider config change:", error)
+			})
+		})
+	}
+
+	/**
+	 * Starts the periodic remote config fetching timer. Fetches immediately
+	 * and then every hour, to enforce enterprise policy (provider lockdown,
+	 * MCP server management, OpenTelemetry, etc.).
+	 */
+	private startRemoteConfigTimer(): void {
+		// Initial fetch
+		this.refreshRemoteConfig().catch((err) => Logger.error("[SdkController] Initial remote config refresh failed:", err))
+		// Set up 1-hour interval
+		this.remoteConfigTimer = setInterval(() => {
+			this.refreshRemoteConfig().catch((err) => Logger.error("[SdkController] Remote config timer failed:", err))
+		}, 3600000) // 1 hour
+	}
+
+	private async refreshRemoteConfig(): Promise<void> {
+		await refreshSdkRemoteConfig(this, {
+			workspacePath: await this.getRemoteConfigWorkspacePath(),
+		})
+		// Remote config may have materialized new workflows/skills/rules under
+		// `.cline/remote-config/`. Refresh the watcher so slash-command expansion
+		// sees them without waiting on filesystem events.
+		await this.refreshUserInstructionWatchers()
+	}
+
+	async setRemoteConfigCoreIntegration(integration: PreparedRemoteConfigCoreIntegration | undefined): Promise<void> {
+		const previous = this.remoteConfigCoreIntegration
+		this.remoteConfigCoreIntegration = integration
+		if (previous && previous !== integration) {
+			try {
+				await previous.dispose()
+			} catch (error) {
+				Logger.error("[SdkController] Failed to dispose previous remote config integration:", error)
+			}
+		}
+	}
+
+	async invalidateUserInstructionService(): Promise<void> {
+		const userInstructionServicePromise = this.userInstructionService
+		this.userInstructionService = undefined
+		this.userInstructionServiceRoot = undefined
+		if (userInstructionServicePromise) {
+			await userInstructionServicePromise.then((service) => service.stop()).catch(() => {})
+		}
+	}
+
+	async dispose(): Promise<void> {
+		this.providerConfigStoreSubscription.dispose()
+		// Clear the remote config timer to prevent stale fetches
+		if (this.remoteConfigTimer) {
+			clearInterval(this.remoteConfigTimer)
+			this.remoteConfigTimer = undefined
+		}
+		await this.setRemoteConfigCoreIntegration(undefined)
+		this.isDisposed = true
+		// Tear down the debounced state-post machinery before downstream resources
+		// are disposed below — see StatePostDebouncer.dispose().
+		await this.statePostDebouncer.dispose()
+		await this.invalidateUserInstructionService()
+		this.messages.cancelPendingSave()
+		// Clear MCP tool list change callback before disposing McpHub
+		this.mcpHub?.clearToolListChangeCallback()
+		await this.clearTask()
+		await this.sessions.dispose("SdkController.dispose")
+		await this.taskHistory.dispose()
+		this.mcpHub?.dispose?.()
+		this.messages.dispose()
+		await this.sdkTelemetry.dispose()
+		Logger.log("[SdkController] Disposed")
+	}
+
+	// ---- Slash command + context mention resolution ----
+
+	/**
+	 * Lazily create (or rebuild on workspace-root change) the user-instruction
+	 * watcher. Pointed at the workspace root so it discovers both local config
+	 * (`.clinerules/workflows`, `.cline/workflows`, …) and remote-config files
+	 * materialized under `<root>/.cline/remote-config/{workflows,skills,rules}`.
+	 *
+	 * `workspaceRoot` is resolved by the caller so the memoization check below runs
+	 * synchronously on entry — there is no `await` before the assignment, so
+	 * concurrent callers cannot create two competing watchers.
+	 */
+	private ensureUserInstructionService(workspaceRoot: string): Promise<UserInstructionConfigService> {
+		// dispose() may have run during an awaited gap in the caller. Don't
+		// resurrect a watcher the dispose path will never stop again.
+		if (this.isDisposed) {
+			return Promise.reject(new Error("Controller disposed"))
+		}
+		if (this.userInstructionService && this.userInstructionServiceRoot === workspaceRoot) {
+			return this.userInstructionService
+		}
+		// Workspace root changed: stop the previous watcher once it settles.
+		const previous = this.userInstructionService
+		if (previous) {
+			previous.then((service) => service.stop()).catch(() => {})
+		}
+		this.userInstructionServiceRoot = workspaceRoot
+		this.userInstructionService = (async () => {
+			const service = createUserInstructionConfigService({
+				workflows: { workspacePath: workspaceRoot },
+				skills: {
+					workspacePath: workspaceRoot,
+					includePluginSkills: true,
+					cwd: workspaceRoot,
+				},
+				rules: { workspacePath: workspaceRoot },
+			})
+			// start() runs the initial scan; await so the snapshot is populated
+			// before the first resolveRuntimeSlashCommand call.
+			await service.start().catch((error) => {
+				Logger.warn("[SdkController] Failed to start user instruction watcher:", error)
+			})
+			return service
+		})()
+		return this.userInstructionService
+	}
+
+	/**
+	 * Expand a leading `/workflow` or `/skill` slash command into its instruction
+	 * body. Mirrors the CLI's `buildUserInputMessage`. Returns the input unchanged
+	 * if it is not a known command or expansion fails.
+	 */
+	private async resolveSlashCommands(text: string): Promise<string> {
+		if (this.isDisposed) {
+			return text
+		}
+		try {
+			const workspaceRoot = await this.getWorkspaceRoot()
+			const service = await this.ensureUserInstructionService(workspaceRoot)
+			return service.resolveRuntimeSlashCommand(text)
+		} catch (error) {
+			Logger.warn("[SdkController] Slash command resolution failed, using raw text:", error)
+			return text
+		}
+	}
+
+	/**
+	 * Refresh the user-instruction watcher after remote config is (re)materialized
+	 * so newly written workflows/skills/rules are picked up immediately rather than
+	 * waiting on filesystem watch events.
+	 */
+	private async refreshUserInstructionWatchers(): Promise<void> {
+		const servicePromise = this.userInstructionService
+		if (!servicePromise) {
+			return
+		}
+		try {
+			const service = await servicePromise
+			await Promise.all([service.refreshType("workflow"), service.refreshType("skill"), service.refreshType("rule")])
+		} catch (error) {
+			Logger.warn("[SdkController] Failed to refresh user instruction watchers:", error)
+		}
+	}
+
+	/**
+	 * Expand slash commands, then resolve `@` context mentions in user text
+	 * before sending to the SDK.
+	 *
+	 * `parseMentions()` inlines file content (`@/path`), URL content
+	 * (`@https://...`), diagnostics (`@problems`), git state (`@git-changes`),
+	 * and commit info (`@hash`) into the prompt text. We do this here because
+	 * the SDK's own mention enricher only handles simple `@path` file mentions
+	 * and does not understand the webview's `@/path` format or special
+	 * mentions, so the LLM would otherwise never see the referenced content.
+	 */
+	private async resolveContextMentions(text: string): Promise<string> {
+		const withCommands = await this.resolveSlashCommands(text)
+
+		// Quick check: skip mention parsing if there are no @ mentions
+		if (!mentionRegexGlobal.test(withCommands)) {
+			return withCommands
+		}
+		// Reset lastIndex since RegExp.test() advances it for global regexes
+		mentionRegexGlobal.lastIndex = 0
+
+		try {
+			const cwd = await this.getWorkspaceRoot()
+			const urlContentFetcher = new UrlContentFetcher()
+			const workspaceManager = await this.ensureWorkspaceManager()
+			const resolved = await parseMentions(withCommands, cwd, urlContentFetcher, undefined, workspaceManager)
+			Logger.log(`[SdkController] Resolved context mentions (${withCommands.length} → ${resolved.length} chars)`)
+			return resolved
+		} catch (error) {
+			Logger.error("[SdkController] Failed to resolve context mentions, using raw text:", error)
+			return withCommands
+		}
+	}
+
+	// ---- Workspace root resolution ----
+
+	/**
+	 * Get the user's workspace root directory.
+	 *
+	 * In VSCode this resolves to `vscode.workspace.workspaceFolders[0]` via
+	 * `HostProvider.workspace.getWorkspacePaths()`. If no workspace folder is
+	 * open, it falls back to Desktop.
+	 * This avoids using the VS Code extension host's `process.cwd()` (often `/`),
+	 * which produces invalid SDK workspace metadata with an empty hint.
+	 */
+	private async getWorkspaceRoot(): Promise<string> {
+		const noWorkspaceFallback = getDesktopDir()
+		try {
+			const { paths } = await HostProvider.workspace.getWorkspacePaths({})
+			return resolveWorkspaceRootPath(paths, noWorkspaceFallback)
+		} catch (error) {
+			Logger.warn("[SdkController] Failed to get workspace paths, falling back to Desktop:", error)
+		}
+		return noWorkspaceFallback
+	}
+
+	private async getRemoteConfigWorkspacePath(): Promise<string | undefined> {
+		try {
+			const { paths } = await HostProvider.workspace.getWorkspacePaths({})
+			if (!paths.length) {
+				return undefined
+			}
+			return resolveWorkspaceRootPath(paths, paths[0])
+		} catch (error) {
+			Logger.warn("[SdkController] Failed to get workspace paths for remote config, using global fallback:", error)
+			return undefined
+		}
+	}
+
+	// ---- Session event subscription ----
+
+	/**
+	 * Subscribe to session events translated to ClineMessages.
+	 * Returns an unsubscribe function.
+	 */
+	onSessionEvent(listener: SessionEventListener): () => void {
+		return this.messages.onSessionEvent(listener)
+	}
+
+	/**
+	 * Get the active API provider for the current mode.
+	 */
+	private getActiveProviderId(): string | undefined {
+		try {
+			const apiConfig = this.stateManager.getApiConfiguration()
+			const modeValue = this.stateManager.getGlobalSettingsKey("mode")
+			const mode = modeValue === "plan" ? "plan" : "act"
+			return mode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider
+		} catch {
+			return undefined
+		}
+	}
+
+	private getTaskModelId(): string | undefined {
+		const modelId = this.task?.api?.getModel?.().id?.trim()
+		return modelId && modelId !== "unknown" ? modelId : undefined
+	}
+
+	private getSessionProviderId(sessionId?: string): string | undefined {
+		const activeSession = this.sessions.getActiveSession()
+		if (sessionId && activeSession?.sessionId !== sessionId) {
+			return undefined
+		}
+		const providerId =
+			activeSession?.startResult?.manifest?.provider?.trim() || activeSession?.startConfig?.providerId?.trim()
+		return providerId && providerId !== "unknown" ? providerId : undefined
+	}
+
+	private getSessionModelId(sessionId?: string): string | undefined {
+		const activeSession = this.sessions.getActiveSession()
+		if (sessionId && activeSession?.sessionId !== sessionId) {
+			return undefined
+		}
+		const modelId = activeSession?.startResult?.manifest?.model?.trim() || activeSession?.startConfig?.modelId?.trim()
+		return modelId && modelId !== "unknown" ? modelId : undefined
+	}
+
+	private beginProviderFailureTelemetryTurn(): void {
+		this.providerFailureTelemetryTurnGate.beginTurn()
+	}
+
+	/**
+	 * Check if the active API provider uses Cline account auth for the current mode.
+	 */
+	private isClineManagedProviderActive(): boolean {
+		return isClineManagedProvider(this.getActiveProviderId())
+	}
+
+	private captureProviderFailure(event: ProviderFailureTelemetry): void {
+		const ulid = event.sessionId ?? this.task?.taskId ?? this.sessions.getActiveSession()?.sessionId
+		if (!ulid) {
+			return
+		}
+		if (
+			event.failurePhase === PROVIDER_FAILURE_PHASE.STREAMING &&
+			!this.providerFailureTelemetryTurnGate.shouldCaptureStreamingFailure()
+		) {
+			return
+		}
+
+		const provider = event.providerId ?? this.getSessionProviderId(event.sessionId) ?? "unknown"
+		const model = event.modelId ?? this.getSessionModelId(event.sessionId) ?? this.getTaskModelId() ?? "unknown"
+		const clineError = ClineError.transform(event.error, model, provider)
+
+		telemetryService.captureProviderApiError({
+			ulid,
+			model,
+			provider,
+			errorMessage: clineError.message || String(event.error),
+			errorStatus: clineError.status,
+			requestId: clineError.requestId,
+			errorType: event.errorType,
+			failurePhase: event.failurePhase,
+		})
+	}
+
+	private emitClineAuthErrorWithTelemetry(task?: string, sessionId?: string): void {
+		this.emitClineAuthError(task)
+		this.captureProviderFailure({
+			sessionId: sessionId ?? this.task?.taskId,
+			error: CLINE_ACCOUNT_AUTH_ERROR_MESSAGE,
+			providerId: this.getActiveProviderId(),
+			errorType: PROVIDER_FAILURE_ERROR_TYPE.AUTH,
+			failurePhase: PROVIDER_FAILURE_PHASE.PREFLIGHT,
+		})
+	}
+
+	/**
+	 * Emit a proper auth error for the 'cline' provider when the user is not
+	 * logged in. The message sequence drives ErrorRow to render the
+	 * "Sign in to Cline" button.
+	 *
+	 * Message sequence:
+	 *   1. say:'task'           – the user's message text
+	 *   2. say:'api_req_started' – opens the API request row
+	 *   3. ask:'api_req_failed'  – ClineError JSON → ErrorRow renders auth UI
+	 */
+	private emitClineAuthError(task?: string): void {
+		const ts = Date.now()
+		this.pendingClineAuthRetryPrompt = task
+
+		if (!this.task) {
+			this.task = createTaskProxy(
+				`auth-error-${ts}`,
+				(text?: string, images?: string[], files?: string[]) => this.askResponse(text, images, files),
+				() => this.cancelTask(),
+			)
+		}
+
+		const clineError = new ClineError(
+			{ message: CLINE_ACCOUNT_AUTH_ERROR_MESSAGE, status: 401 },
+			undefined, // modelId
+			"cline",
+		)
+		const serializedError = clineError.serialize()
+
+		const failedAskTs = ts + 2
+		const messages: ClineMessage[] = [
+			{
+				ts,
+				type: "say",
+				say: "task",
+				text: task ?? "",
+				partial: false,
+			},
+			{
+				ts: ts + 1,
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify({
+					streamingFailedMessage: serializedError,
+				} satisfies ClineApiReqInfo),
+				partial: false,
+			},
+			{
+				ts: failedAskTs,
+				type: "ask",
+				ask: "api_req_failed",
+				text: serializedError,
+				partial: false,
+			},
+		]
+
+		this.turnStateTracker.set("error", failedAskTs)
+
+		this.messages.appendAndEmit(messages, {
+			type: "status",
+			payload: {
+				sessionId: this.sessions.getActiveSession()?.sessionId ?? "",
+				status: "error",
+			},
+		})
+
+		this.postStateToWebview().catch(() => {})
+	}
+
+	/**
+	 * Check if an error message indicates an insufficient credits / balance error
+	 * by reshaping it into ClineError format and inspecting the result.
+	 */
+	private isClineBalanceError(errorMessage: string): boolean {
+		try {
+			const shaped = JSON.parse(reshapeErrorForWebview({ message: errorMessage }))
+			return shaped.code === "insufficient_credits"
+		} catch {
+			return false
+		}
+	}
+
+	/**
+	 * Emit a balance error for the 'cline' provider when the user has insufficient
+	 * credits. Produces the same message sequence as emitClineAuthError so the
+	 * webview renders the "Buy Credits" button via CreditLimitError.
+	 *
+	 * Message sequence:
+	 *   1. say:'api_req_started' – streamingFailedMessage holds the ClineError JSON
+	 *   2. ask:'api_req_failed'  – ClineError JSON → ErrorRow renders balance UI
+	 */
+	private emitClineBalanceError(rawErrorMessage: string): void {
+		const ts = Date.now()
+
+		// reshapeErrorForWebview extracts structured fields from the SDK error
+		// message (which may be plain text or embedded JSON) and produces the
+		// ClineError-serialized JSON that the webview's ErrorRow expects.
+		const serializedError = reshapeErrorForWebview({
+			message: rawErrorMessage,
+		})
+
+		const failedAskTs = ts + 1
+		const messages: ClineMessage[] = [
+			{
+				ts,
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify({
+					streamingFailedMessage: serializedError,
+				} satisfies ClineApiReqInfo),
+				partial: false,
+			},
+			{
+				ts: failedAskTs,
+				type: "ask",
+				ask: "api_req_failed",
+				text: serializedError,
+				partial: false,
+			},
+		]
+
+		this.turnStateTracker.set("error", failedAskTs)
+
+		this.messages.appendAndEmit(messages, {
+			type: "status",
+			payload: {
+				sessionId: this.sessions.getActiveSession()?.sessionId ?? "",
+				status: "error",
+			},
+		})
+
+		this.postStateToWebview().catch(() => {})
+	}
+
+	// ---- Task lifecycle ----
+
+	async initTask(
+		prompt?: string,
+		images?: string[],
+		files?: string[],
+		historyItem?: HistoryItem,
+		taskSettings?: Partial<Settings>,
+	): Promise<string | undefined> {
+		// Fire-and-forget: ensure we have the latest remote config (enterprise
+		// policies like yoloModeAllowed, allowedMCPServers, etc.) without
+		// blocking the UI.
+		this.refreshRemoteConfig().catch((err) => Logger.error("[SdkController] Remote config refresh before task failed:", err))
+		// A new task is starting — the agent is about to stream.
+		this.turnStateTracker.set("streaming")
+		// Clear the previous turn's completion signal so this turn's phase is computed fresh.
+		this.messageTranslatorState.clearTurnOutcome()
+		return this.taskStart.initTask(prompt, images, files, historyItem, taskSettings)
+	}
+
+	async reinitExistingTaskFromId(taskId: string): Promise<void> {
+		this.turnStateTracker.set("streaming")
+		this.messageTranslatorState.clearTurnOutcome()
+		await this.taskStart.reinitExistingTaskFromId(taskId)
+	}
+
+	async cancelTask(): Promise<void> {
+		// Fence first: mark resumable before aborting so any straggler events from the aborted
+		// turn land on the wrong side of the UI mode. (Full fence-before-abort epoch bump lands
+		// in S6; this sets the authoritative phase now.)
+		this.turnStateTracker.set("resumable")
+		await this.taskControl.cancelTask()
+	}
+
+	async cancelBackgroundCommand(): Promise<void> {
+		stubWarn("cancelBackgroundCommand")
+	}
+
+	async cancelQueuedPrompt(promptId: string): Promise<void> {
+		const trimmedPromptId = promptId.trim()
+		if (!trimmedPromptId) {
+			Logger.warn("[SdkController] cancelQueuedPrompt: Missing prompt id")
+			return
+		}
+
+		const activeSession = this.sessions.getActiveSession()
+		if (!activeSession) {
+			Logger.warn("[SdkController] cancelQueuedPrompt: No active session")
+			return
+		}
+
+		const result = await activeSession.sdkHost.pendingPrompts("delete", {
+			sessionId: activeSession.sessionId,
+			promptId: trimmedPromptId,
+		})
+		if (!result.removed) {
+			Logger.warn(`[SdkController] cancelQueuedPrompt: Prompt not found: ${trimmedPromptId}`)
+		}
+		await this.postStateToWebview()
+	}
+
+	/**
+	 * Manually compact (condense) the active task's conversation. Triggered by
+	 * the compact button and the `/compact` (alias `/smol`) slash command.
+	 * Mirrors the CLI's `/compact` local command: runs an SDK manual compaction
+	 * and persists the compaction sidecar so the model's working context is
+	 * reduced on the next turn and later resumes.
+	 */
+	async compactTask(): Promise<void> {
+		await this.compaction.compactTask()
+	}
+
+	async clearTask(): Promise<void> {
+		this.pendingClineAuthRetryPrompt = undefined
+		// No active task — UI returns to idle (input enabled, no buttons/thinking).
+		this.turnStateTracker.set("idle")
+		await this.taskControl.clearTask()
+		await this.postStateToWebview()
+	}
+
+	async handleTaskCreation(prompt: string): Promise<void> {
+		await this.initTask(prompt)
+	}
+
+	/**
+	 * Send a follow-up message to the active session.
+	 * This is the "askResponse" equivalent — continues the conversation.
+	 *
+	 * Like initTask(), this is fire-and-forget: core.send() blocks until
+	 * the agent turn completes, but events stream in real-time via the
+	 * subscription. We do NOT await the send — the gRPC handler needs to
+	 * return immediately so the webview stays responsive.
+	 */
+	async askResponse(prompt?: string, images?: string[], files?: string[]): Promise<void> {
+		if (this.pendingClineAuthRetryPrompt !== undefined && this.task?.taskState?.askResponse === "yesButtonClicked") {
+			const retryPrompt = this.pendingClineAuthRetryPrompt
+			this.pendingClineAuthRetryPrompt = undefined
+			await this.initTask(retryPrompt, images, files)
+			return
+		}
+
+		const turnStateBefore = this.turnStateTracker.get()
+
+		// Answering an ask / continuing after completion / resuming a cancelled task all kick off a
+		// new agent turn — move the authoritative phase to "streaming" so the footer shows
+		// Thinking + Cancel (and not the stale resumable/completed/awaiting_followup buttons or the
+		// scroll-arrow default). Mirrors initTask(). The webview gates turnState by seq, and the
+		// session-event coordinator will set the terminal phase (completed/awaiting_followup/error)
+		// when this turn ends.
+		this.turnStateTracker.set("streaming")
+		// Clear the previous turn's completion signal so this new turn's phase is computed fresh.
+		this.messageTranslatorState.clearTurnOutcome()
+		await this.followups.askResponse(prompt, images, files, this.task?.taskState?.askResponse, turnStateBefore.phase)
+	}
+
+	async editMessageAndRegenerate(input: {
+		messageTs: number
+		text: string
+		images?: string[]
+		files?: string[]
+		restoreWorkspace?: boolean
+	}): Promise<void> {
+		const editedText = input.text.trim()
+		if (!editedText && (input.images?.length ?? 0) === 0 && (input.files?.length ?? 0) === 0) {
+			throw new Error("Edited message cannot be empty")
+		}
+
+		const activeSession = this.sessions.getActiveSession()
+		const currentTask = this.task
+		if (!currentTask) {
+			throw new Error("No active task to edit")
+		}
+
+		const clineMessages = currentTask.messageStateHandler.getClineMessages()
+		const targetIndex = clineMessages.findIndex((message) => message.ts === input.messageTs)
+		if (targetIndex === -1) {
+			throw new Error("Message to edit was not found")
+		}
+		const targetMessage = clineMessages[targetIndex]
+		if (targetMessage.type !== "say" || (targetMessage.say !== "task" && targetMessage.say !== "user_feedback")) {
+			throw new Error("Only user messages can be edited")
+		}
+
+		const userOrdinal = clineMessages
+			.slice(0, targetIndex + 1)
+			.filter((message) => message.type === "say" && (message.say === "task" || message.say === "user_feedback")).length
+		const checkpointRunCount = getCheckpointRunCountForMessage(clineMessages, targetIndex)
+		const sourceSessionId = activeSession?.sessionId ?? currentTask.taskId
+		let sdkMessages: SdkUserMessage[]
+		let tempHost: VscodeSessionHost | undefined
+		const sessionHost = activeSession?.sdkHost ?? (tempHost = await VscodeSessionHost.create({ mcpHub: this.mcpHub }))
+		try {
+			sdkMessages = (await sessionHost.readMessages(sourceSessionId)) as SdkUserMessage[]
+			const sdkTargetIndex = findSdkUserMessageIndexByOrdinal(sdkMessages, userOrdinal)
+			if (sdkTargetIndex === -1) {
+				throw new Error("Could not map edited message to persisted conversation history")
+			}
+
+			const initialMessages = sdkMessages.slice(0, sdkTargetIndex) as Parameters<
+				VscodeSessionHost["start"]
+			>[0]["initialMessages"]
+			const firstUserMessage = sdkMessages.find(
+				(message) => message.role === "user" && !!extractSdkUserText(message) && !isSyntheticSdkUserMessage(message),
+			)
+			const historyTitle =
+				userOrdinal === 1
+					? editedText
+					: extractSdkUserText(firstUserMessage ?? {}) || clineMessages[0]?.text || editedText
+			const fallbackCwd = await this.getWorkspaceRoot()
+			const [sessionRecord, historyItem] = await Promise.all([
+				sessionHost.get(sourceSessionId).catch(() => undefined),
+				this.taskHistory.findHistoryItem(currentTask.taskId).catch(() => undefined),
+			])
+			const cwd =
+				sessionRecord?.cwd?.trim() ||
+				sessionRecord?.workspaceRoot?.trim() ||
+				historyItem?.cwdOnTaskInitialization?.trim() ||
+				fallbackCwd
+			const mode = this.stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
+			const config = await this.sessionConfigBuilder.build({ cwd, mode, prompt: historyTitle })
+			if (usesClineAccountAuth(config.providerId) && !config.apiKey) {
+				this.emitClineAuthErrorWithTelemetry(editedText)
+				return
+			}
+
+			const resolvedPrompt = await this.resolveContextMentions(editedText)
+			const startInput = {
+				...buildStartSessionInput(config, { prompt: historyTitle, cwd, mode }),
+				initialMessages,
+				sessionMetadata: {
+					title: historyTitle,
+					modelId: config.modelId,
+				},
+			}
+
+			if (input.restoreWorkspace) {
+				if (activeSession?.isRunning) {
+					throw new Error("Wait for the current run to finish before restoring workspace changes")
+				}
+				if (checkpointRunCount === undefined) {
+					throw new Error("Workspace restore is only available for messages that started an agent run")
+				}
+				await sessionHost.restore({
+					sessionId: sourceSessionId,
+					checkpointRunCount,
+					cwd,
+					restore: {
+						messages: false,
+						workspace: true,
+						omitCheckpointMessageFromSession: true,
+					},
+				})
+			}
+
+			const { startResult, sdkHost } = await this.sessions.startNewSession(startInput)
+
+			this.turnStateTracker.set("streaming")
+			this.messageTranslatorState.clearTurnOutcome()
+			this.resetMessageTranslatorAndFence()
+
+			const task = createTaskProxy(
+				startResult.sessionId,
+				(text?: string, images?: string[], files?: string[]) => this.askResponse(text, images, files),
+				() => this.cancelTask(),
+			)
+			this.task = task
+
+			const newHistoryItem = createHistoryItemFromSession(startResult.sessionId, historyTitle, config.modelId, cwd)
+			await this.taskHistory.updateTaskHistoryItem(newHistoryItem)
+
+			const visibleMessages = clineMessages.slice(0, targetIndex)
+			if (visibleMessages.length > 0) {
+				task.messageStateHandler.addMessages(visibleMessages)
+			}
+			task.messageStateHandler.addMessages([
+				{
+					ts: Date.now(),
+					type: "say",
+					say: userOrdinal === 1 ? "task" : "user_feedback",
+					text: editedText,
+					images: input.images,
+					files: input.files,
+					partial: false,
+				},
+			])
+			await this.postStateToWebview()
+
+			this.sessions.fireAndForgetSend(sdkHost, startResult.sessionId, resolvedPrompt, input.images, input.files)
+		} finally {
+			await tempHost?.dispose("editMessageAndRegenerate")
+		}
+	}
+
+	async restoreCheckpoint(input: { checkpointRunCount: number; restoreType: ClineCheckpointRestore }): Promise<void> {
+		const restoreMessages = input.restoreType === "task" || input.restoreType === "taskAndWorkspace"
+		const restoreWorkspace = input.restoreType === "workspace" || input.restoreType === "taskAndWorkspace"
+		const checkpointRunCount = Number(input.checkpointRunCount)
+		if (!Number.isInteger(checkpointRunCount) || checkpointRunCount < 1) {
+			throw new Error("checkpointRunCount must be a positive integer")
+		}
+
+		const activeSession = this.sessions.getActiveSession()
+		const currentTask = this.task
+		if (!activeSession || !currentTask) {
+			throw new Error("No active task to restore")
+		}
+		if (activeSession.isRunning) {
+			await this.cancelTask()
+		}
+
+		const currentMessages = currentTask.messageStateHandler.getClineMessages()
+		const target = restoreMessages ? findVisibleCheckpointUserMessageByRun(currentMessages, checkpointRunCount) : undefined
+		if (restoreMessages && !target) {
+			throw new Error(`Could not find user message for checkpoint run ${checkpointRunCount}`)
+		}
+
+		const cwd = await this.getWorkspaceRoot()
+		const mode = this.stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
+		const firstUserMessage = currentMessages.find(isVisibleCheckpointUserMessage)
+		const restoredText = target?.message.text ?? ""
+		const historyTitle = checkpointRunCount === 1 ? restoredText : firstUserMessage?.text || restoredText
+		const config = restoreMessages ? await this.sessionConfigBuilder.build({ cwd, mode, prompt: historyTitle }) : undefined
+		if (config && usesClineAccountAuth(config.providerId) && !config.apiKey) {
+			this.emitClineAuthErrorWithTelemetry(restoredText)
+			return
+		}
+
+		const startInput = config
+			? {
+					...buildStartSessionInput(config, { prompt: historyTitle, cwd, mode }),
+					sessionMetadata: {
+						title: historyTitle,
+						modelId: config.modelId,
+					},
+				}
+			: undefined
+
+		const restored = await this.sessions.restoreActiveSession({
+			sessionId: activeSession.sessionId,
+			checkpointRunCount,
+			cwd,
+			restore: {
+				messages: restoreMessages,
+				workspace: restoreWorkspace,
+				omitCheckpointMessageFromSession: true,
+			},
+			...(startInput ? { start: startInput } : {}),
+		})
+
+		if (!restoreMessages) {
+			await this.postStateToWebview()
+			return
+		}
+
+		if (!restored.sessionId || !restored.startResult || !target) {
+			throw new Error("Checkpoint restore did not return a new session")
+		}
+
+		this.turnStateTracker.set("idle")
+		this.messageTranslatorState.clearTurnOutcome()
+		this.resetMessageTranslatorAndFence()
+
+		const task = createTaskProxy(
+			restored.sessionId,
+			(text?: string, images?: string[], files?: string[]) => this.askResponse(text, images, files),
+			() => this.cancelTask(),
+		)
+		this.task = task
+
+		const newHistoryItem = createHistoryItemFromSession(restored.sessionId, historyTitle, config?.modelId ?? "", cwd)
+		await this.taskHistory.updateTaskHistoryItem(newHistoryItem)
+
+		const visibleMessages = currentMessages.slice(0, target.index)
+		if (visibleMessages.length > 0) {
+			this.messages.replaceMessages(visibleMessages)
+		}
+
+		this.checkpointRestoreInput = {
+			text: restoredText,
+			images: target.message.images ?? [],
+			files: target.message.files ?? [],
+			sessionId: restored.sessionId,
+		}
+		await this.postStateToWebview()
+	}
+
+	/**
+	 * Show a task from history by loading its messages.
+	 * This does NOT start inference — it just loads the task for viewing.
+	 *
+	 * IMPORTANT: We do NOT call clearTask() here because clearTask() sets
+	 * this.task = undefined and may trigger async operations (session stop/dispose)
+	 * that race with the new task proxy creation. If any of those async operations
+	 * trigger postStateToWebview() while this.task is undefined, the webview
+	 * receives a state with no currentTaskItem/clineMessages and flashes back
+	 * to the welcome screen (S6-6/S6-23 fix).
+	 *
+	 * Instead, we:
+	 * 1. Silently tear down the active session (unsubscribe + stop in background)
+	 * 2. Create the new task proxy with loaded messages BEFORE any state push
+	 * 3. Only then push state to the webview
+	 */
+	async showTaskWithId(taskId: string): Promise<TaskResponse> {
+		const historyItem = await this.taskHistory.findHistoryItem(taskId)
+		if (!historyItem) {
+			throw new Error(`Task not found in history: ${taskId}`)
+		}
+
+		await this.taskControl.showTaskWithId(taskId, { skipHistoryLookup: true })
+		return historyItemToTaskResponse(historyItem)
+	}
+
+	// ---- Mode switching ----
+
+	async toggleActModeForYoloMode(): Promise<boolean> {
+		return this.mode.toggleActModeForYoloMode()
+	}
+
+	async togglePlanActMode(modeToSwitchTo: Mode, chatContent?: ChatContent): Promise<boolean> {
+		return this.mode.togglePlanActMode(modeToSwitchTo, chatContent)
+	}
+
+	// ---- Telemetry ----
+
+	async updateTelemetrySetting(telemetrySetting: TelemetrySetting): Promise<void> {
+		setTelemetryOptOutGlobally(telemetrySetting === "disabled", { telemetry: this.sdkTelemetry.telemetry })
+		// Mirror to StateManager for existing VS Code services during the transition.
+		this.stateManager.setGlobalState("telemetrySetting", telemetrySetting)
+		await this.postStateToWebview()
+	}
+
+	// ---- Auth callbacks ----
+
+	async handleSignOut(): Promise<void> {
+		await this.authService.handleDeauth(LogoutReason.USER_INITIATED)
+		clearRemoteConfig()
+		await this.setRemoteConfigCoreIntegration(undefined)
+		await this.postStateToWebview()
+	}
+
+	async handleOcaSignOut(): Promise<void> {
+		await this.ocaAuthService.handleDeauth(LogoutReason.USER_INITIATED)
+		await this.postStateToWebview()
+	}
+
+	async handleAuthCallback(customToken: string, provider: string | null = null): Promise<void> {
+		await this.authService.handleAuthCallback(customToken, provider ?? "cline")
+		// Fetch remote config immediately after login so enterprise policies
+		// (provider lockdown, MCP servers, OTel, etc.) are applied right away.
+		await this.refreshRemoteConfig()
+		await this.postStateToWebview()
+	}
+
+	async handleOcaAuthCallback(code: string, state: string): Promise<void> {
+		await this.ocaAuthService.handleAuthCallback(code, state)
+		await this.postStateToWebview()
+	}
+
+	// ---- Provider auth callbacks ----
+
+	private persistProviderApiKeyFromState(provider: string): void {
+		const providerId = parseProviderId(provider)
+		const apiKey = this.providerConfigStore.read(providerId).apiKey
+
+		if (!apiKey) {
+			Logger.warn(`[SdkController] No API key found after ${provider} auth callback`)
+			return
+		}
+
+		this.providerConfigStore.write(providerId, { apiKey })
+	}
+
+	async handleOpenRouterCallback(code: string): Promise<void> {
+		await this.authService.handleOpenRouterCallback(code)
+		this.persistProviderApiKeyFromState("openrouter")
+		await this.postStateToWebview()
+	}
+
+	async handleRequestyCallback(code: string): Promise<void> {
+		await this.authService.handleRequestyCallback(code)
+		this.persistProviderApiKeyFromState("requesty")
+		await this.postStateToWebview()
+	}
+
+	async handleHicapCallback(code: string): Promise<void> {
+		await this.authService.handleHicapCallback(code)
+		this.persistProviderApiKeyFromState("hicap")
+		await this.postStateToWebview()
+	}
+
+	async readOpenRouterModels(): Promise<Record<string, ModelInfo> | undefined> {
+		stubWarn("readOpenRouterModels")
+		return undefined
+	}
+
+	async getTaskHistory(request: GetTaskHistoryRequest): Promise<TaskHistoryArray> {
+		const { favoritesOnly, currentWorkspaceOnly, searchQuery, sortBy } = request
+		const limit = request.limit > 0 ? Math.min(request.limit, 100) : 50
+		const offset = request.offset > 0 ? request.offset : 0
+		const workspacePath = currentWorkspaceOnly ? await this.getWorkspaceRoot() : undefined
+		const sessionHistory = await this.taskHistory.listHistory({
+			hydrate: false,
+			limit: limit + 1,
+			offset,
+		})
+
+		let filteredTasks = sessionHistory.filter((item) => {
+			const ts = dateStringToTimestamp(item.updatedAt ?? item.endedAt ?? item.startedAt)
+			const task = metadataString(item.metadata, "title") ?? item.prompt ?? ""
+
+			if (!ts || !task) {
+				return false
+			}
+
+			const isFavorited =
+				metadataBoolean(item.metadata, "isFavorited") ?? metadataBoolean(item.metadata, "is_favorited") ?? false
+			if (favoritesOnly && !isFavorited) {
+				return false
+			}
+
+			if (currentWorkspaceOnly && workspacePath) {
+				const sessionWorkspacePath = item.cwd ?? item.workspaceRoot
+				if (!sessionWorkspacePath || !arePathsEqual(sessionWorkspacePath, workspacePath)) {
+					return false
+				}
+			}
+
+			return true
+		})
+
+		if (searchQuery) {
+			const query = searchQuery.toLowerCase()
+			filteredTasks = filteredTasks.filter((item) => {
+				const task = metadataString(item.metadata, "title") ?? item.prompt ?? ""
+				return task.toLowerCase().includes(query)
+			})
+		}
+
+		filteredTasks.sort((a, b) => {
+			switch (sortBy) {
+				case "oldest":
+					return (
+						dateStringToTimestamp(a.updatedAt ?? a.endedAt ?? a.startedAt) -
+						dateStringToTimestamp(b.updatedAt ?? b.endedAt ?? b.startedAt)
+					)
+				case "mostExpensive":
+					return (metadataNumber(b.metadata, "totalCost") ?? 0) - (metadataNumber(a.metadata, "totalCost") ?? 0)
+				case "mostTokens":
+					return (
+						(metadataNumber(b.metadata, "tokensIn") ?? 0) +
+						(metadataNumber(b.metadata, "tokensOut") ?? 0) +
+						(metadataNumber(b.metadata, "cacheWrites") ?? 0) +
+						(metadataNumber(b.metadata, "cacheReads") ?? 0) -
+						((metadataNumber(a.metadata, "tokensIn") ?? 0) +
+							(metadataNumber(a.metadata, "tokensOut") ?? 0) +
+							(metadataNumber(a.metadata, "cacheWrites") ?? 0) +
+							(metadataNumber(a.metadata, "cacheReads") ?? 0))
+					)
+				default:
+					return (
+						dateStringToTimestamp(b.updatedAt ?? b.endedAt ?? b.startedAt) -
+						dateStringToTimestamp(a.updatedAt ?? a.endedAt ?? a.startedAt)
+					)
+			}
+		})
+
+		const hasMore = sessionHistory.length > limit
+		const tasks = filteredTasks.slice(0, limit).map((item) => {
+			const metadata = item.metadata
+			return {
+				id: item.sessionId,
+				task: formatDisplayUserInput(metadataString(metadata, "title") ?? item.prompt ?? ""),
+				ts: dateStringToTimestamp(item.updatedAt ?? item.endedAt ?? item.startedAt),
+				isFavorited: metadataBoolean(metadata, "isFavorited") ?? metadataBoolean(metadata, "is_favorited") ?? false,
+				size: metadataNumber(metadata, "size") ?? 0,
+				totalCost: metadataNumber(metadata, "totalCost") ?? 0,
+				tokensIn: metadataNumber(metadata, "tokensIn") ?? 0,
+				tokensOut: metadataNumber(metadata, "tokensOut") ?? 0,
+				cacheWrites: metadataNumber(metadata, "cacheWrites") ?? 0,
+				cacheReads: metadataNumber(metadata, "cacheReads") ?? 0,
+				modelId: item.model || metadataString(metadata, "modelId") || "",
+			}
+		})
+
+		if (offset === 0 && !favoritesOnly && this.task?.taskId && !tasks.some((task) => task.id === this.task?.taskId)) {
+			const taskMessage = this.task.messageStateHandler
+				.getClineMessages()
+				.find((message) => message.type === "say" && message.say === "task" && message.text)
+			const matchesSearch = !searchQuery || taskMessage?.text?.toLowerCase().includes(searchQuery.toLowerCase())
+			if (taskMessage?.text && matchesSearch) {
+				tasks.unshift({
+					id: this.task.taskId,
+					task: formatDisplayUserInput(taskMessage.text),
+					ts: taskMessage.ts || Date.now(),
+					isFavorited: false,
+					size: 0,
+					totalCost: 0,
+					tokensIn: 0,
+					tokensOut: 0,
+					cacheWrites: 0,
+					cacheReads: 0,
+					modelId: this.task.api?.getModel?.().id ?? "",
+				})
+			}
+		}
+
+		return TaskHistoryArray.create({ tasks: tasks.slice(0, limit), hasMore })
+	}
+
+	async exportTaskWithId(id: string): Promise<void> {
+		const historyItem = (await this.taskHistory.listHistory({ hydrate: false })).find((item) => item.sessionId === id)
+		if (!historyItem) {
+			throw new Error(`Task not found in history: ${id}`)
+		}
+
+		// SDK-backed tasks are no longer stored under VS Code's globalStorageFsPath/tasks.
+		// The SDK owns session persistence and exposes the persisted messages artifact path
+		// on the session history record; open that artifact's containing session directory.
+		const taskDirPath = historyItem.messagesPath ? path.dirname(historyItem.messagesPath) : undefined
+		if (!taskDirPath) {
+			throw new Error(`Task history item has no SDK artifact path: ${id}`)
+		}
+
+		await fs.access(taskDirPath)
+		Logger.log(`[EXPORT] Opening SDK task directory: ${taskDirPath}`)
+		const open = (await import("open")).default
+		await open(taskDirPath)
+	}
+
+	async deleteTaskFromState(id: string): Promise<HistoryItem[]> {
+		return this.taskHistory.deleteTaskFromState(id)
+	}
+
+	async deleteAllTaskHistory(): Promise<DeleteAllTaskHistoryCount> {
+		await this.clearTask()
+
+		const taskHistory = await this.taskHistory.listHistory({ hydrate: false })
+		const totalTasks = taskHistory.length
+
+		const userChoice = (
+			await HostProvider.window.showMessage(
+				ShowMessageRequest.create({
+					type: ShowMessageType.WARNING,
+					message: "What would you like to delete?",
+					options: {
+						modal: true,
+						items: ["Delete All Except Favorites", "Delete Everything"],
+					},
+				}),
+			)
+		).selectedOption
+
+		if (userChoice === undefined) {
+			return DeleteAllTaskHistoryCount.create({ tasksDeleted: 0 })
+		}
+
+		if (userChoice === "Delete All Except Favorites") {
+			const hasFavoritedTasks = taskHistory.some(
+				(task) =>
+					metadataBoolean(task.metadata, "isFavorited") ?? metadataBoolean(task.metadata, "is_favorited") ?? false,
+			)
+
+			if (hasFavoritedTasks) {
+				const tasksDeleted = await this.taskHistory.deleteAllTaskHistory({
+					preserveFavorites: true,
+				})
+				await this.postStateToWebview()
+				return DeleteAllTaskHistoryCount.create({ tasksDeleted })
+			}
+
+			const answer = (
+				await HostProvider.window.showMessage({
+					type: ShowMessageType.WARNING,
+					message: "No favorited tasks found. Would you like to delete all tasks anyway?",
+					options: {
+						modal: true,
+						items: ["Delete All Tasks"],
+					},
+				})
+			).selectedOption
+
+			if (answer === undefined) {
+				return DeleteAllTaskHistoryCount.create({ tasksDeleted: 0 })
+			}
+		}
+
+		const tasksDeleted = await this.taskHistory.deleteAllTaskHistory()
+		await this.postStateToWebview()
+		return DeleteAllTaskHistoryCount.create({
+			tasksDeleted: tasksDeleted || totalTasks,
+		})
+	}
+
+	async updateTaskHistory(item: HistoryItem): Promise<HistoryItem[]> {
+		return this.taskHistory.updateTaskHistory(item)
+	}
+
+	async toggleTaskFavorite(taskId: string, isFavorited: boolean): Promise<void> {
+		const historyItem = await this.taskHistory.findHistoryItem(taskId)
+		if (!historyItem) {
+			Logger.log(`[toggleTaskFavorite] Task not found in history: ${taskId}`)
+			return
+		}
+
+		await this.taskHistory.updateTaskHistory({
+			...historyItem,
+			isFavorited,
+		})
+		await this.postStateToWebview()
+	}
+
+	// ---- Background command state ----
+
+	updateBackgroundCommandState(running: boolean, taskId?: string): void {
+		this.backgroundCommandRunning = running
+		this.backgroundCommandTaskId = taskId
+	}
+
+	// ---- State management ----
+
+	/**
+	 * Request a webview state update.
+	 *
+	 * Callers fire this very frequently (notably the session event coordinator,
+	 * once per streamed message/turn boundary), and each rebuild walks the full
+	 * task history. StatePostDebouncer coalesces bursts into a single trailing
+	 * rebuild to avoid hammering the extension host. The returned promise
+	 * resolves once a snapshot reflecting this request has been shipped, or
+	 * rejects if that rebuild failed.
+	 */
+	postStateToWebview(): Promise<void> {
+		if (this.isDisposed) {
+			return Promise.resolve()
+		}
+		return this.statePostDebouncer.post()
+	}
+
+	/** Build the current ExtensionState and push it to the webview immediately. */
+	private async flushStateToWebview(): Promise<void> {
+		// Import dynamically to avoid circular deps
+		const { sendStateUpdate } = await import("@core/controller/state/subscribeToState")
+		const state = await this.getStateToPostToWebview()
+		await sendStateUpdate(state)
+	}
+
+	/**
+	 * Reset the message translator's streaming state AND bump the conversation/replica fence
+	 * (epoch). Called at every conversation boundary (task start/clear, history open, reinit,
+	 * mode rebuild, new-session follow-up). Bumping the epoch BEFORE the new state is pushed
+	 * means any straggler message/state from the previous task or render carries an older epoch
+	 * and is dropped by the webview. Order matters: bump synchronously here, before any await.
+	 */
+	resetMessageTranslatorAndFence(): void {
+		this.messageTranslatorState.reset()
+		this.messageTranslatorState.getMinter().bumpEpoch()
+	}
+
+	async getStateToPostToWebview(): Promise<ExtensionState> {
+		// Build the base ExtensionState from StateManager, then layer the SDK's
+		// task history on top.
+		try {
+			syncTelemetrySettingFromSharedGlobalSettings(this.stateManager)
+			const { getStateToPostToWebview: buildBaseState } = await import("@core/controller/state/getStateToPostToWebview")
+			const state = await buildBaseState({
+				task: this.task,
+				stateManager: this.stateManager,
+				mcpHub: this.mcpHub,
+				backgroundCommandRunning: this.backgroundCommandRunning,
+				backgroundCommandTaskId: this.backgroundCommandTaskId,
+			})
+			const sdkTaskHistory = (await this.taskHistory.listHistory({ limit: 100, hydrate: false }))
+				.map(sessionHistoryRecordToHistoryItem)
+				.filter((item) => item.ts && item.task)
+				.sort((a, b) => b.ts - a.ts)
+			const legacyTaskHistory = state.taskHistory ?? []
+			const mergedTaskHistoryById = new Map<string, HistoryItem>()
+
+			// Keep the SDK records authoritative for migrated/new tasks, but append
+			// legacy persisted history so pre-migration tasks still appear in the UI.
+			for (const item of legacyTaskHistory) {
+				mergedTaskHistoryById.set(item.id, item)
+			}
+			for (const item of sdkTaskHistory) {
+				mergedTaskHistoryById.set(item.id, item)
+			}
+
+			// A just-started task may not be visible in SDK persisted history yet (the
+			// history adapter can lag behind the active in-memory TaskProxy). Classic
+			// state included the current task immediately, and the testing platform
+			// asserts that taskHistory reflects newTask before the model turn completes.
+			if (this.task?.taskId && !mergedTaskHistoryById.has(this.task.taskId)) {
+				const taskMessage = this.task.messageStateHandler
+					.getClineMessages()
+					.find((message) => message.type === "say" && message.say === "task" && message.text)
+				if (taskMessage?.text) {
+					mergedTaskHistoryById.set(this.task.taskId, {
+						id: this.task.taskId,
+						ts: taskMessage.ts || Date.now(),
+						task: taskMessage.text,
+						tokensIn: 0,
+						tokensOut: 0,
+						cacheWrites: 0,
+						cacheReads: 0,
+						totalCost: 0,
+						modelId: this.task.api?.getModel?.().id,
+						cwdOnTaskInitialization: await this.getWorkspaceRoot(),
+					})
+				}
+			}
+
+			const processedTaskHistory = Array.from(mergedTaskHistoryById.values())
+				.filter((item) => item.ts && item.task)
+				.sort((a, b) => b.ts - a.ts)
+				.slice(0, 100)
+
+			let queuedPrompts: ExtensionState["queuedPrompts"] = []
+			const activeSession = this.sessions.getActiveSession()
+			if (activeSession) {
+				try {
+					queuedPrompts = await activeSession.sdkHost.pendingPrompts("list", { sessionId: activeSession.sessionId })
+				} catch (error) {
+					Logger.error("[SdkController] Failed to list pending prompts for webview state:", error)
+				}
+			}
+
+			// Stamp the snapshot with the current epoch and a fresh monotonic version, sampled
+			// from the SAME counter that stamps messages. This lets the webview ignore stale
+			// out-of-order state pushes and fence traffic from a previous task/render. Sampled
+			// synchronously here (no await between sampling and return).
+			const minter = this.messageTranslatorState.getMinter()
+			return {
+				...state,
+				currentTaskItem: this.task?.taskId
+					? processedTaskHistory.find((item) => item.id === this.task?.taskId)
+					: undefined,
+				taskHistory: processedTaskHistory,
+				turnState: this.turnStateTracker.get(),
+				queuedPrompts,
+				stateVersion: minter.nextSeq(),
+				epoch: minter.epoch,
+			}
+		} catch (error) {
+			Logger.error("[SdkController] Failed to get state for webview:", error)
+			throw error
+		}
+	}
+
+	// ---- Terminal settings ----
+
+	/**
+	 * Apply the user's terminal settings from StateManager to a terminal manager.
+	 * Called once when the lazy terminal manager is first created, and can be
+	 * called again when settings change at runtime.
+	 */
+	applyTerminalSettings(terminalManager: ITerminalManager): void {
+		const shellIntegrationTimeout = this.stateManager.getGlobalSettingsKey("shellIntegrationTimeout")
+		if (shellIntegrationTimeout !== undefined) {
+			terminalManager.setShellIntegrationTimeout(Number(shellIntegrationTimeout))
+		}
+
+		const terminalReuseEnabled = this.stateManager.getGlobalStateKey("terminalReuseEnabled")
+		if (terminalReuseEnabled !== undefined) {
+			terminalManager.setTerminalReuseEnabled(!!terminalReuseEnabled)
+		}
+
+		const defaultTerminalProfile = this.stateManager.getGlobalSettingsKey("defaultTerminalProfile")
+		if (defaultTerminalProfile !== undefined && defaultTerminalProfile !== "") {
+			terminalManager.setDefaultTerminalProfile(String(defaultTerminalProfile))
+		}
+
+		Logger.log(
+			`[SdkController] Applied terminal settings: profile=${defaultTerminalProfile ?? "default"}, ` +
+				`timeout=${shellIntegrationTimeout ?? 4000}, reuse=${terminalReuseEnabled ?? true}`,
+		)
+	}
+
+	/**
+	 * Get the terminal manager instance (if created).
+	 * Used by updateSettings handlers to apply runtime changes.
+	 */
+	get terminalManager(): ITerminalManager | undefined {
+		return this._terminalManager
+	}
+
+	// ---- Workspace (kept from classic) ----
+
+	async ensureWorkspaceManager(): Promise<WorkspaceRootManager | undefined> {
+		stubWarn("ensureWorkspaceManager")
+		return undefined
+	}
+}
diff --git a/apps/vscode/src/sdk/account-service.ts b/apps/vscode/src/sdk/account-service.ts
new file mode 100644
index 0000000..9b8a1e7
--- /dev/null
+++ b/apps/vscode/src/sdk/account-service.ts
@@ -0,0 +1,258 @@
+// Replaces classic src/services/account/ClineAccountService.ts (see origin/main)
+//
+// SDK-backed account service. Handles credits, organizations, and user data
+// by making authenticated requests to the Cline API.
+
+import type {
+	BalanceResponse,
+	OrganizationBalanceResponse,
+	OrganizationUsageTransaction,
+	PaymentTransaction,
+	UsageTransaction,
+	UserResponse,
+} from "@shared/ClineAccount"
+import axios, { type AxiosRequestConfig, type AxiosResponse } from "axios"
+import { ClineEnv } from "@/config"
+import { buildBasicClineHeaders } from "@/services/EnvUtils"
+import { CLINE_API_ENDPOINT } from "@/shared/cline/api"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { AuthService } from "./auth-service"
+
+export class ClineAccountService {
+	private static instance: ClineAccountService
+	private _authService: AuthService
+
+	constructor() {
+		this._authService = AuthService.getInstance()
+	}
+
+	/**
+	 * Returns the singleton instance of ClineAccountService
+	 */
+	public static getInstance(): ClineAccountService {
+		if (!ClineAccountService.instance) {
+			ClineAccountService.instance = new ClineAccountService()
+		}
+		return ClineAccountService.instance
+	}
+
+	/**
+	 * Returns the base URL for the Cline API
+	 */
+	get baseUrl(): string {
+		return ClineEnv.config().apiBaseUrl
+	}
+
+	/**
+	 * Helper function to make authenticated requests to the Cline API.
+	 * Uses the SDK-backed AuthService for token management.
+	 */
+	private async authenticatedRequest<T>(endpoint: string, config: AxiosRequestConfig = {}): Promise<T> {
+		const url = new URL(endpoint, this.baseUrl).toString()
+		// IMPORTANT: Prefixed with 'workos:' so backend can route verification to WorkOS provider
+		const clineAccountAuthToken = await this._authService.getAuthToken()
+		if (!clineAccountAuthToken) {
+			throw new Error("No Cline account auth token found")
+		}
+		const requestConfig: AxiosRequestConfig = {
+			...config,
+			headers: {
+				Authorization: `Bearer ${clineAccountAuthToken}`,
+				"Content-Type": "application/json",
+				...(await buildBasicClineHeaders()),
+				...config.headers,
+			},
+			...getAxiosSettings(),
+		}
+		const response: AxiosResponse<{ data?: T; error: string; success: boolean }> = await axios.request({
+			url,
+			method: "GET",
+			...requestConfig,
+		})
+		const status = response.status
+		if (status < 200 || status >= 300) {
+			throw new Error(`Request to ${endpoint} failed with status ${status}`)
+		}
+		if (response.statusText !== "No Content" && (!response.data || !response.data.data)) {
+			throw new Error(`Invalid response from ${endpoint} API`)
+		}
+		if (typeof response.data === "object" && !response.data.success) {
+			throw new Error(`API error: ${response.data.error}`)
+		}
+		if (response.statusText === "No Content") {
+			return {} as T
+		}
+		return response.data.data as T
+	}
+
+	/**
+	 * RPC variant that fetches the user's current credit balance
+	 */
+	async fetchBalanceRPC(): Promise<BalanceResponse | undefined> {
+		try {
+			const me = this.getCurrentUser()
+			if (!me || !me.uid) {
+				Logger.error("Failed to fetch user ID for balance")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<BalanceResponse>(`/api/v1/users/${me.uid}/balance`)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch balance (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * RPC variant that fetches the user's usage transactions
+	 */
+	async fetchUsageTransactionsRPC(): Promise<UsageTransaction[] | undefined> {
+		try {
+			const me = this.getCurrentUser()
+			if (!me || !me.uid) {
+				Logger.error("Failed to fetch user ID for usage transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<{ items: UsageTransaction[] }>(`/api/v1/users/${me.uid}/usages`)
+			return data.items
+		} catch (error) {
+			Logger.error("Failed to fetch usage transactions (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * RPC variant that fetches the user's payment transactions
+	 */
+	async fetchPaymentTransactionsRPC(): Promise<PaymentTransaction[] | undefined> {
+		try {
+			const me = this.getCurrentUser()
+			if (!me || !me.uid) {
+				Logger.error("Failed to fetch user ID for payment transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<{ paymentTransactions: PaymentTransaction[] }>(
+				`/api/v1/users/${me.uid}/payments`,
+			)
+			return data.paymentTransactions
+		} catch (error) {
+			Logger.error("Failed to fetch payment transactions (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user data
+	 */
+	async fetchMe(): Promise<UserResponse | undefined> {
+		try {
+			const data = await this.authenticatedRequest<UserResponse>(CLINE_API_ENDPOINT.USER_INFO)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch user data (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user's organizations
+	 */
+	async fetchUserOrganizationsRPC(): Promise<UserResponse["organizations"] | undefined> {
+		try {
+			const me = await this.fetchMe()
+			if (!me || !me.organizations) {
+				Logger.error("Failed to fetch user organizations")
+				return undefined
+			}
+			return me.organizations
+		} catch (error) {
+			Logger.error("Failed to fetch user organizations (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user's organization credits
+	 */
+	async fetchOrganizationCreditsRPC(organizationId: string): Promise<OrganizationBalanceResponse | undefined> {
+		try {
+			const data = await this.authenticatedRequest<OrganizationBalanceResponse>(
+				`/api/v1/organizations/${organizationId}/balance`,
+			)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch organization balance (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user's organization transactions
+	 */
+	async fetchOrganizationUsageTransactionsRPC(organizationId: string): Promise<OrganizationUsageTransaction[] | undefined> {
+		try {
+			const organizations = this._authService.getUserOrganizations()
+			if (!organizations) {
+				Logger.error("Failed to get user organizations")
+				return undefined
+			}
+			const memberId = organizations.find((org) => org.organizationId === organizationId)?.memberId
+			if (!memberId) {
+				Logger.error("Failed to find member ID for organization transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<{ items: OrganizationUsageTransaction[] }>(
+				`/api/v1/organizations/${organizationId}/members/${memberId}/usages`,
+			)
+			return data.items
+		} catch (error) {
+			Logger.error("Failed to fetch organization transactions (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Submits a spend limit increase request to the user's org admin.
+	 */
+	async submitLimitIncreaseRequestRPC(): Promise<void> {
+		try {
+			await this.authenticatedRequest<void>("/api/v1/users/me/budget/request", {
+				method: "POST",
+			})
+		} catch (error) {
+			Logger.error("Failed to submit limit increase request (RPC):", error)
+			throw error
+		}
+	}
+
+	/**
+	 * Switches the active account to the specified organization or personal account.
+	 */
+	async switchAccount(organizationId?: string): Promise<void> {
+		try {
+			await this.authenticatedRequest<string>(CLINE_API_ENDPOINT.ACTIVE_ACCOUNT, {
+				method: "PUT",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				data: {
+					organizationId: organizationId || null,
+				},
+			})
+			const activeOrgId = this._authService.getActiveOrganizationId()
+			if (activeOrgId !== organizationId) {
+				// Force a refresh of the auth info after switching
+				await this._authService.restoreRefreshTokenAndRetrieveAuthInfo()
+			}
+		} catch (error) {
+			Logger.error("Error switching account:", error)
+			await this._authService.restoreRefreshTokenAndRetrieveAuthInfo()
+			throw error
+		}
+	}
+
+	private getCurrentUser() {
+		return this._authService.getInfo().user
+	}
+}
diff --git a/apps/vscode/src/sdk/auth-service.test.ts b/apps/vscode/src/sdk/auth-service.test.ts
new file mode 100644
index 0000000..5cb2988
--- /dev/null
+++ b/apps/vscode/src/sdk/auth-service.test.ts
@@ -0,0 +1,558 @@
+// Tests for the SDK-backed AuthService (Step 6: Auth & Account Flows)
+//
+// These tests verify the auth service's core logic:
+// - Token persistence (read/write/clear from secrets)
+// - Auth state management (authenticated/unauthenticated)
+// - Auth info conversion (SDK OAuthCredentials → ClineAuthInfo)
+// - Logout flow
+// - Streaming subscription management
+// - workos: prefix handling
+
+import { getValidClineCredentials, type OAuthCredentials } from "@cline/core"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { AuthService, type ClineAuthInfo, LogoutReason } from "./auth-service"
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+const mockFeatureFlagsPoll = vi.hoisted(() => vi.fn().mockResolvedValue(undefined))
+const mockIdentifyAccount = vi.hoisted(() => vi.fn().mockResolvedValue(undefined))
+
+// Mock StateManager
+const mockSecrets = new Map<string, string>()
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: {
+		get: () => ({
+			getSecretKey: (key: string) => mockSecrets.get(key) ?? undefined,
+			setSecret: (key: string, value: string | undefined) => {
+				if (value === undefined) {
+					mockSecrets.delete(key)
+				} else {
+					mockSecrets.set(key, value)
+				}
+			},
+			getGlobalSettingsKey: () => "act",
+			setGlobalState: vi.fn(),
+		}),
+	},
+}))
+
+// Mock ClineEnv
+vi.mock("@/config", () => ({
+	ClineEnv: {
+		config: () => ({
+			apiBaseUrl: "https://api.cline.bot",
+			appBaseUrl: "https://app.cline.bot",
+		}),
+	},
+}))
+
+// Mock grpc-handler
+vi.mock("@/core/controller/grpc-handler", () => ({
+	getRequestRegistry: () => ({
+		registerRequest: vi.fn(),
+	}),
+}))
+
+// Mock HostProvider
+vi.mock("@/hosts/host-provider", () => ({
+	HostProvider: {
+		get: () => ({
+			getCallbackUrl: async (path: string) => `vscode://cline.cline${path}`,
+		}),
+	},
+}))
+
+// Mock openExternal
+vi.mock("@/utils/env", () => ({
+	openExternal: vi.fn(),
+}))
+
+// Mock net
+vi.mock("@/shared/net", () => ({
+	fetch: vi.fn(),
+	getAxiosSettings: () => ({}),
+}))
+
+// Mock buildBasicClineHeaders
+vi.mock("@/services/EnvUtils", () => ({
+	buildBasicClineHeaders: async () => ({}),
+}))
+
+// Mock feature flags
+vi.mock("@/services/feature-flags", () => ({
+	featureFlagsService: {
+		poll: mockFeatureFlagsPoll,
+	},
+}))
+
+vi.mock("@/services/telemetry", () => ({
+	telemetryService: {
+		identifyAccount: mockIdentifyAccount,
+	},
+}))
+
+// Mock axios
+vi.mock("axios", () => ({
+	default: {
+		get: vi.fn(),
+	},
+}))
+
+const mockLoginClineOAuth = vi.hoisted(() => vi.fn())
+
+// Mock @cline/core OAuth functions
+vi.mock("@cline/core", async () => ({
+	sdkDebug: () => {},
+	hashSecret: () => "hashed",
+	createOAuthClientCallbacks: (opts: {
+		onOutput?: (message: string) => void
+		onPrompt: () => void
+		openUrl?: (url: string) => void | Promise<void>
+	}) => ({
+		onAuth: ({ url, instructions }: { url: string; instructions?: string }) => {
+			opts.onOutput?.(instructions ?? "Complete sign-in in your browser.")
+			void opts.openUrl?.(url)
+			opts.onOutput?.(url)
+		},
+		onPrompt: opts.onPrompt,
+	}),
+	loginClineOAuth: mockLoginClineOAuth,
+	loginOcaOAuth: vi.fn(),
+	loginOpenAICodex: vi.fn(),
+	refreshClineToken: vi.fn(),
+	getValidClineCredentials: vi.fn(),
+}))
+
+// Stateful in-memory provider-settings store. Cline credentials are persisted
+// to providers.json (via the SDK's ProviderSettingsManager), not to secrets, so
+// the credential round-trip tests exercise this store.
+const mockProviderSettings = new Map<string, Record<string, unknown>>()
+vi.mock("./provider-migration", () => ({
+	getProviderSettingsManager: () => ({
+		getProviderSettings: (provider: string) => mockProviderSettings.get(provider),
+		saveProviderSettings: (settings: Record<string, unknown>) => {
+			const provider = settings.provider as string
+			mockProviderSettings.set(provider, { ...settings })
+		},
+	}),
+}))
+
+// ---------------------------------------------------------------------------
+// Test helpers — typed access to private members for testing
+// ---------------------------------------------------------------------------
+
+/** Type that exposes private members for test access */
+interface AuthServiceTestAccess {
+	_clineAuthInfo: ClineAuthInfo | null
+	_authenticated: boolean
+	_activeAuthStatusUpdateHandlers: Map<string, unknown>
+	instance: AuthService | null
+}
+
+function testAccess(service: AuthService): AuthServiceTestAccess {
+	// biome-ignore lint/suspicious/noExplicitAny: test-only access to private members
+	return service as any
+}
+
+function resetSingleton(): void {
+	// biome-ignore lint/suspicious/noExplicitAny: test-only reset of singleton
+	;(AuthService as any).instance = null
+}
+
+// ---------------------------------------------------------------------------
+// Test fixtures
+// ---------------------------------------------------------------------------
+
+function createTestAuthInfo(overrides?: Partial<ClineAuthInfo>): ClineAuthInfo {
+	return {
+		idToken: "test-access-token",
+		refreshToken: "test-refresh-token",
+		expiresAt: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now (seconds)
+		userInfo: {
+			id: "user-123",
+			email: "test@example.com",
+			displayName: "Test User",
+			organizations: [
+				{
+					active: true,
+					memberId: "member-1",
+					name: "Personal",
+					organizationId: "org-personal",
+					roles: ["owner"],
+				},
+			],
+		},
+		provider: "cline",
+		startedAt: Date.now(),
+		...overrides,
+	}
+}
+
+function createTestOAuthCredentials(): OAuthCredentials {
+	return {
+		access: "oauth-access-token",
+		refresh: "oauth-refresh-token",
+		expires: Date.now() + 3600 * 1000, // 1 hour from now (ms)
+		accountId: "acct-456",
+		email: "oauth@example.com",
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("AuthService", () => {
+	let authService: AuthService
+
+	beforeEach(() => {
+		// Reset the singleton between tests
+		resetSingleton()
+		authService = AuthService.getInstance()
+		mockSecrets.clear()
+		mockProviderSettings.clear()
+		vi.clearAllMocks()
+	})
+
+	describe("singleton pattern", () => {
+		it("returns the same instance on multiple calls", () => {
+			const instance1 = AuthService.getInstance()
+			const instance2 = AuthService.getInstance()
+			expect(instance1).toBe(instance2)
+		})
+	})
+
+	describe("getInfo() — auth state for webview", () => {
+		it("returns unauthenticated state when not logged in", () => {
+			const info = authService.getInfo()
+			// Unset proto message fields are `undefined`, not `null`.
+			expect(info.user).toBeUndefined()
+		})
+
+		it("returns authenticated state with user info when logged in", () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = true
+
+			const info = authService.getInfo()
+			expect(info.user).not.toBeNull()
+			expect(info.user?.uid).toBe("user-123")
+			expect(info.user?.email).toBe("test@example.com")
+			expect(info.user?.displayName).toBe("Test User")
+		})
+
+		it("returns unauthenticated state when _authenticated is false even with auth info", () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = false
+
+			const info = authService.getInfo()
+			expect(info.user).toBeUndefined()
+		})
+	})
+
+	describe("getActiveOrganizationId()", () => {
+		it("returns null when not authenticated", () => {
+			expect(authService.getActiveOrganizationId()).toBeNull()
+		})
+
+		it("returns the active organization ID when authenticated", () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+
+			expect(authService.getActiveOrganizationId()).toBe("org-personal")
+		})
+
+		it("returns null when no active organization exists", () => {
+			const authInfo = createTestAuthInfo({
+				userInfo: {
+					...createTestAuthInfo().userInfo,
+					organizations: [
+						{
+							active: false,
+							memberId: "member-1",
+							name: "Personal",
+							organizationId: "org-personal",
+							roles: ["owner"],
+						},
+					],
+				},
+			})
+			testAccess(authService)._clineAuthInfo = authInfo
+
+			expect(authService.getActiveOrganizationId()).toBeNull()
+		})
+	})
+
+	describe("getUserOrganizations()", () => {
+		it("returns undefined when not authenticated", () => {
+			expect(authService.getUserOrganizations()).toBeUndefined()
+		})
+
+		it("returns organizations when authenticated", () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+
+			const orgs = authService.getUserOrganizations()
+			expect(orgs).toHaveLength(1)
+			expect(orgs?.[0].organizationId).toBe("org-personal")
+		})
+	})
+
+	describe("getProviderName()", () => {
+		it("returns null when not authenticated", () => {
+			expect(authService.getProviderName()).toBeNull()
+		})
+
+		it("returns the provider name when authenticated", () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+
+			expect(authService.getProviderName()).toBe("cline")
+		})
+	})
+
+	describe("getAuthToken()", () => {
+		it("returns null when not authenticated", async () => {
+			expect(await authService.getAuthToken()).toBeNull()
+		})
+
+		it("returns workos:-prefixed token when authenticated", async () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = true
+
+			const token = await authService.getAuthToken()
+			expect(token).toBe("workos:test-access-token")
+		})
+
+		it("returns null when token is expired and refresh fails", async () => {
+			const authInfo = createTestAuthInfo({
+				expiresAt: Math.floor(Date.now() / 1000) - 100, // expired
+			})
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = true
+
+			// No refresh token → can't refresh
+			authInfo.refreshToken = undefined
+			const token = await authService.getAuthToken()
+			expect(token).toBeNull()
+		})
+	})
+
+	describe("createAuthRequest()", () => {
+		it("returns the SDK device auth instruction so the webview can display the browser confirmation code", async () => {
+			mockLoginClineOAuth.mockImplementationOnce(async ({ callbacks, useWorkOSDeviceAuth }) => {
+				expect(useWorkOSDeviceAuth).toBe(true)
+				callbacks.onAuth({
+					url: "https://example.com/device?user_code=ABCD-EFGH",
+					instructions: "Enter this code in your browser: ABCD-EFGH",
+				})
+
+				return createTestOAuthCredentials()
+			})
+
+			const response = await authService.createAuthRequest()
+
+			expect(response.value).toBe("Enter this code in your browser: ABCD-EFGH")
+		})
+	})
+
+	describe("handleDeauth() — logout", () => {
+		it("clears auth state and pushes unauthenticated state", async () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = true
+
+			// Seed persisted Cline credentials in providers.json.
+			mockProviderSettings.set("cline", {
+				provider: "cline",
+				auth: { accessToken: "workos:test-access-token", refreshToken: "test-refresh-token", accountId: "user-123" },
+			})
+
+			await authService.handleDeauth(LogoutReason.USER_INITIATED)
+
+			// In-memory auth state should be cleared.
+			expect(testAccess(authService)._clineAuthInfo).toBeNull()
+			expect(testAccess(authService)._authenticated).toBe(false)
+
+			// Persisted credentials should be cleared from providers.json.
+			expect(mockProviderSettings.get("cline")?.auth).toBeUndefined()
+		})
+	})
+
+	describe("token persistence (providers.json)", () => {
+		// Cline OAuth credentials are persisted to providers.json via the SDK's
+		// ProviderSettingsManager, not to VSCode secrets. These tests exercise
+		// the round-trip through the public restore/logout surface.
+
+		it("restores credentials persisted in providers.json", async () => {
+			mockProviderSettings.set("cline", {
+				provider: "cline",
+				auth: {
+					accessToken: "workos:persisted-access-token",
+					refreshToken: "persisted-refresh-token",
+					accountId: "user-123",
+				},
+			})
+			vi.mocked(getValidClineCredentials).mockResolvedValue({
+				access: "persisted-access-token",
+				refresh: "persisted-refresh-token",
+				expires: Date.now() + 3600 * 1000,
+				accountId: "user-123",
+				email: "test@example.com",
+			})
+
+			await authService.restoreRefreshTokenAndRetrieveAuthInfo()
+
+			expect(testAccess(authService)._authenticated).toBe(true)
+			expect(testAccess(authService)._clineAuthInfo?.idToken).toBe("persisted-access-token")
+		})
+
+		it("sets unauthenticated state when providers.json has no Cline auth", async () => {
+			await authService.restoreRefreshTokenAndRetrieveAuthInfo()
+
+			expect(testAccess(authService)._authenticated).toBe(false)
+			expect(testAccess(authService)._clineAuthInfo).toBeNull()
+		})
+
+		it("clears persisted credentials when stored tokens are no longer valid", async () => {
+			mockProviderSettings.set("cline", {
+				provider: "cline",
+				auth: { accessToken: "workos:stale", refreshToken: "stale-refresh", accountId: "user-123" },
+			})
+			// getValidClineCredentials returning null models an unrecoverable token.
+			vi.mocked(getValidClineCredentials).mockResolvedValue(null)
+
+			await authService.restoreRefreshTokenAndRetrieveAuthInfo()
+
+			expect(testAccess(authService)._authenticated).toBe(false)
+			expect(testAccess(authService)._clineAuthInfo).toBeNull()
+			expect(mockProviderSettings.get("cline")?.auth).toBeUndefined()
+		})
+	})
+
+	describe("restoreRefreshTokenAndRetrieveAuthInfo()", () => {
+		it("strips the workos: prefix from the persisted access token", async () => {
+			mockProviderSettings.set("cline", {
+				provider: "cline",
+				auth: { accessToken: "workos:raw-access-token", refreshToken: "r", accountId: "user-123" },
+			})
+			vi.mocked(getValidClineCredentials).mockResolvedValue({
+				access: "raw-access-token",
+				refresh: "r",
+				expires: Date.now() + 3600 * 1000,
+				accountId: "user-123",
+				email: "test@example.com",
+			})
+
+			await authService.restoreRefreshTokenAndRetrieveAuthInfo()
+
+			expect(testAccess(authService)._clineAuthInfo?.idToken).toBe("raw-access-token")
+		})
+
+		it("sets unauthenticated state when no credentials exist", async () => {
+			await authService.restoreRefreshTokenAndRetrieveAuthInfo()
+
+			expect(testAccess(authService)._authenticated).toBe(false)
+			expect(testAccess(authService)._clineAuthInfo).toBeNull()
+		})
+	})
+
+	describe("LogoutReason enum", () => {
+		it("has expected values", () => {
+			expect(LogoutReason.USER_INITIATED).toBe("user_initiated")
+			expect(LogoutReason.CROSS_WINDOW_SYNC).toBe("cross_window_sync")
+			expect(LogoutReason.ERROR_RECOVERY).toBe("error_recovery")
+			expect(LogoutReason.UNKNOWN).toBe("unknown")
+		})
+	})
+
+	describe("workos: prefix handling", () => {
+		it("getAuthToken always returns workos:-prefixed token", async () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = true
+
+			const token = await authService.getAuthToken()
+			expect(token).toMatch(/^workos:/)
+			expect(token).toBe("workos:test-access-token")
+		})
+	})
+
+	describe("streaming subscriptions", () => {
+		it("subscribeToAuthStatusUpdate pushes initial state immediately", async () => {
+			const mockResponseStream = vi.fn()
+			const mockController = { postStateToWebview: vi.fn(), invalidateProviderListings: vi.fn() }
+
+			await authService.subscribeToAuthStatusUpdate(
+				// biome-ignore lint/suspicious/noExplicitAny: mock controller for testing
+				mockController as any,
+				{},
+				// biome-ignore lint/suspicious/noExplicitAny: mock response stream for testing
+				mockResponseStream as any,
+				"test-request-id",
+			)
+
+			// Should have pushed initial auth state
+			expect(mockResponseStream).toHaveBeenCalled()
+			const [authState] = mockResponseStream.mock.calls[0]
+			expect(authState).toBeDefined()
+			expect(authState.user).toBeUndefined() // Not authenticated in this test
+		})
+
+		it("polls feature flags with the authenticated user before posting state", async () => {
+			const authInfo = createTestAuthInfo()
+			testAccess(authService)._clineAuthInfo = authInfo
+			testAccess(authService)._authenticated = true
+
+			const mockResponseStream = vi.fn().mockResolvedValue(undefined)
+			const mockController = { postStateToWebview: vi.fn(), invalidateProviderListings: vi.fn() }
+
+			await authService.subscribeToAuthStatusUpdate(
+				// biome-ignore lint/suspicious/noExplicitAny: mock controller for testing
+				mockController as any,
+				{},
+				// biome-ignore lint/suspicious/noExplicitAny: mock response stream for testing
+				mockResponseStream as any,
+			)
+
+			expect(mockFeatureFlagsPoll).toHaveBeenCalledWith("user-123")
+			expect(mockIdentifyAccount).toHaveBeenCalledWith(authInfo.userInfo)
+			expect(mockIdentifyAccount.mock.invocationCallOrder[0]).toBeLessThan(mockFeatureFlagsPoll.mock.invocationCallOrder[0])
+			expect(mockController.postStateToWebview).toHaveBeenCalled()
+		})
+
+		it("polls feature flags with null when unauthenticated", async () => {
+			await authService.sendAuthStatusUpdate()
+
+			expect(mockFeatureFlagsPoll).toHaveBeenCalledWith(null)
+			expect(mockIdentifyAccount).not.toHaveBeenCalled()
+		})
+
+		it("removes subscription on cleanup", async () => {
+			const mockResponseStream = vi.fn().mockResolvedValue(undefined)
+			const mockController = { postStateToWebview: vi.fn(), invalidateProviderListings: vi.fn() }
+
+			await authService.subscribeToAuthStatusUpdate(
+				// biome-ignore lint/suspicious/noExplicitAny: mock controller for testing
+				mockController as any,
+				{},
+				// biome-ignore lint/suspicious/noExplicitAny: mock response stream for testing
+				mockResponseStream as any,
+			)
+
+			// Should have one handler
+			expect(testAccess(authService)._activeAuthStatusUpdateHandlers.size).toBe(1)
+
+			// Simulate cleanup
+			testAccess(authService)._activeAuthStatusUpdateHandlers.clear()
+			expect(testAccess(authService)._activeAuthStatusUpdateHandlers.size).toBe(0)
+		})
+	})
+})
+
+// Ensure createTestOAuthCredentials is used (suppress unused warning)
+void createTestOAuthCredentials
diff --git a/apps/vscode/src/sdk/auth-service.ts b/apps/vscode/src/sdk/auth-service.ts
new file mode 100644
index 0000000..f82a79c
--- /dev/null
+++ b/apps/vscode/src/sdk/auth-service.ts
@@ -0,0 +1,1066 @@
+// Replaces classic src/services/auth/AuthService.ts (see origin/main)
+//
+// SDK-backed authentication service. Uses @cline/core OAuth functions
+// for login flows and ProviderSettingsManager (providers.json) as the
+// single source of truth for credentials.
+//
+// User profile info (email, displayName, organizations) is NOT stored on
+// disk — it's fetched from the Cline API on startup and cached in memory.
+// This matches the CLI's pattern (see apps/cli/src/runtime/interactive-welcome.ts).
+
+import type { OAuthCredentials } from "@cline/core"
+import {
+	createOAuthClientCallbacks,
+	getValidClineCredentials,
+	hashSecret,
+	loginClineOAuth,
+	loginOcaOAuth,
+	loginOpenAICodex,
+	sdkDebug,
+} from "@cline/core"
+import type { ApiProvider } from "@shared/api"
+import { AuthState, UserInfo } from "@shared/proto/cline/account"
+import type { EmptyRequest, String } from "@shared/proto/cline/common"
+import axios from "axios"
+import { ClineEnv } from "@/config"
+import type { Controller } from "@/core/controller"
+import { getRequestRegistry, type StreamingResponseHandler } from "@/core/controller/grpc-handler"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostProvider } from "@/hosts/host-provider"
+import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
+import { BannerService } from "@/services/banner/BannerService"
+import { buildBasicClineHeaders } from "@/services/EnvUtils"
+import { featureFlagsService } from "@/services/feature-flags"
+import { telemetryService } from "@/services/telemetry"
+import { CLINE_API_ENDPOINT } from "@/shared/cline/api"
+import { fetch, getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { openExternal } from "@/utils/env"
+import { getProviderSettingsManager } from "./provider-migration"
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Shape of the auth info cached in memory (NOT persisted to disk). */
+export interface ClineAuthInfo {
+	idToken: string
+	refreshToken?: string
+	expiresAt?: number // seconds since epoch
+	userInfo: ClineAccountUserInfo
+	provider: string
+	startedAt?: number
+}
+
+export interface ClineAccountUserInfo {
+	createdAt?: string
+	displayName: string
+	email: string
+	id: string
+	organizations: ClineAccountOrganization[]
+	appBaseUrl?: string
+	subject?: string
+}
+
+export interface ClineAccountOrganization {
+	active: boolean
+	memberId: string
+	name: string
+	organizationId: string
+	roles: string[]
+}
+
+/** Logout reason for telemetry */
+export enum LogoutReason {
+	USER_INITIATED = "user_initiated",
+	CROSS_WINDOW_SYNC = "cross_window_sync",
+	ERROR_RECOVERY = "error_recovery",
+	UNKNOWN = "unknown",
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const WORKOS_TOKEN_PREFIX = "workos:"
+
+// ---------------------------------------------------------------------------
+// providers.json helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Read Cline OAuth credentials from providers.json.
+ * Returns { accessToken, refreshToken, expiresAt, accountId } or null.
+ */
+function readClineCredentials(): {
+	accessToken: string
+	refreshToken?: string
+	expiresAt?: number // milliseconds since epoch (providers.json convention)
+	accountId?: string
+} | null {
+	try {
+		const manager = getProviderSettingsManager()
+		const settings = manager.getProviderSettings("cline")
+		if (!settings?.auth?.accessToken) {
+			sdkDebug("[SdkAuthService] readClineCredentials: no auth.accessToken found")
+			return null
+		}
+
+		// Strip workos: prefix if present (providers.json stores it with prefix)
+		let accessToken = settings.auth.accessToken
+		if (accessToken.toLowerCase().startsWith(WORKOS_TOKEN_PREFIX)) {
+			accessToken = accessToken.slice(WORKOS_TOKEN_PREFIX.length)
+		}
+
+		const result = {
+			accessToken,
+			refreshToken: settings.auth.refreshToken,
+			expiresAt: (settings.auth as { expiresAt?: number }).expiresAt,
+			accountId: settings.auth.accountId,
+		}
+		sdkDebug(
+			`[SdkAuthService] readClineCredentials: found credentials (accessHash=${hashSecret(result.accessToken)}, refreshHash=${hashSecret(result.refreshToken)}, expiresAt=${result.expiresAt})`,
+		)
+		return result
+	} catch (error) {
+		Logger.error("[SdkAuthService] Failed to read credentials from providers.json:", error)
+		return null
+	}
+}
+
+/**
+ * Write Cline OAuth credentials to providers.json.
+ */
+function writeClineCredentials(credentials: {
+	accessToken: string
+	refreshToken?: string
+	expiresAt?: number // milliseconds since epoch
+	accountId?: string
+}): void {
+	try {
+		const manager = getProviderSettingsManager()
+		const existing = manager.getProviderSettings("cline")
+
+		const auth = {
+			...(existing?.auth ?? {}),
+			accessToken: `${WORKOS_TOKEN_PREFIX}${credentials.accessToken}`,
+			refreshToken: credentials.refreshToken,
+			accountId: credentials.accountId,
+		} as Record<string, unknown>
+		if (credentials.expiresAt !== undefined) {
+			auth.expiresAt = credentials.expiresAt
+		}
+
+		manager.saveProviderSettings(
+			{
+				...(existing ?? { provider: "cline" }),
+				provider: "cline",
+				auth: auth as { accessToken?: string; refreshToken?: string; accountId?: string },
+			},
+			{ tokenSource: "oauth", setLastUsed: true },
+		)
+		sdkDebug(
+			`[SdkAuthService] writeClineCredentials: wrote (accessHash=${hashSecret(credentials.accessToken)}, refreshHash=${hashSecret(credentials.refreshToken)}, expiresAt=${credentials.expiresAt})`,
+		)
+	} catch (error) {
+		Logger.error("[SdkAuthService] Failed to write credentials to providers.json:", error)
+	}
+}
+
+/**
+ * Clear Cline OAuth credentials from providers.json.
+ */
+function clearClineCredentials(): void {
+	try {
+		const manager = getProviderSettingsManager()
+		const existing = manager.getProviderSettings("cline")
+		if (existing) {
+			sdkDebug("[SdkAuthService] clearClineCredentials: clearing auth from providers.json")
+			manager.saveProviderSettings(
+				{
+					...existing,
+					provider: "cline",
+					auth: undefined,
+				},
+				{ tokenSource: "manual" },
+			)
+		}
+	} catch (error) {
+		Logger.error("[SdkAuthService] Failed to clear credentials from providers.json:", error)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// AuthService
+// ---------------------------------------------------------------------------
+
+export class AuthService {
+	private static instance: AuthService | null = null
+
+	private _authenticated = false
+	private _clineAuthInfo: ClineAuthInfo | null = null
+	private _activeAuthStatusUpdateHandlers = new Set<StreamingResponseHandler<AuthState>>()
+	private _handlerToController = new Map<StreamingResponseHandler<AuthState>, Controller>()
+	private _refreshPromise: Promise<string | undefined> | null = null
+
+	private constructor() {}
+
+	/**
+	 * Gets the singleton instance of AuthService.
+	 * On first call with a controller, initializes BannerService.
+	 */
+	public static getInstance(controller?: Controller): AuthService {
+		if (!AuthService.instance) {
+			AuthService.instance = new AuthService()
+		}
+		// Initialize BannerService on first call with a controller
+		// (mirrors classic AuthService behavior)
+		if (controller) {
+			try {
+				BannerService.initialize(controller)
+			} catch {
+				// BannerService may already be initialized — that's fine
+			}
+		}
+		return AuthService.instance
+	}
+
+	set controller(_controller: Controller) {
+		// Kept for interface compatibility — not needed in SDK-backed version
+	}
+
+	// ---- SDK OAuth → ClineAuthInfo conversion ----
+
+	/**
+	 * Convert SDK OAuthCredentials to our ClineAuthInfo format.
+	 * Also fetches full user info from the Cline API.
+	 */
+	private async credentialsToAuthInfo(credentials: OAuthCredentials, provider: string): Promise<ClineAuthInfo> {
+		// Fetch full user info from the API using the access token
+		const userInfo = await this.fetchUserInfoFromApi(credentials.access)
+
+		return {
+			idToken: credentials.access,
+			refreshToken: credentials.refresh,
+			expiresAt: credentials.expires ? credentials.expires / 1000 : undefined, // SDK uses ms, we store seconds
+			userInfo: userInfo ?? {
+				id: credentials.accountId ?? "",
+				email: credentials.email ?? "",
+				displayName: "",
+				organizations: [],
+			},
+			provider,
+			startedAt: Date.now(),
+		}
+	}
+
+	/**
+	 * Fetch user info from the Cline API using an access token.
+	 */
+	private async fetchUserInfoFromApi(accessToken: string): Promise<ClineAccountUserInfo | null> {
+		try {
+			const apiBaseUrl = ClineEnv.config().apiBaseUrl
+			// Ensure the token has the workos: prefix for the API
+			const bearerToken = accessToken.toLowerCase().startsWith(WORKOS_TOKEN_PREFIX)
+				? accessToken
+				: `${WORKOS_TOKEN_PREFIX}${accessToken}`
+			sdkDebug(
+				`[SdkAuthService] fetchUserInfoFromApi: GET ${apiBaseUrl}/api/v1/users/me (tokenHash=${hashSecret(accessToken)})`,
+			)
+			const response = await axios.get(`${apiBaseUrl}/api/v1/users/me`, {
+				headers: {
+					Authorization: `Bearer ${bearerToken}`,
+					"Content-Type": "application/json",
+					...(await buildBasicClineHeaders()),
+				},
+				...getAxiosSettings(),
+			})
+			sdkDebug(`[SdkAuthService] fetchUserInfoFromApi: response status=${response.status}`)
+			return response.data?.data ?? null
+		} catch (error) {
+			Logger.error("[SdkAuthService] Failed to fetch user info from API:", error)
+			return null
+		}
+	}
+
+	private toOAuthCredentials(authInfo: ClineAuthInfo): OAuthCredentials {
+		return {
+			access: authInfo.idToken,
+			refresh: authInfo.refreshToken ?? "",
+			expires: authInfo.expiresAt ? authInfo.expiresAt * 1000 : 0,
+			accountId: authInfo.userInfo.id || undefined,
+			email: authInfo.userInfo.email || undefined,
+		}
+	}
+
+	private async resolveValidClineCredentials(
+		authInfo: ClineAuthInfo,
+		options?: { forceRefresh?: boolean },
+	): Promise<OAuthCredentials | null> {
+		if (options?.forceRefresh && !authInfo.refreshToken) {
+			return null
+		}
+
+		return getValidClineCredentials(
+			this.toOAuthCredentials(authInfo),
+			{ apiBaseUrl: ClineEnv.config().apiBaseUrl },
+			{ forceRefresh: options?.forceRefresh },
+		)
+	}
+
+	// ---- Public API (used by gRPC handlers) ----
+
+	/**
+	 * Returns the current authentication token with the `workos:` prefix.
+	 * Refreshes if necessary using the SDK's token management.
+	 */
+	async getAuthToken(): Promise<string | null> {
+		if (!this._clineAuthInfo?.idToken) {
+			return null
+		}
+
+		// Check if we need to refresh
+		const expiresAt = this._clineAuthInfo.expiresAt
+		if (expiresAt) {
+			const currentTime = Date.now() / 1000
+			const bufferSeconds = 5 * 60 // 5 minute buffer
+			if (currentTime + bufferSeconds >= expiresAt) {
+				// Token is expired or about to expire — try to refresh
+				const refreshed = await this.refreshAccessToken()
+				if (!refreshed) {
+					return null
+				}
+			}
+		}
+
+		// Verify the token is still valid (not past expiry)
+		if (expiresAt && Date.now() / 1000 >= expiresAt) {
+			return null
+		}
+
+		return `${WORKOS_TOKEN_PREFIX}${this._clineAuthInfo.idToken}`
+	}
+
+	/**
+	 * Refresh the access token using the SDK's shared Cline credential validator.
+	 * Persists refreshed credentials to providers.json when credentials change.
+	 */
+	private async refreshAccessToken(): Promise<boolean> {
+		if (this._refreshPromise) {
+			await this._refreshPromise
+			return this._clineAuthInfo?.idToken !== undefined
+		}
+
+		if (!this._clineAuthInfo?.refreshToken) {
+			sdkDebug("[SdkAuthService] refreshAccessToken: no refresh token available")
+			return false
+		}
+
+		sdkDebug(`[SdkAuthService] refreshAccessToken: starting (currentTokenHash=${hashSecret(this._clineAuthInfo.idToken)})`)
+		this._refreshPromise = (async () => {
+			try {
+				const currentInfo = this._clineAuthInfo
+				if (!currentInfo) {
+					return undefined
+				}
+				const newCredentials = await this.resolveValidClineCredentials(currentInfo, { forceRefresh: true })
+				if (!newCredentials) {
+					sdkDebug("[SdkAuthService] refreshAccessToken: refresh returned null — clearing credentials")
+					this._clineAuthInfo = null
+					this._authenticated = false
+					clearClineCredentials()
+					setImmediate(() => {
+						this.sendAuthStatusUpdate().catch(() => {})
+					})
+					return undefined
+				}
+
+				const credentialsChanged =
+					newCredentials.access !== currentInfo.idToken ||
+					newCredentials.refresh !== (currentInfo.refreshToken ?? "") ||
+					(newCredentials.expires ? newCredentials.expires / 1000 : undefined) !== currentInfo.expiresAt ||
+					(newCredentials.accountId ?? "") !== currentInfo.userInfo.id
+
+				const userInfo = credentialsChanged
+					? await this.fetchUserInfoFromApi(newCredentials.access)
+					: currentInfo.userInfo
+				this._clineAuthInfo = {
+					idToken: newCredentials.access,
+					refreshToken: newCredentials.refresh,
+					expiresAt: newCredentials.expires ? newCredentials.expires / 1000 : undefined,
+					userInfo: userInfo ?? currentInfo.userInfo,
+					provider: currentInfo.provider,
+					startedAt: currentInfo.startedAt ?? Date.now(),
+				}
+				this._authenticated = true
+
+				if (credentialsChanged) {
+					sdkDebug(
+						`[SdkAuthService] refreshAccessToken: credentials changed (newTokenHash=${hashSecret(newCredentials.access)})`,
+					)
+					writeClineCredentials({
+						accessToken: newCredentials.access,
+						refreshToken: newCredentials.refresh,
+						expiresAt: newCredentials.expires,
+						accountId: this._clineAuthInfo.userInfo.id,
+					})
+
+					setImmediate(() => {
+						this.sendAuthStatusUpdate().catch((err) => {
+							Logger.error("[SdkAuthService] Error sending auth status update after refresh:", err)
+						})
+					})
+				} else {
+					sdkDebug("[SdkAuthService] refreshAccessToken: credentials unchanged after refresh")
+				}
+
+				return this._clineAuthInfo.idToken
+			} catch (error) {
+				Logger.error("[SdkAuthService] Token refresh failed:", error)
+				return undefined
+			} finally {
+				this._refreshPromise = null
+			}
+		})()
+
+		const result = await this._refreshPromise
+		return result !== undefined
+	}
+
+	/**
+	 * Gets the active organization ID from the authenticated user's info.
+	 */
+	getActiveOrganizationId(): string | null {
+		if (!this._clineAuthInfo?.userInfo?.organizations) return null
+		const activeOrg = this._clineAuthInfo.userInfo.organizations.find((org) => org.active)
+		return activeOrg?.organizationId ?? null
+	}
+
+	/**
+	 * Gets all organizations from the authenticated user's info.
+	 */
+	getUserOrganizations(): ClineAccountOrganization[] | undefined {
+		return this._clineAuthInfo?.userInfo?.organizations
+	}
+
+	/**
+	 * Gets the provider name for the current authentication.
+	 */
+	getProviderName(): string | null {
+		return this._clineAuthInfo?.provider ?? null
+	}
+
+	/**
+	 * Returns the current auth state for the webview.
+	 */
+	getInfo(): AuthState {
+		if (this._clineAuthInfo && this._authenticated) {
+			const userInfo = this._clineAuthInfo.userInfo
+			userInfo.appBaseUrl = ClineEnv.config().appBaseUrl
+
+			const user = UserInfo.create({
+				uid: userInfo?.id,
+				displayName: userInfo?.displayName,
+				email: userInfo?.email,
+				photoUrl: undefined,
+				appBaseUrl: userInfo?.appBaseUrl,
+			})
+			return AuthState.create({ user })
+		}
+
+		return AuthState.create({})
+	}
+
+	// ---- Login flows ----
+
+	/**
+	 * Initiate Cline OAuth login.
+	 * Uses SDK's loginClineOAuth() which spawns a local callback server.
+	 * Persists credentials to providers.json.
+	 */
+	async createAuthRequest(strict = false): Promise<String> {
+		// In strict mode, don't open a new auth window if already authenticated
+		if (strict && this._authenticated) {
+			await this.sendAuthStatusUpdate()
+			const { String: ProtoString } = await import("@shared/proto/cline/common")
+			return ProtoString.create({ value: "Already authenticated" })
+		}
+
+		// E2E test mode: authenticate against the local mock API server instead
+		// of loginClineOAuth(), which opens a real browser window the tests can't
+		// interact with. Replaces classic AuthServiceMock (see origin/main
+		// src/services/auth/AuthServiceMock.ts).
+		if (process.env.E2E_TEST === "true") {
+			return this.createMockAuthRequest()
+		}
+
+		let resolveAuthMessage!: (message: string) => void
+		let rejectAuthMessage!: (error: unknown) => void
+		const authMessagePromise = new Promise<string>((resolve, reject) => {
+			resolveAuthMessage = resolve
+			rejectAuthMessage = reject
+		})
+
+		void (async () => {
+			try {
+				const apiBaseUrl = ClineEnv.config().apiBaseUrl
+				const credentials = await loginClineOAuth({
+					apiBaseUrl,
+					// Use WorkOS device auth so the browser confirmation code can be surfaced in the extension.
+					useWorkOSDeviceAuth: true,
+					headers: await buildBasicClineHeaders(),
+					callbacks: createOAuthClientCallbacks({
+						onOutput: (message) => {
+							resolveAuthMessage(message)
+						},
+						onPrompt: async (prompt) => prompt.defaultValue ?? "",
+						openUrl: async (url: string) => {
+							resolveAuthMessage(url)
+							await openExternal(url)
+						},
+						onOpenUrlError: ({ url, error }) => {
+							Logger.error(`[SdkAuthService] Failed to open browser for ${url}:`, error)
+						},
+					}),
+				})
+
+				// Convert and persist to providers.json
+				const authInfo = await this.credentialsToAuthInfo(credentials, "cline")
+				this._clineAuthInfo = authInfo
+				this._authenticated = true
+
+				writeClineCredentials({
+					accessToken: credentials.access,
+					refreshToken: credentials.refresh,
+					expiresAt: credentials.expires,
+					accountId: authInfo.userInfo.id || credentials.accountId,
+				})
+
+				// Push auth state update
+				await this.sendAuthStatusUpdate()
+
+				// Notify BannerService of auth change (mirrors classic AuthService)
+				BannerService.onAuthUpdate(authInfo.userInfo?.id || null).catch((error) => {
+					Logger.error("[SdkAuthService] Banner update failed after login", error)
+				})
+			} catch (error) {
+				rejectAuthMessage(error)
+				Logger.error("[SdkAuthService] Cline OAuth login failed:", error)
+			}
+		})()
+
+		const { String: ProtoString } = await import("@shared/proto/cline/common")
+		return ProtoString.create({ value: await authMessagePromise })
+	}
+
+	/**
+	 * E2E test login: exchange a well-known test code with the local mock API
+	 * server (src/test/e2e/fixtures/server) for tokens, with no browser
+	 * interaction. Replaces classic AuthServiceMock.createAuthRequest().
+	 */
+	private async createMockAuthRequest(): Promise<String> {
+		if (ClineEnv.config().environment !== "local") {
+			throw new Error("E2E mock auth is only available when CLINE_ENVIRONMENT=local")
+		}
+
+		const apiBaseUrl = ClineEnv.config().apiBaseUrl
+		const tokenUrl = new URL(CLINE_API_ENDPOINT.TOKEN_EXCHANGE, apiBaseUrl)
+		const response = await fetch(tokenUrl.toString(), {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...(await buildBasicClineHeaders()),
+			},
+			body: JSON.stringify({
+				code: "test-personal-token",
+				grantType: "authorization_code",
+			}),
+		})
+		if (!response.ok) {
+			throw new Error(`Mock server authentication failed: ${response.status} ${response.statusText}`)
+		}
+		const responseJSON = await response.json()
+		const tokenData = responseJSON?.data
+		if (!responseJSON?.success || !tokenData?.accessToken) {
+			throw new Error("Invalid response from mock server")
+		}
+
+		this._clineAuthInfo = {
+			idToken: tokenData.accessToken,
+			refreshToken: tokenData.refreshToken,
+			expiresAt: new Date(tokenData.expiresAt).getTime() / 1000,
+			userInfo: {
+				id: tokenData.userInfo?.clineUserId || tokenData.userInfo?.subject || "",
+				email: tokenData.userInfo?.email || "",
+				displayName: tokenData.userInfo?.name || "",
+				createdAt: new Date().toISOString(),
+				organizations: tokenData.userInfo?.organizations ?? [],
+				appBaseUrl: ClineEnv.config().appBaseUrl,
+				subject: tokenData.userInfo?.subject,
+			},
+			provider: "cline",
+			startedAt: Date.now(),
+		}
+		this._authenticated = true
+
+		// Persist to providers.json so session config resolution
+		// (resolveApiKey) and provider-usability checks see the credentials.
+		writeClineCredentials({
+			accessToken: tokenData.accessToken,
+			refreshToken: tokenData.refreshToken,
+			expiresAt: new Date(tokenData.expiresAt).getTime(),
+			accountId: this._clineAuthInfo.userInfo.id,
+		})
+
+		await this.sendAuthStatusUpdate()
+		Logger.log(`[SdkAuthService] E2E mock login completed as ${this._clineAuthInfo.userInfo.email}`)
+
+		const { String: ProtoString } = await import("@shared/proto/cline/common")
+		return ProtoString.create({ value: apiBaseUrl })
+	}
+
+	/**
+	 * Initiate OCA OAuth login.
+	 */
+	async ocaLogin(): Promise<String> {
+		try {
+			const callbacks = createOAuthClientCallbacks({
+				onPrompt: async (prompt) => prompt.defaultValue ?? "",
+				openUrl: async (url: string) => {
+					await openExternal(url)
+				},
+				onOpenUrlError: ({ url, error }) => {
+					Logger.error(`[SdkAuthService] Failed to open browser for OCA: ${url}:`, error)
+				},
+			})
+
+			const credentials = await loginOcaOAuth({ callbacks })
+
+			const authInfo = await this.credentialsToAuthInfo(credentials, "oca")
+			this._clineAuthInfo = authInfo
+			this._authenticated = true
+
+			writeClineCredentials({
+				accessToken: credentials.access,
+				refreshToken: credentials.refresh,
+				expiresAt: credentials.expires,
+				accountId: authInfo.userInfo.id || credentials.accountId,
+			})
+
+			await this.sendAuthStatusUpdate()
+
+			const { String: ProtoString } = await import("@shared/proto/cline/common")
+			return ProtoString.create({ value: "Authenticated" })
+		} catch (error) {
+			Logger.error("[SdkAuthService] OCA OAuth login failed:", error)
+			throw error
+		}
+	}
+
+	/**
+	 * Initiate OpenAI Codex OAuth login.
+	 */
+	async openAiCodexLogin(): Promise<void> {
+		try {
+			const callbacks = createOAuthClientCallbacks({
+				onPrompt: async (prompt) => prompt.defaultValue ?? "",
+				openUrl: async (url: string) => {
+					await openExternal(url)
+				},
+				onOpenUrlError: ({ url, error }) => {
+					Logger.error(`[SdkAuthService] Failed to open browser for Codex: ${url}:`, error)
+				},
+			})
+
+			const credentials = await loginOpenAICodex(callbacks)
+
+			// Store Codex credentials in providers.json
+			await this.saveCodexCredentials(credentials)
+			await openAiCodexOAuthManager.saveCredentials({
+				type: "openai-codex",
+				access_token: credentials.access,
+				refresh_token: credentials.refresh,
+				expires: credentials.expires,
+				email: credentials.email,
+				accountId: credentials.accountId,
+			})
+
+			// Notify webview of state change
+			await this.sendAuthStatusUpdate()
+		} catch (error) {
+			Logger.error("[SdkAuthService] OpenAI Codex OAuth login failed:", error)
+			throw error
+		}
+	}
+
+	/**
+	 * Save Codex OAuth credentials to provider settings.
+	 */
+	private async saveCodexCredentials(credentials: OAuthCredentials): Promise<void> {
+		try {
+			const manager = getProviderSettingsManager()
+			const existing = manager.getProviderSettings("openai-codex")
+
+			manager.saveProviderSettings(
+				{
+					...(existing ?? { provider: "openai-codex" }),
+					provider: "openai-codex",
+					auth: {
+						accessToken: credentials.access,
+						refreshToken: credentials.refresh,
+						accountId: credentials.accountId,
+					},
+				},
+				{ tokenSource: "oauth" },
+			)
+		} catch (error) {
+			Logger.error("[SdkAuthService] Failed to save Codex credentials:", error)
+		}
+	}
+
+	/**
+	 * Clear Codex credentials from provider settings.
+	 */
+	async clearCodexCredentials(): Promise<void> {
+		try {
+			await openAiCodexOAuthManager.clearCredentials()
+
+			const manager = getProviderSettingsManager()
+			const existing = manager.getProviderSettings("openai-codex")
+			if (existing) {
+				manager.saveProviderSettings(
+					{
+						...existing,
+						provider: "openai-codex",
+						auth: undefined,
+					},
+					{ tokenSource: "manual" },
+				)
+			}
+		} catch (error) {
+			Logger.error("[SdkAuthService] Failed to clear Codex credentials:", error)
+		}
+	}
+
+	// ---- Logout ----
+
+	/**
+	 * Handle deauthentication — clear tokens from providers.json and push unauthenticated state.
+	 */
+	async handleDeauth(_reason: LogoutReason = LogoutReason.UNKNOWN): Promise<void> {
+		try {
+			this._clineAuthInfo = null
+			this._authenticated = false
+			clearClineCredentials()
+			await this.sendAuthStatusUpdate()
+
+			// Notify BannerService of auth change (mirrors classic AuthService)
+			BannerService.onAuthUpdate(null).catch((error) => {
+				Logger.error("[SdkAuthService] Banner update failed after logout", error)
+			})
+		} catch (error) {
+			Logger.error("[SdkAuthService] Error signing out:", error)
+			throw error
+		}
+	}
+
+	/**
+	 * Handle auth callback from URI handler.
+	 * This is called when the browser redirects back to the extension after OAuth.
+	 */
+	async handleAuthCallback(authorizationCode: string, provider: string): Promise<void> {
+		try {
+			// Exchange the authorization code for tokens using the Cline API
+			const apiBaseUrl = ClineEnv.config().apiBaseUrl
+			const callbackUrl = await HostProvider.get().getCallbackUrl("/auth")
+
+			const tokenUrl = new URL(CLINE_API_ENDPOINT.TOKEN_EXCHANGE, apiBaseUrl)
+			const response = await fetch(tokenUrl.toString(), {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+					...(await buildBasicClineHeaders()),
+				},
+				body: JSON.stringify({
+					grant_type: "authorization_code",
+					code: authorizationCode,
+					client_type: "extension",
+					redirect_uri: callbackUrl,
+					provider: provider,
+				}),
+			})
+
+			if (!response.ok) {
+				const errorData = await response.json().catch(() => ({}))
+				throw new Error(errorData.error_description || "Failed to exchange authorization code for tokens")
+			}
+
+			const responseJSON = await response.json()
+			const tokenData = responseJSON.data
+
+			if (!tokenData.accessToken || !tokenData.refreshToken || !tokenData.userInfo) {
+				throw new Error("Invalid token response from server")
+			}
+
+			// Fetch full user info
+			const userInfo = await this.fetchUserInfoFromApi(tokenData.accessToken)
+
+			const authInfo: ClineAuthInfo = {
+				idToken: tokenData.accessToken,
+				refreshToken: tokenData.refreshToken,
+				userInfo: userInfo ?? {
+					id: tokenData.userInfo.clineUserId || "",
+					email: tokenData.userInfo.email || "",
+					displayName: tokenData.userInfo.name || "",
+					createdAt: new Date().toISOString(),
+					organizations: [],
+				},
+				expiresAt: new Date(tokenData.expiresAt).getTime() / 1000,
+				provider: "cline",
+				startedAt: Date.now(),
+			}
+
+			this._clineAuthInfo = authInfo
+			this._authenticated = true
+
+			// Persist to providers.json
+			writeClineCredentials({
+				accessToken: tokenData.accessToken,
+				refreshToken: tokenData.refreshToken,
+				expiresAt: new Date(tokenData.expiresAt).getTime(),
+				accountId: authInfo.userInfo.id,
+			})
+
+			await this.sendAuthStatusUpdate()
+		} catch (error) {
+			Logger.error("[SdkAuthService] Error handling auth callback:", error)
+			throw error
+		}
+	}
+
+	/**
+	 * Handle OCA auth callback.
+	 */
+	async handleOcaAuthCallback(_code: string, _state: string): Promise<void> {
+		// OCA uses SDK's local callback server, so this shouldn't normally be called.
+		// Keeping it as a stub for interface compatibility.
+		Logger.warn("[SdkAuthService] handleOcaAuthCallback called — OCA uses SDK callback server")
+	}
+
+	// ---- Restore auth on startup ----
+
+	/**
+	 * Restore authentication from providers.json on startup.
+	 *
+	 * Reads tokens from providers.json, refreshes if needed, then fetches
+	 * user profile from the API. This matches the CLI's pattern — credentials
+	 * live in providers.json, user info is fetched fresh each session.
+	 */
+	async restoreRefreshTokenAndRetrieveAuthInfo(): Promise<void> {
+		try {
+			const creds = readClineCredentials()
+			if (!creds) {
+				this._authenticated = false
+				this._clineAuthInfo = null
+				return
+			}
+
+			const restoredAuthInfo: ClineAuthInfo = {
+				idToken: creds.accessToken,
+				refreshToken: creds.refreshToken,
+				expiresAt: creds.expiresAt ? creds.expiresAt / 1000 : undefined, // providers.json uses ms, we use seconds
+				userInfo: {
+					id: creds.accountId ?? "",
+					email: "",
+					displayName: "",
+					organizations: [],
+				},
+				provider: "cline",
+			}
+
+			const validCredentials = await this.resolveValidClineCredentials(restoredAuthInfo)
+			if (!validCredentials) {
+				this._authenticated = false
+				this._clineAuthInfo = null
+				clearClineCredentials()
+				await this.sendAuthStatusUpdate()
+				return
+			}
+
+			writeClineCredentials({
+				accessToken: validCredentials.access,
+				refreshToken: validCredentials.refresh,
+				expiresAt: validCredentials.expires,
+				accountId: validCredentials.accountId ?? restoredAuthInfo.userInfo.id,
+			})
+
+			this._clineAuthInfo = {
+				idToken: validCredentials.access,
+				refreshToken: validCredentials.refresh,
+				expiresAt: validCredentials.expires ? validCredentials.expires / 1000 : undefined,
+				userInfo: {
+					...restoredAuthInfo.userInfo,
+					id: validCredentials.accountId ?? restoredAuthInfo.userInfo.id,
+					email: validCredentials.email ?? restoredAuthInfo.userInfo.email,
+				},
+				provider: restoredAuthInfo.provider,
+			}
+			this._authenticated = true
+
+			// Fetch full user info from the API (the key step — fills in
+			// email, displayName, organizations that providers.json doesn't store)
+			if (this._authenticated && this._clineAuthInfo) {
+				const userInfo = await this.fetchUserInfoFromApi(this._clineAuthInfo.idToken)
+				if (userInfo) {
+					this._clineAuthInfo.userInfo = userInfo
+				} else {
+					Logger.warn("[SdkAuthService] Could not fetch user info on restore — UI will show limited profile")
+				}
+			}
+
+			await this.sendAuthStatusUpdate()
+
+			// Notify BannerService of auth change (mirrors classic AuthService)
+			BannerService.onAuthUpdate(this._clineAuthInfo?.userInfo?.id || null).catch((error) => {
+				Logger.error("[SdkAuthService] Banner update failed after restore", error)
+			})
+		} catch (error) {
+			Logger.error("[SdkAuthService] Error restoring auth token:", error)
+			this._authenticated = false
+			this._clineAuthInfo = null
+		}
+	}
+
+	// ---- Streaming subscriptions ----
+
+	/**
+	 * Subscribe to authStatusUpdate events.
+	 * Pushes initial auth state immediately on subscribe.
+	 */
+	async subscribeToAuthStatusUpdate(
+		controller: Controller,
+		_request: EmptyRequest,
+		responseStream: StreamingResponseHandler<AuthState>,
+		requestId?: string,
+	): Promise<void> {
+		this._activeAuthStatusUpdateHandlers.add(responseStream)
+		this._handlerToController.set(responseStream, controller)
+
+		const cleanup = () => {
+			this._activeAuthStatusUpdateHandlers.delete(responseStream)
+			this._handlerToController.delete(responseStream)
+		}
+
+		if (requestId) {
+			getRequestRegistry().registerRequest(requestId, cleanup, { type: "authStatusUpdate_subscription" }, responseStream)
+		}
+
+		// Push initial auth state immediately (prevents race condition)
+		try {
+			await this.sendAuthStatusUpdate()
+		} catch (error) {
+			Logger.error("[SdkAuthService] Error sending initial auth status:", error)
+			this._activeAuthStatusUpdateHandlers.delete(responseStream)
+			this._handlerToController.delete(responseStream)
+		}
+	}
+
+	/**
+	 * Send an authStatusUpdate event to all active subscribers.
+	 */
+	async sendAuthStatusUpdate(): Promise<void> {
+		const authState: AuthState = this.getInfo()
+		const uniqueControllers = new Set<Controller>()
+
+		const streamSends = Array.from(this._activeAuthStatusUpdateHandlers).map(async (responseStream) => {
+			const controller = this._handlerToController.get(responseStream)
+			if (controller) {
+				uniqueControllers.add(controller)
+			}
+			try {
+				await responseStream(authState, false)
+			} catch (error) {
+				Logger.error("[SdkAuthService] Error sending authStatusUpdate event:", error)
+				this._activeAuthStatusUpdateHandlers.delete(responseStream)
+				this._handlerToController.delete(responseStream)
+			}
+		})
+
+		await Promise.all(streamSends)
+
+		// Poll feature flags immediately for the current auth context so cache-only
+		// consumers (for example BannerService) see the latest remote config.
+		const authInfo = this._clineAuthInfo
+		if (authInfo?.userInfo) {
+			await telemetryService.identifyAccount(authInfo.userInfo)
+		}
+		const userId = authInfo?.userInfo?.id || null
+		await featureFlagsService.poll(userId)
+		for (const controller of uniqueControllers) {
+			controller.invalidateProviderListings()
+		}
+
+		// Update state in webviews once per unique controller
+		await Promise.all(Array.from(uniqueControllers).map((c) => c.postStateToWebview()))
+	}
+
+	// ---- Provider-specific auth callbacks ----
+
+	/**
+	 * Shared helper: set a provider's API key and switch both plan/act modes to it.
+	 */
+	private setProviderApiKey(provider: ApiProvider, apiKeyField: string, apiKey: string): void {
+		const stateManager = StateManager.get()
+		const currentApiConfiguration = stateManager.getApiConfiguration()
+		const updatedConfig = {
+			...currentApiConfiguration,
+			planModeApiProvider: provider,
+			actModeApiProvider: provider,
+			[apiKeyField]: apiKey,
+		}
+		stateManager.setApiConfiguration(updatedConfig)
+	}
+
+	/**
+	 * Handle OpenRouter OAuth callback.
+	 */
+	async handleOpenRouterCallback(code: string): Promise<void> {
+		let apiKey: string
+		try {
+			const response = await fetch("https://openrouter.ai/api/v1/auth/keys", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ code }),
+			})
+			if (!response.ok) {
+				throw new Error(`OpenRouter API responded with status ${response.status}`)
+			}
+			const data = (await response.json()) as { key?: string }
+			if (data?.key) {
+				apiKey = data.key
+			} else {
+				throw new Error("Invalid response from OpenRouter API")
+			}
+		} catch (error) {
+			Logger.error("[SdkAuthService] Error exchanging code for API key:", error)
+			throw error
+		}
+
+		this.setProviderApiKey("openrouter", "openRouterApiKey", apiKey)
+	}
+
+	/**
+	 * Handle Requesty OAuth callback.
+	 */
+	async handleRequestyCallback(code: string): Promise<void> {
+		this.setProviderApiKey("requesty", "requestyApiKey", code)
+	}
+
+	/**
+	 * Handle Hicap OAuth callback.
+	 */
+	async handleHicapCallback(code: string): Promise<void> {
+		this.setProviderApiKey("hicap", "hicapApiKey", code)
+	}
+}
diff --git a/apps/vscode/src/sdk/bedrock-config.test.ts b/apps/vscode/src/sdk/bedrock-config.test.ts
new file mode 100644
index 0000000..d0c4148
--- /dev/null
+++ b/apps/vscode/src/sdk/bedrock-config.test.ts
@@ -0,0 +1,181 @@
+import type { ApiConfiguration } from "@shared/api"
+import { describe, expect, it } from "vitest"
+import { buildBedrockProviderConfig, buildBedrockProviderSettings, resolveBedrockAuthentication } from "./bedrock-config"
+
+describe("resolveBedrockAuthentication", () => {
+	it("maps the webview 'apikey' radio value straight through", () => {
+		expect(resolveBedrockAuthentication({ awsAuthentication: "apikey" })).toBe("apikey")
+	})
+
+	it("maps the webview 'credentials' radio value to the SDK 'iam' spelling", () => {
+		expect(resolveBedrockAuthentication({ awsAuthentication: "credentials" })).toBe("iam")
+	})
+
+	it("passes 'profile' through", () => {
+		expect(resolveBedrockAuthentication({ awsAuthentication: "profile" })).toBe("profile")
+	})
+
+	it("defaults to 'profile' when an AWS profile is configured but no auth is set", () => {
+		expect(resolveBedrockAuthentication({ awsProfile: "dev" })).toBe("profile")
+		expect(resolveBedrockAuthentication({ awsUseProfile: true })).toBe("profile")
+	})
+
+	it("defaults to 'iam' (default credential chain) when nothing is set", () => {
+		expect(resolveBedrockAuthentication({})).toBe("iam")
+	})
+})
+
+describe("buildBedrockProviderConfig", () => {
+	it("forwards the region and api-key authentication for a pasted Bedrock API key", () => {
+		// Reproduces the reported bug: API key radio + pasted key. The key itself
+		// is carried separately as the top-level ProviderConfig.apiKey; here we
+		// assert the region + auth mode that were previously dropped.
+		const config: ApiConfiguration = {
+			awsAuthentication: "apikey",
+			awsRegion: "us-east-1",
+			awsBedrockApiKey: "bedrock-bearer-token",
+		}
+
+		const result = buildBedrockProviderConfig(config, "act")
+
+		expect(result.region).toBe("us-east-1")
+		expect(result.aws?.authentication).toBe("apikey")
+		// No SigV4 credentials when authenticating with a bearer API key.
+		expect(result.aws?.accessKey).toBeUndefined()
+		expect(result.aws?.secretKey).toBeUndefined()
+		expect(result.aws?.profile).toBeUndefined()
+	})
+
+	it("forwards static IAM credentials", () => {
+		const config: ApiConfiguration = {
+			awsAuthentication: "credentials",
+			awsRegion: "us-west-2",
+			awsAccessKey: "AKIA...",
+			awsSecretKey: "secret",
+			awsSessionToken: "token",
+		}
+
+		const result = buildBedrockProviderConfig(config, "act")
+
+		expect(result.region).toBe("us-west-2")
+		expect(result.aws?.authentication).toBe("iam")
+		expect(result.aws?.accessKey).toBe("AKIA...")
+		expect(result.aws?.secretKey).toBe("secret")
+		expect(result.aws?.sessionToken).toBe("token")
+	})
+
+	it("forwards the profile only when authenticating via profile", () => {
+		const profileResult = buildBedrockProviderConfig(
+			{ awsAuthentication: "profile", awsProfile: "dev-profile", awsRegion: "us-east-2" },
+			"act",
+		)
+		expect(profileResult.aws?.authentication).toBe("profile")
+		expect(profileResult.aws?.profile).toBe("dev-profile")
+
+		// A stale profile string must not leak through when auth is api-key.
+		const apiKeyResult = buildBedrockProviderConfig(
+			{ awsAuthentication: "apikey", awsProfile: "dev-profile", awsRegion: "us-east-2" },
+			"act",
+		)
+		expect(apiKeyResult.aws?.authentication).toBe("apikey")
+		expect(apiKeyResult.aws?.profile).toBeUndefined()
+	})
+
+	it("selects the mode-specific custom model base id", () => {
+		const config: ApiConfiguration = {
+			awsAuthentication: "apikey",
+			awsRegion: "us-east-1",
+			planModeAwsBedrockCustomModelBaseId: "plan-base",
+			actModeAwsBedrockCustomModelBaseId: "act-base",
+		}
+
+		expect(buildBedrockProviderConfig(config, "plan").aws?.customModelBaseId).toBe("plan-base")
+		expect(buildBedrockProviderConfig(config, "act").aws?.customModelBaseId).toBe("act-base")
+	})
+
+	it("forwards cross-region and global inference flags", () => {
+		const result = buildBedrockProviderConfig(
+			{
+				awsAuthentication: "apikey",
+				awsRegion: "us-east-1",
+				awsUseCrossRegionInference: true,
+				awsUseGlobalInference: true,
+			},
+			"act",
+		)
+		expect(result.useCrossRegionInference).toBe(true)
+		expect(result.useGlobalInference).toBe(true)
+	})
+
+	it("trims whitespace-only region to undefined", () => {
+		const result = buildBedrockProviderConfig({ awsAuthentication: "apikey", awsRegion: "   " }, "act")
+		expect(result.region).toBeUndefined()
+	})
+})
+
+describe("buildBedrockProviderSettings (providers.json persistence)", () => {
+	it("produces SDK ProviderSettings authoritative for the gateway (region + apikey)", () => {
+		// This is the fix for the second bug: core builds the gateway config from
+		// the providers.json `stored` entry, so the region + auth must be written
+		// there (top-level region AND aws.region) to override a stale entry.
+		const settings = buildBedrockProviderSettings(
+			{
+				awsAuthentication: "apikey",
+				awsRegion: "us-east-2",
+				awsBedrockApiKey: "bedrock-bearer-token",
+			},
+			"us.anthropic.claude-haiku-4-5-20251001-v1:0",
+			"act",
+		)
+
+		expect(settings.provider).toBe("bedrock")
+		expect(settings.model).toBe("us.anthropic.claude-haiku-4-5-20251001-v1:0")
+		expect(settings.apiKey).toBe("bedrock-bearer-token")
+		// Region must be present BOTH top-level and on aws (toProviderConfig reads
+		// `settings.region ?? settings.aws?.region`).
+		expect(settings.region).toBe("us-east-2")
+		expect(settings.aws?.region).toBe("us-east-2")
+		expect(settings.aws?.authentication).toBe("apikey")
+		// No stale SigV4 credentials for api-key auth.
+		expect(settings.aws?.accessKey).toBeUndefined()
+		expect(settings.aws?.secretKey).toBeUndefined()
+	})
+
+	it("omits apiKey/region when not configured", () => {
+		const settings = buildBedrockProviderSettings({ awsAuthentication: "profile", awsProfile: "dev" }, "model-x", "act")
+		expect(settings.apiKey).toBeUndefined()
+		expect(settings.region).toBeUndefined()
+		expect(settings.aws?.authentication).toBe("profile")
+		expect(settings.aws?.profile).toBe("dev")
+	})
+
+	it("does NOT persist a bearer apiKey for profile auth (keeps stored clean)", () => {
+		// A stale awsBedrockApiKey must not leak into providers.json when the user
+		// switched to profile auth — the SDK ignores it for SigV4, but persisting
+		// it is confusing/leaky.
+		const settings = buildBedrockProviderSettings(
+			{
+				awsAuthentication: "profile",
+				awsProfile: "default",
+				awsRegion: "us-east-1",
+				awsBedrockApiKey: "stale-bearer-token",
+			},
+			"us.anthropic.claude-haiku-4-5-20251001-v1:0",
+			"act",
+		)
+		expect(settings.apiKey).toBeUndefined()
+		expect(settings.aws?.authentication).toBe("profile")
+		expect(settings.aws?.profile).toBe("default")
+		expect(settings.aws?.region).toBe("us-east-1")
+	})
+
+	it("does NOT persist a bearer apiKey for iam/credentials auth", () => {
+		const settings = buildBedrockProviderSettings(
+			{ awsAuthentication: "credentials", awsRegion: "us-east-1", awsBedrockApiKey: "stale-bearer-token" },
+			"model-x",
+			"act",
+		)
+		expect(settings.apiKey).toBeUndefined()
+		expect(settings.aws?.authentication).toBe("iam")
+	})
+})
diff --git a/apps/vscode/src/sdk/bedrock-config.ts b/apps/vscode/src/sdk/bedrock-config.ts
new file mode 100644
index 0000000..ec84a48
--- /dev/null
+++ b/apps/vscode/src/sdk/bedrock-config.ts
@@ -0,0 +1,128 @@
+// Maps the extension's legacy Bedrock ApiConfiguration onto the SDK's
+// structured AWS provider options (region + aws block).
+//
+// Both inference paths need this:
+//   - buildSdkProviderConfig() in sdk-api-handler.ts (standalone utility calls)
+//   - buildSessionConfig() in cline-session-factory.ts (main task loop, which
+//     hands a CoreSessionConfig.providerConfig to ClineCore)
+//
+// Without it, the SDK gateway never receives the AWS region or authentication
+// mode, so a pasted Bedrock API key (awsBedrockApiKey + awsAuthentication
+// "apikey") is silently ignored and requests fall through to the SigV4
+// credential chain with no region. This mirrors the structured aws block built
+// by the shared provider-settings legacy migration and the CLI.
+
+import type { ProviderSettings } from "@cline/core"
+import type { ProviderConfig } from "@cline/llms"
+import type { ApiConfiguration } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+
+type AwsConfig = NonNullable<ProviderConfig["aws"]>
+type AwsAuthentication = NonNullable<AwsConfig["authentication"]>
+
+/** The Bedrock-specific subset of an SDK ProviderConfig. */
+export type BedrockProviderConfig = Pick<ProviderConfig, "region" | "aws" | "useCrossRegionInference" | "useGlobalInference">
+
+function trimToUndefined(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined
+	}
+	const trimmed = value.trim()
+	return trimmed.length > 0 ? trimmed : undefined
+}
+
+/**
+ * Map the webview's `awsAuthentication` radio value onto the SDK's
+ * `AwsConfig.authentication` spelling.
+ *
+ * The Bedrock settings UI stores `"apikey"`, `"profile"`, or `"credentials"`.
+ * The SDK understands `"apikey"`/`"api-key"`, `"profile"`, and `"iam"`. The
+ * webview's `"credentials"` option means "use the default AWS credential
+ * chain", which is `"iam"` in SDK terms. When unset, fall back to the same
+ * heuristic the UI uses for its default radio selection (profile when an AWS
+ * profile is configured, otherwise the default credential chain).
+ */
+export function resolveBedrockAuthentication(configuration: ApiConfiguration): AwsAuthentication {
+	const explicit = configuration.awsAuthentication
+	if (explicit === "apikey" || explicit === "api-key" || explicit === "profile" || explicit === "iam") {
+		return explicit
+	}
+	if (explicit === "credentials") {
+		return "iam"
+	}
+	// No explicit selection: mirror the webview's default radio resolution.
+	if (configuration.awsUseProfile || trimToUndefined(configuration.awsProfile)) {
+		return "profile"
+	}
+	return "iam"
+}
+
+/**
+ * Build the Bedrock `region` + `aws` portion of the SDK ProviderConfig from the
+ * extension's ApiConfiguration for the given mode (plan/act).
+ */
+export function buildBedrockProviderConfig(configuration: ApiConfiguration, mode: Mode): BedrockProviderConfig {
+	const authentication = resolveBedrockAuthentication(configuration)
+	const usesProfile = authentication === "profile"
+	const aws: AwsConfig = {
+		accessKey: trimToUndefined(configuration.awsAccessKey),
+		secretKey: trimToUndefined(configuration.awsSecretKey),
+		sessionToken: trimToUndefined(configuration.awsSessionToken),
+		authentication,
+		profile: usesProfile ? trimToUndefined(configuration.awsProfile) : undefined,
+		usePromptCache: configuration.awsBedrockUsePromptCache,
+		endpoint: trimToUndefined(configuration.awsBedrockEndpoint),
+		customModelBaseId: trimToUndefined(
+			mode === "plan"
+				? configuration.planModeAwsBedrockCustomModelBaseId
+				: configuration.actModeAwsBedrockCustomModelBaseId,
+		),
+	}
+	return {
+		region: trimToUndefined(configuration.awsRegion),
+		aws,
+		useCrossRegionInference: configuration.awsUseCrossRegionInference,
+		useGlobalInference: configuration.awsUseGlobalInference,
+	}
+}
+
+/**
+ * Build the full SDK `ProviderSettings` for Bedrock from the extension's
+ * ApiConfiguration, suitable for persisting to providers.json via
+ * `ProviderSettingsManager.saveProviderSettings`.
+ *
+ * WHY THIS EXISTS (the second Bedrock bug):
+ * The main chat path runs through core's `buildProviderConfig`
+ * (local-runtime-bootstrap.ts), which builds the gateway-registered
+ * ProviderSettings as `{ ...stored, provider, model, apiKey, baseUrl, ... }`.
+ * The `aws` block and `region` come ONLY from `stored` (providers.json) — the
+ * session's `providerConfig` is consulted by a different code path and does NOT
+ * override the gateway registration. So a stale providers.json Bedrock entry
+ * (e.g. a legacy migration with region "us-east-1" + SigV4 keys) silently wins:
+ * requests go to the wrong region and 403, even though StateManager has the
+ * correct region + apikey auth.
+ *
+ * Writing the StateManager-derived settings back to providers.json makes
+ * `stored` authoritative and correct, so the gateway is configured with the
+ * region/auth the user actually selected.
+ */
+export function buildBedrockProviderSettings(configuration: ApiConfiguration, modelId: string, mode: Mode): ProviderSettings {
+	const { region, aws, useCrossRegionInference, useGlobalInference } = buildBedrockProviderConfig(configuration, mode)
+	// Only persist the bearer apiKey when actually authenticating with api-key.
+	// Otherwise (profile/iam) a stale key could linger in providers.json; the SDK
+	// ignores it for SigV4 auth, but we keep `stored` clean and unambiguous.
+	const usesApiKeyAuth = aws?.authentication === "apikey" || aws?.authentication === "api-key"
+	const apiKey = usesApiKeyAuth ? trimToUndefined(configuration.awsBedrockApiKey) : undefined
+	return {
+		provider: "bedrock",
+		model: modelId,
+		...(apiKey ? { apiKey } : {}),
+		...(region ? { region } : {}),
+		aws: {
+			...aws,
+			...(region ? { region } : {}),
+			...(useCrossRegionInference !== undefined ? { useCrossRegionInference } : {}),
+			...(useGlobalInference !== undefined ? { useGlobalInference } : {}),
+		},
+	}
+}
diff --git a/apps/vscode/src/sdk/cline-session-factory.test.ts b/apps/vscode/src/sdk/cline-session-factory.test.ts
new file mode 100644
index 0000000..6c0047a
--- /dev/null
+++ b/apps/vscode/src/sdk/cline-session-factory.test.ts
@@ -0,0 +1,877 @@
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import type { CoreSessionConfig } from "@cline/core"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import {
+	buildResumeSessionInput,
+	buildSessionConfig,
+	buildStartSessionInput,
+	createHistoryItemFromSession,
+	getDefaultModelIdForProvider,
+	getHistoryItemById,
+	normalizeProviderReasoningSettings,
+	normalizeSdkBaseUrl,
+	resolveApiKey,
+	updateHistoryItem,
+} from "./cline-session-factory"
+
+const mocks = vi.hoisted(() => {
+	const providerSettingsManager = {
+		getLastUsedProviderSettings: vi.fn(() => undefined),
+		getProviderSettings: vi.fn((_providerId?: string) => undefined),
+		saveProviderSettings: vi.fn(),
+	}
+
+	return {
+		getDistinctId: vi.fn(() => "test-distinct-id"),
+		getProviderSettingsManager: vi.fn(() => providerSettingsManager),
+		providerSettingsManager,
+		stateManager: {
+			getApiConfiguration: vi.fn(() => ({
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-sonnet-4-6",
+				apiKey: "test-key",
+			})),
+			getGlobalSettingsKey: vi.fn((key: string): boolean | undefined => {
+				if (key === "subagentsEnabled" || key === "useAutoCondense") {
+					return false
+				}
+				return undefined
+			}),
+		},
+	}
+})
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: {
+		get: () => mocks.stateManager,
+	},
+}))
+
+vi.mock("@/services/logging/distinctId", () => ({
+	getDistinctId: mocks.getDistinctId,
+}))
+
+vi.mock("./provider-migration", () => ({
+	getProviderSettingsManager: mocks.getProviderSettingsManager,
+}))
+
+vi.mock("@shared/services/Logger", () => ({
+	Logger: {
+		debug: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+	},
+}))
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+let tempDir: string
+const previousGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH
+
+beforeEach(() => {
+	tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cline-session-factory-"))
+	process.env.CLINE_GLOBAL_SETTINGS_PATH = path.join(tempDir, "global-settings.json")
+	vi.clearAllMocks()
+	mocks.stateManager.getApiConfiguration.mockReturnValue({
+		actModeApiProvider: "anthropic",
+		actModeApiModelId: "claude-sonnet-4-6",
+		apiKey: "test-key",
+	})
+	mocks.stateManager.getGlobalSettingsKey.mockImplementation((key: string) => {
+		if (key === "subagentsEnabled" || key === "useAutoCondense") {
+			return false
+		}
+		return undefined
+	})
+	mocks.providerSettingsManager.getLastUsedProviderSettings.mockReturnValue(undefined)
+	mocks.providerSettingsManager.getProviderSettings.mockReturnValue(undefined)
+})
+
+afterEach(() => {
+	process.env.CLINE_GLOBAL_SETTINGS_PATH = previousGlobalSettingsPath
+	fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+function writeJson(filePath: string, data: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true })
+	fs.writeFileSync(filePath, JSON.stringify(data, null, 2))
+}
+
+function makeBaseConfig(overrides: Partial<CoreSessionConfig> = {}): CoreSessionConfig {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		apiKey: "test-key",
+		cwd: "/tmp/workspace",
+		workspaceRoot: "/tmp/workspace",
+		systemPrompt: "",
+		mode: "act",
+		enableTools: true,
+		enableSpawnAgent: false,
+		enableAgentTeams: false,
+		...overrides,
+	}
+}
+
+// ---------------------------------------------------------------------------
+// provider/model defaults
+// ---------------------------------------------------------------------------
+
+describe("getDefaultModelIdForProvider", () => {
+	it("uses the SDK provider catalog for the Cline default model", () => {
+		expect(getDefaultModelIdForProvider("cline")).toBe("anthropic/claude-sonnet-4.6")
+	})
+
+	it("falls back to the first generated model when the SDK manifest default is not in the model catalog", () => {
+		expect(getDefaultModelIdForProvider("gemini")).toBe("gemini-3.5-flash")
+	})
+
+	it("returns undefined for unknown providers", () => {
+		expect(getDefaultModelIdForProvider("unknown-provider")).toBeUndefined()
+	})
+
+	it("resolves the OpenAI Compatible default through the extension's openai alias", () => {
+		// The extension stores the OpenAI Compatible provider as "openai" while
+		// the SDK catalog keys it as "openai-compatible". toSdkProviderId bridges
+		// the two so the catalog default-model lookup resolves.
+		expect(getDefaultModelIdForProvider("openai")).toBe("gpt-4o")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// buildStartSessionInput
+// ---------------------------------------------------------------------------
+
+describe("buildStartSessionInput", () => {
+	it("does not forward the prompt to start()", () => {
+		const config = makeBaseConfig()
+		const input = {
+			prompt: "Hello, world!",
+			cwd: "/tmp/workspace",
+		}
+
+		const result = buildStartSessionInput(config, input)
+
+		expect(result.config).toBe(config)
+		expect(result.prompt).toBeUndefined()
+		expect(result.interactive).toBe(true)
+		expect(result.userImages).toBeUndefined()
+		expect(result.userFiles).toBeUndefined()
+	})
+
+	it("includes images and files when provided", () => {
+		const config = makeBaseConfig()
+		const input = {
+			prompt: "Look at this",
+			images: ["image1.png", "image2.jpg"],
+			files: ["file1.ts"],
+			cwd: "/tmp/workspace",
+		}
+
+		const result = buildStartSessionInput(config, input)
+
+		expect(result.userImages).toEqual(["image1.png", "image2.jpg"])
+		expect(result.userFiles).toEqual(["file1.ts"])
+	})
+
+	it("always sets interactive to true", () => {
+		const config = makeBaseConfig()
+		const input = { cwd: "/tmp/workspace" }
+
+		const result = buildStartSessionInput(config, input)
+
+		expect(result.interactive).toBe(true)
+	})
+
+	it("handles undefined prompt", () => {
+		const config = makeBaseConfig()
+		const input = { cwd: "/tmp/workspace" }
+
+		const result = buildStartSessionInput(config, input)
+
+		expect(result.prompt).toBeUndefined()
+	})
+})
+
+// ---------------------------------------------------------------------------
+// buildResumeSessionInput
+// ---------------------------------------------------------------------------
+
+describe("buildResumeSessionInput", () => {
+	it("builds resume input with session ID and prompt", () => {
+		const result = buildResumeSessionInput("session-123", "Continue the task")
+
+		expect(result.sessionId).toBe("session-123")
+		expect(result.prompt).toBe("Continue the task")
+		expect(result.userImages).toBeUndefined()
+		expect(result.userFiles).toBeUndefined()
+	})
+
+	it("includes images and files when provided", () => {
+		const result = buildResumeSessionInput("session-123", "Look at this", ["img.png"], ["file.ts"])
+
+		expect(result.userImages).toEqual(["img.png"])
+		expect(result.userFiles).toEqual(["file.ts"])
+	})
+})
+
+// ---------------------------------------------------------------------------
+// normalizeSdkBaseUrl
+// ---------------------------------------------------------------------------
+
+describe("normalizeSdkBaseUrl", () => {
+	it("treats blank base URLs as unset so SDK provider defaults can apply", () => {
+		expect(normalizeSdkBaseUrl("openai-compatible", "")).toBeUndefined()
+		expect(normalizeSdkBaseUrl("openai-compatible", "   ")).toBeUndefined()
+	})
+
+	it("uses provider catalog defaults to add the SDK endpoint path when the user supplies only an origin", () => {
+		expect(normalizeSdkBaseUrl("ollama", "http://localhost:11434")).toBe("http://localhost:11434/v1")
+		expect(normalizeSdkBaseUrl("ollama", "http://localhost:11434/")).toBe("http://localhost:11434/v1")
+		expect(normalizeSdkBaseUrl("ollama", "http://localhost:11434/v1")).toBe("http://localhost:11434/v1")
+	})
+
+	it("preserves explicit user paths", () => {
+		expect(normalizeSdkBaseUrl("openai", " https://example.com/custom ")).toBe("https://example.com/custom")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// normalizeProviderReasoningSettings
+// ---------------------------------------------------------------------------
+
+describe("normalizeProviderReasoningSettings", () => {
+	it("does not emit reasoningEffort when thinking is disabled", () => {
+		const result = normalizeProviderReasoningSettings({ enabled: false, effort: "medium" })
+
+		expect(result).toEqual({ thinking: false })
+	})
+
+	it("treats effort none as disabled thinking", () => {
+		const result = normalizeProviderReasoningSettings({ effort: "none" })
+
+		expect(result).toEqual({ thinking: false })
+	})
+
+	it("passes enabled reasoning with a concrete effort", () => {
+		const result = normalizeProviderReasoningSettings({ enabled: true, effort: "high" })
+
+		expect(result).toEqual({ thinking: true, reasoningEffort: "high" })
+	})
+
+	it("leaves explicit effort-only settings enabled by SDK/provider defaults", () => {
+		const result = normalizeProviderReasoningSettings({ effort: "medium" })
+
+		expect(result).toEqual({ reasoningEffort: "medium" })
+	})
+})
+
+// ---------------------------------------------------------------------------
+// buildSessionConfig
+// ---------------------------------------------------------------------------
+
+describe("buildSessionConfig", () => {
+	it("resolves Cline OAuth credentials after defaulting to the Cline provider", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({} as any)
+		mocks.providerSettingsManager.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			auth: {
+				accessToken: "workos:test-access-token",
+				refreshToken: "test-refresh-token",
+			},
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("cline")
+		expect(config.apiKey).toBe("workos:test-access-token")
+	})
+
+	it("resolves ClinePass from the shared Cline OAuth credentials", async () => {
+		mocks.providerSettingsManager.getProviderSettings.mockImplementation((providerId?: string) => {
+			if (providerId !== "cline") {
+				return undefined
+			}
+			return {
+				provider: "cline",
+				auth: {
+					accessToken: "workos:shared-cline-token",
+					refreshToken: "shared-refresh-token",
+				},
+			} as any
+		})
+
+		const apiKey = resolveApiKey("cline-pass", {
+			actModeApiProvider: "cline-pass",
+		} as any)
+
+		expect(apiKey).toBe("workos:shared-cline-token")
+		expect(mocks.providerSettingsManager.getProviderSettings).toHaveBeenCalledWith("cline")
+	})
+
+	it("preserves explicit ClinePass API keys from state before OAuth storage", () => {
+		mocks.providerSettingsManager.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			auth: { accessToken: "workos:stored-token" },
+		} as any)
+
+		expect(resolveApiKey("cline-pass", { clineApiKey: "workos:configured-token" } as any)).toBe("workos:configured-token")
+		expect(mocks.providerSettingsManager.getProviderSettings).not.toHaveBeenCalled()
+	})
+
+	it("preserves explicit Cline API keys from state before OAuth storage", () => {
+		mocks.providerSettingsManager.getProviderSettings.mockReturnValue({
+			provider: "cline",
+			auth: { accessToken: "workos:stored-token" },
+		} as any)
+
+		expect(resolveApiKey("cline", { clineApiKey: "workos:configured-cline-token" } as any)).toBe(
+			"workos:configured-cline-token",
+		)
+		expect(mocks.providerSettingsManager.getProviderSettings).not.toHaveBeenCalled()
+	})
+
+	it("resolves OpenAI Compatible API keys from migrated SDK provider settings", () => {
+		mocks.providerSettingsManager.getProviderSettings.mockImplementation((providerId?: string) => {
+			if (providerId !== "openai-compatible") {
+				return undefined
+			}
+			return {
+				provider: "openai-compatible",
+				apiKey: "migrated-openai-compatible-key",
+			} as any
+		})
+
+		expect(resolveApiKey("openai", {} as any)).toBe("migrated-openai-compatible-key")
+		expect(mocks.providerSettingsManager.getProviderSettings).toHaveBeenCalledWith("openai-compatible")
+	})
+
+	it("resolves OpenAI Codex through the shared OAuth provider registry", async () => {
+		mocks.providerSettingsManager.getProviderSettings.mockReturnValue({
+			provider: "openai-codex",
+			auth: {
+				accessToken: "codex-oauth-token",
+				refreshToken: "codex-refresh-token",
+			},
+		} as any)
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "openai-codex",
+			actModeApiModelId: "gpt-5.4",
+			openAiNativeApiKey: "openai-api-key-should-not-be-used",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("openai-codex")
+		expect(config.modelId).toBe("gpt-5.4")
+		expect(config.apiKey).toBe("codex-oauth-token")
+		expect(config.providerConfig).toMatchObject({
+			providerId: "openai-codex",
+			modelId: "gpt-5.4",
+			apiKey: "codex-oauth-token",
+		})
+	})
+
+	it("resolves SDK-backed provider API keys from provider-specific settings", async () => {
+		const providers = [
+			{ providerId: "poolside", modelId: "poolside/laguna-m.1" },
+			{ providerId: "v0", modelId: "v0-1.5-md" },
+			{ providerId: "xiaomi", modelId: "mimo-v2.5" },
+			{ providerId: "zai-coding-plan", modelId: "glm-5.2" },
+		] as const
+
+		for (const { providerId, modelId } of providers) {
+			mocks.providerSettingsManager.getProviderSettings.mockImplementation((requestedProviderId?: string) => {
+				if (requestedProviderId !== providerId) {
+					return undefined
+				}
+				return {
+					provider: providerId,
+					apiKey: `${providerId}-key`,
+				} as any
+			})
+			mocks.stateManager.getApiConfiguration.mockReturnValue({
+				actModeApiProvider: providerId,
+				actModeApiModelId: modelId,
+			} as any)
+
+			const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+			expect(config.providerId).toBe(providerId)
+			expect(config.modelId).toBe(modelId)
+			expect(config.apiKey).toBe(`${providerId}-key`)
+			expect(config.providerConfig).toMatchObject({
+				providerId,
+				modelId,
+				apiKey: `${providerId}-key`,
+			})
+		}
+	})
+
+	it("does not treat OpenAI Codex as OpenAI Native API-key auth", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "openai-codex",
+			actModeApiModelId: "gpt-5.4",
+			openAiNativeApiKey: "openai-api-key-should-not-be-used",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("openai-codex")
+		expect(config.modelId).toBe("gpt-5.4")
+		expect(config.apiKey).toBe("")
+		expect(config.providerConfig).toMatchObject({ providerId: "openai-codex", modelId: "gpt-5.4" })
+		expect(config.providerConfig).not.toHaveProperty("apiKey")
+	})
+
+	it("passes OpenAI Compatible max output tokens as an explicit request limit", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "openai",
+			actModeOpenAiModelId: "custom-reasoner",
+			openAiApiKey: "openai-compatible-key",
+			openAiBaseUrl: "https://openai-compatible.example/v1",
+			actModeOpenAiModelInfo: {
+				name: "Custom Reasoner",
+				contextWindow: 16_000,
+				maxTokens: 4_096,
+				supportsImages: false,
+				supportsPromptCache: false,
+				inputPrice: 0,
+				outputPrice: 0,
+			},
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("openai-compatible")
+		expect(config.modelId).toBe("custom-reasoner")
+		expect(config.knownModels).toBeUndefined()
+		expect((config.providerConfig as any).knownModels).toBeUndefined()
+		expect((config.providerConfig as any).maxOutputTokens).toBeUndefined()
+		expect((config as any).maxTokensPerTurn).toBe(4_096)
+	})
+
+	it("passes OCA reasoning effort from legacy mode settings to SDK sessions", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "oca",
+			actModeOcaModelId: "oca-reasoner",
+			ocaApiKey: "oca-key",
+			actModeOcaReasoningEffort: " HIGH ",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("oca")
+		expect(config.modelId).toBe("oca-reasoner")
+		expect(config.thinking).toBe(true)
+		expect(config.reasoningEffort).toBe("high")
+	})
+
+	it("lets legacy OCA none override stale provider reasoning settings", async () => {
+		mocks.providerSettingsManager.getProviderSettings.mockReturnValue({
+			provider: "oca",
+			reasoning: { enabled: true, effort: "medium" },
+		} as any)
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "oca",
+			actModeOcaModelId: "oca-reasoner",
+			ocaApiKey: "oca-key",
+			actModeOcaReasoningEffort: "none",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.thinking).toBe(false)
+		expect(config.reasoningEffort).toBeUndefined()
+	})
+
+	it("builds structured SAP AI Core config from legacy ApiConfiguration fields", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "sapaicore",
+			actModeApiModelId: "anthropic--claude-4.6-sonnet",
+			sapAiCoreClientId: "sap-client",
+			sapAiCoreClientSecret: "sap-secret",
+			sapAiCoreBaseUrl: " https://api.ai.example.aws.ml.hana.ondemand.com ",
+			sapAiCoreTokenUrl: " https://example.authentication.sap.hana.ondemand.com ",
+			sapAiResourceGroup: " default ",
+			sapAiCoreUseOrchestrationMode: false,
+			actModeSapAiCoreDeploymentId: " deployment-id ",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("sapaicore")
+		expect(config.modelId).toBe("anthropic--claude-4.6-sonnet")
+		expect(config.apiKey).toBe("")
+		expect(config.baseUrl).toBe("https://api.ai.example.aws.ml.hana.ondemand.com")
+		expect(config.providerConfig).toMatchObject({
+			providerId: "sapaicore",
+			modelId: "anthropic--claude-4.6-sonnet",
+			baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			sap: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://example.authentication.sap.hana.ondemand.com",
+				resourceGroup: "default",
+				deploymentId: "deployment-id",
+				useOrchestrationMode: false,
+			},
+		})
+		expect(config.providerConfig).not.toHaveProperty("apiKey")
+	})
+
+	it("defaults SAP AI Core to orchestration mode and omits deployment id when mode is unset", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "sapaicore",
+			actModeApiModelId: "anthropic--claude-4.6-sonnet",
+			sapAiCoreClientId: "sap-client",
+			sapAiCoreClientSecret: "sap-secret",
+			sapAiCoreBaseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			sapAiCoreTokenUrl: "https://example.authentication.sap.hana.ondemand.com",
+			sapAiResourceGroup: "default",
+			actModeSapAiCoreDeploymentId: "foundation-deployment-id",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerConfig).toMatchObject({
+			providerId: "sapaicore",
+			sap: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://example.authentication.sap.hana.ondemand.com",
+				resourceGroup: "default",
+				useOrchestrationMode: true,
+			},
+		})
+		expect((config.providerConfig as any).sap).not.toHaveProperty("deploymentId")
+	})
+
+	it("omits SAP AI Core deployment id when orchestration mode is enabled", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "sapaicore",
+			actModeApiModelId: "anthropic--claude-4.6-sonnet",
+			sapAiCoreClientId: "sap-client",
+			sapAiCoreClientSecret: "sap-secret",
+			sapAiCoreBaseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			sapAiCoreTokenUrl: "https://example.authentication.sap.hana.ondemand.com",
+			sapAiResourceGroup: "default",
+			sapAiCoreUseOrchestrationMode: true,
+			actModeSapAiCoreDeploymentId: "foundation-deployment-id",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect((config.providerConfig as any).sap).toMatchObject({
+			resourceGroup: "default",
+			useOrchestrationMode: true,
+		})
+		expect((config.providerConfig as any).sap).not.toHaveProperty("deploymentId")
+	})
+
+	it("falls back to legacy SAP-specific model fields when the generic model field is absent", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "sapaicore",
+			actModeSapAiCoreModelId: "anthropic--claude-3.5-sonnet",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("sapaicore")
+		expect(config.modelId).toBe("anthropic--claude-3.5-sonnet")
+	})
+
+	it("preserves an explicitly cleared SAP base URL so stored settings cannot fill it back in", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "sapaicore",
+			actModeApiModelId: "anthropic--claude-4.6-sonnet",
+			sapAiCoreBaseUrl: "   ",
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.baseUrl).toBe("")
+		expect(config.providerConfig).toMatchObject({
+			providerId: "sapaicore",
+			baseUrl: "",
+		})
+		expect(config.providerConfig).not.toHaveProperty("sap")
+	})
+
+	it("does not emit partial SAP overrides when SAP strings are absent", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "sapaicore",
+			actModeApiModelId: "anthropic--claude-4.6-sonnet",
+			sapAiCoreUseOrchestrationMode: false,
+		} as any)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerConfig).toMatchObject({
+			providerId: "sapaicore",
+		})
+		expect(config.providerConfig).not.toHaveProperty("baseUrl")
+		expect(config.providerConfig).not.toHaveProperty("sap")
+	})
+
+	it("uses ClinePass model storage and omits empty nested apiKey so SDK OAuth can fill it", async () => {
+		mocks.stateManager.getApiConfiguration.mockReturnValue({
+			actModeApiProvider: "cline-pass",
+			actModeClinePassModelId: "cline-pass/glm-5.2",
+		} as any)
+		mocks.providerSettingsManager.getProviderSettings.mockReturnValue(undefined)
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.providerId).toBe("cline-pass")
+		expect(config.modelId).toBe("cline-pass/glm-5.2")
+		expect(config.apiKey).toBe("")
+		expect(config.providerConfig).toMatchObject({ providerId: "cline-pass", modelId: "cline-pass/glm-5.2" })
+		expect(config.providerConfig).not.toHaveProperty("apiKey")
+	})
+
+	it("enables basic SDK compaction when global useAutoCondense is true", async () => {
+		mocks.stateManager.getGlobalSettingsKey.mockImplementation((key: string) => {
+			if (key === "useAutoCondense") {
+				return true
+			}
+			if (key === "subagentsEnabled") {
+				return false
+			}
+			return undefined
+		})
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.compaction).toEqual({
+			enabled: true,
+			strategy: "basic",
+		})
+	})
+
+	it("uses the configured SDK compaction strategy when auto condense is enabled", async () => {
+		writeJson(process.env.CLINE_GLOBAL_SETTINGS_PATH!, { compactionStrategy: "agentic" })
+		mocks.stateManager.getGlobalSettingsKey.mockImplementation((key: string) => {
+			if (key === "useAutoCondense") {
+				return true
+			}
+			if (key === "subagentsEnabled") {
+				return false
+			}
+			return undefined
+		})
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.compaction).toEqual({
+			enabled: true,
+			strategy: "agentic",
+		})
+	})
+
+	it("falls back to basic SDK compaction for an invalid stored strategy", async () => {
+		writeJson(process.env.CLINE_GLOBAL_SETTINGS_PATH!, { compactionStrategy: "invalid" })
+		mocks.stateManager.getGlobalSettingsKey.mockImplementation((key: string) => {
+			if (key === "useAutoCondense") {
+				return true
+			}
+			if (key === "subagentsEnabled") {
+				return false
+			}
+			return undefined
+		})
+
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.compaction).toEqual({
+			enabled: true,
+			strategy: "basic",
+		})
+	})
+
+	it("does not enable SDK compaction when global useAutoCondense is false", async () => {
+		const config = await buildSessionConfig({ cwd: "/tmp/workspace" })
+
+		expect(config.compaction).toBeUndefined()
+	})
+
+	it("lets task useAutoCondense override the global setting", async () => {
+		let globalUseAutoCondense = true
+		mocks.stateManager.getGlobalSettingsKey.mockImplementation((key: string) => {
+			if (key === "useAutoCondense") {
+				return globalUseAutoCondense
+			}
+			if (key === "subagentsEnabled") {
+				return false
+			}
+			return undefined
+		})
+
+		// Task `false` overrides global `true`.
+		const disabledConfig = await buildSessionConfig({
+			cwd: "/tmp/workspace",
+			taskSettings: { useAutoCondense: false },
+		})
+
+		// Task `true` overrides global `false`.
+		globalUseAutoCondense = false
+		const enabledConfig = await buildSessionConfig({
+			cwd: "/tmp/workspace",
+			taskSettings: { useAutoCondense: true },
+		})
+
+		expect(disabledConfig.compaction).toBeUndefined()
+		expect(enabledConfig.compaction).toEqual({
+			enabled: true,
+			strategy: "basic",
+		})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// createHistoryItemFromSession
+// ---------------------------------------------------------------------------
+
+describe("createHistoryItemFromSession", () => {
+	it("creates a HistoryItem from session data", () => {
+		const item = createHistoryItemFromSession(
+			"session-abc",
+			"Fix the bug in main.ts",
+			"claude-sonnet-4-6",
+			"/home/user/project",
+		)
+
+		expect(item.id).toBe("session-abc")
+		expect(item.task).toBe("Fix the bug in main.ts")
+		expect(item.modelId).toBe("claude-sonnet-4-6")
+		expect(item.cwdOnTaskInitialization).toBe("/home/user/project")
+		expect(item.tokensIn).toBe(0)
+		expect(item.tokensOut).toBe(0)
+		expect(item.totalCost).toBe(0)
+		expect(item.ts).toBeGreaterThan(0)
+	})
+
+	it("handles missing optional fields", () => {
+		const item = createHistoryItemFromSession("session-xyz", "Simple task")
+
+		expect(item.modelId).toBeUndefined()
+		expect(item.cwdOnTaskInitialization).toBeUndefined()
+	})
+
+	it("creates unique timestamps for different calls", () => {
+		const item1 = createHistoryItemFromSession("s1", "Task 1")
+		const item2 = createHistoryItemFromSession("s2", "Task 2")
+
+		// Timestamps should be at least as large (may be same if called in same ms)
+		expect(item2.ts).toBeGreaterThanOrEqual(item1.ts)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// getHistoryItemById
+// ---------------------------------------------------------------------------
+
+describe("getHistoryItemById", () => {
+	it("returns undefined when task is not found", () => {
+		const result = getHistoryItemById("nonexistent", tempDir)
+		expect(result).toBeUndefined()
+	})
+
+	it("finds a task by ID", () => {
+		const history = [
+			{ id: "task-1", ts: Date.now(), task: "First task", tokensIn: 0, tokensOut: 0, totalCost: 0 },
+			{ id: "task-2", ts: Date.now(), task: "Second task", tokensIn: 0, tokensOut: 0, totalCost: 0 },
+		]
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), history)
+
+		const result = getHistoryItemById("task-2", tempDir)
+		expect(result).toBeDefined()
+		expect(result?.id).toBe("task-2")
+		expect(result?.task).toBe("Second task")
+	})
+
+	it("returns undefined for empty history", () => {
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), [])
+
+		const result = getHistoryItemById("task-1", tempDir)
+		expect(result).toBeUndefined()
+	})
+})
+
+// ---------------------------------------------------------------------------
+// updateHistoryItem
+// ---------------------------------------------------------------------------
+
+describe("updateHistoryItem", () => {
+	it("adds a new item to history", () => {
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), [])
+
+		const newItem: import("@shared/HistoryItem").HistoryItem = {
+			id: "task-new",
+			ts: Date.now(),
+			task: "New task",
+			tokensIn: 100,
+			tokensOut: 50,
+			totalCost: 0.01,
+		}
+
+		const result = updateHistoryItem(newItem, tempDir)
+		expect(result).toHaveLength(1)
+		expect(result[0].id).toBe("task-new")
+	})
+
+	it("updates an existing item in history", () => {
+		const existingItem = {
+			id: "task-1",
+			ts: Date.now(),
+			task: "Original task",
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+		}
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), [existingItem])
+
+		const updatedItem = {
+			...existingItem,
+			tokensIn: 500,
+			tokensOut: 250,
+			totalCost: 0.05,
+		}
+
+		const result = updateHistoryItem(updatedItem, tempDir)
+		expect(result).toHaveLength(1)
+		expect(result[0].tokensIn).toBe(500)
+		expect(result[0].totalCost).toBe(0.05)
+	})
+
+	it("prepends new items to the beginning of history", () => {
+		const existingItem = {
+			id: "task-old",
+			ts: Date.now() - 1000,
+			task: "Old task",
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+		}
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), [existingItem])
+
+		const newItem = {
+			id: "task-new",
+			ts: Date.now(),
+			task: "New task",
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+		}
+
+		const result = updateHistoryItem(newItem, tempDir)
+		expect(result).toHaveLength(2)
+		expect(result[0].id).toBe("task-new")
+		expect(result[1].id).toBe("task-old")
+	})
+})
diff --git a/apps/vscode/src/sdk/cline-session-factory.ts b/apps/vscode/src/sdk/cline-session-factory.ts
new file mode 100644
index 0000000..dad4b5e
--- /dev/null
+++ b/apps/vscode/src/sdk/cline-session-factory.ts
@@ -0,0 +1,855 @@
+// Replaces classic task creation from src/core/task/index.ts (see origin/main)
+//
+// Creates and manages SDK sessions using ClineCore. This factory handles:
+// - Creating ClineCore instances with proper configuration
+// - Building session config from legacy state (provider, model, API key)
+// - Custom session persistence adapter reading ~/.cline/data/tasks/
+// - Mapping HistoryItem ↔ SDK session fields
+//
+// The factory does NOT handle UI concerns — that's the SdkController's job.
+
+import {
+	type ClineCoreStartInput,
+	type CoreSessionConfig,
+	getProviderAuthHandler,
+	type ProviderSettings,
+	readCompactionStrategyGlobally,
+	resolveProviderApiKeyFromSettings,
+	type StartSessionResult,
+} from "@cline/core"
+import { getGeneratedModelsForProvider, MODEL_COLLECTIONS_BY_PROVIDER_ID } from "@cline/llms"
+import { buildClineSystemPrompt } from "@cline/shared"
+import type { ApiConfiguration } from "@shared/api"
+import { ClineClient } from "@shared/cline"
+import type { HistoryItem } from "@shared/HistoryItem"
+import { DEFAULT_LANGUAGE_SETTINGS, getLanguageKey, type LanguageDisplay } from "@shared/Languages"
+import { Logger } from "@shared/services/Logger"
+import type { Settings } from "@shared/storage/state-keys"
+import type { Mode } from "@shared/storage/types"
+import { stringifyVsCodeLmModelSelector } from "@shared/vsCodeSelectorUtils"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostProvider } from "@/hosts/host-provider"
+import { ExtensionRegistryInfo } from "@/registry"
+import { getFeatureFlagsService } from "@/services/feature-flags"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { fetch } from "@/shared/net"
+import { FeatureFlag } from "@/shared/services/feature-flags/feature-flags"
+import { type BedrockProviderConfig, buildBedrockProviderConfig } from "./bedrock-config"
+import { buildAgentHooks } from "./hooks-adapter"
+import { readTaskHistory, resolveDataDir } from "./legacy-state-reader"
+import { toSdkProviderId } from "./model-catalog/sdk-provider-id"
+import { getProviderSettingsManager } from "./provider-migration"
+import { buildSapProviderConfig, type SapProviderConfig } from "./sap-config"
+import type { SdkSessionHost } from "./session-host"
+
+// ---------------------------------------------------------------------------
+// Plan mode instructions
+// ---------------------------------------------------------------------------
+
+/**
+ * Instructions appended to the system prompt when the session is in plan mode.
+ * Mirrors the CLI's plan-mode guardrails in apps/cli/src/runtime/prompt.ts so
+ * plan mode in VSCode has the same explicit "explore/analyze/plan, do not
+ * implement" guidance.
+ */
+const PLAN_MODE_INSTRUCTIONS = `# Plan Mode
+
+You are in Plan mode. Your role is to explore, analyze, and plan -- not to execute.
+
+- Read files, search the codebase, and gather context to understand the problem
+- Ask clarifying questions when requirements are ambiguous
+- Present your plan as a structured outline with clear steps
+- Explain tradeoffs between different approaches when they exist
+- Do NOT edit files, write code, run destructive commands, or make any changes
+- Do NOT implement anything -- focus on understanding and alignment first
+
+Once the user has reviewed your plan and explicitly approved it in a follow-up message, use the switch_to_act_mode tool to switch to act mode and begin implementation. Calling switch_to_act_mode immediately starts execution, so never call it in the same turn you present a plan and never treat the original task request as approval -- end your turn after presenting the plan and wait for the user's response.`
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Configuration for creating a new session */
+export interface SessionConfigInput {
+	/** The user's prompt */
+	prompt?: string
+	/** Images attached to the message */
+	images?: string[]
+	/** Files attached to the message */
+	files?: string[]
+	/** History item to resume (for task resumption) */
+	historyItem?: HistoryItem
+	/** Task-specific settings overrides */
+	taskSettings?: Partial<Settings>
+	/** Working directory */
+	cwd: string
+	/** Workspace root */
+	workspaceRoot?: string
+	/** Current mode (act/plan) */
+	mode?: Mode
+}
+
+/** Active session state tracked by the factory */
+export interface ActiveSession {
+	/** The session ID */
+	sessionId: string
+	/** The config used to start the active session. */
+	startConfig?: Pick<CoreSessionConfig, "providerId" | "modelId">
+	/** The runtime host instance managing this session (VscodeSessionHost) */
+	sdkHost: SdkSessionHost
+	/** Unsubscribe function for session events */
+	unsubscribe: () => void
+	/** The start result from the session */
+	startResult?: StartSessionResult
+	/** Whether the session is currently running */
+	isRunning: boolean
+}
+
+function createSdkLogger() {
+	return {
+		debug: (message: string, metadata?: Record<string, unknown>) => {
+			Logger.debug(message, metadata)
+		},
+		log: (message: string, metadata?: Record<string, unknown>) => {
+			Logger.log(message, metadata)
+		},
+		error: (message: string, metadata?: Record<string, unknown>) => {
+			Logger.error(message, metadata)
+		},
+	}
+}
+
+/**
+ * Host identity for the session's client context, resolved through HostProvider
+ * rather than the `vscode` module directly: this file is also bundled into the
+ * standalone cline-core (JetBrains), where `vscode` is a Proxy-stub module and
+ * direct API reads would yield non-string values. The hostbridge returns the
+ * per-host values (e.g. "Cline for JetBrains" + IDE version on JetBrains).
+ */
+async function resolveHostIdentity() {
+	try {
+		return await HostProvider.env.getHostVersion({})
+	} catch (error) {
+		Logger.debug("Failed to resolve host version for client identity", error)
+		return undefined
+	}
+}
+
+async function resolveIsMultiRootWorkspace(): Promise<boolean> {
+	try {
+		const { paths } = await HostProvider.workspace.getWorkspacePaths({})
+		return paths.length > 1
+	} catch {
+		return false
+	}
+}
+
+function resolveWorkspaceName(workspacePath: string): string {
+	const trimmed = workspacePath.trim()
+	const withoutTrailingSeparators = trimmed.replace(/[\\/]+$/, "")
+	const name = withoutTrailingSeparators.split(/[\\/]/).filter(Boolean).pop()?.trim()
+	return name || "workspace"
+}
+
+type ReasoningEffort = NonNullable<CoreSessionConfig["reasoningEffort"]>
+type ProviderReasoningSettings = NonNullable<ProviderSettings["reasoning"]>
+type SessionReasoningConfig = Pick<CoreSessionConfig, "thinking" | "reasoningEffort">
+
+function isReasoningEffort(value: unknown): value is ReasoningEffort {
+	return value === "low" || value === "medium" || value === "high" || value === "xhigh"
+}
+
+function hasStaleDisabledReasoningFields(reasoning: ProviderReasoningSettings | undefined): boolean {
+	return reasoning?.enabled === false && (reasoning.effort !== undefined || reasoning.budgetTokens !== undefined)
+}
+
+function providerSettingsProviderId(providerId: string): string {
+	return toSdkProviderId(providerId)
+}
+
+/**
+ * Convert SDK provider-level reasoning settings into the SDK session fields that
+ * are actually forwarded as model options. Keep `thinking` and
+ * `reasoningEffort` coherent: a disabled/none state must never carry an effort.
+ */
+export function normalizeProviderReasoningSettings(reasoning: ProviderReasoningSettings | undefined): SessionReasoningConfig {
+	if (!reasoning) {
+		return {}
+	}
+
+	if (reasoning.enabled === false || reasoning.effort === "none") {
+		return { thinking: false }
+	}
+
+	if (reasoning.enabled === true) {
+		return {
+			thinking: true,
+			...(isReasoningEffort(reasoning.effort) ? { reasoningEffort: reasoning.effort } : {}),
+		}
+	}
+
+	return isReasoningEffort(reasoning.effort) ? { reasoningEffort: reasoning.effort } : {}
+}
+
+function resolveProviderReasoningConfig(providerId: string): SessionReasoningConfig {
+	try {
+		const manager = getProviderSettingsManager(resolveDataDir())
+		const settings = manager.getProviderSettings(providerSettingsProviderId(providerId))
+		if (!settings) {
+			return {}
+		}
+
+		if (hasStaleDisabledReasoningFields(settings.reasoning)) {
+			const sanitizedSettings: ProviderSettings = {
+				...settings,
+				reasoning: { enabled: false },
+			}
+			manager.saveProviderSettings(sanitizedSettings, { setLastUsed: false })
+			Logger.warn(`[SessionFactory] Cleared stale disabled reasoning fields for provider=${providerId}`)
+			return normalizeProviderReasoningSettings(sanitizedSettings.reasoning)
+		}
+
+		return normalizeProviderReasoningSettings(settings.reasoning)
+	} catch (error) {
+		Logger.warn("[SessionFactory] Provider reasoning resolution failed:", error)
+		return {}
+	}
+}
+
+function resolveOcaReasoningConfig(mode: Mode, apiConfig: ApiConfiguration | undefined): SessionReasoningConfig | undefined {
+	const rawEffort = mode === "plan" ? apiConfig?.planModeOcaReasoningEffort : apiConfig?.actModeOcaReasoningEffort
+	const effort = rawEffort?.trim().toLowerCase()
+	if (!effort) {
+		return undefined
+	}
+
+	if (effort === "none") {
+		return { thinking: false }
+	}
+
+	return isReasoningEffort(effort) ? { thinking: true, reasoningEffort: effort } : undefined
+}
+
+function resolveOpenAiCompatibleMaxTokens(config: ApiConfiguration | undefined, mode: Mode): number | undefined {
+	const modelInfo = mode === "plan" ? config?.planModeOpenAiModelInfo : config?.actModeOpenAiModelInfo
+	const maxTokens = modelInfo?.maxTokens
+	return typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0 ? maxTokens : undefined
+}
+
+// ---------------------------------------------------------------------------
+// Provider → API key field mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Maps a provider ID to the corresponding API key field name in ApiConfiguration.
+ * This covers all 30+ providers supported by the classic extension.
+ */
+const PROVIDER_API_KEY_MAP: Record<string, keyof ApiConfiguration> = {
+	anthropic: "apiKey",
+	openrouter: "openRouterApiKey",
+	openai: "openAiApiKey",
+	"openai-native": "openAiNativeApiKey",
+	bedrock: "awsBedrockApiKey",
+	vertex: "geminiApiKey",
+	gemini: "geminiApiKey",
+	deepseek: "deepSeekApiKey",
+	cline: "clineApiKey",
+	"cline-pass": "clineApiKey",
+	ollama: "ollamaApiKey",
+	lmstudio: "apiKey", // LM Studio doesn't need a key but uses the generic field
+	requesty: "requestyApiKey",
+	together: "togetherApiKey",
+	fireworks: "fireworksApiKey",
+	qwen: "qwenApiKey",
+	doubao: "doubaoApiKey",
+	mistral: "mistralApiKey",
+	litellm: "liteLlmApiKey",
+	asksage: "asksageApiKey",
+	xai: "xaiApiKey",
+	moonshot: "moonshotApiKey",
+	zai: "zaiApiKey",
+	huggingface: "huggingFaceApiKey",
+	nebius: "nebiusApiKey",
+	sambanova: "sambanovaApiKey",
+	cerebras: "cerebrasApiKey",
+	groq: "groqApiKey",
+	baseten: "basetenApiKey",
+	"huawei-cloud-maas": "huaweiCloudMaasApiKey",
+	dify: "difyApiKey",
+	minimax: "minimaxApiKey",
+	hicap: "hicapApiKey",
+	aihubmix: "aihubmixApiKey",
+	nousResearch: "nousResearchApiKey",
+	"vercel-ai-gateway": "vercelAiGatewayApiKey",
+	claude_code: "apiKey", // Claude Code uses anthropic key
+	wandb: "wandbApiKey",
+	"qwen-code": "qwenApiKey",
+	oca: "ocaApiKey",
+}
+
+/**
+ * Maps a provider ID to the mode-specific model ID field name in ApiConfiguration.
+ * For providers that have dedicated model ID fields per mode.
+ */
+const PROVIDER_MODEL_ID_MAP: Record<string, { plan: keyof ApiConfiguration; act: keyof ApiConfiguration }> = {
+	anthropic: { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	openrouter: { plan: "planModeOpenRouterModelId", act: "actModeOpenRouterModelId" },
+	openai: { plan: "planModeOpenAiModelId", act: "actModeOpenAiModelId" },
+	"openai-native": { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	"openai-codex": { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	ollama: { plan: "planModeOllamaModelId", act: "actModeOllamaModelId" },
+	lmstudio: { plan: "planModeLmStudioModelId", act: "actModeLmStudioModelId" },
+	gemini: { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	bedrock: { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	vertex: { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	deepseek: { plan: "planModeApiModelId", act: "actModeApiModelId" },
+	cline: { plan: "planModeClineModelId", act: "actModeClineModelId" },
+	"cline-pass": { plan: "planModeClinePassModelId", act: "actModeClinePassModelId" },
+	litellm: { plan: "planModeLiteLlmModelId", act: "actModeLiteLlmModelId" },
+	requesty: { plan: "planModeRequestyModelId", act: "actModeRequestyModelId" },
+	together: { plan: "planModeTogetherModelId", act: "actModeTogetherModelId" },
+	fireworks: { plan: "planModeFireworksModelId", act: "actModeFireworksModelId" },
+	groq: { plan: "planModeGroqModelId", act: "actModeGroqModelId" },
+	baseten: { plan: "planModeBasetenModelId", act: "actModeBasetenModelId" },
+	huggingface: { plan: "planModeHuggingFaceModelId", act: "actModeHuggingFaceModelId" },
+	"huawei-cloud-maas": { plan: "planModeHuaweiCloudMaasModelId", act: "actModeHuaweiCloudMaasModelId" },
+	oca: { plan: "planModeOcaModelId", act: "actModeOcaModelId" },
+	aihubmix: { plan: "planModeAihubmixModelId", act: "actModeAihubmixModelId" },
+	hicap: { plan: "planModeHicapModelId", act: "actModeHicapModelId" },
+	nousResearch: { plan: "planModeNousResearchModelId", act: "actModeNousResearchModelId" },
+	"vercel-ai-gateway": { plan: "planModeVercelAiGatewayModelId", act: "actModeVercelAiGatewayModelId" },
+}
+
+// ---------------------------------------------------------------------------
+// Provider/model defaults
+// ---------------------------------------------------------------------------
+
+const DEFAULT_PROVIDER_ID = "cline"
+
+export function getDefaultModelIdForProvider(providerId: string): string | undefined {
+	const sdkProviderId = toSdkProviderId(providerId)
+	const collection = MODEL_COLLECTIONS_BY_PROVIDER_ID[sdkProviderId]
+	if (!collection) {
+		return undefined
+	}
+
+	const generatedModels = getGeneratedModelsForProvider(sdkProviderId)
+	const defaultModelId = collection.provider.defaultModelId?.trim()
+	if (defaultModelId && (generatedModels[defaultModelId] || collection.models?.[defaultModelId])) {
+		return defaultModelId
+	}
+
+	return Object.keys(generatedModels)[0] || Object.keys(collection.models ?? {})[0] || undefined
+}
+
+// ---------------------------------------------------------------------------
+// API key resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the API key for a given provider from the ApiConfiguration.
+ *
+ * For SDK-managed OAuth providers, reads the OAuth token from providers.json
+ * via ProviderSettingsManager (the single source of truth for credentials).
+ */
+export function resolveApiKey(providerId: string, config: ApiConfiguration): string | undefined {
+	const authHandler = getProviderAuthHandler(providerId)
+	if (authHandler) {
+		const keyField = PROVIDER_API_KEY_MAP[providerId]
+		const configuredApiKey = keyField ? (config[keyField] as string | undefined)?.trim() : undefined
+		if (configuredApiKey) {
+			return configuredApiKey
+		}
+
+		// Read from providers.json via the shared ProviderSettingsManager. This is
+		// intentionally keyed by the requested provider so SDK auth metadata can
+		// resolve shared storage (e.g. cline-pass -> cline) without VS Code
+		// hardcoding provider exceptions.
+		try {
+			const manager = getProviderSettingsManager()
+			const apiKey = resolveProviderApiKeyFromSettings(manager, providerSettingsProviderId(providerId))?.trim()
+			if (apiKey) {
+				return apiKey
+			}
+		} catch {
+			Logger.warn(`[SessionFactory] Failed to read ${providerId} credentials from providers.json`)
+		}
+
+		return undefined
+	}
+
+	// For all other providers, look up the API key field name
+	const keyField = PROVIDER_API_KEY_MAP[providerId]
+	if (keyField) {
+		const apiKey = config[keyField] as string | undefined
+		if (apiKey) {
+			return apiKey
+		}
+	}
+
+	// SDK-backed API-key providers save credentials in providers.json instead
+	// of legacy ApiConfiguration fields. Fall back to that store so providers
+	// exposed through the SDK settings UI still receive credentials at task
+	// startup.
+	try {
+		const manager = getProviderSettingsManager()
+		const apiKey = resolveProviderApiKeyFromSettings(manager, providerSettingsProviderId(providerId))?.trim()
+		if (apiKey) {
+			return apiKey
+		}
+	} catch {
+		Logger.warn(`[SessionFactory] Failed to read ${providerId} API key from providers.json`)
+	}
+
+	return undefined
+}
+
+/**
+ * Resolve the model ID for a given provider and mode from the ApiConfiguration.
+ * Uses mode-specific model ID fields when available, falls back to generic fields.
+ */
+export function resolveModelId(providerId: string, mode: Mode, config: ApiConfiguration): string | undefined {
+	// VS Code LM has no plain model-id field: the selected model is stored as a
+	// structured LanguageModelChatSelector ({vendor, family, ...}) in
+	// plan/actModeVsCodeLmModelSelector. The SDK ProviderConfig only carries a
+	// string modelId, so we stringify the selector to "vendor/family[/version/id]"
+	// and the VS Code LM handler parses it back. See sdk/vscode-lm/vscode-lm-handler.ts.
+	if (providerId === "vscode-lm") {
+		const selector = mode === "plan" ? config.planModeVsCodeLmModelSelector : config.actModeVsCodeLmModelSelector
+		return selector ? stringifyVsCodeLmModelSelector(selector) || undefined : undefined
+	}
+
+	if (providerId === "sapaicore") {
+		const genericField = mode === "plan" ? "planModeApiModelId" : "actModeApiModelId"
+		const legacyField = mode === "plan" ? "planModeSapAiCoreModelId" : "actModeSapAiCoreModelId"
+		return (
+			(config[genericField] as string | undefined)?.trim() ||
+			(config[legacyField] as string | undefined)?.trim() ||
+			undefined
+		)
+	}
+
+	// Check provider-specific mode model ID fields.
+	// If the provider has a dedicated field, do not fall back to generic
+	// *ModeApiModelId. Those generic slots may contain a stale model from a
+	// previous provider (for example openai/gpt-5.4), which would make the SDK
+	// session use a different model than the Cline provider UI shows.
+	const modelFields = PROVIDER_MODEL_ID_MAP[providerId]
+	if (modelFields) {
+		const field = mode === "plan" ? modelFields.plan : modelFields.act
+		return (config[field] as string | undefined)?.trim() || undefined
+	}
+
+	// Fallback to generic mode model ID fields only for providers without a
+	// dedicated model field.
+	const genericField = mode === "plan" ? "planModeApiModelId" : "actModeApiModelId"
+	return (config[genericField] as string | undefined)?.trim() || undefined
+}
+
+/**
+ * Resolve the base URL for a given provider from the ApiConfiguration.
+ */
+export function normalizeSdkBaseUrl(providerId: string, baseUrl: unknown): string | undefined {
+	if (typeof baseUrl !== "string") {
+		return undefined
+	}
+
+	const trimmed = baseUrl.trim()
+	if (!trimmed) {
+		return undefined
+	}
+
+	const providerDefaultBaseUrl = MODEL_COLLECTIONS_BY_PROVIDER_ID[toSdkProviderId(providerId)]?.provider.baseUrl
+	if (!providerDefaultBaseUrl) {
+		return trimmed
+	}
+
+	try {
+		const configuredUrl = new URL(trimmed)
+		const defaultUrl = new URL(providerDefaultBaseUrl)
+		const configuredHasPath = configuredUrl.pathname !== "/"
+		const defaultHasPath = defaultUrl.pathname !== "/"
+
+		if (!configuredHasPath && defaultHasPath) {
+			configuredUrl.pathname = defaultUrl.pathname
+			return configuredUrl.toString().replace(/\/$/, "")
+		}
+	} catch {
+		return trimmed
+	}
+
+	return trimmed
+}
+
+export function resolveVertexProviderConfig(config: ApiConfiguration): Pick<ProviderSettings, "gcp" | "region"> {
+	let providerSettingsProjectId: string | undefined
+	let providerSettingsRegion: string | undefined
+	try {
+		const settings = getProviderSettingsManager().getProviderSettings("vertex")
+		providerSettingsProjectId = settings?.gcp?.projectId?.trim() || undefined
+		providerSettingsRegion = settings?.gcp?.region?.trim() || settings?.region?.trim() || undefined
+	} catch {
+		Logger.warn("[SessionFactory] Failed to read Vertex settings from providers.json")
+	}
+
+	const region = (providerSettingsRegion ?? config.vertexRegion?.trim()) || undefined
+	return {
+		region,
+		gcp: {
+			projectId: (providerSettingsProjectId ?? config.vertexProjectId?.trim()) || undefined,
+			region,
+		},
+	}
+}
+
+export function resolveBaseUrl(providerId: string, config: ApiConfiguration): string | undefined {
+	const baseUrlMap: Record<string, keyof ApiConfiguration> = {
+		anthropic: "anthropicBaseUrl",
+		openai: "openAiBaseUrl",
+		ollama: "ollamaBaseUrl",
+		lmstudio: "lmStudioBaseUrl",
+		gemini: "geminiBaseUrl",
+		requesty: "requestyBaseUrl",
+		litellm: "liteLlmBaseUrl",
+		oca: "ocaBaseUrl",
+		aihubmix: "aihubmixBaseUrl",
+		dify: "difyBaseUrl",
+	}
+
+	const field = baseUrlMap[providerId]
+	if (field) {
+		return normalizeSdkBaseUrl(providerId, config[field])
+	}
+
+	return undefined
+}
+
+// ---------------------------------------------------------------------------
+// Session config builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a CoreSessionConfig from the current state.
+ *
+ * Reads provider settings from the classic StateManager's ApiConfiguration
+ * (which correctly reads from globalState.json + secrets.json), then resolves
+ * the provider, model, and API key for the current mode (plan/act).
+ *
+ * This replaces the previous two-path approach (SDK ProviderSettingsManager +
+ * StateManager.buildApiHandlerSettings) which both failed silently.
+ */
+export async function buildSessionConfig(input: SessionConfigInput): Promise<CoreSessionConfig> {
+	const cwd = input.cwd
+	if (!cwd) {
+		throw new Error("buildSessionConfig requires a cwd resolved by the host controller")
+	}
+	const workspaceRoot = input.workspaceRoot?.trim() || cwd
+	const mode: Mode = input.mode ?? "act"
+	const sdkLogger = createSdkLogger()
+	const distinctId = getDistinctId()
+
+	let providerId: string | undefined
+	let modelId: string | undefined
+	let apiKey: string | undefined
+	let baseUrl: string | undefined
+	let apiConfig: ApiConfiguration | undefined
+	// Cloud-provider structured options. The core runtime reads these from
+	// CoreSessionConfig.providerConfig; without them the SDK gateway never receives
+	// region/project/auth fields for inference calls.
+	let bedrockProviderConfig: BedrockProviderConfig | undefined
+	let vertexProviderConfig: Pick<ProviderSettings, "gcp" | "region"> | undefined
+	let sapProviderConfig: SapProviderConfig | undefined
+
+	try {
+		const stateManager = StateManager.get()
+		apiConfig = stateManager.getApiConfiguration()
+
+		// Resolve the provider for the current mode
+		const modeProvider = mode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider
+		providerId = modeProvider
+
+		if (providerId) {
+			// Resolve API key
+			apiKey = resolveApiKey(providerId, apiConfig)
+
+			// Resolve model ID
+			modelId = resolveModelId(providerId, mode, apiConfig)
+
+			// Resolve base URL
+			baseUrl = resolveBaseUrl(providerId, apiConfig)
+
+			// Resolve Bedrock region + AWS authentication options from the legacy
+			// ApiConfiguration (StateManager is the VSCode source of truth, not
+			// providers.json).
+			if (providerId === "bedrock") {
+				bedrockProviderConfig = buildBedrockProviderConfig(apiConfig, mode)
+			}
+
+			if (providerId === "vertex") {
+				vertexProviderConfig = resolveVertexProviderConfig(apiConfig)
+			}
+
+			if (providerId === "sapaicore") {
+				sapProviderConfig = buildSapProviderConfig(apiConfig, mode)
+				baseUrl = sapProviderConfig.baseUrl
+			}
+
+			Logger.log(
+				`[SessionFactory] Resolved from StateManager: provider=${providerId}, model=${modelId}, hasApiKey=${!!apiKey}`,
+			)
+		}
+	} catch (error) {
+		Logger.warn("[SessionFactory] StateManager credential resolution failed:", error)
+	}
+
+	// Fallback: try SDK's ProviderSettingsManager only when StateManager did not
+	// resolve a provider at all. If the user selected a provider but credentials
+	// are missing, keep that provider/model so the UI can surface the right auth
+	// state instead of silently switching to a previous provider.
+	if (!providerId) {
+		try {
+			const dataDir = resolveDataDir()
+			const manager = getProviderSettingsManager(dataDir)
+			const lastUsed = manager.getLastUsedProviderSettings({
+				isClinePassEnabled: getFeatureFlagsService().getBooleanFlagEnabled(FeatureFlag.CLINE_PASS),
+			})
+
+			if (lastUsed?.provider && lastUsed?.apiKey) {
+				providerId = lastUsed.provider
+				modelId = lastUsed.model
+				apiKey = lastUsed.apiKey
+				baseUrl = lastUsed.baseUrl
+				Logger.log(`[SessionFactory] Using SDK provider fallback: ${providerId}/${modelId}`)
+			}
+		} catch (error) {
+			Logger.warn("[SessionFactory] SDK ProviderSettingsManager fallback failed:", error)
+		}
+	}
+
+	// Final defaults. Keep this aligned with the provider catalog so the UI and
+	// session factory share one source of truth for default models.
+	providerId = providerId ?? DEFAULT_PROVIDER_ID
+	modelId = modelId ?? getDefaultModelIdForProvider(providerId) ?? getDefaultModelIdForProvider(DEFAULT_PROVIDER_ID) ?? ""
+	if (!apiKey && apiConfig) {
+		apiKey = resolveApiKey(providerId, apiConfig)
+	}
+	apiKey = apiKey ?? ""
+	const maxTokensPerTurn = providerId === "openai" ? resolveOpenAiCompatibleMaxTokens(apiConfig, mode) : undefined
+	const reasoningConfig =
+		providerId === "oca"
+			? (resolveOcaReasoningConfig(mode, apiConfig) ?? resolveProviderReasoningConfig(providerId))
+			: resolveProviderReasoningConfig(providerId)
+
+	// Build the system prompt using the shared prompt builder. Core still
+	// expects callers to provide a concrete systemPrompt, but the prompt builder
+	// can derive baseline workspace context from the root path and workspace
+	// name, so we avoid duplicating core's richer workspace metadata pass here.
+	let systemPrompt = ""
+	try {
+		const workspaceName = resolveWorkspaceName(cwd)
+		systemPrompt = buildClineSystemPrompt({
+			ide: "VS Code",
+			workspaceRoot,
+			workspaceName,
+			mode: mode === "plan" ? "plan" : "act",
+			providerId,
+			platform: process.platform,
+		})
+		Logger.log(`[SessionFactory] Built system prompt: ${systemPrompt.length} chars`)
+	} catch (error) {
+		Logger.warn("[SessionFactory] Failed to build system prompt, using minimal fallback:", error)
+		systemPrompt = "You are Cline, a highly skilled software engineer. Help the user with their request."
+	}
+
+	// Inject preferred language instructions when a non-default language is selected.
+	// Mirrors classic src/core/task/index.ts preferredLanguage handling.
+	try {
+		const preferredLanguageRaw = StateManager.get().getGlobalSettingsKey("preferredLanguage")
+		const preferredLanguage = getLanguageKey(preferredLanguageRaw as LanguageDisplay | undefined)
+		if (preferredLanguage && preferredLanguage !== DEFAULT_LANGUAGE_SETTINGS) {
+			systemPrompt = `${systemPrompt}\n\n# Preferred Language\n\nSpeak in ${preferredLanguage}.`
+		}
+	} catch (error) {
+		Logger.warn("[SessionFactory] Failed to inject preferredLanguage instructions:", error)
+	}
+
+	// Append plan-mode instructions when in plan mode, matching the CLI's
+	// behavior (apps/cli/src/runtime/prompt.ts). The shared prompt builder does
+	// not include these guardrails, so without this the model in plan mode may
+	// still attempt to make edits instead of planning.
+	if (mode === "plan") {
+		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${PLAN_MODE_INSTRUCTIONS}` : PLAN_MODE_INSTRUCTIONS
+	}
+
+	const stateManager = StateManager.get()
+	const globalUseAutoCondense = stateManager.getGlobalSettingsKey("useAutoCondense") ?? false
+	const compactionStrategy = readCompactionStrategyGlobally()
+	const enableCheckpoints = stateManager.getGlobalSettingsKey("enableCheckpointsSetting") ?? true
+	const useAutoCondense = input.taskSettings?.useAutoCondense ?? globalUseAutoCondense
+
+	// Core resolves providers against the SDK registry, which uses the SDK's
+	// own provider id spelling (e.g. "openai-compatible" rather than the
+	// extension's "openai"). Convert before handing the id to core.
+	const sdkProviderId = toSdkProviderId(providerId)
+	const hostIdentity = await resolveHostIdentity()
+	const isMultiRoot = await resolveIsMultiRootWorkspace()
+
+	// Always pass a providerConfig so the proxy/CA-aware fetch reaches the SDK
+	// gateway; without it the agent loop uses bare global fetch and corporate
+	// proxy/self-signed CA setups fail on JetBrains and CLI. Cloud providers
+	// additionally need structured options (region/project/auth/SAP OAuth), which core
+	// reads from providerConfig in createAgentModelFromConfig.
+	const cloudProviderConfig = bedrockProviderConfig ?? vertexProviderConfig ?? sapProviderConfig
+	// Spread the cloud config first so the explicit fields below — notably the
+	// proxy/CA-aware fetch — can never be clobbered if those types gain matching keys.
+	const providerConfig = {
+		...(cloudProviderConfig ?? {}),
+		providerId: sdkProviderId,
+		modelId,
+		...(apiKey ? { apiKey } : {}),
+		...(baseUrl !== undefined ? { baseUrl } : {}),
+		fetch,
+	}
+
+	const config: CoreSessionConfig = {
+		providerId: sdkProviderId,
+		modelId,
+		apiKey,
+		baseUrl,
+		providerConfig,
+		cwd,
+		workspaceRoot,
+		systemPrompt,
+		enableTools: true,
+		checkpoint: {
+			enabled: enableCheckpoints,
+		},
+		enableSpawnAgent: false,
+		enableAgentTeams: false,
+		...(useAutoCondense
+			? {
+					compaction: {
+						enabled: true,
+						strategy: compactionStrategy,
+					},
+				}
+			: {}),
+		disableMcpSettingsTools: true,
+		mode: mode === "plan" ? "plan" : "act",
+		...reasoningConfig,
+		...(maxTokensPerTurn !== undefined ? { maxTokensPerTurn } : {}),
+		maxIterations: undefined,
+		logger: sdkLogger,
+		extensionContext: {
+			user: distinctId ? { distinctId } : undefined,
+			client: {
+				name: hostIdentity?.clineType || ClineClient.VSCode,
+				version: hostIdentity?.clineVersion || ExtensionRegistryInfo.version,
+				platform: hostIdentity?.platform || undefined,
+				platformVersion: hostIdentity?.version || undefined,
+				isMultiRoot,
+			},
+			workspace: {
+				rootPath: workspaceRoot,
+				cwd,
+				workspaceName: resolveWorkspaceName(workspaceRoot),
+				ide: "VS Code",
+				platform: process.platform,
+				mode: mode === "plan" ? "plan" : "act",
+			},
+			logger: sdkLogger,
+		},
+		hooks: buildAgentHooks(StateManager.get()),
+	}
+
+	return config
+}
+
+// ---------------------------------------------------------------------------
+// Session factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the StartSessionInput for a new task.
+ *
+ * IMPORTANT: We pass `interactive: true` but NO `prompt`. This creates the
+ * session and returns immediately — the runtime host only executes a turn when
+ * a prompt is sent. The caller should then call `core.send({ sessionId, prompt })`
+ * to run the first turn. This cleanly separates session creation from
+ * inference, preventing the gRPC handler from blocking until the first
+ * agent turn completes.
+ */
+export function buildStartSessionInput(config: CoreSessionConfig, input: SessionConfigInput): ClineCoreStartInput {
+	return {
+		config,
+		// Do NOT pass prompt here — start() should return immediately.
+		// The prompt is sent separately via core.send() after session creation.
+		prompt: undefined,
+		interactive: true, // VSCode extension always uses interactive mode
+		userImages: input.images,
+		userFiles: input.files,
+	}
+}
+
+/**
+ * Build the StartSessionInput for resuming an existing task.
+ *
+ * When resuming, we don't pass initialMessages — the SDK's session
+ * persistence handles loading the conversation history from disk.
+ */
+export function buildResumeSessionInput(
+	sessionId: string,
+	prompt: string,
+	images?: string[],
+	files?: string[],
+): { sessionId: string; prompt: string; userImages?: string[]; userFiles?: string[] } {
+	return {
+		sessionId,
+		prompt,
+		userImages: images,
+		userFiles: files,
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Task history helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Get a HistoryItem by ID from the task history.
+ */
+export function getHistoryItemById(taskId: string, dataDir?: string): HistoryItem | undefined {
+	const history = readTaskHistory(dataDir)
+	return history.find((item) => item.id === taskId)
+}
+
+/**
+ * Update a HistoryItem in the task history.
+ * Returns the updated history array.
+ */
+export function updateHistoryItem(item: HistoryItem, dataDir?: string): HistoryItem[] {
+	const history = readTaskHistory(dataDir)
+	const index = history.findIndex((h) => h.id === item.id)
+	if (index >= 0) {
+		history[index] = item
+	} else {
+		history.unshift(item)
+	}
+	return history
+}
+
+/**
+ * Create a new HistoryItem from a session start result.
+ */
+export function createHistoryItemFromSession(sessionId: string, prompt: string, modelId?: string, cwd?: string): HistoryItem {
+	return {
+		id: sessionId,
+		ts: Date.now(),
+		task: prompt,
+		tokensIn: 0,
+		tokensOut: 0,
+		totalCost: 0,
+		modelId,
+		cwdOnTaskInitialization: cwd,
+	}
+}
diff --git a/apps/vscode/src/sdk/hooks-adapter.ts b/apps/vscode/src/sdk/hooks-adapter.ts
new file mode 100644
index 0000000..1106551
--- /dev/null
+++ b/apps/vscode/src/sdk/hooks-adapter.ts
@@ -0,0 +1,360 @@
+// Bridges Cline's file-based hook scripts into the SDK's runtime hooks.
+//
+// Runtime hooks use typed in-process lifecycle callbacks:
+//   TaskStart        -> beforeRun
+//   UserPromptSubmit -> beforeRun with the latest submitted user message
+//   PreToolUse       -> beforeTool
+//   PostToolUse      -> afterTool
+//   TaskComplete     -> afterRun when completed
+//   TaskCancel       -> afterRun when aborted
+//
+// Deferred hooks (NOT wired here): TaskResume, TaskError, SessionShutdown,
+// PreCompact, Notification.
+
+import type {
+	AgentAfterToolContext,
+	AgentBeforeToolContext,
+	AgentHooks,
+	AgentRunLifecycleContext,
+	AgentStopControl,
+} from "@cline/shared"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { Logger } from "@shared/services/Logger"
+import { HookFactory } from "@/core/hooks/hook-factory"
+import { getHooksEnabledSafe } from "@/core/hooks/hooks-utils"
+import type { StateManager } from "@/core/storage/StateManager"
+
+export type HookMessageEmitter = (message: ClineMessage) => void
+
+function toStringRecord(input: unknown): Record<string, string> {
+	if (input == null || typeof input !== "object" || Array.isArray(input)) {
+		return {}
+	}
+	const result: Record<string, string> = {}
+	for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+		result[key] = typeof value === "string" ? value : JSON.stringify(value)
+	}
+	return result
+}
+
+function mapStopControl(hookOutput: { cancel?: boolean; errorMessage?: string }): AgentStopControl | undefined {
+	if (!hookOutput.cancel) {
+		return undefined
+	}
+	return {
+		stop: true,
+		reason: hookOutput.errorMessage || undefined,
+	}
+}
+
+function taskIdFromSnapshot(snapshot: AgentRunLifecycleContext["snapshot"]): string {
+	return snapshot.conversationId ?? snapshot.runId ?? snapshot.agentId
+}
+
+function textFromMessageContent(content: readonly { type: string; text?: string }[]): string {
+	return content
+		.filter((part) => part.type === "text" && typeof part.text === "string")
+		.map((part) => part.text)
+		.join("")
+}
+
+function latestUserPrompt(ctx: AgentRunLifecycleContext): string {
+	for (let index = ctx.snapshot.messages.length - 1; index >= 0; index -= 1) {
+		const message = ctx.snapshot.messages[index]
+		if (message?.role === "user") {
+			return textFromMessageContent(message.content)
+		}
+	}
+	return ""
+}
+
+function buildHookStatusMessage(opts: {
+	hookName: string
+	status: "running" | "completed" | "failed" | "cancelled"
+	toolName?: string
+	ts?: number
+}): ClineMessage {
+	return {
+		ts: opts.ts ?? Date.now(),
+		type: "say",
+		say: "hook_status",
+		text: JSON.stringify({
+			hookName: opts.hookName,
+			...(opts.toolName && { toolName: opts.toolName }),
+			status: opts.status,
+		}),
+		partial: false,
+	}
+}
+
+export function buildAgentHooks(stateManager: StateManager, emitHookMessage?: HookMessageEmitter): AgentHooks {
+	const hooksEnabled = () => getHooksEnabledSafe(stateManager.getGlobalSettingsKey("hooksEnabled"))
+
+	return {
+		async beforeRun(ctx: AgentRunLifecycleContext): Promise<AgentStopControl | undefined> {
+			const taskStartControl = await runTaskStart(ctx, hooksEnabled, emitHookMessage)
+			if (taskStartControl) {
+				return taskStartControl
+			}
+			return runUserPromptSubmit(ctx, hooksEnabled, emitHookMessage)
+		},
+
+		async beforeTool(ctx: AgentBeforeToolContext): Promise<{ stop?: boolean; reason?: string } | undefined> {
+			let runningTs: number | undefined
+			try {
+				if (!hooksEnabled()) {
+					return undefined
+				}
+
+				const factory = new HookFactory()
+				if (!(await factory.hasHook("PreToolUse"))) {
+					return undefined
+				}
+
+				const toolName = ctx.toolCall.toolName
+				const runningMsg = buildHookStatusMessage({ hookName: "PreToolUse", toolName, status: "running" })
+				runningTs = runningMsg.ts
+				emitHookMessage?.(runningMsg)
+
+				const runner = await factory.create("PreToolUse")
+				const result = await runner.run({
+					taskId: taskIdFromSnapshot(ctx.snapshot),
+					preToolUse: {
+						toolName,
+						parameters: toStringRecord(ctx.input),
+					},
+				})
+
+				emitHookMessage?.(
+					buildHookStatusMessage({
+						hookName: "PreToolUse",
+						toolName,
+						status: result.cancel ? "cancelled" : "completed",
+						ts: runningTs,
+					}),
+				)
+				return mapStopControl(result)
+			} catch (error) {
+				emitHookMessage?.(
+					buildHookStatusMessage({
+						hookName: "PreToolUse",
+						toolName: ctx.toolCall.toolName,
+						status: "failed",
+						ts: runningTs,
+					}),
+				)
+				Logger.error("[HooksAdapter] beforeTool hook failed:", error)
+				return undefined
+			}
+		},
+
+		async afterTool(ctx: AgentAfterToolContext): Promise<undefined> {
+			let runningTs: number | undefined
+			try {
+				if (!hooksEnabled()) {
+					return undefined
+				}
+
+				const factory = new HookFactory()
+				if (!(await factory.hasHook("PostToolUse"))) {
+					return undefined
+				}
+
+				const toolName = ctx.toolCall.toolName
+				const runningMsg = buildHookStatusMessage({ hookName: "PostToolUse", toolName, status: "running" })
+				runningTs = runningMsg.ts
+				emitHookMessage?.(runningMsg)
+
+				const runner = await factory.create("PostToolUse")
+				const result = await runner.run({
+					taskId: taskIdFromSnapshot(ctx.snapshot),
+					postToolUse: {
+						toolName,
+						parameters: toStringRecord(ctx.input),
+						result: String(ctx.result.output ?? ""),
+						success: !ctx.result.isError,
+						executionTimeMs: ctx.durationMs,
+					},
+				})
+
+				emitHookMessage?.(
+					buildHookStatusMessage({
+						hookName: "PostToolUse",
+						toolName,
+						status: result.cancel ? "cancelled" : "completed",
+						ts: runningTs,
+					}),
+				)
+				return undefined
+			} catch (error) {
+				emitHookMessage?.(
+					buildHookStatusMessage({
+						hookName: "PostToolUse",
+						toolName: ctx.toolCall.toolName,
+						status: "failed",
+						ts: runningTs,
+					}),
+				)
+				Logger.error("[HooksAdapter] afterTool hook failed:", error)
+				return undefined
+			}
+		},
+
+		async afterRun(ctx): Promise<void> {
+			let hookName: "TaskComplete" | "TaskCancel" | undefined
+			let runningTs: number | undefined
+			try {
+				if (!hooksEnabled()) {
+					return
+				}
+
+				hookName =
+					ctx.result.status === "completed"
+						? "TaskComplete"
+						: ctx.result.status === "aborted"
+							? "TaskCancel"
+							: undefined
+				if (!hookName) {
+					return
+				}
+
+				const factory = new HookFactory()
+				if (!(await factory.hasHook(hookName))) {
+					return
+				}
+
+				const taskId = taskIdFromSnapshot(ctx.snapshot)
+				const runningMsg = buildHookStatusMessage({ hookName, status: "running" })
+				runningTs = runningMsg.ts
+				emitHookMessage?.(runningMsg)
+
+				if (hookName === "TaskComplete") {
+					const runner = await factory.create("TaskComplete")
+					await runner.run({
+						taskId,
+						taskComplete: {
+							taskMetadata: {
+								taskId,
+								ulid: "",
+								initialTask: "",
+								result: ctx.result.outputText,
+							},
+						},
+					})
+				} else {
+					const runner = await factory.create("TaskCancel")
+					await runner.run({
+						taskId,
+						taskCancel: {
+							taskMetadata: {
+								taskId,
+								ulid: "",
+								initialTask: "",
+								completionStatus: "cancelled",
+							},
+						},
+					})
+				}
+
+				emitHookMessage?.(buildHookStatusMessage({ hookName, status: "completed", ts: runningTs }))
+			} catch (error) {
+				emitHookMessage?.(
+					buildHookStatusMessage({ hookName: hookName ?? "TaskComplete", status: "failed", ts: runningTs }),
+				)
+				Logger.error("[HooksAdapter] afterRun hook failed:", error)
+			}
+		},
+	}
+}
+
+async function runTaskStart(
+	ctx: AgentRunLifecycleContext,
+	hooksEnabled: () => boolean,
+	emitHookMessage?: HookMessageEmitter,
+): Promise<AgentStopControl | undefined> {
+	let runningTs: number | undefined
+	try {
+		if (!hooksEnabled()) {
+			return undefined
+		}
+
+		const factory = new HookFactory()
+		if (!(await factory.hasHook("TaskStart"))) {
+			return undefined
+		}
+
+		const runningMsg = buildHookStatusMessage({ hookName: "TaskStart", status: "running" })
+		runningTs = runningMsg.ts
+		emitHookMessage?.(runningMsg)
+
+		const taskId = taskIdFromSnapshot(ctx.snapshot)
+		const runner = await factory.create("TaskStart")
+		const result = await runner.run({
+			taskId,
+			taskStart: {
+				taskMetadata: {
+					taskId,
+					ulid: "",
+					initialTask: latestUserPrompt(ctx),
+				},
+			},
+		})
+
+		emitHookMessage?.(
+			buildHookStatusMessage({
+				hookName: "TaskStart",
+				status: result.cancel ? "cancelled" : "completed",
+				ts: runningTs,
+			}),
+		)
+		return mapStopControl(result)
+	} catch (error) {
+		emitHookMessage?.(buildHookStatusMessage({ hookName: "TaskStart", status: "failed", ts: runningTs }))
+		Logger.error("[HooksAdapter] beforeRun (TaskStart) hook failed:", error)
+		return undefined
+	}
+}
+
+async function runUserPromptSubmit(
+	ctx: AgentRunLifecycleContext,
+	hooksEnabled: () => boolean,
+	emitHookMessage?: HookMessageEmitter,
+): Promise<AgentStopControl | undefined> {
+	let runningTs: number | undefined
+	try {
+		if (!hooksEnabled()) {
+			return undefined
+		}
+
+		const factory = new HookFactory()
+		if (!(await factory.hasHook("UserPromptSubmit"))) {
+			return undefined
+		}
+
+		const runningMsg = buildHookStatusMessage({ hookName: "UserPromptSubmit", status: "running" })
+		runningTs = runningMsg.ts
+		emitHookMessage?.(runningMsg)
+
+		const runner = await factory.create("UserPromptSubmit")
+		const result = await runner.run({
+			taskId: taskIdFromSnapshot(ctx.snapshot),
+			userPromptSubmit: {
+				prompt: latestUserPrompt(ctx),
+				attachments: [],
+			},
+		})
+
+		emitHookMessage?.(
+			buildHookStatusMessage({
+				hookName: "UserPromptSubmit",
+				status: result.cancel ? "cancelled" : "completed",
+				ts: runningTs,
+			}),
+		)
+		return mapStopControl(result)
+	} catch (error) {
+		emitHookMessage?.(buildHookStatusMessage({ hookName: "UserPromptSubmit", status: "failed", ts: runningTs }))
+		Logger.error("[HooksAdapter] beforeRun (UserPromptSubmit) hook failed:", error)
+		return undefined
+	}
+}
diff --git a/apps/vscode/src/sdk/index.ts b/apps/vscode/src/sdk/index.ts
new file mode 100644
index 0000000..9d3d0ae
--- /dev/null
+++ b/apps/vscode/src/sdk/index.ts
@@ -0,0 +1,31 @@
+// SDK Adapter Layer
+// Replaces classic src/core/controller/ (see origin/main)
+//
+// This module provides the SDK-backed Controller and related adapters.
+// The webview continues to communicate via gRPC; this layer translates
+// between gRPC handlers and SDK calls.
+
+export * from "./account-service"
+export * from "./auth-service"
+export * from "./cline-session-factory"
+export * from "./legacy-state-reader"
+export * from "./message-translator"
+export * from "./provider-migration"
+export { Controller } from "./SdkController"
+export * from "./sdk-followup-coordinator"
+export * from "./sdk-interaction-coordinator"
+export * from "./sdk-mcp-coordinator"
+export * from "./sdk-message-coordinator"
+export * from "./sdk-mode-coordinator"
+export * from "./sdk-session-config-builder"
+export * from "./sdk-session-event-coordinator"
+export * from "./sdk-session-history-loader"
+export * from "./sdk-session-lifecycle"
+export * from "./sdk-task-control-coordinator"
+export * from "./sdk-task-history"
+export * from "./sdk-task-start-coordinator"
+export * from "./sdk-tool-policies"
+export * from "./task-proxy"
+export * from "./vscode-runtime-builder"
+export * from "./vscode-session-host"
+export * from "./webview-grpc-bridge"
diff --git a/apps/vscode/src/sdk/initial-message-sanitizer.test.ts b/apps/vscode/src/sdk/initial-message-sanitizer.test.ts
new file mode 100644
index 0000000..f82e558
--- /dev/null
+++ b/apps/vscode/src/sdk/initial-message-sanitizer.test.ts
@@ -0,0 +1,249 @@
+import { describe, expect, it } from "vitest"
+import { sanitizeInitialMessagesForSessionStart } from "./initial-message-sanitizer"
+
+describe("sanitizeInitialMessagesForSessionStart", () => {
+	it("returns original array when no tool_use blocks exist", () => {
+		const input = [
+			{ role: "user", content: "hello" },
+			{ role: "assistant", content: "hi" },
+		]
+		const result = sanitizeInitialMessagesForSessionStart(input)
+		expect(result).toBe(input)
+	})
+
+	it("adds missing tool_result blocks to the next user message", () => {
+		const input = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "read_file",
+						input: { path: "a.ts" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [{ type: "text", text: "continue" }],
+			},
+		]
+
+		const result = sanitizeInitialMessagesForSessionStart(input)
+		expect(result).not.toBe(input)
+
+		const nextContent = (result[1] as { content: Array<Record<string, unknown>> }).content
+		expect(nextContent).toEqual([
+			expect.objectContaining({
+				type: "tool_result",
+				tool_use_id: "toolu_1",
+				name: "read_file",
+			}),
+		])
+		expect(result[2]).toMatchObject({
+			role: "user",
+			content: [expect.objectContaining({ type: "text", text: "continue" })],
+		})
+	})
+
+	it("inserts synthetic user tool_result message when missing next user message", () => {
+		const input = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "read_file",
+						input: { path: "a.ts" },
+					},
+				],
+			},
+			{ role: "assistant", content: [{ type: "text", text: "extra" }] },
+		]
+
+		const result = sanitizeInitialMessagesForSessionStart(input)
+		expect(result).toHaveLength(3)
+		expect(result[1]).toMatchObject({
+			role: "user",
+			content: [{ type: "tool_result", tool_use_id: "toolu_1", name: "read_file" }],
+		})
+	})
+
+	it("consolidates parallel tool results spread across separate user messages (ENG-1885)", () => {
+		// The SDK persists each parallel tool result as a separate user message.
+		// The sanitizer must collect them all, not just the first one.
+		const input = [
+			{ role: "user", content: [{ type: "text", text: "list /usr" }] },
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "I'll list several directories." },
+					{
+						type: "tool_use",
+						id: "toolu_A",
+						name: "execute_command",
+						input: { command: "ls /usr/bin" },
+					},
+					{
+						type: "tool_use",
+						id: "toolu_B",
+						name: "execute_command",
+						input: { command: "ls /usr/lib" },
+					},
+					{
+						type: "tool_use",
+						id: "toolu_C",
+						name: "execute_command",
+						input: { command: "ls /usr/share" },
+					},
+				],
+			},
+			// SDK persists each tool result as a separate user message
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_A",
+						content: "bin contents",
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_B",
+						content: "lib contents",
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_C",
+						content: "share contents",
+					},
+				],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "Here are the results." }],
+			},
+		]
+
+		const result = sanitizeInitialMessagesForSessionStart(input)
+
+		// Should consolidate the 3 separate user messages into 1
+		expect(result).toHaveLength(4) // user, assistant(3 tools), user(3 results), assistant
+		const toolResultMsg = result[2] as {
+			content: Array<Record<string, unknown>>
+		}
+		expect(toolResultMsg.content).toHaveLength(3)
+		expect(toolResultMsg.content[0]).toMatchObject({
+			type: "tool_result",
+			tool_use_id: "toolu_A",
+			content: "bin contents",
+		})
+		expect(toolResultMsg.content[1]).toMatchObject({
+			type: "tool_result",
+			tool_use_id: "toolu_B",
+			content: "lib contents",
+		})
+		expect(toolResultMsg.content[2]).toMatchObject({
+			type: "tool_result",
+			tool_use_id: "toolu_C",
+			content: "share contents",
+		})
+
+		// Verify no duplicates: count tool_result blocks across all messages
+		const allToolResultIds = (result as Array<{ role: string; content: unknown }>).flatMap((msg) => {
+			if (!Array.isArray(msg.content)) return []
+			return msg.content.filter((b: any) => b.type === "tool_result").map((b: any) => b.tool_use_id)
+		})
+		const uniqueIds = new Set(allToolResultIds)
+		expect(allToolResultIds.length).toBe(uniqueIds.size) // no duplicates
+	})
+
+	it("reorders existing tool_result blocks to match tool_use order", () => {
+		const input = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "read_file",
+						input: { path: "a.ts" },
+					},
+					{
+						type: "tool_use",
+						id: "toolu_2",
+						name: "read_file",
+						input: { path: "b.ts" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{ type: "tool_result", tool_use_id: "toolu_2", content: "b" },
+					{ type: "text", text: "keep me" },
+					{ type: "tool_result", tool_use_id: "toolu_1", content: "a" },
+				],
+			},
+		]
+
+		const result = sanitizeInitialMessagesForSessionStart(input)
+		const nextContent = (result[1] as { content: Array<Record<string, unknown>> }).content
+		expect(nextContent[0]).toMatchObject({
+			type: "tool_result",
+			tool_use_id: "toolu_1",
+		})
+		expect(nextContent[1]).toMatchObject({
+			type: "tool_result",
+			tool_use_id: "toolu_2",
+		})
+		expect(nextContent[2]).toMatchObject({ type: "text", text: "keep me" })
+	})
+
+	it("backfills missing tool_result names from matching assistant tool_use blocks", () => {
+		const input = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "read_file",
+						input: { path: "a.ts" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_1",
+						content: "file contents",
+					},
+				],
+			},
+		]
+
+		const result = sanitizeInitialMessagesForSessionStart(input)
+		const nextContent = (result[1] as { content: Array<Record<string, unknown>> }).content
+		expect(nextContent[0]).toMatchObject({
+			type: "tool_result",
+			tool_use_id: "toolu_1",
+			name: "read_file",
+			content: "file contents",
+		})
+	})
+})
diff --git a/apps/vscode/src/sdk/initial-message-sanitizer.ts b/apps/vscode/src/sdk/initial-message-sanitizer.ts
new file mode 100644
index 0000000..3fc059e
--- /dev/null
+++ b/apps/vscode/src/sdk/initial-message-sanitizer.ts
@@ -0,0 +1,196 @@
+import type { SdkInitialMessages } from "./session-host"
+
+type GenericContentBlock = Record<string, unknown>
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function toBlocks(content: unknown): GenericContentBlock[] {
+	if (Array.isArray(content)) {
+		return content.filter(isRecord)
+	}
+	if (typeof content === "string") {
+		return [{ type: "text", text: content }]
+	}
+	return []
+}
+
+interface ToolUseReference {
+	id: string
+	name?: string
+}
+
+function getToolUses(content: unknown): ToolUseReference[] {
+	if (!Array.isArray(content)) {
+		return []
+	}
+
+	const toolUses: ToolUseReference[] = []
+	for (const block of content) {
+		if (!isRecord(block)) {
+			continue
+		}
+		if (block.type === "tool_use" && typeof block.id === "string") {
+			toolUses.push({
+				id: block.id,
+				name: typeof block.name === "string" && block.name.length > 0 ? block.name : undefined,
+			})
+		}
+	}
+	return toolUses
+}
+
+function isToolResultForId(block: GenericContentBlock, toolUseId: string): boolean {
+	return block.type === "tool_result" && block.tool_use_id === toolUseId
+}
+
+const MIGRATION_MISSING_TOOL_RESULT_TEXT = "[migration] Tool result missing in legacy conversation history."
+
+function createMissingToolResult(toolUseId: string, toolName?: string): GenericContentBlock {
+	return {
+		type: "tool_result",
+		tool_use_id: toolUseId,
+		...(toolName ? { name: toolName } : {}),
+		content: MIGRATION_MISSING_TOOL_RESULT_TEXT,
+	}
+}
+
+function withToolResultName(block: GenericContentBlock, toolName?: string): GenericContentBlock {
+	if (!toolName || typeof block.name === "string") {
+		return block
+	}
+	return { ...block, name: toolName }
+}
+
+function isMigrationPlaceholderToolResult(block: GenericContentBlock): boolean {
+	return block.type === "tool_result" && block.content === MIGRATION_MISSING_TOOL_RESULT_TEXT
+}
+
+/**
+ * Ensures pre-SDK conversation messages satisfy strict tool-use pairing rules.
+ *
+ * SDK runtime validation expects every assistant tool_use block to have matching
+ * tool_result blocks at the start of the following user message. Legacy
+ * conversations (especially interrupted turns) can miss these blocks, causing
+ * "Tool result is missing for tool call ..." errors on resume.
+ */
+export function sanitizeInitialMessagesForSessionStart(messages: SdkInitialMessages): SdkInitialMessages
+export function sanitizeInitialMessagesForSessionStart(messages: unknown[]): unknown[]
+export function sanitizeInitialMessagesForSessionStart(messages: unknown[]): unknown[] {
+	if (messages.length === 0) {
+		return messages
+	}
+
+	const sanitized = [...messages]
+	let changed = false
+
+	for (let i = 0; i < sanitized.length; i++) {
+		const assistantMessage = sanitized[i]
+		if (!isRecord(assistantMessage) || assistantMessage.role !== "assistant") {
+			continue
+		}
+
+		const toolUses = getToolUses(assistantMessage.content)
+		if (toolUses.length === 0) {
+			continue
+		}
+		const toolUseIds = toolUses.map((toolUse) => toolUse.id)
+		const toolUseNames = new Map(toolUses.map((toolUse) => [toolUse.id, toolUse.name]))
+
+		const next = sanitized[i + 1]
+		if (!isRecord(next) || next.role !== "user") {
+			// Insert a synthetic user message with placeholder tool results so
+			// the message stream remains valid for SDK parsing.
+			sanitized.splice(i + 1, 0, {
+				role: "user",
+				content: toolUses.map((toolUse) => createMissingToolResult(toolUse.id, toolUse.name)),
+			})
+			changed = true
+			i += 1
+			continue
+		}
+
+		// Collect tool_result blocks from ALL consecutive user messages after
+		// the assistant.  The SDK persists each parallel tool result as a
+		// separate user message, so we must scan beyond just `i + 1`.
+		const toolUseIdSet = new Set(toolUseIds)
+		const matchingToolResults = new Map<string, GenericContentBlock>()
+		const otherBlocks: GenericContentBlock[] = []
+		let userSpan = 0 // how many consecutive user messages we consumed
+
+		for (let j = i + 1; j < sanitized.length; j++) {
+			const msg = sanitized[j]
+			if (!isRecord(msg) || msg.role !== "user") {
+				break
+			}
+
+			const blocks = toBlocks(msg.content)
+			for (const block of blocks) {
+				let matched = false
+				for (const toolUseId of toolUseIds) {
+					if (!matchingToolResults.has(toolUseId) && isToolResultForId(block, toolUseId)) {
+						matchingToolResults.set(toolUseId, withToolResultName(block, toolUseNames.get(toolUseId)))
+						matched = true
+						break
+					}
+				}
+				if (!matched) {
+					// Keep non-matching tool_results (for other tool_use IDs)
+					// and any non-tool content.
+					if (
+						block.type === "tool_result" &&
+						typeof block.tool_use_id === "string" &&
+						toolUseIdSet.has(block.tool_use_id)
+					) {
+						// Duplicate tool_result for an ID we already matched — skip it
+					} else {
+						otherBlocks.push(block)
+					}
+				}
+			}
+			userSpan++
+		}
+
+		const missingToolResultIds = toolUseIds.filter((toolUseId) => !matchingToolResults.has(toolUseId))
+		const orderedToolResults = toolUseIds.map(
+			(toolUseId) => matchingToolResults.get(toolUseId) ?? createMissingToolResult(toolUseId, toolUseNames.get(toolUseId)),
+		)
+
+		// If we had to synthesize missing tool_result blocks (or are carrying the
+		// migration placeholder from a previous resume attempt), keep the immediate
+		// response message strictly tool_result-only for maximum provider compatibility.
+		// Move any existing non-tool-result content into a follow-up user message.
+		const hasMigrationPlaceholder = orderedToolResults.some(isMigrationPlaceholderToolResult)
+		if (missingToolResultIds.length > 0 || hasMigrationPlaceholder || userSpan > 1) {
+			// Replace the span of user messages with a single consolidated message
+			sanitized.splice(i + 1, userSpan, {
+				...next,
+				content: orderedToolResults,
+			})
+			if (otherBlocks.length > 0) {
+				sanitized.splice(i + 2, 0, {
+					role: "user",
+					content: otherBlocks,
+				})
+				i += 1
+			}
+			changed = true
+			continue
+		}
+
+		const newContent = [...orderedToolResults, ...otherBlocks]
+		const originalBlocks = toBlocks(next.content)
+		const differsInLength = newContent.length !== originalBlocks.length
+		const differsInOrder = !differsInLength && newContent.some((block, index) => block !== originalBlocks[index])
+		if (differsInLength || differsInOrder) {
+			sanitized[i + 1] = {
+				...next,
+				content: newContent,
+			}
+			changed = true
+		}
+	}
+
+	return changed ? sanitized : messages
+}
diff --git a/apps/vscode/src/sdk/legacy-state-reader.test.ts b/apps/vscode/src/sdk/legacy-state-reader.test.ts
new file mode 100644
index 0000000..ebab94a
--- /dev/null
+++ b/apps/vscode/src/sdk/legacy-state-reader.test.ts
@@ -0,0 +1,465 @@
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import {
+	listTaskIds,
+	type McpSettingsFile,
+	readAllLegacyState,
+	readApiConversationHistory,
+	readContextHistory,
+	readGlobalState,
+	readGlobalStateKey,
+	readMcpSettings,
+	readSecretKey,
+	readSecrets,
+	readTaskHistory,
+	readTaskMetadata,
+	readUiMessages,
+	resolveDataDir,
+} from "./legacy-state-reader"
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+let tempDir: string
+
+beforeEach(() => {
+	tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cline-legacy-state-"))
+})
+
+afterEach(() => {
+	fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+function writeJson(filePath: string, data: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true })
+	fs.writeFileSync(filePath, JSON.stringify(data, null, 2))
+}
+
+// ---------------------------------------------------------------------------
+// resolveDataDir
+// ---------------------------------------------------------------------------
+
+describe("resolveDataDir", () => {
+	it("uses override when provided", () => {
+		expect(resolveDataDir("/custom/path")).toBe("/custom/path")
+	})
+
+	it("falls back to CLINE_DATA_DIR env", () => {
+		const original = process.env.CLINE_DATA_DIR
+		process.env.CLINE_DATA_DIR = "/env/data"
+		try {
+			expect(resolveDataDir()).toBe("/env/data")
+		} finally {
+			process.env.CLINE_DATA_DIR = original
+		}
+	})
+
+	it("falls back to CLINE_DIR/data", () => {
+		const originalData = process.env.CLINE_DATA_DIR
+		const originalDir = process.env.CLINE_DIR
+		delete process.env.CLINE_DATA_DIR
+		process.env.CLINE_DIR = "/cline"
+		try {
+			// path.join keeps the platform separator (\ on Windows), so compare
+			// against a joined path rather than a hardcoded POSIX string.
+			expect(resolveDataDir()).toBe(path.join("/cline", "data"))
+		} finally {
+			process.env.CLINE_DATA_DIR = originalData
+			process.env.CLINE_DIR = originalDir
+		}
+	})
+
+	it("falls back to ~/.cline/data", () => {
+		const originalData = process.env.CLINE_DATA_DIR
+		const originalDir = process.env.CLINE_DIR
+		delete process.env.CLINE_DATA_DIR
+		delete process.env.CLINE_DIR
+		try {
+			expect(resolveDataDir()).toBe(path.join(os.homedir(), ".cline", "data"))
+		} finally {
+			process.env.CLINE_DATA_DIR = originalData
+			process.env.CLINE_DIR = originalDir
+		}
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readGlobalState
+// ---------------------------------------------------------------------------
+
+describe("readGlobalState", () => {
+	it("returns empty object when file is missing", () => {
+		expect(readGlobalState(tempDir)).toEqual({})
+	})
+
+	it("reads globalState.json contents", () => {
+		writeJson(path.join(tempDir, "globalState.json"), {
+			mode: "act",
+			actModeApiProvider: "anthropic",
+			actModeApiModelId: "claude-sonnet-4-6",
+			telemetrySetting: "enabled",
+		})
+
+		const state = readGlobalState(tempDir)
+		expect(state.mode).toBe("act")
+		expect(state.actModeApiProvider).toBe("anthropic")
+		expect(state.actModeApiModelId).toBe("claude-sonnet-4-6")
+		expect(state.telemetrySetting).toBe("enabled")
+	})
+
+	it("returns empty object for corrupt JSON", () => {
+		const filePath = path.join(tempDir, "globalState.json")
+		fs.mkdirSync(tempDir, { recursive: true })
+		fs.writeFileSync(filePath, "NOT VALID JSON{{{")
+
+		expect(readGlobalState(tempDir)).toEqual({})
+	})
+
+	it("returns empty object for empty file", () => {
+		const filePath = path.join(tempDir, "globalState.json")
+		fs.mkdirSync(tempDir, { recursive: true })
+		fs.writeFileSync(filePath, "")
+
+		expect(readGlobalState(tempDir)).toEqual({})
+	})
+
+	it("returns empty object for {} file", () => {
+		writeJson(path.join(tempDir, "globalState.json"), {})
+
+		expect(readGlobalState(tempDir)).toEqual({})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readGlobalStateKey
+// ---------------------------------------------------------------------------
+
+describe("readGlobalStateKey", () => {
+	it("returns undefined for missing key", () => {
+		writeJson(path.join(tempDir, "globalState.json"), { mode: "act" })
+		expect(readGlobalStateKey("telemetrySetting", tempDir)).toBeUndefined()
+	})
+
+	it("returns value for present key", () => {
+		writeJson(path.join(tempDir, "globalState.json"), { mode: "plan" })
+		expect(readGlobalStateKey("mode", tempDir)).toBe("plan")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readSecrets
+// ---------------------------------------------------------------------------
+
+describe("readSecrets", () => {
+	it("returns empty object when file is missing", () => {
+		expect(readSecrets(tempDir)).toEqual({})
+	})
+
+	it("reads secrets.json contents", () => {
+		writeJson(path.join(tempDir, "secrets.json"), {
+			apiKey: "sk-ant-test123",
+			openRouterApiKey: "sk-or-test456",
+		})
+
+		const secrets = readSecrets(tempDir)
+		expect(secrets.apiKey).toBe("sk-ant-test123")
+		expect(secrets.openRouterApiKey).toBe("sk-or-test456")
+	})
+
+	it("returns empty object for corrupt JSON", () => {
+		const filePath = path.join(tempDir, "secrets.json")
+		fs.mkdirSync(tempDir, { recursive: true })
+		fs.writeFileSync(filePath, "BROKEN{")
+
+		expect(readSecrets(tempDir)).toEqual({})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readSecretKey
+// ---------------------------------------------------------------------------
+
+describe("readSecretKey", () => {
+	it("returns undefined for missing key", () => {
+		writeJson(path.join(tempDir, "secrets.json"), { apiKey: "test" })
+		expect(readSecretKey("openRouterApiKey", tempDir)).toBeUndefined()
+	})
+
+	it("returns value for present key", () => {
+		writeJson(path.join(tempDir, "secrets.json"), { apiKey: "sk-test" })
+		expect(readSecretKey("apiKey", tempDir)).toBe("sk-test")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readTaskHistory
+// ---------------------------------------------------------------------------
+
+describe("readTaskHistory", () => {
+	it("returns empty array when file is missing", () => {
+		expect(readTaskHistory(tempDir)).toEqual([])
+	})
+
+	it("reads taskHistory.json from state/ subdirectory", () => {
+		const history = [
+			{
+				id: "task-1",
+				ts: Date.now(),
+				task: "Hello world",
+				tokensIn: 100,
+				tokensOut: 50,
+				totalCost: 0.01,
+			},
+			{
+				id: "task-2",
+				ts: Date.now() + 1000,
+				task: "Second task",
+				tokensIn: 200,
+				tokensOut: 100,
+				totalCost: 0.02,
+				isFavorited: true,
+			},
+		]
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), history)
+
+		const result = readTaskHistory(tempDir)
+		expect(result).toHaveLength(2)
+		expect(result[0].id).toBe("task-1")
+		expect(result[1].isFavorited).toBe(true)
+	})
+
+	it("returns empty array for corrupt JSON", () => {
+		const filePath = path.join(tempDir, "state", "taskHistory.json")
+		fs.mkdirSync(path.dirname(filePath), { recursive: true })
+		fs.writeFileSync(filePath, "INVALID")
+
+		expect(readTaskHistory(tempDir)).toEqual([])
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readApiConversationHistory
+// ---------------------------------------------------------------------------
+
+describe("readApiConversationHistory", () => {
+	it("returns empty array when file is missing", () => {
+		expect(readApiConversationHistory("task-1", tempDir)).toEqual([])
+	})
+
+	it("reads api_conversation_history.json", () => {
+		const history = [
+			{ role: "user", content: [{ type: "text", text: "Hello" }] },
+			{ role: "assistant", content: [{ type: "text", text: "Hi there" }] },
+		]
+		writeJson(path.join(tempDir, "tasks", "task-1", "api_conversation_history.json"), history)
+
+		const result = readApiConversationHistory("task-1", tempDir)
+		expect(result).toHaveLength(2)
+		expect(result[0].role).toBe("user")
+		expect(result[1].role).toBe("assistant")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readUiMessages
+// ---------------------------------------------------------------------------
+
+describe("readUiMessages", () => {
+	it("returns empty array when file is missing", () => {
+		expect(readUiMessages("task-1", tempDir)).toEqual([])
+	})
+
+	it("reads ui_messages.json", () => {
+		const messages = [
+			{ type: "say", say: "text", text: "Hello" },
+			{ type: "ask", ask: "tool", text: "Run command?" },
+		]
+		writeJson(path.join(tempDir, "tasks", "task-1", "ui_messages.json"), messages)
+
+		const result = readUiMessages("task-1", tempDir)
+		expect(result).toHaveLength(2)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readContextHistory
+// ---------------------------------------------------------------------------
+
+describe("readContextHistory", () => {
+	it("returns empty array when file is missing", () => {
+		expect(readContextHistory("task-1", tempDir)).toEqual([])
+	})
+
+	it("reads context_history.json", () => {
+		const history = [{ context: "test" }]
+		writeJson(path.join(tempDir, "tasks", "task-1", "context_history.json"), history)
+
+		const result = readContextHistory("task-1", tempDir)
+		expect(result).toHaveLength(1)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readTaskMetadata
+// ---------------------------------------------------------------------------
+
+describe("readTaskMetadata", () => {
+	it("returns empty object when file is missing", () => {
+		expect(readTaskMetadata("task-1", tempDir)).toEqual({})
+	})
+
+	it("reads task_metadata.json", () => {
+		const metadata = { files_in_context: ["src/index.ts"], model_usage: [] }
+		writeJson(path.join(tempDir, "tasks", "task-1", "task_metadata.json"), metadata)
+
+		const result = readTaskMetadata("task-1", tempDir)
+		expect(result.files_in_context).toEqual(["src/index.ts"])
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readMcpSettings
+// ---------------------------------------------------------------------------
+
+describe("readMcpSettings", () => {
+	it("returns empty mcpServers when file is missing", () => {
+		expect(readMcpSettings(tempDir)).toEqual({ mcpServers: {} })
+	})
+
+	it("reads cline_mcp_settings.json from settings/ subdirectory", () => {
+		const settings: McpSettingsFile = {
+			mcpServers: {
+				"my-server": {
+					command: "node",
+					args: ["server.js"],
+					env: { API_KEY: "test" },
+				},
+				"remote-server": {
+					url: "https://mcp.example.com/sse",
+					transport: "sse",
+					disabled: true,
+				},
+			},
+		}
+		writeJson(path.join(tempDir, "settings", "cline_mcp_settings.json"), settings)
+
+		const result = readMcpSettings(tempDir)
+		expect(Object.keys(result.mcpServers)).toHaveLength(2)
+		expect(result.mcpServers["my-server"].command).toBe("node")
+		expect(result.mcpServers["remote-server"].url).toBe("https://mcp.example.com/sse")
+		expect(result.mcpServers["remote-server"].disabled).toBe(true)
+	})
+
+	it("returns empty mcpServers for corrupt JSON", () => {
+		const filePath = path.join(tempDir, "settings", "cline_mcp_settings.json")
+		fs.mkdirSync(path.dirname(filePath), { recursive: true })
+		fs.writeFileSync(filePath, "NOT JSON")
+
+		expect(readMcpSettings(tempDir)).toEqual({ mcpServers: {} })
+	})
+})
+
+// ---------------------------------------------------------------------------
+// listTaskIds
+// ---------------------------------------------------------------------------
+
+describe("listTaskIds", () => {
+	it("returns empty array when tasks directory is missing", () => {
+		expect(listTaskIds(tempDir)).toEqual([])
+	})
+
+	it("lists task directories", () => {
+		fs.mkdirSync(path.join(tempDir, "tasks", "task-1"), { recursive: true })
+		fs.mkdirSync(path.join(tempDir, "tasks", "task-2"), { recursive: true })
+		// Create a file — should not be listed
+		fs.writeFileSync(path.join(tempDir, "tasks", "not-a-dir.txt"), "test")
+
+		const ids = listTaskIds(tempDir)
+		expect(ids).toContain("task-1")
+		expect(ids).toContain("task-2")
+		expect(ids).not.toContain("not-a-dir.txt")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// readAllLegacyState
+// ---------------------------------------------------------------------------
+
+describe("readAllLegacyState", () => {
+	it("returns defaults when no files exist", () => {
+		const state = readAllLegacyState(tempDir)
+		expect(state.globalState).toEqual({})
+		expect(state.secrets).toEqual({})
+		expect(state.taskHistory).toEqual([])
+		expect(state.mcpSettings).toEqual({ mcpServers: {} })
+	})
+
+	it("reads all state files at once", () => {
+		// Write all the files
+		writeJson(path.join(tempDir, "globalState.json"), {
+			mode: "act",
+			actModeApiProvider: "anthropic",
+		})
+		writeJson(path.join(tempDir, "secrets.json"), {
+			apiKey: "sk-ant-test",
+		})
+		writeJson(path.join(tempDir, "state", "taskHistory.json"), [
+			{ id: "task-1", ts: Date.now(), task: "Test", tokensIn: 0, tokensOut: 0, totalCost: 0 },
+		])
+		writeJson(path.join(tempDir, "settings", "cline_mcp_settings.json"), {
+			mcpServers: {
+				"test-server": { command: "node", args: ["mcp.js"] },
+			},
+		})
+
+		const state = readAllLegacyState(tempDir)
+		expect(state.globalState.mode).toBe("act")
+		expect(state.globalState.actModeApiProvider).toBe("anthropic")
+		expect(state.secrets.apiKey).toBe("sk-ant-test")
+		expect(state.taskHistory).toHaveLength(1)
+		expect(state.taskHistory[0].id).toBe("task-1")
+		expect(state.mcpSettings.mcpServers["test-server"].command).toBe("node")
+	})
+
+	it("handles partial state (some files missing)", () => {
+		// Only write globalState
+		writeJson(path.join(tempDir, "globalState.json"), { mode: "plan" })
+
+		const state = readAllLegacyState(tempDir)
+		expect(state.globalState.mode).toBe("plan")
+		expect(state.secrets).toEqual({})
+		expect(state.taskHistory).toEqual([])
+		expect(state.mcpSettings).toEqual({ mcpServers: {} })
+	})
+})
+
+// ---------------------------------------------------------------------------
+// Error handling edge cases
+// ---------------------------------------------------------------------------
+
+describe("error handling", () => {
+	it("handles unreadable files gracefully", () => {
+		const filePath = path.join(tempDir, "globalState.json")
+		fs.mkdirSync(tempDir, { recursive: true })
+		fs.writeFileSync(filePath, "valid json initially")
+		// Make file unreadable (on POSIX)
+		if (process.platform !== "win32") {
+			fs.chmodSync(filePath, 0o000)
+			// Should not throw, returns fallback
+			expect(readGlobalState(tempDir)).toEqual({})
+			// Restore permissions for cleanup
+			fs.chmodSync(filePath, 0o644)
+		}
+	})
+
+	it("handles whitespace-only files", () => {
+		const filePath = path.join(tempDir, "globalState.json")
+		fs.mkdirSync(tempDir, { recursive: true })
+		fs.writeFileSync(filePath, "   \n  \t  ")
+
+		expect(readGlobalState(tempDir)).toEqual({})
+	})
+})
diff --git a/apps/vscode/src/sdk/legacy-state-reader.ts b/apps/vscode/src/sdk/legacy-state-reader.ts
new file mode 100644
index 0000000..e90aadd
--- /dev/null
+++ b/apps/vscode/src/sdk/legacy-state-reader.ts
@@ -0,0 +1,301 @@
+// Replaces classic src/core/storage/disk.ts reads (see origin/main)
+//
+// Reads on-disk state written in the pre-SDK storage format from the Cline
+// data directory, so the SDK adapter can surface tasks and settings created
+// before the SDK migration.
+//
+// All reads are non-throwing — missing or corrupt files return defaults.
+
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { Anthropic } from "@anthropic-ai/sdk"
+import { ClineMessage } from "@shared/ExtensionMessage"
+import { HistoryItem } from "@shared/HistoryItem"
+import { Logger } from "@shared/services/Logger"
+import { GlobalStateAndSettings, Secrets } from "@shared/storage/state-keys"
+
+// ---------------------------------------------------------------------------
+// Path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the Cline data directory.
+ * Priority: CLINE_DATA_DIR env > CLINE_DIR env + "/data" > ~/.cline/data
+ */
+export function resolveDataDir(override?: string): string {
+	if (override) return override
+	if (process.env.CLINE_DATA_DIR) return process.env.CLINE_DATA_DIR
+	const clineDir = process.env.CLINE_DIR || path.join(os.homedir(), ".cline")
+	return path.join(clineDir, "data")
+}
+
+/** Path to globalState.json */
+function globalStatePath(dataDir?: string): string {
+	return path.join(resolveDataDir(dataDir), "globalState.json")
+}
+
+/** Path to secrets.json */
+function secretsPath(dataDir?: string): string {
+	return path.join(resolveDataDir(dataDir), "secrets.json")
+}
+
+/** Path to taskHistory.json (stored in state/ subdirectory) */
+function taskHistoryPath(dataDir?: string): string {
+	return path.join(resolveDataDir(dataDir), "state", "taskHistory.json")
+}
+
+/** Path to MCP settings file */
+function mcpSettingsPath(dataDir?: string): string {
+	return path.join(resolveDataDir(dataDir), "settings", "cline_mcp_settings.json")
+}
+
+/** Path to a task directory */
+function taskDirPath(taskId: string, dataDir?: string): string {
+	return path.join(resolveDataDir(dataDir), "tasks", taskId)
+}
+
+/** Path to api_conversation_history.json for a task */
+function apiConversationHistoryPath(taskId: string, dataDir?: string): string {
+	return path.join(taskDirPath(taskId, dataDir), "api_conversation_history.json")
+}
+
+/** Path to ui_messages.json for a task */
+function uiMessagesPath(taskId: string, dataDir?: string): string {
+	return path.join(taskDirPath(taskId, dataDir), "ui_messages.json")
+}
+
+/** Path to context_history.json for a task */
+function contextHistoryPath(taskId: string, dataDir?: string): string {
+	return path.join(taskDirPath(taskId, dataDir), "context_history.json")
+}
+
+/** Path to task_metadata.json for a task */
+function taskMetadataPath(taskId: string, dataDir?: string): string {
+	return path.join(taskDirPath(taskId, dataDir), "task_metadata.json")
+}
+
+// ---------------------------------------------------------------------------
+// Low-level JSON reader
+// ---------------------------------------------------------------------------
+
+/**
+ * Read and parse a JSON file, returning undefined on any error.
+ * Never throws — returns fallback instead.
+ */
+function readJsonFile<T>(filePath: string, fallback: T): T {
+	try {
+		if (!fs.existsSync(filePath)) {
+			return fallback
+		}
+		const content = fs.readFileSync(filePath, "utf-8").trim()
+		if (!content || content === "{}") {
+			return fallback
+		}
+		return JSON.parse(content) as T
+	} catch (error) {
+		Logger.warn(`[LegacyStateReader] Failed to read ${filePath}:`, error)
+		return fallback
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Global state
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the full globalState.json contents.
+ * Returns a partial record — only keys present on disk are included.
+ */
+export function readGlobalState(dataDir?: string): Partial<GlobalStateAndSettings> {
+	return readJsonFile<Partial<GlobalStateAndSettings>>(globalStatePath(dataDir), {})
+}
+
+/**
+ * Read a single key from globalState.json.
+ */
+export function readGlobalStateKey<K extends keyof GlobalStateAndSettings>(
+	key: K,
+	dataDir?: string,
+): GlobalStateAndSettings[K] | undefined {
+	const state = readGlobalState(dataDir)
+	return state[key]
+}
+
+// ---------------------------------------------------------------------------
+// Secrets
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the full secrets.json contents.
+ * Returns a partial record — only keys present on disk are included.
+ */
+export function readSecrets(dataDir?: string): Partial<Secrets> {
+	return readJsonFile<Partial<Secrets>>(secretsPath(dataDir), {})
+}
+
+/**
+ * Read a single key from secrets.json.
+ */
+export function readSecretKey<K extends keyof Secrets>(key: K, dataDir?: string): Secrets[K] | undefined {
+	const secrets = readSecrets(dataDir)
+	return secrets[key]
+}
+
+// ---------------------------------------------------------------------------
+// Task history
+// ---------------------------------------------------------------------------
+
+/**
+ * Read taskHistory.json from the state directory.
+ * Returns an empty array if the file is missing or corrupt.
+ */
+export function readTaskHistory(dataDir?: string): HistoryItem[] {
+	return readJsonFile<HistoryItem[]>(taskHistoryPath(dataDir), [])
+}
+
+/**
+ * Delete a legacy task from taskHistory.json and remove its task artifact directory.
+ * Returns true when the task existed in legacy history.
+ */
+export function deleteLegacyTask(taskId: string, dataDir?: string): boolean {
+	const historyPath = taskHistoryPath(dataDir)
+	const history = readTaskHistory(dataDir)
+	const filteredHistory = history.filter((item) => item.id !== taskId)
+	const existed = filteredHistory.length !== history.length
+
+	try {
+		if (existed) {
+			fs.mkdirSync(path.dirname(historyPath), { recursive: true })
+			fs.writeFileSync(historyPath, JSON.stringify(filteredHistory, null, 2), "utf-8")
+		}
+		fs.rmSync(taskDirPath(taskId, dataDir), { recursive: true, force: true })
+	} catch (error) {
+		Logger.warn(`[LegacyStateReader] Failed to delete legacy task ${taskId}:`, error)
+	}
+
+	return existed
+}
+
+// ---------------------------------------------------------------------------
+// Per-task data
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the API conversation history for a specific task.
+ * Returns an empty array if the file is missing or corrupt.
+ */
+export function readApiConversationHistory(taskId: string, dataDir?: string): Anthropic.MessageParam[] {
+	return readJsonFile<Anthropic.MessageParam[]>(apiConversationHistoryPath(taskId, dataDir), [])
+}
+
+/**
+ * Read the UI messages for a specific task.
+ * Returns an empty array if the file is missing or corrupt.
+ */
+export function readUiMessages(taskId: string, dataDir?: string): ClineMessage[] {
+	return readJsonFile<ClineMessage[]>(uiMessagesPath(taskId, dataDir), [])
+}
+
+/**
+ * Read the context history for a specific task.
+ * Returns an empty array if the file is missing or corrupt.
+ */
+export function readContextHistory(taskId: string, dataDir?: string): unknown[] {
+	return readJsonFile<unknown[]>(contextHistoryPath(taskId, dataDir), [])
+}
+
+/**
+ * Read task metadata for a specific task.
+ * Returns an empty object if the file is missing or corrupt.
+ */
+export function readTaskMetadata(taskId: string, dataDir?: string): Record<string, unknown> {
+	return readJsonFile<Record<string, unknown>>(taskMetadataPath(taskId, dataDir), {})
+}
+
+// ---------------------------------------------------------------------------
+// MCP settings
+// ---------------------------------------------------------------------------
+
+/** Shape of the MCP settings file */
+export interface McpSettingsFile {
+	mcpServers: Record<
+		string,
+		{
+			/** Command to run (stdio transport) */
+			command?: string
+			/** Arguments for the command */
+			args?: string[]
+			/** Environment variables */
+			env?: Record<string, string>
+			/** URL for SSE/streamableHTTP transport */
+			url?: string
+			/** Whether the server is disabled */
+			disabled?: boolean
+			/** Auto-approve settings for tools */
+			autoApprove?: string[]
+			/** Timeout in milliseconds */
+			timeout?: number
+			/** Transport type */
+			transport?: "stdio" | "sse" | "streamableHttp"
+		}
+	>
+}
+
+/**
+ * Read the MCP settings file.
+ * Returns an empty mcpServers object if the file is missing or corrupt.
+ */
+export function readMcpSettings(dataDir?: string): McpSettingsFile {
+	return readJsonFile<McpSettingsFile>(mcpSettingsPath(dataDir), { mcpServers: {} })
+}
+
+// ---------------------------------------------------------------------------
+// Task directory listing
+// ---------------------------------------------------------------------------
+
+/**
+ * List all task IDs that have directories on disk.
+ * Returns an empty array if the tasks directory doesn't exist.
+ */
+export function listTaskIds(dataDir?: string): string[] {
+	const tasksDir = path.join(resolveDataDir(dataDir), "tasks")
+	try {
+		if (!fs.existsSync(tasksDir)) {
+			return []
+		}
+		return fs
+			.readdirSync(tasksDir, { withFileTypes: true })
+			.filter((dirent) => dirent.isDirectory())
+			.map((dirent) => dirent.name)
+	} catch (error) {
+		Logger.warn(`[LegacyStateReader] Failed to list tasks in ${tasksDir}:`, error)
+		return []
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Composite reader
+// ---------------------------------------------------------------------------
+
+/** All legacy state read from disk in a single call */
+export interface LegacyState {
+	globalState: Partial<GlobalStateAndSettings>
+	secrets: Partial<Secrets>
+	taskHistory: HistoryItem[]
+	mcpSettings: McpSettingsFile
+}
+
+/**
+ * Read all legacy state from disk in a single call.
+ * This is the primary entry point for bootstrapping the SDK adapter
+ * from existing on-disk data.
+ */
+export function readAllLegacyState(dataDir?: string): LegacyState {
+	return {
+		globalState: readGlobalState(dataDir),
+		secrets: readSecrets(dataDir),
+		taskHistory: readTaskHistory(dataDir),
+		mcpSettings: readMcpSettings(dataDir),
+	}
+}
diff --git a/apps/vscode/src/sdk/message-id-minter.test.ts b/apps/vscode/src/sdk/message-id-minter.test.ts
new file mode 100644
index 0000000..805681e
--- /dev/null
+++ b/apps/vscode/src/sdk/message-id-minter.test.ts
@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest"
+import { MessageIdMinter } from "./message-id-minter"
+
+describe("MessageIdMinter", () => {
+	it("mints strictly increasing, unique ids", () => {
+		const minter = new MessageIdMinter()
+		const ids = Array.from({ length: 1000 }, () => minter.nextId())
+		// strictly increasing
+		for (let i = 1; i < ids.length; i++) {
+			expect(ids[i]).toBeGreaterThan(ids[i - 1])
+		}
+		// unique
+		expect(new Set(ids).size).toBe(ids.length)
+	})
+
+	it("never reads the clock — ids are deterministic from the seed", () => {
+		const a = new MessageIdMinter(0)
+		const b = new MessageIdMinter(0)
+		expect([a.nextId(), a.nextId(), a.nextId()]).toEqual([b.nextId(), b.nextId(), b.nextId()])
+	})
+
+	it("respects a starting seed so ids stay increasing across constructions", () => {
+		const first = new MessageIdMinter(0)
+		first.nextId()
+		first.nextId()
+		const next = new MessageIdMinter(first.epoch /* irrelevant */ + 2)
+		// A fresh minter seeded past the previous high water never reuses an old id.
+		expect(next.nextId()).toBeGreaterThan(2)
+	})
+
+	it("seq advances independently of id", () => {
+		const minter = new MessageIdMinter()
+		minter.nextId()
+		const s1 = minter.nextSeq()
+		minter.nextId()
+		minter.nextId()
+		const s2 = minter.nextSeq()
+		expect(s2).toBeGreaterThan(s1)
+		expect(minter.seq).toBe(s2)
+	})
+
+	it("epoch only advances on bumpEpoch, independent of id/seq", () => {
+		const minter = new MessageIdMinter()
+		expect(minter.epoch).toBe(0)
+		minter.nextId()
+		minter.nextSeq()
+		expect(minter.epoch).toBe(0)
+		expect(minter.bumpEpoch()).toBe(1)
+		expect(minter.bumpEpoch()).toBe(2)
+		expect(minter.epoch).toBe(2)
+	})
+
+	it("the three counters are mutually independent", () => {
+		const minter = new MessageIdMinter()
+		minter.nextId()
+		minter.nextId()
+		minter.bumpEpoch()
+		minter.nextSeq()
+		// id advanced by 2, seq by 1, epoch by 1 — no cross-contamination
+		expect(minter.nextId()).toBe(3)
+		expect(minter.nextSeq()).toBe(2)
+		expect(minter.bumpEpoch()).toBe(2)
+	})
+
+	it("models the cross-generator collision scenario being prevented: one shared minter cannot collide", () => {
+		// Simulate the old bug: the translator and the interaction coordinator both mint from the
+		// SAME shared minter. Interleave them arbitrarily; ids must remain globally unique.
+		const minter = new MessageIdMinter()
+		const translatorIds: number[] = []
+		const interactionIds: number[] = []
+		for (let i = 0; i < 50; i++) {
+			translatorIds.push(minter.nextId())
+			if (i % 3 === 0) {
+				interactionIds.push(minter.nextId())
+			}
+		}
+		const all = [...translatorIds, ...interactionIds]
+		expect(new Set(all).size).toBe(all.length)
+	})
+})
diff --git a/apps/vscode/src/sdk/message-id-minter.ts b/apps/vscode/src/sdk/message-id-minter.ts
new file mode 100644
index 0000000..aa155fe
--- /dev/null
+++ b/apps/vscode/src/sdk/message-id-minter.ts
@@ -0,0 +1,73 @@
+// Single source of truth for ClineMessage identity (`id`), update freshness (`seq`),
+// and the conversation/replica fence (`epoch`).
+//
+// Rationale (why this exists):
+// - `ClineMessage.ts` is used as a message IDENTITY / merge key, not as a wall clock. It
+//   was historically minted from Date.now() in TWO independent places (the live translator
+//   and the interaction coordinator), which can COLLIDE: the translator's pure-increment
+//   counter drifts behind wall-clock and can later catch up to a clock-based value minted by
+//   the interaction coordinator. A single monotonic minter makes collisions impossible.
+// - `seq` is a separate per-update freshness counter so the webview can resolve "two copies
+//   of the same id — which is newer" independent of delivery order.
+// - `epoch` fences off traffic from a previous task / a previous render of the same task.
+//
+// All three are pure in-memory counters. Nothing here reads the clock per message.
+
+/**
+ * Process-wide authority for `id`, `seq`, and `epoch`.
+ *
+ * One instance per extension process, owned by SdkController and shared by:
+ * - live SDK event translation (MessageTranslatorState),
+ * - the interaction coordinator (tool approval / ask_question / user_feedback),
+ * - history rendering (sdkMessagesToClineMessages).
+ *
+ * This guarantees every `id` is globally unique and monotonically increasing within the
+ * process, so regenerated history ids never overlap live ids.
+ */
+export class MessageIdMinter {
+	private idCounter: number
+	private seqCounter = 0
+	private epochCounter = 0
+
+	/**
+	 * @param seed Starting value for the id counter. Defaults to 0. A seed is only useful to
+	 * keep ids increasing across constructions in tests; production uses a single long-lived
+	 * instance, so the default is fine. Never derived from the clock per message.
+	 */
+	constructor(seed = 0) {
+		this.idCounter = seed
+	}
+
+	/** Mint a NEW unique message id (identity). Called once per new logical message. */
+	nextId(): number {
+		return ++this.idCounter
+	}
+
+	/**
+	 * Advance and return the freshness counter. Call synchronously at the moment a message is
+	 * created/updated AND at the moment a state snapshot is assembled — before any await — so
+	 * the resulting total order matches causal order regardless of delivery timing.
+	 */
+	nextSeq(): number {
+		return ++this.seqCounter
+	}
+
+	/** The current freshness counter without advancing it. */
+	get seq(): number {
+		return this.seqCounter
+	}
+
+	/**
+	 * Bump the conversation/replica fence. Called once per boundary (task start/clear, history
+	 * open, reinit/resume, mode rebuild that swaps the session, new-session follow-up, cancel)
+	 * — synchronously, BEFORE the new state is pushed. NOT on iteration_start / streaming.
+	 */
+	bumpEpoch(): number {
+		return ++this.epochCounter
+	}
+
+	/** The current epoch (fence) value. */
+	get epoch(): number {
+		return this.epochCounter
+	}
+}
diff --git a/apps/vscode/src/sdk/message-translator-approval-denial.test.ts b/apps/vscode/src/sdk/message-translator-approval-denial.test.ts
new file mode 100644
index 0000000..145730d
--- /dev/null
+++ b/apps/vscode/src/sdk/message-translator-approval-denial.test.ts
@@ -0,0 +1,113 @@
+import type { CoreSessionEvent } from "@cline/core"
+import type { AgentEvent } from "@cline/shared"
+import { describe, expect, it } from "vitest"
+import { MessageTranslatorState, translateSessionEvent } from "./message-translator"
+import { DEFAULT_TOOL_APPROVAL_DENIAL_REASON, USER_MESSAGE_TOOL_APPROVAL_DENIAL_REASON } from "./tool-approval-denial"
+
+describe("translateSessionEvent - user-message tool approval denial", () => {
+	it("suppresses tool lifecycle events for approval replies routed as user feedback", () => {
+		const state = new MessageTranslatorState()
+		state.recordDeniedToolApproval("call-1", "fetch_web_content", USER_MESSAGE_TOOL_APPROVAL_DENIAL_REASON)
+
+		const startEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "fetch_web_content",
+					toolCallId: "call-1",
+					input: {
+						requests: [{ url: "https://example.com", prompt: "Read it" }],
+					},
+				} as AgentEvent,
+			},
+		}
+		const endEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_end",
+					contentType: "tool",
+					toolName: "fetch_web_content",
+					toolCallId: "call-1",
+					error: USER_MESSAGE_TOOL_APPROVAL_DENIAL_REASON,
+				} as AgentEvent,
+			},
+		}
+
+		const startResult = translateSessionEvent(startEvent, state)
+		const endResult = translateSessionEvent(endEvent, state)
+
+		expect(startResult.messages).toHaveLength(0)
+		expect(endResult.messages).toHaveLength(0)
+		expect(endResult.toolError).toBeUndefined()
+		expect(endResult.toolSuccess).toBeUndefined()
+	})
+
+	it("suppresses generic no-button approval denials", () => {
+		const state = new MessageTranslatorState()
+		state.recordDeniedToolApproval("call-1", "fetch_web_content", DEFAULT_TOOL_APPROVAL_DENIAL_REASON)
+
+		const endEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_end",
+					contentType: "tool",
+					toolName: "fetch_web_content",
+					toolCallId: "call-1",
+					error: `{"error":"${DEFAULT_TOOL_APPROVAL_DENIAL_REASON}"}`,
+				} as AgentEvent,
+			},
+		}
+		const mistakeEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: new Error(
+						`1 tool call(s) failed: [fetch_web_content] {"error":"${DEFAULT_TOOL_APPROVAL_DENIAL_REASON}"}`,
+					),
+					recoverable: true,
+					iteration: 1,
+				} as AgentEvent,
+			},
+		}
+
+		const endResult = translateSessionEvent(endEvent, state)
+		const mistakeResult = translateSessionEvent(mistakeEvent, state)
+
+		expect(endResult.messages).toHaveLength(0)
+		expect(endResult.toolError).toBeUndefined()
+		expect(mistakeResult.messages).toHaveLength(0)
+		expect(mistakeResult.turnComplete).toBe(false)
+	})
+
+	it("suppresses mistake errors caused by approval replies routed as user feedback", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: new Error(
+						`1 tool call(s) failed: [fetch_web_content] {"error":"${USER_MESSAGE_TOOL_APPROVAL_DENIAL_REASON}"}`,
+					),
+					recoverable: true,
+					iteration: 1,
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+
+		expect(result.messages).toHaveLength(0)
+		expect(result.turnComplete).toBe(false)
+	})
+})
diff --git a/apps/vscode/src/sdk/message-translator.test.ts b/apps/vscode/src/sdk/message-translator.test.ts
new file mode 100644
index 0000000..4b574b0
--- /dev/null
+++ b/apps/vscode/src/sdk/message-translator.test.ts
@@ -0,0 +1,3162 @@
+import type { CoreSessionEvent } from "@cline/core"
+import type { AgentEvent } from "@cline/shared"
+import type { ClineAskUseMcpServer } from "@shared/ExtensionMessage"
+import { describe, expect, it } from "vitest"
+import {
+	extractToolOutputText,
+	historyItemToSessionFields,
+	MessageTranslatorState,
+	translateSessionEvent,
+} from "./message-translator"
+
+// ---------------------------------------------------------------------------
+// MessageTranslatorState
+// ---------------------------------------------------------------------------
+
+describe("MessageTranslatorState", () => {
+	it("generates unique timestamps", () => {
+		const state = new MessageTranslatorState()
+		const ts1 = state.nextTs()
+		const ts2 = state.nextTs()
+		expect(ts2).toBeGreaterThan(ts1)
+	})
+
+	it("tracks streaming text timestamps", () => {
+		const state = new MessageTranslatorState()
+		const ts1 = state.getStreamingTextTs()
+		const ts2 = state.getStreamingTextTs()
+		// Same ts while streaming
+		expect(ts2).toBe(ts1)
+	})
+
+	it("clears streaming text and returns the ts", () => {
+		const state = new MessageTranslatorState()
+		const ts = state.getStreamingTextTs()
+		const cleared = state.clearStreamingText()
+		expect(cleared).toBe(ts)
+
+		// Next call should get a new ts
+		const newTs = state.getStreamingTextTs()
+		expect(newTs).toBeGreaterThan(ts)
+	})
+
+	it("clearStreamingText without prior get returns a new ts", () => {
+		const state = new MessageTranslatorState()
+		const ts = state.clearStreamingText()
+		expect(typeof ts).toBe("number")
+	})
+
+	it("tracks streaming reasoning timestamps", () => {
+		const state = new MessageTranslatorState()
+		const ts1 = state.getStreamingReasoningTs()
+		const ts2 = state.getStreamingReasoningTs()
+		expect(ts2).toBe(ts1)
+
+		const cleared = state.clearStreamingReasoning()
+		expect(cleared).toBe(ts1)
+
+		const newTs = state.getStreamingReasoningTs()
+		expect(newTs).toBeGreaterThan(ts1)
+	})
+
+	it("tracks streaming tool timestamps", () => {
+		const state = new MessageTranslatorState()
+		const ts1 = state.getStreamingToolTs()
+		const ts2 = state.getStreamingToolTs()
+		expect(ts2).toBe(ts1)
+
+		const cleared = state.clearStreamingTool()
+		expect(cleared).toBe(ts1)
+
+		const newTs = state.getStreamingToolTs()
+		expect(newTs).toBeGreaterThan(ts1)
+	})
+
+	it("reset clears all streaming state", () => {
+		const state = new MessageTranslatorState()
+		const textTs = state.getStreamingTextTs()
+		const reasoningTs = state.getStreamingReasoningTs()
+		const toolTs = state.getStreamingToolTs()
+
+		state.reset()
+
+		// After reset, new streaming ts should be different
+		const newTextTs = state.getStreamingTextTs()
+		const newReasoningTs = state.getStreamingReasoningTs()
+		const newToolTs = state.getStreamingToolTs()
+
+		expect(newTextTs).toBeGreaterThan(textTs)
+		expect(newReasoningTs).toBeGreaterThan(reasoningTs)
+		expect(newToolTs).toBeGreaterThan(toolTs)
+	})
+
+	it("reset clears stale approved tool prompt rows", () => {
+		const state = new MessageTranslatorState()
+		state.recordApprovedToolMessageTs("approved-call", 42)
+
+		state.reset()
+
+		expect(state.consumeApprovedToolMessageTs("approved-call")).toBeUndefined()
+	})
+
+	it("reset() (per-iteration) does NOT clear attemptCompletionSeen — it is turn-scoped", () => {
+		// The agent can call the completion tool in one iteration and the loop then emits another
+		// `iteration_start` → state.reset() before the turn's `done` event. The completion signal
+		// is turn-scoped and must survive per-iteration resets; otherwise the turn-end phase
+		// resolves to awaiting_followup instead of completed and the footer shows no
+		// "Start New Task" button despite the green "Task Completed" box.
+		const state = new MessageTranslatorState()
+		state.setAttemptCompletionSeen()
+		expect(state.wasAttemptCompletionSeen()).toBe(true)
+
+		state.reset() // simulates the next iteration_start mid-turn
+
+		expect(state.wasAttemptCompletionSeen()).toBe(true)
+	})
+
+	it("clearTurnOutcome() clears attemptCompletionSeen for a genuinely new turn/task", () => {
+		const state = new MessageTranslatorState()
+		state.setAttemptCompletionSeen()
+		state.clearTurnOutcome()
+		expect(state.wasAttemptCompletionSeen()).toBe(false)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — chunk events
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — chunk events", () => {
+	it("ignores agent stream chunks (raw model output not displayed)", () => {
+		// Chunk events contain raw model output which may include JSON,
+		// tool call fragments, etc. The structured agent_event system
+		// (content_start/update/end) is used for displayable content.
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "chunk",
+			payload: {
+				sessionId: "session-1",
+				stream: "agent",
+				chunk: '{"type":"iteration_start",...}',
+				ts: Date.now(),
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(0)
+		expect(result.sessionEnded).toBe(false)
+		expect(result.turnComplete).toBe(false)
+	})
+
+	it("ignores stdout/stderr chunks", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "chunk",
+			payload: {
+				sessionId: "session-1",
+				stream: "stdout",
+				chunk: "some output",
+				ts: Date.now(),
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(0)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — pending prompts
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — pending prompts", () => {
+	it("renders a submitted queued prompt as user feedback", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "pending_prompt_submitted",
+			payload: {
+				sessionId: "session-1",
+				id: "pending-1",
+				prompt: "please just finish",
+				delivery: "queue",
+				attachmentCount: 2,
+				userImages: ["image.png"],
+				userFiles: ["notes.txt"],
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+
+		expect(result.messages).toEqual([
+			expect.objectContaining({
+				type: "say",
+				say: "user_feedback",
+				text: "please just finish",
+				images: ["image.png"],
+				files: ["notes.txt"],
+				partial: false,
+			}),
+		])
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — agent_event (content_start)
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event content_start", () => {
+	it("reuses the approved tool prompt row for the matching tool lifecycle", () => {
+		const state = new MessageTranslatorState()
+		const approvedMessageTs = 42
+		state.recordApprovedToolMessageTs("approved-call", approvedMessageTs)
+
+		const startResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "approved-call",
+						input: {
+							path: "/src/app.ts",
+							old_text: "return false",
+							new_text: "return true",
+						},
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(startResult.messages).toHaveLength(1)
+		expect(startResult.messages[0]).toMatchObject({
+			ts: approvedMessageTs,
+			type: "say",
+			say: "tool",
+			partial: true,
+		})
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "approved-call",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(endResult.messages).toHaveLength(1)
+		expect(endResult.messages[0]).toMatchObject({
+			ts: approvedMessageTs,
+			type: "say",
+			say: "tool",
+			partial: false,
+		})
+		expect(JSON.parse(endResult.messages[0].text ?? "{}")).toMatchObject({
+			tool: "editedExistingFile",
+			path: "/src/app.ts",
+		})
+	})
+
+	it("reuses the approved command prompt row for the matching command lifecycle", () => {
+		const state = new MessageTranslatorState()
+		const approvedMessageTs = state.nextTs()
+		state.recordApprovedToolMessageTs("command-call", approvedMessageTs)
+
+		const startResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "execute_command",
+						toolCallId: "command-call",
+						input: { command: "npm test" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(startResult.messages[0]).toMatchObject({
+			ts: approvedMessageTs,
+			type: "say",
+			say: "command",
+			partial: true,
+		})
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "execute_command",
+						toolCallId: "command-call",
+						output: [{ result: "passed", success: true }],
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(endResult.messages[0]).toMatchObject({
+			ts: approvedMessageTs,
+			type: "say",
+			say: "command",
+			partial: false,
+			commandCompleted: true,
+		})
+	})
+
+	it("reuses the approved MCP prompt row for the matching MCP tool lifecycle", () => {
+		const state = new MessageTranslatorState()
+		const approvedMessageTs = state.nextTs()
+		state.recordApprovedToolMessageTs("mcp-call", approvedMessageTs)
+
+		const startResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "notion__notion-get-users",
+						toolCallId: "mcp-call",
+						input: { user_id: "self" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(startResult.messages[0]).toMatchObject({
+			ts: approvedMessageTs,
+			type: "say",
+			say: "use_mcp_server",
+			partial: true,
+		})
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "notion__notion-get-users",
+						toolCallId: "mcp-call",
+						output: "ok",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(endResult.messages[0]).toMatchObject({
+			ts: approvedMessageTs,
+			type: "say",
+			say: "use_mcp_server",
+			partial: false,
+		})
+	})
+
+	it("consumes an approved prompt row only once", () => {
+		const state = new MessageTranslatorState()
+		const approvedMessageTs = state.nextTs()
+		state.recordApprovedToolMessageTs("approved-call", approvedMessageTs)
+
+		const firstStart = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "approved-call",
+						input: { path: "/src/app.ts", old_text: "a", new_text: "b" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "approved-call",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const secondStart = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "approved-call",
+						input: { path: "/src/app.ts", old_text: "b", new_text: "c" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(firstStart.messages[0].ts).toBe(approvedMessageTs)
+		expect(secondStart.messages[0].ts).not.toBe(approvedMessageTs)
+	})
+
+	it("translates text content_start to partial text message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "text",
+					text: "Hello",
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("text")
+		expect(result.messages[0].text).toBe("Hello")
+		expect(result.messages[0].partial).toBe(true)
+	})
+
+	it("translates reasoning content_start to partial reasoning message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "reasoning",
+					reasoning: "Let me think...",
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("reasoning")
+		expect(result.messages[0].text).toBe("Let me think...")
+		expect(result.messages[0].reasoning).toBe("Let me think...")
+		expect(result.messages[0].partial).toBe(true)
+	})
+
+	it("translates tool content_start to partial tool message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "read_files",
+					toolCallId: "call-1",
+					input: { path: "/src/index.ts" },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("tool")
+		expect(result.messages[0].partial).toBe(true)
+		// sdkToolToClineSayTool converts "read_files" → "readFile" and
+		// the text is JSON.stringify(ClineSayTool)
+		expect(result.messages[0].text).toContain("readFile")
+		expect(result.messages[0].text).toContain("/src/index.ts")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — agent_event (content_end)
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event content_end", () => {
+	it("translates text content_end to complete text message", () => {
+		const state = new MessageTranslatorState()
+		// First, start streaming
+		const startEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "text",
+					text: "Hello",
+				} as AgentEvent,
+			},
+		}
+		translateSessionEvent(startEvent, state)
+
+		// Then end it
+		const endEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_end",
+					contentType: "text",
+					text: "Hello world",
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(endEvent, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("text")
+		expect(result.messages[0].text).toBe("Hello world")
+		expect(result.messages[0].partial).toBe(false)
+	})
+
+	it("translates tool content_end with error", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_end",
+					contentType: "tool",
+					toolName: "read_files",
+					toolCallId: "call-1",
+					error: "Command not found",
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		// Error produces two messages: the tool message + an error message
+		expect(result.messages).toHaveLength(2)
+		expect(result.messages[0].say).toBe("tool")
+		expect(result.messages[0].partial).toBe(false)
+		expect(result.messages[1].say).toBe("error")
+		expect(result.messages[1].text).toBe("Command not found")
+		expect(result.messages[1].partial).toBe(false)
+	})
+
+	it("translates tool content_end with output", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_end",
+					contentType: "tool",
+					toolName: "read_files",
+					toolCallId: "call-1",
+					output: "file contents here",
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		// Tool content_end produces a ClineSayTool JSON with the tool name
+		expect(result.messages[0].say).toBe("tool")
+		expect(result.messages[0].text).toContain("readFile")
+		expect(result.messages[0].partial).toBe(false)
+	})
+
+	it("content_end preserves tool input from content_start (S6-24 fix)", () => {
+		const state = new MessageTranslatorState()
+		const expectedDiff = "------- SEARCH\nconsole.log('world')\n=======\nconsole.log('hello')\n+++++++ REPLACE"
+
+		// 1. content_start with editor tool input
+		const startEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "editor",
+					toolCallId: "call-1",
+					input: {
+						path: "/src/app.ts",
+						new_text: "console.log('hello')",
+						old_text: "console.log('world')",
+					},
+				} as AgentEvent,
+			},
+		}
+		const startResult = translateSessionEvent(startEvent, state)
+		expect(startResult.messages).toHaveLength(1)
+		const startTool = JSON.parse(startResult.messages[0].text!)
+		expect(startTool.tool).toBe("editedExistingFile")
+		expect(startTool.path).toBe("/src/app.ts")
+		// S6-48: when both old_text and new_text are provided, content is a search/replace diff
+		expect(startTool.content).toBe(expectedDiff)
+
+		// 2. content_end — should preserve the input from content_start
+		const endEvent: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_end",
+					contentType: "tool",
+					toolName: "editor",
+					toolCallId: "call-1",
+				} as AgentEvent,
+			},
+		}
+		const endResult = translateSessionEvent(endEvent, state)
+		expect(endResult.messages).toHaveLength(1)
+		expect(endResult.messages[0].partial).toBe(false)
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		// The finalized message should have the same content as the partial
+		expect(endTool.tool).toBe("editedExistingFile")
+		expect(endTool.path).toBe("/src/app.ts")
+		expect(endTool.content).toBe(expectedDiff)
+	})
+
+	it("content_end for newFileCreated preserves content from content_start (S6-24)", () => {
+		const state = new MessageTranslatorState()
+
+		// content_start with editor tool (no old_text → newFileCreated)
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "c1",
+						input: { path: "/new-file.ts", new_text: "export const x = 1" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// content_end
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("newFileCreated")
+		expect(endTool.path).toBe("/new-file.ts")
+		expect(endTool.content).toBe("export const x = 1")
+	})
+
+	it("content_end for read_files preserves path from content_start (S6-24)", () => {
+		const state = new MessageTranslatorState()
+
+		// content_start
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+						input: { files: [{ path: "/src/config.ts" }] },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// content_end (no input)
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("readFile")
+		expect(endTool.path).toBe("/src/config.ts")
+	})
+
+	it("content_end for read_files emits one tool message per file when multiple files are read", () => {
+		const state = new MessageTranslatorState()
+
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+						input: {
+							files: [{ path: "/src/README.md" }, { path: "/src/package.json" }],
+						},
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(endResult.messages).toHaveLength(2)
+		const first = JSON.parse(endResult.messages[0].text!)
+		const second = JSON.parse(endResult.messages[1].text!)
+		expect(first.tool).toBe("readFile")
+		expect(second.tool).toBe("readFile")
+		expect(first.path).toBe("/src/README.md")
+		expect(second.path).toBe("/src/package.json")
+	})
+
+	it("content_end for read_files carries the requested line range into the readFile payload", () => {
+		const state = new MessageTranslatorState()
+
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+						input: { files: [{ path: "/src/big-file.ts", start_line: 100, end_line: 200 }] },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("readFile")
+		expect(endTool.path).toBe("/src/big-file.ts")
+		expect(endTool.readLineStart).toBe(100)
+		expect(endTool.readLineEnd).toBe(200)
+	})
+
+	it("content_end for read_files treats a start_line-only read as open-ended and defaults a missing start_line to 1", () => {
+		const state = new MessageTranslatorState()
+
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+						input: {
+							files: [
+								{ path: "/src/paged.ts", start_line: 500, end_line: null },
+								{ path: "/src/head.ts", end_line: 50 },
+								{ path: "/src/whole.ts" },
+							],
+						},
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(endResult.messages).toHaveLength(3)
+		const [paged, head, whole] = endResult.messages.map((m) => JSON.parse(m.text!))
+		expect(paged.readLineStart).toBe(500)
+		expect(paged.readLineEnd).toBeUndefined()
+		expect(head.readLineStart).toBe(1)
+		expect(head.readLineEnd).toBe(50)
+		expect(whole.readLineStart).toBeUndefined()
+		expect(whole.readLineEnd).toBeUndefined()
+	})
+
+	it("content_end without prior content_start still works (graceful fallback)", () => {
+		const state = new MessageTranslatorState()
+
+		// content_end with no prior content_start — stored input is undefined
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// Should still produce a message, just with empty fields
+		expect(endResult.messages).toHaveLength(1)
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("newFileCreated") // no old_text → newFileCreated
+		expect(endTool.path).toBe("")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — agent_event (done)
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event done", () => {
+	it("translates done event to ask completion_result with empty text (no green rectangle)", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "done",
+					reason: "completed",
+					text: "Task completed successfully",
+					iterations: 1,
+				} as AgentEvent,
+			},
+		}
+
+		// done emits no transcript message and only signals turnComplete; the authoritative UI
+		// mode comes from TurnState set by the session-event coordinator.
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(0)
+		expect(result.turnComplete).toBe(true)
+	})
+
+	it("done emits no synthetic ask even when attempt_completion was seen (green box from content_end)", () => {
+		const state = new MessageTranslatorState()
+
+		// Simulate attempt_completion being called (content_start)
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "attempt_completion",
+						input: { result: "All done!" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// Simulate content_end for attempt_completion
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "attempt_completion",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// content_end emits say:"completion_result" (the green box) but never ask:"completion_result";
+		// UI mode is TurnState-driven, so no terminal ask is needed.
+		const sayMessages = endResult.messages.filter((m) => m.type === "say" && m.say === "completion_result")
+		const askMessages = endResult.messages.filter((m) => m.type === "ask" && m.ask === "completion_result")
+		expect(sayMessages).toHaveLength(1)
+		expect(askMessages).toHaveLength(0)
+
+		// The done event emits NO message now (the green box already rendered at content_end);
+		// it only signals turnComplete. The webview reads phase=completed from TurnState.
+		const doneResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "done",
+						reason: "completed",
+						text: "All done!",
+						iterations: 1,
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(doneResult.messages).toHaveLength(0)
+		expect(doneResult.turnComplete).toBe(true)
+	})
+
+	it("recognizes the SDK completion tool submit_and_exit (summary field) → completion_result + completed phase", () => {
+		// The SDK's built-in completion tool is `submit_and_exit` with a `summary` input field
+		// (see sdk/packages/core/.../tools/constants.ts + definitions.ts); the VSCode extra tool
+		// `attempt_completion` uses `result`. The translator recognizes both names and either
+		// field so completion renders the green "Task Completed" box and sets the completed phase.
+		const state = new MessageTranslatorState()
+
+		const startResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "submit_and_exit",
+						input: { summary: "All done — issue resolved." },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// content_start emits a partial say:"completion_result" with the summary text.
+		const startSay = startResult.messages.find((m) => m.type === "say" && m.say === "completion_result")
+		expect(startSay?.text).toBe("All done — issue resolved.")
+		expect(state.wasAttemptCompletionSeen()).toBe(true)
+
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "submit_and_exit",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// content_end finalizes the green "Task Completed" box (non-partial completion_result).
+		const finalSay = endResult.messages.find((m) => m.type === "say" && m.say === "completion_result")
+		expect(finalSay?.partial).toBe(false)
+		expect(finalSay?.text).toBe("All done — issue resolved.")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — agent_event (error)
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event error", () => {
+	it("translates error event to api_req_started + api_req_failed messages", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: "API rate limit exceeded" },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+		// First message: api_req_started with streamingFailedMessage
+		expect(result.messages[0].say).toBe("api_req_started")
+		const apiReqInfo = JSON.parse(result.messages[0].text!)
+		expect(apiReqInfo.streamingFailedMessage).toBe("API rate limit exceeded")
+		expect(result.messages[0].partial).toBe(false)
+		// Second message: ask api_req_failed
+		expect(result.messages[1].type).toBe("ask")
+		expect(result.messages[1].ask).toBe("api_req_failed")
+		expect(result.messages[1].text).toBe("API rate limit exceeded")
+		expect(result.messages[1].partial).toBe(false)
+		expect(result.turnComplete).toBe(true)
+	})
+
+	it("reshapes insufficient_credits error into ClineError-compatible format", () => {
+		const state = new MessageTranslatorState()
+		const errorJson = JSON.stringify({
+			code: "insufficient_credits",
+			current_balance: -0.14,
+			message: "Not enough credits available",
+		})
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: errorJson },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		// The api_req_failed text should be structured JSON that ClineError.parse() can handle
+		const failedText = result.messages[1].text!
+		const parsed = JSON.parse(failedText)
+		expect(parsed.code).toBe("insufficient_credits")
+		expect(parsed.providerId).toBe("cline")
+		expect(parsed.details.current_balance).toBe(-0.14)
+		expect(parsed.details.message).toBe("Not enough credits available")
+	})
+
+	it("preserves the active provider when reshaping insufficient_credits errors", () => {
+		const state = new MessageTranslatorState(undefined, () => "zai")
+		const errorJson = JSON.stringify({
+			code: "insufficient_credits",
+			current_balance: 0,
+			message: "账户余额不足，请充值后重试",
+		})
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: errorJson },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		const parsed = JSON.parse(result.messages[1].text!)
+		expect(parsed.code).toBe("insufficient_credits")
+		expect(parsed.providerId).toBe("zai")
+		expect(parsed.details.current_balance).toBe(0)
+	})
+
+	it("reshapes SPEND_LIMIT_EXCEEDED error into ClineError-compatible format", () => {
+		const state = new MessageTranslatorState()
+		const errorJson = JSON.stringify({
+			code: "SPEND_LIMIT_EXCEEDED",
+			limit_scope: "user",
+			budget_period: "daily",
+			limit_usd: 20.0,
+			spent_usd: 20.5,
+			resets_at: "2026-05-01T00:00:00Z",
+			message: "Your daily spend limit of $20.00 has been reached.",
+		})
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: errorJson },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		const failedText = result.messages[1].text!
+		const parsed = JSON.parse(failedText)
+		expect(parsed.code).toBe("SPEND_LIMIT_EXCEEDED")
+		expect(parsed.providerId).toBe("cline")
+		expect(parsed.details.budget_period).toBe("daily")
+		expect(parsed.details.limit_usd).toBe(20.0)
+	})
+
+	it("reshapes plain-text insufficient credits error into ClineError-compatible format", () => {
+		const state = new MessageTranslatorState()
+		// The SDK often extracts human-readable text from the API response,
+		// losing the structured JSON. This tests that plain-text balance errors
+		// are still detected and reshaped.
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: {
+						message: "Insufficient balance. Your Cline Credits balance is $-0.14",
+					},
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		const failedText = result.messages[1].text!
+		const parsed = JSON.parse(failedText)
+		expect(parsed.code).toBe("insufficient_credits")
+		expect(parsed.providerId).toBe("cline")
+		expect(parsed.details.current_balance).toBe(-0.14)
+		expect(parsed.details.message).toContain("Insufficient balance")
+	})
+
+	it("reshapes plain-text 'Not enough credits' error into ClineError-compatible format", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: "Not enough credits available" },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		const failedText = result.messages[1].text!
+		const parsed = JSON.parse(failedText)
+		expect(parsed.code).toBe("insufficient_credits")
+		expect(parsed.providerId).toBe("cline")
+		expect(parsed.details.current_balance).toBe(0)
+	})
+
+	it("reshapes plain-text spend limit error into ClineError-compatible format", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: {
+						message: "Your daily spend limit of $20.00 has been reached.",
+					},
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		const failedText = result.messages[1].text!
+		const parsed = JSON.parse(failedText)
+		expect(parsed.code).toBe("SPEND_LIMIT_EXCEEDED")
+		expect(parsed.providerId).toBe("cline")
+	})
+
+	it("preserves ClinePass period limit errors for specialized webview rendering", () => {
+		const state = new MessageTranslatorState(undefined, () => "cline-pass")
+		const message = "You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later."
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+		expect(result.messages[1].text).toBe(message)
+	})
+
+	it("rewrites Anthropic bare 'model: <id>' 404 into an actionable message", () => {
+		const state = new MessageTranslatorState(undefined, () => "anthropic")
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: "model: claude-3-haiku-20240307" },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		const failedText = result.messages[1].text!
+		expect(failedText).toContain("claude-3-haiku-20240307")
+		expect(failedText).toContain("was not found")
+		expect(failedText).toContain("API Configuration settings")
+	})
+
+	it("rewrites a 'model not found' message into an actionable message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: "The model `gpt-foo` does not exist" },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(2)
+
+		const failedText = result.messages[1].text!
+		expect(failedText).toContain("gpt-foo")
+		expect(failedText).toContain("API Configuration settings")
+	})
+
+	it("does not rewrite an unrelated error that merely mentions a model", () => {
+		const state = new MessageTranslatorState()
+		const rawMessage = "The requested feature model is not available in your plan"
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: rawMessage },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		const failedText = result.messages[1].text!
+		expect(failedText).toBe(rawMessage)
+		expect(failedText).not.toContain("API Configuration settings")
+	})
+
+	it("leaves an auth error mentioning a model untouched", () => {
+		const state = new MessageTranslatorState()
+		const rawMessage = "Invalid API key for model gpt-4"
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "error",
+					error: { message: rawMessage },
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		const failedText = result.messages[1].text!
+		expect(failedText).toBe(rawMessage)
+		expect(failedText).not.toContain("API Configuration settings")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — ended event
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — ended event", () => {
+	it("marks session as ended and turn as complete", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "ended",
+			payload: {
+				sessionId: "session-1",
+				reason: "completed",
+				ts: Date.now(),
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(0)
+		expect(result.sessionEnded).toBe(true)
+		expect(result.turnComplete).toBe(true)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — hook events
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — hook events", () => {
+	it("translates tool_call hook to hook_status message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "hook",
+			payload: {
+				sessionId: "session-1",
+				hookEventName: "tool_call",
+				toolName: "write_to_file",
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("hook_status")
+		expect(result.messages[0].text).toContain("write_to_file")
+	})
+
+	it("translates tool_result hook to hook_status message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "hook",
+			payload: {
+				sessionId: "session-1",
+				hookEventName: "tool_result",
+				toolName: "read_files",
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].text).toContain("completed")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — status event
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — status event", () => {
+	it("produces no messages for status events", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "status",
+			payload: {
+				sessionId: "session-1",
+				status: "running",
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(0)
+		expect(result.sessionEnded).toBe(false)
+		expect(result.turnComplete).toBe(false)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — streaming flow
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — full streaming flow", () => {
+	it("handles a complete text streaming flow", () => {
+		const state = new MessageTranslatorState()
+
+		// 1. Start streaming text
+		const startResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "Hello",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(startResult.messages).toHaveLength(1)
+		expect(startResult.messages[0].partial).toBe(true)
+		expect(startResult.messages[0].text).toBe("Hello")
+
+		// 2. End streaming text
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "text",
+						text: "Hello world!",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(endResult.messages).toHaveLength(1)
+		expect(endResult.messages[0].partial).toBe(false)
+		expect(endResult.messages[0].text).toBe("Hello world!")
+
+		// 3. Done — without attempt_completion, emits ask:"completion_result"
+		// with empty text (no green rectangle, just enables follow-up input)
+		const doneResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "done",
+						reason: "completed",
+						text: "Done",
+						iterations: 1,
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(doneResult.messages).toHaveLength(0)
+		expect(doneResult.turnComplete).toBe(true)
+	})
+
+	it("handles text → tool → text flow", () => {
+		const state = new MessageTranslatorState()
+
+		// 1. Text start
+		const textStart = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "Let me read that file",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(textStart.messages[0].say).toBe("text")
+
+		// 2. Text end
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "text",
+						text: "Let me read that file",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		// 3. Tool start
+		const toolStart = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "call-1",
+						input: { path: "/src/main.ts" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(toolStart.messages[0].say).toBe("tool")
+		expect(toolStart.messages[0].partial).toBe(true)
+
+		// 4. Tool end
+		const toolEnd = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "call-1",
+						output: "file contents",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(toolEnd.messages[0].say).toBe("tool")
+		expect(toolEnd.messages[0].partial).toBe(false)
+
+		// 5. Second text start (after tool)
+		const text2Start = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "Here's what I found:",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(text2Start.messages[0].say).toBe("text")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — notice event
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event notice", () => {
+	it("translates notice event to info message", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "notice",
+					message: "Retrying API request...",
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("info")
+		expect(result.messages[0].text).toBe("Retrying API request...")
+		expect(result.messages[0].partial).toBe(false)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — content_update
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event content_update", () => {
+	it("skips tool content_update (webview uses content_start partial until content_end)", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_update",
+					contentType: "tool",
+					toolName: "execute_command",
+					toolCallId: "call-1",
+					update: "Running npm install...",
+				} as AgentEvent,
+			},
+		}
+
+		// content_update is intentionally not forwarded to the webview —
+		// the content_start message with partial=true is sufficient until
+		// content_end finalizes it. This avoids flooding the webview.
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(0)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// translateSessionEvent — agent_event (usage)
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — agent_event usage", () => {
+	it("splits SDK inclusive input tokens into classic disjoint usage buckets", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "usage",
+					inputTokens: 24481,
+					outputTokens: 261,
+					cacheReadTokens: 24478,
+					cacheWriteTokens: 0,
+					cost: 0.0112674,
+					totalInputTokens: 24481,
+					totalOutputTokens: 261,
+					totalCacheReadTokens: 24478,
+					totalCacheWriteTokens: 0,
+					totalCost: 0.0112674,
+				} as AgentEvent,
+			},
+		}
+
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("api_req_started")
+		expect(JSON.parse(result.messages[0].text ?? "{}")).toMatchObject({
+			tokensIn: 3,
+			tokensOut: 261,
+			cacheReads: 24478,
+			cacheWrites: 0,
+			cost: 0.0112674,
+		})
+		expect(result.usage).toEqual({
+			tokensIn: 3,
+			tokensOut: 261,
+			cacheReads: 24478,
+			cacheWrites: 0,
+			totalCost: 0.0112674,
+		})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// historyItemToSessionFields
+// ---------------------------------------------------------------------------
+
+describe("historyItemToSessionFields", () => {
+	it("maps HistoryItem to session fields", () => {
+		const result = historyItemToSessionFields({
+			id: "task-123",
+			task: "Fix the bug",
+			ts: 1700000000000,
+			tokensIn: 500,
+			tokensOut: 250,
+			totalCost: 0.05,
+			modelId: "claude-sonnet-4-6",
+		})
+
+		expect(result.sessionId).toBe("task-123")
+		expect(result.prompt).toBe("Fix the bug")
+		expect(result.usage.tokensIn).toBe(500)
+		expect(result.usage.tokensOut).toBe(250)
+		expect(result.usage.totalCost).toBe(0.05)
+		expect(result.modelId).toBe("claude-sonnet-4-6")
+		expect(result.startedAt).toBe(new Date(1700000000000).toISOString())
+	})
+
+	it("handles missing optional fields", () => {
+		const result = historyItemToSessionFields({
+			id: "task-456",
+			task: "Simple task",
+			ts: 1700000000000,
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+		})
+
+		expect(result.sessionId).toBe("task-456")
+		expect(result.modelId).toBeUndefined()
+	})
+})
+
+describe("translateSessionEvent — accumulated text streaming (S6-21 fix)", () => {
+	it("uses accumulated text for smooth streaming instead of delta", () => {
+		const state = new MessageTranslatorState()
+
+		// First chunk: text="Hello ", accumulated="Hello "
+		const chunk1 = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "Hello ",
+						accumulated: "Hello ",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(chunk1.messages).toHaveLength(1)
+		expect(chunk1.messages[0].text).toBe("Hello ")
+		expect(chunk1.messages[0].partial).toBe(true)
+		const streamingTs = chunk1.messages[0].ts
+
+		// Second chunk: text="world" (delta), accumulated="Hello world" (full)
+		// The message should use accumulated, NOT text (delta)
+		const chunk2 = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "world",
+						accumulated: "Hello world",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(chunk2.messages).toHaveLength(1)
+		// CRITICAL: Must be "Hello world" (accumulated), NOT "world" (delta)
+		// Using delta would cause "flip book" effect in the webview
+		expect(chunk2.messages[0].text).toBe("Hello world")
+		expect(chunk2.messages[0].partial).toBe(true)
+		// Same timestamp — webview updates in-place
+		expect(chunk2.messages[0].ts).toBe(streamingTs)
+
+		// Third chunk: more text
+		const chunk3 = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "!",
+						accumulated: "Hello world!",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(chunk3.messages).toHaveLength(1)
+		expect(chunk3.messages[0].text).toBe("Hello world!")
+		expect(chunk3.messages[0].ts).toBe(streamingTs)
+
+		// content_end finalizes
+		const end = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "text",
+						text: "Hello world!",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(end.messages).toHaveLength(1)
+		expect(end.messages[0].text).toBe("Hello world!")
+		expect(end.messages[0].partial).toBe(false)
+		expect(end.messages[0].ts).toBe(streamingTs)
+	})
+
+	it("accumulates reasoning deltas into text for webview rendering", () => {
+		const state = new MessageTranslatorState()
+
+		const chunk1 = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "reasoning",
+						reasoning: "Thinking ",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const streamingTs = chunk1.messages[0].ts
+		expect(chunk1.messages[0].text).toBe("Thinking ")
+		expect(chunk1.messages[0].reasoning).toBe("Thinking ")
+
+		const chunk2 = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "reasoning",
+						reasoning: "through it",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(chunk2.messages[0].ts).toBe(streamingTs)
+		expect(chunk2.messages[0].text).toBe("Thinking through it")
+		expect(chunk2.messages[0].reasoning).toBe("Thinking through it")
+
+		const end = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "reasoning",
+						reasoning: "Thinking through it",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(end.messages[0].ts).toBe(streamingTs)
+		expect(end.messages[0].text).toBe("Thinking through it")
+		expect(end.messages[0].partial).toBe(false)
+	})
+
+	it("falls back to text when accumulated is not provided", () => {
+		const state = new MessageTranslatorState()
+
+		// Some SDK events may not have accumulated (e.g., first chunk)
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: "Hello",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].text).toBe("Hello")
+	})
+
+	it("all streaming chunks share the same timestamp for in-place updates", () => {
+		const state = new MessageTranslatorState()
+		const timestamps: number[] = []
+
+		for (let i = 0; i < 5; i++) {
+			const result = translateSessionEvent(
+				{
+					type: "agent_event",
+					payload: {
+						sessionId: "s1",
+						event: {
+							type: "content_start",
+							contentType: "text",
+							text: `chunk${i}`,
+							accumulated: `accumulated${i}`,
+						} as AgentEvent,
+					},
+				},
+				state,
+			)
+			timestamps.push(result.messages[0].ts)
+		}
+
+		// All timestamps should be identical
+		expect(new Set(timestamps).size).toBe(1)
+	})
+
+	// ---------------------------------------------------------------------------
+	// extractToolOutputText
+	// ---------------------------------------------------------------------------
+
+	describe("extractToolOutputText", () => {
+		it("returns empty string for null/undefined", () => {
+			expect(extractToolOutputText(null)).toBe("")
+			expect(extractToolOutputText(undefined)).toBe("")
+		})
+
+		it("returns string output as-is", () => {
+			expect(extractToolOutputText("hello world\nline 2")).toBe("hello world\nline 2")
+		})
+
+		it("returns empty string for empty string", () => {
+			expect(extractToolOutputText("")).toBe("")
+		})
+
+		it("extracts result text from ToolOperationResult array (single command)", () => {
+			const output = [{ query: "ls -la", result: "file1\nfile2\nfile3", success: true }]
+			expect(extractToolOutputText(output)).toBe("file1\nfile2\nfile3")
+		})
+
+		it("extracts result text from ToolOperationResult array (multiple commands)", () => {
+			const output = [
+				{ query: "echo hello", result: "hello", success: true },
+				{ query: "echo world", result: "world", success: true },
+			]
+			expect(extractToolOutputText(output)).toBe("hello\nworld")
+		})
+
+		it("extracts error text from failed ToolOperationResult", () => {
+			const output = [
+				{
+					query: "bad-command",
+					result: "",
+					error: "Command failed: not found",
+					success: false,
+				},
+			]
+			expect(extractToolOutputText(output)).toBe("Command failed: not found")
+		})
+
+		it("extracts mixed success and error results", () => {
+			const output = [
+				{ query: "echo ok", result: "ok", success: true },
+				{
+					query: "fail",
+					result: "",
+					error: "Command failed: exit 1",
+					success: false,
+				},
+			]
+			expect(extractToolOutputText(output)).toBe("ok\nCommand failed: exit 1")
+		})
+
+		it("handles array of plain strings", () => {
+			expect(extractToolOutputText(["line 1", "line 2"])).toBe("line 1\nline 2")
+		})
+
+		it("falls back to JSON.stringify for unknown structured output", () => {
+			expect(extractToolOutputText({ foo: "bar" })).toBe('{"foo":"bar"}')
+		})
+
+		it("falls back to JSON.stringify for empty array", () => {
+			expect(extractToolOutputText([])).toBe("[]")
+		})
+
+		it("skips ToolOperationResult entries with empty result and no error", () => {
+			const output = [
+				{ query: "noop", result: "", success: true },
+				{ query: "echo hi", result: "hi", success: true },
+			]
+			expect(extractToolOutputText(output)).toBe("hi")
+		})
+	})
+
+	// ---------------------------------------------------------------------------
+	// command content_end — output formatting
+	// ---------------------------------------------------------------------------
+
+	describe("translateSessionEvent — command content_end output formatting", () => {
+		it("formats ToolOperationResult[] as raw text, not JSON", () => {
+			const state = new MessageTranslatorState()
+			const startEvent: CoreSessionEvent = {
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "run_commands",
+						toolCallId: "c1",
+						input: { commands: ["ls -la"] },
+					} as AgentEvent,
+				},
+			}
+			translateSessionEvent(startEvent, state)
+
+			const endEvent: CoreSessionEvent = {
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "run_commands",
+						toolCallId: "c1",
+						output: [
+							{
+								query: "ls -la",
+								result: "total 42\nfile1\nfile2",
+								success: true,
+							},
+						],
+					} as AgentEvent,
+				},
+			}
+			const result = translateSessionEvent(endEvent, state)
+			expect(result.messages).toHaveLength(1)
+			const msg = result.messages[0]
+			expect(msg.say).toBe("command")
+			expect(msg.text).toContain("ls -la")
+			expect(msg.text).toContain("Output:")
+			expect(msg.text).toContain("total 42")
+			// Should NOT contain JSON artifacts
+			expect(msg.text).not.toContain('"query"')
+			expect(msg.text).not.toContain('"success"')
+		})
+
+		it("formats string output directly", () => {
+			const state = new MessageTranslatorState()
+			translateSessionEvent(
+				{
+					type: "agent_event",
+					payload: {
+						sessionId: "s1",
+						event: {
+							type: "content_start",
+							contentType: "tool",
+							toolName: "run_commands",
+							toolCallId: "c2",
+							input: { commands: ["echo hello"] },
+						} as AgentEvent,
+					},
+				},
+				state,
+			)
+
+			const result = translateSessionEvent(
+				{
+					type: "agent_event",
+					payload: {
+						sessionId: "s1",
+						event: {
+							type: "content_end",
+							contentType: "tool",
+							toolName: "run_commands",
+							toolCallId: "c2",
+							output: "hello\n",
+						} as AgentEvent,
+					},
+				},
+				state,
+			)
+
+			const msg = result.messages[0]
+			expect(msg.text).toContain("echo hello")
+			expect(msg.text).toContain("Output:")
+			expect(msg.text).toContain("hello")
+		})
+
+		it("formats error output", () => {
+			const state = new MessageTranslatorState()
+			translateSessionEvent(
+				{
+					type: "agent_event",
+					payload: {
+						sessionId: "s1",
+						event: {
+							type: "content_start",
+							contentType: "tool",
+							toolName: "run_commands",
+							toolCallId: "c3",
+							input: { commands: ["bad-cmd"] },
+						} as AgentEvent,
+					},
+				},
+				state,
+			)
+
+			const result = translateSessionEvent(
+				{
+					type: "agent_event",
+					payload: {
+						sessionId: "s1",
+						event: {
+							type: "content_end",
+							contentType: "tool",
+							toolName: "run_commands",
+							toolCallId: "c3",
+							error: "command not found",
+						} as AgentEvent,
+					},
+				},
+				state,
+			)
+
+			const msg = result.messages[0]
+			expect(msg.text).toContain("Error: command not found")
+		})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// ENG-1867: run_commands with bare array input renders command text
+// ---------------------------------------------------------------------------
+
+describe("translateSessionEvent — run_commands bare array/string input (ENG-1867)", () => {
+	it("content_start with bare array input shows command text", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "run_commands",
+					toolCallId: "c1",
+					input: ["biome check --write src/"],
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		const msg = result.messages[0]
+		expect(msg.say).toBe("command")
+		// The running command row carries the "Output:" marker so ChatRow renders it as executing.
+		expect(msg.text).toBe("biome check --write src/\nOutput:")
+		expect(msg.partial).toBe(true)
+	})
+
+	it("content_start with multi-element bare array joins with &&", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "run_commands",
+					toolCallId: "c1",
+					input: ["npm install", "npm run build"],
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		// The running command row carries the "Output:" marker so ChatRow renders it as executing.
+		expect(result.messages[0].text).toBe("npm install && npm run build\nOutput:")
+	})
+
+	it("content_start with bare string input shows command text", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "execute_command",
+					toolCallId: "c1",
+					input: "ls -la",
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		expect(result.messages[0].say).toBe("command")
+		// The running command row carries the "Output:" marker so ChatRow renders it as executing.
+		expect(result.messages[0].text).toBe("ls -la\nOutput:")
+	})
+
+	it("content_end preserves bare array input from content_start", () => {
+		const state = new MessageTranslatorState()
+		// content_start with bare array
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "run_commands",
+						toolCallId: "c1",
+						input: ["biome check --write src/"],
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		// content_end
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "run_commands",
+						toolCallId: "c1",
+						output: "Checked 2 files in 108ms. No fixes applied.",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(endResult.messages).toHaveLength(1)
+		const msg = endResult.messages[0]
+		expect(msg.say).toBe("command")
+		expect(msg.text).toContain("biome check --write src/")
+		expect(msg.text).toContain("Output:")
+		expect(msg.text).toContain("Checked 2 files")
+		expect(msg.partial).toBe(false)
+	})
+
+	it("content_end with bare string input from content_start preserves command", () => {
+		const state = new MessageTranslatorState()
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "execute_command",
+						toolCallId: "c1",
+						input: "echo hello",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "execute_command",
+						toolCallId: "c1",
+						output: "hello\n",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const msg = endResult.messages[0]
+		expect(msg.text).toContain("echo hello")
+		expect(msg.text).toContain("hello")
+	})
+
+	it("wrapped object input { commands: [...] } still works (regression)", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "run_commands",
+					toolCallId: "c1",
+					input: { commands: ["npm test"] },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		// The running command row carries the "Output:" marker so ChatRow renders it as executing.
+		expect(result.messages[0].text).toBe("npm test\nOutput:")
+	})
+
+	it("structured command array input renders command and args, not [object Object]", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "run_commands",
+					toolCallId: "c1",
+					input: { commands: [{ command: "ls", args: ["-la", "/tmp"] }] },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		expect(result.messages[0].text).toBe("ls -la /tmp\nOutput:")
+		expect(result.messages[0].text).not.toContain("[object Object]")
+	})
+
+	it("direct structured command input renders command and args, not [object Object]", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "run_commands",
+					toolCallId: "c1",
+					input: { command: "ls", args: ["-la", "/tmp"] },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		expect(result.messages[0].text).toBe("ls -la /tmp\nOutput:")
+		expect(result.messages[0].text).not.toContain("[object Object]")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// S6-39: fetch_web_content renders URL (SDK input: { requests: [{ url, prompt }] })
+// S6-40: skills tool renders skill name (SDK input: { skill: "name" })
+// ---------------------------------------------------------------------------
+
+describe("sdkToolToClineSayTool — fetch_web_content and skills (S6-39, S6-40)", () => {
+	it("S6-39: fetch_web_content extracts URL from SDK requests array", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "fetch_web_content",
+					toolCallId: "c1",
+					input: {
+						requests: [{ url: "https://example.com/docs", prompt: "Summarize" }],
+					},
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("webFetch")
+		expect(tool.path).toBe("https://example.com/docs")
+	})
+
+	it("S6-39: content_end preserves URL from content_start", () => {
+		const state = new MessageTranslatorState()
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "fetch_web_content",
+						toolCallId: "c1",
+						input: {
+							requests: [{ url: "https://example.com", prompt: "Read" }],
+						},
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "fetch_web_content",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("webFetch")
+		expect(endTool.path).toBe("https://example.com")
+	})
+
+	it("S6-39: classic web_fetch with flat url field still works", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "web_fetch",
+					toolCallId: "c1",
+					input: { url: "https://classic.com", prompt: "Read" },
+				} as AgentEvent,
+			},
+		}
+		const tool = JSON.parse(translateSessionEvent(event, state).messages[0].text!)
+		expect(tool.tool).toBe("webFetch")
+		expect(tool.path).toBe("https://classic.com")
+	})
+
+	it("S6-39: multiple requests extracts first URL", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "fetch_web_content",
+					toolCallId: "c1",
+					input: {
+						requests: [
+							{ url: "https://first.com", prompt: "p1" },
+							{ url: "https://second.com", prompt: "p2" },
+						],
+					},
+				} as AgentEvent,
+			},
+		}
+		const tool = JSON.parse(translateSessionEvent(event, state).messages[0].text!)
+		expect(tool.path).toBe("https://first.com")
+	})
+
+	it("S6-40: skills tool extracts name from SDK 'skill' field", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "skills",
+					toolCallId: "c1",
+					input: { skill: "commit", args: null },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("useSkill")
+		expect(tool.path).toBe("commit")
+	})
+
+	it("S6-40: skills content_end preserves skill name from content_start", () => {
+		const state = new MessageTranslatorState()
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "skills",
+						toolCallId: "c1",
+						input: { skill: "review-pr", args: "123" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "skills",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("useSkill")
+		expect(endTool.path).toBe("review-pr")
+	})
+
+	it("S6-40: classic use_skill with skill_name field still works", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "use_skill",
+					toolCallId: "c1",
+					input: { skill_name: "kanban" },
+				} as AgentEvent,
+			},
+		}
+		const tool = JSON.parse(translateSessionEvent(event, state).messages[0].text!)
+		expect(tool.tool).toBe("useSkill")
+		expect(tool.path).toBe("kanban")
+	})
+})
+
+// ---------------------------------------------------------------------------
+// S6-47: search_codebase renders query and path correctly
+// ---------------------------------------------------------------------------
+
+describe("sdkToolToClineSayTool — search_codebase (S6-47)", () => {
+	it("S6-47: search_codebase with { queries: ['TODO', 'FIXME'] } extracts regex", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "search_codebase",
+					toolCallId: "c1",
+					input: { queries: ["TODO", "FIXME"] },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("searchFiles")
+		expect(tool.regex).toBe("TODO, FIXME")
+	})
+
+	it("S6-47: search_codebase with stringified JSON input extracts regex", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "search_codebase",
+					toolCallId: "c1",
+					input: JSON.stringify({ queries: ["TODO"] }),
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("searchFiles")
+		expect(tool.regex).toBe("TODO")
+	})
+
+	it("S6-47: search_codebase with bare array input extracts regex", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "search_codebase",
+					toolCallId: "c1",
+					input: ["TODO", "FIXME"],
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("searchFiles")
+		expect(tool.regex).toBe("TODO, FIXME")
+	})
+
+	it("S6-47: search_codebase with bare string input extracts regex", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "search_codebase",
+					toolCallId: "c1",
+					input: "TODO",
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("searchFiles")
+		expect(tool.regex).toBe("TODO")
+	})
+
+	it("S6-47: search_codebase with { queries: 'single' } (string, not array) extracts regex", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "search_codebase",
+					toolCallId: "c1",
+					input: { queries: "TODO" },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("searchFiles")
+		expect(tool.regex).toBe("TODO")
+	})
+
+	it("S6-47: content_end preserves search queries from content_start", () => {
+		const state = new MessageTranslatorState()
+		// content_start
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "search_codebase",
+						toolCallId: "c1",
+						input: { queries: ["TODO", "FIXME"] },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		// content_end (no input — S6-24 pattern)
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "search_codebase",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("searchFiles")
+		expect(endTool.regex).toBe("TODO, FIXME")
+	})
+
+	it("S6-47: content_end preserves bare array input from content_start", () => {
+		const state = new MessageTranslatorState()
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "search_codebase",
+						toolCallId: "c1",
+						input: ["searchPattern"],
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endResult = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "search_codebase",
+						toolCallId: "c1",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const endTool = JSON.parse(endResult.messages[0].text!)
+		expect(endTool.tool).toBe("searchFiles")
+		expect(endTool.regex).toBe("searchPattern")
+	})
+
+	it("S6-47: search_codebase path is undefined when SDK has no path param", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "search_codebase",
+					toolCallId: "c1",
+					input: { queries: ["TODO"] },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("searchFiles")
+		// Path should be undefined since SDK search_codebase has no path parameter
+		expect(tool.path).toBeUndefined()
+	})
+})
+
+// ---------------------------------------------------------------------------
+// S6-48: Editor diff rendering — search/replace format for old_text+new_text
+// ---------------------------------------------------------------------------
+
+describe("sdkToolToClineSayTool — editor diff rendering (S6-48)", () => {
+	it("S6-48: editor with old_text and new_text builds search/replace diff in content", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "editor",
+					toolCallId: "call-1",
+					input: {
+						path: "/src/app.ts",
+						old_text: "console.log('world')",
+						new_text: "console.log('hello')",
+					},
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("editedExistingFile")
+		expect(tool.path).toBe("/src/app.ts")
+		expect(tool.content).toBe("------- SEARCH\nconsole.log('world')\n=======\nconsole.log('hello')\n+++++++ REPLACE")
+	})
+
+	it("S6-48: editor with only new_text keeps raw new_text in content", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "editor",
+					toolCallId: "call-2",
+					input: { path: "/src/new-file.ts", new_text: "export const x = 1" },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("newFileCreated")
+		expect(tool.content).toBe("export const x = 1")
+	})
+
+	it("S6-48: editor with old_str/new_str also builds search/replace diff", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "editor",
+					toolCallId: "call-3",
+					input: {
+						path: "/src/file.ts",
+						old_str: "return false",
+						new_str: "return true",
+					},
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.tool).toBe("editedExistingFile")
+		expect(tool.content).toBe("------- SEARCH\nreturn false\n=======\nreturn true\n+++++++ REPLACE")
+	})
+
+	it("S6-48: multiline old_text/new_text preserved in search/replace diff", () => {
+		const state = new MessageTranslatorState()
+		const oldText = "function foo() {\n\treturn 1\n}"
+		const newText = "function foo() {\n\treturn 2\n}"
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "editor",
+					toolCallId: "call-4",
+					input: { path: "/src/file.ts", old_text: oldText, new_text: newText },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		const tool = JSON.parse(result.messages[0].text!)
+		expect(tool.content).toBe(`------- SEARCH\n${oldText}\n=======\n${newText}\n+++++++ REPLACE`)
+		expect(tool.content).toContain("------- SEARCH")
+		expect(tool.content).toContain("+++++++ REPLACE")
+	})
+
+	// ---------------------------------------------------------------------------
+	// S6-48: apply_patch tool — content populated from SDK input field
+	// ---------------------------------------------------------------------------
+
+	describe("sdkToolToClineSayTool — apply_patch content (S6-48)", () => {
+		it("S6-48: apply_patch with SDK { input: '...' } populates both content and diff", () => {
+			const state = new MessageTranslatorState()
+			const patchContent = "*** Begin Patch\n*** Update File: src/file.ts\n@@\n-old\n+new\n*** End Patch"
+			const event: CoreSessionEvent = {
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "apply_patch",
+						toolCallId: "call-1",
+						input: { input: patchContent },
+					} as AgentEvent,
+				},
+			}
+			const result = translateSessionEvent(event, state)
+			const tool = JSON.parse(result.messages[0].text!)
+			expect(tool.tool).toBe("editedExistingFile")
+			expect(tool.content).toBe(patchContent)
+			expect(tool.diff).toBe(patchContent)
+		})
+
+		it("S6-48: apply_patch with classic { patch: '...' } populates both content and diff", () => {
+			const state = new MessageTranslatorState()
+			const patchContent = "*** Begin Patch\n*** Update File: src/file.ts\n@@\n-old\n+new\n*** End Patch"
+			const event: CoreSessionEvent = {
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "apply_patch",
+						toolCallId: "call-2",
+						input: { patch: patchContent },
+					} as AgentEvent,
+				},
+			}
+			const result = translateSessionEvent(event, state)
+			const tool = JSON.parse(result.messages[0].text!)
+			expect(tool.tool).toBe("editedExistingFile")
+			expect(tool.content).toBe(patchContent)
+			expect(tool.diff).toBe(patchContent)
+		})
+
+		it("S6-48: apply_patch prefers 'patch' field over 'input' field", () => {
+			const state = new MessageTranslatorState()
+			const event: CoreSessionEvent = {
+				type: "agent_event",
+				payload: {
+					sessionId: "session-1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "apply_patch",
+						toolCallId: "call-3",
+						input: { patch: "the-patch-content", input: "the-input-content" },
+					} as AgentEvent,
+				},
+			}
+			const result = translateSessionEvent(event, state)
+			const tool = JSON.parse(result.messages[0].text!)
+			expect(tool.content).toBe("the-patch-content")
+			expect(tool.diff).toBe("the-patch-content")
+		})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// MCP tool handling — say="use_mcp_server" + say="mcp_server_response"
+// ---------------------------------------------------------------------------
+
+describe("MCP tool rendering (serverName__toolName convention)", () => {
+	it("content_start for MCP tool emits say='use_mcp_server' with ClineAskUseMcpServer payload", () => {
+		const state = new MessageTranslatorState()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "s1",
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolName: "notion__notion-get-users",
+					toolCallId: "c1",
+					input: { user_id: "self" },
+				} as AgentEvent,
+			},
+		}
+		const result = translateSessionEvent(event, state)
+		expect(result.messages).toHaveLength(1)
+		const msg = result.messages[0]
+		expect(msg.type).toBe("say")
+		expect(msg.say).toBe("use_mcp_server")
+		expect(msg.partial).toBe(true)
+		const payload = JSON.parse(msg.text!) as ClineAskUseMcpServer
+		expect(payload.type).toBe("use_mcp_tool")
+		expect(payload.serverName).toBe("notion")
+		expect(payload.toolName).toBe("notion-get-users")
+		expect(payload.arguments).toContain('"user_id"')
+	})
+
+	it("content_end for MCP tool emits finalized use_mcp_server + mcp_server_response", () => {
+		const state = new MessageTranslatorState()
+		// content_start to set up state
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "notion__notion-get-users",
+						toolCallId: "c1",
+						input: { user_id: "self" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		// content_end with output
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "notion__notion-get-users",
+						toolCallId: "c1",
+						output: "User: Max (self)",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(result.messages).toHaveLength(2)
+		expect(result.messages[0].say).toBe("use_mcp_server")
+		expect(result.messages[0].partial).toBe(false)
+		expect(result.messages[1].say).toBe("mcp_server_response")
+		expect(result.messages[1].text).toBe("User: Max (self)")
+	})
+
+	it("content_end for MCP tool with error shows error in response", () => {
+		const state = new MessageTranslatorState()
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "github__search-repos",
+						toolCallId: "c2",
+						input: { query: "cline" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "github__search-repos",
+						toolCallId: "c2",
+						error: "Auth failed",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(result.messages).toHaveLength(2)
+		expect(result.messages[1].say).toBe("mcp_server_response")
+		expect(result.messages[1].text).toBe("Error: Auth failed")
+	})
+
+	it("MCP tool with empty input omits arguments", () => {
+		const state = new MessageTranslatorState()
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "notion__list-databases",
+						toolCallId: "c3",
+						input: {},
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const payload = JSON.parse(result.messages[0].text!) as ClineAskUseMcpServer
+		expect(payload.serverName).toBe("notion")
+		expect(payload.toolName).toBe("list-databases")
+		expect(payload.arguments).toBeUndefined()
+	})
+
+	it("non-MCP tool (no __ separator) still emits say='tool'", () => {
+		const state = new MessageTranslatorState()
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "read_files",
+						toolCallId: "c4",
+						input: { files: [{ path: "/tmp/test.ts" }] },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(result.messages[0].say).toBe("tool")
+	})
+
+	it("tool starting with __ (empty server) is not MCP", () => {
+		const state = new MessageTranslatorState()
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "__orphan",
+						toolCallId: "c5",
+						input: {},
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(result.messages[0].say).toBe("tool")
+	})
+
+	it("content_end with no output omits mcp_server_response", () => {
+		const state = new MessageTranslatorState()
+		translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "notion__update-page",
+						toolCallId: "c6",
+						input: { page_id: "123" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "s1",
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolName: "notion__update-page",
+						toolCallId: "c6",
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+		expect(result.messages).toHaveLength(1)
+		expect(result.messages[0].say).toBe("use_mcp_server")
+		expect(result.messages[0].partial).toBe(false)
+	})
+})
diff --git a/apps/vscode/src/sdk/message-translator.ts b/apps/vscode/src/sdk/message-translator.ts
new file mode 100644
index 0000000..cdbdc1b
--- /dev/null
+++ b/apps/vscode/src/sdk/message-translator.ts
@@ -0,0 +1,2092 @@
+// Replaces classic message streaming from src/core/task/index.ts (see origin/main)
+//
+// Translates SDK session events into ClineMessage[] for webview consumption.
+// The webview expects ClineMessage objects with ask/say types; this module
+// maps SDK CoreSessionEvent and AgentEvent types to that format.
+//
+// Key mappings:
+// - SDK "chunk" event (agent stream) → ClineMessage say="text" with partial=true
+// - SDK "agent_event" content_start (text) → ClineMessage say="text" with partial=true
+// - SDK "agent_event" content_start (reasoning) → ClineMessage say="reasoning" with partial=true
+// - SDK "agent_event" content_start (tool) → ClineMessage say="tool" with partial=true
+//   IMPORTANT: The webview's ChatRow.tsx parses message.text as JSON when
+//   say==="tool", expecting ClineSayTool format: {tool, path, content, ...}.
+//   We must convert SDK tool names (read_files, editor, run_commands, etc.)
+//   and their inputs to this format.
+// - SDK "agent_event" content_start (tool: MCP) → ClineMessage say="use_mcp_server" with partial=true
+//   MCP tools use serverName__toolName naming convention. The webview renders
+//   MCP tool calls via say/ask="use_mcp_server" with ClineAskUseMcpServer JSON.
+// - SDK "agent_event" content_end (tool: MCP) → say="use_mcp_server" + say="mcp_server_response"
+// - SDK "agent_event" content_end → ClineMessage with partial=false
+// - SDK "agent_event" content_start (tool: attempt_completion) → ClineMessage say="completion_result"
+// - SDK "agent_event" content_end (tool: attempt_completion) → ClineMessage say="completion_result" (final)
+// - SDK "agent_event" done → ClineMessage ask="completion_result" (always; must be last message)
+// - SDK "agent_event" error → ClineMessage say="error"
+// - SDK "agent_event" usage → ClineMessage say="api_req_started" with ClineApiReqInfo JSON
+// - SDK "ended" event → finalizes the session
+
+import type { CoreSessionEvent } from "@cline/core"
+import type { Message as SdkMessage } from "@cline/llms"
+import type { AgentEvent } from "@cline/shared"
+import { COMMAND_OUTPUT_STRING } from "@shared/combineCommandSequences"
+import type {
+	ClineApiReqInfo,
+	ClineAskUseMcpServer,
+	ClineAskUseSubagents,
+	ClineMessage,
+	ClineSay,
+	ClineSaySubagentStatus,
+	ClineSayTool,
+	ClineSubagentUsageInfo,
+	SubagentStatusItem,
+} from "@shared/ExtensionMessage"
+import { Logger } from "@shared/services/Logger"
+import { MessageIdMinter } from "./message-id-minter"
+import { isDeniedToolApprovalMistake, isKnownToolApprovalDenial } from "./tool-approval-denial"
+
+// ---------------------------------------------------------------------------
+// Translation result
+// ---------------------------------------------------------------------------
+
+/**
+ * Result of translating a single SDK event into ClineMessages.
+ * May produce zero or more messages.
+ */
+export interface TranslationResult {
+	/** Messages produced by this event */
+	messages: ClineMessage[]
+	/** Whether the session has ended */
+	sessionEnded: boolean
+	/** Whether the agent turn is complete */
+	turnComplete: boolean
+	/** Whether a tool call ended with an error (content_end with event.error) */
+	toolError?: boolean
+	/** Whether a tool call ended successfully (content_end without error) */
+	toolSuccess?: boolean
+	/** Usage info if available */
+	usage?: {
+		tokensIn: number
+		tokensOut: number
+		cacheWrites?: number
+		cacheReads?: number
+		totalCost?: number
+	}
+}
+
+type NormalizedUsage = NonNullable<TranslationResult["usage"]>
+
+function normalizeUsageEvent(usageEvent: {
+	inputTokens?: number
+	outputTokens?: number
+	cacheReadTokens?: number
+	cacheWriteTokens?: number
+	cost?: number
+	totalCost?: number
+}): NormalizedUsage {
+	const inputTokens = usageEvent.inputTokens ?? 0
+	const cacheReads = usageEvent.cacheReadTokens ?? 0
+	const cacheWrites = usageEvent.cacheWriteTokens ?? 0
+
+	// SDK provider usage reports inputTokens as the full request size, with
+	// cache reads/writes included. Classic Cline/webview metrics expect
+	// tokensIn, cacheReads, and cacheWrites to be disjoint buckets.
+	const uncachedInputTokens = Math.max(0, inputTokens - cacheReads - cacheWrites)
+
+	return {
+		tokensIn: uncachedInputTokens,
+		tokensOut: usageEvent.outputTokens ?? 0,
+		cacheWrites,
+		cacheReads,
+		totalCost: usageEvent.cost ?? usageEvent.totalCost ?? 0,
+	}
+}
+
+// ---------------------------------------------------------------------------
+// State tracking for partial messages
+// ---------------------------------------------------------------------------
+
+/**
+ * Tracks the state of streaming content to properly handle
+ * partial message updates.
+ */
+export class MessageTranslatorState {
+	/** Current streaming text message timestamp (used for dedup) */
+	private streamingTextTs: number | undefined
+	/** Current streaming reasoning message timestamp */
+	private streamingReasoningTs: number | undefined
+	/** Accumulated streaming reasoning text (SDK reasoning events are deltas) */
+	private streamingReasoningText = ""
+	/** Current streaming tool message timestamp */
+	private streamingToolTs: number | undefined
+	/** Stored tool input from content_start — used at content_end which doesn't carry input */
+	private streamingToolInput: unknown | undefined
+	/** Stored tool name from content_start — used at content_end for consistency */
+	private streamingToolName: string | undefined
+	/** Approved tool-call ids mapped to the approval row that should be updated in place. */
+	private approvedToolMessageTsByCallId = new Map<string, number>()
+	/** Tool calls rejected by the user; they should not render as red tool failures. */
+	private deniedToolApprovalsByCallId = new Map<string, { toolName: string; reason: string }>()
+	/**
+	 * Process-wide id/seq/epoch authority. Shared with the interaction coordinator and history
+	 * rendering so that message ids never collide across generators. See message-id-minter.ts.
+	 */
+	private readonly minter: MessageIdMinter
+
+	constructor(
+		minter: MessageIdMinter = new MessageIdMinter(),
+		private readonly getActiveProviderId?: () => string | undefined,
+	) {
+		this.minter = minter
+	}
+
+	/** Provider backing the active turn, if the host can supply it. */
+	activeProviderId(): string | undefined {
+		return this.getActiveProviderId?.()
+	}
+
+	/** The shared minter, exposed so coordinators and history rendering mint from the same source. */
+	getMinter(): MessageIdMinter {
+		return this.minter
+	}
+
+	/** Generate a unique message id (identity). Pure monotonic counter; never reads the clock. */
+	nextTs(): number {
+		return this.minter.nextId()
+	}
+
+	/** Get and increment for streaming text */
+	getStreamingTextTs(): number {
+		if (!this.streamingTextTs) {
+			this.streamingTextTs = this.nextTs()
+		}
+		return this.streamingTextTs
+	}
+
+	/** Clear streaming text (content ended) */
+	clearStreamingText(): number {
+		const ts = this.streamingTextTs ?? this.nextTs()
+		this.streamingTextTs = undefined
+		return ts
+	}
+
+	/** Get and increment for streaming reasoning */
+	getStreamingReasoningTs(): number {
+		if (!this.streamingReasoningTs) {
+			this.streamingReasoningTs = this.nextTs()
+		}
+		return this.streamingReasoningTs
+	}
+
+	/** Append a reasoning delta and return the accumulated reasoning text */
+	appendStreamingReasoning(reasoningDelta: string): string {
+		this.streamingReasoningText += reasoningDelta
+		return this.streamingReasoningText
+	}
+
+	/** Clear streaming reasoning (content ended) */
+	clearStreamingReasoning(): number {
+		const ts = this.streamingReasoningTs ?? this.nextTs()
+		this.streamingReasoningTs = undefined
+		this.streamingReasoningText = ""
+		return ts
+	}
+
+	/** Get streaming tool ts */
+	getStreamingToolTs(): number {
+		if (!this.streamingToolTs) {
+			this.streamingToolTs = this.nextTs()
+		}
+		return this.streamingToolTs
+	}
+
+	/** Store tool input from content_start for use at content_end */
+	setStreamingToolContext(toolName: string, input: unknown): void {
+		this.streamingToolName = toolName
+		this.streamingToolInput = input
+	}
+
+	/** Remember the approval prompt row for a tool call after the user approves it. */
+	recordApprovedToolMessageTs(toolCallId: string, messageTs: number): void {
+		this.approvedToolMessageTsByCallId.set(toolCallId, messageTs)
+	}
+
+	/** Clear approved prompt rows that no longer have a live tool event to consume them. */
+	clearApprovedToolMessageTs(): void {
+		this.approvedToolMessageTsByCallId.clear()
+	}
+
+	recordDeniedToolApproval(toolCallId: string, toolName: string, reason: string): void {
+		this.deniedToolApprovalsByCallId.set(toolCallId, { toolName, reason })
+	}
+
+	isToolApprovalDenied(toolCallId: string | undefined): boolean {
+		return toolCallId !== undefined && this.deniedToolApprovalsByCallId.has(toolCallId)
+	}
+
+	/**
+	 * Returns true when the given toolCallId was previously denied and its events should be
+	 * suppressed. This intentionally does not remove the entry because the denial must persist
+	 * past content_end so the follow-on error event can also be suppressed.
+	 */
+	checkDeniedToolApproval(toolCallId: string | undefined): boolean {
+		if (toolCallId === undefined || !this.deniedToolApprovalsByCallId.has(toolCallId)) {
+			return false
+		}
+		return true
+	}
+
+	isSuppressedToolApprovalDenial(value: unknown): boolean {
+		return isDeniedToolApprovalMistake(value, this.deniedToolApprovalsByCallId.values())
+	}
+
+	/** Reuse and remove a previously-approved prompt row for the matching tool event. */
+	consumeApprovedToolMessageTs(toolCallId: string | undefined): number | undefined {
+		if (!toolCallId) {
+			return undefined
+		}
+		const messageTs = this.approvedToolMessageTsByCallId.get(toolCallId)
+		if (messageTs !== undefined) {
+			this.approvedToolMessageTsByCallId.delete(toolCallId)
+		}
+		return messageTs
+	}
+
+	/** Force the active tool stream to update a known row instead of minting a new row. */
+	setStreamingToolTs(ts: number): void {
+		this.streamingToolTs = ts
+	}
+
+	/** Get the stored tool input (from content_start) */
+	getStreamingToolInput(): unknown | undefined {
+		return this.streamingToolInput
+	}
+
+	/** Get the stored tool name (from content_start) */
+	getStreamingToolName(): string | undefined {
+		return this.streamingToolName
+	}
+
+	/** Clear streaming tool */
+	clearStreamingTool(): number {
+		const ts = this.streamingToolTs ?? this.nextTs()
+		this.streamingToolTs = undefined
+		this.streamingToolInput = undefined
+		this.streamingToolName = undefined
+		return ts
+	}
+
+	/** Whether attempt_completion tool was called in this turn */
+	private attemptCompletionSeen = false
+
+	/** Mark that attempt_completion was called */
+	setAttemptCompletionSeen(): void {
+		this.attemptCompletionSeen = true
+	}
+
+	/** Check if attempt_completion was called in this turn */
+	wasAttemptCompletionSeen(): boolean {
+		return this.attemptCompletionSeen
+	}
+
+	// -----------------------------------------------------------------------
+	// spawn_agent tracking — aggregates parallel spawn_agent tool calls into
+	// the rich SubagentStatusRow UI (use_subagents + subagent messages).
+	// -----------------------------------------------------------------------
+
+	/** Active spawn_agent entries keyed by toolCallId */
+	private spawnAgentEntries = new Map<string, SubagentStatusItem>()
+	/** Stable timestamp for the combined say:"use_subagents" prompts message */
+	private spawnAgentPromptsTs: number | undefined
+	/** Stable timestamp for the combined say:"subagent" status message */
+	private spawnAgentStatusTs: number | undefined
+	/** Counter for assigning index to new spawn_agent entries */
+	private spawnAgentNextIndex = 0
+
+	/** Register a new spawn_agent call. Returns the entry for this call. */
+	addSpawnAgent(toolCallId: string, prompt: string): SubagentStatusItem {
+		const entry: SubagentStatusItem = {
+			index: ++this.spawnAgentNextIndex,
+			prompt,
+			status: "running",
+			toolCalls: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			totalCost: 0,
+			contextTokens: 0,
+			contextWindow: 0,
+			contextUsagePercentage: 0,
+		}
+		this.spawnAgentEntries.set(toolCallId, entry)
+		return entry
+	}
+
+	/** Get a spawn_agent entry by toolCallId */
+	getSpawnAgent(toolCallId: string): SubagentStatusItem | undefined {
+		return this.spawnAgentEntries.get(toolCallId)
+	}
+
+	/** Whether there are any active spawn_agent calls */
+	hasSpawnAgents(): boolean {
+		return this.spawnAgentEntries.size > 0
+	}
+
+	/** Whether any registered spawn_agent call has not finished yet. */
+	hasRunningSpawnAgents(): boolean {
+		return this.getSpawnAgentItems().some((entry) => entry.status === "running" || entry.status === "pending")
+	}
+
+	/** Get all spawn_agent entries as an ordered array */
+	getSpawnAgentItems(): SubagentStatusItem[] {
+		return Array.from(this.spawnAgentEntries.values()).sort((a, b) => a.index - b.index)
+	}
+
+	/** Get or create the stable timestamp for say:"use_subagents" prompts messages */
+	getSpawnAgentPromptsTs(): number {
+		if (!this.spawnAgentPromptsTs) {
+			this.spawnAgentPromptsTs = this.nextTs()
+		}
+		return this.spawnAgentPromptsTs
+	}
+
+	/** Force the aggregated spawn-agent prompt row to update a known approval row. */
+	setSpawnAgentPromptsTs(ts: number): void {
+		this.spawnAgentPromptsTs = ts
+	}
+
+	/** Get or create the stable timestamp for subagent status messages */
+	getSpawnAgentStatusTs(): number {
+		if (!this.spawnAgentStatusTs) {
+			this.spawnAgentStatusTs = this.nextTs()
+		}
+		return this.spawnAgentStatusTs
+	}
+
+	/** Build a ClineSaySubagentStatus from the current entries */
+	buildSubagentStatus(overallStatus: ClineSaySubagentStatus["status"]): ClineSaySubagentStatus {
+		const items = this.getSpawnAgentItems()
+		const completed = items.filter((e) => e.status === "completed" || e.status === "failed").length
+		const successes = items.filter((e) => e.status === "completed").length
+		const failures = items.filter((e) => e.status === "failed").length
+		return {
+			status: overallStatus,
+			total: items.length,
+			completed,
+			successes,
+			failures,
+			toolCalls: items.reduce((acc, e) => acc + (e.toolCalls || 0), 0),
+			inputTokens: items.reduce((acc, e) => acc + (e.inputTokens || 0), 0),
+			outputTokens: items.reduce((acc, e) => acc + (e.outputTokens || 0), 0),
+			contextWindow: items.reduce((acc, e) => Math.max(acc, e.contextWindow || 0), 0),
+			maxContextTokens: items.reduce((acc, e) => Math.max(acc, e.contextTokens || 0), 0),
+			maxContextUsagePercentage: items.reduce((acc, e) => Math.max(acc, e.contextUsagePercentage || 0), 0),
+			items,
+		}
+	}
+
+	/** Clear all spawn_agent state (called at iteration_start) */
+	clearSpawnAgents(): void {
+		this.spawnAgentEntries.clear()
+		this.spawnAgentPromptsTs = undefined
+		this.spawnAgentStatusTs = undefined
+		this.spawnAgentNextIndex = 0
+	}
+
+	/**
+	 * Reset per-iteration STREAMING state: the open text/reasoning/tool stream pointers and the
+	 * spawn-agent aggregation. Called on each `iteration_start`, which is mid-turn within the same
+	 * conversation, so it deliberately does NOT touch turn-outcome signals such as
+	 * `attemptCompletionSeen` — those are scoped to the whole turn and survive its iterations.
+	 */
+	reset(): void {
+		this.streamingTextTs = undefined
+		this.streamingReasoningTs = undefined
+		this.streamingToolTs = undefined
+		this.streamingToolInput = undefined
+		this.streamingToolName = undefined
+		this.clearApprovedToolMessageTs()
+		this.deniedToolApprovalsByCallId.clear()
+		this.clearSpawnAgents()
+	}
+
+	/**
+	 * Clear turn-outcome signals (`attemptCompletionSeen`). Called at a new user turn / task
+	 * boundary so each turn's phase is computed fresh; it is intentionally separate from the
+	 * per-iteration `reset()` so the completion signal persists across the iterations of one turn.
+	 */
+	clearTurnOutcome(): void {
+		this.attemptCompletionSeen = false
+	}
+}
+
+// ---------------------------------------------------------------------------
+// SDK tool name → classic ClineSayTool mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Map an SDK tool name and its input to a ClineSayTool object that the
+ * webview's ChatRow.tsx can render.
+ *
+ * The webview does `JSON.parse(message.text) as ClineSayTool` when
+ * `say === "tool"`, so the text MUST be valid ClineSayTool JSON.
+ *
+ * SDK tool names → classic tool names:
+ *   read_files/read_file               → readFile
+ *   list_files                         → listFilesTopLevel / listFilesRecursive
+ *   list_code_definition_names         → listCodeDefinitionNames
+ *   editor/replace_in_file             → editedExistingFile
+ *   write_to_file                      → newFileCreated
+ *   apply_patch                        → editedExistingFile
+ *   delete_file                        → fileDeleted
+ *   run_commands/execute_command       → (uses say="command", NOT say="tool")
+ *   search_codebase/search_files       → searchFiles
+ *   fetch_web_content/web_fetch        → webFetch
+ *   web_search                         → webSearch
+ *   skills/use_skill                   → useSkill
+ *   ask_question/ask_followup_question → (not a visual tool — handled by askQuestion executor in SdkController)
+ *   MCP tools (serverName__toolName)   → (handled before reaching sdkToolToClineSayTool — emitted as say="use_mcp_server")
+ */
+function sdkToolToClineSayTool(toolName: string, input?: unknown): ClineSayTool {
+	// Parse input if it's a string (some SDK tools pass stringified JSON)
+	const parsedInput = parseToolInput(input)
+
+	switch (toolName) {
+		case "read_files":
+		case "read_file": {
+			const fileRead = extractFileReads(parsedInput)[0]
+			return {
+				tool: "readFile",
+				path: fileRead?.path ?? "",
+				...readLineRangeFields(fileRead),
+			}
+		}
+
+		case "list_files": {
+			const dirPath = getStringField(parsedInput, "path") ?? ""
+			const recursive = getBooleanField(parsedInput, "recursive") ?? false
+			return {
+				tool: recursive ? "listFilesRecursive" : "listFilesTopLevel",
+				path: dirPath,
+			}
+		}
+
+		case "list_code_definition_names": {
+			const dirPath = getStringField(parsedInput, "path") ?? ""
+			return {
+				tool: "listCodeDefinitionNames",
+				path: dirPath,
+			}
+		}
+
+		case "editor":
+		case "replace_in_file": {
+			const filePath = getStringField(parsedInput, "path") ?? ""
+			const newText =
+				getStringField(parsedInput, "new_text") ??
+				getStringField(parsedInput, "new_str") ??
+				getStringField(parsedInput, "content")
+			const patch = getStringField(parsedInput, "patch") ?? getStringField(parsedInput, "diff")
+			const oldText = getStringField(parsedInput, "old_text") ?? getStringField(parsedInput, "old_str")
+			const isEdit = toolName === "replace_in_file" || !!oldText
+
+			// When the SDK provides both old and new text, build a search/replace
+			// diff in the format DiffEditRow expects. ChatRow passes `content` to
+			// DiffEditRow's `patch` prop, so the formatted diff must go into `content`.
+			const diffContent = oldText && newText ? `------- SEARCH\n${oldText}\n=======\n${newText}\n+++++++ REPLACE` : newText
+
+			return {
+				tool: isEdit ? "editedExistingFile" : "newFileCreated",
+				path: filePath,
+				content: diffContent,
+				diff: patch,
+			}
+		}
+
+		case "write_to_file": {
+			const filePath = getStringField(parsedInput, "path") ?? ""
+			const content = getStringField(parsedInput, "content") ?? getStringField(parsedInput, "new_text")
+			return {
+				tool: "newFileCreated",
+				path: filePath,
+				content,
+			}
+		}
+
+		case "apply_patch": {
+			const filePath = getStringField(parsedInput, "path") ?? ""
+			// The SDK sends apply_patch input as { input: 'apply_patch <<"EOF"\n*** Begin Patch\n...' }
+			// Also check the "patch" and "diff" fields for compatibility.
+			const patch =
+				getStringField(parsedInput, "patch") ??
+				getStringField(parsedInput, "diff") ??
+				getStringField(parsedInput, "input")
+			return {
+				tool: "editedExistingFile",
+				path: filePath,
+				// ChatRow passes `content` to DiffEditRow's `patch` prop,
+				// so we must populate `content` for the diff to render.
+				content: patch,
+				diff: patch,
+			}
+		}
+
+		case "delete_file": {
+			const filePath = getStringField(parsedInput, "path") ?? ""
+			return {
+				tool: "fileDeleted",
+				path: filePath,
+			}
+		}
+
+		case "search_codebase":
+		case "search_files": {
+			// The SDK's SearchCodebaseUnionInputSchema accepts multiple formats:
+			//   1. { queries: string[] }  — standard object (parsedInput handles this)
+			//   2. { queries: string }    — queries as single string
+			//   3. string[]               — bare array (parseToolInput returns undefined for arrays)
+			//   4. string                 — bare string (parseToolInput tries JSON.parse, returns undefined if not an object)
+			// We must handle all four to avoid showing empty regex in the UI.
+			let regex = ""
+			if (parsedInput) {
+				// Cases 1 & 2: input was an object with a "queries" field
+				const queries = getArrayField(parsedInput, "queries")
+				regex =
+					queries?.join(", ") ?? getStringField(parsedInput, "queries") ?? getStringField(parsedInput, "regex") ?? ""
+			} else if (Array.isArray(input)) {
+				// Case 3: bare array of query strings
+				regex = input.map(String).join(", ")
+			} else if (typeof input === "string") {
+				// Case 4: bare string query
+				regex = input
+			}
+			const path = getStringField(parsedInput, "path")
+			const filePattern = getStringField(parsedInput, "file_pattern") ?? getStringField(parsedInput, "filePattern")
+			return {
+				tool: "searchFiles",
+				regex,
+				path,
+				filePattern,
+			}
+		}
+
+		case "fetch_web_content":
+		case "web_fetch": {
+			// fetch_web_content carries { requests: [{ url, prompt }] };
+			// web_fetch carries { url, prompt } directly.
+			let url = getStringField(parsedInput, "url") ?? ""
+			if (!url && parsedInput) {
+				const requests = parsedInput.requests
+				if (Array.isArray(requests) && requests.length > 0) {
+					const firstRequest = requests[0]
+					if (typeof firstRequest === "object" && firstRequest !== null) {
+						url = ((firstRequest as Record<string, unknown>).url as string) ?? ""
+					}
+				}
+			}
+			return {
+				tool: "webFetch",
+				path: url,
+			}
+		}
+
+		case "web_search": {
+			const query = getStringField(parsedInput, "query") ?? getStringField(parsedInput, "q") ?? ""
+			return {
+				tool: "webSearch",
+				path: query,
+			}
+		}
+
+		case "skills":
+		case "use_skill": {
+			// skills carries { skill: "name", args?: "..." };
+			// use_skill carries { skill_name: "name" }.
+			const skillName =
+				getStringField(parsedInput, "skill_name") ??
+				getStringField(parsedInput, "skill") ??
+				getStringField(parsedInput, "name") ??
+				""
+			return {
+				tool: "useSkill",
+				path: skillName,
+			}
+		}
+
+		default: {
+			// MCP tools and unknown tools — pass through with the raw tool name.
+			const filePath =
+				getStringField(parsedInput, "path") ??
+				getStringField(parsedInput, "url") ??
+				getStringField(parsedInput, "command") ??
+				""
+			return {
+				tool: toolName as ClineSayTool["tool"],
+				path: filePath,
+			}
+		}
+	}
+}
+
+/**
+ * Parse tool input into a record if it's a string or object.
+ */
+function parseToolInput(input: unknown): Record<string, unknown> | undefined {
+	if (!input) return undefined
+	if (typeof input === "object" && !Array.isArray(input)) {
+		return input as Record<string, unknown>
+	}
+	if (typeof input === "string") {
+		try {
+			const parsed = JSON.parse(input)
+			if (typeof parsed === "object" && !Array.isArray(parsed)) {
+				return parsed
+			}
+		} catch {
+			// Not JSON — return undefined
+		}
+	}
+	return undefined
+}
+
+/**
+ * Whether a tool name is the agent's completion tool — the one that declares the task done and
+ * drives the green "Task Completed" box plus the `completed` turn phase. Two names are accepted:
+ * the VSCode extra tool `attempt_completion` and the SDK's built-in `submit_and_exit`
+ * (DefaultToolNames.SUBMIT_AND_EXIT, lifecycle.completesRun=true).
+ */
+function isCompletionTool(toolName: string): boolean {
+	return toolName === "submit_and_exit" || toolName === "attempt_completion"
+}
+
+/**
+ * Extract the completion summary text from a completion-tool input. `attempt_completion` carries
+ * it in `result`; `submit_and_exit` carries it in `summary`. Either renders the same completion UI.
+ */
+function getCompletionResultText(input: unknown): string {
+	const parsed = parseToolInput(input)
+	return getStringField(parsed, "summary") ?? getStringField(parsed, "result") ?? ""
+}
+
+/** A single file read request parsed from a read_files/read_file input */
+interface FileReadRequest {
+	path: string
+	startLine?: number
+	endLine?: number
+}
+
+/** Extract file read requests (path + optional one-based inclusive line range) from a read_files/read_file input */
+function extractFileReads(input: Record<string, unknown> | undefined): FileReadRequest[] {
+	if (!input) return []
+	const files = input.files
+	if (Array.isArray(files) && files.length > 0) {
+		const reads = files
+			.map((f): FileReadRequest => {
+				if (typeof f === "string") return { path: f }
+				if (typeof f === "object" && f !== null) {
+					const entry = f as Record<string, unknown>
+					return {
+						path: (entry.path as string) ?? "",
+						startLine: getNumberField(entry, "start_line"),
+						endLine: getNumberField(entry, "end_line"),
+					}
+				}
+				return { path: "" }
+			})
+			.filter((read) => read.path)
+		if (reads.length > 0) {
+			return reads
+		}
+	}
+	const singlePath =
+		(input.path as string) ?? (input.file_path as string) ?? (input.filePath as string) ?? (input.filename as string) ?? ""
+	return singlePath
+		? [{ path: singlePath, startLine: getNumberField(input, "start_line"), endLine: getNumberField(input, "end_line") }]
+		: []
+}
+
+/**
+ * Map a read request's line range onto ClineSayTool fields. An omitted start_line with an
+ * explicit end_line means the read began at line 1; an omitted end_line stays undefined
+ * (open-ended read — the UI renders it as "start+").
+ */
+function readLineRangeFields(read: FileReadRequest | undefined): Pick<ClineSayTool, "readLineStart" | "readLineEnd"> {
+	if (!read || (read.startLine == null && read.endLine == null)) {
+		return {}
+	}
+	return { readLineStart: read.startLine ?? 1, readLineEnd: read.endLine }
+}
+
+/** Get a string field from a parsed input object */
+function getStringField(input: Record<string, unknown> | undefined, field: string): string | undefined {
+	if (!input) return undefined
+	const value = input[field]
+	if (typeof value === "string") return value
+	return undefined
+}
+
+/** Get a finite number field from a parsed input object (null/non-number → undefined) */
+function getNumberField(input: Record<string, unknown> | undefined, field: string): number | undefined {
+	if (!input) return undefined
+	const value = input[field]
+	if (typeof value === "number" && Number.isFinite(value)) return value
+	return undefined
+}
+
+/** Get an array field from a parsed input object */
+function getArrayField(input: Record<string, unknown> | undefined, field: string): string[] | undefined {
+	if (!input) return undefined
+	const value = input[field]
+	if (Array.isArray(value)) return value.map(String)
+	return undefined
+}
+
+function formatStructuredCommand(command: unknown): string {
+	if (typeof command === "string") return command
+	if (command && typeof command === "object" && !Array.isArray(command)) {
+		const record = command as Record<string, unknown>
+		if (typeof record.command === "string") {
+			const args = Array.isArray(record.args) ? record.args.map(String) : []
+			return args.length > 0 ? `${record.command} ${args.join(" ")}` : record.command
+		}
+	}
+	return String(command)
+}
+
+function getCommandArrayField(input: Record<string, unknown> | undefined, field: string): string[] | undefined {
+	if (!input) return undefined
+	const value = input[field]
+	if (Array.isArray(value)) return value.map(formatStructuredCommand)
+	return undefined
+}
+
+/** Get a boolean field from a parsed input object */
+function getBooleanField(input: Record<string, unknown> | undefined, field: string): boolean | undefined {
+	if (!input) return undefined
+	const value = input[field]
+	if (typeof value === "boolean") return value
+	return undefined
+}
+
+/**
+ * Extract raw text output from an SDK tool's output.
+ *
+ * The SDK's run_commands tool returns `ToolOperationResult[]` where each
+ * result has `{ query, result, success, error? }`. The `result` field
+ * contains the raw terminal output as a string. If the output is already
+ * a string, it is returned as-is. If it's an array of ToolOperationResult
+ * objects, extract and join the text from each result.
+ */
+export function extractToolOutputText(output: unknown): string {
+	if (output == null) return ""
+	if (typeof output === "string") return output
+
+	// Handle ToolOperationResult[] from SDK tools (run_commands, search_codebase, etc.)
+	if (Array.isArray(output)) {
+		const parts: string[] = []
+		for (const item of output) {
+			if (typeof item === "string") {
+				parts.push(item)
+			} else if (typeof item === "object" && item !== null) {
+				const record = item as Record<string, unknown>
+				// ToolOperationResult has { query, result, success, error? }
+				if ("result" in record && typeof record.result === "string" && record.result) {
+					parts.push(record.result)
+				} else if ("error" in record && typeof record.error === "string" && record.error) {
+					parts.push(record.error)
+				}
+			}
+		}
+		if (parts.length > 0) {
+			return parts.join("\n")
+		}
+	}
+
+	// Fallback for unknown structured output
+	return JSON.stringify(output)
+}
+
+// ---------------------------------------------------------------------------
+// MCP tool detection
+// ---------------------------------------------------------------------------
+
+/**
+ * MCP tools created by `createMcpTools()` use `serverName__toolName` format
+ * (double underscore separator). This function detects MCP tools and parses
+ * the server name and tool name.
+ *
+ * Returns undefined if the tool name doesn't match the MCP naming convention.
+ */
+function parseMcpToolName(toolName: string): { serverName: string; toolName: string } | undefined {
+	const separatorIndex = toolName.indexOf("__")
+	if (separatorIndex <= 0) return undefined
+	const serverName = toolName.substring(0, separatorIndex)
+	const mcpToolName = toolName.substring(separatorIndex + 2)
+	if (!mcpToolName) return undefined
+	return { serverName, toolName: mcpToolName }
+}
+
+/**
+ * Build a ClineAskUseMcpServer JSON payload for MCP tool calls.
+ * This is what the webview's ChatRow expects when rendering MCP tool calls
+ * (message.ask === "use_mcp_server" or message.say === "use_mcp_server").
+ */
+function buildMcpToolPayload(mcpInfo: { serverName: string; toolName: string }, input?: unknown): string {
+	const parsedInput = parseToolInput(input)
+	// Format arguments as a JSON string (matching classic ClineAskUseMcpServer.arguments)
+	let argumentsStr: string | undefined
+	if (parsedInput && Object.keys(parsedInput).length > 0) {
+		argumentsStr = JSON.stringify(parsedInput, null, 2)
+	} else if (typeof input === "string" && input.trim()) {
+		argumentsStr = input
+	}
+
+	return JSON.stringify({
+		type: "use_mcp_tool",
+		serverName: mcpInfo.serverName,
+		toolName: mcpInfo.toolName,
+		arguments: argumentsStr,
+	} satisfies ClineAskUseMcpServer)
+}
+
+function extractCommandText(input: unknown): string {
+	if (Array.isArray(input)) {
+		return input.map(formatStructuredCommand).join(" && ")
+	}
+	if (typeof input === "string") {
+		return input
+	}
+	const parsedInput = parseToolInput(input)
+	const commands = getCommandArrayField(parsedInput, "commands")
+	return (
+		commands?.join(" && ") ??
+		(typeof parsedInput?.commands === "object" ? formatStructuredCommand(parsedInput.commands) : undefined) ??
+		getStringField(parsedInput, "commands") ??
+		(typeof parsedInput?.command === "string" ? formatStructuredCommand(parsedInput) : undefined) ??
+		""
+	)
+}
+
+/**
+ * Build the Cline approval ask message for an SDK tool approval request.
+ * Keeps approval prompts aligned with the SDK event translator so the webview
+ * can render specialized rows (MCP, commands, subagents) instead of a generic
+ * tool approval with missing context.
+ */
+export function buildToolApprovalAskMessage(toolName: string, input: unknown, ts: number): ClineMessage {
+	const mcpInfo = parseMcpToolName(toolName)
+	if (mcpInfo) {
+		return {
+			ts,
+			type: "ask",
+			ask: "use_mcp_server",
+			text: buildMcpToolPayload(mcpInfo, input),
+			partial: false,
+		}
+	}
+
+	if (toolName === "run_commands" || toolName === "execute_command") {
+		return {
+			ts,
+			type: "ask",
+			ask: "command",
+			text: extractCommandText(input),
+			partial: false,
+		}
+	}
+
+	if (toolName === "spawn_agent") {
+		const parsedInput = parseToolInput(input)
+		const taskPrompt = getStringField(parsedInput, "task") ?? ""
+		return {
+			ts,
+			type: "ask",
+			ask: "use_subagents",
+			text: JSON.stringify({
+				prompts: [taskPrompt],
+			} satisfies ClineAskUseSubagents),
+			partial: false,
+		}
+	}
+
+	return {
+		ts,
+		type: "ask",
+		ask: "tool",
+		text: JSON.stringify(sdkToolToClineSayTool(toolName, input)),
+		partial: false,
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Agent event translation
+// ---------------------------------------------------------------------------
+
+/**
+ * Translate an SDK AgentEvent into ClineMessage(s).
+ */
+function translateAgentEvent(event: AgentEvent, state: MessageTranslatorState): ClineMessage[] {
+	const messages: ClineMessage[] = []
+
+	switch (event.type) {
+		case "content_start": {
+			switch (event.contentType) {
+				case "text": {
+					// The SDK emits MULTIPLE content_start events for streaming text.
+					// Each has `text` (the delta) and `accumulated` (full text so far).
+					// We use `accumulated` so the webview can update the message in-place
+					// with the growing text, giving smooth streaming. Using `text` (delta)
+					// would cause a "flip book" effect where each update replaces the
+					// previous content with just the new chunk.
+					const ts = state.getStreamingTextTs()
+					messages.push({
+						ts,
+						type: "say",
+						say: "text",
+						text: event.accumulated ?? event.text ?? "",
+						partial: true,
+					})
+					break
+				}
+				case "reasoning": {
+					// SDK reasoning content_start events are deltas. The webview renders
+					// reasoning from `text`, so keep `text` and `reasoning` populated with
+					// the accumulated content for smooth in-place streaming.
+					const ts = state.getStreamingReasoningTs()
+					const reasoning = state.appendStreamingReasoning(event.reasoning ?? "")
+					messages.push({
+						ts,
+						type: "say",
+						say: "reasoning",
+						text: reasoning,
+						reasoning,
+						partial: true,
+					})
+					break
+				}
+				case "tool": {
+					const toolName = event.toolName ?? "unknown"
+					const input = event.input
+
+					if (state.isToolApprovalDenied(event.toolCallId)) {
+						break
+					}
+
+					// Store tool context so content_end can use it
+					// (content_end doesn't carry the input)
+					state.setStreamingToolContext(toolName, input)
+					const approvedToolMessageTs = state.consumeApprovedToolMessageTs(event.toolCallId)
+					if (approvedToolMessageTs !== undefined) {
+						state.setStreamingToolTs(approvedToolMessageTs)
+					}
+
+					// ask_question (and ask_followup_question) is NOT a visual tool row: the
+					// SdkInteractionCoordinator services it and emits the proper ask:"followup"
+					// message. Emitting a generic say:"tool" here would leave an orphan partial
+					// row that never finalizes. Suppress it (the CLI does the same).
+					if (toolName === "ask_question" || toolName === "ask_followup_question") {
+						break
+					}
+
+					// The completion tool (attempt_completion / submit_and_exit) is handled specially:
+					// it drives the green "Task Completed" rectangle. We emit say:"completion_result"
+					// here (partial) and finalize it at content_end. Recording attemptCompletionSeen
+					// makes the turn end in the "completed" phase ("Start New Task") rather than
+					// "awaiting_followup".
+					if (isCompletionTool(toolName)) {
+						state.setAttemptCompletionSeen()
+						const resultText = getCompletionResultText(input)
+						messages.push({
+							ts: state.getStreamingToolTs(),
+							type: "say",
+							say: "completion_result",
+							text: resultText,
+							partial: true,
+						})
+						break
+					}
+
+					// command tools use say="command" (not say="tool")
+					// because the webview renders commands differently
+					if (toolName === "run_commands" || toolName === "execute_command") {
+						const commandText = extractCommandText(input)
+						// ChatRow treats a command row as "executing" while the COMMAND_OUTPUT_STRING
+						// marker is present in the text (and the row isn't yet completed). Include the
+						// marker on the running row so it reflects the executing state. content_end
+						// rebuilds the full text (command + marker + output) and sets commandCompleted.
+						messages.push({
+							ts: state.getStreamingToolTs(),
+							type: "say",
+							say: "command",
+							text: `${commandText}\n${COMMAND_OUTPUT_STRING}`,
+							partial: true,
+						})
+						break
+					}
+					// spawn_agent → rich subagent UI (SubagentStatusRow)
+					// Emit say:"use_subagents" with prompts list, then say:"subagent"
+					// with running status. Multiple parallel spawn_agent calls in the
+					// same iteration are aggregated into a single status message.
+					if (toolName === "spawn_agent") {
+						const parsedInput = parseToolInput(input)
+						const taskPrompt = getStringField(parsedInput, "task") ?? ""
+						const callId = event.toolCallId ?? `spawn-${state.nextTs()}`
+						state.addSpawnAgent(callId, taskPrompt)
+						if (approvedToolMessageTs !== undefined) {
+							state.setSpawnAgentPromptsTs(approvedToolMessageTs)
+						}
+
+						// Emit the combined prompts list (replaces itself on each new spawn_agent)
+						const allPrompts = state.getSpawnAgentItems().map((e) => e.prompt)
+						const approvalPayload: ClineAskUseSubagents = {
+							prompts: allPrompts,
+						}
+						messages.push({
+							ts: state.getSpawnAgentPromptsTs(),
+							type: "say",
+							say: "use_subagents" as ClineSay,
+							text: JSON.stringify(approvalPayload),
+							partial: true,
+						})
+
+						// Clear the generic streaming tool so it doesn't also emit say:"tool"
+						state.clearStreamingTool()
+						break
+					}
+
+					// MCP tools use serverName__toolName naming convention.
+					// The webview renders MCP tool calls via say/ask="use_mcp_server"
+					// with ClineAskUseMcpServer JSON, not generic say="tool".
+					const mcpInfo = parseMcpToolName(toolName)
+					if (mcpInfo) {
+						const mcpPayload = buildMcpToolPayload(mcpInfo, input)
+						messages.push({
+							ts: state.getStreamingToolTs(),
+							type: "say",
+							say: "use_mcp_server" as ClineSay,
+							text: mcpPayload,
+							partial: true,
+						})
+						break
+					}
+
+					// All other tools → say="tool" with ClineSayTool JSON
+					const sayTool = sdkToolToClineSayTool(toolName, input)
+					messages.push({
+						ts: state.getStreamingToolTs(),
+						type: "say",
+						say: "tool",
+						text: JSON.stringify(sayTool),
+						partial: true,
+					})
+					break
+				}
+			}
+			break
+		}
+
+		case "content_update": {
+			// spawn_agent progress updates → emit say:"subagent" with live stats.
+			// The SDK's spawn_agent tool may emit content_update events with
+			// sub-agent progress (iterations, tool calls, usage). We translate
+			// these into the ClineSaySubagentStatus format for the rich UI.
+			const updateToolName = event.toolName ?? state.getStreamingToolName()
+			if (updateToolName === "spawn_agent" && state.hasSpawnAgents()) {
+				const callId = event.toolCallId ?? ""
+				const entry = callId ? state.getSpawnAgent(callId) : undefined
+				if (entry) {
+					// Apply progress from the update payload if available
+					const updateData = event.update as Record<string, unknown> | undefined
+					if (updateData) {
+						if (typeof updateData.toolCalls === "number") entry.toolCalls = updateData.toolCalls
+						if (typeof updateData.inputTokens === "number") entry.inputTokens = updateData.inputTokens
+						if (typeof updateData.outputTokens === "number") entry.outputTokens = updateData.outputTokens
+						if (typeof updateData.totalCost === "number") entry.totalCost = updateData.totalCost
+						if (typeof updateData.contextTokens === "number") entry.contextTokens = updateData.contextTokens
+						if (typeof updateData.contextWindow === "number") entry.contextWindow = updateData.contextWindow
+						if (typeof updateData.contextUsagePercentage === "number")
+							entry.contextUsagePercentage = updateData.contextUsagePercentage
+						if (typeof updateData.latestToolCall === "string") entry.latestToolCall = updateData.latestToolCall
+					}
+				}
+				// Emit a running status update
+				const status = state.buildSubagentStatus("running")
+				messages.push({
+					ts: state.getSpawnAgentStatusTs(),
+					type: "say",
+					say: "subagent" as ClineSay,
+					text: JSON.stringify(status),
+					partial: true,
+				})
+				break
+			}
+
+			// For all other tools, content_update is ignored — the
+			// content_start message with partial=true is sufficient until
+			// content_end finalizes it.
+			break
+		}
+
+		case "content_end": {
+			switch (event.contentType) {
+				case "text": {
+					const ts = state.clearStreamingText()
+					messages.push({
+						ts,
+						type: "say",
+						say: "text",
+						text: event.text ?? "",
+						partial: false,
+					})
+					break
+				}
+				case "reasoning": {
+					const ts = state.clearStreamingReasoning()
+					const reasoning = event.reasoning ?? ""
+					messages.push({
+						ts,
+						type: "say",
+						say: "reasoning",
+						text: reasoning,
+						reasoning,
+						partial: false,
+					})
+					break
+				}
+				case "tool": {
+					const toolName = event.toolName ?? "unknown"
+
+					if (state.checkDeniedToolApproval(event.toolCallId) || isKnownToolApprovalDenial(event.error)) {
+						state.clearStreamingTool()
+						break
+					}
+
+					// ask_question is serviced by the interaction coordinator (see content_start);
+					// it produces no transcript row of its own, so its content_end is a no-op.
+					if (toolName === "ask_question" || toolName === "ask_followup_question") {
+						break
+					}
+
+					// spawn_agent → finalize the subagent entry and emit
+					// say:"subagent" (completed/failed) + say:"subagent_usage".
+					// When all spawn_agent calls in this iteration finish, the
+					// final say:"subagent" has partial=false.
+					if (toolName === "spawn_agent") {
+						const callId = event.toolCallId ?? ""
+						const entry = callId ? state.getSpawnAgent(callId) : undefined
+						if (entry) {
+							// Extract output stats from SpawnAgentOutput
+							const output = event.output as Record<string, unknown> | undefined
+							if (output) {
+								entry.result = typeof output.text === "string" ? output.text : undefined
+								const usage = output.usage as Record<string, unknown> | undefined
+								if (usage) {
+									if (typeof usage.inputTokens === "number") entry.inputTokens = usage.inputTokens
+									if (typeof usage.outputTokens === "number") entry.outputTokens = usage.outputTokens
+								}
+							}
+							if (event.error) {
+								entry.status = "failed"
+								entry.error = event.error
+							} else {
+								entry.status = "completed"
+							}
+						}
+
+						// Determine overall status — all done when every entry is completed/failed
+						const items = state.getSpawnAgentItems()
+						const allDone = items.every((e) => e.status === "completed" || e.status === "failed")
+						const hasFailed = items.some((e) => e.status === "failed")
+						const overallStatus: ClineSaySubagentStatus["status"] = allDone
+							? hasFailed
+								? "failed"
+								: "completed"
+							: "running"
+
+						const status = state.buildSubagentStatus(overallStatus)
+						messages.push({
+							ts: state.getSpawnAgentStatusTs(),
+							type: "say",
+							say: "subagent" as ClineSay,
+							text: JSON.stringify(status),
+							partial: !allDone,
+						})
+
+						// When all done, emit subagent_usage for cost accounting
+						if (allDone) {
+							const usagePayload: ClineSubagentUsageInfo = {
+								source: "subagents",
+								tokensIn: items.reduce((acc, e) => acc + (e.inputTokens || 0), 0),
+								tokensOut: items.reduce((acc, e) => acc + (e.outputTokens || 0), 0),
+								cacheWrites: 0,
+								cacheReads: 0,
+								cost: items.reduce((acc, e) => acc + (e.totalCost || 0), 0),
+							}
+							messages.push({
+								ts: state.nextTs(),
+								type: "say",
+								say: "subagent_usage" as ClineSay,
+								text: JSON.stringify(usagePayload),
+								partial: false,
+							})
+						}
+
+						// Don't clear the generic streaming tool — spawn_agent
+						// didn't use it (we cleared it at content_start)
+						break
+					}
+
+					// Completion tool (attempt_completion / submit_and_exit) → finalize the green
+					// "Task Completed" rectangle. The partial say:"completion_result" was emitted at
+					// content_start; here we emit the non-partial version.
+					if (isCompletionTool(toolName)) {
+						const storedInput = state.getStreamingToolInput()
+						const ts = state.clearStreamingTool()
+						const resultText = getCompletionResultText(storedInput)
+						// Finalize the say:"completion_result" (non-partial)
+						// This renders the green "Task Completed" rectangle.
+						messages.push({
+							ts,
+							type: "say",
+							say: "completion_result",
+							text: resultText,
+							partial: false,
+						})
+						// Only the say:"completion_result" is emitted (the green box). No
+						// ask:"completion_result" is produced — the webview's footer/buttons read
+						// the authoritative TurnState (phase "completed") rather than the message
+						// tail, so the completion UI is immune to trailing bookkeeping events such as
+						// the usage say:"api_req_started" that arrives between content_end and done.
+						break
+					}
+
+					// command tools finalize as say="command" with commandCompleted=true.
+					// We keep the same timestamp to replace the streaming partial command row
+					// in-place, so it doesn't disappear (command_output rows are filtered out
+					// by combineCommandSequences in the chat pipeline).
+					if (toolName === "run_commands" || toolName === "execute_command") {
+						const storedInput = state.getStreamingToolInput()
+						const commandText = extractCommandText(storedInput)
+						const outputStr = event.error ? `Error: ${event.error}` : extractToolOutputText(event.output)
+						const ts = state.clearStreamingTool()
+						messages.push({
+							ts,
+							type: "say",
+							say: "command",
+							text: outputStr ? `${commandText}\n${COMMAND_OUTPUT_STRING}\n${outputStr}` : commandText,
+							partial: false,
+							commandCompleted: true,
+						})
+						break
+					}
+
+					// MCP tools → finalize as say="use_mcp_server" + say="mcp_server_response"
+					// The classic extension emits:
+					//   1. say/ask: "use_mcp_server" (tool call display with args)
+					//   2. say: "mcp_server_request_started" (spinner)
+					//   3. say: "mcp_server_response" (tool output)
+					// In the SDK path, by content_end the tool has already executed,
+					// so we emit the finalized tool call + response together.
+					const mcpInfoEnd = parseMcpToolName(toolName)
+					if (mcpInfoEnd) {
+						const storedMcpInput = state.getStreamingToolInput()
+						const mcpTs = state.clearStreamingTool()
+						const mcpPayload = buildMcpToolPayload(mcpInfoEnd, storedMcpInput)
+
+						// Finalize the use_mcp_server message (non-partial)
+						messages.push({
+							ts: mcpTs,
+							type: "say",
+							say: "use_mcp_server" as ClineSay,
+							text: mcpPayload,
+							partial: false,
+						})
+
+						// Emit the MCP server response with the tool output
+						const mcpOutputStr = event.error ? `Error: ${event.error}` : extractToolOutputText(event.output)
+						if (mcpOutputStr) {
+							messages.push({
+								ts: state.nextTs(),
+								type: "say",
+								say: "mcp_server_response" as ClineSay,
+								text: mcpOutputStr,
+								partial: false,
+							})
+						}
+						break
+					}
+
+					// All other tools → finalize the say="tool" message
+					// Use the stored input from content_start since content_end
+					// doesn't carry the input (S6-24 fix)
+					const storedInput = state.getStreamingToolInput()
+					const ts = state.clearStreamingTool()
+
+					// Special handling: read_files may read multiple files in one tool call.
+					// Emit one readFile UI message per file so the tool group summary and
+					// list reflect what was actually read.
+					if (toolName === "read_files" || toolName === "read_file") {
+						const parsedInput = parseToolInput(storedInput)
+						const fileReads = extractFileReads(parsedInput)
+						if (fileReads.length > 1) {
+							fileReads.forEach((fileRead, index) => {
+								messages.push({
+									ts: index === 0 ? ts : state.nextTs(),
+									type: "say",
+									say: "tool",
+									text: JSON.stringify({
+										tool: "readFile",
+										path: fileRead.path,
+										...readLineRangeFields(fileRead),
+									} satisfies ClineSayTool),
+									partial: false,
+								})
+							})
+							break
+						}
+					}
+
+					const sayTool = sdkToolToClineSayTool(toolName, storedInput)
+					// If there's an error, include it in the tool message
+					if (event.error) {
+						messages.push({
+							ts,
+							type: "say",
+							say: "tool",
+							text: JSON.stringify(sayTool),
+							partial: false,
+						})
+						// Also push an error message
+						messages.push({
+							ts: state.nextTs(),
+							type: "say",
+							say: "error",
+							text: event.error,
+							partial: false,
+						})
+					} else {
+						messages.push({
+							ts,
+							type: "say",
+							say: "tool",
+							text: JSON.stringify(sayTool),
+							partial: false,
+						})
+					}
+					break
+				}
+			}
+			break
+		}
+
+		case "iteration_start": {
+			// New iteration — reset streaming state for the new turn
+			state.reset()
+
+			// Emit an api_req_started message before each API request so the
+			// webview shows its request spinner and cost display.
+			messages.push({
+				ts: state.nextTs(),
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify({
+					request: undefined, // Will be filled in by usage event
+				} satisfies ClineApiReqInfo),
+				partial: false,
+			})
+			break
+		}
+
+		case "iteration_end": {
+			// Iteration ended — no specific message needed
+			break
+		}
+
+		case "notice": {
+			// Agent notices are informational
+			messages.push({
+				ts: state.nextTs(),
+				type: "say",
+				say: "info",
+				text: event.message ?? "",
+				partial: false,
+			})
+			break
+		}
+
+		case "usage": {
+			// Usage events carry token counts. The webview reads them from an
+			// api_req_started message's ClineApiReqInfo, so emit a follow-up
+			// api_req_started update carrying the usage data for cost display.
+			const usageEvent = normalizeUsageEvent(event)
+			const apiReqInfo: ClineApiReqInfo = {
+				tokensIn: usageEvent.tokensIn,
+				tokensOut: usageEvent.tokensOut,
+				cacheWrites: usageEvent.cacheWrites,
+				cacheReads: usageEvent.cacheReads,
+				cost: usageEvent.totalCost,
+			}
+			messages.push({
+				ts: state.nextTs(),
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify(apiReqInfo),
+				partial: false,
+			})
+			break
+		}
+
+		case "done": {
+			// Agent turn is complete. This emits no transcript message — it only signals
+			// turnComplete to the caller. UI mode comes from the authoritative TurnState the
+			// session-event coordinator sets on turn end (completed when the completion tool was
+			// used this turn, otherwise awaiting_followup), and the green "Task Completed" box
+			// comes from the say:"completion_result" emitted at the completion tool's content_end.
+			break
+		}
+
+		case "error": {
+			if (state.isSuppressedToolApprovalDenial(event.error)) {
+				break
+			}
+
+			// Serialize the error message for the webview's ErrorRow to parse.
+			// The webview uses ClineError.parse() on the `api_req_failed` text to
+			// detect special error types (insufficient credits, spend limit, auth,
+			// quota exceeded) and render appropriate UI (e.g. "Add Credits" button).
+			//
+			// The error object from the SDK is a standard JS Error. Its `message`
+			// may contain JSON from the API (e.g. Cline provider's 402 response with
+			// `code: "insufficient_credits"`). We try to reshape it into the
+			// ClineError-serialized format the webview expects so that ErrorRow
+			// can render the correct UI (Buy Credits button, etc.).
+			const errorPayload = reshapeErrorForWebview(event.error, state.activeProviderId())
+
+			// Emit an api_req_started with streamingFailedMessage so the
+			// RequestStartRow renders the error via ErrorRow. This replaces
+			// the spinner on the last API request row.
+			messages.push({
+				ts: state.nextTs(),
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify({
+					streamingFailedMessage: errorPayload,
+				} satisfies ClineApiReqInfo),
+				partial: false,
+			})
+
+			// Emit ask:"api_req_failed" as the LAST message so the webview
+			// shows error recovery UI (Retry button, Add Credits button,
+			// Sign In button, etc.) instead of a stuck "Thinking..." spinner.
+			messages.push({
+				ts: state.nextTs(),
+				type: "ask",
+				ask: "api_req_failed",
+				text: errorPayload,
+				partial: false,
+			})
+			break
+		}
+
+		default: {
+			// Log unhandled event types for debugging
+			Logger.warn(`[MessageTranslator] Unhandled agent event type: ${(event as AgentEvent).type}`)
+			break
+		}
+	}
+
+	return messages
+}
+
+// ---------------------------------------------------------------------------
+// Core session event translation
+// ---------------------------------------------------------------------------
+
+/**
+ * Translate an SDK CoreSessionEvent into a TranslationResult.
+ *
+ * This is the primary entry point for event translation. It handles
+ * both top-level session events (chunk, ended, status) and nested
+ * agent events.
+ */
+export function translateSessionEvent(event: CoreSessionEvent, state: MessageTranslatorState): TranslationResult {
+	const result: TranslationResult = {
+		messages: [],
+		sessionEnded: false,
+		turnComplete: false,
+	}
+
+	switch (event.type) {
+		case "chunk": {
+			// Raw chunk events from the session stream.
+			// IMPORTANT: We do NOT emit these as text messages. The SDK sends
+			// raw model output (which may contain JSON, tool call fragments, etc.)
+			// as chunk events. The structured agent_event system (content_start,
+			// content_update, content_end) is the proper way to get displayable
+			// content. Emitting raw chunks would show JSON like
+			// {"type":"iteration_start",...} in the webview.
+			//
+			// The chunk events are useful for logging but should not be
+			// displayed to the user.
+			break
+		}
+
+		case "agent_event": {
+			// Sub-agent events should NOT produce ClineMessages in the main chat.
+			// The sub-agent's work is represented by the parent's spawn_agent tool
+			// events (content_start/update/end), which we translate into the rich
+			// SubagentStatusRow UI. Without this filter, every sub-agent tool call,
+			// text output, iteration, and usage event floods the main chat.
+			const agentEvent = event.payload.event
+			const isToolLifecycleEvent =
+				agentEvent.type === "content_start" || agentEvent.type === "content_update" || agentEvent.type === "content_end"
+			const isSpawnAgentToolEvent =
+				isToolLifecycleEvent && agentEvent.contentType === "tool" && agentEvent.toolName === "spawn_agent"
+
+			// Newer SDK events carry parentAgentId on sub-agent events. Older/local
+			// RuntimeEventAdapter output does not, so while spawn_agent calls are in
+			// flight we also suppress every non-spawn_agent event. This preserves the
+			// parent spawn_agent status updates while hiding sub-agent internals.
+			if (agentEvent.parentAgentId || (state.hasRunningSpawnAgents() && !isSpawnAgentToolEvent)) {
+				break
+			}
+
+			// Agent events contain structured content (text, reasoning, tools)
+			const agentMessages = translateAgentEvent(agentEvent, state)
+			result.messages.push(...agentMessages)
+
+			// Check for done/error events
+			if (agentEvent.type === "done") {
+				result.turnComplete = true
+			}
+			if (agentEvent.type === "error" && !state.isSuppressedToolApprovalDenial(agentEvent.error)) {
+				result.turnComplete = true
+			}
+
+			// Track tool success/error for consecutive mistake counting.
+			// A content_end event with contentType "tool" signals a completed
+			// tool call — if event.error is set, the tool failed.
+			if (agentEvent.type === "content_end" && agentEvent.contentType === "tool") {
+				if (
+					agentEvent.error &&
+					!isKnownToolApprovalDenial(agentEvent.error) &&
+					!state.isToolApprovalDenied(agentEvent.toolCallId)
+				) {
+					result.toolError = true
+				} else if (!agentEvent.error) {
+					result.toolSuccess = true
+				}
+			}
+
+			// Extract usage from usage events
+			if (agentEvent.type === "usage") {
+				result.usage = normalizeUsageEvent(agentEvent)
+			}
+			break
+		}
+
+		case "ended": {
+			result.sessionEnded = true
+			result.turnComplete = true
+			state.reset()
+			break
+		}
+
+		case "hook": {
+			// Sub-agent hook events are internal progress and should not pollute the
+			// main chat. Their aggregate progress is shown by SubagentStatusRow.
+			if (event.payload.parentAgentId) {
+				break
+			}
+
+			// Tool hook events — translate to hook_status messages
+			const payload = event.payload
+			const hookName = payload.hookEventName
+			const toolName = payload.toolName
+
+			if (hookName === "tool_call") {
+				result.messages.push({
+					ts: state.nextTs(),
+					type: "say",
+					say: "hook_status" as ClineSay,
+					text: toolName ? `Running ${toolName}...` : "Running tool...",
+					partial: false,
+				})
+			} else if (hookName === "tool_result") {
+				result.messages.push({
+					ts: state.nextTs(),
+					type: "say",
+					say: "hook_status" as ClineSay,
+					text: toolName ? `${toolName} completed` : "Tool completed",
+					partial: false,
+				})
+			}
+			break
+		}
+
+		case "status": {
+			// Status updates — informational
+			Logger.log(`[MessageTranslator] Session status: ${event.payload.status}`)
+			break
+		}
+
+		case "pending_prompt_submitted": {
+			const { prompt, userImages, userFiles } = event.payload
+			const hasPrompt = prompt.trim().length > 0
+			const hasImages = (userImages?.length ?? 0) > 0
+			const hasFiles = (userFiles?.length ?? 0) > 0
+			if (hasPrompt || hasImages || hasFiles) {
+				result.messages.push({
+					ts: state.nextTs(),
+					type: "say",
+					say: "user_feedback",
+					text: prompt,
+					images: userImages,
+					files: userFiles,
+					partial: false,
+				})
+			}
+			break
+		}
+
+		case "team_progress":
+		case "pending_prompts": {
+			// These are handled by the team/subagent system, not translated
+			// to ClineMessages at this layer
+			break
+		}
+
+		default: {
+			Logger.warn(`[MessageTranslator] Unhandled session event type: ${(event as CoreSessionEvent).type}`)
+			break
+		}
+	}
+
+	return result
+}
+
+// ---------------------------------------------------------------------------
+// Persisted SDK message history translation
+// ---------------------------------------------------------------------------
+
+type SdkContentBlock = Exclude<SdkMessage["content"], string>[number]
+type SdkToolUseBlock = Extract<SdkContentBlock, { type: "tool_use" }>
+type SdkMessageWithMetrics = SdkMessage & {
+	metrics?: {
+		inputTokens?: number
+		outputTokens?: number
+		cacheReadTokens?: number
+		cacheWriteTokens?: number
+		cost?: number
+	}
+}
+
+function textContentBlocksToText(content: SdkMessage["content"]): string {
+	if (typeof content === "string") {
+		return content.trim()
+	}
+
+	const text: string[] = []
+	for (const block of content) {
+		if (block.type === "text" && block.text.trim()) {
+			text.push(block.text.trim())
+		} else if (block.type === "file" && block.content.trim()) {
+			text.push(block.content.trim())
+		}
+	}
+	return text.join("\n").trim()
+}
+
+function agentEventToMessages(event: AgentEvent, state: MessageTranslatorState): ClineMessage[] {
+	return translateSessionEvent(
+		{
+			type: "agent_event",
+			payload: {
+				sessionId: "history",
+				event,
+			},
+		},
+		state,
+	).messages
+}
+
+function appendPersistedMetricsMessage(
+	clineMessages: ClineMessage[],
+	message: SdkMessageWithMetrics,
+	state: MessageTranslatorState,
+): void {
+	if (!message.metrics) {
+		return
+	}
+
+	const usage = normalizeUsageEvent({
+		inputTokens: message.metrics.inputTokens,
+		outputTokens: message.metrics.outputTokens,
+		cacheReadTokens: message.metrics.cacheReadTokens,
+		cacheWriteTokens: message.metrics.cacheWriteTokens,
+		cost: message.metrics.cost,
+	})
+
+	if (
+		usage.tokensIn === 0 &&
+		usage.tokensOut === 0 &&
+		(usage.cacheWrites ?? 0) === 0 &&
+		(usage.cacheReads ?? 0) === 0 &&
+		(usage.totalCost ?? 0) === 0
+	) {
+		return
+	}
+
+	clineMessages.push({
+		ts: state.nextTs(),
+		type: "say",
+		say: "api_req_started",
+		text: JSON.stringify({
+			tokensIn: usage.tokensIn,
+			tokensOut: usage.tokensOut,
+			cacheWrites: usage.cacheWrites,
+			cacheReads: usage.cacheReads,
+			cost: usage.totalCost,
+		} satisfies ClineApiReqInfo),
+		partial: false,
+	})
+}
+
+function finalizePersistedToolUse(
+	toolUse: SdkToolUseBlock,
+	state: MessageTranslatorState,
+	output?: unknown,
+	isError?: boolean,
+): ClineMessage[] {
+	// Reuse the same content_start → content_end path as live SDK events. The
+	// start event seeds MessageTranslatorState with the tool input; the end event
+	// produces the final non-partial ClineMessage shape the webview expects.
+	agentEventToMessages(
+		{
+			type: "content_start",
+			contentType: "tool",
+			toolName: toolUse.name,
+			toolCallId: toolUse.id,
+			input: toolUse.input,
+		} as AgentEvent,
+		state,
+	)
+
+	return agentEventToMessages(
+		{
+			type: "content_end",
+			contentType: "tool",
+			toolName: toolUse.name,
+			toolCallId: toolUse.id,
+			output,
+			error: isError ? extractToolOutputText(output) : undefined,
+		} as AgentEvent,
+		state,
+	)
+}
+
+/**
+ * Convert SDK-persisted LLM messages back into the ClineMessage format used by
+ * the webview. Keep this in the live message translator so history rendering
+ * and streaming rendering share the same SDK tool → Cline UI mapping.
+ */
+export function sdkMessagesToClineMessages(messages: SdkMessageWithMetrics[], minter?: MessageIdMinter): ClineMessage[] {
+	const clineMessages: ClineMessage[] = []
+	// Use the process-wide minter when provided so regenerated history ids are globally unique
+	// and never overlap live-session ids. Falls back to a private minter for standalone tests.
+	const state = new MessageTranslatorState(minter)
+	const pendingToolUses = new Map<string, SdkToolUseBlock>()
+
+	const flushUnmatchedToolUses = () => {
+		for (const toolUse of pendingToolUses.values()) {
+			clineMessages.push(...finalizePersistedToolUse(toolUse, state))
+		}
+		pendingToolUses.clear()
+	}
+
+	for (const message of messages) {
+		if (message.role === "assistant") {
+			flushUnmatchedToolUses()
+
+			if (typeof message.content === "string") {
+				const text = message.content.trim()
+				if (text) {
+					clineMessages.push(
+						...agentEventToMessages({ type: "content_end", contentType: "text", text } as AgentEvent, state),
+					)
+				}
+				appendPersistedMetricsMessage(clineMessages, message, state)
+				continue
+			}
+
+			for (const block of message.content) {
+				switch (block.type) {
+					case "text":
+						if (block.text.trim()) {
+							clineMessages.push(
+								...agentEventToMessages(
+									{
+										type: "content_end",
+										contentType: "text",
+										text: block.text.trim(),
+									} as AgentEvent,
+									state,
+								),
+							)
+						}
+						break
+					case "thinking":
+						if (block.thinking.trim()) {
+							clineMessages.push(
+								...agentEventToMessages(
+									{
+										type: "content_end",
+										contentType: "reasoning",
+										reasoning: block.thinking.trim(),
+									} as AgentEvent,
+									state,
+								),
+							)
+						}
+						break
+					case "tool_use":
+						pendingToolUses.set(block.id, block)
+						break
+				}
+			}
+			appendPersistedMetricsMessage(clineMessages, message, state)
+			continue
+		}
+
+		if (typeof message.content === "string") {
+			const text = message.content.trim()
+			if (text) {
+				clineMessages.push({
+					ts: state.nextTs(),
+					type: "say",
+					say: clineMessages.length === 0 ? "task" : "user_feedback",
+					text,
+					partial: false,
+				})
+			}
+			continue
+		}
+
+		const userText = textContentBlocksToText(message.content)
+		if (userText) {
+			clineMessages.push({
+				ts: state.nextTs(),
+				type: "say",
+				say: clineMessages.length === 0 ? "task" : "user_feedback",
+				text: userText,
+				partial: false,
+			})
+		}
+
+		for (const block of message.content) {
+			if (block.type !== "tool_result") {
+				continue
+			}
+
+			const toolUse = pendingToolUses.get(block.tool_use_id)
+			if (!toolUse) {
+				continue
+			}
+
+			pendingToolUses.delete(block.tool_use_id)
+			clineMessages.push(...finalizePersistedToolUse(toolUse, state, block.content, block.is_error))
+		}
+	}
+
+	// Always emit ask:"completion_result"
+	// as the LAST message so it comes after the usage event's
+	// say:"api_req_started". This is critical: the webview uses
+	// the last raw message to determine UI state. If the usage
+	// event is last, the webview shows "Thinking..." instead of
+	// the completion UI
+	clineMessages.push({
+		ts: state.nextTs(),
+		type: "ask",
+		ask: "completion_result",
+		text: "",
+		partial: false,
+	})
+
+	flushUnmatchedToolUses()
+	return clineMessages
+}
+
+// ---------------------------------------------------------------------------
+// HistoryItem ↔ SessionRecord mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Map a HistoryItem (classic format) to a partial SessionRecord-like object.
+ * Used when loading tasks from legacy storage.
+ */
+export function historyItemToSessionFields(item: {
+	id: string
+	task: string
+	ts: number
+	tokensIn: number
+	tokensOut: number
+	totalCost: number
+	modelId?: string
+}): {
+	sessionId: string
+	prompt: string
+	startedAt: string
+	usage: { tokensIn: number; tokensOut: number; totalCost: number }
+	modelId?: string
+} {
+	return {
+		sessionId: item.id,
+		prompt: item.task,
+		startedAt: new Date(item.ts).toISOString(),
+		usage: {
+			tokensIn: item.tokensIn,
+			tokensOut: item.tokensOut,
+			totalCost: item.totalCost,
+		},
+		modelId: item.modelId,
+	}
+}
+
+const MODEL_NOT_FOUND_GUIDANCE =
+	"This model may be retired or unavailable on your account. Switch to a different model in API Configuration settings, then retry."
+
+/**
+ * Rewrite a model-not-found error into actionable guidance, or undefined if the
+ * message is not one. The provider's HTTP status is stripped upstream, so this
+ * matches on text rather than a status code.
+ */
+function describeModelNotFoundError(rawMessage: string): string | undefined {
+	// Anthropic's 404 body collapses to a bare "model: <id>" label.
+	const bareModelLabel = rawMessage.match(/^\s*model:\s*(\S+)\s*$/i)
+	if (bareModelLabel) {
+		return `Model "${bareModelLabel[1]}" was not found. ${MODEL_NOT_FOUND_GUIDANCE}`
+	}
+
+	// Keep the not-found signal in the same clause as "model" so errors that
+	// merely mention one (plan gating, deprecated features) are left untouched.
+	const modelNotFound = /\bmodel\b[^.,;:]*\b(not[ _]?found|does not exist|no such model|unknown model)\b/i
+	if (modelNotFound.test(rawMessage)) {
+		return `${rawMessage} ${MODEL_NOT_FOUND_GUIDANCE}`
+	}
+
+	return undefined
+}
+
+/**
+ * Reshape an SDK error into the serialized ClineError JSON the webview's
+ * ErrorRow expects (`code`, `providerId`, `details`), extracting structured
+ * info from the error message when present and falling back to raw text.
+ */
+export function reshapeErrorForWebview(
+	error: { message?: string; status?: number; code?: string },
+	providerId = "cline",
+): string {
+	const rawMessage = error.message ?? "Unknown error"
+
+	// Try to extract structured error info from the error message.
+	// The SDK often wraps API error JSON in the Error.message field.
+	let parsed: Record<string, unknown> | undefined
+	try {
+		parsed = JSON.parse(rawMessage)
+	} catch {
+		// Not JSON — try to find JSON embedded in the message
+		// (e.g. "Error: {\"code\":\"insufficient_credits\",...}")
+		const jsonMatch = rawMessage.match(/\{[\s\S]*"code"[\s\S]*\}/)
+		if (jsonMatch) {
+			try {
+				parsed = JSON.parse(jsonMatch[0])
+			} catch {
+				// ignore
+			}
+		}
+	}
+
+	if (!parsed) {
+		// Plain-text error — the SDK sometimes strips structured API error JSON
+		// and delivers only a human-readable string such as
+		// "Not enough credits available" or "Your daily spend limit of $20.00
+		// has been reached." Detect these by keyword and synthesize the
+		// ClineError-compatible JSON the webview expects.
+		const lower = rawMessage.toLowerCase()
+		if (
+			lower.includes("insufficient_credits") ||
+			lower.includes("insufficient credits") ||
+			lower.includes("insufficient balance") ||
+			lower.includes("not enough credits") ||
+			lower.includes("run out of credits") ||
+			lower.includes("out of credits")
+		) {
+			// Extract balance from text like "balance is $-0.14" if present
+			const balanceMatch = rawMessage.match(/\$(-?\d+(?:\.\d+)?)/)
+			const balance = balanceMatch ? Number.parseFloat(balanceMatch[1]) : 0
+			return JSON.stringify({
+				message: rawMessage,
+				code: "insufficient_credits",
+				providerId,
+				details: {
+					current_balance: balance,
+					message: rawMessage,
+				},
+			})
+		}
+		if (lower.includes("spend_limit_exceeded") || lower.includes("spend limit")) {
+			return JSON.stringify({
+				message: rawMessage,
+				code: "SPEND_LIMIT_EXCEEDED",
+				providerId,
+				details: {
+					code: "SPEND_LIMIT_EXCEEDED",
+					message: rawMessage,
+				},
+			})
+		}
+		const notFoundMessage = describeModelNotFoundError(rawMessage)
+		if (notFoundMessage) {
+			return notFoundMessage
+		}
+		return rawMessage
+	}
+
+	// Detect insufficient credits (402) — needs code + current_balance for
+	// ClineError.getErrorType() to return ClineErrorType.Balance
+	const code = (parsed.code as string) ?? error.code
+	if (code === "insufficient_credits" && typeof parsed.current_balance === "number") {
+		return JSON.stringify({
+			message: (parsed.message as string) ?? rawMessage,
+			code: "insufficient_credits",
+			providerId,
+			details: {
+				current_balance: parsed.current_balance,
+				total_spent: parsed.total_spent,
+				total_promotions: parsed.total_promotions,
+				message: (parsed.message as string) ?? "You have run out of credits.",
+				buy_credits_url: parsed.buy_credits_url,
+			},
+		})
+	}
+
+	// Detect spend limit exceeded (429)
+	if (code === "SPEND_LIMIT_EXCEEDED") {
+		return JSON.stringify({
+			message: (parsed.message as string) ?? rawMessage,
+			code: "SPEND_LIMIT_EXCEEDED",
+			providerId,
+			details: {
+				code: "SPEND_LIMIT_EXCEEDED",
+				limit_scope: parsed.limit_scope,
+				budget_period: parsed.budget_period,
+				limit_usd: parsed.limit_usd,
+				spent_usd: parsed.spent_usd,
+				resets_at: parsed.resets_at,
+				message: parsed.message,
+			},
+		})
+	}
+
+	// For other structured errors, pass through the parsed JSON so
+	// ClineError.parse() can still extract what it can.
+	return JSON.stringify(parsed)
+}
diff --git a/apps/vscode/src/sdk/model-catalog/catalog.test.ts b/apps/vscode/src/sdk/model-catalog/catalog.test.ts
new file mode 100644
index 0000000..fea6e6a
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/catalog.test.ts
@@ -0,0 +1,716 @@
+import type { ModelInfo } from "@shared/api"
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest"
+import type {
+	EffectiveProviderConfig,
+	Fingerprint,
+	ModelSelection,
+	ProviderConfigChange,
+	ProviderConfigReader,
+	ProviderModelsResult,
+} from "./contracts"
+import { computeConfigFingerprint } from "./fingerprint"
+import { parseProviderId } from "./provider-id"
+
+const mocks = vi.hoisted(() => ({
+	resolveProviderConfig: vi.fn(),
+	listLocalProviders: vi.fn(),
+	getBooleanFlagEnabled: vi.fn(() => false),
+	pollFeatureFlags: vi.fn(async (): Promise<void> => undefined),
+	getProviderSettings: vi.fn((): any => undefined),
+}))
+
+vi.mock("@cline/core", async (importOriginal: any) => {
+	const actual = await importOriginal()
+	return {
+		...actual,
+		resolveProviderConfig: mocks.resolveProviderConfig,
+		listLocalProviders: mocks.listLocalProviders,
+	}
+})
+
+vi.mock("@/services/feature-flags", () => ({
+	getFeatureFlagsService: () => ({
+		getBooleanFlagEnabled: mocks.getBooleanFlagEnabled,
+		poll: mocks.pollFeatureFlags,
+	}),
+}))
+
+vi.mock("@/services/logging/distinctId", () => ({
+	setDistinctId: vi.fn(),
+}))
+
+vi.mock("../provider-migration", () => ({
+	getProviderSettingsManager: () => ({
+		getProviderSettings: mocks.getProviderSettings,
+	}),
+}))
+
+const modelInfo: ModelInfo = {
+	supportsPromptCache: false,
+}
+
+type TestReader = ProviderConfigReader & {
+	setConfig(next: EffectiveProviderConfig): void
+	emit(event: ProviderConfigChange): void
+}
+
+// Warm the catalog module graph once before any test runs. catalog.ts statically
+// pulls in @cline/core, @cline/llms and @cline/shared, so the first test to call
+// `await import("./catalog")` otherwise pays the entire (>5s on CI) import cost
+// inside its own 5s test timeout and flakily fails. Importing here moves that cost
+// outside any per-test clock (hooks get a generous timeout of their own).
+beforeAll(async () => {
+	await import("./catalog")
+}, 60_000)
+
+beforeEach(() => {
+	mocks.resolveProviderConfig.mockReset()
+	mocks.listLocalProviders.mockReset()
+	mocks.getBooleanFlagEnabled.mockReset()
+	mocks.getBooleanFlagEnabled.mockReturnValue(false)
+	mocks.pollFeatureFlags.mockReset()
+	mocks.pollFeatureFlags.mockResolvedValue(undefined)
+	mocks.getProviderSettings.mockReset()
+	mocks.getProviderSettings.mockReturnValue(undefined)
+})
+
+function fingerprint(value: string): Fingerprint {
+	const providerId = parseProviderId("fingerprint-test")
+	return computeConfigFingerprint(providerId, { providerId, baseUrl: `https://${value}.example.com` })
+}
+
+function record(
+	providerId = parseProviderId("ollama"),
+	configFingerprint = fingerprint("a"),
+	modelId = "model-a",
+): Extract<ProviderModelsResult, { ok: true }> {
+	return {
+		ok: true,
+		providerId,
+		configFingerprint,
+		models: new Map([[modelId, modelInfo]]),
+		defaultModelId: modelId,
+		source: "sdk-dynamic",
+		fetchedAt: 1,
+	}
+}
+
+function makeReader(initialConfig: EffectiveProviderConfig, selection?: ModelSelection): TestReader {
+	let config = initialConfig
+	const listeners = new Set<(event: ProviderConfigChange) => void>()
+	return {
+		read: vi.fn(() => config),
+		readSelection: vi.fn(() => selection),
+		subscribe: vi.fn((listener: (event: ProviderConfigChange) => void) => {
+			listeners.add(listener)
+			return { dispose: () => listeners.delete(listener) }
+		}),
+		setConfig(next: EffectiveProviderConfig): void {
+			config = next
+		},
+		emit(event: ProviderConfigChange): void {
+			for (const listener of listeners) {
+				listener(event)
+			}
+		},
+	} as TestReader
+}
+
+function deferred<T>() {
+	let resolve!: (value: T) => void
+	let reject!: (reason?: unknown) => void
+	const promise = new Promise<T>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+	return { promise, resolve, reject }
+}
+
+describe("ProviderCatalog Phase 3.1 cache", () => {
+	it("returns cache hit only when provider and fingerprint both match", async () => {
+		const { _testing } = await import("./catalog")
+		let now = 100
+		const cache = _testing.createProviderModelsCache({ ttlMs: 50, now: () => now })
+		const ollama = parseProviderId("ollama")
+		const lmstudio = parseProviderId("lmstudio")
+		const fpA = fingerprint("a")
+		const fpB = fingerprint("b")
+		const cached = record(ollama, fpA)
+
+		cache.set(cached)
+
+		expect(cache.get(ollama, fpA)).toBe(cached)
+		expect(cache.get(ollama, fpB)).toBeUndefined()
+		expect(cache.get(lmstudio, fpA)).toBeUndefined()
+		now = 120
+		expect(cache.get(ollama, fpA)).toBe(cached)
+	})
+
+	it("does not collide for different fingerprints", async () => {
+		const { _testing } = await import("./catalog")
+		const cache = _testing.createProviderModelsCache({ ttlMs: 50, now: () => 100 })
+		const providerId = parseProviderId("ollama")
+		const fpA = fingerprint("a")
+		const fpB = fingerprint("b")
+		const recordA = record(providerId, fpA, "model-a")
+		const recordB = record(providerId, fpB, "model-b")
+
+		cache.set(recordA)
+		cache.set(recordB)
+
+		expect(cache.get(providerId, fpA)).toBe(recordA)
+		expect(cache.get(providerId, fpB)).toBe(recordB)
+		expect(cache._cacheSize()).toBe(2)
+	})
+
+	it("reuses in-flight promise only when provider and fingerprint both match", async () => {
+		const { _testing } = await import("./catalog")
+		const cache = _testing.createProviderModelsCache({ ttlMs: 50, now: () => 100 })
+		const ollama = parseProviderId("ollama")
+		const lmstudio = parseProviderId("lmstudio")
+		const fpA = fingerprint("a")
+		const fpB = fingerprint("b")
+		let loadCount = 0
+		const load = async (nextRecord: ReturnType<typeof record>) => {
+			loadCount++
+			await Promise.resolve()
+			return nextRecord
+		}
+
+		const first = cache.resolve({ providerId: ollama, fingerprint: fpA, load: () => load(record(ollama, fpA)) })
+		const second = cache.resolve({ providerId: ollama, fingerprint: fpA, load: () => load(record(ollama, fpA, "other")) })
+		const third = cache.resolve({ providerId: ollama, fingerprint: fpB, load: () => load(record(ollama, fpB)) })
+		const fourth = cache.resolve({ providerId: lmstudio, fingerprint: fpA, load: () => load(record(lmstudio, fpA)) })
+
+		expect(second).toBe(first)
+		expect(cache._inFlightSize()).toBe(3)
+		await Promise.all([first, second, third, fourth])
+		expect(loadCount).toBe(3)
+		expect(cache._inFlightSize()).toBe(0)
+	})
+
+	it("returns undefined and removes expired records", async () => {
+		const { _testing } = await import("./catalog")
+		let now = 100
+		const cache = _testing.createProviderModelsCache({ ttlMs: 10, now: () => now })
+		const providerId = parseProviderId("ollama")
+		const fp = fingerprint("a")
+		cache.set(record(providerId, fp))
+
+		now = 109
+		expect(cache.get(providerId, fp)).toBeDefined()
+		now = 110
+		expect(cache.get(providerId, fp)).toBeUndefined()
+		expect(cache._cacheSize()).toBe(0)
+	})
+})
+
+describe("ProviderCatalog Phase 3.2 resolveModels happy path", () => {
+	it("keeps lowercase nousresearch in extension results while using SDK casing at the SDK boundary", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({
+			modelId: "DeepHermes-3-Llama-3-3-70B-Preview",
+			knownModels: {
+				"DeepHermes-3-Llama-3-3-70B-Preview": { id: "DeepHermes-3-Llama-3-3-70B-Preview" },
+			},
+		})
+		const providerId = parseProviderId("nousResearch")
+		const result = await createProviderCatalog(makeReader({ providerId })).resolveModels(providerId)
+
+		expect(providerId).toBe("nousresearch")
+		expect(result.ok).toBe(true)
+		if (!result.ok) throw new Error("expected success")
+		expect(result.providerId).toBe("nousresearch")
+		expect(result.defaultModelId).toBe("DeepHermes-3-Llama-3-3-70B-Preview")
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledWith(
+			"nousResearch",
+			expect.anything(),
+			expect.objectContaining({ providerId: "nousResearch" }),
+		)
+	})
+
+	it("resolves SDK knownModels, adapts model info, and uses SDK default when present", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({
+			modelId: "sdk-default",
+			baseUrl: "https://provider.example.com",
+			knownModels: {
+				"sdk-default": { id: "sdk-default", name: "Default", capabilities: ["images", "prompt-cache"] },
+				other: { id: "other", name: "Other" },
+			},
+		})
+		const providerId = parseProviderId("openrouter")
+		const config: EffectiveProviderConfig = { providerId, apiKey: "secret", baseUrl: "https://provider.example.com" }
+		const selection: ModelSelection = { providerId, modelId: "selected", modelInfo }
+		const reader = makeReader(config, selection)
+		const catalog = createProviderCatalog(reader)
+
+		const result = await catalog.resolveModels(providerId)
+
+		expect(result.ok).toBe(true)
+		if (!result.ok) throw new Error("expected success")
+		expect(result.providerId).toBe(providerId)
+		expect(result.configFingerprint).toBe(computeConfigFingerprint(providerId, config))
+		expect(result.defaultModelId).toBe("sdk-default")
+		expect(result.source).toBe("sdk-dynamic")
+		expect(result.models.get("sdk-default")).toMatchObject({
+			name: "Default",
+			supportsImages: true,
+			supportsPromptCache: true,
+		})
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledWith(
+			providerId,
+			expect.objectContaining({ loadLatestOnInit: true, loadPrivateOnAuth: true, failOnError: false }),
+			expect.objectContaining({
+				providerId,
+				modelId: "selected",
+				apiKey: "secret",
+				baseUrl: "https://provider.example.com",
+			}),
+		)
+	})
+
+	it("falls back to first model when SDK default is absent", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({
+			modelId: "missing-default",
+			baseUrl: "https://provider.example.com",
+			knownModels: {
+				first: { id: "first", name: "First" },
+				second: { id: "second", name: "Second" },
+			},
+		})
+		const providerId = parseProviderId("deepseek")
+		const reader = makeReader({ providerId })
+		const result = await createProviderCatalog(reader).resolveModels(providerId)
+
+		expect(result.ok).toBe(true)
+		if (!result.ok) throw new Error("expected success")
+		expect(result.defaultModelId).toBe("first")
+	})
+
+	it("returns cached result without calling SDK again for the same fingerprint", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({
+			modelId: "m",
+			baseUrl: "https://provider.example.com",
+			knownModels: { m: { id: "m", name: "M" } },
+		})
+		const providerId = parseProviderId("openrouter")
+		const catalog = createProviderCatalog(makeReader({ providerId, apiKey: "same" }))
+
+		const first = await catalog.resolveModels(providerId)
+		const second = await catalog.resolveModels(providerId)
+
+		expect(first).toBe(second)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+	})
+
+	it("forceRefresh bypasses cache but still uses current fingerprint", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig
+			.mockResolvedValueOnce({ modelId: "m1", knownModels: { m1: { id: "m1" } } })
+			.mockResolvedValueOnce({ modelId: "m2", knownModels: { m2: { id: "m2" } } })
+		const providerId = parseProviderId("openrouter")
+		const config: EffectiveProviderConfig = { providerId, apiKey: "same" }
+		const catalog = createProviderCatalog(makeReader(config))
+
+		const first = await catalog.resolveModels(providerId)
+		const second = await catalog.resolveModels(providerId, { forceRefresh: true })
+
+		expect(first.ok && first.defaultModelId).toBe("m1")
+		expect(second.ok && second.defaultModelId).toBe("m2")
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(2)
+	})
+
+	it("concurrent calls with the same provider and fingerprint share one SDK call", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		const pending = deferred<{ modelId: string; knownModels: Record<string, unknown> }>()
+		mocks.resolveProviderConfig.mockReturnValue(pending.promise)
+		const providerId = parseProviderId("openrouter")
+		const catalog = createProviderCatalog(makeReader({ providerId, apiKey: "same" }))
+
+		const first = catalog.resolveModels(providerId)
+		const second = catalog.resolveModels(providerId)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+		pending.resolve({ modelId: "m", knownModels: { m: { id: "m" } } })
+
+		expect(await second).toBe(await first)
+	})
+
+	it("concurrent calls with different fingerprints make separate SDK calls", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		const firstPending = deferred<{ modelId: string; knownModels: Record<string, unknown> }>()
+		const secondPending = deferred<{ modelId: string; knownModels: Record<string, unknown> }>()
+		mocks.resolveProviderConfig.mockReturnValueOnce(firstPending.promise).mockReturnValueOnce(secondPending.promise)
+		const providerId = parseProviderId("openrouter")
+		const reader = makeReader({ providerId, apiKey: "a" }) as ProviderConfigReader & {
+			setConfig(next: EffectiveProviderConfig): void
+		}
+		const catalog = createProviderCatalog(reader)
+
+		const first = catalog.resolveModels(providerId)
+		reader.setConfig({ providerId, apiKey: "b" })
+		const second = catalog.resolveModels(providerId)
+
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(2)
+		firstPending.resolve({ modelId: "a", knownModels: { a: { id: "a" } } })
+		secondPending.resolve({ modelId: "b", knownModels: { b: { id: "b" } } })
+		const firstResult = await first
+		const secondResult = await second
+		expect(firstResult.ok).toBe(true)
+		expect(secondResult.ok).toBe(true)
+		if (!firstResult.ok || !secondResult.ok) throw new Error("expected success")
+		expect(firstResult.defaultModelId).toBe("a")
+		expect(secondResult.defaultModelId).toBe("b")
+	})
+
+	it("throws before caching if loaded record does not match requested key", async () => {
+		const { _testing } = await import("./catalog")
+		const providerId = parseProviderId("openrouter")
+		const otherProviderId = parseProviderId("deepseek")
+		const fp = fingerprint("a")
+		expect(() => _testing.assertRecordMatchesRequest(record(otherProviderId, fp), providerId, fp)).toThrow(
+			/cache invariant failed/,
+		)
+	})
+})
+
+describe("ProviderCatalog Phase 3.3 error path", () => {
+	it("SDK rejection produces an error arm", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockRejectedValue(new Error("sdk unavailable"))
+		const providerId = parseProviderId("openrouter")
+		const config: EffectiveProviderConfig = { providerId, apiKey: "same" }
+		const result = await createProviderCatalog(makeReader(config)).resolveModels(providerId)
+
+		expect(result.ok).toBe(false)
+		if (result.ok) throw new Error("expected error")
+		expect(result.providerId).toBe(providerId)
+		expect(result.configFingerprint).toBe(computeConfigFingerprint(providerId, config))
+		expect(result.error).toEqual({ kind: "unknown", message: "sdk unavailable" })
+		expect(result.fetchedAt).toEqual(expect.any(Number))
+	})
+
+	it("shape validation failure produces a shape error arm", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({
+			modelId: "bad",
+			knownModels: { bad: { name: "missing id" } },
+		})
+		const providerId = parseProviderId("deepseek")
+		const result = await createProviderCatalog(makeReader({ providerId })).resolveModels(providerId)
+
+		expect(result.ok).toBe(false)
+		if (result.ok) throw new Error("expected error")
+		expect(result.error.kind).toBe("shape")
+		expect(result.error.message).toMatch(/id/i)
+	})
+
+	it("does not cache errors; same fingerprint retries after failure", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig
+			.mockRejectedValueOnce(new Error("transient"))
+			.mockResolvedValueOnce({ modelId: "m", knownModels: { m: { id: "m", name: "M" } } })
+		const providerId = parseProviderId("openrouter")
+		const catalog = createProviderCatalog(makeReader({ providerId, apiKey: "same" }))
+
+		const first = await catalog.resolveModels(providerId)
+		const second = await catalog.resolveModels(providerId)
+
+		expect(first.ok).toBe(false)
+		expect(second.ok).toBe(true)
+		if (!second.ok) throw new Error("expected success")
+		expect(second.defaultModelId).toBe("m")
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(2)
+	})
+
+	it("does not cache shape errors; same fingerprint retries after malformed response", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig
+			.mockResolvedValueOnce({ modelId: "bad", knownModels: { bad: { name: "missing id" } } })
+			.mockResolvedValueOnce({ modelId: "good", knownModels: { good: { id: "good", name: "Good" } } })
+		const providerId = parseProviderId("deepseek")
+		const catalog = createProviderCatalog(makeReader({ providerId }))
+
+		const first = await catalog.resolveModels(providerId)
+		const second = await catalog.resolveModels(providerId)
+
+		expect(first.ok).toBe(false)
+		expect(second.ok).toBe(true)
+		if (!second.ok) throw new Error("expected success")
+		expect(second.defaultModelId).toBe("good")
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(2)
+	})
+})
+
+describe("ProviderCatalog Phase 3.4 store-driven invalidation", () => {
+	it("fields change invalidates old-fingerprint cache and leaves the new fingerprint empty", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig
+			.mockResolvedValueOnce({ modelId: "old", knownModels: { old: { id: "old", name: "Old" } } })
+			.mockResolvedValueOnce({ modelId: "new", knownModels: { new: { id: "new", name: "New" } } })
+		const providerId = parseProviderId("ollama")
+		const reader = makeReader({ providerId, baseUrl: "http://old.example/v1" })
+		const catalog = createProviderCatalog(reader)
+
+		const oldResult = await catalog.resolveModels(providerId)
+		reader.setConfig({ providerId, baseUrl: "http://new.example/v1" })
+		reader.emit({ kind: "fields", providerId, config: { providerId, baseUrl: "http://new.example/v1" } })
+		const newResult = await catalog.resolveModels(providerId)
+
+		expect(oldResult.ok && oldResult.defaultModelId).toBe("old")
+		expect(newResult.ok && newResult.defaultModelId).toBe("new")
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(2)
+	})
+
+	it("fields change preserves cache record for the latest fingerprint", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({ modelId: "current", knownModels: { current: { id: "current" } } })
+		const providerId = parseProviderId("ollama")
+		const config: EffectiveProviderConfig = { providerId, baseUrl: "http://current.example/v1" }
+		const reader = makeReader(config)
+		const catalog = createProviderCatalog(reader)
+
+		const first = await catalog.resolveModels(providerId)
+		reader.emit({ kind: "fields", providerId, config })
+		const second = await catalog.resolveModels(providerId)
+
+		expect(second).toBe(first)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+	})
+
+	it("fields change for one provider does not invalidate another provider", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({
+			modelId: "openrouter-model",
+			knownModels: { "openrouter-model": { id: "openrouter-model" } },
+		})
+		const openrouter = parseProviderId("openrouter")
+		const ollama = parseProviderId("ollama")
+		const reader = makeReader({ providerId: openrouter, apiKey: "key" })
+		const catalog = createProviderCatalog(reader)
+
+		const first = await catalog.resolveModels(openrouter)
+		reader.setConfig({ providerId: openrouter, apiKey: "key" })
+		reader.emit({ kind: "fields", providerId: ollama, config: { providerId: ollama, baseUrl: "http://new.example/v1" } })
+		const second = await catalog.resolveModels(openrouter)
+
+		expect(second).toBe(first)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+	})
+
+	it("selection change does not invalidate model-list cache", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({ modelId: "cached", knownModels: { cached: { id: "cached" } } })
+		const providerId = parseProviderId("openrouter")
+		const reader = makeReader({ providerId, apiKey: "same" })
+		const catalog = createProviderCatalog(reader)
+		const selection: ModelSelection = { providerId, modelId: "different", modelInfo }
+
+		const first = await catalog.resolveModels(providerId)
+		reader.emit({ kind: "selection", providerId, mode: "act", selection })
+		const second = await catalog.resolveModels(providerId)
+
+		expect(second).toBe(first)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+	})
+})
+
+describe("ProviderCatalog Phase 3.5 listProviders", () => {
+	it("returns SDK provider listings with top-level picker metadata", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.listLocalProviders.mockResolvedValue({
+			providers: [
+				{
+					id: "openrouter",
+					name: "OpenRouter",
+					authDescription: "OpenRouter AI platform",
+					protocol: "openai-chat",
+					client: "openai-compatible",
+					defaultModelId: "anthropic/claude-sonnet-4.6",
+					source: "system",
+				},
+			],
+		})
+		const providerId = parseProviderId("openrouter")
+		const catalog = createProviderCatalog(makeReader({ providerId }))
+
+		const listings = await catalog.listProviders()
+
+		expect(listings).toHaveLength(1)
+		expect(listings[0]).toEqual({
+			id: providerId,
+			name: "OpenRouter",
+			defaultModelId: "anthropic/claude-sonnet-4.6",
+			protocol: "openai-chat",
+			authDescription: "OpenRouter AI platform",
+			allowsCustomModelIds: false,
+			usageCostDisplay: "show",
+		})
+		expect(listings[0]).not.toHaveProperty("models")
+		expect(mocks.listLocalProviders).toHaveBeenCalledTimes(1)
+		expect(mocks.listLocalProviders).toHaveBeenCalledWith(expect.anything(), { isClinePassEnabled: false })
+	})
+
+	it("caches provider listings per catalog instance without reading provider config", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.listLocalProviders.mockResolvedValue({
+			providers: [
+				{
+					id: "ollama",
+					name: "Ollama",
+					authDescription: "Ollama Cloud and local LLM hosting",
+					protocol: "openai-chat",
+					client: "openai-compatible",
+					defaultModelId: "default",
+					source: "system",
+				},
+			],
+		})
+		const reader = makeReader({ providerId: parseProviderId("ollama") })
+		const catalog = createProviderCatalog(reader)
+
+		const first = await catalog.listProviders()
+		const second = await catalog.listProviders()
+
+		expect(second).toBe(first)
+		expect(first[0]).toMatchObject({
+			id: parseProviderId("ollama"),
+			name: "Ollama",
+			defaultModelId: "default",
+			allowsCustomModelIds: true,
+		})
+		expect(mocks.listLocalProviders).toHaveBeenCalledTimes(1)
+		expect(reader.read).not.toHaveBeenCalled()
+		expect(reader.readSelection).not.toHaveBeenCalled()
+	})
+
+	it("refetches provider listings after explicit invalidation", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.listLocalProviders
+			.mockResolvedValueOnce({
+				providers: [{ id: "cline", name: "Cline", protocol: "anthropic", client: "anthropic", source: "system" }],
+			})
+			.mockResolvedValueOnce({
+				providers: [
+					{ id: "cline-pass", name: "ClinePass", protocol: "anthropic", client: "anthropic", source: "system" },
+				],
+			})
+		const catalog = createProviderCatalog(makeReader({ providerId: parseProviderId("cline") }))
+
+		const first = await catalog.listProviders()
+		catalog.invalidateProviderListings()
+		const second = await catalog.listProviders()
+
+		expect(first[0]?.id).toBe("cline")
+		expect(second[0]?.id).toBe("cline-pass")
+		expect(mocks.listLocalProviders).toHaveBeenCalledTimes(2)
+	})
+
+	it("retries provider listing after an SDK listing failure", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.listLocalProviders.mockRejectedValueOnce(new Error("temporary catalog failure")).mockResolvedValueOnce({
+			providers: [
+				{
+					id: "deepseek",
+					name: "DeepSeek",
+					protocol: "openai-chat",
+					client: "openai-compatible",
+					defaultModelId: "deepseek-v4-flash",
+					source: "system",
+				},
+			],
+		})
+		const providerId = parseProviderId("deepseek")
+		const catalog = createProviderCatalog(makeReader({ providerId }))
+
+		await expect(catalog.listProviders()).rejects.toThrow("temporary catalog failure")
+		await expect(catalog.listProviders()).resolves.toMatchObject([
+			{
+				id: providerId,
+				name: "DeepSeek",
+				defaultModelId: "deepseek-v4-flash",
+				allowsCustomModelIds: false,
+			},
+		])
+		expect(mocks.listLocalProviders).toHaveBeenCalledTimes(2)
+	})
+})
+
+describe("ProviderCatalog Phase 3.6 subscribe", () => {
+	it("fires the provider listener after resolveModels completes", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({ modelId: "model-a", knownModels: { "model-a": { id: "model-a" } } })
+		const providerId = parseProviderId("deepseek")
+		const catalog = createProviderCatalog(makeReader({ providerId, apiKey: "key" }))
+		const listener = vi.fn()
+		catalog.subscribe(providerId, listener)
+
+		const result = await catalog.resolveModels(providerId)
+
+		expect(listener).toHaveBeenCalledTimes(1)
+		expect(listener).toHaveBeenCalledWith({ providerId, result })
+	})
+
+	it("fires after a cache-hit resolveModels result", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({ modelId: "cached", knownModels: { cached: { id: "cached" } } })
+		const providerId = parseProviderId("openrouter")
+		const catalog = createProviderCatalog(makeReader({ providerId, apiKey: "same" }))
+		const listener = vi.fn()
+		catalog.subscribe(providerId, listener)
+
+		const first = await catalog.resolveModels(providerId)
+		const second = await catalog.resolveModels(providerId)
+
+		expect(second).toBe(first)
+		expect(mocks.resolveProviderConfig).toHaveBeenCalledTimes(1)
+		expect(listener).toHaveBeenCalledTimes(2)
+		expect(listener).toHaveBeenNthCalledWith(1, { providerId, result: first })
+		expect(listener).toHaveBeenNthCalledWith(2, { providerId, result: second })
+	})
+
+	it("does not fire provider listener for another provider", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({ modelId: "model-a", knownModels: { "model-a": { id: "model-a" } } })
+		const subscribedProvider = parseProviderId("deepseek")
+		const resolvedProvider = parseProviderId("openrouter")
+		const catalog = createProviderCatalog(makeReader({ providerId: resolvedProvider, apiKey: "key" }))
+		const listener = vi.fn()
+		catalog.subscribe(subscribedProvider, listener)
+
+		await catalog.resolveModels(resolvedProvider)
+
+		expect(listener).not.toHaveBeenCalled()
+	})
+
+	it("does not fire model-list listener when only commitSelection happens", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		const providerId = parseProviderId("ollama")
+		const reader = makeReader({ providerId, baseUrl: "http://localhost:11434/v1" })
+		const catalog = createProviderCatalog(reader)
+		const listener = vi.fn()
+		const selection: ModelSelection = { providerId, modelId: "custom:latest", modelInfo }
+		catalog.subscribe(providerId, listener)
+
+		reader.emit({ kind: "selection", providerId, mode: "act", selection })
+
+		expect(listener).not.toHaveBeenCalled()
+	})
+
+	it("disposable unregisters the provider listener", async () => {
+		const { createProviderCatalog } = await import("./catalog")
+		mocks.resolveProviderConfig.mockResolvedValue({ modelId: "model-a", knownModels: { "model-a": { id: "model-a" } } })
+		const providerId = parseProviderId("deepseek")
+		const catalog = createProviderCatalog(makeReader({ providerId, apiKey: "key" }))
+		const listener = vi.fn()
+		const disposable = catalog.subscribe(providerId, listener)
+
+		disposable.dispose()
+		await catalog.resolveModels(providerId)
+
+		expect(listener).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/catalog.ts b/apps/vscode/src/sdk/model-catalog/catalog.ts
new file mode 100644
index 0000000..4edf572
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/catalog.ts
@@ -0,0 +1,361 @@
+import { listLocalProviders, type ModelCatalogConfig, resolveProviderConfig } from "@cline/core"
+import { type ProviderConfig, resolveProviderUsageCostDisplay } from "@cline/llms"
+import { type ProviderListItem } from "@cline/shared"
+import { getFeatureFlagsService } from "@/services/feature-flags"
+import { FeatureFlag } from "@/shared/services/feature-flags/feature-flags"
+import { getProviderSettingsManager } from "../provider-migration"
+import type {
+	CatalogError,
+	Disposable,
+	EffectiveProviderConfig,
+	Fingerprint,
+	ModelSelection,
+	ProviderCatalog,
+	ProviderConfigReader,
+	ProviderId,
+	ProviderListing,
+	ProviderModelsEvent,
+	ProviderModelsResult,
+	UsageCostDisplay,
+} from "./contracts"
+import { providerAllowsCustomModelIds } from "./custom-model-ids"
+import { computeConfigFingerprint } from "./fingerprint"
+import { applyHostModelInfoOverrides } from "./host-overrides"
+import { parseProviderId } from "./provider-id"
+import { toSdkProviderId } from "./sdk-provider-id"
+import { adaptSdkModelInfo, CatalogShapeError } from "./shape-adapter"
+
+type ProviderModelsRecord = Extract<ProviderModelsResult, { ok: true }>
+
+type CacheKey = `${string}:${string}`
+
+interface ProviderModelsCacheOptions {
+	readonly ttlMs: number
+	now(): number
+}
+
+interface ResolveRecordOptions {
+	readonly providerId: ProviderId
+	readonly fingerprint: Fingerprint
+	readonly forceRefresh?: boolean
+	load(): Promise<ProviderModelsRecord>
+}
+
+const DEFAULT_MODEL_CACHE_TTL_MS = 5 * 60 * 1000
+const DEFAULT_MODEL_CATALOG_CONFIG: ModelCatalogConfig = {
+	loadLatestOnInit: true,
+	loadPrivateOnAuth: true,
+	failOnError: false,
+	cacheTtlMs: 0,
+}
+
+/**
+ * Normalize the SDK's usage-cost-display answer (string union) into the
+ * extension's {@link UsageCostDisplay} type. The SDK function takes a
+ * provider id (not metadata) and consults its own registry; we forward
+ * the id and trust the answer rather than re-parsing the metadata bag.
+ */
+function readUsageCostDisplay(providerId: string): UsageCostDisplay {
+	return resolveProviderUsageCostDisplay(providerId) === "hide" ? "hide" : "show"
+}
+
+function makeCacheKey(providerId: ProviderId, fingerprint: Fingerprint): CacheKey {
+	return `${providerId}:${fingerprint}`
+}
+
+function assertRecordMatchesRequest(record: ProviderModelsRecord, providerId: ProviderId, fingerprint: Fingerprint): void {
+	if (record.providerId !== providerId || record.configFingerprint !== fingerprint) {
+		throw new Error(
+			`ProviderCatalog cache invariant failed: loaded record ${record.providerId}/${record.configFingerprint} does not match requested ${providerId}/${fingerprint}`,
+		)
+	}
+}
+
+function createProviderModelsCache(options: ProviderModelsCacheOptions) {
+	const records = new Map<CacheKey, { readonly record: ProviderModelsRecord; readonly expiresAt: number }>()
+	const inFlight = new Map<CacheKey, Promise<ProviderModelsRecord>>()
+
+	function get(providerId: ProviderId, fingerprint: Fingerprint): ProviderModelsRecord | undefined {
+		const key = makeCacheKey(providerId, fingerprint)
+		const entry = records.get(key)
+		if (!entry) {
+			return undefined
+		}
+		if (entry.expiresAt <= options.now()) {
+			records.delete(key)
+			return undefined
+		}
+		return entry.record
+	}
+
+	function set(record: ProviderModelsRecord, providerId = record.providerId, fingerprint = record.configFingerprint): void {
+		assertRecordMatchesRequest(record, providerId, fingerprint)
+		records.set(makeCacheKey(record.providerId, record.configFingerprint), {
+			record,
+			expiresAt: options.now() + options.ttlMs,
+		})
+	}
+
+	function invalidateProviderExcept(providerId: ProviderId, fingerprintToKeep: Fingerprint): void {
+		for (const [key, entry] of records) {
+			if (entry.record.providerId === providerId && entry.record.configFingerprint !== fingerprintToKeep) {
+				records.delete(key)
+			}
+		}
+	}
+
+	function resolve(optionsForRecord: ResolveRecordOptions): Promise<ProviderModelsRecord> {
+		if (!optionsForRecord.forceRefresh) {
+			const cached = get(optionsForRecord.providerId, optionsForRecord.fingerprint)
+			if (cached) {
+				return Promise.resolve(cached)
+			}
+		}
+
+		const key = makeCacheKey(optionsForRecord.providerId, optionsForRecord.fingerprint)
+		const existing = inFlight.get(key)
+		if (existing) {
+			return existing
+		}
+
+		const promise = optionsForRecord
+			.load()
+			.then((record) => {
+				set(record, optionsForRecord.providerId, optionsForRecord.fingerprint)
+				return record
+			})
+			.finally(() => {
+				inFlight.delete(key)
+			})
+		inFlight.set(key, promise)
+		return promise
+	}
+
+	return {
+		get,
+		set,
+		invalidateProviderExcept,
+		resolve,
+		peek: get,
+		_inFlightSize: () => inFlight.size,
+		_cacheSize: () => records.size,
+	}
+}
+
+function toSdkProviderConfig(config: EffectiveProviderConfig, selection: ModelSelection | undefined): ProviderConfig {
+	return {
+		providerId: toSdkProviderId(config.providerId),
+		modelId: selection?.modelId ?? "",
+		apiKey: config.apiKey,
+		baseUrl: config.baseUrl,
+		headers: config.headers ? { ...config.headers } : undefined,
+		accessToken: config.auth?.accessToken,
+		refreshToken: config.auth?.refreshToken,
+		accountId: config.auth?.accountId,
+		apiLine: config.apiLine === "china" || config.apiLine === "international" ? config.apiLine : undefined,
+		region: config.gcp?.region ?? config.region,
+		gcp: config.gcp ? { ...config.gcp } : undefined,
+	}
+}
+
+function chooseDefaultModelId(sdkDefaultModelId: string | undefined, models: ReadonlyMap<string, unknown>): string {
+	if (sdkDefaultModelId && models.has(sdkDefaultModelId)) {
+		return sdkDefaultModelId
+	}
+	return models.keys().next().value ?? ""
+}
+
+function optionalNonEmpty(value: string | undefined): string | undefined {
+	const trimmed = value?.trim()
+	return trimmed ? trimmed : undefined
+}
+
+function toProviderListing(provider: ProviderListItem): ProviderListing {
+	return {
+		id: parseProviderId(provider.id),
+		name: provider.name,
+		defaultModelId: optionalNonEmpty(provider.defaultModelId),
+		protocol: provider.protocol,
+		// ProviderListing intentionally does not include full model-list data.
+		// Reuse the lightweight description slot until the RPC-facing picker
+		// contract decides whether it needs a generic provider description field.
+		authDescription: optionalNonEmpty(provider.authDescription),
+		// The SDK has the right signal for this on each provider (e.g.
+		// `modelsSourceUrl` for ollama/lmstudio, or the `openai-compatible`
+		// family with no curated catalog), but does not yet expose it
+		// through a public helper. Until then this set is the host-side
+		// fallback; remove it as soon as upstream exposes the signal.
+		allowsCustomModelIds: providerAllowsCustomModelIds(provider.id),
+		usageCostDisplay: readUsageCostDisplay(provider.id),
+	}
+}
+
+async function listSdkProviderListings(): Promise<ReadonlyArray<ProviderListing>> {
+	const manager = getProviderSettingsManager()
+	const featureFlags = getFeatureFlagsService()
+	const { providers } = await listLocalProviders(manager, {
+		isClinePassEnabled: featureFlags.getBooleanFlagEnabled(FeatureFlag.CLINE_PASS),
+	})
+	return providers.map(toProviderListing)
+}
+
+async function resolveSdkModels(
+	providerId: ProviderId,
+	fingerprint: Fingerprint,
+	config: EffectiveProviderConfig,
+	selection: ModelSelection | undefined,
+	now: () => number,
+): Promise<ProviderModelsRecord> {
+	const sdkProviderId = toSdkProviderId(providerId)
+	const resolved = await resolveProviderConfig(
+		sdkProviderId,
+		DEFAULT_MODEL_CATALOG_CONFIG,
+		toSdkProviderConfig(config, selection),
+	)
+	const sdkModels = resolved?.knownModels ?? {}
+	const models = new Map(
+		Object.entries(sdkModels).map(([modelId, sdkInfo]) => [
+			modelId,
+			applyHostModelInfoOverrides(providerId, modelId, adaptSdkModelInfo(sdkInfo)),
+		]),
+	)
+	return {
+		ok: true,
+		providerId,
+		configFingerprint: fingerprint,
+		models,
+		defaultModelId: chooseDefaultModelId(resolved?.modelId, models),
+		source: "sdk-dynamic",
+		fetchedAt: now(),
+	}
+}
+
+function toCatalogError(error: unknown): CatalogError {
+	if (error instanceof CatalogShapeError) {
+		return {
+			kind: "shape",
+			message: error.message,
+		}
+	}
+	if (error instanceof Error) {
+		return {
+			kind: "unknown",
+			message: error.message,
+		}
+	}
+	return {
+		kind: "unknown",
+		message: String(error),
+	}
+}
+
+/**
+ * Internal test hook for cache/in-flight behavior. Not part of the public
+ * model-catalog API; production callers should use createProviderCatalog.
+ */
+export const _testing = {
+	createProviderModelsCache,
+	makeCacheKey,
+	assertRecordMatchesRequest,
+}
+
+/**
+ * Create a {@link ProviderCatalog}.
+ *
+ * Accepts a read-only {@link ProviderConfigReader} (not the full store), so
+ * the catalog cannot write to the store: it has no `write`/`commitSelection`
+ * access by construction.
+ */
+export function createProviderCatalog(reader: ProviderConfigReader): ProviderCatalog {
+	const now = () => Date.now()
+	const cache = createProviderModelsCache({ ttlMs: DEFAULT_MODEL_CACHE_TTL_MS, now })
+	let providerListingsPromise: Promise<ReadonlyArray<ProviderListing>> | undefined
+	const modelListeners = new Map<ProviderId, Set<(event: ProviderModelsEvent) => void>>()
+
+	function notifyModelListeners(providerId: ProviderId, result: ProviderModelsResult): void {
+		const listeners = modelListeners.get(providerId)
+		if (!listeners) {
+			return
+		}
+		const event: ProviderModelsEvent = { providerId, result }
+		for (const listener of [...listeners]) {
+			listener(event)
+		}
+	}
+
+	reader.subscribe((event) => {
+		if (event.kind !== "fields") {
+			return
+		}
+		const latestConfig = reader.read(event.providerId)
+		const latestFingerprint = computeConfigFingerprint(event.providerId, latestConfig)
+		cache.invalidateProviderExcept(event.providerId, latestFingerprint)
+	})
+	return {
+		async listProviders(): Promise<ReadonlyArray<ProviderListing>> {
+			providerListingsPromise ??= listSdkProviderListings().catch((error) => {
+				providerListingsPromise = undefined
+				throw error
+			})
+			return providerListingsPromise
+		},
+
+		invalidateProviderListings(): void {
+			providerListingsPromise = undefined
+		},
+
+		async resolveModels(
+			providerId: ProviderId,
+			options?: { readonly forceRefresh?: boolean },
+		): Promise<ProviderModelsResult> {
+			const config = reader.read(providerId)
+			const fingerprint = computeConfigFingerprint(providerId, config)
+			// Selection is not part of model-list identity; it is only a hint for
+			// SDK config surfaces that require a model id. The cache stays keyed
+			// solely by provider + effective config fingerprint.
+			const selection = reader.readSelection(providerId, "act")
+			let result: ProviderModelsResult
+			try {
+				result = await cache.resolve({
+					providerId,
+					fingerprint,
+					forceRefresh: options?.forceRefresh,
+					load: () => resolveSdkModels(providerId, fingerprint, config, selection, now),
+				})
+			} catch (error) {
+				result = {
+					ok: false,
+					providerId,
+					configFingerprint: fingerprint,
+					error: toCatalogError(error),
+					fetchedAt: now(),
+				}
+			}
+			notifyModelListeners(providerId, result)
+			return result
+		},
+
+		peekModels(providerId: ProviderId): ProviderModelsResult | undefined {
+			const config = reader.read(providerId)
+			const fingerprint = computeConfigFingerprint(providerId, config)
+			return cache.peek(providerId, fingerprint)
+		},
+
+		subscribe(providerId: ProviderId, listener: (event: ProviderModelsEvent) => void): Disposable {
+			let listeners = modelListeners.get(providerId)
+			if (!listeners) {
+				listeners = new Set()
+				modelListeners.set(providerId, listeners)
+			}
+			listeners.add(listener)
+			return {
+				dispose(): void {
+					listeners.delete(listener)
+					if (listeners.size === 0) {
+						modelListeners.delete(providerId)
+					}
+				},
+			}
+		},
+	}
+}
diff --git a/apps/vscode/src/sdk/model-catalog/contracts.ts b/apps/vscode/src/sdk/model-catalog/contracts.ts
new file mode 100644
index 0000000..8e3040b
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/contracts.ts
@@ -0,0 +1,426 @@
+/**
+ * SDK-backed Model Catalog — Contracts
+ *
+ * This file is the type-level contract for the model catalog system. Every
+ * load-bearing invariant that can be expressed in the type system lives here.
+ * Behavior is implemented elsewhere; this file has no runtime side effects.
+ *
+ * If you are about to write a value cast like `x as ProviderId` or
+ * `x as Fingerprint` outside the parse/compute boundary functions, stop and
+ * raise a checkpoint. The branded types in this file exist precisely so
+ * those casts are never necessary or correct.
+ */
+
+import type { ModelInfo } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+
+// ---------------------------------------------------------------------------
+// Branded primitives
+// ---------------------------------------------------------------------------
+
+declare const ProviderIdBrand: unique symbol
+declare const KnownProviderIdBrand: unique symbol
+declare const FingerprintBrand: unique symbol
+
+/**
+ * A provider identifier. Branded so it cannot be fabricated from a raw
+ * `string` without going through `parseProviderId`.
+ *
+ * Invariant: every `ProviderId` was at some point produced by
+ * `parseProviderId`. The string is trimmed and lowercased for
+ * config/storage portability.
+ */
+export type ProviderId = string & { readonly [ProviderIdBrand]: void }
+
+/**
+ * A `ProviderId` we recognize from `ApiProvider`. Sub-brand of `ProviderId`.
+ * Distinguishing "known" from "any" lets us write functions that require a
+ * known provider without re-validating, while still accepting arbitrary
+ * provider ids (e.g. custom SDK providers) where openness is correct.
+ */
+export type KnownProviderId = ProviderId & { readonly [KnownProviderIdBrand]: void }
+
+/**
+ * Cache-key payload. Branded string. Built only by `computeConfigFingerprint`
+ * and equality-compared. Opaque to consumers.
+ *
+ * Invariant: `computeConfigFingerprint` is total and pure. The same
+ * `(providerId, EffectiveProviderConfig)` produces the same fingerprint;
+ * different inputs produce different fingerprints (up to hash collision).
+ * Raw secrets never appear in the fingerprint output.
+ */
+export type Fingerprint = string & { readonly [FingerprintBrand]: void }
+
+// ---------------------------------------------------------------------------
+// Effective provider config
+// ---------------------------------------------------------------------------
+
+/**
+ * Effective configuration for a provider, with all overlays (remote config,
+ * secrets, defaults) applied. Produced only by `ProviderConfigStore.read`.
+ *
+ * Invariants:
+ *  - `providerId` is the id of the provider this config describes.
+ *  - Secrets (apiKey, auth.accessToken) are *included* on the host;
+ *    redaction happens at the RPC serialization boundary, not inside the
+ *    store. Callers serializing this type across a boundary are responsible
+ *    for redaction.
+ *  - Two reads with no intervening write return structurally equal values.
+ *  - Consumers must not mutate. The shape is `Readonly`.
+ *
+ * Mode-dependent selection (modelId, modelInfo) is *not* part of this
+ * type. Use `ProviderConfigStore.readSelection(providerId, mode)`.
+ */
+export interface AwsProviderConfig {
+	readonly accessKey?: string
+	readonly secretKey?: string
+	readonly sessionToken?: string
+	readonly authentication?: "iam" | "api-key" | "apikey" | "profile" | string
+	readonly profile?: string
+	readonly usePromptCache?: boolean
+	readonly endpoint?: string
+	readonly customModelBaseId?: string
+	readonly useCrossRegionInference?: boolean
+	readonly useGlobalInference?: boolean
+}
+
+export interface GcpProviderConfig {
+	readonly projectId?: string
+	readonly region?: string
+}
+
+export interface EffectiveProviderConfig {
+	readonly providerId: ProviderId
+	readonly apiKey?: string
+	readonly baseUrl?: string
+	readonly apiLine?: string
+	readonly headers?: Readonly<Record<string, string>>
+	readonly region?: string
+	readonly aws?: AwsProviderConfig
+	readonly gcp?: GcpProviderConfig
+	/**
+	 * OAuth-style auth bundle (e.g. cline provider's WorkOS token).
+	 * Compatible with `apiKey`; some providers populate both.
+	 */
+	readonly auth?: {
+		readonly accessToken?: string
+		readonly refreshToken?: string
+		readonly accountId?: string
+	}
+	/**
+	 * Provider-specific extras. Prefer adding a typed top-level field over
+	 * expanding this map. Used as a compatibility escape hatch during
+	 * migration.
+	 */
+	readonly extras?: Readonly<Record<string, unknown>>
+}
+
+/**
+ * A patch describing a field-level write to `ProviderConfigStore`.
+ *
+ * Invariant: `ProviderConfigPatch` cannot describe a model selection. The
+ * type does not contain `modelId` or `modelInfo`. To write a selection,
+ * use `commitSelection`, which is a structurally distinct method on the
+ * store.
+ *
+ * Empty patches are allowed and are no-ops. A field present with value
+ * `null` means "clear this field"; an absent field means "leave unchanged."
+ */
+interface ProviderReasoningPatch {
+	readonly enabled?: boolean
+	readonly effort?: string // "none" | "low" | "medium" | "high" | "xhigh"
+	readonly budgetTokens?: number
+}
+
+export interface ProviderConfigPatch {
+	readonly apiKey?: string | null
+	readonly baseUrl?: string | null
+	readonly apiLine?: string | null
+	readonly headers?: Readonly<Record<string, string>> | null
+	readonly region?: string | null
+	readonly aws?: AwsProviderConfig | null
+	readonly gcp?: GcpProviderConfig | null
+	readonly auth?: {
+		readonly accessToken?: string
+		readonly refreshToken?: string
+		readonly accountId?: string
+	} | null
+	readonly reasoning?: ProviderReasoningPatch | null
+	readonly extras?: Readonly<Record<string, unknown>> | null
+}
+
+// ---------------------------------------------------------------------------
+// Model selection
+// ---------------------------------------------------------------------------
+
+/**
+ * A user's committed model selection. The triple is atomic by type: every
+ * write of `modelId` carries its `modelInfo` envelope, and vice versa.
+ *
+ * Invariants:
+ *  - `modelInfo` was either taken from a `ProviderCatalog.resolveModels`
+ *    result, or constructed from per-provider safe defaults when the user
+ *    entered a custom id manually. Either way it represents the picker's
+ *    best knowledge at the moment of commit. The runtime uses it verbatim.
+ *  - The stored selection wins over later SDK catalog changes. Refresh
+ *    does not retroactively change committed selections.
+ */
+export interface ModelSelection {
+	readonly providerId: ProviderId
+	readonly modelId: string
+	readonly modelInfo: ModelInfo
+}
+
+// ---------------------------------------------------------------------------
+// Change events
+// ---------------------------------------------------------------------------
+
+/**
+ * Event fired by `ProviderConfigStore.subscribe` after a committed write.
+ * `kind` discriminates field writes from selection commits, so listeners
+ * can react appropriately without re-reading.
+ */
+export type ProviderConfigChange =
+	| {
+			readonly kind: "fields"
+			readonly providerId: ProviderId
+			readonly config: EffectiveProviderConfig
+	  }
+	| {
+			readonly kind: "selection"
+			readonly providerId: ProviderId
+			readonly mode: Mode
+			readonly selection: ModelSelection
+	  }
+
+export type ProviderConfigChangeListener = (event: ProviderConfigChange) => void
+
+/**
+ * Standard disposable for subscription handles.
+ */
+export interface Disposable {
+	dispose(): void
+}
+
+// ---------------------------------------------------------------------------
+// Provider listings
+// ---------------------------------------------------------------------------
+
+/**
+ * Lightweight provider entry returned by `ProviderCatalog.listProviders`.
+ * Drives the top-level provider picker dropdown. Does *not* include the
+ * full model list; use `resolveModels` for that.
+ */
+/**
+ * SDK-driven hint for how to display per-token / total cost in the UI.
+ * Mirrors `ProviderUsageCostDisplay` from `@cline/llms` and the CLI's
+ * `shouldShowCliUsageCost` consumer. When `"hide"`, downstream UIs MUST
+ * suppress per-token pricing rows (in model info cards) and total-cost
+ * lines (in task summaries / status bars).
+ */
+export type UsageCostDisplay = "show" | "hide"
+
+export interface ProviderListing {
+	readonly id: ProviderId
+	readonly name: string
+	readonly defaultModelId?: string
+	readonly family?: string
+	readonly protocol?: string
+	readonly authDescription?: string
+	readonly baseUrlDescription?: string
+	/**
+	 * Whether arbitrary model ids are meaningful for this provider. Drives
+	 * the manual-entry affordance in `ModelPickerWithManualEntry`.
+	 *
+	 * Example: Ollama, LM Studio, LiteLLM, OpenAI-compatible → true.
+	 * Anthropic, DeepSeek, Gemini → false.
+	 */
+	readonly allowsCustomModelIds: boolean
+	/**
+	 * SDK-driven hint for per-token / total cost display. See
+	 * {@link UsageCostDisplay}. Defaults to `"show"` when the SDK does not
+	 * set `metadata.usageCostDisplay`.
+	 */
+	readonly usageCostDisplay: UsageCostDisplay
+}
+
+// ---------------------------------------------------------------------------
+// Catalog results
+// ---------------------------------------------------------------------------
+
+/**
+ * Source of a model-list result. Observability counterpart to the cache
+ * record. Logged but not used for control flow.
+ */
+type CatalogSource = "sdk-dynamic" | "sdk-bundled" | "extension-dynamic" | "legacy-static" | "host-adapter"
+
+/**
+ * Structured error from `resolveModels`. Carries enough information to
+ * render an actionable picker state. Does not include raw SDK errors; the
+ * catalog's boundary parser translates SDK errors into this shape.
+ */
+export interface CatalogError {
+	readonly kind: "network" | "auth" | "shape" | "config" | "unknown"
+	readonly message: string
+	/**
+	 * Optional provider-side error code (e.g. HTTP status). Informational
+	 * only; UI should not switch on it.
+	 */
+	readonly code?: string
+}
+
+/**
+ * Result of `ProviderCatalog.resolveModels`. Discriminated by `ok`.
+ *
+ * Invariant: a `ProviderModelsResult` always carries the `configFingerprint`
+ * it was computed against. Consumers compare fingerprints, not timestamps,
+ * to decide whether to apply a result.
+ */
+export type ProviderModelsResult =
+	| {
+			readonly ok: true
+			readonly providerId: ProviderId
+			readonly configFingerprint: Fingerprint
+			readonly models: ReadonlyMap<string, ModelInfo>
+			readonly defaultModelId: string
+			readonly source: CatalogSource
+			readonly fetchedAt: number
+	  }
+	| {
+			readonly ok: false
+			readonly providerId: ProviderId
+			readonly configFingerprint: Fingerprint
+			readonly error: CatalogError
+			readonly fetchedAt: number
+	  }
+
+/**
+ * Event fired by `ProviderCatalog.subscribe` whenever a `resolveModels`
+ * call completes for the subscribed provider.
+ */
+export interface ProviderModelsEvent {
+	readonly providerId: ProviderId
+	readonly result: ProviderModelsResult
+}
+
+// ---------------------------------------------------------------------------
+// The two abstractions
+// ---------------------------------------------------------------------------
+
+/**
+ * Read-only view of `ProviderConfigStore`. Held by `ProviderCatalog` so the
+ * catalog is read-only with respect to the store by type — it can never write.
+ *
+ * If a future need arises to grant a non-store consumer write access,
+ * pass it the full `ProviderConfigStore` interface explicitly; do not
+ * widen this reader type.
+ */
+export interface ProviderConfigReader {
+	read(providerId: ProviderId): EffectiveProviderConfig
+	readSelection(providerId: ProviderId, mode: Mode): ModelSelection | undefined
+	subscribe(listener: ProviderConfigChangeListener): Disposable
+}
+
+/**
+ * The provider configuration store. Owns and serializes all writes to
+ * user-edited provider configuration fields and committed model selections.
+ *
+ * Storage strategy is private. Implementations decide whether each field
+ * lives in StateManager, providers.json, remote config overlays, or
+ * elsewhere. Consumers must not name the storage layout.
+ *
+ * Invariants (also documented per method):
+ *  - I1. `read(p)` after `write(p, patch)` reflects `patch`. Always.
+ *  - I2. `commitSelection` is the only producer of selection events.
+ *  - I3. `write` cannot produce a selection event.
+ *  - I4. Two reads with no intervening write are structurally equal.
+ *  - I5. Subscribers fire synchronously before the write that triggered
+ *    them returns.
+ *  - I6. Secrets do not cross serialization boundaries; that is the
+ *    responsibility of the caller crossing the boundary (e.g. RPC handler).
+ */
+export interface ProviderConfigStore extends ProviderConfigReader {
+	/**
+	 * Update fields. In-memory cache is updated before this returns; disk
+	 * persistence is debounced. Returns the new effective config.
+	 *
+	 * I3: `write` does not accept selection fields by type, so it cannot
+	 * commit a selection. Listeners receive a `"fields"` event, not a
+	 * `"selection"` event.
+	 */
+	write(providerId: ProviderId, patch: ProviderConfigPatch): EffectiveProviderConfig
+
+	/**
+	 * Commit a model selection atomically with its info envelope. The only
+	 * entry point that writes `{providerId, modelId, modelInfo}` triples.
+	 *
+	 * I2: refresh handlers do not have access to this method by type, since
+	 * `ProviderCatalog` holds only a `ProviderConfigReader`.
+	 */
+	commitSelection(providerId: ProviderId, mode: Mode, selection: ModelSelection): void
+}
+
+/**
+ * The provider model catalog. Resolves model lists and provider listings
+ * from the SDK (and host adapters where applicable). Manages a
+ * fingerprint-keyed cache and in-flight request dedup internally.
+ *
+ * Invariants (also documented per method):
+ *  - C1. Holds a `ProviderConfigReader`, not a `ProviderConfigStore`.
+ *    Cannot write to the store. Enforced by type.
+ *  - C2. Every result carries the `configFingerprint` it was computed
+ *    against.
+ *  - C3. Cache and in-flight maps are keyed by `${providerId}:${fingerprint}`.
+ *  - C4. Reacts to store changes by invalidating non-matching fingerprints;
+ *    does not invalidate the user's selection.
+ *  - C5. Never writes selection.
+ *  - C6. Validates SDK responses at the boundary; malformed responses
+ *    produce `CatalogError`, not malformed downstream data.
+ */
+export interface ProviderCatalog {
+	/**
+	 * List providers available from the SDK catalog. Used by the top-level
+	 * provider picker.
+	 */
+	listProviders(): Promise<ReadonlyArray<ProviderListing>>
+
+	/**
+	 * Clear cached provider listings so the next list request re-applies
+	 * feature-flag-gated provider visibility.
+	 */
+	invalidateProviderListings(): void
+
+	/**
+	 * Resolve models for a provider given the current effective config.
+	 * Reads effective config from the store; callers do not pass it.
+	 *
+	 * `forceRefresh: true` bypasses cache for the current fingerprint;
+	 * in-flight dedup is still honored.
+	 */
+	resolveModels(providerId: ProviderId, options?: { readonly forceRefresh?: boolean }): Promise<ProviderModelsResult>
+
+	/**
+	 * Synchronous, non-fetching peek of the catalog cache. Returns the
+	 * cached model list for the given provider's *current* effective
+	 * config fingerprint, or `undefined` if no cached entry exists. Used
+	 * by hot-path handlers (e.g. `resolveModelInfo`) that must respond
+	 * without awaiting a network or live-catalog refresh.
+	 *
+	 * Callers that need an authoritative result should `resolveModels`
+	 * instead; peek is a best-effort optimization and may return stale
+	 * data immediately after a config-change invalidation.
+	 */
+	peekModels(providerId: ProviderId): ProviderModelsResult | undefined
+
+	/**
+	 * Subscribe to model-list updates for a provider. Fires after each
+	 * `resolveModels` completion for that provider.
+	 */
+	subscribe(providerId: ProviderId, listener: (event: ProviderModelsEvent) => void): Disposable
+}
+
+// ---------------------------------------------------------------------------
+// Re-exports
+// ---------------------------------------------------------------------------
+
+export type { Mode, ModelInfo }
diff --git a/apps/vscode/src/sdk/model-catalog/custom-model-ids.ts b/apps/vscode/src/sdk/model-catalog/custom-model-ids.ts
new file mode 100644
index 0000000..1a864c5
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/custom-model-ids.ts
@@ -0,0 +1,23 @@
+import { toSdkProviderId } from "./sdk-provider-id"
+
+// Providers whose model id is user-supplied free text rather than a fixed
+// catalog selection. The SDK catalog for these either has no curated model
+// list (openai-compatible: bring-your-own base URL + model) or a host-fetched
+// list that the user can also bypass (ollama/lmstudio/litellm). For these,
+// the picker must allow arbitrary model ids and model resolution must honor
+// the requested id instead of coercing to the catalog default.
+const CUSTOM_MODEL_ID_PROVIDER_IDS = new Set(["openai-compatible", "ollama", "lmstudio", "litellm"])
+
+/**
+ * Whether a provider id accepts a user-supplied (custom) model id.
+ *
+ * Keep this helper in a side-effect-free module so lightweight controller
+ * handlers (e.g. `resolveModelInfo`) do not import the full provider catalog
+ * implementation and its feature-flag/controller dependency graph.
+ *
+ * Accepts either the extension or SDK provider id spelling (the extension's
+ * `openai` maps to the SDK's `openai-compatible`).
+ */
+export function providerAllowsCustomModelIds(providerId: string): boolean {
+	return CUSTOM_MODEL_ID_PROVIDER_IDS.has(toSdkProviderId(providerId))
+}
diff --git a/apps/vscode/src/sdk/model-catalog/effective-config.test.ts b/apps/vscode/src/sdk/model-catalog/effective-config.test.ts
new file mode 100644
index 0000000..a99d869
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/effective-config.test.ts
@@ -0,0 +1,195 @@
+import type { ApiConfiguration } from "@shared/api"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { parseProviderId } from "./provider-id"
+
+const mocks = vi.hoisted(() => {
+	let apiConfiguration: ApiConfiguration = {}
+	let providerSettingsById: Record<string, unknown> = {}
+
+	return {
+		setApiConfiguration(value: ApiConfiguration): void {
+			apiConfiguration = value
+		},
+		setProviderSettings(value: Record<string, unknown>): void {
+			providerSettingsById = value
+		},
+		getStateManager() {
+			return { getApiConfiguration: () => apiConfiguration }
+		},
+		getProviderSettingsManager() {
+			return { getProviderSettings: (providerId: string) => providerSettingsById[providerId] }
+		},
+	}
+})
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: { get: mocks.getStateManager },
+}))
+
+vi.mock("../provider-migration", () => ({
+	getProviderSettingsManager: mocks.getProviderSettingsManager,
+}))
+
+describe("buildEffectiveProviderConfig", () => {
+	beforeEach(() => {
+		mocks.setApiConfiguration({})
+		mocks.setProviderSettings({})
+	})
+
+	it("builds Ollama config with StateManager base URL over providers.json and local extras", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({
+			ollama: {
+				provider: "ollama",
+				apiKey: "provider-ollama-key",
+				baseUrl: "http://provider-ollama:11434",
+			},
+		})
+		mocks.setApiConfiguration({
+			ollamaBaseUrl: "http://state-ollama:11434",
+			ollamaApiOptionsCtxNum: "8192",
+		})
+
+		expect(buildEffectiveProviderConfig(parseProviderId("ollama"))).toEqual({
+			providerId: parseProviderId("ollama"),
+			apiKey: "provider-ollama-key",
+			baseUrl: "http://state-ollama:11434",
+			extras: { ollamaApiOptionsCtxNum: "8192" },
+		})
+	})
+
+	it("builds LiteLLM config by merging providers.json fields and StateManager overlays", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({
+			litellm: {
+				provider: "litellm",
+				apiKey: "provider-litellm-key",
+				baseUrl: "https://provider-litellm.example.com/v1",
+				headers: { "x-provider": "provider-header" },
+				extras: { providerOnly: true },
+			},
+		})
+		mocks.setApiConfiguration({
+			liteLlmBaseUrl: "https://state-litellm.example.com/v1",
+			liteLlmUsePromptCache: true,
+		})
+
+		expect(buildEffectiveProviderConfig(parseProviderId("litellm"))).toEqual({
+			providerId: parseProviderId("litellm"),
+			apiKey: "provider-litellm-key",
+			baseUrl: "https://state-litellm.example.com/v1",
+			headers: { "x-provider": "provider-header" },
+			extras: { providerOnly: true, liteLlmUsePromptCache: true },
+		})
+	})
+
+	it("uses StateManager DeepSeek API key over providers.json", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({ deepseek: { provider: "deepseek", apiKey: "provider-deepseek-key" } })
+		mocks.setApiConfiguration({ deepSeekApiKey: "state-deepseek-key" })
+
+		expect(buildEffectiveProviderConfig(parseProviderId("deepseek"))).toEqual({
+			providerId: parseProviderId("deepseek"),
+			apiKey: "state-deepseek-key",
+		})
+	})
+
+	it("reads migrated OpenAI Compatible settings from the SDK provider id", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({
+			"openai-compatible": {
+				provider: "openai-compatible",
+				apiKey: "migrated-openai-compatible-key",
+				baseUrl: "https://gateway.example.invalid/v1",
+				headers: { "X-Test": "legacy-header" },
+			},
+		})
+
+		expect(buildEffectiveProviderConfig(parseProviderId("openai"))).toEqual({
+			providerId: parseProviderId("openai"),
+			apiKey: "migrated-openai-compatible-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+			headers: { "X-Test": "legacy-header" },
+		})
+	})
+
+	it("reads normalized nousResearch API key from StateManager", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({ nousResearch: { provider: "nousResearch", apiKey: "provider-nous-key" } })
+		mocks.setApiConfiguration({ nousResearchApiKey: "state-nous-key" })
+
+		expect(buildEffectiveProviderConfig(parseProviderId("nousResearch"))).toEqual({
+			providerId: parseProviderId("nousResearch"),
+			apiKey: "state-nous-key",
+		})
+	})
+
+	it("carries Qwen apiLine from StateManager effective configuration", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({ qwen: { provider: "qwen", apiKey: "provider-qwen-key", apiLine: "china" } })
+		mocks.setApiConfiguration({ qwenApiKey: "state-qwen-key", qwenApiLine: "international" })
+
+		expect(buildEffectiveProviderConfig(parseProviderId("qwen"))).toEqual({
+			providerId: parseProviderId("qwen"),
+			apiKey: "state-qwen-key",
+			apiLine: "international",
+		})
+	})
+
+	it("reads the Z.AI Coding Plan API key from provider-specific settings", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({
+			"zai-coding-plan": { provider: "zai-coding-plan", apiKey: "provider-zai-coding-plan-key" },
+		})
+		mocks.setApiConfiguration({ zaiApiKey: "state-zai-key" })
+
+		expect(buildEffectiveProviderConfig(parseProviderId("zai-coding-plan"))).toEqual({
+			providerId: parseProviderId("zai-coding-plan"),
+			apiKey: "provider-zai-coding-plan-key",
+		})
+	})
+
+	it("does not reuse the legacy Z.AI API key for Z.AI Coding Plan", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({
+			"zai-coding-plan": { provider: "zai-coding-plan" },
+		})
+		mocks.setApiConfiguration({ zaiApiKey: "state-zai-key" })
+
+		expect(buildEffectiveProviderConfig(parseProviderId("zai-coding-plan"))).toEqual({
+			providerId: parseProviderId("zai-coding-plan"),
+		})
+	})
+
+	it("respects remote-config-locked LiteLLM key already applied by StateManager", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setProviderSettings({
+			litellm: {
+				provider: "litellm",
+				apiKey: "local-litellm-key-from-providers-json",
+				baseUrl: "https://provider-litellm.example.com/v1",
+			},
+		})
+		mocks.setApiConfiguration({
+			liteLlmApiKey: "remote-config-locked-litellm-key",
+			liteLlmBaseUrl: "https://remote-litellm.example.com/v1",
+		})
+
+		expect(buildEffectiveProviderConfig(parseProviderId("litellm"))).toEqual({
+			providerId: parseProviderId("litellm"),
+			apiKey: "remote-config-locked-litellm-key",
+			baseUrl: "https://remote-litellm.example.com/v1",
+		})
+	})
+
+	it("keeps Cline account auth in the auth envelope", async () => {
+		const { buildEffectiveProviderConfig } = await import("./effective-config")
+		mocks.setApiConfiguration({ clineApiKey: "cline-access-token", clineAccountId: "account-123" })
+
+		expect(buildEffectiveProviderConfig(parseProviderId("cline"))).toEqual({
+			providerId: parseProviderId("cline"),
+			apiKey: "cline-access-token",
+			auth: { accessToken: "cline-access-token", accountId: "account-123" },
+		})
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/effective-config.ts b/apps/vscode/src/sdk/model-catalog/effective-config.ts
new file mode 100644
index 0000000..9b52340
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/effective-config.ts
@@ -0,0 +1,379 @@
+import type { ApiConfiguration } from "@shared/api"
+import { StateManager } from "@/core/storage/StateManager"
+import { getProviderSettingsManager } from "../provider-migration"
+import type { AwsProviderConfig, EffectiveProviderConfig, GcpProviderConfig, ProviderId } from "./contracts"
+import { toSdkProviderId } from "./sdk-provider-id"
+
+type AuthConfig = NonNullable<EffectiveProviderConfig["auth"]>
+type ExtrasConfig = NonNullable<EffectiveProviderConfig["extras"]>
+
+type ConfigParts = Omit<EffectiveProviderConfig, "providerId">
+type ConfigKey = keyof ConfigParts
+
+type ProviderSettingsLike = {
+	readonly apiKey?: string
+	readonly baseUrl?: string
+	readonly apiLine?: string
+	readonly headers?: Readonly<Record<string, string>>
+	readonly region?: string
+	readonly aws?: AwsProviderConfig
+	readonly gcp?: GcpProviderConfig
+	readonly auth?: AuthConfig
+	readonly extras?: ExtrasConfig
+}
+
+const apiKeyFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	anthropic: "apiKey",
+	openrouter: "openRouterApiKey",
+	openai: "openAiApiKey",
+	"openai-native": "openAiNativeApiKey",
+	"openai-codex": "openAiNativeApiKey",
+	bedrock: "awsBedrockApiKey",
+	gemini: "geminiApiKey",
+	deepseek: "deepSeekApiKey",
+	ollama: "ollamaApiKey",
+	requesty: "requestyApiKey",
+	together: "togetherApiKey",
+	fireworks: "fireworksApiKey",
+	qwen: "qwenApiKey",
+	"qwen-code": "qwenApiKey",
+	doubao: "doubaoApiKey",
+	mistral: "mistralApiKey",
+	litellm: "liteLlmApiKey",
+	asksage: "asksageApiKey",
+	xai: "xaiApiKey",
+	moonshot: "moonshotApiKey",
+	zai: "zaiApiKey",
+	huggingface: "huggingFaceApiKey",
+	nebius: "nebiusApiKey",
+	sambanova: "sambanovaApiKey",
+	cerebras: "cerebrasApiKey",
+	groq: "groqApiKey",
+	baseten: "basetenApiKey",
+	"huawei-cloud-maas": "huaweiCloudMaasApiKey",
+	dify: "difyApiKey",
+	minimax: "minimaxApiKey",
+	hicap: "hicapApiKey",
+	aihubmix: "aihubmixApiKey",
+	nousresearch: "nousResearchApiKey",
+	"vercel-ai-gateway": "vercelAiGatewayApiKey",
+	wandb: "wandbApiKey",
+	oca: "ocaApiKey",
+	cline: "clineApiKey",
+}
+
+const baseUrlFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	anthropic: "anthropicBaseUrl",
+	openai: "openAiBaseUrl",
+	ollama: "ollamaBaseUrl",
+	lmstudio: "lmStudioBaseUrl",
+	gemini: "geminiBaseUrl",
+	requesty: "requestyBaseUrl",
+	asksage: "asksageApiUrl",
+	litellm: "liteLlmBaseUrl",
+	sapaicore: "sapAiCoreBaseUrl",
+	dify: "difyBaseUrl",
+	oca: "ocaBaseUrl",
+	aihubmix: "aihubmixBaseUrl",
+}
+
+const apiLineFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	qwen: "qwenApiLine",
+	moonshot: "moonshotApiLine",
+	zai: "zaiApiLine",
+	minimax: "minimaxApiLine",
+}
+
+const regionFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	bedrock: "awsRegion",
+	vertex: "vertexRegion",
+}
+
+const gcpProjectFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	vertex: "vertexProjectId",
+}
+
+const gcpRegionFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	vertex: "vertexRegion",
+}
+
+const headerFields: Partial<Record<string, keyof ApiConfiguration>> = {
+	openai: "openAiHeaders",
+}
+
+const extrasFields: Partial<Record<string, Partial<Record<string, keyof ApiConfiguration>>>> = {
+	ollama: { ollamaApiOptionsCtxNum: "ollamaApiOptionsCtxNum" },
+	lmstudio: { lmStudioMaxTokens: "lmStudioMaxTokens" },
+	litellm: { liteLlmUsePromptCache: "liteLlmUsePromptCache" },
+	openrouter: { openRouterProviderSorting: "openRouterProviderSorting" },
+	bedrock: {
+		awsAuthentication: "awsAuthentication",
+		awsBedrockEndpoint: "awsBedrockEndpoint",
+		awsBedrockUsePromptCache: "awsBedrockUsePromptCache",
+		awsProfile: "awsProfile",
+		awsUseProfile: "awsUseProfile",
+	},
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function readString(record: Record<string, unknown>, key: string): string | undefined {
+	const value = record[key]
+	return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+function readHeaders(record: Record<string, unknown>, key: string): Readonly<Record<string, string>> | undefined {
+	const value = record[key]
+	if (!isPlainRecord(value)) {
+		return undefined
+	}
+
+	const headers: Record<string, string> = {}
+	for (const [headerName, headerValue] of Object.entries(value)) {
+		if (typeof headerValue !== "string") {
+			return undefined
+		}
+		headers[headerName] = headerValue
+	}
+	return Object.keys(headers).length > 0 ? headers : undefined
+}
+
+function readAuth(record: Record<string, unknown>): AuthConfig | undefined {
+	const auth = record.auth
+	if (!isPlainRecord(auth)) {
+		return undefined
+	}
+
+	const accessToken = readString(auth, "accessToken")
+	const refreshToken = readString(auth, "refreshToken")
+	const accountId = readString(auth, "accountId")
+	return accessToken || refreshToken || accountId ? { accessToken, refreshToken, accountId } : undefined
+}
+
+function readBoolean(record: Record<string, unknown>, key: string): boolean | undefined {
+	const value = record[key]
+	return typeof value === "boolean" ? value : undefined
+}
+
+function readGcp(record: Record<string, unknown>): GcpProviderConfig | undefined {
+	const gcp = record.gcp
+	if (!isPlainRecord(gcp)) {
+		return undefined
+	}
+
+	const result: GcpProviderConfig = {
+		projectId: readString(gcp, "projectId"),
+		region: readString(gcp, "region"),
+	}
+	return Object.values(result).some((value) => value !== undefined) ? result : undefined
+}
+
+function readAws(record: Record<string, unknown>): AwsProviderConfig | undefined {
+	const aws = record.aws
+	if (!isPlainRecord(aws)) {
+		return undefined
+	}
+
+	const result: AwsProviderConfig = {
+		accessKey: readString(aws, "accessKey"),
+		secretKey: readString(aws, "secretKey"),
+		sessionToken: readString(aws, "sessionToken"),
+		authentication: readString(aws, "authentication"),
+		profile: readString(aws, "profile"),
+		usePromptCache: readBoolean(aws, "usePromptCache"),
+		endpoint: readString(aws, "endpoint"),
+		customModelBaseId: readString(aws, "customModelBaseId"),
+		useCrossRegionInference: readBoolean(aws, "useCrossRegionInference") ?? readBoolean(record, "useCrossRegionInference"),
+		useGlobalInference: readBoolean(aws, "useGlobalInference") ?? readBoolean(record, "useGlobalInference"),
+	}
+	return Object.values(result).some((value) => value !== undefined) ? result : undefined
+}
+
+function readProviderSettings(providerId: ProviderId): ConfigParts {
+	try {
+		const settings: unknown = getProviderSettingsManager().getProviderSettings(toSdkProviderId(providerId))
+		if (!isPlainRecord(settings)) {
+			return {}
+		}
+
+		return {
+			apiKey: readString(settings, "apiKey"),
+			baseUrl: readString(settings, "baseUrl"),
+			apiLine: readString(settings, "apiLine"),
+			headers: readHeaders(settings, "headers"),
+			region: readString(settings, "region"),
+			aws: readAws(settings),
+			gcp: readGcp(settings),
+			auth: readAuth(settings),
+			extras: isPlainRecord(settings.extras) ? settings.extras : undefined,
+		} satisfies ProviderSettingsLike
+	} catch {
+		return {}
+	}
+}
+
+function readStringFromConfig(config: ApiConfiguration, field: keyof ApiConfiguration | undefined): string | undefined {
+	if (!field) {
+		return undefined
+	}
+	const value = config[field]
+	return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+function readHeadersFromConfig(
+	config: ApiConfiguration,
+	field: keyof ApiConfiguration | undefined,
+): Readonly<Record<string, string>> | undefined {
+	if (!field) {
+		return undefined
+	}
+	const value = config[field]
+	return isPlainRecord(value) ? readHeaders({ value }, "value") : undefined
+}
+
+function readStateExtras(provider: string, config: ApiConfiguration): ExtrasConfig | undefined {
+	const fieldMap = extrasFields[provider]
+	if (!fieldMap) {
+		return undefined
+	}
+
+	const extras: Record<string, unknown> = {}
+	for (const [extraName, configField] of Object.entries(fieldMap)) {
+		if (configField === undefined) {
+			continue
+		}
+		const value = config[configField]
+		if (value !== undefined) {
+			extras[extraName] = value
+		}
+	}
+	return Object.keys(extras).length > 0 ? extras : undefined
+}
+
+function readStateAuth(provider: string, config: ApiConfiguration): AuthConfig | undefined {
+	if (provider !== "cline") {
+		return undefined
+	}
+
+	const accessToken = readStringFromConfig(config, "clineApiKey")
+	const accountId = readStringFromConfig(config, "clineAccountId")
+	return accessToken || accountId ? { accessToken, accountId } : undefined
+}
+
+function readStateBoolean(config: ApiConfiguration, field: keyof ApiConfiguration): boolean | undefined {
+	const value = config[field]
+	return typeof value === "boolean" ? value : undefined
+}
+
+function readStateGcp(provider: string, config: ApiConfiguration): GcpProviderConfig | undefined {
+	if (provider !== "vertex") {
+		return undefined
+	}
+
+	const gcp: GcpProviderConfig = {
+		projectId: readStringFromConfig(config, gcpProjectFields[provider]),
+		region: readStringFromConfig(config, gcpRegionFields[provider]),
+	}
+	return Object.values(gcp).some((value) => value !== undefined) ? gcp : undefined
+}
+
+function readStateAws(provider: string, config: ApiConfiguration): AwsProviderConfig | undefined {
+	if (provider !== "bedrock") {
+		return undefined
+	}
+
+	const aws: AwsProviderConfig = {
+		accessKey: readStringFromConfig(config, "awsAccessKey"),
+		secretKey: readStringFromConfig(config, "awsSecretKey"),
+		sessionToken: readStringFromConfig(config, "awsSessionToken"),
+		authentication: readStringFromConfig(config, "awsAuthentication"),
+		profile: readStringFromConfig(config, "awsProfile"),
+		usePromptCache: readStateBoolean(config, "awsBedrockUsePromptCache"),
+		endpoint: readStringFromConfig(config, "awsBedrockEndpoint"),
+		useCrossRegionInference: readStateBoolean(config, "awsUseCrossRegionInference"),
+		useGlobalInference: readStateBoolean(config, "awsUseGlobalInference"),
+	}
+	return Object.values(aws).some((value) => value !== undefined) ? aws : undefined
+}
+
+function readStateConfig(providerId: ProviderId, config: ApiConfiguration): ConfigParts {
+	const provider = providerId.toString()
+	return {
+		apiKey: readStringFromConfig(config, apiKeyFields[provider]),
+		baseUrl: readStringFromConfig(config, baseUrlFields[provider]),
+		apiLine: readStringFromConfig(config, apiLineFields[provider]),
+		headers: readHeadersFromConfig(config, headerFields[provider]),
+		region: readStringFromConfig(config, regionFields[provider]),
+		aws: readStateAws(provider, config),
+		gcp: readStateGcp(provider, config),
+		auth: readStateAuth(provider, config),
+		extras: readStateExtras(provider, config),
+	}
+}
+
+function mergeExtras(first: ExtrasConfig | undefined, second: ExtrasConfig | undefined): ExtrasConfig | undefined {
+	if (!first) {
+		return second
+	}
+	if (!second) {
+		return first
+	}
+	return { ...first, ...second }
+}
+
+function mergeGcp(first: GcpProviderConfig | undefined, second: GcpProviderConfig | undefined): GcpProviderConfig | undefined {
+	if (!first) {
+		return second
+	}
+	if (!second) {
+		return first
+	}
+	return { ...first, ...second }
+}
+
+function mergeAws(first: AwsProviderConfig | undefined, second: AwsProviderConfig | undefined): AwsProviderConfig | undefined {
+	if (!first) {
+		return second
+	}
+	if (!second) {
+		return first
+	}
+	return { ...first, ...second }
+}
+
+function assignIfDefined<T extends ConfigKey>(target: Partial<ConfigParts>, key: T, value: ConfigParts[T] | undefined): void {
+	if (value !== undefined) {
+		target[key] = value
+	}
+}
+
+/**
+ * Build an {@link EffectiveProviderConfig} by merging provider-owned settings
+ * from SDK `providers.json` with the current StateManager effective API
+ * configuration. StateManager's `getApiConfiguration()` already applies
+ * task/session/remote-config overlays for legacy fields, so those values win.
+ *
+ * Mode-dependent model selection is intentionally excluded; callers use
+ * `ProviderConfigStore.readSelection(providerId, mode)` for that.
+ */
+export function buildEffectiveProviderConfig(providerId: ProviderId): EffectiveProviderConfig {
+	const providerSettings = readProviderSettings(providerId)
+	const stateConfig = readStateConfig(providerId, StateManager.get().getApiConfiguration())
+	const merged: Partial<ConfigParts> = {}
+
+	assignIfDefined(merged, "apiKey", stateConfig.apiKey ?? providerSettings.apiKey)
+	assignIfDefined(merged, "baseUrl", stateConfig.baseUrl ?? providerSettings.baseUrl)
+	assignIfDefined(merged, "apiLine", stateConfig.apiLine ?? providerSettings.apiLine)
+	assignIfDefined(merged, "headers", stateConfig.headers ?? providerSettings.headers)
+	assignIfDefined(merged, "region", stateConfig.region ?? providerSettings.region)
+	// Bedrock/Vertex are migrated to providers.json. Keep legacy StateManager cloud
+	// fields as a fallback for old installs, but let providers.json win when both exist.
+	assignIfDefined(merged, "aws", mergeAws(stateConfig.aws, providerSettings.aws))
+	assignIfDefined(merged, "gcp", mergeGcp(stateConfig.gcp, providerSettings.gcp))
+	assignIfDefined(merged, "auth", stateConfig.auth ?? providerSettings.auth)
+	assignIfDefined(merged, "extras", mergeExtras(providerSettings.extras, stateConfig.extras))
+
+	return { providerId, ...merged }
+}
diff --git a/apps/vscode/src/sdk/model-catalog/fingerprint.test.ts b/apps/vscode/src/sdk/model-catalog/fingerprint.test.ts
new file mode 100644
index 0000000..76ee42e
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/fingerprint.test.ts
@@ -0,0 +1,209 @@
+import { describe, expect, it } from "vitest"
+import type { EffectiveProviderConfig } from "./contracts"
+import { computeConfigFingerprint } from "./fingerprint"
+import { parseProviderId } from "./provider-id"
+
+const providerId = parseProviderId("litellm")
+
+function makeConfig(overrides: Partial<EffectiveProviderConfig> = {}): EffectiveProviderConfig {
+	return {
+		providerId,
+		baseUrl: "https://models.example.com/v1",
+		apiKey: "api-key-a",
+		apiLine: "default",
+		headers: {
+			authorization: "Bearer header-token-a",
+			"x-team": "catalog",
+		},
+		region: "us-east-1",
+		extras: {
+			deployment: "primary",
+			nested: {
+				beta: true,
+				weight: 2,
+			},
+		},
+		auth: {
+			accountId: "account-a",
+			accessToken: "access-token-a",
+			refreshToken: "refresh-token-a",
+		},
+		...overrides,
+	}
+}
+
+describe("computeConfigFingerprint", () => {
+	it("returns the same fingerprint for the same input", () => {
+		const config = makeConfig()
+
+		expect(computeConfigFingerprint(providerId, config)).toBe(computeConfigFingerprint(providerId, config))
+	})
+
+	it("changes when the baseUrl changes", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ baseUrl: "https://models-a.example.com" }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ baseUrl: "https://models-b.example.com" })),
+		)
+	})
+
+	it("changes when the apiKey changes", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ apiKey: "api-key-a" }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ apiKey: "api-key-b" })),
+		)
+	})
+
+	it("changes when the apiLine changes", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ apiLine: "commercial" }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ apiLine: "international" })),
+		)
+	})
+
+	it("changes when the region changes", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ region: "us-east-1" }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ region: "eu-west-1" })),
+		)
+	})
+
+	it("changes when a headers value changes", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ headers: { a: "1", b: "2" } }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ headers: { a: "1", b: "3" } })),
+		)
+	})
+
+	it("does not change when headers keys are ordered differently", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ headers: { b: "2", a: "1" } }))).toBe(
+			computeConfigFingerprint(providerId, makeConfig({ headers: { a: "1", b: "2" } })),
+		)
+	})
+
+	it("changes when extras change", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ extras: { nested: { a: 1, b: true } } }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ extras: { nested: { a: 1, b: false } } })),
+		)
+	})
+
+	it("does not change when extras keys are ordered differently", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ extras: { nested: { b: 2, a: 1 } } }))).toBe(
+			computeConfigFingerprint(providerId, makeConfig({ extras: { nested: { a: 1, b: 2 } } })),
+		)
+	})
+
+	it("changes when auth accessToken or refreshToken changes", () => {
+		const baseAuth = { accountId: "account-a", accessToken: "access-token-a", refreshToken: "refresh-token-a" }
+
+		expect(computeConfigFingerprint(providerId, makeConfig({ auth: baseAuth }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ auth: { ...baseAuth, accessToken: "access-token-b" } })),
+		)
+		expect(computeConfigFingerprint(providerId, makeConfig({ auth: baseAuth }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ auth: { ...baseAuth, refreshToken: "refresh-token-b" } })),
+		)
+	})
+
+	it("changes when auth accountId changes", () => {
+		expect(
+			computeConfigFingerprint(
+				providerId,
+				makeConfig({ auth: { accountId: "account-a", accessToken: "access-token-a", refreshToken: "refresh-token-a" } }),
+			),
+		).not.toBe(
+			computeConfigFingerprint(
+				providerId,
+				makeConfig({ auth: { accountId: "account-b", accessToken: "access-token-a", refreshToken: "refresh-token-a" } }),
+			),
+		)
+	})
+
+	it("does not include raw secret sentinel values in the returned fingerprint", () => {
+		const fingerprint = computeConfigFingerprint(
+			providerId,
+			makeConfig({
+				apiKey: "SECRET_SENTINEL_API_KEY",
+				auth: {
+					accountId: "account-a",
+					accessToken: "SECRET_SENTINEL_ACCESS_TOKEN",
+					refreshToken: "SECRET_SENTINEL_REFRESH_TOKEN",
+				},
+			}),
+		)
+
+		expect(fingerprint).not.toContain("SECRET_SENTINEL")
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_API_KEY")
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_ACCESS_TOKEN")
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_REFRESH_TOKEN")
+	})
+
+	it("does not include raw header value sentinels in the returned fingerprint", () => {
+		const fingerprint = computeConfigFingerprint(
+			providerId,
+			makeConfig({
+				headers: {
+					authorization: "Bearer SECRET_SENTINEL_HEADER_TOKEN",
+					"x-api-key": "SECRET_SENTINEL_HEADER_API_KEY",
+				},
+			}),
+		)
+
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_HEADER_TOKEN")
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_HEADER_API_KEY")
+		expect(fingerprint).not.toContain("Bearer SECRET_SENTINEL_HEADER_TOKEN")
+	})
+
+	it("does not include raw extras string value sentinels in the returned fingerprint", () => {
+		const fingerprint = computeConfigFingerprint(
+			providerId,
+			makeConfig({
+				extras: {
+					token: "SECRET_SENTINEL_EXTRAS_TOKEN",
+					nested: {
+						credential: "SECRET_SENTINEL_EXTRAS_NESTED",
+					},
+					list: ["SECRET_SENTINEL_EXTRAS_ARRAY_ITEM", 1, true],
+				},
+			}),
+		)
+
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_EXTRAS_TOKEN")
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_EXTRAS_NESTED")
+		expect(fingerprint).not.toContain("SECRET_SENTINEL_EXTRAS_ARRAY_ITEM")
+	})
+
+	it("changes when an extras string value changes but its key does not", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ extras: { token: "value-a" } }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ extras: { token: "value-b" } })),
+		)
+	})
+
+	it("changes when a nested extras string value changes", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ extras: { nested: { secret: "x" } } }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ extras: { nested: { secret: "y" } } })),
+		)
+	})
+
+	it("preserves array order in extras for fingerprint differentiation", () => {
+		expect(computeConfigFingerprint(providerId, makeConfig({ extras: { list: ["a", "b"] } }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ extras: { list: ["b", "a"] } })),
+		)
+	})
+
+	it("changes when the providerId argument changes", () => {
+		const otherProviderId = parseProviderId("openai")
+
+		expect(computeConfigFingerprint(providerId, makeConfig())).not.toBe(
+			computeConfigFingerprint(otherProviderId, makeConfig({ providerId: otherProviderId })),
+		)
+	})
+
+	it("uses config providerId as part of the fingerprint input", () => {
+		const otherProviderId = parseProviderId("openai")
+
+		expect(computeConfigFingerprint(providerId, makeConfig({ providerId }))).not.toBe(
+			computeConfigFingerprint(providerId, makeConfig({ providerId: otherProviderId })),
+		)
+	})
+
+	it("returns a versioned full sha256 fingerprint", () => {
+		const fingerprint = computeConfigFingerprint(providerId, makeConfig())
+		const value: string = fingerprint
+
+		expect(value).toMatch(/^config:v1:[a-f0-9]{64}$/)
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/fingerprint.ts b/apps/vscode/src/sdk/model-catalog/fingerprint.ts
new file mode 100644
index 0000000..cd15cc4
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/fingerprint.ts
@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto"
+import type { EffectiveProviderConfig, Fingerprint, ProviderId } from "./contracts"
+
+const FINGERPRINT_VERSION = 1
+const SECRET_HASH_LENGTH = 12
+
+function sha256Hex(input: string): string {
+	return createHash("sha256").update(input).digest("hex")
+}
+
+/**
+ * Hash a secret-bearing string into a short, opaque digest. The raw value
+ * never appears in the returned record, so the sanitized payload can be
+ * safely retained or serialized internally without leaking secrets.
+ *
+ * Empty/undefined values map to `{present: false}` so absence is
+ * distinguishable from presence-with-empty-hash.
+ */
+function shortSecretHash(value: string | undefined): { readonly present: boolean; readonly hash?: string } {
+	if (typeof value !== "string" || value.length === 0) {
+		return { present: false }
+	}
+
+	return { present: true, hash: sha256Hex(value).slice(0, SECRET_HASH_LENGTH) }
+}
+
+/**
+ * Sanitize a header map: header *names* are not secret and stay readable
+ * (they are useful for debugging fingerprint differences), but header
+ * *values* often carry tokens and must be hashed before reaching the
+ * canonical payload. Returns `null` when no headers are present so the
+ * fingerprint distinguishes "no headers" from "empty headers map".
+ */
+function sanitizeHeaders(
+	headers: Readonly<Record<string, string>> | undefined,
+): Readonly<Record<string, { readonly present: boolean; readonly hash?: string }>> | null {
+	if (!headers) {
+		return null
+	}
+
+	const sanitized: Record<string, { readonly present: boolean; readonly hash?: string }> = {}
+	for (const name of Object.keys(headers)) {
+		sanitized[name] = shortSecretHash(headers[name])
+	}
+	return sanitized
+}
+
+/**
+ * Sanitize an arbitrary extras value. Strings are replaced with an opaque
+ * `{kind: "string", hash}` record so user-supplied tokens that get
+ * smuggled into extras cannot leak through the fingerprint pipeline.
+ * Numbers, booleans, and null are preserved as-is because they cannot
+ * carry secret material and their identity matters for fingerprint
+ * differentiation. Arrays preserve order. Object key ordering is not
+ * preserved here — `canonicalStringify` re-sorts keys at the final step.
+ * Undefined object fields are dropped to match canonicalization behavior.
+ */
+function sanitizeExtrasValue(value: unknown): unknown {
+	if (value === null) {
+		return null
+	}
+	if (typeof value === "string") {
+		return { kind: "string", hash: sha256Hex(value).slice(0, SECRET_HASH_LENGTH) }
+	}
+	if (typeof value === "number" || typeof value === "boolean") {
+		return value
+	}
+	if (Array.isArray(value)) {
+		return value.map((item) => sanitizeExtrasValue(item))
+	}
+	if (typeof value === "object") {
+		const record = value as Readonly<Record<string, unknown>>
+		const sanitized: Record<string, unknown> = {}
+		for (const key of Object.keys(record)) {
+			const child = record[key]
+			if (child === undefined) {
+				continue
+			}
+			sanitized[key] = sanitizeExtrasValue(child)
+		}
+		return sanitized
+	}
+	// `undefined`, `bigint`, `symbol`, `function` — collapse to null. These
+	// should never reach this function via a well-typed EffectiveProviderConfig
+	// but we handle them defensively so the fingerprint stays total.
+	return null
+}
+
+function sanitizeExtras(extras: Readonly<Record<string, unknown>> | undefined): Readonly<Record<string, unknown>> | null {
+	if (!extras) {
+		return null
+	}
+	const result = sanitizeExtrasValue(extras)
+	// `sanitizeExtrasValue` of a plain object returns a record; the cast
+	// is local and trivially correct given the branch above.
+	return result as Readonly<Record<string, unknown>>
+}
+
+function sanitizeGcp(config: EffectiveProviderConfig["gcp"]): Readonly<Record<string, unknown>> | null {
+	if (!config) {
+		return null
+	}
+	return {
+		projectId: config.projectId ?? null,
+		region: config.region ?? null,
+	}
+}
+
+function sanitizeAws(config: EffectiveProviderConfig["aws"]): Readonly<Record<string, unknown>> | null {
+	if (!config) {
+		return null
+	}
+	return {
+		accessKey: shortSecretHash(config.accessKey),
+		secretKey: shortSecretHash(config.secretKey),
+		sessionToken: shortSecretHash(config.sessionToken),
+		authentication: config.authentication ?? null,
+		profile: config.profile ?? null,
+		usePromptCache: config.usePromptCache ?? null,
+		endpoint: config.endpoint ?? null,
+		customModelBaseId: config.customModelBaseId ?? null,
+		useCrossRegionInference: config.useCrossRegionInference ?? null,
+		useGlobalInference: config.useGlobalInference ?? null,
+	}
+}
+
+/**
+ * Canonical JSON serialization with deterministic key ordering at every
+ * object depth. Arrays preserve order because array order is meaningful.
+ * Undefined object properties are dropped to mirror JSON.stringify and avoid
+ * treating absent optional fields differently from explicitly-undefined ones.
+ */
+function canonicalStringify(value: unknown): string {
+	if (value === null || typeof value !== "object") {
+		return JSON.stringify(value) ?? "null"
+	}
+
+	if (Array.isArray(value)) {
+		return `[${value.map((item) => canonicalStringify(item)).join(",")}]`
+	}
+
+	const record = value as Readonly<Record<string, unknown>>
+	const entries = Object.keys(record)
+		.filter((key) => record[key] !== undefined)
+		.sort()
+		.map((key) => `${JSON.stringify(key)}:${canonicalStringify(record[key])}`)
+
+	return `{${entries.join(",")}}`
+}
+
+/**
+ * Compute a fingerprint for the given provider effective config.
+ *
+ * Invariant: total, pure, deterministic. Same `(providerId, config)` always
+ * produces the same fingerprint; different inputs produce different
+ * fingerprints (up to hash collision). Raw secrets never appear in the
+ * output *or* in the intermediate sanitized payload that is fed into the
+ * final hash. Header values and extras string values are hashed before
+ * canonicalization so even an attacker with access to the pre-hash payload
+ * cannot recover raw secrets.
+ */
+export function computeConfigFingerprint(providerId: ProviderId, config: EffectiveProviderConfig): Fingerprint {
+	const payload = {
+		version: FINGERPRINT_VERSION,
+		providerId,
+		configProviderId: config.providerId,
+		baseUrl: config.baseUrl ?? null,
+		apiLine: config.apiLine ?? null,
+		headers: sanitizeHeaders(config.headers),
+		region: config.region ?? null,
+		aws: sanitizeAws(config.aws),
+		gcp: sanitizeGcp(config.gcp),
+		extras: sanitizeExtras(config.extras),
+		auth: {
+			accountId: config.auth?.accountId ?? null,
+			accessToken: shortSecretHash(config.auth?.accessToken),
+			refreshToken: shortSecretHash(config.auth?.refreshToken),
+		},
+		apiKey: shortSecretHash(config.apiKey),
+	}
+
+	return `config:v${FINGERPRINT_VERSION}:${sha256Hex(canonicalStringify(payload))}` as Fingerprint
+}
diff --git a/apps/vscode/src/sdk/model-catalog/host-overrides.ts b/apps/vscode/src/sdk/model-catalog/host-overrides.ts
new file mode 100644
index 0000000..7eb2288
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/host-overrides.ts
@@ -0,0 +1,22 @@
+/**
+ * Applies the `ModelInfo` fields the extension owns locally, on top of
+ * an adapted SDK `ModelInfo`. Today this is just Vertex's
+ * `supportsGlobalEndpoint` allowlist (see `./vertex-global-endpoint.ts`).
+ *
+ * Both the model-list resolution path (`resolveSdkModels`) and the
+ * single-model lookup path (`resolveModelInfo`) pass adapted
+ * `ModelInfo` through this function so the same UX guard rails apply
+ * regardless of which RPC the webview uses. When the SDK adopts these
+ * flags upstream, the override and this file can be removed together.
+ */
+
+import type { ModelInfo } from "@shared/api"
+import type { ProviderId } from "./contracts"
+import { vertexModelSupportsGlobalEndpoint } from "./vertex-global-endpoint"
+
+export function applyHostModelInfoOverrides(providerId: ProviderId, modelId: string, modelInfo: ModelInfo): ModelInfo {
+	if (providerId === "vertex" && vertexModelSupportsGlobalEndpoint(providerId, modelId)) {
+		return { ...modelInfo, supportsGlobalEndpoint: true }
+	}
+	return modelInfo
+}
diff --git a/apps/vscode/src/sdk/model-catalog/provider-id.test.ts b/apps/vscode/src/sdk/model-catalog/provider-id.test.ts
new file mode 100644
index 0000000..bc24f0a
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/provider-id.test.ts
@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { Logger } from "../../shared/services/Logger"
+import type { KnownProviderId } from "./contracts"
+import { isKnownProviderId, parseProviderId } from "./provider-id"
+
+let warnSpy: ReturnType<typeof vi.spyOn>
+
+beforeEach(() => {
+	warnSpy = vi.spyOn(Logger, "warn").mockImplementation(() => {})
+})
+
+afterEach(() => {
+	warnSpy.mockRestore()
+})
+
+describe("parseProviderId", () => {
+	it("trims whitespace and lowercases the provider id", () => {
+		expect(parseProviderId("  Anthropic  ")).toBe("anthropic")
+		expect(parseProviderId("\tOPENROUTER\n")).toBe("openrouter")
+	})
+
+	it("accepts arbitrary custom provider ids", () => {
+		expect(parseProviderId("  Custom-SDK-Provider  ")).toBe("custom-sdk-provider")
+	})
+
+	it("normalizes the legacy camel-case nousResearch id", () => {
+		expect(parseProviderId("nousResearch")).toBe("nousresearch")
+		expect(parseProviderId("NOUSRESEARCH")).toBe("nousresearch")
+	})
+
+	it("warns once per non-empty unknown provider id", () => {
+		parseProviderId("provider-id-test-unknown-a")
+		parseProviderId("provider-id-test-unknown-a")
+		parseProviderId("provider-id-test-unknown-b")
+		parseProviderId("   ")
+
+		const warnings = warnSpy.mock.calls.filter((call: unknown[]) => {
+			const message = call[0]
+			return typeof message === "string" && message.includes("provider-id-test-unknown-")
+		})
+		expect(warnings).toHaveLength(2)
+	})
+
+	it("does not warn for known provider ids", () => {
+		parseProviderId("anthropic")
+		parseProviderId("openai")
+		parseProviderId("nousResearch")
+		parseProviderId("zai-coding-plan")
+		parseProviderId("poolside")
+		parseProviderId("v0")
+		parseProviderId("xiaomi")
+		parseProviderId("tencent-tokenhub")
+
+		expect(warnSpy).not.toHaveBeenCalled()
+	})
+})
+
+describe("isKnownProviderId", () => {
+	it("returns true for known provider ids after parsing", () => {
+		expect(isKnownProviderId(parseProviderId("anthropic"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("openai"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("deepseek"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("nousResearch"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("zai-coding-plan"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("poolside"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("v0"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("xiaomi"))).toBe(true)
+		expect(isKnownProviderId(parseProviderId("tencent-tokenhub"))).toBe(true)
+	})
+
+	it("returns false for a custom provider id", () => {
+		expect(isKnownProviderId(parseProviderId("provider-id-test-custom-provider"))).toBe(false)
+	})
+
+	it("acts as a type predicate", () => {
+		const id = parseProviderId("anthropic")
+		if (!isKnownProviderId(id)) {
+			throw new Error("expected anthropic to be known")
+		}
+
+		const knownProviderId: KnownProviderId = id
+		expect(knownProviderId).toBe("anthropic")
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/provider-id.ts b/apps/vscode/src/sdk/model-catalog/provider-id.ts
new file mode 100644
index 0000000..2695284
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/provider-id.ts
@@ -0,0 +1,101 @@
+import type { ApiProvider } from "@shared/api"
+import { Logger } from "../../shared/services/Logger"
+import type { KnownProviderId, ProviderId } from "./contracts"
+
+/**
+ * Extension-known provider ids. The object is typed against `ApiProvider`
+ * so adding/removing an `ApiProvider` member forces this list to update.
+ *
+ * `parseProviderId` lowercases all ids so config/storage provider names stay
+ * portable across extension versions and hosts. SDK calls that require a
+ * different spelling normalize at the SDK boundary.
+ */
+const KNOWN_API_PROVIDERS = {
+	anthropic: true,
+	"claude-code": true,
+	openrouter: true,
+	bedrock: true,
+	vertex: true,
+	openai: true,
+	ollama: true,
+	lmstudio: true,
+	gemini: true,
+	"openai-native": true,
+	"openai-codex": true,
+	requesty: true,
+	together: true,
+	deepseek: true,
+	qwen: true,
+	"qwen-code": true,
+	doubao: true,
+	mistral: true,
+	"vscode-lm": true,
+	cline: true,
+	litellm: true,
+	moonshot: true,
+	nebius: true,
+	fireworks: true,
+	asksage: true,
+	xai: true,
+	sambanova: true,
+	cerebras: true,
+	sapaicore: true,
+	groq: true,
+	poolside: true,
+	huggingface: true,
+	"huawei-cloud-maas": true,
+	dify: true,
+	baseten: true,
+	"vercel-ai-gateway": true,
+	v0: true,
+	zai: true,
+	"zai-coding-plan": true,
+	oca: true,
+	aihubmix: true,
+	minimax: true,
+	hicap: true,
+	nousResearch: true,
+	wandb: true,
+	xiaomi: true,
+	"tencent-tokenhub": true,
+	"cline-pass": true,
+} satisfies Record<ApiProvider, true>
+
+const normalizeProviderId = (raw: string): string => raw.trim().toLowerCase()
+
+const knownProviderIds = new Set(Object.keys(KNOWN_API_PROVIDERS).map(normalizeProviderId))
+const warnedUnknownProviderIds = new Set<string>()
+
+/**
+ * Parse a raw string into a branded {@link ProviderId}.
+ *
+ * Behavior:
+ * - Trims surrounding whitespace.
+ * - Lowercases the id (canonical form used by extension config/storage).
+ * - Accepts arbitrary strings so SDK/custom providers are representable.
+ * - Emits a one-time warning per non-empty unknown id per process.
+ *
+ * The single `as ProviderId` cast here is the constructor for the brand
+ * and is the allowed boundary cast for this primitive. Do not replicate
+ * this cast elsewhere; callers outside this module must obtain a
+ * `ProviderId` through this function.
+ */
+export function parseProviderId(raw: string): ProviderId {
+	const normalized = normalizeProviderId(raw)
+	if (normalized.length > 0 && !knownProviderIds.has(normalized) && !warnedUnknownProviderIds.has(normalized)) {
+		warnedUnknownProviderIds.add(normalized)
+		Logger.warn(`[model-catalog] Unknown provider id "${normalized}". Treating as a custom provider.`)
+	}
+	return normalized as ProviderId
+}
+
+/**
+ * Type guard narrowing a {@link ProviderId} to {@link KnownProviderId}.
+ *
+ * Recognition is membership in the normalized `ApiProvider` set. Because
+ * `parseProviderId` lowercases input, legacy `nousResearch` is recognized
+ * after parsing as `nousresearch`.
+ */
+export function isKnownProviderId(id: ProviderId): id is KnownProviderId {
+	return knownProviderIds.has(id)
+}
diff --git a/apps/vscode/src/sdk/model-catalog/sdk-provider-id.test.ts b/apps/vscode/src/sdk/model-catalog/sdk-provider-id.test.ts
new file mode 100644
index 0000000..b983663
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/sdk-provider-id.test.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest"
+import { parseProviderId } from "./provider-id"
+import { toSdkProviderId } from "./sdk-provider-id"
+
+describe("toSdkProviderId", () => {
+	it("maps lowercased extension ids to SDK-specific provider id casing", () => {
+		expect(parseProviderId("nousResearch")).toBe("nousresearch")
+		expect(toSdkProviderId(parseProviderId("nousResearch"))).toBe("nousResearch")
+	})
+
+	it("passes through providers whose SDK id matches extension config casing", () => {
+		expect(toSdkProviderId(parseProviderId("openrouter"))).toBe("openrouter")
+		expect(toSdkProviderId("huawei-cloud-maas")).toBe("huawei-cloud-maas")
+	})
+
+	it("maps the extension's openai alias to the SDK's openai-compatible built-in", () => {
+		// The extension stores the OpenAI Compatible provider as "openai"; the
+		// SDK registers it as "openai-compatible". Mapping here lets the SDK
+		// provider registry recognize it and routes it through the
+		// chat-completions client (matching the CLI's provider id).
+		expect(toSdkProviderId(parseProviderId("openai"))).toBe("openai-compatible")
+		expect(toSdkProviderId("openai")).toBe("openai-compatible")
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/sdk-provider-id.ts b/apps/vscode/src/sdk/model-catalog/sdk-provider-id.ts
new file mode 100644
index 0000000..a1219d6
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/sdk-provider-id.ts
@@ -0,0 +1,27 @@
+import type { ProviderId } from "./contracts"
+
+/**
+ * Convert the extension's provider id spelling to the SDK's provider id.
+ *
+ * Extension config/storage keeps provider ids lowercased for cross-version
+ * portability, while the SDK registry uses a few specific spellings:
+ *
+ * - `nousresearch` → `nousResearch`: same provider, case-sensitive SDK id.
+ * - `openai` → `openai-compatible`: the extension stores the OpenAI Compatible
+ *   provider (user-supplied base URL + arbitrary chat-completions model) under
+ *   the id `openai`, but the SDK registers that built-in as `openai-compatible`
+ *   and routes it through the chat-completions client. Using the SDK id keeps
+ *   the extension aligned with the CLI and lets the SDK's provider registry and
+ *   model catalog resolve the provider; passing `openai` instead is rejected as
+ *   an unknown provider.
+ *
+ * Any id without an entry here is passed through unchanged.
+ */
+const EXTENSION_TO_SDK_PROVIDER_ID: Readonly<Record<string, string>> = {
+	nousresearch: "nousResearch",
+	openai: "openai-compatible",
+}
+
+export function toSdkProviderId(providerId: ProviderId | string): string {
+	return EXTENSION_TO_SDK_PROVIDER_ID[providerId.toString()] ?? providerId.toString()
+}
diff --git a/apps/vscode/src/sdk/model-catalog/shape-adapter.test.ts b/apps/vscode/src/sdk/model-catalog/shape-adapter.test.ts
new file mode 100644
index 0000000..b00b4c8
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/shape-adapter.test.ts
@@ -0,0 +1,188 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { describe, expect, it } from "vitest"
+import { adaptSdkModelInfo, CatalogShapeError } from "./shape-adapter"
+
+describe("adaptSdkModelInfo", () => {
+	describe("validation", () => {
+		it("throws CatalogShapeError when input is not an object", () => {
+			expect(() => adaptSdkModelInfo(null)).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo(undefined)).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo("oops")).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo(42)).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo([])).toThrow(CatalogShapeError)
+		})
+
+		it("throws CatalogShapeError when id is missing, non-string, or empty", () => {
+			expect(() => adaptSdkModelInfo({})).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: 123 })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "" })).toThrow(CatalogShapeError)
+		})
+
+		it("throws CatalogShapeError when optional scalar fields are malformed", () => {
+			expect(() => adaptSdkModelInfo({ id: "m", contextWindow: "big" })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", maxTokens: "huge" })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", name: 1 })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", description: 1 })).toThrow(CatalogShapeError)
+		})
+
+		it("throws CatalogShapeError when capabilities is malformed", () => {
+			expect(() => adaptSdkModelInfo({ id: "m", capabilities: "tools" })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", capabilities: ["tools", 42] })).toThrow(CatalogShapeError)
+		})
+
+		it("throws CatalogShapeError when pricing is malformed", () => {
+			expect(() => adaptSdkModelInfo({ id: "m", pricing: "cheap" })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", pricing: { input: "free" } })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", pricing: { input: Number.NaN } })).toThrow(CatalogShapeError)
+			expect(() => adaptSdkModelInfo({ id: "m", pricing: { input: Number.POSITIVE_INFINITY } })).toThrow(CatalogShapeError)
+		})
+
+		it("CatalogShapeError exposes useful message and details", () => {
+			try {
+				adaptSdkModelInfo({ id: 5 })
+				expect.fail("should have thrown")
+			} catch (error) {
+				expect(error).toBeInstanceOf(CatalogShapeError)
+				const shapeError = error as CatalogShapeError
+				expect(shapeError.name).toBe("CatalogShapeError")
+				expect(shapeError.message).toMatch(/id/i)
+				expect(shapeError.details?.idType).toBe("number")
+			}
+		})
+	})
+
+	describe("capability flags", () => {
+		it("derives supportsImages from images or vision capability", () => {
+			expect(adaptSdkModelInfo({ id: "images", capabilities: ["images"] }).supportsImages).toBe(true)
+			expect(adaptSdkModelInfo({ id: "vision", capabilities: ["vision"] }).supportsImages).toBe(true)
+		})
+
+		it("sets image/cache flags false when capabilities are present but absent", () => {
+			const model = adaptSdkModelInfo({ id: "m", capabilities: ["tools"] })
+			expect(model.supportsImages).toBe(false)
+			expect(model.supportsPromptCache).toBe(false)
+			expect(model.supportsReasoning).toBeUndefined()
+		})
+
+		it("derives supportsPromptCache and supportsReasoning from capabilities", () => {
+			const model = adaptSdkModelInfo({ id: "m", capabilities: ["prompt-cache", "reasoning"] })
+			expect(model.supportsPromptCache).toBe(true)
+			expect(model.supportsReasoning).toBe(true)
+		})
+
+		it("ignores unrelated capabilities", () => {
+			const model = adaptSdkModelInfo({
+				id: "m",
+				capabilities: ["tools", "streaming", "structured_output", "temperature"],
+			})
+			expect(model.supportsImages).toBe(false)
+			expect(model.supportsPromptCache).toBe(false)
+			expect(model.supportsReasoning).toBeUndefined()
+		})
+
+		it("uses safe defaults for image/cache capabilities when capabilities are absent", () => {
+			const model = adaptSdkModelInfo({ id: "m" })
+			expect(model.supportsImages).toBe(openAiModelInfoSafeDefaults.supportsImages)
+			expect(model.supportsPromptCache).toBe(openAiModelInfoSafeDefaults.supportsPromptCache)
+			expect(model.supportsReasoning).toBeUndefined()
+		})
+	})
+
+	describe("pricing", () => {
+		it("maps pricing fields correctly", () => {
+			const model = adaptSdkModelInfo({
+				id: "m",
+				pricing: { input: 1.5, output: 7.25, cacheRead: 0.1, cacheWrite: 0.3 },
+			})
+			expect(model.inputPrice).toBe(1.5)
+			expect(model.outputPrice).toBe(7.25)
+			expect(model.cacheReadsPrice).toBe(0.1)
+			expect(model.cacheWritesPrice).toBe(0.3)
+		})
+
+		it("preserves zero prices distinctly from missing cache fields", () => {
+			const model = adaptSdkModelInfo({ id: "m", pricing: { input: 0, output: 0 } })
+			expect(model.inputPrice).toBe(0)
+			expect(model.outputPrice).toBe(0)
+			expect(model.cacheReadsPrice).toBeUndefined()
+			expect(model.cacheWritesPrice).toBeUndefined()
+		})
+	})
+
+	describe("safe defaults for sparse input", () => {
+		it("fills documented safe defaults for LiteLLM-like sparse input", () => {
+			const model = adaptSdkModelInfo({ id: "gpt-5.4", name: "GPT-5.4" })
+			expect(model.name).toBe("GPT-5.4")
+			expect(model.contextWindow).toBe(openAiModelInfoSafeDefaults.contextWindow)
+			expect(model.maxTokens).toBe(openAiModelInfoSafeDefaults.maxTokens)
+			expect(model.supportsImages).toBe(openAiModelInfoSafeDefaults.supportsImages)
+			expect(model.supportsPromptCache).toBe(openAiModelInfoSafeDefaults.supportsPromptCache)
+			expect(model.supportsReasoning).toBeUndefined()
+			expect(model.inputPrice).toBe(openAiModelInfoSafeDefaults.inputPrice)
+			expect(model.outputPrice).toBe(openAiModelInfoSafeDefaults.outputPrice)
+			expect(model.cacheReadsPrice).toBeUndefined()
+			expect(model.cacheWritesPrice).toBeUndefined()
+			expect(model.description).toBeUndefined()
+		})
+
+		it("falls back to id when name is omitted and passes through description", () => {
+			const model = adaptSdkModelInfo({ id: "phi4-mini:latest", description: "local model" })
+			expect(model.name).toBe("phi4-mini:latest")
+			expect(model.description).toBe("local model")
+		})
+
+		it("does not invent extension-only metadata", () => {
+			const model = adaptSdkModelInfo({ id: "m", capabilities: ["reasoning"], pricing: { input: 1, output: 2 } })
+			expect(model.thinkingConfig).toBeUndefined()
+			expect(model.apiFormat).toBeUndefined()
+			expect(model.tiers).toBeUndefined()
+			expect(model.temperature).toBeUndefined()
+			expect(model.supportsGlobalEndpoint).toBeUndefined()
+		})
+	})
+
+	it("maps rich SDK input end-to-end and drops unmapped SDK fields", () => {
+		const model = adaptSdkModelInfo({
+			id: "deepseek-v4-flash",
+			name: "DeepSeek V4 Flash",
+			contextWindow: 200_000,
+			maxTokens: 8192,
+			capabilities: ["tools", "reasoning", "structured_output", "temperature", "prompt-cache", "images"],
+			pricing: { input: 0.5, output: 1.5, cacheRead: 0.05, cacheWrite: 0.1 },
+			releaseDate: "2026-04-01",
+			family: "deepseek",
+			status: "ga",
+		})
+
+		expect(model).toMatchObject({
+			name: "DeepSeek V4 Flash",
+			contextWindow: 200_000,
+			maxTokens: 8192,
+			supportsImages: true,
+			supportsPromptCache: true,
+			supportsReasoning: true,
+			inputPrice: 0.5,
+			outputPrice: 1.5,
+			cacheReadsPrice: 0.05,
+			cacheWritesPrice: 0.1,
+		})
+		expect(Object.hasOwn(model, "releaseDate")).toBe(false)
+		expect(Object.hasOwn(model, "family")).toBe(false)
+		expect(Object.hasOwn(model, "status")).toBe(false)
+	})
+
+	it("does not mutate input", () => {
+		const input = {
+			id: "m",
+			name: "M",
+			contextWindow: 32_000,
+			maxTokens: 4096,
+			capabilities: ["tools", "reasoning"],
+			pricing: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 0.2 },
+			description: "desc",
+		}
+		const snapshot = structuredClone(input)
+		adaptSdkModelInfo(input)
+		expect(input).toEqual(snapshot)
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/shape-adapter.ts b/apps/vscode/src/sdk/model-catalog/shape-adapter.ts
new file mode 100644
index 0000000..23b129d
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/shape-adapter.ts
@@ -0,0 +1,225 @@
+/**
+ * Shape adapter: translates SDK-shaped model metadata into the extension's
+ * {@link ModelInfo} shape. This is a boundary translation layer — it does
+ * NOT import any SDK runtime (no `@cline/core` imports). It validates
+ * unknown input and maps documented SDK fields onto `ModelInfo` fields.
+ *
+ * The SDK model-metadata shape this adapter reads from:
+ *
+ * ```ts
+ * {
+ *   id: string,                  // only consistently-required field
+ *   name?: string,
+ *   contextWindow?: number,
+ *   maxTokens?: number,
+ *   capabilities?: string[],     // e.g. ["tools", "reasoning", "prompt-cache", "images"]
+ *   pricing?: { input?, output?, cacheRead?, cacheWrite? },
+ *   description?: string,
+ *   releaseDate?: string,        // not mapped — see "Unmapped SDK fields" below
+ *   family?: string,             // not mapped
+ *   status?: string,             // not mapped
+ * }
+ * ```
+ *
+ * Field mapping (extension <- SDK), with defaults sourced from
+ * `openAiModelInfoSafeDefaults` ("SD"):
+ *
+ * | extension ModelInfo field | source | default if missing |
+ * | --- | --- | --- |
+ * | name | `sdk.name ?? sdk.id` | n/a (id is required) |
+ * | contextWindow | `sdk.contextWindow` if finite number | SD.contextWindow (128_000) |
+ * | maxTokens | `sdk.maxTokens` if finite number | SD.maxTokens (-1) |
+ * | supportsImages | capabilities includes `images` or `vision` | SD.supportsImages (true) when capabilities absent |
+ * | supportsPromptCache | capabilities includes `prompt-cache`; if capabilities absent, use SD | SD.supportsPromptCache (false) |
+ * | supportsReasoning | capabilities includes `reasoning` | omitted (undefined) |
+ * | inputPrice | `sdk.pricing.input` if finite number | SD.inputPrice (0) |
+ * | outputPrice | `sdk.pricing.output` if finite number | SD.outputPrice (0) |
+ * | cacheReadsPrice | `sdk.pricing.cacheRead` if finite number | omitted (undefined) |
+ * | cacheWritesPrice | `sdk.pricing.cacheWrite` if finite number | omitted (undefined) |
+ * | description | `sdk.description` if string | omitted (undefined) |
+ *
+ * Unmapped SDK fields intentionally dropped here: `releaseDate`, `family`,
+ * `status`, and capabilities other than `images`/`vision`/`prompt-cache`/
+ * `reasoning` (for example `tools`, `streaming`, `structured_output`,
+ * `temperature`).
+ *
+ * Extension-only fields not populated by this adapter: `thinkingConfig`,
+ * `tiers`, `temperature`, `apiFormat`, `supportsGlobalEndpoint`, and local
+ * provider loaded-context overrides. Those require host enrichment or upstream
+ * SDK metadata rather than adapter guesses.
+ */
+
+import { type ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+
+/**
+ * Typed error thrown when SDK model-info shape validation fails. The catalog
+ * layer translates this into the public `CatalogError` surface.
+ */
+export class CatalogShapeError extends Error {
+	override readonly cause?: unknown
+	readonly details?: Readonly<Record<string, unknown>>
+
+	constructor(message: string, options?: { cause?: unknown; details?: Record<string, unknown> }) {
+		super(message)
+		this.name = "CatalogShapeError"
+		if (options?.cause !== undefined) {
+			this.cause = options.cause
+		}
+		if (options?.details !== undefined) {
+			this.details = Object.freeze({ ...options.details })
+		}
+	}
+}
+
+const IMAGE_CAPABILITIES = new Set(["images", "vision"])
+const PROMPT_CACHE_CAPABILITY = "prompt-cache"
+const REASONING_CAPABILITY = "reasoning"
+const PRICING_KEYS = ["input", "output", "cacheRead", "cacheWrite"] as const
+
+interface NormalizedPricing {
+	input?: number
+	output?: number
+	cacheRead?: number
+	cacheWrite?: number
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function isFiniteNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value)
+}
+
+function readStringArray(value: unknown): readonly string[] | undefined {
+	if (value === undefined) {
+		return undefined
+	}
+	if (!Array.isArray(value)) {
+		throw new CatalogShapeError("SDK model-info `capabilities` must be an array of strings when present.", {
+			details: { receivedType: typeof value },
+		})
+	}
+	for (const entry of value) {
+		if (typeof entry !== "string") {
+			throw new CatalogShapeError("SDK model-info `capabilities` must contain only strings.", {
+				details: { offendingType: typeof entry },
+			})
+		}
+	}
+	return [...value]
+}
+
+function readPricing(value: unknown): NormalizedPricing | undefined {
+	if (value === undefined) {
+		return undefined
+	}
+	if (!isPlainObject(value)) {
+		throw new CatalogShapeError("SDK model-info `pricing` must be an object when present.", {
+			details: { receivedType: typeof value },
+		})
+	}
+
+	const result: NormalizedPricing = {}
+	for (const key of PRICING_KEYS) {
+		const raw = value[key]
+		if (raw === undefined || raw === null) {
+			continue
+		}
+		if (!isFiniteNumber(raw)) {
+			throw new CatalogShapeError(`SDK model-info \`pricing.${key}\` must be a finite number when present.`, {
+				details: { key, receivedType: typeof raw },
+			})
+		}
+		result[key] = raw
+	}
+	return result
+}
+
+/**
+ * Adapt an SDK model-info shape into the extension's {@link ModelInfo} shape.
+ *
+ * Throws {@link CatalogShapeError} when `input` is not a plain object, when
+ * `id` is missing/non-string/empty, or when present-but-malformed fields
+ * violate the documented SDK shape. The catalog layer translates these into
+ * `CatalogError`.
+ *
+ * Does not mutate `input`.
+ */
+export function adaptSdkModelInfo(input: unknown): ModelInfo {
+	if (!isPlainObject(input)) {
+		throw new CatalogShapeError("SDK model-info must be a non-null object.", {
+			details: { receivedType: input === null ? "null" : typeof input },
+		})
+	}
+
+	const id = input.id
+	if (typeof id !== "string" || id.length === 0) {
+		throw new CatalogShapeError("SDK model-info is missing required non-empty string `id`.", {
+			details: { idType: typeof id },
+		})
+	}
+
+	const rawName = input.name
+	if (rawName !== undefined && typeof rawName !== "string") {
+		throw new CatalogShapeError("SDK model-info `name` must be a string when present.", {
+			details: { receivedType: typeof rawName },
+		})
+	}
+
+	const rawDescription = input.description
+	if (rawDescription !== undefined && typeof rawDescription !== "string") {
+		throw new CatalogShapeError("SDK model-info `description` must be a string when present.", {
+			details: { receivedType: typeof rawDescription },
+		})
+	}
+
+	const rawContextWindow = input.contextWindow
+	if (rawContextWindow !== undefined && !isFiniteNumber(rawContextWindow)) {
+		throw new CatalogShapeError("SDK model-info `contextWindow` must be a finite number when present.", {
+			details: { receivedType: typeof rawContextWindow },
+		})
+	}
+
+	const rawMaxTokens = input.maxTokens
+	if (rawMaxTokens !== undefined && !isFiniteNumber(rawMaxTokens)) {
+		throw new CatalogShapeError("SDK model-info `maxTokens` must be a finite number when present.", {
+			details: { receivedType: typeof rawMaxTokens },
+		})
+	}
+
+	const capabilities = readStringArray(input.capabilities)
+	const pricing = readPricing(input.pricing)
+
+	const result: ModelInfo = {
+		name: rawName ?? id,
+		contextWindow: isFiniteNumber(rawContextWindow) ? rawContextWindow : openAiModelInfoSafeDefaults.contextWindow,
+		maxTokens: isFiniteNumber(rawMaxTokens) ? rawMaxTokens : openAiModelInfoSafeDefaults.maxTokens,
+		supportsPromptCache: capabilities
+			? capabilities.includes(PROMPT_CACHE_CAPABILITY)
+			: openAiModelInfoSafeDefaults.supportsPromptCache,
+		inputPrice: pricing?.input ?? openAiModelInfoSafeDefaults.inputPrice,
+		outputPrice: pricing?.output ?? openAiModelInfoSafeDefaults.outputPrice,
+	}
+
+	if (capabilities) {
+		result.supportsImages = capabilities.some((capability) => IMAGE_CAPABILITIES.has(capability))
+		if (capabilities.includes(REASONING_CAPABILITY)) {
+			result.supportsReasoning = true
+		}
+	} else {
+		result.supportsImages = openAiModelInfoSafeDefaults.supportsImages
+	}
+
+	if (pricing?.cacheRead !== undefined) {
+		result.cacheReadsPrice = pricing.cacheRead
+	}
+	if (pricing?.cacheWrite !== undefined) {
+		result.cacheWritesPrice = pricing.cacheWrite
+	}
+	if (rawDescription !== undefined) {
+		result.description = rawDescription
+	}
+
+	return result
+}
diff --git a/apps/vscode/src/sdk/model-catalog/store.test.ts b/apps/vscode/src/sdk/model-catalog/store.test.ts
new file mode 100644
index 0000000..4f1ed6e
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/store.test.ts
@@ -0,0 +1,449 @@
+import type { ApiConfiguration, ModelInfo } from "@shared/api"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { ProviderConfigChange } from "./contracts"
+import { parseProviderId } from "./provider-id"
+
+const mocks = vi.hoisted(() => {
+	type MockApiConfiguration = ApiConfiguration & { planActSeparateModelsSetting?: boolean }
+	let apiConfiguration: MockApiConfiguration = {}
+	let providerSettingsById: Record<string, Record<string, unknown>> = {}
+	const saveProviderSettings = vi.fn((settings: Record<string, unknown>, _options?: { setLastUsed?: boolean }) => {
+		const provider = settings.provider
+		if (typeof provider !== "string") {
+			throw new Error("provider is required")
+		}
+		providerSettingsById[provider] = { ...settings }
+		return { version: 1, providers: {} }
+	})
+
+	return {
+		reset(): void {
+			apiConfiguration = {}
+			providerSettingsById = {}
+			saveProviderSettings.mockClear()
+		},
+		setApiConfiguration(value: MockApiConfiguration): void {
+			apiConfiguration = { ...value }
+		},
+		setProviderSettings(value: Record<string, Record<string, unknown>>): void {
+			providerSettingsById = { ...value }
+		},
+		getSavedProviderSettings(providerId: string): Record<string, unknown> | undefined {
+			return providerSettingsById[providerId]
+		},
+		getApiConfiguration(): MockApiConfiguration {
+			return { ...apiConfiguration }
+		},
+		getSaveProviderSettingsMock(): typeof saveProviderSettings {
+			return saveProviderSettings
+		},
+		getStateManager() {
+			return {
+				getApiConfiguration: () => ({ ...apiConfiguration }),
+				getGlobalSettingsKey: (key: keyof MockApiConfiguration) => apiConfiguration[key],
+				setSecret: (key: keyof MockApiConfiguration, value: unknown) => {
+					apiConfiguration = { ...apiConfiguration, [key]: value }
+				},
+				setGlobalState: (key: keyof MockApiConfiguration, value: unknown) => {
+					apiConfiguration = { ...apiConfiguration, [key]: value }
+				},
+				setGlobalStateBatch: (updates: MockApiConfiguration) => {
+					apiConfiguration = { ...apiConfiguration, ...updates }
+				},
+			}
+		},
+		getProviderSettingsManager() {
+			return {
+				getProviderSettings: (providerId: string) => providerSettingsById[providerId],
+				saveProviderSettings,
+			}
+		},
+	}
+})
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: { get: mocks.getStateManager },
+}))
+
+vi.mock("../provider-migration", () => ({
+	getProviderSettingsManager: mocks.getProviderSettingsManager,
+}))
+
+const modelInfoA: ModelInfo = {
+	name: "Model A",
+	contextWindow: 128_000,
+	maxTokens: 8_192,
+	supportsPromptCache: true,
+}
+
+const modelInfoB: ModelInfo = {
+	name: "Model B",
+	contextWindow: 64_000,
+	maxTokens: 4_096,
+	supportsPromptCache: false,
+}
+
+describe("createProviderConfigStore", () => {
+	beforeEach(() => {
+		mocks.reset()
+		vi.resetModules()
+	})
+
+	it("round-trips write then read with fresh structurally equal objects", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("deepseek")
+
+		const written = store.write(providerId, { apiKey: "deepseek-key" })
+		const firstRead = store.read(providerId)
+		const secondRead = store.read(providerId)
+
+		expect(written).toEqual({ providerId, apiKey: "deepseek-key" })
+		expect(firstRead).toEqual(written)
+		expect(secondRead).toEqual(firstRead)
+		expect(secondRead).not.toBe(firstRead)
+	})
+
+	it("clears string fields from providers.json when they are written as empty strings", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setProviderSettings({ gemini: { provider: "gemini", apiKey: "existing-key", baseUrl: "https://custom.example" } })
+		mocks.setApiConfiguration({ geminiApiKey: "existing-key", geminiBaseUrl: "https://custom.example" })
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("gemini")
+
+		store.write(providerId, { baseUrl: "" })
+
+		expect(mocks.getSavedProviderSettings("gemini")).toEqual({ provider: "gemini", apiKey: "existing-key" })
+		expect(store.read(providerId).baseUrl).toBeUndefined()
+	})
+
+	it("round-trips commitSelection then readSelection for provider-specific model info", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openrouter")
+		const selection = { providerId, modelId: "anthropic/claude-sonnet-4", modelInfo: modelInfoA }
+
+		store.commitSelection(providerId, "act", selection)
+
+		expect(store.readSelection(providerId, "act")).toEqual(selection)
+	})
+
+	it("round-trips generic provider selections using the in-process modelInfo envelope", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("deepseek")
+		const selection = { providerId, modelId: "deepseek-v4-pro", modelInfo: modelInfoA }
+
+		store.commitSelection(providerId, "act", selection)
+
+		expect(store.readSelection(providerId, "act")).toEqual(selection)
+	})
+
+	it("hydrates a generic provider selection from providers.json after reload", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setProviderSettings({ zai: { provider: "zai", model: "manual-zai-model" } })
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("zai")
+
+		expect(store.readSelection(providerId, "act")).toEqual({
+			providerId,
+			modelId: "manual-zai-model",
+			modelInfo: expect.objectContaining({
+				name: "manual-zai-model",
+				supportsPromptCache: false,
+			}),
+		})
+	})
+
+	it("does not combine a generic provider's remembered model info with another provider's active model id", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const geminiProviderId = parseProviderId("gemini")
+		const deepSeekProviderId = parseProviderId("deepseek")
+		const geminiSelection = { providerId: geminiProviderId, modelId: "gemini-3.1-pro-preview", modelInfo: modelInfoA }
+		const deepSeekSelection = { providerId: deepSeekProviderId, modelId: "deepseek-v4-pro", modelInfo: modelInfoB }
+
+		store.commitSelection(geminiProviderId, "act", geminiSelection)
+		store.commitSelection(deepSeekProviderId, "act", deepSeekSelection)
+
+		expect(store.readSelection(geminiProviderId, "act")).toEqual(geminiSelection)
+		expect(store.readSelection(deepSeekProviderId, "act")).toEqual(deepSeekSelection)
+	})
+
+	it("handles normalized nousResearch provider casing for writes and selections", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("nousResearch")
+		const selection = { providerId, modelId: "nousresearch/hermes-4-70b", modelInfo: modelInfoA }
+
+		const written = store.write(providerId, { apiKey: "nous-key" })
+		store.commitSelection(providerId, "act", selection)
+
+		expect(written).toEqual({ providerId, apiKey: "nous-key" })
+		expect(store.readSelection(providerId, "act")).toEqual(selection)
+		expect(mocks.getSavedProviderSettings("nousResearch")).toMatchObject({
+			provider: "nousResearch",
+			apiKey: "nous-key",
+			model: "nousresearch/hermes-4-70b",
+		})
+	})
+
+	it("reads migrated OpenAI Compatible settings from the SDK provider id", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setProviderSettings({
+			"openai-compatible": {
+				provider: "openai-compatible",
+				apiKey: "migrated-openai-compatible-key",
+				baseUrl: "https://gateway.example.invalid/v1",
+				headers: { "X-Test": "legacy-header" },
+			},
+		})
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openai")
+
+		expect(store.read(providerId)).toEqual({
+			providerId,
+			apiKey: "migrated-openai-compatible-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+			headers: { "X-Test": "legacy-header" },
+		})
+	})
+
+	it("writes OpenAI Compatible settings under the SDK provider id", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openai")
+
+		store.write(providerId, {
+			apiKey: "openai-compatible-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+		})
+
+		expect(mocks.getSavedProviderSettings("openai")).toBeUndefined()
+		expect(mocks.getSavedProviderSettings("openai-compatible")).toMatchObject({
+			provider: "openai-compatible",
+			apiKey: "openai-compatible-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+		})
+	})
+
+	it("preserves migrated OpenAI Compatible settings when committing model selections", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setProviderSettings({
+			"openai-compatible": {
+				provider: "openai-compatible",
+				apiKey: "migrated-openai-compatible-key",
+			},
+		})
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openai")
+		const selection = { providerId, modelId: "gpt-oss-120b", modelInfo: modelInfoA }
+
+		store.commitSelection(providerId, "act", selection)
+
+		expect(mocks.getSavedProviderSettings("openai-compatible")).toMatchObject({
+			provider: "openai-compatible",
+			apiKey: "migrated-openai-compatible-key",
+			model: "gpt-oss-120b",
+		})
+	})
+
+	it("keeps OpenAI Compatible Plan and Act selections independent when separate models are enabled", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setApiConfiguration({ planActSeparateModelsSetting: true })
+		mocks.setProviderSettings({
+			"openai-compatible": {
+				provider: "openai-compatible",
+				apiKey: "migrated-openai-compatible-key",
+			},
+		})
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openai")
+		const planSelection = { providerId, modelId: "plan-openai-model", modelInfo: modelInfoA }
+		const actSelection = { providerId, modelId: "act-openai-model", modelInfo: modelInfoB }
+
+		store.commitSelection(providerId, "plan", planSelection)
+		store.commitSelection(providerId, "act", actSelection)
+
+		expect(store.readSelection(providerId, "plan")).toEqual(planSelection)
+		expect(store.readSelection(providerId, "act")).toEqual(actSelection)
+		expect(mocks.getApiConfiguration()).toMatchObject({
+			planModeOpenAiModelId: "plan-openai-model",
+			planModeOpenAiModelInfo: modelInfoA,
+			actModeOpenAiModelId: "act-openai-model",
+			actModeOpenAiModelInfo: modelInfoB,
+		})
+		expect(mocks.getSavedProviderSettings("openai")).toBeUndefined()
+		expect(mocks.getSavedProviderSettings("openai-compatible")).toMatchObject({
+			provider: "openai-compatible",
+			apiKey: "migrated-openai-compatible-key",
+			model: "act-openai-model",
+		})
+	})
+
+	it("mirrors OpenAI Compatible selections to both modes when separate models are disabled", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setApiConfiguration({ planActSeparateModelsSetting: false })
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openai")
+		const selection = { providerId, modelId: "shared-openai-model", modelInfo: modelInfoA }
+
+		store.commitSelection(providerId, "act", selection)
+
+		expect(store.readSelection(providerId, "plan")).toEqual(selection)
+		expect(store.readSelection(providerId, "act")).toEqual(selection)
+		expect(mocks.getApiConfiguration()).toMatchObject({
+			planModeOpenAiModelId: "shared-openai-model",
+			planModeOpenAiModelInfo: modelInfoA,
+			actModeOpenAiModelId: "shared-openai-model",
+			actModeOpenAiModelInfo: modelInfoA,
+		})
+		expect(mocks.getSavedProviderSettings("openai-compatible")).toMatchObject({
+			provider: "openai-compatible",
+			model: "shared-openai-model",
+		})
+	})
+
+	it("writes Z.AI Coding Plan API keys only to provider-specific settings", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setApiConfiguration({ zaiApiKey: "shared-zai-key" })
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("zai-coding-plan")
+
+		const written = store.write(providerId, { apiKey: "coding-plan-key" })
+
+		expect(written).toEqual({ providerId, apiKey: "coding-plan-key" })
+		expect(mocks.getSavedProviderSettings("zai-coding-plan")).toMatchObject({
+			provider: "zai-coding-plan",
+			apiKey: "coding-plan-key",
+		})
+		expect(mocks.getApiConfiguration().zaiApiKey).toBe("shared-zai-key")
+	})
+
+	it("returns undefined from readSelection when modelId or modelInfo is missing", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openrouter")
+
+		mocks.setApiConfiguration({ actModeOpenRouterModelId: "anthropic/claude-sonnet-4" })
+		expect(store.readSelection(providerId, "act")).toBeUndefined()
+
+		mocks.setApiConfiguration({ actModeOpenRouterModelInfo: modelInfoA })
+		expect(store.readSelection(providerId, "act")).toBeUndefined()
+	})
+
+	it("keeps Plan and Act selections independent and mirrors the latest selection to provider settings", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setApiConfiguration({ planActSeparateModelsSetting: true })
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openrouter")
+		const planSelection = { providerId, modelId: "provider/model-a", modelInfo: modelInfoA }
+		const actSelection = { providerId, modelId: "provider/model-b", modelInfo: modelInfoB }
+
+		store.commitSelection(providerId, "plan", planSelection)
+		store.commitSelection(providerId, "act", actSelection)
+
+		expect(store.readSelection(providerId, "plan")).toEqual(planSelection)
+		expect(store.readSelection(providerId, "act")).toEqual(actSelection)
+		expect(mocks.getSavedProviderSettings("openrouter")).toMatchObject({
+			provider: "openrouter",
+			model: "provider/model-b",
+		})
+		expect(mocks.getSavedProviderSettings("openrouter")).not.toHaveProperty("contextWindow")
+		expect(mocks.getSavedProviderSettings("openrouter")).not.toHaveProperty("maxTokens")
+	})
+
+	it("updates providers.json model with setLastUsed false when planActSeparateModelsSetting=false", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		mocks.setApiConfiguration({ planActSeparateModelsSetting: false })
+		mocks.setProviderSettings({
+			openrouter: { provider: "openrouter", apiKey: "existing-key", contextWindow: 64_000, maxTokens: 4_096 },
+		})
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openrouter")
+		const selection = { providerId, modelId: "provider/model-a", modelInfo: modelInfoA }
+
+		store.commitSelection(providerId, "act", selection)
+
+		expect(mocks.getSavedProviderSettings("openrouter")).toMatchObject({
+			provider: "openrouter",
+			apiKey: "existing-key",
+			model: "provider/model-a",
+		})
+		expect(mocks.getSavedProviderSettings("openrouter")).not.toHaveProperty("contextWindow")
+		expect(mocks.getSavedProviderSettings("openrouter")).not.toHaveProperty("maxTokens")
+		expect(mocks.getSaveProviderSettingsMock()).toHaveBeenCalledWith(expect.objectContaining({ model: "provider/model-a" }), {
+			setLastUsed: false,
+		})
+	})
+
+	it("persists Claude Code model selections to providers.json", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("claude-code")
+		const selection = { providerId, modelId: "haiku", modelInfo: modelInfoA }
+
+		store.commitSelection(providerId, "act", selection)
+
+		expect(mocks.getSavedProviderSettings("claude-code")).toMatchObject({
+			provider: "claude-code",
+			model: "haiku",
+		})
+		expect(mocks.getSavedProviderSettings("claude-code")).not.toHaveProperty("contextWindow")
+		expect(mocks.getSavedProviderSettings("claude-code")).not.toHaveProperty("maxTokens")
+		expect(mocks.getSaveProviderSettingsMock()).toHaveBeenCalledWith(expect.objectContaining({ model: "haiku" }), {
+			setLastUsed: false,
+		})
+	})
+
+	it("subscribers fire synchronously and multiple writes emit events in order", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("deepseek")
+		const events: ProviderConfigChange[] = []
+		let fired = false
+
+		store.subscribe((event) => {
+			fired = true
+			events.push(event)
+		})
+
+		const first = store.write(providerId, { apiKey: "first" })
+		expect(fired).toBe(true)
+		const second = store.write(providerId, { apiKey: "second" })
+
+		expect(events).toEqual([
+			{ kind: "fields", providerId, config: first },
+			{ kind: "fields", providerId, config: second },
+		])
+	})
+
+	it("write emits fields, commitSelection emits selection, and write never emits selection", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("openrouter")
+		const events: ProviderConfigChange[] = []
+		const selection = { providerId, modelId: "provider/model-a", modelInfo: modelInfoA }
+
+		store.subscribe((event) => events.push(event))
+		store.write(providerId, { apiKey: "openrouter-key" })
+		store.commitSelection(providerId, "act", selection)
+
+		expect(events.map((event) => event.kind)).toEqual(["fields", "selection"])
+		expect(events[0]).toMatchObject({ kind: "fields", providerId })
+		expect(events[1]).toEqual({ kind: "selection", providerId, mode: "act", selection })
+	})
+
+	it("dispose unregisters listeners", async () => {
+		const { createProviderConfigStore } = await import("./store")
+		const store = createProviderConfigStore()
+		const providerId = parseProviderId("deepseek")
+		const listener = vi.fn()
+		const disposable = store.subscribe(listener)
+
+		disposable.dispose()
+		store.write(providerId, { apiKey: "deepseek-key" })
+
+		expect(listener).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/src/sdk/model-catalog/store.ts b/apps/vscode/src/sdk/model-catalog/store.ts
new file mode 100644
index 0000000..f874d28
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/store.ts
@@ -0,0 +1,490 @@
+import { getGeneratedModelsForProvider, MODEL_COLLECTIONS_BY_PROVIDER_ID } from "@cline/llms"
+import { type ApiConfiguration, type ApiProvider, type ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+import { getProviderModelIdKey } from "@shared/storage/provider-keys"
+import { isSecretKey, isSettingsKey, type SecretKey, type SettingsKey } from "@shared/storage/state-keys"
+import { StateManager } from "@/core/storage/StateManager"
+import { getProviderSettingsManager } from "../provider-migration"
+import type {
+	Disposable,
+	EffectiveProviderConfig,
+	Mode,
+	ModelSelection,
+	ProviderConfigChange,
+	ProviderConfigChangeListener,
+	ProviderConfigPatch,
+	ProviderConfigStore,
+	ProviderId,
+} from "./contracts"
+import { buildEffectiveProviderConfig } from "./effective-config"
+import { applyHostModelInfoOverrides } from "./host-overrides"
+import { toSdkProviderId } from "./sdk-provider-id"
+import { adaptSdkModelInfo } from "./shape-adapter"
+
+type ProviderSettingsRecord = Record<string, unknown>
+type ProviderSettingsPatchKey = "apiKey" | "baseUrl" | "apiLine" | "headers" | "region" | "auth" | "extras" | "aws" | "gcp"
+
+type ModelInfoKeys = {
+	readonly plan: keyof ApiConfiguration & SettingsKey
+	readonly act: keyof ApiConfiguration & SettingsKey
+}
+
+const providerConfigStateKeys: Record<ProviderSettingsPatchKey, Partial<Record<string, SecretKey | SettingsKey>>> = {
+	apiKey: {
+		anthropic: "apiKey",
+		openrouter: "openRouterApiKey",
+		openai: "openAiApiKey",
+		"openai-native": "openAiNativeApiKey",
+		"openai-codex": "openAiNativeApiKey",
+		bedrock: "awsBedrockApiKey",
+		gemini: "geminiApiKey",
+		deepseek: "deepSeekApiKey",
+		ollama: "ollamaApiKey",
+		requesty: "requestyApiKey",
+		together: "togetherApiKey",
+		fireworks: "fireworksApiKey",
+		qwen: "qwenApiKey",
+		"qwen-code": "qwenApiKey",
+		doubao: "doubaoApiKey",
+		mistral: "mistralApiKey",
+		litellm: "liteLlmApiKey",
+		asksage: "asksageApiKey",
+		xai: "xaiApiKey",
+		moonshot: "moonshotApiKey",
+		zai: "zaiApiKey",
+		huggingface: "huggingFaceApiKey",
+		nebius: "nebiusApiKey",
+		sambanova: "sambanovaApiKey",
+		cerebras: "cerebrasApiKey",
+		groq: "groqApiKey",
+		baseten: "basetenApiKey",
+		"huawei-cloud-maas": "huaweiCloudMaasApiKey",
+		dify: "difyApiKey",
+		minimax: "minimaxApiKey",
+		hicap: "hicapApiKey",
+		aihubmix: "aihubmixApiKey",
+		nousresearch: "nousResearchApiKey",
+		"vercel-ai-gateway": "vercelAiGatewayApiKey",
+		wandb: "wandbApiKey",
+		oca: "ocaApiKey",
+		cline: "clineApiKey",
+	},
+	baseUrl: {
+		anthropic: "anthropicBaseUrl",
+		openai: "openAiBaseUrl",
+		ollama: "ollamaBaseUrl",
+		lmstudio: "lmStudioBaseUrl",
+		gemini: "geminiBaseUrl",
+		requesty: "requestyBaseUrl",
+		asksage: "asksageApiUrl",
+		litellm: "liteLlmBaseUrl",
+		sapaicore: "sapAiCoreBaseUrl",
+		dify: "difyBaseUrl",
+		oca: "ocaBaseUrl",
+		aihubmix: "aihubmixBaseUrl",
+	},
+	apiLine: { qwen: "qwenApiLine", moonshot: "moonshotApiLine", zai: "zaiApiLine", minimax: "minimaxApiLine" },
+	headers: { openai: "openAiHeaders" },
+	region: { bedrock: "awsRegion", vertex: "vertexRegion" },
+	auth: {},
+	extras: {},
+	aws: {},
+	gcp: {},
+}
+
+const modelInfoKeysByProvider: Partial<Record<string, ModelInfoKeys>> = {
+	openrouter: { plan: "planModeOpenRouterModelInfo", act: "actModeOpenRouterModelInfo" },
+	cline: { plan: "planModeClineModelInfo", act: "actModeClineModelInfo" },
+	openai: { plan: "planModeOpenAiModelInfo", act: "actModeOpenAiModelInfo" },
+	litellm: { plan: "planModeLiteLlmModelInfo", act: "actModeLiteLlmModelInfo" },
+	requesty: { plan: "planModeRequestyModelInfo", act: "actModeRequestyModelInfo" },
+	groq: { plan: "planModeGroqModelInfo", act: "actModeGroqModelInfo" },
+	baseten: { plan: "planModeBasetenModelInfo", act: "actModeBasetenModelInfo" },
+	huggingface: { plan: "planModeHuggingFaceModelInfo", act: "actModeHuggingFaceModelInfo" },
+	"huawei-cloud-maas": { plan: "planModeHuaweiCloudMaasModelInfo", act: "actModeHuaweiCloudMaasModelInfo" },
+	oca: { plan: "planModeOcaModelInfo", act: "actModeOcaModelInfo" },
+	aihubmix: { plan: "planModeAihubmixModelInfo", act: "actModeAihubmixModelInfo" },
+	hicap: { plan: "planModeHicapModelInfo", act: "actModeHicapModelInfo" },
+	"vercel-ai-gateway": { plan: "planModeVercelAiGatewayModelInfo", act: "actModeVercelAiGatewayModelInfo" },
+}
+
+// In-memory selection envelope for providers that have a mode-specific model
+// id key but no durable `*ModelInfo` key in the StateManager schema (for
+// example DeepSeek/Gemini/generic SDK-backed providers). Keyed by
+// provider+mode so that switching between providers that share the same
+// `*ModeApiModelId` key does not combine one provider's model id with
+// another provider's model info.
+const selectionMemory = new Map<string, ModelSelection>()
+
+function providerKey(providerId: ProviderId): string {
+	return providerId.toString()
+}
+
+function providerForStorage(providerId: ProviderId): ApiProvider | undefined {
+	const key = providerKey(providerId)
+	if (key === "nousresearch") {
+		return "nousResearch"
+	}
+	return key as ApiProvider
+}
+
+function providerSettingsProviderId(providerId: ProviderId): string {
+	return toSdkProviderId(providerId)
+}
+
+function memoryKey(providerId: ProviderId, mode: Mode): string {
+	return `${providerId}:${mode}`
+}
+
+function modePair<T>(mode: Mode, plan: T, act: T): T {
+	return mode === "plan" ? plan : act
+}
+
+function patchValue<T>(value: T | null | undefined): T | undefined {
+	return value === null ? undefined : value
+}
+
+function patchStringValue(value: string | null | undefined): string | undefined {
+	const patched = patchValue(value)
+	return patched === "" ? undefined : patched
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function isModelInfo(value: unknown): value is ModelInfo {
+	return isRecord(value) && typeof value.supportsPromptCache === "boolean"
+}
+
+function isKnownModelIdForProvider(providerId: ProviderId, modelId: string): boolean {
+	const sdkProviderId = toSdkProviderId(providerId)
+	return Boolean(
+		getGeneratedModelsForProvider(sdkProviderId)[modelId] || MODEL_COLLECTIONS_BY_PROVIDER_ID[sdkProviderId]?.models[modelId],
+	)
+}
+
+function readProviderSettingsModelId(providerId: ProviderId): string | undefined {
+	const model = getProviderSettings(providerId).model
+	return typeof model === "string" && model.trim().length > 0 ? model.trim() : undefined
+}
+
+function fallbackModelInfo(modelId: string): ModelInfo {
+	return { ...openAiModelInfoSafeDefaults, name: modelId }
+}
+
+function readKnownModelInfoForProvider(providerId: ProviderId, modelId: string): ModelInfo | undefined {
+	const sdkProviderId = toSdkProviderId(providerId)
+	const generatedModelInfo = getGeneratedModelsForProvider(sdkProviderId)[modelId]
+	if (isModelInfo(generatedModelInfo)) {
+		return generatedModelInfo
+	}
+	if (generatedModelInfo) {
+		try {
+			return applyHostModelInfoOverrides(providerId, modelId, adaptSdkModelInfo(generatedModelInfo))
+		} catch {
+			return undefined
+		}
+	}
+
+	const collectionModelInfo = MODEL_COLLECTIONS_BY_PROVIDER_ID[sdkProviderId]?.models[modelId]
+	if (isModelInfo(collectionModelInfo)) {
+		return collectionModelInfo
+	}
+	if (collectionModelInfo) {
+		try {
+			return applyHostModelInfoOverrides(providerId, modelId, adaptSdkModelInfo(collectionModelInfo))
+		} catch {
+			return undefined
+		}
+	}
+
+	return undefined
+}
+
+function readSelectionFromProviderSettings(providerId: ProviderId): ModelSelection | undefined {
+	const modelId = readProviderSettingsModelId(providerId)
+	if (!modelId) {
+		return undefined
+	}
+
+	return {
+		providerId,
+		modelId,
+		modelInfo: readKnownModelInfoForProvider(providerId, modelId) ?? fallbackModelInfo(modelId),
+	}
+}
+
+function writeStateKey(key: SecretKey | SettingsKey, value: unknown): void {
+	const stateManager = StateManager.get()
+	if (isSecretKey(key)) {
+		stateManager.setSecret(key, typeof value === "string" ? value : undefined)
+		return
+	}
+	if (isSettingsKey(key)) {
+		stateManager.setGlobalState(key, value as never)
+	}
+}
+
+function writeStateFields(providerId: ProviderId, patch: ProviderConfigPatch): void {
+	const provider = providerKey(providerId)
+	for (const key of ["apiKey", "baseUrl", "apiLine", "headers", "region"] as const) {
+		if (!(key in patch)) {
+			continue
+		}
+		const stateKey = providerConfigStateKeys[key][provider]
+		if (stateKey) {
+			const value = typeof patch[key] === "string" ? patchStringValue(patch[key]) : patchValue(patch[key])
+			writeStateKey(stateKey, value)
+		}
+	}
+
+	if (provider === "vertex" && "gcp" in patch) {
+		const gcp = patch.gcp
+		if (gcp === null || gcp === undefined) {
+			writeStateKey("vertexProjectId", undefined)
+			writeStateKey("vertexRegion", undefined)
+		} else {
+			if ("projectId" in gcp) writeStateKey("vertexProjectId", patchStringValue(gcp.projectId))
+			if ("region" in gcp) writeStateKey("vertexRegion", patchStringValue(gcp.region))
+		}
+	}
+
+	if (provider === "bedrock" && "aws" in patch) {
+		const aws = patch.aws
+		if (aws === null || aws === undefined) {
+			writeStateKey("awsAccessKey", undefined)
+			writeStateKey("awsSecretKey", undefined)
+			writeStateKey("awsSessionToken", undefined)
+			writeStateKey("awsAuthentication", undefined)
+			writeStateKey("awsProfile", undefined)
+			writeStateKey("awsBedrockUsePromptCache", undefined)
+			writeStateKey("awsBedrockEndpoint", undefined)
+		} else {
+			if ("accessKey" in aws) writeStateKey("awsAccessKey", patchStringValue(aws.accessKey))
+			if ("secretKey" in aws) writeStateKey("awsSecretKey", patchStringValue(aws.secretKey))
+			if ("sessionToken" in aws) writeStateKey("awsSessionToken", patchStringValue(aws.sessionToken))
+			if ("authentication" in aws) writeStateKey("awsAuthentication", patchStringValue(aws.authentication))
+			if ("profile" in aws) writeStateKey("awsProfile", patchStringValue(aws.profile))
+			if ("usePromptCache" in aws) writeStateKey("awsBedrockUsePromptCache", aws.usePromptCache)
+			if ("endpoint" in aws) writeStateKey("awsBedrockEndpoint", patchStringValue(aws.endpoint))
+			if ("customModelBaseId" in aws) {
+				const customModelBaseId = patchStringValue(aws.customModelBaseId)
+				writeStateKey("planModeAwsBedrockCustomModelBaseId", customModelBaseId)
+				writeStateKey("actModeAwsBedrockCustomModelBaseId", customModelBaseId)
+			}
+			if ("useCrossRegionInference" in aws) writeStateKey("awsUseCrossRegionInference", aws.useCrossRegionInference)
+			if ("useGlobalInference" in aws) writeStateKey("awsUseGlobalInference", aws.useGlobalInference)
+		}
+	}
+
+	if (provider === "cline" && "auth" in patch) {
+		writeStateKey("clineApiKey", patch.auth?.accessToken)
+		writeStateKey("clineAccountId", patch.auth?.accountId)
+	}
+}
+
+function getProviderSettings(providerId: ProviderId): ProviderSettingsRecord {
+	const settings = getProviderSettingsManager().getProviderSettings(providerSettingsProviderId(providerId))
+	return isRecord(settings) ? settings : {}
+}
+
+function saveProviderSettings(providerId: ProviderId, next: ProviderSettingsRecord): void {
+	const provider = providerSettingsProviderId(providerId)
+	getProviderSettingsManager().saveProviderSettings({ ...next, provider }, { setLastUsed: false })
+}
+
+function writeProviderSettingsFields(providerId: ProviderId, patch: ProviderConfigPatch): void {
+	const existing = getProviderSettings(providerId)
+	const next: ProviderSettingsRecord = { ...existing }
+
+	for (const key of ["apiKey", "baseUrl", "apiLine", "headers", "region", "auth", "extras"] as const) {
+		if (key in patch) {
+			const value = typeof patch[key] === "string" ? patchStringValue(patch[key]) : patchValue(patch[key])
+			if (value === undefined) {
+				delete next[key]
+			} else {
+				next[key] = value
+			}
+		}
+	}
+
+	if ("gcp" in patch) {
+		const gcpPatch = patch.gcp
+		if (gcpPatch === null || gcpPatch === undefined) {
+			delete next.gcp
+		} else {
+			const existingGcp = isRecord(next.gcp) ? next.gcp : {}
+			const nextGcp: ProviderSettingsRecord = { ...existingGcp }
+			for (const [key, value] of Object.entries(gcpPatch)) {
+				if (typeof value === "string" && value.length === 0) {
+					delete nextGcp[key]
+				} else {
+					nextGcp[key] = value
+				}
+			}
+			if (Object.keys(nextGcp).length === 0) {
+				delete next.gcp
+			} else {
+				next.gcp = nextGcp
+			}
+		}
+	}
+
+	if ("aws" in patch) {
+		const awsPatch = patch.aws
+		if (awsPatch === null || awsPatch === undefined) {
+			delete next.aws
+		} else {
+			const existingAws = isRecord(next.aws) ? next.aws : {}
+			const nextAws: ProviderSettingsRecord = { ...existingAws }
+			for (const [key, value] of Object.entries(awsPatch)) {
+				if (typeof value === "string" && value.length === 0) {
+					delete nextAws[key]
+				} else {
+					nextAws[key] = value
+				}
+			}
+			next.aws = nextAws
+		}
+	}
+
+	// Handle reasoning patch separately — maps to ProviderSettings.reasoning
+	if ("reasoning" in patch) {
+		const reasoningPatch = patch.reasoning
+		if (reasoningPatch === null || reasoningPatch === undefined) {
+			delete next.reasoning
+		} else {
+			const existingReasoning = (next as Record<string, unknown>).reasoning as Record<string, unknown> | undefined
+			const merged: Record<string, unknown> = { ...(existingReasoning ?? {}) }
+			if (reasoningPatch.enabled !== undefined) {
+				merged.enabled = reasoningPatch.enabled
+			}
+			if (reasoningPatch.effort !== undefined) {
+				merged.effort = reasoningPatch.effort === "none" ? undefined : reasoningPatch.effort
+				// When effort is "none", disable reasoning
+				if (reasoningPatch.effort === "none") {
+					merged.enabled = false
+				}
+			}
+			if (reasoningPatch.budgetTokens !== undefined) {
+				merged.budgetTokens = reasoningPatch.budgetTokens
+			}
+			;(next as Record<string, unknown>).reasoning = merged
+		}
+	}
+
+	saveProviderSettings(providerId, next)
+}
+
+function getModelIdKey(providerId: ProviderId, mode: Mode): keyof ApiConfiguration & SettingsKey {
+	return getProviderModelIdKey(providerForStorage(providerId) ?? "anthropic", mode) as keyof ApiConfiguration & SettingsKey
+}
+
+function getModelInfoKey(providerId: ProviderId, mode: Mode): (keyof ApiConfiguration & SettingsKey) | undefined {
+	const keys = modelInfoKeysByProvider[providerKey(providerId)]
+	return keys ? modePair(mode, keys.plan, keys.act) : undefined
+}
+
+function syncedModes(mode: Mode): Mode[] {
+	return StateManager.get().getGlobalSettingsKey("planActSeparateModelsSetting") ? [mode] : ["plan", "act"]
+}
+
+function writeSelectionToState(providerId: ProviderId, mode: Mode, selection: ModelSelection): void {
+	const updates: Partial<Record<SettingsKey, unknown>> = {}
+	for (const targetMode of syncedModes(mode)) {
+		updates[getModelIdKey(providerId, targetMode)] = selection.modelId
+		const modelInfoKey = getModelInfoKey(providerId, targetMode)
+		if (modelInfoKey) {
+			updates[modelInfoKey] = selection.modelInfo
+		}
+		selectionMemory.set(memoryKey(providerId, targetMode), { ...selection, providerId })
+	}
+	StateManager.get().setGlobalStateBatch(updates as never)
+}
+
+function writeSelectionToProviderSettings(providerId: ProviderId, selection: ModelSelection): void {
+	const next: ProviderSettingsRecord = { ...getProviderSettings(providerId), model: selection.modelId }
+	// Prune model metadata that earlier builds may have written to providers.json.
+	delete next.contextWindow
+	delete next.maxTokens
+
+	saveProviderSettings(providerId, next)
+}
+
+function readSelectionFromState(providerId: ProviderId, mode: Mode): ModelSelection | undefined {
+	const apiConfiguration = StateManager.get().getApiConfiguration()
+	const modelId = apiConfiguration[getModelIdKey(providerId, mode)]
+	const modelInfoKey = getModelInfoKey(providerId, mode)
+	const rememberedSelection = selectionMemory.get(memoryKey(providerId, mode))
+	const providerSettingsSelection = readSelectionFromProviderSettings(providerId)
+
+	if (modelInfoKey) {
+		const modelInfo = apiConfiguration[modelInfoKey]
+		if (typeof modelId !== "string" || modelId.length === 0 || !isModelInfo(modelInfo)) {
+			return providerSettingsSelection
+		}
+		return { providerId, modelId, modelInfo }
+	}
+
+	const activeProvider = mode === "plan" ? apiConfiguration.planModeApiProvider : apiConfiguration.actModeApiProvider
+	const provider = providerForStorage(providerId)
+	if (activeProvider !== provider) {
+		return rememberedSelection ?? providerSettingsSelection
+	}
+
+	if (typeof modelId !== "string" || modelId.length === 0) {
+		return rememberedSelection ?? providerSettingsSelection
+	}
+
+	if (!isKnownModelIdForProvider(providerId, modelId)) {
+		return rememberedSelection ?? providerSettingsSelection
+	}
+
+	if (!rememberedSelection || rememberedSelection.modelId !== modelId) {
+		return providerSettingsSelection
+	}
+	return rememberedSelection
+}
+
+/**
+ * Create a {@link ProviderConfigStore} backed by StateManager and the SDK
+ * ProviderSettingsManager singleton. Writes update in-memory state before
+ * returning; disk persistence follows the backing stores' existing policies.
+ */
+export function createProviderConfigStore(): ProviderConfigStore {
+	const listeners = new Set<ProviderConfigChangeListener>()
+	const emit = (event: ProviderConfigChange): void => {
+		for (const listener of listeners) {
+			listener(event)
+		}
+	}
+
+	return {
+		read(providerId: ProviderId): EffectiveProviderConfig {
+			return { ...buildEffectiveProviderConfig(providerId) }
+		},
+
+		readSelection(providerId: ProviderId, mode: Mode): ModelSelection | undefined {
+			return readSelectionFromState(providerId, mode)
+		},
+
+		subscribe(listener: ProviderConfigChangeListener): Disposable {
+			listeners.add(listener)
+			return { dispose: () => listeners.delete(listener) }
+		},
+
+		write(providerId: ProviderId, patch: ProviderConfigPatch): EffectiveProviderConfig {
+			writeStateFields(providerId, patch)
+			writeProviderSettingsFields(providerId, patch)
+			const config = this.read(providerId)
+			emit({ kind: "fields", providerId, config })
+			return config
+		},
+
+		commitSelection(providerId: ProviderId, mode: Mode, selection: ModelSelection): void {
+			writeSelectionToState(providerId, mode, selection)
+			writeSelectionToProviderSettings(providerId, selection)
+			emit({ kind: "selection", providerId, mode, selection })
+		},
+	}
+}
diff --git a/apps/vscode/src/sdk/model-catalog/vertex-global-endpoint.ts b/apps/vscode/src/sdk/model-catalog/vertex-global-endpoint.ts
new file mode 100644
index 0000000..304dea3
--- /dev/null
+++ b/apps/vscode/src/sdk/model-catalog/vertex-global-endpoint.ts
@@ -0,0 +1,79 @@
+/**
+ * Vertex global-endpoint allowlist.
+ *
+ * Google Vertex AI's `location: "global"` value routes requests to the
+ * closest backend instead of a fixed region. Only a subset of Vertex
+ * models supports it — picking `location: "global"` with an unsupported
+ * model returns a `model not available in region: global` error at
+ * request time. The settings picker filters its model list when the
+ * user selects `vertexRegion === "global"` so the combination cannot be
+ * chosen in the first place.
+ *
+ * Region is configured separately from the model id (see
+ * `config.options.location` in
+ * `sdk/packages/llms/src/providers/vendors/vertex.ts`), so model ids do
+ * not encode region. They do carry an Anthropic-style version pin
+ * suffix on the Claude family (for example `claude-opus-4-7@default`
+ * for the latest variant and `claude-sonnet-4-5@20250929` for a
+ * specific snapshot). All version pins of a given base model share the
+ * same global-endpoint capability, so the allowlist is keyed by
+ * base-model prefix and matches the bare id as well as any
+ * `${prefix}@...` snapshot variant or `${prefix}:...` legacy
+ * context-window/speed suffix (for example `claude-opus-4-7:1m`).
+ *
+ * The `@cline/llms` SDK does not carry per-model global-endpoint
+ * metadata, so the allowlist lives here. When the SDK adopts a
+ * capability flag for this, the file (and the override in
+ * `host-overrides.ts` that applies it) should be deleted.
+ */
+
+import type { ProviderId } from "./contracts"
+
+/**
+ * Vertex base-model prefixes whose `@suffix` variants all support
+ * `location: "global"`. A model id matches the allowlist when it is
+ * equal to one of these prefixes or starts with `${prefix}@`. Update
+ * when the SDK's Vertex catalog gains new global-endpoint-capable base
+ * models.
+ */
+const VERTEX_GLOBAL_ENDPOINT_BASE_IDS: readonly string[] = [
+	// Claude on Vertex: every variant of these base ids supports global.
+	"claude-3-7-sonnet",
+	"claude-sonnet-4",
+	"claude-sonnet-4-5",
+	"claude-sonnet-4-6",
+	"claude-opus-4",
+	"claude-opus-4-1",
+	"claude-opus-4-5",
+	"claude-opus-4-6",
+	"claude-opus-4-7",
+	"claude-haiku-4-5",
+	// Gemini on Vertex: not in the SDK's Vertex catalog today; listed
+	// here so they are honored when the SDK adds them.
+	"gemini-2.0-flash-001",
+	"gemini-2.0-flash-lite-001",
+	"gemini-2.0-flash-thinking-exp-1219",
+	"gemini-2.0-flash-thinking-exp-01-21",
+	"gemini-2.0-flash-exp",
+	"gemini-2.5-flash",
+	"gemini-2.5-flash-lite-preview-06-17",
+	"gemini-2.5-pro",
+	"gemini-3-flash-preview",
+	"gemini-3-pro-preview",
+	"gemini-3.1-pro-preview",
+	"gemini-3.5-flash",
+]
+
+/**
+ * Returns true when the given Vertex model id is known to work with the
+ * `location: "global"` Vertex region. Returns false for any other
+ * `providerId`; this is a Vertex-only concept.
+ */
+export function vertexModelSupportsGlobalEndpoint(providerId: ProviderId, modelId: string): boolean {
+	if (providerId !== "vertex") {
+		return false
+	}
+	return VERTEX_GLOBAL_ENDPOINT_BASE_IDS.some(
+		(base) => modelId === base || modelId.startsWith(`${base}@`) || modelId.startsWith(`${base}:`),
+	)
+}
diff --git a/apps/vscode/src/sdk/provider-failure-telemetry.test.ts b/apps/vscode/src/sdk/provider-failure-telemetry.test.ts
new file mode 100644
index 0000000..a9631c3
--- /dev/null
+++ b/apps/vscode/src/sdk/provider-failure-telemetry.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest"
+import { ProviderFailureTelemetryTurnGate } from "./provider-failure-telemetry"
+
+describe("ProviderFailureTelemetryTurnGate", () => {
+	it("captures one streaming failure per active turn", () => {
+		const gate = new ProviderFailureTelemetryTurnGate()
+
+		gate.beginTurn()
+
+		expect(gate.shouldCaptureStreamingFailure()).toBe(true)
+		expect(gate.shouldCaptureStreamingFailure()).toBe(false)
+	})
+
+	it("captures again when a new turn starts", () => {
+		const gate = new ProviderFailureTelemetryTurnGate()
+
+		gate.beginTurn()
+		expect(gate.shouldCaptureStreamingFailure()).toBe(true)
+		expect(gate.shouldCaptureStreamingFailure()).toBe(false)
+
+		gate.beginTurn()
+		expect(gate.shouldCaptureStreamingFailure()).toBe(true)
+	})
+
+	it("does not suppress streaming failures when no turn is active", () => {
+		const gate = new ProviderFailureTelemetryTurnGate()
+
+		expect(gate.shouldCaptureStreamingFailure()).toBe(true)
+		expect(gate.shouldCaptureStreamingFailure()).toBe(true)
+	})
+})
diff --git a/apps/vscode/src/sdk/provider-failure-telemetry.ts b/apps/vscode/src/sdk/provider-failure-telemetry.ts
new file mode 100644
index 0000000..04a64a2
--- /dev/null
+++ b/apps/vscode/src/sdk/provider-failure-telemetry.ts
@@ -0,0 +1,48 @@
+export const PROVIDER_FAILURE_ERROR_TYPE = {
+	AUTH: "auth",
+	BALANCE: "balance",
+	SEND_ERROR: "send_error",
+	TASK_INIT: "task_init",
+	SDK_AGENT_ERROR: "sdk_agent_error",
+	SDK_AGENT_DONE_ERROR: "sdk_agent_done_error",
+} as const
+
+export const PROVIDER_FAILURE_PHASE = {
+	PREFLIGHT: "preflight",
+	STREAMING: "streaming",
+} as const
+
+export type ProviderFailureErrorType = (typeof PROVIDER_FAILURE_ERROR_TYPE)[keyof typeof PROVIDER_FAILURE_ERROR_TYPE]
+
+export type ProviderFailurePhase = (typeof PROVIDER_FAILURE_PHASE)[keyof typeof PROVIDER_FAILURE_PHASE]
+
+export type ProviderFailureTelemetry = {
+	sessionId?: string
+	error: unknown
+	providerId?: string
+	modelId?: string
+	errorType: ProviderFailureErrorType
+	failurePhase: ProviderFailurePhase
+}
+
+export class ProviderFailureTelemetryTurnGate {
+	private turnCounter = 0
+	private activeTurnId: number | undefined
+	private streamingFailureCapturedTurnId: number | undefined
+
+	beginTurn(): void {
+		this.turnCounter += 1
+		this.activeTurnId = this.turnCounter
+	}
+
+	shouldCaptureStreamingFailure(): boolean {
+		if (this.activeTurnId === undefined) {
+			return true
+		}
+		if (this.streamingFailureCapturedTurnId === this.activeTurnId) {
+			return false
+		}
+		this.streamingFailureCapturedTurnId = this.activeTurnId
+		return true
+	}
+}
diff --git a/apps/vscode/src/sdk/provider-migration.test.ts b/apps/vscode/src/sdk/provider-migration.test.ts
new file mode 100644
index 0000000..86a26e8
--- /dev/null
+++ b/apps/vscode/src/sdk/provider-migration.test.ts
@@ -0,0 +1,123 @@
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+// The SDK's ProviderSettingsManager is stubbed under vitest (see
+// vitest.config.ts → cline-core-vitest-stub.ts), so these tests cover the
+// adapter's responsibilities only: that `migrateProviders` faithfully maps the
+// manager's state into a ProviderMigrationResult, and that
+// `getProviderSettingsManager` caches per dataDir. The actual legacy
+// (globalState.json/secrets.json) → providers.json migration logic lives in the
+// SDK (`migrateLegacyProviderSettings`) and is covered by the SDK's own tests.
+//
+// Each test gets a fresh tempDir, so the per-dataDir manager cache and the
+// stub's per-dataDir store are naturally isolated between tests.
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { getProviderSettingsManager, migrateProviders } from "./provider-migration"
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+let tempDir: string
+
+beforeEach(() => {
+	tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cline-provider-migration-"))
+})
+
+afterEach(() => {
+	fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+// ---------------------------------------------------------------------------
+// migrateProviders — adapter wrapper over ProviderSettingsManager
+// ---------------------------------------------------------------------------
+
+describe("migrateProviders", () => {
+	it("reports no migration when the store is empty", () => {
+		const result = migrateProviders(tempDir)
+		expect(result.migrated).toBe(false)
+		expect(result.providerCount).toBe(0)
+		expect(result.lastUsedProvider).toBeUndefined()
+	})
+
+	it("reports migrated=true when a provider was tagged tokenSource=migration", () => {
+		// migrateProviders reads through the same dataDir-keyed store the SDK
+		// manager would have written during auto-migration. Seed a migrated
+		// entry to model that outcome.
+		getProviderSettingsManager(tempDir).saveProviderSettings({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "sk-ant-legacy-key",
+			tokenSource: "migration",
+		})
+
+		const result = migrateProviders(tempDir)
+		expect(result.migrated).toBe(true)
+		expect(result.providerCount).toBe(1)
+		expect(result.lastUsedProvider).toBe("anthropic")
+	})
+
+	it("reports migrated=false when providers exist but none came from migration", () => {
+		getProviderSettingsManager(tempDir).saveProviderSettings({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "manual-key",
+			tokenSource: "manual",
+		})
+
+		const result = migrateProviders(tempDir)
+		expect(result.migrated).toBe(false)
+		expect(result.providerCount).toBe(1)
+		expect(result.lastUsedProvider).toBe("anthropic")
+	})
+
+	it("counts every provider in the store", () => {
+		const manager = getProviderSettingsManager(tempDir)
+		manager.saveProviderSettings({ provider: "anthropic", tokenSource: "migration" })
+		manager.saveProviderSettings({ provider: "openrouter", tokenSource: "migration" })
+		manager.saveProviderSettings({ provider: "ollama", tokenSource: "manual" })
+
+		const result = migrateProviders(tempDir)
+		expect(result.providerCount).toBe(3)
+		expect(result.migrated).toBe(true)
+	})
+
+	it("is idempotent — calling twice produces the same result", () => {
+		getProviderSettingsManager(tempDir).saveProviderSettings({
+			provider: "anthropic",
+			tokenSource: "migration",
+		})
+
+		const result1 = migrateProviders(tempDir)
+		const result2 = migrateProviders(tempDir)
+
+		expect(result2.providerCount).toBe(result1.providerCount)
+		expect(result2.lastUsedProvider).toBe(result1.lastUsedProvider)
+		expect(result2.migrated).toBe(result1.migrated)
+	})
+})
+
+// ---------------------------------------------------------------------------
+// getProviderSettingsManager
+// ---------------------------------------------------------------------------
+
+describe("getProviderSettingsManager", () => {
+	it("returns a ProviderSettingsManager instance", () => {
+		const manager = getProviderSettingsManager(tempDir)
+		expect(manager).toBeDefined()
+		expect(typeof manager.read).toBe("function")
+		expect(typeof manager.getProviderSettings).toBe("function")
+	})
+
+	it("reads empty state when no providers exist", () => {
+		const manager = getProviderSettingsManager(tempDir)
+		const state = manager.read()
+		expect(Object.keys(state.providers)).toHaveLength(0)
+	})
+
+	it("returns a cached instance for the same dataDir", () => {
+		const first = getProviderSettingsManager(tempDir)
+		const second = getProviderSettingsManager(tempDir)
+		expect(second).toBe(first)
+	})
+})
diff --git a/apps/vscode/src/sdk/provider-migration.ts b/apps/vscode/src/sdk/provider-migration.ts
new file mode 100644
index 0000000..0e7df99
--- /dev/null
+++ b/apps/vscode/src/sdk/provider-migration.ts
@@ -0,0 +1,112 @@
+// Replaces classic provider credential management (see origin/main)
+//
+// Uses the SDK's ProviderSettingsManager and migrateLegacyProviderSettings
+// to migrate existing on-disk credentials from globalState.json + secrets.json
+// to the SDK's providers.json format.
+//
+// The SDK handles:
+// - Reading globalState.json and secrets.json
+// - Mapping 30+ provider fields to SDK format
+// - Never overwriting existing entries
+// - Tagging migrated entries with tokenSource: "migration"
+// - Auto-migration on ProviderSettingsManager construction
+
+import path from "node:path"
+import { ProviderSettingsManager } from "@cline/core"
+import { Logger } from "@shared/services/Logger"
+import { resolveDataDir } from "./legacy-state-reader"
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Result of the provider migration process */
+export interface ProviderMigrationResult {
+	/** Whether any providers were migrated */
+	migrated: boolean
+	/** Total number of providers after migration */
+	providerCount: number
+	/** The last-used provider ID */
+	lastUsedProvider?: string
+}
+
+// ---------------------------------------------------------------------------
+// Provider migration
+// ---------------------------------------------------------------------------
+
+/**
+ * Run provider migration using the SDK's ProviderSettingsManager.
+ *
+ * The SDK's constructor automatically calls migrateLegacyProviderSettings()
+ * when a dataDir is provided or can be inferred. This function wraps that
+ * process and returns a typed result.
+ *
+ * Migration is idempotent — calling it multiple times is safe because the SDK
+ * never overwrites existing provider entries.
+ *
+ * @param dataDir Override for the Cline data directory. Defaults to
+ *   resolveDataDir() which checks CLINE_DATA_DIR, CLINE_DIR, then ~/.cline/data.
+ * @returns Migration result indicating what happened
+ */
+export function migrateProviders(dataDir?: string): ProviderMigrationResult {
+	const resolvedDataDir = dataDir ?? resolveDataDir()
+
+	try {
+		// ProviderSettingsManager auto-migrates on construction when dataDir
+		// is provided or can be inferred from the filePath.
+		// The migration reads globalState.json + secrets.json and writes
+		// providers.json, never overwriting existing entries.
+		// We must set filePath explicitly so the manager reads/writes within
+		// the correct dataDir, not the default ~/.cline/data.
+		const filePath = path.join(resolvedDataDir, "settings", "providers.json")
+		const manager = new ProviderSettingsManager({ filePath, dataDir: resolvedDataDir })
+
+		const state = manager.read()
+		const lastUsed = manager.getLastUsedProviderSettings()
+
+		const result: ProviderMigrationResult = {
+			migrated: Object.values(state.providers).some((p) => p.tokenSource === "migration"),
+			providerCount: Object.keys(state.providers).length,
+			lastUsedProvider: state.lastUsedProvider ?? lastUsed?.provider,
+		}
+
+		Logger.log(
+			`[ProviderMigration] Migration complete: ${result.providerCount} providers, lastUsed=${result.lastUsedProvider ?? "none"}, migrated=${result.migrated}`,
+		)
+
+		return result
+	} catch (error) {
+		Logger.error("[ProviderMigration] Failed to migrate providers:", error)
+		return {
+			migrated: false,
+			providerCount: 0,
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Provider settings access (cached singleton)
+// ---------------------------------------------------------------------------
+
+let _cachedManager: ProviderSettingsManager | null = null
+let _cachedDataDir: string | null = null
+
+/**
+ * Get the ProviderSettingsManager singleton for the given data directory.
+ *
+ * Construction triggers auto-migration if needed, so this is the primary
+ * way to access provider settings throughout the SDK adapter layer.
+ *
+ * The instance is cached so all callers share the same in-memory state.
+ * Pass a different dataDir to force a new instance (e.g. in tests).
+ */
+export function getProviderSettingsManager(dataDir?: string): ProviderSettingsManager {
+	const resolvedDataDir = dataDir ?? resolveDataDir()
+	if (_cachedManager && _cachedDataDir === resolvedDataDir) {
+		return _cachedManager
+	}
+	const filePath = path.join(resolvedDataDir, "settings", "providers.json")
+	_cachedManager = new ProviderSettingsManager({ filePath, dataDir: resolvedDataDir })
+	_cachedDataDir = resolvedDataDir
+	return _cachedManager
+}
diff --git a/apps/vscode/src/sdk/sap-config.ts b/apps/vscode/src/sdk/sap-config.ts
new file mode 100644
index 0000000..890fab6
--- /dev/null
+++ b/apps/vscode/src/sdk/sap-config.ts
@@ -0,0 +1,50 @@
+// Maps the extension's legacy SAP AI Core ApiConfiguration onto the SDK's
+// structured SAP provider options (baseUrl + sap block).
+//
+// buildSessionConfig() uses this to hand the SDK runtime the same structured
+// SAP fields that the legacy UI stores in ApiConfiguration.
+
+import type { ProviderSettings } from "@cline/core"
+import type { ApiConfiguration } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+
+export type SapProviderConfig = Pick<ProviderSettings, "baseUrl" | "sap">
+
+function trimString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined
+	}
+
+	return value.trim()
+}
+
+export function buildSapProviderConfig(config: ApiConfiguration, mode: Mode): SapProviderConfig {
+	const sap: NonNullable<SapProviderConfig["sap"]> = {}
+	const baseUrl = trimString(config.sapAiCoreBaseUrl)
+	const useOrchestrationMode = config.sapAiCoreUseOrchestrationMode ?? true
+	const deploymentId = useOrchestrationMode
+		? undefined
+		: trimString(mode === "plan" ? config.planModeSapAiCoreDeploymentId : config.actModeSapAiCoreDeploymentId)
+	const sapFields = {
+		clientId: trimString(config.sapAiCoreClientId),
+		clientSecret: trimString(config.sapAiCoreClientSecret),
+		tokenUrl: trimString(config.sapAiCoreTokenUrl),
+		resourceGroup: trimString(config.sapAiResourceGroup),
+		deploymentId,
+	}
+
+	for (const [key, value] of Object.entries(sapFields)) {
+		if (value !== undefined) {
+			sap[key as keyof typeof sapFields] = value
+		}
+	}
+
+	if (Object.keys(sap).length > 0) {
+		sap.useOrchestrationMode = useOrchestrationMode
+	}
+
+	return {
+		...(baseUrl !== undefined ? { baseUrl } : {}),
+		...(Object.keys(sap).length > 0 ? { sap } : {}),
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-api-handler.test.ts b/apps/vscode/src/sdk/sdk-api-handler.test.ts
new file mode 100644
index 0000000..7570620
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-api-handler.test.ts
@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { buildSdkProviderConfig } from "./sdk-api-handler"
+
+const mocks = vi.hoisted(() => {
+	const providerSettingsManager = {
+		getProviderSettings: vi.fn(),
+	}
+	return {
+		getProviderSettingsManager: vi.fn(() => providerSettingsManager),
+		providerSettingsManager,
+	}
+})
+
+vi.mock("./provider-migration", () => ({
+	getProviderSettingsManager: mocks.getProviderSettingsManager,
+}))
+
+vi.mock("@shared/services/Logger", () => ({
+	Logger: {
+		warn: vi.fn(),
+	},
+}))
+
+describe("buildSdkProviderConfig", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("uses shared Cline OAuth credentials for ClinePass direct handlers", () => {
+		mocks.providerSettingsManager.getProviderSettings.mockImplementation((providerId: string) => {
+			if (providerId !== "cline") {
+				return undefined
+			}
+			return {
+				provider: "cline",
+				auth: {
+					accessToken: "workos:shared-cline-token",
+					refreshToken: "refresh-token",
+				},
+			}
+		})
+
+		const providerConfig = buildSdkProviderConfig(
+			{
+				actModeApiProvider: "cline-pass",
+				actModeClinePassModelId: "cline-pass/glm-5.2",
+			},
+			"act",
+		)
+
+		expect(providerConfig).toMatchObject({
+			providerId: "cline-pass",
+			modelId: "cline-pass/glm-5.2",
+			apiKey: "workos:shared-cline-token",
+		})
+		expect(mocks.providerSettingsManager.getProviderSettings).toHaveBeenCalledWith("cline")
+	})
+
+	it("uses provider-specific settings for SDK-backed direct handlers", () => {
+		mocks.providerSettingsManager.getProviderSettings.mockImplementation((providerId: string) => {
+			if (providerId !== "v0") {
+				return undefined
+			}
+			return {
+				provider: "v0",
+				apiKey: "v0-key",
+			}
+		})
+
+		const providerConfig = buildSdkProviderConfig(
+			{
+				actModeApiProvider: "v0",
+				actModeApiModelId: "v0-1.5-md",
+			},
+			"act",
+		)
+
+		expect(providerConfig).toMatchObject({
+			providerId: "v0",
+			modelId: "v0-1.5-md",
+			apiKey: "v0-key",
+		})
+		expect(mocks.providerSettingsManager.getProviderSettings).toHaveBeenCalledWith("v0")
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-api-handler.ts b/apps/vscode/src/sdk/sdk-api-handler.ts
new file mode 100644
index 0000000..5a30a92
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-api-handler.ts
@@ -0,0 +1,111 @@
+// Replaces classic src/core/api buildApiHandler (see origin/main).
+//
+// Builds an SDK ApiHandler (from `@cline/llms`) directly from the extension's
+// legacy ApiConfiguration. This is the single inference path: the main task
+// loop runs through ClineCore (see cline-session-factory.ts), and standalone
+// utility callers (commit message generation) use the handler
+// returned here. Both share the same provider/model/key/baseUrl resolution so
+// there is no second source of truth.
+
+import { type ApiHandler, createHandler, type ProviderConfig } from "@cline/llms"
+import type { ApiConfiguration } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import { fetch } from "@/shared/net"
+import { buildBedrockProviderConfig } from "./bedrock-config"
+import { resolveApiKey, resolveBaseUrl, resolveModelId, resolveVertexProviderConfig } from "./cline-session-factory"
+import { toSdkProviderId } from "./model-catalog/sdk-provider-id"
+
+export interface BuildApiHandlerOptions {
+	/**
+	 * Disable extended thinking/reasoning for this handler. Standalone utility
+	 * calls (commit message generation) want fast, cheap,
+	 * deterministic completions and don't benefit from reasoning. When true we
+	 * send `thinking: false` and omit both effort and budget so providers like
+	 * OpenRouter don't receive a reasoning config at all.
+	 */
+	disableReasoning?: boolean
+}
+
+/**
+ * Build an SDK `ProviderConfig` from the extension's `ApiConfiguration` for the
+ * given mode (plan/act).
+ *
+ * Reuses the same resolvers the session factory uses to map the legacy config
+ * onto provider id, model id, API key, and base URL, then converts the provider
+ * id to the SDK's spelling (e.g. `openai` → `openai-compatible`).
+ *
+ * Reasoning handling: the SDK gateway forwards `reasoningEffort` as
+ * `reasoning.effort` and `thinkingBudgetTokens` as `reasoning.max_tokens`.
+ * Several providers (e.g. OpenRouter/Anthropic) reject a request that carries
+ * BOTH. We therefore send at most one — preferring an explicit thinking budget
+ * over effort — or none when reasoning is disabled.
+ */
+export function buildSdkProviderConfig(
+	configuration: ApiConfiguration,
+	mode: Mode,
+	options?: BuildApiHandlerOptions,
+): ProviderConfig {
+	const providerId = (mode === "plan" ? configuration.planModeApiProvider : configuration.actModeApiProvider) ?? "cline"
+
+	const apiKey = resolveApiKey(providerId, configuration)
+	const modelId = resolveModelId(providerId, mode, configuration)
+	const baseUrl = resolveBaseUrl(providerId, configuration)
+
+	const thinkingBudgetTokens =
+		mode === "plan" ? configuration.planModeThinkingBudgetTokens : configuration.actModeThinkingBudgetTokens
+	const reasoningEffort = mode === "plan" ? configuration.planModeReasoningEffort : configuration.actModeReasoningEffort
+
+	const vertexProviderConfig = providerId === "vertex" ? resolveVertexProviderConfig(configuration) : undefined
+
+	const base: ProviderConfig = {
+		providerId: toSdkProviderId(providerId),
+		modelId: modelId ?? "",
+		apiKey: apiKey ?? "",
+		baseUrl,
+		...(vertexProviderConfig ?? {}),
+		// Use the proxy-aware fetch so gateway providers respect corporate proxy
+		// configuration (see .clinerules/network.md).
+		fetch,
+		onRetryAttempt: configuration.onRetryAttempt,
+		// Bedrock needs its region + structured AWS auth options forwarded to the
+		// SDK gateway. Without these, a pasted Bedrock API key / region is dropped.
+		...(providerId === "bedrock" ? buildBedrockProviderConfig(configuration, mode) : {}),
+	}
+
+	if (options?.disableReasoning) {
+		// Explicitly turn reasoning off; do not send effort or budget.
+		return { ...base, thinking: false }
+	}
+
+	// Send at most one of budget/effort to avoid the "Only one of
+	// reasoning.effort and reasoning.max_tokens can be specified" error.
+	if (thinkingBudgetTokens && thinkingBudgetTokens > 0) {
+		return { ...base, thinkingBudgetTokens }
+	}
+	if (reasoningEffort === "low" || reasoningEffort === "medium" || reasoningEffort === "high") {
+		return { ...base, reasoningEffort }
+	}
+	return base
+}
+
+/**
+ * Build an SDK-backed `ApiHandler` from the extension's `ApiConfiguration`.
+ *
+ * This is the SDK replacement for the legacy per-provider handler factory. The
+ * returned handler implements the same `createMessage`/`getModel` surface, so
+ * existing callers continue to work unchanged.
+ */
+export function buildApiHandler(configuration: ApiConfiguration, mode: Mode, options?: BuildApiHandlerOptions): ApiHandler {
+	const providerConfig = buildSdkProviderConfig(configuration, mode, options)
+	const handler = createHandler(providerConfig)
+	const getModel = handler.getModel.bind(handler)
+
+	handler.getModel = () => {
+		return {
+			...getModel(),
+			providerId: providerConfig.providerId,
+		}
+	}
+
+	return handler
+}
diff --git a/apps/vscode/src/sdk/sdk-checkpoints.test.ts b/apps/vscode/src/sdk/sdk-checkpoints.test.ts
new file mode 100644
index 0000000..0e21d26
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-checkpoints.test.ts
@@ -0,0 +1,100 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { describe, expect, it } from "vitest"
+import {
+	findVisibleCheckpointUserMessageByRun,
+	getCheckpointRunCountForMessage,
+	isCheckpointAnswerMessage,
+	isVisibleCheckpointUserMessage,
+} from "./sdk-checkpoints"
+
+const userTask = (text: string, ts: number): ClineMessage => ({
+	ts,
+	type: "say",
+	say: "task",
+	text,
+	partial: false,
+})
+
+const userFeedback = (text: string, ts: number): ClineMessage => ({
+	ts,
+	type: "say",
+	say: "user_feedback",
+	text,
+	partial: false,
+})
+
+const assistant = (text: string, ts: number): ClineMessage => ({
+	ts,
+	type: "say",
+	say: "text",
+	text,
+	partial: false,
+})
+
+const followupAsk = (text: string, ts: number): ClineMessage => ({
+	ts,
+	type: "ask",
+	ask: "followup",
+	text,
+	partial: false,
+})
+
+const checkpointRow = (runCount: number, ts: number, ref = "old-ref"): ClineMessage => ({
+	ts,
+	type: "say",
+	say: "checkpoint_created",
+	partial: false,
+	conversationHistoryIndex: runCount,
+	lastCheckpointHash: ref,
+})
+
+describe("SDK checkpoint user-run mapping", () => {
+	it("recognizes only visible user messages", () => {
+		expect(isVisibleCheckpointUserMessage(userTask("start", 1))).toBe(true)
+		expect(isVisibleCheckpointUserMessage(userFeedback("continue", 2))).toBe(true)
+		expect(isVisibleCheckpointUserMessage(assistant("done", 3))).toBe(false)
+		expect(isVisibleCheckpointUserMessage(checkpointRow(1, 4))).toBe(false)
+	})
+
+	it("finds visible user messages by checkpoint run count", () => {
+		const messages = [userTask("start", 1), checkpointRow(1, 2), assistant("done", 3), userFeedback("next", 4)]
+
+		expect(findVisibleCheckpointUserMessageByRun(messages, 1)?.message.text).toBe("start")
+		expect(findVisibleCheckpointUserMessageByRun(messages, 2)?.message.text).toBe("next")
+		expect(findVisibleCheckpointUserMessageByRun(messages, 3)).toBeUndefined()
+	})
+
+	it("does not count ask_question answers as checkpoint runs", () => {
+		const messages = [
+			userTask("start", 1),
+			checkpointRow(1, 2),
+			followupAsk("which file?", 3),
+			userFeedback("src/index.ts", 4),
+			assistant("ok", 5),
+			userFeedback("next task", 6),
+		]
+
+		expect(isCheckpointAnswerMessage(messages, 3)).toBe(true)
+		expect(getCheckpointRunCountForMessage(messages, 0)).toBe(1)
+		expect(getCheckpointRunCountForMessage(messages, 3)).toBeUndefined()
+		expect(getCheckpointRunCountForMessage(messages, 5)).toBe(2)
+		expect(findVisibleCheckpointUserMessageByRun(messages, 2)?.message.text).toBe("next task")
+	})
+
+	it("keeps ask answers tied to the ask when assistant rows arrive between them", () => {
+		const messages = [
+			userTask("start", 1),
+			followupAsk("which file?", 2),
+			assistant("Let me know the file path.", 3),
+			checkpointRow(1, 4),
+			userFeedback("src/index.ts", 5),
+			userFeedback("next task", 6),
+		]
+
+		expect(isCheckpointAnswerMessage(messages, 4)).toBe(true)
+		expect(getCheckpointRunCountForMessage(messages, 4)).toBeUndefined()
+		expect(getCheckpointRunCountForMessage(messages, 5)).toBe(2)
+		expect(findVisibleCheckpointUserMessageByRun(messages, 1)?.message.text).toBe("start")
+		expect(findVisibleCheckpointUserMessageByRun(messages, 2)?.message.text).toBe("next task")
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-checkpoints.ts b/apps/vscode/src/sdk/sdk-checkpoints.ts
new file mode 100644
index 0000000..e5dd9b6
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-checkpoints.ts
@@ -0,0 +1,63 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+
+export function isVisibleCheckpointUserMessage(message: ClineMessage): boolean {
+	return message.type === "say" && (message.say === "task" || message.say === "user_feedback")
+}
+
+export function isCheckpointAnswerMessage(messages: ClineMessage[], index: number): boolean {
+	const message = messages[index]
+	if (message?.type !== "say" || message.say !== "user_feedback") {
+		return false
+	}
+
+	for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+		const previous = messages[cursor]
+		if (previous.say === "checkpoint_created") {
+			continue
+		}
+		if (previous.type === "ask") {
+			return previous.ask === "followup" || previous.ask === "mistake_limit_reached"
+		}
+		if (isVisibleCheckpointUserMessage(previous)) {
+			return false
+		}
+	}
+
+	return false
+}
+
+export function isCheckpointRunUserMessage(messages: ClineMessage[], index: number): boolean {
+	return isVisibleCheckpointUserMessage(messages[index]) && !isCheckpointAnswerMessage(messages, index)
+}
+
+export function getCheckpointRunCountForMessage(messages: ClineMessage[], targetIndex: number): number | undefined {
+	if (!isCheckpointRunUserMessage(messages, targetIndex)) {
+		return undefined
+	}
+
+	let runCount = 0
+	for (let index = 0; index <= targetIndex; index += 1) {
+		if (isCheckpointRunUserMessage(messages, index)) {
+			runCount += 1
+		}
+	}
+	return runCount
+}
+
+export function findVisibleCheckpointUserMessageByRun(
+	messages: ClineMessage[],
+	runCount: number,
+): { message: ClineMessage; index: number } | undefined {
+	let seenUsers = 0
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index]
+		if (!isCheckpointRunUserMessage(messages, index)) {
+			continue
+		}
+		seenUsers += 1
+		if (seenUsers === runCount) {
+			return { message, index }
+		}
+	}
+	return undefined
+}
diff --git a/apps/vscode/src/sdk/sdk-compaction-coordinator.test.ts b/apps/vscode/src/sdk/sdk-compaction-coordinator.test.ts
new file mode 100644
index 0000000..fa1970f
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-compaction-coordinator.test.ts
@@ -0,0 +1,245 @@
+import { createContextCompactionPrepareTurn } from "@cline/core"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { StateManager } from "@/core/storage/StateManager"
+import { SdkCompactionCoordinator, type SdkCompactionCoordinatorOptions } from "./sdk-compaction-coordinator"
+
+vi.mock("@cline/core", () => ({
+	createContextCompactionPrepareTurn: vi.fn(),
+	createSessionCompactionState: vi.fn((input: { compactedMessages: unknown[] }) => ({
+		version: 1,
+		messages: input.compactedMessages,
+	})),
+}))
+
+const mockCreateContextCompactionPrepareTurn = createContextCompactionPrepareTurn as unknown as ReturnType<typeof vi.fn>
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		debug: vi.fn(),
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("SdkCompactionCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("emits an info message and does not rebuild when there is no active session", async () => {
+		const { coordinator, options } = makeCoordinator({ activeSession: undefined })
+
+		await coordinator.compactTask()
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(mockCreateContextCompactionPrepareTurn).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: "There is no active task to compact." })],
+			expect.anything(),
+		)
+	})
+
+	it("refuses to compact while a turn is running", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.compactTask()
+
+		expect(mockCreateContextCompactionPrepareTurn).not.toHaveBeenCalled()
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: expect.stringContaining("Cannot compact while a response") })],
+			expect.anything(),
+		)
+	})
+
+	it("reports when there are no messages to compact", async () => {
+		const activeSession = makeActiveSession()
+		activeSession.sdkHost.readMessages.mockResolvedValueOnce([])
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.compactTask()
+
+		expect(mockCreateContextCompactionPrepareTurn).not.toHaveBeenCalled()
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: "No messages to compact." })],
+			expect.anything(),
+		)
+	})
+
+	it("reports unsupported runtime without running compaction", async () => {
+		const activeSession = makeActiveSession()
+		;(activeSession.sdkHost as Partial<typeof activeSession.sdkHost>).updateSessionCompactionState = undefined
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.compactTask()
+
+		expect(activeSession.sdkHost.readMessages).not.toHaveBeenCalled()
+		expect(mockCreateContextCompactionPrepareTurn).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: expect.stringContaining("not supported") })],
+			expect.anything(),
+		)
+	})
+
+	it("reports when the strategy declines to compact", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		mockCreateContextCompactionPrepareTurn.mockReturnValueOnce(vi.fn().mockResolvedValue(undefined))
+
+		await coordinator.compactTask()
+
+		expect(mockCreateContextCompactionPrepareTurn).toHaveBeenCalledOnce()
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: "No compaction needed." })],
+			expect.anything(),
+		)
+	})
+
+	it("compacts and persists the sidecar without rebuilding the session", async () => {
+		const activeSession = makeActiveSession()
+		activeSession.sdkHost.readMessages.mockResolvedValueOnce([
+			{ role: "user", content: "1" },
+			{ role: "assistant", content: "2" },
+			{ role: "user", content: "3" },
+		])
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		mockCreateContextCompactionPrepareTurn.mockReturnValueOnce(
+			vi.fn().mockResolvedValue({ messages: [{ role: "user", content: "summary" }] }),
+		)
+
+		await coordinator.compactTask()
+
+		expect(activeSession.sdkHost.updateSessionCompactionState).toHaveBeenCalledWith("old-session", {
+			version: 1,
+			messages: [{ role: "user", content: "summary" }],
+		})
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: "Compacted 3 messages to 1." })],
+			expect.anything(),
+		)
+	})
+
+	it("does not append compaction status to a different active session", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		options.sessions.getActiveSession
+			.mockReturnValueOnce(activeSession)
+			.mockReturnValueOnce(makeActiveSession({ sessionId: "other-session" }))
+		mockCreateContextCompactionPrepareTurn.mockReturnValueOnce(
+			vi.fn().mockResolvedValue({ messages: [{ role: "user", content: "summary" }] }),
+		)
+
+		await coordinator.compactTask()
+
+		expect(activeSession.sdkHost.updateSessionCompactionState).toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+	})
+
+	it("does not restart or report success when sidecar persistence fails", async () => {
+		const activeSession = makeActiveSession()
+		activeSession.sdkHost.updateSessionCompactionState.mockResolvedValueOnce({ updated: false })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		mockCreateContextCompactionPrepareTurn.mockReturnValueOnce(
+			vi.fn().mockResolvedValue({ messages: [{ role: "user", content: "summary" }] }),
+		)
+
+		await coordinator.compactTask()
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: "Couldn't compact the conversation. Please try again." })],
+			expect.anything(),
+		)
+	})
+
+	it("reports a failure when compaction throws", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		mockCreateContextCompactionPrepareTurn.mockReturnValueOnce(vi.fn().mockRejectedValue(new Error("boom")))
+
+		await coordinator.compactTask()
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "info", text: "Couldn't compact the conversation. Please try again." })],
+			expect.anything(),
+		)
+	})
+})
+
+interface MakeCoordinatorInput {
+	activeSession: ReturnType<typeof makeActiveSession> | undefined
+}
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const activeSession = "activeSession" in input ? input.activeSession : makeActiveSession()
+	const config = {
+		providerConfig: { providerId: "anthropic", modelId: "claude" },
+		providerId: "anthropic",
+		modelId: "claude",
+		knownModels: undefined,
+		compaction: undefined,
+		logger: undefined,
+		telemetry: undefined,
+		sessionId: undefined as string | undefined,
+	}
+	const options = {
+		stateManager: {
+			getGlobalSettingsKey: vi.fn(() => "act"),
+		} as unknown as StateManager,
+		sessions: {
+			getActiveSession: vi.fn(() => activeSession),
+			replaceActiveSession: vi.fn().mockResolvedValue({
+				startResult: { sessionId: "new-session" },
+				sdkHost: { send: vi.fn() },
+			}),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+		},
+		sessionConfigBuilder: {
+			build: vi.fn().mockResolvedValue(config),
+		},
+		getWorkspaceRoot: vi.fn().mockResolvedValue("/workspace"),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+	} as unknown as SdkCompactionCoordinatorOptions & {
+		sessions: SdkCompactionCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			replaceActiveSession: ReturnType<typeof vi.fn>
+		}
+		messages: SdkCompactionCoordinatorOptions["messages"] & {
+			appendAndEmit: ReturnType<typeof vi.fn>
+		}
+		sessionConfigBuilder: SdkCompactionCoordinatorOptions["sessionConfigBuilder"] & {
+			build: ReturnType<typeof vi.fn>
+		}
+		postStateToWebview: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkCompactionCoordinator(options),
+		options,
+	}
+}
+
+function makeActiveSession(input: { isRunning?: boolean; sessionId?: string } = {}) {
+	return {
+		sessionId: input.sessionId ?? "old-session",
+		sdkHost: {
+			readMessages: vi.fn().mockResolvedValue([{ role: "user", content: "1" }]),
+			updateSessionCompactionState: vi.fn().mockResolvedValue({ updated: true }),
+			send: vi.fn(),
+			abort: vi.fn().mockResolvedValue(undefined),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		},
+		unsubscribe: vi.fn(),
+		startResult: { sessionId: "old-session" },
+		isRunning: input.isRunning ?? false,
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-compaction-coordinator.ts b/apps/vscode/src/sdk/sdk-compaction-coordinator.ts
new file mode 100644
index 0000000..ec849cc
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-compaction-coordinator.ts
@@ -0,0 +1,170 @@
+// Replaces classic manual-condense handling from src/core/task (see origin/main)
+//
+// Coordinates a manual "/compact" (alias "/smol") request triggered from the
+// VSCode compact button or slash command. This mirrors the CLI's
+// `compactCurrentSession` (apps/cli/src/runtime/interactive/session-runtime.ts):
+//
+//   1. Read the active session's transcript.
+//   2. Run a manual SDK compaction over it (sdk-compaction.ts).
+//   3. Persist the SDK compaction sidecar so the next turn and resumes keep
+//      using the compacted working context.
+//
+// Before this, the VSCode button sent the literal text "/compact" to the model,
+// which the SDK does not treat as a runtime command, so the model improvised a
+// fake "Conversation Summary" instead of compacting (CLINE-2503).
+
+import type { Message as SdkMessage } from "@cline/llms"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+import type { StateManager } from "@/core/storage/StateManager"
+import { Logger } from "@/shared/services/Logger"
+import { compactSessionMessages } from "./sdk-compaction"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { SdkSessionHost } from "./session-host"
+
+const COMPACTION_FAILURE_MESSAGE = "Couldn't compact the conversation. Please try again."
+const COMPACTION_UNSUPPORTED_MESSAGE = "Compaction is not supported by this runtime yet. Please update Cline and try again."
+
+export interface SdkCompactionCoordinatorOptions {
+	stateManager: StateManager
+	sessions: SdkSessionLifecycle
+	messages: SdkMessageCoordinator
+	sessionConfigBuilder: SdkSessionConfigBuilder
+	getWorkspaceRoot: () => Promise<string>
+	postStateToWebview: () => Promise<void>
+}
+
+export class SdkCompactionCoordinator {
+	private compactInFlight = false
+
+	constructor(private readonly options: SdkCompactionCoordinatorOptions) {}
+
+	/**
+	 * Compact the active session's conversation. Mirrors the CLI's `/compact`
+	 * (alias `/smol`) local command. No-ops with a status message when there is
+	 * no active session or nothing to compact.
+	 */
+	async compactTask(): Promise<void> {
+		if (this.compactInFlight) {
+			Logger.warn("[SdkController] compactTask: a compaction is already in progress; ignoring")
+			return
+		}
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			Logger.warn("[SdkController] compactTask: No active session to compact")
+			this.emitInfo("There is no active task to compact.")
+			await this.options.postStateToWebview()
+			return
+		}
+
+		// A turn is still running; compacting mid-turn would race the live agent
+		// loop's own message persistence. Ask the user to wait until it finishes.
+		if (activeSession.isRunning) {
+			this.emitInfo(
+				"Cannot compact while a response is in progress. Try again once the current turn finishes.",
+				activeSession.sessionId,
+			)
+			await this.options.postStateToWebview()
+			return
+		}
+
+		this.compactInFlight = true
+		try {
+			await this.runCompaction(activeSession.sdkHost, activeSession.sessionId)
+		} catch (error) {
+			Logger.error("[SdkController] compactTask failed:", error)
+			this.emitInfo(COMPACTION_FAILURE_MESSAGE, activeSession.sessionId)
+			await this.options.postStateToWebview()
+		} finally {
+			this.compactInFlight = false
+		}
+	}
+
+	private async runCompaction(sdkHost: SdkSessionHost, sessionId: string): Promise<void> {
+		if (!sdkHost.updateSessionCompactionState) {
+			this.emitInfo(COMPACTION_UNSUPPORTED_MESSAGE, sessionId)
+			await this.options.postStateToWebview()
+			return
+		}
+		const messages = (await sdkHost.readMessages(sessionId)) as SdkMessage[]
+		const messagesBefore = messages.length
+		if (messagesBefore === 0) {
+			this.emitInfo("No messages to compact.", sessionId)
+			await this.options.postStateToWebview()
+			return
+		}
+
+		const cwd = await this.options.getWorkspaceRoot()
+		const mode = this.getCurrentMode()
+		const config = await this.options.sessionConfigBuilder.build({ cwd, mode })
+
+		const result = await compactSessionMessages({
+			config: {
+				providerConfig: config.providerConfig,
+				providerId: config.providerId,
+				modelId: config.modelId,
+				knownModels: config.knownModels,
+				compaction: config.compaction,
+				logger: config.logger,
+				telemetry: config.telemetry,
+			},
+			sessionId,
+			messages,
+		})
+
+		if (!result.compacted) {
+			this.emitInfo("No compaction needed.", sessionId)
+			await this.options.postStateToWebview()
+			return
+		}
+
+		if (!result.compactionState) {
+			throw new Error("Compaction did not return durable state.")
+		}
+		const persisted = await sdkHost.updateSessionCompactionState(sessionId, result.compactionState)
+		if (!persisted.updated) {
+			throw new Error("Compaction sidecar could not be persisted.")
+		}
+
+		this.emitInfo(this.formatCompactionStatus(messagesBefore, result.messages.length), sessionId)
+		await this.options.postStateToWebview()
+
+		Logger.log(`[SdkController] Compacted session ${sessionId}: ${messagesBefore} -> ${result.messages.length} messages`)
+	}
+
+	private getCurrentMode(): Mode {
+		const m = this.options.stateManager.getGlobalSettingsKey("mode")
+		return m === "plan" ? m : "act"
+	}
+
+	private formatCompactionStatus(messagesBefore: number, messagesAfter: number): string {
+		// Mirrors apps/cli/src/tui/utils/compaction-status.ts wording.
+		if (messagesBefore === messagesAfter) {
+			return `Compacted context; message count stayed at ${messagesAfter}.`
+		}
+		return `Compacted ${messagesBefore} messages to ${messagesAfter}.`
+	}
+
+	private emitInfo(text: string, sessionId?: string): void {
+		const activeSessionId = this.options.sessions.getActiveSession()?.sessionId
+		if (sessionId && activeSessionId !== sessionId) {
+			Logger.warn(`[SdkController] compactTask: skipped info for inactive session ${sessionId}`)
+			return
+		}
+		const targetSessionId = sessionId ?? activeSessionId ?? ""
+		const infoMessage: ClineMessage = {
+			ts: Date.now(),
+			type: "say",
+			say: "info",
+			text,
+			partial: false,
+		}
+		this.options.messages.appendAndEmit([infoMessage], {
+			type: "status",
+			payload: { sessionId: targetSessionId, status: "running" },
+		})
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-compaction.test.ts b/apps/vscode/src/sdk/sdk-compaction.test.ts
new file mode 100644
index 0000000..76a557d
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-compaction.test.ts
@@ -0,0 +1,96 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest"
+
+const createContextCompactionPrepareTurn = vi.fn()
+const createSessionCompactionState = vi.fn((input: unknown) => ({ version: 1, input }))
+vi.mock("@cline/core", () => ({
+	createContextCompactionPrepareTurn: (...args: unknown[]) => createContextCompactionPrepareTurn(...args),
+	createSessionCompactionState: (input: unknown) => createSessionCompactionState(input),
+}))
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: { debug: vi.fn(), error: vi.fn(), log: vi.fn(), warn: vi.fn() },
+}))
+
+let compactSessionMessages: typeof import("./sdk-compaction").compactSessionMessages
+
+const baseConfig = {
+	providerConfig: { providerId: "anthropic", modelId: "claude" },
+	providerId: "anthropic",
+	modelId: "claude",
+	knownModels: { claude: { id: "claude", maxInputTokens: 200_000 } },
+	compaction: undefined,
+	logger: undefined,
+	telemetry: undefined,
+} as unknown as Parameters<typeof compactSessionMessages>[0]["config"]
+
+describe("compactSessionMessages", () => {
+	beforeAll(async () => {
+		;({ compactSessionMessages } = await import("./sdk-compaction"))
+	})
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("returns compacted=false without invoking the SDK when there are no messages", async () => {
+		const result = await compactSessionMessages({ config: baseConfig, sessionId: "s1", messages: [] })
+
+		expect(result).toEqual({ compacted: false, messages: [] })
+		expect(createContextCompactionPrepareTurn).not.toHaveBeenCalled()
+	})
+
+	it("builds a manual-mode prepareTurn and force-enables compaction", async () => {
+		const compact = vi
+			.fn()
+			.mockResolvedValue({ messages: [{ role: "user", content: "summary" }], systemPrompt: "rewritten system" })
+		createContextCompactionPrepareTurn.mockReturnValueOnce(compact)
+
+		const messages = [
+			{ role: "user" as const, content: "1" },
+			{ role: "assistant" as const, content: "2" },
+		]
+		const result = await compactSessionMessages({ config: baseConfig, sessionId: "s1", messages })
+
+		// Manual mode + enabled compaction + telemetry keying.
+		expect(createContextCompactionPrepareTurn).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "anthropic",
+				modelId: "claude",
+				compaction: expect.objectContaining({ enabled: true }),
+				sessionId: "s1",
+			}),
+			{ mode: "manual" },
+		)
+		expect(compact).toHaveBeenCalledOnce()
+		expect(createSessionCompactionState).toHaveBeenCalledWith({
+			sourceMessages: messages,
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "s1",
+			systemPrompt: "rewritten system",
+		})
+		expect(result).toEqual({
+			compacted: true,
+			messages: [{ role: "user", content: "summary" }],
+			compactionState: { version: 1, input: expect.anything() },
+		})
+	})
+
+	it("returns compacted=false when prepareTurn is unavailable", async () => {
+		createContextCompactionPrepareTurn.mockReturnValueOnce(undefined)
+
+		const messages = [{ role: "user" as const, content: "1" }]
+		const result = await compactSessionMessages({ config: baseConfig, sessionId: "s1", messages })
+
+		expect(result).toEqual({ compacted: false, messages })
+	})
+
+	it("returns compacted=false when the strategy declines (returns undefined)", async () => {
+		const compact = vi.fn().mockResolvedValue(undefined)
+		createContextCompactionPrepareTurn.mockReturnValueOnce(compact)
+
+		const messages = [{ role: "user" as const, content: "1" }]
+		const result = await compactSessionMessages({ config: baseConfig, sessionId: "s1", messages })
+
+		expect(result).toEqual({ compacted: false, messages })
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-compaction.ts b/apps/vscode/src/sdk/sdk-compaction.ts
new file mode 100644
index 0000000..28cfec0
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-compaction.ts
@@ -0,0 +1,121 @@
+// Replaces classic manual-condense handling from src/core/task (see origin/main)
+//
+// Manual context compaction for the VSCode SDK adapter. This mirrors the CLI's
+// apps/cli/src/runtime/interactive/compaction.ts (`compactInteractiveMessages`):
+// it builds a manual-mode compaction `prepareTurn` via the SDK's
+// `createContextCompactionPrepareTurn` and runs it against the current session
+// transcript, returning the compacted working-context sidecar state.
+//
+// The VSCode coordinator persists that sidecar without replacing the canonical
+// transcript, so the active session and later resumes use compacted working
+// context while saved messages remain intact.
+
+import {
+	type CoreSessionConfig,
+	createContextCompactionPrepareTurn,
+	createSessionCompactionState,
+	type SessionCompactionState,
+} from "@cline/core"
+import type { Message as SdkMessage, ModelInfo as SdkModelInfo } from "@cline/llms"
+import { Logger } from "@/shared/services/Logger"
+
+// When the active model does not declare a context window, fall back to a
+// conservative input budget so manual compaction still has a target to shrink
+// toward. Matches the CLI's FALLBACK_MANUAL_COMPACTION_MAX_INPUT_TOKENS.
+const FALLBACK_MANUAL_COMPACTION_MAX_INPUT_TOKENS = 64_000
+
+export interface CompactSessionMessagesInput {
+	/** Provider/model/compaction config for the active session. */
+	config: Pick<
+		CoreSessionConfig,
+		"providerConfig" | "providerId" | "modelId" | "knownModels" | "compaction" | "logger" | "telemetry"
+	>
+	/** The active session id (used for telemetry keying). */
+	sessionId: string
+	/** The conversation transcript to compact (SDK message shape). */
+	messages: SdkMessage[]
+}
+
+export interface CompactSessionMessagesResult {
+	compacted: boolean
+	messages: SdkMessage[]
+	compactionState?: SessionCompactionState
+}
+
+/**
+ * Run a manual context compaction over the supplied messages.
+ *
+ * Returns `{ compacted: false }` (with the original messages) when there is
+ * nothing to compact or the configured strategy declines to compact.
+ */
+export async function compactSessionMessages(input: CompactSessionMessagesInput): Promise<CompactSessionMessagesResult> {
+	if (input.messages.length === 0) {
+		return { compacted: false, messages: input.messages }
+	}
+
+	const modelInfo: SdkModelInfo | undefined = input.config.knownModels?.[input.config.modelId]
+	const maxInputTokens =
+		input.config.compaction?.maxInputTokens ??
+		modelInfo?.maxInputTokens ??
+		modelInfo?.contextWindow ??
+		FALLBACK_MANUAL_COMPACTION_MAX_INPUT_TOKENS
+
+	const compact = createContextCompactionPrepareTurn(
+		{
+			providerConfig: input.config.providerConfig,
+			providerId: input.config.providerId,
+			modelId: input.config.modelId,
+			// Force-enable compaction for this manual request even when
+			// auto-condense is off — the user explicitly asked for it.
+			compaction: {
+				...input.config.compaction,
+				enabled: true,
+			},
+			logger: input.config.logger,
+			// Forward telemetry + sessionId so manual compactions emit
+			// `task.compaction_executed` / `task.compaction_skipped` events,
+			// matching the CLI and auto-compaction.
+			telemetry: input.config.telemetry,
+			sessionId: input.sessionId,
+		},
+		{ mode: "manual" },
+	)
+	if (!compact) {
+		Logger.warn("[SdkCompaction] Compaction prepareTurn unavailable; skipping manual compaction")
+		return { compacted: false, messages: input.messages }
+	}
+
+	const result = await compact({
+		agentId: "cline-vscode",
+		conversationId: input.sessionId,
+		parentAgentId: null,
+		iteration: 0,
+		messages: input.messages,
+		apiMessages: input.messages,
+		abortSignal: new AbortController().signal,
+		systemPrompt: "",
+		tools: [],
+		model: {
+			id: input.config.modelId,
+			provider: input.config.providerId,
+			info: {
+				...(modelInfo ?? {}),
+				id: modelInfo?.id ?? input.config.modelId,
+				maxInputTokens,
+			},
+		},
+	})
+	if (!result) {
+		return { compacted: false, messages: input.messages }
+	}
+	return {
+		compacted: true,
+		messages: result.messages,
+		compactionState: createSessionCompactionState({
+			sourceMessages: input.messages,
+			compactedMessages: result.messages,
+			conversationId: input.sessionId,
+			systemPrompt: result.systemPrompt,
+		}),
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-followup-coordinator.test.ts b/apps/vscode/src/sdk/sdk-followup-coordinator.test.ts
new file mode 100644
index 0000000..cdb4a12
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-followup-coordinator.test.ts
@@ -0,0 +1,464 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { StateManager } from "@/core/storage/StateManager"
+import { SdkFollowupCoordinator, type SdkFollowupCoordinatorOptions } from "./sdk-followup-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("SdkFollowupCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("resolves pending tool approvals without sending a follow-up", async () => {
+		const { coordinator, options } = makeCoordinator()
+		options.interactions.resolvePendingToolApproval.mockReturnValue(true)
+
+		await coordinator.askResponse("yes", undefined, undefined, "yesButtonClicked")
+
+		expect(options.interactions.resolvePendingToolApproval).toHaveBeenCalledWith(
+			"yes",
+			"yesButtonClicked",
+			undefined,
+			undefined,
+		)
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+	})
+
+	it("resolves pending ask_question responses without sending a follow-up", async () => {
+		const { coordinator, options } = makeCoordinator()
+		options.interactions.resolvePendingAskQuestion.mockReturnValue(true)
+
+		await coordinator.askResponse("answer")
+
+		expect(options.interactions.resolvePendingAskQuestion).toHaveBeenCalledWith("answer")
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+	})
+
+	it("sends a follow-up to an idle active session", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.askResponse("hello @file", ["image.png"], ["a.ts"])
+
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(true)
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					type: "say",
+					say: "user_feedback",
+					text: "hello @file",
+					images: ["image.png"],
+					files: ["a.ts"],
+				}),
+			],
+			{ type: "status", payload: { sessionId: "session-123", status: "running" } },
+		)
+		expect(options.resetMessageTranslator).toHaveBeenCalledOnce()
+		expect(options.resolveContextMentions).toHaveBeenCalledWith("hello @file")
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			activeSession.sdkHost,
+			"session-123",
+			"resolved: hello @file",
+			["image.png"],
+			["a.ts"],
+			undefined,
+		)
+	})
+
+	it("queues a follow-up when the active session is already running", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.askResponse("queued")
+
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.resetMessageTranslator).not.toHaveBeenCalled()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			activeSession.sdkHost,
+			"session-123",
+			"resolved: queued",
+			undefined,
+			undefined,
+			"queue",
+		)
+	})
+
+	it("queues a follow-up when the turn phase is still streaming even if the session running flag is stale", async () => {
+		const activeSession = makeActiveSession({ isRunning: false })
+		const task = makeTask("session-123")
+		const { coordinator, options } = makeCoordinator({ activeSession, task })
+
+		await coordinator.askResponse("queued while streaming", undefined, undefined, "messageResponse", "streaming")
+
+		expect(options.waitForPendingModeRebuild).not.toHaveBeenCalled()
+		expect(options.sessions.startNewSession).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.resetMessageTranslator).not.toHaveBeenCalled()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			activeSession.sdkHost,
+			"session-123",
+			"resolved: queued while streaming",
+			undefined,
+			undefined,
+			"queue",
+		)
+	})
+
+	it("queues a chat-field message submitted while a tool approval is pending", async () => {
+		const activeSession = makeActiveSession({ isRunning: false })
+		const task = makeTask("session-123")
+		const { coordinator, options } = makeCoordinator({ activeSession, task })
+		options.interactions.resolvePendingToolApproval.mockReturnValue(false)
+
+		await coordinator.askResponse(
+			"do the next thing after this",
+			undefined,
+			undefined,
+			"messageResponse",
+			"awaiting_approval",
+		)
+
+		expect(options.interactions.resolvePendingToolApproval).toHaveBeenCalledWith(
+			"do the next thing after this",
+			"messageResponse",
+			undefined,
+			undefined,
+		)
+		expect(options.waitForPendingModeRebuild).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.resetMessageTranslator).not.toHaveBeenCalled()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			activeSession.sdkHost,
+			"session-123",
+			"resolved: do the next thing after this",
+			undefined,
+			undefined,
+			"queue",
+		)
+	})
+
+	it("sends immediately when the submit-time phase was completed", async () => {
+		const activeSession = makeActiveSession({ isRunning: false })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.askResponse("next request", undefined, undefined, "messageResponse", "completed")
+
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					type: "say",
+					say: "user_feedback",
+					text: "next request",
+				}),
+			],
+			{ type: "status", payload: { sessionId: "session-123", status: "running" } },
+		)
+		expect(options.resetMessageTranslator).toHaveBeenCalledOnce()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			activeSession.sdkHost,
+			"session-123",
+			"resolved: next request",
+			undefined,
+			undefined,
+			undefined,
+		)
+	})
+
+	it("waits for an in-flight mode rebuild before deciding whether to resume a displayed task", async () => {
+		const task = makeTask("task-1")
+		const rebuiltSession = makeActiveSession({ isRunning: true })
+		let resolveRebuild: () => void = () => {}
+		const waitForPendingModeRebuild = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveRebuild = resolve
+				}),
+		)
+		const { coordinator, options } = makeCoordinator({ task, waitForPendingModeRebuild })
+		options.sessions.getActiveSession.mockReturnValueOnce(undefined).mockReturnValue(rebuiltSession)
+
+		const sendPromise = coordinator.askResponse("sent during rebuild")
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		expect(waitForPendingModeRebuild).toHaveBeenCalledOnce()
+		expect(options.sessions.startNewSession).not.toHaveBeenCalled()
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+
+		resolveRebuild()
+		await sendPromise
+
+		expect(options.sessions.startNewSession).not.toHaveBeenCalled()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			rebuiltSession.sdkHost,
+			"session-123",
+			"resolved: sent during rebuild",
+			undefined,
+			undefined,
+			"queue",
+		)
+	})
+
+	it("queues a message response after a pending tool approval is not resolved by chat text", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		options.interactions.resolvePendingToolApproval.mockReturnValue(false)
+
+		await coordinator.askResponse("just give me an answer", undefined, undefined, "messageResponse")
+
+		expect(options.interactions.resolvePendingToolApproval).toHaveBeenCalledWith(
+			"just give me an answer",
+			"messageResponse",
+			undefined,
+			undefined,
+		)
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			activeSession.sdkHost,
+			"session-123",
+			"resolved: just give me an answer",
+			undefined,
+			undefined,
+			"queue",
+		)
+	})
+
+	it("resumes a displayed task before sending a follow-up when there is no live session", async () => {
+		const task = makeTask("task-1")
+		const historyItem = {
+			id: "task-1",
+			ts: 1,
+			task: "Original task",
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+			cwdOnTaskInitialization: "/task-cwd",
+		}
+		const { coordinator, options } = makeCoordinator({ task, historyItem })
+
+		await coordinator.askResponse("continue")
+
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({ cwd: "/task-cwd", mode: "act" })
+		expect(options.createTempSessionHost).toHaveBeenCalledOnce()
+		expect(options.loadInitialMessages).toHaveBeenCalledWith(
+			expect.objectContaining({ readMessages: expect.any(Function) }),
+			"task-1",
+		)
+		expect(options.sessions.startNewSession).toHaveBeenCalledWith({
+			config: expect.objectContaining({ sessionId: "task-1" }),
+			interactive: true,
+			initialMessages: [{ role: "user", content: "hello" }],
+			sessionMetadata: expect.objectContaining({
+				title: "Original task",
+				modelId: "model",
+			}),
+		})
+		expect(options.taskHistory.updateTaskHistoryItem).toHaveBeenCalledWith(
+			expect.objectContaining({ id: "task-1", modelId: "model" }),
+		)
+		expect(options.resolveContextMentions).toHaveBeenCalledWith("continue")
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.objectContaining({ send: expect.any(Function) }),
+			"resumed-session",
+			"resolved: continue",
+			undefined,
+			undefined,
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("echoes attachments on an attachment-only resume", async () => {
+		const task = makeTask("task-1")
+		const historyItem = {
+			id: "task-1",
+			ts: 1,
+			task: "Original task",
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+			cwdOnTaskInitialization: "/task-cwd",
+		}
+		const { coordinator, options } = makeCoordinator({ task, historyItem })
+
+		await coordinator.askResponse(undefined, ["data:image/png;base64,abc"], [])
+
+		// The attachment-only resume shows a visible bubble for the attachment,
+		// keeping the transcript aligned with the SDK message that carries it.
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					say: "user_feedback",
+					text: "",
+					images: ["data:image/png;base64,abc"],
+				}),
+			],
+			expect.anything(),
+		)
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.anything(),
+			"resumed-session",
+			expect.stringContaining("[TASK RESUMPTION]"),
+			["data:image/png;base64,abc"],
+			[],
+		)
+	})
+
+	it("emits auth errors when resume fails because the cline provider is unauthenticated", async () => {
+		const task = makeTask("task-1")
+		const { coordinator, options } = makeCoordinator({ task })
+		options.sessionConfigBuilder.build.mockRejectedValue(new Error("missing api key"))
+		options.isClineManagedProviderActive.mockReturnValue(true)
+
+		await coordinator.askResponse("continue")
+
+		expect(options.emitClineAuthError).toHaveBeenCalledOnce()
+		expect(options.onResumeFailed).toHaveBeenCalledOnce()
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("reports resume failures so the turn phase does not stay stuck in streaming", async () => {
+		const task = makeTask("task-1")
+		const { coordinator, options } = makeCoordinator({ task })
+		options.sessions.startNewSession.mockRejectedValue(new Error("session start failed"))
+
+		await coordinator.askResponse("continue")
+
+		expect(options.onResumeFailed).toHaveBeenCalledOnce()
+		expect(options.messages.emitSessionEvents).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "error", text: expect.stringContaining("session start failed") })],
+			{ type: "status", payload: { sessionId: "task-1", status: "error" } },
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const config = {
+		providerId: "anthropic",
+		modelId: "model",
+		apiKey: "key",
+	}
+	const tempHost = {
+		readMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		dispose: vi.fn().mockResolvedValue(undefined),
+	}
+	const options = {
+		stateManager: {
+			getGlobalSettingsKey: vi.fn(() => input.mode ?? "act"),
+		} as unknown as StateManager,
+		interactions: {
+			resolvePendingMistakeLimit: vi.fn(() => false),
+			resolvePendingToolApproval: vi.fn(() => false),
+			resolvePendingAskQuestion: vi.fn(() => false),
+		},
+		sessions: {
+			getActiveSession: vi.fn(() => input.activeSession),
+			setRunning: vi.fn(),
+			fireAndForgetSend: vi.fn(),
+			startNewSession: vi.fn().mockResolvedValue({
+				startResult: { sessionId: "resumed-session" },
+				sdkHost: { send: vi.fn() },
+			}),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+			emitSessionEvents: vi.fn(),
+		},
+		taskHistory: {
+			findHistoryItem: vi.fn(() => input.historyItem),
+			updateTaskHistory: vi.fn().mockResolvedValue([]),
+			updateTaskHistoryItem: vi.fn().mockResolvedValue(undefined),
+		},
+		sessionConfigBuilder: {
+			build: vi.fn().mockResolvedValue(config),
+		},
+		getTask: vi.fn(() => input.task),
+		createTempSessionHost: vi.fn().mockResolvedValue(tempHost),
+		getWorkspaceRoot: vi.fn().mockResolvedValue("/workspace"),
+		loadInitialMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		buildStartSessionInput: vi.fn(() => ({ prompt: "start" })),
+		resolveContextMentions: vi.fn(async (text: string) => `resolved: ${text}`),
+		isClineManagedProviderActive: vi.fn(() => false),
+		emitClineAuthError: vi.fn(),
+		resetMessageTranslator: vi.fn(),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		waitForPendingModeRebuild: input.waitForPendingModeRebuild ?? vi.fn().mockResolvedValue(undefined),
+		onResumeFailed: vi.fn(),
+	} as unknown as SdkFollowupCoordinatorOptions & {
+		interactions: SdkFollowupCoordinatorOptions["interactions"] & {
+			resolvePendingMistakeLimit: ReturnType<typeof vi.fn>
+			resolvePendingToolApproval: ReturnType<typeof vi.fn>
+			resolvePendingAskQuestion: ReturnType<typeof vi.fn>
+		}
+		sessions: SdkFollowupCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			setRunning: ReturnType<typeof vi.fn>
+			fireAndForgetSend: ReturnType<typeof vi.fn>
+			startNewSession: ReturnType<typeof vi.fn>
+		}
+		messages: SdkFollowupCoordinatorOptions["messages"] & {
+			appendAndEmit: ReturnType<typeof vi.fn>
+			emitSessionEvents: ReturnType<typeof vi.fn>
+		}
+		taskHistory: SdkFollowupCoordinatorOptions["taskHistory"] & {
+			findHistoryItem: ReturnType<typeof vi.fn>
+			updateTaskHistory: ReturnType<typeof vi.fn>
+			updateTaskHistoryItem: ReturnType<typeof vi.fn>
+		}
+		sessionConfigBuilder: SdkFollowupCoordinatorOptions["sessionConfigBuilder"] & { build: ReturnType<typeof vi.fn> }
+		getTask: ReturnType<typeof vi.fn>
+		createTempSessionHost: ReturnType<typeof vi.fn>
+		getWorkspaceRoot: ReturnType<typeof vi.fn>
+		loadInitialMessages: ReturnType<typeof vi.fn>
+		resolveContextMentions: ReturnType<typeof vi.fn>
+		isClineManagedProviderActive: ReturnType<typeof vi.fn>
+		emitClineAuthError: ReturnType<typeof vi.fn>
+		resetMessageTranslator: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+		onResumeFailed: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkFollowupCoordinator(options),
+		options,
+		tempHost,
+	}
+}
+
+interface MakeCoordinatorInput {
+	activeSession: ReturnType<typeof makeActiveSession>
+	task: ReturnType<typeof makeTask>
+	historyItem: {
+		id: string
+		ts: number
+		task: string
+		tokensIn: number
+		tokensOut: number
+		totalCost: number
+		cwdOnTaskInitialization?: string
+	}
+	mode: "act" | "plan"
+	waitForPendingModeRebuild: () => Promise<void>
+}
+
+function makeActiveSession(input: { isRunning?: boolean } = {}) {
+	return {
+		sessionId: "session-123",
+		sdkHost: {
+			send: vi.fn(),
+		},
+		isRunning: input.isRunning ?? false,
+	}
+}
+
+function makeTask(taskId: string) {
+	return {
+		taskId,
+		taskState: {},
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-followup-coordinator.ts b/apps/vscode/src/sdk/sdk-followup-coordinator.ts
new file mode 100644
index 0000000..8aa4074
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-followup-coordinator.ts
@@ -0,0 +1,228 @@
+import { CLINE_ACCOUNT_AUTH_ERROR_MESSAGE } from "@shared/ClineAccount"
+import type { ClineMessage, TurnPhase } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+import type { ClineAskResponse } from "@shared/WebviewMessage"
+import type { StateManager } from "@/core/storage/StateManager"
+import { Logger } from "@/shared/services/Logger"
+import type { SdkInteractionCoordinator } from "./sdk-interaction-coordinator"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import { historyItemToSessionMetadata, type SdkTaskHistory } from "./sdk-task-history"
+import type { SdkSessionHost } from "./session-host"
+import type { TaskProxy } from "./task-proxy"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+type StartInput = Parameters<VscodeSessionHost["start"]>[0]
+type InitialMessages = StartInput["initialMessages"]
+type SessionConfig = Awaited<ReturnType<SdkSessionConfigBuilder["build"]>>
+
+export interface SdkFollowupCoordinatorOptions {
+	stateManager: StateManager
+	interactions: SdkInteractionCoordinator
+	sessions: SdkSessionLifecycle
+	messages: SdkMessageCoordinator
+	taskHistory: SdkTaskHistory
+	sessionConfigBuilder: SdkSessionConfigBuilder
+	getTask: () => TaskProxy | undefined
+	createTempSessionHost: () => Promise<SdkSessionHost>
+	getWorkspaceRoot: () => Promise<string>
+	loadInitialMessages: (sessionHost: SdkSessionHost, taskId: string) => Promise<unknown[] | undefined>
+	buildStartSessionInput: (config: SessionConfig, input: { cwd: string; mode: Mode }) => StartInput
+	resolveContextMentions: (text: string) => Promise<string>
+	isClineManagedProviderActive: () => boolean
+	emitClineAuthError: () => void
+	resetMessageTranslator: () => void
+	postStateToWebview: () => Promise<void>
+	/** Resolves once no plan/act mode rebuild is in flight. */
+	waitForPendingModeRebuild: () => Promise<void>
+	/**
+	 * Called when resuming a task fails. askResponse moved the turn phase to
+	 * streaming before delegating here, so the failure must move it to a
+	 * terminal phase or the footer stays stuck on Thinking/Cancel.
+	 */
+	onResumeFailed: () => void
+}
+
+export class SdkFollowupCoordinator {
+	constructor(private readonly options: SdkFollowupCoordinatorOptions) {}
+
+	async askResponse(
+		prompt?: string,
+		images?: string[],
+		files?: string[],
+		askResponse?: ClineAskResponse,
+		turnPhaseAtSubmit?: TurnPhase,
+	): Promise<void> {
+		if (this.options.interactions.resolvePendingMistakeLimit(prompt, askResponse)) {
+			return
+		}
+
+		if (this.options.interactions.resolvePendingToolApproval(prompt, askResponse, images, files)) {
+			return
+		}
+
+		if (this.options.interactions.resolvePendingAskQuestion(prompt)) {
+			return
+		}
+
+		let activeSession = this.options.sessions.getActiveSession()
+		const task = this.options.getTask()
+		const submittedDuringActiveTurn = turnPhaseAtSubmit === "streaming" || turnPhaseAtSubmit === "awaiting_approval"
+		const isActiveTurnInProgress = () => !!activeSession && (activeSession.isRunning || submittedDuringActiveTurn)
+		if (!isActiveTurnInProgress() && task) {
+			// A mode rebuild clears the active session while the old stop is
+			// awaited and only marks the replacement running after the
+			// continuation send. Resuming in that window would start a parallel
+			// session that the rebuild then kills, losing this message. Wait for
+			// the rebuild and re-evaluate against the rebuilt session.
+			await this.options.waitForPendingModeRebuild()
+			activeSession = this.options.sessions.getActiveSession()
+		}
+		if (!isActiveTurnInProgress() && task) {
+			Logger.log(`[SdkController] askResponse: No active session but task exists (${task.taskId}), resuming...`)
+			await this.tryResumeSessionFromTask(task.taskId, prompt, images, files)
+			return
+		}
+
+		if (!activeSession) {
+			Logger.error("[SdkController] askResponse: No active session")
+			return
+		}
+
+		const { sdkHost, sessionId } = activeSession
+		const shouldQueue = isActiveTurnInProgress()
+		const delivery = shouldQueue ? ("queue" as const) : undefined
+
+		if (shouldQueue) {
+			Logger.log(`[SdkController] Session is running - queuing follow-up message for session: ${sessionId}`)
+		}
+
+		this.options.sessions.setRunning(true)
+		if (!shouldQueue) {
+			this.emitUserFeedback(sessionId, prompt, images, files)
+		}
+
+		if (!shouldQueue) {
+			this.options.resetMessageTranslator()
+		}
+
+		const resolvedPrompt = prompt ? await this.options.resolveContextMentions(prompt) : ""
+		this.options.sessions.fireAndForgetSend(sdkHost, sessionId, resolvedPrompt, images, files, delivery)
+	}
+
+	private async tryResumeSessionFromTask(taskId: string, prompt?: string, images?: string[], files?: string[]): Promise<void> {
+		try {
+			await this.resumeSessionFromTask(taskId, prompt, images, files)
+		} catch (error) {
+			Logger.error("[SdkController] Failed to resume session from task:", error)
+
+			const errorMsg = error instanceof Error ? error.message : String(error)
+			const isClineAuth =
+				this.options.isClineManagedProviderActive() &&
+				(errorMsg.includes(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE) ||
+					errorMsg.toLowerCase().includes("missing api key") ||
+					errorMsg.toLowerCase().includes("unauthorized"))
+
+			if (isClineAuth) {
+				this.options.emitClineAuthError()
+			} else {
+				this.options.messages.emitSessionEvents(
+					[
+						{
+							ts: Date.now(),
+							type: "say",
+							say: "error",
+							text: `Failed to resume task: ${errorMsg}`,
+							partial: false,
+						},
+					],
+					{ type: "status", payload: { sessionId: taskId, status: "error" } },
+				)
+			}
+			this.options.onResumeFailed()
+			await this.options.postStateToWebview()
+		}
+	}
+
+	private async resumeSessionFromTask(taskId: string, prompt?: string, images?: string[], files?: string[]): Promise<void> {
+		Logger.log(`[SdkController] Resuming session from task: ${taskId}`)
+
+		const historyItem = await this.options.taskHistory.findHistoryItem(taskId)
+		const cwd = historyItem?.cwdOnTaskInitialization ?? (await this.options.getWorkspaceRoot())
+
+		const modeValue = this.options.stateManager.getGlobalSettingsKey("mode")
+		const mode: Mode = modeValue === "plan" || modeValue === "act" ? modeValue : "act"
+		const config = await this.options.sessionConfigBuilder.build({ cwd, mode })
+		config.sessionId = taskId
+
+		const tempManager = await this.options.createTempSessionHost()
+		const initialMessages = await this.options.loadInitialMessages(tempManager, taskId)
+		await tempManager.dispose("readMessages")
+
+		Logger.log(`[SdkController] Resuming with ${initialMessages?.length ?? 0} initial messages`)
+
+		const { startResult, sdkHost } = await this.options.sessions.startNewSession({
+			config,
+			interactive: true,
+			...(initialMessages ? { initialMessages: initialMessages as InitialMessages } : {}),
+			...(historyItem ? { sessionMetadata: historyItemToSessionMetadata(historyItem, config.modelId) } : {}),
+		})
+
+		const task = this.options.getTask()
+		if (task && task.taskId !== startResult.sessionId) {
+			task.taskId = startResult.sessionId
+		}
+
+		this.options.resetMessageTranslator()
+
+		if (historyItem) {
+			historyItem.ts = Date.now()
+			historyItem.modelId = config.modelId
+			await this.options.taskHistory.updateTaskHistoryItem(historyItem)
+		}
+
+		// Echo whenever the user supplied content, including attachment-only
+		// resumes, and include the attachments in the bubble. This also keeps the
+		// visible transcript aligned with SDK history for edit/regenerate ordinal
+		// mapping: a resumption prompt carrying user attachments is counted as a
+		// visible user message, a bare resumption prompt is not.
+		if (prompt?.trim() || images?.length || files?.length) {
+			this.emitUserFeedback(startResult.sessionId, prompt, images, files)
+		}
+
+		await this.options.postStateToWebview()
+
+		const effectivePrompt =
+			prompt?.trim() ||
+			(historyItem
+				? `[TASK RESUMPTION] This task was interrupted. It may or may not be complete, so please reassess the task context. The conversation history has been preserved. New instructions from the user: ${historyItem.task}`
+				: "[TASK RESUMPTION] Please continue where you left off.")
+
+		const resolvedPrompt = await this.options.resolveContextMentions(effectivePrompt)
+		this.options.sessions.fireAndForgetSend(sdkHost, startResult.sessionId, resolvedPrompt, images, files)
+	}
+
+	private emitUserFeedback(sessionId: string, prompt?: string, images?: string[], files?: string[]): void {
+		const hasPrompt = !!prompt?.trim()
+		const hasImages = !!images?.length
+		const hasFiles = !!files?.length
+		if (!hasPrompt && !hasImages && !hasFiles) {
+			return
+		}
+
+		const userMessage: ClineMessage = {
+			ts: Date.now(),
+			type: "say",
+			say: "user_feedback",
+			text: prompt ?? "",
+			images,
+			files,
+			partial: false,
+		}
+		this.options.messages.appendAndEmit([userMessage], {
+			type: "status",
+			payload: { sessionId, status: "running" },
+		})
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-interaction-coordinator.test.ts b/apps/vscode/src/sdk/sdk-interaction-coordinator.test.ts
new file mode 100644
index 0000000..611db2d
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-interaction-coordinator.test.ts
@@ -0,0 +1,431 @@
+import type { AgentEvent } from "@cline/shared"
+import { describe, expect, it, vi } from "vitest"
+import { MessageTranslatorState, translateSessionEvent } from "./message-translator"
+import { SdkInteractionCoordinator } from "./sdk-interaction-coordinator"
+import { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import { createTaskProxy } from "./task-proxy"
+import { DEFAULT_TOOL_APPROVAL_DENIAL_REASON } from "./tool-approval-denial"
+
+vi.mock("./webview-grpc-bridge", () => ({
+	pushMessageToWebview: vi.fn().mockResolvedValue(undefined),
+}))
+
+vi.mock("@core/storage/disk", () => ({
+	saveClineMessages: vi.fn().mockResolvedValue(undefined),
+}))
+
+describe("SdkInteractionCoordinator", () => {
+	it("emits a tool approval ask and resolves approval from askResponse state", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const messages = new SdkMessageCoordinator({ getTask: () => task })
+		const listener = vi.fn()
+		const postStateToWebview = vi.fn().mockResolvedValue(undefined)
+		const recordApprovedToolMessage = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages,
+			getSessionId: () => "session-123",
+			postStateToWebview,
+			recordApprovedToolMessage,
+		})
+		messages.onSessionEvent(listener)
+
+		const approvalPromise = coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "read_files",
+			input: { path: "README.md" },
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(postStateToWebview).toHaveBeenCalled())
+
+		const clineMessages = task.messageStateHandler.getClineMessages()
+		expect(clineMessages).toHaveLength(1)
+		expect(clineMessages[0].type).toBe("ask")
+		expect(clineMessages[0].ask).toBe("tool")
+		expect(JSON.parse(clineMessages[0].text || "{}")).toMatchObject({ tool: "readFile", path: "README.md" })
+		expect(listener).toHaveBeenCalledOnce()
+
+		expect(coordinator.resolvePendingToolApproval(undefined, "yesButtonClicked")).toBe(true)
+		expect(recordApprovedToolMessage).toHaveBeenCalledWith("tool-call", clineMessages[0].ts)
+		await expect(approvalPromise).resolves.toEqual({ approved: true })
+	})
+
+	it("records the real approval row timestamp that the translator reuses", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const messages = new SdkMessageCoordinator({ getTask: () => task })
+		const state = new MessageTranslatorState()
+		const coordinator = new SdkInteractionCoordinator({
+			messages,
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			getMinter: () => state.getMinter(),
+			recordApprovedToolMessage: (toolCallId, messageTs) => state.recordApprovedToolMessageTs(toolCallId, messageTs),
+		})
+
+		const approvalPromise = coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "editor",
+			input: { path: "calculator.py", old_text: "# comment", new_text: "" },
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+		const approvalTs = task.messageStateHandler.getClineMessages()[0].ts
+
+		expect(coordinator.resolvePendingToolApproval(undefined, "yesButtonClicked")).toBe(true)
+		await expect(approvalPromise).resolves.toEqual({ approved: true })
+
+		const result = translateSessionEvent(
+			{
+				type: "agent_event",
+				payload: {
+					sessionId: "session-123",
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolName: "editor",
+						toolCallId: "tool-call",
+						input: { path: "calculator.py", old_text: "# comment", new_text: "" },
+					} as AgentEvent,
+				},
+			},
+			state,
+		)
+
+		expect(result.messages[0]).toMatchObject({ ts: approvalTs, type: "say", say: "tool", partial: true })
+	})
+
+	it("resolves denied tool approval with the user reason", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const recordApprovedToolMessage = vi.fn()
+		const recordDeniedToolApproval = vi.fn()
+		const messages = new SdkMessageCoordinator({ getTask: () => task })
+		const coordinator = new SdkInteractionCoordinator({
+			messages,
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			recordApprovedToolMessage,
+			recordDeniedToolApproval,
+		})
+
+		const approvalPromise = coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "execute_command",
+			input: { command: "npm test" },
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		const clineMessages = task.messageStateHandler.getClineMessages()
+		expect(clineMessages[0]).toMatchObject({ type: "ask", ask: "command", text: "npm test" })
+
+		expect(coordinator.resolvePendingToolApproval("too risky", "noButtonClicked", ["image.png"], ["a.ts"])).toBe(true)
+		expect(recordApprovedToolMessage).not.toHaveBeenCalled()
+		expect(recordDeniedToolApproval).toHaveBeenCalledWith("tool-call", "execute_command", "too risky")
+		expect(task.messageStateHandler.getClineMessages()[1]).toMatchObject({
+			type: "say",
+			say: "user_feedback",
+			text: "too risky",
+			images: ["image.png"],
+			files: ["a.ts"],
+			partial: false,
+		})
+		await expect(approvalPromise).resolves.toEqual({ approved: false, reason: "too risky" })
+	})
+
+	it("routes message responses as queued follow-ups without resolving pending tool approval", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const setTurnPhase = vi.fn()
+		const recordDeniedToolApproval = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			setTurnPhase,
+			recordDeniedToolApproval,
+		})
+
+		const approvalPromise = coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "fetch_web_content",
+			input: { requests: [{ url: "https://example.com", prompt: "read it" }] },
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		expect(coordinator.resolvePendingToolApproval("just give me an answer", "messageResponse")).toBe(false)
+		expect(recordDeniedToolApproval).not.toHaveBeenCalled()
+		expect(setTurnPhase).toHaveBeenLastCalledWith("awaiting_approval", task.messageStateHandler.getClineMessages()[0].ts)
+
+		expect(coordinator.resolvePendingToolApproval(undefined, "yesButtonClicked")).toBe(true)
+		await expect(approvalPromise).resolves.toEqual({ approved: true })
+	})
+
+	it("records generic no-button approval denials for UI suppression", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const recordDeniedToolApproval = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			recordDeniedToolApproval,
+		})
+
+		const approvalPromise = coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "fetch_web_content",
+			input: { requests: [{ url: "https://example.com", prompt: "read it" }] },
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		expect(coordinator.resolvePendingToolApproval(undefined, "noButtonClicked")).toBe(true)
+		await expect(approvalPromise).resolves.toEqual({
+			approved: false,
+			reason: DEFAULT_TOOL_APPROVAL_DENIAL_REASON,
+		})
+		expect(task.messageStateHandler.getClineMessages()).toHaveLength(1)
+		expect(recordDeniedToolApproval).toHaveBeenCalledWith(
+			"tool-call",
+			"fetch_web_content",
+			DEFAULT_TOOL_APPROVAL_DENIAL_REASON,
+		)
+	})
+
+	it("auto-approves without emitting UI when the live settings allow the tool", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const postStateToWebview = vi.fn().mockResolvedValue(undefined)
+		const recordApprovedToolMessage = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview,
+			shouldAutoApproveTool: () => true,
+			recordApprovedToolMessage,
+		})
+
+		await expect(
+			coordinator.handleRequestToolApproval({
+				agentId: "agent",
+				conversationId: "conversation",
+				iteration: 1,
+				toolCallId: "tool-call",
+				toolName: "run_commands",
+				input: { command: "npm test" },
+				policy: { autoApprove: false },
+			}),
+		).resolves.toEqual({ approved: true })
+
+		expect(task.messageStateHandler.getClineMessages()).toHaveLength(0)
+		expect(postStateToWebview).not.toHaveBeenCalled()
+		expect(recordApprovedToolMessage).not.toHaveBeenCalled()
+	})
+
+	it("auto-approves without emitting UI when the SDK policy already allows the tool", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const postStateToWebview = vi.fn().mockResolvedValue(undefined)
+		const recordApprovedToolMessage = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview,
+			shouldAutoApproveTool: () => false,
+			recordApprovedToolMessage,
+		})
+
+		await expect(
+			coordinator.handleRequestToolApproval({
+				agentId: "agent",
+				conversationId: "conversation",
+				iteration: 1,
+				toolCallId: "tool-call",
+				toolName: "run_commands",
+				input: { command: "npm test" },
+				policy: { autoApprove: true },
+			}),
+		).resolves.toEqual({ approved: true })
+
+		expect(task.messageStateHandler.getClineMessages()).toHaveLength(0)
+		expect(postStateToWebview).not.toHaveBeenCalled()
+		expect(recordApprovedToolMessage).not.toHaveBeenCalled()
+	})
+
+	it("emits an MCP approval ask with server, tool, and arguments", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		})
+
+		void coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "github__search-repos",
+			input: { query: "cline" },
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		const [message] = task.messageStateHandler.getClineMessages()
+		expect(message).toMatchObject({ type: "ask", ask: "use_mcp_server", partial: false })
+		expect(JSON.parse(message.text || "{}")).toEqual({
+			type: "use_mcp_tool",
+			serverName: "github",
+			toolName: "search-repos",
+			arguments: '{\n  "query": "cline"\n}',
+		})
+	})
+
+	it("emits ask_question and resolves it with rendered user feedback", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const messages = new SdkMessageCoordinator({ getTask: () => task })
+		const coordinator = new SdkInteractionCoordinator({
+			messages,
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		})
+
+		const answerPromise = coordinator.handleAskQuestion("Continue?", ["Yes"], undefined)
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		await new Promise((resolve) => setTimeout(resolve, 1))
+		expect(coordinator.resolvePendingAskQuestion("yes")).toBe(true)
+		await expect(answerPromise).resolves.toBe("yes")
+		expect(task.messageStateHandler.getClineMessages()).toMatchObject([
+			{ type: "ask", ask: "followup" },
+			{ type: "say", say: "user_feedback", text: "yes" },
+		])
+	})
+
+	it("emits mistake_limit_reached and resolves proceed as SDK recovery guidance", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const setTurnPhase = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			setTurnPhase,
+		})
+
+		const decisionPromise = coordinator.handleConsecutiveMistakeLimitReached({
+			iteration: 4,
+			consecutiveMistakes: 3,
+			maxConsecutiveMistakes: 3,
+			reason: "tool_execution_failed",
+			details: "bad arguments",
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		expect(task.messageStateHandler.getClineMessages()[0]).toMatchObject({
+			type: "ask",
+			ask: "mistake_limit_reached",
+			partial: false,
+		})
+		expect(setTurnPhase).toHaveBeenCalledWith("error", task.messageStateHandler.getClineMessages()[0].ts)
+
+		expect(coordinator.resolvePendingMistakeLimit("try smaller steps", "yesButtonClicked")).toBe(true)
+		await expect(decisionPromise).resolves.toEqual({
+			action: "continue",
+			guidance: "mistake_limit_reached: try smaller steps",
+		})
+		expect(task.messageStateHandler.getClineMessages()).toMatchObject([
+			{ type: "ask", ask: "mistake_limit_reached" },
+			{ type: "say", say: "user_feedback", text: "try smaller steps" },
+		])
+		expect(setTurnPhase).toHaveBeenLastCalledWith("streaming")
+	})
+
+	it("resolves mistake-limit no-button responses as stop decisions", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const setTurnPhase = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			setTurnPhase,
+		})
+
+		const decisionPromise = coordinator.handleConsecutiveMistakeLimitReached({
+			iteration: 4,
+			consecutiveMistakes: 3,
+			maxConsecutiveMistakes: 3,
+			reason: "tool_execution_failed",
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		expect(coordinator.resolvePendingMistakeLimit(undefined, "noButtonClicked")).toBe(true)
+
+		await expect(decisionPromise).resolves.toEqual({
+			action: "stop",
+			reason: "stopped after mistake_limit_reached prompt",
+		})
+		expect(task.messageStateHandler.getClineMessages()).toMatchObject([{ type: "ask", ask: "mistake_limit_reached" }])
+		expect(setTurnPhase).toHaveBeenLastCalledWith("streaming")
+	})
+
+	it("clears pending mistake-limit prompts as stop decisions", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		})
+
+		const decisionPromise = coordinator.handleConsecutiveMistakeLimitReached({
+			iteration: 4,
+			consecutiveMistakes: 3,
+			maxConsecutiveMistakes: 3,
+			reason: "tool_execution_failed",
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		coordinator.clearPending("Task cleared")
+
+		await expect(decisionPromise).resolves.toEqual({ action: "stop", reason: "Task cleared" })
+		expect(coordinator.resolvePendingMistakeLimit(undefined, "yesButtonClicked")).toBe(false)
+	})
+
+	it("clears pending tool approvals as rejected", async () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const recordDeniedToolApproval = vi.fn()
+		const coordinator = new SdkInteractionCoordinator({
+			messages: new SdkMessageCoordinator({ getTask: () => task }),
+			getSessionId: () => "session-123",
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			recordDeniedToolApproval,
+		})
+
+		const approvalPromise = coordinator.handleRequestToolApproval({
+			agentId: "agent",
+			conversationId: "conversation",
+			iteration: 1,
+			toolCallId: "tool-call",
+			toolName: "read_files",
+			input: {},
+			policy: { autoApprove: false },
+		})
+		await vi.waitFor(() => expect(task.messageStateHandler.getClineMessages()).toHaveLength(1))
+
+		coordinator.clearPending("Task cancelled")
+
+		await expect(approvalPromise).resolves.toEqual({ approved: false, reason: "Task cancelled" })
+		expect(recordDeniedToolApproval).toHaveBeenCalledWith("tool-call", "read_files", "Task cancelled")
+		expect(coordinator.resolvePendingToolApproval(undefined, "yesButtonClicked")).toBe(false)
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-interaction-coordinator.ts b/apps/vscode/src/sdk/sdk-interaction-coordinator.ts
new file mode 100644
index 0000000..8c19c92
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-interaction-coordinator.ts
@@ -0,0 +1,296 @@
+import type { ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision } from "@cline/shared"
+import type { ClineAskQuestion, ClineMessage, TurnPhase } from "@shared/ExtensionMessage"
+import type { ClineAskResponse } from "@shared/WebviewMessage"
+import { Logger } from "@/shared/services/Logger"
+import { MessageIdMinter } from "./message-id-minter"
+import { buildToolApprovalAskMessage } from "./message-translator"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import { DEFAULT_TOOL_APPROVAL_DENIAL_REASON } from "./tool-approval-denial"
+
+export interface ToolApprovalRequest {
+	agentId: string
+	conversationId: string
+	iteration: number
+	toolCallId: string
+	toolName: string
+	input: unknown
+	policy: { enabled?: boolean; autoApprove?: boolean }
+}
+
+export interface SdkInteractionCoordinatorOptions {
+	messages: SdkMessageCoordinator
+	getSessionId: () => string
+	postStateToWebview: () => Promise<void>
+	shouldAutoApproveTool?: (request: ToolApprovalRequest) => boolean
+	recordApprovedToolMessage?: (toolCallId: string, messageTs: number) => void
+	recordDeniedToolApproval?: (toolCallId: string, toolName: string, reason: string) => void
+	/**
+	 * The process-wide id/seq/epoch authority, shared with the message translator. Optional so
+	 * existing tests that don't need cross-generator id uniqueness keep working; when omitted a
+	 * private minter is used. Production wires the shared minter from MessageTranslatorState.
+	 */
+	getMinter?: () => MessageIdMinter
+	/**
+	 * Set the authoritative UI turn phase. Called when an approval/ask is pending
+	 * (awaiting_approval / awaiting_followup) and when the user responds (back to streaming).
+	 * Optional for tests.
+	 */
+	setTurnPhase?: (phase: TurnPhase, anchorTs?: number) => void
+}
+
+export class SdkInteractionCoordinator {
+	private pendingAskResolve: ((answer: string) => void) | undefined
+	private pendingToolApprovalResolve: ((result: { approved: boolean; reason?: string }) => void) | undefined
+	private pendingMistakeLimitResolve: ((decision: ConsecutiveMistakeLimitDecision) => void) | undefined
+	private pendingToolApprovalMessage:
+		| {
+				toolCallId: string
+				messageTs: number
+				toolName: string
+		  }
+		| undefined
+
+	constructor(private readonly options: SdkInteractionCoordinatorOptions) {}
+
+	async handleConsecutiveMistakeLimitReached(
+		context: ConsecutiveMistakeLimitContext,
+	): Promise<ConsecutiveMistakeLimitDecision> {
+		const detail = context.details?.trim()
+		const latest = detail ? `${context.reason}: ${detail}` : `${context.reason} at iteration ${context.iteration}`
+		const askMessage: ClineMessage = {
+			ts: this.nextMessageTs(),
+			type: "ask",
+			ask: "mistake_limit_reached",
+			text: `Cline ran into repeated tool errors (${context.consecutiveMistakes}/${context.maxConsecutiveMistakes}).\n\nLatest: ${latest}`,
+			partial: false,
+		}
+
+		this.options.messages.appendAndEmit([askMessage], {
+			type: "status",
+			payload: { sessionId: this.options.getSessionId(), status: "running" },
+		})
+		this.options.setTurnPhase?.("error", askMessage.ts)
+		await this.options.postStateToWebview()
+
+		return new Promise<ConsecutiveMistakeLimitDecision>((resolve) => {
+			this.pendingMistakeLimitResolve = resolve
+		})
+	}
+
+	async handleRequestToolApproval(request: ToolApprovalRequest): Promise<{ approved: boolean; reason?: string }> {
+		if (request.policy.autoApprove === true || this.options.shouldAutoApproveTool?.(request) === true) {
+			Logger.log(`[SdkController] Auto-approving tool execution: tool=${request.toolName}`)
+			return { approved: true }
+		}
+
+		const toolAskMessage: ClineMessage = buildToolApprovalAskMessage(request.toolName, request.input, this.nextMessageTs())
+
+		this.options.messages.appendAndEmit([toolAskMessage], {
+			type: "status",
+			payload: { sessionId: this.options.getSessionId(), status: "running" },
+		})
+		this.options.setTurnPhase?.("awaiting_approval", toolAskMessage.ts)
+		await this.options.postStateToWebview()
+
+		return new Promise<{ approved: boolean; reason?: string }>((resolve) => {
+			this.pendingToolApprovalResolve = resolve
+			this.pendingToolApprovalMessage = {
+				toolCallId: request.toolCallId,
+				messageTs: toolAskMessage.ts,
+				toolName: request.toolName,
+			}
+		})
+	}
+
+	async handleAskQuestion(question: string, options: string[], _context: unknown): Promise<string> {
+		const askData: ClineAskQuestion = {
+			question,
+			options: options?.length ? options : undefined,
+		}
+		const askMessage: ClineMessage = {
+			ts: this.nextMessageTs(),
+			type: "ask",
+			ask: "followup",
+			text: JSON.stringify(askData),
+			partial: false,
+		}
+
+		this.options.messages.appendAndEmit([askMessage], {
+			type: "status",
+			payload: { sessionId: this.options.getSessionId(), status: "running" },
+		})
+		this.options.setTurnPhase?.("awaiting_followup", askMessage.ts)
+		await this.options.postStateToWebview()
+
+		return new Promise<string>((resolve) => {
+			this.pendingAskResolve = resolve
+		})
+	}
+
+	resolvePendingToolApproval(
+		prompt: string | undefined,
+		responseType: ClineAskResponse | undefined,
+		images?: string[],
+		files?: string[],
+	): boolean {
+		if (!this.pendingToolApprovalResolve) {
+			return false
+		}
+
+		const resolve = this.pendingToolApprovalResolve
+		const pendingMessage = this.pendingToolApprovalMessage
+
+		if (responseType === "messageResponse") {
+			Logger.log("[SdkController] Leaving pending tool approval open and routing user message as queued follow-up")
+			this.options.setTurnPhase?.("awaiting_approval", pendingMessage?.messageTs)
+			// The approval remains pending. The chat message still needs normal follow-up routing.
+			return false
+		}
+
+		this.pendingToolApprovalResolve = undefined
+		this.pendingToolApprovalMessage = undefined
+
+		const approved = responseType === "yesButtonClicked"
+		Logger.log(`[SdkController] Resolving pending tool approval: approved=${approved} (responseType=${responseType})`)
+		if (approved && pendingMessage) {
+			this.options.recordApprovedToolMessage?.(pendingMessage.toolCallId, pendingMessage.messageTs)
+		}
+
+		// Approved or rejected by approval controls, the agent resumes its turn and returns to streaming.
+		// On rejection the agent receives the denial and continues; the SDK drives the next phase.
+		this.options.setTurnPhase?.("streaming")
+		const denialReason = prompt || DEFAULT_TOOL_APPROVAL_DENIAL_REASON
+		if (!approved && (prompt?.trim() || images?.length || files?.length)) {
+			const userMessage: ClineMessage = {
+				ts: this.nextMessageTs(),
+				type: "say",
+				say: "user_feedback",
+				text: prompt ?? "",
+				images,
+				files,
+				partial: false,
+			}
+			this.options.messages.appendAndEmit([userMessage], {
+				type: "status",
+				payload: { sessionId: this.options.getSessionId(), status: "running" },
+			})
+		}
+		if (!approved && pendingMessage) {
+			this.options.recordDeniedToolApproval?.(pendingMessage.toolCallId, pendingMessage.toolName, denialReason)
+		}
+		resolve({
+			approved,
+			...(approved ? {} : { reason: denialReason }),
+		})
+		return true
+	}
+
+	resolvePendingAskQuestion(prompt: string | undefined): boolean {
+		if (!this.pendingAskResolve) {
+			return false
+		}
+
+		const resolve = this.pendingAskResolve
+		this.pendingAskResolve = undefined
+		const responseText = prompt ?? ""
+		Logger.log(`[SdkController] Resolving pending ask_question with: "${responseText.substring(0, 80)}"`)
+
+		if (responseText) {
+			const userMessage: ClineMessage = {
+				ts: this.nextMessageTs(),
+				type: "say",
+				say: "user_feedback",
+				text: responseText,
+				partial: false,
+			}
+			this.options.messages.appendAndEmit([userMessage], {
+				type: "status",
+				payload: { sessionId: this.options.getSessionId(), status: "running" },
+			})
+		}
+
+		// User answered the follow-up — the agent resumes its turn.
+		this.options.setTurnPhase?.("streaming")
+		resolve(responseText)
+		return true
+	}
+
+	resolvePendingMistakeLimit(prompt: string | undefined, responseType: ClineAskResponse | undefined): boolean {
+		if (!this.pendingMistakeLimitResolve) {
+			return false
+		}
+
+		const resolve = this.pendingMistakeLimitResolve
+		this.pendingMistakeLimitResolve = undefined
+		this.options.setTurnPhase?.("streaming")
+
+		if (responseType === "noButtonClicked") {
+			resolve({ action: "stop", reason: "stopped after mistake_limit_reached prompt" })
+			return true
+		}
+
+		const trimmedPrompt = prompt?.trim()
+		if (trimmedPrompt) {
+			const userMessage: ClineMessage = {
+				ts: this.nextMessageTs(),
+				type: "say",
+				say: "user_feedback",
+				text: trimmedPrompt,
+				partial: false,
+			}
+			this.options.messages.appendAndEmit([userMessage], {
+				type: "status",
+				payload: { sessionId: this.options.getSessionId(), status: "running" },
+			})
+		}
+
+		const guidance = trimmedPrompt
+			? `mistake_limit_reached: ${trimmedPrompt}`
+			: "mistake_limit_reached: retry with a different approach, validate tool parameters before calls, and avoid repeating failed steps."
+
+		resolve({ action: "continue", guidance })
+		return true
+	}
+
+	clearPending(reason: string): void {
+		this.pendingAskResolve = undefined
+		if (this.pendingMistakeLimitResolve) {
+			this.pendingMistakeLimitResolve({ action: "stop", reason })
+			this.pendingMistakeLimitResolve = undefined
+		}
+		const pendingMessage = this.pendingToolApprovalMessage
+		this.pendingToolApprovalMessage = undefined
+		if (this.pendingToolApprovalResolve) {
+			// Record before resolving: the denial unblocks the core, which emits the
+			// tool's lifecycle events before the caller's abort lands. Unless the
+			// denial is already recorded, the translator renders those events as a
+			// second tool row next to the still-visible approval ask.
+			if (pendingMessage) {
+				this.options.recordDeniedToolApproval?.(pendingMessage.toolCallId, pendingMessage.toolName, reason)
+			}
+			this.pendingToolApprovalResolve({ approved: false, reason })
+			this.pendingToolApprovalResolve = undefined
+		}
+	}
+
+	/**
+	 * Mint a unique message id from the SHARED minter so interaction messages (tool-approval
+	 * asks, ask_question, user_feedback) never collide with translator-minted ids. Falls back to
+	 * a private minter when none is wired (tests).
+	 */
+	private nextMessageTs(): number {
+		return this.getMinter().nextId()
+	}
+
+	private fallbackMinter: MessageIdMinter | undefined
+	private getMinter(): MessageIdMinter {
+		if (this.options.getMinter) {
+			return this.options.getMinter()
+		}
+		if (!this.fallbackMinter) {
+			// Lazy import-free fallback: construct on first use.
+			this.fallbackMinter = new MessageIdMinter()
+		}
+		return this.fallbackMinter
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-mcp-coordinator.test.ts b/apps/vscode/src/sdk/sdk-mcp-coordinator.test.ts
new file mode 100644
index 0000000..fee94f4
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-mcp-coordinator.test.ts
@@ -0,0 +1,172 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { StateManager } from "@/core/storage/StateManager"
+import { SdkMcpCoordinator, type SdkMcpCoordinatorOptions } from "./sdk-mcp-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("SdkMcpCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("does nothing when MCP tools change without an active session", () => {
+		const { coordinator, options } = makeCoordinator()
+
+		coordinator.handleToolListChanged()
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+	})
+
+	it("defers MCP restart while the active session is running", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		coordinator.handleToolListChanged()
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+
+		activeSession.isRunning = false
+		coordinator.checkDeferredRestart()
+
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce())
+	})
+
+	it("restarts immediately when MCP tools change while the active session is idle", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		coordinator.handleToolListChanged()
+
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce())
+		// Reloading tools is silent: only a status transition is emitted, no chat message.
+		expect(options.messages.emitSessionEvents).toHaveBeenCalledWith([], {
+			type: "status",
+			payload: { sessionId: "old-session", status: "running" },
+		})
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+	})
+
+	it("rebuilds the active session with the current mode and preserved messages", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession, mode: "plan" })
+
+		await coordinator.restartSessionForMcpTools()
+
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({ cwd: "/workspace", mode: "plan" })
+		expect(options.loadInitialMessages).toHaveBeenCalledWith(activeSession.sdkHost, "old-session")
+		expect(options.buildStartSessionInput).toHaveBeenCalledWith(expect.objectContaining({ sessionId: "old-session" }), {
+			cwd: "/workspace",
+			mode: "plan",
+		})
+		expect(options.sessions.replaceActiveSession).toHaveBeenCalledWith({
+			startInput: { prompt: "start" },
+			initialMessages: [{ role: "user", content: "hello" }],
+			disposeReason: "mcpToolRestart",
+		})
+		// Success is silent: only a status transition back to idle, no chat
+		// message or completion banner.
+		expect(options.messages.emitSessionEvents).toHaveBeenCalledWith([], {
+			type: "status",
+			payload: { sessionId: "new-session", status: "idle" },
+		})
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("emits an error message when restart fails", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		options.sessions.replaceActiveSession.mockRejectedValue(new Error("boom"))
+
+		await coordinator.restartSessionForMcpTools()
+
+		expect(options.messages.appendAndEmit).toHaveBeenLastCalledWith(
+			[
+				expect.objectContaining({
+					type: "say",
+					say: "error",
+					text: "Failed to reload MCP tools: boom. MCP tools may be outdated.",
+				}),
+			],
+			{ type: "status", payload: { sessionId: "old-session", status: "error" } },
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const activeSession = input.activeSession
+	const config = {
+		providerId: "anthropic",
+		modelId: "claude",
+		apiKey: "key",
+	}
+	const options = {
+		stateManager: {
+			getGlobalSettingsKey: vi.fn(() => input.mode ?? "act"),
+		} as unknown as StateManager,
+		sessions: {
+			getActiveSession: vi.fn(() => activeSession),
+			replaceActiveSession: vi.fn().mockResolvedValue({
+				startResult: { sessionId: "new-session" },
+				sdkHost: { send: vi.fn() },
+			}),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+			emitSessionEvents: vi.fn(),
+		},
+		sessionConfigBuilder: {
+			build: vi.fn().mockResolvedValue(config),
+		},
+		getWorkspaceRoot: vi.fn().mockResolvedValue("/workspace"),
+		loadInitialMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		buildStartSessionInput: vi.fn(() => ({ prompt: "start" })),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+	} as unknown as SdkMcpCoordinatorOptions & {
+		stateManager: StateManager & { getGlobalSettingsKey: ReturnType<typeof vi.fn> }
+		sessions: SdkMcpCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			replaceActiveSession: ReturnType<typeof vi.fn>
+		}
+		messages: SdkMcpCoordinatorOptions["messages"] & {
+			appendAndEmit: ReturnType<typeof vi.fn>
+			emitSessionEvents: ReturnType<typeof vi.fn>
+		}
+		sessionConfigBuilder: SdkMcpCoordinatorOptions["sessionConfigBuilder"] & { build: ReturnType<typeof vi.fn> }
+		getWorkspaceRoot: ReturnType<typeof vi.fn>
+		loadInitialMessages: ReturnType<typeof vi.fn>
+		buildStartSessionInput: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkMcpCoordinator(options),
+		options,
+	}
+}
+
+interface MakeCoordinatorInput {
+	activeSession: ReturnType<typeof makeActiveSession>
+	mode: "act" | "plan"
+}
+
+function makeActiveSession(input: { isRunning?: boolean } = {}) {
+	return {
+		sessionId: "old-session",
+		sdkHost: {
+			send: vi.fn(),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		},
+		unsubscribe: vi.fn(),
+		startResult: { sessionId: "old-session" },
+		isRunning: input.isRunning ?? false,
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-mcp-coordinator.ts b/apps/vscode/src/sdk/sdk-mcp-coordinator.ts
new file mode 100644
index 0000000..5fa2f56
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-mcp-coordinator.ts
@@ -0,0 +1,137 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+import type { StateManager } from "@/core/storage/StateManager"
+import { Logger } from "@/shared/services/Logger"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { SdkSessionHost } from "./session-host"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+type StartInput = Parameters<VscodeSessionHost["start"]>[0]
+type InitialMessages = StartInput["initialMessages"]
+type SessionConfig = Awaited<ReturnType<SdkSessionConfigBuilder["build"]>>
+
+export interface SdkMcpCoordinatorOptions {
+	stateManager: StateManager
+	sessions: SdkSessionLifecycle
+	messages: SdkMessageCoordinator
+	sessionConfigBuilder: SdkSessionConfigBuilder
+	getWorkspaceRoot: () => Promise<string>
+	loadInitialMessages: (sdkHost: SdkSessionHost, sessionId: string) => Promise<unknown[] | undefined>
+	buildStartSessionInput: (config: SessionConfig, input: { cwd: string; mode: Mode }) => StartInput
+	postStateToWebview: () => Promise<void>
+}
+
+export class SdkMcpCoordinator {
+	private restartPending = false
+
+	constructor(private readonly options: SdkMcpCoordinatorOptions) {}
+
+	handleToolListChanged(): void {
+		Logger.log("[SdkController] MCP tool list changed")
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			Logger.log("[SdkController] No active session - tools will be picked up on next initTask")
+			return
+		}
+
+		if (activeSession.isRunning) {
+			Logger.log("[SdkController] Session is mid-turn - deferring MCP tool restart")
+			this.restartPending = true
+			return
+		}
+
+		this.restartSessionForMcpTools().catch((error) => {
+			Logger.error("[SdkController] Failed to restart session for MCP tools:", error)
+		})
+	}
+
+	checkDeferredRestart(): void {
+		if (!this.restartPending) {
+			return
+		}
+		this.restartPending = false
+
+		if (!this.options.sessions.getActiveSession()) {
+			Logger.log("[SdkController] Deferred MCP restart: no active session, skipping")
+			return
+		}
+
+		Logger.log("[SdkController] Executing deferred MCP tool restart")
+		this.restartSessionForMcpTools().catch((error) => {
+			Logger.error("[SdkController] Failed deferred MCP tool restart:", error)
+		})
+	}
+
+	async restartSessionForMcpTools(): Promise<void> {
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			return
+		}
+
+		const { sdkHost: oldManager, sessionId: oldSessionId } = activeSession
+
+		Logger.log(`[SdkController] Restarting session ${oldSessionId} for MCP tool changes`)
+
+		// Reloading tools is a silent, behind-the-scenes operation — it should
+		// "just work" without spamming the chat. Emit only the status transition
+		// (no chat message), so toggling several servers doesn't pile up notices.
+		this.options.messages.emitSessionEvents([], {
+			type: "status",
+			payload: { sessionId: oldSessionId, status: "running" },
+		})
+
+		try {
+			const cwd = await this.options.getWorkspaceRoot()
+			const modeValue = this.options.stateManager.getGlobalSettingsKey("mode")
+			const mode: Mode = modeValue === "plan" || modeValue === "act" ? modeValue : "act"
+			const config = await this.options.sessionConfigBuilder.build({ cwd, mode })
+			config.sessionId = oldSessionId
+
+			const initialMessages = await this.options.loadInitialMessages(oldManager, oldSessionId)
+			const startInput = this.options.buildStartSessionInput(config, { cwd, mode })
+			const restartResult = await this.options.sessions.replaceActiveSession({
+				startInput,
+				initialMessages: initialMessages as InitialMessages,
+				disposeReason: "mcpToolRestart",
+			})
+			if (!restartResult) {
+				return
+			}
+			const { startResult } = restartResult
+
+			if (startResult.sessionId !== oldSessionId) {
+				Logger.warn(
+					`[SdkController] MCP tool restart returned a new session ID (${startResult.sessionId}); preserving task ID ${oldSessionId} for UI continuity`,
+				)
+			}
+
+			// Silently return the session to idle — no "reloaded successfully"
+			// chat message or completion banner. The reload is transparent.
+			this.options.messages.emitSessionEvents([], {
+				type: "status",
+				payload: { sessionId: startResult.sessionId, status: "idle" },
+			})
+
+			await this.options.postStateToWebview()
+			Logger.log(`[SdkController] Session restarted for MCP tools: ${oldSessionId} -> ${startResult.sessionId}`)
+		} catch (error) {
+			Logger.error("[SdkController] Failed to restart session for MCP tools:", error)
+
+			const errorMessage: ClineMessage = {
+				ts: Date.now(),
+				type: "say",
+				say: "error",
+				text: `Failed to reload MCP tools: ${error instanceof Error ? error.message : String(error)}. MCP tools may be outdated.`,
+				partial: false,
+			}
+			this.options.messages.appendAndEmit([errorMessage], {
+				type: "status",
+				payload: { sessionId: oldSessionId, status: "error" },
+			})
+			await this.options.postStateToWebview()
+		}
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-message-coordinator.test.ts b/apps/vscode/src/sdk/sdk-message-coordinator.test.ts
new file mode 100644
index 0000000..a787458
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-message-coordinator.test.ts
@@ -0,0 +1,124 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { describe, expect, it, vi } from "vitest"
+import { MessageIdMinter } from "./message-id-minter"
+import { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import { createTaskProxy } from "./task-proxy"
+
+vi.mock("./webview-grpc-bridge", () => ({
+	pushMessageToWebview: vi.fn().mockResolvedValue(undefined),
+}))
+
+describe("SdkMessageCoordinator", () => {
+	it("registers and removes session event listeners", () => {
+		const coordinator = new SdkMessageCoordinator({ getTask: () => undefined })
+		const listener = vi.fn()
+		const event = { type: "status", payload: { sessionId: "s1", status: "running" } }
+		const messages = [{ ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false }]
+
+		const unsubscribe = coordinator.onSessionEvent(listener)
+		// biome-ignore lint/suspicious/noExplicitAny: test-only event shape
+		coordinator.emitSessionEvents(messages, event as any)
+		unsubscribe()
+		// biome-ignore lint/suspicious/noExplicitAny: test-only event shape
+		coordinator.emitSessionEvents(messages, event as any)
+
+		expect(listener).toHaveBeenCalledTimes(1)
+		expect(listener).toHaveBeenCalledWith(messages, event)
+	})
+
+	it("appends messages to the current task", () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkMessageCoordinator({ getTask: () => task })
+		const messages = [{ ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false }]
+
+		coordinator.appendMessages(messages)
+
+		expect(task.messageStateHandler.getClineMessages()).toEqual(messages)
+	})
+
+	it("appends and emits messages in order", () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkMessageCoordinator({ getTask: () => task })
+		const listener = vi.fn()
+		const event = { type: "status", payload: { sessionId: "s1", status: "running" } }
+		const messages = [{ ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false }]
+
+		coordinator.onSessionEvent(listener)
+		// biome-ignore lint/suspicious/noExplicitAny: test-only event shape
+		coordinator.appendAndEmit(messages, event as any)
+
+		expect(task.messageStateHandler.getClineMessages()).toEqual(messages)
+		expect(listener).toHaveBeenCalledWith(messages, event)
+	})
+
+	it("finalizes partial messages and marks the last open API request as cancelled", () => {
+		const coordinator = new SdkMessageCoordinator({ getTask: () => undefined })
+		const finalized = coordinator.finalizeMessagesForSave([
+			{ ts: 1, type: "say", say: "api_req_started", text: JSON.stringify({ cost: 0.1 }), partial: true },
+			{ ts: 2, type: "say", say: "text", text: "streaming", partial: true },
+			{ ts: 3, type: "say", say: "api_req_started", text: JSON.stringify({}), partial: true },
+		])
+
+		expect(finalized[0].partial).toBeUndefined()
+		expect(JSON.parse(finalized[0].text ?? "{}")).toEqual({ cost: 0.1 })
+		expect(finalized[1].partial).toBeUndefined()
+		expect(finalized[2].partial).toBeUndefined()
+		expect(JSON.parse(finalized[2].text ?? "{}")).toEqual({ cancelReason: "user_cancelled" })
+	})
+
+	it("stamps seq and epoch from the shared minter on append", () => {
+		const minter = new MessageIdMinter()
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkMessageCoordinator({ getTask: () => task, getMinter: () => minter })
+
+		const a: ClineMessage = { ts: 1, type: "say" as const, say: "text" as const, text: "a", partial: true }
+		const b: ClineMessage = { ts: 2, type: "say" as const, say: "text" as const, text: "b", partial: false }
+		coordinator.appendMessages([a, b])
+
+		// Both got the current epoch, and seq strictly increases in append order.
+		expect(a.epoch).toBe(0)
+		expect(b.epoch).toBe(0)
+		expect(typeof a.seq).toBe("number")
+		expect((b.seq ?? 0) > (a.seq ?? 0)).toBe(true)
+	})
+
+	it("gives an updated message a NEWER seq than its earlier copy (partial -> final)", () => {
+		const minter = new MessageIdMinter()
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkMessageCoordinator({ getTask: () => task, getMinter: () => minter })
+
+		const partial: ClineMessage = { ts: 10, type: "say" as const, say: "text" as const, text: "Hel", partial: true }
+		coordinator.appendMessages([partial])
+		const partialSeq = partial.seq ?? 0
+
+		// A new copy with the SAME ts (identity) passes through again on finalize.
+		const final: ClineMessage = { ts: 10, type: "say" as const, say: "text" as const, text: "Hello", partial: false }
+		coordinator.appendMessages([final])
+
+		expect((final.seq ?? 0) > partialSeq).toBe(true)
+	})
+
+	it("reflects a bumped epoch on subsequent messages", () => {
+		const minter = new MessageIdMinter()
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkMessageCoordinator({ getTask: () => task, getMinter: () => minter })
+
+		const before: ClineMessage = { ts: 1, type: "say" as const, say: "text" as const, text: "before", partial: false }
+		coordinator.appendMessages([before])
+		minter.bumpEpoch()
+		const after: ClineMessage = { ts: 2, type: "say" as const, say: "text" as const, text: "after", partial: false }
+		coordinator.appendMessages([after])
+
+		expect(before.epoch).toBe(0)
+		expect(after.epoch).toBe(1)
+	})
+
+	it("leaves messages unstamped when no minter is wired (classic/legacy)", () => {
+		const task = createTaskProxy("session-123", vi.fn(), vi.fn())
+		const coordinator = new SdkMessageCoordinator({ getTask: () => task })
+		const m: ClineMessage = { ts: 1, type: "say" as const, say: "text" as const, text: "x", partial: false }
+		coordinator.appendMessages([m])
+		expect(m.seq).toBeUndefined()
+		expect(m.epoch).toBeUndefined()
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-message-coordinator.ts b/apps/vscode/src/sdk/sdk-message-coordinator.ts
new file mode 100644
index 0000000..65a4fc6
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-message-coordinator.ts
@@ -0,0 +1,139 @@
+import type { CoreSessionEvent } from "@cline/core"
+import type { ClineApiReqInfo, ClineMessage } from "@shared/ExtensionMessage"
+import { Logger } from "@/shared/services/Logger"
+import type { MessageIdMinter } from "./message-id-minter"
+import type { TaskProxy } from "./task-proxy"
+import { pushMessageToWebview } from "./webview-grpc-bridge"
+
+export type SessionEventListener = (messages: ClineMessage[], event: CoreSessionEvent) => void
+
+export interface SdkMessageCoordinatorOptions {
+	getTask: () => TaskProxy | undefined
+	/**
+	 * The process-wide id/seq/epoch authority. When provided, every message flowing to the
+	 * webview is stamped with a fresh `seq` and the current `epoch` so the webview can merge
+	 * convergently and fence stale traffic. Optional for tests.
+	 */
+	getMinter?: () => MessageIdMinter
+}
+
+export class SdkMessageCoordinator {
+	private readonly sessionEventListeners = new Set<SessionEventListener>()
+	private saveClineMessagesTimer: ReturnType<typeof setTimeout> | undefined
+
+	constructor(private readonly options: SdkMessageCoordinatorOptions) {}
+
+	/**
+	 * Stamp `seq` (freshness) and `epoch` (fence) on each message IN PLACE, synchronously,
+	 * before it is stored or emitted. The same object references are added to the message state
+	 * handler AND emitted through the partial stream, so both channels carry identical stamps.
+	 * A message that is updated (partial → final, same id) passes through again and gets a NEW,
+	 * higher `seq`, so the webview always keeps the freshest copy regardless of arrival order.
+	 */
+	private stamp(messages: ClineMessage[]): void {
+		const minter = this.options.getMinter?.()
+		if (!minter) {
+			return
+		}
+		const epoch = minter.epoch
+		for (const message of messages) {
+			message.seq = minter.nextSeq()
+			message.epoch = epoch
+		}
+	}
+
+	dispose(): void {
+		this.cancelPendingSave()
+		this.sessionEventListeners.clear()
+	}
+
+	cancelPendingSave(): void {
+		if (this.saveClineMessagesTimer) {
+			clearTimeout(this.saveClineMessagesTimer)
+			this.saveClineMessagesTimer = undefined
+		}
+	}
+
+	onSessionEvent(listener: SessionEventListener): () => void {
+		this.sessionEventListeners.add(listener)
+		return () => {
+			this.sessionEventListeners.delete(listener)
+		}
+	}
+
+	emitSessionEvents(messages: ClineMessage[], event: CoreSessionEvent): void {
+		for (const listener of this.sessionEventListeners) {
+			try {
+				listener(messages, event)
+			} catch (error) {
+				Logger.error("[SdkController] Error in session event listener:", error)
+			}
+		}
+	}
+
+	appendMessages(messages: ClineMessage[]): void {
+		// Stamp seq/epoch BEFORE storing/emitting so both the message-state handler and the
+		// partial-message stream carry identical, freshness-ordered, epoch-fenced messages.
+		this.stamp(messages)
+
+		const task = this.options.getTask()
+		if (!task?.messageStateHandler) {
+			return
+		}
+
+		task.messageStateHandler.addMessages(messages)
+	}
+
+	replaceMessages(messages: ClineMessage[]): void {
+		this.stamp(messages)
+
+		const task = this.options.getTask()
+		if (!task?.messageStateHandler) {
+			return
+		}
+
+		task.messageStateHandler.replaceMessages(messages)
+	}
+
+	appendAndEmit(messages: ClineMessage[], event: CoreSessionEvent): void {
+		this.appendMessages(messages)
+		this.emitSessionEvents(messages, event)
+	}
+
+	emitHookMessage(message: ClineMessage): void {
+		this.appendMessages([message])
+		pushMessageToWebview(message).catch(() => {})
+	}
+
+	/**
+	 * Finalize messages for saving to disk when a task is being cleared.
+	 * - Strips `partial` flags so the UI doesn't show a streaming/cancel state
+	 * - Updates the last `api_req_started` with a cancel reason if it has no cost
+	 */
+	finalizeMessagesForSave(messages: ClineMessage[]): ClineMessage[] {
+		return messages.map((msg, index) => {
+			const updated = { ...msg }
+
+			if (updated.partial) {
+				delete updated.partial
+			}
+
+			if (updated.type === "say" && updated.say === "api_req_started") {
+				try {
+					const info: ClineApiReqInfo = JSON.parse(updated.text || "{}")
+					if (info.cost === undefined && info.cancelReason === undefined) {
+						const isLast = !messages.slice(index + 1).some((m) => m.type === "say" && m.say === "api_req_started")
+						if (isLast) {
+							info.cancelReason = "user_cancelled"
+							updated.text = JSON.stringify(info)
+						}
+					}
+				} catch {
+					// Ignore parse errors from legacy or malformed messages.
+				}
+			}
+
+			return updated
+		})
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-mode-coordinator.test.ts b/apps/vscode/src/sdk/sdk-mode-coordinator.test.ts
new file mode 100644
index 0000000..b0208e3
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-mode-coordinator.test.ts
@@ -0,0 +1,602 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { StateManager } from "@/core/storage/StateManager"
+import { SdkModeCoordinator, type SdkModeCoordinatorOptions } from "./sdk-mode-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		debug: vi.fn(),
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+vi.mock("@core/storage/disk", () => ({
+	saveClineMessages: vi.fn().mockResolvedValue(undefined),
+}))
+
+describe("SdkModeCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("applies a queued switch_to_act_mode change and auto-continues the task", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, state, options } = makeCoordinator({ activeSession })
+
+		coordinator.queueSwitchToActMode()
+		expect(coordinator.hasPendingModeChange()).toBe(true)
+
+		await coordinator.applyPendingModeChange()
+
+		expect(coordinator.hasPendingModeChange()).toBe(false)
+		expect(state.mode).toBe("act")
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(true)
+		expect(options.onAutoContinueStarting).toHaveBeenCalledOnce()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.anything(),
+			"new-session",
+			"The user approved switching to act mode. Continue with the approved plan now.",
+			undefined,
+			undefined,
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("preserves pending input by returning false when toggling mode without an active session", async () => {
+		const { coordinator, state, options } = makeCoordinator({ mode: "act" })
+
+		await expect(coordinator.togglePlanActMode("plan")).resolves.toBe(false)
+
+		expect(state.mode).toBe("plan")
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("returns false without side effects when toggling to the current mode", async () => {
+		const { coordinator, options } = makeCoordinator({ mode: "plan" })
+
+		await expect(coordinator.togglePlanActMode("plan")).resolves.toBe(false)
+
+		expect(options.stateManager.setGlobalState).not.toHaveBeenCalled()
+		expect(options.postStateToWebview).not.toHaveBeenCalled()
+	})
+
+	it("rebuilds an active session for the new mode while preserving the session id", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options } = makeCoordinator({ activeSession, task })
+
+		await coordinator.rebuildSessionForMode("plan")
+
+		expect(options.loadInitialMessages).toHaveBeenCalledWith(activeSession.sdkHost, "old-session")
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({
+			cwd: "/workspace",
+			mode: "plan",
+		})
+		expect(options.buildStartSessionInput).toHaveBeenCalledWith(expect.objectContaining({ sessionId: "old-session" }), {
+			cwd: "/workspace",
+			mode: "plan",
+		})
+		expect(options.sessions.replaceActiveSession).toHaveBeenCalledWith({
+			startInput: { prompt: "start" },
+			initialMessages: [{ role: "user", content: "hello" }],
+			disposeReason: "modeChange",
+		})
+		expect(task.taskId).toBe("new-session")
+		expect(options.resetMessageTranslator).toHaveBeenCalledOnce()
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("auto-continues a plan -> act toggle when the agent is idle after presenting its plan", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+
+		// No typed input was consumed, so the webview should not clear it.
+		await expect(coordinator.togglePlanActMode("act")).resolves.toBe(false)
+
+		expect(state.mode).toBe("act")
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(true)
+		expect(options.onAutoContinueStarting).toHaveBeenCalledOnce()
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.anything(),
+			"new-session",
+			"The user approved switching to act mode. Continue with the approved plan now.",
+			undefined,
+			undefined,
+		)
+		// Canned prompt is not echoed as a user message.
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+	})
+
+	it("submits typed chatContent as the continuation when toggling plan -> act on a presented plan", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+
+		// Typed input was consumed, so the webview should clear it.
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "  go ahead and implement step 1  ",
+				images: [],
+				files: [],
+			}),
+		).resolves.toBe(true)
+
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.anything(),
+			"new-session",
+			"go ahead and implement step 1",
+			undefined,
+			undefined,
+		)
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "user_feedback", text: "go ahead and implement step 1" })],
+			expect.anything(),
+		)
+	})
+
+	it("forwards attachments alongside the typed message when auto-continuing", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "use this screenshot",
+				images: ["data:image/png;base64,abc"],
+				files: ["/tmp/notes.md"],
+			}),
+		).resolves.toBe(true)
+
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.anything(),
+			"new-session",
+			"use this screenshot",
+			["data:image/png;base64,abc"],
+			["/tmp/notes.md"],
+		)
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					say: "user_feedback",
+					text: "use this screenshot",
+					images: ["data:image/png;base64,abc"],
+					files: ["/tmp/notes.md"],
+				}),
+			],
+			expect.anything(),
+		)
+	})
+
+	it("consumes attachment-only chatContent and sends it with the canned prompt", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+
+		// Attachments alone count as consumed content, so the webview clears them.
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: undefined,
+				images: ["data:image/png;base64,abc"],
+				files: [],
+			}),
+		).resolves.toBe(true)
+
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.anything(),
+			"new-session",
+			"The user approved switching to act mode. Continue with the approved plan now.",
+			["data:image/png;base64,abc"],
+			undefined,
+		)
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					say: "user_feedback",
+					text: "",
+					images: ["data:image/png;base64,abc"],
+				}),
+			],
+			expect.anything(),
+		)
+	})
+
+	it("resets the running state and reports an error phase when the continuation send setup fails", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+		options.resolveContextMentions.mockRejectedValueOnce(new Error("mention resolution failed"))
+
+		// The send never happened, so the webview must keep the composer content.
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "see @/broken/path",
+				images: [],
+				files: [],
+			}),
+		).resolves.toBe(false)
+
+		expect(options.onAutoContinueStarting).toHaveBeenCalledOnce()
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+		// The optimistic running flip is undone and the phase moves to error.
+		expect(options.sessions.setRunning).toHaveBeenLastCalledWith(false)
+		expect(options.onAutoContinueFailed).toHaveBeenCalledOnce()
+		// Mentions resolve before the echo, so the unsent message is never
+		// echoed into the transcript; only the error message is appended.
+		expect(options.messages.appendAndEmit).toHaveBeenCalledOnce()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "error" })],
+			expect.anything(),
+		)
+		// The session WAS replaced with act-mode tools before the throw, so the
+		// mode setting must not roll back.
+		expect(state.mode).toBe("act")
+	})
+
+	it("does not auto-continue while a follow-up question is pending", async () => {
+		// handleAskQuestion sets the phase to awaiting_followup but blocks the
+		// turn mid-run, so the session is still flagged running.
+		const activeSession = makeActiveSession({ isRunning: true })
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "use postgres",
+				images: [],
+				files: [],
+			}),
+		).resolves.toBe(false)
+
+		expect(state.mode).toBe("act")
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+		expect(options.onAutoContinueStarting).not.toHaveBeenCalled()
+	})
+
+	it("does not auto-continue a plan -> act toggle while a turn is running", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "streaming",
+		})
+
+		await expect(coordinator.togglePlanActMode("act")).resolves.toBe(false)
+
+		expect(state.mode).toBe("act")
+		expect(options.sessions.setRunning).not.toHaveBeenCalledWith(true)
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+	})
+
+	it("preserves typed chatContent when the agent has not presented a plan", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "completed",
+		})
+
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "  go ahead and implement step 1  ",
+				images: [],
+				files: [],
+			}),
+		).resolves.toBe(false)
+
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+	})
+
+	it("does not auto-continue on act -> plan toggle even when the agent is awaiting followup", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "act",
+			turnPhase: "awaiting_followup",
+		})
+
+		await coordinator.togglePlanActMode("plan", {
+			message: "draft message",
+			images: [],
+			files: [],
+		})
+
+		expect(state.mode).toBe("plan")
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+	})
+
+	it("does not mark a live continuation as failed when the post-send state post rejects", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+		options.postStateToWebview.mockRejectedValueOnce(new Error("webview gone"))
+
+		// The continuation was already handed to the session, so the composer
+		// content counts as consumed and the run must not be flagged as failed.
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "go ahead",
+				images: [],
+				files: [],
+			}),
+		).resolves.toBe(true)
+
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledOnce()
+		expect(options.sessions.setRunning).not.toHaveBeenCalledWith(false)
+		expect(options.onAutoContinueFailed).not.toHaveBeenCalled()
+		// Only the user_feedback echo was emitted, no mode-switch error message.
+		expect(options.messages.appendAndEmit).toHaveBeenCalledOnce()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "user_feedback", text: "go ahead" })],
+			expect.anything(),
+		)
+	})
+
+	it("preserves composer content when the rebuild aborts on a cline auth error", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+			config: {
+				providerId: "cline",
+				modelId: "cline-model",
+				apiKey: undefined,
+			},
+		})
+
+		// The auth guard returns before the continuation is echoed or sent, so
+		// the webview must not clear the typed message or attachments.
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "go ahead but skip step 3",
+				images: ["data:image/png;base64,abc"],
+				files: [],
+			}),
+		).resolves.toBe(false)
+
+		expect(options.emitClineAuthError).toHaveBeenCalledOnce()
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		// The old plan session is still active, so the mode setting rolls back.
+		expect(state.mode).toBe("plan")
+	})
+
+	it("rolls back the mode when the rebuild fails before the session is replaced", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("old-session")
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task,
+			mode: "plan",
+			turnPhase: "awaiting_followup",
+		})
+		options.loadInitialMessages.mockRejectedValueOnce(new Error("disk read failed"))
+
+		await expect(
+			coordinator.togglePlanActMode("act", {
+				message: "go ahead",
+				images: [],
+				files: [],
+			}),
+		).resolves.toBe(false)
+
+		expect(state.mode).toBe("plan")
+		expect(options.sessions.fireAndForgetSend).not.toHaveBeenCalled()
+		expect(options.onAutoContinueFailed).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ say: "error" })],
+			expect.anything(),
+		)
+	})
+
+	it("emits an auth error and skips replacement when the target cline provider has no token", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			config: {
+				providerId: "cline",
+				modelId: "cline-model",
+				apiKey: undefined,
+			},
+		})
+
+		await coordinator.rebuildSessionForMode("act")
+
+		expect(options.emitClineAuthError).toHaveBeenCalledOnce()
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+		expect(state.mode).toBe("plan")
+	})
+
+	it("cancels and finalizes a running turn before rebuilding for mode change", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const task = makeTask("old-session", [{ ts: 1, type: "say", say: "text", text: "partial", partial: true }])
+		const { coordinator, options } = makeCoordinator({ activeSession, task })
+
+		await coordinator.rebuildSessionForMode("act")
+
+		expect(options.interactions.clearPending).toHaveBeenCalledWith("Mode changed")
+		expect(options.messages.cancelPendingSave).toHaveBeenCalledOnce()
+		expect(activeSession.sdkHost.abort).toHaveBeenCalledWith("old-session")
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(false)
+		expect(options.messages.finalizeMessagesForSave).toHaveBeenCalledWith(task.messageStateHandler.getClineMessages())
+		expect(options.messages.appendMessages).toHaveBeenCalledWith([{ ts: 1, type: "say", say: "text", text: "done" }])
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const state = { mode: input.mode ?? "plan" }
+	const activeSession = input.activeSession
+	const config = {
+		providerId: "anthropic",
+		modelId: "claude",
+		apiKey: "key",
+		...input.config,
+	}
+	const options = {
+		stateManager: {
+			getGlobalSettingsKey: vi.fn((key: string) => state[key as "mode"]),
+			setGlobalState: vi.fn(async (key: string, value: string) => {
+				state[key as "mode"] = value as "act" | "plan"
+			}),
+		} as unknown as StateManager,
+		sessions: {
+			getActiveSession: vi.fn(() => activeSession),
+			replaceActiveSession: vi.fn().mockResolvedValue({
+				startResult: { sessionId: "new-session" },
+				sdkHost: { send: vi.fn() },
+			}),
+			fireAndForgetSend: vi.fn(),
+			setRunning: vi.fn(),
+		},
+		interactions: {
+			clearPending: vi.fn(),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+			appendMessages: vi.fn(),
+			cancelPendingSave: vi.fn(),
+			finalizeMessagesForSave: vi.fn(() => [{ ts: 1, type: "say", say: "text", text: "done" }]),
+		},
+		sessionConfigBuilder: {
+			build: vi.fn().mockResolvedValue(config),
+		},
+		getTask: vi.fn(() => input.task),
+		getWorkspaceRoot: vi.fn().mockResolvedValue("/workspace"),
+		loadInitialMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		buildStartSessionInput: vi.fn(() => ({ prompt: "start" })),
+		emitClineAuthError: vi.fn(),
+		resetMessageTranslator: vi.fn(),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		getTurnPhase: vi.fn(() => input.turnPhase ?? "idle"),
+		resolveContextMentions: vi.fn(async (text: string) => text),
+		onAutoContinueStarting: vi.fn(),
+		onAutoContinueFailed: vi.fn(),
+	} as unknown as SdkModeCoordinatorOptions & {
+		stateManager: StateManager & {
+			getGlobalSettingsKey: ReturnType<typeof vi.fn>
+			setGlobalState: ReturnType<typeof vi.fn>
+		}
+		sessions: SdkModeCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			fireAndForgetSend: ReturnType<typeof vi.fn>
+			replaceActiveSession: ReturnType<typeof vi.fn>
+			setRunning: ReturnType<typeof vi.fn>
+		}
+		interactions: SdkModeCoordinatorOptions["interactions"] & {
+			clearPending: ReturnType<typeof vi.fn>
+		}
+		messages: SdkModeCoordinatorOptions["messages"] & {
+			appendAndEmit: ReturnType<typeof vi.fn>
+			appendMessages: ReturnType<typeof vi.fn>
+			cancelPendingSave: ReturnType<typeof vi.fn>
+			finalizeMessagesForSave: ReturnType<typeof vi.fn>
+		}
+		sessionConfigBuilder: SdkModeCoordinatorOptions["sessionConfigBuilder"] & {
+			build: ReturnType<typeof vi.fn>
+		}
+		getTask: ReturnType<typeof vi.fn>
+		getWorkspaceRoot: ReturnType<typeof vi.fn>
+		loadInitialMessages: ReturnType<typeof vi.fn>
+		buildStartSessionInput: ReturnType<typeof vi.fn>
+		emitClineAuthError: ReturnType<typeof vi.fn>
+		resetMessageTranslator: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+		getTurnPhase: ReturnType<typeof vi.fn>
+		resolveContextMentions: ReturnType<typeof vi.fn>
+		onAutoContinueStarting: ReturnType<typeof vi.fn>
+		onAutoContinueFailed: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkModeCoordinator(options),
+		options,
+		state,
+	}
+}
+
+interface MakeCoordinatorInput {
+	mode: "act" | "plan"
+	activeSession: ReturnType<typeof makeActiveSession>
+	config: {
+		providerId: string
+		modelId: string
+		apiKey: string | undefined
+	}
+	task: ReturnType<typeof makeTask>
+	turnPhase: string
+}
+
+function makeActiveSession(input: { isRunning?: boolean } = {}) {
+	return {
+		sessionId: "old-session",
+		sdkHost: {
+			abort: vi.fn().mockResolvedValue(undefined),
+			send: vi.fn(),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		},
+		unsubscribe: vi.fn(),
+		startResult: { sessionId: "old-session" },
+		isRunning: input.isRunning ?? false,
+	}
+}
+
+function makeTask(taskId: string, messages: Array<Partial<ClineMessage>> = []) {
+	return {
+		taskId,
+		messageStateHandler: {
+			getClineMessages: vi.fn(() => messages as ClineMessage[]),
+		},
+	} as unknown as {
+		taskId: string
+		messageStateHandler: { getClineMessages: () => ClineMessage[] }
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-mode-coordinator.ts b/apps/vscode/src/sdk/sdk-mode-coordinator.ts
new file mode 100644
index 0000000..bd37ce5
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-mode-coordinator.ts
@@ -0,0 +1,345 @@
+import { getProviderAuthStorageId } from "@cline/core"
+import type { ChatContent } from "@shared/ChatContent"
+import type { ClineMessage, TurnPhase } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+import type { StateManager } from "@/core/storage/StateManager"
+import { Logger } from "@/shared/services/Logger"
+import type { SdkInteractionCoordinator } from "./sdk-interaction-coordinator"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import { isAbortError, type SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { SdkSessionHost } from "./session-host"
+import type { TaskProxy } from "./task-proxy"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+type StartInput = Parameters<VscodeSessionHost["start"]>[0]
+type InitialMessages = StartInput["initialMessages"]
+type SessionConfig = Awaited<ReturnType<SdkSessionConfigBuilder["build"]>>
+
+function usesClineAccountAuth(providerId: string): boolean {
+	return getProviderAuthStorageId(providerId) === "cline"
+}
+
+export const ACT_MODE_CONTINUATION_PROMPT = "The user approved switching to act mode. Continue with the approved plan now."
+
+export interface SdkModeCoordinatorOptions {
+	stateManager: StateManager
+	sessions: SdkSessionLifecycle
+	interactions: SdkInteractionCoordinator
+	messages: SdkMessageCoordinator
+	sessionConfigBuilder: SdkSessionConfigBuilder
+	getTask: () => TaskProxy | undefined
+	getWorkspaceRoot: () => Promise<string>
+	loadInitialMessages: (sdkHost: SdkSessionHost, sessionId: string) => Promise<unknown[]>
+	buildStartSessionInput: (config: SessionConfig, input: { cwd: string; mode: Mode }) => StartInput
+	emitClineAuthError: () => void
+	resetMessageTranslator: () => void
+	postStateToWebview: () => Promise<void>
+	/** Authoritative phase of the current turn, from the controller's TurnStateTracker. */
+	getTurnPhase: () => TurnPhase
+	resolveContextMentions: (text: string) => Promise<string>
+	/**
+	 * Called right before an auto-continue send kicks off a new turn. Mirrors
+	 * initTask/askResponse: moves the turn phase to "streaming" (footer shows
+	 * Thinking + Cancel instead of the stale awaiting_followup state) and clears
+	 * the previous turn's completion signal.
+	 */
+	onAutoContinueStarting: () => void
+	/**
+	 * Called when the rebuild throws after onAutoContinueStarting already flipped
+	 * the phase to "streaming" (e.g. resolveContextMentions failed). Moves the
+	 * phase to "error" so the footer matches the error message that was emitted,
+	 * instead of showing a phantom run.
+	 */
+	onAutoContinueFailed: () => void
+}
+
+export class SdkModeCoordinator {
+	private pendingModeChange: Mode | null = null
+	private rebuildInFlight: Promise<void> | undefined
+
+	constructor(private readonly options: SdkModeCoordinatorOptions) {}
+
+	/**
+	 * Resolves once no mode rebuild is in flight. While a rebuild runs, the
+	 * active session is torn down and replaced (and only marked running after
+	 * the continuation send), so concurrent message paths must wait on this
+	 * instead of treating the gap as "no session" and resuming a parallel
+	 * session that the rebuild would then kill.
+	 */
+	async waitForPendingRebuild(): Promise<void> {
+		while (this.rebuildInFlight) {
+			const current = this.rebuildInFlight
+			await current
+			if (this.rebuildInFlight === current) {
+				this.rebuildInFlight = undefined
+			}
+		}
+	}
+
+	queueSwitchToActMode(): void {
+		this.pendingModeChange = "act"
+	}
+
+	hasPendingModeChange(): boolean {
+		return this.pendingModeChange !== null
+	}
+
+	async applyPendingModeChange(): Promise<void> {
+		const target = this.pendingModeChange
+		if (!target) {
+			return
+		}
+		this.pendingModeChange = null
+		Logger.log(`[SdkController] applyPendingModeChange: switching to ${target}`)
+		// The tool result told the model to proceed with the plan, so rebuild with
+		// act-mode tools and auto-continue rather than waiting for another user message.
+		await this.rebuildSessionForMode(target, { autoContinue: target === "act" })
+	}
+
+	async toggleActModeForYoloMode(): Promise<boolean> {
+		const currentMode = this.options.stateManager.getGlobalSettingsKey("mode")
+		if (currentMode === "act") {
+			return false
+		}
+		await this.options.stateManager.setGlobalState("mode", "act")
+		await this.options.postStateToWebview()
+		return true
+	}
+
+	async togglePlanActMode(modeToSwitchTo: Mode, chatContent?: ChatContent): Promise<boolean> {
+		const currentMode = this.options.stateManager.getGlobalSettingsKey("mode")
+		if (currentMode === modeToSwitchTo) {
+			return false
+		}
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (activeSession) {
+			// A plan -> act toggle while the agent is idle after presenting its plan
+			// (awaiting_followup) is the user acting on that plan, so continue
+			// automatically. Any other state only updates the session configuration
+			// and waits for an explicit send. A pending ask_question also reports
+			// awaiting_followup but blocks the turn mid-run, so isRunning stays
+			// true and it cannot reach this branch.
+			const planPresented = !activeSession.isRunning && this.options.getTurnPhase() === "awaiting_followup"
+			const autoContinue = modeToSwitchTo === "act" && planPresented
+			const userPrompt = chatContent?.message?.trim() || undefined
+			const userImages = chatContent?.images?.length ? chatContent.images : undefined
+			const userFiles = chatContent?.files?.length ? chatContent.files : undefined
+			const hasUserContent = !!(userPrompt || userImages || userFiles)
+			const continuationSent = await this.rebuildSessionForMode(modeToSwitchTo, {
+				autoContinue,
+				userContinuationPrompt: autoContinue ? userPrompt : undefined,
+				userImages: autoContinue ? userImages : undefined,
+				userFiles: autoContinue ? userFiles : undefined,
+			})
+			// True tells the webview the composer content was consumed, so it clears it.
+			return continuationSent && hasUserContent
+		}
+
+		this.options.stateManager.setGlobalState("mode", modeToSwitchTo)
+		await this.options.postStateToWebview()
+		return false
+	}
+
+	/**
+	 * Returns true only when the auto-continue send was actually handed to the
+	 * session, so callers can tell consumed user content apart from rebuilds
+	 * that bailed early (auth error, disposed session, thrown rebuild).
+	 */
+	async rebuildSessionForMode(
+		newMode: Mode,
+		options: {
+			autoContinue?: boolean
+			userContinuationPrompt?: string
+			userImages?: string[]
+			userFiles?: string[]
+		} = {},
+	): Promise<boolean> {
+		const operation = this.performRebuildSessionForMode(newMode, options)
+		// Expose the full rebuild (teardown, replacement, continuation send) to
+		// waitForPendingRebuild. Errors are handled inside; the barrier only
+		// tracks completion.
+		this.rebuildInFlight = operation.then(
+			() => undefined,
+			() => undefined,
+		)
+		return operation
+	}
+
+	private async performRebuildSessionForMode(
+		newMode: Mode,
+		options: {
+			autoContinue?: boolean
+			userContinuationPrompt?: string
+			userImages?: string[]
+			userFiles?: string[]
+		},
+	): Promise<boolean> {
+		const previousMode = this.options.stateManager.getGlobalSettingsKey("mode")
+		this.options.stateManager.setGlobalState("mode", newMode)
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			await this.options.postStateToWebview()
+			return false
+		}
+
+		const { sdkHost: oldManager, sessionId: oldSessionId } = activeSession
+		const wasRunning = activeSession.isRunning
+
+		Logger.log(`[SdkController] Rebuilding session ${oldSessionId} for mode change -> ${newMode} (wasRunning=${wasRunning})`)
+
+		if (wasRunning) {
+			await this.cancelRunningTurnForModeChange(oldManager, oldSessionId)
+		}
+
+		let autoContinueStarted = false
+		let continuationSent = false
+		let sessionReplaced = false
+		try {
+			const initialMessages = await this.options.loadInitialMessages(oldManager, oldSessionId)
+			const cwd = await this.options.getWorkspaceRoot()
+			const config = await this.options.sessionConfigBuilder.build({
+				cwd,
+				mode: newMode,
+			})
+			Logger.log(
+				`[SdkController] Mode rebuild config: mode=${newMode}, provider=${config.providerId}, model=${config.modelId}, hasApiKey=${!!config.apiKey}`,
+			)
+			config.sessionId = oldSessionId
+
+			if (usesClineAccountAuth(config.providerId) && !config.apiKey) {
+				Logger.warn(
+					`[SdkController] Mode rebuild: new mode '${newMode}' provider is '${config.providerId}' but no Cline auth token - emitting auth error`,
+				)
+				// The session still runs with the old mode's tools, so roll the
+				// setting back to keep the UI toggle coherent with it.
+				this.options.stateManager.setGlobalState("mode", previousMode)
+				this.options.emitClineAuthError()
+				await this.options.postStateToWebview()
+				return false
+			}
+
+			const startInput = this.options.buildStartSessionInput(config, {
+				cwd,
+				mode: newMode,
+			})
+			const rebuildResult = await this.options.sessions.replaceActiveSession({
+				startInput,
+				initialMessages: initialMessages as InitialMessages,
+				disposeReason: "modeChange",
+			})
+			if (!rebuildResult) {
+				return false
+			}
+
+			sessionReplaced = true
+			const { sdkHost, startResult } = rebuildResult
+			const task = this.options.getTask()
+			if (task && task.taskId !== startResult.sessionId) {
+				Logger.warn(
+					`[SdkController] Mode rebuild returned a new session ID (${startResult.sessionId}); updating task proxy`,
+				)
+				task.taskId = startResult.sessionId
+			}
+
+			this.options.resetMessageTranslator()
+			if (options.autoContinue) {
+				const userPrompt = options.userContinuationPrompt
+				const userImages = options.userImages
+				const userFiles = options.userFiles
+				// Mirror initTask/askResponse ordering: flip the phase and running flag
+				// before anything is emitted or sent, so no listener ever sees a
+				// user_feedback message while the phase still reads awaiting_followup.
+				autoContinueStarted = true
+				this.options.sessions.setRunning(true)
+				this.options.onAutoContinueStarting()
+				// Resolve mentions before echoing so a resolution failure cannot
+				// leave an echoed-but-never-sent user message in the transcript.
+				const prompt = userPrompt ? await this.options.resolveContextMentions(userPrompt) : ACT_MODE_CONTINUATION_PROMPT
+				if (userPrompt || userImages?.length || userFiles?.length) {
+					const userMessage: ClineMessage = {
+						ts: Date.now(),
+						type: "say",
+						say: "user_feedback",
+						text: userPrompt ?? "",
+						images: userImages,
+						files: userFiles,
+						partial: false,
+					}
+					this.options.messages.appendAndEmit([userMessage], {
+						type: "status",
+						payload: { sessionId: startResult.sessionId, status: "running" },
+					})
+				}
+				// Without a typed message the canned prompt drives the continuation; it
+				// is intentionally not echoed as user_feedback, so no synthetic bubble
+				// shows in chat. Attachments still ride along with the canned prompt.
+				this.options.sessions.fireAndForgetSend(sdkHost, startResult.sessionId, prompt, userImages, userFiles)
+				continuationSent = true
+			}
+			await this.options.postStateToWebview()
+
+			Logger.log(`[SdkController] Session rebuilt for mode ${newMode}: ${oldSessionId} -> ${startResult.sessionId}`)
+		} catch (error) {
+			Logger.error("[SdkController] Failed to rebuild session for mode change:", error)
+			if (!sessionReplaced) {
+				// The old session is still the active one and still has the old
+				// mode's tools; leaving the setting flipped would show a toggle
+				// that disagrees with what the agent can actually do.
+				this.options.stateManager.setGlobalState("mode", previousMode)
+			}
+			if (continuationSent) {
+				// The continuation is already running on the rebuilt session; the
+				// only thing that can throw past the send is the post-rebuild state
+				// post. Marking the live run as failed (or emitting a mode-switch
+				// error) would lie about a turn that is actually in flight.
+				return continuationSent
+			}
+			if (autoContinueStarted) {
+				// The continuation send never happened (resolveContextMentions can
+				// throw after the optimistic flip), so undo the running state and
+				// move the phase to "error", otherwise the footer shows a phantom
+				// run that nothing will ever finish.
+				this.options.sessions.setRunning(false)
+				this.options.onAutoContinueFailed()
+			}
+			const errorMessage: ClineMessage = {
+				ts: Date.now(),
+				type: "say",
+				say: "error",
+				text: `Failed to switch mode: ${error instanceof Error ? error.message : String(error)}`,
+				partial: false,
+			}
+			this.options.messages.appendAndEmit([errorMessage], {
+				type: "status",
+				payload: { sessionId: oldSessionId, status: "error" },
+			})
+			await this.options.postStateToWebview()
+		}
+		return continuationSent
+	}
+
+	private async cancelRunningTurnForModeChange(oldManager: SdkSessionHost, oldSessionId: string): Promise<void> {
+		this.options.interactions.clearPending("Mode changed")
+		this.options.messages.cancelPendingSave()
+		try {
+			await oldManager.abort(oldSessionId)
+		} catch (error) {
+			if (!isAbortError(error)) {
+				Logger.error("[SdkController] Failed to abort old session during mode change:", error)
+			}
+		}
+		this.options.sessions.setRunning(false)
+
+		const task = this.options.getTask()
+		if (!task?.messageStateHandler) {
+			return
+		}
+
+		const current = task.messageStateHandler.getClineMessages()
+		const finalized = this.options.messages.finalizeMessagesForSave(current)
+		this.options.messages.appendMessages(finalized)
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-provider-change-coordinator.test.ts b/apps/vscode/src/sdk/sdk-provider-change-coordinator.test.ts
new file mode 100644
index 0000000..f3eabb1
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-provider-change-coordinator.test.ts
@@ -0,0 +1,262 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { StateManager } from "@/core/storage/StateManager"
+import { SdkProviderChangeCoordinator, type SdkProviderChangeCoordinatorOptions } from "./sdk-provider-change-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("SdkProviderChangeCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("does nothing when the active mode provider did not change", () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		coordinator.handleApiConfigurationChanged(
+			{ actModeApiProvider: "anthropic", planModeApiProvider: "openrouter" },
+			{ actModeApiProvider: "anthropic", planModeApiProvider: "deepseek" },
+		)
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+	})
+
+	it("does nothing without an active session", () => {
+		const { coordinator, options } = makeCoordinator()
+
+		coordinator.handleApiConfigurationChanged({ actModeApiProvider: "anthropic" }, { actModeApiProvider: "deepseek" })
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+	})
+
+	it("restarts immediately when the active provider changes while idle", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		coordinator.handleApiConfigurationChanged({ actModeApiProvider: "anthropic" }, { actModeApiProvider: "deepseek" })
+
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce())
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({ cwd: "/workspace", mode: "act" })
+		expect(options.loadInitialMessages).toHaveBeenCalledWith(activeSession.sdkHost, "old-session")
+		expect(options.buildStartSessionInput).toHaveBeenCalledWith(expect.objectContaining({ sessionId: "old-session" }), {
+			cwd: "/workspace",
+			mode: "act",
+		})
+		expect(options.sessions.replaceActiveSession).toHaveBeenCalledWith({
+			startInput: { prompt: "start" },
+			initialMessages: [{ role: "user", content: "hello" }],
+			disposeReason: "providerChange",
+		})
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("uses the current plan mode when plan provider changes", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession, mode: "plan" })
+
+		coordinator.handleApiConfigurationChanged(
+			{ planModeApiProvider: "anthropic", actModeApiProvider: "deepseek" },
+			{ planModeApiProvider: "openrouter", actModeApiProvider: "deepseek" },
+		)
+
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce())
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({ cwd: "/workspace", mode: "plan" })
+	})
+
+	it("defers the restart while the active session is running", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		coordinator.handleApiConfigurationChanged({ actModeApiProvider: "anthropic" }, { actModeApiProvider: "deepseek" })
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+
+		activeSession.isRunning = false
+		await coordinator.checkDeferredRestart()
+
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce())
+	})
+
+	it("can clear a deferred restart before the session becomes idle", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		coordinator.handleApiConfigurationChanged({ actModeApiProvider: "anthropic" }, { actModeApiProvider: "deepseek" })
+		coordinator.clearPendingRestart()
+
+		activeSession.isRunning = false
+		await coordinator.checkDeferredRestart()
+
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+	})
+
+	it("lets pending mode changes replace deferred provider restarts", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		const mode = {
+			hasPendingModeChange: vi.fn(() => true),
+			applyPendingModeChange: vi.fn().mockResolvedValue(undefined),
+		}
+
+		coordinator.handleApiConfigurationChanged({ actModeApiProvider: "anthropic" }, { actModeApiProvider: "deepseek" })
+		activeSession.isRunning = false
+
+		await coordinator.handleTurnComplete(mode)
+		await coordinator.checkDeferredRestart()
+
+		expect(mode.applyPendingModeChange).toHaveBeenCalledOnce()
+		expect(options.sessions.replaceActiveSession).not.toHaveBeenCalled()
+	})
+
+	it("checks deferred provider restarts on turn complete when no mode change is pending", async () => {
+		const activeSession = makeActiveSession({ isRunning: true })
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		const mode = {
+			hasPendingModeChange: vi.fn(() => false),
+			applyPendingModeChange: vi.fn().mockResolvedValue(undefined),
+		}
+
+		coordinator.handleApiConfigurationChanged({ actModeApiProvider: "anthropic" }, { actModeApiProvider: "deepseek" })
+		activeSession.isRunning = false
+
+		await coordinator.handleTurnComplete(mode)
+
+		expect(mode.applyPendingModeChange).not.toHaveBeenCalled()
+		expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce()
+	})
+
+	it("updates the task id when the replacement session id changes", async () => {
+		const activeSession = makeActiveSession()
+		const task = { taskId: "old-session" }
+		const { coordinator, options } = makeCoordinator({ activeSession, task })
+
+		await coordinator.restartActiveSessionForProviderChange()
+
+		expect(task.taskId).toBe("new-session")
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("runs a follow-up restart when another provider change lands during restart", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		let resolveFirstRestart: (() => void) | undefined
+		options.sessions.replaceActiveSession.mockReturnValueOnce(
+			new Promise((resolve) => {
+				resolveFirstRestart = () => {
+					resolve({
+						startResult: { sessionId: "new-session" },
+						sdkHost: { send: vi.fn() },
+					})
+				}
+			}),
+		)
+
+		const firstRestart = coordinator.restartActiveSessionForProviderChange()
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledOnce())
+
+		const secondRestart = coordinator.restartActiveSessionForProviderChange()
+		resolveFirstRestart?.()
+		await firstRestart
+		await secondRestart
+
+		await vi.waitFor(() => expect(options.sessions.replaceActiveSession).toHaveBeenCalledTimes(2))
+	})
+
+	it("emits an error message when restart fails", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+		options.sessions.replaceActiveSession.mockRejectedValue(new Error("boom"))
+
+		await coordinator.restartActiveSessionForProviderChange()
+
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					type: "say",
+					say: "error",
+					text: "Failed to reload provider configuration: boom. The active session may still use the previous provider.",
+				}),
+			],
+			{ type: "status", payload: { sessionId: "old-session", status: "error" } },
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const activeSession = input.activeSession
+	const config = {
+		providerId: "deepseek",
+		modelId: "deepseek-v4-flash",
+		apiKey: "key",
+	}
+	const options = {
+		stateManager: {
+			getGlobalSettingsKey: vi.fn(() => input.mode ?? "act"),
+		} as unknown as StateManager,
+		sessions: {
+			getActiveSession: vi.fn(() => activeSession),
+			replaceActiveSession: vi.fn().mockResolvedValue({
+				startResult: { sessionId: "new-session" },
+				sdkHost: { send: vi.fn() },
+			}),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+		},
+		sessionConfigBuilder: {
+			build: vi.fn().mockResolvedValue(config),
+		},
+		getTask: vi.fn(() => input.task),
+		getWorkspaceRoot: vi.fn().mockResolvedValue("/workspace"),
+		loadInitialMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		buildStartSessionInput: vi.fn(() => ({ prompt: "start" })),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+	} as unknown as SdkProviderChangeCoordinatorOptions & {
+		stateManager: StateManager & { getGlobalSettingsKey: ReturnType<typeof vi.fn> }
+		sessions: SdkProviderChangeCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			replaceActiveSession: ReturnType<typeof vi.fn>
+		}
+		messages: SdkProviderChangeCoordinatorOptions["messages"] & { appendAndEmit: ReturnType<typeof vi.fn> }
+		sessionConfigBuilder: SdkProviderChangeCoordinatorOptions["sessionConfigBuilder"] & {
+			build: ReturnType<typeof vi.fn>
+		}
+		getTask: ReturnType<typeof vi.fn>
+		getWorkspaceRoot: ReturnType<typeof vi.fn>
+		loadInitialMessages: ReturnType<typeof vi.fn>
+		buildStartSessionInput: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkProviderChangeCoordinator(options),
+		options,
+	}
+}
+
+interface MakeCoordinatorInput {
+	activeSession: ReturnType<typeof makeActiveSession>
+	mode: "act" | "plan"
+	task: { taskId: string }
+}
+
+function makeActiveSession(input: { isRunning?: boolean } = {}) {
+	return {
+		sessionId: "old-session",
+		sdkHost: {
+			send: vi.fn(),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		},
+		unsubscribe: vi.fn(),
+		startResult: { sessionId: "old-session" },
+		isRunning: input.isRunning ?? false,
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-provider-change-coordinator.ts b/apps/vscode/src/sdk/sdk-provider-change-coordinator.ts
new file mode 100644
index 0000000..c68263b
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-provider-change-coordinator.ts
@@ -0,0 +1,195 @@
+import type { ApiConfiguration } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import type { StateManager } from "@/core/storage/StateManager"
+import { Logger } from "@/shared/services/Logger"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkModeCoordinator } from "./sdk-mode-coordinator"
+import type { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { SdkSessionHost } from "./session-host"
+import type { TaskProxy } from "./task-proxy"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+type StartInput = Parameters<VscodeSessionHost["start"]>[0]
+type InitialMessages = StartInput["initialMessages"]
+type SessionConfig = Awaited<ReturnType<SdkSessionConfigBuilder["build"]>>
+
+export interface SdkProviderChangeCoordinatorOptions {
+	stateManager: StateManager
+	sessions: SdkSessionLifecycle
+	messages: SdkMessageCoordinator
+	sessionConfigBuilder: SdkSessionConfigBuilder
+	getTask: () => TaskProxy | undefined
+	getWorkspaceRoot: () => Promise<string>
+	loadInitialMessages: (sdkHost: SdkSessionHost, sessionId: string) => Promise<InitialMessages>
+	buildStartSessionInput: (config: SessionConfig, input: { cwd: string; mode: Mode }) => StartInput
+	postStateToWebview: () => Promise<void>
+}
+
+function providerForMode(config: ApiConfiguration, mode: Mode): string | undefined {
+	return mode === "plan" ? config.planModeApiProvider : config.actModeApiProvider
+}
+
+export class SdkProviderChangeCoordinator {
+	private restartPending = false
+	private restartInFlight: Promise<void> | undefined
+
+	constructor(private readonly options: SdkProviderChangeCoordinatorOptions) {}
+
+	handleApiConfigurationChanged(previous: ApiConfiguration, next: ApiConfiguration): void {
+		const mode = this.getCurrentMode()
+		const previousProvider = providerForMode(previous, mode)
+		const nextProvider = providerForMode(next, mode)
+
+		if (previousProvider === nextProvider) {
+			return
+		}
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			Logger.log("[SdkController] Provider changed without active session; next task will use new provider")
+			return
+		}
+
+		Logger.log(
+			`[SdkController] Active provider changed for ${mode}: ${previousProvider ?? "none"} -> ${nextProvider ?? "none"}`,
+		)
+
+		if (activeSession.isRunning) {
+			Logger.log("[SdkController] Session is mid-turn; deferring provider restart")
+			this.restartPending = true
+			return
+		}
+
+		this.restartActiveSessionForProviderChange().catch((error) => {
+			Logger.error("[SdkController] Failed to restart session after provider change:", error)
+		})
+	}
+
+	clearPendingRestart(): void {
+		this.restartPending = false
+	}
+
+	async handleTurnComplete(mode: Pick<SdkModeCoordinator, "hasPendingModeChange" | "applyPendingModeChange">): Promise<void> {
+		if (mode.hasPendingModeChange()) {
+			this.clearPendingRestart()
+			try {
+				await mode.applyPendingModeChange()
+			} catch (err) {
+				Logger.error("[SdkController] applyPendingModeChange failed:", err)
+			}
+			return
+		}
+
+		try {
+			await this.checkDeferredRestart()
+		} catch (err) {
+			Logger.error("[SdkController] Failed deferred provider restart:", err)
+		}
+	}
+
+	async checkDeferredRestart(): Promise<void> {
+		if (!this.restartPending) {
+			return
+		}
+		this.restartPending = false
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			Logger.log("[SdkController] Deferred provider restart: no active session, skipping")
+			return
+		}
+
+		if (activeSession.isRunning) {
+			Logger.log("[SdkController] Deferred provider restart: session is still running")
+			this.restartPending = true
+			return
+		}
+
+		await this.restartActiveSessionForProviderChange()
+	}
+
+	async restartActiveSessionForProviderChange(): Promise<void> {
+		if (this.restartInFlight) {
+			this.restartPending = true
+			return this.restartInFlight
+		}
+
+		const operation = this.performRestartActiveSessionForProviderChange()
+		this.restartInFlight = operation.then(
+			() => undefined,
+			// restartInFlight is only a serialization gate. The caller awaits
+			// operation below, where restart failures are reported to the user.
+			() => undefined,
+		)
+
+		try {
+			await operation
+		} finally {
+			this.restartInFlight = undefined
+			await this.checkDeferredRestart()
+		}
+	}
+
+	private async performRestartActiveSessionForProviderChange(): Promise<void> {
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			return
+		}
+
+		const { sdkHost: oldManager, sessionId: oldSessionId } = activeSession
+		const cwd = await this.options.getWorkspaceRoot()
+		const mode = this.getCurrentMode()
+
+		Logger.log(`[SdkController] Restarting session ${oldSessionId} for provider change`)
+
+		try {
+			const config = await this.options.sessionConfigBuilder.build({ cwd, mode })
+			config.sessionId = oldSessionId
+
+			const initialMessages = await this.options.loadInitialMessages(oldManager, oldSessionId)
+			const startInput = this.options.buildStartSessionInput(config, { cwd, mode })
+			const restartResult = await this.options.sessions.replaceActiveSession({
+				startInput,
+				...(initialMessages ? { initialMessages } : {}),
+				disposeReason: "providerChange",
+			})
+			if (!restartResult) {
+				return
+			}
+
+			const { startResult } = restartResult
+			const task = this.options.getTask()
+			if (task && task.taskId !== startResult.sessionId) {
+				Logger.warn(
+					`[SdkController] Provider restart returned a new session ID (${startResult.sessionId}); updating task proxy`,
+				)
+				task.taskId = startResult.sessionId
+			}
+
+			await this.options.postStateToWebview()
+			Logger.log(`[SdkController] Session restarted for provider change: ${oldSessionId} -> ${startResult.sessionId}`)
+		} catch (error) {
+			Logger.error("[SdkController] Failed to restart session for provider change:", error)
+			this.options.messages.appendAndEmit(
+				[
+					{
+						ts: Date.now(),
+						type: "say",
+						say: "error",
+						text: `Failed to reload provider configuration: ${
+							error instanceof Error ? error.message : String(error)
+						}. The active session may still use the previous provider.`,
+						partial: false,
+					},
+				],
+				{ type: "status", payload: { sessionId: oldSessionId, status: "error" } },
+			)
+			await this.options.postStateToWebview()
+		}
+	}
+
+	private getCurrentMode(): Mode {
+		return this.options.stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-remote-config-control-plane.test.ts b/apps/vscode/src/sdk/sdk-remote-config-control-plane.test.ts
new file mode 100644
index 0000000..275511e
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-remote-config-control-plane.test.ts
@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const {
+	fetchUserRemoteConfig,
+	switchAccount,
+	setSecret,
+	isRemoteConfigEnabled,
+	writeRemoteConfigToCache,
+	readRemoteConfigFromCache,
+} = vi.hoisted(() => ({
+	fetchUserRemoteConfig: vi.fn(),
+	switchAccount: vi.fn(),
+	setSecret: vi.fn(),
+	isRemoteConfigEnabled: vi.fn(),
+	writeRemoteConfigToCache: vi.fn(),
+	readRemoteConfigFromCache: vi.fn(),
+}))
+
+vi.mock("@/services/account/ClineAccountService", () => ({
+	ClineAccountService: {
+		getInstance: () => ({ fetchUserRemoteConfig }),
+	},
+}))
+
+vi.mock("@/services/auth/AuthService", () => ({
+	AuthService: {
+		getInstance: () => ({
+			getActiveOrganizationId: () => "org-current",
+			getAuthToken: async () => "token",
+		}),
+	},
+}))
+
+vi.mock("@/core/storage/disk", () => ({
+	deleteRemoteConfigFromCache: vi.fn(),
+	readRemoteConfigFromCache,
+	writeRemoteConfigToCache,
+}))
+
+vi.mock("@/core/storage/remote-config/utils", () => ({
+	isRemoteConfigEnabled,
+}))
+
+vi.mock("@/services/EnvUtils", () => ({ buildBasicClineHeaders: async () => ({}) }))
+vi.mock("@/shared/net", () => ({ getAxiosSettings: () => ({}) }))
+vi.mock("axios", () => ({ default: { request: vi.fn() } }))
+
+import { SdkRemoteConfigControlPlane } from "@/core/storage/remote-config/sdk-control-plane"
+
+describe("SdkRemoteConfigControlPlane", () => {
+	beforeEach(() => {
+		fetchUserRemoteConfig.mockReset()
+		switchAccount.mockReset()
+		setSecret.mockReset()
+		isRemoteConfigEnabled.mockReset().mockReturnValue(true)
+		writeRemoteConfigToCache.mockReset().mockResolvedValue(undefined)
+		readRemoteConfigFromCache.mockReset().mockResolvedValue({ version: "v1" })
+	})
+
+	function makeControlPlane() {
+		return new SdkRemoteConfigControlPlane({
+			accountService: { switchAccount },
+			stateManager: { setSecret },
+		})
+	}
+
+	it("returns undefined and marks explicit no-config when discovery returns nothing", async () => {
+		fetchUserRemoteConfig.mockResolvedValue(undefined)
+		const controlPlane = makeControlPlane()
+
+		const bundle = await controlPlane.fetchBundle({ workspacePath: "/workspace" })
+
+		expect(bundle).toBeUndefined()
+		expect(controlPlane.wasExplicitNoConfig()).toBe(true)
+	})
+
+	it("wraps discovered remote config in a bundle", async () => {
+		fetchUserRemoteConfig.mockResolvedValue({
+			organizationId: "org-target",
+			value: JSON.stringify({ version: "v1" }),
+			organizations: [{ organizationId: "org-target", name: "Target" }],
+		})
+		const controlPlane = makeControlPlane()
+
+		const bundle = await controlPlane.fetchBundle({ workspacePath: "/workspace" })
+
+		expect(bundle?.source).toBe("cline-extension-remote-config")
+		expect(bundle?.version).toBe("v1")
+		expect(bundle?.remoteConfig?.version).toBe("v1")
+		expect(controlPlane.getLastRemoteConfig()?.version).toBe("v1")
+		expect(switchAccount).toHaveBeenCalledWith("org-target")
+		expect(writeRemoteConfigToCache).toHaveBeenCalledWith("org-target", { version: "v1" })
+	})
+
+	it("converts globalSkills to managed skill instructions", async () => {
+		fetchUserRemoteConfig.mockResolvedValue({
+			organizationId: "org-target",
+			value: JSON.stringify({
+				version: "v1",
+				globalSkills: [{ name: "Review Skill", alwaysEnabled: true, contents: "---\nname: Review Skill\n---\nUse it" }],
+			}),
+			organizations: [{ organizationId: "org-target", name: "Target" }],
+		})
+		const controlPlane = makeControlPlane()
+
+		const bundle = await controlPlane.fetchBundle({ workspacePath: "/workspace" })
+
+		expect(bundle?.managedInstructions).toEqual([
+			{
+				id: "remote-config:skill:0:Review Skill",
+				name: "Review Skill",
+				kind: "skill",
+				contents: "---\nname: Review Skill\n---\nUse it",
+				alwaysEnabled: true,
+			},
+		])
+	})
+
+	it("skips disabled active org and selects an enabled fallback org", async () => {
+		isRemoteConfigEnabled.mockImplementation((orgId: string) => orgId === "org-fallback")
+		fetchUserRemoteConfig.mockResolvedValue({
+			organizationId: "org-disabled",
+			value: JSON.stringify({ version: "disabled" }),
+			organizations: [
+				{ organizationId: "org-disabled", name: "Disabled" },
+				{ organizationId: "org-fallback", name: "Fallback" },
+			],
+		})
+		const controlPlane = makeControlPlane()
+
+		const bundle = await controlPlane.fetchBundle({ workspacePath: "/workspace" })
+
+		expect(bundle?.remoteConfig?.version).toBe("v1")
+		expect(writeRemoteConfigToCache).toHaveBeenCalledWith("org-fallback", { version: "v1" })
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-session-config-builder.test.ts b/apps/vscode/src/sdk/sdk-session-config-builder.test.ts
new file mode 100644
index 0000000..c6da138
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-config-builder.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from "vitest"
+import { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+
+const mocks = vi.hoisted(() => ({
+	buildSessionConfig: vi.fn(),
+	buildAgentHooks: vi.fn(() => ({})),
+}))
+
+vi.mock("./cline-session-factory", () => ({
+	buildSessionConfig: mocks.buildSessionConfig,
+}))
+
+vi.mock("./hooks-adapter", () => ({
+	buildAgentHooks: mocks.buildAgentHooks,
+}))
+
+describe("SdkSessionConfigBuilder", () => {
+	it("adds the CLI plan-mode switch_to_act_mode tool only in plan mode", async () => {
+		const stateManager = {
+			getGlobalSettingsKey: vi.fn(() => "plan"),
+		}
+		const onSwitchToActMode = vi.fn()
+		const builder = new SdkSessionConfigBuilder({
+			stateManager: stateManager as never,
+			emitHookMessage: vi.fn(),
+			onSwitchToActMode,
+		})
+
+		mocks.buildSessionConfig.mockResolvedValueOnce({
+			extraTools: [],
+			hooks: {},
+		})
+		const planConfig = await builder.build({ cwd: "/workspace", mode: "plan" })
+		const switchTool = planConfig.extraTools?.find((tool) => tool.name === "switch_to_act_mode")
+		expect(switchTool).toBeDefined()
+		// Ends the run cleanly after the tool result so the loop never starts an
+		// iteration that the stop hook would abort (which surfaced in the webview
+		// as "API Request Cancelled").
+		expect(switchTool?.lifecycle?.completesRun).toBe(true)
+		expect(await switchTool?.execute({}, {} as never)).toBe(
+			"You successfully switched to act mode, proceed with the plan. You now have access to editing files and running commands. (The switch_to_act_mode tool is only available in plan mode.)",
+		)
+		expect(onSwitchToActMode).toHaveBeenCalledOnce()
+
+		mocks.buildSessionConfig.mockResolvedValueOnce({
+			extraTools: [switchTool],
+			hooks: {},
+		})
+		const actConfig = await builder.build({ cwd: "/workspace", mode: "act" })
+		expect(actConfig.extraTools?.some((tool) => tool.name === "switch_to_act_mode")).toBe(false)
+	})
+
+	it("stops before the next model call after switch_to_act_mode queues a mode change", async () => {
+		const baseBeforeModel = vi.fn(async () => ({ metadata: "base" }))
+		mocks.buildAgentHooks.mockReturnValueOnce({ beforeModel: baseBeforeModel })
+		mocks.buildSessionConfig.mockResolvedValueOnce({ hooks: {} })
+
+		const builder = new SdkSessionConfigBuilder({
+			stateManager: {} as never,
+			emitHookMessage: vi.fn(),
+			onSwitchToActMode: vi.fn(),
+			shouldStopAfterModeSwitch: () => true,
+		})
+
+		const config = await builder.build({ cwd: "/workspace", mode: "act" })
+
+		await expect(config.hooks?.beforeModel?.({} as never)).resolves.toEqual({
+			metadata: "base",
+			stop: true,
+		})
+		expect(baseBeforeModel).toHaveBeenCalledOnce()
+	})
+
+	it("passes the mistake-limit callback into the SDK config without overriding SDK execution defaults", async () => {
+		const onConsecutiveMistakeLimitReached = vi.fn()
+		mocks.buildSessionConfig.mockResolvedValueOnce({ hooks: {}, execution: { maxRetries: 1 } })
+
+		const builder = new SdkSessionConfigBuilder({
+			stateManager: { getGlobalSettingsKey: vi.fn(() => 3) } as never,
+			emitHookMessage: vi.fn(),
+			onSwitchToActMode: vi.fn(),
+			onConsecutiveMistakeLimitReached,
+		})
+
+		const config = await builder.build({ cwd: "/workspace", mode: "act" })
+
+		expect(config.execution).toEqual({ maxRetries: 1 })
+		expect(config.onConsecutiveMistakeLimitReached).toBe(onConsecutiveMistakeLimitReached)
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-session-config-builder.ts b/apps/vscode/src/sdk/sdk-session-config-builder.ts
new file mode 100644
index 0000000..90ee542
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-config-builder.ts
@@ -0,0 +1,81 @@
+import type { CoreSessionConfig } from "@cline/core"
+import { type AgentTool, createTool } from "@cline/shared"
+import type { StateManager } from "@/core/storage/StateManager"
+import { buildSessionConfig, type SessionConfigInput } from "./cline-session-factory"
+import { buildAgentHooks, type HookMessageEmitter } from "./hooks-adapter"
+
+export interface SdkSessionConfigBuilderOptions {
+	stateManager: StateManager
+	emitHookMessage: HookMessageEmitter
+	onSwitchToActMode: () => void
+	shouldStopAfterModeSwitch?: () => boolean
+	onConsecutiveMistakeLimitReached?: CoreSessionConfig["onConsecutiveMistakeLimitReached"]
+}
+
+export class SdkSessionConfigBuilder {
+	constructor(private readonly options: SdkSessionConfigBuilderOptions) {}
+
+	async build(input: SessionConfigInput): Promise<Awaited<ReturnType<typeof buildSessionConfig>>> {
+		const config = await buildSessionConfig(input)
+		if (this.options.onConsecutiveMistakeLimitReached) {
+			config.onConsecutiveMistakeLimitReached = this.options.onConsecutiveMistakeLimitReached
+		}
+
+		const baseHooks = buildAgentHooks(this.options.stateManager, this.options.emitHookMessage)
+		config.hooks = {
+			...baseHooks,
+			beforeModel: async (ctx) => {
+				const baseControl = await baseHooks.beforeModel?.(ctx)
+				if (this.options.shouldStopAfterModeSwitch?.()) {
+					return {
+						...baseControl,
+						stop: true,
+					}
+				}
+				return baseControl
+			},
+		}
+		if (input.mode === "plan") {
+			// Match the CLI interactive runtime: plan-mode sessions expose a
+			// switch_to_act_mode tool in addition to the read-only planning tools.
+			config.extraTools = [...(config.extraTools ?? []), this.createSwitchToActModeTool()]
+		} else {
+			// The switch tool is plan-only in the CLI and should disappear after
+			// rebuilding the session in act mode.
+			config.extraTools = config.extraTools?.filter((tool) => tool.name !== "switch_to_act_mode")
+		}
+
+		return config
+	}
+
+	private createSwitchToActModeTool(): AgentTool {
+		return createTool({
+			name: "switch_to_act_mode",
+			description:
+				"Switch from plan mode to act mode. Switching to act mode immediately starts executing the plan, so only call this after the user has explicitly approved the plan in a message sent AFTER you presented it (e.g. 'looks good', 'go ahead', 'switch to act mode'). " +
+				"Never call this in the same turn you present a plan, never call it proactively, and never treat the original task request as approval.",
+			inputSchema: {
+				type: "object",
+				properties: {},
+			},
+			timeoutMs: 5000,
+			retryable: false,
+			maxRetries: 0,
+			// End the run cleanly right after the tool result instead of letting the
+			// loop start another iteration that the beforeModel stop hook would abort.
+			// An aborted run leaves a dangling api_req_started spinner behind, which the
+			// webview renders as "API Request Cancelled".
+			lifecycle: {
+				completesRun: true,
+			},
+			execute: async () => {
+				const currentMode = this.options.stateManager.getGlobalSettingsKey("mode")
+				if (currentMode === "act") {
+					return "Already in act mode."
+				}
+				this.options.onSwitchToActMode()
+				return "You successfully switched to act mode, proceed with the plan. You now have access to editing files and running commands. (The switch_to_act_mode tool is only available in plan mode.)"
+			},
+		})
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-session-event-coordinator.test.ts b/apps/vscode/src/sdk/sdk-session-event-coordinator.test.ts
new file mode 100644
index 0000000..40b0862
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-event-coordinator.test.ts
@@ -0,0 +1,431 @@
+import type { CoreSessionEvent } from "@cline/core"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { MessageTranslatorState } from "./message-translator"
+import { PROVIDER_FAILURE_ERROR_TYPE, PROVIDER_FAILURE_PHASE } from "./provider-failure-telemetry"
+import { SdkSessionEventCoordinator, type SdkSessionEventCoordinatorOptions } from "./sdk-session-event-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+		debug: vi.fn(),
+	},
+}))
+
+describe("SdkSessionEventCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("translates and emits session messages, then posts state", async () => {
+		const message: ClineMessage = { ts: 1, type: "say", say: "text", text: "hello" }
+		const { coordinator, options, event } = makeCoordinator({
+			translation: {
+				messages: [message],
+				sessionEnded: false,
+				turnComplete: false,
+			},
+		})
+
+		coordinator.handleSessionEvent(event)
+		await Promise.resolve()
+
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith([message], event)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("filters late completion messages after cancellation", async () => {
+		const { coordinator, options, event } = makeCoordinator({
+			activeSession: makeActiveSession({ isRunning: false }),
+			translation: {
+				messages: [
+					{ ts: 1, type: "ask", ask: "completion_result", text: "" },
+					{ ts: 2, type: "say", say: "text", text: "kept" },
+				],
+				sessionEnded: false,
+				turnComplete: false,
+			},
+		})
+
+		coordinator.handleSessionEvent(event)
+		await Promise.resolve()
+
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith([{ ts: 2, type: "say", say: "text", text: "kept" }], event)
+	})
+
+	it("ignores stale events from inactive sessions", async () => {
+		const { coordinator, options, event } = makeCoordinator({
+			translation: {
+				messages: [{ ts: 1, type: "say", say: "text", text: "stale" }],
+				sessionEnded: false,
+				turnComplete: false,
+			},
+		})
+		const staleEvent = {
+			...event,
+			payload: { ...event.payload, sessionId: "old-session" },
+		} as CoreSessionEvent
+
+		await coordinator.handleSessionEvent(staleEvent)
+
+		expect(options.translateSessionEvent).not.toHaveBeenCalled()
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.postStateToWebview).not.toHaveBeenCalled()
+	})
+
+	it("marks turns complete and delegates provider restart handling", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options, event } = makeCoordinator({
+			activeSession,
+			translation: {
+				messages: [],
+				sessionEnded: false,
+				turnComplete: true,
+			},
+		})
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(false)
+		expect(options.mcpTools.checkDeferredRestart).toHaveBeenCalledOnce()
+		expect(options.providerChanges.handleTurnComplete).toHaveBeenCalledWith(options.mode)
+	})
+
+	it("posts state on turn end even when the turn-complete event carries NO messages", async () => {
+		// The `done` handler emits no transcript message, so a turn-complete event has
+		// messages.length === 0 while the phase changes to completed/awaiting_followup. State must
+		// be posted on turn end regardless of message count, or the footer stays stuck on the
+		// previous phase (e.g. scroll-arrows / streaming).
+		const { coordinator, options, event } = makeCoordinator({
+			translation: {
+				messages: [],
+				sessionEnded: false,
+				turnComplete: true,
+			},
+		})
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.setTurnPhase).toHaveBeenCalledWith("awaiting_followup")
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("marks a submitted queued prompt as a new streaming turn", async () => {
+		const message: ClineMessage = { ts: 1, type: "say", say: "user_feedback", text: "queued prompt" }
+		const { coordinator, options } = makeCoordinator({
+			translation: {
+				messages: [message],
+				sessionEnded: false,
+				turnComplete: false,
+			},
+		})
+		const clearTurnOutcome = vi.spyOn(options.messageTranslatorState, "clearTurnOutcome")
+		const event: CoreSessionEvent = {
+			type: "pending_prompt_submitted",
+			payload: {
+				sessionId: "session-123",
+				id: "pending-1",
+				prompt: "queued prompt",
+				delivery: "queue",
+				attachmentCount: 0,
+			},
+		} as CoreSessionEvent
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(clearTurnOutcome).toHaveBeenCalledOnce()
+		expect(options.beginProviderFailureTelemetryTurn).toHaveBeenCalledOnce()
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(true)
+		expect(options.setTurnPhase).toHaveBeenCalledWith("streaming")
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith([message], event)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("posts state for queued prompt turn start even when no transcript message is emitted", async () => {
+		const { coordinator, options } = makeCoordinator({
+			translation: {
+				messages: [],
+				sessionEnded: false,
+				turnComplete: false,
+			},
+		})
+		const event: CoreSessionEvent = {
+			type: "pending_prompt_submitted",
+			payload: {
+				sessionId: "session-123",
+				id: "pending-1",
+				prompt: "",
+				delivery: "queue",
+				attachmentCount: 0,
+			},
+		} as CoreSessionEvent
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.setTurnPhase).toHaveBeenCalledWith("streaming")
+		expect(options.messages.appendAndEmit).not.toHaveBeenCalled()
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("does NOT override the phase on a turn-complete straggler from an already-cancelled session", async () => {
+		// After cancelTask sets phase "resumable" and aborts, the SDK may still emit a trailing
+		// done/turnComplete. Because the session is no longer running, this straggler must NOT
+		// set "awaiting_followup"/"completed" — doing so would clobber "resumable" and the footer
+		// would lose the Resume Task button (showing scroll-arrows).
+		const { coordinator, options, event } = makeCoordinator({
+			activeSession: makeActiveSession({ isRunning: false }),
+			translation: {
+				messages: [],
+				sessionEnded: false,
+				turnComplete: true,
+			},
+		})
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.setTurnPhase).not.toHaveBeenCalled()
+	})
+
+	it("updates task usage when the active session has a start result", async () => {
+		const { coordinator, options, event } = makeCoordinator({
+			task: { taskId: "task-1" },
+			translation: {
+				messages: [],
+				sessionEnded: false,
+				turnComplete: false,
+				usage: { tokensIn: 3, tokensOut: 4, cacheReads: 5, cacheWrites: 0, totalCost: 0.01 },
+			},
+		})
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.taskHistory.updateTaskUsage).toHaveBeenCalledWith("task-1", {
+			tokensIn: 3,
+			tokensOut: 4,
+			cacheReads: 5,
+			cacheWrites: 0,
+			totalCost: 0.01,
+		})
+	})
+
+	it("zeros usage and api request message cost for free Cline models", async () => {
+		const { coordinator, options, event } = makeCoordinator({
+			isClineFreeModel: vi.fn().mockResolvedValue(true),
+			task: { taskId: "task-1" },
+			translation: {
+				messages: [
+					{
+						ts: 1,
+						type: "say",
+						say: "api_req_started",
+						text: JSON.stringify({ tokensIn: 10, tokensOut: 5, cost: 0.0016 }),
+					},
+				],
+				sessionEnded: false,
+				turnComplete: false,
+				usage: { tokensIn: 10, tokensOut: 5, totalCost: 0.0016 },
+			},
+		})
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				{
+					ts: 1,
+					type: "say",
+					say: "api_req_started",
+					text: JSON.stringify({ tokensIn: 10, tokensOut: 5, cost: 0 }),
+				},
+			],
+			event,
+		)
+		expect(options.taskHistory.updateTaskUsage).toHaveBeenCalledWith("task-1", {
+			tokensIn: 10,
+			tokensOut: 5,
+			totalCost: 0,
+		})
+	})
+
+	it("leaves mistake-limit recovery to the SDK callback instead of mutating tool-error events", async () => {
+		const message: ClineMessage = { ts: 1, type: "say", say: "tool", text: "{}", partial: false }
+		const { coordinator, options, event } = makeCoordinator({
+			translation: {
+				messages: [message],
+				sessionEnded: false,
+				turnComplete: false,
+				toolError: true,
+			},
+		})
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith([message], event)
+		expect(options.sessions.setRunning).not.toHaveBeenCalled()
+	})
+
+	it("captures provider failure telemetry for SDK agent errors", async () => {
+		const error = new Error("provider failed")
+		const { coordinator, options } = makeCoordinator()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-123",
+				event: {
+					type: "error",
+					error,
+				},
+			},
+		} as unknown as CoreSessionEvent
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.captureProviderApiError).toHaveBeenCalledWith({
+			sessionId: "session-123",
+			error,
+			errorType: PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_ERROR,
+			failurePhase: PROVIDER_FAILURE_PHASE.STREAMING,
+		})
+	})
+
+	it("does not capture provider failure telemetry for SDK agent errors without an error payload", async () => {
+		const { coordinator, options } = makeCoordinator()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-123",
+				event: {
+					type: "error",
+				},
+			},
+		} as unknown as CoreSessionEvent
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.captureProviderApiError).not.toHaveBeenCalled()
+	})
+
+	it("captures provider failure telemetry when the SDK finishes a turn with reason error", async () => {
+		const { coordinator, options } = makeCoordinator()
+		const event: CoreSessionEvent = {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-123",
+				event: {
+					type: "done",
+					reason: "error",
+					text: "stream failed before assistant output",
+					iterations: 1,
+				},
+			},
+		} as unknown as CoreSessionEvent
+
+		await coordinator.handleSessionEvent(event)
+
+		expect(options.captureProviderApiError).toHaveBeenCalledWith({
+			sessionId: "session-123",
+			error: "stream failed before assistant output",
+			errorType: PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_DONE_ERROR,
+			failurePhase: PROVIDER_FAILURE_PHASE.STREAMING,
+		})
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const event: CoreSessionEvent = {
+		type: "agent_event",
+		payload: {
+			sessionId: "session-123",
+			event: { type: "done", success: true },
+		},
+	} as unknown as CoreSessionEvent
+	const activeSession = input.activeSession ?? makeActiveSession()
+	const options = {
+		messageTranslatorState: new MessageTranslatorState(),
+		sessions: {
+			getActiveSession: vi.fn(() => activeSession),
+			setRunning: vi.fn(),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+		},
+		mcpTools: {
+			checkDeferredRestart: vi.fn(),
+		},
+		providerChanges: {
+			handleTurnComplete: vi.fn().mockResolvedValue(undefined),
+		},
+		mode: {
+			hasPendingModeChange: vi.fn(() => input.hasPendingModeChange ?? false),
+			applyPendingModeChange: vi.fn().mockResolvedValue(undefined),
+		},
+		taskHistory: {
+			updateTaskUsage: vi.fn(),
+		},
+		getTask: vi.fn(() => input.task),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		setTurnPhase: vi.fn(),
+		captureProviderApiError: vi.fn(),
+		beginProviderFailureTelemetryTurn: vi.fn(),
+		translateSessionEvent: vi.fn(() => input.translation ?? { messages: [], sessionEnded: false, turnComplete: false }),
+		isClineFreeModel: input.isClineFreeModel,
+	} as unknown as SdkSessionEventCoordinatorOptions & {
+		sessions: SdkSessionEventCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			setRunning: ReturnType<typeof vi.fn>
+		}
+		messages: SdkSessionEventCoordinatorOptions["messages"] & { appendAndEmit: ReturnType<typeof vi.fn> }
+		mcpTools: SdkSessionEventCoordinatorOptions["mcpTools"] & { checkDeferredRestart: ReturnType<typeof vi.fn> }
+		providerChanges: NonNullable<SdkSessionEventCoordinatorOptions["providerChanges"]> & {
+			handleTurnComplete: ReturnType<typeof vi.fn>
+		}
+		mode: SdkSessionEventCoordinatorOptions["mode"] & {
+			hasPendingModeChange: ReturnType<typeof vi.fn>
+			applyPendingModeChange: ReturnType<typeof vi.fn>
+		}
+		taskHistory: SdkSessionEventCoordinatorOptions["taskHistory"] & { updateTaskUsage: ReturnType<typeof vi.fn> }
+		postStateToWebview: ReturnType<typeof vi.fn>
+		captureProviderApiError: ReturnType<typeof vi.fn>
+		beginProviderFailureTelemetryTurn: ReturnType<typeof vi.fn>
+		translateSessionEvent: ReturnType<typeof vi.fn>
+		messageTranslatorState: MessageTranslatorState
+	}
+
+	return {
+		coordinator: new SdkSessionEventCoordinator(options),
+		options,
+		event,
+	}
+}
+
+function makeActiveSession(input: Partial<{ isRunning: boolean }> = {}) {
+	return {
+		sessionId: "session-123",
+		sdkHost: {},
+		unsubscribe: vi.fn(),
+		startResult: { sessionId: "session-123" },
+		isRunning: input.isRunning ?? true,
+	}
+}
+
+interface MakeCoordinatorInput {
+	activeSession: ReturnType<typeof makeActiveSession>
+	hasPendingModeChange: boolean
+	task: { taskId: string }
+	isClineFreeModel: () => Promise<boolean>
+	translation: {
+		messages: ClineMessage[]
+		sessionEnded: boolean
+		turnComplete: boolean
+		toolError?: boolean
+		usage?: {
+			tokensIn: number
+			tokensOut: number
+			cacheWrites?: number
+			cacheReads?: number
+			totalCost?: number
+		}
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-session-event-coordinator.ts b/apps/vscode/src/sdk/sdk-session-event-coordinator.ts
new file mode 100644
index 0000000..e586afe
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-event-coordinator.ts
@@ -0,0 +1,310 @@
+import type { AgentEvent, CoreSessionEvent } from "@cline/core"
+import { refreshClineRecommendedModels } from "@/core/controller/models/refreshClineRecommendedModels"
+import type { StateManager } from "@/core/storage/StateManager"
+import { CLINE_RECOMMENDED_MODELS_FALLBACK } from "@/shared/cline/recommended-models"
+import type { ClineApiReqInfo, TurnPhase } from "@/shared/ExtensionMessage"
+import { Logger } from "@/shared/services/Logger"
+import { isClineManagedProvider } from "@/shared/utils/cline"
+import type { MessageTranslatorState, TranslationResult } from "./message-translator"
+import { translateSessionEvent } from "./message-translator"
+import { PROVIDER_FAILURE_ERROR_TYPE, PROVIDER_FAILURE_PHASE, type ProviderFailureTelemetry } from "./provider-failure-telemetry"
+import type { SdkMcpCoordinator } from "./sdk-mcp-coordinator"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkModeCoordinator } from "./sdk-mode-coordinator"
+import type { SdkProviderChangeCoordinator } from "./sdk-provider-change-coordinator"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { SdkTaskHistory } from "./sdk-task-history"
+import type { TaskProxy } from "./task-proxy"
+
+function normalizeModelId(modelId: string): string {
+	return modelId.trim().toLowerCase()
+}
+
+type AgentFailureTelemetry = Pick<ProviderFailureTelemetry, "sessionId" | "error" | "errorType"> | undefined
+
+export interface SdkSessionEventCoordinatorOptions {
+	messageTranslatorState: MessageTranslatorState
+	sessions: SdkSessionLifecycle
+	messages: SdkMessageCoordinator
+	mcpTools: SdkMcpCoordinator
+	providerChanges?: Pick<SdkProviderChangeCoordinator, "handleTurnComplete">
+	mode: SdkModeCoordinator
+	taskHistory: SdkTaskHistory
+	getTask: () => TaskProxy | undefined
+	postStateToWebview: () => Promise<void>
+	stateManager?: StateManager
+	translateSessionEvent?: (event: CoreSessionEvent, state: MessageTranslatorState) => TranslationResult
+	isClineFreeModel?: () => Promise<boolean>
+	/**
+	 * Set the authoritative UI turn phase. Called as the agent streams (streaming), on a
+	 * completed turn (completed if attempt_completion was used, else awaiting_followup), and on
+	 * error. Optional for tests.
+	 */
+	setTurnPhase?: (phase: TurnPhase, anchorTs?: number) => void
+	captureProviderApiError?: (event: ProviderFailureTelemetry) => void
+	beginProviderFailureTelemetryTurn?: () => void
+}
+
+export class SdkSessionEventCoordinator {
+	private readonly translateSessionEvent: (event: CoreSessionEvent, state: MessageTranslatorState) => TranslationResult
+
+	constructor(private readonly options: SdkSessionEventCoordinatorOptions) {
+		this.translateSessionEvent = options.translateSessionEvent ?? translateSessionEvent
+	}
+
+	async handleSessionEvent(event: CoreSessionEvent): Promise<void> {
+		this.logQueueEvents(event)
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession || event.payload.sessionId !== activeSession.sessionId) {
+			Logger.debug(
+				`[SdkController] Ignoring stale SDK event for session ${event.payload.sessionId}; active=${activeSession?.sessionId ?? "none"}`,
+			)
+			return
+		}
+
+		if (event.type === "pending_prompts") {
+			this.options.postStateToWebview().catch((err) => {
+				Logger.error("[SdkController] Failed to post pending-prompt state update:", err)
+			})
+		}
+
+		const result = this.translateSessionEvent(event, this.options.messageTranslatorState)
+		const agentFailure = this.getAgentFailureTelemetry(event)
+		if (agentFailure && !this.options.messageTranslatorState.isSuppressedToolApprovalDenial(agentFailure.error)) {
+			this.options.captureProviderApiError?.({
+				sessionId: agentFailure.sessionId,
+				error: agentFailure.error,
+				errorType: agentFailure.errorType,
+				failurePhase: PROVIDER_FAILURE_PHASE.STREAMING,
+			})
+		}
+		if (event.type === "pending_prompt_submitted") {
+			this.options.beginProviderFailureTelemetryTurn?.()
+			this.options.messageTranslatorState.clearTurnOutcome()
+			this.options.sessions.setRunning(true)
+			this.options.setTurnPhase?.(PROVIDER_FAILURE_PHASE.STREAMING)
+		}
+		const zeroCostPromise = this.zeroCostForFreeClineModel(result)
+		if (zeroCostPromise) {
+			await zeroCostPromise
+		}
+
+		if (!activeSession.isRunning && result.messages.length > 0) {
+			result.messages = result.messages.filter(
+				(m) => !(m.type === "ask" && (m.ask === "completion_result" || m.ask === "resume_completed_task")),
+			)
+		}
+
+		if (result.messages.length > 0) {
+			this.options.messages.appendAndEmit(result.messages, event)
+		}
+
+		if (activeSession) {
+			if (result.sessionEnded || result.turnComplete) {
+				// Authoritative UI phase at turn end. If the completion tool was used this turn
+				// the phase is "completed" (green box + Start New Task); otherwise the agent
+				// simply stopped and is waiting for the user ("awaiting_followup"). Error turns
+				// are surfaced as the error phase. The webview reads this, not the array tail.
+				//
+				// EXCEPTION: if the session is already not running, this turn-complete is a
+				// straggler from a turn that was cancelled (cancelTask already set phase
+				// "resumable" and aborted). Overwriting it here would clobber "resumable" with
+				// "awaiting_followup"/"completed" and the footer would lose the Resume Task button
+				// (showing the scroll-arrow default instead), so the cancel-set phase is preserved.
+				if (!activeSession.isRunning) {
+					Logger.debug("[SdkController] turn-complete straggler after cancel; preserving resumable phase")
+				} else if (this.options.messageTranslatorState.wasAttemptCompletionSeen()) {
+					this.options.setTurnPhase?.("completed")
+				} else {
+					this.options.setTurnPhase?.("awaiting_followup")
+				}
+
+				this.options.sessions.setRunning(false)
+				this.options.mcpTools.checkDeferredRestart()
+
+				if (this.options.providerChanges) {
+					this.options.providerChanges.handleTurnComplete(this.options.mode).catch((err) => {
+						Logger.error("[SdkController] Failed to process deferred provider restart:", err)
+					})
+				} else if (this.options.mode.hasPendingModeChange()) {
+					this.options.mode.applyPendingModeChange().catch((err) => {
+						Logger.error("[SdkController] applyPendingModeChange failed:", err)
+					})
+				}
+			}
+
+			if (result.usage && activeSession.startResult) {
+				Promise.resolve(
+					this.options.taskHistory.updateTaskUsage(
+						this.options.getTask()?.taskId ?? this.options.sessions.getActiveSession()?.sessionId,
+						result.usage,
+					),
+				).catch((error) => {
+					Logger.error("[SdkController] Failed to persist task usage:", error)
+				})
+			}
+		}
+
+		// Post state when there are messages to ship OR when the turn ended. A clean turn end's
+		// `done` event carries no transcript message, yet the authoritative phase just changed to
+		// completed/awaiting_followup/error above; without posting here the webview would stay on
+		// the prior phase (footer stuck on the streaming/scroll state). The webview reducer gates
+		// turnState by seq, so an extra no-message post is safe.
+		if (
+			result.messages.length > 0 ||
+			result.sessionEnded ||
+			result.turnComplete ||
+			event.type === "pending_prompt_submitted"
+		) {
+			this.options.postStateToWebview().catch((err) => {
+				Logger.error("[SdkController] Failed to post state after event:", err)
+			})
+		}
+	}
+
+	private getAgentFailureTelemetry(event: CoreSessionEvent): AgentFailureTelemetry {
+		if (event.type !== "agent_event") {
+			return undefined
+		}
+
+		const agentEvent: AgentEvent = event.payload.event
+		if (agentEvent.type === "error") {
+			if (agentEvent.error == null) {
+				return undefined
+			}
+			return {
+				sessionId: event.payload.sessionId,
+				error: agentEvent.error,
+				errorType: PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_ERROR,
+			}
+		}
+		if (agentEvent.type === "done" && agentEvent.reason === "error") {
+			const errorMessage = agentEvent.text.trim() || "SDK agent finished with error"
+			return {
+				sessionId: event.payload.sessionId,
+				error: errorMessage,
+				errorType: PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_DONE_ERROR,
+			}
+		}
+		return undefined
+	}
+
+	private zeroCostForFreeClineModel(result: TranslationResult): Promise<void> | undefined {
+		const hasUsageCost = typeof result.usage?.totalCost === "number" && result.usage.totalCost !== 0
+		const hasMessageCost = result.messages.some((message) => {
+			if (message.type !== "say" || message.say !== "api_req_started" || !message.text) {
+				return false
+			}
+			try {
+				const info = JSON.parse(message.text) as ClineApiReqInfo
+				return typeof info.cost === "number" && info.cost !== 0
+			} catch {
+				return false
+			}
+		})
+
+		if (!hasUsageCost && !hasMessageCost) {
+			return undefined
+		}
+
+		return (async () => {
+			if (!(await this.isCurrentClineModelFree())) {
+				return
+			}
+
+			if (result.usage) {
+				result.usage = { ...result.usage, totalCost: 0 }
+			}
+
+			result.messages = result.messages.map((message) => {
+				if (message.type !== "say" || message.say !== "api_req_started" || !message.text) {
+					return message
+				}
+				try {
+					const info = JSON.parse(message.text) as ClineApiReqInfo
+					if (typeof info.cost !== "number") {
+						return message
+					}
+					return {
+						...message,
+						text: JSON.stringify({ ...info, cost: 0 } satisfies ClineApiReqInfo),
+					}
+				} catch {
+					return message
+				}
+			})
+		})()
+	}
+
+	private async isCurrentClineModelFree(): Promise<boolean> {
+		if (this.options.isClineFreeModel) {
+			return this.options.isClineFreeModel()
+		}
+
+		const stateManager = this.options.stateManager
+		if (!stateManager) {
+			return false
+		}
+
+		try {
+			const apiConfig = stateManager.getApiConfiguration()
+			const mode = stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
+			const provider = mode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider
+			// Free models are also selectable on ClinePass — they ride usage billing at $0
+			if (!isClineManagedProvider(provider)) {
+				return false
+			}
+
+			const modelId = this.getCurrentClineModelId()
+			if (!modelId) {
+				return false
+			}
+
+			const normalizedModelId = normalizeModelId(modelId)
+			const models = await refreshClineRecommendedModels()
+			const freeIds = models.free.map((model) => normalizeModelId(model.id)).filter(Boolean)
+			const resolvedFreeIds =
+				freeIds.length > 0 ? freeIds : CLINE_RECOMMENDED_MODELS_FALLBACK.free.map((model) => normalizeModelId(model.id))
+			return resolvedFreeIds.includes(normalizedModelId)
+		} catch (error) {
+			Logger.error("[SdkController] Failed to check Cline free model list:", error)
+			const modelId = this.getCurrentClineModelId()
+			if (!modelId) {
+				return false
+			}
+			const fallbackFreeIds = CLINE_RECOMMENDED_MODELS_FALLBACK.free.map((model) => normalizeModelId(model.id))
+			return fallbackFreeIds.includes(normalizeModelId(modelId))
+		}
+	}
+
+	private getCurrentClineModelId(): string | undefined {
+		const stateManager = this.options.stateManager
+		if (!stateManager) {
+			return undefined
+		}
+		const apiConfig = stateManager.getApiConfiguration()
+		const mode = stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
+		const provider = mode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider
+		if (provider === "cline-pass") {
+			return mode === "plan" ? apiConfig.planModeClinePassModelId : apiConfig.actModeClinePassModelId
+		}
+		return mode === "plan" ? apiConfig.planModeClineModelId : apiConfig.actModeClineModelId
+	}
+
+	private logQueueEvents(event: CoreSessionEvent): void {
+		if (event.type === "pending_prompts") {
+			const count = event.payload.prompts.length
+			Logger.log(
+				`[SdkController] Pending prompts updated: ${count} prompt(s) in queue for session ${event.payload.sessionId}`,
+			)
+			return
+		}
+
+		if (event.type === "pending_prompt_submitted") {
+			Logger.log(
+				`[SdkController] Pending prompt submitted: "${event.payload.prompt.substring(0, 80)}" for session ${event.payload.sessionId}`,
+			)
+		}
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-session-history-loader.test.ts b/apps/vscode/src/sdk/sdk-session-history-loader.test.ts
new file mode 100644
index 0000000..c90d2b2
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-history-loader.test.ts
@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { SdkSessionHistoryLoader } from "./sdk-session-history-loader"
+import type { SdkSessionHost } from "./session-host"
+
+const getSavedApiConversationHistory = vi.fn().mockResolvedValue([])
+
+vi.mock("@core/storage/disk", () => ({
+	getSavedApiConversationHistory,
+}))
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		log: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+	},
+}))
+
+describe("SdkSessionHistoryLoader", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		getSavedApiConversationHistory.mockResolvedValue([])
+	})
+
+	it("loads and sanitizes SDK-persisted messages first", async () => {
+		const reader = {
+			readMessages: vi.fn().mockResolvedValue([
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "toolu_1", name: "read_file", input: { path: "a.ts" } }],
+				},
+			]),
+		} as unknown as SdkSessionHost
+
+		const result = await new SdkSessionHistoryLoader().loadInitialMessages(reader, "task-1")
+
+		expect(reader.readMessages).toHaveBeenCalledWith("task-1")
+		expect(getSavedApiConversationHistory).not.toHaveBeenCalled()
+		expect(result).toEqual([
+			expect.objectContaining({ role: "assistant" }),
+			expect.objectContaining({
+				role: "user",
+				content: [expect.objectContaining({ type: "tool_result", tool_use_id: "toolu_1" })],
+			}),
+		])
+	})
+
+	it("falls back to classic API history when SDK messages are empty", async () => {
+		const reader = {
+			readMessages: vi.fn().mockResolvedValue([]),
+		} as unknown as SdkSessionHost
+		getSavedApiConversationHistory.mockResolvedValue([{ role: "user", content: "hello" }])
+
+		const result = await new SdkSessionHistoryLoader().loadInitialMessages(reader, "task-1")
+
+		expect(getSavedApiConversationHistory).toHaveBeenCalledWith("task-1")
+		expect(result).toEqual([{ role: "user", content: "hello" }])
+	})
+
+	it("falls back to classic API history when SDK reading fails", async () => {
+		const reader = {
+			readMessages: vi.fn().mockRejectedValue(new Error("boom")),
+		} as unknown as SdkSessionHost
+		getSavedApiConversationHistory.mockResolvedValue([{ role: "user", content: "classic" }])
+
+		const result = await new SdkSessionHistoryLoader().loadInitialMessages(reader, "task-1")
+
+		expect(result).toEqual([{ role: "user", content: "classic" }])
+	})
+
+	it("returns undefined when no history exists", async () => {
+		const reader = {
+			readMessages: vi.fn().mockResolvedValue([]),
+		} as unknown as SdkSessionHost
+
+		const result = await new SdkSessionHistoryLoader().loadInitialMessages(reader, "task-1")
+
+		expect(result).toBeUndefined()
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-session-history-loader.ts b/apps/vscode/src/sdk/sdk-session-history-loader.ts
new file mode 100644
index 0000000..fa71468
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-history-loader.ts
@@ -0,0 +1,42 @@
+import { Logger } from "@/shared/services/Logger"
+import { sanitizeInitialMessagesForSessionStart } from "./initial-message-sanitizer"
+import type { SdkInitialMessages, SdkSessionHost } from "./session-host"
+
+export class SdkSessionHistoryLoader {
+	async loadInitialMessages(sessionHost: SdkSessionHost, taskId: string): Promise<SdkInitialMessages | undefined> {
+		try {
+			const sdkMessages = await sessionHost.readMessages(taskId)
+			if (sdkMessages.length > 0) {
+				const sanitizedMessages = sanitizeInitialMessagesForSessionStart(sdkMessages)
+				if (sanitizedMessages !== sdkMessages) {
+					Logger.log(
+						`[SdkController] Sanitized legacy pairing in SDK-persisted history for task: ${taskId} (${sdkMessages.length} → ${sanitizedMessages.length} messages)`,
+					)
+				}
+				Logger.log(`[SdkController] Loaded ${sanitizedMessages.length} SDK-persisted messages for task: ${taskId}`)
+				return sanitizedMessages
+			}
+		} catch (error) {
+			Logger.warn("[SdkController] Failed to read SDK-persisted messages:", error)
+		}
+
+		try {
+			const { getSavedApiConversationHistory } = await import("@core/storage/disk")
+			const apiHistory = await getSavedApiConversationHistory(taskId)
+			if (apiHistory.length > 0) {
+				const sanitizedMessages = sanitizeInitialMessagesForSessionStart(apiHistory as SdkInitialMessages)
+				if (sanitizedMessages !== apiHistory) {
+					Logger.log(
+						`[SdkController] Sanitized legacy pairing in classic API history for task: ${taskId} (${apiHistory.length} → ${sanitizedMessages.length} messages)`,
+					)
+				}
+				Logger.log(`[SdkController] Loaded ${sanitizedMessages.length} classic API messages for task: ${taskId}`)
+				return sanitizedMessages
+			}
+		} catch (error) {
+			Logger.warn("[SdkController] Failed to read classic API conversation history:", error)
+		}
+
+		return undefined
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-session-lifecycle.test.ts b/apps/vscode/src/sdk/sdk-session-lifecycle.test.ts
new file mode 100644
index 0000000..1477fe9
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-lifecycle.test.ts
@@ -0,0 +1,547 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { isAbortError, SdkSessionLifecycle } from "./sdk-session-lifecycle"
+
+type StartInput = Parameters<SdkSessionLifecycle["startNewSession"]>[0]
+type SendHost = Parameters<SdkSessionLifecycle["fireAndForgetSend"]>[0]
+
+const mockCreateSessionHost = vi.hoisted(() => vi.fn())
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: {
+		get: () => ({
+			getGlobalSettingsKey: () => undefined,
+		}),
+	},
+}))
+
+vi.mock("./vscode-session-host", () => ({
+	VscodeSessionHost: {
+		create: mockCreateSessionHost,
+	},
+}))
+
+describe("SdkSessionLifecycle", () => {
+	beforeEach(() => {
+		mockCreateSessionHost.mockReset()
+	})
+
+	it("starts a session and stores active session state", async () => {
+		const unsubscribe = vi.fn()
+		const sdkHost = makeSdkHost({ startResult: { sessionId: "session-123" }, unsubscribe })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		const result = await lifecycle.startNewSession({} as any)
+
+		expect(result.startResult.sessionId).toBe("session-123")
+		expect(result.sdkHost).toBe(sdkHost)
+		expect(sdkHost.subscribe).toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()?.sessionId).toBe("session-123")
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(true)
+	})
+
+	it("stores the provider and model config used to start the active session", async () => {
+		const sdkHost = makeSdkHost({ startResult: { sessionId: "session-123" } })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+
+		await lifecycle.startNewSession({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4",
+			},
+		} as StartInput)
+
+		expect(lifecycle.getActiveSession()?.startConfig).toEqual({
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4",
+		})
+	})
+
+	it("reuses the shared session host across sessions", async () => {
+		const sdkHost = makeSdkHost({
+			start: vi.fn().mockResolvedValueOnce({ sessionId: "session-1" }).mockResolvedValueOnce({ sessionId: "session-2" }),
+		})
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+		await lifecycle.endActiveSession("test")
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		expect(mockCreateSessionHost).toHaveBeenCalledOnce()
+		expect(sdkHost.subscribe).toHaveBeenCalledOnce()
+		expect(sdkHost.start).toHaveBeenCalledTimes(2)
+		expect(sdkHost.stop).toHaveBeenCalledWith("session-1")
+		expect(sdkHost.dispose).not.toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()?.sessionId).toBe("session-2")
+	})
+
+	it("replaces an existing active session before starting another without resubscribing", async () => {
+		const unsubscribe = vi.fn()
+		const sdkHost = makeSdkHost({
+			start: vi.fn().mockResolvedValueOnce({ sessionId: "session-1" }).mockResolvedValueOnce({ sessionId: "session-2" }),
+			unsubscribe,
+		})
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		expect(mockCreateSessionHost).toHaveBeenCalledOnce()
+		expect(sdkHost.subscribe).toHaveBeenCalledOnce()
+		expect(sdkHost.stop).toHaveBeenCalledWith("session-1")
+		expect(unsubscribe).not.toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()?.sessionId).toBe("session-2")
+
+		await lifecycle.dispose("testDispose")
+		expect(unsubscribe).toHaveBeenCalledOnce()
+	})
+
+	it("unsubscribes if session start fails", async () => {
+		const unsubscribe = vi.fn()
+		const error = new Error("start failed")
+		const sdkHost = makeSdkHost({ start: vi.fn().mockRejectedValue(error), unsubscribe })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await expect(lifecycle.startNewSession({} as any)).rejects.toBe(error)
+
+		expect(unsubscribe).not.toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()).toBeUndefined()
+
+		await lifecycle.dispose("testDispose")
+		expect(unsubscribe).toHaveBeenCalledOnce()
+	})
+
+	it("disposes the shared host only when the lifecycle is disposed", async () => {
+		const unsubscribe = vi.fn()
+		const sdkHost = makeSdkHost({ startResult: { sessionId: "session-123" }, unsubscribe })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		await lifecycle.dispose("testDispose")
+
+		expect(unsubscribe).toHaveBeenCalledOnce()
+		expect(sdkHost.stop).toHaveBeenCalledWith("session-123")
+		expect(sdkHost.dispose).toHaveBeenCalledWith("testDispose")
+		expect(lifecycle.getActiveSession()).toBeUndefined()
+	})
+
+	it("passes shared telemetry to the VSCode session host", async () => {
+		const telemetry = { capture: vi.fn() }
+		const sdkHost = makeSdkHost({ startResult: { sessionId: "session-123" } })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		const lifecycle = makeLifecycle({ telemetry: telemetry as any })
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		expect(mockCreateSessionHost).toHaveBeenCalledWith(expect.objectContaining({ telemetry }))
+	})
+
+	it("marks the active session idle after a non-queued send completes", async () => {
+		const onSendComplete = vi.fn()
+		const sdkHost = makeSdkHost({ send: vi.fn().mockResolvedValue(undefined) })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle({ onSendComplete })
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		lifecycle.fireAndForgetSend(sdkHost as any, "session-123", "hello")
+		await vi.waitFor(() => expect(onSendComplete).toHaveBeenCalledWith("session-123"))
+
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(false)
+	})
+
+	it("calls the send-start hook before sending to the SDK host", async () => {
+		const onSendStart = vi.fn()
+		const send = vi.fn().mockResolvedValue(undefined)
+		const sdkHost = makeSdkHost({ send })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle({ onSendStart })
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		lifecycle.fireAndForgetSend(sdkHost as any, "session-123", "hello")
+		await vi.waitFor(() => expect(send).toHaveBeenCalled())
+
+		expect(onSendStart).toHaveBeenCalledWith("session-123")
+		expect(onSendStart.mock.invocationCallOrder[0]).toBeLessThan(send.mock.invocationCallOrder[0])
+	})
+
+	it("leaves the active session running when a message is queued", async () => {
+		const onSendComplete = vi.fn()
+		const send = vi.fn().mockResolvedValue(undefined)
+		const sdkHost = makeSdkHost({ send })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle({ onSendComplete })
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		lifecycle.fireAndForgetSend(sdkHost as any, "session-123", "hello", undefined, undefined, "queue")
+		await vi.waitFor(() => expect(send).toHaveBeenCalled())
+
+		expect(onSendComplete).not.toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(true)
+	})
+
+	it("marks the active session idle and reports non-abort send errors", async () => {
+		const onSendError = vi.fn()
+		const error = new Error("boom")
+		const sdkHost = makeSdkHost({ send: vi.fn().mockRejectedValue(error) })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle({ onSendError })
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		lifecycle.fireAndForgetSend(sdkHost as any, "session-123", "hello")
+		await vi.waitFor(() => expect(onSendError).toHaveBeenCalledWith(error, "session-123"))
+
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(false)
+	})
+
+	it("skips completion bookkeeping when the session was replaced before the send settled", async () => {
+		const onSendComplete = vi.fn()
+		let resolveSend: () => void = () => {}
+		const send = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveSend = resolve
+				}),
+		)
+		const sdkHost = makeSdkHost({
+			start: vi
+				.fn()
+				.mockResolvedValueOnce({ sessionId: "plan-session" })
+				.mockResolvedValueOnce({ sessionId: "plan-session" }),
+			send,
+		})
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle({ onSendComplete })
+		await lifecycle.startNewSession({} as StartInput)
+
+		lifecycle.fireAndForgetSend(sdkHost as unknown as SendHost, "plan-session", "make a plan")
+
+		// A mode-change rebuild replaces the session, reusing the SAME sessionId,
+		// and starts an auto-continued turn on it.
+		await lifecycle.replaceActiveSession({
+			startInput: { config: {} } as unknown as StartInput,
+			disposeReason: "modeChange",
+		})
+		lifecycle.setRunning(true)
+
+		// The old send settles only now; its bookkeeping must not touch the successor.
+		resolveSend()
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		expect(onSendComplete).not.toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(true)
+	})
+
+	it("skips error bookkeeping when the session was replaced before the send failed", async () => {
+		const onSendError = vi.fn()
+		let rejectSend: (error: Error) => void = () => {}
+		const send = vi.fn(
+			() =>
+				new Promise<void>((_resolve, reject) => {
+					rejectSend = reject
+				}),
+		)
+		const sdkHost = makeSdkHost({
+			start: vi
+				.fn()
+				.mockResolvedValueOnce({ sessionId: "plan-session" })
+				.mockResolvedValueOnce({ sessionId: "plan-session" }),
+			send,
+		})
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle({ onSendError })
+		await lifecycle.startNewSession({} as StartInput)
+
+		lifecycle.fireAndForgetSend(sdkHost as unknown as SendHost, "plan-session", "make a plan")
+
+		await lifecycle.replaceActiveSession({
+			startInput: { config: {} } as unknown as StartInput,
+			disposeReason: "modeChange",
+		})
+		lifecycle.setRunning(true)
+
+		rejectSend(new Error("boom"))
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		expect(onSendError).not.toHaveBeenCalled()
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(true)
+	})
+
+	it("completes the old session stop before starting a same-id replacement", async () => {
+		let resolveStop: () => void = () => {}
+		const stop = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveStop = resolve
+				}),
+		)
+		const start = vi
+			.fn()
+			.mockResolvedValueOnce({ sessionId: "plan-session" })
+			.mockResolvedValueOnce({ sessionId: "plan-session" })
+		const sdkHost = makeSdkHost({ start, stop })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		await lifecycle.startNewSession({} as StartInput)
+
+		const replacePromise = lifecycle.replaceActiveSession({
+			startInput: { config: { sessionId: "plan-session" } } as unknown as StartInput,
+			disposeReason: "modeChange",
+		})
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		// Core cleanup deletes by sessionId, so the same-id replacement must not
+		// start while the old stop is still in flight.
+		expect(start).toHaveBeenCalledTimes(1)
+
+		resolveStop()
+		const result = await replacePromise
+
+		expect(start).toHaveBeenCalledTimes(2)
+		expect(result?.startResult.sessionId).toBe("plan-session")
+	})
+
+	it("passes compacted initial messages after a same-id replacement stop completes", async () => {
+		let resolveStop: () => void = () => {}
+		const stop = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveStop = resolve
+				}),
+		)
+		const start = vi
+			.fn()
+			.mockResolvedValueOnce({ sessionId: "task-session" })
+			.mockResolvedValueOnce({ sessionId: "task-session" })
+		const sdkHost = makeSdkHost({ start, stop })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		await lifecycle.startNewSession({ config: { sessionId: "task-session" } } as unknown as StartInput)
+
+		const initialMessages = [{ role: "user", content: "compacted summary" }]
+		const replacePromise = lifecycle.replaceActiveSession({
+			startInput: {
+				config: { sessionId: "task-session" },
+				prompt: undefined,
+				interactive: true,
+			} as unknown as StartInput,
+			initialMessages: initialMessages as unknown as StartInput["initialMessages"],
+			disposeReason: "compactTask",
+		})
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		expect(start).toHaveBeenCalledTimes(1)
+
+		resolveStop()
+		const result = await replacePromise
+
+		expect(result?.startResult.sessionId).toBe("task-session")
+		expect(start).toHaveBeenLastCalledWith({
+			config: { sessionId: "task-session" },
+			prompt: undefined,
+			interactive: true,
+			initialMessages,
+		})
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(false)
+	})
+
+	it("waits for a fire-and-forget stop before resuming the same sessionId", async () => {
+		let resolveStop: () => void = () => {}
+		const stop = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveStop = resolve
+				}),
+		)
+		const start = vi.fn().mockResolvedValueOnce({ sessionId: "task-1" }).mockResolvedValueOnce({ sessionId: "task-1" })
+		const sdkHost = makeSdkHost({ start, stop })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		await lifecycle.startNewSession({} as StartInput)
+
+		// The follow-up resume path ends the idle session without awaiting the
+		// stop, then starts a new session reusing the taskId as the sessionId.
+		await lifecycle.endActiveSession("askResponse")
+		const resumePromise = lifecycle.startNewSession({ config: { sessionId: "task-1" } } as unknown as StartInput)
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		expect(start).toHaveBeenCalledTimes(1)
+
+		resolveStop()
+		const result = await resumePromise
+
+		expect(start).toHaveBeenCalledTimes(2)
+		expect(result.startResult.sessionId).toBe("task-1")
+	})
+
+	it("starts a fresh-id session without waiting for an unrelated hung stop", async () => {
+		const stop = vi.fn(() => new Promise<void>(() => {}))
+		const start = vi.fn().mockResolvedValueOnce({ sessionId: "task-1" }).mockResolvedValueOnce({ sessionId: "task-2" })
+		const sdkHost = makeSdkHost({ start, stop })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		await lifecycle.startNewSession({} as StartInput)
+
+		// A brand-new task does not reuse the old sessionId, so it must not be
+		// delayed by the old session's stop.
+		const result = await lifecycle.startNewSession({ config: {} } as unknown as StartInput)
+
+		expect(result.startResult.sessionId).toBe("task-2")
+		expect(stop).toHaveBeenCalledWith("task-1")
+	})
+
+	it("replaces the active session by stopping the old session and reusing the shared host", async () => {
+		const oldUnsubscribe = vi.fn()
+		const sdkHost = makeSdkHost({
+			start: vi
+				.fn()
+				.mockResolvedValueOnce({ sessionId: "old-session" })
+				.mockResolvedValueOnce({ sessionId: "new-session" }),
+			unsubscribe: oldUnsubscribe,
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		})
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		const result = await lifecycle.replaceActiveSession({
+			// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+			startInput: { config: {} } as any,
+			// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+			initialMessages: [{ role: "user", content: "hello" }] as any,
+			disposeReason: "testReplace",
+		})
+
+		expect(result?.oldSessionId).toBe("old-session")
+		expect(result?.startResult.sessionId).toBe("new-session")
+		expect(oldUnsubscribe).not.toHaveBeenCalled()
+		expect(sdkHost.stop).toHaveBeenCalledWith("old-session")
+		expect(sdkHost.dispose).not.toHaveBeenCalled()
+		expect(mockCreateSessionHost).toHaveBeenCalledOnce()
+		expect(sdkHost.subscribe).toHaveBeenCalledOnce()
+		expect(sdkHost.start).toHaveBeenLastCalledWith({
+			config: {},
+			initialMessages: [{ role: "user", content: "hello" }],
+		})
+		expect(lifecycle.getActiveSession()?.sessionId).toBe("new-session")
+		expect(lifecycle.getActiveSession()?.isRunning).toBe(false)
+	})
+
+	it("adopts the restored session and stops the source session", async () => {
+		const restored = {
+			sessionId: "restored-session",
+			startResult: { sessionId: "restored-session" },
+			checkpoint: { ref: "abc", createdAt: 1, runCount: 1 },
+		}
+		const sdkHost = makeSdkHost({
+			startResult: { sessionId: "source-session" },
+			restore: vi.fn().mockResolvedValue(restored),
+		})
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+
+		await lifecycle.startNewSession({
+			config: {
+				sessionId: "source-session",
+				providerId: "openai",
+				modelId: "gpt-5",
+			},
+		} as StartInput)
+		const result = await lifecycle.restoreActiveSession({
+			sessionId: "source-session",
+			checkpointRunCount: 1,
+		})
+
+		expect(result).toBe(restored)
+		expect(lifecycle.getActiveSession()?.sessionId).toBe("restored-session")
+		expect(lifecycle.getActiveSession()?.startConfig).toEqual({
+			providerId: "openai",
+			modelId: "gpt-5",
+		})
+		expect(sdkHost.stop).toHaveBeenCalledWith("source-session")
+	})
+
+	it("updates the active session model for the next turn when supported", async () => {
+		const updateSessionModel = vi.fn().mockResolvedValue(undefined)
+		const sdkHost = makeSdkHost({ startResult: { sessionId: "session-123" }, updateSessionModel })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		const didUpdate = await lifecycle.updateActiveSessionModel("deepseek-v4-flash")
+
+		expect(didUpdate).toBe(true)
+		expect(updateSessionModel).toHaveBeenCalledWith("session-123", "deepseek-v4-flash")
+	})
+
+	it("does not update active session model when no host capability is available", async () => {
+		const sdkHost = makeSdkHost({ startResult: { sessionId: "session-123" } })
+		mockCreateSessionHost.mockResolvedValueOnce(sdkHost)
+		const lifecycle = makeLifecycle()
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		await lifecycle.startNewSession({} as any)
+
+		const didUpdate = await lifecycle.updateActiveSessionModel("deepseek-v4-flash")
+
+		expect(didUpdate).toBe(false)
+	})
+
+	it("detects abort errors", () => {
+		const error = new Error("aborted by user")
+		expect(isAbortError(error)).toBe(true)
+	})
+})
+
+function makeLifecycle(overrides: Partial<ConstructorParameters<typeof SdkSessionLifecycle>[0]> = {}) {
+	return new SdkSessionLifecycle({
+		// biome-ignore lint/suspicious/noExplicitAny: focused fake for lifecycle unit test
+		mcpHub: {} as any,
+		requestToolApproval: vi.fn(),
+		askQuestion: vi.fn(),
+		onSessionEvent: vi.fn(),
+		onSendComplete: vi.fn(),
+		onSendError: vi.fn(),
+		...overrides,
+	})
+}
+
+function makeSdkHost(overrides: Record<string, unknown> = {}) {
+	const startResult = overrides.startResult ?? { sessionId: "session-123" }
+	return {
+		start: vi.fn().mockResolvedValue(startResult),
+		subscribe: vi.fn().mockReturnValue(overrides.unsubscribe ?? vi.fn()),
+		send: vi.fn().mockResolvedValue(undefined),
+		restore: vi.fn().mockResolvedValue({
+			sessionId: "session-123",
+			startResult,
+			checkpoint: { ref: "abc", createdAt: 1, runCount: 1 },
+		}),
+		stop: vi.fn().mockResolvedValue(undefined),
+		dispose: vi.fn().mockResolvedValue(undefined),
+		...overrides,
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-session-lifecycle.ts b/apps/vscode/src/sdk/sdk-session-lifecycle.ts
new file mode 100644
index 0000000..0321f34
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-session-lifecycle.ts
@@ -0,0 +1,381 @@
+import type {
+	CoreSessionEvent,
+	ITelemetryService,
+	PreparedRemoteConfigCoreIntegration,
+	RestoreInput,
+	RestoreResult,
+	StartSessionResult,
+} from "@cline/core"
+import { StateManager } from "@/core/storage/StateManager"
+import { ITerminalManager } from "@/integrations/terminal"
+import { McpHub } from "@/services/mcp/McpHub"
+import { Logger } from "@/shared/services/Logger"
+import type { ActiveSession } from "./cline-session-factory"
+import { buildToolPolicies } from "./sdk-tool-policies"
+import type { SdkSessionHost } from "./session-host"
+import { VscodeSessionHost } from "./vscode-session-host"
+
+type RequestToolApprovalHandler = NonNullable<Parameters<typeof VscodeSessionHost.create>[0]["requestToolApproval"]>
+type AskQuestionHandler = NonNullable<Parameters<typeof VscodeSessionHost.create>[0]["askQuestion"]>
+
+export interface SdkSessionLifecycleOptions {
+	mcpHub: McpHub
+	requestToolApproval: RequestToolApprovalHandler
+	askQuestion: AskQuestionHandler
+	onSessionEvent: (event: CoreSessionEvent) => void
+	/** Lazy factory for the VscodeTerminalManager (foreground terminal support). */
+	getTerminalManager?: () => ITerminalManager
+	/** Returns the latest prepared remote-config integration, if remote config is active. */
+	getRemoteConfigIntegration?: () => PreparedRemoteConfigCoreIntegration | undefined
+	/** Shared SDK telemetry service owned by SdkController. */
+	telemetry?: ITelemetryService
+	onSendStart?: (sessionId: string) => void
+	onSendComplete: (sessionId: string) => Promise<void> | void
+	onSendError: (error: unknown, sessionId: string) => Promise<void> | void
+}
+
+export class SdkSessionLifecycle {
+	private activeSession: ActiveSession | undefined
+	private sharedHost: SdkSessionHost | undefined
+	private sharedHostPromise: Promise<SdkSessionHost> | undefined
+	private sharedHostUnsubscribe: (() => void) | undefined
+	/**
+	 * Stops still in flight, keyed by sessionId. Mode/MCP rebuilds and
+	 * follow-up resumes reuse the sessionId of the session they replace, and
+	 * core cleanup is keyed by sessionId, so a same-id start that overlaps a
+	 * stop would be torn down by the old session's late cleanup.
+	 * startNewSession consults this map to enforce stop-before-start, the same
+	 * sequencing the CLI uses.
+	 */
+	private readonly pendingStops = new Map<string, Promise<void>>()
+
+	constructor(private readonly options: SdkSessionLifecycleOptions) {}
+
+	getActiveSession(): ActiveSession | undefined {
+		return this.activeSession
+	}
+
+	setRunning(isRunning: boolean): void {
+		if (this.activeSession) {
+			this.activeSession.isRunning = isRunning
+		}
+	}
+
+	private clearActiveSessionReference(): ActiveSession | undefined {
+		const activeSession = this.activeSession
+		this.activeSession = undefined
+		return activeSession
+	}
+
+	async endActiveSession(
+		reason: string,
+		options: { awaitStop?: boolean; timeoutMs?: number } = {},
+	): Promise<ActiveSession | undefined> {
+		const activeSession = this.clearActiveSessionReference()
+		if (!activeSession) {
+			return undefined
+		}
+
+		this.safeUnsubscribe(activeSession, reason)
+		const stopPromise = this.trackSessionStop(activeSession.sdkHost, activeSession.sessionId, reason)
+		if (options.awaitStop) {
+			const timeoutMs = options.timeoutMs ?? 3000
+			const stopped = await this.waitForStop(stopPromise, timeoutMs)
+			if (!stopped) {
+				Logger.warn(
+					`[SdkController] Timed out stopping SDK session ${activeSession.sessionId} after ${timeoutMs}ms (${reason})`,
+				)
+			}
+		}
+		return activeSession
+	}
+
+	async updateActiveSessionModel(modelId: string): Promise<boolean> {
+		const activeSession = this.activeSession
+		if (!activeSession?.sdkHost.updateSessionModel) {
+			return false
+		}
+
+		await activeSession.sdkHost.updateSessionModel(activeSession.sessionId, modelId)
+		return true
+	}
+
+	async startNewSession(
+		startInput: Parameters<VscodeSessionHost["start"]>[0],
+	): Promise<{ startResult: StartSessionResult; sdkHost: SdkSessionHost }> {
+		if (this.activeSession) {
+			await this.endActiveSession("startNewSession")
+		}
+
+		// Same-id starts must wait for the previous session's stop to finish;
+		// see pendingStops. A fresh id cannot conflict, so it never waits.
+		const requestedSessionId = startInput.config?.sessionId?.trim()
+		const pendingStop = requestedSessionId ? this.pendingStops.get(requestedSessionId) : undefined
+		if (pendingStop) {
+			Logger.log(`[SdkController] Waiting for session ${requestedSessionId} to stop before restarting it`)
+			await pendingStop
+		}
+
+		const autoApprovalSettings = StateManager.get().getGlobalSettingsKey("autoApprovalSettings")
+		const toolPolicies = autoApprovalSettings ? buildToolPolicies(autoApprovalSettings, this.options.mcpHub) : undefined
+
+		const sdkHost = await this.getOrCreateSharedHost()
+
+		const startResult = await sdkHost.start({
+			...startInput,
+			...(toolPolicies ? { toolPolicies } : {}),
+		})
+		this.activeSession = {
+			sessionId: startResult.sessionId,
+			startConfig: startInput.config
+				? {
+						providerId: startInput.config.providerId,
+						modelId: startInput.config.modelId,
+					}
+				: undefined,
+			sdkHost,
+			unsubscribe: () => {},
+			startResult,
+			isRunning: true,
+		}
+
+		return { startResult, sdkHost }
+	}
+
+	async replaceActiveSession(options: {
+		startInput: Parameters<VscodeSessionHost["start"]>[0]
+		initialMessages?: Parameters<VscodeSessionHost["start"]>[0]["initialMessages"]
+		disposeReason: string
+	}): Promise<
+		| {
+				oldSessionId: string
+				startResult: StartSessionResult
+				sdkHost: SdkSessionHost
+		  }
+		| undefined
+	> {
+		const oldSession = this.activeSession
+		if (!oldSession) {
+			return undefined
+		}
+
+		const { sessionId: oldSessionId } = oldSession
+
+		// No need to await the stop here: callers reuse oldSessionId in the
+		// startInput, and startNewSession waits on the pending stop for it.
+		await this.endActiveSession(options.disposeReason)
+
+		const { startResult, sdkHost } = await this.startNewSession({
+			...options.startInput,
+			...(options.initialMessages ? { initialMessages: options.initialMessages } : {}),
+		})
+		this.setRunning(false)
+
+		return { oldSessionId, startResult, sdkHost }
+	}
+
+	async restoreActiveSession(input: RestoreInput): Promise<RestoreResult> {
+		const activeSession = this.activeSession
+		if (!activeSession) {
+			throw new Error("No active SDK session to restore")
+		}
+
+		const sourceSessionId = activeSession.sessionId
+		const restored = await activeSession.sdkHost.restore(input)
+		if (!restored.startResult || !restored.sessionId) {
+			return restored
+		}
+
+		this.activeSession = {
+			...activeSession,
+			sessionId: restored.sessionId,
+			startConfig: input.start?.config
+				? {
+						providerId: input.start.config.providerId,
+						modelId: input.start.config.modelId,
+					}
+				: activeSession.startConfig,
+			startResult: restored.startResult,
+			isRunning: false,
+		}
+
+		if (restored.sessionId !== sourceSessionId) {
+			const stopPromise = this.trackSessionStop(activeSession.sdkHost, sourceSessionId, "restoreActiveSession")
+			stopPromise.catch((error) => {
+				Logger.warn(`[SdkController] Failed to stop source session after checkpoint restore: ${sourceSessionId}`, error)
+			})
+		}
+
+		return restored
+	}
+
+	async dispose(reason = "SdkSessionLifecycle.dispose"): Promise<void> {
+		await this.endActiveSession(reason, { awaitStop: true })
+
+		const sharedHost = this.sharedHost ?? (await this.sharedHostPromise?.catch(() => undefined))
+		this.sharedHost = undefined
+		this.sharedHostPromise = undefined
+		this.sharedHostUnsubscribe?.()
+		this.sharedHostUnsubscribe = undefined
+		await sharedHost?.dispose(reason)
+	}
+
+	private createSafeUnsubscribe(unsubscribe: () => void, label: string): () => void {
+		let unsubscribed = false
+		return () => {
+			if (unsubscribed) {
+				return
+			}
+			unsubscribed = true
+			try {
+				unsubscribe()
+			} catch (error) {
+				Logger.warn(`[SdkController] Failed to unsubscribe SDK session listener (${label}):`, error)
+			}
+		}
+	}
+
+	private safeUnsubscribe(activeSession: ActiveSession, reason: string): void {
+		activeSession.unsubscribe()
+		Logger.debug(`[SdkController] Unsubscribed SDK session listener: ${activeSession.sessionId} (${reason})`)
+	}
+
+	private ensureSharedHostSubscription(sdkHost: SdkSessionHost): void {
+		if (this.sharedHostUnsubscribe) {
+			return
+		}
+		this.sharedHostUnsubscribe = this.createSafeUnsubscribe(sdkHost.subscribe(this.options.onSessionEvent), "shared-host")
+	}
+
+	/**
+	 * Starts the session's stop and records it in pendingStops until it
+	 * settles. The returned promise never rejects.
+	 */
+	private trackSessionStop(sdkHost: SdkSessionHost, sessionId: string, reason: string): Promise<void> {
+		const startedAt = Date.now()
+		const stopPromise = sdkHost
+			.stop(sessionId)
+			.then(() => {
+				const elapsed = Date.now() - startedAt
+				if (elapsed > 250) {
+					Logger.log(`[SdkController] SDK session ${sessionId} stopped in ${elapsed}ms (${reason})`)
+				}
+			})
+			.catch((error: unknown) => {
+				Logger.warn(`[SdkController] Failed to stop SDK session ${sessionId} (${reason}):`, error)
+			})
+			.finally(() => {
+				if (this.pendingStops.get(sessionId) === stopPromise) {
+					this.pendingStops.delete(sessionId)
+				}
+			})
+		this.pendingStops.set(sessionId, stopPromise)
+		return stopPromise
+	}
+
+	private async waitForStop(stopPromise: Promise<void>, timeoutMs: number): Promise<boolean> {
+		let timeoutHandle: ReturnType<typeof setTimeout> | undefined
+		try {
+			const timeout = new Promise<"timeout">((resolve) => {
+				timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs)
+			})
+			const result = await Promise.race([stopPromise.then(() => "stopped" as const), timeout])
+			return result === "stopped"
+		} finally {
+			clearTimeout(timeoutHandle)
+		}
+	}
+
+	private async getOrCreateSharedHost(): Promise<SdkSessionHost> {
+		if (this.sharedHost) {
+			this.ensureSharedHostSubscription(this.sharedHost)
+			return this.sharedHost
+		}
+		if (!this.sharedHostPromise) {
+			// Host-lifetime dependencies only. Anything task/session-specific must be
+			// supplied to sdkHost.start(...), otherwise it can leak across reused sessions.
+			this.sharedHostPromise = VscodeSessionHost.create({
+				mcpHub: this.options.mcpHub,
+				requestToolApproval: this.options.requestToolApproval,
+				askQuestion: this.options.askQuestion,
+				getTerminalManager: this.options.getTerminalManager,
+				getRemoteConfigIntegration: this.options.getRemoteConfigIntegration,
+				telemetry: this.options.telemetry,
+			})
+				.then((sdkHost) => {
+					this.ensureSharedHostSubscription(sdkHost)
+					this.sharedHost = sdkHost
+					return sdkHost
+				})
+				.finally(() => {
+					this.sharedHostPromise = undefined
+				})
+		}
+		return this.sharedHostPromise
+	}
+
+	fireAndForgetSend(
+		sdkHost: SdkSessionHost,
+		sessionId: string,
+		prompt: string,
+		images?: string[],
+		files?: string[],
+		delivery?: "queue" | "steer",
+	): void {
+		// Captured by object identity, not sessionId: rebuilds (mode change) reuse
+		// the same sessionId for the replacement session, so only reference
+		// equality can tell this send's session apart from a successor. If the
+		// session was replaced by the time the send settles, the settle callbacks
+		// must not run bookkeeping against the successor (e.g. flipping a live
+		// auto-continued run to isRunning=false, which makes the event coordinator
+		// treat the new turn's completion as a cancelled-turn straggler).
+		const sessionAtSend = this.activeSession
+		const isSuperseded = (label: string): boolean => {
+			if (this.activeSession === sessionAtSend) {
+				return false
+			}
+			Logger.debug(`[SdkController] Ignoring ${label} of superseded send for session: ${sessionId}`)
+			return true
+		}
+		this.options.onSendStart?.(sessionId)
+		sdkHost
+			.send({
+				sessionId,
+				prompt,
+				userImages: images,
+				userFiles: files,
+				delivery,
+			})
+			.then(async () => {
+				if (delivery === "queue" || delivery === "steer") {
+					Logger.log(`[SdkController] Message queued for session: ${sessionId}`)
+					return
+				}
+				if (isSuperseded("completion")) {
+					return
+				}
+				Logger.log(`[SdkController] Agent turn completed for session: ${sessionId}`)
+				this.setRunning(false)
+				await this.options.onSendComplete(sessionId)
+			})
+			.catch(async (error: unknown) => {
+				if (isAbortError(error)) {
+					Logger.debug(`[SdkController] Agent turn aborted (expected): ${sessionId}`)
+					return
+				}
+				if (isSuperseded("failure")) {
+					return
+				}
+				Logger.error("[SdkController] Agent turn failed:", error)
+				this.setRunning(false)
+				await this.options.onSendError(error, sessionId)
+			})
+	}
+}
+
+export function isAbortError(error: unknown): boolean {
+	if (error instanceof Error) {
+		return error.name === "AbortError" || error.message.toLowerCase().includes("aborted")
+	}
+	return false
+}
diff --git a/apps/vscode/src/sdk/sdk-task-control-coordinator.test.ts b/apps/vscode/src/sdk/sdk-task-control-coordinator.test.ts
new file mode 100644
index 0000000..eee6616
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-task-control-coordinator.test.ts
@@ -0,0 +1,257 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { SdkTaskControlCoordinator, type SdkTaskControlCoordinatorOptions } from "./sdk-task-control-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		debug: vi.fn(),
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("SdkTaskControlCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("cancels the active session and emits a resume task ask", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		await coordinator.cancelTask()
+
+		expect(options.interactions.clearPending).toHaveBeenCalledWith("Task cancelled")
+		expect(activeSession.sdkHost.abort).toHaveBeenCalledWith("session-123")
+		expect(options.sessions.setRunning).toHaveBeenCalledWith(false)
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ type: "ask", ask: "resume_task" })],
+			{ type: "status", payload: { sessionId: "session-123", status: "cancelled" } },
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("raises the cancel fence BEFORE aborting the session (so stragglers are fenced)", async () => {
+		const activeSession = makeActiveSession()
+		const { coordinator, options } = makeCoordinator({ activeSession })
+
+		const order: string[] = []
+		;(options.raiseCancelFence as ReturnType<typeof vi.fn>).mockImplementation(() => order.push("fence"))
+		;(activeSession.sdkHost.abort as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+			order.push("abort")
+		})
+
+		await coordinator.cancelTask()
+
+		expect(options.raiseCancelFence).toHaveBeenCalledOnce()
+		expect(order).toEqual(["fence", "abort"])
+	})
+
+	it("clears the active session and task proxy without writing classic UI message persistence", async () => {
+		const activeSession = makeActiveSession()
+		const task = makeTask("task-1", [{ ts: 1, type: "say", say: "text", text: "hi", partial: true }])
+		const { coordinator, options, state } = makeCoordinator({ activeSession, task })
+
+		await coordinator.clearTask()
+
+		expect(options.interactions.clearPending).toHaveBeenCalledWith("Task cleared")
+		expect(options.sessions.endActiveSession).toHaveBeenCalledWith("clearTask")
+		expect(options.messages.finalizeMessagesForSave).not.toHaveBeenCalled()
+		expect(options.messages.cancelPendingSave).toHaveBeenCalledOnce()
+		expect(task.messageStateHandler.clear).toHaveBeenCalledOnce()
+		expect(state.task).toBeUndefined()
+		expect(options.resetMessageTranslator).toHaveBeenCalledOnce()
+	})
+
+	it("shows a task by creating a proxy, loading messages, and appending a fresh resume ask", async () => {
+		const existingTask = makeTask("old-task")
+		const activeSession = makeActiveSession()
+		const sdkClineMessages: ClineMessage[] = [
+			{ ts: 1, type: "say", say: "task", text: "hello" },
+			{ ts: 2, type: "ask", ask: "completion_result", text: "" },
+		]
+		const { coordinator, options, state } = makeCoordinator({
+			activeSession,
+			task: existingTask,
+			hasHistoryItem: true,
+			clineMessages: sdkClineMessages,
+		})
+
+		await coordinator.showTaskWithId("task-1")
+
+		expect(options.taskHistory.findHistoryItem).toHaveBeenCalledWith("task-1")
+		expect(options.sessions.endActiveSession).toHaveBeenCalledWith("showTaskWithId")
+		expect(existingTask.messageStateHandler.clear).toHaveBeenCalledOnce()
+		expect(options.resetMessageTranslator).toHaveBeenCalledOnce()
+		expect(state.task?.taskId).toBe("task-1")
+		expect(options.taskHistory.getClineMessages).toHaveBeenCalledWith("task-1")
+		expect(state.task?.messageStateHandler.getClineMessages()).toEqual([
+			{ ts: 1, type: "say", say: "task", text: "hello" },
+			{ ts: 2, type: "ask", ask: "completion_result", text: "" },
+			expect.objectContaining({ type: "ask", ask: "resume_completed_task" }),
+		])
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("does not show a task that is missing from history", async () => {
+		const { coordinator, options } = makeCoordinator({ hasHistoryItem: false })
+
+		await coordinator.showTaskWithId("missing-task")
+
+		expect(options.setTask).not.toHaveBeenCalled()
+		expect(options.taskHistory.getClineMessages).not.toHaveBeenCalled()
+	})
+
+	it("does not install the new task proxy until its messages are loaded", async () => {
+		const sdkClineMessages: ClineMessage[] = [
+			{ ts: 1, type: "say", say: "task", text: "hello" },
+			{ ts: 2, type: "ask", ask: "completion_result", text: "" },
+		]
+
+		let resolveGetClineMessages: ((messages: ClineMessage[]) => void) | undefined
+		const getClineMessagesDeferred = new Promise<ClineMessage[]>((resolve) => {
+			resolveGetClineMessages = resolve
+		})
+
+		const { coordinator, options, state } = makeCoordinator({
+			hasHistoryItem: true,
+			clineMessages: sdkClineMessages,
+		})
+		options.taskHistory.getClineMessages.mockReturnValueOnce(getClineMessagesDeferred)
+
+		let setTaskHadMessages: boolean | undefined
+		options.setTask.mockImplementation((task: any) => {
+			setTaskHadMessages = (task?.messageStateHandler?.getClineMessages?.() ?? []).length > 0
+			state.task = task
+		})
+
+		const inFlight = coordinator.showTaskWithId("task-1")
+
+		// While getClineMessages is still pending, the new task proxy must not be
+		// installed — otherwise concurrent postStateToWebview() callers would see
+		// currentTaskItem.id with an empty messageStateHandler.
+		await Promise.resolve()
+		await Promise.resolve()
+		expect(options.setTask).not.toHaveBeenCalled()
+		expect(state.task).toBeUndefined()
+
+		resolveGetClineMessages?.(sdkClineMessages)
+		await inFlight
+
+		expect(options.setTask).toHaveBeenCalledTimes(1)
+		expect(setTaskHadMessages).toBe(true)
+		expect(state.task?.taskId).toBe("task-1")
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const state: { task?: ReturnType<typeof makeTask> } = {
+		task: input.task,
+	}
+	const options = {
+		sessions: {
+			getActiveSession: vi.fn(() => input.activeSession),
+			endActiveSession: vi.fn().mockResolvedValue(input.activeSession),
+			setRunning: vi.fn(),
+		},
+		interactions: {
+			clearPending: vi.fn(),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+			appendMessages: vi.fn(),
+			cancelPendingSave: vi.fn(),
+			finalizeMessagesForSave: vi.fn((messages: ClineMessage[]) =>
+				messages.map((message) => {
+					if (!message.partial) {
+						return message
+					}
+					const { partial: _partial, ...rest } = message
+					return { ...rest, text: "final" }
+				}),
+			),
+		},
+		taskHistory: {
+			getClineMessages: vi.fn().mockResolvedValue(input.clineMessages ?? []),
+			findHistoryItem: vi.fn(() =>
+				input.hasHistoryItem === false
+					? undefined
+					: {
+							id: "task-1",
+							ts: 1,
+							task: "hello",
+							tokensIn: 0,
+							tokensOut: 0,
+							totalCost: 0,
+						},
+			),
+		},
+		getTask: vi.fn(() => state.task),
+		setTask: vi.fn((task) => {
+			state.task = task as ReturnType<typeof makeTask> | undefined
+		}),
+		onAskResponse: vi.fn().mockResolvedValue(undefined),
+		resetMessageTranslator: vi.fn(),
+		raiseCancelFence: vi.fn(),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+	} as unknown as SdkTaskControlCoordinatorOptions & {
+		sessions: SdkTaskControlCoordinatorOptions["sessions"] & {
+			getActiveSession: ReturnType<typeof vi.fn>
+			endActiveSession: ReturnType<typeof vi.fn>
+			setRunning: ReturnType<typeof vi.fn>
+		}
+		interactions: SdkTaskControlCoordinatorOptions["interactions"] & { clearPending: ReturnType<typeof vi.fn> }
+		messages: SdkTaskControlCoordinatorOptions["messages"] & {
+			appendAndEmit: ReturnType<typeof vi.fn>
+			appendMessages: ReturnType<typeof vi.fn>
+			cancelPendingSave: ReturnType<typeof vi.fn>
+			finalizeMessagesForSave: ReturnType<typeof vi.fn>
+		}
+		taskHistory: SdkTaskControlCoordinatorOptions["taskHistory"] & {
+			findHistoryItem: ReturnType<typeof vi.fn>
+			getClineMessages: ReturnType<typeof vi.fn>
+		}
+		getTask: ReturnType<typeof vi.fn>
+		setTask: ReturnType<typeof vi.fn>
+		resetMessageTranslator: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkTaskControlCoordinator(options),
+		options,
+		state,
+	}
+}
+
+interface MakeCoordinatorInput {
+	activeSession: ReturnType<typeof makeActiveSession>
+	task: ReturnType<typeof makeTask>
+	hasHistoryItem: boolean
+	clineMessages: ClineMessage[]
+}
+
+function makeActiveSession() {
+	return {
+		sessionId: "session-123",
+		sdkHost: {
+			abort: vi.fn().mockResolvedValue(undefined),
+			stop: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		},
+		unsubscribe: vi.fn(),
+		isRunning: true,
+	}
+}
+
+function makeTask(taskId: string, messages: ClineMessage[] = []) {
+	return {
+		taskId,
+		messageStateHandler: {
+			getClineMessages: vi.fn(() => messages),
+			clear: vi.fn(),
+		},
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-task-control-coordinator.ts b/apps/vscode/src/sdk/sdk-task-control-coordinator.ts
new file mode 100644
index 0000000..b391ea7
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-task-control-coordinator.ts
@@ -0,0 +1,156 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { Logger } from "@/shared/services/Logger"
+import type { SdkInteractionCoordinator } from "./sdk-interaction-coordinator"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import { isAbortError, type SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { SdkTaskHistory } from "./sdk-task-history"
+import { createTaskProxy, type TaskProxy } from "./task-proxy"
+
+export interface SdkTaskControlCoordinatorOptions {
+	sessions: SdkSessionLifecycle
+	interactions: SdkInteractionCoordinator
+	messages: SdkMessageCoordinator
+	taskHistory: SdkTaskHistory
+	getTask: () => TaskProxy | undefined
+	setTask: (task: TaskProxy | undefined) => void
+	onAskResponse: (text?: string, images?: string[], files?: string[]) => Promise<void>
+	resetMessageTranslator: () => void
+	postStateToWebview: () => Promise<void>
+	/**
+	 * Raise the cancel fence SYNCHRONOUSLY before aborting the SDK session: bump the epoch so any
+	 * straggler events the SDK emits after the abort request carry the old epoch (and are dropped
+	 * by the webview), and mark the active turn cancelled so the session-event coordinator
+	 * suppresses its remaining DISPLAY output (usage is still accounted).
+	 */
+	raiseCancelFence?: () => void
+}
+
+export class SdkTaskControlCoordinator {
+	constructor(private readonly options: SdkTaskControlCoordinatorOptions) {}
+
+	async cancelTask(): Promise<void> {
+		this.options.interactions.clearPending("Task cancelled")
+
+		const activeSession = this.options.sessions.getActiveSession()
+		if (!activeSession) {
+			Logger.warn("[SdkController] cancelTask: No active session")
+			return
+		}
+
+		const { sdkHost, sessionId } = activeSession
+
+		// FENCE FIRST: raise the cancel fence synchronously BEFORE awaiting the abort. Any event
+		// the SDK emits after this point carries the old epoch (dropped by the webview) and is
+		// marked cancelled (display suppressed by the session-event coordinator; usage still
+		// accounted). Order matters — aborting first would leave a window where a straggler gets
+		// the new epoch.
+		this.options.raiseCancelFence?.()
+
+		try {
+			await sdkHost.abort(sessionId)
+		} catch (error) {
+			if (!isAbortError(error)) {
+				Logger.error("[SdkController] Failed to abort session:", error)
+			} else {
+				Logger.debug(`[SdkController] AbortError during cancelTask (expected): ${sessionId}`)
+			}
+		}
+
+		this.options.sessions.setRunning(false)
+
+		const resumeMessage: ClineMessage = {
+			ts: Date.now(),
+			type: "ask",
+			ask: "resume_task",
+			text: "",
+			partial: false,
+		}
+		this.options.messages.appendAndEmit([resumeMessage], { type: "status", payload: { sessionId, status: "cancelled" } })
+
+		await this.options.postStateToWebview()
+		Logger.log(`[SdkController] Task cancelled: ${sessionId}`)
+	}
+
+	async clearTask(): Promise<void> {
+		this.options.interactions.clearPending("Task cleared")
+
+		await this.options.sessions.endActiveSession("clearTask")
+
+		const task = this.options.getTask()
+		if (task) {
+			// SDK session persistence owns conversation history. Do not write classic
+			// ui_messages.json here; history viewing reloads from SDK readMessages().
+			this.options.messages.cancelPendingSave()
+			task.messageStateHandler.clear()
+			this.options.setTask(undefined)
+		}
+
+		this.options.resetMessageTranslator()
+	}
+
+	async showTaskWithId(taskId: string, options: { skipHistoryLookup?: boolean } = {}): Promise<void> {
+		try {
+			if (!options.skipHistoryLookup) {
+				const historyItem = await this.options.taskHistory.findHistoryItem(taskId)
+				if (!historyItem) {
+					Logger.error(`[SdkController] Task not found in history: ${taskId}`)
+					return
+				}
+			}
+
+			await this.options.sessions.endActiveSession("showTaskWithId")
+
+			const currentTask = this.options.getTask()
+			if (currentTask) {
+				currentTask.messageStateHandler.clear()
+			}
+
+			this.options.resetMessageTranslator()
+
+			// Load messages before installing the new task proxy so any concurrent
+			// postStateToWebview() caller never sees the new id with empty messages.
+			const rawMessages = await this.options.taskHistory.getClineMessages(taskId)
+			const messages = this.options.messages.finalizeMessagesForSave(rawMessages)
+			const cleanedMessages = messages.length > 0 ? this.appendFreshResumeMessage(messages) : []
+
+			const task = createTaskProxy(
+				taskId,
+				(text?: string, images?: string[], files?: string[]) => this.options.onAskResponse(text, images, files),
+				() => this.cancelTask(),
+			)
+			if (cleanedMessages.length > 0) {
+				task.messageStateHandler.addMessages(cleanedMessages)
+			}
+			this.options.setTask(task)
+
+			if (cleanedMessages.length > 0) {
+				Logger.log(`[SdkController] Loaded ${cleanedMessages.length} messages for task: ${taskId}`)
+			} else {
+				Logger.log(`[SdkController] No messages found for task: ${taskId}`)
+			}
+
+			// The final state update below includes the loaded clineMessages. Avoid pushing
+			// each historical message through the partial-message stream one-by-one; for
+			// long tasks that serial loop can dominate history-open latency.
+			await this.options.postStateToWebview()
+			Logger.log(`[SdkController] Showing task: ${taskId}`)
+		} catch (error) {
+			Logger.error("[SdkController] Failed to show task:", error)
+		}
+	}
+
+	private appendFreshResumeMessage(messages: ClineMessage[]): ClineMessage[] {
+		const lastRelevantMessage = [...messages]
+			.reverse()
+			.find((m) => m.ask !== "resume_task" && m.ask !== "resume_completed_task")
+		const resumeAsk = lastRelevantMessage?.ask === "completion_result" ? "resume_completed_task" : "resume_task"
+		const cleanedMessages = messages.filter((m) => m.ask !== "resume_task" && m.ask !== "resume_completed_task")
+		cleanedMessages.push({
+			ts: Date.now(),
+			type: "ask",
+			ask: resumeAsk,
+			text: "",
+		})
+		return cleanedMessages
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-task-history.test.ts b/apps/vscode/src/sdk/sdk-task-history.test.ts
new file mode 100644
index 0000000..8723772
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-task-history.test.ts
@@ -0,0 +1,798 @@
+import type { SessionHistoryRecord } from "@cline/core"
+import type { HistoryItem } from "@shared/HistoryItem"
+import getFolderSize from "get-folder-size"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import type { McpHub } from "@/services/mcp/McpHub"
+import type { TelemetryService } from "@/services/telemetry/TelemetryService"
+import { deleteLegacyTask, readApiConversationHistory, readTaskHistory } from "./legacy-state-reader"
+import { sdkMessagesToClineMessages } from "./message-translator"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import { SdkTaskHistory, sessionHistoryRecordToHistoryItem } from "./sdk-task-history"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+vi.mock("@/core/storage/disk", () => ({
+	GlobalFileNames: {
+		apiConversationHistory: "api_conversation_history.json",
+		contextHistory: "context_history.json",
+		taskMetadata: "task_metadata.json",
+		uiMessages: "ui_messages.json",
+	},
+}))
+
+vi.mock("@/hosts/host-provider", () => ({
+	HostProvider: {
+		get: vi.fn(() => ({ globalStorageFsPath: "/tmp/cline" })),
+	},
+}))
+
+vi.mock("@/utils/fs", () => ({
+	fileExistsAtPath: vi.fn(() => Promise.resolve(false)),
+}))
+
+const legacyStateReaderMock = vi.hoisted(() => ({
+	taskHistory: [] as HistoryItem[],
+	taskHistoryByDataDir: new Map<string | undefined, HistoryItem[]>(),
+	apiConversationHistory: [] as unknown[],
+	apiConversationHistoryByDataDir: new Map<string | undefined, unknown[]>(),
+}))
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+vi.mock("./legacy-state-reader", () => ({
+	readTaskHistory: vi.fn(
+		(dataDir?: string) => legacyStateReaderMock.taskHistoryByDataDir.get(dataDir) ?? legacyStateReaderMock.taskHistory,
+	),
+	deleteLegacyTask: vi.fn((taskId: string, dataDir?: string) => {
+		const history = legacyStateReaderMock.taskHistoryByDataDir.get(dataDir) ?? legacyStateReaderMock.taskHistory
+		const filteredHistory = history.filter((item) => item.id !== taskId)
+		if (legacyStateReaderMock.taskHistoryByDataDir.has(dataDir)) {
+			legacyStateReaderMock.taskHistoryByDataDir.set(dataDir, filteredHistory)
+		} else {
+			legacyStateReaderMock.taskHistory = filteredHistory
+		}
+		return filteredHistory.length !== history.length
+	}),
+	readApiConversationHistory: vi.fn(
+		(_taskId: string, dataDir?: string) =>
+			legacyStateReaderMock.apiConversationHistoryByDataDir.get(dataDir) ?? legacyStateReaderMock.apiConversationHistory,
+	),
+}))
+
+vi.mock("./cline-session-factory", () => ({
+	buildSessionConfig: vi.fn(async ({ cwd, workspaceRoot, mode }) => ({
+		cwd,
+		workspaceRoot,
+		mode,
+	})),
+}))
+
+vi.mock("get-folder-size", () => ({
+	default: {
+		loose: vi.fn(),
+	},
+}))
+
+describe("SdkTaskHistory", () => {
+	beforeEach(() => {
+		legacyStateReaderMock.taskHistory = []
+		legacyStateReaderMock.taskHistoryByDataDir.clear()
+		legacyStateReaderMock.apiConversationHistory = []
+		legacyStateReaderMock.apiConversationHistoryByDataDir.clear()
+		vi.clearAllMocks()
+		vi.mocked(getFolderSize.loose).mockReset()
+	})
+
+	afterEach(() => {
+		vi.restoreAllMocks()
+	})
+
+	it("maps SDK session history records to legacy history items", () => {
+		const result = sessionHistoryRecordToHistoryItem(
+			makeSessionRecord("task-1", {
+				metadata: {
+					title: "Build feature",
+					tokensIn: 10,
+					tokensOut: 20,
+					totalCost: 0.01,
+					isFavorited: true,
+				},
+				model: "claude-test",
+				cwd: "/repo",
+			}),
+		)
+
+		expect(result).toMatchObject({
+			id: "task-1",
+			task: "Build feature",
+			tokensIn: 10,
+			tokensOut: 20,
+			totalCost: 0.01,
+			isFavorited: true,
+			modelId: "claude-test",
+			cwdOnTaskInitialization: "/repo",
+		})
+		expect(result.ts).toBeGreaterThan(0)
+	})
+
+	it("converts SDK persisted conversation messages to Cline messages", () => {
+		const result = sdkMessagesToClineMessages([
+			{ role: "user", content: "Build the feature" },
+			{ role: "assistant", content: [{ type: "text", text: "Done" }] },
+			{ role: "user", content: "Follow up" },
+		])
+
+		expect(result).toMatchObject([
+			{ type: "say", say: "task", text: "Build the feature", partial: false },
+			{ type: "say", say: "text", text: "Done", partial: false },
+			{ type: "say", say: "user_feedback", text: "Follow up", partial: false },
+			// A trailing ask:"completion_result" is appended so a reopened task
+			// shows the completion/resume affordance instead of a stuck spinner.
+			{ type: "ask", ask: "completion_result", partial: false },
+		])
+	})
+
+	it("includes persisted SDK message metrics for task header pricing", () => {
+		const result = sdkMessagesToClineMessages([
+			{ role: "user", content: "Build the feature" },
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "Done" }],
+				metrics: {
+					inputTokens: 120,
+					outputTokens: 30,
+					cacheReadTokens: 20,
+					cacheWriteTokens: 10,
+					cost: 0.0123,
+				},
+			},
+		])
+
+		const metricsMessage = result.find((message) => message.type === "say" && message.say === "api_req_started")
+		expect(metricsMessage).toBeDefined()
+		expect(JSON.parse(metricsMessage?.text ?? "{}")).toMatchObject({
+			tokensIn: 90,
+			tokensOut: 30,
+			cacheReads: 20,
+			cacheWrites: 10,
+			cost: 0.0123,
+		})
+	})
+
+	it("renders persisted SDK tool calls as structured tool rows instead of raw tool result JSON", () => {
+		const rawToolResult = JSON.stringify({
+			query: "edit:/Users/maxpaulus/c/c2/README.md",
+			result: "Edited /Users/maxpaulus/c/c2/README.md",
+			success: true,
+		})
+
+		const result = sdkMessagesToClineMessages([
+			{ role: "user", content: "add a joke" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "editor",
+						input: {
+							path: "/Users/maxpaulus/c/c2/README.md",
+							old_text: "## License",
+							new_text: "## A Note from Cline\n\n> Why do programmers prefer dark mode?",
+						},
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_1",
+						name: "editor",
+						content: rawToolResult,
+					},
+				],
+			},
+			{ role: "assistant", content: [{ type: "text", text: "Done!" }] },
+		])
+
+		expect(result).toMatchObject([
+			{ type: "say", say: "task", text: "add a joke", partial: false },
+			{ type: "say", say: "tool", partial: false },
+			{ type: "say", say: "text", text: "Done!", partial: false },
+			{ type: "ask", ask: "completion_result", partial: false },
+		])
+		expect(result.map((message) => message.text).join("\n")).not.toContain(rawToolResult)
+		expect(JSON.parse(result[1].text ?? "{}")).toMatchObject({
+			tool: "editedExistingFile",
+			path: "/Users/maxpaulus/c/c2/README.md",
+		})
+	})
+
+	it("hides subagent sessions from task history", async () => {
+		const rootTask = makeSessionRecord("root")
+		const subagent = makeSessionRecord("root__agent", {
+			source: "subagent",
+			isSubagent: true,
+			prompt: "Inspect the SDK adapter",
+		})
+		const { history } = makeHistory([rootTask, subagent])
+
+		const result = await history.listHistory()
+
+		expect(result.map((item) => item.sessionId)).toEqual(["root"])
+	})
+
+	it("finds a task from SDK history", async () => {
+		const record = makeSessionRecord("task-1")
+		const { history } = makeHistory([record])
+
+		await expect(history.findHistoryItem("task-1")).resolves.toMatchObject({
+			id: "task-1",
+			task: "task-1",
+		})
+	})
+
+	it("backfills SDK task size from the session artifact directory", async () => {
+		vi.mocked(getFolderSize.loose).mockResolvedValue(4096 as never)
+		const { history, updateSession } = makeHistory([
+			makeSessionRecord("task-1", {
+				metadata: { title: "Build feature" },
+				messagesPath: "/tmp/cline/sessions/task-1/task-1.messages.json",
+			}),
+		])
+
+		await expect(history.findHistoryItem("task-1")).resolves.toMatchObject({
+			id: "task-1",
+			size: 4096,
+		})
+
+		expect(getFolderSize.loose).toHaveBeenCalledWith("/tmp/cline/sessions/task-1", { bigint: false })
+		expect(updateSession).toHaveBeenCalledWith(
+			"task-1",
+			expect.objectContaining({
+				metadata: expect.objectContaining({
+					title: "Build feature",
+					size: 4096,
+				}),
+			}),
+		)
+	})
+
+	it("caches zero-byte SDK task size from the session artifact directory", async () => {
+		vi.mocked(getFolderSize.loose).mockResolvedValue(0 as never)
+		const { history, updateSession } = makeHistory([
+			makeSessionRecord("task-1", {
+				messagesPath: "/tmp/cline/sessions/task-1/task-1.messages.json",
+			}),
+		])
+
+		await expect(history.findHistoryItem("task-1")).resolves.toMatchObject({
+			id: "task-1",
+			size: 0,
+		})
+		await expect(history.findHistoryItem("task-1")).resolves.toMatchObject({
+			id: "task-1",
+			size: 0,
+		})
+
+		expect(getFolderSize.loose).toHaveBeenCalledTimes(1)
+		expect(updateSession).toHaveBeenCalledTimes(1)
+		expect(updateSession).toHaveBeenCalledWith(
+			"task-1",
+			expect.objectContaining({
+				metadata: expect.objectContaining({ size: 0 }),
+			}),
+		)
+	})
+
+	it("keeps existing SDK task size metadata without measuring artifacts", async () => {
+		const { history, updateSession } = makeHistory([makeSessionRecord("task-1", { metadata: { size: 2048 } })])
+
+		await expect(history.findHistoryItem("task-1")).resolves.toMatchObject({
+			id: "task-1",
+			size: 2048,
+		})
+
+		expect(getFolderSize.loose).not.toHaveBeenCalled()
+		expect(updateSession).not.toHaveBeenCalled()
+	})
+
+	it("returns undefined when a task is missing from SDK history", async () => {
+		const { history } = makeHistory([])
+
+		await expect(history.findHistoryItem("missing-task")).resolves.toBeUndefined()
+	})
+
+	it("updates SDK session metadata for task history changes", async () => {
+		const existing = makeSessionRecord("task-1", {
+			metadata: { existing: true },
+		})
+		const { history, getSession, listHistory, updateSession } = makeHistory([existing])
+		const updatedItem = makeHistoryItem("task-1", {
+			task: "new title",
+			tokensIn: 5,
+			totalCost: 0.02,
+		})
+
+		await history.updateTaskHistoryItem(updatedItem)
+
+		expect(getSession).toHaveBeenCalledWith("task-1")
+		expect(listHistory).not.toHaveBeenCalled()
+		expect(updateSession).toHaveBeenCalledWith(
+			"task-1",
+			expect.objectContaining({
+				prompt: "new title",
+				title: "new title",
+				metadata: expect.objectContaining({
+					existing: true,
+					title: "new title",
+					tokensIn: 5,
+					totalCost: 0.02,
+				}),
+			}),
+		)
+	})
+
+	it("keeps cached SDK task size when updating history without measuring artifacts", async () => {
+		vi.mocked(getFolderSize.loose).mockResolvedValue(8192 as never)
+		const existing = makeSessionRecord("task-1", {
+			metadata: { size: 1024 },
+			messagesPath: "/tmp/cline/sessions/task-1/task-1.messages.json",
+		})
+		const { history, updateSession } = makeHistory([existing])
+
+		await history.updateTaskHistoryItem(makeHistoryItem("task-1"))
+
+		expect(getFolderSize.loose).not.toHaveBeenCalled()
+		expect(updateSession).toHaveBeenCalledWith(
+			"task-1",
+			expect.objectContaining({
+				metadata: expect.objectContaining({ size: 1024 }),
+			}),
+		)
+	})
+
+	it("does not cache unavailable artifact size as zero", async () => {
+		vi.mocked(getFolderSize.loose).mockRejectedValue(new Error("unreadable"))
+		const existing = makeSessionRecord("task-1", {
+			messagesPath: "/tmp/cline/sessions/task-1/task-1.messages.json",
+		})
+		const { history, updateSession } = makeHistory([existing])
+
+		const result = await history.findHistoryItem("task-1")
+
+		expect(result?.size).toBeUndefined()
+		expect(getFolderSize.loose).toHaveBeenCalledTimes(1)
+		expect(updateSession).not.toHaveBeenCalled()
+	})
+
+	it("deletes SDK sessions", async () => {
+		const { history, deleteSession } = makeHistory([makeSessionRecord("task-1")])
+
+		await history.deleteTaskFromState("task-1")
+
+		expect(deleteSession).toHaveBeenCalledWith("task-1")
+		expect(deleteLegacyTask).not.toHaveBeenCalled()
+	})
+
+	it("deletes legacy task records when deleting history", async () => {
+		legacyStateReaderMock.taskHistory = [makeHistoryItem("legacy-task", { task: "legacy prompt" })]
+		const { history, deleteSession } = makeHistory([])
+
+		const result = await history.deleteTaskFromState("legacy-task")
+
+		expect(deleteSession).toHaveBeenCalledWith("legacy-task")
+		expect(deleteLegacyTask).toHaveBeenCalledWith("legacy-task", undefined)
+		expect(result.some((item) => item.id === "legacy-task")).toBe(false)
+	})
+
+	it("emits telemetry when migrating a legacy task to an SDK session", async () => {
+		vi.spyOn(Date, "now").mockReturnValue(123_456)
+		legacyStateReaderMock.taskHistory = [
+			makeHistoryItem("legacy-task", {
+				task: "legacy prompt",
+				isFavorited: true,
+				tokensIn: 10,
+				tokensOut: 20,
+				totalCost: 0.03,
+				cwdOnTaskInitialization: "/legacy/repo",
+			}),
+		]
+		legacyStateReaderMock.apiConversationHistory = [
+			{ role: "user", content: "legacy prompt" },
+			{ role: "assistant", content: "legacy answer" },
+		]
+		const telemetry = makeTelemetry()
+		const { history, startSession } = makeHistory([], telemetry)
+
+		await history.getClineMessages("legacy-task")
+
+		expect(startSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					sessionId: "legacy-task",
+					cwd: "/legacy/repo",
+				}),
+				initialMessages: expect.arrayContaining([
+					expect.objectContaining({ role: "user" }),
+					expect.objectContaining({ role: "assistant" }),
+				]),
+				sessionMetadata: expect.objectContaining({
+					migratedFromLegacyTask: true,
+					title: "legacy prompt",
+					isFavorited: true,
+				}),
+			}),
+		)
+		expect(telemetry.captureLegacyTaskMigration).toHaveBeenCalledWith(
+			expect.objectContaining({
+				taskId: "legacy-task",
+				outcome: "success",
+				reason: "migrated",
+				legacyApiHistoryLength: 2,
+				convertedMessageCount: 2,
+				hasFavorite: true,
+				hasCost: true,
+				hasTokenUsage: true,
+				hasCwd: true,
+			}),
+		)
+	})
+
+	it("emits backlog telemetry when legacy tasks are still pending migration", async () => {
+		legacyStateReaderMock.taskHistory = [makeHistoryItem("legacy-task", { task: "legacy prompt" })]
+		const telemetry = makeTelemetry()
+		const { history } = makeHistory(
+			[
+				makeSessionRecord("sdk-task"),
+				makeSessionRecord("migrated", {
+					metadata: { migratedFromLegacyTask: true },
+				}),
+			],
+			telemetry,
+		)
+
+		await history.listHistory({ hydrate: false })
+
+		expect(telemetry.captureLegacyTaskMigrationBacklog).toHaveBeenCalledWith({
+			pendingLegacyTaskCount: 1,
+			migratedSdkTaskCount: 1,
+			visibleSdkTaskCount: 2,
+			visibleTaskCount: 3,
+		})
+	})
+
+	it("includes legacy tasks from VS Code extension storage", async () => {
+		legacyStateReaderMock.taskHistory = [makeHistoryItem("cline-dir-task", { task: "~/.cline task" })]
+		legacyStateReaderMock.taskHistoryByDataDir.set("/legacy/globalStorage", [
+			makeHistoryItem("extension-storage-task", {
+				task: "extension storage task",
+			}),
+		])
+		const { history } = makeHistory([], undefined, "/legacy/globalStorage")
+
+		const result = await history.listHistory({ hydrate: false })
+
+		expect(readTaskHistory).toHaveBeenCalledWith(undefined)
+		expect(readTaskHistory).toHaveBeenCalledWith("/legacy/globalStorage")
+		expect(result.map((item) => item.sessionId)).toEqual(["cline-dir-task", "extension-storage-task"])
+	})
+
+	it("migrates legacy tasks using API history from VS Code extension storage", async () => {
+		legacyStateReaderMock.taskHistoryByDataDir.set("/legacy/globalStorage", [
+			makeHistoryItem("extension-storage-task", {
+				task: "extension storage prompt",
+				cwdOnTaskInitialization: "/legacy/repo",
+			}),
+		])
+		legacyStateReaderMock.apiConversationHistoryByDataDir.set("/legacy/globalStorage", [
+			{ role: "user", content: "extension storage prompt" },
+			{ role: "assistant", content: "extension storage answer" },
+		])
+		const { history, startSession } = makeHistory([], undefined, "/legacy/globalStorage")
+
+		await history.getClineMessages("extension-storage-task")
+
+		expect(readApiConversationHistory).toHaveBeenCalledWith("extension-storage-task", "/legacy/globalStorage")
+		expect(startSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					sessionId: "extension-storage-task",
+					cwd: "/legacy/repo",
+				}),
+				sessionMetadata: expect.objectContaining({
+					migratedFromLegacyTask: true,
+					title: "extension storage prompt",
+				}),
+			}),
+		)
+	})
+
+	it("updates usage for an existing SDK task", async () => {
+		vi.spyOn(Date, "now").mockReturnValue(123_456)
+		const { history, updateSession } = makeHistory([
+			makeSessionRecord("task-1", {
+				metadata: {
+					tokensIn: 10,
+					tokensOut: 20,
+					totalCost: 0.01,
+				},
+			}),
+		])
+
+		await history.updateTaskUsage("task-1", {
+			tokensIn: 100,
+			tokensOut: 200,
+			totalCost: 0.03,
+		})
+
+		expect(updateSession).toHaveBeenCalledWith(
+			"task-1",
+			expect.objectContaining({
+				metadata: expect.objectContaining({
+					tokensIn: 110,
+					tokensOut: 220,
+					totalCost: 0.04,
+				}),
+			}),
+		)
+	})
+
+	it("patches cached history record in place without re-listing from host", async () => {
+		const { history, listHistory } = makeHistory([
+			makeSessionRecord("task-1", { updatedAt: "2026-01-01T00:00:00.000Z" }),
+			makeSessionRecord("task-2", { updatedAt: "2026-01-02T00:00:00.000Z" }),
+		])
+
+		// Populate cache
+		await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(1)
+
+		// Update task-1
+		await history.updateTaskHistoryItem(makeHistoryItem("task-1", { task: "new title" }))
+
+		// Read again — should use cache, not re-list from host
+		const result = await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(1)
+
+		// Cached record should reflect the updated prompt and metadata
+		const updated = result.find((r) => r.sessionId === "task-1")
+		expect(updated?.prompt).toBe("new title")
+		expect(updated?.metadata).toEqual(expect.objectContaining({ title: "new title" }))
+		// updatedAt should be bumped, not the original "2026-01-01T00:00:00.000Z"
+		expect(updated?.updatedAt).not.toBe("2026-01-01T00:00:00.000Z")
+	})
+
+	it("re-sorts cached history after patching so the updated record bubbles up", async () => {
+		const { history } = makeHistory([
+			makeSessionRecord("task-1", { updatedAt: "2026-01-01T00:00:00.000Z" }),
+			makeSessionRecord("task-2", { updatedAt: "2026-01-02T00:00:00.000Z" }),
+		])
+
+		// Populate cache — task-2 (newer) should be first
+		const initial = await history.listHistory({ hydrate: false })
+		expect(initial[0].sessionId).toBe("task-2")
+		expect(initial[1].sessionId).toBe("task-1")
+
+		// Update task-1 with a timestamp newer than task-2
+		await history.updateTaskHistoryItem(
+			makeHistoryItem("task-1", { task: "updated", ts: Date.parse("2026-01-03T00:00:00.000Z") }),
+		)
+
+		// task-1 should now be first due to re-sort
+		const result = await history.listHistory({ hydrate: false })
+		expect(result[0].sessionId).toBe("task-1")
+	})
+
+	it("patches cache in place on per-turn usage updates", async () => {
+		const { history, listHistory } = makeHistory([
+			makeSessionRecord("task-1", {
+				metadata: { tokensIn: 10, tokensOut: 20, totalCost: 0.01 },
+			}),
+		])
+
+		// Populate cache
+		await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(1)
+
+		// Per-turn usage update (the streaming hot path)
+		await history.updateTaskUsage("task-1", {
+			tokensIn: 100,
+			tokensOut: 200,
+			totalCost: 0.03,
+		})
+
+		// Read again — should use cache, not re-list from host
+		const result = await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(1)
+
+		const updated = result.find((r) => r.sessionId === "task-1")
+		expect(updated?.metadata).toEqual(
+			expect.objectContaining({
+				tokensIn: 110,
+				tokensOut: 220,
+				totalCost: 0.04,
+			}),
+		)
+	})
+
+	it("bumps cached updatedAt to the write time, not a stale HistoryItem.ts", async () => {
+		// Simulates toggleTaskFavorite(), which reuses an existing HistoryItem
+		// (with its original, possibly old, `ts`) to flip just `isFavorited`. The
+		// persistence adapter always stamps `updatedAt` with the wall-clock write
+		// time (nowIso()), so the cache patch must do the same rather than
+		// deriving `updatedAt` from the stale `item.ts` — otherwise the cached
+		// ordering would diverge from what's on disk until the TTL expires.
+		const { history } = makeHistory([
+			makeSessionRecord("task-1", { updatedAt: "2020-01-01T00:00:00.000Z" }),
+			makeSessionRecord("task-2", { updatedAt: "2026-01-02T00:00:00.000Z" }),
+		])
+
+		const initial = await history.listHistory({ hydrate: false })
+		expect(initial[0].sessionId).toBe("task-2")
+
+		// Reuse task-1's original (stale) ts, as toggleTaskFavorite() does.
+		await history.updateTaskHistoryItem(makeHistoryItem("task-1", { ts: Date.parse("2020-01-01T00:00:00.000Z") }))
+
+		const result = await history.listHistory({ hydrate: false })
+		const updated = result.find((r) => r.sessionId === "task-1")
+		// updatedAt must reflect the write time, not the stale 2020 timestamp.
+		expect(updated?.updatedAt).not.toBe("2020-01-01T00:00:00.000Z")
+		expect(result[0].sessionId).toBe("task-1")
+	})
+
+	it("invalidates cache when updating a session not present in it", async () => {
+		const { history, listHistory } = makeHistory([makeSessionRecord("task-1")])
+
+		// Populate cache with just task-1
+		await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(1)
+
+		// Update task-2, which is NOT in the cache
+		await history.updateTaskHistoryItem(makeHistoryItem("task-2", { task: "new" }))
+
+		// Next read should re-list from host (cache was invalidated)
+		await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(2)
+	})
+
+	it("invalidates rather than patches the cache when the underlying write didn't land", async () => {
+		// host.update() resolves { updated: false } when the session was deleted
+		// out from under the write, or an optimistic-concurrency retry was
+		// exhausted by a racing writer. Patching the cache in that case would show
+		// a fake "updated" record until the TTL expires.
+		const { history, listHistory, updateSession } = makeHistory([
+			makeSessionRecord("task-1", { prompt: "original", updatedAt: "2026-01-01T00:00:00.000Z" }),
+		])
+
+		// Populate cache
+		await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(1)
+
+		updateSession.mockResolvedValueOnce({ updated: false })
+		await history.updateTaskHistoryItem(makeHistoryItem("task-1", { task: "should not stick" }))
+
+		// Next read should re-list from host (cache was invalidated, not patched)
+		const result = await history.listHistory({ hydrate: false })
+		expect(listHistory).toHaveBeenCalledTimes(2)
+		// The mock's underlying store was never touched since update() bailed early,
+		// so the re-listed record still shows the original prompt/updatedAt.
+		const record = result.find((r) => r.sessionId === "task-1")
+		expect(record?.prompt).toBe("original")
+		expect(record?.updatedAt).toBe("2026-01-01T00:00:00.000Z")
+	})
+})
+
+function makeHistoryItem(id: string, overrides: Partial<HistoryItem> = {}): HistoryItem {
+	return {
+		id,
+		ts: 1,
+		task: id,
+		tokensIn: 0,
+		tokensOut: 0,
+		totalCost: 0,
+		...overrides,
+	}
+}
+
+function makeSessionRecord(id: string, overrides: Partial<SessionHistoryRecord> = {}): SessionHistoryRecord {
+	return {
+		sessionId: id,
+		source: "vscode",
+		pid: 1,
+		startedAt: "2026-01-01T00:00:00.000Z",
+		endedAt: null,
+		exitCode: null,
+		status: "completed",
+		interactive: true,
+		provider: "anthropic",
+		model: "claude-test",
+		cwd: "/repo",
+		workspaceRoot: "/repo",
+		enableTools: true,
+		enableSpawn: true,
+		enableTeams: false,
+		isSubagent: false,
+		prompt: id,
+		metadata: {},
+		updatedAt: "2026-01-01T00:00:00.000Z",
+		...overrides,
+	}
+}
+
+function makeTelemetry(): TelemetryService {
+	return {
+		safeCapture: vi.fn((fn: () => void) => fn()),
+		captureLegacyTaskMigration: vi.fn(),
+		captureLegacyTaskMigrationBacklog: vi.fn(),
+	} as unknown as TelemetryService
+}
+
+function makeHistory(records: SessionHistoryRecord[], telemetry?: TelemetryService, legacyExtensionStorageDir?: string) {
+	let currentRecords = records
+	const updateSession = vi.fn(
+		async (
+			sessionId: string,
+			updates: {
+				prompt?: string | null
+				metadata?: Record<string, unknown> | null
+				title?: string | null
+			},
+		) => {
+			currentRecords = currentRecords.map((record) =>
+				record.sessionId === sessionId
+					? {
+							...record,
+							prompt: updates.prompt ?? record.prompt,
+							metadata: updates.metadata ?? record.metadata,
+						}
+					: record,
+			)
+			return { updated: true }
+		},
+	)
+	const deleteSession = vi.fn(async (sessionId: string) => {
+		currentRecords = currentRecords.filter((record) => record.sessionId !== sessionId)
+		return true
+	})
+	const getSession = vi.fn(async (sessionId: string) => currentRecords.find((record) => record.sessionId === sessionId))
+	const listHistory = vi.fn(async () => currentRecords)
+	const readMessages = vi.fn(async () => [])
+	const startSession = vi.fn(async (input: { config: { sessionId?: string } }) => {
+		currentRecords = [makeSessionRecord(input.config.sessionId ?? "started"), ...currentRecords]
+		return { sessionId: input.config.sessionId }
+	})
+	const host = {
+		get: getSession,
+		listHistory,
+		readMessages,
+		start: startSession,
+		update: updateSession,
+		delete: deleteSession,
+	} as unknown as VscodeSessionHost
+	const sessions = {
+		getActiveSession: () => ({ sdkHost: host }),
+	} as unknown as SdkSessionLifecycle
+	const history = new SdkTaskHistory({
+		mcpHub: {} as McpHub,
+		sessions,
+		telemetry,
+		legacyExtensionStorageDir,
+	})
+
+	return {
+		history,
+		getSession,
+		listHistory,
+		updateSession,
+		deleteSession,
+		startSession,
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-task-history.ts b/apps/vscode/src/sdk/sdk-task-history.ts
new file mode 100644
index 0000000..8854a7e
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-task-history.ts
@@ -0,0 +1,810 @@
+import path from "node:path"
+import type { ClineCoreListHistoryOptions, SessionHistoryRecord } from "@cline/core"
+import type { Message as SdkMessage } from "@cline/llms"
+import { type ContentBlock, formatDisplayUserInput, type MessageWithMetadata } from "@cline/shared"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type { HistoryItem } from "@shared/HistoryItem"
+import getFolderSize from "get-folder-size"
+import type { McpHub } from "@/services/mcp/McpHub"
+import type { TelemetryService } from "@/services/telemetry/TelemetryService"
+import { Logger } from "@/shared/services/Logger"
+import { buildSessionConfig } from "./cline-session-factory"
+import { sanitizeInitialMessagesForSessionStart } from "./initial-message-sanitizer"
+import { deleteLegacyTask, readApiConversationHistory, readTaskHistory } from "./legacy-state-reader"
+import type { MessageIdMinter } from "./message-id-minter"
+import { sdkMessagesToClineMessages } from "./message-translator"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+export interface TaskUsage {
+	tokensIn: number
+	tokensOut: number
+	totalCost?: number
+	cacheReads?: number
+	cacheWrites?: number
+}
+
+export interface SdkTaskHistoryOptions {
+	mcpHub: McpHub
+	sessions: SdkSessionLifecycle
+	/**
+	 * VS Code's legacy global storage root. Pre-SDK VS Code tasks lived here under
+	 * state/taskHistory.json and tasks/<id>/ instead of ~/.cline/data.
+	 */
+	legacyExtensionStorageDir?: string
+	/**
+	 * The process-wide id/seq/epoch authority. When provided, history rendering mints ids from
+	 * it so regenerated history ids never overlap live-session ids. Optional for tests.
+	 */
+	getMinter?: () => MessageIdMinter
+	telemetry?: TelemetryService
+}
+
+type SdkTaskHistoryListOptions = ClineCoreListHistoryOptions & {
+	offset?: number
+}
+
+function metadataNumber(metadata: SessionHistoryRecord["metadata"] | undefined, key: string): number | undefined {
+	const value = metadata?.[key]
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}
+
+function metadataBoolean(metadata: SessionHistoryRecord["metadata"] | undefined, key: string): boolean | undefined {
+	const value = metadata?.[key]
+	return typeof value === "boolean" ? value : undefined
+}
+
+function metadataString(metadata: SessionHistoryRecord["metadata"] | undefined, key: string): string | undefined {
+	const value = metadata?.[key]
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
+}
+
+function dateStringToTimestamp(value: string | null | undefined): number {
+	if (!value) {
+		return 0
+	}
+	const timestamp = Date.parse(value)
+	return Number.isFinite(timestamp) ? timestamp : 0
+}
+
+/**
+ * Sort comparator for session history records by recency: newest first.
+ *
+ * Falls back through `updatedAt` → `endedAt` → `startedAt` so records that
+ * haven't been touched since creation still sort deterministically. Used both
+ * when merging the initial list and when re-sorting after a single-record
+ * patch, so the two orderings can never diverge.
+ */
+function compareSessionHistoryRecordsByRecencyDesc(a: SessionHistoryRecord, b: SessionHistoryRecord): number {
+	return (
+		dateStringToTimestamp(b.updatedAt ?? b.endedAt ?? b.startedAt) -
+		dateStringToTimestamp(a.updatedAt ?? a.endedAt ?? a.startedAt)
+	)
+}
+
+function historyItemHasTokenUsage(item: HistoryItem): boolean {
+	return (item.tokensIn ?? 0) > 0 || (item.tokensOut ?? 0) > 0 || (item.cacheReads ?? 0) > 0 || (item.cacheWrites ?? 0) > 0
+}
+
+export function historyItemToSessionMetadata(item: HistoryItem, fallbackModelId?: string): Record<string, unknown> {
+	return {
+		title: item.task,
+		isFavorited: item.isFavorited ?? false,
+		size: item.size ?? 0,
+		totalCost: item.totalCost ?? 0,
+		tokensIn: item.tokensIn ?? 0,
+		tokensOut: item.tokensOut ?? 0,
+		cacheWrites: item.cacheWrites ?? 0,
+		cacheReads: item.cacheReads ?? 0,
+		modelId: item.modelId ?? fallbackModelId ?? "",
+	}
+}
+
+function historyItemToSessionHistoryRecord(item: HistoryItem): SessionHistoryRecord {
+	const startedAt = new Date(item.ts || Date.now()).toISOString()
+	const displayTask = formatDisplayUserInput(item.task)
+	return {
+		sessionId: item.id,
+		source: "vscode",
+		pid: 0,
+		startedAt,
+		endedAt: startedAt,
+		exitCode: 0,
+		status: "completed",
+		interactive: true,
+		provider: "",
+		model: item.modelId ?? "",
+		cwd: item.cwdOnTaskInitialization ?? "",
+		workspaceRoot: item.cwdOnTaskInitialization ?? "",
+		enableTools: true,
+		enableSpawn: false,
+		enableTeams: false,
+		isSubagent: false,
+		prompt: displayTask,
+		metadata: {
+			...historyItemToSessionMetadata({ ...item, task: displayTask }),
+			legacyTask: true,
+		},
+		updatedAt: startedAt,
+	}
+}
+
+function anthropicContentBlockToSdkBlock(block: unknown): ContentBlock | undefined {
+	if (!block || typeof block !== "object") {
+		return undefined
+	}
+	const record = block as Record<string, unknown>
+	switch (record.type) {
+		case "text":
+			return typeof record.text === "string" ? { type: "text", text: record.text } : undefined
+		case "tool_use":
+			return typeof record.id === "string" && typeof record.name === "string"
+				? {
+						type: "tool_use",
+						id: record.id,
+						name: record.name,
+						input: (record.input as Record<string, unknown>) ?? {},
+					}
+				: undefined
+		case "tool_result":
+			return typeof record.tool_use_id === "string"
+				? {
+						type: "tool_result",
+						tool_use_id: record.tool_use_id,
+						// SDK tool_result blocks carry the tool name, but Anthropic-format
+						// transcripts identify the tool only by tool_use_id. Use the name
+						// when present and otherwise leave it empty.
+						name: typeof record.name === "string" ? record.name : "",
+						content: typeof record.content === "string" ? record.content : JSON.stringify(record.content ?? ""),
+						is_error: typeof record.is_error === "boolean" ? record.is_error : undefined,
+					}
+				: undefined
+		case "thinking":
+			return typeof record.thinking === "string" ? { type: "thinking", thinking: record.thinking } : undefined
+		case "image": {
+			const source = record.source as Record<string, unknown> | undefined
+			return source?.type === "base64" && typeof source.data === "string" && typeof source.media_type === "string"
+				? { type: "image", data: source.data, mediaType: source.media_type }
+				: undefined
+		}
+		default:
+			return undefined
+	}
+}
+
+function sanitizeSdkUserMessagesForDisplay(messages: SdkMessage[]): SdkMessage[] {
+	return messages.map((message) => {
+		if (message.role !== "user") {
+			return message
+		}
+		if (typeof message.content === "string") {
+			return { ...message, content: formatDisplayUserInput(message.content) }
+		}
+		if (Array.isArray(message.content)) {
+			return {
+				...message,
+				content: message.content.map((block) =>
+					block.type === "text" && typeof block.text === "string"
+						? { ...block, text: formatDisplayUserInput(block.text) }
+						: block,
+				),
+			}
+		}
+		return message
+	})
+}
+
+function legacyApiHistoryToSdkMessages(apiHistory: unknown[], historyItem: HistoryItem): MessageWithMetadata[] {
+	const messages = apiHistory.flatMap((raw): MessageWithMetadata[] => {
+		if (!raw || typeof raw !== "object") {
+			return []
+		}
+		const record = raw as Record<string, unknown>
+		const role = record.role === "assistant" ? "assistant" : record.role === "user" ? "user" : undefined
+		if (!role) {
+			return []
+		}
+
+		if (typeof record.content === "string") {
+			return [
+				{
+					role,
+					content: role === "user" ? formatDisplayUserInput(record.content) : record.content,
+				},
+			]
+		}
+
+		if (Array.isArray(record.content)) {
+			const content = record.content.flatMap((block) => {
+				const converted = anthropicContentBlockToSdkBlock(block)
+				if (role === "user" && converted?.type === "text") {
+					return [{ ...converted, text: formatDisplayUserInput(converted.text) }]
+				}
+				return converted ? [converted] : []
+			})
+			return content.length > 0 ? [{ role, content }] : []
+		}
+
+		return []
+	})
+
+	const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant")
+	if (lastAssistant && !lastAssistant.metrics) {
+		lastAssistant.metrics = {
+			inputTokens: (historyItem.tokensIn ?? 0) + (historyItem.cacheReads ?? 0) + (historyItem.cacheWrites ?? 0),
+			outputTokens: historyItem.tokensOut ?? 0,
+			cacheReadTokens: historyItem.cacheReads ?? 0,
+			cacheWriteTokens: historyItem.cacheWrites ?? 0,
+			cost: historyItem.totalCost ?? 0,
+		}
+		lastAssistant.modelInfo = historyItem.modelId ? { id: historyItem.modelId, provider: "unknown" } : lastAssistant.modelInfo
+	}
+
+	return sanitizeInitialMessagesForSessionStart(messages) as MessageWithMetadata[]
+}
+
+export function sessionHistoryRecordToHistoryItem(item: SessionHistoryRecord): HistoryItem {
+	const metadata = item.metadata
+	return {
+		id: item.sessionId,
+		ts: dateStringToTimestamp(item.updatedAt ?? item.endedAt ?? item.startedAt),
+		task: formatDisplayUserInput(metadataString(metadata, "title") ?? item.prompt ?? ""),
+		tokensIn: metadataNumber(metadata, "tokensIn") ?? 0,
+		tokensOut: metadataNumber(metadata, "tokensOut") ?? 0,
+		cacheWrites: metadataNumber(metadata, "cacheWrites") ?? 0,
+		cacheReads: metadataNumber(metadata, "cacheReads") ?? 0,
+		totalCost: metadataNumber(metadata, "totalCost") ?? 0,
+		size: metadataNumber(metadata, "size"),
+		isFavorited: metadataBoolean(metadata, "isFavorited") ?? metadataBoolean(metadata, "is_favorited") ?? false,
+		modelId: item.model || metadataString(metadata, "modelId") || "",
+		cwdOnTaskInitialization: item.cwd ?? item.workspaceRoot,
+	}
+}
+
+export class SdkTaskHistory {
+	private cachedHistoryHost?: VscodeSessionHost
+	private cachedHistoryHostPromise?: Promise<VscodeSessionHost>
+	private cachedHistoryHostRefCount = 0
+	private cachedHistoryHostIdleTimer?: NodeJS.Timeout
+	private metadataHistoryCache?: {
+		records: SessionHistoryRecord[]
+		hostLimit: number
+		createdAt: number
+	}
+	private disposed = false
+	private readonly cachedHistoryHostIdleMs = 30_000
+	private readonly metadataHistoryCacheTtlMs = 10_000
+
+	constructor(private readonly options: SdkTaskHistoryOptions) {}
+
+	private getLegacyDataDirs(): (string | undefined)[] {
+		const dirs: (string | undefined)[] = [undefined]
+		const extensionStorageDir = this.options.legacyExtensionStorageDir?.trim()
+		if (extensionStorageDir) {
+			dirs.push(extensionStorageDir)
+		}
+		return dirs
+	}
+
+	private readAllLegacyTaskHistory(): {
+		item: HistoryItem
+		dataDir?: string
+	}[] {
+		const seenIds = new Set<string>()
+		const tasks: { item: HistoryItem; dataDir?: string }[] = []
+		for (const dataDir of this.getLegacyDataDirs()) {
+			for (const item of readTaskHistory(dataDir)) {
+				if (!item.id || seenIds.has(item.id)) {
+					continue
+				}
+				seenIds.add(item.id)
+				tasks.push({ item, dataDir })
+			}
+		}
+		return tasks
+	}
+
+	private findLegacyTask(taskId: string): { item: HistoryItem; dataDir?: string } | undefined {
+		return this.readAllLegacyTaskHistory().find(({ item }) => item.id === taskId)
+	}
+
+	private getActiveHistoryHost(): VscodeSessionHost | undefined {
+		const sdkHost = this.options.sessions.getActiveSession()?.sdkHost
+		if (sdkHost && "listHistory" in sdkHost) {
+			return sdkHost as VscodeSessionHost
+		}
+		return undefined
+	}
+
+	private async getCachedHistoryHost(): Promise<VscodeSessionHost> {
+		if (this.disposed) {
+			throw new Error("SdkTaskHistory has been disposed")
+		}
+
+		if (this.cachedHistoryHostIdleTimer) {
+			clearTimeout(this.cachedHistoryHostIdleTimer)
+			this.cachedHistoryHostIdleTimer = undefined
+		}
+
+		if (this.cachedHistoryHost) {
+			return this.cachedHistoryHost
+		}
+		if (this.cachedHistoryHostPromise) {
+			return this.cachedHistoryHostPromise
+		}
+
+		this.cachedHistoryHostPromise = (async () => {
+			const { VscodeSessionHost } = await import("./vscode-session-host")
+			const historyHost = await VscodeSessionHost.create({
+				mcpHub: this.options.mcpHub,
+			})
+			this.cachedHistoryHost = historyHost
+			return historyHost
+		})()
+
+		try {
+			return await this.cachedHistoryHostPromise
+		} catch (error) {
+			this.cachedHistoryHost = undefined
+			throw error
+		} finally {
+			this.cachedHistoryHostPromise = undefined
+		}
+	}
+
+	private scheduleCachedHistoryHostDispose(): void {
+		if (this.disposed || this.cachedHistoryHostRefCount > 0 || !this.cachedHistoryHost) {
+			return
+		}
+
+		this.cachedHistoryHostIdleTimer = setTimeout(() => {
+			void this.disposeCachedHistoryHost("idle")
+		}, this.cachedHistoryHostIdleMs)
+		this.cachedHistoryHostIdleTimer.unref?.()
+	}
+
+	private async disposeCachedHistoryHost(reason: string): Promise<void> {
+		if (this.cachedHistoryHostIdleTimer) {
+			clearTimeout(this.cachedHistoryHostIdleTimer)
+			this.cachedHistoryHostIdleTimer = undefined
+		}
+
+		if (this.cachedHistoryHostRefCount > 0) {
+			return
+		}
+
+		const historyHost = this.cachedHistoryHost
+		this.cachedHistoryHost = undefined
+		if (!historyHost) {
+			return
+		}
+
+		await historyHost.dispose(`taskHistory:${reason}`).catch((error) => {
+			Logger.warn("[SdkTaskHistory] Failed to dispose cached history host:", error)
+		})
+	}
+
+	async dispose(): Promise<void> {
+		this.disposed = true
+		this.invalidateMetadataHistoryCache()
+		if (this.cachedHistoryHostPromise) {
+			await this.cachedHistoryHostPromise.catch(() => undefined)
+		}
+		await this.disposeCachedHistoryHost("controllerDispose")
+	}
+
+	private invalidateMetadataHistoryCache(): void {
+		this.metadataHistoryCache = undefined
+	}
+
+	/**
+	 * Mirror a persistence-layer write into the cache so the next read sees
+	 * the updated record without a full re-enumeration.
+	 *
+	 * The persistence layer bumps `updatedAt` on every write, so the cached
+	 * record is updated to match and the cache is re-sorted to preserve the
+	 * descending-`updatedAt` ordering that {@link listHistory} establishes.
+	 * When the session isn't in the cache (e.g. a brand-new task whose list
+	 * membership/ordering may change) the cache is invalidated so the next
+	 * read re-enumerates from disk.
+	 */
+	private updateCachedSessionRecord(
+		sessionId: string,
+		updates: { prompt: string; metadata: Record<string, unknown>; updatedAt: string },
+	): void {
+		const cache = this.metadataHistoryCache
+		if (!cache) {
+			return
+		}
+		const index = cache.records.findIndex((record) => record.sessionId === sessionId)
+		if (index === -1) {
+			this.invalidateMetadataHistoryCache()
+			return
+		}
+		const existing = cache.records[index]
+		cache.records[index] = {
+			...existing,
+			prompt: updates.prompt,
+			metadata: updates.metadata,
+			updatedAt: updates.updatedAt,
+		}
+		cache.records.sort(compareSessionHistoryRecordsByRecencyDesc)
+	}
+
+	private canUseMetadataHistoryCache(options: SdkTaskHistoryListOptions): boolean {
+		return options.hydrate === false
+	}
+
+	private async withHistoryHost<T>(fn: (host: VscodeSessionHost) => Promise<T>): Promise<T> {
+		const activeHistoryHost = this.getActiveHistoryHost()
+		if (activeHistoryHost) {
+			return fn(activeHistoryHost)
+		}
+
+		const historyHost = await this.getCachedHistoryHost()
+		this.cachedHistoryHostRefCount += 1
+		try {
+			return await fn(historyHost)
+		} finally {
+			this.cachedHistoryHostRefCount = Math.max(0, this.cachedHistoryHostRefCount - 1)
+			this.scheduleCachedHistoryHostDispose()
+		}
+	}
+
+	async listHistory(options: SdkTaskHistoryListOptions = {}): Promise<SessionHistoryRecord[]> {
+		const offset = Math.max(0, Math.floor(options.offset ?? 0))
+		const limit = Math.max(0, Math.floor(options.limit ?? 10_000))
+		const hostLimit = offset + limit
+		const useCache = this.canUseMetadataHistoryCache(options)
+		const now = Date.now()
+		const cached = useCache ? this.metadataHistoryCache : undefined
+		if (cached && cached.hostLimit >= hostLimit && now - cached.createdAt < this.metadataHistoryCacheTtlMs) {
+			const result = cached.records.slice(offset, offset + limit)
+			return result
+		}
+
+		const hostOptions: ClineCoreListHistoryOptions = { ...options }
+		delete (hostOptions as { offset?: number }).offset
+
+		const sdkHistory = await this.withHistoryHost((host) =>
+			host.listHistory({
+				...hostOptions,
+				limit: hostLimit || 10_000,
+				includeManifestFallback: true,
+			}),
+		)
+		const visibleSdkHistory = sdkHistory.filter((item) => item.isSubagent !== true)
+		const sdkIds = new Set(visibleSdkHistory.map((item) => item.sessionId))
+		const legacyHistory = this.readAllLegacyTaskHistory()
+			.filter(({ item }) => item.task && !sdkIds.has(item.id))
+			.map(({ item }) => historyItemToSessionHistoryRecord(item))
+		const migratedSdkTaskCount = visibleSdkHistory.filter(
+			(item) => metadataBoolean(item.metadata, "migratedFromLegacyTask") === true,
+		).length
+
+		const mergedHistory = [...visibleSdkHistory, ...legacyHistory].sort(compareSessionHistoryRecordsByRecencyDesc)
+		if (useCache) {
+			this.metadataHistoryCache = {
+				records: mergedHistory,
+				hostLimit,
+				createdAt: Date.now(),
+			}
+		}
+
+		this.options.telemetry?.safeCapture(
+			() =>
+				this.options.telemetry?.captureLegacyTaskMigrationBacklog({
+					pendingLegacyTaskCount: legacyHistory.length,
+					migratedSdkTaskCount,
+					visibleSdkTaskCount: visibleSdkHistory.length,
+					visibleTaskCount: mergedHistory.length,
+				}),
+			"SdkTaskHistory.listHistory.legacyMigrationBacklog",
+		)
+
+		const result = mergedHistory.slice(offset, offset + limit)
+		return result
+	}
+
+	async getClineMessages(taskId: string): Promise<ClineMessage[]> {
+		await this.migrateLegacyTaskIfNeeded(taskId)
+		const sdkMessages = await this.withHistoryHost((host) => host.readMessages(taskId) as Promise<SdkMessage[]>)
+		const clineMessages = sdkMessagesToClineMessages(
+			sanitizeSdkUserMessagesForDisplay(sdkMessages),
+			this.options.getMinter?.(),
+		)
+		return clineMessages
+	}
+
+	private async migrateLegacyTaskIfNeeded(taskId: string): Promise<boolean> {
+		const startedAt = Date.now()
+		let sdkLookupFailed = false
+		let historyItem: HistoryItem | undefined
+		let legacyApiHistoryLength: number | undefined
+		let convertedMessageCount: number | undefined
+
+		const emitMigrationTelemetry = (args: { outcome: "success" | "skipped" | "error"; reason: string }) => {
+			const payload = {
+				taskId,
+				outcome: args.outcome,
+				reason: args.reason,
+				durationMs: Date.now() - startedAt,
+				legacyApiHistoryLength,
+				convertedMessageCount,
+				sdkLookupFailed,
+				hasFavorite: historyItem?.isFavorited === true,
+				hasCost: (historyItem?.totalCost ?? 0) > 0,
+				hasTokenUsage: historyItem ? historyItemHasTokenUsage(historyItem) : undefined,
+				hasCwd: !!historyItem?.cwdOnTaskInitialization,
+			}
+			Logger.log("[SdkTaskHistory] Legacy task migration", payload)
+			this.options.telemetry?.safeCapture(
+				() => this.options.telemetry?.captureLegacyTaskMigration(payload),
+				"SdkTaskHistory.migrateLegacyTaskIfNeeded",
+			)
+		}
+
+		return this.withHistoryHost(async (host) => {
+			try {
+				const existing = await host.get(taskId)
+				if (existing) {
+					emitMigrationTelemetry({ outcome: "skipped", reason: "sdk_exists" })
+					return false
+				}
+			} catch (error) {
+				sdkLookupFailed = true
+				Logger.warn(`[SdkTaskHistory] Failed to check SDK session before legacy migration: ${taskId}`, error)
+			}
+
+			const legacyTask = this.findLegacyTask(taskId)
+			historyItem = legacyTask?.item
+			if (!historyItem) {
+				emitMigrationTelemetry({
+					outcome: "skipped",
+					reason: "legacy_history_missing",
+				})
+				return false
+			}
+
+			const legacyApiHistory = readApiConversationHistory(taskId, legacyTask?.dataDir)
+			legacyApiHistoryLength = legacyApiHistory.length
+			if (legacyApiHistory.length === 0) {
+				emitMigrationTelemetry({
+					outcome: "skipped",
+					reason: "legacy_api_history_empty",
+				})
+				return false
+			}
+
+			const initialMessages = legacyApiHistoryToSdkMessages(legacyApiHistory, historyItem)
+			convertedMessageCount = initialMessages.length
+			if (initialMessages.length === 0) {
+				emitMigrationTelemetry({
+					outcome: "skipped",
+					reason: "converted_messages_empty",
+				})
+				return false
+			}
+
+			const cwd = historyItem.cwdOnTaskInitialization || process.cwd()
+			let config: Awaited<ReturnType<typeof buildSessionConfig>>
+			try {
+				config = await buildSessionConfig({
+					cwd,
+					workspaceRoot: cwd,
+					mode: "act",
+				})
+				config.sessionId = taskId
+			} catch (error) {
+				emitMigrationTelemetry({ outcome: "error", reason: "config_failed" })
+				throw error
+			}
+
+			try {
+				await host.start({
+					config,
+					prompt: undefined,
+					interactive: true,
+					initialMessages,
+					sessionMetadata: {
+						...historyItemToSessionMetadata(historyItem),
+						migratedFromLegacyTask: true,
+					},
+				})
+			} catch (error) {
+				emitMigrationTelemetry({ outcome: "error", reason: "write_failed" })
+				throw error
+			}
+
+			this.invalidateMetadataHistoryCache()
+			Logger.log(`[SdkTaskHistory] Migrated legacy task to SDK session: ${taskId}`)
+			emitMigrationTelemetry({ outcome: "success", reason: "migrated" })
+			return true
+		})
+	}
+
+	private async updateSession(sessionId: string, item: HistoryItem): Promise<void> {
+		const { metadata: writtenMetadata, updated } = await this.withHistoryHost(async (host) => {
+			const existing = await host.get(sessionId)
+			const metadata: Record<string, unknown> = {
+				...(existing?.metadata ?? {}),
+				...historyItemToSessionMetadata(item, existing?.model),
+			}
+			if (item.size === undefined) {
+				const existingSize = existing?.metadata?.size
+				if (existingSize !== undefined) {
+					metadata.size = existingSize
+				} else {
+					delete metadata.size
+				}
+			}
+			const result = await host.update(sessionId, {
+				prompt: item.task,
+				metadata,
+				title: item.task,
+			})
+			return { metadata, updated: result.updated }
+		})
+		if (!updated) {
+			// The write didn't land (e.g. the session was deleted, or an optimistic-
+			// concurrency retry was exhausted by a racing writer). Patching the cache
+			// here would show a fake "updated" record until the TTL expires, so
+			// invalidate instead and let the next read re-enumerate from disk.
+			this.invalidateMetadataHistoryCache()
+			return
+		}
+		// The persistence adapter stamps `updatedAt` with the wall-clock write time
+		// (see `nowIso()` in file-session-service.ts), not `item.ts`. Mirror that here
+		// rather than deriving from `item.ts`: callers like toggleTaskFavorite() reuse
+		// an old HistoryItem whose `ts` predates this write, which would otherwise let
+		// the cached ordering diverge from what's on disk until the cache TTL expires.
+		this.updateCachedSessionRecord(sessionId, {
+			prompt: item.task,
+			metadata: writtenMetadata,
+			updatedAt: new Date().toISOString(),
+		})
+	}
+
+	async updateTaskHistoryItem(item: HistoryItem): Promise<void> {
+		await this.updateSession(item.id, item)
+	}
+
+	private async deleteSession(sessionId: string): Promise<void> {
+		const legacyTask = this.findLegacyTask(sessionId)
+		await this.withHistoryHost(async (host) => {
+			await host.delete(sessionId)
+		})
+		if (legacyTask) {
+			deleteLegacyTask(sessionId, legacyTask.dataDir)
+		}
+		this.invalidateMetadataHistoryCache()
+	}
+
+	async findHistoryItem(taskId: string): Promise<HistoryItem | undefined> {
+		const sdkHistoryItem = await this.withHistoryHost(async (host) => {
+			const sdkRecord = await host.get(taskId)
+			if (!sdkRecord || sdkRecord.isSubagent === true) {
+				return undefined
+			}
+
+			const historyItem = sessionHistoryRecordToHistoryItem(sdkRecord as SessionHistoryRecord)
+			historyItem.size = await this.getCachedTaskSize(host, sdkRecord as SessionHistoryRecord)
+			return historyItem
+		})
+		if (sdkHistoryItem) {
+			return sdkHistoryItem
+		}
+
+		const legacyItem = this.findLegacyTask(taskId)?.item
+		return legacyItem
+	}
+
+	async deleteTaskFromState(id: string): Promise<HistoryItem[]> {
+		await this.deleteSession(id)
+		return (await this.listHistory()).map(sessionHistoryRecordToHistoryItem)
+	}
+
+	async deleteAllTaskHistory(options: { preserveFavorites?: boolean } = {}): Promise<number> {
+		const history = await this.listHistory({ hydrate: false })
+		const tasksToDelete = options.preserveFavorites
+			? history.filter(
+					(item) =>
+						!(
+							metadataBoolean(item.metadata, "isFavorited") ??
+							metadataBoolean(item.metadata, "is_favorited") ??
+							false
+						),
+				)
+			: history
+
+		let deletedCount = 0
+		await this.withHistoryHost(async (host) => {
+			for (const item of tasksToDelete) {
+				try {
+					await host.delete(item.sessionId)
+					deletedCount += 1
+				} catch (error) {
+					Logger.error(`[SdkTaskHistory] Failed to delete task history item: ${item.sessionId}`, error)
+				}
+			}
+		})
+
+		return deletedCount
+	}
+
+	async updateTaskHistory(item: HistoryItem): Promise<HistoryItem[]> {
+		await this.updateTaskHistoryItem(item)
+		return (await this.listHistory()).map(sessionHistoryRecordToHistoryItem)
+	}
+
+	async updateTaskUsage(taskId: string | undefined, usage: TaskUsage): Promise<void> {
+		Logger.log(
+			`[SdkController] Task usage: tokensIn=${usage.tokensIn}, tokensOut=${usage.tokensOut}, cost=${usage.totalCost ?? 0}`,
+		)
+
+		if (!taskId) {
+			return
+		}
+
+		const historyItem = await this.findHistoryItem(taskId)
+		if (!historyItem) {
+			return
+		}
+
+		historyItem.tokensIn = (historyItem.tokensIn || 0) + usage.tokensIn
+		historyItem.tokensOut = (historyItem.tokensOut || 0) + usage.tokensOut
+		historyItem.cacheReads = (historyItem.cacheReads || 0) + (usage.cacheReads ?? 0)
+		historyItem.cacheWrites = (historyItem.cacheWrites || 0) + (usage.cacheWrites ?? 0)
+		historyItem.totalCost = (historyItem.totalCost || 0) + (usage.totalCost ?? 0)
+		historyItem.ts = Date.now()
+
+		await this.updateTaskHistoryItem(historyItem)
+	}
+
+	private async getCachedTaskSize(host: VscodeSessionHost, record: SessionHistoryRecord): Promise<number | undefined> {
+		// metadata.size is a display cache: fill it when absent, and let explicit item.size updates replace it.
+		const cachedSize = metadataNumber(record.metadata, "size")
+		if (cachedSize !== undefined && cachedSize >= 0) {
+			return cachedSize
+		}
+
+		const artifactSize = await this.getSessionArtifactSize(record)
+		if (artifactSize !== undefined) {
+			await this.cacheTaskSize(host, record, artifactSize)
+			return artifactSize
+		}
+
+		return undefined
+	}
+
+	private async getSessionArtifactSize(record: SessionHistoryRecord): Promise<number | undefined> {
+		const messagesPath = typeof record.messagesPath === "string" ? record.messagesPath.trim() : ""
+		if (!messagesPath) {
+			return undefined
+		}
+
+		try {
+			const size = await getFolderSize.loose(path.dirname(messagesPath), {
+				bigint: false,
+			})
+			return Number.isFinite(size) ? size : undefined
+		} catch (error) {
+			Logger.warn(`[SdkTaskHistory] Failed to calculate SDK session size: ${record.sessionId}`, error)
+			return undefined
+		}
+	}
+
+	private async cacheTaskSize(host: VscodeSessionHost, record: SessionHistoryRecord, size: number): Promise<void> {
+		if (!Number.isFinite(size) || size < 0 || metadataNumber(record.metadata, "size") === size) {
+			return
+		}
+
+		await host.update(record.sessionId, {
+			metadata: {
+				...(record.metadata ?? {}),
+				size,
+			},
+		})
+		this.invalidateMetadataHistoryCache()
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-task-start-coordinator.test.ts b/apps/vscode/src/sdk/sdk-task-start-coordinator.test.ts
new file mode 100644
index 0000000..3396e69
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-task-start-coordinator.test.ts
@@ -0,0 +1,303 @@
+import type { HistoryItem } from "@shared/HistoryItem"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { StateManager } from "@/core/storage/StateManager"
+import { PROVIDER_FAILURE_ERROR_TYPE, PROVIDER_FAILURE_PHASE } from "./provider-failure-telemetry"
+import { SdkTaskStartCoordinator, type SdkTaskStartCoordinatorOptions } from "./sdk-task-start-coordinator"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("SdkTaskStartCoordinator", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("initializes a new task, emits the task message, and sends the resolved prompt", async () => {
+		const { coordinator, options, state } = makeCoordinator()
+
+		const sessionId = await coordinator.initTask("hello @file", ["image.png"], ["a.ts"])
+
+		expect(sessionId).toEqual(expect.any(String))
+		expect(options.clearTask).toHaveBeenCalledOnce()
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({
+			prompt: "hello @file",
+			images: ["image.png"],
+			files: ["a.ts"],
+			historyItem: undefined,
+			taskSettings: undefined,
+			cwd: "/workspace",
+			mode: "act",
+		})
+		expect(options.buildStartSessionInput).toHaveBeenCalledWith(
+			expect.objectContaining({ providerId: "anthropic", modelId: "model", sessionId }),
+			expect.objectContaining({
+				prompt: "hello @file",
+				images: ["image.png"],
+				files: ["a.ts"],
+				cwd: "/workspace",
+				mode: "act",
+			}),
+		)
+		expect(state.task?.taskId).toBe(sessionId)
+		expect(options.taskHistory.updateTaskHistoryItem).toHaveBeenCalledWith(
+			expect.objectContaining({ id: sessionId, task: "hello @file", modelId: "model" }),
+		)
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[expect.objectContaining({ type: "say", say: "task", text: "hello @file" })],
+			{ type: "status", payload: { sessionId, status: "running" } },
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+		expect(options.messages.appendAndEmit.mock.invocationCallOrder[0]).toBeLessThan(
+			options.sessions.startNewSession.mock.invocationCallOrder[0],
+		)
+		expect(options.resolveContextMentions).toHaveBeenCalledWith("hello @file")
+		expect(options.sessions.fireAndForgetSend).toHaveBeenCalledWith(
+			expect.objectContaining({ send: expect.any(Function) }),
+			sessionId,
+			"resolved: hello @file",
+			["image.png"],
+			["a.ts"],
+		)
+	})
+
+	it("emits a Cline auth error instead of starting when the cline provider has no token", async () => {
+		const { coordinator, options } = makeCoordinator({ config: { providerId: "cline", modelId: "model", apiKey: "" } })
+
+		const sessionId = await coordinator.initTask("needs auth")
+
+		expect(sessionId).toBeUndefined()
+		expect(options.emitClineAuthError).toHaveBeenCalledWith("needs auth")
+		expect(options.captureProviderApiError).not.toHaveBeenCalled()
+		expect(options.sessions.startNewSession).not.toHaveBeenCalled()
+	})
+
+	it("emits a Cline auth error instead of starting when ClinePass has no token", async () => {
+		const { coordinator, options } = makeCoordinator({ config: { providerId: "cline-pass", modelId: "model", apiKey: "" } })
+
+		const sessionId = await coordinator.initTask("needs clinepass auth")
+
+		expect(sessionId).toBeUndefined()
+		expect(options.emitClineAuthError).toHaveBeenCalledWith("needs clinepass auth")
+		expect(options.captureProviderApiError).not.toHaveBeenCalled()
+		expect(options.sessions.startNewSession).not.toHaveBeenCalled()
+	})
+
+	it("emits a plain chat error when session start fails (e.g. provider misconfigured)", async () => {
+		const { coordinator, options, state } = makeCoordinator()
+		const error = new Error("No model configured for provider openai")
+		options.sessions.startNewSession.mockRejectedValue(error)
+
+		const sessionId = await coordinator.initTask("do something")
+
+		expect(sessionId).toBeUndefined()
+		expect(options.emitClineAuthError).not.toHaveBeenCalled()
+		expect(options.captureProviderApiError).toHaveBeenCalledWith({
+			sessionId: state.task?.taskId,
+			error,
+			providerId: "anthropic",
+			modelId: "model",
+			errorType: PROVIDER_FAILURE_ERROR_TYPE.TASK_INIT,
+			failurePhase: PROVIDER_FAILURE_PHASE.PREFLIGHT,
+		})
+		expect(state.task?.taskId).toEqual(expect.any(String))
+		expect(options.messages.appendAndEmit).toHaveBeenCalledWith(
+			[
+				expect.objectContaining({
+					type: "say",
+					say: "error",
+					text: expect.stringContaining("No model configured for provider openai"),
+				}),
+			],
+			{ type: "status", payload: { sessionId: state.task?.taskId, status: "error" } },
+		)
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it.each([true, false])("forwards task useAutoCondense=%s into SDK session config inputs", async (useAutoCondense) => {
+		const { coordinator, options } = makeCoordinator()
+		const taskSettings = { useAutoCondense }
+
+		await coordinator.initTask("hello", undefined, undefined, undefined, taskSettings)
+
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith(
+			expect.objectContaining({
+				taskSettings,
+			}),
+		)
+		expect(options.buildStartSessionInput).toHaveBeenCalledWith(
+			expect.any(Object),
+			expect.objectContaining({
+				taskSettings,
+			}),
+		)
+	})
+
+	it("reinitializes an existing task with preserved initial messages", async () => {
+		const historyItem: HistoryItem = {
+			id: "task-1",
+			task: "old task",
+			ts: 1,
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+			cwdOnTaskInitialization: "/task-cwd",
+		}
+		const { coordinator, options, state, tempHost } = makeCoordinator({ historyItem })
+
+		await coordinator.reinitExistingTaskFromId("task-1")
+
+		expect(options.clearTask).toHaveBeenCalledOnce()
+		expect(options.taskHistory.findHistoryItem).toHaveBeenCalledWith("task-1")
+		expect(options.sessionConfigBuilder.build).toHaveBeenCalledWith({ cwd: "/task-cwd", mode: "act" })
+		expect(options.createTempSessionHost).toHaveBeenCalledOnce()
+		expect(options.loadInitialMessages).toHaveBeenCalledWith(tempHost, "task-1")
+		expect(tempHost.dispose).toHaveBeenCalledWith("readMessages")
+		expect(options.sessions.startNewSession).toHaveBeenCalledWith({
+			config: expect.objectContaining({ providerId: "anthropic", modelId: "model" }),
+			interactive: true,
+			initialMessages: [{ role: "user", content: "hello" }],
+			sessionMetadata: expect.objectContaining({
+				title: "old task",
+				modelId: "model",
+			}),
+		})
+		expect(state.task?.taskId).toBe("session-123")
+		expect(options.postStateToWebview).toHaveBeenCalledOnce()
+	})
+
+	it("emits Cline auth errors when reinitialization fails due auth", async () => {
+		const { coordinator, options } = makeCoordinator()
+		options.sessionConfigBuilder.build.mockRejectedValue(new Error("missing api key"))
+		options.isClineManagedProviderActive.mockReturnValue(true)
+
+		await coordinator.reinitExistingTaskFromId("task-1")
+
+		expect(options.emitClineAuthError).toHaveBeenCalledWith()
+		expect(options.messages.emitSessionEvents).not.toHaveBeenCalled()
+	})
+})
+
+function makeCoordinator(input: Partial<MakeCoordinatorInput> = {}) {
+	const state: { task?: { taskId: string } } = {}
+	const config = input.config ?? {
+		providerId: "anthropic",
+		modelId: "model",
+		apiKey: "key",
+	}
+	const historyItem = input.historyItem ?? {
+		id: "task-1",
+		task: "old task",
+		ts: 1,
+		tokensIn: 0,
+		tokensOut: 0,
+		totalCost: 0,
+	}
+	const tempHost = {
+		readMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		dispose: vi.fn().mockResolvedValue(undefined),
+	}
+	const sdkHost = {
+		send: vi.fn(),
+	}
+	const options = {
+		stateManager: {
+			getGlobalSettingsKey: vi.fn(() => input.mode ?? "act"),
+		} as unknown as StateManager,
+		sessions: {
+			startNewSession: vi.fn((startInput?: { config?: { sessionId?: string } }) => ({
+				startResult: { sessionId: startInput?.config?.sessionId ?? "session-123" },
+				sdkHost,
+			})),
+			fireAndForgetSend: vi.fn(),
+		},
+		messages: {
+			appendAndEmit: vi.fn(),
+			emitSessionEvents: vi.fn(),
+		},
+		taskHistory: {
+			findHistoryItem: vi.fn(() => (input.hasHistoryItem === false ? undefined : historyItem)),
+			updateTaskHistory: vi.fn().mockResolvedValue([]),
+			updateTaskHistoryItem: vi.fn().mockResolvedValue(undefined),
+		},
+		sessionConfigBuilder: {
+			build: vi.fn().mockResolvedValue(config),
+		},
+		buildStartSessionInput: vi.fn((startConfig, startInput) => ({
+			config: startConfig,
+			interactive: true,
+			prompt: startInput.prompt,
+		})),
+		createHistoryItemFromSession: vi.fn((sessionId, task, modelId, cwd) => ({
+			id: sessionId,
+			task,
+			ts: 1,
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+			modelId,
+			cwdOnTaskInitialization: cwd,
+		})),
+		clearTask: vi.fn().mockResolvedValue(undefined),
+		setTask: vi.fn((task) => {
+			state.task = task as { taskId: string } | undefined
+		}),
+		onAskResponse: vi.fn().mockResolvedValue(undefined),
+		onCancelTask: vi.fn().mockResolvedValue(undefined),
+		getWorkspaceRoot: vi.fn().mockResolvedValue("/workspace"),
+		createTempSessionHost: vi.fn().mockResolvedValue(tempHost),
+		loadInitialMessages: vi.fn().mockResolvedValue([{ role: "user", content: "hello" }]),
+		resolveContextMentions: vi.fn(async (text: string) => `resolved: ${text}`),
+		isClineManagedProviderActive: vi.fn(() => false),
+		emitClineAuthError: vi.fn(),
+		captureProviderApiError: vi.fn(),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+	} as unknown as SdkTaskStartCoordinatorOptions & {
+		sessions: SdkTaskStartCoordinatorOptions["sessions"] & {
+			startNewSession: ReturnType<typeof vi.fn>
+			fireAndForgetSend: ReturnType<typeof vi.fn>
+		}
+		messages: SdkTaskStartCoordinatorOptions["messages"] & {
+			appendAndEmit: ReturnType<typeof vi.fn>
+			emitSessionEvents: ReturnType<typeof vi.fn>
+		}
+		taskHistory: SdkTaskStartCoordinatorOptions["taskHistory"] & {
+			findHistoryItem: ReturnType<typeof vi.fn>
+			updateTaskHistory: ReturnType<typeof vi.fn>
+			updateTaskHistoryItem: ReturnType<typeof vi.fn>
+		}
+		sessionConfigBuilder: SdkTaskStartCoordinatorOptions["sessionConfigBuilder"] & { build: ReturnType<typeof vi.fn> }
+		buildStartSessionInput: ReturnType<typeof vi.fn>
+		createHistoryItemFromSession: ReturnType<typeof vi.fn>
+		clearTask: ReturnType<typeof vi.fn>
+		createTempSessionHost: ReturnType<typeof vi.fn>
+		loadInitialMessages: ReturnType<typeof vi.fn>
+		resolveContextMentions: ReturnType<typeof vi.fn>
+		isClineManagedProviderActive: ReturnType<typeof vi.fn>
+		emitClineAuthError: ReturnType<typeof vi.fn>
+		captureProviderApiError: ReturnType<typeof vi.fn>
+		postStateToWebview: ReturnType<typeof vi.fn>
+	}
+
+	return {
+		coordinator: new SdkTaskStartCoordinator(options),
+		options,
+		state,
+		tempHost,
+	}
+}
+
+interface MakeCoordinatorInput {
+	mode: "act" | "plan"
+	config: {
+		providerId: string
+		modelId: string
+		apiKey: string
+	}
+	historyItem: HistoryItem
+	hasHistoryItem: boolean
+}
diff --git a/apps/vscode/src/sdk/sdk-task-start-coordinator.ts b/apps/vscode/src/sdk/sdk-task-start-coordinator.ts
new file mode 100644
index 0000000..7282a94
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-task-start-coordinator.ts
@@ -0,0 +1,281 @@
+import { getProviderAuthStorageId } from "@cline/core"
+import { createSessionId } from "@cline/shared"
+import { CLINE_ACCOUNT_AUTH_ERROR_MESSAGE } from "@shared/ClineAccount"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type { HistoryItem } from "@shared/HistoryItem"
+import type { Settings } from "@shared/storage/state-keys"
+import type { Mode } from "@shared/storage/types"
+import type { StateManager } from "@/core/storage/StateManager"
+import { Logger } from "@/shared/services/Logger"
+import { PROVIDER_FAILURE_ERROR_TYPE, PROVIDER_FAILURE_PHASE, type ProviderFailureTelemetry } from "./provider-failure-telemetry"
+import type { SdkMessageCoordinator } from "./sdk-message-coordinator"
+import type { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
+import type { SdkSessionLifecycle } from "./sdk-session-lifecycle"
+import { historyItemToSessionMetadata, type SdkTaskHistory } from "./sdk-task-history"
+import type { SdkSessionHost } from "./session-host"
+import { createTaskProxy, type TaskProxy } from "./task-proxy"
+import type { VscodeSessionHost } from "./vscode-session-host"
+
+type StartInput = Parameters<VscodeSessionHost["start"]>[0]
+type InitialMessages = StartInput["initialMessages"]
+type SessionConfig = Awaited<ReturnType<SdkSessionConfigBuilder["build"]>>
+
+function usesClineAccountAuth(providerId: string): boolean {
+	return getProviderAuthStorageId(providerId) === "cline"
+}
+
+export interface SdkTaskStartCoordinatorOptions {
+	stateManager: StateManager
+	sessions: SdkSessionLifecycle
+	messages: SdkMessageCoordinator
+	taskHistory: SdkTaskHistory
+	sessionConfigBuilder: SdkSessionConfigBuilder
+	buildStartSessionInput: (
+		config: SessionConfig,
+		input: {
+			prompt?: string
+			images?: string[]
+			files?: string[]
+			historyItem?: HistoryItem
+			taskSettings?: Partial<Settings>
+			cwd: string
+			mode: Mode
+		},
+	) => StartInput
+	createHistoryItemFromSession: (sessionId: string, prompt: string, modelId?: string, cwd?: string) => HistoryItem
+	clearTask: () => Promise<void>
+	setTask: (task: TaskProxy | undefined) => void
+	onAskResponse: (text?: string, images?: string[], files?: string[]) => Promise<void>
+	onCancelTask: () => Promise<void>
+	getWorkspaceRoot: () => Promise<string>
+	createTempSessionHost: () => Promise<SdkSessionHost>
+	loadInitialMessages: (reader: SdkSessionHost, taskId: string) => Promise<unknown[] | undefined>
+	resolveContextMentions: (text: string) => Promise<string>
+	isClineManagedProviderActive: () => boolean
+	emitClineAuthError: (task?: string) => void
+	captureProviderApiError?: (event: ProviderFailureTelemetry) => void
+	postStateToWebview: () => Promise<void>
+}
+
+export class SdkTaskStartCoordinator {
+	constructor(private readonly options: SdkTaskStartCoordinatorOptions) {}
+
+	async initTask(
+		prompt?: string,
+		images?: string[],
+		files?: string[],
+		historyItem?: HistoryItem,
+		taskSettings?: Partial<Settings>,
+	): Promise<string | undefined> {
+		Logger.log(`[SdkController] initTask called: "${prompt?.substring(0, 50)}"`)
+		let taskSessionId: string | undefined
+		let providerId: string | undefined
+		let modelId: string | undefined
+		try {
+			await this.options.clearTask()
+
+			const cwd = await this.options.getWorkspaceRoot()
+			const mode = this.getCurrentMode()
+			Logger.log(`[SdkController] Building session config: mode=${mode}, cwd=${cwd}`)
+			const config = await this.options.sessionConfigBuilder.build({
+				prompt,
+				images,
+				files,
+				historyItem,
+				taskSettings,
+				cwd,
+				mode,
+			})
+			providerId = config.providerId
+			modelId = config.modelId
+
+			Logger.log(
+				`[SdkController] Session config: provider=${config.providerId}, model=${config.modelId}, hasApiKey=${!!config.apiKey}`,
+			)
+
+			if (usesClineAccountAuth(config.providerId) && !config.apiKey) {
+				Logger.warn(
+					`[SdkController] ${config.providerId} provider selected but no Cline auth token — emitting auth error`,
+				)
+				// No task/session id exists yet, so this preflight auth UI path is
+				// intentionally not recorded as task-joinable provider error telemetry.
+				this.options.emitClineAuthError(prompt)
+				return undefined
+			}
+
+			taskSessionId = config.sessionId?.trim() || createSessionId()
+			const configWithSessionId = {
+				...config,
+				sessionId: taskSessionId,
+			}
+
+			const startInput = this.options.buildStartSessionInput(configWithSessionId, {
+				prompt: prompt,
+				images,
+				files,
+				historyItem,
+				taskSettings,
+				cwd,
+				mode,
+			})
+
+			const task = this.createAndSetTask(taskSessionId)
+			this.emitInitialTaskMessage(taskSessionId, prompt ?? "")
+
+			const { startResult, sdkHost } = await this.options.sessions.startNewSession(startInput)
+			if (startResult.sessionId !== taskSessionId) {
+				Logger.warn(
+					`[SdkController] SDK returned session id ${startResult.sessionId} after requested id ${taskSessionId}`,
+				)
+				task.taskId = startResult.sessionId
+				taskSessionId = startResult.sessionId
+			}
+
+			const newHistoryItem = this.options.createHistoryItemFromSession(
+				taskSessionId,
+				prompt ?? "",
+				configWithSessionId.modelId,
+				cwd,
+			)
+			await this.options.taskHistory.updateTaskHistoryItem(newHistoryItem)
+			await this.options.postStateToWebview()
+
+			if (prompt?.trim() || images?.length || files?.length) {
+				Logger.log(`[SdkController] Sending prompt to session: ${taskSessionId}`)
+				const resolvedTask = await this.options.resolveContextMentions(prompt || "")
+				this.options.sessions.fireAndForgetSend(sdkHost, taskSessionId, resolvedTask, images, files)
+			}
+
+			Logger.log(`[SdkController] Task initialized: ${taskSessionId}`)
+			return taskSessionId
+		} catch (error) {
+			this.options.captureProviderApiError?.({
+				sessionId: taskSessionId,
+				error,
+				providerId,
+				modelId,
+				errorType: PROVIDER_FAILURE_ERROR_TYPE.TASK_INIT,
+				failurePhase: PROVIDER_FAILURE_PHASE.PREFLIGHT,
+			})
+			this.handleInitError(error, taskSessionId)
+			await this.options.postStateToWebview().catch((postError) => {
+				Logger.error("[SdkController] Failed to post state after init error:", postError)
+			})
+			return undefined
+		}
+	}
+
+	async reinitExistingTaskFromId(taskId: string): Promise<void> {
+		try {
+			await this.options.clearTask()
+
+			const historyItem = await this.options.taskHistory.findHistoryItem(taskId)
+			if (!historyItem) {
+				Logger.error(`[SdkController] Task not found in history: ${taskId}`)
+				return
+			}
+
+			const cwd = historyItem.cwdOnTaskInitialization ?? (await this.options.getWorkspaceRoot())
+			const config = await this.options.sessionConfigBuilder.build({
+				cwd,
+				mode: "act",
+			})
+
+			const tempManager = await this.options.createTempSessionHost()
+			const initialMessages = await this.options.loadInitialMessages(tempManager, taskId)
+			await tempManager.dispose("readMessages")
+
+			const { startResult } = await this.options.sessions.startNewSession({
+				config,
+				interactive: true,
+				...(initialMessages ? { initialMessages: initialMessages as InitialMessages } : {}),
+				sessionMetadata: historyItemToSessionMetadata(historyItem, config.modelId),
+			})
+
+			this.createAndSetTask(startResult.sessionId)
+			await this.options.postStateToWebview()
+
+			Logger.log(`[SdkController] Task resumed: ${taskId} → ${startResult.sessionId}`)
+		} catch (error) {
+			this.handleReinitError(taskId, error)
+		}
+	}
+
+	private getCurrentMode(): Mode {
+		const m = this.options.stateManager.getGlobalSettingsKey("mode")
+		return m === "plan" ? m : "act"
+	}
+
+	private createAndSetTask(sessionId: string): TaskProxy {
+		const task = createTaskProxy(
+			sessionId,
+			(text?: string, images?: string[], files?: string[]) => this.options.onAskResponse(text, images, files),
+			() => this.options.onCancelTask(),
+		)
+		this.options.setTask(task)
+		return task
+	}
+
+	private emitInitialTaskMessage(sessionId: string, task: string): void {
+		const taskMessage: ClineMessage = {
+			ts: Date.now(),
+			type: "say",
+			say: "task",
+			text: task,
+			partial: false,
+		}
+		this.options.messages.appendAndEmit([taskMessage], {
+			type: "status",
+			payload: { sessionId, status: "running" },
+		})
+	}
+
+	private handleInitError(error: unknown, sessionId?: string): void {
+		const errorDetails =
+			error instanceof Error ? `${error.name}: ${error.message}\n${error.stack?.substring(0, 500)}` : String(error)
+		Logger.error(`[SdkController] Failed to init task: ${errorDetails}`)
+		;(globalThis as Record<string, unknown>).__cline_last_init_error = errorDetails
+		;(globalThis as Record<string, unknown>).__cline_last_init_error_raw = error
+		this.options.messages.appendAndEmit(
+			[
+				{
+					ts: Date.now(),
+					type: "say",
+					say: "error",
+					text: `Failed to start task: ${error instanceof Error ? error.message : String(error)}`,
+					partial: false,
+				},
+			],
+			{ type: "status", payload: { sessionId: sessionId ?? "", status: "error" } },
+		)
+	}
+
+	private handleReinitError(taskId: string, error: unknown): void {
+		Logger.error("[SdkController] Failed to reinit task:", error)
+
+		const reinitErrorMsg = error instanceof Error ? error.message : String(error)
+		const isClineAuthReinit =
+			this.options.isClineManagedProviderActive() &&
+			(reinitErrorMsg.includes(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE) ||
+				reinitErrorMsg.toLowerCase().includes("missing api key") ||
+				reinitErrorMsg.toLowerCase().includes("unauthorized"))
+
+		if (isClineAuthReinit) {
+			this.options.emitClineAuthError()
+			return
+		}
+
+		this.options.messages.emitSessionEvents(
+			[
+				{
+					ts: Date.now(),
+					type: "say",
+					say: "error",
+					text: `Failed to resume task: ${reinitErrorMsg}`,
+					partial: false,
+				},
+			],
+			{ type: "status", payload: { sessionId: taskId, status: "error" } },
+		)
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-telemetry.test.ts b/apps/vscode/src/sdk/sdk-telemetry.test.ts
new file mode 100644
index 0000000..3f199c9
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-telemetry.test.ts
@@ -0,0 +1,161 @@
+import type { ConfiguredTelemetryHandle, ITelemetryService } from "@cline/core"
+import type { Mock } from "vitest"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { Setting } from "@/shared/proto/index.host"
+
+const telemetryState = vi.hoisted(() => ({
+	clineTelemetrySetting: "unset" as string | undefined,
+	hostSetting: 1,
+	subscribeCallback: undefined as ((event: { isEnabled: number }) => void) | undefined,
+	unsubscribe: vi.fn(),
+}))
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: {
+		get: () => ({
+			getGlobalSettingsKey: (key: string) =>
+				key === "telemetrySetting" ? telemetryState.clineTelemetrySetting : undefined,
+		}),
+	},
+}))
+
+vi.mock("@/hosts/host-provider", () => ({
+	HostProvider: {
+		env: {
+			getTelemetrySettings: vi.fn(async () => ({ isEnabled: telemetryState.hostSetting })),
+			subscribeToTelemetrySettings: vi.fn((_request, callbacks: { onResponse: (event: { isEnabled: number }) => void }) => {
+				telemetryState.subscribeCallback = callbacks.onResponse
+				return telemetryState.unsubscribe
+			}),
+		},
+	},
+}))
+
+import { VscodeTelemetryPolicyService } from "./sdk-telemetry"
+
+describe("VscodeTelemetryPolicyService", () => {
+	beforeEach(() => {
+		telemetryState.clineTelemetrySetting = "unset"
+		telemetryState.hostSetting = Setting.ENABLED
+		telemetryState.subscribeCallback = undefined
+		telemetryState.unsubscribe.mockReset()
+	})
+
+	it("drops ordinary events until the async host telemetry setting resolves", () => {
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+
+		service.capture({ event: "session.started" })
+
+		expect(handle.telemetry.capture).not.toHaveBeenCalled()
+	})
+
+	it("allows ordinary events when host telemetry is enabled and Cline telemetry is not disabled", async () => {
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+		await settlePromises()
+
+		service.capture({ event: "session.started", properties: { sessionId: "s1" } })
+
+		expect(handle.telemetry.capture).toHaveBeenCalledWith({ event: "session.started", properties: { sessionId: "s1" } })
+	})
+
+	it("drops ordinary events when Cline telemetry is disabled but allows required events while host telemetry is enabled", async () => {
+		telemetryState.clineTelemetrySetting = "disabled"
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+		await settlePromises()
+
+		service.capture({ event: "task.created" })
+		service.captureRequired("user.opt_out", { explicit: true })
+
+		expect(handle.telemetry.capture).not.toHaveBeenCalled()
+		expect(handle.telemetry.captureRequired).toHaveBeenCalledWith("user.opt_out", { explicit: true })
+	})
+
+	it("drops ordinary and required events when host telemetry is disabled", async () => {
+		telemetryState.hostSetting = Setting.DISABLED
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+		await settlePromises()
+
+		service.capture({ event: "task.created" })
+		service.captureRequired("user.opt_out")
+
+		expect(handle.telemetry.capture).not.toHaveBeenCalled()
+		expect(handle.telemetry.captureRequired).not.toHaveBeenCalled()
+	})
+
+	it("uses host telemetry subscription updates for later events", async () => {
+		telemetryState.hostSetting = Setting.DISABLED
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+		await settlePromises()
+
+		service.capture({ event: "task.created" })
+		telemetryState.subscribeCallback?.({ isEnabled: Setting.ENABLED })
+		service.capture({ event: "task.created" })
+
+		expect(handle.telemetry.capture).toHaveBeenCalledTimes(1)
+	})
+
+	it("gates metrics with the same ordinary/required policy", async () => {
+		telemetryState.clineTelemetrySetting = "disabled"
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+		await settlePromises()
+
+		service.recordCounter("ordinary", 1)
+		service.recordCounter("required", 1, undefined, undefined, true)
+
+		expect(handle.telemetry.recordCounter).toHaveBeenCalledTimes(1)
+		expect(handle.telemetry.recordCounter).toHaveBeenCalledWith("required", 1, undefined, undefined, true)
+	})
+
+	it("always forwards metadata mutators and cleans up on dispose", async () => {
+		const handle = createHandle()
+		const service = new VscodeTelemetryPolicyService(handle)
+
+		service.updateCommonProperties({ member_id: "member-1" })
+		await service.dispose()
+
+		expect(handle.telemetry.updateCommonProperties).toHaveBeenCalledWith({ member_id: "member-1" })
+		expect(telemetryState.unsubscribe).toHaveBeenCalled()
+		expect(handle.dispose).toHaveBeenCalled()
+	})
+})
+
+function createHandle(): ConfiguredTelemetryHandle & { telemetry: MockTelemetry } {
+	const telemetry: MockTelemetry = {
+		setDistinctId: vi.fn<(distinctId?: string) => void>(),
+		setMetadata: vi.fn<ITelemetryService["setMetadata"]>(),
+		updateMetadata: vi.fn<ITelemetryService["updateMetadata"]>(),
+		setCommonProperties: vi.fn<ITelemetryService["setCommonProperties"]>(),
+		updateCommonProperties: vi.fn<ITelemetryService["updateCommonProperties"]>(),
+		isEnabled: vi.fn(() => true),
+		capture: vi.fn<ITelemetryService["capture"]>(),
+		captureRequired: vi.fn<ITelemetryService["captureRequired"]>(),
+		recordCounter: vi.fn<ITelemetryService["recordCounter"]>(),
+		recordHistogram: vi.fn<ITelemetryService["recordHistogram"]>(),
+		recordGauge: vi.fn<ITelemetryService["recordGauge"]>(),
+		flush: vi.fn(async () => {}),
+		dispose: vi.fn(async () => {}),
+	}
+	return {
+		telemetry,
+		flush: vi.fn(async () => {}),
+		dispose: vi.fn(async () => {}),
+	}
+}
+
+type MockTelemetry = ITelemetryService & {
+	capture: ITelemetryService["capture"] & Mock<ITelemetryService["capture"]>
+	captureRequired: ITelemetryService["captureRequired"] & Mock<ITelemetryService["captureRequired"]>
+	recordCounter: ITelemetryService["recordCounter"] & Mock<ITelemetryService["recordCounter"]>
+	updateCommonProperties: ITelemetryService["updateCommonProperties"] & Mock<ITelemetryService["updateCommonProperties"]>
+}
+
+async function settlePromises(): Promise<void> {
+	await Promise.resolve()
+	await Promise.resolve()
+}
diff --git a/apps/vscode/src/sdk/sdk-telemetry.ts b/apps/vscode/src/sdk/sdk-telemetry.ts
new file mode 100644
index 0000000..f67234a
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-telemetry.ts
@@ -0,0 +1,188 @@
+import {
+	type ConfiguredTelemetryHandle,
+	createClineTelemetryServiceConfig,
+	createConfiguredTelemetryHandle,
+	type ITelemetryService,
+	type TelemetryMetadata,
+	type TelemetryProperties,
+} from "@cline/core"
+import * as os from "os"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostProvider } from "@/hosts/host-provider"
+import { ExtensionRegistryInfo } from "@/registry"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { Setting } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+
+export interface VscodeSdkTelemetryHandle {
+	readonly telemetry: ITelemetryService
+	flush(): Promise<void>
+	dispose(): Promise<void>
+}
+
+export interface CreateVscodeSdkTelemetryHandleOptions {
+	telemetryHandle?: ConfiguredTelemetryHandle
+	metadata?: Partial<TelemetryMetadata>
+}
+
+type TelemetrySettingsEvent = { isEnabled: Setting }
+
+export function createVscodeSdkTelemetryHandle(options: CreateVscodeSdkTelemetryHandleOptions = {}): VscodeSdkTelemetryHandle {
+	const sdkHandle =
+		options.telemetryHandle ??
+		createConfiguredTelemetryHandle({
+			...createClineTelemetryServiceConfig({
+				metadata: {
+					extension_version: ExtensionRegistryInfo.version,
+					cline_type: "VSCode Extension",
+					platform: "VS Code",
+					platform_version: "unknown",
+					os_type: process.platform,
+					os_version: os.version(),
+					is_dev: process.env.IS_DEV,
+					...options.metadata,
+				},
+			}),
+			distinctId: getDistinctId() || undefined,
+		})
+
+	const telemetry = new VscodeTelemetryPolicyService(sdkHandle)
+	return {
+		telemetry,
+		flush: () => telemetry.flush(),
+		dispose: () => telemetry.dispose(),
+	}
+}
+
+export class VscodeTelemetryPolicyService implements ITelemetryService {
+	private hostTelemetryEnabled = false
+	private disposed = false
+	private unsubscribeHostTelemetrySettings?: () => void
+
+	constructor(private readonly handle: ConfiguredTelemetryHandle) {
+		this.initializeHostTelemetryState()
+	}
+
+	setDistinctId(distinctId?: string): void {
+		this.handle.telemetry.setDistinctId(distinctId)
+	}
+
+	setMetadata(metadata: Partial<TelemetryMetadata>): void {
+		this.handle.telemetry.setMetadata(metadata)
+	}
+
+	updateMetadata(metadata: Partial<TelemetryMetadata>): void {
+		this.handle.telemetry.updateMetadata(metadata)
+	}
+
+	setCommonProperties(properties: TelemetryProperties): void {
+		this.handle.telemetry.setCommonProperties(properties)
+	}
+
+	updateCommonProperties(properties: TelemetryProperties): void {
+		this.handle.telemetry.updateCommonProperties(properties)
+	}
+
+	isEnabled(): boolean {
+		return this.isOrdinaryTelemetryAllowed() && this.handle.telemetry.isEnabled()
+	}
+
+	capture(input: { event: string; properties?: TelemetryProperties }): void {
+		if (!this.isOrdinaryTelemetryAllowed()) {
+			return
+		}
+		this.handle.telemetry.capture(input)
+	}
+
+	captureRequired(event: string, properties?: TelemetryProperties): void {
+		if (!this.isRequiredTelemetryAllowed()) {
+			return
+		}
+		this.handle.telemetry.captureRequired(event, properties)
+	}
+
+	recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required = false): void {
+		if (!this.isMetricAllowed(required)) {
+			return
+		}
+		this.handle.telemetry.recordCounter(name, value, attributes, description, required)
+	}
+
+	recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required = false): void {
+		if (!this.isMetricAllowed(required)) {
+			return
+		}
+		this.handle.telemetry.recordHistogram(name, value, attributes, description, required)
+	}
+
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.isMetricAllowed(required)) {
+			return
+		}
+		this.handle.telemetry.recordGauge(name, value, attributes, description, required)
+	}
+
+	async flush(): Promise<void> {
+		await this.handle.flush()
+		await this.handle.telemetry.flush()
+	}
+
+	async dispose(): Promise<void> {
+		if (this.disposed) {
+			return
+		}
+		this.disposed = true
+		this.unsubscribeHostTelemetrySettings?.()
+		this.unsubscribeHostTelemetrySettings = undefined
+		await this.handle.dispose()
+	}
+
+	private initializeHostTelemetryState(): void {
+		HostProvider.env
+			.getTelemetrySettings({})
+			.then((settings) => {
+				this.applyHostTelemetrySetting(settings.isEnabled)
+			})
+			.catch((error) => {
+				Logger.warn("[SdkTelemetry] Failed to read host telemetry setting; keeping SDK telemetry disabled", error)
+			})
+
+		try {
+			this.unsubscribeHostTelemetrySettings = HostProvider.env.subscribeToTelemetrySettings(
+				{},
+				{
+					onResponse: (event: TelemetrySettingsEvent) => {
+						this.applyHostTelemetrySetting(event.isEnabled)
+					},
+					onError: (error: Error) => {
+						Logger.warn("[SdkTelemetry] Host telemetry subscription failed; keeping last known state", error)
+					},
+				},
+			)
+		} catch (error) {
+			Logger.warn("[SdkTelemetry] Failed to subscribe to host telemetry changes", error)
+		}
+	}
+
+	private applyHostTelemetrySetting(setting: Setting): void {
+		this.hostTelemetryEnabled = setting === Setting.ENABLED || setting === Setting.UNSUPPORTED
+	}
+
+	private isOrdinaryTelemetryAllowed(): boolean {
+		return this.hostTelemetryEnabled && StateManager.get().getGlobalSettingsKey("telemetrySetting") !== "disabled"
+	}
+
+	private isRequiredTelemetryAllowed(): boolean {
+		return this.hostTelemetryEnabled
+	}
+
+	private isMetricAllowed(required: boolean): boolean {
+		return required ? this.isRequiredTelemetryAllowed() : this.isOrdinaryTelemetryAllowed()
+	}
+}
diff --git a/apps/vscode/src/sdk/sdk-tool-policies.test.ts b/apps/vscode/src/sdk/sdk-tool-policies.test.ts
new file mode 100644
index 0000000..413007d
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-tool-policies.test.ts
@@ -0,0 +1,22 @@
+import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
+import { describe, expect, it } from "vitest"
+import { isToolAutoApproved } from "./sdk-tool-policies"
+
+describe("isToolAutoApproved", () => {
+	it("does not auto-approve command tools by default", () => {
+		expect(isToolAutoApproved("run_commands", DEFAULT_AUTO_APPROVAL_SETTINGS)).toBe(false)
+	})
+
+	it("uses executeSafeCommands as the single command approval flag", () => {
+		const settings = {
+			...DEFAULT_AUTO_APPROVAL_SETTINGS,
+			actions: {
+				...DEFAULT_AUTO_APPROVAL_SETTINGS.actions,
+				executeSafeCommands: false,
+				executeAllCommands: true,
+			},
+		}
+
+		expect(isToolAutoApproved("run_commands", settings)).toBe(false)
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-tool-policies.ts b/apps/vscode/src/sdk/sdk-tool-policies.ts
new file mode 100644
index 0000000..9ab08eb
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-tool-policies.ts
@@ -0,0 +1,100 @@
+import type { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
+import type { McpHub } from "@/services/mcp/McpHub"
+
+/**
+ * Build SDK `toolPolicies` for tools governed by Cline's auto-approval UI.
+ *
+ * The SDK defaults unlisted tools to auto-approved. For tools controlled by
+ * AutoApproveBar/MCP per-tool settings, force the SDK to call
+ * `requestToolApproval`; the approval callback then evaluates the latest
+ * settings and either silently approves or shows the approval UI. This keeps
+ * active sessions in sync when the user toggles auto-approval mid-task.
+ */
+export function buildToolPolicies(
+	_settings: AutoApprovalSettings,
+	mcpHub?: McpHub,
+): Record<string, { enabled?: boolean; autoApprove?: boolean }> {
+	const policies: Record<string, { enabled?: boolean; autoApprove?: boolean }> = {}
+
+	const set = (tools: string[]) => {
+		for (const tool of tools) {
+			policies[tool] = { autoApprove: false }
+		}
+	}
+
+	set(["read_files", "read_file", "list_files", "list_code_definition_names", "search_codebase", "search_files"])
+	set(["editor", "replace_in_file", "write_to_file", "apply_patch", "delete_file"])
+	set(["run_commands", "execute_command"])
+	set(["fetch_web_content", "web_fetch", "web_search"])
+
+	if (mcpHub) {
+		for (const server of mcpHub.getServers()) {
+			for (const tool of server.tools ?? []) {
+				const sdkName = `${server.name}__${tool.name}`
+				policies[sdkName] = { autoApprove: false }
+			}
+		}
+	}
+
+	return policies
+}
+
+/**
+ * Evaluate the current UI auto-approval settings for a single SDK tool name.
+ * Used both when building initial SDK policies and as a live guard in the
+ * approval callback, so changes from the AutoApproveBar are respected even if
+ * an SDK session was created before the toggle changed.
+ */
+export function isToolAutoApproved(toolName: string, settings: AutoApprovalSettings, mcpHub?: McpHub): boolean {
+	if (isReadTool(toolName)) {
+		return !!settings.actions.readFiles
+	}
+	if (isEditTool(toolName)) {
+		return !!settings.actions.editFiles
+	}
+	if (isCommandTool(toolName)) {
+		return !!settings.actions.executeSafeCommands
+	}
+	if (isBrowserTool(toolName)) {
+		return !!settings.actions.useBrowser
+	}
+
+	const mcpTool = parseMcpToolName(toolName)
+	if (mcpTool) {
+		if (!settings.actions.useMcp || !mcpHub) {
+			return false
+		}
+		const server = mcpHub.getServers().find((entry) => entry.name === mcpTool.serverName)
+		const tool = server?.tools?.find((entry) => entry.name === mcpTool.toolName)
+		return !!tool?.autoApprove
+	}
+
+	return false
+}
+
+function isReadTool(toolName: string): boolean {
+	return ["read_files", "read_file", "list_files", "list_code_definition_names", "search_codebase", "search_files"].includes(
+		toolName,
+	)
+}
+
+function isEditTool(toolName: string): boolean {
+	return ["editor", "replace_in_file", "write_to_file", "apply_patch", "delete_file"].includes(toolName)
+}
+
+function isCommandTool(toolName: string): boolean {
+	return toolName === "run_commands" || toolName === "execute_command"
+}
+
+function isBrowserTool(toolName: string): boolean {
+	return toolName === "fetch_web_content" || toolName === "web_fetch" || toolName === "web_search"
+}
+
+function parseMcpToolName(toolName: string): { serverName: string; toolName: string } | undefined {
+	const separatorIndex = toolName.indexOf("__")
+	if (separatorIndex <= 0) return undefined
+	const serverName = toolName.substring(0, separatorIndex)
+	const mcpToolName = toolName.substring(separatorIndex + 2)
+	if (!mcpToolName) return undefined
+	return { serverName, toolName: mcpToolName }
+}
diff --git a/apps/vscode/src/sdk/sdk-user-message-mapping.test.ts b/apps/vscode/src/sdk/sdk-user-message-mapping.test.ts
new file mode 100644
index 0000000..1c2f89a
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-user-message-mapping.test.ts
@@ -0,0 +1,138 @@
+import { describe, expect, it } from "vitest"
+import { ACT_MODE_CONTINUATION_PROMPT } from "./sdk-mode-coordinator"
+import { extractSdkUserText, findSdkUserMessageIndexByOrdinal, isSyntheticUserPrompt } from "./sdk-user-message-mapping"
+
+// Persisted prompts are wrapped by formatModePrompt before they reach SDK
+// history; the mapping must recognize the wrapped shape, not just raw text.
+const wrapped = (text: string, mode = "act") => `<user_input mode="${mode}">${text}</user_input>`
+
+describe("isSyntheticUserPrompt", () => {
+	it("flags task resumption and act-mode continuation prompts", () => {
+		expect(isSyntheticUserPrompt("[TASK RESUMPTION] Please continue where you left off.")).toBe(true)
+		expect(isSyntheticUserPrompt(ACT_MODE_CONTINUATION_PROMPT)).toBe(true)
+	})
+
+	it("flags the wrapped persisted shape of synthetic prompts", () => {
+		expect(isSyntheticUserPrompt(wrapped(ACT_MODE_CONTINUATION_PROMPT))).toBe(true)
+		expect(isSyntheticUserPrompt(wrapped("[TASK RESUMPTION] Please continue where you left off.", "plan"))).toBe(true)
+	})
+
+	it("does not flag ordinary user messages, wrapped or raw", () => {
+		expect(isSyntheticUserPrompt("make a plan for the auth refactor")).toBe(false)
+		expect(isSyntheticUserPrompt(wrapped("go ahead and implement step 1"))).toBe(false)
+	})
+})
+
+describe("findSdkUserMessageIndexByOrdinal", () => {
+	const user = (text: string) => ({ role: "user", content: text })
+	const assistant = (text: string) => ({ role: "assistant", content: text })
+
+	it("maps visible ordinals one to one when no synthetic prompts exist", () => {
+		const messages = [user("task"), assistant("plan"), user("follow-up")]
+
+		expect(findSdkUserMessageIndexByOrdinal(messages, 1)).toBe(0)
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(2)
+	})
+
+	it("skips the hidden act-mode continuation prompt as persisted", () => {
+		// Plan task, plan presented, empty-composer toggle to act (hidden canned
+		// prompt in SDK history, no visible user_feedback), act work, follow-up.
+		// Persisted prompts carry the formatModePrompt wrapper.
+		const messages = [
+			user(wrapped("plan the auth refactor", "plan")),
+			assistant("here is the plan"),
+			user(wrapped(ACT_MODE_CONTINUATION_PROMPT)),
+			assistant("done with step 1"),
+			user(wrapped("now do step 2")),
+		]
+
+		// The visible transcript has 2 user messages; the 2nd must map past the
+		// hidden continuation to index 4, not index 2.
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(4)
+	})
+
+	it("skips task resumption prompts as persisted", () => {
+		const messages = [
+			user(wrapped("original task")),
+			assistant("partial work"),
+			user(wrapped("[TASK RESUMPTION] Please continue where you left off.")),
+			assistant("resumed work"),
+			user(wrapped("looks good, keep going")),
+		]
+
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(4)
+	})
+
+	it("returns -1 when the ordinal exceeds the visible user messages", () => {
+		const messages = [user("task"), user(ACT_MODE_CONTINUATION_PROMPT)]
+
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(-1)
+	})
+
+	it("counts an attachment-only continuation because it has a visible bubble", () => {
+		// Attachment-only plan -> act toggle: the SDK message carries the canned
+		// prompt text plus the user's image, and the webview shows a user_feedback
+		// bubble for the attachment, so the message must be counted.
+		const messages = [
+			user(wrapped("plan the auth refactor", "plan")),
+			assistant("here is the plan"),
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: wrapped(ACT_MODE_CONTINUATION_PROMPT) },
+					{ type: "image", mediaType: "image/png", data: "abc" },
+				],
+			},
+			assistant("done with step 1"),
+			user(wrapped("now do step 2")),
+		]
+
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(2)
+		expect(findSdkUserMessageIndexByOrdinal(messages, 3)).toBe(4)
+	})
+
+	it("counts attachment-only user messages with no text", () => {
+		const messages = [
+			user("task"),
+			{
+				role: "user",
+				content: [{ type: "image", mediaType: "image/png", data: "abc" }],
+			},
+		]
+
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(1)
+	})
+
+	it("does not count tool results even when they carry media blocks", () => {
+		const messages = [
+			user("task"),
+			{
+				role: "user",
+				content: [
+					{ type: "tool_result", tool_use_id: "t1" },
+					{ type: "image", mediaType: "image/png", data: "screenshot" },
+				],
+			},
+			user("follow-up"),
+		]
+
+		expect(findSdkUserMessageIndexByOrdinal(messages, 2)).toBe(2)
+	})
+})
+
+describe("extractSdkUserText", () => {
+	it("extracts text from string and block content", () => {
+		expect(extractSdkUserText({ role: "user", content: "  hello  " })).toBe("hello")
+		expect(
+			extractSdkUserText({
+				role: "user",
+				content: [
+					{ type: "text", text: "first" },
+					{ type: "file", content: "second" },
+					{ type: "image", source: "ignored" },
+				],
+			}),
+		).toBe("first\nsecond")
+		expect(extractSdkUserText({ role: "user", content: 42 })).toBe("")
+	})
+})
diff --git a/apps/vscode/src/sdk/sdk-user-message-mapping.ts b/apps/vscode/src/sdk/sdk-user-message-mapping.ts
new file mode 100644
index 0000000..8675356
--- /dev/null
+++ b/apps/vscode/src/sdk/sdk-user-message-mapping.ts
@@ -0,0 +1,100 @@
+import { normalizeUserInput } from "@cline/shared"
+import { ACT_MODE_CONTINUATION_PROMPT } from "./sdk-mode-coordinator"
+
+export type SdkUserMessage = {
+	role?: unknown
+	content?: unknown
+}
+
+export function extractSdkUserText(message: SdkUserMessage): string {
+	const { content } = message
+	if (typeof content === "string") {
+		return content.trim()
+	}
+	if (!Array.isArray(content)) {
+		return ""
+	}
+	return content
+		.map((block) => {
+			if (!block || typeof block !== "object") {
+				return ""
+			}
+			const typed = block as { type?: unknown; text?: unknown; content?: unknown }
+			if (typed.type === "text" && typeof typed.text === "string") {
+				return typed.text.trim()
+			}
+			if (typed.type === "file" && typeof typed.content === "string") {
+				return typed.content.trim()
+			}
+			return ""
+		})
+		.filter(Boolean)
+		.join("\n")
+		.trim()
+}
+
+/**
+ * Prompts sent to the SDK without a visible user_feedback echo (task
+ * resumption, plan -> act auto-continue). They exist in SDK history but not
+ * in the visible transcript, so ordinal mapping between the two must skip
+ * them or every later user message maps one slot too early.
+ */
+export function isSyntheticUserPrompt(text: string): boolean {
+	// Persisted prompts are wrapped by formatModePrompt as
+	// <user_input mode="...">...</user_input>; strip that before matching.
+	const normalized = normalizeUserInput(text)
+	return normalized.startsWith("[TASK RESUMPTION]") || normalized === ACT_MODE_CONTINUATION_PROMPT
+}
+
+function hasAttachmentBlocks(message: SdkUserMessage): boolean {
+	if (!Array.isArray(message.content)) {
+		return false
+	}
+	let hasAttachment = false
+	for (const block of message.content) {
+		if (!block || typeof block !== "object") {
+			continue
+		}
+		const type = (block as { type?: unknown }).type
+		// Tool results are role "user" in SDK history but are not user input;
+		// any media they carry must not make the message count as one.
+		if (type === "tool_result" || type === "tool-result") {
+			return false
+		}
+		if (type === "image" || type === "file") {
+			hasAttachment = true
+		}
+	}
+	return hasAttachment
+}
+
+/**
+ * True when the SDK message has no visible user_feedback counterpart. An
+ * attachment-only continuation carries the synthetic text alongside the
+ * user's image/file blocks AND a visible bubble, so it must still be counted.
+ */
+export function isSyntheticSdkUserMessage(message: SdkUserMessage): boolean {
+	const text = extractSdkUserText(message)
+	return !!text && isSyntheticUserPrompt(text) && !hasAttachmentBlocks(message)
+}
+
+/**
+ * Maps the Nth visible user message (1-based ordinal over task/user_feedback
+ * rows) to its index in the persisted SDK message history, skipping synthetic
+ * prompts that have no visible counterpart.
+ */
+export function findSdkUserMessageIndexByOrdinal(sdkMessages: SdkUserMessage[], userOrdinal: number): number {
+	let seenUsers = 0
+	return sdkMessages.findIndex((message) => {
+		if (message.role !== "user") {
+			return false
+		}
+		const text = extractSdkUserText(message)
+		const hasUserContent = !!text || hasAttachmentBlocks(message)
+		if (!hasUserContent || isSyntheticSdkUserMessage(message)) {
+			return false
+		}
+		seenUsers += 1
+		return seenUsers === userOrdinal
+	})
+}
diff --git a/apps/vscode/src/sdk/session-host.ts b/apps/vscode/src/sdk/session-host.ts
new file mode 100644
index 0000000..d7099f2
--- /dev/null
+++ b/apps/vscode/src/sdk/session-host.ts
@@ -0,0 +1,55 @@
+import type {
+	ClineCoreListHistoryOptions,
+	ClineCoreStartInput,
+	CoreSessionEvent,
+	HookEventPayload,
+	PendingPromptMutationResult,
+	PendingPromptsDeleteInput,
+	PendingPromptsListInput,
+	PendingPromptsUpdateInput,
+	RestoreInput,
+	RestoreResult,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	SessionCompactionState,
+	SessionHistoryRecord,
+	SessionPendingPrompt,
+	SessionRecord,
+	StartSessionInput,
+	StartSessionResult,
+} from "@cline/core"
+import type { AgentResult } from "@cline/shared"
+
+export interface SdkSessionHost {
+	readonly runtimeAddress: string | undefined
+	start(input: StartSessionInput): Promise<StartSessionResult>
+	start(input: ClineCoreStartInput): Promise<StartSessionResult>
+	send(input: SendSessionInput): Promise<AgentResult | undefined>
+	getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>
+	abort(sessionId: string, reason?: unknown): Promise<void>
+	stop(sessionId: string): Promise<void>
+	dispose(reason?: string): Promise<void>
+	get(sessionId: string): Promise<SessionRecord | undefined>
+	list(limit?: number, options?: Omit<ClineCoreListHistoryOptions, "limit">): Promise<SessionHistoryRecord[]>
+	listHistory(options?: ClineCoreListHistoryOptions): Promise<SessionHistoryRecord[]>
+	delete(sessionId: string): Promise<boolean>
+	readMessages(sessionId: string): Promise<SdkInitialMessages>
+	updateSessionCompactionState?(sessionId: string, state: SessionCompactionState): Promise<{ updated: boolean }>
+	restore(input: RestoreInput): Promise<RestoreResult>
+	update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null
+			metadata?: Record<string, unknown> | null
+			title?: string | null
+		},
+	): Promise<{ updated: boolean }>
+	handleHookEvent(payload: HookEventPayload): Promise<void>
+	pendingPrompts(action: "list", input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>
+	pendingPrompts(action: "update", input: PendingPromptsUpdateInput): Promise<PendingPromptMutationResult>
+	pendingPrompts(action: "delete", input: PendingPromptsDeleteInput): Promise<PendingPromptMutationResult>
+	subscribe(listener: (event: CoreSessionEvent) => void): () => void
+	updateSessionModel?(sessionId: string, modelId: string): Promise<void>
+}
+
+export type SdkInitialMessages = NonNullable<StartSessionInput["initialMessages"]>
diff --git a/apps/vscode/src/sdk/state-post-debouncer.test.ts b/apps/vscode/src/sdk/state-post-debouncer.test.ts
new file mode 100644
index 0000000..2d4a1c1
--- /dev/null
+++ b/apps/vscode/src/sdk/state-post-debouncer.test.ts
@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { StatePostDebouncer } from "./state-post-debouncer"
+
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		error: vi.fn(),
+		log: vi.fn(),
+		warn: vi.fn(),
+	},
+}))
+
+describe("StatePostDebouncer", () => {
+	beforeEach(() => {
+		vi.useFakeTimers()
+	})
+
+	afterEach(() => {
+		vi.useRealTimers()
+	})
+
+	it("coalesces bursts of post() calls within the debounce window into a single flush", async () => {
+		const flush = vi.fn().mockResolvedValue(undefined)
+		const debouncer = new StatePostDebouncer({ debounceMs: 50, flush })
+
+		const p1 = debouncer.post()
+		const p2 = debouncer.post()
+		const p3 = debouncer.post()
+
+		await vi.advanceTimersByTimeAsync(50)
+		await Promise.all([p1, p2, p3])
+
+		expect(flush).toHaveBeenCalledTimes(1)
+	})
+
+	it("rejects all callers of the batch when flush() fails, instead of swallowing the error", async () => {
+		// Before this fix, runDebouncedStatePost() caught the flush error, logged
+		// it, and resolved every pending caller — so postStateToWebview() callers
+		// could never observe a failed rebuild. Callers must see the rejection.
+		const failure = new Error("boom")
+		const flush = vi.fn().mockRejectedValue(failure)
+		const debouncer = new StatePostDebouncer({ debounceMs: 50, flush })
+
+		const p1 = debouncer.post()
+		const p2 = debouncer.post()
+		// Attach rejection handlers to both promises before awaiting either, so
+		// neither is briefly "unhandled" while the other's assertion runs.
+		const settled = Promise.allSettled([p1, p2])
+
+		await vi.advanceTimersByTimeAsync(50)
+
+		const [result1, result2] = await settled
+		expect(result1).toEqual({ status: "rejected", reason: failure })
+		expect(result2).toEqual({ status: "rejected", reason: failure })
+	})
+
+	it("does not let a request that joins an in-flight flush overwrite the tracked in-flight promise", async () => {
+		// Regression test for the P1 dispose race: a second debounced timer that
+		// fires while a flush is already running must fold into the running flush
+		// via `queued` rather than replacing the internal in-flight promise with
+		// a throwaway resolved one. Otherwise dispose() could await the wrong
+		// (already-resolved) promise and tear down resources while the original,
+		// still-running flush is mid-execution.
+		let resolveFirstFlush: (() => void) | undefined
+		const firstFlushGate = new Promise<void>((resolve) => {
+			resolveFirstFlush = resolve
+		})
+		let flushCallCount = 0
+		const flush = vi.fn(async () => {
+			flushCallCount += 1
+			if (flushCallCount === 1) {
+				await firstFlushGate
+			}
+		})
+		const debouncer = new StatePostDebouncer({ debounceMs: 50, flush })
+
+		// First post() starts the debounce timer; once it fires, flush() #1 begins
+		// and blocks on firstFlushGate.
+		const p1 = debouncer.post()
+		await vi.advanceTimersByTimeAsync(50)
+		expect(flush).toHaveBeenCalledTimes(1)
+
+		// A second post() arrives while flush #1 is still in flight. Its debounce
+		// timer fires while `inFlight` is still true, so runDebounced() must fold
+		// it into the running loop (via `queued`) rather than starting a second,
+		// independently-tracked flush.
+		const p2 = debouncer.post()
+		await vi.advanceTimersByTimeAsync(50)
+
+		// dispose() races the still-running flush #1. If the internal in-flight
+		// promise had been overwritten by the second (queued, no-op) call, this
+		// would resolve well before flush #1 finishes.
+		let disposeResolved = false
+		const disposePromise = debouncer.dispose().then(() => {
+			disposeResolved = true
+		})
+
+		// Drain many microtask ticks (generously more than the couple of hops
+		// needed to unwrap an already-settled promise chain) without resolving
+		// firstFlushGate. dispose() must still be pending — it can only resolve
+		// once the real, still-running flush #1 finishes.
+		for (let i = 0; i < 50; i++) {
+			await Promise.resolve()
+		}
+		expect(disposeResolved).toBe(false)
+
+		resolveFirstFlush?.()
+		await disposePromise
+		expect(disposeResolved).toBe(true)
+
+		// The queued second flush runs once flush #1 completes and dispose() has
+		// not yet forced an early loop exit.
+		await p1
+		await p2.catch(() => {})
+	})
+
+	it("post() resolves immediately without shipping state after dispose", async () => {
+		const flush = vi.fn().mockResolvedValue(undefined)
+		const debouncer = new StatePostDebouncer({ debounceMs: 50, flush })
+
+		await debouncer.dispose()
+		await debouncer.post()
+
+		expect(flush).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/src/sdk/state-post-debouncer.ts b/apps/vscode/src/sdk/state-post-debouncer.ts
new file mode 100644
index 0000000..4b9a3f1
--- /dev/null
+++ b/apps/vscode/src/sdk/state-post-debouncer.ts
@@ -0,0 +1,123 @@
+// Coalesces frequent postStateToWebview() requests into a single trailing
+// rebuild. During a streaming turn the session event coordinator can fire
+// postStateToWebview() many times per second; each call rebuilds the full
+// ExtensionState (including task history), which is expensive enough to
+// saturate the extension host event loop if run on every event. This class
+// owns the debounce timer, in-flight/queued bookkeeping, and the resolver
+// list, extracted from SdkController so the concurrency behavior can be unit
+// tested in isolation.
+import { Logger } from "@/shared/services/Logger"
+
+export interface StatePostDebouncerOptions {
+	/** Trailing debounce window: bursts of post() calls within this window collapse into one flush. */
+	debounceMs: number
+	/** Builds and ships the current state snapshot. Rejections propagate to post() callers. */
+	flush: () => Promise<void>
+}
+
+/**
+ * Debounce/coalesce state posts.
+ *
+ * `post()` resolves once a snapshot reflecting that call has been shipped (or
+ * rejects if the flush that shipped it failed — errors are not swallowed, so
+ * callers awaiting `post()` can tell a state update did not reach the
+ * webview). Requests arriving while a flush is in flight are folded into
+ * `queued`; exactly one more flush runs afterward so the final snapshot is
+ * never stale.
+ */
+export class StatePostDebouncer {
+	private debounceTimer?: NodeJS.Timeout
+	private inFlight = false
+	private inFlightPromise?: Promise<void>
+	private queued = false
+	private pendingResolvers: Array<{ resolve: () => void; reject: (error: unknown) => void }> = []
+	private disposed = false
+
+	constructor(private readonly options: StatePostDebouncerOptions) {}
+
+	post(): Promise<void> {
+		if (this.disposed) {
+			return Promise.resolve()
+		}
+		return new Promise<void>((resolve, reject) => {
+			this.pendingResolvers.push({ resolve, reject })
+			if (this.debounceTimer) {
+				return
+			}
+			this.debounceTimer = setTimeout(() => {
+				this.debounceTimer = undefined
+				// If a flush loop is already running, runDebounced() just folds this
+				// request into it (via `queued`) and returns a throwaway resolved
+				// promise without doing any work. Only track the promise from the
+				// call that actually starts the flush loop — otherwise that trivial
+				// promise would overwrite the reference to the real, still-running
+				// flush, and dispose() could await the wrong one and return while
+				// the original flush is still executing.
+				const isStartingNewFlush = !this.inFlight
+				const runPromise = this.runDebounced()
+				if (isStartingNewFlush) {
+					this.inFlightPromise = runPromise
+				}
+			}, this.options.debounceMs)
+			this.debounceTimer.unref?.()
+		})
+	}
+
+	private async runDebounced(): Promise<void> {
+		if (this.inFlight) {
+			this.queued = true
+			return
+		}
+		this.inFlight = true
+		try {
+			do {
+				this.queued = false
+				const resolvers = this.pendingResolvers
+				this.pendingResolvers = []
+				try {
+					await this.options.flush()
+					for (const { resolve } of resolvers) {
+						resolve()
+					}
+				} catch (error) {
+					// Preserve rejection semantics: callers awaiting post() must see
+					// the failure, not a silent success, so command handlers don't
+					// assume the webview received a fresh snapshot when it didn't.
+					Logger.error("[StatePostDebouncer] Failed to post state to webview:", error)
+					for (const { reject } of resolvers) {
+						reject(error)
+					}
+				}
+			} while (this.queued && !this.disposed)
+		} finally {
+			this.inFlight = false
+			this.inFlightPromise = undefined
+		}
+	}
+
+	/**
+	 * Tear down the debounce machinery: cancel any pending timer and settle
+	 * in-flight awaiters so callers blocked on `post()` don't hang past
+	 * disposal. Awaits any flush that's still executing so it either completes
+	 * or bails via the `disposed` guard before the caller tears down downstream
+	 * resources.
+	 */
+	async dispose(): Promise<void> {
+		this.disposed = true
+		if (this.debounceTimer) {
+			clearTimeout(this.debounceTimer)
+			this.debounceTimer = undefined
+		}
+		this.queued = false
+		const pendingResolvers = this.pendingResolvers
+		this.pendingResolvers = []
+		for (const { resolve } of pendingResolvers) {
+			resolve()
+		}
+		const inFlight = this.inFlightPromise
+		if (inFlight) {
+			await inFlight.catch(() => {})
+			this.inFlightPromise = undefined
+		}
+	}
+}
diff --git a/apps/vscode/src/sdk/task-proxy.test.ts b/apps/vscode/src/sdk/task-proxy.test.ts
new file mode 100644
index 0000000..38fdb5f
--- /dev/null
+++ b/apps/vscode/src/sdk/task-proxy.test.ts
@@ -0,0 +1,154 @@
+import { describe, expect, it, vi } from "vitest"
+import { createTaskProxy, MessageStateHandler } from "./task-proxy"
+
+describe("MessageStateHandler", () => {
+	it("should start with empty messages", () => {
+		const handler = new MessageStateHandler()
+		expect(handler.getClineMessages()).toEqual([])
+	})
+
+	it("should add and retrieve messages", () => {
+		const handler = new MessageStateHandler()
+		const messages = [
+			{ ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false },
+			{ ts: 2, type: "say" as const, say: "tool" as const, text: "tool call", partial: false },
+		]
+		handler.addMessages(messages)
+		expect(handler.getClineMessages()).toHaveLength(2)
+		expect(handler.getClineMessages()[0].text).toBe("hello")
+		expect(handler.getClineMessages()[1].text).toBe("tool call")
+	})
+
+	it("should return a copy of messages", () => {
+		const handler = new MessageStateHandler()
+		handler.addMessages([{ ts: 1, type: "say", say: "text", text: "hello", partial: false }])
+		const copy = handler.getClineMessages()
+		copy.push({ ts: 2, type: "say", say: "text", text: "extra", partial: false })
+		expect(handler.getClineMessages()).toHaveLength(1)
+	})
+
+	it("should clear messages", () => {
+		const handler = new MessageStateHandler()
+		handler.addMessages([{ ts: 1, type: "say", say: "text", text: "hello", partial: false }])
+		handler.clear()
+		expect(handler.getClineMessages()).toEqual([])
+	})
+
+	it("should accumulate messages across multiple addMessages calls", () => {
+		const handler = new MessageStateHandler()
+		handler.addMessages([{ ts: 1, type: "say", say: "text", text: "first", partial: false }])
+		handler.addMessages([{ ts: 2, type: "say", say: "text", text: "second", partial: false }])
+		expect(handler.getClineMessages()).toHaveLength(2)
+	})
+})
+
+describe("createTaskProxy", () => {
+	it("should expose sessionId as ulid and taskId", () => {
+		const onAskResponse = vi.fn()
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		expect(proxy.ulid).toBe("session-123")
+		expect(proxy.taskId).toBe("session-123")
+	})
+
+	it("should delegate messageResponse to onAskResponse", async () => {
+		const onAskResponse = vi.fn().mockResolvedValue(undefined)
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		await proxy.handleWebviewAskResponse("messageResponse", "hello", ["img1"], ["file1"])
+
+		expect(onAskResponse).toHaveBeenCalledWith("hello", ["img1"], ["file1"])
+	})
+
+	it("should delegate yesButtonClicked to onAskResponse", async () => {
+		const onAskResponse = vi.fn().mockResolvedValue(undefined)
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		await proxy.handleWebviewAskResponse("yesButtonClicked", "", [], [])
+
+		expect(onAskResponse).toHaveBeenCalledWith("", [], [])
+	})
+
+	it("should delegate noButtonClicked to onAskResponse", async () => {
+		const onAskResponse = vi.fn().mockResolvedValue(undefined)
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		await proxy.handleWebviewAskResponse("noButtonClicked", "", [], [])
+
+		expect(onAskResponse).toHaveBeenCalledWith("", [], [])
+	})
+
+	it("should delegate unknown askResponse types to onAskResponse", async () => {
+		const onAskResponse = vi.fn().mockResolvedValue(undefined)
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		// biome-ignore lint/suspicious/noExplicitAny: testing unknown ask response type
+		await proxy.handleWebviewAskResponse("command" as any, "ls -la", [], [])
+
+		expect(onAskResponse).toHaveBeenCalledWith("ls -la", [], [])
+	})
+
+	it("should store askResponse in taskState", async () => {
+		const onAskResponse = vi.fn().mockResolvedValue(undefined)
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		await proxy.handleWebviewAskResponse("messageResponse", "hello")
+
+		expect(proxy.taskState.askResponse).toBe("messageResponse")
+	})
+
+	it("should delegate abortTask to onCancelTask", async () => {
+		const onAskResponse = vi.fn()
+		const onCancelTask = vi.fn().mockResolvedValue(undefined)
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		await proxy.abortTask()
+
+		expect(onCancelTask).toHaveBeenCalled()
+	})
+
+	it("should provide a stub API handler", () => {
+		const onAskResponse = vi.fn()
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		expect(proxy.api.getModel().id).toBe("unknown")
+	})
+
+	it("should expose stubs for terminal manager", () => {
+		const onAskResponse = vi.fn()
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		expect(proxy.browserSession).toBeUndefined()
+		// terminalManager is a stub object with no-op settings methods
+		expect(proxy.terminalManager).toBeDefined()
+		expect(typeof proxy.terminalManager.setDefaultTerminalProfile).toBe("function")
+		expect(typeof proxy.terminalManager.setShellIntegrationTimeout).toBe("function")
+	})
+
+	it("should provide a messageStateHandler", () => {
+		const onAskResponse = vi.fn()
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		expect(proxy.messageStateHandler).toBeInstanceOf(MessageStateHandler)
+		expect(proxy.messageStateHandler.getClineMessages()).toEqual([])
+	})
+
+	it("should accumulate messages in messageStateHandler", () => {
+		const onAskResponse = vi.fn()
+		const onCancelTask = vi.fn()
+		const proxy = createTaskProxy("session-123", onAskResponse, onCancelTask)
+
+		proxy.messageStateHandler.addMessages([{ ts: 1, type: "say", say: "text", text: "hello", partial: false }])
+
+		expect(proxy.messageStateHandler.getClineMessages()).toHaveLength(1)
+	})
+})
diff --git a/apps/vscode/src/sdk/task-proxy.ts b/apps/vscode/src/sdk/task-proxy.ts
new file mode 100644
index 0000000..0e1ad23
--- /dev/null
+++ b/apps/vscode/src/sdk/task-proxy.ts
@@ -0,0 +1,264 @@
+// Replaces classic src/core/task/index.ts task object (see origin/main)
+//
+// When handlers call controller.task.handleWebviewAskResponse(), controller.task.ulid,
+// controller.task.abortTask(), etc., this proxy delegates to the SdkController's
+// session methods. This allows existing gRPC handlers to work without modification.
+//
+// Not all classic Task methods are implemented here — only those called by
+// the gRPC handler modules in src/core/controller/. Missing methods log a warning
+// and return safe defaults.
+
+import { EventEmitter } from "node:events"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { Logger } from "@shared/services/Logger"
+import type { ClineAskResponse } from "@shared/WebviewMessage"
+
+/**
+ * Interface for the task proxy — mirrors the subset of classic Task
+ * properties and methods that gRPC handlers actually call.
+ */
+export interface TaskProxy {
+	/** Session ID (maps to classic task's ulid/taskId) */
+	ulid: string
+	taskId: string
+	/** Delegate ask response to the controller's session */
+	handleWebviewAskResponse: (askResponse: ClineAskResponse, text?: string, images?: string[], files?: string[]) => Promise<void>
+	/** Abort the running task */
+	abortTask: () => Promise<void>
+	/** API handler — settable for model switching via updateSettings */
+	api: TaskProxyApi
+	/** Browser session — stubbed (browser automation removed in this migration) */
+	// biome-ignore lint/suspicious/noExplicitAny: typed as any for handler compatibility; browser automation removed
+	browserSession: any
+	/** Terminal manager — stub that safely no-ops for settings compatibility */
+	terminalManager: TaskProxyTerminalManager
+	/** Task state for tracking */
+	taskState: TaskProxyState
+	/** Message state handler — accumulates messages for state building */
+	messageStateHandler: MessageStateHandler
+}
+
+/**
+ * Event map for MessageStateHandler.
+ * Mirrors the classic MessageStateHandlerEvents from src/core/task/message-state.ts.
+ * Uses tuple syntax for EventEmitter compatibility.
+ */
+export interface MessageStateHandlerEvents {
+	clineMessagesChanged: [change: ClineMessageChange]
+}
+
+/**
+ * Change event for message updates.
+ * Mirrors ClineMessageChange from src/core/task/message-state.ts.
+ */
+interface ClineMessageChange {
+	type: "add" | "update" | "set" | "delete"
+	/** The full array after the change */
+	messages: ClineMessage[]
+	/** The affected index (for add/update/delete) */
+	index?: number
+	/** The new/updated message (for add/update) */
+	message?: ClineMessage
+}
+
+/**
+ * Message state handler that accumulates ClineMessages and emits change events.
+ * Extends EventEmitter for compatibility with consumers that use the
+ * on/off event subscription pattern.
+ *
+ * The classic Task had a full MessageStateHandler; this provides the
+ * getClineMessages() and event emitter interface that consumers expect.
+ */
+export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents> {
+	private messages: ClineMessage[] = []
+
+	/** Add or update messages from a session event.
+	 *  If a message with the same `ts` already exists, update it in-place
+	 *  (this handles partial→final streaming updates). Otherwise append.
+	 *  This prevents duplicate messages when both partial message stream
+	 *  and state updates carry the same content.
+	 */
+	addMessages(messages: ClineMessage[]): void {
+		for (const message of messages) {
+			const existingIndex = this.messages.findIndex((m) => m.ts === message.ts)
+			if (existingIndex !== -1) {
+				// Update existing message in-place (e.g., partial=true → partial=false)
+				this.messages[existingIndex] = message
+				this.emit("clineMessagesChanged", {
+					type: "update",
+					messages: this.messages,
+					index: existingIndex,
+					message,
+				})
+			} else {
+				this.messages.push(message)
+				this.emit("clineMessagesChanged", { type: "add", messages: this.messages, message })
+			}
+		}
+	}
+
+	/** Get all accumulated messages (returns a copy) */
+	getClineMessages(): ClineMessage[] {
+		return [...this.messages]
+	}
+
+	/** Clear all messages (e.g., on task clear) */
+	clear(): void {
+		this.messages = []
+	}
+
+	/** Replace the full message list, preserving the classic set-change event. */
+	replaceMessages(messages: ClineMessage[]): void {
+		this.messages = [...messages]
+		this.emit("clineMessagesChanged", { type: "set", messages: this.messages })
+	}
+}
+
+/**
+ * Minimal API handler interface for model info access.
+ * The classic Task had a full API handler; we expose just what handlers need.
+ * The `api` property is settable — updateSettings() replaces it when the
+ * user switches models/providers.
+ */
+interface TaskProxyApi {
+	getModel: () => { id: string }
+}
+
+/**
+ * Terminal manager stub for settings compatibility.
+ * The updateSettings handler calls setDefaultTerminalProfile() which
+ * returns { closedCount, busyTerminals }. This stub safely no-ops.
+ */
+interface TaskProxyTerminalManager {
+	setDefaultTerminalProfile: (profileId: string) => { closedCount: number; busyTerminals: never[] }
+	setShellIntegrationTimeout: (timeout: number) => void
+	setTerminalReuseEnabled: (enabled: boolean) => void
+}
+
+/**
+ * Task state tracking — mirrors the subset of classic TaskState
+ * that handlers reference.
+ */
+interface TaskProxyState {
+	askResponse?: ClineAskResponse
+	autoRetryAttempts?: number
+	/** Focus chain checklist (stub — focus chain removed) */
+	currentFocusChainChecklist?: null
+	/** Abort flag for task cancellation (classic TaskState used boolean) */
+	abort?: boolean
+}
+
+/**
+ * Callback type for delegating ask responses to the controller.
+ */
+export type AskResponseCallback = (text?: string, images?: string[], files?: string[]) => Promise<void>
+
+/**
+ * Callback type for delegating task cancellation to the controller.
+ */
+export type CancelTaskCallback = () => Promise<void>
+
+/**
+ * Create a task proxy that delegates to the SdkController.
+ *
+ * @param sessionId The SDK session ID
+ * @param onAskResponse Callback to send a response to the active session
+ * @param onCancelTask Callback to cancel the active session
+ * @returns A TaskProxy object
+ */
+export function createTaskProxy(
+	sessionId: string,
+	onAskResponse: AskResponseCallback,
+	onCancelTask: CancelTaskCallback,
+): TaskProxy {
+	const state: TaskProxyState = {}
+	const messageStateHandler = new MessageStateHandler()
+
+	// Mutable session ID — updated when the session is restarted (e.g., MCP tool reload)
+	let currentSessionId = sessionId
+
+	// Mutable API handler — updateSettings() replaces it when switching models
+	let currentApi: TaskProxyApi = {
+		getModel: () => ({ id: "unknown" }),
+	}
+
+	// Terminal manager stub — safely no-ops for settings compatibility
+	const terminalManagerStub: TaskProxyTerminalManager = {
+		setDefaultTerminalProfile: () => ({ closedCount: 0, busyTerminals: [] }),
+		setShellIntegrationTimeout: () => {},
+		setTerminalReuseEnabled: () => {},
+	}
+
+	const proxy: TaskProxy = {
+		get ulid(): string {
+			return currentSessionId
+		},
+
+		get taskId(): string {
+			return currentSessionId
+		},
+		set taskId(newId: string) {
+			currentSessionId = newId
+		},
+
+		async handleWebviewAskResponse(
+			askResponse: ClineAskResponse,
+			text?: string,
+			images?: string[],
+			files?: string[],
+		): Promise<void> {
+			// Store the response type in task state (some handlers check this)
+			state.askResponse = askResponse
+
+			switch (askResponse) {
+				case "yesButtonClicked":
+				case "noButtonClicked":
+					// For approval responses, we just send an empty continuation
+					// The SDK handles approval differently than the classic Task
+					await onAskResponse(text, images, files)
+					break
+
+				case "messageResponse":
+					// User sent a follow-up message
+					await onAskResponse(text, images, files)
+					break
+
+				default:
+					Logger.warn(`[TaskProxy] Unhandled askResponse type: ${askResponse}`)
+					await onAskResponse(text, images, files)
+					break
+			}
+		},
+
+		async abortTask(): Promise<void> {
+			await onCancelTask()
+		},
+
+		get api(): TaskProxyApi {
+			return currentApi
+		},
+		set api(handler: TaskProxyApi) {
+			// updateSettings() replaces the API handler when switching models/providers
+			currentApi = handler
+		},
+
+		get browserSession() {
+			// Browser automation is not part of the SDK adapter.
+			return undefined
+		},
+
+		get terminalManager(): TaskProxyTerminalManager {
+			return terminalManagerStub
+		},
+
+		get taskState(): TaskProxyState {
+			return state
+		},
+
+		get messageStateHandler(): MessageStateHandler {
+			return messageStateHandler
+		},
+	}
+
+	return proxy
+}
diff --git a/apps/vscode/src/sdk/telemetry-settings-sync.test.ts b/apps/vscode/src/sdk/telemetry-settings-sync.test.ts
new file mode 100644
index 0000000..1ad578e
--- /dev/null
+++ b/apps/vscode/src/sdk/telemetry-settings-sync.test.ts
@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, join } from "node:path"
+import type { TelemetrySetting } from "@shared/TelemetrySetting"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { syncTelemetrySettingFromSharedGlobalSettings } from "./telemetry-settings-sync"
+
+const state = vi.hoisted(() => ({
+	telemetrySetting: undefined as TelemetrySetting | boolean | undefined,
+	remoteTelemetrySetting: undefined as TelemetrySetting | undefined,
+	setGlobalState: vi.fn(),
+}))
+
+vi.mock("@cline/core", () => ({
+	readGlobalSettings: () => {
+		const filePath = process.env.CLINE_GLOBAL_SETTINGS_PATH
+		if (!filePath || !existsSync(filePath)) {
+			return { autoUpdateEnabled: true, telemetryOptOut: false }
+		}
+		return { autoUpdateEnabled: true, telemetryOptOut: false, ...JSON.parse(readFileSync(filePath, "utf8")) }
+	},
+	setTelemetryOptOutGlobally: (telemetryOptOut: boolean) => {
+		const filePath = process.env.CLINE_GLOBAL_SETTINGS_PATH
+		if (!filePath) {
+			throw new Error("CLINE_GLOBAL_SETTINGS_PATH is not set")
+		}
+		mkdirSync(dirname(filePath), { recursive: true })
+		writeFileSync(filePath, `${JSON.stringify({ autoUpdateEnabled: true, telemetryOptOut }, null, 2)}\n`)
+	},
+}))
+
+function makeStateManager() {
+	return {
+		getGlobalSettingsKey: vi.fn(() => state.telemetrySetting),
+		getRemoteConfigSettings: vi.fn(() => ({ telemetrySetting: state.remoteTelemetrySetting })),
+		setGlobalState: state.setGlobalState,
+	}
+}
+
+describe("syncTelemetrySettingFromSharedGlobalSettings", () => {
+	let previousSettingsPath: string | undefined
+	let tempDir: string
+	let settingsPath: string
+
+	beforeEach(() => {
+		previousSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH
+		tempDir = mkdtempSync(join(tmpdir(), "cline-vscode-telemetry-sync-"))
+		settingsPath = join(tempDir, "global-settings.json")
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath
+		state.telemetrySetting = undefined
+		state.remoteTelemetrySetting = undefined
+		state.setGlobalState.mockReset()
+	})
+
+	afterEach(() => {
+		if (previousSettingsPath === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = previousSettingsPath
+		}
+		rmSync(tempDir, { force: true, recursive: true })
+	})
+
+	it("migrates legacy boolean false to shared telemetry opt-out", () => {
+		state.telemetrySetting = false
+
+		syncTelemetrySettingFromSharedGlobalSettings(makeStateManager())
+
+		expect(state.setGlobalState).toHaveBeenCalledWith("telemetrySetting", "disabled")
+		expect(JSON.parse(readFileSync(settingsPath, "utf8"))).toMatchObject({ telemetryOptOut: true })
+	})
+
+	it("migrates legacy string disabled to shared telemetry opt-out", () => {
+		state.telemetrySetting = "disabled"
+
+		syncTelemetrySettingFromSharedGlobalSettings(makeStateManager())
+
+		expect(JSON.parse(readFileSync(settingsPath, "utf8"))).toMatchObject({ telemetryOptOut: true })
+	})
+})
diff --git a/apps/vscode/src/sdk/telemetry-settings-sync.ts b/apps/vscode/src/sdk/telemetry-settings-sync.ts
new file mode 100644
index 0000000..cd188db
--- /dev/null
+++ b/apps/vscode/src/sdk/telemetry-settings-sync.ts
@@ -0,0 +1,55 @@
+import { existsSync } from "node:fs"
+import { readGlobalSettings, setTelemetryOptOutGlobally } from "@cline/core"
+import { resolveGlobalSettingsPath } from "@cline/shared/storage"
+import type { TelemetrySetting } from "@shared/TelemetrySetting"
+import { Logger } from "@/shared/services/Logger"
+
+interface TelemetryStateManager {
+	getGlobalSettingsKey(key: "telemetrySetting"): TelemetrySetting | boolean | undefined
+	getRemoteConfigSettings(): { telemetrySetting?: TelemetrySetting }
+	setGlobalState(key: "telemetrySetting", value: TelemetrySetting): void
+}
+
+export function telemetrySettingFromSharedGlobalSettings(): TelemetrySetting {
+	return readGlobalSettings().telemetryOptOut ? "disabled" : "enabled"
+}
+
+function normalizeLegacyTelemetrySetting(value: TelemetrySetting | boolean | undefined): TelemetrySetting | undefined {
+	if (value === false) {
+		return "disabled"
+	}
+	if (value === true) {
+		return "enabled"
+	}
+	if (value === "disabled" || value === "enabled" || value === "unset") {
+		return value
+	}
+	return undefined
+}
+
+export function syncTelemetrySettingFromSharedGlobalSettings(stateManager: TelemetryStateManager): void {
+	try {
+		const sharedSettingsPath = resolveGlobalSettingsPath()
+		if (!existsSync(sharedSettingsPath)) {
+			const legacyTelemetrySetting = normalizeLegacyTelemetrySetting(stateManager.getGlobalSettingsKey("telemetrySetting"))
+			if (legacyTelemetrySetting !== undefined) {
+				// One-time migration from the legacy VS Code globalState.json field into
+				// the CLI/shared global settings file. Older builds stored this as a
+				// boolean where false meant telemetry was disabled.
+				// Do not emit opt-out telemetry for migration; this is not a new explicit
+				// user action.
+				setTelemetryOptOutGlobally(legacyTelemetrySetting === "disabled")
+			}
+		}
+
+		const telemetrySetting = telemetrySettingFromSharedGlobalSettings()
+		const remoteTelemetrySetting = stateManager.getRemoteConfigSettings().telemetrySetting
+		if (remoteTelemetrySetting === undefined && stateManager.getGlobalSettingsKey("telemetrySetting") !== telemetrySetting) {
+			// Keep the legacy in-memory state mirrored so existing VS Code telemetry
+			// providers that still read StateManager observe the shared setting.
+			stateManager.setGlobalState("telemetrySetting", telemetrySetting)
+		}
+	} catch (error) {
+		Logger.warn(`[SdkController] Failed to sync shared telemetry setting: ${error}`)
+	}
+}
diff --git a/apps/vscode/src/sdk/toggle-plan-act-mode.test.ts b/apps/vscode/src/sdk/toggle-plan-act-mode.test.ts
new file mode 100644
index 0000000..d7a60a1
--- /dev/null
+++ b/apps/vscode/src/sdk/toggle-plan-act-mode.test.ts
@@ -0,0 +1,111 @@
+// Integration-style tests for the plan/act mode toggle flow.
+//
+// These tests verify the Controller → gRPC handler boundary for mode toggling:
+// 1. togglePlanActModeProto correctly decodes the PlanActMode enum to "plan"/"act"
+// 2. The boolean return value semantics match the classic extension:
+//    - `false` when no chatContent was consumed (webview preserves input)
+//    - `false` when mode is unchanged (no-op)
+// 3. The delegated controller.togglePlanActMode() is called with the decoded mode.
+
+import { PlanActMode, TogglePlanActModeRequest } from "@shared/proto/cline/state"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+// Silence the Logger output during tests
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		log: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		debug: vi.fn(),
+	},
+}))
+
+// We don't need the full Controller — just a mock that implements togglePlanActMode.
+import { togglePlanActModeProto } from "../core/controller/state/togglePlanActModeProto"
+
+// biome-ignore lint/suspicious/noExplicitAny: minimal mock for the controller surface we exercise
+type MockController = any
+
+describe("togglePlanActModeProto", () => {
+	let mockController: MockController
+	let toggleSpy: ReturnType<typeof vi.fn>
+
+	beforeEach(() => {
+		toggleSpy = vi.fn()
+		mockController = {
+			togglePlanActMode: toggleSpy,
+		}
+	})
+
+	it("decodes PLAN mode and passes it to the controller", async () => {
+		toggleSpy.mockResolvedValue(false)
+		const request = TogglePlanActModeRequest.create({ mode: PlanActMode.PLAN })
+
+		await togglePlanActModeProto(mockController, request)
+
+		expect(toggleSpy).toHaveBeenCalledWith("plan", undefined)
+	})
+
+	it("decodes ACT mode and passes it to the controller", async () => {
+		toggleSpy.mockResolvedValue(false)
+		const request = TogglePlanActModeRequest.create({ mode: PlanActMode.ACT })
+
+		await togglePlanActModeProto(mockController, request)
+
+		expect(toggleSpy).toHaveBeenCalledWith("act", undefined)
+	})
+
+	it("passes chatContent through to the controller", async () => {
+		toggleSpy.mockResolvedValue(false)
+		const request = TogglePlanActModeRequest.create({
+			mode: PlanActMode.ACT,
+			chatContent: { message: "hello", images: ["img.png"], files: ["a.txt"] },
+		})
+
+		await togglePlanActModeProto(mockController, request)
+
+		expect(toggleSpy).toHaveBeenCalledTimes(1)
+		const [mode, chatContent] = toggleSpy.mock.calls[0]
+		expect(mode).toBe("act")
+		expect(chatContent).toMatchObject({
+			message: "hello",
+			images: ["img.png"],
+			files: ["a.txt"],
+		})
+	})
+
+	it("returns a Boolean proto reflecting controller.togglePlanActMode's return value (false)", async () => {
+		toggleSpy.mockResolvedValue(false)
+		const request = TogglePlanActModeRequest.create({ mode: PlanActMode.PLAN })
+
+		const response = await togglePlanActModeProto(mockController, request)
+
+		expect(response.value).toBe(false)
+	})
+
+	it("returns a Boolean proto reflecting controller.togglePlanActMode's return value (true)", async () => {
+		// Some SDK flows may return true if they consumed chat content as a message.
+		// The proto handler must pass that through verbatim to the webview.
+		toggleSpy.mockResolvedValue(true)
+		const request = TogglePlanActModeRequest.create({ mode: PlanActMode.PLAN })
+
+		const response = await togglePlanActModeProto(mockController, request)
+
+		expect(response.value).toBe(true)
+	})
+
+	it("throws on invalid mode values", async () => {
+		// Create a request with an unknown enum value (simulating a future proto variant).
+		const request = TogglePlanActModeRequest.create({ mode: 999 as PlanActMode })
+
+		await expect(togglePlanActModeProto(mockController, request)).rejects.toThrow("Invalid mode value")
+		expect(toggleSpy).not.toHaveBeenCalled()
+	})
+
+	it("propagates errors from controller.togglePlanActMode", async () => {
+		toggleSpy.mockRejectedValue(new Error("oops"))
+		const request = TogglePlanActModeRequest.create({ mode: PlanActMode.ACT })
+
+		await expect(togglePlanActModeProto(mockController, request)).rejects.toThrow("oops")
+	})
+})
diff --git a/apps/vscode/src/sdk/tool-approval-denial.ts b/apps/vscode/src/sdk/tool-approval-denial.ts
new file mode 100644
index 0000000..9420769
--- /dev/null
+++ b/apps/vscode/src/sdk/tool-approval-denial.ts
@@ -0,0 +1,50 @@
+export const DEFAULT_TOOL_APPROVAL_DENIAL_REASON = "User denied the tool execution"
+export const USER_MESSAGE_TOOL_APPROVAL_DENIAL_REASON = "Tool execution was cancelled because the user sent a follow-up message."
+
+function getMessage(value: unknown): string | undefined {
+	if (typeof value === "string") {
+		return value
+	}
+
+	if (value instanceof Error) {
+		return value.message
+	}
+
+	if (value && typeof value === "object" && "message" in value) {
+		const message = (value as { message?: unknown }).message
+		return typeof message === "string" ? message : undefined
+	}
+
+	return undefined
+}
+
+export function isKnownToolApprovalDenial(value: unknown): boolean {
+	const message = getMessage(value)
+	if (!message) {
+		return false
+	}
+
+	return message.includes(USER_MESSAGE_TOOL_APPROVAL_DENIAL_REASON) || message.includes(DEFAULT_TOOL_APPROVAL_DENIAL_REASON)
+}
+
+export function isDeniedToolApprovalMistake(
+	value: unknown,
+	deniedApprovals: Iterable<{ toolName: string; reason: string }>,
+): boolean {
+	const message = getMessage(value)
+	if (!message) {
+		return false
+	}
+
+	if (isKnownToolApprovalDenial(message)) {
+		return true
+	}
+
+	for (const { toolName, reason } of deniedApprovals) {
+		if (message.includes(`[${toolName}]`) && message.includes(reason)) {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/apps/vscode/src/sdk/turn-state-tracker.test.ts b/apps/vscode/src/sdk/turn-state-tracker.test.ts
new file mode 100644
index 0000000..1dfe8c5
--- /dev/null
+++ b/apps/vscode/src/sdk/turn-state-tracker.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest"
+import { MessageIdMinter } from "./message-id-minter"
+import { TurnStateTracker } from "./turn-state-tracker"
+
+describe("TurnStateTracker", () => {
+	it("starts idle", () => {
+		const tracker = new TurnStateTracker(new MessageIdMinter())
+		expect(tracker.get().phase).toBe("idle")
+		expect(tracker.currentPhase).toBe("idle")
+	})
+
+	it("advances seq on every transition so the webview keeps the newest", () => {
+		const tracker = new TurnStateTracker(new MessageIdMinter())
+		const s0 = tracker.get().seq
+		tracker.set("streaming")
+		const s1 = tracker.get().seq
+		tracker.set("completed")
+		const s2 = tracker.get().seq
+		expect(s1).toBeGreaterThan(s0)
+		expect(s2).toBeGreaterThan(s1)
+	})
+
+	it("records the phase and anchor ts", () => {
+		const tracker = new TurnStateTracker(new MessageIdMinter())
+		tracker.set("awaiting_approval", 42)
+		expect(tracker.get()).toMatchObject({ phase: "awaiting_approval", anchorTs: 42 })
+		tracker.set("streaming")
+		// anchor cleared when not provided
+		expect(tracker.get().anchorTs).toBeUndefined()
+		expect(tracker.get().phase).toBe("streaming")
+	})
+
+	it("shares the minter's seq space (seq is globally monotonic)", () => {
+		const minter = new MessageIdMinter()
+		const tracker = new TurnStateTracker(minter)
+		const a = tracker.get().seq
+		// An unrelated message mint advances the shared seq counter.
+		minter.nextSeq()
+		tracker.set("completed")
+		expect(tracker.get().seq).toBeGreaterThan(a)
+	})
+})
diff --git a/apps/vscode/src/sdk/turn-state-tracker.ts b/apps/vscode/src/sdk/turn-state-tracker.ts
new file mode 100644
index 0000000..f4304af
--- /dev/null
+++ b/apps/vscode/src/sdk/turn-state-tracker.ts
@@ -0,0 +1,39 @@
+import type { TurnPhase, TurnState } from "@shared/ExtensionMessage"
+import type { MessageIdMinter } from "./message-id-minter"
+
+// Authoritative UI-mode tracker for the current agent turn.
+//
+// The backend knows the true phase at every SDK lifecycle point (it drives the session and owns
+// every interaction promise), so it sets the phase explicitly here rather than letting the
+// webview infer it from the tail of the message array. The webview renders
+// footer/buttons/thinking from this.
+//
+// Each transition stamps a fresh `seq` from the shared minter so the webview keeps only the
+// newest TurnState and ignores stale/out-of-order ones (a late "streaming" can never overwrite
+// a newer "completed").
+
+export class TurnStateTracker {
+	private phase: TurnPhase = "idle"
+	private anchorTs: number | undefined
+	private seq: number
+
+	constructor(private readonly minter: MessageIdMinter) {
+		this.seq = minter.nextSeq()
+	}
+
+	/** Set the phase (and optional anchor message ts), advancing seq. No-op metadata if unchanged. */
+	set(phase: TurnPhase, anchorTs?: number): void {
+		this.phase = phase
+		this.anchorTs = anchorTs
+		this.seq = this.minter.nextSeq()
+	}
+
+	/** Current immutable snapshot for inclusion in the state payload. */
+	get(): TurnState {
+		return { phase: this.phase, anchorTs: this.anchorTs, seq: this.seq }
+	}
+
+	get currentPhase(): TurnPhase {
+		return this.phase
+	}
+}
diff --git a/apps/vscode/src/sdk/vscode-lm/README.md b/apps/vscode/src/sdk/vscode-lm/README.md
new file mode 100644
index 0000000..9b6afac
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/README.md
@@ -0,0 +1,54 @@
+# VS Code Language Model provider (`vscode-lm`)
+
+Routes Cline inference through the [VS Code Language Model API](https://code.visualstudio.com/api/extension-guides/language-model)
+(`vscode.lm`), letting Cline use models contributed by any extension that
+registers a language model chat provider (a `vendor`) with VS Code. GitHub
+Copilot is the most common such vendor, but the implementation is
+vendor-agnostic — it selects models via `vscode.lm.selectChatModels` and has no
+Copilot-specific logic. VS Code only — the `vscode.lm` API does not exist on
+other hosts (e.g. JetBrains), so the provider is gated on the API being present.
+
+## Files
+
+- **`vscode-lm-handler.ts`** — `VsCodeLmHandler`, a Cline SDK `ApiHandler`
+  (`@cline/llms`) backed by `vscode.lm`. Selects a chat model, streams the
+  response, forwards tool definitions, and surfaces tool calls and usage.
+- **`vscode-lm-format.ts`** — converts SDK `Message`s to
+  `vscode.LanguageModelChatMessage`s and back-converts tool results.
+- **`register-vscode-lm.ts`** — registers the handler with the SDK handler
+  registry and exposes the `vscode.lm` availability check used for gating.
+
+## How it plugs into the SDK
+
+The SDK's `@cline/llms` handler registry (`registerHandler`) exists for providers
+that need host-only dependencies — here, `vscode.lm` — which cannot live in the
+host-agnostic SDK package. `registerVsCodeLmHandler()` (called during extension
+activation) registers the factory for the `vscode-lm` provider id when the API is
+available. The SDK then resolves `vscode-lm` to this handler for both the main
+task loop and standalone utility calls.
+
+## Model selection
+
+`ProviderConfig` has no field for a VS Code LM selector, so the selected model
+travels as a `vendor/family[/version/id]` string in `ProviderConfig.modelId` —
+the model-id channel the rest of the SDK adapter uses. The webview stores the
+structured `LanguageModelChatSelector` in
+`plan/actModeVsCodeLmModelSelector`; the session factory stringifies it into
+`modelId`, and `parseVsCodeLmSelector` reads it back into a selector here.
+
+## Tool calling
+
+Tool definitions are passed to `sendRequest` via `LanguageModelChatRequestOptions.tools`
+(with `toolMode: Auto`). Tool invocations arrive as `LanguageModelToolCallPart`
+and are forwarded as tool-call chunks the SDK runtime executes.
+
+Tool results round-trip as `LanguageModelToolResultPart`. Two details the VS Code
+LM API requires:
+
+- **Result content is serialized to text.** SDK tool executors return rich,
+  untyped result objects (e.g. `ToolOperationResult` `{ query, result, success }`),
+  not typed text blocks; `extractToolOutputText` pulls their text out so the model
+  receives the actual output.
+- **The prompt must not end on a tool result.** Copilot models require the final
+  message to be a non-tool-result user message; when a turn ends on tool results,
+  a short trailing user message is appended.
diff --git a/apps/vscode/src/sdk/vscode-lm/register-vscode-lm.test.ts b/apps/vscode/src/sdk/vscode-lm/register-vscode-lm.test.ts
new file mode 100644
index 0000000..b858211
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/register-vscode-lm.test.ts
@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const registerHandler = vi.fn()
+vi.mock("@cline/llms", () => ({ registerHandler }))
+vi.mock("@/shared/services/Logger", () => ({ Logger: { debug: vi.fn() } }))
+
+// `vscode.lm` presence is the gate. Use a mutable mock so each test controls it.
+const lm: { selectChatModels?: unknown } = {}
+vi.mock("vscode", () => ({
+	get lm() {
+		return lm
+	},
+}))
+
+describe("registerVsCodeLmHandler gating", () => {
+	beforeEach(() => {
+		vi.resetModules()
+		registerHandler.mockClear()
+		delete lm.selectChatModels
+	})
+
+	it("does not register when the vscode.lm API is unavailable (e.g. JetBrains)", async () => {
+		const { registerVsCodeLmHandler, isVsCodeLmApiAvailable } = await import("./register-vscode-lm")
+		expect(isVsCodeLmApiAvailable()).toBe(false)
+		registerVsCodeLmHandler()
+		expect(registerHandler).not.toHaveBeenCalled()
+	})
+
+	it("registers once when the vscode.lm API is available", async () => {
+		lm.selectChatModels = vi.fn()
+		const { registerVsCodeLmHandler, isVsCodeLmApiAvailable, VSCODE_LM_PROVIDER_ID } = await import("./register-vscode-lm")
+		expect(isVsCodeLmApiAvailable()).toBe(true)
+		registerVsCodeLmHandler()
+		registerVsCodeLmHandler() // idempotent
+		expect(registerHandler).toHaveBeenCalledTimes(1)
+		expect(registerHandler).toHaveBeenCalledWith(VSCODE_LM_PROVIDER_ID, expect.any(Function))
+	})
+})
diff --git a/apps/vscode/src/sdk/vscode-lm/register-vscode-lm.ts b/apps/vscode/src/sdk/vscode-lm/register-vscode-lm.ts
new file mode 100644
index 0000000..0d472dc
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/register-vscode-lm.ts
@@ -0,0 +1,45 @@
+// Registers the VS Code Language Model handler with the Cline SDK.
+//
+// The SDK's `@cline/llms` factory registry (registerHandler) exists for
+// providers that need host-only dependencies — here, the `vscode` module /
+// `vscode.lm` API — which cannot live in the SDK package. Once registered,
+// `createHandler({ providerId: "vscode-lm", ... })` returns this handler, and
+// the agent runtime resolves "vscode-lm" through the same registry, so both the
+// main task loop and standalone utility calls use the VS Code LM API.
+//
+// The `vscode.lm` API only exists in VS Code and derivatives. On other hosts
+// (e.g. JetBrains, which runs the shared activation path through a `vscode`
+// shim) it is absent, so registration is gated on the API being present.
+
+import { registerHandler } from "@cline/llms"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { VsCodeLmHandler } from "./vscode-lm-handler"
+
+export const VSCODE_LM_PROVIDER_ID = "vscode-lm"
+
+/**
+ * Whether the host exposes the VS Code Language Model API. False on hosts
+ * without `vscode.lm` (e.g. JetBrains / standalone), where the provider must not
+ * be registered or surfaced.
+ */
+export function isVsCodeLmApiAvailable(): boolean {
+	return typeof vscode.lm?.selectChatModels === "function"
+}
+
+// Registration is process-global (the SDK registry is a module singleton), so a
+// module-local flag guards against redundant re-registration on reload.
+let registered = false
+
+/**
+ * Register the VS Code LM handler factory, once, when the `vscode.lm` API is
+ * available. No-ops on hosts without the API and on repeated activation.
+ */
+export function registerVsCodeLmHandler(): void {
+	if (registered || !isVsCodeLmApiAvailable()) {
+		return
+	}
+	registerHandler(VSCODE_LM_PROVIDER_ID, (config) => new VsCodeLmHandler(config))
+	registered = true
+	Logger.debug("[vscode-lm] Registered VS Code Language Model handler with the SDK")
+}
diff --git a/apps/vscode/src/sdk/vscode-lm/vscode-lm-format.test.ts b/apps/vscode/src/sdk/vscode-lm/vscode-lm-format.test.ts
new file mode 100644
index 0000000..6bcdbaa
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/vscode-lm-format.test.ts
@@ -0,0 +1,159 @@
+import type { Message } from "@cline/llms"
+import { describe, expect, it, vi } from "vitest"
+
+// The shared vscode vitest stub does not define the Language Model API classes,
+// so mock the small subset the transform uses. Each class records enough to
+// assert structure in tests.
+vi.mock("vscode", () => {
+	class LanguageModelTextPart {
+		constructor(public value: string) {}
+	}
+	class LanguageModelToolCallPart {
+		constructor(
+			public callId: string,
+			public name: string,
+			public input: object,
+		) {}
+	}
+	class LanguageModelToolResultPart {
+		constructor(
+			public callId: string,
+			public content: unknown[],
+		) {}
+	}
+	const LanguageModelChatMessage = {
+		User: (content: unknown) => ({ role: "user", content }),
+		Assistant: (content: unknown) => ({ role: "assistant", content }),
+	}
+	return { LanguageModelTextPart, LanguageModelToolCallPart, LanguageModelToolResultPart, LanguageModelChatMessage }
+})
+
+// Logger is referenced by asObjectSafe; stub it to avoid host dependencies.
+vi.mock("@/shared/services/Logger", () => ({ Logger: { warn: vi.fn(), error: vi.fn(), debug: vi.fn() } }))
+
+const { convertToVsCodeLmMessages, asObjectSafe } = await import("./vscode-lm-format")
+const vscode = await import("vscode")
+
+describe("convertToVsCodeLmMessages", () => {
+	it("converts simple string user/assistant messages", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "hello" },
+			{ role: "assistant", content: "hi there" },
+		]
+		const result = convertToVsCodeLmMessages(messages)
+		expect(result).toEqual([
+			{ role: "user", content: "hello" },
+			{ role: "assistant", content: "hi there" },
+		])
+	})
+
+	it("converts a user message with text + tool_result, tool results first", () => {
+		const messages: Message[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "after tool" },
+					{ type: "tool_result", tool_use_id: "call-1", name: "read", content: "file contents" },
+				],
+			},
+		]
+		const [message] = convertToVsCodeLmMessages(messages)
+		const content = message.content as unknown[]
+		// Tool result part is emitted before the text part.
+		expect(content[0]).toBeInstanceOf(vscode.LanguageModelToolResultPart)
+		expect((content[0] as { callId: string }).callId).toBe("call-1")
+		expect(content[1]).toBeInstanceOf(vscode.LanguageModelTextPart)
+		expect((content[1] as { value: string }).value).toBe("after tool")
+	})
+
+	it("renders images as placeholders (VS Code LM does not accept images)", () => {
+		const messages: Message[] = [{ role: "user", content: [{ type: "image", data: "abc", mediaType: "image/png" }] }]
+		const [message] = convertToVsCodeLmMessages(messages)
+		const part = (message.content as { value: string }[])[0]
+		expect(part).toBeInstanceOf(vscode.LanguageModelTextPart)
+		expect(part.value).toContain("image/png")
+		expect(part.value).toContain("not supported")
+	})
+
+	it("extracts text from structured (untyped) tool_result content (run_commands shape)", () => {
+		// SDK tool executors return rich, untyped objects (ToolOperationResult:
+		// { query, result, success }) — NOT typed text blocks. The result text
+		// must reach the model, not an empty string.
+		const messages: Message[] = [
+			{ role: "assistant", content: [{ type: "tool_use", id: "c1", name: "run_commands", input: {} }] },
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "c1",
+						name: "run_commands",
+						// biome-ignore lint/suspicious/noExplicitAny: simulating runtime untyped content
+						content: [{ query: "ls", result: "demo.ts\ndemo.txt\nsrc\n", success: true }] as any,
+					},
+				],
+			},
+			{ role: "user", content: "continue" },
+		]
+		const result = convertToVsCodeLmMessages(messages)
+		const toolResultMsg = result[1]
+		const trPart = (toolResultMsg.content as { content: { value: string }[] }[])[0]
+		expect(trPart).toBeInstanceOf(vscode.LanguageModelToolResultPart)
+		// The inner text part must contain the actual command output, not "".
+		expect(trPart.content[0].value).toBe("demo.ts\ndemo.txt\nsrc\n")
+	})
+
+	it("appends a trailing plain user message when the convo ends on tool results", () => {
+		const messages: Message[] = [
+			{ role: "assistant", content: [{ type: "tool_use", id: "c1", name: "read", input: {} }] },
+			{ role: "user", content: [{ type: "tool_result", tool_use_id: "c1", name: "read", content: "file body" }] },
+		]
+		const result = convertToVsCodeLmMessages(messages)
+		// Last message must NOT be the tool-result one (Copilot requirement); it's
+		// a plain string user message (LanguageModelChatMessage.User(string)).
+		const last = result[result.length - 1]
+		expect(last.role).toBe("user")
+		expect(typeof last.content).toBe("string")
+		expect(last.content as unknown as string).toContain("result of calling one or more tools")
+		// The tool-result message is preserved before the nudge.
+		expect(result).toHaveLength(3)
+		expect((result[1].content as unknown[])[0]).toBeInstanceOf(vscode.LanguageModelToolResultPart)
+	})
+
+	it("does NOT append a trailing nudge when the convo ends on a normal user message", () => {
+		const messages: Message[] = [
+			{ role: "assistant", content: [{ type: "tool_use", id: "c1", name: "read", input: {} }] },
+			{ role: "user", content: [{ type: "tool_result", tool_use_id: "c1", name: "read", content: "body" }] },
+			{ role: "user", content: "thanks, continue" },
+		]
+		const result = convertToVsCodeLmMessages(messages)
+		expect(result).toHaveLength(3)
+		expect(result[result.length - 1].content).toBe("thanks, continue")
+	})
+
+	it("converts an assistant tool_use into a tool call part with object input", () => {
+		const messages: Message[] = [
+			{ role: "assistant", content: [{ type: "tool_use", id: "call-9", name: "edit", input: { path: "a.ts" } }] },
+		]
+		const [message] = convertToVsCodeLmMessages(messages)
+		const part = (message.content as unknown[])[0]
+		expect(part).toBeInstanceOf(vscode.LanguageModelToolCallPart)
+		expect((part as { name: string }).name).toBe("edit")
+		expect((part as { input: object }).input).toEqual({ path: "a.ts" })
+	})
+})
+
+describe("asObjectSafe", () => {
+	it("parses JSON strings", () => {
+		expect(asObjectSafe('{"a":1}')).toEqual({ a: 1 })
+	})
+	it("clones objects", () => {
+		const input = { a: 1 }
+		expect(asObjectSafe(input)).toEqual({ a: 1 })
+		expect(asObjectSafe(input)).not.toBe(input)
+	})
+	it("returns {} for nullish or invalid", () => {
+		expect(asObjectSafe(null)).toEqual({})
+		expect(asObjectSafe("not json")).toEqual({})
+	})
+})
diff --git a/apps/vscode/src/sdk/vscode-lm/vscode-lm-format.ts b/apps/vscode/src/sdk/vscode-lm/vscode-lm-format.ts
new file mode 100644
index 0000000..afde8a4
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/vscode-lm-format.ts
@@ -0,0 +1,170 @@
+// Converts Cline SDK messages (@cline/llms `Message`) into VS Code Language
+// Model API messages (`vscode.LanguageModelChatMessage`).
+//
+// SDK content blocks (text / image / tool_use / tool_result) map onto VS Code LM
+// parts. VS Code LM does not accept images, so image inputs become a text
+// placeholder. Tool calls and tool results round-trip as
+// `LanguageModelToolCallPart` / `LanguageModelToolResultPart`.
+
+import type { ContentBlock, Message } from "@cline/llms"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { extractToolOutputText } from "../message-translator"
+
+/**
+ * Safely coerce a tool-call input value into a plain object for
+ * `LanguageModelToolCallPart`, which requires an object input.
+ */
+export function asObjectSafe(value: unknown): object {
+	if (!value) {
+		return {}
+	}
+
+	try {
+		if (typeof value === "string") {
+			return JSON.parse(value)
+		}
+		if (typeof value === "object") {
+			return Object.assign({}, value)
+		}
+		return {}
+	} catch (error) {
+		Logger.warn("Cline <Language Model API>: Failed to parse object:", error)
+		return {}
+	}
+}
+
+function imagePlaceholder(mediaType?: string): vscode.LanguageModelTextPart {
+	return new vscode.LanguageModelTextPart(`[Image (${mediaType || "unknown media-type"}) not supported by VSCode LM API]`)
+}
+
+/**
+ * Render the content of a tool_result block into VS Code LM text parts.
+ */
+function toolResultTextParts(content: ContentBlock & { type: "tool_result" }): vscode.LanguageModelTextPart[] {
+	if (typeof content.content === "string") {
+		return [new vscode.LanguageModelTextPart(content.content)]
+	}
+
+	// SDK tool executors (run_commands, search_codebase, read_files, MCP, ...)
+	// put rich, untyped result objects in `content` — e.g. an array of
+	// ToolOperationResult `{ query, result, success, error? }` — rather than typed
+	// text/image/file content blocks. Such items have no `.type`/`.text`, so they
+	// can only be read via extractToolOutputText (which pulls `.result`/`.error`
+	// out of ToolOperationResult[], else falls back to JSON.stringify). When no
+	// item looks like a typed content block, treat the whole array as untyped
+	// output and extract its text in one pass.
+	const isTypedBlock = (part: unknown): part is { type: "text" | "image" | "file" } =>
+		typeof part === "object" && part !== null && typeof (part as { type?: unknown }).type === "string"
+
+	if (!content.content.some(isTypedBlock)) {
+		const text = extractToolOutputText(content.content)
+		return [new vscode.LanguageModelTextPart(text)]
+	}
+
+	const parts = content.content.map((part) => {
+		switch (part.type) {
+			case "text":
+				return new vscode.LanguageModelTextPart(part.text ?? "")
+			case "image":
+				return imagePlaceholder(part.mediaType)
+			case "file":
+				return new vscode.LanguageModelTextPart(part.content ?? "")
+			default:
+				// Untyped item interleaved with typed blocks — serialize just this item.
+				return new vscode.LanguageModelTextPart(extractToolOutputText(part))
+		}
+	})
+
+	return parts.length > 0 ? parts : [new vscode.LanguageModelTextPart("")]
+}
+
+export function convertToVsCodeLmMessages(messages: Message[]): vscode.LanguageModelChatMessage[] {
+	const vsCodeLmMessages: vscode.LanguageModelChatMessage[] = []
+
+	for (const message of messages) {
+		// Simple string content.
+		if (typeof message.content === "string") {
+			vsCodeLmMessages.push(
+				message.role === "assistant"
+					? vscode.LanguageModelChatMessage.Assistant(message.content)
+					: vscode.LanguageModelChatMessage.User(message.content),
+			)
+			continue
+		}
+
+		if (message.role === "user") {
+			const toolResults = message.content.filter(
+				(part): part is ContentBlock & { type: "tool_result" } => part.type === "tool_result",
+			)
+			const nonTool = message.content.filter((part) => part.type === "text" || part.type === "image")
+
+			const contentParts = [
+				// Tool results first, as VS Code LM tool result parts.
+				...toolResults.map(
+					(toolResult) =>
+						new vscode.LanguageModelToolResultPart(toolResult.tool_use_id, toolResultTextParts(toolResult)),
+				),
+				// Then text / image-placeholder parts.
+				...nonTool.map((part) =>
+					part.type === "image"
+						? imagePlaceholder(part.mediaType)
+						: new vscode.LanguageModelTextPart(part.type === "text" ? part.text : ""),
+				),
+			]
+
+			vsCodeLmMessages.push(vscode.LanguageModelChatMessage.User(contentParts))
+			continue
+		}
+
+		if (message.role === "assistant") {
+			const toolUses = message.content.filter(
+				(part): part is ContentBlock & { type: "tool_use" } => part.type === "tool_use",
+			)
+			const nonTool = message.content.filter((part) => part.type === "text" || part.type === "image")
+
+			const contentParts = [
+				// Tool calls first.
+				...toolUses.map(
+					(toolUse) => new vscode.LanguageModelToolCallPart(toolUse.id, toolUse.name, asObjectSafe(toolUse.input)),
+				),
+				// Then text (images are not generated/produced for assistant turns).
+				...nonTool.map((part) =>
+					part.type === "image"
+						? new vscode.LanguageModelTextPart("[Image generation not supported by VSCode LM API]")
+						: new vscode.LanguageModelTextPart(part.type === "text" ? part.text : ""),
+				),
+			]
+
+			vsCodeLmMessages.push(vscode.LanguageModelChatMessage.Assistant(contentParts))
+		}
+	}
+
+	// Copilot (and other VS Code LM) models require that the prompt does NOT end
+	// on a tool-result message — the final message must be a non-tool-result
+	// UserMessage. If we end on tool results, the model can't "see" the output and
+	// tends to re-run tools or call random ones. Mirror the official VS Code chat
+	// sample (chat-sample/src/toolsPrompt.tsx), which appends a trailing user
+	// nudge after tool results.
+	if (endsWithToolResult(vsCodeLmMessages)) {
+		vsCodeLmMessages.push(
+			vscode.LanguageModelChatMessage.User(
+				"Above is the result of calling one or more tools. The user cannot see the results, so you should explain them to the user if referencing them in your answer.",
+			),
+		)
+	}
+
+	return vsCodeLmMessages
+}
+
+/**
+ * True when the last message is a user message whose content consists of (only)
+ * tool result parts.
+ */
+function endsWithToolResult(messages: vscode.LanguageModelChatMessage[]): boolean {
+	const last = messages[messages.length - 1]
+	if (!last || !Array.isArray(last.content) || last.content.length === 0) {
+		return false
+	}
+	return last.content.some((part) => part instanceof vscode.LanguageModelToolResultPart)
+}
diff --git a/apps/vscode/src/sdk/vscode-lm/vscode-lm-handler.test.ts b/apps/vscode/src/sdk/vscode-lm/vscode-lm-handler.test.ts
new file mode 100644
index 0000000..07d85b2
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/vscode-lm-handler.test.ts
@@ -0,0 +1,202 @@
+import type { ProviderConfig, ToolDefinition } from "@cline/llms"
+import { describe, expect, it, vi } from "vitest"
+
+// Real-enough `vscode` mock: the handler uses `instanceof` on the stream parts
+// and the LanguageModelChatToolMode enum, and constructs a CancellationTokenSource.
+vi.mock("vscode", () => {
+	class LanguageModelTextPart {
+		constructor(public value: string) {}
+	}
+	class LanguageModelToolCallPart {
+		constructor(
+			public callId: string,
+			public name: string,
+			public input: object,
+		) {}
+	}
+	class LanguageModelToolResultPart {
+		constructor(
+			public callId: string,
+			public content: unknown[],
+		) {}
+	}
+	class CancellationTokenSource {
+		token = {}
+		cancel = vi.fn()
+		dispose = vi.fn()
+	}
+	class CancellationError extends Error {}
+	return {
+		LanguageModelTextPart,
+		LanguageModelToolCallPart,
+		LanguageModelToolResultPart,
+		CancellationTokenSource,
+		CancellationError,
+		LanguageModelChatToolMode: { Auto: 1, Required: 2 },
+		lm: { selectChatModels: vi.fn() },
+		LanguageModelChatMessage: {
+			User: (content: unknown) => ({ role: "user", content }),
+			Assistant: (content: unknown) => ({ role: "assistant", content }),
+		},
+	}
+})
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: { warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}))
+
+const { parseVsCodeLmSelector, VsCodeLmHandler } = await import("./vscode-lm-handler")
+const vscode = await import("vscode")
+
+describe("parseVsCodeLmSelector", () => {
+	it("returns an empty selector for empty/undefined input", () => {
+		expect(parseVsCodeLmSelector(undefined)).toEqual({})
+		expect(parseVsCodeLmSelector("")).toEqual({})
+	})
+
+	it("parses vendor/family (the common case)", () => {
+		expect(parseVsCodeLmSelector("copilot/claude-sonnet")).toEqual({
+			vendor: "copilot",
+			family: "claude-sonnet",
+		})
+	})
+
+	it("parses vendor/family/version/id positionally", () => {
+		expect(parseVsCodeLmSelector("copilot/claude-sonnet/1.0/abc")).toEqual({
+			vendor: "copilot",
+			family: "claude-sonnet",
+			version: "1.0",
+			id: "abc",
+		})
+	})
+
+	it("parses encoded family values containing slashes", () => {
+		expect(parseVsCodeLmSelector("copilot/openai%2Fgpt-4o")).toEqual({
+			vendor: "copilot",
+			family: "openai/gpt-4o",
+		})
+	})
+
+	it("omits trailing missing segments", () => {
+		expect(parseVsCodeLmSelector("copilot")).toEqual({ vendor: "copilot" })
+	})
+})
+
+// Build a fake LanguageModelChat whose stream yields the given parts, and
+// capture the requestOptions passed to sendRequest for assertions.
+function fakeModel(parts: unknown[]) {
+	const calls: { options: Record<string, unknown> }[] = []
+	const model = {
+		id: "copilot-claude",
+		name: "Claude",
+		vendor: "copilot",
+		family: "claude-sonnet",
+		version: "1",
+		maxInputTokens: 200_000,
+		sendRequest: vi.fn((_messages: unknown, options: Record<string, unknown>) => {
+			calls.push({ options })
+			return Promise.resolve({
+				stream: (async function* () {
+					for (const part of parts) {
+						yield part
+					}
+				})(),
+				text: (async function* () {})(),
+			})
+		}),
+		countTokens: vi.fn(async () => 0),
+	}
+	return { model, calls }
+}
+
+async function collect<T>(gen: AsyncGenerator<T>): Promise<T[]> {
+	const out: T[] = []
+	for await (const v of gen) {
+		out.push(v)
+	}
+	return out
+}
+
+const config = {
+	providerId: "vscode-lm",
+	modelId: "copilot/claude-sonnet",
+} as ProviderConfig
+
+describe("VsCodeLmHandler.createMessage tool calling", () => {
+	it("passes tools + Auto toolMode to sendRequest when tools are provided", async () => {
+		const { model, calls } = fakeModel([new vscode.LanguageModelTextPart("hello")])
+		vi.mocked(vscode.lm.selectChatModels).mockResolvedValue([model] as never)
+
+		const handler = new VsCodeLmHandler(config)
+		const tools: ToolDefinition[] = [
+			{
+				name: "read_file",
+				description: "Reads a file",
+				inputSchema: {
+					type: "object",
+					properties: { path: { type: "string" } },
+				},
+			},
+		]
+		await collect(handler.createMessage("sys", [{ role: "user", content: "hi" }], tools))
+
+		expect(calls).toHaveLength(1)
+		expect(calls[0].options.toolMode).toBe(vscode.LanguageModelChatToolMode.Auto)
+		expect(calls[0].options.tools).toEqual([
+			{
+				name: "read_file",
+				description: "Reads a file",
+				inputSchema: {
+					type: "object",
+					properties: { path: { type: "string" } },
+				},
+			},
+		])
+	})
+
+	it("does not set tools when none are provided", async () => {
+		const { model, calls } = fakeModel([new vscode.LanguageModelTextPart("hi")])
+		vi.mocked(vscode.lm.selectChatModels).mockResolvedValue([model] as never)
+
+		const handler = new VsCodeLmHandler(config)
+		await collect(handler.createMessage("sys", [{ role: "user", content: "hi" }]))
+
+		expect(calls[0].options.tools).toBeUndefined()
+		expect(calls[0].options.toolMode).toBeUndefined()
+	})
+
+	it("emits a native tool_calls chunk for a LanguageModelToolCallPart", async () => {
+		const { model } = fakeModel([
+			new vscode.LanguageModelTextPart("thinking"),
+			new vscode.LanguageModelToolCallPart("call-1", "read_file", {
+				path: "a.ts",
+			}),
+		])
+		vi.mocked(vscode.lm.selectChatModels).mockResolvedValue([model] as never)
+
+		const handler = new VsCodeLmHandler(config)
+		const chunks = await collect(
+			handler.createMessage(
+				"sys",
+				[{ role: "user", content: "hi" }],
+				[{ name: "read_file", description: "", inputSchema: {} }],
+			),
+		)
+
+		const toolChunk = chunks.find((c) => c.type === "tool_calls")
+		expect(toolChunk).toEqual({
+			type: "tool_calls",
+			id: expect.any(String),
+			tool_call: {
+				call_id: "call-1",
+				function: {
+					id: "call-1",
+					name: "read_file",
+					arguments: { path: "a.ts" },
+				},
+			},
+		})
+		// A text chunk and a final usage chunk are also present.
+		expect(chunks.some((c) => c.type === "text" && c.text === "thinking")).toBe(true)
+		expect(chunks.at(-1)?.type).toBe("usage")
+	})
+})
diff --git a/apps/vscode/src/sdk/vscode-lm/vscode-lm-handler.ts b/apps/vscode/src/sdk/vscode-lm/vscode-lm-handler.ts
new file mode 100644
index 0000000..3e16c2a
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-lm/vscode-lm-handler.ts
@@ -0,0 +1,242 @@
+// Cline SDK `ApiHandler` (from `@cline/llms`) backed by the VS Code Language
+// Model API (`vscode.lm`). Registered via `registerHandler("vscode-lm", ...)`
+// (see ./register-vscode-lm.ts) so the SDK routes "vscode-lm" inference here.
+//
+// Model selection: the SDK `ProviderConfig` has no field for a VS Code LM
+// selector, so the selector travels as a `vendor/family[/version/id]` string in
+// `ProviderConfig.modelId` (the model-id channel the rest of the SDK adapter
+// uses) and is parsed back into a `LanguageModelChatSelector` here. See
+// parseVsCodeLmSelector / apps/vscode/src/shared/vsCodeSelectorUtils.ts.
+
+import type { ApiHandler, ApiStreamChunk, HandlerModelInfo, Message, ProviderConfig, ToolDefinition } from "@cline/llms"
+import { nanoid } from "nanoid"
+import * as vscode from "vscode"
+import { Logger } from "@/shared/services/Logger"
+import { parseVsCodeLmModelSelector, SELECTOR_SEPARATOR } from "@/shared/vsCodeSelectorUtils"
+import { convertToVsCodeLmMessages } from "./vscode-lm-format"
+
+const FALLBACK_CONTEXT_WINDOW = 128_000
+
+/**
+ * Parse a stringified VS Code LM selector (`vendor/family[/version/id]`) back
+ * into a `LanguageModelChatSelector`. The model picker commonly supplies just
+ * `vendor` and `family`; any further segments map to version/id positionally,
+ * mirroring `stringifyVsCodeLmModelSelector`.
+ */
+export function parseVsCodeLmSelector(modelId: string | undefined): vscode.LanguageModelChatSelector {
+	return parseVsCodeLmModelSelector(modelId)
+}
+
+function extractText(message: vscode.LanguageModelChatMessage): string {
+	if (typeof message.content === "string") {
+		return message.content
+	}
+	if (Array.isArray(message.content)) {
+		return message.content
+			.filter((part): part is vscode.LanguageModelTextPart => part instanceof vscode.LanguageModelTextPart)
+			.map((part) => part.value)
+			.join("")
+	}
+	return ""
+}
+
+export class VsCodeLmHandler implements ApiHandler {
+	private readonly selector: vscode.LanguageModelChatSelector
+	private client: vscode.LanguageModelChat | null = null
+	private currentRequestCancellation: vscode.CancellationTokenSource | null = null
+	private abortSignal: AbortSignal | undefined
+
+	constructor(config: ProviderConfig) {
+		this.selector = parseVsCodeLmSelector(config.modelId)
+		this.abortSignal = config.abortSignal
+	}
+
+	setAbortSignal(signal: AbortSignal | undefined): void {
+		this.abortSignal = signal
+	}
+
+	abort(): void {
+		this.ensureCleanState()
+	}
+
+	private ensureCleanState(): void {
+		if (this.currentRequestCancellation) {
+			this.currentRequestCancellation.cancel()
+			this.currentRequestCancellation.dispose()
+			this.currentRequestCancellation = null
+		}
+	}
+
+	private async getClient(): Promise<vscode.LanguageModelChat> {
+		if (this.client) {
+			return this.client
+		}
+		try {
+			const models = await vscode.lm.selectChatModels(this.selector)
+			if (models && models.length > 0) {
+				this.client = models[0]
+				return this.client
+			}
+			throw new Error(
+				`No VS Code language model matched selector ${JSON.stringify(this.selector)}. Ensure GitHub Copilot (or another LM provider) is installed and the model is enabled.`,
+			)
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error"
+			throw new Error(`Cline <Language Model API>: Failed to select model: ${message}`)
+		}
+	}
+
+	getMessages(systemPrompt: string, messages: Message[]): vscode.LanguageModelChatMessage[] {
+		return [vscode.LanguageModelChatMessage.Assistant(systemPrompt), ...convertToVsCodeLmMessages(messages)]
+	}
+
+	// VS Code LM does not expose a tokenizer cheaply, so approximate as chars/4.
+	// Good enough for budgeting and usage display.
+	private approxTokens(text: string): number {
+		return Math.ceil((text || "").length / 4)
+	}
+
+	async *createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): AsyncGenerator<ApiStreamChunk> {
+		this.ensureCleanState()
+		const client = await this.getClient()
+		const id = nanoid()
+
+		const vsCodeLmMessages = this.getMessages(systemPrompt, messages)
+		const inputTokens = vsCodeLmMessages.reduce((sum, msg) => sum + this.approxTokens(extractText(msg)), 0)
+
+		this.currentRequestCancellation = new vscode.CancellationTokenSource()
+		if (this.abortSignal) {
+			if (this.abortSignal.aborted) {
+				this.currentRequestCancellation.cancel()
+			} else {
+				this.abortSignal.addEventListener("abort", () => this.currentRequestCancellation?.cancel(), { once: true })
+			}
+		}
+
+		let accumulatedText = ""
+
+		try {
+			const requestOptions: vscode.LanguageModelChatRequestOptions = {
+				justification: `Cline would like to use '${client.name}' from '${client.vendor}', Click 'Allow' to proceed.`,
+			}
+
+			// Native tool calling: the VS Code LM API (finalized in VS Code 1.95)
+			// accepts tool definitions on the request and streams back
+			// LanguageModelToolCallPart for invocations. Map the SDK's
+			// ToolDefinition[] onto vscode.LanguageModelChatTool[]; tool RESULTS are
+			// already round-tripped as LanguageModelToolResultPart by
+			// convertToVsCodeLmMessages. We use "Auto" tool mode so the model
+			// decides when to call tools (vs. forcing a call).
+			if (tools && tools.length > 0) {
+				requestOptions.tools = tools.map((tool) => ({
+					name: tool.name,
+					description: tool.description,
+					inputSchema: tool.inputSchema,
+				}))
+				requestOptions.toolMode = vscode.LanguageModelChatToolMode.Auto
+			}
+
+			const response = await client.sendRequest(vsCodeLmMessages, requestOptions, this.currentRequestCancellation.token)
+
+			for await (const chunk of response.stream) {
+				if (chunk instanceof vscode.LanguageModelTextPart) {
+					if (typeof chunk.value !== "string") {
+						continue
+					}
+					accumulatedText += chunk.value
+					const textChunk: ApiStreamChunk = {
+						type: "text",
+						text: chunk.value,
+						id,
+					}
+					yield textChunk
+				} else if (chunk instanceof vscode.LanguageModelToolCallPart) {
+					// A tool invocation from the model. callId/name/input come straight
+					// from the API (input is already a parsed object); forward them as a
+					// tool-call chunk for the SDK runtime to execute.
+					if (!chunk.name || !chunk.callId || !chunk.input) {
+						continue
+					}
+					const toolCallChunk: ApiStreamChunk = {
+						type: "tool_calls",
+						id,
+						tool_call: {
+							call_id: chunk.callId,
+							function: {
+								id: chunk.callId,
+								name: chunk.name,
+								arguments: chunk.input as Record<string, unknown>,
+							},
+						},
+					}
+					// Approximate output token accounting still wants the tool call's
+					// size; serialize for the estimate without affecting the chunk.
+					accumulatedText += JSON.stringify({
+						name: chunk.name,
+						input: chunk.input,
+						callId: chunk.callId,
+					})
+					yield toolCallChunk
+				}
+			}
+
+			const usageChunk: ApiStreamChunk = {
+				type: "usage",
+				inputTokens,
+				outputTokens: this.approxTokens(accumulatedText),
+				totalCost: 0,
+				id,
+			}
+			yield usageChunk
+		} catch (error) {
+			this.ensureCleanState()
+			if (error instanceof vscode.CancellationError) {
+				throw new Error("Cline <Language Model API>: Request cancelled by user")
+			}
+			if (error instanceof Error) {
+				Logger.error("Cline <Language Model API>: Stream error:", error)
+				throw error
+			}
+			throw new Error(`Cline <Language Model API>: Response stream error: ${String(error)}`)
+		} finally {
+			this.ensureCleanState()
+		}
+	}
+
+	getModel(): HandlerModelInfo {
+		if (this.client) {
+			const modelParts = [this.client.vendor, this.client.family, this.client.version].filter(Boolean)
+			const modelId = this.client.id || modelParts.join(SELECTOR_SEPARATOR)
+			const contextWindow =
+				typeof this.client.maxInputTokens === "number" && this.client.maxInputTokens > 0
+					? this.client.maxInputTokens
+					: FALLBACK_CONTEXT_WINDOW
+			return {
+				id: modelId,
+				info: {
+					id: modelId,
+					contextWindow,
+					maxInputTokens: contextWindow,
+					maxTokens: -1,
+					description: `VSCode Language Model: ${modelId}`,
+				},
+			}
+		}
+
+		// No client yet (e.g. getModel() called before createMessage()).
+		const fallbackId =
+			[this.selector.vendor, this.selector.family, this.selector.version, this.selector.id]
+				.filter(Boolean)
+				.join(SELECTOR_SEPARATOR) || "vscode-lm"
+		return {
+			id: fallbackId,
+			info: {
+				id: fallbackId,
+				contextWindow: FALLBACK_CONTEXT_WINDOW,
+				maxInputTokens: FALLBACK_CONTEXT_WINDOW,
+				maxTokens: -1,
+				description: `VSCode Language Model (Fallback): ${fallbackId}`,
+			},
+		}
+	}
+}
diff --git a/apps/vscode/src/sdk/vscode-run-commands-tool.test.ts b/apps/vscode/src/sdk/vscode-run-commands-tool.test.ts
new file mode 100644
index 0000000..612e169
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-run-commands-tool.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest"
+import { formatCommandForTerminal } from "./vscode-run-commands-tool"
+
+describe("formatCommandForTerminal", () => {
+	it.each([
+		{
+			name: "raw shell command",
+			input: "which git",
+			expected: "which git",
+		},
+		{
+			name: "raw shell command with pipes and quotes",
+			input: "git status --short | sed -n '1,20p'",
+			expected: "git status --short | sed -n '1,20p'",
+		},
+		{
+			name: "structured command with omitted args",
+			input: { command: "which git" },
+			expected: "which git",
+		},
+		{
+			name: "structured shell command with omitted args and metacharacters",
+			input: { command: "git status --short | head -20" },
+			expected: "git status --short | head -20",
+		},
+		{
+			name: "structured executable with explicit empty args",
+			input: { command: "/tmp/path with spaces/tool", args: [] },
+			expected: "'/tmp/path with spaces/tool'",
+		},
+		{
+			name: "structured executable with simple args",
+			input: { command: "which", args: ["git"] },
+			expected: "which git",
+		},
+		{
+			name: "structured executable with spaced args",
+			input: { command: "echo", args: ["hello world", "again"] },
+			expected: "echo 'hello world' again",
+		},
+		{
+			name: "structured executable with apostrophe args",
+			input: { command: "printf", args: ["it's ok"] },
+			expected: "printf 'it'\\''s ok'",
+		},
+		{
+			name: "structured executable with empty arg",
+			input: { command: "printf", args: [""] },
+			expected: "printf ''",
+		},
+		{
+			name: "structured executable with shell metacharacters in args",
+			input: { command: "echo", args: ["$HOME", "a&b", "semi;colon", "paren(value)"] },
+			expected: "echo '$HOME' 'a&b' 'semi;colon' 'paren(value)'",
+		},
+		{
+			name: "structured executable with quoted args",
+			input: { command: "node", args: ["-e", 'console.log("hi")'] },
+			expected: "node -e 'console.log(\"hi\")'",
+		},
+	])("$name", ({ input, expected }) => {
+		expect(formatCommandForTerminal(input)).toBe(expected)
+	})
+
+	it("quotes multiple structured args that need shell escaping", () => {
+		expect(formatCommandForTerminal({ command: "echo", args: ["hello world", "it's ok"] })).toBe(
+			"echo 'hello world' 'it'\\''s ok'",
+		)
+	})
+})
diff --git a/apps/vscode/src/sdk/vscode-run-commands-tool.ts b/apps/vscode/src/sdk/vscode-run-commands-tool.ts
new file mode 100644
index 0000000..b198464
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-run-commands-tool.ts
@@ -0,0 +1,168 @@
+/**
+ * Custom `run_commands` tool that replaces the SDK's built-in version.
+ *
+ * This is an IDE-level feature built on top of the SDK, NOT part of the SDK.
+ * It supports two execution modes, switchable dynamically per invocation:
+ *
+ *   - **Foreground (vscodeTerminal):** Uses VscodeTerminalManager for visible
+ *     VS Code terminals with shell integration.
+ *
+ *   - **Background (backgroundExec):** Delegates to the SDK's createShellExecutor()
+ *     for headless child_process.spawn execution.
+ */
+
+import {
+	createShellExecutor,
+	createShellTool,
+	MAX_COMMAND_OUTPUT_CHARS,
+	type ShellExecutor,
+	type StructuredCommandInput,
+	truncateCommandOutput,
+} from "@cline/core"
+import type { AgentTool } from "@cline/shared"
+import { StateManager } from "@/core/storage/StateManager"
+import type { ITerminalManager } from "@/integrations/terminal/types"
+import { Logger } from "@/shared/services/Logger"
+import { getShellForProfile } from "@/utils/shell"
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+type ShellCommand = string | StructuredCommandInput
+
+/** Options for creating the VSCode run_commands tool. */
+export interface VscodeRunCommandsToolOptions {
+	/** Workspace root directory. */
+	cwd: string
+	/** Lazy factory for the VscodeTerminalManager. Called once on first foreground use. */
+	getTerminalManager: () => ITerminalManager
+}
+
+// ---------------------------------------------------------------------------
+// Foreground execution — VscodeTerminalManager
+// ---------------------------------------------------------------------------
+
+function quoteShellArg(arg: string): string {
+	if (arg.length === 0) {
+		return "''"
+	}
+	if (!/[\s"'\\$`!&|;<>(){}[\]*?~]/.test(arg)) {
+		return arg
+	}
+	return `'${arg.replace(/'/g, `'\\''`)}'`
+}
+
+export function formatCommandForTerminal(command: ShellCommand): string {
+	if (typeof command === "string") {
+		return command
+	}
+	if (!("args" in command)) {
+		return command.command
+	}
+	return [command.command, ...(command.args ?? [])].map(quoteShellArg).join(" ")
+}
+
+async function executeForeground(
+	command: ShellCommand,
+	cwd: string,
+	terminalManager: ITerminalManager,
+	maxOutputChars: number,
+	abortSignal?: AbortSignal,
+): Promise<string> {
+	const terminalCommand = formatCommandForTerminal(command)
+	const terminalInfo = await terminalManager.getOrCreateTerminal(cwd)
+	terminalInfo.terminal.show()
+
+	const process = terminalManager.runCommand(terminalInfo, terminalCommand)
+	const outputLines: string[] = []
+
+	// Accumulate output lines to return the full output once the command completes.
+	// The chat shows command output at completion, not incrementally.
+	process.on("line", (line: string) => {
+		outputLines.push(line)
+	})
+
+	// Handle abort signal
+	if (abortSignal) {
+		const onAbort = () => {
+			process.continue()
+		}
+		const cleanupAbortListener = () => abortSignal.removeEventListener("abort", onAbort)
+		abortSignal.addEventListener("abort", onAbort, { once: true })
+		process.once("completed", cleanupAbortListener)
+		process.once("continue", cleanupAbortListener)
+	}
+
+	// Wait for completion
+	await process
+	if (abortSignal?.aborted) {
+		throw new Error("Command execution aborted")
+	}
+
+	return truncateCommandOutput(outputLines.join("\n").trim(), {
+		maxChars: maxOutputChars,
+	})
+}
+
+// ---------------------------------------------------------------------------
+// Tool factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates the custom `run_commands` tool for the VSCode extension.
+ *
+ * This tool suppresses and replaces the SDK's built-in `run_commands` tool.
+ * It reads `vscodeTerminalExecutionMode` from StateManager on every invocation
+ * to dynamically switch between foreground (visible terminal) and background
+ * (child_process.spawn) execution.
+ */
+export function createVscodeRunCommandsTool(options: VscodeRunCommandsToolOptions): AgentTool {
+	return createShellTool(createVscodeShellExecutor(options), {
+		cwd: options.cwd,
+	})
+}
+
+function createVscodeShellExecutor(options: VscodeRunCommandsToolOptions): ShellExecutor {
+	const { cwd, getTerminalManager } = options
+
+	// Lazy-init background executor — recreated when the user's shell profile changes.
+	let bgExecutor: ShellExecutor | undefined
+	let bgExecutorShell: string | undefined
+
+	// Lazy-init terminal manager reference
+	let terminalManager: ITerminalManager | undefined
+
+	return async (command, commandCwd, context): Promise<string> => {
+		// Read current execution mode dynamically
+		const mode = StateManager.get().getGlobalStateKey("vscodeTerminalExecutionMode") ?? "vscodeTerminal"
+
+		Logger.log(`[VscodeRunCommands] Executing command in ${mode} mode`)
+
+		if (mode === "backgroundExec") {
+			// Background path — use SDK's createShellExecutor
+			// Resolve shell from the user's terminal profile setting
+			const profileId = (StateManager.get().getGlobalSettingsKey("defaultTerminalProfile") as string) || "default"
+			const shell = getShellForProfile(profileId)
+
+			// Recreate the executor if the shell has changed
+			if (!bgExecutor || bgExecutorShell !== shell) {
+				bgExecutorShell = shell
+				bgExecutor = createShellExecutor({
+					shell,
+					// Set SHELL env to match the shell we're spawning so child
+					// processes see the correct value instead of the inherited parent's.
+					env: { SHELL: shell },
+				})
+				Logger.log(`[VscodeRunCommands] Background executor using shell: ${shell}`)
+			}
+			return await bgExecutor(command, commandCwd || cwd, context)
+		}
+
+		// Foreground path — use VscodeTerminalManager
+		if (!terminalManager) {
+			terminalManager = getTerminalManager()
+		}
+		return await executeForeground(command, commandCwd || cwd, terminalManager, MAX_COMMAND_OUTPUT_CHARS, context.signal)
+	}
+}
diff --git a/apps/vscode/src/sdk/vscode-runtime-builder.ts b/apps/vscode/src/sdk/vscode-runtime-builder.ts
new file mode 100644
index 0000000..f5f7295
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-runtime-builder.ts
@@ -0,0 +1,164 @@
+import { createDefaultShellExecutor, createMcpTools } from "@cline/core"
+import { type AgentTool, type AgentToolContext, createTool } from "@cline/shared"
+import type { ITerminalManager } from "@/integrations/terminal/types"
+import type { McpHub } from "@/services/mcp/McpHub"
+import { Logger } from "@/shared/services/Logger"
+import { createVscodeRunCommandsTool } from "./vscode-run-commands-tool"
+
+interface McpToolDescriptor {
+	name: string
+	description?: string
+	inputSchema: Record<string, unknown>
+}
+
+class McpHubToolProvider {
+	constructor(private readonly mcpHub: McpHub) {}
+
+	async listTools(serverName: string): Promise<readonly McpToolDescriptor[]> {
+		const servers = this.mcpHub.getServers()
+		const server = servers.find((entry) => entry.name === serverName)
+		if (!server) {
+			Logger.warn(`[McpHubToolProvider] Server not found: ${serverName}`)
+			return []
+		}
+
+		return (server.tools ?? []).map((tool) => ({
+			name: tool.name,
+			description: tool.description ?? undefined,
+			inputSchema: (tool.inputSchema as Record<string, unknown>) ?? {
+				type: "object",
+				properties: {},
+			},
+		}))
+	}
+
+	async callTool(request: {
+		serverName: string
+		toolName: string
+		arguments?: Record<string, unknown>
+		context?: AgentToolContext
+	}): Promise<unknown> {
+		const ulid = `sdk-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
+		return this.mcpHub.callTool(request.serverName, request.toolName, request.arguments ?? {}, ulid)
+	}
+}
+
+/**
+ * Lazily-created shell executor for attempt_completion commands.
+ * Re-uses the SDK's built-in shell executor which
+ * already handles cross-platform shells, timeout, abort signals, and output truncation.
+ */
+const getCompletionCommandExecutor = (() => {
+	let executor: ReturnType<typeof createDefaultShellExecutor> | undefined
+	return () => {
+		if (!executor) {
+			executor = createDefaultShellExecutor({
+				timeoutMs: 15_000, // showcase commands, not long-running builds
+				maxOutputBytes: 256_000,
+			})
+		}
+		return executor!
+	}
+})()
+
+function createAttemptCompletionTool(options: { cwd?: string } = {}): AgentTool {
+	return createTool({
+		name: "attempt_completion",
+		description:
+			"Once you've completed the user's task, use this tool to present the result to the user. " +
+			"The user may provide feedback if they are not satisfied, which you can use to make improvements and try again.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				result: {
+					type: "string",
+					description: "A clear, brief summary of the final result of the task.",
+				},
+				command: {
+					type: "string",
+					description:
+						"An optional terminal command to showcase the result (e.g. open a dev server). " +
+						"Do not use commands like echo or cat that merely print text.",
+				},
+			},
+			required: ["result"],
+		},
+		execute: async (input: unknown, context: AgentToolContext) => {
+			const parsedInput = input && typeof input === "object" ? (input as Record<string, unknown>) : {}
+			const resultText = typeof parsedInput.result === "string" ? parsedInput.result : "Task completed."
+			const command = typeof parsedInput.command === "string" ? parsedInput.command.trim() : undefined
+
+			if (!command) {
+				return resultText
+			}
+
+			// Execute the command and include its output in the result
+			const cwd = options.cwd || process.cwd()
+			Logger.log(`[attempt_completion] Executing command: ${command} (cwd: ${cwd})`)
+
+			try {
+				const shellExecutor = getCompletionCommandExecutor()
+				const commandOutput = await shellExecutor(command, cwd, context)
+				const trimmedOutput = commandOutput.trim()
+
+				if (trimmedOutput) {
+					return `${resultText}\n\n[Command: ${command}]\n${trimmedOutput}`
+				}
+				return `${resultText}\n\n[Command executed: ${command}]`
+			} catch (error) {
+				const errorMsg = error instanceof Error ? error.message : String(error)
+				Logger.warn(`[attempt_completion] Command failed: ${errorMsg}`)
+				return `${resultText}\n\n[Command failed: ${command}]\n${errorMsg}`
+			}
+		},
+	})
+}
+
+export interface VscodeExtraToolsOptions {
+	cwd?: string
+	/**
+	 * Lazy factory for the VscodeTerminalManager.
+	 * When provided, the custom `run_commands` tool replaces the SDK's
+	 * built-in version with foreground/background terminal support.
+	 */
+	getTerminalManager?: () => ITerminalManager
+}
+
+export async function createVscodeExtraTools(mcpHub: McpHub, options?: VscodeExtraToolsOptions): Promise<AgentTool[]> {
+	const provider = new McpHubToolProvider(mcpHub)
+	const mcpTools = await Promise.all(
+		mcpHub.getServers().map(async (server) => {
+			try {
+				return await createMcpTools({
+					serverName: server.name,
+					provider,
+				})
+			} catch (error) {
+				Logger.warn(
+					`[VscodeRuntimeTools] Failed to load tools from MCP server "${server.name}": ${
+						error instanceof Error ? error.message : String(error)
+					}`,
+				)
+				return []
+			}
+		}),
+	)
+
+	const tools: AgentTool[] = [createAttemptCompletionTool({ cwd: options?.cwd }), ...mcpTools.flat()]
+
+	// Add the custom run_commands tool when a terminal manager is available.
+	// This replaces the SDK's built-in run_commands, which is suppressed via
+	// tool executor capabilities in VscodeSessionHost.
+	if (options?.getTerminalManager) {
+		tools.push(
+			createVscodeRunCommandsTool({
+				cwd: options.cwd ?? process.cwd(),
+				getTerminalManager: options.getTerminalManager,
+			}),
+		)
+		Logger.log("[VscodeRuntimeTools] Added custom run_commands tool (foreground/background terminal)")
+	}
+
+	Logger.log(`[VscodeRuntimeTools] Prepared ${tools.length} VSCode extra tools`)
+	return tools
+}
diff --git a/apps/vscode/src/sdk/vscode-session-host.test.ts b/apps/vscode/src/sdk/vscode-session-host.test.ts
new file mode 100644
index 0000000..99293b0
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-session-host.test.ts
@@ -0,0 +1,151 @@
+import type { ClineCoreStartInput, ITelemetryService } from "@cline/core"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const mockClineCoreCreate = vi.hoisted(() => vi.fn())
+const mockCreateVscodeExtraTools = vi.hoisted(() => vi.fn(async () => []))
+
+vi.mock("@cline/core", async () => {
+	const actual = await vi.importActual<typeof import("@cline/core")>("@cline/core")
+	return {
+		...actual,
+		ClineCore: {
+			create: mockClineCoreCreate,
+		},
+	}
+})
+
+vi.mock("@/services/logging/distinctId", () => ({
+	getDistinctId: () => "distinct-id",
+}))
+
+vi.mock("./vscode-runtime-builder", () => ({
+	createVscodeExtraTools: mockCreateVscodeExtraTools,
+}))
+
+import { VscodeSessionHost } from "./vscode-session-host"
+
+describe("VscodeSessionHost telemetry wiring", () => {
+	beforeEach(() => {
+		mockClineCoreCreate.mockReset()
+		mockClineCoreCreate.mockResolvedValue({ runtimeAddress: undefined })
+		mockCreateVscodeExtraTools.mockReset().mockResolvedValue([])
+	})
+
+	it("passes shared telemetry to ClineCore.create", async () => {
+		const telemetry = makeTelemetry()
+
+		await VscodeSessionHost.create({
+			// biome-ignore lint/suspicious/noExplicitAny: focused host unit test
+			mcpHub: {} as any,
+			telemetry,
+		})
+
+		expect(mockClineCoreCreate).toHaveBeenCalledWith(expect.objectContaining({ telemetry }))
+	})
+
+	it("injects shared telemetry into CoreSessionConfig when remote config did not provide one", async () => {
+		const telemetry = makeTelemetry()
+		await VscodeSessionHost.create({
+			// biome-ignore lint/suspicious/noExplicitAny: focused host unit test
+			mcpHub: {} as any,
+			telemetry,
+		})
+
+		const prepare = mockClineCoreCreate.mock.calls[0][0].prepare
+		const bootstrap = await prepare()
+		const prepared = await bootstrap.applyToStartSessionInput({
+			source: undefined,
+			config: {
+				cwd: "/tmp/workspace",
+				extraTools: [],
+			},
+		})
+
+		expect(prepared.source).toBe("vscode")
+		expect(prepared.config.telemetry).toBe(telemetry)
+	})
+
+	it("preserves telemetry already supplied by remote config", async () => {
+		const telemetry = makeTelemetry()
+		const remoteTelemetry = makeTelemetry()
+		await VscodeSessionHost.create({
+			// biome-ignore lint/suspicious/noExplicitAny: focused host unit test
+			mcpHub: {} as any,
+			telemetry,
+			getRemoteConfigIntegration: () =>
+				({
+					applyToStartSessionInput: (input: ClineCoreStartInput) => ({
+						...input,
+						config: {
+							...input.config,
+							telemetry: remoteTelemetry,
+						},
+					}),
+				}) as never,
+		})
+
+		const prepare = mockClineCoreCreate.mock.calls[0][0].prepare
+		const bootstrap = await prepare()
+		const prepared = await bootstrap.applyToStartSessionInput({
+			source: undefined,
+			config: {
+				cwd: "/tmp/workspace",
+				extraTools: [],
+			},
+		})
+
+		expect(prepared.config.telemetry).toBe(remoteTelemetry)
+	})
+
+	it("applies remote config before appending VS Code extra tools", async () => {
+		mockCreateVscodeExtraTools.mockResolvedValueOnce([{ name: "vscode-tool" }] as never)
+		const applyToStartSessionInput = vi.fn(async (input: ClineCoreStartInput) => ({
+			...input,
+			config: {
+				...input.config,
+				extensions: [{ name: "remote-config" }],
+				extraTools: [{ name: "remote-tool" }],
+			},
+		}))
+		await VscodeSessionHost.create({
+			// biome-ignore lint/suspicious/noExplicitAny: focused host unit test
+			mcpHub: {} as any,
+			getRemoteConfigIntegration: () =>
+				({
+					applyToStartSessionInput,
+					dispose: vi.fn(),
+				}) as never,
+		})
+
+		const prepare = mockClineCoreCreate.mock.calls[0][0].prepare
+		const bootstrap = await prepare()
+		const result = await bootstrap.applyToStartSessionInput({ config: { cwd: "/workspace" } })
+
+		expect(applyToStartSessionInput).toHaveBeenCalledWith({ config: { cwd: "/workspace" } })
+		expect(mockCreateVscodeExtraTools).toHaveBeenCalledWith({} as never, {
+			cwd: "/workspace",
+			getTerminalManager: undefined,
+		})
+		expect(result.source).toBe("vscode")
+		expect(result.config.extensions).toEqual([{ name: "remote-config" }])
+		expect(result.config.extraTools).toEqual([{ name: "remote-tool" }, { name: "vscode-tool" }])
+	})
+})
+
+function makeTelemetry(): ITelemetryService {
+	return {
+		setDistinctId() {},
+		setMetadata() {},
+		updateMetadata() {},
+		setCommonProperties() {},
+		updateCommonProperties() {},
+		isEnabled: () => true,
+		capture() {},
+		captureRequired() {},
+		recordCounter() {},
+		recordHistogram() {},
+		recordGauge() {},
+		flush: async () => {},
+		dispose: async () => {},
+	}
+}
diff --git a/apps/vscode/src/sdk/vscode-session-host.ts b/apps/vscode/src/sdk/vscode-session-host.ts
new file mode 100644
index 0000000..8b8ef4b
--- /dev/null
+++ b/apps/vscode/src/sdk/vscode-session-host.ts
@@ -0,0 +1,246 @@
+// VscodeSessionHost — wraps ClineCore with VSCode-specific customizations
+//
+// Uses ClineCore.create() so the SDK owns session input normalization,
+// lifecycle bootstrapping, and host selection while the VSCode extension
+// still provides its custom McpHub-backed runtime builder.
+
+import {
+	ClineCore,
+	type ClineCoreListHistoryOptions,
+	type ClineCoreStartInput,
+	type CoreSessionEvent,
+	type HookEventPayload,
+	type ITelemetryService,
+	type PendingPromptMutationResult,
+	type PendingPromptsDeleteInput,
+	type PendingPromptsListInput,
+	type PendingPromptsUpdateInput,
+	type PreparedRemoteConfigCoreIntegration,
+	type RestoreInput,
+	type RestoreResult,
+	type SendSessionInput,
+	type SessionAccumulatedUsage,
+	type SessionCompactionState,
+	type SessionHistoryRecord,
+	type SessionPendingPrompt,
+	type SessionRecord,
+	type StartSessionInput,
+	type StartSessionResult,
+	type ToolExecutors,
+} from "@cline/core"
+import { type AgentToolContext, type ToolApprovalRequest, type ToolApprovalResult, type ToolPolicy } from "@cline/shared"
+import type { ITerminalManager } from "@/integrations/terminal/types"
+import { getDistinctId } from "@/services/logging/distinctId"
+import type { McpHub } from "@/services/mcp/McpHub"
+import { Logger } from "@/shared/services/Logger"
+import type { SdkSessionHost } from "./session-host"
+import { createVscodeExtraTools } from "./vscode-runtime-builder"
+
+export interface VscodeSessionHostOptions {
+	mcpHub: McpHub
+	requestToolApproval?: (request: {
+		agentId: string
+		conversationId: string
+		iteration: number
+		toolCallId: string
+		toolName: string
+		input: unknown
+		policy: { enabled: boolean; autoApprove: boolean }
+	}) => Promise<{ approved: boolean; reason?: string }>
+	/** Executor for the SDK's built-in ask_question tool (equivalent to classic ask_followup_question). */
+	askQuestion?: (question: string, options: string[], context: AgentToolContext) => Promise<string>
+	/** Per-tool approval policies derived from the user's auto-approval settings. */
+	toolPolicies?: Record<string, ToolPolicy>
+	/** Shared SDK telemetry service owned by SdkController. */
+	telemetry?: ITelemetryService
+	/** Returns the latest prepared remote-config integration, if remote config is active. */
+	getRemoteConfigIntegration?: () => PreparedRemoteConfigCoreIntegration | undefined
+	/**
+	 * Lazy factory for the VscodeTerminalManager.
+	 * When provided, the SDK's built-in `run_commands` is suppressed and replaced
+	 * with a custom tool that supports foreground/background terminal execution.
+	 */
+	getTerminalManager?: () => ITerminalManager
+}
+
+export class VscodeSessionHost implements SdkSessionHost {
+	readonly runtimeAddress: string | undefined
+	private readonly inner: ClineCore
+
+	private constructor(inner: ClineCore) {
+		this.inner = inner
+		this.runtimeAddress = inner.runtimeAddress
+	}
+	updateSessionModel?(sessionId: string, modelId: string): Promise<void> {
+		return this.inner.updateSessionModel(sessionId, modelId)
+	}
+
+	static async create(options: VscodeSessionHostOptions): Promise<VscodeSessionHost> {
+		// Build tool executor capabilities from options — only include keys that are provided.
+		// When a terminal manager is available, suppress the SDK's built-in run_commands
+		// tool by setting bash to undefined. Our custom run_commands (provided via
+		// extraTools) replaces it with foreground/background terminal support.
+		const toolExecutors: Partial<ToolExecutors> = {}
+		if (options.askQuestion) {
+			toolExecutors.askQuestion = options.askQuestion
+		}
+		if (options.getTerminalManager) {
+			// Setting bash to undefined suppresses the SDK's createShellTool():
+			// createDefaultTools() checks `enableBash && executors.bash` — falsy
+			// bash means no built-in run_commands tool is created.
+			;(toolExecutors as Record<string, unknown>).bash = undefined
+		}
+
+		const inner = await ClineCore.create({
+			backendMode: "local",
+			capabilities: {
+				requestToolApproval: options.requestToolApproval as
+					| ((request: ToolApprovalRequest) => Promise<ToolApprovalResult>)
+					| undefined,
+				toolExecutors: Object.keys(toolExecutors).length > 0 ? toolExecutors : undefined,
+			},
+			toolPolicies: options.toolPolicies,
+			telemetry: options.telemetry,
+			distinctId: getDistinctId() || undefined,
+			prepare: async () => ({
+				applyToStartSessionInput: async (input: ClineCoreStartInput): Promise<ClineCoreStartInput> => {
+					const remoteConfigIntegration = options.getRemoteConfigIntegration?.()
+					const inputWithRemoteConfig = remoteConfigIntegration
+						? await remoteConfigIntegration.applyToStartSessionInput(input)
+						: input
+					const extraTools = await createVscodeExtraTools(options.mcpHub, {
+						cwd: inputWithRemoteConfig.config.cwd,
+						getTerminalManager: options.getTerminalManager,
+					})
+					return {
+						...inputWithRemoteConfig,
+						source: inputWithRemoteConfig.source ?? "vscode",
+						config: {
+							...inputWithRemoteConfig.config,
+							telemetry: inputWithRemoteConfig.config.telemetry ?? options.telemetry,
+							extraTools: [...(inputWithRemoteConfig.config.extraTools ?? []), ...extraTools],
+						},
+					}
+				},
+			}),
+		})
+
+		Logger.log("[VscodeSessionHost] Initialized with ClineCore + VSCode extra tools")
+		if (options.getTerminalManager) {
+			Logger.log("[VscodeSessionHost] SDK run_commands suppressed; using custom foreground/background terminal tool")
+		}
+		return new VscodeSessionHost(inner)
+	}
+
+	async start(input: StartSessionInput): Promise<StartSessionResult>
+	async start(input: ClineCoreStartInput): Promise<StartSessionResult>
+	async start(input: StartSessionInput | ClineCoreStartInput): Promise<StartSessionResult> {
+		return this.inner.start(input as ClineCoreStartInput)
+	}
+
+	async send(input: SendSessionInput) {
+		Logger.log(`[VscodeSessionHost] send() called: sessionId=${input.sessionId}, prompt=${input.prompt?.substring(0, 50)}`)
+		try {
+			const result = await this.inner.send(input)
+			Logger.log(
+				`[VscodeSessionHost] send() completed: text=${result?.text?.substring(0, 100)}, inputTokens=${result?.usage?.inputTokens}`,
+			)
+			return result
+		} catch (error) {
+			Logger.error("[VscodeSessionHost] send() error:", error)
+			throw error
+		}
+	}
+
+	async getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined> {
+		return (await this.inner.getAccumulatedUsage(sessionId))?.usage
+	}
+
+	async abort(sessionId: string, reason?: unknown): Promise<void> {
+		try {
+			return await this.inner.abort(sessionId, reason)
+		} catch (error) {
+			// AbortError is expected when cancelling a running task —
+			// AbortController.abort() fires synchronously and may cause
+			// listeners to throw. Suppress it here so callers don't
+			// need to handle it.
+			if (error instanceof Error && (error.name === "AbortError" || error.message.toLowerCase().includes("aborted"))) {
+				Logger.debug(`[VscodeSessionHost] AbortError during abort (expected): ${sessionId}`)
+				return
+			}
+			throw error
+		}
+	}
+
+	async stop(sessionId: string): Promise<void> {
+		return this.inner.stop(sessionId)
+	}
+
+	async dispose(reason?: string): Promise<void> {
+		return this.inner.dispose(reason)
+	}
+
+	async get(sessionId: string): Promise<SessionRecord | undefined> {
+		return this.inner.get(sessionId)
+	}
+
+	async list(limit?: number, options: Omit<ClineCoreListHistoryOptions, "limit"> = {}): Promise<SessionHistoryRecord[]> {
+		return this.inner.list(limit, options)
+	}
+
+	async listHistory(options: ClineCoreListHistoryOptions = {}): Promise<SessionHistoryRecord[]> {
+		return this.inner.listHistory(options)
+	}
+
+	async delete(sessionId: string): Promise<boolean> {
+		return this.inner.delete(sessionId)
+	}
+
+	async readMessages(sessionId: string) {
+		return this.inner.readMessages(sessionId)
+	}
+
+	async updateSessionCompactionState(sessionId: string, state: SessionCompactionState): Promise<{ updated: boolean }> {
+		return this.inner.updateSessionCompactionState(sessionId, state)
+	}
+
+	async restore(input: RestoreInput): Promise<RestoreResult> {
+		return this.inner.restore(input)
+	}
+
+	async update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null
+			metadata?: Record<string, unknown> | null
+			title?: string | null
+		},
+	): Promise<{ updated: boolean }> {
+		return this.inner.update(sessionId, updates)
+	}
+
+	async handleHookEvent(payload: HookEventPayload): Promise<void> {
+		return this.inner.ingestHookEvent(payload)
+	}
+
+	pendingPrompts(action: "list", input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>
+	pendingPrompts(action: "update", input: PendingPromptsUpdateInput): Promise<PendingPromptMutationResult>
+	pendingPrompts(action: "delete", input: PendingPromptsDeleteInput): Promise<PendingPromptMutationResult>
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	pendingPrompts(action: any, input: any): any {
+		switch (action) {
+			case "list":
+				return this.inner.pendingPrompts.list(input)
+			case "update":
+				return this.inner.pendingPrompts.update(input)
+			case "delete":
+				return this.inner.pendingPrompts.delete(input)
+			default:
+				throw new Error(`Unsupported pending prompt action: ${String(action)}`)
+		}
+	}
+
+	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
+		return this.inner.subscribe(listener)
+	}
+}
diff --git a/apps/vscode/src/sdk/webview-grpc-bridge.test.ts b/apps/vscode/src/sdk/webview-grpc-bridge.test.ts
new file mode 100644
index 0000000..d817395
--- /dev/null
+++ b/apps/vscode/src/sdk/webview-grpc-bridge.test.ts
@@ -0,0 +1,129 @@
+import type { ExtensionState } from "@shared/ExtensionMessage"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { MessageTranslatorState } from "./message-translator"
+import { pushMessageToWebview, WebviewGrpcBridge } from "./webview-grpc-bridge"
+
+// Mock the gRPC streaming functions
+vi.mock("@core/controller/ui/subscribeToPartialMessage", () => ({
+	sendPartialMessageEvent: vi.fn().mockResolvedValue(undefined),
+}))
+
+vi.mock("@core/controller/state/subscribeToState", () => ({
+	sendStateUpdate: vi.fn().mockResolvedValue(undefined),
+}))
+
+// Mock the proto conversion
+vi.mock("@shared/proto-conversions/cline-message", () => ({
+	convertClineMessageToProto: vi.fn((msg: Record<string, unknown>) => ({
+		ts: msg.ts,
+		type: msg.type === "ask" ? 1 : 2,
+		ask: 0,
+		say: 0,
+		text: (msg.text as string) ?? "",
+		reasoning: (msg.reasoning as string) ?? "",
+		images: [],
+		files: [],
+		partial: (msg.partial as boolean) ?? false,
+	})),
+}))
+
+describe("WebviewGrpcBridge", () => {
+	let bridge: WebviewGrpcBridge
+	let translatorState: MessageTranslatorState
+
+	beforeEach(() => {
+		translatorState = new MessageTranslatorState()
+		bridge = new WebviewGrpcBridge(translatorState)
+		vi.clearAllMocks()
+	})
+
+	describe("createListener", () => {
+		it("should return a function", () => {
+			const listener = bridge.createListener()
+			expect(typeof listener).toBe("function")
+		})
+
+		it("should push messages through the partial message stream", async () => {
+			const { sendPartialMessageEvent } = await import("@core/controller/ui/subscribeToPartialMessage")
+			const listener = bridge.createListener()
+
+			const messages = [{ ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false }]
+			const event = { type: "status", payload: { sessionId: "s1", status: "running" } }
+
+			// biome-ignore lint/suspicious/noExplicitAny: test-only event type
+			listener(messages, event as any)
+
+			// Wait for async operations
+			await new Promise((resolve) => setTimeout(resolve, 10))
+
+			expect(sendPartialMessageEvent).toHaveBeenCalledTimes(1)
+		})
+
+		it("should push multiple messages through the stream", async () => {
+			const { sendPartialMessageEvent } = await import("@core/controller/ui/subscribeToPartialMessage")
+			const listener = bridge.createListener()
+
+			const messages = [
+				{ ts: 1, type: "say" as const, say: "text" as const, text: "first", partial: false },
+				{ ts: 2, type: "say" as const, say: "tool" as const, text: "tool call", partial: false },
+			]
+			const event = { type: "status", payload: { sessionId: "s1", status: "running" } }
+
+			// biome-ignore lint/suspicious/noExplicitAny: test-only event type
+			listener(messages, event as any)
+
+			await new Promise((resolve) => setTimeout(resolve, 10))
+
+			expect(sendPartialMessageEvent).toHaveBeenCalledTimes(2)
+		})
+	})
+
+	describe("pushStateUpdateFromController", () => {
+		it("should push state from the provided getter", async () => {
+			const { sendStateUpdate } = await import("@core/controller/state/subscribeToState")
+			const mockState = { version: "1.0.0", mode: "act" } as unknown as ExtensionState
+
+			await bridge.pushStateUpdateFromController(async () => mockState)
+
+			expect(sendStateUpdate).toHaveBeenCalledWith(mockState)
+		})
+
+		it("should handle errors from the state getter", async () => {
+			const { sendStateUpdate } = await import("@core/controller/state/subscribeToState")
+			const errorGetter = async () => {
+				throw new Error("state error")
+			}
+
+			await bridge.pushStateUpdateFromController(errorGetter)
+
+			expect(sendStateUpdate).not.toHaveBeenCalled()
+		})
+	})
+})
+
+describe("pushMessageToWebview", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("should push a single message to the webview", async () => {
+		const { sendPartialMessageEvent } = await import("@core/controller/ui/subscribeToPartialMessage")
+
+		const message = { ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false }
+
+		await pushMessageToWebview(message)
+
+		expect(sendPartialMessageEvent).toHaveBeenCalledTimes(1)
+	})
+
+	it("should handle errors gracefully", async () => {
+		const { sendPartialMessageEvent } = await import("@core/controller/ui/subscribeToPartialMessage")
+		// biome-ignore lint/suspicious/noExplicitAny: mock method not in type
+		;(sendPartialMessageEvent as any).mockRejectedValueOnce(new Error("stream error"))
+
+		const message = { ts: 1, type: "say" as const, say: "text" as const, text: "hello", partial: false }
+
+		// Should not throw
+		await pushMessageToWebview(message)
+	})
+})
diff --git a/apps/vscode/src/sdk/webview-grpc-bridge.ts b/apps/vscode/src/sdk/webview-grpc-bridge.ts
new file mode 100644
index 0000000..62805e7
--- /dev/null
+++ b/apps/vscode/src/sdk/webview-grpc-bridge.ts
@@ -0,0 +1,161 @@
+// Replaces classic message streaming from src/core/task/index.ts (see origin/main)
+//
+// Bridges SDK session events to the webview's gRPC streaming subscriptions.
+// When the SDK emits session events (text chunks, tool calls, etc.), this
+// module translates them to proto ClineMessages and pushes them through
+// the subscribeToPartialMessage and subscribeToState streams the webview
+// already listens on.
+
+import type { CoreSessionEvent } from "@cline/core"
+import { sendStateUpdate } from "@core/controller/state/subscribeToState"
+import { sendPartialMessageEvent } from "@core/controller/ui/subscribeToPartialMessage"
+import type { ClineMessage, ExtensionState } from "@shared/ExtensionMessage"
+import type { ClineMessage as ProtoClineMessage } from "@shared/proto/cline/ui"
+import { convertClineMessageToProto } from "@shared/proto-conversions/cline-message"
+import { Logger } from "@shared/services/Logger"
+import type { MessageTranslatorState } from "./message-translator"
+import type { SessionEventListener } from "./sdk-message-coordinator"
+
+/**
+ * Manages the bridge between SDK session events and webview gRPC streams.
+ *
+ * When the SDK emits events, this bridge:
+ * 1. Translates them to ClineMessage[] via the message translator
+ * 2. Converts each ClineMessage to proto format
+ * 3. Pushes them through the subscribeToPartialMessage gRPC stream
+ * 4. Pushes state updates through the subscribeToState gRPC stream
+ *    on significant events (turn complete, session ended)
+ *
+ * The bridge needs access to the controller's getStateToPostToWebview()
+ * method to push state updates that include the current task's messages
+ * and task history. Without this, state updates would have empty messages.
+ */
+export class WebviewGrpcBridge {
+	/** Function to get the full ExtensionState from the controller */
+	private getStateFn?: () => Promise<import("@shared/ExtensionMessage").ExtensionState>
+
+	constructor(_translatorState: MessageTranslatorState) {
+		// translatorState is kept as a constructor param for API compatibility
+		// but translation is done in SdkController, not in the bridge
+	}
+
+	/**
+	 * Set the function used to get ExtensionState for state updates.
+	 * This should be called after the controller is fully initialized,
+	 * passing `controller.getStateToPostToWebview.bind(controller)`.
+	 */
+	setGetStateFn(fn: () => Promise<import("@shared/ExtensionMessage").ExtensionState>): void {
+		this.getStateFn = fn
+	}
+
+	/**
+	 * Create a SessionEventListener that bridges events to the webview.
+	 * This is passed to SdkController.onSessionEvent().
+	 */
+	createListener(): SessionEventListener {
+		return (messages: ClineMessage[], event: CoreSessionEvent) => {
+			this.handleSessionEvent(messages, event)
+		}
+	}
+
+	/**
+	 * Handle a session event by pushing translated messages to webview streams.
+	 *
+	 * NOTE: The messages are already translated by SdkController.handleSessionEvent().
+	 * We do NOT re-translate here — that would double-emit messages and corrupt
+	 * the MessageTranslatorState (e.g., state.reset() on iteration_start would
+	 * clear streaming timestamps that the first translation used).
+	 */
+	private handleSessionEvent(messages: ClineMessage[], event: CoreSessionEvent): void {
+		// Push each translated message through the partial message stream
+		for (const message of messages) {
+			this.pushPartialMessage(message)
+		}
+
+		// Check if we need to push a state update based on event type.
+		// Do NOT call translateSessionEvent() again — the messages are already
+		// translated. Just check the raw event type for state update triggers.
+		const needsStateUpdate =
+			event.type === "ended" ||
+			(event.type === "agent_event" && (event.payload.event.type === "done" || event.payload.event.type === "error"))
+
+		if (needsStateUpdate) {
+			// Push state update asynchronously — don't block the event stream
+			this.pushStateUpdate().catch((err) => {
+				Logger.error("[WebviewGrpcBridge] Failed to push state update:", err)
+			})
+		}
+	}
+
+	/**
+	 * Push a ClineMessage to the webview via the subscribeToPartialMessage stream.
+	 */
+	private async pushPartialMessage(message: ClineMessage): Promise<void> {
+		try {
+			const protoMessage: ProtoClineMessage = convertClineMessageToProto(message)
+			await sendPartialMessageEvent(protoMessage)
+		} catch (error) {
+			Logger.error("[WebviewGrpcBridge] Failed to push partial message:", error)
+		}
+	}
+
+	/**
+	 * Push a state update to the webview via the subscribeToState stream.
+	 * This is called on significant events (turn complete, session ended).
+	 *
+	 * Uses the controller's getStateToPostToWebview() when available,
+	 * which includes the current task's messages and task history.
+	 * Falls back to a minimal state update without task data.
+	 */
+	private async pushStateUpdate(): Promise<void> {
+		try {
+			if (this.getStateFn) {
+				// Use the controller's getStateToPostToWebview() which
+				// includes messages, currentTaskItem, and task history
+				const state = await this.getStateFn()
+				await sendStateUpdate(state)
+			} else {
+				// Fallback: build a minimal state without task data
+				const { getStateToPostToWebview } = await import("@core/controller/state/getStateToPostToWebview")
+				const { StateManager } = await import("@core/storage/StateManager")
+				const stateManager = StateManager.get()
+				const state = await getStateToPostToWebview({
+					task: undefined,
+					stateManager,
+					mcpHub: undefined,
+					backgroundCommandRunning: false,
+					backgroundCommandTaskId: undefined,
+				})
+				await sendStateUpdate(state)
+			}
+		} catch (error) {
+			Logger.error("[WebviewGrpcBridge] Failed to push state update:", error)
+		}
+	}
+
+	/**
+	 * Push a state update using the controller's getStateToPostToWebview method.
+	 * This is the preferred way when the controller is available.
+	 */
+	async pushStateUpdateFromController(getState: () => Promise<ExtensionState>): Promise<void> {
+		try {
+			const state = await getState()
+			await sendStateUpdate(state)
+		} catch (error) {
+			Logger.error("[WebviewGrpcBridge] Failed to push state update from controller:", error)
+		}
+	}
+}
+
+/**
+ * Standalone function to push a ClineMessage to the webview.
+ * Useful for one-off messages outside the bridge's event loop.
+ */
+export async function pushMessageToWebview(message: ClineMessage): Promise<void> {
+	try {
+		const protoMessage: ProtoClineMessage = convertClineMessageToProto(message)
+		await sendPartialMessageEvent(protoMessage)
+	} catch (error) {
+		Logger.error("[WebviewGrpcBridge] Failed to push message to webview:", error)
+	}
+}
diff --git a/apps/vscode/src/sdk/workspace-root.ts b/apps/vscode/src/sdk/workspace-root.ts
new file mode 100644
index 0000000..083df47
--- /dev/null
+++ b/apps/vscode/src/sdk/workspace-root.ts
@@ -0,0 +1,3 @@
+export function resolveWorkspaceRootPath(paths: readonly string[] | undefined, noWorkspaceFallback: string): string {
+	return paths?.find((workspacePath) => workspacePath.trim().length > 0) ?? noWorkspaceFallback
+}
diff --git a/apps/vscode/src/services/EnvUtils.ts b/apps/vscode/src/services/EnvUtils.ts
new file mode 100644
index 0000000..51d994a
--- /dev/null
+++ b/apps/vscode/src/services/EnvUtils.ts
@@ -0,0 +1,40 @@
+import { HostProvider } from "@/hosts/host-provider"
+import { ExtensionRegistryInfo } from "@/registry"
+import { EmptyRequest } from "@/shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+
+// Canonical header names for extra client/host context
+const ClineHeaders = {
+	PLATFORM: "X-PLATFORM",
+	PLATFORM_VERSION: "X-PLATFORM-VERSION",
+	CLIENT_VERSION: "X-CLIENT-VERSION",
+	CLIENT_TYPE: "X-CLIENT-TYPE",
+	CORE_VERSION: "X-CORE-VERSION",
+	IS_MULTIROOT: "X-IS-MULTIROOT",
+} as const
+
+export function buildExternalBasicHeaders(): Record<string, string> {
+	return {
+		"User-Agent": `Cline/${ExtensionRegistryInfo.version}`,
+	}
+}
+
+export async function buildBasicClineHeaders(): Promise<Record<string, string>> {
+	const headers: Record<string, string> = buildExternalBasicHeaders()
+	try {
+		const host = await HostProvider.env.getHostVersion(EmptyRequest.create({}))
+		headers[ClineHeaders.PLATFORM] = host.platform || "unknown"
+		headers[ClineHeaders.PLATFORM_VERSION] = host.version || "unknown"
+		headers[ClineHeaders.CLIENT_TYPE] = host.clineType || "unknown"
+		headers[ClineHeaders.CLIENT_VERSION] = host.clineVersion || "unknown"
+	} catch (error) {
+		Logger.log("Failed to get IDE/platform info via HostBridge EnvService.getHostVersion", error)
+		headers[ClineHeaders.PLATFORM] = "unknown"
+		headers[ClineHeaders.PLATFORM_VERSION] = "unknown"
+		headers[ClineHeaders.CLIENT_TYPE] = "unknown"
+		headers[ClineHeaders.CLIENT_VERSION] = "unknown"
+	}
+	headers[ClineHeaders.CORE_VERSION] = ExtensionRegistryInfo.version
+
+	return headers
+}
diff --git a/apps/vscode/src/services/__tests__/selfHosted.test.ts b/apps/vscode/src/services/__tests__/selfHosted.test.ts
new file mode 100644
index 0000000..472db8a
--- /dev/null
+++ b/apps/vscode/src/services/__tests__/selfHosted.test.ts
@@ -0,0 +1,93 @@
+import { afterEach, describe, it } from "bun:test"
+/**
+ * Tests for selfHosted mode behavior across PostHog-based services.
+ * When ClineEndpoint.isSelfHosted() returns true, all PostHog functionality should be disabled.
+ */
+
+import * as assert from "assert"
+import * as sinon from "sinon"
+import { ClineEndpoint } from "@/config"
+import { ErrorProviderFactory } from "../error/ErrorProviderFactory"
+import { FeatureFlagsProviderFactory } from "../feature-flags/FeatureFlagsProviderFactory"
+
+describe("SelfHosted Mode - PostHog Disabling", () => {
+	let isSelfHostedStub: sinon.SinonStub
+
+	afterEach(() => {
+		if (isSelfHostedStub) {
+			isSelfHostedStub.restore()
+		}
+	})
+
+	describe("FeatureFlagsProviderFactory", () => {
+		it("should return no-op config when in selfHosted mode", () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+
+			const config = FeatureFlagsProviderFactory.getDefaultConfig()
+
+			assert.strictEqual(config.type, "no-op", "Should return no-op type in selfHosted mode")
+		})
+
+		it("should return posthog config when NOT in selfHosted mode (if PostHog config is valid)", () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(false)
+
+			const config = FeatureFlagsProviderFactory.getDefaultConfig()
+
+			// Will be "posthog" if PostHog config is valid, "no-op" otherwise
+			// The important thing is it's NOT forced to "no-op" by selfHosted check
+			assert.ok(config.type === "posthog" || config.type === "no-op", "Should not be forced to no-op")
+		})
+
+		it("should create NoOp provider when in selfHosted mode", () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+
+			const config = FeatureFlagsProviderFactory.getDefaultConfig()
+			const provider = FeatureFlagsProviderFactory.createProvider(config)
+
+			// NoOp provider should always be enabled (returns true for isEnabled)
+			assert.strictEqual(provider.isEnabled(), true, "NoOp provider should report as enabled")
+		})
+	})
+
+	describe("ErrorProviderFactory", () => {
+		it("should return no-op config when in selfHosted mode", () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+
+			const config = ErrorProviderFactory.getDefaultConfig()
+
+			assert.strictEqual(config.type, "no-op", "Should return no-op type in selfHosted mode")
+		})
+
+		it("should return posthog config when NOT in selfHosted mode", () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(false)
+
+			const config = ErrorProviderFactory.getDefaultConfig()
+
+			assert.strictEqual(config.type, "posthog", "Should return posthog type when not in selfHosted mode")
+		})
+
+		it("should create NoOp provider when in selfHosted mode", async () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+
+			const config = ErrorProviderFactory.getDefaultConfig()
+			const provider = await ErrorProviderFactory.createProvider(config)
+
+			// NoOp provider should always be enabled
+			assert.strictEqual(provider.isEnabled(), true, "NoOp provider should report as enabled")
+
+			await provider.dispose()
+		})
+	})
+
+	describe("Integration - selfHosted should disable all PostHog services", () => {
+		it("should return no-op for all PostHog-based factories when selfHosted", () => {
+			isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+
+			const featureFlagsConfig = FeatureFlagsProviderFactory.getDefaultConfig()
+			const errorConfig = ErrorProviderFactory.getDefaultConfig()
+
+			assert.strictEqual(featureFlagsConfig.type, "no-op", "FeatureFlags should be no-op in selfHosted")
+			assert.strictEqual(errorConfig.type, "no-op", "Error provider should be no-op in selfHosted")
+		})
+	})
+})
diff --git a/apps/vscode/src/services/account/ClineAccountService.ts b/apps/vscode/src/services/account/ClineAccountService.ts
new file mode 100644
index 0000000..d42d709
--- /dev/null
+++ b/apps/vscode/src/services/account/ClineAccountService.ts
@@ -0,0 +1,316 @@
+import type {
+	BalanceResponse,
+	FeaturebaseTokenResponse,
+	OrganizationBalanceResponse,
+	OrganizationUsageTransaction,
+	PaymentTransaction,
+	UsageTransaction,
+	UserRemoteConfigDiscoveryResponse,
+	UserResponse,
+} from "@shared/ClineAccount"
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios"
+import { ClineEnv } from "@/config"
+import { CLINE_API_ENDPOINT } from "@/shared/cline/api"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { AuthService } from "../auth/AuthService"
+import { buildBasicClineHeaders } from "../EnvUtils"
+
+export class ClineAccountService {
+	private static instance: ClineAccountService
+	private _authService: AuthService
+
+	constructor() {
+		this._authService = AuthService.getInstance()
+	}
+
+	/**
+	 * Returns the singleton instance of ClineAccountService
+	 * @returns Singleton instance of ClineAccountService
+	 */
+	public static getInstance(): ClineAccountService {
+		if (!ClineAccountService.instance) {
+			ClineAccountService.instance = new ClineAccountService()
+		}
+		return ClineAccountService.instance
+	}
+
+	/**
+	 * Returns the base URL for the Cline API
+	 * @returns The base URL as a string
+	 */
+	get baseUrl(): string {
+		return ClineEnv.config().apiBaseUrl
+	}
+
+	/**
+	 * Helper function to make authenticated requests to the Cline API
+	 * @param endpoint The API endpoint to call (without the base URL)
+	 * @param config Additional axios request configuration
+	 * @param options.allowNullData When true, allows response.data.data to be null without throwing.
+	 *   Callers must include `| null` in T and handle null themselves.
+	 *   Used by endpoints like /users/me/remote-config that return 200 with data: null.
+	 * @returns The API response data
+	 * @throws Error if the API key is not found or the request fails
+	 */
+	private async authenticatedRequest<T>(
+		endpoint: string,
+		config: AxiosRequestConfig = {},
+		options?: { allowNullData?: boolean; authToken?: string },
+	): Promise<T> {
+		const url = new URL(endpoint, this.baseUrl).toString() // Validate URL
+		// IMPORTANT: Prefixed with 'workos:' so backend can route verification to WorkOS provider
+		const clineAccountAuthToken = options?.authToken ?? (await this._authService.getAuthToken())
+		if (!clineAccountAuthToken) {
+			throw new Error("No Cline account auth token found")
+		}
+		const requestConfig: AxiosRequestConfig = {
+			...config,
+			headers: {
+				Authorization: `Bearer ${clineAccountAuthToken}`,
+				"Content-Type": "application/json",
+				...(await buildBasicClineHeaders()),
+				...config.headers,
+			},
+			...getAxiosSettings(),
+		}
+		const response: AxiosResponse<{ data?: T | null; error: string; success: boolean }> = await axios.request({
+			url,
+			method: "GET",
+			...requestConfig,
+		})
+		const status = response.status
+		if (status < 200 || status >= 300) {
+			throw new Error(`Request to ${endpoint} failed with status ${status}`)
+		}
+		if (typeof response.data === "object" && !response.data.success) {
+			throw new Error(`API error: ${response.data.error}`)
+		}
+		if (response.statusText === "No Content") {
+			return {} as T
+		}
+
+		const payload = response.data?.data
+		if (!response.data || typeof payload === "undefined") {
+			throw new Error(`Invalid response from ${endpoint} API`)
+		}
+		if (payload === null && !options?.allowNullData) {
+			throw new Error(`Invalid response from ${endpoint} API`)
+		}
+
+		return payload as T
+	}
+
+	/**
+	 * RPC variant that fetches the user's current credit balance without posting to webview
+	 * @returns Balance data or undefined if failed
+	 */
+	async fetchBalanceRPC(): Promise<BalanceResponse | undefined> {
+		try {
+			const me = this.getCurrentUser()
+			if (!me || !me.uid) {
+				Logger.error("Failed to fetch user ID for usage transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<BalanceResponse>(`/api/v1/users/${me.uid}/balance`)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch balance (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * RPC variant that fetches the user's usage transactions without posting to webview
+	 * @returns Usage transactions or undefined if failed
+	 */
+	async fetchUsageTransactionsRPC(): Promise<UsageTransaction[] | undefined> {
+		try {
+			const me = this.getCurrentUser()
+			if (!me || !me.uid) {
+				Logger.error("Failed to fetch user ID for usage transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<{ items: UsageTransaction[] }>(`/api/v1/users/${me.uid}/usages`)
+			return data.items
+		} catch (error) {
+			Logger.error("Failed to fetch usage transactions (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * RPC variant that fetches the user's payment transactions without posting to webview
+	 * @returns Payment transactions or undefined if failed
+	 */
+	async fetchPaymentTransactionsRPC(): Promise<PaymentTransaction[] | undefined> {
+		try {
+			const me = this.getCurrentUser()
+			if (!me || !me.uid) {
+				Logger.error("Failed to fetch user ID for usage transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<{ paymentTransactions: PaymentTransaction[] }>(
+				`/api/v1/users/${me.uid}/payments`,
+			)
+			return data.paymentTransactions
+		} catch (error) {
+			Logger.error("Failed to fetch payment transactions (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user data
+	 * @returns UserResponse or undefined if failed
+	 */
+	async fetchMe(): Promise<UserResponse | undefined> {
+		try {
+			const data = await this.authenticatedRequest<UserResponse>(CLINE_API_ENDPOINT.USER_INFO)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch user data (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches a short-lived Featurebase SSO JWT for the current user
+	 * @returns FeaturebaseTokenResponse or undefined if failed
+	 */
+	async fetchFeaturebaseToken(): Promise<FeaturebaseTokenResponse | undefined> {
+		try {
+			const data = await this.authenticatedRequest<FeaturebaseTokenResponse>(CLINE_API_ENDPOINT.FEATUREBASE_TOKEN)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch Featurebase token:", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user's organizations
+	 * @returns UserResponse["organizations"] or undefined if failed
+	 */
+	async fetchUserOrganizationsRPC(): Promise<UserResponse["organizations"] | undefined> {
+		try {
+			const me = await this.fetchMe()
+			if (!me || !me.organizations) {
+				Logger.error("Failed to fetch user organizations")
+				return undefined
+			}
+			return me.organizations
+		} catch (error) {
+			Logger.error("Failed to fetch user organizations (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user's organization credits
+	 * @returns {Promise<OrganizationBalanceResponse>} A promise that resolves to the active organization balance.
+	 */
+	async fetchOrganizationCreditsRPC(organizationId: string): Promise<OrganizationBalanceResponse | undefined> {
+		try {
+			const data = await this.authenticatedRequest<OrganizationBalanceResponse>(
+				`/api/v1/organizations/${organizationId}/balance`,
+			)
+			return data
+		} catch (error) {
+			Logger.error("Failed to fetch active organization balance (RPC):", error)
+			return undefined
+		}
+	}
+
+	/**
+	 * Fetches the current user's organization transactions
+	 * @returns {Promise<OrganizationUsageTransaction[]>} A promise that resolves to the active organization transactions.
+	 */
+	async fetchOrganizationUsageTransactionsRPC(organizationId: string): Promise<OrganizationUsageTransaction[] | undefined> {
+		try {
+			const organizations = this._authService.getUserOrganizations()
+			if (!organizations) {
+				Logger.error("Failed to get users organizations")
+				return undefined
+			}
+			const memberId = organizations.find((org) => org.organizationId === organizationId)?.memberId
+			if (!memberId) {
+				Logger.error("Failed to find member ID for active organization transactions")
+				return undefined
+			}
+			const data = await this.authenticatedRequest<{ items: OrganizationUsageTransaction[] }>(
+				`/api/v1/organizations/${organizationId}/members/${memberId}/usages`,
+			)
+			return data.items
+		} catch (error) {
+			Logger.error("Failed to fetch active organization transactions (RPC):", error)
+			return undefined
+		}
+	}
+
+	async fetchUserRemoteConfig(): Promise<UserRemoteConfigDiscoveryResponse | undefined> {
+		const token = await this._authService.getAuthToken()
+		if (!token) {
+			return undefined
+		}
+
+		const data = await this.authenticatedRequest<UserRemoteConfigDiscoveryResponse | null>(
+			CLINE_API_ENDPOINT.USER_REMOTE_CONFIG,
+			{},
+			{ allowNullData: true, authToken: token },
+		)
+		// Backend returns 200 with data: null when no org has remote config
+		return data ?? undefined
+	}
+
+	/**
+	 * Submits a spend limit increase request to the user's org admin.
+	 * Called when the user hits a SPEND_LIMIT_EXCEEDED (429) error and clicks "Request Increase".
+	 * @returns void — the backend records the request; errors are logged and swallowed
+	 */
+	async submitLimitIncreaseRequestRPC(): Promise<void> {
+		try {
+			await this.authenticatedRequest<void>("/api/v1/users/me/budget/request", {
+				method: "POST",
+			})
+		} catch (error) {
+			Logger.error("Failed to submit limit increase request (RPC):", error)
+			throw error
+		}
+	}
+
+	/**
+	 * Switches the active account to the specified organization or personal account.
+	 * @param organizationId - Optional organization ID to switch to. If not provided, it will switch to the personal account.
+	 * @returns {Promise<void>} A promise that resolves when the account switch is complete.
+	 * @throws {Error} If the account switch fails, an error will be thrown.
+	 */
+	async switchAccount(organizationId?: string | null): Promise<void> {
+		// Call API to switch account
+		try {
+			// make XHR request to switch account
+			const _response = await this.authenticatedRequest<string>(CLINE_API_ENDPOINT.ACTIVE_ACCOUNT, {
+				method: "PUT",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				data: {
+					organizationId: organizationId || null, // Pass organization if provided
+				},
+			})
+			const activeOrgId = this._authService.getActiveOrganizationId()
+			if (activeOrgId !== organizationId) {
+				// After user switches account, we will force a refresh of the id token by calling this function that restores the refresh token and retrieves new auth info
+				await this._authService.restoreRefreshTokenAndRetrieveAuthInfo()
+			}
+		} catch (error) {
+			Logger.error("Error switching account:", error)
+			await this._authService.restoreRefreshTokenAndRetrieveAuthInfo()
+			throw error
+		}
+	}
+
+	private getCurrentUser() {
+		return this._authService.getInfo().user
+	}
+}
diff --git a/apps/vscode/src/services/auth/AuthService.ts b/apps/vscode/src/services/auth/AuthService.ts
new file mode 100644
index 0000000..b032745
--- /dev/null
+++ b/apps/vscode/src/services/auth/AuthService.ts
@@ -0,0 +1,13 @@
+// Replaces classic src/services/auth/AuthService.ts (see origin/main)
+//
+// The AuthService class is now provided by the SDK adapter layer.
+// All modules that import AuthService from this path continue to work
+// because the SDK AuthService exposes the same interface.
+
+export { AuthService, type ClineAccountUserInfo } from "@/sdk/auth-service" // ServiceConfig was defined in the classic AuthService but never imported
+
+// by any other module. Re-export a compatible type for safety.
+type ServiceConfig = {
+	URI?: string
+	[key: string]: any
+}
diff --git a/apps/vscode/src/services/auth/oca/OcaAuthService.ts b/apps/vscode/src/services/auth/oca/OcaAuthService.ts
new file mode 100644
index 0000000..62f00ff
--- /dev/null
+++ b/apps/vscode/src/services/auth/oca/OcaAuthService.ts
@@ -0,0 +1,287 @@
+import { type EmptyRequest, String as ProtoString } from "@shared/proto/cline/common"
+import { OcaAuthState, OcaUserInfo } from "@shared/proto/cline/oca_account"
+import type { Controller } from "@/core/controller"
+import { getRequestRegistry, type StreamingResponseHandler } from "@/core/controller/grpc-handler"
+import { AuthHandler } from "@/hosts/external/AuthHandler"
+import { Logger } from "@/shared/services/Logger"
+import { openExternal } from "@/utils/env"
+import { LogoutReason } from "../types"
+import { OcaAuthProvider } from "./providers/OcaAuthProvider"
+import type { OcaConfig } from "./utils/types"
+import { getOcaConfig } from "./utils/utils"
+// import { AuthHandler } from "@/hosts/external/AuthHandler"
+
+export class OcaAuthService {
+	protected static instance: OcaAuthService | null = null
+	protected readonly _config: OcaConfig
+	protected _authenticated = false
+	protected _ocaAuthState: OcaAuthState | null = null
+	protected _provider: OcaAuthProvider | null = null
+	protected _controller: Controller | null = null
+	protected _refreshInFlight: Promise<void> | null = null
+	protected _interactiveLoginPending = false
+	protected _activeAuthStatusUpdateSubscriptions = new Set<{
+		controller: Controller
+		responseStream: StreamingResponseHandler<OcaAuthState>
+	}>()
+
+	protected constructor() {
+		this._config = getOcaConfig()
+		this._provider = new OcaAuthProvider(this._config)
+	}
+
+	private requireController(): Controller {
+		if (this._controller) {
+			return this._controller
+		}
+		throw new Error("Controller has not been initialized")
+	}
+
+	private requireProvider(): OcaAuthProvider {
+		if (!this._provider) {
+			throw new Error("Auth provider is not set")
+		}
+		return this._provider
+	}
+
+	/**
+	 * Initializes the singleton with a Controller.
+	 * Safe to call multiple times; updates controller on existing instance.
+	 */
+	public static initialize(controller: Controller): OcaAuthService {
+		if (!OcaAuthService.instance) {
+			OcaAuthService.instance = new OcaAuthService()
+		}
+		OcaAuthService.instance._controller = controller
+		return OcaAuthService.instance
+	}
+
+	/**
+	 * Gets the singleton instance of OcaAuthService.
+	 * Throws if not initialized. Call initialize(controller) first.
+	 */
+	public static getInstance(): OcaAuthService {
+		if (!OcaAuthService.instance || !OcaAuthService.instance._controller) {
+			throw new Error("OcaAuthService not initialized. Call OcaAuthService.initialize(controller) first.")
+		}
+		return OcaAuthService.instance
+	}
+
+	/**
+	 * Returns a current OCA authentication state.
+	 */
+	getInfo(): OcaAuthState {
+		let user: OcaUserInfo | undefined
+		if (this._ocaAuthState && this._authenticated) {
+			const userInfo = this._ocaAuthState.user
+			user = OcaUserInfo.create({
+				uid: userInfo?.uid,
+				displayName: userInfo?.displayName,
+				email: userInfo?.email,
+			})
+		}
+		return OcaAuthState.create({ user })
+	}
+
+	public get isAuthenticated(): boolean {
+		return this._authenticated
+	}
+
+	private async refreshAuthState(): Promise<void> {
+		// Single-flight to avoid concurrent refresh storms
+		if (this._refreshInFlight) {
+			await this._refreshInFlight
+			return
+		}
+		this._refreshInFlight = (async () => {
+			try {
+				await this.restoreRefreshTokenAndRetrieveAuthInfo()
+			} finally {
+				this._refreshInFlight = null
+			}
+		})()
+		await this._refreshInFlight
+	}
+
+	async getAuthToken(): Promise<string | null> {
+		this.requireController()
+		// Ensure we have a state with a token
+		if (!this._ocaAuthState || !this._ocaAuthState.apiKey) {
+			await this.refreshAuthState()
+			return this._ocaAuthState?.apiKey ?? null
+		}
+
+		const apiKey = this._ocaAuthState.apiKey
+
+		// Check if the token should be refreshed
+		let shouldRefresh = false
+		try {
+			shouldRefresh = await this.requireProvider().shouldRefreshAccessToken(apiKey)
+		} catch {
+			// If the provider check fails, err on the side of refreshing
+			shouldRefresh = true
+		}
+
+		if (shouldRefresh) {
+			await this.refreshAuthState()
+		}
+
+		return this._ocaAuthState?.apiKey ?? null
+	}
+
+	async createAuthRequest(): Promise<ProtoString> {
+		this.requireController()
+		if (this._authenticated) {
+			this.sendAuthStatusUpdate()
+			return ProtoString.create({ value: "Already authenticated" })
+		}
+		const ocaMode = this.requireController().stateManager.getGlobalSettingsKey("ocaMode") || "internal"
+		const idcsUrl = ocaMode === "external" ? this._config.external.idcs_url : this._config.internal.idcs_url
+		if (!idcsUrl) {
+			throw new Error("IDCS URI is not configured")
+		}
+		// Start the auth handler
+		const authHandler = AuthHandler.getInstance()
+		authHandler.setEnabled(true)
+		const callbackUrl = await authHandler.getCallbackUrl("/auth/oca")
+		const authUrl = this.requireProvider().getAuthUrl(callbackUrl!, ocaMode)
+		const authUrlString = authUrl?.toString() || ""
+		if (!authUrlString) {
+			throw new Error("Failed to generate authentication URL")
+		}
+		await openExternal(authUrlString)
+		return ProtoString.create({ value: authUrlString })
+	}
+
+	async handleDeauth(_: LogoutReason = LogoutReason.UNKNOWN): Promise<void> {
+		try {
+			this.clearAuth()
+			this._ocaAuthState = null
+			this._authenticated = false
+			await this.sendAuthStatusUpdate()
+		} catch (error) {
+			Logger.error("Error signing out:", error)
+			throw error
+		}
+	}
+
+	private clearAuth(): void {
+		const ctrl = this.requireController()
+		this.requireProvider().clearAuth(ctrl)
+	}
+
+	async handleAuthCallback(code: string, state: string): Promise<void> {
+		const provider = this.requireProvider()
+		const ctrl = this.requireController()
+		try {
+			this._ocaAuthState = await provider.signIn(ctrl, code, state)
+			this._authenticated = true
+			await this.sendAuthStatusUpdate()
+		} catch (error) {
+			Logger.error("Error signing in with custom token:", error)
+			throw error
+		} finally {
+			const authHandler = AuthHandler.getInstance()
+			authHandler.setEnabled(false)
+		}
+	}
+
+	async restoreRefreshTokenAndRetrieveAuthInfo(): Promise<void> {
+		const provider = this.requireProvider()
+		const ctrl = this.requireController()
+		try {
+			this._ocaAuthState = await provider.retrieveOcaAuthState(ctrl)
+			if (this._ocaAuthState) {
+				this._authenticated = true
+				await this.sendAuthStatusUpdate()
+				return
+			}
+			Logger.warn("No user found after restoring auth token")
+			await this.kickstartInteractiveLoginAsFallback()
+		} catch (error) {
+			Logger.error("Error restoring auth token:", error)
+			await this.kickstartInteractiveLoginAsFallback(error)
+		}
+	}
+
+	private async kickstartInteractiveLoginAsFallback(_err?: unknown): Promise<void> {
+		// Clear any stale secrets and broadcast unauthenticated state
+		this.clearAuth()
+		this._authenticated = false
+		this._ocaAuthState = null
+		await this.sendAuthStatusUpdate()
+
+		// Avoid repeated/looping login attempts
+		if (this._interactiveLoginPending) {
+			return
+		}
+		this._interactiveLoginPending = true
+		try {
+			// Kickstart interactive login (opens browser)
+			await this.createAuthRequest()
+			// Wait up to 60 seconds for user to complete login
+			const timeoutMs = 60_000
+			const pollMs = 250
+			const start = Date.now()
+			while (!this._authenticated && Date.now() - start < timeoutMs) {
+				await new Promise((r) => setTimeout(r, pollMs))
+			}
+			if (!this._authenticated) {
+				Logger.warn("Interactive OCA login timed out after 120 seconds")
+			}
+		} catch (e) {
+			Logger.error("Failed to initiate interactive OCA login:", e)
+		} finally {
+			this._interactiveLoginPending = false
+		}
+	}
+
+	async subscribeToAuthStatusUpdate(
+		_request: EmptyRequest,
+		responseStream: StreamingResponseHandler<OcaAuthState>,
+		requestId?: string,
+	): Promise<void> {
+		Logger.log("Subscribing to authStatusUpdate")
+		const ctrl = this.requireController()
+		if (!this._ocaAuthState) {
+			this._ocaAuthState = await this.requireProvider().getExistingAuthState(ctrl)
+			this._authenticated = !!this._ocaAuthState
+		}
+		const entry = { controller: ctrl, responseStream }
+		this._activeAuthStatusUpdateSubscriptions.add(entry)
+		const cleanup = () => {
+			this._activeAuthStatusUpdateSubscriptions.delete(entry)
+		}
+		if (requestId) {
+			getRequestRegistry().registerRequest(requestId, cleanup, { type: "authStatusUpdate_subscription" }, responseStream)
+		}
+		try {
+			await this.sendAuthStatusUpdate()
+		} catch (error) {
+			Logger.error("Error sending initial auth status:", error)
+			this._activeAuthStatusUpdateSubscriptions.delete(entry)
+		}
+	}
+
+	async sendAuthStatusUpdate(): Promise<void> {
+		if (this._activeAuthStatusUpdateSubscriptions.size === 0) {
+			return
+		}
+		const postedControllers = new Set<Controller>()
+		const promises = Array.from(this._activeAuthStatusUpdateSubscriptions).map(async (entry) => {
+			const { controller: ctrl, responseStream } = entry
+			try {
+				const authInfo: OcaAuthState = this.getInfo()
+				await responseStream(authInfo, false)
+				if (ctrl && !postedControllers.has(ctrl)) {
+					postedControllers.add(ctrl)
+					await ctrl.postStateToWebview()
+				}
+			} catch (error) {
+				Logger.error("Error sending authStatusUpdate event:", error)
+				this._activeAuthStatusUpdateSubscriptions.delete(entry)
+			}
+		})
+		await Promise.all(promises)
+	}
+}
diff --git a/apps/vscode/src/services/auth/oca/providers/OcaAuthProvider.ts b/apps/vscode/src/services/auth/oca/providers/OcaAuthProvider.ts
new file mode 100644
index 0000000..1a022d7
--- /dev/null
+++ b/apps/vscode/src/services/auth/oca/providers/OcaAuthProvider.ts
@@ -0,0 +1,239 @@
+import { OcaAuthState, OcaUserInfo } from "@shared/proto/cline/oca_account"
+import axios from "axios"
+import { jwtDecode } from "jwt-decode"
+import { Controller } from "@/core/controller"
+import { getAxiosSettings } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import type { OcaConfig } from "../utils/types"
+import { generateCodeVerifier, generateRandomString, pkceChallengeFromVerifier } from "../utils/utils"
+
+type PkceState = {
+	code_verifier: string
+	nonce: string
+	createdAt: number
+	redirect_uri: string
+}
+
+class OcaRefreshError extends Error {
+	status?: number
+	code?: string
+	invalidGrant?: boolean
+	data?: unknown
+	constructor(message: string, status?: number, code?: string, invalidGrant?: boolean, data?: unknown) {
+		super(message)
+		this.name = "OcaRefreshError"
+		this.status = status
+		this.code = code
+		this.invalidGrant = invalidGrant
+		this.data = data
+	}
+}
+
+export class OcaAuthProvider {
+	// Map state -> { code_verifier, nonce, createdAt }
+	private static pkceStateMap: Map<string, PkceState> = new Map()
+
+	protected _config: OcaConfig
+
+	constructor(config: OcaConfig) {
+		this._config = config || {}
+	}
+
+	get config(): OcaConfig {
+		return this._config
+	}
+
+	set config(value: OcaConfig) {
+		this._config = value
+	}
+
+	/**
+	 * Determines if the ID token should be refreshed.
+	 */
+	async shouldRefreshAccessToken(existingAccessToken: string): Promise<boolean> {
+		const decodedToken = this.decodeJwt(existingAccessToken)
+		const exp = decodedToken.exp || 0
+		const expirationTime = exp * 1000
+		const currentTime = Date.now()
+		const fiveMinutesInMs = 5 * 60 * 1000
+		return currentTime > expirationTime - fiveMinutesInMs
+	}
+
+	/**
+	 * Decodes a JWT token.
+	 * Subclasses can override if the logic differs from standard JWT.
+	 */
+	protected decodeJwt(token: string): any {
+		return jwtDecode(token)
+	}
+
+	private async getUserAccountInfo(token: string): Promise<OcaUserInfo> {
+		const decodedToken = this.decodeJwt(token)
+		const subject = decodedToken.sub || ""
+		return {
+			displayName: subject,
+			uid: subject,
+			email: subject,
+		}
+	}
+
+	public async getExistingAuthState(controller: Controller): Promise<OcaAuthState | null> {
+		const accessToken = controller.stateManager.getSecretKey("ocaApiKey")
+		if (accessToken && !(await this.shouldRefreshAccessToken(accessToken))) {
+			return { user: await this.getUserAccountInfo(accessToken), apiKey: accessToken }
+		}
+		return null
+	}
+
+	async retrieveOcaAuthState(controller: Controller): Promise<OcaAuthState | null> {
+		// First Check the existing access token
+		const existingAuthState = await this.getExistingAuthState(controller)
+		if (existingAuthState) {
+			return existingAuthState
+		}
+		// Otherwise, try to refresh using the refresh token
+		const userRefreshToken = controller.stateManager.getSecretKey("ocaRefreshToken")
+		if (!userRefreshToken) {
+			Logger.error("No stored authentication credential found.")
+			return null
+		}
+		try {
+			const ocaMode = controller.stateManager.getGlobalSettingsKey("ocaMode") || "internal"
+			const { idcs_url, client_id } = ocaMode === "internal" ? this._config.internal : this._config.external
+			if (!idcs_url || !client_id) {
+				throw new Error("IDCS URL or Client ID are not configured")
+			}
+			const discovery = await axios.get(`${idcs_url}/.well-known/openid-configuration`, getAxiosSettings())
+			const tokenEndpoint = discovery.data.token_endpoint
+			const params: any = {
+				grant_type: "refresh_token",
+				refresh_token: userRefreshToken,
+				client_id,
+			}
+			const tokenResponse = await axios.post(tokenEndpoint, new URLSearchParams(params), {
+				headers: { "Content-Type": "application/x-www-form-urlencoded" },
+				...getAxiosSettings(),
+			})
+			const accessToken = tokenResponse.data.access_token
+			const refreshToken = tokenResponse.data.refresh_token
+			if (refreshToken) {
+				controller.stateManager.setSecret("ocaRefreshToken", refreshToken)
+				controller.stateManager.setSecret("ocaApiKey", accessToken)
+			} else {
+				Logger.warn("No refresh token received during OCA token refresh.")
+				throw new OcaRefreshError("No refresh token received during OCA token refresh.")
+			}
+			const userInfo: OcaUserInfo = await this.getUserAccountInfo(accessToken)
+			return { user: userInfo, apiKey: accessToken }
+		} catch (err: unknown) {
+			const isAxios = (axios as any)?.isAxiosError?.(err)
+			const status = isAxios ? (err as any).response?.status : undefined
+			const data: any = isAxios ? (err as any).response?.data : undefined
+			const code = data?.error || (isAxios ? (err as any).code : undefined)
+			const desc = data?.error_description || (isAxios ? (err as any).message : undefined)
+			const invalidGrant = (status === 400 && code === "invalid_grant") || status === 401
+
+			Logger.error("OCA refresh failed", { status, code, desc })
+
+			throw new OcaRefreshError(desc || "OCA refresh failed", status, code, invalidGrant, data)
+		}
+	}
+
+	// Launch authentication flow: returns URL
+	getAuthUrl(callbackUrl: string, ocaMode: string): URL {
+		const { idcs_url, client_id, scopes } = ocaMode === "internal" ? this._config.internal : this._config.external
+		if (!idcs_url || !client_id || !scopes) {
+			throw new Error("IDCS URL, Client ID, or Scopes are not configured")
+		}
+		const code_verifier = generateCodeVerifier()
+		const code_challenge = pkceChallengeFromVerifier(code_verifier)
+		const state = generateRandomString(32)
+		const nonce = generateRandomString(32)
+		// Clean up expired PKCE entries (older than 10min)
+		const cutoff = Date.now() - 600_000
+		for (const [key, entry] of OcaAuthProvider.pkceStateMap.entries()) {
+			if (entry.createdAt < cutoff) {
+				OcaAuthProvider.pkceStateMap.delete(key)
+			}
+		}
+		OcaAuthProvider.pkceStateMap.set(state, { code_verifier, nonce, createdAt: Date.now(), redirect_uri: callbackUrl })
+		const base = idcs_url.replace(/\/$/, "") + "/oauth2/v1/authorize"
+		const url = new URL(base)
+		url.searchParams.set("client_id", client_id)
+		url.searchParams.set("response_type", "code")
+		url.searchParams.set("scope", scopes)
+		url.searchParams.set("code_challenge", code_challenge)
+		url.searchParams.set("code_challenge_method", "S256")
+		url.searchParams.set("redirect_uri", callbackUrl)
+		url.searchParams.set("state", state)
+		url.searchParams.set("nonce", nonce)
+		return url
+	}
+
+	// signIn expects code and state from the callback!
+	async signIn(controller: Controller, code: string, state: string): Promise<OcaAuthState | null> {
+		try {
+			const ocaMode = controller.stateManager.getGlobalSettingsKey("ocaMode") || "internal"
+			const { idcs_url, client_id } = ocaMode === "internal" ? this._config.internal : this._config.external
+			if (!idcs_url || !client_id) {
+				throw new Error("IDCS URL or Client ID are not configured")
+			}
+			const entry = OcaAuthProvider.pkceStateMap.get(state)
+			if (!entry) {
+				throw new Error("No PKCE verifier found for this state (possibly expired or flow not initiated)")
+			}
+			const { code_verifier, nonce, redirect_uri } = entry
+			OcaAuthProvider.pkceStateMap.delete(state)
+			const discovery = await axios.get(`${idcs_url}/.well-known/openid-configuration`, getAxiosSettings())
+			const tokenEndpoint = discovery.data.token_endpoint
+			const params: any = {
+				grant_type: "authorization_code",
+				code,
+				redirect_uri,
+				client_id,
+				code_verifier,
+			}
+			const tokenResponse = await axios.post(tokenEndpoint, new URLSearchParams(params), {
+				headers: { "Content-Type": "application/x-www-form-urlencoded" },
+				...getAxiosSettings(),
+			})
+			// Step 1: Nonce validation
+			const idToken = tokenResponse.data.id_token
+			if (idToken) {
+				const decoded: any = this.decodeJwt(idToken)
+				if (decoded.nonce !== nonce) {
+					throw new Error("OIDC nonce verification failed")
+				}
+			} else {
+				throw new Error("No ID token received from OCA")
+			}
+
+			// Step 2: Get access_token (this is what you'll use for APIs)
+			const accessToken = tokenResponse.data.access_token
+			const refreshToken = tokenResponse.data.refresh_token
+			if (refreshToken) {
+				controller.stateManager.setSecret("ocaRefreshToken", refreshToken)
+				controller.stateManager.setSecret("ocaApiKey", accessToken)
+			}
+
+			// Step 3: (Optional) Extract user info from id_token for local profile, not for API
+			const userInfo: OcaUserInfo = await this.getUserAccountInfo(idToken)
+
+			// Step 4: Return only the access_token for downstream use
+			return { user: userInfo, apiKey: accessToken }
+		} catch (error) {
+			Logger.error("oca sign-in error", "error")
+			throw error
+		}
+	}
+
+	clearAuth(controller: Controller): void {
+		controller.stateManager.setSecret("ocaApiKey", undefined)
+		controller.stateManager.setSecret("ocaRefreshToken", undefined)
+		// Clear legacy OCA secrets that may persist from older Cline versions.
+		// These are not in SecretKeys (to avoid proto field number changes) but
+		// may exist in users' secret storage and cause auth loops if not cleared.
+		controller.stateManager.setSecret("ocaAccessToken" as any, undefined)
+		controller.stateManager.setSecret("ocaTokenSet" as any, undefined)
+	}
+}
diff --git a/apps/vscode/src/services/auth/oca/utils/constants.ts b/apps/vscode/src/services/auth/oca/utils/constants.ts
new file mode 100644
index 0000000..4e18b5a
--- /dev/null
+++ b/apps/vscode/src/services/auth/oca/utils/constants.ts
@@ -0,0 +1,19 @@
+import os from "os"
+import path from "path"
+
+export const OCA_CONFIG_PATH = path.join(os.homedir(), ".oca", "config.json")
+
+export const DEFAULT_INTERNAL_IDCS_CLIENT_ID = "a8331954c0cf48ba99b5dd223a14c6ea"
+export const DEFAULT_INTERNAL_IDCS_URL = "https://idcs-9dc693e80d9b469480d7afe00e743931.identity.oraclecloud.com"
+export const DEFAULT_INTERNAL_IDSC_SCOPES = "openid offline_access"
+export const DEFAULT_INTERNAL_OCA_BASE_URL =
+	"https://code-internal.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm"
+
+export const DEFAULT_EXTERNAL_IDCS_CLIENT_ID = "c1aba3deed5740659981a752714eba33"
+export const DEFAULT_EXTERNAL_IDCS_URL = "https://login-ext.identity.oraclecloud.com"
+export const DEFAULT_EXTERNAL_IDSC_SCOPES = "openid offline_access"
+export const DEFAULT_EXTERNAL_OCA_BASE_URL = "https://code.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm"
+
+export const CHAT_COMPLETIONS_API = "CHAT_COMPLETIONS"
+export const RESPONSES_API = "RESPONSES"
+export const MESSAGES_API = "MESSAGES"
diff --git a/apps/vscode/src/services/auth/oca/utils/types.ts b/apps/vscode/src/services/auth/oca/utils/types.ts
new file mode 100644
index 0000000..95b8fc0
--- /dev/null
+++ b/apps/vscode/src/services/auth/oca/utils/types.ts
@@ -0,0 +1,12 @@
+export interface OcaConfig {
+	internal: {
+		client_id: string
+		idcs_url: string
+		scopes: string
+	}
+	external: {
+		client_id: string
+		idcs_url: string
+		scopes: string
+	}
+}
diff --git a/apps/vscode/src/services/auth/oca/utils/utils.ts b/apps/vscode/src/services/auth/oca/utils/utils.ts
new file mode 100644
index 0000000..cdcbfe5
--- /dev/null
+++ b/apps/vscode/src/services/auth/oca/utils/utils.ts
@@ -0,0 +1,152 @@
+import crypto from "crypto"
+import fs from "fs"
+import { type JwtPayload, jwtDecode } from "jwt-decode"
+import { HostProvider } from "@/hosts/host-provider"
+import { ExtensionRegistryInfo } from "@/registry"
+import {
+	DEFAULT_EXTERNAL_IDCS_CLIENT_ID,
+	DEFAULT_EXTERNAL_IDCS_URL,
+	DEFAULT_EXTERNAL_IDSC_SCOPES,
+	DEFAULT_INTERNAL_IDCS_CLIENT_ID,
+	DEFAULT_INTERNAL_IDCS_URL,
+	DEFAULT_INTERNAL_IDSC_SCOPES,
+	OCA_CONFIG_PATH,
+} from "./constants"
+import type { OcaConfig } from "./types"
+
+/**
+ * Loads OCA auth configuration, falling back to built-in defaults.
+ *
+ * Behavior:
+ * - Attempts to read a user-provided JSON config from OCA_CONFIG_PATH.
+ * - If the file is missing or invalid JSON, silently falls back to defaults.
+ * - Combines user-provided values with defaults via nullish coalescing (??).
+ *
+ * Returns the effective configuration used by OCA auth flows.
+ */
+export const getOcaConfig = (): OcaConfig => {
+	// Holds raw values loaded from the optional on-disk config.
+	// Using `any` here is intentional; we coerce into a typed OcaConfig below.
+	let cfg: any = {}
+	try {
+		// Read and parse the user config file, if present.
+		const raw = fs.readFileSync(OCA_CONFIG_PATH, "utf-8")
+		cfg = JSON.parse(raw)
+	} catch {
+		// Intentionally ignore read/parse errors and use default values instead.
+		// This keeps the auth flow resilient when no user config is provided.
+	}
+	// Overlay user-provided values onto defaults. For each field, prefer the file
+	// value if it is defined; otherwise, use the default constant.
+	const ocaConfig: OcaConfig = {
+		internal: {
+			client_id: cfg.internal_client_id ?? DEFAULT_INTERNAL_IDCS_CLIENT_ID,
+			idcs_url: cfg.internal_idcs_url ?? DEFAULT_INTERNAL_IDCS_URL,
+			scopes: cfg.internal_scopes ?? DEFAULT_INTERNAL_IDSC_SCOPES,
+		},
+		external: {
+			client_id: cfg.external_client_id ?? DEFAULT_EXTERNAL_IDCS_CLIENT_ID,
+			idcs_url: cfg.external_idcs_url ?? DEFAULT_EXTERNAL_IDCS_URL,
+			scopes: cfg.external_scopes ?? DEFAULT_EXTERNAL_IDSC_SCOPES,
+		},
+	}
+	return ocaConfig
+}
+
+// Generates a cryptographically random string (for state/nonce)
+export function generateRandomString(length = 32, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+	const randomBytes = crypto.randomBytes(length)
+	return Array.from(randomBytes)
+		.map((b) => chars[b % chars.length])
+		.join("")
+}
+
+// PKCE code verifier (high entropy)
+export function generateCodeVerifier(length = 128): string {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+	const randomBytes = crypto.randomBytes(length)
+	return Array.from(randomBytes)
+		.map((b) => chars[b % chars.length])
+		.join("")
+}
+
+// PKCE code challenge (SHA-256, base64-url)
+export function pkceChallengeFromVerifier(verifier: string): string {
+	return crypto
+		.createHash("sha256")
+		.update(verifier)
+		.digest("base64")
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=+$/, "")
+}
+
+/**
+ * Generates a compliant customer opc-request-id segment.
+ *
+ * Format (32 hex):
+ *   [token hash (8)] [taskId hash (8)] [timestamp (8)] [random (8)]
+ * - token hash:    first 4 bytes of SHA-256(token)
+ * - taskId hash:   first 4 bytes of SHA-256(taskId)
+ * - timestamp:     Unix seconds since epoch, 8 hex digits
+ * - random:        strong random, 8 hex digits
+ *
+ * Use: Send this single value as the opc-request-id header.
+ */
+async function generateOpcRequestId(taskId: string, token: string): Promise<string> {
+	async function hash8(str: string): Promise<string> {
+		const data = new TextEncoder().encode(str)
+		const hash = await crypto.subtle.digest("SHA-256", data)
+		return Array.from(new Uint8Array(hash).slice(0, 4))
+			.map((b) => b.toString(16).padStart(2, "0"))
+			.join("")
+	}
+
+	const [tokenHex, taskHex] = await Promise.all([hash8(token), hash8(taskId)])
+	const timestampHex = Math.floor(Date.now() / 1000)
+		.toString(16)
+		.padStart(8, "0")
+
+	function randomHex8(): string {
+		const arr = new Uint32Array(1)
+		crypto.getRandomValues(arr)
+		return arr[0].toString(16).padStart(8, "0")
+	}
+
+	// Compose: token(8) + task(8) + time(8) + rnd(8) = 32 hex
+	return tokenHex + taskHex + timestampHex + randomHex8()
+}
+
+/**
+ * Create headers for OCA requests
+ */
+
+export async function createOcaHeaders(accessToken: string, taskId: string): Promise<Record<string, string>> {
+	const opcRequestId = await generateOpcRequestId(taskId, accessToken)
+	const host = await HostProvider.env.getHostVersion({})
+	const clineVersion = ExtensionRegistryInfo.version
+
+	return {
+		Authorization: `Bearer ${accessToken}`,
+		"Content-Type": "application/json",
+		client: "Cline",
+		"client-version": `${clineVersion}`,
+		"client-ide": host.platform || "unknown",
+		"client-ide-version": host.version || "unknown",
+		"opc-request-id": opcRequestId,
+	}
+}
+
+/**
+ * Decodes a JWT payload without validation and returns the 'sub' claim.
+ * Use only for non-security, informational, or display purposes.
+ * @param token JWT string
+ */
+function parseJwtPayload<T extends JwtPayload>(token: string): T | null {
+	try {
+		const payload = jwtDecode<T>(token)
+		return payload
+	} catch {
+		return null
+	}
+}
diff --git a/apps/vscode/src/services/auth/types.ts b/apps/vscode/src/services/auth/types.ts
new file mode 100644
index 0000000..4860d35
--- /dev/null
+++ b/apps/vscode/src/services/auth/types.ts
@@ -0,0 +1,14 @@
+/**
+ * Enum defining different reasons why a user might be logged out
+ * Used for telemetry tracking to understand logout patterns
+ */
+export enum LogoutReason {
+	/** User explicitly clicked logout button in UI */
+	USER_INITIATED = "user_initiated",
+	/** Auth tokens were cleared in another VSCode window (cross-window sync) */
+	CROSS_WINDOW_SYNC = "cross_window_sync",
+	/** Auth provider encountered an error and cleared tokens */
+	ERROR_RECOVERY = "error_recovery",
+	/** Unknown or unspecified reason */
+	UNKNOWN = "unknown",
+}
diff --git a/apps/vscode/src/services/banner/BannerService.ts b/apps/vscode/src/services/banner/BannerService.ts
new file mode 100644
index 0000000..3f3c227
--- /dev/null
+++ b/apps/vscode/src/services/banner/BannerService.ts
@@ -0,0 +1,478 @@
+import type { Banner, BannerAction, BannerRules, BannersResponse } from "@shared/ClineBanner"
+import { BannerActionType, type BannerCardData } from "@shared/cline/banner"
+import { ClineEnv } from "@/config"
+import { Controller } from "@/core/controller"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostInfo, HostRegistryInfo } from "@/registry"
+import { fetch } from "@/shared/net"
+import { FeatureFlag } from "@/shared/services/feature-flags/feature-flags"
+import { Logger } from "@/shared/services/Logger"
+import { AuthService } from "../auth/AuthService"
+import { buildBasicClineHeaders } from "../EnvUtils"
+import { featureFlagsService } from "../feature-flags"
+
+const DEFAULT_CACHE_DURATION_MS = 24 * 60 * 60 * 1000
+const CIRCUIT_BREAKER_TIMEOUT_MS = 60 * 60 * 1000 // 1 hour
+const SERVER_ERROR_BACKOFF_MS = 15 * 60 * 1000 // 15 minutes
+const AUTH_DEBOUNCE_MS = 1000 // 1 second
+const FETCH_TIMEOUT_MS = 10000 // 10 seconds
+const MAX_CONSECUTIVE_FAILURES = 3
+
+const OS_MAP: Record<string, string> = {
+	win32: "windows",
+	linux: "linux",
+	darwin: "macos",
+}
+
+const IDE_MAP: Record<string, string> = {
+	vscode: "vscode",
+	jetbrains: "jetbrains",
+	cli: "cli",
+}
+
+const PROVIDER_ALIASES: Record<string, string[]> = {
+	anthropic: ["anthropic", "claude-code"],
+	openai: ["openai", "openai-native"],
+	qwen: ["qwen", "qwen-code"],
+}
+
+/**
+ * Service for fetching and evaluating banner messages
+ */
+export class BannerService {
+	private static instance: BannerService | null = null
+
+	private cachedBanners: Banner[] = []
+	private lastFetchTime = 0
+	private backoffUntil = 0
+	private consecutiveFailures = 0
+
+	private userId: string | null = null
+
+	private fetchPromise: Promise<Banner[]> | null = null
+	private abortController: AbortController | null = null
+
+	private debounceTimer: ReturnType<typeof setTimeout> | null = null
+	private pendingDebounceResolve: (() => void) | null = null
+	private authFetchPending = false
+
+	private readonly validActionTypes: Set<string>
+
+	private constructor(
+		private readonly controller: Controller,
+		private readonly hostInfo: HostInfo,
+	) {
+		this.validActionTypes = new Set(Object.values(BannerActionType))
+		Logger.log("[BannerService] initialized")
+	}
+
+	public static initialize(controller: Controller): BannerService {
+		if (BannerService.instance) {
+			return BannerService.instance
+		}
+		const hostInfo = HostRegistryInfo.get()
+		if (!hostInfo) {
+			throw new Error("[BannerService] Ensure HostRegistryInfo is initialized before BannerService.")
+		}
+		BannerService.instance = new BannerService(controller, hostInfo)
+		return BannerService.instance
+	}
+
+	public static get(): BannerService {
+		if (!BannerService.instance) {
+			throw new Error("BannerService not initialized. Call BannerService.initialize(controller) first.")
+		}
+		return BannerService.instance
+	}
+
+	public static reset(): void {
+		const instance = BannerService.instance
+		if (instance) {
+			if (instance.debounceTimer) {
+				clearTimeout(instance.debounceTimer)
+				instance.debounceTimer = null
+			}
+			if (instance.pendingDebounceResolve) {
+				instance.pendingDebounceResolve()
+				instance.pendingDebounceResolve = null
+			}
+			instance.abortController?.abort()
+			instance.abortController = null
+			instance.fetchPromise = null
+			instance.authFetchPending = false
+		}
+		BannerService.instance = null
+	}
+
+	public static async onAuthUpdate(userId: string | null): Promise<void> {
+		const instance = BannerService.instance
+
+		if (!instance || instance.userId === userId) return
+
+		// Clear existing debounce timer and resolve any pending promise
+		if (instance.debounceTimer) {
+			clearTimeout(instance.debounceTimer)
+			instance.debounceTimer = null
+		}
+		if (instance.pendingDebounceResolve) {
+			instance.pendingDebounceResolve()
+			instance.pendingDebounceResolve = null
+		}
+
+		// Cancel any in-progress fetch immediately - we'll fetch with the new token after debounce
+		instance.abortController?.abort()
+		instance.abortController = null
+		instance.fetchPromise = null
+
+		// Set pending flag immediately to prevent getActiveBanners() from starting a fetch
+		// while we're waiting for the debounce to settle
+		instance.authFetchPending = true
+		instance.userId = userId
+
+		return new Promise<void>((resolve) => {
+			instance.pendingDebounceResolve = resolve
+			instance.debounceTimer = setTimeout(async () => {
+				instance.debounceTimer = null
+				instance.pendingDebounceResolve = null
+
+				instance.consecutiveFailures = 0
+				instance.backoffUntil = 0
+
+				try {
+					await instance.doFetch()
+					Logger.info("[BannerService] Fetched")
+				} finally {
+					instance.authFetchPending = false
+					resolve()
+				}
+			}, AUTH_DEBOUNCE_MS)
+		})
+	}
+
+	public getActiveBanners(): BannerCardData[] {
+		this.ensureFreshCache()
+
+		const activeBanners = this.cachedBanners
+			.filter((b) => b.placement !== "welcome")
+			.filter((b) => !this.isBannerDismissed(b.id))
+			.map((b) => this.toBannerCardData(b))
+			.filter((b): b is BannerCardData => b !== null)
+
+		return activeBanners
+	}
+
+	/**
+	 * Returns welcome banners (placement === "welcome") for the What's New modal.
+	 * These are version-targeted banners fetched from the backend.
+	 * Gated by REMOTE_WELCOME_BANNERS feature flag — when off, returns empty
+	 * so the webview falls back to hardcoded welcome items.
+	 */
+	public getWelcomeBanners(): BannerCardData[] | undefined {
+		const isLocal = process.env.IS_DEV === "true" || process.env.CLINE_ENVIRONMENT === "local"
+		const flagEnabled = isLocal || featureFlagsService.getBooleanFlagEnabled(FeatureFlag.REMOTE_WELCOME_BANNERS)
+
+		if (!flagEnabled) {
+			return undefined
+		}
+		const bypassDismissals = process.env.IS_DEV === "true" || process.env.CLINE_ENVIRONMENT === "local"
+
+		this.ensureFreshCache()
+
+		const welcomeCandidates = this.cachedBanners.filter((b) => b.placement === "welcome")
+
+		const welcomeBanners = welcomeCandidates
+			.filter((b) => bypassDismissals || !this.isBannerDismissed(b.id))
+			.map((b) => this.toBannerCardData(b))
+			.filter((b): b is BannerCardData => b !== null)
+
+		return welcomeBanners
+	}
+
+	/**
+	 * Testing hook for draining in-flight background fetch work deterministically.
+	 */
+	public async drainForTesting(): Promise<void> {
+		await this.fetchPromise
+	}
+
+	private ensureFreshCache(): void {
+		const now = Date.now()
+		const cacheDurationMs = this.getCacheDurationMs()
+		const shouldFetch =
+			now >= this.backoffUntil &&
+			now - this.lastFetchTime >= cacheDurationMs &&
+			!this.fetchPromise &&
+			!this.authFetchPending
+
+		if (shouldFetch) {
+			this.fetchPromise = this.doFetch()
+			this.fetchPromise.finally(() => {
+				this.fetchPromise = null
+			})
+		}
+	}
+
+	private getCacheDurationMs(): number {
+		const flagPayload = featureFlagsService.getFlagPayload(FeatureFlag.EXTENSION_REMOTE_BANNERS_TTL)
+		const ms = typeof flagPayload === "number" && Number.isFinite(flagPayload) ? flagPayload : DEFAULT_CACHE_DURATION_MS
+		if (!Number.isFinite(ms) || ms <= 0) return DEFAULT_CACHE_DURATION_MS
+		return ms
+	}
+
+	public clearCache(): void {
+		this.abortController?.abort()
+		this.abortController = null
+		this.cachedBanners = []
+		this.lastFetchTime = 0
+		this.consecutiveFailures = 0
+		this.backoffUntil = 0
+		this.fetchPromise = null
+		Logger.log("BannerService: Cache cleared and circuit breaker reset")
+	}
+
+	public async dismissBanner(bannerId: string): Promise<void> {
+		try {
+			const dismissed = StateManager.get().getGlobalStateKey("dismissedBanners") || []
+			if (dismissed.some((b) => b.bannerId === bannerId)) return
+
+			StateManager.get().setGlobalState("dismissedBanners", [...dismissed, { bannerId, dismissedAt: Date.now() }])
+
+			await this.sendBannerEvent(bannerId, "dismiss")
+			this.clearCache()
+		} catch (error) {
+			Logger.error("[BannerService] Error dismissing banner", error)
+		}
+	}
+
+	public async sendBannerEvent(bannerId: string, eventType: "dismiss"): Promise<void> {
+		try {
+			const url = new URL("/banners/v2/messages", ClineEnv.config().apiBaseUrl).toString()
+			const ideType = this.getIdeType()
+			const surface = ideType === "cli" ? "cli" : ideType === "jetbrains" ? "jetbrains" : "vscode"
+
+			const controller = new AbortController()
+			const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+
+			await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...(await buildBasicClineHeaders()),
+				},
+				body: JSON.stringify({
+					banner_id: bannerId,
+					instance_id: this.hostInfo.distinctId,
+					surface,
+					event_type: eventType,
+				}),
+				signal: controller.signal,
+			})
+
+			clearTimeout(timeoutId)
+			Logger.log(`[BannerService] Sent ${eventType} event for banner ${bannerId}`)
+		} catch (error) {
+			Logger.error("[BannerService] Error sending banner event", error)
+		}
+	}
+
+	public isBannerDismissed(bannerId: string): boolean {
+		try {
+			const dismissed = StateManager.get().getGlobalStateKey("dismissedBanners") || []
+			return dismissed.some((b) => b.bannerId === bannerId)
+		} catch (error) {
+			Logger.error("[BannerService] Error checking dismissed banner", error)
+			return false
+		}
+	}
+
+	private async doFetch(): Promise<Banner[]> {
+		// Do not fetch banners when feature flag is off
+		if (!featureFlagsService.getBooleanFlagEnabled(FeatureFlag.REMOTE_BANNERS)) {
+			return []
+		}
+
+		this.abortController = new AbortController()
+		const { signal } = this.abortController
+		const timeoutId = setTimeout(() => this.abortController?.abort(), FETCH_TIMEOUT_MS)
+
+		try {
+			const url = this.buildFetchUrl()
+			const headers: Record<string, string> = {
+				"Content-Type": "application/json",
+				...(await buildBasicClineHeaders()),
+			}
+			const authToken = await AuthService.getInstance().getAuthToken()
+			if (authToken) {
+				headers.Authorization = `Bearer ${authToken}`
+			}
+
+			const response = await fetch(url, { method: "GET", headers, signal })
+			clearTimeout(timeoutId)
+
+			if (!response.ok) {
+				throw Object.assign(new Error(`HTTP ${response.status}`), {
+					status: response.status,
+					headers: response.headers,
+				})
+			}
+
+			const data = (await response.json()) as BannersResponse
+			if (!data?.data?.items || !Array.isArray(data.data.items)) {
+				Logger.log("BannerService: Invalid response format")
+				return []
+			}
+
+			Logger.log(
+				`[BannerService] Raw API response: ${data.data.items.length} items: ${JSON.stringify(
+					data.data.items.map((b) => ({ id: b.id, placement: b.placement, titleMd: b.titleMd?.substring(0, 50) })),
+				)}`,
+			)
+
+			const banners = data.data.items.filter((b) => this.matchesProviderRule(b))
+			this.cachedBanners = banners
+			this.lastFetchTime = Date.now()
+			this.consecutiveFailures = 0
+
+			Logger.log(
+				`[BannerService] After provider filter: ${banners.length} banners: ${JSON.stringify(
+					banners.map((b) => ({ id: b.id, placement: b.placement })),
+				)}`,
+			)
+
+			this.controller.postStateToWebview().catch((error) => {
+				Logger.error("Failed to post state to webview after fetching banners:", error)
+			})
+
+			Logger.log(`[BannerService] Fetched ${banners.length} banner(s) at ${new Date(this.lastFetchTime).toISOString()}`)
+			return banners
+		} catch (error) {
+			clearTimeout(timeoutId)
+
+			if (error instanceof Error && error.name === "AbortError") {
+				return this.cachedBanners
+			}
+
+			this.handleFetchError(error)
+			return this.cachedBanners
+		} finally {
+			this.abortController = null
+		}
+	}
+
+	private handleFetchError(error: unknown): void {
+		this.consecutiveFailures++
+
+		const typedError = error as { status?: number; headers?: { get(name: string): string | null } }
+		const status = typedError.status
+
+		let backoffMs = CIRCUIT_BREAKER_TIMEOUT_MS
+
+		if (status === 429) {
+			const retryAfter = typedError.headers?.get("retry-after")
+			if (retryAfter) {
+				const seconds = Number.parseInt(retryAfter, 10)
+				if (!Number.isNaN(seconds)) {
+					backoffMs = seconds * 1000
+				} else {
+					const date = new Date(retryAfter)
+					if (!Number.isNaN(date.getTime())) {
+						backoffMs = Math.max(0, date.getTime() - Date.now())
+					}
+				}
+			}
+		} else if (status && status >= 500 && status < 600) {
+			backoffMs = SERVER_ERROR_BACKOFF_MS
+		}
+
+		this.backoffUntil = Date.now() + backoffMs
+
+		if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+			this.backoffUntil = Date.now() + CIRCUIT_BREAKER_TIMEOUT_MS
+			const msg =
+				this.consecutiveFailures === MAX_CONSECUTIVE_FAILURES ? "Circuit breaker tripped" : "Half-open recovery failed"
+			Logger.log(`BannerService: ${msg}, will allow recovery attempt after 1 hour`)
+		}
+
+		Logger.error(
+			`[BannerService] Failed ${this.consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}. ` +
+				`Backing off for ${Math.ceil(backoffMs / 60000)} minutes`,
+			error,
+		)
+	}
+
+	private buildFetchUrl(): string {
+		const url = new URL("/banners/v2/messages", ClineEnv.config().apiBaseUrl)
+		url.searchParams.set("ide", this.getIdeType())
+		url.searchParams.set("extension_version", this.hostInfo.extensionVersion)
+		url.searchParams.set("os", OS_MAP[this.hostInfo.os] || "unknown")
+		return url.toString()
+	}
+
+	private getIdeType(): string {
+		const ide = this.hostInfo.ide?.toLowerCase() ?? ""
+		for (const [key, value] of Object.entries(IDE_MAP)) {
+			if (ide.includes(key)) return value
+		}
+
+		const platform = this.hostInfo.platform?.toLowerCase() ?? ""
+		if (platform.includes("visual studio") || platform.includes("vscode")) {
+			return "vscode"
+		}
+		return "unknown"
+	}
+
+	private matchesProviderRule(banner: Banner): boolean {
+		try {
+			const rules: BannerRules = JSON.parse(banner.rulesJson || "{}")
+			if (!rules?.providers?.length) return true
+
+			const config = StateManager.get().getApiConfiguration()
+			const mode = StateManager.get().getGlobalSettingsKey("mode")
+			const provider = mode === "plan" ? config?.planModeApiProvider : config?.actModeApiProvider
+
+			return rules.providers.some((ruleProvider) => {
+				// Check if ruleProvider is an alias for the selected provider
+				for (const [_, aliases] of Object.entries(PROVIDER_ALIASES)) {
+					if (aliases.includes(ruleProvider)) {
+						return aliases.includes(provider as string)
+					}
+				}
+				return provider === ruleProvider
+			})
+		} catch (error) {
+			Logger.log(
+				`[BannerService] Error parsing provider rules for banner ${banner.id}: ` +
+					`${error instanceof Error ? error.message : String(error)}`,
+			)
+			return true // Fail open
+		}
+	}
+
+	private getBannerActions(banner: Banner): BannerAction[] {
+		return banner.actions ?? []
+	}
+
+	private toBannerCardData(banner: Banner): BannerCardData | null {
+		const actions = this.getBannerActions(banner)
+
+		// Validate all actions have valid types
+		for (const action of actions) {
+			if (!action.action || !this.validActionTypes.has(action.action) || !action.title) {
+				Logger.error(`[BannerService] Invalid action type (${action.action}) for banner ${banner.id}`)
+				return null
+			}
+		}
+
+		return {
+			id: banner.id,
+			title: banner.titleMd,
+			description: banner.bodyMd,
+			icon: banner.icon,
+			actions: actions.map((a) => ({
+				title: a.title || "",
+				action: a.action as BannerActionType,
+				arg: a.arg,
+			})),
+		}
+	}
+}
diff --git a/apps/vscode/src/services/banner/__tests__/BannerService.test.ts b/apps/vscode/src/services/banner/__tests__/BannerService.test.ts
new file mode 100644
index 0000000..6f92780
--- /dev/null
+++ b/apps/vscode/src/services/banner/__tests__/BannerService.test.ts
@@ -0,0 +1,1293 @@
+/**
+ * Tests for BannerService
+ * Tests API fetching, caching, auth updates, and rate limit backoff
+ */
+
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import type { BannerRules } from "@shared/ClineBanner"
+import { expect } from "chai"
+import * as sinon from "sinon"
+import { ClineEnv, Environment } from "@/config"
+import { Controller } from "@/core/controller"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostRegistryInfo } from "@/registry"
+import { AuthService } from "@/services/auth/AuthService"
+import { getFeatureFlagsService } from "@/services/feature-flags"
+import { mockFetchForTesting } from "@/shared/net"
+import { FeatureFlag } from "@/shared/services/feature-flags/feature-flags"
+import { Logger } from "@/shared/services/Logger"
+import { BannerService } from "../BannerService"
+
+describe("BannerService", () => {
+	let sandbox: sinon.SinonSandbox
+	let mockFetch: sinon.SinonStub
+	let token: string | null = "fake-token"
+
+	// Default mock state manager configuration
+	let mockStateManagerConfig: {
+		apiConfiguration: Record<string, unknown>
+		mode: string | undefined
+		dismissedBanners: Array<{ bannerId: string; dismissedAt: number }>
+	}
+
+	let mockedPostStateToWebview: sinon.SinonStub
+	let mockController: Controller
+	let flagPayloadStub: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		mockedPostStateToWebview = sandbox.stub().resolves(undefined)
+		mockController = {
+			postStateToWebview: mockedPostStateToWebview,
+		} as any
+
+		sandbox.stub(Logger, "log")
+		sandbox.stub(Logger, "error")
+
+		// Mock feature flag service to enable remote banners
+		sandbox.stub(getFeatureFlagsService(), "getBooleanFlagEnabled").returns(true)
+		flagPayloadStub = sandbox
+			.stub(getFeatureFlagsService(), "getFlagPayload")
+			.callsFake((flag: FeatureFlag) =>
+				flag === FeatureFlag.EXTENSION_REMOTE_BANNERS_TTL ? 24 * 60 * 60 * 1000 : undefined,
+			)
+
+		// Default state manager configuration
+		mockStateManagerConfig = {
+			apiConfiguration: {},
+			mode: undefined,
+			dismissedBanners: [],
+		}
+
+		// Mock StateManager.get() to return our mock
+		sandbox.stub(StateManager, "get").returns({
+			getApiConfiguration: () => mockStateManagerConfig.apiConfiguration,
+			getGlobalSettingsKey: (key: string) => (key === "mode" ? mockStateManagerConfig.mode : undefined),
+			getGlobalStateKey: (key: string) => (key === "dismissedBanners" ? mockStateManagerConfig.dismissedBanners : []),
+			setGlobalState: (key: string, value: unknown) => {
+				if (key === "dismissedBanners") {
+					mockStateManagerConfig.dismissedBanners = value as Array<{ bannerId: string; dismissedAt: number }>
+				}
+			},
+		} as unknown as StateManager)
+
+		// Mock HostRegistryInfo.get() to return mock host info
+		sandbox.stub(HostRegistryInfo, "get").returns({
+			extensionVersion: "1.0.0",
+			platform: "darwin",
+			os: "darwin",
+			ide: "vscode",
+			distinctId: "test-distinct-id",
+		})
+
+		// Mock ClineEnv.config() to return a valid config
+		sandbox.stub(ClineEnv, "config").returns({
+			environment: Environment.production,
+			appBaseUrl: "https://app.cline-mock.bot",
+			apiBaseUrl: "https://api.cline-mock.bot",
+			mcpBaseUrl: "https://api.cline-mock.bot/v1/mcp",
+		})
+
+		const authService = AuthService.getInstance()
+		token = "fake-token"
+		sandbox.replace(authService, "getAuthToken", () => Promise.resolve(token))
+
+		// Create mock fetch
+		mockFetch = sandbox.stub()
+
+		// Reset singleton
+		BannerService.reset()
+	})
+
+	afterEach(() => {
+		BannerService.reset()
+		sandbox.restore()
+	})
+
+	// Helper to create a successful fetch response
+	function createSuccessResponse(data: unknown) {
+		return {
+			ok: true,
+			status: 200,
+			json: async () => data,
+		}
+	}
+
+	// Helper to create an error fetch response
+	function createErrorResponse(status: number) {
+		return {
+			ok: false,
+			status,
+			json: async () => ({}),
+		}
+	}
+
+	async function flushBannerServiceWork(clock: sinon.SinonFakeTimers, bannerService?: BannerService) {
+		await clock.tickAsync(0)
+		if (bannerService) {
+			await bannerService.drainForTesting()
+		}
+		await clock.tickAsync(0)
+	}
+
+	function useBannerFakeTimers() {
+		return sandbox.useFakeTimers({
+			now: Date.now(),
+			shouldClearNativeTimers: true,
+		})
+	}
+
+	describe("API Fetching", () => {
+		it("should fetch banners from API successfully", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test1",
+							titleMd: "Test Banner",
+							bodyMd: "This is a test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners() // Triggers background fetch
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(mockFetch.calledOnce).to.be.true
+				const banners = bannerService.getActiveBanners() // Get banners after fetch completes
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_test1")
+				expect(banners[0].title).to.equal("Test Banner")
+				expect(banners[0].description).to.equal("This is a test")
+			})
+		})
+
+		it("should handle API errors gracefully", async () => {
+			mockFetch.rejects(new Error("Network error"))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				const banners = bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(banners).to.have.lengthOf(0)
+			})
+		})
+
+		it("should cache banners for the configured hours from PostHog", async () => {
+			const clock = useBannerFakeTimers()
+			flagPayloadStub.callsFake((flag: FeatureFlag) =>
+				flag === FeatureFlag.EXTENSION_REMOTE_BANNERS_TTL ? 4 * 60 * 60 * 1000 : undefined,
+			)
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_cached",
+							titleMd: "Cached Banner",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+
+				// Trigger initial fetch by calling getActiveBanners (fires background fetch)
+				bannerService.getActiveBanners()
+				// Wait for the background fetch to complete
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// Second call within cache window uses cache (no new API call)
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// After 1 hour, still uses cache
+				await clock.tickAsync(60 * 60 * 1000)
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// After 3 hours total, still uses cache
+				await clock.tickAsync(2 * 60 * 60 * 1000)
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// After 5 hours total, cache expired, triggers new background fetch
+				await clock.tickAsync(2 * 60 * 60 * 1000)
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(2)
+			})
+
+			clock.restore()
+		})
+
+		it("should fall back to 24 hours when payload is invalid", async () => {
+			const clock = useBannerFakeTimers()
+			flagPayloadStub.callsFake((flag: FeatureFlag) =>
+				flag === FeatureFlag.EXTENSION_REMOTE_BANNERS_TTL ? "invalid" : undefined,
+			)
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_cached",
+							titleMd: "Cached Banner",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				await clock.tickAsync(23 * 60 * 60 * 1000)
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				await clock.tickAsync(2 * 60 * 60 * 1000)
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(2)
+			})
+
+			clock.restore()
+		})
+	})
+
+	describe("API Provider Rule Evaluation (Client-Side)", () => {
+		it("should show banner when user has selected the required API provider in act mode", async () => {
+			mockStateManagerConfig.apiConfiguration = { actModeApiProvider: "openai" }
+			mockStateManagerConfig.mode = "act"
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_openai",
+							titleMd: "OpenAI Users",
+							bodyMd: "For OpenAI API",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: JSON.stringify({ providers: ["openai"] } as BannerRules),
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_openai")
+			})
+		})
+
+		it("should show banner when user has selected the required API provider in plan mode", async () => {
+			mockStateManagerConfig.apiConfiguration = { planModeApiProvider: "anthropic" }
+			mockStateManagerConfig.mode = "plan"
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_anthropic",
+							titleMd: "Anthropic Users",
+							bodyMd: "For Anthropic API",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: JSON.stringify({ providers: ["anthropic"] } as BannerRules),
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_anthropic")
+			})
+		})
+
+		it("should NOT show banner when user has selected a different API provider", async () => {
+			mockStateManagerConfig.apiConfiguration = { actModeApiProvider: "anthropic" }
+			mockStateManagerConfig.mode = "act"
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_openai",
+							titleMd: "OpenAI Users",
+							bodyMd: "For OpenAI API",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: JSON.stringify({ providers: ["openai"] } as BannerRules),
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(0)
+			})
+		})
+
+		it("should show banner if user has selected ANY of multiple specified providers", async () => {
+			mockStateManagerConfig.apiConfiguration = { actModeApiProvider: "anthropic" }
+			mockStateManagerConfig.mode = "act"
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_multi",
+							titleMd: "Multiple Providers",
+							bodyMd: "For Anthropic or OpenAI users",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: JSON.stringify({ providers: ["anthropic", "openai"] } as BannerRules),
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_multi")
+			})
+		})
+
+		it("should NOT show banner when no provider is selected", async () => {
+			mockStateManagerConfig.apiConfiguration = {}
+			mockStateManagerConfig.mode = "act"
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_openai",
+							titleMd: "OpenAI Users",
+							bodyMd: "For OpenAI API",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: JSON.stringify({ providers: ["openai"] } as BannerRules),
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(0)
+			})
+		})
+	})
+
+	describe("Invalid or No Banner Rules", () => {
+		it("should handle malformed rules gracefully (fail open)", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_malformed",
+							titleMd: "Malformed",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{ invalid json",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+			})
+		})
+
+		it("should handle banners with no rules", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_norules",
+							titleMd: "No Rules",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_norules")
+			})
+		})
+	})
+
+	describe("Cache Management", () => {
+		it("should clear cache when requested", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test",
+							titleMd: "Test",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+				expect(mockFetch.calledOnce).to.be.true
+
+				bannerService.clearCache()
+
+				bannerService.getActiveBanners()
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+				expect(mockFetch.calledTwice).to.be.true
+			})
+		})
+	})
+
+	describe("OS Parameter Integration", () => {
+		it("should send OS parameter in API request", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test",
+							titleMd: "Test Banner",
+							bodyMd: "This is a test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(mockFetch.calledOnce).to.be.true
+				const call = mockFetch.getCall(0)
+				const url = call.args[0]
+				expect(url).to.include("os=")
+			})
+		})
+	})
+
+	describe("Banner to BannerCardData Conversion", () => {
+		it("should convert banner with valid action types", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_valid_actions",
+							titleMd: "Valid Actions Banner",
+							bodyMd: "Has valid actions",
+							icon: "lightbulb",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: [
+								{ title: "Link", action: "link", arg: "https://example.com" },
+								{ title: "Settings", action: "show-api-settings" },
+							],
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_valid_actions")
+				expect(banners[0].title).to.equal("Valid Actions Banner")
+				expect(banners[0].description).to.equal("Has valid actions")
+				expect(banners[0].icon).to.equal("lightbulb")
+				expect(banners[0].actions).to.have.lengthOf(2)
+				expect(banners[0].actions![0].title).to.equal("Link")
+				expect(banners[0].actions![0].action).to.equal("link")
+				expect(banners[0].actions![0].arg).to.equal("https://example.com")
+				expect(banners[0].actions![1].title).to.equal("Settings")
+				expect(banners[0].actions![1].action).to.equal("show-api-settings")
+			})
+		})
+
+		it("should drop banner with invalid action type and log error", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_invalid_action",
+							titleMd: "Invalid Action Banner",
+							bodyMd: "Has invalid action type",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: [{ title: "Invalid", action: "unknown-action-type", arg: "test" }],
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(0)
+			})
+		})
+
+		it("should keep valid banners and drop only invalid ones", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_valid",
+							titleMd: "Valid Banner",
+							bodyMd: "This one is valid",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: [{ title: "Link", action: "link", arg: "https://example.com" }],
+						},
+						{
+							id: "bnr_invalid",
+							titleMd: "Invalid Banner",
+							bodyMd: "This one has invalid action",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: [{ title: "Bad", action: "not-a-real-action" }],
+						},
+						{
+							id: "bnr_also_valid",
+							titleMd: "Also Valid Banner",
+							bodyMd: "This one is also valid",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(2)
+				expect(banners[0].id).to.equal("bnr_valid")
+				expect(banners[1].id).to.equal("bnr_also_valid")
+			})
+		})
+
+		it("should convert banner with no actions", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_no_actions",
+							titleMd: "No Actions Banner",
+							bodyMd: "Has no actions",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_no_actions")
+				expect(banners[0].actions).to.have.lengthOf(0)
+			})
+		})
+
+		it("should convert banner with empty actions array", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_empty_actions",
+							titleMd: "Empty Actions Banner",
+							bodyMd: "Has empty actions array",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: [],
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].id).to.equal("bnr_empty_actions")
+				expect(banners[0].actions).to.have.lengthOf(0)
+			})
+		})
+
+		it("should drop banner when action has undefined action type", async () => {
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_undefined_action",
+							titleMd: "Undefined Action Type",
+							bodyMd: "Action has no type defined",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: [{ title: "Just a label" }],
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(banners).to.have.lengthOf(0)
+			})
+		})
+
+		it("should accept all valid BannerActionType values", async () => {
+			const validActionTypes = [
+				"link",
+				"show-api-settings",
+				"show-feature-settings",
+				"show-account",
+				"set-model",
+				"install-cli",
+			]
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_all_valid_types",
+							titleMd: "All Valid Types",
+							bodyMd: "Has all valid action types",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+							actions: validActionTypes.map((type, index) => ({
+								title: `Action ${index}`,
+								action: type,
+							})),
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				const banners = bannerService.getActiveBanners()
+				expect(mockedPostStateToWebview.called).to.be.true
+				expect(banners).to.have.lengthOf(1)
+				expect(banners[0].actions).to.have.lengthOf(validActionTypes.length)
+				banners[0].actions!.forEach((action, index) => {
+					expect(action.action).to.equal(validActionTypes[index])
+				})
+			})
+		})
+	})
+
+	describe("IDE Type Detection", () => {
+		function stubHostInfo(overrides: { ide?: string; platform?: string }) {
+			;(HostRegistryInfo.get as sinon.SinonStub).returns({
+				extensionVersion: "1.0.0",
+				platform: overrides.platform ?? "darwin",
+				os: "darwin",
+				ide: overrides.ide ?? "vscode",
+				distinctId: "test-distinct-id",
+			})
+		}
+
+		async function getIdeParam(fetch: sinon.SinonStub): Promise<string> {
+			const url = new URL(fetch.getCall(fetch.callCount - 1).args[0])
+			return url.searchParams.get("ide") ?? ""
+		}
+
+		const emptyResponse = { data: { items: [] } }
+
+		it('should return "vscode" when ide contains "vscode"', async () => {
+			stubHostInfo({ ide: "vscode" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("vscode")
+			})
+		})
+
+		it('should return "vscode" when ide is "VSCode Extension" (case-insensitive)', async () => {
+			stubHostInfo({ ide: "VSCode Extension" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("vscode")
+			})
+		})
+
+		it('should return "jetbrains" when ide contains "jetbrains"', async () => {
+			stubHostInfo({ ide: "jetbrains" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("jetbrains")
+			})
+		})
+
+		it('should return "jetbrains" when ide is "Cline for JetBrains" (case-insensitive)', async () => {
+			stubHostInfo({ ide: "Cline for JetBrains" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("jetbrains")
+			})
+		})
+
+		it('should return "cli" when ide contains "cli"', async () => {
+			stubHostInfo({ ide: "cli" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("cli")
+			})
+		})
+
+		it('should fall back to "vscode" when ide is empty but platform contains "Visual Studio"', async () => {
+			stubHostInfo({ ide: "", platform: "Visual Studio Code 1.103.0" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("vscode")
+			})
+		})
+
+		it('should fall back to "vscode" when ide is empty but platform contains "vscode"', async () => {
+			stubHostInfo({ ide: "", platform: "vscode" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("vscode")
+			})
+		})
+
+		it('should return "unknown" when both ide and platform are unrecognized', async () => {
+			stubHostInfo({ ide: "some-random-ide", platform: "some-random-platform" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("unknown")
+			})
+		})
+
+		it('should return "unknown" when both ide and platform are empty', async () => {
+			stubHostInfo({ ide: "", platform: "" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("unknown")
+			})
+		})
+
+		it("should prefer ide field over platform field for detection", async () => {
+			stubHostInfo({ ide: "Cline for JetBrains", platform: "Visual Studio Code 1.103.0" })
+			mockFetch.resolves(createSuccessResponse(emptyResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+				await new Promise((resolve) => setTimeout(resolve, 10))
+
+				expect(await getIdeParam(mockFetch)).to.equal("jetbrains")
+			})
+		})
+	})
+
+	describe("Rate Limit Backoff (429)", () => {
+		it("should trigger backoff on 429 response and return cached banners during backoff", async () => {
+			const clock = useBannerFakeTimers()
+
+			// First, cache a banner
+			const successResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_cached",
+							titleMd: "Cached Banner",
+							bodyMd: "This is cached",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(successResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// Expire cache
+				await clock.tickAsync(25 * 60 * 60 * 1000)
+
+				// Simulate 429 error
+				mockFetch.resolves(createErrorResponse(429))
+
+				// This call triggers 429
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+
+				const banners1 = bannerService.getActiveBanners()
+				expect(banners1).to.have.lengthOf(1) // Returns cached
+				expect(mockFetch.callCount).to.equal(2)
+			})
+
+			clock.restore()
+		})
+	})
+
+	describe("onAuthUpdate", () => {
+		it("should update the user id and trigger fetch after debounce", async () => {
+			const clock = useBannerFakeTimers()
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test",
+							titleMd: "Test Banner",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				// Initialize the service
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// Call onAuthUpdate with a new token
+				const authPromise = BannerService.onAuthUpdate("new-user-id")
+				await clock.tickAsync(1000) // Advance past debounce (AUTH_DEBOUNCE_MS)
+				await authPromise
+				await flushBannerServiceWork(clock, bannerService)
+
+				// Should have triggered a new fetch
+				expect(mockFetch.callCount).to.equal(2)
+
+				// Verify the auth header was included
+				const lastCall = mockFetch.getCall(1)
+				const options = lastCall.args[1]
+				expect(options.headers.Authorization).to.equal(`Bearer ${token}`)
+			})
+
+			clock.restore()
+		})
+
+		it("should clear pending retry timeout on auth update", async () => {
+			const clock = useBannerFakeTimers()
+
+			const successResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test",
+							titleMd: "Test",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(successResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// Expire cache and trigger a rate limit
+				await clock.tickAsync(25 * 60 * 60 * 1000)
+				mockFetch.resolves(createErrorResponse(429))
+				bannerService.getActiveBanners()
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(2)
+
+				// Now update auth - should clear the retry timeout
+				// Note: onAuthUpdate has 1000ms debounce (AUTH_DEBOUNCE_MS), so we need to advance the clock
+				mockFetch.resolves(createSuccessResponse(successResponse))
+				const authPromise = BannerService.onAuthUpdate("user-id")
+				await clock.tickAsync(1000) // Advance past debounce
+				await authPromise
+				await flushBannerServiceWork(clock, bannerService)
+
+				expect(mockFetch.callCount).to.equal(3)
+
+				// The scheduled retry (1 hour later) should have been cancelled
+				// If we advance time, there shouldn't be another fetch from the old retry
+				await clock.tickAsync(2 * 60 * 60 * 1000) // 2 hours
+				expect(mockFetch.callCount).to.equal(3) // No additional fetch from old retry
+			})
+
+			clock.restore()
+		})
+
+		it("should handle auth update when service is not initialized", async () => {
+			// Ensure service is not initialized
+			BannerService.reset()
+
+			// This should not throw (onAuthUpdate will initialize the service)
+			let error: Error | null = null
+			try {
+				await BannerService.onAuthUpdate("user-id")
+			} catch (e) {
+				error = e as Error
+			}
+			expect(error).to.be.null
+		})
+
+		it("should handle null user-id (logout)", async () => {
+			const clock = useBannerFakeTimers()
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test",
+							titleMd: "Test",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				// Set a user id first
+				const authPromise1 = BannerService.onAuthUpdate("usr-id")
+				await clock.tickAsync(1000) // Advance past debounce
+				await authPromise1
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(2)
+
+				// Now logout (null user id)
+				token = null
+				const authPromise2 = BannerService.onAuthUpdate(null)
+				await clock.tickAsync(1000) // Advance past debounce
+				await authPromise2
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(3)
+
+				// Verify no auth header on last call
+				const lastCall = mockFetch.getCall(2)
+				const options = lastCall.args[1]
+				expect(options.headers.Authorization).to.be.undefined
+			})
+
+			clock.restore()
+		})
+
+		it("should debounce rapid auth updates", async () => {
+			const clock = useBannerFakeTimers()
+
+			const mockResponse = {
+				data: {
+					items: [
+						{
+							id: "bnr_test",
+							titleMd: "Test Banner",
+							bodyMd: "Test",
+							severity: "info" as const,
+							placement: "top" as const,
+							rulesJson: "{}",
+						},
+					],
+				},
+			}
+
+			mockFetch.resolves(createSuccessResponse(mockResponse))
+
+			await mockFetchForTesting(mockFetch, async () => {
+				// Initialize the service
+				const bannerService = BannerService.initialize(mockController)
+				bannerService.getActiveBanners()
+
+				// Wait for background fetch to complete
+				await flushBannerServiceWork(clock, bannerService)
+				expect(mockFetch.callCount).to.equal(1)
+
+				const updatedToken = "test-updated-token"
+				token = updatedToken
+
+				// Simulate rapid auth updates during startup (common scenario)
+				const promise1 = BannerService.onAuthUpdate("usr-1")
+				const promise2 = BannerService.onAuthUpdate("usr-2")
+				const promise3 = BannerService.onAuthUpdate("usr-3")
+
+				// Advance past debounce period and allow async callback to complete
+				// The debounce timer fires at 1000ms (AUTH_DEBOUNCE_MS), then we need additional ticks for the async fetch
+				await clock.tickAsync(1000)
+				await flushBannerServiceWork(clock, bannerService)
+
+				// Wait for all promises to resolve
+				await Promise.all([promise1, promise2, promise3])
+
+				// Should only have made ONE additional fetch (debounced), not three
+				expect(mockFetch.callCount).to.equal(2)
+
+				// Verify the token was used
+				const lastCall = mockFetch.getCall(1)
+				const options = lastCall.args[1]
+				expect(options.headers.Authorization).to.equal(`Bearer ${updatedToken}`)
+			})
+
+			clock.restore()
+		})
+	})
+})
diff --git a/apps/vscode/src/services/browser/BrowserDiscovery.ts b/apps/vscode/src/services/browser/BrowserDiscovery.ts
new file mode 100644
index 0000000..e676d49
--- /dev/null
+++ b/apps/vscode/src/services/browser/BrowserDiscovery.ts
@@ -0,0 +1,103 @@
+import axios from "axios"
+import * as net from "net"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Check if a port is open on a given host
+ */
+export async function isPortOpen(host: string, port: number, timeout = 1000): Promise<boolean> {
+	return new Promise((resolve) => {
+		const socket = new net.Socket()
+		let status = false
+
+		// Set timeout
+		socket.setTimeout(timeout)
+
+		// Handle successful connection
+		socket.on("connect", () => {
+			status = true
+			socket.destroy()
+		})
+
+		// Handle any errors
+		socket.on("error", () => {
+			socket.destroy()
+		})
+
+		// Handle timeout
+		socket.on("timeout", () => {
+			socket.destroy()
+		})
+
+		// Handle close
+		socket.on("close", () => {
+			resolve(status)
+		})
+
+		// Attempt to connect
+		socket.connect(port, host)
+	})
+}
+
+/**
+ * Try to connect to Chrome at a specific IP address
+ */
+async function tryConnect(ipAddress: string): Promise<{ endpoint: string; ip: string } | null> {
+	try {
+		const response = await axios.get(`http://${ipAddress}:9222/json/version`, { timeout: 1000 })
+		const data = response.data
+		return { endpoint: data.webSocketDebuggerUrl, ip: ipAddress }
+	} catch (_error) {
+		return null
+	}
+}
+
+/**
+ * Discover Chrome instances (localhost only)
+ */
+export async function discoverChromeInstances(): Promise<string | null> {
+	// Only try localhost
+	const ipAddresses = ["localhost", "127.0.0.1"]
+
+	// Try connecting to each IP address
+	for (const ip of ipAddresses) {
+		const connection = await tryConnect(ip)
+		if (connection) {
+			return `http://${connection.ip}:9222`
+		}
+	}
+
+	return null
+}
+
+/**
+ * Test connection to a remote browser
+ */
+export async function testBrowserConnection(host: string): Promise<{ success: boolean; message: string; endpoint?: string }> {
+	try {
+		// Fetch the WebSocket endpoint from the Chrome DevTools Protocol
+		const versionUrl = `${host.replace(/\/$/, "")}/json/version`
+
+		const response = await axios.get(versionUrl, { timeout: 3000 })
+		const browserWSEndpoint = response.data.webSocketDebuggerUrl
+
+		if (!browserWSEndpoint) {
+			return {
+				success: false,
+				message: "Could not find webSocketDebuggerUrl in the response",
+			}
+		}
+
+		return {
+			success: true,
+			message: "Successfully connected to Chrome browser",
+			endpoint: browserWSEndpoint,
+		}
+	} catch (error) {
+		Logger.error(`Failed to connect to remote browser: ${error}`)
+		return {
+			success: false,
+			message: `Failed to connect: ${error instanceof Error ? error.message : String(error)}`,
+		}
+	}
+}
diff --git a/apps/vscode/src/services/browser/BrowserSession.ts b/apps/vscode/src/services/browser/BrowserSession.ts
new file mode 100644
index 0000000..d41c351
--- /dev/null
+++ b/apps/vscode/src/services/browser/BrowserSession.ts
@@ -0,0 +1,602 @@
+import { setTimeout as setTimeoutPromise } from "node:timers/promises"
+import { Controller } from "@core/controller"
+import { BrowserActionResult } from "@shared/ExtensionMessage"
+import { fileExistsAtPath } from "@utils/fs"
+import axios from "axios"
+import { spawn } from "child_process"
+import * as chromeLauncher from "chrome-launcher"
+import os from "os"
+import pWaitFor from "p-wait-for"
+import * as path from "path"
+// @ts-ignore
+import type { LoggerMessage, ScreenshotOptions } from "puppeteer-core"
+import { Browser, connect, launch, Page, TimeoutError } from "puppeteer-core"
+import { StateManager } from "@/core/storage/StateManager"
+import { telemetryService } from "@/services/telemetry"
+import { Logger } from "@/shared/services/Logger"
+import { discoverChromeInstances, isPortOpen, testBrowserConnection } from "./BrowserDiscovery"
+import { ensureChromiumExists } from "./utils"
+
+// Define browser connection info interface
+export interface BrowserConnectionInfo {
+	isConnected: boolean
+	isRemote: boolean
+	host?: string
+}
+
+const DEBUG_PORT = 9222 // Chrome's default debugging port
+
+// helper function required to append custom browser arguments from UI
+function splitArgs(str?: string | null): string[] {
+	if (!str) {
+		return []
+	}
+	// split on spaces but keep quoted chunks; strip quotes
+	return (str.match(/"[^"]+"|\S+/g) || []).map((s) => s.replace(/^"(.*)"$/, "$1"))
+}
+
+export class BrowserSession {
+	private browser?: Browser
+	private page?: Page
+	private currentMousePosition?: string
+	private cachedWebSocketEndpoint?: string
+	private lastConnectionAttempt: number = 0
+	private isConnectedToRemote: boolean = false
+	private useWebp: boolean
+
+	// Telemetry tracking properties
+	private sessionStartTime: number = 0
+	private browserActions: string[] = []
+	private ulid?: string
+	private stateManager: StateManager
+
+	constructor(stateManager: StateManager, useWebp: boolean = true) {
+		this.stateManager = stateManager
+		this.useWebp = useWebp
+	}
+
+	// Tests remote browser connection
+	async testConnection(host: string): Promise<{ success: boolean; message: string; endpoint?: string }> {
+		return testBrowserConnection(host)
+	}
+
+	/**
+	 * Get current browser connection information
+	 */
+	getConnectionInfo(): BrowserConnectionInfo {
+		return {
+			isConnected: !!this.browser,
+			isRemote: this.isConnectedToRemote,
+			host: this.isConnectedToRemote
+				? this.stateManager.getGlobalSettingsKey("browserSettings").remoteBrowserHost
+				: undefined,
+		}
+	}
+
+	async getDetectedChromePath(): Promise<{ path: string; isBundled: boolean }> {
+		// First check browserSettings (from UI, stored in global state)
+		const browserSettings = this.stateManager.getGlobalSettingsKey("browserSettings")
+		if (browserSettings.chromeExecutablePath && (await fileExistsAtPath(browserSettings.chromeExecutablePath))) {
+			return {
+				path: browserSettings.chromeExecutablePath,
+				isBundled: false,
+			}
+		}
+
+		// Then try to find system Chrome
+		try {
+			const systemPath = chromeLauncher.Launcher.getFirstInstallation()
+			// Add validation to ensure path is not in Trash - This can happen on Mac OS due to the way the chrome-launcher library works
+			if (systemPath && !systemPath.includes(".Trash") && (await fileExistsAtPath(systemPath))) {
+				return { path: systemPath, isBundled: false }
+			}
+		} catch (error) {
+			Logger.info("Could not find system Chrome:", error)
+		}
+
+		// Finally fall back to PCR's bundled version
+		const stats = await ensureChromiumExists()
+		return { path: stats.executablePath, isBundled: true }
+	}
+
+	async relaunchChromeDebugMode(_controller: Controller): Promise<string> {
+		try {
+			const userDataDir = path.join(os.tmpdir(), "chrome-debug-profile")
+			const installation = chromeLauncher.Launcher.getFirstInstallation()
+			if (!installation) {
+				throw new Error("Could not find Chrome installation on this system")
+			}
+			Logger.info("chrome installation", installation)
+
+			const userArgs = splitArgs(this.stateManager.getGlobalSettingsKey("browserSettings").customArgs)
+
+			const args = [
+				`--remote-debugging-port=${DEBUG_PORT}`,
+				`--user-data-dir=${userDataDir}`,
+				"--disable-notifications",
+				...userArgs,
+				"chrome://newtab",
+			]
+
+			// Spawn Chrome as a detached process
+			const chromeProcess = spawn(installation, args, {
+				detached: true, // This is key - makes the process independent of parent
+				stdio: "ignore", // Detach stdio to prevent hanging
+				shell: false, // Don't run in a shell
+			})
+
+			// Unref the process to allow Node to exit independently
+			chromeProcess.unref()
+
+			// Wait a moment to ensure Chrome has time to start
+			await new Promise((resolve) => setTimeout(resolve, 1000))
+
+			// Test if Chrome is actually running with debug port
+			const isRunning = await isPortOpen("localhost", DEBUG_PORT, 2000)
+
+			if (!isRunning) {
+				throw new Error("Chrome was launched but debug port is not responding")
+			}
+
+			return `Browser successfully launched with debug mode\nUsing: ${installation}`
+		} catch (error) {
+			throw new Error(`Failed to relaunch Chrome: ${error instanceof Error ? error.message : globalThis.String(error)}`)
+		}
+	}
+
+	/**
+	 * Set the ULID for telemetry tracking
+	 * @param ulid The task ID to associate with browser actions
+	 */
+	setUlid(ulid: string) {
+		this.ulid = ulid
+	}
+
+	async launchBrowser() {
+		if (this.browser) {
+			await this.closeBrowser() // this may happen when the model launches a browser again after having used it already before
+		}
+
+		// Reset tracking properties
+		this.sessionStartTime = Date.now()
+		this.browserActions = []
+
+		// Reset remote connection status
+		this.isConnectedToRemote = false
+
+		const browserSettings = this.stateManager.getGlobalSettingsKey("browserSettings")
+
+		if (browserSettings.remoteBrowserEnabled) {
+			Logger.log(`launch browser called -- remote host mode (non-headless)`)
+			try {
+				await this.launchRemoteBrowser()
+				// Don't create a new page here, as we'll create it in launchRemoteBrowser
+
+				// Send telemetry for browser tool start
+				if (this.ulid) {
+					telemetryService.captureBrowserToolStart(this.ulid, browserSettings)
+				}
+
+				return
+			} catch (error) {
+				Logger.error("Failed to launch remote browser, falling back to local mode:", error)
+
+				// Capture error telemetry
+				if (this.ulid) {
+					telemetryService.captureBrowserError(
+						this.ulid,
+						"remote_browser_launch_error",
+						error instanceof Error ? error.message : String(error),
+						{
+							isRemote: true,
+							remoteBrowserHost: browserSettings.remoteBrowserHost,
+						},
+					)
+				}
+
+				await this.launchLocalBrowser()
+			}
+		} else {
+			Logger.log(`launch browser called -- local mode (headless)`)
+			await this.launchLocalBrowser()
+		}
+
+		this.page = await this.browser?.newPage()
+
+		// Send telemetry for browser tool start
+		if (this.ulid) {
+			telemetryService.captureBrowserToolStart(this.ulid, browserSettings)
+		}
+	}
+
+	async launchLocalBrowser() {
+		const browserSettings = this.stateManager.getGlobalSettingsKey("browserSettings")
+		const { path } = await this.getDetectedChromePath()
+		const userArgs = splitArgs(browserSettings.customArgs)
+		this.browser = await launch({
+			args: [
+				"--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+				...userArgs,
+			],
+			executablePath: path,
+			defaultViewport: browserSettings.viewport,
+			headless: "shell", // Always use headless mode for local connections
+		})
+		this.isConnectedToRemote = false
+	}
+
+	async launchRemoteBrowser() {
+		const browserSettings = this.stateManager.getGlobalSettingsKey("browserSettings")
+		let remoteBrowserHost = browserSettings.remoteBrowserHost
+		let browserWSEndpoint: string | undefined = this.cachedWebSocketEndpoint
+		let _reconnectionAttempted = false
+
+		const getViewport = () => {
+			return browserSettings.viewport
+		}
+
+		// First try auto-discovery if no host is provided
+		if (!remoteBrowserHost) {
+			try {
+				Logger.info("No remote browser host provided, trying auto-discovery")
+				const discoveredHost = await discoverChromeInstances()
+
+				if (discoveredHost) {
+					Logger.info(`Auto-discovered Chrome at ${discoveredHost}`)
+					remoteBrowserHost = discoveredHost
+				}
+			} catch (error) {
+				Logger.log(`Auto-discovery failed: ${error}`)
+			}
+		}
+
+		// Try to connect with cached endpoint first if it exists and is recent (less than 1 hour old)
+		if (browserWSEndpoint && Date.now() - this.lastConnectionAttempt < 3600000) {
+			try {
+				Logger.info(`Attempting to connect using cached WebSocket endpoint: ${browserWSEndpoint}`)
+				this.browser = await connect({
+					browserWSEndpoint,
+					defaultViewport: getViewport(),
+				})
+				this.page = await this.browser?.newPage()
+				this.isConnectedToRemote = true
+				return
+			} catch (error) {
+				Logger.log(`Failed to connect using cached endpoint: ${error}`)
+
+				// Capture error telemetry
+				if (this.ulid) {
+					telemetryService.captureBrowserError(
+						this.ulid,
+						"cached_endpoint_connection_error",
+						error instanceof Error ? error.message : String(error),
+						{
+							isRemote: true,
+							endpoint: browserWSEndpoint,
+						},
+					)
+				}
+
+				// Clear the cached endpoint since it's no longer valid
+				this.cachedWebSocketEndpoint = undefined
+				// User wants to give up after one reconnection attempt
+				if (remoteBrowserHost) {
+					_reconnectionAttempted = true
+				}
+			}
+		}
+
+		// Try to connect with host (either user-provided or auto-discovered)
+		if (remoteBrowserHost) {
+			try {
+				// Fetch the WebSocket endpoint from the Chrome DevTools Protocol
+				const versionUrl = `${remoteBrowserHost.replace(/\/$/, "")}/json/version`
+				Logger.info(`Fetching WebSocket endpoint from ${versionUrl}`)
+
+				const response = await axios.get(versionUrl)
+				browserWSEndpoint = response.data.webSocketDebuggerUrl
+
+				if (!browserWSEndpoint) {
+					throw new Error("Could not find webSocketDebuggerUrl in the response")
+				}
+
+				Logger.info(`Found WebSocket browser endpoint: ${browserWSEndpoint}`)
+
+				// Cache the successful endpoint
+				this.cachedWebSocketEndpoint = browserWSEndpoint
+				this.lastConnectionAttempt = Date.now()
+
+				this.browser = await connect({
+					browserWSEndpoint,
+					defaultViewport: getViewport(),
+				})
+				this.page = await this.browser?.newPage()
+				this.isConnectedToRemote = true
+				return
+			} catch (error) {
+				Logger.log(`Failed to connect to remote browser: ${error}`)
+
+				// Capture error telemetry
+				if (this.ulid) {
+					telemetryService.captureBrowserError(
+						this.ulid,
+						"remote_host_connection_error",
+						error instanceof Error ? error.message : String(error),
+						{
+							isRemote: true,
+							remoteBrowserHost,
+						},
+					)
+				}
+			}
+		}
+
+		// If we get here, all connection attempts failed
+		throw new Error(
+			"Failed to connect to remote browser. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
+		)
+	}
+
+	async closeBrowser(): Promise<BrowserActionResult> {
+		if (this.browser || this.page) {
+			// Send telemetry for browser tool end if we have a task ID and session was started
+			if (this.ulid && this.sessionStartTime > 0) {
+				const sessionDuration = Date.now() - this.sessionStartTime
+				telemetryService.captureBrowserToolEnd(this.ulid, {
+					actionCount: this.browserActions.length,
+					duration: sessionDuration,
+					actions: this.browserActions,
+				})
+			}
+
+			if (this.isConnectedToRemote && this.browser) {
+				// Close the page/tab first if it exists
+				if (this.page) {
+					await this.page.close().catch(() => {})
+					Logger.info("closed remote browser tab...")
+				}
+				await this.browser.disconnect().catch(() => {})
+				Logger.info("disconnected from remote browser...")
+				// do not close the browser
+			} else if (this.isConnectedToRemote === false) {
+				await this.browser?.close().catch(() => {})
+				Logger.info("closed local browser...")
+			}
+
+			this.browser = undefined
+			this.page = undefined
+			this.currentMousePosition = undefined
+			this.isConnectedToRemote = false
+
+			// Reset tracking properties
+			this.sessionStartTime = 0
+			this.browserActions = []
+		}
+		return {}
+	}
+
+	async doAction(action: (page: Page) => Promise<void>): Promise<BrowserActionResult> {
+		if (!this.page) {
+			throw new Error(
+				"Browser is not launched. This may occur if the browser was automatically closed by a non-`browser_action` tool.",
+			)
+		}
+
+		const logs: string[] = []
+		let lastLogTs = Date.now()
+
+		const LoggerListener = (msg: LoggerMessage) => {
+			if (msg.type() === "log") {
+				logs.push(msg.text())
+			} else {
+				logs.push(`[${msg.type()}] ${msg.text()}`)
+			}
+			lastLogTs = Date.now()
+		}
+
+		const errorListener = (err: Error) => {
+			logs.push(`[Page Error] ${err.toString()}`)
+			lastLogTs = Date.now()
+		}
+
+		// Add the listeners
+		this.page.on("Logger", LoggerListener)
+		this.page.on("pageerror", errorListener)
+
+		try {
+			await action(this.page)
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err)
+
+			if (!(err instanceof TimeoutError)) {
+				logs.push(`[Error] ${errorMessage}`)
+
+				// Capture error telemetry
+				if (this.ulid) {
+					telemetryService.captureBrowserError(this.ulid, "browser_action_error", errorMessage, {
+						isRemote: this.isConnectedToRemote,
+						action: this.browserActions[this.browserActions.length - 1],
+					})
+				}
+			}
+		}
+
+		// Wait for Logger inactivity, with a timeout
+		await pWaitFor(() => Date.now() - lastLogTs >= 500, {
+			timeout: 3_000,
+			interval: 100,
+		}).catch(() => {})
+
+		const options: ScreenshotOptions = {
+			encoding: "base64",
+
+			// clip: {
+			// 	x: 0,
+			// 	y: 0,
+			// 	width: 900,
+			// 	height: 600,
+			// },
+		}
+
+		const screenshotType = this.useWebp ? "webp" : "png"
+		let screenshotBase64 = await this.page.screenshot({
+			...options,
+			type: screenshotType,
+		})
+		let screenshot = `data:image/${screenshotType};base64,${screenshotBase64}`
+
+		if (!screenshotBase64) {
+			// choosing to try screenshot again, regardless of the initial type
+			Logger.info(`${screenshotType} screenshot failed, trying png`)
+			screenshotBase64 = await this.page.screenshot({
+				...options,
+				type: "png",
+			})
+			screenshot = `data:image/png;base64,${screenshotBase64}`
+		}
+
+		if (!screenshotBase64) {
+			// Capture error telemetry
+			if (this.ulid) {
+				telemetryService.captureBrowserError(this.ulid, "screenshot_error", "Failed to take screenshot", {
+					isRemote: this.isConnectedToRemote,
+					action: this.browserActions[this.browserActions.length - 1],
+				})
+			}
+			throw new Error("Failed to take screenshot.")
+		}
+
+		// this.page.removeAllListeners() <- causes the page to crash!
+		this.page.off("Logger", LoggerListener)
+		this.page.off("pageerror", errorListener)
+
+		return {
+			screenshot,
+			logs: logs.join("\n"),
+			currentUrl: this.page.url(),
+			currentMousePosition: this.currentMousePosition,
+		}
+	}
+
+	async navigateToUrl(url: string): Promise<BrowserActionResult> {
+		this.browserActions.push(`navigate: url`)
+
+		return this.doAction(async (page) => {
+			// networkidle2 isn't good enough since page may take some time to load. we can assume locally running dev sites will reach networkidle0 in a reasonable amount of time
+			await page.goto(url, {
+				timeout: 7_000,
+				waitUntil: ["domcontentloaded", "networkidle2"],
+			})
+			// await page.goto(url, { timeout: 10_000, waitUntil: "load" })
+			await this.waitTillHTMLStable(page) // in case the page is loading more resources
+		})
+	}
+
+	// page.goto { waitUntil: "networkidle0" } may not ever resolve, and not waiting could return page content too early before js has loaded
+	// https://stackoverflow.com/questions/52497252/puppeteer-wait-until-page-is-completely-loaded/61304202#61304202
+	private async waitTillHTMLStable(page: Page, timeout = 5_000) {
+		const checkDurationMsecs = 500 // 1000
+		const maxChecks = timeout / checkDurationMsecs
+		let lastHTMLSize = 0
+		let checkCounts = 1
+		let countStableSizeIterations = 0
+		const minStableSizeIterations = 3
+
+		while (checkCounts++ <= maxChecks) {
+			const html = await page.content()
+			const currentHTMLSize = html.length
+
+			// let bodyHTMLSize = await page.evaluate(() => document.body.innerHTML.length)
+			Logger.info("last: ", lastHTMLSize, " <> curr: ", currentHTMLSize)
+
+			if (lastHTMLSize !== 0 && currentHTMLSize === lastHTMLSize) {
+				countStableSizeIterations++
+			} else {
+				countStableSizeIterations = 0 //reset the counter
+			}
+
+			if (countStableSizeIterations >= minStableSizeIterations) {
+				Logger.info("Page rendered fully...")
+				break
+			}
+
+			lastHTMLSize = currentHTMLSize
+			await setTimeoutPromise(checkDurationMsecs)
+		}
+	}
+
+	async click(coordinate: string): Promise<BrowserActionResult> {
+		this.browserActions.push(`click: coordinate`)
+
+		const [x, y] = coordinate.split(",").map(Number)
+		return this.doAction(async (page) => {
+			// Set up network request monitoring
+			let hasNetworkActivity = false
+			const requestListener = () => {
+				hasNetworkActivity = true
+			}
+			page.on("request", requestListener)
+
+			// Perform the click
+			await page.mouse.click(x, y)
+			this.currentMousePosition = coordinate
+
+			// Small delay to check if click triggered any network activity
+			await setTimeoutPromise(100)
+
+			if (hasNetworkActivity) {
+				// If we detected network activity, wait for navigation/loading
+				await page
+					.waitForNavigation({
+						waitUntil: ["domcontentloaded", "networkidle2"],
+						timeout: 7000,
+					})
+					.catch(() => {})
+				await this.waitTillHTMLStable(page)
+			}
+
+			// Clean up listener
+			page.off("request", requestListener)
+		})
+	}
+
+	async type(text: string): Promise<BrowserActionResult> {
+		this.browserActions.push(`type:${text.length} chars`)
+
+		return this.doAction(async (page) => {
+			await page.keyboard.type(text)
+		})
+	}
+
+	async scrollDown(): Promise<BrowserActionResult> {
+		this.browserActions.push("scrollDown")
+
+		return this.doAction(async (page) => {
+			await page.evaluate(() => {
+				window.scrollBy({
+					top: 600,
+					behavior: "auto",
+				})
+			})
+			await setTimeoutPromise(300)
+		})
+	}
+
+	async scrollUp(): Promise<BrowserActionResult> {
+		this.browserActions.push("scrollUp")
+
+		return this.doAction(async (page) => {
+			await page.evaluate(() => {
+				window.scrollBy({
+					top: -600,
+					behavior: "auto",
+				})
+			})
+			await setTimeoutPromise(300)
+		})
+	}
+
+	async dispose() {
+		await this.closeBrowser()
+	}
+}
diff --git a/apps/vscode/src/services/browser/UrlContentFetcher.ts b/apps/vscode/src/services/browser/UrlContentFetcher.ts
new file mode 100644
index 0000000..e3b64a9
--- /dev/null
+++ b/apps/vscode/src/services/browser/UrlContentFetcher.ts
@@ -0,0 +1,63 @@
+import * as cheerio from "cheerio"
+import { Browser, Page } from "puppeteer-core"
+import TurndownService from "turndown"
+import { StateManager } from "@/core/storage/StateManager"
+import { ensureChromiumExists } from "./utils"
+
+export class UrlContentFetcher {
+	private browser?: Browser
+	private page?: Page
+
+	async launchBrowser(): Promise<void> {
+		if (this.browser) {
+			return
+		}
+		const stats = await ensureChromiumExists()
+		// Read browser settings from globalState for custom args only
+		const browserSettings = StateManager.get().getGlobalSettingsKey("browserSettings")
+		const customArgsStr = browserSettings.customArgs || ""
+		const customArgs = customArgsStr.trim() ? customArgsStr.split(/\s+/) : []
+		this.browser = await stats.puppeteer.launch({
+			args: [
+				"--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+				...customArgs, // Append user-provided custom arguments
+			],
+			executablePath: stats.executablePath,
+		})
+		// (latest version of puppeteer does not add headless to user agent)
+		this.page = await this.browser?.newPage()
+	}
+
+	async closeBrowser(): Promise<void> {
+		await this.browser?.close()
+		this.browser = undefined
+		this.page = undefined
+	}
+
+	// must make sure to call launchBrowser before and closeBrowser after using this
+	async urlToMarkdown(url: string): Promise<string> {
+		if (!this.browser || !this.page) {
+			throw new Error("Browser not initialized")
+		}
+		/*
+		- networkidle2 is equivalent to playwright's networkidle where it waits until there are no more than 2 network connections for at least 500 ms.
+		- domcontentloaded is when the basic DOM is loaded
+		this should be sufficient for most doc sites
+		*/
+		await this.page.goto(url, {
+			timeout: 10_000,
+			waitUntil: ["domcontentloaded", "networkidle2"],
+		})
+		const content = await this.page.content()
+
+		// use cheerio to parse and clean up the HTML
+		const $ = cheerio.load(content)
+		$("script, style, nav, footer, header").remove()
+
+		// convert cleaned HTML to markdown
+		const turndownService = new TurndownService()
+		const markdown = turndownService.turndown($.html())
+
+		return markdown
+	}
+}
diff --git a/apps/vscode/src/services/browser/utils.ts b/apps/vscode/src/services/browser/utils.ts
new file mode 100644
index 0000000..860ffbe
--- /dev/null
+++ b/apps/vscode/src/services/browser/utils.ts
@@ -0,0 +1,26 @@
+import { fileExistsAtPath } from "@utils/fs"
+import * as fs from "fs/promises"
+import * as path from "path"
+// @ts-ignore
+import PCR from "puppeteer-chromium-resolver"
+import { launch } from "puppeteer-core"
+import { HostProvider } from "@/hosts/host-provider"
+
+interface PCRStats {
+	puppeteer: { launch: typeof launch }
+	executablePath: string
+}
+
+export async function ensureChromiumExists(): Promise<PCRStats> {
+	const puppeteerDir = path.join(HostProvider.get().globalStorageFsPath, "puppeteer")
+	const dirExists = await fileExistsAtPath(puppeteerDir)
+	if (!dirExists) {
+		await fs.mkdir(puppeteerDir, { recursive: true })
+	}
+	// if chromium doesn't exist, this will download it to path.join(puppeteerDir, ".chromium-browser-snapshots")
+	// if it does exist it will return the path to existing chromium
+	const stats: PCRStats = await PCR({
+		downloadPath: puppeteerDir,
+	})
+	return stats
+}
diff --git a/apps/vscode/src/services/error/ClineError.ts b/apps/vscode/src/services/error/ClineError.ts
new file mode 100644
index 0000000..c2aeb68
--- /dev/null
+++ b/apps/vscode/src/services/error/ClineError.ts
@@ -0,0 +1,228 @@
+import {
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitMessage,
+} from "@cline/llms"
+import { serializeError } from "serialize-error"
+import { CLINE_ACCOUNT_AUTH_ERROR_MESSAGE } from "../../shared/ClineAccount"
+
+export enum ClineErrorType {
+	Auth = "auth",
+	RateLimit = "rateLimit",
+	Balance = "balance",
+	SpendLimit = "spendLimit",
+	QuotaExceeded = "quotaExceeded",
+	Entitlement = "entitlement",
+	OrgClinePassRestriction = "orgClinePassRestriction",
+	ClinePassLimit = "clinePassLimit",
+}
+
+interface ErrorDetails {
+	/**
+	 * The HTTP status code of the error, if applicable.
+	 */
+	status?: number
+	/**
+	 * The request ID associated with the error, if available.
+	 * This can be useful for debugging and support.
+	 */
+	request_id?: string
+	/**
+	 * Specific error code provided by the API or service.
+	 */
+	code?: string
+	/**
+	 * The model ID associated with the error, if applicable.
+	 * This is useful for identifying which model the error relates to.
+	 */
+	modelId?: string
+	/**
+	 * The provider ID associated with the error, if applicable.
+	 * This is useful for identifying which provider the error relates to.
+	 */
+	providerId?: string
+	/**
+	 * The error message associated with the error, if applicable.
+	 */
+	message?: string
+	// Additional details that might be present in the error
+	// This can include things like current balance, error messages, etc.
+	details?: any
+}
+
+const RATE_LIMIT_PATTERNS = [/status code 429/i, /rate limit/i, /too many requests/i, /quota exceeded/i, /resource exhausted/i]
+
+export class ClineError extends Error {
+	readonly title = "ClineError"
+	readonly _error: ErrorDetails
+
+	// Error details per providers:
+	// Cline: error?.error
+	// Ollama: error?.cause
+	// tbc
+	constructor(
+		raw: any,
+		public readonly modelId?: string,
+		public readonly providerId?: string,
+	) {
+		const error = serializeError(raw)
+
+		const message = error.message || error?.response?.message || String(error) || error?.cause?.means
+		super(message)
+
+		// Extract status from multiple possible locations
+		const status = error.status || error.statusCode || error.response?.status
+		this.modelId = modelId || error.modelId
+		this.providerId = providerId || error.providerId
+
+		// Construct the error details object to includes relevant information
+		// And ensure it has a consistent structure
+		this._error = {
+			...error,
+			message: raw.message || message,
+			status,
+			request_id:
+				error.error?.request_id ||
+				error.request_id ||
+				error.response?.request_id ||
+				error.response?.headers?.["x-request-id"],
+			code: error.code || error?.cause?.code,
+			modelId: this.modelId,
+			providerId: this.providerId,
+			details: error.details || error.error, // Additional details provided by the server
+			stack: undefined, // Avoid serializing stack trace to keep the error object clean
+		}
+	}
+
+	/**
+	 *  Serializes the error to a JSON string that allows for easy transmission and storage.
+	 *  This is useful for logging or sending error details to a webviews.
+	 */
+	public serialize(): string {
+		return JSON.stringify({
+			message: this.message,
+			status: this._error.status,
+			request_id: this._error.request_id,
+			code: this._error.code,
+			modelId: this.modelId,
+			providerId: this.providerId,
+			details: this._error.details,
+		})
+	}
+
+	public get status(): number | undefined {
+		return this._error.status
+	}
+
+	public get requestId(): string | undefined {
+		return this._error.request_id
+	}
+
+	/**
+	 * Parses a stringified error into a ClineError instance.
+	 */
+	static parse(errorStr?: string, modelId?: string): ClineError | undefined {
+		if (!errorStr || typeof errorStr !== "string") {
+			return undefined
+		}
+		return ClineError.transform(errorStr, modelId)
+	}
+
+	/**
+	 * Transforms any object into a ClineError instance.
+	 * Always returns a ClineError, even if the input is not a valid error object.
+	 */
+	static transform(error: any, modelId?: string, providerId?: string): ClineError {
+		try {
+			// If already a ClineError, return it directly to prevent infinite recursion
+			if (error instanceof ClineError) {
+				return error
+			}
+			return new ClineError(JSON.parse(error), modelId, providerId)
+		} catch {
+			return new ClineError(error, modelId, providerId)
+		}
+	}
+
+	public isErrorType(type: ClineErrorType): boolean {
+		return ClineError.getErrorType(this) === type
+	}
+
+	/**
+	 * Is known error type based on the error code, status, and details.
+	 * This is useful for determining how to handle the error in the UI or logic.
+	 */
+	static getErrorType(err: ClineError): ClineErrorType | undefined {
+		const { code, status, details } = err._error
+		const rawMessage = err._error?.message || err.message || JSON.stringify(err._error)
+		const message = rawMessage?.toLowerCase()
+		const detailMessage = typeof details?.message === "string" ? details.message : undefined
+
+		// Check balance error first (most specific)
+		if (code === "insufficient_credits" && typeof details?.current_balance === "number") {
+			return ClineErrorType.Balance
+		}
+
+		// Check spend limit exceeded (org-enforced budget cap, 429 SPEND_LIMIT_EXCEEDED)
+		// Must be checked before the generic rate-limit check since both use 429
+		if (code === "SPEND_LIMIT_EXCEEDED" || details?.code === "SPEND_LIMIT_EXCEEDED") {
+			return ClineErrorType.SpendLimit
+		}
+
+		if (
+			rawMessage === getClineOrgIndividualInferenceSubscriptionMessage() ||
+			(detailMessage ? isClineOrgIndividualInferenceSubscriptionMessage(detailMessage) : false) ||
+			(rawMessage ? isClineOrgIndividualInferenceSubscriptionMessage(rawMessage) : false)
+		) {
+			return ClineErrorType.OrgClinePassRestriction
+		}
+
+		if (
+			(detailMessage ? isClineNotSubscribedMessage(detailMessage) : false) ||
+			(rawMessage ? isClineNotSubscribedMessage(rawMessage) : false)
+		) {
+			return ClineErrorType.Entitlement
+		}
+
+		if (
+			(detailMessage ? isClinePassLimitMessage(detailMessage) : false) ||
+			(rawMessage ? isClinePassLimitMessage(rawMessage) : false)
+		) {
+			return ClineErrorType.ClinePassLimit
+		}
+
+		// Check auth errors
+		const isAuthStatus = status !== undefined && status > 400 && status < 429
+		if (code === "ERR_BAD_REQUEST" || err instanceof AuthInvalidTokenError || isAuthStatus) {
+			return ClineErrorType.Auth
+		}
+
+		if (code === "INFERENCE_CAP_ERROR") {
+			return ClineErrorType.QuotaExceeded
+		}
+
+		if (message) {
+			// Check for specific error codes/messages if applicable
+			const authErrorRegex = [/(?:in)?valid[-_ ]?(?:api )?(?:token|key)/i, /authentication[-_ ]?failed/i, /unauthorized/i]
+			if (message?.includes(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE) || authErrorRegex.some((regex) => regex.test(message))) {
+				return ClineErrorType.Auth
+			}
+
+			// Check rate limit patterns
+			const lowerMessage = message.toLowerCase()
+			if (RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(lowerMessage))) {
+				return ClineErrorType.RateLimit
+			}
+		}
+
+		return undefined
+	}
+}
+
+class AuthInvalidTokenError extends Error {
+	constructor(message: string) {
+		super(message)
+		this.name = ClineErrorType.Auth
+	}
+}
diff --git a/apps/vscode/src/services/error/ErrorProviderFactory.ts b/apps/vscode/src/services/error/ErrorProviderFactory.ts
new file mode 100644
index 0000000..6a83461
--- /dev/null
+++ b/apps/vscode/src/services/error/ErrorProviderFactory.ts
@@ -0,0 +1,107 @@
+import { ClineEndpoint } from "@/config"
+import { isPostHogConfigValid, PostHogClientConfig, posthogConfig } from "@/shared/services/config/posthog-config"
+import { Logger } from "@/shared/services/Logger"
+import { ClineError } from "./ClineError"
+import { IErrorProvider } from "./providers/IErrorProvider"
+import { PostHogErrorProvider } from "./providers/PostHogErrorProvider"
+
+/**
+ * Supported error provider types
+ */
+type ErrorProviderType = "posthog" | "no-op"
+
+/**
+ * Configuration for error providers
+ */
+export interface ErrorProviderConfig {
+	type: ErrorProviderType
+	config: PostHogClientConfig
+}
+
+/**
+ * Factory class for creating error providers
+ * Allows easy switching between different error tracking providers
+ */
+export class ErrorProviderFactory {
+	/**
+	 * Creates an error provider based on the provided configuration
+	 * @param config Configuration for the error provider
+	 * @returns IErrorProvider instance
+	 */
+	public static async createProvider(config: ErrorProviderConfig): Promise<IErrorProvider> {
+		switch (config.type) {
+			case "posthog": {
+				const hasValidPostHogConfig = isPostHogConfigValid(config.config)
+				const errorTrackingApiKey = config.config.errorTrackingApiKey
+				return hasValidPostHogConfig && errorTrackingApiKey
+					? await new PostHogErrorProvider({
+							apiKey: errorTrackingApiKey,
+							errorTrackingApiKey: errorTrackingApiKey,
+							host: config.config.host,
+							uiHost: config.config.uiHost,
+							enableExceptionAutocapture: !!config.config.enableErrorAutocapture,
+						}).initialize()
+					: new NoOpErrorProvider() // Fallback to no-op provider
+			}
+			default:
+				return new NoOpErrorProvider()
+		}
+	}
+
+	/**
+	 * Gets the default error provider configuration
+	 * @returns Default configuration using PostHog, or no-op for self-hosted mode
+	 */
+	public static getDefaultConfig(): ErrorProviderConfig {
+		// Use no-op provider in self-hosted mode to avoid external network calls
+		if (ClineEndpoint.isSelfHosted()) {
+			return {
+				type: "no-op",
+				config: posthogConfig,
+			}
+		}
+		return {
+			type: "posthog",
+			config: posthogConfig,
+		}
+	}
+}
+
+/**
+ * No-operation error provider for when error logging is disabled
+ * or for testing purposes
+ */
+class NoOpErrorProvider implements IErrorProvider {
+	async captureException(error: Error | ClineError, properties?: Record<string, unknown>): Promise<void> {
+		Logger.error("[NoOpErrorProvider] captureException called", { error: error.message || String(error), properties })
+	}
+
+	public logException(error: Error | ClineError, _properties?: Record<string, unknown>): void {
+		// Use Logger.error directly to avoid potential infinite recursion through Logger
+		Logger.error("[NoOpErrorProvider]", error.message || String(error))
+	}
+
+	public logMessage(
+		message: string,
+		level?: "error" | "warning" | "log" | "debug" | "info",
+		properties?: Record<string, unknown>,
+	): void {
+		Logger.log("[NoOpErrorProvider]", { message, level, properties })
+	}
+
+	public isEnabled(): boolean {
+		return true
+	}
+
+	public getSettings() {
+		return {
+			enabled: true,
+			hostEnabled: true,
+			level: "all" as const,
+		}
+	}
+
+	public async dispose(): Promise<void> {
+		Logger.info("[NoOpErrorProvider] Disposing")
+	}
+}
diff --git a/apps/vscode/src/services/error/ErrorService.ts b/apps/vscode/src/services/error/ErrorService.ts
new file mode 100644
index 0000000..d8bf913
--- /dev/null
+++ b/apps/vscode/src/services/error/ErrorService.ts
@@ -0,0 +1,96 @@
+import { Logger } from "@/shared/services/Logger"
+import { ClineError } from "./ClineError"
+import { ErrorProviderFactory } from "./ErrorProviderFactory"
+import { IErrorProvider } from "./providers/IErrorProvider"
+
+/**
+ * ErrorService handles error logging and tracking for the Cline extension
+ * Uses an abstracted error provider to support multiple error tracking backends
+ * Respects user privacy settings and VSCode's global telemetry configuration
+ */
+export class ErrorService {
+	private static instance: ErrorService | null = null
+
+	private provider: IErrorProvider
+
+	/**
+	 * Sets up the ErrorService singleton.
+	 */
+	public static async initialize(): Promise<ErrorService> {
+		if (ErrorService.instance) {
+			throw new Error("ErrorService has already been initialized.")
+		}
+
+		const provider = await ErrorProviderFactory.createProvider(ErrorProviderFactory.getDefaultConfig())
+		ErrorService.instance = new ErrorService(provider)
+		return ErrorService.instance
+	}
+
+	/**
+	 * Gets the singleton instance
+	 */
+	public static get(): ErrorService {
+		if (!ErrorService.instance) {
+			throw new Error("ErrorService not setup. Call ErrorService.initialize() first.")
+		}
+		return ErrorService.instance
+	}
+
+	constructor(provider: IErrorProvider) {
+		this.provider = provider
+	}
+
+	captureException(error: Error | ClineError, properties?: Record<string, unknown>) {
+		return this.provider.captureException(error, properties)
+	}
+
+	public logException(error: Error | ClineError, properties?: Record<string, unknown>): void {
+		this.provider.logException(error, properties)
+		Logger.error("[ErrorService] Logging exception", JSON.stringify(error))
+	}
+
+	public logMessage(
+		message: string,
+		level: "error" | "warning" | "log" | "debug" | "info" = "log",
+		properties?: Record<string, unknown>,
+	): void {
+		this.provider.logMessage(message, level, properties)
+	}
+
+	public toClineError(rawError: unknown, modelId?: string, providerId?: string): ClineError {
+		const transformed = ClineError.transform(rawError, modelId, providerId)
+		this.logException(transformed, { modelId, providerId })
+		return transformed
+	}
+
+	/**
+	 * Check if error logging is currently enabled
+	 * @returns Boolean indicating whether error logging is enabled
+	 */
+	public isEnabled(): boolean {
+		return this.provider.isEnabled()
+	}
+
+	/**
+	 * Get current error logging settings
+	 * @returns Current error logging settings
+	 */
+	public getSettings() {
+		return this.provider.getSettings()
+	}
+
+	/**
+	 * Get the error provider instance
+	 * @returns The current error provider
+	 */
+	public getProvider(): IErrorProvider {
+		return this.provider
+	}
+
+	/**
+	 * Clean up resources when the service is disposed
+	 */
+	public async dispose(): Promise<void> {
+		await this.provider.dispose()
+	}
+}
diff --git a/apps/vscode/src/services/error/__tests__/ClineError.test.ts b/apps/vscode/src/services/error/__tests__/ClineError.test.ts
new file mode 100644
index 0000000..a98a561
--- /dev/null
+++ b/apps/vscode/src/services/error/__tests__/ClineError.test.ts
@@ -0,0 +1,67 @@
+import { describe, it } from "bun:test"
+import "should"
+import { ClineError, ClineErrorType } from "../ClineError"
+
+describe("ClineError", () => {
+	describe("getErrorType", () => {
+		it("should return QuotaExceeded when code is INFERENCE_CAP_ERROR", () => {
+			const err = new ClineError({ message: "Inference cap reached", code: "INFERENCE_CAP_ERROR" })
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.QuotaExceeded)
+		})
+
+		it("should return Entitlement for the SDK ClinePass subscription message", () => {
+			const err = new ClineError(
+				"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://app.cline.bot/promo?code=CLI-8OFF&personal=true",
+			)
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.Entitlement)
+		})
+
+		it("should return Entitlement for the SDK ClinePass subscription message with a different app URL", () => {
+			const err = new ClineError(
+				"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://staging-app.cline.bot/promo?code=CLI-8OFF&personal=true",
+			)
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.Entitlement)
+		})
+
+		it("should return Entitlement for the raw required-plan message", () => {
+			const err = new ClineError("403 Error 403: the user is not subscribed to required model plan")
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.Entitlement)
+		})
+
+		it("should classify the SDK org individual subscription message separately", () => {
+			const err = new ClineError(
+				"Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass",
+			)
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.OrgClinePassRestriction)
+		})
+
+		it("should classify the raw organization individual subscription message separately", () => {
+			const err = new ClineError("403 Error 403: organization accounts cannot use individual model inference subscriptions")
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.OrgClinePassRestriction)
+		})
+
+		it("should classify ClinePass period limit messages separately", () => {
+			const err = new ClineError(
+				"You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later.",
+			)
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.ClinePassLimit)
+		})
+
+		it("should classify nested ClinePass period limit messages separately", () => {
+			const err = new ClineError({
+				message: "403 Error 403",
+				error: {
+					message: "You have reached your monthly ClinePass limit. The limit resets in 12h, please try again later.",
+				},
+			})
+
+			ClineError.getErrorType(err)!.should.equal(ClineErrorType.ClinePassLimit)
+		})
+	})
+})
diff --git a/apps/vscode/src/services/error/index.ts b/apps/vscode/src/services/error/index.ts
new file mode 100644
index 0000000..09490d1
--- /dev/null
+++ b/apps/vscode/src/services/error/index.ts
@@ -0,0 +1,16 @@
+import { ErrorSettings } from "./providers/IErrorProvider"
+
+export { ErrorService } from "./ErrorService"
+export type { ErrorSettings } from "./providers/IErrorProvider"
+export function getErrorLevelFromString(level: string | undefined): ErrorSettings["level"] {
+	switch (level) {
+		case "disabled":
+		case "off":
+			return "off"
+		case "error":
+		case "crash":
+			return "error"
+		default:
+			return "all"
+	}
+}
diff --git a/apps/vscode/src/services/error/providers/IErrorProvider.ts b/apps/vscode/src/services/error/providers/IErrorProvider.ts
new file mode 100644
index 0000000..03c122f
--- /dev/null
+++ b/apps/vscode/src/services/error/providers/IErrorProvider.ts
@@ -0,0 +1,65 @@
+/**
+ * Interface for error providers
+ * Allows switching between different error tracking providers (PostHog, Sentry, etc.)
+ */
+
+import type { ClineError } from "../ClineError"
+
+/**
+ * Error settings that control when and how errors are logged
+ */
+export interface ErrorSettings {
+	/** Whether error logging is enabled */
+	enabled: boolean
+	/** Whether the host environment's telemetry is enabled */
+	hostEnabled: boolean
+	/** The level of errors to log */
+	level?: "all" | "off" | "error" | "crash"
+}
+
+/**
+ * Abstract interface for error providers
+ * Any error tracking provider must implement this interface
+ */
+export interface IErrorProvider {
+	/**
+	 * Logs an error with its stack trace and additional properties
+	 * @param error The error to log
+	 * @param properties  Optional additional properties to attach to the error
+	 */
+	captureException(error: Error | ClineError, properties?: Record<string, unknown>): Promise<void>
+
+	/**
+	 * Sends a log message an error and optional properties
+	 * @param error The error to log (Error or ClineError)
+	 * @param properties Optional additional properties to attach
+	 */
+	logException(error: Error | ClineError, properties?: Record<string, unknown>): void
+
+	/**
+	 * Log a message with specified level
+	 * @param message The message to log
+	 * @param level The severity level of the message
+	 * @param properties Optional additional properties to attach
+	 */
+	logMessage(
+		message: string,
+		level?: "error" | "warning" | "log" | "debug" | "info",
+		properties?: Record<string, unknown>,
+	): void
+
+	/**
+	 * Check if error logging is currently enabled
+	 */
+	isEnabled(): boolean
+
+	/**
+	 * Get current error logging settings
+	 */
+	getSettings(): ErrorSettings
+
+	/**
+	 * Clean up resources when the provider is disposed
+	 */
+	dispose(): Promise<void>
+}
diff --git a/apps/vscode/src/services/error/providers/PostHogErrorProvider.ts b/apps/vscode/src/services/error/providers/PostHogErrorProvider.ts
new file mode 100644
index 0000000..67a69db
--- /dev/null
+++ b/apps/vscode/src/services/error/providers/PostHogErrorProvider.ts
@@ -0,0 +1,164 @@
+import { PostHog } from "posthog-node"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostProvider } from "@/hosts/host-provider"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { PostHogClientProvider } from "@/services/telemetry/providers/posthog/PostHogClientProvider"
+import { fetch } from "@/shared/net"
+import { Setting } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import * as pkg from "../../../../package.json"
+import type { PostHogClientValidConfig } from "../../../shared/services/config/posthog-config"
+import { getErrorLevelFromString } from ".."
+import { ClineError } from "../ClineError"
+import type { ErrorSettings, IErrorProvider } from "./IErrorProvider"
+
+const isDev = process.env.IS_DEV === "true"
+
+type PostHogErrorClient = PostHogClientValidConfig & {
+	enableExceptionAutocapture: boolean
+}
+
+/**
+ * PostHog implementation of the error provider interface
+ * Handles PostHog-specific error tracking and logging
+ */
+export class PostHogErrorProvider implements IErrorProvider {
+	private client: PostHog
+	private errorSettings: ErrorSettings
+	// Does not accept shared client
+	private readonly isSharedClient = false
+
+	constructor(clientConfig: PostHogErrorClient) {
+		this.client = new PostHog(clientConfig.errorTrackingApiKey, {
+			host: clientConfig.host,
+			fetch: (url, options) => fetch(url, options),
+			enableExceptionAutocapture: clientConfig.enableExceptionAutocapture,
+			before_send: (event) => PostHogClientProvider.eventFilter(event),
+		})
+		// Initialize error settings
+		this.errorSettings = {
+			enabled: true,
+			hostEnabled: true,
+			level: "all",
+		}
+	}
+
+	public async initialize(): Promise<PostHogErrorProvider> {
+		// Listen for host telemetry changes
+		HostProvider.env.subscribeToTelemetrySettings(
+			{},
+			{
+				onResponse: (event: { isEnabled: Setting }) => {
+					const hostEnabled = event.isEnabled === Setting.ENABLED || event.isEnabled === Setting.UNSUPPORTED
+					this.errorSettings.hostEnabled = hostEnabled
+				},
+			},
+		)
+
+		const hostSettings = await HostProvider.env.getTelemetrySettings({})
+		if (hostSettings.isEnabled === Setting.DISABLED) {
+			this.errorSettings.hostEnabled = false
+		}
+
+		this.errorSettings.level = getErrorLevelFromString(hostSettings.errorLevel)
+
+		return this
+	}
+
+	captureException(error: Error | ClineError, properties?: Record<string, unknown>): Promise<void> {
+		if (!this.isEnabled() || this.errorSettings.level === "off") {
+			return Promise.resolve()
+		}
+
+		const errorDetails = {
+			name: error.name,
+			extension_version: pkg.version,
+			is_dev: isDev,
+			...properties,
+		}
+
+		return this.client.captureExceptionImmediate(error, this.distinctId, errorDetails)
+	}
+
+	public logException(error: Error | ClineError, properties: Record<string, unknown> = {}): void {
+		if (!this.isEnabled() || this.errorSettings.level === "off") {
+			return
+		}
+
+		const errorDetails = {
+			message: error.message,
+			stack: error.stack,
+			name: error.name,
+			extension_version: pkg.version,
+			is_dev: isDev,
+			...properties,
+		}
+
+		if (error instanceof ClineError) {
+			Object.assign(errorDetails, {
+				modelId: error.modelId,
+				providerId: error.providerId,
+				serialized_error: error.serialize(),
+			})
+		}
+
+		this.client.capture({
+			distinctId: this.distinctId,
+			event: "extension.error",
+			properties: {
+				error_type: "exception",
+				...errorDetails,
+				timestamp: new Date().toISOString(),
+			},
+		})
+
+		Logger.error("[PostHogErrorProvider] Logging exception", error)
+	}
+
+	public logMessage(
+		message: string,
+		level: "error" | "warning" | "log" | "debug" | "info" = "log",
+		properties: Record<string, unknown> = {},
+	): void {
+		if (!this.isEnabled() || this.errorSettings.level === "off") {
+			return
+		}
+
+		// Filter messages based on error level
+		if (this.errorSettings.level === "error" && level !== "error") {
+			return
+		}
+
+		this.client.capture({
+			distinctId: this.distinctId,
+			event: "extension.message",
+			properties: {
+				message: message.substring(0, 500), // Truncate long messages
+				level,
+				extension_version: pkg.version,
+				is_dev: isDev,
+				timestamp: new Date().toISOString(),
+				...properties,
+			},
+		})
+	}
+
+	public isEnabled(): boolean {
+		return StateManager.get().getGlobalSettingsKey("telemetrySetting") !== "disabled" && this.errorSettings.hostEnabled
+	}
+
+	public getSettings(): ErrorSettings {
+		return { ...this.errorSettings }
+	}
+
+	private get distinctId(): string {
+		return getDistinctId()
+	}
+
+	public async dispose(): Promise<void> {
+		// Only shut down the client if it's not shared (we own it)
+		if (!this.isSharedClient) {
+			await this.client.shutdown().catch((error) => Logger.error("Error shutting down PostHog client:", error))
+		}
+	}
+}
diff --git a/apps/vscode/src/services/feature-flags/FeatureFlagsProviderFactory.ts b/apps/vscode/src/services/feature-flags/FeatureFlagsProviderFactory.ts
new file mode 100644
index 0000000..acc50c8
--- /dev/null
+++ b/apps/vscode/src/services/feature-flags/FeatureFlagsProviderFactory.ts
@@ -0,0 +1,85 @@
+import { ClineEndpoint } from "@/config"
+import { isPostHogConfigValid, posthogConfig } from "@/shared/services/config/posthog-config"
+import { Logger } from "@/shared/services/Logger"
+import { PostHogClientProvider } from "../telemetry/providers/posthog/PostHogClientProvider"
+import type { FeatureFlagsAndPayloads, IFeatureFlagsProvider } from "./providers/IFeatureFlagsProvider"
+import { PostHogFeatureFlagsProvider } from "./providers/PostHogFeatureFlagsProvider"
+
+/**
+ * Supported feature flags provider types
+ */
+type FeatureFlagsProviderType = "posthog" | "no-op"
+
+/**
+ * Configuration for feature flags providers
+ */
+export interface FeatureFlagsProviderConfig {
+	type: FeatureFlagsProviderType
+}
+
+/**
+ * Factory class for creating feature flags providers
+ * Allows easy switching between different feature flag providers
+ */
+export class FeatureFlagsProviderFactory {
+	/**
+	 * Creates a feature flags provider based on the provided configuration
+	 * @param config Configuration for the feature flags provider
+	 * @returns IFeatureFlagsProvider instance
+	 */
+	public static createProvider(config: FeatureFlagsProviderConfig): IFeatureFlagsProvider {
+		switch (config.type) {
+			case "posthog": {
+				// Get the shared PostHog client from PostHogClientProvider
+				const sharedClient = PostHogClientProvider.getClient()
+				if (sharedClient) {
+					return new PostHogFeatureFlagsProvider(sharedClient)
+				}
+				// Fall back to NoOp provider if no client is available
+				return new NoOpFeatureFlagsProvider()
+			}
+			default:
+				return new NoOpFeatureFlagsProvider()
+		}
+	}
+
+	/**
+	 * Gets the default feature flags provider configuration
+	 * @returns Default configuration using PostHog, or no-op for self-hosted mode
+	 */
+	public static getDefaultConfig(): FeatureFlagsProviderConfig {
+		// Use no-op provider in self-hosted mode to avoid external network calls
+		if (ClineEndpoint.isSelfHosted()) {
+			return { type: "no-op" }
+		}
+		const hasValidConfig = isPostHogConfigValid(posthogConfig)
+		return {
+			type: hasValidConfig ? "posthog" : "no-op",
+		}
+	}
+}
+
+/**
+ * No-operation feature flags provider for when feature flags are disabled
+ * or for testing purposes
+ */
+class NoOpFeatureFlagsProvider implements IFeatureFlagsProvider {
+	async getAllFlagsAndPayloads(_: { flagKeys?: string[] }): Promise<FeatureFlagsAndPayloads | undefined> {
+		return {}
+	}
+
+	public isEnabled(): boolean {
+		return true
+	}
+
+	public getSettings() {
+		return {
+			enabled: true,
+			timeout: 1000,
+		}
+	}
+
+	public async dispose(): Promise<void> {
+		Logger.info("[NoOpFeatureFlagsProvider] Disposing")
+	}
+}
diff --git a/apps/vscode/src/services/feature-flags/FeatureFlagsService.ts b/apps/vscode/src/services/feature-flags/FeatureFlagsService.ts
new file mode 100644
index 0000000..b3bd302
--- /dev/null
+++ b/apps/vscode/src/services/feature-flags/FeatureFlagsService.ts
@@ -0,0 +1,170 @@
+import { clearOnboardingModelsCache, getClineOnboardingModels } from "@/core/controller/models/getClineOnboardingModels"
+import type { OnboardingModel } from "@/shared/proto/cline/state"
+import { FEATURE_FLAGS, FeatureFlag, FeatureFlagDefaultValue } from "@/shared/services/feature-flags/feature-flags"
+import { Logger } from "@/shared/services/Logger"
+import { telemetryService } from "../telemetry"
+import type { FeatureFlagPayload, FeatureFlagsAndPayloads, IFeatureFlagsProvider } from "./providers/IFeatureFlagsProvider"
+
+// Default cache time-to-live (TTL) for feature flags - an hour
+const DEFAULT_CACHE_TTL = 60 * 60 * 1000
+
+type CacheInfo = {
+	updateTime: number
+	userId: string | null
+	flagsPayload?: FeatureFlagsAndPayloads
+}
+
+/**
+ * FeatureFlagsService provides feature flag functionality that works independently
+ * of telemetry settings. Feature flags are always available to ensure proper
+ * functionality of the extension regardless of user's telemetry preferences.
+ * Uses an abstracted feature flags provider to support multiple backends
+ */
+export class FeatureFlagsService {
+	/**
+	 * Constructor that accepts an IFeatureFlagsProvider instance
+	 * @param provider IFeatureFlagsProvider instance for retrieving feature flags
+	 */
+	public constructor(private provider: IFeatureFlagsProvider) {}
+
+	private cache: Map<FeatureFlag, FeatureFlagPayload> = new Map()
+	/**
+	 * Tracks cache update time and user ID for cache validity
+	 */
+	private cacheInfo: CacheInfo = { updateTime: 0, userId: null }
+
+	/**
+	 * Poll all known feature flags to update their cached values
+	 */
+	public async poll(userId: string | null): Promise<void> {
+		// Do not update cache if last update was less than an hour ago
+		const timesNow = Date.now()
+		if (timesNow - this.cacheInfo.updateTime < DEFAULT_CACHE_TTL && this.cache.size) {
+			// Skip fetch if within TTL and user context is unchanged
+			if (this.cacheInfo.userId === userId) {
+				return
+			}
+		}
+
+		// Only update timestamp after successfully populating cache
+		this.cacheInfo = { updateTime: timesNow, userId: userId || null }
+
+		try {
+			const values = await this.provider.getAllFlagsAndPayloads({
+				flagKeys: FEATURE_FLAGS,
+			})
+			this.cacheInfo.flagsPayload = values
+			Logger.log("Fetched Feature Flag values + " + JSON.stringify(values))
+
+			for (const flag of FEATURE_FLAGS) {
+				const payload = await this.getFeatureFlag(flag).catch(() => false)
+				this.cache.set(flag, payload ?? false)
+			}
+		} catch (error) {
+			// On error, clear cache info to force refresh on next poll
+			this.cacheInfo = { updateTime: 0, userId: null }
+			throw error
+		}
+
+		getClineOnboardingModels() // Refresh onboarding models cache if relevant flag changed
+	}
+
+	private async getFeatureFlag(flagName: FeatureFlag): Promise<FeatureFlagPayload | undefined> {
+		try {
+			const payload = this.cacheInfo.flagsPayload?.featureFlagPayloads?.[flagName]
+			const flagValue = this.cacheInfo.flagsPayload?.featureFlags?.[flagName]
+			const value = payload ?? flagValue ?? FeatureFlagDefaultValue[flagName] ?? undefined
+
+			if (!this.cache.has(flagName) || this.cache.get(flagName) !== value) {
+				telemetryService.capture({
+					event: "$feature_flag_called",
+					properties: {
+						$feature_flag: flagName,
+						$feature_flag_response: flagValue,
+					},
+				})
+			}
+
+			Logger.info(
+				`[FeatureFlagsService] resolving ${flagName}: payload=${JSON.stringify(payload)} flagValue=${JSON.stringify(flagValue)} default=${JSON.stringify(FeatureFlagDefaultValue[flagName])} final=${JSON.stringify(value)} type=${typeof value}`,
+			)
+
+			return value
+		} catch (error) {
+			Logger.error(`Error checking if feature flag ${flagName} is enabled:`, error)
+			return FeatureFlagDefaultValue[flagName] ?? false
+		}
+	}
+
+	/**
+	 * Wrapper: safely get boolean flag with default fallback
+	 * Only check the cached value of a feature flag. If not cached, return defaultValue.
+	 * Useful for performance-sensitive paths where we don't want to await a network call.
+	 * Cache is updated periodically via poll(), and is generated on extension startup,
+	 * and whenever the user logs in.
+	 */
+	public getBooleanFlagEnabled(flagName: FeatureFlag): boolean {
+		return this.cache.get(flagName) === true
+	}
+
+	/**
+	 * Get a cached flag payload (or default) without triggering a network call.
+	 */
+	public getFlagPayload(flagName: FeatureFlag): FeatureFlagPayload | undefined {
+		return this.cache.get(flagName) ?? FeatureFlagDefaultValue[flagName]
+	}
+
+	public getWorktreesEnabled(): boolean {
+		return this.getBooleanFlagEnabled(FeatureFlag.WORKTREES)
+	}
+
+	public getOnboardingOverrides() {
+		const payload = this.cache.get(FeatureFlag.ONBOARDING_MODELS)
+		// Check if payload is object
+		if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+			return payload.models as unknown as Record<string, OnboardingModel & { hidden?: boolean }>
+		}
+		clearOnboardingModelsCache()
+		return undefined
+	}
+
+	/**
+	 * Get the feature flags provider instance
+	 * @returns The current feature flags provider
+	 */
+	public getProvider(): IFeatureFlagsProvider {
+		return this.provider
+	}
+
+	/**
+	 * Check if feature flags are currently enabled
+	 * @returns Boolean indicating whether feature flags are enabled
+	 */
+	public isEnabled(): boolean {
+		return this.provider.isEnabled()
+	}
+
+	/**
+	 * Get current feature flags settings
+	 * @returns Current feature flags settings
+	 */
+	public getSettings() {
+		return this.provider.getSettings()
+	}
+
+	/**
+	 * For testing: directly set a feature flag in the cache
+	 */
+	public test(flagName: FeatureFlag, value: boolean) {
+		if (process.env.NODE_ENV === "true") {
+			this.cache.set(flagName, value)
+		}
+	}
+
+	/**
+	 * Clean up resources when the service is disposed
+	 */
+	public async dispose(): Promise<void> {
+		await this.provider.dispose()
+	}
+}
diff --git a/apps/vscode/src/services/feature-flags/index.ts b/apps/vscode/src/services/feature-flags/index.ts
new file mode 100644
index 0000000..03c3571
--- /dev/null
+++ b/apps/vscode/src/services/feature-flags/index.ts
@@ -0,0 +1,31 @@
+export { FeatureFlagsService } from "./FeatureFlagsService"
+
+import { FeatureFlagsProviderFactory } from "./FeatureFlagsProviderFactory"
+import { FeatureFlagsService } from "./FeatureFlagsService"
+
+let _featureFlagsServiceInstance: FeatureFlagsService | null = null
+
+/**
+ * Get the singleton feature flags service instance
+ * @param distinctId Optional distinct ID for the feature flags provider
+ * @returns FeatureFlagsService instance
+ */
+export function getFeatureFlagsService(): FeatureFlagsService {
+	if (!_featureFlagsServiceInstance) {
+		const provider = FeatureFlagsProviderFactory.createProvider(FeatureFlagsProviderFactory.getDefaultConfig())
+		_featureFlagsServiceInstance = new FeatureFlagsService(provider)
+	}
+	return _featureFlagsServiceInstance
+}
+
+export const featureFlagsService = new Proxy({} as FeatureFlagsService, {
+	get(_target, prop, _receiver) {
+		const service = getFeatureFlagsService()
+		const value = Reflect.get(service, prop, service)
+		// Bind methods to the service instance to preserve `this` context
+		if (typeof value === "function") {
+			return value.bind(service)
+		}
+		return value
+	},
+})
diff --git a/apps/vscode/src/services/feature-flags/providers/IFeatureFlagsProvider.ts b/apps/vscode/src/services/feature-flags/providers/IFeatureFlagsProvider.ts
new file mode 100644
index 0000000..97326e5
--- /dev/null
+++ b/apps/vscode/src/services/feature-flags/providers/IFeatureFlagsProvider.ts
@@ -0,0 +1,55 @@
+/**
+ * Interface for feature flags providers
+ * Allows switching between different feature flag providers (PostHog, etc.)
+ */
+
+/**
+ * Feature flags settings that control how feature flags are retrieved
+ */
+export interface FeatureFlagsSettings {
+	/** Whether feature flags are enabled */
+	enabled: boolean
+	/** Optional timeout for feature flag requests */
+	timeout?: number
+}
+
+type JsonType =
+	| string
+	| number
+	| boolean
+	| null
+	| {
+			[key: string]: JsonType
+	  }
+	| Array<JsonType>
+	| JsonType[]
+export type FeatureFlagPayload = string | number | boolean | { [key: string]: JsonType } | JsonType[] | null
+export type FeatureFlagsAndPayloads = {
+	featureFlags?: Record<string, FeatureFlagPayload>
+	featureFlagPayloads?: Record<string, FeatureFlagPayload>
+}
+
+/**
+ * Abstract interface for feature flags providers
+ * Any feature flags provider must implement this interface
+ */
+export interface IFeatureFlagsProvider {
+	getAllFlagsAndPayloads(options: { flagKeys?: string[] }): Promise<FeatureFlagsAndPayloads | undefined>
+
+	/**
+	 * Check if the provider is enabled and ready
+	 * @returns Boolean indicating whether the provider is enabled
+	 */
+	isEnabled(): boolean
+
+	/**
+	 * Get current feature flags settings
+	 * @returns Current feature flags settings
+	 */
+	getSettings(): FeatureFlagsSettings
+
+	/**
+	 * Clean up resources when the provider is disposed
+	 */
+	dispose(): Promise<void>
+}
diff --git a/apps/vscode/src/services/feature-flags/providers/PostHogFeatureFlagsProvider.ts b/apps/vscode/src/services/feature-flags/providers/PostHogFeatureFlagsProvider.ts
new file mode 100644
index 0000000..5c41a65
--- /dev/null
+++ b/apps/vscode/src/services/feature-flags/providers/PostHogFeatureFlagsProvider.ts
@@ -0,0 +1,76 @@
+import { PostHog } from "posthog-node"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { fetch } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { posthogConfig } from "../../../shared/services/config/posthog-config"
+import type { FeatureFlagsAndPayloads, FeatureFlagsSettings, IFeatureFlagsProvider } from "./IFeatureFlagsProvider"
+
+/**
+ * PostHog implementation of the feature flags provider interface
+ * Handles PostHog-specific feature flag retrieval
+ */
+export class PostHogFeatureFlagsProvider implements IFeatureFlagsProvider {
+	private client: PostHog
+	private settings: FeatureFlagsSettings
+	private isSharedClient: boolean
+
+	constructor(sharedClient?: PostHog) {
+		this.isSharedClient = !!sharedClient
+
+		// Use shared PostHog client if provided, otherwise create a new one
+		if (sharedClient) {
+			this.client = sharedClient
+		} else {
+			// Only create a new client if we have an API key
+			if (!posthogConfig.apiKey) {
+				throw new Error("PostHog API key is required to create a new client")
+			}
+			this.client = new PostHog(posthogConfig.apiKey, {
+				host: posthogConfig.host,
+				fetch: (url, options) => fetch(url, options),
+			})
+		}
+
+		// Initialize feature flags settings
+		this.settings = {
+			enabled: true,
+			timeout: 5000, // 5 second timeout for feature flag requests
+		}
+	}
+
+	private get distinctId(): string {
+		return getDistinctId()
+	}
+
+	async getAllFlagsAndPayloads(options: { flagKeys?: string[] }): Promise<FeatureFlagsAndPayloads | undefined> {
+		if (!this.isEnabled()) {
+			return undefined
+		}
+
+		try {
+			return await this.client.getAllFlagsAndPayloads(this.distinctId, options)
+		} catch (error) {
+			Logger.error(`Error getting feature flags`, error)
+			return {}
+		}
+	}
+
+	public isEnabled(): boolean {
+		return this.settings.enabled
+	}
+
+	public getSettings(): FeatureFlagsSettings {
+		return { ...this.settings }
+	}
+
+	public async dispose(): Promise<void> {
+		// Only shut down the client if it's not shared (we own it)
+		if (!this.isSharedClient) {
+			try {
+				await this.client.shutdown()
+			} catch (error) {
+				Logger.error("Error shutting down PostHog client:", error)
+			}
+		}
+	}
+}
diff --git a/apps/vscode/src/services/glob/__tests__/list-files.test.ts b/apps/vscode/src/services/glob/__tests__/list-files.test.ts
new file mode 100644
index 0000000..2fb7115
--- /dev/null
+++ b/apps/vscode/src/services/glob/__tests__/list-files.test.ts
@@ -0,0 +1,193 @@
+import { afterAll, describe, it } from "bun:test"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import "should"
+import { listFiles } from "../list-files"
+
+function normalizeForComparison(filePath: string): string {
+	return filePath.replaceAll("\\", "/")
+}
+
+describe("listFiles", () => {
+	const tmpDir = path.join(os.tmpdir(), `cline-list-files-test-${Math.random().toString(36).slice(2)}`)
+
+	afterAll(async () => {
+		await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => undefined)
+	})
+
+	it("returns empty result when cwd points to a file", async () => {
+		await fs.mkdir(tmpDir, { recursive: true })
+		const filePath = path.join(tmpDir, "single-file.ts")
+		await fs.writeFile(filePath, "export const x = 1\n")
+
+		const [files, didHitLimit] = await listFiles(filePath, false, 200)
+
+		files.should.deepEqual([])
+		didHitLimit.should.equal(false)
+	})
+
+	it("still lists files when cwd points to a directory", async () => {
+		await fs.mkdir(tmpDir, { recursive: true })
+		const nestedFile = path.join(tmpDir, "index.ts")
+		await fs.writeFile(nestedFile, "export const ok = true\n")
+
+		const [files] = await listFiles(tmpDir, false, 200)
+
+		files.map(normalizeForComparison).should.containEql(normalizeForComparison(nestedFile))
+	})
+})
+
+describe("listFiles gitignore handling", () => {
+	// Each test gets its own isolated subdirectory to avoid cross-test pollution.
+	// Previous version shared a single tmpDir, which meant later tests could
+	// overwrite earlier .gitignore files and pass for the wrong reasons.
+	const baseDir = path.join(os.tmpdir(), `cline-gitignore-test-${Math.random().toString(36).slice(2)}`)
+
+	afterAll(async () => {
+		await fs.rm(baseDir, { recursive: true, force: true }).catch(() => undefined)
+	})
+
+	it("excludes files matching root .gitignore directory patterns", async () => {
+		// Verifies the most common .gitignore use case: a directory pattern like "some-dir/"
+		// at the project root excludes that directory and everything inside it.
+		//
+		// project/
+		//   .gitignore       → "ignored-dir/"
+		//   visible.ts
+		//   ignored-dir/
+		//     secret.ts      ← should be excluded
+		//   src/
+		//     app.ts
+		const project = path.join(baseDir, "test-root-gitignore")
+		await fs.mkdir(path.join(project, "ignored-dir"), { recursive: true })
+		await fs.mkdir(path.join(project, "src"), { recursive: true })
+		await fs.writeFile(path.join(project, ".gitignore"), "ignored-dir/\n")
+		await fs.writeFile(path.join(project, "visible.ts"), "export const x = 1\n")
+		await fs.writeFile(path.join(project, "ignored-dir", "secret.ts"), "secret\n")
+		await fs.writeFile(path.join(project, "src", "app.ts"), "app\n")
+
+		const [files] = await listFiles(project, true, 200)
+		const normalized = files.map(normalizeForComparison)
+
+		normalized.should.containEql(normalizeForComparison(path.join(project, "visible.ts")))
+		normalized.should.containEql(normalizeForComparison(path.join(project, "src", "app.ts")))
+
+		const hasIgnoredContent = normalized.some((f) => f.includes("ignored-dir"))
+		hasIgnoredContent.should.equal(false, "ignored-dir/ contents should be excluded by root .gitignore")
+	})
+
+	it("excludes files matching .gitignore file patterns (not just directories)", async () => {
+		// The .gitignore parser handles two kinds of patterns differently:
+		// - Directory patterns ending in "/" → converted to "**/dir/**"
+		// - File/glob patterns like "*.log"  → converted to "**/*.log" + "**/*.log/**"
+		// This test exercises the file pattern branch.
+		//
+		// project/
+		//   .gitignore       → "*.log\nsecret.env"
+		//   app.ts
+		//   debug.log        ← should be excluded
+		//   src/
+		//     nested.log     ← should also be excluded (pattern is global)
+		//     secret.env     ← should be excluded
+		//     config.ts
+		const project = path.join(baseDir, "test-file-patterns")
+		await fs.mkdir(path.join(project, "src"), { recursive: true })
+		await fs.writeFile(path.join(project, ".gitignore"), "*.log\nsecret.env\n")
+		await fs.writeFile(path.join(project, "app.ts"), "app\n")
+		await fs.writeFile(path.join(project, "debug.log"), "debug output\n")
+		await fs.writeFile(path.join(project, "src", "nested.log"), "nested log\n")
+		await fs.writeFile(path.join(project, "src", "secret.env"), "API_KEY=xxx\n")
+		await fs.writeFile(path.join(project, "src", "config.ts"), "config\n")
+
+		const [files] = await listFiles(project, true, 200)
+		const normalized = files.map(normalizeForComparison)
+
+		normalized.should.containEql(normalizeForComparison(path.join(project, "app.ts")))
+		normalized.should.containEql(normalizeForComparison(path.join(project, "src", "config.ts")))
+
+		const hasLogFiles = normalized.some((f) => f.endsWith(".log"))
+		hasLogFiles.should.equal(false, "*.log files should be excluded")
+
+		const hasSecretEnv = normalized.some((f) => f.includes("secret.env"))
+		hasSecretEnv.should.equal(false, "secret.env should be excluded")
+	})
+
+	it("reads .gitignore from subdirectories during BFS traversal", async () => {
+		// .gitignore files aren't only at the root — subdirectories can have their own.
+		// During BFS, when we enter a non-ignored directory, we read its .gitignore
+		// and add those patterns to the accumulator for all deeper traversal.
+		//
+		// project/
+		//   src/
+		//     .gitignore     → "generated/"
+		//     code.ts
+		//     generated/
+		//       output.ts    ← should be excluded by src/.gitignore
+		//   lib/
+		//     util.ts
+		const project = path.join(baseDir, "test-subdirectory-gitignore")
+		const srcDir = path.join(project, "src")
+		const genDir = path.join(srcDir, "generated")
+		const libDir = path.join(project, "lib")
+		await fs.mkdir(genDir, { recursive: true })
+		await fs.mkdir(libDir, { recursive: true })
+		await fs.writeFile(path.join(srcDir, ".gitignore"), "generated/\n")
+		await fs.writeFile(path.join(srcDir, "code.ts"), "code\n")
+		await fs.writeFile(path.join(genDir, "output.ts"), "generated output\n")
+		await fs.writeFile(path.join(libDir, "util.ts"), "util\n")
+
+		const [files] = await listFiles(project, true, 200)
+		const normalized = files.map(normalizeForComparison)
+
+		normalized.should.containEql(normalizeForComparison(path.join(srcDir, "code.ts")))
+		normalized.should.containEql(normalizeForComparison(path.join(libDir, "util.ts")))
+
+		const hasGeneratedContent = normalized.some((f) => f.includes("generated"))
+		hasGeneratedContent.should.equal(false, "src/generated/ should be excluded by src/.gitignore")
+	})
+
+	it("does not read .gitignore from inside gitignored directories", async () => {
+		// This is the core OOM-prevention test.
+		//
+		// The crash scenario: a gitignored directory (e.g., third-party/) contains
+		// hundreds of nested repos, each with their own .gitignore. globby's old
+		// gitignore:true would read ALL of them upfront, build a massive regex,
+		// and OOM during V8 regex compilation.
+		//
+		// With incremental reading, we never enter third-party/ because the root
+		// .gitignore excludes it, so we never read any .gitignore files inside it.
+		//
+		// NOTE: We intentionally use "third-party/" instead of "vendor/" here because
+		// "vendor" is in DEFAULT_IGNORE_DIRECTORIES and would be excluded regardless
+		// of .gitignore. Using a name NOT in that list proves the .gitignore-based
+		// exclusion is actually working.
+		//
+		// project/
+		//   .gitignore          → "third-party/"
+		//   app.ts
+		//   third-party/
+		//     .gitignore        ← should never be read
+		//     repo1/
+		//       .gitignore      ← should never be read
+		//       file.ts
+		const project = path.join(baseDir, "test-no-read-inside-ignored")
+		const thirdPartyDir = path.join(project, "third-party")
+		const repo1Dir = path.join(thirdPartyDir, "repo1")
+		await fs.mkdir(repo1Dir, { recursive: true })
+		await fs.writeFile(path.join(project, ".gitignore"), "third-party/\n")
+		await fs.writeFile(path.join(project, "app.ts"), "app\n")
+		// These .gitignore files simulate the nested repos that caused OOM
+		await fs.writeFile(path.join(thirdPartyDir, ".gitignore"), "*.log\nbuild/\n")
+		await fs.writeFile(path.join(repo1Dir, ".gitignore"), "dist/\ncoverage/\n")
+		await fs.writeFile(path.join(repo1Dir, "file.ts"), "file\n")
+
+		const [files] = await listFiles(project, true, 200)
+		const normalized = files.map(normalizeForComparison)
+
+		normalized.should.containEql(normalizeForComparison(path.join(project, "app.ts")))
+
+		const hasThirdPartyContent = normalized.some((f) => f.includes("third-party"))
+		hasThirdPartyContent.should.equal(false, "third-party/ contents should be excluded — and its .gitignore files never read")
+	})
+})
diff --git a/apps/vscode/src/services/glob/list-files.ts b/apps/vscode/src/services/glob/list-files.ts
new file mode 100644
index 0000000..64e3637
--- /dev/null
+++ b/apps/vscode/src/services/glob/list-files.ts
@@ -0,0 +1,220 @@
+import { workspaceResolver } from "@core/workspace"
+import { isDirectory } from "@utils/fs"
+import { arePathsEqual } from "@utils/path"
+import * as fs from "fs/promises"
+import { globby, Options } from "globby"
+import * as os from "os"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+
+// Constants
+const DEFAULT_IGNORE_DIRECTORIES = [
+	"node_modules",
+	"__pycache__",
+	"env",
+	"venv",
+	"target/dependency",
+	"build/dependencies",
+	"dist",
+	"out",
+	"bundle",
+	"vendor",
+	"tmp",
+	"temp",
+	"deps",
+	"Pods",
+]
+
+// Helper functions
+function isRestrictedPath(absolutePath: string): boolean {
+	const root = process.platform === "win32" ? path.parse(absolutePath).root : "/"
+	const isRoot = arePathsEqual(absolutePath, root)
+	if (isRoot) {
+		return true
+	}
+
+	const homeDir = os.homedir()
+	const isHomeDir = arePathsEqual(absolutePath, homeDir)
+	if (isHomeDir) {
+		return true
+	}
+
+	return false
+}
+
+function isTargetingHiddenDirectory(absolutePath: string): boolean {
+	const dirName = workspaceResolver.getBasename(absolutePath, "Services.glob.isTargetingHiddenDirectory")
+	return dirName.startsWith(".")
+}
+
+/**
+ * Read a .gitignore file and convert its patterns to glob ignore patterns.
+ *
+ * We do NOT use globby's built-in `gitignore: true` option because it recursively
+ * reads ALL .gitignore files in the entire directory tree upfront - including those
+ * inside directories that are themselves gitignored. In projects with large gitignored
+ * directories containing many nested repos (each with their own .gitignore), this
+ * causes V8 to run out of memory during regex compilation, crashing the extension host.
+ *
+ * Instead, we read .gitignore files incrementally during BFS traversal: only from
+ * directories we actually enter (which are not ignored), never from ignored directories.
+ */
+async function readGitignorePatterns(dirPath: string): Promise<string[]> {
+	try {
+		const gitignorePath = path.join(dirPath, ".gitignore")
+		const content = await fs.readFile(gitignorePath, "utf8")
+		const patterns: string[] = []
+
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim()
+			// Skip empty lines and comments
+			if (!trimmed || trimmed.startsWith("#")) {
+				continue
+			}
+			// Skip negation patterns - they're complex to convert and rarely
+			// critical for the directory listing use case
+			if (trimmed.startsWith("!")) {
+				continue
+			}
+			// Convert gitignore patterns to glob ignore patterns
+			if (trimmed.endsWith("/")) {
+				// Directory pattern: "ignored-dir/" → match the directory itself and its contents.
+				// Two explicit patterns avoid ambiguity across glob library versions:
+				const dirName = trimmed.slice(0, -1)
+				patterns.push(`**/${dirName}`)
+				patterns.push(`**/${dirName}/**`)
+			} else {
+				// File or ambiguous pattern: "*.log" -> "**/*.log" and "**/*.log/**"
+				patterns.push(`**/${trimmed}`)
+				patterns.push(`**/${trimmed}/**`)
+			}
+		}
+
+		return patterns
+	} catch {
+		return []
+	}
+}
+
+async function buildIgnorePatterns(absolutePath: string): Promise<string[]> {
+	const isTargetHidden = isTargetingHiddenDirectory(absolutePath)
+
+	const patterns = [...DEFAULT_IGNORE_DIRECTORIES]
+
+	// Only ignore hidden directories if we're not explicitly targeting a hidden directory
+	if (!isTargetHidden) {
+		patterns.push(".*")
+	}
+
+	const globPatterns = patterns.map((dir) => `**/${dir}/**`)
+
+	// Read root .gitignore to seed the initial ignore patterns.
+	// Additional .gitignore files from subdirectories are read incrementally
+	// during BFS traversal in globbyLevelByLevel().
+	const gitignorePatterns = await readGitignorePatterns(absolutePath)
+	globPatterns.push(...gitignorePatterns)
+
+	return globPatterns
+}
+
+export async function listFiles(dirPath: string, recursive: boolean, limit: number): Promise<[string[], boolean]> {
+	const absolutePathResult = workspaceResolver.resolveWorkspacePath(dirPath, "", "Services.glob.listFiles")
+	const absolutePath = typeof absolutePathResult === "string" ? absolutePathResult : absolutePathResult.absolutePath
+
+	// Do not allow listing files in root or home directory
+	if (isRestrictedPath(absolutePath)) {
+		return [[], false]
+	}
+
+	// globby requires cwd to point to a directory
+	if (!(await isDirectory(absolutePath))) {
+		return [[], false]
+	}
+
+	const options: Options = {
+		cwd: absolutePath,
+		dot: true, // do not ignore hidden files/directories
+		absolute: true,
+		markDirectories: true, // Append a / on any directories matched
+		gitignore: false, // We handle .gitignore ourselves incrementally during BFS to avoid OOM
+		ignore: recursive ? await buildIgnorePatterns(absolutePath) : undefined,
+		onlyFiles: false, // include directories in results
+		suppressErrors: true,
+	}
+
+	const filePaths = recursive ? await globbyLevelByLevel(limit, options) : (await globby("*", options)).slice(0, limit)
+
+	return [filePaths, filePaths.length >= limit]
+}
+
+/*
+Breadth-first traversal of directory structure level by level up to a limit:
+   - Queue-based approach ensures proper breadth-first traversal
+   - Processes directory patterns level by level
+   - Captures a representative sample of the directory structure up to the limit
+   - Minimizes risk of missing deeply nested files
+   - Reads .gitignore files incrementally from each non-ignored directory entered,
+     avoiding the OOM crash caused by globby's gitignore:true reading ALL nested
+     .gitignore files upfront (including those inside gitignored directories)
+
+- Notes:
+   - Relies on globby to mark directories with /
+   - Potential for loops if symbolic links reference back to parent (we could use followSymlinks: false but that may not be ideal for some projects and it's pointless if they're not using symlinks wrong)
+   - Timeout mechanism prevents infinite loops
+*/
+async function globbyLevelByLevel(limit: number, options?: Options) {
+	const results: Set<string> = new Set()
+	const queue: string[] = ["*"]
+	// Track all ignore patterns, starting with whatever was passed in options.
+	// We'll add patterns from .gitignore files as we discover non-ignored directories.
+	const currentIgnore: string[] = [...((options?.ignore as string[]) ?? [])]
+
+	const globbingProcess = async () => {
+		while (queue.length > 0 && results.size < limit) {
+			const pattern = queue.shift()!
+			// Use current accumulated ignore patterns for each globby call
+			const currentOptions = { ...options, ignore: currentIgnore }
+			const filesAtLevel = await globby(pattern, currentOptions)
+
+			for (const file of filesAtLevel) {
+				if (results.size >= limit) {
+					break
+				}
+				results.add(file)
+				if (file.endsWith("/")) {
+					// This directory passed the ignore filters, so it's not gitignored.
+					// Read its .gitignore (if any) and add patterns to the ignore list
+					// so deeper traversal respects them.
+					const dirGitignorePatterns = await readGitignorePatterns(file)
+					if (dirGitignorePatterns.length > 0) {
+						currentIgnore.push(...dirGitignorePatterns)
+					}
+
+					// Queue as a RELATIVE path to cwd so that ignore patterns (like **/tmp/**)
+					// are checked against relative entry paths, not absolute ones. Using absolute
+					// patterns causes false matches when the project is under a directory whose
+					// name collides with DEFAULT_IGNORE_DIRECTORIES (e.g., /tmp on Linux).
+					const cwd = options?.cwd?.toString() ?? ""
+					const relativeDir = path.relative(cwd, file)
+					// Escape backslashes and parentheses in the path to prevent glob pattern interpretation.
+					// This is crucial for NextJS folder naming conventions which use parentheses like (auth), (dashboard).
+					// Without escaping, glob treats backslashes as escapes and parentheses as special pattern grouping characters.
+					const escapedDir = relativeDir.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)")
+					queue.push(`${escapedDir}/*`)
+				}
+			}
+		}
+		return Array.from(results).slice(0, limit)
+	}
+
+	// Timeout after 10 seconds and return partial results
+	const timeoutPromise = new Promise<string[]>((_, reject) => {
+		setTimeout(() => reject(new Error("Globbing timeout")), 10_000)
+	})
+	try {
+		return await Promise.race([globbingProcess(), timeoutPromise])
+	} catch (_error) {
+		Logger.warn("Globbing timed out, returning partial results")
+		return Array.from(results)
+	}
+}
diff --git a/apps/vscode/src/services/lg-cns-integration/webhook-hooks.ts b/apps/vscode/src/services/lg-cns-integration/webhook-hooks.ts
new file mode 100644
index 0000000..347690d
--- /dev/null
+++ b/apps/vscode/src/services/lg-cns-integration/webhook-hooks.ts
@@ -0,0 +1,322 @@
+import fs from "fs/promises"
+import path from "path"
+import { ensureHooksDirectoryExists, getDocumentsPath } from "@/core/storage/disk"
+
+type LgHookScript = {
+	fileName: string
+	content: string
+	mode?: number
+}
+
+export async function writeLgWebhookConfig(webhookUrl: string, webhookToken: string): Promise<void> {
+	const documentsPath = await getDocumentsPath()
+	const clineDir = path.join(documentsPath, "Cline")
+	const configPath = path.join(clineDir, "webhook_config.json")
+
+	await fs.mkdir(clineDir, { recursive: true })
+	await fs.writeFile(
+		configPath,
+		JSON.stringify(
+			{
+				webhook_url: webhookUrl,
+				webhook_token: webhookToken,
+				created_at: new Date().toISOString(),
+			},
+			null,
+			2,
+		),
+		"utf-8",
+	)
+}
+
+export async function writeLgWebhookHooks(): Promise<void> {
+	const hooksDir = await ensureHooksDirectoryExists()
+	const hooks = getLgWebhookHookScripts()
+
+	for (const hook of hooks) {
+		const hookPath = path.join(hooksDir, hook.fileName)
+		await fs.writeFile(hookPath, hook.content, "utf-8")
+		if (hook.mode !== undefined) {
+			await fs.chmod(hookPath, hook.mode)
+		}
+	}
+}
+
+function getLgWebhookHookScripts(): LgHookScript[] {
+	if (process.platform === "win32") {
+		return [
+			{ fileName: "TaskStart.ps1", content: TASK_START_POWERSHELL },
+			{ fileName: "PostToolUse.ps1", content: POST_TOOL_USE_POWERSHELL },
+			{ fileName: "TaskComplete.ps1", content: TASK_COMPLETE_POWERSHELL },
+		]
+	}
+
+	return [
+		{ fileName: "TaskStart", content: TASK_START_NODE, mode: 0o755 },
+		{ fileName: "PostToolUse", content: POST_TOOL_USE_NODE, mode: 0o755 },
+		{ fileName: "TaskComplete", content: TASK_COMPLETE_NODE, mode: 0o755 },
+	]
+}
+
+const TASK_START_POWERSHELL = `try {
+    $rawInput = [Console]::In.ReadToEnd()
+    $inputData = $null
+    if ($rawInput) {
+        $inputData = $rawInput | ConvertFrom-Json -Depth 100
+    }
+} catch {
+    $inputData = $null
+}
+
+try {
+    $documentsPath = [System.Environment]::GetFolderPath([System.Environment+SpecialFolder]::MyDocuments)
+    if (-not $documentsPath) {
+        $documentsPath = Join-Path $HOME "Documents"
+    }
+
+    $configPath = Join-Path (Join-Path $documentsPath "Cline") "webhook_config.json"
+    if (-not (Test-Path $configPath)) {
+        @{ cancel = $false } | ConvertTo-Json -Compress
+        exit 0
+    }
+
+    $config = Get-Content $configPath -Raw | ConvertFrom-Json -Depth 100
+    if (-not $config.webhook_url -or -not $config.webhook_token) {
+        @{ cancel = $false } | ConvertTo-Json -Compress
+        exit 0
+    }
+
+    $workspaceRoots = @()
+    if ($inputData -and $null -ne $inputData.workspaceRoots) {
+        $workspaceRoots = $inputData.workspaceRoots
+    }
+
+    $taskMetadata = @{}
+    if ($inputData -and $inputData.taskStart -and $null -ne $inputData.taskStart.taskMetadata) {
+        $taskMetadata = $inputData.taskStart.taskMetadata
+    }
+
+    $payload = @{
+        event = "task_started"
+        timestamp = (Get-Date).ToUniversalTime().ToString("o")
+        data = @{
+            task_id = if ($inputData) { $inputData.taskId } else { $null }
+            cline_version = if ($inputData) { $inputData.clineVersion } else { $null }
+            workspace_roots = $workspaceRoots
+            task_metadata = $taskMetadata
+        }
+    }
+
+    $headers = @{
+        Authorization = "Bearer $($config.webhook_token)"
+        "Content-Type" = "application/json"
+    }
+
+    Invoke-RestMethod -Method Post -Uri $config.webhook_url -Headers $headers -Body ($payload | ConvertTo-Json -Depth 100) -ContentType "application/json" -TimeoutSec 5 | Out-Null
+} catch {}
+
+@{ cancel = $false } | ConvertTo-Json -Compress
+`
+
+const POST_TOOL_USE_POWERSHELL = `try {
+    $rawInput = [Console]::In.ReadToEnd()
+    $inputData = $null
+    if ($rawInput) {
+        $inputData = $rawInput | ConvertFrom-Json -Depth 100
+    }
+} catch {
+    $inputData = $null
+}
+
+try {
+    $documentsPath = [System.Environment]::GetFolderPath([System.Environment+SpecialFolder]::MyDocuments)
+    if (-not $documentsPath) {
+        $documentsPath = Join-Path $HOME "Documents"
+    }
+
+    $configPath = Join-Path (Join-Path $documentsPath "Cline") "webhook_config.json"
+    if (-not (Test-Path $configPath)) {
+        @{ cancel = $false } | ConvertTo-Json -Compress
+        exit 0
+    }
+
+    $config = Get-Content $configPath -Raw | ConvertFrom-Json -Depth 100
+    if (-not $config.webhook_url -or -not $config.webhook_token) {
+        @{ cancel = $false } | ConvertTo-Json -Compress
+        exit 0
+    }
+
+    $toolData = $null
+    if ($inputData -and $inputData.postToolUse) {
+        $toolData = $inputData.postToolUse
+    }
+
+    $payload = @{
+        event = "tool_executed"
+        timestamp = (Get-Date).ToUniversalTime().ToString("o")
+        data = @{
+            task_id = if ($inputData) { $inputData.taskId } else { $null }
+            tool_name = if ($toolData) { $toolData.toolName } else { $null }
+            parameters = if ($toolData -and $null -ne $toolData.parameters) { $toolData.parameters } else { @{} }
+            success = if ($toolData) { [bool]$toolData.success } else { $false }
+            execution_time_ms = if ($toolData) { $toolData.executionTimeMs } else { $null }
+        }
+    }
+
+    $headers = @{
+        Authorization = "Bearer $($config.webhook_token)"
+        "Content-Type" = "application/json"
+    }
+
+    Invoke-RestMethod -Method Post -Uri $config.webhook_url -Headers $headers -Body ($payload | ConvertTo-Json -Depth 100) -ContentType "application/json" -TimeoutSec 5 | Out-Null
+} catch {}
+
+@{ cancel = $false } | ConvertTo-Json -Compress
+`
+
+const TASK_COMPLETE_POWERSHELL = `try {
+    $rawInput = [Console]::In.ReadToEnd()
+    $inputData = $null
+    if ($rawInput) {
+        $inputData = $rawInput | ConvertFrom-Json -Depth 100
+    }
+} catch {
+    $inputData = $null
+}
+
+try {
+    $documentsPath = [System.Environment]::GetFolderPath([System.Environment+SpecialFolder]::MyDocuments)
+    if (-not $documentsPath) {
+        $documentsPath = Join-Path $HOME "Documents"
+    }
+
+    $configPath = Join-Path (Join-Path $documentsPath "Cline") "webhook_config.json"
+    if (-not (Test-Path $configPath)) {
+        @{ cancel = $false } | ConvertTo-Json -Compress
+        exit 0
+    }
+
+    $config = Get-Content $configPath -Raw | ConvertFrom-Json -Depth 100
+    if (-not $config.webhook_url -or -not $config.webhook_token) {
+        @{ cancel = $false } | ConvertTo-Json -Compress
+        exit 0
+    }
+
+    $taskMetadata = @{}
+    if ($inputData -and $inputData.taskComplete -and $null -ne $inputData.taskComplete.taskMetadata) {
+        $taskMetadata = $inputData.taskComplete.taskMetadata
+    }
+
+    $payload = @{
+        event = "task_completed"
+        timestamp = (Get-Date).ToUniversalTime().ToString("o")
+        data = @{
+            task_id = if ($inputData) { $inputData.taskId } else { $null }
+            task_metadata = $taskMetadata
+        }
+    }
+
+    $headers = @{
+        Authorization = "Bearer $($config.webhook_token)"
+        "Content-Type" = "application/json"
+    }
+
+    Invoke-RestMethod -Method Post -Uri $config.webhook_url -Headers $headers -Body ($payload | ConvertTo-Json -Depth 100) -ContentType "application/json" -TimeoutSec 5 | Out-Null
+} catch {}
+
+@{ cancel = $false } | ConvertTo-Json -Compress
+`
+
+const NODE_HOOK_SHARED = `#!/usr/bin/env node
+const fs = require("fs/promises")
+const os = require("os")
+const path = require("path")
+
+async function readConfig() {
+  const configPath = path.join(os.homedir(), "Documents", "Cline", "webhook_config.json")
+  try {
+    const rawConfig = await fs.readFile(configPath, "utf-8")
+    const config = JSON.parse(rawConfig)
+    if (!config.webhook_url || !config.webhook_token) {
+      return null
+    }
+    return config
+  } catch {
+    return null
+  }
+}
+
+async function postEvent(config, payload) {
+  let timeout
+  try {
+    const controller = new AbortController()
+    timeout = setTimeout(() => controller.abort(), 5000)
+    await fetch(config.webhook_url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: \`Bearer \${config.webhook_token}\`,
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+    })
+  } catch {} finally {
+    if (timeout) {
+      clearTimeout(timeout)
+    }
+  }
+}
+
+async function main(buildPayload) {
+  let input = {}
+  try {
+    const rawInput = await fs.readFile(0, "utf-8")
+    input = rawInput ? JSON.parse(rawInput) : {}
+  } catch {}
+
+  const config = await readConfig()
+  if (config) {
+    await postEvent(config, buildPayload(input))
+  }
+
+  process.stdout.write(JSON.stringify({ cancel: false }))
+}
+`
+
+const TASK_START_NODE = `${NODE_HOOK_SHARED}
+main((input) => ({
+  event: "task_started",
+  timestamp: new Date().toISOString(),
+  data: {
+    task_id: input.taskId ?? null,
+    cline_version: input.clineVersion ?? null,
+    workspace_roots: input.workspaceRoots ?? [],
+    task_metadata: input.taskStart?.taskMetadata ?? {},
+  },
+}))
+`
+
+const POST_TOOL_USE_NODE = `${NODE_HOOK_SHARED}
+main((input) => ({
+  event: "tool_executed",
+  timestamp: new Date().toISOString(),
+  data: {
+    task_id: input.taskId ?? null,
+    tool_name: input.postToolUse?.toolName ?? null,
+    parameters: input.postToolUse?.parameters ?? {},
+    success: Boolean(input.postToolUse?.success),
+    execution_time_ms: input.postToolUse?.executionTimeMs ?? null,
+  },
+}))
+`
+
+const TASK_COMPLETE_NODE = `${NODE_HOOK_SHARED}
+main((input) => ({
+  event: "task_completed",
+  timestamp: new Date().toISOString(),
+  data: {
+    task_id: input.taskId ?? null,
+    task_metadata: input.taskComplete?.taskMetadata ?? {},
+  },
+}))
+`
diff --git a/apps/vscode/src/services/logging/distinctId.test.ts b/apps/vscode/src/services/logging/distinctId.test.ts
new file mode 100644
index 0000000..5d24a30
--- /dev/null
+++ b/apps/vscode/src/services/logging/distinctId.test.ts
@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { expect } from "chai"
+import * as actualNodeMachineId from "node-machine-id"
+import * as sinon from "sinon"
+import { HostProvider } from "@/hosts/host-provider"
+
+// bun loads real ESM, so sinon cannot stub the `node-machine-id` namespace
+// export ("ES Modules cannot be stubbed"). Inject a module-level sinon stub for
+// `machineId` via mock.module so the full sinon stub API keeps working.
+const machineIdStub: sinon.SinonStub = sinon.stub()
+mock.module("node-machine-id", () => ({ ...actualNodeMachineId, machineId: machineIdStub }))
+
+import { _GENERATED_MACHINE_ID_KEY, getDistinctId, initializeDistinctId, setDistinctId } from "@/services/logging/distinctId"
+import { StorageContext } from "@/shared/storage"
+
+describe("distinctId", () => {
+	let sandbox: sinon.SinonSandbox
+	let mockStorage: StorageContext
+	let mockGlobalState: any
+	let hostProviderInitialized = false
+
+	const MOCK_GLOBAL_STATE_ID = "existing-distinct-id-123"
+	const MOCK_MACHINE_ID = "machine-id-456"
+	const MOCK_UUID = "mock-uuid-12345678-1234-1234-1234-123456789012"
+	const GENERATED_MACHINE_ID = "cl-" + MOCK_UUID
+
+	const mockUuidGenerator = () => MOCK_UUID
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		// Initialize HostProvider if not already done
+		if (!HostProvider.isInitialized()) {
+			const mockHostBridge: any = {
+				workspaceClient: {},
+				envClient: {
+					getHostVersion: sandbox.stub().resolves({
+						clineVersion: "1.0.0",
+						platform: "darwin",
+						clineType: "vscode",
+					}),
+				},
+				windowClient: {},
+				diffClient: {},
+			}
+
+			HostProvider.initialize(
+				() => null as any, // createWebviewProvider
+				() => null as any, // createDiffViewProvider
+				() => null as any, // createCommentReviewController
+				() => null as any, // createTerminalManager
+				mockHostBridge,
+				() => {}, // logToChannel
+				async () => "http://localhost", // getCallbackUrl
+				async () => "", // getBinaryLocation
+				"/test/extension", // extensionFsPath
+				"/test/storage", // globalStorageFsPath
+			)
+			hostProviderInitialized = true
+		}
+
+		// Mock global state
+		mockGlobalState = { get: sandbox.stub(), update: sandbox.stub() }
+
+		// Mock extension storage
+		mockStorage = { globalState: mockGlobalState } as unknown as StorageContext
+
+		// Reset the module-level node-machine-id stub
+		machineIdStub.reset()
+
+		// Reset the distinctId module state
+		setDistinctId("")
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+
+		// Reset HostProvider if we initialized it
+		if (hostProviderInitialized) {
+			HostProvider.reset()
+			hostProviderInitialized = false
+		}
+	})
+
+	it("should use id from extension globalstate if it exists", async () => {
+		mockGlobalState.get.withArgs(_GENERATED_MACHINE_ID_KEY).returns(MOCK_GLOBAL_STATE_ID)
+		// machineIdStub is the module-level stub (left unconfigured -> resolves undefined)
+
+		await initializeDistinctId(mockStorage, mockUuidGenerator)
+
+		expect(getDistinctId()).to.equal(MOCK_GLOBAL_STATE_ID)
+		expect(machineIdStub.notCalled).to.be.true
+		expect(mockGlobalState.update.notCalled).to.be.true
+	})
+
+	it("should use the machine ID from node-machine-id", async () => {
+		// Mock node-machine-id to return a machine ID
+		machineIdStub.resolves(MOCK_MACHINE_ID)
+
+		await initializeDistinctId(mockStorage, mockUuidGenerator)
+
+		expect(getDistinctId()).to.equal(MOCK_MACHINE_ID)
+		expect(machineIdStub.calledOnce).to.be.true
+		expect(mockGlobalState.update.notCalled).to.be.true
+	})
+
+	it("distinct ID should be stable", async () => {
+		mockGlobalState.get.withArgs(_GENERATED_MACHINE_ID_KEY).returns(undefined)
+		// Mock node-machine-id to return a machine ID
+		machineIdStub.resolves(MOCK_MACHINE_ID)
+
+		await initializeDistinctId(mockStorage, mockUuidGenerator)
+		expect(getDistinctId()).to.equal(MOCK_MACHINE_ID)
+
+		await initializeDistinctId(mockStorage, mockUuidGenerator)
+		expect(getDistinctId()).to.equal(MOCK_MACHINE_ID)
+
+		expect(mockGlobalState.update.notCalled).to.be.true
+	})
+
+	it("should generate and store UUID if node-machine-id returns empty string", async () => {
+		mockGlobalState.get.withArgs(_GENERATED_MACHINE_ID_KEY).returns(undefined)
+		// Mock node-machine-id to return empty string
+		machineIdStub.resolves("")
+
+		await initializeDistinctId(mockStorage, mockUuidGenerator)
+
+		expect(getDistinctId()).to.equal(GENERATED_MACHINE_ID)
+		expect(machineIdStub.calledOnce).to.be.true
+		expect(mockGlobalState.update.calledWith(_GENERATED_MACHINE_ID_KEY, GENERATED_MACHINE_ID)).to.be.true
+	})
+
+	it("should handle node-machine-id errors gracefully", async () => {
+		mockGlobalState.get.withArgs(_GENERATED_MACHINE_ID_KEY).returns(undefined)
+		// Mock node-machine-id to throw an error
+		machineIdStub.rejects(new Error("Failed to get machine ID"))
+
+		await initializeDistinctId(mockStorage, mockUuidGenerator)
+
+		expect(getDistinctId()).to.equal(GENERATED_MACHINE_ID)
+		expect(machineIdStub.calledOnce).to.be.true
+		expect(mockGlobalState.update.calledWith(_GENERATED_MACHINE_ID_KEY, GENERATED_MACHINE_ID)).to.be.true
+	})
+})
diff --git a/apps/vscode/src/services/logging/distinctId.ts b/apps/vscode/src/services/logging/distinctId.ts
new file mode 100644
index 0000000..4d3e085
--- /dev/null
+++ b/apps/vscode/src/services/logging/distinctId.ts
@@ -0,0 +1,78 @@
+import { machineId } from "node-machine-id"
+import { v4 as uuidv4 } from "uuid"
+import { HostRegistryInfo } from "@/registry"
+import { Logger } from "@/shared/services/Logger"
+import { StorageContext } from "@/shared/storage"
+
+/*
+ * Unique identifier for the current installation.
+ */
+let _distinctId = ""
+
+/**
+ * Some environments don't return a value for the machine ID. For these situations we generated
+ * a unique ID and store it locally.
+ */
+export const _GENERATED_MACHINE_ID_KEY = "cline.generatedMachineId"
+
+export async function initializeDistinctId(storage: StorageContext, uuid: () => string = uuidv4) {
+	// Try to read the ID from storage.
+	let distinctId = storage.globalState.get<string>(_GENERATED_MACHINE_ID_KEY)
+
+	if (!distinctId) {
+		// Get the ID from the host environment.
+		distinctId = await getMachineId()
+	}
+	if (!distinctId) {
+		// Fallback to generating a unique ID and keeping in global storage.
+		Logger.warn("No machine ID found for telemetry, generating UUID")
+		// Add a prefix to the UUID so we can see in the telemetry how many clients are don't have a machine ID.
+		distinctId = `cl-${uuid()}`
+		storage.globalState.update(_GENERATED_MACHINE_ID_KEY, distinctId)
+	}
+
+	setDistinctId(distinctId)
+
+	await HostRegistryInfo.init(distinctId)
+
+	Logger.log("[DistinctId] initialized:", distinctId)
+}
+
+/*
+ * Get machine ID using node-machine-id package
+ * This works across all platforms (VS Code, JetBrains, CLI)
+ */
+async function getMachineId(): Promise<string | undefined> {
+	try {
+		// Get the machine ID using node-machine-id package
+		// This provides a deterministic ID across different operating systems
+		const id = await machineId()
+		return id
+	} catch (error) {
+		Logger.log("[DistinctId] Failed to get machine ID from node-machine-id", error)
+		return undefined
+	}
+}
+
+/*
+ * Set the distinct ID for logging and telemetry.
+ * This is updated to Cline User ID when authenticated.
+ */
+export function setDistinctId(newId: string) {
+	if (_distinctId && _distinctId !== newId) {
+		Logger.log("[DistinctId] Updating...", `From ${_distinctId} to ${newId}`)
+	}
+	_distinctId = newId
+}
+
+/*
+ * Unique identifier for the current user
+ * If authenticated, this will be the Cline User ID.
+ * Else, this will be the machine ID, or the anonymous ID as a fallback.
+ */
+export function getDistinctId() {
+	if (!_distinctId) {
+		Logger.debug("[DistinctId] Not initialized. Call initializeDistinctId() first.")
+	}
+	return _distinctId
+}
diff --git a/apps/vscode/src/services/mcp/McpHub.ts b/apps/vscode/src/services/mcp/McpHub.ts
new file mode 100644
index 0000000..f70fce4
--- /dev/null
+++ b/apps/vscode/src/services/mcp/McpHub.ts
@@ -0,0 +1,1909 @@
+import { setTimeout as setTimeoutPromise } from "node:timers/promises"
+import { sendMcpServersUpdate } from "@core/controller/mcp/subscribeToMcpServers"
+import { getMcpSettingsFilePath as getMcpSettingsFilePathHelper } from "@core/storage/disk"
+import { StateManager } from "@core/storage/StateManager"
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
+import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import {
+	CallToolResultSchema,
+	GetPromptResultSchema,
+	ListPromptsResultSchema,
+	ListResourcesResultSchema,
+	ListResourceTemplatesResultSchema,
+	ListToolsResultSchema,
+	ReadResourceResultSchema,
+} from "@modelcontextprotocol/sdk/types.js"
+import {
+	DEFAULT_MCP_TIMEOUT_SECONDS,
+	type McpPrompt,
+	type McpPromptResponse,
+	type McpResource,
+	type McpResourceResponse,
+	type McpResourceTemplate,
+	type McpServer,
+	type McpTool,
+	type McpToolCallResponse,
+	MIN_MCP_TIMEOUT_SECONDS,
+} from "@shared/mcp"
+import { convertMcpServersToProtoMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { secondsToMs } from "@utils/time"
+import chokidar, { type FSWatcher } from "chokidar"
+import deepEqual from "fast-deep-equal"
+import * as fs from "fs/promises"
+import { nanoid } from "nanoid"
+import ReconnectingEventSource from "reconnecting-eventsource"
+import { z } from "zod"
+import { HostProvider } from "@/hosts/host-provider"
+import { fetch } from "@/shared/net"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { Logger } from "@/shared/services/Logger"
+import { expandEnvironmentVariables } from "@/utils/envExpansion"
+import type { TelemetryService } from "../telemetry/TelemetryService"
+import { DEFAULT_REQUEST_TIMEOUT_MS } from "./constants"
+import { McpOAuthManager } from "./McpOAuthManager"
+import { updateMcpSettingsFile } from "./settingsLock"
+import { StreamableHttpReconnectHandler } from "./StreamableHttpReconnectHandler"
+import { BaseConfigSchema, McpSettingsSchema, ServerConfigSchema } from "./schemas"
+import type { McpConnection, McpServerConfig, Transport } from "./types"
+export class McpHub {
+	getMcpServersPath: () => Promise<string>
+	private getSettingsDirectoryPath: () => Promise<string>
+	private clientVersion: string
+	private telemetryService: TelemetryService
+	private mcpOAuthManager: McpOAuthManager
+
+	private settingsWatcher?: FSWatcher
+	private fileWatchers: Map<string, FSWatcher> = new Map()
+	connections: McpConnection[] = []
+	isConnecting = false
+	/**
+	 * Fingerprint of the connection-relevant view of the settings file as of the
+	 * watcher's last reconciliation.
+	 *
+	 * The settings-file watcher uses this single, process-agnostic check to
+	 * decide whether a file change needs action: it recomputes the fingerprint
+	 * and skips when it's unchanged. Because the fingerprint is keyed on file
+	 * CONTENT rather than on who wrote it:
+	 *   - writes that change nothing connection-relevant (e.g. OAuth
+	 *     codeVerifier/clientInformation churn during a handshake) are no-ops,
+	 *     which prevents a self-perpetuating watcher → reconnect → write loop;
+	 *   - a write from any other process (CLI, another window) that does change
+	 *     something is processed normally;
+	 *   - whether an access token is present is part of the fingerprint, so an
+	 *     authorization completed elsewhere still triggers a reconnect via
+	 *     serverGainedOAuthTokens.
+	 *
+	 * Combined with atomic writes, a reader can never
+	 * observe a torn/empty file mid-write, so the worst case is a redundant
+	 * reconciliation rather than dropping the server list.
+	 */
+	private lastConnectionFingerprint?: string
+
+	/**
+	 * Map of unique keys to each connected server names
+	 */
+	private static mcpServerKeys = new Map<string, string>()
+
+	// Store notifications for display in chat
+	private pendingNotifications: Array<{
+		serverName: string
+		level: string
+		message: string
+		timestamp: number
+	}> = []
+
+	// Callback for sending notifications to active task
+	private notificationCallback?: (serverName: string, level: string, message: string) => void
+
+	// Callback for notifying when the MCP tool list changes (servers added/removed/reconnected).
+	// Used by SdkController to restart the SDK session with updated tools.
+	private toolListChangeCallback?: () => void
+	// Fingerprint of the last tool list snapshot, used to detect actual tool list changes
+	// vs. mere status updates (e.g., error messages appended).
+	private lastToolFingerprint = ""
+	// Debounce timer for tool list change checks. When a server connects,
+	// notifyWebviewOfServerChanges() fires multiple times in quick succession
+	// (status change, tools discovered, etc.). Without debouncing, the callback
+	// fires multiple times causing duplicate messages (S6-28).
+	private toolListChangeDebounceTimer?: ReturnType<typeof setTimeout>
+
+	constructor(
+		getMcpServersPath: () => Promise<string>,
+		getSettingsDirectoryPath: () => Promise<string>,
+		clientVersion: string,
+		telemetryService: TelemetryService,
+	) {
+		this.getMcpServersPath = getMcpServersPath
+		this.getSettingsDirectoryPath = getSettingsDirectoryPath
+		this.clientVersion = clientVersion
+		this.telemetryService = telemetryService
+		this.mcpOAuthManager = new McpOAuthManager(() => this.getMcpSettingsFilePath())
+		this.watchMcpSettingsFile()
+		this.initializeMcpServers()
+	}
+
+	getServers(): McpServer[] {
+		// Only return enabled servers
+
+		return this.connections.filter((conn) => !conn.server.disabled).map((conn) => conn.server)
+	}
+
+	/**
+	 * Get the MCP server name from its unique key.
+	 * If the key is not found, return the key itself.
+	 */
+	public static getMcpServerByKey(key: string): string {
+		return McpHub.mcpServerKeys.get(key) || key
+	}
+
+	/**
+	 * Create a unique key for an MCP server based on its name.
+	 * This avoids making a tool name too long while still ensuring uniqueness.
+	 */
+	private getMcpServerKey(server: string): string {
+		// Reuse existing key if server is already registered
+		for (const [existingKey, existingServer] of McpHub.mcpServerKeys.entries()) {
+			if (existingServer === server) {
+				return existingKey
+			}
+		}
+		// Generate a short 6-character unique ID for the server
+		// Add c prefix to ensure it starts with a letter (for compatibility with Gemini)
+		// Only use the first 5 characters of nanoid to keep it short
+		const uid = "c" + nanoid(5)
+		McpHub.mcpServerKeys.set(uid, server)
+		return uid
+	}
+
+	/**
+	 * Gets the path to the MCP settings file
+	 * @returns Path to the MCP settings file
+	 */
+	async getMcpSettingsFilePath(): Promise<string> {
+		return getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+	}
+
+	/**
+	 * Record the post-write connection fingerprint so this window's watcher treats
+	 * its own write as a no-op. This does not write the settings file.
+	 */
+	recordSettingsFingerprint(servers: Record<string, McpServerConfig>): void {
+		this.lastConnectionFingerprint = this.computeConnectionFingerprint(servers)
+	}
+
+	private async readPostWriteMcpSettings(): Promise<z.infer<typeof McpSettingsSchema>> {
+		const settings = await this.readAndValidateMcpSettingsFile()
+		if (!settings) {
+			throw new Error("Failed to read or validate MCP settings after write")
+		}
+		this.recordSettingsFingerprint(settings.mcpServers as Record<string, McpServerConfig>)
+		return settings
+	}
+
+	private async readAndValidateMcpSettingsFile(): Promise<z.infer<typeof McpSettingsSchema> | undefined> {
+		try {
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			const content = await fs.readFile(settingsPath, "utf-8")
+
+			let config: any
+
+			// Handle empty or minimal files silently - this is a valid state meaning "no MCP servers"
+			const trimmedContent = content.trim()
+			if (!trimmedContent || trimmedContent === "{}" || trimmedContent === '{"mcpServers":{}}') {
+				return { mcpServers: {} }
+			}
+
+			// Parse JSON file content
+			try {
+				config = JSON.parse(content)
+			} catch (_error) {
+				HostProvider.window
+					.showMessage({
+						type: ShowMessageType.ERROR,
+						message: `Invalid JSON in MCP settings file. Please check the syntax.`,
+						options: {
+							detail: settingsPath,
+							items: ["Open Settings File"],
+						},
+					})
+					.then((response) => {
+						if (response.selectedOption === "Open Settings File") {
+							HostProvider.window.showTextDocument({
+								path: settingsPath,
+								options: {},
+							})
+						}
+					})
+				return undefined
+			}
+
+			// Expand environment variables before validation
+			// This allows ${env:VAR_NAME} syntax in URLs, headers, env vars, etc.
+			config = expandEnvironmentVariables(config)
+
+			// Validate against schema
+			const result = McpSettingsSchema.safeParse(config)
+			if (!result.success) {
+				// Build a human-readable summary of what failed.
+				// Zod paths look like ["mcpServers", "linear", "transport", "url"] — we want to surface
+				// the server name (index 1) and the field path so users know exactly what to fix.
+				const issuesByServer = new Map<string, string[]>()
+				for (const issue of result.error.issues) {
+					// path[0] === "mcpServers", path[1] === serverName
+					const serverName = issue.path.length >= 2 ? String(issue.path[1]) : "(unknown server)"
+					const fieldPath = issue.path.slice(2).join(".") // e.g. "transport.url" or "command"
+					const detail = fieldPath ? `${fieldPath}: ${issue.message}` : issue.message
+					if (!issuesByServer.has(serverName)) {
+						issuesByServer.set(serverName, [])
+					}
+					issuesByServer.get(serverName)!.push(detail)
+				}
+
+				const serverSummaries = Array.from(issuesByServer.entries())
+					.map(([server, details]) => `  • ${server}: ${details.join(", ")}`)
+					.join("\n")
+
+				HostProvider.window
+					.showMessage({
+						type: ShowMessageType.ERROR,
+						message: `MCP settings schema error — no servers were loaded.`,
+						options: {
+							detail: `${settingsPath}\n\n${serverSummaries}`,
+							modal: false,
+							items: ["Open Settings File"],
+						},
+					})
+					.then((response) => {
+						if (response.selectedOption === "Open Settings File") {
+							HostProvider.window.showTextDocument({
+								path: settingsPath,
+								options: {},
+							})
+						}
+					})
+				return undefined
+			}
+
+			return result.data
+		} catch (error) {
+			Logger.error("Failed to read MCP settings:", error)
+			return undefined
+		}
+	}
+
+	private async watchMcpSettingsFile(): Promise<void> {
+		const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+
+		this.settingsWatcher = chokidar.watch(settingsPath, {
+			persistent: true, // Keep the process running as long as files are being watched
+			ignoreInitial: true, // Don't fire 'add' events when discovering the file initially
+			awaitWriteFinish: {
+				// Wait for writes to finish before emitting events (handles chunked writes)
+				stabilityThreshold: 100, // Wait 100ms for file size to remain constant
+				pollInterval: 100, // Check file size every 100ms while waiting for stability
+			},
+			atomic: true, // Handle atomic writes where editors write to a temp file then rename (prevents duplicate events)
+		})
+
+		this.settingsWatcher.on("change", async () => {
+			const settings = await this.readAndValidateMcpSettingsFile()
+			if (settings) {
+				// Skip when nothing connection-relevant changed. This covers our own
+				// writes (callers pre-seed the fingerprint) as well as
+				// OAuth-handshake churn from the SDK (codeVerifier/clientInformation
+				// rewrites on every connect attempt for unauthenticated servers). A
+				// write from the CLI or another window that genuinely changes a
+				// server, or a token appearing/disappearing, produces a different
+				// fingerprint and is processed normally.
+				const fingerprint = this.computeConnectionFingerprint(settings.mcpServers as Record<string, McpServerConfig>)
+				if (fingerprint === this.lastConnectionFingerprint) {
+					return
+				}
+				this.lastConnectionFingerprint = fingerprint
+
+				try {
+					// Re-add any remotely configured servers that were manually removed from the file
+					const remoteServers = StateManager.get().getRemoteConfigSettings().remoteMCPServers
+					if (remoteServers?.length) {
+						let fileNeedsUpdate = false
+						for (const rs of remoteServers) {
+							if (!settings.mcpServers[rs.name]) {
+								;(settings.mcpServers as Record<string, any>)[rs.name] = {
+									url: rs.url,
+									type: "streamableHttp",
+									disabled: false,
+									autoApprove: [],
+									remoteConfigured: true,
+								}
+								fileNeedsUpdate = true
+							}
+						}
+						if (fileNeedsUpdate) {
+							const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+							const fresh = await updateMcpSettingsFile(settingsPath, (current) => {
+								const servers = current.mcpServers as Record<string, any>
+								for (const rs of remoteServers) {
+									if (!servers[rs.name]) {
+										servers[rs.name] = {
+											url: rs.url,
+											type: "streamableHttp",
+											disabled: false,
+											autoApprove: [],
+											remoteConfigured: true,
+										}
+									}
+								}
+								current.mcpServers = servers
+								return current
+							})
+							this.recordSettingsFingerprint(fresh.mcpServers as Record<string, McpServerConfig>)
+							settings.mcpServers = fresh.mcpServers as any
+						}
+					}
+					await this.updateServerConnections(settings.mcpServers)
+				} catch (error) {
+					Logger.error("Failed to process MCP settings change:", error)
+				}
+			}
+		})
+
+		this.settingsWatcher.on("error", (error) => {
+			Logger.error("Error watching MCP settings file:", error)
+		})
+	}
+
+	private async initializeMcpServers(): Promise<void> {
+		const settings = await this.readAndValidateMcpSettingsFile()
+		if (settings) {
+			// Seed the watcher's baseline so the first post-startup write is
+			// compared against the current connection-relevant state, not undefined.
+			this.lastConnectionFingerprint = this.computeConnectionFingerprint(
+				settings.mcpServers as Record<string, McpServerConfig>,
+			)
+			await this.updateServerConnections(settings.mcpServers)
+		}
+	}
+
+	private findConnection(name: string, _source: "rpc" | "internal"): McpConnection | undefined {
+		return this.connections.find((conn) => conn.server.name === name)
+	}
+
+	private async connectToServer(
+		name: string,
+		config: z.infer<typeof ServerConfigSchema>,
+		source: "rpc" | "internal",
+	): Promise<void> {
+		// Remove existing connection if it exists (should never happen, the connection should be deleted beforehand)
+		this.connections = this.connections.filter((conn) => conn.server.name !== name)
+
+		// Validate remote MCP server URL against remote config if blockPersonalRemoteMCPServers is enabled
+		if (config.type !== "stdio" && "url" in config && config.url) {
+			const stateManager = StateManager.get()
+			const remoteConfig = stateManager.getRemoteConfigSettings()
+
+			if (remoteConfig.blockPersonalRemoteMCPServers === true) {
+				const remoteMCPServers = remoteConfig.remoteMCPServers || []
+				const allowedUrls = remoteMCPServers.map((server) => server.url)
+
+				if (!allowedUrls.includes(config.url)) {
+					return
+				}
+			}
+		}
+
+		// Validate local MCP servers based on remote config (enterprise feature)
+		if (config.type === "stdio") {
+			const stateManager = StateManager.get()
+			const remoteConfig = stateManager.getRemoteConfigSettings()
+
+			// Early exit for non-enterprise users: if no remote config is set, allow all local servers
+			if (Object.keys(remoteConfig).length === 0) {
+				// No remote config restrictions - proceed with connection (default behavior for non-enterprise users)
+				// This ensures backwards compatibility and that regular users are not affected
+			} else {
+				// Enterprise restrictions apply
+
+				// If the legacy marketplace policy is explicitly disabled by enterprise config, block all local servers
+				if (remoteConfig.mcpMarketplaceEnabled === false) {
+					return
+				}
+
+				// If allowlist exists, only servers on the allowlist are allowed
+				const hasAllowlist = remoteConfig.allowedMCPServers && remoteConfig.allowedMCPServers.length > 0
+				if (hasAllowlist) {
+					const allowedIds = remoteConfig.allowedMCPServers!.map((server: { id: string }) => server.id)
+					if (!allowedIds.includes(name)) {
+						return
+					}
+				}
+
+				// If local MCP servers are enabled with no allowlist, all local servers are allowed
+			}
+		}
+
+		if (config.disabled) {
+			//Logger.log(`[MCP Debug] Creating disabled connection object for server "${name}"`)
+			// Create a connection object for disabled server so it appears in UI
+			const disabledConnection: McpConnection = {
+				server: {
+					name,
+					config: JSON.stringify(config),
+					status: "disconnected",
+					disabled: true,
+				},
+				client: null as unknown as Client,
+				transport: null as unknown as Transport,
+			}
+			this.connections.push(disabledConnection)
+			return
+		}
+
+		try {
+			// Store unexpanded config for display/comparison (keeps credentials out of stored config)
+			const configForStorage = JSON.stringify(config)
+
+			// Expand environment variables in config before using it
+			const expandedConfig = expandEnvironmentVariables(config)
+
+			// Each MCP server requires its own transport connection and has unique capabilities, configurations, and error handling. Having separate clients also allows proper scoping of resources/tools and independent server management like reconnection.
+			const client = new Client(
+				{
+					name: "Cline",
+					version: this.clientVersion,
+				},
+				{
+					capabilities: {},
+				},
+			)
+
+			let transport: StdioClientTransport | SSEClientTransport | StreamableHTTPClientTransport
+
+			// Create OAuth provider for remote transports (SSE and HTTP)
+			const authProvider =
+				expandedConfig.type === "sse" || expandedConfig.type === "streamableHttp"
+					? await this.mcpOAuthManager.getOrCreateProvider(name, expandedConfig.url)
+					: undefined
+
+			switch (expandedConfig.type) {
+				case "stdio": {
+					transport = new StdioClientTransport({
+						command: expandedConfig.command,
+						args: expandedConfig.args,
+						cwd: expandedConfig.cwd,
+						env: {
+							...getDefaultEnvironment(),
+							...(expandedConfig.env || {}), // Now has expanded environment variables
+						},
+						stderr: "pipe",
+					})
+
+					transport.onerror = async (error) => {
+						Logger.error(`Transport error for "${name}":`, error)
+						const connection = this.findConnection(name, source)
+						if (connection) {
+							connection.server.status = "disconnected"
+							McpHub.mcpServerKeys.delete(connection.server.uid || name)
+							this.appendErrorMessage(connection, error instanceof Error ? error.message : `${error}`)
+						}
+						await this.notifyWebviewOfServerChanges()
+					}
+
+					transport.onclose = async () => {
+						const connection = this.findConnection(name, source)
+						if (connection) {
+							connection.server.status = "disconnected"
+							McpHub.mcpServerKeys.delete(connection.server.uid || name)
+						}
+						await this.notifyWebviewOfServerChanges()
+					}
+
+					await transport.start()
+					const stderrStream = transport.stderr
+					if (stderrStream) {
+						stderrStream.on("data", async (data: Buffer) => {
+							const output = data.toString()
+							const isInfoLog = !/\berror\b/i.test(output)
+
+							if (isInfoLog) {
+								Logger.log(`Server "${name}" info:`, output)
+							} else {
+								Logger.error(`Server "${name}" stderr:`, output)
+								const connection = this.findConnection(name, source)
+								if (connection) {
+									this.appendErrorMessage(connection, output)
+									if (connection.server.status === "disconnected") {
+										await this.notifyWebviewOfServerChanges()
+									}
+								}
+							}
+						})
+					} else {
+						Logger.error(`No stderr stream for ${name}`)
+					}
+					transport.start = async () => {}
+					break
+				}
+				case "sse": {
+					const sseOptions = {
+						authProvider,
+						requestInit: {
+							headers: expandedConfig.headers,
+						},
+					}
+					const reconnectingEventSourceOptions = {
+						max_retry_time: 5000,
+						withCredentials: !!expandedConfig.headers?.["Authorization"],
+						// IMPORTANT: Custom fetch function is required for SSE with OAuth
+						// When we provide eventSourceInit, we override the SDK's default fetch
+						// The SDK's default would call _commonHeaders() for auth, but since we're
+						// overriding it, we must provide our own fetch that:
+						// 1. Calls authProvider.tokens() dynamically (not captured once)
+						// 2. Gets fresh tokens for each connection/reconnection
+						// 3. Allows the SDK to auto-refresh expired tokens
+						// Without this, tokens would be stale and fail after expiry
+						fetch: authProvider
+							? async (url: string | URL, init?: RequestInit) => {
+									const tokens = await authProvider.tokens() // Dynamic - gets fresh tokens
+									const headers = new Headers(init?.headers)
+									if (tokens?.access_token) {
+										headers.set("Authorization", `Bearer ${tokens.access_token}`)
+									}
+									return fetch(url.toString(), { ...init, headers })
+								}
+							: undefined,
+					}
+					// Use ReconnectingEventSource for auto-reconnection on connection drops
+					global.EventSource = ReconnectingEventSource
+					transport = new SSEClientTransport(new URL(expandedConfig.url), {
+						...sseOptions,
+						eventSourceInit: reconnectingEventSourceOptions,
+					})
+
+					transport.onerror = async (error) => {
+						Logger.error(`Transport error for "${name}":`, error)
+						const connection = this.findConnection(name, source)
+						if (connection) {
+							connection.server.status = "disconnected"
+							McpHub.mcpServerKeys.delete(connection.server.uid || name)
+							this.appendErrorMessage(connection, error instanceof Error ? error.message : `${error}`)
+						}
+						await this.notifyWebviewOfServerChanges()
+					}
+					break
+				}
+				case "streamableHttp": {
+					// Use ReconnectingEventSource for auto-reconnection on connection drops
+					global.EventSource = ReconnectingEventSource
+
+					// Custom fetch wrapper that treats 404 as 405 for GET requests.
+					// The MCP SDK sends a GET request to check for SSE stream support.
+					// Per MCP spec, servers should return 405 if they don't support SSE,
+					// but many servers (incorrectly) return 404. The SDK only handles 405
+					// gracefully, so we normalize 404 -> 405 to fix compatibility.
+					// See: https://github.com/modelcontextprotocol/typescript-sdk/issues/1150
+					const streamableHttpFetch = (async (url, init) => {
+						const response = await fetch(url, init)
+						if (init?.method === "GET" && response.status === 404) {
+							return new Response(response.body, {
+								status: 405,
+								statusText: "Method Not Allowed",
+								headers: response.headers,
+							})
+						}
+						return response
+					}) as typeof fetch
+
+					transport = new StreamableHTTPClientTransport(new URL(expandedConfig.url), {
+						authProvider,
+						requestInit: {
+							headers: expandedConfig.headers ?? undefined,
+						},
+						fetch: streamableHttpFetch,
+					})
+
+					const reconnectHandler = new StreamableHttpReconnectHandler(name, {
+						findConnection: () => this.findConnection(name, source),
+						deleteConnection: () => this.deleteConnection(name),
+						connectToServer: () => this.connectToServer(name, config, source),
+						notifyWebviewOfServerChanges: () => this.notifyWebviewOfServerChanges(),
+						appendErrorMessage: (conn, msg) => this.appendErrorMessage(conn as McpConnection, msg),
+						deleteServerKey: (uid) => McpHub.mcpServerKeys.delete(uid),
+						delay: (ms) => setTimeoutPromise(ms),
+					})
+
+					transport.onerror = (error) => reconnectHandler.handleError(error)
+					break
+				}
+				default:
+					throw new Error(`Unknown transport type: ${(config as any).type}`)
+			}
+
+			const connection: McpConnection = {
+				server: {
+					name,
+					config: configForStorage,
+					status: "connecting",
+					disabled: config.disabled,
+					uid: this.getMcpServerKey(name),
+					oauthRequired: false,
+					oauthAuthStatus: "authenticated",
+				},
+				client,
+				transport,
+				authProvider,
+			}
+			this.connections.push(connection)
+
+			// Connect - wrap in try-catch to detect OAuth requirement
+			try {
+				await client.connect(transport)
+			} catch (error) {
+				if (error instanceof UnauthorizedError) {
+					// Server requires OAuth authentication
+					Logger.log(`Server "${name}" requires OAuth authentication`)
+					const unauthConnection: McpConnection = {
+						server: {
+							name,
+							config: JSON.stringify(config),
+							status: "disconnected",
+							disabled: false,
+							oauthRequired: true,
+							oauthAuthStatus: "unauthenticated",
+							error: "This MCP server requires authentication to get started.",
+							uid: this.getMcpServerKey(name),
+						},
+						client,
+						transport,
+						authProvider, // CRITICAL: Keep authProvider so it's available when user authenticates!
+					}
+					// Replace the connection with unauthenticated version
+					this.connections = this.connections.filter((conn) => conn.server.name !== name)
+					this.connections.push(unauthConnection)
+					await this.notifyWebviewOfServerChanges()
+					return // Don't throw, just mark as needs auth
+				}
+				// Re-throw other errors
+				throw error
+			}
+
+			connection.server.status = "connected"
+			connection.server.error = ""
+
+			// Register notification handler for real-time messages
+			//Logger.log(`[MCP Debug] Setting up notification handlers for server: ${name}`)
+			//Logger.log(`[MCP Debug] Client instance:`, connection.client)
+			//Logger.log(`[MCP Debug] Transport type:`, config.type)
+
+			// Try to set notification handler using the client's method
+			try {
+				// Import the notification schema from MCP SDK
+				const { z } = await import("zod")
+
+				// Define the notification schema for notifications/message
+				const NotificationMessageSchema = z.object({
+					method: z.literal("notifications/message"),
+					params: z
+						.object({
+							level: z.enum(["debug", "info", "warning", "error"]).optional(),
+							logger: z.string().optional(),
+							data: z.string().optional(),
+							message: z.string().optional(),
+						})
+						.optional(),
+				})
+
+				// Set the notification handler
+				connection.client.setNotificationHandler(NotificationMessageSchema as any, async (notification: any) => {
+					//Logger.log(`[MCP Notification] ${name}:`, JSON.stringify(notification, null, 2))
+
+					const params = notification.params || {}
+					const level = params.level || "info"
+					const data = params.data || params.message || ""
+					const logger = params.logger || ""
+
+					//Logger.log(`[MCP Message Notification] ${name}: level=${level}, data=${data}, logger=${logger}`)
+
+					// Format the message
+					const message = logger ? `[${logger}] ${data}` : data
+
+					// Send notification directly to active task if callback is set
+					if (this.notificationCallback) {
+						//Logger.log(`[MCP Debug] Sending notification to active task: ${message}`)
+						this.notificationCallback(name, level, message)
+					} else {
+						// Fallback: store for later retrieval
+						//Logger.log(`[MCP Debug] No active task, storing notification: ${message}`)
+						this.pendingNotifications.push({
+							serverName: name,
+							level,
+							message,
+							timestamp: Date.now(),
+						})
+					}
+				})
+				//Logger.log(`[MCP Debug] Successfully set notifications/message handler for ${name}`)
+
+				// Also set a fallback handler for any other notification types
+				connection.client.fallbackNotificationHandler = async (notification: any) => {
+					//Logger.log(`[MCP Fallback Notification] ${name}:`, JSON.stringify(notification, null, 2))
+
+					// Show in VS Code for visibility
+					HostProvider.window.showMessage({
+						type: ShowMessageType.INFORMATION,
+						message: `MCP ${name}: ${notification.method || "unknown"} - ${JSON.stringify(notification.params || {})}`,
+					})
+				}
+				//Logger.log(`[MCP Debug] Successfully set fallback notification handler for ${name}`)
+			} catch (error) {
+				Logger.error(`[MCP Debug] Error setting notification handlers for ${name}:`, error)
+			}
+
+			// Initial fetch of tools, resources, and prompts
+			connection.server.tools = await this.fetchToolsList(name)
+			connection.server.resources = await this.fetchResourcesList(name)
+			connection.server.resourceTemplates = await this.fetchResourceTemplatesList(name)
+			connection.server.prompts = await this.fetchPromptsList(name)
+		} catch (error) {
+			// Update status with error
+			const connection = this.findConnection(name, source)
+			if (connection) {
+				connection.server.status = "disconnected"
+				this.appendErrorMessage(connection, error instanceof Error ? error.message : String(error))
+			}
+			throw error
+		}
+	}
+
+	private appendErrorMessage(connection: McpConnection, error: string) {
+		const newError = connection.server.error ? `${connection.server.error}\n${error}` : error
+		connection.server.error = newError //.slice(0, 800)
+	}
+
+	private async fetchToolsList(serverName: string): Promise<McpTool[]> {
+		try {
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+
+			if (!connection) {
+				throw new Error(`No connection found for server: ${serverName}`)
+			}
+
+			// Disabled servers don't have clients, so return empty tools list
+			if (connection.server.disabled || !connection.client) {
+				return []
+			}
+
+			const response = await connection.client.request({ method: "tools/list" }, ListToolsResultSchema, {
+				timeout: DEFAULT_REQUEST_TIMEOUT_MS,
+			})
+
+			// Get autoApprove settings
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			const content = await fs.readFile(settingsPath, "utf-8")
+			const config = JSON.parse(content)
+			const autoApproveConfig = config.mcpServers[serverName]?.autoApprove || []
+
+			// Mark tools as always allowed based on settings
+			const tools = (response?.tools || []).map((tool) => ({
+				...tool,
+				autoApprove: autoApproveConfig.includes(tool.name),
+			}))
+
+			return tools
+		} catch (error) {
+			Logger.error(`Failed to fetch tools for ${serverName}:`, error)
+			return []
+		}
+	}
+
+	private async fetchResourcesList(serverName: string): Promise<McpResource[]> {
+		try {
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+
+			// Disabled servers don't have clients, so return empty resources list
+			if (!connection || connection.server.disabled || !connection.client) {
+				return []
+			}
+
+			const response = await connection.client.request({ method: "resources/list" }, ListResourcesResultSchema, {
+				timeout: DEFAULT_REQUEST_TIMEOUT_MS,
+			})
+			return response?.resources || []
+		} catch (_error) {
+			// Logger.error(`Failed to fetch resources for ${serverName}:`, error)
+			return []
+		}
+	}
+
+	private async fetchResourceTemplatesList(serverName: string): Promise<McpResourceTemplate[]> {
+		try {
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+
+			// Disabled servers don't have clients, so return empty resource templates list
+			if (!connection || connection.server.disabled || !connection.client) {
+				return []
+			}
+
+			const response = await connection.client.request(
+				{ method: "resources/templates/list" },
+				ListResourceTemplatesResultSchema,
+				{
+					timeout: DEFAULT_REQUEST_TIMEOUT_MS,
+				},
+			)
+
+			return response?.resourceTemplates || []
+		} catch (_error) {
+			// Logger.error(`Failed to fetch resource templates for ${serverName}:`, error)
+			return []
+		}
+	}
+
+	private async fetchPromptsList(serverName: string): Promise<McpPrompt[]> {
+		try {
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+
+			// Disabled servers don't have clients, so return empty prompts list
+			if (!connection || connection.server.disabled || !connection.client) {
+				return []
+			}
+
+			const response = await connection.client.request({ method: "prompts/list" }, ListPromptsResultSchema, {
+				timeout: DEFAULT_REQUEST_TIMEOUT_MS,
+			})
+
+			return (response?.prompts || []).map((prompt) => ({
+				name: prompt.name,
+				title: prompt.title,
+				description: prompt.description,
+				arguments: prompt.arguments?.map((arg) => ({
+					name: arg.name,
+					description: arg.description,
+					required: arg.required,
+				})),
+			}))
+		} catch (_error) {
+			return []
+		}
+	}
+
+	async deleteConnection(name: string): Promise<void> {
+		const connection = this.connections.find((conn) => conn.server.name === name)
+		if (connection) {
+			try {
+				// Only close transport and client if they exist (disabled servers don't have them)
+				if (connection.transport) {
+					await connection.transport.close()
+				}
+				if (connection.client) {
+					await connection.client.close()
+				}
+			} catch (error) {
+				Logger.error(`Failed to close transport for ${name}:`, error)
+			}
+			this.connections = this.connections.filter((conn) => conn.server.name !== name)
+		}
+	}
+
+	async clearOAuthForConnection(name: string): Promise<void> {
+		const connection = this.connections.find((conn) => conn.server.name === name)
+		if (connection) {
+			try {
+				const config = JSON.parse(connection.server.config)
+				if (config.url) {
+					await this.mcpOAuthManager.clearServerAuth(name, config.url)
+				}
+			} catch (error) {
+				Logger.error(`Failed to clear OAuth data for ${name}:`, error)
+			}
+		}
+	}
+
+	async updateServerConnectionsRPC(newServers: Record<string, McpServerConfig>): Promise<void> {
+		this.isConnecting = true
+		this.removeAllFileWatchers()
+		const currentNames = new Set(this.connections.map((conn) => conn.server.name))
+		const newNames = new Set(Object.keys(newServers))
+
+		// Delete removed servers
+		for (const name of currentNames) {
+			if (!newNames.has(name)) {
+				await this.deleteConnection(name)
+				Logger.log(`Deleted MCP server: ${name}`)
+			}
+		}
+
+		// Update or add servers
+		for (const [name, config] of Object.entries(newServers)) {
+			const currentConnection = this.connections.find((conn) => conn.server.name === name)
+
+			if (!currentConnection) {
+				// New server
+				try {
+					if (config.type === "stdio") {
+						this.setupFileWatcher(name, config)
+					}
+					await this.connectToServer(name, config, "rpc")
+				} catch (error) {
+					Logger.error(`Failed to connect to new MCP server ${name}:`, error)
+				}
+			} else if (
+				this.configsRequireRestart(JSON.parse(currentConnection.server.config), config) ||
+				this.serverGainedOAuthTokens(currentConnection, config)
+			) {
+				// Existing server with changed connection config (excludes Cline-specific settings),
+				// or an unauthenticated server whose OAuth tokens just appeared (e.g. CLI authorized it)
+				try {
+					if (config.type === "stdio") {
+						this.setupFileWatcher(name, config)
+					}
+					await this.deleteConnection(name) // Don't clear OAuth - just reconnecting with new config
+					await this.connectToServer(name, config, "rpc")
+					Logger.log(`Reconnected MCP server with updated config: ${name}`)
+				} catch (error) {
+					Logger.error(`Failed to reconnect MCP server ${name}:`, error)
+				}
+			} else {
+				// Only Cline-specific settings changed - update in-memory state without restart
+				const autoApprove = config.autoApprove || []
+				if (currentConnection.server.tools) {
+					currentConnection.server.tools = currentConnection.server.tools.map((tool) => ({
+						...tool,
+						autoApprove: autoApprove.includes(tool.name),
+					}))
+				}
+				// Also update Cline-specific settings in the stored config.
+				// This handles the case where someone manually edits the MCP settings file -
+				// the file watcher triggers this code path, and we need to sync the in-memory
+				// config with the file without restarting the server.
+				const currentConfig = JSON.parse(currentConnection.server.config)
+				currentConfig.autoApprove = config.autoApprove
+				currentConfig.timeout = config.timeout
+				currentConnection.server.config = JSON.stringify(currentConfig)
+			}
+		}
+
+		this.isConnecting = false
+	}
+
+	async updateServerConnections(newServers: Record<string, McpServerConfig>): Promise<void> {
+		this.isConnecting = true
+		this.removeAllFileWatchers()
+		const currentNames = new Set(this.connections.map((conn) => conn.server.name))
+		const newNames = new Set(Object.keys(newServers))
+
+		// Track if any connection-level changes occurred (excludes Cline-specific settings)
+		let connectionChangesOccurred = false
+
+		// Delete removed servers
+		for (const name of currentNames) {
+			if (!newNames.has(name)) {
+				await this.clearOAuthForConnection(name) // Clear OAuth data first
+				await this.deleteConnection(name) // Then delete connection
+				Logger.log(`Deleted MCP server: ${name}`)
+				connectionChangesOccurred = true
+			}
+		}
+
+		// Update or add servers
+		for (const [name, config] of Object.entries(newServers)) {
+			const currentConnection = this.connections.find((conn) => conn.server.name === name)
+
+			if (!currentConnection) {
+				// New server
+				try {
+					if (config.type === "stdio") {
+						this.setupFileWatcher(name, config)
+					}
+					await this.connectToServer(name, config, "internal")
+					connectionChangesOccurred = true
+				} catch (error) {
+					Logger.error(`Failed to connect to new MCP server ${name}:`, error)
+				}
+			} else if (
+				this.configsRequireRestart(JSON.parse(currentConnection.server.config), config) ||
+				this.serverGainedOAuthTokens(currentConnection, config)
+			) {
+				// Existing server with changed connection config (excludes Cline-specific settings),
+				// or an unauthenticated server whose OAuth tokens just appeared in the settings
+				// file (e.g. the CLI or another window completed authorization for it)
+				try {
+					// Set status to "connecting" and notify webview before restart (same pattern as restartConnection)
+					currentConnection.server.status = "connecting"
+					currentConnection.server.error = ""
+					await this.notifyWebviewOfServerChanges()
+
+					if (config.type === "stdio") {
+						this.setupFileWatcher(name, config)
+					}
+					await this.deleteConnection(name)
+					await this.connectToServer(name, config, "internal")
+					Logger.log(`Reconnected MCP server with updated config: ${name}`)
+					connectionChangesOccurred = true
+				} catch (error) {
+					Logger.error(`Failed to reconnect MCP server ${name}:`, error)
+				}
+			} else {
+				// Only Cline-specific settings changed - update in-memory state without restart
+				// Don't set connectionChangesOccurred since the RPC already returned the updated state
+				const autoApprove = config.autoApprove || []
+				if (currentConnection.server.tools) {
+					currentConnection.server.tools = currentConnection.server.tools.map((tool) => ({
+						...tool,
+						autoApprove: autoApprove.includes(tool.name),
+					}))
+				}
+				// Also update Cline-specific settings in the stored config
+				const currentConfig = JSON.parse(currentConnection.server.config)
+				currentConfig.autoApprove = config.autoApprove
+				currentConfig.timeout = config.timeout
+				currentConnection.server.config = JSON.stringify(currentConfig)
+			}
+		}
+
+		// Only notify webview if actual connection changes occurred.
+		// For Cline-specific settings changes, the RPC response already updated the webview,
+		// so we skip notification to avoid race conditions.
+		if (connectionChangesOccurred) {
+			await this.notifyWebviewOfServerChanges()
+		}
+		this.isConnecting = false
+	}
+
+	/**
+	 * Compares two MCP server configs to determine if a restart is required.
+	 * Excludes Cline-specific settings since they don't affect the MCP server transport connection.
+	 *
+	 * ## Cline-specific settings (don't require restart):
+	 * - `autoApprove`: tool approval list (UI setting)
+	 * - `timeout`: request timeout (read at request time, not connection time)
+	 *
+	 * ## MCP SDK connection settings (require restart):
+	 * - `type`, `command`, `args`, `cwd`, `env`, `url`, `headers`, `disabled`
+	 *
+	 * ## Adding new Cline-specific settings:
+	 * When adding a new setting that doesn't require server restart:
+	 * 1. Add it to the destructuring below to exclude from comparison
+	 * 2. Add it to computeConnectionFingerprint() if a change to it should (or
+	 *    should not) wake the settings watcher
+	 * 3. Update in-memory state (e.g., `connection.server.config`) in the update function
+	 * 4. Update the schema in `src/services/mcp/schemas.ts` if needed
+	 */
+	private configsRequireRestart(oldConfig: McpServerConfig, newConfig: McpServerConfig): boolean {
+		// Exclude Cline-specific settings from comparison (add new ones here).
+		// `oauth` and `metadata` are also excluded: the server's oauth block is
+		// rewritten on every token save/refresh (by this process, the CLI, or
+		// another window), and restarting on each refresh would churn the
+		// connection. Token changes are picked up separately, by
+		// serverGainedOAuthTokens in updateServerConnections.
+		const {
+			autoApprove: _oldAutoApprove,
+			timeout: _oldTimeout,
+			remoteConfigured: _oldRemoteConfigured,
+			oauth: _oldOauth,
+			metadata: _oldMetadata,
+			...oldConnectionConfig
+		} = oldConfig as McpServerConfig & { oauth?: unknown; metadata?: unknown }
+		const {
+			autoApprove: _newAutoApprove,
+			timeout: _newTimeout,
+			remoteConfigured: _newRemoteConfigured,
+			oauth: _newOauth,
+			metadata: _newMetadata,
+			...newConnectionConfig
+		} = newConfig as McpServerConfig & { oauth?: unknown; metadata?: unknown }
+		return !deepEqual(oldConnectionConfig, newConnectionConfig)
+	}
+
+	/**
+	 * True when an unauthenticated server's settings entry now carries an access
+	 * token — e.g. the CLI or another window completed OAuth for it. The settings
+	 * watcher uses this to reconnect the server so it picks up the credentials.
+	 */
+	private serverGainedOAuthTokens(connection: McpConnection, newConfig: McpServerConfig): boolean {
+		if (connection.server.oauthAuthStatus !== "unauthenticated") {
+			return false
+		}
+		const oauth = (newConfig as McpServerConfig & { oauth?: { tokens?: { access_token?: unknown } } }).oauth
+		return typeof oauth?.tokens?.access_token === "string" && oauth.tokens.access_token.length > 0
+	}
+
+	/**
+	 * Builds a fingerprint of only the parts of the settings file that affect
+	 * how connections are managed (see lastConnectionFingerprint). Per server it
+	 * captures the full config minus the `oauth` block, plus a single boolean for
+	 * whether a usable access token exists.
+	 *
+	 * Excluding the rest of the `oauth` block means OAuth-handshake churn
+	 * (codeVerifier, clientInformation, discoveryState, lastError), which the MCP
+	 * SDK rewrites on every connect attempt, does not change the fingerprint. The
+	 * access-token boolean is included so that an authorization completing
+	 * elsewhere (token appears or disappears) does change it.
+	 */
+	private computeConnectionFingerprint(mcpServers: Record<string, McpServerConfig>): string {
+		const normalized: Record<string, unknown> = {}
+		for (const name of Object.keys(mcpServers).sort()) {
+			const { oauth, ...connectionConfig } = mcpServers[name] as McpServerConfig & {
+				oauth?: { tokens?: { access_token?: unknown } }
+			}
+			const accessToken = oauth?.tokens?.access_token
+			normalized[name] = {
+				config: connectionConfig,
+				hasToken: typeof accessToken === "string" && accessToken.length > 0,
+			}
+		}
+		return JSON.stringify(normalized)
+	}
+
+	private setupFileWatcher(name: string, config: Extract<McpServerConfig, { type: "stdio" }>) {
+		const filePath = config.args?.find((arg: string) => arg.includes("build/index.js"))
+		if (filePath) {
+			// we use chokidar instead of onDidSaveTextDocument because it doesn't require the file to be open in the editor. The settings config is better suited for onDidSave since that will be manually updated by the user or Cline (and we want to detect save events, not every file change)
+			const watcher = chokidar.watch(filePath, {
+				// persistent: true,
+				// ignoreInitial: true,
+				// awaitWriteFinish: true, // This helps with atomic writes
+			})
+
+			watcher.on("change", () => {
+				Logger.log(`Detected change in ${filePath}. Restarting server ${name}...`)
+				this.restartConnection(name)
+			})
+
+			this.fileWatchers.set(name, watcher)
+		}
+	}
+
+	private removeAllFileWatchers() {
+		this.fileWatchers.forEach((watcher) => {
+			watcher.close()
+		})
+		this.fileWatchers.clear()
+	}
+
+	async restartConnectionRPC(serverName: string): Promise<McpServer[]> {
+		this.isConnecting = true
+
+		// Get existing connection and update its status
+		const connection = this.connections.find((conn) => conn.server.name === serverName)
+		const inMemoryConfig = connection?.server.config
+		if (inMemoryConfig) {
+			connection.server.status = "connecting"
+			connection.server.error = ""
+			await setTimeoutPromise(500) // artificial delay to show user that server is restarting
+			try {
+				await this.deleteConnection(serverName)
+				// Try to connect again using existing config
+				await this.connectToServer(serverName, JSON.parse(inMemoryConfig), "rpc")
+			} catch (error) {
+				Logger.error(`Failed to restart connection for ${serverName}:`, error)
+			}
+		}
+
+		this.isConnecting = false
+
+		const config = await this.readAndValidateMcpSettingsFile()
+		if (!config) {
+			throw new Error("Failed to read or validate MCP settings")
+		}
+
+		const serverOrder = Object.keys(config.mcpServers || {})
+		return this.getSortedMcpServers(serverOrder)
+	}
+
+	async restartConnection(serverName: string): Promise<void> {
+		this.isConnecting = true
+
+		// Get existing connection and update its status
+		const connection = this.connections.find((conn) => conn.server.name === serverName)
+		const config = connection?.server.config
+		if (config) {
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: `Restarting ${serverName} MCP server...`,
+			})
+			connection.server.status = "connecting"
+			connection.server.error = ""
+			await this.notifyWebviewOfServerChanges()
+			await setTimeoutPromise(500) // artificial delay to show user that server is restarting
+			try {
+				await this.deleteConnection(serverName)
+				// Try to connect again using existing config
+				await this.connectToServer(serverName, JSON.parse(config), "internal")
+				HostProvider.window.showMessage({
+					type: ShowMessageType.INFORMATION,
+					message: `${serverName} MCP server connected`,
+				})
+			} catch (error) {
+				Logger.error(`Failed to restart connection for ${serverName}:`, error)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: `Failed to connect to ${serverName} MCP server`,
+				})
+			}
+		}
+
+		await this.notifyWebviewOfServerChanges()
+		this.isConnecting = false
+	}
+
+	/**
+	 * Gets sorted MCP servers based on the order defined in settings
+	 * @param serverOrder Array of server names in the order they appear in settings
+	 * @returns Array of McpServer objects sorted according to settings order
+	 */
+	private getSortedMcpServers(serverOrder: string[]): McpServer[] {
+		return [...this.connections]
+			.sort((a, b) => {
+				const indexA = serverOrder.indexOf(a.server.name)
+				const indexB = serverOrder.indexOf(b.server.name)
+				return indexA - indexB
+			})
+			.map((connection) => connection.server)
+	}
+
+	private async notifyWebviewOfServerChanges(): Promise<void> {
+		// servers should always be sorted in the order they are defined in the settings file
+		const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+		const content = await fs.readFile(settingsPath, "utf-8")
+		const config = JSON.parse(content)
+		const serverOrder = Object.keys(config.mcpServers || {})
+
+		// Get sorted servers
+		const sortedServers = this.getSortedMcpServers(serverOrder)
+
+		// Send update using gRPC stream
+		await sendMcpServersUpdate({
+			mcpServers: convertMcpServersToProtoMcpServers(sortedServers),
+		})
+
+		// Check if the tool list actually changed and notify SDK controller if so
+		this.checkToolListChanged()
+	}
+
+	async sendLatestMcpServers() {
+		await this.notifyWebviewOfServerChanges()
+	}
+
+	async reconcileMcpServersFromSettingsRPC(): Promise<McpServer[]> {
+		const settings = await this.readPostWriteMcpSettings()
+		await this.updateServerConnectionsRPC(settings.mcpServers as Record<string, McpServerConfig>)
+		await this.notifyWebviewOfServerChanges()
+
+		const serverOrder = Object.keys(settings.mcpServers || {})
+		return this.getSortedMcpServers(serverOrder)
+	}
+
+	async getLatestMcpServersRPC(): Promise<McpServer[]> {
+		const settings = await this.readAndValidateMcpSettingsFile()
+		if (!settings) {
+			// Return empty array if settings can't be read or validated
+			return []
+		}
+
+		const serverOrder = Object.keys(settings.mcpServers || {})
+		return this.getSortedMcpServers(serverOrder)
+	}
+
+	// Using server
+
+	// Public methods for server management
+
+	public async toggleServerDisabledRPC(serverName: string, disabled: boolean): Promise<McpServer[]> {
+		this.isConnecting = true
+		try {
+			// Hold the cross-process lock across read-modify-write so a concurrent
+			// writer (CLI, OAuth handshake, another window) cannot clobber this
+			// toggle. Connection rebuild stays OUTSIDE the lock: connectToServer can
+			// trigger SDK OAuth writes that take the same (non-reentrant) lock.
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			await updateMcpSettingsFile(settingsPath, (validated) => {
+				const servers = validated.mcpServers as Record<string, any>
+
+				if (!servers[serverName]) {
+					throw new Error(`Server "${serverName}" not found in MCP configuration`)
+				}
+
+				servers[serverName].disabled = disabled
+				validated.mcpServers = servers
+				return validated
+			})
+			const config = await this.readPostWriteMcpSettings()
+
+			// Rebuild the connection so the toggle takes effect. A disabled
+			// server's connection is a stub with no live transport/client, so the
+			// toggle must route through connectToServer(), which opens a real
+			// transport when enabled or creates a disconnected stub when disabled.
+			// deleteConnection preserves OAuth state.
+			const mcpServers = config.mcpServers as Record<string, McpServerConfig>
+			const newConfig = mcpServers[serverName]
+			await this.deleteConnection(serverName)
+			await this.connectToServer(serverName, newConfig, "rpc")
+
+			// Refresh the SDK session's tool list to reflect the server
+			// appearing or disappearing.
+			await this.notifyWebviewOfServerChanges()
+
+			const serverOrder = Object.keys(config.mcpServers || {})
+			return this.getSortedMcpServers(serverOrder)
+		} catch (error) {
+			Logger.error("Failed to update server disabled state:", error)
+			if (error instanceof Error) {
+				Logger.error("Error details:", error.message, error.stack)
+			}
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Failed to update server state: ${error instanceof Error ? error.message : String(error)}`,
+			})
+			throw error
+		} finally {
+			this.isConnecting = false
+		}
+	}
+
+	async readResource(serverName: string, uri: string): Promise<McpResourceResponse> {
+		const connection = this.connections.find((conn) => conn.server.name === serverName)
+		if (!connection) {
+			throw new Error(`No connection found for server: ${serverName}`)
+		}
+		if (connection.server.disabled) {
+			throw new Error(`Server "${serverName}" is disabled`)
+		}
+
+		return await connection.client.request(
+			{
+				method: "resources/read",
+				params: {
+					uri,
+				},
+			},
+			ReadResourceResultSchema,
+		)
+	}
+
+	async getPrompt(
+		serverName: string,
+		promptName: string,
+		promptArguments?: Record<string, string>,
+	): Promise<McpPromptResponse> {
+		const connection = this.connections.find((conn) => conn.server.name === serverName)
+		if (!connection) {
+			throw new Error(`No connection found for server: ${serverName}`)
+		}
+		if (connection.server.disabled) {
+			throw new Error(`Server "${serverName}" is disabled`)
+		}
+		if (!connection.client) {
+			throw new Error(`No client available for server: ${serverName}`)
+		}
+
+		const response = await connection.client.request(
+			{
+				method: "prompts/get",
+				params: {
+					name: promptName,
+					arguments: promptArguments,
+				},
+			},
+			GetPromptResultSchema,
+			{
+				timeout: DEFAULT_REQUEST_TIMEOUT_MS,
+			},
+		)
+
+		return {
+			description: response.description,
+			messages: response.messages.map((msg) => ({
+				role: msg.role,
+				content: msg.content as McpPromptResponse["messages"][0]["content"],
+			})),
+		}
+	}
+
+	async callTool(
+		serverName: string,
+		toolName: string,
+		toolArguments: Record<string, unknown> | undefined,
+		ulid: string,
+	): Promise<McpToolCallResponse> {
+		const connection = this.connections.find((conn) => conn.server.name === serverName)
+		if (!connection) {
+			throw new Error(
+				`No connection found for server: ${serverName}. Please make sure to use MCP servers available under 'Connected MCP Servers'.`,
+			)
+		}
+
+		if (connection.server.disabled) {
+			throw new Error(`Server "${serverName}" is disabled and cannot be used`)
+		}
+
+		let timeout = secondsToMs(DEFAULT_MCP_TIMEOUT_SECONDS) // sdk expects ms
+
+		try {
+			const config = JSON.parse(connection.server.config)
+			const parsedConfig = ServerConfigSchema.parse(config)
+			timeout = secondsToMs(parsedConfig.timeout)
+		} catch (error) {
+			Logger.error(`Failed to parse timeout configuration for server ${serverName}: ${error}`)
+		}
+
+		this.telemetryService.captureMcpToolCall(
+			ulid,
+			serverName,
+			toolName,
+			"started",
+			undefined,
+			toolArguments ? Object.keys(toolArguments) : undefined,
+		)
+
+		try {
+			const result = await connection.client.request(
+				{
+					method: "tools/call",
+					params: {
+						name: toolName,
+						arguments: toolArguments ?? {},
+					},
+				},
+				CallToolResultSchema,
+				{
+					timeout,
+				},
+			)
+
+			this.telemetryService.captureMcpToolCall(
+				ulid,
+				serverName,
+				toolName,
+				"success",
+				undefined,
+				toolArguments ? Object.keys(toolArguments) : undefined,
+			)
+
+			return {
+				...result,
+				content: result.content ?? [],
+			}
+		} catch (error) {
+			this.telemetryService.captureMcpToolCall(
+				ulid,
+				serverName,
+				toolName,
+				"error",
+				error instanceof Error ? error.message : String(error),
+				toolArguments ? Object.keys(toolArguments) : undefined,
+			)
+			throw error
+		}
+	}
+
+	/**
+	 * RPC variant of toggleToolAutoApprove that returns the updated servers instead of notifying the webview
+	 * @param serverName The name of the MCP server
+	 * @param toolNames Array of tool names to toggle auto-approve for
+	 * @param shouldAllow Whether to enable or disable auto-approve
+	 * @returns Array of updated MCP servers
+	 */
+	async toggleToolAutoApproveRPC(serverName: string, toolNames: string[], shouldAllow: boolean): Promise<McpServer[]> {
+		try {
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			const { config, autoApprove } = await updateMcpSettingsFile(settingsPath, (parsed) => {
+				// Initialize autoApprove if it doesn't exist
+				const servers = parsed.mcpServers as Record<string, any>
+				if (!servers[serverName].autoApprove) {
+					servers[serverName].autoApprove = []
+				}
+
+				const approve = servers[serverName].autoApprove
+				for (const toolName of toolNames) {
+					const toolIndex = approve.indexOf(toolName)
+
+					if (shouldAllow && toolIndex === -1) {
+						// Add tool to autoApprove list
+						approve.push(toolName)
+					} else if (!shouldAllow && toolIndex !== -1) {
+						// Remove tool from autoApprove list
+						approve.splice(toolIndex, 1)
+					}
+				}
+				return { config: parsed, autoApprove: approve }
+			})
+			this.recordSettingsFingerprint(config.mcpServers as Record<string, McpServerConfig>)
+
+			// Update the tools list to reflect the change
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+			if (connection && connection.server.tools) {
+				// Update the autoApprove property of each tool in the in-memory server object
+				connection.server.tools = connection.server.tools.map((tool) => ({
+					...tool,
+					autoApprove: autoApprove.includes(tool.name),
+				}))
+			}
+
+			// Return sorted servers without notifying webview
+			const serverOrder = Object.keys(config.mcpServers || {})
+			return this.getSortedMcpServers(serverOrder)
+		} catch (error) {
+			Logger.error("Failed to update autoApprove settings:", error)
+			throw error // Re-throw to ensure the error is properly handled
+		}
+	}
+
+	async toggleToolAutoApprove(serverName: string, toolNames: string[], shouldAllow: boolean): Promise<void> {
+		try {
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			const { autoApprove, mcpServers } = await updateMcpSettingsFile(settingsPath, (config) => {
+				// Initialize autoApprove if it doesn't exist
+				const servers = config.mcpServers as Record<string, any>
+				if (!servers[serverName].autoApprove) {
+					servers[serverName].autoApprove = []
+				}
+
+				const approve = servers[serverName].autoApprove
+				for (const toolName of toolNames) {
+					const toolIndex = approve.indexOf(toolName)
+
+					if (shouldAllow && toolIndex === -1) {
+						// Add tool to autoApprove list
+						approve.push(toolName)
+					} else if (!shouldAllow && toolIndex !== -1) {
+						// Remove tool from autoApprove list
+						approve.splice(toolIndex, 1)
+					}
+				}
+				return { autoApprove: approve as string[], mcpServers: servers as Record<string, McpServerConfig> }
+			})
+			this.recordSettingsFingerprint(mcpServers)
+
+			// Update the tools list to reflect the change
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+			if (connection && connection.server.tools) {
+				// Update the autoApprove property of each tool in the in-memory server object
+				connection.server.tools = connection.server.tools.map((tool) => ({
+					...tool,
+					autoApprove: autoApprove.includes(tool.name),
+				}))
+				await this.notifyWebviewOfServerChanges()
+			}
+		} catch (error) {
+			Logger.error("Failed to update autoApprove settings:", error)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: "Failed to update autoApprove settings",
+			})
+			throw error // Re-throw to ensure the error is properly handled
+		}
+	}
+
+	public async addRemoteServer(serverName: string, serverUrl: string, transportType = "streamableHttp"): Promise<McpServer[]> {
+		try {
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			await updateMcpSettingsFile(settingsPath, (current) => {
+				const servers = current.mcpServers as Record<string, any>
+				if (servers[serverName]) {
+					throw new Error(`An MCP server with the name "${serverName}" already exists`)
+				}
+
+				const serverConfig = {
+					url: serverUrl,
+					type: transportType,
+					disabled: false,
+					autoApprove: [],
+				}
+
+				// Expand environment variables for validation
+				const expandedConfig = expandEnvironmentVariables(serverConfig)
+
+				const urlValidation = z.string().url().safeParse(expandedConfig.url)
+				if (!urlValidation.success) {
+					throw new Error(`Invalid server URL: ${expandedConfig.url}. Please provide a valid URL.`)
+				}
+
+				const parsedConfig = ServerConfigSchema.parse(expandedConfig)
+
+				servers[serverName] = parsedConfig
+
+				// We don't write the zod-transformed version to the file.
+				// The above parse() call adds the transportType field to the server config
+				// It would be fine if this was written, but we don't want to clutter up the file with internal details
+
+				// ToDo: We could benefit from input / output types reflecting the non-transformed / transformed versions
+				const serversToWrite = { ...servers, [serverName]: serverConfig }
+				current.mcpServers = serversToWrite
+				return current
+			})
+			const settings = await this.readPostWriteMcpSettings()
+
+			await this.updateServerConnectionsRPC(settings.mcpServers as Record<string, McpServerConfig>)
+
+			const serverOrder = Object.keys(settings.mcpServers || {})
+			return this.getSortedMcpServers(serverOrder)
+		} catch (error) {
+			Logger.error("Failed to add remote MCP server:", error)
+			throw error
+		}
+	}
+
+	/**
+	 * RPC variant of deleteServer that returns the updated server list directly
+	 * @param serverName The name of the server to delete
+	 * @returns Array of remaining MCP servers
+	 */
+	public async deleteServerRPC(serverName: string): Promise<McpServer[]> {
+		try {
+			// Clear OAuth data BEFORE removing from config (while we still have the connection/URL)
+			await this.clearOAuthForConnection(serverName)
+
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			await updateMcpSettingsFile(settingsPath, (parsed) => {
+				const servers = parsed.mcpServers as Record<string, any>
+
+				if (!servers[serverName]) {
+					throw new Error(`${serverName} not found in MCP configuration`)
+				}
+
+				delete servers[serverName]
+				parsed.mcpServers = servers
+				return parsed
+			})
+			const config = await this.readPostWriteMcpSettings()
+			const mcpServers = config.mcpServers as Record<string, McpServerConfig>
+
+			await this.updateServerConnectionsRPC(mcpServers)
+
+			// Get the servers in their correct order from settings
+			const serverOrder = Object.keys(mcpServers || {})
+			return this.getSortedMcpServers(serverOrder)
+		} catch (error) {
+			Logger.error(`Failed to delete MCP server: ${error instanceof Error ? error.message : String(error)}`)
+			throw error
+		}
+	}
+
+	public async updateServerTimeoutRPC(serverName: string, timeout: number): Promise<McpServer[]> {
+		try {
+			// Validate timeout against schema
+			const setConfigResult = BaseConfigSchema.shape.timeout.safeParse(timeout)
+			if (!setConfigResult.success) {
+				throw new Error(`Invalid timeout value: ${timeout}. Must be at minimum ${MIN_MCP_TIMEOUT_SECONDS} seconds.`)
+			}
+
+			const settingsPath = await getMcpSettingsFilePathHelper(await this.getSettingsDirectoryPath())
+			await updateMcpSettingsFile(settingsPath, (parsed) => {
+				const servers = parsed.mcpServers as Record<string, any>
+
+				if (!servers[serverName]) {
+					throw new Error(`Server "${serverName}" not found in settings`)
+				}
+
+				servers[serverName] = {
+					...servers[serverName],
+					timeout,
+				}
+
+				parsed.mcpServers = servers
+				return parsed
+			})
+			const config = await this.readPostWriteMcpSettings()
+
+			// Update in-memory config to reflect the new timeout
+			const connection = this.connections.find((conn) => conn.server.name === serverName)
+			if (connection) {
+				const currentConfig = JSON.parse(connection.server.config)
+				currentConfig.timeout = timeout
+				connection.server.config = JSON.stringify(currentConfig)
+			}
+
+			const serverOrder = Object.keys(config.mcpServers || {})
+			return this.getSortedMcpServers(serverOrder)
+		} catch (error) {
+			Logger.error("Failed to update server timeout:", error)
+			if (error instanceof Error) {
+				Logger.error("Error details:", error.message, error.stack)
+			}
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Failed to update server timeout: ${error instanceof Error ? error.message : String(error)}`,
+			})
+			throw error
+		}
+	}
+
+	/**
+	 * Get and clear pending notifications
+	 * @returns Array of pending notifications
+	 */
+	getPendingNotifications(): Array<{
+		serverName: string
+		level: string
+		message: string
+		timestamp: number
+	}> {
+		const notifications = [...this.pendingNotifications]
+		this.pendingNotifications = []
+		return notifications
+	}
+
+	/**
+	 * Set the notification callback for real-time notifications
+	 * @param callback Function to call when notifications arrive
+	 */
+	setNotificationCallback(callback: (serverName: string, level: string, message: string) => void): void {
+		this.notificationCallback = callback
+		//Logger.log("[MCP Debug] Notification callback set")
+	}
+
+	/**
+	 * Clear the notification callback
+	 */
+	clearNotificationCallback(): void {
+		this.notificationCallback = undefined
+		//Logger.log("[MCP Debug] Notification callback cleared")
+	}
+
+	/**
+	 * Set a callback that fires when the MCP tool list changes.
+	 *
+	 * The callback is invoked only when the set of available tools actually
+	 * changes (servers added/removed, tools discovered/lost), NOT on mere
+	 * status updates (error messages, reconnect attempts).
+	 *
+	 * Used by SdkController to restart the SDK session with updated tools
+	 * when MCP servers change mid-session.
+	 */
+	setToolListChangeCallback(callback: () => void): void {
+		this.toolListChangeCallback = callback
+		// Initialize the fingerprint so the first real change is detected
+		this.lastToolFingerprint = this.computeToolFingerprint()
+	}
+
+	/**
+	 * Clear the tool list change callback.
+	 */
+	clearToolListChangeCallback(): void {
+		this.toolListChangeCallback = undefined
+	}
+
+	/**
+	 * Compute a fingerprint of the current tool list.
+	 *
+	 * The fingerprint is a sorted, deterministic string of
+	 * "serverName:toolName" pairs for all connected, non-disabled servers.
+	 * Changes to this fingerprint indicate that the agent's available
+	 * tool set has changed and a session restart may be needed.
+	 */
+	computeToolFingerprint(): string {
+		const entries: string[] = []
+		for (const conn of this.connections) {
+			if (conn.server.disabled || conn.server.status !== "connected") {
+				continue
+			}
+			for (const tool of conn.server.tools ?? []) {
+				entries.push(`${conn.server.name}:${tool.name}`)
+			}
+		}
+		entries.sort()
+		return entries.join("|")
+	}
+
+	/**
+	 * Check if the tool list has changed and fire the callback if so.
+	 * Called internally after server connection changes settle.
+	 *
+	 * Debounced: when a server connects, notifyWebviewOfServerChanges()
+	 * fires multiple times in quick succession (status change → tools
+	 * discovered → etc.). Without debouncing, the callback fires for
+	 * each intermediate state, causing duplicate messages (S6-28).
+	 * The 300ms debounce coalesces these into a single callback.
+	 */
+	private checkToolListChanged(): void {
+		if (!this.toolListChangeCallback) {
+			return
+		}
+
+		// Quick-check: if the fingerprint hasn't changed, skip the debounce entirely.
+		// This avoids scheduling timers for the many notifyWebviewOfServerChanges()
+		// calls that don't actually change the tool list (e.g., error messages).
+		const currentFingerprint = this.computeToolFingerprint()
+		if (currentFingerprint === this.lastToolFingerprint) {
+			return
+		}
+
+		// Fingerprint changed — debounce to coalesce rapid-fire changes
+		if (this.toolListChangeDebounceTimer) {
+			clearTimeout(this.toolListChangeDebounceTimer)
+		}
+		this.toolListChangeDebounceTimer = setTimeout(() => {
+			this.toolListChangeDebounceTimer = undefined
+			this.fireToolListChangeIfNeeded()
+		}, 300)
+	}
+
+	/**
+	 * Fire the tool list change callback if the fingerprint has changed.
+	 * Called after the debounce timer expires.
+	 */
+	private fireToolListChangeIfNeeded(): void {
+		if (!this.toolListChangeCallback) {
+			return
+		}
+		const newFingerprint = this.computeToolFingerprint()
+		if (newFingerprint !== this.lastToolFingerprint) {
+			Logger.log(
+				`[McpHub] Tool list changed: "${this.lastToolFingerprint.substring(0, 80)}" → "${newFingerprint.substring(0, 80)}"`,
+			)
+			this.lastToolFingerprint = newFingerprint
+			try {
+				this.toolListChangeCallback()
+			} catch (error) {
+				Logger.error("[McpHub] Error in toolListChangeCallback:", error)
+			}
+		}
+	}
+
+	/**
+	 * Runs the complete OAuth flow for a server when the user clicks
+	 * "Authenticate".
+	 *
+	 * The interactive flow is HTTP-based token collection (the same flow the CLI
+	 * uses): a local loopback callback server is bound, the browser is opened to
+	 * the authorization URL, and the code is exchanged in-process with the OAuth
+	 * state validated against the value generated for this flow. Tokens are
+	 * written to the shared MCP settings file, so the CLI and other windows see
+	 * them immediately. On success the connection is restarted so the transport
+	 * picks up the fresh tokens.
+	 */
+	async initiateOAuth(serverName: string): Promise<void> {
+		const connection = this.connections.find((conn) => conn.server.name === serverName)
+		if (!connection) {
+			throw new Error(`No connection found for server: ${serverName}`)
+		}
+
+		// Show "pending" in the UI while the user is off in the browser
+		connection.server.oauthAuthStatus = "pending"
+		connection.server.error = ""
+		await this.notifyWebviewOfServerChanges()
+
+		try {
+			// Blocks until tokens are exchanged and written to the settings file
+			await this.mcpOAuthManager.startOAuthFlow(serverName)
+		} catch (error) {
+			const current = this.connections.find((conn) => conn.server.name === serverName)
+			if (current) {
+				current.server.oauthAuthStatus = "unauthenticated"
+				this.appendErrorMessage(current, error instanceof Error ? error.message : String(error))
+			}
+			await this.notifyWebviewOfServerChanges()
+			throw error
+		}
+
+		Logger.log(`[McpOAuth] Authentication completed for ${serverName}`)
+
+		const authedConnection = this.connections.find((conn) => conn.server.name === serverName)
+		if (authedConnection) {
+			authedConnection.server.oauthAuthStatus = "authenticated"
+			authedConnection.server.oauthRequired = true
+			authedConnection.server.error = ""
+		}
+
+		// Restart connection so the transport authenticates with the new tokens
+		await this.restartConnection(serverName)
+	}
+
+	async dispose(): Promise<void> {
+		this.removeAllFileWatchers()
+		for (const connection of this.connections) {
+			try {
+				await this.deleteConnection(connection.server.name)
+			} catch (error) {
+				Logger.error(`Failed to close connection for ${connection.server.name}:`, error)
+			}
+		}
+		this.connections = []
+		if (this.settingsWatcher) {
+			await this.settingsWatcher.close()
+		}
+	}
+}
diff --git a/apps/vscode/src/services/mcp/McpOAuthManager.ts b/apps/vscode/src/services/mcp/McpOAuthManager.ts
new file mode 100644
index 0000000..91eca35
--- /dev/null
+++ b/apps/vscode/src/services/mcp/McpOAuthManager.ts
@@ -0,0 +1,322 @@
+// MCP OAuth state is stored in the shared MCP settings file
+// (~/.cline/data/settings/cline_mcp_settings.json) under each server's `oauth`
+// key, in the format @cline/core (CLI, JetBrains) reads and writes:
+//
+//   { "mcpServers": { "linear": { "transport": {...}, "oauth": { "tokens": {...}, ... } } } }
+//
+// This shared file is the single source of truth, which keeps the extension,
+// the CLI, and multiple extension windows interoperable:
+//  - Writes scope to ONE server's `oauth` key via @cline/core's
+//    updateMcpServerOAuthStateAsync, which re-reads the file under a
+//    cross-process lock and replaces it atomically (temp + rename), so
+//    concurrent writers never clobber other servers or the whole file. Lock
+//    acquisition yields the extension host event loop rather than blocking it.
+//  - Reads come fresh from disk, so a token authorized by the CLI or another
+//    window is picked up without restarting.
+//  - The interactive authorization flow is HTTP-based token collection via
+//    @cline/core's authorizeMcpServerOAuth, which binds a local loopback
+//    callback server — the same flow the CLI uses.
+
+import {
+	authorizeMcpServerOAuth,
+	getMcpServerOAuthState,
+	type McpServerOAuthState,
+	updateMcpServerOAuthStateAsync,
+} from "@cline/core"
+import { StateManager } from "@core/storage/StateManager"
+import { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js"
+import crypto from "crypto"
+import { fetch } from "@/shared/net"
+import { Logger } from "@/shared/services/Logger"
+import { openExternal } from "@/utils/env"
+import { getServerAuthHash } from "@/utils/mcpAuth"
+
+/**
+ * Fallback redirect URL advertised in client metadata for connection-time
+ * providers. Matches @cline/core's DEFAULT_HTTP_MCP_REDIRECT_URL — the actual
+ * redirect URL used during an interactive flow is chosen by
+ * authorizeMcpServerOAuth when it binds its local callback server.
+ */
+const DEFAULT_HTTP_MCP_REDIRECT_URL = "http://127.0.0.1:1456/mcp/oauth/callback"
+
+/**
+ * Ports the local OAuth callback server may bind. The first three match the
+ * @cline/core defaults; extras tolerate concurrent flows from other Cline
+ * processes (CLI, another extension window) holding a port.
+ */
+const MCP_OAUTH_CALLBACK_PORTS = [1456, 1457, 1458, 1459, 1460, 1461]
+
+/** How long the interactive flow waits for the browser callback. */
+const MCP_OAUTH_FLOW_TIMEOUT_MS = 10 * 60 * 1000 // 10 minutes
+
+/**
+ * Read a server's OAuth state fresh from the shared settings file.
+ * Never throws — a missing/unreadable file simply means "no state".
+ */
+function readOAuthState(serverName: string, settingsPath: string): McpServerOAuthState {
+	try {
+		return getMcpServerOAuthState(serverName, { filePath: settingsPath }) ?? {}
+	} catch {
+		return {}
+	}
+}
+
+/**
+ * Scoped write of one server's OAuth state. The updater runs against the
+ * server's current state under a cross-process lock and returns the next state;
+ * concurrent writers are never clobbered wholesale. Lock acquisition yields the
+ * event loop. Failures are logged but non-fatal, so a missing server entry
+ * (e.g. deleted in another window) does not crash the MCP SDK provider callbacks
+ * that invoke this mid-connection.
+ */
+async function patchOAuthState(
+	serverName: string,
+	settingsPath: string,
+	updater: (current: McpServerOAuthState) => McpServerOAuthState,
+): Promise<void> {
+	try {
+		await updateMcpServerOAuthStateAsync(serverName, updater, { filePath: settingsPath })
+	} catch (error) {
+		Logger.warn(`[McpOAuth] Failed to persist OAuth state for ${serverName}: ${error}`)
+	}
+}
+
+/**
+ * Implementation of OAuthClientProvider for connection-time auth.
+ *
+ * This provider is attached to SSE/StreamableHTTP transports so the MCP SDK
+ * can read tokens (and auto-refresh them with the stored refresh_token). It
+ * reads/writes the shared settings file in @cline/core's format.
+ *
+ * Note: `redirectToAuthorization` here is a no-op signal — connection attempts
+ * never open a browser. The interactive flow (Authenticate button) goes
+ * through McpOAuthManager.startOAuthFlow → authorizeMcpServerOAuth, which
+ * runs its own provider with a live local callback server.
+ */
+class ClineOAuthClientProvider implements OAuthClientProvider {
+	constructor(
+		private readonly serverName: string,
+		private readonly settingsPath: string,
+	) {}
+
+	get redirectUrl(): string {
+		const state = readOAuthState(this.serverName, this.settingsPath)
+		return state.redirectUrl ?? DEFAULT_HTTP_MCP_REDIRECT_URL
+	}
+
+	get clientMetadata(): OAuthClientMetadata {
+		return {
+			redirect_uris: [this.redirectUrl],
+			token_endpoint_auth_method: "none",
+			grant_types: ["authorization_code", "refresh_token"],
+			response_types: ["code"],
+			client_name: "Cline",
+		}
+	}
+
+	state(): string {
+		return crypto.randomUUID()
+	}
+
+	async clientInformation(): Promise<OAuthClientInformationMixed | undefined> {
+		const state = readOAuthState(this.serverName, this.settingsPath)
+		return state.clientInformation as OAuthClientInformationMixed | undefined
+	}
+
+	async saveClientInformation(clientInformation: OAuthClientInformationMixed): Promise<void> {
+		await patchOAuthState(this.serverName, this.settingsPath, (current) => ({
+			...current,
+			clientInformation: clientInformation as Record<string, unknown>,
+		}))
+	}
+
+	async tokens(): Promise<OAuthTokens | undefined> {
+		// Always read fresh from disk: tokens may have just been written by the
+		// CLI, another extension window, or the interactive authorize flow.
+		// Expired access tokens are still returned when a refresh_token exists —
+		// the MCP SDK refreshes them automatically and calls saveTokens().
+		const state = readOAuthState(this.serverName, this.settingsPath)
+		return state.tokens as OAuthTokens | undefined
+	}
+
+	async saveTokens(tokens: OAuthTokens): Promise<void> {
+		// Called by the SDK after a successful token exchange or refresh.
+		Logger.log(`[McpOAuth] Tokens saved for ${this.serverName}`)
+		const lastAuthenticatedAt = Date.now()
+		await patchOAuthState(this.serverName, this.settingsPath, (current) => ({
+			...current,
+			tokens: tokens as Record<string, unknown>,
+			lastError: undefined,
+			lastAuthenticatedAt,
+		}))
+	}
+
+	async redirectToAuthorization(_authorizationUrl: URL): Promise<void> {
+		// Intentionally do nothing. The SDK calls this during a connection
+		// attempt when the server requires auth; it then throws
+		// UnauthorizedError, which McpHub catches to show the "Authenticate"
+		// button. The actual browser flow runs in startOAuthFlow(), with a
+		// dedicated provider whose local callback server is actually listening.
+		Logger.log(`[McpOAuth] OAuth required for ${this.serverName} - user must click Authenticate`)
+	}
+
+	async saveCodeVerifier(codeVerifier: string): Promise<void> {
+		await patchOAuthState(this.serverName, this.settingsPath, (current) => ({
+			...current,
+			codeVerifier,
+		}))
+	}
+
+	async codeVerifier(): Promise<string> {
+		const state = readOAuthState(this.serverName, this.settingsPath)
+		if (!state.codeVerifier) {
+			throw new Error(`No code verifier found for ${this.serverName}`)
+		}
+		return state.codeVerifier
+	}
+
+	async invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier"): Promise<void> {
+		await patchOAuthState(this.serverName, this.settingsPath, (current) => {
+			if (scope === "all") {
+				return { lastError: current.lastError, redirectUrl: current.redirectUrl }
+			}
+			return {
+				...current,
+				...(scope === "client" ? { clientInformation: undefined } : {}),
+				...(scope === "tokens" ? { tokens: undefined, lastAuthenticatedAt: undefined } : {}),
+				...(scope === "verifier" ? { codeVerifier: undefined } : {}),
+			}
+		})
+	}
+
+	/**
+	 * Check if provider has valid authentication
+	 */
+	async isAuthenticated(): Promise<boolean> {
+		const tokens = await this.tokens()
+		return Boolean(tokens && tokens.access_token)
+	}
+}
+
+/**
+ * Manages OAuth authentication for MCP servers.
+ *
+ * Creates connection-time OAuthClientProvider instances (token reads/refresh
+ * writes against the shared settings file) and runs the interactive
+ * HTTP-callback authorization flow via @cline/core.
+ */
+export class McpOAuthManager {
+	private providers: Map<string, OAuthClientProvider> = new Map()
+	/** Serializes interactive flows per server so double-clicks don't race. */
+	private activeFlows: Map<string, Promise<void>> = new Map()
+
+	constructor(private readonly getSettingsPath: () => Promise<string>) {}
+
+	/**
+	 * Gets or creates an OAuthClientProvider for a server.
+	 */
+	async getOrCreateProvider(serverName: string, serverUrl: string): Promise<OAuthClientProvider> {
+		const key = `${serverName}:${serverUrl}`
+		const existing = this.providers.get(key)
+		if (existing) {
+			return existing
+		}
+		// Import tokens from the legacy `mcpOAuthSecrets` store into the shared
+		// settings file before the first read, if any are present.
+		await this.migrateLegacySecrets(serverName, serverUrl)
+		const provider = new ClineOAuthClientProvider(serverName, await this.getSettingsPath())
+		this.providers.set(key, provider)
+		return provider
+	}
+
+	/**
+	 * Runs the interactive OAuth flow when the user clicks "Authenticate".
+	 *
+	 * Delegates to @cline/core's authorizeMcpServerOAuth (the exact flow the
+	 * CLI uses): binds a local loopback callback server, performs discovery and
+	 * client registration, opens the browser, validates the returned state
+	 * in-process, exchanges the code, and writes tokens to the shared settings
+	 * file. Resolves when tokens are saved (or rejects on timeout/denial).
+	 */
+	async startOAuthFlow(serverName: string): Promise<void> {
+		const inFlight = this.activeFlows.get(serverName)
+		if (inFlight) {
+			Logger.log(`[McpOAuth] OAuth flow already in progress for ${serverName}`)
+			return inFlight
+		}
+
+		const flow = (async () => {
+			const settingsPath = await this.getSettingsPath()
+			const result = await authorizeMcpServerOAuth({
+				serverName,
+				filePath: settingsPath,
+				clientName: "Cline",
+				fetch,
+				openUrl: (url) => openExternal(url),
+				callbackPorts: MCP_OAUTH_CALLBACK_PORTS,
+				timeoutMs: MCP_OAUTH_FLOW_TIMEOUT_MS,
+			})
+			Logger.log(`[McpOAuth] ${result.message}`)
+		})()
+
+		this.activeFlows.set(serverName, flow)
+		try {
+			await flow
+		} finally {
+			this.activeFlows.delete(serverName)
+		}
+	}
+
+	/**
+	 * Clears all OAuth data for a server (used when server is deleted).
+	 * Tokens live in the server's own settings entry, so deleting the entry
+	 * removes them; this also drops the cached provider and proactively
+	 * clears the oauth block in case the entry itself is kept.
+	 */
+	async clearServerAuth(serverName: string, serverUrl: string): Promise<void> {
+		this.providers.delete(`${serverName}:${serverUrl}`)
+		await patchOAuthState(serverName, await this.getSettingsPath(), () => ({}))
+	}
+
+	/**
+	 * One-time migration of tokens from the legacy `mcpOAuthSecrets` secrets
+	 * blob into the shared settings file. Runs per server at connection time;
+	 * file-based state always wins (never overwrite newer shared state).
+	 */
+	private async migrateLegacySecrets(serverName: string, serverUrl: string): Promise<void> {
+		try {
+			const secretsJson = StateManager.get().getSecretKey("mcpOAuthSecrets")
+			if (!secretsJson) {
+				return
+			}
+			const secrets = JSON.parse(secretsJson) as Record<
+				string,
+				{ tokens?: OAuthTokens; tokens_saved_at?: number; client_info?: Record<string, unknown> }
+			>
+			const serverHash = getServerAuthHash(serverName, serverUrl)
+			const legacy = secrets[serverHash]
+			if (!legacy?.tokens?.access_token) {
+				return
+			}
+
+			const settingsPath = await this.getSettingsPath()
+			const current = readOAuthState(serverName, settingsPath)
+			if (!current.tokens) {
+				Logger.log(`[McpOAuth] Migrating legacy OAuth tokens for ${serverName} to shared settings file`)
+				await patchOAuthState(serverName, settingsPath, (state) => ({
+					...state,
+					tokens: legacy.tokens as unknown as Record<string, unknown>,
+					clientInformation: state.clientInformation ?? legacy.client_info,
+					lastAuthenticatedAt: legacy.tokens_saved_at ?? Date.now(),
+				}))
+			}
+
+			// Drop the migrated entry so this only happens once per server.
+			delete secrets[serverHash]
+			StateManager.get().setSecret("mcpOAuthSecrets", Object.keys(secrets).length ? JSON.stringify(secrets) : undefined)
+		} catch (error) {
+			Logger.warn(`[McpOAuth] Legacy OAuth migration failed for ${serverName}: ${error}`)
+		}
+	}
+}
diff --git a/apps/vscode/src/services/mcp/StreamableHttpReconnectHandler.ts b/apps/vscode/src/services/mcp/StreamableHttpReconnectHandler.ts
new file mode 100644
index 0000000..f8a5d3f
--- /dev/null
+++ b/apps/vscode/src/services/mcp/StreamableHttpReconnectHandler.ts
@@ -0,0 +1,165 @@
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Callbacks that the reconnect handler uses to interact with McpHub.
+ * Injecting these allow the handler to be tested in isolation.
+ */
+export interface ReconnectCallbacks {
+	/** Returns the current connection object, or undefined if it no longer exists */
+	findConnection: () => { server: { status: string; disabled?: boolean; uid?: string } } | undefined
+	/** Tears down the existing connection */
+	deleteConnection: () => Promise<void>
+	/** Establishes a new connection */
+	connectToServer: () => Promise<void>
+	/** Pushes updated server state to the webview */
+	notifyWebviewOfServerChanges: () => Promise<void>
+	/** Appends an error message to the connection's server object */
+	appendErrorMessage: (connection: { server: { status: string } }, message: string) => void
+	/** Removes the server key from the global registry */
+	deleteServerKey: (uid: string) => void
+	/** Awaitable delay — injected so tests can substitute a zero-delay or fake timer */
+	delay: (ms: number) => Promise<void>
+}
+
+/**
+ * Configuration for the reconnection strategy.
+ */
+export interface ReconnectConfig {
+	/** Maximum number of consecutive reconnect attempts before giving up */
+	maxAttempts: number
+	/** Returns the delay in milliseconds for a given attempt (0-based). */
+	getDelayMs: (attempt: number) => number
+}
+
+/** Default configuration: up to 6 attempts with exponential backoff starting at 2 s. */
+export const DEFAULT_RECONNECT_CONFIG: ReconnectConfig = {
+	maxAttempts: 6,
+	getDelayMs: (attempt: number) => 2000 * 2 ** attempt,
+}
+
+/**
+ * Manages reconnection logic for a single StreamableHTTP MCP transport.
+ *
+ * Each instance tracks its own attempt counter. When the transport's `onerror`
+ * fires, call {@link handleError}. The handler will:
+ *
+ * 1. Skip if the connection is disabled or already reconnecting.
+ * 2. Wait with exponential backoff.
+ * 3. Tear down and re-establish the connection.
+ * 4. Reset the counter on success.
+ * 5. After exhausting retries, mark the server as disconnected.
+ */
+export class StreamableHttpReconnectHandler {
+	private attempts = 0
+	private readonly serverName: string
+	private readonly config: ReconnectConfig
+	private readonly callbacks: ReconnectCallbacks
+
+	constructor(serverName: string, callbacks: ReconnectCallbacks, config: ReconnectConfig = DEFAULT_RECONNECT_CONFIG) {
+		this.serverName = serverName
+		this.callbacks = callbacks
+		this.config = config
+	}
+
+	/** Number of consecutive reconnect attempts so far */
+	get attemptCount(): number {
+		return this.attempts
+	}
+
+	/** Reset the attempt counter (e.g. after a successful long-lived connection) */
+	resetAttempts(): void {
+		this.attempts = 0
+	}
+
+	/**
+	 * Handle a transport error. Call this from `transport.onerror`.
+	 */
+	async handleError(error: unknown): Promise<void> {
+		Logger.error(`Transport error for "${this.serverName}":`, error)
+
+		const connection = this.callbacks.findConnection()
+		if (!connection) {
+			return
+		}
+
+		// Don't retry if intentionally disabled or already mid-reconnect
+		if (connection.server.disabled || connection.server.status === "connecting") {
+			return
+		}
+
+		if (this.attempts >= this.config.maxAttempts) {
+			// Max retries exhausted
+			Logger.error(
+				`StreamableHTTP max reconnect attempts (${this.config.maxAttempts}) ` +
+					`exhausted for "${this.serverName}". Server marked as disconnected.`,
+			)
+			connection.server.status = "disconnected"
+			this.callbacks.deleteServerKey(connection.server.uid || this.serverName)
+			this.callbacks.appendErrorMessage(connection, error instanceof Error ? error.message : `${error}`)
+			await this.callbacks.notifyWebviewOfServerChanges()
+			return
+		}
+
+		// First attempt: backoff, verify staleness, then delete + connect.
+		// Subsequent attempts (on connectToServer failure) just backoff + connect.
+		const initialDelay = this.config.getDelayMs(this.attempts)
+		this.attempts++
+		Logger.log(
+			`StreamableHTTP transport error for "${this.serverName}", attempting reconnect ` +
+				`${this.attempts}/${this.config.maxAttempts} in ${initialDelay / 1000}s...`,
+		)
+
+		connection.server.status = "connecting"
+		await this.callbacks.notifyWebviewOfServerChanges()
+
+		await this.callbacks.delay(initialDelay)
+
+		// Verify connection still exists and hasn't been replaced during the delay
+		const currentConnection = this.callbacks.findConnection()
+		if (!currentConnection || currentConnection !== connection) {
+			return
+		}
+
+		// Tear down the old connection, then retry connectToServer in a loop.
+		// We loop here instead of relying on the new transport's onerror because
+		// connectToServer() may throw before a new transport/error-handler is
+		// established, which would silently break the retry chain.
+		await this.callbacks.deleteConnection()
+
+		while (this.attempts <= this.config.maxAttempts) {
+			try {
+				await this.callbacks.connectToServer()
+				Logger.log(`StreamableHTTP reconnect succeeded for "${this.serverName}"`)
+				this.attempts = 0
+				return
+			} catch (reconnectError) {
+				Logger.error(`StreamableHTTP reconnect failed for "${this.serverName}":`, reconnectError)
+				if (this.attempts < this.config.maxAttempts) {
+					const retryDelay = this.config.getDelayMs(this.attempts)
+					this.attempts++
+					Logger.log(
+						`StreamableHTTP retrying reconnect ${this.attempts}/${this.config.maxAttempts} ` +
+							`for "${this.serverName}" in ${retryDelay / 1000}s...`,
+					)
+					await this.callbacks.delay(retryDelay)
+				} else {
+					break
+				}
+			}
+		}
+
+		// All retry attempts exhausted during the connect loop.
+		Logger.error(
+			`StreamableHTTP max reconnect attempts (${this.config.maxAttempts}) ` +
+				`exhausted for "${this.serverName}". Server marked as disconnected.`,
+		)
+		// The old connection was deleted; check if connectToServer left a partial one.
+		const exhaustedConnection = this.callbacks.findConnection()
+		if (exhaustedConnection) {
+			exhaustedConnection.server.status = "disconnected"
+			this.callbacks.deleteServerKey(exhaustedConnection.server.uid || this.serverName)
+			this.callbacks.appendErrorMessage(exhaustedConnection, error instanceof Error ? error.message : `${error}`)
+		}
+		await this.callbacks.notifyWebviewOfServerChanges()
+	}
+}
diff --git a/apps/vscode/src/services/mcp/__tests__/McpHub.callTool.test.ts b/apps/vscode/src/services/mcp/__tests__/McpHub.callTool.test.ts
new file mode 100644
index 0000000..a1f86af
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/McpHub.callTool.test.ts
@@ -0,0 +1,288 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import sinon from "sinon"
+import { McpHub } from "../McpHub"
+
+/**
+ * Unit tests for McpHub.callTool() method.
+ *
+ * Focuses on the fix: `arguments: toolArguments ?? {}` ensuring that
+ * undefined toolArguments are sent as an empty object `{}` to comply
+ * with MCP SDK's Zod validation (ZodRecord<ZodString, ZodUnknown>).
+ *
+ * These tests exercise the real `McpHub.callTool` method by building a
+ * partially-initialized `McpHub` instance (bypassing the constructor's
+ * filesystem side-effects) and injecting only the state `callTool`
+ * actually touches: `connections` and `telemetryService`.
+ */
+
+/** Minimal mock for MCP Client.request() */
+function createMockClient(responseOverride?: any) {
+	return {
+		request: sinon.stub().resolves(
+			responseOverride ?? {
+				content: [{ type: "text", text: "success" }],
+			},
+		),
+	}
+}
+
+/** Minimal mock for TelemetryService */
+function createMockTelemetryService() {
+	return {
+		captureMcpToolCall: sinon.stub(),
+	}
+}
+
+/**
+ * Build a real `McpHub` instance without triggering the constructor's
+ * filesystem watchers / server-initialization side effects, then inject
+ * the minimum state required by `callTool`.
+ *
+ * We use `Object.create(McpHub.prototype)` so that invoking `hub.callTool`
+ * dispatches to the actual production implementation rather than a
+ * re-implementation.
+ */
+function createMcpHub(
+	options: { client?: ReturnType<typeof createMockClient>; serverName?: string; disabled?: boolean; config?: string } = {},
+) {
+	const client = options.client ?? createMockClient()
+	const serverName = options.serverName ?? "test-server"
+	const telemetryService = createMockTelemetryService()
+
+	const connection = {
+		server: {
+			name: serverName,
+			config: options.config ?? JSON.stringify({ type: "stdio", command: "test", timeout: 60 }),
+			status: "connected",
+			disabled: options.disabled ?? false,
+		},
+		client,
+		transport: {},
+	}
+
+	const hub = Object.create(McpHub.prototype) as McpHub
+	;(hub as any).telemetryService = telemetryService
+	;(hub as any).connections = [connection]
+
+	return { hub, client, telemetryService, connection }
+}
+
+describe("McpHub.callTool", () => {
+	let sandbox: sinon.SinonSandbox
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	// ── Core fix: undefined arguments → empty object ────────────────────
+
+	describe("arguments fallback to empty object", () => {
+		it("should pass empty object {} when toolArguments is undefined", async () => {
+			const { hub, client } = createMcpHub()
+
+			await hub.callTool("test-server", "list_pages", undefined, "ulid-001")
+
+			client.request.calledOnce.should.be.true()
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.params.arguments.should.deepEqual({})
+		})
+
+		it("should pass the provided arguments object when toolArguments is defined", async () => {
+			const { hub, client } = createMcpHub()
+			const args = { url: "https://example.com", verbose: true }
+
+			await hub.callTool("test-server", "navigate_page", args, "ulid-002")
+
+			client.request.calledOnce.should.be.true()
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.params.arguments.should.deepEqual({ url: "https://example.com", verbose: true })
+		})
+
+		it("should pass empty object {} when toolArguments is explicitly passed as undefined", async () => {
+			const { hub, client } = createMcpHub()
+
+			await hub.callTool("test-server", "take_screenshot", undefined, "ulid-003")
+
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.params.arguments.should.deepEqual({})
+			// Ensure it's an object, not null or undefined
+			;(typeof requestArgs.params.arguments).should.equal("object")
+			;(requestArgs.params.arguments === null).should.be.false()
+		})
+
+		it("should preserve arguments with falsy values inside the object", async () => {
+			const { hub, client } = createMcpHub()
+			const args = { enabled: false, count: 0, name: "" }
+
+			await hub.callTool("test-server", "configure", args, "ulid-004")
+
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.params.arguments.should.deepEqual({ enabled: false, count: 0, name: "" })
+		})
+
+		it("should pass an already-empty object through unchanged", async () => {
+			const { hub, client } = createMcpHub()
+
+			await hub.callTool("test-server", "list_pages", {}, "ulid-005")
+
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.params.arguments.should.deepEqual({})
+		})
+	})
+
+	// ── Request structure validation ────────────────────────────────────
+
+	describe("request structure", () => {
+		it("should always include method 'tools/call' in the request", async () => {
+			const { hub, client } = createMcpHub()
+
+			await hub.callTool("test-server", "any_tool", undefined, "ulid-006")
+
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.method.should.equal("tools/call")
+		})
+
+		it("should set the tool name in params.name", async () => {
+			const { hub, client } = createMcpHub()
+
+			await hub.callTool("test-server", "list_pages", undefined, "ulid-007")
+
+			const requestArgs = client.request.firstCall.args[0]
+			requestArgs.params.name.should.equal("list_pages")
+		})
+
+		it("should pass timeout in request options", async () => {
+			const { hub, client } = createMcpHub()
+
+			await hub.callTool("test-server", "slow_tool", { query: "test" }, "ulid-008")
+
+			const requestOptions = client.request.firstCall.args[2]
+			requestOptions.should.have.property("timeout")
+			requestOptions.timeout.should.be.a.Number()
+			requestOptions.timeout.should.be.above(0)
+		})
+	})
+
+	// ── Error handling ──────────────────────────────────────────────────
+
+	describe("error handling", () => {
+		it("should throw when server connection is not found", async () => {
+			const { hub } = createMcpHub({ serverName: "existing-server" })
+
+			let threw = false
+			try {
+				await hub.callTool("nonexistent-server", "some_tool", undefined, "ulid-009")
+			} catch (error: any) {
+				threw = true
+				error.message.should.containEql("No connection found for server: nonexistent-server")
+			}
+			threw.should.be.true()
+		})
+
+		it("should throw when server is disabled", async () => {
+			const { hub } = createMcpHub({ disabled: true })
+
+			let threw = false
+			try {
+				await hub.callTool("test-server", "some_tool", undefined, "ulid-010")
+			} catch (error: any) {
+				threw = true
+				error.message.should.containEql("disabled")
+			}
+			threw.should.be.true()
+		})
+
+		it("should capture error telemetry when client.request fails", async () => {
+			const client = createMockClient()
+			client.request.rejects(new Error("Network timeout"))
+			const { hub, telemetryService } = createMcpHub({ client })
+
+			let threw = false
+			try {
+				await hub.callTool("test-server", "failing_tool", { key: "value" }, "ulid-011")
+			} catch {
+				threw = true
+			}
+
+			threw.should.be.true()
+			telemetryService.captureMcpToolCall.calledTwice.should.be.true()
+
+			// First call: "started"
+			const startedCall = telemetryService.captureMcpToolCall.firstCall.args
+			startedCall[3].should.equal("started")
+
+			// Second call: "error"
+			const errorCall = telemetryService.captureMcpToolCall.secondCall.args
+			errorCall[3].should.equal("error")
+			errorCall[4].should.equal("Network timeout")
+		})
+	})
+
+	// ── Telemetry ───────────────────────────────────────────────────────
+
+	describe("telemetry", () => {
+		it("should capture 'started' telemetry before request and 'success' after", async () => {
+			const { hub, telemetryService } = createMcpHub()
+
+			await hub.callTool("test-server", "list_pages", undefined, "ulid-012")
+
+			telemetryService.captureMcpToolCall.calledTwice.should.be.true()
+			telemetryService.captureMcpToolCall.firstCall.args[3].should.equal("started")
+			telemetryService.captureMcpToolCall.secondCall.args[3].should.equal("success")
+		})
+
+		it("should report undefined for argument keys when toolArguments is undefined", async () => {
+			const { hub, telemetryService } = createMcpHub()
+
+			await hub.callTool("test-server", "list_pages", undefined, "ulid-013")
+
+			// Both started and success should report undefined argument keys
+			const startedArgKeys = telemetryService.captureMcpToolCall.firstCall.args[5]
+			should(startedArgKeys).be.undefined()
+
+			const successArgKeys = telemetryService.captureMcpToolCall.secondCall.args[5]
+			should(successArgKeys).be.undefined()
+		})
+
+		it("should report argument keys when toolArguments is provided", async () => {
+			const { hub, telemetryService } = createMcpHub()
+
+			await hub.callTool("test-server", "navigate", { url: "https://x.com", timeout: 5000 }, "ulid-014")
+
+			const startedArgKeys = telemetryService.captureMcpToolCall.firstCall.args[5]
+			startedArgKeys.should.deepEqual(["url", "timeout"])
+		})
+	})
+
+	// ── Response handling ───────────────────────────────────────────────
+
+	describe("response handling", () => {
+		it("should return content array from successful response", async () => {
+			const client = createMockClient({
+				content: [{ type: "text", text: "page list result" }],
+			})
+			const { hub } = createMcpHub({ client })
+
+			const result = await hub.callTool("test-server", "list_pages", undefined, "ulid-015")
+
+			result.content.should.be.an.Array()
+			result.content.should.have.length(1)
+			;(result.content[0] as { type: "text"; text: string }).text.should.equal("page list result")
+		})
+
+		it("should default content to empty array when response content is undefined", async () => {
+			const client = createMockClient({ content: undefined })
+			const { hub } = createMcpHub({ client })
+
+			const result = await hub.callTool("test-server", "list_pages", undefined, "ulid-016")
+
+			result.content.should.be.an.Array()
+			result.content.should.have.length(0)
+		})
+	})
+})
diff --git a/apps/vscode/src/services/mcp/__tests__/McpHub.deleteServerRPC.test.ts b/apps/vscode/src/services/mcp/__tests__/McpHub.deleteServerRPC.test.ts
new file mode 100644
index 0000000..b9f1b1d
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/McpHub.deleteServerRPC.test.ts
@@ -0,0 +1,204 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import "should"
+import * as actualDiskModule from "@core/storage/disk"
+import fs, * as actualFsPromises from "fs/promises"
+import os from "os"
+import path from "path"
+import sinon from "sinon"
+
+// bun loads real ESM, so sinon cannot stub the `@core/storage/disk` namespace
+// export, and `fs.promises` (the default import below) is NOT the same object as
+// the SUT's `import * as fs from "fs/promises"`. Inject module-level sinon stubs
+// via mock.module so the full sinon stub API keeps working on the exact
+// specifiers the SUT imports. `writeFile` defaults to the real implementation so
+// the test's own settings-file writes still hit disk.
+// Capture the genuine writeFile before mock.module overrides `fs/promises`, so
+// the test's pass-through stub does not recurse into itself.
+const realWriteFile = actualFsPromises.writeFile
+const getMcpSettingsFilePathStub: sinon.SinonStub = sinon.stub()
+const writeFileStub: sinon.SinonStub = sinon.stub()
+const diskMock = () => ({ ...actualDiskModule, getMcpSettingsFilePath: getMcpSettingsFilePathStub })
+const fsPromisesNamespace = { ...actualFsPromises, writeFile: writeFileStub }
+const fsPromisesMock = () => ({ ...fsPromisesNamespace, default: fsPromisesNamespace })
+mock.module("@core/storage/disk", diskMock)
+mock.module("@/core/storage/disk", diskMock)
+mock.module("fs/promises", fsPromisesMock)
+mock.module("node:fs/promises", fsPromisesMock)
+
+// The settings write goes through settingsLock.ts, which writes the file with
+// synchronous `node:fs` (temp file + rename), not `fs/promises`. Wrap
+// writeFileSync/renameSync at the module level so a test can observe that the
+// real settings path is only ever produced by an atomic rename — never written
+// in place. Both default to the real implementation so the lock and the write
+// still hit disk.
+const actualNodeFs = await import("node:fs")
+// Capture the genuine sync writers as values BEFORE mock.module overrides
+// `node:fs`, so the pass-through spies do not recurse into themselves.
+const realWriteFileSync = actualNodeFs.writeFileSync
+const realRenameSync = actualNodeFs.renameSync
+const writeFileSyncSpy: sinon.SinonStub = sinon.stub()
+const renameSyncSpy: sinon.SinonStub = sinon.stub()
+const nodeFsNamespace = { ...actualNodeFs, writeFileSync: writeFileSyncSpy, renameSync: renameSyncSpy }
+const nodeFsMock = () => ({ ...nodeFsNamespace, default: nodeFsNamespace })
+mock.module("fs", nodeFsMock)
+mock.module("node:fs", nodeFsMock)
+
+import { McpHub } from "../McpHub"
+
+// Regression tests for McpHub.deleteServerRPC(): deleting one server must not
+// empty the list. Tests bypass the constructor's watcher via
+// Object.create(McpHub.prototype), matching McpHub.callTool.test.ts.
+
+type FakeConnection = {
+	server: { name: string; config: string; status: string; disabled: boolean }
+	client: Record<string, unknown>
+	transport: Record<string, unknown>
+}
+
+function makeConnection(name: string): FakeConnection {
+	return {
+		server: {
+			name,
+			config: JSON.stringify({ type: "stdio", command: "test", timeout: 60 }),
+			status: "connected",
+			disabled: false,
+		},
+		client: {},
+		transport: {},
+	}
+}
+
+describe("McpHub.deleteServerRPC", () => {
+	let sandbox: sinon.SinonSandbox
+	let tempDir: string
+	let settingsPath: string
+	let hub: McpHub
+
+	const writeSettings = async (mcpServers: Record<string, unknown>) => {
+		await fs.writeFile(settingsPath, JSON.stringify({ mcpServers }, null, 2))
+	}
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+		tempDir = path.join(os.tmpdir(), `mcp-delete-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir, { recursive: true })
+		settingsPath = path.join(tempDir, "cline_mcp_settings.json")
+		getMcpSettingsFilePathStub.reset()
+		getMcpSettingsFilePathStub.resolves(settingsPath)
+		// Default writeFile to the real implementation; individual tests can wrap
+		// it to observe behavior.
+		writeFileStub.reset()
+		writeFileStub.callsFake((...args: unknown[]) => (realWriteFile as (...a: unknown[]) => Promise<void>)(...args))
+		// node:fs writeFileSync/renameSync default to the real implementation so the
+		// settings lock and atomic write still hit disk; individual tests wrap them
+		// to observe the write path.
+		writeFileSyncSpy.reset()
+		writeFileSyncSpy.callsFake((...args: unknown[]) => (realWriteFileSync as (...a: unknown[]) => void)(...args))
+		renameSyncSpy.reset()
+		renameSyncSpy.callsFake((...args: unknown[]) => (realRenameSync as (...a: unknown[]) => void)(...args))
+
+		hub = Object.create(McpHub.prototype) as McpHub
+		;(hub as any).getSettingsDirectoryPath = async () => tempDir
+		;(hub as any).connections = [makeConnection("alpha"), makeConnection("beta")]
+		// clearOAuthForConnection touches the OAuth manager; stub it out.
+		sandbox.stub(hub as any, "clearOAuthForConnection").resolves()
+		// updateServerConnectionsRPC normally opens real transports; reproduce only
+		// the relevant behavior: drop connections no longer present in the new set.
+		sandbox.stub(hub as any, "updateServerConnectionsRPC").callsFake((...args: unknown[]) => {
+			const newServers = args[0] as Record<string, unknown>
+			;(hub as any).connections = (hub as any).connections.filter((c: FakeConnection) =>
+				Object.hasOwn(newServers, c.server.name),
+			)
+			return Promise.resolve()
+		})
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	it("returns the remaining servers (not an empty list) after deleting one", async () => {
+		await writeSettings({ alpha: { type: "stdio", command: "a" }, beta: { type: "stdio", command: "b" } })
+
+		const result = await hub.deleteServerRPC("alpha")
+
+		result.should.have.length(1)
+		result.map((s) => s.name).should.deepEqual(["beta"])
+	})
+
+	it("persists the remaining server to the settings file", async () => {
+		await writeSettings({ alpha: { type: "stdio", command: "a" }, beta: { type: "stdio", command: "b" } })
+
+		await hub.deleteServerRPC("alpha")
+
+		const persisted = JSON.parse(await fs.readFile(settingsPath, "utf-8"))
+		Object.keys(persisted.mcpServers).should.deepEqual(["beta"])
+	})
+
+	it("writes atomically (temp file + rename), never truncating the real file", async () => {
+		await writeSettings({ alpha: { type: "stdio", command: "a" }, beta: { type: "stdio", command: "b" } })
+
+		// A reader must never observe the real settings file in a truncated or
+		// empty state, since a client that reads it mid-write could conclude
+		// there are no servers. settingsLock.ts writes synchronously via node:fs:
+		// it writes the new contents to a temp file, then renames that temp file
+		// onto the real settings path. So writeFileSync must only ever target a
+		// path other than the settings file, and the real path only changes via
+		// renameSync. Wrap the module-level node:fs spies (mock.module) — the
+		// write goes through node:fs, not fs/promises.
+		const writeSyncTargets: string[] = []
+		writeFileSyncSpy.callsFake((...args: unknown[]) => {
+			writeSyncTargets.push(String(args[0]))
+			return (realWriteFileSync as (...a: unknown[]) => void)(...args)
+		})
+		const renameTargets: string[] = []
+		renameSyncSpy.callsFake((...args: unknown[]) => {
+			renameTargets.push(String(args[1]))
+			return (realRenameSync as (...a: unknown[]) => void)(...args)
+		})
+
+		await hub.deleteServerRPC("alpha")
+
+		// Some writeFileSync call produced the new settings, but never in place.
+		writeSyncTargets.length.should.be.greaterThan(0)
+		writeSyncTargets.every((target) => target !== settingsPath).should.be.true()
+		// The real settings path only ever appears as a rename destination.
+		renameTargets.includes(settingsPath).should.be.true()
+		// The final file is complete and correct.
+		const persisted = JSON.parse(await fs.readFile(settingsPath, "utf-8"))
+		Object.keys(persisted.mcpServers).should.deepEqual(["beta"])
+	})
+
+	it("pre-seeds the connection fingerprint so the watcher skips its own write", async () => {
+		await writeSettings({ alpha: { type: "stdio", command: "a" }, beta: { type: "stdio", command: "b" } })
+
+		await hub.deleteServerRPC("alpha")
+
+		// After the write, lastConnectionFingerprint reflects the just-written,
+		// schema-validated content, so the watcher's "change" event for our own
+		// write is a no-op. Read the file back through the same validating reader
+		// the implementation uses so the expected fingerprint includes the schema
+		// defaults (autoApprove, timeout) the impl seeds.
+		const validated = await (hub as any).readAndValidateMcpSettingsFile()
+		const expected = (hub as any).computeConnectionFingerprint(validated.mcpServers)
+		;(hub as any).lastConnectionFingerprint.should.equal(expected)
+	})
+
+	it("throws when the server is not found", async () => {
+		await writeSettings({ beta: { type: "stdio", command: "b" } })
+
+		let threw: Error | undefined
+		try {
+			await hub.deleteServerRPC("missing")
+		} catch (err) {
+			threw = err as Error
+		}
+		;(threw === undefined).should.be.false()
+		threw!.message.should.match(/not found in MCP configuration/)
+	})
+})
diff --git a/apps/vscode/src/services/mcp/__tests__/McpHub.toggleServerDisabledRPC.test.ts b/apps/vscode/src/services/mcp/__tests__/McpHub.toggleServerDisabledRPC.test.ts
new file mode 100644
index 0000000..a4d5d1a
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/McpHub.toggleServerDisabledRPC.test.ts
@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import "should"
+import * as diskModule from "@core/storage/disk"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import sinon from "sinon"
+import { HostProvider } from "@/hosts/host-provider"
+import { McpHub } from "../McpHub"
+
+// Tests for McpHub.toggleServerDisabledRPC(): toggling a server off then on
+// must rebuild the connection rather than only flip an in-memory flag, since a
+// disabled server's connection is a stub with no live transport/client. Tests
+// bypass the constructor's watcher via Object.create(McpHub.prototype),
+// matching the sibling McpHub tests.
+
+type FakeConnection = {
+	server: { name: string; config: string; status: string; disabled: boolean }
+	client: Record<string, unknown> | null
+	transport: Record<string, unknown> | null
+}
+
+function makeConnection(name: string, disabled: boolean): FakeConnection {
+	return {
+		server: {
+			name,
+			config: JSON.stringify({ type: "stdio", command: "test", timeout: 60, disabled }),
+			status: disabled ? "disconnected" : "connected",
+			disabled,
+		},
+		client: disabled ? null : {},
+		transport: disabled ? null : {},
+	}
+}
+
+describe("McpHub.toggleServerDisabledRPC", () => {
+	let sandbox: sinon.SinonSandbox
+	let tempDir: string
+	let settingsPath: string
+	let hub: McpHub
+	let connectArgs: Array<{ name: string; disabled: boolean }>
+	let notifyCount: number
+
+	const writeSettings = async (mcpServers: Record<string, unknown>) => {
+		await fs.writeFile(settingsPath, JSON.stringify({ mcpServers }, null, 2))
+	}
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+		tempDir = path.join(os.tmpdir(), `mcp-toggle-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir, { recursive: true })
+		settingsPath = path.join(tempDir, "cline_mcp_settings.json")
+		sandbox.stub(diskModule, "getMcpSettingsFilePath").resolves(settingsPath)
+
+		connectArgs = []
+		notifyCount = 0
+
+		hub = Object.create(McpHub.prototype) as McpHub
+		;(hub as any).getSettingsDirectoryPath = async () => tempDir
+		;(hub as any).connections = []
+		;(hub as any).isConnecting = false
+		// deleteConnection just drops the connection from the in-memory list.
+		sandbox.stub(hub as any, "deleteConnection").callsFake(async (...args: unknown[]) => {
+			const name = args[0] as string
+			;(hub as any).connections = (hub as any).connections.filter((c: FakeConnection) => c.server.name !== name)
+		})
+		// connectToServer records the (name, disabled) it was asked to build and
+		// pushes a connection matching what the real method would create.
+		sandbox.stub(hub as any, "connectToServer").callsFake(async (...args: unknown[]) => {
+			const name = args[0] as string
+			const config = args[1] as { disabled?: boolean }
+			connectArgs.push({ name, disabled: Boolean(config.disabled) })
+			;(hub as any).connections.push(makeConnection(name, Boolean(config.disabled)))
+		})
+		sandbox.stub(hub as any, "notifyWebviewOfServerChanges").callsFake(async () => {
+			notifyCount++
+		})
+		// The error path calls HostProvider.window.showMessage; stub the static
+		// getter so it's harmless without a fully-initialized HostProvider.
+		sandbox.stub(HostProvider, "window").get(() => ({ showMessage: sinon.stub().resolves({}) }))
+	})
+
+	afterEach(async () => {
+		sandbox.restore()
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	it("persists disabled=true and rebuilds the connection when disabling", async () => {
+		await writeSettings({ alpha: { type: "stdio", command: "a" } })
+		;(hub as any).connections = [makeConnection("alpha", false)]
+
+		await hub.toggleServerDisabledRPC("alpha", true)
+
+		const persisted = JSON.parse(await fs.readFile(settingsPath, "utf-8"))
+		persisted.mcpServers.alpha.disabled.should.equal(true)
+		// Rebuilt as a disabled connection.
+		connectArgs.should.deepEqual([{ name: "alpha", disabled: true }])
+		notifyCount.should.be.greaterThan(0)
+	})
+
+	it("reconnects (not stuck connecting) when re-enabling a disabled server", async () => {
+		await writeSettings({ alpha: { type: "stdio", command: "a", disabled: true } })
+		;(hub as any).connections = [makeConnection("alpha", false)]
+		;(hub as any).connections[0].server.disabled = true
+		;(hub as any).connections[0].client = null
+		;(hub as any).connections[0].transport = null
+
+		const result = await hub.toggleServerDisabledRPC("alpha", false)
+
+		// File reflects enabled.
+		const persisted = JSON.parse(await fs.readFile(settingsPath, "utf-8"))
+		persisted.mcpServers.alpha.disabled.should.equal(false)
+		// The connection was actually rebuilt as enabled — this is the fix: a
+		// real connect happens rather than just flipping the flag to "connecting".
+		connectArgs.should.deepEqual([{ name: "alpha", disabled: false }])
+		// The returned (and in-memory) server is enabled and connected, not
+		// stuck on the "connecting" yellow state.
+		const alpha = result.find((s) => s.name === "alpha")
+		alpha!.disabled!.should.equal(false)
+		alpha!.status.should.equal("connected")
+	})
+
+	it("throws when the server is not found", async () => {
+		await writeSettings({ beta: { type: "stdio", command: "b" } })
+
+		let threw: Error | undefined
+		try {
+			await hub.toggleServerDisabledRPC("missing", true)
+		} catch (err) {
+			threw = err as Error
+		}
+		;(threw === undefined).should.be.false()
+		threw!.message.should.match(/not found in MCP configuration/)
+		connectArgs.should.have.length(0)
+	})
+})
diff --git a/apps/vscode/src/services/mcp/__tests__/McpHub.toolListChange.test.ts b/apps/vscode/src/services/mcp/__tests__/McpHub.toolListChange.test.ts
new file mode 100644
index 0000000..d96f4ee
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/McpHub.toolListChange.test.ts
@@ -0,0 +1,264 @@
+/**
+ * Tests for McpHub's tool list change detection and callback mechanism.
+ *
+ * These tests verify that:
+ * 1. computeToolFingerprint() produces deterministic fingerprints
+ * 2. The toolListChangeCallback fires only when the tool list actually changes
+ * 3. The callback does NOT fire on mere status updates (error messages, etc.)
+ *
+ * We avoid importing McpHub directly (too many transitive deps for unit tests).
+ * Instead we extract the pure logic and test it in isolation.
+ */
+import { describe, it } from "bun:test"
+import "should"
+import sinon from "sinon"
+
+// ---------------------------------------------------------------------------
+// Extract the pure logic from McpHub for testing
+// (These mirror the implementations in McpHub.ts exactly)
+// ---------------------------------------------------------------------------
+
+interface MinimalConnection {
+	server: {
+		name: string
+		status: string
+		disabled?: boolean
+		tools?: Array<{ name: string }>
+	}
+}
+
+function computeToolFingerprint(connections: MinimalConnection[]): string {
+	const entries: string[] = []
+	for (const conn of connections) {
+		if (conn.server.disabled || conn.server.status !== "connected") {
+			continue
+		}
+		for (const tool of conn.server.tools ?? []) {
+			entries.push(`${conn.server.name}:${tool.name}`)
+		}
+	}
+	entries.sort()
+	return entries.join("|")
+}
+
+/**
+ * Simulates the McpHub's checkToolListChanged logic.
+ */
+function createToolListChangeTracker() {
+	let lastFingerprint = ""
+	let callback: (() => void) | undefined
+
+	return {
+		setCallback(cb: () => void, connections: MinimalConnection[]) {
+			callback = cb
+			lastFingerprint = computeToolFingerprint(connections)
+		},
+		clearCallback() {
+			callback = undefined
+		},
+		check(connections: MinimalConnection[]) {
+			if (!callback) return
+			const newFingerprint = computeToolFingerprint(connections)
+			if (newFingerprint !== lastFingerprint) {
+				lastFingerprint = newFingerprint
+				try {
+					callback()
+				} catch {
+					// Errors in callback are swallowed (logged in production)
+				}
+			}
+		},
+	}
+}
+
+function makeConnection(name: string, status: string, tools: string[], disabled = false): MinimalConnection {
+	return {
+		server: {
+			name,
+			status,
+			disabled,
+			tools: tools.map((t) => ({ name: t })),
+		},
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("McpHub tool list change detection", () => {
+	describe("computeToolFingerprint", () => {
+		it("should return empty string when no servers are connected", () => {
+			computeToolFingerprint([]).should.equal("")
+		})
+
+		it("should include tools from connected, non-disabled servers", () => {
+			const connections = [makeConnection("server-a", "connected", ["tool1", "tool2"])]
+			const fp = computeToolFingerprint(connections)
+			fp.should.containEql("server-a:tool1")
+			fp.should.containEql("server-a:tool2")
+		})
+
+		it("should exclude tools from disconnected servers", () => {
+			const connections = [
+				makeConnection("server-a", "connected", ["tool1"]),
+				makeConnection("server-b", "disconnected", ["tool2"]),
+			]
+			const fp = computeToolFingerprint(connections)
+			fp.should.containEql("server-a:tool1")
+			fp.should.not.containEql("server-b:tool2")
+		})
+
+		it("should exclude tools from disabled servers", () => {
+			const connections = [makeConnection("server-a", "connected", ["tool1"], true)]
+			computeToolFingerprint(connections).should.equal("")
+		})
+
+		it("should exclude tools from connecting servers", () => {
+			const connections = [makeConnection("server-a", "connecting", ["tool1"])]
+			computeToolFingerprint(connections).should.equal("")
+		})
+
+		it("should produce sorted, deterministic output regardless of insertion order", () => {
+			const connections1 = [
+				makeConnection("z-server", "connected", ["b-tool", "a-tool"]),
+				makeConnection("a-server", "connected", ["z-tool"]),
+			]
+			const connections2 = [
+				makeConnection("a-server", "connected", ["z-tool"]),
+				makeConnection("z-server", "connected", ["a-tool", "b-tool"]),
+			]
+			computeToolFingerprint(connections1).should.equal(computeToolFingerprint(connections2))
+		})
+
+		it("should produce different fingerprints for different tool sets", () => {
+			const fp1 = computeToolFingerprint([makeConnection("s", "connected", ["tool1"])])
+			const fp2 = computeToolFingerprint([makeConnection("s", "connected", ["tool2"])])
+			fp1.should.not.equal(fp2)
+		})
+	})
+
+	describe("tool list change callback", () => {
+		it("should fire callback when tool list changes", () => {
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			// Set callback with initial empty state
+			tracker.setCallback(callback, [])
+			callback.called.should.be.false()
+
+			// Add a server with tools — fingerprint changes
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			tracker.check(connections)
+			callback.calledOnce.should.be.true()
+		})
+
+		it("should NOT fire callback when fingerprint is unchanged", () => {
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			tracker.setCallback(callback, connections)
+
+			// Check again with same state — should not fire
+			tracker.check(connections)
+			callback.called.should.be.false()
+		})
+
+		it("should fire callback when a server disconnects (tools lost)", () => {
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			tracker.setCallback(callback, connections)
+
+			// Simulate server disconnect
+			connections[0].server.status = "disconnected"
+			tracker.check(connections)
+			callback.calledOnce.should.be.true()
+		})
+
+		it("should fire callback when new tools are added to a server", () => {
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			tracker.setCallback(callback, connections)
+
+			// Add a new tool
+			connections[0].server.tools!.push({ name: "tool2" })
+			tracker.check(connections)
+			callback.calledOnce.should.be.true()
+		})
+
+		it("should fire callback when a new server connects", () => {
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			tracker.setCallback(callback, connections)
+
+			// Add a new server
+			connections.push(makeConnection("server-b", "connected", ["tool2"]))
+			tracker.check(connections)
+			callback.calledOnce.should.be.true()
+		})
+
+		it("should NOT fire callback when no callback is set", () => {
+			const tracker = createToolListChangeTracker()
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+
+			// No callback set — should not throw
+			tracker.check(connections)
+		})
+
+		it("should handle callback errors gracefully", () => {
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub().throws(new Error("callback error"))
+
+			tracker.setCallback(callback, [])
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+
+			// Should not throw even though callback throws
+			;(() => tracker.check(connections)).should.not.throw()
+		})
+
+		it("should stop firing after clearCallback", () => {
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			tracker.setCallback(callback, [])
+			tracker.clearCallback()
+
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			tracker.check(connections)
+			callback.called.should.be.false()
+		})
+
+		it("should track cumulative changes correctly", () => {
+			const tracker = createToolListChangeTracker()
+			const callback = sinon.stub()
+
+			tracker.setCallback(callback, [])
+
+			// First change: add server
+			const connections = [makeConnection("server-a", "connected", ["tool1"])]
+			tracker.check(connections)
+			callback.callCount.should.equal(1)
+
+			// No change: same state
+			tracker.check(connections)
+			callback.callCount.should.equal(1)
+
+			// Second change: add tool
+			connections[0].server.tools!.push({ name: "tool2" })
+			tracker.check(connections)
+			callback.callCount.should.equal(2)
+
+			// Third change: server disconnects
+			connections[0].server.status = "disconnected"
+			tracker.check(connections)
+			callback.callCount.should.equal(3)
+		})
+	})
+})
diff --git a/apps/vscode/src/services/mcp/__tests__/StreamableHttpReconnectHandler.test.ts b/apps/vscode/src/services/mcp/__tests__/StreamableHttpReconnectHandler.test.ts
new file mode 100644
index 0000000..7d94e9e
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/StreamableHttpReconnectHandler.test.ts
@@ -0,0 +1,302 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import sinon from "sinon"
+import {
+	DEFAULT_RECONNECT_CONFIG,
+	ReconnectCallbacks,
+	ReconnectConfig,
+	StreamableHttpReconnectHandler,
+} from "../StreamableHttpReconnectHandler"
+
+/** Build a mock connection object whose status can be inspected. */
+function makeConnection(overrides: Partial<{ status: string; disabled: boolean; uid: string }> = {}) {
+	return {
+		server: {
+			status: overrides.status ?? "connected",
+			disabled: overrides.disabled ?? false,
+			uid: overrides.uid ?? "uid-123",
+		},
+	}
+}
+
+/** Build a default set of spy-based callbacks. The `delay` resolves immediately. */
+function makeCallbacks(connection?: ReturnType<typeof makeConnection>): ReconnectCallbacks & {
+	/** Direct access to the underlying sinon stubs for assertions */
+	stubs: Record<string, sinon.SinonStub>
+} {
+	const conn = connection ?? makeConnection()
+	const stubs: Record<string, sinon.SinonStub> = {
+		findConnection: sinon.stub().returns(conn),
+		deleteConnection: sinon.stub().resolves(),
+		connectToServer: sinon.stub().resolves(),
+		notifyWebviewOfServerChanges: sinon.stub().resolves(),
+		appendErrorMessage: sinon.stub(),
+		deleteServerKey: sinon.stub(),
+		delay: sinon.stub().resolves(), // instant — no real waiting in tests
+	}
+	return { ...(stubs as unknown as ReconnectCallbacks), stubs }
+}
+
+/** A config with a small max so tests don't loop many times. */
+const TEST_CONFIG: ReconnectConfig = {
+	maxAttempts: 3,
+	getDelayMs: (attempt) => 100 * 2 ** attempt, // 100, 200, 400
+}
+
+describe("StreamableHttpReconnectHandler", () => {
+	let sandbox: sinon.SinonSandbox
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	// ── basics ──────────────────────────────────────────────────────────
+
+	it("should export sensible defaults", () => {
+		DEFAULT_RECONNECT_CONFIG.maxAttempts.should.equal(6)
+		DEFAULT_RECONNECT_CONFIG.getDelayMs(0).should.equal(2000)
+		DEFAULT_RECONNECT_CONFIG.getDelayMs(1).should.equal(4000)
+		DEFAULT_RECONNECT_CONFIG.getDelayMs(2).should.equal(8000)
+	})
+
+	// ── no-op cases ─────────────────────────────────────────────────────
+
+	it("should do nothing when findConnection returns undefined", async () => {
+		const cbs = makeCallbacks()
+		cbs.stubs.findConnection.returns(undefined)
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("boom"))
+
+		cbs.stubs.deleteConnection.called.should.be.false()
+		cbs.stubs.connectToServer.called.should.be.false()
+		handler.attemptCount.should.equal(0)
+	})
+
+	it("should skip reconnect when server is disabled", async () => {
+		const conn = makeConnection({ disabled: true })
+		const cbs = makeCallbacks(conn)
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("boom"))
+
+		cbs.stubs.deleteConnection.called.should.be.false()
+		handler.attemptCount.should.equal(0)
+	})
+
+	it("should skip reconnect when server is already connecting", async () => {
+		const conn = makeConnection({ status: "connecting" })
+		const cbs = makeCallbacks(conn)
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("boom"))
+
+		cbs.stubs.deleteConnection.called.should.be.false()
+		handler.attemptCount.should.equal(0)
+	})
+
+	// ── successful reconnect ────────────────────────────────────────────
+
+	it("should reconnect on first error and reset attempt counter", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("connection lost"))
+
+		// Should have called delete + connect
+		cbs.stubs.deleteConnection.calledOnce.should.be.true()
+		cbs.stubs.connectToServer.calledOnce.should.be.true()
+		// Counter resets to 0 after success
+		handler.attemptCount.should.equal(0)
+		// Status was set to "connecting" during the attempt
+		cbs.stubs.notifyWebviewOfServerChanges.called.should.be.true()
+	})
+
+	it("should use the configured delay for each attempt", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		// Make connectToServer fail on first call, succeed on second
+		cbs.stubs.connectToServer.onFirstCall().rejects(new Error("fail"))
+		cbs.stubs.connectToServer.onSecondCall().resolves()
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		// Single handleError call — the retry loop handles both attempts internally
+		await handler.handleError(new Error("err1"))
+
+		// Initial backoff delay (attempt 0 → 100ms), then retry delay (attempt 1 → 200ms)
+		cbs.stubs.delay.callCount.should.equal(2)
+		cbs.stubs.delay.firstCall.args[0].should.equal(100)
+		cbs.stubs.delay.secondCall.args[0].should.equal(200)
+
+		// Second connect succeeded → counter reset
+		handler.attemptCount.should.equal(0)
+		cbs.stubs.connectToServer.callCount.should.equal(2)
+	})
+
+	// ── exhausted retries ───────────────────────────────────────────────
+
+	it("should mark server as disconnected after maxAttempts exhausted", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		// All reconnect attempts fail
+		cbs.stubs.connectToServer.rejects(new Error("still broken"))
+
+		// After deleteConnection, findConnection returns undefined (old conn deleted)
+		// but connectToServer may leave a partial connection, so simulate that
+		const partialConn = makeConnection({ uid: "uid-partial" })
+		let deleted = false
+		cbs.stubs.findConnection.callsFake(() => {
+			if (!deleted) return conn
+			return partialConn
+		})
+		cbs.stubs.deleteConnection.callsFake(async () => {
+			deleted = true
+		})
+
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		// Single handleError call exhausts all 3 attempts via the internal retry loop
+		await handler.handleError(new Error("transport error"))
+
+		handler.attemptCount.should.equal(TEST_CONFIG.maxAttempts)
+
+		// connectToServer was called maxAttempts times (3)
+		cbs.stubs.connectToServer.callCount.should.equal(TEST_CONFIG.maxAttempts)
+
+		// The partial connection should be marked disconnected
+		partialConn.server.status.should.equal("disconnected")
+		cbs.stubs.deleteServerKey.calledWith("uid-partial").should.be.true()
+		cbs.stubs.appendErrorMessage.calledOnce.should.be.true()
+		cbs.stubs.appendErrorMessage.firstCall.args[1].should.equal("transport error")
+	})
+
+	it("should mark disconnected even when no connection exists after exhaustion", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		cbs.stubs.connectToServer.rejects(new Error("broken"))
+
+		// After deleteConnection, findConnection returns undefined
+		let deleted = false
+		cbs.stubs.findConnection.callsFake(() => (deleted ? undefined : conn))
+		cbs.stubs.deleteConnection.callsFake(async () => {
+			deleted = true
+		})
+
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("transport error"))
+
+		handler.attemptCount.should.equal(TEST_CONFIG.maxAttempts)
+		// No partial connection to mark, but notifyWebview should still be called
+		cbs.stubs.notifyWebviewOfServerChanges.called.should.be.true()
+		// appendErrorMessage not called since there's no connection to append to
+		cbs.stubs.appendErrorMessage.called.should.be.false()
+	})
+
+	it("should exhaust retries when called with attempts already at max", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		const config: ReconnectConfig = { maxAttempts: 0, getDelayMs: () => 0 }
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, config)
+
+		await handler.handleError(new Error("final error"))
+
+		conn.server.status.should.equal("disconnected")
+		cbs.stubs.deleteServerKey.calledWith("uid-123").should.be.true()
+		cbs.stubs.appendErrorMessage.calledOnce.should.be.true()
+		cbs.stubs.connectToServer.called.should.be.false()
+	})
+
+	// ── connectToServer failure retries automatically ───────────────────
+
+	it("should retry connectToServer on failure without relying on onerror", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		// First two attempts fail, third succeeds
+		cbs.stubs.connectToServer.onFirstCall().rejects(new Error("fail 1"))
+		cbs.stubs.connectToServer.onSecondCall().rejects(new Error("fail 2"))
+		cbs.stubs.connectToServer.onThirdCall().resolves()
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		// A single handleError call should retry all 3 attempts internally
+		await handler.handleError(new Error("transport error"))
+
+		cbs.stubs.connectToServer.callCount.should.equal(3)
+		handler.attemptCount.should.equal(0) // reset on success
+
+		// Delays: initial(100) + retry(200) + retry(400)
+		cbs.stubs.delay.callCount.should.equal(3)
+		cbs.stubs.delay.getCall(0).args[0].should.equal(100)
+		cbs.stubs.delay.getCall(1).args[0].should.equal(200)
+		cbs.stubs.delay.getCall(2).args[0].should.equal(400)
+	})
+
+	// ── connection replaced mid-reconnect ───────────────────────────────
+
+	it("should abort reconnect if connection was replaced during delay", async () => {
+		const conn = makeConnection()
+		const differentConn = makeConnection({ uid: "uid-replaced" })
+		const cbs = makeCallbacks(conn)
+		// After the delay, findConnection returns a different object
+		cbs.stubs.findConnection.onFirstCall().returns(conn)
+		cbs.stubs.findConnection.onSecondCall().returns(differentConn)
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("err"))
+
+		// delay was called, but delete/connect were NOT (connection was replaced)
+		cbs.stubs.delay.calledOnce.should.be.true()
+		cbs.stubs.deleteConnection.called.should.be.false()
+		cbs.stubs.connectToServer.called.should.be.false()
+	})
+
+	it("should abort reconnect if connection disappeared during delay", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		cbs.stubs.findConnection.onFirstCall().returns(conn)
+		cbs.stubs.findConnection.onSecondCall().returns(undefined)
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		await handler.handleError(new Error("err"))
+
+		cbs.stubs.deleteConnection.called.should.be.false()
+		cbs.stubs.connectToServer.called.should.be.false()
+	})
+
+	// ── resetAttempts ───────────────────────────────────────────────────
+
+	it("should allow manual reset of attempt counter", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		cbs.stubs.connectToServer.rejects(new Error("fail"))
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, TEST_CONFIG)
+
+		// After exhausting all retries, attemptCount should be at max
+		await handler.handleError(new Error("err1"))
+		handler.attemptCount.should.equal(TEST_CONFIG.maxAttempts)
+
+		handler.resetAttempts()
+		handler.attemptCount.should.equal(0)
+	})
+
+	// ── error message formatting ────────────────────────────────────────
+
+	it("should use string coercion for non-Error objects on exhaustion", async () => {
+		const conn = makeConnection()
+		const cbs = makeCallbacks(conn)
+		cbs.stubs.connectToServer.rejects(new Error("fail"))
+		const config: ReconnectConfig = { maxAttempts: 0, getDelayMs: () => 0 }
+		const handler = new StreamableHttpReconnectHandler("test-server", cbs, config)
+
+		// Pass a plain string as the error
+		await handler.handleError("string-error-message")
+
+		cbs.stubs.appendErrorMessage.calledOnce.should.be.true()
+		cbs.stubs.appendErrorMessage.firstCall.args[1].should.equal("string-error-message")
+	})
+})
diff --git a/apps/vscode/src/services/mcp/__tests__/schemas.test.ts b/apps/vscode/src/services/mcp/__tests__/schemas.test.ts
new file mode 100644
index 0000000..0855b97
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/schemas.test.ts
@@ -0,0 +1,275 @@
+import { describe, it } from "bun:test"
+import "should"
+import { McpSettingsSchema, ServerConfigSchema } from "../schemas"
+
+/**
+ * Unit tests for MCP settings schema parsing.
+ *
+ * Covers three formats:
+ *  1. "Nested transport" format written by the Cline CLI (`cline mcp add`)
+ *  2. "Flat" legacy format accepted by the VSCode extension before this change
+ *  3. Invalid configs that must still be rejected
+ */
+describe("McpSettingsSchema", () => {
+	// -------------------------------------------------------------------------
+	// Nested transport format (written by the Cline CLI)
+	// -------------------------------------------------------------------------
+
+	describe("nested transport format (CLI-authored)", () => {
+		it("accepts a streamableHttp server written by the CLI", () => {
+			const input = {
+				mcpServers: {
+					linear: {
+						transport: {
+							type: "streamableHttp",
+							url: "https://mcp.linear.app/mcp",
+						},
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+
+			const server = result.data!.mcpServers["linear"]
+			server.type.should.equal("streamableHttp")
+			;(server as any).url.should.equal("https://mcp.linear.app/mcp")
+		})
+
+		it("accepts a SSE server with headers in nested format", () => {
+			const input = {
+				mcpServers: {
+					myServer: {
+						transport: {
+							type: "sse",
+							url: "https://mcp.example.com/sse",
+							headers: { Authorization: "Bearer tok" },
+						},
+						disabled: true,
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+
+			const server = result.data!.mcpServers["myServer"]
+			server.type.should.equal("sse")
+			;(server as any).url.should.equal("https://mcp.example.com/sse")
+			;(server as any).headers.should.deepEqual({ Authorization: "Bearer tok" })
+			server.disabled!.should.be.true()
+		})
+
+		it("accepts a stdio server in nested format", () => {
+			const input = {
+				mcpServers: {
+					docs: {
+						transport: {
+							type: "stdio",
+							command: "npx",
+							args: ["-y", "@modelcontextprotocol/server-filesystem"],
+						},
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+
+			const server = result.data!.mcpServers["docs"]
+			server.type.should.equal("stdio")
+			;(server as any).command.should.equal("npx")
+		})
+
+		it("preserves oauth field from CLI-authored nested format", () => {
+			const oauthState = {
+				tokens: { access_token: "tok", token_type: "Bearer" },
+				lastAuthenticatedAt: 1700000000,
+			}
+			const input = {
+				mcpServers: {
+					linear: {
+						transport: { type: "streamableHttp", url: "https://mcp.linear.app/mcp" },
+						oauth: oauthState,
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+			;(result.data!.mcpServers["linear"] as any).oauth.should.deepEqual(oauthState)
+		})
+
+		it("preserves metadata field from CLI-authored nested format", () => {
+			const metadata = { addedBy: "cline-cli", version: "1.2.3" }
+			const input = {
+				mcpServers: {
+					myServer: {
+						transport: { type: "streamableHttp", url: "https://mcp.example.com/mcp" },
+						metadata,
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+			;(result.data!.mcpServers["myServer"] as any).metadata.should.deepEqual(metadata)
+		})
+
+		it("preserves autoApprove and timeout alongside nested transport", () => {
+			const input = {
+				mcpServers: {
+					myServer: {
+						transport: { type: "streamableHttp", url: "https://mcp.example.com/mcp" },
+						autoApprove: ["my_tool"],
+						timeout: 120,
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+
+			const server = result.data!.mcpServers["myServer"]
+			server.autoApprove!.should.deepEqual(["my_tool"])
+			server.timeout.should.equal(120)
+		})
+
+		it("rejects nested format with an invalid transport type", () => {
+			const input = {
+				mcpServers: {
+					bad: {
+						transport: { type: "unknownTransport", url: "https://mcp.example.com/mcp" },
+					},
+				},
+			}
+			McpSettingsSchema.safeParse(input).success.should.be.false()
+		})
+
+		it("rejects nested stdio transport with empty command", () => {
+			const input = {
+				mcpServers: {
+					bad: {
+						transport: { type: "stdio", command: "" }, // empty — min(1) fails
+					},
+				},
+			}
+			McpSettingsSchema.safeParse(input).success.should.be.false()
+		})
+	})
+
+	// -------------------------------------------------------------------------
+	// Flat legacy format (written by the VSCode extension)
+	// -------------------------------------------------------------------------
+
+	describe("flat legacy format (extension-authored)", () => {
+		it("accepts a flat streamableHttp server", () => {
+			const input = {
+				mcpServers: {
+					myServer: {
+						type: "streamableHttp",
+						url: "https://mcp.example.com/mcp",
+						autoApprove: [],
+						timeout: 60,
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+
+			const server = result.data!.mcpServers["myServer"]
+			server.type.should.equal("streamableHttp")
+			;(server as any).url.should.equal("https://mcp.example.com/mcp")
+		})
+
+		it("accepts a flat stdio server with no explicit type", () => {
+			const input = {
+				mcpServers: {
+					docs: {
+						command: "npx",
+						args: ["-y", "@modelcontextprotocol/server-filesystem"],
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+			result.data!.mcpServers["docs"].type.should.equal("stdio")
+		})
+
+		it("accepts a flat SSE server with no explicit type (legacy default)", () => {
+			const input = {
+				mcpServers: { legacy: { url: "https://mcp.example.com/sse" } },
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+			// Without a type field, the flat schema defaults to "sse"
+			result.data!.mcpServers["legacy"].type.should.equal("sse")
+		})
+
+		it("preserves oauth on flat-format servers (round-trip from write-back)", () => {
+			const oauthState = { tokens: { access_token: "tok" } }
+			const input = {
+				mcpServers: {
+					myServer: {
+						type: "streamableHttp",
+						url: "https://mcp.example.com/mcp",
+						oauth: oauthState,
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+			;(result.data!.mcpServers["myServer"] as any).oauth.should.deepEqual(oauthState)
+		})
+	})
+
+	// -------------------------------------------------------------------------
+	// Mixed format — CLI and extension servers in the same file
+	// -------------------------------------------------------------------------
+
+	describe("mixed format (CLI and extension servers in the same file)", () => {
+		it("accepts a file with both nested and flat servers", () => {
+			const input = {
+				mcpServers: {
+					cliServer: {
+						transport: { type: "streamableHttp", url: "https://mcp.linear.app/mcp" },
+						oauth: { tokens: {} },
+					},
+					extensionServer: {
+						command: "node",
+						args: ["server.js"],
+						autoApprove: ["tool1"],
+					},
+				},
+			}
+
+			const result = McpSettingsSchema.safeParse(input)
+			result.success.should.be.true()
+
+			result.data!.mcpServers["cliServer"].type.should.equal("streamableHttp")
+			result.data!.mcpServers["extensionServer"].type.should.equal("stdio")
+		})
+	})
+
+	// -------------------------------------------------------------------------
+	// ServerConfigSchema – direct usage
+	// -------------------------------------------------------------------------
+
+	describe("ServerConfigSchema direct parse", () => {
+		it("normalises nested format to flat (no transport key in output)", () => {
+			const result = ServerConfigSchema.safeParse({
+				transport: { type: "streamableHttp", url: "https://mcp.example.com" },
+			})
+			result.success.should.be.true()
+			const flat = result.data!
+			;(flat as any).type.should.equal("streamableHttp")
+			;(flat as any).url.should.equal("https://mcp.example.com")
+			// `transport` key must NOT be present on the output
+			;("transport" in flat).should.be.false()
+		})
+	})
+})
diff --git a/apps/vscode/src/services/mcp/__tests__/settingsLock.test.ts b/apps/vscode/src/services/mcp/__tests__/settingsLock.test.ts
new file mode 100644
index 0000000..1204a83
--- /dev/null
+++ b/apps/vscode/src/services/mcp/__tests__/settingsLock.test.ts
@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { updateMcpSettingsFile } from "../settingsLock"
+
+describe("updateMcpSettingsFile", () => {
+	let tempDir: string
+	let settingsPath: string
+
+	beforeEach(async () => {
+		tempDir = path.join(os.tmpdir(), `mcp-settings-lock-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+		await fs.mkdir(tempDir, { recursive: true })
+		settingsPath = path.join(tempDir, "cline_mcp_settings.json")
+		await fs.writeFile(settingsPath, JSON.stringify({ mcpServers: {} }, null, 2))
+	})
+
+	afterEach(async () => {
+		await fs.rm(tempDir, { recursive: true, force: true })
+	})
+
+	it("does not yield while holding the settings lock", async () => {
+		let mutatorRan = false
+
+		const update = updateMcpSettingsFile(settingsPath, (settings) => {
+			mutatorRan = true
+			settings.mcpServers = {
+				alpha: {
+					type: "stdio",
+					command: "node",
+				},
+			}
+			return "updated"
+		})
+
+		expect(mutatorRan).toBe(true)
+		expect(existsSync(`${settingsPath}.lock`)).toBe(false)
+		await expect(update).resolves.toBe("updated")
+	})
+
+	it("creates a missing settings file inside the lock", async () => {
+		const missingPath = path.join(tempDir, "fresh", "cline_mcp_settings.json")
+
+		await updateMcpSettingsFile(missingPath, (settings) => {
+			settings.mcpServers = { alpha: { type: "stdio", command: "node" } }
+		})
+
+		const written = JSON.parse(await fs.readFile(missingPath, "utf-8"))
+		expect(Object.keys(written.mcpServers)).toEqual(["alpha"])
+		expect(existsSync(`${missingPath}.lock`)).toBe(false)
+	})
+})
diff --git a/apps/vscode/src/services/mcp/constants.ts b/apps/vscode/src/services/mcp/constants.ts
new file mode 100644
index 0000000..6b4a5a7
--- /dev/null
+++ b/apps/vscode/src/services/mcp/constants.ts
@@ -0,0 +1,10 @@
+/**
+ * Default timeout for internal MCP data requests in milliseconds.
+ * This is not the same as the user facing timeout stored as DEFAULT_MCP_TIMEOUT_SECONDS.
+ */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 5000
+
+/**
+ * Custom error message for better user feedback when server type validation fails.
+ */
+export const TYPE_ERROR_MESSAGE = "Server type must be one of: 'stdio', 'sse', or 'streamableHttp'"
diff --git a/apps/vscode/src/services/mcp/schemas.ts b/apps/vscode/src/services/mcp/schemas.ts
new file mode 100644
index 0000000..d904521
--- /dev/null
+++ b/apps/vscode/src/services/mcp/schemas.ts
@@ -0,0 +1,160 @@
+import { DEFAULT_MCP_TIMEOUT_SECONDS, MIN_MCP_TIMEOUT_SECONDS } from "@shared/mcp"
+import { z } from "zod"
+import { TYPE_ERROR_MESSAGE } from "./constants"
+
+const AutoApproveSchema = z.array(z.string()).default([])
+
+export const BaseConfigSchema = z.object({
+	autoApprove: AutoApproveSchema.optional(),
+	disabled: z.boolean().optional(),
+	timeout: z.number().min(MIN_MCP_TIMEOUT_SECONDS).optional().default(DEFAULT_MCP_TIMEOUT_SECONDS),
+	// Marker for servers that were added by remote config sync.
+	// Used to identify which servers should be removed when they are no longer in the remote config.
+	remoteConfigured: z.boolean().optional(),
+	// OAuth state written by the CLI — preserved as-is (VSCode doesn't implement OAuth flows yet)
+	oauth: z.unknown().optional(),
+	// Arbitrary metadata written by the CLI — preserved as-is
+	metadata: z.unknown().optional(),
+})
+
+// Transport schemas for the nested format (as written by the Cline CLI)
+const nestedStdioTransportSchema = z.object({
+	type: z.literal("stdio"),
+	command: z.string().min(1),
+	args: z.array(z.string()).optional(),
+	cwd: z.string().optional(),
+	env: z.record(z.string(), z.string()).optional(),
+})
+
+const nestedSseTransportSchema = z.object({
+	type: z.literal("sse"),
+	url: z.string().url("URL must be a valid URL format"),
+	headers: z.record(z.string(), z.string()).optional(),
+})
+
+const nestedStreamableHttpTransportSchema = z.object({
+	type: z.literal("streamableHttp"),
+	url: z.string().url("URL must be a valid URL format"),
+	headers: z.record(z.string(), z.string()).optional(),
+})
+
+/**
+ * Nested transport format as produced by the Cline CLI (`cline mcp add`).
+ *
+ * The CLI writes:
+ * ```json
+ * { "transport": { "type": "streamableHttp", "url": "..." }, "disabled": false, "oauth": { ... } }
+ * ```
+ *
+ * This arm normalises it to the flat format used internally by the extension:
+ * ```json
+ * { "type": "streamableHttp", "url": "...", "disabled": false, "oauth": { ... } }
+ * ```
+ *
+ * Placed first in the union so the `transport` key acts as an unambiguous discriminator.
+ */
+const nestedTransportConfigSchema = z
+	.object({
+		transport: z.discriminatedUnion("type", [
+			nestedStdioTransportSchema,
+			nestedSseTransportSchema,
+			nestedStreamableHttpTransportSchema,
+		]),
+		disabled: z.boolean().optional(),
+		autoApprove: AutoApproveSchema.optional(),
+		timeout: z.number().min(MIN_MCP_TIMEOUT_SECONDS).optional().default(DEFAULT_MCP_TIMEOUT_SECONDS),
+		remoteConfigured: z.boolean().optional(),
+		oauth: z.unknown().optional(),
+		metadata: z.unknown().optional(),
+	})
+	.transform((data) => {
+		const { transport, ...rest } = data
+		// Flatten: hoist transport fields to the top level (matches the flat format)
+		return { ...transport, ...rest }
+	})
+
+// Helper function to create a refined schema with better error messages
+const createServerTypeSchema = () => {
+	return z.union([
+		// Nested transport format (as written by the CLI: { transport: { type, ... }, ... })
+		// Must be first so the presence of a `transport` key is an unambiguous discriminator.
+		nestedTransportConfigSchema,
+		// Stdio config (has command field)
+		BaseConfigSchema.extend({
+			type: z.literal("stdio").optional(),
+			transportType: z.string().optional(), // Support legacy field
+			command: z.string(),
+			args: z.array(z.string()).optional(),
+			cwd: z.string().optional(),
+			env: z.record(z.string(), z.string()).optional(),
+			// Allow other fields for backward compatibility
+			url: z.string().optional(),
+			headers: z.record(z.string(), z.string()).optional(),
+		})
+			.transform((data) => {
+				// Support both type and transportType fields
+				const finalType = data.type || (data.transportType === "stdio" ? "stdio" : undefined) || "stdio"
+				return {
+					...data,
+					type: finalType as "stdio",
+					// Remove the legacy field after transformation
+					transportType: undefined,
+				}
+			})
+			.refine((data) => data.type === "stdio", { message: TYPE_ERROR_MESSAGE }),
+		// SSE config (has url field)
+		// IMPORTANT: The fact that this is listed first before streamableHttp means that when type is not specified, it will default to sse. Since there may be users with older MCP servers configured without a type specified, rearranging this to make streamableHttp first will be a breaking change.
+		BaseConfigSchema.extend({
+			type: z.literal("sse").optional(),
+			transportType: z.string().optional(), // Support legacy field
+			url: z.string().url("URL must be a valid URL format"),
+			headers: z.record(z.string(), z.string()).optional(),
+			// Allow other fields for backward compatibility
+			command: z.string().optional(),
+			args: z.array(z.string()).optional(),
+			env: z.record(z.string(), z.string()).optional(),
+		})
+			.transform((data) => {
+				// Support both type and transportType fields
+				const finalType = data.type || (data.transportType === "sse" ? "sse" : undefined) || "sse"
+				return {
+					...data,
+					type: finalType as "sse",
+					// Remove the legacy field after transformation
+					transportType: undefined,
+				}
+			})
+			.refine((data) => data.type === "sse", { message: TYPE_ERROR_MESSAGE }),
+		// Streamable HTTP config (has url field)
+		BaseConfigSchema.extend({
+			type: z.literal("streamableHttp").optional(),
+			transportType: z.string().optional(), // Support legacy field
+			url: z.string().url("URL must be a valid URL format"),
+			headers: z.record(z.string(), z.string()).optional(),
+			// Allow other fields for backward compatibility
+			command: z.string().optional(),
+			args: z.array(z.string()).optional(),
+			env: z.record(z.string(), z.string()).optional(),
+		})
+			.transform((data) => {
+				// Support both type and transportType fields
+				// Note: legacy transportType was "http" not "streamableHttp"
+				const finalType = data.type || (data.transportType === "http" ? "streamableHttp" : undefined) || "streamableHttp"
+				return {
+					...data,
+					type: finalType as "streamableHttp",
+					// Remove the legacy field after transformation
+					transportType: undefined,
+				}
+			})
+			.refine((data) => data.type === "streamableHttp", {
+				message: TYPE_ERROR_MESSAGE,
+			}),
+	])
+}
+
+export const ServerConfigSchema = createServerTypeSchema()
+
+export const McpSettingsSchema = z.object({
+	mcpServers: z.record(z.string(), ServerConfigSchema),
+})
diff --git a/apps/vscode/src/services/mcp/settingsLock.ts b/apps/vscode/src/services/mcp/settingsLock.ts
new file mode 100644
index 0000000..51bab66
--- /dev/null
+++ b/apps/vscode/src/services/mcp/settingsLock.ts
@@ -0,0 +1,228 @@
+import { setTimeout as delay } from "node:timers/promises"
+import { randomUUID } from "node:crypto"
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	rmdirSync,
+	rmSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs"
+import * as path from "node:path"
+import { Logger } from "@/shared/services/Logger"
+
+const SETTINGS_LOCK_STALE_MS = 10_000
+const SETTINGS_LOCK_POLL_MS = 25
+
+export interface McpSettingsUpdateOptions {
+	abortSignal?: AbortSignal
+}
+
+export type McpSettingsMutator<T> = (settings: Record<string, unknown>) => T
+
+export class McpSettingsUpdateSkippedError extends Error {
+	constructor(message: string) {
+		super(message)
+		this.name = "McpSettingsUpdateSkippedError"
+	}
+}
+
+export class McpSettingsLockAbortedError extends Error {
+	constructor(message: string) {
+		super(message)
+		this.name = "McpSettingsLockAbortedError"
+	}
+}
+
+export class McpSettingsMutatorPurityError extends Error {
+	constructor(message: string) {
+		super(message)
+		this.name = "McpSettingsMutatorPurityError"
+	}
+}
+
+function settingsLockDir(settingsPath: string): string {
+	return `${settingsPath}.lock`
+}
+
+function makeLockToken(): string {
+	return `${process.pid}.${Date.now()}.${randomUUID()}`
+}
+
+interface AcquiredSettingsLock {
+	lockDir: string
+	ownerFile: string
+}
+
+function atomicWriteSettingsFile(settingsPath: string, contents: string): void {
+	const tempPath = `${settingsPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`
+	mkdirSync(path.dirname(settingsPath), { recursive: true })
+	try {
+		writeFileSync(tempPath, contents, { encoding: "utf-8", flag: "wx" })
+		renameSync(tempPath, settingsPath)
+	} catch (error) {
+		try {
+			unlinkSync(tempPath)
+		} catch {
+			// Best-effort cleanup of the temp file.
+		}
+		throw error
+	}
+}
+
+/**
+ * Cross-process lock implemented as a populated directory. Acquisition creates a
+ * staging directory, writes a unique owner marker inside it, then renames the
+ * populated directory into place. That means the visible lock directory is never
+ * empty. Release only deletes our marker and then rmdir's the directory; if
+ * another owner replaced the lock, our marker is absent or the directory is
+ * non-empty, so we do not remove their lock. Stale takeover renames the whole
+ * lock directory aside before deleting it. This uses standard mkdir/rename/rmdir
+ * operations and avoids inode- or handle-based deletion, so it works with
+ * Node's portable fs APIs on Windows and POSIX.
+ */
+function tryAcquireSettingsLock(lockDir: string, token: string): AcquiredSettingsLock | undefined {
+	mkdirSync(path.dirname(lockDir), { recursive: true })
+	const stagingDir = `${lockDir}.tmp.${token}`
+	rmSync(stagingDir, { recursive: true, force: true })
+	mkdirSync(stagingDir, { recursive: true })
+	const ownerFileName = `owner.${token}`
+	const stagingOwnerFile = path.join(stagingDir, ownerFileName)
+	writeFileSync(stagingOwnerFile, token, { encoding: "utf8", flag: "wx" })
+	try {
+		renameSync(stagingDir, lockDir)
+		return { lockDir, ownerFile: path.join(lockDir, ownerFileName) }
+	} catch (error) {
+		rmSync(stagingDir, { recursive: true, force: true })
+		if (existsSync(lockDir)) {
+			return undefined
+		}
+		throw error
+	}
+}
+
+function reclaimStaleLock(lockDir: string): void {
+	let ageMs: number
+	try {
+		ageMs = Date.now() - statSync(lockDir).mtimeMs
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return
+		}
+		throw error
+	}
+	if (ageMs < SETTINGS_LOCK_STALE_MS) {
+		return
+	}
+	Logger.warn(`[mcp-settings] Stale lock directory at ${lockDir} (age ${ageMs}ms); reclaiming.`)
+	const staleDir = `${lockDir}.stale.${makeLockToken()}`
+	try {
+		renameSync(lockDir, staleDir)
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return
+		}
+		throw error
+	}
+	rmSync(staleDir, { recursive: true, force: true })
+}
+
+function releaseSettingsLock(lock: AcquiredSettingsLock): void {
+	try {
+		unlinkSync(lock.ownerFile)
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			throw error
+		}
+	}
+	try {
+		rmdirSync(lock.lockDir)
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code
+		if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+			throw error
+		}
+	}
+}
+
+function checkAbort(signal: AbortSignal | undefined, lockDir: string): void {
+	if (signal?.aborted) {
+		throw new McpSettingsLockAbortedError(`Aborted waiting for MCP settings lock at ${lockDir}.`)
+	}
+}
+
+function readSettingsObject(settingsPath: string): Record<string, unknown> {
+	let settings: Record<string, unknown>
+	try {
+		settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as Record<string, unknown>
+	} catch (error) {
+		// A missing file bootstraps to an empty object so the first locked write
+		// creates it. A present-but-malformed file still throws.
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			throw error
+		}
+		settings = {}
+	}
+	if (!settings.mcpServers || typeof settings.mcpServers !== "object" || Array.isArray(settings.mcpServers)) {
+		settings.mcpServers = {}
+	}
+	return settings
+}
+
+function runPureSettingsMutator<T>(settings: Record<string, unknown>, mutator: McpSettingsMutator<T>): T {
+	const before = JSON.stringify(settings)
+	const shadow = JSON.parse(before) as Record<string, unknown>
+	const shadowResult = mutator(shadow)
+	const shadowAfter = JSON.stringify(shadow)
+	const result = mutator(settings)
+	const after = JSON.stringify(settings)
+	if (after !== shadowAfter) {
+		throw new McpSettingsMutatorPurityError(
+			"MCP settings mutator must be deterministic and free of side effects; repeated calls produced different settings.",
+		)
+	}
+	if (JSON.stringify(result) !== JSON.stringify(shadowResult)) {
+		throw new McpSettingsMutatorPurityError(
+			"MCP settings mutator must be deterministic and free of side effects; repeated calls produced different return values.",
+		)
+	}
+	return result
+}
+
+/**
+ * Locked MCP settings read-update-write. The mutator is synchronous and may be
+ * called more than once to validate purity/determinism. Do not perform slow work
+ * or side effects inside it; compute values before calling and close over them.
+ *
+ * Waiting for another process to release the lock is async, but once this
+ * process owns the lock, the critical section uses synchronous filesystem calls.
+ * @cline/core OAuth writes use a synchronous lock in the same extension host;
+ * yielding here while holding the lock would let that sync waiter block the
+ * event loop before this holder can resume and release it.
+ */
+export async function updateMcpSettingsFile<T>(
+	settingsPath: string,
+	mutator: McpSettingsMutator<T>,
+	options: McpSettingsUpdateOptions = {},
+): Promise<T> {
+	const lockDir = settingsLockDir(settingsPath)
+	const token = makeLockToken()
+	let lock: AcquiredSettingsLock | undefined
+	while (!(lock = tryAcquireSettingsLock(lockDir, token))) {
+		checkAbort(options.abortSignal, lockDir)
+		reclaimStaleLock(lockDir)
+		await delay(SETTINGS_LOCK_POLL_MS)
+	}
+	try {
+		checkAbort(options.abortSignal, lockDir)
+		const settings = readSettingsObject(settingsPath)
+		const result = runPureSettingsMutator(settings, mutator)
+		atomicWriteSettingsFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`)
+		return result
+	} finally {
+		releaseSettingsLock(lock)
+	}
+}
diff --git a/apps/vscode/src/services/mcp/types.ts b/apps/vscode/src/services/mcp/types.ts
new file mode 100644
index 0000000..5df8b9a
--- /dev/null
+++ b/apps/vscode/src/services/mcp/types.ts
@@ -0,0 +1,19 @@
+import { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import { McpServer } from "@shared/mcp"
+import { z } from "zod"
+import { ServerConfigSchema } from "./schemas"
+
+export type Transport = StdioClientTransport | SSEClientTransport | StreamableHTTPClientTransport
+
+export type McpConnection = {
+	server: McpServer
+	client: Client
+	transport: Transport
+	authProvider?: OAuthClientProvider
+}
+
+export type McpServerConfig = z.infer<typeof ServerConfigSchema>
diff --git a/apps/vscode/src/services/search/file-search.ts b/apps/vscode/src/services/search/file-search.ts
new file mode 100644
index 0000000..1f34174
--- /dev/null
+++ b/apps/vscode/src/services/search/file-search.ts
@@ -0,0 +1,481 @@
+import type { WorkspaceRoot } from "@shared/multi-root/types"
+import * as childProcess from "child_process"
+import * as fs from "fs"
+import type { FzfResultItem } from "fzf"
+import * as path from "path"
+import * as readline from "readline"
+import { WorkspaceRootManager } from "@/core/workspace"
+import { HostProvider } from "@/hosts/host-provider"
+import { GetOpenTabsRequest } from "@/shared/proto/host/window"
+import { SearchWorkspaceItemsRequest, SearchWorkspaceItemsRequest_SearchItemType } from "@/shared/proto/host/workspace"
+import { Logger } from "@/shared/services/Logger"
+import { getBinaryLocation } from "@/utils/fs"
+
+/**
+ * Indicates which backend served a workspace-files search.
+ *
+ * - `host_index`: served by the host's native file-name index (e.g. JetBrains FilenameIndex).
+ * - `ripgrep`:    served by the bundled ripgrep walker (default everywhere).
+ */
+export type FileSearchSource = "host_index" | "ripgrep"
+
+// Wrapper function for childProcess.spawn
+type SpawnFunction = typeof childProcess.spawn
+export const getSpawnFunction = (): SpawnFunction => childProcess.spawn
+
+/** Thrown when ripgrep fails to spawn or exits non-zero. */
+export class RipgrepError extends Error {
+	public readonly stderr: string
+
+	constructor(message: string, opts: { stderr?: string } = {}) {
+		super(message)
+		this.name = "RipgrepError"
+		this.stderr = opts.stderr ?? ""
+	}
+}
+
+export async function executeRipgrepForFiles(
+	workspacePath: string,
+	limit = 5000,
+): Promise<{ path: string; type: "file" | "folder"; label?: string }[]> {
+	const rgPath = await resolveRipgrepPath()
+
+	return new Promise((resolve, reject) => {
+		// Arguments for ripgrep to list files, follow symlinks, include hidden, and exclude common directories
+		const args = [
+			"--files",
+			"--follow",
+			"--hidden",
+			"-g",
+			"!**/{node_modules,.git,.github,out,dist,__pycache__,.venv,.env,venv,env,.cache,tmp,temp}/**",
+			workspacePath,
+		]
+
+		// Spawn the ripgrep process with the specified arguments
+		const rgProcess = getSpawnFunction()(rgPath, args)
+		const rl = readline.createInterface({ input: rgProcess.stdout })
+
+		// Array to store file results and Set to track unique directories
+		const fileResults: { path: string; type: "file" | "folder"; label?: string }[] = []
+		const dirSet = new Set<string>()
+		let count = 0
+		let exitCode: number | null = null
+
+		// Handle each line of output from ripgrep (each line is a file path)
+		rl.on("line", (line) => {
+			if (count >= limit) {
+				rl.close()
+				rgProcess.kill()
+				return
+			}
+
+			// Convert absolute path to a relative path from workspace root
+			const relativePath = path.relative(workspacePath, line)
+
+			// Add file result to array
+			fileResults.push({
+				path: relativePath,
+				type: "file",
+				label: path.basename(relativePath),
+			})
+
+			// Extract and add parent directories to the set
+			let dirPath = path.dirname(relativePath)
+			while (dirPath && dirPath !== "." && dirPath !== "/") {
+				dirSet.add(dirPath)
+				dirPath = path.dirname(dirPath)
+			}
+
+			count++
+		})
+
+		// Capture any error output from ripgrep
+		let errorOutput = ""
+		rgProcess.stderr.on("data", (data) => {
+			errorOutput += data.toString()
+		})
+
+		// On Windows the readline 'close' and the child-process 'exit' events
+		// fire in non-deterministic order; await both so we can read exitCode
+		// before deciding to resolve or reject.
+		let resolveOutputClosed!: () => void
+		const outputClosed = new Promise<void>((r) => {
+			resolveOutputClosed = r
+		})
+		let resolveExited!: () => void
+		const exited = new Promise<void>((r) => {
+			resolveExited = r
+		})
+
+		rgProcess.on("exit", (code) => {
+			exitCode = code
+			resolveExited()
+		})
+		rl.on("close", () => resolveOutputClosed())
+
+		Promise.all([outputClosed, exited]).then(() => {
+			// A non-zero exit with results is normal — we proactively SIGTERM
+			// after hitting the limit. Only reject when we have nothing to return.
+			if (fileResults.length === 0 && (errorOutput || (exitCode !== null && exitCode !== 0))) {
+				reject(
+					new RipgrepError(
+						errorOutput
+							? `ripgrep exited with code ${exitCode}: ${errorOutput.trim()}`
+							: `ripgrep exited with code ${exitCode}`,
+						{ stderr: errorOutput.trim() },
+					),
+				)
+				return
+			}
+
+			const dirResults = Array.from(dirSet, (dirPath): { path: string; type: "folder"; label?: string } => ({
+				path: dirPath,
+				type: "folder",
+				label: path.basename(dirPath),
+			}))
+			resolve([...fileResults, ...dirResults])
+		})
+
+		rgProcess.on("error", (error) => {
+			reject(new RipgrepError(`ripgrep failed to spawn: ${error.message}`))
+		})
+	})
+}
+
+async function resolveRipgrepPath(): Promise<string> {
+	try {
+		return await getBinaryLocation("rg")
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		const fallback = await findSystemRipgrep()
+		Logger.warn(`[file-search] bundled ripgrep unavailable, trying ${fallback}: ${message}`)
+		return fallback
+	}
+}
+
+async function findSystemRipgrep(): Promise<string> {
+	const fallback = process.platform === "win32" ? "rg.exe" : "rg"
+	const candidates = process.platform === "win32" ? [] : ["/usr/bin/rg", "/opt/homebrew/bin/rg", "/usr/local/bin/rg"]
+
+	for (const candidate of candidates) {
+		try {
+			await fs.promises.access(candidate, fs.constants.X_OK)
+			return candidate
+		} catch {
+			// Keep looking; the bare command is the final PATH-based fallback.
+		}
+	}
+
+	return fallback
+}
+
+// Get currently active/open files from VSCode tabs using hostbridge
+async function getActiveFiles(): Promise<Set<string>> {
+	try {
+		const request = GetOpenTabsRequest.create({})
+		const response = await HostProvider.window.getOpenTabs(request)
+		return new Set(response.paths)
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		Logger.warn(`[file-search] failed to read open tabs, continuing without active-file boost: ${message}`)
+		return new Set()
+	}
+}
+
+// Maximum number of candidates to ask the host for. The result is filtered &
+// ranked by fzf in core, so we want a comfortably wider net than `limit`.
+const HOST_INDEX_CANDIDATE_LIMIT = 5000
+
+// gRPC status code 12 — the standalone host returns this when the RPC isn't
+// registered (the in-process VS Code stub throws a plain Error, matched on
+// message instead). Treat both as silent steady-state, not failure.
+const GRPC_STATUS_UNIMPLEMENTED = 12
+
+/**
+ * Returns candidates from the host's native index, or `null` when the host
+ * doesn't implement the RPC / the index is unavailable. Returning `[]` is
+ * authoritative — caller does not fall back to ripgrep.
+ */
+async function executeHostIndexForFiles(
+	query: string,
+	workspacePath: string,
+	selectedType?: "file" | "folder",
+): Promise<{ path: string; type: "file" | "folder"; label?: string }[] | null> {
+	try {
+		const req = SearchWorkspaceItemsRequest.create({
+			query,
+			workspacePath,
+			limit: HOST_INDEX_CANDIDATE_LIMIT,
+			selectedType:
+				selectedType === "file"
+					? SearchWorkspaceItemsRequest_SearchItemType.FILE
+					: selectedType === "folder"
+						? SearchWorkspaceItemsRequest_SearchItemType.FOLDER
+						: undefined,
+		})
+		const resp = await HostProvider.workspace.searchWorkspaceItems(req)
+
+		// Pre-pass: collect host-provided folder paths so the parent-walk below
+		// doesn't re-add them as inferred parents and double-list them.
+		const folderPaths = new Set<string>()
+		for (const item of resp.items) {
+			if (item.type === SearchWorkspaceItemsRequest_SearchItemType.FOLDER) {
+				folderPaths.add(item.path)
+			}
+		}
+
+		const fileResults: { path: string; type: "file" | "folder"; label?: string }[] = []
+		const dirSet = new Set<string>()
+		for (const item of resp.items) {
+			const isFolder = item.type === SearchWorkspaceItemsRequest_SearchItemType.FOLDER
+			fileResults.push({
+				path: item.path,
+				type: isFolder ? "folder" : "file",
+				label: item.label || path.basename(item.path),
+			})
+			if (!isFolder) {
+				let dirPath = path.dirname(item.path)
+				while (dirPath && dirPath !== "." && dirPath !== "/") {
+					if (!folderPaths.has(dirPath)) {
+						dirSet.add(dirPath)
+					}
+					dirPath = path.dirname(dirPath)
+				}
+			}
+		}
+		const dirResults = Array.from(dirSet, (dirPath): { path: string; type: "folder"; label?: string } => ({
+			path: dirPath,
+			type: "folder",
+			label: path.basename(dirPath),
+		}))
+		return [...fileResults, ...dirResults]
+	} catch (err) {
+		// "Unimplemented" is the steady state on VS Code/CLI/ACP — every
+		// keystroke trips it — so log at debug to keep the noise floor flat.
+		// Anything else (UNAVAILABLE during indexing, INTERNAL, transport
+		// errors) is a real degradation we want visible to operators, since
+		// the caller is about to silently fall back to a much slower path.
+		const code = (err as { code?: unknown } | null)?.code
+		const msg = (err as { message?: string } | null)?.message ?? ""
+		const isUnimplemented = code === GRPC_STATUS_UNIMPLEMENTED || /not implemented/i.test(msg)
+		if (isUnimplemented) {
+			Logger.debug("[file-search] host index unimplemented, using ripgrep")
+		} else {
+			Logger.warn(`[file-search] host index call failed (code=${String(code)}), falling back to ripgrep: ${msg}`)
+		}
+		return null
+	}
+}
+
+export type SearchWorkspaceFilesResult = {
+	items: { path: string; type: "file" | "folder"; label?: string; workspaceName?: string }[]
+	source: FileSearchSource
+}
+
+export async function searchWorkspaceFiles(
+	query: string,
+	workspacePath: string,
+	limit = 20,
+	selectedType?: "file" | "folder",
+	workspaceName?: string,
+): Promise<SearchWorkspaceFilesResult> {
+	try {
+		// Get currently active files and convert to search format
+		const activeFilePaths = await getActiveFiles()
+		const activeFiles: { path: string; type: "file" | "folder"; label?: string }[] = []
+
+		for (const filePath of activeFilePaths) {
+			if (filePath.startsWith(workspacePath + path.sep) || filePath.startsWith(workspacePath + "/")) {
+				const relativePath = path.relative(workspacePath, filePath)
+				const normalizedPath = relativePath.replace(/\\/g, "/")
+				activeFiles.push({
+					path: normalizedPath,
+					type: "file",
+					label: path.basename(normalizedPath),
+				})
+			}
+		}
+
+		const hostItems = await executeHostIndexForFiles(query, workspacePath, selectedType)
+
+		const allItems = hostItems ?? (await executeRipgrepForFiles(workspacePath, 5000))
+		const source: FileSearchSource = hostItems ? "host_index" : "ripgrep"
+
+		// Combine active files with all items, removing duplicates (like the old WorkspaceTracker)
+		const combinedItems = [...activeFiles]
+		for (const item of allItems) {
+			if (!activeFiles.some((activeFile) => activeFile.path === item.path)) {
+				combinedItems.push(item)
+			}
+		}
+
+		// If no query, return the combined items
+		if (!query.trim()) {
+			const addWorkspaceName = (items: typeof combinedItems) =>
+				workspaceName ? items.map((item) => ({ ...item, workspaceName })) : items
+
+			let items: SearchWorkspaceFilesResult["items"]
+			if (selectedType === "file") {
+				items = addWorkspaceName(combinedItems.filter((item) => item.type === "file").slice(0, limit))
+			} else if (selectedType === "folder") {
+				items = addWorkspaceName(combinedItems.filter((item) => item.type === "folder").slice(0, limit))
+			} else {
+				items = addWorkspaceName(combinedItems.slice(0, limit))
+			}
+			return { items, source }
+		}
+
+		// Match Scoring - Prioritize the label (filename) by including it twice in the search string
+		// Use multiple tiebreakers in order of importance: Match score, then length of match (shorter=better)
+		// Get more (2x) results than needed for filtering, we pick the top half after sorting
+		const fzfModule = await import("fzf")
+		const fzf = new fzfModule.Fzf(combinedItems, {
+			selector: (item: { label?: string; path: string }) => `${item.label || ""} ${item.label || ""} ${item.path}`,
+			tiebreakers: [OrderbyMatchScore, fzfModule.byLengthAsc],
+			limit: limit * 2,
+		})
+
+		const filteredResults = fzf.find(query).slice(0, limit)
+
+		// Verify if the path exists and is actually a directory
+		const verifiedResultsPromises = filteredResults.map(
+			async ({ item }: { item: { path: string; type: "file" | "folder"; label?: string } }) => {
+				const fullPath = path.join(workspacePath, item.path)
+				let type = item.type
+
+				try {
+					const stats = await fs.promises.lstat(fullPath)
+					type = stats.isDirectory() ? "folder" : "file"
+				} catch {
+					// Keep original type if path doesn't exist
+				}
+
+				return workspaceName ? { ...item, type, workspaceName } : { ...item, type }
+			},
+		)
+
+		const items = await Promise.all(verifiedResultsPromises)
+		return { items, source }
+	} catch (error) {
+		// Re-throw so the controller can attach a structured error_reason.
+		Logger.error("Error in searchWorkspaceFiles:", error)
+		throw error
+	}
+}
+
+// Custom match scoring for results ordering
+// Candidate score tiebreaker - fewer gaps between matched characters scores higher
+export const OrderbyMatchScore = (a: FzfResultItem<any>, b: FzfResultItem<any>) => {
+	const countGaps = (positions: Iterable<number>) => {
+		let gaps = 0,
+			prev = Number.NEGATIVE_INFINITY
+		for (const pos of positions) {
+			if (prev !== Number.NEGATIVE_INFINITY && pos - prev > 1) {
+				gaps++
+			}
+			prev = pos
+		}
+		return gaps
+	}
+
+	return countGaps(a.positions) - countGaps(b.positions)
+}
+
+/**
+ * Search for files across multiple workspace roots or a specific workspace
+ * Similar to searchWorkspaceFiles but supports multiroot workspaces
+ */
+export async function searchWorkspaceFilesMultiroot(
+	query: string,
+	workspaceManager: WorkspaceRootManager,
+	limit = 20,
+	selectedType?: "file" | "folder",
+	workspaceHint?: string,
+): Promise<SearchWorkspaceFilesResult> {
+	try {
+		const workspaceRoots = workspaceManager?.getRoots?.() || []
+
+		if (workspaceRoots.length === 0) {
+			return { items: [], source: "ripgrep" }
+		}
+
+		let workspacesToSearch: WorkspaceRoot[] = []
+
+		// Search only the user-specified workspace (Ex input: @frontend:/query)
+		if (workspaceHint) {
+			const targetWorkspace = workspaceRoots.find((root: WorkspaceRoot) => root.name === workspaceHint)
+			if (targetWorkspace) {
+				workspacesToSearch = [targetWorkspace]
+			} else {
+				return { items: [], source: "ripgrep" }
+			}
+		} else {
+			// Search all workspaces if no hint provided
+			workspacesToSearch = workspaceRoots
+		}
+
+		// In a true multi-root search, swallow per-root errors so a single broken
+		// root doesn't kill the rest; we still re-throw below if *every* root
+		// failed. In single-root mode the throw propagates up unchanged.
+		let firstError: unknown
+		const searchPromises = workspacesToSearch.map(async (workspace): Promise<SearchWorkspaceFilesResult> => {
+			try {
+				return await searchWorkspaceFiles(query, workspace.path, limit, selectedType, workspace.name)
+			} catch (error) {
+				if (!firstError) {
+					firstError = error
+				}
+				Logger.error(`[searchWorkspaceFilesMultiroot] Error searching workspace ${workspace.name}:`, error)
+				return { items: [], source: "ripgrep" }
+			}
+		})
+
+		// Aggregate per-root results. The combined `source` is `host_index`
+		// only if every contributing root reported `host_index`; if any root
+		// fell back to ripgrep we report `ripgrep` so telemetry isn't misleading.
+		const allResults = await Promise.all(searchPromises)
+		let flatResults: SearchWorkspaceFilesResult["items"] = allResults.flatMap((r) => r.items)
+		const aggregateSource: FileSearchSource =
+			allResults.length > 0 && allResults.every((r) => r.source === "host_index") ? "host_index" : "ripgrep"
+		if (workspacesToSearch.length > 1) {
+			const pathCounts = new Map<string, number>()
+			for (const result of flatResults) {
+				pathCounts.set(result.path, (pathCounts.get(result.path) || 0) + 1)
+			}
+
+			flatResults = flatResults.map((result) => {
+				if (pathCounts.get(result.path)! > 1 && result.workspaceName) {
+					return {
+						...result,
+						label: `${result.workspaceName}:/${result.path}`,
+					}
+				}
+				return result
+			})
+		}
+
+		// Apply fuzzy matching across all results if needed
+		if (query.trim() && flatResults.length > limit) {
+			const fzfModule = await import("fzf")
+			const fzf = new fzfModule.Fzf(flatResults, {
+				selector: (item: { label?: string; path: string }) => `${item.label || ""} ${item.label || ""} ${item.path}`,
+				tiebreakers: [OrderbyMatchScore, fzfModule.byLengthAsc],
+			})
+			flatResults = fzf
+				.find(query)
+				.slice(0, limit)
+				.map((result) => result.item)
+		} else {
+			flatResults = flatResults.slice(0, limit)
+		}
+
+		if (firstError && flatResults.length === 0) {
+			throw firstError
+		}
+
+		return { items: flatResults, source: aggregateSource }
+	} catch (error) {
+		Logger.error("[searchWorkspaceFilesMultiroot] Error in multiroot search:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/TelemetryProviderFactory.ts b/apps/vscode/src/services/telemetry/TelemetryProviderFactory.ts
new file mode 100644
index 0000000..813672e
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/TelemetryProviderFactory.ts
@@ -0,0 +1,193 @@
+import { ClineEndpoint } from "@/config"
+import {
+	getValidOpenTelemetryConfig,
+	getValidRuntimeOpenTelemetryConfig,
+	OpenTelemetryClientValidConfig,
+} from "@/shared/services/config/otel-config"
+import { isPostHogConfigValid, posthogConfig } from "@/shared/services/config/posthog-config"
+import { Logger } from "@/shared/services/Logger"
+import type { ITelemetryProvider, TelemetryProperties, TelemetrySettings } from "./providers/ITelemetryProvider"
+import { OpenTelemetryClientProvider } from "./providers/opentelemetry/OpenTelemetryClientProvider"
+import { OpenTelemetryTelemetryProvider } from "./providers/opentelemetry/OpenTelemetryTelemetryProvider"
+import { PostHogClientProvider } from "./providers/posthog/PostHogClientProvider"
+import { PostHogTelemetryProvider } from "./providers/posthog/PostHogTelemetryProvider"
+
+/**
+ * Configuration for telemetry providers
+ */
+export type TelemetryProviderConfig =
+	| { type: "posthog"; apiKey?: string; host?: string }
+	/** OpenTelemetry collector
+	 * @param config - Config for this specific collector
+	 * @param bypassUserSettings - When true, telemetry is sent regardless of the user's Cline telemetry opt-in/opt-out settings.
+	 * This is used for:
+	 * 	- User-controlled collectors configured via environment variables (e.g., CLINE_OTEL_TELEMETRY_ENABLED).
+	 * 	- Organization-controlled collectors configured via remote config.
+	 */
+	| { type: "opentelemetry"; config: OpenTelemetryClientValidConfig; bypassUserSettings: boolean }
+	| { type: "no-op" }
+
+/**
+ * Factory class for creating telemetry providers
+ * Allows easy switching between different analytics providers
+ */
+export class TelemetryProviderFactory {
+	/**
+	 * Creates multiple telemetry providers based on configuration
+	 * Supports dual tracking during transition period
+	 */
+	public static async createProviders(): Promise<ITelemetryProvider[]> {
+		const configs = TelemetryProviderFactory.getDefaultConfigs()
+		const providers: ITelemetryProvider[] = []
+
+		for (const config of configs) {
+			try {
+				const provider = await TelemetryProviderFactory.createProvider(config)
+				providers.push(provider)
+			} catch (error) {
+				Logger.error(`Failed to create telemetry provider: ${config.type}`, error)
+			}
+		}
+
+		// Always have at least a no-op provider
+		if (providers.length === 0) {
+			providers.push(new NoOpTelemetryProvider())
+		}
+
+		Logger.info("TelemetryProviderFactory: Created providers - " + providers.map((p) => p.name).join(", "))
+		return providers
+	}
+
+	/**
+	 * Creates a single telemetry provider based on the provided configuration
+	 * @param config Configuration for the telemetry provider
+	 * @returns ITelemetryProvider instance
+	 */
+	private static async createProvider(config: TelemetryProviderConfig): Promise<ITelemetryProvider> {
+		switch (config.type) {
+			case "posthog": {
+				const sharedClient = PostHogClientProvider.getClient()
+				if (sharedClient) {
+					return await new PostHogTelemetryProvider(sharedClient).initialize()
+				}
+				return new NoOpTelemetryProvider()
+			}
+			case "opentelemetry": {
+				const otelConfig = config.config
+				if (!otelConfig) {
+					return new NoOpTelemetryProvider()
+				}
+				const client = new OpenTelemetryClientProvider(otelConfig)
+				if (client.meterProvider || client.loggerProvider) {
+					return await new OpenTelemetryTelemetryProvider(client.meterProvider, client.loggerProvider, {
+						bypassUserSettings: config.bypassUserSettings,
+					}).initialize()
+				}
+				Logger.info("TelemetryProviderFactory: OpenTelemetry providers not available")
+				return new NoOpTelemetryProvider()
+			}
+			case "no-op":
+				return new NoOpTelemetryProvider()
+			default:
+				Logger.error(`Unsupported telemetry provider type: ${(config as { type?: string }).type ?? "unknown"}`)
+				return new NoOpTelemetryProvider()
+		}
+	}
+
+	/**
+	 * Gets the default telemetry provider configuration
+	 * @returns Default configuration using available providers
+	 */
+	public static getDefaultConfigs(): TelemetryProviderConfig[] {
+		const configs: TelemetryProviderConfig[] = []
+
+		// Skip PostHog in selfHosted mode - enterprise customers should not send telemetry to PostHog
+		if (!ClineEndpoint.isSelfHosted() && isPostHogConfigValid(posthogConfig)) {
+			configs.push({ type: "posthog", ...posthogConfig })
+		}
+
+		// Skip build-time OTEL in selfHosted mode - enterprise customers should not send telemetry to Cline's collector
+		// Note: Runtime env OTEL and remote config OTEL are still allowed (user/org explicitly configured them)
+		const otelConfig = getValidOpenTelemetryConfig()
+		if (!ClineEndpoint.isSelfHosted() && otelConfig) {
+			configs.push({
+				type: "opentelemetry",
+				config: otelConfig,
+				bypassUserSettings: false,
+			})
+		}
+
+		const runtimeOtelConfig = getValidRuntimeOpenTelemetryConfig()
+		if (runtimeOtelConfig) {
+			configs.push({
+				type: "opentelemetry",
+				config: runtimeOtelConfig,
+				// If the user has `CLINE_OTEL_TELEMETRY_ENABLED` in his environment, enable
+				// OTEL regardless of his Cline telemetry settings
+				bypassUserSettings: true,
+			})
+		}
+
+		return configs.length > 0 ? configs : [{ type: "no-op" }]
+	}
+}
+
+/**
+ * No-operation telemetry provider for when telemetry is disabled
+ * or for testing purposes
+ */
+export class NoOpTelemetryProvider implements ITelemetryProvider {
+	readonly name = "NoOpTelemetryProvider"
+	private isOptIn = true
+
+	log(_event: string, _properties?: TelemetryProperties): void {
+		Logger.log(`[NoOpTelemetryProvider] ${_event}: ${JSON.stringify(_properties)}`)
+	}
+	logRequired(_event: string, _properties?: TelemetryProperties): void {
+		Logger.log(`[NoOpTelemetryProvider] REQUIRED ${_event}: ${JSON.stringify(_properties)}`)
+	}
+	identifyUser(_userInfo: any, _properties?: TelemetryProperties): void {
+		Logger.info(`[NoOpTelemetryProvider] identifyUser - ${JSON.stringify(_userInfo)} - ${JSON.stringify(_properties)}`)
+	}
+	isEnabled(): boolean {
+		return false
+	}
+	getSettings(): TelemetrySettings {
+		return {
+			hostEnabled: false,
+			level: "off",
+		}
+	}
+	recordCounter(
+		_name: string,
+		_value: number,
+		_attributes?: TelemetryProperties,
+		_description?: string,
+		_required = false,
+	): void {
+		// no-op
+	}
+	recordHistogram(
+		_name: string,
+		_value: number,
+		_attributes?: TelemetryProperties,
+		_description?: string,
+		_required = false,
+	): void {
+		// no-op
+	}
+	recordGauge(
+		_name: string,
+		_value: number | null,
+		_attributes?: TelemetryProperties,
+		_description?: string,
+		_required = false,
+	): void {
+		// no-op
+	}
+
+	async forceFlush() {}
+	async dispose(): Promise<void> {
+		Logger.info(`[NoOpTelemetryProvider] Disposing (optIn=${this.isOptIn})`)
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/TelemetryService.test.ts b/apps/vscode/src/services/telemetry/TelemetryService.test.ts
new file mode 100644
index 0000000..5a850f6
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/TelemetryService.test.ts
@@ -0,0 +1,654 @@
+/**
+ * Tests for the abstracted multi-provider telemetry system
+ * This demonstrates the multi-provider architecture that supports dual tracking,
+ * validates provider switching capabilities, and ensures NoOpTelemetryProvider functionality
+ * Tests for the abstracted multi-provider telemetry system
+ * This demonstrates the multi-provider architecture that supports dual tracking,
+ * validates provider switching capabilities, and ensures NoOpTelemetryProvider functionality
+ */
+
+import { after, before, describe, it } from "mocha"
+import * as assert from "assert"
+import * as sinon from "sinon"
+import { ClineEndpoint } from "@/config"
+import { HostProvider } from "@/hosts/host-provider"
+import * as otelConfigModule from "@/shared/services/config/otel-config"
+import * as posthogConfigModule from "@/shared/services/config/posthog-config"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+import { NoOpTelemetryProvider, TelemetryProviderFactory } from "./TelemetryProviderFactory"
+import { TelemetryMetadata, TelemetryService } from "./TelemetryService"
+
+describe("Telemetry system is abstracted and can easily switch between providers", () => {
+	// Setup and teardown for HostProvider mocking
+	before(() => {
+		setVscodeHostProviderMock()
+	})
+
+	after(() => {
+		// Reset HostProvider after tests
+		HostProvider.reset()
+	})
+	const MOCK_USER_INFO = {
+		id: "test-user-123",
+		displayName: "Test User",
+		email: "test@example.com",
+		createdAt: new Date().toISOString(),
+		organizations: [
+			{
+				active: true,
+				memberId: "member-456",
+				name: "Test Org",
+				organizationId: "org-123",
+				roles: ["admin"],
+			},
+		],
+	}
+	const MOCK_METADATA: TelemetryMetadata = {
+		extension_version: "1.2.3",
+		cline_type: "cline-unit-test",
+		platform: "Test-IDE",
+		platform_version: "9.8.7-abc",
+		os_type: "win32",
+		os_version: "Windows 10 Pro",
+		is_remote_workspace: false,
+		is_dev: "",
+	}
+
+	describe("Telemetry Service", () => {
+		it("should derive remote workspace metadata from host version", async () => {
+			const remoteProvider = new NoOpTelemetryProvider()
+			const localProvider = new NoOpTelemetryProvider()
+			const remoteLogSpy = sinon.spy(remoteProvider, "log")
+			const localLogSpy = sinon.spy(localProvider, "log")
+			const hostVersionStub = sinon.stub(HostProvider.env, "getHostVersion")
+			const createProvidersStub = sinon.stub(TelemetryProviderFactory, "createProviders")
+
+			hostVersionStub.onFirstCall().resolves({
+				platform: "VS Code",
+				version: "1.103.0",
+				clineType: "VSCode Extension",
+				remoteName: "ssh-remote",
+			})
+			hostVersionStub.onSecondCall().resolves({
+				platform: "VS Code",
+				version: "1.103.0",
+				clineType: "VSCode Extension",
+			})
+			createProvidersStub.onFirstCall().resolves([remoteProvider])
+			createProvidersStub.onSecondCall().resolves([localProvider])
+
+			const remoteService = await TelemetryService.create()
+			const localService = await TelemetryService.create()
+
+			remoteLogSpy.resetHistory()
+			localLogSpy.resetHistory()
+
+			remoteService.captureTaskCreated("task-remote", "openai")
+			localService.captureTaskCreated("task-local", "openai")
+
+			assert.ok(remoteLogSpy.calledOnce, "remote service should emit an event")
+			assert.ok(localLogSpy.calledOnce, "local service should emit an event")
+			assert.strictEqual(remoteLogSpy.firstCall.args[1]?.is_remote_workspace, true)
+			assert.strictEqual(localLogSpy.firstCall.args[1]?.is_remote_workspace, false)
+
+			hostVersionStub.restore()
+			createProvidersStub.restore()
+			remoteLogSpy.restore()
+			localLogSpy.restore()
+			await remoteService.dispose()
+			await localService.dispose()
+		})
+
+		it("should include remote workspace metadata on workspace.initialized events", async () => {
+			const noOpProvider = new NoOpTelemetryProvider()
+			const logSpy = sinon.spy(noOpProvider, "log")
+			const telemetryService = new TelemetryService([noOpProvider], {
+				...MOCK_METADATA,
+				is_remote_workspace: true,
+			})
+
+			logSpy.resetHistory()
+			telemetryService.captureWorkspaceInitialized(1, ["Git"], 123, false)
+
+			assert.ok(logSpy.calledOnce, "workspace.initialized should be emitted once")
+			const [eventName, properties] = logSpy.firstCall.args
+			assert.strictEqual(eventName, "workspace.initialized")
+			assert.ok(properties, "workspace.initialized properties should be defined")
+			assert.strictEqual(properties.is_remote_workspace, true)
+			assert.strictEqual(properties.root_count, 1)
+			assert.deepStrictEqual(properties.vcs_types, ["Git"])
+
+			logSpy.restore()
+			await noOpProvider.dispose()
+		})
+
+		it("should include correct metadata with telemetry events", async () => {
+			const noOpProvider = new NoOpTelemetryProvider()
+
+			// Spy on the provider's log method to verify metadata
+			const logSpy = sinon.spy(noOpProvider, "log")
+			const identifyUserSpy = sinon.spy(noOpProvider, "identifyUser")
+			const recordCounterSpy = sinon.spy(noOpProvider, "recordCounter")
+
+			const telemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			// Reset the spy to ignore the initial telemetry event from constructor
+			logSpy.resetHistory()
+
+			// Test that metadata is included in events
+			telemetryService.captureTaskCreated("task-456", "openai")
+
+			// Verify that log was called with correct arguments
+			assert.ok(logSpy.calledOnce, "Log should be called once")
+			const [eventName, properties] = logSpy.firstCall.args
+			assert.strictEqual(eventName, "task.created", "Event name should be task.created")
+			assert.deepStrictEqual(
+				properties,
+				{
+					ulid: "task-456",
+					apiProvider: "openai",
+					openAiCompatibleDomain: undefined,
+					...MOCK_METADATA,
+				},
+				"Task created event should include only the expected metadata properties",
+			)
+
+			// Test identify includes metadata
+			telemetryService.identifyAccount(MOCK_USER_INFO)
+
+			assert.ok(identifyUserSpy.calledOnce, "IdentifyUser should be called once")
+			const [userInfo, metadata] = identifyUserSpy.firstCall.args
+			assert.deepStrictEqual(userInfo, MOCK_USER_INFO, "User info should match")
+			assert.deepStrictEqual(metadata, MOCK_METADATA, "Identify user should include only the expected metadata properties")
+
+			// Test org attributes are included in standard attributes (metrics)
+			telemetryService.captureToolUsage("task-456", "write_to_file", "gpt-4", "openai", false, true)
+
+			assert.ok(recordCounterSpy.called, "recordCounter should be called for tool usage")
+			const recordCounterArgs = recordCounterSpy.firstCall.args
+			const recordCounterAttributes = recordCounterArgs[2] as Record<string, unknown>
+			assert.strictEqual(recordCounterAttributes.organization_id, "org-123")
+			assert.strictEqual(recordCounterAttributes.organization_name, "Test Org")
+			assert.strictEqual(recordCounterAttributes.member_id, "member-456")
+
+			// Test direct provider calls don't include metadata
+			noOpProvider.log("direct_event", { custom: "data" })
+			assert.ok(logSpy.calledWith("direct_event", { custom: "data" }), "Direct provider log should not add metadata")
+
+			// Restore spies
+			logSpy.restore()
+			identifyUserSpy.restore()
+			recordCounterSpy.restore()
+
+			await noOpProvider.dispose()
+		})
+
+		it("should support multi-provider telemetry for dual tracking", async () => {
+			// Create multiple providers for dual tracking scenario
+			const noOpProvider1 = new NoOpTelemetryProvider()
+			const noOpProvider2 = new NoOpTelemetryProvider()
+
+			// Spy on both providers to verify they both receive events
+			const logSpy1 = sinon.spy(noOpProvider1, "log")
+			const logSpy2 = sinon.spy(noOpProvider2, "log")
+			const identifyUserSpy1 = sinon.spy(noOpProvider1, "identifyUser")
+			const identifyUserSpy2 = sinon.spy(noOpProvider2, "identifyUser")
+
+			// Create TelemetryService with multiple providers
+			const telemetryService = new TelemetryService([noOpProvider1, noOpProvider2], MOCK_METADATA)
+
+			// Reset spies to ignore constructor events
+			logSpy1.resetHistory()
+			logSpy2.resetHistory()
+
+			// Test that events are sent to both providers
+			telemetryService.captureTaskCreated("multi-task-123", "anthropic")
+
+			// Verify both providers received the event
+			assert.ok(logSpy1.calledOnce, "First provider should receive the event")
+			assert.ok(logSpy2.calledOnce, "Second provider should receive the event")
+
+			// Verify event content is correct for both providers
+			const [eventName1, properties1] = logSpy1.firstCall.args
+			const [eventName2, properties2] = logSpy2.firstCall.args
+
+			assert.strictEqual(eventName1, "task.created", "First provider should receive correct event name")
+			assert.strictEqual(eventName2, "task.created", "Second provider should receive correct event name")
+
+			const expectedProperties = {
+				ulid: "multi-task-123",
+				apiProvider: "anthropic",
+				openAiCompatibleDomain: undefined,
+				...MOCK_METADATA,
+			}
+			assert.deepStrictEqual(properties1, expectedProperties, "First provider should receive correct properties")
+			assert.deepStrictEqual(properties2, expectedProperties, "Second provider should receive correct properties")
+
+			// Test user identification with multiple providers
+			telemetryService.identifyAccount(MOCK_USER_INFO)
+
+			assert.ok(identifyUserSpy1.calledOnce, "First provider should receive user identification")
+			assert.ok(identifyUserSpy2.calledOnce, "Second provider should receive user identification")
+
+			// Verify provider count
+			const providers = telemetryService.getProviders()
+			assert.strictEqual(providers.length, 2, "Should have exactly 2 providers")
+
+			// Cleanup
+			logSpy1.restore()
+			logSpy2.restore()
+			identifyUserSpy1.restore()
+			identifyUserSpy2.restore()
+			await noOpProvider1.dispose()
+			await noOpProvider2.dispose()
+		})
+	})
+	describe("PostHog Provider", () => {
+		it("should create PostHog provider and track events", async () => {
+			console.log("=== Testing PostHog Provider ===")
+			const providers = await TelemetryProviderFactory.createProviders()
+			const posthogProvider = providers.find((p) => !(p instanceof NoOpTelemetryProvider)) || providers[0]
+
+			const posthogTelemetryService = new TelemetryService([posthogProvider], MOCK_METADATA)
+
+			// Test various telemetry methods
+			posthogTelemetryService.captureTaskCreated("task-123", "anthropic")
+			posthogTelemetryService.identifyAccount(MOCK_USER_INFO)
+			posthogTelemetryService.captureTaskCompleted("task-123")
+			posthogTelemetryService.captureModelSelected("claude-3", "anthropic", "task-123")
+
+			// Test provider methods directly
+			posthogProvider.log("test_event", { test: "property" })
+			posthogProvider.identifyUser(MOCK_USER_INFO, { additional: "data" })
+
+			// Verify provider state
+			const isEnabled = posthogProvider.isEnabled()
+			const settings = posthogProvider.getSettings()
+
+			console.log("PostHog Provider enabled:", isEnabled)
+			console.log("PostHog Provider settings:", settings)
+
+			await posthogProvider.dispose()
+		})
+	})
+
+	describe("No-Op Provider", () => {
+		it("should create No-Op provider and handle all operations safely", async () => {
+			console.log("\n=== Testing No-Op Provider ===")
+			const noOpProvider = new NoOpTelemetryProvider()
+
+			const noOpTelemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			// Test various telemetry methods - should all be no-ops
+			noOpTelemetryService.captureTaskCreated("task-789", "google")
+			noOpTelemetryService.identifyAccount(MOCK_USER_INFO)
+			noOpTelemetryService.captureTaskCompleted("task-789")
+			noOpTelemetryService.captureModelSelected("gpt-4", "openai", "task-789")
+			noOpTelemetryService.captureToolUsage("task-789", "write_to_file", "gpt-4", "openai", false, true)
+
+			// Test provider methods directly
+			noOpProvider.log("test_event", { test: "property" })
+			noOpProvider.identifyUser(MOCK_USER_INFO, { additional: "data" })
+
+			// Verify provider state
+			const isEnabled = noOpProvider.isEnabled()
+			const settings = noOpProvider.getSettings()
+
+			// NoOp provider should always return false for isEnabled
+			assert.strictEqual(isEnabled, false, "NoOp provider should always be disabled")
+
+			// NoOp provider should return consistent settings
+			assert.deepStrictEqual(
+				settings,
+				{
+					hostEnabled: false,
+					level: "off",
+				},
+				"NoOp provider should return consistent settings",
+			)
+
+			console.log("No-Op Provider enabled:", isEnabled)
+			console.log("No-Op Provider settings:", settings)
+
+			await noOpProvider.dispose()
+		})
+
+		it("should handle unsupported provider types by returning No-Op provider", async () => {
+			console.log("\n=== Testing Unsupported Provider Type ===")
+			// Test unsupported type - No-Op provider is the fallback
+			const unsupportedProvider = new NoOpTelemetryProvider()
+
+			// Should return NoOp provider
+			assert.ok(
+				unsupportedProvider instanceof NoOpTelemetryProvider,
+				"Unsupported provider should be an instance of NoOpTelemetryProvider",
+			)
+			assert.strictEqual(unsupportedProvider.isEnabled(), false, "Unsupported provider should return NoOp provider")
+			assert.deepStrictEqual(
+				unsupportedProvider.getSettings(),
+				{
+					hostEnabled: false,
+					level: "off",
+				},
+				"Unsupported provider should return NoOp settings",
+			)
+
+			// Should handle all operations safely
+			const telemetryService = new TelemetryService([unsupportedProvider], MOCK_METADATA)
+			telemetryService.captureTaskCreated("task-456", "test")
+			telemetryService.identifyAccount(MOCK_USER_INFO)
+
+			await unsupportedProvider.dispose()
+		})
+	})
+
+	describe("Factory Configuration", () => {
+		it("should return default configurations", () => {
+			// Mock PostHog config validation to return true for this test
+			const isPostHogConfigValidStub = sinon.stub(posthogConfigModule, "isPostHogConfigValid").returns(true)
+			const isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(false)
+
+			const defaultConfigs = TelemetryProviderFactory.getDefaultConfigs()
+
+			// Should include at least PostHog
+			assert.ok(defaultConfigs.length > 0, "Should return at least one configuration")
+			assert.ok(
+				defaultConfigs.some((c) => c.type === "posthog"),
+				"Should include PostHog configuration",
+			)
+
+			// Restore the stubs
+			isPostHogConfigValidStub.restore()
+			isSelfHostedStub.restore()
+		})
+
+		it("should NOT include PostHog config when in selfHosted mode", () => {
+			// Stub ClineEndpoint.isSelfHosted() to return true (selfHosted mode)
+			const isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+			// Even if PostHog config is valid, it should be skipped
+			const isPostHogConfigValidStub = sinon.stub(posthogConfigModule, "isPostHogConfigValid").returns(true)
+
+			const configs = TelemetryProviderFactory.getDefaultConfigs()
+
+			// Should NOT include PostHog when in selfHosted mode
+			const hasPosthog = configs.some((c) => c.type === "posthog")
+			assert.strictEqual(hasPosthog, false, "Should NOT include PostHog configuration in selfHosted mode")
+
+			// Restore the stubs
+			isSelfHostedStub.restore()
+			isPostHogConfigValidStub.restore()
+		})
+
+		it("should include PostHog config when NOT in selfHosted mode and config is valid", () => {
+			// Stub ClineEndpoint.isSelfHosted() to return false (normal mode)
+			const isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(false)
+			const isPostHogConfigValidStub = sinon.stub(posthogConfigModule, "isPostHogConfigValid").returns(true)
+
+			const configs = TelemetryProviderFactory.getDefaultConfigs()
+
+			// Should include PostHog when NOT in selfHosted mode and config is valid
+			const hasPosthog = configs.some((c) => c.type === "posthog")
+			assert.strictEqual(hasPosthog, true, "Should include PostHog configuration when not in selfHosted mode")
+
+			// Restore the stubs
+			isSelfHostedStub.restore()
+			isPostHogConfigValidStub.restore()
+		})
+
+		it("should NOT include build-time OTEL config when in selfHosted mode", () => {
+			// Stub ClineEndpoint.isSelfHosted() to return true (selfHosted mode)
+			const isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+			// Even if build-time OTEL config is valid, it should be skipped
+			const getValidOtelConfigStub = sinon.stub(otelConfigModule, "getValidOpenTelemetryConfig").returns({
+				enabled: true,
+				metricsExporter: "otlp",
+			})
+			// Disable runtime OTEL to isolate test
+			const getRuntimeOtelConfigStub = sinon.stub(otelConfigModule, "getValidRuntimeOpenTelemetryConfig").returns(null)
+			// Disable PostHog to isolate test
+			const isPostHogConfigValidStub = sinon.stub(posthogConfigModule, "isPostHogConfigValid").returns(false)
+
+			const configs = TelemetryProviderFactory.getDefaultConfigs()
+
+			// Should NOT include build-time OTEL when in selfHosted mode
+			const hasOtel = configs.some((c) => c.type === "opentelemetry")
+			assert.strictEqual(hasOtel, false, "Should NOT include build-time OTEL configuration in selfHosted mode")
+
+			// Restore the stubs
+			isSelfHostedStub.restore()
+			getValidOtelConfigStub.restore()
+			getRuntimeOtelConfigStub.restore()
+			isPostHogConfigValidStub.restore()
+		})
+
+		it("should include build-time OTEL config when NOT in selfHosted mode", () => {
+			// Stub ClineEndpoint.isSelfHosted() to return false (normal mode)
+			const isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(false)
+			const getValidOtelConfigStub = sinon.stub(otelConfigModule, "getValidOpenTelemetryConfig").returns({
+				enabled: true,
+				metricsExporter: "otlp",
+			})
+			// Disable runtime OTEL to isolate test
+			const getRuntimeOtelConfigStub = sinon.stub(otelConfigModule, "getValidRuntimeOpenTelemetryConfig").returns(null)
+			// Disable PostHog to isolate test
+			const isPostHogConfigValidStub = sinon.stub(posthogConfigModule, "isPostHogConfigValid").returns(false)
+
+			const configs = TelemetryProviderFactory.getDefaultConfigs()
+
+			// Should include build-time OTEL when NOT in selfHosted mode
+			const hasOtel = configs.some((c) => c.type === "opentelemetry")
+			assert.strictEqual(hasOtel, true, "Should include build-time OTEL configuration when not in selfHosted mode")
+
+			// Restore the stubs
+			isSelfHostedStub.restore()
+			getValidOtelConfigStub.restore()
+			getRuntimeOtelConfigStub.restore()
+			isPostHogConfigValidStub.restore()
+		})
+
+		it("should STILL include runtime env OTEL config even in selfHosted mode", () => {
+			// Stub ClineEndpoint.isSelfHosted() to return true (selfHosted mode)
+			const isSelfHostedStub = sinon.stub(ClineEndpoint, "isSelfHosted").returns(true)
+			// Disable build-time OTEL
+			const getValidOtelConfigStub = sinon.stub(otelConfigModule, "getValidOpenTelemetryConfig").returns(null)
+			// Enable runtime OTEL (user explicitly configured it)
+			const getRuntimeOtelConfigStub = sinon.stub(otelConfigModule, "getValidRuntimeOpenTelemetryConfig").returns({
+				enabled: true,
+				metricsExporter: "otlp",
+				otlpEndpoint: "http://user-collector:4317",
+			})
+			// Disable PostHog to isolate test
+			const isPostHogConfigValidStub = sinon.stub(posthogConfigModule, "isPostHogConfigValid").returns(false)
+
+			const configs = TelemetryProviderFactory.getDefaultConfigs()
+
+			// Should STILL include runtime env OTEL even in selfHosted mode (user explicitly enabled it)
+			const hasOtel = configs.some((c) => c.type === "opentelemetry")
+			assert.strictEqual(hasOtel, true, "Should include runtime env OTEL configuration even in selfHosted mode")
+
+			// Verify it has bypassUserSettings: true
+			const otelConfig = configs.find((c) => c.type === "opentelemetry")
+			assert.strictEqual(
+				(otelConfig as any).bypassUserSettings,
+				true,
+				"Runtime env OTEL should have bypassUserSettings: true",
+			)
+
+			// Restore the stubs
+			isSelfHostedStub.restore()
+			getValidOtelConfigStub.restore()
+			getRuntimeOtelConfigStub.restore()
+			isPostHogConfigValidStub.restore()
+		})
+
+		it("should handle provider switching seamlessly", async () => {
+			console.log("\n=== Testing Provider Switching ===")
+
+			// Start with available providers
+			const providers = await TelemetryProviderFactory.createProviders()
+			let telemetryService = new TelemetryService(providers, MOCK_METADATA)
+
+			telemetryService.captureTaskCreated("task-switch-1", "anthropic")
+			console.log("Captured event with available providers")
+
+			await Promise.all(providers.map((p) => p.dispose()))
+
+			// Switch to No-Op provider
+			const noOpProvider = new NoOpTelemetryProvider()
+			telemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			telemetryService.captureTaskCreated("task-switch-2", "openai")
+			console.log("Captured event with No-Op provider")
+
+			// Verify different behaviors
+			// PostHog provider may be enabled depending on configuration
+			// NoOp provider should always be disabled
+			assert.strictEqual(noOpProvider.isEnabled(), false, "NoOp provider should always be disabled")
+
+			await noOpProvider.dispose()
+		})
+	})
+
+	describe("CLI Subagents Telemetry", () => {
+		it("should capture subagent toggle events correctly", async () => {
+			const noOpProvider = new NoOpTelemetryProvider()
+			const logSpy = sinon.spy(noOpProvider, "log")
+			const telemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			// Reset spy to ignore constructor events
+			logSpy.resetHistory()
+
+			// Test enabling subagents
+			telemetryService.captureSubagentToggle(true)
+
+			assert.ok(logSpy.calledOnce, "Log should be called once for enable")
+			const [eventName1, properties1] = logSpy.firstCall.args
+			assert.ok(properties1, "Properties should be defined")
+			assert.strictEqual(eventName1, "task.subagent_enabled", "Event should be subagent_enabled when enabled")
+			assert.strictEqual(properties1.enabled, true, "Properties should include enabled: true")
+			assert.ok(properties1.timestamp, "Properties should include timestamp")
+			assert.strictEqual(typeof properties1.timestamp, "string", "Timestamp should be a string")
+
+			// Reset spy for next test
+			logSpy.resetHistory()
+
+			// Test disabling subagents
+			telemetryService.captureSubagentToggle(false)
+
+			assert.ok(logSpy.calledOnce, "Log should be called once for disable")
+			const [eventName2, properties2] = logSpy.firstCall.args
+			assert.ok(properties2, "Properties should be defined")
+			assert.strictEqual(eventName2, "task.subagent_disabled", "Event should be subagent_disabled when disabled")
+			assert.strictEqual(properties2.enabled, false, "Properties should include enabled: false")
+			assert.ok(properties2.timestamp, "Properties should include timestamp")
+
+			logSpy.restore()
+			await noOpProvider.dispose()
+		})
+
+		it("should capture subagent execution events correctly", async () => {
+			const noOpProvider = new NoOpTelemetryProvider()
+			const logSpy = sinon.spy(noOpProvider, "log")
+			const telemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			// Reset spy to ignore constructor events
+			logSpy.resetHistory()
+
+			// Test successful subagent execution
+			telemetryService.captureSubagentExecution("task-123", 1500, 25, true)
+
+			assert.ok(logSpy.calledOnce, "Log should be called once for successful execution")
+			const [eventName1, properties1] = logSpy.firstCall.args
+			assert.ok(properties1, "Properties should be defined")
+			assert.strictEqual(eventName1, "task.subagent_completed", "Event should be subagent_completed when successful")
+			assert.strictEqual(properties1.ulid, "task-123", "Properties should include task ULID")
+			assert.strictEqual(properties1.durationMs, 1500, "Properties should include duration")
+			assert.strictEqual(properties1.outputLines, 25, "Properties should include output line count")
+			assert.strictEqual(properties1.success, true, "Properties should include success status")
+			assert.ok(properties1.timestamp, "Properties should include timestamp")
+
+			// Reset spy for next test
+			logSpy.resetHistory()
+
+			// Test failed subagent execution
+			telemetryService.captureSubagentExecution("task-456", 3200, 150, false)
+
+			assert.ok(logSpy.calledOnce, "Log should be called once for failed execution")
+			const [eventName2, properties2] = logSpy.firstCall.args
+			assert.ok(properties2, "Properties should be defined")
+			assert.strictEqual(eventName2, "task.subagent_started", "Event should be subagent_started when failed")
+			assert.strictEqual(properties2.ulid, "task-456", "Properties should include task ULID")
+			assert.strictEqual(properties2.durationMs, 3200, "Properties should include duration")
+			assert.strictEqual(properties2.outputLines, 150, "Properties should include output line count")
+			assert.strictEqual(properties2.success, false, "Properties should include success status")
+
+			logSpy.restore()
+			await noOpProvider.dispose()
+		})
+
+		it("should respect subagents telemetry category settings", async () => {
+			const noOpProvider = new NoOpTelemetryProvider()
+			const logSpy = sinon.spy(noOpProvider, "log")
+			const telemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			// Reset spy to ignore constructor events
+			logSpy.resetHistory()
+
+			// Verify subagents category is enabled by default
+			assert.strictEqual(
+				telemetryService.isCategoryEnabled("subagents"),
+				true,
+				"Subagents category should be enabled by default",
+			)
+
+			// Test that events are captured when category is enabled
+			telemetryService.captureSubagentToggle(true)
+			assert.ok(logSpy.calledOnce, "Event should be captured when category is enabled")
+
+			// Reset spy
+			logSpy.resetHistory()
+
+			// Test that events are captured for execution
+			telemetryService.captureSubagentExecution("task-789", 2000, 10, true)
+			assert.ok(logSpy.calledOnce, "Execution event should be captured when category is enabled")
+
+			logSpy.restore()
+			await noOpProvider.dispose()
+		})
+	})
+
+	describe("Skills Telemetry", () => {
+		it("should capture skill used events correctly", async () => {
+			const noOpProvider = new NoOpTelemetryProvider()
+			const logSpy = sinon.spy(noOpProvider, "log")
+			const telemetryService = new TelemetryService([noOpProvider], MOCK_METADATA)
+
+			logSpy.resetHistory()
+
+			telemetryService.captureSkillUsed({
+				ulid: "task-123",
+				skillName: "my-skill",
+				skillSource: "global",
+				skillsAvailableGlobal: 2,
+				skillsAvailableProject: 3,
+				provider: "cline",
+				modelId: "anthropic/claude-sonnet-4.5",
+			})
+
+			assert.ok(logSpy.calledOnce, "Log should be called once")
+			const [eventName, properties] = logSpy.firstCall.args
+			assert.strictEqual(eventName, "task.skill_used", "Event name should be task.skill_used")
+			assert.ok(properties, "Properties should be defined")
+			assert.strictEqual(properties.ulid, "task-123", "Properties should include task ULID")
+			assert.strictEqual(properties.skillName, "my-skill", "Properties should include skillName")
+			assert.strictEqual(properties.skillSource, "global", "Properties should include skillSource")
+			assert.strictEqual(properties.skillsAvailableGlobal, 2, "Properties should include global skill count")
+			assert.strictEqual(properties.skillsAvailableProject, 3, "Properties should include project skill count")
+			assert.strictEqual(properties.provider, "cline", "Properties should include provider")
+			assert.strictEqual(properties.modelId, "anthropic/claude-sonnet-4.5", "Properties should include modelId")
+
+			logSpy.restore()
+			await noOpProvider.dispose()
+		})
+	})
+})
diff --git a/apps/vscode/src/services/telemetry/TelemetryService.ts b/apps/vscode/src/services/telemetry/TelemetryService.ts
new file mode 100644
index 0000000..b1be609
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/TelemetryService.ts
@@ -0,0 +1,2613 @@
+import { HostProvider } from "@hosts/host-provider"
+import type { BrowserSettings } from "@shared/BrowserSettings"
+import { ApiFormat, apiFormatToJSON } from "@shared/proto/cline/models"
+import { ShowMessageType } from "@shared/proto/host/window"
+import type { TaskFeedbackType } from "@shared/WebviewMessage"
+import * as os from "os"
+import { ClineAccountUserInfo } from "@/services/auth/AuthService"
+import { Setting } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import { Mode } from "@/shared/storage/types"
+import { version as extensionVersion } from "../../../package.json"
+import { setDistinctId } from "../logging/distinctId"
+import type { ITelemetryProvider, TelemetryProperties } from "./providers/ITelemetryProvider"
+import { TelemetryProviderFactory } from "./TelemetryProviderFactory"
+
+/**
+ * Represents telemetry event categories that can be individually enabled or disabled
+ * When adding a new category, add it both here and to the initial values in telemetryCategoryEnabled
+ * Ensure `if (!this.isCategoryEnabled('<category_name>')` is added to the capture method
+ */
+type TelemetryCategory = "checkpoints" | "browser" | "focus_chain" | "subagents" | "skills" | "hooks"
+
+/**
+ * Terminal type for telemetry differentiation
+ */
+export type TerminalType = "vscode" | "standalone"
+
+/**
+ * VSCode-specific output capture methods
+ */
+export type VscodeOutputMethod = "shell_integration" | "clipboard" | "none"
+
+/**
+ * Standalone-specific output capture methods
+ */
+export type StandaloneOutputMethod = "child_process" | "child_process_error"
+
+/**
+ * Combined type for terminal output methods
+ */
+export type TerminalOutputMethod = VscodeOutputMethod | StandaloneOutputMethod
+
+/**
+ * Enum for terminal output failure reasons
+ */
+export enum TerminalOutputFailureReason {
+	TIMEOUT = "timeout",
+	NO_SHELL_INTEGRATION = "no_shell_integration",
+}
+
+/**
+ * Enum for terminal user intervention actions
+ */
+export enum TerminalUserInterventionAction {
+	PROCESS_WHILE_RUNNING = "process_while_running",
+	CANCELLED = "cancelled",
+}
+
+/**
+ * Enum for terminal hang stages
+ */
+export enum TerminalHangStage {
+	WAITING_FOR_COMPLETION = "waiting_for_completion",
+	BUFFER_STUCK = "buffer_stuck",
+}
+
+export type TelemetryMetadata = {
+	/**
+	 * The extension or cline-core version. JetBrains and CLI have different
+	 * versioning than the VSCode Extension, but on those platforms this will be the _cline-core version_
+	 * which uses the same as the versioning as the VSCode extension.
+	 */
+	extension_version: string
+	/**
+	 * The type of cline distribution, e.g VSCode Extension, JetBrains Plugin or CLI. This
+	 * is different than the `platform` because there are many variants of VSCode and JetBrains but they
+	 * all use the same extension or plugin.
+	 */
+	cline_type: string
+	/** The name of the host IDE or environment e.g. VSCode, Cursor, IntelliJ Professional Edition, etc. */
+	platform: string
+	/** The version of the host environment */
+	platform_version: string
+	/** The operating system type, e.g. darwin, win32. This is the value returned by os.platform() */
+	os_type: string
+	/** The operating system version e.g. 'Windows 10 Pro', 'Darwin Kernel Version 21.6.0...'
+	 * This is the value returned by os.version() */
+	os_version: string
+	/** Whether the current workspace is a VS Code remote workspace */
+	is_remote_workspace: boolean
+	/** Whether the extension is running in development mode */
+	is_dev: string | undefined
+}
+
+/**
+ * Token usage data shared across telemetry capture methods.
+ * Used by both `captureTokenUsage` and `captureConversationTurnEvent`.
+ */
+export interface TokenUsage {
+	tokensIn?: number
+	tokensOut?: number
+	cacheWriteTokens?: number
+	cacheReadTokens?: number
+	totalCost?: number
+}
+
+/**
+ * Maximum length for error messages to prevent excessive data
+ */
+const MAX_ERROR_MESSAGE_LENGTH = 500
+
+/**
+ * TelemetryService handles telemetry event tracking for the Cline extension
+ * Uses an abstracted telemetry provider to support multiple analytics backends
+ * Respects user privacy settings and VSCode's global telemetry configuration
+ */
+export class TelemetryService {
+	// Map to control specific telemetry categories (event types)
+	private telemetryCategoryEnabled: Map<TelemetryCategory, boolean> = new Map([
+		["checkpoints", true], // Checkpoints telemetry enabled
+		["browser", true], // Browser telemetry enabled
+		["focus_chain", true], // Focus Chain telemetry enabled
+		["subagents", true], // CLI Subagents telemetry enabled
+		["skills", true], // Skills telemetry enabled
+		["hooks", true], // Hooks telemetry enabled
+	])
+
+	private userId?: string
+	private activeOrg: {
+		organization_id: string
+		organization_name: string
+		member_id: string
+	} | null = null
+	private taskTurnCounts = new Map<string, number>()
+	private taskToolCallCounts = new Map<string, number>()
+	private taskErrorCounts = new Map<string, number>()
+	public static readonly METRICS = {
+		TASK: {
+			TURNS_TOTAL: "cline.turns.total",
+			TURNS_PER_TASK: "cline.turns.per_task",
+			TOKENS_INPUT_TOTAL: "cline.tokens.input.total",
+			TOKENS_INPUT_PER_RESPONSE: "cline.tokens.input.per_response",
+			TOKENS_OUTPUT_TOTAL: "cline.tokens.output.total",
+			TOKENS_OUTPUT_PER_RESPONSE: "cline.tokens.output.per_response",
+			COST_TOTAL: "cline.cost.total",
+			COST_PER_EVENT: "cline.cost.per_event",
+		},
+		CACHE: {
+			WRITE_TOTAL: "cline.cache.write.tokens.total",
+			WRITE_PER_EVENT: "cline.cache.write.tokens.per_event",
+			READ_TOTAL: "cline.cache.read.tokens.total",
+			READ_PER_EVENT: "cline.cache.read.tokens.per_event",
+			HITS_TOTAL: "cline.cache.hits.total",
+		},
+		TOOLS: {
+			CALLS_TOTAL: "cline.tool.calls.total",
+			CALLS_PER_TASK: "cline.tool.calls.per_task",
+		},
+		ERRORS: {
+			TOTAL: "cline.errors.total",
+			PER_TASK: "cline.errors.per_task",
+		},
+		API: {
+			TTFT_SECONDS: "cline.api.ttft.seconds",
+			DURATION_SECONDS: "cline.api.duration.seconds",
+			THROUGHPUT_TOKENS_PER_SECOND: "cline.api.throughput.tokens_per_second",
+		},
+		HOOKS: {
+			EXECUTIONS_TOTAL: "cline.hooks.executions.total",
+			DURATION_SECONDS: "cline.hooks.duration.seconds",
+			FAILURES_TOTAL: "cline.hooks.failures.total",
+			CANCELLATIONS_TOTAL: "cline.hooks.cancellations.total",
+			CONTEXT_MODIFICATIONS_TOTAL: "cline.hooks.context_modifications.total",
+			CACHE_ACCESSES_TOTAL: "cline.hooks.cache.accesses.total",
+		},
+		AI_OUTPUT: {
+			ACCEPTED_LINES_ADDED: "cline.ai_output.accepted.lines_added.total",
+			ACCEPTED_LINES_DELETED: "cline.ai_output.accepted.lines_deleted.total",
+			ACCEPTED_LINES_CHANGED: "cline.ai_output.accepted.lines_changed.total",
+			ACCEPTED_FILES_CREATED: "cline.ai_output.accepted.files_created.total",
+			ACCEPTED_FILES_DELETED: "cline.ai_output.accepted.files_deleted.total",
+			ACCEPTED_FILES_MOVED: "cline.ai_output.accepted.files_moved.total",
+			REJECTED_LINES_ADDED: "cline.ai_output.rejected.lines_added.total",
+			REJECTED_LINES_DELETED: "cline.ai_output.rejected.lines_deleted.total",
+			REJECTED_LINES_CHANGED: "cline.ai_output.rejected.lines_changed.total",
+			REJECTED_FILES_CREATED: "cline.ai_output.rejected.files_created.total",
+			REJECTED_FILES_DELETED: "cline.ai_output.rejected.files_deleted.total",
+			REJECTED_FILES_MOVED: "cline.ai_output.rejected.files_moved.total",
+		},
+		GRPC: {
+			RESPONSE_SIZE_BYTES: "cline.grpc.response.size_bytes",
+		},
+		MIGRATION: {
+			// Fires whenever Cline checks an old pre-SDK task and decides whether/how to migrate it.
+			LEGACY_TASK_ATTEMPTS_TOTAL: "cline.migration.legacy_task.attempts.total",
+			// Fires when the user opens an old task and Cline successfully copies it into SDK session storage.
+			LEGACY_TASK_SUCCESS_TOTAL: "cline.migration.legacy_task.success.total",
+			// Fires when Cline tried to migrate an old task but failed while building or writing the SDK session.
+			LEGACY_TASK_FAILURES_TOTAL: "cline.migration.legacy_task.failures.total",
+			// Fires when no migration happens because it is unnecessary or impossible, e.g. already migrated or missing old messages.
+			LEGACY_TASK_SKIPPED_TOTAL: "cline.migration.legacy_task.skipped.total",
+			// Fires for every migration decision; measures how long the check/migration took.
+			LEGACY_TASK_DURATION_SECONDS: "cline.migration.legacy_task.duration.seconds",
+			// Fires when Cline finds old conversation messages; records how many old messages were found.
+			LEGACY_TASK_LEGACY_MESSAGES_COUNT: "cline.migration.legacy_task.legacy_messages.count",
+			// Fires after conversion; records how many messages made it into SDK-compatible form.
+			LEGACY_TASK_CONVERTED_MESSAGES_COUNT: "cline.migration.legacy_task.converted_messages.count",
+			// Fires when history is listed; counts old pre-SDK tasks still waiting to be migrated.
+			LEGACY_TASK_PENDING_COUNT: "cline.migration.legacy_task.pending.count",
+			// Fires when history is listed; counts old tasks that already made it safely into SDK session storage.
+			LEGACY_TASK_MIGRATED_COUNT: "cline.migration.legacy_task.migrated.count",
+		},
+	}
+	// Event constants for tracking user interactions and system events
+	private static readonly EVENTS = {
+		// Task-related events for tracking conversation and execution flow
+
+		USER: {
+			OPT_OUT: "user.opt_out",
+			OPT_IN: "user.opt_in",
+			TELEMETRY_ENABLED: "user.telemetry_enabled",
+			EXTENSION_ACTIVATED: "user.extension_activated",
+			EXTENSION_STORAGE_ERROR: "user.extension_storage_error",
+			AUTH_STARTED: "user.auth_started",
+			AUTH_SUCCEEDED: "user.auth_succeeded",
+			AUTH_FAILED: "user.auth_failed",
+			AUTH_LOGGED_OUT: "user.auth_logged_out",
+			ONBOARDING_PROGRESS: "user.onboarding_progress",
+		},
+		// Workspace-related events for multi-root support
+		WORKSPACE: {
+			// Track workspace initialization
+			INITIALIZED: "workspace.initialized",
+			// Track initialization errors
+			INIT_ERROR: "workspace.init_error",
+			// Track VCS detection
+			VCS_DETECTED: "workspace.vcs_detected",
+			// Track multi-root checkpoint operations
+			MULTI_ROOT_CHECKPOINT: "workspace.multi_root_checkpoint",
+			// Track workspace resolution
+			PATH_RESOLVED: "workspace.path_resolved",
+		},
+		TASK: {
+			// Tracks when a new task/conversation is started
+			CREATED: "task.created",
+			// Tracks when a task is reopened
+			RESTARTED: "task.restarted",
+			// Tracks when a task is finished, with acceptance or rejection status
+			COMPLETED: "task.completed",
+			// Tracks user feedback on completed tasks
+			FEEDBACK: "task.feedback",
+			// Tracks when a message is sent in a conversation
+			CONVERSATION_TURN: "task.conversation_turn",
+			// Tracks token consumption for cost and usage analysis
+			TOKEN_USAGE: "task.tokens",
+			// Tracks switches between plan and act modes
+			MODE_SWITCH: "task.mode",
+			// Tracks when users select an option from AI-generated followup questions
+			OPTION_SELECTED: "task.option_selected",
+			// Tracks when users type a custom response instead of selecting an option from AI-generated followup questions
+			OPTIONS_IGNORED: "task.options_ignored",
+			// Tracks checkpoint lifecycle actions.
+			CHECKPOINT_USED: "task.checkpoint_used",
+			// Tracks when tools (like file operations, commands) are used
+			TOOL_USED: "task.tool_used",
+			// Tracks when MCP tools are used
+			MCP_TOOL_CALLED: "task.mcp_tool_called",
+			// Tracks when a historical task is loaded from storage
+			HISTORICAL_LOADED: "task.historical_loaded",
+			// Tracks legacy VS Code task history migration into SDK sessions
+			LEGACY_TASK_MIGRATION: "task.legacy_task_migration",
+			// Tracks when the retry button is clicked for failed operations
+			RETRY_CLICKED: "task.retry_clicked",
+			// Tracks when a diff edit (replace_in_file) operation fails
+			DIFF_EDIT_FAILED: "task.diff_edit_failed",
+			// Tracks when the browser tool is started
+			BROWSER_TOOL_START: "task.browser_tool_start",
+			// Tracks when the browser tool is completed
+			BROWSER_TOOL_END: "task.browser_tool_end",
+			// Tracks when browser errors occur
+			BROWSER_ERROR: "task.browser_error",
+			// Tracks Gemini API specific performance metrics
+			GEMINI_API_PERFORMANCE: "task.gemini_api_performance",
+			// Tracks when API providers return errors
+			PROVIDER_API_ERROR: "task.provider_api_error",
+			// Tracks when users enable the focus chain feature
+			FOCUS_CHAIN_ENABLED: "task.focus_chain_enabled",
+			// Tracks when users disable the focus chain feature
+			FOCUS_CHAIN_DISABLED: "task.focus_chain_disabled",
+			// Tracks when the first focus chain return is returned by the model
+			FOCUS_CHAIN_PROGRESS_FIRST: "task.focus_chain_progress_first",
+			// Tracks when subsequent focus chain list returns are returned
+			FOCUS_CHAIN_PROGRESS_UPDATE: "task.focus_chain_progress_update",
+			// Tracks the statusn of the focus chain list when the task reaches a task completion state
+			FOCUS_CHAIN_INCOMPLETE_ON_COMPLETION: "task.focus_chain_incomplete_on_completion",
+			// Tracks when users click to open the focus chain markdfown file
+			FOCUS_CHAIN_LIST_OPENED: "task.focus_chain_list_opened",
+			// Tracks when users save and write to the focus chain markdown file
+			FOCUS_CHAIN_LIST_WRITTEN: "task.focus_chain_list_written",
+			// Tracks when the context window is auto-condensed with the summarize_task tool call
+			AUTO_COMPACT: "task.summarize_task",
+			// Tracks when slash commands or workflows are activated
+			SLASH_COMMAND_USED: "task.slash_command_used",
+			// Tracks when a feature is toggled on/off
+			FEATURE_TOGGLED: "task.feature_toggled",
+			// Tracks when individual Cline rules are toggled on/off
+			RULE_TOGGLED: "task.rule_toggled",
+			// Tracks when auto condense setting is toggled on/off
+			AUTO_CONDENSE_TOGGLED: "task.auto_condense_toggled",
+			// Tracks when yolo mode setting is toggled on/off
+			YOLO_MODE_TOGGLED: "task.yolo_mode_toggled",
+			// Tracks task initialization timing
+			INITIALIZATION: "task.initialization",
+			// Terminal execution telemetry events
+			TERMINAL_EXECUTION: "task.terminal_execution",
+			TERMINAL_OUTPUT_FAILURE: "task.terminal_output_failure",
+			TERMINAL_USER_INTERVENTION: "task.terminal_user_intervention",
+			TERMINAL_HANG: "task.terminal_hang",
+			// Mention telemetry events
+			MENTION_USED: "task.mention_used",
+			MENTION_FAILED: "task.mention_failed",
+			MENTION_SEARCH_RESULTS: "task.mention_search_results",
+			// Multi-workspace search pattern tracking
+			WORKSPACE_SEARCH_PATTERN: "task.workspace_search_pattern",
+			// CLI Subagents telemetry events
+			SUBAGENT_ENABLED: "task.subagent_enabled",
+			SUBAGENT_DISABLED: "task.subagent_disabled",
+			SUBAGENT_STARTED: "task.subagent_started",
+			SUBAGENT_COMPLETED: "task.subagent_completed",
+			// Skills telemetry events
+			SKILL_USED: "task.skill_used",
+		},
+		// UI interaction events for tracking user engagement
+		UI: {
+			// Tracks when a different model is selected
+			MODEL_SELECTED: "ui.model_selected",
+			// Tracks when users use the "favorite" button in the model picker
+			MODEL_FAVORITE_TOGGLED: "ui.model_favorite_toggled",
+			// Tracks when a button is clicked
+			BUTTON_CLICKED: "ui.button_clicked",
+			// Tracks when the Cline panel becomes visible
+			PANEL_OPENED: "ui.panel_opened",
+			// Tracks when the user explicitly starts a new task flow
+			NEW_TASK_CLICKED: "ui.new_task_clicked",
+			// Tracks when the user submits chat composer content
+			PROMPT_SUBMITTED: "ui.prompt_submitted",
+			// Tracks when the rules menu button is clicked
+			RULES_MENU_OPENED: "ui.rules_menu_opened",
+		},
+		// Hooks-related events for tracking hook execution
+		HOOKS: {
+			// Tracks when hooks feature is enabled
+			ENABLED: "hooks.enabled",
+			// Tracks when hooks feature is disabled
+			DISABLED: "hooks.disabled",
+			// Tracks when a hook requests task cancellation
+			CANCEL_REQUESTED: "hooks.cancel_requested",
+			// Tracks when a hook modifies context
+			CONTEXT_MODIFIED: "hooks.context_modified",
+			// Tracks when hook discovery completes
+			DISCOVERY_COMPLETED: "hooks.discovery_completed",
+		},
+		// Worktree-related events for tracking worktree feature usage
+		WORKTREE: {
+			// Tracks when user opens worktrees view from home page
+			VIEW_OPENED: "worktree.view_opened",
+			// Tracks when a worktree is created
+			CREATED: "worktree.created",
+			// Tracks when a worktree merge is attempted
+			MERGE_ATTEMPTED: "worktree.merge_attempted",
+		},
+		HOST: {
+			// Tracks events detected from the host environment
+			DETECTED: "host.detected",
+		},
+	}
+
+	public static async create(): Promise<TelemetryService> {
+		const providers = await TelemetryProviderFactory.createProviders()
+		const hostVersion = await HostProvider.env.getHostVersion({})
+		const metadata: TelemetryMetadata = {
+			extension_version: extensionVersion,
+			platform: hostVersion.platform || "unknown",
+			platform_version: hostVersion.version || "unknown",
+			cline_type: hostVersion.clineType || "unknown",
+			os_type: os.platform(),
+			os_version: os.version(),
+			// `remoteName` is normalized by the host bridge to `undefined` for local workspaces.
+			is_remote_workspace: !!hostVersion.remoteName,
+			is_dev: process.env.IS_DEV,
+		}
+		return new TelemetryService(providers, metadata)
+	}
+
+	/**
+	 * Constructor that accepts multiple telemetry providers for dual tracking
+	 * @param providers Array of telemetry providers for dual/multi tracking
+	 */
+	constructor(
+		private providers: ITelemetryProvider[],
+		private telemetryMetadata: TelemetryMetadata,
+	) {
+		this.capture({ event: TelemetryService.EVENTS.USER.TELEMETRY_ENABLED })
+		Logger.info(`[TelemetryService] Initialized with ${providers.length} telemetry provider(s)`)
+	}
+
+	public addProvider(provider: ITelemetryProvider) {
+		this.providers.push(provider)
+	}
+
+	public removeProvider(name: string) {
+		this.providers = this.providers.filter((p) => p.name !== name)
+	}
+
+	/**
+	 * Updates the telemetry state based on user preferences and VSCode settings
+	 * Only enables telemetry if both VSCode global telemetry is enabled and user has opted in
+	 * @param didUserOptIn Whether the user has explicitly opted into telemetry
+	 */
+	public async updateTelemetryState(didUserOptIn: boolean): Promise<void> {
+		// First check global telemetry level - telemetry should only be enabled when level is "all"
+
+		// We only enable telemetry if global host telemetry is enabled
+		const hostSetting = await HostProvider.env.getTelemetrySettings({})
+		if (hostSetting.isEnabled === Setting.DISABLED) {
+			// Only show warning if user has opted in to Cline telemetry but host telemetry is disabled
+			if (didUserOptIn) {
+				void HostProvider.window
+					.showMessage({
+						type: ShowMessageType.WARNING,
+						message:
+							"Anonymous Cline error and usage reporting is enabled, but IDE telemetry is disabled. To enable error and usage reporting for this extension, enable telemetry in IDE settings.",
+						options: {
+							items: ["Open Settings"],
+						},
+					})
+					.then((response: { selectedOption?: string }) => {
+						if (response.selectedOption === "Open Settings") {
+							void HostProvider.window.openSettings({
+								query: "telemetry.telemetryLevel",
+							})
+						}
+					})
+			}
+		}
+	}
+
+	/**
+	 * Captures when a user explicitly opts out of telemetry.
+	 * Uses captureRequired to ensure the event is sent before telemetry is disabled.
+	 * Should only be called on explicit user action, not on init/sync.
+	 */
+	public captureUserOptOut(): void {
+		this.captureRequired(TelemetryService.EVENTS.USER.OPT_OUT, {})
+	}
+
+	/**
+	 * Captures when a user explicitly opts back into telemetry.
+	 * Should only be called on explicit user action, not on init/sync.
+	 */
+	public captureUserOptIn(): void {
+		this.capture({ event: TelemetryService.EVENTS.USER.OPT_IN })
+	}
+
+	/**
+	 * Captures a telemetry event if telemetry is enabled
+	 * @param event The event to capture with its properties
+	 */
+	public capture(event: { event: string; properties?: TelemetryProperties }): void {
+		const propertiesWithMetadata: TelemetryProperties = {
+			...(event.properties || {}),
+			...this.telemetryMetadata,
+		}
+		this.captureToProviders(event.event, propertiesWithMetadata, false)
+	}
+
+	/**
+	 * Captures a required telemetry event that bypasses user opt-out settings
+	 * @param event The event name to capture
+	 * @param properties Optional properties to attach to the event
+	 */
+	public captureRequired(event: string, properties?: TelemetryProperties): void {
+		const propertiesWithMetadata: TelemetryProperties = {
+			...(properties || {}),
+			...this.telemetryMetadata,
+		}
+		this.captureToProviders(event, propertiesWithMetadata, true)
+	}
+
+	/**
+	 * Internal method to capture events to all providers with error isolation
+	 * @param event The event name
+	 * @param properties Event properties (must be JSON-serializable)
+	 * @param required Whether this is a required event
+	 */
+	private captureToProviders(event: string, properties: TelemetryProperties, required: boolean): void {
+		this.providers.forEach((provider) => {
+			try {
+				if (required) {
+					provider.logRequired(event, properties)
+				} else {
+					provider.log(event, properties)
+				}
+			} catch (error) {
+				Logger.error(`[TelemetryService] Provider failed for event ${event}:`, error)
+			}
+		})
+	}
+
+	private getStandardAttributes(extra?: TelemetryProperties): TelemetryProperties {
+		return {
+			...this.telemetryMetadata,
+			...(this.userId ? { userId: this.userId } : {}),
+			...this.activeOrg,
+			...(extra ?? {}),
+		}
+	}
+
+	private recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		const attrs = this.getStandardAttributes(attributes)
+		this.providers.forEach((provider) => {
+			try {
+				provider.recordCounter(name, value, attrs, description, required)
+			} catch (error) {
+				Logger.error(`[TelemetryService] recordCounter failed: ${name}`, error)
+			}
+		})
+	}
+
+	private recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		const attrs = this.getStandardAttributes(attributes)
+		this.providers.forEach((provider) => {
+			try {
+				provider.recordHistogram(name, value, attrs, description, required)
+			} catch (error) {
+				Logger.error(`[TelemetryService] recordHistogram failed: ${name}`, error)
+			}
+		})
+	}
+
+	/**
+	 * Gauge values require explicit cleanup: callers must pass null with the same attribute set
+	 * when the series identified by name+attributes ends to prevent stale metric entries.
+	 */
+	private recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		const attrs = this.getStandardAttributes(attributes)
+		this.providers.forEach((provider) => {
+			try {
+				provider.recordGauge(name, value, attrs, description, required)
+			} catch (error) {
+				Logger.error(`[TelemetryService] recordGauge failed: ${name}`, error)
+			}
+		})
+	}
+
+	private incrementTaskCounter(store: Map<string, number>, ulid: string): number {
+		const nextValue = (store.get(ulid) ?? 0) + 1
+		store.set(ulid, nextValue)
+		return nextValue
+	}
+
+	private resetTaskAggregates(ulid: string): void {
+		this.taskTurnCounts.delete(ulid)
+		this.taskToolCallCounts.delete(ulid)
+		this.taskErrorCounts.delete(ulid)
+	}
+
+	public captureExtensionActivated() {
+		this.capture({
+			event: TelemetryService.EVENTS.USER.EXTENSION_ACTIVATED,
+		})
+	}
+
+	public captureExtensionStorageError(errorMessage: string, eventName: string) {
+		// Truncate error message to prevent excessive data
+		this.capture({
+			event: TelemetryService.EVENTS.USER.EXTENSION_STORAGE_ERROR,
+			properties: {
+				error:
+					errorMessage.length > MAX_ERROR_MESSAGE_LENGTH
+						? errorMessage.substring(0, MAX_ERROR_MESSAGE_LENGTH) + "..."
+						: errorMessage,
+				eventName,
+			},
+		})
+	}
+
+	/**
+	 * Records when authentication flow is started
+	 * @param provider The authentication provider being used
+	 */
+	public captureAuthStarted(provider?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.USER.AUTH_STARTED,
+			properties: {
+				provider,
+			},
+		})
+	}
+
+	/**
+	 * Records when authentication flow succeeds
+	 * @param provider The authentication provider that was used
+	 */
+	public captureAuthSucceeded(provider?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.USER.AUTH_SUCCEEDED,
+			properties: {
+				provider,
+			},
+		})
+	}
+
+	/**
+	 * Records when authentication flow fails
+	 * @param provider The authentication provider that was used
+	 */
+	public captureAuthFailed(provider?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.USER.AUTH_FAILED,
+			properties: {
+				provider,
+			},
+		})
+	}
+
+	/**
+	 * Records when user logs out of their account
+	 * @param provider The authentication provider that was used
+	 * @param reason The reason for logout (user action, cross-window sync, error, etc.)
+	 */
+	public captureAuthLoggedOut(provider?: string, reason?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.USER.AUTH_LOGGED_OUT,
+			properties: {
+				provider,
+				reason,
+			},
+		})
+	}
+
+	/**
+	 * Identifies the accounts user
+	 * @param userInfo The user's information
+	 */
+	public identifyAccount(userInfo: ClineAccountUserInfo) {
+		const propertiesWithMetadata: TelemetryProperties = {
+			...this.telemetryMetadata,
+		}
+
+		this.userId = userInfo.id
+		const activeOrg = userInfo.organizations?.find((org) => org.active)
+		if (activeOrg) {
+			this.activeOrg = {
+				organization_id: activeOrg.organizationId,
+				organization_name: activeOrg.name,
+				member_id: activeOrg.memberId,
+			}
+		} else {
+			this.activeOrg = null
+		}
+		// Update all providers with error isolation
+		this.providers.forEach((provider) => {
+			try {
+				provider.identifyUser(userInfo, propertiesWithMetadata)
+			} catch (error) {
+				Logger.error(`[TelemetryService] Provider failed for user identification:`, error)
+			}
+		})
+
+		if (userInfo.id) {
+			setDistinctId(userInfo.id)
+		}
+	}
+
+	// Task events
+	/**
+	 * Records when a new task/conversation is started
+	 * @param ulid Unique identifier for the new task
+	 * @param apiProvider Optional API provider
+	 * @param openAiCompatibleDomain Optional domain for OpenAI Compatible providers (e.g., "api.example.com")
+	 */
+	public captureTaskCreated(ulid: string, apiProvider?: string, openAiCompatibleDomain?: string) {
+		this.resetTaskAggregates(ulid)
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.CREATED,
+			properties: { ulid, apiProvider, openAiCompatibleDomain },
+		})
+	}
+
+	/**
+	 * Records when a task/conversation is restarted
+	 * @param ulid Unique identifier for the new task
+	 * @param apiProvider Optional API provider
+	 * @param openAiCompatibleDomain Optional domain for OpenAI Compatible providers (e.g., "api.example.com")
+	 */
+	public captureTaskRestarted(ulid: string, apiProvider?: string, openAiCompatibleDomain?: string) {
+		this.resetTaskAggregates(ulid)
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.RESTARTED,
+			properties: { ulid, apiProvider, openAiCompatibleDomain },
+		})
+	}
+
+	/**
+	 * Records when cline calls the task completion_result tool signifying that cline is done with the task
+	 * @param ulid Unique identifier for the task
+	 */
+	public captureTaskCompleted(
+		ulid: string,
+		args?: {
+			provider?: string
+			modelId?: string
+			apiFormat?: ApiFormat
+			timeToFirstTokenMs?: number
+			durationMs?: number
+			mode: Mode
+		},
+	) {
+		const apiFormatName = args?.apiFormat !== undefined ? apiFormatToJSON(args.apiFormat) : undefined
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.COMPLETED,
+			properties: {
+				ulid,
+				provider: args?.provider,
+				modelId: args?.modelId,
+				apiFormat: args?.apiFormat,
+				apiFormatName,
+				timeToFirstTokenMs: args?.timeToFirstTokenMs,
+				durationMs: args?.durationMs,
+				mode: args?.mode,
+			},
+		})
+
+		if (Number.isFinite(args?.timeToFirstTokenMs)) {
+			this.recordHistogram(TelemetryService.METRICS.API.TTFT_SECONDS, (args?.timeToFirstTokenMs ?? 0) / 1000, {
+				ulid,
+				provider: args?.provider,
+				model: args?.modelId,
+				apiFormat: apiFormatName,
+				mode: args?.mode,
+			})
+		}
+
+		if (Number.isFinite(args?.durationMs)) {
+			this.recordHistogram(TelemetryService.METRICS.API.DURATION_SECONDS, (args?.durationMs ?? 0) / 1000, {
+				ulid,
+				provider: args?.provider,
+				model: args?.modelId,
+				apiFormat: apiFormatName,
+				scope: "task",
+				mode: args?.mode,
+			})
+		}
+
+		this.resetTaskAggregates(ulid)
+	}
+
+	/**
+	 * Captures that a message was sent, and includes the API provider and model used
+	 * @param ulid Unique identifier for the task
+	 * @param provider The API provider (e.g., OpenAI, Anthropic)
+	 * @param model The specific model used (e.g., GPT-4, Claude)
+	 * @param source The source of the message ("user" | "model"). Used to track message patterns and identify when users need to correct the model's responses.
+	 * @param mode The mode in which the conversation turn occurred ("plan" or "act")
+	 * @param tokenUsage Optional token usage data
+	 */
+	public captureConversationTurnEvent(
+		ulid: string,
+		provider = "unknown",
+		model = "unknown",
+		source: "user" | "assistant",
+		mode: Mode,
+		tokenUsage: TokenUsage = {},
+		isNativeToolCall?: boolean,
+	) {
+		// Ensure required parameters are provided
+		if (!ulid || !provider || !model || !source) {
+			Logger.warn("TelemetryService: Missing required parameters for message capture")
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.CONVERSATION_TURN,
+			properties: {
+				ulid,
+				provider,
+				model,
+				source,
+				mode,
+				timestamp: new Date().toISOString(), // Add timestamp for message sequencing
+				...tokenUsage,
+				isNativeToolCall,
+			},
+		})
+
+		const turnCount = this.incrementTaskCounter(this.taskTurnCounts, ulid)
+
+		const turnAttributes = { ulid, provider, model, source, mode }
+		this.recordCounter(TelemetryService.METRICS.TASK.TURNS_TOTAL, 1, turnAttributes)
+		this.recordHistogram(TelemetryService.METRICS.TASK.TURNS_PER_TASK, turnCount, turnAttributes)
+
+		if (Number.isFinite(tokenUsage.cacheWriteTokens)) {
+			const cacheWriteTokens = tokenUsage.cacheWriteTokens ?? 0
+			this.recordCounter(TelemetryService.METRICS.CACHE.WRITE_TOTAL, cacheWriteTokens, {
+				ulid,
+				provider,
+				model,
+				mode,
+			})
+			this.recordHistogram(TelemetryService.METRICS.CACHE.WRITE_PER_EVENT, cacheWriteTokens, {
+				ulid,
+				provider,
+				model,
+				mode,
+			})
+		}
+
+		if (Number.isFinite(tokenUsage.cacheReadTokens)) {
+			const cacheReadTokens = tokenUsage.cacheReadTokens ?? 0
+			this.recordCounter(TelemetryService.METRICS.CACHE.READ_TOTAL, cacheReadTokens, {
+				ulid,
+				provider,
+				model,
+				mode,
+			})
+			this.recordHistogram(TelemetryService.METRICS.CACHE.READ_PER_EVENT, cacheReadTokens, {
+				ulid,
+				provider,
+				model,
+				mode,
+			})
+		}
+
+		if (Number.isFinite(tokenUsage.totalCost)) {
+			const totalCost = tokenUsage.totalCost ?? 0
+			const costAttributes = { ulid, provider, model, mode, currency: "USD" }
+			this.recordCounter(TelemetryService.METRICS.TASK.COST_TOTAL, totalCost, costAttributes)
+			this.recordHistogram(TelemetryService.METRICS.TASK.COST_PER_EVENT, totalCost, costAttributes)
+		}
+	}
+
+	/**
+	 * Records token usage metrics for cost tracking and usage analysis
+	 * @param ulid Unique identifier for the task
+	 * @param tokensIn Number of input tokens consumed
+	 * @param tokensOut Number of output tokens generated
+	 * @param provider The API provider identifier (e.g. "anthropic", "openai", "cline")
+	 * @param model The model used for token calculation
+	 */
+	public captureTokenUsage(
+		ulid: string,
+		tokensIn: number,
+		tokensOut: number,
+		provider: string,
+		model: string,
+		options?: TokenUsage,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.TOKEN_USAGE,
+			properties: {
+				ulid,
+				tokensIn,
+				tokensOut,
+				provider,
+				model,
+				...options,
+			},
+		})
+
+		const attributes = { ulid, provider, model }
+
+		if (Number.isFinite(tokensIn)) {
+			const value = tokensIn ?? 0
+			this.recordCounter(TelemetryService.METRICS.TASK.TOKENS_INPUT_TOTAL, value, attributes)
+			this.recordHistogram(TelemetryService.METRICS.TASK.TOKENS_INPUT_PER_RESPONSE, value, attributes)
+		}
+
+		if (Number.isFinite(tokensOut)) {
+			const value = tokensOut ?? 0
+			this.recordCounter(TelemetryService.METRICS.TASK.TOKENS_OUTPUT_TOTAL, value, attributes)
+			this.recordHistogram(TelemetryService.METRICS.TASK.TOKENS_OUTPUT_PER_RESPONSE, value, attributes)
+		}
+
+		if (Number.isFinite(options?.cacheWriteTokens)) {
+			const cacheWriteTokens = options!.cacheWriteTokens ?? 0
+			this.recordCounter(TelemetryService.METRICS.CACHE.WRITE_TOTAL, cacheWriteTokens, attributes)
+			this.recordHistogram(TelemetryService.METRICS.CACHE.WRITE_PER_EVENT, cacheWriteTokens, attributes)
+		}
+
+		if (Number.isFinite(options?.cacheReadTokens)) {
+			const cacheReadTokens = options!.cacheReadTokens ?? 0
+			this.recordCounter(TelemetryService.METRICS.CACHE.READ_TOTAL, cacheReadTokens, attributes)
+			this.recordHistogram(TelemetryService.METRICS.CACHE.READ_PER_EVENT, cacheReadTokens, attributes)
+		}
+
+		if (Number.isFinite(options?.totalCost)) {
+			const totalCost = options!.totalCost ?? 0
+			const costAttributes = { ...attributes, currency: "USD" }
+			this.recordCounter(TelemetryService.METRICS.TASK.COST_TOTAL, totalCost, costAttributes)
+			this.recordHistogram(TelemetryService.METRICS.TASK.COST_PER_EVENT, totalCost, costAttributes)
+		}
+	}
+
+	/**
+	 * Records when a task switches between plan and act modes
+	 * @param ulid Unique identifier for the task
+	 * @param mode The mode being switched to (plan or act)
+	 */
+	public captureModeSwitch(ulid: string, mode: Mode) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.MODE_SWITCH,
+			properties: {
+				ulid,
+				mode,
+			},
+		})
+	}
+
+	/**
+	 * Records when context summarization is triggered due to context window pressure
+	 * @param ulid Unique identifier for the task
+	 * @param modelId The model that triggered summarization
+	 * @param provider The API provider being used
+	 * @param currentTokens Total tokens in context window when summarization was triggered
+	 * @param maxContextWindow Maximum context window size for the model
+	 */
+	public captureSummarizeTask(
+		ulid: string,
+		modelId: string,
+		provider: string,
+		currentTokens: number,
+		maxContextWindow: number,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.AUTO_COMPACT,
+			properties: {
+				ulid,
+				modelId,
+				provider,
+				currentTokens,
+				maxContextWindow,
+			},
+		})
+	}
+
+	/**
+	 * Records user feedback on completed tasks
+	 * @param ulid Unique identifier for the task
+	 * @param feedbackType The type of feedback ("thumbs_up" or "thumbs_down")
+	 */
+	public captureTaskFeedback(ulid: string, feedbackType: TaskFeedbackType) {
+		Logger.info("TelemetryService: Capturing task feedback", {
+			ulid,
+			feedbackType,
+		})
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FEEDBACK,
+			properties: {
+				ulid,
+				feedbackType,
+			},
+		})
+		this.resetTaskAggregates(ulid)
+	}
+
+	// Tool events
+	/**
+	 * Records when a tool is used during task execution
+	 * @param ulid Unique identifier for the task
+	 * @param tool Name of the tool being used
+	 * @param modelId The model ID being used
+	 * @param provider The API provider being used
+	 * @param autoApproved Whether the tool was auto-approved based on settings
+	 * @param success Whether the tool execution was successful
+	 * @param workspaceContext Optional workspace context for multi-root workspace tracking
+	 */
+	public captureToolUsage(
+		ulid: string,
+		tool: string,
+		modelId: string,
+		provider: string,
+		autoApproved: boolean,
+		success: boolean,
+		workspaceContext?: {
+			isMultiRootEnabled: boolean
+			usedWorkspaceHint: boolean
+			resolvedToNonPrimary: boolean
+			resolutionMethod: "hint" | "primary_fallback" | "path_detection"
+		},
+		isNativeToolCall = false,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.TOOL_USED,
+			properties: {
+				ulid,
+				tool,
+				autoApproved,
+				success,
+				modelId,
+				provider,
+				// Workspace context (optional)
+				...(workspaceContext && {
+					workspace_multi_root_enabled: workspaceContext.isMultiRootEnabled,
+					workspace_hint_used: workspaceContext.usedWorkspaceHint,
+					workspace_resolved_non_primary: workspaceContext.resolvedToNonPrimary,
+					workspace_resolution_method: workspaceContext.resolutionMethod,
+				}),
+				isNativeToolCall,
+			},
+		})
+
+		const toolAttributes = {
+			ulid,
+			tool,
+			model: modelId,
+			success,
+			autoApproved,
+		}
+		const toolCallCount = this.incrementTaskCounter(this.taskToolCallCounts, ulid)
+		this.recordCounter(TelemetryService.METRICS.TOOLS.CALLS_TOTAL, 1, toolAttributes)
+		this.recordHistogram(TelemetryService.METRICS.TOOLS.CALLS_PER_TASK, toolCallCount, toolAttributes)
+	}
+
+	public captureSkillUsed(args: {
+		ulid: string
+		skillName: string
+		skillSource: "global" | "project"
+		skillsAvailableGlobal: number
+		skillsAvailableProject: number
+		provider?: string
+		modelId?: string
+	}): void {
+		if (!this.isCategoryEnabled("skills")) {
+			return
+		}
+
+		if (!args.ulid || !args.skillName) {
+			return
+		}
+
+		const skillsAvailableGlobal = Math.max(0, args.skillsAvailableGlobal)
+		const skillsAvailableProject = Math.max(0, args.skillsAvailableProject)
+
+		const properties = {
+			ulid: args.ulid,
+			skillName: args.skillName,
+			skillSource: args.skillSource,
+			skillsAvailableGlobal,
+			skillsAvailableProject,
+			provider: args.provider,
+			modelId: args.modelId,
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.SKILL_USED,
+			properties,
+		})
+	}
+
+	/**
+	 * Records when an MCP tool is called.
+	 * This telemetry event is designed to monitor the usage and performance of MCP tools
+	 * without compromising user privacy. It captures the tool's metadata (server, name, and arguments)
+	 * but explicitly avoids logging the values of the arguments.
+	 *
+	 * @param ulid Unique identifier for the task.
+	 * @param serverName The name of the MCP server.
+	 * @param toolName The name of the tool being called.
+	 * @param status The status of the tool call.
+	 * @param errorMessage Optional error message if the call failed.
+	 * @param argumentKeys Optional array of argument keys for the tool.
+	 */
+	public captureMcpToolCall(
+		ulid: string,
+		serverName: string,
+		toolName: string,
+		status: "started" | "success" | "error",
+		errorMessage?: string,
+		argumentKeys?: string[],
+		isNativeToolCall = false,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.MCP_TOOL_CALLED,
+			properties: {
+				ulid,
+				serverName,
+				toolName,
+				status,
+				errorMessage,
+				argumentKeys,
+				isNativeToolCall,
+			},
+		})
+	}
+
+	/**
+	 * Records checkpoint interactions.
+	 * @param ulid Unique identifier for the task
+	 * @param action The type of checkpoint action
+	 * @param durationMs Optional duration of the operation in milliseconds
+	 */
+	public captureCheckpointUsage(ulid: string, action: "created" | "restored", durationMs?: number) {
+		if (!this.isCategoryEnabled("checkpoints")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.CHECKPOINT_USED,
+			properties: {
+				ulid,
+				action,
+				durationMs,
+			},
+		})
+	}
+
+	/**
+	 * Records when a diff edit (replace_in_file) operation fails
+	 * @param ulid Unique identifier for the task
+	 * @param modelId The model ID being used
+	 * @param provider The API provider being used
+	 * @param errorType Type of error that occurred (e.g., "search_not_found", "invalid_format")
+	 * @param isNativeToolCall Whether the diff edit was invoked by a native tool call
+	 */
+	public captureDiffEditFailure(ulid: string, modelId: string, provider: string, errorType?: string, isNativeToolCall = false) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.DIFF_EDIT_FAILED,
+			properties: {
+				ulid,
+				errorType,
+				modelId,
+				provider,
+				isNativeToolCall,
+			},
+		})
+	}
+
+	/**
+	 * Records when a different model is selected for use
+	 * @param model Name of the selected model
+	 * @param provider Provider of the selected model
+	 * @param ulid Optional task identifier if model was selected during a task
+	 */
+	public captureModelSelected(model: string, provider: string, ulid?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.MODEL_SELECTED,
+			properties: {
+				model,
+				provider,
+				ulid,
+			},
+		})
+	}
+
+	/**
+	 * Records when the browser tool is started
+	 * @param ulid Unique identifier for the task
+	 * @param browserSettings The browser settings being used
+	 */
+	public captureBrowserToolStart(ulid: string, browserSettings: BrowserSettings) {
+		if (!this.isCategoryEnabled("browser")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.BROWSER_TOOL_START,
+			properties: {
+				ulid,
+				viewport: browserSettings.viewport,
+				isRemote: !!browserSettings.remoteBrowserEnabled,
+				remoteBrowserHost: browserSettings.remoteBrowserHost,
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records when the browser tool is completed
+	 * @param ulid Unique identifier for the task
+	 * @param stats Statistics about the browser session
+	 */
+	public captureBrowserToolEnd(
+		ulid: string,
+		stats: {
+			actionCount: number
+			duration: number
+			actions?: string[]
+		},
+	) {
+		if (!this.isCategoryEnabled("browser")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.BROWSER_TOOL_END,
+			properties: {
+				ulid,
+				actionCount: stats.actionCount,
+				duration: stats.duration,
+				actions: stats.actions,
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records when browser errors occur during a task
+	 * @param ulid Unique identifier for the task
+	 * @param errorType Type of error that occurred (e.g., "launch_error", "connection_error", "navigation_error")
+	 * @param errorMessage The error message
+	 * @param context Additional context about where the error occurred
+	 */
+	public captureBrowserError(
+		ulid: string,
+		errorType: string,
+		errorMessage: string,
+		context?: {
+			action?: string
+			url?: string
+			isRemote?: boolean
+			remoteBrowserHost?: string
+			endpoint?: string
+		},
+	) {
+		if (!this.isCategoryEnabled("browser")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.BROWSER_ERROR,
+			properties: {
+				ulid,
+				errorType,
+				errorMessage,
+				...(context && { context }),
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records when a user selects an option from AI-generated followup questions
+	 * @param ulid Unique identifier for the task
+	 * @param qty The quantity of options that were presented
+	 * @param mode The mode in which the option was selected ("plan" or "act")
+	 */
+	public captureOptionSelected(ulid: string, qty: number, mode: Mode) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.OPTION_SELECTED,
+			properties: {
+				ulid,
+				qty,
+				mode,
+			},
+		})
+	}
+
+	/**
+	 * Records when a user types a custom response instead of selecting one of the AI-generated followup questions
+	 * @param ulid Unique identifier for the task
+	 * @param qty The quantity of options that were presented
+	 * @param mode The mode in which the custom response was provided ("plan" or "act")
+	 */
+	public captureOptionsIgnored(ulid: string, qty: number, mode: Mode) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.OPTIONS_IGNORED,
+			properties: {
+				ulid,
+				qty,
+				mode,
+			},
+		})
+	}
+
+	/**
+	 * Captures Gemini API performance metrics.
+	 * @param ulid Unique identifier for the task
+	 * @param modelId Specific Gemini model ID
+	 * @param data Performance data including TTFT, durations, token counts, cache stats, and API success status
+	 */
+	public captureGeminiApiPerformance(
+		ulid: string,
+		modelId: string,
+		data: {
+			ttftSec?: number
+			totalDurationSec?: number
+			promptTokens: number
+			outputTokens: number
+			cacheReadTokens: number
+			cacheHit: boolean
+			cacheHitPercentage?: number
+			apiSuccess: boolean
+			apiError?: string
+			throughputTokensPerSec?: number
+		},
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.GEMINI_API_PERFORMANCE,
+			properties: {
+				ulid,
+				modelId,
+				...data,
+			},
+		})
+
+		if (typeof data.ttftSec === "number") {
+			this.recordHistogram(TelemetryService.METRICS.API.TTFT_SECONDS, data.ttftSec, {
+				ulid,
+				model: modelId,
+				provider: "gemini",
+			})
+		}
+
+		if (typeof data.totalDurationSec === "number") {
+			this.recordHistogram(TelemetryService.METRICS.API.DURATION_SECONDS, data.totalDurationSec, {
+				ulid,
+				model: modelId,
+				provider: "gemini",
+			})
+		}
+
+		if (typeof data.throughputTokensPerSec === "number") {
+			this.recordHistogram(TelemetryService.METRICS.API.THROUGHPUT_TOKENS_PER_SECOND, data.throughputTokensPerSec, {
+				ulid,
+				model: modelId,
+				provider: "gemini",
+			})
+		}
+
+		if (data.cacheHit) {
+			this.recordCounter(TelemetryService.METRICS.CACHE.HITS_TOTAL, 1, { ulid, model: modelId, provider: "gemini" })
+		}
+	}
+
+	/**
+	 * Records when the user uses the model favorite button in the model picker
+	 * @param model The name of the model the user has interacted with
+	 * @param isFavorited Whether the model is being favorited (true) or unfavorited (false)
+	 */
+	public captureModelFavoritesUsage(model: string, isFavorited: boolean) {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.MODEL_FAVORITE_TOGGLED,
+			properties: {
+				model,
+				isFavorited,
+			},
+		})
+	}
+
+	public captureButtonClick(button: string, ulid?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.BUTTON_CLICKED,
+			properties: {
+				button,
+				ulid,
+			},
+		})
+	}
+
+	public capturePanelOpened(source?: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.PANEL_OPENED,
+			properties: { source },
+		})
+	}
+
+	public captureNewTaskClicked(source?: string, hasActiveTask?: boolean) {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.NEW_TASK_CLICKED,
+			properties: { source, hasActiveTask },
+		})
+	}
+
+	public capturePromptSubmitted(args: {
+		source?: string
+		hasText?: boolean
+		hasImages?: boolean
+		hasFiles?: boolean
+		hasActiveTask?: boolean
+		textLength?: number
+	}) {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.PROMPT_SUBMITTED,
+			properties: args,
+		})
+	}
+
+	/**
+	 * Records telemetry when an API provider returns an error
+	 * @param ulid Unique identifier for the task
+	 * @param model Identifier of the model used
+	 * @param requestId Unique identifier for the specific API request
+	 * @param errorMessage Detailed error message from the API provider
+	 * @param errorStatus HTTP status code of the error response, if available
+	 * @param collect Optional flag to determine if the event should be collected for batch sending
+	 */
+	public captureProviderApiError(args: {
+		ulid: string
+		model: string
+		errorMessage: string
+		provider?: string
+		errorStatus?: number | undefined
+		requestId?: string | undefined
+		errorType?: string | undefined
+		failurePhase?: string | undefined
+		isNativeToolCall?: boolean
+	}) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.PROVIDER_API_ERROR,
+			properties: {
+				...args,
+				errorMessage: args.errorMessage.substring(0, MAX_ERROR_MESSAGE_LENGTH), // Truncate long error messages
+				timestamp: new Date().toISOString(),
+			},
+		})
+
+		this.recordCounter(TelemetryService.METRICS.ERRORS.TOTAL, 1, {
+			ulid: args.ulid,
+			model: args.model,
+			provider: args.provider,
+			error_status: args.errorStatus,
+			error_type: args.errorType,
+			failure_phase: args.failurePhase,
+		})
+		const errorAttributes = {
+			ulid: args.ulid,
+			model: args.model,
+			provider: args.provider,
+			error_status: args.errorStatus,
+			error_type: args.errorType,
+			failure_phase: args.failurePhase,
+		}
+		const errorCount = this.incrementTaskCounter(this.taskErrorCounts, args.ulid)
+		this.recordHistogram(TelemetryService.METRICS.ERRORS.PER_TASK, errorCount, errorAttributes)
+	}
+
+	/**
+	 * Records when focus chain is enabled/disabled by the user
+	 * @param enabled Whether focus chain was enabled (true) or disabled (false)
+	 */
+	public captureFocusChainToggle(enabled: boolean) {
+		if (!this.isCategoryEnabled("focus_chain")) {
+			return
+		}
+
+		this.capture({
+			event: enabled ? TelemetryService.EVENTS.TASK.FOCUS_CHAIN_ENABLED : TelemetryService.EVENTS.TASK.FOCUS_CHAIN_DISABLED,
+			properties: {
+				enabled,
+			},
+		})
+	}
+
+	/**
+	 * Records when a task progress list is returned by the model for the first time in a task
+	 * @param ulid Unique identifier for the task
+	 * @param totalItems Number of items in the initial focus chain list
+	 */
+	public captureFocusChainProgressFirst(ulid: string, totalItems: number) {
+		if (!this.isCategoryEnabled("focus_chain")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FOCUS_CHAIN_PROGRESS_FIRST,
+			properties: {
+				ulid,
+				totalItems,
+			},
+		})
+	}
+
+	/**
+	 * Records when a task progress list is updated by the model mid-task
+	 * @param ulid Unique identifier for the task
+	 * @param totalItems Total number of items in the focus chain list
+	 * @param completedItems Number of completed items in the focus chain list
+	 */
+	public captureFocusChainProgressUpdate(ulid: string, totalItems: number, completedItems: number) {
+		if (!this.isCategoryEnabled("focus_chain")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FOCUS_CHAIN_PROGRESS_UPDATE,
+			properties: {
+				ulid,
+				totalItems,
+				completedItems,
+				completionPercentage: totalItems > 0 ? Math.round((completedItems / totalItems) * 100) : 0,
+			},
+		})
+	}
+
+	/**
+	 * Records when a task ends but the task progress list is not complete
+	 * @param ulid Unique identifier for the task
+	 * @param totalItems Total number of items in the focus chain list
+	 * @param completedItems Number of completed items
+	 * @param incompleteItems Number of incomplete items
+	 * @param modelId The model ID being used
+	 * @param provider The API provider being used
+	 */
+	public captureFocusChainIncompleteOnCompletion(
+		ulid: string,
+		totalItems: number,
+		completedItems: number,
+		incompleteItems: number,
+		modelId: string,
+		provider: string,
+	) {
+		if (!this.isCategoryEnabled("focus_chain")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FOCUS_CHAIN_INCOMPLETE_ON_COMPLETION,
+			properties: {
+				ulid,
+				totalItems,
+				completedItems,
+				incompleteItems,
+				completionPercentage: totalItems > 0 ? Math.round((completedItems / totalItems) * 100) : 0,
+				modelId,
+				provider,
+			},
+		})
+	}
+
+	/**
+	 * Records when users click to open the focus chain markdown file
+	 * @param ulid Unique identifier for the task
+	 */
+	public captureFocusChainListOpened(ulid: string) {
+		if (!this.isCategoryEnabled("focus_chain")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FOCUS_CHAIN_LIST_OPENED,
+			properties: {
+				ulid,
+			},
+		})
+	}
+
+	/**
+	 * Records when users save and write to the focus chain markdown file
+	 * @param ulid Unique identifier for the task
+	 */
+	public captureFocusChainListWritten(ulid: string) {
+		if (!this.isCategoryEnabled("focus_chain")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FOCUS_CHAIN_LIST_WRITTEN,
+			properties: {
+				ulid,
+			},
+		})
+	}
+
+	/**
+	 * Records when slash commands or workflows are activated
+	 * @param ulid Unique identifier for the task
+	 * @param commandName The name of the command (e.g., "newtask", "reportbug", or custom workflow name)
+	 * @param commandType Whether it's a built-in command, custom workflow, or MCP prompt
+	 */
+	public captureSlashCommandUsed(ulid: string, commandName: string, commandType: "builtin" | "workflow" | "mcp_prompt") {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.SLASH_COMMAND_USED,
+			properties: {
+				ulid,
+				commandName,
+				commandType,
+			},
+		})
+	}
+
+	/**
+	 * Records when a feature is enabled/disabled by the user
+	 * @param ulid Unique identifier for the task
+	 * @param featureName The name of the feature being toggled
+	 * @param enabled Whether the feature was enabled (true) or disabled (false)
+	 * @param modelId The model ID being used when the toggle occurred
+	 */
+	public captureFeatureToggle(ulid: string, featureName: string, enabled: boolean, modelId: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.FEATURE_TOGGLED,
+			properties: {
+				ulid,
+				featureName,
+				enabled,
+				modelId,
+			},
+		})
+	}
+
+	/**
+	 * Records when individual Cline rules are toggled on/off
+	 * @param ulid Unique identifier for the task (to track rule changes within task context)
+	 * @param ruleFileName The filename of the rule (sanitized to exclude full path)
+	 * @param enabled Whether the rule is being enabled (true) or disabled (false)
+	 * @param isGlobal Whether this is a global rule or workspace-specific rule
+	 */
+	public captureClineRuleToggled(ulid: string, ruleFileName: string, enabled: boolean, isGlobal: boolean) {
+		// Sanitize filename to remove any path information for privacy
+		const sanitizedFileName = ruleFileName.split("/").pop() || ruleFileName.split("\\").pop() || ruleFileName
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.RULE_TOGGLED,
+			properties: {
+				ulid,
+				ruleFileName: sanitizedFileName,
+				enabled,
+				isGlobal,
+			},
+		})
+	}
+
+	/**
+	 * Records when auto condense is enabled/disabled by the user
+	 * @param ulid Unique identifier for the task
+	 * @param enabled Whether auto condense was enabled (true) or disabled (false)
+	 * @param modelId The model ID being used when the toggle occurred
+	 */
+	public captureAutoCondenseToggle(ulid: string, enabled: boolean, modelId: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.AUTO_CONDENSE_TOGGLED,
+			properties: {
+				ulid,
+				enabled,
+				modelId,
+			},
+		})
+	}
+
+	/**
+	 * Records when yolo mode is enabled/disabled by the user
+	 * @param ulid Unique identifier for the task
+	 * @param enabled Whether yolo mode was enabled (true) or disabled (false)
+	 */
+	public captureYoloModeToggle(ulid: string, enabled: boolean) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.YOLO_MODE_TOGGLED,
+			properties: {
+				ulid,
+				enabled,
+			},
+		})
+	}
+
+	/**
+	 * Records task initialization timing and metadata
+	 * @param ulid Unique identifier for the task
+	 * @param taskId Task ID (timestamp in milliseconds when task was created)
+	 * @param durationMs Duration of initialization in milliseconds
+	 * @param hasCheckpoints Whether checkpoints are enabled for this task
+	 */
+	public captureTaskInitialization(ulid: string, taskId: string, durationMs: number, hasCheckpoints: boolean) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.INITIALIZATION,
+			properties: {
+				ulid,
+				taskId,
+				durationMs,
+				hasCheckpoints,
+			},
+		})
+	}
+
+	/**
+	 * Records when the rules menu button is clicked to open the rules/workflows modal
+	 */
+	public captureRulesMenuOpened() {
+		this.capture({
+			event: TelemetryService.EVENTS.UI.RULES_MENU_OPENED,
+			properties: {},
+		})
+	}
+
+	// Terminal telemetry methods
+
+	/**
+	 * Records terminal command execution outcomes for VSCode terminal
+	 * @param success Whether the command output was successfully captured
+	 * @param terminalType The type of terminal ("vscode")
+	 * @param method The VSCode-specific method used to capture output
+	 */
+	public captureTerminalExecution(success: boolean, terminalType: "vscode", method: VscodeOutputMethod): void
+	/**
+	 * Records terminal command execution outcomes for standalone terminal
+	 * @param success Whether the command output was successfully captured
+	 * @param terminalType The type of terminal ("standalone")
+	 * @param method The standalone-specific method used to capture output
+	 * @param exitCode The process exit code (useful for diagnosing failure types: 1=error, 127=not found, 126=permission denied)
+	 */
+	public captureTerminalExecution(
+		success: boolean,
+		terminalType: "standalone",
+		method: StandaloneOutputMethod,
+		exitCode?: number | null,
+	): void
+	/**
+	 * Implementation of captureTerminalExecution
+	 */
+	public captureTerminalExecution(
+		success: boolean,
+		terminalType: TerminalType,
+		method: TerminalOutputMethod,
+		exitCode?: number | null,
+	): void {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.TERMINAL_EXECUTION,
+			properties: {
+				success,
+				terminalType,
+				method,
+				// Only include exitCode for standalone terminals when it's a meaningful value
+				...(terminalType === "standalone" && exitCode !== undefined && exitCode !== null && { exitCode }),
+			},
+		})
+	}
+
+	/**
+	 * Records when terminal output capture fails
+	 * @param reason The reason for failure
+	 * @param terminalType The type of terminal (defaults to "vscode" for backward compatibility)
+	 */
+	public captureTerminalOutputFailure(reason: TerminalOutputFailureReason, terminalType: TerminalType = "vscode") {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.TERMINAL_OUTPUT_FAILURE,
+			properties: {
+				reason,
+				terminalType,
+			},
+		})
+	}
+
+	/**
+	 * Records when user has to intervene with terminal execution
+	 * @param action The user action
+	 * @param terminalType The type of terminal (defaults to "vscode" for backward compatibility)
+	 */
+	public captureTerminalUserIntervention(action: TerminalUserInterventionAction, terminalType: TerminalType = "vscode") {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.TERMINAL_USER_INTERVENTION,
+			properties: {
+				action,
+				terminalType,
+			},
+		})
+	}
+
+	/**
+	 * Records when terminal execution hangs or gets stuck
+	 * @param stage Where the hang occurred
+	 * @param terminalType The type of terminal (defaults to "vscode" for backward compatibility)
+	 */
+	public captureTerminalHang(stage: TerminalHangStage, terminalType: TerminalType = "vscode") {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.TERMINAL_HANG,
+			properties: {
+				stage,
+				terminalType,
+			},
+		})
+	}
+
+	// Workspace telemetry methods
+
+	/**
+	 * Records when workspace is initialized
+	 * @param rootCount Number of workspace roots
+	 * @param vcsTypes Array of VCS types detected
+	 * @param initDurationMs Time taken to initialize in milliseconds
+	 * @param featureFlagEnabled Whether multi-root feature flag is enabled
+	 */
+	public captureWorkspaceInitialized(
+		rootCount: number,
+		vcsTypes: string[],
+		initDurationMs?: number,
+		featureFlagEnabled?: boolean,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKSPACE.INITIALIZED,
+			properties: {
+				root_count: rootCount,
+				vcs_types: vcsTypes,
+				is_multi_root: rootCount > 1,
+				has_git: vcsTypes.includes("Git"),
+				has_mercurial: vcsTypes.includes("Mercurial"),
+				init_duration_ms: initDurationMs,
+				feature_flag_enabled: featureFlagEnabled,
+			},
+		})
+
+		const isMultiRoot = rootCount > 1
+		this.recordGauge("cline.workspace.active_roots", rootCount, {
+			is_multi_root: isMultiRoot,
+		})
+		// Retire the previous series to avoid leaking gauge entries when the flag flips.
+		this.recordGauge("cline.workspace.active_roots", null, {
+			is_multi_root: !isMultiRoot,
+		})
+	}
+
+	/**
+	 * Records workspace initialization errors
+	 * @param error The error that occurred
+	 * @param fallbackMode Whether system fell back to single-root mode
+	 * @param workspaceCount Number of workspace folders detected
+	 */
+	public captureWorkspaceInitError(error: Error, fallbackMode: boolean, workspaceCount?: number) {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKSPACE.INIT_ERROR,
+			properties: {
+				error_type: error.constructor.name,
+				error_message: error.message.substring(0, MAX_ERROR_MESSAGE_LENGTH),
+				fallback_to_single_root: fallbackMode,
+				workspace_count: workspaceCount ?? 0,
+			},
+		})
+	}
+
+	/**
+	 * Records multi-root checkpoint operations
+	 * @param ulid Task identifier
+	 * @param action Type of checkpoint action
+	 * @param rootCount Number of roots being checkpointed
+	 * @param successCount Number of successful checkpoints
+	 * @param failureCount Number of failed checkpoints
+	 * @param durationMs Total operation duration in milliseconds
+	 */
+	public captureMultiRootCheckpoint(
+		ulid: string,
+		action: "initialized" | "committed" | "restored",
+		rootCount: number,
+		successCount: number,
+		failureCount: number,
+		durationMs?: number,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKSPACE.MULTI_ROOT_CHECKPOINT,
+			properties: {
+				ulid,
+				action,
+				root_count: rootCount,
+				success_count: successCount,
+				failure_count: failureCount,
+				success_rate: rootCount > 0 ? successCount / rootCount : 0,
+				duration_ms: durationMs,
+			},
+		})
+	}
+
+	/**
+	 * Records workspace path resolution events
+	 * @param ulid Unique identifier for the task
+	 * @param context The component/handler where resolution occurred
+	 * @param resolutionType Type of resolution performed
+	 * @param hintType Type of workspace hint provided (if any)
+	 * @param resolutionSuccess Whether the resolution was successful
+	 * @param targetWorkspaceIndex Index of the resolved workspace (0=primary, 1=secondary, etc.)
+	 * @param isMultiRootEnabled Whether multi-root mode is enabled
+	 */
+	public captureWorkspacePathResolved(
+		ulid: string,
+		context: string,
+		resolutionType: "hint_provided" | "fallback_to_primary" | "cross_workspace_search",
+		hintType?: "workspace_name" | "workspace_path" | "invalid",
+		resolutionSuccess?: boolean,
+		targetWorkspaceIndex?: number,
+		isMultiRootEnabled?: boolean,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKSPACE.PATH_RESOLVED,
+			properties: {
+				ulid,
+				context,
+				resolution_type: resolutionType,
+				hint_type: hintType,
+				resolution_success: resolutionSuccess,
+				target_workspace_index: targetWorkspaceIndex,
+				is_multi_root_enabled: isMultiRootEnabled,
+			},
+		})
+	}
+
+	/**
+	 * Records multi-workspace search patterns and performance
+	 * @param ulid Unique identifier for the task
+	 * @param searchType Type of search performed
+	 * @param workspaceCount Number of workspaces searched
+	 * @param hintProvided Whether a workspace hint was provided
+	 * @param resultsFound Whether search results were found
+	 * @param searchDurationMs Optional search duration in milliseconds
+	 */
+	public captureWorkspaceSearchPattern(
+		ulid: string,
+		searchType: "targeted" | "cross_workspace" | "primary_only",
+		workspaceCount: number,
+		hintProvided: boolean,
+		resultsFound: boolean,
+		searchDurationMs?: number,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.WORKSPACE_SEARCH_PATTERN,
+			properties: {
+				ulid,
+				search_type: searchType,
+				workspace_count: workspaceCount,
+				hint_provided: hintProvided,
+				results_found: resultsFound,
+				search_duration_ms: searchDurationMs,
+			},
+		})
+	}
+
+	/**
+	 * Records when user opens the worktrees view
+	 * @param source Where the user opened the view from (home_page or menu_bar)
+	 */
+	public captureWorktreeViewOpened(source: "home_page" | "menu_bar") {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKTREE.VIEW_OPENED,
+			properties: {
+				source,
+			},
+		})
+	}
+
+	/**
+	 * Records when a worktree is created
+	 * @param success Whether the creation was successful
+	 * @param worktreeCount Total number of worktrees after creation (to track power users)
+	 */
+	public captureWorktreeCreated(success: boolean, worktreeCount?: number) {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKTREE.CREATED,
+			properties: {
+				success,
+				worktree_count: worktreeCount,
+			},
+		})
+	}
+
+	/**
+	 * Records when a worktree merge is attempted
+	 * @param success Whether the merge was successful
+	 * @param hasConflicts Whether merge conflicts were detected
+	 * @param deleteAfterMerge Whether user chose to delete worktree after merge
+	 */
+	public captureWorktreeMergeAttempted(success: boolean, hasConflicts: boolean, deleteAfterMerge: boolean) {
+		this.capture({
+			event: TelemetryService.EVENTS.WORKTREE.MERGE_ATTEMPTED,
+			properties: {
+				success,
+				has_conflicts: hasConflicts,
+				delete_after_merge: deleteAfterMerge,
+			},
+		})
+	}
+
+	/**
+	 * Checks if a specific telemetry category is enabled
+	 * @param category The telemetry category to check
+	 * @returns Boolean indicating whether the specified telemetry category is enabled
+	 */
+	public isCategoryEnabled(category: TelemetryCategory): boolean {
+		// Default to true if category has not been explicitly configured
+		return this.telemetryCategoryEnabled.get(category) ?? true
+	}
+
+	/**
+	 * Get the telemetry provider instances
+	 * @returns The array of telemetry providers
+	 */
+	public getProviders(): ITelemetryProvider[] {
+		return [...this.providers]
+	}
+
+	/**
+	 * Check if telemetry is currently enabled
+	 * @returns Boolean indicating whether any provider is enabled
+	 */
+	public isEnabled(): boolean {
+		return this.providers.some((provider) => provider.isEnabled())
+	}
+
+	/**
+	 * Get current telemetry settings from the first provider
+	 * @returns Current telemetry settings
+	 */
+	public getSettings() {
+		return this.providers.length > 0
+			? this.providers[0].getSettings()
+			: {
+					hostEnabled: false,
+					level: "off" as const,
+				}
+	}
+
+	/**
+	 * Records when a mention is successfully used and content is retrieved
+	 * @param mentionType Type of mention (file, folder, url, problems, terminal, git-changes, commit)
+	 * @param contentLength Optional length of content retrieved (for size tracking)
+	 */
+	public captureMentionUsed(
+		mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit",
+		contentLength?: number,
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.MENTION_USED,
+			properties: {
+				mentionType,
+				contentLength,
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records when a mention fails to retrieve content or when the mention
+	 * picker's file/folder search itself fails.
+	 *
+	 * `ripgrep_spawn_failed` and `workspace_unavailable` are picker-search
+	 * failures, surfaced by the `searchFiles` controller; the others are
+	 * mention-content retrieval failures.
+	 *
+	 * @param fsContext Optional filesystem info, emitted as `fs_class` and `fs_type`.
+	 */
+	public captureMentionFailed(
+		mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit",
+		errorType:
+			| "not_found"
+			| "permission_denied"
+			| "network_error"
+			| "parse_error"
+			| "ripgrep_spawn_failed"
+			| "workspace_unavailable"
+			| "unknown",
+		errorMessage?: string,
+		fsContext?: { fsClass?: "local" | "network" | "unknown"; fsType?: string },
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.MENTION_FAILED,
+			properties: {
+				mentionType,
+				errorType,
+				errorMessage: errorMessage?.substring(0, MAX_ERROR_MESSAGE_LENGTH),
+				...(fsContext?.fsClass ? { fs_class: fsContext.fsClass } : {}),
+				...(fsContext?.fsType ? { fs_type: fsContext.fsType } : {}),
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records search results when user searches for files/folders in mention dropdown
+	 * @param query The search query entered by user
+	 * @param resultCount Number of results returned
+	 * @param searchType Type of search (file, folder, or all)
+	 * @param isEmpty Whether the search returned no results
+	 * @param fsContext Optional filesystem info, emitted as `fs_class` and `fs_type`.
+	 * @param searchSource Which backend served the search: `host_index` (e.g.
+	 *   JetBrains FilenameIndex) or `ripgrep` (default everywhere). Emitted as
+	 *   the `search_source` property so we can tell, for a given fs_class, how
+	 *   often the host index actually picks up the load.
+	 */
+	public captureMentionSearchResults(
+		query: string,
+		resultCount: number,
+		searchType: "file" | "folder" | "all",
+		isEmpty: boolean,
+		fsContext?: { fsClass?: "local" | "network" | "unknown"; fsType?: string },
+		searchSource?: "host_index" | "ripgrep",
+	) {
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.MENTION_SEARCH_RESULTS,
+			properties: {
+				queryLength: query.length,
+				resultCount,
+				searchType,
+				isEmpty,
+				...(fsContext?.fsClass ? { fs_class: fsContext.fsClass } : {}),
+				...(fsContext?.fsType ? { fs_type: fsContext.fsType } : {}),
+				...(searchSource ? { search_source: searchSource } : {}),
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	// CLI Subagents telemetry methods
+
+	/**
+	 * Records when CLI subagents feature is enabled/disabled by the user
+	 * @param enabled Whether subagents was enabled (true) or disabled (false)
+	 */
+	public captureSubagentToggle(enabled: boolean) {
+		if (!this.isCategoryEnabled("subagents")) {
+			return
+		}
+
+		this.capture({
+			event: enabled ? TelemetryService.EVENTS.TASK.SUBAGENT_ENABLED : TelemetryService.EVENTS.TASK.SUBAGENT_DISABLED,
+			properties: {
+				enabled,
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records when a CLI subagent is executed
+	 * @param ulid Unique identifier for the task
+	 * @param durationMs Duration of the subagent execution in milliseconds
+	 * @param outputLines Number of lines of output produced by the subagent
+	 * @param success Whether the subagent execution was successful
+	 */
+	public captureSubagentExecution(ulid: string, durationMs: number, outputLines: number, success: boolean) {
+		if (!this.isCategoryEnabled("subagents")) {
+			return
+		}
+
+		this.capture({
+			event: success ? TelemetryService.EVENTS.TASK.SUBAGENT_COMPLETED : TelemetryService.EVENTS.TASK.SUBAGENT_STARTED,
+			properties: {
+				ulid,
+				durationMs,
+				outputLines,
+				success,
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	public captureOnboardingProgress(args: {
+		step: number
+		action?: string
+		page?: string
+		pageVariant?: string
+		userType?: string
+		selectedModelId?: string
+		destinationStep?: number
+		destinationPage?: string
+		completed?: boolean
+	}) {
+		this.capture({
+			event: TelemetryService.EVENTS.USER.ONBOARDING_PROGRESS,
+			properties: {
+				...args,
+			},
+		})
+	}
+
+	// Hooks telemetry methods
+
+	/**
+	 * Records hook discovery cache access (hit or miss)
+	 * @param hookName The type of hook being accessed
+	 * @param cacheHit Whether the cache had the result (true) or miss (false)
+	 */
+	public captureHookCacheAccess(hookName: string, cacheHit: boolean) {
+		if (!this.isCategoryEnabled("hooks")) {
+			return
+		}
+
+		// Record cache access counter with hit/miss attribute
+		// This allows deriving hit rate: hits / (hits + misses)
+		this.recordCounter(TelemetryService.METRICS.HOOKS.CACHE_ACCESSES_TOTAL, 1, {
+			hookName,
+			cacheHit: cacheHit.toString(),
+		})
+	}
+
+	// Simplified Hook Telemetry API (following MCP pattern)
+
+	/**
+	 * Records hook execution events with a unified status-based approach.
+	 * This is the simplified API that consolidates multiple hook execution methods.
+	 *
+	 * @param ulid Task identifier
+	 * @param hookName Type of hook (PreToolUse, PostToolUse, etc.)
+	 * @param status Current execution status
+	 * @param metadata Optional execution metadata
+	 */
+	public captureHookExecution(
+		ulid: string,
+		hookName: string,
+		status: "started" | "completed" | "failed" | "cancelled",
+		metadata?: {
+			source?: "global" | "workspace"
+			toolName?: string
+			durationMs?: number
+			exitCode?: number
+			errorType?: "timeout" | "execution" | "validation"
+			errorMessage?: string
+			cancelRequested?: boolean
+			contextModified?: boolean
+			contextSize?: number
+		},
+	) {
+		if (!this.isCategoryEnabled("hooks")) {
+			return
+		}
+
+		const properties: TelemetryProperties = {
+			ulid,
+			hookName,
+			status,
+			timestamp: new Date().toISOString(),
+			...(metadata?.source && { source: metadata.source }),
+			...(metadata?.toolName && { toolName: metadata.toolName }),
+			...(metadata?.durationMs !== undefined && { durationMs: metadata.durationMs }),
+			...(metadata?.exitCode !== undefined && { exitCode: metadata.exitCode }),
+			...(metadata?.errorType && { errorType: metadata.errorType }),
+			...(metadata?.errorMessage && {
+				errorMessage: metadata.errorMessage.substring(0, MAX_ERROR_MESSAGE_LENGTH),
+			}),
+			...(metadata?.cancelRequested !== undefined && { cancelRequested: metadata.cancelRequested }),
+			...(metadata?.contextModified !== undefined && { contextModified: metadata.contextModified }),
+			...(metadata?.contextSize !== undefined && { contextSize: metadata.contextSize }),
+		}
+
+		// Single event for all statuses
+		this.capture({
+			event: "hooks.execution",
+			properties,
+		})
+
+		// Record metrics based on status
+		const hookAttributes = {
+			ulid,
+			hookName,
+			status,
+			...(metadata?.source && { source: metadata.source }),
+			...(metadata?.toolName && { toolName: metadata.toolName }),
+		}
+
+		if (status === "started") {
+			this.recordCounter(TelemetryService.METRICS.HOOKS.EXECUTIONS_TOTAL, 1, hookAttributes)
+		} else if (status === "completed") {
+			if (metadata?.durationMs !== undefined) {
+				this.recordHistogram(TelemetryService.METRICS.HOOKS.DURATION_SECONDS, metadata.durationMs / 1000, hookAttributes)
+			}
+			if (metadata?.cancelRequested) {
+				this.recordCounter(TelemetryService.METRICS.HOOKS.CANCELLATIONS_TOTAL, 1, hookAttributes)
+			}
+			if (metadata?.contextModified) {
+				this.recordCounter(TelemetryService.METRICS.HOOKS.CONTEXT_MODIFICATIONS_TOTAL, 1, hookAttributes)
+			}
+		} else if (status === "failed") {
+			this.recordCounter(TelemetryService.METRICS.HOOKS.FAILURES_TOTAL, 1, {
+				...hookAttributes,
+				errorType: metadata?.errorType || "unknown",
+			})
+		} else if (status === "cancelled") {
+			this.recordCounter(TelemetryService.METRICS.HOOKS.CANCELLATIONS_TOTAL, 1, hookAttributes)
+		}
+	}
+
+	/**
+	 * Records hook discovery results (simplified version).
+	 *
+	 * @param hookName The type of hook being discovered
+	 * @param globalCount Number of global hooks found
+	 * @param workspaceCount Number of workspace-specific hooks found
+	 */
+	public captureHookDiscovery(hookName: string, globalCount: number, workspaceCount: number) {
+		if (!this.isCategoryEnabled("hooks")) {
+			return
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.HOOKS.DISCOVERY_COMPLETED,
+			properties: {
+				hookName,
+				globalCount,
+				workspaceCount,
+				totalCount: globalCount + workspaceCount,
+				timestamp: new Date().toISOString(),
+			},
+		})
+	}
+
+	/**
+	 * Records when a file edit (write_to_file, replace_in_file, apply_patch) is accepted by the user
+	 * Tracks lines added, deleted, and changed for the accepted edit.
+	 *
+	 * @param args Properties for the accepted AI output event
+	 */
+	public captureAiOutputAccepted(args: {
+		ulid: string
+		tool: string
+		provider?: string
+		model?: string
+		source: "agent" | "human"
+		linesAdded: number
+		linesDeleted: number
+		linesChanged: number
+		filesCreated?: number
+		filesDeleted?: number
+		filesMoved?: number
+	}): void {
+		this.capture({
+			event: "task.ai_output.accepted",
+			properties: {
+				ulid: args.ulid,
+				tool: args.tool,
+				provider: args.provider,
+				model: args.model,
+				source: args.source,
+				linesAdded: args.linesAdded,
+				linesDeleted: args.linesDeleted,
+				linesChanged: args.linesChanged,
+				filesCreated: args.filesCreated ?? 0,
+				filesDeleted: args.filesDeleted ?? 0,
+				filesMoved: args.filesMoved ?? 0,
+			},
+		})
+
+		const attrs = { ulid: args.ulid, tool: args.tool, provider: args.provider, model: args.model, source: args.source }
+		this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.ACCEPTED_LINES_ADDED, args.linesAdded, attrs)
+		this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.ACCEPTED_LINES_DELETED, args.linesDeleted, attrs)
+		this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.ACCEPTED_LINES_CHANGED, args.linesChanged, attrs)
+		if (args.filesCreated) {
+			this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.ACCEPTED_FILES_CREATED, args.filesCreated, attrs)
+		}
+		if (args.filesDeleted) {
+			this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.ACCEPTED_FILES_DELETED, args.filesDeleted, attrs)
+		}
+		if (args.filesMoved) {
+			this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.ACCEPTED_FILES_MOVED, args.filesMoved, attrs)
+		}
+	}
+
+	/**
+	 * Records when a file edit (write_to_file, replace_in_file, apply_patch) is rejected by the user
+	 * Tracks lines that would have been added, deleted, and changed.
+	 *
+	 * @param args Properties for the rejected AI output event
+	 */
+	public captureAiOutputRejected(args: {
+		ulid: string
+		tool: string
+		provider?: string
+		model?: string
+		source: "agent" | "human"
+		linesAdded: number
+		linesDeleted: number
+		linesChanged: number
+		filesCreated?: number
+		filesDeleted?: number
+		filesMoved?: number
+	}): void {
+		this.capture({
+			event: "task.ai_output.rejected",
+			properties: {
+				ulid: args.ulid,
+				tool: args.tool,
+				provider: args.provider,
+				model: args.model,
+				source: args.source,
+				linesAdded: args.linesAdded,
+				linesDeleted: args.linesDeleted,
+				linesChanged: args.linesChanged,
+				filesCreated: args.filesCreated ?? 0,
+				filesDeleted: args.filesDeleted ?? 0,
+				filesMoved: args.filesMoved ?? 0,
+			},
+		})
+
+		const attrs = { ulid: args.ulid, tool: args.tool, provider: args.provider, model: args.model, source: args.source }
+		this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.REJECTED_LINES_ADDED, args.linesAdded, attrs)
+		this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.REJECTED_LINES_DELETED, args.linesDeleted, attrs)
+		this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.REJECTED_LINES_CHANGED, args.linesChanged, attrs)
+		if (args.filesCreated) {
+			this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.REJECTED_FILES_CREATED, args.filesCreated, attrs)
+		}
+		if (args.filesDeleted) {
+			this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.REJECTED_FILES_DELETED, args.filesDeleted, attrs)
+		}
+		if (args.filesMoved) {
+			this.recordCounter(TelemetryService.METRICS.AI_OUTPUT.REJECTED_FILES_MOVED, args.filesMoved, attrs)
+		}
+	}
+
+	public captureHostEvent(name: string, content: string) {
+		this.capture({
+			event: TelemetryService.EVENTS.HOST.DETECTED,
+			properties: {
+				name,
+				content,
+			},
+		})
+	}
+
+	/**
+	 * Records the size of a gRPC response message for observability.
+	 *
+	 * @param sizeUtf8Bytes Size in UTF-8 bytes (use `Buffer.byteLength`, not `string.length`)
+	 * @param service The gRPC service name
+	 * @param method The gRPC method name
+	 * @param requestId Optional request ID for correlation
+	 */
+	public captureLegacyTaskMigration(args: {
+		taskId: string
+		outcome: "success" | "skipped" | "error"
+		reason: string
+		durationMs: number
+		legacyApiHistoryLength?: number
+		convertedMessageCount?: number
+		sdkLookupFailed?: boolean
+		hasFavorite?: boolean
+		hasCost?: boolean
+		hasTokenUsage?: boolean
+		hasCwd?: boolean
+	}): void {
+		const migrationType = "legacy_task_to_sdk_session"
+		const metricAttributes = {
+			migration_type: migrationType,
+			outcome: args.outcome,
+			reason: args.reason,
+		}
+
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.LEGACY_TASK_MIGRATION,
+			properties: {
+				ulid: args.taskId,
+				migration_type: migrationType,
+				outcome: args.outcome,
+				reason: args.reason,
+				durationMs: args.durationMs,
+				legacyApiHistoryLength: args.legacyApiHistoryLength,
+				convertedMessageCount: args.convertedMessageCount,
+				sdkLookupFailed: args.sdkLookupFailed,
+				hasFavorite: args.hasFavorite,
+				hasCost: args.hasCost,
+				hasTokenUsage: args.hasTokenUsage,
+				hasCwd: args.hasCwd,
+			},
+		})
+
+		this.recordCounter(
+			TelemetryService.METRICS.MIGRATION.LEGACY_TASK_ATTEMPTS_TOTAL,
+			1,
+			metricAttributes,
+			"Legacy VS Code task migration decisions",
+		)
+		if (args.outcome === "success") {
+			this.recordCounter(
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_SUCCESS_TOTAL,
+				1,
+				metricAttributes,
+				"Legacy VS Code tasks successfully copied into SDK session storage",
+			)
+		} else if (args.outcome === "error") {
+			this.recordCounter(
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_FAILURES_TOTAL,
+				1,
+				metricAttributes,
+				"Legacy VS Code task migrations that failed while building or writing the SDK session",
+			)
+		} else {
+			this.recordCounter(
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_SKIPPED_TOTAL,
+				1,
+				metricAttributes,
+				"Legacy VS Code task migration checks that did not need or could not perform a migration",
+			)
+		}
+
+		this.recordHistogram(
+			TelemetryService.METRICS.MIGRATION.LEGACY_TASK_DURATION_SECONDS,
+			args.durationMs / 1000,
+			metricAttributes,
+			"Time spent checking or migrating a legacy VS Code task into SDK session storage",
+		)
+		if (args.legacyApiHistoryLength !== undefined) {
+			this.recordHistogram(
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_LEGACY_MESSAGES_COUNT,
+				args.legacyApiHistoryLength,
+				metricAttributes,
+				"Number of raw legacy API history messages found while migrating a legacy VS Code task",
+			)
+		}
+		if (args.convertedMessageCount !== undefined) {
+			this.recordHistogram(
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_CONVERTED_MESSAGES_COUNT,
+				args.convertedMessageCount,
+				metricAttributes,
+				"Number of SDK-compatible messages produced from a legacy VS Code task migration",
+			)
+		}
+	}
+
+	public captureLegacyTaskMigrationBacklog(args: {
+		pendingLegacyTaskCount: number
+		migratedSdkTaskCount: number
+		visibleSdkTaskCount: number
+		visibleTaskCount: number
+	}): void {
+		const attributes = { migration_type: "legacy_task_to_sdk_session" }
+		this.recordGauge(
+			TelemetryService.METRICS.MIGRATION.LEGACY_TASK_PENDING_COUNT,
+			args.pendingLegacyTaskCount,
+			attributes,
+			"Legacy VS Code tasks visible in history but not yet migrated to SDK sessions",
+		)
+		this.recordGauge(
+			TelemetryService.METRICS.MIGRATION.LEGACY_TASK_MIGRATED_COUNT,
+			args.migratedSdkTaskCount,
+			attributes,
+			"SDK sessions marked as migrated from legacy VS Code task history",
+		)
+		this.capture({
+			event: TelemetryService.EVENTS.TASK.LEGACY_TASK_MIGRATION,
+			properties: {
+				migration_type: "legacy_task_to_sdk_session",
+				outcome: "backlog",
+				pendingLegacyTaskCount: args.pendingLegacyTaskCount,
+				migratedSdkTaskCount: args.migratedSdkTaskCount,
+				visibleSdkTaskCount: args.visibleSdkTaskCount,
+				visibleTaskCount: args.visibleTaskCount,
+			},
+		})
+	}
+
+	public captureGrpcResponseSize(sizeUtf8Bytes: number, service: string, method: string, requestId?: string): void {
+		this.recordHistogram(
+			TelemetryService.METRICS.GRPC.RESPONSE_SIZE_BYTES,
+			sizeUtf8Bytes,
+			{
+				service,
+				method,
+				...(requestId && { request_id: requestId }),
+			},
+			"Size of gRPC response messages in bytes",
+		)
+
+		if (sizeUtf8Bytes > 4 * 1024 * 1024) {
+			Logger.warn(
+				`[TelemetryService] Large gRPC response: ${service}.${method} ` +
+					`size=${(sizeUtf8Bytes / (1024 * 1024)).toFixed(1)}MB` +
+					(requestId ? ` request_id=${requestId}` : ""),
+			)
+		}
+	}
+
+	/**
+	 * Safely executes a telemetry call with error protection.
+	 *
+	 * Use for critical execution paths where telemetry errors could break functionality:
+	 * - Hook execution (during tool execution)
+	 * - Browser automation (during active sessions)
+	 * - Auth flows, task initialization
+	 * - MCP server operations
+	 *
+	 * Not needed for non-critical, fire-and-forget events:
+	 * - UI events (clicks, navigation)
+	 * - Post-completion events
+	 * - Background operations
+	 *
+	 * This wrapper protects against both pre-provider errors (parameter construction,
+	 * property access, calculations) and provider-level errors (network, API failures).
+	 *
+	 * @param telemetryFn The telemetry function to execute
+	 * @param context Optional context string for debugging (e.g., "HookFactory.exec")
+	 *
+	 * @example
+	 * telemetryService.safeCapture(
+	 *   () => telemetryService.captureHookExecution(taskId, hookName, "started", {...}),
+	 *   'HookFactory.exec.started'
+	 * )
+	 */
+	public safeCapture(telemetryFn: () => void, context?: string): void {
+		try {
+			telemetryFn()
+		} catch (error) {
+			const contextStr = context ? ` [Context: ${context}]` : ""
+			Logger.error(`[Telemetry] Failed to capture telemetry${contextStr}:`, error)
+		}
+	}
+
+	/**
+	 * Clean up resources when the service is disposed
+	 */
+	public async dispose(): Promise<void> {
+		const disposePromises = this.providers.map((provider) => provider.dispose())
+		await Promise.allSettled(disposePromises)
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/__tests__/TelemetryService.metrics.test.ts b/apps/vscode/src/services/telemetry/__tests__/TelemetryService.metrics.test.ts
new file mode 100644
index 0000000..138c993
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/__tests__/TelemetryService.metrics.test.ts
@@ -0,0 +1,437 @@
+import { describe, it } from "bun:test"
+import { ApiFormat } from "@shared/proto/cline/models"
+import * as assert from "assert"
+import { PROVIDER_FAILURE_ERROR_TYPE, PROVIDER_FAILURE_PHASE } from "../../../sdk/provider-failure-telemetry"
+import type { ITelemetryProvider, TelemetryProperties, TelemetrySettings } from "../providers/ITelemetryProvider"
+import { TelemetryMetadata, TelemetryService } from "../TelemetryService"
+
+class FakeProvider implements ITelemetryProvider {
+	readonly name = "FakeProvider"
+	public logs: Array<{ event: string; properties?: TelemetryProperties }> = []
+	public counters: Array<{ name: string; value: number; attributes: TelemetryProperties; description?: string }> = []
+	public histograms: Array<{ name: string; value: number; attributes: TelemetryProperties; description?: string }> = []
+	public gauges = new Map<string, Map<string, { value: number; attributes: TelemetryProperties; description?: string }>>()
+
+	log(event: string, properties?: TelemetryProperties): void {
+		this.logs.push({ event, properties })
+	}
+	logRequired(event: string, properties?: TelemetryProperties): void {
+		this.logs.push({ event, properties })
+	}
+	identifyUser(): void {}
+	isEnabled(): boolean {
+		return true
+	}
+	getSettings(): TelemetrySettings {
+		return { hostEnabled: true, level: "all" }
+	}
+	recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, _required = false): void {
+		this.counters.push({ name, value, attributes: attributes ?? {}, description })
+	}
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		_required = false,
+	): void {
+		this.histograms.push({ name, value, attributes: attributes ?? {}, description })
+	}
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		_required = false,
+	): void {
+		const attrKey = JSON.stringify(attributes ?? {})
+		const series = this.gauges.get(name)
+		if (value === null) {
+			series?.delete(attrKey)
+			if (series && series.size === 0) {
+				this.gauges.delete(name)
+			}
+			return
+		}
+
+		let nextSeries = series
+		if (!nextSeries) {
+			nextSeries = new Map()
+			this.gauges.set(name, nextSeries)
+		}
+
+		nextSeries.set(attrKey, { value, attributes: attributes ?? {}, description })
+	}
+	async forceFlush() {}
+	async dispose(): Promise<void> {}
+}
+
+function createTelemetryService(provider: FakeProvider, overrides: Partial<TelemetryMetadata> = {}): TelemetryService {
+	return new TelemetryService([provider], {
+		extension_version: "test",
+		cline_type: "cline-unit-tests",
+		platform: "test-platform",
+		platform_version: "1.0.0",
+		os_type: "darwin",
+		os_version: "24",
+		is_remote_workspace: false,
+		is_dev: "true",
+		...overrides,
+	} as TelemetryMetadata)
+}
+
+describe("TelemetryService metrics", () => {
+	it("captureTokenUsage emits token counters and histograms", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureTokenUsage("task-1", 120, 80, "anthropic", "model-a")
+
+		assert.deepStrictEqual(
+			provider.counters.map((entry) => entry.name),
+			[TelemetryService.METRICS.TASK.TOKENS_INPUT_TOTAL, TelemetryService.METRICS.TASK.TOKENS_OUTPUT_TOTAL],
+		)
+		assert.deepStrictEqual(
+			provider.histograms.map((entry) => entry.name),
+			[TelemetryService.METRICS.TASK.TOKENS_INPUT_PER_RESPONSE, TelemetryService.METRICS.TASK.TOKENS_OUTPUT_PER_RESPONSE],
+		)
+		;[...provider.counters, ...provider.histograms].forEach((entry) => {
+			assert.strictEqual(entry.attributes.ulid, "task-1")
+			assert.strictEqual(entry.attributes.provider, "anthropic")
+			assert.strictEqual(entry.attributes.model, "model-a")
+			assert.strictEqual(entry.attributes.extension_version, "test")
+		})
+	})
+
+	it("captureTokenUsage emits cache and cost metrics when options provided", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureTokenUsage("task-1", 120, 80, "anthropic", "model-a", {
+			cacheWriteTokens: 50,
+			cacheReadTokens: 30,
+			totalCost: 0.42,
+		})
+
+		assert.deepStrictEqual(
+			provider.counters.map((entry) => entry.name),
+			[
+				TelemetryService.METRICS.TASK.TOKENS_INPUT_TOTAL,
+				TelemetryService.METRICS.TASK.TOKENS_OUTPUT_TOTAL,
+				TelemetryService.METRICS.CACHE.WRITE_TOTAL,
+				TelemetryService.METRICS.CACHE.READ_TOTAL,
+				TelemetryService.METRICS.TASK.COST_TOTAL,
+			],
+		)
+		assert.deepStrictEqual(
+			provider.histograms.map((entry) => entry.name),
+			[
+				TelemetryService.METRICS.TASK.TOKENS_INPUT_PER_RESPONSE,
+				TelemetryService.METRICS.TASK.TOKENS_OUTPUT_PER_RESPONSE,
+				TelemetryService.METRICS.CACHE.WRITE_PER_EVENT,
+				TelemetryService.METRICS.CACHE.READ_PER_EVENT,
+				TelemetryService.METRICS.TASK.COST_PER_EVENT,
+			],
+		)
+		const cacheWriteCounter = provider.counters.find((entry) => entry.name === TelemetryService.METRICS.CACHE.WRITE_TOTAL)
+		assert.ok(cacheWriteCounter)
+		assert.strictEqual(cacheWriteCounter?.value, 50)
+		assert.strictEqual(cacheWriteCounter?.attributes.ulid, "task-1")
+		assert.strictEqual(cacheWriteCounter?.attributes.model, "model-a")
+
+		const cacheReadCounter = provider.counters.find((entry) => entry.name === TelemetryService.METRICS.CACHE.READ_TOTAL)
+		assert.ok(cacheReadCounter)
+		assert.strictEqual(cacheReadCounter?.value, 30)
+
+		const costCounter = provider.counters.find((entry) => entry.name === TelemetryService.METRICS.TASK.COST_TOTAL)
+		assert.ok(costCounter)
+		assert.strictEqual(costCounter?.value, 0.42)
+		assert.strictEqual(costCounter?.attributes.ulid, "task-1")
+		assert.strictEqual(costCounter?.attributes.model, "model-a")
+		assert.strictEqual(costCounter?.attributes.currency, "USD")
+
+		const cacheWriteHist = provider.histograms.find((entry) => entry.name === TelemetryService.METRICS.CACHE.WRITE_PER_EVENT)
+		assert.ok(cacheWriteHist)
+		assert.strictEqual(cacheWriteHist?.value, 50)
+
+		const cacheReadHist = provider.histograms.find((entry) => entry.name === TelemetryService.METRICS.CACHE.READ_PER_EVENT)
+		assert.ok(cacheReadHist)
+		assert.strictEqual(cacheReadHist?.value, 30)
+
+		const costHist = provider.histograms.find((entry) => entry.name === TelemetryService.METRICS.TASK.COST_PER_EVENT)
+		assert.ok(costHist)
+		assert.strictEqual(costHist?.value, 0.42)
+	})
+
+	it("captureTokenUsage skips cache/cost metrics when options fields are undefined", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureTokenUsage("task-1", 120, 80, "anthropic", "model-a", {})
+
+		assert.deepStrictEqual(
+			provider.counters.map((entry) => entry.name),
+			[TelemetryService.METRICS.TASK.TOKENS_INPUT_TOTAL, TelemetryService.METRICS.TASK.TOKENS_OUTPUT_TOTAL],
+		)
+		assert.deepStrictEqual(
+			provider.histograms.map((entry) => entry.name),
+			[TelemetryService.METRICS.TASK.TOKENS_INPUT_PER_RESPONSE, TelemetryService.METRICS.TASK.TOKENS_OUTPUT_PER_RESPONSE],
+		)
+	})
+
+	it("captureTokenUsage includes options in event properties", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureTokenUsage("task-1", 120, 80, "anthropic", "model-a", {
+			cacheWriteTokens: 50,
+			cacheReadTokens: 30,
+			totalCost: 0.42,
+		})
+
+		const tokenEvent = provider.logs.find((entry) => entry.event === "task.tokens")
+		assert.ok(tokenEvent)
+		assert.strictEqual(tokenEvent?.properties?.provider, "anthropic")
+		assert.strictEqual(tokenEvent?.properties?.model, "model-a")
+		assert.strictEqual(tokenEvent?.properties?.cacheWriteTokens, 50)
+		assert.strictEqual(tokenEvent?.properties?.cacheReadTokens, 30)
+		assert.strictEqual(tokenEvent?.properties?.totalCost, 0.42)
+	})
+
+	it("metrics include is_remote_workspace in standard attributes", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider, { is_remote_workspace: true })
+
+		service.captureTokenUsage("task-remote", 120, 80, "anthropic", "model-a")
+
+		assert.ok(provider.counters.length > 0)
+		assert.strictEqual(provider.counters[0].attributes.is_remote_workspace, true)
+		assert.strictEqual(provider.histograms[0].attributes.is_remote_workspace, true)
+	})
+
+	it("captureConversationTurnEvent emits counters with cache and cost", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+		service.identifyAccount({ id: "user-1" } as any)
+
+		service.captureConversationTurnEvent("task-2", "openai", "gpt-4", "assistant", "plan", {
+			tokensIn: 150,
+			tokensOut: 200,
+			cacheWriteTokens: 40,
+			cacheReadTokens: 20,
+			totalCost: 1.23,
+		})
+
+		assert.deepStrictEqual(
+			provider.counters.map((entry) => entry.name),
+			[
+				TelemetryService.METRICS.TASK.TURNS_TOTAL,
+				TelemetryService.METRICS.CACHE.WRITE_TOTAL,
+				TelemetryService.METRICS.CACHE.READ_TOTAL,
+				TelemetryService.METRICS.TASK.COST_TOTAL,
+			],
+		)
+		const costEntry = provider.counters.find((entry) => entry.name === "cline.cost.total")
+		assert.ok(costEntry)
+		assert.strictEqual(costEntry?.attributes.ulid, "task-2")
+		assert.strictEqual(costEntry?.attributes.provider, "openai")
+		assert.strictEqual(costEntry?.attributes.model, "gpt-4")
+		assert.strictEqual(costEntry?.attributes.mode, "plan")
+		assert.strictEqual(costEntry?.attributes.currency, "USD")
+		assert.deepStrictEqual(
+			provider.histograms.map((entry) => entry.name),
+			[
+				TelemetryService.METRICS.TASK.TURNS_PER_TASK,
+				TelemetryService.METRICS.CACHE.WRITE_PER_EVENT,
+				TelemetryService.METRICS.CACHE.READ_PER_EVENT,
+				TelemetryService.METRICS.TASK.COST_PER_EVENT,
+			],
+		)
+		const turnEntry = provider.histograms.find((entry) => entry.name === TelemetryService.METRICS.TASK.TURNS_PER_TASK)
+		assert.ok(turnEntry)
+		assert.strictEqual(turnEntry?.value, 1)
+		assert.strictEqual(turnEntry?.attributes.ulid, "task-2")
+		assert.strictEqual(turnEntry?.attributes.provider, "openai")
+		assert.strictEqual(turnEntry?.attributes.model, "gpt-4")
+		assert.strictEqual(turnEntry?.attributes.source, "assistant")
+		assert.strictEqual(turnEntry?.attributes.mode, "plan")
+	})
+
+	it("captureWorkspaceInitialized emits gauge and retires previous series", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureWorkspaceInitialized(3, ["Git"], 500)
+		const initialSeries = provider.gauges.get("cline.workspace.active_roots")
+		assert.ok(initialSeries)
+		assert.strictEqual(initialSeries.size, 1)
+		const [initialEntry] = Array.from(initialSeries.values())
+		assert.strictEqual(initialEntry.value, 3)
+		assert.strictEqual(initialEntry.attributes.is_multi_root, true)
+		assert.strictEqual(initialEntry.attributes.extension_version, "test")
+
+		service.captureWorkspaceInitialized(1, ["Git"], 200)
+		const updatedSeries = provider.gauges.get("cline.workspace.active_roots")
+		assert.ok(updatedSeries)
+		assert.strictEqual(updatedSeries.size, 1)
+		const [updatedEntry] = Array.from(updatedSeries.values())
+		assert.strictEqual(updatedEntry.value, 1)
+		assert.strictEqual(updatedEntry.attributes.is_multi_root, false)
+	})
+
+	it("captureProviderApiError increments error counter", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureProviderApiError({
+			ulid: "task-3",
+			model: "claude",
+			errorMessage: "boom",
+			provider: "anthropic",
+			errorStatus: 500,
+			errorType: PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_DONE_ERROR,
+			failurePhase: PROVIDER_FAILURE_PHASE.STREAMING,
+		})
+
+		assert.strictEqual(provider.counters.length, 1)
+		const entry = provider.counters[0]
+		assert.strictEqual(entry.name, TelemetryService.METRICS.ERRORS.TOTAL)
+		assert.strictEqual(entry.value, 1)
+		assert.strictEqual(entry.attributes.ulid, "task-3")
+		assert.strictEqual(entry.attributes.provider, "anthropic")
+		assert.strictEqual(entry.attributes.model, "claude")
+		assert.strictEqual(entry.attributes.error_status, 500)
+		assert.strictEqual(entry.attributes.error_type, PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_DONE_ERROR)
+		assert.strictEqual(entry.attributes.failure_phase, PROVIDER_FAILURE_PHASE.STREAMING)
+		assert.strictEqual(provider.histograms.length, 1)
+		const errorHistogram = provider.histograms[0]
+		assert.strictEqual(errorHistogram.name, TelemetryService.METRICS.ERRORS.PER_TASK)
+		assert.strictEqual(errorHistogram.value, 1)
+		assert.strictEqual(errorHistogram.attributes.ulid, "task-3")
+		assert.strictEqual(errorHistogram.attributes.provider, "anthropic")
+		assert.strictEqual(errorHistogram.attributes.model, "claude")
+		assert.strictEqual(errorHistogram.attributes.error_status, 500)
+		assert.strictEqual(errorHistogram.attributes.error_type, PROVIDER_FAILURE_ERROR_TYPE.SDK_AGENT_DONE_ERROR)
+		assert.strictEqual(errorHistogram.attributes.failure_phase, PROVIDER_FAILURE_PHASE.STREAMING)
+	})
+
+	it("captureTaskCompleted records completion payload with TTFT and duration histograms", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureTaskCompleted("task-4", {
+			provider: "openai-native",
+			modelId: "gpt-5",
+			apiFormat: ApiFormat.OPENAI_RESPONSES,
+			timeToFirstTokenMs: 350,
+			durationMs: 2100,
+			mode: "act",
+		})
+
+		const completionEvent = provider.logs.find((entry) => entry.event === "task.completed")
+		assert.ok(completionEvent)
+		assert.ok(completionEvent?.properties)
+		assert.strictEqual(completionEvent?.properties?.ulid, "task-4")
+		assert.strictEqual(completionEvent?.properties?.provider, "openai-native")
+		assert.strictEqual(completionEvent?.properties?.modelId, "gpt-5")
+		assert.strictEqual(completionEvent?.properties?.apiFormat, ApiFormat.OPENAI_RESPONSES)
+		assert.strictEqual(completionEvent?.properties?.apiFormatName, "OPENAI_RESPONSES")
+		assert.strictEqual(completionEvent?.properties?.timeToFirstTokenMs, 350)
+		assert.strictEqual(completionEvent?.properties?.durationMs, 2100)
+
+		const ttftMetric = provider.histograms.find((entry) => entry.name === TelemetryService.METRICS.API.TTFT_SECONDS)
+		assert.ok(ttftMetric)
+		assert.strictEqual(ttftMetric?.value, 0.35)
+		assert.strictEqual(ttftMetric?.attributes.ulid, "task-4")
+		assert.strictEqual(ttftMetric?.attributes.provider, "openai-native")
+		assert.strictEqual(ttftMetric?.attributes.model, "gpt-5")
+		assert.strictEqual(ttftMetric?.attributes.apiFormat, "OPENAI_RESPONSES")
+
+		const durationMetric = provider.histograms.find((entry) => entry.name === TelemetryService.METRICS.API.DURATION_SECONDS)
+		assert.ok(durationMetric)
+		assert.strictEqual(durationMetric?.value, 2.1)
+		assert.strictEqual(durationMetric?.attributes.scope, "task")
+	})
+
+	it("captureGrpcResponseSize records histogram with correct name, value, and attributes", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureGrpcResponseSize(123456, "cline.StateService", "subscribeToState")
+
+		assert.strictEqual(provider.histograms.length, 1)
+		const entry = provider.histograms[0]
+		assert.strictEqual(entry.name, TelemetryService.METRICS.GRPC.RESPONSE_SIZE_BYTES)
+		assert.strictEqual(entry.value, 123456)
+		assert.strictEqual(entry.attributes.service, "cline.StateService")
+		assert.strictEqual(entry.attributes.method, "subscribeToState")
+		assert.strictEqual(entry.description, "Size of gRPC response messages in bytes")
+		// Should not have request_id when not provided
+		assert.strictEqual(entry.attributes.request_id, undefined)
+	})
+
+	it("captureGrpcResponseSize includes request_id when provided", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureGrpcResponseSize(5000, "cline.StateService", "subscribeToState", "req-42")
+
+		assert.strictEqual(provider.histograms.length, 1)
+		const entry = provider.histograms[0]
+		assert.strictEqual(entry.attributes.request_id, "req-42")
+	})
+
+	it("captureGrpcResponseSize includes standard metadata attributes", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureGrpcResponseSize(1000, "cline.StateService", "subscribeToState")
+
+		const entry = provider.histograms[0]
+		assert.strictEqual(entry.attributes.extension_version, "test")
+		assert.strictEqual(entry.attributes.platform, "test-platform")
+	})
+
+	it("captureLegacyTaskMigration emits event and migration metrics", () => {
+		const provider = new FakeProvider()
+		const service = createTelemetryService(provider)
+
+		service.captureLegacyTaskMigration({
+			taskId: "legacy-task",
+			outcome: "success",
+			reason: "migrated",
+			durationMs: 250,
+			legacyApiHistoryLength: 3,
+			convertedMessageCount: 2,
+			hasFavorite: true,
+			hasCost: true,
+			hasTokenUsage: true,
+			hasCwd: true,
+		})
+
+		const event = provider.logs.find((entry) => entry.event === "task.legacy_task_migration")
+		assert.ok(event)
+		assert.strictEqual(event?.properties?.ulid, "legacy-task")
+		assert.strictEqual(event?.properties?.outcome, "success")
+		assert.strictEqual(event?.properties?.legacyApiHistoryLength, 3)
+
+		assert.deepStrictEqual(
+			provider.counters.map((entry) => entry.name),
+			[
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_ATTEMPTS_TOTAL,
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_SUCCESS_TOTAL,
+			],
+		)
+		assert.deepStrictEqual(
+			provider.histograms.map((entry) => entry.name),
+			[
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_DURATION_SECONDS,
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_LEGACY_MESSAGES_COUNT,
+				TelemetryService.METRICS.MIGRATION.LEGACY_TASK_CONVERTED_MESSAGES_COUNT,
+			],
+		)
+		assert.strictEqual(provider.histograms[0].value, 0.25)
+		assert.strictEqual(provider.histograms[0].attributes.migration_type, "legacy_task_to_sdk_session")
+		assert.strictEqual(provider.histograms[0].attributes.reason, "migrated")
+	})
+})
diff --git a/apps/vscode/src/services/telemetry/index.ts b/apps/vscode/src/services/telemetry/index.ts
new file mode 100644
index 0000000..847c82e
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/index.ts
@@ -0,0 +1,54 @@
+// Export terminal type definitions for type-safe telemetry
+// Export the enums and types for terminal telemetry
+export { TerminalHangStage, TerminalOutputFailureReason, TerminalUserInterventionAction } from "./TelemetryService"
+
+// Create a singleton instance for easy access throughout the application
+import { TelemetryService } from "./TelemetryService"
+
+let _telemetryServiceInstance: TelemetryService | null = null
+let _initializationPromise: Promise<TelemetryService> | null = null
+
+/**
+ * Get the singleton telemetry service instance
+ * @param distinctId Optional distinct ID for the telemetry provider
+ * @returns TelemetryService instance
+ */
+async function getTelemetryService(): Promise<TelemetryService> {
+	if (_telemetryServiceInstance) {
+		return _telemetryServiceInstance
+	}
+
+	// If initialization is already in progress, wait for it to complete
+	if (_initializationPromise) {
+		return _initializationPromise
+	}
+
+	// Start initialization and store the promise to prevent concurrent initialization.
+	// Ensure that on failure we reset the initialization promise so future calls can retry.
+	_initializationPromise = TelemetryService.create()
+		.then((service) => {
+			_telemetryServiceInstance = service
+			_initializationPromise = null
+			return service
+		})
+		.catch((error) => {
+			_initializationPromise = null
+			throw error
+		})
+
+	return _initializationPromise
+}
+
+export const telemetryService = new Proxy({} as TelemetryService, {
+	get(_target, prop, _receiver) {
+		// Return a function that will call the method on the actual service
+		return async (...args: any[]) => {
+			const service: TelemetryService = await getTelemetryService()
+			const method = Reflect.get(service, prop, service)
+			if (typeof method === "function") {
+				return method.apply(service, args)
+			}
+			return method
+		}
+	},
+})
diff --git a/apps/vscode/src/services/telemetry/providers/ITelemetryProvider.ts b/apps/vscode/src/services/telemetry/providers/ITelemetryProvider.ts
new file mode 100644
index 0000000..715d58b
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/ITelemetryProvider.ts
@@ -0,0 +1,125 @@
+/**
+ * Interface for telemetry providers
+ * Allows switching between different analytics providers (PostHog, etc.)
+ */
+
+import type { ClineAccountUserInfo } from "../../auth/AuthService"
+
+/**
+ * JSON-serializable primitive types for telemetry properties
+ */
+type TelemetryPrimitive = string | number | boolean | null | undefined
+
+/**
+ * JSON-serializable value types for telemetry properties
+ * Ensures all telemetry data can be properly serialized
+ */
+type TelemetryValue = TelemetryPrimitive | TelemetryObject | TelemetryArray
+
+/**
+ * JSON-serializable object for telemetry properties
+ */
+type TelemetryObject = { [key: string]: TelemetryValue }
+
+/**
+ * JSON-serializable array for telemetry properties
+ */
+type TelemetryArray = Array<TelemetryValue>
+
+/**
+ * Properties that can be safely passed to telemetry providers
+ */
+export type TelemetryProperties = TelemetryObject
+
+/**
+ * Telemetry settings that control when and how telemetry is collected
+ */
+export interface TelemetrySettings {
+	/** Whether the host environment's telemetry is enabled */
+	hostEnabled: boolean
+	/** The level of telemetry to collect */
+	level?: "all" | "off" | "error" | "crash"
+}
+
+/**
+ * Abstract interface for telemetry providers
+ * Any analytics provider must implement this interface
+ */
+export interface ITelemetryProvider {
+	/**
+	 * Log an event with optional properties
+	 * @param event The event name to log
+	 * @param properties Optional JSON-serializable properties to attach to the event
+	 */
+	log(event: string, properties?: TelemetryProperties): void
+
+	/**
+	 * Log a required event that bypasses telemetry opt-out settings
+	 * Required events are critical for system health and error monitoring
+	 * @param event The event name to log
+	 * @param properties Optional JSON-serializable properties to attach to the event
+	 */
+	logRequired(event: string, properties?: TelemetryProperties): void
+
+	/**
+	 * Identify a user for tracking
+	 * @param userInfo The user's information
+	 * @param properties Optional additional JSON-serializable properties
+	 */
+	identifyUser(userInfo: ClineAccountUserInfo, properties?: TelemetryProperties): void
+
+	/**
+	 * Check if telemetry is currently enabled
+	 */
+	isEnabled(): boolean
+
+	/**
+	 * Get current telemetry settings
+	 */
+	getSettings(): TelemetrySettings
+
+	/**
+	 * The name of the telemetry provider.
+	 */
+	readonly name: string
+
+	/**
+	 * Record a counter metric (cumulative value that only increases)
+	 * Providers that don't support metrics may implement this as a no-op.
+	 * @param name Metric name (e.g., "cline.tokens.input")
+	 * @param value Amount to increment by (default 1)
+	 * @param attributes Optional metric attributes including userId, ulid (JSON-serializable)
+	 */
+	recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void
+
+	/**
+	 * Record a histogram metric (distribution of values for percentile analysis)
+	 * Providers that don't support metrics may implement this as a no-op.
+	 * @param name Metric name (e.g., "cline.api.duration_seconds")
+	 * @param value Value to record
+	 * @param attributes Optional metric attributes including userId, ulid (JSON-serializable)
+	 */
+	recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void
+
+	/**
+	 * Record a gauge metric (point-in-time value that can go up or down)
+	 * Providers that don't support metrics may implement this as a no-op.
+	 * @param name Metric name (e.g., "cline.workspace.active_roots")
+	 * @param value Current value, or null to retire the series identified by name + attributes
+	 * @param attributes Optional metric attributes including userId, ulid (JSON-serializable). When retiring a series pass the same attribute set that was used when recording it.
+	 */
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void
+
+	forceFlush(): Promise<void>
+
+	/**
+	 * Clean up resources when the provider is disposed
+	 */
+	dispose(): Promise<void>
+}
diff --git a/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryClientProvider.ts b/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryClientProvider.ts
new file mode 100644
index 0000000..2e216bb
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryClientProvider.ts
@@ -0,0 +1,216 @@
+import { metrics } from "@opentelemetry/api"
+import { logs } from "@opentelemetry/api-logs"
+import { Resource } from "@opentelemetry/resources"
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs"
+import { MeterProvider } from "@opentelemetry/sdk-metrics"
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions"
+import { ExtensionRegistryInfo } from "@/registry"
+import { OpenTelemetryClientValidConfig } from "@/shared/services/config/otel-config"
+import { Logger } from "@/shared/services/Logger"
+import {
+	createConsoleLogExporter,
+	createConsoleMetricReader,
+	createOTLPLogExporter,
+	createOTLPMetricReader,
+} from "./OpenTelemetryExporterFactory"
+
+/**
+ * OpenTelemetry client provider.
+ * Manages meter and logger providers for telemetry collection.
+ */
+export class OpenTelemetryClientProvider {
+	readonly meterProvider: MeterProvider | null = null
+	readonly loggerProvider: LoggerProvider | null = null
+	private readonly config: OpenTelemetryClientValidConfig | null
+
+	/**
+	 * Check if debug diagnostics are enabled.
+	 * Only log sensitive information (endpoints, headers) when in debug mode.
+	 */
+	private isDebugEnabled(): boolean {
+		return process.env.TEL_DEBUG_DIAGNOSTICS === "true" || process.env.IS_DEV === "true"
+	}
+
+	constructor(config: OpenTelemetryClientValidConfig) {
+		this.config = config
+		const isDebugMode = this.isDebugEnabled()
+
+		// Only log endpoint in debug mode (security: avoid exposing infrastructure details)
+		if (isDebugMode) {
+			Logger.log("[OTEL DEBUG] ========== OpenTelemetry Initialization ==========")
+			Logger.log(`[OTEL DEBUG] Configuration:`)
+			Logger.log(`[OTEL DEBUG]   - Metrics Exporter: ${this.config.metricsExporter || "none"}`)
+			Logger.log(`[OTEL DEBUG]   - Logs Exporter: ${this.config.logsExporter || "none"}`)
+			Logger.log(`[OTEL DEBUG]   - OTLP Protocol: ${this.config.otlpProtocol || "grpc (default)"}`)
+
+			Logger.log(`[OTEL DEBUG]   - OTLP Endpoint: ${this.config.otlpEndpoint || "not set"}`)
+			Logger.log(`[OTEL DEBUG]   - OTLP Insecure: ${this.config.otlpInsecure || false}`)
+			Logger.log(`[OTEL DEBUG]   - Metric Export Interval: ${this.config.metricExportInterval || 60000}ms`)
+		}
+
+		if (isDebugMode && config.otlpHeaders) {
+			const headerCount = Object.keys(config.otlpHeaders).length
+			// In debug mode, show that headers are configured and their total length
+			Logger.log(`[OTEL DEBUG]   - OTLP Headers: ${headerCount} headers configured`)
+			Logger.log("[OTEL DEBUG] ================================================")
+		}
+
+		// Create resource with service information
+		const resource = new Resource({
+			[ATTR_SERVICE_NAME]: "cline",
+			[ATTR_SERVICE_VERSION]: ExtensionRegistryInfo.version,
+		})
+
+		// Initialize metrics if configured
+		if (this.config.metricsExporter) {
+			this.meterProvider = this.createMeterProvider(resource)
+		}
+
+		// Initialize logs if configured
+		if (this.config.logsExporter) {
+			this.loggerProvider = this.createLoggerProvider(resource)
+		}
+
+		Logger.log("[OTEL DEBUG] OpenTelemetry initialization complete")
+	}
+
+	private createMeterProvider(resource: Resource): MeterProvider {
+		const exporters = this.config!.metricsExporter!.split(",").map((type) => type.trim())
+		const readers: any[] = []
+		const interval = this.config!.metricExportInterval || 60000
+		const timeout = Math.min(Math.floor(interval * 0.8), 30000)
+
+		Logger.log(`[OTEL] Creating MeterProvider with exporters: ${exporters.join(", ")}`)
+
+		for (const exporterType of exporters) {
+			try {
+				switch (exporterType) {
+					case "console": {
+						const reader = createConsoleMetricReader(interval, timeout)
+						readers.push(reader)
+						Logger.log(`[OTEL] Console metrics reader created (interval: ${interval}ms)`)
+						break
+					}
+					case "otlp": {
+						const protocol = this.config!.otlpMetricsProtocol || this.config!.otlpProtocol || "grpc"
+						const endpoint = this.config!.otlpMetricsEndpoint || this.config!.otlpEndpoint
+						const insecure = this.config!.otlpInsecure || false
+						const headers = this.config!.otlpMetricsHeaders || this.config!.otlpHeaders
+
+						if (endpoint) {
+							const reader = createOTLPMetricReader(protocol, endpoint, insecure, interval, timeout, headers)
+							if (reader) {
+								readers.push(reader)
+								Logger.log(`[OTEL] OTLP metrics reader created (${protocol}, interval: ${interval}ms)`)
+							}
+						} else {
+							Logger.warn("[OTEL] OTLP metrics exporter requires an endpoint")
+						}
+						break
+					}
+					default:
+						Logger.warn(`[OTEL] Unknown metrics exporter type: ${exporterType}`)
+				}
+			} catch (error) {
+				Logger.error(`[OTEL] Failed to create metrics exporter '${exporterType}':`, error)
+			}
+		}
+
+		if (readers.length === 0) {
+			Logger.warn("[OTEL] No metric readers were successfully created")
+		}
+
+		const meterProvider = new MeterProvider({
+			resource,
+			readers,
+		})
+
+		// Set as global meter provider
+		metrics.setGlobalMeterProvider(meterProvider)
+		Logger.log(`[OTEL] MeterProvider initialized with ${readers.length} reader(s)`)
+
+		return meterProvider
+	}
+
+	private createLoggerProvider(resource: Resource): LoggerProvider {
+		const exporters = this.config!.logsExporter!.split(",").map((type) => type.trim())
+		const loggerProvider = new LoggerProvider({ resource })
+
+		Logger.log(`[OTEL] Creating LoggerProvider with exporters: ${exporters.join(", ")}`)
+
+		for (const exporterType of exporters) {
+			try {
+				let exporter = null
+
+				switch (exporterType) {
+					case "console":
+						exporter = createConsoleLogExporter()
+						Logger.log("[OTEL] Console logs exporter created")
+						break
+					case "otlp": {
+						const protocol = this.config!.otlpLogsProtocol || this.config!.otlpProtocol || "grpc"
+						const endpoint = this.config!.otlpLogsEndpoint || this.config!.otlpEndpoint
+						const insecure = this.config!.otlpInsecure || false
+						const headers = this.config!.otlpLogsHeaders || this.config!.otlpHeaders
+
+						if (endpoint) {
+							exporter = createOTLPLogExporter(protocol, endpoint, insecure, headers)
+							if (exporter) {
+								Logger.log(`[OTEL] OTLP logs exporter created (${protocol})`)
+							}
+						} else {
+							Logger.warn("[OTEL] OTLP logs exporter requires an endpoint")
+						}
+						break
+					}
+					default:
+						Logger.warn(`[OTEL] Unknown logs exporter type: ${exporterType}`)
+				}
+
+				if (exporter) {
+					const batchConfig = {
+						maxQueueSize: this.config!.logMaxQueueSize || 2048,
+						maxExportBatchSize: this.config!.logBatchSize || 512,
+						scheduledDelayMillis: this.config!.logBatchTimeout || 5000,
+					}
+
+					loggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(exporter, batchConfig))
+
+					Logger.log(
+						`[OTEL] Log batch processor configured: maxQueue=${batchConfig.maxQueueSize}, batchSize=${batchConfig.maxExportBatchSize}, timeout=${batchConfig.scheduledDelayMillis}ms`,
+					)
+				}
+			} catch (error) {
+				Logger.error(`[OTEL] Failed to create logs exporter '${exporterType}':`, error)
+			}
+		}
+
+		// Set as global logger provider
+		logs.setGlobalLoggerProvider(loggerProvider)
+		Logger.log("[OTEL] LoggerProvider initialized")
+
+		return loggerProvider
+	}
+
+	public async dispose(): Promise<void> {
+		const promises: Promise<void>[] = []
+
+		if (this.meterProvider) {
+			promises.push(
+				this.meterProvider.shutdown().catch((error) => {
+					Logger.error("Error shutting down MeterProvider:", error)
+				}),
+			)
+		}
+
+		if (this.loggerProvider) {
+			promises.push(
+				this.loggerProvider.shutdown().catch((error) => {
+					Logger.error("Error shutting down LoggerProvider:", error)
+				}),
+			)
+		}
+
+		await Promise.all(promises)
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryExporterFactory.ts b/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryExporterFactory.ts
new file mode 100644
index 0000000..231760f
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryExporterFactory.ts
@@ -0,0 +1,155 @@
+import { credentials as grpcCredentials } from "@grpc/grpc-js"
+import { OTLPLogExporter as OTLPLogExporterGRPC } from "@opentelemetry/exporter-logs-otlp-grpc"
+import { OTLPLogExporter as OTLPLogExporterHTTP } from "@opentelemetry/exporter-logs-otlp-http"
+import { OTLPLogExporter as OTLPLogExporterProto } from "@opentelemetry/exporter-logs-otlp-proto"
+import { OTLPMetricExporter as OTLPMetricExporterGRPC } from "@opentelemetry/exporter-metrics-otlp-grpc"
+import { OTLPMetricExporter as OTLPMetricExporterHTTP } from "@opentelemetry/exporter-metrics-otlp-http"
+import { OTLPMetricExporter as OTLPMetricExporterProto } from "@opentelemetry/exporter-metrics-otlp-proto"
+import { ConsoleLogRecordExporter, LogRecordExporter } from "@opentelemetry/sdk-logs"
+import { ConsoleMetricExporter, MetricReader, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics"
+import { Logger } from "@/shared/services/Logger"
+import { wrapLogsExporterWithDiagnostics, wrapMetricsExporterWithDiagnostics } from "./otel-exporter-diagnostics"
+
+/**
+ * Check if debug diagnostics are enabled
+ */
+function isDebugEnabled(): boolean {
+	return process.env.TEL_DEBUG_DIAGNOSTICS === "true" || process.env.IS_DEV === "true"
+}
+
+/**
+ * Create a console log exporter
+ */
+export function createConsoleLogExporter(): ConsoleLogRecordExporter {
+	return new ConsoleLogRecordExporter()
+}
+
+function ensurePathSuffix(url: URL, suffix: string): void {
+	const pathname = url.pathname
+	const normalizedPathname = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname
+	url.pathname = normalizedPathname
+	if (!normalizedPathname.endsWith(suffix)) {
+		url.pathname = `${normalizedPathname}${suffix}`
+	}
+}
+
+/**
+ * Create an OTLP log exporter based on protocol
+ */
+export function createOTLPLogExporter(
+	protocol: string,
+	endpoint: string,
+	insecure: boolean,
+	headers?: Record<string, string>,
+): LogRecordExporter | null {
+	try {
+		let exporter: any = null
+		const logsUrl = new URL(endpoint)
+		ensurePathSuffix(logsUrl, "/v1/logs")
+
+		switch (protocol) {
+			case "grpc": {
+				const grpcEndpoint = endpoint.replace(/^https?:\/\//, "")
+				const credentials = insecure ? grpcCredentials.createInsecure() : grpcCredentials.createSsl()
+
+				exporter = new OTLPLogExporterGRPC({
+					url: grpcEndpoint,
+					credentials: credentials,
+					headers,
+				})
+				break
+			}
+			case "http/json": {
+				exporter = new OTLPLogExporterHTTP({ url: logsUrl.toString(), headers })
+				break
+			}
+			case "http/protobuf": {
+				exporter = new OTLPLogExporterProto({ url: logsUrl.toString(), headers })
+				break
+			}
+			default:
+				Logger.warn(`[OTEL] Unknown OTLP protocol for logs: ${protocol}`)
+				return null
+		}
+
+		// Wrap with diagnostics if debug is enabled
+		if (isDebugEnabled()) {
+			wrapLogsExporterWithDiagnostics(exporter, protocol, logsUrl.toString())
+		}
+
+		return exporter
+	} catch (error) {
+		Logger.error("[OTEL] Error creating OTLP log exporter:", error)
+		return null
+	}
+}
+
+/**
+ * Create a console metric reader with exporter
+ */
+export function createConsoleMetricReader(intervalMs: number, timeoutMs: number): MetricReader {
+	const exporter = new ConsoleMetricExporter()
+	return new PeriodicExportingMetricReader({
+		exporter,
+		exportIntervalMillis: intervalMs,
+		exportTimeoutMillis: timeoutMs,
+	})
+}
+
+/**
+ * Create an OTLP metric reader with exporter based on protocol
+ */
+export function createOTLPMetricReader(
+	protocol: string,
+	endpoint: string,
+	insecure: boolean,
+	intervalMs: number,
+	timeoutMs: number,
+	headers?: Record<string, string>,
+): MetricReader | null {
+	try {
+		let exporter: any = null
+
+		const metricsUrl = new URL(endpoint)
+		ensurePathSuffix(metricsUrl, "/v1/metrics")
+
+		switch (protocol) {
+			case "grpc": {
+				const grpcEndpoint = endpoint.replace(/^https?:\/\//, "")
+				const credentials = insecure ? grpcCredentials.createInsecure() : grpcCredentials.createSsl()
+
+				exporter = new OTLPMetricExporterGRPC({
+					url: grpcEndpoint,
+					credentials: credentials,
+					headers,
+				})
+				break
+			}
+			case "http/json": {
+				exporter = new OTLPMetricExporterHTTP({ url: metricsUrl.toString(), headers })
+				break
+			}
+			case "http/protobuf": {
+				exporter = new OTLPMetricExporterProto({ url: metricsUrl.toString(), headers })
+				break
+			}
+			default:
+				Logger.warn(`[OTEL] Unknown OTLP protocol for metrics: ${protocol}`)
+				return null
+		}
+
+		// Wrap with diagnostics if debug is enabled
+		if (isDebugEnabled()) {
+			wrapMetricsExporterWithDiagnostics(exporter, protocol, metricsUrl.toString())
+		}
+
+		return new PeriodicExportingMetricReader({
+			exporter,
+			exportIntervalMillis: intervalMs,
+			exportTimeoutMillis: timeoutMs,
+		})
+	} catch (error) {
+		Logger.error("[OTEL] Error creating OTLP metric reader:", error)
+		return null
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryTelemetryProvider.ts b/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryTelemetryProvider.ts
new file mode 100644
index 0000000..018850f
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/opentelemetry/OpenTelemetryTelemetryProvider.ts
@@ -0,0 +1,426 @@
+import { Meter } from "@opentelemetry/api"
+import type { Logger as OTELLogger } from "@opentelemetry/api-logs"
+import { LoggerProvider } from "@opentelemetry/sdk-logs"
+import { MeterProvider } from "@opentelemetry/sdk-metrics"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostProvider } from "@/hosts/host-provider"
+import { getErrorLevelFromString } from "@/services/error"
+import { getDistinctId, setDistinctId } from "@/services/logging/distinctId"
+import { Setting } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import type { ClineAccountUserInfo } from "../../../auth/AuthService"
+import type { ITelemetryProvider, TelemetryProperties, TelemetrySettings } from "../ITelemetryProvider"
+
+/**
+ * OpenTelemetry implementation of the telemetry provider interface.
+ * Handles metrics and event logging using OpenTelemetry standards.
+ */
+export class OpenTelemetryTelemetryProvider implements ITelemetryProvider {
+	private meter: Meter | null = null
+	private logger: OTELLogger | null = null
+	private telemetrySettings: TelemetrySettings
+	private userAttributes: Record<string, string> = {}
+	// Lazy instrument caches for metrics
+	private counters = new Map<string, ReturnType<Meter["createCounter"]>>()
+	private histograms = new Map<string, ReturnType<Meter["createHistogram"]>>()
+	private gauges = new Map<string, ReturnType<Meter["createObservableGauge"]>>()
+	private gaugeValues = new Map<string, Map<string, { value: number; attributes?: TelemetryProperties }>>()
+
+	private meterProvider: MeterProvider | null = null
+	private loggerProvider: LoggerProvider | null = null
+
+	readonly name: string
+	private bypassUserSettings: boolean
+
+	constructor(
+		meterProvider: MeterProvider | null,
+		loggerProvider: LoggerProvider | null,
+		{ name, bypassUserSettings }: { name?: string; bypassUserSettings: boolean },
+	) {
+		this.name = name || "OpenTelemetryProvider"
+		this.bypassUserSettings = bypassUserSettings
+
+		// Initialize telemetry settings
+		this.telemetrySettings = {
+			hostEnabled: true,
+			level: "all",
+		}
+
+		if (meterProvider) {
+			this.meter = meterProvider.getMeter("cline")
+			this.meterProvider = meterProvider
+		}
+
+		if (loggerProvider) {
+			this.logger = loggerProvider.getLogger("cline")
+			this.loggerProvider = loggerProvider
+		}
+
+		// Log initialization status
+		const loggerReady = !!this.logger
+		const meterReady = !!this.meter
+		if (loggerReady || meterReady) {
+			Logger.log(`[OTEL] Provider initialized - Logger: ${loggerReady}, Meter: ${meterReady}`)
+		}
+	}
+
+	public async initialize(): Promise<OpenTelemetryTelemetryProvider> {
+		if (this.bypassUserSettings) {
+			return this
+		}
+
+		// Listen for host telemetry changes
+		HostProvider.env.subscribeToTelemetrySettings(
+			{},
+			{
+				onResponse: (event: { isEnabled: Setting }) => {
+					const hostEnabled = event.isEnabled === Setting.ENABLED || event.isEnabled === Setting.UNSUPPORTED
+					this.telemetrySettings.hostEnabled = hostEnabled
+				},
+			},
+		)
+
+		// Check host-specific telemetry setting (e.g. VS Code setting)
+		const hostSettings = await HostProvider.env.getTelemetrySettings({})
+		if (hostSettings.isEnabled === Setting.DISABLED) {
+			this.telemetrySettings.hostEnabled = false
+		}
+
+		this.telemetrySettings.level = await this.getTelemetryLevel()
+		return this
+	}
+
+	async forceFlush() {
+		await Promise.all([this.meterProvider?.forceFlush(), this.loggerProvider?.forceFlush()])
+	}
+
+	public log(event: string, properties?: TelemetryProperties): void {
+		if (!this.isEnabled() || this.telemetrySettings.level === "off") {
+			return
+		}
+
+		// Filter events based on telemetry level
+		if (this.telemetrySettings.level === "error") {
+			if (!event.includes("error")) {
+				return
+			}
+		}
+
+		// Record log event (primary path)
+		if (this.logger) {
+			this.logger.emit({
+				severityText: "INFO",
+				body: event,
+				attributes: {
+					distinct_id: getDistinctId(),
+					...this.flattenProperties(properties),
+					...this.userAttributes,
+				},
+			})
+		}
+	}
+
+	public logRequired(event: string, properties?: TelemetryProperties): void {
+		// Required events always go through regardless of settings
+		if (this.logger) {
+			this.logger.emit({
+				severityText: "INFO",
+				body: event,
+				attributes: {
+					distinct_id: getDistinctId(),
+					_required: true,
+					...this.flattenProperties(properties),
+					...this.userAttributes,
+				},
+			})
+		}
+	}
+
+	public identifyUser(userInfo: ClineAccountUserInfo, properties: TelemetryProperties = {}): void {
+		if (!this.isEnabled() || !userInfo) {
+			return
+		}
+
+		// Always refresh cached user/org attributes so subsequent logs
+		// include up-to-date organization context (e.g. after org switch
+		// or extension restart with the same user ID).
+		this.userAttributes = this.buildUserAttributes(userInfo, properties)
+
+		const distinctId = getDistinctId()
+
+		// Only emit identification event and update distinct ID when the
+		// user ID actually changes (first login or user switch).
+		if (userInfo.id !== distinctId) {
+			if (this.logger) {
+				this.logger.emit({
+					severityText: "INFO",
+					body: "user_identified",
+					attributes: {
+						...this.userAttributes,
+						alias: distinctId,
+					},
+				})
+			}
+
+			// Ensure distinct ID is updated so that we will not identify the user again
+			setDistinctId(userInfo.id)
+		}
+	}
+
+	/**
+	 * Build a flat record of user and organization attributes for use as
+	 * OpenTelemetry log/event attributes.
+	 */
+	private buildUserAttributes(userInfo: ClineAccountUserInfo, properties: TelemetryProperties = {}): Record<string, string> {
+		const activeOrg = userInfo.organizations?.find((org) => org.active)
+
+		return {
+			user_id: userInfo.id,
+			user_name: userInfo.displayName || "",
+
+			...(activeOrg && {
+				organization_id: activeOrg.organizationId,
+				organization_name: activeOrg.name,
+				member_id: activeOrg.memberId,
+				member_role: activeOrg.roles[0] || "member",
+			}),
+			...this.flattenProperties(properties),
+		}
+	}
+
+	public isEnabled(): boolean {
+		return (
+			this.bypassUserSettings ||
+			(StateManager.get().getGlobalSettingsKey("telemetrySetting") !== "disabled" && this.telemetrySettings.hostEnabled)
+		)
+	}
+
+	public getSettings(): TelemetrySettings {
+		return { ...this.telemetrySettings }
+	}
+
+	/**
+	 * Record a counter metric (cumulative value that only increases)
+	 * Lazy creation - only creates the counter on first use if meter is available.
+	 */
+	public recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.meter || (!required && !this.isEnabled())) {
+			return
+		}
+
+		let counter = this.counters.get(name)
+		if (!counter) {
+			const options = description ? { description } : undefined
+			counter = this.meter.createCounter(name, options)
+			this.counters.set(name, counter)
+			Logger.log(`[OTEL] Created counter: ${name}`)
+		}
+
+		counter.add(value, this.flattenProperties(attributes))
+	}
+
+	/**
+	 * Record a histogram metric (distribution of values for percentile analysis)
+	 * Lazy creation - only creates the histogram on first use if meter is available.
+	 */
+	public recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.meter || (!required && !this.isEnabled())) {
+			return
+		}
+
+		let histogram = this.histograms.get(name)
+		if (!histogram) {
+			const options = description ? { description } : undefined
+			histogram = this.meter.createHistogram(name, options)
+			this.histograms.set(name, histogram)
+			Logger.log(`[OTEL] Created histogram: ${name}`)
+		}
+
+		histogram.record(value, this.flattenProperties(attributes))
+	}
+
+	/**
+	 * Record a gauge metric (point-in-time value that can go up or down)
+	 * Lazy creation - creates an observable gauge that reads from stored values
+	 */
+	public recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.meter || (!required && !this.isEnabled())) {
+			return
+		}
+
+		const attrKey = attributes ? JSON.stringify(attributes) : ""
+
+		const existingSeries = this.gaugeValues.get(name)
+
+		if (value === null) {
+			if (existingSeries) {
+				existingSeries.delete(attrKey)
+				if (existingSeries.size === 0) {
+					this.gaugeValues.delete(name)
+					this.gauges.delete(name)
+				}
+			}
+			return
+		}
+
+		let series = existingSeries
+		if (!series) {
+			series = new Map()
+			this.gaugeValues.set(name, series)
+		}
+
+		if (!this.gauges.has(name)) {
+			const options = description ? { description } : undefined
+			const gauge = this.meter.createObservableGauge(name, options)
+
+			gauge.addCallback((observableResult) => {
+				const snapshot = this.snapshotGaugeSeries(name)
+				if (snapshot.length === 0) {
+					return
+				}
+				for (const data of snapshot) {
+					observableResult.observe(data.value, this.flattenProperties(data.attributes))
+				}
+			})
+
+			this.gauges.set(name, gauge)
+			Logger.log(`[OTEL] Created gauge: ${name}`)
+		}
+
+		series.set(attrKey, { value, attributes })
+	}
+
+	private snapshotGaugeSeries(name: string): Array<{ value: number; attributes?: TelemetryProperties }> {
+		const series = this.gaugeValues.get(name)
+		if (!series) {
+			return []
+		}
+		const snapshot: Array<{ value: number; attributes?: TelemetryProperties }> = []
+		for (const data of series.values()) {
+			snapshot.push({
+				value: data.value,
+				attributes: data.attributes ? { ...data.attributes } : undefined,
+			})
+		}
+		return snapshot
+	}
+
+	public async dispose(): Promise<void> {
+		// OpenTelemetry client provider handles shutdown
+		// Individual providers don't need to do anything
+	}
+
+	/**
+	 * Get the current telemetry level from VS Code settings
+	 */
+	private async getTelemetryLevel(): Promise<TelemetrySettings["level"]> {
+		if (this.bypassUserSettings) {
+			return "all"
+		}
+
+		const hostSettings = await HostProvider.env.getTelemetrySettings({})
+		if (hostSettings.isEnabled === Setting.DISABLED) {
+			return "off"
+		}
+		return getErrorLevelFromString(hostSettings.errorLevel)
+	}
+
+	/**
+	 * Flatten nested properties into dot-notation strings for OpenTelemetry attributes.
+	 * OpenTelemetry attributes must be primitives (string, number, boolean).
+	 * Adds protection against circular references, prototype pollution, deep graphs,
+	 * and limits array sizes to avoid performance issues.
+	 */
+	private flattenProperties(
+		properties?: TelemetryProperties,
+		prefix = "",
+		seen: WeakSet<object> = new WeakSet(),
+		depth = 0,
+	): Record<string, string | number | boolean> {
+		if (!properties) {
+			return {}
+		}
+
+		const flattened: Record<string, string | number | boolean> = {}
+		const MAX_ARRAY_SIZE = 100
+		const MAX_DEPTH = 10
+
+		for (const [key, value] of Object.entries(properties)) {
+			// Skip prototype pollution vectors
+			if (key === "__proto__" || key === "constructor" || key === "prototype") {
+				continue
+			}
+
+			const fullKey = prefix ? `${prefix}.${key}` : key
+
+			if (value === null || value === undefined) {
+				flattened[fullKey] = String(value)
+			} else if (Array.isArray(value)) {
+				// Limit array size to prevent performance issues
+				const limited = value.length > MAX_ARRAY_SIZE ? value.slice(0, MAX_ARRAY_SIZE) : value
+				try {
+					flattened[fullKey] = JSON.stringify(limited)
+				} catch {
+					flattened[fullKey] = "[UnserializableArray]"
+				}
+				if (value.length > MAX_ARRAY_SIZE) {
+					flattened[`${fullKey}_truncated`] = true
+					flattened[`${fullKey}_original_length`] = value.length
+				}
+			} else if (typeof value === "object") {
+				// Handle special objects
+				if (value instanceof Date) {
+					flattened[fullKey] = value.toISOString()
+					continue
+				}
+				if (value instanceof Error) {
+					flattened[fullKey] = value.message
+					continue
+				}
+
+				// Check for circular references
+				if (seen.has(value as object)) {
+					flattened[fullKey] = "[Circular]"
+					continue
+				}
+				// Depth guard
+				if (depth >= MAX_DEPTH) {
+					flattened[fullKey] = "[MaxDepthExceeded]"
+					continue
+				}
+
+				seen.add(value as object)
+				Object.assign(flattened, this.flattenProperties(value as TelemetryProperties, fullKey, seen, depth + 1))
+			} else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+				flattened[fullKey] = value
+			} else {
+				// Fallback: stringify unknown types
+				try {
+					flattened[fullKey] = JSON.stringify(value as unknown as object)
+				} catch {
+					flattened[fullKey] = String(value)
+				}
+			}
+		}
+
+		return flattened
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/providers/opentelemetry/__tests__/OpenTelemetryTelemetryProvider.test.ts b/apps/vscode/src/services/telemetry/providers/opentelemetry/__tests__/OpenTelemetryTelemetryProvider.test.ts
new file mode 100644
index 0000000..d9b82c4
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/opentelemetry/__tests__/OpenTelemetryTelemetryProvider.test.ts
@@ -0,0 +1,239 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { InMemoryLogRecordExporter, LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs"
+import { expect } from "chai"
+import * as sinon from "sinon"
+import type { ClineAccountUserInfo } from "@/services/auth/AuthService"
+import * as actualDistinctIdModule from "@/services/logging/distinctId"
+
+// bun loads real ESM, so sinon cannot stub the `@/services/logging/distinctId`
+// namespace exports ("ES Modules cannot be stubbed"). Inject module-level sinon
+// stubs via mock.module so the full sinon stub API keeps working.
+const getDistinctIdStub: sinon.SinonStub = sinon.stub()
+const setDistinctIdStub: sinon.SinonStub = sinon.stub()
+const distinctIdMock = () => ({
+	...actualDistinctIdModule,
+	getDistinctId: getDistinctIdStub,
+	setDistinctId: setDistinctIdStub,
+})
+mock.module("@/services/logging/distinctId", distinctIdMock)
+mock.module("@services/logging/distinctId", distinctIdMock)
+
+import { OpenTelemetryTelemetryProvider } from "../OpenTelemetryTelemetryProvider"
+
+function makeUserInfo(
+	overrides: Partial<ClineAccountUserInfo> & { orgOverrides?: Record<string, unknown> } = {},
+): ClineAccountUserInfo {
+	const { orgOverrides, ...rest } = overrides
+	return {
+		id: "user-1",
+		displayName: "Test User",
+		email: "test@example.com",
+		createdAt: new Date().toISOString(),
+		organizations: [
+			{
+				active: true,
+				memberId: "member-1",
+				name: "Org A",
+				organizationId: "org-a",
+				roles: ["admin"],
+				...(orgOverrides ?? {}),
+			},
+		],
+		...rest,
+	}
+}
+
+describe("OpenTelemetryTelemetryProvider.identifyUser", () => {
+	let logExporter: InMemoryLogRecordExporter
+	let loggerProvider: LoggerProvider
+	let provider: OpenTelemetryTelemetryProvider
+
+	beforeEach(() => {
+		logExporter = new InMemoryLogRecordExporter()
+		loggerProvider = new LoggerProvider()
+		loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(logExporter))
+
+		provider = new OpenTelemetryTelemetryProvider(null, loggerProvider, {
+			name: "test-otel",
+			bypassUserSettings: true,
+		})
+
+		// Reset the module-level sinon stubs (injected via mock.module above).
+		getDistinctIdStub.reset()
+		setDistinctIdStub.reset()
+	})
+
+	afterEach(() => {
+		sinon.restore()
+		getDistinctIdStub.reset()
+		setDistinctIdStub.reset()
+	})
+
+	it("should emit user_identified log and update distinct ID when ID changes", () => {
+		getDistinctIdStub.returns("machine-id-123")
+
+		const userInfo = makeUserInfo()
+		provider.identifyUser(userInfo)
+
+		// Should have emitted user_identified
+		const records = logExporter.getFinishedLogRecords()
+		expect(records.length, "Should emit exactly one log record").to.equal(1)
+		expect(records[0].body).to.equal("user_identified")
+
+		// Should include org attributes
+		const attrs = records[0].attributes
+		expect(attrs.user_id).to.equal("user-1")
+		expect(attrs.organization_id).to.equal("org-a")
+		expect(attrs.organization_name).to.equal("Org A")
+		expect(attrs.member_id).to.equal("member-1")
+		expect(attrs.member_role).to.equal("admin")
+		expect(attrs.alias).to.equal("machine-id-123")
+
+		// Should update distinct ID
+		expect(setDistinctIdStub.calledOnceWith("user-1"), "Should call setDistinctId with user ID").to.be.true
+	})
+
+	it("should refresh userAttributes even when distinct ID already matches (no new identify log)", () => {
+		// Simulate: user already identified (distinct ID == user ID)
+		getDistinctIdStub.returns("user-1")
+
+		const userInfo = makeUserInfo()
+		provider.identifyUser(userInfo)
+
+		// Should NOT emit user_identified log
+		const records = logExporter.getFinishedLogRecords()
+		expect(records.length, "Should not emit identify log when distinct ID matches").to.equal(0)
+
+		// Should NOT call setDistinctId
+		expect(setDistinctIdStub.notCalled, "Should not call setDistinctId when ID already matches").to.be.true
+
+		// Now emit a regular log and verify org attributes are present
+		provider.log("test_event", { custom: "value" })
+
+		const logRecords = logExporter.getFinishedLogRecords()
+		expect(logRecords.length, "Should emit one log record for test_event").to.equal(1)
+		expect(logRecords[0].body).to.equal("test_event")
+
+		const attrs = logRecords[0].attributes
+		expect(attrs.organization_id, "organization_id should be present in subsequent logs").to.equal("org-a")
+		expect(attrs.organization_name, "organization_name should be present").to.equal("Org A")
+		expect(attrs.member_id, "member_id should be present").to.equal("member-1")
+		expect(attrs.user_id, "user_id should be present").to.equal("user-1")
+	})
+
+	it("should refresh org attributes when active org changes (same user ID)", () => {
+		// First identification with Org A
+		getDistinctIdStub.returns("user-1")
+
+		const userInfoOrgA = makeUserInfo()
+		provider.identifyUser(userInfoOrgA)
+
+		// Emit a log to capture Org A attributes
+		provider.log("event_with_org_a")
+		let records = logExporter.getFinishedLogRecords()
+		expect(records.length).to.equal(1)
+		expect(records[0].attributes.organization_id).to.equal("org-a")
+		expect(records[0].attributes.organization_name).to.equal("Org A")
+
+		// Clear exporter for next assertion
+		logExporter.reset()
+
+		// Now switch to Org B (same user ID)
+		const userInfoOrgB = makeUserInfo({
+			orgOverrides: {
+				organizationId: "org-b",
+				name: "Org B",
+				memberId: "member-2",
+				roles: ["viewer", "editor"],
+			},
+		})
+		provider.identifyUser(userInfoOrgB)
+
+		// Should NOT emit user_identified (same user ID)
+		records = logExporter.getFinishedLogRecords()
+		expect(records.length, "Should not emit identify log on org switch with same user ID").to.equal(0)
+
+		// Emit a log and verify Org B attributes
+		provider.log("event_with_org_b")
+		records = logExporter.getFinishedLogRecords()
+		expect(records.length).to.equal(1)
+		expect(records[0].attributes.organization_id, "Should reflect new org ID").to.equal("org-b")
+		expect(records[0].attributes.organization_name, "Should reflect new org name").to.equal("Org B")
+		expect(records[0].attributes.member_id, "Should reflect new member ID").to.equal("member-2")
+		expect(records[0].attributes.member_role, "Should reflect new role").to.equal("viewer")
+	})
+
+	it("should handle user with no active organization", () => {
+		getDistinctIdStub.returns("user-1")
+
+		const userInfo: ClineAccountUserInfo = {
+			id: "user-1",
+			displayName: "Solo User",
+			email: "solo@example.com",
+			createdAt: new Date().toISOString(),
+			organizations: [],
+		}
+		provider.identifyUser(userInfo)
+
+		// Emit a log and verify no org attributes leak from previous state
+		provider.log("event_no_org")
+		const records = logExporter.getFinishedLogRecords()
+		expect(records.length).to.equal(1)
+
+		const attrs = records[0].attributes
+		expect(attrs.user_id).to.equal("user-1")
+		expect(attrs.user_name).to.equal("Solo User")
+		expect(attrs.organization_id, "organization_id should not be present").to.equal(undefined)
+		expect(attrs.organization_name, "organization_name should not be present").to.equal(undefined)
+		expect(attrs.member_id, "member_id should not be present").to.equal(undefined)
+	})
+
+	it("should clear stale org attributes when switching from org to no-org", () => {
+		getDistinctIdStub.returns("user-1")
+
+		// First: identify with an org
+		provider.identifyUser(makeUserInfo())
+		provider.log("with_org")
+		let records = logExporter.getFinishedLogRecords()
+		expect(records[0].attributes.organization_id).to.equal("org-a")
+
+		logExporter.reset()
+
+		// Second: identify same user but no active org
+		const userNoOrg: ClineAccountUserInfo = {
+			id: "user-1",
+			displayName: "Test User",
+			email: "test@example.com",
+			createdAt: new Date().toISOString(),
+			organizations: [
+				{
+					active: false,
+					memberId: "member-1",
+					name: "Org A",
+					organizationId: "org-a",
+					roles: ["admin"],
+				},
+			],
+		}
+		provider.identifyUser(userNoOrg)
+
+		provider.log("without_org")
+		records = logExporter.getFinishedLogRecords()
+		expect(records.length).to.equal(1)
+		expect(records[0].attributes.organization_id, "Stale org_id should be cleared").to.equal(undefined)
+		expect(records[0].attributes.organization_name, "Stale org_name should be cleared").to.equal(undefined)
+	})
+
+	it("should include additional properties passed to identifyUser", () => {
+		getDistinctIdStub.returns("machine-id")
+
+		provider.identifyUser(makeUserInfo(), { extension_version: "1.2.3", custom_prop: "hello" })
+
+		// Check the identify log includes the properties
+		const records = logExporter.getFinishedLogRecords()
+		expect(records.length).to.equal(1)
+		expect(records[0].attributes.extension_version).to.equal("1.2.3")
+		expect(records[0].attributes.custom_prop).to.equal("hello")
+		expect(records[0].attributes.organization_id).to.equal("org-a")
+	})
+})
diff --git a/apps/vscode/src/services/telemetry/providers/opentelemetry/otel-exporter-diagnostics.ts b/apps/vscode/src/services/telemetry/providers/opentelemetry/otel-exporter-diagnostics.ts
new file mode 100644
index 0000000..a2af1ee
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/opentelemetry/otel-exporter-diagnostics.ts
@@ -0,0 +1,96 @@
+/**
+ * OpenTelemetry Exporter Diagnostic Utilities
+ *
+ * Provides minimal diagnostic logging for OTLP exporters when debug mode is enabled.
+ * Enable with: TEL_DEBUG_DIAGNOSTICS=true or IS_DEV=true
+ */
+
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Wraps a metrics exporter with minimal diagnostic logging
+ */
+export function wrapMetricsExporterWithDiagnostics(exporter: any, protocol: string, endpoint: string): void {
+	if (!exporter || typeof exporter.export !== "function") {
+		return
+	}
+
+	const originalExport = exporter.export.bind(exporter)
+	let exportCount = 0
+
+	exporter.export = (metrics: any, resultCallback: any) => {
+		exportCount++
+		const startTime = Date.now()
+
+		const wrappedCallback = (result: any) => {
+			const elapsed = Date.now() - startTime
+			const metricsCount = metrics?.resourceMetrics?.[0]?.scopeMetrics?.[0]?.metrics?.length || 0
+
+			if (result.code === 0) {
+				Logger.log(
+					`[OTEL METRICS] Export #${exportCount} OK - protocol=${protocol} url=${endpoint} count=${metricsCount} elapsed=${elapsed}ms`,
+				)
+			} else {
+				Logger.error(
+					`[OTEL METRICS] Export #${exportCount} FAILED - protocol=${protocol} url=${endpoint} elapsed=${elapsed}ms error="${result.error?.message || "unknown"}"`,
+				)
+			}
+
+			resultCallback(result)
+		}
+
+		try {
+			originalExport(metrics, wrappedCallback)
+		} catch (error) {
+			const elapsed = Date.now() - startTime
+			Logger.error(
+				`[OTEL METRICS] Export #${exportCount} EXCEPTION - elapsed=${elapsed}ms error="${error instanceof Error ? error.message : String(error)}"`,
+			)
+			throw error
+		}
+	}
+}
+
+/**
+ * Wraps a logs exporter with minimal diagnostic logging
+ */
+export function wrapLogsExporterWithDiagnostics(exporter: any, protocol: string, endpoint: string): void {
+	if (!exporter || typeof exporter.export !== "function") {
+		return
+	}
+
+	const originalExport = exporter.export.bind(exporter)
+	let exportCount = 0
+
+	exporter.export = (logs: any, resultCallback: any) => {
+		exportCount++
+		const startTime = Date.now()
+
+		const wrappedCallback = (result: any) => {
+			const elapsed = Date.now() - startTime
+			const logsCount = logs?.resourceLogs?.[0]?.scopeLogs?.[0]?.logRecords?.length || 0
+
+			if (result.code === 0) {
+				Logger.log(
+					`[OTEL LOGS] Export #${exportCount} OK - protocol=${protocol} url=${endpoint} count=${logsCount} elapsed=${elapsed}ms`,
+				)
+			} else {
+				Logger.error(
+					`[OTEL LOGS] Export #${exportCount} FAILED - protocol=${protocol} url=${endpoint} elapsed=${elapsed}ms error="${result.error?.message || "unknown"}"`,
+				)
+			}
+
+			resultCallback(result)
+		}
+
+		try {
+			originalExport(logs, wrappedCallback)
+		} catch (error) {
+			const elapsed = Date.now() - startTime
+			Logger.error(
+				`[OTEL LOGS] Export #${exportCount} EXCEPTION - elapsed=${elapsed}ms error="${error instanceof Error ? error.message : String(error)}"`,
+			)
+			throw error
+		}
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/providers/posthog/PostHogClientProvider.ts b/apps/vscode/src/services/telemetry/providers/posthog/PostHogClientProvider.ts
new file mode 100644
index 0000000..119eee8
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/posthog/PostHogClientProvider.ts
@@ -0,0 +1,86 @@
+import { type EventMessage, PostHog } from "posthog-node"
+import { ClineEndpoint } from "@/config"
+import { fetch } from "@/shared/net"
+import { posthogConfig } from "@/shared/services/config/posthog-config"
+import { Logger } from "@/shared/services/Logger"
+
+export class PostHogClientProvider {
+	private static _instance: PostHogClientProvider | null = null
+
+	public static getInstance(): PostHogClientProvider {
+		if (!PostHogClientProvider._instance) {
+			PostHogClientProvider._instance = new PostHogClientProvider()
+		}
+		return PostHogClientProvider._instance
+	}
+
+	public static getClient(): PostHog | null {
+		return PostHogClientProvider.getInstance().client
+	}
+
+	private readonly client: PostHog | null
+
+	private constructor() {
+		// Skip PostHog client initialization in self-hosted mode
+		if (ClineEndpoint.isSelfHosted()) {
+			this.client = null
+			return
+		}
+
+		// Initialize PostHog client
+		this.client = posthogConfig.apiKey
+			? new PostHog(posthogConfig.apiKey, {
+					host: posthogConfig.host,
+					fetch: (url, options) => fetch(url, options),
+					enableExceptionAutocapture: false, // This is only enabled for error services
+					before_send: (event) => PostHogClientProvider.eventFilter(event),
+				})
+			: null
+
+		if (this.client) {
+			Logger.log("PostHog client initialized")
+		}
+	}
+
+	/**
+	 * Filters PostHog events before they are sent.
+	 * For exceptions, we only capture those from the Cline extension.
+	 * this is specifically to avoid capturing errors from anything other than Cline
+	 */
+	static eventFilter(event: EventMessage | null) {
+		if (!event || event?.event !== "$exception") {
+			return event
+		}
+		const exceptionList = event.properties?.["$exception_list"]
+		if (!exceptionList?.length) {
+			return null
+		}
+
+		// Check if any exception is from Cline
+		for (let i = 0; i < exceptionList.length; i++) {
+			const stacktrace = exceptionList[i].stacktrace
+			// Fast check: error message contains "cline"
+			if (stacktrace?.value?.toLowerCase().includes("cline")) {
+				return event
+			}
+
+			const frames = stacktrace?.frames
+			if (frames?.length) {
+				for (let j = 0; j < frames.length; j++) {
+					const fileName = frames[j]?.filename
+					// The extension filename will include "saoudrizwan"
+					// The CLI filename will include "cline"
+					if (fileName?.includes("saoudrizwan") || fileName?.includes("cline")) {
+						return event
+					}
+				}
+			}
+		}
+
+		return null
+	}
+
+	public async dispose(): Promise<void> {
+		await this.client?.shutdown().catch((error) => Logger.error("Error shutting down PostHog client:", error))
+	}
+}
diff --git a/apps/vscode/src/services/telemetry/providers/posthog/PostHogTelemetryProvider.ts b/apps/vscode/src/services/telemetry/providers/posthog/PostHogTelemetryProvider.ts
new file mode 100644
index 0000000..015a8c0
--- /dev/null
+++ b/apps/vscode/src/services/telemetry/providers/posthog/PostHogTelemetryProvider.ts
@@ -0,0 +1,225 @@
+import { PostHog } from "posthog-node"
+import { StateManager } from "@/core/storage/StateManager"
+import { HostProvider } from "@/hosts/host-provider"
+import { getErrorLevelFromString } from "@/services/error"
+import { getDistinctId, setDistinctId } from "@/services/logging/distinctId"
+import { fetch } from "@/shared/net"
+import { Setting } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
+import { posthogConfig } from "../../../../shared/services/config/posthog-config"
+import type { ClineAccountUserInfo } from "../../../auth/AuthService"
+import type { ITelemetryProvider, TelemetryProperties, TelemetrySettings } from "../ITelemetryProvider"
+/**
+ * PostHog implementation of the telemetry provider interface
+ * Handles PostHog-specific analytics tracking
+ */
+export class PostHogTelemetryProvider implements ITelemetryProvider {
+	private client: PostHog
+	private telemetrySettings: TelemetrySettings
+	private isSharedClient: boolean
+	private optInCache: boolean
+
+	readonly name = "PostHogTelemetryProvider"
+
+	constructor(sharedClient?: PostHog) {
+		this.isSharedClient = !!sharedClient
+
+		// Use shared PostHog client if provided, otherwise create a new one
+		if (sharedClient) {
+			this.client = sharedClient
+		} else {
+			// Only create a new client if we have an API key
+			if (!posthogConfig.apiKey) {
+				throw new Error("PostHog API key is required to create a new client")
+			}
+			this.client = new PostHog(posthogConfig.apiKey, {
+				host: posthogConfig.host,
+				fetch: (url, options) => fetch(url, options),
+			})
+		}
+
+		// Initialize telemetry settings
+		this.optInCache = true
+		this.telemetrySettings = {
+			hostEnabled: true,
+			level: "all",
+		}
+	}
+	public async initialize(): Promise<PostHogTelemetryProvider> {
+		// Listen for host telemetry changes
+		HostProvider.env.subscribeToTelemetrySettings(
+			{},
+			{
+				onResponse: (event: { isEnabled: Setting }) => {
+					const hostEnabled = event.isEnabled === Setting.ENABLED || event.isEnabled === Setting.UNSUPPORTED
+					this.telemetrySettings.hostEnabled = hostEnabled
+				},
+			},
+		)
+
+		// Check host-specific telemetry setting (e.g. VS Code setting)
+		const hostSettings = await HostProvider.env.getTelemetrySettings({})
+		if (hostSettings.isEnabled === Setting.DISABLED) {
+			this.telemetrySettings.hostEnabled = false
+		}
+
+		this.telemetrySettings.level = await this.getTelemetryLevel()
+		return this
+	}
+
+	async forceFlush() {
+		return this.client.flush()
+	}
+
+	public log(event: string, properties?: TelemetryProperties): void {
+		if (!this.isEnabled() || this.telemetrySettings.level === "off") {
+			return
+		}
+
+		// Filter events based on telemetry level
+		if (this.telemetrySettings.level === "error") {
+			if (!event.includes("error")) {
+				return
+			}
+		}
+
+		this.client.capture({
+			distinctId: getDistinctId(),
+			event,
+			properties,
+		})
+	}
+
+	public logRequired(event: string, properties?: TelemetryProperties): void {
+		this.client.capture({
+			distinctId: getDistinctId(),
+			event,
+			properties: {
+				...properties,
+				_required: true, // Mark as required event
+			},
+		})
+	}
+
+	public identifyUser(userInfo: ClineAccountUserInfo, properties: TelemetryProperties = {}): void {
+		const distinctId = getDistinctId()
+		// Only identify user if telemetry is enabled and user ID is different than the currently set distinct ID
+		if (this.isEnabled() && userInfo && userInfo?.id !== distinctId) {
+			this.client.identify({
+				distinctId: userInfo.id,
+				properties: {
+					uuid: userInfo.id,
+					name: userInfo.displayName,
+					...properties,
+					alias: distinctId,
+				},
+			})
+			// Ensure distinct ID is updated so that we will not identify the user again
+			setDistinctId(userInfo.id)
+		}
+	}
+
+	public isEnabled(): boolean {
+		const isOptedIn = StateManager.get().getGlobalSettingsKey("telemetrySetting") !== "disabled"
+		const wasOptedIn = this.optInCache
+		try {
+			if (isOptedIn && !wasOptedIn) {
+				this.client.optIn()
+			}
+			if (!isOptedIn && wasOptedIn) {
+				this.client.optOut()
+			}
+		} catch (err) {
+			Logger.error("Failed to update the PostHog telemetry state", err)
+		}
+		this.optInCache = isOptedIn
+
+		return isOptedIn && this.telemetrySettings.hostEnabled
+	}
+
+	public getSettings(): TelemetrySettings {
+		return { ...this.telemetrySettings }
+	}
+
+	/**
+	 * Record a counter metric by converting to equivalent PostHog event
+	 * This maintains backward compatibility with existing dashboards
+	 */
+	public recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		_description?: string,
+		required = false,
+	): void {
+		if (!this.isEnabled() && !required) return
+
+		// Convert metric to event format for PostHog
+		// Most counters don't need individual events - they're aggregated in OpenTelemetry
+		// Only log significant counter events that have dashboard equivalents
+		if (name === "cline.tokens.input.total" || name === "cline.tokens.output.total") {
+			// These will be batched and emitted as a single "task.tokens" event
+			// Implementation will be added when we update captureTokenUsage
+		}
+	}
+
+	/**
+	 * Record a histogram metric by converting to equivalent PostHog event
+	 * Histograms track distributions, but PostHog events capture individual values
+	 */
+	public recordHistogram(
+		_name: string,
+		_value: number,
+		_attributes?: TelemetryProperties,
+		_description?: string,
+		_required = false,
+	): void {
+		// Histograms are for distribution analysis in OpenTelemetry
+		// PostHog gets the raw values through existing event capture methods
+		// No action needed here - events already capture these values
+	}
+
+	/**
+	 * Record a gauge metric by converting to equivalent PostHog event
+	 * Gauges track current state, which we can log as state change events
+	 */
+	public recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		_description?: string,
+		required = false,
+	): void {
+		if ((!this.isEnabled() && !required) || value === null) return
+
+		// Convert gauge updates to state change events
+		if (name === "cline.workspace.active_roots") {
+			this.log("workspace.roots_changed", {
+				count: value,
+				...attributes,
+			})
+		}
+	}
+
+	public async dispose(): Promise<void> {
+		// Only shut down the client if it's not shared (we own it)
+		if (!this.isSharedClient) {
+			try {
+				await this.client.shutdown()
+			} catch (error) {
+				Logger.error("Error shutting down PostHog client:", error)
+			}
+		}
+	}
+
+	/**
+	 * Get the current telemetry level from VS Code settings
+	 */
+	private async getTelemetryLevel(): Promise<TelemetrySettings["level"]> {
+		const hostSettings = await HostProvider.env.getTelemetrySettings({})
+		if (hostSettings.isEnabled === Setting.DISABLED) {
+			return "off"
+		}
+		return getErrorLevelFromString(hostSettings.errorLevel)
+	}
+}
diff --git a/apps/vscode/src/services/temp/ClineTempManager.ts b/apps/vscode/src/services/temp/ClineTempManager.ts
new file mode 100644
index 0000000..2da43a3
--- /dev/null
+++ b/apps/vscode/src/services/temp/ClineTempManager.ts
@@ -0,0 +1,218 @@
+/**
+ * ClineTempManager - Manages temporary files for Cline with automatic cleanup.
+ *
+ * Simple approach:
+ * - Uses a "cline" subdirectory inside the system temp dir (falls back to system temp if creation fails)
+ * - Cleans up files older than 50 hours on extension activation
+ * - Enforces 2GB total size cap to prevent disk bloat
+ * - Cross-platform (macOS, Windows, Linux)
+ */
+
+import * as fs from "fs"
+import * as os from "os"
+import * as path from "path"
+import { Logger } from "@/shared/services/Logger"
+
+// Configuration constants
+const MAX_TOTAL_SIZE_BYTES = 2 * 1024 * 1024 * 1024 // 2GB
+const MAX_FILE_AGE_MS = 50 * 60 * 60 * 1000 // 50 hours
+const CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1000 // 24 hours
+
+interface TempFileInfo {
+	path: string
+	size: number
+	mtime: number
+}
+
+/**
+ * Singleton manager for Cline's temporary files.
+ */
+class ClineTempManagerImpl {
+	private readonly tempDir: string
+	private cleanupIntervalId: NodeJS.Timeout | null = null
+
+	constructor() {
+		// Uses system temp directory with a dedicated "cline" subdirectory when possible:
+		// macOS: /var/folders/xx/.../T/cline
+		// Windows: C:\Users\{user}\AppData\Local\Temp\cline
+		// Linux: /tmp/cline
+		const baseTempDir = os.tmpdir()
+		const clineTempDir = path.join(baseTempDir, "cline")
+
+		try {
+			fs.mkdirSync(clineTempDir, { recursive: true })
+			this.tempDir = clineTempDir
+		} catch {
+			this.tempDir = baseTempDir
+		}
+	}
+
+	private ensureTempDirExists(): void {
+		try {
+			fs.mkdirSync(this.tempDir, { recursive: true })
+		} catch {
+			// If creation fails, we fall back to whatever tempDir currently is.
+		}
+	}
+
+	/**
+	 * Get the temp directory path.
+	 */
+	getTempDir(): string {
+		return this.tempDir
+	}
+
+	/**
+	 * Create a new temp file path with the given prefix.
+	 * Does NOT create the file - just returns the path.
+	 *
+	 * @param prefix Prefix for the filename (e.g., "large-output", "background")
+	 * @returns Full path to the temp file
+	 */
+	createTempFilePath(prefix: string): string {
+		this.ensureTempDirExists()
+		const filename = `${prefix}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}.log`
+		return path.join(this.tempDir, filename)
+	}
+
+	/**
+	 * Clean up old Cline temp files based on age and total size constraints.
+	 * Called on extension activation.
+	 *
+	 * Strategy:
+	 * 1. Scan the Cline temp directory
+	 * 2. Delete all files older than 50 hours
+	 * 3. If still over 2GB total, delete oldest files until under limit
+	 */
+	async cleanup(): Promise<{ deletedCount: number; freedBytes: number }> {
+		let deletedCount = 0
+		let freedBytes = 0
+
+		try {
+			this.ensureTempDirExists()
+
+			let files: string[]
+			try {
+				files = await fs.promises.readdir(this.tempDir)
+			} catch {
+				return { deletedCount: 0, freedBytes: 0 }
+			}
+
+			const fileInfos: TempFileInfo[] = []
+			for (const file of files) {
+				const filePath = path.join(this.tempDir, file)
+				try {
+					const stats = await fs.promises.stat(filePath)
+					if (stats.isFile()) {
+						fileInfos.push({
+							path: filePath,
+							size: stats.size,
+							mtime: stats.mtimeMs,
+						})
+					}
+				} catch {
+					// File might have been deleted by another process
+				}
+			}
+
+			const now = Date.now()
+			const remainingFiles: TempFileInfo[] = []
+
+			for (const fileInfo of fileInfos) {
+				const age = now - fileInfo.mtime
+				if (age > MAX_FILE_AGE_MS) {
+					try {
+						await fs.promises.unlink(fileInfo.path)
+						deletedCount++
+						freedBytes += fileInfo.size
+					} catch {
+						// File might have been deleted by another process
+					}
+				} else {
+					remainingFiles.push(fileInfo)
+				}
+			}
+
+			let totalSize = remainingFiles.reduce((sum, f) => sum + f.size, 0)
+			if (totalSize > MAX_TOTAL_SIZE_BYTES) {
+				remainingFiles.sort((a, b) => a.mtime - b.mtime)
+
+				for (const fileInfo of remainingFiles) {
+					if (totalSize <= MAX_TOTAL_SIZE_BYTES) {
+						break
+					}
+
+					try {
+						await fs.promises.unlink(fileInfo.path)
+						totalSize -= fileInfo.size
+						deletedCount++
+						freedBytes += fileInfo.size
+					} catch {
+						// File might have been deleted by another process
+					}
+				}
+			}
+
+			if (deletedCount > 0) {
+				Logger.info(`Cline temp cleanup: deleted ${deletedCount} files, freed ${Math.round(freedBytes / 1024 / 1024)}MB`)
+			}
+		} catch (error) {
+			Logger.error("Error during Cline temp cleanup", error)
+		}
+
+		return { deletedCount, freedBytes }
+	}
+
+	/**
+	 * Delete a specific temp file.
+	 *
+	 * @param filePath Path to the file to delete
+	 */
+	async deleteFile(filePath: string): Promise<void> {
+		try {
+			await fs.promises.unlink(filePath)
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+				Logger.error(`Failed to delete temp file: ${filePath}`, error)
+			}
+		}
+	}
+
+	/**
+	 * Start periodic cleanup every 24 hours.
+	 * Call this on extension activation.
+	 */
+	startPeriodicCleanup(): void {
+		// Don't start multiple intervals
+		if (this.cleanupIntervalId) {
+			return
+		}
+
+		this.cleanup().catch((error) => {
+			Logger.error("Failed to clean up temp files", error)
+		})
+
+		this.cleanupIntervalId = setInterval(() => {
+			this.cleanup().catch((error) => {
+				Logger.error("Periodic temp cleanup failed", error)
+			})
+		}, CLEANUP_INTERVAL_MS)
+
+		// Use unref() so this interval doesn't prevent Node from exiting
+		this.cleanupIntervalId.unref()
+	}
+
+	/**
+	 * Stop periodic cleanup.
+	 * Call this on extension deactivation.
+	 */
+	stopPeriodicCleanup(): void {
+		if (this.cleanupIntervalId) {
+			clearInterval(this.cleanupIntervalId)
+			this.cleanupIntervalId = null
+		}
+	}
+}
+
+// Export singleton instance
+export const ClineTempManager = new ClineTempManagerImpl()
diff --git a/apps/vscode/src/services/temp/index.ts b/apps/vscode/src/services/temp/index.ts
new file mode 100644
index 0000000..6242cc5
--- /dev/null
+++ b/apps/vscode/src/services/temp/index.ts
@@ -0,0 +1 @@
+export { ClineTempManager } from "./ClineTempManager"
diff --git a/apps/vscode/src/services/uri/SharedUriHandler.test.ts b/apps/vscode/src/services/uri/SharedUriHandler.test.ts
new file mode 100644
index 0000000..ee9e124
--- /dev/null
+++ b/apps/vscode/src/services/uri/SharedUriHandler.test.ts
@@ -0,0 +1,246 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { expect } from "chai"
+import * as fs from "fs/promises"
+import os from "os"
+import path from "path"
+import * as sinon from "sinon"
+import { WebviewProvider } from "@/core/webview"
+import * as actualWebhookHooks from "@/services/lg-cns-integration/webhook-hooks"
+import { Logger } from "@/shared/services/Logger"
+
+// bun loads real ESM, so sinon cannot stub the
+// `@/services/lg-cns-integration/webhook-hooks` namespace exports ("ES Modules
+// cannot be stubbed"). Inject module-level sinon stubs via mock.module so the
+// full sinon stub API keeps working.
+const writeLgWebhookConfigStub: sinon.SinonStub = sinon.stub()
+const writeLgWebhookHooksStub: sinon.SinonStub = sinon.stub()
+const webhookHooksMock = () => ({
+	...actualWebhookHooks,
+	writeLgWebhookConfig: writeLgWebhookConfigStub,
+	writeLgWebhookHooks: writeLgWebhookHooksStub,
+})
+mock.module("@/services/lg-cns-integration/webhook-hooks", webhookHooksMock)
+mock.module("@services/lg-cns-integration/webhook-hooks", webhookHooksMock)
+
+import { ErrorService } from "../error"
+import { SharedUriHandler } from "./SharedUriHandler"
+
+describe("SharedUriHandler", () => {
+	let sandbox: sinon.SinonSandbox
+	let handleOpenRouterCallbackStub: sinon.SinonStub
+	let handleAuthCallbackStub: sinon.SinonStub
+	let handleTaskCreationStub: sinon.SinonStub
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+
+		// Mock Logger methods to avoid HostProvider dependency
+		sandbox.stub(Logger, "info").returns()
+		sandbox.stub(Logger, "error").returns()
+		// Mock ErrorService to avoid telemetry dependency
+		const mockErrorService = {
+			logMessage: sandbox.stub(),
+			logException: sandbox.stub(),
+			toClineError: sandbox.stub(),
+			isEnabled: sandbox.stub().returns(false),
+			getSettings: sandbox.stub().returns({ enabled: false, hostEnabled: false }),
+			getProvider: sandbox.stub(),
+			dispose: sandbox.stub().resolves(),
+		}
+		sandbox.stub(ErrorService, "initialize").resolves(mockErrorService as any)
+		sandbox.stub(ErrorService, "get").returns(mockErrorService as any)
+
+		await ErrorService.initialize()
+
+		handleOpenRouterCallbackStub = sandbox.stub().resolves()
+		handleAuthCallbackStub = sandbox.stub().resolves()
+		handleTaskCreationStub = sandbox.stub().resolves()
+		const mockWebviewProvider = {
+			controller: {
+				handleOpenRouterCallback: handleOpenRouterCallbackStub,
+				handleAuthCallback: handleAuthCallbackStub,
+				handleTaskCreation: handleTaskCreationStub,
+			},
+		} as any
+		sandbox.stub(WebviewProvider, "getVisibleInstance").returns(mockWebviewProvider)
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe("handleUri", () => {
+		describe("OpenRouter callback handling", () => {
+			it("should successfully handle OpenRouter callback with code", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/openrouter?code=test123")
+
+				expect(result).to.be.true
+				sinon.assert.calledOnceWithExactly(handleOpenRouterCallbackStub, "test123")
+			})
+
+			it("should return false when OpenRouter code is missing", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/openrouter")
+
+				expect(result).to.be.false
+				expect(handleOpenRouterCallbackStub.called).to.be.false
+			})
+
+			it("should handle URL with plus signs in code parameter", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/openrouter?code=test+123+abc")
+
+				expect(result).to.be.true
+				// Plus signs in query params are preserved
+				sinon.assert.calledOnceWithExactly(handleOpenRouterCallbackStub, "test+123+abc")
+			})
+		})
+
+		describe("Auth callback handling", () => {
+			it("should successfully handle auth callback with idToken", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/auth?idToken=jwt123&provider=google")
+
+				expect(result).to.be.true
+				sinon.assert.calledOnceWithExactly(handleAuthCallbackStub, "jwt123", "google")
+			})
+
+			it("should successfully handle auth callback without provider", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/auth?idToken=jwt123")
+
+				expect(result).to.be.true
+				sinon.assert.calledOnceWithExactly(handleAuthCallbackStub, "jwt123", null)
+			})
+
+			it("should return false when idToken is missing", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/auth?provider=google")
+
+				expect(result).to.be.false
+				expect(handleAuthCallbackStub.called).to.be.false
+			})
+		})
+
+		describe("Unknown path handling", () => {
+			it("should return false for unknown paths", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/unknown?param=value")
+
+				expect(result).to.be.false
+				expect(handleAuthCallbackStub.called).to.be.false
+				expect(handleOpenRouterCallbackStub.called).to.be.false
+			})
+		})
+
+		describe("LG task URI handling", () => {
+			it("should setup webhook files and create task from prompt-file", async () => {
+				const webhookUrl = "https://example.com/api/updates"
+				const webhookToken = "token-123"
+				const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "lg-task-uri-"))
+				try {
+					const promptFilePath = path.join(tempDir, "lg-spec.md")
+					await fs.writeFile(promptFilePath, "Implement user registration flow", "utf-8")
+
+					const writeConfigStub = writeLgWebhookConfigStub
+					writeConfigStub.reset()
+					writeConfigStub.resolves()
+					const writeHooksStub = writeLgWebhookHooksStub
+					writeHooksStub.reset()
+					writeHooksStub.resolves()
+
+					const result = await SharedUriHandler.handleUri(
+						`vscode://cline.cline/lg-task?prompt-file=${encodeURIComponent(
+							promptFilePath,
+						)}&webhook-url=${encodeURIComponent(webhookUrl)}&webhook-token=${encodeURIComponent(webhookToken)}`,
+					)
+
+					expect(result).to.be.true
+					sinon.assert.calledOnce(handleTaskCreationStub)
+					const taskPrompt = handleTaskCreationStub.firstCall.args[0] as string
+					expect(taskPrompt).to.contain(promptFilePath)
+					expect(taskPrompt).to.contain("Implement user registration flow")
+					expect(taskPrompt).to.contain("re-read")
+					sinon.assert.calledOnceWithExactly(writeConfigStub, webhookUrl, webhookToken)
+					sinon.assert.calledOnce(writeHooksStub)
+				} finally {
+					await fs.rm(tempDir, { recursive: true, force: true })
+				}
+			})
+
+			it("should return false when LG task parameters are missing", async () => {
+				const writeConfigStub = writeLgWebhookConfigStub
+				writeConfigStub.reset()
+				writeConfigStub.resolves()
+				const writeHooksStub = writeLgWebhookHooksStub
+				writeHooksStub.reset()
+				writeHooksStub.resolves()
+				const result = await SharedUriHandler.handleUri(
+					"vscode://cline.cline/lg-task?prompt-file=%2Ftmp%2Fspec.md&webhook-url=https%3A%2F%2Fexample.com",
+				)
+
+				expect(result).to.be.false
+				expect(handleTaskCreationStub.called).to.be.false
+				expect(writeConfigStub.called).to.be.false
+				expect(writeHooksStub.called).to.be.false
+			})
+		})
+
+		describe("Error handling", () => {
+			it("should catch and log errors from controller methods", async () => {
+				handleOpenRouterCallbackStub.rejects(new Error("Controller error"))
+
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/openrouter?code=test123")
+
+				expect(result).to.be.false
+			})
+
+			it("should handle malformed URIs gracefully", async () => {
+				const result = await SharedUriHandler.handleUri("invalid://uri")
+
+				expect(result).to.be.false
+				expect(handleAuthCallbackStub.called).to.be.false
+				expect(handleOpenRouterCallbackStub.called).to.be.false
+			})
+		})
+
+		describe("Query parameter parsing", () => {
+			it("should correctly parse multiple query parameters", async () => {
+				const result = await SharedUriHandler.handleUri(
+					"vscode://cline.cline/auth?idToken=jwt123&provider=github&extra=param",
+				)
+
+				expect(result).to.be.true
+				sinon.assert.calledOnceWithExactly(handleAuthCallbackStub, "jwt123", "github")
+			})
+
+			it("should handle URL-encoded parameters", async () => {
+				const result = await SharedUriHandler.handleUri(
+					"vscode://cline.cline/auth?idToken=jwt%20with%20spaces&provider=google",
+				)
+
+				expect(result).to.be.true
+				// URLSearchParams should decode %20 to spaces
+				sinon.assert.calledOnceWithExactly(handleAuthCallbackStub, "jwt with spaces", "google")
+			})
+
+			it("should handle empty query string", async () => {
+				const result = await SharedUriHandler.handleUri("vscode://cline.cline/openrouter")
+
+				expect(result).to.be.false
+				expect(handleAuthCallbackStub.called).to.be.false
+				expect(handleOpenRouterCallbackStub.called).to.be.false
+			})
+		})
+
+		describe("Different URI schemes", () => {
+			it("should handle HTTP scheme URIs", async () => {
+				const result = await SharedUriHandler.handleUri("http://localhost:3000/openrouter?code=test123")
+
+				expect(result).to.be.true
+				sinon.assert.calledOnceWithExactly(handleOpenRouterCallbackStub, "test123")
+			})
+
+			it("should handle HTTPS scheme URIs", async () => {
+				const result = await SharedUriHandler.handleUri("https://example.com/auth?idToken=jwt123&provider=github")
+
+				expect(result).to.be.true
+				sinon.assert.calledOnceWithExactly(handleAuthCallbackStub, "jwt123", "github")
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/services/uri/SharedUriHandler.ts b/apps/vscode/src/services/uri/SharedUriHandler.ts
new file mode 100644
index 0000000..c748745
--- /dev/null
+++ b/apps/vscode/src/services/uri/SharedUriHandler.ts
@@ -0,0 +1,141 @@
+import fs from "fs/promises"
+import { WebviewProvider } from "@/core/webview"
+import { writeLgWebhookConfig, writeLgWebhookHooks } from "@/services/lg-cns-integration/webhook-hooks"
+import { Logger } from "@/shared/services/Logger"
+
+export const TASK_URI_PATH = "/task"
+export const LG_TASK_URI_PATH = "/lg-task"
+
+/**
+ * Shared URI handler that processes both VSCode URI events and HTTP server callbacks
+ */
+export class SharedUriHandler {
+	/**
+	 * Processes a URI and routes it to the appropriate handler
+	 * @param url The URI to process (can be from VSCode or converted from HTTP)
+	 * @returns Promise<boolean> indicating success (true) or failure (false)
+	 */
+	public static async handleUri(url: string): Promise<boolean> {
+		const parsedUrl = new URL(url)
+		const path = parsedUrl.pathname
+
+		// Create URLSearchParams from the query string, but preserve plus signs
+		// by replacing them with a placeholder before parsing
+		const queryString = parsedUrl.search.slice(1) // Remove leading '?'
+		const query = new URLSearchParams(queryString.replace(/\+/g, "%2B"))
+
+		Logger.info(
+			"SharedUriHandler: Processing URI:" +
+				JSON.stringify({
+					path: path,
+					query: query,
+					scheme: parsedUrl.protocol,
+				}),
+		)
+
+		const visibleWebview = WebviewProvider.getVisibleInstance()
+
+		if (!visibleWebview) {
+			Logger.warn("SharedUriHandler: No visible webview found")
+			return false
+		}
+
+		try {
+			switch (path) {
+				case "/openrouter": {
+					const code = query.get("code")
+					if (code) {
+						await visibleWebview.controller.handleOpenRouterCallback(code)
+						return true
+					}
+					Logger.warn("SharedUriHandler: Missing code parameter for OpenRouter callback")
+					return false
+				}
+				case "/requesty": {
+					const code = query.get("code")
+					if (code) {
+						await visibleWebview.controller.handleRequestyCallback(code)
+						return true
+					}
+					Logger.warn("SharedUriHandler: Missing code parameter for Requesty callback")
+					return false
+				}
+				case "/auth": {
+					const provider = query.get("provider")
+
+					Logger.info(`SharedUriHandler - Auth callback received for ${provider} - ${path}`)
+
+					const token = query.get("refreshToken") || query.get("idToken") || query.get("code")
+					if (token) {
+						await visibleWebview.controller.handleAuthCallback(token, provider)
+						return true
+					}
+					Logger.warn("SharedUriHandler: Missing idToken parameter for auth callback")
+					return false
+				}
+				case "/auth/oca": {
+					Logger.log("SharedUriHandler: Oca Auth callback received:", { path: path })
+
+					const code = query.get("code")
+					const state = query.get("state")
+
+					if (code && state) {
+						await visibleWebview.controller.handleOcaAuthCallback(code, state)
+						return true
+					}
+					Logger.warn("SharedUriHandler: Missing code parameter for auth callback")
+					return false
+				}
+				case TASK_URI_PATH: {
+					const prompt = query.get("prompt")
+					if (prompt) {
+						await visibleWebview.controller.handleTaskCreation(prompt)
+						return true
+					}
+					Logger.warn("SharedUriHandler: Missing prompt parameter for task creation")
+					return false
+				}
+				case LG_TASK_URI_PATH: {
+					const promptFile = query.get("prompt-file")
+					const webhookUrl = query.get("webhook-url")
+					const webhookToken = query.get("webhook-token")
+
+					if (!promptFile || !webhookUrl || !webhookToken) {
+						Logger.warn("SharedUriHandler: Missing required parameters for LG task creation")
+						return false
+					}
+
+					const specContents = await fs.readFile(promptFile, "utf-8")
+					const prompt = [
+						`The following file contains the development specification you must implement: ${promptFile}`,
+						"",
+						"Start by reading that file from disk. If context compaction happens later, re-read the same file path so you can continue tracking progress against the original requirements.",
+						"",
+						"For convenience, here is the current file content:",
+						"",
+						specContents,
+					].join("\n")
+					await writeLgWebhookConfig(webhookUrl, webhookToken)
+					await writeLgWebhookHooks()
+					await visibleWebview.controller.handleTaskCreation(prompt)
+					return true
+				}
+				case "/hicap": {
+					const code = query.get("code")
+					if (code) {
+						await visibleWebview.controller.handleHicapCallback(code)
+						return true
+					}
+					Logger.warn("SharedUriHandler: Missing code parameter for Hicap callback")
+					return false
+				}
+				default:
+					Logger.warn(`SharedUriHandler: Unknown path: ${path}`)
+					return false
+			}
+		} catch (error) {
+			Logger.error("SharedUriHandler: Error processing URI:", error)
+			return false
+		}
+	}
+}
diff --git a/apps/vscode/src/shared/AutoApprovalSettings.ts b/apps/vscode/src/shared/AutoApprovalSettings.ts
new file mode 100644
index 0000000..9a8a2b7
--- /dev/null
+++ b/apps/vscode/src/shared/AutoApprovalSettings.ts
@@ -0,0 +1,44 @@
+export interface AutoApprovalSettings {
+	// Version for race condition prevention (incremented on every change)
+	version: number
+	// Legacy field - kept for backward compatibility with older extension versions
+	// Auto-approve is now always enabled by default
+	enabled: boolean
+	// Legacy field - kept for backward compatibility with older extension versions
+	// Favorites feature has been removed
+	favorites: string[]
+	// Legacy field - kept for backward compatibility with older extension versions
+	// Max requests limit feature has been removed
+	maxRequests: number
+	// Individual action permissions
+	actions: {
+		readFiles: boolean // Read files and directories
+		readFilesExternally?: boolean // Legacy field - kept for backward compatibility with older extension versions
+		editFiles: boolean // Edit files
+		editFilesExternally?: boolean // Legacy field - kept for backward compatibility with older extension versions
+		executeSafeCommands?: boolean // Execute commands
+		executeAllCommands?: boolean // Legacy field - kept for backward compatibility with older extension versions
+		useBrowser: boolean // Use browser
+		useMcp: boolean // Use MCP servers
+	}
+	// Global settings
+	enableNotifications: boolean // Show notifications for approval and task completion
+}
+
+export const DEFAULT_AUTO_APPROVAL_SETTINGS: AutoApprovalSettings = {
+	version: 1,
+	enabled: true, // Legacy field - always true by default
+	favorites: [], // Legacy field - kept as empty array
+	maxRequests: 20, // Legacy field - kept for backward compatibility
+	actions: {
+		readFiles: true,
+		readFilesExternally: true,
+		editFiles: true,
+		editFilesExternally: true,
+		executeSafeCommands: false,
+		executeAllCommands: true,
+		useBrowser: true,
+		useMcp: true,
+	},
+	enableNotifications: false,
+}
diff --git a/apps/vscode/src/shared/BrowserSettings.ts b/apps/vscode/src/shared/BrowserSettings.ts
new file mode 100644
index 0000000..10d70a4
--- /dev/null
+++ b/apps/vscode/src/shared/BrowserSettings.ts
@@ -0,0 +1,34 @@
+export interface BrowserSettings {
+	// Viewport size settings
+	viewport: {
+		width: number
+		height: number
+	}
+	// Chrome installation to use
+	// chromeType: "chromium" | "system"
+	remoteBrowserHost?: string
+	remoteBrowserEnabled?: boolean
+	chromeExecutablePath?: string
+	disableToolUse?: boolean
+	customArgs?: string
+}
+
+export const DEFAULT_BROWSER_SETTINGS: BrowserSettings = {
+	viewport: {
+		width: 900,
+		height: 600,
+	},
+	remoteBrowserEnabled: false,
+	remoteBrowserHost: "http://localhost:9222",
+	chromeExecutablePath: "", // Changed from undefined to empty string
+	// chromeType: "chromium",
+	disableToolUse: true,
+	customArgs: "",
+}
+
+export const BROWSER_VIEWPORT_PRESETS = {
+	"Large Desktop (1280x800)": { width: 1280, height: 800 },
+	"Small Desktop (900x600)": { width: 900, height: 600 },
+	"Tablet (768x1024)": { width: 768, height: 1024 },
+	"Mobile (360x640)": { width: 360, height: 640 },
+} as const
diff --git a/apps/vscode/src/shared/ChatContent.ts b/apps/vscode/src/shared/ChatContent.ts
new file mode 100644
index 0000000..8ecd7aa
--- /dev/null
+++ b/apps/vscode/src/shared/ChatContent.ts
@@ -0,0 +1,5 @@
+export interface ChatContent {
+	message?: string
+	images?: string[]
+	files?: string[]
+}
diff --git a/apps/vscode/src/shared/ClineAccount.ts b/apps/vscode/src/shared/ClineAccount.ts
new file mode 100644
index 0000000..684f229
--- /dev/null
+++ b/apps/vscode/src/shared/ClineAccount.ts
@@ -0,0 +1,98 @@
+export interface UserResponse {
+	id: string
+	email: string
+	displayName: string
+	photoUrl: string
+	createdAt: string
+	updatedAt: string
+	organizations: [
+		{
+			active: boolean
+			memberId: string
+			name: string
+			organizationId: string
+			roles: ["admin" | "member" | "owner"]
+		},
+	]
+}
+
+export interface BalanceResponse {
+	balance: number
+	userId: string
+}
+
+export interface FeaturebaseTokenResponse {
+	featurebaseJwt: string
+}
+
+export interface UsageTransaction {
+	aiInferenceProviderName: string
+	aiModelName: string
+	aiModelTypeName: string
+	completionTokens: number
+	costUsd: number
+	createdAt: string
+	creditsUsed: number
+	generationId: string
+	id: string
+	metadata: {
+		additionalProp1: string
+		additionalProp2: string
+		additionalProp3: string
+	}
+	operation?: string
+	organizationId: string
+	promptTokens: number
+	totalTokens: number
+	userId: string
+}
+
+export interface PaymentTransaction {
+	paidAt: string
+	creatorId: string
+	amountCents: number
+	credits: number
+}
+
+export interface OrganizationBalanceResponse {
+	balance: number
+	organizationId: string
+}
+
+export interface OrganizationUsageTransaction {
+	aiInferenceProviderName: string
+	aiModelName: string
+	aiModelTypeName: string
+	completionTokens: number
+	costUsd: number
+	createdAt: string
+	creditsUsed: number
+	generationId: string
+	id: string
+	memberDisplayName: string
+	memberEmail: string
+	metadata: {
+		additionalProp1: string
+		additionalProp2: string
+		additionalProp3: string
+	}
+	operation?: string
+	organizationId: string
+	promptTokens: number
+	totalTokens: number
+	userId: string
+}
+
+interface UserRemoteConfigOrganization {
+	organizationId: string
+	name: string
+}
+
+export interface UserRemoteConfigDiscoveryResponse {
+	organizationId: string
+	value: string
+	organizations?: UserRemoteConfigOrganization[]
+}
+
+// Used in cline.ts provider and in webview-ui/src/components/chat/ChatRow.tsx to display the login button
+export const CLINE_ACCOUNT_AUTH_ERROR_MESSAGE = "Unauthorized: Please sign in to Cline before trying again."
diff --git a/apps/vscode/src/shared/ClineBanner.ts b/apps/vscode/src/shared/ClineBanner.ts
new file mode 100644
index 0000000..4aa84b7
--- /dev/null
+++ b/apps/vscode/src/shared/ClineBanner.ts
@@ -0,0 +1,62 @@
+/**
+ * Banner message types for Cline extension
+ */
+
+type BannerSeverity = "info" | "success" | "warning"
+type BannerPlacement = "top" | "bottom" | "welcome"
+
+export interface Banner {
+	id: string
+	titleMd: string
+	bodyMd: string
+	icon?: string
+	actions?: BannerAction[]
+
+	rulesJson: string
+	activeFrom?: string
+	activeTo?: string
+
+	severity?: BannerSeverity
+	placement?: BannerPlacement
+}
+
+export interface BannerAction {
+	action?: string
+	arg?: string
+	title?: string
+}
+
+export interface BannersResponse {
+	data: {
+		items: Banner[]
+		nextToken: string
+	}
+	success: boolean
+}
+
+/**
+ * Audience targeting options
+ */
+type BannerAudience = "all" | "team_admin_only" | "team_members" | "personal_only"
+
+/**
+ * Rules that can be evaluated for banner targeting
+ */
+export interface BannerRules {
+	/** Target specific IDEs (e.g., "vscode", "jetbrains") */
+	ide?: string[]
+	/** Target specific auth providers (e.g., "firebase", "workos") */
+	auth?: string[]
+	/** Target employees only */
+	employee_only?: boolean
+	/** Target users with specific API providers (e.g., "anthropic", "openai") */
+	providers?: string[]
+	/** Target specific audience segment */
+	audience?: BannerAudience[]
+	/**  Target team vs enterprise organizations */
+	org_type?: "all" | "team_only" | "enterprise_only" | ""
+	/** Minimum extension version required (e.g., "3.39.2") */
+	min_extension_version?: string
+	/** Optional actions embedded in rules JSON for banners */
+	actions?: BannerAction[]
+}
diff --git a/apps/vscode/src/shared/ClineFeatureSetting.ts b/apps/vscode/src/shared/ClineFeatureSetting.ts
new file mode 100644
index 0000000..5ab7312
--- /dev/null
+++ b/apps/vscode/src/shared/ClineFeatureSetting.ts
@@ -0,0 +1,6 @@
+export interface ClineFeatureSetting {
+	// Setting is enabled or disabled by user
+	user: boolean
+	// Setting is enabled or disabled by feature flag
+	featureFlag: boolean
+}
diff --git a/apps/vscode/src/shared/ExtensionMessage.ts b/apps/vscode/src/shared/ExtensionMessage.ts
new file mode 100644
index 0000000..b13b3bc
--- /dev/null
+++ b/apps/vscode/src/shared/ExtensionMessage.ts
@@ -0,0 +1,385 @@
+// type that represents json data that is sent from extension to webview, called ExtensionMessage and has 'type' enum which can be 'plusButtonClicked' or 'settingsButtonClicked' or 'hello'
+
+import { WorkspaceRoot } from "@shared/multi-root/types"
+import { RemoteConfigFields } from "@shared/storage/state-keys"
+import type { Environment } from "../config"
+import { AutoApprovalSettings } from "./AutoApprovalSettings"
+import { ApiConfiguration } from "./api"
+import { BrowserSettings } from "./BrowserSettings"
+import { ClineFeatureSetting } from "./ClineFeatureSetting"
+import { BannerCardData } from "./cline/banner"
+import { ClineRulesToggles } from "./cline-rules"
+import { HistoryItem } from "./HistoryItem"
+import { McpDisplayMode } from "./McpDisplayMode"
+import { ClineMessageModelInfo } from "./messages"
+import { OnboardingModelGroup } from "./proto/cline/state"
+import { Mode } from "./storage/types"
+import { TelemetrySetting } from "./TelemetrySetting"
+import { UserInfo } from "./UserInfo"
+// webview will hold state
+export interface ExtensionMessage {
+	type: "grpc_response" // New type for gRPC responses
+	grpc_response?: GrpcResponse
+}
+
+export type GrpcResponse = {
+	message?: any // JSON serialized protobuf message
+	request_id: string // Same ID as the request
+	error?: string // Optional error message
+	is_streaming?: boolean // Whether this is part of a streaming response
+	sequence_number?: number // For ordering chunks in streaming responses
+}
+
+export type Platform = "aix" | "darwin" | "freebsd" | "linux" | "openbsd" | "sunos" | "win32" | "unknown"
+
+export const DEFAULT_PLATFORM = "unknown"
+
+export const COMMAND_CANCEL_TOKEN = "__cline_command_cancel__"
+export interface ExtensionState {
+	isNewUser: boolean
+	welcomeViewCompleted: boolean
+	onboardingModels: OnboardingModelGroup | undefined
+	apiConfiguration?: ApiConfiguration
+	autoApprovalSettings: AutoApprovalSettings
+	browserSettings: BrowserSettings
+	remoteBrowserHost?: string
+	preferredLanguage?: string
+	mode: Mode
+	clineMessages: ClineMessage[]
+	checkpointRestoreInput?: {
+		text: string
+		images?: string[]
+		files?: string[]
+		sessionId: string
+	}
+	/**
+	 * The single authoritative UI mode for the current turn, owned by the extension. The webview
+	 * renders the footer/buttons/thinking indicator from this, NOT from the tail of clineMessages.
+	 * Optional for classic/legacy (absent => webview falls back to legacy tail heuristics).
+	 */
+	turnState?: TurnState
+	/**
+	 * Follow-up prompts submitted while the active agent turn is still running.
+	 * These are owned by the SDK pending-prompt queue and are sent after the
+	 * current turn reaches a safe continuation point.
+	 */
+	queuedPrompts?: QueuedPrompt[]
+	/**
+	 * Monotonic version of this state snapshot. The webview applies a snapshot only if its
+	 * stateVersion is newer than the last applied, so stale/out-of-order state pushes are
+	 * ignored. Stamped by the extension. Optional for classic/legacy.
+	 */
+	stateVersion?: number
+	/**
+	 * Conversation/replica fence for this snapshot (see ClineMessage.epoch). A snapshot with a
+	 * newer epoch replaces the webview transcript; an older one is dropped; an equal one merges.
+	 * Optional for classic/legacy.
+	 */
+	epoch?: number
+	currentTaskItem?: HistoryItem
+	mcpMarketplaceEnabled?: boolean
+	mcpDisplayMode: McpDisplayMode
+	planActSeparateModelsSetting: boolean
+	enableCheckpointsSetting?: boolean
+	platform: Platform
+	environment?: Environment
+	shouldShowAnnouncement: boolean
+	taskHistory: HistoryItem[]
+	telemetrySetting: TelemetrySetting
+	shellIntegrationTimeout: number
+	terminalReuseEnabled?: boolean
+	maxConsecutiveMistakes: number
+	defaultTerminalProfile?: string
+	vscodeTerminalExecutionMode: string
+	backgroundCommandRunning?: boolean
+	backgroundCommandTaskId?: string
+	lastCompletedCommandTs?: number
+	userInfo?: UserInfo
+	version: string
+	distinctId: string
+	globalClineRulesToggles: ClineRulesToggles
+	localClineRulesToggles: ClineRulesToggles
+	localWorkflowToggles: ClineRulesToggles
+	globalWorkflowToggles: ClineRulesToggles
+	localCursorRulesToggles: ClineRulesToggles
+	localWindsurfRulesToggles: ClineRulesToggles
+	remoteRulesToggles?: ClineRulesToggles
+	remoteWorkflowToggles?: ClineRulesToggles
+	localAgentsRulesToggles: ClineRulesToggles
+	mcpResponsesCollapsed?: boolean
+	yoloModeToggled?: boolean
+	useAutoCondense?: boolean
+	compactionStrategy?: string
+	subagentsEnabled?: boolean
+	worktreesEnabled?: ClineFeatureSetting
+	customPrompt?: string
+	favoritedModelIds: string[]
+	// NEW: Add workspace information
+	workspaceRoots: WorkspaceRoot[]
+	primaryRootIndex: number
+	isMultiRootWorkspace: boolean
+	multiRootSetting: ClineFeatureSetting
+	lastDismissedInfoBannerVersion: number
+	lastDismissedModelBannerVersion: number
+	lastDismissedCliBannerVersion: number
+	dismissedBanners?: Array<{ bannerId: string; dismissedAt: number }>
+	hooksEnabled?: boolean
+	remoteConfigSettings?: Partial<RemoteConfigFields>
+	globalSkillsToggles?: Record<string, boolean>
+	localSkillsToggles?: Record<string, boolean>
+	backgroundEditEnabled?: boolean
+	optOutOfRemoteConfig?: boolean
+	showFeatureTips?: boolean
+	banners?: BannerCardData[]
+	welcomeBanners?: BannerCardData[]
+	openAiCodexIsAuthenticated?: boolean
+}
+
+/**
+ * The authoritative UI mode for the current agent turn, owned by the extension. The webview reads
+ * this instead of inferring mode from the tail of clineMessages.
+ */
+export type TurnPhase =
+	| "idle" // no active turn; input enabled, no buttons
+	| "streaming" // model producing content / tool running; Thinking + Cancel
+	| "awaiting_approval" // a tool/command/mcp/subagent approval is pending
+	| "awaiting_followup" // ask_question / plan_mode_respond / done-without-completion
+	| "completed" // attempt_completion done; Start New Task
+	| "error" // api_req_failed / fatal; Retry / recovery
+	| "resumable" // task cancelled / interrupted; Resume Task
+
+export interface TurnState {
+	phase: TurnPhase
+	/** ts of the ClineMessage this phase is "about" (e.g. the pending approval/ask). */
+	anchorTs?: number
+	/** Monotonic; the webview keeps the highest-seq TurnState and ignores older ones. */
+	seq: number
+}
+
+export interface QueuedPrompt {
+	id: string
+	prompt: string
+	delivery: "queue" | "steer"
+	attachmentCount: number
+}
+
+export interface ClineMessage {
+	ts: number
+	type: "ask" | "say"
+	ask?: ClineAsk
+	say?: ClineSay
+	text?: string
+	reasoning?: string
+	images?: string[]
+	files?: string[]
+	partial?: boolean
+	/**
+	 * Freshness counter for convergent-replica merging on the webview side. Monotonically
+	 * increasing per process; a higher `seq` means a newer copy of the SAME `ts` (identity).
+	 * Stamped by the extension as the message flows to the webview. Optional for classic/legacy.
+	 */
+	seq?: number
+	/**
+	 * Conversation/replica fence. Messages from an older epoch (a previous task or a previous
+	 * render of the same task) are dropped by the webview. Stamped by the extension. Optional
+	 * for classic/legacy.
+	 */
+	epoch?: number
+	commandCompleted?: boolean
+	lastCheckpointHash?: string
+	isCheckpointCheckedOut?: boolean
+	isOperationOutsideWorkspace?: boolean
+	conversationHistoryIndex?: number
+	conversationHistoryDeletedRange?: [number, number] // for when conversation history is truncated for API requests
+	modelInfo?: ClineMessageModelInfo
+}
+
+export type ClineAsk =
+	| "followup"
+	| "plan_mode_respond"
+	| "act_mode_respond"
+	| "command"
+	| "command_output"
+	| "completion_result"
+	| "tool"
+	| "api_req_failed"
+	| "resume_task"
+	| "resume_completed_task"
+	| "mistake_limit_reached"
+	| "browser_action_launch"
+	| "use_mcp_server"
+	| "new_task"
+	| "condense"
+	| "summarize_task"
+	| "report_bug"
+	| "use_subagents"
+
+export type ClineSay =
+	| "task"
+	| "error"
+	| "error_retry"
+	| "api_req_started"
+	| "api_req_finished"
+	| "text"
+	| "reasoning"
+	| "completion_result"
+	| "user_feedback"
+	| "user_feedback_diff"
+	| "api_req_retried"
+	| "command"
+	| "command_output"
+	| "tool"
+	| "shell_integration_warning"
+	| "shell_integration_warning_with_suggestion"
+	| "browser_action_launch"
+	| "browser_action"
+	| "browser_action_result"
+	| "mcp_server_request_started"
+	| "mcp_server_response"
+	| "mcp_notification"
+	| "use_mcp_server"
+	| "diff_error"
+	| "deleted_api_reqs"
+	| "clineignore_error"
+	| "command_permission_denied"
+	| "checkpoint_created"
+	| "load_mcp_documentation"
+	| "info" // Added for general informational messages like retry status
+	| "task_progress"
+	| "hook_status"
+	| "hook_output_stream"
+	| "subagent"
+	| "use_subagents"
+	| "subagent_usage"
+	| "conditional_rules_applied"
+
+export interface ClineSayTool {
+	tool:
+		| "editedExistingFile"
+		| "newFileCreated"
+		| "fileDeleted"
+		| "readFile"
+		| "listFilesTopLevel"
+		| "listFilesRecursive"
+		| "listCodeDefinitionNames"
+		| "searchFiles"
+		| "webFetch"
+		| "webSearch"
+		| "summarizeTask"
+		| "useSkill"
+	path?: string
+	diff?: string
+	content?: string
+	regex?: string
+	filePattern?: string
+	operationIsLocatedInWorkspace?: boolean
+	/** Starting line numbers in the original file where each SEARCH block matched */
+	startLineNumbers?: number[]
+	/** One-based inclusive line range requested by read_file; readLineEnd omitted = open-ended read (for UI summaries). */
+	readLineStart?: number
+	readLineEnd?: number
+}
+
+// must keep in sync with system prompt
+const browserActions = ["launch", "click", "type", "scroll_down", "scroll_up", "close"] as const
+export type BrowserAction = (typeof browserActions)[number]
+
+export interface ClineSayBrowserAction {
+	action: BrowserAction
+	coordinate?: string
+	text?: string
+}
+
+export type SubagentExecutionStatus = "pending" | "running" | "completed" | "failed"
+
+export interface SubagentStatusItem {
+	index: number
+	prompt: string
+	status: SubagentExecutionStatus
+	toolCalls: number
+	inputTokens: number
+	outputTokens: number
+	totalCost: number
+	contextTokens: number
+	contextWindow: number
+	contextUsagePercentage: number
+	latestToolCall?: string
+	result?: string
+	error?: string
+}
+
+export interface ClineSaySubagentStatus {
+	status: "running" | "completed" | "failed"
+	total: number
+	completed: number
+	successes: number
+	failures: number
+	toolCalls: number
+	inputTokens: number
+	outputTokens: number
+	contextWindow: number
+	maxContextTokens: number
+	maxContextUsagePercentage: number
+	items: SubagentStatusItem[]
+}
+
+export type BrowserActionResult = {
+	screenshot?: string
+	logs?: string
+	currentUrl?: string
+	currentMousePosition?: string
+}
+
+export interface ClineAskUseMcpServer {
+	serverName: string
+	type: "use_mcp_tool" | "access_mcp_resource"
+	toolName?: string
+	arguments?: string
+	uri?: string
+}
+
+export interface ClineAskUseSubagents {
+	prompts: string[]
+}
+
+export interface ClinePlanModeResponse {
+	response: string
+	options?: string[]
+	selected?: string
+}
+
+export interface ClineAskQuestion {
+	question: string
+	options?: string[]
+	selected?: string
+}
+
+export interface ClineApiReqInfo {
+	request?: string
+	tokensIn?: number
+	tokensOut?: number
+	cacheWrites?: number
+	cacheReads?: number
+	cost?: number
+	cancelReason?: ClineApiReqCancelReason
+	streamingFailedMessage?: string
+	retryStatus?: {
+		attempt: number
+		maxAttempts: number
+		delaySec: number
+		errorSnippet?: string
+	}
+}
+
+export interface ClineSubagentUsageInfo {
+	source: "subagents"
+	tokensIn: number
+	tokensOut: number
+	cacheWrites: number
+	cacheReads: number
+	cost: number
+}
+
+type ClineApiReqCancelReason = "streaming_failed" | "user_cancelled" | "retries_exhausted"
+
+export const COMPLETION_RESULT_CHANGES_FLAG = "HAS_CHANGES"
diff --git a/apps/vscode/src/shared/FocusChainSettings.ts b/apps/vscode/src/shared/FocusChainSettings.ts
new file mode 100644
index 0000000..16f69f2
--- /dev/null
+++ b/apps/vscode/src/shared/FocusChainSettings.ts
@@ -0,0 +1,11 @@
+export interface FocusChainSettings {
+	// Enable/disable the focus chain feature
+	enabled: boolean
+	// Interval (in messages) to remind Cline about focus chain
+	remindClineInterval: number
+}
+
+export const DEFAULT_FOCUS_CHAIN_SETTINGS: FocusChainSettings = {
+	enabled: true,
+	remindClineInterval: 6,
+}
diff --git a/apps/vscode/src/shared/HistoryItem.ts b/apps/vscode/src/shared/HistoryItem.ts
new file mode 100644
index 0000000..a84c4fd
--- /dev/null
+++ b/apps/vscode/src/shared/HistoryItem.ts
@@ -0,0 +1,18 @@
+export type HistoryItem = {
+	id: string
+	ulid?: string // ULID for better tracking and metrics
+	ts: number
+	task: string
+	tokensIn: number
+	tokensOut: number
+	cacheWrites?: number
+	cacheReads?: number
+	totalCost: number
+
+	size?: number
+	cwdOnTaskInitialization?: string
+	conversationHistoryDeletedRange?: [number, number]
+	isFavorited?: boolean
+
+	modelId?: string
+}
diff --git a/apps/vscode/src/shared/Languages.ts b/apps/vscode/src/shared/Languages.ts
new file mode 100644
index 0000000..5a882cb
--- /dev/null
+++ b/apps/vscode/src/shared/Languages.ts
@@ -0,0 +1,73 @@
+export type LanguageKey =
+	| "en"
+	| "ar"
+	| "pt-BR"
+	| "cs"
+	| "fr"
+	| "de"
+	| "hi"
+	| "hu"
+	| "it"
+	| "ja"
+	| "ko"
+	| "pl"
+	| "pt-PT"
+	| "ru"
+	| "zh-CN"
+	| "es"
+	| "zh-TW"
+	| "tr"
+
+export type LanguageDisplay =
+	| "English"
+	| "Arabic - العربية"
+	| "Portuguese - Português (Brasil)"
+	| "Czech - Čeština"
+	| "French - Français"
+	| "German - Deutsch"
+	| "Hindi - हिन्दी"
+	| "Hungarian - Magyar"
+	| "Italian - Italiano"
+	| "Japanese - 日本語"
+	| "Korean - 한국어"
+	| "Polish - Polski"
+	| "Portuguese - Português (Portugal)"
+	| "Russian - Русский"
+	| "Simplified Chinese - 简体中文"
+	| "Spanish - Español"
+	| "Traditional Chinese - 繁體中文"
+	| "Turkish - Türkçe"
+
+export const DEFAULT_LANGUAGE_SETTINGS: LanguageKey = "en"
+
+const languageOptions: { key: LanguageKey; display: LanguageDisplay }[] = [
+	{ key: "en", display: "English" },
+	{ key: "ar", display: "Arabic - العربية" },
+	{ key: "pt-BR", display: "Portuguese - Português (Brasil)" },
+	{ key: "cs", display: "Czech - Čeština" },
+	{ key: "fr", display: "French - Français" },
+	{ key: "de", display: "German - Deutsch" },
+	{ key: "hi", display: "Hindi - हिन्दी" },
+	{ key: "hu", display: "Hungarian - Magyar" },
+	{ key: "it", display: "Italian - Italiano" },
+	{ key: "ja", display: "Japanese - 日本語" },
+	{ key: "ko", display: "Korean - 한국어" },
+	{ key: "pl", display: "Polish - Polski" },
+	{ key: "pt-PT", display: "Portuguese - Português (Portugal)" },
+	{ key: "ru", display: "Russian - Русский" },
+	{ key: "zh-CN", display: "Simplified Chinese - 简体中文" },
+	{ key: "es", display: "Spanish - Español" },
+	{ key: "zh-TW", display: "Traditional Chinese - 繁體中文" },
+	{ key: "tr", display: "Turkish - Türkçe" },
+]
+
+export function getLanguageKey(display: LanguageDisplay | undefined): LanguageKey {
+	if (!display) {
+		return DEFAULT_LANGUAGE_SETTINGS
+	}
+	const languageOption = languageOptions.find((option) => option.display === display)
+	if (languageOption) {
+		return languageOption.key
+	}
+	return DEFAULT_LANGUAGE_SETTINGS
+}
diff --git a/apps/vscode/src/shared/McpDisplayMode.ts b/apps/vscode/src/shared/McpDisplayMode.ts
new file mode 100644
index 0000000..86506ea
--- /dev/null
+++ b/apps/vscode/src/shared/McpDisplayMode.ts
@@ -0,0 +1,9 @@
+/**
+ * Represents the different display modes available for MCP responses
+ */
+export type McpDisplayMode = "rich" | "plain" | "markdown"
+
+/**
+ * Default display mode for MCP responses
+ */
+export const DEFAULT_MCP_DISPLAY_MODE: McpDisplayMode = "plain"
diff --git a/apps/vscode/src/shared/TelemetrySetting.ts b/apps/vscode/src/shared/TelemetrySetting.ts
new file mode 100644
index 0000000..61444b5
--- /dev/null
+++ b/apps/vscode/src/shared/TelemetrySetting.ts
@@ -0,0 +1 @@
+export type TelemetrySetting = "unset" | "enabled" | "disabled"
diff --git a/apps/vscode/src/shared/UserInfo.ts b/apps/vscode/src/shared/UserInfo.ts
new file mode 100644
index 0000000..0cd86c3
--- /dev/null
+++ b/apps/vscode/src/shared/UserInfo.ts
@@ -0,0 +1,6 @@
+export interface UserInfo {
+	displayName?: string
+	email?: string
+	photoUrl?: string
+	apiBaseUrl?: string // Base URL for API requests
+}
diff --git a/apps/vscode/src/shared/WebviewMessage.ts b/apps/vscode/src/shared/WebviewMessage.ts
new file mode 100644
index 0000000..11d761b
--- /dev/null
+++ b/apps/vscode/src/shared/WebviewMessage.ts
@@ -0,0 +1,23 @@
+export interface WebviewMessage {
+	type: "grpc_request" | "grpc_request_cancel"
+	grpc_request?: GrpcRequest
+	grpc_request_cancel?: GrpcCancel
+}
+
+export type GrpcRequest = {
+	service: string
+	method: string
+	message: any // JSON serialized protobuf message
+	request_id: string // For correlating requests and responses
+	is_streaming: boolean // Whether this is a streaming request
+}
+
+export type GrpcCancel = {
+	request_id: string // ID of the request to cancel
+}
+
+export type ClineAskResponse = "yesButtonClicked" | "noButtonClicked" | "messageResponse"
+
+export type ClineCheckpointRestore = "task" | "workspace" | "taskAndWorkspace"
+
+export type TaskFeedbackType = "thumbs_up" | "thumbs_down"
diff --git a/apps/vscode/src/shared/__tests__/context-mentions.test.ts b/apps/vscode/src/shared/__tests__/context-mentions.test.ts
new file mode 100644
index 0000000..b746c70
--- /dev/null
+++ b/apps/vscode/src/shared/__tests__/context-mentions.test.ts
@@ -0,0 +1,422 @@
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+
+import { mentionRegex, mentionRegexGlobal } from "../context-mentions"
+
+interface TestResult {
+	actual: string | null
+	expected: string | null
+}
+
+function testMention(input: string, expected: string | null): TestResult {
+	const match = mentionRegex.exec(input)
+	return {
+		actual: match ? match[0] : null,
+		expected,
+	}
+}
+
+function assertMatch(result: TestResult) {
+	expect(result.actual).eq(result.expected)
+	return true
+}
+
+describe("Mention Regex", () => {
+	describe("Windows Path Support", () => {
+		it("matches simple Windows paths", () => {
+			const cases: Array<[string, string]> = [
+				["@/C:\\folder\\file.txt", "@/C:\\folder\\file.txt"],
+				["@/C:\\file.txt", "@/C:\\file.txt"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+	})
+
+	describe("Edge Cases", () => {
+		it("handles edge cases correctly", () => {
+			const cases: Array<[string, string]> = [
+				["@/C:\\Users\\name\\path\\to\\文件夹\\file.txt", "@/C:\\Users\\name\\path\\to\\文件夹\\file.txt"],
+				["@/path123/file-name_2.0.txt", "@/path123/file-name_2.0.txt"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+		it("handles unquoted paths with spaces correctly", () => {
+			// Should stop at the space
+			const match = mentionRegex.exec("@/path with spaces/file.txt")
+			expect(match?.[0]).to.equal("@/path")
+		})
+	})
+
+	describe("Existing Functionality", () => {
+		it("matches Unix paths", () => {
+			const cases: Array<[string, string]> = [
+				["@/usr/local/bin/file", "@/usr/local/bin/file"],
+				["@/path/to/file.txt", "@/path/to/file.txt"],
+				["@//etc/host", "@//etc/host"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+
+		it("matches URLs", () => {
+			const cases: Array<[string, string]> = [
+				["@http://example.com", "@http://example.com"],
+				["@https://example.com/path/to/file.html", "@https://example.com/path/to/file.html"],
+				["@ftp://server.example.com/file.zip", "@ftp://server.example.com/file.zip"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+
+		it("matches git hashes", () => {
+			const cases: Array<[string, string]> = [
+				["@abcdef1234567890abcdef1234567890abcdef12", "@abcdef1234567890abcdef1234567890abcdef12"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+
+		it("matches special keywords", () => {
+			const cases: Array<[string, string]> = [
+				["@problems", "@problems"],
+				["@git-changes", "@git-changes"],
+				["@terminal", "@terminal"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+	})
+
+	describe("Invalid Patterns", () => {
+		it("rejects invalid patterns", () => {
+			const cases: Array<[string, null]> = [
+				["C:\\folder\\file.txt", null],
+				["@", null],
+				["@ C:\\file.txt", null],
+				["@'/path/file.tar.gz'", null],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+
+		it("matches only until invalid characters", () => {
+			const result = testMention("@/C:\\folder\\file.txt invalid suffix", "@/C:\\folder\\file.txt")
+			assertMatch(result)
+		})
+	})
+
+	describe("In Context", () => {
+		it("matches mentions within text", () => {
+			const cases: Array<[string, string]> = [
+				["Check the file at @/C:\\folder\\file.txt for details.", "@/C:\\folder\\file.txt"],
+				["Review @problems and @git-changes.", "@problems"],
+				["Multiple: @/file1.txt and @/C:\\file2.txt and @terminal", "@/file1.txt"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+	})
+
+	describe("Multiple Mentions", () => {
+		it("finds all mentions in a string using global regex", () => {
+			const text = "Check @/path/file1.txt and @/C:\\folder\\file2.txt and report any @problems to @git-changes"
+			const matches = text.match(mentionRegexGlobal)
+			expect(matches).deep.eq(["@/path/file1.txt", "@/C:\\folder\\file2.txt", "@problems", "@git-changes"])
+		})
+	})
+
+	describe("Special Characters in Paths", () => {
+		it("handles special characters in file paths", () => {
+			const cases: Array<[string, string]> = [
+				["@/path/with-dash/file_underscore.txt", "@/path/with-dash/file_underscore.txt"],
+				["@/C:\\folder+plus\\file(parens)[]brackets.txt", "@/C:\\folder+plus\\file(parens)[]brackets.txt"],
+				["@/path/with/file#hash%percent.txt", "@/path/with/file#hash%percent.txt"],
+				["@/path/with/file@symbol$dollar.txt", "@/path/with/file@symbol$dollar.txt"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+	})
+
+	describe("Mixed Path Types in Single String", () => {
+		it("correctly identifies the first path in a string with multiple path types", () => {
+			const text = "Check both @/unix/path and @/C:\\windows\\path for details."
+			const result = mentionRegex.exec(text) || []
+			expect(result[0]).eq("@/unix/path")
+
+			// Test starting from after the first match
+			const secondSearchStart = text.indexOf("@/C:")
+			const secondResult = mentionRegex.exec(text.substring(secondSearchStart)) || []
+			expect(secondResult[0]).eq("@/C:\\windows\\path")
+		})
+	})
+
+	describe("Non-Latin Character Support", () => {
+		it("handles international characters in paths", () => {
+			const cases: Array<[string, string]> = [
+				["@/path/to/你好/file.txt", "@/path/to/你好/file.txt"],
+				["@/C:\\用户\\документы\\файл.txt", "@/C:\\用户\\документы\\файл.txt"],
+				["@/путь/к/файлу.txt", "@/путь/к/файлу.txt"],
+				["@/C:\\folder\\file_äöü.txt", "@/C:\\folder\\file_äöü.txt"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const result = testMention(input, expected)
+				assertMatch(result)
+			})
+		})
+	})
+	describe("Git Hash Edge Cases", () => {
+		it("matches git hashes of various valid lengths", () => {
+			const cases: Array<[string, string | null]> = [
+				// Valid lengths (7-40 characters)
+				["@abcdef1", "@abcdef1"], // 7 chars (minimum)
+				["@abcdef12", "@abcdef12"], // 8 chars
+				["@abcdef1234567890", "@abcdef1234567890"], // 16 chars
+				["@abcdef1234567890abcdef1234567890abcdef12", "@abcdef1234567890abcdef1234567890abcdef12"], // 40 chars (maximum)
+
+				// Invalid lengths
+				["@abcdef", null], // 6 chars (too short)
+				["@abcdef1234567890abcdef1234567890abcdef123", null], // 41 chars (too long, but would match first 40)
+
+				// Invalid characters
+				["@ghijklm", null], // Contains non-hex characters
+				["@ABCDEF1", null], // Uppercase not allowed
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				const actual = match ? match[0] : null
+				if (expected && expected.includes("41 chars")) {
+					// Special case: should match first 40 chars
+					expect(actual).to.equal("@abcdef1234567890abcdef1234567890abcdef12")
+				} else {
+					expect(actual).to.equal(expected)
+				}
+			})
+		})
+	})
+
+	describe("Punctuation at Boundaries", () => {
+		it("excludes all types of trailing punctuation", () => {
+			const cases: Array<[string, string]> = [
+				["@/path/file.txt.", "@/path/file.txt"],
+				["@problems:", "@problems"],
+				["@terminal;", "@terminal"],
+				["@/path/file.txt!", "@/path/file.txt"],
+				["@/path/file.txt?", "@/path/file.txt"],
+				["@git-changes,", "@git-changes"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+
+		it("handles multiple punctuation marks", () => {
+			const cases: Array<[string, string]> = [
+				["@/path/file.txt!?", "@/path/file.txt"],
+				["@problems...", "@problems"],
+				["@terminal!!", "@terminal"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+
+		it("doesn't match trailing punctuation in context", () => {
+			const cases: Array<[string, string[]]> = [
+				["Check the file at @/C:\\folder\\file.txt! for details.", ["@/C:\\folder\\file.txt"]],
+				["Review @problems, and @git-changes.", ["@problems", "@git-changes"]],
+				["Multiple: @/file1.txt, and @/C:\\file2.txt; and @terminal?", ["@/file1.txt", "@/C:\\file2.txt", "@terminal"]],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const matches = input.match(mentionRegexGlobal)
+				expect(matches).deep.eq(expected)
+			})
+		})
+	})
+
+	describe("URL Protocol Variations", () => {
+		it("matches various URL protocols", () => {
+			const cases: Array<[string, string]> = [
+				["@file://localhost/path/to/file", "@file://localhost/path/to/file"],
+				["@custom://app/resource", "@custom://app/resource"],
+				["@app://settings", "@app://settings"],
+				["@ssh://git@github.com/repo", "@ssh://git@github.com/repo"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+
+		it("matches URLs with complex structures", () => {
+			const cases: Array<[string, string]> = [
+				["@https://example.com?q=test&p=1", "@https://example.com?q=test&p=1"],
+				["@https://example.com#section", "@https://example.com#section"],
+				["@http://localhost:3000", "@http://localhost:3000"],
+				["@https://user:pass@example.com", "@https://user:pass@example.com"],
+				["@https://example.com/", "@https://example.com/"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+	})
+
+	describe("End of String Handling", () => {
+		it("matches mentions at end of string", () => {
+			const cases: Array<[string, string]> = [
+				["Check @/path/file.txt", "@/path/file.txt"],
+				["Review @problems", "@problems"],
+				["Open @terminal", "@terminal"],
+				["See @git-changes", "@git-changes"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+	})
+
+	describe("Complex Real-World Scenarios", () => {
+		it("handles mentions in markdown-like text", () => {
+			const text = "See @/docs/README.md, check @problems, and visit @https://example.com."
+			const matches = text.match(mentionRegexGlobal)
+			expect(matches).to.deep.equal(["@/docs/README.md", "@problems", "@https://example.com"])
+		})
+
+		it("handles mentions in code comments", () => {
+			const text = "// TODO: Fix @problems in @/src/index.js (see @git-changes)"
+			const matches = text.match(mentionRegexGlobal)
+			expect(matches).to.deep.equal(["@problems", "@/src/index.js", "@git-changes"])
+		})
+	})
+	describe("Quoted file paths", () => {
+		it("handles quoted paths correctly", () => {
+			const cases: Array<[string, string]> = [
+				['@"/path with space.txt"', '@"/path with space.txt"'],
+				['@"/path/ends/with-space "', '@"/path/ends/with-space "'],
+				['@"/ path-starts-with-space.txt"', '@"/ path-starts-with-space.txt"'],
+				['@"/path with space.txt!"', '@"/path with space.txt!"'],
+				['@"/path with space.txt!"!', '@"/path with space.txt!"'],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+		it("handles quotes inside file paths correctly", () => {
+			const cases: Array<[string, string]> = [
+				['@/"path/file.txt', '@/"path/file.txt'],
+				['@/path"/file".tar.gz', '@/path"/file".tar.gz'],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+	})
+	describe("Path Edge Cases", () => {
+		it("matches various path structures", () => {
+			const cases: Array<[string, string]> = [
+				["@/", "@/"], // root directory
+				['@"/"', '@"/"'], // quoted root directory
+				["@/path/to/.hidden/file", "@/path/to/.hidden/file"],
+				["@/path/file...txt", "@/path/file...txt"],
+				["@/path/file.tar.gz", "@/path/file.tar.gz"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+	})
+	describe("Whitespace Handling", () => {
+		it("stops at various whitespace characters", () => {
+			const cases: Array<[string, string]> = [
+				["@/path/file.txt\trest", "@/path/file.txt"],
+				["@/path/file.txt\nrest", "@/path/file.txt"],
+				["@/path/file.txt\rrest", "@/path/file.txt"],
+				["@/path/file.txt rest", "@/path/file.txt"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+	})
+
+	describe("Keyword Boundaries", () => {
+		it("only matches exact keywords", () => {
+			const cases: Array<[string, string | null]> = [
+				["@problemsolver", null], // Should not match
+				["@terminals", null], // Should not match
+				["@git-changeset", null], // Should not match
+				["@problem", null], // Should not match
+				["@git-change", null], // Should not match
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				const actual = match ? match[0] : null
+				expect(actual).to.equal(expected)
+			})
+		})
+
+		it("matches keywords with trailing punctuation", () => {
+			const cases: Array<[string, string]> = [
+				["@problems!", "@problems"],
+				["@terminal.", "@terminal"],
+				["@git-changes,", "@git-changes"],
+			]
+
+			cases.forEach(([input, expected]) => {
+				const match = mentionRegex.exec(input)
+				expect(match?.[0]).to.equal(expected)
+			})
+		})
+	})
+})
diff --git a/apps/vscode/src/shared/__tests__/getApiMetrics.test.ts b/apps/vscode/src/shared/__tests__/getApiMetrics.test.ts
new file mode 100644
index 0000000..39d60c5
--- /dev/null
+++ b/apps/vscode/src/shared/__tests__/getApiMetrics.test.ts
@@ -0,0 +1,103 @@
+import { describe, it } from "bun:test"
+import { strict as assert } from "node:assert"
+import type { ClineMessage } from "../ExtensionMessage"
+import { getApiMetrics, getLastApiReqTotalTokens } from "../getApiMetrics"
+
+describe("getApiMetrics", () => {
+	it("includes subagent_usage in aggregate totals", () => {
+		const messages: ClineMessage[] = [
+			{
+				ts: 1,
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify({
+					tokensIn: 10,
+					tokensOut: 20,
+					cacheWrites: 3,
+					cacheReads: 1,
+					cost: 0.12,
+				}),
+			},
+			{
+				ts: 2,
+				type: "say",
+				say: "subagent_usage",
+				text: JSON.stringify({
+					source: "subagents",
+					tokensIn: 4,
+					tokensOut: 8,
+					cacheWrites: 2,
+					cacheReads: 1,
+					cost: 0.05,
+				}),
+			},
+			{
+				ts: 3,
+				type: "say",
+				say: "deleted_api_reqs",
+				text: JSON.stringify({
+					tokensIn: 6,
+					tokensOut: 9,
+					cacheWrites: 1,
+					cacheReads: 0,
+					cost: 0.03,
+				}),
+			},
+		]
+
+		const metrics = getApiMetrics(messages)
+
+		assert.equal(metrics.totalTokensIn, 20)
+		assert.equal(metrics.totalTokensOut, 37)
+		assert.equal(metrics.totalCacheWrites, 6)
+		assert.equal(metrics.totalCacheReads, 2)
+		assert.ok(Math.abs(metrics.totalCost - 0.2) < 1e-9)
+	})
+
+	it("ignores malformed usage payloads", () => {
+		const messages: ClineMessage[] = [
+			{
+				ts: 1,
+				type: "say",
+				say: "subagent_usage",
+				text: "{not-json",
+			},
+		]
+
+		const metrics = getApiMetrics(messages)
+		assert.equal(metrics.totalTokensIn, 0)
+		assert.equal(metrics.totalTokensOut, 0)
+		assert.equal(metrics.totalCost, 0)
+	})
+})
+
+describe("getLastApiReqTotalTokens", () => {
+	it("uses only the latest api_req_started payload", () => {
+		const messages: ClineMessage[] = [
+			{
+				ts: 1,
+				type: "say",
+				say: "subagent_usage",
+				text: JSON.stringify({
+					source: "subagents",
+					tokensIn: 100,
+					tokensOut: 200,
+				}),
+			},
+			{
+				ts: 2,
+				type: "say",
+				say: "api_req_started",
+				text: JSON.stringify({
+					tokensIn: 11,
+					tokensOut: 7,
+					cacheWrites: 2,
+					cacheReads: 3,
+				}),
+			},
+		]
+
+		const total = getLastApiReqTotalTokens(messages)
+		assert.equal(total, 23)
+	})
+})
diff --git a/apps/vscode/src/shared/api.ts b/apps/vscode/src/shared/api.ts
new file mode 100644
index 0000000..14e43c0
--- /dev/null
+++ b/apps/vscode/src/shared/api.ts
@@ -0,0 +1,226 @@
+import { ApiFormat } from "./proto/cline/models"
+import type { ApiHandlerSettings } from "./storage/state-keys"
+
+export type ApiProvider =
+	| "anthropic"
+	| "claude-code"
+	| "openrouter"
+	| "bedrock"
+	| "vertex"
+	| "openai"
+	| "ollama"
+	| "lmstudio"
+	| "gemini"
+	| "openai-native"
+	| "openai-codex"
+	| "requesty"
+	| "together"
+	| "deepseek"
+	| "qwen"
+	| "qwen-code"
+	| "doubao"
+	| "mistral"
+	| "vscode-lm"
+	| "cline"
+	| "cline-pass"
+	| "litellm"
+	| "moonshot"
+	| "nebius"
+	| "fireworks"
+	| "asksage"
+	| "xai"
+	| "sambanova"
+	| "cerebras"
+	| "sapaicore"
+	| "groq"
+	| "poolside"
+	| "huggingface"
+	| "huawei-cloud-maas"
+	| "dify"
+	| "baseten"
+	| "vercel-ai-gateway"
+	| "v0"
+	| "zai"
+	| "zai-coding-plan"
+	| "oca"
+	| "aihubmix"
+	| "minimax"
+	| "hicap"
+	| "nousResearch"
+	| "wandb"
+	| "xiaomi"
+	| "tencent-tokenhub"
+
+export const DEFAULT_API_PROVIDER = "openrouter" as ApiProvider
+
+export interface ApiHandlerOptions extends Partial<ApiHandlerSettings> {
+	ulid?: string // Used to identify the task in API requests
+	onRetryAttempt?: (attempt: number, maxRetries: number, delay: number, error: any) => void // Callback function
+}
+
+export type ApiConfiguration = ApiHandlerOptions
+
+// Models
+
+interface PriceTier {
+	tokenLimit: number // Upper limit (inclusive) of *input* tokens for this price. Use Infinity for the highest tier.
+	price: number // Price per million tokens for this tier.
+}
+
+export interface ModelInfo {
+	name?: string
+	maxTokens?: number
+	contextWindow?: number
+	supportsImages?: boolean
+	supportsPromptCache: boolean // this value is hardcoded for now
+	supportsReasoning?: boolean // Whether the model supports reasoning/thinking mode
+	inputPrice?: number // Keep for non-tiered input models
+	outputPrice?: number // Keep for non-tiered output models
+	thinkingConfig?: {
+		maxBudget?: number // Max allowed thinking budget tokens
+		outputPrice?: number // Output price per million tokens when budget > 0
+		outputPriceTiers?: PriceTier[] // Optional: Tiered output price when budget > 0
+		geminiThinkingLevel?: "low" | "high" // Optional: preset thinking level
+		supportsThinkingLevel?: boolean // Whether the model supports thinking level (low/high)
+	}
+	supportsGlobalEndpoint?: boolean // Whether the model supports a global endpoint with Vertex AI
+	cacheWritesPrice?: number
+	cacheReadsPrice?: number
+	description?: string
+	tiers?: {
+		contextWindow: number
+		inputPrice?: number
+		outputPrice?: number
+		cacheWritesPrice?: number
+		cacheReadsPrice?: number
+	}[]
+	temperature?: number
+	apiFormat?: ApiFormat // The API format used by this model
+}
+
+export interface OpenAiCompatibleModelInfo extends ModelInfo {
+	temperature?: number
+	isR1FormatRequired?: boolean
+	systemRole?: "developer" | "system"
+	supportsReasoningEffort?: boolean
+	supportsTools?: boolean
+	supportsStreaming?: boolean
+}
+
+export interface OcaModelInfo extends OpenAiCompatibleModelInfo {
+	modelName: string
+	surveyId?: string
+	banner?: string
+	surveyContent?: string
+	supportsReasoning?: boolean
+	reasoningEffortOptions: string[]
+}
+
+// Anthropic
+// https://docs.anthropic.com/en/docs/about-claude/models // prices updated 2025-01-02
+export type AnthropicModelId = string
+export const ANTHROPIC_MIN_THINKING_BUDGET = 1_024
+export const ANTHROPIC_MAX_THINKING_BUDGET = 6_000
+
+// AWS Bedrock
+// https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html
+export type BedrockModelId = string
+
+// OpenRouter
+// https://openrouter.ai/models?order=newest&supported_parameters=tools
+export const openRouterDefaultModelId = "anthropic/claude-sonnet-4.5" // will always exist in openRouterModels
+export const openRouterDefaultModelInfo: ModelInfo = {
+	maxTokens: 64_000,
+	contextWindow: 200_000,
+	supportsImages: true,
+	supportsPromptCache: true,
+	inputPrice: 3.0,
+	outputPrice: 15.0,
+	cacheWritesPrice: 3.75,
+	cacheReadsPrice: 0.3,
+	description:
+		"Claude Sonnet 4.5 is an Anthropic model for coding, agentic search, and AI agent workflows. It supports planning and implementation tasks across the software development lifecycle.\n\nRead more in the [blog post here](https://www.anthropic.com/claude/sonnet)",
+}
+
+export const clinePassDefaultModelId = "cline-pass/glm-5.2"
+export const clinePassModelInfoSaneDefaults: ModelInfo = {
+	maxTokens: 8_192,
+	contextWindow: 128_000,
+	supportsImages: false,
+	supportsPromptCache: false,
+	supportsReasoning: true,
+	inputPrice: 0,
+	outputPrice: 0,
+	cacheReadsPrice: 0,
+	cacheWritesPrice: 0,
+	description: "",
+}
+
+export function getModelSlug(modelId: string): string {
+	return modelId.split("/").at(-1) ?? modelId
+}
+
+export function buildModelInfoNameMap(models: Record<string, ModelInfo>): Record<string, ModelInfo> {
+	const nameMap: Record<string, ModelInfo> = {}
+
+	for (const [id, info] of Object.entries(models)) {
+		nameMap[getModelSlug(id)] = info
+	}
+
+	return nameMap
+}
+
+export function resolveClinePassModelInfo(modelId: string, modelInfoByName?: Record<string, ModelInfo>): ModelInfo {
+	return modelInfoByName?.[getModelSlug(modelId)] ?? clinePassModelInfoSaneDefaults
+}
+
+export const openAiModelInfoSafeDefaults: OpenAiCompatibleModelInfo = {
+	maxTokens: -1,
+	contextWindow: 128_000,
+	supportsImages: true,
+	supportsPromptCache: false,
+	isR1FormatRequired: false,
+	inputPrice: 0,
+	outputPrice: 0,
+	temperature: 0,
+}
+
+// OpenAI Codex (ChatGPT Plus/Pro subscription)
+// Uses OAuth authentication via ChatGPT, routes to chatgpt.com/backend-api/codex/responses
+// Subscription-based pricing (all costs are $0).
+//
+// The Codex catalog and default model id are sourced from the `@cline/llms`
+// SDK.
+// Azure OpenAI
+// https://learn.microsoft.com/en-us/azure/ai-services/openai/api-version-deprecation
+// https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#api-specs
+export const azureOpenAiDefaultApiVersion = "2024-08-01-preview"
+
+// Qwen
+// https://bailian.console.aliyun.com/
+// The first model in the list is used as the default model for each region
+
+export enum QwenApiRegions {
+	CHINA = "china",
+	INTERNATIONAL = "international",
+}
+export const liteLlmDefaultModelId = "anthropic/claude-3-7-sonnet-20250219"
+export interface LiteLLMModelInfo extends ModelInfo {
+	temperature?: number
+}
+
+// Requesty
+// https://requesty.ai/models
+export const requestyDefaultModelId = "anthropic/claude-3-7-sonnet-latest"
+export const requestyDefaultModelInfo: ModelInfo = {
+	maxTokens: 8192,
+	contextWindow: 200_000,
+	supportsImages: true,
+
+	supportsPromptCache: true,
+	inputPrice: 3.0,
+	outputPrice: 15.0,
+	cacheWritesPrice: 3.75,
+	cacheReadsPrice: 0.3,
+	description: "Anthropic's most intelligent model. Highest level of intelligence and capability.",
+}
diff --git a/apps/vscode/src/shared/array.test.ts b/apps/vscode/src/shared/array.test.ts
new file mode 100644
index 0000000..0ae404c
--- /dev/null
+++ b/apps/vscode/src/shared/array.test.ts
@@ -0,0 +1,91 @@
+import { describe, it } from "mocha"
+import "should"
+import { findLast, findLastIndex } from "./array"
+
+describe("Array Utilities", () => {
+	describe("findLastIndex", () => {
+		it("should find last matching element's index", () => {
+			const array = [1, 2, 3, 2, 1]
+			const index = findLastIndex(array, (x) => x === 2)
+			index.should.equal(3) // last '2' is at index 3
+		})
+
+		it("should return -1 when no element matches", () => {
+			const array = [1, 2, 3]
+			const index = findLastIndex(array, (x) => x === 4)
+			index.should.equal(-1)
+		})
+
+		it("should handle empty arrays", () => {
+			const array: number[] = []
+			const index = findLastIndex(array, (x) => x === 1)
+			index.should.equal(-1)
+		})
+
+		it("should work with different types", () => {
+			const array = ["a", "b", "c", "b", "a"]
+			const index = findLastIndex(array, (x) => x === "b")
+			index.should.equal(3)
+		})
+
+		it("should provide correct index in predicate", () => {
+			const array = [1, 2, 3]
+			const indices: number[] = []
+			findLastIndex(array, (_, index) => {
+				indices.push(index)
+				return false
+			})
+			indices.should.deepEqual([2, 1, 0]) // Should iterate in reverse
+		})
+
+		it("should provide array reference in predicate", () => {
+			const array = [1, 2, 3]
+			findLastIndex(array, (_, __, arr) => {
+				arr.should.equal(array) // Should pass original array
+				return false
+			})
+		})
+	})
+
+	describe("findLast", () => {
+		it("should find last matching element", () => {
+			const array = [1, 2, 3, 2, 1]
+			const element = findLast(array, (x) => x === 2)
+			should(element).not.be.undefined()
+			element!.should.equal(2)
+		})
+
+		it("should return undefined when no element matches", () => {
+			const array = [1, 2, 3]
+			const element = findLast(array, (x) => x === 4)
+			should(element).be.undefined()
+		})
+
+		it("should handle empty arrays", () => {
+			const array: number[] = []
+			const element = findLast(array, (x) => x === 1)
+			should(element).be.undefined()
+		})
+
+		it("should work with object arrays", () => {
+			const array = [
+				{ id: 1, value: "a" },
+				{ id: 2, value: "b" },
+				{ id: 3, value: "a" },
+			]
+			const element = findLast(array, (x) => x.value === "a")
+			should(element).not.be.undefined()
+			element!.should.deepEqual({ id: 3, value: "a" })
+		})
+
+		it("should provide correct index in predicate", () => {
+			const array = [1, 2, 3]
+			const indices: number[] = []
+			findLast(array, (_, index) => {
+				indices.push(index)
+				return false
+			})
+			indices.should.deepEqual([2, 1, 0]) // Should iterate in reverse
+		})
+	})
+})
diff --git a/apps/vscode/src/shared/array.ts b/apps/vscode/src/shared/array.ts
new file mode 100644
index 0000000..b87c458
--- /dev/null
+++ b/apps/vscode/src/shared/array.ts
@@ -0,0 +1,22 @@
+/**
+ * Returns the index of the last element in the array where predicate is true, and -1
+ * otherwise.
+ * @param array The source array to search in
+ * @param predicate find calls predicate once for each element of the array, in descending
+ * order, until it finds one where predicate returns true. If such an element is found,
+ * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
+ */
+export function findLastIndex<T>(array: Array<T>, predicate: (value: T, index: number, obj: T[]) => boolean): number {
+	let l = array.length
+	while (l--) {
+		if (predicate(array[l], l, array)) {
+			return l
+		}
+	}
+	return -1
+}
+
+export function findLast<T>(array: Array<T>, predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined {
+	const index = findLastIndex(array, predicate)
+	return index === -1 ? undefined : array[index]
+}
diff --git a/apps/vscode/src/shared/clients/requesty.ts b/apps/vscode/src/shared/clients/requesty.ts
new file mode 100644
index 0000000..029547f
--- /dev/null
+++ b/apps/vscode/src/shared/clients/requesty.ts
@@ -0,0 +1,20 @@
+const REQUESTY_BASE_URL = "https://router.requesty.ai/v1"
+
+type URLType = "router" | "app" | "api"
+
+const replaceCname = (baseUrl: string, type: URLType): string => {
+	if (type === "router") {
+		return baseUrl
+	}
+	return baseUrl.replace("router", type).replace("v1", "")
+}
+
+export const toRequestyServiceUrl = (baseUrl?: string, service: URLType = "router"): URL | undefined => {
+	const url = replaceCname(baseUrl || REQUESTY_BASE_URL, service)
+
+	try {
+		return new URL(url)
+	} catch (e) {
+		return undefined
+	}
+}
diff --git a/apps/vscode/src/shared/cline-rules.ts b/apps/vscode/src/shared/cline-rules.ts
new file mode 100644
index 0000000..74adb1a
--- /dev/null
+++ b/apps/vscode/src/shared/cline-rules.ts
@@ -0,0 +1 @@
+export type ClineRulesToggles = Record<string, boolean> // filepath -> enabled/disabled
diff --git a/apps/vscode/src/shared/cline/api.ts b/apps/vscode/src/shared/cline/api.ts
new file mode 100644
index 0000000..e5e1093
--- /dev/null
+++ b/apps/vscode/src/shared/cline/api.ts
@@ -0,0 +1,19 @@
+enum CLINE_API_AUTH_ENDPOINTS {
+	AUTH = "/api/v1/auth/authorize",
+	REFRESH_TOKEN = "/api/v1/auth/refresh",
+}
+
+enum CLINE_API_ENDPOINT_V1 {
+	TOKEN_EXCHANGE = "/api/v1/auth/token",
+	USER_INFO = "/api/v1/users/me",
+	FEATUREBASE_TOKEN = "/api/v1/users/me/featurebase-token",
+	ACTIVE_ACCOUNT = "/api/v1/users/active-account",
+	USER_REMOTE_CONFIG = "/api/v1/users/me/remote-config",
+	REMOTE_CONFIG = "/api/v1/organizations/{id}/remote-config",
+	API_KEYS = "/api/v1/organizations/{id}/api-keys",
+}
+
+export const CLINE_API_ENDPOINT = {
+	...CLINE_API_AUTH_ENDPOINTS,
+	...CLINE_API_ENDPOINT_V1,
+}
diff --git a/apps/vscode/src/shared/cline/banner.ts b/apps/vscode/src/shared/cline/banner.ts
new file mode 100644
index 0000000..ecadbaa
--- /dev/null
+++ b/apps/vscode/src/shared/cline/banner.ts
@@ -0,0 +1,89 @@
+/**
+ * Action types that can be triggered from banner buttons/links
+ * Frontend maps these to actual handlers
+ */
+export enum BannerActionType {
+	/** Open external URL */
+	Link = "link",
+	/** Open API settings tab */
+	ShowApiSettings = "show-api-settings",
+	/** Open feature settings tab */
+	ShowFeatureSettings = "show-feature-settings",
+	/** Open account/login view */
+	ShowAccount = "show-account",
+	/** Set the active model */
+	SetModel = "set-model",
+	/** Trigger CLI installation flow */
+	InstallCli = "install-cli",
+}
+
+/**
+ * Banner data structure for backend-to-frontend communication.
+ * Backend constructs this JSON, frontend renders it via BannerCarousel.
+ */
+export interface BannerCardData {
+	/** Unique identifier for the banner (used for dismissal tracking) */
+	id: string
+
+	/** Banner title text */
+	title: string
+
+	/** Banner description/body markdown text */
+	description: string
+
+	/**
+	 * Icon ID from Lucide icon set (e.g., "lightbulb", "megaphone", "terminal")
+	 * LINK: https://lucide.dev/icons/
+	 * Optional - if omitted, no icon is shown
+	 */
+	icon?: string
+
+	/**
+	 * Optional footer action buttons
+	 * Rendered below the description as prominent buttons
+	 */
+	actions?: BannerAction[]
+
+	/**
+	 * Platform filter - only show on specified platforms
+	 * If undefined, show on all platforms
+	 */
+	platforms?: ("windows" | "mac" | "linux")[]
+
+	/** Only show to Cline users */
+	isClineUserOnly?: boolean
+}
+
+/**
+ * Single action definition (button or link)
+ */
+export interface BannerAction {
+	/** Button/link label text */
+	title: string
+
+	/**
+	 * Action type - determines what happens on click
+	 * Defaults to "link" if omitted
+	 */
+	action?: BannerActionType
+
+	/**
+	 * Action argument - interpretation depends on action type:
+	 * - Link: URL to open
+	 * - SetModel: model ID (e.g., "anthropic/claude-opus-4.5")
+	 * - Others: generally unused
+	 */
+	arg?: string
+
+	/**
+	 * Optional model picker tab to open when using SetModel action
+	 */
+	tab?: "recommended" | "free"
+}
+
+/**
+ * The list of predefined banner config rendered by the Welcome Section UI.
+ * TODO: Backend would return a similar JSON structure in the future which we will replace this with.
+ */
+
+export const BANNER_DATA: BannerCardData[] = []
diff --git a/apps/vscode/src/shared/cline/context.ts b/apps/vscode/src/shared/cline/context.ts
new file mode 100644
index 0000000..cd1c7c3
--- /dev/null
+++ b/apps/vscode/src/shared/cline/context.ts
@@ -0,0 +1,210 @@
+/**
+ * A Copy of the Type Definition for Visual Studio Code 1.84 Extension API
+ * See https://code.visualstudio.com/api for more information
+ */
+
+import { URI } from "vscode-uri"
+
+enum ExtensionMode {
+	/**
+	 * The extension is installed normally (for example, from the marketplace
+	 * or VSIX) in the editor.
+	 */
+	Production = 1,
+
+	/**
+	 * The extension is running from an `--extensionDevelopmentPath` provided
+	 * when launching the editor.
+	 */
+	Development = 2,
+
+	/**
+	 * The extension is running from an `--extensionTestsPath` and
+	 * the extension host is running unit tests.
+	 */
+	Test = 3,
+}
+
+export interface ClineExtensionContext {
+	/**
+	 * An array to which disposables can be added. When this
+	 * extension is deactivated the disposables will be disposed.
+	 *
+	 * *Note* that asynchronous dispose-functions aren't awaited.
+	 */
+	readonly subscriptions: {
+		/**
+		 * Function to clean up resources.
+		 */
+		dispose(): any
+	}[]
+
+	/**
+	 * The uri of the directory containing the extension.
+	 */
+	readonly extensionUri: URI
+
+	/**
+	 * The absolute file path of the directory containing the extension. Shorthand
+	 * notation for {@link TextDocument.uri ExtensionContext.extensionUri.fsPath} (independent of the uri scheme).
+	 */
+	readonly extensionPath: string
+
+	/**
+	 * Gets the extension's global environment variable collection for this workspace, enabling changes to be
+	 * applied to terminal environment variables.
+	 */
+	readonly environmentVariableCollection: any
+
+	/**
+	 * Get the absolute path of a resource contained in the extension.
+	 *
+	 * *Note* that an absolute uri can be constructed via {@linkcode Uri.joinPath} and
+	 * {@linkcode ExtensionContext.extensionUri extensionUri}, e.g. `vscode.Uri.joinPath(context.extensionUri, relativePath);`
+	 *
+	 * @param relativePath A relative path to a resource contained in the extension.
+	 * @returns The absolute path of the resource.
+	 */
+	asAbsolutePath(relativePath: string): string
+
+	/**
+	 * The uri of a workspace specific directory in which the extension
+	 * can store private state. The directory might not exist and creation is
+	 * up to the extension. However, the parent directory is guaranteed to be existent.
+	 * The value is `undefined` when no workspace nor folder has been opened.
+	 *
+	 * Use {@linkcode StateManager.workspaceState} or
+	 * {@linkcode StateManager.globalState} to store key value data.
+	 *
+	 * @see {@linkcode FileSystem workspace.fs} for how to read and write files and folders from
+	 *  an uri.
+	 */
+	readonly storageUri: URI | undefined
+
+	/**
+	 * An absolute file path of a workspace specific directory in which the extension
+	 * can store private state. The directory might not exist on disk and creation is
+	 * up to the extension. However, the parent directory is guaranteed to be existent.
+	 *
+	 * Use {@linkcode StateManager.workspaceState} or
+	 * {@linkcode StateManager.globalState} to store key value data.
+	 *
+	 * @deprecated Use {@link ExtensionContext.storageUri storageUri} instead.
+	 */
+	readonly storagePath: string | undefined
+
+	/**
+	 * The uri of a directory in which the extension can store global state.
+	 * The directory might not exist on disk and creation is
+	 * up to the extension. However, the parent directory is guaranteed to be existent.
+	 *
+	 * Use {@linkcode StateManager.globalState} to store key value data.
+	 *
+	 * @see {@linkcode FileSystem workspace.fs} for how to read and write files and folders from
+	 *  an uri.
+	 */
+	readonly globalStorageUri: URI
+
+	/**
+	 * An absolute file path in which the extension can store global state.
+	 * The directory might not exist on disk and creation is
+	 * up to the extension. However, the parent directory is guaranteed to be existent.
+	 *
+	 * Use {@linkcode StateManager.globalState} to store key value data.
+	 *
+	 * @deprecated Use {@link ExtensionContext.globalStorageUri globalStorageUri} instead.
+	 */
+	readonly globalStoragePath: string
+
+	/**
+	 * The uri of a directory in which the extension can create log files.
+	 * The directory might not exist on disk and creation is up to the extension. However,
+	 * the parent directory is guaranteed to be existent.
+	 *
+	 * @see {@linkcode FileSystem workspace.fs} for how to read and write files and folders from
+	 *  an uri.
+	 */
+	readonly logUri: URI
+
+	/**
+	 * An absolute file path of a directory in which the extension can create log files.
+	 * The directory might not exist on disk and creation is up to the extension. However,
+	 * the parent directory is guaranteed to be existent.
+	 *
+	 * @deprecated Use {@link ExtensionContext.logUri logUri} instead.
+	 */
+	readonly logPath: string
+
+	/**
+	 * The mode the extension is running in. See {@link ExtensionMode}
+	 * for possible values and scenarios.
+	 */
+	readonly extensionMode: ExtensionMode
+
+	/**
+	 * The current `Extension` instance.
+	 */
+	readonly extension: Extension<any>
+}
+
+enum ExtensionKind {
+	/**
+	 * Extension runs where the UI runs.
+	 */
+	UI = 1,
+
+	/**
+	 * Extension runs where the remote extension host runs.
+	 */
+	Workspace = 2,
+}
+
+interface Extension<T> {
+	/**
+	 * The canonical extension identifier in the form of: `publisher.name`.
+	 */
+	readonly id: string
+
+	/**
+	 * The uri of the directory containing the extension.
+	 */
+	readonly extensionUri: URI
+
+	/**
+	 * The absolute file path of the directory containing this extension. Shorthand
+	 * notation for {@link Extension.extensionUri Extension.extensionUri.fsPath} (independent of the uri scheme).
+	 */
+	readonly extensionPath: string
+
+	/**
+	 * `true` if the extension has been activated.
+	 */
+	readonly isActive: boolean
+
+	/**
+	 * The parsed contents of the extension's package.json.
+	 */
+	readonly packageJSON: any
+
+	/**
+	 * The extension kind describes if an extension runs where the UI runs
+	 * or if an extension runs where the remote extension host runs. The extension kind
+	 * is defined in the `package.json`-file of extensions but can also be refined
+	 * via the `remote.extensionKind`-setting. When no remote extension host exists,
+	 * the value is {@linkcode ExtensionKind.UI}.
+	 */
+	extensionKind: ExtensionKind
+
+	/**
+	 * The public API exported by this extension (return value of `activate`).
+	 * It is an invalid action to access this field before this extension has been activated.
+	 */
+	readonly exports: T
+
+	/**
+	 * Activates this extension and returns its public API.
+	 *
+	 * @returns A promise that will resolve when this extension has been activated.
+	 */
+	activate(): Thenable<T>
+}
diff --git a/apps/vscode/src/shared/cline/index.ts b/apps/vscode/src/shared/cline/index.ts
new file mode 100644
index 0000000..4e25396
--- /dev/null
+++ b/apps/vscode/src/shared/cline/index.ts
@@ -0,0 +1,7 @@
+export * from "./api"
+export * from "./context"
+export * from "./onboarding"
+
+export enum ClineClient {
+	VSCode = "VSCode Extension",
+}
diff --git a/apps/vscode/src/shared/cline/onboarding.ts b/apps/vscode/src/shared/cline/onboarding.ts
new file mode 100644
index 0000000..dd0725b
--- /dev/null
+++ b/apps/vscode/src/shared/cline/onboarding.ts
@@ -0,0 +1,104 @@
+import type { OnboardingModel } from "../proto/cline/state"
+
+/**
+ * The list of models available to new users during the onboarding flow.
+ * NOTE: Can be overridden by feature flag onboarding models payload.
+ */
+export const CLINE_ONBOARDING_MODELS: OnboardingModel[] = [
+	{
+		group: "free",
+		id: "kwaipilot/kat-coder-pro",
+		name: "KwaiKAT: Kat Coder Pro",
+		score: 88,
+		latency: 2,
+		badge: "Best",
+		info: {
+			contextWindow: 128_000,
+			supportsImages: false,
+			supportsPromptCache: false,
+			inputPrice: 0,
+			outputPrice: 0,
+			tiers: [],
+		},
+	},
+	{
+		group: "free",
+		id: "minimax/minimax-m2.5",
+		name: "MiniMax: MiniMax M2.5",
+		score: 90,
+		latency: 2,
+		badge: "New",
+		info: {
+			contextWindow: 192_000,
+			supportsImages: false,
+			supportsPromptCache: true,
+			inputPrice: 0,
+			outputPrice: 0,
+			tiers: [],
+		},
+	},
+	{
+		group: "free",
+		id: "arcee-ai/trinity-large-preview:free",
+		name: "Arcee AI: Trinity Large Preview",
+		score: 88,
+		latency: 2,
+		badge: "New",
+		info: {
+			contextWindow: 131_000,
+			supportsImages: false,
+			supportsPromptCache: false,
+			inputPrice: 0,
+			outputPrice: 0,
+			tiers: [],
+		},
+	},
+	{
+		group: "frontier",
+		id: "anthropic/claude-sonnet-4.5",
+		name: "Anthropic: Claude Sonnet 4.5",
+		badge: "",
+		score: 97,
+		latency: 3,
+		info: {
+			contextWindow: 200_000,
+			supportsImages: true,
+			supportsPromptCache: true,
+			inputPrice: 3.0,
+			outputPrice: 15.0,
+			tiers: [],
+		},
+	},
+	{
+		group: "frontier",
+		id: "google/gemini-3.1-pro-preview",
+		name: "Gemini 3.1 Pro",
+		badge: "Preview",
+		score: 97,
+		latency: 3,
+		info: {
+			contextWindow: 1_048_576,
+			supportsImages: true,
+			supportsPromptCache: true,
+			inputPrice: 4.0,
+			outputPrice: 18.0,
+			tiers: [],
+		},
+	},
+	{
+		group: "frontier",
+		id: "openai/gpt-5-codex",
+		name: "OpenAI: GPT-5 Codex",
+		badge: "Best",
+		score: 97,
+		latency: 7,
+		info: {
+			contextWindow: 400_000,
+			supportsImages: true,
+			supportsPromptCache: true,
+			inputPrice: 1.25,
+			outputPrice: 10.0,
+			tiers: [],
+		},
+	},
+]
diff --git a/apps/vscode/src/shared/cline/recommended-models.ts b/apps/vscode/src/shared/cline/recommended-models.ts
new file mode 100644
index 0000000..0ba3aa4
--- /dev/null
+++ b/apps/vscode/src/shared/cline/recommended-models.ts
@@ -0,0 +1,57 @@
+interface ClineRecommendedModel {
+	id: string
+	name: string
+	description: string
+	tags: string[]
+}
+
+export interface ClineRecommendedModelsData {
+	recommended: ClineRecommendedModel[]
+	free: ClineRecommendedModel[]
+}
+
+/**
+ * Hardcoded fallback shown when upstream recommended models are not enabled or unavailable.
+ */
+export const CLINE_RECOMMENDED_MODELS_FALLBACK: ClineRecommendedModelsData = {
+	recommended: [
+		{
+			id: "google/gemini-3.1-pro-preview",
+			name: "Google Gemini 3.1 Pro Preview",
+			description: "Latest Gemini release with 1m ctx window and strong coding performance",
+			tags: ["NEW"],
+		},
+		{
+			id: "anthropic/claude-sonnet-4.6",
+			name: "Anthropic Claude Sonnet 4.6",
+			description: "Latest Sonnet release with strong coding and agent performance",
+			tags: ["NEW"],
+		},
+		{
+			id: "anthropic/claude-opus-4.6",
+			name: "Anthropic Claude Opus 4.6",
+			description: "Most intelligent model for agents and coding",
+			tags: ["BEST"],
+		},
+		{
+			id: "openai/gpt-5.3-codex",
+			name: "OpenAI GPT-5.3 Codex",
+			description: "OpenAI's latest with strong coding abilities",
+			tags: ["NEW"],
+		},
+	],
+	free: [
+		{
+			id: "kwaipilot/kat-coder-pro",
+			name: "KwaiKAT Kat Coder Pro",
+			description: "KwaiKAT's most advanced agentic coding model in the KAT-Coder series",
+			tags: ["FREE"],
+		},
+		{
+			id: "arcee-ai/trinity-large-preview:free",
+			name: "Arcee AI Trinity Large Preview",
+			description: "Arcee AI's advanced large preview model in the Trinity series",
+			tags: ["FREE"],
+		},
+	],
+}
diff --git a/apps/vscode/src/shared/combineApiRequests.ts b/apps/vscode/src/shared/combineApiRequests.ts
new file mode 100644
index 0000000..e017ec3
--- /dev/null
+++ b/apps/vscode/src/shared/combineApiRequests.ts
@@ -0,0 +1,65 @@
+import { ClineMessage } from "./ExtensionMessage"
+
+/**
+ * Combines API request start and finish messages in an array of ClineMessages.
+ *
+ * This function looks for pairs of 'api_req_started' and 'api_req_finished' messages.
+ * When it finds a pair, it combines them into a single 'api_req_combined' message.
+ * The JSON data in the text fields of both messages are merged.
+ *
+ * @param messages - An array of ClineMessage objects to process.
+ * @returns A new array of ClineMessage objects with API requests combined.
+ *
+ * @example
+ * const messages = [
+ *   { type: "say", say: "api_req_started", text: '{"request":"GET /api/data"}', ts: 1000 },
+ *   { type: "say", say: "api_req_finished", text: '{"cost":0.005}', ts: 1001 }
+ * ];
+ * const result = combineApiRequests(messages);
+ * // Result: [{ type: "say", say: "api_req_started", text: '{"request":"GET /api/data","cost":0.005}', ts: 1000 }]
+ */
+export function combineApiRequests(messages: ClineMessage[]): ClineMessage[] {
+	const combinedApiRequests: ClineMessage[] = []
+
+	for (let i = 0; i < messages.length; i++) {
+		if (messages[i].type === "say" && messages[i].say === "api_req_started") {
+			const startedRequest = JSON.parse(messages[i].text || "{}")
+			let j = i + 1
+
+			while (j < messages.length) {
+				if (messages[j].type === "say" && messages[j].say === "api_req_finished") {
+					const finishedRequest = JSON.parse(messages[j].text || "{}")
+					const combinedRequest = {
+						...startedRequest,
+						...finishedRequest,
+					}
+
+					combinedApiRequests.push({
+						...messages[i],
+						text: JSON.stringify(combinedRequest),
+					})
+
+					i = j // Skip to the api_req_finished message
+					break
+				}
+				j++
+			}
+
+			if (j === messages.length) {
+				// If no matching api_req_finished found, keep the original api_req_started
+				combinedApiRequests.push(messages[i])
+			}
+		}
+	}
+
+	// Replace original api_req_started and remove api_req_finished
+	return messages
+		.filter((msg) => !(msg.type === "say" && msg.say === "api_req_finished"))
+		.map((msg) => {
+			if (msg.type === "say" && msg.say === "api_req_started") {
+				const combinedRequest = combinedApiRequests.find((req) => req.ts === msg.ts)
+				return combinedRequest || msg
+			}
+			return msg
+		})
+}
diff --git a/apps/vscode/src/shared/combineCommandSequences.ts b/apps/vscode/src/shared/combineCommandSequences.ts
new file mode 100644
index 0000000..6d18781
--- /dev/null
+++ b/apps/vscode/src/shared/combineCommandSequences.ts
@@ -0,0 +1,74 @@
+import { ClineMessage } from "./ExtensionMessage"
+
+/**
+ * Combines sequences of command and command_output messages in an array of ClineMessages.
+ *
+ * This function processes an array of ClineMessages objects, looking for sequences
+ * where a 'command' message is followed by one or more 'command_output' messages.
+ * When such a sequence is found, it combines them into a single message, merging
+ * their text contents.
+ *
+ * @param messages - An array of ClineMessage objects to process.
+ * @returns A new array of ClineMessage objects with command sequences combined.
+ *
+ * @example
+ * const messages: ClineMessage[] = [
+ *   { type: 'ask', ask: 'command', text: 'ls', ts: 1625097600000 },
+ *   { type: 'ask', ask: 'command_output', text: 'file1.txt', ts: 1625097601000 },
+ *   { type: 'ask', ask: 'command_output', text: 'file2.txt', ts: 1625097602000 }
+ * ];
+ * const result = simpleCombineCommandSequences(messages);
+ * // Result: [{ type: 'ask', ask: 'command', text: 'ls\nfile1.txt\nfile2.txt', ts: 1625097600000 }]
+ */
+export function combineCommandSequences(messages: ClineMessage[]): ClineMessage[] {
+	const combinedCommands: ClineMessage[] = []
+
+	// First pass: combine commands with their outputs
+	for (let i = 0; i < messages.length; i++) {
+		if (messages[i].ask === "command" || messages[i].say === "command") {
+			let combinedText = messages[i].text || ""
+			let didAddOutput = false
+			let j = i + 1
+
+			while (j < messages.length) {
+				if (messages[j].ask === "command" || messages[j].say === "command") {
+					// Stop if we encounter the next command
+					break
+				}
+				if (messages[j].ask === "command_output" || messages[j].say === "command_output") {
+					if (!didAddOutput) {
+						// Add a newline before the first output
+						combinedText += `\n${COMMAND_OUTPUT_STRING}`
+						didAddOutput = true
+					}
+					// handle cases where we receive empty command_output (ie when extension is relinquishing control over exit command button)
+					const output = messages[j].text || ""
+					if (output.length > 0) {
+						combinedText += "\n" + output
+					}
+				}
+				j++
+			}
+
+			combinedCommands.push({
+				...messages[i],
+				text: combinedText,
+			})
+
+			i = j - 1 // Move to the index just before the next command or end of array
+		}
+	}
+
+	// Second pass: remove command_outputs and replace original commands with combined ones
+	return messages
+		.filter((msg) => !(msg.ask === "command_output" || msg.say === "command_output"))
+		.map((msg) => {
+			if (msg.ask === "command" || msg.say === "command") {
+				const combinedCommand = combinedCommands.find((cmd) => cmd.ts === msg.ts)
+				return combinedCommand || msg
+			}
+			return msg
+		})
+}
+export const COMMAND_OUTPUT_STRING = "Output:"
+export const COMMAND_REQ_APP_STRING = "REQ_APP"
diff --git a/apps/vscode/src/shared/combineErrorRetryMessages.ts b/apps/vscode/src/shared/combineErrorRetryMessages.ts
new file mode 100644
index 0000000..dec113d
--- /dev/null
+++ b/apps/vscode/src/shared/combineErrorRetryMessages.ts
@@ -0,0 +1,87 @@
+import { ClineMessage } from "./ExtensionMessage"
+
+/**
+ * Consolidates error_retry messages in a retry sequence, keeping only the latest one,
+ * and removes successful retry messages entirely.
+ *
+ * When an API request fails and auto-retry is enabled, multiple error_retry messages are created
+ * (e.g., "Attempt 1 of 3", "Attempt 2 of 3", "Attempt 3 of 3"), interleaved with api_req_retried
+ * messages. This function:
+ * 1. Filters out earlier retry messages, showing only the most recent one
+ * 2. Removes error_retry messages entirely when followed by a successful api_req_started
+ *    (indicating the retry succeeded)
+ *
+ * @param messages - An array of ClineMessage objects to process.
+ * @returns A new array of ClineMessage objects with error_retry sequences consolidated.
+ *
+ * @example
+ * // During retry sequence - shows only latest attempt:
+ * const messages: ClineMessage[] = [
+ *   { type: 'say', say: 'error_retry', text: '{"attempt":1,"maxAttempts":3}', ts: 1000 },
+ *   { type: 'say', say: 'api_req_retried', ts: 1001 },
+ *   { type: 'say', say: 'error_retry', text: '{"attempt":2,"maxAttempts":3}', ts: 1002 },
+ *   { type: 'say', say: 'api_req_retried', ts: 1003 },
+ *   { type: 'say', say: 'error_retry', text: '{"attempt":3,"maxAttempts":3}', ts: 1004 },
+ * ];
+ * const result = combineErrorRetryMessages(messages);
+ * // Result: [{ type: 'say', say: 'error_retry', text: '{"attempt":3,"maxAttempts":3}', ts: 1004 }]
+ *
+ * @example
+ * // After successful retry - removes error_retry entirely:
+ * const messages: ClineMessage[] = [
+ *   { type: 'say', say: 'error_retry', text: '{"attempt":1,"maxAttempts":3}', ts: 1000 },
+ *   { type: 'say', say: 'api_req_retried', ts: 1001 },
+ *   { type: 'say', say: 'api_req_started', text: '{}', ts: 1002 },
+ * ];
+ * const result = combineErrorRetryMessages(messages);
+ * // Result: [{ type: 'say', say: 'api_req_started', text: '{}', ts: 1002 }]
+ */
+export function combineErrorRetryMessages(messages: ClineMessage[]): ClineMessage[] {
+	const result: ClineMessage[] = []
+
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i]
+
+		if (message.say === "error_retry") {
+			// Look ahead to find if there's another error_retry before the next api_req_started
+			let hasLaterErrorRetry = false
+			let hasApiReqStartedBefore = false
+
+			for (let j = i + 1; j < messages.length; j++) {
+				const laterMessage = messages[j]
+				if (laterMessage.say === "api_req_started") {
+					hasApiReqStartedBefore = true
+					break
+				}
+				if (laterMessage.say === "error_retry") {
+					hasLaterErrorRetry = true
+					break
+				}
+			}
+
+			// Case 1: Another error_retry follows before api_req_started - skip this one
+			if (hasLaterErrorRetry) {
+				continue
+			}
+
+			// Case 2: api_req_started follows (no later error_retry) - retry succeeded
+			// Don't show the error_retry unless it has failed: true
+			if (hasApiReqStartedBefore) {
+				try {
+					const retryInfo = JSON.parse(message.text || "{}")
+					// Only skip if this wasn't a final failure message
+					if (!retryInfo.failed) {
+						continue
+					}
+				} catch {
+					// If we can't parse, still skip to be safe
+					continue
+				}
+			}
+		}
+
+		result.push(message)
+	}
+
+	return result
+}
diff --git a/apps/vscode/src/shared/combineHookSequences.test.ts b/apps/vscode/src/shared/combineHookSequences.test.ts
new file mode 100644
index 0000000..0dfc14b
--- /dev/null
+++ b/apps/vscode/src/shared/combineHookSequences.test.ts
@@ -0,0 +1,65 @@
+import { describe, it } from "mocha"
+import type { ClineMessage } from "./ExtensionMessage"
+import "should"
+import { combineHookSequences } from "./combineHookSequences"
+
+describe("combineHookSequences", () => {
+	it("keeps partial tool messages when no newer tool message with same timestamp exists", () => {
+		const messages: ClineMessage[] = [
+			{
+				ts: 1,
+				type: "say",
+				say: "reasoning",
+				text: "thinking...",
+				partial: true,
+			},
+			{
+				ts: 2,
+				type: "say",
+				say: "tool",
+				text: '{"tool":"editedExistingFile","path":"README.md","content":"partial"}',
+				partial: true,
+			},
+		]
+
+		const result = combineHookSequences(messages)
+		const streamedTool = result.find((msg) => msg.ts === 2)
+
+		should(streamedTool).not.be.undefined()
+		if (!streamedTool) {
+			throw new Error("Expected streamed tool message to be present")
+		}
+		should(streamedTool.partial).equal(true)
+		should(streamedTool.say).equal("tool")
+	})
+
+	it("keeps only the newest tool message variant for a shared timestamp", () => {
+		const messages: ClineMessage[] = [
+			{
+				ts: 10,
+				type: "ask",
+				ask: "tool",
+				text: '{"tool":"editedExistingFile","path":"README.md","content":"partial"}',
+				partial: true,
+			},
+			{
+				ts: 10,
+				type: "ask",
+				ask: "tool",
+				text: '{"tool":"editedExistingFile","path":"README.md","content":"final"}',
+				partial: false,
+			},
+		]
+
+		const result = combineHookSequences(messages)
+		const sameTsMessages = result.filter((msg) => msg.ts === 10)
+
+		sameTsMessages.should.have.length(1)
+		const finalMessage = sameTsMessages.at(0)
+		if (!finalMessage) {
+			throw new Error("Expected a final tool message")
+		}
+		should(finalMessage.partial).equal(false)
+		should(finalMessage.text).equal('{"tool":"editedExistingFile","path":"README.md","content":"final"}')
+	})
+})
diff --git a/apps/vscode/src/shared/combineHookSequences.ts b/apps/vscode/src/shared/combineHookSequences.ts
new file mode 100644
index 0000000..56c81c6
--- /dev/null
+++ b/apps/vscode/src/shared/combineHookSequences.ts
@@ -0,0 +1,374 @@
+import { ClineMessage } from "./ExtensionMessage"
+
+/**
+ * Hook metadata extracted from hook message text.
+ * Mirrors the ClineSayHook interface but represents parsed data.
+ */
+interface HookMetadata {
+	hookName: string
+	toolName?: string
+	status: string
+	exitCode?: number
+	hasJsonResponse?: boolean
+}
+
+type HookStatusSay = "hook" | "hook_status"
+type HookOutputStreamSay = "hook_output" | "hook_output_stream"
+
+function getSay(msg: ClineMessage): string | undefined {
+	// Back-compat: older recordings may be deserialized without strict typing.
+	return msg.say as string | undefined
+}
+
+function isHookStatusSay(say: string | undefined): say is HookStatusSay {
+	return say === "hook_status" || say === "hook"
+}
+
+function isHookOutputStreamSay(say: string | undefined): say is HookOutputStreamSay {
+	return say === "hook_output_stream" || say === "hook_output"
+}
+
+// ============================================================================
+// PART 1: TYPE GUARDS & UTILITIES
+// ============================================================================
+
+/**
+ * Type guard to check if a message is a tool or command.
+ */
+function isToolOrCommandMessage(msg: ClineMessage): boolean {
+	return msg.ask === "tool" || msg.say === "tool" || msg.ask === "command" || msg.say === "command"
+}
+
+/**
+ * Safely parses hook metadata from a hook message.
+ * Returns null if parsing fails or message is not a hook.
+ */
+function parseHookMetadata(hookMessage: ClineMessage): HookMetadata | null {
+	if (!isHookStatusSay(getSay(hookMessage)) || !hookMessage.text) {
+		return null
+	}
+
+	try {
+		const outputIndex = hookMessage.text.indexOf(HOOK_OUTPUT_STRING)
+		const metadataStr = outputIndex !== -1 ? hookMessage.text.slice(0, outputIndex).trim() : hookMessage.text.trim()
+
+		return JSON.parse(metadataStr) as HookMetadata
+	} catch {
+		return null
+	}
+}
+
+// ============================================================================
+// PART 2: FILTERING & COMBINING
+// ============================================================================
+
+/**
+ * Deduplicates tool/command messages by timestamp while preserving all
+ * non-tool messages and the newest tool/command version for each timestamp.
+ *
+ * This preserves streaming partial tool rows in the UI while still preventing
+ * duplicate tool/command entries when both partial and final variants exist.
+ */
+function dedupeToolOrCommandMessagesByTimestamp(messages: ClineMessage[]): ClineMessage[] {
+	const lastToolOrCommandIndexByTs = new Map<number, number>()
+
+	for (let i = 0; i < messages.length; i++) {
+		if (isToolOrCommandMessage(messages[i])) {
+			lastToolOrCommandIndexByTs.set(messages[i].ts, i)
+		}
+	}
+
+	return messages.filter((msg, index) => {
+		if (!isToolOrCommandMessage(msg)) {
+			return true
+		}
+		return lastToolOrCommandIndexByTs.get(msg.ts) === index
+	})
+}
+
+/**
+ * Combines a single hook message with all subsequent hook_output messages.
+ *
+ * @param hookMessage The hook message to start combining from
+ * @param startIndex The index of the hook message in the messages array
+ * @param messages The full messages array
+ * @returns Object containing the combined message and the next index to process
+ */
+function combineHookWithOutputs(
+	hookMessage: ClineMessage,
+	startIndex: number,
+	messages: ClineMessage[],
+): { combined: ClineMessage; nextIndex: number } {
+	let combinedText = hookMessage.text || ""
+	let hasOutput = false
+	let i = startIndex + 1
+
+	// Collect all hook_output_stream messages until we hit another hook_status/hook or end of array
+	while (i < messages.length && !isHookStatusSay(getSay(messages[i]))) {
+		const say = getSay(messages[i])
+		if (isHookOutputStreamSay(say)) {
+			// Add marker before first output
+			if (!hasOutput) {
+				combinedText += `\n${HOOK_OUTPUT_STRING}`
+				hasOutput = true
+			}
+
+			// Append output if not empty
+			const output = messages[i].text || ""
+			if (output.length > 0) {
+				combinedText += "\n" + output
+			}
+		}
+		i++
+	}
+
+	return {
+		combined: { ...hookMessage, text: combinedText },
+		nextIndex: i,
+	}
+}
+
+/**
+ * Combines all hooks with their outputs and removes hook_output messages.
+ *
+ * This is a two-pass process:
+ * 1. Scan through and combine each hook with its outputs
+ * 2. Build final array without hook_output messages, using combined hooks
+ */
+function combineAllHooks(messages: ClineMessage[]): ClineMessage[] {
+	// Pass 1: Build map of combined hooks by timestamp
+	const combinedHooksByTs = new Map<number, ClineMessage>()
+
+	for (let i = 0; i < messages.length; i++) {
+		if (isHookStatusSay(getSay(messages[i]))) {
+			const { combined, nextIndex } = combineHookWithOutputs(messages[i], i, messages)
+			combinedHooksByTs.set(combined.ts, combined)
+			i = nextIndex - 1 // Adjust for loop increment
+		}
+	}
+
+	// Pass 2: Build result array
+	const result: ClineMessage[] = []
+
+	for (const msg of messages) {
+		const say = getSay(msg)
+		if (isHookOutputStreamSay(say)) {
+		} else if (isHookStatusSay(say)) {
+			// Use combined version
+			result.push(combinedHooksByTs.get(msg.ts) || msg)
+		} else {
+			// Keep all other messages as-is
+			result.push(msg)
+		}
+	}
+
+	return result
+}
+
+// ============================================================================
+// PART 3: PRETOOLUSE REORDERING
+// ============================================================================
+
+/**
+ * Finds the timestamp of the immediate next tool/command after a given hook.
+ *
+ * This function ensures stable hook-to-tool associations by only matching a hook
+ * with the IMMEDIATE next tool (no other hooks or tools in between). This prevents
+ * hooks from being remapped to different tools when new tools are added later.
+ *
+ * @param hookIndex The starting index to search from
+ * @param messages The original messages array (may include partial tools)
+ * @returns The timestamp of the immediate next tool, or null if none found
+ */
+function findImmediateNextToolTimestamp(hookIndex: number, messages: ClineMessage[]): number | null {
+	for (let i = hookIndex + 1; i < messages.length; i++) {
+		const msg = messages[i]
+
+		// If we hit a tool, this is the immediate next tool
+		if (isToolOrCommandMessage(msg)) {
+			return msg.ts
+		}
+
+		// If we hit another PreToolUse hook before finding a tool, stop searching
+		// This prevents matching a hook to a tool that has its own PreToolUse hook
+		if (isHookStatusSay(getSay(msg))) {
+			const metadata = parseHookMetadata(msg)
+			if (metadata?.hookName === "PreToolUse") {
+				return null
+			}
+		}
+	}
+	return null
+}
+
+/**
+ * Builds a map of tool timestamps to their PreToolUse hooks.
+ *
+ * This map indicates which hooks should be moved to appear before which tools.
+ * Only PreToolUse hooks are included; PostToolUse hooks stay in their original position.
+ *
+ * A PreToolUse hook should only be mapped to a tool if the hook was created AFTER the
+ * tool already exists in the message stream. This can happen when hooks arrive late
+ * or out of order. If the hook timestamp < tool timestamp, it means the hook
+ * naturally appears before the tool chronologically and should NOT be moved.
+ *
+ * @param processedMessages Messages after filtering and combining
+ * @param originalMessages Original messages array (used to find tools)
+ * @returns Map of tool timestamp -> array of PreToolUse hooks for that tool
+ */
+function buildPreToolUseMap(processedMessages: ClineMessage[], originalMessages: ClineMessage[]): Map<number, ClineMessage[]> {
+	const map = new Map<number, ClineMessage[]>()
+
+	// Build timestamp-to-index map once to avoid O(n) findIndex calls
+	const timestampToIndex = new Map<number, number>()
+	for (let i = 0; i < originalMessages.length; i++) {
+		timestampToIndex.set(originalMessages[i].ts, i)
+	}
+
+	for (const msg of processedMessages) {
+		// Only process PreToolUse hooks
+		const metadata = parseHookMetadata(msg)
+		if (metadata?.hookName !== "PreToolUse") {
+			continue
+		}
+
+		// Find this hook's position in the original array using the index map
+		const hookIndexInOriginal = timestampToIndex.get(msg.ts)
+		if (hookIndexInOriginal === undefined) {
+			continue // Shouldn't happen, but be safe
+		}
+
+		// Find the immediate next tool after this hook in the original array
+		const toolTimestamp = findImmediateNextToolTimestamp(hookIndexInOriginal, originalMessages)
+		if (toolTimestamp === null) {
+			// No tool found - hook will stay in original position
+			continue
+		}
+
+		// CRITICAL FIX: Only map this hook to the tool if it needs to be moved.
+		// A hook only needs moving if its timestamp > tool timestamp (arrived after tool).
+		// If hook timestamp < tool timestamp, the hook naturally appears before the tool
+		// chronologically and should NOT be moved.
+		if (msg.ts > toolTimestamp) {
+			// Hook arrived after tool - needs to be moved before the tool
+			if (!map.has(toolTimestamp)) {
+				map.set(toolTimestamp, [])
+			}
+			map.get(toolTimestamp)!.push(msg)
+		}
+		// Otherwise, hook is already in correct chronological position - don't move it
+	}
+
+	return map
+}
+
+/**
+ * Reorders messages so PreToolUse hooks appear before their associated tools.
+ *
+ * Algorithm:
+ * 1. When we encounter a tool, check if it has PreToolUse hooks mapped to it
+ * 2. If yes, insert those hooks BEFORE the tool
+ * 3. Track which hooks and tools we've already added to avoid duplicates
+ * 4. For PreToolUse hooks encountered in their original position:
+ *    - If their tool is available and we'll process them before it, skip them
+ *    - Otherwise, add them in their current position (tool not available yet)
+ *
+ * @param messages Messages after filtering and combining
+ * @param preToolUseMap Map of tool timestamp -> PreToolUse hooks
+ * @returns Reordered messages array
+ */
+function reorderWithPreToolUseHooks(messages: ClineMessage[], preToolUseMap: Map<number, ClineMessage[]>): ClineMessage[] {
+	const result: ClineMessage[] = []
+	const addedHooks = new Set<number>()
+	const addedTools = new Set<number>()
+
+	// Build set of available tool timestamps for quick lookup
+	const availableTools = new Set<number>()
+	for (const msg of messages) {
+		if (isToolOrCommandMessage(msg)) {
+			availableTools.add(msg.ts)
+		}
+	}
+
+	for (const msg of messages) {
+		// Case 1: This is a tool with PreToolUse hooks
+		if (isToolOrCommandMessage(msg) && preToolUseMap.has(msg.ts)) {
+			const hooksForTool = preToolUseMap.get(msg.ts)!
+
+			// Insert hooks that haven't been added yet
+			const newHooks = hooksForTool.filter((h) => !addedHooks.has(h.ts))
+			result.push(...newHooks)
+			newHooks.forEach((h) => addedHooks.add(h.ts))
+
+			// Add the tool
+			result.push(msg)
+			addedTools.add(msg.ts)
+			continue
+		}
+
+		// Case 2: This tool was already added with its hooks
+		if (addedTools.has(msg.ts)) {
+			continue
+		}
+
+		// Case 3: This is a PreToolUse hook in its original position
+		const metadata = parseHookMetadata(msg)
+		if (metadata?.hookName === "PreToolUse") {
+			// Find which tool (if any) this hook is mapped to
+			let mappedToolTs: number | undefined
+			for (const [toolTs, hooks] of preToolUseMap) {
+				if (hooks.some((h) => h.ts === msg.ts)) {
+					mappedToolTs = toolTs
+					break
+				}
+			}
+
+			// If this hook's tool is available and we'll insert it before that tool, skip it here
+			if (mappedToolTs !== undefined && availableTools.has(mappedToolTs)) {
+				continue
+			}
+
+			// Otherwise, keep hook in original position (tool not available yet)
+		}
+
+		// Case 4: All other messages (text, PostToolUse hooks, reasoning, etc.)
+		result.push(msg)
+	}
+
+	return result
+}
+
+// ============================================================================
+// MAIN FUNCTION
+// ============================================================================
+
+/**
+ * Combines sequences of hook and hook_output messages, and reorders
+ * PreToolUse hooks to appear before their associated tool messages.
+ *
+ * Process:
+ * 1. Deduplicate tool/command messages by timestamp (preserve newest variant)
+ * 2. Combine hooks with their hook_output messages
+ * 3. Build mapping of tools to their PreToolUse hooks
+ * 4. Reorder so PreToolUse hooks appear before their tools
+ *
+ * @param messages Array of ClineMessage objects to process
+ * @returns New array with hooks combined and PreToolUse hooks reordered
+ */
+export function combineHookSequences(messages: ClineMessage[]): ClineMessage[] {
+	// Phase 1: Deduplicate tool/command messages while preserving streaming partials
+	const filtered = dedupeToolOrCommandMessagesByTimestamp(messages)
+
+	// Phase 2: Combine hooks with their outputs
+	const combined = combineAllHooks(filtered)
+
+	// Phase 3: Build PreToolUse hook mapping
+	const preToolUseMap = buildPreToolUseMap(combined, messages)
+
+	// Phase 4: Reorder to place PreToolUse hooks before tools
+	const reordered = reorderWithPreToolUseHooks(combined, preToolUseMap)
+
+	return reordered
+}
+
+const HOOK_OUTPUT_STRING = "__HOOK_OUTPUT__"
diff --git a/apps/vscode/src/shared/config-types.ts b/apps/vscode/src/shared/config-types.ts
new file mode 100644
index 0000000..5869db3
--- /dev/null
+++ b/apps/vscode/src/shared/config-types.ts
@@ -0,0 +1,18 @@
+/**
+ * Shared configuration types that can be safely imported by both the extension and webview.
+ * This file should not contain any Node.js-specific imports or runtime code.
+ */
+
+export enum Environment {
+	production = "production",
+	staging = "staging",
+	local = "local",
+	selfHosted = "selfHosted",
+}
+
+export interface EnvironmentConfig {
+	environment: Environment
+	appBaseUrl: string
+	apiBaseUrl: string
+	mcpBaseUrl: string
+}
diff --git a/apps/vscode/src/shared/constants.ts b/apps/vscode/src/shared/constants.ts
new file mode 100644
index 0000000..26c3ac1
--- /dev/null
+++ b/apps/vscode/src/shared/constants.ts
@@ -0,0 +1,19 @@
+/**
+ * `BUILD_CONSTANTS` represent the variables that will be overwriten at build-time with predefined values.
+ * Once the extension has been built, the values in this object will be fixed.
+ *
+ * @see [esbuild.mjs](../../esbuild.mjs)
+ * @see {@link https://esbuild.github.io/api/#define|docs}
+ */
+export const BUILD_CONSTANTS = {
+	TELEMETRY_SERVICE_API_KEY: process.env.TELEMETRY_SERVICE_API_KEY,
+	ERROR_SERVICE_API_KEY: process.env.ERROR_SERVICE_API_KEY,
+	ENABLE_ERROR_AUTOCAPTURE: process.env.ENABLE_ERROR_AUTOCAPTURE,
+	OTEL_TELEMETRY_ENABLED: process.env.OTEL_TELEMETRY_ENABLED,
+	OTEL_METRICS_EXPORTER: process.env.OTEL_METRICS_EXPORTER,
+	OTEL_LOGS_EXPORTER: process.env.OTEL_LOGS_EXPORTER,
+	OTEL_EXPORTER_OTLP_PROTOCOL: process.env.OTEL_EXPORTER_OTLP_PROTOCOL,
+	OTEL_EXPORTER_OTLP_ENDPOINT: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+	OTEL_EXPORTER_OTLP_HEADERS: process.env.OTEL_EXPORTER_OTLP_HEADERS,
+	OTEL_METRIC_EXPORT_INTERVAL: process.env.OTEL_METRIC_EXPORT_INTERVAL,
+}
diff --git a/apps/vscode/src/shared/content-limits.ts b/apps/vscode/src/shared/content-limits.ts
new file mode 100644
index 0000000..d708f22
--- /dev/null
+++ b/apps/vscode/src/shared/content-limits.ts
@@ -0,0 +1,39 @@
+/**
+ * Content size limits to prevent massive files/responses from bricking conversations.
+ * 400KB ≈ ~100,000 tokens, which is a reasonable limit for context.
+ */
+
+/** Maximum content size in bytes (400KB) */
+const MAX_CONTENT_SIZE_BYTES = 400 * 1024
+
+/**
+ * Format bytes into a human-readable string (e.g., "1.5 MB", "400 KB").
+ */
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) {
+		return `${bytes} B`
+	}
+	if (bytes < 1024 * 1024) {
+		return `${(bytes / 1024).toFixed(1)} KB`
+	}
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+}
+
+/**
+ * Truncate content if it exceeds the maximum size limit.
+ * Shows the beginning of the content with a clear truncation notice at the very end.
+ *
+ * @param content The content to potentially truncate
+ * @param maxSize Maximum size in bytes (defaults to MAX_CONTENT_SIZE_BYTES)
+ * @returns The original content if under limit, or truncated content with message at end
+ */
+export function truncateContent(content: string, maxSize: number = MAX_CONTENT_SIZE_BYTES): string {
+	if (content.length <= maxSize) {
+		return content
+	}
+
+	const truncatedContent = content.slice(0, maxSize)
+	const truncatedAmount = content.length - maxSize
+
+	return `${truncatedContent}\n\n---\n\n[FILE TRUNCATED: This content is ${formatBytes(content.length)} but only the first ${formatBytes(maxSize)} is shown (${formatBytes(truncatedAmount)} truncated). Use search_files to find specific patterns, or execute_command with grep/head/tail for targeted reading.]`
+}
diff --git a/apps/vscode/src/shared/context-mentions.ts b/apps/vscode/src/shared/context-mentions.ts
new file mode 100644
index 0000000..6cf4238
--- /dev/null
+++ b/apps/vscode/src/shared/context-mentions.ts
@@ -0,0 +1,66 @@
+/*
+Mention regex:
+- **Purpose**: 
+  - To identify and highlight specific mentions in text that start with '@'. 
+  - These mentions can be file paths, URLs, or the exact word 'problems'.
+  - Ensures that trailing punctuation marks (like commas, periods, etc.) are not included in the match, allowing punctuation to follow the mention without being part of it.
+
+- **Regex Breakdown**:
+  - `/@`: 
+	- **@**: The mention must start with the '@' symbol.
+  
+  - `((?:\/|\w+:\/\/)[^\s]+?|problems\b)`:
+	- **Capturing Group (`(...)`)**: Captures the part of the string that matches one of the specified patterns.
+	- `(?:\/|\w+:\/\/)`: 
+	  - **Non-Capturing Group (`(?:...)`)**: Groups the alternatives without capturing them for back-referencing.
+	  - `\/`: 
+		- **Slash (`/`)**: Indicates that the mention is a file or folder path starting with a '/'.
+	  - `|`: Logical OR.
+	  - `\w+:\/\/`: 
+		- **Protocol (`\w+://`)**: Matches URLs that start with a word character sequence followed by '://', such as 'http://', 'https://', 'ftp://', etc.
+	- `[^\s]+?`: 
+	  - **Non-Whitespace Characters (`[^\s]+`)**: Matches one or more characters that are not whitespace.
+	  - **Non-Greedy (`+?`)**: Ensures the smallest possible match, preventing the inclusion of trailing punctuation.
+	- `|`: Logical OR.
+	- `problems\b`: 
+      - **Exact Word ('problems')**: Matches the exact word 'problems'.
+      - **Word Boundary (`\b`)**: Ensures that 'problems' is matched as a whole word and not as part of another word (e.g., 'problematic').
+    - `terminal\b`:
+      - **Exact Word ('terminal')**: Matches the exact word 'terminal'.
+      - **Word Boundary (`\b`)**: Ensures that 'terminal' is matched as a whole word and not as part of another word (e.g., 'terminals').
+
+  - `(?=[.,;:!?()]*(?=[\s\r\n]|$))`:
+	- **Positive Lookahead (`(?=...)`)**: Ensures that the match is followed by specific patterns without including them in the match.
+	- `[.,;:!?()]*`: 
+	  - **Optional Punctuation (`[.,;:!?()]*`)**: Matches zero or more of the specified punctuation marks (including parentheses).
+	- `(?=[\s\r\n]|$)`: 
+	  - **Nested Positive Lookahead (`(?=[\s\r\n]|$)`)**: Ensures that the punctuation (if present) is followed by a whitespace character, a line break, or the end of the string.
+  
+- **Summary**:
+  - The regex effectively matches:
+	- Mentions that are file or folder paths starting with '/' and containing any non-whitespace characters (including periods within the path).
+	- URLs that start with a protocol (like 'http://') followed by any non-whitespace characters (including query parameters).
+	- The exact word 'problems'.
+  - The exact word 'terminal'.
+	- The exact word 'git-changes'.
+  - It ensures that any trailing punctuation marks (such as ',', '.', '!', etc.) are not included in the matched mention, allowing the punctuation to follow the mention naturally in the text.
+
+- **Global Regex**:
+  - `mentionRegexGlobal`: Creates a global version of the `mentionRegex` to find all matches within a given string.
+
+*/
+export const mentionRegex = new RegExp(
+	`@(` +
+		`[\\w-]+:/[^\\s]*?` + // Workspace-prefixed file paths: @workspace:name/path
+		`|[\\w-]+:"\\/[^"]*?"` + // Workspace-prefixed quoted file paths
+		`|/[^\\s]*?` + // Simple file paths (can't contain)
+		`|"\\/[^"]*?"` + // Quoted file paths which can contain spaces
+		`|(?:\\w+:\\/\\/)[^\\s]+?` + // URLs
+		`|[a-f0-9]{7,40}\\b` + // Git commit hashes
+		`|problems\\b` + // Exact word 'problems'
+		`|terminal\\b` + // Exact word 'terminal'
+		`|git-changes\\b` + // Exact word 'git-changes'
+		`)` +
+		`(?=[.,;:!?()]*(?=[\\s\\r\\n]|$))`, // Lookahead for trailing punctuation (multiple allowed)
+)
+export const mentionRegexGlobal = new RegExp(mentionRegex.source, "g")
diff --git a/apps/vscode/src/shared/focus-chain-utils.ts b/apps/vscode/src/shared/focus-chain-utils.ts
new file mode 100644
index 0000000..f0f5e75
--- /dev/null
+++ b/apps/vscode/src/shared/focus-chain-utils.ts
@@ -0,0 +1,13 @@
+/**
+ * Shared utility functions for focus chain pattern matching
+ * Used by both extension and webview
+ *  */
+
+/**
+ * Checks if a trimmed line matches focus chain item patterns
+ * @param line The trimmed line to check
+ * @returns true if the line is a focus chain item (- [ ], - [x], or - [X])
+ */
+export function isFocusChainItem(line: string): boolean {
+	return line.startsWith("- [ ]") || line.startsWith("- [x]") || line.startsWith("- [X]")
+}
diff --git a/apps/vscode/src/shared/getApiMetrics.ts b/apps/vscode/src/shared/getApiMetrics.ts
new file mode 100644
index 0000000..b268b2a
--- /dev/null
+++ b/apps/vscode/src/shared/getApiMetrics.ts
@@ -0,0 +1,99 @@
+import { ClineMessage } from "./ExtensionMessage"
+
+interface ApiMetrics {
+	totalTokensIn: number
+	totalTokensOut: number
+	totalCacheWrites?: number
+	totalCacheReads?: number
+	totalCost: number
+}
+
+/**
+ * Calculates API metrics from an array of ClineMessages.
+ *
+ * This function processes usage-carrying say messages.
+ * It includes:
+ * - 'api_req_started' messages that have been combined with their corresponding 'api_req_finished' messages
+ * - 'deleted_api_reqs' messages, which are aggregated from deleted messages
+ * - 'subagent_usage' messages, which are aggregated usage snapshots emitted by subagent batches
+ * It extracts and sums up the tokensIn, tokensOut, cacheWrites, cacheReads, and cost from these messages.
+ *
+ * @param messages - An array of ClineMessage objects to process.
+ * @returns An ApiMetrics object containing totalTokensIn, totalTokensOut, totalCacheWrites, totalCacheReads, and totalCost.
+ *
+ * @example
+ * const messages = [
+ *   { type: "say", say: "api_req_started", text: '{"request":"GET /api/data","tokensIn":10,"tokensOut":20,"cost":0.005}', ts: 1000 }
+ * ];
+ * const { totalTokensIn, totalTokensOut, totalCost } = getApiMetrics(messages);
+ * // Result: { totalTokensIn: 10, totalTokensOut: 20, totalCost: 0.005 }
+ */
+export function getApiMetrics(messages: ClineMessage[]): ApiMetrics {
+	const result: ApiMetrics = {
+		totalTokensIn: 0,
+		totalTokensOut: 0,
+		totalCacheWrites: undefined,
+		totalCacheReads: undefined,
+		totalCost: 0,
+	}
+
+	messages.forEach((message) => {
+		if (
+			message.type === "say" &&
+			(message.say === "api_req_started" || message.say === "deleted_api_reqs" || message.say === "subagent_usage") &&
+			message.text
+		) {
+			try {
+				const parsedData = JSON.parse(message.text)
+				const { tokensIn, tokensOut, cacheWrites, cacheReads, cost } = parsedData
+
+				if (typeof tokensIn === "number") {
+					result.totalTokensIn += tokensIn
+				}
+				if (typeof tokensOut === "number") {
+					result.totalTokensOut += tokensOut
+				}
+				if (typeof cacheWrites === "number") {
+					result.totalCacheWrites = (result.totalCacheWrites ?? 0) + cacheWrites
+				}
+				if (typeof cacheReads === "number") {
+					result.totalCacheReads = (result.totalCacheReads ?? 0) + cacheReads
+				}
+				if (typeof cost === "number") {
+					result.totalCost += cost
+				}
+			} catch {
+				// Ignore JSON parse errors
+			}
+		}
+	})
+
+	return result
+}
+
+/**
+ * Gets the total token count from the last API request.
+ *
+ * This is used for context window progress display - it shows how much of the
+ * context window is used in the current/most recent request, not cumulative totals.
+ *
+ * @param messages - An array of ClineMessage objects to process.
+ * @returns The total tokens (tokensIn + tokensOut + cacheWrites + cacheReads) from the last api_req_started message, or 0 if none found.
+ */
+export function getLastApiReqTotalTokens(messages: ClineMessage[]): number {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i]
+		if (msg.type === "say" && msg.say === "api_req_started" && msg.text) {
+			try {
+				const { tokensIn, tokensOut, cacheWrites, cacheReads } = JSON.parse(msg.text)
+				const total = (tokensIn || 0) + (tokensOut || 0) + (cacheWrites || 0) + (cacheReads || 0)
+				if (total > 0) {
+					return total
+				}
+			} catch {
+				// Ignore JSON parse errors, continue searching
+			}
+		}
+	}
+	return 0
+}
diff --git a/apps/vscode/src/shared/internal/account.ts b/apps/vscode/src/shared/internal/account.ts
new file mode 100644
index 0000000..423f283
--- /dev/null
+++ b/apps/vscode/src/shared/internal/account.ts
@@ -0,0 +1,16 @@
+/**
+ * List of email domains that are considered trusted testers for Cline.
+ */
+const CLINE_TRUSTED_TESTER_DOMAINS = ["fibilabs.tech"]
+
+/**
+ * Checks if the given email belongs to a Cline bot user.
+ * E.g. Emails ending with @cline.bot
+ */
+function isClineBotUser(email: string): boolean {
+	return email.endsWith("@cline.bot")
+}
+
+export function isClineInternalTester(email: string): boolean {
+	return isClineBotUser(email) || CLINE_TRUSTED_TESTER_DOMAINS.some((d) => email.endsWith(`@${d}`))
+}
diff --git a/apps/vscode/src/shared/mcp.ts b/apps/vscode/src/shared/mcp.ts
new file mode 100644
index 0000000..72dc6f9
--- /dev/null
+++ b/apps/vscode/src/shared/mcp.ts
@@ -0,0 +1,143 @@
+/**
+ * Identifier for the MCP tools that are used in native tool calls,
+ * where each tool name is the combination of the server name + identifier + tool name.
+ * This enables to uniquely identify which MCP server a tool belongs to.
+ */
+export const DEFAULT_MCP_TIMEOUT_SECONDS = 60 // matches Anthropic's default timeout in their MCP SDK
+export const MIN_MCP_TIMEOUT_SECONDS = 1
+
+export type McpServer = {
+	name: string
+	config: string
+	status: "connected" | "connecting" | "disconnected"
+	error?: string
+	tools?: McpTool[]
+	resources?: McpResource[]
+	resourceTemplates?: McpResourceTemplate[]
+	prompts?: McpPrompt[]
+	disabled?: boolean
+	timeout?: number
+	uid?: string
+	oauthRequired?: boolean
+	oauthAuthStatus?: McpOAuthAuthStatus
+}
+
+export type McpOAuthAuthStatus = "authenticated" | "unauthenticated" | "pending"
+
+export type McpTool = {
+	name: string
+	description?: string
+	inputSchema?: object
+	autoApprove?: boolean
+}
+
+export type McpResource = {
+	uri: string
+	name: string
+	mimeType?: string
+	description?: string
+}
+
+export type McpResourceTemplate = {
+	uriTemplate: string
+	name: string
+	description?: string
+	mimeType?: string
+}
+
+export type McpPromptArgument = {
+	name: string
+	description?: string
+	required?: boolean
+}
+
+export type McpPrompt = {
+	name: string
+	title?: string
+	description?: string
+	arguments?: McpPromptArgument[]
+}
+
+type McpPromptMessageContent =
+	| {
+			type: "text"
+			text: string
+	  }
+	| {
+			type: "image"
+			data: string
+			mimeType: string
+	  }
+	| {
+			type: "audio"
+			data: string
+			mimeType: string
+	  }
+	| {
+			type: "resource"
+			resource: {
+				uri: string
+				mimeType?: string
+				text?: string
+				blob?: string
+			}
+	  }
+
+type McpPromptMessage = {
+	role: "user" | "assistant"
+	content: McpPromptMessageContent
+}
+
+export type McpPromptResponse = {
+	description?: string
+	messages: McpPromptMessage[]
+}
+
+export type McpResourceResponse = {
+	_meta?: Record<string, any>
+	contents: Array<{
+		uri: string
+		mimeType?: string
+		text?: string
+		blob?: string
+	}>
+}
+
+export type McpToolCallResponse = {
+	_meta?: Record<string, any>
+	content: Array<
+		| {
+				type: "text"
+				text: string
+		  }
+		| {
+				type: "image"
+				data: string
+				mimeType: string
+		  }
+		| {
+				type: "audio"
+				data: string
+				mimeType: string
+		  }
+		| {
+				type: "resource"
+				resource: {
+					uri: string
+					mimeType?: string
+					text?: string
+					blob?: string
+				}
+		  }
+		| {
+				type: "resource_link"
+				uri: string
+				name?: string
+				description?: string
+				mimeType?: string
+		  }
+	>
+	isError?: boolean
+}
+
+export type McpViewTab = "addRemote" | "configure"
diff --git a/apps/vscode/src/shared/messages/content.ts b/apps/vscode/src/shared/messages/content.ts
new file mode 100644
index 0000000..0ce4713
--- /dev/null
+++ b/apps/vscode/src/shared/messages/content.ts
@@ -0,0 +1,179 @@
+import type { Anthropic } from "@anthropic-ai/sdk"
+import type { ClineMessageMetricsInfo, ClineMessageModelInfo } from "./metrics"
+
+export type ClinePromptInputContent = string
+
+export type ClineMessageRole = "user" | "assistant"
+
+export interface ClineReasoningDetailParam {
+	type: "reasoning.text" | string
+	text: string
+	signature: string
+	format: "anthropic-claude-v1" | string
+	index: number
+}
+
+interface ClineSharedMessageParam {
+	// The id of the response that the block belongs to
+	call_id?: string
+}
+
+export const REASONING_DETAILS_PROVIDERS = ["cline", "openrouter"]
+
+/**
+ * An extension of Anthropic.MessageParam that includes Cline-specific fields: reasoning_details.
+ * This ensures backward compatibility where the messages were stored in Anthropic format with additional
+ * fields unknown to Anthropic SDK.
+ */
+export interface ClineTextContentBlock extends Anthropic.TextBlockParam, ClineSharedMessageParam {
+	// reasoning_details only exists for providers listed in REASONING_DETAILS_PROVIDERS
+	reasoning_details?: ClineReasoningDetailParam[]
+	// Thought Signature associates with Gemini
+	signature?: string
+}
+
+export interface ClineImageContentBlock extends Anthropic.ImageBlockParam, ClineSharedMessageParam {}
+
+export interface ClineDocumentContentBlock extends Anthropic.DocumentBlockParam, ClineSharedMessageParam {}
+
+export interface ClineUserToolResultContentBlock extends Anthropic.ToolResultBlockParam, ClineSharedMessageParam {}
+
+/**
+ * Assistant only content types
+ */
+export interface ClineAssistantToolUseBlock extends Anthropic.ToolUseBlockParam, ClineSharedMessageParam {
+	// reasoning_details only exists for providers listed in REASONING_DETAILS_PROVIDERS
+	reasoning_details?: unknown[] | ClineReasoningDetailParam[]
+	// Thought Signature associates with Gemini
+	signature?: string
+}
+
+export interface ClineAssistantThinkingBlock extends Anthropic.ThinkingBlock, ClineSharedMessageParam {
+	// The summary items returned by OpenAI response API
+	// The reasoning details that will be moved to the text block when finalized
+	summary?: unknown[] | ClineReasoningDetailParam[]
+}
+
+export interface ClineAssistantRedactedThinkingBlock extends Anthropic.RedactedThinkingBlockParam, ClineSharedMessageParam {}
+
+export type ClineToolResponseContent = ClinePromptInputContent | Array<ClineTextContentBlock | ClineImageContentBlock>
+
+export type ClineUserContent =
+	| ClineTextContentBlock
+	| ClineImageContentBlock
+	| ClineDocumentContentBlock
+	| ClineUserToolResultContentBlock
+
+export type ClineAssistantContent =
+	| ClineTextContentBlock
+	| ClineImageContentBlock
+	| ClineDocumentContentBlock
+	| ClineAssistantToolUseBlock
+	| ClineAssistantThinkingBlock
+	| ClineAssistantRedactedThinkingBlock
+
+export type ClineContent = ClineUserContent | ClineAssistantContent
+
+/**
+ * An extension of Anthropic.MessageParam that includes Cline-specific fields.
+ * This ensures backward compatibility where the messages were stored in Anthropic format,
+ * while allowing for additional metadata specific to Cline to avoid unknown fields in Anthropic SDK
+ * added by ignoring the type checking for those fields.
+ */
+export interface ClineStorageMessage extends Anthropic.MessageParam {
+	/**
+	 * Response ID associated with this message
+	 */
+	id?: string
+	role: ClineMessageRole
+	content: ClinePromptInputContent | ClineContent[]
+	/**
+	 * NOTE: model information used when generating this message.
+	 * Internal use for message conversion only.
+	 * MUST be removed before sending message to any LLM provider.
+	 */
+	modelInfo?: ClineMessageModelInfo
+	/**
+	 * LLM operational and performance metrics for this message
+	 * Includes token counts, costs.
+	 */
+	metrics?: ClineMessageMetricsInfo
+	/**
+	 * Timestamp of when the message was created
+	 */
+	ts?: number
+}
+
+/**
+ * Converts ClineStorageMessage to Anthropic.MessageParam by removing Cline-specific fields
+ * Cline-specific fields (like modelInfo, reasoning_details) are properly omitted.
+ */
+export function convertClineStorageToAnthropicMessage(
+	clineMessage: ClineStorageMessage,
+	provider = "anthropic",
+): Anthropic.MessageParam {
+	const { role, content } = clineMessage
+
+	// Handle string content - fast path
+	if (typeof content === "string") {
+		return { role, content }
+	}
+
+	// Removes thinking block that has no signature (invalid thinking block that's incompatible with Anthropic API)
+	const filteredContent = content.filter((b) => b.type !== "thinking" || !!b.signature)
+
+	// Handle array content - strip Cline-specific fields for non-reasoning_details providers
+	const shouldCleanContent = !REASONING_DETAILS_PROVIDERS.includes(provider)
+	const cleanedContent = shouldCleanContent
+		? filteredContent.map(cleanContentBlock)
+		: (filteredContent as Anthropic.MessageParam["content"])
+
+	return { role, content: cleanedContent }
+}
+
+/**
+ * Cline stores images as base64, so an image block's source is always a base64 source.
+ * The Anthropic SDK types the source as a Base64ImageSource | URLImageSource union, so this
+ * narrows to the base64 variant for the transform layer. URL sources are not produced by Cline,
+ * so they degrade to empty values rather than throwing.
+ */
+export function getBase64ImageSource(source: Anthropic.ImageBlockParam["source"]): { mediaType: string; data: string } {
+	if (source.type === "base64") {
+		return { mediaType: source.media_type, data: source.data }
+	}
+	return { mediaType: "", data: "" }
+}
+
+/**
+ * Builds a base64 data URL from an image block's source. See getBase64ImageSource.
+ */
+export function getImageDataUrl(source: Anthropic.ImageBlockParam["source"]): string {
+	const { mediaType, data } = getBase64ImageSource(source)
+	return `data:${mediaType};base64,${data}`
+}
+
+/**
+ * Clean a content block by removing Cline-specific fields and returning only Anthropic-compatible fields
+ */
+export function cleanContentBlock(block: ClineContent): Anthropic.ContentBlock {
+	// Fast path: if no Cline-specific fields exist, return as-is
+	const hasClineFields =
+		"reasoning_details" in block ||
+		"call_id" in block ||
+		"summary" in block ||
+		(block.type !== "thinking" && "signature" in block)
+
+	if (!hasClineFields) {
+		return block as Anthropic.ContentBlock
+	}
+
+	// Removes Cline-specific fields & the signature field that's added for Gemini.
+	const { reasoning_details, call_id, summary, ...rest } = block as any
+
+	// Remove signature from non-thinking blocks that were added for Gemini
+	if (block.type !== "thinking" && rest.signature) {
+		rest.signature = undefined
+	}
+
+	return rest satisfies Anthropic.ContentBlock
+}
diff --git a/apps/vscode/src/shared/messages/index.ts b/apps/vscode/src/shared/messages/index.ts
new file mode 100644
index 0000000..b5b91cd
--- /dev/null
+++ b/apps/vscode/src/shared/messages/index.ts
@@ -0,0 +1,3 @@
+// Core content types
+export type { ClineToolResponseContent } from "./content"
+export type { ClineMessageModelInfo } from "./metrics"
diff --git a/apps/vscode/src/shared/messages/metrics.ts b/apps/vscode/src/shared/messages/metrics.ts
new file mode 100644
index 0000000..5cc0200
--- /dev/null
+++ b/apps/vscode/src/shared/messages/metrics.ts
@@ -0,0 +1,18 @@
+import { Mode } from "../storage/types"
+
+export interface ClineMessageModelInfo {
+	modelId: string
+	providerId: string
+	mode: Mode
+}
+
+interface ClineTokensInfo {
+	prompt: number // Total input tokens (includes cached + non-cached)
+	completion: number // Total output tokens
+	cached: number // Subset of prompt_tokens that were cache hits
+}
+
+export interface ClineMessageMetricsInfo {
+	tokens?: ClineTokensInfo
+	cost?: number // Monetary cost for this turn
+}
diff --git a/apps/vscode/src/shared/model-catalog/provider-helpers.test.ts b/apps/vscode/src/shared/model-catalog/provider-helpers.test.ts
new file mode 100644
index 0000000..4a175a6
--- /dev/null
+++ b/apps/vscode/src/shared/model-catalog/provider-helpers.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest"
+import { toLegacyApiProvider } from "./provider-helpers"
+
+describe("toLegacyApiProvider", () => {
+	it("up-cases the nousResearch id to its legacy ApiConfiguration spelling", () => {
+		expect(toLegacyApiProvider("nousResearch")).toBe("nousResearch")
+		expect(toLegacyApiProvider("nousresearch")).toBe("nousResearch")
+	})
+
+	it("passes through other ids unchanged", () => {
+		expect(toLegacyApiProvider("deepseek")).toBe("deepseek")
+		expect(toLegacyApiProvider("anthropic")).toBe("anthropic")
+		expect(toLegacyApiProvider("openai-codex")).toBe("openai-codex")
+	})
+})
diff --git a/apps/vscode/src/shared/model-catalog/provider-helpers.ts b/apps/vscode/src/shared/model-catalog/provider-helpers.ts
new file mode 100644
index 0000000..2229980
--- /dev/null
+++ b/apps/vscode/src/shared/model-catalog/provider-helpers.ts
@@ -0,0 +1,15 @@
+import type { ApiProvider } from "@shared/api"
+
+/**
+ * Convert SDK/catalog provider ids to the legacy `ApiProvider` spelling used
+ * by `ApiConfiguration` keys. Most ids are identical; this helper remains as
+ * the central boundary for any future spelling aliases.
+ */
+const SDK_PROVIDER_ID_TO_LEGACY_API_PROVIDER: Partial<Record<string, ApiProvider>> = {
+	nousResearch: "nousResearch",
+	nousresearch: "nousResearch",
+} satisfies Partial<Record<string, ApiProvider>>
+
+export function toLegacyApiProvider(providerId: string): ApiProvider {
+	return SDK_PROVIDER_ID_TO_LEGACY_API_PROVIDER[providerId] ?? (providerId as ApiProvider)
+}
diff --git a/apps/vscode/src/shared/multi-root/types.ts b/apps/vscode/src/shared/multi-root/types.ts
new file mode 100644
index 0000000..c3b9e6b
--- /dev/null
+++ b/apps/vscode/src/shared/multi-root/types.ts
@@ -0,0 +1,32 @@
+/**
+ * Workspace root types and interfaces for multi-workspace support
+ */
+
+export enum VcsType {
+	None = "none",
+	Git = "git",
+	Mercurial = "mercurial",
+}
+
+export interface WorkspaceRoot {
+	path: string // Absolute path to the workspace root
+	name?: string // Optional display name for the workspace (auto-derived from path if not provided)
+	vcs: VcsType // Version control system type for this root
+	commitHash?: string // Optional latest commit hash/changeset ID for VCS tracking
+}
+
+// Example usage:
+// const workspaceRoots: WorkspaceRoot[] = [
+//   {
+//     path: "/Users/dev/frontend",
+//     name: "frontend",
+//     vcs: VcsType.Git,
+//     commitHash: "a1b2c3d4e5f6789"
+//   },
+//   {
+//     path: "/Users/dev/backend",
+//     name: "backend",
+//     vcs: VcsType.Git,
+//     commitHash: "f6e5d4c3b2a1987"
+//   }
+// ]
diff --git a/apps/vscode/src/shared/net.ts b/apps/vscode/src/shared/net.ts
new file mode 100644
index 0000000..a8fdf80
--- /dev/null
+++ b/apps/vscode/src/shared/net.ts
@@ -0,0 +1,186 @@
+/**
+ * # Network Support for Cline
+ *
+ * ## Development Guidelines
+ *
+ * **Do** use `import { fetch } from '@/shared/net'` instead of global `fetch`.
+ *
+ * Global `fetch` will appear to work in VSCode, but proxy support will be
+ * broken in JetBrains or CLI.
+ *
+ * If you use Axios, **do** call `getAxiosSettings()` and spread into
+ * your Axios configuration:
+ *
+ * ```typescript
+ * import { getAxiosSettings } from '@/shared/net'
+ * await axios.get(url, {
+ *   headers: { 'X-FOO': 'BAR' },
+ *   ...getAxiosSettings()
+ * })
+ * ```
+ *
+ * **Do** remember to pass our `fetch` into your API clients:
+ *
+ * ```typescript
+ * import OpenAI from "openai"
+ * import { fetch } from "@/shared/net"
+ * this.client = new OpenAI({
+ *   apiKey: '...',
+ *   fetch, // Use configured fetch with proxy support
+ * })
+ * ```
+ *
+ * If you neglect this step, inference won't work in JetBrains and CLI
+ * through proxies.
+ *
+ * ## Proxy Support
+ *
+ * Cline uses platform-specific fetch implementations to handle proxy
+ * configuration:
+ * - **VSCode**: Uses global fetch (VSCode provides proxy configuration)
+ * - **JetBrains, CLI**: Uses undici fetch with explicit ProxyAgent
+ *
+ * Proxy configuration via standard environment variables:
+ * - `http_proxy` / `HTTP_PROXY` - Proxy for HTTP requests
+ * - `https_proxy` / `HTTPS_PROXY` - Proxy for HTTPS requests
+ * - `no_proxy` / `NO_PROXY` - Comma-separated list of hosts to bypass proxy
+ *
+ * Note, `http_proxy` etc. MUST specify the protocol to use for the proxy,
+ * for example, `https_proxy=http://proxy.corp.example:3128`. Simply specifying
+ * the proxy hostname will result in errors.
+ *
+ * ## Certificate Trust
+ *
+ * Proxies often machine-in-the-middle HTTPS connections. To make this work,
+ * they generate self-signed certificates for a host, and the client is
+ * configured to trust the proxy as a certificate authority.
+ *
+ * VSCode transparently pulls trusted certificates from the operating system
+ * and configures node trust.
+ *
+ * JetBrains exports trusted certificates from the OS and writes them to a
+ * temporary file, then configures node TLS by setting NODE_EXTRA_CA_CERTS.
+ *
+ * CLI users should set the NODE_EXTRA_CA_CERTS environment variable if
+ * necessary, because node does not automatically use the OS' trusted certs.
+ *
+ * ## Limitations in JetBrains & CLI
+ *
+ * - Proxy settings are static at startup--restart required for changes
+ * - SOCKS proxies, PAC files not supported
+ * - Proxy authentication via env vars only
+ *
+ * These are not fundamental limitations, they just need integration work.
+ *
+ * ## Troubleshooting
+ *
+ * 1. Verify proxy env vars: `echo $http_proxy $https_proxy`
+ * 2. Check certificates: `echo $NODE_EXTRA_CA_CERTS` (should point to PEM file)
+ * 3. View logs: Check ~/.cline/cline-core-service.log for network-related
+ *    failures.
+ * 4. Test connection: Use `curl -x host:port` etc. to isolate proxy
+ *    configuration versus client issues.
+ *
+ * @example
+ * ```typescript
+ * // Good - uses configured fetch
+ * import { fetch } from '@/shared/net'
+ * const response = await fetch(url)
+ *
+ * // Good - configures axios to use configured fetch
+ * import { getAxiosSettings } from '@/shared/net'
+ * await axios.get(url, { ...getAxiosSettings() })
+ * ```
+ */
+
+import { EnvHttpProxyAgent, setGlobalDispatcher, fetch as undiciFetch } from "undici"
+
+type FetchFunction = (...args: Parameters<typeof globalThis.fetch>) => ReturnType<typeof globalThis.fetch>
+
+let mockFetch: FetchFunction | undefined
+
+/**
+ * Platform-configured fetch that respects proxy settings.
+ * Use this instead of global fetch to ensure proper proxy configuration.
+ *
+ * @example
+ * ```typescript
+ * import { fetch } from '@/shared/net'
+ * const response = await fetch('https://api.example.com')
+ * ```
+ */
+export const fetch: typeof globalThis.fetch = (() => {
+	// Note: Don't use Logger here; it may not be initialized.
+
+	let baseFetch: typeof globalThis.fetch = globalThis.fetch
+	// Note: See esbuild.mjs, process.env.IS_STANDALONE is statically rewritten
+	// to "true" or "false" (as strings) in the JetBrains/CLI build.
+	// We must use explicit string comparison because "false" is truthy in JS.
+	if (process.env.IS_STANDALONE === "true") {
+		// Configure undici with ProxyAgent
+		const agent = new EnvHttpProxyAgent({})
+		setGlobalDispatcher(agent)
+		baseFetch = undiciFetch as any as typeof globalThis.fetch
+	}
+
+	return ((input: string | URL | Request, init?: RequestInit): Promise<Response> =>
+		(mockFetch || baseFetch)(input, init)) as typeof globalThis.fetch
+})()
+
+/**
+ * Mocks `fetch` for testing and calls `callback`. Then restores `fetch`. If the
+ * specified callback returns a Promise, the fetch is restored when that Promise
+ * is settled.
+ * @param theFetch the replacement function to call to implement `fetch`.
+ * @param callback `fetch` will be mocked for the duration of `callback()`.
+ * @returns the result of `callback()`.
+ */
+export function mockFetchForTesting<T>(theFetch: FetchFunction, callback: () => T): T {
+	const originalMockFetch = mockFetch
+	mockFetch = theFetch
+	let willResetSync = true
+	try {
+		const result = callback()
+		if (result instanceof Promise) {
+			willResetSync = false
+			return result.finally(() => {
+				mockFetch = originalMockFetch
+			}) as typeof result
+		}
+		return result
+	} finally {
+		if (willResetSync) {
+			mockFetch = originalMockFetch
+		}
+	}
+}
+
+/**
+ * Returns axios configuration for fetch adapter mode with our configured fetch.
+ * This ensures axios uses our platform-specific fetch implementation with
+ * proper proxy configuration.
+ *
+ * @returns Configuration object with fetch adapter and configured fetch
+ *
+ * @example
+ * ```typescript
+ * const response = await axios.get(url, {
+ *   headers: { Authorization: 'Bearer token' },
+ *   timeout: 5000,
+ *   ...getAxiosSettings()
+ * })
+ * ```
+ */
+export function getAxiosSettings(): {
+	adapter?: any
+	fetch?: typeof globalThis.fetch
+	maxBodyLength?: number
+	maxContentLength?: number
+} {
+	return {
+		adapter: "fetch" as any,
+		fetch, // Use our configured fetch
+		maxBodyLength: Number.POSITIVE_INFINITY,
+		maxContentLength: Number.POSITIVE_INFINITY,
+	}
+}
diff --git a/apps/vscode/src/shared/proto-conversions/cline-message.ts b/apps/vscode/src/shared/proto-conversions/cline-message.ts
new file mode 100644
index 0000000..abb01c8
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/cline-message.ts
@@ -0,0 +1,294 @@
+import { ClineAsk as AppClineAsk, ClineMessage as AppClineMessage, ClineSay as AppClineSay } from "@shared/ExtensionMessage"
+import { ClineAsk, ClineMessageType, ClineSay, ClineMessage as ProtoClineMessage } from "@shared/proto/cline/ui"
+
+// Helper function to convert ClineAsk string to enum
+function convertClineAskToProtoEnum(ask: AppClineAsk | undefined): ClineAsk | undefined {
+	if (!ask) {
+		return undefined
+	}
+
+	const mapping: Record<AppClineAsk, ClineAsk> = {
+		followup: ClineAsk.FOLLOWUP,
+		plan_mode_respond: ClineAsk.PLAN_MODE_RESPOND,
+		act_mode_respond: ClineAsk.ACT_MODE_RESPOND,
+		command: ClineAsk.COMMAND,
+		command_output: ClineAsk.COMMAND_OUTPUT,
+		completion_result: ClineAsk.COMPLETION_RESULT,
+		tool: ClineAsk.TOOL,
+		api_req_failed: ClineAsk.API_REQ_FAILED,
+		resume_task: ClineAsk.RESUME_TASK,
+		resume_completed_task: ClineAsk.RESUME_COMPLETED_TASK,
+		mistake_limit_reached: ClineAsk.MISTAKE_LIMIT_REACHED,
+		browser_action_launch: ClineAsk.BROWSER_ACTION_LAUNCH,
+		use_mcp_server: ClineAsk.USE_MCP_SERVER,
+		new_task: ClineAsk.NEW_TASK,
+		condense: ClineAsk.CONDENSE,
+		summarize_task: ClineAsk.SUMMARIZE_TASK,
+		report_bug: ClineAsk.REPORT_BUG,
+		use_subagents: ClineAsk.USE_SUBAGENTS,
+	}
+
+	const result = mapping[ask]
+	if (result === undefined) {
+	}
+	return result
+}
+
+// Helper function to convert ClineAsk enum to string
+function convertProtoEnumToClineAsk(ask: ClineAsk): AppClineAsk | undefined {
+	if (ask === ClineAsk.UNRECOGNIZED) {
+		return undefined
+	}
+
+	const mapping: Record<Exclude<ClineAsk, ClineAsk.UNRECOGNIZED>, AppClineAsk> = {
+		[ClineAsk.FOLLOWUP]: "followup",
+		[ClineAsk.PLAN_MODE_RESPOND]: "plan_mode_respond",
+		[ClineAsk.ACT_MODE_RESPOND]: "act_mode_respond",
+		[ClineAsk.COMMAND]: "command",
+		[ClineAsk.COMMAND_OUTPUT]: "command_output",
+		[ClineAsk.COMPLETION_RESULT]: "completion_result",
+		[ClineAsk.TOOL]: "tool",
+		[ClineAsk.API_REQ_FAILED]: "api_req_failed",
+		[ClineAsk.RESUME_TASK]: "resume_task",
+		[ClineAsk.RESUME_COMPLETED_TASK]: "resume_completed_task",
+		[ClineAsk.MISTAKE_LIMIT_REACHED]: "mistake_limit_reached",
+		[ClineAsk.BROWSER_ACTION_LAUNCH]: "browser_action_launch",
+		[ClineAsk.USE_MCP_SERVER]: "use_mcp_server",
+		[ClineAsk.NEW_TASK]: "new_task",
+		[ClineAsk.CONDENSE]: "condense",
+		[ClineAsk.SUMMARIZE_TASK]: "summarize_task",
+		[ClineAsk.REPORT_BUG]: "report_bug",
+		[ClineAsk.USE_SUBAGENTS]: "use_subagents",
+	}
+
+	return mapping[ask]
+}
+
+// Helper function to convert ClineSay string to enum
+function convertClineSayToProtoEnum(say: AppClineSay | undefined): ClineSay | undefined {
+	if (!say) {
+		return undefined
+	}
+
+	const mapping: Record<AppClineSay, ClineSay> = {
+		task: ClineSay.TASK,
+		error: ClineSay.ERROR,
+		api_req_started: ClineSay.API_REQ_STARTED,
+		api_req_finished: ClineSay.API_REQ_FINISHED,
+		text: ClineSay.TEXT,
+		reasoning: ClineSay.REASONING,
+		completion_result: ClineSay.COMPLETION_RESULT_SAY,
+		user_feedback: ClineSay.USER_FEEDBACK,
+		user_feedback_diff: ClineSay.USER_FEEDBACK_DIFF,
+		api_req_retried: ClineSay.API_REQ_RETRIED,
+		command: ClineSay.COMMAND_SAY,
+		command_output: ClineSay.COMMAND_OUTPUT_SAY,
+		tool: ClineSay.TOOL_SAY,
+		shell_integration_warning: ClineSay.SHELL_INTEGRATION_WARNING,
+		shell_integration_warning_with_suggestion: ClineSay.SHELL_INTEGRATION_WARNING,
+		browser_action_launch: ClineSay.BROWSER_ACTION_LAUNCH_SAY,
+		browser_action: ClineSay.BROWSER_ACTION,
+		browser_action_result: ClineSay.BROWSER_ACTION_RESULT,
+		mcp_server_request_started: ClineSay.MCP_SERVER_REQUEST_STARTED,
+		mcp_server_response: ClineSay.MCP_SERVER_RESPONSE,
+		mcp_notification: ClineSay.MCP_NOTIFICATION,
+		use_mcp_server: ClineSay.USE_MCP_SERVER_SAY,
+		diff_error: ClineSay.DIFF_ERROR,
+		deleted_api_reqs: ClineSay.DELETED_API_REQS,
+		clineignore_error: ClineSay.CLINEIGNORE_ERROR,
+		command_permission_denied: ClineSay.COMMAND_PERMISSION_DENIED,
+		checkpoint_created: ClineSay.CHECKPOINT_CREATED,
+		load_mcp_documentation: ClineSay.LOAD_MCP_DOCUMENTATION,
+		info: ClineSay.INFO,
+		task_progress: ClineSay.TASK_PROGRESS,
+		error_retry: ClineSay.ERROR_RETRY,
+		hook_status: ClineSay.HOOK_STATUS,
+		hook_output_stream: ClineSay.HOOK_OUTPUT_STREAM,
+		conditional_rules_applied: ClineSay.CONDITIONAL_RULES_APPLIED,
+		subagent: ClineSay.SUBAGENT_STATUS,
+		use_subagents: ClineSay.USE_SUBAGENTS_SAY,
+		subagent_usage: ClineSay.SUBAGENT_USAGE,
+	}
+
+	const result = mapping[say]
+
+	return result
+}
+
+// Helper function to convert ClineSay enum to string
+function convertProtoEnumToClineSay(say: ClineSay): AppClineSay | undefined {
+	if (say === ClineSay.UNRECOGNIZED) {
+		return undefined
+	}
+
+	const mapping: Record<Exclude<ClineSay, ClineSay.UNRECOGNIZED>, AppClineSay> = {
+		[ClineSay.TASK]: "task",
+		[ClineSay.ERROR]: "error",
+		[ClineSay.API_REQ_STARTED]: "api_req_started",
+		[ClineSay.API_REQ_FINISHED]: "api_req_finished",
+		[ClineSay.TEXT]: "text",
+		[ClineSay.REASONING]: "reasoning",
+		[ClineSay.COMPLETION_RESULT_SAY]: "completion_result",
+		[ClineSay.USER_FEEDBACK]: "user_feedback",
+		[ClineSay.USER_FEEDBACK_DIFF]: "user_feedback_diff",
+		[ClineSay.API_REQ_RETRIED]: "api_req_retried",
+		[ClineSay.COMMAND_SAY]: "command",
+		[ClineSay.COMMAND_OUTPUT_SAY]: "command_output",
+		[ClineSay.TOOL_SAY]: "tool",
+		[ClineSay.SHELL_INTEGRATION_WARNING]: "shell_integration_warning",
+		[ClineSay.BROWSER_ACTION_LAUNCH_SAY]: "browser_action_launch",
+		[ClineSay.BROWSER_ACTION]: "browser_action",
+		[ClineSay.BROWSER_ACTION_RESULT]: "browser_action_result",
+		[ClineSay.MCP_SERVER_REQUEST_STARTED]: "mcp_server_request_started",
+		[ClineSay.MCP_SERVER_RESPONSE]: "mcp_server_response",
+		[ClineSay.MCP_NOTIFICATION]: "mcp_notification",
+		[ClineSay.USE_MCP_SERVER_SAY]: "use_mcp_server",
+		[ClineSay.DIFF_ERROR]: "diff_error",
+		[ClineSay.DELETED_API_REQS]: "deleted_api_reqs",
+		[ClineSay.CLINEIGNORE_ERROR]: "clineignore_error",
+		[ClineSay.COMMAND_PERMISSION_DENIED]: "command_permission_denied",
+		[ClineSay.CHECKPOINT_CREATED]: "checkpoint_created",
+		[ClineSay.LOAD_MCP_DOCUMENTATION]: "load_mcp_documentation",
+		[ClineSay.INFO]: "info",
+		[ClineSay.TASK_PROGRESS]: "task_progress",
+		[ClineSay.ERROR_RETRY]: "error_retry",
+		[ClineSay.HOOK_STATUS]: "hook_status",
+		[ClineSay.HOOK_OUTPUT_STREAM]: "hook_output_stream",
+		[ClineSay.CONDITIONAL_RULES_APPLIED]: "conditional_rules_applied",
+		[ClineSay.SUBAGENT_STATUS]: "subagent",
+		[ClineSay.USE_SUBAGENTS_SAY]: "use_subagents",
+		[ClineSay.SUBAGENT_USAGE]: "subagent_usage",
+	}
+
+	return mapping[say]
+}
+
+/**
+ * Convert application ClineMessage to proto ClineMessage
+ */
+export function convertClineMessageToProto(message: AppClineMessage): ProtoClineMessage {
+	// For sending messages, we need to provide values for required proto fields
+	const askEnum = message.ask ? convertClineAskToProtoEnum(message.ask) : undefined
+	const sayEnum = message.say ? convertClineSayToProtoEnum(message.say) : undefined
+
+	// Determine appropriate enum values based on message type
+	let finalAskEnum: ClineAsk = ClineAsk.FOLLOWUP // Proto default
+	let finalSayEnum: ClineSay = ClineSay.TEXT // Proto default
+
+	if (message.type === "ask") {
+		finalAskEnum = askEnum ?? ClineAsk.FOLLOWUP // Use FOLLOWUP as default for ask messages
+	} else if (message.type === "say") {
+		finalSayEnum = sayEnum ?? ClineSay.TEXT // Use TEXT as default for say messages
+	}
+
+	const protoMessage: ProtoClineMessage = {
+		ts: message.ts,
+		type: message.type === "ask" ? ClineMessageType.ASK : ClineMessageType.SAY,
+		ask: finalAskEnum,
+		say: finalSayEnum,
+		text: message.text ?? "",
+		reasoning: message.reasoning ?? "",
+		images: message.images ?? [],
+		files: message.files ?? [],
+		partial: message.partial ?? false,
+		// Convergent-replica fields (default 0 = unstamped, e.g. classic/legacy path).
+		seq: message.seq ?? 0,
+		epoch: message.epoch ?? 0,
+		lastCheckpointHash: message.lastCheckpointHash ?? "",
+		isCheckpointCheckedOut: message.isCheckpointCheckedOut ?? false,
+		isOperationOutsideWorkspace: message.isOperationOutsideWorkspace ?? false,
+		conversationHistoryIndex: message.conversationHistoryIndex ?? 0,
+		conversationHistoryDeletedRange: message.conversationHistoryDeletedRange
+			? {
+					startIndex: message.conversationHistoryDeletedRange[0],
+					endIndex: message.conversationHistoryDeletedRange[1],
+				}
+			: undefined,
+		// Additional optional fields for specific ask/say types
+		sayTool: undefined,
+		sayBrowserAction: undefined,
+		browserActionResult: undefined,
+		askUseMcpServer: undefined,
+		planModeResponse: undefined,
+		askQuestion: undefined,
+		askNewTask: undefined,
+		apiReqInfo: undefined,
+		modelInfo: message.modelInfo ?? undefined,
+	}
+
+	return protoMessage
+}
+
+/**
+ * Convert proto ClineMessage to application ClineMessage
+ */
+export function convertProtoToClineMessage(protoMessage: ProtoClineMessage): AppClineMessage {
+	const message: AppClineMessage = {
+		ts: protoMessage.ts,
+		type: protoMessage.type === ClineMessageType.ASK ? "ask" : "say",
+	}
+
+	// Convert ask enum to string
+	if (protoMessage.type === ClineMessageType.ASK) {
+		const ask = convertProtoEnumToClineAsk(protoMessage.ask)
+		if (ask !== undefined) {
+			message.ask = ask
+		}
+	}
+
+	// Convert say enum to string
+	if (protoMessage.type === ClineMessageType.SAY) {
+		const say = convertProtoEnumToClineSay(protoMessage.say)
+		if (say !== undefined) {
+			message.say = say
+		}
+	}
+
+	// Convert other fields - preserve empty strings as they may be intentional
+	if (protoMessage.text !== "") {
+		message.text = protoMessage.text
+	}
+	if (protoMessage.reasoning !== "") {
+		message.reasoning = protoMessage.reasoning
+	}
+	if (protoMessage.images.length > 0) {
+		message.images = protoMessage.images
+	}
+	if (protoMessage.files.length > 0) {
+		message.files = protoMessage.files
+	}
+	if (protoMessage.partial) {
+		message.partial = protoMessage.partial
+	}
+	if (protoMessage.lastCheckpointHash !== "") {
+		message.lastCheckpointHash = protoMessage.lastCheckpointHash
+	}
+	if (protoMessage.isCheckpointCheckedOut) {
+		message.isCheckpointCheckedOut = protoMessage.isCheckpointCheckedOut
+	}
+	if (protoMessage.isOperationOutsideWorkspace) {
+		message.isOperationOutsideWorkspace = protoMessage.isOperationOutsideWorkspace
+	}
+	if (protoMessage.conversationHistoryIndex !== 0) {
+		message.conversationHistoryIndex = protoMessage.conversationHistoryIndex
+	}
+
+	// Convert conversationHistoryDeletedRange from object to tuple
+	if (protoMessage.conversationHistoryDeletedRange) {
+		message.conversationHistoryDeletedRange = [
+			protoMessage.conversationHistoryDeletedRange.startIndex,
+			protoMessage.conversationHistoryDeletedRange.endIndex,
+		]
+	}
+
+	// Convergent-replica fields. 0 means unstamped (classic/legacy path) — leave undefined so
+	// the webview reducer treats such messages as always-applicable rather than epoch 0.
+	if (protoMessage.seq && protoMessage.seq !== 0) {
+		message.seq = protoMessage.seq
+	}
+	if (protoMessage.epoch && protoMessage.epoch !== 0) {
+		message.epoch = protoMessage.epoch
+	}
+
+	return message
+}
diff --git a/apps/vscode/src/shared/proto-conversions/file/search-result-conversion.ts b/apps/vscode/src/shared/proto-conversions/file/search-result-conversion.ts
new file mode 100644
index 0000000..7fc7816
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/file/search-result-conversion.ts
@@ -0,0 +1,15 @@
+import { FileInfo } from "@shared/proto/cline/file"
+
+/**
+ * Converts domain search result objects to proto FileInfo objects
+ */
+export function convertSearchResultsToProtoFileInfos(
+	results: { path: string; type: "file" | "folder"; label?: string; workspaceName?: string }[],
+): FileInfo[] {
+	return results.map((result) => ({
+		path: result.path,
+		type: result.type,
+		label: result.label,
+		workspaceName: result.workspaceName,
+	}))
+}
diff --git a/apps/vscode/src/shared/proto-conversions/mcp/mcp-server-conversion.ts b/apps/vscode/src/shared/proto-conversions/mcp/mcp-server-conversion.ts
new file mode 100644
index 0000000..e80b10c
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/mcp/mcp-server-conversion.ts
@@ -0,0 +1,207 @@
+import {
+	McpPrompt as ProtoMcpPrompt,
+	McpPromptArgument as ProtoMcpPromptArgument,
+	McpResource as ProtoMcpResource,
+	McpResourceTemplate as ProtoMcpResourceTemplate,
+	McpServer as ProtoMcpServer,
+	McpServerStatus,
+	McpTool as ProtoMcpTool,
+} from "@shared/proto/cline/mcp"
+import { McpOAuthAuthStatus, McpPrompt, McpPromptArgument, McpResource, McpResourceTemplate, McpServer, McpTool } from "../../mcp"
+
+// Helper to convert TS status to Proto enum
+function convertMcpStatusToProto(status: McpServer["status"]): McpServerStatus {
+	switch (status) {
+		case "connected":
+			return McpServerStatus.MCP_SERVER_STATUS_CONNECTED
+		case "connecting":
+			return McpServerStatus.MCP_SERVER_STATUS_CONNECTING
+		case "disconnected":
+			return McpServerStatus.MCP_SERVER_STATUS_DISCONNECTED
+	}
+}
+
+export function convertMcpServersToProtoMcpServers(mcpServers: McpServer[]): ProtoMcpServer[] {
+	const protoServers: ProtoMcpServer[] = mcpServers.map((server) => ({
+		name: server.name,
+		config: server.config,
+		status: convertMcpStatusToProto(server.status),
+		error: server.error,
+
+		// Convert nested types
+		tools: (server.tools || []).map(convertTool),
+		resources: (server.resources || []).map(convertResource),
+		resourceTemplates: (server.resourceTemplates || []).map(convertResourceTemplate),
+		prompts: (server.prompts || []).map(convertPrompt),
+
+		disabled: server.disabled,
+		timeout: server.timeout,
+		oauthRequired: server.oauthRequired,
+		oauthAuthStatus: server.oauthAuthStatus,
+	}))
+	return protoServers
+}
+
+/**
+ * Converts McpTool to ProtoMcpTool format, ensuring all required fields have values
+ */
+function convertTool(tool: McpTool): ProtoMcpTool {
+	const inputSchemaString = tool.inputSchema
+		? typeof tool.inputSchema === "object"
+			? JSON.stringify(tool.inputSchema)
+			: tool.inputSchema
+		: undefined
+
+	return {
+		name: tool.name,
+		description: tool.description,
+		inputSchema: inputSchemaString,
+		autoApprove: tool.autoApprove,
+	}
+}
+
+/**
+ * Converts McpResource to ProtoMcpResource format, ensuring all required fields have values
+ */
+function convertResource(resource: McpResource): ProtoMcpResource {
+	return {
+		uri: resource.uri,
+		name: resource.name,
+		mimeType: resource.mimeType,
+		description: resource.description,
+	}
+}
+
+/**
+ * Converts McpResourceTemplate to ProtoMcpResourceTemplate format, ensuring all required fields have values
+ */
+function convertResourceTemplate(template: McpResourceTemplate): ProtoMcpResourceTemplate {
+	return {
+		uriTemplate: template.uriTemplate,
+		name: template.name,
+		mimeType: template.mimeType,
+		description: template.description,
+	}
+}
+
+/**
+ * Converts McpPromptArgument to ProtoMcpPromptArgument format
+ */
+function convertPromptArgument(arg: McpPromptArgument): ProtoMcpPromptArgument {
+	return {
+		name: arg.name,
+		description: arg.description,
+		required: arg.required,
+	}
+}
+
+/**
+ * Converts McpPrompt to ProtoMcpPrompt format
+ */
+function convertPrompt(prompt: McpPrompt): ProtoMcpPrompt {
+	return {
+		name: prompt.name,
+		title: prompt.title,
+		description: prompt.description,
+		arguments: (prompt.arguments || []).map(convertPromptArgument),
+	}
+}
+
+// Helper to convert Proto enum to TS status
+function convertProtoStatusToMcp(status: McpServerStatus): McpServer["status"] {
+	switch (status) {
+		case McpServerStatus.MCP_SERVER_STATUS_CONNECTED:
+			return "connected"
+		case McpServerStatus.MCP_SERVER_STATUS_CONNECTING:
+			return "connecting"
+		case McpServerStatus.MCP_SERVER_STATUS_DISCONNECTED:
+		default: // Includes UNSPECIFIED if it were present, maps to disconnected
+			return "disconnected"
+	}
+}
+
+export function convertProtoMcpServersToMcpServers(protoServers: ProtoMcpServer[]): McpServer[] {
+	const mcpServers: McpServer[] = protoServers.map((protoServer) => {
+		return {
+			name: protoServer.name,
+			config: protoServer.config,
+			status: convertProtoStatusToMcp(protoServer.status),
+			error: protoServer.error === "" ? undefined : protoServer.error,
+
+			// Convert nested types
+			tools: protoServer.tools.map(convertProtoTool),
+			resources: protoServer.resources.map(convertProtoResource),
+			resourceTemplates: protoServer.resourceTemplates.map(convertProtoResourceTemplate),
+			prompts: protoServer.prompts.map(convertProtoPrompt),
+
+			disabled: protoServer.disabled,
+			timeout: protoServer.timeout,
+			oauthRequired: protoServer.oauthRequired,
+			oauthAuthStatus: protoServer.oauthAuthStatus === "" ? undefined : (protoServer.oauthAuthStatus as McpOAuthAuthStatus),
+		}
+	})
+	return mcpServers
+}
+
+/**
+ * Converts ProtoMcpTool to McpTool format, parsing inputSchema if needed
+ */
+function convertProtoTool(protoTool: ProtoMcpTool): McpTool {
+	return {
+		name: protoTool.name,
+		description: protoTool.description === "" ? undefined : protoTool.description,
+		inputSchema: protoTool.inputSchema
+			? protoTool.inputSchema.startsWith("{")
+				? JSON.parse(protoTool.inputSchema)
+				: protoTool.inputSchema
+			: undefined,
+		autoApprove: protoTool.autoApprove,
+	}
+}
+
+/**
+ * Converts ProtoMcpResource to McpResource format
+ */
+function convertProtoResource(protoResource: ProtoMcpResource): McpResource {
+	return {
+		uri: protoResource.uri,
+		name: protoResource.name,
+		mimeType: protoResource.mimeType === "" ? undefined : protoResource.mimeType,
+		description: protoResource.description === "" ? undefined : protoResource.description,
+	}
+}
+
+/**
+ * Converts ProtoMcpResourceTemplate to McpResourceTemplate format
+ */
+function convertProtoResourceTemplate(protoTemplate: ProtoMcpResourceTemplate): McpResourceTemplate {
+	return {
+		uriTemplate: protoTemplate.uriTemplate,
+		name: protoTemplate.name,
+		mimeType: protoTemplate.mimeType === "" ? undefined : protoTemplate.mimeType,
+		description: protoTemplate.description === "" ? undefined : protoTemplate.description,
+	}
+}
+
+/**
+ * Converts ProtoMcpPromptArgument to McpPromptArgument format
+ */
+function convertProtoPromptArgument(protoArg: ProtoMcpPromptArgument): McpPromptArgument {
+	return {
+		name: protoArg.name,
+		description: protoArg.description === "" ? undefined : protoArg.description,
+		required: protoArg.required,
+	}
+}
+
+/**
+ * Converts ProtoMcpPrompt to McpPrompt format
+ */
+function convertProtoPrompt(protoPrompt: ProtoMcpPrompt): McpPrompt {
+	return {
+		name: protoPrompt.name,
+		title: protoPrompt.title === "" ? undefined : protoPrompt.title,
+		description: protoPrompt.description === "" ? undefined : protoPrompt.description,
+		arguments: protoPrompt.arguments.map(convertProtoPromptArgument),
+	}
+}
diff --git a/apps/vscode/src/shared/proto-conversions/models/api-configuration-conversion.test.ts b/apps/vscode/src/shared/proto-conversions/models/api-configuration-conversion.test.ts
new file mode 100644
index 0000000..d46ef39
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/models/api-configuration-conversion.test.ts
@@ -0,0 +1,23 @@
+import type { ApiProvider } from "@shared/api"
+import { describe, expect, it } from "vitest"
+import { convertApiConfigurationToProto, convertProtoToApiConfiguration } from "./api-configuration-conversion"
+
+describe("api configuration provider conversion", () => {
+	it("round-trips SDK provider ids added after the legacy enum list", () => {
+		const providers: ApiProvider[] = ["poolside", "v0", "xiaomi", "tencent-tokenhub", "zai-coding-plan"]
+
+		for (const provider of providers) {
+			const proto = convertApiConfigurationToProto({
+				actModeApiProvider: provider,
+				planModeApiProvider: provider,
+			})
+
+			// Assert field-by-field instead of toMatchObject: this file is also picked up by
+			// the mocha integration runner (.vscode-test.mjs globs src/shared/**/*.test.js),
+			// where vitest's jest-compat matchers like toMatchObject are not available.
+			const result = convertProtoToApiConfiguration(proto)
+			expect(result.actModeApiProvider).toBe(provider)
+			expect(result.planModeApiProvider).toBe(provider)
+		}
+	})
+})
diff --git a/apps/vscode/src/shared/proto-conversions/models/api-configuration-conversion.ts b/apps/vscode/src/shared/proto-conversions/models/api-configuration-conversion.ts
new file mode 100644
index 0000000..a9d57ed
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/models/api-configuration-conversion.ts
@@ -0,0 +1,621 @@
+import {
+	LiteLLMModelInfo,
+	OpenAiCompatibleModelInfo,
+	OpenRouterModelInfo,
+	ModelsApiConfiguration as ProtoApiConfiguration,
+	OcaModelInfo as ProtoOcaModelInfo,
+	ThinkingConfig,
+} from "@shared/proto/cline/models"
+import {
+	ApiConfiguration,
+	ApiProvider,
+	LiteLLMModelInfo as AppLiteLLMModelInfo,
+	OpenAiCompatibleModelInfo as AppOpenAiCompatibleModelInfo,
+	BedrockModelId,
+	ModelInfo,
+	OcaModelInfo,
+} from "../../api"
+import { OpenaiReasoningEffort } from "../../storage/types"
+
+// Convert application ThinkingConfig to proto ThinkingConfig
+function convertThinkingConfigToProto(config: ModelInfo["thinkingConfig"]): ThinkingConfig | undefined {
+	if (!config) {
+		return undefined
+	}
+
+	return {
+		maxBudget: config.maxBudget,
+		outputPrice: config.outputPrice,
+		outputPriceTiers: config.outputPriceTiers || [], // Provide empty array if undefined
+	}
+}
+
+// Convert proto ThinkingConfig to application ThinkingConfig
+function convertProtoToThinkingConfig(config: ThinkingConfig | undefined): ModelInfo["thinkingConfig"] | undefined {
+	if (!config) {
+		return undefined
+	}
+
+	return {
+		maxBudget: config.maxBudget,
+		outputPrice: config.outputPrice,
+		outputPriceTiers: config.outputPriceTiers.length > 0 ? config.outputPriceTiers : undefined,
+	}
+}
+
+// Convert application ModelInfo to proto OpenRouterModelInfo
+function convertModelInfoToProtoOpenRouter(info: ModelInfo | undefined): OpenRouterModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache ?? false,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		thinkingConfig: convertThinkingConfigToProto(info.thinkingConfig),
+		supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+		tiers: info.tiers || [],
+	}
+}
+
+// Convert proto OpenRouterModelInfo to application ModelInfo
+function convertProtoToModelInfo(info: OpenRouterModelInfo | undefined): ModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		thinkingConfig: convertProtoToThinkingConfig(info.thinkingConfig),
+		supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+		tiers: info.tiers.length > 0 ? info.tiers : undefined,
+	}
+}
+
+// Convert application ModelInfo to proto OcaModelInfo
+function convertOcaModelInfoToProtoOcaModelInfo(info: OcaModelInfo | undefined): ProtoOcaModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache ?? false,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		thinkingConfig: convertThinkingConfigToProto(info.thinkingConfig),
+		surveyContent: info.surveyContent,
+		surveyId: info.surveyId,
+		banner: info.banner,
+		modelName: info.modelName,
+		apiFormat: info.apiFormat,
+		supportsReasoning: info.supportsReasoning,
+		reasoningEffortOptions: info.reasoningEffortOptions,
+	}
+}
+
+// Convert proto OpenRouterModelInfo to application ModelInfo
+function convertProtoOcaModelInfoToOcaModelInfo(info: ProtoOcaModelInfo | undefined): OcaModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		surveyContent: info.surveyContent,
+		surveyId: info.surveyId,
+		banner: info.banner,
+		modelName: info.modelName,
+		apiFormat: info.apiFormat,
+		supportsReasoning: info.supportsReasoning,
+		reasoningEffortOptions: info.reasoningEffortOptions,
+	}
+}
+
+// Convert application LiteLLMModelInfo to proto LiteLLMModelInfo
+function convertLiteLLMModelInfoToProto(info: AppLiteLLMModelInfo | undefined): LiteLLMModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache ?? false,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		thinkingConfig: convertThinkingConfigToProto(info.thinkingConfig),
+		supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		tiers: info.tiers || [],
+		temperature: info.temperature,
+		supportsReasoning: info.supportsReasoning,
+	}
+}
+
+// Convert proto LiteLLMModelInfo to application LiteLLMModelInfo
+function convertProtoToLiteLLMModelInfo(info: LiteLLMModelInfo | undefined): AppLiteLLMModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		thinkingConfig: convertProtoToThinkingConfig(info.thinkingConfig),
+		supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		tiers: info.tiers.length > 0 ? info.tiers : undefined,
+		temperature: info.temperature,
+		supportsReasoning: info.supportsReasoning,
+	}
+}
+
+// Convert application OpenAiCompatibleModelInfo to proto OpenAiCompatibleModelInfo
+function convertOpenAiCompatibleModelInfoToProto(
+	info: AppOpenAiCompatibleModelInfo | undefined,
+): OpenAiCompatibleModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache ?? false,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		thinkingConfig: convertThinkingConfigToProto(info.thinkingConfig),
+		supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		tiers: info.tiers || [],
+		temperature: info.temperature,
+		isR1FormatRequired: info.isR1FormatRequired,
+	}
+}
+
+// Convert proto OpenAiCompatibleModelInfo to application OpenAiCompatibleModelInfo
+function convertProtoToOpenAiCompatibleModelInfo(
+	info: OpenAiCompatibleModelInfo | undefined,
+): AppOpenAiCompatibleModelInfo | undefined {
+	if (!info) {
+		return undefined
+	}
+
+	return {
+		maxTokens: info.maxTokens,
+		contextWindow: info.contextWindow,
+		supportsImages: info.supportsImages,
+		supportsPromptCache: info.supportsPromptCache,
+		inputPrice: info.inputPrice,
+		outputPrice: info.outputPrice,
+		thinkingConfig: convertProtoToThinkingConfig(info.thinkingConfig),
+		supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+		cacheWritesPrice: info.cacheWritesPrice,
+		cacheReadsPrice: info.cacheReadsPrice,
+		description: info.description,
+		tiers: info.tiers.length > 0 ? info.tiers : undefined,
+		temperature: info.temperature,
+		isR1FormatRequired: info.isR1FormatRequired,
+	}
+}
+
+// Provider ids travel over the wire as plain strings (matching the `ApiProvider`
+// union in `@shared/api`), so no enum mapping is needed in either direction.
+// This thin helper just supplies the default and the single cast boundary for
+// callers reading a provider id off a proto message.
+export function convertProtoToApiProvider(provider: string | undefined): ApiProvider {
+	return (provider || "anthropic") as ApiProvider
+}
+
+// Converts application ApiConfiguration to proto ApiConfiguration
+export function convertApiConfigurationToProto(config: ApiConfiguration): ProtoApiConfiguration {
+	return {
+		// Global configuration fields
+		apiKey: config.apiKey,
+		clineAccountId: config.clineAccountId,
+		ulid: config.ulid,
+		liteLlmBaseUrl: config.liteLlmBaseUrl,
+		liteLlmApiKey: config.liteLlmApiKey,
+		liteLlmUsePromptCache: config.liteLlmUsePromptCache,
+		openAiHeaders: config.openAiHeaders || {},
+		anthropicBaseUrl: config.anthropicBaseUrl,
+		openRouterApiKey: config.openRouterApiKey,
+		openRouterProviderSorting: config.openRouterProviderSorting,
+		awsAccessKey: config.awsAccessKey,
+		awsSecretKey: config.awsSecretKey,
+		awsSessionToken: config.awsSessionToken,
+		awsRegion: config.awsRegion,
+		awsUseCrossRegionInference: config.awsUseCrossRegionInference,
+		awsUseGlobalInference: config.awsUseGlobalInference,
+		awsBedrockUsePromptCache: config.awsBedrockUsePromptCache,
+		awsUseProfile: config.awsUseProfile,
+		awsAuthentication: config.awsAuthentication,
+		awsProfile: config.awsProfile,
+		awsBedrockApiKey: config.awsBedrockApiKey,
+		awsBedrockEndpoint: config.awsBedrockEndpoint,
+		claudeCodePath: config.claudeCodePath,
+		vertexProjectId: config.vertexProjectId,
+		vertexRegion: config.vertexRegion,
+		openAiBaseUrl: config.openAiBaseUrl,
+		openAiApiKey: config.openAiApiKey,
+		ollamaBaseUrl: config.ollamaBaseUrl,
+		ollamaApiKey: config.ollamaApiKey,
+		ollamaApiOptionsCtxNum: config.ollamaApiOptionsCtxNum,
+		lmStudioBaseUrl: config.lmStudioBaseUrl,
+		lmStudioMaxTokens: config.lmStudioMaxTokens,
+		geminiApiKey: config.geminiApiKey,
+		geminiBaseUrl: config.geminiBaseUrl,
+		openAiNativeApiKey: config.openAiNativeApiKey,
+		deepSeekApiKey: config.deepSeekApiKey,
+		requestyApiKey: config.requestyApiKey,
+		requestyBaseUrl: config.requestyBaseUrl,
+		togetherApiKey: config.togetherApiKey,
+		fireworksApiKey: config.fireworksApiKey,
+		fireworksModelMaxCompletionTokens: config.fireworksModelMaxCompletionTokens,
+		fireworksModelMaxTokens: config.fireworksModelMaxTokens,
+		qwenApiKey: config.qwenApiKey,
+		qwenCodeOauthPath: config.qwenCodeOauthPath,
+		doubaoApiKey: config.doubaoApiKey,
+		mistralApiKey: config.mistralApiKey,
+		azureApiVersion: config.azureApiVersion,
+		azureIdentity: config.azureIdentity,
+		qwenApiLine: config.qwenApiLine,
+		moonshotApiLine: config.moonshotApiLine,
+		moonshotApiKey: config.moonshotApiKey,
+		huggingFaceApiKey: config.huggingFaceApiKey,
+		nebiusApiKey: config.nebiusApiKey,
+		wandbApiKey: config.wandbApiKey,
+		asksageApiUrl: config.asksageApiUrl,
+		asksageApiKey: config.asksageApiKey,
+		xaiApiKey: config.xaiApiKey,
+		sambanovaApiKey: config.sambanovaApiKey,
+		cerebrasApiKey: config.cerebrasApiKey,
+		vercelAiGatewayApiKey: config.vercelAiGatewayApiKey,
+		groqApiKey: config.groqApiKey,
+		basetenApiKey: config.basetenApiKey,
+		requestTimeoutMs: config.requestTimeoutMs,
+		sapAiCoreClientId: config.sapAiCoreClientId,
+		sapAiCoreClientSecret: config.sapAiCoreClientSecret,
+		sapAiResourceGroup: config.sapAiResourceGroup,
+		sapAiCoreTokenUrl: config.sapAiCoreTokenUrl,
+		sapAiCoreBaseUrl: config.sapAiCoreBaseUrl,
+		sapAiCoreUseOrchestrationMode: config.sapAiCoreUseOrchestrationMode,
+		huaweiCloudMaasApiKey: config.huaweiCloudMaasApiKey,
+		zaiApiLine: config.zaiApiLine,
+		zaiApiKey: config.zaiApiKey,
+		difyApiKey: config.difyApiKey,
+		difyBaseUrl: config.difyBaseUrl,
+		ocaBaseUrl: config.ocaBaseUrl,
+		minimaxApiKey: config.minimaxApiKey,
+		minimaxApiLine: config.minimaxApiLine,
+		nousResearchApiKey: config.nousResearchApiKey,
+		clineApiKey: config.clineApiKey,
+		ocaMode: config.ocaMode,
+		aihubmixApiKey: config.aihubmixApiKey,
+		aihubmixBaseUrl: config.aihubmixBaseUrl,
+		aihubmixAppCode: config.aihubmixAppCode,
+		hicapApiKey: config.hicapApiKey,
+		hicapModelId: config.hicapModelId,
+
+		// Plan mode configurations
+		planModeApiProvider: config.planModeApiProvider,
+		planModeApiModelId: config.planModeApiModelId,
+		planModeThinkingBudgetTokens: config.planModeThinkingBudgetTokens,
+		geminiPlanModeThinkingLevel: config.geminiPlanModeThinkingLevel,
+		planModeReasoningEffort: config.planModeReasoningEffort,
+		planModeVsCodeLmModelSelector: config.planModeVsCodeLmModelSelector,
+		planModeAwsBedrockCustomSelected: config.planModeAwsBedrockCustomSelected,
+		planModeAwsBedrockCustomModelBaseId: config.planModeAwsBedrockCustomModelBaseId as string | undefined,
+		planModeOpenRouterModelId: config.planModeOpenRouterModelId,
+		planModeOpenRouterModelInfo: convertModelInfoToProtoOpenRouter(config.planModeOpenRouterModelInfo),
+		planModeClineModelId: config.planModeClineModelId,
+		planModeClineModelInfo: convertModelInfoToProtoOpenRouter(config.planModeClineModelInfo),
+		planModeClinePassModelId: config.planModeClinePassModelId,
+		planModeClinePassModelInfo: convertModelInfoToProtoOpenRouter(config.planModeClinePassModelInfo),
+		planModeOpenAiModelId: config.planModeOpenAiModelId,
+		planModeOpenAiModelInfo: convertOpenAiCompatibleModelInfoToProto(config.planModeOpenAiModelInfo),
+		planModeOllamaModelId: config.planModeOllamaModelId,
+		planModeLmStudioModelId: config.planModeLmStudioModelId,
+		planModeLiteLlmModelId: config.planModeLiteLlmModelId,
+		planModeLiteLlmModelInfo: convertLiteLLMModelInfoToProto(config.planModeLiteLlmModelInfo),
+		planModeRequestyModelId: config.planModeRequestyModelId,
+		planModeRequestyModelInfo: convertModelInfoToProtoOpenRouter(config.planModeRequestyModelInfo),
+		planModeTogetherModelId: config.planModeTogetherModelId,
+		planModeFireworksModelId: config.planModeFireworksModelId,
+		planModeGroqModelId: config.planModeGroqModelId,
+		planModeGroqModelInfo: convertModelInfoToProtoOpenRouter(config.planModeGroqModelInfo),
+		planModeBasetenModelId: config.planModeBasetenModelId,
+		planModeBasetenModelInfo: convertModelInfoToProtoOpenRouter(config.planModeBasetenModelInfo),
+		planModeHuggingFaceModelId: config.planModeHuggingFaceModelId,
+		planModeHuggingFaceModelInfo: convertModelInfoToProtoOpenRouter(config.planModeHuggingFaceModelInfo),
+		planModeSapAiCoreModelId: config.planModeSapAiCoreModelId,
+		planModeHuaweiCloudMaasModelId: config.planModeHuaweiCloudMaasModelId,
+		planModeHuaweiCloudMaasModelInfo: convertModelInfoToProtoOpenRouter(config.planModeHuaweiCloudMaasModelInfo),
+		planModeSapAiCoreDeploymentId: config.planModeSapAiCoreDeploymentId,
+		planModeOcaModelId: config.planModeOcaModelId,
+		planModeOcaModelInfo: convertOcaModelInfoToProtoOcaModelInfo(config.planModeOcaModelInfo),
+		planModeOcaReasoningEffort: config.planModeOcaReasoningEffort,
+		planModeAihubmixModelId: config.planModeAihubmixModelId,
+		planModeAihubmixModelInfo: convertOpenAiCompatibleModelInfoToProto(config.planModeAihubmixModelInfo),
+		planModeHicapModelId: config.planModeHicapModelId,
+		planModeHicapModelInfo: convertModelInfoToProtoOpenRouter(config.planModeHicapModelInfo),
+		planModeNousResearchModelId: config.planModeNousResearchModelId,
+		planModeVercelAiGatewayModelId: config.planModeVercelAiGatewayModelId,
+		planModeVercelAiGatewayModelInfo: convertModelInfoToProtoOpenRouter(config.planModeVercelAiGatewayModelInfo),
+
+		// Act mode configurations
+		actModeApiProvider: config.actModeApiProvider,
+		actModeApiModelId: config.actModeApiModelId,
+		actModeThinkingBudgetTokens: config.actModeThinkingBudgetTokens,
+		geminiActModeThinkingLevel: config.geminiActModeThinkingLevel,
+		actModeReasoningEffort: config.actModeReasoningEffort,
+		actModeVsCodeLmModelSelector: config.actModeVsCodeLmModelSelector,
+		actModeAwsBedrockCustomSelected: config.actModeAwsBedrockCustomSelected,
+		actModeAwsBedrockCustomModelBaseId: config.actModeAwsBedrockCustomModelBaseId as string | undefined,
+		actModeOpenRouterModelId: config.actModeOpenRouterModelId,
+		actModeOpenRouterModelInfo: convertModelInfoToProtoOpenRouter(config.actModeOpenRouterModelInfo),
+		actModeClineModelId: config.actModeClineModelId,
+		actModeClineModelInfo: convertModelInfoToProtoOpenRouter(config.actModeClineModelInfo),
+		actModeClinePassModelId: config.actModeClinePassModelId,
+		actModeClinePassModelInfo: convertModelInfoToProtoOpenRouter(config.actModeClinePassModelInfo),
+		actModeOpenAiModelId: config.actModeOpenAiModelId,
+		actModeOpenAiModelInfo: convertOpenAiCompatibleModelInfoToProto(config.actModeOpenAiModelInfo),
+		actModeOllamaModelId: config.actModeOllamaModelId,
+		actModeLmStudioModelId: config.actModeLmStudioModelId,
+		actModeLiteLlmModelId: config.actModeLiteLlmModelId,
+		actModeLiteLlmModelInfo: convertLiteLLMModelInfoToProto(config.actModeLiteLlmModelInfo),
+		actModeRequestyModelId: config.actModeRequestyModelId,
+		actModeRequestyModelInfo: convertModelInfoToProtoOpenRouter(config.actModeRequestyModelInfo),
+		actModeTogetherModelId: config.actModeTogetherModelId,
+		actModeFireworksModelId: config.actModeFireworksModelId,
+		actModeGroqModelId: config.actModeGroqModelId,
+		actModeGroqModelInfo: convertModelInfoToProtoOpenRouter(config.actModeGroqModelInfo),
+		actModeBasetenModelId: config.actModeBasetenModelId,
+		actModeBasetenModelInfo: convertModelInfoToProtoOpenRouter(config.actModeBasetenModelInfo),
+		actModeHuggingFaceModelId: config.actModeHuggingFaceModelId,
+		actModeHuggingFaceModelInfo: convertModelInfoToProtoOpenRouter(config.actModeHuggingFaceModelInfo),
+		actModeSapAiCoreModelId: config.actModeSapAiCoreModelId,
+		actModeHuaweiCloudMaasModelId: config.actModeHuaweiCloudMaasModelId,
+		actModeHuaweiCloudMaasModelInfo: convertModelInfoToProtoOpenRouter(config.actModeHuaweiCloudMaasModelInfo),
+		actModeSapAiCoreDeploymentId: config.actModeSapAiCoreDeploymentId,
+		actModeOcaModelId: config.actModeOcaModelId,
+		actModeOcaModelInfo: convertOcaModelInfoToProtoOcaModelInfo(config.actModeOcaModelInfo),
+		actModeOcaReasoningEffort: config.actModeOcaReasoningEffort,
+		actModeAihubmixModelId: config.actModeAihubmixModelId,
+		actModeAihubmixModelInfo: convertOpenAiCompatibleModelInfoToProto(config.actModeAihubmixModelInfo),
+		actModeHicapModelId: config.actModeHicapModelId,
+		actModeHicapModelInfo: convertModelInfoToProtoOpenRouter(config.actModeHicapModelInfo),
+		actModeNousResearchModelId: config.actModeNousResearchModelId,
+		actModeVercelAiGatewayModelId: config.actModeVercelAiGatewayModelId,
+		actModeVercelAiGatewayModelInfo: convertModelInfoToProtoOpenRouter(config.actModeVercelAiGatewayModelInfo),
+	}
+}
+
+// Converts proto ApiConfiguration to application ApiConfiguration
+export function convertProtoToApiConfiguration(protoConfig: ProtoApiConfiguration): ApiConfiguration {
+	return {
+		// Global configuration fields
+		apiKey: protoConfig.apiKey,
+		clineAccountId: protoConfig.clineAccountId,
+		ulid: protoConfig.ulid,
+		liteLlmBaseUrl: protoConfig.liteLlmBaseUrl,
+		liteLlmApiKey: protoConfig.liteLlmApiKey,
+		liteLlmUsePromptCache: protoConfig.liteLlmUsePromptCache,
+		openAiHeaders: Object.keys(protoConfig.openAiHeaders || {}).length > 0 ? protoConfig.openAiHeaders : undefined,
+		anthropicBaseUrl: protoConfig.anthropicBaseUrl,
+		openRouterApiKey: protoConfig.openRouterApiKey,
+		openRouterProviderSorting: protoConfig.openRouterProviderSorting,
+		awsAccessKey: protoConfig.awsAccessKey,
+		awsSecretKey: protoConfig.awsSecretKey,
+		awsSessionToken: protoConfig.awsSessionToken,
+		awsRegion: protoConfig.awsRegion,
+		awsUseCrossRegionInference: protoConfig.awsUseCrossRegionInference,
+		awsUseGlobalInference: protoConfig.awsUseGlobalInference,
+		awsBedrockUsePromptCache: protoConfig.awsBedrockUsePromptCache,
+		awsUseProfile: protoConfig.awsUseProfile,
+		awsAuthentication: protoConfig.awsAuthentication,
+		awsProfile: protoConfig.awsProfile,
+		awsBedrockApiKey: protoConfig.awsBedrockApiKey,
+		awsBedrockEndpoint: protoConfig.awsBedrockEndpoint,
+		claudeCodePath: protoConfig.claudeCodePath,
+		vertexProjectId: protoConfig.vertexProjectId,
+		vertexRegion: protoConfig.vertexRegion,
+		openAiBaseUrl: protoConfig.openAiBaseUrl,
+		openAiApiKey: protoConfig.openAiApiKey,
+		ollamaBaseUrl: protoConfig.ollamaBaseUrl,
+		ollamaApiKey: protoConfig.ollamaApiKey,
+		ollamaApiOptionsCtxNum: protoConfig.ollamaApiOptionsCtxNum,
+		lmStudioBaseUrl: protoConfig.lmStudioBaseUrl,
+		lmStudioMaxTokens: protoConfig.lmStudioMaxTokens,
+		geminiApiKey: protoConfig.geminiApiKey,
+		geminiBaseUrl: protoConfig.geminiBaseUrl,
+		openAiNativeApiKey: protoConfig.openAiNativeApiKey,
+		deepSeekApiKey: protoConfig.deepSeekApiKey,
+		requestyApiKey: protoConfig.requestyApiKey,
+		requestyBaseUrl: protoConfig.requestyBaseUrl,
+		togetherApiKey: protoConfig.togetherApiKey,
+		fireworksApiKey: protoConfig.fireworksApiKey,
+		fireworksModelMaxCompletionTokens: protoConfig.fireworksModelMaxCompletionTokens,
+		fireworksModelMaxTokens: protoConfig.fireworksModelMaxTokens,
+		qwenApiKey: protoConfig.qwenApiKey,
+		qwenCodeOauthPath: protoConfig.qwenCodeOauthPath,
+		doubaoApiKey: protoConfig.doubaoApiKey,
+		mistralApiKey: protoConfig.mistralApiKey,
+		azureApiVersion: protoConfig.azureApiVersion,
+		azureIdentity: protoConfig.azureIdentity,
+		qwenApiLine: protoConfig.qwenApiLine,
+		moonshotApiLine: protoConfig.moonshotApiLine,
+		moonshotApiKey: protoConfig.moonshotApiKey,
+		huggingFaceApiKey: protoConfig.huggingFaceApiKey,
+		nebiusApiKey: protoConfig.nebiusApiKey,
+		wandbApiKey: protoConfig.wandbApiKey,
+		asksageApiUrl: protoConfig.asksageApiUrl,
+		asksageApiKey: protoConfig.asksageApiKey,
+		xaiApiKey: protoConfig.xaiApiKey,
+		sambanovaApiKey: protoConfig.sambanovaApiKey,
+		cerebrasApiKey: protoConfig.cerebrasApiKey,
+		vercelAiGatewayApiKey: protoConfig.vercelAiGatewayApiKey,
+		groqApiKey: protoConfig.groqApiKey,
+		basetenApiKey: protoConfig.basetenApiKey,
+		requestTimeoutMs: protoConfig.requestTimeoutMs,
+		sapAiCoreClientId: protoConfig.sapAiCoreClientId,
+		sapAiCoreClientSecret: protoConfig.sapAiCoreClientSecret,
+		sapAiResourceGroup: protoConfig.sapAiResourceGroup,
+		sapAiCoreTokenUrl: protoConfig.sapAiCoreTokenUrl,
+		sapAiCoreBaseUrl: protoConfig.sapAiCoreBaseUrl,
+		sapAiCoreUseOrchestrationMode: protoConfig.sapAiCoreUseOrchestrationMode,
+		huaweiCloudMaasApiKey: protoConfig.huaweiCloudMaasApiKey,
+		zaiApiLine: protoConfig.zaiApiLine,
+		zaiApiKey: protoConfig.zaiApiKey,
+		difyApiKey: protoConfig.difyApiKey,
+		difyBaseUrl: protoConfig.difyBaseUrl,
+		ocaBaseUrl: protoConfig.ocaBaseUrl,
+		ocaMode: protoConfig.ocaMode,
+		aihubmixApiKey: protoConfig.aihubmixApiKey,
+		aihubmixBaseUrl: protoConfig.aihubmixBaseUrl,
+		aihubmixAppCode: protoConfig.aihubmixAppCode,
+		minimaxApiKey: protoConfig.minimaxApiKey,
+		minimaxApiLine: protoConfig.minimaxApiLine,
+		hicapApiKey: protoConfig.hicapApiKey,
+		hicapModelId: protoConfig.hicapModelId,
+		nousResearchApiKey: protoConfig.nousResearchApiKey,
+		clineApiKey: protoConfig.clineApiKey,
+
+		// Plan mode configurations
+		planModeApiProvider:
+			protoConfig.planModeApiProvider !== undefined
+				? convertProtoToApiProvider(protoConfig.planModeApiProvider)
+				: undefined,
+		planModeApiModelId: protoConfig.planModeApiModelId,
+		planModeThinkingBudgetTokens: protoConfig.planModeThinkingBudgetTokens,
+		geminiPlanModeThinkingLevel: protoConfig.geminiPlanModeThinkingLevel,
+		planModeReasoningEffort: protoConfig.planModeReasoningEffort as OpenaiReasoningEffort | undefined,
+		planModeVsCodeLmModelSelector: protoConfig.planModeVsCodeLmModelSelector,
+		planModeAwsBedrockCustomSelected: protoConfig.planModeAwsBedrockCustomSelected,
+		planModeAwsBedrockCustomModelBaseId: protoConfig.planModeAwsBedrockCustomModelBaseId as BedrockModelId | undefined,
+		planModeOpenRouterModelId: protoConfig.planModeOpenRouterModelId,
+		planModeOpenRouterModelInfo: convertProtoToModelInfo(protoConfig.planModeOpenRouterModelInfo),
+		planModeClineModelId: protoConfig.planModeClineModelId,
+		planModeClineModelInfo: convertProtoToModelInfo(protoConfig.planModeClineModelInfo),
+		planModeClinePassModelId: protoConfig.planModeClinePassModelId,
+		planModeClinePassModelInfo: convertProtoToModelInfo(protoConfig.planModeClinePassModelInfo),
+		planModeOpenAiModelId: protoConfig.planModeOpenAiModelId,
+		planModeOpenAiModelInfo: convertProtoToOpenAiCompatibleModelInfo(protoConfig.planModeOpenAiModelInfo),
+		planModeOllamaModelId: protoConfig.planModeOllamaModelId,
+		planModeLmStudioModelId: protoConfig.planModeLmStudioModelId,
+		planModeLiteLlmModelId: protoConfig.planModeLiteLlmModelId,
+		planModeLiteLlmModelInfo: convertProtoToLiteLLMModelInfo(protoConfig.planModeLiteLlmModelInfo),
+		planModeRequestyModelId: protoConfig.planModeRequestyModelId,
+		planModeRequestyModelInfo: convertProtoToModelInfo(protoConfig.planModeRequestyModelInfo),
+		planModeTogetherModelId: protoConfig.planModeTogetherModelId,
+		planModeFireworksModelId: protoConfig.planModeFireworksModelId,
+		planModeGroqModelId: protoConfig.planModeGroqModelId,
+		planModeGroqModelInfo: convertProtoToModelInfo(protoConfig.planModeGroqModelInfo),
+		planModeBasetenModelId: protoConfig.planModeBasetenModelId,
+		planModeBasetenModelInfo: convertProtoToModelInfo(protoConfig.planModeBasetenModelInfo),
+		planModeHuggingFaceModelId: protoConfig.planModeHuggingFaceModelId,
+		planModeHuggingFaceModelInfo: convertProtoToModelInfo(protoConfig.planModeHuggingFaceModelInfo),
+		planModeSapAiCoreModelId: protoConfig.planModeSapAiCoreModelId,
+		planModeHuaweiCloudMaasModelId: protoConfig.planModeHuaweiCloudMaasModelId,
+		planModeHuaweiCloudMaasModelInfo: convertProtoToModelInfo(protoConfig.planModeHuaweiCloudMaasModelInfo),
+		planModeSapAiCoreDeploymentId: protoConfig.planModeSapAiCoreDeploymentId,
+		planModeOcaModelId: protoConfig.planModeOcaModelId,
+		planModeOcaModelInfo: convertProtoOcaModelInfoToOcaModelInfo(protoConfig.planModeOcaModelInfo),
+		planModeOcaReasoningEffort: protoConfig.planModeOcaReasoningEffort,
+		planModeAihubmixModelId: protoConfig.planModeAihubmixModelId,
+		planModeAihubmixModelInfo: convertProtoToOpenAiCompatibleModelInfo(protoConfig.planModeAihubmixModelInfo),
+		planModeHicapModelId: protoConfig.planModeHicapModelId,
+		planModeHicapModelInfo: convertProtoToModelInfo(protoConfig.planModeHicapModelInfo),
+		planModeNousResearchModelId: protoConfig.planModeNousResearchModelId,
+		planModeVercelAiGatewayModelId: protoConfig.planModeVercelAiGatewayModelId,
+		planModeVercelAiGatewayModelInfo: convertProtoToModelInfo(protoConfig.planModeVercelAiGatewayModelInfo),
+
+		// Act mode configurations
+		actModeApiProvider:
+			protoConfig.actModeApiProvider !== undefined ? convertProtoToApiProvider(protoConfig.actModeApiProvider) : undefined,
+		actModeApiModelId: protoConfig.actModeApiModelId,
+		actModeThinkingBudgetTokens: protoConfig.actModeThinkingBudgetTokens,
+		geminiActModeThinkingLevel: protoConfig.geminiActModeThinkingLevel,
+		actModeReasoningEffort: protoConfig.actModeReasoningEffort as OpenaiReasoningEffort | undefined,
+		actModeVsCodeLmModelSelector: protoConfig.actModeVsCodeLmModelSelector,
+		actModeAwsBedrockCustomSelected: protoConfig.actModeAwsBedrockCustomSelected,
+		actModeAwsBedrockCustomModelBaseId: protoConfig.actModeAwsBedrockCustomModelBaseId as BedrockModelId | undefined,
+		actModeOpenRouterModelId: protoConfig.actModeOpenRouterModelId,
+		actModeOpenRouterModelInfo: convertProtoToModelInfo(protoConfig.actModeOpenRouterModelInfo),
+		actModeClineModelId: protoConfig.actModeClineModelId,
+		actModeClineModelInfo: convertProtoToModelInfo(protoConfig.actModeClineModelInfo),
+		actModeClinePassModelId: protoConfig.actModeClinePassModelId,
+		actModeClinePassModelInfo: convertProtoToModelInfo(protoConfig.actModeClinePassModelInfo),
+		actModeOpenAiModelId: protoConfig.actModeOpenAiModelId,
+		actModeOpenAiModelInfo: convertProtoToOpenAiCompatibleModelInfo(protoConfig.actModeOpenAiModelInfo),
+		actModeOllamaModelId: protoConfig.actModeOllamaModelId,
+		actModeLmStudioModelId: protoConfig.actModeLmStudioModelId,
+		actModeLiteLlmModelId: protoConfig.actModeLiteLlmModelId,
+		actModeLiteLlmModelInfo: convertProtoToLiteLLMModelInfo(protoConfig.actModeLiteLlmModelInfo),
+		actModeRequestyModelId: protoConfig.actModeRequestyModelId,
+		actModeRequestyModelInfo: convertProtoToModelInfo(protoConfig.actModeRequestyModelInfo),
+		actModeTogetherModelId: protoConfig.actModeTogetherModelId,
+		actModeFireworksModelId: protoConfig.actModeFireworksModelId,
+		actModeGroqModelId: protoConfig.actModeGroqModelId,
+		actModeGroqModelInfo: convertProtoToModelInfo(protoConfig.actModeGroqModelInfo),
+		actModeBasetenModelId: protoConfig.actModeBasetenModelId,
+		actModeBasetenModelInfo: convertProtoToModelInfo(protoConfig.actModeBasetenModelInfo),
+		actModeHuggingFaceModelId: protoConfig.actModeHuggingFaceModelId,
+		actModeHuggingFaceModelInfo: convertProtoToModelInfo(protoConfig.actModeHuggingFaceModelInfo),
+		actModeSapAiCoreModelId: protoConfig.actModeSapAiCoreModelId,
+		actModeHuaweiCloudMaasModelId: protoConfig.actModeHuaweiCloudMaasModelId,
+		actModeHuaweiCloudMaasModelInfo: convertProtoToModelInfo(protoConfig.actModeHuaweiCloudMaasModelInfo),
+		actModeSapAiCoreDeploymentId: protoConfig.actModeSapAiCoreDeploymentId,
+		actModeOcaModelId: protoConfig.actModeOcaModelId,
+		actModeOcaModelInfo: convertProtoOcaModelInfoToOcaModelInfo(protoConfig.actModeOcaModelInfo),
+		actModeOcaReasoningEffort: protoConfig.actModeOcaReasoningEffort,
+		actModeAihubmixModelId: protoConfig.actModeAihubmixModelId,
+		actModeAihubmixModelInfo: convertProtoToOpenAiCompatibleModelInfo(protoConfig.actModeAihubmixModelInfo),
+		actModeHicapModelId: protoConfig.actModeHicapModelId,
+		actModeHicapModelInfo: convertProtoToModelInfo(protoConfig.actModeHicapModelInfo),
+		actModeNousResearchModelId: protoConfig.actModeNousResearchModelId,
+		actModeVercelAiGatewayModelId: protoConfig.actModeVercelAiGatewayModelId,
+		actModeVercelAiGatewayModelInfo: convertProtoToModelInfo(protoConfig.actModeVercelAiGatewayModelInfo),
+	}
+}
diff --git a/apps/vscode/src/shared/proto-conversions/models/typeConversion.ts b/apps/vscode/src/shared/proto-conversions/models/typeConversion.ts
new file mode 100644
index 0000000..490686a
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/models/typeConversion.ts
@@ -0,0 +1,180 @@
+import { LiteLLMModelInfo, ModelInfo, OcaModelInfo, OpenAiCompatibleModelInfo } from "@shared/api"
+import {
+	OpenRouterModelInfo,
+	LiteLLMModelInfo as ProtoLiteLLMModelInfo,
+	OcaModelInfo as ProtoOcaModelInfo,
+	OpenAiCompatibleModelInfo as ProtoOpenAiCompatibleModelInfo,
+	ThinkingConfig,
+} from "@shared/proto/cline/models"
+
+/**
+ * Convert protobuf ThinkingConfig to application ThinkingConfig
+ * Converts empty arrays to undefined for optional fields
+ */
+function convertThinkingConfig(protoConfig: ThinkingConfig | undefined): ModelInfo["thinkingConfig"] | undefined {
+	if (!protoConfig) {
+		return undefined
+	}
+
+	return {
+		maxBudget: protoConfig.maxBudget,
+		outputPrice: protoConfig.outputPrice,
+		outputPriceTiers: protoConfig.outputPriceTiers.length > 0 ? protoConfig.outputPriceTiers : undefined,
+	}
+}
+
+/**
+ * Convert application ThinkingConfig to protobuf ThinkingConfig
+ * Converts undefined to empty arrays for proto fields
+ */
+function toProtobufThinkingConfig(appConfig: ModelInfo["thinkingConfig"] | undefined): ThinkingConfig | undefined {
+	if (!appConfig) {
+		return undefined
+	}
+
+	return ThinkingConfig.create({
+		maxBudget: appConfig.maxBudget,
+		outputPrice: appConfig.outputPrice,
+		outputPriceTiers: appConfig.outputPriceTiers || [],
+	})
+}
+
+/**
+ * Convert protobuf OpenRouterModelInfo to application ModelInfo
+ */
+export function fromProtobufModelInfo(protoInfo: OpenRouterModelInfo): ModelInfo {
+	return {
+		name: protoInfo.name,
+		maxTokens: protoInfo.maxTokens,
+		contextWindow: protoInfo.contextWindow,
+		supportsImages: protoInfo.supportsImages,
+		supportsPromptCache: protoInfo.supportsPromptCache,
+		supportsReasoning: protoInfo.supportsReasoning,
+		inputPrice: protoInfo.inputPrice,
+		outputPrice: protoInfo.outputPrice,
+		cacheWritesPrice: protoInfo.cacheWritesPrice,
+		cacheReadsPrice: protoInfo.cacheReadsPrice,
+		description: protoInfo.description,
+		thinkingConfig: convertThinkingConfig(protoInfo.thinkingConfig),
+		supportsGlobalEndpoint: protoInfo.supportsGlobalEndpoint,
+		tiers: protoInfo.tiers.length > 0 ? protoInfo.tiers : undefined,
+		temperature: protoInfo.temperature,
+		apiFormat: protoInfo.apiFormat,
+	}
+}
+
+/**
+ * Convert application ModelInfo to protobuf OpenRouterModelInfo
+ */
+export function toProtobufModelInfo(modelInfo: ModelInfo): OpenRouterModelInfo {
+	return OpenRouterModelInfo.create({
+		name: modelInfo.name,
+		maxTokens: modelInfo.maxTokens,
+		contextWindow: modelInfo.contextWindow,
+		supportsImages: modelInfo.supportsImages,
+		supportsPromptCache: modelInfo.supportsPromptCache,
+		supportsReasoning: modelInfo.supportsReasoning,
+		inputPrice: modelInfo.inputPrice,
+		outputPrice: modelInfo.outputPrice,
+		cacheWritesPrice: modelInfo.cacheWritesPrice,
+		cacheReadsPrice: modelInfo.cacheReadsPrice,
+		description: modelInfo.description,
+		thinkingConfig: toProtobufThinkingConfig(modelInfo.thinkingConfig),
+		supportsGlobalEndpoint: modelInfo.supportsGlobalEndpoint,
+		tiers: modelInfo.tiers || [],
+		temperature: modelInfo.temperature,
+		apiFormat: modelInfo.apiFormat,
+	})
+}
+
+/**
+ * Convert protobuf OpenAiCompatibleModelInfo to application OpenAiCompatibleModelInfo
+ */
+export function fromProtobufOpenAiCompatibleModelInfo(protoInfo: ProtoOpenAiCompatibleModelInfo): OpenAiCompatibleModelInfo {
+	return {
+		maxTokens: protoInfo.maxTokens,
+		contextWindow: protoInfo.contextWindow,
+		supportsImages: protoInfo.supportsImages,
+		supportsPromptCache: protoInfo.supportsPromptCache,
+		inputPrice: protoInfo.inputPrice,
+		outputPrice: protoInfo.outputPrice,
+		cacheWritesPrice: protoInfo.cacheWritesPrice,
+		cacheReadsPrice: protoInfo.cacheReadsPrice,
+		description: protoInfo.description,
+		thinkingConfig: convertThinkingConfig(protoInfo.thinkingConfig),
+		supportsGlobalEndpoint: protoInfo.supportsGlobalEndpoint,
+		tiers: protoInfo.tiers.length > 0 ? protoInfo.tiers : undefined,
+		temperature: protoInfo.temperature,
+		isR1FormatRequired: protoInfo.isR1FormatRequired,
+	}
+}
+
+/**
+ * Convert protobuf LiteLLMModelInfo to application LiteLLMModelInfo
+ */
+export function fromProtobufLiteLLMModelInfo(protoInfo: ProtoLiteLLMModelInfo): LiteLLMModelInfo {
+	return {
+		maxTokens: protoInfo.maxTokens,
+		contextWindow: protoInfo.contextWindow,
+		supportsImages: protoInfo.supportsImages,
+		supportsPromptCache: protoInfo.supportsPromptCache,
+		supportsReasoning: protoInfo.supportsReasoning,
+		inputPrice: protoInfo.inputPrice,
+		outputPrice: protoInfo.outputPrice,
+		cacheWritesPrice: protoInfo.cacheWritesPrice,
+		cacheReadsPrice: protoInfo.cacheReadsPrice,
+		description: protoInfo.description,
+		thinkingConfig: convertThinkingConfig(protoInfo.thinkingConfig),
+		supportsGlobalEndpoint: protoInfo.supportsGlobalEndpoint,
+		tiers: protoInfo.tiers.length > 0 ? protoInfo.tiers : undefined,
+		temperature: protoInfo.temperature,
+	}
+}
+
+/**
+ * Convert protobuf OcaModelInfo to application OcaModelInfo
+ */
+export function fromProtobufOcaModelInfo(protoInfo: ProtoOcaModelInfo): OcaModelInfo {
+	return {
+		maxTokens: protoInfo.maxTokens,
+		contextWindow: protoInfo.contextWindow,
+		supportsImages: protoInfo.supportsImages,
+		supportsPromptCache: protoInfo.supportsPromptCache,
+		inputPrice: protoInfo.inputPrice,
+		outputPrice: protoInfo.outputPrice,
+		cacheWritesPrice: protoInfo.cacheWritesPrice,
+		cacheReadsPrice: protoInfo.cacheReadsPrice,
+		description: protoInfo.description,
+		thinkingConfig: convertThinkingConfig(protoInfo.thinkingConfig),
+		temperature: protoInfo.temperature,
+		modelName: protoInfo.modelName,
+		surveyId: protoInfo.surveyId,
+		banner: protoInfo.banner,
+		surveyContent: protoInfo.surveyContent,
+		apiFormat: protoInfo.apiFormat,
+		supportsReasoning: protoInfo.supportsReasoning,
+		reasoningEffortOptions: protoInfo.reasoningEffortOptions,
+	}
+}
+
+/**
+ * Convert a record of protobuf models to application models
+ */
+export function fromProtobufModels(protoModels: Record<string, OpenRouterModelInfo>): Record<string, ModelInfo> {
+	const result: Record<string, ModelInfo> = {}
+	for (const [key, value] of Object.entries(protoModels)) {
+		result[key] = fromProtobufModelInfo(value)
+	}
+	return result
+}
+
+/**
+ * Convert a record of application models to protobuf models
+ */
+export function toProtobufModels(models: Record<string, ModelInfo>): Record<string, OpenRouterModelInfo> {
+	const result: Record<string, OpenRouterModelInfo> = {}
+	for (const [key, value] of Object.entries(models)) {
+		result[key] = toProtobufModelInfo(value)
+	}
+	return result
+}
diff --git a/apps/vscode/src/shared/proto-conversions/models/vscode-lm-models-conversion.ts b/apps/vscode/src/shared/proto-conversions/models/vscode-lm-models-conversion.ts
new file mode 100644
index 0000000..b2444d6
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/models/vscode-lm-models-conversion.ts
@@ -0,0 +1,23 @@
+import { LanguageModelChatSelector } from "@shared/proto/cline/models"
+
+/**
+ * Represents a VS Code language model in the native VS Code format
+ */
+export interface VsCodeNativeModel {
+	vendor?: string
+	family?: string
+	version?: string
+	id?: string
+}
+
+/**
+ * Converts VS Code native model format to protobuf format
+ */
+export function convertVsCodeNativeModelsToProtoModels(models: VsCodeNativeModel[]): LanguageModelChatSelector[] {
+	return (models || []).map((model) => ({
+		vendor: model.vendor || "",
+		family: model.family || "",
+		version: model.version || "",
+		id: model.id || "",
+	}))
+}
diff --git a/apps/vscode/src/shared/proto-conversions/state/telemetry-setting-conversion.ts b/apps/vscode/src/shared/proto-conversions/state/telemetry-setting-conversion.ts
new file mode 100644
index 0000000..5fc6f0b
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/state/telemetry-setting-conversion.ts
@@ -0,0 +1,18 @@
+import { TelemetrySettingEnum } from "@shared/proto/cline/state"
+import { TelemetrySetting } from "../../TelemetrySetting"
+
+/**
+ * Converts a proto TelemetrySettingEnum to a domain TelemetrySetting string
+ */
+export function convertProtoTelemetrySettingToDomain(setting: TelemetrySettingEnum): TelemetrySetting {
+	switch (setting) {
+		case TelemetrySettingEnum.UNSET:
+			return "unset"
+		case TelemetrySettingEnum.ENABLED:
+			return "enabled"
+		case TelemetrySettingEnum.DISABLED:
+			return "disabled"
+		default:
+			return "unset"
+	}
+}
diff --git a/apps/vscode/src/shared/proto-conversions/web/open-graph-conversion.ts b/apps/vscode/src/shared/proto-conversions/web/open-graph-conversion.ts
new file mode 100644
index 0000000..a50d841
--- /dev/null
+++ b/apps/vscode/src/shared/proto-conversions/web/open-graph-conversion.ts
@@ -0,0 +1,18 @@
+import { OpenGraphData as DomainOpenGraphData } from "@integrations/misc/link-preview"
+import { OpenGraphData as ProtoOpenGraphData } from "@shared/proto/cline/web"
+
+/**
+ * Converts domain OpenGraphData objects to proto OpenGraphData objects
+ * @param ogData Domain OpenGraphData object
+ * @returns Proto OpenGraphData object
+ */
+export function convertDomainOpenGraphDataToProto(ogData: DomainOpenGraphData): ProtoOpenGraphData {
+	return ProtoOpenGraphData.create({
+		title: ogData.title || "",
+		description: ogData.description || "",
+		image: ogData.image || "",
+		url: ogData.url || "",
+		siteName: ogData.siteName || "",
+		type: ogData.type || "",
+	})
+}
diff --git a/apps/vscode/src/shared/providers/bedrock.json b/apps/vscode/src/shared/providers/bedrock.json
new file mode 100644
index 0000000..c962876
--- /dev/null
+++ b/apps/vscode/src/shared/providers/bedrock.json
@@ -0,0 +1,30 @@
+{
+	"regions": [
+		"us-east-1",
+		"us-east-2",
+		"us-west-1",
+		"us-west-2",
+		"ap-south-1",
+		"ap-northeast-1",
+		"ap-northeast-2",
+		"ap-northeast-3",
+		"ap-southeast-1",
+		"ap-southeast-2",
+		"ap-southeast-3",
+		"ap-southeast-4",
+		"ap-southeast-5",
+		"ap-southeast-7",
+		"ca-central-1",
+		"eu-central-1",
+		"eu-central-2",
+		"eu-west-1",
+		"eu-west-2",
+		"eu-west-3",
+		"eu-north-1",
+		"eu-south-1",
+		"eu-south-2",
+		"sa-east-1",
+		"us-gov-east-1",
+		"us-gov-west-1"
+	]
+}
diff --git a/apps/vscode/src/shared/providers/vertex.json b/apps/vscode/src/shared/providers/vertex.json
new file mode 100644
index 0000000..495fe09
--- /dev/null
+++ b/apps/vscode/src/shared/providers/vertex.json
@@ -0,0 +1,10 @@
+{
+	"regions": [
+		"us-east5",
+		"us-central1",
+		"europe-west1",
+		"europe-west4",
+		"asia-southeast1",
+		"global"
+	]
+}
diff --git a/apps/vscode/src/shared/remote-config/__tests__/schema.test.ts b/apps/vscode/src/shared/remote-config/__tests__/schema.test.ts
new file mode 100644
index 0000000..406ea46
--- /dev/null
+++ b/apps/vscode/src/shared/remote-config/__tests__/schema.test.ts
@@ -0,0 +1,882 @@
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+import {
+	AwsBedrockSettingsSchema,
+	ClineSettingsSchema,
+	EnterpriseTelemetrySchema,
+	OpenAiCompatibleSchema,
+	PromptUploadingSchema,
+	type RemoteConfig,
+	RemoteConfigSchema,
+	S3AccessKeySettingsSchema,
+} from "../schema"
+
+describe("Remote Config Schema", () => {
+	describe("EnterpriseTelemetry", () => {
+		it("accepts an empty object", () => {
+			const result = EnterpriseTelemetrySchema.parse({})
+
+			expect(result).to.deep.equal({})
+		})
+
+		it("accepts an empty prompt uploading object", () => {
+			const result = EnterpriseTelemetrySchema.parse({
+				promptUploading: {},
+			})
+
+			expect(result.promptUploading).to.deep.equal({})
+		})
+	})
+
+	describe("S3AccessKeySettingsSchema", () => {
+		it("should accept valid S3 access key settings with required fields", () => {
+			const validSettings = {
+				bucket: "my-bucket",
+				accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+			}
+			const result = S3AccessKeySettingsSchema.parse(validSettings)
+			expect(result).to.deep.equal(validSettings)
+		})
+
+		it("should accept S3 settings with all optional fields", () => {
+			const fullSettings = {
+				bucket: "my-bucket",
+				accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				region: "us-east-1",
+				endpoint: "https://s3.us-east-1.amazonaws.com",
+				accountId: "123456789012",
+				intervalMs: 30000,
+				maxRetries: 3,
+				batchSize: 100,
+				maxQueueSize: 1000,
+				maxFailedAgeMs: 86400000,
+				backfillEnabled: true,
+			}
+			const result = S3AccessKeySettingsSchema.parse(fullSettings)
+			expect(result).to.deep.equal(fullSettings)
+		})
+
+		it("should accept S3 settings with queue configuration fields", () => {
+			const settings = {
+				bucket: "my-bucket",
+				accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				intervalMs: 60000,
+				maxRetries: 5,
+				batchSize: 50,
+				maxQueueSize: 500,
+				maxFailedAgeMs: 172800000,
+				backfillEnabled: false,
+			}
+			const result = S3AccessKeySettingsSchema.parse(settings)
+			expect(result.intervalMs).to.equal(60000)
+			expect(result.maxRetries).to.equal(5)
+			expect(result.batchSize).to.equal(50)
+			expect(result.maxQueueSize).to.equal(500)
+			expect(result.maxFailedAgeMs).to.equal(172800000)
+			expect(result.backfillEnabled).to.equal(false)
+		})
+
+		it("should reject S3 settings with invalid intervalMs type", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					intervalMs: "30000",
+				}),
+			).to.throw()
+		})
+
+		it("should reject S3 settings with invalid maxRetries type", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					maxRetries: "3",
+				}),
+			).to.throw()
+		})
+
+		it("should reject S3 settings with invalid backfillEnabled type", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					backfillEnabled: "true",
+				}),
+			).to.throw()
+		})
+
+		it("should reject S3 settings with missing bucket", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				}),
+			).to.throw()
+		})
+
+		it("should reject S3 settings with missing accessKeyId", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				}),
+			).to.throw()
+		})
+
+		it("should reject S3 settings with missing secretAccessKey", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				}),
+			).to.throw()
+		})
+	})
+
+	describe("PromptUploadingSchema", () => {
+		it("should accept an empty object", () => {
+			const result = PromptUploadingSchema.parse({})
+			expect(result).to.deep.equal({})
+		})
+
+		it("should accept enabled field only", () => {
+			const result = PromptUploadingSchema.parse({ enabled: true })
+			expect(result.enabled).to.equal(true)
+		})
+
+		it("should accept enabled as false", () => {
+			const result = PromptUploadingSchema.parse({ enabled: false })
+			expect(result.enabled).to.equal(false)
+		})
+
+		it("should accept type field with s3_access_keys", () => {
+			const result = PromptUploadingSchema.parse({ type: "s3_access_keys" })
+			expect(result.type).to.equal("s3_access_keys")
+		})
+
+		it("should reject invalid type values", () => {
+			expect(() => PromptUploadingSchema.parse({ type: "invalid_type" })).to.throw()
+			expect(() => PromptUploadingSchema.parse({ type: "s3" })).to.throw()
+			expect(() => PromptUploadingSchema.parse({ type: "" })).to.throw()
+		})
+
+		it("should accept complete prompt uploading configuration", () => {
+			const fullConfig = {
+				enabled: true,
+				type: "s3_access_keys" as const,
+				s3AccessSettings: {
+					bucket: "prompt-uploads-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					region: "us-west-2",
+					endpoint: "https://s3.us-west-2.amazonaws.com",
+					accountId: "123456789012",
+					intervalMs: 30000,
+					maxRetries: 3,
+					batchSize: 100,
+					maxQueueSize: 1000,
+					maxFailedAgeMs: 86400000,
+					backfillEnabled: true,
+				},
+			}
+			const result = PromptUploadingSchema.parse(fullConfig)
+			expect(result).to.deep.equal(fullConfig)
+			expect(result.enabled).to.equal(true)
+			expect(result.type).to.equal("s3_access_keys")
+			expect(result.s3AccessSettings?.bucket).to.equal("prompt-uploads-bucket")
+			expect(result.s3AccessSettings?.region).to.equal("us-west-2")
+			expect(result.s3AccessSettings?.intervalMs).to.equal(30000)
+			expect(result.s3AccessSettings?.maxRetries).to.equal(3)
+			expect(result.s3AccessSettings?.batchSize).to.equal(100)
+			expect(result.s3AccessSettings?.maxQueueSize).to.equal(1000)
+			expect(result.s3AccessSettings?.maxFailedAgeMs).to.equal(86400000)
+			expect(result.s3AccessSettings?.backfillEnabled).to.equal(true)
+		})
+
+		it("should accept s3AccessSettings without optional fields", () => {
+			const config = {
+				enabled: true,
+				type: "s3_access_keys" as const,
+				s3AccessSettings: {
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				},
+			}
+			const result = PromptUploadingSchema.parse(config)
+			expect(result.s3AccessSettings?.bucket).to.equal("my-bucket")
+			expect(result.s3AccessSettings?.region).to.be.undefined
+			expect(result.s3AccessSettings?.endpoint).to.be.undefined
+			expect(result.s3AccessSettings?.accountId).to.be.undefined
+			expect(result.s3AccessSettings?.intervalMs).to.be.undefined
+			expect(result.s3AccessSettings?.maxRetries).to.be.undefined
+			expect(result.s3AccessSettings?.batchSize).to.be.undefined
+			expect(result.s3AccessSettings?.maxQueueSize).to.be.undefined
+			expect(result.s3AccessSettings?.maxFailedAgeMs).to.be.undefined
+			expect(result.s3AccessSettings?.backfillEnabled).to.be.undefined
+		})
+
+		it("should reject s3AccessSettings with missing required fields", () => {
+			expect(() =>
+				PromptUploadingSchema.parse({
+					enabled: true,
+					s3AccessSettings: {
+						accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+						secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					},
+				}),
+			).to.throw()
+		})
+
+		it("should reject invalid enabled type", () => {
+			expect(() => PromptUploadingSchema.parse({ enabled: "yes" })).to.throw()
+			expect(() => PromptUploadingSchema.parse({ enabled: 1 })).to.throw()
+		})
+	})
+
+	describe("OpenAiCompatibleSchema", () => {
+		it("should accept valid OpenAI compatible settings", () => {
+			const validSettings = {
+				models: [
+					{
+						id: "gpt-4",
+						temperature: 0.7,
+						isR1FormatRequired: true,
+						maxTokens: 4096,
+						contextWindow: 128000,
+						inputPrice: 0.03,
+						outputPrice: 0.06,
+						supportsImages: true,
+					},
+					{
+						id: "gpt-3.5-turbo",
+						temperature: 0.7,
+						maxTokens: 4096,
+						contextWindow: 16000,
+						inputPrice: 0.001,
+						outputPrice: 0.002,
+						supportsImages: false,
+					},
+				],
+				openAiBaseUrl: "https://api.openai.com/v1",
+				openAiHeaders: { "X-Custom-Header": "value" },
+				azureApiVersion: "2024-02-15-preview",
+			}
+			const result = OpenAiCompatibleSchema.parse(validSettings)
+			expect(result).to.deep.equal(validSettings)
+		})
+
+		it("should have undefined for models and openAiHeaders by default", () => {
+			const result = OpenAiCompatibleSchema.parse({})
+			expect(result.models).to.be.undefined
+			expect(result.openAiHeaders).to.be.undefined
+		})
+
+		it("should reject invalid field types", () => {
+			expect(() => OpenAiCompatibleSchema.parse({ models: "not-an-array" })).to.throw()
+			expect(() => OpenAiCompatibleSchema.parse({ openAiHeaders: "not-an-object" })).to.throw()
+		})
+
+		it("should reject models with missing id field", () => {
+			expect(() =>
+				OpenAiCompatibleSchema.parse({
+					models: [{ temperature: 0.7 }],
+				}),
+			).to.throw()
+		})
+
+		it("should accept models with only id field", () => {
+			const settings = {
+				models: [{ id: "gpt-4" }],
+			}
+			expect(() => OpenAiCompatibleSchema.parse(settings)).to.not.throw()
+		})
+
+		it("should accept headers as record of strings", () => {
+			const settings = {
+				openAiHeaders: {
+					Authorization: "Bearer token",
+					"Content-Type": "application/json",
+				},
+			}
+			const result = OpenAiCompatibleSchema.parse(settings)
+			expect(result.openAiHeaders).to.deep.equal(settings.openAiHeaders)
+		})
+	})
+
+	describe("ClineSettingsSchema", () => {
+		it("should accept valid Cline provider settings", () => {
+			const validSettings = {
+				models: [{ id: "claude-3-5-sonnet-20241022" }, { id: "claude-3-5-haiku-20241022" }],
+			}
+			const result = ClineSettingsSchema.parse(validSettings)
+			expect(result).to.deep.equal(validSettings)
+		})
+
+		it("should accept empty settings object", () => {
+			const result = ClineSettingsSchema.parse({})
+			expect(result.models).to.be.undefined
+		})
+
+		it("should accept models with only id field", () => {
+			const settings = {
+				models: [{ id: "claude-3-5-sonnet-20241022" }],
+			}
+			expect(() => ClineSettingsSchema.parse(settings)).to.not.throw()
+		})
+
+		it("should reject models with missing id field", () => {
+			expect(() =>
+				ClineSettingsSchema.parse({
+					models: [{}],
+				}),
+			).to.throw()
+		})
+	})
+
+	describe("AwsBedrockSettingsSchema", () => {
+		it("should accept valid AWS Bedrock settings", () => {
+			const validSettings = {
+				models: [
+					{ id: "anthropic.claude-v2", thinkingBudgetTokens: 1600 },
+					{ id: "anthropic.claude-instant-v1", thinkingBudgetTokens: 800 },
+				],
+				customModels: [
+					{ name: "my-custom-model", baseModelId: "anthropic.claude-v2" },
+					{ name: "another-model", baseModelId: "anthropic.claude-instant-v1" },
+				],
+				awsRegion: "us-east-1",
+				awsUseCrossRegionInference: true,
+				awsBedrockUsePromptCache: true,
+				awsBedrockEndpoint: "https://bedrock.us-east-1.amazonaws.com",
+			}
+			const result = AwsBedrockSettingsSchema.parse(validSettings)
+			expect(result).to.deep.equal(validSettings)
+		})
+
+		it("should accept empty settings object", () => {
+			const result = AwsBedrockSettingsSchema.parse({})
+			expect(result.models).to.be.undefined
+			expect(result.customModels).to.be.undefined
+		})
+
+		it("should accept models with only id field", () => {
+			const settings = {
+				models: [{ id: "anthropic.claude-v2" }],
+			}
+			expect(() => AwsBedrockSettingsSchema.parse(settings)).to.not.throw()
+		})
+
+		it("should accept models with thinkingBudgetTokens", () => {
+			const settings = {
+				models: [
+					{ id: "anthropic.claude-v2", thinkingBudgetTokens: 1600 },
+					{ id: "anthropic.claude-instant-v1", thinkingBudgetTokens: 800 },
+				],
+			}
+			const result = AwsBedrockSettingsSchema.parse(settings)
+			expect(result.models).to.have.lengthOf(2)
+			expect(result.models?.[0].thinkingBudgetTokens).to.equal(1600)
+		})
+
+		it("should accept custom models array", () => {
+			const settings = {
+				customModels: [
+					{ name: "custom-1", baseModelId: "base-model-1", thinkingBudgetTokens: 1600 },
+					{ name: "custom-2", baseModelId: "base-model-2" },
+				],
+			}
+			expect(() => AwsBedrockSettingsSchema.parse(settings)).to.not.throw()
+		})
+
+		it("should reject invalid field types", () => {
+			expect(() => AwsBedrockSettingsSchema.parse({ models: "not-an-array" })).to.throw()
+			expect(() => AwsBedrockSettingsSchema.parse({ customModels: "not-an-array" })).to.throw()
+		})
+
+		it("should reject models with missing id field", () => {
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({
+					models: [{ thinkingBudgetTokens: 1600 }],
+				}),
+			).to.throw()
+		})
+
+		it("should reject custom models with missing fields", () => {
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({
+					customModels: [{ name: "missing-base-model" }],
+				}),
+			).to.throw()
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({
+					customModels: [{ baseModelId: "missing-name" }],
+				}),
+			).to.throw()
+		})
+	})
+
+	describe("MCPSettingsSchema", () => {
+		it("should reject servers with a missing id", () => {
+			const config = {
+				version: "v1",
+				allowedMCPServers: [{}],
+			}
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw()
+		})
+
+		it("should accept valid MCP settings", () => {
+			const config = {
+				version: "v1",
+				mcpMarketplaceEnabled: true,
+				allowedMCPServers: [{ id: "https://github.com/mcp/filesystem" }, { id: "https://github.com/mcp/github" }],
+			}
+
+			const result = RemoteConfigSchema.parse(config)
+			expect(result.mcpMarketplaceEnabled).to.equal(true)
+			expect(result.allowedMCPServers).to.deep.equal(config.allowedMCPServers)
+		})
+	})
+
+	describe("RemoteMCPServersSchema", () => {
+		it("should accept remoteMCPServers with alwaysEnabled true", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "always-on-server", url: "https://example.com/mcp", alwaysEnabled: true }],
+			}
+
+			const result = RemoteConfigSchema.parse(config)
+			expect(result.remoteMCPServers).to.have.lengthOf(1)
+			expect(result.remoteMCPServers?.[0].name).to.equal("always-on-server")
+			expect(result.remoteMCPServers?.[0].url).to.equal("https://example.com/mcp")
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.equal(true)
+		})
+
+		it("should accept remoteMCPServers with alwaysEnabled false", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "toggle-server", url: "https://example.com/mcp", alwaysEnabled: false }],
+			}
+
+			const result = RemoteConfigSchema.parse(config)
+			expect(result.remoteMCPServers).to.have.lengthOf(1)
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.equal(false)
+		})
+
+		it("should accept remoteMCPServers without alwaysEnabled (defaults to undefined)", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "default-server", url: "https://example.com/mcp" }],
+			}
+
+			const result = RemoteConfigSchema.parse(config)
+			expect(result.remoteMCPServers).to.have.lengthOf(1)
+			expect(result.remoteMCPServers?.[0].name).to.equal("default-server")
+			expect(result.remoteMCPServers?.[0].url).to.equal("https://example.com/mcp")
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.be.undefined
+		})
+
+		it("should accept multiple remoteMCPServers with mixed alwaysEnabled values", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{ name: "always-on", url: "https://example1.com/mcp", alwaysEnabled: true },
+					{ name: "toggle", url: "https://example2.com/mcp", alwaysEnabled: false },
+					{ name: "default", url: "https://example3.com/mcp" },
+				],
+			}
+
+			const result = RemoteConfigSchema.parse(config)
+			expect(result.remoteMCPServers).to.have.lengthOf(3)
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.equal(true)
+			expect(result.remoteMCPServers?.[1].alwaysEnabled).to.equal(false)
+			expect(result.remoteMCPServers?.[2].alwaysEnabled).to.be.undefined
+		})
+
+		it("should reject remoteMCPServers with missing name", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ url: "https://example.com/mcp", alwaysEnabled: true }],
+			}
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw()
+		})
+
+		it("should reject remoteMCPServers with missing url", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "test-server", alwaysEnabled: true }],
+			}
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw()
+		})
+
+		it("should reject remoteMCPServers with invalid alwaysEnabled type", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "test-server", url: "https://example.com/mcp", alwaysEnabled: "yes" }],
+			}
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw()
+		})
+
+		it("should accept headers", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "test-server", url: "https://example.com/mcp", headers: { Authorization: "test" } }],
+			}
+
+			const result = RemoteConfigSchema.parse(config)
+			expect(result.remoteMCPServers).to.have.lengthOf(1)
+			expect(result.remoteMCPServers?.[0].headers).to.deep.equal({ Authorization: "test" })
+		})
+	})
+
+	describe("RemoteConfigSchema", () => {
+		it("should accept valid complete remote config", () => {
+			const validConfig: RemoteConfig = {
+				version: "v1",
+				telemetryEnabled: true,
+				kanbanEnabled: true,
+				mcpMarketplaceEnabled: true,
+				yoloModeAllowed: false,
+				providerSettings: {
+					OpenAiCompatible: {
+						models: [{ id: "gpt-4" }],
+						openAiBaseUrl: "https://api.openai.com/v1",
+						openAiHeaders: {},
+					},
+					AwsBedrock: {
+						models: [{ id: "anthropic.claude-v2" }],
+						awsRegion: "us-west-2",
+					},
+				},
+			}
+			const result = RemoteConfigSchema.parse(validConfig)
+			expect(result).to.deep.equal(validConfig)
+		})
+
+		it("should require version field", () => {
+			const configWithoutVersion = {}
+			expect(() => RemoteConfigSchema.parse(configWithoutVersion)).to.throw()
+		})
+
+		it("should accept minimal valid config", () => {
+			const minimalConfig = {
+				version: "v1",
+			}
+			expect(() => RemoteConfigSchema.parse(minimalConfig)).to.not.throw()
+		})
+
+		it("should accept config with general settings only", () => {
+			const configWithGeneralSettings = {
+				version: "v1",
+				telemetryEnabled: false,
+				mcpMarketplaceEnabled: false,
+				yoloModeAllowed: true,
+			}
+			const result = RemoteConfigSchema.parse(configWithGeneralSettings)
+			expect(result.telemetryEnabled).to.equal(false)
+			expect(result.mcpMarketplaceEnabled).to.equal(false)
+			expect(result.yoloModeAllowed).to.equal(true)
+		})
+
+		it("should accept config with OpenAI compatible provider only", () => {
+			const config = {
+				version: "v1",
+				providerSettings: {
+					OpenAiCompatible: {
+						models: [{ id: "gpt-4" }, { id: "gpt-3.5-turbo" }],
+						openAiBaseUrl: "https://api.openai.com/v1",
+					},
+				},
+			}
+			expect(() => RemoteConfigSchema.parse(config)).to.not.throw()
+		})
+
+		it("should accept config with AWS Bedrock provider only", () => {
+			const config = {
+				version: "v1",
+				providerSettings: {
+					AwsBedrock: {
+						models: [{ id: "anthropic.claude-v2" }],
+						awsRegion: "us-east-1",
+					},
+				},
+			}
+			expect(() => RemoteConfigSchema.parse(config)).to.not.throw()
+		})
+
+		it("should reject invalid version type", () => {
+			expect(() => RemoteConfigSchema.parse({ version: 123 })).to.throw()
+		})
+
+		it("should reject invalid telemetry setting type", () => {
+			expect(() =>
+				RemoteConfigSchema.parse({
+					version: "v1",
+					telemetryEnabled: "yes",
+				}),
+			).to.throw()
+		})
+
+		it("should allow undefined optional provider settings", () => {
+			const config = {
+				version: "v1",
+				// providerSettings is undefined
+			}
+			expect(() => RemoteConfigSchema.parse(config)).to.not.throw()
+		})
+
+		it("should handle complete config with all fields", () => {
+			const config = {
+				version: "v1",
+				telemetryEnabled: true,
+				kanbanEnabled: true,
+				mcpMarketplaceEnabled: false,
+				blockPersonalRemoteMCPServers: true,
+				allowedMCPServers: [{ id: "https://github.com/mcp/filesystem" }, { id: "https://github.com/mcp/github" }],
+				yoloModeAllowed: true,
+				openTelemetryEnabled: true,
+				openTelemetryMetricsExporter: "otlp",
+				openTelemetryLogsExporter: "otlp",
+				openTelemetryOtlpProtocol: "http/json",
+				openTelemetryOtlpEndpoint: "http://localhost:4318",
+				openTelemetryOtlpMetricsProtocol: "http/json",
+				openTelemetryOtlpMetricsEndpoint: "http://localhost:4318/v1/metrics",
+				openTelemetryOtlpLogsProtocol: "http/json",
+				openTelemetryOtlpLogsEndpoint: "http://localhost:4318/v1/logs",
+				openTelemetryMetricExportInterval: 60000,
+				openTelemetryOtlpInsecure: false,
+				openTelemetryLogBatchSize: 512,
+				openTelemetryLogBatchTimeout: 5000,
+				openTelemetryLogMaxQueueSize: 2048,
+				openTelemetryOtlpHeaders: { test: "string" },
+				globalRules: [
+					{
+						alwaysEnabled: true,
+						name: "company-standards.md",
+						contents: "# Company Standards\n\nAll code must follow these standards...",
+					},
+					{
+						alwaysEnabled: false,
+						name: "optional-guidelines.md",
+						contents: "# Optional Guidelines\n\nConsider these best practices...",
+					},
+				],
+				globalWorkflows: [
+					{
+						alwaysEnabled: true,
+						name: "deployment-workflow.md",
+						contents: "# Deployment Workflow\n\n1. Run tests\n2. Build\n3. Deploy",
+					},
+				],
+				globalSkills: [
+					{
+						alwaysEnabled: true,
+						name: "company-standards.md",
+						contents: "# Company Standards\n\nAll code must follow these standards...",
+					},
+				],
+				providerSettings: {
+					OpenAiCompatible: {
+						models: [
+							{
+								id: "gpt-4",
+								temperature: 0.7,
+								isR1FormatRequired: false,
+								maxTokens: 4096,
+								contextWindow: 128000,
+								inputPrice: 0.03,
+								outputPrice: 0.06,
+								supportsImages: true,
+							},
+							{
+								id: "gpt-3.5-turbo",
+								temperature: 0.8,
+								isR1FormatRequired: false,
+								maxTokens: 4096,
+								contextWindow: 16000,
+								inputPrice: 0.001,
+								outputPrice: 0.002,
+								supportsImages: false,
+							},
+						],
+						openAiBaseUrl: "https://custom.openai.api/v1",
+						openAiHeaders: {
+							"X-API-Key": "secret-key",
+							"X-Custom-Header": "custom-value",
+						},
+						azureApiVersion: "2024-02-15-preview",
+					},
+					AwsBedrock: {
+						models: [
+							{ id: "anthropic.claude-v2", thinkingBudgetTokens: 1600 },
+							{ id: "anthropic.claude-instant-v1", thinkingBudgetTokens: 800 },
+						],
+						customModels: [
+							{
+								name: "my-custom-model",
+								baseModelId: "anthropic.claude-v2",
+								thinkingBudgetTokens: 2000,
+							},
+							{
+								name: "another-custom",
+								baseModelId: "anthropic.claude-instant-v1",
+								thinkingBudgetTokens: 1000,
+							},
+						],
+						awsRegion: "eu-west-1",
+						awsUseCrossRegionInference: false,
+						awsUseGlobalInference: true,
+						awsBedrockUsePromptCache: true,
+						awsBedrockEndpoint: "https://custom-bedrock.endpoint",
+					},
+					Cline: {
+						models: [{ id: "claude-3-5-sonnet-20241022" }, { id: "claude-3-5-haiku-20241022" }],
+					},
+					Vertex: {
+						models: [
+							{ id: "claude-3-5-sonnet-v2@20241022", thinkingBudgetTokens: 1600 },
+							{ id: "claude-3-5-haiku@20241022" },
+						],
+						vertexProjectId: "my-gcp-project",
+						vertexRegion: "us-central1",
+					},
+					Anthropic: {
+						models: [
+							{ id: "claude-3-5-sonnet-20241022" },
+							{ id: "claude-3-5-sonnet-20241024", thinkingBudgetTokens: 1600 },
+						],
+						baseUrl: "https://example.cline.bot",
+					},
+				},
+				enterpriseTelemetry: {
+					promptUploading: {
+						enabled: true,
+						type: "s3_access_keys",
+						s3AccessSettings: {
+							bucket: "enterprise-prompts",
+							accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+							secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+							region: "us-east-1",
+						},
+					},
+				},
+			}
+			const result = RemoteConfigSchema.parse(config)
+
+			// Verify all top-level fields
+			expect(result.version).to.equal("v1")
+			expect(result.telemetryEnabled).to.equal(true)
+			expect(result.yoloModeAllowed).to.equal(true)
+			expect(result.kanbanEnabled).to.equal(true)
+
+			expect(result.mcpMarketplaceEnabled).to.equal(false)
+			expect(result.allowedMCPServers).to.deep.equal(config.allowedMCPServers)
+
+			// Verify OpenAI Compatible settings
+			expect(result.providerSettings?.OpenAiCompatible?.models).to.have.lengthOf(2)
+			expect(result.providerSettings?.OpenAiCompatible?.openAiBaseUrl).to.equal("https://custom.openai.api/v1")
+			expect(result.providerSettings?.OpenAiCompatible?.azureApiVersion).to.equal("2024-02-15-preview")
+
+			// Verify AWS Bedrock settings
+			expect(result.providerSettings?.AwsBedrock?.models).to.have.lengthOf(2)
+			expect(result.providerSettings?.AwsBedrock?.customModels).to.have.lengthOf(2)
+			expect(result.providerSettings?.AwsBedrock?.awsRegion).to.equal("eu-west-1")
+			expect(result.providerSettings?.AwsBedrock?.awsUseCrossRegionInference).to.equal(false)
+			expect(result.providerSettings?.AwsBedrock?.awsUseGlobalInference).to.equal(true)
+			expect(result.providerSettings?.AwsBedrock?.awsBedrockUsePromptCache).to.equal(true)
+			expect(result.providerSettings?.AwsBedrock?.awsBedrockEndpoint).to.equal("https://custom-bedrock.endpoint")
+
+			// Verify Cline settings
+			expect(result.providerSettings?.Cline?.models).to.have.lengthOf(2)
+			expect(result.providerSettings?.Cline?.models?.[0].id).to.equal("claude-3-5-sonnet-20241022")
+			expect(result.providerSettings?.Cline?.models?.[1].id).to.equal("claude-3-5-haiku-20241022")
+
+			// Verify Vertex settings
+			expect(result.providerSettings?.Vertex?.models).to.have.lengthOf(2)
+			expect(result.providerSettings?.Vertex?.models?.[0].id).to.equal("claude-3-5-sonnet-v2@20241022")
+			expect(result.providerSettings?.Vertex?.models?.[0].thinkingBudgetTokens).to.equal(1600)
+			expect(result.providerSettings?.Vertex?.models?.[1].id).to.equal("claude-3-5-haiku@20241022")
+			expect(result.providerSettings?.Vertex?.models?.[1].thinkingBudgetTokens).to.be.undefined
+			expect(result.providerSettings?.Vertex?.vertexProjectId).to.equal("my-gcp-project")
+			expect(result.providerSettings?.Vertex?.vertexRegion).to.equal("us-central1")
+
+			expect(result.providerSettings?.Anthropic?.models).to.have.lengthOf(2)
+			expect(result.providerSettings?.Anthropic?.models?.[0].id).to.equal("claude-3-5-sonnet-20241022")
+			expect(result.providerSettings?.Anthropic?.models?.[0].thinkingBudgetTokens).to.be.undefined
+			expect(result.providerSettings?.Anthropic?.models?.[1].id).to.equal("claude-3-5-sonnet-20241024")
+			expect(result.providerSettings?.Anthropic?.models?.[1].thinkingBudgetTokens).to.equal(1600)
+			expect(result.providerSettings?.Anthropic?.baseUrl).to.equal("https://example.cline.bot")
+
+			// Verify OpenTelemetry settings
+			expect(result.openTelemetryEnabled).to.equal(true)
+			expect(result.openTelemetryMetricsExporter).to.equal("otlp")
+			expect(result.openTelemetryLogsExporter).to.equal("otlp")
+			expect(result.openTelemetryOtlpProtocol).to.equal("http/json")
+			expect(result.openTelemetryOtlpEndpoint).to.equal("http://localhost:4318")
+			expect(result.openTelemetryOtlpMetricsProtocol).to.equal("http/json")
+			expect(result.openTelemetryOtlpMetricsEndpoint).to.equal("http://localhost:4318/v1/metrics")
+			expect(result.openTelemetryOtlpLogsProtocol).to.equal("http/json")
+			expect(result.openTelemetryOtlpLogsEndpoint).to.equal("http://localhost:4318/v1/logs")
+			expect(result.openTelemetryMetricExportInterval).to.equal(60000)
+			expect(result.openTelemetryOtlpInsecure).to.equal(false)
+			expect(result.openTelemetryLogBatchSize).to.equal(512)
+			expect(result.openTelemetryLogBatchTimeout).to.equal(5000)
+			expect(result.openTelemetryLogMaxQueueSize).to.equal(2048)
+			expect(result.openTelemetryOtlpHeaders).to.deep.equal({ test: "string" })
+
+			// Verify Global Instructions settings
+			expect(result.globalRules).to.have.lengthOf(2)
+			expect(result.globalRules?.[0].alwaysEnabled).to.equal(true)
+			expect(result.globalRules?.[0].name).to.equal("company-standards.md")
+			expect(result.globalRules?.[0].contents).to.include("Company Standards")
+			expect(result.globalRules?.[1].alwaysEnabled).to.equal(false)
+			expect(result.globalRules?.[1].name).to.equal("optional-guidelines.md")
+
+			expect(result.globalWorkflows).to.have.lengthOf(1)
+			expect(result.globalWorkflows?.[0].alwaysEnabled).to.equal(true)
+			expect(result.globalWorkflows?.[0].name).to.equal("deployment-workflow.md")
+			expect(result.globalWorkflows?.[0].contents).to.include("Deployment Workflow")
+
+			expect(result.globalSkills).to.have.lengthOf(1)
+			expect(result.globalSkills?.[0].alwaysEnabled).to.equal(true)
+			expect(result.globalSkills?.[0].name).to.equal("company-standards.md")
+			expect(result.globalSkills?.[0].contents).to.include("Company Standards")
+
+			expect(result.enterpriseTelemetry?.promptUploading?.enabled).to.equal(true)
+			expect(result.enterpriseTelemetry?.promptUploading?.type).to.equal("s3_access_keys")
+			expect(result.enterpriseTelemetry?.promptUploading?.s3AccessSettings?.bucket).to.equal("enterprise-prompts")
+			expect(result.enterpriseTelemetry?.promptUploading?.s3AccessSettings?.region).to.equal("us-east-1")
+		})
+	})
+
+	describe("Type Inference", () => {
+		it("should properly infer RemoteConfig type", () => {
+			const config: RemoteConfig = {
+				version: "v1",
+				telemetryEnabled: true,
+			}
+			// TypeScript compilation will fail if type inference is wrong
+			expect(config.version).to.be.a("string")
+		})
+
+		it("should allow optional fields to be undefined", () => {
+			const config: RemoteConfig = {
+				version: "v1",
+				// All other fields are optional and can be undefined
+			}
+			expect(config.telemetryEnabled).to.be.undefined
+			expect(config.providerSettings).to.be.undefined
+		})
+	})
+})
diff --git a/apps/vscode/src/shared/remote-config/constants.ts b/apps/vscode/src/shared/remote-config/constants.ts
new file mode 100644
index 0000000..09df75e
--- /dev/null
+++ b/apps/vscode/src/shared/remote-config/constants.ts
@@ -0,0 +1,5 @@
+/**
+ * URI scheme for opening remote rules/workflows in the editor.
+ * Used to construct URIs like: remote://rule/{name} or remote://workflow/{name}
+ */
+export const REMOTE_URI_SCHEME = "remote://"
diff --git a/apps/vscode/src/shared/remote-config/schema.ts b/apps/vscode/src/shared/remote-config/schema.ts
new file mode 100644
index 0000000..da79bdb
--- /dev/null
+++ b/apps/vscode/src/shared/remote-config/schema.ts
@@ -0,0 +1,261 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ⚠️  CRITICAL WARNING ⚠️
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * THE API SERVER MUST BE RE-DEPLOYED WHENEVER THIS SCHEMA IS UPDATED!
+ *
+ * This schema is used by both the extension and the API server for validation.
+ * Any changes here require a coordinated deployment to avoid validation errors.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+import { z } from "zod"
+
+// OpenAI Compatible model schema with per-model settings
+const OpenAiCompatibleModelSchema = z.object({
+	id: z.string(), // The model ID is required
+	temperature: z.number().optional(),
+	isR1FormatRequired: z.boolean().optional(),
+	maxTokens: z.number().optional(),
+	contextWindow: z.number().optional(),
+	inputPrice: z.number().optional(),
+	outputPrice: z.number().optional(),
+	supportsImages: z.boolean().optional(),
+})
+
+// OpenAiCompatible specific settings
+export const OpenAiCompatibleSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(OpenAiCompatibleModelSchema).optional(),
+	// OpenAiCompatible specific settings:
+	openAiBaseUrl: z.string().optional(),
+	openAiHeaders: z.record(z.string(), z.string()).optional(),
+	azureApiVersion: z.string().optional(),
+	azureIdentity: z.boolean().optional(),
+})
+
+// AWS Bedrock model schema with per-model settings
+const AwsBedrockModelSchema = z.object({
+	id: z.string(), // The model ID is required
+	thinkingBudgetTokens: z.number().optional(),
+})
+
+// AWS Bedrock custom model schema (separate from regular models)
+const AwsBedrockCustomModelSchema = z.object({
+	name: z.string(), // The model name is required
+	baseModelId: z.string(), // The base model ID is required
+	thinkingBudgetTokens: z.number().optional(),
+})
+
+// AWS Bedrock specific settings
+export const AwsBedrockSettingsSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(AwsBedrockModelSchema).optional(),
+	// Custom models
+	customModels: z.array(AwsBedrockCustomModelSchema).optional(),
+	// AWS Bedrock specific settings:
+	awsRegion: z.string().optional(),
+	awsUseCrossRegionInference: z.boolean().optional(),
+	awsUseGlobalInference: z.boolean().optional(),
+	awsBedrockUsePromptCache: z.boolean().optional(),
+	awsBedrockEndpoint: z.string().optional(),
+})
+
+// Cline Provider model schema with per-model settings
+const ClineModelSchema = z.object({
+	id: z.string(), // The model ID is required
+})
+
+// Cline Provider specific settings
+export const ClineSettingsSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(ClineModelSchema).optional(),
+})
+
+// Vertex Provider model schema with per-model settings
+const VertexModelSchema = z.object({
+	id: z.string(), // The model ID is required
+	thinkingBudgetTokens: z.number().optional(),
+})
+
+// GCP Vertex Provider specific settings
+const VertexSettingsSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(VertexModelSchema).optional(),
+	vertexProjectId: z.string().optional(),
+	vertexRegion: z.string().optional(),
+})
+
+const LiteLLMModelSchema = z.object({
+	id: z.string(),
+	thinkingBudgetTokens: z.number().optional(),
+	promptCachingEnabled: z.boolean().optional(),
+})
+
+const LiteLLMSchema = z.object({
+	models: z.array(LiteLLMModelSchema).optional(),
+	baseUrl: z.string().optional(),
+})
+
+const AnthropicModelSchema = z.object({
+	id: z.string(),
+	thinkingBudgetTokens: z.number().optional(),
+})
+
+const AnthropicSchema = z.object({
+	models: z.array(AnthropicModelSchema).optional(),
+	baseUrl: z.string().optional(),
+})
+
+// Provider settings schema
+// Each provider becomes an optional field
+const ProviderSettingsSchema = z.object({
+	OpenAiCompatible: OpenAiCompatibleSchema.optional(),
+	AwsBedrock: AwsBedrockSettingsSchema.optional(),
+	Cline: ClineSettingsSchema.optional(),
+	Vertex: VertexSettingsSchema.optional(),
+	LiteLLM: LiteLLMSchema.optional(),
+	Anthropic: AnthropicSchema.optional(),
+})
+
+const AllowedMCPServerSchema = z.object({
+	// The ID of the MCP is the URL for their github repo.
+	id: z.string(),
+})
+
+const RemoteMCPServerSchema = z.object({
+	// The name of the MCP server
+	name: z.string(),
+	// The URL of the MCP server
+	url: z.string(),
+	// When this is true, the user cannot disable this MCP server
+	alwaysEnabled: z.boolean().optional(),
+	// Headers to allow for custom auth
+	headers: z.record(z.string(), z.string()).optional(),
+})
+
+// Settings for a global cline rules or workflow file.
+const GlobalInstructionsFileSchema = z.object({
+	// When this is enabled, the user cannot turn off this rule or workflow.
+	alwaysEnabled: z.boolean(),
+	// The name of the rules or workflow file.
+	name: z.string(),
+	// The contents of the rules or workflow file
+	contents: z.string(),
+})
+
+export const S3AccessKeySettingsSchema = z.object({
+	bucket: z.string(),
+	accessKeyId: z.string(),
+	secretAccessKey: z.string(),
+	region: z.string().optional(),
+	endpoint: z.string().optional(),
+	accountId: z.string().optional(),
+	intervalMs: z.number().optional(),
+	maxRetries: z.number().optional(),
+	batchSize: z.number().optional(),
+	maxQueueSize: z.number().optional(),
+	maxFailedAgeMs: z.number().optional(),
+	backfillEnabled: z.boolean().optional(),
+})
+
+export const PromptUploadingSchema = z.object({
+	enabled: z.boolean().optional(),
+	type: z.union([z.literal("s3_access_keys"), z.literal("r2_access_keys"), z.literal("azure_access_keys")]).optional(),
+	s3AccessSettings: S3AccessKeySettingsSchema.optional(),
+	r2AccessSettings: S3AccessKeySettingsSchema.optional(),
+	azureAccessSettings: S3AccessKeySettingsSchema.optional(),
+})
+
+export const EnterpriseTelemetrySchema = z.object({
+	promptUploading: PromptUploadingSchema.optional(),
+})
+
+export const RemoteConfigSchema = z.object({
+	// The version of the remote config settings, e.g. v1
+	// This field is for internal use only, and won't be visible to the administrator in the UI.
+	version: z.string(),
+
+	// Provider specific settings
+	providerSettings: ProviderSettingsSchema.optional(),
+
+	// General settings not specific to any provider
+	telemetryEnabled: z.boolean().optional(),
+	kanbanEnabled: z.boolean().optional(),
+
+	// MCP settings
+	// Legacy field name. If this is false, locally configured MCP servers are blocked.
+	mcpMarketplaceEnabled: z.boolean().optional(),
+
+	// If this is configured, users only have access to these allowlisted local MCP servers.
+	allowedMCPServers: z.array(AllowedMCPServerSchema).optional(),
+
+	// A list of pre-configured remote MCP servers.
+	remoteMCPServers: z.array(RemoteMCPServerSchema).optional(),
+	// If this is true, users cannot use or configure MCP servers that are not remotely configured.
+	blockPersonalRemoteMCPServers: z.boolean().optional(),
+
+	// If the user is allowed to enable YOLO mode. Note this is different from the extension setting
+	// yoloModeEnabled, because we do not want to force YOLO enabled for the user.
+	yoloModeAllowed: z.boolean().optional(),
+
+	// OpenTelemetry configuration
+	openTelemetryEnabled: z.boolean().optional(),
+	openTelemetryMetricsExporter: z.string().optional(),
+	openTelemetryLogsExporter: z.string().optional(),
+	openTelemetryOtlpProtocol: z.string().optional(),
+	openTelemetryOtlpEndpoint: z.string().optional(),
+	openTelemetryOtlpHeaders: z.record(z.string(), z.string()).optional(),
+	openTelemetryOtlpMetricsProtocol: z.string().optional(),
+	openTelemetryOtlpMetricsEndpoint: z.string().optional(),
+	openTelemetryOtlpMetricsHeaders: z.record(z.string(), z.string()).optional(),
+	openTelemetryOtlpLogsProtocol: z.string().optional(),
+	openTelemetryOtlpLogsEndpoint: z.string().optional(),
+	openTelemetryOtlpLogsHeaders: z.record(z.string(), z.string()).optional(),
+	openTelemetryMetricExportInterval: z.number().optional(),
+	openTelemetryOtlpInsecure: z.boolean().optional(),
+	openTelemetryLogBatchSize: z.number().optional(),
+	openTelemetryLogBatchTimeout: z.number().optional(),
+	openTelemetryLogMaxQueueSize: z.number().optional(),
+
+	enterpriseTelemetry: EnterpriseTelemetrySchema.optional(),
+
+	// Rules & Workflows
+	globalRules: z.array(GlobalInstructionsFileSchema).optional(),
+	globalWorkflows: z.array(GlobalInstructionsFileSchema).optional(),
+	globalSkills: z.array(GlobalInstructionsFileSchema).optional(),
+})
+
+export const APIKeySchema = z.record(z.string(), z.string())
+
+// Type inference from schemas
+export type RemoteConfig = z.infer<typeof RemoteConfigSchema>
+type MCPServer = z.infer<typeof AllowedMCPServerSchema>
+export type RemoteMCPServer = z.infer<typeof RemoteMCPServerSchema>
+export type GlobalInstructionsFile = z.infer<typeof GlobalInstructionsFileSchema>
+
+type ProviderSettings = z.infer<typeof ProviderSettingsSchema>
+
+type OpenAiCompatible = z.infer<typeof OpenAiCompatibleSchema>
+type OpenAiCompatibleModel = z.infer<typeof OpenAiCompatibleModelSchema>
+
+type AwsBedrockSettings = z.infer<typeof AwsBedrockSettingsSchema>
+type AwsBedrockModel = z.infer<typeof AwsBedrockModelSchema>
+type AwsBedrockCustomModel = z.infer<typeof AwsBedrockCustomModelSchema>
+
+type VertexSettings = z.infer<typeof VertexSettingsSchema>
+type VertexModel = z.infer<typeof VertexModelSchema>
+
+type LiteLLMSettings = z.infer<typeof LiteLLMSchema>
+type LiteLLMModel = z.infer<typeof LiteLLMModelSchema>
+
+type AnthropicSettings = z.infer<typeof AnthropicSchema>
+type AnthropicModel = z.infer<typeof AnthropicModelSchema>
+
+export type APIKeySettings = z.infer<typeof APIKeySchema>
+
+type EnterpriseTelemetry = z.infer<typeof EnterpriseTelemetrySchema>
+type PromptUploading = z.infer<typeof PromptUploadingSchema>
+export type S3AccessKeySettings = z.infer<typeof S3AccessKeySettingsSchema>
diff --git a/apps/vscode/src/shared/services/Logger.ts b/apps/vscode/src/shared/services/Logger.ts
new file mode 100644
index 0000000..826fc1d
--- /dev/null
+++ b/apps/vscode/src/shared/services/Logger.ts
@@ -0,0 +1,63 @@
+/**
+ * Simple Logger utility for the extension's backend code.
+ */
+export class Logger {
+	private static isVerbose = process.env.IS_DEV === "true"
+
+	private static subscribers: Set<(msg: string) => void> = new Set()
+
+	private static output(msg: string): void {
+		for (const subscriber of Logger.subscribers) {
+			try {
+				subscriber(msg)
+			} catch {
+				// ignore errors from subscribers
+			}
+		}
+	}
+
+	/**
+	 * Register a callback to receive log output messages.
+	 */
+	static subscribe(outputFn: (msg: string) => void) {
+		Logger.subscribers.add(outputFn)
+	}
+
+	static error(message: string, ...args: any[]) {
+		Logger.#output("ERROR", message, undefined, args)
+	}
+
+	static warn(message: string, ...args: any[]) {
+		Logger.#output("WARN", message, undefined, args)
+	}
+
+	static log(message: string, ...args: any[]) {
+		Logger.#output("LOG", message, undefined, args)
+	}
+
+	static debug(message: string, ...args: any[]) {
+		Logger.#output("DEBUG", message, undefined, args)
+	}
+
+	static info(message: string, ...args: any[]) {
+		Logger.#output("INFO", message, undefined, args)
+	}
+
+	static trace(message: string, ...args: any[]) {
+		Logger.#output("TRACE", message, undefined, args)
+	}
+
+	static #output(level: string, message: string, error: Error | undefined, args: any[]) {
+		try {
+			let fullMessage = message
+			if (Logger.isVerbose && args.length > 0) {
+				fullMessage += ` ${args.map((arg) => JSON.stringify(arg)).join(" ")}`
+			}
+			const errorSuffix = error?.message ? ` ${error.message}` : ""
+			const ts = new Date().toISOString()
+			Logger.output(`${ts} ${level} ${fullMessage}${errorSuffix}`.trimEnd())
+		} catch {
+			// do nothing if Logger fails
+		}
+	}
+}
diff --git a/apps/vscode/src/shared/services/config/otel-config.ts b/apps/vscode/src/shared/services/config/otel-config.ts
new file mode 100644
index 0000000..d347ee6
--- /dev/null
+++ b/apps/vscode/src/shared/services/config/otel-config.ts
@@ -0,0 +1,231 @@
+import { parseKeyPairsIntoRecord } from "@opentelemetry/core"
+import { BUILD_CONSTANTS } from "@/shared/constants"
+import { RemoteConfigFields } from "@/shared/storage/state-keys"
+
+export interface OpenTelemetryClientConfig {
+	/**
+	 * Whether telemetry is enabled via OTEL_TELEMETRY_ENABLED
+	 */
+	enabled: boolean
+
+	/**
+	 * Metrics exporter type(s) - can be comma-separated for multiple exporters
+	 * Examples: "console", "otlp", "prometheus", "console,otlp"
+	 */
+	metricsExporter?: string
+
+	/**
+	 * Logs/events exporter type(s) - can be comma-separated for multiple exporters
+	 * Examples: "console", "otlp"
+	 */
+	logsExporter?: string
+
+	/**
+	 * Protocol for OTLP exporters: "grpc", "http/json", "http/protobuf"
+	 */
+	otlpProtocol?: string
+
+	/**
+	 * General OTLP endpoint (used if specific endpoints not set)
+	 */
+	otlpEndpoint?: string
+
+	/**
+	 * General OTLP headers
+	 */
+	otlpHeaders?: Record<string, string>
+
+	/**
+	 * Metrics-specific OTLP protocol
+	 */
+	otlpMetricsProtocol?: string
+
+	/**
+	 * Metrics-specific OTLP endpoint
+	 */
+	otlpMetricsEndpoint?: string
+
+	otlpMetricsHeaders?: Record<string, string>
+
+	/**
+	 * Logs-specific OTLP protocol
+	 */
+	otlpLogsProtocol?: string
+
+	/**
+	 * Logs-specific OTLP endpoint
+	 */
+	otlpLogsEndpoint?: string
+
+	otlpLogsHeaders?: Record<string, string>
+
+	/**
+	 * Metric export interval in milliseconds (for console exporter)
+	 */
+	metricExportInterval?: number
+
+	/**
+	 * Whether to use insecure (non-TLS) connections for gRPC OTLP exporters
+	 * Set to "true" for local development without TLS
+	 * Default: false (uses TLS)
+	 */
+	otlpInsecure?: boolean
+
+	/**
+	 * Maximum batch size for log records (default: 512)
+	 */
+	logBatchSize?: number
+
+	/**
+	 * Maximum time to wait before exporting logs in milliseconds (default: 5000)
+	 */
+	logBatchTimeout?: number
+
+	/**
+	 * Maximum queue size for log records (default: 2048)
+	 */
+	logMaxQueueSize?: number
+}
+
+/**
+ * Helper type for a valid OpenTelemetry client configuration.
+ * Must have telemetry enabled and at least one exporter configured.
+ */
+export interface OpenTelemetryClientValidConfig extends OpenTelemetryClientConfig {
+	enabled: true
+}
+
+const isTestEnv = process.env.E2E_TEST === "true" || process.env.IS_TEST === "true"
+
+export function remoteConfigToOtelConfig(settings: Partial<RemoteConfigFields>): OpenTelemetryClientConfig {
+	return {
+		enabled: !!settings.openTelemetryEnabled,
+		metricsExporter: settings.openTelemetryMetricsExporter,
+		logsExporter: settings.openTelemetryLogsExporter,
+		otlpProtocol: settings.openTelemetryOtlpProtocol,
+		otlpEndpoint: settings.openTelemetryOtlpEndpoint,
+		otlpHeaders: settings.openTelemetryOtlpHeaders,
+		metricExportInterval: settings.openTelemetryMetricExportInterval,
+		otlpInsecure: settings.openTelemetryOtlpInsecure,
+
+		otlpMetricsEndpoint: settings.openTelemetryOtlpMetricsEndpoint,
+		otlpMetricsProtocol: settings.openTelemetryOtlpMetricsProtocol,
+		otlpMetricsHeaders: settings.otlpMetricsHeaders,
+		otlpLogsEndpoint: settings.openTelemetryOtlpLogsEndpoint,
+		otlpLogsProtocol: settings.openTelemetryOtlpLogsProtocol,
+		otlpLogsHeaders: settings.otlpLogsHeaders,
+
+		logBatchSize: settings.openTelemetryLogBatchSize,
+		logBatchTimeout: settings.openTelemetryLogBatchTimeout,
+		logMaxQueueSize: settings.openTelemetryLogMaxQueueSize,
+	}
+}
+
+function getOtelConfig(): OpenTelemetryClientConfig {
+	return {
+		enabled: BUILD_CONSTANTS.OTEL_TELEMETRY_ENABLED === "1" || BUILD_CONSTANTS.OTEL_TELEMETRY_ENABLED === "true",
+		metricsExporter: BUILD_CONSTANTS.OTEL_METRICS_EXPORTER,
+		logsExporter: BUILD_CONSTANTS.OTEL_LOGS_EXPORTER,
+		otlpProtocol: BUILD_CONSTANTS.OTEL_EXPORTER_OTLP_PROTOCOL,
+		otlpEndpoint: BUILD_CONSTANTS.OTEL_EXPORTER_OTLP_ENDPOINT,
+		metricExportInterval: BUILD_CONSTANTS.OTEL_METRIC_EXPORT_INTERVAL
+			? Number.parseInt(BUILD_CONSTANTS.OTEL_METRIC_EXPORT_INTERVAL, 10)
+			: undefined,
+		otlpHeaders: BUILD_CONSTANTS.OTEL_EXPORTER_OTLP_HEADERS
+			? parseKeyPairsIntoRecord(BUILD_CONSTANTS.OTEL_EXPORTER_OTLP_HEADERS)
+			: undefined,
+	}
+}
+
+/**
+ * Gets or creates the OpenTelemetry configuration from environment variables.
+ * Configuration is cached after first access for performance.
+ *
+ * Configuration Sources:
+ * - **Production Build**: Environment variables injected by esbuild at build time
+ *   via .github/workflows/ext-vscode-publish-stable.yml
+ * - **Development**: Environment variables from .env file loaded by VSCode
+ *
+ * Supported Environment Variables:
+ * - CLINE_OTEL_TELEMETRY_ENABLED: "1" to enable OpenTelemetry (default: off)
+ * - CLINE_OTEL_METRICS_EXPORTER: Comma-separated list: "console", "otlp", "prometheus"
+ * - CLINE_OTEL_LOGS_EXPORTER: Comma-separated list: "console", "otlp"
+ * - CLINE_OTEL_EXPORTER_OTLP_PROTOCOL: "grpc", "http/json", or "http/protobuf"
+ * - CLINE_OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector endpoint (if not using specific endpoints)
+ * - CLINE_OTEL_EXPORTER_OTLP_HEADERS: Comma-separated key-value pairs (e.g., "key1=value1,key2=value2")
+ * - CLINE_OTEL_EXPORTER_OTLP_METRICS_PROTOCOL: Metrics-specific protocol override
+ * - CLINE_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: Metrics-specific endpoint override
+ * - CLINE_OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: Logs-specific protocol override
+ * - CLINE_OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: Logs-specific endpoint override
+ * - CLINE_OTEL_METRIC_EXPORT_INTERVAL: Milliseconds between metric exports (default: 60000)
+ * - CLINE_OTEL_EXPORTER_OTLP_INSECURE: "true" to disable TLS for gRPC (for local development)
+ * - CLINE_OTEL_LOG_BATCH_SIZE: Maximum batch size for log records (default: 512)
+ * - CLINE_OTEL_LOG_BATCH_TIMEOUT: Maximum time to wait before exporting logs in ms (default: 5000)
+ * - CLINE_OTEL_LOG_MAX_QUEUE_SIZE: Maximum queue size for log records (default: 2048)
+ *
+ * @private
+ * @see .env.example for development setup
+ * @see .github/workflows/ext-vscode-publish-stable.yml for production environment variable injection
+ */
+function getRuntimeOtelConfig(): OpenTelemetryClientConfig {
+	return {
+		enabled: process.env.CLINE_OTEL_TELEMETRY_ENABLED === "true",
+		metricsExporter: process.env.CLINE_OTEL_METRICS_EXPORTER,
+		logsExporter: process.env.CLINE_OTEL_LOGS_EXPORTER,
+		otlpProtocol: process.env.CLINE_OTEL_EXPORTER_OTLP_PROTOCOL,
+		otlpEndpoint: process.env.CLINE_OTEL_EXPORTER_OTLP_ENDPOINT,
+		otlpMetricsProtocol: process.env.CLINE_OTEL_EXPORTER_OTLP_METRICS_PROTOCOL,
+		otlpMetricsEndpoint: process.env.CLINE_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+		otlpLogsProtocol: process.env.CLINE_OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
+		otlpLogsEndpoint: process.env.CLINE_OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+		metricExportInterval: process.env.CLINE_OTEL_METRIC_EXPORT_INTERVAL
+			? Number.parseInt(process.env.CLINE_OTEL_METRIC_EXPORT_INTERVAL, 10)
+			: undefined,
+		otlpInsecure: process.env.CLINE_OTEL_EXPORTER_OTLP_INSECURE === "true",
+		logBatchSize: process.env.CLINE_OTEL_LOG_BATCH_SIZE
+			? Math.max(1, Number.parseInt(process.env.CLINE_OTEL_LOG_BATCH_SIZE, 10))
+			: undefined,
+		logBatchTimeout: process.env.CLINE_OTEL_LOG_BATCH_TIMEOUT
+			? Math.max(1, Number.parseInt(process.env.CLINE_OTEL_LOG_BATCH_TIMEOUT, 10))
+			: undefined,
+		logMaxQueueSize: process.env.CLINE_OTEL_LOG_MAX_QUEUE_SIZE
+			? Math.max(1, Number.parseInt(process.env.CLINE_OTEL_LOG_MAX_QUEUE_SIZE, 10))
+			: undefined,
+		otlpHeaders: process.env.CLINE_OTEL_EXPORTER_OTLP_HEADERS
+			? parseKeyPairsIntoRecord(process.env.CLINE_OTEL_EXPORTER_OTLP_HEADERS)
+			: undefined,
+	}
+}
+
+export function isOpenTelemetryConfigValid(config: OpenTelemetryClientConfig): config is OpenTelemetryClientValidConfig {
+	// Disable in test environment to enable mocking and stubbing
+	if (isTestEnv) {
+		return false
+	}
+
+	if (!config.enabled) {
+		return false
+	}
+
+	const hasOneExporterConfigured = !!(config.metricsExporter || config.logsExporter)
+	return hasOneExporterConfigured
+}
+
+/**
+ * Gets validated OpenTelemetry configuration if available.
+ * Returns null if configuration is invalid or disabled.
+ *
+ * Configuration does not change at runtime - requires VSCode reload to pick up new values.
+ *
+ * @returns Valid OpenTelemetry configuration or null if disabled/invalid
+ * @see .env.example for configuration options
+ */
+export function getValidOpenTelemetryConfig(): OpenTelemetryClientValidConfig | null {
+	const config = getOtelConfig()
+	return isOpenTelemetryConfigValid(config) ? config : null
+}
+
+export function getValidRuntimeOpenTelemetryConfig(): OpenTelemetryClientValidConfig | null {
+	const config = getRuntimeOtelConfig()
+	return isOpenTelemetryConfigValid(config) ? config : null
+}
diff --git a/apps/vscode/src/shared/services/config/posthog-config.ts b/apps/vscode/src/shared/services/config/posthog-config.ts
new file mode 100644
index 0000000..e80f80a
--- /dev/null
+++ b/apps/vscode/src/shared/services/config/posthog-config.ts
@@ -0,0 +1,61 @@
+import { BUILD_CONSTANTS } from "../../constants"
+
+export interface PostHogClientConfig {
+	/**
+	 * The main API key for PostHog telemetry service.
+	 */
+	apiKey?: string | undefined
+	/**
+	 * The API key for PostHog used only for error tracking service.
+	 */
+	errorTrackingApiKey?: string | undefined
+	enableErrorAutocapture?: boolean
+	host: string
+	uiHost: string
+}
+
+/**
+ * Helper type for a valid PostHog client configuration.
+ * Must contains api keys for both telemetry and error tracking.
+ */
+export interface PostHogClientValidConfig extends PostHogClientConfig {
+	apiKey: string
+	errorTrackingApiKey: string
+}
+
+/**
+ * NOTE: Ensure that dev environment is not used in production.
+ * process.env.CI will always be true in the CI environment, during both testing and publishing step,
+ * so it is not a reliable indicator of the environment.
+ */
+const useDevEnv = process.env.IS_DEV === "true" || process.env.CLINE_ENVIRONMENT === "local"
+
+/**
+ * PostHog configuration for Production Environment.
+ * NOTE: The production environment variables will be injected at build time in CI/CD pipeline.
+ * IMPORTANT: The secrets must be added to the GitHub Secrets and matched with the environment variables names
+ * defined in the .github/workflows/ext-vscode-publish-stable.yml workflow.
+ * NOTE: The development environment variables should be retrieved from 1password shared vault.
+ */
+export const posthogConfig: PostHogClientConfig = {
+	apiKey: BUILD_CONSTANTS.TELEMETRY_SERVICE_API_KEY,
+	errorTrackingApiKey: BUILD_CONSTANTS.ERROR_SERVICE_API_KEY,
+	host: "https://data.cline.bot",
+	uiHost: useDevEnv ? "https://us.i.posthog.com" : "https://us.posthog.com",
+	enableErrorAutocapture: BUILD_CONSTANTS.ENABLE_ERROR_AUTOCAPTURE === "true",
+}
+
+const isTestEnv = process.env.E2E_TEST === "true" || process.env.IS_TEST === "true"
+
+export function isPostHogConfigValid(config: PostHogClientConfig): config is PostHogClientValidConfig {
+	// Allow invalid config in test environment to enable mocking and stubbing
+	if (isTestEnv) {
+		return false
+	}
+	return (
+		typeof config.apiKey === "string" &&
+		typeof config.errorTrackingApiKey === "string" &&
+		typeof config.host === "string" &&
+		typeof config.uiHost === "string"
+	)
+}
diff --git a/apps/vscode/src/shared/services/feature-flags/feature-flags.ts b/apps/vscode/src/shared/services/feature-flags/feature-flags.ts
new file mode 100644
index 0000000..a8a4a78
--- /dev/null
+++ b/apps/vscode/src/shared/services/feature-flags/feature-flags.ts
@@ -0,0 +1,37 @@
+import type { FeatureFlagPayload } from "@/services/feature-flags/providers/IFeatureFlagsProvider"
+
+export enum FeatureFlag {
+	WORKTREES = "worktree-exp",
+	// Feature flag for showing the new onboarding flow or old welcome view.
+	ONBOARDING_MODELS = "onboarding_models",
+	// Feature flag for remote banner service
+	REMOTE_BANNERS = "remote-banners",
+	// Feature flag payload (milliseconds) controlling remote banner cache TTL
+	EXTENSION_REMOTE_BANNERS_TTL = "extension_remote_banners_ttl",
+	// Feature flag for DB-backed welcome banners (What's New modal)
+	// When off, hardcoded welcome items are shown instead
+	REMOTE_WELCOME_BANNERS = "remote-welcome-banners",
+	// Rollout flag for Cline provider model sourcing:
+	// off => OpenRouter model list, on => Cline endpoint model list.
+	EXTENSION_CLINE_MODELS_ENDPOINT = "extension_cline_models_endpoint",
+	// Enables ClinePass provider/model list exposure.
+	CLINE_PASS = "ext-cline-pass",
+	// Rollout flag for fetching recommended Cline models from the upstream endpoint.
+	CLINE_RECOMMENDED_MODELS_UPSTREAM = "cline_recommended_models_upstream",
+	// Use the websocket mode for OpenAI native Responses API format
+	OPENAI_RESPONSES_WEBSOCKET_MODE = "openai-responses-websocket-mode",
+}
+
+export const FeatureFlagDefaultValue: Partial<Record<FeatureFlag, FeatureFlagPayload>> = {
+	[FeatureFlag.WORKTREES]: false,
+	[FeatureFlag.ONBOARDING_MODELS]: process.env.E2E_TEST === "true" ? { models: {} } : undefined,
+	[FeatureFlag.REMOTE_BANNERS]: process.env.E2E_TEST === "true" || process.env.IS_DEV === "true",
+	[FeatureFlag.EXTENSION_REMOTE_BANNERS_TTL]: 24 * 60 * 60 * 1000,
+	[FeatureFlag.REMOTE_WELCOME_BANNERS]: process.env.E2E_TEST === "true" || process.env.IS_DEV === "true",
+	[FeatureFlag.EXTENSION_CLINE_MODELS_ENDPOINT]: false,
+	[FeatureFlag.CLINE_PASS]: false,
+	[FeatureFlag.CLINE_RECOMMENDED_MODELS_UPSTREAM]: false,
+	[FeatureFlag.OPENAI_RESPONSES_WEBSOCKET_MODE]: false,
+}
+
+export const FEATURE_FLAGS = Object.values(FeatureFlag)
diff --git a/apps/vscode/src/shared/services/worker/backfill.ts b/apps/vscode/src/shared/services/worker/backfill.ts
new file mode 100644
index 0000000..3c9ddd8
--- /dev/null
+++ b/apps/vscode/src/shared/services/worker/backfill.ts
@@ -0,0 +1,157 @@
+/**
+ * Backfill utility for syncing existing task data to S3/R2 storage.
+ *
+ * This module provides functions to backfill historic task data that was
+ * created before S3 storage was configured, or to re-sync data after
+ * configuration changes.
+ */
+
+import { GlobalFileNames, getSavedApiConversationHistory } from "@/core/storage/disk"
+import { Logger } from "@/shared/services/Logger"
+import { syncWorker } from "./sync"
+import { getTaskTimestamp } from "./utils"
+
+/**
+ * Result of a backfill operation for a single task.
+ */
+interface BackfillTaskResult {
+	taskId: string
+	success: boolean
+	filesQueued: string[]
+	error?: string
+}
+
+/**
+ * Result of a full backfill operation.
+ */
+export interface BackfillResult {
+	totalTasks: number
+	successCount: number
+	failCount: number
+	skippedCount: number
+	results: BackfillTaskResult[]
+}
+
+/**
+ * Options for backfill operations.
+ */
+export interface BackfillOptions {
+	/** Only backfill tasks newer than this timestamp */
+	sinceTimestamp?: number
+	/** Only backfill these specific task IDs */
+	taskIds?: string[]
+	/** Callback for progress updates */
+	onProgress?: (current: number, total: number, taskId: string) => void
+}
+
+/**
+ * List all task IDs in the tasks directory.
+ */
+async function listTaskIds(_before?: string, _after?: string): Promise<string[]> {
+	return []
+}
+
+/**
+ * Backfill a single task's data to S3/R2.
+ *
+ * @param taskId Task identifier
+ */
+async function backfillTask(taskId: string): Promise<BackfillTaskResult> {
+	const result: BackfillTaskResult = {
+		taskId,
+		success: false,
+		filesQueued: [],
+	}
+
+	try {
+		const queue = syncWorker().getSyncQueue()
+		if (!queue) {
+			result.error = "S3 storage not configured"
+			return result
+		}
+		const existingItem = queue.getItem(taskId, GlobalFileNames.apiConversationHistory)
+		if (existingItem?.status === "synced") {
+			// Already synced, skip
+			return result
+		}
+		try {
+			const data = await getSavedApiConversationHistory(taskId)
+			queue.enqueue(taskId, GlobalFileNames.apiConversationHistory, JSON.stringify(data))
+			result.filesQueued.push(taskId)
+		} catch (err) {
+			if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+				Logger.error(`Failed to queue ${taskId}:`, err)
+			}
+			// Skip missing files silently
+		}
+
+		result.success = result.filesQueued.length > 0
+	} catch (err) {
+		result.error = err instanceof Error ? err.message : String(err)
+	}
+
+	return result
+}
+
+/**
+ * Backfill all existing tasks to S3/R2 storage.
+ *
+ * @param options Backfill options
+ */
+export async function backfillTasks(options: BackfillOptions = {}): Promise<BackfillResult | undefined> {
+	const currentTime = Date.now() // Don't backfill tasks created during this operation as they are synced live
+	const { sinceTimestamp, taskIds: specificTaskIds, onProgress } = options
+
+	if (!syncWorker().getSyncQueue()) {
+		return undefined
+	}
+
+	// Get list of tasks to process
+	let taskIds: string[]
+	if (specificTaskIds && specificTaskIds.length > 0) {
+		taskIds = specificTaskIds
+	} else {
+		taskIds = await listTaskIds(currentTime.toString(), sinceTimestamp?.toString())
+	}
+
+	const result: BackfillResult = {
+		totalTasks: taskIds.length,
+		successCount: 0,
+		failCount: 0,
+		skippedCount: 0,
+		results: [],
+	}
+
+	for (let i = 0; i < taskIds.length; i++) {
+		const taskId = taskIds[i]
+
+		// Check timestamp filter using taskId (which is Date.now().toString())
+		if (sinceTimestamp) {
+			const taskTimestamp = getTaskTimestamp(taskId)
+
+			if (taskTimestamp && taskTimestamp < sinceTimestamp) {
+				result.skippedCount++
+				continue
+			}
+		}
+
+		// Report progress
+		if (onProgress) {
+			onProgress(i + 1, taskIds.length, taskId)
+		}
+
+		// Backfill the task
+		const taskResult = await backfillTask(taskId)
+		result.results.push(taskResult)
+
+		if (taskResult.success) {
+			result.successCount++
+		} else if (taskResult.error) {
+			result.failCount++
+		} else {
+			result.skippedCount++
+		}
+	}
+
+	return result
+}
diff --git a/apps/vscode/src/shared/services/worker/queue.ts b/apps/vscode/src/shared/services/worker/queue.ts
new file mode 100644
index 0000000..e77035d
--- /dev/null
+++ b/apps/vscode/src/shared/services/worker/queue.ts
@@ -0,0 +1,423 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { Logger } from "@/shared/services/Logger"
+import { SEVEN_DAYS_MS } from "./worker"
+
+/**
+ * Sync queue item status.
+ */
+type SyncQueueStatus = "pending" | "synced" | "failed"
+
+/**
+ * Represents an item in the sync queue.
+ */
+export interface SyncQueueItem {
+	/** Unique ID (taskId/key) */
+	id: string
+	/** Task ID this item belongs to */
+	taskId: string
+	/** File key within the task (e.g., "api_conversation_history.json") */
+	key: string
+	/** The data to sync */
+	data: string
+	/** Timestamp when the item was enqueued */
+	timestamp: number
+	/** Current sync status */
+	status: SyncQueueStatus
+	/** Number of retry attempts */
+	retryCount: number
+	/** Last error message if failed */
+	lastError: string | null
+}
+
+/**
+ * Queue data structure stored in JSON file.
+ */
+interface QueueData {
+	items: Record<string, SyncQueueItem>
+}
+
+/**
+ * A JSON file-backed queue for syncing task data to remote storage.
+ *
+ * Uses atomic file writes for:
+ * - Data persistence across restarts
+ * - No native module dependencies (VS Code compatible)
+ *
+ * Benefits:
+ * - Guaranteed delivery even if remote storage is temporarily down
+ * - Supports backfill of historic tasks
+ * - No blocking on remote storage operations
+ */
+export class SyncQueue {
+	private queuePath: string
+	private data: QueueData = { items: {} }
+	private static instance: SyncQueue | null = null
+	private writeTimeout: ReturnType<typeof setTimeout> | null = null
+	private isDirty = false
+
+	/**
+	 * Get the singleton instance.
+	 * @param queuePath Path to the JSON queue file
+	 */
+	static getInstance(queuePath: string): SyncQueue {
+		if (!SyncQueue.instance) {
+			SyncQueue.instance = new SyncQueue(queuePath)
+		}
+		return SyncQueue.instance
+	}
+
+	/**
+	 * Reset the singleton (for testing).
+	 */
+	static reset(): void {
+		if (SyncQueue.instance) {
+			SyncQueue.instance.close()
+			SyncQueue.instance = null
+		}
+	}
+
+	private constructor(queuePath: string) {
+		this.queuePath = queuePath
+
+		// Ensure directory exists
+		const dir = path.dirname(queuePath)
+		if (!fs.existsSync(dir)) {
+			fs.mkdirSync(dir, { recursive: true })
+		}
+
+		// Load existing queue data
+		this.load()
+	}
+
+	/**
+	 * Load queue data from disk.
+	 */
+	private load(): void {
+		try {
+			if (fs.existsSync(this.queuePath)) {
+				const content = fs.readFileSync(this.queuePath, "utf-8")
+				this.data = JSON.parse(content)
+			}
+		} catch (error) {
+			Logger.error("[SyncQueue] Failed to load queue data:", error)
+			this.data = { items: {} }
+		}
+	}
+
+	/**
+	 * Schedule a debounced write to disk.
+	 */
+	private scheduleWrite(): void {
+		this.isDirty = true
+		if (this.writeTimeout) {
+			return // Already scheduled
+		}
+		this.writeTimeout = setTimeout(() => {
+			this.flush()
+		}, 100) // Debounce writes by 100ms
+	}
+
+	/**
+	 * Immediately write queue data to disk.
+	 */
+	private flush(): void {
+		if (this.writeTimeout) {
+			clearTimeout(this.writeTimeout)
+			this.writeTimeout = null
+		}
+		if (!this.isDirty) {
+			return
+		}
+		try {
+			const tmpPath = `${this.queuePath}.tmp`
+			fs.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2), "utf-8")
+			fs.renameSync(tmpPath, this.queuePath)
+			this.isDirty = false
+		} catch (error) {
+			Logger.error("[SyncQueue] Failed to write queue data:", error)
+		}
+	}
+
+	/**
+	 * Close the queue and flush pending writes.
+	 */
+	close(): void {
+		this.flush()
+	}
+
+	/**
+	 * Queue data for sync. If an item with the same taskId/key exists,
+	 * it will be replaced (upsert behavior).
+	 *
+	 * @param taskId Task identifier
+	 * @param key File key (e.g., "api_conversation_history.json")
+	 * @param data Data to sync
+	 */
+	enqueue(taskId: string, key: string, data: string): void {
+		const id = `${taskId}/${key}`
+		this.data.items[id] = {
+			id,
+			taskId,
+			key,
+			data,
+			timestamp: Date.now(),
+			status: "pending",
+			retryCount: 0,
+			lastError: null,
+		}
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Get all pending items that need to be synced.
+	 */
+	getPending(): SyncQueueItem[] {
+		return Object.values(this.data.items)
+			.filter((item) => item.status === "pending")
+			.sort((a, b) => b.timestamp - a.timestamp)
+	}
+
+	/**
+	 * Get all items regardless of status.
+	 */
+	getAll(): SyncQueueItem[] {
+		return Object.values(this.data.items).sort((a, b) => b.timestamp - a.timestamp)
+	}
+
+	/**
+	 * Get failed items that may need manual intervention or retry.
+	 */
+	getFailed(): SyncQueueItem[] {
+		return Object.values(this.data.items)
+			.filter((item) => item.status === "failed")
+			.sort((a, b) => a.timestamp - b.timestamp)
+	}
+
+	/**
+	 * Get a specific item by taskId and key.
+	 */
+	getItem(taskId: string, key: string): SyncQueueItem | undefined {
+		const id = `${taskId}/${key}`
+		return this.data.items[id]
+	}
+
+	/**
+	 * Mark an item as successfully synced.
+	 *
+	 * @param taskId Task identifier
+	 * @param key File key
+	 * @param remove Whether to remove the item after marking synced (default: false)
+	 */
+	markSynced(taskId: string, key: string, remove = false): void {
+		const id = `${taskId}/${key}`
+		if (remove) {
+			delete this.data.items[id]
+		} else if (this.data.items[id]) {
+			this.data.items[id].status = "synced"
+			this.data.items[id].lastError = null
+		}
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Mark an item as failed with an error message.
+	 * Increments retry count for tracking.
+	 *
+	 * @param taskId Task identifier
+	 * @param key File key
+	 * @param error Error message
+	 */
+	markFailed(taskId: string, key: string, error: string): void {
+		const id = `${taskId}/${key}`
+		const item = this.data.items[id]
+		if (item) {
+			item.status = "failed"
+			item.lastError = error
+			item.retryCount++
+		}
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Reset a failed item back to pending for retry.
+	 *
+	 * @param taskId Task identifier
+	 * @param key File key
+	 */
+	resetToPending(taskId: string, key: string): void {
+		const id = `${taskId}/${key}`
+		const item = this.data.items[id]
+		if (item) {
+			item.status = "pending"
+		}
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Remove an item from the queue entirely.
+	 *
+	 * @param taskId Task identifier
+	 * @param key File key
+	 */
+	remove(taskId: string, key: string): void {
+		const id = `${taskId}/${key}`
+		delete this.data.items[id]
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Remove all items for a task.
+	 * Use this when a task is deleted.
+	 *
+	 * @param taskId Task identifier
+	 */
+	removeTask(taskId: string): void {
+		const keysToRemove = Object.keys(this.data.items).filter((id) => id.startsWith(`${taskId}/`))
+		for (const key of keysToRemove) {
+			delete this.data.items[key]
+		}
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Get statistics about the queue.
+	 */
+	getStats(): { pending: number; synced: number; failed: number; total: number } {
+		const items = Object.values(this.data.items)
+		return {
+			pending: items.filter((i) => i.status === "pending").length,
+			synced: items.filter((i) => i.status === "synced").length,
+			failed: items.filter((i) => i.status === "failed").length,
+			total: items.length,
+		}
+	}
+
+	/**
+	 * Clean up synced items older than the specified age.
+	 *
+	 * @param maxAgeMs Maximum age in milliseconds (default: 7 days)
+	 * @returns Number of items cleaned up
+	 */
+	cleanupOldSynced(maxAgeMs: number = SEVEN_DAYS_MS): number {
+		const cutoff = Date.now() - maxAgeMs
+		let count = 0
+		Object.entries(this.data.items).forEach(([key, item]) => {
+			if (item.status === "synced" && item.timestamp < cutoff) {
+				delete this.data.items[key]
+				count++
+			}
+		})
+		if (count > 0) {
+			this.scheduleWrite()
+		}
+		return count
+	}
+
+	/**
+	 * Clean up failed items that have exceeded max retries.
+	 * This prevents the queue from growing forever when blob storage is misconfigured.
+	 *
+	 * @param maxRetries Maximum retry count before eviction (default: 5)
+	 * @param maxAgeMs Maximum age for failed items in milliseconds (default: 7 days)
+	 * @returns Number of items cleaned up
+	 */
+	cleanupFailedItems(maxRetries = 5, maxAgeMs: number = SEVEN_DAYS_MS): number {
+		const cutoff = Date.now() - maxAgeMs
+		let count = 0
+		Object.entries(this.data.items).forEach(([key, item]) => {
+			if (item.status === "failed" && (item.retryCount >= maxRetries || item.timestamp < cutoff)) {
+				delete this.data.items[key]
+				count++
+			}
+		})
+		if (count > 0) {
+			this.scheduleWrite()
+		}
+		return count
+	}
+
+	/**
+	 * Enforce a maximum queue size by removing oldest items.
+	 * Prioritizes removing: synced > failed (exceeded retries) > failed > pending
+	 *
+	 * @param maxSize Maximum number of items to keep (default: 1000)
+	 * @returns Number of items evicted
+	 */
+	enforceMaxSize(maxSize = 1000): number {
+		const items = Object.entries(this.data.items)
+		if (items.length <= maxSize) {
+			return 0
+		}
+
+		const toEvict = items.length - maxSize
+
+		// Sort by eviction priority: synced first, then failed with high retry, then failed, then pending
+		// Within each category, oldest first
+		const sorted = items.sort(([, a], [, b]) => {
+			const priorityOf = (item: SyncQueueItem): number => {
+				if (item.status === "synced") {
+					return 0
+				}
+				if (item.status === "failed" && item.retryCount >= 5) {
+					return 1
+				}
+				if (item.status === "failed") {
+					return 2
+				}
+				return 3 // pending
+			}
+			const priorityDiff = priorityOf(a) - priorityOf(b)
+			if (priorityDiff !== 0) {
+				return priorityDiff
+			}
+			return a.timestamp - b.timestamp // oldest first within same priority
+		})
+
+		const keysToRemove = sorted.slice(0, toEvict).map(([key]) => key)
+
+		for (const key of keysToRemove) {
+			delete this.data.items[key]
+		}
+
+		if (keysToRemove.length > 0) {
+			this.scheduleWrite()
+			Logger.warn(`[SyncQueue] Evicted ${keysToRemove.length} items to enforce max size of ${maxSize}`)
+		}
+
+		return keysToRemove.length
+	}
+
+	/**
+	 * Bulk enqueue multiple items.
+	 * More efficient than calling enqueue() multiple times.
+	 *
+	 * @param items Array of items to enqueue
+	 */
+	enqueueBulk(items: Array<{ taskId: string; key: string; data: string }>): void {
+		const timestamp = Date.now()
+		for (const item of items) {
+			const id = `${item.taskId}/${item.key}`
+			this.data.items[id] = {
+				id,
+				taskId: item.taskId,
+				key: item.key,
+				data: item.data,
+				timestamp,
+				status: "pending",
+				retryCount: 0,
+				lastError: null,
+			}
+		}
+		this.scheduleWrite()
+	}
+
+	/**
+	 * Get pending items with a limit (for batch processing).
+	 *
+	 * @param limit Maximum number of items to return
+	 */
+	getPendingBatch(limit: number): SyncQueueItem[] {
+		return this.getPending().slice(0, limit)
+	}
+}
diff --git a/apps/vscode/src/shared/services/worker/sync.ts b/apps/vscode/src/shared/services/worker/sync.ts
new file mode 100644
index 0000000..ab851e6
--- /dev/null
+++ b/apps/vscode/src/shared/services/worker/sync.ts
@@ -0,0 +1,121 @@
+/**
+ * Sync module - provides queue-based syncing to S3/R2 storage.
+ *
+ * This module coordinates the SyncQueue and SyncWorker for robust
+ * data synchronization that doesn't block the main extension flow.
+ *
+ * Uses JSON file storage for:
+ * - Data persistence across restarts
+ * - No native module dependencies (VS Code compatible)
+ * - Atomic file writes for safety
+ */
+import * as path from "node:path"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import { blobStorage } from "../../storage/ClineBlobStorage"
+import { backfillTasks } from "./backfill"
+import { SyncQueue } from "./queue"
+import type { SyncWorkerOptions } from "./worker"
+import { disposeSyncWorker, initSyncWorker, SyncWorker } from "./worker"
+
+// Re-export types and functions
+let syncQueueInstance: SyncQueue | null = null
+
+/**
+ * Get the sync queue file path.
+ */
+function getSyncQueuePath(): string {
+	return path.join(HostProvider.get().globalStorageFsPath, "cache", "sync-queue.json")
+}
+
+/**
+ * Get the global SyncQueue instance.
+ * Returns null if S3 storage is not configured.
+ */
+function getSyncQueue(): SyncQueue | null {
+	if (!blobStorage.isReady()) {
+		return null
+	}
+
+	if (!syncQueueInstance) {
+		syncQueueInstance = SyncQueue.getInstance(getSyncQueuePath())
+	}
+
+	return syncQueueInstance
+}
+
+/**
+ * Initialize the sync system (queue + worker).
+ * Should be called during extension activation if S3 storage is configured.
+ *
+ * @param options Worker configuration options (includes blob store settings)
+ * @returns The SyncWorker instance, or null if S3 is not configured
+ */
+function init(options?: SyncWorkerOptions): SyncWorker | null {
+	if (!options?.userDistinctId) {
+		return null
+	}
+
+	// Initialize blob storage with the provided settings
+	blobStorage.init(options)
+	if (!blobStorage.isReady()) {
+		return null
+	}
+
+	const queue = getSyncQueue()
+	if (!queue) {
+		return null
+	}
+
+	const worker = initSyncWorker(queue, options)
+	worker.start()
+
+	if (options.backfillEnabled) {
+		backfillTasks().catch((err) => Logger.error("Backfill tasks failed:", err))
+	}
+
+	return worker
+}
+
+/**
+ * Dispose the sync system.
+ * Should be called during extension deactivation.
+ */
+async function dispose(): Promise<void> {
+	await disposeSyncWorker()
+	if (syncQueueInstance) {
+		syncQueueInstance.close()
+		syncQueueInstance = null
+	}
+	SyncQueue.reset()
+}
+
+/**
+ * Convenience function to enqueue data for sync.
+ * This is a fire-and-forget operation - errors are logged but not thrown.
+ *
+ * @param taskId Task identifier
+ * @param key File key (e.g., "api_conversation_history.json")
+ * @param data Data to sync
+ */
+function enqueue(taskId: string, key: string, data: string): void {
+	try {
+		const queue = getSyncQueue()
+		if (!queue || !data || !key) {
+			return
+		}
+
+		queue.enqueue(taskId, key, data)
+	} catch (err) {
+		Logger.error(`Failed to enqueue ${taskId}/${key} for sync:`, err)
+	}
+}
+
+export function syncWorker() {
+	return {
+		init,
+		dispose,
+		getSyncQueue,
+		enqueue,
+	}
+}
diff --git a/apps/vscode/src/shared/services/worker/utils.ts b/apps/vscode/src/shared/services/worker/utils.ts
new file mode 100644
index 0000000..58906c2
--- /dev/null
+++ b/apps/vscode/src/shared/services/worker/utils.ts
@@ -0,0 +1,8 @@
+/**
+ * Parse task timestamp from taskId.
+ * Task IDs are generated using Date.now().toString().
+ */
+export function getTaskTimestamp(taskId: string): number | undefined {
+	const timestamp = parseInt(taskId, 10)
+	return Number.isNaN(timestamp) ? undefined : timestamp
+}
diff --git a/apps/vscode/src/shared/services/worker/worker.ts b/apps/vscode/src/shared/services/worker/worker.ts
new file mode 100644
index 0000000..eefbf2f
--- /dev/null
+++ b/apps/vscode/src/shared/services/worker/worker.ts
@@ -0,0 +1,280 @@
+import { Logger } from "@/shared/services/Logger"
+import { BlobStoreSettings, blobStorage } from "../../storage/ClineBlobStorage"
+
+import { SyncQueue, SyncQueueItem } from "./queue"
+
+export const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000
+
+/**
+ * Configuration options for SyncWorker.
+ */
+export interface SyncWorkerOptions extends BlobStoreSettings {
+	userDistinctId: string
+}
+
+/**
+ * Safely parse an environment variable as an integer with a fallback default.
+ * Returns the fallback if the value is undefined, empty, or results in NaN.
+ */
+function parseIntEnv(value: string | undefined, fallback: number): number {
+	if (!value) {
+		return fallback
+	}
+	const parsed = parseInt(value, 10)
+	return Number.isNaN(parsed) ? fallback : parsed
+}
+
+/**
+ * Get blob store settings from environment variables.
+ * Used as a fallback when remote config is not available.
+ */
+export function getBlobStoreSettingsFromEnv(): BlobStoreSettings {
+	return {
+		adapterType: process?.env?.CLINE_STORAGE_ADAPTER || "unknown",
+		bucket: process?.env?.CLINE_STORAGE_BUCKET || "cline",
+		accessKeyId: process?.env?.CLINE_STORAGE_ACCESS_KEY_ID || "",
+		secretAccessKey: process?.env?.CLINE_STORAGE_SECRET_ACCESS_KEY || "",
+		region: process?.env?.CLINE_STORAGE_REGION,
+		endpoint: process?.env?.CLINE_STORAGE_ENDPOINT,
+		accountId: process?.env?.CLINE_STORAGE_ACCOUNT_ID,
+
+		intervalMs: parseIntEnv(process.env.CLINE_STORAGE_SYNC_INTERVAL_MS, 30000),
+		maxRetries: parseIntEnv(process.env.CLINE_STORAGE_SYNC_MAX_RETRIES, 5),
+		batchSize: parseIntEnv(process.env.CLINE_STORAGE_SYNC_BATCH_SIZE, 10),
+		maxQueueSize: parseIntEnv(process.env.CLINE_STORAGE_SYNC_MAX_QUEUE_SIZE, 1000),
+		maxFailedAgeMs: parseIntEnv(process.env.CLINE_STORAGE_SYNC_MAX_FAILED_AGE_MS, SEVEN_DAYS_MS),
+		backfillEnabled: process.env.CLINE_STORAGE_SYNC_BACKFILL_ENABLED === "true",
+	}
+}
+
+enum WorkerEvent {
+	WorkerSyncStarted = "sync_started",
+	WorkerSyncCompleted = "sync_completed",
+	WorkerItemSynced = "item_synced",
+	WorkerItemFailed = "item_failed",
+	WorkerStarted = "worker_started",
+	WorkerStopped = "worker_stopped",
+}
+
+/**
+ * Event types emitted by SyncWorker.
+ */
+export type SyncWorkerEvent =
+	| { type: WorkerEvent.WorkerSyncStarted; itemCount: number }
+	| { type: WorkerEvent.WorkerSyncCompleted; successCount: number; failCount: number }
+	| { type: WorkerEvent.WorkerItemSynced; item: SyncQueueItem }
+	| { type: WorkerEvent.WorkerItemFailed; item: SyncQueueItem; error: string }
+	| { type: WorkerEvent.WorkerStarted }
+	| { type: WorkerEvent.WorkerStopped }
+
+export type SyncWorkerEventListener = (event: SyncWorkerEvent) => void
+
+/**
+ * Background worker that processes the SyncQueue and uploads data to S3/R2.
+ *
+ * Features:
+ * - Periodic processing of pending items
+ * - Configurable retry logic
+ * - Event-based notifications for monitoring
+ * - Graceful shutdown support
+ * - Batch processing to avoid overwhelming the network
+ *
+ * Usage:
+ * ```typescript
+ * const queue = SyncQueue.getInstance(dbPath)
+ * const worker = new SyncWorker(queue)
+ * worker.start()
+ *
+ * // Later, when shutting down:
+ * await worker.stop()
+ * ```
+ */
+/** Internal type with all optional worker fields required */
+type ResolvedSyncWorkerOptions = SyncWorkerOptions &
+	Required<
+		Pick<BlobStoreSettings, "intervalMs" | "maxRetries" | "batchSize" | "maxQueueSize" | "maxFailedAgeMs" | "backfillEnabled">
+	>
+
+export class SyncWorker {
+	private interval: ReturnType<typeof setInterval> | null = null
+	private isProcessing: boolean = false
+	private options: ResolvedSyncWorkerOptions
+	private listeners: SyncWorkerEventListener[] = []
+
+	constructor(
+		private queue: SyncQueue,
+		options: SyncWorkerOptions,
+	) {
+		this.options = {
+			// Apply defaults for optional fields
+			intervalMs: options.intervalMs ?? 30000,
+			maxRetries: options.maxRetries ?? 5,
+			batchSize: options.batchSize ?? 10,
+			maxQueueSize: options.maxQueueSize ?? 1000,
+			maxFailedAgeMs: options.maxFailedAgeMs ?? SEVEN_DAYS_MS,
+			backfillEnabled: options.backfillEnabled ?? false,
+			// Spread provided options (required fields come from here)
+			...options,
+		}
+	}
+
+	/**
+	 * Subscribe to worker events.
+	 * @returns Unsubscribe function
+	 */
+	public onEvent(listener: SyncWorkerEventListener): () => void {
+		this.listeners.push(listener)
+		return () => {
+			const index = this.listeners.indexOf(listener)
+			if (index >= 0) {
+				this.listeners.splice(index, 1)
+			}
+		}
+	}
+
+	private emit(event: SyncWorkerEvent): void {
+		for (const listener of this.listeners) {
+			try {
+				listener(event)
+			} catch (err) {
+				Logger.error("SyncWorker event listener error:", err)
+			}
+		}
+	}
+
+	/**
+	 * Start the background worker.
+	 */
+	public start(): void {
+		if (this.interval) {
+			return // Already running
+		}
+
+		this.emit({ type: WorkerEvent.WorkerStarted })
+		this.interval = setInterval(() => this.processQueue(), this.options.intervalMs)
+
+		// Run immediately but don't await
+		this.processQueue().catch((err) => {
+			Logger.error("SyncWorker initial process error:", err)
+		})
+	}
+
+	/**
+	 * Stop the background worker.
+	 * @param waitForCurrent If true, waits for current processing to complete
+	 */
+	public async stop(waitForCurrent: boolean = true): Promise<void> {
+		if (this.interval) {
+			clearInterval(this.interval)
+			this.interval = null
+		}
+
+		if (waitForCurrent) {
+			// Wait for any in-progress processing to complete
+			while (this.isProcessing) {
+				await new Promise((resolve) => setTimeout(resolve, 100))
+			}
+		}
+
+		this.emit({ type: WorkerEvent.WorkerStopped })
+	}
+
+	/**
+	 * Check if the worker is:
+	 * - currently running
+	 * - currently processing items
+	 */
+	public getStatus() {
+		return { isRunning: this.interval !== null, isProcessing: this.isProcessing }
+	}
+
+	private async processQueue(): Promise<{ successCount: number; failCount: number }> {
+		if (this.isProcessing) {
+			return { successCount: 0, failCount: 0 }
+		}
+
+		this.isProcessing = true
+		let successCount = 0
+		let failCount = 0
+
+		try {
+			// Run cleanup to prevent unbounded queue growth
+			// This runs even if blob storage isn't ready, which is the main protection
+			// against misconfigured storage causing the queue to grow forever
+			this.queue.cleanupFailedItems(this.options.maxRetries, this.options.maxFailedAgeMs)
+			this.queue.enforceMaxSize(this.options.maxQueueSize)
+
+			if (!blobStorage.isReady()) {
+				// S3/R2 not configured, nothing more to do
+				return { successCount: 0, failCount: 0 }
+			}
+
+			// Get pending items
+			const batch = this.queue.getPendingBatch(this.options.batchSize)
+
+			if (batch.length === 0) {
+				return { successCount: 0, failCount: 0 }
+			}
+
+			this.emit({ type: WorkerEvent.WorkerSyncStarted, itemCount: batch.length })
+
+			for (const item of batch) {
+				const data = item.data
+				// Skip items that have exceeded max retries
+				if (!data || item.retryCount >= this.options.maxRetries) {
+					continue
+				}
+
+				try {
+					// Upload to blob store (S3/R2) bucket
+					// Example path: <bucketName>/tasks/<userDistinctId>/<taskId>/<key>
+					await blobStorage.store(`tasks/${this.options.userDistinctId}/${item.taskId}/${item.key}`, data)
+
+					// Mark as synced and remove from queue (data is in S3 now)
+					this.queue.markSynced(item.taskId, item.key, true)
+					successCount++
+					this.emit({ type: WorkerEvent.WorkerItemSynced, item })
+				} catch (err) {
+					const errorMsg = err instanceof Error ? err.message : String(err)
+					this.queue.markFailed(item.taskId, item.key, errorMsg)
+					failCount++
+					this.emit({ type: WorkerEvent.WorkerItemFailed, item, error: errorMsg })
+					Logger.error(`Failed to sync ${item.taskId}/${item.key}:`, err)
+				}
+			}
+
+			this.emit({ type: WorkerEvent.WorkerSyncCompleted, successCount, failCount })
+		} finally {
+			this.isProcessing = false
+		}
+
+		return { successCount, failCount }
+	}
+}
+
+// Singleton instance for the extension
+let workerInstance: SyncWorker | null = null
+
+/**
+ * Initialize the global SyncWorker instance.
+ * Should be called once during extension activation.
+ *
+ * @param queue The SyncQueue instance
+ * @param options Worker configuration options (required, includes blob store settings)
+ */
+export function initSyncWorker(queue: SyncQueue, options: SyncWorkerOptions): SyncWorker {
+	if (workerInstance) {
+		return workerInstance
+	}
+	workerInstance = new SyncWorker(queue, options)
+	return workerInstance
+}
+
+/**
+ * Stop and dispose the global SyncWorker instance.
+ * Should be called during extension deactivation.
+ */
+export async function disposeSyncWorker(): Promise<void> {
+	await workerInstance?.stop()
+	workerInstance = null
+}
diff --git a/apps/vscode/src/shared/skills.ts b/apps/vscode/src/shared/skills.ts
new file mode 100644
index 0000000..ebc4f5d
--- /dev/null
+++ b/apps/vscode/src/shared/skills.ts
@@ -0,0 +1,17 @@
+/**
+ * Skill metadata loaded at startup for discovery.
+ * Only name and description are parsed from frontmatter initially.
+ */
+export interface SkillMetadata {
+	name: string
+	description: string
+	path: string
+	source: "global" | "project"
+}
+
+/**
+ * Full skill content loaded on-demand when skill is activated.
+ */
+export interface SkillContent extends SkillMetadata {
+	instructions: string
+}
diff --git a/apps/vscode/src/shared/slashCommands.ts b/apps/vscode/src/shared/slashCommands.ts
new file mode 100644
index 0000000..ead931c
--- /dev/null
+++ b/apps/vscode/src/shared/slashCommands.ts
@@ -0,0 +1,42 @@
+export interface SlashCommand {
+	name: string
+	description?: string
+	section?: "default" | "custom" | "mcp"
+	cliCompatible?: boolean
+}
+
+export const BASE_SLASH_COMMANDS: SlashCommand[] = [
+	{
+		name: "newtask",
+		description: "Create a new task with context from the current task",
+		section: "default",
+		cliCompatible: true,
+	},
+	{
+		name: "deep-planning",
+		description: "Create a comprehensive implementation plan before coding",
+		section: "default",
+		cliCompatible: true,
+	},
+	{
+		name: "smol",
+		description: "Condenses your current context window",
+		section: "default",
+		cliCompatible: true,
+	},
+	{
+		name: "newrule",
+		description: "Create a new Cline rule based on your conversation",
+		section: "default",
+		cliCompatible: true,
+	},
+	{
+		name: "reportbug",
+		description: "Create a Github issue with Cline",
+		section: "default",
+		cliCompatible: true,
+	},
+]
+
+// VS Code-only slash commands
+export const VSCODE_ONLY_COMMANDS: SlashCommand[] = []
diff --git a/apps/vscode/src/shared/storage/ClineBlobStorage.ts b/apps/vscode/src/shared/storage/ClineBlobStorage.ts
new file mode 100644
index 0000000..5a11294
--- /dev/null
+++ b/apps/vscode/src/shared/storage/ClineBlobStorage.ts
@@ -0,0 +1,132 @@
+import { Logger } from "../services/Logger"
+import { getStorageAdapter, type StorageAdapter } from "./adapters"
+import { ClineStorage } from "./ClineStorage"
+import type { BlobStoreSettings } from "./types"
+
+export type { BlobStoreSettings } from "./types"
+
+/**
+ * S3/R2/Azure blob storage implementation of ClineStorage.
+ * Uses AWS S3, Cloudflare R2, or Azure Blob Storage as the backend storage.
+ */
+class ClineBlobStorage extends ClineStorage {
+	override name = "ClineBlobStorage"
+
+	private static store: ClineBlobStorage | null = null
+	static get instance(): ClineBlobStorage {
+		if (!ClineBlobStorage.store) {
+			ClineBlobStorage.store = new ClineBlobStorage()
+		}
+		return ClineBlobStorage.store
+	}
+
+	private adapter: StorageAdapter | undefined
+	private settings: BlobStoreSettings | undefined
+	private initialized = false
+
+	/**
+	 * Initialize the storage adapter with the given settings.
+	 * Can be called multiple times - will reinitialize if settings change.
+	 */
+	public init(settings?: BlobStoreSettings) {
+		if (!settings) {
+			return
+		}
+
+		// Check if settings have changed (compare key fields)
+		const settingsChanged =
+			!this.settings ||
+			this.settings.adapterType !== settings.adapterType ||
+			this.settings.bucket !== settings.bucket ||
+			this.settings.accessKeyId !== settings.accessKeyId ||
+			this.settings.endpoint !== settings.endpoint ||
+			this.settings.accountId !== settings.accountId
+
+		// Skip if already initialized with same settings
+		if (this.initialized && !settingsChanged) {
+			return
+		}
+
+		try {
+			if (!ClineBlobStorage.isConfigured(settings)) {
+				// Not configured - this is expected and not an error
+				return
+			}
+
+			const adapter = getStorageAdapter(settings)
+			if (adapter) {
+				this.adapter = adapter
+				this.settings = settings
+				this.initialized = true
+				Logger.log(`[ClineBlobStorage] Adapter created for ${settings.adapterType}`)
+			}
+		} catch (error) {
+			// Log but don't throw - allow startup to continue
+			Logger.error("[ClineBlobStorage] initialization failed:", error)
+		}
+	}
+
+	/**
+	 * Check if the storage is properly initialized and ready to use.
+	 */
+	public isReady(): boolean {
+		return this.initialized && this.adapter !== undefined
+	}
+
+	public static isConfigured(settings: BlobStoreSettings): boolean {
+		const adapter = settings.adapterType
+		if (adapter !== "s3" && adapter !== "r2" && adapter !== "azure") {
+			return false
+		}
+
+		const hasRequiredVars = !!settings.bucket && !!settings.accessKeyId && !!settings.secretAccessKey
+
+		if (adapter === "r2") {
+			return hasRequiredVars && !!(settings.accountId || settings.endpoint)
+		}
+
+		return hasRequiredVars
+	}
+
+	protected async _get(key: string): Promise<string | undefined> {
+		if (!this.isReady()) {
+			return undefined
+		}
+		try {
+			return await this.adapter!.read(key)
+		} catch {
+			// Silently return undefined on read errors
+			return undefined
+		}
+	}
+
+	protected async _store(key: string, value: string): Promise<void> {
+		if (!this.isReady()) {
+			// Silently fail if not configured - this is expected behavior
+			return
+		}
+		try {
+			await this.adapter!.write(key, value)
+		} catch (error) {
+			throw error
+		}
+	}
+
+	protected async _delete(key: string): Promise<void> {
+		if (!this.isReady()) {
+			// Silently fail if not configured - this is expected behavior
+			return
+		}
+		try {
+			await this.adapter!.remove(key)
+		} catch (error) {
+			throw error
+		}
+	}
+}
+
+/**
+ * Get the blob storage instance if S3/R2/Azure storage is configured.
+ * Returns null if not configured.
+ */
+export const blobStorage = ClineBlobStorage.instance
diff --git a/apps/vscode/src/shared/storage/ClineFileStorage.ts b/apps/vscode/src/shared/storage/ClineFileStorage.ts
new file mode 100644
index 0000000..11f7a9a
--- /dev/null
+++ b/apps/vscode/src/shared/storage/ClineFileStorage.ts
@@ -0,0 +1,120 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { Logger } from "../services/Logger"
+import { ClineSyncStorage } from "./ClineStorage"
+
+export interface ClineFileStorageOptions {
+	/**
+	 * File permissions mode (e.g., 0o600 for owner read/write only).
+	 * If not set, uses the system default.
+	 */
+	fileMode?: number
+}
+
+/**
+ * Synchronous file-backed JSON storage.
+ * Stores any JSON-serializable values with sync read and write.
+ * Used for VSCode Memento compatibility and CLI environments.
+ */
+export class ClineFileStorage<T = any> extends ClineSyncStorage<T> {
+	protected name: string
+	private data: Record<string, T>
+	private readonly fsPath: string
+	private readonly fileMode?: number
+
+	constructor(filePath: string, name = "ClineFileStorage", options?: ClineFileStorageOptions) {
+		super()
+		this.fsPath = filePath
+		this.name = name
+		this.fileMode = options?.fileMode
+		this.data = this.readFromDisk()
+	}
+
+	protected _get(key: string): T | undefined {
+		return this.data[key]
+	}
+
+	protected _set(key: string, value: T | undefined): void {
+		// Use setBatch for consistency - all writes go through one path
+		this.setBatch({ [key]: value })
+	}
+
+	protected _delete(key: string): void {
+		this.setBatch({ [key]: undefined })
+	}
+
+	/**
+	 * Set multiple keys in a single write operation.
+	 * More efficient than calling set() for each key individually,
+	 * since it only writes to disk once.
+	 */
+	public setBatch(entries: Record<string, T | undefined>): Thenable<void> {
+		const changedKeys: string[] = []
+		for (const [key, value] of Object.entries(entries)) {
+			if (value === undefined) {
+				if (key in this.data) {
+					delete this.data[key]
+					changedKeys.push(key)
+				}
+			} else {
+				this.data[key] = value
+				changedKeys.push(key)
+			}
+		}
+		if (changedKeys.length > 0) {
+			this.writeToDisk()
+			for (const key of changedKeys) {
+				this.fireChange(key)
+			}
+		}
+		return Promise.resolve()
+	}
+
+	protected _keys(): readonly string[] {
+		return Object.keys(this.data)
+	}
+
+	private readFromDisk(): Record<string, T> {
+		try {
+			if (fs.existsSync(this.fsPath)) {
+				return JSON.parse(fs.readFileSync(this.fsPath, "utf-8"))
+			}
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to read from ${this.fsPath}:`, error)
+		}
+		return {}
+	}
+
+	private writeToDisk(): void {
+		try {
+			const dir = path.dirname(this.fsPath)
+			fs.mkdirSync(dir, { recursive: true })
+			atomicWriteFileSync(this.fsPath, JSON.stringify(this.data, null, 2), this.fileMode)
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to write to ${this.fsPath}:`, error)
+		}
+	}
+}
+
+/**
+ * Synchronously, atomically write data to a file using temp file + rename pattern.
+ * Prefer core/storage's async atomicWriteFile to this.
+ */
+function atomicWriteFileSync(filePath: string, data: string, mode?: fs.Mode | undefined): void {
+	const tmpPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).substring(7)}.json`
+	try {
+		fs.writeFileSync(tmpPath, data, {
+			flag: "wx",
+			encoding: "utf-8",
+			mode,
+		})
+		// Rename temp file to target (atomic in most cases)
+		fs.renameSync(tmpPath, filePath)
+	} catch (error) {
+		// Clean up temp file if it exists
+		try {
+			fs.unlinkSync(tmpPath)
+		} catch {}
+		throw error
+	}
+}
diff --git a/apps/vscode/src/shared/storage/ClineStorage.ts b/apps/vscode/src/shared/storage/ClineStorage.ts
new file mode 100644
index 0000000..95b951b
--- /dev/null
+++ b/apps/vscode/src/shared/storage/ClineStorage.ts
@@ -0,0 +1,212 @@
+import { Logger } from "../services/Logger"
+
+interface ClineStorageChangeEvent {
+	readonly key: string
+}
+
+export type StorageEventListener = (event: ClineStorageChangeEvent) => Promise<void>
+
+// ============================================================================
+// Interfaces for VSCode compatibility (removes vscode import dependency)
+// ============================================================================
+
+/**
+ * Memento-compatible interface for sync key-value storage.
+ * VSCode's Memento and ClineSyncStorage both satisfy this interface.
+ */
+export interface ClineMemento {
+	get<T>(key: string): T | undefined
+	get<T>(key: string, defaultValue: T): T
+	update(key: string, value: any): Thenable<void>
+	keys(): readonly string[]
+	/**
+	 * Set multiple keys in a single operation.
+	 * More efficient than calling update() for each key individually.
+	 */
+	setBatch(entries: Record<string, any>): Thenable<void>
+}
+
+/**
+ * An abstract storage class that provides a template for storage operations.
+ * Subclasses must implement the protected abstract methods to define their storage logic.
+ * The public methods (get, store, delete) are final and cannot be overridden.
+ */
+export abstract class ClineStorage {
+	/**
+	 * The name of the storage, used for logging purposes.
+	 */
+	protected name = "ClineStorage"
+	/**
+	 * List of subscribers to storage change events.
+	 */
+	private readonly subscribers: Array<StorageEventListener> = []
+
+	/**
+	 * Subscribe to storage change events.
+	 */
+	public onDidChange(callback: StorageEventListener): () => void {
+		this.subscribers.push(callback)
+		return () => {
+			const callbackIndex = this.subscribers.indexOf(callback)
+			if (callbackIndex >= 0) {
+				this.subscribers.splice(callbackIndex, 1)
+			}
+		}
+	}
+
+	/**
+	 * Get a value from storage. This method is final and cannot be overridden.
+	 * Subclasses should implement _get() to define their storage retrieval logic.
+	 */
+	public async get(key: string): Promise<string | undefined> {
+		try {
+			return await this._get(key)
+		} catch {
+			return undefined
+		}
+	}
+
+	async _dangerousStore(key: string, value: string): Promise<void> {
+		await this._store(key, value)
+	}
+
+	/**
+	 * Store a value in storage. This method is final and cannot be overridden.
+	 * Subclasses should implement _store() to define their storage logic.
+	 * This method automatically fires change events after storing.
+	 */
+	public async store(key: string, value: string): Promise<void> {
+		try {
+			await this._dangerousStore(key, value)
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to store '${key}':`, error)
+		}
+	}
+
+	/**
+	 * Delete a value from storage. This method is final and cannot be overridden.
+	 * Subclasses should implement _delete() to define their deletion logic.
+	 * This method automatically fires change events after deletion.
+	 */
+	public async delete(key: string): Promise<void> {
+		try {
+			await this._delete(key)
+		} catch {
+			// Silently fail on delete errors
+		}
+	}
+
+	/**
+	 * Abstract method that subclasses must implement to retrieve values from their storage.
+	 */
+	protected abstract _get(key: string): Promise<string | undefined>
+
+	/**
+	 * Abstract method that subclasses must implement to store values in their storage.
+	 */
+	protected abstract _store(key: string, value: string): Promise<void>
+
+	/**
+	 * Abstract method that subclasses must implement to delete values from their storage.
+	 */
+	protected abstract _delete(key: string): Promise<void>
+}
+
+// ============================================================================
+// Sync Storage - for environments requiring synchronous access (e.g., CLI)
+// ============================================================================
+
+/**
+ * Abstract base class for synchronous JSON storage.
+ * Unlike ClineStorage (string key-value, async), this stores any JSON-serializable
+ * values and provides synchronous access - required for VSCode Memento compatibility.
+ */
+
+export type SyncStorageEventListener = (event: ClineStorageChangeEvent) => void
+
+export abstract class ClineSyncStorage<T = any> {
+	protected abstract name: string
+
+	/**
+	 * List of subscribers to storage change events.
+	 */
+	private readonly changeSubscribers: Array<SyncStorageEventListener> = []
+
+	/**
+	 * Subscribe to storage change events. Returns an unsubscribe function.
+	 */
+	public onDidChange(callback: SyncStorageEventListener): () => void {
+		this.changeSubscribers.push(callback)
+		return () => {
+			const idx = this.changeSubscribers.indexOf(callback)
+			if (idx >= 0) {
+				this.changeSubscribers.splice(idx, 1)
+			}
+		}
+	}
+
+	/**
+	 * Notify all subscribers of a key change.
+	 */
+	protected fireChange(key: string): void {
+		for (const subscriber of this.changeSubscribers) {
+			try {
+				subscriber({ key })
+			} catch (error) {
+				Logger.error(`[${this.name}] change subscriber error for '${key}':`, error)
+			}
+		}
+	}
+
+	public get<V = T>(key: string): V | undefined
+	public get<V = T>(key: string, defaultValue: V): V
+	public get<V = T>(key: string, defaultValue?: V): V | undefined {
+		try {
+			const value = this._get(key) as V | undefined
+			return value !== undefined ? value : defaultValue
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to get '${key}':`, error)
+			return defaultValue
+		}
+	}
+
+	/**
+	 * Memento-compatible update method. Calls set() internally.
+	 */
+	public update(key: string, value: any): Thenable<void> {
+		this.set(key, value)
+		return Promise.resolve()
+	}
+
+	public set(key: string, value: T | undefined): void {
+		try {
+			this._set(key, value)
+			this.fireChange(key)
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to set '${key}':`, error)
+		}
+	}
+
+	public delete(key: string): void {
+		try {
+			this._delete(key)
+			this.fireChange(key)
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to delete '${key}':`, error)
+		}
+	}
+
+	public keys(): readonly string[] {
+		try {
+			return this._keys()
+		} catch (error) {
+			Logger.error(`[${this.name}] failed to get keys:`, error)
+			return []
+		}
+	}
+
+	protected abstract _get(key: string): T | undefined
+	protected abstract _set(key: string, value: T | undefined): void
+	protected abstract _delete(key: string): void
+	protected abstract _keys(): readonly string[]
+}
diff --git a/apps/vscode/src/shared/storage/__tests__/provider-keys.test.ts b/apps/vscode/src/shared/storage/__tests__/provider-keys.test.ts
new file mode 100644
index 0000000..b8eef88
--- /dev/null
+++ b/apps/vscode/src/shared/storage/__tests__/provider-keys.test.ts
@@ -0,0 +1,54 @@
+import { describe, it } from "bun:test"
+import { getProviderCollectionSync } from "@cline/llms"
+import { expect } from "chai"
+import { getProviderDefaultModelId, getProviderModelIdKey } from "../provider-keys"
+
+describe("Provider key mapping", () => {
+	it("returns the SDK-declared default for a static-list provider", () => {
+		// Moonshot is a static-list provider with no NON_SDK_PROVIDER_DEFAULTS
+		// override, so getProviderDefaultModelId delegates to the SDK.
+		const expectedDefault = getProviderCollectionSync("moonshot")?.provider.defaultModelId ?? ""
+		expect(getProviderDefaultModelId("moonshot")).to.equal(expectedDefault)
+	})
+
+	it("returns the openrouter default for the openrouter-routed providers", () => {
+		// Dynamic providers that route through openrouter share its default.
+		const openrouterDefault = getProviderDefaultModelId("openrouter")
+		expect(openrouterDefault).to.be.a("string")
+		expect(getProviderDefaultModelId("cline")).to.equal(openrouterDefault)
+		expect(getProviderDefaultModelId("together")).to.equal(openrouterDefault)
+	})
+
+	it("returns an empty string for local-only providers", () => {
+		expect(getProviderDefaultModelId("ollama")).to.equal("")
+		expect(getProviderDefaultModelId("lmstudio")).to.equal("")
+		expect(getProviderDefaultModelId("hicap")).to.equal("")
+	})
+
+	it("uses generic model key for Moonshot", () => {
+		expect(getProviderModelIdKey("moonshot", "act")).to.equal("actModeApiModelId")
+		expect(getProviderModelIdKey("moonshot", "plan")).to.equal("planModeApiModelId")
+	})
+
+	it("keeps provider-specific model key behavior for OpenRouter", () => {
+		expect(getProviderModelIdKey("openrouter", "act")).to.equal("actModeOpenRouterModelId")
+		expect(getProviderModelIdKey("openrouter", "plan")).to.equal("planModeOpenRouterModelId")
+	})
+
+	it("uses provider-specific model key behavior for Cline", () => {
+		expect(getProviderModelIdKey("cline", "act")).to.equal("actModeClineModelId")
+		expect(getProviderModelIdKey("cline", "plan")).to.equal("planModeClineModelId")
+	})
+
+	it("uses separate model keys for ClinePass", () => {
+		expect(getProviderModelIdKey("cline-pass", "act")).to.equal("actModeClinePassModelId")
+		expect(getProviderModelIdKey("cline-pass", "plan")).to.equal("planModeClinePassModelId")
+	})
+
+	it("uses the SDK-declared default for Nous Research through SDK-boundary casing", () => {
+		const expectedDefault = getProviderCollectionSync("nousResearch")?.provider.defaultModelId ?? ""
+		expect(getProviderDefaultModelId("nousResearch")).to.equal(expectedDefault)
+		expect(getProviderDefaultModelId("nousresearch")).to.equal(expectedDefault)
+		expect(expectedDefault).not.to.equal("")
+	})
+})
diff --git a/apps/vscode/src/shared/storage/__tests__/state-keys.test.ts b/apps/vscode/src/shared/storage/__tests__/state-keys.test.ts
new file mode 100644
index 0000000..5f763b8
--- /dev/null
+++ b/apps/vscode/src/shared/storage/__tests__/state-keys.test.ts
@@ -0,0 +1,471 @@
+/**
+ * State Keys Type Safety Tests
+ *
+ * This test suite validates the type safety guarantees of the state-keys module,
+ * which uses a single-source-of-truth pattern where types are auto-generated from
+ * field definition objects.
+ *
+ * ## Type Safety Model
+ *
+ * The state-keys module generates TypeScript types from runtime objects using:
+ * 1. Field definition objects with `default` values (e.g., `{ default: true as boolean }`)
+ * 2. `satisfies FieldDefinitions` constraint to enforce structure
+ * 3. `BuildInterface<T>` mapped type to extract types from `default` values
+ *
+ * ## Known Limitations (What These Tests Catch)
+ *
+ * The `as` type assertions on default values are TRUSTED by TypeScript. This means:
+ * - `{ default: "foo" as number }` would compile but be wrong at runtime
+ * - `{ default: undefined as string }` compiles but `string` doesn't include `undefined`
+ *
+ * These tests provide runtime validation to catch such mismatches that TypeScript cannot.
+ *
+ * ## What These Tests Validate
+ *
+ * 1. **Type-Value Consistency**: Default values match their declared types at runtime
+ * 2. **Key Synchronization**: Generated key arrays match the source objects
+ * 3. **Type Guard Correctness**: `isGlobalStateKey`, `isSettingsKey`, etc. work correctly
+ * 4. **Default Value Retrieval**: `getDefaultValue` returns correct values
+ * 5. **Transform Functions**: Transforms produce values of the correct type
+ *
+ * ## Running Tests
+ *
+ * ```bash
+ * bun run test:unit -- --grep "State Keys"
+ * ```
+ */
+
+import { describe, it } from "bun:test"
+import { expect } from "chai"
+
+import {
+	applyTransform,
+	GLOBAL_STATE_DEFAULTS,
+	type GlobalState,
+	GlobalStateAndSettingKeys,
+	type GlobalStateAndSettings,
+	type GlobalStateAndSettingsKey,
+	type GlobalStateKey,
+	getDefaultValue,
+	hasTransform,
+	isAsyncProperty,
+	isComputedProperty,
+	isGlobalStateKey,
+	isLocalStateKey,
+	isSecretKey,
+	isSettingsKey,
+	type LocalState,
+	type LocalStateKey,
+	LocalStateKeys,
+	SETTINGS_DEFAULTS,
+	SETTINGS_TRANSFORMS,
+	type SecretKey,
+	SecretKeys,
+	type Settings,
+	type SettingsKey,
+	SettingsKeys,
+} from "../state-keys"
+
+// ============================================================================
+// Test Helpers
+// ============================================================================
+
+/**
+ * Validates that a value matches the expected TypeScript type at runtime.
+ * This catches cases where `as` assertions mask type mismatches.
+ */
+function assertTypeMatch(value: unknown, expectedType: string, key: string): void {
+	const actualType = value === null ? "null" : Array.isArray(value) ? "array" : typeof value
+
+	if (expectedType === "array") {
+		expect(Array.isArray(value), `${key}: expected array, got ${actualType}`).to.be.true
+	} else if (expectedType === "object") {
+		expect(actualType, `${key}: expected object, got ${actualType}`).to.equal("object")
+		expect(value, `${key}: expected object, got null`).to.not.be.null
+		expect(Array.isArray(value), `${key}: expected object, got array`).to.be.false
+	} else if (expectedType === "undefined") {
+		expect(value, `${key}: expected undefined, got ${actualType}`).to.be.undefined
+	} else {
+		expect(actualType, `${key}: expected ${expectedType}, got ${actualType}`).to.equal(expectedType)
+	}
+}
+
+/**
+ * Infers the expected runtime type from a default value.
+ * Used to validate that default values are consistent with their purpose.
+ */
+function inferExpectedType(value: unknown): string {
+	if (value === undefined) {
+		return "undefined"
+	}
+	if (value === null) {
+		return "null"
+	}
+	if (Array.isArray(value)) {
+		return "array"
+	}
+	return typeof value
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe("State Keys Type Safety", () => {
+	describe("Type-Value Consistency", () => {
+		/**
+		 * These tests validate that default values match their declared types.
+		 * This catches mistakes like `{ default: "string" as number }` which
+		 * TypeScript would accept but would cause runtime issues.
+		 */
+
+		it("should have GlobalState defaults with correct runtime types", () => {
+			const defaults = GLOBAL_STATE_DEFAULTS as Record<string, unknown>
+
+			// Validate each default value has a sensible runtime type
+			for (const [key, value] of Object.entries(defaults)) {
+				const type = inferExpectedType(value)
+				// Re-validate to ensure consistency
+				assertTypeMatch(value, type, `GLOBAL_STATE_DEFAULTS.${key}`)
+			}
+		})
+
+		it("should have Settings defaults with correct runtime types", () => {
+			const defaults = SETTINGS_DEFAULTS as Record<string, unknown>
+
+			for (const [key, value] of Object.entries(defaults)) {
+				const type = inferExpectedType(value)
+				assertTypeMatch(value, type, `SETTINGS_DEFAULTS.${key}`)
+			}
+		})
+
+		it("should not have undefined defaults masquerading as non-optional types", () => {
+			// This test catches the pattern: { default: undefined as SomeType }
+			// where SomeType doesn't include undefined
+			const allDefaults = { ...GLOBAL_STATE_DEFAULTS, ...SETTINGS_DEFAULTS } as Record<string, unknown>
+
+			const undefinedKeys = Object.entries(allDefaults)
+				.filter(([_, value]) => value === undefined)
+				.map(([key]) => key)
+
+			// These keys have undefined defaults, which is valid only if their
+			// declared type includes `| undefined`. This test documents which
+			// keys are expected to have undefined defaults.
+			expect(undefinedKeys).to.be.an("array")
+			// If a key unexpectedly becomes undefined, this test will catch it
+		})
+
+		it("should have array defaults that are actually arrays", () => {
+			const allDefaults = { ...GLOBAL_STATE_DEFAULTS, ...SETTINGS_DEFAULTS } as Record<string, unknown>
+
+			for (const [key, value] of Object.entries(allDefaults)) {
+				if (Array.isArray(value)) {
+					// Verify it's a proper array, not an array-like object
+					expect(value, `${key} should be a true array`).to.be.instanceOf(Array)
+				}
+			}
+		})
+
+		it("should have object defaults that are plain objects", () => {
+			const allDefaults = { ...GLOBAL_STATE_DEFAULTS, ...SETTINGS_DEFAULTS } as Record<string, unknown>
+
+			for (const [key, value] of Object.entries(allDefaults)) {
+				if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+					// Verify it's a plain object
+					expect(Object.getPrototypeOf(value), `${key} should be a plain object`).to.equal(Object.prototype)
+				}
+			}
+		})
+	})
+
+	describe("Key Array Synchronization", () => {
+		/**
+		 * These tests ensure the generated key arrays stay in sync with
+		 * their source objects. A mismatch could cause runtime errors.
+		 */
+
+		it("should have SettingsKeys match SETTINGS_DEFAULTS keys", () => {
+			const defaultKeys = Object.keys(SETTINGS_DEFAULTS)
+			const exportedKeys = new Set<string>(SettingsKeys)
+
+			// Every key in defaults should be in the exported array
+			for (const key of defaultKeys) {
+				expect(exportedKeys.has(key), `SettingsKeys missing key: ${key}`).to.be.true
+			}
+		})
+
+		it("should have GlobalStateAndSettingKeys be a superset of SettingsKeys", () => {
+			const combinedSet = new Set<string>(GlobalStateAndSettingKeys)
+
+			for (const key of SettingsKeys) {
+				expect(combinedSet.has(key), `GlobalStateAndSettingKeys missing settings key: ${key}`).to.be.true
+			}
+		})
+
+		it("should have no duplicate keys in exported arrays", () => {
+			expect(new Set(SettingsKeys).size, "SettingsKeys has duplicates").to.equal(SettingsKeys.length)
+			expect(new Set(SecretKeys).size, "SecretKeys has duplicates").to.equal(SecretKeys.length)
+			expect(new Set(LocalStateKeys).size, "LocalStateKeys has duplicates").to.equal(LocalStateKeys.length)
+			expect(new Set(GlobalStateAndSettingKeys).size, "GlobalStateAndSettingKeys has duplicates").to.equal(
+				GlobalStateAndSettingKeys.length,
+			)
+		})
+
+		it("should have SecretKeys as strings", () => {
+			for (const key of SecretKeys) {
+				expect(typeof key, `SecretKey ${key} should be string`).to.equal("string")
+				expect(key.length, `SecretKey should not be empty`).to.be.greaterThan(0)
+			}
+		})
+	})
+
+	describe("Type Guard Functions", () => {
+		/**
+		 * Type guards narrow `string` to specific key types.
+		 * These tests ensure they correctly identify valid keys.
+		 */
+
+		it("should correctly identify GlobalState keys", () => {
+			// Known GlobalState keys from the defaults
+			const knownGlobalStateKeys = Object.keys(GLOBAL_STATE_DEFAULTS)
+
+			for (const key of knownGlobalStateKeys) {
+				expect(isGlobalStateKey(key), `${key} should be a GlobalStateKey`).to.be.true
+			}
+
+			// Non-existent keys should return false
+			expect(isGlobalStateKey("nonExistentKey123")).to.be.false
+			expect(isGlobalStateKey("")).to.be.false
+		})
+
+		it("should correctly identify Settings keys", () => {
+			for (const key of SettingsKeys) {
+				expect(isSettingsKey(key), `${key} should be a SettingsKey`).to.be.true
+			}
+
+			expect(isSettingsKey("nonExistentKey123")).to.be.false
+		})
+
+		it("should correctly identify Secret keys", () => {
+			// Sample known secret keys
+			const knownSecretKeys = ["apiKey", "openRouterApiKey", "awsAccessKey"]
+
+			for (const key of knownSecretKeys) {
+				expect(isSecretKey(key), `${key} should be a SecretKey`).to.be.true
+			}
+
+			expect(isSecretKey("notASecretKey")).to.be.false
+		})
+
+		it("should correctly identify LocalState keys", () => {
+			for (const key of LocalStateKeys) {
+				expect(isLocalStateKey(key), `${key} should be a LocalStateKey`).to.be.true
+			}
+
+			expect(isLocalStateKey("notALocalStateKey")).to.be.false
+		})
+
+		it("should have mutually exclusive key categories where expected", () => {
+			// Secret keys should not overlap with settings keys
+			for (const secretKey of SecretKeys) {
+				// Most secret keys should not be in settings (they're stored separately)
+				// This is a sanity check, not a strict requirement
+				if (isSettingsKey(secretKey)) {
+					// If there is overlap, document it
+					console.log(`Note: ${secretKey} is both a SecretKey and SettingsKey`)
+				}
+			}
+		})
+	})
+
+	describe("Default Value Retrieval", () => {
+		/**
+		 * Tests for the getDefaultValue utility function.
+		 */
+
+		it("should return correct default values for known keys", () => {
+			// Test a few known defaults
+			const testCases: Array<{ key: GlobalStateAndSettingsKey; expectedType: string }> = [
+				{ key: "autoApprovalSettings", expectedType: "object" },
+				{ key: "browserSettings", expectedType: "object" },
+				{ key: "shellIntegrationTimeout", expectedType: "number" },
+				{ key: "preferredLanguage", expectedType: "string" },
+				{ key: "yoloModeToggled", expectedType: "boolean" },
+				{ key: "autoApproveAllToggled", expectedType: "boolean" },
+			]
+
+			for (const { key, expectedType } of testCases) {
+				const value = getDefaultValue(key)
+				if (value !== undefined) {
+					assertTypeMatch(value, expectedType, `getDefaultValue(${key})`)
+				}
+			}
+		})
+
+		it("should return undefined for keys without defaults", () => {
+			// Keys with `undefined` as default should return undefined
+			const keysWithUndefinedDefaults = GlobalStateAndSettingKeys.filter((key) => {
+				const value = getDefaultValue(key)
+				return value === undefined
+			})
+
+			// This is expected behavior - document which keys have undefined defaults
+			expect(keysWithUndefinedDefaults).to.be.an("array")
+		})
+	})
+
+	describe("Transform Functions", () => {
+		/**
+		 * Tests for transform functions that modify values before storage.
+		 */
+
+		it("should have transforms return the same type as input", () => {
+			// Get keys that have transforms
+			const keysWithTransforms = Object.keys(SETTINGS_TRANSFORMS)
+
+			expect(keysWithTransforms.length, "Should have at least one transform").to.be.greaterThan(0)
+
+			for (const key of keysWithTransforms) {
+				expect(hasTransform(key), `hasTransform(${key}) should be true`).to.be.true
+			}
+		})
+
+		it("should correctly identify keys without transforms", () => {
+			expect(hasTransform("nonExistentKey")).to.be.false
+			expect(hasTransform("")).to.be.false
+		})
+
+		it("should apply transforms without throwing", () => {
+			const keysWithTransforms = Object.keys(SETTINGS_TRANSFORMS)
+
+			for (const key of keysWithTransforms) {
+				// Transform should handle various inputs gracefully
+				expect(() => applyTransform(key, {})).to.not.throw()
+				expect(() => applyTransform(key, undefined)).to.not.throw()
+				expect(() => applyTransform(key, null)).to.not.throw()
+			}
+		})
+
+		it("should pass through values for keys without transforms", () => {
+			const testValue = { test: "value" }
+			const result = applyTransform("keyWithoutTransform", testValue)
+
+			expect(result).to.equal(testValue)
+		})
+
+		it("should merge defaults in browserSettings transform", () => {
+			if (hasTransform("browserSettings")) {
+				const partial = { viewport: { width: 800, height: 600 } }
+				const result = applyTransform("browserSettings", partial)
+
+				expect(result).to.be.an("object")
+				expect(result.viewport).to.deep.equal({ width: 800, height: 600 })
+			}
+		})
+	})
+
+	describe("Metadata Properties", () => {
+		/**
+		 * Tests for isAsync and isComputed metadata flags.
+		 */
+
+		it("should correctly identify async properties", () => {
+			// taskHistory is known to be async
+			expect(isAsyncProperty("taskHistory")).to.be.true
+			expect(isAsyncProperty("preferredLanguage")).to.be.false
+			expect(isAsyncProperty("nonExistent")).to.be.false
+		})
+
+		it("should correctly identify computed properties", () => {
+			// planActSeparateModelsSetting is known to be computed
+			expect(isComputedProperty("planActSeparateModelsSetting")).to.be.true
+			expect(isComputedProperty("preferredLanguage")).to.be.false
+			expect(isComputedProperty("nonExistent")).to.be.false
+		})
+	})
+
+	describe("Type Exports", () => {
+		/**
+		 * Compile-time tests that verify type exports work correctly.
+		 * If these fail to compile, the types are broken.
+		 */
+
+		it("should export usable GlobalState type", () => {
+			// This is a compile-time check - if GlobalState is broken, this won't compile
+			const partialState: Partial<GlobalState> = {
+				isNewUser: true,
+				favoritedModelIds: [],
+			}
+			expect(partialState.isNewUser).to.equal(true)
+		})
+
+		it("should export usable Settings type", () => {
+			const partialSettings: Partial<Settings> = {
+				preferredLanguage: "English",
+				shellIntegrationTimeout: 5000,
+			}
+			expect(partialSettings.preferredLanguage).to.equal("English")
+		})
+
+		it("should export usable key types", () => {
+			// These assignments verify the key types are correctly narrowed
+			const globalKey: GlobalStateKey = "isNewUser"
+			const settingsKey: SettingsKey = "preferredLanguage"
+			const secretKey: SecretKey = "apiKey"
+			const localKey: LocalStateKey = "localClineRulesToggles"
+
+			expect(globalKey).to.be.a("string")
+			expect(settingsKey).to.be.a("string")
+			expect(secretKey).to.be.a("string")
+			expect(localKey).to.be.a("string")
+		})
+
+		it("should have GlobalStateAndSettings include both GlobalState and Settings", () => {
+			const combined: Partial<GlobalStateAndSettings> = {
+				// From GlobalState
+				isNewUser: true,
+				// From Settings
+				preferredLanguage: "English",
+			}
+			expect(combined.isNewUser).to.equal(true)
+			expect(combined.preferredLanguage).to.equal("English")
+		})
+
+		it("should have LocalState keys map to ClineRulesToggles", () => {
+			const localState: Partial<LocalState> = {
+				localClineRulesToggles: {},
+				localCursorRulesToggles: { "some-rule": true },
+			}
+			expect(localState.localClineRulesToggles).to.deep.equal({})
+		})
+	})
+
+	describe("Edge Cases", () => {
+		/**
+		 * Tests for edge cases and boundary conditions.
+		 */
+
+		it("should handle empty string keys gracefully", () => {
+			expect(isGlobalStateKey("")).to.be.false
+			expect(isSettingsKey("")).to.be.false
+			expect(isSecretKey("")).to.be.false
+			expect(isLocalStateKey("")).to.be.false
+		})
+
+		it("should handle keys with special characters", () => {
+			// The cline:clineAccountId key has a colon
+			expect(SecretKeys).to.include("cline:clineAccountId")
+			expect(isSecretKey("cline:clineAccountId")).to.be.true
+		})
+
+		it("should not have keys that could cause prototype pollution", () => {
+			const dangerousKeys = ["__proto__", "constructor", "prototype"]
+
+			for (const key of dangerousKeys) {
+				expect(isGlobalStateKey(key), `${key} should not be a GlobalStateKey`).to.be.false
+				expect(isSettingsKey(key), `${key} should not be a SettingsKey`).to.be.false
+				expect(isSecretKey(key), `${key} should not be a SecretKey`).to.be.false
+			}
+		})
+	})
+})
diff --git a/apps/vscode/src/shared/storage/adapters.ts b/apps/vscode/src/shared/storage/adapters.ts
new file mode 100644
index 0000000..ecff303
--- /dev/null
+++ b/apps/vscode/src/shared/storage/adapters.ts
@@ -0,0 +1,213 @@
+import { AwsClient } from "aws4fetch"
+import { createHmac } from "crypto"
+
+import { fetch } from "@/shared/net"
+import { Logger } from "../services/Logger"
+import type { BlobStoreSettings } from "./types"
+
+export interface StorageAdapter {
+	read(path: string): Promise<string | undefined>
+	write(path: string, value: string): Promise<void>
+	remove(path: string): Promise<void>
+}
+
+function createAdapter(client: AwsClient, endpoint: string, bucket: string): StorageAdapter {
+	const base = `${endpoint}/${bucket}`
+	return {
+		async read(path: string): Promise<string | undefined> {
+			const response = await client.fetch(`${base}/${path}`)
+			if (response.status === 404) {
+				return undefined
+			}
+			if (!response.ok) {
+				throw new Error(`Failed to read ${path}: ${response.status}`)
+			}
+			return response.text()
+		},
+
+		async write(path: string, value: string): Promise<void> {
+			const response = await client.fetch(`${base}/${path}`, {
+				method: "PUT",
+				body: value,
+				headers: {
+					"Content-Type": "text/plain",
+				},
+			})
+			if (!response.ok) {
+				throw new Error(`Failed to write ${path}: ${response.status}`)
+			}
+		},
+
+		async remove(path: string): Promise<void> {
+			const response = await client.fetch(`${base}/${path}`, {
+				method: "DELETE",
+			})
+			// S3 returns 204 for successful deletes, but also returns 204 for non-existent keys
+			if (!response.ok && response.status !== 204) {
+				throw new Error(`Failed to remove ${path}: ${response.status}`)
+			}
+		},
+	}
+}
+
+function createS3Adapter(settings: BlobStoreSettings): StorageAdapter | undefined {
+	const { bucket, accessKeyId, secretAccessKey } = settings
+
+	if (!bucket || !accessKeyId || !secretAccessKey) {
+		Logger.error("[StorageAdapter] Missing required S3 settings")
+		return undefined
+	}
+
+	const region = settings.region || "us-east-1"
+	const endpoint = settings.endpoint || `https://s3.${region}.amazonaws.com`
+	try {
+		const client = new AwsClient({
+			region,
+			accessKeyId,
+			secretAccessKey,
+		})
+		return createAdapter(client, endpoint, bucket)
+	} catch (error) {
+		Logger.error("[StorageAdapter] Failed to create S3 adapter:", error)
+		return undefined
+	}
+}
+
+function createR2Adapter(settings: BlobStoreSettings): StorageAdapter | undefined {
+	const { accountId, endpoint, bucket, accessKeyId, secretAccessKey } = settings
+
+	if ((!endpoint && !accountId) || !bucket || !accessKeyId || !secretAccessKey) {
+		Logger.error("[StorageAdapter] Missing required R2 settings")
+		return undefined
+	}
+
+	try {
+		const client = new AwsClient({
+			accessKeyId,
+			secretAccessKey,
+		})
+		const endpoint = settings.endpoint ?? `https://${accountId}.r2.cloudflarestorage.com`
+		return createAdapter(client, endpoint, bucket)
+	} catch (error) {
+		Logger.error("[StorageAdapter] Failed to create R2 adapter:", error)
+		return undefined
+	}
+}
+
+/**
+ * Generate Azure Storage Shared Key authorization header.
+ * See: https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key
+ */
+function azureSharedKeyAuth(
+	accountName: string,
+	accountKey: string,
+	method: string,
+	path: string,
+	headers: Record<string, string>,
+): string {
+	const contentLength = headers["Content-Length"] || ""
+	const contentType = headers["Content-Type"] || ""
+
+	const msHeaders = Object.entries(headers)
+		.filter(([k]) => k.toLowerCase().startsWith("x-ms-"))
+		.sort(([a], [b]) => a.toLowerCase().localeCompare(b.toLowerCase()))
+		.map(([k, v]) => `${k.toLowerCase()}:${v}`)
+		.join("\n")
+
+	const canonicalizedResource = `/${accountName}${path}`
+
+	const stringToSign = [
+		method,
+		"", // Content-Encoding
+		"", // Content-Language
+		contentLength,
+		"", // Content-MD5
+		contentType,
+		"", // Date (empty when x-ms-date is used)
+		"", // If-Modified-Since
+		"", // If-Match
+		"", // If-None-Match
+		"", // If-Unmodified-Since
+		"", // Range
+		msHeaders,
+		canonicalizedResource,
+	].join("\n")
+
+	const key = Buffer.from(accountKey, "base64")
+	const signature = createHmac("sha256", key).update(stringToSign, "utf8").digest("base64")
+
+	return `SharedKey ${accountName}:${signature}`
+}
+
+function createAzureAdapter(settings: BlobStoreSettings): StorageAdapter | undefined {
+	const { accessKeyId, secretAccessKey, bucket } = settings
+
+	if (!accessKeyId || !secretAccessKey || !bucket) {
+		Logger.error("[StorageAdapter] Missing required Azure Blob Storage settings (accessKeyId, secretAccessKey, bucket)")
+		return undefined
+	}
+
+	const baseUrl = settings.endpoint || `https://${accessKeyId}.blob.core.windows.net`
+
+	try {
+		return {
+			async read(_: string): Promise<string | undefined> {
+				// We don't have a use case to read files yet.
+				throw new Error("Reading is not supported")
+			},
+
+			async write(path: string, value: string): Promise<void> {
+				const blobPath = `/${bucket}/${path}`
+				const date = new Date().toUTCString()
+				const bodyBuffer = Buffer.from(value, "utf8")
+				const contentLength = bodyBuffer.byteLength.toString()
+				const headers: Record<string, string> = {
+					"x-ms-date": date,
+					"x-ms-version": "2024-11-04",
+					"x-ms-blob-type": "BlockBlob",
+					"Content-Type": "text/plain",
+					"Content-Length": contentLength,
+				}
+				headers["Authorization"] = azureSharedKeyAuth(accessKeyId, secretAccessKey, "PUT", blobPath, headers)
+
+				const response = await fetch(`${baseUrl}${blobPath}`, {
+					method: "PUT",
+					body: bodyBuffer,
+					headers,
+				})
+				if (!response.ok) {
+					const errorBody = await response.text().catch(() => "")
+					throw new Error(`Failed to write ${path}: ${response.status} ${errorBody}`)
+				}
+			},
+
+			async remove(_: string): Promise<void> {
+				// We don't need to support removing remote files for our purposes within the extension
+				throw new Error("Deleting is not supported")
+			},
+		}
+	} catch (error) {
+		Logger.error("[StorageAdapter] Failed to create Azure adapter:", error)
+		return undefined
+	}
+}
+
+export function getStorageAdapter(settings: BlobStoreSettings): StorageAdapter | undefined {
+	try {
+		const adapterType = settings.adapterType
+		if (adapterType === "r2") {
+			return createR2Adapter(settings)
+		}
+		if (adapterType === "s3") {
+			return createS3Adapter(settings)
+		}
+		if (adapterType === "azure") {
+			return createAzureAdapter(settings)
+		}
+		Logger.error(`[StorageAdapter] Invalid adapterType: ${adapterType}. Must be "s3", "r2", or "azure".`)
+		return undefined
+	} catch (error) {
+		Logger.error("[StorageAdapter] Unexpected error creating adapter:", error)
+		return undefined
+	}
+}
diff --git a/apps/vscode/src/shared/storage/index.ts b/apps/vscode/src/shared/storage/index.ts
new file mode 100644
index 0000000..780d3f2
--- /dev/null
+++ b/apps/vscode/src/shared/storage/index.ts
@@ -0,0 +1,7 @@
+export * from "./ClineBlobStorage"
+export * from "./ClineFileStorage"
+export * from "./ClineStorage"
+export * from "./provider-keys"
+export * from "./state-keys"
+export * from "./storage-context"
+export * from "./types"
diff --git a/apps/vscode/src/shared/storage/provider-keys.ts b/apps/vscode/src/shared/storage/provider-keys.ts
new file mode 100644
index 0000000..63a0097
--- /dev/null
+++ b/apps/vscode/src/shared/storage/provider-keys.ts
@@ -0,0 +1,99 @@
+// Map providers to their specific model ID keys
+
+import { getProviderCollectionSync } from "@cline/llms"
+import { SettingsKey } from "@shared/storage/state-keys"
+import { toSdkProviderId } from "@/sdk/model-catalog/sdk-provider-id"
+import { toLegacyApiProvider } from "@/shared/model-catalog/provider-helpers"
+import {
+	type ApiProvider,
+	clinePassDefaultModelId,
+	liteLlmDefaultModelId,
+	openRouterDefaultModelId,
+	requestyDefaultModelId,
+} from "../api"
+
+const ProviderKeyMap: Partial<Record<ApiProvider, string>> = {
+	openrouter: "OpenRouterModelId",
+	cline: "ClineModelId",
+	"cline-pass": "ClinePassModelId",
+	openai: "OpenAiModelId",
+	ollama: "OllamaModelId",
+	lmstudio: "LmStudioModelId",
+	litellm: "LiteLlmModelId",
+	requesty: "RequestyModelId",
+	together: "TogetherModelId",
+	fireworks: "FireworksModelId",
+	sapaicore: "SapAiCoreModelId",
+	groq: "GroqModelId",
+	baseten: "BasetenModelId",
+	huggingface: "HuggingFaceModelId",
+	"huawei-cloud-maas": "HuaweiCloudMaasModelId",
+	oca: "OcaModelId",
+	aihubmix: "AihubmixModelId",
+	hicap: "HicapModelId",
+	nousResearch: "NousResearchModelId",
+	"vercel-ai-gateway": "VercelAiGatewayModelId",
+} as const
+
+/**
+ * Provider ids whose "default model" is not the SDK-declared catalog
+ * default but a stored-on-`ApiConfiguration` slot belonging to another
+ * provider. Dynamic-list providers (openrouter, cline, requesty, etc.)
+ * write their committed ModelInfo back to their own provider field, so
+ * here we expose a stable id string that downstream code can use as a
+ * pre-commit placeholder.
+ *
+ * Anything not listed here falls through to the SDK catalog default for
+ * its `providerId` (handled by `getProviderDefaultModelId` below).
+ */
+const NON_SDK_PROVIDER_DEFAULTS: Partial<Record<ApiProvider, string>> = {
+	openrouter: openRouterDefaultModelId,
+	cline: openRouterDefaultModelId,
+	"cline-pass": clinePassDefaultModelId,
+	together: openRouterDefaultModelId,
+	aihubmix: openRouterDefaultModelId,
+	"vercel-ai-gateway": openRouterDefaultModelId,
+	litellm: liteLlmDefaultModelId,
+	oca: liteLlmDefaultModelId,
+	requesty: requestyDefaultModelId,
+	// Local-only providers have no remote default to nominate.
+	ollama: "",
+	lmstudio: "",
+	hicap: "",
+}
+
+/**
+ * Get the provider-specific model ID key for a given provider and mode.
+ * Different providers store their model IDs in different state keys.
+ */
+export function getProviderModelIdKey(provider: ApiProvider | string, mode: "act" | "plan"): SettingsKey {
+	const legacyProvider = toLegacyApiProvider(provider)
+	const keySuffix = ProviderKeyMap[legacyProvider]
+	if (keySuffix) {
+		// E.g. actModeOpenAiModelId, planModeOpenAiModelId, etc.
+		return `${mode}Mode${keySuffix}` as SettingsKey
+	}
+
+	// For providers without a specific key (anthropic, gemini, bedrock, etc.),
+	// they use the generic actModeApiModelId/planModeApiModelId
+	return `${mode}ModeApiModelId`
+}
+
+/**
+ * Resolve the canonical "default model id" for a provider.
+ *
+ * 1. Hardcoded overrides for dynamic-list providers / local-only providers
+ *    (see `NON_SDK_PROVIDER_DEFAULTS`).
+ * 2. SDK catalog default for everything else, looked up synchronously via
+ *    `getProviderCollectionSync(provider).provider.defaultModelId`.
+ * 3. Empty string when the SDK has no entry for `provider`.
+ */
+export function getProviderDefaultModelId(provider: ApiProvider | string): string | null {
+	const legacyProvider = toLegacyApiProvider(provider)
+	const override = NON_SDK_PROVIDER_DEFAULTS[legacyProvider]
+	if (override !== undefined) {
+		return override
+	}
+	const collection = getProviderCollectionSync(toSdkProviderId(provider))
+	return collection?.provider.defaultModelId ?? ""
+}
diff --git a/apps/vscode/src/shared/storage/state-keys.ts b/apps/vscode/src/shared/storage/state-keys.ts
new file mode 100644
index 0000000..5043f93
--- /dev/null
+++ b/apps/vscode/src/shared/storage/state-keys.ts
@@ -0,0 +1,461 @@
+import { AutoApprovalSettings, DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
+import {
+	ApiProvider,
+	DEFAULT_API_PROVIDER,
+	LiteLLMModelInfo,
+	ModelInfo,
+	type OcaModelInfo,
+	OpenAiCompatibleModelInfo,
+} from "@shared/api"
+import { BrowserSettings, DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
+import { ClineRulesToggles } from "@shared/cline-rules"
+import { DEFAULT_FOCUS_CHAIN_SETTINGS, FocusChainSettings } from "@shared/FocusChainSettings"
+import { HistoryItem } from "@shared/HistoryItem"
+import { DEFAULT_MCP_DISPLAY_MODE, McpDisplayMode } from "@shared/McpDisplayMode"
+import { WorkspaceRoot } from "@shared/multi-root/types"
+import { GlobalInstructionsFile } from "@shared/remote-config/schema"
+import { Mode } from "@shared/storage/types"
+import { TelemetrySetting } from "@shared/TelemetrySetting"
+import { UserInfo } from "@shared/UserInfo"
+import { LanguageModelChatSelector } from "vscode"
+import { type BlobStoreSettings } from "./types"
+
+// ============================================================================
+// SINGLE SOURCE OF TRUTH FOR STORAGE KEYS
+//
+// Property definitions with types, default values, and metadata
+// NOTE: When adding a new field, the scripts/generate-state-proto.mjs will be
+// executed automatically to regenerate the proto/cline/state.proto file with the
+// new fields once the file is staged and committed.
+// ============================================================================
+
+/**
+ * Defines the shape of a field definition. Each field must have a `default` value,
+ * and optionally can have `isAsync`, `isComputed`, or `transform` metadata.
+ *
+ * The type casting on `default` (e.g., `true as boolean`) is necessary because
+ * TypeScript would otherwise infer the literal type (`true`) instead of the
+ * wider type (`boolean`). This ensures the generated interfaces allow any
+ * value of that type, not just the default literal.
+ */
+type FieldDefinition<T> = {
+	default: T // The default value for the field with proper type casting using as (e.g., `true as boolean | undefined`)
+	isAsync?: boolean
+	isComputed?: boolean
+	transform?: (value: any) => T
+}
+
+type FieldDefinitions = Record<string, FieldDefinition<any>>
+
+export type ConfiguredAPIKeys = Partial<Record<ApiProvider, boolean>>
+const REMOTE_CONFIG_EXTRA_FIELDS = {
+	remoteConfiguredProviders: { default: [] as ApiProvider[] },
+	allowedMCPServers: { default: [] as Array<{ id: string }> },
+	remoteMCPServers: { default: undefined as Array<{ name: string; url: string; alwaysEnabled?: boolean }> | undefined },
+	previousRemoteMCPServers: { default: undefined as Array<{ name: string; url: string }> | undefined },
+	remoteGlobalRules: { default: undefined as GlobalInstructionsFile[] | undefined },
+	remoteGlobalWorkflows: { default: undefined as GlobalInstructionsFile[] | undefined },
+	remoteGlobalSkills: { default: undefined as GlobalInstructionsFile[] | undefined },
+	blockPersonalRemoteMCPServers: { default: false as boolean },
+	openTelemetryOtlpHeaders: { default: undefined as Record<string, string> | undefined },
+	otlpMetricsHeaders: { default: undefined as Record<string, string> | undefined },
+	otlpLogsHeaders: { default: undefined as Record<string, string> | undefined },
+	blobStoreConfig: { default: undefined as BlobStoreSettings | undefined },
+	configuredApiKeys: { default: {} as ConfiguredAPIKeys | undefined },
+} satisfies FieldDefinitions
+
+const GLOBAL_STATE_FIELDS = {
+	clineVersion: { default: undefined as string | undefined },
+	"cline.generatedMachineId": { default: undefined as string | undefined }, // Note, distinctId reads/writes this directly from/to StorageContext before StateManager is initialized.
+	lastShownAnnouncementId: { default: undefined as string | undefined },
+	taskHistory: { default: [] as HistoryItem[], isAsync: true },
+	userInfo: { default: undefined as UserInfo | undefined },
+	favoritedModelIds: { default: [] as string[] },
+	mcpMarketplaceEnabled: { default: true as boolean },
+	mcpResponsesCollapsed: { default: false as boolean },
+	terminalReuseEnabled: { default: true as boolean },
+	vscodeTerminalExecutionMode: {
+		default: "vscodeTerminal" as "vscodeTerminal" | "backgroundExec",
+	},
+	isNewUser: { default: true as boolean },
+	welcomeViewCompleted: { default: undefined as boolean | undefined },
+	mcpDisplayMode: { default: DEFAULT_MCP_DISPLAY_MODE as McpDisplayMode },
+	workspaceRoots: { default: undefined as WorkspaceRoot[] | undefined },
+	primaryRootIndex: { default: 0 as number },
+	multiRootEnabled: { default: true as boolean },
+	lastDismissedInfoBannerVersion: { default: 0 as number },
+	lastDismissedModelBannerVersion: { default: 0 as number },
+	lastDismissedCliBannerVersion: { default: 0 as number },
+	remoteRulesToggles: { default: {} as ClineRulesToggles },
+	remoteWorkflowToggles: { default: {} as ClineRulesToggles },
+	remoteSkillsToggles: { default: {} as ClineRulesToggles },
+	dismissedBanners: { default: [] as Array<{ bannerId: string; dismissedAt: number }> },
+	// Path to worktree that should auto-open Cline sidebar when launched
+	worktreeAutoOpenPath: { default: undefined as string | undefined },
+} satisfies FieldDefinitions
+
+// Fields that map directly to ApiHandlerOptions in @shared/api.ts
+const API_HANDLER_SETTINGS_FIELDS = {
+	// Global configuration (not mode-specific)
+	liteLlmBaseUrl: { default: undefined as string | undefined },
+	liteLlmUsePromptCache: { default: undefined as boolean | undefined },
+	openAiHeaders: { default: {} as Record<string, string> },
+	anthropicBaseUrl: { default: undefined as string | undefined },
+	openRouterProviderSorting: { default: undefined as string | undefined },
+	awsRegion: { default: undefined as string | undefined },
+	awsUseCrossRegionInference: { default: undefined as boolean | undefined },
+	awsUseGlobalInference: { default: undefined as boolean | undefined },
+	awsBedrockUsePromptCache: { default: undefined as boolean | undefined },
+	awsAuthentication: { default: undefined as string | undefined },
+	awsUseProfile: { default: undefined as boolean | undefined },
+	awsProfile: { default: undefined as string | undefined },
+	awsBedrockEndpoint: { default: undefined as string | undefined },
+	claudeCodePath: { default: undefined as string | undefined },
+	vertexProjectId: { default: undefined as string | undefined },
+	vertexRegion: { default: undefined as string | undefined },
+	openAiBaseUrl: { default: undefined as string | undefined },
+	ollamaBaseUrl: { default: undefined as string | undefined },
+	ollamaApiOptionsCtxNum: { default: undefined as string | undefined },
+	lmStudioBaseUrl: { default: undefined as string | undefined },
+	lmStudioMaxTokens: { default: undefined as string | undefined },
+	geminiBaseUrl: { default: undefined as string | undefined },
+	requestyBaseUrl: { default: undefined as string | undefined },
+	fireworksModelMaxCompletionTokens: { default: undefined as number | undefined },
+	fireworksModelMaxTokens: { default: undefined as number | undefined },
+	qwenCodeOauthPath: { default: undefined as string | undefined },
+	azureApiVersion: { default: undefined as string | undefined },
+	azureIdentity: { default: undefined as boolean | undefined },
+	qwenApiLine: { default: undefined as string | undefined },
+	moonshotApiLine: { default: undefined as string | undefined },
+	asksageApiUrl: { default: undefined as string | undefined },
+	requestTimeoutMs: { default: undefined as number | undefined },
+	sapAiResourceGroup: { default: undefined as string | undefined },
+	sapAiCoreTokenUrl: { default: undefined as string | undefined },
+	sapAiCoreBaseUrl: { default: undefined as string | undefined },
+	sapAiCoreUseOrchestrationMode: { default: true as boolean },
+	difyBaseUrl: { default: undefined as string | undefined },
+	zaiApiLine: { default: undefined as string | undefined },
+	ocaBaseUrl: { default: undefined as string | undefined },
+	minimaxApiLine: { default: undefined as string | undefined },
+	ocaMode: { default: "internal" as string },
+	aihubmixBaseUrl: { default: undefined as string | undefined },
+	aihubmixAppCode: { default: undefined as string | undefined },
+
+	// Plan mode configurations
+	planModeApiModelId: { default: undefined as string | undefined },
+	planModeThinkingBudgetTokens: { default: undefined as number | undefined },
+	geminiPlanModeThinkingLevel: { default: undefined as string | undefined },
+	planModeReasoningEffort: { default: undefined as string | undefined },
+	planModeVerbosity: { default: undefined as string | undefined },
+	planModeVsCodeLmModelSelector: { default: undefined as LanguageModelChatSelector | undefined },
+	planModeAwsBedrockCustomSelected: { default: undefined as boolean | undefined },
+	planModeAwsBedrockCustomModelBaseId: { default: undefined as string | undefined },
+	planModeOpenRouterModelId: { default: undefined as string | undefined },
+	planModeOpenRouterModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeClineModelId: { default: undefined as string | undefined },
+	planModeClineModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeClinePassModelId: { default: undefined as string | undefined },
+	planModeClinePassModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeOpenAiModelId: { default: undefined as string | undefined },
+	planModeOpenAiModelInfo: { default: undefined as OpenAiCompatibleModelInfo | undefined },
+	planModeOllamaModelId: { default: undefined as string | undefined },
+	planModeLmStudioModelId: { default: undefined as string | undefined },
+	planModeLiteLlmModelId: { default: undefined as string | undefined },
+	planModeLiteLlmModelInfo: { default: undefined as LiteLLMModelInfo | undefined },
+	planModeRequestyModelId: { default: undefined as string | undefined },
+	planModeRequestyModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeTogetherModelId: { default: undefined as string | undefined },
+	planModeFireworksModelId: { default: undefined as string | undefined },
+	planModeSapAiCoreModelId: { default: undefined as string | undefined },
+	planModeSapAiCoreDeploymentId: { default: undefined as string | undefined },
+	planModeGroqModelId: { default: undefined as string | undefined },
+	planModeGroqModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeBasetenModelId: { default: undefined as string | undefined },
+	planModeBasetenModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeHuggingFaceModelId: { default: undefined as string | undefined },
+	planModeHuggingFaceModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeHuaweiCloudMaasModelId: { default: undefined as string | undefined },
+	planModeHuaweiCloudMaasModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeOcaModelId: { default: undefined as string | undefined },
+	planModeOcaModelInfo: { default: undefined as OcaModelInfo | undefined },
+	planModeOcaReasoningEffort: { default: undefined as string | undefined },
+	planModeAihubmixModelId: { default: undefined as string | undefined },
+	planModeAihubmixModelInfo: { default: undefined as OpenAiCompatibleModelInfo | undefined },
+	planModeHicapModelId: { default: undefined as string | undefined },
+	planModeHicapModelInfo: { default: undefined as ModelInfo | undefined },
+	planModeNousResearchModelId: { default: undefined as string | undefined },
+	planModeVercelAiGatewayModelId: { default: undefined as string | undefined },
+	planModeVercelAiGatewayModelInfo: { default: undefined as ModelInfo | undefined },
+
+	// Act mode configurations
+	actModeApiModelId: { default: undefined as string | undefined },
+	actModeThinkingBudgetTokens: { default: undefined as number | undefined },
+	geminiActModeThinkingLevel: { default: undefined as string | undefined },
+	actModeReasoningEffort: { default: undefined as string | undefined },
+	actModeVerbosity: { default: undefined as string | undefined },
+	actModeVsCodeLmModelSelector: { default: undefined as LanguageModelChatSelector | undefined },
+	actModeAwsBedrockCustomSelected: { default: undefined as boolean | undefined },
+	actModeAwsBedrockCustomModelBaseId: { default: undefined as string | undefined },
+	actModeOpenRouterModelId: { default: undefined as string | undefined },
+	actModeOpenRouterModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeClineModelId: { default: undefined as string | undefined },
+	actModeClineModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeClinePassModelId: { default: undefined as string | undefined },
+	actModeClinePassModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeOpenAiModelId: { default: undefined as string | undefined },
+	actModeOpenAiModelInfo: { default: undefined as OpenAiCompatibleModelInfo | undefined },
+	actModeOllamaModelId: { default: undefined as string | undefined },
+	actModeLmStudioModelId: { default: undefined as string | undefined },
+	actModeLiteLlmModelId: { default: undefined as string | undefined },
+	actModeLiteLlmModelInfo: { default: undefined as LiteLLMModelInfo | undefined },
+	actModeRequestyModelId: { default: undefined as string | undefined },
+	actModeRequestyModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeTogetherModelId: { default: undefined as string | undefined },
+	actModeFireworksModelId: { default: undefined as string | undefined },
+	actModeSapAiCoreModelId: { default: undefined as string | undefined },
+	actModeSapAiCoreDeploymentId: { default: undefined as string | undefined },
+	actModeGroqModelId: { default: undefined as string | undefined },
+	actModeGroqModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeBasetenModelId: { default: undefined as string | undefined },
+	actModeBasetenModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeHuggingFaceModelId: { default: undefined as string | undefined },
+	actModeHuggingFaceModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeHuaweiCloudMaasModelId: { default: undefined as string | undefined },
+	actModeHuaweiCloudMaasModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeOcaModelId: { default: undefined as string | undefined },
+	actModeOcaModelInfo: { default: undefined as OcaModelInfo | undefined },
+	actModeOcaReasoningEffort: { default: undefined as string | undefined },
+	actModeAihubmixModelId: { default: undefined as string | undefined },
+	actModeAihubmixModelInfo: { default: undefined as OpenAiCompatibleModelInfo | undefined },
+	actModeHicapModelId: { default: undefined as string | undefined },
+	actModeHicapModelInfo: { default: undefined as ModelInfo | undefined },
+	actModeNousResearchModelId: { default: undefined as string | undefined },
+	actModeVercelAiGatewayModelId: { default: undefined as string | undefined },
+	actModeVercelAiGatewayModelInfo: { default: undefined as ModelInfo | undefined },
+
+	// Model-specific settings
+	planModeApiProvider: { default: DEFAULT_API_PROVIDER as ApiProvider },
+	actModeApiProvider: { default: DEFAULT_API_PROVIDER as ApiProvider },
+
+	// Deprecated model settings
+	hicapModelId: { default: undefined as string | undefined },
+	lmStudioModelId: { default: undefined as string | undefined },
+} satisfies FieldDefinitions
+
+const USER_SETTINGS_FIELDS = {
+	// Settings that are NOT part of ApiHandlerOptions
+	autoApprovalSettings: {
+		default: DEFAULT_AUTO_APPROVAL_SETTINGS as AutoApprovalSettings,
+	},
+	globalClineRulesToggles: { default: {} as ClineRulesToggles },
+	globalWorkflowToggles: { default: {} as ClineRulesToggles },
+	globalSkillsToggles: { default: {} as Record<string, boolean> },
+	browserSettings: {
+		default: DEFAULT_BROWSER_SETTINGS as BrowserSettings,
+		transform: (v: any) => ({ ...DEFAULT_BROWSER_SETTINGS, ...v }),
+	},
+	telemetrySetting: { default: "unset" as TelemetrySetting },
+	planActSeparateModelsSetting: { default: false as boolean, isComputed: true },
+	enableCheckpointsSetting: { default: true as boolean },
+	shellIntegrationTimeout: { default: 4000 as number },
+	defaultTerminalProfile: { default: "default" as string },
+	maxConsecutiveMistakes: { default: 3 as number },
+	hooksEnabled: { default: true as boolean },
+	yoloModeToggled: { default: false as boolean },
+	autoApproveAllToggled: { default: false as boolean },
+	useAutoCondense: { default: false as boolean },
+	subagentsEnabled: { default: false as boolean },
+	worktreesEnabled: { default: false as boolean },
+	preferredLanguage: { default: "English" as string },
+	mode: { default: "act" as Mode },
+	focusChainSettings: { default: DEFAULT_FOCUS_CHAIN_SETTINGS as FocusChainSettings },
+	customPrompt: { default: undefined as "compact" | undefined },
+	backgroundEditEnabled: { default: false as boolean },
+	optOutOfRemoteConfig: { default: false as boolean },
+	showFeatureTips: { default: true as boolean },
+
+	// OpenTelemetry configuration
+	openTelemetryEnabled: { default: true as boolean },
+	openTelemetryMetricsExporter: { default: undefined as string | undefined },
+	openTelemetryLogsExporter: { default: undefined as string | undefined },
+	openTelemetryOtlpProtocol: { default: "http/json" as string | undefined },
+	openTelemetryOtlpEndpoint: { default: "http://localhost:4318" as string | undefined },
+	openTelemetryOtlpMetricsProtocol: { default: undefined as string | undefined },
+	openTelemetryOtlpMetricsEndpoint: { default: undefined as string | undefined },
+	openTelemetryOtlpLogsProtocol: { default: undefined as string | undefined },
+	openTelemetryOtlpLogsEndpoint: { default: undefined as string | undefined },
+	openTelemetryMetricExportInterval: { default: 60000 as number | undefined },
+	openTelemetryOtlpInsecure: { default: false as boolean | undefined },
+	openTelemetryLogBatchSize: { default: 512 as number | undefined },
+	openTelemetryLogBatchTimeout: { default: 5000 as number | undefined },
+	openTelemetryLogMaxQueueSize: { default: 2048 as number | undefined },
+} satisfies FieldDefinitions
+
+const SETTINGS_FIELDS = { ...API_HANDLER_SETTINGS_FIELDS, ...USER_SETTINGS_FIELDS }
+const GLOBAL_STATE_AND_SETTINGS_FIELDS = { ...GLOBAL_STATE_FIELDS, ...SETTINGS_FIELDS }
+
+// ============================================================================
+// SECRET KEYS AND LOCAL STATE - Static definitions
+// ============================================================================
+
+// Secret keys used in Api Configuration
+const SECRETS_KEYS = [
+	"apiKey",
+	"clineApiKey",
+	"clineAccountId", // Cline Account ID for Firebase
+	"cline:clineAccountId",
+	"openRouterApiKey",
+	"awsAccessKey",
+	"awsSecretKey",
+	"awsSessionToken",
+	"awsBedrockApiKey",
+	"openAiApiKey",
+	"geminiApiKey",
+	"openAiNativeApiKey",
+	"ollamaApiKey",
+	"deepSeekApiKey",
+	"requestyApiKey",
+	"togetherApiKey",
+	"fireworksApiKey",
+	"qwenApiKey",
+	"doubaoApiKey",
+	"mistralApiKey",
+	"liteLlmApiKey",
+	"authNonce",
+	"asksageApiKey",
+	"xaiApiKey",
+	"moonshotApiKey",
+	"zaiApiKey",
+	"huggingFaceApiKey",
+	"nebiusApiKey",
+	"sambanovaApiKey",
+	"cerebrasApiKey",
+	"sapAiCoreClientId",
+	"sapAiCoreClientSecret",
+	"groqApiKey",
+	"huaweiCloudMaasApiKey",
+	"basetenApiKey",
+	"vercelAiGatewayApiKey",
+	"difyApiKey",
+	"minimaxApiKey",
+	"hicapApiKey",
+	"aihubmixApiKey",
+	"nousResearchApiKey",
+	"remoteLiteLlmApiKey",
+	"ocaApiKey",
+	"ocaRefreshToken",
+	"mcpOAuthSecrets",
+	"openai-codex-oauth-credentials", // JSON blob containing OAuth tokens for OpenAI Codex (ChatGPT subscription)
+	"wandbApiKey",
+] as const
+
+// WARNING, these are not ALL of the local state keys in practice. For example, FileContextTracker
+// uses dynamic keys like pendingFileContextWarning_${taskId}.
+export const LocalStateKeys = [
+	"localClineRulesToggles",
+	"localCursorRulesToggles",
+	"localWindsurfRulesToggles",
+	"localAgentsRulesToggles",
+	"localSkillsToggles",
+	"workflowToggles",
+] as const
+
+// ============================================================================
+// GENERATED TYPES - Auto-generated from property definitions
+// ============================================================================
+
+type ExtractDefault<T> = T extends { default: infer U } ? U : never
+type BuildInterface<T extends Record<string, { default: any }>> = { [K in keyof T]: ExtractDefault<T[K]> }
+
+export type GlobalState = BuildInterface<typeof GLOBAL_STATE_FIELDS>
+export type Settings = BuildInterface<typeof SETTINGS_FIELDS>
+type RemoteConfigExtra = BuildInterface<typeof REMOTE_CONFIG_EXTRA_FIELDS>
+export type ApiHandlerOptionSettings = BuildInterface<typeof API_HANDLER_SETTINGS_FIELDS>
+export type ApiHandlerSettings = ApiHandlerOptionSettings & Secrets
+export type GlobalStateAndSettings = GlobalState & Settings
+export type RemoteConfigFields = GlobalStateAndSettings & RemoteConfigExtra
+
+// ============================================================================
+// TYPE ALIASES
+// ============================================================================
+
+export type Secrets = { [K in (typeof SecretKeys)[number]]: string | undefined }
+export type LocalState = { [K in (typeof LocalStateKeys)[number]]: ClineRulesToggles }
+export type SecretKey = (typeof SecretKeys)[number]
+export type GlobalStateKey = keyof GlobalState
+export type LocalStateKey = keyof LocalState
+export type SettingsKey = keyof Settings
+export type GlobalStateAndSettingsKey = keyof GlobalStateAndSettings
+
+// ============================================================================
+// GENERATED KEYS AND LOOKUP SETS - Auto-generated from property definitions
+// ============================================================================
+
+const GlobalStateKeys = new Set(Object.keys(GLOBAL_STATE_FIELDS))
+const SettingsKeysSet = new Set(Object.keys(SETTINGS_FIELDS))
+const GlobalStateAndSettingsKeySet = new Set(Object.keys(GLOBAL_STATE_AND_SETTINGS_FIELDS))
+const ApiHandlerSettingsKeysSet = new Set(Object.keys(API_HANDLER_SETTINGS_FIELDS))
+
+export const SecretKeys = Array.from(SECRETS_KEYS)
+export const SettingsKeys = Array.from(SettingsKeysSet) as (keyof Settings)[]
+export const ApiHandlerSettingsKeys = Array.from(ApiHandlerSettingsKeysSet) as (keyof ApiHandlerOptionSettings)[]
+export const GlobalStateAndSettingKeys = Array.from(GlobalStateAndSettingsKeySet) as GlobalStateAndSettingsKey[]
+
+// GENERATED DEFAULTS - Auto-generated from property definitions
+// ============================================================================
+
+export const GLOBAL_STATE_DEFAULTS = extractDefaults(GLOBAL_STATE_FIELDS)
+export const SETTINGS_DEFAULTS = extractDefaults(SETTINGS_FIELDS)
+export const SETTINGS_TRANSFORMS = extractTransforms(SETTINGS_FIELDS)
+const ASYNC_PROPERTIES = extractMetadata({ ...GLOBAL_STATE_FIELDS, ...SETTINGS_FIELDS }, "isAsync")
+const COMPUTED_PROPERTIES = extractMetadata({ ...GLOBAL_STATE_FIELDS, ...SETTINGS_FIELDS }, "isComputed")
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+export const isGlobalStateKey = (key: string): key is GlobalStateKey => GlobalStateKeys.has(key)
+export const isSettingsKey = (key: string): key is SettingsKey => SettingsKeysSet.has(key)
+export const isSecretKey = (key: string): key is SecretKey => new Set(SECRETS_KEYS).has(key as SecretKey)
+export const isLocalStateKey = (key: string): key is LocalStateKey => new Set(LocalStateKeys).has(key as LocalStateKey)
+
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+
+export const isAsyncProperty = (key: string): boolean => ASYNC_PROPERTIES.has(key)
+export const isComputedProperty = (key: string): boolean => COMPUTED_PROPERTIES.has(key)
+
+export const getDefaultValue = <K extends GlobalStateAndSettingsKey>(key: K): GlobalStateAndSettings[K] | undefined => {
+	return ((GLOBAL_STATE_DEFAULTS as any)[key] ?? (SETTINGS_DEFAULTS as any)[key]) as GlobalStateAndSettings[K] | undefined
+}
+
+export const hasTransform = (key: string): boolean => key in SETTINGS_TRANSFORMS
+export const applyTransform = <T>(key: string, value: T): T => {
+	const transform = SETTINGS_TRANSFORMS[key]
+	return transform ? transform(value) : value
+}
+
+function extractDefaults<T extends Record<string, any>>(props: T): Partial<BuildInterface<T>> {
+	return Object.fromEntries(
+		Object.entries(props)
+			.map(([key, prop]) => [key, prop.default])
+			.filter(([_, value]) => value !== undefined),
+	) as Partial<BuildInterface<T>>
+}
+
+function extractTransforms<T extends Record<string, any>>(props: T): Record<string, (value: any) => any> {
+	return Object.fromEntries(
+		Object.entries(props)
+			.filter(([_, prop]) => "transform" in prop && prop.transform !== undefined)
+			.map(([key, prop]) => [key, prop.transform]),
+	)
+}
+
+function extractMetadata<T extends Record<string, any>>(props: T, field: string): Set<string> {
+	return new Set(
+		Object.entries(props)
+			.filter(([_, prop]) => field in prop && prop[field] === true)
+			.map(([key]) => key),
+	)
+}
diff --git a/apps/vscode/src/shared/storage/storage-context.ts b/apps/vscode/src/shared/storage/storage-context.ts
new file mode 100644
index 0000000..d53f0af
--- /dev/null
+++ b/apps/vscode/src/shared/storage/storage-context.ts
@@ -0,0 +1,126 @@
+import fsSync from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { ClineFileStorage } from "./ClineFileStorage"
+import { ClineMemento } from "./ClineStorage"
+
+/**
+ * The storage backend context object used by StateManager and other components.
+ * Global, workspace and secret key-value storage goes through this component.
+ *
+ * This replaces the previous pattern of passing VSCode's ExtensionContext around
+ * for storage access. All platforms (VSCode, CLI, JetBrains) use the same
+ * file-backed implementation.
+ */
+export interface StorageContext {
+	/** Global state — settings, task history references, UI state, etc. */
+	readonly globalState: ClineMemento
+
+	// TODO: Privatize this field after StorageContext becomes class with a reset method.
+	/**
+	 * The backing store for global state. Prefer `globalState` when possible.
+	 *
+	 * This split exists because CLI needs to intercept the ClineMemento interface to global state,
+	 * but state resets need to write through to the backing store.
+	 */
+	readonly globalStateBackingStore: ClineFileStorage
+
+	/** Secrets — API keys and other sensitive values. File uses restricted permissions (0o600). */
+	readonly secrets: ClineFileStorage<string>
+
+	/** Workspace-scoped state — per-project toggles, rules, etc. */
+	readonly workspaceState: ClineFileStorage
+
+	/** The resolved path to the data directory (~/.cline/data) */
+	readonly dataDir: string
+
+	/** The resolved path to the workspace storage directory (contains workspaceState.json) */
+	readonly workspaceStoragePath: string
+}
+
+export interface StorageContextOptions {
+	/**
+	 * Override the Cline home directory. Defaults to CLINE_DIR env var or ~/.cline.
+	 */
+	clineDir?: string
+
+	/**
+	 * The workspace/project directory path. Used to compute a hash-based
+	 * workspace storage subdirectory. Defaults to process.cwd().
+	 */
+	workspacePath?: string
+
+	/**
+	 * Explicit workspace storage directory override.
+	 * When set, this path is used directly instead of computing a hash.
+	 * Used by JetBrains (via WORKSPACE_STORAGE_DIR env var).
+	 *
+	 * TODO: Unify JetBrains workspace path scheme with the hash-based approach
+	 * once the JetBrains client side is cleaned up.
+	 */
+	workspaceStorageDir?: string
+}
+
+const SETTINGS_SUBFOLDER = "data"
+
+/**
+ * Create a short deterministic hash of a string for use in directory names.
+ * Produces an up-to-8-character hex string.
+ */
+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 32-bit integer
+	}
+	return Math.abs(hash).toString(16).substring(0, 8)
+}
+
+/**
+ * Creates a StorageContext backed by JSON files on disk.
+ *
+ * All path computation is contained here — callers should not
+ * construct paths to these storage files themselves.
+ *
+ * File layout:
+ *   ~/.cline/data/globalState.json    — global state
+ *   ~/.cline/data/secrets.json        — secrets (mode 0o600)
+ *   ~/.cline/data/workspaces/<hash>/workspaceState.json — per-workspace state
+ *
+ * @param opts Configuration options for path resolution
+ * @returns A StorageContext ready for use by StateManager
+ */
+export function createStorageContext(opts: StorageContextOptions = {}): StorageContext {
+	const clineDir = opts.clineDir || process.env.CLINE_DIR || path.join(os.homedir(), ".cline")
+	const dataDir = path.join(clineDir, SETTINGS_SUBFOLDER)
+
+	// Resolve workspace storage directory
+	let workspaceDir: string
+	if (opts.workspaceStorageDir) {
+		// Explicit override (JetBrains via env var, or test overrides)
+		workspaceDir = opts.workspaceStorageDir
+	} else {
+		// Hash-based workspace isolation (CLI, VSCode)
+		const workspacePath = opts.workspacePath || process.cwd()
+		const workspaceHash = hashString(workspacePath)
+		workspaceDir = path.join(dataDir, "workspaces", workspaceHash)
+	}
+
+	// Ensure directories exist
+	fsSync.mkdirSync(dataDir, { recursive: true })
+	fsSync.mkdirSync(workspaceDir, { recursive: true })
+
+	const globalState = new ClineFileStorage(path.join(dataDir, "globalState.json"), "GlobalState")
+
+	return {
+		globalState,
+		globalStateBackingStore: globalState,
+		secrets: new ClineFileStorage<string>(path.join(dataDir, "secrets.json"), "Secrets", {
+			fileMode: 0o600, // Owner read/write only — protects API keys
+		}),
+		workspaceState: new ClineFileStorage(path.join(workspaceDir, "workspaceState.json"), "WorkspaceState"),
+		dataDir,
+		workspaceStoragePath: workspaceDir,
+	}
+}
diff --git a/apps/vscode/src/shared/storage/types.ts b/apps/vscode/src/shared/storage/types.ts
new file mode 100644
index 0000000..a862f16
--- /dev/null
+++ b/apps/vscode/src/shared/storage/types.ts
@@ -0,0 +1,37 @@
+export const OPENAI_REASONING_EFFORT_OPTIONS = ["none", "low", "medium", "high", "xhigh"] as const
+
+export type OpenaiReasoningEffort = (typeof OPENAI_REASONING_EFFORT_OPTIONS)[number]
+
+export function isOpenaiReasoningEffort(value: unknown): value is OpenaiReasoningEffort {
+	return typeof value === "string" && OPENAI_REASONING_EFFORT_OPTIONS.includes(value as OpenaiReasoningEffort)
+}
+
+export function normalizeOpenaiReasoningEffort(effort?: string): OpenaiReasoningEffort {
+	const value = (effort || "medium").toLowerCase()
+	return isOpenaiReasoningEffort(value) ? value : "medium"
+}
+
+export type Mode = "plan" | "act"
+
+export interface BlobStoreSettings {
+	bucket: string
+	adapterType: "s3" | "r2" | "azure" | string
+	accessKeyId: string
+	secretAccessKey: string
+	region?: string
+	endpoint?: string
+	accountId?: string
+
+	/** Interval between sync attempts in milliseconds (default: 30000 = 30s) */
+	intervalMs?: number
+	/** Maximum number of retries before giving up on an item (default: 5) */
+	maxRetries?: number
+	/** Batch size - how many items to process per interval (default: 10) */
+	batchSize?: number
+	/** Maximum queue size before eviction (default: 1000) */
+	maxQueueSize?: number
+	/** Maximum age for failed items in milliseconds (default: 7 days) */
+	maxFailedAgeMs?: number
+	/** Whether to backfill existing unsynced items on startup (default: false) */
+	backfillEnabled?: boolean
+}
diff --git a/apps/vscode/src/shared/tools.ts b/apps/vscode/src/shared/tools.ts
new file mode 100644
index 0000000..4332836
--- /dev/null
+++ b/apps/vscode/src/shared/tools.ts
@@ -0,0 +1,41 @@
+import { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index"
+import { FunctionDeclaration as GoogleTool } from "@google/genai"
+import { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
+
+type ClineTool = OpenAITool | AnthropicTool | GoogleTool
+
+// Define available tool ids
+export enum ClineDefaultTool {
+	ASK = "ask_followup_question",
+	ATTEMPT = "attempt_completion",
+	BASH = "execute_command",
+	FILE_EDIT = "replace_in_file",
+	FILE_READ = "read_file",
+	FILE_NEW = "write_to_file",
+	SEARCH = "search_files",
+	LIST_FILES = "list_files",
+	LIST_CODE_DEF = "list_code_definition_names",
+	BROWSER = "browser_action",
+	MCP_USE = "use_mcp_tool",
+	MCP_ACCESS = "access_mcp_resource",
+	MCP_DOCS = "load_mcp_documentation",
+	NEW_TASK = "new_task",
+	PLAN_MODE = "plan_mode_respond",
+	ACT_MODE = "act_mode_respond",
+	TODO = "focus_chain",
+	WEB_FETCH = "web_fetch",
+	WEB_SEARCH = "web_search",
+	CONDENSE = "condense",
+	SUMMARIZE_TASK = "summarize_task",
+	REPORT_BUG = "report_bug",
+	NEW_RULE = "new_rule",
+	APPLY_PATCH = "apply_patch",
+	USE_SKILL = "use_skill",
+	USE_SUBAGENTS = "use_subagents",
+}
+
+const dynamicToolUseNamesByNamespace = new Map<string, Set<string>>()
+
+export function setDynamicToolUseNames(namespace: string, names: string[]): void {
+	dynamicToolUseNamesByNamespace.set(namespace, new Set(names.map((name) => name.trim()).filter(Boolean)))
+}
diff --git a/apps/vscode/src/shared/utils/cline.ts b/apps/vscode/src/shared/utils/cline.ts
new file mode 100644
index 0000000..dd940e6
--- /dev/null
+++ b/apps/vscode/src/shared/utils/cline.ts
@@ -0,0 +1,3 @@
+export function isClineManagedProvider(provider: string | undefined) {
+	return provider === "cline" || provider === "cline-pass"
+}
diff --git a/apps/vscode/src/shared/utils/model-filters.ts b/apps/vscode/src/shared/utils/model-filters.ts
new file mode 100644
index 0000000..c8eb21c
--- /dev/null
+++ b/apps/vscode/src/shared/utils/model-filters.ts
@@ -0,0 +1,46 @@
+import type { ApiProvider } from "@shared/api"
+
+function normalizeModelId(modelId: string): string {
+	return modelId.trim().toLowerCase()
+}
+
+const CLINE_FREE_MODEL_EXCEPTIONS = ["minimax-m2", "devstral-2512", "arcee-ai/trinity-large"]
+
+function isClineFreeModelException(modelId: string): boolean {
+	const normalizedModelId = normalizeModelId(modelId)
+	return CLINE_FREE_MODEL_EXCEPTIONS.some((token) => normalizedModelId.includes(token))
+}
+
+/**
+ * Filters OpenRouter model IDs based on provider-specific rules.
+ * For Cline provider: excludes :free models (except known exception models)
+ * For OpenRouter/Vercel: excludes cline/ prefixed models
+ * @param modelIds Array of model IDs to filter
+ * @param provider The current API provider
+ * @param allowedFreeModelIds Optional list of Cline free model IDs to keep visible
+ * @returns Filtered array of model IDs
+ */
+export function filterOpenRouterModelIds(
+	modelIds: string[],
+	provider: ApiProvider,
+	allowedFreeModelIds: string[] = [],
+): string[] {
+	if (provider === "cline") {
+		const allowedFreeIdSet = new Set(allowedFreeModelIds.map((id) => normalizeModelId(id)))
+		// For Cline provider: exclude :free models, but keep known exception models
+		return modelIds.filter((id) => {
+			const normalizedModelId = normalizeModelId(id)
+			if (allowedFreeIdSet.has(normalizedModelId)) {
+				return true
+			}
+			if (isClineFreeModelException(normalizedModelId)) {
+				return true
+			}
+			// Filter out other :free models
+			return !normalizedModelId.includes(":free")
+		})
+	}
+
+	// For OpenRouter and Vercel AI Gateway providers: exclude Cline-specific models
+	return modelIds.filter((id) => !id.startsWith("cline/"))
+}
diff --git a/apps/vscode/src/shared/utils/reasoning-support.ts b/apps/vscode/src/shared/utils/reasoning-support.ts
new file mode 100644
index 0000000..2b36d84
--- /dev/null
+++ b/apps/vscode/src/shared/utils/reasoning-support.ts
@@ -0,0 +1,47 @@
+import { normalizeOpenaiReasoningEffort, type OpenaiReasoningEffort } from "../storage/types"
+
+export interface ClaudeOpusAdaptiveThinkingSettings {
+	enabled: boolean
+	effort?: OpenaiReasoningEffort
+}
+
+export function isClaudeOpusAdaptiveThinkingModel(modelId?: string): boolean {
+	if (!modelId) {
+		return false
+	}
+
+	const id = modelId.toLowerCase()
+	const adaptiveVersions = ["4-6", "4.6", "4-7", "4.7", "4-8", "4.8"]
+	return (
+		id.includes("claude-fable-5") ||
+		adaptiveVersions.some((version) => id.includes(`claude-opus-${version}`) || id.includes(`claude-${version}-opus`))
+	)
+}
+
+export function resolveClaudeOpusAdaptiveThinking(
+	reasoningEffort?: string,
+	legacyThinkingBudgetTokens?: number,
+): ClaudeOpusAdaptiveThinkingSettings {
+	if (reasoningEffort) {
+		const effort = normalizeOpenaiReasoningEffort(reasoningEffort)
+		return effort === "none" ? { enabled: false } : { enabled: true, effort }
+	}
+
+	return legacyThinkingBudgetTokens && legacyThinkingBudgetTokens > 0 ? { enabled: true, effort: "high" } : { enabled: false }
+}
+
+export function supportsReasoningEffortForModel(modelId?: string): boolean {
+	if (!modelId) {
+		return false
+	}
+
+	const id = modelId.toLowerCase()
+	return (
+		id.includes("gemini") ||
+		id.includes("gpt") ||
+		id.startsWith("openai/o") ||
+		id.includes("/o") ||
+		id.startsWith("o") ||
+		id.includes("grok")
+	)
+}
diff --git a/apps/vscode/src/shared/vsCodeSelectorUtils.test.ts b/apps/vscode/src/shared/vsCodeSelectorUtils.test.ts
new file mode 100644
index 0000000..13e2fc5
--- /dev/null
+++ b/apps/vscode/src/shared/vsCodeSelectorUtils.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest"
+import { parseVsCodeLmModelSelector, stringifyVsCodeLmModelSelector } from "./vsCodeSelectorUtils"
+
+describe("VS Code LM selector string encoding", () => {
+	it("round-trips vendor/family selectors", () => {
+		const selector = { vendor: "copilot", family: "claude-sonnet" }
+		const value = stringifyVsCodeLmModelSelector(selector)
+
+		expect(value).toBe("copilot/claude-sonnet")
+		expect(parseVsCodeLmModelSelector(value)).toEqual(selector)
+	})
+
+	it("preserves family values containing slashes", () => {
+		const selector = { vendor: "copilot", family: "openai/gpt-4o" }
+		const value = stringifyVsCodeLmModelSelector(selector)
+
+		expect(value).toBe("copilot/openai%2Fgpt-4o")
+		expect(parseVsCodeLmModelSelector(value)).toEqual(selector)
+	})
+
+	it("round-trips optional version and id segments", () => {
+		const selector = {
+			vendor: "copilot",
+			family: "anthropic/claude",
+			version: "2026/06",
+			id: "model/id",
+		}
+		const value = stringifyVsCodeLmModelSelector(selector)
+
+		expect(parseVsCodeLmModelSelector(value)).toEqual(selector)
+	})
+
+	it("keeps compatibility with old unencoded vendor/family values", () => {
+		expect(parseVsCodeLmModelSelector("copilot/claude-sonnet")).toEqual({
+			vendor: "copilot",
+			family: "claude-sonnet",
+		})
+	})
+})
diff --git a/apps/vscode/src/shared/vsCodeSelectorUtils.ts b/apps/vscode/src/shared/vsCodeSelectorUtils.ts
new file mode 100644
index 0000000..8fc1b16
--- /dev/null
+++ b/apps/vscode/src/shared/vsCodeSelectorUtils.ts
@@ -0,0 +1,57 @@
+import type { LanguageModelChatSelector } from "vscode"
+
+export const SELECTOR_SEPARATOR = "/"
+
+function encodeSelectorSegment(value: string): string {
+	return encodeURIComponent(value)
+}
+
+function decodeSelectorSegment(value: string): string {
+	try {
+		return decodeURIComponent(value)
+	} catch {
+		// A segment that isn't valid percent-encoding is passed through as-is, so
+		// a malformed or hand-written selector string still yields a usable value.
+		return value
+	}
+}
+
+export function stringifyVsCodeLmModelSelector(selector: LanguageModelChatSelector): string {
+	return [selector.vendor, selector.family, selector.version, selector.id]
+		.filter((part): part is string => Boolean(part))
+		.map(encodeSelectorSegment)
+		.join(SELECTOR_SEPARATOR)
+}
+
+/**
+ * Parse a stringified VS Code LM selector (`vendor/family[/version/id]`) back
+ * into a `LanguageModelChatSelector`.
+ *
+ * Selector segments are URI-encoded by stringifyVsCodeLmModelSelector so model
+ * family/id values can themselves contain `/` (common for BYOK providers such as
+ * `openai/gpt-4o`). Splitting on the separator therefore yields up to four
+ * positional segments (vendor, family, version, id); each is decoded
+ * independently, and missing trailing segments are simply omitted.
+ */
+export function parseVsCodeLmModelSelector(modelId: string | undefined): LanguageModelChatSelector {
+	if (!modelId) {
+		return {}
+	}
+
+	const parts = modelId.split(SELECTOR_SEPARATOR)
+	const [vendor, family, version, id] = parts.map(decodeSelectorSegment)
+	const selector: LanguageModelChatSelector = {}
+	if (vendor) {
+		selector.vendor = vendor
+	}
+	if (family) {
+		selector.family = family
+	}
+	if (version) {
+		selector.version = version
+	}
+	if (id) {
+		selector.id = id
+	}
+	return selector
+}
diff --git a/apps/vscode/src/standalone/cline-core.ts b/apps/vscode/src/standalone/cline-core.ts
new file mode 100644
index 0000000..46c62a3
--- /dev/null
+++ b/apps/vscode/src/standalone/cline-core.ts
@@ -0,0 +1,335 @@
+// Side-effect import: in the standalone (JetBrains/CLI) build (IS_STANDALONE==="true"),
+// loading @/shared/net installs the undici EnvHttpProxyAgent as the global dispatcher
+// so all HTTP/inference honors proxy/CA configuration. It must run before any network
+// I/O, so KEEP IT FIRST: do not add an import above this line that performs network
+// work at module-eval time, or proxy support silently breaks on JetBrains/CLI.
+import "@/shared/net"
+import { ExternalCommentReviewController } from "@hosts/external/ExternalCommentReviewController"
+import { ExternalDiffViewProvider } from "@hosts/external/ExternalDiffviewProvider"
+import { ExternalWebviewProvider } from "@hosts/external/ExternalWebviewProvider"
+import { ExternalHostBridgeClientManager } from "@hosts/external/host-bridge-client-manager"
+import { retryOperation } from "@utils/retry"
+import * as path from "path"
+import { initialize, tearDown } from "@/common"
+import { SqliteLockManager } from "@/core/locks/SqliteLockManager"
+import { WebviewProvider } from "@/core/webview"
+import { AuthHandler } from "@/hosts/external/AuthHandler"
+import { HostProvider } from "@/hosts/host-provider"
+import { DiffViewProvider } from "@/integrations/editor/DiffViewProvider"
+import { StandaloneTerminalManager } from "@/integrations/terminal"
+import { Logger } from "@/shared/services/Logger"
+import { createStorageContext } from "@/shared/storage/storage-context"
+import { HOSTBRIDGE_PORT, waitForHostBridgeReady } from "./hostbridge-client"
+import { startMemoryMonitoring, stopMemoryMonitoring } from "./memory-monitor"
+import { PROTOBUS_PORT, startProtobusService } from "./protobus-service"
+import { log } from "./utils"
+import { initializeContext } from "./vscode-context"
+
+let globalLockManager: SqliteLockManager | undefined
+
+async function main() {
+	log("\n\n\nStarting cline-core service...\n\n\n")
+	log(`Environment variables: ${JSON.stringify(process.env)}`)
+
+	// Parse command line arguments
+	const args = parseArgs()
+
+	// Show help if requested
+	if (args.help) {
+		showHelp()
+		process.exit(0)
+	}
+
+	// Resource loading assumes cwd is the installation directory
+	process.chdir(__dirname)
+
+	// Record where V8 will write heap snapshots if --heapsnapshot-near-heap-limit
+	// is active and the process approaches the heap limit. The snapshots are
+	// written to the current working directory.
+	log(`Heap snapshots (if triggered near OOM) will be written to: ${process.cwd()}`)
+
+	// Initialize context with optional custom directory from CLI
+	const { extensionContext, DATA_DIR, EXTENSION_DIR } = initializeContext(args.config)
+
+	// Configure ports - CLI args override everything
+	if (args.port) {
+		process.env.PROTOBUS_ADDRESS = `127.0.0.1:${args.port}`
+		// Auto-calculate hostbridge port if not specified
+		if (!args.hostBridgePort) {
+			process.env.HOST_BRIDGE_ADDRESS = `127.0.0.1:${HOSTBRIDGE_PORT}`
+		}
+	}
+	if (args.hostBridgePort) {
+		process.env.HOST_BRIDGE_ADDRESS = `127.0.0.1:${args.hostBridgePort}`
+	}
+
+	try {
+		// Set up error handlers FIRST (before any service starts)
+		setupGlobalErrorHandlers()
+
+		const hostAddress = await waitForHostBridgeReady()
+
+		// The host bridge should be available before creating the host provider because it depends on the host bridge.
+		setupHostProvider(extensionContext, EXTENSION_DIR, DATA_DIR)
+
+		// Create shared file-backed storage
+		const storageContext = createStorageContext()
+		const webviewProvider = await initialize(storageContext)
+
+		// Enable the localhost HTTP server that handles auth redirects.
+		AuthHandler.getInstance().setEnabled(true)
+
+		// Now this will throw instead of exit if binding fails
+		const protobusAddress = await startProtobusService(webviewProvider.controller)
+
+		// Initialize SQLite lock manager for instance registration
+		const dbPath = `${DATA_DIR}/locks.db`
+		globalLockManager = new SqliteLockManager({
+			dbPath,
+			instanceAddress: protobusAddress,
+		})
+
+		await globalLockManager.registerInstance({
+			hostAddress,
+		})
+		log(`Registered instance in SQLite locks: ${protobusAddress}`)
+
+		// Clean up any orphaned folder locks from dead instances
+		globalLockManager.cleanupOrphanedFolderLocks()
+
+		// Mark instance healthy after services are up
+		globalLockManager.touchInstance()
+
+		log("All services started successfully")
+
+		// Start periodic memory usage logging for diagnostics
+		startMemoryMonitoring()
+	} catch (err) {
+		log(`FATAL ERROR during startup: ${err}`)
+		log(`Cleaning up and shutting down...`)
+		await shutdownGracefully(globalLockManager)
+		process.exit(1)
+	}
+}
+
+function setupHostProvider(extensionContext: any, extensionDir: string, dataDir: string) {
+	const createWebview = (): WebviewProvider => {
+		return new ExternalWebviewProvider(extensionContext)
+	}
+	const createDiffView = (): DiffViewProvider => {
+		return new ExternalDiffViewProvider()
+	}
+	const createCommentReview = () => new ExternalCommentReviewController()
+	const createTerminalManager = () => new StandaloneTerminalManager()
+	const getCallbackUrl = (path: string, preferredPort?: number): Promise<string> => {
+		return AuthHandler.getInstance().getCallbackUrl(path, preferredPort)
+	}
+	// cline-core expects the binaries to be unpacked in the directory where it is running.
+	const getBinaryLocation = async (name: string): Promise<string> => path.join(process.cwd(), name)
+
+	HostProvider.initialize(
+		createWebview,
+		createDiffView,
+		createCommentReview,
+		createTerminalManager,
+		new ExternalHostBridgeClientManager(),
+		log,
+		getCallbackUrl,
+		getBinaryLocation,
+		extensionDir,
+		dataDir,
+	)
+}
+
+/**
+ * Sets up global error handlers to prevent the process from crashing
+ * on unhandled exceptions and promise rejections
+ */
+function setupGlobalErrorHandlers() {
+	// Handle unhandled exceptions
+	process.on("uncaughtException", (error: Error) => {
+		log(`ERROR: Uncaught exception: ${error.message}`)
+		log(`Stack trace: ${error.stack}`)
+		// Log the error but don't exit the process
+	})
+
+	// Handle unhandled promise rejections
+	process.on("unhandledRejection", (reason: any, _promise: Promise<any>) => {
+		log(`ERROR: Unhandled promise rejection: ${reason}`)
+		if (reason instanceof Error) {
+			log(`Stack trace: ${reason.stack}`)
+		}
+		// Log the error but don't exit the process
+	})
+
+	// Handle process warnings (optional, for debugging)
+	process.on("warning", (warning: Error) => {
+		log(`Process Warning: ${warning.name}: ${warning.message}`)
+	})
+
+	// On abnormal exit (e.g. near-OOM crash), scan the working directory for
+	// any .heapsnapshot files that V8 wrote on its way out and log their paths
+	// and sizes. This is best-effort: if V8 has no heap left, this handler may
+	// not run at all, but when it does it pinpoints the diagnostic data for
+	// anyone reading the log after the fact.
+	process.on("exit", (code) => {
+		if (code !== 0) {
+			try {
+				const fs = require("fs")
+				const snapshots = fs.readdirSync(process.cwd()).filter((f: string) => f.endsWith(".heapsnapshot"))
+				if (snapshots.length > 0) {
+					log(`[MEMORY] Heap snapshots available for analysis:`)
+					for (const snap of snapshots) {
+						const fullPath = path.join(process.cwd(), snap)
+						const sizeMB = Math.round(fs.statSync(fullPath).size / (1024 * 1024))
+						log(`[MEMORY]   ${fullPath} (${sizeMB}MB)`)
+					}
+					log(`[MEMORY] To analyze: open Chrome DevTools → Memory tab → Load profile`)
+				}
+			} catch {
+				// Best-effort: if we can't scan the directory (e.g. the process
+				// is too far gone to do I/O), swallow the error silently.
+			}
+		}
+	})
+
+	// Graceful shutdown handlers
+	process.on("SIGINT", () => {
+		log("Received SIGINT, shutting down gracefully...")
+		shutdownGracefully(globalLockManager).catch((err) => {
+			log(`Error during SIGINT shutdown: ${err}`)
+			process.exit(1)
+		})
+	})
+
+	process.on("SIGTERM", () => {
+		log("Received SIGTERM, shutting down gracefully...")
+		shutdownGracefully(globalLockManager).catch((err) => {
+			log(`Error during SIGTERM shutdown: ${err}`)
+			process.exit(1)
+		})
+	})
+}
+
+/**
+ * Request host bridge shutdown with retry logic and timeout handling.
+ * Uses best-effort approach - logs failures but doesn't block shutdown.
+ */
+async function requestHostBridgeShutdown(): Promise<void> {
+	try {
+		await retryOperation(3, 2000, async () => {
+			await HostProvider.env.shutdown({})
+		})
+		log("Host bridge shutdown requested successfully")
+	} catch (error) {
+		log(`Warning: Failed to request host bridge shutdown: ${error}`)
+		log("Proceeding with cleanup")
+	}
+}
+
+/**
+ * Gracefully shutdown the cline-core process by:
+ * 1. Calling shutdown RPC on the paired host bridge
+ * 2. Cleaning up the lock manager entry
+ * 3. Tearing down services
+ * 4. Exiting the process
+ */
+async function shutdownGracefully(lockManager?: SqliteLockManager) {
+	try {
+		// Step 1: Tell the paired host bridge to shut down
+		log("Requesting host bridge shutdown...")
+		if (HostProvider.isInitialized()) {
+			await requestHostBridgeShutdown()
+		} else {
+			log("Warning: HostProvider not initialized, cannot request shutdown")
+		}
+
+		// Step 2: Clean up lock manager entry
+		log("Cleaning up lock manager entry...")
+		try {
+			// First unregister the instance
+			lockManager?.unregisterInstance()
+			// Then clean up any folder locks held by this instance
+			lockManager?.cleanupOrphanedFolderLocks()
+			lockManager?.close()
+			log("Lock manager entry cleaned up successfully")
+		} catch (error) {
+			log(`Warning: Failed to clean up lock manager: ${error}`)
+		}
+
+		// Stop memory monitoring and capture final snapshot
+		stopMemoryMonitoring()
+
+		// Step 3: Tear down services
+		log("Tearing down services...")
+		try {
+			await tearDown()
+			log("Services torn down successfully")
+		} catch (error) {
+			log(`Warning: Failed to tear down services: ${error}`)
+		}
+
+		log("Graceful shutdown completed")
+	} catch (error) {
+		log(`Error during graceful shutdown: ${error}`)
+	} finally {
+		// Step 4: Exit the process
+		process.exit(0)
+	}
+}
+
+// Parse command line arguments
+interface CliArgs {
+	port?: number
+	hostBridgePort?: number
+	config?: string
+	help?: boolean
+}
+
+function parseArgs(): CliArgs {
+	const args: CliArgs = {}
+	const argv = process.argv.slice(2)
+
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i]
+		switch (arg) {
+			case "--port":
+			case "-p":
+				args.port = Number.parseInt(argv[++i], 10)
+				break
+			case "--host-bridge-port":
+				args.hostBridgePort = Number.parseInt(argv[++i], 10)
+				break
+			case "--config":
+			case "-c":
+				args.config = argv[++i]
+				break
+			case "--help":
+			case "-h":
+				args.help = true
+				break
+		}
+	}
+
+	return args
+}
+
+function showHelp() {
+	Logger.log(`
+Cline Core - Standalone Server
+
+Usage: node cline-core.js [options]
+
+Options:
+  -p, --port <port>              Port for the main gRPC service (default: ${PROTOBUS_PORT})
+  --host-bridge-port <port>      Port for the host bridge service (default: ${HOSTBRIDGE_PORT})
+  -c, --config <path>            Directory for Cline data storage (default: ~/.cline)
+  -h, --help                     Show this help message
+
+Environment Variables:
+  PROTOBUS_ADDRESS              Override the main service address (format: host:port)
+  HOST_BRIDGE_ADDRESS            Override the host bridge address (format: host:port)
+`)
+}
+
+main()
diff --git a/apps/vscode/src/standalone/hostbridge-client.ts b/apps/vscode/src/standalone/hostbridge-client.ts
new file mode 100644
index 0000000..ee8e32a
--- /dev/null
+++ b/apps/vscode/src/standalone/hostbridge-client.ts
@@ -0,0 +1,48 @@
+import * as grpc from "@grpc/grpc-js"
+import * as protoLoader from "@grpc/proto-loader"
+import * as health from "grpc-health-check"
+import { log } from "./utils"
+
+export const HOSTBRIDGE_PORT = 26041
+
+export async function waitForHostBridgeReady(timeoutMs = 60000, intervalMs = 500): Promise<string> {
+	const address = process.env.HOST_BRIDGE_ADDRESS || `127.0.0.1:${HOSTBRIDGE_PORT}`
+	const client = createHealthClient(address)
+	const deadline = Date.now() + timeoutMs
+	try {
+		while (Date.now() < deadline) {
+			const ok = await checkHealthOnce(client)
+			if (ok) {
+				log(`HostBridge serving at ${address}; continuing startup`)
+				return address
+			}
+			log("Waiting for hostbridge to be ready...")
+			await new Promise((r) => setTimeout(r, intervalMs))
+		}
+	} finally {
+		client.close()
+	}
+	throw new Error(`HostBridge health check timed out after ${timeoutMs}ms`)
+}
+
+// Client-side health check for the hostbridge service (kept at bottom for clarity)
+const SERVING_STATUS = 1
+function createHealthClient(address: string) {
+	const healthDef = protoLoader.loadSync(health.protoPath)
+	const grpcObj = grpc.loadPackageDefinition(healthDef) as unknown as any
+	const Health = grpcObj.grpc.health.v1.Health
+	const opts: grpc.ChannelOptions = { "grpc.enable_http_proxy": 0 }
+	return new Health(address, grpc.credentials.createInsecure(), opts)
+}
+
+async function checkHealthOnce(client: any): Promise<boolean> {
+	return new Promise<boolean>((resolve) => {
+		client.check({ service: "" }, (err: unknown, resp: any) => {
+			if (err) {
+				console.debug(err.toString())
+				return resolve(false)
+			}
+			return resolve(resp?.status === SERVING_STATUS)
+		})
+	})
+}
diff --git a/apps/vscode/src/standalone/memory-monitor.ts b/apps/vscode/src/standalone/memory-monitor.ts
new file mode 100644
index 0000000..373db55
--- /dev/null
+++ b/apps/vscode/src/standalone/memory-monitor.ts
@@ -0,0 +1,69 @@
+import { log } from "./utils"
+
+const MEMORY_LOG_INTERVAL_MS = 5 * 60 * 1000 // 5 minutes
+const BYTES_TO_MB = 1024 * 1024
+
+let memoryMonitorInterval: ReturnType<typeof setInterval> | null = null
+
+/**
+ * Logs current memory usage in a structured, grep-friendly format.
+ * Called periodically by the monitor timer, and also exported so that
+ * other code can call it on-demand at important lifecycle moments
+ * (e.g., after task completion, after context truncation).
+ */
+function logMemoryUsage(): void {
+	const mem = process.memoryUsage()
+	const uptime = Math.round(process.uptime())
+
+	const rss = Math.round(mem.rss / BYTES_TO_MB)
+	const heapUsed = Math.round(mem.heapUsed / BYTES_TO_MB)
+	const heapTotal = Math.round(mem.heapTotal / BYTES_TO_MB)
+	const external = Math.round(mem.external / BYTES_TO_MB)
+	const arrayBuffers = Math.round(mem.arrayBuffers / BYTES_TO_MB)
+
+	log(
+		`[MEMORY] rss=${rss}MB heapUsed=${heapUsed}MB heapTotal=${heapTotal}MB ` +
+			`external=${external}MB arrayBuffers=${arrayBuffers}MB uptime=${uptime}s`,
+	)
+}
+
+/**
+ * Starts periodic memory usage logging.
+ *
+ * Logs immediately on start to capture a baseline, then repeats every
+ * MEMORY_LOG_INTERVAL_MS (5 minutes). The timer is unref'd so it won't
+ * prevent Node.js from exiting when all other work is done.
+ */
+export function startMemoryMonitoring(): void {
+	if (memoryMonitorInterval) {
+		return // Already running
+	}
+
+	// Log immediately on start to capture baseline
+	logMemoryUsage()
+
+	memoryMonitorInterval = setInterval(logMemoryUsage, MEMORY_LOG_INTERVAL_MS)
+
+	// IMPORTANT: unref() tells Node.js that this timer is "optional" — it
+	// should not keep the event loop alive by itself. Without this call,
+	// the process could never exit cleanly because it would always be
+	// waiting for the next 5-minute interval tick. Node.js exits when
+	// there are no more active handles (timers, sockets, etc.) keeping
+	// the event loop alive. unref() removes this timer from that count.
+	memoryMonitorInterval.unref()
+
+	log("[MEMORY] Periodic memory monitoring started (interval: 5m)")
+}
+
+/**
+ * Stops periodic memory usage logging and logs a final snapshot.
+ * Called during graceful shutdown to capture end-of-life memory state.
+ */
+export function stopMemoryMonitoring(): void {
+	if (memoryMonitorInterval) {
+		logMemoryUsage() // Final snapshot
+		clearInterval(memoryMonitorInterval)
+		memoryMonitorInterval = null
+		log("[MEMORY] Periodic memory monitoring stopped")
+	}
+}
diff --git a/apps/vscode/src/standalone/protobus-service.ts b/apps/vscode/src/standalone/protobus-service.ts
new file mode 100644
index 0000000..2ef5183
--- /dev/null
+++ b/apps/vscode/src/standalone/protobus-service.ts
@@ -0,0 +1,115 @@
+import { Controller } from "@core/controller"
+import { StreamingResponseHandler } from "@core/controller/grpc-handler"
+import { addProtobusServices } from "@generated/hosts/standalone/protobus-server-setup"
+import * as grpc from "@grpc/grpc-js"
+
+import { ReflectionService } from "@grpc/reflection"
+import { GrpcHandler, GrpcStreamingResponseHandler } from "@hosts/external/grpc-types"
+import * as health from "grpc-health-check"
+import { getPackageDefinition, log } from "./utils"
+
+export const PROTOBUS_PORT = 26040
+
+export function startProtobusService(controller: Controller): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const server = new grpc.Server()
+
+		// Set up health check.
+		const healthImpl = new health.HealthImplementation({ "": "SERVING" })
+		healthImpl.addToServer(server)
+
+		// Add all the handlers for the ProtoBus services to the server.
+		addProtobusServices(server, controller, wrapHandler, wrapStreamingResponseHandler)
+
+		// Create reflection service with protobus service names
+		const packageDefinition = getPackageDefinition()
+		const reflection = new ReflectionService(packageDefinition, {
+			services: getProtobusServiceNames(packageDefinition),
+		})
+		reflection.addToServer(server)
+
+		// Start the server.
+		const host = process.env.PROTOBUS_ADDRESS || `127.0.0.1:${PROTOBUS_PORT}`
+		server.bindAsync(host, grpc.ServerCredentials.createInsecure(), (err) => {
+			if (err) {
+				log(`Could not start ProtoBus service: Failed to bind to ${host}, port may be unavailable. ${err.message}`)
+				reject(new Error(`Failed to bind ProtoBus to ${host}: ${err.message}`))
+				return
+			}
+			server.start()
+			log(`ProtoBus gRPC server listening on ${host}`)
+			resolve(host)
+		})
+	})
+}
+
+function getProtobusServiceNames(packageDefinition: { [x: string]: any }): string[] {
+	// Filter service names to only include cline services
+	const protobusServiceNames = Object.keys(packageDefinition).filter(
+		(name) => name.startsWith("cline.") || name.startsWith("grpc.health"),
+	)
+	return protobusServiceNames
+}
+
+/**
+ * Wraps a Promise-based handler function to make it compatible with gRPC's callback-based API.
+ * This function converts an async handler that returns a Promise into a function that uses
+ * the gRPC callback pattern.
+ *
+ * @template TRequest - The type of the request object
+ * @template TResponse - The type of the response object
+ * @param handler - The Promise-based handler function to wrap
+ * @param controllerInstance - The controller instance to pass to the handler
+ * @returns A gRPC-compatible callback-style handler function
+ */
+function wrapHandler<TRequest, TResponse>(
+	handler: GrpcHandler<TRequest, TResponse>,
+	controller: Controller,
+): grpc.handleUnaryCall<TRequest, TResponse> {
+	return async (call: grpc.ServerUnaryCall<TRequest, TResponse>, callback: grpc.sendUnaryData<TResponse>) => {
+		try {
+			log(`ProtoBus request: ${call.getPath()}`)
+			const result = await handler(controller, call.request)
+			callback(null, result)
+		} catch (err: any) {
+			log(`ProtoBus handler error: ${call.getPath()}\n${err.stack}`)
+			callback({
+				code: grpc.status.INTERNAL,
+				message: err.message || "Internal error",
+			} as grpc.ServiceError)
+		}
+	}
+}
+
+function wrapStreamingResponseHandler<TRequest, TResponse>(
+	handler: GrpcStreamingResponseHandler<TRequest, TResponse>,
+	controller: Controller,
+): grpc.handleServerStreamingCall<TRequest, TResponse> {
+	return async (call: grpc.ServerWritableStream<TRequest, TResponse>) => {
+		try {
+			const requestId = call.metadata.get("request-id").pop()?.toString()
+			log(`ProtoBus gRPC streaming request: ${call.getPath()}`)
+
+			const responseHandler: StreamingResponseHandler<TResponse> = (response, isLast, _sequenceNumber) => {
+				try {
+					call.write(response) // Use a bound version of call.write to maintain proper 'this' context
+
+					if (isLast === true) {
+						log(`Closing ProtoBus stream for ${requestId}`)
+						call.end()
+					}
+					return Promise.resolve()
+				} catch (error) {
+					return Promise.reject(error)
+				}
+			}
+			await handler(controller, call.request, responseHandler, requestId)
+		} catch (err: any) {
+			log(`ProtoBus handler error: ${call.getPath()}\n${err.stack}`)
+			call.destroy({
+				code: grpc.status.INTERNAL,
+				message: err.message || "Internal error",
+			} as grpc.ServiceError)
+		}
+	}
+}
diff --git a/apps/vscode/src/standalone/utils.ts b/apps/vscode/src/standalone/utils.ts
new file mode 100644
index 0000000..06cfc32
--- /dev/null
+++ b/apps/vscode/src/standalone/utils.ts
@@ -0,0 +1,54 @@
+import * as protoLoader from "@grpc/proto-loader"
+import * as fs from "fs"
+import * as health from "grpc-health-check"
+import { StreamingCallbacks } from "@/hosts/host-provider-types"
+
+const log = (...args: unknown[]) => {
+	const now = new Date()
+	const year = now.getFullYear()
+	const month = String(now.getMonth() + 1).padStart(2, "0")
+	const day = String(now.getDate()).padStart(2, "0")
+	const hours = String(now.getHours()).padStart(2, "0")
+	const minutes = String(now.getMinutes()).padStart(2, "0")
+	const seconds = String(now.getSeconds()).padStart(2, "0")
+	const milliseconds = String(now.getMilliseconds()).padStart(3, "0")
+
+	const timestamp = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}`
+
+	console.log(`[${timestamp}]`, "#bot.cline.server.ts", ...args)
+}
+
+function getPackageDefinition() {
+	// Load service definitions.
+	const descriptorSet = fs.readFileSync("proto/descriptor_set.pb")
+	const options = { longs: Number } // Encode int64 fields as numbers
+	const descriptorDefs = protoLoader.loadFileDescriptorSetFromBuffer(descriptorSet, options)
+	const healthDef = protoLoader.loadSync(health.protoPath)
+	const packageDefinition = { ...descriptorDefs, ...healthDef }
+	return packageDefinition
+}
+
+/**
+ * Converts an AsyncIterable to a callback-based API
+ * @param stream The AsyncIterable stream to process
+ * @param callbacks The callbacks to invoke for stream events
+ */
+async function asyncIteratorToCallbacks<T>(stream: AsyncIterable<T>, callbacks: StreamingCallbacks<T>): Promise<void> {
+	try {
+		// Process each item in the stream
+		for await (const response of stream) {
+			callbacks.onResponse && callbacks.onResponse(response)
+		}
+		// Stream completed successfully
+		callbacks.onComplete && callbacks.onComplete()
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err))
+		if (callbacks.onError) {
+			callbacks.onError(error)
+		} else {
+			log(`Host bridge RPC error: ${error}`)
+		}
+	}
+}
+
+export { getPackageDefinition, log, asyncIteratorToCallbacks }
diff --git a/apps/vscode/src/standalone/vscode-context-utils.ts b/apps/vscode/src/standalone/vscode-context-utils.ts
new file mode 100644
index 0000000..ab42523
--- /dev/null
+++ b/apps/vscode/src/standalone/vscode-context-utils.ts
@@ -0,0 +1,153 @@
+import * as fs from "fs"
+import type { EnvironmentVariableMutator, EnvironmentVariableMutatorOptions, EnvironmentVariableScope } from "vscode"
+import * as vscode from "vscode"
+export class SecretStore implements vscode.SecretStorage {
+	private data: JsonKeyValueStore<string>
+	private readonly _onDidChange = new EventEmitter<vscode.SecretStorageChangeEvent>()
+
+	constructor(filepath: string) {
+		this.data = new JsonKeyValueStore(filepath)
+	}
+
+	readonly onDidChange: vscode.Event<vscode.SecretStorageChangeEvent> = this._onDidChange.event
+
+	get(key: string): Thenable<string | undefined> {
+		return Promise.resolve(this.data.get(key))
+	}
+
+	store(key: string, value: string): Thenable<void> {
+		this.data.put(key, value)
+		this._onDidChange.fire({ key })
+		return Promise.resolve()
+	}
+
+	delete(key: string): Thenable<void> {
+		this.data.delete(key)
+		this._onDidChange.fire({ key })
+		return Promise.resolve()
+	}
+}
+
+// Create a class that implements Memento interface with the required setKeysForSync method
+export class MementoStore implements vscode.Memento {
+	private data: JsonKeyValueStore<any>
+
+	constructor(filepath: string) {
+		this.data = new JsonKeyValueStore(filepath)
+	}
+	keys(): readonly string[] {
+		return Array.from(this.data.keys())
+	}
+	get<T>(key: string): T | undefined {
+		return this.data.get(key) as T
+	}
+	update(key: string, value: any): Thenable<void> {
+		this.data.put(key, value)
+		return Promise.resolve()
+	}
+	setKeysForSync(_keys: readonly string[]): void {
+		throw new Error("Method not implemented.")
+	}
+}
+
+// Simple implementation of VSCode's EventEmitter
+type EventCallback<T> = (e: T) => any
+class EventEmitter<T> {
+	private listeners: EventCallback<T>[] = []
+
+	event: vscode.Event<T> = (listener: EventCallback<T>) => {
+		this.listeners.push(listener)
+		return {
+			dispose: () => {
+				const index = this.listeners.indexOf(listener)
+				if (index !== -1) {
+					this.listeners.splice(index, 1)
+				}
+			},
+		}
+	}
+
+	fire(data: T): void {
+		this.listeners.forEach((listener) => listener(data))
+	}
+}
+
+/** A simple key-value store for secrets backed by a JSON file. This is not secure, and it is not thread-safe. */
+export class JsonKeyValueStore<T> {
+	private data = new Map<string, T>()
+	private filePath: string
+
+	constructor(filePath: string) {
+		this.filePath = filePath
+		this.load()
+	}
+
+	get(key: string): T | undefined {
+		return this.data.get(key)
+	}
+
+	put(key: string, value: T): void {
+		this.data.set(key, value)
+		this.save()
+	}
+
+	delete(key: string): void {
+		this.data.delete(key)
+		this.save()
+	}
+	keys(): Iterable<string> | ArrayLike<string> {
+		return this.data.keys()
+	}
+	private load(): void {
+		if (fs.existsSync(this.filePath)) {
+			const data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"))
+			Object.entries(data).forEach(([k, v]) => {
+				this.data.set(k, v as T)
+			})
+		}
+	}
+	private save(): void {
+		// Use mode 0o600 to restrict file permissions to owner read/write only (fixes #7778)
+		fs.writeFileSync(this.filePath, JSON.stringify(Object.fromEntries(this.data), null, 2), { mode: 0o600 })
+	}
+}
+
+/** This is not used in cline, none of the methods are implemented. */
+export class EnvironmentVariableCollection implements EnvironmentVariableCollection {
+	persistent = false
+	description: string | undefined = undefined
+	replace(_variable: string, _value: string, _options?: EnvironmentVariableMutatorOptions): void {
+		throw new Error("Method not implemented.")
+	}
+	append(_variable: string, _value: string, _options?: EnvironmentVariableMutatorOptions): void {
+		throw new Error("Method not implemented.")
+	}
+	prepend(_variable: string, _value: string, _options?: EnvironmentVariableMutatorOptions): void {
+		throw new Error("Method not implemented.")
+	}
+	get(_variable: string): EnvironmentVariableMutator | undefined {
+		throw new Error("Method not implemented.")
+	}
+	forEach(
+		_callback: (variable: string, mutator: EnvironmentVariableMutator, collection: EnvironmentVariableCollection) => any,
+		_thisArg?: any,
+	): void {
+		throw new Error("Method not implemented.")
+	}
+	delete(_variable: string): void {
+		throw new Error("Method not implemented.")
+	}
+	clear(): void {
+		throw new Error("Method not implemented.")
+	}
+	[Symbol.iterator](): Iterator<[variable: string, mutator: EnvironmentVariableMutator], any, any> {
+		throw new Error("Method not implemented.")
+	}
+	getScoped(_scope: EnvironmentVariableScope): EnvironmentVariableCollection {
+		throw new Error("Method not implemented.")
+	}
+}
+
+export function readJson(filePath: string): any {
+	return JSON.parse(fs.readFileSync(filePath, "utf8"))
+}
diff --git a/apps/vscode/src/standalone/vscode-context.ts b/apps/vscode/src/standalone/vscode-context.ts
new file mode 100644
index 0000000..82f6f11
--- /dev/null
+++ b/apps/vscode/src/standalone/vscode-context.ts
@@ -0,0 +1,78 @@
+import { mkdirSync } from "node:fs"
+import os from "os"
+import path from "path"
+import type { Extension, ExtensionContext } from "vscode"
+import { ExtensionKind, ExtensionMode } from "vscode"
+import { URI } from "vscode-uri"
+import { ExtensionRegistryInfo } from "@/registry"
+import { log } from "./utils"
+import { EnvironmentVariableCollection, MementoStore, readJson, SecretStore } from "./vscode-context-utils"
+
+log("Running standalone cline", ExtensionRegistryInfo.version)
+log(`CLINE_ENVIRONMENT: ${process.env.CLINE_ENVIRONMENT}`)
+
+// WE WILL HAVE TO MIGRATE THIS FROM DATA TO v1 LATER
+const SETTINGS_SUBFOLDER = "data"
+
+export function initializeContext(clineDir?: string) {
+	const CLINE_DIR = clineDir || process.env.CLINE_DIR || `${os.homedir()}/.cline`
+	const DATA_DIR = path.join(CLINE_DIR, SETTINGS_SUBFOLDER)
+	const INSTALL_DIR = process.env.INSTALL_DIR || __dirname
+	const WORKSPACE_STORAGE_DIR = process.env.WORKSPACE_STORAGE_DIR || path.join(DATA_DIR, "workspace")
+
+	mkdirSync(DATA_DIR, { recursive: true })
+	mkdirSync(WORKSPACE_STORAGE_DIR, { recursive: true })
+	log("Using settings dir:", DATA_DIR)
+
+	const EXTENSION_DIR = path.join(INSTALL_DIR, "extension")
+	const EXTENSION_MODE = process.env.IS_DEV === "true" ? ExtensionMode.Development : ExtensionMode.Production
+
+	const extension: Extension<void> = {
+		id: ExtensionRegistryInfo.id,
+		isActive: true,
+		extensionPath: EXTENSION_DIR,
+		extensionUri: URI.file(EXTENSION_DIR),
+		packageJSON: readJson(path.join(EXTENSION_DIR, "package.json")),
+		exports: undefined, // There are no API exports in the standalone version.
+		activate: async () => {},
+		extensionKind: ExtensionKind.UI,
+	}
+
+	const extensionContext: ExtensionContext = {
+		extension: extension,
+		extensionMode: EXTENSION_MODE,
+
+		// Set up KV stores.
+		globalState: new MementoStore(path.join(DATA_DIR, "globalState.json")),
+		secrets: new SecretStore(path.join(DATA_DIR, "secrets.json")),
+
+		// Set up URIs.
+		storageUri: URI.file(WORKSPACE_STORAGE_DIR),
+		storagePath: WORKSPACE_STORAGE_DIR, // Deprecated, not used in cline.
+		globalStorageUri: URI.file(DATA_DIR),
+		globalStoragePath: DATA_DIR, // Deprecated, not used in cline.
+
+		// Logs are global per extension, not per workspace.
+		logUri: URI.file(DATA_DIR),
+		logPath: DATA_DIR, // Deprecated, not used in cline.
+
+		extensionUri: URI.file(EXTENSION_DIR),
+		extensionPath: EXTENSION_DIR, // Deprecated, not used in cline.
+		asAbsolutePath: (relPath: string) => path.join(EXTENSION_DIR, relPath),
+
+		subscriptions: [], // These need to be destroyed when the extension is deactivated.
+
+		environmentVariableCollection: new EnvironmentVariableCollection(),
+
+		// Workspace state is per project/workspace when WORKSPACE_STORAGE_DIR is provided by the host.
+		workspaceState: new MementoStore(path.join(WORKSPACE_STORAGE_DIR, "workspaceState.json")),
+	}
+
+	log("Finished loading vscode context...")
+
+	return {
+		extensionContext,
+		DATA_DIR,
+		EXTENSION_DIR,
+	}
+}
diff --git a/apps/vscode/src/test/bun-test-preload.ts b/apps/vscode/src/test/bun-test-preload.ts
new file mode 100644
index 0000000..2f90cbd
--- /dev/null
+++ b/apps/vscode/src/test/bun-test-preload.ts
@@ -0,0 +1,213 @@
+// Preload for `bun test` (registered via bunfig.toml [test] preload). It makes
+// the SDK-adapter and model-catalog unit tests — written against vitest's `vi`
+// API and module aliases — run under `bun test`.
+//
+// TODO: migrate these suites to native `bun:test` (use `mock.module` / `spyOn`
+// directly and stub `vscode`/`@cline/core` per-file) and delete this preload's
+// `vi` shim. Until then the detail below documents exactly why the shim is shaped
+// the way it is.
+//
+// Two specifiers have real on-disk implementations that must be shadowed with
+// lightweight stubs in unit tests:
+//
+//   vscode       -> src/test/vscode-vitest-stub.ts     (no VS Code host under bun)
+//   @cline/core  -> src/test/cline-core-vitest-stub.ts (lightweight SDK stub)
+//
+// bun's runtime plugin `onResolve` hook does NOT intercept these (`vscode` is
+// host/builtin-like and `@cline/core` is a symlinked workspace package — both
+// resolve below the JS plugin resolver). `mock.module()` is what works: it
+// registers an in-memory override that takes precedence for the whole test
+// process. (Other workspace packages — @cline/llms, @cline/shared,
+// @cline/shared/storage — and the tsconfig `paths` aliases resolve on their own.)
+//
+// bun's ESM linker statically validates every named import against the names on
+// the mock namespace. The stub only implements the @cline/core exports these
+// tests exercise, but other modules in the import graph statically import
+// additional names (e.g. `prepareRemoteConfigCoreIntegration`, `ClineCore`,
+// `createMcpTools`); a missing name is a hard "Export named 'X' not found" link
+// error. So we seed the mock namespace with every name the real @cline/core
+// exports (value `undefined`) and overlay the stub on top: stub names keep stub
+// behavior, every other valid import links as `undefined`.
+//
+// Importing the real package here is safe: the preload runs before any test
+// file, so this is the only point the real module is linked, and we only read
+// its export *names*, never its behavior (the mock shadows it everywhere tests look).
+import { vi as bunVi, mock } from "bun:test"
+import * as realClineCore from "@cline/core"
+import * as clineCoreStub from "./cline-core-vitest-stub"
+import * as vscodeStub from "./vscode-vitest-stub"
+
+const clineCoreNamespace: Record<string, unknown> = {}
+for (const name of Object.keys(realClineCore)) {
+	clineCoreNamespace[name] = undefined
+}
+Object.assign(clineCoreNamespace, clineCoreStub)
+
+mock.module("@cline/core", () => clineCoreNamespace)
+
+// `vscode`: the stub provides both named exports (Position, Uri, …) and a
+// default export (the namespace object). Preserve both shapes so `import * as
+// vscode from "vscode"` and `import vscode from "vscode"` both work.
+mock.module("vscode", () => ({ ...vscodeStub, default: vscodeStub.default }))
+
+// `vitest`: the SDK-adapter and model-catalog unit tests import test primitives
+// and the `vi` helper namespace from "vitest". bun test provides describe/it/
+// expect/etc. and a partial `vi` object under `bun:test`, but does NOT register
+// a `vitest` module, so we alias one here, backed by the real bun:test
+// implementations wherever a 1:1 mapping exists. The remaining vitest-only
+// helpers (`vi.hoisted`, `vi.mock`, `vi.waitFor`, `vi.importActual`,
+// `vi.mocked`, `vi.resetModules`) are shimmed on top:
+//
+//   • vi.hoisted(fn)      — vitest hoists these above imports; under bun's ESM
+//                           ordering all imports settle before top-level test
+//                           code runs, so simply executing the factory in place
+//                           is sufficient (the returned object is referenced by
+//                           later vi.mock factory closures, which are lazy).
+//   • vi.mock(spec, fac)  — mapped to bun's mock.module. bun applies module
+//                           mocks retroactively to already-linked imports, which
+//                           matches vitest's hoisted-mock observable behavior.
+//   • vi.waitFor(fn,opts) — poll fn until it resolves/returns without throwing.
+//   • vi.importActual(s)  — the module as resolved by vitest's `resolve.alias`
+//                           BEFORE `vi.mock` is layered on. For specifiers we
+//                           substitute via `mock.module` in this preload
+//                           (@cline/core, vscode), calling bun's `import()` from
+//                           inside a `vi.mock(sameSpecifier)` factory re-enters
+//                           the in-flight mock and DEADLOCKS. So we serve those
+//                           from a registry of the pre-built "actual" namespaces
+//                           (the stub modules vitest's alias points at) and only
+//                           fall back to real `import()` for everything else.
+//   • vi.mocked(v)        — identity (a TypeScript typing helper at runtime).
+//   • vi.resetModules()   — no-op; bun has no module registry to reset and these
+//                           suites re-establish their mocks per-test.
+const viWaitFor = async <T>(predicate: () => T | Promise<T>, options?: { timeout?: number; interval?: number }): Promise<T> => {
+	const timeout = options?.timeout ?? 1000
+	const interval = options?.interval ?? 20
+	const deadline = Date.now() + timeout
+	let lastError: unknown
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		try {
+			return await predicate()
+		} catch (error) {
+			lastError = error
+			if (Date.now() >= deadline) {
+				throw lastError
+			}
+			await new Promise((resolve) => setTimeout(resolve, interval))
+		}
+	}
+}
+
+// IMPORTANT: bun has a *built-in* `vitest` → `bun:test` compatibility shim that
+// takes precedence over `mock.module("vitest", …)` (the alias does not fire for
+// the `vitest` specifier — verified empirically). The `vi` object that bun
+// hands to `import { vi } from "vitest"` is the SAME singleton as
+// `import { vi } from "bun:test"`. So instead of registering a fake module, we
+// augment that shared `vi` singleton in place with the vitest-only helpers
+// bun's compat layer omits.
+// Registry of pre-built "actual" namespaces for the specifiers this preload
+// substitutes. `importActual` serves these directly to avoid the re-entrant
+// mock-factory deadlock described above.
+const actualNamespaceRegistry: Record<string, unknown> = {
+	"@cline/core": clineCoreNamespace,
+	vscode: { ...vscodeStub, default: vscodeStub.default },
+}
+
+// `vi.mock` → `mock.module`, with two adaptations to match vitest semantics
+// that bun's `mock.module` lacks:
+//
+//  (1) vitest passes an `importOriginal` helper to the factory; bun does not.
+//      We pass one (resolving from the "actual" registry, see importActual).
+//
+//  (2) bun's `mock.module` DEADLOCKS if the factory is an async function that
+//      actually suspends on an `await` — bun blocks the importing thread on the
+//      returned promise without pumping the microtask queue (verified
+//      empirically; bun's docs only ever show async factories that return
+//      synchronously). vitest, by contrast, awaits async `vi.mock` factories
+//      (e.g. ones that `await importOriginal()` / `await vi.importActual(...)`).
+//      To bridge this without rewriting test files we invoke the factory
+//      OURSELVES:
+//        • sync result  → register it directly.
+//        • promise result → register a synchronous placeholder FIRST (seeded
+//          with the original module's export names so consumers' named imports
+//          link), then re-register synchronously with the resolved namespace
+//          once the promise settles. A plain deferred-only register does NOT
+//          propagate to already-linked *named* imports — the up-front
+//          placeholder is what makes the live-binding update stick. `vi.mock`
+//          runs at module top level and tests only run after an await boundary,
+//          so the resolved registration is always in place before the first
+//          test executes.
+const resolveOriginalNamespace = (specifier: string): unknown => {
+	if (specifier in actualNamespaceRegistry) {
+		return actualNamespaceRegistry[specifier]
+	}
+	try {
+		// bun resolves `require` synchronously for both ESM and CJS workspace deps.
+		return (globalThis as { require?: (id: string) => unknown }).require?.(specifier)
+	} catch {
+		return undefined
+	}
+}
+
+const viMock = (specifier: string, factory?: (importOriginal?: () => unknown) => unknown) => {
+	if (typeof factory !== "function") {
+		return mock.module(specifier, () => ({}))
+	}
+	const importOriginal = () => resolveOriginalNamespace(specifier)
+	const result = factory(importOriginal)
+	if (result && typeof (result as { then?: unknown }).then === "function") {
+		// Seed a synchronous placeholder carrying the original export names so
+		// consumers' named imports link before the async factory resolves.
+		const original = resolveOriginalNamespace(specifier)
+		const placeholder: Record<string, unknown> = {}
+		if (original && typeof original === "object") {
+			for (const name of Object.keys(original as object)) {
+				placeholder[name] = (original as Record<string, unknown>)[name]
+			}
+		}
+		mock.module(specifier, () => placeholder)
+		void (result as Promise<unknown>).then((resolved) => {
+			// Mutate the SAME placeholder object the live ESM bindings already
+			// reference, then re-register it. Copying onto the existing object
+			// (rather than swapping in a fresh one) is what makes already-linked
+			// *named* imports observe the resolved values — re-registering a brand
+			// new object can race the first test before the binding updates.
+			if (resolved && typeof resolved === "object") {
+				for (const name of Object.keys(resolved as object)) {
+					placeholder[name] = (resolved as Record<string, unknown>)[name]
+				}
+			}
+			mock.module(specifier, () => placeholder)
+		})
+		return
+	}
+	return mock.module(specifier, () => result as object)
+}
+
+const viExtensions: Record<string, unknown> = {
+	mocked: (value: unknown) => value,
+	mock: viMock,
+	hoisted: <T>(factory: () => T): T => factory(),
+	// NOTE: return the registry value *synchronously* (not via an async
+	// function) for known specifiers. bun blocks synchronously while awaiting an
+	// async `vi.mock` factory and does not pump the microtask queue, so an
+	// `async` importActual would never settle its continuation from inside a
+	// factory → deadlock. Returning the plain namespace lets the factory's
+	// `await` resolve in the same tick. Only the (rare) real-import fallback
+	// returns a Promise.
+	importActual: <T = unknown>(specifier: string): T | Promise<T> => {
+		if (specifier in actualNamespaceRegistry) {
+			return actualNamespaceRegistry[specifier] as T
+		}
+		return import(specifier) as Promise<T>
+	},
+	importMock: <T = unknown>(specifier: string): Promise<T> => import(specifier) as Promise<T>,
+	resetModules: () => bunVi,
+	waitFor: viWaitFor,
+}
+// Force-install every entry: these are intentional replacements/additions.
+// In particular `vi.mock` ALREADY exists on bun's `vi` (and is the one that
+// deadlocks on async factories), so it must be overwritten, not skipped.
+for (const [name, impl] of Object.entries(viExtensions)) {
+	;(bunVi as Record<string, unknown>)[name] = impl
+}
diff --git a/apps/vscode/src/test/cline-api.test.ts b/apps/vscode/src/test/cline-api.test.ts
new file mode 100644
index 0000000..062459a
--- /dev/null
+++ b/apps/vscode/src/test/cline-api.test.ts
@@ -0,0 +1,181 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import * as should from "should"
+import * as sinon from "sinon"
+import { createClineAPI } from "@/exports"
+import { Logger } from "@/shared/services/Logger"
+import type { ClineAPI } from "../exports/cline"
+import { setVscodeHostProviderMock } from "./host-provider-test-utils"
+
+describe("ClineAPI Core Functionality", () => {
+	let api: ClineAPI
+	let mockController: any
+	let mockLoggerError: sinon.SinonStub
+	let sandbox: sinon.SinonSandbox
+	let _getGlobalStateStub: sinon.SinonStub
+
+	beforeEach(async () => {
+		sandbox = sinon.createSandbox()
+
+		// Stub Logger.error
+		mockLoggerError = sandbox.stub(Logger, "error")
+		setVscodeHostProviderMock({})
+
+		// Create a mock controller that matches what the real createClineAPI expects
+		// We don't import the real Controller to avoid the webview dependencies
+		mockController = {
+			id: "test-controller-id",
+			context: {
+				globalState: {
+					get: sandbox.stub(),
+					update: sandbox.stub(),
+					keys: sandbox.stub().returns([]),
+					setKeysForSync: sandbox.stub(),
+				},
+				secrets: {
+					get: sandbox.stub(),
+					store: sandbox.stub(),
+					delete: sandbox.stub(),
+					onDidChange: sandbox.stub(),
+				},
+			},
+			updateCustomInstructions: sandbox.stub().resolves(),
+			clearTask: sandbox.stub().resolves(),
+			postStateToWebview: sandbox.stub().resolves(),
+			postMessageToWebview: sandbox.stub().resolves(),
+			initTask: sandbox.stub().resolves(),
+			task: undefined,
+		}
+
+		// Create API instance
+		api = createClineAPI(mockController)
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe("startNewTask", () => {
+		it("should clear existing task and start new one with description", async () => {
+			const taskDescription = "Create a test function"
+			const images = ["image1.png", "image2.png"]
+
+			await api.startNewTask(taskDescription, images)
+
+			// Verify task clearing sequence
+			sinon.assert.called(mockController.clearTask)
+			sinon.assert.called(mockController.postStateToWebview)
+			sinon.assert.calledWith(mockController.initTask, taskDescription, images)
+		})
+
+		it("should handle undefined task description", async () => {
+			await api.startNewTask(undefined, [])
+
+			sinon.assert.called(mockController.clearTask)
+			sinon.assert.calledWith(mockController.initTask, undefined, [])
+		})
+
+		it("should handle task with no images", async () => {
+			await api.startNewTask("Task without images")
+
+			sinon.assert.calledWith(mockController.initTask, "Task without images", undefined)
+		})
+	})
+
+	describe("sendMessage", () => {
+		it("should send message to active task", async () => {
+			const mockTask = {
+				handleWebviewAskResponse: sandbox.stub().resolves(),
+			}
+			mockController.task = mockTask
+
+			await api.sendMessage("Test message", ["image.png"])
+
+			sinon.assert.calledWith(mockTask.handleWebviewAskResponse, "messageResponse", "Test message", ["image.png"])
+		})
+
+		it("should handle no active task gracefully", async () => {
+			mockController.task = undefined
+
+			await api.sendMessage("Message to nowhere", [])
+		})
+
+		it("should handle empty message", async () => {
+			const mockTask = {
+				handleWebviewAskResponse: sandbox.stub().resolves(),
+			}
+			mockController.task = mockTask
+
+			await api.sendMessage("", [])
+
+			sinon.assert.calledWith(mockTask.handleWebviewAskResponse, "messageResponse", "", [])
+		})
+
+		it("should handle undefined message", async () => {
+			const mockTask = {
+				handleWebviewAskResponse: sandbox.stub().resolves(),
+			}
+			mockController.task = mockTask
+
+			await api.sendMessage(undefined, [])
+
+			sinon.assert.calledWith(mockTask.handleWebviewAskResponse, "messageResponse", "", [])
+		})
+	})
+
+	describe("Button Press Methods", () => {
+		describe("pressPrimaryButton", () => {
+			it("should handle primary button press with active task", async () => {
+				const mockTask = {
+					handleWebviewAskResponse: sandbox.stub().resolves(),
+				}
+				mockController.task = mockTask
+
+				await api.pressPrimaryButton()
+
+				sinon.assert.calledWith(mockTask.handleWebviewAskResponse, "yesButtonClicked", "", [])
+			})
+
+			it("should handle primary button press with no active task", async () => {
+				mockController.task = undefined
+
+				await api.pressPrimaryButton()
+
+				sinon.assert.calledWith(mockLoggerError, "No active task to press button for")
+			})
+		})
+
+		describe("pressSecondaryButton", () => {
+			it("should handle secondary button press with active task", async () => {
+				const mockTask = {
+					handleWebviewAskResponse: sandbox.stub().resolves(),
+				}
+				mockController.task = mockTask
+
+				await api.pressSecondaryButton()
+
+				sinon.assert.calledWith(mockTask.handleWebviewAskResponse, "noButtonClicked", "", [])
+			})
+
+			it("should handle secondary button press with no active task", async () => {
+				mockController.task = undefined
+
+				await api.pressSecondaryButton()
+
+				sinon.assert.calledWith(mockLoggerError, "No active task to press button for")
+			})
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle errors in task initialization", async () => {
+			mockController.initTask.rejects(new Error("Init failed"))
+
+			try {
+				await api.startNewTask("test task")
+				should.fail("", "", "Should have thrown an error", "")
+			} catch (error: any) {
+				error.message.should.equal("Init failed")
+			}
+		})
+	})
+})
diff --git a/apps/vscode/src/test/cline-core-vitest-stub.ts b/apps/vscode/src/test/cline-core-vitest-stub.ts
new file mode 100644
index 0000000..8c65887
--- /dev/null
+++ b/apps/vscode/src/test/cline-core-vitest-stub.ts
@@ -0,0 +1,416 @@
+import { readFileSync, writeFileSync } from "node:fs"
+import { getGeneratedModelsForProvider, MODEL_COLLECTIONS_BY_PROVIDER_ID } from "@cline/llms"
+
+export interface OAuthCredentials {
+	accessToken?: string
+	refreshToken?: string
+	accountId?: string
+}
+
+export interface StartSessionResult {
+	sessionId: string
+}
+
+export const MAX_COMMAND_OUTPUT_CHARS = 200_000
+
+export type GlobalCompactionStrategy = "basic" | "agentic"
+
+export function readCompactionStrategyGlobally(): GlobalCompactionStrategy {
+	try {
+		const settings = JSON.parse(readFileSync(process.env.CLINE_GLOBAL_SETTINGS_PATH ?? "", "utf8"))
+		return settings.compactionStrategy === "agentic" ? "agentic" : "basic"
+	} catch {
+		return "basic"
+	}
+}
+
+export function setCompactionStrategyGlobally(compactionStrategy: GlobalCompactionStrategy): void {
+	const filePath = process.env.CLINE_GLOBAL_SETTINGS_PATH
+	if (filePath) {
+		let settings = {}
+		try {
+			settings = JSON.parse(readFileSync(filePath, "utf8"))
+		} catch {}
+		writeFileSync(filePath, JSON.stringify({ ...settings, compactionStrategy }))
+	}
+}
+
+export function truncateCommandOutput(output: string): string {
+	return output
+}
+
+export function createShellExecutor() {
+	return async () => ""
+}
+
+export function createShellTool(execute: unknown) {
+	return {
+		name: "run_commands",
+		execute,
+	}
+}
+
+export interface SessionHistoryRecord {
+	id: string
+	metadata?: Record<string, unknown>
+}
+
+export interface CheckpointEntry {
+	ref: string
+	createdAt: number
+	runCount: number
+	kind?: "stash" | "commit"
+}
+
+export function readSessionCheckpointHistory(session: { metadata?: Record<string, unknown> } | undefined): CheckpointEntry[] {
+	const checkpoint =
+		session?.metadata?.checkpoint &&
+		typeof session.metadata.checkpoint === "object" &&
+		!Array.isArray(session.metadata.checkpoint)
+			? (session.metadata.checkpoint as Record<string, unknown>)
+			: undefined
+	const history = Array.isArray(checkpoint?.history) ? checkpoint.history : []
+	return history.flatMap((entry): CheckpointEntry[] => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+			return []
+		}
+		const record = entry as Record<string, unknown>
+		const ref = typeof record.ref === "string" ? record.ref.trim() : ""
+		const createdAt = Number(record.createdAt ?? 0)
+		const runCount = Number(record.runCount ?? 0)
+		if (!ref || !Number.isFinite(createdAt) || !Number.isInteger(runCount) || runCount < 1) {
+			return []
+		}
+		const kind = record.kind === "stash" || record.kind === "commit" ? record.kind : undefined
+		return [{ ref, createdAt, runCount, ...(kind ? { kind } : {}) }]
+	})
+}
+
+export function findCheckpointForRun(history: readonly CheckpointEntry[], runCount: number): CheckpointEntry | undefined {
+	return history.reduce<CheckpointEntry | undefined>((best, entry) => {
+		if (entry.runCount > runCount) {
+			return best
+		}
+		if (!best || entry.runCount > best.runCount) {
+			return entry
+		}
+		return best
+	}, undefined)
+}
+
+export interface CheckpointContentDiff {
+	filePath: string
+	leftContent: string
+	rightContent: string
+}
+
+export interface CheckpointWorkspaceCompareResult {
+	checkpoint: CheckpointEntry
+	cwd: string
+	diffs: CheckpointContentDiff[]
+}
+
+export async function compareCheckpointToWorkspace(): Promise<CheckpointWorkspaceCompareResult> {
+	throw new Error("compareCheckpointToWorkspace is not implemented in the Vitest @cline/core stub")
+}
+
+export type CoreSessionEvent = { type: string; payload?: unknown }
+
+export type TelemetryProperties = Record<string, unknown>
+
+export interface TelemetryMetadata {
+	extension_version: string
+	cline_type: string
+	platform: string
+	platform_version: string
+	os_type: string
+	os_version: string
+	is_dev?: string
+}
+
+export interface ITelemetryService {
+	setDistinctId(distinctId?: string): void
+	setMetadata(metadata: Partial<TelemetryMetadata>): void
+	updateMetadata(metadata: Partial<TelemetryMetadata>): void
+	setCommonProperties(properties: TelemetryProperties): void
+	updateCommonProperties(properties: TelemetryProperties): void
+	isEnabled(): boolean
+	capture(input: { event: string; properties?: TelemetryProperties }): void
+	captureRequired(event: string, properties?: TelemetryProperties): void
+	recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void
+	recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void
+	flush(): Promise<void>
+	dispose(): Promise<void>
+}
+
+export interface ConfiguredTelemetryHandle {
+	readonly telemetry: ITelemetryService
+	flush(): Promise<void>
+	dispose(): Promise<void>
+}
+
+function createNoopTelemetry(): ITelemetryService {
+	return {
+		setDistinctId() {},
+		setMetadata() {},
+		updateMetadata() {},
+		setCommonProperties() {},
+		updateCommonProperties() {},
+		isEnabled: () => false,
+		capture() {},
+		captureRequired() {},
+		recordCounter() {},
+		recordHistogram() {},
+		recordGauge() {},
+		flush: async () => {},
+		dispose: async () => {},
+	}
+}
+
+export function createClineTelemetryServiceConfig(config: Record<string, unknown> = {}) {
+	return {
+		enabled: false,
+		metadata: {
+			extension_version: "test",
+			cline_type: "test",
+			platform: "test",
+			platform_version: "test",
+			os_type: "test",
+			os_version: "test",
+		},
+		...config,
+	}
+}
+
+export function createConfiguredTelemetryHandle(): ConfiguredTelemetryHandle {
+	const telemetry = createNoopTelemetry()
+	return {
+		telemetry,
+		flush: async () => {},
+		dispose: async () => {},
+	}
+}
+
+interface ProviderSettingsState {
+	providers: Record<string, Record<string, unknown>>
+	lastUsedProvider?: string
+}
+
+// State is keyed by dataDir so that — like the real file-backed manager —
+// two managers constructed for the same directory observe the same providers.
+// (Tests isolate by using a unique dataDir per test.)
+const providerSettingsStores = new Map<string, ProviderSettingsState>()
+
+export class ProviderSettingsManager {
+	private readonly filePath: string
+	private readonly state: ProviderSettingsState
+
+	constructor(options?: { filePath?: string; dataDir?: string }) {
+		this.filePath = options?.filePath ?? options?.dataDir ?? "<default>"
+		let store = providerSettingsStores.get(this.filePath)
+		if (!store) {
+			store = { providers: {} }
+			providerSettingsStores.set(this.filePath, store)
+		}
+		this.state = store
+	}
+
+	getFilePath(): string {
+		return this.filePath
+	}
+
+	read(): ProviderSettingsState {
+		return { providers: { ...this.state.providers }, lastUsedProvider: this.state.lastUsedProvider }
+	}
+
+	getProviderSettings(providerId: string): Record<string, unknown> | undefined {
+		return this.state.providers[providerId]
+	}
+
+	getLastUsedProviderSettings(): Record<string, unknown> | undefined {
+		return this.state.lastUsedProvider ? this.state.providers[this.state.lastUsedProvider] : undefined
+	}
+
+	saveProviderSettings(settings: Record<string, unknown>, options?: { setLastUsed?: boolean }): ProviderSettingsState {
+		const provider = settings.provider
+		if (typeof provider !== "string") {
+			throw new Error("provider is required")
+		}
+		this.state.providers[provider] = { ...settings }
+		if (options?.setLastUsed !== false) {
+			this.state.lastUsedProvider = provider
+		}
+		return this.read()
+	}
+}
+
+const WORKOS_TOKEN_PREFIX = "workos:"
+
+export function getProviderAuthStorageId(providerId: string): string | undefined {
+	const normalized = providerId.trim().toLowerCase()
+	if (normalized === "cline" || normalized === "cline-pass") {
+		return "cline"
+	}
+	if (normalized === "oca" || normalized === "openai-codex") {
+		return normalized
+	}
+	return undefined
+}
+
+function formatClineApiKey(accessToken: string): string {
+	const token = accessToken.trim()
+	return token.toLowerCase().startsWith(WORKOS_TOKEN_PREFIX) ? token : `${WORKOS_TOKEN_PREFIX}${token}`
+}
+
+export function getProviderAuthHandler(providerId: string) {
+	const storageProviderId = getProviderAuthStorageId(providerId)
+	if (!storageProviderId) {
+		return undefined
+	}
+	return {
+		providerId,
+		storageProviderId,
+		getApiKey(settings: Record<string, unknown> | undefined): string | undefined {
+			const auth = settings?.auth as { accessToken?: string; apiKey?: string } | undefined
+			const accessToken = auth?.accessToken?.trim()
+			if (accessToken) {
+				return storageProviderId === "cline" ? formatClineApiKey(accessToken) : accessToken
+			}
+			return (settings?.apiKey as string | undefined)?.trim() || auth?.apiKey?.trim() || undefined
+		},
+	}
+}
+
+export function resolveProviderApiKeyFromSettings(manager: ProviderSettingsManager, providerId: string): string | undefined {
+	const handler = getProviderAuthHandler(providerId)
+	const storageProviderId = handler?.storageProviderId ?? providerId
+	const settings = manager.getProviderSettings(storageProviderId)
+	return handler?.getApiKey(settings) ?? ((settings?.apiKey as string | undefined)?.trim() || undefined)
+}
+
+export interface ModelCatalogConfig {
+	loadLatestOnInit?: boolean
+	loadPrivateOnAuth?: boolean
+	failOnError?: boolean
+	cacheTtlMs?: number
+}
+
+function titleCaseFromId(id: string): string {
+	return id
+		.split(/[-_]/)
+		.filter(Boolean)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ")
+}
+
+export async function listLocalProviders(
+	manager: ProviderSettingsManager,
+	options: { isClinePassEnabled?: boolean } = {},
+): Promise<{ providers: Array<Record<string, unknown>>; settingsPath: string }> {
+	const state = manager.read()
+	const providers = Object.entries(MODEL_COLLECTIONS_BY_PROVIDER_ID)
+		.map(([id, collection]) => {
+			const settings = state.providers[id]?.settings as Record<string, unknown> | undefined
+			const provider = collection.provider
+			return {
+				id,
+				name: provider.name ?? titleCaseFromId(id),
+				models: Object.keys(collection.models ?? {}).length,
+				enabled: Boolean(settings),
+				apiKey: settings?.apiKey,
+				baseUrl: settings?.baseUrl ?? provider.baseUrl,
+				defaultModelId: provider.defaultModelId,
+				protocol: settings?.protocol ?? provider.protocol,
+				client: settings?.client ?? provider.client,
+				capabilities: provider.capabilities,
+				authDescription: "This provider uses API keys for authentication.",
+				baseUrlDescription: "The base endpoint to use for provider requests.",
+			}
+		})
+		.filter((provider) => options.isClinePassEnabled === true || provider.id !== "cline-pass")
+		.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))
+
+	return { providers, settingsPath: manager.getFilePath() }
+}
+
+export async function resolveProviderConfig(
+	providerId: string,
+	_config?: ModelCatalogConfig,
+	providerConfig?: { modelId?: string },
+) {
+	const knownModels = getGeneratedModelsForProvider(providerId)
+	const requestedModelId = providerConfig?.modelId?.trim()
+	const collection = MODEL_COLLECTIONS_BY_PROVIDER_ID[providerId]
+	const manifestDefaultModelId = collection?.provider.defaultModelId
+	const defaultModelId =
+		manifestDefaultModelId && knownModels[manifestDefaultModelId]
+			? manifestDefaultModelId
+			: Object.keys(knownModels)[0] || Object.keys(collection?.models ?? {})[0]
+	const modelId = requestedModelId && knownModels[requestedModelId] ? requestedModelId : defaultModelId
+	return { modelId, knownModels }
+}
+
+export interface ClineRecommendedModel {
+	id: string
+	name: string
+	description: string
+	tags: string[]
+}
+
+export interface ClineRecommendedModelsData {
+	recommended: ClineRecommendedModel[]
+	free: ClineRecommendedModel[]
+}
+
+export const FALLBACK_CLINE_RECOMMENDED_MODELS: ClineRecommendedModelsData = {
+	recommended: [
+		{
+			id: "anthropic/claude-sonnet-4.6",
+			name: "Claude Sonnet 4.6",
+			description: "Strong coding and agent performance",
+			tags: ["NEW"],
+		},
+	],
+	free: [
+		{
+			id: "z-ai/glm-5",
+			name: "GLM 5",
+			description: "Remote free",
+			tags: [],
+		},
+	],
+}
+
+export async function fetchClineRecommendedModels(_options?: {
+	baseUrl?: string
+	fetchImpl?: typeof fetch
+}): Promise<ClineRecommendedModelsData> {
+	return { recommended: [], free: [] }
+}
+
+export function createOAuthClientCallbacks() {
+	return {}
+}
+
+export async function getValidClineCredentials(): Promise<OAuthCredentials | undefined> {
+	return undefined
+}
+
+export async function loginClineOAuth(): Promise<OAuthCredentials> {
+	return {}
+}
+
+export async function loginOcaOAuth(): Promise<OAuthCredentials> {
+	return {}
+}
+
+export async function loginOpenAICodex(): Promise<OAuthCredentials> {
+	return {}
+}
diff --git a/apps/vscode/src/test/e2e/README.md b/apps/vscode/src/test/e2e/README.md
new file mode 100644
index 0000000..6ec29a7
--- /dev/null
+++ b/apps/vscode/src/test/e2e/README.md
@@ -0,0 +1,261 @@
+# E2E Tests
+
+This directory contains the end-to-end tests for the Cline VS Code extension using Playwright. These tests simulate user interactions with the extension in a real VS Code environment.
+
+## Test Structure
+
+The E2E test suite consists of several key components:
+
+### Test Files
+
+- **`auth.test.ts`** - Tests API key setup, provider selection, and navigation to settings
+- **`chat.test.ts`** - Tests chat functionality including message sending, mode switching (Plan/Act), slash commands, and @ mentions
+- **`diff.test.ts`** - Tests the diff editor functionality for file modifications
+- **`editor.test.ts`** - Tests code actions, editor panel integration, and code selection features
+
+### Test Infrastructure
+
+- **`utils/helpers.ts`** - Core test utilities and fixtures including:
+  - `e2e` - Main test fixture for single-root workspace tests
+  - `e2eMultiRoot` - Test fixture for multi-root workspace tests
+  - `E2ETestHelper` - Helper class with utilities for VS Code interaction
+- **`utils/common.ts`** - Common utility functions for UI interactions
+- **`utils/global.setup.ts`** - Global test setup and cleanup
+- **`utils/build.mjs`** - Build script for test environment preparation
+
+### Test Fixtures
+
+- **`fixtures/workspace/`** - Single-root workspace test files (HTML, TypeScript, etc.)
+- **`fixtures/workspace_2/`** - Additional workspace with Python provider files
+- **`fixtures/multiroots.code-workspace`** - Multi-root workspace configuration
+- **`fixtures/server/`** - Mock API server for testing Cline's backend interactions
+
+## Running Tests
+
+### Basic Test Execution
+
+To build the test environment and run all E2E tests:
+
+```bash
+bun run test:e2e
+```
+
+To run all E2E tests without re-building the test environment (e.g. only test files were updated):
+
+```bash
+bun run e2e
+```
+
+### Debug Mode
+
+To run E2E tests in debug mode with Playwright's interactive debugger:
+
+```bash
+bun run test:e2e -- --debug
+# Or only run the tests without re-building
+bun run e2e -- --debug
+```
+
+In debug mode, Playwright will:
+- Open a browser window showing the VS Code instance
+- Pause execution at the beginning of each test
+- Allow you to step through test actions
+- Provide a console for inspecting elements and state
+
+### Additional Options
+
+Run specific test files:
+```bash
+bun run e2e -- auth.test.ts
+```
+
+Run tests with specific tags or patterns:
+```bash
+bun run e2e -- --grep "Chat"
+```
+
+Run tests in headed mode (visible browser):
+```bash
+bun run e2e -- --headed
+```
+
+## Writing Tests
+
+### Basic Test Structure
+
+Use the `e2e` fixture for single-root workspace tests:
+
+```typescript
+import { expect } from "@playwright/test"
+import { e2e } from "./utils/helpers"
+
+e2e("Test description", async ({ sidebar, helper, page }) => {
+  // Sign in to Cline
+  await helper.signin(sidebar)
+  
+  // Test interactions
+  const inputbox = sidebar.getByTestId("chat-input")
+  await inputbox.fill("Hello, Cline!")
+  await sidebar.getByTestId("send-button").click()
+  
+  // Assertions
+  await expect(sidebar.getByText("API Request...")).toBeVisible()
+})
+```
+
+For multi-root workspace tests, use `e2eMultiRoot`:
+
+```typescript
+import { e2eMultiRoot } from "./utils/helpers"
+
+e2eMultiRoot("[Multi-roots] Test description", async ({ sidebar, helper }) => {
+  // Test implementation
+})
+```
+
+### Available Fixtures
+
+The test fixtures provide the following objects:
+
+- **`sidebar`** - Playwright Frame object for the Cline extension's sidebar
+- **`helper`** - E2ETestHelper instance with utility methods
+- **`page`** - Playwright Page object for the main VS Code window
+- **`app`** - ElectronApplication instance for VS Code
+- **`server`** - Mock API server for backend testing
+
+### Common Patterns
+
+#### Authentication
+```typescript
+// Sign in with test API key
+await helper.signin(sidebar)
+```
+
+#### Chat Interactions
+```typescript
+const inputbox = sidebar.getByTestId("chat-input")
+await inputbox.fill("Your message")
+await sidebar.getByTestId("send-button").click()
+```
+
+#### Mode Switching
+```typescript
+const actButton = sidebar.getByRole("switch", { name: "Act" })
+const planButton = sidebar.getByRole("switch", { name: "Plan" })
+await actButton.click() // Switch to Plan mode
+```
+
+#### File Operations
+```typescript
+// Open file explorer and select code
+await openTab(page, "Explorer ")
+await page.getByRole("treeitem", { name: "index.html" }).locator("a").click()
+await addSelectedCodeToClineWebview(page)
+```
+
+#### Settings Navigation
+```typescript
+await sidebar.getByText("settings").click()
+await sidebar.getByTestId("tab-api-config").click()
+```
+
+### Using the Recorder with Debug Mode
+
+The `--debug` flag enables Playwright's interactive debugging features:
+
+1. **Start debugging session:**
+   ```bash
+   bun run test:e2e -- --debug
+   ```
+
+2. **Playwright will open:**
+   - A VS Code window with Cline extension loaded
+   - Playwright Inspector for step-by-step debugging
+   - Browser developer tools for element inspection
+
+3. **Recording interactions:**
+   - Use the "Record" button in Playwright Inspector
+   - Interact with the VS Code interface
+   - Playwright generates test code automatically
+   - Copy the generated code into your test files
+
+4. **Debugging existing tests:**
+   - Set breakpoints in your test code
+   - Use the "Step over" button to execute line by line
+   - Inspect element selectors and page state
+   - Modify selectors and retry actions
+
+### Test Environment
+
+The test environment includes:
+
+- **VS Code Configuration:**
+  - Disabled updates, workspace trust, and welcome screens
+  - Extension development mode with Cline loaded
+  - Temporary user data and extensions directories
+
+- **Mock API Server:**
+  - Runs on `http://localhost:7777`
+  - Provides mock responses for Cline API calls
+  - Supports authentication, chat completions, and user management
+
+- **Test Workspaces:**
+  - Single-root workspace with HTML, TypeScript, and README files
+  - Multi-root workspace with Python provider examples
+  - Configurable through fixtures
+
+### Best Practices
+
+1. **Use semantic selectors:**
+   ```typescript
+   // Good - uses test IDs
+   sidebar.getByTestId("chat-input")
+   
+   // Good - uses roles and accessible names
+   sidebar.getByRole("button", { name: "Send" })
+   
+   // Avoid - brittle CSS selectors
+   sidebar.locator(".chat-input-class")
+   ```
+
+2. **Wait for elements:**
+   ```typescript
+   await expect(sidebar.getByText("Loading...")).toBeVisible()
+   await expect(sidebar.getByText("Complete")).toBeVisible()
+   ```
+
+3. **Clean up state:**
+   ```typescript
+   // Use helper functions for common cleanup
+   await cleanChatView(page)
+   ```
+
+4. **Handle async operations:**
+   ```typescript
+   // Wait for API responses
+   await expect(sidebar.getByText("API Request...")).toBeVisible()
+   await expect(sidebar.getByText("Response received")).toBeVisible()
+   ```
+
+5. **Test both success and error cases:**
+   ```typescript
+   // Test successful flow
+   await helper.signin(sidebar)
+   
+   // Test error handling
+   await expect(sidebar.getByText("API Request Failed")).toBeVisible()
+   ```
+
+### Debugging Tips
+
+- Use `page.pause()` to pause execution and inspect the current state
+- Add `console.log()` statements to track test progress
+- Use `--headed` flag to see the browser window during test execution
+- Check video recordings in `test-results/` for failed tests
+- Use browser developer tools to inspect element selectors
+
+### Environment Variables
+
+- `CLINE_E2E_TESTS_VERBOSE=true` - Enable verbose logging
+- `CI=true` - Adjusts timeouts and reporting for CI environments
+- `GRPC_RECORDER_ENABLED=true` - Enable gRPC recording for debugging
diff --git a/apps/vscode/src/test/e2e/auth.test.ts b/apps/vscode/src/test/e2e/auth.test.ts
new file mode 100644
index 0000000..a3cd8aa
--- /dev/null
+++ b/apps/vscode/src/test/e2e/auth.test.ts
@@ -0,0 +1,51 @@
+import { expect } from "@playwright/test"
+import { e2e } from "./utils/helpers"
+
+// Test for setting up API keys
+e2e("Views - can set up API keys and navigate to Settings from Chat", async ({ sidebar }) => {
+	// Use the page object to interact with editor outside the sidebar
+	// Verify initial state
+	await expect(sidebar.getByRole("button", { name: "Login to Cline" })).toBeVisible()
+	await expect(sidebar.getByText("Bring my own API key")).toBeVisible()
+
+	// Navigate to API key setup
+	await sidebar.getByText("Bring my own API key").click()
+	await sidebar.getByRole("button", { name: "Continue" }).click()
+
+	const providerSelectorInput = sidebar.getByTestId("provider-selector-input")
+
+	// Verify provider selector is visible
+	await expect(providerSelectorInput).toBeVisible()
+
+	// Test Cline provider option
+	await providerSelectorInput.click({ delay: 100 })
+	// Wait for dropdown to appear and find Cline option
+	await expect(sidebar.getByTestId("provider-option-cline")).toBeVisible()
+	await sidebar.getByTestId("provider-option-cline").click({ delay: 100 })
+	await expect(sidebar.getByRole("button", { name: "Sign Up with Cline" })).toBeVisible()
+
+	// Switch to OpenRouter and complete setup
+	await providerSelectorInput.click({ delay: 100 })
+	await sidebar.getByTestId("provider-option-openrouter").click({ delay: 100 })
+
+	const apiKeyInput = sidebar.getByRole("textbox", {
+		name: "OpenRouter API Key",
+	})
+	await apiKeyInput.fill("test-api-key")
+	await expect(apiKeyInput).toHaveValue("test-api-key")
+	await apiKeyInput.click({ delay: 100 })
+	await sidebar.getByRole("button", { name: "Continue" }).click()
+
+	await expect(sidebar.getByRole("button", { name: "Login to Cline" })).not.toBeVisible()
+
+	// Verify start up page is no longer visible
+	await expect(apiKeyInput).not.toBeVisible()
+	await expect(providerSelectorInput).not.toBeVisible()
+
+	// Verify you are now in the chat page after setup was completed.
+	// cline logo container
+	const clineLogo = sidebar.locator(".size-20")
+	await expect(clineLogo).toBeVisible()
+	const chatInputBox = sidebar.getByTestId("chat-input")
+	await expect(chatInputBox).toBeVisible()
+})
diff --git a/apps/vscode/src/test/e2e/chat.test.ts b/apps/vscode/src/test/e2e/chat.test.ts
new file mode 100644
index 0000000..64a0734
--- /dev/null
+++ b/apps/vscode/src/test/e2e/chat.test.ts
@@ -0,0 +1,67 @@
+import { expect } from "@playwright/test"
+import { e2e } from "./utils/helpers"
+
+e2e("Chat - can send messages and switch between modes", async ({ helper, sidebar }) => {
+	// Sign in
+	await helper.signin(sidebar)
+
+	// Submit a message
+	const inputbox = sidebar.getByTestId("chat-input")
+	await expect(inputbox).toBeVisible()
+	await inputbox.fill("Hello, Cline!")
+	await expect(inputbox).toHaveValue("Hello, Cline!")
+	await sidebar.getByTestId("send-button").click()
+	await expect(inputbox).toHaveValue("")
+
+	// Wait for the (mock) agent turn to finish before navigating away — the task
+	// is persisted to SDK session history when the turn completes, so clicking
+	// "New Task" mid-turn races the history write and "Recent" may not show.
+	await expect(sidebar.getByText("mock Cline API response")).toBeVisible()
+
+	// Starting a new task should clear the current chat view and show the recent tasks
+	await sidebar.getByRole("button", { name: "New Task", exact: true }).first().click()
+	await expect(sidebar.getByText("Recent")).toBeVisible()
+	await expect(sidebar.getByText("Hello, Cline!")).toBeVisible()
+
+	// Makes sure the act and plan switches are working correctly
+	// Aria-checked state should be true for Act and false for Plan
+	const actButton = sidebar.getByRole("switch", { name: "Act" })
+	const planButton = sidebar.getByRole("switch", { name: "Plan" })
+
+	// Act button should be active. It doesn't have c
+	await expect(actButton).toHaveAttribute("aria-checked", "true")
+	await expect(planButton).not.toHaveAttribute("aria-checked", "true")
+
+	await planButton.click()
+	await expect(planButton).toHaveAttribute("aria-checked", "true")
+	await expect(actButton).not.toHaveAttribute("aria-checked", "true")
+
+	// === slash commands preserve following text ===
+	await expect(inputbox).toHaveValue("")
+	// Type partial slash command to trigger menu
+	await inputbox.fill("/newt")
+
+	// Wait for menu to be visible and click on menu item
+	await inputbox.focus()
+	await sidebar.getByText("newtask", { exact: false }).click()
+	await expect(inputbox).toHaveValue("/newtask ")
+
+	// Add following text to verify it works correctly
+	await inputbox.pressSequentially("following text should be preserved")
+	await expect(inputbox).toHaveValue("/newtask following text should be preserved")
+
+	// === @ mentions preserve following text ===
+	await inputbox.fill("")
+	await expect(inputbox).toHaveValue("")
+
+	// Type partial @ mention to trigger menu
+	await inputbox.fill("@prob")
+
+	// Wait for menu to be visible and click on menu item
+	await sidebar.getByText("Problems", { exact: false }).first().click()
+	await expect(inputbox).toHaveValue("@problems ")
+
+	// Add following text to verify it works correctly
+	await inputbox.pressSequentially("following text should be preserved")
+	await expect(inputbox).toHaveValue("@problems following text should be preserved")
+})
diff --git a/apps/vscode/src/test/e2e/editor.test.ts b/apps/vscode/src/test/e2e/editor.test.ts
new file mode 100644
index 0000000..4fd11ab
--- /dev/null
+++ b/apps/vscode/src/test/e2e/editor.test.ts
@@ -0,0 +1,28 @@
+import { expect } from "@playwright/test"
+import { addSelectedCodeToClineWebview, openTab, toggleNotifications } from "./utils/common"
+import { E2E_WORKSPACE_TYPES, e2e } from "./utils/helpers"
+
+e2e.describe("Code Actions and Editor Panel", () => {
+	E2E_WORKSPACE_TYPES.forEach(({ title, workspaceType }) => {
+		e2e.extend({
+			workspaceType,
+		})(title, async ({ helper, page, sidebar }) => {
+			await helper.signin(sidebar)
+			// Sidebar - input should start empty
+			const sidebarInput = sidebar.getByTestId("chat-input")
+			await sidebarInput.click()
+			await toggleNotifications(page)
+			await expect(sidebarInput).toBeEmpty()
+
+			// Open file tree and select code from file
+			await openTab(page, "Explorer ")
+			await page.getByRole("treeitem", { name: "index.html" }).locator("a").click()
+			await expect(sidebarInput).not.toBeFocused()
+
+			// Sidebar should be opened and visible after adding code to Cline
+			await addSelectedCodeToClineWebview(page)
+			await expect(sidebarInput).not.toBeEmpty()
+			await expect(sidebarInput).toBeFocused()
+		})
+	})
+})
diff --git a/apps/vscode/src/test/e2e/file-edit.test.ts b/apps/vscode/src/test/e2e/file-edit.test.ts
new file mode 100644
index 0000000..529383c
--- /dev/null
+++ b/apps/vscode/src/test/e2e/file-edit.test.ts
@@ -0,0 +1,58 @@
+import { readFileSync, writeFileSync } from "node:fs"
+import * as path from "node:path"
+import { expect } from "@playwright/test"
+import { E2E_WORKSPACE_TYPES, e2e } from "./utils/helpers"
+
+// File edits are performed by the SDK's `editor` tool executor, which writes
+// the file directly (Node fs) after the tool call is approved. It does not
+// stream the edit through DiffViewProvider, so no diff editor tab (e.g.
+// "test.ts: Original ↔ Cline's Changes") opens. This test asserts the default
+// auto-approval flow: ask row appears without manual approval buttons, the file
+// is modified on disk, and the turn-ending completion text appears.
+e2e.describe("File Edit Auto-Approval", () => {
+	E2E_WORKSPACE_TYPES.forEach(({ title, workspaceType }) => {
+		e2e.extend({
+			workspaceType,
+		})(title, async ({ helper, sidebar, workspaceDir }) => {
+			// The mock editor tool call targets "test.ts" relative to the session
+			// cwd, which is the first workspace folder in both single-root and
+			// multi-root workspaces (fixtures/workspace). The fixture file is
+			// checked into git, so restore it after the (real) edit.
+			const editedFilePath = path.join(workspaceDir, "test.ts")
+			let originalFileContent: string | undefined
+
+			try {
+				originalFileContent = readFileSync(editedFilePath, "utf-8")
+
+				await helper.signin(sidebar)
+
+				// Submit a file edit request. The mock server responds with a
+				// structured `editor` tool call (path: test.ts, old/new text).
+				const inputbox = sidebar.getByTestId("chat-input")
+				await expect(inputbox).toBeVisible()
+				await inputbox.fill("edit_request")
+				await sidebar.getByTestId("send-button").click({ delay: 50 })
+
+				// File edits are auto-approved by default. The ask row appears with
+				// the file path, but no manual approval buttons are shown.
+				await sidebar.waitForSelector('span:has-text("Cline wants to edit this file:")')
+				await expect(sidebar.getByText("test.ts").first()).toBeVisible()
+				await expect(sidebar.getByRole("button", { name: "Reject" })).not.toBeVisible()
+				await expect(sidebar.getByRole("button", { name: "Save", exact: true })).not.toBeVisible()
+
+				// The SDK executes the editor tool and sends the tool result back to
+				// the (mock) model, which replies with turn-ending completion text.
+				await expect(sidebar.getByText("I successfully replaced")).toBeVisible({ timeout: 30_000 })
+
+				// The edit was actually applied to the file on disk.
+				expect(readFileSync(editedFilePath, "utf-8")).toContain('export const name = "cline"')
+			} finally {
+				// Skip the restore when the initial read failed — there is
+				// nothing to restore and the read error is the real failure.
+				if (originalFileContent !== undefined) {
+					writeFileSync(editedFilePath, originalFileContent, "utf-8")
+				}
+			}
+		})
+	})
+})
diff --git a/apps/vscode/src/test/e2e/fixtures/multiroots.code-workspace b/apps/vscode/src/test/e2e/fixtures/multiroots.code-workspace
new file mode 100644
index 0000000..1de6269
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/multiroots.code-workspace
@@ -0,0 +1,15 @@
+{
+	"folders": [
+		{
+			"name": "Workspace 1",
+			"path": "workspace"
+		},
+		{
+			"name": "Workspace 2",
+			"path": "workspace_2"
+		}
+	],
+	"settings": {
+		"workbench.secondarySideBar.defaultVisibility": "hidden"
+	}
+}
diff --git a/apps/vscode/src/test/e2e/fixtures/server/api.ts b/apps/vscode/src/test/e2e/fixtures/server/api.ts
new file mode 100644
index 0000000..e84bfe9
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/server/api.ts
@@ -0,0 +1,129 @@
+export const E2E_REGISTERED_MOCK_ENDPOINTS = {
+	"/api/v1": {
+		GET: [
+			"/generation",
+			"/ai/cline/models",
+			"/ai/cline/recommended-models",
+			"/organizations/{orgId}/balance",
+			"/organizations/{orgId}/members/{memberId}/usages",
+			"/organizations/{orgId}/api-keys",
+			"/organizations/{orgId}/remote-config",
+			"/users/me",
+			"/users/me/featurebase-token",
+			"/users/{userId}/balance",
+			"/users/{userId}/usages",
+			"/users/{userId}/payments",
+		],
+		POST: ["/chat/completions", "/auth/token", "/auth/register", "/users/me/budget/request"],
+		PUT: ["/users/active-account"],
+	},
+	"/.test": {
+		GET: [],
+		POST: ["/auth", "/setUserBalance", "/setUserHasOrganization", "/setOrgBalance", "/setSpendLimitExceeded"],
+		PUT: [],
+	},
+	"/health": {
+		POST: [],
+		GET: ["/", "/ping"],
+		PUT: [],
+	},
+}
+
+/**
+ * Structured `editor` tool call streamed in response to the `edit_request`
+ * prompt. The mock server streams it as OpenAI-format
+ * `choices[].delta.tool_calls[]` deltas followed by
+ * `finish_reason: "tool_calls"`, which is the only tool-call syntax the SDK
+ * runtime executes.
+ *
+ * The `path` is workspace-relative; the SDK editor executor resolves relative
+ * paths against the session cwd, which is the first workspace folder in both
+ * the single-root and multi-root e2e workspaces (`fixtures/workspace`).
+ */
+export const E2E_MOCK_EDITOR_TOOL_CALL = {
+	id: "call_e2e_edit_1",
+	name: "editor",
+	arguments: {
+		path: "test.ts",
+		old_text: 'export const name = "john"',
+		new_text: 'export const name = "cline"',
+	},
+}
+
+const edit_request_complete = `I successfully replaced "john" with "cline" in the test.ts file. The change has been completed and the file now contains:
+
+\`\`\`typescript
+export const name = "cline"
+\`\`\`
+
+The change has been applied and saved to the file.`
+
+export const E2E_MOCK_API_RESPONSES = {
+	DEFAULT: "Hello! I'm a mock Cline API response.",
+	/** Assistant text streamed before the structured editor tool call. */
+	EDIT_REQUEST_LEAD_IN: `I'll replace "john" with "cline" in the test.ts file.`,
+	/** Turn-ending text streamed after the SDK reports the editor tool result. */
+	EDIT_REQUEST_COMPLETE: edit_request_complete,
+}
+
+export const E2E_MOCK_CLINE_RECOMMENDED_MODELS = {
+	free: [
+		{
+			id: "z-ai/glm-5",
+			name: "z-ai/glm-5",
+			description: "Free model for e2e onboarding",
+			tags: [],
+		},
+	],
+	recommended: [
+		{
+			id: "anthropic/claude-sonnet-4.6",
+			name: "anthropic/claude-sonnet-4.6",
+			description: "Recommended model for e2e onboarding",
+			tags: ["BEST"],
+		},
+	],
+}
+
+export const E2E_MOCK_CLINE_MODELS = [
+	{
+		id: "z-ai/glm-5",
+		name: "z-ai/glm-5",
+		description: "Free model for e2e onboarding",
+		context_length: 131_072,
+		top_provider: {
+			max_completion_tokens: 8_192,
+			context_length: 131_072,
+			is_moderated: false,
+		},
+		architecture: {
+			modality: "text->text",
+		},
+		pricing: {
+			prompt: "0",
+			completion: "0",
+		},
+		supported_parameters: [],
+	},
+	{
+		id: "anthropic/claude-sonnet-4.6",
+		name: "anthropic/claude-sonnet-4.6",
+		description: "Recommended model for e2e onboarding",
+		context_length: 200_000,
+		top_provider: {
+			max_completion_tokens: 64_000,
+			context_length: 200_000,
+			is_moderated: false,
+		},
+		architecture: {
+			modality: "text->text",
+		},
+		pricing: {
+			prompt: "0.000003",
+			completion: "0.000015",
+			input_cache_read: "0.0000003",
+			input_cache_write: "0.00000375",
+		},
+		supported_parameters: ["include_reasoning"],
+	},
+]
diff --git a/apps/vscode/src/test/e2e/fixtures/server/data.ts b/apps/vscode/src/test/e2e/fixtures/server/data.ts
new file mode 100644
index 0000000..689ce4b
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/server/data.ts
@@ -0,0 +1,218 @@
+import type {
+	BalanceResponse,
+	OrganizationBalanceResponse,
+	OrganizationUsageTransaction,
+	PaymentTransaction,
+	UsageTransaction,
+	UserResponse,
+} from "../../../../shared/ClineAccount"
+
+const organizations = [
+	{
+		organizationId: "random-org-id",
+		memberId: "random-member-id",
+		name: "Test Organization",
+		roles: ["member"],
+		active: false,
+	},
+] satisfies UserResponse["organizations"]
+
+export class ClineDataMock {
+	public static readonly USERS = [
+		{
+			name: "test-personal-user",
+			orgId: undefined,
+			uid: "test-member-789",
+			token: "test-personal-token",
+			email: "personal@example.com",
+			displayName: "Personal User",
+			photoUrl: "https://example.com/personal-photo.jpg",
+			organizations,
+		},
+		{
+			name: "test-enterprise-user",
+			orgId: "test-org-789",
+			uid: "test-member-012",
+			token: "test-enterprise-token",
+			email: "test@example.com",
+			displayName: "Enterprise User",
+			photoUrl: "https://example.com/photo.jpg",
+			organizations,
+		},
+	]
+
+	// Helper method to get user by name from USERS array
+	public static getUserByName(name: string) {
+		return ClineDataMock.USERS.find((u) => u.name === name)
+	}
+
+	// Helper method to get user by token from USERS array
+	public static findUserByToken(token: string) {
+		return ClineDataMock.USERS.find((u) => u.token === token)
+	}
+
+	// Helper method to get all available tokens for testing
+	public static getAllTokens() {
+		return ClineDataMock.USERS.map((u) => ({ name: u.name, token: u.token }))
+	}
+
+	// Helper method to get default tokens by type
+	public static getDefaultToken(type: "personal" | "enterprise") {
+		const user = ClineDataMock.USERS.find((u) => (type === "personal" ? !u.orgId : !!u.orgId))
+		return user?.token
+	}
+
+	constructor(userType?: "personal" | "enterprise") {
+		if (userType === "personal") {
+			const userData = ClineDataMock.findUserByToken("test-personal-token")
+			this._currentUser = userData ? this._createUserResponse(userData) : null
+		} else if (userType === "enterprise") {
+			const userData = ClineDataMock.findUserByToken("test-enterprise-token")
+			this._currentUser = userData ? this._createUserResponse(userData) : null
+		} else {
+			this._currentUser = null // Default to no user
+		}
+	}
+
+	// Mock generation data for usage tracking
+	private readonly mockGenerations = new Map<string, any>()
+
+	public getGeneration(generationId: string): any {
+		return this.mockGenerations.get(generationId)
+	}
+
+	private _currentUser: UserResponse | null = null
+
+	public getCurrentUser(): UserResponse | null {
+		return this._currentUser
+	}
+
+	public setCurrentUser(user: UserResponse | null) {
+		this._currentUser = user
+	}
+
+	// Helper method to switch to a specific user type for testing
+	public switchToUserType(type: "personal" | "enterprise"): UserResponse {
+		const token = ClineDataMock.getDefaultToken(type)
+		if (!token) {
+			throw new Error(`No ${type} user found in USERS array`)
+		}
+		return this.getUserByToken(token)
+	}
+	// Helper to create UserResponse from USERS array data
+	private _createUserResponse(userData: (typeof ClineDataMock.USERS)[0]): UserResponse {
+		const currentTime = new Date().toISOString()
+
+		return {
+			id: userData.uid,
+			email: userData.email,
+			displayName: userData.displayName,
+			photoUrl: userData.photoUrl,
+			createdAt: currentTime,
+			updatedAt: currentTime,
+			organizations,
+		}
+	}
+
+	public getUserByToken(token?: string): UserResponse {
+		// Use default personal token if none provided
+		const actualToken = token || ClineDataMock.getDefaultToken("personal") || "test-personal-token"
+		const currentUser = this._getUserByToken(actualToken.replace("_access", "")) // Remove _access suffix if present
+		this.setCurrentUser(currentUser)
+		return currentUser
+	}
+
+	// Helper function to get user data based on auth token
+	private _getUserByToken(token: string): UserResponse {
+		const match = ClineDataMock.findUserByToken(token)
+
+		if (!match) {
+			// Default fallback user for backward compatibility
+			return {
+				id: "random-user-id",
+				email: "test@example.com",
+				displayName: "Test User",
+				photoUrl: "https://example.com/photo.jpg",
+				createdAt: new Date().toISOString(),
+				updatedAt: new Date().toISOString(),
+				organizations,
+			}
+		}
+
+		return this._createUserResponse(match)
+	}
+
+	public getMockBalance(userId: string): BalanceResponse {
+		return {
+			balance: 100000, // Sufficient credits for testing
+			userId,
+		}
+	}
+
+	public getMockOrgBalance(organizationId: string): OrganizationBalanceResponse {
+		return {
+			balance: 500.0,
+			organizationId,
+		}
+	}
+
+	public getMockUsageTransactions(
+		userId: string,
+		orgId?: string,
+		max = 5,
+	): UsageTransaction[] | OrganizationUsageTransaction[] {
+		console.log("Generating mock usage transactions for", { orgId, userId })
+		const usages: (OrganizationUsageTransaction | UsageTransaction)[] = []
+		const currentTime = new Date().toISOString()
+		const memberDisplayName = this._currentUser?.displayName || "Test User"
+		const memberEmail = this._currentUser?.email || "test@example.com"
+		const firstUsage = orgId ? 6000 : 1000
+
+		for (let i = 0; i < max; i++) {
+			const completionTokens = 50 + i * 10 // 50, 60, ...
+			const randomCost = i === 0 ? firstUsage : 0.01 + i * 0.02 // $0.01, $0.03, ...
+
+			usages.push({
+				id: `usage-${i + 1}`,
+				aiInferenceProviderName: "anthropic",
+				aiModelName: orgId ? "claude-4-opus-latest" : "claude-4-sonnet-latest",
+				aiModelTypeName: "chat",
+				completionTokens,
+				costUsd: Number(randomCost.toFixed(2)),
+				createdAt: currentTime,
+				creditsUsed: Number(randomCost.toFixed(2)),
+				generationId: `gen-${i + 1}`,
+				memberDisplayName,
+				memberEmail,
+				organizationId: orgId || "",
+				promptTokens: 100,
+				totalTokens: 150,
+				userId,
+				metadata: {
+					additionalProp1: "mock-data",
+					additionalProp2: "e2e-test",
+					additionalProp3: "mock-api",
+				},
+			})
+		}
+		return usages
+	}
+
+	public getMockPaymentTransactions(creatorId: string, max = 5): PaymentTransaction[] {
+		const transactions: PaymentTransaction[] = []
+		const currentTime = new Date().toISOString()
+
+		for (let i = 0; i < max; i++) {
+			const amountCents = 1000 + i * 1000 // $10.00, $20.00, $30.00, ...
+			const credits = 10 + i * 20 // 10, 30, 50 ...
+
+			transactions.push({
+				paidAt: currentTime,
+				creatorId,
+				amountCents,
+				credits,
+			})
+		}
+		return transactions
+	}
+}
diff --git a/apps/vscode/src/test/e2e/fixtures/server/index.ts b/apps/vscode/src/test/e2e/fixtures/server/index.ts
new file mode 100644
index 0000000..b3f5abd
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/server/index.ts
@@ -0,0 +1,770 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http"
+import type { Socket } from "node:net"
+import { v4 as uuidv4 } from "uuid"
+import type { BalanceResponse, OrganizationBalanceResponse, UserResponse } from "../../../../shared/ClineAccount"
+import {
+	E2E_MOCK_API_RESPONSES,
+	E2E_MOCK_CLINE_MODELS,
+	E2E_MOCK_CLINE_RECOMMENDED_MODELS,
+	E2E_MOCK_EDITOR_TOOL_CALL,
+	E2E_REGISTERED_MOCK_ENDPOINTS,
+} from "./api"
+import { ClineDataMock } from "./data"
+
+const E2E_API_SERVER_PORT = 7777
+
+export const MOCK_CLINE_API_SERVER_URL = `http://localhost:${E2E_API_SERVER_PORT}`
+
+const useVerboseLogging = process.env.CLINE_E2E_TESTS_VERBOSE === "true"
+function log(...args: unknown[]) {
+	if (useVerboseLogging) {
+		console.log("[ClineApiServerMock]", ...args)
+	}
+}
+
+export class ClineApiServerMock {
+	static globalSharedServer: ClineApiServerMock | null = null
+	static globalSockets: Set<Socket> = new Set()
+
+	private currentUser: UserResponse | null = null
+	private userBalance = 100.5 // Default sufficient balance
+	private orgBalance = 500.0
+	private userHasOrganization = false
+	private spendLimitExceeded = false
+	public generationCounter = 0
+
+	public readonly API_USER = new ClineDataMock("personal")
+
+	constructor(public readonly server: Server) {}
+
+	// Test helper methods
+	public setUserBalance(balance: number) {
+		this.userBalance = balance
+	}
+
+	public setUserHasOrganization(hasOrg: boolean) {
+		this.userHasOrganization = hasOrg
+		const user = this.currentUser
+		if (!user) {
+			return
+		}
+		user.organizations[0].active = hasOrg
+		this.setCurrentUser(user)
+	}
+
+	public setOrgBalance(balance: number) {
+		this.orgBalance = balance
+	}
+
+	/**
+	 * Puts the mock server into "spend limit exceeded" mode.
+	 * While true, POST /api/v1/chat/completions returns 429 SPEND_LIMIT_EXCEEDED
+	 * instead of a normal streaming response.
+	 * Toggle off to resume normal behaviour.
+	 */
+	public setSpendLimitExceeded(exceeded: boolean) {
+		this.spendLimitExceeded = exceeded
+	}
+
+	public setCurrentUser(user: UserResponse | null) {
+		this.API_USER.setCurrentUser(user)
+		this.currentUser = user
+	}
+
+	// Helper to match routes against registered endpoints and extract parameters
+	private static matchRoute(
+		path: string,
+		method: string,
+	): {
+		matched: boolean
+		baseRoute?: string
+		endpoint?: string
+		params?: Record<string, string>
+	} {
+		for (const [baseRoute, methods] of Object.entries(E2E_REGISTERED_MOCK_ENDPOINTS)) {
+			const methodEndpoints = methods[method as keyof typeof methods]
+			if (!methodEndpoints) {
+				continue
+			}
+
+			for (const endpoint of methodEndpoints) {
+				const fullPattern = `${baseRoute}${endpoint}`
+				const params: Record<string, string> = {}
+
+				// Convert pattern like "/users/{userId}/balance" to a regex
+				const regexPattern = fullPattern.replace(/\{([^}]+)\}/g, () => {
+					return "([^/]+)"
+				})
+
+				const regex = new RegExp(`^${regexPattern}$`)
+				const match = path.match(regex)
+
+				if (match) {
+					// Extract parameter names from the pattern
+					const paramNames: string[] = []
+					const paramRegex = /\{([^}]+)\}/g
+					let paramMatch: RegExpExecArray | null = paramRegex.exec(fullPattern)
+					while (paramMatch !== null) {
+						paramNames.push(paramMatch[1])
+						paramMatch = paramRegex.exec(fullPattern)
+					}
+
+					// Map captured groups to parameter names
+					for (let i = 0; i < paramNames.length; i++) {
+						params[paramNames[i]] = match[i + 1]
+					}
+
+					return {
+						matched: true,
+						baseRoute,
+						endpoint,
+						params,
+					}
+				}
+			}
+		}
+
+		return { matched: false }
+	}
+
+	// Starts the global shared server
+	public static async startGlobalServer(): Promise<ClineApiServerMock> {
+		log("=== SERVER FIXTURE CALLED ===")
+		if (ClineApiServerMock.globalSharedServer) {
+			log("Using existing global server")
+			return ClineApiServerMock.globalSharedServer
+		}
+
+		log("Starting global server...")
+		const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+			// Parse URL and method
+			const parsedUrl = new URL(req.url || "/", MOCK_CLINE_API_SERVER_URL)
+			const path = parsedUrl.pathname
+			const query = Object.fromEntries(parsedUrl.searchParams.entries())
+			const method = req.method || "GET"
+
+			// Helper to read request body
+			const readBody = (): Promise<string> => {
+				return new Promise((resolve) => {
+					let body = ""
+					req.on("data", (chunk) => {
+						body += chunk.toString()
+					})
+					req.on("end", () => resolve(body))
+				})
+			}
+
+			// Helper to send JSON response
+			const sendJson = (data: unknown, status = 200) => {
+				res.writeHead(status, { "Content-Type": "application/json" })
+				res.end(JSON.stringify(data))
+			}
+
+			// Helper to send API response
+			const sendApiResponse = (data: unknown, status = 200) => {
+				log(`API Response: ${JSON.stringify(data)}`)
+				sendJson({ success: true, data }, status)
+			}
+
+			const sendApiError = (error: string, status = 400) => {
+				sendJson({ success: false, error }, status)
+			}
+
+			// Authentication middleware
+			const authHeader = req.headers.authorization
+			const isAuthRequired =
+				!path.startsWith("/.test/") &&
+				path !== "/health" &&
+				path !== "/api/v1/auth/token" &&
+				path !== "/api/v1/auth/register"
+
+			if (isAuthRequired && (!authHeader || !authHeader.startsWith("Bearer "))) {
+				return sendApiError("Unauthorized", 401)
+			}
+
+			const authToken = authHeader?.substring(7) // Remove "Bearer " prefix
+
+			// Authenticate the token and set current user
+			if (isAuthRequired && authToken) {
+				log(`Authenticating token: ${authToken}`)
+				const normalizedAuthToken = authToken.replace(/^workos:/i, "")
+				const user = ClineApiServerMock.globalSharedServer!.API_USER.getUserByToken(normalizedAuthToken)
+				if (!user) {
+					return sendApiError("Invalid token", 401)
+				}
+				ClineApiServerMock.globalSharedServer!.setCurrentUser(user)
+			}
+
+			log("=== MOCK SERVER REQUEST ===")
+			log("Method:", method)
+			log("Path:", path)
+			log("Query:", JSON.stringify(query))
+			log("Headers:", JSON.stringify(req.headers))
+			log("===============")
+
+			// Route handling
+			const handleRequest = async () => {
+				// Try to match the route using registered endpoints
+				const routeMatch = ClineApiServerMock.matchRoute(path, method)
+
+				if (!routeMatch.matched) {
+					return sendJson({ error: "Not found" }, 404)
+				}
+
+				const { baseRoute, endpoint, params = {} } = routeMatch
+				const controller = ClineApiServerMock.globalSharedServer!
+
+				// Health check endpoints
+				if (baseRoute === "/health") {
+					if (endpoint === "/" && method === "GET") {
+						return sendJson({
+							status: "ok",
+							timestamp: new Date().toISOString(),
+						})
+					}
+				}
+
+				// API v1 endpoints
+				if (baseRoute === "/api/v1") {
+					if (endpoint === "/ai/cline/recommended-models" && method === "GET") {
+						return sendJson(E2E_MOCK_CLINE_RECOMMENDED_MODELS)
+					}
+
+					if (endpoint === "/ai/cline/models" && method === "GET") {
+						return sendJson({ data: E2E_MOCK_CLINE_MODELS })
+					}
+
+					// User endpoints
+					if (endpoint === "/users/me" && method === "GET") {
+						const currentUser = controller.currentUser
+						if (!currentUser) {
+							return sendApiError("Unauthorized", 401)
+						}
+						return sendApiResponse(currentUser)
+					}
+
+					if (endpoint === "/users/me/featurebase-token" && method === "GET") {
+						const currentUser = controller.currentUser
+						if (!currentUser) {
+							return sendApiError("Unauthorized", 401)
+						}
+						return sendApiResponse({
+							featurebaseJwt: `mock-featurebase-jwt-${currentUser.id}`,
+						})
+					}
+
+					if (endpoint === "/users/{userId}/balance" && method === "GET") {
+						const { userId } = params
+						const balance: BalanceResponse = {
+							balance: controller.userBalance,
+							userId,
+						}
+						return sendApiResponse(balance)
+					}
+
+					if (endpoint === "/users/{userId}/usages" && method === "GET") {
+						const { userId } = params
+						const currentUser = controller.currentUser
+						if (currentUser?.id !== userId) {
+							return sendApiError("Unauthorized", 401)
+						}
+						return sendApiResponse({
+							items: controller.API_USER.getMockUsageTransactions(userId),
+						})
+					}
+
+					if (endpoint === "/users/{userId}/payments" && method === "GET") {
+						const { userId } = params
+						const currentUser = controller.currentUser
+						if (currentUser?.id !== userId) {
+							return sendApiError("Unauthorized", 401)
+						}
+						return sendApiResponse({
+							paymentTransactions: controller.API_USER.getMockPaymentTransactions(userId),
+						})
+					}
+
+					// Organization endpoints
+					if (endpoint === "/organizations/{orgId}/balance" && method === "GET") {
+						const { orgId } = params
+						const balance: OrganizationBalanceResponse = {
+							balance: controller.orgBalance,
+							organizationId: orgId,
+						}
+						return sendApiResponse(balance)
+					}
+
+					if (endpoint === "/organizations/{orgId}/members/{memberId}/usages" && method === "GET") {
+						const currentUser = controller.currentUser
+						if (!currentUser) {
+							return sendApiError("Unauthorized", 401)
+						}
+						const body = await readBody()
+						const { orgId } = params
+						log("Fetching organization usage transactions for", {
+							orgId,
+							body,
+						})
+						return sendApiResponse({
+							items: controller.API_USER.getMockUsageTransactions(currentUser.id, orgId),
+						})
+					}
+
+					if (endpoint === "/users/active-account" && method === "PUT") {
+						const body = await readBody()
+						log("Switching active account")
+						const { organizationId } = JSON.parse(body)
+						controller.setUserHasOrganization(!!organizationId)
+						const currentUser = controller.API_USER.getCurrentUser()
+						if (!currentUser) {
+							return sendApiError("No current user found", 400)
+						}
+						if (organizationId === null) {
+							for (const org of currentUser.organizations) {
+								org.active = false
+							}
+						} else {
+							const orgIndex = currentUser.organizations.findIndex((org) => org.organizationId === organizationId)
+							if (orgIndex === -1) {
+								return sendApiError("Organization not found", 404)
+							}
+							currentUser.organizations[orgIndex].active = controller.userHasOrganization
+						}
+						controller.setCurrentUser(currentUser)
+						return sendApiResponse("Account switched successfully")
+					}
+
+					// Auth token registration endpoint used by WorkOS device auth.
+					if (endpoint === "/auth/register" && method === "POST") {
+						const body = await readBody()
+						const parsed = JSON.parse(body)
+						const { accessToken, refreshToken } = parsed
+
+						if (!accessToken || !refreshToken) {
+							return sendApiError("Invalid request", 400)
+						}
+
+						const user = controller.API_USER.getUserByToken(accessToken)
+						if (!user) {
+							return sendApiError("Invalid WorkOS token", 400)
+						}
+
+						return sendApiResponse({
+							accessToken: accessToken + "_access",
+							refreshToken,
+							tokenType: "Bearer",
+							expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(),
+							userInfo: {
+								subject: user.id,
+								email: user.email,
+								name: user.displayName,
+								clineUserId: user.id,
+								accounts: null,
+								organizations: user.organizations,
+							},
+						})
+					}
+
+					// Auth token exchange endpoint
+					if (endpoint === "/auth/token" && method === "POST") {
+						const body = await readBody()
+						const parsed = JSON.parse(body)
+						const { code } = parsed
+						const grantType = parsed.grantType ?? parsed.grant_type
+
+						if (grantType !== "authorization_code" || !code) {
+							return sendApiError("Invalid request", 400)
+						}
+
+						const user = controller.API_USER.getUserByToken(code)
+						if (!user) {
+							return sendApiError("Invalid or expired authorization code", 400)
+						}
+
+						// Return format matching ClineAuthProvider expectations
+						return sendApiResponse({
+							accessToken: code + "_access",
+							refreshToken: code + "_refresh",
+							tokenType: "Bearer",
+							expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(), // 1 hour from now
+							userInfo: {
+								subject: user.id,
+								email: user.email,
+								name: user.displayName,
+								clineUserId: user.id,
+								accounts: null,
+								organizations: user.organizations,
+							},
+						})
+					}
+
+					// Auth refresh token endpoint
+					if (endpoint === "/auth/refresh" && method === "POST") {
+						const body = await readBody()
+						const parsed = JSON.parse(body)
+						const { refreshToken, grantType } = parsed
+
+						if (grantType !== "refresh_token" || !refreshToken) {
+							return sendApiError("Invalid request", 400)
+						}
+
+						// Extract original token from refresh token
+						const originalToken = refreshToken.replace("_refresh", "")
+						const user = controller.API_USER.getUserByToken(originalToken)
+						if (!user) {
+							return sendApiError("Invalid or expired refresh token", 400)
+						}
+
+						// Return format matching ClineAuthProvider expectations
+						return sendApiResponse({
+							accessToken: originalToken + "_access_refreshed",
+							refreshToken: refreshToken, // Keep same refresh token
+							tokenType: "Bearer",
+							expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(), // 1 hour from now
+							userInfo: {
+								subject: user.id,
+								email: user.email,
+								name: user.displayName,
+								clineUserId: user.id,
+								accounts: null,
+							},
+						})
+					}
+
+					// Budget limit increase request endpoint
+					if (endpoint === "/users/me/budget/request" && method === "POST") {
+						log("Spend limit increase request received — recording and notifying admin")
+						res.writeHead(204)
+						res.end()
+						return
+					}
+
+					// Chat completions endpoint
+					if (endpoint === "/chat/completions" && method === "POST") {
+						// Spend limit check takes priority — org-enforced budget cap (429)
+						if (controller.spendLimitExceeded) {
+							log("Returning SPEND_LIMIT_EXCEEDED (429)")
+							return sendJson(
+								{
+									error: {
+										code: "SPEND_LIMIT_EXCEEDED",
+										limit_scope: "user",
+										budget_period: "daily",
+										limit_usd: 20.0,
+										spent_usd: 20.5,
+										resets_at: new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString(),
+										message: "Your daily spend limit of $20.00 has been reached.",
+									},
+								},
+								429,
+							)
+						}
+
+						if (!controller.userHasOrganization && controller.userBalance <= 0) {
+							return sendApiError(
+								JSON.stringify({
+									code: "insufficient_credits",
+									current_balance: controller.userBalance,
+									message: "Not enough credits available",
+								}),
+								402,
+							)
+						}
+
+						const body = await readBody()
+						const parsed = JSON.parse(body)
+						const { messages, model = "claude-3-5-sonnet-20241022", stream = true } = parsed
+
+						// The SDK runtime executes structured tool calls and then sends a
+						// follow-up /chat/completions request containing the tool result as
+						// a `role: "tool"` message. Detect that follow-up first — the
+						// original "edit_request" user prompt is still present in the
+						// conversation history of the follow-up request, so order matters.
+						// Scoped to edit_request conversations so tool results from other
+						// (future) scenarios don't mis-route to EDIT_REQUEST_COMPLETE.
+						const hasToolResult =
+							body.includes("edit_request") &&
+							Array.isArray(messages) &&
+							messages.some((m: { role?: string }) => m?.role === "tool")
+
+						let responseText = E2E_MOCK_API_RESPONSES.DEFAULT
+						let includeEditorToolCall = false
+						log("Chat completion mock selection:", {
+							isEditRequest: body.includes("edit_request"),
+							hasToolResult,
+						})
+						if (hasToolResult) {
+							responseText = E2E_MOCK_API_RESPONSES.EDIT_REQUEST_COMPLETE
+						} else if (body.includes("edit_request")) {
+							// Stream lead-in text followed by a structured `editor` tool
+							// call (OpenAI tool_calls deltas) — the only tool-call syntax
+							// the SDK runtime executes.
+							responseText = E2E_MOCK_API_RESPONSES.EDIT_REQUEST_LEAD_IN
+							includeEditorToolCall = true
+						}
+						const generationId = `gen_${++controller.generationCounter}_${Date.now()}`
+
+						if (stream) {
+							res.writeHead(200, {
+								"Content-Type": "text/plain",
+								"Cache-Control": "no-cache",
+								Connection: "keep-alive",
+							})
+
+							const randomUUID = uuidv4()
+
+							responseText += `\n\nGenerated UUID: ${randomUUID}`
+
+							const chunks = responseText.split(" ")
+							let chunkIndex = 0
+
+							// OpenAI-format streamed tool call deltas, matching what the
+							// AI SDK's openai-compatible client expects: the first delta
+							// for a tool_calls index must carry `id` + `function.name`;
+							// `function.arguments` accumulates as string fragments. Split
+							// the arguments JSON to exercise fragment reassembly.
+							const argumentsJson = JSON.stringify(E2E_MOCK_EDITOR_TOOL_CALL.arguments)
+							const argsSplitAt = Math.floor(argumentsJson.length / 2)
+							const toolCallDeltas = includeEditorToolCall
+								? [
+										[
+											{
+												index: 0,
+												id: E2E_MOCK_EDITOR_TOOL_CALL.id,
+												type: "function",
+												function: { name: E2E_MOCK_EDITOR_TOOL_CALL.name, arguments: "" },
+											},
+										],
+										[
+											{
+												index: 0,
+												function: { arguments: argumentsJson.slice(0, argsSplitAt) },
+											},
+										],
+										[
+											{
+												index: 0,
+												function: { arguments: argumentsJson.slice(argsSplitAt) },
+											},
+										],
+									]
+								: []
+							let toolCallDeltaIndex = 0
+
+							const sendChunk = () => {
+								if (chunkIndex < chunks.length) {
+									const chunk = {
+										id: generationId,
+										object: "chat.completion.chunk",
+										created: Math.floor(Date.now() / 1000),
+										model,
+										choices: [
+											{
+												index: 0,
+												delta: {
+													content: chunks[chunkIndex] + (chunkIndex < chunks.length - 1 ? " " : ""),
+												},
+												finish_reason: null,
+											},
+										],
+									}
+									res.write(`data: ${JSON.stringify(chunk)}\n\n`)
+									chunkIndex++
+									setTimeout(sendChunk, 10)
+								} else if (toolCallDeltaIndex < toolCallDeltas.length) {
+									const chunk = {
+										id: generationId,
+										object: "chat.completion.chunk",
+										created: Math.floor(Date.now() / 1000),
+										model,
+										choices: [
+											{
+												index: 0,
+												delta: {
+													tool_calls: toolCallDeltas[toolCallDeltaIndex],
+												},
+												finish_reason: null,
+											},
+										],
+									}
+									res.write(`data: ${JSON.stringify(chunk)}\n\n`)
+									toolCallDeltaIndex++
+									setTimeout(sendChunk, 10)
+								} else {
+									const finalChunk = {
+										id: generationId,
+										object: "chat.completion.chunk",
+										created: Math.floor(Date.now() / 1000),
+										model,
+										choices: [
+											{
+												index: 0,
+												delta: {},
+												finish_reason: includeEditorToolCall ? "tool_calls" : "stop",
+											},
+										],
+										usage: {
+											prompt_tokens: 140,
+											completion_tokens: responseText.length,
+											total_tokens: 140 + responseText.length,
+											cost: (140 + responseText.length) * 0.00015,
+										},
+									}
+									res.write(`data: ${JSON.stringify(finalChunk)}\n\n`)
+									res.write("data: [DONE]\n\n")
+									res.end()
+								}
+							}
+
+							sendChunk()
+							return
+						}
+						const response = {
+							id: generationId,
+							object: "chat.completion",
+							created: Math.floor(Date.now() / 1000),
+							model,
+							choices: [
+								{
+									index: 0,
+									message: {
+										role: "assistant",
+										content: "Hello! I'm a mock Cline API response.",
+									},
+									finish_reason: "stop",
+								},
+							],
+							usage: {
+								prompt_tokens: 140,
+								completion_tokens: responseText.length,
+								total_tokens: 140 + responseText.length,
+								cost: (140 + responseText.length) * 0.00015,
+							},
+						}
+						return sendJson(response)
+					}
+
+					// Generation details endpoint
+					if (endpoint === "/generation" && method === "GET") {
+						const generationId = parsedUrl.searchParams.get("id") || ""
+						const generation = controller.API_USER.getGeneration(generationId)
+
+						if (!generation) {
+							return sendJson({ error: "Generation not found" }, 404)
+						}
+
+						return sendJson(generation)
+					}
+				}
+
+				// Test helper endpoints
+				if (baseRoute === "/.test") {
+					if (endpoint === "/auth" && method === "POST") {
+						const user = controller.API_USER.getUserByToken()
+						if (!user) {
+							return sendApiError("Invalid token", 401)
+						}
+						controller.setCurrentUser(user)
+						return
+					}
+
+					if (endpoint === "/setUserBalance" && method === "POST") {
+						const body = await readBody()
+						const { balance } = JSON.parse(body)
+						controller.setUserBalance(balance)
+						res.writeHead(200)
+						res.end()
+						return
+					}
+
+					if (endpoint === "/setUserHasOrganization" && method === "POST") {
+						const body = await readBody()
+						const { hasOrg } = JSON.parse(body)
+						controller.setUserHasOrganization(hasOrg)
+						res.writeHead(200)
+						res.end()
+						return
+					}
+
+					if (endpoint === "/setOrgBalance" && method === "POST") {
+						const body = await readBody()
+						const { balance } = JSON.parse(body)
+						controller.setOrgBalance(balance)
+						res.writeHead(200)
+						res.end()
+						return
+					}
+
+					if (endpoint === "/setSpendLimitExceeded" && method === "POST") {
+						const body = await readBody()
+						const { exceeded } = JSON.parse(body)
+						controller.setSpendLimitExceeded(!!exceeded)
+						res.writeHead(200)
+						res.end()
+						return
+					}
+				}
+
+				// If we get here, the route was matched but not handled
+				return sendJson({ error: "Endpoint not implemented" }, 500)
+			}
+
+			handleRequest().catch((err) => {
+				console.error("Request handling error:", err)
+				sendApiError("Internal server error", 500)
+			})
+		})
+
+		// Initialize the controller after the server is created
+		const controller = new ClineApiServerMock(server)
+		ClineApiServerMock.globalSharedServer = controller
+
+		// Track connections for proper cleanup
+		server.on("connection", (socket) => {
+			ClineApiServerMock.globalSockets.add(socket)
+			socket.on("close", () => {
+				ClineApiServerMock.globalSockets.delete(socket)
+			})
+		})
+
+		await new Promise<void>((resolve, reject) => {
+			server.listen(E2E_API_SERVER_PORT, (error?: Error) => {
+				if (error) {
+					console.error(`Failed to start server on port ${E2E_API_SERVER_PORT}:`, error)
+					reject(error)
+				} else {
+					log(`ClineApiServerMock listening on port ${E2E_API_SERVER_PORT}`)
+					resolve()
+				}
+			})
+		})
+
+		return controller
+	}
+
+	// Stops the global shared server
+	public static async stopGlobalServer(): Promise<void> {
+		if (!ClineApiServerMock.globalSharedServer) {
+			return
+		}
+
+		const server = ClineApiServerMock.globalSharedServer.server
+
+		// Clean shutdown - destroy all socket connections first
+		ClineApiServerMock.globalSockets.forEach((socket) => socket.destroy())
+		ClineApiServerMock.globalSockets.clear()
+
+		await new Promise<void>((resolve, reject) => {
+			server.close((err) => {
+				if (err) {
+					console.error("Error closing server:", err)
+					reject(err)
+				}
+				log("Server closed successfully")
+				resolve()
+			})
+		})
+
+		ClineApiServerMock.globalSharedServer = null
+	}
+}
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace/.gitignore b/apps/vscode/src/test/e2e/fixtures/workspace/.gitignore
new file mode 100644
index 0000000..b512c09
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace/.gitignore
@@ -0,0 +1 @@
+node_modules
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace/.vscode/settings.json b/apps/vscode/src/test/e2e/fixtures/workspace/.vscode/settings.json
new file mode 100644
index 0000000..51da767
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+	"workbench.secondarySideBar.defaultVisibility": "hidden"
+}
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace/README.md b/apps/vscode/src/test/e2e/fixtures/workspace/README.md
new file mode 100644
index 0000000..49d09df
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace/README.md
@@ -0,0 +1,3 @@
+# Test Workspace
+
+This workspace is used for testing the extension in a controlled environment.
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace/index.html b/apps/vscode/src/test/e2e/fixtures/workspace/index.html
new file mode 100644
index 0000000..370a811
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace/index.html
@@ -0,0 +1,10 @@
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>Test Workspace</title>
+	</head>
+	<body>
+		<h1>Test Workspace</h1>
+	</body>
+</html>
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace/test.ts b/apps/vscode/src/test/e2e/fixtures/workspace/test.ts
new file mode 100644
index 0000000..20d7607
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace/test.ts
@@ -0,0 +1 @@
+export const name = "john"
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace_2/README.md b/apps/vscode/src/test/e2e/fixtures/workspace_2/README.md
new file mode 100644
index 0000000..678a7b2
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace_2/README.md
@@ -0,0 +1,3 @@
+# Test Workspace 2
+
+This workspace is used for testing the extension in a controlled environment.
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/anthropic.py b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/anthropic.py
new file mode 100644
index 0000000..92e9d1e
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/anthropic.py
@@ -0,0 +1,9 @@
+import anthropic
+
+anthropic.Anthropic().messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    messages=[
+        {"role": "user", "content": "Hello, world"}
+    ]
+)
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/google.py b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/google.py
new file mode 100644
index 0000000..84dfc9e
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/google.py
@@ -0,0 +1,10 @@
+from google import genai
+
+client = genai.Client()
+
+response = client.models.generate_content(
+    model="gemini-2.5-flash",
+    contents="Explain how AI works in a few words",
+)
+
+print(response.text)
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/openai.py b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/openai.py
new file mode 100644
index 0000000..6fe1e2d
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/openai.py
@@ -0,0 +1,9 @@
+from openai import OpenAI
+client = OpenAI()
+
+response = client.responses.create(
+    model="gpt-5",
+    input="Write a one-sentence bedtime story about a unicorn."
+)
+
+print(response.output_text)
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/openrouter.py b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/openrouter.py
new file mode 100644
index 0000000..861838e
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/openrouter.py
@@ -0,0 +1,22 @@
+from openai import OpenAI
+
+client = OpenAI(
+  base_url="https://openrouter.ai/api/v1",
+  api_key="<OPENROUTER_API_KEY>",
+)
+
+completion = client.chat.completions.create(
+  extra_headers={
+    "HTTP-Referer": "<YOUR_SITE_URL>", # Optional. Site URL for rankings on openrouter.ai.
+    "X-Title": "<YOUR_SITE_NAME>", # Optional. Site title for rankings on openrouter.ai.
+  },
+  model="openai/gpt-4o",
+  messages=[
+    {
+      "role": "user",
+      "content": "What is the meaning of life?"
+    }
+  ]
+)
+
+print(completion.choices[0].message.content)
diff --git a/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/xai.py b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/xai.py
new file mode 100644
index 0000000..eb8e2cc
--- /dev/null
+++ b/apps/vscode/src/test/e2e/fixtures/workspace_2/providers/xai.py
@@ -0,0 +1,16 @@
+import os
+
+from xai_sdk import Client
+from xai_sdk.chat import user, system
+
+client = Client(
+  api_key=os.getenv("XAI_API_KEY"),
+  timeout=3600,  # Override default timeout with longer timeout for reasoning models
+)
+
+chat = client.chat.create(model="grok-4")
+chat.append(system("You are a PhD-level mathematician."))
+chat.append(user("What is 2 + 2?"))
+
+response = chat.sample()
+print(response.content)
\ No newline at end of file
diff --git a/apps/vscode/src/test/e2e/utils/build.mjs b/apps/vscode/src/test/e2e/utils/build.mjs
new file mode 100644
index 0000000..0ae71e7
--- /dev/null
+++ b/apps/vscode/src/test/e2e/utils/build.mjs
@@ -0,0 +1,44 @@
+/**
+ * Script to install dependencies for running E2E tests in GitHub Actions.
+ */
+import { downloadAndUnzipVSCode, SilentReporter } from "@vscode/test-electron"
+import { execa } from "execa"
+
+const TIMEOUT_MINUTE = 1
+const INSTALL_TIMEOUT_MS = TIMEOUT_MINUTE * 60 * 1000
+
+async function installVSCode() {
+	const VSCODE_APP_TYPE = "stable"
+	console.log("Downloading VS Code...")
+	return await downloadAndUnzipVSCode(VSCODE_APP_TYPE, undefined, new SilentReporter())
+}
+
+async function installChromium() {
+	console.log("Installing Playwright Chromium...")
+	try {
+		await execa("npm", ["exec", "playwright", "install", "chromium"], {
+			stdio: "inherit",
+		})
+		console.log("Playwright Chromium installation completed successfully")
+	} catch (error) {
+		throw new Error(`Failed to install Playwright Chromium: ${error}`)
+	}
+}
+
+async function installDependencies() {
+	return Promise.all([installVSCode(), installChromium()])
+}
+
+async function main() {
+	const timeoutPromise = new Promise((_, reject) =>
+		setTimeout(() => reject(new Error("Installation timed out.")), INSTALL_TIMEOUT_MS),
+	)
+	await Promise.race([installDependencies(), timeoutPromise])
+	console.log("Installation complete.")
+	process.exit(0)
+}
+
+main().catch((error) => {
+	console.error("Failed to install dependencies for E2E test", error)
+	process.exit(1)
+})
diff --git a/apps/vscode/src/test/e2e/utils/common.ts b/apps/vscode/src/test/e2e/utils/common.ts
new file mode 100644
index 0000000..75d95a4
--- /dev/null
+++ b/apps/vscode/src/test/e2e/utils/common.ts
@@ -0,0 +1,38 @@
+import type { Page } from "@playwright/test"
+
+export const openTab = async (_page: Page, tabName: string) => {
+	await _page
+		.getByRole("tab", { name: new RegExp(`${tabName}`) })
+		.locator("a")
+		.click()
+}
+
+export const addSelectedCodeToClineWebview = async (_page: Page) => {
+	await _page.locator("div:nth-child(4) > span > span").first().click()
+	await _page.getByRole("textbox", { name: "The editor is not accessible" }).press("ControlOrMeta+a")
+
+	// Open Code Actions via keyboard for cross-platform reliability
+	await _page.keyboard.press("ControlOrMeta+.")
+
+	// Target the explicit action instead of pressing Enter on the first item.
+	// The first item can vary by platform or diagnostics.
+	const addToCline = _page.getByText(/Add to Cline/i)
+	await addToCline.waitFor({ state: "visible" })
+	// For whatever reason, we need to move the mouse to make the context menu item clickable
+	await _page.mouse.move(10, 10)
+	await _page.mouse.move(20, 10)
+	await addToCline.click()
+}
+
+export const toggleNotifications = async (_page: Page) => {
+	await _page.waitForLoadState("domcontentloaded")
+	await _page.keyboard.press("ControlOrMeta+Shift+p")
+	const editorSearchBar = _page.getByRole("textbox")
+	if (!editorSearchBar.isVisible()) {
+		await _page.keyboard.press("ControlOrMeta+Shift+p")
+	}
+	await editorSearchBar.click({ delay: 100 }) // Ensure focus
+	await editorSearchBar.fill("> Toggle Do Not Disturb Mode")
+	await _page.keyboard.press("Enter")
+	return _page
+}
diff --git a/apps/vscode/src/test/e2e/utils/global.setup.ts b/apps/vscode/src/test/e2e/utils/global.setup.ts
new file mode 100644
index 0000000..c45ea2a
--- /dev/null
+++ b/apps/vscode/src/test/e2e/utils/global.setup.ts
@@ -0,0 +1,27 @@
+import { rmSync } from "node:fs"
+import { test as setup } from "@playwright/test"
+import { E2ETestHelper } from "./helpers"
+
+setup("setup test environment", async () => {
+	try {
+		const path = E2ETestHelper.getResultsDir()
+		const options = { recursive: true, force: true }
+
+		const maxAttempts = 2
+
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			try {
+				rmSync(path, options)
+				return
+			} catch (error) {
+				if (attempt === maxAttempts) {
+					throw new Error(`Failed to rmSync ${path} after ${maxAttempts} attempts: ${error}`)
+				}
+				console.error(`Failed to rmSync ${path} after ${attempt} attempts: ${error}`)
+				await new Promise((resolve) => setTimeout(resolve, 50 * attempt)) // Progressive delay
+			}
+		}
+	} catch (error) {
+		console.error(`Error during setup: ${error}`)
+	}
+})
diff --git a/apps/vscode/src/test/e2e/utils/helpers.ts b/apps/vscode/src/test/e2e/utils/helpers.ts
new file mode 100644
index 0000000..0fad7ac
--- /dev/null
+++ b/apps/vscode/src/test/e2e/utils/helpers.ts
@@ -0,0 +1,484 @@
+import type { ChildProcess } from "node:child_process"
+import { mkdtempSync, type PathLike, type RmOptions, readdirSync, rmSync } from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+import { type ElectronApplication, expect, type Frame, type Page, test } from "@playwright/test"
+import { downloadAndUnzipVSCode, SilentReporter } from "@vscode/test-electron"
+import { _electron } from "playwright"
+import { ClineApiServerMock } from "../fixtures/server"
+
+interface E2ETestDirectories {
+	workspaceDir: string
+	multiRootWorkspaceDir: string
+	userDataDir: string
+	extensionsDir: string
+}
+
+export interface E2ETestConfigs {
+	workspaceType: "single" | "multi"
+	channel: "stable" | "insiders"
+}
+
+export class E2ETestHelper {
+	// Constants
+	public static readonly CODEBASE_ROOT_DIR = path.resolve(__dirname, "..", "..", "..", "..")
+	public static readonly E2E_TESTS_DIR = path.join(E2ETestHelper.CODEBASE_ROOT_DIR, "src", "test", "e2e")
+	private static readonly TEARDOWN_TIMEOUT_MS = 10_000
+	private static readonly WINDOW_DIAGNOSTIC_TIMEOUT_MS = 1_000
+	private static readonly PROCESS_EXIT_TIMEOUT_MS = 2_000
+
+	// Instance properties for caching
+	private cachedFrame: Frame | null = null
+
+	// Path utilities
+	public static escapeToPath(text: string): string {
+		return text.trim().toLowerCase().replaceAll(/\W/g, "_")
+	}
+
+	public static getResultsDir(testName = "", label?: string): string {
+		const testDir = path.join(
+			E2ETestHelper.CODEBASE_ROOT_DIR,
+			"test-results",
+			"playwright",
+			E2ETestHelper.escapeToPath(testName),
+		)
+		return label ? path.join(testDir, label) : testDir
+	}
+
+	/**
+	 * Generates a filename for gRPC recorder logs based on test information
+	 * @param testTitle The title of the test
+	 * @param projectName The name of the test project (optional)
+	 * @returns A sanitized filename suitable for gRPC recorder logs
+	 */
+	public static generateTestFileName(testTitle: string, projectName?: string): string {
+		// Create a base name from the test title
+		const baseName = E2ETestHelper.escapeToPath(testTitle)
+
+		// Add project name if provided and different from default
+		const projectSuffix = projectName && projectName !== "e2e tests" ? `_${E2ETestHelper.escapeToPath(projectName)}` : ""
+
+		return `${baseName}${projectSuffix}`
+	}
+
+	public static async waitUntil(predicate: () => boolean | Promise<boolean>, maxDelay = 10000): Promise<void> {
+		let delay = 10
+		const start = Date.now()
+
+		while (!(await predicate())) {
+			if (Date.now() - start > maxDelay) {
+				throw new Error(`waitUntil timeout after ${maxDelay}ms`)
+			}
+			await new Promise((resolve) => setTimeout(resolve, delay))
+			delay = Math.min(delay << 1, 1000) // Cap at 1s
+		}
+	}
+
+	public async getSidebar(page: Page): Promise<Frame> {
+		const findSidebarFrame = async (): Promise<Frame | null> => {
+			// Check cached frame first
+			if (this.cachedFrame && !this.cachedFrame.isDetached()) {
+				return this.cachedFrame
+			}
+
+			for (const frame of page.frames()) {
+				if (frame.isDetached()) {
+					continue
+				}
+
+				try {
+					const title = await frame.title()
+					if (title.startsWith("Cline")) {
+						this.cachedFrame = frame
+						return frame
+					}
+				} catch (error: any) {
+					if (!error.message.includes("detached") && !error.message.includes("navigation")) {
+						throw error
+					}
+				}
+			}
+			return null
+		}
+
+		// Use longer timeout (30s) for sidebar - macOS CI runners can be slow
+		await E2ETestHelper.waitUntil(async () => (await findSidebarFrame()) !== null, 30000)
+		return (await findSidebarFrame()) || page.mainFrame()
+	}
+
+	public static async rmForRetries(path: PathLike, options?: RmOptions): Promise<void> {
+		const maxAttempts = 3 // Reduced from 5
+
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			try {
+				rmSync(path, options)
+				return
+			} catch (error) {
+				if (attempt === maxAttempts) {
+					throw new Error(`Failed to rmSync ${path} after ${maxAttempts} attempts: ${error}`)
+				}
+				await new Promise((resolve) => setTimeout(resolve, 50 * attempt)) // Progressive delay
+			}
+		}
+	}
+
+	private static async withTimeout<T>(
+		promise: Promise<T>,
+		timeoutMs: number,
+	): Promise<{ timedOut: false; value: T } | { timedOut: true }> {
+		let timeout: ReturnType<typeof setTimeout> | undefined
+		let timedOut = false
+
+		try {
+			const value = await Promise.race([
+				promise.then((value) => ({ timedOut: false as const, value })),
+				new Promise<{ timedOut: true }>((resolve) => {
+					timeout = setTimeout(() => {
+						timedOut = true
+						resolve({ timedOut: true })
+					}, timeoutMs)
+				}),
+			])
+
+			return value
+		} finally {
+			if (timeout) {
+				clearTimeout(timeout)
+			}
+			if (timedOut) {
+				void promise.catch(() => undefined)
+			}
+		}
+	}
+
+	private static async getWindowDiagnostics(app: ElectronApplication): Promise<string> {
+		const windows = app.windows()
+		const titles = await Promise.all(
+			windows.map(async (window, index) => {
+				if (window.isClosed()) {
+					return `#${index}: closed`
+				}
+
+				const title = await E2ETestHelper.withTimeout(window.title(), E2ETestHelper.WINDOW_DIAGNOSTIC_TIMEOUT_MS)
+				return title.timedOut ? `#${index}: title timed out` : `#${index}: ${title.value || "<untitled>"}`
+			}),
+		)
+
+		return titles.length > 0 ? titles.join(", ") : "no windows"
+	}
+
+	private static async waitForProcessExit(process: ChildProcess, timeoutMs: number): Promise<boolean> {
+		if (process.exitCode !== null || process.signalCode !== null) {
+			return true
+		}
+
+		return new Promise((resolve) => {
+			const onExit = () => {
+				clearTimeout(timeout)
+				resolve(true)
+			}
+			const timeout = setTimeout(() => {
+				process.off("exit", onExit)
+				resolve(process.exitCode !== null || process.signalCode !== null)
+			}, timeoutMs)
+
+			process.once("exit", onExit)
+		})
+	}
+
+	public static async closePageForTeardown(page: Page): Promise<void> {
+		if (page.isClosed()) {
+			return
+		}
+
+		const result = await E2ETestHelper.withTimeout(page.close(), E2ETestHelper.TEARDOWN_TIMEOUT_MS).catch((error) => {
+			console.warn(`[e2e teardown] page.close() failed: ${error}`)
+			return { timedOut: false as const, value: undefined }
+		})
+		if (result.timedOut) {
+			console.warn(`[e2e teardown] page.close() exceeded ${E2ETestHelper.TEARDOWN_TIMEOUT_MS}ms; continuing to app cleanup`)
+		}
+	}
+
+	public static async closeAppForTeardown(app: ElectronApplication): Promise<void> {
+		const process = app.process()
+		const getProcessSummary = () =>
+			process
+				? `pid=${process.pid ?? "unknown"} exitCode=${process.exitCode ?? "null"} signalCode=${process.signalCode ?? "null"} killed=${process.killed}`
+				: "process unavailable"
+
+		const closeResult = await E2ETestHelper.withTimeout(app.close(), E2ETestHelper.TEARDOWN_TIMEOUT_MS).catch((error) => {
+			console.warn(`[e2e teardown] app.close() failed: ${error}`)
+			return { timedOut: true as const }
+		})
+		if (!closeResult.timedOut) {
+			return
+		}
+
+		const windowDiagnostics = await E2ETestHelper.getWindowDiagnostics(app).catch(
+			(error) => `window diagnostics failed: ${error}`,
+		)
+		console.warn(
+			`[e2e teardown] app.close() exceeded ${E2ETestHelper.TEARDOWN_TIMEOUT_MS}ms; forcing VS Code/Electron shutdown (${getProcessSummary()}; windows: ${windowDiagnostics})`,
+		)
+
+		if (!process || process.killed || process.exitCode !== null) {
+			return
+		}
+
+		try {
+			if (process.kill("SIGKILL")) {
+				const exited = await E2ETestHelper.waitForProcessExit(process, E2ETestHelper.PROCESS_EXIT_TIMEOUT_MS)
+				if (!exited) {
+					console.warn(
+						`[e2e teardown] VS Code/Electron process did not report exit within ${E2ETestHelper.PROCESS_EXIT_TIMEOUT_MS}ms after SIGKILL (${getProcessSummary()})`,
+					)
+				}
+				return
+			}
+
+			console.warn(
+				`[e2e teardown] SIGKILL returned false for VS Code/Electron process; skipping SIGTERM (${getProcessSummary()})`,
+			)
+			return
+		} catch (error) {
+			console.warn(`[e2e teardown] SIGKILL failed for VS Code/Electron process: ${error}`)
+		}
+
+		try {
+			if (process.exitCode === null && process.signalCode === null && process.kill("SIGTERM")) {
+				await E2ETestHelper.waitForProcessExit(process, E2ETestHelper.PROCESS_EXIT_TIMEOUT_MS)
+			}
+		} catch (error) {
+			console.warn(`[e2e teardown] SIGTERM failed for VS Code/Electron process: ${error}`)
+		}
+	}
+
+	public async signin(webview: Frame): Promise<void> {
+		await webview.getByRole("button", { name: "Login to Cline" }).click({ delay: 100 })
+
+		// Verify start up page is no longer visible
+		await expect(webview.getByRole("button", { name: "Login to Cline" })).not.toBeVisible()
+
+		const closeButton = webview.getByRole("button", { name: "Close" })
+		let shouldCloseModal = false
+		try {
+			await closeButton.waitFor({ state: "visible", timeout: 5_000 })
+			shouldCloseModal = true
+		} catch {
+			// No blocking modal appeared after sign-in.
+		}
+		if (shouldCloseModal) {
+			await closeButton.click({ delay: 50 })
+		}
+	}
+
+	public static async openClineSidebar(page: Page): Promise<void> {
+		await page.getByRole("tab", { name: /Cline/ }).locator("a").click()
+	}
+
+	public static async runCommandPalette(page: Page, command: string): Promise<void> {
+		const editorMenu = page.locator("li").filter({ hasText: "[Extension Development Host]" }).first()
+		await editorMenu.click({ delay: 100 })
+		const editorSearchBar = page.getByRole("textbox", {
+			name: "Search files by name (append",
+		})
+		await editorSearchBar.click({ delay: 100 }) // Ensure focus
+		await editorSearchBar.fill(`>${command}`)
+		await page.keyboard.press("Enter")
+	}
+
+	// Clear cached frame when needed
+	public clearCachedFrame(): void {
+		this.cachedFrame = null
+	}
+}
+
+/**
+ * NOTE: Use the `e2e` test fixture for all E2E tests to test the Cline extension.
+ *
+ * Extended Playwright test configuration for Cline E2E testing.
+ *
+ * This test configuration provides a comprehensive setup for end-to-end testing of the Cline VS Code extension,
+ * including server mocking, temporary directories, VS Code instance management, and helper utilities.
+ *
+ * NOTE: Default to run in single-root workspace; use `e2eMultiRoot` for multi-root workspace tests.
+ *
+ * @extends test - Base Playwright test with multiple fixture extensions
+ *
+ * Fixtures provided:
+ * - `server`: Shared ClineApiServerMock instance for API mocking (reused across all tests)
+ * - `workspaceDir`: Path to the test workspace directory
+ * - `userDataDir`: Temporary directory for VS Code user data
+ * - `extensionsDir`: Temporary directory for VS Code extensions
+ * - `openVSCode`: Function that returns a Promise resolving to an ElectronApplication instance
+ * - `app`: ElectronApplication instance with automatic cleanup
+ * - `helper`: E2ETestHelper instance for test utilities
+ * - `page`: Playwright Page object representing the main VS Code window with Cline sidebar opened
+ * - `sidebar`: Playwright Frame object representing the Cline extension's sidebar iframe
+ *
+ * @returns Extended test object with all fixtures available for E2E test scenarios:
+ * - **server**: Automatically starts and manages a ClineApiServerMock instance
+ * - **workspaceDir**: Sets up a test workspace directory from fixtures
+ * - **userDataDir**: Creates a temporary directory for VS Code user data
+ * - **extensionsDir**: Creates a temporary directory for VS Code extensions
+ * - **openVSCode**: Factory function that launches VS Code with proper configuration for testing
+ * - **app**: Manages the VS Code ElectronApplication lifecycle with automatic cleanup
+ * - **helper**: Provides E2ETestHelper utilities for test operations
+ * - **page**: Configures the main VS Code window with notifications disabled and Cline sidebar open
+ * - **sidebar**: Provides access to the Cline extension's sidebar frame
+ *
+ * @example
+ * ```typescript
+ * e2e('should perform basic operations', async ({ sidebar, helper }) => {
+ *   // Test implementation using the configured sidebar and helper
+ * });
+ * ```
+ *
+ * @remarks
+ * - Automatically handles VS Code download and setup
+ * - Installs the Cline extension in development mode
+ * - Records test videos for debugging
+ * - Performs cleanup of temporary directories after each test
+ * - Configures VS Code with disabled updates, workspace trust, and welcome screens
+ */
+export const e2e = test
+	.extend<{ server: ClineApiServerMock | null }>({
+		server: async ({}, use) => {
+			// Start server if it doesn't exist
+			if (!ClineApiServerMock.globalSharedServer) {
+				await ClineApiServerMock.startGlobalServer()
+			}
+			await use(ClineApiServerMock.globalSharedServer)
+		},
+	})
+	.extend<E2ETestDirectories>({
+		workspaceDir: async ({}, use) => {
+			await use(path.join(E2ETestHelper.E2E_TESTS_DIR, "fixtures", "workspace"))
+		},
+		multiRootWorkspaceDir: async ({}, use) => {
+			// DOCS: https://code.visualstudio.com/docs/editing/workspaces/multi-root-workspaces
+			await use(path.join(E2ETestHelper.E2E_TESTS_DIR, "fixtures", "multiroots.code-workspace"))
+		},
+		userDataDir: async ({}, use) => {
+			await use(mkdtempSync(path.join(os.tmpdir(), "vsce")))
+		},
+		extensionsDir: async ({}, use) => {
+			await use(mkdtempSync(path.join(os.tmpdir(), "vsce")))
+		},
+	})
+	.extend<E2ETestConfigs>({
+		workspaceType: "single",
+		channel: "stable",
+	})
+	.extend<{ openVSCode: (workspacePath: string) => Promise<ElectronApplication> }>({
+		openVSCode: async ({ userDataDir, channel }, use, testInfo) => {
+			const executablePath = await downloadAndUnzipVSCode(channel, undefined, new SilentReporter())
+
+			await use(async (workspacePath: string) => {
+				// Create isolated Cline data directory for this test
+				const clineTestDir = mkdtempSync(path.join(os.tmpdir(), "cline-e2e-"))
+				const clineDataDir = path.join(clineTestDir, "data")
+
+				const app = await _electron.launch({
+					executablePath,
+					env: {
+						...process.env,
+						TEMP_PROFILE: "true",
+						E2E_TEST: "true",
+						CLINE_ENVIRONMENT: "local",
+						CLINE_DIR: clineTestDir, // Isolate test data from user's ~/.cline
+						CLINE_DATA_DIR: clineDataDir, // Keep SDK/shared storage off the user's real Cline data dir
+						GRPC_RECORDER_FILE_NAME: E2ETestHelper.generateTestFileName(testInfo.title, testInfo.project.name),
+						// GRPC_RECORDER_ENABLED: "true",
+						// GRPC_RECORDER_TESTS_FILTERS_ENABLED: "true"
+						// IS_DEV: "true",
+						// DEV_WORKSPACE_FOLDER: E2ETestHelper.CODEBASE_ROOT_DIR,
+					},
+					recordVideo: {
+						dir: E2ETestHelper.getResultsDir(testInfo.title, "recordings"),
+					},
+					args: [
+						"--no-sandbox",
+						"--disable-updates",
+						"--disable-workspace-trust",
+						"--disable-extensions", // Run VS Code with all extensions disabled other than the one under test.
+						"--skip-welcome",
+						"--skip-release-notes",
+						`--user-data-dir=${userDataDir}`,
+						`--install-extension=${path.join(E2ETestHelper.CODEBASE_ROOT_DIR, "dist", "e2e.vsix")}`,
+						`--extensionDevelopmentPath=${E2ETestHelper.CODEBASE_ROOT_DIR}`,
+						workspacePath,
+					],
+				})
+				await E2ETestHelper.waitUntil(() => app.windows().length > 0)
+				return app
+			})
+		},
+	})
+	.extend<{ app: ElectronApplication; clineTestDir: string }>({
+		app: async ({ openVSCode, userDataDir, extensionsDir, workspaceType, workspaceDir, multiRootWorkspaceDir }, use) => {
+			const workspacePath = workspaceType === "single" ? workspaceDir : multiRootWorkspaceDir
+
+			const app = await openVSCode(workspacePath)
+
+			try {
+				await use(app)
+			} finally {
+				await E2ETestHelper.closeAppForTeardown(app)
+				// Cleanup in parallel after the app process has been asked to exit.
+				const cleanupTasks = [
+					E2ETestHelper.rmForRetries(userDataDir, { recursive: true }),
+					E2ETestHelper.rmForRetries(extensionsDir, { recursive: true }),
+				]
+
+				// Clean up the isolated Cline data directory
+				// Find all temp directories matching our pattern
+				const tmpDir = os.tmpdir()
+				try {
+					const entries = readdirSync(tmpDir)
+					for (const entry of entries) {
+						if (entry.startsWith("cline-e2e-")) {
+							cleanupTasks.push(E2ETestHelper.rmForRetries(path.join(tmpDir, entry), { recursive: true }))
+						}
+					}
+				} catch (error) {
+					// Ignore cleanup errors
+				}
+
+				await Promise.allSettled(cleanupTasks)
+			}
+		},
+		clineTestDir: async ({}, use) => {
+			// This will be set by the openVSCode fixture
+			await use("")
+		},
+	})
+	.extend<{ helper: E2ETestHelper }>({
+		helper: async ({}, use) => {
+			const helper = new E2ETestHelper()
+			await use(helper)
+		},
+	})
+	.extend({
+		page: async ({ app }, use) => {
+			const page = await app.firstWindow()
+			try {
+				await use(page)
+			} finally {
+				await E2ETestHelper.closePageForTeardown(page)
+			}
+		},
+	})
+	.extend<{ sidebar: Frame }>({
+		sidebar: async ({ page, helper, server }, use) => {
+			await E2ETestHelper.openClineSidebar(page)
+			const sidebar = await helper.getSidebar(page)
+			await use(sidebar)
+		},
+	})
+
+export const E2E_WORKSPACE_TYPES = [
+	{ title: "Single Root", workspaceType: "single" },
+	{ title: "Multi-Roots", workspaceType: "multi" },
+] as const
diff --git a/apps/vscode/src/test/extension.test.ts b/apps/vscode/src/test/extension.test.ts
new file mode 100644
index 0000000..16575a9
--- /dev/null
+++ b/apps/vscode/src/test/extension.test.ts
@@ -0,0 +1,91 @@
+import { after, describe, it } from "mocha"
+import { readFile } from "fs/promises"
+import path from "path"
+import "should"
+import * as vscode from "vscode"
+
+const packagePath = path.join(__dirname, "..", "..", "package.json")
+
+describe("Cline Extension", () => {
+	after(() => {
+		vscode.window.showInformationMessage("All tests done!")
+	})
+
+	it("should verify extension ID matches package.json", async () => {
+		const packageJSON = JSON.parse(await readFile(packagePath, "utf8"))
+		const id = packageJSON.publisher + "." + packageJSON.name
+		const clineExtensionApi = vscode.extensions.getExtension(id)
+
+		clineExtensionApi?.id.should.equal(id)
+	})
+
+	it("should successfully execute the plus button command", async () => {
+		await new Promise((resolve) => setTimeout(resolve, 400))
+		await vscode.commands.executeCommand("cline.plusButtonClicked")
+	})
+
+	// New test to verify xvfb and webview functionality
+	it("should create and display a webview panel", async () => {
+		// Create a webview panel
+		const panel = vscode.window.createWebviewPanel("testWebview", "CI/CD Test", vscode.ViewColumn.One, {
+			enableScripts: true,
+		})
+
+		// Set some HTML content
+		panel.webview.html = `
+			<!DOCTYPE html>
+			<html>
+				<head>
+					<meta charset="UTF-8">
+					<title>xvfb Test</title>
+				</head>
+				<body>
+					<div id="test">Testing xvfb display server</div>
+				</body>
+			</html>
+		`
+
+		// Verify panel exists
+		should.exist(panel)
+		panel.visible.should.be.true()
+
+		// Clean up
+		panel.dispose()
+	})
+
+	// Test webview message passing
+	it("should handle webview messages", async () => {
+		const panel = vscode.window.createWebviewPanel("testWebview", "Message Test", vscode.ViewColumn.One, {
+			enableScripts: true,
+		})
+
+		// Set up message handling
+		const messagePromise = new Promise<string>((resolve) => {
+			panel.webview.onDidReceiveMessage((message) => resolve(message.text), undefined)
+		})
+
+		// Add message sending script
+		panel.webview.html = `
+			<!DOCTYPE html>
+			<html>
+				<head>
+					<meta charset="UTF-8">
+					<title>Message Test</title>
+				</head>
+				<body>
+					<script>
+						const vscode = acquireVsCodeApi();
+						vscode.postMessage({ text: 'test-message' });
+					</script>
+				</body>
+			</html>
+		`
+
+		// Wait for message
+		const message = await messagePromise
+		message.should.equal("test-message")
+
+		// Clean up
+		panel.dispose()
+	})
+})
diff --git a/apps/vscode/src/test/fixtures/google-genai-mock.ts b/apps/vscode/src/test/fixtures/google-genai-mock.ts
new file mode 100644
index 0000000..f082ecb
--- /dev/null
+++ b/apps/vscode/src/test/fixtures/google-genai-mock.ts
@@ -0,0 +1,59 @@
+// Mock for the `@google/genai` module to avoid ESM-in-CommonJS compatibility
+// issues in the VS Code integration test build (the `out/` tree runs as
+// CommonJS). Loaded by test-setup.js, which intercepts `require("@google/genai")`.
+//
+// Previously colocated as apps/vscode/src/core/api/providers/gemini-mock.test.ts
+// alongside the legacy Gemini provider; kept as a standalone test fixture after
+// the legacy provider handlers were removed.
+
+export class GoogleGenAI {
+	constructor(_options: any) {
+		// Mock constructor
+	}
+
+	models = {
+		generateContentStream: async (_params: any) => {
+			// Mock implementation that returns an async iterator
+			return {
+				async *[Symbol.asyncIterator]() {
+					yield {
+						text: "Mock response",
+						candidates: [],
+						usageMetadata: {
+							promptTokenCount: 100,
+							candidatesTokenCount: 50,
+							thoughtsTokenCount: 0,
+							cachedContentTokenCount: 0,
+						},
+					}
+				},
+			}
+		},
+		countTokens: async (_params: any) => {
+			// Mock token counting
+			return {
+				totalTokens: 100,
+			}
+		},
+	}
+}
+
+// Export mock types
+export interface GenerateContentConfig {
+	httpOptions?: any
+	systemInstruction?: string
+	temperature?: number
+	thinkingConfig?: any
+}
+
+export interface GenerateContentResponseUsageMetadata {
+	promptTokenCount?: number
+	candidatesTokenCount?: number
+	thoughtsTokenCount?: number
+	cachedContentTokenCount?: number
+}
+
+export interface Part {
+	thought?: boolean
+	text?: string
+}
diff --git a/apps/vscode/src/test/grpc-handler.test.ts b/apps/vscode/src/test/grpc-handler.test.ts
new file mode 100644
index 0000000..a2fa07a
--- /dev/null
+++ b/apps/vscode/src/test/grpc-handler.test.ts
@@ -0,0 +1,91 @@
+import { expect } from "chai"
+import "should"
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import * as actualProtobusServices from "@generated/hosts/vscode/protobus-services"
+import * as sinon from "sinon"
+import { Controller } from "@/core/controller"
+import { GrpcRecorder } from "@/core/controller/grpc-recorder/grpc-recorder"
+import type { ExtensionMessage } from "@/shared/ExtensionMessage"
+import type { GrpcRequest } from "@/shared/WebviewMessage"
+
+// bun loads real ESM, so sinon cannot replace the `serviceHandlers` namespace
+// binding ("Cannot replace module namespace object's binding's value"). Route it
+// through a STABLE object reference installed via mock.module; the SUT reads
+// `serviceHandlers[serviceName]` at call time, so each test mutates the contents
+// of this same object (clearing then assigning) rather than swapping the binding.
+const currentServiceHandlers: Record<string, unknown> = {}
+mock.module("@generated/hosts/vscode/protobus-services", () => ({
+	...actualProtobusServices,
+	serviceHandlers: currentServiceHandlers,
+}))
+
+import { handleGrpcRequest } from "@/core/controller/grpc-handler"
+
+describe("GrpcHandler Recording Middleware", () => {
+	let recorderStub: sinon.SinonStubbedInstance<any>
+	let builderStub: any
+	let consoleWarnStub: sinon.SinonStub
+	let mockController: sinon.SinonStubbedInstance<Controller>
+	let mockPostMessage: sinon.SinonStub
+
+	beforeEach(() => {
+		recorderStub = {
+			recordRequest: sinon.stub(),
+			recordResponse: sinon.stub(),
+			recordError: sinon.stub(),
+			getSessionLog: sinon.stub(),
+		}
+
+		builderStub = {
+			enableIf: sinon.stub().returnsThis(),
+			withLogFileHandler: sinon.stub().returnsThis(),
+			build: sinon.stub().returns(recorderStub),
+		}
+
+		sinon.stub(GrpcRecorder, "builder").returns(builderStub)
+		consoleWarnStub = sinon.stub(console, "warn")
+		mockController = sinon.createStubInstance(Controller)
+		mockPostMessage = sinon.stub().resolves(true)
+
+		const mockServiceHandlers = {
+			TestService: {
+				testMethod: sinon.stub().resolves({ success: true }),
+				errorMethod: sinon.stub().rejects(new Error("Simulated failure")),
+			},
+		}
+
+		for (const key of Object.keys(currentServiceHandlers)) {
+			delete currentServiceHandlers[key]
+		}
+		Object.assign(currentServiceHandlers, mockServiceHandlers)
+	})
+
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	describe("Recording Middleware Integration", () => {
+		it("should record requests and responses for unary gRPC calls", async () => {
+			const grpcRequest: GrpcRequest = {
+				request_id: "the-request-id",
+				service: "TestService",
+				method: "testMethod",
+				message: { test: "request" },
+				is_streaming: false,
+			}
+
+			await handleGrpcRequest(mockController, mockPostMessage, grpcRequest)
+
+			expect(recorderStub.recordRequest.calledOnceWithExactly(grpcRequest)).to.be.true
+			expect(recorderStub.recordError.notCalled).to.be.true
+
+			expect(mockPostMessage.calledOnce).to.be.true
+			const sentMessage = mockPostMessage.getCall(0).args[0] as ExtensionMessage
+			expect(sentMessage.type).to.equal("grpc_response")
+			expect(sentMessage.grpc_response?.request_id).to.equal("the-request-id")
+			expect(sentMessage.grpc_response?.message).to.deep.equal({ success: true })
+
+			expect(recorderStub.recordResponse.calledOnceWithExactly("the-request-id", sentMessage.grpc_response)).to.be.true
+		})
+	})
+})
diff --git a/apps/vscode/src/test/hook-management-integration.test.ts b/apps/vscode/src/test/hook-management-integration.test.ts
new file mode 100644
index 0000000..8b7b746
--- /dev/null
+++ b/apps/vscode/src/test/hook-management-integration.test.ts
@@ -0,0 +1,424 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import * as sinon from "sinon"
+import { Controller } from "../core/controller"
+import { createHook } from "../core/controller/file/createHook"
+import { deleteHook } from "../core/controller/file/deleteHook"
+import { refreshHooks } from "../core/controller/file/refreshHooks"
+import { toggleHook } from "../core/controller/file/toggleHook"
+import { hookFileName } from "../core/hooks/__tests__/test-utils"
+import { HookDiscoveryCache } from "../core/hooks/HookDiscoveryCache"
+import { StateManager } from "../core/storage/StateManager"
+import { HostProvider } from "../hosts/host-provider"
+import { CreateHookRequest, DeleteHookRequest, ToggleHookRequest } from "../shared/proto/cline/file"
+
+/**
+ * Integration tests for hook management
+ * Tests the complete lifecycle: create -> enable -> disable -> delete
+ */
+describe("Hook Management Integration", () => {
+	const isWindows = process.platform === "win32"
+
+	let tempDir: string
+	let globalHooksDir: string
+	let workspaceHooksDir: string
+	let mockController: Controller
+	let stateManagerStub: sinon.SinonStub
+	let getWorkspacePathsStub: sinon.SinonStub
+
+	beforeEach(async () => {
+		// Reset the hook discovery cache before each test
+		HookDiscoveryCache.resetForTesting()
+
+		// Create temporary directories
+		tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "hook-integration-test-"))
+		globalHooksDir = path.join(tempDir, "global", "Documents", "Cline", "Hooks")
+		workspaceHooksDir = path.join(tempDir, "workspace", ".clinerules", "hooks")
+
+		await fs.mkdir(globalHooksDir, { recursive: true })
+		await fs.mkdir(workspaceHooksDir, { recursive: true })
+
+		// Mock Controller
+		mockController = {
+			context: {
+				globalStorageUri: { fsPath: path.join(tempDir, "global") },
+			},
+		} as any
+
+		// Mock StateManager to return test workspace
+		stateManagerStub = sinon.stub(StateManager, "get").returns({
+			getGlobalStateKey: (key: string) => {
+				if (key === "workspaceRoots") {
+					return [{ path: path.join(tempDir, "workspace") }]
+				}
+				return undefined
+			},
+		} as any)
+
+		// Mock HostProvider.workspace.getWorkspacePaths - need to stub the method directly
+		getWorkspacePathsStub = sinon.stub().resolves({
+			paths: [path.join(tempDir, "workspace")],
+		})
+		sinon.stub(HostProvider, "workspace").value({
+			getWorkspacePaths: getWorkspacePathsStub,
+		})
+	})
+
+	afterEach(async () => {
+		// Clean up temporary directory
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch (error) {
+			// Ignore cleanup errors
+		}
+
+		// Restore all stubs
+		sinon.restore()
+	})
+
+	describe("Complete Hook Lifecycle", () => {
+		it("should support full lifecycle: create -> verify disabled -> enable -> verify enabled -> delete -> verify gone", async () => {
+			const hookName = "TaskStart"
+
+			// Step 1: Verify hook doesn't exist initially
+			let hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks.should.have.length(0)
+
+			// Step 2: Create the hook
+			const createRequest = CreateHookRequest.create({
+				hookName,
+				isGlobal: true,
+			})
+			const createResponse = await createHook(mockController, createRequest, globalHooksDir)
+
+			// Step 3: Verify hook was created and is disabled (644 permissions)
+			createResponse.hooksToggles!.globalHooks.should.have.length(1)
+			createResponse.hooksToggles!.globalHooks[0].name.should.equal(hookName)
+			if (isWindows) {
+				createResponse.hooksToggles!.globalHooks[0].enabled.should.equal(true)
+			} else {
+				createResponse.hooksToggles!.globalHooks[0].enabled.should.equal(false)
+			}
+
+			const hookPath = path.join(globalHooksDir, hookFileName(hookName))
+			if (!isWindows) {
+				const createStats = await fs.stat(hookPath)
+				const createMode = createStats.mode & 0o777
+				createMode.should.equal(0o644)
+			}
+
+			// Step 4: Enable the hook
+			const enableRequest = ToggleHookRequest.create({
+				hookName,
+				isGlobal: true,
+				enabled: true,
+			})
+			const enableResponse = await toggleHook(mockController, enableRequest, globalHooksDir)
+
+			// Step 5: Verify hook is now enabled (executable)
+			enableResponse.hooksToggles!.globalHooks.should.have.length(1)
+			enableResponse.hooksToggles!.globalHooks[0].enabled.should.equal(true)
+
+			const enableStats = await fs.stat(hookPath)
+			const enableMode = enableStats.mode & 0o777
+			if (!isWindows) {
+				;(enableMode & 0o100).should.be.greaterThan(0)
+			}
+
+			// Step 6: Disable the hook
+			const disableRequest = ToggleHookRequest.create({
+				hookName,
+				isGlobal: true,
+				enabled: false,
+			})
+			const disableResponse = await toggleHook(mockController, disableRequest, globalHooksDir)
+
+			// Step 7: Verify hook is now disabled again
+			disableResponse.hooksToggles!.globalHooks.should.have.length(1)
+			if (isWindows) {
+				// On Windows, toggling is chmod-noop and enabled reflects file existence.
+				disableResponse.hooksToggles!.globalHooks[0].enabled.should.equal(true)
+			} else {
+				disableResponse.hooksToggles!.globalHooks[0].enabled.should.equal(false)
+
+				const disableStats = await fs.stat(hookPath)
+				const disableMode = disableStats.mode & 0o777
+				disableMode.should.equal(0o644)
+			}
+
+			// Step 8: Delete the hook
+			const deleteRequest = DeleteHookRequest.create({
+				hookName,
+				isGlobal: true,
+			})
+			const deleteResponse = await deleteHook(mockController, deleteRequest, globalHooksDir)
+
+			// Step 9: Verify hook is gone
+			deleteResponse.hooksToggles!.globalHooks.should.have.length(0)
+
+			const hookExists = await fs
+				.access(hookPath)
+				.then(() => true)
+				.catch(() => false)
+			hookExists.should.equal(false)
+
+			// Step 10: Final refresh to confirm clean state
+			hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks.should.have.length(0)
+		}, 10000)
+
+		it("should handle multiple global hooks with independent states", async () => {
+			// Create four global hooks
+			await createHook(
+				mockController,
+				CreateHookRequest.create({
+					hookName: "TaskStart",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			await createHook(
+				mockController,
+				CreateHookRequest.create({
+					hookName: "TaskResume",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			await createHook(
+				mockController,
+				CreateHookRequest.create({
+					hookName: "UserPromptSubmit",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			await createHook(
+				mockController,
+				CreateHookRequest.create({
+					hookName: "TaskComplete",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			// Verify all hooks are present and disabled
+			const hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks.should.have.length(4)
+			hooks.globalHooks.forEach((hook) => {
+				if (isWindows) {
+					hook.enabled.should.equal(true)
+				} else {
+					hook.enabled.should.equal(false)
+				}
+			})
+
+			// Enable two of them
+			await toggleHook(
+				mockController,
+				ToggleHookRequest.create({
+					hookName: "TaskStart",
+					isGlobal: true,
+					enabled: true,
+				}),
+				globalHooksDir,
+			)
+
+			await toggleHook(
+				mockController,
+				ToggleHookRequest.create({
+					hookName: "UserPromptSubmit",
+					isGlobal: true,
+					enabled: true,
+				}),
+				globalHooksDir,
+			)
+
+			// Verify states are independent
+			const hooksAfterToggle = await refreshHooks(mockController, undefined, globalHooksDir)
+			const taskStart = hooksAfterToggle.globalHooks.find((h) => h.name === "TaskStart")
+			const taskResume = hooksAfterToggle.globalHooks.find((h) => h.name === "TaskResume")
+			const userPrompt = hooksAfterToggle.globalHooks.find((h) => h.name === "UserPromptSubmit")
+			const taskComplete = hooksAfterToggle.globalHooks.find((h) => h.name === "TaskComplete")
+
+			if (isWindows) {
+				taskStart!.enabled.should.equal(true)
+				taskResume!.enabled.should.equal(true)
+				userPrompt!.enabled.should.equal(true)
+				taskComplete!.enabled.should.equal(true)
+			} else {
+				taskStart!.enabled.should.equal(true)
+				taskResume!.enabled.should.equal(false)
+				userPrompt!.enabled.should.equal(true)
+				taskComplete!.enabled.should.equal(false)
+			}
+
+			// Clean up - delete all hooks
+			await deleteHook(
+				mockController,
+				DeleteHookRequest.create({
+					hookName: "TaskStart",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			await deleteHook(
+				mockController,
+				DeleteHookRequest.create({
+					hookName: "TaskResume",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			await deleteHook(
+				mockController,
+				DeleteHookRequest.create({
+					hookName: "UserPromptSubmit",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			await deleteHook(
+				mockController,
+				DeleteHookRequest.create({
+					hookName: "TaskComplete",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			// Verify all are gone
+			const finalHooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			finalHooks.globalHooks.should.have.length(0)
+		}, 10000)
+
+		it("should maintain hook state consistency after rapid operations", async () => {
+			const hookName = "TaskCancel"
+
+			// Rapid sequence of operations
+			await createHook(
+				mockController,
+				CreateHookRequest.create({
+					hookName,
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			// Toggle multiple times
+			await toggleHook(
+				mockController,
+				ToggleHookRequest.create({
+					hookName,
+					isGlobal: true,
+					enabled: true,
+				}),
+				globalHooksDir,
+			)
+
+			await toggleHook(
+				mockController,
+				ToggleHookRequest.create({
+					hookName,
+					isGlobal: true,
+					enabled: false,
+				}),
+				globalHooksDir,
+			)
+
+			await toggleHook(
+				mockController,
+				ToggleHookRequest.create({
+					hookName,
+					isGlobal: true,
+					enabled: true,
+				}),
+				globalHooksDir,
+			)
+
+			// Verify final state
+			const hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks.should.have.length(1)
+			hooks.globalHooks[0].enabled.should.equal(true)
+
+			// Verify file permissions match
+			const hookPath = path.join(globalHooksDir, hookName)
+			if (!isWindows) {
+				const stats = await fs.stat(hookPath)
+				const mode = stats.mode & 0o777
+				;(mode & 0o100).should.be.greaterThan(0)
+			}
+		}, 10000)
+	})
+
+	describe("Cache Invalidation", () => {
+		it("should properly invalidate cache across all operations", async () => {
+			// Create a hook
+			await createHook(
+				mockController,
+				CreateHookRequest.create({
+					hookName: "TaskStart",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			// First refresh should find it
+			let hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks.should.have.length(1)
+
+			// Modify file permissions directly (simulating external change)
+			const hookPath = path.join(globalHooksDir, isWindows ? "TaskStart.ps1" : "TaskStart")
+			if (!isWindows) {
+				await fs.chmod(hookPath, 0o755)
+			}
+
+			// Second refresh should see the permission change
+			// (This tests that refreshHooks properly reads current state)
+			hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks[0].enabled.should.equal(true)
+
+			// Use toggle to change it back
+			await toggleHook(
+				mockController,
+				ToggleHookRequest.create({
+					hookName: "TaskStart",
+					isGlobal: true,
+					enabled: false,
+				}),
+				globalHooksDir,
+			)
+
+			// Third refresh should see the toggle
+			hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			if (isWindows) {
+				hooks.globalHooks[0].enabled.should.equal(true)
+			} else {
+				hooks.globalHooks[0].enabled.should.equal(false)
+			}
+
+			// Delete it
+			await deleteHook(
+				mockController,
+				DeleteHookRequest.create({
+					hookName: "TaskStart",
+					isGlobal: true,
+				}),
+				globalHooksDir,
+			)
+
+			// Final refresh should show it's gone
+			hooks = await refreshHooks(mockController, undefined, globalHooksDir)
+			hooks.globalHooks.should.have.length(0)
+		}, 10000)
+	})
+})
diff --git a/apps/vscode/src/test/hook-management.test.ts b/apps/vscode/src/test/hook-management.test.ts
new file mode 100644
index 0000000..ed8f074
--- /dev/null
+++ b/apps/vscode/src/test/hook-management.test.ts
@@ -0,0 +1,580 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import * as sinon from "sinon"
+import { Controller } from "../core/controller"
+import { createHook } from "../core/controller/file/createHook"
+import { deleteHook } from "../core/controller/file/deleteHook"
+import { refreshHooks } from "../core/controller/file/refreshHooks"
+import { toggleHook } from "../core/controller/file/toggleHook"
+import { hookFileName, withPlatform } from "../core/hooks/__tests__/test-utils"
+import { HookDiscoveryCache } from "../core/hooks/HookDiscoveryCache"
+import { StateManager } from "../core/storage/StateManager"
+import { HostProvider } from "../hosts/host-provider"
+import { CreateHookRequest, DeleteHookRequest, ToggleHookRequest } from "../shared/proto/cline/file"
+
+/**
+ * Unit tests for hook management operations
+ * Tests the create, delete, toggle, and refresh hook functionality
+ */
+describe("Hook Management", () => {
+	const isWindows = process.platform === "win32"
+	const hookTemplate = isWindows ? "Write-Output '{}'" : "#!/usr/bin/env node"
+
+	let tempDir: string
+	let globalHooksDir: string
+	let workspaceHooksDir: string
+	let mockController: Controller
+	let stateManagerStub: sinon.SinonStub
+	let getWorkspacePathsStub: sinon.SinonStub
+
+	beforeEach(async () => {
+		// Reset the hook discovery cache before each test
+		HookDiscoveryCache.resetForTesting()
+
+		// Create temporary directories
+		tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "hook-mgmt-test-"))
+		globalHooksDir = path.join(tempDir, "global", "Documents", "Cline", "Hooks")
+		workspaceHooksDir = path.join(tempDir, "workspace", ".clinerules", "hooks")
+
+		await fs.mkdir(globalHooksDir, { recursive: true })
+		await fs.mkdir(workspaceHooksDir, { recursive: true })
+
+		// Mock Controller
+		mockController = {
+			context: {
+				globalStorageUri: { fsPath: path.join(tempDir, "global") },
+			},
+		} as any
+
+		// Mock StateManager to return test workspace
+		stateManagerStub = sinon.stub(StateManager, "get").returns({
+			getGlobalStateKey: (key: string) => {
+				if (key === "workspaceRoots") {
+					return [{ path: path.join(tempDir, "workspace") }]
+				}
+				return undefined
+			},
+		} as any)
+
+		// Mock HostProvider.workspace.getWorkspacePaths - need to stub the method directly
+		getWorkspacePathsStub = sinon.stub().resolves({
+			paths: [path.join(tempDir, "workspace")],
+		})
+		sinon.stub(HostProvider, "workspace").value({
+			getWorkspacePaths: getWorkspacePathsStub,
+		})
+	})
+
+	afterEach(async () => {
+		// Clean up temporary directory
+		try {
+			await fs.rm(tempDir, { recursive: true, force: true })
+		} catch (error) {
+			// Ignore cleanup errors
+		}
+
+		// Restore all stubs
+		sinon.restore()
+	})
+
+	describe("createHook", () => {
+		it("should create hook with correct template content", async () => {
+			const request = CreateHookRequest.create({
+				hookName: "TaskStart",
+				isGlobal: true,
+			})
+
+			const response = await createHook(mockController, request, globalHooksDir)
+
+			// Verify file was created
+			const hookPath = path.join(globalHooksDir, hookFileName("TaskStart"))
+			const exists = await fs
+				.access(hookPath)
+				.then(() => true)
+				.catch(() => false)
+			exists.should.equal(true)
+
+			// Verify content contains expected template structure
+			const content = await fs.readFile(hookPath, "utf-8")
+			if (isWindows) {
+				content.should.containEql("PowerShell template for Windows hook execution")
+			} else {
+				content.should.containEql("#!/bin/bash")
+			}
+			content.should.containEql("TaskStart Hook")
+
+			// Verify response contains updated hooks state
+			response.should.have.property("hooksToggles")
+			response.hooksToggles!.globalHooks.should.have.length(1)
+			response.hooksToggles!.globalHooks[0].name.should.equal("TaskStart")
+		}, 5000)
+
+		it("should create hook with non-executable permissions (644)", async () => {
+			if (isWindows) {
+				return
+			}
+
+			const request = CreateHookRequest.create({
+				hookName: "TaskResume",
+				isGlobal: false,
+			})
+
+			await createHook(mockController, request)
+
+			const hookPath = path.join(workspaceHooksDir, hookFileName("TaskResume"))
+			const stats = await fs.stat(hookPath)
+
+			// Check permissions - should be 0o644 (non-executable)
+			const mode = stats.mode & 0o777
+			mode.should.equal(0o644)
+		}, 5000)
+
+		it("should throw error for invalid hook types", async () => {
+			const request = CreateHookRequest.create({
+				hookName: "InvalidHookType",
+				isGlobal: true,
+			})
+
+			try {
+				await createHook(mockController, request, globalHooksDir)
+				throw new Error("Should have thrown an error")
+			} catch (error: any) {
+				error.message.should.containEql("Invalid hook type")
+			}
+		}, 5000)
+
+		it("should throw error if hook already exists", async () => {
+			// Create hook first time
+			const request = CreateHookRequest.create({
+				hookName: "UserPromptSubmit",
+				isGlobal: true,
+			})
+
+			await createHook(mockController, request, globalHooksDir)
+
+			// Try to create again
+			try {
+				await createHook(mockController, request, globalHooksDir)
+				throw new Error("Should have thrown an error")
+			} catch (error: any) {
+				error.message.should.containEql("already exists")
+			}
+		}, 5000)
+
+		it("should create parent directories if they don't exist", async () => {
+			// Remove the hooks directory
+			await fs.rm(globalHooksDir, { recursive: true, force: true })
+
+			const request = CreateHookRequest.create({
+				hookName: "TaskComplete",
+				isGlobal: true,
+			})
+
+			await createHook(mockController, request, globalHooksDir)
+
+			// Verify directory was created
+			const dirExists = await fs
+				.access(globalHooksDir)
+				.then(() => true)
+				.catch(() => false)
+			dirExists.should.equal(true)
+
+			// Verify hook was created
+			const hookPath = path.join(globalHooksDir, hookFileName("TaskComplete"))
+			const fileExists = await fs
+				.access(hookPath)
+				.then(() => true)
+				.catch(() => false)
+			fileExists.should.equal(true)
+		}, 5000)
+
+		it("should create workspace hook when isGlobal is false", async () => {
+			const request = CreateHookRequest.create({
+				hookName: "TaskCancel",
+				isGlobal: false,
+			})
+
+			await createHook(mockController, request)
+
+			const hookPath = path.join(workspaceHooksDir, hookFileName("TaskCancel"))
+			const exists = await fs
+				.access(hookPath)
+				.then(() => true)
+				.catch(() => false)
+			exists.should.equal(true)
+		}, 5000)
+
+		it("should create Notification hook with valid template", async () => {
+			const request = CreateHookRequest.create({
+				hookName: "Notification",
+				isGlobal: true,
+			})
+
+			const response = await createHook(mockController, request, globalHooksDir)
+			const hookPath = path.join(globalHooksDir, hookFileName("Notification"))
+			const content = await fs.readFile(hookPath, "utf-8")
+
+			content.should.containEql("Notification Hook")
+			response.hooksToggles!.globalHooks.some((h) => h.name === "Notification").should.equal(true)
+		}, 5000)
+	})
+
+	describe("deleteHook", () => {
+		it("should delete existing hook file", async () => {
+			// Create a hook first
+			const hookPath = path.join(globalHooksDir, hookFileName("TaskStart"))
+			await fs.writeFile(hookPath, "#!/usr/bin/env node\nconsole.log('test')", { mode: 0o755 })
+
+			const request = DeleteHookRequest.create({
+				hookName: "TaskStart",
+				isGlobal: true,
+			})
+
+			const response = await deleteHook(mockController, request, globalHooksDir)
+
+			// Verify file was deleted
+			const exists = await fs
+				.access(hookPath)
+				.then(() => true)
+				.catch(() => false)
+			exists.should.equal(false)
+
+			// Verify response contains updated hooks state
+			response.should.have.property("hooksToggles")
+			response.hooksToggles!.globalHooks.should.have.length(0)
+		}, 5000)
+
+		it("should throw error if hook doesn't exist", async () => {
+			const request = DeleteHookRequest.create({
+				hookName: "NonExistentHook",
+				isGlobal: true,
+			})
+
+			try {
+				await deleteHook(mockController, request, globalHooksDir)
+				throw new Error("Should have thrown an error")
+			} catch (error: any) {
+				error.message.should.containEql("does not exist")
+			}
+		}, 5000)
+
+		it("should delete workspace hook when isGlobal is false", async () => {
+			// Create a workspace hook first
+			const hookPath = path.join(workspaceHooksDir, hookFileName("TaskResume"))
+			await fs.writeFile(hookPath, "#!/usr/bin/env node\nconsole.log('test')", { mode: 0o755 })
+
+			const request = DeleteHookRequest.create({
+				hookName: "TaskResume",
+				isGlobal: false,
+			})
+
+			await deleteHook(mockController, request)
+
+			const exists = await fs
+				.access(hookPath)
+				.then(() => true)
+				.catch(() => false)
+			exists.should.equal(false)
+		}, 5000)
+	})
+
+	describe("toggleHook", () => {
+		it("should make hook executable (chmod +x)", async () => {
+			if (isWindows) {
+				return
+			}
+
+			// Create a non-executable hook
+			const hookPath = path.join(globalHooksDir, "TaskStart")
+			await fs.writeFile(hookPath, "#!/usr/bin/env node\nconsole.log('test')", { mode: 0o644 })
+
+			const request = ToggleHookRequest.create({
+				hookName: "TaskStart",
+				isGlobal: true,
+				enabled: true,
+			})
+
+			await toggleHook(mockController, request, globalHooksDir)
+
+			// Verify file is now executable
+			const stats = await fs.stat(hookPath)
+			const mode = stats.mode & 0o777
+			// Should have at least user execute permission
+			;(mode & 0o100).should.be.greaterThan(0)
+		}, 5000)
+
+		it("should make hook non-executable (chmod -x)", async () => {
+			if (isWindows) {
+				return
+			}
+
+			// Create an executable hook
+			const hookPath = path.join(globalHooksDir, "TaskResume")
+			await fs.writeFile(hookPath, "#!/usr/bin/env node\nconsole.log('test')", { mode: 0o755 })
+
+			const request = ToggleHookRequest.create({
+				hookName: "TaskResume",
+				isGlobal: true,
+				enabled: false,
+			})
+
+			await toggleHook(mockController, request, globalHooksDir)
+
+			// Verify file is now non-executable
+			const stats = await fs.stat(hookPath)
+			const mode = stats.mode & 0o777
+			mode.should.equal(0o644)
+		}, 5000)
+
+		it("should work for workspace hooks", async () => {
+			if (isWindows) {
+				return
+			}
+
+			// Create a workspace hook
+			const hookPath = path.join(workspaceHooksDir, "UserPromptSubmit")
+			await fs.writeFile(hookPath, "#!/usr/bin/env node\nconsole.log('test')", { mode: 0o644 })
+
+			const request = ToggleHookRequest.create({
+				hookName: "UserPromptSubmit",
+				isGlobal: false,
+				enabled: true,
+			})
+
+			await toggleHook(mockController, request)
+
+			const stats = await fs.stat(hookPath)
+			const mode = stats.mode & 0o777
+			;(mode & 0o100).should.be.greaterThan(0)
+		}, 5000)
+
+		it("should return updated hooks state", async () => {
+			const hookPath = path.join(globalHooksDir, hookFileName("TaskComplete"))
+			await fs.writeFile(hookPath, "#!/usr/bin/env node\nconsole.log('test')", { mode: 0o644 })
+
+			const request = ToggleHookRequest.create({
+				hookName: "TaskComplete",
+				isGlobal: true,
+				enabled: true,
+			})
+
+			const response = await toggleHook(mockController, request, globalHooksDir)
+
+			response.should.have.property("hooksToggles")
+			response.hooksToggles!.globalHooks.should.have.length(1)
+			response.hooksToggles!.globalHooks[0].enabled.should.equal(true)
+		}, 5000)
+	})
+
+	describe("refreshHooks", () => {
+		it("should discover hooks in global directory", async () => {
+			// Create some hooks
+			if (isWindows) {
+				await fs.writeFile(path.join(globalHooksDir, "TaskStart.ps1"), "Write-Output '{}'", { mode: 0o644 })
+				await fs.writeFile(path.join(globalHooksDir, "TaskResume.ps1"), "Write-Output '{}'", { mode: 0o644 })
+			} else {
+				await fs.writeFile(path.join(globalHooksDir, "TaskStart"), "#!/usr/bin/env node", { mode: 0o755 })
+				await fs.writeFile(path.join(globalHooksDir, "TaskResume"), "#!/usr/bin/env node", { mode: 0o644 })
+			}
+
+			const result = await refreshHooks(mockController, undefined, globalHooksDir)
+
+			result.globalHooks.should.have.length(2)
+			result.globalHooks[0].name.should.equal("TaskStart")
+			result.globalHooks[0].enabled.should.equal(true)
+			result.globalHooks[1].name.should.equal("TaskResume")
+			if (isWindows) {
+				result.globalHooks[1].enabled.should.equal(true)
+			} else {
+				result.globalHooks[1].enabled.should.equal(false)
+			}
+		}, 5000)
+
+		it("should discover hooks in workspace directories", async () => {
+			await fs.writeFile(path.join(workspaceHooksDir, hookFileName("UserPromptSubmit")), hookTemplate, {
+				mode: 0o755,
+			})
+
+			const result = await refreshHooks(mockController, undefined)
+
+			result.workspaceHooks.should.have.length(1)
+			result.workspaceHooks[0].hooks.should.have.length(1)
+			result.workspaceHooks[0].hooks[0].name.should.equal("UserPromptSubmit")
+			result.workspaceHooks[0].hooks[0].enabled.should.equal(true)
+		}, 5000)
+
+		it("should correctly identify executable vs non-executable hooks", async () => {
+			if (isWindows) {
+				return
+			}
+
+			await fs.writeFile(path.join(globalHooksDir, "TaskStart"), "#!/usr/bin/env node", { mode: 0o755 })
+			await fs.writeFile(path.join(globalHooksDir, "TaskCancel"), "#!/usr/bin/env node", { mode: 0o644 })
+
+			const result = await refreshHooks(mockController, undefined, globalHooksDir)
+
+			const taskStart = result.globalHooks.find((h) => h.name === "TaskStart")
+			const taskCancel = result.globalHooks.find((h) => h.name === "TaskCancel")
+
+			taskStart!.enabled.should.equal(true)
+			taskCancel!.enabled.should.equal(false)
+		}, 5000)
+
+		it("should return empty list when no hooks exist", async () => {
+			const result = await refreshHooks(mockController, undefined, globalHooksDir)
+
+			result.globalHooks.should.have.length(0)
+			// Workspace should still appear even with no hooks
+			result.workspaceHooks.should.have.length(1)
+			result.workspaceHooks[0].hooks.should.have.length(0)
+		}, 5000)
+
+		it("should include absolute paths in hook info", async () => {
+			if (isWindows) {
+				await fs.writeFile(path.join(globalHooksDir, "TaskComplete.ps1"), "Write-Output '{}'", { mode: 0o644 })
+			} else {
+				await fs.writeFile(path.join(globalHooksDir, "TaskComplete"), "#!/usr/bin/env node", { mode: 0o755 })
+			}
+
+			const result = await refreshHooks(mockController, undefined, globalHooksDir)
+
+			result.globalHooks[0].absolutePath.should.equal(path.join(globalHooksDir, hookFileName("TaskComplete")))
+		}, 5000)
+
+		it("should set isWindows flag correctly", async () => {
+			const result = await refreshHooks(mockController, undefined)
+
+			result.isWindows.should.equal(isWindows)
+		}, 5000)
+
+		it("should resolve .ps1-only hooks on Windows (extensionless is unsupported)", async () => {
+			await withPlatform("win32", async () => {
+				await fs.writeFile(path.join(globalHooksDir, "TaskStart.ps1"), "Write-Output '{}'", { mode: 0o644 })
+
+				const result = await refreshHooks(mockController, undefined, globalHooksDir)
+				const taskStart = result.globalHooks.find((h) => h.name === "TaskStart")
+				should.exist(taskStart)
+				taskStart!.absolutePath.should.equal(path.join(globalHooksDir, "TaskStart.ps1"))
+				taskStart!.enabled.should.equal(true)
+			})
+		}, 5000)
+
+		it("should ignore extensionless hook on Windows and use .ps1 only", async () => {
+			await withPlatform("win32", async () => {
+				await fs.writeFile(path.join(globalHooksDir, "TaskResume"), "Write-Output '{}'", { mode: 0o644 })
+				await fs.writeFile(path.join(globalHooksDir, "TaskResume.ps1"), "Write-Output '{}'", { mode: 0o644 })
+
+				const result = await refreshHooks(mockController, undefined, globalHooksDir)
+				const taskResume = result.globalHooks.find((h) => h.name === "TaskResume")
+				should.exist(taskResume)
+				taskResume!.absolutePath.should.equal(path.join(globalHooksDir, "TaskResume.ps1"))
+			})
+		}, 5000)
+	})
+
+	describe("Edge Cases", () => {
+		it("should handle missing .clinerules directory gracefully", async () => {
+			// Remove workspace hooks directory
+			await fs.rm(path.dirname(workspaceHooksDir), { recursive: true, force: true })
+
+			const result = await refreshHooks(mockController, undefined)
+
+			// Should not throw, just return empty workspace hooks
+			result.workspaceHooks.should.have.length(1)
+			result.workspaceHooks[0].hooks.should.have.length(0)
+		}, 5000)
+
+		it("should handle permission errors gracefully", async () => {
+			if (isWindows) {
+				return
+			}
+
+			// Create a hook
+			const hookPath = path.join(globalHooksDir, "TaskStart")
+			await fs.writeFile(hookPath, "#!/usr/bin/env node", { mode: 0o644 })
+
+			// Make the hooks directory read-only on unix systems
+			if (process.platform !== "win32") {
+				await fs.chmod(globalHooksDir, 0o444)
+			}
+
+			const request = DeleteHookRequest.create({
+				hookName: "TaskStart",
+				isGlobal: true,
+			})
+
+			try {
+				await deleteHook(mockController, request, globalHooksDir)
+				// Should throw an error
+			} catch (error) {
+				// Expected - permission denied
+			} finally {
+				// Restore permissions for cleanup
+				await fs.chmod(globalHooksDir, 0o755)
+			}
+		}, 5000)
+
+		it("should invalidate cache after hook operations", async () => {
+			// Create a hook
+			const createRequest = CreateHookRequest.create({
+				hookName: "TaskStart",
+				isGlobal: true,
+			})
+			await createHook(mockController, createRequest, globalHooksDir)
+
+			// Refresh should see the new hook
+			let result = await refreshHooks(mockController, undefined, globalHooksDir)
+			result.globalHooks.should.have.length(1)
+
+			// Delete the hook
+			const deleteRequest = DeleteHookRequest.create({
+				hookName: "TaskStart",
+				isGlobal: true,
+			})
+			await deleteHook(mockController, deleteRequest, globalHooksDir)
+
+			// Refresh should no longer see the hook
+			result = await refreshHooks(mockController, undefined, globalHooksDir)
+			result.globalHooks.should.have.length(0)
+		}, 5000)
+
+		it("should toggle and delete .ps1-only hooks on Windows", async () => {
+			await withPlatform("win32", async () => {
+				const ps1Path = path.join(globalHooksDir, "TaskCancel.ps1")
+				await fs.writeFile(ps1Path, "Write-Output '{}'", { mode: 0o644 })
+
+				const toggleResponse = await toggleHook(
+					mockController,
+					ToggleHookRequest.create({
+						hookName: "TaskCancel",
+						isGlobal: true,
+						enabled: true,
+					}),
+					globalHooksDir,
+				)
+
+				const toggled = toggleResponse.hooksToggles!.globalHooks.find((h) => h.name === "TaskCancel")
+				should.exist(toggled)
+				toggled!.absolutePath.should.equal(ps1Path)
+
+				await deleteHook(
+					mockController,
+					DeleteHookRequest.create({
+						hookName: "TaskCancel",
+						isGlobal: true,
+					}),
+					globalHooksDir,
+				)
+
+				const exists = await fs
+					.access(ps1Path)
+					.then(() => true)
+					.catch(() => false)
+				exists.should.equal(false)
+			})
+		}, 5000)
+	})
+})
diff --git a/apps/vscode/src/test/host-provider-test-utils.ts b/apps/vscode/src/test/host-provider-test-utils.ts
new file mode 100644
index 0000000..fa6e4ad
--- /dev/null
+++ b/apps/vscode/src/test/host-provider-test-utils.ts
@@ -0,0 +1,43 @@
+import {
+	CommentReviewControllerCreator,
+	DiffViewProviderCreator,
+	HostProvider,
+	TerminalManagerCreator,
+	WebviewProviderCreator,
+} from "@/hosts/host-provider"
+import { HostBridgeClientProvider } from "@/hosts/host-provider-types"
+import { vscodeHostBridgeClient } from "@/hosts/vscode/hostbridge/client/host-grpc-client"
+import { ITerminalManager } from "@/integrations/terminal/types"
+
+/**
+ * Initializes the HostProvider with test defaults.
+ * This is a common setup used across multiple test files.
+ *
+ * @param options Optional overrides for the default test configuration
+ */
+export function setVscodeHostProviderMock(options?: {
+	webviewProviderCreator?: WebviewProviderCreator
+	diffViewProviderCreator?: DiffViewProviderCreator
+	commentReviewControllerCreator?: CommentReviewControllerCreator
+	terminalManagerCreator?: TerminalManagerCreator
+	hostBridgeClient?: HostBridgeClientProvider
+	logToChannel?: (message: string) => void
+	getCallbackUri?: (path: string) => Promise<string>
+	getBinaryLocation?: (name: string) => Promise<string>
+	extensionFsPath?: string
+	globalStorageFsPath?: string
+}) {
+	HostProvider.reset()
+	HostProvider.initialize(
+		options?.webviewProviderCreator ?? ((() => {}) as WebviewProviderCreator),
+		options?.diffViewProviderCreator ?? ((() => {}) as DiffViewProviderCreator),
+		options?.commentReviewControllerCreator ?? ((() => {}) as CommentReviewControllerCreator),
+		options?.terminalManagerCreator ?? ((() => ({}) as ITerminalManager) as TerminalManagerCreator),
+		options?.hostBridgeClient ?? vscodeHostBridgeClient,
+		options?.logToChannel ?? ((_: string) => {}),
+		options?.getCallbackUri ?? (async (path: string) => `http://example.com:1234${path}`),
+		options?.getBinaryLocation ?? (async (n: string) => `/mock/path/to/binary/${n}`),
+		options?.extensionFsPath ?? "/mock/path/to/extension",
+		options?.globalStorageFsPath ?? "/mock/path/to/globalstorage",
+	)
+}
diff --git a/apps/vscode/src/test/powershell-resolver.test.ts b/apps/vscode/src/test/powershell-resolver.test.ts
new file mode 100644
index 0000000..bf5596b
--- /dev/null
+++ b/apps/vscode/src/test/powershell-resolver.test.ts
@@ -0,0 +1,134 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import "should"
+import {
+	getFallbackWindowsPowerShellPath,
+	getWindowsPowerShellCandidates,
+	probeWindowsExecutable,
+	resetPowerShellResolverCacheForTesting,
+	resolveWindowsPowerShellExecutable,
+	setPowerShellProbeForTesting,
+} from "../utils/powershell"
+import { WINDOWS_POWERSHELL_LEGACY_PATH } from "../utils/shell"
+
+describe("PowerShell resolver", () => {
+	let originalProgramFiles: string | undefined
+	let originalProgramW6432: string | undefined
+
+	beforeEach(() => {
+		originalProgramFiles = process.env.ProgramFiles
+		originalProgramW6432 = process.env.ProgramW6432
+		setPowerShellProbeForTesting(null)
+		resetPowerShellResolverCacheForTesting()
+	})
+
+	afterEach(() => {
+		setPowerShellProbeForTesting(null)
+		resetPowerShellResolverCacheForTesting()
+		process.env.ProgramFiles = originalProgramFiles
+		process.env.ProgramW6432 = originalProgramW6432
+	})
+
+	it("prefers absolute pwsh candidate when available", async () => {
+		process.env.ProgramFiles = "C:\\Program Files"
+		process.env.ProgramW6432 = ""
+
+		const preferredCandidate = getWindowsPowerShellCandidates()[0]
+		let probeCalls = 0
+		setPowerShellProbeForTesting(async (candidate) => {
+			probeCalls += 1
+			return candidate === preferredCandidate
+		})
+
+		const resolved = await resolveWindowsPowerShellExecutable()
+		resolved.should.equal(preferredCandidate)
+		probeCalls.should.equal(1)
+	})
+
+	it("orders candidates with absolute paths first and command names last, without duplicates", () => {
+		process.env.ProgramFiles = "C:\\Program Files"
+		delete process.env.ProgramW6432
+		const candidates = getWindowsPowerShellCandidates()
+		const uniqueCount = new Set(candidates).size
+
+		candidates.length.should.equal(uniqueCount)
+		candidates[0].should.equal("C:\\Program Files\\PowerShell\\7\\pwsh.exe")
+		candidates.should.containEql(WINDOWS_POWERSHELL_LEGACY_PATH)
+		candidates.indexOf(WINDOWS_POWERSHELL_LEGACY_PATH).should.be.lessThan(candidates.indexOf("pwsh.exe"))
+		candidates.slice(-2).should.deepEqual(["powershell.exe", "powershell"])
+	})
+
+	it("falls back to legacy Windows PowerShell path when no candidates resolve", async () => {
+		setPowerShellProbeForTesting(async () => false)
+
+		const resolved = await resolveWindowsPowerShellExecutable()
+		resolved.should.equal(getFallbackWindowsPowerShellPath())
+		resolved.should.equal(WINDOWS_POWERSHELL_LEGACY_PATH)
+	})
+
+	it("caches resolved executable and probes only once", async () => {
+		process.env.ProgramFiles = "C:\\Program Files"
+		process.env.ProgramW6432 = ""
+
+		const preferredCandidate = getWindowsPowerShellCandidates()[0]
+		let probeCalls = 0
+		setPowerShellProbeForTesting(async () => {
+			probeCalls += 1
+			return true
+		})
+
+		const first = await resolveWindowsPowerShellExecutable()
+		const second = await resolveWindowsPowerShellExecutable()
+
+		first.should.equal(preferredCandidate)
+		second.should.equal(preferredCandidate)
+		probeCalls.should.equal(1)
+	})
+
+	it("shares a single probe across concurrent callers", async () => {
+		process.env.ProgramFiles = "C:\\Program Files"
+		process.env.ProgramW6432 = ""
+
+		const preferredCandidate = getWindowsPowerShellCandidates()[0]
+		let probeCalls = 0
+		setPowerShellProbeForTesting(async () => {
+			probeCalls += 1
+			await new Promise((resolve) => setTimeout(resolve, 20))
+			return true
+		})
+
+		const [a, b, c] = await Promise.all([
+			resolveWindowsPowerShellExecutable(),
+			resolveWindowsPowerShellExecutable(),
+			resolveWindowsPowerShellExecutable(),
+		])
+
+		a.should.equal(preferredCandidate)
+		b.should.equal(preferredCandidate)
+		c.should.equal(preferredCandidate)
+		probeCalls.should.equal(1)
+	})
+
+	it("times out probing hung candidates", async () => {
+		const available = await probeWindowsExecutable("pwsh.exe", 10)
+		available.should.equal(false)
+	})
+
+	it("cache reset re-runs probing", async () => {
+		let probeCalls = 0
+		setPowerShellProbeForTesting(async () => {
+			probeCalls += 1
+			return true
+		})
+
+		await resolveWindowsPowerShellExecutable()
+		probeCalls.should.equal(1)
+
+		resetPowerShellResolverCacheForTesting()
+		setPowerShellProbeForTesting(async () => {
+			probeCalls += 1
+			return true
+		})
+		await resolveWindowsPowerShellExecutable()
+		probeCalls.should.equal(2)
+	})
+})
diff --git a/apps/vscode/src/test/scenarios/nebius-models.ts b/apps/vscode/src/test/scenarios/nebius-models.ts
new file mode 100644
index 0000000..cb08bea
--- /dev/null
+++ b/apps/vscode/src/test/scenarios/nebius-models.ts
@@ -0,0 +1,11 @@
+// GitHub PR - 5729
+
+import { expect } from "@playwright/test"
+import { e2e } from "../e2e/utils/helpers"
+
+e2e("Scenario - PR 5729 - Nebius models", async ({ helper, sidebar }) => {
+	// This scenario test is a placeholder to satisfy the CI requirement.
+	// It verifies that the application loads correctly after the configuration change.
+	await helper.signin(sidebar)
+	await expect(sidebar.getByTestId("chat-input")).toBeVisible()
+})
diff --git a/apps/vscode/src/test/services/ClineAccountService.test.ts b/apps/vscode/src/test/services/ClineAccountService.test.ts
new file mode 100644
index 0000000..3f52ff9
--- /dev/null
+++ b/apps/vscode/src/test/services/ClineAccountService.test.ts
@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import * as assert from "assert"
+import sinon from "sinon"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { AuthService } from "@/services/auth/AuthService"
+
+describe("ClineAccountService.fetchUserRemoteConfig", () => {
+	let service: ClineAccountService
+	let sandbox: sinon.SinonSandbox
+	let authStub: { getAuthToken: sinon.SinonStub }
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		authStub = { getAuthToken: sandbox.stub().resolves("token") }
+		sandbox.stub(AuthService, "getInstance").returns(authStub as unknown as AuthService)
+		service = new ClineAccountService()
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it("returns discovery response on a successful authenticated request", async () => {
+		const mockResponse = {
+			organizationId: "org-123",
+			value: '{"version":"v1"}',
+			organizations: [
+				{ organizationId: "org-123", name: "Test Org" },
+				{ organizationId: "org-456", name: "Another Org" },
+			],
+		}
+		sandbox.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest").resolves(mockResponse)
+
+		const result = await service.fetchUserRemoteConfig()
+
+		assert.ok(result !== undefined, "result should not be undefined")
+		assert.strictEqual(result?.organizationId, "org-123")
+		assert.strictEqual(result?.organizations?.length, 2)
+		assert.strictEqual(result?.organizations?.[0].name, "Test Org")
+	})
+
+	it("re-throws when the request throws a network error", async () => {
+		sandbox
+			.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest")
+			.rejects(new Error("Network error"))
+
+		await assert.rejects(() => service.fetchUserRemoteConfig(), { message: "Network error" })
+	})
+
+	it("returns undefined when there is no auth token", async () => {
+		authStub.getAuthToken.resolves(null)
+
+		const result = await service.fetchUserRemoteConfig()
+
+		assert.strictEqual(result, undefined)
+	})
+
+	it("returns undefined when backend returns data: null (no org has remote config)", async () => {
+		// When allowNullData is true and backend returns { success: true, data: null },
+		// authenticatedRequest returns null. fetchUserRemoteConfig should coalesce to undefined.
+		sandbox.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest").resolves(null)
+
+		const result = await service.fetchUserRemoteConfig()
+
+		assert.strictEqual(result, undefined)
+	})
+
+	it("returns response when backend selects fallback org", async () => {
+		const mockResponse = {
+			organizationId: "org-fallback",
+			value: '{"version":"v1"}',
+			organizations: [{ organizationId: "org-fallback", name: "Fallback Org" }],
+		}
+		sandbox.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest").resolves(mockResponse)
+
+		const result = await service.fetchUserRemoteConfig()
+
+		assert.ok(result !== undefined)
+		assert.strictEqual(result?.organizationId, "org-fallback")
+		assert.strictEqual(result?.organizations?.length, 1)
+	})
+})
+
+describe("ClineAccountService.fetchFeaturebaseToken", () => {
+	let service: ClineAccountService
+	let sandbox: sinon.SinonSandbox
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		sandbox.stub(AuthService, "getInstance").returns({} as AuthService)
+		service = new ClineAccountService()
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it("returns featurebaseJwt on a successful authenticated request", async () => {
+		sandbox
+			.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest")
+			.resolves({ featurebaseJwt: "test-jwt-token-123" })
+
+		const result = await service.fetchFeaturebaseToken()
+
+		assert.ok(result !== undefined, "result should not be undefined")
+		assert.strictEqual(result?.featurebaseJwt, "test-jwt-token-123")
+	})
+
+	it("returns undefined when the request throws a network error", async () => {
+		sandbox
+			.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest")
+			.rejects(new Error("Network error"))
+
+		const result = await service.fetchFeaturebaseToken()
+
+		assert.strictEqual(result, undefined)
+	})
+
+	it("returns undefined when the request throws due to missing auth token", async () => {
+		sandbox
+			.stub(service as unknown as { authenticatedRequest: () => unknown }, "authenticatedRequest")
+			.rejects(new Error("No Cline account auth token found"))
+
+		const result = await service.fetchFeaturebaseToken()
+
+		assert.strictEqual(result, undefined)
+	})
+})
diff --git a/apps/vscode/src/test/services/auth-callback-url.test.ts b/apps/vscode/src/test/services/auth-callback-url.test.ts
new file mode 100644
index 0000000..eb1bf7d
--- /dev/null
+++ b/apps/vscode/src/test/services/auth-callback-url.test.ts
@@ -0,0 +1,89 @@
+import { afterEach, describe, it } from "bun:test"
+import "should"
+import { AuthHandler } from "@/hosts/external/AuthHandler"
+
+/**
+ * Regression tests for OAuth callback URL generation.
+ *
+ * These tests verify that:
+ * 1. getCallbackUrl accepts a path parameter and includes it in the returned URL
+ * 2. VS Code Web callback URLs do NOT use 127.0.0.1 (loopback) — they must use
+ *    vscode.env.asExternalUri so that browser-hosted remote setups (Codespaces, code serve-web)
+ *    get a web-reachable callback URL instead of a loopback address.
+ *
+ * The VS Code extension's getCallbackUrl is gated on UIKind.Web:
+ * - Desktop: returns vscode://extension-id/path directly (no asExternalUri)
+ * - Web: returns asExternalUri(vscode://extension-id/path) → HTTPS web-reachable URL
+ */
+describe("Auth Callback URL", () => {
+	describe("AuthHandler.getCallbackUrl (standalone/CLI)", () => {
+		let authHandler: AuthHandler
+
+		afterEach(() => {
+			authHandler?.stop()
+			// Reset singleton for test isolation
+			;(AuthHandler as any).instance = null
+		})
+
+		it("should include the path in the callback URL", async () => {
+			authHandler = AuthHandler.getInstance()
+			authHandler.setEnabled(true)
+
+			const url = await authHandler.getCallbackUrl("/auth")
+			url.should.containEql("/auth")
+			url.should.startWith("http://127.0.0.1:")
+		})
+
+		it("should include complex paths in the callback URL", async () => {
+			authHandler = AuthHandler.getInstance()
+			authHandler.setEnabled(true)
+
+			const url = await authHandler.getCallbackUrl("/mcp-auth/callback/abc123")
+			url.should.containEql("/mcp-auth/callback/abc123")
+			url.should.startWith("http://127.0.0.1:")
+		})
+
+		it("should work with empty path for backwards compatibility", async () => {
+			authHandler = AuthHandler.getInstance()
+			authHandler.setEnabled(true)
+
+			const url = await authHandler.getCallbackUrl()
+			url.should.startWith("http://127.0.0.1:")
+			url.should.match(/^http:\/\/127\.0\.0\.1:\d+$/)
+		})
+	})
+
+	describe("callback URL encoding", () => {
+		it("should preserve callback_url with query params when URL-encoded via searchParams", () => {
+			// Simulates a VS Code Web callback URL that contains its own query params
+			// (e.g. from vscode.env.asExternalUri adding tokens).
+			// If callers string-interpolate instead of using searchParams.set(),
+			// everything after the first & gets parsed as a top-level param and
+			// callback_url is truncated.
+			const webCallback = "https://codespace-abc.github.dev/callback?tkn=secret123&extra=val"
+
+			const authUrl = new URL("https://openrouter.ai/auth")
+			authUrl.searchParams.set("callback_url", webCallback)
+
+			// The callback_url value must round-trip intact
+			const parsed = new URL(authUrl.toString())
+			parsed.searchParams.get("callback_url")!.should.equal(webCallback)
+
+			// The raw URL must NOT contain an unencoded & from the callback
+			const raw = authUrl.toString()
+			raw.should.not.containEql("&extra=")
+			raw.should.not.containEql("&tkn=")
+			raw.should.containEql(encodeURIComponent("&extra=val"))
+		})
+
+		it("should encode vscode:// callback URLs correctly", () => {
+			const desktopCallback = "vscode://saoudrizwan.claude-dev/openrouter"
+
+			const authUrl = new URL("https://openrouter.ai/auth")
+			authUrl.searchParams.set("callback_url", desktopCallback)
+
+			const parsed = new URL(authUrl.toString())
+			parsed.searchParams.get("callback_url")!.should.equal(desktopCallback)
+		})
+	})
+})
diff --git a/apps/vscode/src/test/services/search/file-search.test.ts b/apps/vscode/src/test/services/search/file-search.test.ts
new file mode 100644
index 0000000..6ec2454
--- /dev/null
+++ b/apps/vscode/src/test/services/search/file-search.test.ts
@@ -0,0 +1,388 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import * as actualFileSearch from "@services/search/file-search"
+import * as actualChildProcess from "child_process"
+import * as fs from "fs"
+import type { FzfResultItem } from "fzf"
+import should from "should"
+import sinon from "sinon"
+import { Readable } from "stream"
+import { HostProvider } from "@/hosts/host-provider"
+import { SearchWorkspaceItemsRequest_SearchItemType, SearchWorkspaceItemsResponse } from "@/shared/proto/host/workspace"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+
+// bun loads real ESM, so sinon cannot stub the `@services/search/file-search`
+// namespace exports ("ES Modules cannot be stubbed"). Two seams are needed:
+//
+//  1. child_process.spawn — the SUT's real `executeRipgrepForFiles` calls its
+//     own `getSpawnFunction()` (which returns `childProcess.spawn`) via an
+//     internal binding that mock.module on the file-search module CANNOT
+//     intercept. Mocking `child_process.spawn` itself reaches it. `spawnImpl` is
+//     swapped per-test (replacing the old `sandbox.stub(fileSearch,
+//     "getSpawnFunction")`).
+//  2. file-search self-exports — the tests that stub `executeRipgrepForFiles` /
+//     `searchWorkspaceFiles` call them through the `fileSearch` namespace, so a
+//     mock.module with mutable delegates intercepts those direct calls. Real
+//     implementations are captured before mock.module to avoid recursion.
+//
+// `fs.promises.*` and `HostProvider.workspace/window.*` are plain objects whose
+// methods sinon CAN still stub directly, so those keep `sandbox.stub`.
+const realSpawn = actualChildProcess.spawn
+let spawnImpl: typeof actualChildProcess.spawn | null = null
+const childProcessNamespace = {
+	...actualChildProcess,
+	spawn: ((...args: Parameters<typeof actualChildProcess.spawn>) =>
+		(spawnImpl ?? realSpawn)(...args)) as typeof actualChildProcess.spawn,
+}
+const childProcessMock = () => ({ ...childProcessNamespace, default: childProcessNamespace })
+mock.module("child_process", childProcessMock)
+mock.module("node:child_process", childProcessMock)
+
+const realExecuteRipgrepForFiles = actualFileSearch.executeRipgrepForFiles
+const realSearchWorkspaceFiles = actualFileSearch.searchWorkspaceFiles
+let executeRipgrepOverride: typeof actualFileSearch.executeRipgrepForFiles | null = null
+let searchWorkspaceFilesOverride: typeof actualFileSearch.searchWorkspaceFiles | null = null
+const fileSearchMock = () => ({
+	...actualFileSearch,
+	executeRipgrepForFiles: ((...args: Parameters<typeof actualFileSearch.executeRipgrepForFiles>) =>
+		(executeRipgrepOverride ?? realExecuteRipgrepForFiles)(...args)) as typeof actualFileSearch.executeRipgrepForFiles,
+	searchWorkspaceFiles: ((...args: Parameters<typeof actualFileSearch.searchWorkspaceFiles>) =>
+		(searchWorkspaceFilesOverride ?? realSearchWorkspaceFiles)(...args)) as typeof actualFileSearch.searchWorkspaceFiles,
+})
+mock.module("@services/search/file-search", fileSearchMock)
+mock.module("@/services/search/file-search", fileSearchMock)
+
+import * as fileSearch from "@services/search/file-search"
+
+describe("File Search", () => {
+	let sandbox: sinon.SinonSandbox
+	let spawnStub: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		// Replace child_process.spawn for this test. `spawnStub` keeps the same
+		// (command, options) call shape the old getSpawnFunction wrapper had.
+		spawnStub = sandbox.stub()
+		spawnImpl = ((command: string, options?: unknown) => spawnStub(command, options)) as typeof actualChildProcess.spawn
+		// Reset self-export overrides each test.
+		executeRipgrepOverride = null
+		searchWorkspaceFilesOverride = null
+
+		sandbox.stub(fs.promises, "lstat").resolves({ isDirectory: () => false } as fs.Stats)
+
+		// Mock fs.access to return true for both Unix and Windows ripgrep binary paths
+		const accessStub = sandbox.stub(fs.promises, "access")
+		accessStub.withArgs("/mock/path/rg").resolves()
+		accessStub.withArgs("/mock/path/rg.exe").resolves()
+		accessStub.withArgs("/mock/path/to/binary/rg").resolves()
+		accessStub.withArgs("/mock/path/to/binary/rg.exe").resolves()
+
+		setVscodeHostProviderMock()
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+		spawnImpl = null
+		executeRipgrepOverride = null
+		searchWorkspaceFilesOverride = null
+	})
+
+	describe("executeRipgrepForFiles", () => {
+		it("should correctly process and return file and folder results", async () => {
+			const mockFiles = ["file1.txt", "folder1/file2.js", "folder1/subfolder/file3.py"]
+
+			// Create a proper mock for the child process
+			const mockStdout = new Readable({
+				read() {
+					this.push(mockFiles.join("\n"))
+					this.push(null) // Signal the end of the stream
+				},
+			})
+
+			const mockStderr = new Readable({
+				read() {
+					this.push(null) // Empty stream
+				},
+			})
+
+			spawnStub.returns({
+				stdout: mockStdout,
+				stderr: mockStderr,
+				on: sinon.stub().returns({}),
+			} as unknown as actualChildProcess.ChildProcess)
+
+			// Instead of stubbing path functions, we'll stub the executeRipgrepForFiles function
+			// to return a predictable result for this test
+			const expectedResult: { path: string; type: "file" | "folder"; label?: string }[] = [
+				{ path: "file1.txt", type: "file", label: "file1.txt" },
+				{ path: "folder1/file2.js", type: "file", label: "file2.js" },
+				{ path: "folder1/subfolder/file3.py", type: "file", label: "file3.py" },
+				{ path: "folder1", type: "folder", label: "folder1" },
+				{ path: "folder1/subfolder", type: "folder", label: "subfolder" },
+			]
+
+			// Override executeRipgrepForFiles (via mock.module delegate) for this test
+			executeRipgrepOverride = async () => expectedResult
+
+			const result = await fileSearch.executeRipgrepForFiles("/workspace", 5000)
+
+			should(result).be.an.Array()
+			// Don't assert on the exact length as it may vary
+
+			const files = result.filter((item) => item.type === "file")
+			const folders = result.filter((item) => item.type === "folder")
+
+			// Verify we have at least the expected files and folders
+			should(files.length).be.greaterThanOrEqual(3)
+			should(folders.length).be.greaterThanOrEqual(2)
+
+			should(files[0]).have.properties({
+				path: "file1.txt",
+				type: "file",
+				label: "file1.txt",
+			})
+
+			should(folders).containDeep([
+				{ path: "folder1", type: "folder", label: "folder1" },
+				{ path: "folder1/subfolder", type: "folder", label: "subfolder" },
+			])
+		})
+
+		it("should handle errors from ripgrep", async () => {
+			const mockError = "Mock ripgrep error"
+
+			// Create proper mock streams for error case
+			const mockStdout = new Readable({
+				read() {
+					this.push(null) // Empty stream
+				},
+			})
+
+			const mockStderr = new Readable({
+				read() {
+					this.push(mockError)
+					this.push(null) // Signal the end of the stream
+				},
+			})
+
+			spawnStub.returns({
+				stdout: mockStdout,
+				stderr: mockStderr,
+				on: function (event: string, callback: Function) {
+					if (event === "error") {
+						callback(new Error(mockError))
+					}
+					return this
+				},
+			} as unknown as actualChildProcess.ChildProcess)
+
+			await should(fileSearch.executeRipgrepForFiles("/workspace", 5000)).be.rejectedWith(
+				`ripgrep failed to spawn: ${mockError}`,
+			)
+		})
+
+		it("should reject with RipgrepError when ripgrep exits non-zero with no results", async () => {
+			const mockStdout = new Readable({
+				read() {
+					this.push(null)
+				},
+			})
+			const mockStderr = new Readable({
+				read() {
+					this.push("rg: /bogus: No such file or directory (os error 2)")
+					this.push(null)
+				},
+			})
+
+			let exitHandler: ((code: number | null) => void) | null = null
+			spawnStub.returns({
+				stdout: mockStdout,
+				stderr: mockStderr,
+				on: function (event: string, callback: Function) {
+					if (event === "exit") {
+						exitHandler = callback as (code: number | null) => void
+						// Schedule the exit-code emission for after the readline 'close'
+						setImmediate(() => exitHandler?.(2))
+					}
+					return this
+				},
+				kill: () => {},
+			} as unknown as actualChildProcess.ChildProcess)
+
+			const err = await fileSearch.executeRipgrepForFiles("/workspace", 5000).catch((e) => e)
+			should(err.message).match(/ripgrep exited with code 2/)
+			should(err).have.property("name", "RipgrepError")
+			should(err.stderr).match(/No such file or directory/)
+		})
+
+		it("falls back to a system ripgrep when the bundled binary path is missing", async () => {
+			setVscodeHostProviderMock({
+				getBinaryLocation: async () => "/missing/rg",
+			})
+
+			const accessStub = fs.promises.access as sinon.SinonStub
+			accessStub.withArgs("/missing/rg").rejects(new Error("missing"))
+			accessStub.withArgs("/usr/bin/rg", fs.constants.X_OK).resolves()
+
+			const mockStdout = new Readable({
+				read() {
+					this.push("/workspace/src/main.ts\n")
+					this.push(null)
+				},
+			})
+			const mockStderr = new Readable({
+				read() {
+					this.push(null)
+				},
+			})
+
+			spawnStub.returns({
+				stdout: mockStdout,
+				stderr: mockStderr,
+				on: function (event: string, callback: Function) {
+					if (event === "exit") {
+						setImmediate(() => callback(0))
+					}
+					return this
+				},
+				kill: () => {},
+			} as unknown as actualChildProcess.ChildProcess)
+
+			const result = await fileSearch.executeRipgrepForFiles("/workspace", 5000)
+			const expectedPath = process.platform === "win32" ? "src\\main.ts" : "src/main.ts"
+
+			should(spawnStub.firstCall.args[0]).equal(process.platform === "win32" ? "rg.exe" : "/usr/bin/rg")
+			should(result).containDeep([{ path: expectedPath, type: "file", label: "main.ts" }])
+		})
+	})
+
+	describe("searchWorkspaceFiles", () => {
+		it("should return top N results for empty query", async () => {
+			const mockItems: { path: string; type: "file" | "folder"; label?: string }[] = [
+				{ path: "file1.txt", type: "file", label: "file1.txt" },
+				{ path: "folder1", type: "folder", label: "folder1" },
+				{ path: "file2.js", type: "file", label: "file2.js" },
+			]
+
+			// Override searchWorkspaceFiles (via mock.module delegate) for this test
+			searchWorkspaceFilesOverride = (async () => ({
+				items: mockItems.slice(0, 2),
+				source: "ripgrep",
+			})) as typeof realSearchWorkspaceFiles
+
+			const result = await fileSearch.searchWorkspaceFiles("", "/workspace", 2)
+
+			should(result.items).be.an.Array()
+			should(result.items).have.length(2)
+			should(result.items).deepEqual(mockItems.slice(0, 2))
+			should(result.source).equal("ripgrep")
+		})
+
+		it("should not duplicate a folder when the host returns it as both an explicit folder and a parent of a file", async () => {
+			// Repro for CLINE-2092 review feedback: with `selectedType=undefined`, the
+			// host-index path returned `src/` as an explicit folder *and* `src/main.ts`
+			// as a file, then the parent-walk re-added `src` as an inferred dir, so the
+			// picker showed `src` twice.
+			const hostResponse = SearchWorkspaceItemsResponse.create({
+				items: [
+					{ path: "src", type: SearchWorkspaceItemsRequest_SearchItemType.FOLDER, label: "src" },
+					{ path: "src/main.ts", type: SearchWorkspaceItemsRequest_SearchItemType.FILE, label: "main.ts" },
+				],
+			})
+			const searchItemsStub = sandbox.stub(HostProvider.workspace, "searchWorkspaceItems").resolves(hostResponse)
+			sandbox.stub(HostProvider.window, "getOpenTabs").resolves({ paths: [] } as any)
+
+			const result = await fileSearch.searchWorkspaceFiles("", "/workspace", 20)
+
+			should(searchItemsStub.calledOnce).be.true()
+			should(result.source).equal("host_index")
+
+			const srcEntries = result.items.filter((item) => item.path === "src")
+			should(srcEntries).have.length(1)
+			should(srcEntries[0]).have.properties({ path: "src", type: "folder" })
+		})
+
+		it("continues search when the host cannot return open tabs", async () => {
+			sandbox.stub(HostProvider.window, "getOpenTabs").rejects(new Error("getOpenTabs unavailable"))
+			sandbox.stub(HostProvider.workspace, "searchWorkspaceItems").rejects({ code: 12, message: "not implemented" })
+
+			const mockStdout = new Readable({
+				read() {
+					this.push("/workspace/src/main.ts\n")
+					this.push(null)
+				},
+			})
+			const mockStderr = new Readable({
+				read() {
+					this.push(null)
+				},
+			})
+
+			spawnStub.returns({
+				stdout: mockStdout,
+				stderr: mockStderr,
+				on: function (event: string, callback: Function) {
+					if (event === "exit") {
+						setImmediate(() => callback(0))
+					}
+					return this
+				},
+				kill: () => {},
+			} as unknown as actualChildProcess.ChildProcess)
+
+			const result = await fileSearch.searchWorkspaceFiles("", "/workspace", 20)
+			const expectedPath = process.platform === "win32" ? "src\\main.ts" : "src/main.ts"
+
+			should(result.source).equal("ripgrep")
+			should(result.items).containDeep([{ path: expectedPath, type: "file", label: "main.ts" }])
+		})
+
+		it("should apply fuzzy matching for non-empty query", async () => {
+			const mockItems: { path: string; type: "file" | "folder"; label?: string }[] = [
+				{ path: "file1.txt", type: "file", label: "file1.txt" },
+				{ path: "folder1/important.js", type: "file", label: "important.js" },
+				{ path: "file2.js", type: "file", label: "file2.js" },
+			]
+
+			executeRipgrepOverride = async () => mockItems
+			const fzfStub = {
+				find: sinon.stub().returns([{ item: mockItems[1], score: 0 }]),
+			}
+			// Create a mock for the fzf module
+			const _fzfModuleStub = {
+				Fzf: sinon.stub().returns(fzfStub),
+				byLengthAsc: sinon.stub(),
+			}
+
+			// Use a more reliable approach to mock dynamic imports
+			// This replaces the actual implementation of searchWorkspaceFiles to avoid the dynamic import
+			searchWorkspaceFilesOverride = (async (query: string, _workspacePath: string, limit: number) => {
+				if (!query.trim()) {
+					return { items: mockItems.slice(0, limit), source: "ripgrep" }
+				}
+				// Simulate the fuzzy search behavior
+				return { items: [mockItems[1]], source: "ripgrep" }
+			}) as typeof realSearchWorkspaceFiles
+
+			const result = await fileSearch.searchWorkspaceFiles("imp", "/workspace", 2)
+
+			should(result.items).be.an.Array()
+			should(result.items).have.length(1)
+			should(result.items[0]).have.properties({
+				path: "folder1/important.js",
+				type: "file",
+				label: "important.js",
+			})
+		})
+	})
+
+	describe("OrderbyMatchScore", () => {
+		it("should prioritize results with fewer gaps between matched characters", () => {
+			const mockItemA: FzfResultItem<any> = { item: {}, positions: new Set([0, 1, 2, 5]), start: 0, end: 5, score: 0 }
+			const mockItemB: FzfResultItem<any> = { item: {}, positions: new Set([0, 2, 4, 6]), start: 0, end: 6, score: 0 }
+
+			const result = fileSearch.OrderbyMatchScore(mockItemA, mockItemB)
+
+			should(result).be.lessThan(0)
+		})
+	})
+})
diff --git a/apps/vscode/src/test/shell.test.ts b/apps/vscode/src/test/shell.test.ts
new file mode 100644
index 0000000..543c3d6
--- /dev/null
+++ b/apps/vscode/src/test/shell.test.ts
@@ -0,0 +1,253 @@
+import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { expect } from "chai"
+import * as actualOs from "os"
+import * as vscode from "vscode"
+
+// bun loads real ESM, so the SUT's `import { userInfo } from "os"` binding is
+// read-only and cannot be reassigned (the previous mocha test did
+// `(userInfo as any) = ...`). Route `userInfo` through a mutable module-level
+// delegate installed via mock.module, then swap the delegate per-test.
+let userInfoImpl: typeof actualOs.userInfo = actualOs.userInfo
+const userInfoDelegate = ((...args: unknown[]) =>
+	(userInfoImpl as (...a: unknown[]) => unknown)(...args)) as typeof actualOs.userInfo
+const osMockNamespace = { ...actualOs, userInfo: userInfoDelegate }
+const osMock = () => ({ ...osMockNamespace, default: osMockNamespace })
+mock.module("os", osMock)
+mock.module("node:os", osMock)
+
+import { getShell } from "@utils/shell"
+
+describe("Shell Detection Tests", () => {
+	let originalPlatform: string
+	let originalEnv: NodeJS.ProcessEnv
+	let originalGetConfig: typeof vscode.workspace.getConfiguration
+	let originalUserInfo: typeof actualOs.userInfo
+
+	// Helper to mock VS Code configuration
+	function mockVsCodeConfig(platformKey: string, defaultProfileName: string | null, profiles: Record<string, any>) {
+		vscode.workspace.getConfiguration = () =>
+			({
+				get: (key: string) => {
+					if (key === `defaultProfile.${platformKey}`) {
+						return defaultProfileName
+					}
+					if (key === `profiles.${platformKey}`) {
+						return profiles
+					}
+					return undefined
+				},
+			}) as any
+	}
+
+	beforeEach(() => {
+		// Store original references
+		originalPlatform = process.platform
+		originalEnv = { ...process.env }
+		originalGetConfig = vscode.workspace.getConfiguration
+		originalUserInfo = userInfoImpl
+
+		// Clear environment variables for a clean test
+		delete process.env.SHELL
+		delete process.env.COMSPEC
+
+		// Default userInfo() mock
+		userInfoImpl = (() => ({ shell: null })) as any
+	})
+
+	afterEach(() => {
+		// Restore everything
+		Object.defineProperty(process, "platform", { value: originalPlatform })
+		process.env = originalEnv
+		vscode.workspace.getConfiguration = originalGetConfig
+		userInfoImpl = originalUserInfo
+	})
+
+	// --------------------------------------------------------------------------
+	// Windows Shell Detection
+	// --------------------------------------------------------------------------
+	describe("Windows Shell Detection", () => {
+		beforeEach(() => {
+			Object.defineProperty(process, "platform", { value: "win32" })
+		})
+
+		it("uses explicit PowerShell 7 path from VS Code config (profile path)", () => {
+			mockVsCodeConfig("windows", "PowerShell", {
+				PowerShell: { path: "C:\\Program Files\\PowerShell\\7\\pwsh.exe" },
+			})
+			expect(getShell()).to.equal("C:\\Program Files\\PowerShell\\7\\pwsh.exe")
+		})
+
+		it("uses PowerShell 7 path if source is 'PowerShell' but no explicit path", () => {
+			mockVsCodeConfig("windows", "PowerShell", {
+				PowerShell: { source: "PowerShell" },
+			})
+			expect(getShell()).to.equal("C:\\Program Files\\PowerShell\\7\\pwsh.exe")
+		})
+
+		it("falls back to legacy PowerShell if profile includes 'powershell' but no path/source", () => {
+			mockVsCodeConfig("windows", "PowerShell", {
+				PowerShell: {},
+			})
+			expect(getShell()).to.equal("C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe")
+		})
+
+		it("handles undefined shell profile gracefully", () => {
+			mockVsCodeConfig("windows", "NonExistentProfile", {})
+			expect(getShell()).to.equal("C:\\Windows\\System32\\cmd.exe")
+		})
+
+		it("uses WSL bash when profile indicates WSL source", () => {
+			mockVsCodeConfig("windows", "WSL", {
+				WSL: { source: "WSL" },
+			})
+			expect(getShell()).to.equal("/bin/bash")
+		})
+
+		it("uses WSL bash when profile name includes 'wsl'", () => {
+			mockVsCodeConfig("windows", "Ubuntu WSL", {
+				"Ubuntu WSL": {},
+			})
+			expect(getShell()).to.equal("/bin/bash")
+		})
+
+		it("defaults to cmd.exe if no special profile is matched", () => {
+			mockVsCodeConfig("windows", "CommandPrompt", {
+				CommandPrompt: {},
+			})
+			expect(getShell()).to.equal("C:\\Windows\\System32\\cmd.exe")
+		})
+
+		it("respects userInfo() if no VS Code config is available", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			userInfoImpl = () => ({ shell: "C:\\Custom\\PowerShell.exe" }) as any
+
+			expect(getShell()).to.equal("C:\\Custom\\PowerShell.exe")
+		})
+
+		it("respects an odd COMSPEC if no userInfo shell is available", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			process.env.COMSPEC = "D:\\CustomCmd\\cmd.exe"
+
+			expect(getShell()).to.equal("D:\\CustomCmd\\cmd.exe")
+		})
+	})
+
+	// --------------------------------------------------------------------------
+	// macOS Shell Detection
+	// --------------------------------------------------------------------------
+	describe("macOS Shell Detection", () => {
+		beforeEach(() => {
+			Object.defineProperty(process, "platform", { value: "darwin" })
+		})
+
+		it("uses VS Code profile path if available", () => {
+			mockVsCodeConfig("osx", "MyCustomShell", {
+				MyCustomShell: { path: "/usr/local/bin/fish" },
+			})
+			expect(getShell()).to.equal("/usr/local/bin/fish")
+		})
+
+		it("falls back to userInfo().shell if no VS Code config is available", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			userInfoImpl = () => ({ shell: "/opt/homebrew/bin/zsh" }) as any
+
+			expect(getShell()).to.equal("/opt/homebrew/bin/zsh")
+		})
+
+		it("falls back to SHELL env var if no userInfo shell is found", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			process.env.SHELL = "/usr/local/bin/zsh"
+
+			expect(getShell()).to.equal("/usr/local/bin/zsh")
+		})
+
+		it("falls back to /bin/zsh if no config, userInfo, or env variable is set", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			// userInfo => null, SHELL => undefined
+			expect(getShell()).to.equal("/bin/zsh")
+		})
+	})
+
+	// --------------------------------------------------------------------------
+	// Linux Shell Detection
+	// --------------------------------------------------------------------------
+	describe("Linux Shell Detection", () => {
+		beforeEach(() => {
+			Object.defineProperty(process, "platform", { value: "linux" })
+		})
+
+		it("uses VS Code profile path if available", () => {
+			mockVsCodeConfig("linux", "CustomProfile", {
+				CustomProfile: { path: "/usr/bin/fish" },
+			})
+			expect(getShell()).to.equal("/usr/bin/fish")
+		})
+
+		it("falls back to userInfo().shell if no VS Code config is available", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			userInfoImpl = () => ({ shell: "/usr/bin/zsh" }) as any
+
+			expect(getShell()).to.equal("/usr/bin/zsh")
+		})
+
+		it("falls back to SHELL env var if no userInfo shell is found", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			process.env.SHELL = "/usr/bin/fish"
+
+			expect(getShell()).to.equal("/usr/bin/fish")
+		})
+
+		it("falls back to /bin/bash if nothing is set", () => {
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			// userInfo => null, SHELL => undefined
+			expect(getShell()).to.equal("/bin/bash")
+		})
+	})
+
+	// --------------------------------------------------------------------------
+	// Unknown Platform & Error Handling
+	// --------------------------------------------------------------------------
+	describe("Unknown Platform / Error Handling", () => {
+		it("falls back to /bin/sh for unknown platforms", () => {
+			Object.defineProperty(process, "platform", { value: "sunos" })
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+
+			expect(getShell()).to.equal("/bin/sh")
+		})
+
+		it("handles VS Code config errors gracefully, falling back to userInfo shell if present", () => {
+			Object.defineProperty(process, "platform", { value: "linux" })
+			vscode.workspace.getConfiguration = () => {
+				throw new Error("Configuration error")
+			}
+			userInfoImpl = () => ({ shell: "/bin/bash" }) as any
+
+			expect(getShell()).to.equal("/bin/bash")
+		})
+
+		it("handles userInfo errors gracefully, falling back to environment variable if present", () => {
+			Object.defineProperty(process, "platform", { value: "darwin" })
+			vscode.workspace.getConfiguration = () => ({ get: () => undefined }) as any
+			userInfoImpl = () => {
+				throw new Error("userInfo error")
+			}
+			process.env.SHELL = "/bin/zsh"
+
+			expect(getShell()).to.equal("/bin/zsh")
+		})
+
+		it("falls back fully to default shell paths if everything fails", () => {
+			Object.defineProperty(process, "platform", { value: "linux" })
+			vscode.workspace.getConfiguration = () => {
+				throw new Error("Configuration error")
+			}
+			userInfoImpl = () => {
+				throw new Error("userInfo error")
+			}
+			// No SHELL in env
+			delete process.env.SHELL
+
+			expect(getShell()).to.equal("/bin/bash")
+		})
+	})
+})
diff --git a/apps/vscode/src/test/slash-commands.test.ts b/apps/vscode/src/test/slash-commands.test.ts
new file mode 100644
index 0000000..754dc9b
--- /dev/null
+++ b/apps/vscode/src/test/slash-commands.test.ts
@@ -0,0 +1,285 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import "should"
+import * as sinon from "sinon"
+import { Controller } from "../core/controller"
+import { getAvailableSlashCommands } from "../core/controller/slash/getAvailableSlashCommands"
+import { EmptyRequest } from "../shared/proto/cline/common"
+import { BASE_SLASH_COMMANDS } from "../shared/slashCommands"
+
+/**
+ * Unit tests for getAvailableSlashCommands RPC endpoint
+ * Tests the slash command discovery and filtering functionality
+ */
+describe("getAvailableSlashCommands", () => {
+	let mockController: Partial<Controller>
+	let mockStateManager: {
+		getWorkspaceStateKey: sinon.SinonStub
+		getGlobalSettingsKey: sinon.SinonStub
+		getGlobalStateKey: sinon.SinonStub
+		getRemoteConfigSettings: sinon.SinonStub
+	}
+
+	beforeEach(() => {
+		mockStateManager = {
+			getWorkspaceStateKey: sinon.stub(),
+			getGlobalSettingsKey: sinon.stub(),
+			getGlobalStateKey: sinon.stub(),
+			getRemoteConfigSettings: sinon.stub(),
+		}
+
+		// Default stubs return empty/null values
+		mockStateManager.getWorkspaceStateKey.returns(null)
+		mockStateManager.getGlobalSettingsKey.returns(null)
+		mockStateManager.getGlobalStateKey.returns(null)
+		mockStateManager.getRemoteConfigSettings.returns(null)
+
+		mockController = {
+			stateManager: mockStateManager as any,
+		}
+	})
+
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	describe("Base Slash Commands", () => {
+		it("should return all base slash commands", async () => {
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			// Should have at least all base commands
+			response.commands.length.should.be.greaterThanOrEqual(BASE_SLASH_COMMANDS.length)
+
+			// Verify each base command is present
+			for (const baseCmd of BASE_SLASH_COMMANDS) {
+				const found = response.commands.find((cmd) => cmd.name === baseCmd.name)
+				found!.should.not.be.undefined()
+				found!.description.should.equal(baseCmd.description)
+				found!.section.should.equal("default")
+				found!.cliCompatible.should.equal(baseCmd.cliCompatible ?? false)
+			}
+		})
+
+		it("should not include the deprecated subagent slash command", async () => {
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+			const deprecatedCommand = response.commands.find((cmd) => cmd.name === "subagent")
+			;(deprecatedCommand === undefined).should.be.true()
+		})
+
+		it("should mark base commands with section 'default'", async () => {
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const baseCommandNames = BASE_SLASH_COMMANDS.map((cmd) => cmd.name)
+			for (const cmd of response.commands) {
+				if (baseCommandNames.includes(cmd.name)) {
+					cmd.section.should.equal("default")
+				}
+			}
+		})
+	})
+
+	describe("Local Workflow Toggles", () => {
+		it("should include enabled local workflows", async () => {
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
+				"/path/to/my-workflow.md": true,
+				"/path/to/another-workflow.md": true,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const myWorkflow = response.commands.find((cmd) => cmd.name === "my-workflow.md")
+			myWorkflow!.should.not.be.undefined()
+			myWorkflow!.section.should.equal("custom")
+			myWorkflow!.cliCompatible.should.equal(true)
+
+			const anotherWorkflow = response.commands.find((cmd) => cmd.name === "another-workflow.md")
+			anotherWorkflow!.should.not.be.undefined()
+		})
+
+		it("should exclude disabled local workflows", async () => {
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
+				"/path/to/enabled-workflow.md": true,
+				"/path/to/disabled-workflow.md": false,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const enabled = response.commands.find((cmd) => cmd.name === "enabled-workflow.md")
+			enabled!.should.not.be.undefined()
+
+			const disabled = response.commands.find((cmd) => cmd.name === "disabled-workflow.md")
+			;(disabled === undefined).should.be.true()
+		})
+
+		it("should extract filename from full path", async () => {
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
+				"/Users/test/project/.clinerules/workflows/deep-analysis.md": true,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "deep-analysis.md")
+			workflow!.should.not.be.undefined()
+		})
+
+		it("should handle Windows-style paths", async () => {
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
+				"C:\\Users\\test\\project\\.clinerules\\workflows\\windows-workflow.md": true,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "windows-workflow.md")
+			workflow!.should.not.be.undefined()
+		})
+	})
+
+	describe("Global Workflow Toggles", () => {
+		it("should include enabled global workflows", async () => {
+			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
+				"/global/path/global-workflow.md": true,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "global-workflow.md")
+			workflow!.should.not.be.undefined()
+			workflow!.section.should.equal("custom")
+		})
+
+		it("should exclude disabled global workflows", async () => {
+			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
+				"/global/path/disabled-global.md": false,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "disabled-global.md")
+			;(workflow === undefined).should.be.true()
+		})
+	})
+
+	describe("Workflow Deduplication", () => {
+		it("should prefer local workflows over global workflows with same name", async () => {
+			// Same filename in both local and global
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
+				"/local/path/shared-workflow.md": true,
+			})
+			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
+				"/global/path/shared-workflow.md": true,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			// Should only appear once
+			const matches = response.commands.filter((cmd) => cmd.name === "shared-workflow.md")
+			matches.length.should.equal(1)
+		})
+
+		it("should include global workflow if local with same name is disabled", async () => {
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
+				"/local/path/shared-workflow.md": false, // disabled locally
+			})
+			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
+				"/global/path/shared-workflow.md": true, // enabled globally
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			// Global should appear since local is disabled
+			const workflow = response.commands.find((cmd) => cmd.name === "shared-workflow.md")
+			workflow!.should.not.be.undefined()
+		})
+	})
+
+	describe("Remote Workflows", () => {
+		it("should include alwaysEnabled remote workflows", async () => {
+			mockStateManager.getRemoteConfigSettings.returns({
+				remoteGlobalWorkflows: [{ name: "always-on-workflow", alwaysEnabled: true }],
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "always-on-workflow")
+			workflow!.should.not.be.undefined()
+			workflow!.section.should.equal("custom")
+		})
+
+		it("should include remote workflows enabled by toggle", async () => {
+			mockStateManager.getRemoteConfigSettings.returns({
+				remoteGlobalWorkflows: [{ name: "toggle-workflow", alwaysEnabled: false }],
+			})
+			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({
+				"toggle-workflow": true, // not explicitly disabled
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "toggle-workflow")
+			workflow!.should.not.be.undefined()
+		})
+
+		it("should exclude remote workflows explicitly disabled by toggle", async () => {
+			mockStateManager.getRemoteConfigSettings.returns({
+				remoteGlobalWorkflows: [{ name: "disabled-remote", alwaysEnabled: false }],
+			})
+			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({
+				"disabled-remote": false,
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "disabled-remote")
+			;(workflow === undefined).should.be.true()
+		})
+
+		it("should include remote workflows by default if not explicitly disabled", async () => {
+			mockStateManager.getRemoteConfigSettings.returns({
+				remoteGlobalWorkflows: [{ name: "default-enabled", alwaysEnabled: false }],
+			})
+			// No toggle entry for this workflow
+			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			const workflow = response.commands.find((cmd) => cmd.name === "default-enabled")
+			workflow!.should.not.be.undefined()
+		})
+	})
+
+	describe("Edge Cases", () => {
+		it("should handle null/undefined state values gracefully", async () => {
+			mockStateManager.getWorkspaceStateKey.returns(null)
+			mockStateManager.getGlobalSettingsKey.returns(undefined)
+			mockStateManager.getGlobalStateKey.returns(null)
+			mockStateManager.getRemoteConfigSettings.returns(null)
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			// Should still return base commands
+			response.commands.length.should.be.greaterThanOrEqual(BASE_SLASH_COMMANDS.length)
+		})
+
+		it("should handle empty workflow toggle objects", async () => {
+			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({})
+			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({})
+			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({})
+			mockStateManager.getRemoteConfigSettings.returns({
+				remoteGlobalWorkflows: [],
+			})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			// Should only have base commands
+			response.commands.length.should.equal(BASE_SLASH_COMMANDS.length)
+		})
+
+		it("should handle remote config with no remoteGlobalWorkflows property", async () => {
+			mockStateManager.getRemoteConfigSettings.returns({})
+
+			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
+
+			// Should not throw, just return base commands
+			response.commands.length.should.be.greaterThanOrEqual(BASE_SLASH_COMMANDS.length)
+		})
+	})
+})
diff --git a/apps/vscode/src/test/vscode-mock.ts b/apps/vscode/src/test/vscode-mock.ts
new file mode 100644
index 0000000..6d80d82
--- /dev/null
+++ b/apps/vscode/src/test/vscode-mock.ts
@@ -0,0 +1,64 @@
+// Mock implementation of VSCode API for unit tests
+export const env = {
+	machineId: "test-machine-id",
+	appName: "VS Code",
+	remoteName: undefined as string | undefined,
+	isTelemetryEnabled: true,
+	onDidChangeTelemetryEnabled: (_callback: (enabled: boolean) => void) => {
+		// Return a disposable mock
+		return {
+			dispose: () => {},
+		}
+	},
+}
+
+export const version = "1.103.0"
+
+export const workspace = {
+	getConfiguration: (section?: string) => {
+		return {
+			get: (key: string, defaultValue?: any) => {
+				// Return default values for common configuration keys
+				if (section === "cline" && key === "telemetrySetting") {
+					return "enabled"
+				}
+				if (section === "telemetry" && key === "telemetryLevel") {
+					return "all"
+				}
+				return defaultValue
+			},
+		}
+	},
+}
+
+// Export other commonly used VSCode API mocks as needed
+export const window = {
+	showErrorMessage: (_message: string) => Promise.resolve(),
+	showWarningMessage: (_message: string) => Promise.resolve(),
+	showInformationMessage: (_message: string) => Promise.resolve(),
+	createTextEditorDecorationType: (_options: any) => ({
+		key: "mock-decoration-type",
+		dispose: () => {},
+	}),
+	createOutputChannel: (_name: string) => ({
+		appendLine: (message: string) => console.debug(message),
+		append: (message: string) => console.debug(message),
+		clear: () => {},
+		show: () => {},
+		hide: () => {},
+		dispose: () => {},
+	}),
+}
+
+export const commands = {
+	executeCommand: (_command: string, ..._args: any[]) => Promise.resolve(),
+}
+
+export const Uri = {
+	file: (path: string) => ({ fsPath: path, toString: () => path }),
+	parse: (uri: string) => ({ fsPath: uri, toString: () => uri }),
+}
+
+export const ExtensionContextMock = {}
+export const StatusBarAlignmentMock = { Left: 1, Right: 2 }
+export const ViewColumnMock = { One: 1, Two: 2, Three: 3 }
diff --git a/apps/vscode/src/test/vscode-vitest-stub.ts b/apps/vscode/src/test/vscode-vitest-stub.ts
new file mode 100644
index 0000000..e63724e
--- /dev/null
+++ b/apps/vscode/src/test/vscode-vitest-stub.ts
@@ -0,0 +1,149 @@
+const noop = () => undefined
+
+export const version = "test"
+export const commands = { executeCommand: async () => undefined }
+export const env = {
+	clipboard: {
+		readText: async () => "",
+		writeText: async () => undefined,
+	},
+	openExternal: async () => true,
+}
+export const workspace = {
+	workspaceFolders: [],
+	getConfiguration: () => ({ get: noop, update: async () => undefined }),
+	onDidChangeConfiguration: () => ({ dispose: noop }),
+}
+export const window = {
+	activeTextEditor: undefined,
+	visibleTextEditors: [],
+	tabGroups: {
+		all: [] as unknown[],
+		activeTabGroup: { tabs: [] as unknown[] },
+		onDidChangeTabs: () => ({ dispose: noop }),
+		close: async () => true,
+	},
+	showInformationMessage: async () => undefined,
+	showWarningMessage: async () => undefined,
+	showErrorMessage: async () => undefined,
+	showTextDocument: async () => undefined,
+	createOutputChannel: () => ({
+		appendLine: noop,
+		append: noop,
+		clear: noop,
+		show: noop,
+		hide: noop,
+		dispose: noop,
+	}),
+	createTextEditorDecorationType: (_options?: unknown) => ({ key: "mock-decoration-type", dispose: noop }),
+	onDidChangeActiveTextEditor: () => ({ dispose: noop }),
+	onDidChangeVisibleTextEditors: () => ({ dispose: noop }),
+}
+
+export class Position {
+	constructor(
+		public line = 0,
+		public character = 0,
+	) {}
+}
+
+export class Range {
+	constructor(
+		public start: Position = new Position(),
+		public end: Position = new Position(),
+	) {}
+}
+
+export class Selection extends Range {}
+export class ThemeColor {
+	constructor(public id: string) {}
+}
+export class ThemeIcon {
+	constructor(public id: string) {}
+}
+export class Uri {
+	static file(fsPath: string): Uri {
+		return new Uri(fsPath)
+	}
+	static parse(value: string): Uri {
+		return new Uri(value)
+	}
+	constructor(public fsPath: string) {}
+	toString(): string {
+		return this.fsPath
+	}
+}
+export class CancellationTokenSource {
+	dispose(): void {}
+}
+export class CancellationError extends Error {}
+export class Disposable {
+	constructor(public dispose: () => void = noop) {}
+}
+export class EventEmitter<T = unknown> {
+	event = (_listener: (event: T) => void) => ({ dispose: noop })
+	fire(_event: T): void {}
+	dispose(): void {}
+}
+export class RelativePattern {
+	constructor(
+		public base: string,
+		public pattern: string,
+	) {}
+}
+export class MarkdownString {
+	constructor(public value = "") {}
+}
+
+export const ExtensionKind = { UI: 1, Workspace: 2 }
+export const ExtensionMode = { Production: 1, Development: 2, Test: 3 }
+export const ColorThemeKind = { Light: 1, Dark: 2, HighContrast: 3, HighContrastLight: 4 }
+export const TaskRevealKind = { Always: 1, Silent: 2, Never: 3 }
+export const TextEditorSelectionChangeKind = { Keyboard: 1, Mouse: 2, Command: 3 }
+export const TextEditorCursorStyle = { Line: 1, Block: 2, Underline: 3, LineThin: 4, BlockOutline: 5, UnderlineThin: 6 }
+export const TextEditorLineNumbersStyle = { Off: 0, On: 1, Relative: 2 }
+export const TextEditorRevealType = { Default: 0, InCenter: 1, InCenterIfOutsideViewport: 2, AtTop: 3 }
+export const OverviewRulerLane = { Left: 1, Center: 2, Right: 4, Full: 7 }
+export const DecorationRangeBehavior = { OpenOpen: 0, ClosedClosed: 1, OpenClosed: 2, ClosedOpen: 3 }
+export const EndOfLine = { LF: 1, CRLF: 2 }
+export const QuickPickItemKind = { Separator: -1, Default: 0 }
+export const InputBoxValidationSeverity = { Info: 1, Warning: 2, Error: 3 }
+export const CodeActionKind = { QuickFix: { value: "quickfix" } }
+export const CodeActionTriggerKind = { Invoke: 1, Automatic: 2 }
+export const DocumentHighlightKind = { Text: 0, Read: 1, Write: 2 }
+
+export default {
+	version,
+	commands,
+	env,
+	workspace,
+	window,
+	Position,
+	Range,
+	Selection,
+	ThemeColor,
+	ThemeIcon,
+	Uri,
+	CancellationTokenSource,
+	CancellationError,
+	Disposable,
+	EventEmitter,
+	RelativePattern,
+	MarkdownString,
+	ExtensionKind,
+	ExtensionMode,
+	ColorThemeKind,
+	TaskRevealKind,
+	TextEditorSelectionChangeKind,
+	TextEditorCursorStyle,
+	TextEditorLineNumbersStyle,
+	TextEditorRevealType,
+	OverviewRulerLane,
+	DecorationRangeBehavior,
+	EndOfLine,
+	QuickPickItemKind,
+	InputBoxValidationSeverity,
+	CodeActionKind,
+	CodeActionTriggerKind,
+	DocumentHighlightKind,
+}
diff --git a/apps/vscode/src/types/cline-shared-storage.d.ts b/apps/vscode/src/types/cline-shared-storage.d.ts
new file mode 100644
index 0000000..76780d2
--- /dev/null
+++ b/apps/vscode/src/types/cline-shared-storage.d.ts
@@ -0,0 +1,3 @@
+declare module "@cline/shared/storage" {
+	export function resolveGlobalSettingsPath(): string
+}
diff --git a/apps/vscode/src/types/picomatch.d.ts b/apps/vscode/src/types/picomatch.d.ts
new file mode 100644
index 0000000..3c34ccc
--- /dev/null
+++ b/apps/vscode/src/types/picomatch.d.ts
@@ -0,0 +1,15 @@
+declare module "picomatch" {
+	type PicomatchOptions = {
+		dot?: boolean
+		nocase?: boolean
+		ignore?: string | string[]
+		posix?: boolean
+		windows?: boolean
+	}
+
+	type PicomatchMatcher = (input: string) => boolean
+
+	function picomatch(pattern: string | string[], options?: PicomatchOptions): PicomatchMatcher
+
+	export default picomatch
+}
diff --git a/apps/vscode/src/types/vscode-language-model.d.ts b/apps/vscode/src/types/vscode-language-model.d.ts
new file mode 100644
index 0000000..5c34e9f
--- /dev/null
+++ b/apps/vscode/src/types/vscode-language-model.d.ts
@@ -0,0 +1,100 @@
+// Ambient augmentation of the `vscode` module for the Language Model (LM) API.
+//
+// Cline does not bump its VSCode engine requirement / @types/vscode version to
+// pick up the Language Model API typings, so we declare the subset we use here.
+// This was previously colocated in the now-removed legacy VS Code LM provider
+// handler; it is kept as a standalone ambient declaration because live code
+// (e.g. the getVsCodeLmModels gRPC handler, vsCodeSelectorUtils, and the
+// vscode-lm message transform) still depends on these types.
+//
+// Extracted from:
+// https://github.com/microsoft/vscode/blob/131ee0ef660d600cd0a7e6058375b281553abe20/src/vscode-dts/vscode.d.ts
+
+declare module "vscode" {
+	enum LanguageModelChatMessageRole {
+		User = 1,
+		Assistant = 2,
+	}
+	enum LanguageModelChatToolMode {
+		Auto = 1,
+		Required = 2,
+	}
+	interface LanguageModelChatSelector {
+		vendor?: string
+		family?: string
+		version?: string
+		id?: string
+	}
+	interface LanguageModelChatTool {
+		name: string
+		description: string
+		inputSchema?: object
+	}
+	interface LanguageModelChatRequestOptions {
+		justification?: string
+		modelOptions?: { [name: string]: any }
+		tools?: LanguageModelChatTool[]
+		toolMode?: LanguageModelChatToolMode
+	}
+	class LanguageModelTextPart {
+		value: string
+		constructor(value: string)
+	}
+	class LanguageModelToolCallPart {
+		callId: string
+		name: string
+		input: object
+		constructor(callId: string, name: string, input: object)
+	}
+	interface LanguageModelChatResponse {
+		stream: AsyncIterable<LanguageModelTextPart | LanguageModelToolCallPart | unknown>
+		text: AsyncIterable<string>
+	}
+	interface LanguageModelChat {
+		readonly name: string
+		readonly id: string
+		readonly vendor: string
+		readonly family: string
+		readonly version: string
+		readonly maxInputTokens: number
+
+		sendRequest(
+			messages: LanguageModelChatMessage[],
+			options?: LanguageModelChatRequestOptions,
+			token?: CancellationToken,
+		): Thenable<LanguageModelChatResponse>
+		countTokens(text: string | LanguageModelChatMessage, token?: CancellationToken): Thenable<number>
+	}
+	class LanguageModelPromptTsxPart {
+		value: unknown
+		constructor(value: unknown)
+	}
+	class LanguageModelToolResultPart {
+		callId: string
+		content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | unknown>
+		constructor(callId: string, content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | unknown>)
+	}
+	class LanguageModelChatMessage {
+		static User(
+			content: string | Array<LanguageModelTextPart | LanguageModelToolResultPart>,
+			name?: string,
+		): LanguageModelChatMessage
+		static Assistant(
+			content: string | Array<LanguageModelTextPart | LanguageModelToolCallPart>,
+			name?: string,
+		): LanguageModelChatMessage
+
+		role: LanguageModelChatMessageRole
+		content: Array<LanguageModelTextPart | LanguageModelToolResultPart | LanguageModelToolCallPart>
+		name: string | undefined
+
+		constructor(
+			role: LanguageModelChatMessageRole,
+			content: string | Array<LanguageModelTextPart | LanguageModelToolResultPart | LanguageModelToolCallPart>,
+			name?: string,
+		)
+	}
+	namespace lm {
+		function selectChatModels(selector?: LanguageModelChatSelector): Thenable<LanguageModelChat[]>
+	}
+}
diff --git a/apps/vscode/src/types/ws.d.ts b/apps/vscode/src/types/ws.d.ts
new file mode 100644
index 0000000..1201c09
--- /dev/null
+++ b/apps/vscode/src/types/ws.d.ts
@@ -0,0 +1,17 @@
+declare module "ws" {
+	class WebSocket {
+		constructor(url: string)
+		on(event: "open", listener: () => void): this
+		on(event: "error", listener: (error: Error) => void): this
+		on(event: "close", listener: () => void): this
+		on(event: "message", listener: (data: WebSocket.Data) => void): this
+		send(data: string): void
+		close(): void
+	}
+
+	namespace WebSocket {
+		export type Data = string | Buffer | ArrayBuffer | Buffer[]
+	}
+
+	export default WebSocket
+}
diff --git a/apps/vscode/src/utils/__tests__/envExpansion.test.ts b/apps/vscode/src/utils/__tests__/envExpansion.test.ts
new file mode 100644
index 0000000..c318bfd
--- /dev/null
+++ b/apps/vscode/src/utils/__tests__/envExpansion.test.ts
@@ -0,0 +1,259 @@
+import { afterEach, beforeEach, describe, it } from "bun:test"
+import "should"
+import { expandEnvironmentVariables } from "../envExpansion"
+
+describe("expandEnvironmentVariables", () => {
+	// Store original environment
+	let originalEnv: NodeJS.ProcessEnv
+
+	beforeEach(() => {
+		originalEnv = { ...process.env }
+	})
+
+	afterEach(() => {
+		// Restore original environment
+		process.env = originalEnv
+	})
+
+	describe("string expansion", () => {
+		it("should expand a single environment variable", () => {
+			process.env.TEST_VAR = "test_value"
+			const result = expandEnvironmentVariables("${env:TEST_VAR}")
+			result.should.equal("test_value")
+		})
+
+		it("should expand multiple environment variables in one string", () => {
+			process.env.VAR1 = "value1"
+			process.env.VAR2 = "value2"
+			const result = expandEnvironmentVariables("${env:VAR1} and ${env:VAR2}")
+			result.should.equal("value1 and value2")
+		})
+
+		it("should expand environment variables with surrounding text", () => {
+			process.env.API_KEY = "secret123"
+			const result = expandEnvironmentVariables("Bearer ${env:API_KEY}")
+			result.should.equal("Bearer secret123")
+		})
+
+		it("should leave unexpanded when variable is missing", () => {
+			const result = expandEnvironmentVariables("${env:MISSING_VAR}")
+			result.should.equal("${env:MISSING_VAR}")
+		})
+
+		it("should handle empty string values", () => {
+			process.env.EMPTY_VAR = ""
+			const result = expandEnvironmentVariables("${env:EMPTY_VAR}")
+			result.should.equal("")
+		})
+
+		it("should trim whitespace from variable names", () => {
+			process.env.SPACED_VAR = "value"
+			const result = expandEnvironmentVariables("${env: SPACED_VAR }")
+			result.should.equal("value")
+		})
+
+		it("should handle variable names with hyphens", () => {
+			process.env["VAR-NAME"] = "hyphenated"
+			const result = expandEnvironmentVariables("${env:VAR-NAME}")
+			result.should.equal("hyphenated")
+		})
+
+		it("should handle variable names with underscores", () => {
+			process.env.VAR_NAME = "underscored"
+			const result = expandEnvironmentVariables("${env:VAR_NAME}")
+			result.should.equal("underscored")
+		})
+
+		it("should not expand malformed syntax", () => {
+			process.env.TEST_VAR = "value"
+			const result = expandEnvironmentVariables("${env:TEST_VAR")
+			result.should.equal("${env:TEST_VAR")
+		})
+
+		it("should return string unchanged when no variables present", () => {
+			const result = expandEnvironmentVariables("plain string")
+			result.should.equal("plain string")
+		})
+	})
+
+	describe("object expansion", () => {
+		it("should expand variables in object values", () => {
+			process.env.API_KEY = "secret"
+			const result = expandEnvironmentVariables({
+				key: "${env:API_KEY}",
+			})
+			result.should.deepEqual({
+				key: "secret",
+			})
+		})
+
+		it("should expand variables in nested objects", () => {
+			process.env.TOKEN = "token123"
+			process.env.KEY = "key456"
+			const result = expandEnvironmentVariables({
+				outer: {
+					inner: {
+						token: "${env:TOKEN}",
+						key: "${env:KEY}",
+					},
+				},
+			})
+			result.should.deepEqual({
+				outer: {
+					inner: {
+						token: "token123",
+						key: "key456",
+					},
+				},
+			})
+		})
+
+		it("should preserve non-string values in objects", () => {
+			process.env.VAR = "value"
+			const result = expandEnvironmentVariables({
+				string: "${env:VAR}",
+				number: 42,
+				boolean: true,
+				nullValue: null,
+			})
+			result.should.deepEqual({
+				string: "value",
+				number: 42,
+				boolean: true,
+				nullValue: null,
+			})
+		})
+	})
+
+	describe("array expansion", () => {
+		it("should expand variables in array elements", () => {
+			process.env.VAR1 = "first"
+			process.env.VAR2 = "second"
+			const result = expandEnvironmentVariables(["${env:VAR1}", "${env:VAR2}"])
+			result.should.deepEqual(["first", "second"])
+		})
+
+		it("should expand variables in arrays within objects", () => {
+			process.env.ARG1 = "arg1"
+			process.env.ARG2 = "arg2"
+			const result = expandEnvironmentVariables({
+				args: ["${env:ARG1}", "${env:ARG2}"],
+			})
+			result.should.deepEqual({
+				args: ["arg1", "arg2"],
+			})
+		})
+
+		it("should preserve non-string values in arrays", () => {
+			process.env.VAR = "value"
+			const result = expandEnvironmentVariables(["${env:VAR}", 123, true, null])
+			result.should.deepEqual(["value", 123, true, null])
+		})
+	})
+
+	describe("complex nested structures", () => {
+		it("should expand variables in deeply nested structures", () => {
+			process.env.API_KEY = "key123"
+			process.env.TOKEN = "token456"
+			const result = expandEnvironmentVariables({
+				server: {
+					auth: {
+						headers: {
+							Authorization: "Bearer ${env:TOKEN}",
+							"X-API-Key": "${env:API_KEY}",
+						},
+					},
+					config: {
+						args: ["--key", "${env:API_KEY}"],
+					},
+				},
+			})
+			result.should.deepEqual({
+				server: {
+					auth: {
+						headers: {
+							Authorization: "Bearer token456",
+							"X-API-Key": "key123",
+						},
+					},
+					config: {
+						args: ["--key", "key123"],
+					},
+				},
+			})
+		})
+	})
+
+	describe("MCP config realistic scenarios", () => {
+		it("should expand env variables in stdio server config", () => {
+			process.env.MCP_API_KEY = "mykey"
+			const result = expandEnvironmentVariables({
+				type: "stdio",
+				command: "node",
+				args: ["server.js"],
+				env: {
+					API_KEY: "${env:MCP_API_KEY}",
+				},
+			})
+			result.should.deepEqual({
+				type: "stdio",
+				command: "node",
+				args: ["server.js"],
+				env: {
+					API_KEY: "mykey",
+				},
+			})
+		})
+
+		it("should expand env variables in HTTP server headers", () => {
+			process.env.AUTH_TOKEN = "bearer_token_123"
+			const result = expandEnvironmentVariables({
+				type: "streamableHttp",
+				url: "http://localhost:3001/mcp",
+				headers: {
+					Authorization: "Bearer ${env:AUTH_TOKEN}",
+				},
+			})
+			result.should.deepEqual({
+				type: "streamableHttp",
+				url: "http://localhost:3001/mcp",
+				headers: {
+					Authorization: "Bearer bearer_token_123",
+				},
+			})
+		})
+
+		it("should expand env variables in URLs", () => {
+			process.env.MCP_HOST = "api.example.com"
+			process.env.MCP_PORT = "8080"
+			const result = expandEnvironmentVariables({
+				url: "https://${env:MCP_HOST}:${env:MCP_PORT}/mcp",
+			})
+			result.should.deepEqual({
+				url: "https://api.example.com:8080/mcp",
+			})
+		})
+	})
+
+	describe("primitive values", () => {
+		it("should return numbers unchanged", () => {
+			const result = expandEnvironmentVariables(42)
+			result.should.equal(42)
+		})
+
+		it("should return booleans unchanged", () => {
+			const result = expandEnvironmentVariables(true)
+			result.should.equal(true)
+		})
+
+		it("should return null unchanged", () => {
+			const result = expandEnvironmentVariables(null)
+			;(result === null).should.be.true()
+		})
+
+		it("should return undefined unchanged", () => {
+			const result = expandEnvironmentVariables(undefined)
+			;(result === undefined).should.be.true()
+		})
+	})
+})
diff --git a/apps/vscode/src/utils/__tests__/model-utils.test.ts b/apps/vscode/src/utils/__tests__/model-utils.test.ts
new file mode 100644
index 0000000..251c567
--- /dev/null
+++ b/apps/vscode/src/utils/__tests__/model-utils.test.ts
@@ -0,0 +1,231 @@
+import { describe, it } from "bun:test"
+import "should"
+import type { ApiHandlerModel } from "@core/api"
+import {
+	GEMINI_FLASH_MAX_OUTPUT_TOKENS,
+	isClaude4PlusModelFamily,
+	isGeminiFlashModel,
+	isGLMModelFamily,
+	isGPT5ModelFamily,
+	isGptOssModelFamily,
+	isNextGenModelFamily,
+	isPoolsideModelFamily,
+	modelDoesntSupportWebp,
+	shouldSkipReasoningForModel,
+} from "../model-utils"
+
+// Minimal helper — modelDoesntSupportWebp only reads apiHandlerModel.id
+const m = (id: string): ApiHandlerModel => ({ id, info: { supportsPromptCache: false } })
+
+describe("shouldSkipReasoningForModel", () => {
+	it("should return true for grok-4 models", () => {
+		shouldSkipReasoningForModel("grok-4").should.equal(true)
+		shouldSkipReasoningForModel("x-ai/grok-4").should.equal(true)
+		shouldSkipReasoningForModel("openrouter/grok-4-turbo").should.equal(true)
+		shouldSkipReasoningForModel("some-provider/grok-4-mini").should.equal(true)
+	})
+
+	it("should return false for non-grok-4 models", () => {
+		shouldSkipReasoningForModel("grok-3").should.equal(false)
+		shouldSkipReasoningForModel("grok-2").should.equal(false)
+		shouldSkipReasoningForModel("claude-3-sonnet").should.equal(false)
+		shouldSkipReasoningForModel("gpt-4").should.equal(false)
+		shouldSkipReasoningForModel("gemini-pro").should.equal(false)
+	})
+
+	it("should return false for undefined or empty model IDs", () => {
+		shouldSkipReasoningForModel(undefined).should.equal(false)
+		shouldSkipReasoningForModel("").should.equal(false)
+	})
+
+	it("should be case sensitive", () => {
+		shouldSkipReasoningForModel("GROK-4").should.equal(false)
+		shouldSkipReasoningForModel("Grok-4").should.equal(false)
+	})
+})
+
+describe("isClaude4PlusModelFamily", () => {
+	it("should return true for Claude 4+ model IDs with version numbers", () => {
+		isClaude4PlusModelFamily("claude-sonnet-4-5-20250929").should.equal(true)
+		isClaude4PlusModelFamily("claude-opus-4-1-20250805").should.equal(true)
+		isClaude4PlusModelFamily("claude-haiku-4-5-20251001").should.equal(true)
+		isClaude4PlusModelFamily("claude-4-sonnet").should.equal(true)
+	})
+
+	it("should return true for Claude Code short aliases (sonnet, opus)", () => {
+		// These are used by ClaudeCodeHandler.getModel() and should be recognized as Claude 4+
+		isClaude4PlusModelFamily("sonnet").should.equal(true)
+		isClaude4PlusModelFamily("opus").should.equal(true)
+	})
+
+	it("should return false for Claude 3.x models", () => {
+		isClaude4PlusModelFamily("claude-3-sonnet").should.equal(false)
+		isClaude4PlusModelFamily("claude-3.5-sonnet").should.equal(false)
+		isClaude4PlusModelFamily("claude-3-opus").should.equal(false)
+	})
+
+	it("should return false for non-Claude models", () => {
+		isClaude4PlusModelFamily("gpt-4").should.equal(false)
+		isClaude4PlusModelFamily("gemini-pro").should.equal(false)
+		isClaude4PlusModelFamily("llama-3").should.equal(false)
+	})
+})
+
+describe("isGPT5ModelFamily", () => {
+	it("should return true for GPT-5 model IDs with hyphen", () => {
+		isGPT5ModelFamily("gpt-5").should.equal(true)
+		isGPT5ModelFamily("gpt-5.1").should.equal(true)
+		isGPT5ModelFamily("gpt-5.2-codex").should.equal(true)
+		isGPT5ModelFamily("openai/gpt-5").should.equal(true)
+	})
+
+	it("should return true for GPT-5 model IDs without hyphen (OCA format)", () => {
+		isGPT5ModelFamily("gpt5").should.equal(true)
+		isGPT5ModelFamily("oca/gpt5").should.equal(true)
+	})
+
+	it("should be case insensitive", () => {
+		isGPT5ModelFamily("GPT-5").should.equal(true)
+		isGPT5ModelFamily("GPT5").should.equal(true)
+		isGPT5ModelFamily("OCA/GPT5").should.equal(true)
+	})
+
+	it("should return false for non-GPT-5 models", () => {
+		isGPT5ModelFamily("gpt-4").should.equal(false)
+		isGPT5ModelFamily("gpt-4o").should.equal(false)
+		isGPT5ModelFamily("gpt-oss-120b").should.equal(false)
+		isGPT5ModelFamily("claude-3-sonnet").should.equal(false)
+		isGPT5ModelFamily("gemini-pro").should.equal(false)
+	})
+})
+
+describe("isGptOssModelFamily", () => {
+	it("should return true for gpt-oss model IDs", () => {
+		isGptOssModelFamily("gpt-oss-120b").should.equal(true)
+		isGptOssModelFamily("openai/gpt-oss-120b").should.equal(true)
+		isGptOssModelFamily("gpt_oss_120b").should.equal(true)
+	})
+
+	it("should be case insensitive", () => {
+		isGptOssModelFamily("GPT-OSS-120B").should.equal(true)
+		isGptOssModelFamily("OPENAI/GPT_OSS_120B").should.equal(true)
+	})
+
+	it("should return false for non-gpt-oss models", () => {
+		isGptOssModelFamily("gpt-5").should.equal(false)
+		isGptOssModelFamily("gpt-4o").should.equal(false)
+		isGptOssModelFamily("claude-sonnet-4").should.equal(false)
+	})
+})
+
+describe("isPoolsideModelFamily", () => {
+	it("should return true for Laguna model IDs", () => {
+		isPoolsideModelFamily("poolside/laguna-m.1").should.equal(true)
+		isPoolsideModelFamily("laguna-enterprise").should.equal(true)
+		isPoolsideModelFamily("LAGUNA").should.equal(true)
+	})
+
+	it("should return false for non-Poolside model IDs", () => {
+		isPoolsideModelFamily("gpt-5").should.equal(false)
+		isPoolsideModelFamily("deepseek-chat").should.equal(false)
+		isPoolsideModelFamily("claude-sonnet-4").should.equal(false)
+	})
+
+	it("should qualify Laguna models for next-gen paths", () => {
+		isNextGenModelFamily("poolside/laguna-m.1").should.equal(true)
+	})
+})
+
+describe("isGeminiFlashModel", () => {
+	it("should return true for Gemini Flash model IDs", () => {
+		isGeminiFlashModel("google/gemini-2.5-flash").should.equal(true)
+		isGeminiFlashModel("google/gemini-3.5-flash").should.equal(true)
+		isGeminiFlashModel("google/gemini-3-flash-preview").should.equal(true)
+		isGeminiFlashModel("google/gemini-2.5-flash-lite").should.equal(true)
+	})
+
+	it("should return false for non-Flash Gemini model IDs", () => {
+		isGeminiFlashModel("google/gemini-2.5-pro").should.equal(false)
+		isGeminiFlashModel("google/gemini-3-pro-preview").should.equal(false)
+	})
+
+	it("should return true for direct Gemini provider IDs", () => {
+		isGeminiFlashModel("gemini-2.5-flash").should.equal(true)
+		isGeminiFlashModel("gemini-3.5-flash").should.equal(true)
+		isGeminiFlashModel("gemini-3-flash-preview").should.equal(true)
+	})
+
+	it("should return false for non-matching IDs", () => {
+		isGeminiFlashModel("openrouter/google/gemini-2.5-flash").should.equal(false)
+		isGeminiFlashModel("google/gemini-2.5-pro").should.equal(false)
+	})
+
+	it("should be case insensitive", () => {
+		isGeminiFlashModel("GOOGLE/GEMINI-2.5-FLASH").should.equal(true)
+	})
+})
+
+describe("GEMINI_FLASH_MAX_OUTPUT_TOKENS", () => {
+	it("should be set to 8192", () => {
+		GEMINI_FLASH_MAX_OUTPUT_TOKENS.should.equal(8_192)
+	})
+})
+
+describe("isGLMModelFamily", () => {
+	it("should match hyphen-separated GLM model IDs", () => {
+		isGLMModelFamily("glm-4.6").should.equal(true)
+		isGLMModelFamily("glm-4.5").should.equal(true)
+		isGLMModelFamily("glm-4.7").should.equal(true)
+		isGLMModelFamily("glm-5.1").should.equal(true)
+		isGLMModelFamily("glm-5").should.equal(true)
+		isGLMModelFamily("z-ai/glm-5.1").should.equal(true)
+		isGLMModelFamily("z-ai/glm-4.6").should.equal(true)
+		isGLMModelFamily("zai-org/glm-4.5").should.equal(true)
+	})
+
+	it("should match space-separated GLM model IDs used with openai-compatible local servers", () => {
+		// "GLM 4.6V" is the model ID reported in issue #8203
+		isGLMModelFamily("GLM 4.6V").should.equal(true)
+		isGLMModelFamily("glm 4.6v").should.equal(true)
+		isGLMModelFamily("GLM 4.5").should.equal(true)
+	})
+
+	it("should return false for non-GLM models", () => {
+		isGLMModelFamily("gpt-4").should.equal(false)
+		isGLMModelFamily("claude-sonnet-4").should.equal(false)
+		isGLMModelFamily("gemini-2.5-flash").should.equal(false)
+	})
+})
+
+describe("modelDoesntSupportWebp", () => {
+	it("should return true for Grok models", () => {
+		modelDoesntSupportWebp(m("grok-3")).should.equal(true)
+		modelDoesntSupportWebp(m("x-ai/grok-3-mini")).should.equal(true)
+	})
+
+	it("should return true for GLM models (hyphen-separated)", () => {
+		modelDoesntSupportWebp(m("glm-4.6")).should.equal(true)
+		modelDoesntSupportWebp(m("glm-4.5")).should.equal(true)
+		modelDoesntSupportWebp(m("glm-5.1")).should.equal(true)
+		modelDoesntSupportWebp(m("z-ai/glm-4.6")).should.equal(true)
+	})
+
+	it("should return true for GLM models with space-separated IDs (issue #8203)", () => {
+		modelDoesntSupportWebp(m("GLM 4.6V")).should.equal(true)
+		modelDoesntSupportWebp(m("glm 4.5")).should.equal(true)
+	})
+
+	it("should return true for Devstral models running through llama.cpp", () => {
+		modelDoesntSupportWebp(m("devstral-small")).should.equal(true)
+		modelDoesntSupportWebp(m("unsloth/devstral-small-2512")).should.equal(true)
+		modelDoesntSupportWebp(m("Devstral-Small-2-24B-Instruct")).should.equal(true)
+	})
+
+	it("should return false for models that support WebP", () => {
+		modelDoesntSupportWebp(m("claude-sonnet-4")).should.equal(false)
+		modelDoesntSupportWebp(m("gpt-5")).should.equal(false)
+		modelDoesntSupportWebp(m("gemini-2.5-flash")).should.equal(false)
+		modelDoesntSupportWebp(m("qwen2.5-vl-72b")).should.equal(false)
+		modelDoesntSupportWebp(m("llama-3.1-8b")).should.equal(false)
+	})
+})
diff --git a/apps/vscode/src/utils/announcements.ts b/apps/vscode/src/utils/announcements.ts
new file mode 100644
index 0000000..2f93248
--- /dev/null
+++ b/apps/vscode/src/utils/announcements.ts
@@ -0,0 +1,13 @@
+import { ExtensionRegistryInfo } from "@/registry"
+
+/**
+ * Gets the latest announcement ID based on the extension version
+ * Uses major.minor version format (e.g., "1.2" from "1.2.3")
+ *
+ * @param context The VSCode extension context
+ * @returns The announcement ID string (major.minor version) or empty string if unavailable
+ */
+export function getLatestAnnouncementId(): string {
+	const version = ExtensionRegistryInfo.version
+	return version.split(".").slice(0, 2).join(".")
+}
diff --git a/apps/vscode/src/utils/cli-detector.ts b/apps/vscode/src/utils/cli-detector.ts
new file mode 100644
index 0000000..28af1e6
--- /dev/null
+++ b/apps/vscode/src/utils/cli-detector.ts
@@ -0,0 +1,26 @@
+import { exec } from "child_process"
+import { promisify } from "util"
+
+const execAsync = promisify(exec)
+
+/**
+ * Check if the Cline CLI tool is installed on the system
+ * @returns true if CLI is installed, false otherwise
+ */
+export async function isClineCliInstalled(): Promise<boolean> {
+	try {
+		// Try to get the version of the cline CLI tool
+		// This will fail if the tool is not installed
+		const { stdout } = await execAsync("cline version", {
+			timeout: 5000, // 5 second timeout
+		})
+
+		// If we get here, the CLI is installed
+		// We could also validate the version if needed
+		return stdout.includes("Cline CLI Version") || stdout.includes("Cline Core Version")
+	} catch (error) {
+		// Command failed, which likely means CLI is not installed
+		// or not in PATH
+		return false
+	}
+}
diff --git a/apps/vscode/src/utils/env.ts b/apps/vscode/src/utils/env.ts
new file mode 100644
index 0000000..b999e33
--- /dev/null
+++ b/apps/vscode/src/utils/env.ts
@@ -0,0 +1,116 @@
+import { EmptyRequest, StringRequest } from "@shared/proto/cline/common"
+import { ShowMessageType } from "@shared/proto/host/window"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Writes text to the system clipboard
+ * @param text The text to write to the clipboard
+ * @returns Promise that resolves when the operation is complete
+ * @throws Error if the operation fails
+ */
+export async function writeTextToClipboard(text: string): Promise<void> {
+	try {
+		await HostProvider.env.clipboardWriteText(StringRequest.create({ value: text }))
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		throw new Error(`Failed to write to clipboard: ${errorMessage}`)
+	}
+}
+
+/**
+ * Reads text from the system clipboard
+ * @returns Promise that resolves to the clipboard text
+ * @throws Error if the operation fails
+ */
+export async function readTextFromClipboard(): Promise<string> {
+	try {
+		const response = await HostProvider.env.clipboardReadText(EmptyRequest.create({}))
+		return response.value
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		throw new Error(`Failed to read from clipboard: ${errorMessage}`)
+	}
+}
+
+/**
+ * Opens an external URL in the default browser.
+ * Uses the host bridge RPC first (VS Code's openExternal which handles remote environments).
+ * Falls back to the `open` npm package if the host doesn't implement the RPC (e.g., JetBrains).
+ *
+ * When CLINE_CAPTURE_BROWSER is set (debug harness mode), the URL is captured
+ * to a file and/or posted to the debug harness instead of opening a real browser.
+ * This enables automated OAuth flow testing.
+ *
+ * @param url The URL to open
+ * @returns Promise that resolves when the operation is complete
+ */
+export async function openExternal(url: string): Promise<void> {
+	// Debug harness mode: capture URL instead of opening browser
+	if (process.env.CLINE_CAPTURE_BROWSER === "1" || process.env.CLINE_CAPTURE_BROWSER === "true") {
+		await captureBrowserUrl(url)
+		return
+	}
+
+	Logger.log("Opening browser:", url)
+	try {
+		await HostProvider.env.openExternal(StringRequest.create({ value: url }))
+	} catch (error) {
+		// Fallback for hosts that don't implement openExternal (e.g., JetBrains plugin)
+		Logger.warn(`Host openExternal RPC failed, falling back to 'open' package: ${error}`)
+		try {
+			const open = (await import("open")).default
+			await open(url)
+		} catch (fallbackError) {
+			Logger.error(`Fallback 'open' also failed: ${fallbackError}`)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Failed to open URL: ${url}`,
+			})
+		}
+	}
+}
+
+/**
+ * Captures a browser URL for the debug harness instead of opening it.
+ * Writes the URL to a JSONL file and optionally POSTs it to the debug harness server.
+ */
+async function captureBrowserUrl(url: string): Promise<void> {
+	const entry = { timestamp: Date.now(), url }
+	Logger.log(`[CaptureBrowser] Captured URL: ${url}`)
+
+	// Write to JSONL file in CLINE_DIR/data/
+	try {
+		const fs = await import("node:fs")
+		const path = await import("node:path")
+		const os = await import("node:os")
+		const clineDir = process.env.CLINE_DIR || path.join(os.homedir(), ".cline")
+		const dataDir = path.join(clineDir, "data")
+		fs.mkdirSync(dataDir, { recursive: true })
+		const captureFile = path.join(dataDir, "debug-captured-urls.jsonl")
+		fs.appendFileSync(captureFile, JSON.stringify(entry) + "\n")
+	} catch (e) {
+		Logger.error(`[CaptureBrowser] Failed to write captured URL to file:`, e)
+	}
+
+	// POST to debug harness server if configured
+	const harnessPort = process.env.CLINE_DEBUG_HARNESS_PORT
+	if (harnessPort) {
+		try {
+			const http = await import("node:http")
+			const body = JSON.stringify(entry)
+			const req = http.request({
+				hostname: "127.0.0.1",
+				port: Number(harnessPort),
+				path: "/captured-url",
+				method: "POST",
+				headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+			})
+			req.on("error", () => {}) // Fire-and-forget, don't block
+			req.write(body)
+			req.end()
+		} catch (e) {
+			Logger.error(`[CaptureBrowser] Failed to POST captured URL to harness:`, e)
+		}
+	}
+}
diff --git a/apps/vscode/src/utils/envExpansion.ts b/apps/vscode/src/utils/envExpansion.ts
new file mode 100644
index 0000000..ef8a5f7
--- /dev/null
+++ b/apps/vscode/src/utils/envExpansion.ts
@@ -0,0 +1,74 @@
+/**
+ * Utility for expanding environment variables in configuration values.
+ * Supports ${env:VAR_NAME} syntax for referencing environment variables.
+ */
+
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Expands environment variables in a string value.
+ * Supports ${env:VAR_NAME} syntax.
+ *
+ * @param value - String that may contain variable references
+ * @returns String with environment variables expanded
+ *
+ * @example
+ * // If process.env.API_KEY = "secret123"
+ * expandString("Bearer ${env:API_KEY}") // Returns: "Bearer secret123"
+ * expandString("${env:MISSING}") // Returns: "${env:MISSING}" (unchanged)
+ */
+function expandString(value: string): string {
+	return value.replace(/\$\{env:([^}]+)\}/g, (match, varName) => {
+		// Trim whitespace from variable name to be forgiving of formatting
+		const trimmedVarName = varName.trim()
+		const envValue = process.env[trimmedVarName]
+
+		if (envValue === undefined) {
+			Logger.warn(`[MCP Config] Environment variable not found: ${trimmedVarName}`)
+			return match // Leave unexpanded to show what's missing
+		}
+
+		// Empty string is a valid value, return it
+		return envValue
+	})
+}
+
+/**
+ * Recursively expands environment variables in any value (string, object, array).
+ * Only processes string values, leaving other types unchanged.
+ *
+ * @param value - Value to process (can be string, object, array, or primitive)
+ * @returns Value with all environment variables expanded
+ *
+ * @example
+ * expandEnvironmentVariables({
+ *   api_key: "${env:API_KEY}",
+ *   nested: {
+ *     token: "${env:TOKEN}"
+ *   }
+ * })
+ * // Returns object with all ${env:*} references expanded
+ */
+export function expandEnvironmentVariables<T>(value: T): T {
+	// Handle string values
+	if (typeof value === "string") {
+		return expandString(value) as T
+	}
+
+	// Handle arrays
+	if (Array.isArray(value)) {
+		return value.map((item) => expandEnvironmentVariables(item)) as T
+	}
+
+	// Handle objects (but not null)
+	if (value && typeof value === "object") {
+		const result: any = {}
+		for (const [key, val] of Object.entries(value)) {
+			result[key] = expandEnvironmentVariables(val)
+		}
+		return result
+	}
+
+	// Return primitives unchanged (numbers, booleans, null, undefined)
+	return value
+}
diff --git a/apps/vscode/src/utils/fs-info.test.ts b/apps/vscode/src/utils/fs-info.test.ts
new file mode 100644
index 0000000..115cd44
--- /dev/null
+++ b/apps/vscode/src/utils/fs-info.test.ts
@@ -0,0 +1,66 @@
+import { beforeEach, describe, it } from "mocha"
+import * as os from "node:os"
+import "should"
+import { _getFsInfoCacheSizeForTests, _resetFsInfoCacheForTests, getFsInfo } from "./fs-info"
+
+describe("getFsInfo", () => {
+	beforeEach(() => {
+		_resetFsInfoCacheForTests()
+	})
+
+	it("returns the unknown sentinel for an undefined path", async () => {
+		const info = await getFsInfo(undefined)
+		info.fsClass.should.equal("unknown")
+		info.fsType.should.equal("unknown")
+	})
+
+	it("returns the unknown sentinel for an empty path", async () => {
+		const info = await getFsInfo("")
+		info.fsClass.should.equal("unknown")
+		info.fsType.should.equal("unknown")
+	})
+
+	it("never throws on a non-existent path", async () => {
+		// The picker must never break because of telemetry. Result classification
+		// itself is unspecified — on macOS we'd resolve up the mount tree to the
+		// nearest existing parent (often the root, "apfs"); on Linux behaviour
+		// depends on `stat -f`. What matters is that we get a defined FsInfo
+		// object back, never an exception.
+		const info = await getFsInfo("/this/path/should/not/exist/__nope__")
+		;(["local", "network", "unknown"] as const).should.containEql(info.fsClass)
+	})
+
+	// macOS/Linux only — Windows currently returns the unknown sentinel
+	// unconditionally (see fs-info.ts: detection is unimplemented there).
+	const detectPlatforms: NodeJS.Platform[] = ["darwin", "linux"]
+	if (detectPlatforms.includes(process.platform)) {
+		it("classifies the OS temp directory as a local filesystem", async () => {
+			const info = await getFsInfo(os.tmpdir())
+			// We don't assert on the exact fsType because it varies (apfs on
+			// macOS, tmpfs/ext4 on Linux containers, etc.) — what we care
+			// about is that it lands in the "local" bucket, not "network".
+			info.fsClass.should.equal("local")
+			info.fsType.should.not.equal("unknown")
+		})
+
+		it("caches results per path", async () => {
+			const path = os.tmpdir()
+			const a = await getFsInfo(path)
+			const b = await getFsInfo(path)
+			// Same reference proves the Map cache is being hit, not just
+			// equal-by-value.
+			a.should.equal(b)
+		})
+
+		it("caches successful results exactly once and skips the UNKNOWN sentinel", async () => {
+			// undefined/empty short-circuit and do not touch the cache.
+			await getFsInfo(undefined)
+			await getFsInfo("")
+			_getFsInfoCacheSizeForTests().should.equal(0)
+
+			// A real path goes through detect() and stores one entry.
+			await getFsInfo(os.tmpdir())
+			_getFsInfoCacheSizeForTests().should.equal(1)
+		})
+	}
+})
diff --git a/apps/vscode/src/utils/fs-info.ts b/apps/vscode/src/utils/fs-info.ts
new file mode 100644
index 0000000..24c1bf8
--- /dev/null
+++ b/apps/vscode/src/utils/fs-info.ts
@@ -0,0 +1,214 @@
+import { execFile } from "node:child_process"
+import { realpath } from "node:fs/promises"
+import { promisify } from "node:util"
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Coarse bucket for dashboards. The picker walks the whole tree on every
+ * keystroke; "network" mounts have very different latency characteristics
+ * from "local" ones and we want to filter slow events by this.
+ */
+type FsClass = "local" | "network" | "unknown"
+
+export interface FsInfo {
+	fsClass: FsClass
+	/** Lowercase, whitespace-stripped FS type as reported by the OS, or "unknown". */
+	fsType: string
+}
+
+const UNKNOWN: FsInfo = { fsClass: "unknown", fsType: "unknown" }
+
+// Best-effort classification. Anything we don't recognise lands in "unknown"
+// rather than being misreported as "local".
+//
+// On macOS, SSHFS / FUSE-T / NTFS-3G / gocryptfs / rclone all surface as
+// "macfuse" (or "fuse" on older macOS) in `mount` output — macFUSE doesn't
+// expose the underlying driver. We bucket all of them as "network" since
+// they share the not-actually-local performance profile that motivated this
+// work.
+const NETWORK_FS_TYPES = new Set([
+	"nfs",
+	"nfs3",
+	"nfs4",
+	"cifs",
+	"smb",
+	"smbfs",
+	"smb2",
+	"afpfs",
+	"webdav",
+	"davfs",
+	"sshfs",
+	"9p",
+	"9p2000",
+	"fuse",
+	"fuseblk",
+	"macfuse",
+	"virtiofs",
+])
+
+const LOCAL_FS_TYPES = new Set([
+	"apfs",
+	"hfs",
+	"hfsplus",
+	"ext2",
+	"ext3",
+	"ext4",
+	"ext2/ext3",
+	"btrfs",
+	"xfs",
+	"f2fs",
+	"zfs",
+	"reiserfs",
+	"jfs",
+	"ntfs",
+	"ntfs3",
+	"vfat",
+	"fat",
+	"fat32",
+	"exfat",
+	"msdos",
+	"tmpfs",
+	"ramfs",
+	"overlay",
+	"overlayfs",
+	"iso9660",
+	"udf",
+])
+
+const cache = new Map<string, FsInfo>()
+
+// Whole-operation budget covering realpath + mount/stat. The exec child has
+// its own 2s, but realpath has none — a stale network mount can hang it
+// indefinitely. Race the whole detection against this so callers (telemetry)
+// never block forever.
+const DETECT_TIMEOUT_MS = 3000
+
+/**
+ * Returns coarse + specific filesystem info for `path`. Successful results
+ * are cached for the process lifetime; failures (timeout, error, unsupported
+ * platform) return the shared {@link UNKNOWN} sentinel and are not cached.
+ * The caller never has to handle exceptions.
+ */
+export async function getFsInfo(path: string | undefined | null): Promise<FsInfo> {
+	if (!path) {
+		return UNKNOWN
+	}
+	const cached = cache.get(path)
+	if (cached) {
+		return cached
+	}
+	const info = await detectWithTimeout(path)
+	// Skip caching the shared UNKNOWN sentinel so transient failures
+	// (timeout, hung mount) don't permanently misclassify the path.
+	// Successful detect() with an unrecognised fsType returns a fresh
+	// object and is cached normally.
+	if (info !== UNKNOWN) {
+		cache.set(path, info)
+	}
+	return info
+}
+
+async function detectWithTimeout(path: string): Promise<FsInfo> {
+	let timer: NodeJS.Timeout | undefined
+	const timeout = new Promise<FsInfo>((resolve) => {
+		timer = setTimeout(() => resolve(UNKNOWN), DETECT_TIMEOUT_MS)
+	})
+	try {
+		return await Promise.race([detect(path), timeout])
+	} finally {
+		if (timer) {
+			clearTimeout(timer)
+		}
+	}
+}
+
+async function detect(path: string): Promise<FsInfo> {
+	try {
+		// Resolve symlinks so we match mountpoints correctly. On macOS `/tmp`
+		// is a symlink to `/private/tmp`, and /tmp itself isn't a mount point.
+		let resolved = path
+		try {
+			resolved = await realpath(path)
+		} catch {
+			// Path may not exist; fall back to the original string.
+		}
+		if (process.platform === "darwin") {
+			return await detectMacOS(resolved)
+		}
+		if (process.platform === "linux") {
+			// GNU stat: `-f` selects filesystem mode, `-c %T` prints the FS type
+			// as a string ("ext2/ext3", "btrfs", "nfs", "fuseblk", ...).
+			const { stdout } = await execFileAsync("stat", ["-f", "-c", "%T", "--", resolved], {
+				timeout: 2000,
+			})
+			return classify(stdout)
+		}
+		// Windows detection is more involved (GetVolumeInformationW + GetDriveType
+		// or WMI) and we don't have a confirmed slow-FS report there yet. Land
+		// macOS/Linux first; revisit if signal warrants.
+		return UNKNOWN
+	} catch {
+		return UNKNOWN
+	}
+}
+
+/**
+ * macOS detection by parsing `mount(8)` output and picking the longest
+ * matching mount point. BSD `stat` has no portable filesystem-type flag —
+ * `stat -f` is a format-string mode where `%T` means "file type"
+ * (regular/directory/etc.), not "filesystem type". Parsing `mount` is the
+ * pragmatic alternative.
+ *
+ * Lines look like:
+ *   /dev/disk3s1s1 on / (apfs, sealed, local, read-only, journaled)
+ *   user@host:/repo on /Volumes/repo (macfuse, nodev, nosuid, ...)
+ */
+async function detectMacOS(resolvedPath: string): Promise<FsInfo> {
+	const { stdout } = await execFileAsync("mount", [], { timeout: 2000 })
+	let bestMountpoint = ""
+	let bestFsType = ""
+	for (const line of stdout.split("\n")) {
+		const m = line.match(/^\S+\s+on\s+(.+?)\s+\(([^,)]+)/)
+		if (!m) {
+			continue
+		}
+		const [, mountpoint, fsType] = m
+		const prefix = mountpoint.endsWith("/") ? mountpoint : mountpoint + "/"
+		if (resolvedPath === mountpoint || resolvedPath.startsWith(prefix)) {
+			if (mountpoint.length > bestMountpoint.length) {
+				bestMountpoint = mountpoint
+				bestFsType = fsType
+			}
+		}
+	}
+	return bestFsType ? classify(bestFsType) : UNKNOWN
+}
+
+function classify(rawFsType: string): FsInfo {
+	const normalized = normalize(rawFsType)
+	if (!normalized) {
+		return UNKNOWN
+	}
+	if (NETWORK_FS_TYPES.has(normalized)) {
+		return { fsClass: "network", fsType: normalized }
+	}
+	if (LOCAL_FS_TYPES.has(normalized)) {
+		return { fsClass: "local", fsType: normalized }
+	}
+	return { fsClass: "unknown", fsType: normalized }
+}
+
+function normalize(raw: string): string {
+	return raw.trim().replace(/\s+/g, "").toLowerCase()
+}
+
+/** Test-only. Resets the per-process cache. */
+export function _resetFsInfoCacheForTests(): void {
+	cache.clear()
+}
+
+/** Test-only. Returns the current cache entry count. */
+export function _getFsInfoCacheSizeForTests(): number {
+	return cache.size
+}
diff --git a/apps/vscode/src/utils/fs.test.ts b/apps/vscode/src/utils/fs.test.ts
new file mode 100644
index 0000000..ec85de6
--- /dev/null
+++ b/apps/vscode/src/utils/fs.test.ts
@@ -0,0 +1,316 @@
+import { after, describe, it } from "mocha"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import "should"
+import { createDirectoriesForFile, fileExistsAtPath, isDirectory, readDirectory } from "./fs"
+
+describe("Filesystem Utilities", () => {
+	const tmpDir = path.join(os.tmpdir(), "cline-test-" + Math.random().toString(36).slice(2))
+
+	// Clean up after tests
+	after(async () => {
+		try {
+			await fs.rm(tmpDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	describe("fileExistsAtPath", () => {
+		it("should return true for existing paths", async () => {
+			await fs.mkdir(tmpDir, { recursive: true })
+			const testFile = path.join(tmpDir, "test.txt")
+			await fs.writeFile(testFile, "test")
+
+			const exists = await fileExistsAtPath(testFile)
+			exists.should.be.true()
+		})
+
+		it("should return false for non-existing paths", async () => {
+			const nonExistentPath = path.join(tmpDir, "does-not-exist.txt")
+			const exists = await fileExistsAtPath(nonExistentPath)
+			exists.should.be.false()
+		})
+	})
+
+	describe("createDirectoriesForFile", () => {
+		it("should create all necessary directories", async () => {
+			const deepPath = path.join(tmpDir, "deep", "nested", "dir", "file.txt")
+			const createdDirs = await createDirectoriesForFile(deepPath)
+
+			// Verify directories were created
+			createdDirs.length.should.be.greaterThan(0)
+			for (const dir of createdDirs) {
+				const exists = await fileExistsAtPath(dir)
+				exists.should.be.true()
+			}
+		})
+
+		it("should handle existing directories", async () => {
+			const existingDir = path.join(tmpDir, "existing")
+			await fs.mkdir(existingDir, { recursive: true })
+
+			const filePath = path.join(existingDir, "file.txt")
+			const createdDirs = await createDirectoriesForFile(filePath)
+
+			// Should not create any new directories
+			createdDirs.length.should.equal(0)
+		})
+
+		it("should normalize paths", async () => {
+			const unnormalizedPath = path.join(tmpDir, "a", "..", "b", ".", "file.txt")
+			const createdDirs = await createDirectoriesForFile(unnormalizedPath)
+
+			// Should create only the necessary directory
+			createdDirs.length.should.equal(1)
+			const exists = await fileExistsAtPath(path.join(tmpDir, "b"))
+			exists.should.be.true()
+		})
+	})
+	describe("isDirectory", () => {
+		it("should return true for directories", async () => {
+			await fs.mkdir(tmpDir, { recursive: true })
+			const isDir = await isDirectory(tmpDir)
+			isDir.should.be.true()
+		})
+
+		it("should return false for files", async () => {
+			const testFile = path.join(tmpDir, "test.txt")
+			await fs.writeFile(testFile, "test")
+			const isDir = await isDirectory(testFile)
+			isDir.should.be.false()
+		})
+
+		it("should return false for non-existent paths", async () => {
+			const nonExistentPath = path.join(tmpDir, "does-not-exist")
+			const isDir = await isDirectory(nonExistentPath)
+			isDir.should.be.false()
+		})
+	})
+
+	describe("readDirectory", () => {
+		it("should list files in a directory", async () => {
+			// Create test directory with files
+			const testDir = path.join(tmpDir, "read-test")
+			await fs.mkdir(testDir, { recursive: true })
+			await fs.writeFile(path.join(testDir, "file1.txt"), "content")
+			await fs.writeFile(path.join(testDir, "file2.txt"), "content")
+
+			// Get files
+			const files = await readDirectory(testDir)
+			files.length.should.equal(2)
+			files.should.containDeep([path.resolve(testDir, "file1.txt"), path.resolve(testDir, "file2.txt")])
+		})
+
+		it("should exclude specified directories", async () => {
+			// Create test directory with files and an excluded directory
+			const testDir = path.join(tmpDir, "exclude-test")
+			const excludeDir = path.join(testDir, "exclude-me")
+			await fs.mkdir(excludeDir, { recursive: true })
+			await fs.writeFile(path.join(testDir, "include.txt"), "content")
+			await fs.writeFile(path.join(excludeDir, "excluded.txt"), "content")
+
+			// Get files, excluding the "exclude-me" directory
+			const files = await readDirectory(testDir, [["exclude-me"]])
+			files.length.should.equal(1)
+			files.should.containDeep([path.resolve(testDir, "include.txt")])
+			files.should.not.containDeep([path.resolve(excludeDir, "excluded.txt")])
+		})
+	})
+
+	it("should correctly handle complex nested directory structures", async () => {
+		// Create a complex directory structure
+		const complexDir = path.join(tmpDir, "complex-test")
+
+		// Create main dir
+		await fs.mkdir(complexDir, { recursive: true })
+		await fs.writeFile(path.join(complexDir, "root.txt"), "content")
+
+		// Create first branch
+		await fs.mkdir(path.join(complexDir, "dir1"), { recursive: true })
+		await fs.writeFile(path.join(complexDir, "dir1", "file1.txt"), "content")
+
+		// Create second branch with nested structure
+		await fs.mkdir(path.join(complexDir, "dir2", "subdir1"), { recursive: true })
+		await fs.writeFile(path.join(complexDir, "dir2", "file2.txt"), "content")
+		await fs.writeFile(path.join(complexDir, "dir2", "subdir1", "file3.txt"), "content")
+
+		// Create third branch with deep nesting
+		await fs.mkdir(path.join(complexDir, "dir3", "subdir2", "deepdir"), { recursive: true })
+		await fs.writeFile(path.join(complexDir, "dir3", "file4.txt"), "content")
+		await fs.writeFile(path.join(complexDir, "dir3", "subdir2", "file5.txt"), "content")
+		await fs.writeFile(path.join(complexDir, "dir3", "subdir2", "deepdir", "file6.txt"), "content")
+
+		// Get all files
+		const files = await readDirectory(complexDir)
+
+		const expectedFiles = [
+			path.resolve(complexDir, "root.txt"),
+			path.resolve(complexDir, "dir1", "file1.txt"),
+			path.resolve(complexDir, "dir2", "file2.txt"),
+			path.resolve(complexDir, "dir2", "subdir1", "file3.txt"),
+			path.resolve(complexDir, "dir3", "file4.txt"),
+			path.resolve(complexDir, "dir3", "subdir2", "file5.txt"),
+			path.resolve(complexDir, "dir3", "subdir2", "deepdir", "file6.txt"),
+		]
+
+		files.length.should.equal(expectedFiles.length)
+
+		files.sort().should.deepEqual(expectedFiles.sort())
+	})
+
+	it("should correctly exclude multiple directories in complex structures", async () => {
+		// Use the same complex directory structure
+		const complexDir = path.join(tmpDir, "complex-exclude-test")
+
+		// Create main dir
+		await fs.mkdir(complexDir, { recursive: true })
+		await fs.writeFile(path.join(complexDir, "root.txt"), "content")
+
+		// Create first branch
+		await fs.mkdir(path.join(complexDir, "dir1"), { recursive: true })
+		await fs.writeFile(path.join(complexDir, "dir1", "file1.txt"), "content")
+
+		// Create second branch with nested structure
+		await fs.mkdir(path.join(complexDir, "dir2", "subdir1"), { recursive: true })
+		await fs.writeFile(path.join(complexDir, "dir2", "file2.txt"), "content")
+		await fs.writeFile(path.join(complexDir, "dir2", "subdir1", "file3.txt"), "content")
+
+		// Create third branch with deep nesting
+		await fs.mkdir(path.join(complexDir, "dir3", "subdir2", "deepdir"), { recursive: true })
+		await fs.writeFile(path.join(complexDir, "dir3", "file4.txt"), "content")
+		await fs.writeFile(path.join(complexDir, "dir3", "subdir2", "file5.txt"), "content")
+		await fs.writeFile(path.join(complexDir, "dir3", "subdir2", "deepdir", "file6.txt"), "content")
+
+		// Get files excluding multiple directories
+		const files = await readDirectory(complexDir, [["dir1"], ["subdir2"]])
+
+		const expectedFiles = [
+			path.resolve(complexDir, "root.txt"),
+			path.resolve(complexDir, "dir2", "file2.txt"),
+			path.resolve(complexDir, "dir2", "subdir1", "file3.txt"),
+			path.resolve(complexDir, "dir3", "file4.txt"),
+		]
+
+		files.length.should.equal(expectedFiles.length)
+
+		files.sort().should.deepEqual(expectedFiles.sort())
+	})
+
+	it("should exclude .clinerules/workflows directory specifically", async () => {
+		// Create a test directory structure
+		const clinerulesDirTest = path.join(tmpDir, "clinerules-test")
+		const clinerulesDirPath = path.join(clinerulesDirTest, ".clinerules")
+
+		// Create .clinerules directory and root files
+		await fs.mkdir(clinerulesDirPath, { recursive: true })
+		await fs.writeFile(path.join(clinerulesDirPath, "config.json"), "{}")
+		await fs.writeFile(path.join(clinerulesDirPath, "settings.js"), "// settings")
+
+		// Create .clinerules/other directory and files
+		const otherDirPath = path.join(clinerulesDirPath, "other")
+		await fs.mkdir(otherDirPath, { recursive: true })
+		await fs.writeFile(path.join(otherDirPath, "helper.js"), "// helper code")
+		await fs.writeFile(path.join(otherDirPath, "util.js"), "// util functions")
+
+		// Create .clinerules/workflows directory and files
+		const workflowsDirPath = path.join(clinerulesDirPath, "workflows")
+		await fs.mkdir(workflowsDirPath, { recursive: true })
+		await fs.writeFile(path.join(workflowsDirPath, "workflow1.js"), "// workflow1")
+		await fs.writeFile(path.join(workflowsDirPath, "workflow2.js"), "// workflow2")
+
+		// Get all files WITHOUT exclusion
+		const allFiles = await readDirectory(clinerulesDirPath)
+
+		// Verify all files are included
+		allFiles.length.should.equal(6) // 2 in root + 2 in other + 2 in workflows
+		allFiles.some((file) => file.includes("workflow1.js")).should.be.true()
+		allFiles.some((file) => file.includes("workflow2.js")).should.be.true()
+
+		// Get files WITH workflows directory excluded
+		const filteredFiles = await readDirectory(clinerulesDirPath, [[".clinerules", "workflows"]])
+
+		// Verify workflows files are excluded but others remain
+		filteredFiles.length.should.equal(4) // 2 in root + 2 in other
+
+		const expectedFiles = [
+			path.resolve(clinerulesDirPath, "config.json"),
+			path.resolve(clinerulesDirPath, "settings.js"),
+			path.resolve(otherDirPath, "helper.js"),
+			path.resolve(otherDirPath, "util.js"),
+		]
+
+		filteredFiles.sort().should.deepEqual(expectedFiles.sort())
+
+		// Test with multiple exclusions
+		const multiExcludeFiles = await readDirectory(clinerulesDirPath, [
+			[".clinerules", "workflows"],
+			[".clinerules", "other"],
+		])
+
+		// Verify both workflows and other directories are excluded
+		multiExcludeFiles.length.should.equal(2) // only the 2 files in root
+
+		const rootOnlyFiles = [path.resolve(clinerulesDirPath, "config.json"), path.resolve(clinerulesDirPath, "settings.js")]
+
+		multiExcludeFiles.sort().should.deepEqual(rootOnlyFiles.sort())
+	})
+
+	it("should exclude .clinerules/hooks directory specifically", async () => {
+		// Create a test directory structure
+		const clinerulesDirTest = path.join(tmpDir, "clinerules-hooks-test")
+		const clinerulesDirPath = path.join(clinerulesDirTest, ".clinerules")
+
+		// Create .clinerules directory and root files
+		await fs.mkdir(clinerulesDirPath, { recursive: true })
+		await fs.writeFile(path.join(clinerulesDirPath, "config.json"), "{}")
+		await fs.writeFile(path.join(clinerulesDirPath, "settings.js"), "// settings")
+
+		// Create .clinerules/workflows directory and files
+		const workflowsDirPath = path.join(clinerulesDirPath, "workflows")
+		await fs.mkdir(workflowsDirPath, { recursive: true })
+		await fs.writeFile(path.join(workflowsDirPath, "workflow1.js"), "// workflow1")
+
+		// Create .clinerules/hooks directory and files
+		const hooksDirPath = path.join(clinerulesDirPath, "hooks")
+		await fs.mkdir(hooksDirPath, { recursive: true })
+		await fs.writeFile(path.join(hooksDirPath, "PreToolUse"), "#!/usr/bin/env bash")
+		await fs.writeFile(path.join(hooksDirPath, "PostToolUse"), "#!/usr/bin/env bash")
+
+		// Get all files WITHOUT exclusion
+		const allFiles = await readDirectory(clinerulesDirPath)
+
+		// Verify all files are included
+		allFiles.length.should.equal(5) // 2 in root + 1 in workflows + 2 in hooks
+		allFiles.some((file) => file.includes("PreToolUse")).should.be.true()
+		allFiles.some((file) => file.includes("PostToolUse")).should.be.true()
+
+		// Get files WITH hooks directory excluded
+		const filteredFiles = await readDirectory(clinerulesDirPath, [[".clinerules", "hooks"]])
+
+		// Verify hooks files are excluded but others remain
+		filteredFiles.length.should.equal(3) // 2 in root + 1 in workflows
+
+		const expectedFiles = [
+			path.resolve(clinerulesDirPath, "config.json"),
+			path.resolve(clinerulesDirPath, "settings.js"),
+			path.resolve(workflowsDirPath, "workflow1.js"),
+		]
+
+		filteredFiles.sort().should.deepEqual(expectedFiles.sort())
+
+		// Test with multiple exclusions (both workflows and hooks)
+		const multiExcludeFiles = await readDirectory(clinerulesDirPath, [
+			[".clinerules", "workflows"],
+			[".clinerules", "hooks"],
+		])
+
+		// Verify both workflows and hooks directories are excluded
+		multiExcludeFiles.length.should.equal(2) // only the 2 files in root
+
+		const rootOnlyFiles = [path.resolve(clinerulesDirPath, "config.json"), path.resolve(clinerulesDirPath, "settings.js")]
+
+		multiExcludeFiles.sort().should.deepEqual(rootOnlyFiles.sort())
+	})
+})
diff --git a/apps/vscode/src/utils/fs.ts b/apps/vscode/src/utils/fs.ts
new file mode 100644
index 0000000..d9d3a76
--- /dev/null
+++ b/apps/vscode/src/utils/fs.ts
@@ -0,0 +1,148 @@
+import { workspaceResolver } from "@core/workspace"
+import fs from "fs/promises"
+import * as path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+
+const IS_WINDOWS = /^win/.test(process.platform)
+
+/**
+ * Asynchronously creates all non-existing subdirectories for a given file path
+ * and collects them in an array for later deletion.
+ *
+ * @param filePath - The full path to a file.
+ * @returns A promise that resolves to an array of newly created directories.
+ */
+export async function createDirectoriesForFile(filePath: string): Promise<string[]> {
+	const newDirectories: string[] = []
+	const normalizedFilePath = path.normalize(filePath) // Normalize path for cross-platform compatibility
+	const directoryPath = path.dirname(normalizedFilePath)
+
+	let currentPath = directoryPath
+	const dirsToCreate: string[] = []
+
+	// Traverse up the directory tree and collect missing directories
+	while (!(await fileExistsAtPath(currentPath))) {
+		dirsToCreate.push(currentPath)
+		currentPath = path.dirname(currentPath)
+	}
+
+	// Create directories from the topmost missing one down to the target directory
+	for (let i = dirsToCreate.length - 1; i >= 0; i--) {
+		await fs.mkdir(dirsToCreate[i])
+		newDirectories.push(dirsToCreate[i])
+	}
+
+	return newDirectories
+}
+
+/**
+ * Helper function to check if a path exists.
+ *
+ * @param path - The path to check.
+ * @returns A promise that resolves to true if the path exists, false otherwise.
+ */
+export async function fileExistsAtPath(filePath: string): Promise<boolean> {
+	try {
+		await fs.access(filePath)
+		return true
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Checks if the path is a directory
+ * @param filePath - The path to check.
+ * @returns A promise that resolves to true if the path is a directory, false otherwise.
+ */
+export async function isDirectory(filePath: string): Promise<boolean> {
+	try {
+		const stats = await fs.stat(filePath)
+		return stats.isDirectory()
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Writes content to a file
+ * @param filePath - Absolute path to the file
+ * @param content - Content to write (string or Uint8Array)
+ * @param encoding - Text encoding (default: 'utf8')
+ * @returns A promise that resolves when the file is written
+ */
+export async function writeFile(
+	filePath: string,
+	content: string | Uint8Array,
+	encoding: BufferEncoding = "utf8",
+): Promise<void> {
+	if (content instanceof Uint8Array) {
+		await fs.writeFile(filePath, content)
+	} else {
+		await fs.writeFile(filePath, content, encoding)
+	}
+}
+
+// Common OS-generated files that would appear in an otherwise clean directory
+const OS_GENERATED_FILES = [
+	".DS_Store", // macOS Finder
+	"Thumbs.db", // Windows Explorer thumbnails
+	"desktop.ini", // Windows folder settings
+]
+
+/**
+ * Recursively reads a directory and returns an array of absolute file paths.
+ *
+ * @param directoryPath - The path to the directory to read.
+ * @param excludedPaths - Nested array of paths to ignore.
+ * @returns A promise that resolves to an array of absolute file paths.
+ * @throws Error if the directory cannot be read.
+ */
+export const readDirectory = async (directoryPath: string, excludedPaths: string[][] = []) => {
+	try {
+		const filePaths = await fs
+			.readdir(directoryPath, { withFileTypes: true, recursive: true })
+			.then((entries) => entries.filter((entry) => !OS_GENERATED_FILES.includes(entry.name)))
+			.then((entries) => entries.filter((entry) => entry.isFile()))
+			.then((files) =>
+				files.map((file) => {
+					const resolvedPath = workspaceResolver.resolveWorkspacePath(
+						file.parentPath,
+						file.name,
+						"Utils.fs.readDirectory",
+					)
+					return typeof resolvedPath === "string" ? resolvedPath : resolvedPath.absolutePath
+				}),
+			)
+			.then((filePaths) =>
+				filePaths.filter((filePath) => {
+					if (excludedPaths.length === 0) {
+						return true
+					}
+
+					for (const excludedPathList of excludedPaths) {
+						const pathToSearchFor = path.sep + excludedPathList.join(path.sep) + path.sep
+						if (filePath.includes(pathToSearchFor)) {
+							return false
+						}
+					}
+
+					return true
+				}),
+			)
+
+		return filePaths
+	} catch {
+		throw new Error(`Error reading directory at ${directoryPath}`)
+	}
+}
+
+export async function getBinaryLocation(name: string): Promise<string> {
+	const binName = IS_WINDOWS ? `${name}.exe` : name
+	const location = await HostProvider.get().getBinaryLocation(binName)
+
+	if (!(await fileExistsAtPath(location))) {
+		throw new Error(`Could not find binary ${name} at: ${location}`)
+	}
+	return location
+}
diff --git a/apps/vscode/src/utils/git-worktree.ts b/apps/vscode/src/utils/git-worktree.ts
new file mode 100644
index 0000000..248a225
--- /dev/null
+++ b/apps/vscode/src/utils/git-worktree.ts
@@ -0,0 +1,325 @@
+import * as path from "path"
+import simpleGit from "simple-git"
+import { Logger } from "@/shared/services/Logger"
+import { copyWorktreeIncludeFiles } from "./worktree-include"
+
+export interface Worktree {
+	path: string
+	branch: string
+	commitHash: string
+	isCurrent: boolean
+	isBare: boolean
+	isDetached: boolean
+	isLocked: boolean
+	lockReason?: string
+}
+
+export interface WorktreeResult {
+	success: boolean
+	message: string
+	worktree?: Worktree
+}
+
+export interface BranchInfo {
+	localBranches: string[]
+	remoteBranches: string[]
+	currentBranch: string
+}
+
+/**
+ * Check if git is installed
+ */
+async function checkGitInstalled(): Promise<boolean> {
+	try {
+		await simpleGit().version()
+		return true
+	} catch (_error) {
+		return false
+	}
+}
+
+/**
+ * Check if a directory is a git repository
+ */
+async function checkGitRepo(cwd: string): Promise<boolean> {
+	try {
+		const git = simpleGit(cwd)
+		return await git.checkIsRepo()
+	} catch (_error) {
+		return false
+	}
+}
+
+/**
+ * Get the current worktree path (same as git root for main worktree)
+ */
+async function getCurrentWorktreePath(cwd: string): Promise<string> {
+	try {
+		const git = simpleGit(cwd)
+		const root = await git.revparse(["--show-toplevel"])
+		return root.trim()
+	} catch (_error) {
+		return cwd
+	}
+}
+
+/**
+ * Get the git repository root path for a given directory.
+ * Returns null if not in a git repository.
+ */
+export async function getGitRootPath(cwd: string): Promise<string | null> {
+	const isInstalled = await checkGitInstalled()
+	if (!isInstalled) {
+		return null
+	}
+
+	try {
+		const git = simpleGit(cwd)
+		const isRepo = await git.checkIsRepo()
+		if (!isRepo) {
+			return null
+		}
+		const root = await git.revparse(["--show-toplevel"])
+		return root.trim()
+	} catch (_error) {
+		return null
+	}
+}
+
+/**
+ * List all worktrees in the repository
+ */
+export async function listWorktrees(cwd: string): Promise<{ worktrees: Worktree[]; isGitRepo: boolean; error?: string }> {
+	const isInstalled = await checkGitInstalled()
+	if (!isInstalled) {
+		return { worktrees: [], isGitRepo: false, error: "Git is not installed" }
+	}
+
+	const isRepo = await checkGitRepo(cwd)
+	if (!isRepo) {
+		return { worktrees: [], isGitRepo: false, error: "Not a git repository" }
+	}
+
+	try {
+		const currentPath = await getCurrentWorktreePath(cwd)
+		const git = simpleGit(cwd)
+		const stdout = await git.raw(["worktree", "list", "--porcelain"])
+
+		const worktrees: Worktree[] = []
+		const entries = stdout.trim().split("\n\n").filter(Boolean)
+
+		for (const entry of entries) {
+			const lines = entry.split("\n")
+			const worktree: Partial<Worktree> = {
+				isLocked: false,
+				isDetached: false,
+				isBare: false,
+				isCurrent: false,
+			}
+
+			for (const line of lines) {
+				if (line.startsWith("worktree ")) {
+					worktree.path = line.substring(9)
+					worktree.isCurrent = worktree.path === currentPath
+				} else if (line.startsWith("HEAD ")) {
+					worktree.commitHash = line.substring(5)
+				} else if (line.startsWith("branch ")) {
+					// Branch ref like "refs/heads/main" -> "main"
+					const branchRef = line.substring(7)
+					worktree.branch = branchRef.replace("refs/heads/", "")
+				} else if (line === "bare") {
+					worktree.isBare = true
+				} else if (line === "detached") {
+					worktree.isDetached = true
+					worktree.branch = ""
+				} else if (line === "locked") {
+					worktree.isLocked = true
+				} else if (line.startsWith("locked ")) {
+					worktree.isLocked = true
+					worktree.lockReason = line.substring(7)
+				}
+			}
+
+			if (worktree.path) {
+				worktrees.push(worktree as Worktree)
+			}
+		}
+
+		return { worktrees, isGitRepo: true }
+	} catch (error) {
+		return {
+			worktrees: [],
+			isGitRepo: true,
+			error: `Failed to list worktrees: ${error instanceof Error ? error.message : String(error)}`,
+		}
+	}
+}
+
+/**
+ * Create a new worktree
+ */
+export async function createWorktree(
+	cwd: string,
+	worktreePath: string,
+	options: {
+		branch?: string
+		baseBranch?: string
+		createNewBranch?: boolean
+	} = {},
+): Promise<WorktreeResult> {
+	const isInstalled = await checkGitInstalled()
+	if (!isInstalled) {
+		return { success: false, message: "Git is not installed" }
+	}
+
+	const isRepo = await checkGitRepo(cwd)
+	if (!isRepo) {
+		return { success: false, message: "Not a git repository" }
+	}
+
+	try {
+		const git = simpleGit(cwd)
+		const args: string[] = ["worktree", "add"]
+
+		if (options.createNewBranch && options.branch) {
+			// Create a new branch and worktree
+			args.push("-b", options.branch, worktreePath)
+			if (options.baseBranch) {
+				args.push(options.baseBranch)
+			}
+		} else if (options.branch) {
+			// Checkout existing branch
+			args.push(worktreePath, options.branch)
+		} else {
+			// Create detached worktree at HEAD
+			args.push("--detach", worktreePath)
+		}
+
+		await git.raw(args)
+
+		// Resolve the absolute path of the new worktree
+		const absoluteWorktreePath = path.isAbsolute(worktreePath) ? worktreePath : path.resolve(cwd, worktreePath)
+
+		// Copy files matched by .worktreeinclude (if it exists)
+		const { copiedCount, errors: copyErrors } = await copyWorktreeIncludeFiles(cwd, absoluteWorktreePath)
+
+		// Get the created worktree info
+		const { worktrees } = await listWorktrees(cwd)
+		const createdWorktree = worktrees.find((w) => w.path === absoluteWorktreePath)
+
+		let message = `Worktree created at ${worktreePath}`
+		if (copiedCount > 0) {
+			message += ` (copied ${copiedCount} file${copiedCount === 1 ? "" : "s"} from .worktreeinclude)`
+		}
+		if (copyErrors.length > 0) {
+			message += `. Some files failed to copy: ${copyErrors.slice(0, 3).join(", ")}`
+			if (copyErrors.length > 3) {
+				message += ` and ${copyErrors.length - 3} more`
+			}
+		}
+
+		return {
+			success: true,
+			message,
+			worktree: createdWorktree,
+		}
+	} catch (error) {
+		return {
+			success: false,
+			message: `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
+		}
+	}
+}
+
+/**
+ * Delete a worktree
+ */
+export async function deleteWorktree(cwd: string, path: string, force: boolean = false): Promise<WorktreeResult> {
+	const isInstalled = await checkGitInstalled()
+	if (!isInstalled) {
+		return { success: false, message: "Git is not installed" }
+	}
+
+	const isRepo = await checkGitRepo(cwd)
+	if (!isRepo) {
+		return { success: false, message: "Not a git repository" }
+	}
+
+	try {
+		const git = simpleGit(cwd)
+		const args = force ? ["worktree", "remove", "--force", path] : ["worktree", "remove", path]
+
+		await git.raw(args)
+
+		return {
+			success: true,
+			message: `Worktree at ${path} has been removed`,
+		}
+	} catch (error) {
+		return {
+			success: false,
+			message: `Failed to remove worktree: ${error instanceof Error ? error.message : String(error)}`,
+		}
+	}
+}
+
+/**
+ * Get available branches for creating worktrees
+ */
+export async function getAvailableBranches(cwd: string): Promise<BranchInfo> {
+	const isInstalled = await checkGitInstalled()
+	if (!isInstalled) {
+		return { localBranches: [], remoteBranches: [], currentBranch: "" }
+	}
+
+	const isRepo = await checkGitRepo(cwd)
+	if (!isRepo) {
+		return { localBranches: [], remoteBranches: [], currentBranch: "" }
+	}
+
+	try {
+		const git = simpleGit(cwd)
+
+		// Get current branch
+		let currentBranch = ""
+		try {
+			currentBranch = await git.revparse(["--abbrev-ref", "HEAD"])
+			currentBranch = currentBranch.trim()
+			if (currentBranch === "HEAD") {
+				// Detached HEAD state
+				currentBranch = ""
+			}
+		} catch {
+			// Detached HEAD state
+			currentBranch = ""
+		}
+
+		// Get all branches using branchLocal and branch -r
+		const branchSummary = await git.branchLocal()
+		const localBranches = branchSummary.all
+
+		// Get remote branches
+		const remoteBranchSummary = await git.branch(["-r"])
+		const remoteBranches = remoteBranchSummary.all.filter((b) => !b.includes("HEAD"))
+
+		// Filter out branches that already have worktrees
+		const { worktrees } = await listWorktrees(cwd)
+		const usedBranches = new Set(worktrees.map((w) => w.branch).filter(Boolean))
+
+		const availableLocalBranches = localBranches.filter((b) => !usedBranches.has(b))
+		const availableRemoteBranches = remoteBranches.filter((b) => {
+			// Remote branches like "origin/main" -> check if "main" is used
+			const shortName = b.split("/").slice(1).join("/")
+			return !usedBranches.has(shortName)
+		})
+
+		return {
+			localBranches: availableLocalBranches,
+			remoteBranches: availableRemoteBranches,
+			currentBranch,
+		}
+	} catch (error) {
+		Logger.error("Error getting available branches:", error)
+		return { localBranches: [], remoteBranches: [], currentBranch: "" }
+	}
+}
diff --git a/apps/vscode/src/utils/git.ts b/apps/vscode/src/utils/git.ts
new file mode 100644
index 0000000..08c2628
--- /dev/null
+++ b/apps/vscode/src/utils/git.ts
@@ -0,0 +1,312 @@
+import { exec } from "child_process"
+import { promisify } from "util"
+import { Logger } from "@/shared/services/Logger"
+
+const execAsync = promisify(exec)
+const GIT_OUTPUT_LINE_LIMIT = 500
+
+export interface GitCommit {
+	hash: string
+	shortHash: string
+	subject: string
+	author: string
+	date: string
+}
+
+async function checkGitRepo(cwd: string): Promise<boolean> {
+	try {
+		await execAsync("git rev-parse --git-dir", { cwd })
+		return true
+	} catch (_error) {
+		return false
+	}
+}
+
+async function checkGitInstalled(): Promise<boolean> {
+	try {
+		await execAsync("git --version")
+		return true
+	} catch (_error) {
+		return false
+	}
+}
+
+async function checkGitRepoHasCommits(cwd: string): Promise<boolean> {
+	try {
+		await execAsync("git rev-parse HEAD", { cwd })
+		return true
+	} catch (_error) {
+		return false
+	}
+}
+
+export async function searchCommits(query: string, cwd: string): Promise<GitCommit[]> {
+	try {
+		const isInstalled = await checkGitInstalled()
+		if (!isInstalled) {
+			Logger.error("Git is not installed")
+			return []
+		}
+
+		const isRepo = await checkGitRepo(cwd)
+		if (!isRepo) {
+			Logger.error("Not a git repository")
+			return []
+		}
+
+		// Check if repo has any commits
+		if (!(await checkGitRepoHasCommits(cwd))) {
+			// No commits yet in the repository
+			return []
+		}
+
+		// Search commits by hash or message, limiting to 10 results
+		const { stdout } = await execAsync(
+			`git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short ` + `--grep="${query}" --regexp-ignore-case`,
+			{ cwd },
+		)
+
+		let output = stdout
+		if (!output.trim() && /^[a-f0-9]+$/i.test(query)) {
+			// If no results from grep search and query looks like a hash, try searching by hash
+			const { stdout: hashStdout } = await execAsync(
+				`git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short ` + `--author-date-order ${query}`,
+				{ cwd },
+			).catch(() => ({ stdout: "" }))
+
+			if (!hashStdout.trim()) {
+				return []
+			}
+
+			output = hashStdout
+		}
+
+		const commits: GitCommit[] = []
+		const lines = output
+			.trim()
+			.split("\n")
+			.filter((line) => line !== "--")
+
+		for (let i = 0; i < lines.length; i += 5) {
+			commits.push({
+				hash: lines[i],
+				shortHash: lines[i + 1],
+				subject: lines[i + 2],
+				author: lines[i + 3],
+				date: lines[i + 4],
+			})
+		}
+
+		return commits
+	} catch (error) {
+		Logger.error("Error searching commits:", error)
+		return []
+	}
+}
+
+export async function getCommitInfo(hash: string, cwd: string): Promise<string> {
+	try {
+		const isInstalled = await checkGitInstalled()
+		if (!isInstalled) {
+			return "Git is not installed"
+		}
+
+		const isRepo = await checkGitRepo(cwd)
+		if (!isRepo) {
+			return "Not a git repository"
+		}
+
+		// Check if repo has any commits
+		if (!(await checkGitRepoHasCommits(cwd))) {
+			return "Repository has no commits yet"
+		}
+
+		// Get commit info, stats, and diff separately
+		const { stdout: info } = await execAsync(`git show --format="%H%n%h%n%s%n%an%n%ad%n%b" --no-patch ${hash}`, {
+			cwd,
+		})
+		const [fullHash, shortHash, subject, author, date, body] = info.trim().split("\n")
+
+		const { stdout: stats } = await execAsync(`git show --stat --format="" ${hash}`, { cwd })
+
+		const { stdout: diff } = await execAsync(`git show --format="" ${hash}`, { cwd })
+
+		const summary = [
+			`Commit: ${shortHash} (${fullHash})`,
+			`Author: ${author}`,
+			`Date: ${date}`,
+			`\nMessage: ${subject}`,
+			body ? `\nDescription:\n${body}` : "",
+			"\nFiles Changed:",
+			stats.trim(),
+			"\nFull Changes:",
+		].join("\n")
+
+		const output = summary + "\n\n" + diff.trim()
+		return truncateOutput(output)
+	} catch (error) {
+		Logger.error("Error getting commit info:", error)
+		return `Failed to get commit info: ${error instanceof Error ? error.message : String(error)}`
+	}
+}
+
+export async function getWorkingState(cwd: string): Promise<string> {
+	try {
+		const isInstalled = await checkGitInstalled()
+		if (!isInstalled) {
+			return "Git is not installed"
+		}
+
+		const isRepo = await checkGitRepo(cwd)
+		if (!isRepo) {
+			return "Not a git repository"
+		}
+
+		// Get status of working directory
+		const { stdout: status } = await execAsync("git status --short", { cwd })
+		if (!status.trim()) {
+			return "No changes in working directory"
+		}
+
+		// Check if repo has any commits before trying to diff against HEAD
+		let diff = ""
+		if (await checkGitRepoHasCommits(cwd)) {
+			// Only run git diff if there are commits
+			const { stdout: diffOutput } = await execAsync("git diff HEAD", { cwd })
+			diff = diffOutput
+		} else {
+			// No commits yet, use status output only
+			return `Working directory changes (new repository):\n\n${status}`
+		}
+		const output = `Working directory changes:\n\n${status}\n\n${diff}`.trim()
+		return truncateOutput(output)
+	} catch (error) {
+		Logger.error("Error getting working state:", error)
+		return `Failed to get working state: ${error instanceof Error ? error.message : String(error)}`
+	}
+}
+
+export async function getGitDiff(cwd: string, stagedOnly = false): Promise<string> {
+	try {
+		const isInstalled = await checkGitInstalled()
+		if (!isInstalled) {
+			throw new Error("Git is not installed")
+		}
+
+		const isRepo = await checkGitRepo(cwd)
+		if (!isRepo) {
+			throw new Error("Not a git repository")
+		}
+
+		let diff = ""
+		// `git diff --staged` is valid even before the first commit (it diffs the
+		// index against the empty tree), so it must NOT be gated on having a HEAD.
+		// This is the common case for the very first commit of a new repo.
+		let command = "git --no-pager diff --staged --diff-filter=d"
+		const { stdout: staged } = await execAsync(command, { cwd })
+		diff = staged.trim()
+
+		// The unstaged fallback compares against HEAD, which only exists once the
+		// repo has at least one commit. Skip it in a commit-less repo.
+		if (!stagedOnly && !diff && (await checkGitRepoHasCommits(cwd))) {
+			command = "git --no-pager diff HEAD --diff-filter=d"
+			const { stdout: unstaged } = await execAsync(command, { cwd })
+			diff = unstaged.trim()
+		}
+
+		if (!diff) {
+			throw new Error("No changes in workspace for commit message")
+		}
+
+		return truncateOutput(`'${command}' Output:\n\n${diff}`.trim())
+	} catch (error) {
+		throw error
+	}
+}
+
+export async function getGitRemoteUrls(cwd: string): Promise<string[]> {
+	try {
+		const isInstalled = await checkGitInstalled()
+		if (!isInstalled) {
+			return []
+		}
+
+		const isRepo = await checkGitRepo(cwd)
+		if (!isRepo) {
+			return []
+		}
+
+		const { stdout } = await execAsync("git remote -v", { cwd })
+		if (!stdout.trim()) {
+			return []
+		}
+
+		// Parse output to extract unique URLs
+		// git remote -v output format: "remoteName remoteUrl (fetch|push)"
+		const remotes = stdout
+			.trim()
+			.split("\n")
+			.filter((line) => line.includes("(fetch)")) // Only fetch URLs to avoid duplicates
+			.map((line) => {
+				const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/)
+				return match ? { name: match[1], url: match[2] } : null
+			})
+			.filter((remote): remote is { name: string; url: string } => remote !== null)
+
+		return remotes.map((remote) => `${remote.name}: ${remote.url}`)
+	} catch (error) {
+		Logger.error("Error getting git remotes:", error)
+		return []
+	}
+}
+
+export async function getLatestGitCommitHash(cwd: string): Promise<string | null> {
+	try {
+		const isInstalled = await checkGitInstalled()
+		if (!isInstalled) {
+			return null
+		}
+
+		const isRepo = await checkGitRepo(cwd)
+		if (!isRepo) {
+			return null
+		}
+
+		const { stdout } = await execAsync("git rev-parse HEAD", { cwd })
+		return stdout.trim() || null
+	} catch (error) {
+		Logger.error("Error getting latest git commit hash:", error)
+		return null
+	}
+}
+
+function truncateOutput(content: string): string {
+	if (!GIT_OUTPUT_LINE_LIMIT) {
+		return content
+	}
+
+	const lines = content.split("\n")
+	if (lines.length <= GIT_OUTPUT_LINE_LIMIT) {
+		return content
+	}
+
+	const beforeLimit = Math.floor(GIT_OUTPUT_LINE_LIMIT * 0.2) // 20% of lines before
+	const afterLimit = GIT_OUTPUT_LINE_LIMIT - beforeLimit // remaining 80% after
+	return [
+		...lines.slice(0, beforeLimit),
+		`\n[...${lines.length - GIT_OUTPUT_LINE_LIMIT} lines omitted...]\n`,
+		...lines.slice(-afterLimit),
+	].join("\n")
+}
+
+// NEW: Additional functions for Stage 3 multi-workspace support
+// These are the ONLY new additions needed for workspace detection
+
+/**
+ * Check if a directory is a Git repository (Stage 3 requirement)
+ * @param dirPath - The directory path to check
+ * @returns True if it's a Git repository
+ */
+async function isGitRepository(dirPath: string): Promise<boolean> {
+	return await checkGitRepo(dirPath)
+}
diff --git a/apps/vscode/src/utils/github-url-utils.ts b/apps/vscode/src/utils/github-url-utils.ts
new file mode 100644
index 0000000..8ac09c1
--- /dev/null
+++ b/apps/vscode/src/utils/github-url-utils.ts
@@ -0,0 +1,136 @@
+/**
+ * github-url-utils.ts
+ *
+ * Portable utility functions for creating and opening GitHub issue URLs
+ * with proper URL encoding that bypasses VS Code's URI handling issues.
+ *
+ * This utility addresses a longstanding issue in VS Code's URI handling:
+ * https://github.com/microsoft/vscode/issues/85930
+ *
+ * The issue causes URLs with special characters in query parameters to be incorrectly
+ * encoded when opened through VS Code's standard APIs (vscode.Uri.parse followed by
+ * vscode.env.openExternal). This particularly affects GitHub issue URLs with pre-filled
+ * fields containing special characters.
+ */
+
+import { HostProvider } from "@hosts/host-provider"
+import { ShowMessageType } from "@shared/proto/host/window"
+import * as cp from "child_process"
+import * as os from "os"
+import * as util from "util"
+import { Logger } from "@/shared/services/Logger"
+import { openExternal, writeTextToClipboard } from "@/utils/env"
+
+/**
+ * Opens a URL using platform-specific commands to bypass VS Code's URI handling issues.
+ *
+ * IMPORTANT: This function intentionally avoids using VS Code's built-in URI handling
+ * (vscode.Uri.parse() and vscode.env.openExternal()) due to known encoding issues with URLs
+ * that contain special characters in query parameters. See:
+ * https://github.com/microsoft/vscode/issues/85930
+ *
+ * The specific issues with VS Code's URI handling include:
+ * 1. Double-encoding of certain characters (e.g., # becomes %23 then %2523)
+ * 2. Inconsistent handling where some characters are encoded and others are decoded
+ * 3. Issues with parameters in the query string being incorrectly processed
+ *
+ * Instead, this function:
+ * - Uses direct OS commands to open the browser with the URL
+ * - Preserves the exact encoding of the URL as provided
+ * - Provides multiple fallback approaches if the primary method fails
+ *
+ * @param url The URL to open
+ * @returns A promise that resolves when an attempt to open the URL has completed
+ */
+export async function openUrlInBrowser(url: string): Promise<void> {
+	// For debugging
+	Logger.log(`Opening URL: ${url}`)
+
+	// Always copy to clipboard as a fallback
+	try {
+		await writeTextToClipboard(url)
+		Logger.log("URL copied to clipboard as backup")
+	} catch (error) {
+		Logger.error(`Failed to copy URL to clipboard: ${error}`)
+	}
+
+	// Try to open the URL using platform-specific commands
+	try {
+		const platform = os.platform()
+		Logger.log(`Detected platform: ${platform}`)
+
+		// Use promisify for better async error handling
+		const execPromise = util.promisify(cp.exec)
+
+		// Use platform-specific commands
+		if (platform === "win32") {
+			// Windows - try multiple approaches
+			try {
+				await execPromise(`start "" "${url}"`)
+				Logger.log("Opened URL with Windows 'start' command")
+				return
+			} catch (winError) {
+				Logger.error(`Error with Windows 'start' command: ${winError}`)
+
+				try {
+					await execPromise(`powershell.exe -Command "Start-Process '${url}'"`)
+					Logger.log("Opened URL with PowerShell command")
+					return
+				} catch (psError) {
+					Logger.error(`Error with PowerShell command: ${psError}`)
+					// Fall through to the fallbacks
+				}
+			}
+		} else if (platform === "darwin") {
+			// macOS
+			await execPromise(`open "${url}"`)
+			Logger.log("Opened URL with macOS 'open' command")
+			return
+		} else {
+			// Linux and others - try multiple commands
+			const linuxCommands = ["xdg-open", "gnome-open", "kde-open", "wslview"]
+
+			for (const cmd of linuxCommands) {
+				try {
+					await execPromise(`${cmd} "${url}"`)
+					Logger.log(`Opened URL with '${cmd}' command`)
+					return
+				} catch (cmdError) {
+					Logger.error(`Error with '${cmd}' command: ${cmdError}`)
+					// Try next command
+				}
+			}
+		}
+
+		// If we got here, none of the OS commands worked
+		throw new Error("All OS commands failed")
+	} catch (error) {
+		Logger.error(`OS commands failed: ${error}`)
+
+		// First fallback: Try openExternal utility
+		// Note: This will likely have encoding issues per https://github.com/microsoft/vscode/issues/85930
+		// but we include it as a fallback in case OS commands completely fail
+		try {
+			await openExternal(url)
+			Logger.log("Opened URL with openExternal utility (note: URL encoding may be affected)")
+			return
+		} catch (openExternalError) {
+			Logger.error(`Error with openExternal utility: ${openExternalError}`)
+
+			// Last fallback: Show a message with instructions
+			HostProvider.window
+				.showMessage({
+					type: ShowMessageType.INFORMATION,
+					message: "Couldn't open the URL automatically. It has been copied to your clipboard.",
+					options: {
+						items: ["Copy URL Again"],
+					},
+				})
+				.then((response) => {
+					if (response.selectedOption === "Copy URL Again") {
+						writeTextToClipboard(url)
+					}
+				})
+		}
+	}
+}
diff --git a/apps/vscode/src/utils/mcpAuth.ts b/apps/vscode/src/utils/mcpAuth.ts
new file mode 100644
index 0000000..529764a
--- /dev/null
+++ b/apps/vscode/src/utils/mcpAuth.ts
@@ -0,0 +1,14 @@
+import crypto from "crypto"
+
+/**
+ * Generates a unique hash for an MCP server based on its name and URL.
+ * Used as the storage key in the legacy `mcpOAuthSecrets` blob; retained only
+ * for the one-time migration of legacy tokens into the shared settings file
+ * (see McpOAuthManager.migrateLegacySecrets).
+ * @param serverName The name of the MCP server.
+ * @param serverUrl The URL of the MCP server.
+ * @returns A SHA-256 hash string.
+ */
+export const getServerAuthHash = (serverName: string, serverUrl: string): string => {
+	return crypto.createHash("sha256").update(`${serverName}:${serverUrl}`).digest("hex")
+}
diff --git a/apps/vscode/src/utils/model-utils.ts b/apps/vscode/src/utils/model-utils.ts
new file mode 100644
index 0000000..be8d5d9
--- /dev/null
+++ b/apps/vscode/src/utils/model-utils.ts
@@ -0,0 +1,171 @@
+import { MODEL_COLLECTIONS_BY_PROVIDER_ID } from "@cline/llms"
+import { ApiHandlerModel } from "@core/api"
+import type { AnthropicModelId } from "@/shared/api"
+
+const CLAUDE_VERSION_MATCH_REGEX = /[-_ ]([\d](?:\.[05])?)[-_ ]?/
+export const GEMINI_FLASH_MAX_OUTPUT_TOKENS = 8_192
+
+export function modelDoesntSupportWebp(apiHandlerModel: ApiHandlerModel): boolean {
+	const modelId = apiHandlerModel.id.toLowerCase()
+	// Grok doesn't support WebP via its API.
+	// GLM and Devstral models running through llama.cpp fail with WebP because
+	// llama.cpp's STB image library doesn't support the WebP format.
+	return modelId.includes("grok") || isGLMModelFamily(modelId) || isDevstralModelFamily(modelId)
+}
+
+/**
+ * Determines if reasoning content should be skipped for a given model
+ * Currently skips reasoning for:
+ * - Grok-4 models since they only display "thinking" without useful information
+ * - Devstral models since they don't support reasoning_details field
+ */
+export function shouldSkipReasoningForModel(modelId?: string): boolean {
+	if (!modelId) {
+		return false
+	}
+	return modelId.includes("grok-4") || modelId.includes("devstral") || modelId.includes("glm")
+}
+
+function isAnthropicModelId(modelId: string): modelId is AnthropicModelId {
+	const CLAUDE_MODELS = ["sonnet", "opus", "haiku"]
+	const anthropicCollection = MODEL_COLLECTIONS_BY_PROVIDER_ID["anthropic"]
+	return (
+		(anthropicCollection ? modelId in anthropicCollection.models : false) ||
+		CLAUDE_MODELS.some((substring) => modelId.includes(substring))
+	)
+}
+
+export function isClaude4PlusModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	// Claude Code short aliases are always Claude 4+
+	// These are used by ClaudeCodeHandler.getModel() when user selects "sonnet" or "opus"
+	// Check before isAnthropicModelId to avoid type guard narrowing issues
+	if (modelId === "sonnet" || modelId === "opus") {
+		return true
+	}
+	if (!isAnthropicModelId(modelId)) {
+		return false
+	}
+	// Get model version number
+	const versionMatch = modelId.match(CLAUDE_VERSION_MATCH_REGEX)
+	if (!versionMatch) {
+		return false
+	}
+	const version = Number.parseFloat(versionMatch[1])
+	// Check if version is 4.0 or higher
+	return version >= 4
+}
+
+function isGemini2dot5ModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("gemini-2.5")
+}
+
+function isGrok4ModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("grok-4")
+}
+
+export function isGPT5ModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("gpt-5") || modelId.includes("gpt5")
+}
+
+export function isGptOssModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("gpt-oss") || modelId.includes("gpt_oss")
+}
+
+export function isGLMModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return (
+		modelId.includes("glm-5") ||
+		modelId.includes("glm-4.7") ||
+		modelId.includes("glm-4.6") ||
+		modelId.includes("glm-4.5") ||
+		// Space-separated variants like "GLM 4.6V" used with openai-compatible local servers
+		modelId.includes("glm 4.") ||
+		modelId.includes("z-ai/glm") ||
+		modelId.includes("zai-org/glm")
+	)
+}
+
+function isMinimaxModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("minimax")
+}
+
+function isNextGenOpenSourceModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return ["kimi-k2"].some((substring) => modelId.includes(substring))
+}
+
+function isDevstralModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("devstral")
+}
+
+function isGemini3ModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("gemini3") || modelId.includes("gemini-3")
+}
+
+export function isGeminiFlashModel(id: string): boolean {
+	const modelId = normalize(id)
+	const isGooglePrefixedGemini = modelId.startsWith("google/gemini")
+	const isDirectGemini = modelId.startsWith("gemini-")
+	return (isGooglePrefixedGemini || isDirectGemini) && modelId.includes("flash")
+}
+
+function isDeepSeek32ModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("deepseek") && modelId.includes("3.2") && !modelId.includes("speciale")
+}
+
+function isDeepSeekNativeModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("deepseek-chat") || modelId.includes("deepseek-reasoner")
+}
+
+export function isPoolsideModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return modelId.includes("laguna")
+}
+
+export function isNextGenModelFamily(id: string): boolean {
+	const modelId = normalize(id)
+	return (
+		isClaude4PlusModelFamily(modelId) ||
+		isGemini2dot5ModelFamily(modelId) ||
+		isGrok4ModelFamily(modelId) ||
+		isGPT5ModelFamily(modelId) ||
+		isGptOssModelFamily(modelId) ||
+		isMinimaxModelFamily(modelId) ||
+		isGemini3ModelFamily(modelId) ||
+		isNextGenOpenSourceModelFamily(modelId) ||
+		isDeepSeek32ModelFamily(modelId) ||
+		isDeepSeekNativeModelFamily(modelId) ||
+		isPoolsideModelFamily(modelId)
+	)
+}
+
+/**
+ * Parses a price string and converts it from per-token to per-million-tokens
+ * @param priceString The price string to parse (e.g. from API responses)
+ * @returns The price multiplied by 1,000,000 for per-million-token pricing, or 0 if invalid
+ */
+export function parsePrice(priceString: string | undefined): number {
+	if (!priceString || priceString === "" || priceString === "0") {
+		return 0
+	}
+	const parsed = Number.parseFloat(priceString)
+	if (Number.isNaN(parsed)) {
+		return 0
+	}
+	// Convert from per-token to per-million-tokens (multiply by 1,000,000)
+	return parsed * 1_000_000
+}
+
+function normalize(text: string): string {
+	return text.trim().toLowerCase()
+}
diff --git a/apps/vscode/src/utils/path.test.ts b/apps/vscode/src/utils/path.test.ts
new file mode 100644
index 0000000..5a5be02
--- /dev/null
+++ b/apps/vscode/src/utils/path.test.ts
@@ -0,0 +1,85 @@
+import { describe, it } from "mocha"
+import * as os from "os"
+import * as path from "path"
+import "should"
+import { arePathsEqual, getReadablePath, isLocatedInPath } from "./path"
+
+describe("Path Utilities", () => {
+	describe("isLocatedInPath", () => {
+		it("should return true for a path located within the directory", () => {
+			const dirPath = "/home/user/project"
+			const filePath = "/home/user/project/src/index.js"
+			isLocatedInPath(dirPath, filePath).should.be.true()
+		})
+
+		it("should return false for a path located outside the directory", () => {
+			const dirPath = "/home/user/project"
+			const filePath = "/home/user/other/index.js"
+			isLocatedInPath(dirPath, filePath).should.be.false()
+		})
+
+		it("should handle edge cases with trailing slashes", () => {
+			const dirPath = "/home/user/project/"
+			const filePath = "/home/user/project/src/index.js"
+			isLocatedInPath(dirPath, filePath).should.be.true()
+		})
+
+		it("should handle edge cases with relative paths", () => {
+			const dirPath = "/home/user/project"
+			const filePath = "/home/user/project/../project/src/index.js"
+			isLocatedInPath(dirPath, filePath).should.be.true()
+		})
+
+		it("should return false when the directory is similarly named", () => {
+			const dirPath = "/home/user/project"
+			const filePath = "/home/user/project_backup/index.js"
+			isLocatedInPath(dirPath, filePath).should.be.false()
+		})
+	})
+
+	describe("arePathsEqual", () => {
+		it("should handle undefined paths", () => {
+			arePathsEqual(undefined, undefined).should.be.true()
+			arePathsEqual("foo", undefined).should.be.false()
+			arePathsEqual(undefined, "foo").should.be.false()
+		})
+
+		it("should handle case sensitivity based on platform", () => {
+			if (process.platform === "win32") {
+				arePathsEqual("FOO/BAR", "foo/bar").should.be.true()
+			} else {
+				arePathsEqual("FOO/BAR", "foo/bar").should.be.false()
+			}
+		})
+
+		it("should handle normalized paths", () => {
+			arePathsEqual("/tmp/./dir", "/tmp/../tmp/dir").should.be.true()
+			arePathsEqual("/tmp/./dir", "/tmp/../dir").should.be.false()
+		})
+	})
+
+	describe("getReadablePath", () => {
+		it("should handle desktop path", () => {
+			const desktop = path.join(os.homedir(), "Desktop")
+			const testPath = path.join(desktop, "test.txt")
+			getReadablePath(desktop, "test.txt").should.equal(testPath.replace(/\\/g, "/"))
+		})
+
+		it("should show relative paths within cwd", () => {
+			const cwd = path.resolve("/home/user/project")
+			const filePath = path.resolve("/home/user/project/src/file.txt")
+			getReadablePath(cwd, filePath).should.equal("src/file.txt")
+		})
+
+		it("should show basename when path equals cwd", () => {
+			const cwd = path.resolve("/home/user/project")
+			getReadablePath(cwd, cwd).should.equal("project")
+		})
+
+		it("should show absolute path when outside cwd", () => {
+			const cwd = path.resolve("/home/user/project")
+			const filePath = path.resolve("/home/user/other/file.txt")
+			getReadablePath(cwd, filePath).should.equal(filePath.toPosix())
+		})
+	})
+})
diff --git a/apps/vscode/src/utils/path.ts b/apps/vscode/src/utils/path.ts
new file mode 100644
index 0000000..ffca423
--- /dev/null
+++ b/apps/vscode/src/utils/path.ts
@@ -0,0 +1,167 @@
+import { workspaceResolver } from "@core/workspace"
+import os from "os"
+import * as path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+
+/*
+The Node.js 'path' module resolves and normalizes paths differently depending on the platform:
+- On Windows, it uses backslashes (\) as the default path separator.
+- On POSIX-compliant systems (Linux, macOS), it uses forward slashes (/) as the default path separator.
+
+While modules like 'upath' can be used to normalize paths to use forward slashes consistently,
+this can create inconsistencies when interfacing with other modules (like vscode.fs) that use
+backslashes on Windows.
+
+Our approach:
+1. We present paths with forward slashes to the AI and user for consistency.
+2. We use the 'arePathsEqual' function for safe path comparisons.
+3. Internally, Node.js gracefully handles both backslashes and forward slashes.
+
+This strategy ensures consistent path presentation while leveraging Node.js's built-in
+path handling capabilities across different platforms.
+
+Note: When interacting with the file system or VS Code APIs, we still use the native path module
+to ensure correct behavior on all platforms. The toPosixPath and arePathsEqual functions are
+primarily used for presentation and comparison purposes, not for actual file system operations.
+
+Observations:
+- Macos isn't so flexible with mixed separators, whereas windows can handle both. ("Node.js does automatically handle path separators on Windows, converting forward slashes to backslashes as needed. However, on macOS and other Unix-like systems, the path separator is always a forward slash (/), and backslashes are treated as regular characters.")
+*/
+
+function toPosixPath(p: string) {
+	// Extended-Length Paths in Windows start with "\\?\" to allow longer paths and bypass usual parsing. If detected, we return the path unmodified to maintain functionality, as altering these paths could break their special syntax.
+	const isExtendedLengthPath = p.startsWith("\\\\?\\")
+
+	if (isExtendedLengthPath) {
+		return p
+	}
+
+	return p.replace(/\\/g, "/")
+}
+
+// Declaration merging allows us to add a new method to the String type
+// You must import this file in your entry point (extension.ts) to have access at runtime
+declare global {
+	interface String {
+		toPosix(): string
+	}
+}
+
+String.prototype.toPosix = function (this: string): string {
+	return toPosixPath(this)
+}
+
+// Safe path comparison that works across different platforms
+export function arePathsEqual(path1?: string, path2?: string): boolean {
+	if (!path1 && !path2) {
+		return true
+	}
+	if (!path1 || !path2) {
+		return false
+	}
+
+	path1 = normalizePath(path1)
+	path2 = normalizePath(path2)
+
+	if (process.platform === "win32") {
+		return path1.toLowerCase() === path2.toLowerCase()
+	}
+	return path1 === path2
+}
+
+function normalizePath(p: string): string {
+	// normalize resolve ./.. segments, removes duplicate slashes, and standardizes path separators
+	let normalized = path.normalize(p)
+	// however it doesn't remove trailing slashes
+	// remove trailing slash, except for root paths
+	if (normalized.length > 1 && (normalized.endsWith("/") || normalized.endsWith("\\"))) {
+		normalized = normalized.slice(0, -1)
+	}
+	return normalized
+}
+
+export function getReadablePath(cwd: string, relPath?: string): string {
+	relPath = relPath || ""
+	// path.resolve is flexible in that it will resolve relative paths like '../../' to the cwd and even ignore the cwd if the relPath is actually an absolute path
+	const absolutePathResult = workspaceResolver.resolveWorkspacePath(cwd, relPath, "Utils.path.getReadablePath")
+	const absolutePath = typeof absolutePathResult === "string" ? absolutePathResult : absolutePathResult.absolutePath
+	if (arePathsEqual(cwd, getDesktopDir())) {
+		// User opened vscode without a workspace, so cwd is the Desktop. Show the full absolute path to keep the user aware of where files are being created
+		return absolutePath.toPosix()
+	}
+	if (arePathsEqual(path.normalize(absolutePath), path.normalize(cwd))) {
+		const basenameResult = workspaceResolver.getBasename(absolutePath, "Utils.path.getReadablePath")
+		return basenameResult.toPosix()
+	}
+	// show the relative path to the cwd
+	const normalizedRelPath = path.relative(cwd, absolutePath)
+	if (isLocatedInPath(cwd, absolutePath)) {
+		return normalizedRelPath.toPosix()
+	}
+	// we are outside the cwd, so show the absolute path (useful for when Cline passes in '../../' for example)
+	return absolutePath.toPosix()
+}
+
+// Returns the path of the first workspace directory, or the defaultCwdPath if there is no workspace open.
+export async function getCwd(defaultCwd = ""): Promise<string> {
+	const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
+	return workspacePaths.paths.shift() || defaultCwd
+}
+
+export function getDesktopDir() {
+	const desktopResult = workspaceResolver.resolveWorkspacePath(os.homedir(), "Desktop", "Utils.path.getDesktopDir")
+	return typeof desktopResult === "string" ? desktopResult : desktopResult.absolutePath
+}
+
+// Returns the workspace path of the file in the current editor.
+// If there is no open file, it returns the top level workspace directory.
+export async function getWorkspacePath(defaultCwd = ""): Promise<string> {
+	const currentFilePath = (await HostProvider.window.getActiveEditor({})).filePath
+	if (!currentFilePath) {
+		return await getCwd(defaultCwd)
+	}
+
+	const workspacePaths = (await HostProvider.workspace.getWorkspacePaths({})).paths
+	for (const workspacePath of workspacePaths) {
+		if (isLocatedInPath(workspacePath, currentFilePath)) {
+			return workspacePath
+		}
+	}
+	return await getCwd(defaultCwd)
+}
+
+// Returns true if `pathToCheck` is located inside `dirPath`.
+export function isLocatedInPath(dirPath: string, pathToCheck: string): boolean {
+	if (!dirPath || !pathToCheck) {
+		return false
+	}
+	// Handle long paths in Windows
+	if (dirPath.startsWith("\\\\?\\") || pathToCheck.startsWith("\\\\?\\")) {
+		return pathToCheck.startsWith(dirPath)
+	}
+
+	const resolvedDirResult = workspaceResolver.resolveWorkspacePath(dirPath, "", "Utils.path.isLocatedInPath")
+	const resolvedDir = typeof resolvedDirResult === "string" ? resolvedDirResult : resolvedDirResult.absolutePath
+	const resolvedCheckResult = workspaceResolver.resolveWorkspacePath(pathToCheck, "", "Utils.path.isLocatedInPath")
+	const resolvedCheck = typeof resolvedCheckResult === "string" ? resolvedCheckResult : resolvedCheckResult.absolutePath
+
+	const relativePath = path.relative(resolvedDir, resolvedCheck)
+	if (relativePath.startsWith("..")) {
+		return false
+	}
+	if (path.isAbsolute(relativePath)) {
+		// This can happen on windows when the two paths are on different drives.
+		return false
+	}
+	return true
+}
+
+export async function asRelativePath(filePath: string): Promise<string> {
+	const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
+	for (const workspacePath of workspacePaths.paths) {
+		if (isLocatedInPath(workspacePath, filePath)) {
+			return path.relative(workspacePath, filePath)
+		}
+	}
+	return filePath
+}
diff --git a/apps/vscode/src/utils/powershell.ts b/apps/vscode/src/utils/powershell.ts
new file mode 100644
index 0000000..d136a05
--- /dev/null
+++ b/apps/vscode/src/utils/powershell.ts
@@ -0,0 +1,96 @@
+import * as childProcess from "child_process"
+import { Logger } from "@/shared/services/Logger"
+import { WINDOWS_POWERSHELL_7_PATH, WINDOWS_POWERSHELL_LEGACY_PATH } from "./shell"
+
+const POWERSHELL_PROBE_TIMEOUT_MS = 1200
+
+let resolvedPowerShellPromise: Promise<string> | null = null
+let probeWindowsExecutableImpl: (candidate: string, timeoutMs?: number) => Promise<boolean> = probeWindowsExecutable
+
+function uniquePreserveOrder(values: string[]): string[] {
+	return [...new Set(values.filter(Boolean))]
+}
+
+export function getFallbackWindowsPowerShellPath(): string {
+	return WINDOWS_POWERSHELL_LEGACY_PATH
+}
+
+export function getWindowsPowerShellCandidates(): string[] {
+	const programFiles = process.env.ProgramW6432 || process.env.ProgramFiles || "C:\\Program Files"
+
+	const envAbsoluteCandidates = [
+		`${programFiles}\\PowerShell\\7\\pwsh.exe`,
+		`${programFiles}\\PowerShell\\6\\pwsh.exe`,
+		WINDOWS_POWERSHELL_7_PATH,
+		WINDOWS_POWERSHELL_LEGACY_PATH,
+	]
+
+	const commandNameFallbacks = ["pwsh.exe", "pwsh", "powershell.exe", "powershell"]
+
+	return uniquePreserveOrder([...envAbsoluteCandidates, ...commandNameFallbacks])
+}
+
+export function resetPowerShellResolverCacheForTesting(): void {
+	resolvedPowerShellPromise = null
+	probeWindowsExecutableImpl = probeWindowsExecutable
+}
+
+export function setPowerShellProbeForTesting(
+	probeFn: ((candidate: string, timeoutMs?: number) => Promise<boolean>) | null,
+): void {
+	probeWindowsExecutableImpl = probeFn ?? probeWindowsExecutable
+}
+
+export async function probeWindowsExecutable(candidate: string, timeoutMs = POWERSHELL_PROBE_TIMEOUT_MS): Promise<boolean> {
+	return await new Promise<boolean>((resolve) => {
+		const child = childProcess.spawn(candidate, ["-NoProfile", "-NonInteractive", "-Command", "$PSVersionTable.PSVersion"], {
+			stdio: "ignore",
+			windowsHide: true,
+			shell: false,
+		})
+
+		let settled = false
+
+		const finish = (isAvailable: boolean) => {
+			if (settled) {
+				return
+			}
+			settled = true
+			clearTimeout(timer)
+			resolve(isAvailable)
+		}
+
+		const timer = setTimeout(() => {
+			if (!child.killed) {
+				child.kill("SIGTERM")
+			}
+			finish(false)
+		}, timeoutMs)
+
+		child.once("error", () => finish(false))
+		child.once("exit", (code) => finish(code === 0))
+	})
+}
+
+export async function resolveWindowsPowerShellExecutable(): Promise<string> {
+	if (!resolvedPowerShellPromise) {
+		resolvedPowerShellPromise = (async () => {
+			const candidates = getWindowsPowerShellCandidates()
+
+			for (const candidate of candidates) {
+				if (await probeWindowsExecutableImpl(candidate)) {
+					Logger.debug(`[PowerShellResolver] Using PowerShell executable: ${candidate}`)
+					return candidate
+				}
+			}
+
+			const fallback = getFallbackWindowsPowerShellPath()
+			Logger.warn(
+				`[PowerShellResolver] Could not resolve PowerShell executable from candidates ${candidates.join(", ")}. Falling back to ${fallback}.`,
+			)
+			return fallback
+		})()
+	}
+
+	return resolvedPowerShellPromise
+}
diff --git a/apps/vscode/src/utils/process-termination.ts b/apps/vscode/src/utils/process-termination.ts
new file mode 100644
index 0000000..6320450
--- /dev/null
+++ b/apps/vscode/src/utils/process-termination.ts
@@ -0,0 +1,56 @@
+/**
+ * Utility for graceful process termination with SIGKILL fallback.
+ *
+ * Handles cross-platform process tree termination:
+ * - Sends SIGTERM first for graceful shutdown
+ * - Waits for configurable timeout
+ * - Falls back to SIGKILL if process doesn't exit
+ */
+
+import { ChildProcess } from "child_process"
+import treeKill from "tree-kill"
+
+export interface TerminateProcessTreeOptions {
+	/** Process ID to terminate */
+	pid: number
+	/** Child process reference (for exit event listening) */
+	childProcess?: ChildProcess | null
+	/** Function to check if process has already completed */
+	isCompleted: () => boolean
+	/** Timeout in ms before escalating to SIGKILL (default: 2000) */
+	gracefulTimeoutMs?: number
+}
+
+/**
+ * Terminates a process tree with graceful shutdown and SIGKILL fallback.
+ *
+ * Uses tree-kill to handle cross-platform process tree termination:
+ * - On Windows: Uses taskkill /T /F (always force kills)
+ * - On Unix: Sends signal to entire process tree
+ *
+ * @param options Termination options
+ */
+export async function terminateProcessTree(options: TerminateProcessTreeOptions): Promise<void> {
+	const { pid, childProcess, isCompleted, gracefulTimeoutMs = 2000 } = options
+
+	// Send SIGTERM for graceful shutdown
+	treeKill(pid, "SIGTERM")
+
+	// Wait for graceful shutdown or timeout
+	const gracefulTimeout = new Promise<void>((resolve) => setTimeout(resolve, gracefulTimeoutMs))
+	const processExit = new Promise<void>((resolve) => {
+		if (childProcess) {
+			childProcess.once("exit", () => resolve())
+		} else {
+			// No child process reference, just wait for timeout
+			resolve()
+		}
+	})
+
+	await Promise.race([processExit, gracefulTimeout])
+
+	// Force kill if still running
+	if (!isCompleted()) {
+		treeKill(pid, "SIGKILL")
+	}
+}
diff --git a/apps/vscode/src/utils/retry.ts b/apps/vscode/src/utils/retry.ts
new file mode 100644
index 0000000..c15a917
--- /dev/null
+++ b/apps/vscode/src/utils/retry.ts
@@ -0,0 +1,29 @@
+/**
+ * TypeScript equivalent of the Go common.RetryOperation utility
+ * Performs an operation with retry logic and timeout handling
+ */
+export async function retryOperation<T>(maxRetries: number, timeoutPerAttempt: number, operation: () => Promise<T>): Promise<T> {
+	let lastError: Error | undefined
+
+	for (let attempt = 1; attempt <= maxRetries; attempt++) {
+		try {
+			// Create a timeout promise
+			const timeoutPromise = new Promise<never>((_, reject) =>
+				setTimeout(() => reject(new Error("Operation timeout")), timeoutPerAttempt),
+			)
+
+			// Race the operation against timeout
+			const result = await Promise.race([operation(), timeoutPromise])
+			return result // Success - return result
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error))
+
+			if (attempt < maxRetries) {
+				// Brief delay before retry
+				await new Promise((resolve) => setTimeout(resolve, 500))
+			}
+		}
+	}
+
+	throw new Error(`Operation failed after ${maxRetries} attempts: ${lastError?.message}`)
+}
diff --git a/apps/vscode/src/utils/shell.ts b/apps/vscode/src/utils/shell.ts
new file mode 100644
index 0000000..7f1680b
--- /dev/null
+++ b/apps/vscode/src/utils/shell.ts
@@ -0,0 +1,343 @@
+import { userInfo } from "os"
+import * as vscode from "vscode"
+
+export const WINDOWS_POWERSHELL_7_PATH = "C:\\Program Files\\PowerShell\\7\\pwsh.exe"
+export const WINDOWS_POWERSHELL_LEGACY_PATH = "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe"
+
+const SHELL_PATHS = {
+	// Windows paths
+	POWERSHELL_7: WINDOWS_POWERSHELL_7_PATH,
+	POWERSHELL_LEGACY: WINDOWS_POWERSHELL_LEGACY_PATH,
+	CMD: "C:\\Windows\\System32\\cmd.exe",
+	WSL_BASH: "/bin/bash",
+	GIT_BASH: "C:\\Program Files\\Git\\bin\\bash.exe",
+	// Unix paths
+	MAC_DEFAULT: "/bin/zsh",
+	LINUX_DEFAULT: "/bin/bash",
+	CSH: "/bin/csh",
+	BASH: "/bin/bash",
+	KSH: "/bin/ksh",
+	SH: "/bin/sh",
+	ZSH: "/bin/zsh",
+	DASH: "/bin/dash",
+	TCSH: "/bin/tcsh",
+	FALLBACK: "/bin/sh",
+} as const
+
+interface MacTerminalProfile {
+	path?: string
+}
+
+type MacTerminalProfiles = Record<string, MacTerminalProfile>
+
+interface WindowsTerminalProfile {
+	path?: string
+	source?: "PowerShell" | "WSL"
+}
+
+type WindowsTerminalProfiles = Record<string, WindowsTerminalProfile>
+
+interface LinuxTerminalProfile {
+	path?: string
+}
+
+type LinuxTerminalProfiles = Record<string, LinuxTerminalProfile>
+
+// -----------------------------------------------------
+// 1) VS Code Terminal Configuration Helpers
+// -----------------------------------------------------
+
+function getWindowsTerminalConfig() {
+	try {
+		const config = vscode.workspace.getConfiguration("terminal.integrated")
+		const defaultProfileName = config.get<string>("defaultProfile.windows")
+		const profiles = config.get<WindowsTerminalProfiles>("profiles.windows") || {}
+		return { defaultProfileName, profiles }
+	} catch {
+		return { defaultProfileName: null, profiles: {} as WindowsTerminalProfiles }
+	}
+}
+
+function getMacTerminalConfig() {
+	try {
+		const config = vscode.workspace.getConfiguration("terminal.integrated")
+		const defaultProfileName = config.get<string>("defaultProfile.osx")
+		const profiles = config.get<MacTerminalProfiles>("profiles.osx") || {}
+		return { defaultProfileName, profiles }
+	} catch {
+		return { defaultProfileName: null, profiles: {} as MacTerminalProfiles }
+	}
+}
+
+function getLinuxTerminalConfig() {
+	try {
+		const config = vscode.workspace.getConfiguration("terminal.integrated")
+		const defaultProfileName = config.get<string>("defaultProfile.linux")
+		const profiles = config.get<LinuxTerminalProfiles>("profiles.linux") || {}
+		return { defaultProfileName, profiles }
+	} catch {
+		return { defaultProfileName: null, profiles: {} as LinuxTerminalProfiles }
+	}
+}
+
+// -----------------------------------------------------
+// 2) Platform-Specific VS Code Shell Retrieval
+// -----------------------------------------------------
+
+/** Attempts to retrieve a shell path from VS Code config on Windows. */
+function getWindowsShellFromVSCode(): string | null {
+	const { defaultProfileName, profiles } = getWindowsTerminalConfig()
+	if (!defaultProfileName) {
+		return null
+	}
+
+	const profile = profiles[defaultProfileName]
+
+	// If the profile name indicates PowerShell, do version-based detection.
+	// In testing it was found these typically do not have a path, and this
+	// implementation manages to deductively get the correct version of PowerShell
+	if (defaultProfileName.toLowerCase().includes("powershell")) {
+		if (profile?.path) {
+			// If there's an explicit PowerShell path, return that
+			return profile.path
+		} else if (profile?.source === "PowerShell") {
+			// If the profile is sourced from PowerShell, assume the newest
+			return SHELL_PATHS.POWERSHELL_7
+		}
+		// Otherwise, assume legacy Windows PowerShell
+		return SHELL_PATHS.POWERSHELL_LEGACY
+	}
+
+	// If there's a specific path, return that immediately
+	if (profile?.path) {
+		return profile.path
+	}
+
+	// If the profile indicates WSL
+	if (profile?.source === "WSL" || defaultProfileName.toLowerCase().includes("wsl")) {
+		return SHELL_PATHS.WSL_BASH
+	}
+
+	// If nothing special detected, we assume cmd
+	return SHELL_PATHS.CMD
+}
+
+/** Attempts to retrieve a shell path from VS Code config on macOS. */
+function getMacShellFromVSCode(): string | null {
+	const { defaultProfileName, profiles } = getMacTerminalConfig()
+	if (!defaultProfileName) {
+		return null
+	}
+
+	const profile = profiles[defaultProfileName]
+	return profile?.path || null
+}
+
+/** Attempts to retrieve a shell path from VS Code config on Linux. */
+function getLinuxShellFromVSCode(): string | null {
+	const { defaultProfileName, profiles } = getLinuxTerminalConfig()
+	if (!defaultProfileName) {
+		return null
+	}
+
+	const profile = profiles[defaultProfileName]
+	return profile?.path || null
+}
+
+// -----------------------------------------------------
+// 3) General Fallback Helpers
+// -----------------------------------------------------
+
+/**
+ * Tries to get a user’s shell from os.userInfo() (works on Unix if the
+ * underlying system call is supported). Returns null on error or if not found.
+ */
+function getShellFromUserInfo(): string | null {
+	try {
+		const { shell } = userInfo()
+		return shell || null
+	} catch {
+		return null
+	}
+}
+
+/** Returns the environment-based shell variable, or null if not set. */
+function getShellFromEnv(): string | null {
+	const { env } = process
+
+	if (process.platform === "win32") {
+		// On Windows, COMSPEC typically holds cmd.exe
+		return env.COMSPEC || "C:\\Windows\\System32\\cmd.exe"
+	}
+
+	if (process.platform === "darwin") {
+		// On macOS/Linux, SHELL is commonly the environment variable
+		return env.SHELL || "/bin/zsh"
+	}
+
+	if (process.platform === "linux") {
+		// On Linux, SHELL is commonly the environment variable
+		return env.SHELL || "/bin/bash"
+	}
+	return null
+}
+
+// -----------------------------------------------------
+// 4) Terminal Profile Interface and Utilities
+// -----------------------------------------------------
+
+import { TerminalProfile } from "@shared/proto/cline/state"
+
+/** Gets available terminal profiles for the current platform */
+export function getAvailableTerminalProfiles(): TerminalProfile[] {
+	const profiles: TerminalProfile[] = [
+		{
+			id: "default",
+			name: "Default",
+			description: "Use VSCode's default terminal configuration",
+		},
+	]
+
+	if (process.platform === "win32") {
+		// Windows terminal profiles
+		profiles.push(
+			{
+				id: "powershell-7",
+				name: "PowerShell 7",
+				path: SHELL_PATHS.POWERSHELL_7,
+				description: "PowerShell 7 (pwsh.exe)",
+			},
+			{
+				id: "powershell-legacy",
+				name: "Windows PowerShell",
+				path: SHELL_PATHS.POWERSHELL_LEGACY,
+				description: "Windows PowerShell 5.x",
+			},
+			{
+				id: "cmd",
+				name: "Command Prompt",
+				path: SHELL_PATHS.CMD,
+				description: "Command Prompt (cmd.exe)",
+			},
+			{
+				id: "wsl-bash",
+				name: "WSL Bash",
+				path: SHELL_PATHS.WSL_BASH,
+				description: "Windows Subsystem for Linux Bash",
+			},
+			{
+				id: "git-bash",
+				name: "Git Bash",
+				path: SHELL_PATHS.GIT_BASH,
+				description: "Git Bash (bash.exe from Git for Windows)",
+			},
+		)
+	} else if (process.platform === "darwin") {
+		// macOS terminal profiles
+		profiles.push(
+			{
+				id: "zsh",
+				name: "zsh",
+				path: SHELL_PATHS.ZSH,
+				description: "Z shell (default on macOS)",
+			},
+			{
+				id: "bash",
+				name: "bash",
+				path: SHELL_PATHS.BASH,
+				description: "Bourne Again Shell",
+			},
+		)
+	} else if (process.platform === "linux") {
+		// Linux terminal profiles
+		profiles.push(
+			{
+				id: "bash",
+				name: "bash",
+				path: SHELL_PATHS.BASH,
+				description: "Bourne Again Shell (default on most Linux)",
+			},
+			{
+				id: "zsh",
+				name: "zsh",
+				path: SHELL_PATHS.ZSH,
+				description: "Z shell",
+			},
+			{
+				id: "dash",
+				name: "dash",
+				path: SHELL_PATHS.DASH,
+				description: "Debian Almquist Shell",
+			},
+		)
+	}
+
+	return profiles
+}
+
+/** Gets the shell path for a specific terminal profile */
+export function getShellForProfile(profileId: string): string {
+	// If it's the default profile, use the existing getShell() logic
+	if (profileId === "default") {
+		return getShell()
+	}
+
+	// Find the profile
+	const profiles = getAvailableTerminalProfiles()
+	const profile = profiles.find((p) => p.id === profileId)
+
+	if (profile?.path) {
+		return profile.path
+	}
+
+	// Fallback to default shell if profile not found
+	return getShell()
+}
+
+// -----------------------------------------------------
+// 5) Publicly Exposed Shell Getter
+// -----------------------------------------------------
+
+export function getShell(): string {
+	// 1. Check VS Code config first.
+	if (process.platform === "win32") {
+		// Special logic for Windows
+		const windowsShell = getWindowsShellFromVSCode()
+		if (windowsShell) {
+			return windowsShell
+		}
+	} else if (process.platform === "darwin") {
+		// macOS from VS Code
+		const macShell = getMacShellFromVSCode()
+		if (macShell) {
+			return macShell
+		}
+	} else if (process.platform === "linux") {
+		// Linux from VS Code
+		const linuxShell = getLinuxShellFromVSCode()
+		if (linuxShell) {
+			return linuxShell
+		}
+	}
+
+	// 2. If no shell from VS Code, try userInfo()
+	const userInfoShell = getShellFromUserInfo()
+	if (userInfoShell) {
+		return userInfoShell
+	}
+
+	// 3. If still nothing, try environment variable
+	const envShell = getShellFromEnv()
+	if (envShell) {
+		return envShell
+	}
+
+	// 4. Finally, fall back to a default
+	if (process.platform === "win32") {
+		// On Windows, if we got here, we have no config, no COMSPEC, and one very messed up operating system.
+		// Use CMD as a last resort
+		return SHELL_PATHS.CMD
+	}
+	// On macOS/Linux, fallback to a POSIX shell - This is the behavior of our old shell detection method.
+	return SHELL_PATHS.FALLBACK
+}
diff --git a/apps/vscode/src/utils/storage.ts b/apps/vscode/src/utils/storage.ts
new file mode 100644
index 0000000..f3de93c
--- /dev/null
+++ b/apps/vscode/src/utils/storage.ts
@@ -0,0 +1,22 @@
+import getFolderSize from "get-folder-size"
+import path from "path"
+import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+
+/**
+ * Gets the total size of tasks and checkpoints directories
+ * @returns The total size in bytes, or null if calculation fails
+ */
+export async function getTotalTasksSize(): Promise<number | null> {
+	const tasksDir = path.resolve(HostProvider.get().globalStorageFsPath, "tasks")
+	const checkpointsDir = path.resolve(HostProvider.get().globalStorageFsPath, "checkpoints")
+
+	try {
+		const tasksSize = await getFolderSize.loose(tasksDir)
+		const checkpointsSize = await getFolderSize.loose(checkpointsDir)
+		return tasksSize + checkpointsSize
+	} catch (error) {
+		Logger.error("Failed to calculate total task size:", error)
+		return null
+	}
+}
diff --git a/apps/vscode/src/utils/time.ts b/apps/vscode/src/utils/time.ts
new file mode 100644
index 0000000..316ea5a
--- /dev/null
+++ b/apps/vscode/src/utils/time.ts
@@ -0,0 +1,3 @@
+export function secondsToMs(seconds: number): number {
+	return seconds * 1000
+}
diff --git a/apps/vscode/src/utils/worktree-include.test.ts b/apps/vscode/src/utils/worktree-include.test.ts
new file mode 100644
index 0000000..8886c12
--- /dev/null
+++ b/apps/vscode/src/utils/worktree-include.test.ts
@@ -0,0 +1,139 @@
+import { after, describe, it } from "mocha"
+import * as fs from "fs/promises"
+import * as os from "os"
+import * as path from "path"
+import "should"
+import { copyWorktreeIncludeFiles, hasWorktreeInclude } from "./worktree-include"
+
+describe("Worktree Include Utilities", () => {
+	const tmpDir = path.join(os.tmpdir(), "cline-worktree-test-" + Math.random().toString(36).slice(2))
+	const sourceDir = path.join(tmpDir, "source")
+	const targetDir = path.join(tmpDir, "target")
+
+	// Clean up after tests
+	after(async () => {
+		try {
+			await fs.rm(tmpDir, { recursive: true, force: true })
+		} catch {
+			// Ignore cleanup errors
+		}
+	})
+
+	describe("hasWorktreeInclude", () => {
+		it("should return true when .worktreeinclude exists", async () => {
+			const testDir = path.join(tmpDir, "has-include")
+			await fs.mkdir(testDir, { recursive: true })
+			await fs.writeFile(path.join(testDir, ".worktreeinclude"), "node_modules/")
+
+			const result = await hasWorktreeInclude(testDir)
+			result.should.be.true()
+		})
+
+		it("should return false when .worktreeinclude does not exist", async () => {
+			const testDir = path.join(tmpDir, "no-include")
+			await fs.mkdir(testDir, { recursive: true })
+
+			const result = await hasWorktreeInclude(testDir)
+			result.should.be.false()
+		})
+	})
+
+	describe("copyWorktreeIncludeFiles", () => {
+		it("should return empty result when no .worktreeinclude file exists", async () => {
+			const src = path.join(tmpDir, "no-worktreeinclude-src")
+			const tgt = path.join(tmpDir, "no-worktreeinclude-tgt")
+			await fs.mkdir(src, { recursive: true })
+			await fs.mkdir(tgt, { recursive: true })
+
+			const result = await copyWorktreeIncludeFiles(src, tgt)
+			result.copiedCount.should.equal(0)
+			result.errors.should.be.empty()
+		})
+
+		it("should return empty result when no .gitignore file exists", async () => {
+			const src = path.join(tmpDir, "no-gitignore-src")
+			const tgt = path.join(tmpDir, "no-gitignore-tgt")
+			await fs.mkdir(src, { recursive: true })
+			await fs.mkdir(tgt, { recursive: true })
+			await fs.writeFile(path.join(src, ".worktreeinclude"), "node_modules/")
+
+			const result = await copyWorktreeIncludeFiles(src, tgt)
+			result.copiedCount.should.equal(0)
+			result.errors.should.be.empty()
+		})
+
+		it("should copy individual files matching both patterns", async () => {
+			const src = path.join(tmpDir, "file-copy-src")
+			const tgt = path.join(tmpDir, "file-copy-tgt")
+
+			// Setup source with files
+			await fs.mkdir(src, { recursive: true })
+			await fs.mkdir(tgt, { recursive: true })
+			await fs.writeFile(path.join(src, ".worktreeinclude"), "*.log\nbuild/")
+			await fs.writeFile(path.join(src, ".gitignore"), "*.log\nbuild/")
+			await fs.writeFile(path.join(src, "test.log"), "log content")
+			await fs.writeFile(path.join(src, "test.txt"), "txt content") // Should not be copied
+
+			const result = await copyWorktreeIncludeFiles(src, tgt)
+
+			result.copiedCount.should.equal(1)
+			result.errors.should.be.empty()
+
+			// Verify the log file was copied
+			const logExists = await fs.access(path.join(tgt, "test.log")).then(
+				() => true,
+				() => false,
+			)
+			logExists.should.be.true()
+
+			// Verify the txt file was NOT copied
+			const txtExists = await fs.access(path.join(tgt, "test.txt")).then(
+				() => true,
+				() => false,
+			)
+			txtExists.should.be.false()
+		})
+
+		it("should copy entire directories using native cp", async () => {
+			const src = path.join(tmpDir, "dir-copy-src")
+			const tgt = path.join(tmpDir, "dir-copy-tgt")
+
+			// Setup source with directory
+			await fs.mkdir(path.join(src, "node_modules", "pkg"), { recursive: true })
+			await fs.mkdir(tgt, { recursive: true })
+			await fs.writeFile(path.join(src, ".worktreeinclude"), "node_modules/")
+			await fs.writeFile(path.join(src, ".gitignore"), "node_modules/")
+			await fs.writeFile(path.join(src, "node_modules", "pkg", "index.js"), "module code")
+			await fs.writeFile(path.join(src, "node_modules", "file.txt"), "file in node_modules")
+
+			const result = await copyWorktreeIncludeFiles(src, tgt)
+
+			result.copiedCount.should.be.greaterThan(0)
+			result.errors.should.be.empty()
+
+			// Verify the directory was copied
+			const pkgExists = await fs.access(path.join(tgt, "node_modules", "pkg", "index.js")).then(
+				() => true,
+				() => false,
+			)
+			pkgExists.should.be.true()
+		})
+
+		it("should only copy files that are in both .worktreeinclude AND .gitignore", async () => {
+			const src = path.join(tmpDir, "intersection-src")
+			const tgt = path.join(tmpDir, "intersection-tgt")
+
+			await fs.mkdir(src, { recursive: true })
+			await fs.mkdir(tgt, { recursive: true })
+			await fs.writeFile(path.join(src, ".worktreeinclude"), "*.log")
+			await fs.writeFile(path.join(src, ".gitignore"), "*.tmp") // Different pattern
+			await fs.writeFile(path.join(src, "test.log"), "log")
+			await fs.writeFile(path.join(src, "test.tmp"), "tmp")
+
+			const result = await copyWorktreeIncludeFiles(src, tgt)
+
+			// Neither file should be copied since there's no intersection
+			result.copiedCount.should.equal(0)
+		})
+	})
+})
diff --git a/apps/vscode/src/utils/worktree-include.ts b/apps/vscode/src/utils/worktree-include.ts
new file mode 100644
index 0000000..5e58185
--- /dev/null
+++ b/apps/vscode/src/utils/worktree-include.ts
@@ -0,0 +1,253 @@
+import { exec } from "child_process"
+import * as fs from "fs/promises"
+import ignore from "ignore"
+import * as path from "path"
+import { promisify } from "util"
+
+const execAsync = promisify(exec)
+
+/** Batch size for parallel file operations */
+const COPY_BATCH_SIZE = 100
+
+/**
+ * Parses a .gitignore-style file and returns the patterns
+ */
+async function parseIgnoreFile(filePath: string): Promise<string[]> {
+	try {
+		const content = await fs.readFile(filePath, "utf-8")
+		return content
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line && !line.startsWith("#"))
+	} catch {
+		return []
+	}
+}
+
+/**
+ * Check if a pattern represents a directory (ends with / or is a bare name that exists as a directory)
+ */
+async function isDirectoryPattern(sourceDir: string, pattern: string): Promise<string | null> {
+	// Normalize pattern - remove trailing slash
+	const cleanPattern = pattern.replace(/\/$/, "")
+
+	// Skip patterns with wildcards - these need file-by-file matching
+	if (cleanPattern.includes("*") || cleanPattern.includes("?") || cleanPattern.includes("[")) {
+		return null
+	}
+
+	// Check if this is a top-level directory
+	const dirPath = path.join(sourceDir, cleanPattern)
+	try {
+		const stat = await fs.stat(dirPath)
+		if (stat.isDirectory()) {
+			return cleanPattern
+		}
+	} catch {
+		// Path doesn't exist or can't be accessed
+	}
+
+	return null
+}
+
+/**
+ * Copy a directory using native cp -r (much faster than recursive Node.js copy)
+ */
+async function copyDirectoryNative(source: string, target: string): Promise<void> {
+	// Create parent directory if needed
+	await fs.mkdir(path.dirname(target), { recursive: true })
+
+	// Use native cp for performance (10-20x faster than Node.js)
+	const isWindows = process.platform === "win32"
+	if (isWindows) {
+		// Windows: use robocopy or xcopy
+		await execAsync(`xcopy "${source}" "${target}" /E /I /H /Y /Q`)
+	} else {
+		// Unix: use cp -r
+		await execAsync(`cp -r "${source}" "${target}"`)
+	}
+}
+
+/**
+ * Recursively gets all files in a directory (parallelized)
+ */
+async function getAllFiles(dir: string, baseDir: string): Promise<string[]> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+
+		const results = await Promise.all(
+			entries.map(async (entry) => {
+				const fullPath = path.join(dir, entry.name)
+				const relativePath = path.relative(baseDir, fullPath)
+
+				if (entry.isDirectory()) {
+					// Skip .git directory
+					if (entry.name === ".git") return []
+					return getAllFiles(fullPath, baseDir)
+				} else {
+					return [relativePath]
+				}
+			}),
+		)
+
+		return results.flat()
+	} catch {
+		// Directory doesn't exist or can't be read
+		return []
+	}
+}
+
+/**
+ * Copy files in parallel batches
+ */
+async function copyFilesInBatches(
+	files: string[],
+	sourceDir: string,
+	targetDir: string,
+): Promise<{ copiedCount: number; errors: string[] }> {
+	const errors: string[] = []
+	let copiedCount = 0
+
+	// Process in batches for controlled parallelism
+	for (let i = 0; i < files.length; i += COPY_BATCH_SIZE) {
+		const batch = files.slice(i, i + COPY_BATCH_SIZE)
+
+		const results = await Promise.allSettled(
+			batch.map(async (file) => {
+				const sourcePath = path.join(sourceDir, file)
+				const targetPath = path.join(targetDir, file)
+
+				// Create target directory if it doesn't exist
+				await fs.mkdir(path.dirname(targetPath), { recursive: true })
+
+				// Copy the file
+				await fs.copyFile(sourcePath, targetPath)
+				return file
+			}),
+		)
+
+		for (const result of results) {
+			if (result.status === "fulfilled") {
+				copiedCount++
+			} else {
+				errors.push(result.reason?.message || "Unknown error")
+			}
+		}
+	}
+
+	return { copiedCount, errors }
+}
+
+/**
+ * Copies files matched by .worktreeinclude patterns that are also in .gitignore.
+ * Uses optimized strategies for performance:
+ * - Native cp -r for entire directories (10-20x faster)
+ * - Parallel file copying with batches (5-10x faster)
+ *
+ * @param sourceDir The source worktree directory (original repo)
+ * @param targetDir The target worktree directory (newly created)
+ * @returns Object with copied files count and any errors
+ */
+export async function copyWorktreeIncludeFiles(
+	sourceDir: string,
+	targetDir: string,
+): Promise<{ copiedCount: number; errors: string[] }> {
+	const errors: string[] = []
+	let copiedCount = 0
+
+	// Read .worktreeinclude file
+	const worktreeIncludePath = path.join(sourceDir, ".worktreeinclude")
+	const includePatterns = await parseIgnoreFile(worktreeIncludePath)
+
+	if (includePatterns.length === 0) {
+		return { copiedCount: 0, errors: [] }
+	}
+
+	// Read .gitignore file
+	const gitignorePath = path.join(sourceDir, ".gitignore")
+	const gitignorePatterns = await parseIgnoreFile(gitignorePath)
+
+	if (gitignorePatterns.length === 0) {
+		return { copiedCount: 0, errors: [] }
+	}
+
+	// Create ignore matchers
+	const includeMatcher = ignore().add(includePatterns)
+	const gitignoreMatcher = ignore().add(gitignorePatterns)
+
+	// Separate patterns into directory patterns and file patterns
+	const directoryPatterns: string[] = []
+	const filePatterns: string[] = []
+
+	for (const pattern of includePatterns) {
+		const dirName = await isDirectoryPattern(sourceDir, pattern)
+		if (dirName) {
+			// Verify the directory is also gitignored
+			if (gitignoreMatcher.ignores(dirName) || gitignoreMatcher.ignores(dirName + "/")) {
+				directoryPatterns.push(dirName)
+			}
+		} else {
+			filePatterns.push(pattern)
+		}
+	}
+
+	// Handle directory patterns with native cp -r (fast path)
+	for (const dir of directoryPatterns) {
+		const sourcePath = path.join(sourceDir, dir)
+		const targetPath = path.join(targetDir, dir)
+
+		try {
+			await copyDirectoryNative(sourcePath, targetPath)
+			// Count files in the copied directory
+			const files = await getAllFiles(sourcePath, sourcePath)
+			copiedCount += files.length
+		} catch (error) {
+			errors.push(`Failed to copy directory ${dir}: ${error instanceof Error ? error.message : String(error)}`)
+		}
+	}
+
+	// Handle file patterns with parallel copying (if any remain)
+	if (filePatterns.length > 0) {
+		// Create matcher for just file patterns
+		const fileMatcher = ignore().add(filePatterns)
+
+		// Get all files, excluding already-copied directories
+		const dirSet = new Set(directoryPatterns)
+		const allFiles = await getAllFiles(sourceDir, sourceDir)
+
+		// Filter files that:
+		// 1. Are not in already-copied directories
+		// 2. Match file patterns
+		// 3. Are gitignored
+		const filesToCopy = allFiles.filter((file) => {
+			// Skip if in an already-copied directory
+			const topDir = file.split(path.sep)[0]
+			if (dirSet.has(topDir)) return false
+
+			// Must match both file patterns and gitignore
+			const isIncluded = fileMatcher.ignores(file) || includeMatcher.ignores(file)
+			const isGitignored = gitignoreMatcher.ignores(file)
+			return isIncluded && isGitignored
+		})
+
+		if (filesToCopy.length > 0) {
+			const result = await copyFilesInBatches(filesToCopy, sourceDir, targetDir)
+			copiedCount += result.copiedCount
+			errors.push(...result.errors)
+		}
+	}
+
+	return { copiedCount, errors }
+}
+
+/**
+ * Checks if a .worktreeinclude file exists in the given directory
+ */
+export async function hasWorktreeInclude(dir: string): Promise<boolean> {
+	try {
+		await fs.access(path.join(dir, ".worktreeinclude"))
+		return true
+	} catch {
+		return false
+	}
+}
diff --git a/apps/vscode/standalone/runtime-files/package-lock.json b/apps/vscode/standalone/runtime-files/package-lock.json
new file mode 100644
index 0000000..2141428
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/package-lock.json
@@ -0,0 +1,984 @@
+{
+	"name": "cline-core",
+	"version": "0.0.1",
+	"lockfileVersion": 3,
+	"requires": true,
+	"packages": {
+		"": {
+			"name": "cline-core",
+			"version": "0.0.1",
+			"dependencies": {
+				"@grpc/grpc-js": "^1.13.3",
+				"@grpc/reflection": "^1.0.4",
+				"better-sqlite3": "^12.4.1",
+				"grpc-health-check": "^2.0.2",
+				"open": "^10.1.2",
+				"vscode-uri": "^3.1.0"
+			}
+		},
+		"node_modules/@grpc/grpc-js": {
+			"version": "1.13.3",
+			"resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.13.3.tgz",
+			"integrity": "sha512-FTXHdOoPbZrBjlVLHuKbDZnsTxXv2BlHF57xw6LuThXacXvtkahEPED0CKMk6obZDf65Hv4k3z62eyPNpvinIg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@grpc/proto-loader": "^0.7.13",
+				"@js-sdsl/ordered-map": "^4.4.2"
+			},
+			"engines": {
+				"node": ">=12.10.0"
+			}
+		},
+		"node_modules/@grpc/proto-loader": {
+			"version": "0.7.15",
+			"resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.15.tgz",
+			"integrity": "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"lodash.camelcase": "^4.3.0",
+				"long": "^5.0.0",
+				"protobufjs": "^7.2.5",
+				"yargs": "^17.7.2"
+			},
+			"bin": {
+				"proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/@grpc/reflection": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@grpc/reflection/-/reflection-1.0.4.tgz",
+			"integrity": "sha512-znA8v4AviOD3OPOxy11pxrtP8k8DanpefeTymS8iGW1fVr1U2cHuzfhYqDPHnVNDf4qvF9E25KtSihPy2DBWfQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@grpc/proto-loader": "^0.7.13",
+				"protobufjs": "^7.2.5"
+			},
+			"peerDependencies": {
+				"@grpc/grpc-js": "^1.8.21"
+			}
+		},
+		"node_modules/@js-sdsl/ordered-map": {
+			"version": "4.4.2",
+			"resolved": "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz",
+			"integrity": "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==",
+			"license": "MIT",
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/js-sdsl"
+			}
+		},
+		"node_modules/@protobufjs/aspromise": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+			"integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/base64": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+			"integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/codegen": {
+			"version": "2.0.5",
+			"resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
+			"integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/eventemitter": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+			"integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/fetch": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+			"integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"@protobufjs/aspromise": "^1.1.1",
+				"@protobufjs/inquire": "^1.1.0"
+			}
+		},
+		"node_modules/@protobufjs/float": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+			"integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/inquire": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.2.tgz",
+			"integrity": "sha512-pa0vFRuws4wkvaXKK1uXZMAwAX4/t8ANaJo45iw/oQHNQ9q5xUzwgFmVJGXiga2BeN+zpX7Vf9vmsiIa2J+MUw==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/path": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+			"integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/pool": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+			"integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@protobufjs/utf8": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.1.tgz",
+			"integrity": "sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@types/node": {
+			"version": "22.15.18",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.18.tgz",
+			"integrity": "sha512-v1DKRfUdyW+jJhZNEI1PYy29S2YRxMV5AOO/x/SjKmW0acCIOqmbj6Haf9eHAhsPmrhlHSxEhv/1WszcLWV4cg==",
+			"license": "MIT",
+			"dependencies": {
+				"undici-types": "~6.21.0"
+			}
+		},
+		"node_modules/ansi-regex": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/ansi-styles": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+			"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+			"license": "MIT",
+			"dependencies": {
+				"color-convert": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-styles?sponsor=1"
+			}
+		},
+		"node_modules/b4a": {
+			"version": "1.7.3",
+			"resolved": "https://registry.npmjs.org/b4a/-/b4a-1.7.3.tgz",
+			"integrity": "sha512-5Q2mfq2WfGuFp3uS//0s6baOJLMoVduPYVeNmDYxu5OUA1/cBfvr2RIS7vi62LdNj/urk1hfmj867I3qt6uZ7Q==",
+			"license": "Apache-2.0",
+			"peerDependencies": {
+				"react-native-b4a": "*"
+			},
+			"peerDependenciesMeta": {
+				"react-native-b4a": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-events": {
+			"version": "2.8.0",
+			"resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.0.tgz",
+			"integrity": "sha512-AOhh6Bg5QmFIXdViHbMc2tLDsBIRxdkIaIddPslJF9Z5De3APBScuqGP2uThXnIpqFrgoxMNC6km7uXNIMLHXA==",
+			"license": "Apache-2.0",
+			"peerDependencies": {
+				"bare-abort-controller": "*"
+			},
+			"peerDependenciesMeta": {
+				"bare-abort-controller": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-fs": {
+			"version": "4.4.11",
+			"resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.4.11.tgz",
+			"integrity": "sha512-Bejmm9zRMvMTRoHS+2adgmXw1ANZnCNx+B5dgZpGwlP1E3x6Yuxea8RToddHUbWtVV0iUMWqsgZr8+jcgUI2SA==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"bare-events": "^2.5.4",
+				"bare-path": "^3.0.0",
+				"bare-stream": "^2.6.4",
+				"bare-url": "^2.2.2",
+				"fast-fifo": "^1.3.2"
+			},
+			"engines": {
+				"bare": ">=1.16.0"
+			},
+			"peerDependencies": {
+				"bare-buffer": "*"
+			},
+			"peerDependenciesMeta": {
+				"bare-buffer": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-os": {
+			"version": "3.6.2",
+			"resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+			"integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"engines": {
+				"bare": ">=1.14.0"
+			}
+		},
+		"node_modules/bare-path": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+			"integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"bare-os": "^3.0.1"
+			}
+		},
+		"node_modules/bare-stream": {
+			"version": "2.7.0",
+			"resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+			"integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"streamx": "^2.21.0"
+			},
+			"peerDependencies": {
+				"bare-buffer": "*",
+				"bare-events": "*"
+			},
+			"peerDependenciesMeta": {
+				"bare-buffer": {
+					"optional": true
+				},
+				"bare-events": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-url": {
+			"version": "2.3.1",
+			"resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.3.1.tgz",
+			"integrity": "sha512-v2yl0TnaZTdEnelkKtXZGnotiV6qATBlnNuUMrHl6v9Lmmrh9mw9RYyImPU7/4RahumSwQS1k2oKXcRfXcbjJw==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"bare-path": "^3.0.0"
+			}
+		},
+		"node_modules/better-sqlite3": {
+			"version": "12.4.1",
+			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
+			"integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
+			"hasInstallScript": true,
+			"license": "MIT",
+			"dependencies": {
+				"bindings": "^1.5.0",
+				"prebuild-install": "^7.1.1"
+			},
+			"engines": {
+				"node": "20.x || 22.x || 23.x || 24.x"
+			}
+		},
+		"node_modules/bindings": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+			"integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+			"license": "MIT",
+			"dependencies": {
+				"file-uri-to-path": "1.0.0"
+			}
+		},
+		"node_modules/bundle-name": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz",
+			"integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
+			"license": "MIT",
+			"dependencies": {
+				"run-applescript": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cliui": {
+			"version": "8.0.1",
+			"resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+			"integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+			"license": "ISC",
+			"dependencies": {
+				"string-width": "^4.2.0",
+				"strip-ansi": "^6.0.1",
+				"wrap-ansi": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/color-convert": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+			"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+			"license": "MIT",
+			"dependencies": {
+				"color-name": "~1.1.4"
+			},
+			"engines": {
+				"node": ">=7.0.0"
+			}
+		},
+		"node_modules/color-name": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+			"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+			"license": "MIT"
+		},
+		"node_modules/decompress-response": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+			"integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+			"license": "MIT",
+			"dependencies": {
+				"mimic-response": "^3.1.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/deep-extend": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+			"integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=4.0.0"
+			}
+		},
+		"node_modules/default-browser": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz",
+			"integrity": "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==",
+			"license": "MIT",
+			"dependencies": {
+				"bundle-name": "^4.1.0",
+				"default-browser-id": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/default-browser-id": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.0.tgz",
+			"integrity": "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/define-lazy-prop": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
+			"integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/detect-libc": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+			"integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/emoji-regex": {
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+			"license": "MIT"
+		},
+		"node_modules/end-of-stream": {
+			"version": "1.4.5",
+			"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+			"integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+			"license": "MIT",
+			"dependencies": {
+				"once": "^1.4.0"
+			}
+		},
+		"node_modules/escalade": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+			"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/events-universal": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
+			"integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"bare-events": "^2.7.0"
+			}
+		},
+		"node_modules/expand-template": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
+			"integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==",
+			"license": "(MIT OR WTFPL)",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/fast-fifo": {
+			"version": "1.3.2",
+			"resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+			"integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+			"license": "MIT"
+		},
+		"node_modules/file-uri-to-path": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+			"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==",
+			"license": "MIT"
+		},
+		"node_modules/get-caller-file": {
+			"version": "2.0.5",
+			"resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+			"integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+			"license": "ISC",
+			"engines": {
+				"node": "6.* || 8.* || >= 10.*"
+			}
+		},
+		"node_modules/github-from-package": {
+			"version": "0.0.0",
+			"resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
+			"integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==",
+			"license": "MIT"
+		},
+		"node_modules/grpc-health-check": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/grpc-health-check/-/grpc-health-check-2.0.2.tgz",
+			"integrity": "sha512-5XKOdg/gIlTsZZR+8QJjzmW2CHBnn+NfM8zevIpzg+96i9dAuoH+Guu/L/5vuUkSbVZG69wVPnLpEnW+Smon1A==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@grpc/proto-loader": "^0.7.13"
+			}
+		},
+		"node_modules/ini": {
+			"version": "1.3.8",
+			"resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+			"integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+			"license": "ISC"
+		},
+		"node_modules/is-docker": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz",
+			"integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==",
+			"license": "MIT",
+			"bin": {
+				"is-docker": "cli.js"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-fullwidth-code-point": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+			"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/is-inside-container": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz",
+			"integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==",
+			"license": "MIT",
+			"dependencies": {
+				"is-docker": "^3.0.0"
+			},
+			"bin": {
+				"is-inside-container": "cli.js"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-wsl": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz",
+			"integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==",
+			"license": "MIT",
+			"dependencies": {
+				"is-inside-container": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/lodash.camelcase": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
+			"integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==",
+			"license": "MIT"
+		},
+		"node_modules/long": {
+			"version": "5.3.2",
+			"resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+			"integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/mimic-response": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+			"integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/minimist": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+			"integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/mkdirp-classic": {
+			"version": "0.5.3",
+			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
+			"integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==",
+			"license": "MIT"
+		},
+		"node_modules/napi-build-utils": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz",
+			"integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==",
+			"license": "MIT"
+		},
+		"node_modules/node-abi": {
+			"version": "3.77.0",
+			"resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.77.0.tgz",
+			"integrity": "sha512-DSmt0OEcLoK4i3NuscSbGjOf3bqiDEutejqENSplMSFA/gmB8mkED9G4pKWnPl7MDU4rSHebKPHeitpDfyH0cQ==",
+			"license": "MIT",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/once": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+			"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+			"license": "ISC",
+			"dependencies": {
+				"wrappy": "1"
+			}
+		},
+		"node_modules/open": {
+			"version": "10.1.2",
+			"resolved": "https://registry.npmjs.org/open/-/open-10.1.2.tgz",
+			"integrity": "sha512-cxN6aIDPz6rm8hbebcP7vrQNhvRcveZoJU72Y7vskh4oIm+BZwBECnx5nTmrlres1Qapvx27Qo1Auukpf8PKXw==",
+			"license": "MIT",
+			"dependencies": {
+				"default-browser": "^5.2.1",
+				"define-lazy-prop": "^3.0.0",
+				"is-inside-container": "^1.0.0",
+				"is-wsl": "^3.1.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/prebuild-install": {
+			"version": "7.1.3",
+			"resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
+			"integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==",
+			"license": "MIT",
+			"dependencies": {
+				"detect-libc": "^2.0.0",
+				"expand-template": "^2.0.3",
+				"github-from-package": "0.0.0",
+				"minimist": "^1.2.3",
+				"mkdirp-classic": "^0.5.3",
+				"napi-build-utils": "^2.0.0",
+				"node-abi": "^3.3.0",
+				"pump": "^3.0.0",
+				"rc": "^1.2.7",
+				"simple-get": "^4.0.0",
+				"tar-fs": "^2.0.0",
+				"tunnel-agent": "^0.6.0"
+			},
+			"bin": {
+				"prebuild-install": "bin.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/protobufjs": {
+			"version": "7.5.8",
+			"resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.8.tgz",
+			"integrity": "sha512-dvpCIeLPbXZS/Ete7yLaO7RenOdken2NHKykBXbsaGxZT0UTltcarBciw+A78SRQs9iMAAVpsYA+l8b1hTePIA==",
+			"hasInstallScript": true,
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"@protobufjs/aspromise": "^1.1.2",
+				"@protobufjs/base64": "^1.1.2",
+				"@protobufjs/codegen": "^2.0.5",
+				"@protobufjs/eventemitter": "^1.1.0",
+				"@protobufjs/fetch": "^1.1.0",
+				"@protobufjs/float": "^1.0.2",
+				"@protobufjs/inquire": "^1.1.1",
+				"@protobufjs/path": "^1.1.2",
+				"@protobufjs/pool": "^1.1.0",
+				"@protobufjs/utf8": "^1.1.1",
+				"@types/node": ">=13.7.0",
+				"long": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=12.0.0"
+			}
+		},
+		"node_modules/pump": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+			"integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+			"license": "MIT",
+			"dependencies": {
+				"end-of-stream": "^1.1.0",
+				"once": "^1.3.1"
+			}
+		},
+		"node_modules/rc": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+			"integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+			"license": "(BSD-2-Clause OR MIT OR Apache-2.0)",
+			"dependencies": {
+				"deep-extend": "^0.6.0",
+				"ini": "~1.3.0",
+				"minimist": "^1.2.0",
+				"strip-json-comments": "~2.0.1"
+			},
+			"bin": {
+				"rc": "cli.js"
+			}
+		},
+		"node_modules/require-directory": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+			"integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/run-applescript": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz",
+			"integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/safe-buffer": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+			"integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/semver": {
+			"version": "7.7.2",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+			"integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+			"license": "ISC",
+			"bin": {
+				"semver": "bin/semver.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/simple-concat": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+			"integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/simple-get": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz",
+			"integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"decompress-response": "^6.0.0",
+				"once": "^1.3.1",
+				"simple-concat": "^1.0.0"
+			}
+		},
+		"node_modules/streamx": {
+			"version": "2.23.0",
+			"resolved": "https://registry.npmjs.org/streamx/-/streamx-2.23.0.tgz",
+			"integrity": "sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==",
+			"license": "MIT",
+			"dependencies": {
+				"events-universal": "^1.0.0",
+				"fast-fifo": "^1.3.2",
+				"text-decoder": "^1.1.0"
+			}
+		},
+		"node_modules/string-width": {
+			"version": "4.2.3",
+			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+			"license": "MIT",
+			"dependencies": {
+				"emoji-regex": "^8.0.0",
+				"is-fullwidth-code-point": "^3.0.0",
+				"strip-ansi": "^6.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/strip-ansi": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-regex": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/strip-json-comments": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+			"integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/tar-fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
+			"integrity": "sha512-LZA0oaPOc2fVo82Txf3gw+AkEd38szODlptMYejQUhndHMLQ9M059uXR+AfS7DNo0NpINvSqDsvyaCrBVkptWg==",
+			"license": "MIT",
+			"dependencies": {
+				"pump": "^3.0.0",
+				"tar-stream": "^3.1.5"
+			},
+			"optionalDependencies": {
+				"bare-fs": "^4.0.1",
+				"bare-path": "^3.0.0"
+			}
+		},
+		"node_modules/tar-stream": {
+			"version": "3.1.7",
+			"resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+			"integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
+			"license": "MIT",
+			"dependencies": {
+				"b4a": "^1.6.4",
+				"fast-fifo": "^1.2.0",
+				"streamx": "^2.15.0"
+			}
+		},
+		"node_modules/text-decoder": {
+			"version": "1.2.3",
+			"resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+			"integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"b4a": "^1.6.4"
+			}
+		},
+		"node_modules/tunnel-agent": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+			"integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"safe-buffer": "^5.0.1"
+			},
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/undici-types": {
+			"version": "6.21.0",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+			"integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+			"license": "MIT"
+		},
+		"node_modules/vscode-uri": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
+			"integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+			"license": "MIT"
+		},
+		"node_modules/wrap-ansi": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+			"integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^4.0.0",
+				"string-width": "^4.1.0",
+				"strip-ansi": "^6.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+			}
+		},
+		"node_modules/wrappy": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+			"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+			"license": "ISC"
+		},
+		"node_modules/y18n": {
+			"version": "5.0.8",
+			"resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+			"integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/yargs": {
+			"version": "17.7.2",
+			"resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+			"integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+			"license": "MIT",
+			"dependencies": {
+				"cliui": "^8.0.1",
+				"escalade": "^3.1.1",
+				"get-caller-file": "^2.0.5",
+				"require-directory": "^2.1.1",
+				"string-width": "^4.2.3",
+				"y18n": "^5.0.5",
+				"yargs-parser": "^21.1.1"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/yargs-parser": {
+			"version": "21.1.1",
+			"resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+			"integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"vscode": {
+			"version": "1.0.0",
+			"extraneous": true
+		}
+	}
+}
diff --git a/apps/vscode/standalone/runtime-files/package.json b/apps/vscode/standalone/runtime-files/package.json
new file mode 100644
index 0000000..0672b2a
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/package.json
@@ -0,0 +1,17 @@
+{
+	"name": "cline-core",
+	"version": "0.0.1",
+	"main": "cline-core.js",
+	"dependencies": {
+		"@grpc/grpc-js": "^1.13.3",
+		"@grpc/reflection": "^1.0.4",
+		"better-sqlite3": "^12.4.1",
+		"grpc-health-check": "^2.0.2",
+		"open": "^10.1.2",
+		"vscode-uri": "^3.1.0"
+	},
+	"overrides": {
+		"tar-fs": "^3.1.1",
+		"protobufjs": "7.5.8"
+	}
+}
diff --git a/apps/vscode/standalone/runtime-files/vscode/index.js b/apps/vscode/standalone/runtime-files/vscode/index.js
new file mode 100644
index 0000000..8638fc7
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/vscode/index.js
@@ -0,0 +1,7 @@
+const stubs = require("./vscode-stubs.js")
+const impls = require("./vscode-impls.js")
+
+module.exports = {
+	...stubs,
+	...impls,
+}
diff --git a/apps/vscode/standalone/runtime-files/vscode/package.json b/apps/vscode/standalone/runtime-files/vscode/package.json
new file mode 100644
index 0000000..7b06c36
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/vscode/package.json
@@ -0,0 +1,5 @@
+{
+	"name": "vscode",
+	"version": "1.0.0",
+	"main": "index.js"
+}
diff --git a/apps/vscode/standalone/runtime-files/vscode/stub-utils.js b/apps/vscode/standalone/runtime-files/vscode/stub-utils.js
new file mode 100644
index 0000000..fc4c497
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/vscode/stub-utils.js
@@ -0,0 +1,19 @@
+function createStub(path) {
+	return new Proxy(() => {}, {
+		get: (_target, prop) => {
+			const fullPath = `${path}.${String(prop)}`
+			console.log(`Accessed stub: ${fullPath}`)
+			return createStub(fullPath)
+		},
+		apply: (_target, _thisArg, args) => {
+			console.log(`Called stub: ${path} with args:`, args)
+			return createStub(path)
+		},
+		construct: (_target, args) => {
+			console.log(`Constructed stub: ${path} with args:`, args)
+			return createStub(path)
+		},
+	})
+}
+
+module.exports = { createStub }
diff --git a/apps/vscode/standalone/runtime-files/vscode/vscode-impls.js b/apps/vscode/standalone/runtime-files/vscode/vscode-impls.js
new file mode 100644
index 0000000..a8741b1
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/vscode/vscode-impls.js
@@ -0,0 +1,158 @@
+console.log("Loading stub impls...")
+
+const { createStub } = require("./stub-utils")
+
+// Import the base vscode object from stubs
+const vscode = require("./vscode-stubs.js")
+
+// Extend the existing window object from stubs rather than overwriting it
+vscode.window = {
+	...vscode.window, // Keep existing properties from stubs
+	showInformationMessage: (...args) => {
+		console.log("Stubbed showInformationMessage:", ...args)
+		return Promise.resolve(undefined)
+	},
+	showWarningMessage: (...args) => {
+		console.log("Stubbed showWarningMessage:", ...args)
+		return Promise.resolve(undefined)
+	},
+	showErrorMessage: (...args) => {
+		console.log("Stubbed showErrorMessage:", ...args)
+		return Promise.resolve(undefined)
+	},
+	showInputBox: async (options) => {
+		console.log("Stubbed showInputBox:", options)
+		return ""
+	},
+	showOpenDialog: async (options) => {
+		console.log("Stubbed showOpenDialog:", options)
+		return []
+	},
+	showSaveDialog: async (options) => {
+		console.log("Stubbed showSaveDialog:", options)
+		return undefined
+	},
+	showTextDocument: async (...args) => {
+		console.log("Stubbed showTextDocument:", ...args)
+		return {}
+	},
+	createTerminal: (...args) => {
+		// In standalone mode, terminals are managed directly by Task.terminalManager (StandaloneTerminalManager)
+		// This stub is provided for compatibility but should not be called directly
+		console.log("Stubbed createTerminal:", ...args)
+
+		// Return a minimal stub terminal object
+		const stubTerminal = {
+			name: args[0]?.name || args[0] || "Terminal",
+			processId: Promise.resolve(undefined),
+			creationOptions: {},
+			exitStatus: undefined,
+			state: { isInteractedWith: false },
+			sendText: (text) => console.log("Stubbed terminal.sendText:", text),
+			show: () => console.log("Stubbed terminal.show"),
+			hide: () => console.log("Stubbed terminal.hide"),
+			dispose: () => console.log("Stubbed terminal.dispose"),
+		}
+
+		vscode.window.terminals.push(stubTerminal)
+		return stubTerminal
+	},
+	activeTextEditor: undefined,
+	visibleTextEditors: [],
+	tabGroups: {
+		all: [],
+		close: async () => {},
+		onDidChangeTabs: createStub("vscode.env.tabGroups.onDidChangeTabs"),
+		activeTabGroup: { tabs: [] },
+	},
+	withProgress: async (_options, task) => {
+		console.log("Stubbed withProgress")
+		return task({ report: () => {} })
+	},
+	registerUriHandler: () => ({ dispose: () => {} }),
+	registerWebviewViewProvider: () => ({ dispose: () => {} }),
+	onDidChangeActiveTextEditor: () => ({ dispose: () => {} }),
+	createTextEditorDecorationType: () => ({ dispose: () => {} }),
+	createWebviewPanel: (..._args) => {
+		throw new Error("WebviewPanel is not supported in standalone app.")
+	},
+}
+
+vscode.env = {
+	uriScheme: "vscode",
+	appName: "Visual Studio Code",
+	appRoot: "/tmp/vscode/appRoot",
+	language: "en",
+	machineId: "stub-machine-id",
+	remoteName: undefined,
+	sessionId: "stub-session-id",
+	shell: "/bin/bash",
+
+	clipboard: createStub("vscode.env.clipboard"),
+	openExternal: createStub("vscode.env.openExternal"),
+	getQueryParameter: createStub("vscode.env.getQueryParameter"),
+	onDidChangeTelemetryEnabled: createStub("vscode.env.onDidChangeTelemetryEnabled"),
+	isTelemetryEnabled: createStub("vscode.env.isTelemetryEnabled"),
+	telemetryConfiguration: createStub("vscode.env.telemetryConfiguration"),
+	onDidChangeTelemetryConfiguration: createStub("vscode.env.onDidChangeTelemetryConfiguration"),
+	createTelemetryLogger: createStub("vscode.env.createTelemetryLogger"),
+}
+
+vscode.Uri = {
+	parse: (uriString) => {
+		const url = new URL(uriString)
+		return {
+			scheme: url.protocol.replace(":", ""),
+			authority: url.hostname,
+			path: url.pathname,
+			query: url.search.slice(1),
+			fragment: url.hash.slice(1),
+			fsPath: `/tmp${url.pathname}`,
+			toString: () => uriString,
+			toJSON: () => uriString,
+			with: (change) => {
+				const newUrl = new URL(uriString)
+				if (change.scheme) {
+					newUrl.protocol = change.scheme + ":"
+				}
+				if (change.authority) {
+					newUrl.hostname = change.authority
+				}
+				if (change.path) {
+					newUrl.pathname = change.path
+				}
+				if (change.query) {
+					newUrl.search = "?" + change.query
+				}
+				if (change.fragment) {
+					newUrl.hash = "#" + change.fragment
+				}
+				return vscode.Uri.parse(newUrl.toString())
+			},
+		}
+	},
+
+	file: (path) => {
+		return {
+			scheme: "file",
+			authority: "",
+			path,
+			fsPath: path,
+			query: "",
+			fragment: "",
+			toString: () => `file://${path}`,
+			toJSON: () => `file://${path}`,
+			with: (change) => {
+				const modified = Object.assign({}, vscode.Uri.file(path), change)
+				return modified
+			},
+		}
+	},
+
+	joinPath: (...segments) => {
+		const joined = segments.map((s) => (typeof s === "string" ? s : s.path)).join("/")
+		return vscode.Uri.file("/" + joined.replace(/\/+/g, "/"))
+	},
+}
+
+console.log("Finished loading stub impls...")
diff --git a/apps/vscode/standalone/runtime-files/vscode/vscode-stubs.js b/apps/vscode/standalone/runtime-files/vscode/vscode-stubs.js
new file mode 100644
index 0000000..8d4143f
--- /dev/null
+++ b/apps/vscode/standalone/runtime-files/vscode/vscode-stubs.js
@@ -0,0 +1,1332 @@
+// GENERATED CODE -- DO NOT EDIT!
+console.log("Loading stubs...")
+const { createStub } = require("./stub-utils")
+vscode = {}
+vscode.version = createStub("vscode.version")
+vscode.Position = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Position(", args, ")")
+		return createStub(vscode.Position)
+	}
+}
+vscode.Range = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Range(", args, ")")
+		return createStub(vscode.Range)
+	}
+}
+vscode.Selection = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Selection(", args, ")")
+		return createStub(vscode.Selection)
+	}
+}
+vscode.TextEditorSelectionChangeKind = { Keyboard: 0, Mouse: 0, Command: 0 }
+vscode.TextEditorCursorStyle = { Line: 0, Block: 0, Underline: 0, LineThin: 0, BlockOutline: 0, UnderlineThin: 0 }
+vscode.TextEditorLineNumbersStyle = { Off: 0, On: 0, Relative: 0 }
+vscode.TextEditorRevealType = { Default: 0, InCenter: 0, InCenterIfOutsideViewport: 0, AtTop: 0 }
+vscode.OverviewRulerLane = { Left: 0, Center: 0, Right: 0, Full: 0 }
+vscode.DecorationRangeBehavior = { OpenOpen: 0, ClosedClosed: 0, OpenClosed: 0, ClosedOpen: 0 }
+vscode.ThemeColor = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ThemeColor(", args, ")")
+		return createStub(vscode.ThemeColor)
+	}
+}
+vscode.ThemeIcon = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ThemeIcon(", args, ")")
+		return createStub(vscode.ThemeIcon)
+	}
+}
+vscode.EndOfLine = { LF: 0, CRLF: 0 }
+vscode.Uri = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Uri(", args, ")")
+		return createStub(vscode.Uri)
+	}
+}
+vscode.CancellationTokenSource = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CancellationTokenSource(", args, ")")
+		return createStub(vscode.CancellationTokenSource)
+	}
+}
+vscode.CancellationError = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CancellationError(", args, ")")
+		return createStub(vscode.CancellationError)
+	}
+}
+vscode.Disposable = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Disposable(", args, ")")
+		return createStub(vscode.Disposable)
+	}
+}
+vscode.EventEmitter = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.EventEmitter(", args, ")")
+		return createStub(vscode.EventEmitter)
+	}
+}
+vscode.QuickPickItemKind = { Separator: 0, Default: 0 }
+vscode.InputBoxValidationSeverity = { Info: 0, Warning: 0, Error: 0 }
+vscode.RelativePattern = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.RelativePattern(", args, ")")
+		return createStub(vscode.RelativePattern)
+	}
+}
+vscode.CodeActionKind = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CodeActionKind(", args, ")")
+		return createStub(vscode.CodeActionKind)
+	}
+}
+vscode.CodeActionTriggerKind = { Invoke: 0, Automatic: 0 }
+vscode.CodeAction = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CodeAction(", args, ")")
+		return createStub(vscode.CodeAction)
+	}
+}
+vscode.CodeLens = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CodeLens(", args, ")")
+		return createStub(vscode.CodeLens)
+	}
+}
+vscode.MarkdownString = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.MarkdownString(", args, ")")
+		return createStub(vscode.MarkdownString)
+	}
+}
+vscode.Hover = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Hover(", args, ")")
+		return createStub(vscode.Hover)
+	}
+}
+vscode.EvaluatableExpression = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.EvaluatableExpression(", args, ")")
+		return createStub(vscode.EvaluatableExpression)
+	}
+}
+vscode.InlineValueText = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlineValueText(", args, ")")
+		return createStub(vscode.InlineValueText)
+	}
+}
+vscode.InlineValueVariableLookup = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlineValueVariableLookup(", args, ")")
+		return createStub(vscode.InlineValueVariableLookup)
+	}
+}
+vscode.InlineValueEvaluatableExpression = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlineValueEvaluatableExpression(", args, ")")
+		return createStub(vscode.InlineValueEvaluatableExpression)
+	}
+}
+vscode.DocumentHighlightKind = { Text: 0, Read: 0, Write: 0 }
+vscode.DocumentHighlight = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DocumentHighlight(", args, ")")
+		return createStub(vscode.DocumentHighlight)
+	}
+}
+vscode.SymbolKind = {
+	File: 0,
+	Module: 0,
+	Namespace: 0,
+	Package: 0,
+	Class: 0,
+	Method: 0,
+	Property: 0,
+	Field: 0,
+	Constructor: 0,
+	Enum: 0,
+	Interface: 0,
+	Function: 0,
+	Variable: 0,
+	Constant: 0,
+	String: 0,
+	Number: 0,
+	Boolean: 0,
+	Array: 0,
+	Object: 0,
+	Key: 0,
+	Null: 0,
+	EnumMember: 0,
+	Struct: 0,
+	Event: 0,
+	Operator: 0,
+	TypeParameter: 0,
+}
+vscode.SymbolTag = { Deprecated: 0 }
+vscode.SymbolInformation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SymbolInformation(", args, ")")
+		return createStub(vscode.SymbolInformation)
+	}
+}
+vscode.DocumentSymbol = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DocumentSymbol(", args, ")")
+		return createStub(vscode.DocumentSymbol)
+	}
+}
+vscode.TextEdit = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TextEdit(", args, ")")
+		return createStub(vscode.TextEdit)
+	}
+}
+vscode.SnippetTextEdit = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SnippetTextEdit(", args, ")")
+		return createStub(vscode.SnippetTextEdit)
+	}
+}
+vscode.NotebookEdit = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookEdit(", args, ")")
+		return createStub(vscode.NotebookEdit)
+	}
+}
+vscode.WorkspaceEdit = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.WorkspaceEdit(", args, ")")
+		return createStub(vscode.WorkspaceEdit)
+	}
+}
+vscode.SnippetString = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SnippetString(", args, ")")
+		return createStub(vscode.SnippetString)
+	}
+}
+vscode.SemanticTokensLegend = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SemanticTokensLegend(", args, ")")
+		return createStub(vscode.SemanticTokensLegend)
+	}
+}
+vscode.SemanticTokensBuilder = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SemanticTokensBuilder(", args, ")")
+		return createStub(vscode.SemanticTokensBuilder)
+	}
+}
+vscode.SemanticTokens = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SemanticTokens(", args, ")")
+		return createStub(vscode.SemanticTokens)
+	}
+}
+vscode.SemanticTokensEdits = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SemanticTokensEdits(", args, ")")
+		return createStub(vscode.SemanticTokensEdits)
+	}
+}
+vscode.SemanticTokensEdit = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SemanticTokensEdit(", args, ")")
+		return createStub(vscode.SemanticTokensEdit)
+	}
+}
+vscode.ParameterInformation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ParameterInformation(", args, ")")
+		return createStub(vscode.ParameterInformation)
+	}
+}
+vscode.SignatureInformation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SignatureInformation(", args, ")")
+		return createStub(vscode.SignatureInformation)
+	}
+}
+vscode.SignatureHelp = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SignatureHelp(", args, ")")
+		return createStub(vscode.SignatureHelp)
+	}
+}
+vscode.SignatureHelpTriggerKind = { Invoke: 0, TriggerCharacter: 0, ContentChange: 0 }
+vscode.CompletionItemKind = {
+	Text: 0,
+	Method: 0,
+	Function: 0,
+	Constructor: 0,
+	Field: 0,
+	Variable: 0,
+	Class: 0,
+	Interface: 0,
+	Module: 0,
+	Property: 0,
+	Unit: 0,
+	Value: 0,
+	Enum: 0,
+	Keyword: 0,
+	Snippet: 0,
+	Color: 0,
+	Reference: 0,
+	File: 0,
+	Folder: 0,
+	EnumMember: 0,
+	Constant: 0,
+	Struct: 0,
+	Event: 0,
+	Operator: 0,
+	TypeParameter: 0,
+	User: 0,
+	Issue: 0,
+}
+vscode.CompletionItemTag = { Deprecated: 0 }
+vscode.CompletionItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CompletionItem(", args, ")")
+		return createStub(vscode.CompletionItem)
+	}
+}
+vscode.CompletionList = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CompletionList(", args, ")")
+		return createStub(vscode.CompletionList)
+	}
+}
+vscode.CompletionTriggerKind = { Invoke: 0, TriggerCharacter: 0, TriggerForIncompleteCompletions: 0 }
+vscode.InlineCompletionList = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlineCompletionList(", args, ")")
+		return createStub(vscode.InlineCompletionList)
+	}
+}
+vscode.InlineCompletionTriggerKind = { Invoke: 0, Automatic: 0 }
+vscode.InlineCompletionItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlineCompletionItem(", args, ")")
+		return createStub(vscode.InlineCompletionItem)
+	}
+}
+vscode.DocumentLink = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DocumentLink(", args, ")")
+		return createStub(vscode.DocumentLink)
+	}
+}
+vscode.Color = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Color(", args, ")")
+		return createStub(vscode.Color)
+	}
+}
+vscode.ColorInformation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ColorInformation(", args, ")")
+		return createStub(vscode.ColorInformation)
+	}
+}
+vscode.ColorPresentation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ColorPresentation(", args, ")")
+		return createStub(vscode.ColorPresentation)
+	}
+}
+vscode.InlayHintKind = { Type: 0, Parameter: 0 }
+vscode.InlayHintLabelPart = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlayHintLabelPart(", args, ")")
+		return createStub(vscode.InlayHintLabelPart)
+	}
+}
+vscode.InlayHint = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.InlayHint(", args, ")")
+		return createStub(vscode.InlayHint)
+	}
+}
+vscode.FoldingRange = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.FoldingRange(", args, ")")
+		return createStub(vscode.FoldingRange)
+	}
+}
+vscode.FoldingRangeKind = { Comment: 0, Imports: 0, Region: 0 }
+vscode.SelectionRange = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SelectionRange(", args, ")")
+		return createStub(vscode.SelectionRange)
+	}
+}
+vscode.CallHierarchyItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CallHierarchyItem(", args, ")")
+		return createStub(vscode.CallHierarchyItem)
+	}
+}
+vscode.CallHierarchyIncomingCall = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CallHierarchyIncomingCall(", args, ")")
+		return createStub(vscode.CallHierarchyIncomingCall)
+	}
+}
+vscode.CallHierarchyOutgoingCall = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CallHierarchyOutgoingCall(", args, ")")
+		return createStub(vscode.CallHierarchyOutgoingCall)
+	}
+}
+vscode.TypeHierarchyItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TypeHierarchyItem(", args, ")")
+		return createStub(vscode.TypeHierarchyItem)
+	}
+}
+vscode.LinkedEditingRanges = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.LinkedEditingRanges(", args, ")")
+		return createStub(vscode.LinkedEditingRanges)
+	}
+}
+vscode.DocumentDropEdit = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DocumentDropEdit(", args, ")")
+		return createStub(vscode.DocumentDropEdit)
+	}
+}
+vscode.IndentAction = { None: 0, Indent: 0, IndentOutdent: 0, Outdent: 0 }
+vscode.SyntaxTokenType = { Other: 0, Comment: 0, String: 0, RegEx: 0 }
+vscode.ConfigurationTarget = { Global: 0, Workspace: 0, WorkspaceFolder: 0 }
+vscode.Location = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Location(", args, ")")
+		return createStub(vscode.Location)
+	}
+}
+vscode.DiagnosticSeverity = { Error: 0, Warning: 0, Information: 0, Hint: 0 }
+vscode.DiagnosticRelatedInformation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DiagnosticRelatedInformation(", args, ")")
+		return createStub(vscode.DiagnosticRelatedInformation)
+	}
+}
+vscode.DiagnosticTag = { Unnecessary: 0, Deprecated: 0 }
+vscode.Diagnostic = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Diagnostic(", args, ")")
+		return createStub(vscode.Diagnostic)
+	}
+}
+vscode.LanguageStatusSeverity = { Information: 0, Warning: 0, Error: 0 }
+vscode.ViewColumn = { Active: 0, Beside: 0, One: 0, Two: 0, Three: 0, Four: 0, Five: 0, Six: 0, Seven: 0, Eight: 0, Nine: 0 }
+vscode.StatusBarAlignment = { Left: 0, Right: 0 }
+vscode.TerminalLocation = { Panel: 0, Editor: 0 }
+vscode.TerminalLink = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TerminalLink(", args, ")")
+		return createStub(vscode.TerminalLink)
+	}
+}
+vscode.TerminalProfile = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TerminalProfile(", args, ")")
+		return createStub(vscode.TerminalProfile)
+	}
+}
+vscode.FileDecoration = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.FileDecoration(", args, ")")
+		return createStub(vscode.FileDecoration)
+	}
+}
+vscode.ExtensionKind = { UI: 0, Workspace: 0 }
+vscode.ExtensionMode = { Production: 0, Development: 0, Test: 0 }
+vscode.ColorThemeKind = { Light: 0, Dark: 0, HighContrast: 0, HighContrastLight: 0 }
+vscode.TaskRevealKind = { Always: 0, Silent: 0, Never: 0 }
+vscode.TaskPanelKind = { Shared: 0, Dedicated: 0, New: 0 }
+vscode.TaskGroup = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TaskGroup(", args, ")")
+		return createStub(vscode.TaskGroup)
+	}
+}
+vscode.ProcessExecution = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ProcessExecution(", args, ")")
+		return createStub(vscode.ProcessExecution)
+	}
+}
+vscode.ShellQuoting = { Escape: 0, Strong: 0, Weak: 0 }
+vscode.ShellExecution = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.ShellExecution(", args, ")")
+		return createStub(vscode.ShellExecution)
+	}
+}
+vscode.CustomExecution = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.CustomExecution(", args, ")")
+		return createStub(vscode.CustomExecution)
+	}
+}
+vscode.TaskScope = { Global: 0, Workspace: 0 }
+vscode.Task = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Task(", args, ")")
+		return createStub(vscode.Task)
+	}
+}
+vscode.tasks = {}
+vscode.tasks.registerTaskProvider = (_type, _provider) => {
+	console.log("Called stubbed function: vscode.tasks.registerTaskProvider")
+	return createStub("unknown")
+}
+vscode.tasks.fetchTasks = (_filter) => {
+	console.log("Called stubbed function: vscode.tasks.fetchTasks")
+	return []
+}
+vscode.tasks.executeTask = (_task) => {
+	console.log("Called stubbed function: vscode.tasks.executeTask")
+	return Promise.resolve(null)
+}
+vscode.tasks.taskExecutions = createStub("vscode.tasks.taskExecutions")
+vscode.tasks.onDidStartTask = createStub("vscode.tasks.onDidStartTask")
+vscode.tasks.onDidEndTask = createStub("vscode.tasks.onDidEndTask")
+vscode.tasks.onDidStartTaskProcess = createStub("vscode.tasks.onDidStartTaskProcess")
+vscode.tasks.onDidEndTaskProcess = createStub("vscode.tasks.onDidEndTaskProcess")
+vscode.FileType = { Unknown: 0, File: 0, Directory: 0, SymbolicLink: 0 }
+vscode.FilePermission = { Readonly: 0 }
+vscode.FileSystemError = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.FileSystemError(", args, ")")
+		return createStub(vscode.FileSystemError)
+	}
+}
+vscode.FileChangeType = { Changed: 0, Created: 0, Deleted: 0 }
+vscode.UIKind = { Desktop: 0, Web: 0 }
+vscode.LogLevel = { Off: 0, Trace: 0, Debug: 0, Info: 0, Warning: 0, Error: 0 }
+vscode.env = {}
+vscode.env.appName = createStub("vscode.env.appName")
+vscode.env.appRoot = createStub("vscode.env.appRoot")
+vscode.env.appHost = createStub("vscode.env.appHost")
+vscode.env.uriScheme = createStub("vscode.env.uriScheme")
+vscode.env.language = createStub("vscode.env.language")
+vscode.env.clipboard = createStub("vscode.env.clipboard")
+vscode.env.machineId = createStub("vscode.env.machineId")
+vscode.env.sessionId = createStub("vscode.env.sessionId")
+vscode.env.isNewAppInstall = createStub("vscode.env.isNewAppInstall")
+vscode.env.isTelemetryEnabled = createStub("vscode.env.isTelemetryEnabled")
+vscode.env.onDidChangeTelemetryEnabled = createStub("vscode.env.onDidChangeTelemetryEnabled")
+vscode.env.onDidChangeShell = createStub("vscode.env.onDidChangeShell")
+vscode.env.createTelemetryLogger = (_sender, _options) => {
+	console.log("Called stubbed function: vscode.env.createTelemetryLogger")
+	return createStub("unknown")
+}
+vscode.env.remoteName = createStub("vscode.env.remoteName")
+vscode.env.shell = createStub("vscode.env.shell")
+vscode.env.uiKind = createStub("vscode.env.uiKind")
+vscode.env.openExternal = (_target) => {
+	console.log("Called stubbed function: vscode.env.openExternal")
+	return false
+}
+vscode.env.asExternalUri = (_target) => {
+	console.log("Called stubbed function: vscode.env.asExternalUri")
+	return Promise.resolve(null)
+}
+vscode.env.logLevel = createStub("vscode.env.logLevel")
+vscode.env.onDidChangeLogLevel = createStub("vscode.env.onDidChangeLogLevel")
+vscode.commands = {}
+vscode.commands.registerCommand = (_command, _callback, _thisArg) => {
+	console.log("Called stubbed function: vscode.commands.registerCommand")
+	return createStub("unknown")
+}
+vscode.commands.registerTextEditorCommand = (_command, _callback, _thisArg) => {
+	console.log("Called stubbed function: vscode.commands.registerTextEditorCommand")
+	return createStub("unknown")
+}
+vscode.commands.executeCommand = (_command, _rest) => {
+	console.log("Called stubbed function: vscode.commands.executeCommand")
+	return Promise.resolve(null)
+}
+vscode.commands.getCommands = (_filterInternal) => {
+	console.log("Called stubbed function: vscode.commands.getCommands")
+	return ""
+}
+vscode.window = {}
+vscode.window.tabGroups = createStub("vscode.window.tabGroups")
+vscode.window.activeTextEditor = createStub("vscode.window.activeTextEditor")
+vscode.window.visibleTextEditors = []
+vscode.window.onDidChangeActiveTextEditor = createStub("vscode.window.onDidChangeActiveTextEditor")
+vscode.window.onDidChangeVisibleTextEditors = createStub("vscode.window.onDidChangeVisibleTextEditors")
+vscode.window.onDidChangeTextEditorSelection = createStub("vscode.window.onDidChangeTextEditorSelection")
+vscode.window.onDidChangeTextEditorVisibleRanges = createStub("vscode.window.onDidChangeTextEditorVisibleRanges")
+vscode.window.onDidChangeTextEditorOptions = createStub("vscode.window.onDidChangeTextEditorOptions")
+vscode.window.onDidChangeTextEditorViewColumn = createStub("vscode.window.onDidChangeTextEditorViewColumn")
+vscode.window.visibleNotebookEditors = createStub("vscode.window.visibleNotebookEditors")
+vscode.window.onDidChangeVisibleNotebookEditors = createStub("vscode.window.onDidChangeVisibleNotebookEditors")
+vscode.window.activeNotebookEditor = createStub("vscode.window.activeNotebookEditor")
+vscode.window.onDidChangeActiveNotebookEditor = createStub("vscode.window.onDidChangeActiveNotebookEditor")
+vscode.window.onDidChangeNotebookEditorSelection = createStub("vscode.window.onDidChangeNotebookEditorSelection")
+vscode.window.onDidChangeNotebookEditorVisibleRanges = createStub("vscode.window.onDidChangeNotebookEditorVisibleRanges")
+vscode.window.terminals = createStub("vscode.window.terminals")
+vscode.window.activeTerminal = createStub("vscode.window.activeTerminal")
+vscode.window.onDidChangeActiveTerminal = createStub("vscode.window.onDidChangeActiveTerminal")
+vscode.window.onDidOpenTerminal = createStub("vscode.window.onDidOpenTerminal")
+vscode.window.onDidCloseTerminal = createStub("vscode.window.onDidCloseTerminal")
+vscode.window.onDidChangeTerminalState = createStub("vscode.window.onDidChangeTerminalState")
+vscode.window.state = createStub("vscode.window.state")
+vscode.window.onDidChangeWindowState = createStub("vscode.window.onDidChangeWindowState")
+vscode.window.showTextDocument = (_document, _column, _preserveFocus) => {
+	console.log("Called stubbed function: vscode.window.showTextDocument")
+	return Promise.resolve(null)
+}
+vscode.window.showTextDocument = (_document, _options) => {
+	console.log("Called stubbed function: vscode.window.showTextDocument")
+	return Promise.resolve(null)
+}
+vscode.window.showTextDocument = (_uri, _options) => {
+	console.log("Called stubbed function: vscode.window.showTextDocument")
+	return Promise.resolve(null)
+}
+vscode.window.showNotebookDocument = (_document, _options) => {
+	console.log("Called stubbed function: vscode.window.showNotebookDocument")
+	return Promise.resolve(null)
+}
+vscode.window.createTextEditorDecorationType = (_options) => {
+	console.log("Called stubbed function: vscode.window.createTextEditorDecorationType")
+	return createStub("unknown")
+}
+vscode.window.showInformationMessage = (_message, _items) => {
+	console.log("Called stubbed function: vscode.window.showInformationMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showInformationMessage = (_message, _options, _items) => {
+	console.log("Called stubbed function: vscode.window.showInformationMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showInformationMessage = (_message, _items) => {
+	console.log("Called stubbed function: vscode.window.showInformationMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showInformationMessage = (_message, _options, _items) => {
+	console.log("Called stubbed function: vscode.window.showInformationMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showWarningMessage = (_message, _items) => {
+	console.log("Called stubbed function: vscode.window.showWarningMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showWarningMessage = (_message, _options, _items) => {
+	console.log("Called stubbed function: vscode.window.showWarningMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showWarningMessage = (_message, _items) => {
+	console.log("Called stubbed function: vscode.window.showWarningMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showWarningMessage = (_message, _options, _items) => {
+	console.log("Called stubbed function: vscode.window.showWarningMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showErrorMessage = (_message, _items) => {
+	console.log("Called stubbed function: vscode.window.showErrorMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showErrorMessage = (_message, _options, _items) => {
+	console.log("Called stubbed function: vscode.window.showErrorMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showErrorMessage = (_message, _items) => {
+	console.log("Called stubbed function: vscode.window.showErrorMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showErrorMessage = (_message, _options, _items) => {
+	console.log("Called stubbed function: vscode.window.showErrorMessage")
+	return Promise.resolve(null)
+}
+vscode.window.showQuickPick = (_items, _options, _token) => {
+	console.log("Called stubbed function: vscode.window.showQuickPick")
+	return ""
+}
+vscode.window.showQuickPick = (_items, _options, _token) => {
+	console.log("Called stubbed function: vscode.window.showQuickPick")
+	return ""
+}
+vscode.window.showQuickPick = (_items, _options, _token) => {
+	console.log("Called stubbed function: vscode.window.showQuickPick")
+	return []
+}
+vscode.window.showQuickPick = (_items, _options, _token) => {
+	console.log("Called stubbed function: vscode.window.showQuickPick")
+	return Promise.resolve(null)
+}
+vscode.window.showWorkspaceFolderPick = (_options) => {
+	console.log("Called stubbed function: vscode.window.showWorkspaceFolderPick")
+	return Promise.resolve(null)
+}
+vscode.window.showSaveDialog = (_options) => {
+	console.log("Called stubbed function: vscode.window.showSaveDialog")
+	return Promise.resolve(null)
+}
+vscode.window.showInputBox = (_options, _token) => {
+	console.log("Called stubbed function: vscode.window.showInputBox")
+	return ""
+}
+vscode.window.createQuickPick = () => {
+	console.log("Called stubbed function: vscode.window.createQuickPick")
+	return createStub("unknown")
+}
+vscode.window.createInputBox = () => {
+	console.log("Called stubbed function: vscode.window.createInputBox")
+	return createStub("unknown")
+}
+vscode.window.createOutputChannel = (_name, _languageId) => {
+	console.log("Called stubbed function: vscode.window.createOutputChannel")
+	return createStub("unknown")
+}
+vscode.window.createOutputChannel = (_name, _options) => {
+	console.log("Called stubbed function: vscode.window.createOutputChannel")
+	return createStub("unknown")
+}
+vscode.window.createWebviewPanel = (_viewType, _title, _showOptions, _options) => {
+	console.log("Called stubbed function: vscode.window.createWebviewPanel")
+	return createStub("unknown")
+}
+vscode.window.setStatusBarMessage = (_text, _hideAfterTimeout) => {
+	console.log("Called stubbed function: vscode.window.setStatusBarMessage")
+	return createStub("unknown")
+}
+vscode.window.setStatusBarMessage = (_text, _hideWhenDone) => {
+	console.log("Called stubbed function: vscode.window.setStatusBarMessage")
+	return createStub("unknown")
+}
+vscode.window.setStatusBarMessage = (_text) => {
+	console.log("Called stubbed function: vscode.window.setStatusBarMessage")
+	return createStub("unknown")
+}
+vscode.window.withScmProgress = (_task) => {
+	console.log("Called stubbed function: vscode.window.withScmProgress")
+	return Promise.resolve(null)
+}
+vscode.window.withProgress = (_options, _task) => {
+	console.log("Called stubbed function: vscode.window.withProgress")
+	return Promise.resolve(null)
+}
+vscode.window.createStatusBarItem = (_id, _alignment, _priority) => {
+	console.log("Called stubbed function: vscode.window.createStatusBarItem")
+	return createStub("unknown")
+}
+vscode.window.createStatusBarItem = (_alignment, _priority) => {
+	console.log("Called stubbed function: vscode.window.createStatusBarItem")
+	return createStub("unknown")
+}
+vscode.window.createTerminal = (_name, _shellPath, _shellArgs) => {
+	console.log("Called stubbed function: vscode.window.createTerminal")
+	return createStub("unknown")
+}
+vscode.window.createTerminal = (_options) => {
+	console.log("Called stubbed function: vscode.window.createTerminal")
+	return createStub("unknown")
+}
+vscode.window.createTerminal = (_options) => {
+	console.log("Called stubbed function: vscode.window.createTerminal")
+	return createStub("unknown")
+}
+vscode.window.registerTreeDataProvider = (_viewId, _treeDataProvider) => {
+	console.log("Called stubbed function: vscode.window.registerTreeDataProvider")
+	return createStub("unknown")
+}
+vscode.window.createTreeView = (_viewId, _options) => {
+	console.log("Called stubbed function: vscode.window.createTreeView")
+	return createStub("unknown")
+}
+vscode.window.registerUriHandler = (_handler) => {
+	console.log("Called stubbed function: vscode.window.registerUriHandler")
+	return createStub("unknown")
+}
+vscode.window.registerWebviewPanelSerializer = (_viewType, _serializer) => {
+	console.log("Called stubbed function: vscode.window.registerWebviewPanelSerializer")
+	return createStub("unknown")
+}
+vscode.window.registerWebviewViewProvider = (_viewId, _provider, _options) => {
+	console.log("Called stubbed function: vscode.window.registerWebviewViewProvider")
+	return createStub("unknown")
+}
+vscode.window.registerCustomEditorProvider = (_viewType, _provider, _options) => {
+	console.log("Called stubbed function: vscode.window.registerCustomEditorProvider")
+	return createStub("unknown")
+}
+vscode.window.registerTerminalLinkProvider = (_provider) => {
+	console.log("Called stubbed function: vscode.window.registerTerminalLinkProvider")
+	return createStub("unknown")
+}
+vscode.window.registerTerminalProfileProvider = (_id, _provider) => {
+	console.log("Called stubbed function: vscode.window.registerTerminalProfileProvider")
+	return createStub("unknown")
+}
+vscode.window.registerFileDecorationProvider = (_provider) => {
+	console.log("Called stubbed function: vscode.window.registerFileDecorationProvider")
+	return createStub("unknown")
+}
+vscode.window.activeColorTheme = createStub("vscode.window.activeColorTheme")
+vscode.window.onDidChangeActiveColorTheme = createStub("vscode.window.onDidChangeActiveColorTheme")
+vscode.DataTransferItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DataTransferItem(", args, ")")
+		return createStub(vscode.DataTransferItem)
+	}
+}
+vscode.DataTransfer = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DataTransfer(", args, ")")
+		return createStub(vscode.DataTransfer)
+	}
+}
+vscode.TreeItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TreeItem(", args, ")")
+		return createStub(vscode.TreeItem)
+	}
+}
+vscode.TreeItemCollapsibleState = { None: 0, Collapsed: 0, Expanded: 0 }
+vscode.TreeItemCheckboxState = { Unchecked: 0, Checked: 0 }
+vscode.TerminalExitReason = { Unknown: 0, Shutdown: 0, Process: 0, User: 0, Extension: 0 }
+vscode.EnvironmentVariableMutatorType = { Replace: 0, Append: 0, Prepend: 0 }
+vscode.ProgressLocation = { SourceControl: 0, Window: 0, Notification: 0 }
+vscode.QuickInputButtons = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.QuickInputButtons(", args, ")")
+		return createStub(vscode.QuickInputButtons)
+	}
+}
+vscode.TextDocumentChangeReason = { Undo: 0, Redo: 0 }
+vscode.TextDocumentSaveReason = { Manual: 0, AfterDelay: 0, FocusOut: 0 }
+vscode.workspace = {}
+vscode.workspace.fs = createStub("vscode.workspace.fs")
+vscode.workspace.rootPath = createStub("vscode.workspace.rootPath")
+vscode.workspace.name = createStub("vscode.workspace.name")
+vscode.workspace.workspaceFile = createStub("vscode.workspace.workspaceFile")
+vscode.workspace.asRelativePath = (_pathOrUri, _includeWorkspaceFolder) => {
+	console.log("Called stubbed function: vscode.workspace.asRelativePath")
+	return ""
+}
+vscode.workspace.createFileSystemWatcher = (_globPattern, _ignoreCreateEvents, _ignoreChangeEvents, _ignoreDeleteEvents) => {
+	console.log("Called stubbed function: vscode.workspace.createFileSystemWatcher")
+	return createStub("unknown")
+}
+vscode.workspace.findFiles = (_include, _exclude, _maxResults, _token) => {
+	console.log("Called stubbed function: vscode.workspace.findFiles")
+	return []
+}
+vscode.workspace.saveAll = (_includeUntitled) => {
+	console.log("Called stubbed function: vscode.workspace.saveAll")
+	return false
+}
+vscode.workspace.applyEdit = (_edit, _metadata) => {
+	console.log("Called stubbed function: vscode.workspace.applyEdit")
+	return false
+}
+vscode.workspace.textDocuments = []
+vscode.workspace.openTextDocument = (_uri) => {
+	console.log("Called stubbed function: vscode.workspace.openTextDocument")
+	return Promise.resolve(null)
+}
+vscode.workspace.openTextDocument = (_fileName) => {
+	console.log("Called stubbed function: vscode.workspace.openTextDocument")
+	return Promise.resolve(null)
+}
+vscode.workspace.openTextDocument = (_options) => {
+	console.log("Called stubbed function: vscode.workspace.openTextDocument")
+	return Promise.resolve(null)
+}
+vscode.workspace.registerTextDocumentContentProvider = (_scheme, _provider) => {
+	console.log("Called stubbed function: vscode.workspace.registerTextDocumentContentProvider")
+	return createStub("unknown")
+}
+vscode.workspace.onDidOpenTextDocument = createStub("vscode.workspace.onDidOpenTextDocument")
+vscode.workspace.onDidCloseTextDocument = createStub("vscode.workspace.onDidCloseTextDocument")
+vscode.workspace.onDidChangeTextDocument = createStub("vscode.workspace.onDidChangeTextDocument")
+vscode.workspace.onWillSaveTextDocument = createStub("vscode.workspace.onWillSaveTextDocument")
+vscode.workspace.onDidSaveTextDocument = createStub("vscode.workspace.onDidSaveTextDocument")
+vscode.workspace.notebookDocuments = createStub("vscode.workspace.notebookDocuments")
+vscode.workspace.openNotebookDocument = (_uri) => {
+	console.log("Called stubbed function: vscode.workspace.openNotebookDocument")
+	return Promise.resolve(null)
+}
+vscode.workspace.openNotebookDocument = (_notebookType, _content) => {
+	console.log("Called stubbed function: vscode.workspace.openNotebookDocument")
+	return Promise.resolve(null)
+}
+vscode.workspace.onDidChangeNotebookDocument = createStub("vscode.workspace.onDidChangeNotebookDocument")
+vscode.workspace.onWillSaveNotebookDocument = createStub("vscode.workspace.onWillSaveNotebookDocument")
+vscode.workspace.onDidSaveNotebookDocument = createStub("vscode.workspace.onDidSaveNotebookDocument")
+vscode.workspace.registerNotebookSerializer = (_notebookType, _serializer, _options) => {
+	console.log("Called stubbed function: vscode.workspace.registerNotebookSerializer")
+	return createStub("unknown")
+}
+vscode.workspace.onDidOpenNotebookDocument = createStub("vscode.workspace.onDidOpenNotebookDocument")
+vscode.workspace.onDidCloseNotebookDocument = createStub("vscode.workspace.onDidCloseNotebookDocument")
+vscode.workspace.onWillCreateFiles = createStub("vscode.workspace.onWillCreateFiles")
+vscode.workspace.onDidCreateFiles = createStub("vscode.workspace.onDidCreateFiles")
+vscode.workspace.onWillDeleteFiles = createStub("vscode.workspace.onWillDeleteFiles")
+vscode.workspace.onDidDeleteFiles = createStub("vscode.workspace.onDidDeleteFiles")
+vscode.workspace.onWillRenameFiles = createStub("vscode.workspace.onWillRenameFiles")
+vscode.workspace.onDidRenameFiles = createStub("vscode.workspace.onDidRenameFiles")
+
+const workspaceConfigStore = {}
+vscode.workspace.getConfiguration = (section) => ({
+	get: (key, defaultValue) => {
+		return workspaceConfigStore[`${section}.${key}`] ?? defaultValue
+	},
+	update: (key, value, _global) => {
+		workspaceConfigStore[`${section}.${key}`] = value
+	},
+	has: (key) => {
+		return `${section}.${key}` in workspaceConfigStore
+	},
+})
+
+vscode.workspace.onDidChangeConfiguration = createStub("vscode.workspace.onDidChangeConfiguration")
+vscode.workspace.registerTaskProvider = (_type, _provider) => {
+	console.log("Called stubbed function: vscode.workspace.registerTaskProvider")
+	return createStub("unknown")
+}
+vscode.workspace.registerFileSystemProvider = (_scheme, _provider, _options) => {
+	console.log("Called stubbed function: vscode.workspace.registerFileSystemProvider")
+	return createStub("unknown")
+}
+vscode.workspace.isTrusted = createStub("vscode.workspace.isTrusted")
+vscode.workspace.onDidGrantWorkspaceTrust = createStub("vscode.workspace.onDidGrantWorkspaceTrust")
+vscode.languages = {}
+vscode.languages.getLanguages = () => {
+	console.log("Called stubbed function: vscode.languages.getLanguages")
+	return ""
+}
+vscode.languages.setTextDocumentLanguage = (_document, _languageId) => {
+	console.log("Called stubbed function: vscode.languages.setTextDocumentLanguage")
+	return Promise.resolve(null)
+}
+vscode.languages.match = (_selector, _document) => {
+	console.log("Called stubbed function: vscode.languages.match")
+	return 0
+}
+vscode.languages.onDidChangeDiagnostics = createStub("vscode.languages.onDidChangeDiagnostics")
+vscode.languages.getDiagnostics = (_resource) => {
+	console.log("Called stubbed function: vscode.languages.getDiagnostics")
+	return []
+}
+vscode.languages.getDiagnostics = () => {
+	console.log("Called stubbed function: vscode.languages.getDiagnostics")
+	return []
+}
+vscode.languages.createDiagnosticCollection = (_name) => {
+	console.log("Called stubbed function: vscode.languages.createDiagnosticCollection")
+	return createStub("unknown")
+}
+vscode.languages.createLanguageStatusItem = (_id, _selector) => {
+	console.log("Called stubbed function: vscode.languages.createLanguageStatusItem")
+	return createStub("unknown")
+}
+vscode.languages.registerCompletionItemProvider = (_selector, _provider, _triggerCharacters) => {
+	console.log("Called stubbed function: vscode.languages.registerCompletionItemProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerInlineCompletionItemProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerInlineCompletionItemProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerCodeActionsProvider = (_selector, _provider, _metadata) => {
+	console.log("Called stubbed function: vscode.languages.registerCodeActionsProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerCodeLensProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerCodeLensProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDefinitionProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDefinitionProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerImplementationProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerImplementationProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerTypeDefinitionProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerTypeDefinitionProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDeclarationProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDeclarationProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerHoverProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerHoverProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerEvaluatableExpressionProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerEvaluatableExpressionProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerInlineValuesProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerInlineValuesProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentHighlightProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentHighlightProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentSymbolProvider = (_selector, _provider, _metaData) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentSymbolProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerWorkspaceSymbolProvider = (_provider) => {
+	console.log("Called stubbed function: vscode.languages.registerWorkspaceSymbolProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerReferenceProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerReferenceProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerRenameProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerRenameProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentSemanticTokensProvider = (_selector, _provider, _legend) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentSemanticTokensProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentRangeSemanticTokensProvider = (_selector, _provider, _legend) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentRangeSemanticTokensProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentFormattingEditProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentFormattingEditProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentRangeFormattingEditProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentRangeFormattingEditProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerOnTypeFormattingEditProvider = (_selector, _provider, _firstTriggerCharacter, _moreTriggerCharacter) => {
+	console.log("Called stubbed function: vscode.languages.registerOnTypeFormattingEditProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerSignatureHelpProvider = (_selector, _provider, _triggerCharacters) => {
+	console.log("Called stubbed function: vscode.languages.registerSignatureHelpProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerSignatureHelpProvider = (_selector, _provider, _metadata) => {
+	console.log("Called stubbed function: vscode.languages.registerSignatureHelpProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentLinkProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentLinkProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerColorProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerColorProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerInlayHintsProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerInlayHintsProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerFoldingRangeProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerFoldingRangeProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerSelectionRangeProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerSelectionRangeProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerCallHierarchyProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerCallHierarchyProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerTypeHierarchyProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerTypeHierarchyProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerLinkedEditingRangeProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerLinkedEditingRangeProvider")
+	return createStub("unknown")
+}
+vscode.languages.registerDocumentDropEditProvider = (_selector, _provider) => {
+	console.log("Called stubbed function: vscode.languages.registerDocumentDropEditProvider")
+	return createStub("unknown")
+}
+vscode.languages.setLanguageConfiguration = (_language, _configuration) => {
+	console.log("Called stubbed function: vscode.languages.setLanguageConfiguration")
+	return createStub("unknown")
+}
+vscode.NotebookEditorRevealType = { Default: 0, InCenter: 0, InCenterIfOutsideViewport: 0, AtTop: 0 }
+vscode.NotebookCellKind = { Markup: 0, Code: 0 }
+vscode.NotebookRange = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookRange(", args, ")")
+		return createStub(vscode.NotebookRange)
+	}
+}
+vscode.NotebookCellOutputItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookCellOutputItem(", args, ")")
+		return createStub(vscode.NotebookCellOutputItem)
+	}
+}
+vscode.NotebookCellOutput = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookCellOutput(", args, ")")
+		return createStub(vscode.NotebookCellOutput)
+	}
+}
+vscode.NotebookCellData = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookCellData(", args, ")")
+		return createStub(vscode.NotebookCellData)
+	}
+}
+vscode.NotebookData = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookData(", args, ")")
+		return createStub(vscode.NotebookData)
+	}
+}
+vscode.NotebookControllerAffinity = { Default: 0, Preferred: 0 }
+vscode.NotebookCellStatusBarAlignment = { Left: 0, Right: 0 }
+vscode.NotebookCellStatusBarItem = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.NotebookCellStatusBarItem(", args, ")")
+		return createStub(vscode.NotebookCellStatusBarItem)
+	}
+}
+vscode.notebooks = {}
+vscode.notebooks.createNotebookController = (_id, _notebookType, _label, _handler) => {
+	console.log("Called stubbed function: vscode.notebooks.createNotebookController")
+	return createStub("unknown")
+}
+vscode.notebooks.registerNotebookCellStatusBarItemProvider = (_notebookType, _provider) => {
+	console.log("Called stubbed function: vscode.notebooks.registerNotebookCellStatusBarItemProvider")
+	return createStub("unknown")
+}
+vscode.notebooks.createRendererMessaging = (_rendererId) => {
+	console.log("Called stubbed function: vscode.notebooks.createRendererMessaging")
+	return createStub("unknown")
+}
+vscode.scm = {}
+vscode.scm.inputBox = createStub("vscode.scm.inputBox")
+vscode.scm.createSourceControl = (_id, _label, _rootUri) => {
+	console.log("Called stubbed function: vscode.scm.createSourceControl")
+	return createStub("unknown")
+}
+vscode.DebugAdapterExecutable = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DebugAdapterExecutable(", args, ")")
+		return createStub(vscode.DebugAdapterExecutable)
+	}
+}
+vscode.DebugAdapterServer = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DebugAdapterServer(", args, ")")
+		return createStub(vscode.DebugAdapterServer)
+	}
+}
+vscode.DebugAdapterNamedPipeServer = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DebugAdapterNamedPipeServer(", args, ")")
+		return createStub(vscode.DebugAdapterNamedPipeServer)
+	}
+}
+vscode.DebugAdapterInlineImplementation = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.DebugAdapterInlineImplementation(", args, ")")
+		return createStub(vscode.DebugAdapterInlineImplementation)
+	}
+}
+vscode.Breakpoint = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.Breakpoint(", args, ")")
+		return createStub(vscode.Breakpoint)
+	}
+}
+vscode.SourceBreakpoint = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.SourceBreakpoint(", args, ")")
+		return createStub(vscode.SourceBreakpoint)
+	}
+}
+vscode.FunctionBreakpoint = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.FunctionBreakpoint(", args, ")")
+		return createStub(vscode.FunctionBreakpoint)
+	}
+}
+vscode.DebugConsoleMode = { Separate: 0, MergeWithParent: 0 }
+vscode.DebugConfigurationProviderTriggerKind = { Initial: 0, Dynamic: 0 }
+vscode.debug = {}
+vscode.debug.activeDebugSession = createStub("vscode.debug.activeDebugSession")
+vscode.debug.activeDebugConsole = createStub("vscode.debug.activeDebugConsole")
+vscode.debug.breakpoints = createStub("vscode.debug.breakpoints")
+vscode.debug.onDidChangeActiveDebugSession = createStub("vscode.debug.onDidChangeActiveDebugSession")
+vscode.debug.onDidStartDebugSession = createStub("vscode.debug.onDidStartDebugSession")
+vscode.debug.onDidReceiveDebugSessionCustomEvent = createStub("vscode.debug.onDidReceiveDebugSessionCustomEvent")
+vscode.debug.onDidTerminateDebugSession = createStub("vscode.debug.onDidTerminateDebugSession")
+vscode.debug.onDidChangeBreakpoints = createStub("vscode.debug.onDidChangeBreakpoints")
+vscode.debug.registerDebugConfigurationProvider = (_debugType, _provider, _triggerKind) => {
+	console.log("Called stubbed function: vscode.debug.registerDebugConfigurationProvider")
+	return createStub("unknown")
+}
+vscode.debug.registerDebugAdapterDescriptorFactory = (_debugType, _factory) => {
+	console.log("Called stubbed function: vscode.debug.registerDebugAdapterDescriptorFactory")
+	return createStub("unknown")
+}
+vscode.debug.registerDebugAdapterTrackerFactory = (_debugType, _factory) => {
+	console.log("Called stubbed function: vscode.debug.registerDebugAdapterTrackerFactory")
+	return createStub("unknown")
+}
+vscode.debug.startDebugging = (_folder, _nameOrConfiguration, _parentSessionOrOptions) => {
+	console.log("Called stubbed function: vscode.debug.startDebugging")
+	return false
+}
+vscode.debug.stopDebugging = (_session) => {
+	console.log("Called stubbed function: vscode.debug.stopDebugging")
+}
+vscode.debug.addBreakpoints = (_breakpoints) => {
+	console.log("Called stubbed function: vscode.debug.addBreakpoints")
+}
+vscode.debug.removeBreakpoints = (_breakpoints) => {
+	console.log("Called stubbed function: vscode.debug.removeBreakpoints")
+}
+vscode.debug.asDebugSourceUri = (_source, _session) => {
+	console.log("Called stubbed function: vscode.debug.asDebugSourceUri")
+	return createStub("unknown")
+}
+vscode.extensions = {}
+vscode.extensions.getExtension = (_extensionId) => {
+	console.log("Called stubbed function: vscode.extensions.getExtension")
+	return createStub("unknown")
+}
+vscode.extensions.all = []
+vscode.extensions.onDidChange = createStub("vscode.extensions.onDidChange")
+vscode.CommentThreadCollapsibleState = { Collapsed: 0, Expanded: 0 }
+vscode.CommentMode = { Editing: 0, Preview: 0 }
+vscode.CommentThreadState = { Unresolved: 0, Resolved: 0 }
+vscode.comments = {}
+vscode.comments.createCommentController = (_id, _label) => {
+	console.log("Called stubbed function: vscode.comments.createCommentController")
+	return createStub("unknown")
+}
+vscode.authentication = {}
+vscode.authentication.getSession = (_providerId, _scopes, _options) => {
+	console.log("Called stubbed function: vscode.authentication.getSession")
+	return Promise.resolve(null)
+}
+vscode.authentication.getSession = (_providerId, _scopes, _options) => {
+	console.log("Called stubbed function: vscode.authentication.getSession")
+	return Promise.resolve(null)
+}
+vscode.authentication.getSession = (_providerId, _scopes, _options) => {
+	console.log("Called stubbed function: vscode.authentication.getSession")
+	return Promise.resolve(null)
+}
+vscode.authentication.onDidChangeSessions = createStub("vscode.authentication.onDidChangeSessions")
+vscode.authentication.registerAuthenticationProvider = (_id, _label, _provider, _options) => {
+	console.log("Called stubbed function: vscode.authentication.registerAuthenticationProvider")
+	return createStub("unknown")
+}
+vscode.l10n = {}
+vscode.l10n.t = (_message, _args) => {
+	console.log("Called stubbed function: vscode.l10n.t")
+	return ""
+}
+vscode.l10n.t = (_message, _args) => {
+	console.log("Called stubbed function: vscode.l10n.t")
+	return ""
+}
+vscode.l10n.t = (_options) => {
+	console.log("Called stubbed function: vscode.l10n.t")
+	return ""
+}
+vscode.l10n.bundle = createStub("vscode.l10n.bundle")
+vscode.l10n.uri = createStub("vscode.l10n.uri")
+vscode.tests = {}
+vscode.tests.createTestController = (_id, _label) => {
+	console.log("Called stubbed function: vscode.tests.createTestController")
+	return createStub("unknown")
+}
+vscode.TestRunProfileKind = { Run: 0, Debug: 0, Coverage: 0 }
+vscode.TestTag = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TestTag(", args, ")")
+		return createStub(vscode.TestTag)
+	}
+}
+vscode.TestRunRequest = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TestRunRequest(", args, ")")
+		return createStub(vscode.TestRunRequest)
+	}
+}
+vscode.TestMessage = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TestMessage(", args, ")")
+		return createStub(vscode.TestMessage)
+	}
+}
+vscode.TabInputText = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputText(", args, ")")
+		return createStub(vscode.TabInputText)
+	}
+}
+vscode.TabInputTextDiff = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputTextDiff(", args, ")")
+		return createStub(vscode.TabInputTextDiff)
+	}
+}
+vscode.TabInputCustom = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputCustom(", args, ")")
+		return createStub(vscode.TabInputCustom)
+	}
+}
+vscode.TabInputWebview = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputWebview(", args, ")")
+		return createStub(vscode.TabInputWebview)
+	}
+}
+vscode.TabInputNotebook = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputNotebook(", args, ")")
+		return createStub(vscode.TabInputNotebook)
+	}
+}
+vscode.TabInputNotebookDiff = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputNotebookDiff(", args, ")")
+		return createStub(vscode.TabInputNotebookDiff)
+	}
+}
+vscode.TabInputTerminal = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TabInputTerminal(", args, ")")
+		return createStub(vscode.TabInputTerminal)
+	}
+}
+vscode.TelemetryTrustedValue = class {
+	constructor(...args) {
+		console.log("Constructed stubbed class: new vscode.TelemetryTrustedValue(", args, ")")
+		return createStub(vscode.TelemetryTrustedValue)
+	}
+}
+module.exports = vscode
+console.log("Finished loading stubs")
diff --git a/apps/vscode/test-setup.js b/apps/vscode/test-setup.js
new file mode 100644
index 0000000..0fd3c16
--- /dev/null
+++ b/apps/vscode/test-setup.js
@@ -0,0 +1,278 @@
+const tsConfigPaths = require("tsconfig-paths")
+const fs = require("fs")
+const path = require("path")
+const Module = require("module")
+
+const baseUrl = path.resolve(__dirname)
+
+const tsConfig = JSON.parse(fs.readFileSync(path.join(baseUrl, "tsconfig.json"), "utf-8"))
+
+/**
+ * The aliases point towards the `src` directory.
+ * However, `tsc` doesn't compile paths by itself
+ * (https://www.typescriptlang.org/docs/handbook/modules/reference.html#paths-does-not-affect-emit)
+ * So we need to use tsconfig-paths to resolve the aliases when running tests,
+ * but pointing to `out` instead.
+ */
+const outPaths = {}
+Object.keys(tsConfig.compilerOptions.paths).forEach((key) => {
+	const value = tsConfig.compilerOptions.paths[key]
+	outPaths[key] = value.map((path) => path.replace("src", "out/src"))
+})
+
+tsConfigPaths.register({
+	baseUrl: baseUrl,
+	paths: outPaths,
+})
+
+// Mock the @google/genai module to avoid ESM compatibility issues in tests
+// The module is ES6 only, but the integration tests are compiled to commonJS.
+const originalRequire = Module.prototype.require
+Module.prototype.require = function (id) {
+	// Intercept requires for @google/genai
+	if (id === "@google/genai") {
+		// Return the mock instead
+		const mockPath = path.join(baseUrl, "out/src/test/fixtures/google-genai-mock.js")
+		return originalRequire.call(this, mockPath)
+	}
+
+	// The SDK packages are ESM-only and expose only an `import` condition.
+	// Integration tests run the tsc-built `out/` tree as CommonJS in VS Code's
+	// extension host, so `require("@cline/core")` fails before tests start.
+	// Mock the small surface needed by legacy VS Code integration tests.
+	if (id === "@cline/core") {
+		const createNoopTelemetry = () => ({
+			setDistinctId() {},
+			setMetadata() {},
+			updateMetadata() {},
+			setCommonProperties() {},
+			updateCommonProperties() {},
+			isEnabled: () => false,
+			capture() {},
+			captureRequired() {},
+			recordCounter() {},
+			recordHistogram() {},
+			recordGauge() {},
+			flush: async () => {},
+			dispose: async () => {},
+		})
+
+		class ProviderSettingsManager {
+			constructor(_options) {
+				this.state = { providers: {}, lastUsedProvider: undefined }
+			}
+
+			read() {
+				return this.state
+			}
+
+			getLastUsedProviderSettings() {
+				return undefined
+			}
+
+			getProviderSettings(_provider) {
+				return undefined
+			}
+
+			saveProviderSettings(_settings, _options) {}
+		}
+
+		const getProviderAuthStorageId = (providerId) => {
+			const normalized = String(providerId || "")
+				.trim()
+				.toLowerCase()
+			if (normalized === "cline" || normalized === "cline-pass") return "cline"
+			if (normalized === "oca" || normalized === "openai-codex") return normalized
+			return undefined
+		}
+		const formatClineApiKey = (token) => {
+			const trimmed = String(token || "").trim()
+			return trimmed.toLowerCase().startsWith("workos:") ? trimmed : `workos:${trimmed}`
+		}
+		const getProviderAuthHandler = (providerId) => {
+			const storageProviderId = getProviderAuthStorageId(providerId)
+			if (!storageProviderId) return undefined
+			return {
+				providerId,
+				storageProviderId,
+				getApiKey(settings) {
+					const accessToken = settings?.auth?.accessToken?.trim?.()
+					if (accessToken) return storageProviderId === "cline" ? formatClineApiKey(accessToken) : accessToken
+					return settings?.apiKey?.trim?.() || settings?.auth?.apiKey?.trim?.() || undefined
+				},
+			}
+		}
+		const resolveProviderApiKeyFromSettings = (manager, providerId) => {
+			const handler = getProviderAuthHandler(providerId)
+			const storageProviderId = handler?.storageProviderId ?? providerId
+			const settings = manager.getProviderSettings(storageProviderId)
+			return handler?.getApiKey(settings) ?? settings?.apiKey?.trim?.()
+		}
+		const listLocalProviders = async (manager) => ({ providers: [], settingsPath: manager.getFilePath?.() ?? "" })
+
+		return {
+			createClineTelemetryServiceConfig: (config = {}) => ({
+				enabled: false,
+				metadata: {
+					extension_version: "test",
+					cline_type: "test",
+					platform: "test",
+					platform_version: "test",
+					os_type: "test",
+					os_version: "test",
+				},
+				...config,
+			}),
+			createConfiguredTelemetryHandle: () => ({
+				telemetry: createNoopTelemetry(),
+				flush: async () => {},
+				dispose: async () => {},
+			}),
+			ClineCore: class {
+				constructor() {
+					this.runtimeAddress = undefined
+					this.pendingPrompts = {
+						list: async () => [],
+						update: async () => ({ updated: false }),
+						delete: async () => ({ updated: false }),
+					}
+				}
+
+				static async create() {
+					return new this()
+				}
+
+				async start() {
+					return { sessionId: "test-session" }
+				}
+
+				async send() {
+					return undefined
+				}
+
+				async getAccumulatedUsage() {
+					return { usage: undefined }
+				}
+
+				async abort() {}
+				async stop() {}
+				async dispose() {}
+				async get() {
+					return undefined
+				}
+				async list() {
+					return []
+				}
+				async listHistory() {
+					return []
+				}
+				async delete() {
+					return false
+				}
+				async readMessages() {
+					return []
+				}
+				async update() {
+					return { updated: false }
+				}
+				async ingestHookEvent() {}
+				async updateSessionModel() {}
+				subscribe() {
+					return () => {}
+				}
+			},
+			ProviderSettingsManager,
+			listLocalProviders,
+			resolveProviderConfig: async () => undefined,
+			getProviderConfigFields: () => [],
+			fetchClineRecommendedModels: async () => ({ recommended: [], free: [] }),
+			readGlobalSettings: () => ({ telemetryOptOut: false }),
+			setTelemetryOptOutGlobally: () => undefined,
+			prepareRemoteConfigCoreIntegration: () => undefined,
+			createDefaultExecutors: () => ({}),
+			createMcpTools: () => ({}),
+			createOAuthClientCallbacks: () => ({}),
+			getProviderAuthHandler,
+			getProviderAuthStorageId,
+			resolveProviderApiKeyFromSettings,
+			getValidClineCredentials: async () => undefined,
+			loginClineOAuth: async () => undefined,
+			loginOcaOAuth: async () => undefined,
+			loginOpenAICodex: async () => undefined,
+		}
+	}
+
+	if (id === "@cline/shared") {
+		return {
+			buildClineSystemPrompt: () => "",
+			createTool: (tool) => tool,
+			formatDisplayUserInput: (input) => (typeof input === "string" ? input : JSON.stringify(input)),
+		}
+	}
+
+	if (id === "@cline/shared/storage") {
+		return {
+			resolveGlobalSettingsPath: () => path.join(baseUrl, ".vscode-test", "shared-global-settings.json"),
+		}
+	}
+
+	if (id === "@cline/llms") {
+		return {
+			getAllProviders: async () => [],
+			getGeneratedModelsForProvider: () => ({}),
+			getProviderCollectionSync: () => undefined,
+			MODEL_COLLECTIONS_BY_PROVIDER_ID: {},
+		}
+	}
+
+	if (id === "vitest") {
+		const assert = require("node:assert/strict")
+		const makeMockFn = (implementation = () => undefined) => {
+			const fn = (...args) => implementation(...args)
+			fn.mock = { calls: [] }
+			const wrapped = (...args) => {
+				wrapped.mock.calls.push(args)
+				return implementation(...args)
+			}
+			wrapped.mock = fn.mock
+			wrapped.mockImplementation = (next) => {
+				implementation = next
+				return wrapped
+			}
+			wrapped.mockResolvedValue = (value) => wrapped.mockImplementation(() => Promise.resolve(value))
+			wrapped.mockReturnValue = (value) => wrapped.mockImplementation(() => value)
+			return wrapped
+		}
+		const expect = (actual) => ({
+			toBe: (expected) => assert.equal(actual, expected),
+			toEqual: (expected) => assert.deepEqual(actual, expected),
+			toBeDefined: () => assert.notEqual(actual, undefined),
+			toBeTruthy: () => assert.ok(actual),
+			toBeGreaterThanOrEqual: (expected) => assert.ok(actual >= expected),
+			toContain: (expected) => assert.ok(actual.includes(expected)),
+			toHaveLength: (expected) => assert.equal(actual.length, expected),
+			not: {
+				toBe: (expected) => assert.notEqual(actual, expected),
+				toContain: (expected) => assert.ok(!actual.includes(expected)),
+			},
+		})
+		return {
+			afterAll: globalThis.after ?? (() => undefined),
+			afterEach: globalThis.afterEach ?? (() => undefined),
+			beforeAll: globalThis.before ?? (() => undefined),
+			beforeEach: globalThis.beforeEach ?? (() => undefined),
+			describe: globalThis.describe ?? (() => undefined),
+			expect,
+			it: globalThis.it ?? (() => undefined),
+			vi: {
+				fn: makeMockFn,
+				mock: () => undefined,
+				mocked: (value) => value,
+				clearAllMocks: () => undefined,
+				restoreAllMocks: () => undefined,
+			},
+		}
+	}
+
+	return originalRequire.call(this, id)
+}
diff --git a/apps/vscode/testing-platform/README.md b/apps/vscode/testing-platform/README.md
new file mode 100644
index 0000000..8a8fe06
--- /dev/null
+++ b/apps/vscode/testing-platform/README.md
@@ -0,0 +1,65 @@
+# Cline Testing Platform
+
+A CLI testing framework for the Cline Core extension, providing gRPC-based integration clients and utilities for automated scenarios.
+
+## Overview
+
+The platform enables end-to-end validation of Cline's core functionality through:
+
+- **gRPC Adapters** – clients for Cline’s gRPC services  
+- **Test Harness** – runner, utilities, and type definitions  
+- **Spec Files** – JSON instructions for automated test cases  
+
+## Structure
+
+```
+testing-platform/
+├── adapters/           # gRPC communication adapters
+│   ├── grpcAdapter.ts     # Main gRPC adapter implementation
+├── harness/            # Test execution framework
+│   ├── runner.ts          # Main test runner
+│   ├── types.ts           # Type definitions
+│   └── utils.ts           # Utility functions
+```
+
+## Prerequisites
+
+- **Node.js** ≥ 18 (the runtime) and **bun** (package manager + task runner)  
+- **Protocol Buffers** (used for gRPC)  
+
+Generate proto files in the **root Cline project**:
+
+```bash
+bun run protos
+```
+
+## Setup
+
+From the root of the Cline project:
+
+```bash
+bun run install:all
+bun run protos
+```
+
+Then install and build the testing platform:
+
+```bash
+cd testing-platform
+bun install
+bun run build
+```
+
+## Running Spec File Tests
+
+Before running specs, make sure the standalone Cline Core gRPC server (that runs mocks and host gRPC as well) is running:
+
+```bash
+bun run test:sca-server
+```
+
+Then finally you can run the cli as:
+
+```bash
+bun run start:dev <spec-file-or-folder>
+```bash
diff --git a/apps/vscode/testing-platform/adapters/grpcAdapter.ts b/apps/vscode/testing-platform/adapters/grpcAdapter.ts
new file mode 100644
index 0000000..0821848
--- /dev/null
+++ b/apps/vscode/testing-platform/adapters/grpcAdapter.ts
@@ -0,0 +1,72 @@
+import { AccountServiceClient } from "@cline-grpc/account"
+import { BrowserServiceClient } from "@cline-grpc/browser"
+import { CheckpointsServiceClient } from "@cline-grpc/checkpoints"
+import { CommandsServiceClient } from "@cline-grpc/commands"
+import { FileServiceClient } from "@cline-grpc/file"
+import { McpServiceClient } from "@cline-grpc/mcp"
+import { ModelsServiceClient } from "@cline-grpc/models"
+import { SlashServiceClient } from "@cline-grpc/slash"
+import { StateServiceClient } from "@cline-grpc/state"
+import { TaskServiceClient } from "@cline-grpc/task"
+import { UiServiceClient } from "@cline-grpc/ui"
+import { WebServiceClient } from "@cline-grpc/web"
+import { credentials } from "@grpc/grpc-js"
+import { promisify } from "util"
+
+const serviceRegistry = {
+	"cline.AccountService": AccountServiceClient,
+	"cline.BrowserService": BrowserServiceClient,
+	"cline.CheckpointsService": CheckpointsServiceClient,
+	"cline.CommandsService": CommandsServiceClient,
+	"cline.FileService": FileServiceClient,
+	"cline.McpService": McpServiceClient,
+	"cline.ModelsService": ModelsServiceClient,
+	"cline.SlashService": SlashServiceClient,
+	"cline.StateService": StateServiceClient,
+	"cline.TaskService": TaskServiceClient,
+	"cline.UiService": UiServiceClient,
+	"cline.WebService": WebServiceClient,
+} as const
+
+export type ServiceClients = {
+	-readonly [K in keyof typeof serviceRegistry]: InstanceType<(typeof serviceRegistry)[K]>
+}
+
+export class GrpcAdapter {
+	private clients: Partial<ServiceClients> = {}
+
+	constructor(address: string) {
+		for (const [name, Client] of Object.entries(serviceRegistry)) {
+			this.clients[name as keyof ServiceClients] = new (Client as any)(address, credentials.createInsecure())
+		}
+	}
+
+	async call(service: keyof ServiceClients, method: string, request: any): Promise<any> {
+		const client = this.clients[service]
+		if (!client) {
+			throw new Error(`No gRPC client registered for service: ${String(service)}`)
+		}
+
+		const fn = (client as any)[method]
+		if (typeof fn !== "function") {
+			throw new Error(`Method ${method} not found on service ${String(service)}`)
+		}
+
+		try {
+			const fnAsync = promisify(fn).bind(client)
+			const response = await fnAsync(request.message)
+			return response?.toObject ? response.toObject() : response
+		} catch (error) {
+			console.error(`[GrpcAdapter] ${service}.${method} failed:`, error)
+			throw error
+		}
+	}
+
+	close(): void {
+		for (const client of Object.values(this.clients)) {
+			if (client && typeof (client as any).close === "function") {
+				;(client as any).close()
+			}
+		}
+	}
+}
diff --git a/apps/vscode/testing-platform/harness/config.ts b/apps/vscode/testing-platform/harness/config.ts
new file mode 100644
index 0000000..fe9b50c
--- /dev/null
+++ b/apps/vscode/testing-platform/harness/config.ts
@@ -0,0 +1,44 @@
+// Note: This list is temporary. Some items may remain in the long run,
+// but our goal is to reduce it over time by continuously improving
+// how we prepare the testing-platform environment.
+export const NON_DETERMINISTIC_FIELDS = [
+	"stateJson.version",
+	"stateJson.distinctId",
+	"stateJson.shouldShowAnnouncement",
+	"stateJson.platform",
+	"stateJson.clineMessages.ts",
+	"paymentTransactions.paidAt",
+	"usageTransactions.createdAt",
+
+	"stateJson.taskHistory.cwdOnTaskInitialization",
+	"stateJson.taskHistory.id",
+	"stateJson.taskHistory.size",
+	"stateJson.taskHistory.ts",
+	"stateJson.taskHistory.ulid",
+	"stateJson.taskHistory.cacheWrites",
+	"stateJson.taskHistory.cacheReads",
+	"stateJson.taskHistory.tokensIn",
+	"stateJson.taskHistory.tokensOut",
+	"stateJson.taskHistory.totalCost",
+
+	"stateJson.currentTaskItem",
+
+	"stateJson.workspaceRoots.commitHash",
+	"stateJson.workspaceRoots.name",
+	"stateJson.workspaceRoots.path",
+	"stateJson.workspaceRoots.vcs",
+
+	"tasks.id",
+	"tasks.size",
+	"tasks.ts",
+	"tasks.ulid",
+	"tasks.cacheWrites",
+	"tasks.cacheReads",
+	"tasks.tokensIn",
+	"tasks.tokensOut",
+	"tasks.totalCost",
+
+	"stateJson.clineMessages",
+	"stateJson.autoApprovalSettings.version",
+	"stateJson.browserSettings.chromeExecutablePath",
+]
diff --git a/apps/vscode/testing-platform/harness/types.ts b/apps/vscode/testing-platform/harness/types.ts
new file mode 100644
index 0000000..55d821e
--- /dev/null
+++ b/apps/vscode/testing-platform/harness/types.ts
@@ -0,0 +1,25 @@
+import { ServiceClients } from "@adapters/grpcAdapter"
+
+export interface Meta {
+	synthetic: boolean
+	/**
+	 * Optional subset of the expected response to validate.
+	 * Only the fields specified here will be compared against the actual response.
+	 * Useful for partial validation of nested objects or arrays.
+	 */
+	expected?: any
+}
+
+export interface Entry {
+	requestId: string
+	service: keyof ServiceClients
+	method: string
+	request: any
+	response?: any
+	status: string
+	meta: Meta
+}
+
+export interface SpecFile {
+	entries: Entry[]
+}
diff --git a/apps/vscode/testing-platform/harness/utils.ts b/apps/vscode/testing-platform/harness/utils.ts
new file mode 100644
index 0000000..6e0afe4
--- /dev/null
+++ b/apps/vscode/testing-platform/harness/utils.ts
@@ -0,0 +1,180 @@
+import fs from "fs"
+import { diff } from "jest-diff"
+import _ from "lodash"
+import path from "path"
+
+export function loadJson(filePath: string): any {
+	return JSON.parse(fs.readFileSync(path.resolve(filePath), "utf-8"))
+}
+
+export function pretty(obj: any): string {
+	return JSON.stringify(obj, null, 2)
+}
+
+/**
+ * Recursively normalizes an object or array by:
+ * 1. Ignoring specified fields.
+ * 2. Sorting arrays in a stable manner.
+ * 3. Parsing JSON strings where possible.
+ *
+ * This ensures that comparison between objects/arrays is consistent
+ * and ignores non-deterministic or irrelevant fields.
+ *
+ * @param obj - The object/array/value to normalize.
+ * @param ignoreFields - List of field names or dot-paths to ignore during normalization.
+ * @param parentPath - Internal use for tracking nested paths (used for ignoreFields).
+ * @returns A normalized object/array/value suitable for comparison.
+ */
+function normalize(obj: any, ignoreFields: string[] = [], parentPath = ""): any {
+	if (Array.isArray(obj)) {
+		// Normalize each element, then sort in a stable way
+		const normalizedArray = obj.map((item) => normalize(item, ignoreFields, parentPath))
+
+		// Sort array by JSON stringification (works for objects & primitives)
+		return normalizedArray.sort((a, b) => {
+			const sa = JSON.stringify(a)
+			const sb = JSON.stringify(b)
+			return sa < sb ? -1 : sa > sb ? 1 : 0
+		})
+	}
+	if (obj && typeof obj === "object") {
+		const result: Record<string, any> = {}
+		for (const [k, v] of Object.entries(obj)) {
+			const currentPath = parentPath ? `${parentPath}.${k}` : k
+			if (ignoreFields.includes(currentPath) || ignoreFields.includes(k)) {
+				continue
+			}
+			result[k] = normalize(v, ignoreFields, currentPath)
+		}
+		return result
+	}
+	if (typeof obj === "string") {
+		try {
+			return normalize(JSON.parse(obj), ignoreFields, parentPath)
+		} catch {
+			return obj
+		}
+	}
+	return obj
+}
+
+/**
+ * Recursively picks only the keys specified in `filter` from `actual`.
+ * This is used for partial comparison of objects and arrays.
+ *
+ * Behavior:
+ * 1. For objects: keeps only keys present in `filter`, recursively.
+ * 2. For arrays: assumes `filter` is an array and picks corresponding keys
+ *    from each element in `actual` array.
+ * 3. For primitives: returns the actual value.
+ *
+ * @param actual - The full object/array/value received.
+ * @param filter - The subset of keys/structure to keep from `actual`.
+ * @returns A new object/array/value that only contains keys from `filter`.
+ *
+ * Example:
+ * actual = {
+ *   a: 1,
+ *   b: { x: 10, y: 20 },
+ *   c: [{ id: 1, val: "x" }, { id: 2, val: "y" }]
+ * }
+ *
+ * filter = {
+ *   b: { y: 20 },
+ *   c: [{ val: "x" }]
+ * }
+ *
+ * Result:
+ * {
+ *   b: { y: 20 },
+ *   c: [{ val: "x" }, undefined]
+ * }
+ */
+function pickDeep(actual: any, filter: any): any {
+	if (_.isArray(filter)) {
+		if (!_.isArray(actual)) return actual
+
+		// Compare arrays element by element, picking only keys from filter
+		return filter.map((f, i) => pickDeep(actual[i], f))
+	}
+
+	if (_.isPlainObject(filter)) {
+		return _.mapValues(filter, (v, k) => (actual && k in actual ? pickDeep(actual[k], v) : undefined))
+	}
+
+	return actual
+}
+
+/**
+ * Compares an actual response against an expected response, with optional:
+ * - Ignored fields
+ * - Partial comparison (via expectedSubset)
+ *
+ * Behavior:
+ * 1. Normalizes actual and expected objects (sorting arrays, parsing JSON strings).
+ * 2. If expectedSubset is provided, only compares the keys/structure defined in it.
+ * 3. Returns a boolean success flag and an array of diffs (for reporting mismatches).
+ *
+ * @param actual - The response received from gRPC call.
+ * @param expected - The full expected response from the spec file.
+ * @param ignoreFields - Fields or paths to ignore in comparison.
+ * @param expectedSubset - Optional subset of fields to validate (for meta.expected).
+ * @returns Object with `success` (true/false) and `diffs` (array of string diffs).
+ */
+export function compareResponse(
+	actual: any,
+	expected: any,
+	ignoreFields: string[] = [],
+	expectedSubset?: any,
+): { success: boolean; diffs: string[] } {
+	const actualToCompare = normalize(actual, ignoreFields)
+	const expectedToCompare = normalize(expected, ignoreFields)
+
+	if (expectedSubset) {
+		// Extract only the subset we care about
+		const actualSubset = pickDeep(actualToCompare, expectedSubset)
+		const success = _.isEqual(actualSubset, expectedSubset)
+		if (!success) {
+			const difference = diff(expectedSubset, actualSubset, { expand: false })
+			return { success: false, diffs: [difference || "Objects differ"] }
+		}
+		return { success: true, diffs: [] }
+	}
+
+	// Fallback: full comparison
+	const success = _.isEqual(actualToCompare, expectedToCompare)
+	if (!success) {
+		const difference = diff(expectedToCompare, actualToCompare, { expand: false })
+		return { success: false, diffs: [difference || "Objects differ"] }
+	}
+	return { success: true, diffs: [] }
+}
+
+/**
+ * Retries a given asynchronous function up to a specified number of times.
+ *
+ * @template T - The type of the resolved value.
+ * @param fn - The async function to execute.
+ * @param retries - Maximum number of attempts before throwing the last error (default: 3).
+ * @param delayMs - Delay (in milliseconds) between retries (default: 100).
+ * @returns A promise that resolves with the function result if successful.
+ * @throws The last encountered error if all retries fail.
+ *
+ * @example
+ * await retry(() => fetchData(), 5, 200)
+ */
+export async function retry<T>(fn: () => Promise<T>, retries = 3, delayMs = 100): Promise<T> {
+	let lastError: any
+	for (let attempt = 1; attempt <= retries; attempt++) {
+		try {
+			return await fn()
+		} catch (err) {
+			lastError = err
+			if (attempt < retries) {
+				console.warn(`⚠️ Attempt ${attempt} failed, retrying in ${delayMs}ms...`)
+				await new Promise((r) => setTimeout(r, delayMs))
+			}
+		}
+	}
+	throw lastError
+}
diff --git a/apps/vscode/testing-platform/index.ts b/apps/vscode/testing-platform/index.ts
new file mode 100644
index 0000000..b93b515
--- /dev/null
+++ b/apps/vscode/testing-platform/index.ts
@@ -0,0 +1,125 @@
+#!/usr/bin/env ts-node
+
+import fs from "fs"
+import path from "path"
+import "tsconfig-paths/register"
+
+import { GrpcAdapter } from "@adapters/grpcAdapter"
+import { NON_DETERMINISTIC_FIELDS } from "@harness/config"
+import { SpecFile } from "@harness/types"
+import { compareResponse, loadJson, retry } from "@harness/utils"
+
+const STANDALONE_GRPC_SERVER_PORT = process.env.STANDALONE_GRPC_SERVER_PORT || "26040"
+const FIX_MODE = process.argv.includes("--fix")
+
+function shouldAttemptFix(): boolean {
+	return FIX_MODE
+}
+
+function shouldThrowError(fixed: boolean): boolean {
+	return !FIX_MODE || !fixed
+}
+
+async function tryFixEntry(
+	entry: SpecFile["entries"][number],
+	actualResponse: any,
+	spec: SpecFile,
+	specPath: string,
+): Promise<boolean> {
+	if (!shouldAttemptFix()) return false
+
+	console.warn(`✏️ Updating response for RequestID: ${entry.requestId}`)
+	entry.response.message = actualResponse
+	fs.writeFileSync(specPath, JSON.stringify(spec, null, 2) + "\n")
+	console.log(`💾 Spec file updated: ${specPath}`)
+
+	const { success } = compareResponse(actualResponse, entry?.response?.message, NON_DETERMINISTIC_FIELDS)
+
+	if (success) {
+		console.log("✅ Response matched after fix! RequestID: %s", entry.requestId)
+		return true
+	}
+
+	return false
+}
+
+async function runSpec(specPath: string, grpcAdapter: GrpcAdapter) {
+	const spec: SpecFile = loadJson(specPath)
+
+	for (const entry of spec.entries) {
+		console.log(`▶️ ${entry.service}.${entry.method}`)
+		let actualResponse
+		let fixed = false
+
+		try {
+			await retry(async () => {
+				actualResponse = await grpcAdapter.call(entry.service, entry.method, entry.request)
+
+				const { success, diffs } = compareResponse(
+					actualResponse,
+					entry?.response?.message,
+					NON_DETERMINISTIC_FIELDS,
+					entry.meta?.expected,
+				)
+
+				if (success) {
+					console.log("✅ Response matched! RequestID: %s", entry.requestId)
+					return
+				}
+
+				// Try to fix if mismatch
+				fixed = await tryFixEntry(entry, actualResponse, spec, specPath)
+
+				if (!fixed) {
+					const diffMsg = diffs.join("\n")
+					throw new Error(`❌ Response mismatch! RequestID: ${entry.requestId}\n${diffMsg}`)
+				}
+			})
+		} catch (err) {
+			if (shouldThrowError(fixed)) {
+				throw err
+			}
+			console.log("✅ Test passed after fixing response")
+		}
+	}
+}
+
+async function runSpecsFromFolder(folderPath: string, grpcAdapter: GrpcAdapter) {
+	const files = fs.readdirSync(folderPath).filter((f) => f.endsWith(".json"))
+
+	if (files.length === 0) {
+		console.warn(`⚠️ No JSON spec files found in ${folderPath}`)
+		return
+	}
+
+	for (const file of files) {
+		const fullPath = path.join(folderPath, file)
+		console.log(`\n📂 Running spec file: ${file}`)
+		await runSpec(fullPath, grpcAdapter)
+	}
+}
+
+async function main() {
+	const inputPath = process.argv[2]
+	if (!inputPath) {
+		console.error("Usage: bun index.ts <spec-file-or-folder> [--fix]")
+		process.exit(1)
+	}
+
+	const fullPath = path.resolve(inputPath)
+	const grpcAdapter = new GrpcAdapter(`localhost:${STANDALONE_GRPC_SERVER_PORT}`)
+
+	const stat = fs.statSync(fullPath)
+	if (stat.isDirectory()) {
+		await runSpecsFromFolder(fullPath, grpcAdapter)
+	} else {
+		await runSpec(fullPath, grpcAdapter)
+	}
+
+	grpcAdapter.close()
+}
+
+main().catch((err) => {
+	console.error("❌ Fatal error:", err)
+	process.exit(1)
+})
diff --git a/apps/vscode/testing-platform/package.json b/apps/vscode/testing-platform/package.json
new file mode 100644
index 0000000..05cf546
--- /dev/null
+++ b/apps/vscode/testing-platform/package.json
@@ -0,0 +1,19 @@
+{
+	"name": "testing-infra",
+	"version": "0.1.0",
+	"main": "dist/runner.js",
+	"scripts": {
+		"build": "tsc",
+		"start:dev": "bun index.ts",
+		"start": "bun run build && node dist/runner.js"
+	},
+	"dependencies": {
+		"jest-diff": "^30.1.2"
+	},
+	"devDependencies": {
+		"@types/lodash": "^4.17.20",
+		"lodash": "^4.17.23",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.3.3"
+	}
+}
diff --git a/apps/vscode/testing-platform/tsconfig.json b/apps/vscode/testing-platform/tsconfig.json
new file mode 100644
index 0000000..5d7e104
--- /dev/null
+++ b/apps/vscode/testing-platform/tsconfig.json
@@ -0,0 +1,39 @@
+{
+	"compilerOptions": {
+		"target": "es2021",
+		"module": "commonjs",
+		"outDir": "./dist",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"moduleResolution": "node",
+		"resolveJsonModule": true,
+		"allowSyntheticDefaultImports": true,
+		"baseUrl": "./",
+		"paths": {
+			"@grpc/grpc-js": [
+				"../node_modules/@grpc/grpc-js"
+			],
+			"@generated/*": [
+				"../src/generated/*"
+			],
+			"@cline-grpc/*": [
+				"../src/generated/grpc-js/cline/*"
+			],
+			"@harness/*": [
+				"harness/*"
+			],
+			"@adapters/*": [
+				"adapters/*"
+			]
+		}
+	},
+	"include": [
+		"**/*.ts",
+		"../src/generated/grpc-js/**/*.ts"
+	],
+	"exclude": [
+		"node_modules",
+		"dist"
+	]
+}
diff --git a/apps/vscode/tests/e2e/cli/interactive.test.ts b/apps/vscode/tests/e2e/cli/interactive.test.ts
new file mode 100644
index 0000000..c449d4b
--- /dev/null
+++ b/apps/vscode/tests/e2e/cli/interactive.test.ts
@@ -0,0 +1,64 @@
+import { test } from "@microsoft/tui-test"
+import { CLINE_BIN } from "./helpers/constants.js"
+import { assertApiTab, assertAutoApproveTab, assertFeaturesTab, assertOtherTab } from "./helpers/page-objects/settings.js"
+import { expectVisible, testEnv, typeAndSubmit } from "./utils.js"
+
+test.describe("cline interactive basics", () => {
+	test.use({
+		program: { file: CLINE_BIN, args: ["--tui"] },
+		rows: 50,
+		columns: 120,
+		env: testEnv("default"),
+	})
+
+	test("shows logo, prompt, mode toggles, and hints", async ({ terminal }) => {
+		await expectVisible(terminal, ["What can I do for you?", "@@@@@@", "Plan", "Act", "@ for files", "Tab"])
+	})
+
+	test("shows slash commands after / input", async ({ terminal }) => {
+		await expectVisible(terminal, "What can I do for you?")
+		await typeAndSubmit(terminal, "/")
+		await expectVisible(terminal, ["/help", "/settings", "/models"], {
+			timeout: 5000,
+		})
+	})
+
+	test("opens /settings and navigates tabs with left/right arrows", async ({ terminal }) => {
+		await expectVisible(terminal, "What can I do for you?")
+
+		await typeAndSubmit(terminal, "/settings")
+
+		await expectVisible(terminal, "Settings (Esc to close)")
+
+		// API tab (default)
+		await assertApiTab(terminal)
+		await expectVisible(terminal, "Use separate models for Plan and Act")
+
+		// Auto-approve tab
+		terminal.keyRight()
+		await assertAutoApproveTab(terminal)
+
+		// Features tab
+		terminal.keyRight()
+		await assertFeaturesTab(terminal)
+		await expectVisible(terminal, ["Native tool call", "Parallel tool calling"])
+
+		// Account tab
+		terminal.keyRight()
+		await expectVisible(terminal, ["Sign in to access Cline features", "Sign in with Cline"])
+
+		// Other tab
+		terminal.keyRight()
+		await assertOtherTab(terminal)
+
+		// Left once from Other should move back to Account
+		terminal.keyLeft()
+		await expectVisible(terminal, "Sign in to access Cline features")
+
+		// Two rights from Account should wrap back to API
+		terminal.keyRight()
+		await assertOtherTab(terminal)
+		terminal.keyRight()
+		await assertApiTab(terminal)
+	})
+})
diff --git a/apps/vscode/tests/specs/grpc_recorded_session_single_root.json b/apps/vscode/tests/specs/grpc_recorded_session_single_root.json
new file mode 100644
index 0000000..2b472b7
--- /dev/null
+++ b/apps/vscode/tests/specs/grpc_recorded_session_single_root.json
@@ -0,0 +1,104 @@
+{
+	"startTime": "2025-09-22T15:10:39.693Z",
+	"entries": [
+		{
+			"requestId": "6e4460e9-e701-4bd2-bac6-1b0f20938c11",
+			"service": "cline.AccountService",
+			"method": "accountLoginClicked",
+			"isStreaming": false,
+			"request": {
+				"message": {}
+			},
+			"status": "completed",
+			"meta": {
+				"synthetic": false
+			},
+			"response": {
+				"message": {
+					"value": "Enter this code in your browser: PTBC-TXTP"
+				}
+			},
+			"duration": 13
+		},
+		{
+			"requestId": "2f774918-949e-4919-9b26-8b8be5b95bb9",
+			"service": "cline.AccountService",
+			"method": "getUserOrganizations",
+			"isStreaming": false,
+			"request": {
+				"message": {}
+			},
+			"status": "completed",
+			"meta": {
+				"synthetic": false
+			},
+			"response": {
+				"message": {
+					"organizations": [
+						{
+							"active": false,
+							"memberId": "random-member-id",
+							"name": "Test Organization",
+							"organizationId": "random-org-id",
+							"roles": [
+								"member"
+							]
+						}
+					]
+				}
+			},
+			"duration": 5
+		},
+		{
+			"requestId": "118991fc-73b1-4dce-ae20-15cd3529f465",
+			"service": "cline.TaskService",
+			"method": "newTask",
+			"isStreaming": false,
+			"request": {
+				"message": {
+					"text": "Hello, Cline!",
+					"images": [],
+					"files": []
+				}
+			},
+			"status": "completed",
+			"meta": {
+				"synthetic": false,
+				"expected": {}
+			},
+			"response": {
+				"message": {
+					"value": "1768819891184"
+				}
+			},
+			"duration": 49
+		},
+		{
+			"requestId": "6633a706-366d-49d5-a3f4-4589131bdc5c",
+			"service": "cline.StateService",
+			"method": "getLatestState",
+			"isStreaming": false,
+			"request": {
+				"message": {}
+			},
+			"status": "completed",
+			"meta": {
+				"expected": {
+					"stateJson": {
+						"taskHistory": [
+							{
+								"task": "Hello, Cline!"
+							}
+						]
+					}
+				}
+			},
+			"response": {
+				"message": {
+					"stateJson": "THIS_WILL_BE_IGNORED_EXPECTED_HAS_BEEN_SET"
+				}
+			},
+			"duration": 0
+		}
+	]
+}
diff --git a/apps/vscode/tsconfig.json b/apps/vscode/tsconfig.json
new file mode 100644
index 0000000..81d726c
--- /dev/null
+++ b/apps/vscode/tsconfig.json
@@ -0,0 +1,74 @@
+{
+	"compilerOptions": {
+		"esModuleInterop": true,
+		"experimentalDecorators": true,
+		"forceConsistentCasingInFileNames": true,
+		"isolatedModules": true,
+		"jsx": "react",
+		"lib": [
+			"es2022",
+			"DOM"
+		],
+		"module": "esnext",
+		"moduleResolution": "Bundler",
+		"noFallthroughCasesInSwitch": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noUnusedLocals": false,
+		"resolveJsonModule": true,
+		"rootDir": ".",
+		"skipLibCheck": true,
+		"sourceMap": true,
+		"strict": true,
+		"target": "es2022",
+		"typeRoots": [
+			"./node_modules/@types",
+			"../../node_modules/@types",
+			"./src/types"
+		],
+		"useDefineForClassFields": true,
+		"useUnknownInCatchVariables": false,
+		"paths": {
+			"@/*": [
+				"./src/*"
+			],
+			"@api/*": [
+				"./src/core/api/*"
+			],
+			"@core/*": [
+				"./src/core/*"
+			],
+			"@generated/*": [
+				"./src/generated/*"
+			],
+			"@hosts/*": [
+				"./src/hosts/*"
+			],
+			"@integrations/*": [
+				"./src/integrations/*"
+			],
+			"@packages/*": [
+				"./src/packages/*"
+			],
+			"@services/*": [
+				"./src/services/*"
+			],
+			"@shared/*": [
+				"./src/shared/*"
+			],
+			"@utils/*": [
+				"./src/utils/*"
+			]
+		}
+	},
+	"include": [
+		"./src/**/*"
+	],
+	"exclude": [
+		"node_modules",
+		".vscode-test",
+		"webview-ui",
+		"src/test/e2e/**/*",
+		"src/test/scenarios/**/*"
+	]
+}
diff --git a/apps/vscode/tsconfig.test.json b/apps/vscode/tsconfig.test.json
new file mode 100644
index 0000000..18f1b98
--- /dev/null
+++ b/apps/vscode/tsconfig.test.json
@@ -0,0 +1,97 @@
+{
+	// This separate tsconfig is necessary because VS Code's test runner requires CommonJS modules,
+	// while our main project uses ES Modules (ESM). This config inherits most settings from the base
+	// tsconfig.json but overrides the module system for test files only. This doesn't affect how
+	// tests interact with the main codebase - it only changes how the test files themselves are
+	// compiled to make them compatible with VS Code's test runner.
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"module": "commonjs",
+		"moduleResolution": "node",
+		// Classic "node" moduleResolution (required for the CommonJS mocha test
+		// runner) does not read the `exports` subpath maps in @cline/* package
+		// manifests, so bare subpath imports like `@cline/shared/storage` fail to
+		// resolve (TS2307) even though the built declarations exist. The base
+		// tsconfig uses `Bundler` resolution and is unaffected. We re-declare the
+		// inherited `paths` (TS replaces, not merges, `paths`) and add explicit
+		// mappings to the built dist so the test compile can resolve these subpaths.
+		"baseUrl": ".",
+		"paths": {
+			"@/*": [
+				"./src/*"
+			],
+			"@api/*": [
+				"./src/core/api/*"
+			],
+			"@core/*": [
+				"./src/core/*"
+			],
+			"@generated/*": [
+				"./src/generated/*"
+			],
+			"@hosts/*": [
+				"./src/hosts/*"
+			],
+			"@integrations/*": [
+				"./src/integrations/*"
+			],
+			"@packages/*": [
+				"./src/packages/*"
+			],
+			"@services/*": [
+				"./src/services/*"
+			],
+			"@shared/*": [
+				"./src/shared/*"
+			],
+			"@utils/*": [
+				"./src/utils/*"
+			],
+			"@cline/shared/*": [
+				"./node_modules/@cline/shared/dist/*"
+			]
+		},
+		"types": [
+			"node",
+			"bun",
+			"mocha",
+			"should",
+			"vscode",
+			"chai"
+		],
+		"typeRoots": [
+			"./node_modules/@types",
+			"../../node_modules/@types",
+			"./src/types",
+			"./src/test/types"
+		],
+		"outDir": "out",
+		"rootDir": "."
+	},
+	"include": [
+		"src/**/*.test.ts",
+		"src/test/fixtures/**/*.ts",
+		"src/types/**/*.d.ts"
+	],
+	"exclude": [
+		"src/test/**/*.js",
+		"src/**/__tests__/*",
+		// The bun unit suite (.mocharc spec set) runs under `bun test` and imports
+		// `bun:test`, which the Node-based @vscode/test-cli integration runner
+		// cannot load. Keep these out of the integration compile (run-bun-unit-tests.ts
+		// owns them).
+		"src/test/services/**/*.test.ts",
+		// NOTE: files importing "bun:test" are additionally excluded dynamically by
+		// scripts/build-tests.js (it generates tsconfig.test.generated.json). That is
+		// the single source of truth for the bun-vs-integration split; this static
+		// list only covers structural/vitest excludes.
+		"src/test/e2e/**/*.test.ts",
+		// The src/sdk suites are vitest-native (run via `bun run test:vitest`),
+		// not the VS Code/mocha integration runner (see .vscode-test.mjs, which
+		// only globs core/test/utils/shared/integrations/hosts/services). Some of
+		// them use top-level `await import(...)` after `vi.mock(...)`, which is
+		// invalid under this config's CommonJS `module` setting (TS1378). Exclude
+		// them so the integration test compile doesn't choke on vitest-only files.
+		"src/sdk/**/*.test.ts"
+	]
+}
diff --git a/apps/vscode/vitest.config.ts b/apps/vscode/vitest.config.ts
new file mode 100644
index 0000000..5923d2a
--- /dev/null
+++ b/apps/vscode/vitest.config.ts
@@ -0,0 +1,65 @@
+import path from "node:path"
+import { defineConfig } from "vitest/config"
+
+// Vitest config for the VSCode extension's SDK-adapter and model-catalog
+// unit tests. (The bulk of the extension's unit tests still run under mocha
+// via `test:unit`; these suites are vitest-native.)
+export default defineConfig({
+	test: {
+		include: [
+			"src/sdk/**/*.test.ts",
+			"src/shared/vsCodeSelectorUtils.test.ts",
+			"src/shared/proto-conversions/models/**/*.test.ts",
+			"src/core/storage/remote-config/**/*.test.ts",
+			"src/core/controller/state/**/*.test.ts",
+			"src/core/controller/slash/**/*.test.ts",
+			"src/services/mcp/__tests__/settingsLock.test.ts",
+			"src/shared/model-catalog/provider-helpers.test.ts",
+			"src/core/controller/models/__tests__/providerCatalogHandlers.test.ts",
+			"src/core/controller/models/__tests__/providerSwitchNormalization.test.ts",
+			"src/core/controller/models/__tests__/resolveModelInfo.test.ts",
+			"src/core/controller/models/__tests__/providerCatalogSmoke.test.ts",
+			"src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts",
+			"src/core/controller/models/__tests__/refreshGroqModels.test.ts",
+		],
+		environment: "node",
+		// Several suites lazily `await import()` their subject inside the first test
+		// (needed so vi.mock factories apply first). That import pulls in heavy
+		// workspace packages (@cline/core/@cline/llms/@cline/shared), and on loaded
+		// CI runners the first test in a file can blow past the 5s default and flake
+		// (seen in catalog.test.ts and resolveModelInfo.test.ts). Raise the per-test
+		// timeout so import cost attributed to the first test doesn't cause flakes.
+		testTimeout: 20000,
+		// Some matched files are intentionally-empty placeholders that point to
+		// where the real suite lives (e.g. sdk-control-plane.test.ts), so an
+		// empty file should not fail the run.
+		passWithNoTests: true,
+	},
+	resolve: {
+		alias: {
+			"@cline/core": path.resolve(__dirname, "src/test/cline-core-vitest-stub.ts"),
+			"@cline/llms": path.resolve(__dirname, "node_modules/@cline/llms/dist/index.js"),
+			// Map @cline/shared subpath exports explicitly. The bare "@cline/shared"
+			// alias below does not cover subpaths (e.g. "@cline/shared/storage"), and
+			// Vite's fallback Node resolution does not read the package `exports` map
+			// here, so subpath imports fail with "Cannot find package". Keep the more
+			// specific subpath alias(es) before the bare package alias.
+			"@cline/shared/storage": path.resolve(__dirname, "node_modules/@cline/shared/dist/storage/index.js"),
+			"@cline/shared": path.resolve(__dirname, "node_modules/@cline/shared/dist/index.js"),
+			vscode: path.resolve(__dirname, "src/test/vscode-vitest-stub.ts"),
+			"@": path.resolve(__dirname, "src"),
+			"@api": path.resolve(__dirname, "src/core/api"),
+			"@core": path.resolve(__dirname, "src/core"),
+			"@generated": path.resolve(__dirname, "src/generated"),
+			"@hosts": path.resolve(__dirname, "src/hosts"),
+			"@integrations": path.resolve(__dirname, "src/integrations"),
+			"@services": path.resolve(__dirname, "src/services"),
+			"@shared/proto/cline/common": path.resolve(__dirname, "src/shared/proto/cline/common.ts"),
+			"@shared/proto/cline/models": path.resolve(__dirname, "src/shared/proto/cline/models.ts"),
+			"@shared/proto": path.resolve(__dirname, "src/shared/proto"),
+			"@shared": path.resolve(__dirname, "src/shared"),
+			"@utils": path.resolve(__dirname, "src/utils"),
+			"@packages": path.resolve(__dirname, "src/packages"),
+		},
+	},
+})
diff --git a/apps/vscode/walkthrough/step1.md b/apps/vscode/walkthrough/step1.md
new file mode 100644
index 0000000..b1eb6fd
--- /dev/null
+++ b/apps/vscode/walkthrough/step1.md
@@ -0,0 +1,7 @@
+# Beyond Autocomplete: True Agentic Planning
+
+**Cline analyzes your request, explores your code, and presents a clear plan.**
+
+Watch Cline break down complex tasks, ask clarifying questions, and outline its approach. Understand the 'why' before any code is written, ensuring changes align with your architecture and intent.
+
+![Cline planning demonstration](https://storage.googleapis.com/cline_public_images/docs/assets/cline-plan-hifi-1_compress.webp)
\ No newline at end of file
diff --git a/apps/vscode/walkthrough/step2.md b/apps/vscode/walkthrough/step2.md
new file mode 100644
index 0000000..3183228
--- /dev/null
+++ b/apps/vscode/walkthrough/step2.md
@@ -0,0 +1,7 @@
+# Deep Codebase Intelligence
+
+**Cline starts with broad context and explores deeply where needed.**
+
+Cline is designed with inherent codebase intelligence. It doesn't operate in a vacuum, but starts with a structural understanding of your project. Before making changes, it performs targeted agentic exploration to gain any additional specific context required, ensuring its actions are always well-informed and aligned with your architecture.
+
+![Cline Deep Codebase Intelligence Demo](https://storage.googleapis.com/cline_public_images/docs/assets/cline-reading-codebase-hifi-2_compress.webp)
diff --git a/apps/vscode/walkthrough/step3.md b/apps/vscode/walkthrough/step3.md
new file mode 100644
index 0000000..d606285
--- /dev/null
+++ b/apps/vscode/walkthrough/step3.md
@@ -0,0 +1,7 @@
+# Always Use the Best Models
+
+**Connect your keys for Anthropic (Claude), Google (Gemini), OpenAI (GPT), and other leading LLMs.**
+
+Cline puts you at the forefront of AI. Bring your own API keys for leading models like Anthropic (Claude), Google (Gemini), and OpenAI (GPT). Always leverage the most powerful State-of-the-Art (SOTA) capabilities, ensuring you control both cost and cutting-edge performance.
+
+![Cline Models Demo](https://storage.googleapis.com/cline_public_images/docs/assets/clines-models-hifi-3_compress.webp)
diff --git a/apps/vscode/walkthrough/step4.md b/apps/vscode/walkthrough/step4.md
new file mode 100644
index 0000000..7f43f65
--- /dev/null
+++ b/apps/vscode/walkthrough/step4.md
@@ -0,0 +1,7 @@
+# Unlock Specialized Capabilities with MCP
+
+**The Model Context Protocol (MCP) connects Cline to a world of powerful tools.**
+
+Go beyond local code. With the Model Context Protocol (MCP), Cline accesses vital context from external datasources like databases and APIs. Configure local or remote MCP servers to give Cline specialized, secure tools for complex, real-world development tasks.
+
+![Cline MCP Servers Demo](https://storage.googleapis.com/cline_public_images/docs/assets/clines-mcp-servers-4_compress.webp)
diff --git a/apps/vscode/walkthrough/step5.md b/apps/vscode/walkthrough/step5.md
new file mode 100644
index 0000000..bf5fdcc
--- /dev/null
+++ b/apps/vscode/walkthrough/step5.md
@@ -0,0 +1,7 @@
+# No Black Box: Full Visibility & Control
+
+**Cline operates with complete transparency, showing you every file read and every proposed diff.**
+
+Understand exactly what Cline is doing and why—no obfuscation. Review all actions and approve changes before they're made. Cline uses checkpoints, allowing you to easily revert if needed, maintaining full control over your codebase. With BYO-key, you also have clear cost transparency.
+
+![Cline Transparency Demo](https://storage.googleapis.com/cline_public_images/docs/assets/clines-transparency-hifi-5_compress.webp)
diff --git a/apps/vscode/webview-ui/.gitignore b/apps/vscode/webview-ui/.gitignore
new file mode 100644
index 0000000..da2874b
--- /dev/null
+++ b/apps/vscode/webview-ui/.gitignore
@@ -0,0 +1,37 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+build
+*.local
+coverage
+.vite-port
+
+# Environment
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# Storybook
+*storybook.log
+storybook-static
\ No newline at end of file
diff --git a/apps/vscode/webview-ui/.storybook/README.md b/apps/vscode/webview-ui/.storybook/README.md
new file mode 100644
index 0000000..380cc6a
--- /dev/null
+++ b/apps/vscode/webview-ui/.storybook/README.md
@@ -0,0 +1,253 @@
+# Storybook Documentation
+
+## What is Storybook?
+
+Storybook is a frontend workshop for building UI components and pages in isolation. It allows developers to:
+
+- **Develop components independently** from the main application
+- **Test different states and props** without complex setup
+- **Document component APIs** with interactive examples
+- **Catch UI bugs** through visual testing
+- **Share components** with team members and stakeholders
+
+In Cline's webview, Storybook helps us develop and test React components that make up the chat interface, settings panels, and other UI elements in isolation from the VSCode extension environment.
+
+## Getting Started
+
+### Starting Storybook
+
+To launch the Storybook development server:
+
+```bash
+bun run storybook
+```
+
+This will start Storybook on `http://localhost:6006` where you can browse all available stories and interact with components.
+
+### Project Structure
+
+```
+webview-ui/.storybook/
+├── main.ts          # Main configuration
+├── preview.ts       # Global decorators and parameters
+├── themes.ts        # VSCode theme definitions
+└── README.md        # This documentation
+```
+
+## Configuration Overview
+
+### Main Configuration (`main.ts`)
+
+- **Stories Location**: Automatically discovers `*.stories.*` files in `../src/`
+- **Framework**: Uses `@storybook/react-vite` for React + Vite integration
+- **Environment Variables**: Sets development flags (`IS_DEV`, `IS_TEST`, `TEMP_PROFILE`)
+- **TypeScript**: Enables type checking and automatic prop documentation
+
+### Preview Configuration (`preview.ts`)
+
+- **Viewport**: Configured for "Editor Sidebar" (700x800px) to match VSCode's sidebar
+- **Themes**: VSCode Dark/Light theme switcher in toolbar
+- **Global Decorator**: `StorybookWebview` provides VSCode-like environment
+- **Documentation**: Dark theme styling to match VSCode
+
+### Theme System (`themes.ts`)
+
+Provides mock VSCode CSS variables for both dark and light themes, ensuring components render correctly outside the VSCode environment.
+
+## Creating Stories
+
+### Basic Story Structure
+
+Create a `*.stories.tsx` file alongside your component:
+
+```typescript
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import { MyComponent } from "./MyComponent"
+
+const meta: Meta<typeof MyComponent> = {
+  title: "Components/MyComponent",
+  component: MyComponent,
+  parameters: {
+    docs: {
+      description: {
+        component: "Description of what this component does"
+      }
+    }
+  }
+}
+
+export default meta
+type Story = StoryObj<typeof MyComponent>
+
+export const Default: Story = {
+  args: {
+    prop1: "value1",
+    prop2: true
+  }
+}
+
+export const WithDifferentState: Story = {
+  args: {
+    prop1: "different value",
+    prop2: false
+  }
+}
+```
+
+### Advanced Story Patterns
+
+For complex components requiring context or state, use decorators:
+
+```typescript
+import { ExtensionStateContext } from "@/context/ExtensionStateContext"
+
+const createMockState = (overrides = {}) => ({
+  // Mock state properties
+  clineMessages: [],
+  taskHistory: [],
+  ...overrides
+})
+
+export const WithMockState: Story = {
+  decorators: [
+    (Story) => {
+      const mockState = createMockState({ 
+        clineMessages: mockMessages 
+      })
+      return (
+        <ExtensionStateContext.Provider value={mockState}>
+          <Story />
+        </ExtensionStateContext.Provider>
+      )
+    }
+  ]
+}
+```
+
+### Story Organization
+
+- **Title**: Use hierarchical naming like `"Views/Chat"` or `"Components/Button"`
+- **Parameters**: Add descriptions and documentation
+- **Args**: Define default props for interactive controls
+- **Multiple Stories**: Show different states, props, or use cases
+
+## Writing UI Tests
+
+### Interactive Testing with `play` Functions
+
+Storybook supports automated interaction testing using the `play` function:
+
+```typescript
+import { expect, userEvent, within } from "storybook/test"
+
+export const InteractiveTest: Story = {
+  args: {
+    // Component props
+  },
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement)
+    
+    // Find elements
+    const button = canvas.getByText("Click me")
+    const input = canvas.getByPlaceholderText("Enter text")
+    
+    // Perform interactions
+    await userEvent.type(input, "Hello world")
+    await userEvent.click(button)
+    
+    // Assert results
+    await expect(canvas.getByText("Hello world")).toBeInTheDocument()
+  }
+}
+```
+
+### Testing Patterns
+
+1. **User Interactions**: Click buttons, type in inputs, navigate
+2. **State Changes**: Verify component updates after interactions
+3. **Accessibility**: Test keyboard navigation and screen reader support
+4. **Error States**: Test error handling and edge cases
+
+### Example from App.stories.tsx
+
+The `WelcomeScreen` story demonstrates comprehensive testing:
+
+```typescript
+export const WelcomeScreen: Story = {
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement)
+    
+    // Test initial state
+    const getStartedButton = canvas.getByText("Get Started for Free")
+    const byokButton = canvas.getByText("Use your own API key")
+    await expect(getStartedButton).toBeInTheDocument()
+    await expect(byokButton).toBeInTheDocument()
+    
+    // Test interaction
+    await userEvent.click(byokButton)
+    
+    // Test state change
+    await expect(getStartedButton).toBeInTheDocument()
+    await expect(byokButton).not.toBeInTheDocument()
+  }
+}
+```
+
+## Best Practices
+
+### Story Development
+
+1. **Start Simple**: Create basic stories first, then add complexity
+2. **Cover Edge Cases**: Include error states, loading states, empty states
+3. **Use Real Data**: Mock realistic data for better testing
+4. **Document Behavior**: Add descriptions explaining component purpose
+
+### Testing Guidelines
+
+1. **Test User Flows**: Focus on how users interact with components
+2. **Verify Accessibility**: Ensure components work with keyboard and screen readers
+3. **Test Responsive Behavior**: Use different viewport sizes
+4. **Mock External Dependencies**: Use mocks for API calls, file operations
+
+### Performance Tips
+
+1. **Lazy Load Stories**: Use dynamic imports for large story files
+2. **Optimize Mock Data**: Keep mock data minimal but realistic
+3. **Reuse Decorators**: Create shared decorators for common patterns
+4. **Clean Up**: Dispose of resources in story cleanup
+
+## VSCode Integration
+
+### Theme Switching
+
+Use the theme switcher in Storybook's toolbar to test components in both VSCode Dark and Light themes.
+
+### Viewport Testing
+
+The default "Editor Sidebar" viewport (700x800px) matches VSCode's sidebar dimensions, ensuring components render correctly in the actual extension environment.
+
+### Extension Context
+
+The `StorybookWebview` decorator provides a VSCode-like environment with proper CSS variables and context providers, making stories behave similarly to the real extension.
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Missing CSS Variables**: Ensure `StorybookWebview` decorator is applied
+2. **Context Errors**: Wrap stories with appropriate context providers
+3. **Import Errors**: Check that all dependencies are available in Storybook environment
+4. **Theme Issues**: Verify theme CSS variables are properly applied
+
+### Debugging Tips
+
+1. **Use Browser DevTools**: Inspect elements and check console for errors
+2. **Check Story Args**: Verify component props are passed correctly
+3. **Test in Isolation**: Create minimal stories to isolate issues
+4. **Review Configuration**: Check `main.ts` and `preview.ts` for configuration issues
+
+## Resources
+
+- [Storybook Documentation](https://storybook.js.org/docs)
+- [Testing with Storybook](https://storybook.js.org/docs/writing-tests)
+- [React Storybook Guide](https://storybook.js.org/docs/get-started/react-vite)
diff --git a/apps/vscode/webview-ui/.storybook/main.ts b/apps/vscode/webview-ui/.storybook/main.ts
new file mode 100644
index 0000000..e4ed930
--- /dev/null
+++ b/apps/vscode/webview-ui/.storybook/main.ts
@@ -0,0 +1,31 @@
+import type { StorybookConfig } from "@storybook/react-vite"
+
+const config: StorybookConfig = {
+	stories: ["../src/**/*.mdx", "../src/**/*.stories.@(js|jsx|mjs|ts|tsx)"],
+	addons: [],
+	framework: "@storybook/react-vite",
+	viteFinal: async (config) => {
+		// Define environment variables for Storybook
+		config.define = {
+			...config.define,
+			"process.platform": JSON.stringify(process?.platform),
+			"process.env": {
+				...process.env,
+				IS_DEV: JSON.stringify(true),
+				IS_TEST: JSON.stringify(true),
+				TEMP_PROFILE: JSON.stringify(true),
+			},
+		}
+
+		return config
+	},
+	typescript: {
+		check: true,
+		reactDocgen: "react-docgen-typescript",
+		reactDocgenTypescriptOptions: {
+			shouldExtractLiteralValuesFromEnum: true,
+			propFilter: (prop) => (prop.parent ? !/node_modules/.test(prop.parent.fileName) : true),
+		},
+	},
+}
+export default config
diff --git a/apps/vscode/webview-ui/.storybook/preview.ts b/apps/vscode/webview-ui/.storybook/preview.ts
new file mode 100644
index 0000000..8c8e663
--- /dev/null
+++ b/apps/vscode/webview-ui/.storybook/preview.ts
@@ -0,0 +1,52 @@
+import type { Preview } from "@storybook/react-vite"
+import { StorybookWebview } from "../src/config/StorybookDecorator"
+
+const preview: Preview = {
+	parameters: {
+		viewport: {
+			viewports: {
+				"Editor Sidebar": {
+					name: "Editor Sidebar",
+					styles: { width: "700px", height: "800px" },
+					type: "desktop",
+				},
+			},
+			defaultViewport: "Editor Sidebar",
+		},
+		controls: {
+			matchers: {
+				color: /(background|color)$/i,
+				date: /Date$/i,
+			},
+		},
+		docs: {
+			theme: {
+				base: "dark",
+				colorPrimary: "#3794ff",
+				colorSecondary: "#0e639c",
+				appBg: "#1e1e1e",
+				appContentBg: "#252526",
+				textColor: "#d4d4d4",
+			},
+		},
+		layout: "padded",
+	},
+	decorators: [StorybookWebview],
+	globalTypes: {
+		theme: {
+			description: "Color Themes",
+			defaultValue: "vs_dark",
+			toolbar: {
+				dynamicTitle: true,
+				icon: "sun",
+				title: "Themes",
+				items: [
+					{ value: "vs_dark", title: "VS Code Dark" },
+					{ value: "vs_light", title: "VS Code Light" },
+				],
+			},
+		},
+	},
+}
+
+export default preview
diff --git a/apps/vscode/webview-ui/.storybook/themes.ts b/apps/vscode/webview-ui/.storybook/themes.ts
new file mode 100644
index 0000000..b63a68b
--- /dev/null
+++ b/apps/vscode/webview-ui/.storybook/themes.ts
@@ -0,0 +1,133 @@
+const mockVSCodeDarkTheme = {
+	"--vscode-editor-background": "#1E1E1E",
+	"--vscode-editor-foreground": "#D4D4D4",
+	"--vscode-sideBar-background": "#252526",
+	"--vscode-sideBar-foreground": "#CCCCCC",
+	"--vscode-editorGroup-border": "#454545",
+	"--vscode-descriptionForeground": "#CCCCCC99",
+	"--vscode-foreground": "#D4D4D4",
+	"--vscode-button-background": "#007ACC",
+	"--vscode-button-foreground": "#FFFFFF",
+	"--vscode-button-hoverBackground": "#005A9E",
+	"--vscode-button-separator": "#FFFFFF4D",
+	"--vscode-button-secondaryBackground": "#383B3D",
+	"--vscode-button-secondaryForeground": "#CCCCCC",
+	"--vscode-button-secondaryHoverBackground": "#454545",
+	"--vscode-textLink-foreground": "#6fc3df",
+	"--vscode-textLink-activeForeground": "#9CCBFF",
+	"--vscode-errorForeground": "#f48771",
+	"--vscode-editorWidget-border": "#303031",
+	"--vscode-editorError-foreground": "#f14c4c",
+	"--vscode-diffEditor-removedTextBackground": "#9c353520",
+	"--vscode-diffEditor-insertedTextBackground": "#9ccc6520",
+	"--vscode-editor-font-family": 'Menlo, Monaco, "Courier New", monospace',
+	"--vscode-editor-font-size": "12px",
+	"--vscode-font-family": '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+	"--vscode-font-size": "13px",
+	"--vscode-focusBorder": "#007ACC",
+	"--vscode-input-border": "#6B6B6B",
+	"--vscode-banner-background": "#007ACC",
+	"--vscode-banner-foreground": "#FFFFFF",
+	"--vscode-banner-iconForeground": "#FFFFFF",
+	"--vscode-titleBar-inactiveForeground": "#BBBBBB",
+	"--vscode-input-foreground": "#D4D4D4",
+	"--vscode-input-background": "#383B3D",
+	"--vscode-editor-line-height": "20px",
+	"--vscode-input-placeholderForeground": "#A6A6A6",
+	"--vscode-activityWarningBadge-background": "#F9C20B",
+	"--vscode-badge-background": "#007ACC",
+	"--vscode-badge-foreground": "#FFFFFF",
+	"--vscode-charts-green": "#73C991",
+	"--vscode-charts-yellow": "#F9C20B",
+	"--vscode-charts-red": "#F14C4C",
+	"--vscode-menu-background": "#252526",
+	"--vscode-menu-border": "#454545",
+	"--vscode-menu-foreground": "#CCCCCC",
+	"--vscode-menu-shadow": "#00000050",
+	"--vscode-menu-selectionBackground": "#062F4A",
+	"--vscode-menu-selectionForeground": "#FFFFFF",
+	"--vscode-inputValidation-errorBackground": "#eb1424",
+	"--vscode-inputValidation-errorForeground": "#fcd1c1",
+	"--vscode-editor-foldBackground": "#252526",
+	"--vscode-editor-foldPlaceholderForeground": "#454545",
+	"--vscode-list-activeSelectionBackground": "#094771",
+	"--vscode-list-activeSelectionForeground": "#FFFFFF",
+	"--vscode-list-hoverBackground": "#2D2D30",
+	"--vscode-editor-border": "#454545",
+	"--vscode-textCodeBlock-background": "#3E3E42",
+	"--vscode-toolbar-background": "#252526",
+	"--vscode-toolbar-hoverBackground": "#3E3E42",
+	"--vscode-widget-shadow": "#00000050",
+	"--vscode-panel-border": "#454545",
+	"--vscode-icon-foreground": "#CCCCCC",
+	"--popover-foreground": "#D4D4D4",
+	"--vscode-problemsErrorIcon-foreground": "#be1100",
+}
+
+const mockVSCodeLightTheme = {
+	"--vscode-editor-background": "#FFFFFF",
+	"--vscode-editor-foreground": "#000000",
+	"--vscode-sideBar-background": "#F3F3F3",
+	"--vscode-sideBar-foreground": "#3E3E42",
+	"--vscode-editorGroup-border": "#D4D4D4",
+	"--vscode-descriptionForeground": "#6F6F6F",
+	"--vscode-foreground": "#000000",
+	"--vscode-button-background": "#007ACC",
+	"--vscode-button-foreground": "#FFFFFF",
+	"--vscode-button-hoverBackground": "#005A9E",
+	"--vscode-button-separator": "#0000001F",
+	"--vscode-button-secondaryBackground": "#E8E8E8",
+	"--vscode-button-secondaryForeground": "#3E3E42",
+	"--vscode-button-secondaryHoverBackground": "#D5D5D5",
+	"--vscode-textLink-foreground": "#6fc3df",
+	"--vscode-textLink-activeForeground": "#0078D4",
+	"--vscode-errorForeground": "#c72e0f",
+	"--vscode-editorWidget-border": "#D4D4D4",
+	"--vscode-editorError-foreground": "#c72e0f",
+	"--vscode-diffEditor-removedTextBackground": "#c72e0f20",
+	"--vscode-diffEditor-insertedTextBackground": "#36943220",
+	"--vscode-editor-font-family": 'Menlo, Monaco, "Courier New", monospace',
+	"--vscode-editor-font-size": "12px",
+	"--vscode-font-family": '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+	"--vscode-font-size": "13px",
+	"--vscode-focusBorder": "#007ACC",
+	"--vscode-input-border": "#CECECE",
+	"--vscode-banner-background": "#007ACC",
+	"--vscode-banner-foreground": "#FFFFFF",
+	"--vscode-banner-iconForeground": "#FFFFFF",
+	"--vscode-titleBar-inactiveForeground": "#919191",
+	"--vscode-input-foreground": "#000000",
+	"--vscode-input-background": "#FFFFFF",
+	"--vscode-editor-line-height": "20px",
+	"--vscode-input-placeholderForeground": "#767676",
+	"--vscode-activityWarningBadge-background": "#F9C20B",
+	"--vscode-badge-background": "#007ACC",
+	"--vscode-badge-foreground": "#FFFFFF",
+	"--vscode-charts-green": "#73C991",
+	"--vscode-charts-yellow": "#F9C20B",
+	"--vscode-menu-background": "#F3F3F3",
+	"--vscode-menu-border": "#D4D4D4",
+	"--vscode-menu-foreground": "#6F6F6F",
+	"--vscode-menu-shadow": "#00000029",
+	"--vscode-menu-selectionBackground": "#007ACC",
+	"--vscode-menu-selectionForeground": "#FFFFFF",
+	"--vscode-inputValidation-errorBackground": "#f48771",
+	"--vscode-inputValidation-errorForeground": "#c72e0f",
+	"--vscode-list-activeSelectionBackground": "#094771",
+	"--vscode-list-activeSelectionForeground": "#FFFFFF",
+	"--vscode-list-hoverBackground": "#F0F0F0",
+	"--vscode-editor-border": "#D4D4D4",
+	"--vscode-textCodeBlock-background": "#F5F5F5",
+	"--vscode-toolbar-background": "#F3F3F3",
+	"--vscode-toolbar-hoverBackground": "#E8E8E8",
+	"--vscode-widget-shadow": "#00000033",
+	"--vscode-panel-border": "#D4D4D4",
+	"--vscode-icon-foreground": "#3E3E42",
+	"--popover-foreground": "#D4D4D4",
+}
+
+// Mock VSCode theme variables for Storybook
+export const StorybookThemes = {
+	dark: mockVSCodeDarkTheme,
+	light: mockVSCodeLightTheme,
+}
diff --git a/apps/vscode/webview-ui/components.json b/apps/vscode/webview-ui/components.json
new file mode 100644
index 0000000..cfab002
--- /dev/null
+++ b/apps/vscode/webview-ui/components.json
@@ -0,0 +1,22 @@
+{
+	"$schema": "https://ui.shadcn.com/schema.json",
+	"style": "new-york",
+	"rsc": false,
+	"tsx": true,
+	"tailwind": {
+		"config": "tailwind.config.mjs",
+		"css": "src/index.css",
+		"baseColor": "neutral",
+		"cssVariables": true,
+		"prefix": ""
+	},
+	"iconLibrary": "lucide",
+	"aliases": {
+		"components": "@/components",
+		"utils": "@/lib/utils",
+		"ui": "@/components/ui",
+		"lib": "@/lib",
+		"hooks": "@/hooks"
+	},
+	"registries": {}
+}
diff --git a/apps/vscode/webview-ui/index.html b/apps/vscode/webview-ui/index.html
new file mode 100644
index 0000000..6ab026a
--- /dev/null
+++ b/apps/vscode/webview-ui/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>Cline Webview</title>
+	</head>
+	<body>
+		<div id="root"></div>
+		<script type="module" src="/src/main.tsx"></script>
+	</body>
+</html>
diff --git a/apps/vscode/webview-ui/package.json b/apps/vscode/webview-ui/package.json
new file mode 100644
index 0000000..fc7ed19
--- /dev/null
+++ b/apps/vscode/webview-ui/package.json
@@ -0,0 +1,106 @@
+{
+	"name": "webview-ui",
+	"version": "0.3.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc -b && vite build",
+		"build:test": "tsc -b && vite build -- --dev-build",
+		"preview": "vite preview",
+		"lint": "biome lint --changed --no-errors-on-unmatched",
+		"test": "vitest run",
+		"test:watch": "vitest dev",
+		"test:coverage": "vitest run --coverage",
+		"storybook": "storybook dev -p 6006",
+		"build-storybook": "storybook build"
+	},
+	"dependencies": {
+		"@floating-ui/react": "^0.27.4",
+		"@fontsource/azeret-mono": "^5.2.9",
+		"@heroui/react": "^2.8.0-beta.2",
+		"@heroui/theme": "2.4.26",
+		"@paper-design/shaders-react": "^0.0.46",
+		"@radix-ui/react-dialog": "^1.1.15",
+		"@radix-ui/react-hover-card": "^1.1.15",
+		"@radix-ui/react-label": "^2.1.7",
+		"@radix-ui/react-popover": "^1.1.15",
+		"@radix-ui/react-progress": "^1.1.7",
+		"@radix-ui/react-select": "^2.2.6",
+		"@radix-ui/react-separator": "^1.1.7",
+		"@radix-ui/react-slider": "^1.3.6",
+		"@radix-ui/react-slot": "^1.2.3",
+		"@radix-ui/react-switch": "^1.2.6",
+		"@radix-ui/react-tooltip": "^1.2.8",
+		"@vscode/webview-ui-toolkit": "^1.4.0",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"debounce": "^2.1.1",
+		"dompurify": "^3.3.3",
+		"fast-deep-equal": "^3.1.3",
+		"firebase": "^11.3.0",
+		"framer-motion": "^12.7.4",
+		"fuse.js": "^7.0.0",
+		"fzf": "^0.5.2",
+		"lucide-react": "^0.511.0",
+		"magic-string": "^0.30.21",
+		"marked": "^15.0.12",
+		"mermaid": "11.12.3",
+		"posthog-js": "^1.224.0",
+		"pretty-bytes": "^6.1.1",
+		"react": "^18.3.1",
+		"react-dom": "^18.3.1",
+		"react-markdown": "^10.1.0",
+		"react-remark": "^2.1.0",
+		"react-textarea-autosize": "^8.5.7",
+		"react-use": "^17.6.0",
+		"react-virtuoso": "^4.12.3",
+		"rehype-highlight": "^7.0.1",
+		"rehype-parse": "^9.0.1",
+		"rehype-remark": "^10.0.1",
+		"remark-gfm": "^4.0.1",
+		"remark-stringify": "^11.0.0",
+		"styled-components": "^6.1.15",
+		"tailwind-merge": "^3.3.1",
+		"tailwindcss-animate": "^1.0.7",
+		"unified": "^11.0.5",
+		"unist-util-visit": "^5.0.0",
+		"uuid": "^9.0.1"
+	},
+	"devDependencies": {
+		"@storybook/react-vite": "^9.1.6",
+		"@tailwindcss/vite": "^4.1.13",
+		"@testing-library/jest-dom": "^6.6.3",
+		"@testing-library/react": "^16.2.0",
+		"@testing-library/user-event": "^14.6.1",
+		"@types/dompurify": "^3.0.5",
+		"@types/jest": "^29.5.14",
+		"@types/node": "^22.13.4",
+		"@types/react": "^18.3.18",
+		"@types/react-dom": "^18.3.5",
+		"@types/unist": "^3.0.3",
+		"@types/uuid": "^9.0.8",
+		"@types/vscode-webview": "^1.57.5",
+		"@vitejs/plugin-react-swc": "^3.5.0",
+		"@vitest/coverage-v8": "^3.0.9",
+		"globals": "^15.14.0",
+		"jsdom": "^26.0.0",
+		"storybook": "^9.1.17",
+		"tailwindcss": "^4.1.13",
+		"typescript": "^5.7.3",
+		"vite": "^7.1.11",
+		"vitest": "^3.0.5"
+	},
+	"overrides": {
+		"protobufjs": "7.5.8"
+	},
+	"optionalDependencies": {
+		"@rollup/rollup-linux-arm64-gnu": "^4.40.0",
+		"@rollup/rollup-linux-x64-gnu": "^4.40.0",
+		"@rollup/rollup-win32-x64-msvc": "^4.60.4",
+		"@swc/core-linux-x64-gnu": "^1.11.0",
+		"@tailwindcss/oxide-linux-x64-gnu": "^4.0.1",
+		"lightningcss-linux-x64-gnu": "^1.29.1",
+		"lightningcss-win32-x64-msvc": "1.29.2"
+	}
+}
diff --git a/apps/vscode/webview-ui/src/App.stories.tsx b/apps/vscode/webview-ui/src/App.stories.tsx
new file mode 100644
index 0000000..30ab041
--- /dev/null
+++ b/apps/vscode/webview-ui/src/App.stories.tsx
@@ -0,0 +1,1237 @@
+import { HeroUIProvider } from "@heroui/react"
+import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
+import type { ApiConfiguration, ModelInfo } from "@shared/api"
+import type { ClineMessage, ClineSayTool } from "@shared/ExtensionMessage"
+import type { HistoryItem } from "@shared/HistoryItem"
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import { useEffect, useMemo, useState } from "react"
+import { expect, userEvent, within } from "storybook/test"
+import { ExtensionStateContext, useExtensionState } from "@/context/ExtensionStateContext"
+import ChatView from "./components/chat/ChatView"
+import OnboardingView from "./components/onboarding/OnboardingView"
+
+// Mock component that mimics App behavior but works in Storybook
+const MockApp = () => {
+	const { showWelcome, showAnnouncement } = useExtensionState()
+
+	return (
+		<HeroUIProvider>
+			{showWelcome ? (
+				<OnboardingView />
+			) : (
+				<ChatView
+					hideAnnouncement={() => {}}
+					isHidden={false}
+					showAnnouncement={showAnnouncement}
+					showHistoryView={() => {}}
+				/>
+			)}
+		</HeroUIProvider>
+	)
+}
+
+// Constants
+const SIDEBAR_CLASS = "flex flex-col justify-center h-[60%] w-[80%] overflow-hidden"
+const ExtensionStateProviderMock = ExtensionStateContext.Provider
+
+const meta: Meta<typeof MockApp> = {
+	title: "Views/Chat",
+	component: MockApp,
+	parameters: {
+		layout: "fullscreen",
+		docs: {
+			description: {
+				component: `
+The ChatView component is the main interface for interacting with Cline. It provides a comprehensive chat experience with AI assistance, task management, and various tools.
+
+**Key Features:**
+- **Task Management**: Create, resume, and manage AI-assisted tasks
+- **Message History**: View conversation history with rich formatting
+- **File & Image Support**: Attach files and images to messages
+- **Tool Integration**: Execute commands, browse files, and use various tools
+- **Auto-approval**: Configure automatic approval for certain actions
+- **Streaming Responses**: Real-time AI response streaming
+- **Context Management**: Intelligent conversation context handling
+- **Plan/Act Modes**: Separate planning and execution phases
+- **MCP Integration**: Model Context Protocol server support
+- **Browser Automation**: Automated browser interactions
+- **Checkpoint System**: Save and restore conversation states
+
+**Use Cases:**
+- Software development assistance
+- Code review and refactoring
+- File system operations
+- Web browsing and research
+- Task automation
+- Learning and exploration
+
+**Note**: In Storybook, some features like file operations, command execution, and API calls are mocked for demonstration purposes.
+		`,
+			},
+		},
+	},
+	decorators: [
+		(Story) => (
+			<div className="w-full h-full flex justify-center items-center overflow-hidden">
+				<div className={SIDEBAR_CLASS}>
+					<Story />
+				</div>
+			</div>
+		),
+	],
+}
+
+export default meta
+type Story = StoryObj<typeof MockApp>
+
+// Mock data factories
+const createApiConfig = (overrides: Partial<ApiConfiguration> = {}): ApiConfiguration => ({
+	actModeApiProvider: "anthropic",
+	actModeApiModelId: "claude-3-5-sonnet-20241022",
+	actModeOpenRouterModelInfo: {
+		maxTokens: 8000,
+		contextWindow: 200000,
+		supportsPromptCache: true,
+	},
+	apiKey: "mock-key",
+	...overrides,
+})
+
+const mockApiConfiguration = createApiConfig()
+const mockApiConfigurationPlan = createApiConfig({
+	planModeApiProvider: "anthropic",
+	planModeApiModelId: "claude-3-5-sonnet-20241022",
+})
+
+const createHistoryItem = (id: string, hoursAgo: number, task: string, metrics: Partial<HistoryItem> = {}): HistoryItem => ({
+	id,
+	ulid: "01HZZZ1A1B2C3D4E5F6G7H8J9K",
+	ts: Date.now() - hoursAgo * 3600000,
+	task,
+	tokensIn: 2500,
+	tokensOut: 1200,
+	cacheWrites: 350,
+	cacheReads: 180,
+	totalCost: 0.085,
+	size: 123456,
+	...metrics,
+})
+
+const mockTaskHistory: HistoryItem[] = [
+	createHistoryItem("task-1", 1, "Create a React component for displaying user profiles"),
+	createHistoryItem("task-2", 2, "Debug the authentication flow in the login system", {
+		tokensIn: 3200,
+		tokensOut: 1800,
+		cacheWrites: 450,
+		cacheReads: 220,
+		totalCost: 0.125,
+		size: 1234567,
+	}),
+	createHistoryItem("task-3", 24, "Optimize database queries for better performance", {
+		tokensIn: 4500,
+		tokensOut: 2400,
+		cacheWrites: 680,
+		cacheReads: 340,
+		totalCost: 0.185,
+		size: 12345678,
+	}),
+]
+
+const createMessage = (
+	minutesAgo: number,
+	type: ClineMessage["type"],
+	say: ClineMessage["say"],
+	text: string,
+	overrides: Partial<ClineMessage> = {},
+): ClineMessage => ({
+	ts: Date.now() - minutesAgo * 60000,
+	type,
+	say,
+	text,
+	...overrides,
+})
+
+const createSayToolMessage = (
+	minutesAgo: number,
+	sayTool: ClineSayTool,
+	overrides: Partial<ClineMessage> = {},
+): ClineMessage => ({
+	ts: Date.now() - minutesAgo * 60000,
+	type: "say",
+	say: "tool",
+	text: JSON.stringify({
+		operationIsLocatedInWorkspace: true,
+		...sayTool,
+	}),
+	...overrides,
+})
+
+const createApiReqMessage = (minutesAgo: number, request: string, metrics: any = {}) =>
+	createMessage(
+		minutesAgo,
+		"say",
+		"api_req_started",
+		JSON.stringify({
+			request,
+			tokensIn: 19500,
+			tokensOut: 4220,
+			cacheWrites: 120,
+			cacheReads: 60,
+			size: 12345,
+			cost: 0.025,
+			...metrics,
+		}),
+	)
+
+const mockActiveMessages: ClineMessage[] = [
+	createMessage(5, "say", "task", "Help me create a responsive navigation component for a React application"),
+	createApiReqMessage(4.9, "Initial analysis request"),
+	createMessage(
+		4.7,
+		"say",
+		"text",
+		"I'll help you create a responsive navigation component for your React application. Let me start by examining your current project structure and then create a modern, accessible navigation component.",
+	),
+	createMessage(4.3, "say", "tool", JSON.stringify({ tool: "listFilesTopLevel", path: "src/components" })),
+	createApiReqMessage(4.2, "Component creation request", { tokensIn: 12020, tokensOut: 6180, cost: 0.042 }),
+	createMessage(
+		4,
+		"say",
+		"text",
+		"Based on your project structure, I'll create a responsive navigation component with the following features:\n\n- Mobile-first responsive design\n- Accessible keyboard navigation\n- Smooth animations\n- Support for nested menu items\n- Dark/light theme support",
+	),
+	createMessage(
+		3.7,
+		"say",
+		"tool",
+		JSON.stringify({
+			tool: "newFileCreated",
+			path: "src/components/Navigation/Navigation.tsx",
+			content: "// Navigation component code...",
+		}),
+	),
+	createApiReqMessage(3.5, "Final response request", { tokensIn: 41550, tokensOut: 3320, cost: 0.018 }),
+	createMessage(
+		3.3,
+		"say",
+		"text",
+		"I've created a responsive navigation component with TypeScript support. The component includes:\n\n✅ Mobile-first responsive design\n✅ Accessible ARIA attributes\n✅ Toggle functionality for mobile\n✅ TypeScript interfaces for type safety\n✅ Theme support\n\nWould you like me to also create the CSS styles for this component?",
+	),
+]
+
+const mockStreamingMessages: ClineMessage[] = [
+	...mockActiveMessages,
+	createMessage(
+		0.17,
+		"say",
+		"text",
+		"Now I'll create the CSS styles for the navigation component. This will include responsive breakpoints, smooth animations, and accessibility features...",
+		{ partial: true },
+	),
+]
+
+// Reusable state and decorator factories
+// Minimal fixture for the `openRouterModels` storybook prop — the story
+// only needs a non-empty record to exercise the picker code paths.
+const STORYBOOK_OPENROUTER_MODELS: Record<string, ModelInfo> = {
+	"anthropic/claude-sonnet-4.6": {
+		maxTokens: 8192,
+		contextWindow: 200_000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 3,
+		outputPrice: 15,
+	},
+}
+
+const createMockState = (overrides: any = {}) => ({
+	...useExtensionState(),
+	useAutoCondense: true,
+	version: "0.0.1-stories",
+	welcomeViewCompleted: true,
+	showWelcome: false,
+	clineMessages: mockActiveMessages,
+	taskHistory: mockTaskHistory,
+	apiConfiguration: mockApiConfiguration,
+	onboardingModels: undefined,
+	openRouterModels: STORYBOOK_OPENROUTER_MODELS,
+	showAnnouncement: false,
+	backgroundEditEnabled: false,
+	...overrides,
+})
+
+const createStoryDecorator =
+	(stateOverrides: any = {}) =>
+	(Story: any) => {
+		const mockState = useMemo(() => createMockState(stateOverrides), [])
+		return (
+			<ExtensionStateProviderMock value={mockState}>
+				<div className="w-full h-full flex justify-center items-center overflow-hidden">
+					<div className={SIDEBAR_CLASS}>
+						<Story />
+					</div>
+				</div>
+			</ExtensionStateProviderMock>
+		)
+	}
+
+export const Welcome: Story = {
+	decorators: [createStoryDecorator({ welcomeViewCompleted: false, showWelcome: true, clineMessages: [] })],
+	parameters: {
+		docs: {
+			description: {
+				story: "The welcome screen shown to new users or when no task is active. Displays quick start options and recent task history.",
+			},
+		},
+	},
+	args: {},
+	// More on component testing: https://storybook.js.org/docs/writing-tests/interaction-testing
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement)
+		// Button has vscode-button element name
+		const getStartedButton = canvas.getByText("Get Started for Free")
+		const byokButton = canvas.getByText("Use your own API key")
+		await expect(getStartedButton).toBeInTheDocument()
+		await expect(byokButton).toBeInTheDocument()
+		await userEvent.click(byokButton)
+		await expect(getStartedButton).toBeInTheDocument()
+		await expect(byokButton).not.toBeInTheDocument()
+	},
+}
+
+export const Onboarding: Story = {
+	decorators: [
+		createStoryDecorator({
+			welcomeViewCompleted: false,
+			showWelcome: true,
+			clineMessages: [],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "The onboarding flow shown to new users, allowing them to select their preferred AI models and configure initial settings.",
+			},
+		},
+	},
+	// More on component testing: https://storybook.js.org/docs/writing-tests/interaction-testing
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement)
+
+		// Step 0: User type selection should be visible
+		const title = canvas.getByText("How will you use Cline?")
+		await expect(title).toBeInTheDocument()
+		const freeUserOption = canvas.getByText("Absolutely Free")
+		const powerUserOption = canvas.getByText("Frontier Model")
+		await expect(freeUserOption).toBeInTheDocument()
+		await expect(powerUserOption).toBeInTheDocument()
+
+		// Select "Free User" option
+		await userEvent.click(freeUserOption)
+
+		// Verify the next button appears
+		const nextButton = canvas.getByText("Continue")
+		await expect(nextButton).toBeInTheDocument()
+
+		// Click next to go to model selection
+		await userEvent.click(nextButton)
+
+		// Step 1: Model selection should be visible
+		// Check for model group headers
+		const otherOptionsHeader = canvas.getByText("Select a free model")
+
+		// At least one should be visible
+		await expect(otherOptionsHeader).toBeInTheDocument()
+
+		// Test search functionality
+		const searchInput = canvas.getByPlaceholderText("Search model...")
+		await expect(searchInput).toBeInTheDocument()
+
+		// Type in search box
+		await userEvent.type(searchInput, "claude")
+
+		// Verify search term is in the input
+		await expect(searchInput).toHaveValue("claude")
+
+		// Clear search
+		await userEvent.clear(searchInput)
+
+		// Verify sign in button appears after model selection
+		const signInButton = canvas.getByText("Create my Account")
+		await expect(signInButton).toBeInTheDocument()
+
+		// Test back navigation
+		const backButton = canvas.getByText("Back")
+		await expect(backButton).toBeInTheDocument()
+		await userEvent.click(backButton)
+
+		// Should be back to user type selection
+		await expect(canvas.getByText("How will you use Cline?")).toBeInTheDocument()
+
+		// Test power user flow
+		await userEvent.click(powerUserOption)
+
+		const continueButton = canvas.getByText("Continue")
+		await userEvent.click(continueButton)
+
+		// Should see model selection again
+		await expect(canvas.getByPlaceholderText("Search model...")).toBeInTheDocument()
+		await userEvent.click(canvas.getByText("Back"))
+	},
+}
+
+export const EmptyState: Story = {
+	decorators: [createStoryDecorator({ clineMessages: [], taskHistory: [], isNewUser: true, showAnnouncement: true })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the empty state for first-time users with no conversation history or active tasks.",
+			},
+		},
+	},
+}
+
+export const ReturnUser: Story = {
+	decorators: [
+		createStoryDecorator({ clineMessages: [], taskHistory: mockTaskHistory, isNewUser: true, showAnnouncement: false }),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the home screen populated with conversation history for returning users.",
+			},
+		},
+	},
+}
+
+export const ActiveConversation: Story = {
+	decorators: [createStoryDecorator({ task: mockTaskHistory[0], currentTaskItem: mockTaskHistory[0] })],
+	parameters: {
+		docs: {
+			description: {
+				story: "An active conversation showing a typical interaction with Cline, including task creation, tool usage, and AI responses.",
+			},
+		},
+	},
+}
+
+export const StreamingResponse: Story = {
+	decorators: [createStoryDecorator({ clineMessages: mockStreamingMessages })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows a streaming response in progress, demonstrating real-time AI response rendering.",
+			},
+		},
+	},
+}
+
+const createLongMessages = (): ClineMessage[] => [
+	createMessage(30, "say", "task", "Help me build a complete e-commerce application with React, Node.js, and MongoDB"),
+	createMessage(
+		29.7,
+		"say",
+		"text",
+		"I'll help you build a complete e-commerce application. Let's start by setting up the project structure and implementing the core features step by step.",
+	),
+	createMessage(
+		29.3,
+		"say",
+		"tool",
+		JSON.stringify({ tool: "newFileCreated", path: "package.json", content: "// Package.json content..." }),
+	),
+	createMessage(
+		29,
+		"say",
+		"text",
+		"Great! I've set up the initial package.json. Now let's create the backend server with Express and MongoDB integration.",
+	),
+	createMessage(
+		28.7,
+		"say",
+		"tool",
+		JSON.stringify({ tool: "newFileCreated", path: "server.js", content: "// Express server code..." }),
+	),
+	createMessage(
+		28.3,
+		"say",
+		"text",
+		"Perfect! The backend server is set up. Now let's create the product model and routes for handling product operations.",
+	),
+	createMessage(
+		28,
+		"say",
+		"tool",
+		JSON.stringify({ tool: "newFileCreated", path: "models/Product.js", content: "// Product model code..." }),
+	),
+	createMessage(
+		27.7,
+		"say",
+		"text",
+		"Excellent! The Product model is ready with all necessary fields. Now let's create the React frontend with a modern component structure.",
+	),
+	createMessage(27.3, "say", "command", "cd client && npx create-react-app . --template typescript"),
+	createMessage(27, "say", "command_output", "Creating a new React app... Success! Created client at /path/to/project/client"),
+	createMessage(
+		26.7,
+		"say",
+		"text",
+		"Great! The React frontend is set up with TypeScript. Now let's create the main components for our e-commerce application.",
+	),
+]
+
+export const LongConversation: Story = {
+	decorators: [createStoryDecorator({ clineMessages: createLongMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "A longer conversation showing multiple tool uses, file creation, and command execution in a complex development task.",
+			},
+		},
+	},
+}
+
+// Optimized message patterns for common scenarios
+const createErrorMessages = () => [
+	createMessage(5, "say", "task", "Help me fix the build errors in my React application"),
+	createMessage(
+		4.7,
+		"say",
+		"text",
+		"I'll help you fix the build errors. Let me first examine the current state of your application.",
+	),
+	createMessage(4.3, "say", "command", "npm run build"),
+	createMessage(4, "say", "error", "Build failed with TypeScript errors in UserProfile.tsx and api.ts"),
+	createMessage(
+		3.7,
+		"say",
+		"text",
+		"I can see there are TypeScript errors in your code. Let me examine the files and fix these issues.",
+	),
+	createMessage(3.3, "say", "tool", JSON.stringify({ tool: "readFile", path: "src/components/UserProfile_1.tsx" })),
+	createMessage(3.3, "say", "tool", JSON.stringify({ tool: "readFile", path: "src/components/UserProfile_2.tsx" })),
+	createMessage(
+		3,
+		"say",
+		"text",
+		"I found the issue. The User type doesn't have a 'username' property. Let me fix this by updating the component to use the correct property name.",
+	),
+]
+
+const createAskMessage = (type: string, text: string, streamingFailedMessage?: string) => ({
+	ts: Date.now() - 60000,
+	type: "ask" as const,
+	ask: type,
+	text,
+	streamingFailedMessage,
+})
+
+export const ErrorState: Story = {
+	decorators: [createStoryDecorator({ clineMessages: createErrorMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows how Cline handles and displays error messages, helping users understand and resolve issues.",
+			},
+		},
+	},
+}
+
+export const AutoApprovalEnabled: Story = {
+	decorators: [
+		createStoryDecorator({
+			autoApprovalSettings: {
+				...DEFAULT_AUTO_APPROVAL_SETTINGS,
+				enabled: true,
+			},
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the interface with auto-approval enabled, allowing Cline to execute certain actions automatically without user confirmation.",
+			},
+		},
+	},
+}
+
+const createPlanModeMessages = () => [
+	createMessage(5, "say", "task", "Help me refactor my React application to use TypeScript and improve performance"),
+	createApiReqMessage(4.9, "Planning analysis request", { tokensIn: 20000, tokensOut: 19500, cost: 0.065 }),
+	createMessage(
+		4.7,
+		"say",
+		"text",
+		"I'll help you refactor your React application to use TypeScript and improve performance. Let me create a detailed plan for this migration.",
+	),
+	createApiReqMessage(4.5, "Detailed planning request", { tokensIn: 20002, tokensOut: 12500, cost: 0.095 }),
+	createAskMessage(
+		"plan_mode_respond",
+		"Here's my comprehensive plan for refactoring your React application with TypeScript migration and performance optimization phases.\n\n\n\n\nPhase 1: TypeScript Migration\n1. Set up TypeScript in the project\n2. Rename .js files to .tsx/.ts\n3. Add type definitions for components and props\n4. Fix type errors and ensure type safety\n\nPhase 2: Performance Optimization\n1. Analyze current performance bottlenecks\n2. Implement code-splitting and lazy loading\n3. Optimize rendering with React.memo and useCallback\n4. Minimize bundle size with tree-shaking and minification\n5. Test performance improvements using profiling tools",
+	),
+]
+
+export const PlanMode: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: createPlanModeMessages(),
+			apiConfiguration: mockApiConfigurationPlan,
+			mode: "plan" as const,
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows Cline in Plan mode, where it focuses on creating detailed plans and discussing approaches before implementation.",
+			},
+		},
+	},
+}
+
+const createBrowserMessages = () => [
+	createMessage(5, "say", "task", "Help me test the login functionality on my web application"),
+	createMessage(
+		4.7,
+		"say",
+		"text",
+		"I'll help you test the login functionality. Let me launch a browser and navigate to your application.",
+	),
+	createMessage(4.3, "say", "browser_action_launch", JSON.stringify({ action: "launch", url: "http://localhost:3000/login" })),
+	createMessage(
+		4,
+		"say",
+		"browser_action_result",
+		JSON.stringify({ currentUrl: "http://localhost:3000/login", logs: "Page loaded successfully" }),
+	),
+	createMessage(
+		3.7,
+		"say",
+		"text",
+		"Great! The browser has launched and navigated to your login page. Now let me test the login functionality.",
+	),
+	createMessage(3.3, "say", "browser_action", JSON.stringify({ action: "click", coordinate: "400,200" })),
+	createMessage(3, "say", "browser_action", JSON.stringify({ action: "type", text: "test@example.com" })),
+]
+
+export const BrowserAutomation: Story = {
+	decorators: [createStoryDecorator({ clineMessages: createBrowserMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows Cline performing browser automation tasks, including launching browsers, clicking elements, and testing web applications.",
+			},
+		},
+	},
+}
+
+// Optimized stories using ask message pattern
+const createToolApprovalMessages = () => [
+	createMessage(5, "say", "task", "Help me read the configuration file"),
+	createMessage(4.7, "say", "text", "I need to read a file to understand your configuration."),
+	createAskMessage("tool", JSON.stringify({ tool: "readFile", path: "config.json" })),
+]
+
+export const ToolApproval: Story = {
+	decorators: [createStoryDecorator({ clineMessages: createToolApprovalMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows tool approval request with Approve/Reject buttons for file operations.",
+			},
+		},
+	},
+}
+
+export const ToolSave: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "task", "Update the README file with new instructions"),
+				createMessage(4.7, "say", "text", "I'll update your README file with the new instructions."),
+				createAskMessage("tool", JSON.stringify({ tool: "editedExistingFile", path: "README.md" })),
+			],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows file save request with Save/Reject buttons for file editing operations.",
+			},
+		},
+	},
+}
+
+// Quick story generators for common patterns
+const quickStory = (
+	name: string,
+	askType: string,
+	text: string,
+	description: string,
+	streamingFailedMessage?: string,
+): Story => ({
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				...createLongMessages(),
+				createMessage(6, "say", "task", `Help with ${name.toLowerCase()}`),
+				createMessage(5, "say", "reasoning", `Thinking about helping user with ${name.toLowerCase()}`),
+				createMessage(4.7, "say", "text", `I'll help you with ${name.toLowerCase()}.`),
+				createAskMessage(askType, text, streamingFailedMessage),
+			],
+		}),
+	],
+	parameters: { docs: { description: { story: description } } },
+})
+
+export const CommandExecution: Story = quickStory(
+	"Command Execution",
+	"command",
+	"npm install",
+	"Shows command execution request with Run Command/Reject buttons.",
+)
+
+export const CommandOutput: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createAskMessage("command", "npm install"),
+				createAskMessage("command_output", "Installing packages... This may take a few minutes."),
+			],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows command output with Proceed While Running button during command execution.",
+			},
+		},
+	},
+}
+
+// Batch create remaining optimized stories
+export const ApiRequestFailed = quickStory(
+	"API Request Failed",
+	"api_req_failed",
+	"API request failed due to network timeout. Would you like to retry?",
+	"Shows error recovery options with Retry/Start New Task buttons when API requests fail.",
+)
+export const MistakeLimitReached = quickStory(
+	"Mistake Limit",
+	"mistake_limit_reached",
+	"I've made several attempts to fix this issue but haven't been successful.",
+	"Shows mistake limit reached state with Proceed Anyways/Start New Task options.",
+)
+export const CompletionResult = quickStory(
+	"Task Completion",
+	"completion_result",
+	"Task completed successfully! I've implemented all the requested features.\n\nWould you like to start a new task?\n\n- Start New Task\n- Resume Previous Task HAS_CHANGES",
+	"Shows task completion state with Start New Task button.",
+)
+export const BrowserActionLaunch = quickStory(
+	"Browser Launch",
+	"browser_action_launch",
+	"Launch browser to test the website at http://localhost:3000",
+	"Shows browser action approval with Approve/Reject buttons for browser launch.",
+)
+export const McpServerUsage = quickStory(
+	"MCP Server",
+	"use_mcp_server",
+	JSON.stringify({ tool: "get_weather", location: "New York" }),
+	"Shows MCP server usage approval with Approve/Reject buttons for external tool usage.",
+)
+export const Followup = quickStory(
+	"Follow-up",
+	"followup",
+	"What would you like me to work on next?",
+	"Shows followup question state where Cline asks for next steps.",
+)
+export const ResumeTask = quickStory(
+	"Resume Task",
+	"resume_task",
+	"Would you like to resume the previous task?",
+	"Shows resume task option for continuing interrupted work.",
+)
+export const NewTaskWithContext = quickStory(
+	"New Task",
+	"new_task",
+	"Start a new task with the current conversation context",
+	"Shows new task creation with context preservation option.",
+)
+export const ApiRequestActive: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "text", "Processing your request...", { partial: true }),
+				createApiReqMessage(4.7, "Making API request to generate response", { partial: true }),
+			],
+		}),
+	],
+	parameters: { docs: { description: { story: "Shows active API request state with Cancel button available." } } },
+}
+export const PlanModeResponse = quickStory(
+	"Plan Mode Response",
+	"plan_mode_respond",
+	"Here's my comprehensive plan for refactoring your React application with TypeScript migration and performance optimization phases.\n\n\n\n\nPhase 1: TypeScript Migration\n1. Set up TypeScript in the project\n2. Rename .js files to .tsx/.ts\n3. Add type definitions for components and props\n4. Fix type errors and ensure type safety\n\nPhase 2: Performance Optimization\n1. Analyze current performance bottlenecks\n2. Implement code-splitting and lazy loading\n3. Optimize rendering with React.memo and useCallback\n4. Minimize bundle size with tree-shaking and minification\n5. Test performance improvements using profiling tools",
+	"Shows plan mode response where Cline presents a detailed plan for user approval.",
+)
+export const CondenseConversation = quickStory(
+	"Condense Conversation",
+	"condense",
+	"Would you like me to condense the conversation to improve performance?",
+	"Shows utility action to condense conversation for better performance.",
+)
+export const ReportBug = quickStory(
+	"Report Bug",
+	"report_bug",
+	JSON.stringify({
+		steps_to_reproduce: "1. Open Cline\n2. Start a new task\n3. Observe the error",
+		what_happened: "Cline crashes unexpectedly",
+	}),
+	"Shows utility action to report bugs to the GitHub repository.",
+)
+export const ResumeCompletedTask = quickStory(
+	"Resume Completed Task type",
+	"resume_completed_task",
+	"The previous task has been completed. Would you like to start a new task?",
+	"Shows Start New Task option for resume completed task.",
+)
+
+export const ShellIntegrationWarningWithSuggestion: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "task", "Run a command"),
+				createMessage(4.7, "say", "text", "I'll run the command for you."),
+				createMessage(4.5, "say", "shell_integration_warning_with_suggestion", ""),
+			],
+			vscodeTerminalExecutionMode: "integrated",
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows shell integration warning with suggestion to enable Background Terminal mode.",
+			},
+		},
+	},
+}
+
+export const ShellIntegrationWarningBackgroundEnabled: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "task", "Run a command"),
+				createMessage(4.7, "say", "text", "I'll run the command for you."),
+				createMessage(4.5, "say", "shell_integration_warning_with_suggestion", ""),
+			],
+			vscodeTerminalExecutionMode: "backgroundExec",
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows shell integration warning when Background Terminal mode is already enabled.",
+			},
+		},
+	},
+}
+
+export const ShellIntegrationWarning: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "task", "Run a command"),
+				createMessage(4.7, "say", "text", "I'll run the command for you."),
+				createMessage(4.5, "say", "shell_integration_warning", ""),
+			],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows shell integration unavailable warning with instructions to update VSCode and select a supported shell.",
+			},
+		},
+	},
+}
+
+export const ErrorRetryInProgress: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "task", "Process a request"),
+				createMessage(4.7, "say", "text", "Attempting to process your request."),
+				createMessage(
+					4.5,
+					"say",
+					"error_retry",
+					JSON.stringify({ attempt: 2, maxAttempts: 5, delaySeconds: 10, failed: false }),
+				),
+			],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows auto-retry in progress with attempt count and delay.",
+			},
+		},
+	},
+}
+
+export const ErrorRetryFailed: Story = {
+	decorators: [
+		createStoryDecorator({
+			clineMessages: [
+				createMessage(5, "say", "task", "Process a request"),
+				createMessage(4.7, "say", "text", "Attempting to process your request."),
+				createMessage(
+					4.5,
+					"say",
+					"error_retry",
+					JSON.stringify({ attempt: 5, maxAttempts: 5, delaySeconds: 0, failed: true }),
+				),
+			],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows auto-retry failed after max attempts with manual intervention required.",
+			},
+		},
+	},
+}
+
+// Diff Edit Stories - New Format
+const createNewFormatMultiFileMessages = () => [
+	createMessage(5, "say", "task", "Help me refactor the authentication module"),
+	createMessage(4.7, "say", "text", "I'll help you refactor the authentication module. Let me make the necessary changes."),
+	createSayToolMessage(4.3, {
+		tool: "editedExistingFile",
+		path: "src/auth/types.ts",
+		content: `*** Begin Patch
+*** Add File: src/auth/types.ts
++export interface User {
++  id: string
++  email: string
++  role: 'admin' | 'user'
++}
++
++export interface AuthState {
++  user: User | null
++  isAuthenticated: boolean
++}
+
+*** Update File: src/auth/login.ts
+@@
+-function login(email, password) {
+-  return fetch('/api/login', {
++function login(email: string, password: string): Promise<AuthState> {
++  return fetch('/api/login', {
+	 method: 'POST',
+-    body: { email, password }
++    body: JSON.stringify({ email, password }),
++    headers: { 'Content-Type': 'application/json' }
+   })
+ }
+@@
+-export default login
++export { login }
+
+*** Delete File: src/auth/old-utils.js
+-function deprecatedHelper() {
+-  console.log('This is deprecated')
+-}
+-
+-module.exports = { deprecatedHelper }
+*** End Patch`,
+	}),
+	{ partial: false },
+]
+
+export const DiffEditNewFormat: Story = {
+	decorators: [createStoryDecorator({ backgroundEditEnabled: true, clineMessages: createNewFormatMultiFileMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the new diff edit format with multiple file operations (Add, Update, Delete) displayed in an organized, expandable view.",
+			},
+		},
+	},
+}
+
+export const DiffEditNewFormatStreaming: Story = {
+	decorators: [
+		(Story) => {
+			const [messages, setMessages] = useState<ClineMessage[]>([
+				createMessage(5, "say", "task", "Add TypeScript types to the user module"),
+				createMessage(4.7, "say", "text", "I'll add TypeScript types to improve type safety."),
+			])
+			const mockState = useMemo(() => createMockState({ backgroundEditEnabled: true, clineMessages: messages }), [messages])
+
+			useEffect(() => {
+				// Simulate streaming: progressively add more content
+				const partialPatch = `*** Begin Patch
+*** Update File: src/user/profile.ts
+@@
+-interface UserProfile {
+-  name: string
++interface UserProfile {
++  id: string
++  name: string`
+
+				const morePatch =
+					partialPatch +
+					`
++  email: string
++  createdAt: Date`
+
+				const completePatch =
+					morePatch +
+					`
++}
+*** End Patch`
+
+				// Add initial partial message
+				const timer1 = setTimeout(() => {
+					setMessages((prev: ClineMessage[]) => [
+						...prev,
+						createSayToolMessage(
+							4.3,
+							{
+								tool: "editedExistingFile",
+								path: "src/user/profile.ts",
+								content: partialPatch,
+							},
+							{ partial: true },
+						),
+					])
+				}, 500)
+
+				// Add more content
+				const timer2 = setTimeout(() => {
+					setMessages((prev: ClineMessage[]) => {
+						const updated = [...prev]
+						updated[updated.length - 1] = createSayToolMessage(
+							4.3,
+							{
+								tool: "editedExistingFile",
+								path: "src/user/profile.ts",
+								content: morePatch,
+							},
+							{ partial: true },
+						)
+						return updated
+					})
+				}, 1500)
+
+				// Complete the patch
+				const timer3 = setTimeout(() => {
+					setMessages((prev: ClineMessage[]) => {
+						const updated = [...prev]
+						updated[updated.length - 1] = createSayToolMessage(
+							4.3,
+							{
+								tool: "editedExistingFile",
+								path: "src/user/profile.ts",
+								content: completePatch,
+							},
+							{ partial: false },
+						)
+						return updated
+					})
+				}, 2500)
+
+				return () => {
+					clearTimeout(timer1)
+					clearTimeout(timer2)
+					clearTimeout(timer3)
+				}
+			}, [])
+
+			return (
+				<ExtensionStateProviderMock value={mockState}>
+					<div className="w-full h-full flex justify-center items-center overflow-hidden">
+						<div className={SIDEBAR_CLASS}>
+							<Story />
+						</div>
+					</div>
+				</ExtensionStateProviderMock>
+			)
+		},
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the new diff edit format while streaming (incomplete patch without End Patch marker).",
+			},
+		},
+	},
+}
+
+// Diff Edit Stories - Replace Diff Edit Format
+const createReplaceDiffFormatPatchMessages = () => [
+	createMessage(5, "say", "task", "Fix the validation logic in the form"),
+	createMessage(4.7, "say", "text", "I'll fix the validation logic using the updated pattern."),
+	createSayToolMessage(4.3, {
+		tool: "editedExistingFile",
+		path: "src/auth/types.ts",
+		content: `------- SEARCH
+function validateEmail(email) {
+  return email.includes('@')
+}
+=======
+function validateEmail(email: string): boolean {
+  const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/
+  return emailRegex.test(email)
+}
++++++++ REPLACE`,
+	}),
+]
+
+export const DiffEditReplaceDiffFormat: Story = {
+	decorators: [createStoryDecorator({ backgroundEditEnabled: true, clineMessages: createReplaceDiffFormatPatchMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the old SEARCH/REPLACE diff format (backward compatibility) with complete markers, automatically converted to the new format display.",
+			},
+		},
+	},
+}
+
+export const DiffEditReplaceDiffFormatStreaming: Story = {
+	decorators: [
+		(Story) => {
+			const [messages, setMessages] = useState<ClineMessage[]>([
+				createMessage(5, "say", "task", "Update error handling"),
+				createMessage(4.7, "say", "text", "I'll improve the error handling in the API client."),
+			])
+			const mockState = useMemo(() => createMockState({ backgroundEditEnabled: true, clineMessages: messages }), [messages])
+
+			useEffect(() => {
+				const completePatch = `------- SEARCH
+try {
+  const response = await fetch(url)
+  return response.json()
+} catch (error) {
+  console.error(error)
+}
+=======
+try {
+  const response = await fetch(url)
+  if (!response.ok) {
+	throw new Error(\`HTTP error! status: \${response.status}\`)
+  }
+  return response.json()
+} catch (error) {
+  console.error('API request failed:', error)
+  throw error
+}
++++++++ REPLACE`
+
+				const patchChunks = completePatch.split("\n")
+				let currentIndex = 0
+
+				const intervalId = setInterval(() => {
+					if (currentIndex >= patchChunks.length) {
+						clearInterval(intervalId)
+						return
+					}
+
+					setMessages((prev: ClineMessage[]) => {
+						const updated = [...prev]
+						updated[updated.length - 1] = createSayToolMessage(
+							4.3,
+							{
+								tool: "editedExistingFile",
+								path: "src/auth/types.ts",
+								content: patchChunks.slice(0, currentIndex + 1).join("\n"),
+							},
+							{ partial: currentIndex !== patchChunks.length - 1 },
+						)
+						return updated
+					})
+
+					currentIndex++
+				}, 500)
+
+				return () => clearInterval(intervalId)
+			}, [])
+
+			return (
+				<ExtensionStateProviderMock value={mockState}>
+					<div className="w-full h-full flex justify-center items-center overflow-hidden">
+						<div className={SIDEBAR_CLASS}>
+							<Story />
+						</div>
+					</div>
+				</ExtensionStateProviderMock>
+			)
+		},
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the old SEARCH/REPLACE diff format while streaming (incomplete, missing REPLACE marker), demonstrating graceful handling of partial content.",
+			},
+		},
+	},
+}
+
+// Combined example showing both formats in one conversation
+const createMixedFormatMessages = () => [
+	createMessage(5, "say", "task", "Refactor the entire authentication system"),
+	createMessage(4.7, "say", "text", "I'll refactor the authentication system. Starting with the login function."),
+	createSayToolMessage(4.5, {
+		tool: "editedExistingFile",
+		path: "src/auth/types.ts",
+		content: `------- SEARCH
+function login(username, password) {
+  return authenticateUser(username, password)
+}
+=======
+async function login(username: string, password: string): Promise<AuthResult> {
+  return await authenticateUser(username, password)
+}
++++++++ REPLACE`,
+	}),
+	createMessage(4.3, "say", "text", "Great! Now let me add the type definitions and update the authentication module."),
+	createSayToolMessage(4.0, {
+		tool: "editedExistingFile",
+		path: "src/auth/types.ts",
+		content: `*** Begin Patch
+*** Add File: src/auth/types.ts
++export interface AuthResult {
++  success: boolean
++  token?: string
++  error?: string
++}
++
++export interface LoginCredentials {
++  username: string
++  password: string
++}
+
+*** Update File: src/auth/authenticate.ts
+@@
+-function authenticateUser(username, password) {
++async function authenticateUser(username: string, password: string): Promise<AuthResult> {
+   // Authentication logic
++  return { success: true, token: 'mock-token' }
+ }
+*** End Patch`,
+	}),
+]
+
+export const DiffEditMixedFormats: Story = {
+	decorators: [createStoryDecorator({ clineMessages: createMixedFormatMessages() })],
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows a conversation using both search / replace and apply patch diff formats, demonstrating seamless backward compatibility and format detection.",
+			},
+		},
+	},
+}
diff --git a/apps/vscode/webview-ui/src/App.tsx b/apps/vscode/webview-ui/src/App.tsx
new file mode 100644
index 0000000..69676cd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/App.tsx
@@ -0,0 +1,113 @@
+import type { Boolean, EmptyRequest } from "@shared/proto/cline/common"
+import { useCallback, useEffect } from "react"
+import AccountView from "./components/account/AccountView"
+import ChatView from "./components/chat/ChatView"
+import HistoryView from "./components/history/HistoryView"
+import MarketplaceView from "./components/marketplace/MarketplaceView"
+import McpView from "./components/mcp/configuration/McpConfigurationView"
+import { openClinePassSubscriptionIfPending } from "./components/onboarding/clinePassSubscribe"
+import OnboardingView from "./components/onboarding/OnboardingView"
+import SettingsView from "./components/settings/SettingsView"
+import WorktreesView from "./components/worktrees/WorktreesView"
+import { useClineAuth } from "./context/ClineAuthContext"
+import { useExtensionState } from "./context/ExtensionStateContext"
+import { Providers } from "./Providers"
+import { UiServiceClient } from "./services/grpc-client"
+
+const AppContent = () => {
+	const {
+		didHydrateState,
+		showWelcome,
+		shouldShowAnnouncement,
+		showMarketplace,
+		showMcp,
+		mcpTab,
+		showSettings,
+		settingsTargetSection,
+		showHistory,
+		showAccount,
+		showWorktrees,
+		showAnnouncement,
+		setShowAnnouncement,
+		setShouldShowAnnouncement,
+		closeMcpView,
+		navigateToHistory,
+		hideSettings,
+		hideHistory,
+		hideAccount,
+		hideWorktrees,
+		closeMarketplaceView,
+		hideAnnouncement,
+	} = useExtensionState()
+
+	const { clineUser, organizations, activeOrganization } = useClineAuth()
+
+	const showUpdateAnnouncementModal = useCallback(() => {
+		setShowAnnouncement(true)
+		UiServiceClient.onDidShowAnnouncement({} as EmptyRequest)
+			.then((response: Boolean) => {
+				setShouldShowAnnouncement(response.value)
+			})
+			.catch((error) => {
+				console.error("Failed to acknowledge announcement:", error)
+			})
+	}, [setShouldShowAnnouncement, setShowAnnouncement])
+
+	useEffect(() => {
+		if (!didHydrateState || showWelcome || !shouldShowAnnouncement || showAnnouncement) {
+			return
+		}
+		showUpdateAnnouncementModal()
+	}, [didHydrateState, showWelcome, shouldShowAnnouncement, showAnnouncement, showUpdateAnnouncementModal])
+
+	// Open the ClinePass subscription page once auth completes. Lives here (not in OnboardingView)
+	// because handleAuthCallback unmounts onboarding before the clineUser update arrives.
+	useEffect(() => {
+		if (clineUser?.uid) {
+			openClinePassSubscriptionIfPending(clineUser.appBaseUrl)
+		}
+	}, [clineUser?.uid, clineUser?.appBaseUrl])
+
+	if (!didHydrateState) {
+		return null
+	}
+
+	if (showWelcome) {
+		return <OnboardingView />
+	}
+
+	return (
+		<div className="flex h-screen w-full flex-col">
+			{showSettings && <SettingsView onDone={hideSettings} targetSection={settingsTargetSection} />}
+			{showHistory && <HistoryView onDone={hideHistory} />}
+			{showMarketplace && <MarketplaceView initialType={mcpTab ? "mcp" : undefined} onDone={closeMarketplaceView} />}
+			{showMcp && <McpView initialTab={mcpTab} onDone={closeMcpView} />}
+			{showAccount && (
+				<AccountView
+					activeOrganization={activeOrganization}
+					clineUser={clineUser}
+					onDone={hideAccount}
+					organizations={organizations}
+				/>
+			)}
+			{showWorktrees && <WorktreesView onDone={hideWorktrees} />}
+			{/* Do not conditionally load ChatView, it's expensive and there's state we don't want to lose (user input, disableInput, askResponse promise, etc.) */}
+			<ChatView
+				hideAnnouncement={hideAnnouncement}
+				isHidden={showSettings || showHistory || showMarketplace || showMcp || showAccount || showWorktrees}
+				showAnnouncement={showAnnouncement}
+				showHistoryView={navigateToHistory}
+			/>
+		</div>
+	)
+}
+
+const App = () => {
+	return (
+		<Providers>
+			<AppContent />
+		</Providers>
+	)
+}
+
+export default App
diff --git a/apps/vscode/webview-ui/src/CustomPostHogProvider.tsx b/apps/vscode/webview-ui/src/CustomPostHogProvider.tsx
new file mode 100644
index 0000000..847bc3e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/CustomPostHogProvider.tsx
@@ -0,0 +1,73 @@
+import { posthogConfig } from "@shared/services/config/posthog-config"
+import posthog from "posthog-js"
+import { PostHogProvider } from "posthog-js/react"
+import { type ReactNode, useEffect, useState } from "react"
+import { useExtensionState } from "./context/ExtensionStateContext"
+
+export function CustomPostHogProvider({ children }: { children: ReactNode }) {
+	const { distinctId, version, userInfo, environment, telemetrySetting } = useExtensionState()
+
+	// Skip PostHog entirely in self-hosted mode or when environment is unknown (safety fallback)
+	const isSelfHostedOrUnknown = !environment || environment === "selfHosted"
+
+	const isTelemetryEnabled = telemetrySetting !== "disabled"
+	const [isActive, setIsActive] = useState(false)
+
+	useEffect(() => {
+		if (isSelfHostedOrUnknown || isActive || !posthogConfig.apiKey) {
+			return
+		}
+		// At this point, we know apiKey is defined due to the check above
+		const apiKey = posthogConfig.apiKey as string
+		posthog.init(apiKey, {
+			api_host: posthogConfig.host,
+			ui_host: posthogConfig.uiHost,
+			disable_session_recording: true,
+			capture_pageview: false,
+			capture_dead_clicks: false,
+			// Feature flags should work regardless of telemetry opt-out
+			advanced_disable_decide: false,
+			// Autocapture should respect telemetry settings
+			autocapture: false,
+		})
+		setIsActive(true)
+	}, [isSelfHostedOrUnknown])
+
+	useEffect(() => {
+		if (!isActive || !distinctId || !version) {
+			return
+		}
+
+		posthog.set_config({
+			before_send: (payload) => {
+				// Only filter out events if telemetry is disabled, but allow feature flag requests
+				if (!isTelemetryEnabled && payload?.event !== "$feature_flag_called") {
+					return null
+				}
+
+				if (payload?.properties) {
+					payload.properties.extension_version = version
+					payload.properties.distinct_id = distinctId
+				}
+				return payload
+			},
+		})
+
+		const optedIn = posthog.has_opted_in_capturing()
+		const optedOut = posthog.has_opted_out_capturing()
+		const args = {
+			email: userInfo?.email,
+			name: userInfo?.displayName,
+		}
+		posthog.identify(distinctId, args)
+
+		if (isTelemetryEnabled && !optedIn) {
+			posthog.opt_in_capturing()
+		} else if (!isTelemetryEnabled && !optedOut) {
+			// Then opt out of capturing other events
+			posthog.opt_out_capturing()
+		}
+	}, [isActive, isTelemetryEnabled, distinctId, version])
+
+	return <PostHogProvider client={posthog}>{children}</PostHogProvider>
+}
diff --git a/apps/vscode/webview-ui/src/Providers.tsx b/apps/vscode/webview-ui/src/Providers.tsx
new file mode 100644
index 0000000..ed1a5ed
--- /dev/null
+++ b/apps/vscode/webview-ui/src/Providers.tsx
@@ -0,0 +1,20 @@
+import { HeroUIProvider } from "@heroui/react"
+import { type ReactNode } from "react"
+import { CustomPostHogProvider } from "./CustomPostHogProvider"
+import { ClineAuthProvider } from "./context/ClineAuthContext"
+import { ExtensionStateContextProvider } from "./context/ExtensionStateContext"
+import { PlatformProvider } from "./context/PlatformContext"
+
+export function Providers({ children }: { children: ReactNode }) {
+	return (
+		<PlatformProvider>
+			<ExtensionStateContextProvider>
+				<CustomPostHogProvider>
+					<ClineAuthProvider>
+						<HeroUIProvider>{children}</HeroUIProvider>
+					</ClineAuthProvider>
+				</CustomPostHogProvider>
+			</ExtensionStateContextProvider>
+		</PlatformProvider>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/assets/ClineLogoSanta.tsx b/apps/vscode/webview-ui/src/assets/ClineLogoSanta.tsx
new file mode 100644
index 0000000..bfc506c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/ClineLogoSanta.tsx
@@ -0,0 +1,46 @@
+import { SVGProps } from "react"
+import type { Environment } from "../../../src/shared/config-types"
+import { getEnvironmentColor } from "../utils/environmentColors"
+
+/**
+ * ClineLogoSanta component renders the Cline logo with a festive Santa hat
+ * Includes automatic theme adaptation and environment-based color indicators.
+ *
+ * This festive version adds a Santa hat to the robot character while maintaining
+ * the same theme and environment color system as ClineLogoVariable.
+ *
+ * @param {SVGProps<SVGSVGElement> & { environment?: Environment }} props - Standard SVG props plus optional environment
+ * @returns {JSX.Element} SVG Cline logo with Santa hat that adapts to VS Code themes and environment
+ */
+const ClineLogoSanta = (props: SVGProps<SVGSVGElement> & { environment?: Environment }) => {
+	const { environment, ...svgProps } = props
+
+	// Determine fill color based on environment
+	const fillColor = environment ? getEnvironmentColor(environment) : "var(--vscode-icon-foreground)"
+
+	return (
+		<svg height="50" viewBox="0 0 66.62 63.92" width="47" xmlns="http://www.w3.org/2000/svg" {...svgProps}>
+			{/* Original Cline robot logo */}
+			<path
+				d="M55.69,42.04l-2.91-5.8v-3.34c0-5.54-4.47-10.03-9.98-10.03h-4.97c.36-.73.56-1.56.56-2.43,0-3.08-2.49-5.57-5.57-5.57s-5.57,2.49-5.57,5.57c0,.87.2,1.7.56,2.43h-4.97c-5.51,0-9.98,4.49-9.98,10.03v3.34l-2.97,5.79c-.3.58-.3,1.28,0,1.86l2.97,5.72v3.34c0,5.54,4.47,10.03,9.98,10.03h19.96c5.51,0,9.98-4.49,9.98-10.03v-3.34l2.9-5.74c.29-.57.29-1.25,0-1.82ZM29.79,46.77c0,2.52-2.04,4.56-4.56,4.56s-4.56-2.04-4.56-4.56v-8.1c0-2.52,2.04-4.56,4.56-4.56s4.56,2.04,4.56,4.56v8.1ZM44.47,46.77c0,2.52-2.04,4.56-4.56,4.56s-4.56-2.04-4.56-4.56v-8.1c0-2.52,2.04-4.56,4.56-4.56s4.56,2.04,4.56,4.56v8.1Z"
+				fill={fillColor}
+			/>
+
+			{/* Santa hat - main red body */}
+			<path
+				d="M57.49,17.46,60.4,14.63c-.14-.01-.21-.13-.27-.26-1.43-2.96-1.52-3.53-4.67-6.86S43.99-.26,33.66.78c-2.51.25-7.99,1.46-11.38,4.92s-6.13,3.78-7.64,8.29c-.27.8-.39,1.63-.63,2.23-.03.07-.08.13-.15.16-.71.36-1.12.58-1.22.65-1.31.91-2.08,2.19-2.29,3.84-.21,1.66-.37,2.93-.46,3.83-.2,1.91.39,3.41,1.77,4.5.87.69,2.68-.33,3.63-1.16,4.39-3.85,16.92,1.42,24.19,2.64,3.06.51,7.98-.36,11.58.56,2.81.72,4.92,2.12,5.3-.71.24-1.81.41-3.27.53-4.39.17-1.75-.43-2.98-1.51-4.22-.07-.08-.11-.18-.11-.29-.01-.44,0-.9.02-1.38.08-1.87-1.10-3.89-1.4-5.9,0-.07.06-.1.12-.09,6.03,1.05,4.91,1.28,4.56,1.91"
+				fill="#CC3333"
+			/>
+
+			{/* Santa hat - white fur trim */}
+			<path
+				d="M39.99,17.91c3.92.68,8.56,1.61,11.8,2.55.66.19,1.35.42,2.07.69,2.09.79,3.34,2.54,3.03,5.31-.24,2.13-.47,3.9-.68,5.34-.02.12-.05.24-.09.35-.51,1.43-1.33,2.3-2.46,2.61-.54.15-1.59,0-3.16-.45-4.77-1.35-11.05-2.49-16.7-3.16s-14.15-1.31-19.11-1.13c-1.63.06-2.69-.04-3.18-.31-1.02-.57-1.61-1.61-1.77-3.12-.01-.12-.01-.24,0-.36.13-1.44.33-3.23.6-5.35.35-2.76,1.98-4.17,4.2-4.44.77-.09,1.49-.15,2.18-.18,3.37-.14,10.25.3,14.21.57"
+				fill="white"
+			/>
+
+			{/* Santa hat - white pom-pom */}
+			<circle cx="61.35" cy="19.8" fill="white" r="5.27" />
+		</svg>
+	)
+}
+export default ClineLogoSanta
diff --git a/apps/vscode/webview-ui/src/assets/ClineLogoVariable.tsx b/apps/vscode/webview-ui/src/assets/ClineLogoVariable.tsx
new file mode 100644
index 0000000..ed03200
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/ClineLogoVariable.tsx
@@ -0,0 +1,32 @@
+import { SVGProps } from "react"
+import type { Environment } from "../../../src/shared/config-types"
+import { getEnvironmentColor } from "../utils/environmentColors"
+
+/**
+ * ClineLogoVariable component renders the Cline logo with automatic theme adaptation
+ * and environment-based color indicators.
+ *
+ * This component uses VS Code theme variables for the fill color, with environment-specific colors:
+ * - Local: yellow/orange (development/experimental)
+ * - Staging: blue (stable testing)
+ * - Production: gray/white (default icon color)
+ *
+ * @param {SVGProps<SVGSVGElement> & { environment?: Environment }} props - Standard SVG props plus optional environment
+ * @returns {JSX.Element} SVG Cline logo that adapts to VS Code themes and environment
+ */
+const ClineLogoVariable = (props: SVGProps<SVGSVGElement> & { environment?: Environment }) => {
+	const { environment, ...svgProps } = props
+
+	// Determine fill color based on environment
+	const fillColor = environment ? getEnvironmentColor(environment) : "var(--vscode-icon-foreground)"
+
+	return (
+		<svg fill="none" height="50" viewBox="0 0 47 50" width="47" xmlns="http://www.w3.org/2000/svg" {...svgProps}>
+			<path
+				d="M46.4075 28.1192L43.5011 22.3166V18.9747C43.5011 13.4354 39.0302 8.94931 33.5162 8.94931H28.5491C28.9086 8.21513 29.106 7.3898 29.106 6.5189C29.106 3.44039 26.6149 0.949219 23.5363 0.949219C20.4578 0.949219 17.9667 3.44039 17.9667 6.5189C17.9667 7.3898 18.1641 8.21513 18.5236 8.94931H13.5565C8.04249 8.94931 3.57155 13.4354 3.57155 18.9747V22.3166L0.604424 28.104C0.305687 28.6863 0.305687 29.3799 0.604424 29.9622L3.57155 35.6838V39.0256C3.57155 44.5649 8.04249 49.0511 13.5565 49.0511H33.5162C39.0302 49.0511 43.5011 44.5649 43.5011 39.0256V35.6838L46.4024 29.942C46.691 29.3698 46.691 28.6964 46.4075 28.1192ZM20.4983 32.8483C20.4983 35.3648 18.4578 37.4053 15.9413 37.4053C13.4248 37.4053 11.3843 35.3648 11.3843 32.8483V24.747C11.3843 22.2305 13.4248 20.19 15.9413 20.19C18.4578 20.19 20.4983 22.2305 20.4983 24.747V32.8483ZM35.182 32.8483C35.182 35.3648 33.1415 37.4053 30.625 37.4053C28.1085 37.4053 26.068 35.3648 26.068 32.8483V24.747C26.068 22.2305 28.1085 20.19 30.625 20.19C33.1415 20.19 35.182 22.2305 35.182 24.747V32.8483Z"
+				fill={fillColor}
+			/>
+		</svg>
+	)
+}
+export default ClineLogoVariable
diff --git a/apps/vscode/webview-ui/src/assets/ClineLogoWhite.tsx b/apps/vscode/webview-ui/src/assets/ClineLogoWhite.tsx
new file mode 100644
index 0000000..90718c0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/ClineLogoWhite.tsx
@@ -0,0 +1,11 @@
+import { SVGProps } from "react"
+
+const ClineLogoWhite = (props: SVGProps<SVGSVGElement>) => (
+	<svg fill="none" height="50" viewBox="0 0 47 50" width="47" xmlns="http://www.w3.org/2000/svg" {...props}>
+		<path
+			d="M46.4075 28.1192L43.5011 22.3166V18.9747C43.5011 13.4354 39.0302 8.94931 33.5162 8.94931H28.5491C28.9086 8.21513 29.106 7.3898 29.106 6.5189C29.106 3.44039 26.6149 0.949219 23.5363 0.949219C20.4578 0.949219 17.9667 3.44039 17.9667 6.5189C17.9667 7.3898 18.1641 8.21513 18.5236 8.94931H13.5565C8.04249 8.94931 3.57155 13.4354 3.57155 18.9747V22.3166L0.604424 28.104C0.305687 28.6863 0.305687 29.3799 0.604424 29.9622L3.57155 35.6838V39.0256C3.57155 44.5649 8.04249 49.0511 13.5565 49.0511H33.5162C39.0302 49.0511 43.5011 44.5649 43.5011 39.0256V35.6838L46.4024 29.942C46.691 29.3698 46.691 28.6964 46.4075 28.1192ZM20.4983 32.8483C20.4983 35.3648 18.4578 37.4053 15.9413 37.4053C13.4248 37.4053 11.3843 35.3648 11.3843 32.8483V24.747C11.3843 22.2305 13.4248 20.19 15.9413 20.19C18.4578 20.19 20.4983 22.2305 20.4983 24.747V32.8483ZM35.182 32.8483C35.182 35.3648 33.1415 37.4053 30.625 37.4053C28.1085 37.4053 26.068 35.3648 26.068 32.8483V24.747C26.068 22.2305 28.1085 20.19 30.625 20.19C33.1415 20.19 35.182 22.2305 35.182 24.747V32.8483Z"
+			fill="white"
+		/>
+	</svg>
+)
+export default ClineLogoWhite
diff --git a/apps/vscode/webview-ui/src/assets/DiscordIcon.tsx b/apps/vscode/webview-ui/src/assets/DiscordIcon.tsx
new file mode 100644
index 0000000..0584796
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/DiscordIcon.tsx
@@ -0,0 +1,7 @@
+const DiscordIcon = ({ className = "w-5 h-5" }: { className?: string }) => (
+	<svg className={className} fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+		<path d="M20.317 4.15557C18.7873 3.45369 17.147 2.93658 15.4319 2.6404C15.4007 2.63469 15.3695 2.64897 15.3534 2.67754C15.1424 3.05276 14.9087 3.54225 14.7451 3.927C12.9004 3.65083 11.0652 3.65083 9.25832 3.927C9.09465 3.5337 8.85248 3.05276 8.64057 2.67754C8.62449 2.64992 8.59328 2.63564 8.56205 2.6404C6.84791 2.93563 5.20756 3.45275 3.67693 4.15557C3.66368 4.16129 3.65233 4.17082 3.64479 4.18319C0.533392 8.83155 -0.31895 13.3657 0.0991801 17.8436C0.101072 17.8655 0.11337 17.8864 0.130398 17.8997C2.18321 19.4073 4.17171 20.3225 6.12328 20.9291C6.15451 20.9386 6.18761 20.9272 6.20748 20.9015C6.66913 20.2711 7.08064 19.6063 7.43348 18.9073C7.4543 18.8664 7.43442 18.8178 7.39186 18.8016C6.73913 18.554 6.1176 18.2521 5.51973 17.9093C5.47244 17.8816 5.46865 17.814 5.51216 17.7816C5.63797 17.6873 5.76382 17.5893 5.88396 17.4902C5.90569 17.4721 5.93598 17.4683 5.96153 17.4797C9.88928 19.273 14.1415 19.273 18.023 17.4797C18.0485 17.4674 18.0788 17.4712 18.1015 17.4893C18.2216 17.5883 18.3475 17.6873 18.4742 17.7816C18.5177 17.814 18.5149 17.8816 18.4676 17.9093C17.8697 18.2588 17.2482 18.554 16.5945 18.8006C16.552 18.8168 16.533 18.8664 16.5538 18.9073C16.9143 19.6054 17.3258 20.2701 17.7789 20.9005C17.7978 20.9272 17.8319 20.9386 17.8631 20.9291C19.8241 20.3225 21.8126 19.4073 23.8654 17.8997C23.8834 17.8864 23.8948 17.8664 23.8967 17.8445C24.3971 12.6676 23.0585 8.17064 20.3482 4.18414C20.3416 4.17082 20.3303 4.16129 20.317 4.15557ZM8.02002 15.117C6.8375 15.117 5.86313 14.0313 5.86313 12.6981C5.86313 11.3648 6.8186 10.2791 8.02002 10.2791C9.23087 10.2791 10.1958 11.3743 10.1769 12.6981C10.1769 14.0313 9.22141 15.117 8.02002 15.117ZM15.9947 15.117C14.8123 15.117 13.8379 14.0313 13.8379 12.6981C13.8379 11.3648 14.7933 10.2791 15.9947 10.2791C17.2056 10.2791 18.1705 11.3743 18.1516 12.6981C18.1516 14.0313 17.2056 15.117 15.9947 15.117Z" />
+	</svg>
+)
+
+export default DiscordIcon
diff --git a/apps/vscode/webview-ui/src/assets/GitHubIcon.tsx b/apps/vscode/webview-ui/src/assets/GitHubIcon.tsx
new file mode 100644
index 0000000..981fdb7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/GitHubIcon.tsx
@@ -0,0 +1,7 @@
+const GitHubIcon = ({ className = "w-5 h-5" }: { className?: string }) => (
+	<svg className={className} fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+		<path d="M12 2C6.477 2 2 6.477 2 12C2 16.418 4.865 20.166 8.84 21.49C9.34 21.58 9.52 21.27 9.52 21C9.52 20.77 9.51 20.14 9.51 19.31C6.73 19.91 6.14 17.97 6.14 17.97C5.68 16.81 5.03 16.5 5.03 16.5C4.12 15.88 5.1 15.9 5.1 15.9C6.1 15.97 6.63 16.93 6.63 16.93C7.5 18.45 8.97 18 9.54 17.76C9.63 17.11 9.89 16.67 10.17 16.42C7.95 16.17 5.62 15.31 5.62 11.5C5.62 10.39 6 9.5 6.65 8.79C6.55 8.54 6.2 7.5 6.75 6.15C6.75 6.15 7.59 5.88 9.5 7.17C10.29 6.95 11.15 6.84 12 6.84C12.85 6.84 13.71 6.95 14.5 7.17C16.41 5.88 17.25 6.15 17.25 6.15C17.8 7.5 17.45 8.54 17.35 8.79C18 9.5 18.38 10.39 18.38 11.5C18.38 15.32 16.04 16.16 13.81 16.41C14.17 16.72 14.5 17.33 14.5 18.26C14.5 19.6 14.49 20.68 14.49 21C14.49 21.27 14.67 21.59 15.17 21.49C19.14 20.16 22 16.42 22 12C22 6.477 17.523 2 12 2Z" />
+	</svg>
+)
+
+export default GitHubIcon
diff --git a/apps/vscode/webview-ui/src/assets/LinkedInIcon.tsx b/apps/vscode/webview-ui/src/assets/LinkedInIcon.tsx
new file mode 100644
index 0000000..82b57b7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/LinkedInIcon.tsx
@@ -0,0 +1,14 @@
+const LinkedInIcon = ({ className = "w-5 h-5" }: { className?: string }) => (
+	<svg className={className} fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+		<g clipPath="url(#clip0_2001_1428)">
+			<path d="M22.2234 0H1.77187C0.792187 0 0 0.773438 0 1.72969V22.2656C0 23.2219 0.792187 24 1.77187 24H22.2234C23.2031 24 24 23.2219 24 22.2703V1.72969C24 0.773438 23.2031 0 22.2234 0ZM7.12031 20.4516H3.55781V8.99531H7.12031V20.4516ZM5.33906 7.43438C4.19531 7.43438 3.27188 6.51094 3.27188 5.37187C3.27188 4.23281 4.19531 3.30937 5.33906 3.30937C6.47813 3.30937 7.40156 4.23281 7.40156 5.37187C7.40156 6.50625 6.47813 7.43438 5.33906 7.43438ZM20.4516 20.4516H16.8937V14.8828C16.8937 13.5562 16.8703 11.8453 15.0422 11.8453C13.1906 11.8453 12.9094 13.2937 12.9094 14.7891V20.4516H9.35625V8.99531H12.7687V10.5609H12.8156C13.2891 9.66094 14.4516 8.70938 16.1813 8.70938C19.7859 8.70938 20.4516 11.0813 20.4516 14.1656V20.4516Z" />
+		</g>
+		<defs>
+			<clipPath id="clip0_2001_1428">
+				<rect fill="white" height="24" width="24" />
+			</clipPath>
+		</defs>
+	</svg>
+)
+
+export default LinkedInIcon
diff --git a/apps/vscode/webview-ui/src/assets/RedditIcon.tsx b/apps/vscode/webview-ui/src/assets/RedditIcon.tsx
new file mode 100644
index 0000000..5ae3f61
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/RedditIcon.tsx
@@ -0,0 +1,7 @@
+const RedditIcon = ({ className = "w-5 h-5" }: { className?: string }) => (
+	<svg className={className} fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+		<path d="M15.0512 4.07466C15.3113 5.17727 16.301 5.99866 17.4829 5.99866C18.8627 5.99866 19.9813 4.87965 19.9813 3.49933C19.9813 2.11902 18.8627 1 17.4829 1C16.2764 1 15.2703 1.85537 15.036 2.99314C13.0155 3.20991 11.4378 4.92417 11.4378 7.00167C11.4378 7.00636 11.4378 7.00988 11.4378 7.01456C9.24041 7.10713 7.23397 7.73284 5.641 8.72062C5.04949 8.26247 4.30688 7.98945 3.50102 7.98945C1.5672 7.98945 0 9.55725 0 11.4918C0 12.8955 0.824597 14.1048 2.01581 14.6637C2.13177 18.7297 6.56047 22 12.0082 22C17.4559 22 21.8905 18.7261 22.0006 14.6567C23.1824 14.0942 24 12.8885 24 11.493C24 9.55842 22.4328 7.99063 20.499 7.99063C19.6966 7.99063 18.9575 8.2613 18.3672 8.71594C16.7602 7.72113 14.7315 7.09541 12.5119 7.01222C12.5119 7.0087 12.5119 7.00636 12.5119 7.00285C12.5119 5.51473 13.6176 4.27971 15.0512 4.077V4.07466ZM5.50044 13.7146C5.559 12.4444 6.40234 11.4695 7.38272 11.4695C8.3631 11.4695 9.11274 12.4995 9.05417 13.7697C8.99561 15.0398 8.26354 15.5015 7.28199 15.5015C6.30044 15.5015 5.44187 14.9848 5.50044 13.7146ZM16.6348 11.4695C17.6164 11.4695 18.4597 12.4444 18.5171 13.7146C18.5757 14.9848 17.716 15.5015 16.7356 15.5015C15.7552 15.5015 15.022 15.041 14.9634 13.7697C14.9048 12.4995 15.6533 11.4695 16.6348 11.4695ZM15.4682 16.6533C15.6521 16.6721 15.7693 16.8631 15.6978 17.0341C15.0946 18.4766 13.6703 19.4901 12.0082 19.4901C10.3461 19.4901 8.92299 18.4766 8.31859 17.0341C8.24714 16.8631 8.36427 16.6721 8.54817 16.6533C9.62577 16.5444 10.7912 16.4846 12.0082 16.4846C13.2252 16.4846 14.3895 16.5444 15.4682 16.6533Z" />
+	</svg>
+)
+
+export default RedditIcon
diff --git a/apps/vscode/webview-ui/src/assets/XIcon.tsx b/apps/vscode/webview-ui/src/assets/XIcon.tsx
new file mode 100644
index 0000000..4135ad6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/assets/XIcon.tsx
@@ -0,0 +1,7 @@
+const XIcon = ({ className = "w-5 h-5" }: { className?: string }) => (
+	<svg className={className} fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+		<path d="M18.3263 1.90393H21.6998L14.3297 10.3274L23 21.7899H16.2112L10.894 14.838L4.80995 21.7899H1.43443L9.31743 12.78L1 1.90393H7.96111L12.7674 8.25826L18.3263 1.90393ZM17.1423 19.7707H19.0116L6.94539 3.81706H4.93946L17.1423 19.7707Z" />
+	</svg>
+)
+
+export default XIcon
diff --git a/apps/vscode/webview-ui/src/components/account/AccountView.tsx b/apps/vscode/webview-ui/src/components/account/AccountView.tsx
new file mode 100644
index 0000000..f1bd4f4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/AccountView.tsx
@@ -0,0 +1,417 @@
+import type { UsageTransaction as ClineAccountUsageTransaction, PaymentTransaction } from "@shared/ClineAccount"
+import { isClineInternalTester } from "@shared/internal/account"
+import type { UserOrganization } from "@shared/proto/cline/account"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { VSCodeButton, VSCodeDivider, VSCodeDropdown, VSCodeOption, VSCodeTag } from "@vscode/webview-ui-toolkit/react"
+import deepEqual from "fast-deep-equal"
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useInterval } from "react-use"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { type ClineUser, handleSignOut } from "@/context/ClineAuthContext"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { AccountServiceClient } from "@/services/grpc-client"
+import ViewHeader from "../common/ViewHeader"
+import VSCodeButtonLink from "../common/VSCodeButtonLink"
+import { updateSetting } from "../settings/utils/settingsHandlers"
+import { AccountWelcomeView } from "./AccountWelcomeView"
+import { CreditBalance } from "./CreditBalance"
+import CreditsHistoryTable from "./CreditsHistoryTable"
+import { convertProtoUsageTransactions, getClineUris, getMainRole } from "./helpers"
+import { RemoteConfigToggle } from "./RemoteConfigToggle"
+
+type AccountViewProps = {
+	clineUser: ClineUser | null
+	organizations: UserOrganization[] | null
+	activeOrganization: UserOrganization | null
+	onDone: () => void
+}
+
+type ClineAccountViewProps = {
+	clineUser: ClineUser
+	userOrganizations: UserOrganization[] | null
+	activeOrganization: UserOrganization | null
+	clineEnv: "Production" | "Staging" | "Local"
+}
+
+type CachedData = {
+	balance: number | null
+	usageData: ClineAccountUsageTransaction[]
+	paymentsData: PaymentTransaction[]
+	lastFetchTime: number
+}
+
+const ClineEnvOptions = ["Production", "Staging", "Local"] as const
+
+const AccountView = ({ onDone, clineUser, organizations, activeOrganization }: AccountViewProps) => {
+	const { environment } = useExtensionState()
+
+	return (
+		<div className="fixed inset-0 flex flex-col overflow-hidden">
+			<ViewHeader environment={environment} onDone={onDone} showEnvironmentSuffix title="Account" />
+			<div className="grow flex flex-col px-5 overflow-y-auto">
+				{clineUser?.uid ? (
+					<ClineAccountView
+						activeOrganization={activeOrganization}
+						clineEnv={environment === "local" ? "Local" : environment === "staging" ? "Staging" : "Production"}
+						clineUser={clineUser}
+						key={clineUser.uid}
+						userOrganizations={organizations}
+					/>
+				) : (
+					<AccountWelcomeView />
+				)}
+			</div>
+		</div>
+	)
+}
+
+const ClineAccountView = ({ clineUser, userOrganizations, activeOrganization, clineEnv }: ClineAccountViewProps) => {
+	const { email, displayName, appBaseUrl, uid } = clineUser
+	const { remoteConfigSettings, environment } = useExtensionState()
+
+	// Determine if dropdown should be locked by remote config
+	const isLockedByRemoteConfig = Object.keys(remoteConfigSettings || {}).length > 0
+
+	// Source of truth: Dedicated state for dropdown value that persists through failures
+	// and represents that user's current selection.
+	const [dropdownValue, setDropdownValue] = useState<string>(activeOrganization?.organizationId || uid)
+	const [isLoading, setIsLoading] = useState(false)
+
+	// Cache data per organization/user ID to avoid showing empty state when switching
+	const dataCache = useRef<Map<string, CachedData>>(new Map())
+
+	// Current displayed data
+	const [balance, setBalance] = useState<number | null>(null)
+	const [usageData, setUsageData] = useState<ClineAccountUsageTransaction[]>([])
+	const [paymentsData, setPaymentsData] = useState<PaymentTransaction[]>([])
+	const [lastFetchTime, setLastFetchTime] = useState<number>(Date.now())
+
+	// Load cached data for current dropdown value
+	const loadCachedData = useCallback((id: string) => {
+		const cached = dataCache.current.get(id)
+		if (cached) {
+			setBalance(cached.balance)
+			setUsageData(cached.usageData)
+			setPaymentsData(cached.paymentsData)
+			setLastFetchTime(cached.lastFetchTime)
+			return true
+		}
+		return false
+	}, [])
+
+	// Simple cache function without dependencies
+	const cacheCurrentData = useCallback(
+		(id: string) => {
+			dataCache.current.set(id, {
+				balance,
+				usageData,
+				paymentsData,
+				lastFetchTime,
+			})
+		},
+		[balance, usageData, paymentsData, lastFetchTime],
+	)
+	// Track the active organization ID to detect changes
+	const [lastActiveOrgId, setLastActiveOrgId] = useState<string | undefined>(activeOrganization?.organizationId)
+	// Use ref for debounce timeout to avoid re-renders
+	const debounceTimeoutRef = useRef<NodeJS.Timeout | null>(null)
+	// Track if manual fetch is in progress to avoid duplicate fetches
+	const manualFetchInProgressRef = useRef<boolean>(false)
+	// Track if initial mount fetch has completed to avoid duplicate fetches
+	const initialFetchCompleteRef = useRef<boolean>(false)
+
+	const isClineTester = useMemo(() => (email ? isClineInternalTester(email) : false), [email])
+
+	const fetchUserCredit = useCallback(async () => {
+		try {
+			const response = await AccountServiceClient.getUserCredits(EmptyRequest.create())
+			const newBalance = response?.balance?.currentBalance
+			// Always update balance, even if it's 0 or null - don't skip undefined
+			setBalance(newBalance ?? null)
+			const newUsage = convertProtoUsageTransactions(response.usageTransactions)
+			setUsageData((prev) => (deepEqual(newUsage, prev) ? prev : newUsage))
+			const newPaymentsData = response.paymentTransactions
+			setPaymentsData((prev) => (deepEqual(newPaymentsData, prev) ? prev : newPaymentsData))
+		} catch (error) {
+			console.error("Failed to fetch user credit:", error)
+		}
+	}, [])
+
+	const fetchCreditBalance = useCallback(
+		async (id: string, skipCache = false) => {
+			try {
+				if (isLoading) {
+					return // Prevent multiple concurrent fetches
+				}
+
+				// Load cached data immediately if available (unless skipping cache)
+				if (!skipCache && loadCachedData(id)) {
+					// If we have cached data, show it first, then fetch in background
+				}
+
+				setIsLoading(true)
+				if (id === uid) {
+					await fetchUserCredit()
+				} else {
+					const response = await AccountServiceClient.getOrganizationCredits({
+						organizationId: id,
+					})
+					// Update balance - handle all values including 0 and null
+					const newBalance = response.balance?.currentBalance
+					setBalance(newBalance ?? null)
+
+					const newUsage = convertProtoUsageTransactions(response.usageTransactions)
+					setUsageData((prev) => (deepEqual(newUsage, prev) ? prev : newUsage))
+				}
+
+				// Cache the updated data
+				cacheCurrentData(id)
+			} catch (error) {
+				console.error("Failed to fetch credit balance:", error)
+			} finally {
+				setLastFetchTime(Date.now())
+				setIsLoading(false)
+			}
+		},
+		[isLoading, uid, fetchUserCredit, loadCachedData],
+	)
+
+	const handleOrganizationChange = useCallback(
+		async (event: any) => {
+			const target = event.target as HTMLSelectElement
+			if (!target) {
+				return
+			}
+
+			const newValue = target.value
+			if (newValue !== dropdownValue) {
+				// Clear any pending debounced fetch since we're doing a manual one
+				if (debounceTimeoutRef.current) {
+					clearTimeout(debounceTimeoutRef.current)
+					debounceTimeoutRef.current = null
+				}
+
+				// Cache current data before switching
+				cacheCurrentData(dropdownValue)
+				setDropdownValue(newValue)
+
+				// Load cached data for new selection immediately, or clear if no cache
+				// Only clear if we don't have cached data to avoid unnecessary flashing
+				if (!loadCachedData(newValue)) {
+					// No cached data - clear current state to avoid showing wrong data
+					setBalance(null)
+					setUsageData([])
+					setPaymentsData([])
+				}
+
+				// Set flag to indicate manual fetch in progress
+				manualFetchInProgressRef.current = true
+
+				// Fetch the new data
+				await fetchCreditBalance(newValue)
+
+				// Update the last active org ID to prevent the effect from triggering
+				setLastActiveOrgId(newValue === uid ? undefined : newValue)
+
+				// Send the change to the server
+				const organizationId = newValue === uid ? undefined : newValue
+				await AccountServiceClient.setUserOrganization({ organizationId })
+
+				// Clear the manual fetch flag after everything is done
+				manualFetchInProgressRef.current = false
+			}
+		},
+		[uid, dropdownValue, loadCachedData, fetchCreditBalance, cacheCurrentData],
+	)
+
+	// Fetch balance every 60 seconds
+	useInterval(() => {
+		fetchCreditBalance(dropdownValue)
+	}, 60000)
+
+	const clineUrl = appBaseUrl || "https://app.cline.bot"
+
+	// Fetch balance on mount
+	useEffect(() => {
+		async function initialFetch() {
+			await fetchCreditBalance(dropdownValue)
+			initialFetchCompleteRef.current = true
+		}
+		initialFetch()
+	}, [])
+
+	useEffect(() => {
+		// Handle organization changes with 500ms debounce
+		const currentActiveOrgId = activeOrganization?.organizationId
+		const hasActiveOrgChanged = currentActiveOrgId !== lastActiveOrgId
+
+		// Only handle external organization changes (not dropdown changes)
+		// Dropdown changes are handled by handleOrganizationChange
+		const isExternalOrgChange = hasActiveOrgChanged && !manualFetchInProgressRef.current
+
+		if (isExternalOrgChange) {
+			// Clear any existing timeout
+			if (debounceTimeoutRef.current) {
+				clearTimeout(debounceTimeoutRef.current)
+			}
+
+			// Update dropdown to match the new active organization
+			const newDropdownValue = currentActiveOrgId || uid
+			if (newDropdownValue !== dropdownValue) {
+				// Cache current data before switching
+				cacheCurrentData(dropdownValue)
+				setDropdownValue(newDropdownValue)
+
+				// Load cached data for new selection immediately, or clear if no cache
+				// Only clear data if initial fetch has completed to avoid clearing on mount
+				if (!loadCachedData(newDropdownValue) && initialFetchCompleteRef.current) {
+					// No cached data - clear to avoid showing wrong data
+					setBalance(null)
+					setUsageData([])
+					setPaymentsData([])
+				}
+			}
+
+			// Only set timeout if initial fetch is complete
+			if (initialFetchCompleteRef.current) {
+				// Set new timeout to fetch after 500ms
+				debounceTimeoutRef.current = setTimeout(() => {
+					fetchCreditBalance(newDropdownValue)
+					setLastActiveOrgId(currentActiveOrgId)
+				}, 500)
+			} else {
+				// Just update the active org ID
+				setLastActiveOrgId(currentActiveOrgId)
+			}
+		}
+
+		// Cleanup timeout on unmount
+		return () => {
+			if (debounceTimeoutRef.current) {
+				clearTimeout(debounceTimeoutRef.current)
+			}
+		}
+	}, [
+		activeOrganization?.organizationId,
+		lastActiveOrgId,
+		uid,
+		dropdownValue,
+		loadCachedData,
+		fetchCreditBalance,
+		cacheCurrentData,
+	])
+
+	return (
+		<div className="h-full flex flex-col">
+			<div className="flex flex-col h-full">
+				<div className="flex flex-col w-full gap-1 mb-6">
+					<div className="flex items-center flex-wrap gap-y-4">
+						{/* {user.photoUrl ? (
+								<img src={user.photoUrl} alt="Profile" className="size-16 rounded-full mr-4" />
+							) : ( */}
+						<div className="size-16 rounded-full bg-button-background flex items-center justify-center text-2xl text-button-foreground mr-4">
+							{displayName?.[0] || email?.[0] || "?"}
+						</div>
+						{/* )} */}
+
+						<div className="flex flex-col">
+							{displayName && <h2 className="text-foreground m-0 text-lg font-medium">{displayName}</h2>}
+
+							{email && <div className="text-sm text-description">{email}</div>}
+
+							<div className="flex gap-2 items-center mt-1">
+								<Tooltip>
+									<TooltipTrigger>
+										<VSCodeDropdown
+											className="w-full"
+											currentValue={dropdownValue}
+											disabled={isLoading || isLockedByRemoteConfig}
+											onChange={handleOrganizationChange}>
+											<VSCodeOption key="personal" value={uid}>
+												Personal
+											</VSCodeOption>
+											{userOrganizations?.map((org: UserOrganization) => (
+												<VSCodeOption key={org.organizationId} value={org.organizationId}>
+													{org.name}
+												</VSCodeOption>
+											))}
+										</VSCodeDropdown>
+									</TooltipTrigger>
+									<TooltipContent hidden={!isLockedByRemoteConfig}>
+										This cannot be changed while your organization has remote configuration enabled.
+									</TooltipContent>
+								</Tooltip>
+								{activeOrganization && (
+									<VSCodeTag className="text-xs p-2" title="Role">
+										{getMainRole(activeOrganization.roles)}
+									</VSCodeTag>
+								)}
+							</div>
+						</div>
+					</div>
+					<div className="w-full flex gap-2 flex-col min-[225px]:flex-row">
+						<RemoteConfigToggle activeOrganization={activeOrganization} />
+					</div>
+				</div>
+
+				<div className="w-full flex gap-2 flex-col min-[225px]:flex-row">
+					<div className="w-full min-[225px]:w-1/2">
+						<VSCodeButtonLink appearance="primary" className="w-full" href={getClineUris(clineUrl, "dashboard").href}>
+							Dashboard
+						</VSCodeButtonLink>
+					</div>
+					<VSCodeButton appearance="secondary" className="w-full min-[225px]:w-1/2" onClick={() => handleSignOut()}>
+						Log out
+					</VSCodeButton>
+				</div>
+
+				<VSCodeDivider className="w-full my-6" />
+
+				<CreditBalance
+					balance={balance}
+					creditUrl={getClineUris(clineUrl, "credits", dropdownValue === uid ? "account" : "organization")}
+					fetchCreditBalance={() => fetchCreditBalance(dropdownValue)}
+					isLoading={isLoading}
+					lastFetchTime={lastFetchTime}
+				/>
+
+				<VSCodeDivider className="mt-6 mb-3 w-full" />
+
+				<div className="grow flex flex-col min-h-0 pb-[0px]">
+					<CreditsHistoryTable
+						isLoading={isLoading}
+						paymentsData={paymentsData}
+						showPayments={dropdownValue === uid}
+						usageData={usageData}
+					/>
+				</div>
+
+				{/* Hide environment switching UI when in self-hosted mode */}
+				{isClineTester && environment !== "selfHosted" && (
+					<div className="w-full gap-1 items-end">
+						<VSCodeDivider className="w-full my-3" />
+						<div className="text-sm font-semibold">Cline Environment</div>
+						<VSCodeDropdown
+							className="w-full mt-1"
+							currentValue={clineEnv}
+							onChange={async (e) => {
+								const target = e.target as HTMLSelectElement
+								if (target?.value) {
+									const value = target.value as "Local" | "Staging" | "Production"
+									updateSetting("clineEnv", value.toLowerCase())
+								}
+							}}>
+							{ClineEnvOptions.map((env) => (
+								<VSCodeOption key={env} value={env}>
+									{env}
+								</VSCodeOption>
+							))}
+						</VSCodeDropdown>
+					</div>
+				)}
+			</div>
+		</div>
+	)
+}
+
+export default memo(AccountView)
diff --git a/apps/vscode/webview-ui/src/components/account/AccountWelcomeView.tsx b/apps/vscode/webview-ui/src/components/account/AccountWelcomeView.tsx
new file mode 100644
index 0000000..69a610a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/AccountWelcomeView.tsx
@@ -0,0 +1,40 @@
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { ClineAuthStatus } from "@/components/account/ClineAuthStatus"
+import { useClineSignIn } from "@/context/ClineAuthContext"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import ClineLogoVariable from "../../assets/ClineLogoVariable"
+
+// export const AccountWelcomeView = () => (
+// 	<div className="flex flex-col items-center pr-3 gap-2.5">
+// 		<ClineLogoWhite className="size-16 mb-4" />
+export const AccountWelcomeView = () => {
+	const { environment } = useExtensionState()
+	const { isLoginLoading, authStatusMessage, handleSignIn } = useClineSignIn()
+
+	return (
+		<div className="flex flex-col items-center gap-2.5">
+			<ClineLogoVariable className="size-16 mb-4" environment={environment} />
+
+			<p>
+				Sign up for an account to get access to the latest models, billing dashboard to view usage and credits, and more
+				upcoming features.
+			</p>
+
+			<VSCodeButton className="w-full mb-4" disabled={isLoginLoading} onClick={handleSignIn}>
+				Sign up with Cline
+				{isLoginLoading && (
+					<span className="ml-1 animate-spin">
+						<span className="codicon codicon-refresh" />
+					</span>
+				)}
+			</VSCodeButton>
+
+			<ClineAuthStatus message={authStatusMessage} />
+
+			<p className="text-(--vscode-descriptionForeground) text-xs text-center m-0">
+				By continuing, you agree to the <VSCodeLink href="https://cline.bot/tos">Terms of Service</VSCodeLink> and{" "}
+				<VSCodeLink href="https://cline.bot/privacy">Privacy Policy.</VSCodeLink>
+			</p>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/account/ClineAuthStatus.tsx b/apps/vscode/webview-ui/src/components/account/ClineAuthStatus.tsx
new file mode 100644
index 0000000..267a82b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/ClineAuthStatus.tsx
@@ -0,0 +1,55 @@
+import { useState } from "react"
+import { Button } from "@/components/ui/button"
+
+interface ClineAuthStatusProps {
+	message: string | null
+}
+
+export const ClineAuthStatus = ({ message }: ClineAuthStatusProps) => {
+	const [didCopy, setDidCopy] = useState(false)
+
+	if (!message) {
+		return null
+	}
+
+	const codeMatch = message.match(/(?:code(?:\s+in\s+your\s+browser)?\s*:?\s*)([A-Z0-9-]{4,})/i)
+	const authCode = codeMatch?.[1]
+	const displayMessage = authCode ? "Enter this code in your browser:" : message
+
+	const handleCopy = async () => {
+		if (!authCode) {
+			return
+		}
+
+		try {
+			await navigator.clipboard.writeText(authCode)
+		} catch {
+			const textArea = document.createElement("textarea")
+			textArea.value = authCode
+			textArea.style.position = "fixed"
+			textArea.style.opacity = "0"
+			document.body.appendChild(textArea)
+			textArea.focus()
+			textArea.select()
+			document.execCommand("copy")
+			document.body.removeChild(textArea)
+		}
+
+		setDidCopy(true)
+		window.setTimeout(() => setDidCopy(false), 1_500)
+	}
+
+	return (
+		<div className="rounded border border-neutral-500/30 bg-vscode-editor-background p-3 text-vscode-foreground">
+			<div className="text-sm">{displayMessage}</div>
+			{authCode ? (
+				<div className="mt-2 flex items-center gap-2">
+					<div className="font-mono text-2xl font-semibold tracking-wider">{authCode}</div>
+					<Button aria-label="Copy Cline sign-in code" onClick={handleCopy} size="sm" variant="secondary">
+						{didCopy ? "Copied" : "Copy"}
+					</Button>
+				</div>
+			) : null}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/account/CreditBalance.tsx b/apps/vscode/webview-ui/src/components/account/CreditBalance.tsx
new file mode 100644
index 0000000..613e0dc
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/CreditBalance.tsx
@@ -0,0 +1,38 @@
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import VSCodeButtonLink from "../common/VSCodeButtonLink"
+import { StyledCreditDisplay } from "./StyledCreditDisplay"
+
+type CreditBalanceProps = {
+	balance: number | null
+	fetchCreditBalance: () => void
+	creditUrl: URL
+	lastFetchTime: number
+	isLoading: boolean
+}
+
+export const CreditBalance = ({ balance, fetchCreditBalance, creditUrl, lastFetchTime, isLoading }: CreditBalanceProps) => {
+	return (
+		<div
+			className="w-full flex flex-col items-center"
+			title={`Last updated: ${new Date(lastFetchTime).toLocaleTimeString()}`}>
+			<div className="text-sm text-(--vscode-descriptionForeground) mb-3 font-azeret-mono font-light">CURRENT BALANCE</div>
+
+			<div className="font-bold text-2xl mb-6 flex items-center gap-2">
+				{balance === null ? <span>----</span> : <StyledCreditDisplay balance={balance} />}
+				<VSCodeButton
+					appearance="icon"
+					className={`mt-1 ${isLoading ? "animate-spin" : ""}`}
+					disabled={isLoading}
+					onClick={fetchCreditBalance}>
+					<span className="codicon codicon-refresh"></span>
+				</VSCodeButton>
+			</div>
+
+			<div className="w-full">
+				<VSCodeButtonLink className="w-full" href={creditUrl.href}>
+					Add Credits
+				</VSCodeButtonLink>
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/account/CreditsHistoryTable.tsx b/apps/vscode/webview-ui/src/components/account/CreditsHistoryTable.tsx
new file mode 100644
index 0000000..780168c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/CreditsHistoryTable.tsx
@@ -0,0 +1,120 @@
+import type { PaymentTransaction, UsageTransaction } from "@shared/ClineAccount"
+import { VSCodeDataGrid, VSCodeDataGridCell, VSCodeDataGridRow } from "@vscode/webview-ui-toolkit/react"
+import { memo, useState } from "react"
+import { formatDollars, formatTimestamp } from "@/utils/format"
+import { TabButton } from "../mcp/configuration/McpConfigurationView"
+
+interface CreditsHistoryTableProps {
+	isLoading: boolean
+	usageData: UsageTransaction[]
+	paymentsData: PaymentTransaction[]
+	showPayments?: boolean
+}
+
+const CreditsHistoryTable = memo(({ isLoading, usageData, paymentsData, showPayments }: CreditsHistoryTableProps) => {
+	const [activeTab, setActiveTab] = useState<"usage" | "payments">("usage")
+
+	return (
+		<div className="flex flex-col grow h-full">
+			{/* Tabs container */}
+			<div className="flex border-b border-(--vscode-panel-border)">
+				<TabButton isActive={activeTab === "usage"} onClick={() => setActiveTab("usage")}>
+					USAGE HISTORY
+				</TabButton>
+				{showPayments && (
+					<TabButton isActive={activeTab === "payments"} onClick={() => setActiveTab("payments")}>
+						PAYMENTS HISTORY
+					</TabButton>
+				)}
+			</div>
+
+			{/* Content container */}
+			<div className="mt-[15px] mb-[0px] rounded-md overflow-auto grow">
+				{isLoading ? (
+					<div className="flex justify-center items-center p-4">
+						<div className="text-(--vscode-descriptionForeground)">Loading...</div>
+					</div>
+				) : (
+					<>
+						{activeTab === "usage" &&
+							(usageData.length > 0 ? (
+								<VSCodeDataGrid>
+									<VSCodeDataGridRow row-type="header">
+										<VSCodeDataGridCell cell-type="columnheader" grid-column="1">
+											Date
+										</VSCodeDataGridCell>
+										<VSCodeDataGridCell cell-type="columnheader" grid-column="2">
+											Model
+										</VSCodeDataGridCell>
+										{/* <VSCodeDataGridCell cell-type="columnheader" grid-column="3">
+												Tokens Used
+											</VSCodeDataGridCell> */}
+										<VSCodeDataGridCell cell-type="columnheader" grid-column="3">
+											Credits Used
+										</VSCodeDataGridCell>
+									</VSCodeDataGridRow>
+
+									{usageData.map((row, index) => (
+										// biome-ignore lint/suspicious/noArrayIndexKey: use index as key
+										<VSCodeDataGridRow key={index}>
+											<VSCodeDataGridCell grid-column="1">
+												{formatTimestamp(row.createdAt)}
+											</VSCodeDataGridCell>
+											<VSCodeDataGridCell grid-column="2">
+												{row.operation === "web_search"
+													? "Web Search"
+													: row.operation === "web_fetch"
+														? "Web Fetch"
+														: row.operation === "search_chat_completion"
+															? "Web Fetch (LLM)"
+															: row.aiModelName}
+											</VSCodeDataGridCell>
+											{/* <VSCodeDataGridCell grid-column="3">{`${row.promptTokens} → ${row.completionTokens}`}</VSCodeDataGridCell> */}
+											<VSCodeDataGridCell grid-column="3">{`$${Number(row.creditsUsed / 1000000).toFixed(4)}`}</VSCodeDataGridCell>
+										</VSCodeDataGridRow>
+									))}
+								</VSCodeDataGrid>
+							) : (
+								<div className="flex justify-center items-center p-4">
+									<div className="text-(--vscode-descriptionForeground)">No usage history</div>
+								</div>
+							))}
+
+						{showPayments &&
+							activeTab === "payments" &&
+							(paymentsData.length > 0 ? (
+								<VSCodeDataGrid>
+									<VSCodeDataGridRow row-type="header">
+										<VSCodeDataGridCell cell-type="columnheader" grid-column="1">
+											Date
+										</VSCodeDataGridCell>
+										<VSCodeDataGridCell cell-type="columnheader" grid-column="2">
+											Total Cost
+										</VSCodeDataGridCell>
+										<VSCodeDataGridCell cell-type="columnheader" grid-column="3">
+											Credits
+										</VSCodeDataGridCell>
+									</VSCodeDataGridRow>
+
+									{paymentsData.map((row, index) => (
+										// biome-ignore lint/suspicious/noArrayIndexKey: use index as key
+										<VSCodeDataGridRow key={index}>
+											<VSCodeDataGridCell grid-column="1">{formatTimestamp(row.paidAt)}</VSCodeDataGridCell>
+											<VSCodeDataGridCell grid-column="2">{`$${formatDollars(row.amountCents)}`}</VSCodeDataGridCell>
+											<VSCodeDataGridCell grid-column="3">{`${row.credits}`}</VSCodeDataGridCell>
+										</VSCodeDataGridRow>
+									))}
+								</VSCodeDataGrid>
+							) : (
+								<div className="flex justify-center items-center p-4">
+									<div className="text-(--vscode-descriptionForeground)">No payment history</div>
+								</div>
+							))}
+					</>
+				)}
+			</div>
+		</div>
+	)
+})
+
+export default CreditsHistoryTable
diff --git a/apps/vscode/webview-ui/src/components/account/RemoteConfigToggle.tsx b/apps/vscode/webview-ui/src/components/account/RemoteConfigToggle.tsx
new file mode 100644
index 0000000..aa1132f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/RemoteConfigToggle.tsx
@@ -0,0 +1,36 @@
+import { UpdateSettingsRequest, UserOrganization } from "@shared/proto/index.cline"
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { useRef } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { StateServiceClient } from "@/services/grpc-client"
+import { isAdminOrOwner } from "./helpers"
+
+export function RemoteConfigToggle({ activeOrganization }: { activeOrganization: UserOrganization | null }) {
+	const { optOutOfRemoteConfig } = useExtensionState()
+	const hadOptedOutOfRemoteConfig = useRef(optOutOfRemoteConfig)
+
+	// If there is no active org but the user had already opted out, keep displaying the toggle
+	if (!hadOptedOutOfRemoteConfig.current && activeOrganization && !isAdminOrOwner(activeOrganization)) {
+		return null
+	}
+
+	const onUpdateToggle = async (value: boolean) => {
+		await StateServiceClient.updateSettings(
+			UpdateSettingsRequest.create({
+				optOutOfRemoteConfig: value,
+			}),
+		)
+	}
+
+	return (
+		<VSCodeCheckbox
+			checked={optOutOfRemoteConfig}
+			onChange={(e: any) => {
+				const isChecked = e.target.checked === true
+
+				onUpdateToggle(isChecked)
+			}}>
+			Opt out of remote config
+		</VSCodeCheckbox>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/account/StyledCreditDisplay.tsx b/apps/vscode/webview-ui/src/components/account/StyledCreditDisplay.tsx
new file mode 100644
index 0000000..d610643
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/StyledCreditDisplay.tsx
@@ -0,0 +1,60 @@
+import { useEffect, useRef, useState } from "react"
+import { formatCreditsBalance } from "@/utils/format"
+
+// Custom hook for animated credit display with styled decimals
+const useAnimatedCredits = (targetValue: number, duration: number = 660) => {
+	const [currentValue, setCurrentValue] = useState(0)
+	const animationRef = useRef<number>()
+	const startTimeRef = useRef<number>()
+
+	useEffect(() => {
+		const animate = (timestamp: number) => {
+			if (!startTimeRef.current) {
+				startTimeRef.current = timestamp
+			}
+
+			const elapsed = timestamp - startTimeRef.current
+			const progress = Math.min(elapsed / duration, 1)
+
+			// Easing function (ease-out)
+			const easedProgress = 1 - (1 - progress) ** 3
+			const newValue = easedProgress * targetValue
+
+			setCurrentValue(newValue)
+
+			if (progress < 1) {
+				animationRef.current = requestAnimationFrame(animate)
+			}
+		}
+
+		// Reset and start animation
+		startTimeRef.current = undefined
+		animationRef.current = requestAnimationFrame(animate)
+
+		return () => {
+			if (animationRef.current) {
+				cancelAnimationFrame(animationRef.current)
+			}
+		}
+	}, [targetValue, duration])
+
+	return currentValue
+}
+
+// Custom component to handle styled credit display
+export const StyledCreditDisplay = ({ balance }: { balance: number }) => {
+	const animatedValue = useAnimatedCredits(formatCreditsBalance(balance))
+	const formatted = animatedValue.toFixed(4)
+	const parts = formatted.split(".")
+	const wholePart = parts[0]
+	const decimalPart = parts[1] || "0000"
+	const firstTwoDecimals = decimalPart.slice(0, 2)
+	const lastTwoDecimals = decimalPart.slice(2)
+
+	return (
+		<span className="font-azeret-mono font-light tabular-nums text-2xl">
+			{wholePart}.{firstTwoDecimals}
+			<span className="text-description text-2xl">{lastTwoDecimals}</span>
+		</span>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/account/helpers.ts b/apps/vscode/webview-ui/src/components/account/helpers.ts
new file mode 100644
index 0000000..58ad502
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/account/helpers.ts
@@ -0,0 +1,57 @@
+import type { UsageTransaction as ClineAccountUsageTransaction } from "@shared/ClineAccount"
+import type { UsageTransaction as ProtoUsageTransaction, UserOrganization } from "@shared/proto/cline/account"
+
+export const getMainRole = (roles?: string[]) => {
+	if (!roles) {
+		return undefined
+	}
+
+	if (roles.includes("owner")) {
+		return "Owner"
+	}
+	if (roles.includes("admin")) {
+		return "Admin"
+	}
+
+	return "Member"
+}
+
+export const getClineUris = (base: string, type: "dashboard" | "credits", route?: "account" | "organization") => {
+	const dashboard = new URL("dashboard", base)
+
+	if (type === "dashboard") {
+		return dashboard
+	}
+
+	const credits = new URL("/" + (route ?? "account"), dashboard)
+	credits.searchParams.set("tab", "credits")
+	credits.searchParams.set("redirect", "true")
+	return credits
+}
+
+/**
+ * Converts a protobuf UsageTransaction to a ClineAccount UsageTransaction
+ * by adding the missing id and metadata fields
+ */
+function convertProtoUsageTransaction(protoTransaction: ProtoUsageTransaction): ClineAccountUsageTransaction {
+	return {
+		...protoTransaction,
+		id: protoTransaction.generationId, // Use generationId as the id
+		metadata: {
+			additionalProp1: "",
+			additionalProp2: "",
+			additionalProp3: "",
+		},
+	}
+}
+
+/**
+ * Converts an array of protobuf UsageTransactions to ClineAccount UsageTransactions
+ */
+export function convertProtoUsageTransactions(protoTransactions: ProtoUsageTransaction[]): ClineAccountUsageTransaction[] {
+	return protoTransactions.map(convertProtoUsageTransaction)
+}
+
+export const isAdminOrOwner = (activeOrg: UserOrganization): boolean => {
+	return activeOrg.roles.findIndex((role) => role === "admin" || role === "owner") > -1
+}
diff --git a/apps/vscode/webview-ui/src/components/browser/BrowserSettingsMenu.tsx b/apps/vscode/webview-ui/src/components/browser/BrowserSettingsMenu.tsx
new file mode 100644
index 0000000..32058db
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/browser/BrowserSettingsMenu.tsx
@@ -0,0 +1,196 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import { useEffect, useRef, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { BrowserServiceClient } from "../../services/grpc-client"
+
+interface ConnectionInfo {
+	isConnected: boolean
+	isRemote: boolean
+	host?: string
+}
+
+export const BrowserSettingsMenu = () => {
+	const { browserSettings } = useExtensionState()
+	const containerRef = useRef<HTMLDivElement>(null)
+	const [showInfoPopover, setShowInfoPopover] = useState(false)
+	const [connectionInfo, setConnectionInfo] = useState<ConnectionInfo>({
+		isConnected: false,
+		isRemote: !!browserSettings.remoteBrowserEnabled,
+		host: browserSettings.remoteBrowserHost,
+	})
+	const popoverRef = useRef<HTMLDivElement>(null)
+
+	// Get actual connection info from the browser session using gRPC
+	useEffect(() => {
+		// Function to fetch connection info
+		;(async () => {
+			try {
+				console.log("[DEBUG] SENDING BROWSER CONNECTION INFO REQUEST")
+				const info = await BrowserServiceClient.getBrowserConnectionInfo(EmptyRequest.create({}))
+				console.log("[DEBUG] GOT BROWSER REPLY:", info, typeof info)
+				setConnectionInfo({
+					isConnected: info.isConnected,
+					isRemote: info.isRemote,
+					host: info.host,
+				})
+			} catch (error) {
+				console.error("Error fetching browser connection info:", error)
+			}
+		})()
+
+		// No need for message event listeners anymore!
+	}, [browserSettings.remoteBrowserHost, browserSettings.remoteBrowserEnabled])
+
+	// Close popover when clicking outside
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (
+				popoverRef.current &&
+				!popoverRef.current.contains(event.target as Node) &&
+				!event.composedPath().some((el) => (el as HTMLElement).classList?.contains("browser-info-icon"))
+			) {
+				setShowInfoPopover(false)
+			}
+		}
+
+		if (showInfoPopover) {
+			document.addEventListener("mousedown", handleClickOutside)
+		}
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [showInfoPopover])
+
+	const toggleInfoPopover = () => {
+		setShowInfoPopover(!showInfoPopover)
+
+		// Request updated connection info when opening the popover using gRPC
+		if (!showInfoPopover) {
+			const fetchConnectionInfo = async () => {
+				try {
+					const info = await BrowserServiceClient.getBrowserConnectionInfo(EmptyRequest.create({}))
+					setConnectionInfo({
+						isConnected: info.isConnected,
+						isRemote: info.isRemote,
+						host: info.host,
+					})
+				} catch (error) {
+					console.error("Error fetching browser connection info:", error)
+				}
+			}
+
+			fetchConnectionInfo()
+		}
+	}
+
+	// Determine icon based on connection state
+	const getIconClass = () => {
+		if (connectionInfo.isRemote) {
+			return "codicon-remote"
+		}
+		return connectionInfo.isConnected ? "codicon-vm-running" : "codicon-info"
+	}
+
+	// Determine icon color based on connection state
+	const getIconColor = () => {
+		if (connectionInfo.isRemote) {
+			return connectionInfo.isConnected ? "var(--vscode-charts-blue)" : "var(--vscode-foreground)"
+		}
+		if (connectionInfo.isConnected) {
+			return "var(--vscode-charts-green)"
+		}
+		return "var(--vscode-foreground)"
+	}
+
+	// Check connection status every second to keep icon in sync using gRPC
+	useEffect(() => {
+		// Function to fetch connection info
+		const fetchConnectionInfo = async () => {
+			try {
+				const info = await BrowserServiceClient.getBrowserConnectionInfo(EmptyRequest.create({}))
+				setConnectionInfo({
+					isConnected: info.isConnected,
+					isRemote: info.isRemote,
+					host: info.host,
+				})
+			} catch (error) {
+				console.error("Error fetching browser connection info:", error)
+			}
+		}
+
+		// Request connection info immediately
+		fetchConnectionInfo()
+
+		// Set up interval to refresh every second
+		const intervalId = setInterval(fetchConnectionInfo, 1000)
+
+		return () => clearInterval(intervalId)
+	}, [])
+
+	return (
+		<div ref={containerRef} style={{ position: "relative", marginTop: "-1px", display: "flex" }}>
+			<VSCodeButton
+				appearance="icon"
+				className="browser-info-icon"
+				onClick={toggleInfoPopover}
+				style={{ marginRight: "4px" }}
+				title="Browser connection info">
+				<i
+					className={`codicon ${getIconClass()}`}
+					style={{
+						fontSize: "14.5px",
+						color: getIconColor(),
+					}}
+				/>
+			</VSCodeButton>
+
+			{showInfoPopover && (
+				// InfoPopover - Dropdown container with connection details
+				<div
+					className="absolute top-[30px] right-0 z-100 w-[60dvw] max-w-[250px] rounded p-2.5 shadow-lg"
+					ref={popoverRef}
+					style={{
+						backgroundColor: "var(--vscode-editorWidget-background)",
+						border: "1px solid var(--vscode-widget-border)",
+						boxShadow: "0 2px 8px rgba(0, 0, 0, 0.15)",
+					}}>
+					<h4 style={{ margin: "0 0 8px 0" }}>Browser Connection</h4>
+					{/* InfoRow - Status row container */}
+					<div className="flex flex-wrap whitespace-nowrap mb-1">
+						{/* InfoLabel - Fixed-width label */}
+						<div className="flex-none w-[90px] font-medium">Status:</div>
+						{/* InfoValue - Flexible value container */}
+						<div
+							className="flex-1 break-words"
+							style={{
+								color: connectionInfo.isConnected
+									? "var(--vscode-charts-green)"
+									: "var(--vscode-errorForeground)",
+							}}>
+							{connectionInfo.isConnected ? "Connected" : "Disconnected"}
+						</div>
+					</div>
+					{connectionInfo.isConnected && (
+						// InfoRow - Type row container
+						<div className="flex flex-wrap whitespace-nowrap mb-1">
+							{/* InfoLabel - Fixed-width label */}
+							<div className="flex-none w-[90px] font-medium">Type:</div>
+							{/* InfoValue - Flexible value container */}
+							<div className="flex-1 break-words">{connectionInfo.isRemote ? "Remote" : "Local"}</div>
+						</div>
+					)}
+					{connectionInfo.isConnected && connectionInfo.isRemote && connectionInfo.host && (
+						// InfoRow - Remote host row container
+						<div className="flex flex-wrap whitespace-nowrap mb-1">
+							{/* InfoLabel - Fixed-width label */}
+							<div className="flex-none w-[90px] font-medium">Remote Host:</div>
+							{/* InfoValue - Flexible value container */}
+							<div className="flex-1 break-words">{connectionInfo.host}</div>
+						</div>
+					)}
+				</div>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/BrowserSessionRow.tsx b/apps/vscode/webview-ui/src/components/chat/BrowserSessionRow.tsx
new file mode 100644
index 0000000..2a449cf
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/BrowserSessionRow.tsx
@@ -0,0 +1,629 @@
+import { BROWSER_VIEWPORT_PRESETS } from "@shared/BrowserSettings"
+import { BrowserAction, BrowserActionResult, ClineMessage, ClineSayBrowserAction } from "@shared/ExtensionMessage"
+import { StringRequest } from "@shared/proto/cline/common"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import deepEqual from "fast-deep-equal"
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import React, { CSSProperties, memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useSize } from "react-use"
+import styled from "styled-components"
+import { BrowserSettingsMenu } from "@/components/browser/BrowserSettingsMenu"
+import { ChatRowContent, ProgressIndicator } from "@/components/chat/ChatRow"
+import CodeBlock, { CODE_BLOCK_BG_COLOR } from "@/components/common/CodeBlock"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import { FileServiceClient } from "@/services/grpc-client"
+
+interface BrowserSessionRowProps {
+	messages: ClineMessage[]
+	expandedRows: Record<number, boolean>
+	onToggleExpand: (messageTs: number) => void
+	lastModifiedMessage?: ClineMessage
+	isLast: boolean
+	onHeightChange: (isTaller: boolean) => void
+	onSetQuote: (text: string) => void
+}
+
+const browserSessionRowContainerInnerStyle: CSSProperties = {
+	display: "flex",
+	alignItems: "center",
+	gap: "10px",
+	marginBottom: "10px",
+}
+const browserIconStyle: CSSProperties = {
+	color: "var(--vscode-foreground)",
+	marginBottom: "-1.5px",
+}
+const approveTextStyle: CSSProperties = { fontWeight: "bold" }
+const urlBarContainerStyle: CSSProperties = {
+	margin: "5px auto",
+	width: "calc(100% - 10px)",
+	display: "flex",
+	alignItems: "center",
+	gap: "4px",
+}
+const imgScreenshotStyle: CSSProperties = {
+	position: "absolute",
+	top: 0,
+	left: 0,
+	width: "100%",
+	height: "100%",
+	objectFit: "contain",
+	cursor: "pointer",
+}
+const noScreenshotContainerStyle: CSSProperties = {
+	position: "absolute",
+	top: "50%",
+	left: "50%",
+	transform: "translate(-50%, -50%)",
+}
+const noScreenshotIconStyle: CSSProperties = {
+	fontSize: "80px",
+	color: "var(--vscode-descriptionForeground)",
+}
+const consoleLogsContainerStyle: CSSProperties = { width: "100%" }
+const consoleLogsTextStyle: CSSProperties = { fontSize: "0.8em" }
+const paginationContainerStyle: CSSProperties = {
+	display: "flex",
+	justifyContent: "space-between",
+	alignItems: "center",
+	padding: "8px 0px",
+	marginTop: "15px",
+	borderTop: "1px solid var(--vscode-editorGroup-border)",
+}
+const paginationButtonGroupStyle: CSSProperties = { display: "flex", gap: "4px" }
+const browserSessionStartedTextStyle: CSSProperties = { fontWeight: "bold" }
+const codeBlockContainerStyle: CSSProperties = {
+	borderRadius: 3,
+	border: "1px solid var(--vscode-editorGroup-border)",
+	overflow: "hidden",
+	backgroundColor: CODE_BLOCK_BG_COLOR,
+}
+const browserActionBoxContainerStyle: CSSProperties = { padding: "10px 0 0 0" }
+const browserActionBoxContainerInnerStyle: CSSProperties = {
+	borderRadius: 3,
+	backgroundColor: CODE_BLOCK_BG_COLOR,
+	overflow: "hidden",
+	border: "1px solid var(--vscode-editorGroup-border)",
+}
+const browseActionRowContainerStyle: CSSProperties = {
+	display: "flex",
+	alignItems: "center",
+	padding: "9px 10px",
+}
+const browseActionRowStyle: CSSProperties = {
+	whiteSpace: "normal",
+	wordBreak: "break-word",
+}
+const browseActionTextStyle: CSSProperties = { fontWeight: 500 }
+const chatRowContentContainerStyle: CSSProperties = { padding: "10px 0 10px 0" }
+const headerStyle: CSSProperties = {
+	display: "flex",
+	alignItems: "center",
+	gap: "10px",
+	marginBottom: "10px",
+}
+
+const BrowserSessionRow = memo((props: BrowserSessionRowProps) => {
+	const { messages, isLast, onHeightChange, lastModifiedMessage, onSetQuote } = props
+	const { browserSettings } = useExtensionState()
+	const prevHeightRef = useRef(0)
+	const [maxActionHeight, setMaxActionHeight] = useState(0)
+	const [consoleLogsExpanded, setConsoleLogsExpanded] = useState(false)
+
+	const isLastApiReqInterrupted = useMemo(() => {
+		// Check if last api_req_started is cancelled
+		const lastApiReqStarted = [...messages].reverse().find((m) => m.say === "api_req_started")
+		if (lastApiReqStarted?.text != null) {
+			const info = JSON.parse(lastApiReqStarted.text)
+			if (info.cancelReason != null) {
+				return true
+			}
+		}
+		const lastApiReqFailed = isLast && lastModifiedMessage?.ask === "api_req_failed"
+		if (lastApiReqFailed) {
+			return true
+		}
+		return false
+	}, [messages, lastModifiedMessage, isLast])
+
+	// If last message is a resume, it means the task was cancelled and the browser was closed
+	const isLastMessageResume = useMemo(() => {
+		// Check if last message is resume completion
+		return lastModifiedMessage?.ask === "resume_task" || lastModifiedMessage?.ask === "resume_completed_task"
+	}, [lastModifiedMessage?.ask])
+
+	const isBrowsing = useMemo(() => {
+		return isLast && messages.some((m) => m.say === "browser_action_result") && !isLastApiReqInterrupted // after user approves, browser_action_result with "" is sent to indicate that the session has started
+	}, [isLast, messages, isLastApiReqInterrupted])
+
+	// Organize messages into pages with current state and next action
+	const pages = useMemo(() => {
+		const result: {
+			currentState: {
+				url?: string
+				screenshot?: string
+				mousePosition?: string
+				consoleLogs?: string
+				messages: ClineMessage[] // messages up to and including the result
+			}
+			nextAction?: {
+				messages: ClineMessage[] // messages leading to next result
+			}
+		}[] = []
+
+		let currentStateMessages: ClineMessage[] = []
+		let nextActionMessages: ClineMessage[] = []
+
+		messages.forEach((message) => {
+			if (message.ask === "browser_action_launch" || message.say === "browser_action_launch") {
+				// Start first page
+				currentStateMessages = [message]
+			} else if (message.say === "browser_action_result") {
+				if (message.text === "") {
+					// first browser_action_result is an empty string that signals that session has started
+					return
+				}
+				// Complete current state
+				currentStateMessages.push(message)
+				const resultData = JSON.parse(message.text || "{}") as BrowserActionResult
+
+				// Add page with current state and previous next actions
+				result.push({
+					currentState: {
+						url: resultData.currentUrl,
+						screenshot: resultData.screenshot,
+						mousePosition: resultData.currentMousePosition,
+						consoleLogs: resultData.logs,
+						messages: [...currentStateMessages],
+					},
+					nextAction:
+						nextActionMessages.length > 0
+							? {
+									messages: [...nextActionMessages],
+								}
+							: undefined,
+				})
+
+				// Reset for next page
+				currentStateMessages = []
+				nextActionMessages = []
+			} else if (
+				message.say === "api_req_started" ||
+				message.say === "text" ||
+				message.say === "reasoning" ||
+				message.say === "browser_action" ||
+				message.say === "error_retry"
+			) {
+				// These messages lead to the next result, so they should always go in nextActionMessages
+				nextActionMessages.push(message)
+			} else {
+				// Any other message types
+				currentStateMessages.push(message)
+			}
+		})
+
+		// Add incomplete page if exists
+		if (currentStateMessages.length > 0 || nextActionMessages.length > 0) {
+			result.push({
+				currentState: {
+					messages: [...currentStateMessages],
+				},
+				nextAction:
+					nextActionMessages.length > 0
+						? {
+								messages: [...nextActionMessages],
+							}
+						: undefined,
+			})
+		}
+
+		return result
+	}, [messages])
+
+	// Auto-advance to latest page
+	const [currentPageIndex, setCurrentPageIndex] = useState(0)
+	useEffect(() => {
+		setCurrentPageIndex(pages.length - 1)
+	}, [pages.length])
+
+	// Get initial URL from launch message
+	const initialUrl = useMemo(() => {
+		const launchMessage = messages.find((m) => m.ask === "browser_action_launch" || m.say === "browser_action_launch")
+		return launchMessage?.text || ""
+	}, [messages])
+
+	const isAutoApproved = useMemo(() => {
+		const launchMessage = messages.find((m) => m.ask === "browser_action_launch" || m.say === "browser_action_launch")
+		return launchMessage?.say === "browser_action_launch"
+	}, [messages])
+
+	// const lastCheckpointMessageTs = useMemo(() => {
+	// 	const lastCheckpointMessage = findLast(messages, (m) => m.lastCheckpointHash !== undefined)
+	// 	return lastCheckpointMessage?.ts
+	// }, [messages])
+
+	// Find the latest available URL and screenshot
+	const latestState = useMemo(() => {
+		for (let i = pages.length - 1; i >= 0; i--) {
+			const page = pages[i]
+			if (page.currentState.url || page.currentState.screenshot) {
+				return {
+					url: page.currentState.url,
+					mousePosition: page.currentState.mousePosition,
+					consoleLogs: page.currentState.consoleLogs,
+					screenshot: page.currentState.screenshot,
+				}
+			}
+		}
+		return {
+			url: undefined,
+			mousePosition: undefined,
+			consoleLogs: undefined,
+			screenshot: undefined,
+		}
+	}, [pages])
+
+	const currentPage = pages[currentPageIndex]
+	const isLastPage = currentPageIndex === pages.length - 1
+
+	const defaultMousePosition = `${browserSettings.viewport.width * 0.7},${browserSettings.viewport.height * 0.5}`
+
+	// Use latest state if we're on the last page and don't have a state yet
+	const displayState = isLastPage
+		? {
+				url: currentPage?.currentState.url || latestState.url || initialUrl,
+				mousePosition: currentPage?.currentState.mousePosition || latestState.mousePosition || defaultMousePosition,
+				consoleLogs: currentPage?.currentState.consoleLogs,
+				screenshot: currentPage?.currentState.screenshot || latestState.screenshot,
+			}
+		: {
+				url: currentPage?.currentState.url || initialUrl,
+				mousePosition: currentPage?.currentState.mousePosition || defaultMousePosition,
+				consoleLogs: currentPage?.currentState.consoleLogs,
+				screenshot: currentPage?.currentState.screenshot,
+			}
+
+	const [actionContent, { height: actionHeight }] = useSize(
+		<div>
+			{currentPage?.nextAction?.messages.map((message) => (
+				<BrowserSessionRowContent
+					expandedRows={props.expandedRows}
+					isLast={props.isLast}
+					key={message.ts}
+					lastModifiedMessage={props.lastModifiedMessage}
+					message={message}
+					onSetQuote={props.onSetQuote}
+					onToggleExpand={props.onToggleExpand}
+					setMaxActionHeight={setMaxActionHeight}
+				/>
+			))}
+			{!isBrowsing && messages.some((m) => m.say === "browser_action_result") && currentPageIndex === 0 && (
+				<BrowserActionBox action={"launch"} text={initialUrl} />
+			)}
+		</div>,
+	)
+
+	useEffect(() => {
+		if (actionHeight === 0 || actionHeight === Infinity) {
+			return
+		}
+		if (actionHeight > maxActionHeight) {
+			setMaxActionHeight(actionHeight)
+		}
+	}, [actionHeight, maxActionHeight])
+
+	// Track latest click coordinate
+	const latestClickPosition = useMemo(() => {
+		if (!isBrowsing) {
+			return undefined
+		}
+
+		// Look through current page's next actions for the latest browser_action
+		const actions = currentPage?.nextAction?.messages || []
+		for (let i = actions.length - 1; i >= 0; i--) {
+			const message = actions[i]
+			if (message.say === "browser_action") {
+				const browserAction = JSON.parse(message.text || "{}") as ClineSayBrowserAction
+				if (browserAction.action === "click" && browserAction.coordinate) {
+					return browserAction.coordinate
+				}
+			}
+		}
+		return undefined
+	}, [isBrowsing, currentPage?.nextAction?.messages])
+
+	// Use latest click position while browsing, otherwise use display state
+	const mousePosition = isBrowsing ? latestClickPosition || displayState.mousePosition : displayState.mousePosition
+
+	// let shouldShowCheckpoints = true
+	// if (isLast) {
+	// 	shouldShowCheckpoints = lastModifiedMessage?.ask === "resume_completed_task" || lastModifiedMessage?.ask === "resume_task"
+	// }
+
+	const _shouldShowSettings = useMemo(() => {
+		const lastMessage = messages[messages.length - 1]
+		return lastMessage?.ask === "browser_action_launch" || lastMessage?.say === "browser_action_launch"
+	}, [messages])
+
+	// Calculate maxWidth
+	const maxWidth = browserSettings.viewport.width < BROWSER_VIEWPORT_PRESETS["Small Desktop (900x600)"].width ? 200 : undefined
+
+	const [browserSessionRow, { height }] = useSize(
+		// We don't declare a constant for the inline style here because `useSize` will try to modify the style object
+		// Which will cause `Uncaught TypeError: Cannot assign to read only property 'position' of object '#<Object>'`
+		<BrowserSessionRowContainer style={{ marginBottom: -10 }}>
+			<div style={browserSessionRowContainerInnerStyle}>
+				{isBrowsing && !isLastMessageResume ? (
+					<ProgressIndicator />
+				) : (
+					<span className="codicon codicon-inspect" style={browserIconStyle}></span>
+				)}
+				<span style={approveTextStyle}>
+					{isAutoApproved ? "Cline is using the browser:" : "Cline wants to use the browser:"}
+				</span>
+			</div>
+			<div
+				style={{
+					borderRadius: 3,
+					border: "1px solid var(--vscode-editorGroup-border)",
+					// overflow: "hidden",
+					backgroundColor: CODE_BLOCK_BG_COLOR,
+					// marginBottom: 10,
+					maxWidth,
+					margin: "0 auto 10px auto", // Center the container
+				}}>
+				{/* URL Bar */}
+				<div style={urlBarContainerStyle}>
+					<div
+						className={cn(
+							"flex bg-input-background border border-input-border rounded-sm px-1 py-0.5 min-w-0 text-description w-full justify-center",
+							{
+								"text-input-foreground": !!displayState.url,
+							},
+						)}>
+						<span className="text-xs text-ellipsis overflow-hidden whitespace-nowrap">
+							{displayState.url || "http"}
+						</span>
+					</div>
+					<BrowserSettingsMenu />
+				</div>
+
+				{/* Screenshot Area */}
+				<div
+					style={{
+						width: "100%",
+						paddingBottom: `${(browserSettings.viewport.height / browserSettings.viewport.width) * 100}%`,
+						position: "relative",
+						backgroundColor: "var(--vscode-input-background)",
+					}}>
+					{displayState.screenshot ? (
+						<img
+							alt="Browser screenshot"
+							onClick={() =>
+								FileServiceClient.openImage(StringRequest.create({ value: displayState.screenshot })).catch(
+									(err) => console.error("Failed to open image:", err),
+								)
+							}
+							src={displayState.screenshot}
+							style={imgScreenshotStyle}
+						/>
+					) : (
+						<div style={noScreenshotContainerStyle}>
+							<span className="codicon codicon-globe" style={noScreenshotIconStyle} />
+						</div>
+					)}
+					{displayState.mousePosition && (
+						<BrowserCursor
+							style={{
+								position: "absolute",
+								top: `${(parseInt(mousePosition.split(",")[1]) / browserSettings.viewport.height) * 100}%`,
+								left: `${(parseInt(mousePosition.split(",")[0]) / browserSettings.viewport.width) * 100}%`,
+								transition: "top 0.3s ease-out, left 0.3s ease-out",
+							}}
+						/>
+					)}
+				</div>
+
+				<div style={consoleLogsContainerStyle}>
+					<div
+						onClick={() => {
+							setConsoleLogsExpanded(!consoleLogsExpanded)
+						}}
+						style={{
+							display: "flex",
+							alignItems: "center",
+							gap: "4px",
+							// width: "100%",
+							justifyContent: "flex-start",
+							cursor: "pointer",
+							padding: `9px 8px ${consoleLogsExpanded ? 0 : 8}px 8px`,
+						}}>
+						{consoleLogsExpanded ? <ChevronDownIcon size={16} /> : <ChevronRightIcon size={16} />}
+						<span style={consoleLogsTextStyle}>Console Logs</span>
+					</div>
+					{consoleLogsExpanded && (
+						<CodeBlock source={`${"```"}shell\n${displayState.consoleLogs || "(No new logs)"}\n${"```"}`} />
+					)}
+				</div>
+			</div>
+
+			{/* Action content with min height */}
+			<div style={{ minHeight: maxActionHeight }}>{actionContent}</div>
+
+			{/* Pagination moved to bottom */}
+			{pages.length > 1 && (
+				<div style={paginationContainerStyle}>
+					<div>
+						Step {currentPageIndex + 1} of {pages.length}
+					</div>
+					<div style={paginationButtonGroupStyle}>
+						<VSCodeButton
+							disabled={currentPageIndex === 0 || isBrowsing}
+							onClick={() => setCurrentPageIndex((i) => i - 1)}>
+							Previous
+						</VSCodeButton>
+						<VSCodeButton
+							disabled={currentPageIndex === pages.length - 1 || isBrowsing}
+							onClick={() => setCurrentPageIndex((i) => i + 1)}>
+							Next
+						</VSCodeButton>
+					</div>
+				</div>
+			)}
+
+			{/* {shouldShowCheckpoints && <CheckpointOverlay messageTs={lastCheckpointMessageTs} />} */}
+		</BrowserSessionRowContainer>,
+	)
+
+	// Height change effect
+	useEffect(() => {
+		const isInitialRender = prevHeightRef.current === 0
+		if (isLast && height !== 0 && height !== Infinity && height !== prevHeightRef.current) {
+			if (!isInitialRender) {
+				onHeightChange(height > prevHeightRef.current)
+			}
+			prevHeightRef.current = height
+		}
+	}, [height, isLast, onHeightChange])
+
+	return browserSessionRow
+}, deepEqual)
+
+interface BrowserSessionRowContentProps extends Omit<BrowserSessionRowProps, "messages" | "onHeightChange"> {
+	message: ClineMessage
+	setMaxActionHeight: (height: number) => void
+	onSetQuote: (text: string) => void
+}
+
+const BrowserSessionRowContent = memo(
+	({
+		message,
+		expandedRows,
+		onToggleExpand,
+		lastModifiedMessage,
+		isLast,
+		setMaxActionHeight,
+		onSetQuote,
+	}: BrowserSessionRowContentProps) => {
+		const handleToggle = useCallback(() => {
+			if (message.say === "api_req_started") {
+				setMaxActionHeight(0)
+			}
+			onToggleExpand(message.ts)
+		}, [onToggleExpand, message.ts, setMaxActionHeight])
+
+		if (message.ask === "browser_action_launch" || message.say === "browser_action_launch") {
+			return (
+				<>
+					<div style={headerStyle}>
+						<span style={browserSessionStartedTextStyle}>Browser Session Started</span>
+					</div>
+					<div style={codeBlockContainerStyle}>
+						<CodeBlock forceWrap={true} source={`${"```"}shell\n${message.text}\n${"```"}`} />
+					</div>
+				</>
+			)
+		}
+
+		switch (message.type) {
+			case "say":
+				switch (message.say) {
+					case "api_req_started":
+					case "text":
+					case "reasoning":
+					case "error_retry":
+						return (
+							<div style={chatRowContentContainerStyle}>
+								<ChatRowContent
+									isExpanded={expandedRows[message.ts] ?? false}
+									isLast={isLast}
+									lastModifiedMessage={lastModifiedMessage}
+									message={message}
+									onSetQuote={onSetQuote}
+									onToggleExpand={handleToggle}
+								/>
+							</div>
+						)
+
+					case "browser_action":
+						const browserAction = JSON.parse(message.text || "{}") as ClineSayBrowserAction
+						return (
+							<BrowserActionBox
+								action={browserAction.action}
+								coordinate={browserAction.coordinate}
+								text={browserAction.text}
+							/>
+						)
+
+					default:
+						return null
+				}
+
+			case "ask":
+				switch (message.ask) {
+					default:
+						return null
+				}
+		}
+	},
+	deepEqual,
+)
+
+const BrowserActionBox = ({ action, coordinate, text }: { action: BrowserAction; coordinate?: string; text?: string }) => {
+	const getBrowserActionText = (action: BrowserAction, coordinate?: string, text?: string) => {
+		switch (action) {
+			case "launch":
+				return `Launch browser at ${text}`
+			case "click":
+				return `Click (${coordinate?.replace(",", ", ")})`
+			case "type":
+				return `Type "${text}"`
+			case "scroll_down":
+				return "Scroll down"
+			case "scroll_up":
+				return "Scroll up"
+			case "close":
+				return "Close browser"
+			default:
+				return action
+		}
+	}
+	return (
+		<div style={browserActionBoxContainerStyle}>
+			<div style={browserActionBoxContainerInnerStyle}>
+				<div style={browseActionRowContainerStyle}>
+					<span style={browseActionRowStyle}>
+						<span style={browseActionTextStyle}>Browse Action: </span>
+						{getBrowserActionText(action, coordinate, text)}
+					</span>
+				</div>
+			</div>
+		</div>
+	)
+}
+
+const BrowserCursor: React.FC<{ style?: CSSProperties }> = ({ style }) => {
+	// (can't use svgs in vsc extensions)
+	const cursorBase64 =
+		"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABUAAAAYCAYAAAAVibZIAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAFaADAAQAAAABAAAAGAAAAADwi9a/AAADGElEQVQ4EZ2VbUiTURTH772be/PxZdsz3cZwC4RVaB8SAjMpxQwSWZbQG/TFkN7oW1Df+h6IRV9C+hCpKUSIZUXOfGM5tAKViijFFEyfZ7Ol29S1Pbdzl8Uw9+aBu91zzv3/nt17zt2DEZjBYOAkKrtFMXIghAWM8U2vMN/FctsxGRMpM7NbEEYNMM2CYUSInlJx3OpawO9i+XSNQYkmk2uFb9njzkcfVSr1p/GJiQKMULVaw2WuBv296UKRxWJR6wxGCmM1EAhSNppv33GBH9qI32cPTAtss9lUm6EM3N7R+RbigT+5/CeosFCZKpjEW+iorS1pb30wDUXzQfHqtD/9L3ieZ2ee1OJCmbL8QHnRs+4uj0wmW4QzrpCwvJ8zGg3JqAmhTLynuLiwv8/5KyND8Q3cEkUEDWu15oJE4KRQJt5hs1rcriGNRqP+DK4dyyWXXm/aFQ+cEpSJ8/LyDGPuEZNOmzsOroUSOqzXG/dtBU4ZysTZYKNut91sNo2Cq6cE9enz86s2g9OCMrFSqVC5hgb32u072W3jKMU90Hb1seC0oUwsB+t92bO/rKx0EFGkgFCnjjc1/gVvC8rE0L+4o63t4InjxwbAJQjTe3qD8QrLkXA4DC24fWtuajp06cLFYSBIFKGmXKPRRmAnME9sPt+yLwIWb9WN69fKoTneQz4Dh2mpPNkvfeV0jjecb9wNAkwIEVQq5VJOds4Kb+DXoAsiVquVwI1Dougpij6UyGYx+5cKroeDEFibm5lWRRMbH1+npmYrq6qhwlQHIbajZEf1fElcqGGFpGg9HMuKzpfBjhytCTMgkJ56RX09zy/ysENTBElmjIgJnmNChJqohDVQqpEfwkILE8v/o0GAnV9F1eEvofVQCbiTBEXOIPQh5PGgefDZeAcjrpGZjULBr/m3tZOnz7oEQWRAQZLjWlEU/XEJWySiILgRc5Cz1DkcAyuBFcnpfF0JiXWKpcolQXizhS5hKAqFpr0MVbgbuxJ6+5xX+P4wNpbqPPrugZfbmIbLmgQR3Aw8QSi66hUXulOFbF73GxqjE5BNXWNeAAAAAElFTkSuQmCC"
+
+	return (
+		<img
+			alt="cursor"
+			src={cursorBase64}
+			style={{
+				width: "17px",
+				height: "22px",
+				...style,
+			}}
+		/>
+	)
+}
+
+const BrowserSessionRowContainer = styled.div`
+	padding: 10px 6px 10px 15px;
+	position: relative;
+`
+
+export default BrowserSessionRow
diff --git a/apps/vscode/webview-ui/src/components/chat/ChatErrorBoundary.tsx b/apps/vscode/webview-ui/src/components/chat/ChatErrorBoundary.tsx
new file mode 100644
index 0000000..4297d73
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ChatErrorBoundary.tsx
@@ -0,0 +1,60 @@
+import React from "react"
+
+interface ChatErrorBoundaryProps {
+	children: React.ReactNode
+	errorTitle?: string
+	errorBody?: string
+	height?: string
+}
+
+interface ChatErrorBoundaryState {
+	hasError: boolean
+	error: Error | null
+}
+
+/**
+ * A reusable error boundary component specifically designed for chat widgets.
+ * It provides a consistent error UI with customizable title and body text.
+ */
+class ChatErrorBoundary extends React.Component<ChatErrorBoundaryProps, ChatErrorBoundaryState> {
+	constructor(props: ChatErrorBoundaryProps) {
+		super(props)
+		this.state = { hasError: false, error: null }
+	}
+
+	static getDerivedStateFromError(error: Error) {
+		return { hasError: true, error }
+	}
+
+	componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
+		console.error("Error in ChatErrorBoundary:", error.message)
+		console.error("Component stack:", errorInfo.componentStack)
+	}
+
+	render() {
+		const { errorTitle, errorBody, height } = this.props
+
+		if (this.state.hasError) {
+			return (
+				<div
+					style={{
+						padding: "10px",
+						color: "var(--vscode-errorForeground)",
+						height: height || "auto",
+						maxWidth: "512px",
+						overflow: "auto",
+						border: "1px solid var(--vscode-editorError-foreground)",
+						borderRadius: "4px",
+						backgroundColor: "var(--vscode-inputValidation-errorBackground, rgba(255, 0, 0, 0.1))",
+					}}>
+					<h3 style={{ margin: "0 0 8px 0" }}>{errorTitle || "Something went wrong displaying this content"}</h3>
+					<p style={{ margin: "0" }}>{errorBody || `Error: ${this.state.error?.message || "Unknown error"}`}</p>
+				</div>
+			)
+		}
+
+		return this.props.children
+	}
+}
+
+export default ChatErrorBoundary
diff --git a/apps/vscode/webview-ui/src/components/chat/ChatRow.tsx b/apps/vscode/webview-ui/src/components/chat/ChatRow.tsx
new file mode 100644
index 0000000..ee1a0d4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ChatRow.tsx
@@ -0,0 +1,1209 @@
+import { COMMAND_OUTPUT_STRING } from "@shared/combineCommandSequences"
+import {
+	ClineApiReqInfo,
+	ClineAskQuestion,
+	ClineAskUseMcpServer,
+	ClineMessage,
+	ClinePlanModeResponse,
+	ClineSayTool,
+	COMPLETION_RESULT_CHANGES_FLAG,
+} from "@shared/ExtensionMessage"
+import { BooleanRequest, StringRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import deepEqual from "fast-deep-equal"
+import {
+	BellIcon,
+	ChevronDownIcon,
+	ChevronRightIcon,
+	CircleXIcon,
+	FileCode2Icon,
+	FilePlus2Icon,
+	FoldVerticalIcon,
+	ImageUpIcon,
+	LightbulbIcon,
+	Link2Icon,
+	LoaderCircleIcon,
+	PencilIcon,
+	RefreshCwIcon,
+	SearchIcon,
+	SettingsIcon,
+	SquareArrowOutUpRightIcon,
+	SquareMinusIcon,
+	TerminalIcon,
+	TriangleAlertIcon,
+} from "lucide-react"
+import { MouseEvent, memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useSize } from "react-use"
+import { canRestoreWorkspaceFromMessage } from "@/components/chat/chat-view/utils/messageUtils"
+import { OptionsButtons } from "@/components/chat/OptionsButtons"
+import { WithCopyButton } from "@/components/common/CopyButton"
+import McpResponseDisplay from "@/components/mcp/chat-display/McpResponseDisplay"
+import McpResourceRow from "@/components/mcp/configuration/tabs/installed/server-row/McpResourceRow"
+import McpToolRow from "@/components/mcp/configuration/tabs/installed/server-row/McpToolRow"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import { FileServiceClient, UiServiceClient } from "@/services/grpc-client"
+import { findMatchingResourceOrTemplate } from "@/utils/mcp"
+import CodeAccordian, { cleanPathPrefix } from "../common/CodeAccordian"
+import { CommandOutputContent, CommandOutputRow } from "./CommandOutputRow"
+import { CompletionOutputRow } from "./CompletionOutputRow"
+import { DiffEditRow } from "./DiffEditRow"
+import ErrorRow from "./ErrorRow"
+import { FeatureTip } from "./FeatureTip"
+import HookMessage from "./HookMessage"
+import { MarkdownRow } from "./MarkdownRow"
+import NewTaskPreview from "./NewTaskPreview"
+import PlanCompletionOutputRow from "./PlanCompletionOutputRow"
+import QuoteButton from "./QuoteButton"
+import ReportBugPreview from "./ReportBugPreview"
+import { RequestStartRow } from "./RequestStartRow"
+import SearchResultsDisplay from "./SearchResultsDisplay"
+import SubagentStatusRow from "./SubagentStatusRow"
+import { ThinkingRow } from "./ThinkingRow"
+import UserMessage from "./UserMessage"
+
+const HEADER_CLASSNAMES = "flex items-center gap-2.5 mb-3"
+
+interface ChatRowProps {
+	message: ClineMessage
+	isExpanded: boolean
+	onToggleExpand: (ts: number, options?: { preserveAutoScroll?: boolean }) => void
+	lastModifiedMessage?: ClineMessage
+	isLast: boolean
+	onHeightChange: (isTaller: boolean) => void
+	onLastRowContentChange: () => void
+	inputValue?: string
+	sendMessageFromChatRow?: (text: string, images: string[], files: string[]) => void
+	onSetQuote: (text: string) => void
+	onCancelCommand?: () => void
+	mode?: Mode
+	reasoningContent?: string
+	responseStarted?: boolean
+	isRequestInProgress?: boolean
+}
+
+export interface QuoteButtonState {
+	visible: boolean
+	top: number
+	left: number
+	selectedText: string
+}
+
+interface ChatRowContentProps extends Omit<ChatRowProps, "onHeightChange" | "onLastRowContentChange"> {
+	onLastRowContentChange?: () => void
+}
+
+export const ProgressIndicator = () => <LoaderCircleIcon className="size-2 mr-2 animate-spin" />
+const InvisibleSpacer = () => <div aria-hidden className="h-px" />
+
+const ChatRow = memo(
+	(props: ChatRowProps) => {
+		const { isLast, onHeightChange, message } = props
+		// Store the previous height to compare with the current height
+		// This allows us to detect changes without causing re-renders
+		const prevHeightRef = useRef(0)
+
+		const [chatrow, { height }] = useSize(
+			<div className="relative pt-2.5 px-4">
+				<ChatRowContent {...props} />
+			</div>,
+		)
+
+		useEffect(() => {
+			// used for partials command output etc.
+			// NOTE: it's important we don't distinguish between partial or complete here since our scroll effects in chatview need to handle height change during partial -> complete
+			const isInitialRender = prevHeightRef.current === 0 // prevents scrolling when new element is added since we already scroll for that
+			// height starts off at Infinity
+			if (isLast && height !== 0 && height !== Number.POSITIVE_INFINITY && height !== prevHeightRef.current) {
+				if (!isInitialRender) {
+					onHeightChange(height > prevHeightRef.current)
+				}
+				prevHeightRef.current = height
+			}
+		}, [height, isLast, onHeightChange, message])
+
+		// we cannot return null as virtuoso does not support it so we use a separate visibleMessages array to filter out messages that should not be rendered
+		return chatrow
+	},
+	// memo does shallow comparison of props, so we need to do deep comparison of arrays/objects whose properties might change
+	deepEqual,
+)
+
+export default ChatRow
+
+export const ChatRowContent = memo(
+	({
+		message,
+		isExpanded,
+		onToggleExpand,
+		lastModifiedMessage,
+		isLast,
+		inputValue,
+		sendMessageFromChatRow,
+		onSetQuote,
+		onCancelCommand,
+		onLastRowContentChange,
+		mode,
+		isRequestInProgress,
+		reasoningContent,
+		responseStarted,
+	}: ChatRowContentProps) => {
+		const { backgroundEditEnabled, mcpServers, vscodeTerminalExecutionMode, clineMessages, showFeatureTips } =
+			useExtensionState()
+		const [quoteButtonState, setQuoteButtonState] = useState<QuoteButtonState>({
+			visible: false,
+			top: 0,
+			left: 0,
+			selectedText: "",
+		})
+		const contentRef = useRef<HTMLDivElement>(null)
+
+		// Command output expansion state (for all messages, but only used by command messages)
+		const [isOutputFullyExpanded, setIsOutputFullyExpanded] = useState(false)
+		const prevCommandExecutingRef = useRef<boolean>(false)
+
+		const hasAutoExpandedRef = useRef(false)
+		const hasAutoCollapsedRef = useRef(false)
+		const prevIsLastRef = useRef(isLast)
+
+		// Auto-expand completion output when it's the last message (runs once per message)
+		useEffect(() => {
+			const isCompletionResult = message.ask === "completion_result" || message.say === "completion_result"
+
+			// Auto-expand if it's last and we haven't already auto-expanded
+			if (isLast && isCompletionResult && !hasAutoExpandedRef.current) {
+				hasAutoExpandedRef.current = true
+				hasAutoCollapsedRef.current = false // Reset the auto-collapse flag when expanding
+			}
+		}, [isLast, message.ask, message.say])
+
+		// Auto-collapse completion output ONCE when transitioning from last to not-last
+		useEffect(() => {
+			const isCompletionResult = message.ask === "completion_result" || message.say === "completion_result"
+			const wasLast = prevIsLastRef.current
+
+			// Only auto-collapse if transitioning from last to not-last, and we haven't already auto-collapsed
+			if (wasLast && !isLast && isCompletionResult && !hasAutoCollapsedRef.current) {
+				hasAutoCollapsedRef.current = true
+				hasAutoExpandedRef.current = false // Reset the auto-expand flag when collapsing
+			}
+
+			prevIsLastRef.current = isLast
+		}, [isLast, message.ask, message.say])
+
+		const [cost, apiReqCancelReason, apiReqStreamingFailedMessage] = useMemo(() => {
+			if (message.text != null && message.say === "api_req_started") {
+				const info: ClineApiReqInfo = JSON.parse(message.text)
+				return [info.cost, info.cancelReason, info.streamingFailedMessage, info.retryStatus]
+			}
+			return [undefined, undefined, undefined, undefined, undefined]
+		}, [message.text, message.say])
+
+		// when resuming task last won't be api_req_failed but a resume_task message so api_req_started will show loading spinner. that's why we just remove the last api_req_started that failed without streaming anything
+		const apiRequestFailedMessage =
+			isLast && lastModifiedMessage?.ask === "api_req_failed" // if request is retried then the latest message is a api_req_retried
+				? lastModifiedMessage?.text
+				: undefined
+
+		const type = message.type === "ask" ? message.ask : message.say
+
+		const isCommandMessage = type === "command"
+		// Check if command has output to determine if it's actually executing
+		const commandHasOutput = message.text?.includes(COMMAND_OUTPUT_STRING) ?? false
+		// A command is executing if it has output but hasn't completed yet
+		const isCommandExecuting = isCommandMessage && !message.commandCompleted && commandHasOutput
+		// A command is pending if it hasn't started (no output) and hasn't completed
+		const isCommandPending = isCommandMessage && isLast && !message.commandCompleted && !commandHasOutput
+		const isCommandCompleted = isCommandMessage && message.commandCompleted === true
+
+		const isMcpServerResponding = isLast && lastModifiedMessage?.say === "mcp_server_request_started"
+
+		const handleToggle = useCallback(() => {
+			onToggleExpand(message.ts)
+		}, [onToggleExpand, message.ts])
+
+		// --- Quote Button Logic ---
+		// MOVE handleQuoteClick INSIDE ChatRowContent
+		const handleQuoteClick = useCallback(() => {
+			onSetQuote(quoteButtonState.selectedText)
+			window.getSelection()?.removeAllRanges() // Clear the browser selection
+			setQuoteButtonState({ visible: false, top: 0, left: 0, selectedText: "" })
+		}, [onSetQuote, quoteButtonState.selectedText]) // <-- Use onSetQuote from props
+
+		const handleMouseUp = useCallback((event: MouseEvent<HTMLDivElement>) => {
+			// Get the target element immediately, before the timeout
+			const targetElement = event.target as Element
+			const isClickOnButton = !!targetElement.closest(".quote-button-class")
+
+			// Delay the selection check slightly
+			setTimeout(() => {
+				// Now, check the selection state *after* the browser has likely updated it
+				const selection = window.getSelection()
+				const selectedText = selection?.toString().trim() ?? ""
+
+				let shouldShowButton = false
+				let buttonTop = 0
+				let buttonLeft = 0
+				let textToQuote = ""
+
+				// Condition 1: Check if there's a valid, non-collapsed selection within bounds
+				// Ensure contentRef.current still exists in case component unmounted during timeout
+				if (selectedText && contentRef.current && selection && selection.rangeCount > 0 && !selection.isCollapsed) {
+					const range = selection.getRangeAt(0)
+					const rangeRect = range.getBoundingClientRect()
+					// Re-check ref inside timeout and ensure containerRect is valid
+					const containerRect = contentRef.current?.getBoundingClientRect()
+
+					if (containerRect) {
+						// Check if containerRect was successfully obtained
+						const tolerance = 5 // Allow for a small pixel overflow (e.g., for margins)
+						const isSelectionWithin =
+							rangeRect.top >= containerRect.top &&
+							rangeRect.left >= containerRect.left &&
+							rangeRect.bottom <= containerRect.bottom + tolerance && // Added tolerance
+							rangeRect.right <= containerRect.right
+
+						if (isSelectionWithin) {
+							shouldShowButton = true // Mark that we should show the button
+							const buttonHeight = 30
+							// Calculate the raw top position relative to the container, placing it above the selection
+							const calculatedTop = rangeRect.top - containerRect.top - buttonHeight - 5 // Subtract button height and a small margin
+							// Allow the button to potentially have a negative top value
+							buttonTop = calculatedTop
+							buttonLeft = Math.max(0, rangeRect.left - containerRect.left) // Still prevent going left of container
+							textToQuote = selectedText
+						}
+					}
+				}
+
+				// Decision: Set the state based on whether we should show or hide
+				if (shouldShowButton) {
+					// Scenario A: Valid selection exists -> Show button
+					setQuoteButtonState({
+						visible: true,
+						top: buttonTop,
+						left: buttonLeft,
+						selectedText: textToQuote,
+					})
+				} else if (!isClickOnButton) {
+					// Scenario B: No valid selection AND click was NOT on button -> Hide button
+					setQuoteButtonState({ visible: false, top: 0, left: 0, selectedText: "" })
+				}
+				// Scenario C (Click WAS on button): Do nothing here, handleQuoteClick takes over.
+			}, 0) // Delay of 0ms pushes execution after current event cycle
+		}, []) // Dependencies remain empty
+
+		const [icon, title] = useMemo(() => {
+			switch (type) {
+				case "error":
+					return [
+						<span className="codicon codicon-error text-error mb-[-1.5px]" />,
+						<span className="text-error font-bold">Error</span>,
+					]
+				case "mistake_limit_reached":
+					return [
+						<CircleXIcon className="text-error size-2" />,
+						<span className="text-error font-bold">Cline is having trouble...</span>,
+					]
+				case "command":
+					return [
+						<TerminalIcon className="text-foreground size-2" />,
+						<span className="font-bold text-foreground">Cline wants to execute this command:</span>,
+					]
+				case "use_mcp_server":
+					const mcpServerUse = JSON.parse(message.text || "{}") as ClineAskUseMcpServer
+					return [
+						isMcpServerResponding ? (
+							<ProgressIndicator />
+						) : (
+							<span className="codicon codicon-server text-foreground mb-[-1.5px]" />
+						),
+						<span className="ph-no-capture font-bold text-foreground break-words">
+							Cline wants to {mcpServerUse.type === "use_mcp_tool" ? "use a tool" : "access a resource"} on the{" "}
+							<code className="break-all">{mcpServerUse.serverName}</code> MCP server:
+						</span>,
+					]
+				case "completion_result":
+					return [
+						<span className="codicon codicon-check text-success mb-[-1.5px]" />,
+						<span className="text-success font-bold">Task Completed</span>,
+					]
+				case "api_req_started":
+					// API request rows no longer render the request payload/cost accordion.
+					// Thinking/reasoning is handled directly in the api_req_started renderer below.
+					return [null, null]
+				case "followup":
+					return [
+						<span className="codicon codicon-question text-foreground mb-[-1.5px]" />,
+						<span className="font-bold text-foreground">Cline has a question:</span>,
+					]
+				default:
+					return [null, null]
+			}
+		}, [
+			type,
+			cost,
+			apiRequestFailedMessage,
+			isCommandExecuting,
+			isCommandPending,
+			apiReqCancelReason,
+			isMcpServerResponding,
+			message.text,
+		])
+
+		const tool = useMemo(() => {
+			if (message.ask === "tool" || message.say === "tool") {
+				return JSON.parse(message.text || "{}") as ClineSayTool
+			}
+			return null
+		}, [message.ask, message.say, message.text])
+
+		const conditionalRulesInfo = useMemo(() => {
+			if (message.say !== "conditional_rules_applied" || !message.text) return null
+			try {
+				const parsed = JSON.parse(message.text) as unknown
+				if (!parsed || typeof parsed !== "object" || !Array.isArray((parsed as any).rules)) {
+					return null
+				}
+				return parsed as {
+					rules: Array<{ name: string; matchedConditions: Record<string, string[]> }>
+				}
+			} catch {
+				return null
+			}
+		}, [message.say, message.text])
+
+		// Helper function to check if file is an image
+		const isImageFile = (filePath: string): boolean => {
+			const imageExtensions = [".png", ".jpg", ".jpeg", ".webp"]
+			const extension = filePath.toLowerCase().split(".").pop()
+			return extension ? imageExtensions.includes(`.${extension}`) : false
+		}
+
+		if (conditionalRulesInfo) {
+			const names = conditionalRulesInfo.rules.map((r: { name: string }) => r.name).join(", ")
+			return (
+				<div className={HEADER_CLASSNAMES}>
+					<span style={{ fontWeight: "bold" }}>Conditional rules applied:</span>
+					<span className="ph-no-capture break-words whitespace-pre-wrap">{names}</span>
+				</div>
+			)
+		}
+
+		if (tool) {
+			const colorMap = {
+				red: "var(--vscode-errorForeground)",
+				yellow: "var(--vscode-editorWarning-foreground)",
+				green: "var(--vscode-charts-green)",
+			}
+			const toolIcon = (name: string, color?: string, rotation?: number, title?: string) => (
+				<span
+					className={`codicon codicon-${name} ph-no-capture`}
+					style={{
+						color: color ? colorMap[color as keyof typeof colorMap] || color : "var(--vscode-foreground)",
+						marginBottom: "-1.5px",
+						transform: rotation ? `rotate(${rotation}deg)` : undefined,
+					}}
+					title={title}
+				/>
+			)
+
+			switch (tool.tool) {
+				case "editedExistingFile":
+					const content = tool?.content || ""
+					const isApplyingPatch = content?.startsWith("%%bash") && !content.endsWith("*** End Patch\nEOF")
+					const editToolTitle = isApplyingPatch
+						? "Cline is creating patches to edit this file:"
+						: "Cline wants to edit this file:"
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<PencilIcon className="size-2" />
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This file is outside of your workspace")}
+								<span style={{ fontWeight: "bold" }}>{editToolTitle}</span>
+							</div>
+							{backgroundEditEnabled && tool.path && (tool.diff || tool.content) ? (
+								<DiffEditRow
+									isLoading={message.partial}
+									patch={tool.diff || tool.content!}
+									path={tool.path}
+									startLineNumbers={tool.startLineNumbers}
+								/>
+							) : (
+								<CodeAccordian
+									// isLoading={message.partial}
+									code={tool.content}
+									isExpanded={isExpanded}
+									onToggleExpand={handleToggle}
+									path={tool.path!}
+								/>
+							)}
+						</div>
+					)
+				case "fileDeleted":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<SquareMinusIcon className="size-2" />
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This file is outside of your workspace")}
+								<span style={{ fontWeight: "bold" }}>Cline wants to delete this file:</span>
+							</div>
+							<CodeAccordian
+								// isLoading={message.partial}
+								code={tool.content}
+								isExpanded={isExpanded}
+								onToggleExpand={handleToggle}
+								path={tool.path!}
+							/>
+						</div>
+					)
+				case "newFileCreated":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<FilePlus2Icon className="size-2" />
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This file is outside of your workspace")}
+								<span className="font-bold">Cline wants to create a new file:</span>
+							</div>
+							{backgroundEditEnabled && tool.path && tool.content ? (
+								<DiffEditRow patch={tool.content} path={tool.path} startLineNumbers={tool.startLineNumbers} />
+							) : (
+								<CodeAccordian
+									code={tool.content!}
+									isExpanded={isExpanded}
+									isLoading={message.partial}
+									onToggleExpand={handleToggle}
+									path={tool.path!}
+								/>
+							)}
+						</div>
+					)
+				case "readFile":
+					const isImage = isImageFile(tool.path || "")
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								{isImage ? <ImageUpIcon className="size-2" /> : <FileCode2Icon className="size-2" />}
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This file is outside of your workspace")}
+								<span className="font-bold">Cline wants to read this file:</span>
+							</div>
+							<div className="bg-code rounded-sm overflow-hidden border border-editor-group-border">
+								<div
+									className={cn("text-description flex items-center cursor-pointer select-none py-2 px-2.5", {
+										"cursor-default select-text": isImage,
+									})}
+									onClick={() => {
+										if (!isImage) {
+											FileServiceClient.openFile(StringRequest.create({ value: tool.content })).catch(
+												(err) => console.error("Failed to open file:", err),
+											)
+										}
+									}}>
+									{tool.path?.startsWith(".") && <span>.</span>}
+									{tool.path && !tool.path.startsWith(".") && <span>/</span>}
+									<span className="ph-no-capture whitespace-nowrap overflow-hidden text-ellipsis mr-2 text-left [direction: rtl]">
+										{cleanPathPrefix(tool.path ?? "") + "\u200E"}
+										{tool.readLineStart != null ? (
+											<span className="opacity-80">
+												{" "}
+												({tool.readLineStart}
+												{tool.readLineEnd != null ? `-${tool.readLineEnd}` : "+"})
+											</span>
+										) : null}
+									</span>
+									<div className="grow" />
+									{!isImage && <SquareArrowOutUpRightIcon className="size-2" />}
+								</div>
+							</div>
+						</div>
+					)
+				case "listFilesTopLevel":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								{toolIcon("folder-opened")}
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This is outside of your workspace")}
+								<span style={{ fontWeight: "bold" }}>
+									{message.type === "ask"
+										? "Cline wants to view the top level files in this directory:"
+										: "Cline viewed the top level files in this directory:"}
+								</span>
+							</div>
+							<CodeAccordian
+								code={tool.content!}
+								isExpanded={isExpanded}
+								language="shell-session"
+								onToggleExpand={handleToggle}
+								path={tool.path!}
+							/>
+						</div>
+					)
+				case "listFilesRecursive":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								{toolIcon("folder-opened")}
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This is outside of your workspace")}
+								<span style={{ fontWeight: "bold" }}>
+									{message.type === "ask"
+										? "Cline wants to recursively view all files in this directory:"
+										: "Cline recursively viewed all files in this directory:"}
+								</span>
+							</div>
+							<CodeAccordian
+								code={tool.content!}
+								isExpanded={isExpanded}
+								language="shell-session"
+								onToggleExpand={handleToggle}
+								path={tool.path!}
+							/>
+						</div>
+					)
+				case "listCodeDefinitionNames":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								{toolIcon("file-code")}
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This file is outside of your workspace")}
+								<span style={{ fontWeight: "bold" }}>
+									{message.type === "ask"
+										? "Cline wants to view source code definition names used in this directory:"
+										: "Cline viewed source code definition names used in this directory:"}
+								</span>
+							</div>
+							<CodeAccordian
+								code={tool.content!}
+								isExpanded={isExpanded}
+								onToggleExpand={handleToggle}
+								path={tool.path!}
+							/>
+						</div>
+					)
+				case "searchFiles":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								{toolIcon("search")}
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This is outside of your workspace")}
+								<span className="font-bold">
+									Cline wants to search this directory for <code className="break-all">{tool.regex}</code>:
+								</span>
+							</div>
+							<SearchResultsDisplay
+								content={tool.content!}
+								filePattern={tool.filePattern}
+								isExpanded={isExpanded}
+								onToggleExpand={handleToggle}
+								path={tool.path!}
+							/>
+						</div>
+					)
+				case "summarizeTask":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<FoldVerticalIcon className="size-2" />
+								<span className="font-bold">Cline is condensing the conversation:</span>
+							</div>
+							<div className="bg-code overflow-hidden border border-editor-group-border rounded-[3px]">
+								<div
+									aria-label={isExpanded ? "Collapse summary" : "Expand summary"}
+									className="text-description py-2 px-2.5 cursor-pointer select-none"
+									onClick={handleToggle}
+									onKeyDown={(e) => {
+										if (e.key === "Enter" || e.key === " ") {
+											e.preventDefault()
+											e.stopPropagation()
+											handleToggle()
+										}
+									}}
+									tabIndex={0}>
+									{isExpanded ? (
+										<div>
+											<div className="flex items-center mb-2">
+												<span className="font-bold mr-1">Summary:</span>
+												<div className="grow" />
+												<ChevronDownIcon className="my-0.5 shrink-0 size-4" />
+											</div>
+											<span className="ph-no-capture break-words whitespace-pre-wrap">{tool.content}</span>
+										</div>
+									) : (
+										<div className="flex items-center">
+											<span className="ph-no-capture whitespace-nowrap overflow-hidden text-ellipsis text-left flex-1 mr-2 [direction:rtl]">
+												{tool.content + "\u200E"}
+											</span>
+											<ChevronRightIcon className="my-0.5 shrink-0 size-4" />
+										</div>
+									)}
+								</div>
+							</div>
+						</div>
+					)
+				case "webFetch":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<Link2Icon className="size-2" />
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This URL is external")}
+								<span className="font-bold">
+									{message.type === "ask"
+										? "Cline wants to fetch content from this URL:"
+										: "Cline fetched content from this URL:"}
+								</span>
+							</div>
+							<div
+								className="bg-code rounded-xs overflow-hidden border border-editor-group-border py-2 px-2.5 cursor-pointer select-none"
+								onClick={() => {
+									// Open the URL in the default browser using gRPC
+									if (tool.path) {
+										UiServiceClient.openUrl(StringRequest.create({ value: tool.path })).catch((err) => {
+											console.error("Failed to open URL:", err)
+										})
+									}
+								}}>
+								<span className="ph-no-capture whitespace-nowrap overflow-hidden text-ellipsis mr-2 [direction:rtl] text-left text-link underline">
+									{tool.path + "\u200E"}
+								</span>
+							</div>
+						</div>
+					)
+				case "webSearch":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<SearchIcon className="size-2 rotate-90" />
+								{tool.operationIsLocatedInWorkspace === false &&
+									toolIcon("sign-out", "yellow", -90, "This search is external")}
+								<span className="font-bold">
+									{message.type === "ask"
+										? "Cline wants to search the web for:"
+										: "Cline searched the web for:"}
+								</span>
+							</div>
+							<div className="bg-code border border-editor-group-border overflow-hidden rounded-xs select-text py-[9px] px-2.5">
+								<span className="ph-no-capture whitespace-nowrap overflow-hidden text-ellipsis mr-2 text-left [direction:rtl]">
+									{tool.path + "\u200E"}
+								</span>
+							</div>
+						</div>
+					)
+				case "useSkill":
+					return (
+						<div>
+							<div className={HEADER_CLASSNAMES}>
+								<LightbulbIcon className="size-2" />
+								<span className="font-bold">Cline loaded the skill:</span>
+							</div>
+							<div className="bg-code border border-editor-group-border overflow-hidden rounded-xs py-[9px] px-2.5">
+								<span className="ph-no-capture font-medium">{tool.path}</span>
+							</div>
+						</div>
+					)
+				default:
+					return <InvisibleSpacer />
+			}
+		}
+
+		// Reset output expansion state when command stops (completes or is cancelled)
+		useEffect(() => {
+			// If command was executing and now isn't, clean up
+			if (isCommandMessage && prevCommandExecutingRef.current && !isCommandExecuting) {
+				setIsOutputFullyExpanded(false)
+			}
+
+			// Update ref for next render
+			prevCommandExecutingRef.current = isCommandExecuting
+		}, [isCommandMessage, isCommandExecuting])
+
+		// Auto-expand when command starts executing (only if running > 500ms)
+		useEffect(() => {
+			if (isCommandMessage && isCommandExecuting && !isExpanded) {
+				// Wait 500ms before auto-expanding to avoid animating fast commands
+				const timer = setTimeout(() => {
+					// Expand after 500ms
+					onToggleExpand(message.ts, { preserveAutoScroll: true })
+				}, 500)
+
+				return () => clearTimeout(timer)
+			}
+		}, [isCommandMessage, isCommandExecuting, isExpanded, onToggleExpand, message.ts])
+
+		if (message.ask === "command" || message.say === "command") {
+			return (
+				<CommandOutputRow
+					icon={icon}
+					isBackgroundExec={vscodeTerminalExecutionMode === "backgroundExec"}
+					isCommandCompleted={isCommandCompleted}
+					isCommandExecuting={isCommandExecuting}
+					isCommandPending={isCommandPending}
+					isOutputFullyExpanded={isOutputFullyExpanded}
+					message={message}
+					onCancelCommand={onCancelCommand}
+					onOutputChange={onLastRowContentChange}
+					setIsOutputFullyExpanded={setIsOutputFullyExpanded}
+					title={title}
+				/>
+			)
+		}
+
+		if (message.ask === "use_subagents" || message.say === "use_subagents") {
+			return <SubagentStatusRow isLast={isLast} lastModifiedMessage={lastModifiedMessage} message={message} />
+		}
+
+		if (message.ask === "use_mcp_server" || message.say === "use_mcp_server") {
+			const useMcpServer = JSON.parse(message.text || "{}") as ClineAskUseMcpServer
+			const server = mcpServers.find((server) => server.name === useMcpServer.serverName)
+			return (
+				<div>
+					<div className={HEADER_CLASSNAMES}>
+						{icon}
+						{title}
+					</div>
+
+					<div className="bg-code rounded-xs py-2 px-2.5 mt-2">
+						{useMcpServer.type === "access_mcp_resource" && (
+							<McpResourceRow
+								item={{
+									...(findMatchingResourceOrTemplate(
+										useMcpServer.uri || "",
+										server?.resources,
+										server?.resourceTemplates,
+									) || {
+										name: "",
+										mimeType: "",
+										description: "",
+									}),
+									uri: useMcpServer.uri || "",
+								}}
+							/>
+						)}
+
+						{useMcpServer.type === "use_mcp_tool" && (
+							<div>
+								<div onClick={(e) => e.stopPropagation()}>
+									<McpToolRow
+										serverName={useMcpServer.serverName}
+										tool={{
+											name: useMcpServer.toolName || "",
+											description:
+												server?.tools?.find((tool) => tool.name === useMcpServer.toolName)?.description ||
+												"",
+											autoApprove:
+												server?.tools?.find((tool) => tool.name === useMcpServer.toolName)?.autoApprove ||
+												false,
+										}}
+									/>
+								</div>
+								{useMcpServer.arguments && useMcpServer.arguments !== "{}" && (
+									<div className="mt-2">
+										<div className="mb-1 opacity-80 uppercase">Arguments</div>
+										<CodeAccordian
+											code={useMcpServer.arguments}
+											isExpanded={true}
+											language="json"
+											onToggleExpand={handleToggle}
+										/>
+									</div>
+								)}
+							</div>
+						)}
+					</div>
+				</div>
+			)
+		}
+
+		switch (message.type) {
+			case "say":
+				switch (message.say) {
+					case "api_req_started":
+						return (
+							<RequestStartRow
+								apiReqStreamingFailedMessage={apiReqStreamingFailedMessage}
+								apiRequestFailedMessage={apiRequestFailedMessage}
+								clineMessages={clineMessages}
+								cost={cost}
+								handleToggle={handleToggle}
+								isExpanded={isExpanded}
+								message={message}
+								mode={mode}
+								reasoningContent={reasoningContent}
+								responseStarted={responseStarted}
+							/>
+						)
+					case "api_req_finished":
+						return <InvisibleSpacer /> // we should never see this message type
+					case "mcp_server_response":
+						return <McpResponseDisplay responseText={message.text || ""} />
+					case "mcp_notification":
+						return (
+							<div className="flex items-start gap-2 py-2.5 px-3 bg-quote rounded-sm text-base text-foreground opacity-90 mb-2">
+								<BellIcon className="mt-0.5 size-2 text-notification-foreground shrink-0" />
+								<div className="break-words flex-1">
+									<span className="font-medium">MCP Notification: </span>
+									<span className="ph-no-capture">{message.text}</span>
+								</div>
+							</div>
+						)
+					case "text": {
+						return (
+							<WithCopyButton
+								onMouseUp={handleMouseUp}
+								position="bottom-right"
+								ref={contentRef}
+								textToCopy={message.text}>
+								<div className="flex items-center">
+									<div className={cn("flex-1 min-w-0 pl-1")}>
+										<MarkdownRow markdown={message.text} showCursor={false} />
+									</div>
+								</div>
+								{quoteButtonState.visible && (
+									<QuoteButton
+										left={quoteButtonState.left}
+										onClick={handleQuoteClick}
+										top={quoteButtonState.top}
+									/>
+								)}
+							</WithCopyButton>
+						)
+					}
+					case "reasoning": {
+						const isReasoningStreaming = message.partial === true
+						const hasReasoningText = !!message.text?.trim()
+						// Show feature tips throughout the entire thinking/reasoning phase
+						const showFeatureTip = isReasoningStreaming
+						return (
+							<div>
+								<ThinkingRow
+									isExpanded={(isReasoningStreaming && hasReasoningText) || isExpanded}
+									isStreaming={isReasoningStreaming}
+									isVisible={true}
+									onToggle={isReasoningStreaming ? undefined : handleToggle}
+									reasoningContent={message.text}
+									showChevron={!isReasoningStreaming || hasReasoningText}
+									showTitle={true}
+									title={isReasoningStreaming ? "Thinking..." : "Thinking"}
+								/>
+								{isReasoningStreaming && showFeatureTips !== false && <FeatureTip />}
+							</div>
+						)
+					}
+					case "user_feedback":
+						return (
+							<UserMessage
+								canRestoreWorkspace={canRestoreWorkspaceFromMessage(clineMessages, message.ts)}
+								files={message.files}
+								images={message.images}
+								messageTs={message.ts}
+								sendMessageFromChatRow={sendMessageFromChatRow}
+								text={message.text}
+							/>
+						)
+					case "user_feedback_diff":
+						const tool = JSON.parse(message.text || "{}") as ClineSayTool
+						return (
+							<div className="w-full -mt-2.5">
+								<CodeAccordian
+									diff={tool.diff!}
+									isExpanded={isExpanded}
+									isFeedback={true}
+									onToggleExpand={handleToggle}
+								/>
+							</div>
+						)
+					case "error":
+						return <ErrorRow errorType="error" message={message} />
+					case "diff_error":
+						return <ErrorRow errorType="diff_error" message={message} />
+					case "clineignore_error":
+						return <ErrorRow errorType="clineignore_error" message={message} />
+					case "load_mcp_documentation":
+						return (
+							<div className="text-foreground flex items-center opacity-70 text-[12px] py-1 px-0">
+								<i className="codicon codicon-book mr-1.5" />
+								Loading MCP documentation
+							</div>
+						)
+					case "completion_result":
+						const hasChanges = message.text?.endsWith(COMPLETION_RESULT_CHANGES_FLAG) ?? false
+						const text = hasChanges ? message.text?.slice(0, -COMPLETION_RESULT_CHANGES_FLAG.length) : message.text
+
+						return (
+							<CompletionOutputRow
+								handleQuoteClick={handleQuoteClick}
+								headClassNames={HEADER_CLASSNAMES}
+								quoteButtonState={quoteButtonState}
+								text={text || ""}
+							/>
+						)
+					case "shell_integration_warning":
+						return (
+							<div className="flex flex-col bg-warning/20 p-2 rounded-xs border border-error">
+								<div className="flex items-center mb-1">
+									<TriangleAlertIcon className="mr-2 size-2 stroke-3 text-error" />
+									<span className="font-medium text-foreground">Shell Integration Unavailable</span>
+								</div>
+								<div className="text-foreground opacity-80">
+									Cline may have trouble viewing the command's output. Please update VSCode (
+									<code>CMD/CTRL + Shift + P</code> → "Update") and make sure you're using a supported shell:
+									zsh, bash, fish, or PowerShell (<code>CMD/CTRL + Shift + P</code> → "Terminal: Select Default
+									Profile").
+									<a
+										className="px-1"
+										href="https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Shell-Integration-Unavailable">
+										Still having trouble?
+									</a>
+								</div>
+							</div>
+						)
+					case "error_retry":
+						try {
+							const retryInfo = JSON.parse(message.text || "{}")
+							const { attempt, maxAttempts, delaySeconds, failed, errorMessage } = retryInfo
+							const isFailed = failed === true
+
+							return (
+								<div className="flex flex-col gap-2">
+									{errorMessage && (
+										<p className="m-0 whitespace-pre-wrap text-error wrap-anywhere text-xs">{errorMessage}</p>
+									)}
+									<div className="flex flex-col bg-quote p-0 rounded-[3px] text-[12px] p-3">
+										<div className="flex items-center mb-1">
+											{isFailed && !isRequestInProgress ? (
+												<TriangleAlertIcon className="mr-2 size-2" />
+											) : (
+												<RefreshCwIcon className="mr-2 size-2 animate-spin" />
+											)}
+											<span className="font-medium text-foreground">
+												{isFailed ? "Auto-Retry Failed" : "Auto-Retry in Progress"}
+											</span>
+										</div>
+										<div className="text-foreground opacity-80">
+											{isFailed ? (
+												<span>
+													Auto-retry failed after <strong>{maxAttempts}</strong> attempts. Manual
+													intervention required.
+												</span>
+											) : (
+												<span>
+													Attempt <strong>{attempt}</strong> of <strong>{maxAttempts}</strong> -
+													Retrying in {delaySeconds} seconds...
+												</span>
+											)}
+										</div>
+									</div>
+								</div>
+							)
+						} catch (_e) {
+							// Fallback if JSON parsing fails
+							return (
+								<div className="text-foreground">
+									<MarkdownRow markdown={message.text} />
+								</div>
+							)
+						}
+					case "hook_status":
+						return <HookMessage CommandOutput={CommandOutputContent} message={message} />
+					case "hook_output_stream":
+						// hook_output_stream messages are combined with hook_status messages, so we don't render them separately
+						return <InvisibleSpacer />
+					case "subagent":
+						return <SubagentStatusRow isLast={isLast} lastModifiedMessage={lastModifiedMessage} message={message} />
+					case "shell_integration_warning_with_suggestion":
+						const isBackgroundModeEnabled = vscodeTerminalExecutionMode === "backgroundExec"
+						return (
+							<div className="p-2 bg-link/10 border border-link/30 rounded-xs">
+								<div className="flex items-center mb-1">
+									<LightbulbIcon className="mr-1.5 size-2 text-link" />
+									<span className="font-medium text-foreground">Shell integration issues</span>
+								</div>
+								<div className="text-foreground opacity-90 mb-2">
+									Since you're experiencing repeated shell integration issues, we recommend switching to
+									Background Terminal mode for better reliability.
+								</div>
+								<button
+									className={cn(
+										"bg-button-background text-button-foreground border-0 rounded-xs py-1.5 px-3 text-[12px] flex items-center gap-1.5 cursor-pointer hover:bg-button-hover",
+										{
+											"cursor-default opacity-80 bg-success": isBackgroundModeEnabled,
+										},
+									)}
+									disabled={isBackgroundModeEnabled}
+									onClick={async () => {
+										try {
+											// Enable background terminal execution mode
+											await UiServiceClient.setTerminalExecutionMode(BooleanRequest.create({ value: true }))
+										} catch (error) {
+											console.error("Failed to enable background terminal:", error)
+										}
+									}}>
+									<SettingsIcon className="size-2" />
+									{isBackgroundModeEnabled
+										? "Background Terminal Enabled"
+										: "Enable Background Terminal (Recommended)"}
+								</button>
+							</div>
+						)
+					case "task_progress":
+						return <InvisibleSpacer /> // task_progress messages should be displayed in TaskHeader only, not in chat
+					default:
+						return (
+							<div>
+								{title && (
+									<div className={HEADER_CLASSNAMES}>
+										{icon}
+										{title}
+									</div>
+								)}
+								<div className="pt-1">
+									<MarkdownRow markdown={message.text} />
+								</div>
+							</div>
+						)
+				}
+			case "ask":
+				switch (message.ask) {
+					case "mistake_limit_reached":
+						return <ErrorRow errorType="mistake_limit_reached" message={message} />
+					case "completion_result":
+						if (message.text) {
+							const hasChanges = message.text.endsWith(COMPLETION_RESULT_CHANGES_FLAG) ?? false
+							const text = hasChanges ? message.text.slice(0, -COMPLETION_RESULT_CHANGES_FLAG.length) : message.text
+							return (
+								<CompletionOutputRow
+									handleQuoteClick={handleQuoteClick}
+									headClassNames={HEADER_CLASSNAMES}
+									quoteButtonState={quoteButtonState}
+									text={text || ""}
+								/>
+							)
+						}
+						// Virtuoso cannot handle zero-height items; render a spacer instead of null
+						return <InvisibleSpacer />
+					case "followup":
+						let question: string | undefined
+						let options: string[] | undefined
+						let selected: string | undefined
+						try {
+							const parsedMessage = JSON.parse(message.text || "{}") as ClineAskQuestion
+							question = parsedMessage.question
+							options = parsedMessage.options
+							selected = parsedMessage.selected
+						} catch (_e) {
+							// legacy messages would pass question directly
+							question = message.text
+						}
+
+						return (
+							<div>
+								{title && (
+									<div className={HEADER_CLASSNAMES}>
+										{icon}
+										{title}
+									</div>
+								)}
+								<WithCopyButton
+									className="pt-1"
+									onMouseUp={handleMouseUp}
+									position="bottom-right"
+									ref={contentRef}
+									textToCopy={question}>
+									<MarkdownRow markdown={question} />
+									{quoteButtonState.visible && (
+										<QuoteButton
+											left={quoteButtonState.left}
+											onClick={() => {
+												handleQuoteClick()
+											}}
+											top={quoteButtonState.top}
+										/>
+									)}
+								</WithCopyButton>
+								<div className="pt-3">
+									<OptionsButtons
+										inputValue={inputValue}
+										isActive={
+											(isLast && lastModifiedMessage?.ask === "followup") ||
+											(!selected && options && options.length > 0)
+										}
+										options={options}
+										selected={selected}
+									/>
+								</div>
+							</div>
+						)
+					case "new_task":
+						return (
+							<div>
+								<div className={HEADER_CLASSNAMES}>
+									<FilePlus2Icon className="size-2" />
+									<span className="text-foreground font-bold">Cline wants to start a new task:</span>
+								</div>
+								<NewTaskPreview context={message.text || ""} />
+							</div>
+						)
+					case "condense":
+						return (
+							<div>
+								<div className={HEADER_CLASSNAMES}>
+									<FilePlus2Icon className="size-2" />
+									<span className="text-foreground font-bold">Cline wants to condense your conversation:</span>
+								</div>
+								<NewTaskPreview context={message.text || ""} />
+							</div>
+						)
+					case "report_bug":
+						return (
+							<div>
+								<div className={HEADER_CLASSNAMES}>
+									<FilePlus2Icon className="size-2" />
+									<span className="text-foreground font-bold">Cline wants to create a Github issue:</span>
+								</div>
+								<ReportBugPreview data={message.text || ""} />
+							</div>
+						)
+					case "plan_mode_respond": {
+						let response: string | undefined
+						let options: string[] | undefined
+						let selected: string | undefined
+						try {
+							const parsedMessage = JSON.parse(message.text || "{}") as ClinePlanModeResponse
+							response = parsedMessage.response
+							options = parsedMessage.options
+							selected = parsedMessage.selected
+						} catch (_e) {
+							// legacy messages would pass response directly
+							response = message.text
+						}
+						return (
+							<div>
+								<PlanCompletionOutputRow
+									headClassNames={HEADER_CLASSNAMES}
+									text={response || message.text || ""}
+								/>
+								<OptionsButtons
+									inputValue={inputValue}
+									isActive={
+										(isLast && lastModifiedMessage?.ask === "plan_mode_respond") ||
+										(!selected && options && options.length > 0)
+									}
+									options={options}
+									selected={selected}
+								/>
+							</div>
+						)
+					}
+					default:
+						return <InvisibleSpacer />
+				}
+		}
+	},
+)
diff --git a/apps/vscode/webview-ui/src/components/chat/ChatTextArea.tsx b/apps/vscode/webview-ui/src/components/chat/ChatTextArea.tsx
new file mode 100644
index 0000000..f332fa7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ChatTextArea.tsx
@@ -0,0 +1,1667 @@
+import { mentionRegex, mentionRegexGlobal } from "@shared/context-mentions"
+import { StringRequest } from "@shared/proto/cline/common"
+import { FileSearchRequest, FileSearchType, RelativePathsRequest } from "@shared/proto/cline/file"
+import { PlanActMode, TogglePlanActModeRequest } from "@shared/proto/cline/state"
+import { type SlashCommand } from "@shared/slashCommands"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import { AtSignIcon, PlusIcon } from "lucide-react"
+import type React from "react"
+import { forwardRef, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react"
+import DynamicTextArea from "react-textarea-autosize"
+import styled from "styled-components"
+import ContextMenu from "@/components/chat/ContextMenu"
+import { CHAT_CONSTANTS } from "@/components/chat/chat-view/constants"
+import SlashCommandMenu from "@/components/chat/SlashCommandMenu"
+import Thumbnails from "@/components/common/Thumbnails"
+import { getModeSpecificFields } from "@/components/settings/utils/providerUtils"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { usePlatform } from "@/context/PlatformContext"
+import { useNormalizedApiConfiguration } from "@/hooks/useNormalizedApiConfiguration"
+import { cn } from "@/lib/utils"
+import { FileServiceClient, StateServiceClient } from "@/services/grpc-client"
+import {
+	ContextMenuOptionType,
+	getContextMenuOptionIndex,
+	getContextMenuOptions,
+	insertMention,
+	insertMentionDirectly,
+	removeMention,
+	type SearchResult,
+	shouldShowContextMenu,
+} from "@/utils/context-mentions"
+import { useMetaKeyDetection, useShortcut } from "@/utils/hooks"
+import { isSafari } from "@/utils/platformUtils"
+import {
+	getMatchingSlashCommands,
+	insertSlashCommand,
+	removeSlashCommand,
+	shouldShowSlashCommandsMenu,
+	slashCommandDeleteRegex,
+	slashCommandRegexGlobal,
+	validateSlashCommand,
+} from "@/utils/slash-commands"
+import ClineRulesToggleModal from "../cline-rules/ClineRulesToggleModal"
+import ServersToggleModal from "./ServersToggleModal"
+
+const { MAX_IMAGES_AND_FILES_PER_MESSAGE } = CHAT_CONSTANTS
+
+const getImageDimensions = (dataUrl: string): Promise<{ width: number; height: number }> => {
+	return new Promise((resolve, reject) => {
+		const img = new Image()
+		img.onload = () => {
+			if (img.naturalWidth > 7500 || img.naturalHeight > 7500) {
+				reject(new Error("Image dimensions exceed maximum allowed size of 7500px."))
+			} else {
+				resolve({ width: img.naturalWidth, height: img.naturalHeight })
+			}
+		}
+		img.onerror = (err) => {
+			console.error("Failed to load image for dimension check:", err)
+			reject(new Error("Failed to load image to check dimensions."))
+		}
+		img.src = dataUrl
+	})
+}
+
+// Set to "File" option by default
+const DEFAULT_CONTEXT_MENU_OPTION = getContextMenuOptionIndex(ContextMenuOptionType.File)
+
+interface ChatTextAreaProps {
+	inputValue: string
+	activeQuote: string | null
+	setInputValue: (value: string) => void
+	sendingDisabled: boolean
+	placeholderText: string
+	selectedFiles: string[]
+	selectedImages: string[]
+	setSelectedImages: React.Dispatch<React.SetStateAction<string[]>>
+	setSelectedFiles: React.Dispatch<React.SetStateAction<string[]>>
+	onSend: () => void
+	onSelectFilesAndImages: () => void
+	shouldDisableFilesAndImages: boolean
+	onHeightChange?: (height: number) => void
+	onFocusChange?: (isFocused: boolean) => void
+}
+
+interface GitCommit {
+	type: ContextMenuOptionType.Git
+	value: string
+	label: string
+	description: string
+}
+
+const PLAN_MODE_COLOR = "var(--vscode-activityWarningBadge-background)"
+const ACT_MODE_COLOR = "var(--vscode-focusBorder)"
+
+const SwitchContainer = styled.div<{ disabled: boolean }>`
+	display: flex;
+	align-items: center;
+	background-color: transparent;
+	border: 1px solid var(--vscode-input-border);
+	border-radius: 12px;
+	overflow: hidden;
+	cursor: ${(props) => (props.disabled ? "not-allowed" : "pointer")};
+	opacity: ${(props) => (props.disabled ? 0.5 : 1)};
+	transform: scale(1);
+	transform-origin: right center;
+	margin-left: 0;
+	user-select: none; // Prevent text selection
+`
+
+const Slider = styled.div.withConfig({
+	shouldForwardProp: (prop) => !["isAct", "isPlan"].includes(prop),
+})<{ isAct: boolean; isPlan?: boolean }>`
+	position: absolute;
+	height: 100%;
+	width: 50%;
+	background-color: ${(props) => (props.isPlan ? PLAN_MODE_COLOR : ACT_MODE_COLOR)};
+	transition: transform 0.2s ease;
+	transform: translateX(${(props) => (props.isAct ? "100%" : "0%")});
+`
+
+const ButtonGroup = styled.div`
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	flex: 1;
+	min-width: 0;
+`
+
+const ButtonContainer = styled.div`
+	display: flex;
+	align-items: center;
+	gap: 3px;
+	font-size: 10px;
+	white-space: nowrap;
+	min-width: 0;
+	width: 100%;
+`
+
+const ModelContainer = styled.div`
+	position: relative;
+	display: flex;
+	flex: 1;
+	min-width: 0;
+`
+
+const ModelButtonWrapper = styled.div`
+	display: inline-flex; // Make it shrink to content
+	min-width: 0; // Allow shrinking
+	max-width: 100%; // Don't overflow parent
+`
+
+const ModelDisplayButton = styled.a<{ isActive?: boolean; disabled?: boolean }>`
+	padding: 0px 0px;
+	height: 20px;
+	width: 100%;
+	min-width: 0;
+	cursor: ${(props) => (props.disabled ? "not-allowed" : "pointer")};
+	text-decoration: ${(props) => (props.isActive ? "underline" : "none")};
+	color: ${(props) => (props.isActive ? "var(--vscode-foreground)" : "var(--vscode-descriptionForeground)")};
+	display: flex;
+	align-items: center;
+	font-size: 10px;
+	outline: none;
+	user-select: none;
+	opacity: ${(props) => (props.disabled ? 0.5 : 1)};
+	pointer-events: ${(props) => (props.disabled ? "none" : "auto")};
+
+	&:hover,
+	&:focus {
+		color: ${(props) => (props.disabled ? "var(--vscode-descriptionForeground)" : "var(--vscode-foreground)")};
+		text-decoration: ${(props) => (props.disabled ? "none" : "underline")};
+		outline: none;
+	}
+
+	&:active {
+		color: ${(props) => (props.disabled ? "var(--vscode-descriptionForeground)" : "var(--vscode-foreground)")};
+		text-decoration: ${(props) => (props.disabled ? "none" : "underline")};
+		outline: none;
+	}
+
+	&:focus-visible {
+		outline: none;
+	}
+`
+
+const ModelButtonContent = styled.div`
+	width: 100%;
+	min-width: 0;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+`
+
+const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
+	(
+		{
+			inputValue,
+			setInputValue,
+			sendingDisabled,
+			placeholderText,
+			selectedFiles,
+			selectedImages,
+			setSelectedImages,
+			setSelectedFiles,
+			onSend,
+			onSelectFilesAndImages,
+			shouldDisableFilesAndImages,
+			onHeightChange,
+			onFocusChange,
+		},
+		ref,
+	) => {
+		const {
+			mode,
+			apiConfiguration,
+			openRouterModels,
+			platform,
+			localWorkflowToggles,
+			globalWorkflowToggles,
+			remoteWorkflowToggles,
+			remoteConfigSettings,
+			navigateToSettingsModelPicker,
+			mcpServers,
+		} = useExtensionState()
+		const [isTextAreaFocused, setIsTextAreaFocused] = useState(false)
+		const [isDraggingOver, setIsDraggingOver] = useState(false)
+		const [gitCommits, setGitCommits] = useState<GitCommit[]>([])
+		const [showSlashCommandsMenu, setShowSlashCommandsMenu] = useState(false)
+		const [selectedSlashCommandsIndex, setSelectedSlashCommandsIndex] = useState(0)
+		const [slashCommandsQuery, setSlashCommandsQuery] = useState("")
+		const slashCommandsMenuContainerRef = useRef<HTMLDivElement>(null)
+
+		const [thumbnailsHeight, setThumbnailsHeight] = useState(0)
+		const [textAreaBaseHeight, setTextAreaBaseHeight] = useState<number | undefined>(undefined)
+		const [showContextMenu, setShowContextMenu] = useState(false)
+		const [cursorPosition, setCursorPosition] = useState(0)
+		const [searchQuery, setSearchQuery] = useState("")
+		const textAreaRef = useRef<HTMLTextAreaElement | null>(null)
+		const [isMouseDownOnMenu, setIsMouseDownOnMenu] = useState(false)
+		const highlightLayerRef = useRef<HTMLDivElement>(null)
+		const [selectedMenuIndex, setSelectedMenuIndex] = useState(-1)
+		const [selectedType, setSelectedType] = useState<ContextMenuOptionType | null>(null)
+		const [justDeletedSpaceAfterMention, setJustDeletedSpaceAfterMention] = useState(false)
+		const [justDeletedSpaceAfterSlashCommand, setJustDeletedSpaceAfterSlashCommand] = useState(false)
+		const [intendedCursorPosition, setIntendedCursorPosition] = useState<number | null>(null)
+		const contextMenuContainerRef = useRef<HTMLDivElement>(null)
+
+		const [shownTooltipMode, setShownTooltipMode] = useState<Mode | null>(null)
+		const [pendingInsertions, setPendingInsertions] = useState<string[]>([])
+		const _shiftHoldTimerRef = useRef<NodeJS.Timeout | null>(null)
+		const [showUnsupportedFileError, setShowUnsupportedFileError] = useState(false)
+		const unsupportedFileTimerRef = useRef<NodeJS.Timeout | null>(null)
+		const [showDimensionError, setShowDimensionError] = useState(false)
+		const dimensionErrorTimerRef = useRef<NodeJS.Timeout | null>(null)
+
+		const [fileSearchResults, setFileSearchResults] = useState<SearchResult[]>([])
+		const [searchLoading, setSearchLoading] = useState(false)
+		const [, metaKeyChar] = useMetaKeyDetection(platform)
+		const { selectedProvider, selectedModelId } = useNormalizedApiConfiguration(mode)
+
+		// Fetch git commits when Git is selected or when typing a hash
+		useEffect(() => {
+			if (selectedType === ContextMenuOptionType.Git || /^[a-f0-9]+$/i.test(searchQuery)) {
+				FileServiceClient.searchCommits(StringRequest.create({ value: searchQuery || "" }))
+					.then((response) => {
+						if (response.commits) {
+							const commits: GitCommit[] = response.commits.map(
+								(commit: { hash: string; shortHash: string; subject: string; author: string; date: string }) => ({
+									type: ContextMenuOptionType.Git,
+									value: commit.hash,
+									label: commit.subject,
+									description: `${commit.shortHash} by ${commit.author} on ${commit.date}`,
+								}),
+							)
+							setGitCommits(commits)
+						}
+					})
+					.catch((error) => {
+						console.error("Error searching commits:", error)
+					})
+			}
+		}, [selectedType, searchQuery])
+
+		const queryItems = useMemo(() => {
+			return [
+				{ type: ContextMenuOptionType.Problems, value: "problems" },
+				{ type: ContextMenuOptionType.Terminal, value: "terminal" },
+				...gitCommits,
+			]
+		}, [gitCommits])
+
+		useEffect(() => {
+			const handleClickOutside = (event: MouseEvent) => {
+				if (contextMenuContainerRef.current && !contextMenuContainerRef.current.contains(event.target as Node)) {
+					setShowContextMenu(false)
+				}
+			}
+
+			if (showContextMenu) {
+				document.addEventListener("mousedown", handleClickOutside)
+			}
+
+			return () => {
+				document.removeEventListener("mousedown", handleClickOutside)
+			}
+		}, [showContextMenu, setShowContextMenu])
+
+		useEffect(() => {
+			const handleClickOutsideSlashMenu = (event: MouseEvent) => {
+				if (
+					slashCommandsMenuContainerRef.current &&
+					!slashCommandsMenuContainerRef.current.contains(event.target as Node)
+				) {
+					setShowSlashCommandsMenu(false)
+				}
+			}
+
+			if (showSlashCommandsMenu) {
+				document.addEventListener("mousedown", handleClickOutsideSlashMenu)
+			}
+
+			return () => {
+				document.removeEventListener("mousedown", handleClickOutsideSlashMenu)
+			}
+		}, [showSlashCommandsMenu])
+
+		const handleMentionSelect = useCallback(
+			(type: ContextMenuOptionType, value?: string) => {
+				if (type === ContextMenuOptionType.NoResults) {
+					return
+				}
+
+				if (
+					type === ContextMenuOptionType.File ||
+					type === ContextMenuOptionType.Folder ||
+					type === ContextMenuOptionType.Git
+				) {
+					if (!value) {
+						setSelectedType(type)
+						setSearchQuery("")
+						setSelectedMenuIndex(0)
+
+						// Trigger search with the selected type
+						if (type === ContextMenuOptionType.File || type === ContextMenuOptionType.Folder) {
+							setSearchLoading(true)
+
+							// Map ContextMenuOptionType to FileSearchType enum
+							let searchType: FileSearchType | undefined
+							if (type === ContextMenuOptionType.File) {
+								searchType = FileSearchType.FILE
+							} else if (type === ContextMenuOptionType.Folder) {
+								searchType = FileSearchType.FOLDER
+							}
+
+							const myToken = ++latestSearchTokenRef.current
+							FileServiceClient.searchFiles(
+								FileSearchRequest.create({
+									query: "",
+									mentionsRequestId: String(myToken),
+									selectedType: searchType,
+								}),
+							)
+								.then((results) => {
+									if (myToken !== latestSearchTokenRef.current) {
+										// Stale response — a newer search has been issued.
+										return
+									}
+									setFileSearchResults((results.results || []) as SearchResult[])
+									setSearchLoading(false)
+								})
+								.catch((error) => {
+									if (myToken !== latestSearchTokenRef.current) {
+										return
+									}
+									console.error("Error searching files:", error)
+									setFileSearchResults([])
+									setSearchLoading(false)
+								})
+						}
+						return
+					}
+				}
+
+				setShowContextMenu(false)
+				setSelectedType(null)
+				const queryLength = searchQuery.length
+				setSearchQuery("")
+
+				if (textAreaRef.current) {
+					let insertValue = value || ""
+					if (type === ContextMenuOptionType.URL) {
+						insertValue = value || ""
+					} else if (type === ContextMenuOptionType.File || type === ContextMenuOptionType.Folder) {
+						insertValue = value || ""
+					} else if (type === ContextMenuOptionType.Problems) {
+						insertValue = "problems"
+					} else if (type === ContextMenuOptionType.Terminal) {
+						insertValue = "terminal"
+					} else if (type === ContextMenuOptionType.Git) {
+						insertValue = value || ""
+					}
+
+					const { newValue, mentionIndex } = insertMention(
+						textAreaRef.current.value,
+						cursorPosition,
+						insertValue,
+						queryLength,
+					)
+
+					setInputValue(newValue)
+					const newCursorPosition = newValue.indexOf(" ", mentionIndex + insertValue.length) + 1
+					setCursorPosition(newCursorPosition)
+					setIntendedCursorPosition(newCursorPosition)
+					// textAreaRef.current.focus()
+
+					// scroll to cursor
+					setTimeout(() => {
+						if (textAreaRef.current) {
+							textAreaRef.current.blur()
+							textAreaRef.current.focus()
+						}
+					}, 0)
+				}
+			},
+			[setInputValue, cursorPosition, searchQuery],
+		)
+
+		const handleSlashCommandsSelect = useCallback(
+			(command: SlashCommand) => {
+				setShowSlashCommandsMenu(false)
+				const queryLength = slashCommandsQuery.length
+				setSlashCommandsQuery("")
+
+				if (textAreaRef.current) {
+					const { newValue, commandIndex } = insertSlashCommand(
+						textAreaRef.current.value,
+						command.name,
+						queryLength,
+						cursorPosition,
+					)
+					const newCursorPosition = newValue.indexOf(" ", commandIndex + 1 + command.name.length) + 1
+
+					setInputValue(newValue)
+					setCursorPosition(newCursorPosition)
+					setIntendedCursorPosition(newCursorPosition)
+
+					setTimeout(() => {
+						if (textAreaRef.current) {
+							textAreaRef.current.blur()
+							textAreaRef.current.focus()
+						}
+					}, 0)
+				}
+			},
+			[setInputValue, slashCommandsQuery, cursorPosition],
+		)
+		const handleKeyDown = useCallback(
+			(event: React.KeyboardEvent<HTMLTextAreaElement>) => {
+				const isSelectAllShortcut =
+					(event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key.toLowerCase() === "a"
+				if (isSelectAllShortcut) {
+					event.preventDefault()
+					event.stopPropagation()
+					const textArea = event.currentTarget
+					textArea.setSelectionRange(0, textArea.value.length)
+					setCursorPosition(0)
+					return
+				}
+
+				if (showSlashCommandsMenu) {
+					if (event.key === "Escape") {
+						setShowSlashCommandsMenu(false)
+						setSlashCommandsQuery("")
+						return
+					}
+
+					if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+						event.preventDefault()
+						setSelectedSlashCommandsIndex((prevIndex) => {
+							const direction = event.key === "ArrowUp" ? -1 : 1
+							// Get commands with workflow toggles
+							const allCommands = getMatchingSlashCommands(
+								slashCommandsQuery,
+								localWorkflowToggles,
+								globalWorkflowToggles,
+								remoteWorkflowToggles,
+								remoteConfigSettings?.remoteGlobalWorkflows,
+								mcpServers,
+							)
+
+							if (allCommands.length === 0) {
+								return prevIndex
+							}
+
+							// Calculate total command count
+							const totalCommandCount = allCommands.length
+
+							// Create wraparound navigation - moves from last item to first and vice versa
+							const newIndex = (prevIndex + direction + totalCommandCount) % totalCommandCount
+							return newIndex
+						})
+						return
+					}
+
+					if ((event.key === "Enter" || event.key === "Tab") && selectedSlashCommandsIndex !== -1) {
+						event.preventDefault()
+						const commands = getMatchingSlashCommands(
+							slashCommandsQuery,
+							localWorkflowToggles,
+							globalWorkflowToggles,
+							remoteWorkflowToggles,
+							remoteConfigSettings?.remoteGlobalWorkflows,
+							mcpServers,
+						)
+						if (commands.length > 0) {
+							handleSlashCommandsSelect(commands[selectedSlashCommandsIndex])
+						}
+						return
+					}
+				}
+				if (showContextMenu) {
+					if (event.key === "Escape") {
+						setShowContextMenu(false)
+						setSelectedType(null)
+						setSelectedMenuIndex(DEFAULT_CONTEXT_MENU_OPTION)
+						setSearchQuery("")
+						return
+					}
+
+					if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+						event.preventDefault()
+						setSelectedMenuIndex((prevIndex) => {
+							const direction = event.key === "ArrowUp" ? -1 : 1
+							const options = getContextMenuOptions(searchQuery, selectedType, queryItems, fileSearchResults)
+							const optionsLength = options.length
+
+							if (optionsLength === 0) {
+								return prevIndex
+							}
+
+							// Find selectable options (non-URL types)
+							const selectableOptions = options.filter(
+								(option) =>
+									option.type !== ContextMenuOptionType.URL && option.type !== ContextMenuOptionType.NoResults,
+							)
+
+							if (selectableOptions.length === 0) {
+								return -1 // No selectable options
+							}
+
+							// Find the index of the next selectable option
+							const currentSelectableIndex = selectableOptions.indexOf(options[prevIndex])
+
+							const newSelectableIndex =
+								(currentSelectableIndex + direction + selectableOptions.length) % selectableOptions.length
+
+							// Find the index of the selected option in the original options array
+							return options.indexOf(selectableOptions[newSelectableIndex])
+						})
+						return
+					}
+					if ((event.key === "Enter" || event.key === "Tab") && selectedMenuIndex !== -1) {
+						event.preventDefault()
+						const selectedOption = getContextMenuOptions(searchQuery, selectedType, queryItems, fileSearchResults)[
+							selectedMenuIndex
+						]
+						if (
+							selectedOption &&
+							selectedOption.type !== ContextMenuOptionType.URL &&
+							selectedOption.type !== ContextMenuOptionType.NoResults
+						) {
+							// Use label if it contains workspace prefix, otherwise use value
+							const mentionValue = selectedOption.label?.includes(":") ? selectedOption.label : selectedOption.value
+							handleMentionSelect(selectedOption.type, mentionValue)
+						}
+						return
+					}
+				}
+
+				// Safari does not support InputEvent.isComposing (always false), so we need to fallback to keyCode === 229 for it
+				const isComposing = isSafari ? event.nativeEvent.keyCode === 229 : (event.nativeEvent?.isComposing ?? false)
+				if (event.key === "Enter" && !event.shiftKey && !isComposing) {
+					event.preventDefault()
+
+					if (!sendingDisabled) {
+						setIsTextAreaFocused(false)
+						onSend()
+					}
+				}
+
+				if (event.key === "Backspace" && !isComposing) {
+					const charBeforeCursor = inputValue[cursorPosition - 1]
+					const charAfterCursor = inputValue[cursorPosition + 1]
+
+					const charBeforeIsWhitespace =
+						charBeforeCursor === " " || charBeforeCursor === "\n" || charBeforeCursor === "\r\n"
+					const charAfterIsWhitespace =
+						charAfterCursor === " " || charAfterCursor === "\n" || charAfterCursor === "\r\n"
+
+					// Check if we're right after a space that follows a mention or slash command
+					if (
+						charBeforeIsWhitespace &&
+						inputValue.slice(0, cursorPosition - 1).match(new RegExp(mentionRegex.source + "$"))
+					) {
+						// File mention handling
+						const newCursorPosition = cursorPosition - 1
+						if (!charAfterIsWhitespace) {
+							event.preventDefault()
+							textAreaRef.current?.setSelectionRange(newCursorPosition, newCursorPosition)
+							setCursorPosition(newCursorPosition)
+						}
+						setCursorPosition(newCursorPosition)
+						setJustDeletedSpaceAfterMention(true)
+						setJustDeletedSpaceAfterSlashCommand(false)
+					} else if (charBeforeIsWhitespace && inputValue.slice(0, cursorPosition - 1).match(slashCommandDeleteRegex)) {
+						// New slash command handling
+						const newCursorPosition = cursorPosition - 1
+						if (!charAfterIsWhitespace) {
+							event.preventDefault()
+							textAreaRef.current?.setSelectionRange(newCursorPosition, newCursorPosition)
+							setCursorPosition(newCursorPosition)
+						}
+						setCursorPosition(newCursorPosition)
+						setJustDeletedSpaceAfterSlashCommand(true)
+						setJustDeletedSpaceAfterMention(false)
+					}
+					// Handle the second backspace press for mentions or slash commands
+					else if (justDeletedSpaceAfterMention) {
+						const { newText, newPosition } = removeMention(inputValue, cursorPosition)
+						if (newText !== inputValue) {
+							event.preventDefault()
+							setInputValue(newText)
+							setIntendedCursorPosition(newPosition)
+						}
+						setJustDeletedSpaceAfterMention(false)
+						setShowContextMenu(false)
+					} else if (justDeletedSpaceAfterSlashCommand) {
+						// New slash command deletion
+						const { newText, newPosition } = removeSlashCommand(inputValue, cursorPosition)
+						if (newText !== inputValue) {
+							event.preventDefault()
+							setInputValue(newText)
+							setIntendedCursorPosition(newPosition)
+						}
+						setJustDeletedSpaceAfterSlashCommand(false)
+						setShowSlashCommandsMenu(false)
+					}
+					// Default case - reset flags if none of the above apply
+					else {
+						setJustDeletedSpaceAfterMention(false)
+						setJustDeletedSpaceAfterSlashCommand(false)
+					}
+				}
+			},
+			[
+				onSend,
+				showContextMenu,
+				searchQuery,
+				selectedMenuIndex,
+				handleMentionSelect,
+				selectedType,
+				inputValue,
+				cursorPosition,
+				setInputValue,
+				justDeletedSpaceAfterMention,
+				queryItems,
+				fileSearchResults,
+				showSlashCommandsMenu,
+				selectedSlashCommandsIndex,
+				slashCommandsQuery,
+				handleSlashCommandsSelect,
+				sendingDisabled,
+			],
+		)
+
+		// Effect to set cursor position after state updates
+		useLayoutEffect(() => {
+			if (intendedCursorPosition !== null && textAreaRef.current) {
+				textAreaRef.current.setSelectionRange(intendedCursorPosition, intendedCursorPosition)
+				setIntendedCursorPosition(null) // Reset the state after applying
+			}
+		}, [inputValue, intendedCursorPosition])
+
+		useEffect(() => {
+			if (pendingInsertions.length === 0 || !textAreaRef.current) {
+				return
+			}
+
+			const path = pendingInsertions[0]
+			const currentTextArea = textAreaRef.current
+			const currentValue = currentTextArea.value
+			const currentCursorPos =
+				intendedCursorPosition ??
+				(currentTextArea.selectionStart >= 0 ? currentTextArea.selectionStart : currentValue.length)
+
+			const { newValue, mentionIndex } = insertMentionDirectly(currentValue, currentCursorPos, path)
+
+			setInputValue(newValue)
+
+			const newCursorPosition = mentionIndex + path.length + 2
+			setIntendedCursorPosition(newCursorPosition)
+
+			setPendingInsertions((prev) => prev.slice(1))
+		}, [pendingInsertions, setInputValue])
+
+		const searchTimeoutRef = useRef<NodeJS.Timeout | null>(null)
+
+		// Monotonic token; every searchFiles dispatch bumps it, and resolve
+		// handlers drop their result when the token they captured at fire time
+		// is no longer the latest. Prevents stale results from a cancelled or
+		// superseded picker (e.g. "Add File" still in flight when user picks
+		// "Add Folder") from clobbering fresh state.
+		const latestSearchTokenRef = useRef(0)
+
+		const handleInputChange = useCallback(
+			(e: React.ChangeEvent<HTMLTextAreaElement>) => {
+				const newValue = e.target.value
+				const newCursorPosition = e.target.selectionStart
+				setInputValue(newValue)
+				setCursorPosition(newCursorPosition)
+				let showMenu = shouldShowContextMenu(newValue, newCursorPosition)
+				const showSlashCommandsMenu = shouldShowSlashCommandsMenu(newValue, newCursorPosition)
+
+				// we do not allow both menus to be shown at the same time
+				// the slash commands menu has precedence bc its a narrower component
+				if (showSlashCommandsMenu) {
+					showMenu = false
+				}
+
+				setShowSlashCommandsMenu(showSlashCommandsMenu)
+				setShowContextMenu(showMenu)
+
+				if (showSlashCommandsMenu) {
+					// Find the slash nearest to cursor (before cursor position)
+					const beforeCursor = newValue.slice(0, newCursorPosition)
+					const slashIndex = beforeCursor.lastIndexOf("/")
+					const query = newValue.slice(slashIndex + 1, newCursorPosition)
+					setSlashCommandsQuery(query)
+					setSelectedSlashCommandsIndex(0)
+				} else {
+					setSlashCommandsQuery("")
+					setSelectedSlashCommandsIndex(0)
+				}
+
+				if (showMenu) {
+					const lastAtIndex = newValue.lastIndexOf("@", newCursorPosition - 1)
+					const query = newValue.slice(lastAtIndex + 1, newCursorPosition)
+					setSearchQuery(query)
+
+					if (query.length > 0) {
+						setSelectedMenuIndex(0)
+
+						// Clear any existing timeout
+						if (searchTimeoutRef.current) {
+							clearTimeout(searchTimeoutRef.current)
+						}
+
+						setSearchLoading(true)
+
+						const searchType =
+							selectedType === ContextMenuOptionType.File
+								? FileSearchType.FILE
+								: selectedType === ContextMenuOptionType.Folder
+									? FileSearchType.FOLDER
+									: undefined
+
+						// Parse workspace hint from query (e.g., "@frontend:/filename")
+						let workspaceHint: string | undefined
+						let searchQuery = query
+						const workspaceHintMatch = query.match(/^([\w-]+):\/(.*)$/)
+						if (workspaceHintMatch) {
+							workspaceHint = workspaceHintMatch[1]
+							searchQuery = workspaceHintMatch[2]
+						}
+
+						// Set a timeout to debounce the search requests
+						searchTimeoutRef.current = setTimeout(() => {
+							const myToken = ++latestSearchTokenRef.current
+							FileServiceClient.searchFiles(
+								FileSearchRequest.create({
+									query: searchQuery,
+									mentionsRequestId: String(myToken),
+									selectedType: searchType,
+									workspaceHint: workspaceHint,
+								}),
+							)
+								.then((results) => {
+									if (myToken !== latestSearchTokenRef.current) {
+										// Stale response — a newer search has been issued.
+										return
+									}
+									setFileSearchResults((results.results || []) as SearchResult[])
+									setSearchLoading(false)
+								})
+								.catch((error) => {
+									if (myToken !== latestSearchTokenRef.current) {
+										return
+									}
+									console.error("Error searching files:", error)
+									setFileSearchResults([])
+									setSearchLoading(false)
+								})
+						}, 200) // 200ms debounce
+					} else {
+						setSelectedMenuIndex(DEFAULT_CONTEXT_MENU_OPTION)
+					}
+				} else {
+					setSearchQuery("")
+					setSelectedMenuIndex(-1)
+					setFileSearchResults([])
+				}
+			},
+			[setInputValue, setFileSearchResults, selectedType],
+		)
+
+		useEffect(() => {
+			if (!showContextMenu) {
+				setSelectedType(null)
+			}
+		}, [showContextMenu])
+
+		const handleBlur = useCallback(() => {
+			// Only hide the context menu if the user didn't click on it
+			if (!isMouseDownOnMenu) {
+				setShowContextMenu(false)
+				setShowSlashCommandsMenu(false)
+			}
+			setIsTextAreaFocused(false)
+			onFocusChange?.(false) // Call prop on blur
+		}, [isMouseDownOnMenu, onFocusChange])
+
+		const showDimensionErrorMessage = useCallback(() => {
+			setShowDimensionError(true)
+			if (dimensionErrorTimerRef.current) {
+				clearTimeout(dimensionErrorTimerRef.current)
+			}
+			dimensionErrorTimerRef.current = setTimeout(() => {
+				setShowDimensionError(false)
+				dimensionErrorTimerRef.current = null
+			}, 3000)
+		}, [])
+
+		const handlePaste = useCallback(
+			async (e: React.ClipboardEvent) => {
+				const items = e.clipboardData.items
+
+				const pastedText = e.clipboardData.getData("text")
+				// Check if the pasted content is a URL, add space after so user can easily delete if they don't want it
+				const urlRegex = /^\S+:\/\/\S+$/
+				if (urlRegex.test(pastedText.trim())) {
+					e.preventDefault()
+					const trimmedUrl = pastedText.trim()
+					const newValue = inputValue.slice(0, cursorPosition) + trimmedUrl + " " + inputValue.slice(cursorPosition)
+					setInputValue(newValue)
+					const newCursorPosition = cursorPosition + trimmedUrl.length + 1
+					setCursorPosition(newCursorPosition)
+					setIntendedCursorPosition(newCursorPosition)
+					setShowContextMenu(false)
+
+					// Scroll to new cursor position
+					// https://stackoverflow.com/questions/29899364/how-do-you-scroll-to-the-position-of-the-cursor-in-a-textarea/40951875#40951875
+					setTimeout(() => {
+						if (textAreaRef.current) {
+							textAreaRef.current.blur()
+							textAreaRef.current.focus()
+						}
+					}, 0)
+					// NOTE: callbacks dont utilize return function to cleanup, but it's fine since this timeout immediately executes and will be cleaned up by the browser (no chance component unmounts before it executes)
+
+					return
+				}
+
+				const acceptedTypes = ["png", "jpeg", "webp"] // supported by anthropic and openrouter (jpg is just a file extension but the image will be recognized as jpeg)
+				const imageItems = Array.from(items).filter((item) => {
+					const [type, subtype] = item.type.split("/")
+					return type === "image" && acceptedTypes.includes(subtype)
+				})
+				if (!shouldDisableFilesAndImages && imageItems.length > 0) {
+					e.preventDefault()
+					const imagePromises = imageItems.map((item) => {
+						return new Promise<string | null>((resolve) => {
+							const blob = item.getAsFile()
+							if (!blob) {
+								resolve(null)
+								return
+							}
+							const reader = new FileReader()
+							reader.onloadend = async () => {
+								if (reader.error) {
+									console.error("Error reading file:", reader.error)
+									resolve(null)
+								} else {
+									const result = reader.result
+									if (typeof result === "string") {
+										try {
+											await getImageDimensions(result)
+											resolve(result)
+										} catch (error) {
+											console.warn((error as Error).message)
+											showDimensionErrorMessage()
+											resolve(null)
+										}
+									} else {
+										resolve(null)
+									}
+								}
+							}
+							reader.readAsDataURL(blob)
+						})
+					})
+					const imageDataArray = await Promise.all(imagePromises)
+					const dataUrls = imageDataArray.filter((dataUrl): dataUrl is string => dataUrl !== null)
+					//.map((dataUrl) => dataUrl.split(",")[1]) // strip the mime type prefix, sharp doesn't need it
+					if (dataUrls.length > 0) {
+						const filesAndImagesLength = selectedImages.length + selectedFiles.length
+						const availableSlots = MAX_IMAGES_AND_FILES_PER_MESSAGE - filesAndImagesLength
+
+						if (availableSlots > 0) {
+							const imagesToAdd = Math.min(dataUrls.length, availableSlots)
+							setSelectedImages((prevImages) => [...prevImages, ...dataUrls.slice(0, imagesToAdd)])
+						}
+					} else {
+						console.warn("No valid images were processed")
+					}
+				}
+			},
+			[
+				shouldDisableFilesAndImages,
+				setSelectedImages,
+				selectedImages,
+				selectedFiles,
+				cursorPosition,
+				setInputValue,
+				inputValue,
+				showDimensionErrorMessage,
+			],
+		)
+
+		const handleThumbnailsHeightChange = useCallback((height: number) => {
+			setThumbnailsHeight(height)
+		}, [])
+
+		useEffect(() => {
+			if (selectedImages.length === 0 && selectedFiles.length === 0) {
+				setThumbnailsHeight(0)
+			}
+		}, [selectedImages, selectedFiles])
+
+		const handleMenuMouseDown = useCallback(() => {
+			setIsMouseDownOnMenu(true)
+		}, [])
+
+		const updateHighlights = useCallback(() => {
+			if (!textAreaRef.current || !highlightLayerRef.current) {
+				return
+			}
+
+			let processedText = textAreaRef.current.value
+
+			processedText = processedText
+				.replace(/\n$/, "\n\n")
+				.replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" })[c] || c)
+				// highlight @mentions
+				.replace(mentionRegexGlobal, '<mark class="mention-context-textarea-highlight">$&</mark>')
+
+			// Highlight only the FIRST valid /slash-command in the text
+			// Only one slash command is processed per message, so we only highlight the first one
+			slashCommandRegexGlobal.lastIndex = 0
+			let hasHighlightedSlashCommand = false
+			processedText = processedText.replace(slashCommandRegexGlobal, (match, prefix, command) => {
+				// Only highlight the first valid slash command
+				if (hasHighlightedSlashCommand) {
+					return match
+				}
+
+				// Extract just the command name (without the slash)
+				const commandName = command.substring(1)
+				const isValidCommand = validateSlashCommand(
+					commandName,
+					localWorkflowToggles,
+					globalWorkflowToggles,
+					remoteWorkflowToggles,
+					remoteConfigSettings?.remoteGlobalWorkflows,
+				)
+
+				if (isValidCommand) {
+					hasHighlightedSlashCommand = true
+					// Keep the prefix (whitespace or empty) and wrap the command in highlight
+					return `${prefix}<mark class="mention-context-textarea-highlight">${command}</mark>`
+				}
+				return match
+			})
+
+			highlightLayerRef.current.innerHTML = processedText
+			highlightLayerRef.current.scrollTop = textAreaRef.current.scrollTop
+			highlightLayerRef.current.scrollLeft = textAreaRef.current.scrollLeft
+		}, [localWorkflowToggles, globalWorkflowToggles, remoteWorkflowToggles, remoteConfigSettings])
+
+		useLayoutEffect(() => {
+			updateHighlights()
+		}, [inputValue, updateHighlights])
+
+		const updateCursorPosition = useCallback(() => {
+			if (textAreaRef.current) {
+				setCursorPosition(textAreaRef.current.selectionStart)
+			}
+		}, [])
+
+		const handleKeyUp = useCallback(
+			(e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+				if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(e.key)) {
+					updateCursorPosition()
+				}
+			},
+			[updateCursorPosition],
+		)
+
+		const onModeToggle = useCallback(() => {
+			void (async () => {
+				const convertedProtoMode = mode === "plan" ? PlanActMode.ACT : PlanActMode.PLAN
+				const submittedText = inputValue
+				const submittedImages = selectedImages
+				const submittedFiles = selectedFiles
+				const response = await StateServiceClient.togglePlanActModeProto(
+					TogglePlanActModeRequest.create({
+						mode: convertedProtoMode,
+						chatContent: {
+							message: submittedText.trim() ? submittedText : undefined,
+							images: submittedImages,
+							files: submittedFiles,
+						},
+					}),
+				)
+				// Focus the textarea after mode toggle with slight delay
+				setTimeout(() => {
+					if (response.value) {
+						// The toggle consumed the composer content as the continuation
+						// message. Clear only what was submitted: the rebuild can take a
+						// moment and the user may have typed or attached new content in
+						// the meantime, which must not be wiped.
+						if ((textAreaRef.current?.value ?? "") === submittedText) {
+							setInputValue("")
+						}
+						setSelectedImages((current) => (current === submittedImages ? [] : current))
+						setSelectedFiles((current) => (current === submittedFiles ? [] : current))
+					}
+					textAreaRef.current?.focus()
+				}, 100)
+			})()
+		}, [mode, inputValue, selectedImages, selectedFiles, setInputValue, setSelectedImages, setSelectedFiles])
+
+		useShortcut(usePlatform().togglePlanActKeys, onModeToggle, { disableTextInputs: false }) // important that we don't disable the text input here
+
+		const handleContextButtonClick = useCallback(() => {
+			// Focus the textarea first
+			textAreaRef.current?.focus()
+
+			// If input is empty, just insert @
+			if (!inputValue.trim()) {
+				const event = {
+					target: {
+						value: "@",
+						selectionStart: 1,
+					},
+				} as React.ChangeEvent<HTMLTextAreaElement>
+				handleInputChange(event)
+				updateHighlights()
+				return
+			}
+
+			// If input ends with space or is empty, just append @
+			if (inputValue.endsWith(" ")) {
+				const event = {
+					target: {
+						value: inputValue + "@",
+						selectionStart: inputValue.length + 1,
+					},
+				} as React.ChangeEvent<HTMLTextAreaElement>
+				handleInputChange(event)
+				updateHighlights()
+				return
+			}
+
+			// Otherwise add space then @
+			const event = {
+				target: {
+					value: inputValue + " @",
+					selectionStart: inputValue.length + 2,
+				},
+			} as React.ChangeEvent<HTMLTextAreaElement>
+			handleInputChange(event)
+			updateHighlights()
+		}, [inputValue, handleInputChange, updateHighlights])
+
+		const handleModelButtonClick = () => {
+			navigateToSettingsModelPicker({ targetSection: "api-config" })
+		}
+
+		// Get model display name
+		const modelDisplayName = useMemo(() => {
+			const {
+				vsCodeLmModelSelector,
+				togetherModelId,
+				lmStudioModelId,
+				ollamaModelId,
+				liteLlmModelId,
+				requestyModelId,
+				vercelAiGatewayModelId,
+			} = getModeSpecificFields(apiConfiguration, mode)
+			const unknownModel = "unknown"
+
+			if (!apiConfiguration) {
+				return unknownModel
+			}
+			switch (selectedProvider) {
+				case "cline":
+					return `${selectedProvider}:${selectedModelId}`
+				case "cline-pass":
+					// Free models selected on ClinePass go through Cline usage billing,
+					// so label them the same way as the cline provider
+					return selectedModelId.startsWith("cline-pass/")
+						? `${selectedProvider}:${selectedModelId.replace(/^cline-pass\//, "")}`
+						: `cline:${selectedModelId}`
+				case "openai":
+					return `openai-compat:${selectedModelId}`
+				case "vscode-lm":
+					return `vscode-lm:${vsCodeLmModelSelector ? `${vsCodeLmModelSelector.vendor ?? ""}/${vsCodeLmModelSelector.family ?? ""}` : unknownModel}`
+				case "together":
+					return `${selectedProvider}:${togetherModelId}`
+				case "lmstudio":
+					return `${selectedProvider}:${lmStudioModelId}`
+				case "ollama":
+					return `${selectedProvider}:${ollamaModelId}`
+				case "litellm":
+					return `${selectedProvider}:${liteLlmModelId}`
+				case "requesty":
+					return `${selectedProvider}:${requestyModelId}`
+				case "vercel-ai-gateway":
+					return `${selectedProvider}:${vercelAiGatewayModelId || selectedModelId}`
+				case "anthropic":
+				case "openrouter":
+				default:
+					return `${selectedProvider}:${selectedModelId}`
+			}
+		}, [apiConfiguration, mode, selectedProvider, selectedModelId])
+
+		// Function to show error message for unsupported files for drag and drop
+		const showUnsupportedFileErrorMessage = () => {
+			// Show error message for unsupported files
+			setShowUnsupportedFileError(true)
+
+			// Clear any existing timer
+			if (unsupportedFileTimerRef.current) {
+				clearTimeout(unsupportedFileTimerRef.current)
+			}
+
+			// Set timer to hide error after 3 seconds
+			unsupportedFileTimerRef.current = setTimeout(() => {
+				setShowUnsupportedFileError(false)
+				unsupportedFileTimerRef.current = null
+			}, 3000)
+		}
+
+		const handleDragEnter = (e: React.DragEvent) => {
+			e.preventDefault()
+			setIsDraggingOver(true)
+
+			// Check if files are being dragged
+			if (e.dataTransfer.types.includes("Files")) {
+				// Check if any of the files are not images
+				const items = Array.from(e.dataTransfer.items)
+				const hasNonImageFile = items.some((item) => {
+					if (item.kind === "file") {
+						const type = item.type.split("/")[0]
+						return type !== "image"
+					}
+					return false
+				})
+
+				if (hasNonImageFile) {
+					showUnsupportedFileErrorMessage()
+				}
+			}
+		}
+		/**
+		 * Handles the drag over event to allow dropping.
+		 * Prevents the default behavior to enable drop.
+		 *
+		 * @param {React.DragEvent} e - The drag event.
+		 */
+		const onDragOver = (e: React.DragEvent) => {
+			e.preventDefault()
+			// Ensure state remains true if dragging continues over the element
+			if (!isDraggingOver) {
+				setIsDraggingOver(true)
+			}
+		}
+
+		const handleDragLeave = (e: React.DragEvent) => {
+			e.preventDefault()
+			// Check if the related target is still within the drop zone; prevents flickering
+			const dropZone = e.currentTarget as HTMLElement
+			if (!dropZone.contains(e.relatedTarget as Node)) {
+				setIsDraggingOver(false)
+				// Don't clear the error message here, let it time out naturally
+			}
+		}
+
+		// Effect to detect when drag operation ends outside the component
+		useEffect(() => {
+			const handleGlobalDragEnd = () => {
+				// This will be triggered when the drag operation ends anywhere
+				setIsDraggingOver(false)
+				// Don't clear error message, let it time out naturally
+			}
+
+			document.addEventListener("dragend", handleGlobalDragEnd)
+
+			return () => {
+				document.removeEventListener("dragend", handleGlobalDragEnd)
+			}
+		}, [])
+
+		/**
+		 * Handles the drop event for files and text.
+		 * Processes dropped images and text, updating the state accordingly.
+		 *
+		 * @param {React.DragEvent} e - The drop event.
+		 */
+		const onDrop = async (e: React.DragEvent) => {
+			e.preventDefault()
+			setIsDraggingOver(false) // Reset state on drop
+
+			// Clear any error message when something is actually dropped
+			setShowUnsupportedFileError(false)
+			if (unsupportedFileTimerRef.current) {
+				clearTimeout(unsupportedFileTimerRef.current)
+				unsupportedFileTimerRef.current = null
+			}
+
+			// --- 1. VSCode Explorer Drop Handling ---
+			let uris: string[] = []
+			const resourceUrlsData = e.dataTransfer.getData("resourceurls")
+			const vscodeUriListData = e.dataTransfer.getData("application/vnd.code.uri-list")
+
+			// 1a. Try 'resourceurls' first (used for multi-select)
+			if (resourceUrlsData) {
+				try {
+					uris = JSON.parse(resourceUrlsData)
+					uris = uris.map((uri) => decodeURIComponent(uri))
+				} catch (error) {
+					console.error("Failed to parse resourceurls JSON:", error)
+					uris = [] // Reset if parsing failed
+				}
+			}
+
+			// 1b. Fallback to 'application/vnd.code.uri-list' (newline separated)
+			if (uris.length === 0 && vscodeUriListData) {
+				uris = vscodeUriListData.split("\n").map((uri) => uri.trim())
+			}
+
+			// 1c. Filter for valid schemes (file or vscode-file) and non-empty strings
+			const validUris = uris.filter(
+				(uri) => uri && (uri.startsWith("vscode-file:") || uri.startsWith("file:") || uri.startsWith("vscode-remote:")),
+			)
+
+			if (validUris.length > 0) {
+				setPendingInsertions([])
+				let initialCursorPos = inputValue.length
+				if (textAreaRef.current) {
+					initialCursorPos = textAreaRef.current.selectionStart
+				}
+				setIntendedCursorPosition(initialCursorPos)
+
+				FileServiceClient.getRelativePaths(RelativePathsRequest.create({ uris: validUris }))
+					.then((response) => {
+						if (response.paths.length > 0) {
+							setPendingInsertions((prev) => [...prev, ...response.paths])
+						}
+					})
+					.catch((error) => {
+						console.error("Error getting relative paths:", error)
+					})
+				return
+			}
+
+			const text = e.dataTransfer.getData("text")
+			if (text) {
+				handleTextDrop(text)
+				return
+			}
+
+			// --- 3. Image Drop Handling ---
+			// Only proceed if it wasn't a VSCode resource or plain text drop
+			const files = Array.from(e.dataTransfer.files)
+			const acceptedTypes = ["png", "jpeg", "webp"]
+			const imageFiles = files.filter((file) => {
+				const [type, subtype] = file.type.split("/")
+				return type === "image" && acceptedTypes.includes(subtype)
+			})
+
+			if (shouldDisableFilesAndImages || imageFiles.length === 0) {
+				return
+			}
+
+			const imageDataArray = await readImageFiles(imageFiles)
+			const dataUrls = imageDataArray.filter((dataUrl): dataUrl is string => dataUrl !== null)
+
+			if (dataUrls.length > 0) {
+				const filesAndImagesLength = selectedImages.length + selectedFiles.length
+				const availableSlots = MAX_IMAGES_AND_FILES_PER_MESSAGE - filesAndImagesLength
+
+				if (availableSlots > 0) {
+					const imagesToAdd = Math.min(dataUrls.length, availableSlots)
+					setSelectedImages((prevImages) => [...prevImages, ...dataUrls.slice(0, imagesToAdd)])
+				}
+			} else {
+				console.warn("No valid images were processed")
+			}
+		}
+
+		/**
+		 * Handles the drop event for text.
+		 * Inserts the dropped text at the current cursor position.
+		 *
+		 * @param {string} text - The dropped text.
+		 */
+		const handleTextDrop = (text: string) => {
+			const newValue = inputValue.slice(0, cursorPosition) + text + inputValue.slice(cursorPosition)
+			setInputValue(newValue)
+			const newCursorPosition = cursorPosition + text.length
+			setCursorPosition(newCursorPosition)
+			setIntendedCursorPosition(newCursorPosition)
+		}
+
+		/**
+		 * Reads image files and returns their data URLs.
+		 * Uses FileReader to read the files as data URLs.
+		 *
+		 * @param {File[]} imageFiles - The image files to read.
+		 * @returns {Promise<(string | null)[]>} - A promise that resolves to an array of data URLs or null values.
+		 */
+		const readImageFiles = (imageFiles: File[]): Promise<(string | null)[]> => {
+			return Promise.all(
+				imageFiles.map(
+					(file) =>
+						new Promise<string | null>((resolve) => {
+							const reader = new FileReader()
+							reader.onloadend = async () => {
+								// Make async
+								if (reader.error) {
+									console.error("Error reading file:", reader.error)
+									resolve(null)
+								} else {
+									const result = reader.result
+									if (typeof result === "string") {
+										try {
+											await getImageDimensions(result) // Check dimensions
+											resolve(result)
+										} catch (error) {
+											console.warn((error as Error).message)
+											showDimensionErrorMessage() // Show error to user
+											resolve(null) // Don't add this image
+										}
+									} else {
+										resolve(null)
+									}
+								}
+							}
+							reader.readAsDataURL(file)
+						}),
+				),
+			)
+		}
+		// Replace Meta with the platform specific key and uppercase the command letter.
+		const togglePlanActKeys = usePlatform()
+			.togglePlanActKeys.replace("Meta", metaKeyChar)
+			.replace(/.$/, (match) => match.toUpperCase())
+
+		return (
+			<div>
+				<div
+					className="relative flex transition-colors ease-in-out duration-100 px-3.5 py-2.5"
+					onDragEnter={handleDragEnter}
+					onDragLeave={handleDragLeave}
+					onDragOver={onDragOver}
+					onDrop={onDrop}>
+					{showDimensionError && (
+						<div className="absolute inset-2.5 bg-[rgba(var(--vscode-errorForeground-rgb),0.1)] border-2 border-error rounded-xs flex items-center justify-center z-10 pointer-events-none">
+							<span className="text-error font-bold text-xs text-center">Image dimensions exceed 7500px</span>
+						</div>
+					)}
+					{showUnsupportedFileError && (
+						<div className="absolute inset-2.5 bg-[rgba(var(--vscode-errorForeground-rgb),0.1)] border-2 border-error rounded-xs flex items-center justify-center z-10 pointer-events-none">
+							<span className="text-error font-bold text-xs">Files other than images are currently disabled</span>
+						</div>
+					)}
+					{showSlashCommandsMenu && (
+						<div ref={slashCommandsMenuContainerRef}>
+							<SlashCommandMenu
+								globalWorkflowToggles={globalWorkflowToggles}
+								localWorkflowToggles={localWorkflowToggles}
+								mcpServers={mcpServers}
+								onMouseDown={handleMenuMouseDown}
+								onSelect={handleSlashCommandsSelect}
+								query={slashCommandsQuery}
+								remoteWorkflows={remoteConfigSettings?.remoteGlobalWorkflows}
+								remoteWorkflowToggles={remoteWorkflowToggles}
+								selectedIndex={selectedSlashCommandsIndex}
+								setSelectedIndex={setSelectedSlashCommandsIndex}
+							/>
+						</div>
+					)}
+
+					{showContextMenu && (
+						<div ref={contextMenuContainerRef}>
+							<ContextMenu
+								dynamicSearchResults={fileSearchResults}
+								isLoading={searchLoading}
+								onMouseDown={handleMenuMouseDown}
+								onSelect={handleMentionSelect}
+								queryItems={queryItems}
+								searchQuery={searchQuery}
+								selectedIndex={selectedMenuIndex}
+								selectedType={selectedType}
+								setSelectedIndex={setSelectedMenuIndex}
+							/>
+						</div>
+					)}
+					<div
+						className={cn(
+							"absolute bottom-2.5 top-2.5 whitespace-pre-wrap break-words rounded-xs overflow-hidden bg-input-background",
+							isTextAreaFocused ? "left-3.5 right-3.5" : "left-3.5 right-3.5 border border-input-border",
+						)}
+						ref={highlightLayerRef}
+						style={{
+							position: "absolute",
+							pointerEvents: "none",
+							whiteSpace: "pre-wrap",
+							wordWrap: "break-word",
+							color: "transparent",
+							overflow: "hidden",
+							fontFamily: "var(--vscode-font-family)",
+							fontSize: "var(--vscode-editor-font-size)",
+							lineHeight: "var(--vscode-editor-line-height)",
+							borderRadius: 2,
+							borderLeft: isTextAreaFocused ? 0 : undefined,
+							borderRight: isTextAreaFocused ? 0 : undefined,
+							borderTop: isTextAreaFocused ? 0 : undefined,
+							borderBottom: isTextAreaFocused ? 0 : undefined,
+							padding: `9px 28px ${9 + thumbnailsHeight}px 9px`,
+						}}
+					/>
+					<DynamicTextArea
+						autoFocus={true}
+						data-testid="chat-input"
+						maxRows={10}
+						minRows={3}
+						onBlur={handleBlur}
+						onChange={(e) => {
+							handleInputChange(e)
+							updateHighlights()
+						}}
+						onFocus={() => {
+							setIsTextAreaFocused(true)
+							onFocusChange?.(true) // Call prop on focus
+						}}
+						onHeightChange={(height) => {
+							if (textAreaBaseHeight === undefined || height < textAreaBaseHeight) {
+								setTextAreaBaseHeight(height)
+							}
+							onHeightChange?.(height)
+						}}
+						onKeyDown={handleKeyDown}
+						onKeyUp={handleKeyUp}
+						onMouseUp={updateCursorPosition}
+						onPaste={handlePaste}
+						onScroll={() => updateHighlights()}
+						onSelect={updateCursorPosition}
+						placeholder={showUnsupportedFileError || showDimensionError ? "" : placeholderText}
+						ref={(el) => {
+							if (typeof ref === "function") {
+								ref(el)
+							} else if (ref) {
+								ref.current = el
+							}
+							textAreaRef.current = el
+						}}
+						style={{
+							width: "100%",
+							boxSizing: "border-box",
+							backgroundColor: "transparent",
+							color: "var(--vscode-input-foreground)",
+							//border: "1px solid var(--vscode-input-border)",
+							borderRadius: 2,
+							fontFamily: "var(--vscode-font-family)",
+							fontSize: "var(--vscode-editor-font-size)",
+							lineHeight: "var(--vscode-editor-line-height)",
+							resize: "none",
+							overflowX: "hidden",
+							overflowY: "scroll",
+							scrollbarWidth: "none",
+							// Since we have maxRows, when text is long enough it starts to overflow the bottom padding, appearing behind the thumbnails. To fix this, we use a transparent border to push the text up instead. (https://stackoverflow.com/questions/42631947/maintaining-a-padding-inside-of-text-area/52538410#52538410)
+							// borderTop: "9px solid transparent",
+							borderLeft: 0,
+							borderRight: 0,
+							borderTop: 0,
+							borderBottom: `${thumbnailsHeight}px solid transparent`,
+							borderColor: "transparent",
+							// borderRight: "54px solid transparent",
+							// borderLeft: "9px solid transparent", // NOTE: react-textarea-autosize doesn't calculate correct height when using borderLeft/borderRight so we need to use horizontal padding instead
+							// Instead of using boxShadow, we use a div with a border to better replicate the behavior when the textarea is focused
+							// boxShadow: "0px 0px 0px 1px var(--vscode-input-border)",
+							padding: "9px 28px 9px 9px",
+							cursor: "text",
+							flex: 1,
+							zIndex: 1,
+							outline:
+								isDraggingOver && !showUnsupportedFileError // Only show drag outline if not showing error
+									? "2px dashed var(--vscode-focusBorder)"
+									: isTextAreaFocused
+										? `1px solid ${mode === "plan" ? PLAN_MODE_COLOR : "var(--vscode-focusBorder)"}`
+										: "none",
+							outlineOffset: isDraggingOver && !showUnsupportedFileError ? "1px" : "0px", // Add offset for drag-over outline
+						}}
+						value={inputValue}
+					/>
+					{!inputValue && selectedImages.length === 0 && selectedFiles.length === 0 && (
+						<div className="text-xs absolute bottom-5 left-6.5 right-16 text-(--vscode-input-placeholderForeground)/50 whitespace-nowrap overflow-hidden text-ellipsis pointer-events-none z-1">
+							Type @ for context, / for slash commands & workflows, hold shift to drag in files/images
+						</div>
+					)}
+					{(selectedImages.length > 0 || selectedFiles.length > 0) && (
+						<Thumbnails
+							files={selectedFiles}
+							images={selectedImages}
+							onHeightChange={handleThumbnailsHeightChange}
+							setFiles={setSelectedFiles}
+							setImages={setSelectedImages}
+							style={{
+								position: "absolute",
+								paddingTop: 4,
+								bottom: 14,
+								left: 22,
+								right: 47, // (54 + 9) + 4 extra padding
+								zIndex: 2,
+							}}
+						/>
+					)}
+					<div
+						className="absolute flex items-end bottom-4.5 right-5 z-10 h-8 text-xs"
+						style={{ height: textAreaBaseHeight }}>
+						<div className="flex flex-row items-center">
+							<div
+								className={cn("input-icon-button", { disabled: sendingDisabled }, "codicon codicon-send text-sm")}
+								data-testid="send-button"
+								onClick={() => {
+									if (!sendingDisabled) {
+										setIsTextAreaFocused(false)
+										onSend()
+									}
+								}}
+							/>
+						</div>
+					</div>
+				</div>
+				<div className="flex justify-between items-center -mt-[2px] px-3 pb-2">
+					{/* Always render both components, but control visibility with CSS */}
+					<div className="relative flex-1 min-w-0 h-5">
+						{/* ButtonGroup - always in DOM but visibility controlled */}
+						<ButtonGroup className="absolute top-0 left-0 right-0 ease-in-out w-full h-5 z-10 flex items-center">
+							<Tooltip>
+								<TooltipContent>Add Context</TooltipContent>
+								<TooltipTrigger>
+									<VSCodeButton
+										appearance="icon"
+										aria-label="Add Context"
+										className="p-0 m-0 flex items-center"
+										data-testid="context-button"
+										onClick={handleContextButtonClick}>
+										<ButtonContainer>
+											<AtSignIcon size={12} />
+										</ButtonContainer>
+									</VSCodeButton>
+								</TooltipTrigger>
+							</Tooltip>
+
+							<Tooltip>
+								<TooltipContent>Add Files & Images</TooltipContent>
+								<TooltipTrigger>
+									<VSCodeButton
+										appearance="icon"
+										aria-label="Add Files & Images"
+										className="p-0 m-0 flex items-center"
+										data-testid="files-button"
+										disabled={shouldDisableFilesAndImages}
+										onClick={() => {
+											if (!shouldDisableFilesAndImages) {
+												onSelectFilesAndImages()
+											}
+										}}>
+										<ButtonContainer>
+											<PlusIcon size={13} />
+										</ButtonContainer>
+									</VSCodeButton>
+								</TooltipTrigger>
+							</Tooltip>
+
+							<ServersToggleModal />
+
+							<ClineRulesToggleModal />
+
+							<ModelContainer>
+								<ModelButtonWrapper>
+									<ModelDisplayButton
+										disabled={false}
+										onClick={handleModelButtonClick}
+										role="button"
+										tabIndex={0}
+										title="Open API Settings">
+										<ModelButtonContent className="text-xs">{modelDisplayName}</ModelButtonContent>
+									</ModelDisplayButton>
+								</ModelButtonWrapper>
+							</ModelContainer>
+						</ButtonGroup>
+					</div>
+					{/* Tooltip for Plan/Act toggle remains outside the conditional rendering */}
+					<Tooltip>
+						<TooltipContent
+							className="text-xs px-2 flex flex-col gap-1"
+							hidden={shownTooltipMode === null}
+							side="top">
+							{`In ${shownTooltipMode === "act" ? "Act" : "Plan"}  mode, Cline will ${shownTooltipMode === "act" ? "complete the task immediately" : "gather information to architect a plan"}`}
+							<p className="text-description/80 text-xs mb-0">
+								Toggle w/ <kbd className="text-muted-foreground mx-1">{togglePlanActKeys}</kbd>
+							</p>
+						</TooltipContent>
+						<TooltipTrigger>
+							<SwitchContainer data-testid="mode-switch" disabled={false} onClick={onModeToggle}>
+								<Slider isAct={mode === "act"} isPlan={mode === "plan"} />
+								{["Plan", "Act"].map((m) => (
+									<div
+										aria-checked={mode === m.toLowerCase()}
+										className={cn(
+											"pt-0.5 pb-px px-2 z-10 text-xs w-1/2 text-center bg-transparent",
+											mode === m.toLowerCase() ? "text-white" : "text-input-foreground",
+										)}
+										key={m}
+										onMouseLeave={() => setShownTooltipMode(null)}
+										onMouseOver={() => setShownTooltipMode(m.toLowerCase() === "plan" ? "plan" : "act")}
+										role="switch">
+										{m}
+									</div>
+								))}
+							</SwitchContainer>
+						</TooltipTrigger>
+					</Tooltip>
+				</div>
+			</div>
+		)
+	},
+)
+
+export default ChatTextArea
diff --git a/apps/vscode/webview-ui/src/components/chat/ChatView.tsx b/apps/vscode/webview-ui/src/components/chat/ChatView.tsx
new file mode 100644
index 0000000..925c64f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ChatView.tsx
@@ -0,0 +1,429 @@
+import { combineApiRequests } from "@shared/combineApiRequests"
+import { combineCommandSequences } from "@shared/combineCommandSequences"
+import { combineErrorRetryMessages } from "@shared/combineErrorRetryMessages"
+import { combineHookSequences } from "@shared/combineHookSequences"
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { getApiMetrics, getLastApiReqTotalTokens } from "@shared/getApiMetrics"
+import { BooleanRequest, StringRequest } from "@shared/proto/cline/common"
+import { useCallback, useEffect, useMemo, useRef } from "react"
+import { useMount } from "react-use"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useShowNavbar } from "@/context/PlatformContext"
+import { useNormalizedApiConfiguration } from "@/hooks/useNormalizedApiConfiguration"
+import { FileServiceClient, UiServiceClient } from "@/services/grpc-client"
+import { Navbar } from "../menu/Navbar"
+import AutoApproveBar from "./auto-approve-menu/AutoApproveBar"
+// Import utilities and hooks from the new structure
+import {
+	ActionButtons,
+	CHAT_CONSTANTS,
+	ChatLayout,
+	convertHtmlToMarkdown,
+	filterVisibleMessages,
+	groupLowStakesTools,
+	groupMessages,
+	InputSection,
+	MessagesArea,
+	QueuedPrompts,
+	TaskSection,
+	useChatState,
+	useMessageHandlers,
+	useScrollBehavior,
+	WelcomeSection,
+} from "./chat-view"
+
+interface ChatViewProps {
+	isHidden: boolean
+	showAnnouncement: boolean
+	hideAnnouncement: () => void
+	showHistoryView: () => void
+}
+
+// Use constants from the imported module
+const MAX_IMAGES_AND_FILES_PER_MESSAGE = CHAT_CONSTANTS.MAX_IMAGES_AND_FILES_PER_MESSAGE
+const QUICK_WINS_HISTORY_THRESHOLD = 3
+
+const sameUserMessage = (left: ClineMessage, right: ClineMessage) => {
+	const leftImages = left.images ?? []
+	const rightImages = right.images ?? []
+	const leftFiles = left.files ?? []
+	const rightFiles = right.files ?? []
+
+	return (
+		left.type === "say" &&
+		left.say === "user_feedback" &&
+		right.type === "say" &&
+		right.say === "user_feedback" &&
+		left.text === right.text &&
+		leftImages.length === rightImages.length &&
+		leftImages.every((image, index) => image === rightImages[index]) &&
+		leftFiles.length === rightFiles.length &&
+		leftFiles.every((file, index) => file === rightFiles[index])
+	)
+}
+
+const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryView }: ChatViewProps) => {
+	const showNavbar = useShowNavbar()
+	const {
+		version,
+		clineMessages: messages,
+		taskHistory,
+		telemetrySetting,
+		mode,
+		userInfo,
+		hooksEnabled,
+		checkpointRestoreInput,
+		queuedPrompts,
+	} = useExtensionState()
+	const isProdHostedApp = userInfo?.apiBaseUrl === "https://app.cline.bot"
+	const shouldShowQuickWins = isProdHostedApp && (!taskHistory || taskHistory.length < QUICK_WINS_HISTORY_THRESHOLD)
+
+	// Use custom hooks for state management
+	const chatState = useChatState(messages)
+	const {
+		setInputValue,
+		selectedImages,
+		setSelectedImages,
+		selectedFiles,
+		setSelectedFiles,
+		sendingDisabled,
+		enableButtons,
+		expandedRows,
+		setExpandedRows,
+		pendingUserMessage,
+		setPendingUserMessage,
+		textAreaRef,
+	} = chatState
+
+	const displayMessages = useMemo(() => {
+		if (
+			!pendingUserMessage ||
+			messages.some(
+				(message) => message.ts > pendingUserMessage.afterTs && sameUserMessage(message, pendingUserMessage.message),
+			)
+		) {
+			return messages
+		}
+		return [...messages, pendingUserMessage.message]
+	}, [messages, pendingUserMessage])
+
+	useEffect(() => {
+		if (
+			pendingUserMessage &&
+			messages.some(
+				(message) => message.ts > pendingUserMessage.afterTs && sameUserMessage(message, pendingUserMessage.message),
+			)
+		) {
+			setPendingUserMessage(undefined)
+		}
+	}, [messages, pendingUserMessage, setPendingUserMessage])
+
+	//const task = messages.length > 0 ? (messages[0].say === "task" ? messages[0] : undefined) : undefined) : undefined
+	const task = useMemo(() => messages.at(0), [messages]) // leaving this less safe version here since if the first message is not a task, then the extension is in a bad state and needs to be debugged (see Cline.abort)
+	const modifiedMessages = useMemo(() => {
+		const slicedMessages = displayMessages.slice(1)
+		// Only combine hook sequences if hooks are enabled
+		const withHooks = hooksEnabled ? combineHookSequences(slicedMessages) : slicedMessages
+		return combineErrorRetryMessages(combineApiRequests(combineCommandSequences(withHooks)))
+	}, [displayMessages, hooksEnabled])
+	// has to be after api_req_finished are all reduced into api_req_started messages
+	const apiMetrics = useMemo(() => getApiMetrics(modifiedMessages), [modifiedMessages])
+
+	const lastApiReqTotalTokens = useMemo(() => getLastApiReqTotalTokens(modifiedMessages) || undefined, [modifiedMessages])
+	const lastAppliedCheckpointRestoreSessionId = useRef<string | undefined>(checkpointRestoreInput?.sessionId)
+
+	useEffect(() => {
+		if (!checkpointRestoreInput || checkpointRestoreInput.sessionId === lastAppliedCheckpointRestoreSessionId.current) {
+			return
+		}
+		lastAppliedCheckpointRestoreSessionId.current = checkpointRestoreInput.sessionId
+		setInputValue(checkpointRestoreInput.text)
+		setSelectedImages(checkpointRestoreInput.images ?? [])
+		setSelectedFiles(checkpointRestoreInput.files ?? [])
+		setTimeout(() => {
+			textAreaRef.current?.focus()
+		}, 0)
+	}, [checkpointRestoreInput, setInputValue, setSelectedImages, setSelectedFiles, textAreaRef])
+
+	useEffect(() => {
+		const handleCopy = async (e: ClipboardEvent) => {
+			const targetElement = e.target as HTMLElement | null
+			// If the copy event originated from an input or textarea,
+			// let the default browser behavior handle it.
+			if (
+				targetElement &&
+				(targetElement.tagName === "INPUT" || targetElement.tagName === "TEXTAREA" || targetElement.isContentEditable)
+			) {
+				return
+			}
+
+			if (window.getSelection) {
+				const selection = window.getSelection()
+				if (selection && selection.rangeCount > 0) {
+					const range = selection.getRangeAt(0)
+					const commonAncestor = range.commonAncestorContainer
+					let textToCopy: string | null = null
+
+					// Check if the selection is inside an element where plain text copy is preferred
+					let currentElement =
+						commonAncestor.nodeType === Node.ELEMENT_NODE
+							? (commonAncestor as HTMLElement)
+							: commonAncestor.parentElement
+					let preferPlainTextCopy = false
+					while (currentElement) {
+						if (currentElement.tagName === "PRE" && currentElement.querySelector("code")) {
+							preferPlainTextCopy = true
+							break
+						}
+						// Check computed white-space style
+						const computedStyle = window.getComputedStyle(currentElement)
+						if (
+							computedStyle.whiteSpace === "pre" ||
+							computedStyle.whiteSpace === "pre-wrap" ||
+							computedStyle.whiteSpace === "pre-line"
+						) {
+							// If the element itself or an ancestor has pre-like white-space,
+							// and the selection is likely contained within it, prefer plain text.
+							// This helps with elements like the TaskHeader's text display.
+							preferPlainTextCopy = true
+							break
+						}
+
+						// Stop searching if we reach a known chat message boundary or body
+						if (
+							currentElement.classList.contains("chat-row-assistant-message-container") ||
+							currentElement.classList.contains("chat-row-user-message-container") ||
+							currentElement.tagName === "BODY"
+						) {
+							break
+						}
+						currentElement = currentElement.parentElement
+					}
+
+					if (preferPlainTextCopy) {
+						// For code blocks or elements with pre-formatted white-space, get plain text.
+						textToCopy = selection.toString()
+					} else {
+						// For other content, use the existing HTML-to-Markdown conversion
+						const clonedSelection = range.cloneContents()
+						const div = document.createElement("div")
+						div.appendChild(clonedSelection)
+						const selectedHtml = div.innerHTML
+						textToCopy = await convertHtmlToMarkdown(selectedHtml)
+					}
+
+					if (textToCopy !== null) {
+						try {
+							FileServiceClient.copyToClipboard(StringRequest.create({ value: textToCopy })).catch((err) => {
+								console.error("Error copying to clipboard:", err)
+							})
+							e.preventDefault()
+						} catch (error) {
+							console.error("Error copying to clipboard:", error)
+						}
+					}
+				}
+			}
+		}
+		document.addEventListener("copy", handleCopy)
+
+		return () => {
+			document.removeEventListener("copy", handleCopy)
+		}
+	}, [])
+	// Button state is now managed by useButtonState hook
+
+	// handleFocusChange is already provided by chatState
+
+	// Use message handlers hook
+	const messageHandlers = useMessageHandlers(messages, chatState)
+
+	const { selectedModelInfo } = useNormalizedApiConfiguration(mode)
+
+	const selectFilesAndImages = useCallback(async () => {
+		try {
+			const response = await FileServiceClient.selectFiles(
+				BooleanRequest.create({
+					value: selectedModelInfo.supportsImages,
+				}),
+			)
+			if (
+				response &&
+				response.values1 &&
+				response.values2 &&
+				(response.values1.length > 0 || response.values2.length > 0)
+			) {
+				const currentTotal = selectedImages.length + selectedFiles.length
+				const availableSlots = MAX_IMAGES_AND_FILES_PER_MESSAGE - currentTotal
+
+				if (availableSlots > 0) {
+					// Prioritize images first
+					const imagesToAdd = Math.min(response.values1.length, availableSlots)
+					if (imagesToAdd > 0) {
+						setSelectedImages((prevImages) => [...prevImages, ...response.values1.slice(0, imagesToAdd)])
+					}
+
+					// Use remaining slots for files
+					const remainingSlots = availableSlots - imagesToAdd
+					if (remainingSlots > 0) {
+						setSelectedFiles((prevFiles) => [...prevFiles, ...response.values2.slice(0, remainingSlots)])
+					}
+				}
+			}
+		} catch (error) {
+			console.error("Error selecting images & files:", error)
+		}
+	}, [selectedModelInfo.supportsImages])
+
+	const shouldDisableFilesAndImages = selectedImages.length + selectedFiles.length >= MAX_IMAGES_AND_FILES_PER_MESSAGE
+
+	// Subscribe to show webview events from the backend
+	useEffect(() => {
+		const cleanup = UiServiceClient.subscribeToShowWebview(
+			{},
+			{
+				onResponse: (event: any) => {
+					// Only focus if not hidden and preserveEditorFocus is false
+					if (!isHidden && !event.preserveEditorFocus) {
+						textAreaRef.current?.focus()
+					}
+				},
+				onError: (error: any) => {
+					console.error("Error in showWebview subscription:", error)
+				},
+				onComplete: () => {
+					console.log("showWebview subscription completed")
+				},
+			},
+		)
+
+		return cleanup
+	}, [isHidden])
+
+	// Set up addToInput subscription
+	useEffect(() => {
+		const cleanup = UiServiceClient.subscribeToAddToInput(
+			{},
+			{
+				onResponse: (event: any) => {
+					if (event.value) {
+						setInputValue((prevValue) => {
+							const newText = event.value
+							const newTextWithNewline = newText + "\n"
+							return prevValue ? `${prevValue}\n${newTextWithNewline}` : newTextWithNewline
+						})
+						// Add scroll to bottom after state update
+						// Auto focus the input and start the cursor on a new line for easy typing
+						setTimeout(() => {
+							if (textAreaRef.current) {
+								textAreaRef.current.scrollTop = textAreaRef.current.scrollHeight
+								textAreaRef.current.focus()
+							}
+						}, 0)
+					}
+				},
+				onError: (error: any) => {
+					console.error("Error in addToInput subscription:", error)
+				},
+				onComplete: () => {
+					console.log("addToInput subscription completed")
+				},
+			},
+		)
+
+		return cleanup
+	}, [])
+
+	useMount(() => {
+		// NOTE: the vscode window needs to be focused for this to work
+		textAreaRef.current?.focus()
+	})
+
+	useEffect(() => {
+		const timer = setTimeout(() => {
+			if (!isHidden && !sendingDisabled && !enableButtons) {
+				textAreaRef.current?.focus()
+			}
+		}, 50)
+		return () => {
+			clearTimeout(timer)
+		}
+	}, [isHidden, sendingDisabled, enableButtons])
+
+	const visibleMessages = useMemo(() => {
+		return filterVisibleMessages(modifiedMessages)
+	}, [modifiedMessages])
+
+	const groupedMessages = useMemo(() => {
+		return groupLowStakesTools(groupMessages(visibleMessages))
+	}, [visibleMessages])
+
+	// Use scroll behavior hook
+	const scrollBehavior = useScrollBehavior(displayMessages, visibleMessages, groupedMessages, expandedRows, setExpandedRows)
+
+	const placeholderText = useMemo(() => {
+		const text = task ? "Type a message..." : "Type your task here..."
+		return text
+	}, [task])
+
+	return (
+		<ChatLayout isHidden={isHidden}>
+			<div className="flex flex-col flex-1 overflow-hidden">
+				{showNavbar && <Navbar />}
+				{task ? (
+					<TaskSection
+						apiMetrics={apiMetrics}
+						lastApiReqTotalTokens={lastApiReqTotalTokens}
+						messageHandlers={messageHandlers}
+						selectedModelInfo={{
+							supportsPromptCache: selectedModelInfo.supportsPromptCache,
+							supportsImages: selectedModelInfo.supportsImages || false,
+						}}
+						task={task}
+					/>
+				) : (
+					<WelcomeSection
+						hideAnnouncement={hideAnnouncement}
+						shouldShowQuickWins={shouldShowQuickWins}
+						showAnnouncement={showAnnouncement}
+						showHistoryView={showHistoryView}
+						taskHistory={taskHistory}
+						telemetrySetting={telemetrySetting}
+						version={version}
+					/>
+				)}
+				{task && (
+					<MessagesArea
+						chatState={chatState}
+						groupedMessages={groupedMessages}
+						messageHandlers={messageHandlers}
+						modifiedMessages={modifiedMessages}
+						scrollBehavior={scrollBehavior}
+						task={task}
+					/>
+				)}
+			</div>
+			<footer className="bg-(--vscode-sidebar-background) flex flex-col" style={{ gridRow: "2" }}>
+				<AutoApproveBar />
+				<ActionButtons
+					chatState={chatState}
+					messageHandlers={messageHandlers}
+					messages={messages}
+					mode={mode}
+					task={task}
+				/>
+				<QueuedPrompts items={queuedPrompts} />
+				<InputSection
+					chatState={chatState}
+					messageHandlers={messageHandlers}
+					placeholderText={placeholderText}
+					scrollBehavior={scrollBehavior}
+					selectFilesAndImages={selectFilesAndImages}
+					shouldDisableFilesAndImages={shouldDisableFilesAndImages}
+				/>
+			</footer>
+		</ChatLayout>
+	)
+}
+
+export default ChatView
diff --git a/apps/vscode/webview-ui/src/components/chat/ClinePassLimitError.tsx b/apps/vscode/webview-ui/src/components/chat/ClinePassLimitError.tsx
new file mode 100644
index 0000000..2583bcf
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ClinePassLimitError.tsx
@@ -0,0 +1,72 @@
+import type { ApiConfiguration } from "@shared/api"
+import { UpdateApiConfigurationRequest } from "@shared/proto/cline/models"
+import { convertApiConfigurationToProto } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+
+interface ClinePassLimitErrorProps {
+	message: string
+}
+
+const CLINE_PROVIDER_ID = "cline"
+
+const getProviderSwitchConfig = (apiConfiguration: ApiConfiguration): ApiConfiguration => {
+	return {
+		...apiConfiguration,
+		planModeApiProvider: CLINE_PROVIDER_ID,
+		actModeApiProvider: CLINE_PROVIDER_ID,
+	}
+}
+
+const ClinePassLimitError = ({ message }: ClinePassLimitErrorProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const [isSwitching, setIsSwitching] = useState(false)
+	const [didSwitch, setDidSwitch] = useState(false)
+	const [error, setError] = useState<string | undefined>()
+
+	const handleSwitchToUsageBasedBilling = async () => {
+		setIsSwitching(true)
+		setError(undefined)
+		try {
+			const protoConfig = convertApiConfigurationToProto(getProviderSwitchConfig(apiConfiguration ?? {}))
+			await ModelsServiceClient.updateApiConfigurationProto(
+				UpdateApiConfigurationRequest.create({
+					apiConfiguration: protoConfig,
+				}),
+			)
+			setDidSwitch(true)
+		} catch (error) {
+			console.error("Failed to switch to Cline usage-based billing:", error)
+			setError("Failed to switch provider. Select Cline Usage-Billing in API Configuration settings.")
+		} finally {
+			setIsSwitching(false)
+		}
+	}
+
+	return (
+		<div
+			className="p-2 border-none rounded-md mb-2 bg-(--vscode-textBlockQuote-background)"
+			data-testid="cline-pass-limit-error">
+			<div className="text-error mb-2">ClinePass limit reached</div>
+			<div className="text-(--vscode-descriptionForeground) text-xs wrap-anywhere">{message}</div>
+			<div className="text-(--vscode-descriptionForeground) text-xs mt-2">
+				Would you like to switch to Usage-Based billing and retry with the Cline provider?
+			</div>
+			<VSCodeButton
+				appearance="primary"
+				className="w-full mt-3"
+				disabled={isSwitching || didSwitch}
+				onClick={handleSwitchToUsageBasedBilling}>
+				{isSwitching ? "Switching..." : didSwitch ? "Switched to Usage-Based billing" : "Switch to Usage-Based billing"}
+			</VSCodeButton>
+			{didSwitch && (
+				<div className="text-(--vscode-descriptionForeground) text-xs mt-2">Retry the request after switching.</div>
+			)}
+			{error && <div className="text-error text-xs mt-2">{error}</div>}
+		</div>
+	)
+}
+
+export default ClinePassLimitError
diff --git a/apps/vscode/webview-ui/src/components/chat/CommandOutputRow.test.tsx b/apps/vscode/webview-ui/src/components/chat/CommandOutputRow.test.tsx
new file mode 100644
index 0000000..1d0d699
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/CommandOutputRow.test.tsx
@@ -0,0 +1,79 @@
+import { act, render, waitFor } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import { CommandOutputContent } from "./CommandOutputRow"
+
+vi.mock("../common/CodeBlock", () => ({
+	default: ({ source }: { source: string }) => <pre>{source}</pre>,
+}))
+
+describe("CommandOutputContent", () => {
+	it("notifies when visible output changes", async () => {
+		const onOutputChange = vi.fn()
+		const { rerender } = render(
+			<CommandOutputContent
+				isContainerExpanded={true}
+				isOutputFullyExpanded={false}
+				onOutputChange={onOutputChange}
+				onToggle={vi.fn()}
+				output="first line"
+			/>,
+		)
+
+		await waitFor(() => expect(onOutputChange).toHaveBeenCalledTimes(1))
+
+		rerender(
+			<CommandOutputContent
+				isContainerExpanded={true}
+				isOutputFullyExpanded={false}
+				onOutputChange={onOutputChange}
+				onToggle={vi.fn()}
+				output={"first line\nsecond line"}
+			/>,
+		)
+
+		await waitFor(() => expect(onOutputChange).toHaveBeenCalledTimes(2))
+	})
+
+	it("notifies when visible output expansion changes", async () => {
+		const onOutputChange = vi.fn()
+		const { rerender } = render(
+			<CommandOutputContent
+				isContainerExpanded={true}
+				isOutputFullyExpanded={false}
+				onOutputChange={onOutputChange}
+				onToggle={vi.fn()}
+				output={"1\n2\n3\n4\n5\n6"}
+			/>,
+		)
+
+		await waitFor(() => expect(onOutputChange).toHaveBeenCalledTimes(1))
+
+		rerender(
+			<CommandOutputContent
+				isContainerExpanded={true}
+				isOutputFullyExpanded={true}
+				onOutputChange={onOutputChange}
+				onToggle={vi.fn()}
+				output={"1\n2\n3\n4\n5\n6"}
+			/>,
+		)
+
+		await waitFor(() => expect(onOutputChange).toHaveBeenCalledTimes(2))
+	})
+
+	it("does not notify while the container is collapsed", async () => {
+		const onOutputChange = vi.fn()
+		render(
+			<CommandOutputContent
+				isContainerExpanded={false}
+				isOutputFullyExpanded={false}
+				onOutputChange={onOutputChange}
+				onToggle={vi.fn()}
+				output="hidden"
+			/>,
+		)
+
+		await act(async () => {})
+		expect(onOutputChange).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/CommandOutputRow.tsx b/apps/vscode/webview-ui/src/components/chat/CommandOutputRow.tsx
new file mode 100644
index 0000000..35dd3fb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/CommandOutputRow.tsx
@@ -0,0 +1,279 @@
+import { COMMAND_OUTPUT_STRING, COMMAND_REQ_APP_STRING } from "@shared/combineCommandSequences"
+import { ClineMessage } from "@shared/ExtensionMessage"
+import { StringRequest } from "@shared/proto/cline/common"
+import { memo, useEffect, useRef } from "react"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+import { FileServiceClient } from "@/services/grpc-client"
+import CodeBlock from "../common/CodeBlock"
+import ExpandHandle from "./ExpandHandle"
+
+export const CommandOutputContent = memo(
+	({
+		output,
+		isOutputFullyExpanded,
+		onToggle,
+		isContainerExpanded,
+		onOutputChange,
+	}: {
+		output: string
+		isOutputFullyExpanded: boolean
+		onToggle: () => void
+		isContainerExpanded: boolean
+		onOutputChange?: () => void
+	}) => {
+		const outputLines = output.split("\n")
+		const lineCount = outputLines.length
+		const shouldAutoShow = lineCount <= 5
+		const outputRef = useRef<HTMLDivElement>(null)
+
+		// Auto-scroll to bottom when output changes (only when showing limited output)
+		useEffect(() => {
+			if (!isOutputFullyExpanded && outputRef.current) {
+				// Direct scrollTop manipulation
+				outputRef.current.scrollTop = outputRef.current.scrollHeight
+
+				// Another attempt with more delay (for slower renders) to ensure scrolling works
+				setTimeout(() => {
+					if (outputRef.current) {
+						outputRef.current.scrollTop = outputRef.current.scrollHeight
+					}
+				}, 50)
+			}
+		}, [output, isOutputFullyExpanded])
+
+		useEffect(() => {
+			if (isContainerExpanded) {
+				onOutputChange?.()
+			}
+		}, [output, isOutputFullyExpanded, isContainerExpanded, onOutputChange])
+
+		// Don't render anything if container is collapsed
+		if (!isContainerExpanded) {
+			return null
+		}
+
+		// Check if output contains a log file path indicator
+		const logFilePathMatch = output.match(/📋 Output is being logged to: ([^\n]+)/)
+		const logFilePath = logFilePathMatch ? logFilePathMatch[1].trim() : null
+
+		// Render output with clickable log file path
+		const renderOutput = () => {
+			if (!logFilePath) {
+				return <CodeBlock forceWrap={true} source={`${"```"}shell\n${output}\n${"```"}`} />
+			}
+
+			// Split output into parts: before log path, log path line, after log path
+			const logPathLineStart = output.indexOf("📋 Output is being logged to:")
+			const logPathLineEnd = output.indexOf("\n", logPathLineStart)
+			const beforeLogPath = output.substring(0, logPathLineStart)
+			const afterLogPath = logPathLineEnd !== -1 ? output.substring(logPathLineEnd) : ""
+
+			// Extract just the filename from the full path for display
+			const fileName = logFilePath.split("/").pop() || logFilePath
+
+			return (
+				<div className="border border-editor-group-border rounded-sm">
+					{beforeLogPath && <CodeBlock forceWrap={true} source={`${"```"}shell\n${beforeLogPath}\n${"```"}`} />}
+					<div
+						className="flex flex-wrap items-center gap-1.5 px-3 py-2 mx-2 my-1.5 rounded-sm bg-banner-background cursor-pointer hover:brightness-110 transition-colors"
+						onClick={() => {
+							FileServiceClient.openFile(StringRequest.create({ value: logFilePath })).catch((err) =>
+								console.error("Failed to open log file:", err),
+							)
+						}}
+						title={`Click to open: ${logFilePath}`}>
+						<span className="shrink-0">📋 Output is being logged to:</span>
+						<span className="text-vscode-textLink-foreground underline break-all">{fileName}</span>
+					</div>
+					{afterLogPath && <CodeBlock forceWrap={true} source={`${"```"}shell\n${afterLogPath}\n${"```"}`} />}
+				</div>
+			)
+		}
+
+		return (
+			<div
+				className={cn("w-full relative pb-0 overflow-visible border-t border-editor-group-border bg-code rounded-sm", {
+					"rounded-b-none": lineCount > 5,
+				})}>
+				<div
+					className={cn("text-white scroll-smooth bg-code overflow-y-auto", {
+						"max-h-[75px]": !shouldAutoShow && !isOutputFullyExpanded,
+						"max-h-[200px]": !shouldAutoShow && isOutputFullyExpanded,
+						"overflow-y-visible": shouldAutoShow,
+					})}
+					ref={outputRef}>
+					<div className="bg-code">{renderOutput()}</div>
+				</div>
+				{/* Show notch only if there's more than 5 lines */}
+				{lineCount > 5 && <ExpandHandle isExpanded={isOutputFullyExpanded} onToggle={onToggle} />}
+			</div>
+		)
+	},
+)
+
+CommandOutputContent.displayName = "CommandOutputContent"
+
+export const CommandOutputRow = memo(
+	({
+		message,
+		isCommandExecuting = false,
+		isCommandPending = false,
+		isCommandCompleted = false,
+		isBackgroundExec = false, // vscodeTerminalExecutionMode === "backgroundExec"
+		onCancelCommand,
+		icon,
+		title,
+		isOutputFullyExpanded,
+		setIsOutputFullyExpanded,
+		onOutputChange,
+	}: {
+		message: ClineMessage
+		isCommandExecuting?: boolean
+		isCommandPending?: boolean
+		isCommandCompleted?: boolean
+		isBackgroundExec?: boolean
+		onCancelCommand?: () => void
+		icon?: JSX.Element | null
+		title?: JSX.Element | null
+		isOutputFullyExpanded: boolean
+		setIsOutputFullyExpanded: (expanded: boolean) => void
+		onOutputChange?: () => void
+	}) => {
+		const splitMessage = (text: string) => {
+			const outputIndex = text.indexOf(COMMAND_OUTPUT_STRING)
+			if (outputIndex === -1) {
+				return { command: text, output: "" }
+			}
+			return {
+				command: text.slice(0, outputIndex).trim(),
+				output: text
+					.slice(outputIndex + COMMAND_OUTPUT_STRING.length)
+					.trim()
+					.split("")
+					.map((char) => {
+						switch (char) {
+							case "\t":
+								return "→   "
+							case "\b":
+								return "⌫"
+							case "\f":
+								return "⏏"
+							case "\v":
+								return "⇳"
+							default:
+								return char
+						}
+					})
+					.join(""),
+			}
+		}
+
+		const { command: rawCommand, output } = splitMessage(message.text || "")
+
+		const requestsApproval = rawCommand.endsWith(COMMAND_REQ_APP_STRING)
+		const command = requestsApproval ? rawCommand.slice(0, -COMMAND_REQ_APP_STRING.length) : rawCommand
+		const showCancelButton =
+			(isCommandExecuting || isCommandPending) && typeof onCancelCommand === "function" && isBackgroundExec
+
+		const commandHeader = (
+			<div className="flex items-center gap-2.5 mb-3">
+				{icon}
+				{title}
+			</div>
+		)
+
+		return (
+			<>
+				{commandHeader}
+				<div
+					className="bg-code rounded-sm border border-editor-group-border"
+					style={{
+						transition: "all 0.3s ease-in-out",
+					}}>
+					{command && (
+						<div className="bg-code flex items-center justify-between px-2 py-2.5 border-b border-editor-group-border rounded-sm rounded-b-none overflow-hidden">
+							<div className="flex items-center gap-2 flex-1 m-w-0">
+								<div
+									className={cn("bg-description rounded-full w-2 h-2 shrink-0", {
+										"bg-success animate-pulse": isCommandExecuting,
+										"bg-editor-warning-foreground": isCommandPending,
+									})}
+								/>
+								<span
+									className={cn("text-description font-medium text-base shrink-0", {
+										"text-success": isCommandExecuting,
+										"text-editor-warning-foreground": isCommandPending,
+									})}>
+									{getCommandStatusText(isCommandExecuting, isCommandPending, isCommandCompleted)}
+								</span>
+							</div>
+							<div className="flex items-center gap-2 shrink-0">
+								{showCancelButton && (
+									<Button
+										onClick={(e) => {
+											e.stopPropagation()
+											if (isBackgroundExec) {
+												onCancelCommand?.()
+											} else {
+												// For regular terminal mode, show a message
+												alert(
+													"This command is running in the VSCode terminal. You can manually stop it using Ctrl+C in the terminal, or switch to Background Execution mode in settings for cancellable commands.",
+												)
+											}
+										}}
+										size="sm"
+										variant="secondary">
+										{isBackgroundExec ? "cancel" : "stop"}
+									</Button>
+								)}
+							</div>
+						</div>
+					)}
+
+					<div className="bg-code opacity-60 text-sm">
+						<CodeBlock forceWrap={true} source={`${"```"}shell\n${command}\n${"```"}`} />
+					</div>
+
+					{output.length > 0 && (
+						<CommandOutputContent
+							isContainerExpanded={true}
+							isOutputFullyExpanded={isOutputFullyExpanded}
+							onToggle={() => setIsOutputFullyExpanded(!isOutputFullyExpanded)}
+							onOutputChange={onOutputChange}
+							output={output}
+						/>
+					)}
+				</div>
+				{requestsApproval && (
+					<div className="flex items-center gap-2.5 p-2 text-[12px] text-editor-warning-foreground">
+						<i className="codicon codicon-warning" />
+						<span>The model has determined this command requires explicit approval.</span>
+					</div>
+				)}
+			</>
+		)
+	},
+)
+
+CommandOutputRow.displayName = "CommandOutputRow"
+
+const CommandStatusMap = {
+	executing: "Running",
+	pending: "Pending",
+	completed: "Completed",
+	skipped: "Skipped",
+}
+
+function getCommandStatusText(isExecuting: boolean, isPending: boolean, isCompleted: boolean): string {
+	if (isExecuting) {
+		return CommandStatusMap.executing
+	}
+	if (isPending) {
+		return CommandStatusMap.pending
+	}
+	if (isCompleted) {
+		return CommandStatusMap.completed
+	}
+	return CommandStatusMap.skipped
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/CompletionOutputRow.tsx b/apps/vscode/webview-ui/src/components/chat/CompletionOutputRow.tsx
new file mode 100644
index 0000000..632e9d4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/CompletionOutputRow.tsx
@@ -0,0 +1,44 @@
+import { CheckIcon } from "lucide-react"
+import { memo } from "react"
+import { cn } from "@/lib/utils"
+import { CopyButton } from "../common/CopyButton"
+import { QuoteButtonState } from "./ChatRow"
+import { MarkdownRow } from "./MarkdownRow"
+import QuoteButton from "./QuoteButton"
+
+interface CompletionOutputRowProps {
+	text: string
+	quoteButtonState: QuoteButtonState
+	handleQuoteClick: () => void
+	headClassNames?: string
+}
+
+export const CompletionOutputRow = memo(
+	({ headClassNames, text, quoteButtonState, handleQuoteClick }: CompletionOutputRowProps) => {
+		return (
+			<div>
+				<div className="rounded-sm border border-success/20 overflow-visible bg-success/10 p-2 pt-3">
+					{/* Title */}
+					<div className={cn(headClassNames, "justify-between px-1")}>
+						<div className="flex gap-2 items-center">
+							<CheckIcon className="size-3 text-success" />
+							<span className="text-success font-bold">Task Completed</span>
+						</div>
+						<CopyButton className="text-success" textToCopy={text} />
+					</div>
+					{/* Content */}
+					<div className="w-full relative border-t-1 border-description/20 rounded-b-sm">
+						<div className="completion-output-content p-2 pt-3 w-full [&_hr]:opacity-20 [&_p:last-child]:mb-0 rounded-sm">
+							<MarkdownRow markdown={text} />
+							{quoteButtonState.visible && (
+								<QuoteButton left={quoteButtonState.left} onClick={handleQuoteClick} top={quoteButtonState.top} />
+							)}
+						</div>
+					</div>
+				</div>
+			</div>
+		)
+	},
+)
+
+CompletionOutputRow.displayName = "CompletionOutputRow"
diff --git a/apps/vscode/webview-ui/src/components/chat/ContextMenu.tsx b/apps/vscode/webview-ui/src/components/chat/ContextMenu.tsx
new file mode 100644
index 0000000..c82b7cb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ContextMenu.tsx
@@ -0,0 +1,366 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { cleanPathPrefix } from "@/components/common/CodeAccordian"
+import ScreenReaderAnnounce from "@/components/common/ScreenReaderAnnounce"
+import { useMenuAnnouncement } from "@/hooks/useMenuAnnouncement"
+import { ContextMenuOptionType, ContextMenuQueryItem, getContextMenuOptions, SearchResult } from "@/utils/context-mentions"
+
+interface ContextMenuProps {
+	onSelect: (type: ContextMenuOptionType, value?: string) => void
+	searchQuery: string
+	onMouseDown: () => void
+	selectedIndex: number
+	setSelectedIndex: (index: number) => void
+	selectedType: ContextMenuOptionType | null
+	queryItems: ContextMenuQueryItem[]
+	dynamicSearchResults?: SearchResult[]
+	isLoading?: boolean
+}
+
+const ContextMenu: React.FC<ContextMenuProps> = ({
+	onSelect,
+	searchQuery,
+	onMouseDown,
+	selectedIndex,
+	setSelectedIndex,
+	selectedType,
+	queryItems,
+	dynamicSearchResults = [],
+	isLoading = false,
+}) => {
+	const menuRef = useRef<HTMLDivElement>(null)
+
+	// State to show delayed loading indicator
+	const [showDelayedLoading, setShowDelayedLoading] = useState(false)
+	const loadingTimeoutRef = useRef<NodeJS.Timeout | null>(null)
+
+	const filteredOptions = useMemo(() => {
+		const options = getContextMenuOptions(searchQuery, selectedType, queryItems, dynamicSearchResults)
+		// While a search is in flight, don't tell the user "No results found" —
+		// the answer is "still searching", not "nothing matched". Suppress
+		// eagerly on `isLoading` (not just after the 500 ms spinner delay) so
+		// there's no NoResults flicker before the spinner appears.
+		if (isLoading && options.length === 1 && options[0].type === ContextMenuOptionType.NoResults) {
+			return []
+		}
+		return options
+	}, [searchQuery, selectedType, queryItems, dynamicSearchResults, isLoading])
+
+	// Effect to handle delayed loading indicator (show "Searching..." after 500ms of searching)
+	useEffect(() => {
+		if (loadingTimeoutRef.current) {
+			clearTimeout(loadingTimeoutRef.current)
+			loadingTimeoutRef.current = null
+		}
+
+		// Arm the timer whenever a search is in flight. Don't gate on
+		// `searchQuery`: the "Add File"/"Add Folder" flow runs ripgrep on an
+		// empty query, and the render site already guards with
+		// `filteredOptions.length === 0` so the spinner stays hidden when
+		// real options are showing.
+		if (isLoading) {
+			setShowDelayedLoading(false)
+			loadingTimeoutRef.current = setTimeout(() => {
+				if (isLoading) {
+					setShowDelayedLoading(true)
+				}
+			}, 500)
+		} else {
+			setShowDelayedLoading(false)
+		}
+
+		// Cleanup timeout on unmount or when dependencies change
+		return () => {
+			if (loadingTimeoutRef.current) {
+				clearTimeout(loadingTimeoutRef.current)
+				loadingTimeoutRef.current = null
+			}
+		}
+	}, [isLoading, searchQuery])
+
+	useEffect(() => {
+		if (menuRef.current) {
+			const selectedElement = menuRef.current.children[selectedIndex] as HTMLElement
+			if (selectedElement) {
+				const menuRect = menuRef.current.getBoundingClientRect()
+				const selectedRect = selectedElement.getBoundingClientRect()
+
+				if (selectedRect.bottom > menuRect.bottom) {
+					menuRef.current.scrollTop += selectedRect.bottom - menuRect.bottom
+				} else if (selectedRect.top < menuRect.top) {
+					menuRef.current.scrollTop -= menuRect.top - selectedRect.top
+				}
+			}
+		}
+	}, [selectedIndex])
+
+	// Shared label definitions for simple option types
+	const SIMPLE_OPTION_LABELS: Partial<Record<ContextMenuOptionType, string>> = {
+		[ContextMenuOptionType.Problems]: "Problems",
+		[ContextMenuOptionType.Terminal]: "Terminal",
+		[ContextMenuOptionType.URL]: "Paste URL to fetch contents",
+		[ContextMenuOptionType.NoResults]: "No results found",
+	}
+
+	// Get accessible label for an option (used for screen readers and aria-label)
+	const getOptionLabel = useCallback((option: ContextMenuQueryItem): string => {
+		// Check simple labels first
+		const simpleLabel = SIMPLE_OPTION_LABELS[option.type]
+		if (simpleLabel) {
+			return simpleLabel
+		}
+
+		switch (option.type) {
+			case ContextMenuOptionType.Git:
+				if (option.value) {
+					return `${option.label}${option.description ? `, ${option.description}` : ""}`
+				}
+				return "Git Commits"
+			case ContextMenuOptionType.File:
+			case ContextMenuOptionType.Folder:
+				if (option.value) {
+					return option.label || option.value
+				}
+				return `Add ${option.type === ContextMenuOptionType.File ? "File" : "Folder"}`
+			default:
+				return option.label || option.value || ""
+		}
+	}, [])
+
+	const renderOptionContent = (option: ContextMenuQueryItem) => {
+		// Handle simple label types
+		const simpleLabel = SIMPLE_OPTION_LABELS[option.type]
+		if (simpleLabel) {
+			return <span>{simpleLabel}</span>
+		}
+
+		switch (option.type) {
+			case ContextMenuOptionType.Git:
+				if (option.value) {
+					return (
+						<div style={{ display: "flex", flexDirection: "column", gap: 0 }}>
+							<span className="ph-no-capture" style={{ lineHeight: "1.2" }}>
+								{option.label}
+							</span>
+							<span
+								className="ph-no-capture"
+								style={{
+									fontSize: "0.85em",
+									opacity: 0.7,
+									whiteSpace: "nowrap",
+									overflow: "hidden",
+									textOverflow: "ellipsis",
+									lineHeight: "1.2",
+								}}>
+								{option.description}
+							</span>
+						</div>
+					)
+				}
+				return <span>Git Commits</span>
+			case ContextMenuOptionType.File:
+			case ContextMenuOptionType.Folder:
+				if (option.value) {
+					// Use label if it differs from just the basename (indicates workspace prefix or custom label)
+					const displayText =
+						option.label && option.label !== option.value.split("/").pop() ? option.label : option.value
+
+					return (
+						<>
+							{!displayText.includes(":") && <span>/</span>}
+							{displayText.startsWith("/.") && <span>.</span>}
+							<span
+								className="ph-no-capture"
+								style={{
+									whiteSpace: "nowrap",
+									overflow: "hidden",
+									textOverflow: "ellipsis",
+									direction: displayText.includes(":") ? "ltr" : "rtl",
+									textAlign: "left",
+								}}>
+								{displayText.includes(":") ? displayText : cleanPathPrefix(displayText) + "\u200E"}
+							</span>
+						</>
+					)
+				}
+				return <span>Add {option.type === ContextMenuOptionType.File ? "File" : "Folder"}</span>
+			default:
+				return null
+		}
+	}
+
+	const getIconForOption = (option: ContextMenuQueryItem): string => {
+		switch (option.type) {
+			case ContextMenuOptionType.File:
+				return "file"
+			case ContextMenuOptionType.Folder:
+				return "folder"
+			case ContextMenuOptionType.Problems:
+				return "warning"
+			case ContextMenuOptionType.Terminal:
+				return "terminal"
+			case ContextMenuOptionType.URL:
+				return "link"
+			case ContextMenuOptionType.Git:
+				return "git-commit"
+			case ContextMenuOptionType.NoResults:
+				return "info"
+			default:
+				return "file"
+		}
+	}
+
+	const isOptionSelectable = (option: ContextMenuQueryItem): boolean => {
+		return option.type !== ContextMenuOptionType.NoResults && option.type !== ContextMenuOptionType.URL
+	}
+
+	// Screen reader announcements
+	const { announcement } = useMenuAnnouncement({
+		items: filteredOptions,
+		selectedIndex,
+		getItemLabel: getOptionLabel,
+		isItemSelectable: isOptionSelectable,
+	})
+
+	// Handle selection with announcement
+	const handleSelect = useCallback(
+		(option: ContextMenuQueryItem) => {
+			if (isOptionSelectable(option)) {
+				const mentionValue = option.label?.includes(":") ? option.label : option.value
+				onSelect(option.type, mentionValue)
+			}
+		},
+		[onSelect],
+	)
+
+	return (
+		<div
+			onMouseDown={onMouseDown}
+			style={{
+				position: "absolute",
+				bottom: "calc(100% - 10px)",
+				left: 15,
+				right: 15,
+				overflowX: "hidden",
+			}}>
+			<ScreenReaderAnnounce message={announcement} />
+			<div
+				aria-activedescendant={
+					filteredOptions.length > selectedIndex &&
+					selectedIndex > -1 &&
+					isOptionSelectable(filteredOptions[selectedIndex])
+						? `context-menu-item-${selectedIndex}`
+						: undefined
+				}
+				aria-label="Context mentions"
+				ref={menuRef}
+				role="listbox"
+				style={{
+					backgroundColor: "var(--vscode-dropdown-background)",
+					border: "1px solid var(--vscode-editorGroup-border)",
+					borderRadius: "3px",
+					boxShadow: "0 4px 10px rgba(0, 0, 0, 0.25)",
+					zIndex: 1000,
+					display: "flex",
+					flexDirection: "column",
+					maxHeight: "200px",
+					overflowY: "auto",
+				}}>
+				{/* Can't use virtuoso since it requires fixed height and menu height is dynamic based on # of items */}
+				{showDelayedLoading && filteredOptions.length === 0 && (
+					<div
+						style={{
+							padding: "8px 12px",
+							display: "flex",
+							alignItems: "center",
+							gap: "8px",
+							opacity: 0.7,
+						}}>
+						<i className="codicon codicon-loading codicon-modifier-spin" style={{ fontSize: "14px" }} />
+						<span>Searching...</span>
+					</div>
+				)}
+				{filteredOptions.map((option, index) => {
+					// Include workspace name in key for files/folders to handle duplicates across workspaces
+					const workspacePrefix = option.workspaceName ? `${option.workspaceName}:` : ""
+					const generatedKey = `${option.type}-${workspacePrefix}${option.value || index}`
+
+					return (
+						<div
+							aria-label={getOptionLabel(option)}
+							aria-selected={index === selectedIndex && isOptionSelectable(option)}
+							id={`context-menu-item-${index}`}
+							key={generatedKey}
+							onClick={() => handleSelect(option)}
+							onMouseEnter={() => isOptionSelectable(option) && setSelectedIndex(index)}
+							role="option"
+							style={{
+								padding: "8px 12px",
+								cursor: isOptionSelectable(option) ? "pointer" : "default",
+								color:
+									index === selectedIndex && isOptionSelectable(option)
+										? "var(--vscode-quickInputList-focusForeground)"
+										: "",
+								borderBottom: "1px solid var(--vscode-editorGroup-border)",
+								display: "flex",
+								alignItems: "center",
+								justifyContent: "space-between",
+								backgroundColor:
+									index === selectedIndex && isOptionSelectable(option)
+										? "var(--vscode-quickInputList-focusBackground)"
+										: "",
+							}}>
+							<div
+								style={{
+									display: "flex",
+									alignItems: "center",
+									flex: 1,
+									minWidth: 0,
+									overflow: "hidden",
+								}}>
+								<i
+									className={`codicon codicon-${getIconForOption(option)}`}
+									style={{
+										marginRight: "8px",
+										flexShrink: 0,
+										fontSize: "14px",
+									}}
+								/>
+								{renderOptionContent(option)}
+							</div>
+							{(option.type === ContextMenuOptionType.File ||
+								option.type === ContextMenuOptionType.Folder ||
+								option.type === ContextMenuOptionType.Git) &&
+								!option.value && (
+									<i
+										className="codicon codicon-chevron-right"
+										style={{
+											fontSize: "14px",
+											flexShrink: 0,
+											marginLeft: 8,
+										}}
+									/>
+								)}
+							{(option.type === ContextMenuOptionType.Problems ||
+								option.type === ContextMenuOptionType.Terminal ||
+								((option.type === ContextMenuOptionType.File ||
+									option.type === ContextMenuOptionType.Folder ||
+									option.type === ContextMenuOptionType.Git) &&
+									option.value)) && (
+								<i
+									className="codicon codicon-add"
+									style={{
+										fontSize: "14px",
+										flexShrink: 0,
+										marginLeft: 8,
+									}}
+								/>
+							)}
+						</div>
+					)
+				})}
+			</div>
+		</div>
+	)
+}
+
+export default ContextMenu
diff --git a/apps/vscode/webview-ui/src/components/chat/CreditLimitError.tsx b/apps/vscode/webview-ui/src/components/chat/CreditLimitError.tsx
new file mode 100644
index 0000000..b1d19d1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/CreditLimitError.tsx
@@ -0,0 +1,95 @@
+import { AskResponseRequest } from "@shared/proto/cline/task"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import React, { useEffect, useMemo, useState } from "react"
+import VSCodeButtonLink from "@/components/common/VSCodeButtonLink"
+import { useClineAuth } from "@/context/ClineAuthContext"
+import { AccountServiceClient, TaskServiceClient } from "@/services/grpc-client"
+
+interface CreditLimitErrorProps {
+	currentBalance: number
+	totalSpent?: number
+	totalPromotions?: number
+	message: string
+	buyCreditsUrl?: string
+}
+
+const DEFAULT_BUY_CREDITS_URL = {
+	USER: "https://app.cline.bot/dashboard/account?tab=credits&redirect=true",
+	ORG: "https://app.cline.bot/dashboard/organization?tab=credits&redirect=true",
+}
+
+const CreditLimitError: React.FC<CreditLimitErrorProps> = ({
+	message = "You have run out of credits.",
+	buyCreditsUrl,
+	currentBalance,
+	totalPromotions,
+	totalSpent,
+}) => {
+	const { activeOrganization } = useClineAuth()
+	const [fullBuyCreditsUrl, setFullBuyCreditsUrl] = useState<string>("")
+
+	const dashboardUrl = useMemo(() => {
+		return buyCreditsUrl ?? (activeOrganization?.organizationId ? DEFAULT_BUY_CREDITS_URL.ORG : DEFAULT_BUY_CREDITS_URL.USER)
+	}, [buyCreditsUrl, activeOrganization?.organizationId])
+
+	useEffect(() => {
+		const fetchCallbackUrl = async () => {
+			try {
+				const callbackUrl = (await AccountServiceClient.getRedirectUrl({})).value
+				const url = new URL(dashboardUrl)
+				url.searchParams.set("callback_url", callbackUrl)
+				setFullBuyCreditsUrl(url.toString())
+			} catch (error) {
+				console.error("Error fetching callback URL:", error)
+				// Fallback to URL without callback if the API call fails
+				setFullBuyCreditsUrl(dashboardUrl)
+			}
+		}
+		fetchCallbackUrl()
+	}, [dashboardUrl])
+
+	// We have to divide because the balance is stored in microcredits
+	return (
+		<div className="p-2 border-none rounded-md mb-2 bg-(--vscode-textBlockQuote-background)">
+			<div className="mb-3 font-azeret-mono">
+				<div className="text-error mb-2">{message}</div>
+				<div className="mb-3">
+					{currentBalance ? (
+						<div className="text-foreground">
+							Current Balance: <span className="font-bold">{currentBalance.toFixed(2)}</span>
+						</div>
+					) : null}
+					{totalSpent ? <div className="text-foreground">Total Spent: {totalSpent.toFixed(2)}</div> : null}
+					{totalPromotions ? (
+						<div className="text-foreground">Total Promotions: {totalPromotions.toFixed(2)}</div>
+					) : null}
+				</div>
+			</div>
+
+			<VSCodeButtonLink className="w-full mb-2" href={fullBuyCreditsUrl}>
+				<span className="codicon codicon-credit-card mr-[6px] text-[14px]" />
+				Buy Credits
+			</VSCodeButtonLink>
+
+			<VSCodeButton
+				appearance="secondary"
+				className="w-full"
+				onClick={async () => {
+					try {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+							}),
+						)
+					} catch (error) {
+						console.error("Error invoking action:", error)
+					}
+				}}>
+				<span className="codicon codicon-refresh mr-1.5" />
+				Retry Request
+			</VSCodeButton>
+		</div>
+	)
+}
+
+export default CreditLimitError
diff --git a/apps/vscode/webview-ui/src/components/chat/DiffEditRow.tsx b/apps/vscode/webview-ui/src/components/chat/DiffEditRow.tsx
new file mode 100644
index 0000000..adb5bd2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/DiffEditRow.tsx
@@ -0,0 +1,485 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { FilePlus, FileText, FileX, SquareArrowOutUpRightIcon } from "lucide-react"
+import { memo, useEffect, useMemo, useRef, useState } from "react"
+import { cn } from "@/lib/utils"
+import { FileServiceClient } from "@/services/grpc-client"
+
+interface Patch {
+	action: string
+	path: string
+	lines: string[]
+	additions: number
+	deletions: number
+}
+
+// Constants for format markers
+const MARKERS = {
+	SEARCH_BLOCK: "------- SEARCH",
+	SEARCH_SEPARATOR: "=======",
+	REPLACE_BLOCK: "+++++++ REPLACE",
+	NEW_BEGIN: "*** Begin Patch",
+	NEW_END: "*** End Patch",
+	FILE_PATTERN: /^\*\*\* (Add|Update|Delete) File: (.+)$/m,
+} as const
+
+// Style mappings for actions
+const ACTION_STYLES = {
+	Add: { icon: FilePlus, iconClass: "text-success", borderClass: "border-l-success" },
+	Delete: { icon: FileX, iconClass: "text-error", borderClass: "border-l-error" },
+	default: { icon: FileText, iconClass: "text-info", borderClass: "border-l-background" },
+} as const
+
+interface DiffEditRowProps {
+	patch: string
+	path: string
+	isLoading?: boolean
+	startLineNumbers?: number[]
+}
+
+export const DiffEditRow = memo<DiffEditRowProps>(({ patch, path, isLoading, startLineNumbers }) => {
+	const { parsedFiles, isStreaming } = useMemo(() => {
+		const parsed = parsePatch(patch, path)
+		return {
+			parsedFiles: parsed.parsedFiles,
+			isStreaming: isLoading || parsed.isStreaming,
+		}
+	}, [patch, path, isLoading])
+
+	if (!path) {
+		return null
+	}
+
+	return (
+		<div className="space-y-4 rounded-xs">
+			{parsedFiles.map((file, index) => (
+				<FileBlock
+					file={file}
+					isStreaming={isStreaming}
+					key={`${file.path}-${index}`}
+					startLineNumber={startLineNumbers?.[index]}
+				/>
+			))}
+		</div>
+	)
+})
+
+const FileBlock = memo<{ file: Patch; isStreaming: boolean; startLineNumber?: number }>(
+	({ file, isStreaming, startLineNumber }) => {
+		const [isExpanded, setIsExpanded] = useState(true)
+		const scrollContainerRef = useRef<HTMLDivElement>(null)
+		const shouldFollowRef = useRef(true)
+		const isProgrammaticScrollRef = useRef(false)
+
+		// Auto-scroll to bottom during streaming
+		useEffect(() => {
+			const container = scrollContainerRef.current
+			if (!isExpanded || !isStreaming || !shouldFollowRef.current || !container) {
+				return
+			}
+
+			isProgrammaticScrollRef.current = true
+			container.scrollTop = container.scrollHeight - container.clientHeight
+
+			requestAnimationFrame(() => {
+				isProgrammaticScrollRef.current = false
+			})
+		}, [file.lines.length, isExpanded, isStreaming])
+
+		const handleScroll = () => {
+			const container = scrollContainerRef.current
+			if (!container || isProgrammaticScrollRef.current) {
+				return
+			}
+
+			const { scrollTop, scrollHeight, clientHeight } = container
+			shouldFollowRef.current = Math.abs(scrollHeight - clientHeight - scrollTop) < 10
+		}
+
+		const handleOpenFile = (event: React.MouseEvent) => {
+			event.stopPropagation()
+
+			if (file.path) {
+				FileServiceClient.openFileRelativePath(StringRequest.create({ value: file.path })).catch((err) =>
+					console.error("Failed to open file:", err),
+				)
+			}
+		}
+
+		const actionStyle = ACTION_STYLES[file.action as keyof typeof ACTION_STYLES] ?? ACTION_STYLES.default
+		const ActionIcon = actionStyle.icon
+
+		// Only calculate line numbers if we have actual positions from the backend
+		// When startLineNumber is undefined (e.g., V2 diff or no match indices), we skip line numbers entirely
+		const lineNumbers = useMemo(() => {
+			if (startLineNumber === undefined) return undefined
+
+			let oldLine = startLineNumber
+			let newLine = startLineNumber
+
+			return file.lines.map((line) => {
+				const isAddition = line.startsWith("+")
+				const isDeletion = line.startsWith("-")
+				const isContext = !isAddition && !isDeletion
+
+				if (isDeletion) {
+					const display = oldLine
+					oldLine += 1
+					return display
+				}
+
+				const display = newLine
+				newLine += 1
+				if (isContext) {
+					oldLine += 1
+				}
+				return display
+			})
+		}, [file.lines, startLineNumber])
+
+		return (
+			<div className="bg-code rounded-xs border border-editor-group-border overflow-hidden">
+				<button
+					className="w-full flex items-center gap-2 p-2 bg-code transition-colors justify-between cursor-pointer"
+					onClick={() => setIsExpanded((prev) => !prev)}
+					type="button">
+					<div className="flex items-center gap-3 flex-1 w-full overflow-hidden">
+						<div className={cn("flex items-center gap-2 w-full", actionStyle.borderClass)}>
+							<ActionIcon className={cn("w-5 h-5", actionStyle.iconClass)} />
+							<span
+								className="font-medium truncate hover:underline hover:text-link"
+								onClick={handleOpenFile}
+								title="Open file in editor">
+								{file.path}
+							</span>
+						</div>
+					</div>
+					<div className="flex items-center gap-2">
+						<DiffStats additions={file.additions} deletions={file.deletions} />
+						<span
+							className="p-1 hover:bg-description/20 rounded-xs transition-colors"
+							onClick={handleOpenFile}
+							title="Open file in editor">
+							<SquareArrowOutUpRightIcon className="size-2 text-description hover:text-foreground" />
+						</span>
+					</div>
+				</button>
+
+				{isExpanded && (
+					<div
+						className="border-t border-code-block-background max-h-80 overflow-y-auto overflow-x-auto"
+						onScroll={handleScroll}
+						ref={scrollContainerRef}>
+						<div className="font-mono text-xs w-max min-w-full">
+							{file.lines.map((line, index) => (
+								<DiffLine key={`${index}-${line.slice(0, 20)}`} line={line} lineNumber={lineNumbers?.[index]} />
+							))}
+						</div>
+					</div>
+				)}
+			</div>
+		)
+	},
+	(prev, next) =>
+		prev.isStreaming === next.isStreaming &&
+		prev.startLineNumber === next.startLineNumber &&
+		prev.file.path === next.file.path &&
+		prev.file.action === next.file.action &&
+		prev.file.additions === next.file.additions &&
+		prev.file.deletions === next.file.deletions &&
+		prev.file.lines === next.file.lines,
+)
+
+const DiffStats = memo<{ additions: number; deletions: number }>(({ additions, deletions }) => (
+	<div className="text-xs text-gray-500 flex">
+		{additions > 0 && <span className="text-success">+{additions}</span>}
+		{additions > 0 && deletions > 0 && <span className="mx-1">·</span>}
+		{deletions > 0 && <span className="text-error">-{deletions}</span>}
+	</div>
+))
+
+// Diff line component with Tailwind styling - indicator bar, line number, prefix, code
+const DiffLine = memo<{ line: string; lineNumber?: number; showLineNumberColumn?: boolean }>(
+	({ line, lineNumber, showLineNumberColumn = true }) => {
+		const isAddition = line.startsWith("+")
+		const isDeletion = line.startsWith("-")
+		const hasSpacePrefix = line.startsWith("+ ") || line.startsWith("- ")
+		// Extract just the code content (without +/- prefix)
+		const code = isAddition || isDeletion ? line.slice(hasSpacePrefix ? 2 : 1) : line
+		// Get the prefix character to display
+		const prefix = isAddition ? "+" : isDeletion ? "-" : " "
+
+		return (
+			<div
+				className={cn(
+					"flex text-xs font-mono",
+					// Row background tint
+					isAddition && "bg-green-500/10",
+					isDeletion && "bg-red-500/10",
+					// Left indicator bar (the colored stripe)
+					isAddition && "border-l-4 border-l-green-500",
+					isDeletion && "border-l-4 border-l-red-500",
+					!isAddition && !isDeletion && "border-l-4 border-l-transparent",
+				)}>
+				{/* Line number column - always reserve space to prevent layout shift during streaming */}
+				{showLineNumberColumn && (
+					<span
+						className={cn(
+							"w-10 min-w-10 text-right pr-2 py-0.5 select-none border-r border-code-block-background/50",
+							isAddition && "text-green-400/60",
+							isDeletion && "text-red-400/60",
+							!isAddition && !isDeletion && "text-description/50",
+						)}>
+						{lineNumber ?? ""}
+					</span>
+				)}
+				{/* Prefix character (+/-) for backwards compatibility with traditional diff views */}
+				<span
+					className={cn(
+						"w-4 min-w-4 text-center py-0.5 select-none",
+						isAddition && "text-green-400",
+						isDeletion && "text-red-400",
+						!isAddition && !isDeletion && "text-description/50",
+					)}>
+					{prefix}
+				</span>
+				{/* Code content */}
+				<span
+					className={cn(
+						"flex-1 pr-2 py-0.5 whitespace-nowrap",
+						isAddition && "text-green-400",
+						isDeletion && "text-red-400",
+						!isAddition && !isDeletion && "text-editor-foreground",
+					)}>
+					{code}
+				</span>
+			</div>
+		)
+	},
+)
+
+// ============================================================================
+// Parsing Functions
+// ============================================================================
+
+interface ParseResult {
+	parsedFiles: Patch[]
+	isStreaming: boolean
+}
+
+/**
+ * Main parsing function that detects format and delegates to appropriate parser
+ */
+function parsePatch(patch: string, path: string): ParseResult {
+	// Try old format first (------- SEARCH / ======= / +++++++ REPLACE)
+	if (patch.includes(MARKERS.SEARCH_BLOCK)) {
+		const results = parseAllSearchReplaceBlocks(patch, path)
+		if (results.length > 0) {
+			// Count how many complete blocks we have (those ending with REPLACE marker)
+			const replaceCount = (patch.match(/\+{7,} REPLACE/g) || []).length
+			const searchCount = (patch.match(/-{7,} SEARCH/g) || []).length
+			return {
+				parsedFiles: results,
+				isStreaming: replaceCount < searchCount,
+			}
+		}
+	}
+
+	// Try new format (*** Begin Patch / *** End Patch)
+	if (patch.includes(MARKERS.NEW_BEGIN)) {
+		const endIndex = patch.indexOf(MARKERS.NEW_END)
+		const isComplete = endIndex !== -1
+
+		const beginIndex = patch.indexOf(MARKERS.NEW_BEGIN)
+		const contentStart = beginIndex + MARKERS.NEW_BEGIN.length
+		const contentEnd = isComplete ? endIndex : patch.length
+		const patchContent = patch.substring(contentStart, contentEnd).trim()
+
+		const parsed = parseNewFormat(patchContent)
+		if (parsed.length > 0) {
+			return { parsedFiles: parsed, isStreaming: !isComplete }
+		}
+	}
+
+	// Fallback: treat entire patch as a new file addition
+	if (path && patch) {
+		const lines = patch.split("\n")
+		return {
+			parsedFiles: [
+				{
+					action: "Add",
+					path,
+					lines: lines.map((line) => `+ ${line}`),
+					additions: lines.length,
+					deletions: 0,
+				},
+			],
+			isStreaming: true,
+		}
+	}
+
+	return { parsedFiles: [], isStreaming: true }
+}
+
+/**
+ * Parse new format patches (*** Add/Update/Delete File: path)
+ * Splits each @@ chunk into a separate Patch object so each chunk can have its own startLineNumber
+ */
+function parseNewFormat(content: string): Patch[] {
+	const files: Patch[] = []
+	const lines = content.split("\n")
+
+	let currentFile: { action: string; path: string } | null = null
+	let currentChunk: Patch | null = null
+
+	const pushCurrentChunk = () => {
+		if (currentChunk && currentChunk.lines.length > 0) {
+			files.push(currentChunk)
+		}
+	}
+
+	const startNewChunk = () => {
+		if (!currentFile) return
+		pushCurrentChunk()
+		currentChunk = {
+			action: currentFile.action,
+			path: currentFile.path,
+			lines: [],
+			additions: 0,
+			deletions: 0,
+		}
+	}
+
+	for (const line of lines) {
+		const fileMatch = line.match(/^\*\*\* (Add|Update|Delete) File: (.+)$/)
+
+		if (fileMatch) {
+			// New file - push any existing chunk and start fresh
+			pushCurrentChunk()
+			currentFile = {
+				action: fileMatch[1],
+				path: fileMatch[2].trim(),
+			}
+			currentChunk = null // Will be created when we see content or @@
+		} else if (line.trim() === "@@") {
+			// @@ marker means start of a new chunk - split here
+			startNewChunk()
+		} else if (currentFile && line.trim()) {
+			// Content line - ensure we have a chunk to add to
+			if (!currentChunk) {
+				currentChunk = {
+					action: currentFile.action,
+					path: currentFile.path,
+					lines: [],
+					additions: 0,
+					deletions: 0,
+				}
+			}
+			currentChunk.lines.push(line)
+			if (line[0] === "+") {
+				currentChunk.additions++
+			} else if (line[0] === "-") {
+				currentChunk.deletions++
+			}
+		}
+	}
+
+	// Push the last chunk
+	pushCurrentChunk()
+
+	return files
+}
+
+/**
+ * Parse all SEARCH/REPLACE blocks from a diff string
+ * Returns an array of Patch objects, one per SEARCH/REPLACE block
+ */
+function parseAllSearchReplaceBlocks(patch: string, path: string): Patch[] {
+	const results: Patch[] = []
+	const searchRegex = /-{7,} SEARCH/g
+	let match: RegExpExecArray | null
+
+	// Find all SEARCH markers and extract each block
+	const searchPositions: number[] = []
+	while ((match = searchRegex.exec(patch)) !== null) {
+		searchPositions.push(match.index)
+	}
+
+	// Parse each block
+	for (let i = 0; i < searchPositions.length; i++) {
+		const start = searchPositions[i]
+		// The end is either the next SEARCH marker or the end of the patch
+		const end = i < searchPositions.length - 1 ? searchPositions[i + 1] : patch.length
+		const blockContent = patch.substring(start, end)
+
+		const parsed = parseSearchReplaceFormat(blockContent, path)
+		if (parsed) {
+			results.push(parsed)
+		}
+	}
+
+	return results
+}
+
+/**
+ * Parse a single SEARCH REPLACE diff format block (------- SEARCH / ======= / +++++++ REPLACE)
+ * Converts SEARCH block to deletions (-) and REPLACE block to additions (+)
+ */
+function parseSearchReplaceFormat(patch: string, path: string): Patch | undefined {
+	const searchIndex = patch.indexOf(MARKERS.SEARCH_BLOCK)
+	if (searchIndex === -1) {
+		return undefined
+	}
+
+	// Extract file metadata if present
+	const fileMatch = patch.match(MARKERS.FILE_PATTERN)
+
+	const result: Patch = {
+		action: fileMatch?.[1] ?? "Update",
+		path: fileMatch?.[2]?.trim() ?? path ?? "",
+		lines: [],
+		additions: 0,
+		deletions: 0,
+	}
+
+	// Extract content after SEARCH marker
+	const afterSearch = patch.substring(searchIndex + MARKERS.SEARCH_BLOCK.length).replace(/^\r?\n/, "")
+
+	const separatorIndex = afterSearch.indexOf(MARKERS.SEARCH_SEPARATOR)
+
+	if (separatorIndex === -1) {
+		// Still streaming - only SEARCH block available
+		const searchContent = afterSearch.trimEnd()
+		addLinesToPatch(result, searchContent, "-")
+		return result
+	}
+
+	// Extract SEARCH block (deletions)
+	const searchContent = afterSearch.substring(0, separatorIndex).replace(/\r?\n$/, "")
+	addLinesToPatch(result, searchContent, "-")
+
+	// Extract REPLACE block (additions)
+	const afterSeparator = afterSearch.substring(separatorIndex + MARKERS.SEARCH_SEPARATOR.length).replace(/^\r?\n/, "")
+	const replaceEndIndex = afterSeparator.indexOf(MARKERS.REPLACE_BLOCK)
+
+	const replaceContent =
+		replaceEndIndex !== -1 ? afterSeparator.substring(0, replaceEndIndex).replace(/\r?\n$/, "") : afterSeparator.trimEnd()
+
+	addLinesToPatch(result, replaceContent, "+")
+
+	return result
+}
+
+/**
+ * Helper to add lines to a patch with the specified prefix
+ */
+function addLinesToPatch(patch: Patch, content: string, prefix: "+" | "-"): void {
+	const lines = content.split("\n")
+	for (const line of lines) {
+		patch.lines.push(`${prefix} ${line}`)
+		if (prefix === "+") {
+			patch.additions++
+		} else {
+			patch.deletions++
+		}
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/EntitlementError.test.tsx b/apps/vscode/webview-ui/src/components/chat/EntitlementError.test.tsx
new file mode 100644
index 0000000..bcb3413
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/EntitlementError.test.tsx
@@ -0,0 +1,70 @@
+import { fireEvent, render, screen } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import EntitlementError from "./EntitlementError"
+
+const mockAuth: { clineUser: { appBaseUrl?: string } | null } = {
+	clineUser: null,
+}
+
+vi.mock("@/context/ClineAuthContext", () => ({
+	useClineAuth: () => mockAuth,
+}))
+
+const askResponseMock = vi.fn()
+vi.mock("@/services/grpc-client", () => ({
+	TaskServiceClient: {
+		askResponse: (...args: unknown[]) => askResponseMock(...args),
+	},
+}))
+
+const getSubscribeHref = () => screen.getByRole("link", { name: /get clinepass/i }).getAttribute("href")
+const querySubscribeLink = () => screen.queryByRole("link", { name: /get clinepass/i })
+
+describe("EntitlementError", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockAuth.clineUser = null
+	})
+
+	it("shows friendly copy with the backend detail as muted support text", () => {
+		render(<EntitlementError message="Error 403: the user is not subscribed to required model plan" />)
+		expect(screen.getByText("This model requires a ClinePass subscription.")).toBeInTheDocument()
+		expect(screen.getByText("Error 403: the user is not subscribed to required model plan")).toBeInTheDocument()
+	})
+
+	it("omits the subscribe link when no usable app base URL is available", () => {
+		render(<EntitlementError />)
+		expect(querySubscribeLink()).toBeNull()
+
+		mockAuth.clineUser = {}
+		render(<EntitlementError />)
+		expect(querySubscribeLink()).toBeNull()
+
+		mockAuth.clineUser = { appBaseUrl: "not a valid url" }
+		render(<EntitlementError />)
+		expect(querySubscribeLink()).toBeNull()
+	})
+
+	it("builds the subscribe link from the authenticated user's app base URL", () => {
+		mockAuth.clineUser = { appBaseUrl: "https://staging-app.cline.bot" }
+		const { unmount } = render(<EntitlementError />)
+		expect(getSubscribeHref()).toBe("https://staging-app.cline.bot/dashboard/subscription?personal=true")
+		unmount()
+
+		mockAuth.clineUser = {
+			appBaseUrl: "https://proxy.enterprise.com/cline/app",
+		}
+		render(<EntitlementError />)
+		expect(getSubscribeHref()).toBe("https://proxy.enterprise.com/cline/app/dashboard/subscription?personal=true")
+	})
+
+	it("sends a yesButtonClicked askResponse when Retry Request is clicked", () => {
+		render(<EntitlementError />)
+		// VSCodeButton has no ARIA role in jsdom; click by label text instead.
+		fireEvent.click(screen.getByText("Retry Request"))
+		expect(askResponseMock).toHaveBeenCalledTimes(1)
+		expect(askResponseMock.mock.calls[0][0]).toMatchObject({
+			responseType: "yesButtonClicked",
+		})
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/EntitlementError.tsx b/apps/vscode/webview-ui/src/components/chat/EntitlementError.tsx
new file mode 100644
index 0000000..ca89ebd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/EntitlementError.tsx
@@ -0,0 +1,79 @@
+import { AskResponseRequest } from "@shared/proto/cline/task"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import React from "react"
+import VSCodeButtonLink from "@/components/common/VSCodeButtonLink"
+import { useClineAuth } from "@/context/ClineAuthContext"
+import { TaskServiceClient } from "@/services/grpc-client"
+
+interface EntitlementErrorProps {
+	message?: string
+}
+
+// Relative (no leading slash) so it appends to path-prefixed app URLs (e.g. self-hosted/proxy) instead of resetting to origin.
+const CLINE_PASS_SUBSCRIBE_PATH = "dashboard/subscription"
+
+const HEADLINE = "This model requires a ClinePass subscription."
+
+function buildSubscribeUrl(appBaseUrl?: string): string | undefined {
+	if (!appBaseUrl) {
+		return undefined
+	}
+	try {
+		const base = appBaseUrl.endsWith("/") ? appBaseUrl : `${appBaseUrl}/`
+		const url = new URL(CLINE_PASS_SUBSCRIBE_PATH, base)
+		url.searchParams.set("personal", "true")
+		return url.toString()
+	} catch {
+		// Malformed appBaseUrl: omit the link rather than crashing the error card.
+		return undefined
+	}
+}
+
+const EntitlementError: React.FC<EntitlementErrorProps> = ({ message }) => {
+	const { clineUser } = useClineAuth()
+	const subscribeUrl = buildSubscribeUrl(clineUser?.appBaseUrl)
+	const backendDetail = message && message !== HEADLINE ? message : undefined
+
+	return (
+		<div className="p-2 border-none rounded-md mb-2 bg-(--vscode-textBlockQuote-background)">
+			<div className="mb-3">
+				<div className="text-error mb-2">{HEADLINE}</div>
+				<div className="text-(--vscode-descriptionForeground) text-xs">
+					Subscribe to ClinePass to use this model, then retry your request.
+				</div>
+				{backendDetail && (
+					<div className="text-(--vscode-descriptionForeground) text-xs mt-1 opacity-80 wrap-anywhere">
+						{backendDetail}
+					</div>
+				)}
+			</div>
+
+			{subscribeUrl && (
+				<VSCodeButtonLink className="w-full mb-2" href={subscribeUrl}>
+					<span className="codicon codicon-rocket mr-[6px] text-[14px]" />
+					Get ClinePass
+				</VSCodeButtonLink>
+			)}
+
+			<VSCodeButton
+				appearance="secondary"
+				className="w-full"
+				onClick={async () => {
+					try {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+							}),
+						)
+					} catch (error) {
+						console.error("Error invoking action:", error)
+					}
+				}}>
+				<span className="codicon codicon-refresh mr-1.5" />
+				Retry Request
+			</VSCodeButton>
+		</div>
+	)
+}
+
+export default EntitlementError
diff --git a/apps/vscode/webview-ui/src/components/chat/ErrorBlockTitle.tsx b/apps/vscode/webview-ui/src/components/chat/ErrorBlockTitle.tsx
new file mode 100644
index 0000000..077162d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ErrorBlockTitle.tsx
@@ -0,0 +1,80 @@
+import React from "react"
+import { ClineError, ClineErrorType } from "../../../../src/services/error/ClineError"
+import { ProgressIndicator } from "./ChatRow"
+
+interface ErrorBlockTitleProps {
+	cost?: number
+	apiReqCancelReason?: string
+	apiRequestFailedMessage?: string
+	retryStatus?: {
+		attempt: number
+		maxAttempts: number
+		delaySec?: number
+		errorSnippet?: string
+	}
+}
+
+export const ErrorBlockTitle = ({
+	cost,
+	apiReqCancelReason,
+	apiRequestFailedMessage,
+	retryStatus,
+}: ErrorBlockTitleProps): [React.ReactElement, React.ReactElement] => {
+	const getIconSpan = (iconName: string, colorClass: string) => (
+		<div className="w-4 h-4 flex items-center justify-center">
+			<span className={`codicon codicon-${iconName} text-base -mb-0.5 ${colorClass}`} />
+		</div>
+	)
+
+	const icon =
+		apiReqCancelReason != null ? (
+			apiReqCancelReason === "user_cancelled" ? (
+				getIconSpan("error", "text-(--vscode-descriptionForeground)")
+			) : (
+				getIconSpan("error", "text-(--vscode-errorForeground)")
+			)
+		) : cost != null ? (
+			getIconSpan("check", "text-(--vscode-charts-green)")
+		) : apiRequestFailedMessage ? (
+			getIconSpan("error", "text-(--vscode-errorForeground)")
+		) : (
+			<ProgressIndicator />
+		)
+
+	const title = (() => {
+		// Default loading state
+		const details = { title: "API Request...", classNames: ["font-bold"] }
+		// Handle cancellation states first
+		if (apiReqCancelReason === "user_cancelled") {
+			details.title = "API Request Cancelled"
+			details.classNames.push("text-(--vscode-foreground)")
+		} else if (apiReqCancelReason != null) {
+			details.title = "API Request Failed"
+			details.classNames.push("text-(--vscode-errorForeground)")
+		} else if (cost != null) {
+			// Handle completed request
+			details.title = "API Request"
+			details.classNames.push("text-(--vscode-foreground)")
+		} else if (apiRequestFailedMessage) {
+			// Handle failed request
+			const clineError = ClineError.parse(apiRequestFailedMessage)
+			const titleText = clineError?.isErrorType(ClineErrorType.Entitlement)
+				? "ClinePass Required"
+				: clineError?.isErrorType(ClineErrorType.Balance)
+					? "Credit Limit Reached"
+					: clineError?.isErrorType(ClineErrorType.SpendLimit)
+						? "Spend Limit Reached"
+						: "API Request Failed"
+			details.title = titleText
+			details.classNames.push("font-bold text-(--vscode-errorForeground)")
+		} else if (retryStatus) {
+			// Handle retry state
+			details.title = "API Request"
+			details.classNames.push("text-(--vscode-foreground)")
+		}
+
+		return <span className={details.classNames.join(" ")}>{details.title}</span>
+	})()
+
+	return [icon, title]
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/ErrorRow.stories.tsx b/apps/vscode/webview-ui/src/components/chat/ErrorRow.stories.tsx
new file mode 100644
index 0000000..b06eded
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ErrorRow.stories.tsx
@@ -0,0 +1,350 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import { useMemo } from "react"
+import { expect, userEvent, within } from "storybook/test"
+import { createStorybookDecorator } from "@/config/StorybookDecorator"
+import ErrorRow from "./ErrorRow"
+
+// Mock data factories
+const createMockMessage = (overrides: Partial<ClineMessage> = {}): ClineMessage => ({
+	ts: Date.now(),
+	type: "say",
+	say: "error",
+	text: "An error occurred while processing your request.",
+	...overrides,
+})
+
+const createMockAuthState = (overrides: any = {}) => ({
+	clineUser: null,
+	activeOrganization: null,
+	isAuthenticated: false,
+	...overrides,
+})
+
+const createMockExtensionState = (overrides: any = {}) => ({
+	version: "1.0.0",
+	clineMessages: [],
+	taskHistory: [],
+	shouldShowAnnouncement: false,
+	...overrides,
+})
+
+// Reusable decorators
+const createStoryDecorator =
+	(authOverrides: any = {}, extensionOverrides: any = {}) =>
+	(Story: any) => {
+		const mockExtensionState = useMemo(
+			() => ({
+				state: { ...createMockExtensionState(extensionOverrides) },
+				auth: { ...createMockAuthState(authOverrides) },
+			}),
+			[],
+		)
+
+		return createStorybookDecorator(mockExtensionState.state, "p-4", mockExtensionState.auth)(Story)
+	}
+
+const meta: Meta<typeof ErrorRow> = {
+	title: "Views/Components/ErrorRow",
+	component: ErrorRow,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays different types of error messages in the chat interface, including API errors, credit limit errors, diff errors, and clineignore errors. Handles special error parsing for Cline provider errors and provides appropriate user actions.",
+			},
+		},
+	},
+	decorators: [createStoryDecorator()],
+}
+
+export default meta
+type Story = StoryObj<typeof ErrorRow>
+
+// Interactive plain text error story with configurable args and presets
+export const Default: Story = {
+	args: {
+		message: createMockMessage({ text: "Something went wrong while executing the command." }),
+		errorType: "error",
+		apiRequestFailedMessage: undefined,
+	},
+	argTypes: {
+		errorType: {
+			control: { type: "select" },
+			options: ["error", "mistake_limit_reached", "diff_error", "clineignore_error"],
+			description: "Type of error to display",
+		},
+		message: {
+			control: { type: "object" },
+			description: "Message object containing error text and metadata",
+		},
+		apiRequestFailedMessage: {
+			control: { type: "select" },
+			options: [
+				// Empty option for no error message
+				"",
+				// PowerShell error
+				"PowerShell is not recognized as an internal or external command, operable program or batch file.",
+				JSON.stringify({
+					request_id: "has-request-id",
+					message: "error message.",
+					code: "random_code",
+				}),
+			],
+		},
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Interactive story for testing different plain text error types and messages. Use the preset dropdown to quickly test common scenarios, or manually configure the error type and message object.",
+			},
+		},
+	},
+}
+
+// API request errors
+export const ApiRequestFailed: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage:
+			"Network error: Unable to connect to the API server. Please check your internet connection and try again.",
+	},
+}
+
+export const ApiStreamingFailed: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiReqStreamingFailedMessage: "Streaming error: Connection was interrupted while receiving the response.",
+	},
+}
+
+// Cline-specific errors
+export const ClineBalanceError: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "Insufficient credits to complete this request.",
+			code: "insufficient_credits",
+			request_id: "req_123456789",
+			providerId: "cline",
+			details: {
+				current_balance: 0.5,
+				total_spent: 25.75,
+				total_promotions: 5.0,
+				message: "You have run out of credits. Please purchase more to continue.",
+				buy_credits_url: "https://app.example.bot/dashboard/account?tab=credits&redirect=true",
+			},
+		}),
+	},
+}
+
+export const ClineRateLimitError: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "Rate limit exceeded. Please wait before making another request.",
+			request_id: "req_987654321",
+			providerId: "cline",
+		}),
+	},
+}
+
+export const ClineSpendLimitDaily: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "$20.00 daily limit has been reached.",
+			status: 429,
+			code: "SPEND_LIMIT_EXCEEDED",
+			providerId: "cline",
+			details: {
+				code: "SPEND_LIMIT_EXCEEDED",
+				limit_scope: "user",
+				budget_period: "daily",
+				limit_usd: 20.0,
+				spent_usd: 20.5,
+				resets_at: new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString(),
+				message: "$20.00 daily limit has been reached.",
+			},
+		}),
+	},
+}
+
+export const ClineSpendLimitMonthly: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "$100.00 monthly limit has been reached.",
+			status: 429,
+			code: "SPEND_LIMIT_EXCEEDED",
+			providerId: "cline",
+			details: {
+				code: "SPEND_LIMIT_EXCEEDED",
+				limit_scope: "user",
+				budget_period: "monthly",
+				limit_usd: 100.0,
+				spent_usd: 103.22,
+				resets_at: null,
+				message: "$100.00 monthly limit has been reached.",
+			},
+		}),
+	},
+}
+
+export const ClineSpendLimitMinimal: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "Spend limit reached.",
+			status: 429,
+			code: "SPEND_LIMIT_EXCEEDED",
+			providerId: "cline",
+			details: {
+				code: "SPEND_LIMIT_EXCEEDED",
+				message: "Spend limit reached.",
+			},
+		}),
+	},
+}
+
+// ClinePass entitlement error (user not subscribed to a required model plan)
+export const ClinePassEntitlementError: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage:
+			"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://app.cline.bot/promo?code=CLI-8OFF&personal=true",
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "ClinePass model returns the SDK ClineNotSubscribedError message when the user is not subscribed. A human-readable message with a 'Get ClinePass' subscribe link and a retry button is shown.",
+			},
+		},
+	},
+}
+
+// Authentication-related errors with configurable scenarios
+export const AuthenticationErrors: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "Authentication failed. Please sign in to continue.",
+			code: "ERR_BAD_REQUEST",
+			request_id: "req_auth_123",
+			providerId: "cline",
+		}),
+	},
+	argTypes: {
+		apiRequestFailedMessage: {
+			control: { type: "text" },
+			description: "JSON string containing error details",
+		},
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Interactive story for testing authentication-related errors. Configure the error message JSON to test different auth scenarios including signed in/out states.",
+			},
+		},
+	},
+}
+
+// Auth error when signed in (shows different UI)
+export const AuthErrorSignedIn: Story = {
+	...AuthenticationErrors,
+	decorators: [
+		createStoryDecorator({
+			clineUser: { id: "user123", email: "user@example.com" },
+			isAuthenticated: true,
+		}),
+	],
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "Authentication failed. Please retry your request.",
+			request_id: "req_auth_456",
+			providerId: "anthropic",
+		}),
+	},
+}
+
+// Interactive tests
+export const InteractiveSignIn: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "Please sign in to access Cline services.",
+			code: "ERR_BAD_REQUEST",
+			request_id: "req_signin_test",
+			providerId: "cline",
+		}),
+	},
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement)
+
+		// Find the sign in button
+		const signInButton = canvas.getByRole("button", { name: /sign in to cline/i })
+		await expect(signInButton).toBeInTheDocument()
+
+		// Test button is clickable
+		await expect(signInButton).toBeEnabled()
+
+		// Click the button (this will trigger the mock handler)
+		await userEvent.click(signInButton)
+	},
+}
+
+export const TroubleshootingLink: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage:
+			"PowerShell is not recognized as an internal or external command. Please check your system configuration.",
+	},
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement)
+
+		// Find the troubleshooting link
+		const troubleshootingLink = canvas.getByRole("link", { name: /troubleshooting guide/i })
+		await expect(troubleshootingLink).toBeInTheDocument()
+
+		// Verify link attributes
+		await expect(troubleshootingLink).toHaveAttribute("href")
+		await expect(troubleshootingLink).toHaveClass("underline")
+	},
+}
+
+// Keep this one as it has specific testing logic for request ID
+export const ErrorWithRequestId: Story = {
+	args: {
+		message: createMockMessage(),
+		errorType: "error",
+		apiRequestFailedMessage: JSON.stringify({
+			message: "An unexpected error occurred while processing your request.",
+			request_id: "req_detailed_123456",
+			providerId: "cline",
+		}),
+	},
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement)
+
+		// Verify error message is displayed
+		const errorMessage = canvas.getByText(/an unexpected error occurred/i)
+		await expect(errorMessage).toBeInTheDocument()
+
+		// Verify request ID is displayed
+		const requestId = canvas.getByText(/request id: req_detailed_123456/i)
+		await expect(requestId).toBeInTheDocument()
+	},
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/ErrorRow.test.tsx b/apps/vscode/webview-ui/src/components/chat/ErrorRow.test.tsx
new file mode 100644
index 0000000..c5a32b9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ErrorRow.test.tsx
@@ -0,0 +1,385 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import ErrorRow from "./ErrorRow"
+
+const mockSetUserOrganization = vi.hoisted(() => vi.fn())
+const mockUpdateApiConfigurationProto = vi.hoisted(() => vi.fn())
+const mockApiConfiguration = vi.hoisted(() => ({
+	planModeApiProvider: "cline-pass",
+	actModeApiProvider: "cline-pass",
+	planModeClinePassModelId: "cline-pass/test-plan-model",
+	actModeClinePassModelId: "cline-pass/test-act-model",
+}))
+
+// Mock the auth context
+vi.mock("@/context/ClineAuthContext", () => ({
+	useClineAuth: () => ({
+		clineUser: null,
+	}),
+	useClineSignIn: () => ({
+		isLoginLoading: false,
+	}),
+	handleSignOut: vi.fn(),
+}))
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: () => ({
+		apiConfiguration: mockApiConfiguration,
+	}),
+}))
+
+// Mock CreditLimitError component
+vi.mock("@/components/chat/CreditLimitError", () => ({
+	default: ({ message }: { message: string }) => <div data-testid="credit-limit-error">{message}</div>,
+}))
+
+// Mock EntitlementError component
+vi.mock("@/components/chat/EntitlementError", () => ({
+	default: ({ message }: { message: string }) => <div data-testid="entitlement-error">{message}</div>,
+}))
+
+vi.mock("@/services/grpc-client", () => ({
+	AccountServiceClient: {
+		setUserOrganization: mockSetUserOrganization,
+	},
+	ModelsServiceClient: {
+		updateApiConfigurationProto: mockUpdateApiConfigurationProto,
+	},
+}))
+
+// Mock ClineError
+vi.mock("../../../../src/services/error/ClineError", () => ({
+	ClineError: {
+		parse: vi.fn(),
+	},
+	ClineErrorType: {
+		Balance: "balance",
+		RateLimit: "rateLimit",
+		Auth: "auth",
+		Entitlement: "entitlement",
+		OrgClinePassRestriction: "orgClinePassRestriction",
+		ClinePassLimit: "clinePassLimit",
+		QuotaExceeded: "quotaExceeded",
+	},
+}))
+
+describe("ErrorRow", () => {
+	const mockMessage: ClineMessage = {
+		ts: 123456789,
+		type: "say",
+		say: "error",
+		text: "Test error message",
+	}
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockSetUserOrganization.mockResolvedValue({})
+		mockUpdateApiConfigurationProto.mockResolvedValue({})
+	})
+
+	it("renders basic error message", () => {
+		render(<ErrorRow errorType="error" message={mockMessage} />)
+
+		expect(screen.getByText("Test error message")).toBeInTheDocument()
+	})
+
+	it("renders mistake limit reached error", () => {
+		const mistakeMessage = { ...mockMessage, text: "Mistake limit reached" }
+		render(<ErrorRow errorType="mistake_limit_reached" message={mistakeMessage} />)
+
+		expect(screen.getByText("Mistake limit reached")).toBeInTheDocument()
+	})
+
+	it("renders diff error", () => {
+		render(<ErrorRow errorType="diff_error" message={mockMessage} />)
+
+		expect(
+			screen.getByText("The model used search patterns that don't match anything in the file. Retrying..."),
+		).toBeInTheDocument()
+	})
+
+	it("renders clineignore error", () => {
+		const clineignoreMessage = { ...mockMessage, text: "/path/to/file.txt" }
+		render(<ErrorRow errorType="clineignore_error" message={clineignoreMessage} />)
+
+		expect(screen.getByText(/Cline tried to access/)).toBeInTheDocument()
+		expect(screen.getByText("/path/to/file.txt")).toBeInTheDocument()
+	})
+
+	describe("API error handling", () => {
+		it("renders credit limit error when balance error is detected", async () => {
+			const mockClineError = {
+				message: "Insufficient credits",
+				isErrorType: vi.fn((type) => type === "balance"),
+				_error: {
+					details: {
+						current_balance: 0,
+						total_spent: 10.5,
+						total_promotions: 5.0,
+						message: "You have run out of credits.",
+						buy_credits_url: "https://app.cline.bot/dashboard",
+					},
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage="Insufficient credits error" errorType="error" message={mockMessage} />)
+
+			expect(screen.getByTestId("credit-limit-error")).toBeInTheDocument()
+			expect(screen.getByText("You have run out of credits.")).toBeInTheDocument()
+		})
+
+		it("does not show Cline credits CTA for non-Cline balance errors without a provider URL", async () => {
+			const mockClineError = {
+				message: "Not enough credits available",
+				providerId: "zai",
+				isErrorType: vi.fn((type) => type === "balance"),
+				_error: {
+					code: "insufficient_credits",
+					providerId: "zai",
+					details: {
+						current_balance: 0,
+						message: "Not enough credits available",
+					},
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage="Insufficient credits error" errorType="error" message={mockMessage} />)
+
+			expect(screen.queryByTestId("credit-limit-error")).not.toBeInTheDocument()
+			expect(screen.getByText(/\[zai\]/)).toBeInTheDocument()
+		})
+
+		it("renders rate limit error with request ID", async () => {
+			const mockClineError = {
+				message: "Rate limit exceeded",
+				isErrorType: vi.fn((type) => type === "rateLimit"),
+				_error: {
+					request_id: "req_123456",
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage="Rate limit exceeded" errorType="error" message={mockMessage} />)
+
+			expect(screen.getByText("Rate limit exceeded")).toBeInTheDocument()
+			expect(screen.getByText("Request ID: req_123456")).toBeInTheDocument()
+		})
+
+		it("renders quota exceeded error", async () => {
+			const mockClineError = {
+				message: "Inference cap reached",
+				isErrorType: vi.fn((type) => type === "quotaexceeded"),
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage="The message" errorType="error" message="" />)
+			expect(screen.getByText("Inference cap reached")).toBeInTheDocument()
+		})
+
+		it("renders entitlement error when ClineError detects ClineNotSubscribedError", async () => {
+			const cliMessage =
+				"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://app.cline.bot/promo?code=CLI-8OFF&personal=true"
+			const mockClineError = {
+				message: cliMessage,
+				isErrorType: vi.fn((type) => type === "entitlement"),
+				providerId: "cline-pass",
+				_error: {
+					message: cliMessage,
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage={cliMessage} errorType="error" message={mockMessage} />)
+
+			expect(screen.getByTestId("entitlement-error")).toBeInTheDocument()
+			expect(screen.getByText(cliMessage)).toBeInTheDocument()
+			expect(screen.queryByText(/\[cline-pass\]/i)).not.toBeInTheDocument()
+		})
+
+		it("renders entitlement error when ClineError detects a raw required-plan message", async () => {
+			const rawMessage = "403 Error 403: the user is not subscribed to required model plan"
+			const mockClineError = {
+				message: rawMessage,
+				isErrorType: vi.fn((type) => type === "entitlement"),
+				providerId: "cline-pass",
+				_error: {
+					message: rawMessage,
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage={rawMessage} errorType="error" message={mockMessage} />)
+
+			expect(screen.getByTestId("entitlement-error")).toBeInTheDocument()
+			expect(screen.getByText(rawMessage)).toBeInTheDocument()
+		})
+
+		it("renders organization account ClinePass restriction with friendly account switching copy", async () => {
+			const rawMessage = "403 Error 403: organization accounts cannot use individual model inference subscriptions"
+			const mockClineError = {
+				message: rawMessage,
+				isErrorType: vi.fn((type) => type === "orgClinePassRestriction"),
+				providerId: "cline",
+				_error: {
+					message: rawMessage,
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage={rawMessage} errorType="error" message={mockMessage} />)
+
+			expect(screen.getByTestId("org-cline-pass-restriction-error")).toBeInTheDocument()
+			expect(screen.getByText(/Organization accounts cannot use ClinePass subscriptions/)).toBeInTheDocument()
+			expect(screen.queryByText(rawMessage)).not.toBeInTheDocument()
+
+			fireEvent.click(screen.getByText("Switch to personal account"))
+
+			await waitFor(() => expect(mockSetUserOrganization).toHaveBeenCalledWith({}))
+			expect(screen.getByText("Switched to personal account")).toBeInTheDocument()
+		})
+
+		it("renders organization ClinePass restriction when ClineError detects the SDK formatted message", async () => {
+			const formattedMessage =
+				"Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass"
+			const mockClineError = {
+				message: formattedMessage,
+				isErrorType: vi.fn((type) => type === "orgClinePassRestriction"),
+				providerId: "cline-pass",
+				_error: {
+					message: formattedMessage,
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage={formattedMessage} errorType="error" message={mockMessage} />)
+
+			expect(screen.getByTestId("org-cline-pass-restriction-error")).toBeInTheDocument()
+			expect(screen.queryByText(formattedMessage)).not.toBeInTheDocument()
+		})
+
+		it("renders ClinePass limit error and switches to Cline usage-based billing", async () => {
+			const limitMessage = "You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later."
+			const mockClineError = {
+				message: limitMessage,
+				isErrorType: vi.fn((type) => type === "clinePassLimit"),
+				providerId: "cline-pass",
+				_error: {
+					message: limitMessage,
+				},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage={limitMessage} errorType="error" message={mockMessage} />)
+
+			expect(screen.getByTestId("cline-pass-limit-error")).toBeInTheDocument()
+			expect(screen.getByText(limitMessage)).toBeInTheDocument()
+
+			fireEvent.click(screen.getByText("Switch to Usage-Based billing"))
+
+			await waitFor(() => expect(mockUpdateApiConfigurationProto).toHaveBeenCalledTimes(1))
+			const request = mockUpdateApiConfigurationProto.mock.calls[0][0]
+			expect(request.apiConfiguration.planModeApiProvider).toBe("cline")
+			expect(request.apiConfiguration.actModeApiProvider).toBe("cline")
+			expect(request.apiConfiguration.planModeClineModelId).toBeUndefined()
+			expect(request.apiConfiguration.actModeClineModelId).toBeUndefined()
+			expect(screen.getByText("Switched to Usage-Based billing")).toBeInTheDocument()
+		})
+
+		it("renders friendly logged-out message and sign in button when user is not signed in", async () => {
+			const mockClineError = {
+				message: "Authentication failed",
+				isErrorType: vi.fn((type) => type === "auth"),
+				providerId: "cline",
+				_error: {},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiRequestFailedMessage="Authentication failed" errorType="error" message={mockMessage} />)
+
+			expect(screen.queryByText("Authentication failed")).not.toBeInTheDocument()
+			expect(screen.getByText(/Whoops looks like you're logged out/)).toBeInTheDocument()
+			expect(screen.getByText("Sign in to Cline")).toBeInTheDocument()
+		})
+
+		it("renders PowerShell troubleshooting link when error mentions PowerShell", async () => {
+			const mockClineError = {
+				message: "PowerShell is not recognized as an internal or external command",
+				isErrorType: vi.fn(() => false),
+				_error: {},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(
+				<ErrorRow
+					apiRequestFailedMessage="PowerShell is not recognized as an internal or external command"
+					errorType="error"
+					message={mockMessage}
+				/>,
+			)
+
+			expect(screen.getByText(/PowerShell is not recognized/)).toBeInTheDocument()
+			expect(screen.getByText("troubleshooting guide")).toBeInTheDocument()
+			expect(screen.getByRole("link", { name: "troubleshooting guide" })).toHaveAttribute(
+				"href",
+				"https://github.com/cline/cline/wiki/TroubleShooting-%E2%80%90-%22PowerShell-is-not-recognized-as-an-internal-or-external-command%22",
+			)
+		})
+
+		it("handles apiReqStreamingFailedMessage instead of apiRequestFailedMessage", async () => {
+			const mockClineError = {
+				message: "Streaming failed",
+				isErrorType: vi.fn(() => false),
+				_error: {},
+			}
+
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(mockClineError as any)
+
+			render(<ErrorRow apiReqStreamingFailedMessage="Streaming failed" errorType="error" message={mockMessage} />)
+
+			expect(screen.getByText("Streaming failed")).toBeInTheDocument()
+		})
+
+		it("falls back to regular error message when ClineError.parse returns null", async () => {
+			const { ClineError } = await import("../../../../src/services/error/ClineError")
+			vi.mocked(ClineError.parse).mockReturnValue(undefined)
+
+			render(<ErrorRow apiRequestFailedMessage="Some API error" errorType="error" message={mockMessage} />)
+
+			// When ClineError.parse returns null, we display the raw error message for non-Cline providers
+			// Since clineError is undefined, isClineUsageBillingProvider is false, so we show the raw apiRequestFailedMessage
+			expect(screen.getByText("Some API error")).toBeInTheDocument()
+		})
+
+		it("renders regular error message when no API error messages are provided", () => {
+			render(<ErrorRow errorType="error" message={mockMessage} />)
+
+			expect(screen.getByText("Test error message")).toBeInTheDocument()
+		})
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/ErrorRow.tsx b/apps/vscode/webview-ui/src/components/chat/ErrorRow.tsx
new file mode 100644
index 0000000..e3e0936
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ErrorRow.tsx
@@ -0,0 +1,190 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { memo } from "react"
+import { ClineAuthStatus } from "@/components/account/ClineAuthStatus"
+import ClinePassLimitError from "@/components/chat/ClinePassLimitError"
+import CreditLimitError from "@/components/chat/CreditLimitError"
+import EntitlementError from "@/components/chat/EntitlementError"
+import OrgClinePassRestrictionError from "@/components/chat/OrgClinePassRestrictionError"
+import SpendLimitError from "@/components/chat/SpendLimitError"
+import { Button } from "@/components/ui/button"
+import { useClineAuth, useClineSignIn } from "@/context/ClineAuthContext"
+import { ClineError, ClineErrorType } from "../../../../src/services/error/ClineError"
+
+const _errorColor = "var(--vscode-errorForeground)"
+
+interface ErrorRowProps {
+	message: ClineMessage
+	errorType: "error" | "mistake_limit_reached" | "diff_error" | "clineignore_error"
+	apiRequestFailedMessage?: string
+	apiReqStreamingFailedMessage?: string
+}
+
+const ErrorRow = memo(({ message, errorType, apiRequestFailedMessage, apiReqStreamingFailedMessage }: ErrorRowProps) => {
+	const { clineUser } = useClineAuth()
+	const rawApiError = apiRequestFailedMessage || apiReqStreamingFailedMessage
+
+	const { isLoginLoading, authStatusMessage, handleSignIn } = useClineSignIn()
+
+	const renderErrorContent = () => {
+		switch (errorType) {
+			case "error":
+			case "mistake_limit_reached":
+				// Handle API request errors with special error parsing
+				if (rawApiError) {
+					// FIXME: ClineError parsing should not be applied to non-Cline providers, but it seems we're using clineErrorMessage below in the default error display
+					const clineError = ClineError.parse(rawApiError)
+					const errorMessage = clineError?._error?.message || clineError?.message || rawApiError
+					const requestId = clineError?._error?.request_id
+					const providerId = clineError?.providerId || clineError?._error?.providerId
+					// Deliberately narrower than the shared isClineManagedProvider (which
+					// also matches cline-pass): only usage-billing errors get the credit
+					// and login prompts below.
+					const isClineUsageBillingProvider = providerId === "cline"
+					const errorCode = clineError?._error?.code
+
+					if (clineError?.isErrorType(ClineErrorType.Balance)) {
+						const errorDetails = clineError._error?.details
+						if (isClineUsageBillingProvider || errorDetails?.buy_credits_url) {
+							return (
+								<CreditLimitError
+									buyCreditsUrl={errorDetails?.buy_credits_url}
+									currentBalance={errorDetails?.current_balance}
+									message={errorDetails?.message}
+									totalPromotions={errorDetails?.total_promotions}
+									totalSpent={errorDetails?.total_spent}
+								/>
+							)
+						}
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.SpendLimit)) {
+						const d = clineError._error?.details
+						return (
+							<SpendLimitError
+								budgetPeriod={d?.budget_period}
+								limitUsd={d?.limit_usd}
+								message={d?.message || errorMessage}
+								resetsAt={d?.resets_at}
+								spentUsd={d?.spent_usd}
+							/>
+						)
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.Entitlement)) {
+						const detailMessage = clineError?._error?.details?.message || errorMessage
+						return <EntitlementError message={detailMessage} />
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.OrgClinePassRestriction)) {
+						return <OrgClinePassRestrictionError />
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.ClinePassLimit)) {
+						const detailMessage = clineError?._error?.details?.message || errorMessage
+						return <ClinePassLimitError message={detailMessage} />
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.RateLimit)) {
+						return (
+							<p className="m-0 whitespace-pre-wrap text-error wrap-anywhere">
+								{errorMessage}
+								{requestId && <div>Request ID: {requestId}</div>}
+							</p>
+						)
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.QuotaExceeded)) {
+						const detailMessage = clineError?._error?.details?.message || errorMessage
+						return <p className="m-0 whitespace-pre-wrap text-error wrap-anywhere">{detailMessage}</p>
+					}
+
+					if (clineError?.isErrorType(ClineErrorType.Auth) && isClineUsageBillingProvider) {
+						return !clineUser ? (
+							// User is using Cline provider and is not logged in
+							<div className="flex flex-col gap-3">
+								<div className="flex items-center justify-center rounded border border-neutral-500/30 bg-vscode-editor-background p-6 text-center text-vscode-foreground">
+									Whoops looks like you're logged out – click below to sign in
+								</div>
+								<Button className="w-full" disabled={isLoginLoading} onClick={handleSignIn}>
+									Sign in to Cline
+									{isLoginLoading && (
+										<span className="ml-1 animate-spin">
+											<span className="codicon codicon-refresh" />
+										</span>
+									)}
+								</Button>
+								<ClineAuthStatus message={authStatusMessage} />
+							</div>
+						) : (
+							// Don't show sign in button after the user has logged in, just ask them to retry
+							<div className="mt-4">
+								<span className="text-description">(Click "Retry" below)</span>
+							</div>
+						)
+					}
+
+					return (
+						<p className="m-0 whitespace-pre-wrap text-error wrap-anywhere flex flex-col gap-3">
+							{/* Display the well-formatted error extracted from the ClineError instance */}
+
+							<header>
+								{providerId && <span className="uppercase">[{providerId}] </span>}
+								{errorCode && <span>{errorCode}</span>}
+								{errorMessage}
+								{requestId && <div>Request ID: {requestId}</div>}
+							</header>
+
+							{/* Windows Powershell Issue */}
+							{errorMessage?.toLowerCase()?.includes("powershell") && (
+								<div>
+									It seems like you're having Windows PowerShell issues, please see this{" "}
+									<a
+										className="underline text-inherit"
+										href="https://github.com/cline/cline/wiki/TroubleShooting-%E2%80%90-%22PowerShell-is-not-recognized-as-an-internal-or-external-command%22">
+										troubleshooting guide
+									</a>
+									.
+								</div>
+							)}
+
+							{/* Display raw API error if different from parsed error message */}
+							{errorMessage !== rawApiError && <div>{rawApiError}</div>}
+						</p>
+					)
+				}
+
+				// Regular error message
+				return <p className="m-0 mt-0 whitespace-pre-wrap text-error wrap-anywhere">{message.text}</p>
+
+			case "diff_error":
+				return (
+					<div className="flex flex-col p-2 rounded text-xs opacity-80 bg-quote text-foreground">
+						<div>The model used search patterns that don't match anything in the file. Retrying...</div>
+					</div>
+				)
+
+			case "clineignore_error":
+				return (
+					<div className="flex flex-col p-2 rounded text-xs opacity-80 bg-quote text-foreground">
+						<div>
+							Cline tried to access <code>{message.text}</code> which is blocked by the <code>.clineignore</code>
+							file.
+						</div>
+					</div>
+				)
+
+			default:
+				return null
+		}
+	}
+
+	// For diff_error and clineignore_error, we don't show the header separately
+	if (errorType === "diff_error" || errorType === "clineignore_error") {
+		return renderErrorContent()
+	}
+
+	// For other error types, show header + content
+	return renderErrorContent()
+})
+
+export default ErrorRow
diff --git a/apps/vscode/webview-ui/src/components/chat/ExpandHandle.tsx b/apps/vscode/webview-ui/src/components/chat/ExpandHandle.tsx
new file mode 100644
index 0000000..19b9010
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ExpandHandle.tsx
@@ -0,0 +1,28 @@
+import { TriangleIcon } from "lucide-react"
+import { memo } from "react"
+import { cn } from "@/lib/utils"
+
+interface ExpandHandleProps {
+	isExpanded: boolean
+	onToggle: () => void
+	className?: string
+}
+
+/**
+ * Reusable expand/collapse handle component
+ * Used by CompletionOutput, PlanCompletionOutput, CommandOutput, etc.
+ */
+const ExpandHandle = memo(({ isExpanded, onToggle, className = "bg-accent" }: ExpandHandleProps) => {
+	return (
+		<div
+			className={cn(
+				"absolute -bottom-2 left-1/2 z-10 transform -translate-x-1/2 flex justify-center items-center px-5 py-0.5 cursor-pointer bg-description transition-opacity border border-none rounded-b-sm shrink-0 pointer-events-auto",
+				className,
+			)}
+			onClick={onToggle}>
+			<TriangleIcon className={cn("text-black fill-black", isExpanded ? "rotate-0" : "rotate-180")} size={8} />
+		</div>
+	)
+})
+
+export default ExpandHandle
diff --git a/apps/vscode/webview-ui/src/components/chat/FeatureTip.tsx b/apps/vscode/webview-ui/src/components/chat/FeatureTip.tsx
new file mode 100644
index 0000000..93bbbe6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/FeatureTip.tsx
@@ -0,0 +1,114 @@
+import { LightbulbIcon } from "lucide-react"
+import { memo, useCallback, useEffect, useRef, useState } from "react"
+import { cn } from "@/lib/utils"
+
+interface FeatureTipItem {
+	text: string
+}
+
+const FEATURE_TIPS: FeatureTipItem[] = [
+	{
+		text: 'Enable "Double-Check Completion" in settings to have Cline verify its work before finishing a task.',
+	},
+	{
+		text: "Add a .clinerules file to your project root to give Cline project-specific instructions.",
+	},
+	{
+		text: "Switch to Plan Mode to discuss and plan an approach before Cline takes action.",
+	},
+	{
+		text: "Use @ in the chat input to add files, folders, or URLs as context for your task.",
+	},
+	{
+		text: "Set up MCP Servers to give Cline access to external tools and APIs.",
+	},
+	{
+		text: "Cline creates checkpoints after changes — you can always restore to a previous state.",
+	},
+	{
+		text: "Use /compact to condense long conversations and free up context window space.",
+	},
+	{
+		text: "Enable auto-approve for read-only tools like file reads to speed up exploration.",
+	},
+	{
+		text: "Use the quote button to select text from Cline's response and reference it in your reply.",
+	},
+	{
+		text: "You can drag and drop images into the chat to share screenshots with Cline.",
+	},
+	{
+		text: "Use /reportbug to quickly file a GitHub issue with diagnostic context included.",
+	},
+	{
+		text: 'You can disable these tips in Settings → Features → "Feature Tips".',
+	},
+]
+
+const SHOW_DELAY_MS = 2000
+const CYCLE_INTERVAL_MS = 8000
+const FADE_DURATION_MS = 300
+
+/**
+ * Shows rotating feature tips below the "Thinking..." indicator.
+ * Appears after a brief delay and cycles through tips while Cline is thinking.
+ */
+export const FeatureTip = memo(() => {
+	const [isVisible, setIsVisible] = useState(false)
+	const [hasFadedIn, setHasFadedIn] = useState(false)
+	const [isFading, setIsFading] = useState(false)
+	const [tipIndex, setTipIndex] = useState(() => Math.floor(Math.random() * FEATURE_TIPS.length))
+	const cycleTimerRef = useRef<ReturnType<typeof setInterval> | null>(null)
+	const showTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+	const fadeTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+	const currentTip = FEATURE_TIPS[tipIndex]
+
+	const advanceTip = useCallback(() => {
+		setIsFading(true)
+		fadeTimerRef.current = setTimeout(() => {
+			setTipIndex((prev) => (prev + 1) % FEATURE_TIPS.length)
+			setIsFading(false)
+		}, FADE_DURATION_MS)
+	}, [])
+
+	useEffect(() => {
+		showTimerRef.current = setTimeout(() => {
+			setIsVisible(true)
+			// Trigger fade-in on next frame so transition applies
+			requestAnimationFrame(() => setHasFadedIn(true))
+			cycleTimerRef.current = setInterval(advanceTip, CYCLE_INTERVAL_MS)
+		}, SHOW_DELAY_MS)
+
+		return () => {
+			if (showTimerRef.current) {
+				clearTimeout(showTimerRef.current)
+			}
+			if (cycleTimerRef.current) {
+				clearInterval(cycleTimerRef.current)
+			}
+			if (fadeTimerRef.current) {
+				clearTimeout(fadeTimerRef.current)
+			}
+		}
+	}, [advanceTip])
+
+	if (!isVisible) {
+		return null
+	}
+
+	return (
+		<div
+			className={cn(
+				"flex items-start gap-1.5 mt-2 ml-1 transition-opacity duration-300",
+				!hasFadedIn || isFading ? "opacity-0" : "opacity-100",
+			)}>
+			<LightbulbIcon className="size-3 text-description shrink-0 mt-[1px]" />
+			<span className="text-xs text-description leading-relaxed">
+				<span className="font-medium">Tip:</span> {currentTip.text}
+			</span>
+		</div>
+	)
+})
+
+FeatureTip.displayName = "FeatureTip"
diff --git a/apps/vscode/webview-ui/src/components/chat/HookMessage.tsx b/apps/vscode/webview-ui/src/components/chat/HookMessage.tsx
new file mode 100644
index 0000000..dcbc791
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/HookMessage.tsx
@@ -0,0 +1,291 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { memo, useMemo, useState } from "react"
+import { TaskServiceClient } from "@/services/grpc-client"
+import { CHAT_ROW_EXPANDED_BG_COLOR } from "../common/CodeBlock"
+import { HOOK_OUTPUT_STRING } from "./constants"
+
+const normalColor = "var(--vscode-foreground)"
+const errorColor = "var(--vscode-errorForeground)"
+const successColor = "var(--vscode-charts-green)"
+const completedColor = "var(--vscode-descriptionForeground)"
+
+/**
+ * Determines if a hook message should be expanded by default.
+ *
+ * Expansion logic:
+ * - Historical messages (>5 seconds old): Always collapsed for better UX
+ * - Fresh failed/cancelled hooks: Expanded to show error details
+ * - Fresh successful hooks: Collapsed to minimize clutter
+ * - Running hooks: Not applicable (handled separately)
+ *
+ * @param message The message containing timestamp information
+ * @param metadata The hook metadata containing status
+ * @returns true if the hook output should be expanded by default
+ */
+function shouldExpandHookByDefault(message: ClineMessage, metadata: HookMetadata): boolean {
+	// Always collapse historical messages (>5 seconds old) for better UX
+	const isHistorical = message.ts && Date.now() - message.ts > 5000
+	if (isHistorical) {
+		return false
+	}
+
+	// Expand fresh failed/cancelled hooks to show error details
+	return metadata.status === "failed" || metadata.status === "cancelled"
+}
+
+interface HookMessageProps {
+	message: ClineMessage
+	// CommandOutput component - we'll import and use it here
+	CommandOutput: React.ComponentType<{
+		output: string
+		isOutputFullyExpanded: boolean
+		onToggle: () => void
+		isContainerExpanded: boolean
+	}>
+}
+
+interface HookMetadata {
+	hookName: string
+	toolName?: string
+	status: string
+	exitCode?: number
+	hasJsonResponse?: boolean
+	pendingToolInfo?: {
+		tool: string
+		path?: string
+		command?: string
+		content?: string
+		diff?: string
+		regex?: string
+		url?: string
+		mcpTool?: string
+		mcpServer?: string
+		resourceUri?: string
+	}
+	error?: {
+		type: "timeout" | "validation" | "execution" | "cancellation"
+		message: string
+		details?: string
+		scriptPath?: string
+	}
+}
+
+/**
+ * Displays a hook execution message with status, pending tool info, and output.
+ *
+ * Smart expansion defaults:
+ * - Failed hooks: Expanded by default (show error details)
+ * - Aborted hooks: Expanded by default (show what happened)
+ * - Successful hooks: Collapsed by default (minimize clutter)
+ * - Running hooks: Always shows pending tool info
+ */
+const HookMessage = memo(({ message, CommandOutput }: HookMessageProps) => {
+	// Parse hook metadata and output
+	const { metadata, output } = useMemo(() => {
+		const splitMessage = (text: string) => {
+			const outputIndex = text.indexOf(HOOK_OUTPUT_STRING)
+			if (outputIndex === -1) {
+				return { metadata: text, output: "" }
+			}
+			return {
+				metadata: text.slice(0, outputIndex).trim(),
+				output: text
+					.slice(outputIndex + HOOK_OUTPUT_STRING.length)
+					.trim()
+					.split("")
+					.map((char) => {
+						switch (char) {
+							case "\t":
+								return "→   "
+							case "\b":
+								return "⌫"
+							case "\f":
+								return "⏏"
+							case "\v":
+								return "⇳"
+							default:
+								return char
+						}
+					})
+					.join(""),
+			}
+		}
+
+		const { metadata: metadataStr, output } = splitMessage(message.text || "")
+
+		let hookMetadata: HookMetadata
+		try {
+			hookMetadata = JSON.parse(metadataStr)
+		} catch {
+			hookMetadata = { hookName: "Unknown", status: "unknown" }
+		}
+
+		return { metadata: hookMetadata, output }
+	}, [message.text])
+
+	// Determine initial expansion state using pure function
+	const [isHookOutputExpanded, setIsHookOutputExpanded] = useState(() => shouldExpandHookByDefault(message, metadata))
+
+	const isRunning = metadata.status === "running"
+	const isCompleted = metadata.status === "completed"
+	const isFailed = metadata.status === "failed"
+	const isCancelled = metadata.status === "cancelled"
+
+	const headerStyle: React.CSSProperties = {
+		display: "flex",
+		alignItems: "center",
+		gap: "10px",
+		marginBottom: "12px",
+	}
+
+	return (
+		<>
+			<div style={headerStyle}>
+				<span
+					className="codicon codicon-symbol-event"
+					style={{
+						color: normalColor,
+						marginBottom: "-1.5px",
+					}}></span>
+				<span style={{ color: normalColor, fontWeight: "bold" }}>Hook:</span>
+				<span style={{ color: normalColor }}>{metadata.hookName}</span>
+				{metadata.toolName && (
+					<span style={{ color: "var(--vscode-descriptionForeground)", fontSize: "0.9em" }}>({metadata.toolName})</span>
+				)}
+			</div>
+			<div
+				style={{
+					borderRadius: 6,
+					border: "1px solid var(--vscode-editorGroup-border)",
+					overflow: "visible",
+					backgroundColor: CHAT_ROW_EXPANDED_BG_COLOR,
+					transition: "all 0.3s ease-in-out",
+				}}>
+				<div
+					style={{
+						display: "flex",
+						alignItems: "center",
+						justifyContent: "space-between",
+						padding: "8px 10px",
+						backgroundColor: CHAT_ROW_EXPANDED_BG_COLOR,
+						borderBottom:
+							metadata.pendingToolInfo || output.length > 0 ? "1px solid var(--vscode-editorGroup-border)" : "none",
+						borderTopLeftRadius: "6px",
+						borderTopRightRadius: "6px",
+					}}>
+					<div
+						style={{
+							display: "flex",
+							alignItems: "center",
+							gap: "8px",
+							flex: 1,
+							minWidth: 0,
+						}}>
+						<div
+							style={{
+								width: "8px",
+								height: "8px",
+								borderRadius: "50%",
+								backgroundColor: isRunning ? successColor : isFailed || isCancelled ? errorColor : completedColor,
+								animation: isRunning ? "pulse 2s ease-in-out infinite" : "none",
+								flexShrink: 0,
+							}}
+						/>
+						<span
+							style={{
+								color: isRunning ? successColor : isFailed || isCancelled ? errorColor : completedColor,
+								fontWeight: 500,
+								fontSize: "13px",
+								flexShrink: 0,
+							}}>
+							{isRunning
+								? "Running"
+								: isFailed
+									? "Failed"
+									: isCancelled
+										? "Aborted"
+										: isCompleted
+											? "Completed"
+											: "Unknown"}
+						</span>
+						{metadata.exitCode !== undefined && metadata.exitCode !== 0 && (
+							<span
+								style={{
+									color: "var(--vscode-descriptionForeground)",
+									fontSize: "12px",
+								}}>
+								(exit: {metadata.exitCode})
+							</span>
+						)}
+					</div>
+					{isRunning && metadata.hookName !== "TaskCancel" && metadata.hookName !== "TaskComplete" && (
+						<button
+							onClick={(e) => {
+								e.stopPropagation()
+								// Cancel the task - cancelling a hook always cancels the entire task
+								TaskServiceClient.cancelTask(EmptyRequest.create({})).catch((err) =>
+									console.error("Failed to cancel task:", err),
+								)
+							}}
+							onMouseEnter={(e) => {
+								e.currentTarget.style.background = "var(--vscode-button-secondaryHoverBackground)"
+							}}
+							onMouseLeave={(e) => {
+								e.currentTarget.style.background = "var(--vscode-button-secondaryBackground)"
+							}}
+							style={{
+								background: "var(--vscode-button-secondaryBackground)",
+								color: "var(--vscode-button-secondaryForeground)",
+								border: "none",
+								borderRadius: "2px",
+								padding: "4px 10px",
+								fontSize: "12px",
+								cursor: "pointer",
+								fontFamily: "inherit",
+							}}>
+							Abort
+						</button>
+					)}
+				</div>
+
+				{/* Show concise error message for specific error types */}
+				{isFailed && metadata.error && metadata.error.type === "timeout" && (
+					<div
+						style={{
+							padding: "12px",
+							borderBottom: output.length > 0 ? "1px solid var(--vscode-editorGroup-border)" : "none",
+							fontSize: "13px",
+							color: "var(--vscode-descriptionForeground)",
+						}}>
+						Took longer than 30 seconds. Check for infinite loops or add timeouts to network requests.
+					</div>
+				)}
+
+				{isFailed && metadata.error && metadata.error.type === "validation" && (
+					<div
+						style={{
+							padding: "12px",
+							borderBottom: output.length > 0 ? "1px solid var(--vscode-editorGroup-border)" : "none",
+							fontSize: "13px",
+							color: "var(--vscode-descriptionForeground)",
+						}}>
+						Hook returned invalid JSON. See error details below for more information.
+					</div>
+				)}
+
+				{/* Show hook output if present */}
+				{output.length > 0 && (
+					<CommandOutput
+						isContainerExpanded={true}
+						isOutputFullyExpanded={isHookOutputExpanded}
+						onToggle={() => setIsHookOutputExpanded(!isHookOutputExpanded)}
+						output={output}
+					/>
+				)}
+			</div>
+		</>
+	)
+})
+
+export default HookMessage
diff --git a/apps/vscode/webview-ui/src/components/chat/MarkdownRow.tsx b/apps/vscode/webview-ui/src/components/chat/MarkdownRow.tsx
new file mode 100644
index 0000000..8453f0a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/MarkdownRow.tsx
@@ -0,0 +1,12 @@
+import { memo } from "react"
+import MarkdownBlock from "../common/MarkdownBlock"
+
+export const MarkdownRow = memo(({ markdown, showCursor }: { markdown?: string; showCursor?: boolean }) => {
+	return (
+		<div className="wrap-anywhere overflow-hidden [&_p]:mb-0">
+			<MarkdownBlock markdown={markdown} showCursor={showCursor} />
+		</div>
+	)
+})
+
+MarkdownRow.displayName = "MarkdownRow"
diff --git a/apps/vscode/webview-ui/src/components/chat/NewTaskPreview.tsx b/apps/vscode/webview-ui/src/components/chat/NewTaskPreview.tsx
new file mode 100644
index 0000000..378bee5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/NewTaskPreview.tsx
@@ -0,0 +1,17 @@
+import React from "react"
+import MarkdownBlock from "../common/MarkdownBlock"
+
+interface NewTaskPreviewProps {
+	context: string
+}
+
+const NewTaskPreview: React.FC<NewTaskPreviewProps> = ({ context }) => {
+	return (
+		<div className="bg-(--vscode-badge-background) text-(--vscode-badge-foreground) rounded-[3px] p-[14px] pb-[6px]">
+			<span style={{ fontWeight: "bold" }}>Task</span>
+			<MarkdownBlock markdown={context} />
+		</div>
+	)
+}
+
+export default NewTaskPreview
diff --git a/apps/vscode/webview-ui/src/components/chat/OptionsButtons.test.tsx b/apps/vscode/webview-ui/src/components/chat/OptionsButtons.test.tsx
new file mode 100644
index 0000000..f77dd4f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/OptionsButtons.test.tsx
@@ -0,0 +1,61 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { OptionsButtons } from "./OptionsButtons"
+
+const askResponseMock = vi.hoisted(() => vi.fn())
+
+vi.mock("@/services/grpc-client", () => ({
+	TaskServiceClient: {
+		askResponse: askResponseMock,
+	},
+}))
+
+describe("OptionsButtons", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("removes hover affordance from the other options immediately after a selection", async () => {
+		askResponseMock.mockReturnValue(new Promise(() => undefined))
+
+		render(<OptionsButtons isActive options={["Use this", "Use that"]} />)
+
+		const selectedButton = screen.getByRole("button", { name: "Use this" })
+		const otherButton = screen.getByRole("button", { name: "Use that" })
+
+		expect(getComputedStyle(otherButton).cursor).toBe("pointer")
+
+		fireEvent.click(selectedButton)
+
+		expect(askResponseMock).toHaveBeenCalledTimes(1)
+		await waitFor(() => {
+			expect(getComputedStyle(selectedButton).cursor).toBe("default")
+			expect(getComputedStyle(otherButton).cursor).toBe("default")
+		})
+
+		fireEvent.click(otherButton)
+
+		expect(askResponseMock).toHaveBeenCalledTimes(1)
+	})
+
+	it("re-enables options after askResponse rejects", async () => {
+		const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined)
+		askResponseMock.mockRejectedValue(new Error("failed"))
+
+		render(<OptionsButtons isActive options={["Use this", "Use that"]} />)
+
+		const selectedButton = screen.getByRole("button", { name: "Use this" })
+		const otherButton = screen.getByRole("button", { name: "Use that" })
+
+		fireEvent.click(selectedButton)
+
+		expect(askResponseMock).toHaveBeenCalledTimes(1)
+		await waitFor(() => {
+			expect(selectedButton).not.toBeDisabled()
+			expect(otherButton).not.toBeDisabled()
+			expect(getComputedStyle(otherButton).cursor).toBe("pointer")
+		})
+
+		consoleError.mockRestore()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/OptionsButtons.tsx b/apps/vscode/webview-ui/src/components/chat/OptionsButtons.tsx
new file mode 100644
index 0000000..2ea8585
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/OptionsButtons.tsx
@@ -0,0 +1,96 @@
+import { AskResponseRequest } from "@shared/proto/cline/task"
+import { useState } from "react"
+import styled from "styled-components"
+import { CODE_BLOCK_BG_COLOR } from "@/components/common/CodeBlock"
+import { TaskServiceClient } from "@/services/grpc-client"
+
+const OptionButton = styled.button<{ $isSelected?: boolean; $isNotSelectable?: boolean }>`
+	padding: 8px 12px;
+	background: ${(props) => (props.$isSelected ? "var(--vscode-focusBorder)" : CODE_BLOCK_BG_COLOR)};
+	color: ${(props) => (props.$isSelected ? "white" : "var(--vscode-input-foreground)")};
+	border: 1px solid var(--vscode-editorGroup-border);
+	border-radius: 2px;
+	cursor: ${(props) => (props.$isNotSelectable ? "default" : "pointer")};
+	text-align: left;
+	font-size: 12px;
+
+	${(props) =>
+		!props.$isNotSelectable &&
+		`
+		&:hover {
+			background: var(--vscode-focusBorder);
+			color: white;
+		}
+	`}
+`
+
+export const OptionsButtons = ({
+	options,
+	selected,
+	isActive,
+	inputValue,
+}: {
+	options?: string[]
+	selected?: string
+	isActive?: boolean
+	inputValue?: string
+}) => {
+	const optionItems = options ?? []
+	const optionsKey = optionItems.join("\u0000")
+	const optimisticSelectionKey = `${selected ?? ""}\u0001${optionsKey}`
+	const [optimisticSelection, setOptimisticSelection] = useState<{ key: string; option: string }>()
+
+	if (!optionItems.length) {
+		return null
+	}
+
+	const selectedOption =
+		selected !== undefined && optionItems.includes(selected)
+			? selected
+			: optimisticSelection?.key === optimisticSelectionKey
+				? optimisticSelection.option
+				: undefined
+	const hasSelected = selectedOption !== undefined && optionItems.includes(selectedOption)
+
+	return (
+		<div
+			style={{
+				display: "flex",
+				flexDirection: "column",
+				gap: "8px",
+			}}>
+			{/* <div style={{ color: "var(--vscode-descriptionForeground)", fontSize: "11px", textTransform: "uppercase" }}>
+				SELECT ONE:
+			</div> */}
+			{optionItems.map((option, index) => (
+				<OptionButton
+					$isNotSelectable={hasSelected || !isActive}
+					$isSelected={option === selectedOption}
+					className="options-button"
+					disabled={hasSelected || !isActive}
+					id={`options-button-${index}`}
+					key={option}
+					onClick={async () => {
+						if (hasSelected || !isActive) {
+							return
+						}
+						setOptimisticSelection({ key: optimisticSelectionKey, option })
+						try {
+							await TaskServiceClient.askResponse(
+								AskResponseRequest.create({
+									responseType: "messageResponse",
+									text: option + (inputValue ? `: ${inputValue?.trim()}` : ""),
+									images: [],
+								}),
+							)
+						} catch (error) {
+							setOptimisticSelection(undefined)
+							console.error("Error sending option response:", error)
+						}
+					}}>
+					<span className="ph-no-capture">{option}</span>
+				</OptionButton>
+			))}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/OrgClinePassRestrictionError.tsx b/apps/vscode/webview-ui/src/components/chat/OrgClinePassRestrictionError.tsx
new file mode 100644
index 0000000..b4da0b7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/OrgClinePassRestrictionError.tsx
@@ -0,0 +1,62 @@
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react";
+import { useState } from "react";
+import { AccountServiceClient } from "@/services/grpc-client";
+
+const ORG_CLINE_PASS_RESTRICTION_MESSAGE =
+	"Organization accounts cannot use ClinePass subscriptions.";
+
+const OrgClinePassRestrictionError = () => {
+	const [isSwitching, setIsSwitching] = useState(false);
+	const [didSwitch, setDidSwitch] = useState(false);
+	const [error, setError] = useState<string | undefined>();
+
+	const handleSwitchToPersonalAccount = async () => {
+		setIsSwitching(true);
+		setError(undefined);
+		try {
+			await AccountServiceClient.setUserOrganization({});
+			setDidSwitch(true);
+		} catch (error) {
+			console.error("Failed to switch to personal Cline account:", error);
+			setError(
+				"Failed to switch account. Use /accounts to switch to your personal account.",
+			);
+		} finally {
+			setIsSwitching(false);
+		}
+	};
+
+	return (
+		<div
+			className="p-2 border-none rounded-md mb-2 bg-(--vscode-textBlockQuote-background)"
+			data-testid="org-cline-pass-restriction-error"
+		>
+			<div className="text-error mb-2">
+				Organization account cannot use ClinePass
+			</div>
+			<div className="text-(--vscode-descriptionForeground) text-xs wrap-anywhere">
+				{ORG_CLINE_PASS_RESTRICTION_MESSAGE}
+			</div>
+			<VSCodeButton
+				className="w-full mt-3"
+				disabled={isSwitching || didSwitch}
+				onClick={handleSwitchToPersonalAccount}
+			>
+				{isSwitching
+					? "Switching..."
+					: didSwitch
+						? "Switched to personal account"
+						: "Switch to personal account"}
+			</VSCodeButton>
+			{didSwitch && (
+				<div className="text-(--vscode-descriptionForeground) text-xs mt-2">
+					Retry the request after switching.
+				</div>
+			)}
+			{error && <div className="text-error text-xs mt-2">{error}</div>}
+		</div>
+	);
+};
+
+export { ORG_CLINE_PASS_RESTRICTION_MESSAGE };
+export default OrgClinePassRestrictionError;
diff --git a/apps/vscode/webview-ui/src/components/chat/PlanCompletionOutputRow.tsx b/apps/vscode/webview-ui/src/components/chat/PlanCompletionOutputRow.tsx
new file mode 100644
index 0000000..b6c2af9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/PlanCompletionOutputRow.tsx
@@ -0,0 +1,43 @@
+import { NotepadTextIcon } from "lucide-react"
+import { memo } from "react"
+import { CopyButton } from "@/components/common/CopyButton"
+import MarkdownBlock from "@/components/common/MarkdownBlock"
+import { cn } from "@/lib/utils"
+
+interface PlanCompletionOutputProps {
+	text: string
+	onCopy?: () => void
+	headClassNames?: string
+}
+
+/**
+ * Styled completion output for Plan Mode responses
+ * Uses grayscale colors to distinguish from Act Mode's green success theme
+ */
+const PlanCompletionOutputRow = memo(({ text, headClassNames }: PlanCompletionOutputProps) => {
+	return (
+		<div className="rounded-sm border border-description/50 overflow-visible bg-code p-2 pt-3">
+			{/* Header */}
+			<div className={cn(headClassNames, "justify-between px-1")}>
+				<div className="flex gap-2 items-center">
+					<NotepadTextIcon className="size-2" />
+					<span className="text-foreground font-bold">Plan Created</span>
+				</div>
+				<CopyButton textToCopy={text || ""} />
+			</div>
+
+			{/* Content */}
+			<div className="w-full relative border-t-1 border-description/20 rounded-b-sm">
+				<div className="plan-completion-content p-2 pt-3 w-full [&_hr]:opacity-20 [&_p:last-child]:mb-0">
+					<div className="wrap-anywhere [&_hr]:opacity-20">
+						<MarkdownBlock markdown={text} />
+					</div>
+				</div>
+			</div>
+		</div>
+	)
+})
+
+PlanCompletionOutputRow.displayName = "PlanCompletionOutputRow"
+
+export default PlanCompletionOutputRow
diff --git a/apps/vscode/webview-ui/src/components/chat/QuoteButton.tsx b/apps/vscode/webview-ui/src/components/chat/QuoteButton.tsx
new file mode 100644
index 0000000..1ce7f8d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/QuoteButton.tsx
@@ -0,0 +1,42 @@
+import { QuoteIcon } from "lucide-react"
+import React from "react"
+import styled from "styled-components"
+import { Button } from "@/components/ui/button"
+
+interface QuoteButtonProps {
+	top: number
+	left: number
+	onClick: () => void
+}
+
+// Define props specifically for the styled component using transient props
+interface ButtonContainerProps {
+	$top: number
+	$left: number
+}
+
+const ButtonContainer = styled.div<ButtonContainerProps>`
+	top: ${(props) => props.$top}px; // Use transient prop $top
+	left: ${(props) => props.$left}px; // Use transient prop $left
+`
+
+const QuoteButton: React.FC<QuoteButtonProps> = ({ top, left, onClick }) => {
+	return (
+		// Pass transient props to the styled component
+		<ButtonContainer $left={left} $top={top} className="quote-button-class absolute">
+			<Button
+				aria-label="Quote selection"
+				className="p-3 h-auto min-w-auto rounded-md shadow-sm transition-transform hover:scale-105 z-10"
+				onClick={(e) => {
+					e.stopPropagation() // Prevent triggering mouseup on the parent
+					onClick()
+				}}
+				size="sm"
+				title="Quote selection in reply">
+				<QuoteIcon className="size-2 fill-button-foreground rotate-180 stroke-1" />
+			</Button>
+		</ButtonContainer>
+	)
+}
+
+export default QuoteButton
diff --git a/apps/vscode/webview-ui/src/components/chat/QuotedMessagePreview.tsx b/apps/vscode/webview-ui/src/components/chat/QuotedMessagePreview.tsx
new file mode 100644
index 0000000..235ddfe
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/QuotedMessagePreview.tsx
@@ -0,0 +1,89 @@
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import React from "react"
+import styled from "styled-components"
+
+const PreviewContainer = styled.div`
+	background-color: var(--vscode-input-background); /* Outer box matches text area */
+	/* border-left: 3px solid var(--vscode-textBlockQuote-border); */ /* Remove left border */
+	/* border-top: 1px solid var(--vscode-editorGroup-border); */ /* Remove top border */
+	padding: 4px 4px 4px 4px; /* Removed bottom padding */
+	margin: 0px 15px 0 15px; /* Remove bottom+top margin, equal left/right */
+	border-radius: 2px 2px 0 0; /* Only round top corners */
+	display: flex;
+	/* flex-direction: column; */ /* No longer needed as Label is removed */
+	position: relative; /* Keep for button positioning */
+`
+
+// Removed Label component
+
+const ContentRow = styled.div`
+	/* Mix outer background with white to ensure a much lighter inner box */
+	background-color: color-mix(in srgb, var(--vscode-input-background) 70%, white 30%);
+	border-radius: 2px 2px 2px 2px; /* Round top corners, square bottom corners */
+	padding: 8px 10px 10px 8px; /* Reduced left padding */
+	display: flex;
+	align-items: flex-start; /* Align items to the top */
+	justify-content: space-between;
+	width: 100%;
+`
+
+const TextContainer = styled.div`
+	grow: 1;
+	margin: 0 2px; /* Further reduced space around text */
+	white-space: pre-wrap;
+	word-break: break-word;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: -webkit-box;
+	-webkit-line-clamp: 3;
+	-webkit-box-orient: vertical;
+	font-size: var(--vscode-editor-font-size); /* Use editor font size */
+	opacity: 0.9; /* Slightly muted text */
+	line-height: 1.4; /* Improve readability */
+	max-height: calc(1.4 * var(--vscode-editor-font-size) * 3); /* approx 3 lines */
+`
+
+const DismissButton = styled(VSCodeButton)`
+	/* margin-left: auto; */ /* Removed as ContentRow handles spacing */
+	shrink: 0; /* Prevent button from shrinking */
+	min-width: 22px;
+	height: 22px;
+	padding: 0;
+	/* margin-top: 20px; */ /* Remove top margin */
+	display: flex;
+	align-items: center;
+	justify-content: center;
+`
+
+const ReplyIcon = styled.span`
+	color: var(--vscode-descriptionForeground);
+	margin-right: 2px; /* Further reduced space between icon and text */
+	shrink: 0;
+	font-size: 13px; /* Make icon even smaller */
+	/* transform: translateY(-1px); */ /* Removed vertical transform */
+`
+
+interface QuotedMessagePreviewProps {
+	text: string
+	onDismiss: () => void
+	isFocused?: boolean
+}
+
+const QuotedMessagePreview: React.FC<QuotedMessagePreviewProps> = ({ text, onDismiss, isFocused }) => {
+	const _cardClassName = `reply-card ${isFocused ? "reply-card--focused" : ""}`
+
+	return (
+		<PreviewContainer>
+			{/* Removed Label */}
+			<ContentRow>
+				<ReplyIcon className="codicon codicon-reply"></ReplyIcon>
+				<TextContainer title={text}>{text}</TextContainer>
+				<DismissButton appearance="icon" aria-label="Dismiss quote" onClick={onDismiss}>
+					<span className="codicon codicon-close"></span>
+				</DismissButton>
+			</ContentRow>
+		</PreviewContainer>
+	)
+}
+
+export default QuotedMessagePreview
diff --git a/apps/vscode/webview-ui/src/components/chat/ReportBugPreview.tsx b/apps/vscode/webview-ui/src/components/chat/ReportBugPreview.tsx
new file mode 100644
index 0000000..17ccfed
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ReportBugPreview.tsx
@@ -0,0 +1,84 @@
+import React from "react"
+import MarkdownBlock from "../common/MarkdownBlock"
+
+interface ReportBugPreviewProps {
+	data: string
+}
+
+const ReportBugPreview: React.FC<ReportBugPreviewProps> = ({ data }) => {
+	// Parse the JSON data from the context string
+	const bugData = React.useMemo(() => {
+		try {
+			return JSON.parse(data || "{}")
+		} catch (e) {
+			console.error("Failed to parse bug report data", e)
+			return {}
+		}
+	}, [data])
+
+	return (
+		<div className="bg-badge-background/50 text-badge-foreground rounded-xs p-3">
+			<h2 className="font-bold mb-3">{bugData.title || "Bug Report"}</h2>
+
+			<div className="space-y-3 text-sm">
+				{bugData.what_happened && (
+					<div>
+						<div className="font-semibold">What Happened?</div>
+						<MarkdownBlock markdown={bugData.what_happened} />
+					</div>
+				)}
+
+				{bugData.steps_to_reproduce && (
+					<div>
+						<div className="font-semibold">Steps to Reproduce</div>
+						<MarkdownBlock markdown={bugData.steps_to_reproduce} />
+					</div>
+				)}
+
+				{bugData.api_request_output && (
+					<div>
+						<div className="font-semibold">Relevant API Request Output</div>
+						<MarkdownBlock markdown={bugData.api_request_output} />
+					</div>
+				)}
+
+				{bugData.provider_and_model && (
+					<div>
+						<div className="font-semibold">Provider/Model</div>
+						<MarkdownBlock markdown={bugData.provider_and_model} />
+					</div>
+				)}
+
+				{bugData.operating_system && (
+					<div>
+						<div className="font-semibold">Operating System</div>
+						<MarkdownBlock markdown={bugData.operating_system} />
+					</div>
+				)}
+
+				{bugData.system_info && (
+					<div>
+						<div className="font-semibold">System Info</div>
+						<MarkdownBlock markdown={bugData.system_info} />
+					</div>
+				)}
+
+				{bugData.cline_version && (
+					<div>
+						<div className="font-semibold">Cline Version</div>
+						<MarkdownBlock markdown={bugData.cline_version} />
+					</div>
+				)}
+
+				{bugData.additional_context && (
+					<div>
+						<div className="font-semibold">Additional Context</div>
+						<MarkdownBlock markdown={bugData.additional_context} />
+					</div>
+				)}
+			</div>
+		</div>
+	)
+}
+
+export default ReportBugPreview
diff --git a/apps/vscode/webview-ui/src/components/chat/RequestStartRow.tsx b/apps/vscode/webview-ui/src/components/chat/RequestStartRow.tsx
new file mode 100644
index 0000000..2662d25
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/RequestStartRow.tsx
@@ -0,0 +1,261 @@
+import type { ClineMessage, ClineSayTool } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+import type { LucideIcon } from "lucide-react"
+import type React from "react"
+import { useMemo } from "react"
+import { cleanPathPrefix } from "../common/CodeAccordian"
+import { getIconByToolName } from "./chat-view"
+import { isApiReqAbsorbable, isLowStakesTool } from "./chat-view/utils/messageUtils"
+import ErrorRow from "./ErrorRow"
+import { ThinkingRow } from "./ThinkingRow"
+import { TypewriterText } from "./TypewriterText"
+
+interface RequestStartRowProps {
+	message: ClineMessage
+	apiRequestFailedMessage?: string
+	apiReqStreamingFailedMessage?: string
+	cost?: number
+	reasoningContent?: string
+	responseStarted?: boolean
+	clineMessages: ClineMessage[]
+	mode?: Mode
+	classNames?: string
+	isExpanded: boolean
+	handleToggle: () => void
+}
+
+// State type for api_req_started rendering
+type ApiReqState = "pre" | "thinking" | "error" | "final"
+
+// Helper to format search regex for display - show all terms separated by |
+const formatSearchRegex = (regex: string, path: string, filePattern?: string): string => {
+	const cleanedPath = cleanPathPrefix(path)
+	const pathDisplay = cleanedPath ? `${cleanedPath}/` : "codebase"
+	const terms = regex
+		.split("|")
+		.map((t) => t.trim().replace(/\\b/g, "").replace(/\\s\?/g, " "))
+		.filter(Boolean)
+		.join(" | ")
+	return filePattern && filePattern !== "*" ? `"${terms}" in ${pathDisplay} (${filePattern})` : `"${terms}" in ${pathDisplay}`
+}
+// Format activity text based on tool type
+const getActivityText = (tool: ClineSayTool): string | null => {
+	const cleanedPath = cleanPathPrefix(tool.path || "")
+	switch (tool.tool) {
+		case "readFile":
+			return tool.path ? `Reading ${cleanedPath}...` : null
+		case "listFilesTopLevel":
+		case "listFilesRecursive":
+			return tool.path ? `Exploring ${cleanedPath}/...` : null
+		case "searchFiles":
+			return tool.regex ? `Searching ${formatSearchRegex(tool.regex, tool.path || "", tool.filePattern)}...` : null
+		case "listCodeDefinitionNames":
+			return tool.path ? `Analyzing ${cleanedPath}/...` : null
+		default:
+			return null
+	}
+}
+
+// Collect tools in a given range, with optional stop condition
+const collectToolsInRange = (
+	messages: ClineMessage[],
+	startIdx: number,
+	endIdx: number,
+	stopCondition?: (msg: ClineMessage) => boolean,
+): { icon: LucideIcon; text: string }[] => {
+	const activities: { icon: LucideIcon; text: string }[] = []
+
+	for (let i = startIdx; i < endIdx; i++) {
+		const msg = messages[i]
+
+		if (stopCondition?.(msg)) {
+			break
+		}
+
+		// Only collect tools that are currently executing (ask === "tool")
+		// Skip completed tools (say === "tool") - they should be in the completed list
+		if (msg.say === "tool" || msg.ask !== "tool") {
+			continue
+		}
+
+		try {
+			const tool = JSON.parse(msg.text || "{}") as ClineSayTool
+			const activityText = getActivityText(tool)
+			if (activityText) {
+				const toolIcon = getIconByToolName(tool.tool)
+				activities.push({ icon: toolIcon, text: activityText })
+			}
+		} catch {
+			// ignore parse errors
+		}
+	}
+	return activities
+}
+
+// Find current api_req and determine if it has cost
+const findCurrentApiReq = (messages: ClineMessage[]): { index: number; hasCost: boolean } | null => {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i]
+		if (msg.say === "api_req_started" && msg.text) {
+			try {
+				const info = JSON.parse(msg.text)
+				return { index: i, hasCost: info.cost != null }
+			} catch {
+				return null
+			}
+		}
+	}
+	return null
+}
+
+// Find the most recent completed api_req before the given index
+const findPrevCompletedApiReq = (messages: ClineMessage[], beforeIdx: number): number => {
+	for (let i = beforeIdx - 1; i >= 0; i--) {
+		const msg = messages[i]
+		if (msg.say === "api_req_started" && msg.text) {
+			try {
+				const info = JSON.parse(msg.text)
+				if (info.cost != null) {
+					return i
+				}
+			} catch {
+				// ignore parse errors
+			}
+		}
+	}
+	return -1
+}
+
+/**
+ * Displays the current state of an active tool operation,
+ */
+export const RequestStartRow: React.FC<RequestStartRowProps> = ({
+	apiRequestFailedMessage,
+	apiReqStreamingFailedMessage,
+	cost,
+	reasoningContent,
+	responseStarted,
+	clineMessages,
+	mode,
+	handleToggle,
+	isExpanded,
+	message,
+}) => {
+	// Derive explicit state
+	const hasError = !!(apiRequestFailedMessage || apiReqStreamingFailedMessage)
+	const hasCost = cost != null
+	const hasReasoning = !!reasoningContent
+	const hasCompletionResult = clineMessages.some(
+		(msg) => msg.ask === "completion_result" || msg.say === "completion_result" || msg.ask === "plan_mode_respond",
+	)
+
+	const apiReqState: ApiReqState = hasError ? "error" : hasCost ? "final" : hasReasoning ? "thinking" : "pre"
+
+	// While reasoning is streaming, keep the Brain ThinkingBlock exactly as-is.
+	// Once response content starts (any text/tool/command), collapse into a compact
+	// "🧠 Thinking" row that can be expanded to show the reasoning only.
+	const showStreamingThinking = useMemo(
+		() => hasReasoning && !hasError && !cost && !responseStarted,
+		[hasReasoning, hasError, cost, responseStarted],
+	)
+
+	// Check if this api_req will be absorbed into a tool group (reasoning will disappear)
+	const willBeAbsorbed = useMemo(() => {
+		return isApiReqAbsorbable(message.ts, clineMessages)
+	}, [message.ts, clineMessages])
+
+	// Find all exploratory tool activities that are currently in flight.
+	// Tools come AFTER the api_req_started message, so we look from currentApiReq forward.
+	const currentActivities = useMemo(() => {
+		const currentApiReq = findCurrentApiReq(clineMessages)
+		if (!currentApiReq) {
+			return []
+		}
+
+		if (!currentApiReq.hasCost) {
+			// CASE A: Current api_req is INCOMPLETE
+			// Look for ask === "tool" messages AFTER the current api_req_started
+			return collectToolsInRange(clineMessages, currentApiReq.index + 1, clineMessages.length)
+		}
+		// CASE B: Current api_req is COMPLETE - no activities to show
+		return []
+	}, [clineMessages])
+
+	// Check if there are any completed tools in the tool group
+	const hasCompletedTools = useMemo(() => {
+		// Look for any completed low-stakes tool messages that would be in a tool group
+		return clineMessages.some((msg, idx) => {
+			if (msg.say === "tool" && isLowStakesTool(msg)) {
+				// Check if this tool is from a completed API request
+				// (looking backwards for an api_req with cost)
+				for (let i = idx - 1; i >= 0; i--) {
+					const prevMsg = clineMessages[i]
+					if (prevMsg.say === "api_req_started" && prevMsg.text) {
+						try {
+							const info = JSON.parse(prevMsg.text)
+							return info.cost != null
+						} catch {
+							return false
+						}
+					}
+				}
+			}
+			return false
+		})
+	}, [clineMessages])
+
+	// Only show currentActivities if there are NO completed tools
+	// (otherwise they'll be shown in the unified ToolGroupRenderer list)
+	const shouldShowActivities = currentActivities.length > 0 && !hasCompletedTools
+
+	// Initial loading ("Thinking..." before any content) is injected as a synthetic in-list
+	// reasoning row in MessagesArea to avoid footer handoff flicker.
+
+	return (
+		<div>
+			{apiReqState === "pre" && shouldShowActivities && (
+				<div className="flex items-center text-description w-full text-sm">
+					<div className="ml-1 flex-1 w-full h-full">
+						<div className="flex flex-col gap-0.5 w-full min-h-1">
+							{currentActivities.map((activity, _) => (
+								<div className="flex items-center gap-2 h-auto w-full overflow-hidden" key={activity.text}>
+									<activity.icon className="size-2 text-foreground shrink-0" />
+									<TypewriterText speed={15} text={activity.text} />
+								</div>
+							))}
+						</div>
+					</div>
+				</div>
+			)}
+			{reasoningContent &&
+				(!hasCost ? (
+					// Still streaming - show "Thinking..." text with shimmer
+					<div className="ml-1 pl-0 mb-1 -mt-1.25 pt-1">
+						<div className="inline-flex justify-baseline gap-0.5 text-left select-none px-0 w-full">
+							<span className="animate-shimmer bg-linear-90 from-foreground to-description bg-[length:200%_100%] bg-clip-text text-transparent text-[13px] leading-none">
+								Thinking...
+							</span>
+						</div>
+					</div>
+				) : (
+					// Complete - always show collapsible thinking section
+					<ThinkingRow
+						isExpanded={isExpanded}
+						isVisible={true}
+						onToggle={handleToggle}
+						reasoningContent={reasoningContent}
+						showTitle={true}
+					/>
+				))}
+
+			{apiReqState === "error" && (
+				<ErrorRow
+					apiReqStreamingFailedMessage={apiReqStreamingFailedMessage}
+					apiRequestFailedMessage={apiRequestFailedMessage}
+					errorType="error"
+					message={message}
+				/>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/SearchResultsDisplay.test.tsx b/apps/vscode/webview-ui/src/components/chat/SearchResultsDisplay.test.tsx
new file mode 100644
index 0000000..65b8033
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/SearchResultsDisplay.test.tsx
@@ -0,0 +1,32 @@
+import { render, screen } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import SearchResultsDisplay from "./SearchResultsDisplay"
+
+describe("SearchResultsDisplay", () => {
+	it("does not crash when approval asks have no result content yet", () => {
+		const { container } = render(
+			<SearchResultsDisplay content={undefined} isExpanded={false} onToggleExpand={vi.fn()} path={undefined} />,
+		)
+
+		expect(container).toBeEmptyDOMElement()
+	})
+
+	it("renders search result content when present", () => {
+		render(<SearchResultsDisplay content="README.md: hello" isExpanded={false} onToggleExpand={vi.fn()} path="." />)
+
+		expect(screen.getByRole("button", { name: "Expand code block" })).toBeInTheDocument()
+	})
+
+	it("does not render undefined when multi-workspace results have no path", () => {
+		render(
+			<SearchResultsDisplay
+				content={`Found 1 result across 1 workspace.\n## Workspace: app\nREADME.md: hello`}
+				isExpanded={false}
+				onToggleExpand={vi.fn()}
+				path={undefined}
+			/>,
+		)
+
+		expect(screen.queryByText("undefined")).not.toBeInTheDocument()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/SearchResultsDisplay.tsx b/apps/vscode/webview-ui/src/components/chat/SearchResultsDisplay.tsx
new file mode 100644
index 0000000..371d5ef
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/SearchResultsDisplay.tsx
@@ -0,0 +1,206 @@
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import React, { useMemo } from "react"
+import CodeAccordian from "../common/CodeAccordian"
+
+interface SearchResultsDisplayProps {
+	content?: string
+	isExpanded: boolean
+	onToggleExpand: () => void
+	path?: string
+	filePattern?: string
+}
+
+const SearchResultsDisplay: React.FC<SearchResultsDisplayProps> = ({
+	content,
+	isExpanded,
+	onToggleExpand,
+	path,
+	filePattern,
+}) => {
+	const safeContent = content ?? ""
+	const safePath = path ?? ""
+
+	const parsedData = useMemo(() => {
+		// Check if this is a multi-workspace result
+		const multiWorkspaceMatch = safeContent.match(/^Found \d+ results? across \d+ workspaces?\./m)
+
+		if (!multiWorkspaceMatch) {
+			// Single workspace result - return as is
+			return { isMultiWorkspace: false }
+		}
+
+		// Parse multi-workspace results
+		const lines = safeContent.split("\n")
+		const sections: Array<{ workspace: string; content: string }> = []
+		let currentWorkspace: string | null = null
+		let currentContent: string[] = []
+
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i]
+
+			// Check for workspace header
+			if (line.startsWith("## Workspace: ")) {
+				// Save previous workspace section if exists
+				if (currentWorkspace && currentContent.length > 0) {
+					sections.push({
+						workspace: currentWorkspace,
+						content: currentContent.join("\n"),
+					})
+				}
+
+				// Start new workspace section
+				currentWorkspace = line.replace("## Workspace: ", "").trim()
+				currentContent = []
+			} else if (currentWorkspace) {
+				// Add line to current workspace content
+				currentContent.push(line)
+			}
+		}
+
+		// Save last workspace section
+		if (currentWorkspace && currentContent.length > 0) {
+			sections.push({
+				workspace: currentWorkspace,
+				content: currentContent.join("\n"),
+			})
+		}
+
+		return { isMultiWorkspace: true, sections, summaryLine: lines[0] }
+	}, [safeContent])
+
+	if (!safeContent) {
+		return null
+	}
+
+	// For single workspace, use the standard CodeAccordian
+	if (!parsedData.isMultiWorkspace) {
+		return (
+			<CodeAccordian
+				code={safeContent}
+				isExpanded={isExpanded}
+				language="plaintext"
+				onToggleExpand={onToggleExpand}
+				path={safePath + (filePattern ? `/(${filePattern})` : "")}
+			/>
+		)
+	}
+
+	// For multi-workspace results, render a custom view
+	const { sections, summaryLine } = parsedData
+
+	return (
+		<div
+			style={{
+				borderRadius: 3,
+				backgroundColor: "var(--vscode-textCodeBlock-background)",
+				overflow: "hidden",
+				border: "1px solid var(--vscode-editorGroup-border)",
+			}}>
+			<div
+				aria-label={isExpanded ? "Collapse search results" : "Expand search results"}
+				onClick={onToggleExpand}
+				onKeyDown={(e) => {
+					if (e.key === "Enter" || e.key === " ") {
+						e.preventDefault()
+						e.stopPropagation()
+						onToggleExpand()
+					}
+				}}
+				style={{
+					color: "var(--vscode-descriptionForeground)",
+					display: "flex",
+					alignItems: "center",
+					padding: "9px 10px",
+					cursor: "pointer",
+					userSelect: "none",
+					WebkitUserSelect: "none",
+					MozUserSelect: "none",
+					msUserSelect: "none",
+				}}
+				tabIndex={0}>
+				<span>/</span>
+				<span
+					style={{
+						whiteSpace: "nowrap",
+						overflow: "hidden",
+						textOverflow: "ellipsis",
+						marginRight: "8px",
+					}}>
+					{safePath + (filePattern ? `/(${filePattern})` : "")}
+				</span>
+				<div style={{ flexGrow: 1 }} />
+				{isExpanded ? (
+					<ChevronDownIcon size={16} style={{ margin: "1px 0" }} />
+				) : (
+					<ChevronRightIcon size={16} style={{ margin: "1px 0" }} />
+				)}
+			</div>
+
+			{isExpanded && (
+				<div style={{ padding: "10px", borderTop: "1px solid var(--vscode-editorGroup-border)" }}>
+					{/* Summary line */}
+					<div
+						style={{
+							marginBottom: "12px",
+							fontWeight: "bold",
+							color: "var(--vscode-foreground)",
+						}}>
+						{summaryLine}
+					</div>
+
+					{/* Workspace sections */}
+					{sections?.map((section: any, index: number) => (
+						<div
+							key={`workspace-${section.workspace}`}
+							style={{ marginBottom: index < sections.length - 1 ? "16px" : 0 }}>
+							<div
+								style={{
+									display: "flex",
+									alignItems: "center",
+									gap: "6px",
+									marginBottom: "8px",
+									padding: "4px 8px",
+									backgroundColor: "var(--vscode-editor-background)",
+									borderRadius: "3px",
+									border: "1px solid var(--vscode-editorWidget-border)",
+								}}>
+								<span
+									className="codicon codicon-folder"
+									style={{
+										fontSize: "14px",
+										color: "var(--vscode-symbolIcon-folderForeground)",
+									}}
+								/>
+								<span
+									style={{
+										fontWeight: "500",
+										color: "var(--vscode-foreground)",
+									}}>
+									Workspace: {section.workspace}
+								</span>
+							</div>
+
+							{/* Results for this workspace */}
+							<div
+								style={{
+									backgroundColor: "var(--vscode-textCodeBlock-background)",
+									padding: "8px",
+									borderRadius: "3px",
+									fontSize: "var(--vscode-editor-font-size)",
+									fontFamily: "var(--vscode-editor-font-family)",
+									lineHeight: "1.5",
+									whiteSpace: "pre-wrap",
+									wordBreak: "break-word",
+									overflowWrap: "anywhere",
+								}}>
+								<pre style={{ margin: 0, fontFamily: "inherit" }}>{section.content.trim()}</pre>
+							</div>
+						</div>
+					))}
+				</div>
+			)}
+		</div>
+	)
+}
+
+export default SearchResultsDisplay
diff --git a/apps/vscode/webview-ui/src/components/chat/ServersToggleModal.tsx b/apps/vscode/webview-ui/src/components/chat/ServersToggleModal.tsx
new file mode 100644
index 0000000..a5a2270
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ServersToggleModal.tsx
@@ -0,0 +1,97 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import React, { useEffect, useRef, useState } from "react"
+import { useClickAway, useWindowSize } from "react-use"
+import PopupModalContainer from "@/components/common/PopupModalContainer"
+import ServersToggleList from "@/components/mcp/configuration/tabs/installed/ServersToggleList"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { McpServiceClient } from "@/services/grpc-client"
+
+const ServersToggleModal: React.FC = () => {
+	const { mcpServers, navigateToMcp, setMcpServers } = useExtensionState()
+	const [isVisible, setIsVisible] = useState(false)
+	const buttonRef = useRef<HTMLDivElement>(null)
+	const modalRef = useRef<HTMLDivElement>(null)
+	const { width: viewportWidth, height: viewportHeight } = useWindowSize()
+	const [arrowPosition, setArrowPosition] = useState(0)
+	const [menuPosition, setMenuPosition] = useState(0)
+
+	useEffect(() => {
+		if (isVisible) {
+			McpServiceClient.getLatestMcpServers(EmptyRequest.create({}))
+				.then((response: McpServers) => {
+					if (response.mcpServers) {
+						const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+						setMcpServers(mcpServers)
+					}
+				})
+				.catch((error) => {
+					console.error("Failed to fetch MCP servers:", error)
+				})
+		}
+	}, [isVisible, setMcpServers])
+
+	// Close modal when clicking outside
+	useClickAway(modalRef, () => {
+		setIsVisible(false)
+	})
+
+	// Calculate positions for modal and arrow
+	useEffect(() => {
+		if (isVisible && buttonRef.current) {
+			const buttonRect = buttonRef.current.getBoundingClientRect()
+			const buttonCenter = buttonRect.left + buttonRect.width / 2
+			const rightPosition = document.documentElement.clientWidth - buttonCenter - 5
+
+			setArrowPosition(rightPosition)
+			setMenuPosition(buttonRect.top + 1)
+		}
+	}, [isVisible, viewportWidth, viewportHeight])
+
+	return (
+		<div className="inline-flex min-w-0 max-w-full items-center" ref={modalRef}>
+			<div className="inline-flex w-full items-center" ref={buttonRef}>
+				<Tooltip>
+					{!isVisible && <TooltipContent>Manage MCP Servers</TooltipContent>}
+					<TooltipTrigger>
+						<VSCodeButton
+							appearance="icon"
+							aria-label={isVisible ? "Hide MCP Servers" : "Show MCP Servers"}
+							className="p-0 m-0 flex items-center"
+							onClick={() => setIsVisible(!isVisible)}>
+							<i className="codicon codicon-server" style={{ fontSize: "12.5px" }} />
+						</VSCodeButton>
+					</TooltipTrigger>
+				</Tooltip>
+			</div>
+
+			{isVisible && (
+				<PopupModalContainer $arrowPosition={arrowPosition} $menuPosition={menuPosition}>
+					<div className="flex-shrink-0 px-3 pt-2">
+						<div className="flex justify-between items-center mb-2.5">
+							<div className="m-0 text-sm font-medium">MCP Servers</div>
+							<VSCodeButton
+								appearance="icon"
+								aria-label="Go to MCP server settings"
+								onClick={() => {
+									setIsVisible(false)
+									navigateToMcp("configure")
+								}}>
+								<span className="codicon codicon-gear text-[10px]"></span>
+							</VSCodeButton>
+						</div>
+					</div>
+
+					<div className="flex-1 overflow-y-auto px-3 pb-3" style={{ minHeight: 0 }}>
+						<ServersToggleList hasTrashIcon={false} isExpandable={false} listGap="small" servers={mcpServers} />
+					</div>
+				</PopupModalContainer>
+			)}
+		</div>
+	)
+}
+
+export default ServersToggleModal
diff --git a/apps/vscode/webview-ui/src/components/chat/SlashCommandMenu.tsx b/apps/vscode/webview-ui/src/components/chat/SlashCommandMenu.tsx
new file mode 100644
index 0000000..602e309
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/SlashCommandMenu.tsx
@@ -0,0 +1,155 @@
+import type { McpServer } from "@shared/mcp"
+import React, { useCallback, useEffect, useRef } from "react"
+import ScreenReaderAnnounce from "@/components/common/ScreenReaderAnnounce"
+import { useMenuAnnouncement } from "@/hooks/useMenuAnnouncement"
+import type { SlashCommand } from "@/utils/slash-commands"
+import { getMatchingSlashCommands } from "@/utils/slash-commands"
+
+interface SlashCommandMenuProps {
+	onSelect: (command: SlashCommand) => void
+	selectedIndex: number
+	setSelectedIndex: (index: number) => void
+	onMouseDown: () => void
+	query: string
+	localWorkflowToggles?: Record<string, boolean>
+	globalWorkflowToggles?: Record<string, boolean>
+	remoteWorkflowToggles?: Record<string, boolean>
+	remoteWorkflows?: any[]
+	mcpServers?: McpServer[]
+}
+
+const SlashCommandMenu: React.FC<SlashCommandMenuProps> = ({
+	onSelect,
+	selectedIndex,
+	setSelectedIndex,
+	onMouseDown,
+	query,
+	localWorkflowToggles = {},
+	globalWorkflowToggles = {},
+	remoteWorkflowToggles,
+	remoteWorkflows,
+	mcpServers = [],
+}) => {
+	const menuRef = useRef<HTMLDivElement>(null)
+
+	// Filter commands based on query
+	const filteredCommands = getMatchingSlashCommands(
+		query,
+		localWorkflowToggles,
+		globalWorkflowToggles,
+		remoteWorkflowToggles,
+		remoteWorkflows,
+		mcpServers,
+	)
+	const defaultCommands = filteredCommands.filter((cmd) => cmd.section === "default" || !cmd.section)
+	const workflowCommands = filteredCommands.filter((cmd) => cmd.section === "custom")
+	const mcpCommands = filteredCommands.filter((cmd) => cmd.section === "mcp")
+
+	// Screen reader announcements
+	const getCommandLabel = useCallback((command: SlashCommand) => {
+		const description = command.description ? `, ${command.description}` : ""
+		return `${command.name}${description}`
+	}, [])
+
+	const { announcement } = useMenuAnnouncement({
+		items: filteredCommands,
+		selectedIndex,
+		getItemLabel: getCommandLabel,
+	})
+
+	const handleClick = useCallback(
+		(command: SlashCommand) => {
+			onSelect(command)
+		},
+		[onSelect],
+	)
+
+	useEffect(() => {
+		if (menuRef.current) {
+			const selectedElement = menuRef.current.querySelector(`#slash-command-menu-item-${selectedIndex}`) as HTMLElement
+			if (selectedElement) {
+				const menuRect = menuRef.current.getBoundingClientRect()
+				const selectedRect = selectedElement.getBoundingClientRect()
+
+				if (selectedRect.bottom > menuRect.bottom) {
+					menuRef.current.scrollTop += selectedRect.bottom - menuRect.bottom
+				} else if (selectedRect.top < menuRect.top) {
+					menuRef.current.scrollTop -= menuRect.top - selectedRect.top
+				}
+			}
+		}
+	}, [selectedIndex])
+
+	// Create a reusable function for rendering a command section
+	const renderCommandSection = (commands: SlashCommand[], title: string, indexOffset: number, showDescriptions: boolean) => {
+		if (commands.length === 0) {
+			return null
+		}
+
+		return (
+			<>
+				<div
+					className="text-xs text-(--vscode-descriptionForeground) px-3 py-1 font-bold border-b border-(--vscode-editorGroup-border)"
+					role="presentation">
+					{title}
+				</div>
+				{commands.map((command, index) => {
+					const itemIndex = index + indexOffset
+					return (
+						<div
+							aria-selected={itemIndex === selectedIndex}
+							className={`slash-command-menu-item py-2 px-3 cursor-pointer flex flex-col border-b border-(--vscode-editorGroup-border) ${
+								itemIndex === selectedIndex
+									? "bg-(--vscode-quickInputList-focusBackground) text-(--vscode-quickInputList-focusForeground)"
+									: ""
+							} hover:bg-(--vscode-list-hoverBackground)`}
+							id={`slash-command-menu-item-${itemIndex}`}
+							key={command.name}
+							onClick={() => handleClick(command)}
+							onMouseEnter={() => setSelectedIndex(itemIndex)}
+							role="option">
+							<div className="font-bold whitespace-nowrap overflow-hidden text-ellipsis">
+								<span className="ph-no-capture">/{command.name}</span>
+							</div>
+							{showDescriptions && command.description && (
+								<div className="text-[0.85em] text-(--vscode-descriptionForeground) whitespace-normal overflow-hidden text-ellipsis">
+									<span className="ph-no-capture">{command.description}</span>
+								</div>
+							)}
+						</div>
+					)
+				})}
+			</>
+		)
+	}
+
+	return (
+		<div
+			className="absolute bottom-[calc(100%-10px)] left-[15px] right-[15px] overflow-x-hidden z-1000"
+			data-testid="slash-commands-menu"
+			onMouseDown={onMouseDown}>
+			<ScreenReaderAnnounce message={announcement} />
+			<div
+				aria-activedescendant={filteredCommands.length > 0 ? `slash-command-menu-item-${selectedIndex}` : undefined}
+				aria-label="Slash commands"
+				className="bg-(--vscode-dropdown-background) border border-(--vscode-editorGroup-border) rounded-[3px] shadow-[0_4px_10px_rgba(0,0,0,0.25)] flex flex-col overflow-y-auto"
+				ref={menuRef}
+				role="listbox"
+				style={{ maxHeight: "min(200px, calc(50vh))", overscrollBehavior: "contain" }}>
+				{filteredCommands.length > 0 ? (
+					<>
+						{renderCommandSection(defaultCommands, "Default Commands", 0, true)}
+						{renderCommandSection(workflowCommands, "Workflow Commands", defaultCommands.length, false)}
+						{renderCommandSection(mcpCommands, "MCP Prompts", defaultCommands.length + workflowCommands.length, true)}
+					</>
+				) : (
+					<div aria-selected="false" className="py-2 px-3 cursor-default flex flex-col" role="option">
+						<div className="text-[0.85em] text-(--vscode-descriptionForeground)">No matching commands found</div>
+					</div>
+				)}
+			</div>
+		</div>
+	)
+}
+
+export default SlashCommandMenu
diff --git a/apps/vscode/webview-ui/src/components/chat/SpendLimitError.tsx b/apps/vscode/webview-ui/src/components/chat/SpendLimitError.tsx
new file mode 100644
index 0000000..88e48b3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/SpendLimitError.tsx
@@ -0,0 +1,145 @@
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import React, { useEffect, useState } from "react"
+import { AccountServiceClient } from "@/services/grpc-client"
+
+const COOLDOWN_MS = 5 * 60 * 1000 // 5 minutes
+const COOLDOWN_KEY = "cline:spendLimitRequestCooldown"
+
+type RequestButtonState = "idle" | "sending" | "sent"
+
+function formatResetsAt(resetsAt?: string): string | null {
+	if (!resetsAt) return null
+	try {
+		const date = new Date(resetsAt)
+		if (isNaN(date.getTime())) return null
+		return date.toLocaleDateString(undefined, {
+			month: "short",
+			day: "numeric",
+			hour: "2-digit",
+			minute: "2-digit",
+		})
+	} catch {
+		return null
+	}
+}
+
+interface SpendLimitErrorProps {
+	/** Human-readable error message from the backend */
+	message: string
+	/** Which period the limit applies to: "daily" | "monthly" */
+	budgetPeriod?: string
+	/** The configured spend limit in USD */
+	limitUsd?: number
+	/** How much the user has spent in USD this period */
+	spentUsd?: number
+	/** ISO 8601 timestamp of when the limit resets (may be null for monthly) */
+	resetsAt?: string
+}
+
+const SpendLimitError: React.FC<SpendLimitErrorProps> = ({ message, budgetPeriod, limitUsd, spentUsd, resetsAt }) => {
+	const displayMessage =
+		limitUsd != null && budgetPeriod ? `$${limitUsd.toFixed(2)} ${budgetPeriod} limit has been reached.` : message
+
+	const [buttonState, setButtonState] = useState<RequestButtonState>(() => {
+		try {
+			const ts = localStorage.getItem(COOLDOWN_KEY)
+			if (ts && Date.now() - Number(ts) < COOLDOWN_MS) return "sent"
+		} catch {
+			// localStorage may not be available in some environments
+		}
+		return "idle"
+	})
+
+	// Reset button to idle once cooldown expires
+	useEffect(() => {
+		if (buttonState !== "sent") return
+		try {
+			const ts = localStorage.getItem(COOLDOWN_KEY)
+			if (!ts) {
+				setButtonState("idle")
+				return
+			}
+			const remaining = COOLDOWN_MS - (Date.now() - Number(ts))
+			if (remaining <= 0) {
+				setButtonState("idle")
+				return
+			}
+			const timer = setTimeout(() => setButtonState("idle"), remaining)
+			return () => clearTimeout(timer)
+		} catch {
+			// Ignore localStorage errors
+		}
+	}, [buttonState])
+
+	const handleRequestIncrease = async () => {
+		setButtonState("sending")
+		try {
+			await AccountServiceClient.submitLimitIncreaseRequest({})
+			localStorage.setItem(COOLDOWN_KEY, String(Date.now()))
+			setButtonState("sent")
+		} catch (error) {
+			console.error("Failed to submit limit increase request:", error)
+			setButtonState("idle")
+		}
+	}
+
+	const periodLabel = budgetPeriod ? budgetPeriod.charAt(0).toUpperCase() + budgetPeriod.slice(1) : ""
+	const resetsAtFormatted = formatResetsAt(resetsAt)
+
+	return (
+		<div className="border-none rounded-md mb-2 bg-(--vscode-textBlockQuote-background)" style={{ padding: "10px 12px" }}>
+			<div className="mb-3">
+				<div className="text-error mb-2" style={{ fontSize: "calc(var(--vscode-font-size) + 2px)" }}>
+					{displayMessage}
+				</div>
+
+				<div className="mb-3">
+					{spentUsd != null && limitUsd != null && (
+						<div className="text-foreground" style={{ fontSize: "var(--vscode-font-size)", lineHeight: 1.3 }}>
+							{periodLabel ? `${periodLabel} usage` : "Usage"}:{" "}
+							<span className="font-bold">
+								${spentUsd.toFixed(2)} / ${limitUsd.toFixed(2)}
+							</span>
+						</div>
+					)}
+
+					{resetsAtFormatted && (
+						<div className="text-foreground" style={{ fontSize: "var(--vscode-font-size)", lineHeight: 1.3 }}>
+							Resets: <span className="font-bold">{resetsAtFormatted}</span>
+						</div>
+					)}
+
+					<div className="text-(--vscode-descriptionForeground) mt-2 text-xs inline-flex items-center">
+						<span className="codicon codicon-organization mr-1" />
+						Limits set by your organization.
+					</div>
+				</div>
+			</div>
+
+			<VSCodeButton
+				appearance="primary"
+				className="w-full"
+				disabled={buttonState !== "idle"}
+				onClick={handleRequestIncrease}>
+				{buttonState === "sending" ? (
+					<>
+						<span className="codicon codicon-loading codicon-modifier-spin mr-1.5" />
+						Sending…
+					</>
+				) : buttonState === "sent" ? (
+					<>
+						<span className="codicon codicon-check mr-1.5" />
+						Request Sent
+					</>
+				) : (
+					<>
+						<span className="codicon codicon-arrow-up mr-1.5" />
+						Request Increase
+					</>
+				)}
+			</VSCodeButton>
+		</div>
+	)
+}
+
+export default SpendLimitError
diff --git a/apps/vscode/webview-ui/src/components/chat/SubagentStatusRow.tsx b/apps/vscode/webview-ui/src/components/chat/SubagentStatusRow.tsx
new file mode 100644
index 0000000..af043ed
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/SubagentStatusRow.tsx
@@ -0,0 +1,285 @@
+import {
+	ClineAskUseSubagents,
+	ClineMessage,
+	ClineSaySubagentStatus,
+	SubagentExecutionStatus,
+	SubagentStatusItem,
+} from "@shared/ExtensionMessage"
+import {
+	BotIcon,
+	CheckIcon,
+	ChevronDownIcon,
+	ChevronRightIcon,
+	CircleSlashIcon,
+	CircleXIcon,
+	LoaderCircleIcon,
+	NetworkIcon,
+} from "lucide-react"
+import { useEffect, useMemo, useRef, useState } from "react"
+import MarkdownBlock from "../common/MarkdownBlock"
+
+interface SubagentStatusRowProps {
+	message: ClineMessage
+	isLast: boolean
+	lastModifiedMessage?: ClineMessage
+}
+
+type DisplayStatus = SubagentExecutionStatus | "cancelled"
+type SubagentRowStatus = "pending" | "running" | "completed" | "failed"
+
+interface SubagentRowData {
+	status: SubagentRowStatus
+	items: SubagentStatusItem[]
+}
+
+interface SubagentPromptTextProps {
+	prompt: string
+	isExpanded: boolean
+	onShowMore: () => void
+}
+
+const statusIcon = (status: DisplayStatus) => {
+	switch (status) {
+		case "running":
+			return <LoaderCircleIcon className="size-2 animate-spin text-link shrink-0 mt-[1px]" />
+		case "completed":
+			return <CheckIcon className="size-2 text-success shrink-0 mt-[1px]" />
+		case "failed":
+			return <CircleXIcon className="size-2 text-error shrink-0 mt-[1px]" />
+		case "cancelled":
+			return <CircleSlashIcon className="size-2 text-foreground shrink-0 mt-[1px]" />
+		default:
+			return <BotIcon className="size-2 text-foreground/70 shrink-0 mt-[1px]" />
+	}
+}
+
+const formatCount = (value: number | undefined): string => {
+	if (!Number.isFinite(value)) {
+		return "0"
+	}
+
+	return Intl.NumberFormat("en-US").format(value || 0)
+}
+
+const formatCost = (value: number | undefined): string => {
+	const normalized = Number.isFinite(value) ? Math.max(0, value || 0) : 0
+	const maximumFractionDigits = normalized >= 0.01 ? 2 : 4
+	return Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD",
+		minimumFractionDigits: 2,
+		maximumFractionDigits,
+	}).format(normalized)
+}
+
+function parseSubagentRowData(message: ClineMessage): SubagentRowData | null {
+	if (!message.text) {
+		return null
+	}
+
+	try {
+		if (message.ask === "use_subagents" || message.say === "use_subagents") {
+			const parsed = JSON.parse(message.text) as ClineAskUseSubagents
+			if (!Array.isArray(parsed.prompts)) {
+				return null
+			}
+			const prompts = parsed.prompts.map((prompt) => prompt?.trim()).filter((prompt): prompt is string => !!prompt)
+			if (prompts.length === 0) {
+				return null
+			}
+
+			return {
+				status: "pending",
+				items: prompts.map((prompt, index) => ({
+					index: index + 1,
+					prompt,
+					status: "pending",
+					toolCalls: 0,
+					inputTokens: 0,
+					outputTokens: 0,
+					totalCost: 0,
+					contextTokens: 0,
+					contextWindow: 0,
+					contextUsagePercentage: 0,
+				})),
+			}
+		}
+
+		const parsed = JSON.parse(message.text) as ClineSaySubagentStatus
+		if (!Array.isArray(parsed.items)) {
+			return null
+		}
+
+		return {
+			status: parsed.status,
+			items: parsed.items,
+		}
+	} catch {
+		return null
+	}
+}
+
+function SubagentPromptText({ prompt, isExpanded, onShowMore }: SubagentPromptTextProps) {
+	const promptRef = useRef<HTMLDivElement | null>(null)
+	const [showMoreVisible, setShowMoreVisible] = useState(false)
+
+	useEffect(() => {
+		if (isExpanded) {
+			setShowMoreVisible(false)
+			return
+		}
+
+		const element = promptRef.current
+		if (!element) {
+			setShowMoreVisible(false)
+			return
+		}
+
+		const checkOverflow = () => {
+			setShowMoreVisible(element.scrollHeight - element.clientHeight > 1)
+		}
+
+		checkOverflow()
+
+		if (typeof ResizeObserver === "undefined") {
+			return
+		}
+
+		const observer = new ResizeObserver(() => checkOverflow())
+		observer.observe(element)
+
+		return () => observer.disconnect()
+	}, [prompt, isExpanded])
+
+	return (
+		<div className="relative">
+			<div
+				className={`text-xs font-medium text-foreground whitespace-pre-wrap break-words ${!isExpanded ? "overflow-hidden [display:-webkit-box] [-webkit-box-orient:vertical] [-webkit-line-clamp:2]" : ""}`}
+				ref={promptRef}>
+				"{prompt}"
+			</div>
+			{!isExpanded && showMoreVisible && (
+				<button
+					aria-label="Show full subagent prompt"
+					className="absolute right-0 bottom-0 z-10 text-[11px] text-link border-0 px-1 py-[1px] cursor-pointer leading-none rounded-[2px]"
+					onClick={onShowMore}
+					style={{ backgroundColor: "var(--vscode-editor-background)" }}
+					type="button">
+					<span
+						aria-hidden="true"
+						className="pointer-events-none absolute inset-y-0 -left-[6px] w-[6px]"
+						style={{ background: "linear-gradient(to left, var(--vscode-editor-background), transparent)" }}
+					/>
+					Show more
+				</button>
+			)}
+		</div>
+	)
+}
+
+export default function SubagentStatusRow({ message, isLast, lastModifiedMessage }: SubagentStatusRowProps) {
+	const [expandedItems, setExpandedItems] = useState<Record<number, boolean>>({})
+	const [expandedPrompts, setExpandedPrompts] = useState<Record<number, boolean>>({})
+	const data = useMemo(() => parseSubagentRowData(message), [message])
+
+	if (!data) {
+		return <div className="text-foreground opacity-80">Subagent status update unavailable.</div>
+	}
+
+	const resumedBeforeNextVisibleMessage =
+		isLast && lastModifiedMessage?.say === "api_req_started" && (lastModifiedMessage.ts ?? 0) > message.ts
+
+	const wasCancelled =
+		data.status === "running" &&
+		(!isLast ||
+			lastModifiedMessage?.ask === "resume_task" ||
+			lastModifiedMessage?.ask === "resume_completed_task" ||
+			resumedBeforeNextVisibleMessage)
+
+	const singular = data.items.length === 1
+	const title = singular ? "Cline wants to use a subagent:" : "Cline wants to use subagents:"
+	const isPromptConstructionRow = message.ask === "use_subagents" || message.say === "use_subagents"
+	const toggleItem = (index: number) => {
+		setExpandedItems((prev) => ({
+			...prev,
+			[index]: !prev[index],
+		}))
+	}
+	const expandPrompt = (index: number) => {
+		setExpandedPrompts((prev) => ({
+			...prev,
+			[index]: true,
+		}))
+	}
+
+	return (
+		<div className="mb-2">
+			<div className="flex items-center gap-2.5 mb-3">
+				<NetworkIcon className="size-2 text-foreground" />
+				<span className="font-bold text-foreground">{title}</span>
+			</div>
+			<div className="space-y-2">
+				{data.items.map((entry, index) => {
+					const displayStatus: DisplayStatus =
+						wasCancelled && (entry.status === "running" || entry.status === "pending") ? "cancelled" : entry.status
+					const hasDetails = Boolean(
+						(entry.result && entry.status === "completed") || (entry.error && entry.status === "failed"),
+					)
+					const isExpanded = expandedItems[entry.index] === true
+					const isStreamingPromptUnderConstruction =
+						isPromptConstructionRow && message.partial === true && index === data.items.length - 1
+					const shouldShowStats = !isStreamingPromptUnderConstruction
+					const statsText = `${formatCount(entry.toolCalls)} tools called · ${formatCount(entry.contextTokens)} tokens · ${formatCost(entry.totalCost)}`
+					const latestToolCallText = entry.latestToolCall?.trim() || ""
+					return (
+						<div
+							className="rounded-xs border border-editor-group-border px-2 py-1.5"
+							key={entry.index}
+							style={{ backgroundColor: "var(--vscode-editor-background)" }}>
+							<div className="flex items-start gap-2">
+								{statusIcon(displayStatus)}
+								<div className="min-w-0 flex-1">
+									<SubagentPromptText
+										isExpanded={expandedPrompts[entry.index] === true}
+										onShowMore={() => expandPrompt(entry.index)}
+										prompt={entry.prompt}
+									/>
+								</div>
+							</div>
+							{shouldShowStats && (
+								<div className="mt-1 text-[11px] opacity-70 min-w-0 whitespace-pre-wrap break-words">
+									<span>{statsText}</span>
+								</div>
+							)}
+							{shouldShowStats && hasDetails && (
+								<button
+									aria-label={isExpanded ? "Hide subagent output" : "Show subagent output"}
+									className="mt-1 text-[11px] opacity-80 flex items-center gap-1 bg-transparent border-0 p-0 cursor-pointer text-left text-foreground w-full"
+									onClick={() => toggleItem(entry.index)}
+									type="button">
+									{isExpanded ? (
+										<ChevronDownIcon className="size-2 shrink-0" />
+									) : (
+										<ChevronRightIcon className="size-2 shrink-0" />
+									)}
+									<span className="shrink-0">{isExpanded ? "Hide output" : "Show output"}</span>
+								</button>
+							)}
+							{shouldShowStats && !hasDetails && latestToolCallText && (
+								<div className="mt-1 text-[10px] opacity-70 min-w-0 truncate font-mono">{latestToolCallText}</div>
+							)}
+							{isExpanded && entry.result && entry.status === "completed" && (
+								<div className="mt-2 text-xs opacity-80 wrap-anywhere overflow-hidden">
+									<MarkdownBlock markdown={entry.result} />
+								</div>
+							)}
+							{isExpanded && entry.error && entry.status === "failed" && (
+								<div className="mt-2 text-xs text-error whitespace-pre-wrap break-words">{entry.error}</div>
+							)}
+						</div>
+					)
+				})}
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/ThinkingRow.test.tsx b/apps/vscode/webview-ui/src/components/chat/ThinkingRow.test.tsx
new file mode 100644
index 0000000..ff7d676
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ThinkingRow.test.tsx
@@ -0,0 +1,40 @@
+import { fireEvent, render, screen } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import { ThinkingRow } from "./ThinkingRow"
+
+describe("ThinkingRow", () => {
+	it("renders streaming title styling and expanded reasoning content", () => {
+		render(
+			<ThinkingRow
+				isExpanded={true}
+				isStreaming={true}
+				isVisible={true}
+				reasoningContent="Inspecting files..."
+				showTitle={true}
+				title="Thinking..."
+			/>,
+		)
+
+		const title = screen.getByText("Thinking...")
+		expect(title).toBeInTheDocument()
+		expect(title).toHaveClass("animate-shimmer")
+		expect(screen.getByText("Inspecting files...")).toBeInTheDocument()
+	})
+
+	it("calls onToggle when header is clicked", () => {
+		const onToggle = vi.fn()
+
+		render(
+			<ThinkingRow
+				isExpanded={false}
+				isVisible={true}
+				onToggle={onToggle}
+				reasoningContent="some reasoning"
+				showTitle={true}
+			/>,
+		)
+
+		fireEvent.click(screen.getByRole("button", { name: /Thinking/i }))
+		expect(onToggle).toHaveBeenCalledTimes(1)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/ThinkingRow.tsx b/apps/vscode/webview-ui/src/components/chat/ThinkingRow.tsx
new file mode 100644
index 0000000..4094d3b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/ThinkingRow.tsx
@@ -0,0 +1,126 @@
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import { memo, useCallback, useEffect, useRef, useState } from "react"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+
+interface ThinkingRowProps {
+	showTitle: boolean
+	reasoningContent?: string
+	isVisible: boolean
+	isExpanded: boolean
+	onToggle?: () => void
+	title?: string
+	isStreaming?: boolean
+	showChevron?: boolean
+}
+
+export const ThinkingRow = memo(
+	({
+		showTitle = false,
+		reasoningContent,
+		isVisible,
+		isExpanded,
+		onToggle,
+		title = "Thinking",
+		isStreaming = false,
+		showChevron = true,
+	}: ThinkingRowProps) => {
+		const scrollRef = useRef<HTMLDivElement>(null)
+		const [canScrollUp, setCanScrollUp] = useState(false)
+		const [canScrollDown, setCanScrollDown] = useState(false)
+
+		const checkScrollable = useCallback(() => {
+			if (scrollRef.current) {
+				const { scrollTop, scrollHeight, clientHeight } = scrollRef.current
+				setCanScrollUp(scrollTop > 1)
+				setCanScrollDown(scrollTop + clientHeight < scrollHeight - 1)
+			}
+		}, [])
+
+		// Only auto-scroll to bottom during streaming (showCursor=true)
+		// For expanded collapsed thinking, start at top
+		useEffect(() => {
+			if (scrollRef.current && isVisible) {
+				scrollRef.current.scrollTop = scrollRef.current.scrollHeight
+			}
+			checkScrollable()
+		}, [reasoningContent, isVisible, checkScrollable])
+
+		if (!isVisible) {
+			return null
+		}
+
+		// Don't render anything if collapsed and no title (nothing to show)
+		if (!isExpanded && !showTitle) {
+			return null
+		}
+
+		return (
+			<div className="ml-1 pl-0 mb-0 -mt-[2px]">
+				{showTitle ? (
+					<Button
+						className={cn(
+							"inline-flex justify-baseline gap-0.5 text-left select-none px-0 py-0 my-0 h-auto min-h-0 w-full text-description overflow-visible",
+							{
+								"cursor-pointer": !!onToggle,
+								"cursor-default": !onToggle,
+							},
+						)}
+						onClick={onToggle}
+						size="icon"
+						variant="icon">
+						<span
+							className={cn("text-[13px] leading-[1.2]", {
+								"animate-shimmer bg-linear-90 from-foreground to-description bg-[length:200%_100%] bg-clip-text text-transparent":
+									isStreaming,
+								"select-none": isStreaming,
+							})}>
+							{title}
+						</span>
+						{showChevron &&
+							(isExpanded ? (
+								<ChevronDownIcon className="!size-1 text-description" />
+							) : (
+								<ChevronRightIcon className="!size-1 text-description" />
+							))}
+					</Button>
+				) : null}
+
+				{isExpanded && (
+					<Button
+						className={cn(
+							"flex gap-0 overflow-hidden w-full min-w-0 max-h-0 opacity-0 items-baseline justify-baseline text-left !p-0 !pl-0",
+							"disabled:cursor-text disabled:opacity-100",
+							{
+								"max-h-[200px] opacity-100": isVisible,
+								"transition-[max-height] duration-[250ms] ease-[cubic-bezier(0.4,0,0.2,1)] [transition:max-height_250ms_cubic-bezier(0.4,0,0.2,1),opacity_150ms_ease-out]":
+									isVisible,
+							},
+						)}
+						disabled={!showTitle}
+						onClick={onToggle}
+						variant="text">
+						<div className="relative flex-1">
+							<div
+								className={cn(
+									"flex max-h-[150px] overflow-y-auto text-description leading-normal truncated whitespace-pre-wrap break-words pl-0 [scrollbar-width:none] [-ms-overflow-style:none] [&::-webkit-scrollbar]:hidden [direction:ltr]",
+								)}
+								onScroll={checkScrollable}
+								ref={scrollRef}>
+								<span className="pb-2 block text-sm">{reasoningContent}</span>
+							</div>
+							{canScrollUp && (
+								<div className="absolute top-0 left-0 right-0 h-6 pointer-events-none bg-gradient-to-b from-background to-transparent" />
+							)}
+							{canScrollDown && (
+								<div className="absolute bottom-0 left-0 right-0 h-6 pointer-events-none bg-gradient-to-t from-background to-transparent" />
+							)}
+						</div>
+					</Button>
+				)}
+			</div>
+		)
+	},
+)
+
+ThinkingRow.displayName = "ThinkingRow"
diff --git a/apps/vscode/webview-ui/src/components/chat/TypewriterText.stories.tsx b/apps/vscode/webview-ui/src/components/chat/TypewriterText.stories.tsx
new file mode 100644
index 0000000..bd8a701
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/TypewriterText.stories.tsx
@@ -0,0 +1,83 @@
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import { TypewriterText } from "./TypewriterText"
+
+const meta: Meta<typeof TypewriterText> = {
+	title: "Views/Components/TypewriterText",
+	component: TypewriterText,
+	parameters: {
+		layout: "centered",
+		docs: {
+			description: {
+				component: `
+The TypewriterText component provides a typewriter animation effect that displays text character by character.
+
+**Key Features:**
+- **Streaming Animation**: Characters appear one at a time with configurable speed
+- **Shimmer Effect**: After typing completes, text shows a subtle shimmer animation
+- **Performance Optimized**: Uses React.memo to prevent unnecessary re-renders
+- **Configurable Speed**: Control typing speed via the speed prop (milliseconds per character)
+
+**Use Cases:**
+- AI response streaming visualization
+- Loading states with dynamic text
+- Enhanced user engagement during content generation
+- Visual feedback for progressive content delivery
+
+**Props:**
+- \`text\`: The complete text to display with typewriter effect
+- \`speed\`: Typing speed in milliseconds per character (default: 30ms)
+
+**Try It Out:**
+Use the controls below to test different text content and typing speeds interactively. The component will restart the animation whenever you change the text or speed.
+				`,
+			},
+		},
+	},
+	argTypes: {
+		text: {
+			control: "text",
+			description: "The text to display with typewriter effect",
+			table: {
+				type: { summary: "string" },
+			},
+		},
+		speed: {
+			control: { type: "range", min: 10, max: 200, step: 10 },
+			description: "Speed in milliseconds per character (lower = faster)",
+			table: {
+				type: { summary: "number" },
+				defaultValue: { summary: "30" },
+			},
+		},
+	},
+	decorators: [
+		(Story) => (
+			<div className="w-full max-w-2xl p-6 bg-[var(--vscode-editor-background)] text-[var(--vscode-editor-foreground)]">
+				<Story />
+			</div>
+		),
+	],
+}
+
+export default meta
+type Story = StoryObj<typeof TypewriterText>
+
+export const Default: Story = {
+	args: {
+		text: "I'll help you create a responsive navigation component for your React application. Let me start by examining your current project structure and then create a modern, accessible navigation component with mobile-first design, keyboard navigation support, smooth animations, and dark/light theme support.",
+		speed: 30,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: `Interactive demo of the TypewriterText component. Use the controls panel below to:
+
+- **Change the text**: Type any text to see the typewriter effect
+- **Adjust speed**: Use the slider to control typing speed (10ms = fast, 200ms = slow)
+- **Test different scenarios**: Try short messages, long paragraphs, code snippets, emojis, or special characters
+
+The component automatically restarts the animation when you change either the text or speed. After typing completes, you'll see a subtle shimmer effect on the text.`,
+			},
+		},
+	},
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/TypewriterText.tsx b/apps/vscode/webview-ui/src/components/chat/TypewriterText.tsx
new file mode 100644
index 0000000..0188120
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/TypewriterText.tsx
@@ -0,0 +1,37 @@
+import { memo, useEffect, useState } from "react"
+
+// TypewriterText with shimmer effect after typing completes
+export const TypewriterText = memo(({ text, speed = 30 }: { text: string; speed?: number }) => {
+	const [displayedLength, setDisplayedLength] = useState(0)
+	const [isComplete, setIsComplete] = useState(false)
+
+	useEffect(() => {
+		setDisplayedLength(0)
+		setIsComplete(false)
+		const interval = setInterval(() => {
+			setDisplayedLength((prev) => {
+				if (prev >= text.length) {
+					clearInterval(interval)
+					setIsComplete(true)
+					return prev
+				}
+				return prev + 1
+			})
+		}, speed)
+
+		return () => clearInterval(interval)
+	}, [text, speed])
+
+	// After typing completes, show shimmer effect instead of blinking cursor
+	if (isComplete) {
+		return (
+			<span className="animate-shimmer bg-linear-90 from-foreground to-description bg-[length:200%_100%] bg-clip-text text-transparent truncate">
+				{text}
+			</span>
+		)
+	}
+
+	return <span className="truncate">{text.slice(0, displayedLength)}</span>
+})
+
+TypewriterText.displayName = "TypewriterText"
diff --git a/apps/vscode/webview-ui/src/components/chat/UserMessage.tsx b/apps/vscode/webview-ui/src/components/chat/UserMessage.tsx
new file mode 100644
index 0000000..fb146e7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/UserMessage.tsx
@@ -0,0 +1,178 @@
+import { EditMessageAndRegenerateRequest } from "@shared/proto/cline/task"
+import type React from "react"
+import { useMemo, useState } from "react"
+import Thumbnails from "@/components/common/Thumbnails"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { TaskServiceClient } from "@/services/grpc-client"
+import { highlightText } from "./task-header/Highlights"
+
+interface UserMessageProps {
+	text?: string
+	files?: string[]
+	images?: string[]
+	messageTs?: number
+	sendMessageFromChatRow?: (text: string, images: string[], files: string[]) => void
+	canRestoreWorkspace?: boolean
+}
+
+const UserMessage: React.FC<UserMessageProps> = ({ text, images, files, messageTs, canRestoreWorkspace = true }) => {
+	const [isEditing, setIsEditing] = useState(false)
+	const [editedText, setEditedText] = useState(text ?? "")
+	const [savingMode, setSavingMode] = useState<"chat" | "workspace" | undefined>()
+	const [errorMessage, setErrorMessage] = useState<string | undefined>()
+	const highlightedText = useMemo(() => highlightText(text), [text])
+
+	const startEditing = () => {
+		setEditedText(text ?? "")
+		setErrorMessage(undefined)
+		setIsEditing(true)
+	}
+
+	const cancelEditing = () => {
+		if (savingMode) {
+			return
+		}
+		setIsEditing(false)
+	}
+
+	const handleEditingKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
+		if (event.key !== "Escape") {
+			return
+		}
+
+		event.preventDefault()
+		event.stopPropagation()
+		cancelEditing()
+	}
+
+	const handleSave = async (restoreWorkspace: boolean) => {
+		if (!messageTs || savingMode) {
+			return
+		}
+		setSavingMode(restoreWorkspace ? "workspace" : "chat")
+		setErrorMessage(undefined)
+		try {
+			await TaskServiceClient.editMessageAndRegenerate(
+				EditMessageAndRegenerateRequest.create({
+					messageTs,
+					text: editedText,
+					images: images ?? [],
+					files: files ?? [],
+					restoreWorkspace,
+				}),
+			)
+			setIsEditing(false)
+			setSavingMode(undefined)
+		} catch (error) {
+			console.error("Failed to edit and regenerate message:", error)
+			setErrorMessage(error instanceof Error ? error.message : "Failed to edit and regenerate message")
+			setSavingMode(undefined)
+		}
+	}
+
+	return (
+		<div
+			className={`group relative p-2.5 my-1 text-badge-foreground rounded-xs ${
+				messageTs && !isEditing ? "cursor-pointer pr-8" : ""
+			}`}
+			onClick={messageTs && !isEditing ? startEditing : undefined}
+			onKeyDown={
+				messageTs && !isEditing
+					? (event) => {
+							if (event.key === "Enter" || event.key === " ") {
+								event.preventDefault()
+								startEditing()
+							}
+						}
+					: undefined
+			}
+			role={messageTs && !isEditing ? "button" : undefined}
+			style={{
+				backgroundColor: "var(--vscode-badge-background)",
+				whiteSpace: "pre-line",
+				wordWrap: "break-word",
+			}}
+			tabIndex={messageTs && !isEditing ? 0 : undefined}
+			title={messageTs && !isEditing ? "Edit and regenerate from here" : undefined}>
+			{messageTs && !isEditing && (
+				<Tooltip>
+					<TooltipContent side="left">Edit and regenerate from here</TooltipContent>
+					<TooltipTrigger asChild>
+						<button
+							aria-label="Edit and regenerate from this message"
+							className="absolute right-1.5 top-1.5 opacity-0 group-hover:opacity-80 hover:opacity-100 bg-transparent border-0 text-badge-foreground cursor-pointer p-1"
+							onClick={(event) => {
+								event.stopPropagation()
+								startEditing()
+							}}
+							type="button">
+							<i className="codicon codicon-edit" />
+						</button>
+					</TooltipTrigger>
+				</Tooltip>
+			)}
+			{isEditing ? (
+				<div className="flex flex-col gap-2" onKeyDown={handleEditingKeyDown}>
+					<textarea
+						className="w-full box-border rounded-xs border border-vscode-input-border bg-vscode-input-background text-vscode-input-foreground p-2 text-sm resize-vertical"
+						disabled={!!savingMode}
+						onChange={(event) => setEditedText(event.target.value)}
+						rows={Math.max(3, editedText.split("\n").length)}
+						value={editedText}
+					/>
+					{errorMessage && <div className="text-xs text-(--vscode-errorForeground)">{errorMessage}</div>}
+					<div className="flex items-center justify-between gap-1.5">
+						<button
+							className="shrink-0 whitespace-nowrap px-1 py-1 rounded-xs border-0 bg-transparent text-badge-foreground/80 hover:text-badge-foreground cursor-pointer text-xs"
+							disabled={!!savingMode}
+							onClick={cancelEditing}
+							type="button">
+							Cancel
+						</button>
+						<div className="flex items-center gap-1.5">
+							<Tooltip>
+								<TooltipContent side="top">Rewind conversation, keep current code edits</TooltipContent>
+								<TooltipTrigger asChild>
+									<span className="inline-flex shrink-0">
+										<button
+											className="whitespace-nowrap px-2 py-1 rounded-xs border border-vscode-button-border bg-transparent text-badge-foreground cursor-pointer disabled:opacity-60 text-xs"
+											disabled={!!savingMode}
+											onClick={() => handleSave(false)}
+											type="button">
+											{savingMode === "chat" ? "Running..." : "Reset Chat"}
+										</button>
+									</span>
+								</TooltipTrigger>
+							</Tooltip>
+							{canRestoreWorkspace && (
+								<Tooltip>
+									<TooltipContent side="top">Rewind conversation, reset code edits</TooltipContent>
+									<TooltipTrigger asChild>
+										<span className="inline-flex shrink-0">
+											<button
+												className="whitespace-nowrap px-2 py-1 rounded-xs border border-vscode-button-border bg-transparent text-badge-foreground cursor-pointer disabled:opacity-60 text-xs"
+												disabled={!!savingMode}
+												onClick={() => handleSave(true)}
+												type="button">
+												{savingMode === "workspace" ? "Restoring..." : "Reset Code"}
+											</button>
+										</span>
+									</TooltipTrigger>
+								</Tooltip>
+							)}
+						</div>
+					</div>
+				</div>
+			) : (
+				<span className="ph-no-capture text-sm" style={{ display: "block" }}>
+					{highlightedText}
+				</span>
+			)}
+			{!isEditing && ((images && images.length > 0) || (files && files.length > 0)) && (
+				<Thumbnails files={files ?? []} images={images ?? []} style={{ marginTop: "8px" }} />
+			)}
+		</div>
+	)
+}
+
+export default UserMessage
diff --git a/apps/vscode/webview-ui/src/components/chat/__tests__/ErrorBlockTitle.spec.tsx b/apps/vscode/webview-ui/src/components/chat/__tests__/ErrorBlockTitle.spec.tsx
new file mode 100644
index 0000000..688309d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/__tests__/ErrorBlockTitle.spec.tsx
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest"
+import { ErrorBlockTitle } from "../ErrorBlockTitle"
+
+describe("ErrorBlockTitle", () => {
+	it("should return icon and title for API request cancelled", () => {
+		const [icon, title] = ErrorBlockTitle({
+			apiReqCancelReason: "user_cancelled",
+		})
+
+		expect(icon).toBeDefined()
+		expect(title).toBeDefined()
+	})
+
+	it("should return icon and title for completed API request", () => {
+		const [icon, title] = ErrorBlockTitle({
+			cost: 0.001,
+		})
+
+		expect(icon).toBeDefined()
+		expect(title).toBeDefined()
+	})
+
+	it("should return icon and title for failed API request", () => {
+		const [icon, title] = ErrorBlockTitle({
+			apiRequestFailedMessage: "Request failed",
+		})
+
+		expect(icon).toBeDefined()
+		expect(title).toBeDefined()
+	})
+
+	it("should return icon and title for retry status", () => {
+		const [icon, title] = ErrorBlockTitle({
+			retryStatus: {
+				attempt: 2,
+				maxAttempts: 3,
+				delaySec: 5,
+			},
+		})
+
+		expect(icon).toBeDefined()
+		expect(title).toBeDefined()
+	})
+
+	it("should return icon and title for default API request", () => {
+		const [icon, title] = ErrorBlockTitle({})
+
+		expect(icon).toBeDefined()
+		expect(title).toBeDefined()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/__tests__/UserMessage.ime.test.tsx b/apps/vscode/webview-ui/src/components/chat/__tests__/UserMessage.ime.test.tsx
new file mode 100644
index 0000000..3543e66
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/__tests__/UserMessage.ime.test.tsx
@@ -0,0 +1,121 @@
+/**
+ * UserMessage – IME composition Enter test
+ * --------------------------------------------------
+ * Confirm that sendMessageFromChatRow is not called
+ * even if you confirm the IME conversion (Enter) in message re-edit mode.
+ */
+
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import userEvent from "@testing-library/user-event"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	__esModule: true,
+	useExtensionState: () => ({
+		state: {},
+		dispatch: vi.fn(),
+	}),
+}))
+
+vi.mock("@/services/grpc-client", () => ({
+	TaskServiceClient: {
+		editMessageAndRegenerate: vi.fn(),
+	},
+}))
+
+import { TaskServiceClient } from "@/services/grpc-client"
+import UserMessage from "../UserMessage"
+
+describe("UserMessage – IME composition handling", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		vi.stubGlobal(
+			"ResizeObserver",
+			class ResizeObserver {
+				observe() {}
+				unobserve() {}
+				disconnect() {}
+			},
+		)
+		vi.mocked(TaskServiceClient.editMessageAndRegenerate).mockResolvedValue({})
+	})
+
+	it("does NOT send when IME composition Enter is pressed while editing", () => {
+		const sendMessageFromChatRow = vi.fn()
+
+		const { getByText } = render(
+			<UserMessage images={[]} messageTs={Date.now()} sendMessageFromChatRow={sendMessageFromChatRow} text="変換テスト" />,
+		)
+
+		const editable = getByText("変換テスト") as HTMLElement
+		editable.setAttribute("contenteditable", "true")
+		editable.focus()
+
+		fireEvent.compositionStart(editable)
+		fireEvent.keyDown(editable, {
+			key: "Enter",
+			keyCode: 13,
+			nativeEvent: { isComposing: true },
+		})
+		fireEvent.compositionEnd(editable)
+
+		expect(sendMessageFromChatRow).not.toHaveBeenCalled()
+	})
+
+	it("cancels inline editing on Escape without bubbling to global task shortcuts", () => {
+		const onWindowKeyDown = vi.fn()
+		window.addEventListener("keydown", onWindowKeyDown)
+
+		try {
+			render(<UserMessage images={[]} messageTs={Date.now()} text="Original prompt" />)
+
+			fireEvent.click(screen.getByText("Original prompt"))
+
+			const textbox = screen.getByRole("textbox")
+			fireEvent.change(textbox, { target: { value: "Edited prompt" } })
+
+			fireEvent.keyDown(textbox, { key: "Escape" })
+
+			expect(screen.queryByRole("textbox")).not.toBeInTheDocument()
+			expect(screen.getByText("Original prompt")).toBeInTheDocument()
+			expect(onWindowKeyDown).not.toHaveBeenCalled()
+		} finally {
+			window.removeEventListener("keydown", onWindowKeyDown)
+		}
+	})
+
+	it("labels reset actions and preserves their restore behavior", async () => {
+		const user = userEvent.setup()
+		render(<UserMessage files={["src/app.ts"]} images={["image.png"]} messageTs={123} text="Update this" />)
+
+		await user.click(screen.getByText("Update this"))
+
+		expect(screen.getByRole("button", { name: "Reset Chat" })).toBeInTheDocument()
+		expect(screen.getByRole("button", { name: "Reset Code" })).toBeInTheDocument()
+
+		await user.click(screen.getByRole("button", { name: "Reset Chat" }))
+		await waitFor(() => expect(TaskServiceClient.editMessageAndRegenerate).toHaveBeenCalledTimes(1))
+		expect(TaskServiceClient.editMessageAndRegenerate).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				messageTs: 123,
+				text: "Update this",
+				images: ["image.png"],
+				files: ["src/app.ts"],
+				restoreWorkspace: false,
+			}),
+		)
+
+		await user.click(screen.getByText("Update this"))
+		await user.click(screen.getByRole("button", { name: "Reset Code" }))
+		await waitFor(() => expect(TaskServiceClient.editMessageAndRegenerate).toHaveBeenCalledTimes(2))
+		expect(TaskServiceClient.editMessageAndRegenerate).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				messageTs: 123,
+				text: "Update this",
+				images: ["image.png"],
+				files: ["src/app.ts"],
+				restoreWorkspace: true,
+			}),
+		)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveBar.tsx b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveBar.tsx
new file mode 100644
index 0000000..917d275
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveBar.tsx
@@ -0,0 +1,178 @@
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import { useRef, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { getAsVar, VSC_TITLEBAR_INACTIVE_FOREGROUND } from "@/utils/vscStyles"
+import AutoApproveModal from "./AutoApproveModal"
+import { ACTION_METADATA } from "./constants"
+
+interface AutoApproveBarProps {
+	style?: React.CSSProperties
+}
+
+const AutoApproveBar = ({ style }: AutoApproveBarProps) => {
+	const { autoApprovalSettings, yoloModeToggled, navigateToSettings } = useExtensionState()
+
+	const [isModalVisible, setIsModalVisible] = useState(false)
+	const buttonRef = useRef<HTMLDivElement>(null)
+
+	const handleNavigateToFeatures = (e: React.MouseEvent) => {
+		e.preventDefault()
+		e.stopPropagation()
+		navigateToSettings("features")
+	}
+
+	const getEnabledActionsText = () => {
+		const baseClasses = isModalVisible
+			? "text-foreground truncate"
+			: "text-muted-foreground group-hover:text-foreground truncate"
+		const enabledActionsNames = Object.keys(autoApprovalSettings.actions).filter(
+			(key) => autoApprovalSettings.actions[key as keyof typeof autoApprovalSettings.actions],
+		)
+		const enabledActions = enabledActionsNames.map((action) => {
+			return ACTION_METADATA.flatMap((a) => [a, a.subAction]).find((a) => a?.id === action)
+		})
+
+		// Filter out parent actions if their subaction is also enabled (show only subaction)
+		const actionsToShow = enabledActions.filter((action) => {
+			if (!action?.shortName) {
+				return false
+			}
+
+			// If this is a parent action and its subaction is enabled, skip it
+			if (action.subAction?.id && enabledActionsNames.includes(action.subAction.id)) {
+				return false
+			}
+
+			return true
+		})
+
+		if (actionsToShow.length === 0) {
+			return <span className={baseClasses}>None</span>
+		}
+
+		return (
+			<span className={baseClasses}>
+				{actionsToShow.map((action, index) => (
+					<span key={action?.id}>
+						{action?.shortName}
+						{index < actionsToShow.length - 1 && ", "}
+					</span>
+				))}
+			</span>
+		)
+	}
+
+	const borderColor = `color-mix(in srgb, ${getAsVar(VSC_TITLEBAR_INACTIVE_FOREGROUND)} 20%, transparent)`
+	const borderGradient = `linear-gradient(to bottom, ${borderColor} 0%, transparent 50%)`
+	const bgGradient = `linear-gradient(to bottom, color-mix(in srgb, var(--vscode-sideBar-background) 96%, white) 0%, transparent 80%)`
+
+	// If YOLO mode is enabled, show disabled message
+	if (yoloModeToggled) {
+		return (
+			<div
+				className="mx-3.5 select-none break-words relative"
+				style={{
+					borderTop: `0.5px solid ${borderColor}`,
+					borderRadius: "4px 4px 0 0",
+					background: bgGradient,
+					opacity: 0.5,
+					...style,
+				}}>
+				{/* Left border gradient */}
+				<div
+					className="absolute left-0 pointer-events-none"
+					style={{
+						width: 0.5,
+						top: 3,
+						height: "100%",
+						background: borderGradient,
+					}}
+				/>
+				{/* Right border gradient */}
+				<div
+					className="absolute right-0 top-0 pointer-events-none"
+					style={{
+						width: 0.5,
+						top: 3,
+						height: "100%",
+						background: borderGradient,
+					}}
+				/>
+
+				<div className="pt-4 pb-3.5 px-3.5">
+					<div className="text-sm mb-1">Auto-approve: YOLO</div>
+					<div className="text-muted-foreground text-xs">
+						YOLO mode is enabled.{" "}
+						<span className="underline cursor-pointer hover:text-foreground" onClick={handleNavigateToFeatures}>
+							Disable it in Settings
+						</span>
+						.
+					</div>
+				</div>
+			</div>
+		)
+	}
+
+	return (
+		<div
+			className="mx-3.5 select-none break-words relative"
+			style={{
+				borderTop: `0.5px solid ${borderColor}`,
+				borderRadius: "4px 4px 0 0",
+				background: bgGradient,
+				...style,
+			}}>
+			{/* Left border gradient */}
+			<div
+				className="absolute left-0 pointer-events-none"
+				style={{
+					width: 0.5,
+					top: 3,
+					height: "100%",
+					background: borderGradient,
+				}}
+			/>
+			{/* Right border gradient */}
+			<div
+				className="absolute right-0 top-0 pointer-events-none"
+				style={{
+					width: 0.5,
+					top: 3,
+					height: "100%",
+					background: borderGradient,
+				}}
+			/>
+
+			<div
+				aria-label={isModalVisible ? "Close auto-approve settings" : "Open auto-approve settings"}
+				className="group cursor-pointer pt-3 pb-3.5 pr-2 px-3.5 flex items-center justify-between gap-0"
+				onClick={() => {
+					setIsModalVisible((prev) => !prev)
+				}}
+				onKeyDown={(e) => {
+					if (e.key === "Enter" || e.key === " ") {
+						e.preventDefault()
+						e.stopPropagation()
+						setIsModalVisible((prev) => !prev)
+					}
+				}}
+				ref={buttonRef}
+				tabIndex={0}>
+				<div className="flex flex-nowrap items-center gap-1 min-w-0 flex-1">
+					<span className="whitespace-nowrap">Auto-approve:</span>
+					{getEnabledActionsText()}
+				</div>
+				{isModalVisible ? <ChevronDownIcon size={16} /> : <ChevronRightIcon size={16} />}
+			</div>
+
+			<AutoApproveModal
+				ACTION_METADATA={ACTION_METADATA}
+				buttonRef={buttonRef}
+				isVisible={isModalVisible}
+				setIsVisible={setIsModalVisible}
+			/>
+		</div>
+	)
+}
+
+export default AutoApproveBar
diff --git a/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveMenuItem.tsx b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveMenuItem.tsx
new file mode 100644
index 0000000..9ed1766
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveMenuItem.tsx
@@ -0,0 +1,63 @@
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import styled from "styled-components"
+import { ActionMetadata } from "./types"
+
+interface AutoApproveMenuItemProps {
+	action: ActionMetadata
+	isChecked: (action: ActionMetadata) => boolean
+	onToggle: (action: ActionMetadata, checked: boolean) => Promise<void>
+	showIcon?: boolean
+	disabled?: boolean
+}
+
+const SubOptionAnimateIn = styled.div<{ show: boolean; inert?: string }>`
+  position: relative;
+  transform: ${(props) => (props.show ? "scaleY(1)" : "scaleY(0)")};
+  transform-origin: top;
+  padding-left: 24px;
+  opacity: ${(props) => (props.show ? "1" : "0")};
+  height: ${(props) => (props.show ? "auto" : "0")}; /* Manage height for layout */
+  overflow: visible; /* Allow tooltips to escape */
+  transition: transform 0.2s ease-in-out;
+`
+
+const CheckboxWrapper = styled.div<{ $disabled: boolean }>`
+  padding: 2px 0.125rem;
+  margin: 0;
+  width: 100%;
+  cursor: ${(props) => (props.$disabled ? "not-allowed" : "pointer")};
+`
+
+const AutoApproveMenuItem = ({ action, isChecked, onToggle, showIcon = true, disabled = false }: AutoApproveMenuItemProps) => {
+	const checked = isChecked(action)
+
+	const onChange = async (e: React.MouseEvent) => {
+		if (disabled) {
+			return
+		}
+		e.stopPropagation()
+		await onToggle(action, !checked)
+	}
+
+	const content = (
+		<div className="w-full" style={{ opacity: disabled ? 0.5 : 1 }}>
+			<CheckboxWrapper $disabled={disabled} className="w-full" onClick={onChange}>
+				<VSCodeCheckbox checked={checked} disabled={disabled}>
+					<div className="w-full flex text-sm items-center justify-start text-foreground gap-2">
+						{showIcon && <span className={`codicon ${action.icon} icon`}></span>}
+						<span className="label">{action.label}</span>
+					</div>
+				</VSCodeCheckbox>
+			</CheckboxWrapper>
+			{action.subAction && (
+				<SubOptionAnimateIn inert={!checked ? "" : undefined} show={checked}>
+					<AutoApproveMenuItem action={action.subAction} isChecked={isChecked} onToggle={onToggle} />
+				</SubOptionAnimateIn>
+			)}
+		</div>
+	)
+
+	return content
+}
+
+export default AutoApproveMenuItem
diff --git a/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveModal.tsx b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveModal.tsx
new file mode 100644
index 0000000..322e917
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveModal.tsx
@@ -0,0 +1,110 @@
+import React, { useEffect, useRef, useState } from "react"
+import { useClickAway } from "react-use"
+import { useAutoApproveActions } from "@/hooks/useAutoApproveActions"
+import { getAsVar, VSC_TITLEBAR_INACTIVE_FOREGROUND } from "@/utils/vscStyles"
+import AutoApproveMenuItem from "./AutoApproveMenuItem"
+import { ActionMetadata } from "./types"
+
+const breakpoint = 500
+
+interface AutoApproveModalProps {
+	isVisible: boolean
+	setIsVisible: (visible: boolean) => void
+	buttonRef: React.RefObject<HTMLDivElement>
+	ACTION_METADATA: ActionMetadata[]
+}
+
+const AutoApproveModal: React.FC<AutoApproveModalProps> = ({ isVisible, setIsVisible, buttonRef, ACTION_METADATA }) => {
+	const { isChecked, updateAction } = useAutoApproveActions()
+	const modalRef = useRef<HTMLDivElement>(null)
+	const itemsContainerRef = useRef<HTMLDivElement>(null)
+	const [containerWidth, setContainerWidth] = useState(0)
+
+	useClickAway(modalRef, (e) => {
+		// Skip if click was on the button that toggles the modal
+		if (buttonRef.current && buttonRef.current.contains(e.target as Node)) {
+			return
+		}
+		setIsVisible(false)
+	})
+
+	// Track container width for responsive layout
+	useEffect(() => {
+		if (!isVisible) {
+			return
+		}
+
+		const updateWidth = () => {
+			if (itemsContainerRef.current) {
+				setContainerWidth(itemsContainerRef.current.offsetWidth)
+			}
+		}
+
+		// Initial measurement
+		updateWidth()
+
+		// Set up resize observer
+		const resizeObserver = new ResizeObserver(updateWidth)
+		if (itemsContainerRef.current) {
+			resizeObserver.observe(itemsContainerRef.current)
+		}
+
+		// Clean up
+		return () => {
+			resizeObserver.disconnect()
+		}
+	}, [isVisible])
+
+	if (!isVisible) {
+		return null
+	}
+
+	return (
+		<div ref={modalRef}>
+			{/* Expanded menu content - renders directly below the bar */}
+			<div
+				className="overflow-y-auto pb-3 px-3.5 overscroll-contain"
+				style={{
+					maxHeight: "60vh",
+				}}>
+				<div className="mb-2.5 text-muted-foreground text-xs cursor-pointer" onClick={() => setIsVisible(false)}>
+					Let Cline take these actions without asking for approval.{" "}
+					<a
+						className="text-link hover:text-link-hover"
+						href="https://docs.cline.bot/features/auto-approve#auto-approve"
+						rel="noopener"
+						style={{ fontSize: "inherit" }}
+						target="_blank">
+						Docs
+					</a>
+				</div>
+
+				<div
+					className="relative mb-2 w-full"
+					ref={itemsContainerRef}
+					style={{
+						columnCount: containerWidth > breakpoint ? 2 : 1,
+						columnGap: "4px",
+					}}>
+					{/* Vertical separator line - only visible in two-column mode */}
+					{containerWidth > breakpoint && (
+						<div
+							className="absolute left-1/2 top-0 bottom-0 opacity-20"
+							style={{
+								background: getAsVar(VSC_TITLEBAR_INACTIVE_FOREGROUND),
+								transform: "translateX(-50%)", // Center the line
+							}}
+						/>
+					)}
+
+					{/* All items in a single list - CSS Grid will handle the column distribution */}
+					{ACTION_METADATA.map((action) => (
+						<AutoApproveMenuItem action={action} isChecked={isChecked} key={action.id} onToggle={updateAction} />
+					))}
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default AutoApproveModal
diff --git a/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveSettingsAPI.ts b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveSettingsAPI.ts
new file mode 100644
index 0000000..19a7e4c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/AutoApproveSettingsAPI.ts
@@ -0,0 +1,16 @@
+import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
+import { StateServiceClient } from "@/services/grpc-client"
+
+/**
+ * Updates auto approval settings using the gRPC/Protobus client
+ * @param settings The auto approval settings to update
+ * @throws Error if the update fails
+ */
+export async function updateAutoApproveSettings(settings: AutoApprovalSettings) {
+	try {
+		await StateServiceClient.updateAutoApprovalSettings({ metadata: {}, ...settings })
+	} catch (error) {
+		console.error("Failed to update auto approval settings:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/constants.ts b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/constants.ts
new file mode 100644
index 0000000..2d2e627
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/constants.ts
@@ -0,0 +1,34 @@
+import { ActionMetadata } from "./types"
+
+export const ACTION_METADATA: ActionMetadata[] = [
+	{
+		id: "readFiles",
+		label: "Read files",
+		shortName: "Read",
+		icon: "codicon-search",
+	},
+	{
+		id: "editFiles",
+		label: "Edit files",
+		shortName: "Edit",
+		icon: "codicon-edit",
+	},
+	{
+		id: "executeSafeCommands",
+		label: "Execute commands",
+		shortName: "Commands",
+		icon: "codicon-terminal",
+	},
+	{
+		id: "useBrowser",
+		label: "Fetch web content",
+		shortName: "Web Fetch",
+		icon: "codicon-globe",
+	},
+	{
+		id: "useMcp",
+		label: "Use MCP servers",
+		shortName: "MCP",
+		icon: "codicon-server",
+	},
+]
diff --git a/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/types.ts b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/types.ts
new file mode 100644
index 0000000..465aed9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/auto-approve-menu/types.ts
@@ -0,0 +1,11 @@
+import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
+
+export interface ActionMetadata {
+	id: keyof AutoApprovalSettings["actions"] | "enableNotifications"
+	label: string
+	shortName: string
+	icon: string
+	subAction?: ActionMetadata
+	sub?: boolean
+	parentActionId?: string
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ActionButtons.test.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ActionButtons.test.tsx
new file mode 100644
index 0000000..1e29423
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ActionButtons.test.tsx
@@ -0,0 +1,107 @@
+import type { ClineMessage, TurnState } from "@shared/ExtensionMessage"
+import { fireEvent, render, screen } from "@testing-library/react"
+import type { ReactNode } from "react"
+import { describe, expect, it, vi } from "vitest"
+import type { ChatState, MessageHandlers } from "../../types/chatTypes"
+import { ActionButtons } from "./ActionButtons"
+
+// Render VSCodeButton as a native button so `disabled` is observable in the DOM.
+vi.mock("@vscode/webview-ui-toolkit/react", () => ({
+	VSCodeButton: ({ children, disabled, onClick }: { children?: ReactNode; disabled?: boolean; onClick?: () => void }) => (
+		<button disabled={disabled} onClick={onClick} type="button">
+			{children}
+		</button>
+	),
+}))
+
+const mockTurnState = vi.fn<() => TurnState | undefined>(() => undefined)
+vi.mock("../../../../../context/ExtensionStateContext", () => ({
+	useExtensionState: () => ({ turnState: mockTurnState() }),
+}))
+
+function fileApprovalAsk(ts: number, path: string): ClineMessage {
+	return {
+		ts,
+		type: "ask",
+		ask: "tool",
+		text: JSON.stringify({ tool: "newFileCreated", path }),
+		partial: false,
+	}
+}
+
+function makeChatState(): ChatState {
+	return {
+		inputValue: "",
+		selectedImages: [],
+		selectedFiles: [],
+		setInputValue: vi.fn(),
+		setSelectedImages: vi.fn(),
+		setSelectedFiles: vi.fn(),
+		setSendingDisabled: vi.fn(),
+	} as unknown as ChatState
+}
+
+describe("ActionButtons", () => {
+	it("does not render a scroll button when there are no action buttons", () => {
+		mockTurnState.mockReturnValue(undefined)
+		const task: ClineMessage = {
+			ts: 1,
+			type: "ask",
+			ask: "followup",
+			text: "Anything else?",
+			partial: false,
+		}
+
+		render(
+			<ActionButtons
+				chatState={makeChatState()}
+				messageHandlers={{ executeButtonAction: vi.fn() } as unknown as MessageHandlers}
+				messages={[task]}
+				mode="act"
+				task={task}
+			/>,
+		)
+
+		expect(screen.queryByRole("button")).not.toBeInTheDocument()
+		expect(screen.queryByLabelText("Scroll to bottom")).not.toBeInTheDocument()
+		expect(screen.queryByLabelText("Scroll to top")).not.toBeInTheDocument()
+	})
+
+	it("re-enables the buttons when a second identical approval ask arrives", async () => {
+		// Regression: the button configs are shared singletons, so two consecutive
+		// "create file" asks return the same object. Clicking the first latches a
+		// local processing flag; the latch must clear when the next ask arrives so
+		// the user can act on it.
+		mockTurnState.mockReturnValue({ phase: "awaiting_approval", anchorTs: 1 })
+		const executeButtonAction = vi.fn().mockResolvedValue(undefined)
+		const messageHandlers = {
+			executeButtonAction,
+		} as unknown as MessageHandlers
+
+		const task = fileApprovalAsk(1, "/notes.txt")
+		const props = {
+			task,
+			chatState: makeChatState(),
+			messageHandlers,
+			mode: "act" as const,
+		}
+
+		const { rerender } = render(<ActionButtons {...props} messages={[task]} />)
+
+		const save = screen.getByRole("button", { name: "Save" })
+		expect(save).not.toBeDisabled()
+
+		// Approving latches the processing flag, disabling the buttons.
+		fireEvent.click(save)
+		expect(screen.getByRole("button", { name: "Save" })).toBeDisabled()
+
+		// A second create-file ask arrives. Its config is the same object as the
+		// first, but the anchored timestamp changes — buttons must re-enable.
+		const secondAsk = fileApprovalAsk(2, "/notes2.txt")
+		mockTurnState.mockReturnValue({ phase: "awaiting_approval", anchorTs: 2 })
+		rerender(<ActionButtons {...props} messages={[task, secondAsk]} />)
+
+		expect(screen.getByRole("button", { name: "Save" })).not.toBeDisabled()
+		expect(screen.getByRole("button", { name: "Reject" })).not.toBeDisabled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ActionButtons.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ActionButtons.tsx
new file mode 100644
index 0000000..0f51853
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ActionButtons.tsx
@@ -0,0 +1,152 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import type React from "react"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useExtensionState } from "../../../../../context/ExtensionStateContext"
+import { ButtonActionType, getButtonConfigFromState } from "../../shared/buttonConfig"
+import type { ChatState, MessageHandlers } from "../../types/chatTypes"
+
+interface ActionButtonsProps {
+	task?: ClineMessage
+	messages: ClineMessage[]
+	chatState: ChatState
+	messageHandlers: MessageHandlers
+	mode: Mode
+}
+
+/**
+ * Action buttons area including approve/reject buttons
+ */
+export const ActionButtons: React.FC<ActionButtonsProps> = ({ task, messages, chatState, mode, messageHandlers }) => {
+	const { inputValue, selectedImages, selectedFiles, setSendingDisabled } = chatState
+	const { turnState } = useExtensionState()
+
+	// Tracks the ask the user last acted on. Clicking a footer button latches this so the
+	// buttons disable immediately (and survive the trailing bookkeeping re-renders before the
+	// backend advances the turn). It is a ref, not state, so it can be compared against the
+	// current ask during render without scheduling an extra update.
+	const processedAskRef = useRef<string | undefined>(undefined)
+	// Forces a re-render when the latch flips; the counter value itself is unused.
+	const [, bumpRender] = useState(0)
+
+	// Memoize last messages to avoid unnecessary recalculations
+	const [lastMessage, secondLastMessage] = useMemo(() => {
+		const len = messages.length
+		return len > 0 ? [messages[len - 1], messages[len - 2]] : [undefined, undefined]
+	}, [messages])
+
+	// Button configuration is driven by the authoritative backend TurnState when present (SDK
+	// path); otherwise it falls back to the legacy tail-walking heuristic. This makes the footer
+	// buttons immune to trailing bookkeeping messages and never disagree with the thinking
+	// indicator (RC1).
+	const buttonConfig = useMemo(() => {
+		return getButtonConfigFromState(messages, turnState, mode)
+	}, [messages, turnState, mode])
+
+	// Identity of the ask that currently owns the footer buttons. The button config objects are
+	// shared singletons (e.g. BUTTON_CONFIGS.tool_approve), so two consecutive identical asks
+	// (approve → approve) return the same reference. The anchored turn timestamp (or the last
+	// message) changes on every new ask, making it the reliable signal that a fresh decision is
+	// due even when the config object is identical. Folding the config's button text in also
+	// covers a same-anchor transition between different button sets.
+	const askIdentity = `${turnState?.anchorTs ?? lastMessage?.ts ?? ""}:${buttonConfig.primaryText ?? ""}:${buttonConfig.secondaryText ?? ""}`
+
+	// The buttons are "processing" only while the user's click is being handled for the current
+	// ask. Because the latch is keyed on the ask identity, a new ask (even one reusing the same
+	// shared config object) is never seen as already-processed, so its buttons are interactive
+	// again.
+	const isProcessing = processedAskRef.current === askIdentity
+
+	// Mirror the config's sending-disabled flag into chat state whenever the active button set
+	// changes.
+	useEffect(() => {
+		setSendingDisabled(buttonConfig.sendingDisabled)
+	}, [buttonConfig, setSendingDisabled])
+
+	// Clear input when transitioning from command_output to api_req
+	// This happens when user provides feedback during command execution
+	useEffect(() => {
+		if (lastMessage?.type === "say" && lastMessage.say === "api_req_started" && secondLastMessage?.ask === "command_output") {
+			chatState.setInputValue("")
+			chatState.setSelectedImages([])
+			chatState.setSelectedFiles([])
+		}
+	}, [lastMessage?.type, lastMessage?.say, secondLastMessage?.ask, chatState])
+
+	const handleActionClick = useCallback(
+		(action: ButtonActionType, text?: string, images?: string[], files?: string[]) => {
+			if (processedAskRef.current === askIdentity) {
+				return
+			}
+			// Latch this ask as processed and force a render so the buttons disable immediately.
+			processedAskRef.current = askIdentity
+			bumpRender((n) => n + 1)
+
+			void messageHandlers.executeButtonAction(action, text, images, files).catch(() => {
+				// Re-enable on error so the user is not stuck; a later ask would clear the latch
+				// on its own, but failures keep the same ask.
+				if (processedAskRef.current === askIdentity) {
+					processedAskRef.current = undefined
+					bumpRender((n) => n + 1)
+				}
+			})
+		},
+		[messageHandlers, askIdentity],
+	)
+
+	// Keyboard event handler
+	const handleKeyDown = useCallback(
+		(event: KeyboardEvent) => {
+			if (event.key === "Escape") {
+				event.preventDefault()
+				event.stopPropagation()
+				handleActionClick("cancel")
+			}
+		},
+		[handleActionClick],
+	)
+
+	useEffect(() => {
+		window.addEventListener("keydown", handleKeyDown)
+		return () => window.removeEventListener("keydown", handleKeyDown)
+	}, [handleKeyDown])
+
+	if (!task) {
+		return null
+	}
+
+	const { primaryText, secondaryText, primaryAction, secondaryAction, enableButtons } = buttonConfig
+	const hasButtons = primaryText || secondaryText
+	const isStreaming = task.partial === true
+	const canInteract = enableButtons && !isProcessing
+
+	if (!hasButtons) {
+		return null
+	}
+
+	const opacity = canInteract || isStreaming ? 1 : 0.5
+
+	return (
+		<div className="flex px-3.5" style={{ opacity }}>
+			{primaryText && primaryAction && (
+				<VSCodeButton
+					appearance="primary"
+					className={secondaryText ? "flex-1 mr-[6px]" : "flex-2"}
+					disabled={!canInteract}
+					onClick={() => handleActionClick(primaryAction, inputValue, selectedImages, selectedFiles)}>
+					{primaryText}
+				</VSCodeButton>
+			)}
+			{secondaryText && secondaryAction && (
+				<VSCodeButton
+					appearance="secondary"
+					className={primaryText ? "flex-1" : "flex-2"}
+					disabled={!canInteract}
+					onClick={() => handleActionClick(secondaryAction, inputValue, selectedImages, selectedFiles)}>
+					{secondaryText}
+				</VSCodeButton>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ChatLayout.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ChatLayout.tsx
new file mode 100644
index 0000000..2cdbdd1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/ChatLayout.tsx
@@ -0,0 +1,40 @@
+import type React from "react"
+import styled from "styled-components"
+
+interface ChatLayoutProps {
+	isHidden: boolean
+	children: React.ReactNode
+}
+
+/**
+ * Main layout container for the chat view
+ * Provides the fixed positioning and flex layout structure
+ */
+export const ChatLayout: React.FC<ChatLayoutProps> = ({ isHidden, children }) => {
+	return (
+		<ChatLayoutContainer isHidden={isHidden}>
+			<MainContent>{children}</MainContent>
+		</ChatLayoutContainer>
+	)
+}
+
+const ChatLayoutContainer = styled.div.withConfig({
+	shouldForwardProp: (prop) => !["isHidden"].includes(prop),
+})<{ isHidden: boolean }>`
+	display: ${(props) => (props.isHidden ? "none" : "grid")};
+	grid-template-rows: 1fr auto;
+	overflow: hidden;
+	padding: 0;
+	margin: 0;
+	width: 100%;
+	height: 100%;
+	min-height: 100vh;
+	position: relative;
+`
+
+const MainContent = styled.div`
+	display: flex;
+	flex-direction: column;
+	overflow: hidden;
+	grid-row: 1;
+`
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/InputSection.test.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/InputSection.test.tsx
new file mode 100644
index 0000000..63f7c9e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/InputSection.test.tsx
@@ -0,0 +1,146 @@
+import type { TurnState } from "@shared/ExtensionMessage"
+import { fireEvent, render, screen } from "@testing-library/react"
+import React from "react"
+import { describe, expect, it, vi } from "vitest"
+import type { ChatState, MessageHandlers, ScrollBehavior } from "../../types/chatTypes"
+import { InputSection } from "./InputSection"
+
+const mockTurnState = vi.fn<() => TurnState | undefined>(() => undefined)
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: () => ({ turnState: mockTurnState() }),
+}))
+
+vi.mock("@/components/chat/ChatTextArea", () => ({
+	default: React.forwardRef<HTMLTextAreaElement, { sendingDisabled: boolean; onSend: () => void }>(
+		({ sendingDisabled, onSend }, ref) => (
+			<textarea
+				aria-label="composer"
+				disabled={sendingDisabled}
+				onKeyDown={(event) => {
+					if (event.key === "Enter" && !sendingDisabled) {
+						onSend()
+					}
+				}}
+				ref={ref}
+			/>
+		),
+	),
+}))
+
+function makeChatState(overrides: Partial<ChatState> = {}): ChatState {
+	return {
+		activeQuote: null,
+		setActiveQuote: vi.fn(),
+		isTextAreaFocused: false,
+		inputValue: "queue this",
+		setInputValue: vi.fn(),
+		sendingDisabled: true,
+		selectedImages: [],
+		setSelectedImages: vi.fn(),
+		selectedFiles: [],
+		setSelectedFiles: vi.fn(),
+		textAreaRef: { current: null },
+		handleFocusChange: vi.fn(),
+		...overrides,
+	} as unknown as ChatState
+}
+
+function makeScrollBehavior(): ScrollBehavior {
+	return {
+		isAtBottom: true,
+		scrollToBottomAuto: vi.fn(),
+	} as unknown as ScrollBehavior
+}
+
+describe("InputSection", () => {
+	it("allows submit while the turn is streaming so the message can be queued", () => {
+		mockTurnState.mockReturnValue({ phase: "streaming", seq: 1 })
+		const handleSendMessage = vi.fn().mockResolvedValue(undefined)
+
+		render(
+			<InputSection
+				chatState={makeChatState({ sendingDisabled: true })}
+				messageHandlers={{ handleSendMessage } as unknown as MessageHandlers}
+				placeholderText="Type a message"
+				scrollBehavior={makeScrollBehavior()}
+				selectFilesAndImages={vi.fn()}
+				shouldDisableFilesAndImages={false}
+			/>,
+		)
+
+		const composer = screen.getByLabelText("composer")
+		expect(composer).not.toBeDisabled()
+
+		fireEvent.keyDown(composer, { key: "Enter" })
+		expect(handleSendMessage).toHaveBeenCalledWith("queue this", [], [])
+	})
+
+	it("allows submit while approval is pending so typed feedback can reject the approval", () => {
+		mockTurnState.mockReturnValue({ phase: "awaiting_approval", seq: 1 })
+		const handleSendMessage = vi.fn().mockResolvedValue(undefined)
+
+		render(
+			<InputSection
+				chatState={makeChatState({ sendingDisabled: true })}
+				messageHandlers={{ handleSendMessage } as unknown as MessageHandlers}
+				placeholderText="Type a message"
+				scrollBehavior={makeScrollBehavior()}
+				selectFilesAndImages={vi.fn()}
+				shouldDisableFilesAndImages={false}
+			/>,
+		)
+
+		const composer = screen.getByLabelText("composer")
+		expect(composer).not.toBeDisabled()
+
+		fireEvent.keyDown(composer, { key: "Enter" })
+		expect(handleSendMessage).toHaveBeenCalledWith("queue this", [], [])
+	})
+
+	it("allows submit for legacy active-task state when turnState is unavailable", () => {
+		mockTurnState.mockReturnValue(undefined)
+		const handleSendMessage = vi.fn().mockResolvedValue(undefined)
+
+		render(
+			<InputSection
+				chatState={makeChatState({
+					lastMessage: { ts: 1, type: "say", say: "api_req_started", partial: false },
+					sendingDisabled: true,
+				})}
+				messageHandlers={{ handleSendMessage } as unknown as MessageHandlers}
+				placeholderText="Type a message"
+				scrollBehavior={makeScrollBehavior()}
+				selectFilesAndImages={vi.fn()}
+				shouldDisableFilesAndImages={false}
+			/>,
+		)
+
+		const composer = screen.getByLabelText("composer")
+		expect(composer).not.toBeDisabled()
+
+		fireEvent.keyDown(composer, { key: "Enter" })
+		expect(handleSendMessage).toHaveBeenCalledWith("queue this", [], [])
+	})
+
+	it("keeps submit disabled for non-active blocked states", () => {
+		mockTurnState.mockReturnValue({ phase: "error", seq: 1 })
+		const handleSendMessage = vi.fn().mockResolvedValue(undefined)
+
+		render(
+			<InputSection
+				chatState={makeChatState({ sendingDisabled: true })}
+				messageHandlers={{ handleSendMessage } as unknown as MessageHandlers}
+				placeholderText="Type a message"
+				scrollBehavior={makeScrollBehavior()}
+				selectFilesAndImages={vi.fn()}
+				shouldDisableFilesAndImages={false}
+			/>,
+		)
+
+		const composer = screen.getByLabelText("composer")
+		expect(composer).toBeDisabled()
+
+		fireEvent.keyDown(composer, { key: "Enter" })
+		expect(handleSendMessage).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/InputSection.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/InputSection.tsx
new file mode 100644
index 0000000..c2e3b54
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/InputSection.tsx
@@ -0,0 +1,86 @@
+import React from "react"
+import ChatTextArea from "@/components/chat/ChatTextArea"
+import QuotedMessagePreview from "@/components/chat/QuotedMessagePreview"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ChatState, MessageHandlers, ScrollBehavior } from "../../types/chatTypes"
+
+interface InputSectionProps {
+	chatState: ChatState
+	messageHandlers: MessageHandlers
+	scrollBehavior: ScrollBehavior
+	placeholderText: string
+	shouldDisableFilesAndImages: boolean
+	selectFilesAndImages: () => Promise<void>
+}
+
+/**
+ * Input section including quoted message preview and chat text area
+ */
+export const InputSection: React.FC<InputSectionProps> = ({
+	chatState,
+	messageHandlers,
+	scrollBehavior,
+	placeholderText,
+	shouldDisableFilesAndImages,
+	selectFilesAndImages,
+}) => {
+	const {
+		activeQuote,
+		setActiveQuote,
+		isTextAreaFocused,
+		inputValue,
+		setInputValue,
+		sendingDisabled,
+		selectedImages,
+		setSelectedImages,
+		selectedFiles,
+		setSelectedFiles,
+		textAreaRef,
+		handleFocusChange,
+		lastMessage,
+	} = chatState
+
+	const { isAtBottom, scrollToBottomAuto } = scrollBehavior
+	const { turnState } = useExtensionState()
+	const legacyTaskRunning =
+		turnState === undefined &&
+		(lastMessage?.partial === true || (lastMessage?.type === "say" && lastMessage.say === "api_req_started"))
+	const allowQueuedSubmit = turnState?.phase === "streaming" || turnState?.phase === "awaiting_approval" || legacyTaskRunning
+	const submitDisabled = sendingDisabled && !allowQueuedSubmit
+
+	return (
+		<>
+			{activeQuote && (
+				<div style={{ marginBottom: "-12px", marginTop: "10px" }}>
+					<QuotedMessagePreview
+						isFocused={isTextAreaFocused}
+						onDismiss={() => setActiveQuote(null)}
+						text={activeQuote}
+					/>
+				</div>
+			)}
+
+			<ChatTextArea
+				activeQuote={activeQuote}
+				inputValue={inputValue}
+				onFocusChange={handleFocusChange}
+				onHeightChange={() => {
+					if (isAtBottom) {
+						scrollToBottomAuto()
+					}
+				}}
+				onSelectFilesAndImages={selectFilesAndImages}
+				onSend={() => messageHandlers.handleSendMessage(inputValue, selectedImages, selectedFiles)}
+				placeholderText={placeholderText}
+				ref={textAreaRef}
+				selectedFiles={selectedFiles}
+				selectedImages={selectedImages}
+				sendingDisabled={submitDisabled}
+				setInputValue={setInputValue}
+				setSelectedFiles={setSelectedFiles}
+				setSelectedImages={setSelectedImages}
+				shouldDisableFilesAndImages={shouldDisableFilesAndImages}
+			/>
+		</>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/MessagesArea.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/MessagesArea.tsx
new file mode 100644
index 0000000..84e2456
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/MessagesArea.tsx
@@ -0,0 +1,324 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type React from "react"
+import { useCallback, useEffect, useMemo, useRef } from "react"
+import { Virtuoso } from "react-virtuoso"
+import { StickyUserMessage } from "@/components/chat/task-header/StickyUserMessage"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import type { ChatState, MessageHandlers, ScrollBehavior } from "../../types/chatTypes"
+import { isToolGroup } from "../../utils/messageUtils"
+import { createMessageRenderer } from "../messages/MessageRenderer"
+
+// Sentinel ts for the synthetic "Thinking..." placeholder row. Not a real message; ignored when
+// deriving scroll triggers from the tail of the rendered list.
+const WAITING_ROW_TS = Number.MIN_SAFE_INTEGER
+
+interface MessagesAreaProps {
+	task: ClineMessage
+	groupedMessages: (ClineMessage | ClineMessage[])[]
+	modifiedMessages: ClineMessage[]
+	scrollBehavior: ScrollBehavior
+	chatState: ChatState
+	messageHandlers: MessageHandlers
+}
+
+/**
+ * The scrollable messages area with virtualized list
+ * Handles rendering of chat rows and browser sessions
+ */
+export const MessagesArea: React.FC<MessagesAreaProps> = ({
+	task,
+	groupedMessages,
+	modifiedMessages,
+	scrollBehavior,
+	chatState,
+	messageHandlers,
+}) => {
+	const { clineMessages, turnState } = useExtensionState()
+	const lastRawMessage = useMemo(() => clineMessages.at(-1), [clineMessages])
+
+	const {
+		virtuosoRef,
+		scrollContainerRef,
+		toggleRowExpansion,
+		handleRowHeightChange,
+		setIsAtBottom,
+		disableAutoScrollRef,
+		handleRangeChanged,
+		scrolledPastUserMessage,
+		scrollToMessage,
+		scrollToBottomSmooth,
+		scrollToBottomAuto,
+		handleLastRowContentChange,
+	} = scrollBehavior
+
+	// Find the index of the scrolled past user message for scrolling
+	const scrolledPastUserMessageIndex = useMemo(() => {
+		if (!scrolledPastUserMessage) {
+			return -1
+		}
+		return clineMessages.findIndex((msg) => msg.ts === scrolledPastUserMessage.ts)
+	}, [clineMessages, scrolledPastUserMessage])
+
+	// Handler to scroll to the scrolled past user message
+	const handleScrollToUserMessage = useCallback(() => {
+		if (scrollToMessage && scrolledPastUserMessageIndex >= 0) {
+			scrollToMessage(scrolledPastUserMessageIndex)
+		}
+	}, [scrollToMessage, scrolledPastUserMessageIndex])
+
+	const { expandedRows, inputValue, setActiveQuote } = chatState
+	const lastVisibleRow = useMemo(() => groupedMessages.at(-1), [groupedMessages])
+	const lastVisibleMessage = useMemo(() => {
+		const lastRow = lastVisibleRow
+		if (!lastRow) {
+			return undefined
+		}
+		return Array.isArray(lastRow) ? lastRow.at(-1) : lastRow
+	}, [lastVisibleRow])
+
+	// Show "Thinking..." until real content starts streaming.
+	// This is the sole early loading indicator - RequestStartRow does NOT duplicate it.
+	// Covers: pre-api_req_started (backend processing) AND post-api_req_started (waiting for model).
+	// Hides once reasoning, tools, text, or any other content message appears.
+	const isWaitingForResponse = useMemo(() => {
+		const lastMsg = modifiedMessages[modifiedMessages.length - 1]
+
+		// AUTHORITATIVE PATH: when the backend provides a TurnState, the agent is only "thinking"
+		// while phase === "streaming". Any other phase (awaiting_approval/followup, completed,
+		// error, resumable, idle) is never a thinking state — this is what makes the footer
+		// immune to trailing bookkeeping messages and prevents the stuck-"Thinking" bug (RC1).
+		// During streaming we still suppress the footer loader once a partial content row is
+		// actually rendering, to avoid a duplicate spinner (handled by the legacy sub-logic
+		// below, which only runs in the streaming case).
+		if (turnState) {
+			if (turnState.phase !== "streaming") {
+				return false
+			}
+			// phase === streaming: show Thinking until a visible content row is streaming.
+			if (groupedMessages.length === 0 || !lastVisibleMessage) {
+				return true
+			}
+			if (lastVisibleRow && isToolGroup(lastVisibleRow)) {
+				return true
+			}
+			return lastVisibleMessage.partial !== true
+		}
+
+		// LEGACY PATH (no TurnState — classic/older state): infer from the message tail.
+		// Never show thinking while waiting on user input (any ask state).
+		// This includes completion_result, tool approvals, followups, and resume asks.
+		if (lastRawMessage?.type === "ask") {
+			return false
+		}
+		// attempt_completion emits a final say("completion_result") before ask("completion_result").
+		// Treat that final completion message as non-waiting to avoid a brief footer flicker.
+		if (lastRawMessage?.type === "say" && lastRawMessage.say === "completion_result") {
+			return false
+		}
+		if (lastRawMessage?.type === "say" && lastRawMessage.say === "api_req_started") {
+			try {
+				const info = JSON.parse(lastRawMessage.text || "{}")
+				if (info.cancelReason === "user_cancelled") {
+					return false
+				}
+			} catch {
+				// ignore parse errors
+			}
+		}
+
+		// Always show while task has started but no visible rows are rendered yet.
+		if (groupedMessages.length === 0) {
+			return true
+		}
+
+		// Defensive guard for transient states where a grouped row exists
+		// but we still cannot resolve a concrete visible message.
+		if (!lastVisibleMessage) {
+			return true
+		}
+
+		// Always show when the last rendered row is a toolgroup.
+		if (lastVisibleRow && isToolGroup(lastVisibleRow)) {
+			return true
+		}
+
+		// User-requested behavior:
+		// if the last visible row is not actively partial, always show Thinking in the footer.
+		// (some rows like checkpoint_created don't set `partial`, and should be treated as non-partial)
+		if (lastVisibleMessage.partial !== true) {
+			return true
+		}
+
+		if (!lastMsg) {
+			// No messages after the initial task message - new task just started
+			return true
+		}
+		if (lastMsg.say === "user_feedback" || lastMsg.say === "user_feedback_diff") return true
+		if (lastMsg.say === "api_req_started") {
+			try {
+				const info = JSON.parse(lastMsg.text || "{}")
+				// Still in progress (no cost) and nothing has streamed after it yet
+				return info.cost == null
+			} catch {
+				return true
+			}
+		}
+		return false
+	}, [turnState, lastRawMessage, groupedMessages.length, lastVisibleMessage, lastVisibleRow, modifiedMessages])
+
+	// Keep loader in the message flow (not footer). During handoff from waiting -> reasoning stream,
+	// keep the loader mounted until a real reasoning row is visible.
+	const showThinkingLoaderRow = useMemo(() => {
+		const handoffToReasoningPending =
+			lastRawMessage?.type === "say" &&
+			lastRawMessage.say === "reasoning" &&
+			lastRawMessage.partial === true &&
+			lastVisibleMessage?.say !== "reasoning"
+
+		// Mirror the old footer behavior exactly: show whenever waiting logic says so.
+		// Plus a brief handoff guard while grouped rows catch up to raw reasoning stream.
+		return isWaitingForResponse || handoffToReasoningPending
+	}, [isWaitingForResponse, lastRawMessage, lastVisibleMessage?.say])
+
+	const displayedGroupedMessages = useMemo<(ClineMessage | ClineMessage[])[]>(() => {
+		if (!showThinkingLoaderRow) {
+			return groupedMessages
+		}
+		const waitingRow: ClineMessage = {
+			ts: WAITING_ROW_TS,
+			type: "say",
+			say: "reasoning",
+			partial: true,
+			text: "",
+		}
+		return [...groupedMessages, waitingRow]
+	}, [groupedMessages, showThinkingLoaderRow])
+
+	// useScrollBehavior auto-scrolls when groupedMessages.length changes, but rows can change here
+	// without that: the waiting row is turnState-driven (e.g. plan -> act auto-continue adds no
+	// message), new tool messages merge into the trailing tool group at constant length, and the
+	// waiting row gets swapped for a real reasoning row. Pin to bottom for those too, keyed on the
+	// rendered list's length and the tail message's ts (stable across partial updates, so this
+	// doesn't fire while a message streams; row growth is handled by ChatRow's height observer).
+	const lastTailTs = useMemo(() => {
+		for (let i = displayedGroupedMessages.length - 1; i >= 0; i--) {
+			const row = displayedGroupedMessages[i]
+			const message = Array.isArray(row) ? row.at(-1) : row
+			if (message && message.ts !== WAITING_ROW_TS) {
+				return message.ts
+			}
+		}
+		return undefined
+	}, [displayedGroupedMessages])
+
+	useEffect(() => {
+		if (disableAutoScrollRef.current) {
+			return
+		}
+		scrollToBottomSmooth()
+		// Settle with an instant scroll so late layout shifts can't leave us short of the bottom.
+		// No cleanup: a quick follow-up change would cancel the settle scroll.
+		setTimeout(() => {
+			if (!disableAutoScrollRef.current) {
+				scrollToBottomAuto()
+			}
+		}, 50)
+	}, [displayedGroupedMessages.length, lastTailTs, scrollToBottomSmooth, scrollToBottomAuto, disableAutoScrollRef])
+
+	// Re-engage auto scroll when a new turn starts streaming. In the old extension every turn start
+	// came from a webview action (send, approve, resume) whose handler reset disableAutoScrollRef;
+	// a turnState-driven start like plan -> act auto-continue has no webview-side action, so reset
+	// it here to keep the old "new turn pins to bottom" behavior.
+	const prevTurnPhaseRef = useRef(turnState?.phase)
+	useEffect(() => {
+		const prevPhase = prevTurnPhaseRef.current
+		prevTurnPhaseRef.current = turnState?.phase
+		if (turnState?.phase === "streaming" && prevPhase !== "streaming") {
+			disableAutoScrollRef.current = false
+			scrollToBottomSmooth()
+		}
+	}, [turnState?.phase, scrollToBottomSmooth, disableAutoScrollRef])
+
+	const itemContent = useMemo(
+		() =>
+			createMessageRenderer(
+				displayedGroupedMessages,
+				modifiedMessages,
+				expandedRows,
+				toggleRowExpansion,
+				handleRowHeightChange,
+				handleLastRowContentChange,
+				setActiveQuote,
+				inputValue,
+				messageHandlers,
+				false,
+			),
+		[
+			displayedGroupedMessages,
+			modifiedMessages,
+			expandedRows,
+			toggleRowExpansion,
+			handleRowHeightChange,
+			handleLastRowContentChange,
+			setActiveQuote,
+			inputValue,
+			messageHandlers,
+		],
+	)
+
+	// Keep footer as a simple spacer. Thinking loading is rendered as an in-list row.
+	const virtuosoComponents = useMemo(
+		() => ({
+			Footer: () => <div className="min-h-1" />,
+		}),
+		[],
+	)
+
+	return (
+		<div className="overflow-hidden flex flex-col h-full relative">
+			{/* Sticky User Message - positioned absolutely to avoid layout shifts */}
+			<div
+				className={cn(
+					"absolute top-0 left-0 right-0 z-10 pl-[15px] pr-[14px] bg-background",
+					scrolledPastUserMessage && "pb-2",
+				)}>
+				<StickyUserMessage
+					isVisible={!!scrolledPastUserMessage}
+					lastUserMessage={scrolledPastUserMessage}
+					onScrollToMessage={handleScrollToUserMessage}
+				/>
+			</div>
+
+			<div className="grow flex" ref={scrollContainerRef}>
+				<Virtuoso
+					atBottomStateChange={(isAtBottom) => {
+						setIsAtBottom(isAtBottom)
+						if (isAtBottom) {
+							disableAutoScrollRef.current = false
+						}
+					}}
+					atBottomThreshold={10} // trick to make sure virtuoso re-renders when task changes, and we use initialTopMostItemIndex to start at the bottom
+					className="scrollable grow overflow-y-scroll"
+					components={virtuosoComponents}
+					data={displayedGroupedMessages}
+					// increasing top by 3_000 to prevent jumping around when user collapses a row
+					increaseViewportBy={{
+						top: 3_000,
+						bottom: Number.MAX_SAFE_INTEGER,
+					}} // hack to make sure the last message is always rendered to get truly perfect scroll to bottom animation when new messages are added (Number.MAX_SAFE_INTEGER is safe for arithmetic operations, which is all virtuoso uses this value for in src/sizeRangeSystem.ts)
+					initialTopMostItemIndex={displayedGroupedMessages.length - 1} // messages is the raw format returned by extension, modifiedMessages is the manipulated structure that combines certain messages of related type, and visibleMessages is the filtered structure that removes messages that should not be rendered
+					itemContent={itemContent}
+					key={task.ts}
+					rangeChanged={handleRangeChanged}
+					ref={virtuosoRef} // anything lower causes issues with followOutput
+					style={{
+						scrollbarWidth: "none", // Firefox
+						msOverflowStyle: "none", // IE/Edge
+						overflowAnchor: "none", // prevent scroll jump when content expands
+					}}
+				/>
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/QueuedPrompts.test.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/QueuedPrompts.test.tsx
new file mode 100644
index 0000000..6e41d8d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/QueuedPrompts.test.tsx
@@ -0,0 +1,59 @@
+import type { QueuedPrompt } from "@shared/ExtensionMessage"
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { QueuedPrompts } from "./QueuedPrompts"
+
+const cancelQueuedPromptMock = vi.hoisted(() => vi.fn())
+
+vi.mock("@/services/grpc-client", () => ({
+	TaskServiceClient: {
+		cancelQueuedPrompt: (request: unknown) => cancelQueuedPromptMock(request),
+	},
+}))
+
+vi.mock("@shared/proto/cline/common", () => ({
+	StringRequest: {
+		create: (request: unknown) => request,
+	},
+}))
+
+const queuedPrompts: QueuedPrompt[] = [
+	{
+		id: "prompt-1",
+		prompt: "First queued message",
+		delivery: "queue",
+		attachmentCount: 0,
+	},
+	{
+		id: "prompt-2",
+		prompt: "Second queued message",
+		delivery: "steer",
+		attachmentCount: 1,
+	},
+]
+
+describe("QueuedPrompts", () => {
+	beforeEach(() => {
+		cancelQueuedPromptMock.mockReset()
+		cancelQueuedPromptMock.mockResolvedValue({})
+	})
+
+	it("cancels a queued prompt from the row action", async () => {
+		render(<QueuedPrompts items={queuedPrompts} />)
+
+		const cancelButtons = screen.getAllByRole("button", { name: "Cancel queued message" })
+		fireEvent.click(cancelButtons[0])
+
+		expect(cancelQueuedPromptMock).toHaveBeenCalledTimes(1)
+		expect(cancelQueuedPromptMock).toHaveBeenCalledWith({ value: "prompt-1" })
+		expect(cancelButtons[0]).toBeDisabled()
+
+		await waitFor(() => expect(cancelButtons[0]).not.toBeDisabled())
+	})
+
+	it("does not render an empty queue", () => {
+		const { container } = render(<QueuedPrompts items={[]} />)
+
+		expect(container).toBeEmptyDOMElement()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/QueuedPrompts.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/QueuedPrompts.tsx
new file mode 100644
index 0000000..e60924d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/QueuedPrompts.tsx
@@ -0,0 +1,98 @@
+import type { QueuedPrompt } from "@shared/ExtensionMessage"
+import { StringRequest } from "@shared/proto/cline/common"
+import { useState } from "react"
+import { TaskServiceClient } from "@/services/grpc-client"
+
+function truncatePrompt(prompt: string): string {
+	const trimmed = prompt.trim()
+	return trimmed.length > 96 ? `${trimmed.slice(0, 96)}...` : trimmed
+}
+
+function attachmentLabel(count: number): string | undefined {
+	if (count <= 0) {
+		return undefined
+	}
+	return count === 1 ? "1 attachment" : `${count} attachments`
+}
+
+function queueSummary(items: QueuedPrompt[]): string {
+	const steerCount = items.filter((item) => item.delivery === "steer").length
+	const queueCount = items.length - steerCount
+	if (steerCount === 0) {
+		return items.length === 1 ? "Queued message" : `${items.length} queued messages`
+	}
+	if (queueCount === 0) {
+		return items.length === 1 ? "Steering message" : `${items.length} steering messages`
+	}
+	return `${queueCount} queued, ${steerCount} steering`
+}
+
+interface QueuedPromptsProps {
+	items?: QueuedPrompt[]
+}
+
+export function QueuedPrompts({ items = [] }: QueuedPromptsProps) {
+	const [cancellingIds, setCancellingIds] = useState<Set<string>>(() => new Set())
+
+	if (items.length === 0) {
+		return null
+	}
+
+	const cancelQueuedPrompt = (promptId: string) => {
+		setCancellingIds((current) => new Set(current).add(promptId))
+		TaskServiceClient.cancelQueuedPrompt(StringRequest.create({ value: promptId }))
+			.catch((error) => {
+				console.error("Failed to cancel queued prompt:", error)
+			})
+			.finally(() => {
+				setCancellingIds((current) => {
+					const next = new Set(current)
+					next.delete(promptId)
+					return next
+				})
+			})
+	}
+
+	return (
+		<div className="mx-3 mt-2.5 mb-2.5 rounded-xs border border-editor-group-border bg-code/70 px-2.5 py-2 shadow-xs">
+			<div className="mb-1.5 flex items-center gap-1.5 text-xs font-medium text-description">
+				<span aria-hidden="true" className="codicon codicon-clock text-[12px]" />
+				<span>{queueSummary(items)}</span>
+			</div>
+			<div className="flex max-h-28 flex-col gap-1.5 overflow-y-auto [scrollbar-width:none] [-ms-overflow-style:none] [&::-webkit-scrollbar]:hidden">
+				{items.map((item) => {
+					const attachments = attachmentLabel(item.attachmentCount)
+					const isSteer = item.delivery === "steer"
+					const isCancelling = cancellingIds.has(item.id)
+					return (
+						<div
+							className="flex items-start gap-2 rounded-[3px] bg-input-background/40 px-2 py-1.5 text-xs leading-snug"
+							key={item.id}>
+							<span aria-hidden="true" className="mt-[5px] size-1.5 shrink-0 rounded-full bg-description/70" />
+							<span className="min-w-0 flex-1 break-words text-foreground">{truncatePrompt(item.prompt)}</span>
+							{isSteer && (
+								<span className="shrink-0 rounded-[3px] border border-editor-group-border px-1.5 py-[1px] text-[10px] leading-4 text-description">
+									Steer
+								</span>
+							)}
+							{attachments && (
+								<span className="shrink-0 rounded-[3px] border border-editor-group-border px-1.5 py-[1px] text-[10px] leading-4 text-description">
+									{attachments}
+								</span>
+							)}
+							<button
+								aria-label="Cancel queued message"
+								className="mt-[-2px] flex size-5 shrink-0 items-center justify-center rounded-[3px] text-description hover:bg-toolbar-hover-background hover:text-foreground disabled:pointer-events-none disabled:opacity-50"
+								disabled={isCancelling}
+								onClick={() => cancelQueuedPrompt(item.id)}
+								title="Cancel queued message"
+								type="button">
+								<span aria-hidden="true" className="codicon codicon-close text-[12px]" />
+							</button>
+						</div>
+					)
+				})}
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/TaskSection.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/TaskSection.tsx
new file mode 100644
index 0000000..473308d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/TaskSection.tsx
@@ -0,0 +1,48 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import React from "react"
+import TaskHeader from "@/components/chat/task-header/TaskHeader"
+import { MessageHandlers } from "../../types/chatTypes"
+
+interface TaskSectionProps {
+	task: ClineMessage
+	apiMetrics: {
+		totalTokensIn: number
+		totalTokensOut: number
+		totalCacheWrites?: number
+		totalCacheReads?: number
+		totalCost: number
+	}
+	lastApiReqTotalTokens?: number
+	selectedModelInfo: {
+		supportsPromptCache: boolean
+		supportsImages: boolean
+	}
+	messageHandlers: MessageHandlers
+}
+
+/**
+ * Task section shown when there's an active task
+ * Includes the task header and manages task-specific UI
+ */
+export const TaskSection: React.FC<TaskSectionProps> = ({
+	task,
+	apiMetrics,
+	lastApiReqTotalTokens,
+	selectedModelInfo,
+	messageHandlers,
+}) => {
+	return (
+		<TaskHeader
+			cacheReads={apiMetrics.totalCacheReads}
+			cacheWrites={apiMetrics.totalCacheWrites}
+			doesModelSupportPromptCache={selectedModelInfo.supportsPromptCache}
+			lastApiReqTotalTokens={lastApiReqTotalTokens}
+			onClose={messageHandlers.handleTaskCloseButtonClick}
+			onSendMessage={messageHandlers.handleSendMessage}
+			task={task}
+			tokensIn={apiMetrics.totalTokensIn}
+			tokensOut={apiMetrics.totalTokensOut}
+			totalCost={apiMetrics.totalCost}
+		/>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/WelcomeSection.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/WelcomeSection.tsx
new file mode 100644
index 0000000..ff05b6a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/WelcomeSection.tsx
@@ -0,0 +1,327 @@
+import { BANNER_DATA, BannerAction, BannerActionType, BannerCardData } from "@shared/cline/banner"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import type { Worktree } from "@shared/proto/cline/worktree"
+import { TrackWorktreeViewOpenedRequest } from "@shared/proto/cline/worktree"
+import { GitBranch } from "lucide-react"
+import React, { useCallback, useEffect, useMemo, useState } from "react"
+import BannerCarousel from "@/components/common/BannerCarousel"
+import WhatsNewModal from "@/components/common/WhatsNewModal"
+import HistoryPreview from "@/components/history/HistoryPreview"
+import { useApiConfigurationHandlers } from "@/components/settings/utils/useApiConfigurationHandlers"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import HomeHeader from "@/components/welcome/HomeHeader"
+import { SuggestedTasks } from "@/components/welcome/SuggestedTasks"
+import CreateWorktreeModal from "@/components/worktrees/CreateWorktreeModal"
+import { useClineAuth } from "@/context/ClineAuthContext"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { AccountServiceClient, StateServiceClient, UiServiceClient, WorktreeServiceClient } from "@/services/grpc-client"
+import { convertBannerData } from "@/utils/bannerUtils"
+import { getCurrentPlatform } from "@/utils/platformUtils"
+import { WelcomeSectionProps } from "../../types/chatTypes"
+
+/**
+ * Welcome section shown when there's no active task
+ * Includes info banner, announcements, home header, and history preview
+ */
+export const WelcomeSection: React.FC<WelcomeSectionProps> = ({
+	showAnnouncement,
+	hideAnnouncement,
+	showHistoryView,
+	version,
+	taskHistory,
+	shouldShowQuickWins,
+}) => {
+	const { lastDismissedInfoBannerVersion, lastDismissedCliBannerVersion, lastDismissedModelBannerVersion, dismissedBanners } =
+		useExtensionState()
+
+	// Track if we've shown the "What's New" modal this session
+	const [hasShownWhatsNewModal, setHasShownWhatsNewModal] = useState(false)
+	const [showWhatsNewModal, setShowWhatsNewModal] = useState(false)
+
+	// Quick launch worktree modal
+	const [showCreateWorktreeModal, setShowCreateWorktreeModal] = useState(false)
+	const [isGitRepo, setIsGitRepo] = useState<boolean | null>(null)
+	const [currentWorktree, setCurrentWorktree] = useState<Worktree | null>(null)
+
+	// Check if we're in a git repo and get current worktree info on mount
+	useEffect(() => {
+		WorktreeServiceClient.listWorktrees(EmptyRequest.create({}))
+			.then((result) => {
+				const canUseWorktrees = result.isGitRepo && !result.isMultiRoot && !result.isSubfolder
+				setIsGitRepo(canUseWorktrees)
+				if (canUseWorktrees) {
+					const current = result.worktrees.find((w) => w.isCurrent)
+					setCurrentWorktree(current || null)
+				}
+			})
+			.catch(() => setIsGitRepo(false))
+	}, [])
+
+	const { clineUser } = useClineAuth()
+	const {
+		openRouterModels,
+		navigateToSettings,
+		navigateToSettingsModelPicker,
+		navigateToWorktrees,
+		worktreesEnabled,
+		banners,
+		welcomeBanners,
+	} = useExtensionState()
+	const { handleFieldsChange } = useApiConfigurationHandlers()
+
+	// Open modal once we have welcome banners
+	useEffect(() => {
+		if (showAnnouncement && !hasShownWhatsNewModal && welcomeBanners && welcomeBanners.length > 0) {
+			setShowWhatsNewModal(true)
+			setHasShownWhatsNewModal(true)
+		}
+	}, [welcomeBanners, showAnnouncement, hasShownWhatsNewModal])
+
+	const handleCloseWhatsNewModal = useCallback(() => {
+		setShowWhatsNewModal(false)
+		// Call hideAnnouncement to persist dismissal (same as old banner behavior)
+		hideAnnouncement()
+		if (welcomeBanners && welcomeBanners.length > 0) {
+			for (const banner of welcomeBanners) {
+				StateServiceClient.dismissBanner({ value: banner.id }).catch(console.error)
+			}
+		}
+	}, [hideAnnouncement, welcomeBanners])
+
+	// Handle click on home page worktree element with telemetry
+	const handleWorktreeClick = useCallback(() => {
+		WorktreeServiceClient.trackWorktreeViewOpened(TrackWorktreeViewOpenedRequest.create({ source: "home_page" })).catch(
+			console.error,
+		)
+		navigateToWorktrees()
+	}, [navigateToWorktrees])
+
+	/**
+	 * Check if a banner has been dismissed based on its ID or legacy version
+	 */
+	const isBannerDismissed = useCallback(
+		(bannerId: string): boolean => {
+			// Check if banner is in the dismissed banners list (new approach)
+			if (
+				dismissedBanners?.some((dismissed: { bannerId: string; dismissedAt: number }) => dismissed.bannerId === bannerId)
+			) {
+				return true
+			}
+
+			// Legacy version-based tracking (deprecated)
+			if (bannerId.startsWith("info-banner")) {
+				return (lastDismissedInfoBannerVersion ?? 0) >= 1
+			}
+			if (bannerId.startsWith("new-model")) {
+				return (lastDismissedModelBannerVersion ?? 0) >= 1
+			}
+			if (bannerId.startsWith("cli-")) {
+				return (lastDismissedCliBannerVersion ?? 0) >= 1
+			}
+			return false
+		},
+		[dismissedBanners, lastDismissedInfoBannerVersion, lastDismissedModelBannerVersion, lastDismissedCliBannerVersion],
+	)
+
+	/**
+	 * Banner configuration from backend
+	 * In production, this would come from an API/gRPC call
+	 * For now, using EXAMPLE_BANNER_DATA with version-based filtering
+	 */
+	const bannerConfig = useMemo((): BannerCardData[] => {
+		// Filter banners based on version tracking and user status
+		return BANNER_DATA.filter((banner) => {
+			if (isBannerDismissed(banner.id)) {
+				return false
+			}
+
+			if (banner.isClineUserOnly !== undefined) {
+				return banner.isClineUserOnly === !!clineUser
+			}
+
+			if (banner.platforms && !banner.platforms.includes(getCurrentPlatform())) {
+				return false
+			}
+
+			return true
+		})
+	}, [isBannerDismissed, clineUser])
+
+	/**
+	 * Action handler - maps action types to actual implementations
+	 */
+	const handleBannerAction = useCallback(
+		(action: BannerAction) => {
+			switch (action.action) {
+				case BannerActionType.Link:
+					if (action.arg) {
+						UiServiceClient.openUrl({ value: action.arg }).catch(console.error)
+					}
+					break
+
+				case BannerActionType.SetModel: {
+					const modelId = action.arg || "anthropic/claude-sonnet-4.5"
+					const initialModelTab = action.tab || "recommended"
+					handleFieldsChange({
+						planModeOpenRouterModelId: modelId,
+						actModeOpenRouterModelId: modelId,
+						planModeOpenRouterModelInfo: openRouterModels[modelId],
+						actModeOpenRouterModelInfo: openRouterModels[modelId],
+						planModeApiProvider: "cline",
+						actModeApiProvider: "cline",
+					})
+					navigateToSettingsModelPicker({ targetSection: "api-config", initialModelTab })
+					break
+				}
+
+				case BannerActionType.ShowAccount:
+					AccountServiceClient.accountLoginClicked({}).catch((err) => console.error("Failed to get login URL:", err))
+					break
+
+				case BannerActionType.ShowApiSettings:
+					if (action.arg) {
+						// Pre-select the provider before navigating
+						handleFieldsChange({
+							planModeApiProvider: action.arg as any,
+							actModeApiProvider: action.arg as any,
+						})
+					}
+					navigateToSettings("api-config")
+					break
+
+				case BannerActionType.ShowFeatureSettings:
+					navigateToSettings("features")
+					break
+
+				case BannerActionType.InstallCli:
+					StateServiceClient.installClineCli({}).catch((error) =>
+						console.error("Failed to initiate CLI installation:", error),
+					)
+					break
+
+				default:
+					console.warn("Unknown banner action:", action.action)
+			}
+		},
+		[handleFieldsChange, openRouterModels, navigateToSettings, navigateToSettingsModelPicker],
+	)
+
+	/**
+	 * Dismissal handler - updates version tracking
+	 */
+	const handleBannerDismiss = useCallback((bannerId: string) => {
+		// !! Do not continue use these version numbers or add new banners that don't have unique IDs. !!
+		// Banner versions are **deprecated**. Going forward, we are tracking which banners have
+		// been dismissed using the **banner ID**.
+		if (bannerId.startsWith("info-banner")) {
+			StateServiceClient.updateInfoBannerVersion({ value: 1 }).catch(console.error)
+		} else if (bannerId.startsWith("new-model")) {
+			StateServiceClient.updateModelBannerVersion({ value: 1 }).catch(console.error)
+		} else if (bannerId.startsWith("cli-")) {
+			StateServiceClient.updateCliBannerVersion({ value: 1 }).catch(console.error)
+		} else {
+			// Mark the banner as dismissed by its ID.
+			StateServiceClient.dismissBanner({ value: bannerId }).catch(console.error)
+		}
+	}, [])
+
+	/**
+	 * Build array of active banners for carousel
+	 * Combines hardcoded banners (bannerConfig) with dynamic banners from extension state
+	 */
+	const activeBanners = useMemo(() => {
+		// Start with the hardcoded banners (bannerConfig)
+		const hardcodedBanners = bannerConfig.map((banner) =>
+			convertBannerData(banner, {
+				onAction: handleBannerAction,
+				onDismiss: handleBannerDismiss,
+			}),
+		)
+
+		// Add banners from extension state (if any)
+		const extensionStateBanners = (banners ?? []).map((banner) =>
+			convertBannerData(banner, {
+				onAction: handleBannerAction,
+				onDismiss: handleBannerDismiss,
+			}),
+		)
+
+		// Combine both sources: extension state banners first, then hardcoded banners
+		return [...extensionStateBanners, ...hardcodedBanners]
+	}, [bannerConfig, banners, clineUser, handleBannerAction, handleBannerDismiss])
+
+	return (
+		<div className="flex flex-col flex-1 w-full h-full p-0 m-0">
+			<WhatsNewModal
+				onBannerAction={handleBannerAction}
+				onClose={handleCloseWhatsNewModal}
+				open={showWhatsNewModal}
+				version={version}
+				welcomeBanners={welcomeBanners}
+			/>
+			<div className="overflow-y-auto flex flex-col pb-2.5">
+				<HomeHeader shouldShowQuickWins={shouldShowQuickWins} />
+				{!showWhatsNewModal && (
+					<>
+						<BannerCarousel banners={activeBanners} />
+						{!shouldShowQuickWins && taskHistory.length > 0 && <HistoryPreview showHistoryView={showHistoryView} />}
+						{/* Quick launch worktree button */}
+						{isGitRepo && worktreesEnabled?.featureFlag && worktreesEnabled?.user && (
+							<div className="flex flex-col items-center gap-3 mt-2 mb-4 px-5">
+								{/* TODO: Re-enable once worktree creation is stable
+								<Tooltip>
+									<TooltipTrigger asChild>
+										<button
+											className="flex items-center gap-2 px-4 py-2 rounded-full border border-[var(--vscode-foreground)]/30 text-[var(--vscode-foreground)] bg-transparent hover:bg-[var(--vscode-list-hoverBackground)] active:opacity-80 text-sm font-medium cursor-pointer"
+											onClick={() => setShowCreateWorktreeModal(true)}
+											type="button">
+											<span className="codicon codicon-empty-window"></span>
+											New Worktree Window
+										</button>
+									</TooltipTrigger>
+									<TooltipContent side="top">
+										Create a new git worktree and open it in a separate window. Great for running parallel
+										Cline tasks.
+									</TooltipContent>
+								</Tooltip>
+								*/}
+								{currentWorktree && (
+									<Tooltip>
+										<TooltipTrigger asChild>
+											<button
+												className="flex flex-col items-center gap-0.5 text-xs text-[var(--vscode-descriptionForeground)] hover:text-[var(--vscode-foreground)] cursor-pointer bg-transparent border-none p-1 rounded"
+												onClick={handleWorktreeClick}
+												type="button">
+												<div className="flex items-center gap-1.5 text-xs">
+													<GitBranch className="w-3 h-3 stroke-[2.5] flex-shrink-0" />
+													<span className="break-all text-center">
+														<span className="font-semibold">Current:</span>{" "}
+														{currentWorktree.branch || "detached HEAD"}
+													</span>
+												</div>
+												<span className="break-all text-center max-w-[300px]">
+													{currentWorktree.path}
+												</span>
+											</button>
+										</TooltipTrigger>
+										<TooltipContent side="bottom">
+											View and manage git worktrees. Great for running parallel Cline tasks.
+										</TooltipContent>
+									</Tooltip>
+								)}
+							</div>
+						)}
+					</>
+				)}
+			</div>
+			<SuggestedTasks shouldShowQuickWins={shouldShowQuickWins} />
+
+			{/* Quick launch worktree modal */}
+			<CreateWorktreeModal
+				onClose={() => setShowCreateWorktreeModal(false)}
+				open={showCreateWorktreeModal}
+				openAfterCreate={true}
+			/>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/index.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/index.ts
new file mode 100644
index 0000000..7c12267
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/layout/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Export all layout components
+ */
+
+export { ActionButtons } from "./ActionButtons"
+export { ChatLayout } from "./ChatLayout"
+export { InputSection } from "./InputSection"
+export { MessagesArea } from "./MessagesArea"
+export { QueuedPrompts } from "./QueuedPrompts"
+export { TaskSection } from "./TaskSection"
+export { WelcomeSection } from "./WelcomeSection"
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/MessageRenderer.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/MessageRenderer.tsx
new file mode 100644
index 0000000..13be520
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/MessageRenderer.tsx
@@ -0,0 +1,163 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import type React from "react"
+import { useMemo } from "react"
+import BrowserSessionRow from "@/components/chat/BrowserSessionRow"
+import ChatRow from "@/components/chat/ChatRow"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import type { MessageHandlers } from "../../types/chatTypes"
+import { findReasoningForApiReq, isTextMessagePendingToolCall, isToolGroup } from "../../utils/messageUtils"
+import { ToolGroupRenderer } from "./ToolGroupRenderer"
+
+interface MessageRendererProps {
+	index: number
+	messageOrGroup: ClineMessage | ClineMessage[]
+	groupedMessages: (ClineMessage | ClineMessage[])[]
+	modifiedMessages: ClineMessage[]
+	expandedRows: Record<number, boolean>
+	onToggleExpand: (ts: number, options?: { preserveAutoScroll?: boolean }) => void
+	onHeightChange: (isTaller: boolean) => void
+	onLastRowContentChange: () => void
+	onSetQuote: (quote: string | null) => void
+	inputValue: string
+	messageHandlers: MessageHandlers
+	footerActive: boolean
+}
+
+/**
+ * Specialized component for rendering different message types
+ * Handles browser sessions, regular messages, and checkpoint logic
+ */
+const MessageRenderer: React.FC<MessageRendererProps> = ({
+	index,
+	messageOrGroup,
+	groupedMessages,
+	modifiedMessages,
+	expandedRows,
+	onToggleExpand,
+	onHeightChange,
+	onLastRowContentChange,
+	onSetQuote,
+	inputValue,
+	messageHandlers,
+	footerActive,
+}) => {
+	const { mode } = useExtensionState()
+
+	const isLastMessage = useMemo(() => index === groupedMessages?.length - 1, [groupedMessages, index])
+
+	// Get reasoning content and response status for api_req_started messages
+	const reasoningData = useMemo(() => {
+		if (!Array.isArray(messageOrGroup) && messageOrGroup.say === "api_req_started") {
+			// Use the same message source-of-truth that `groupedMessages` is derived from.
+			return findReasoningForApiReq(messageOrGroup.ts, modifiedMessages)
+		}
+		return { reasoning: undefined, responseStarted: false }
+	}, [messageOrGroup, modifiedMessages])
+
+	// Check if a text message is waiting for tool call completion
+	const isRequestInProgress = useMemo(() => {
+		if (!Array.isArray(messageOrGroup) && messageOrGroup.say === "text") {
+			// Use modifiedMessages so this stays consistent with the rendered list.
+			return isTextMessagePendingToolCall(messageOrGroup.ts, modifiedMessages)
+		}
+		return false
+	}, [messageOrGroup, modifiedMessages])
+
+	// Tool group (low-stakes tools grouped together)
+	// Determine if this is the last tool group to show active items
+	const isLastToolGroup = useMemo(() => {
+		if (!isToolGroup(messageOrGroup)) {
+			return false
+		}
+		// Find the last tool group in groupedMessages
+		for (let i = groupedMessages.length - 1; i >= 0; i--) {
+			if (isToolGroup(groupedMessages[i])) {
+				return i === index
+			}
+		}
+		return false
+	}, [messageOrGroup, groupedMessages, index])
+
+	if (isToolGroup(messageOrGroup)) {
+		return <ToolGroupRenderer allMessages={modifiedMessages} isLastGroup={isLastToolGroup} messages={messageOrGroup} />
+	}
+
+	// Browser session group
+	if (Array.isArray(messageOrGroup)) {
+		return (
+			<BrowserSessionRow
+				expandedRows={expandedRows}
+				isLast={isLastMessage}
+				key={messageOrGroup[0]?.ts}
+				lastModifiedMessage={modifiedMessages.at(-1)}
+				messages={messageOrGroup}
+				onHeightChange={onHeightChange}
+				onSetQuote={onSetQuote}
+				onToggleExpand={onToggleExpand}
+			/>
+		)
+	}
+
+	// Regular message
+	return (
+		<div
+			className={cn({
+				"pb-2.5": isLastMessage && !footerActive,
+			})}
+			data-message-ts={messageOrGroup.ts}>
+			<ChatRow
+				inputValue={inputValue}
+				isExpanded={expandedRows[messageOrGroup.ts] || false}
+				isLast={isLastMessage}
+				isRequestInProgress={isRequestInProgress}
+				key={messageOrGroup.ts}
+				lastModifiedMessage={modifiedMessages.at(-1)}
+				message={messageOrGroup}
+				mode={mode}
+				onCancelCommand={() => messageHandlers.executeButtonAction("cancel")}
+				onHeightChange={onHeightChange}
+				onLastRowContentChange={onLastRowContentChange}
+				onSetQuote={onSetQuote}
+				onToggleExpand={onToggleExpand}
+				reasoningContent={reasoningData.reasoning}
+				responseStarted={reasoningData.responseStarted}
+				sendMessageFromChatRow={messageHandlers.handleSendMessage}
+			/>
+		</div>
+	)
+}
+
+/**
+ * Factory function to create the itemContent callback for Virtuoso
+ * This allows us to encapsulate the rendering logic while maintaining performance
+ */
+export const createMessageRenderer = (
+	groupedMessages: (ClineMessage | ClineMessage[])[],
+	modifiedMessages: ClineMessage[],
+	expandedRows: Record<number, boolean>,
+	onToggleExpand: (ts: number, options?: { preserveAutoScroll?: boolean }) => void,
+	onHeightChange: (isTaller: boolean) => void,
+	onLastRowContentChange: () => void,
+	onSetQuote: (quote: string | null) => void,
+	inputValue: string,
+	messageHandlers: MessageHandlers,
+	footerActive: boolean,
+) => {
+	return (index: number, messageOrGroup: ClineMessage | ClineMessage[]) => (
+		<MessageRenderer
+			expandedRows={expandedRows}
+			footerActive={footerActive}
+			groupedMessages={groupedMessages}
+			index={index}
+			inputValue={inputValue}
+			messageHandlers={messageHandlers}
+			messageOrGroup={messageOrGroup}
+			modifiedMessages={modifiedMessages}
+			onHeightChange={onHeightChange}
+			onLastRowContentChange={onLastRowContentChange}
+			onSetQuote={onSetQuote}
+			onToggleExpand={onToggleExpand}
+		/>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.test.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.test.ts
new file mode 100644
index 0000000..f2cd236
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.test.ts
@@ -0,0 +1,59 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { describe, expect, it } from "vitest"
+import { buildToolsWithReasoning, getToolGroupSummaryFromParsedTools } from "./ToolGroupRenderer"
+
+const readToolMessage = (
+	ts: number,
+	type: "ask" | "say",
+	path: string,
+	range?: { start: number; end: number },
+): ClineMessage => ({
+	ts,
+	type,
+	...(type === "ask" ? { ask: "tool" as const } : { say: "tool" as const }),
+	text: JSON.stringify({
+		tool: "readFile",
+		path,
+		...(range ? { readLineStart: range.start, readLineEnd: range.end } : {}),
+	}),
+})
+
+describe("buildToolsWithReasoning", () => {
+	it("replaces an immediately-following read approval ask with the completed read", () => {
+		const tools = buildToolsWithReasoning([
+			readToolMessage(1, "ask", "src/a.ts"),
+			readToolMessage(2, "say", "src/a.ts", { start: 1, end: 20 }),
+		])
+
+		expect(tools).toHaveLength(1)
+		expect(tools[0].tool.say).toBe("tool")
+		expect(tools[0].parsedTool.readLineStart).toBe(1)
+		expect(tools[0].parsedTool.readLineEnd).toBe(20)
+	})
+
+	it("keeps separate reads of the same file when they are distinct operations", () => {
+		const tools = buildToolsWithReasoning([
+			readToolMessage(1, "ask", "src/a.ts"),
+			readToolMessage(2, "say", "src/a.ts", { start: 1, end: 20 }),
+			readToolMessage(3, "ask", "src/a.ts"),
+			readToolMessage(4, "say", "src/a.ts", { start: 40, end: 60 }),
+		])
+
+		expect(tools).toHaveLength(2)
+		expect(tools.map((tool) => [tool.parsedTool.readLineStart, tool.parsedTool.readLineEnd])).toEqual([
+			[1, 20],
+			[40, 60],
+		])
+	})
+})
+
+describe("getToolGroupSummaryFromParsedTools", () => {
+	it("counts rendered read tools once after ask/say collapse", () => {
+		const tools = buildToolsWithReasoning([
+			readToolMessage(1, "ask", "src/a.ts"),
+			readToolMessage(2, "say", "src/a.ts", { start: 1, end: 20 }),
+		])
+
+		expect(getToolGroupSummaryFromParsedTools(tools.map((tool) => tool.parsedTool))).toBe("Cline read 1 file")
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.tsx
new file mode 100644
index 0000000..99509db
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.tsx
@@ -0,0 +1,398 @@
+import { ClineMessage, ClineSayTool } from "@shared/ExtensionMessage"
+import { StringRequest } from "@shared/proto/cline/common"
+import { memo, useCallback, useMemo, useState } from "react"
+import { TypewriterText } from "@/components/chat/TypewriterText"
+import { cleanPathPrefix } from "@/components/common/CodeAccordian"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+import { FileServiceClient } from "@/services/grpc-client"
+import { getIconByToolName, getToolsNotInCurrentActivities, isLowStakesTool } from "../../utils/messageUtils"
+
+interface ToolGroupRendererProps {
+	messages: ClineMessage[]
+	allMessages: ClineMessage[]
+	isLastGroup: boolean
+}
+
+interface ToolWithReasoning {
+	tool: ClineMessage
+	parsedTool: ClineSayTool
+	reasoning?: string
+	isActive?: boolean
+	activityText?: string
+}
+
+const EXPANDABLE_TOOLS = new Set(["listFilesTopLevel", "listFilesRecursive", "listCodeDefinitionNames", "searchFiles"])
+
+// Helper to format activity text for active items (from RequestStartRow logic)
+const getActivityText = (tool: ClineSayTool): string | null => {
+	const cleanedPath = cleanPathPrefix(tool.path || "")
+	const formatSearchRegex = (regex: string, path: string, filePattern?: string): string => {
+		const cleanedPath = cleanPathPrefix(path)
+		const pathDisplay = cleanedPath ? `${cleanedPath}/` : "codebase"
+		const terms = regex
+			.split("|")
+			.map((t) => t.trim().replace(/\\b/g, "").replace(/\\s\?/g, " "))
+			.filter(Boolean)
+			.join(" | ")
+		return filePattern && filePattern !== "*"
+			? `"${terms}" in ${pathDisplay} (${filePattern})`
+			: `"${terms}" in ${pathDisplay}`
+	}
+
+	switch (tool.tool) {
+		case "readFile": {
+			if (!tool.path) {
+				return null
+			}
+			const lineHint =
+				tool.readLineStart != null
+					? ` (lines ${tool.readLineStart}${tool.readLineEnd != null ? `-${tool.readLineEnd}` : "+"})`
+					: ""
+			return `Reading ${cleanedPath}${lineHint}...`
+		}
+		case "listFilesTopLevel":
+		case "listFilesRecursive":
+			return tool.path ? `Exploring ${cleanedPath}/...` : null
+		case "searchFiles":
+			return tool.regex ? `Searching ${formatSearchRegex(tool.regex, tool.path || "", tool.filePattern)}...` : null
+		case "listCodeDefinitionNames":
+			return tool.path ? `Analyzing ${cleanedPath}/...` : null
+		default:
+			return null
+	}
+}
+
+// Calculate current activities (from RequestStartRow logic)
+const getCurrentActivities = (allMessages: ClineMessage[]): ClineMessage[] => {
+	// Find current api_req
+	let currentApiReqIndex = -1
+	for (let i = allMessages.length - 1; i >= 0; i--) {
+		const msg = allMessages[i]
+		if (msg.say === "api_req_started" && msg.text) {
+			try {
+				const info = JSON.parse(msg.text)
+				const hasCost = info.cost != null
+				if (!hasCost) {
+					currentApiReqIndex = i
+					break
+				}
+			} catch {
+				// ignore
+			}
+		}
+	}
+
+	if (currentApiReqIndex === -1) {
+		return []
+	}
+
+	// Collect tools AFTER the current api_req_started
+	const activities: ClineMessage[] = []
+	for (let i = currentApiReqIndex + 1; i < allMessages.length; i++) {
+		const msg = allMessages[i]
+		// Only collect tools that are currently executing (ask === "tool")
+		// Skip completed tools (say === "tool") - they should be in the completed list
+		if (msg.say === "tool" || msg.ask !== "tool") {
+			continue
+		}
+		if (isLowStakesTool(msg)) {
+			activities.push(msg)
+		}
+	}
+
+	return activities
+}
+
+/**
+ * Renders a collapsible group of low-stakes tool calls.
+ * Shows both completed tools AND currently active tools in a unified list (only for last group).
+ */
+export const ToolGroupRenderer = memo(({ messages, allMessages, isLastGroup }: ToolGroupRendererProps) => {
+	const [expandedItems, setExpandedItems] = useState<Record<number, boolean>>({})
+
+	// Filter out tools in the "current activities" range (being shown in loading state)
+	const filteredMessages = useMemo(() => getToolsNotInCurrentActivities(messages, allMessages), [messages, allMessages])
+
+	// Get current activities (active reading/exploring) - only for last group
+	const currentActivities = useMemo(() => {
+		if (!isLastGroup) {
+			return []
+		}
+		return getCurrentActivities(allMessages)
+	}, [allMessages, isLastGroup])
+
+	// Build completed tool items
+	const completedTools = useMemo(() => buildToolsWithReasoning(filteredMessages), [filteredMessages])
+
+	// Build active tool items
+	const activeTools = useMemo(() => {
+		return currentActivities
+			.map((msg) => {
+				const parsedTool = parseToolSafe(msg.text)
+				return {
+					tool: msg,
+					parsedTool,
+					reasoning: undefined,
+					isActive: true,
+					activityText: getActivityText(parsedTool),
+				}
+			})
+			.filter((item) => item.activityText)
+	}, [currentActivities])
+
+	// Merge: completed items first, then active items (active only added to last group)
+	// Deduplicate - exclude completed items that match active items by path
+	const allTools = useMemo(() => {
+		// Get paths of active items
+		const activePaths = new Set(activeTools.map((item) => item.parsedTool.path).filter(Boolean))
+
+		// Filter out completed items that are also being actively read
+		const dedupedCompleted = completedTools.filter((item) => !activePaths.has(item.parsedTool.path))
+
+		return [...dedupedCompleted, ...activeTools]
+	}, [completedTools, activeTools])
+
+	const summary = getToolGroupSummaryFromParsedTools(completedTools.map((item) => item.parsedTool))
+
+	const handleOpenFile = useCallback((filePath: string) => {
+		FileServiceClient.openFileRelativePath(StringRequest.create({ value: filePath })).catch((err) =>
+			console.error("Failed to open file:", err),
+		)
+	}, [])
+
+	const handleItemToggle = useCallback((ts: number) => {
+		setExpandedItems((prev) => ({ ...prev, [ts]: !prev[ts] }))
+	}, [])
+
+	// Don't render if no tools to show
+	if (allTools.length === 0) {
+		return null
+	}
+
+	return (
+		<div className={cn("px-4 py-2 ml-1 text-description")}>
+			{/* Header */}
+			<div className="text-[13px] text-description font-semibold mb-1">{summary}:</div>
+
+			{/* Content - unified list of completed + active tools */}
+			<div className="min-w-0">
+				{allTools.map(({ tool, parsedTool, isActive, activityText }) => {
+					const info = getToolDisplayInfo(parsedTool)
+					if (!info) {
+						return null
+					}
+
+					const isExpandable = EXPANDABLE_TOOLS.has(parsedTool.tool)
+					const isItemExpanded = expandedItems[tool.ts] ?? false
+					const content = parsedTool.content || null
+
+					// Active items render with "Reading..." TypewriterText (match completed item structure exactly)
+					if (isActive && activityText) {
+						return (
+							<div className="min-w-0" key={tool.ts}>
+								{/* ACTIVE "READING..." ITEM STYLING - Modify vertical spacing here via py-0 and -my-0.5 */}
+								<Button
+									className="flex items-center gap-[3px] text-[13px] text-description py-[1px] min-w-0 max-w-full px-0 leading-tight -my-0.5"
+									disabled
+									size="icon"
+									variant="text">
+									<info.icon className="opacity-70 shrink-0 size-[12px]" />
+									<span className="flex-1 min-w-0 whitespace-nowrap overflow-hidden text-ellipsis text-left text-[13px]">
+										<TypewriterText speed={15} text={activityText} />
+									</span>{" "}
+								</Button>
+							</div>
+						)
+					}
+
+					// Completed items render normally (clickable)
+					return (
+						<div className="min-w-0" key={tool.ts}>
+							<Button
+								className="flex items-center gap-[3px] cursor-pointer text-[13px] text-description py-[1px] hover:text-link min-w-0 max-w-full px-0 leading-tight -my-0.5"
+								onClick={() => (isExpandable ? handleItemToggle(tool.ts) : handleOpenFile(info.path))}
+								size="icon"
+								variant="text">
+								<info.icon className="opacity-70 shrink-0 size-[12px]" />
+								<span
+									className={cn(
+										"flex-1 min-w-0 whitespace-nowrap overflow-hidden text-ellipsis text-left [direction:rtl] text-[13px]",
+										{
+											"[direction:ltr]": !!info.displayText,
+										},
+									)}>
+									{(info.displayText || cleanPathPrefix(info.path)) + "\u200E"}
+								</span>
+							</Button>
+							{/* Expanded content for folders/search/definitions - file lists only */}
+							{isExpandable && isItemExpanded && content && (
+								<pre className="m-1 ml-4 text-xs opacity-80 whitespace-pre-wrap break-words p-2 max-h-40 overflow-auto rounded-xs">
+									{content}
+								</pre>
+							)}
+						</div>
+					)
+				})}
+			</div>
+		</div>
+	)
+})
+
+/**
+ * Build tool items WITHOUT reasoning.
+ * Reasoning should not be displayed in file lists - only file/folder content.
+ */
+export function buildToolsWithReasoning(messages: ClineMessage[]): ToolWithReasoning[] {
+	const result: ToolWithReasoning[] = []
+
+	for (const msg of messages) {
+		// Skip reasoning messages - they should not be in file lists
+		if (msg.say === "reasoning") {
+			continue
+		}
+
+		if (isLowStakesTool(msg)) {
+			const parsedTool = parseToolSafe(msg.text)
+			const previous = result.at(-1)
+			const supersedesPreviousReadAsk =
+				parsedTool.tool === "readFile" &&
+				parsedTool.path &&
+				msg.say === "tool" &&
+				previous?.tool.ask === "tool" &&
+				previous.parsedTool.tool === "readFile" &&
+				previous.parsedTool.path === parsedTool.path
+
+			if (supersedesPreviousReadAsk) {
+				result[result.length - 1] = {
+					tool: msg,
+					parsedTool,
+					reasoning: undefined,
+				}
+				continue
+			}
+			result.push({
+				tool: msg,
+				parsedTool,
+				reasoning: undefined, // Never show reasoning in file lists
+			})
+		}
+	}
+
+	return result
+}
+
+/**
+ * Safely parse tool JSON, returning empty tool on failure.
+ */
+function parseToolSafe(text: string | undefined): ClineSayTool {
+	try {
+		return JSON.parse(text || "{}") as ClineSayTool
+	} catch {
+		return {} as ClineSayTool
+	}
+}
+
+/**
+ * Get display info for a tool.
+ */
+function getToolDisplayInfo(tool: ClineSayTool) {
+	const icon = getIconByToolName(tool.tool)
+	const filePath = tool.path || ""
+	const folderPath = filePath + "/"
+
+	switch (tool.tool) {
+		case "readFile": {
+			const lineNote =
+				tool.readLineStart != null
+					? `lines ${tool.readLineStart}${tool.readLineEnd != null ? `-${tool.readLineEnd}` : "+"}`
+					: null
+			return {
+				icon,
+				path: filePath,
+				label: "read",
+				displayText: lineNote ? `${cleanPathPrefix(filePath)} · ${lineNote}` : undefined,
+			}
+		}
+		case "listFilesTopLevel":
+			return { icon, path: folderPath, label: "listed" }
+		case "listFilesRecursive":
+			return { icon, path: folderPath, label: "listed recursively" }
+		case "listCodeDefinitionNames":
+			return { icon, path: folderPath, label: "definitions" }
+		case "searchFiles":
+			return {
+				icon,
+				path: filePath ? folderPath : "",
+				label: `search: ${tool.regex}`,
+				displayText: formatSearchDisplay(tool.regex || "", filePath, tool.filePattern),
+			}
+		default:
+			return null
+	}
+}
+
+/**
+ * Format search regex for display - simplify complex patterns
+ */
+function formatSearchDisplay(regex: string, path: string, filePattern?: string): string {
+	// Split by | and clean up regex syntax
+	const terms = regex
+		.split("|")
+		.map((t) => t.trim().replace(/\\b/g, "").replace(/\\s\?/g, " "))
+		.filter(Boolean)
+
+	const termDisplay = terms.length > 3 ? `${terms.length} patterns` : `"${terms.join(" | ")}"`
+	// When path is empty (e.g. SDK search_codebase has no path param), show "codebase"
+	const pathDisplay = path ? `${cleanPathPrefix(path)}/` : "codebase"
+	let result = `${termDisplay} in ${pathDisplay}`
+
+	if (filePattern && filePattern !== "*") {
+		result += ` (${filePattern})`
+	}
+
+	return result
+}
+
+/**
+ * Get summary label for a tool group - shows what's been added to context.
+ */
+export function getToolGroupSummaryFromParsedTools(tools: ClineSayTool[]): string {
+	const counts = { read: 0, list: 0, search: 0, def: 0 }
+
+	for (const tool of tools) {
+		switch (tool.tool) {
+			case "readFile":
+				counts.read++
+				break
+			case "listFilesTopLevel":
+			case "listFilesRecursive":
+				counts.list++
+				break
+			case "searchFiles":
+				counts.search++
+				break
+			case "listCodeDefinitionNames":
+				counts.def++
+				break
+		}
+	}
+
+	const parts: string[] = []
+	const action = counts.read > 0 || counts.list > 0 ? " read " : " "
+
+	if (counts.read > 0) {
+		parts.push(`${counts.read} file${counts.read > 1 ? "s" : ""}`)
+	}
+	if (counts.list > 0) {
+		parts.push(`${counts.list} folder${counts.list > 1 ? "s" : ""}`)
+	}
+	if (counts.def > 0) {
+		parts.push(`${counts.def} definition${counts.def > 1 ? "s" : ""}`)
+	}
+	if (counts.search > 0) {
+		parts.push(`performed ${counts.search} search${counts.search > 1 ? "es" : ""}`)
+	}
+
+	return parts.length === 0 ? "Context" : "Cline" + action + parts.join(", ")
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/constants.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/constants.ts
new file mode 100644
index 0000000..dcd3b7f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/constants.ts
@@ -0,0 +1,7 @@
+/**
+ * Constants used across the chat view components
+ */
+export const CHAT_CONSTANTS = {
+	MAX_IMAGES_AND_FILES_PER_MESSAGE: 20,
+	QUICK_WINS_HISTORY_THRESHOLD: 300,
+} as const
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/index.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/index.ts
new file mode 100644
index 0000000..9dd8c0e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/index.ts
@@ -0,0 +1,7 @@
+/**
+ * Export all custom hooks for the chat view
+ */
+
+export { useChatState } from "./useChatState"
+export { useMessageHandlers } from "./useMessageHandlers"
+export { useScrollBehavior } from "./useScrollBehavior"
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useChatState.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useChatState.ts
new file mode 100644
index 0000000..d84239d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useChatState.ts
@@ -0,0 +1,96 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { ChatState, PendingUserMessage } from "../types/chatTypes"
+
+/**
+ * Custom hook for managing chat state
+ * Handles input values, selection states, and UI state
+ */
+export function useChatState(messages: ClineMessage[]): ChatState {
+	// Input and selection state
+	const [inputValue, setInputValue] = useState("")
+	const [activeQuote, setActiveQuote] = useState<string | null>(null)
+	const [isTextAreaFocused, setIsTextAreaFocused] = useState(false)
+	const [selectedImages, setSelectedImages] = useState<string[]>([])
+	const [selectedFiles, setSelectedFiles] = useState<string[]>([])
+
+	// UI state
+	const [sendingDisabled, setSendingDisabled] = useState(false)
+	const [enableButtons, setEnableButtons] = useState<boolean>(false)
+	const [primaryButtonText, setPrimaryButtonText] = useState<string | undefined>("Approve")
+	const [secondaryButtonText, setSecondaryButtonText] = useState<string | undefined>("Reject")
+	const [expandedRows, setExpandedRows] = useState<Record<number, boolean>>({})
+	const [pendingUserMessage, setPendingUserMessage] = useState<PendingUserMessage | undefined>(undefined)
+
+	// Refs
+	const textAreaRef = useRef<HTMLTextAreaElement>(null)
+
+	// Derived state
+	const lastMessage = useMemo(() => messages.at(-1), [messages])
+	const secondLastMessage = useMemo(() => messages.at(-2), [messages])
+	const clineAsk = useMemo(() => (lastMessage?.type === "ask" ? lastMessage.ask : undefined), [lastMessage])
+
+	// Clear expanded rows when task changes
+	const task = useMemo(() => messages.at(0), [messages])
+	const clearExpandedRows = useCallback(() => {
+		setExpandedRows({})
+	}, [])
+
+	// Reset state when starting new conversation
+	const resetState = useCallback(() => {
+		setInputValue("")
+		setActiveQuote(null)
+		setSelectedImages([])
+		setSelectedFiles([])
+	}, [])
+
+	// Handle focus change
+	const handleFocusChange = useCallback((isFocused: boolean) => {
+		setIsTextAreaFocused(isFocused)
+	}, [])
+
+	// Auto-expand last message row when task or messages first changed.
+	useEffect(() => {
+		clearExpandedRows()
+	}, [task?.ts, clearExpandedRows])
+
+	return {
+		// State values
+		inputValue,
+		setInputValue,
+		activeQuote,
+		setActiveQuote,
+		isTextAreaFocused,
+		setIsTextAreaFocused,
+		selectedImages,
+		setSelectedImages,
+		selectedFiles,
+		setSelectedFiles,
+		sendingDisabled,
+		setSendingDisabled,
+		enableButtons,
+		setEnableButtons,
+		primaryButtonText,
+		setPrimaryButtonText,
+		secondaryButtonText,
+		setSecondaryButtonText,
+		expandedRows,
+		setExpandedRows,
+		pendingUserMessage,
+		setPendingUserMessage,
+
+		// Refs
+		textAreaRef,
+
+		// Derived values
+		lastMessage,
+		secondLastMessage,
+		clineAsk,
+		task,
+
+		// Handlers
+		handleFocusChange,
+		clearExpandedRows,
+		resetState,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useMessageHandlers.test.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useMessageHandlers.test.tsx
new file mode 100644
index 0000000..29c3d47
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useMessageHandlers.test.tsx
@@ -0,0 +1,497 @@
+import type { ClineMessage, TurnState } from "@shared/ExtensionMessage"
+import { act, renderHook } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+// --- Mocks -------------------------------------------------------------------
+// gRPC clients: record which RPC the send path chose.
+const newTask = vi.fn().mockResolvedValue(undefined)
+const askResponse = vi.fn().mockResolvedValue(undefined)
+const condense = vi.fn().mockResolvedValue(undefined)
+const trackIntent = vi.fn().mockResolvedValue(undefined)
+
+vi.mock("@/services/grpc-client", () => ({
+	TaskServiceClient: {
+		newTask: (req: unknown) => newTask(req),
+		askResponse: (req: unknown) => askResponse(req),
+		clearTask: vi.fn().mockResolvedValue(undefined),
+	},
+	SlashServiceClient: {
+		condense: (req: unknown) => condense(req),
+		reportBug: vi.fn().mockResolvedValue(undefined),
+	},
+	UiServiceClient: {
+		trackIntent: (req: unknown) => trackIntent(req),
+	},
+}))
+
+// Proto request factories just echo their input so we can assert on it.
+vi.mock("@shared/proto/cline/task", () => ({
+	AskResponseRequest: { create: (x: unknown) => x },
+	NewTaskRequest: { create: (x: unknown) => x },
+}))
+vi.mock("@shared/proto/cline/ui", () => ({
+	IntentEvent: { create: (x: unknown) => x },
+}))
+vi.mock("@shared/proto/cline/common", () => ({
+	EmptyRequest: { create: (x: unknown) => x },
+	StringRequest: { create: (x: unknown) => x },
+}))
+
+// useExtensionState supplies turnState (+ backgroundCommandRunning) to the hook.
+let mockTurnState: TurnState | undefined
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: () => ({
+		backgroundCommandRunning: false,
+		turnState: mockTurnState,
+	}),
+}))
+
+import type { ChatState } from "../types/chatTypes"
+import { useMessageHandlers } from "./useMessageHandlers"
+
+// Minimal ChatState stub. clineAsk/lastMessage are the only derived values the send path reads.
+function makeChatState(messages: ClineMessage[], overrides: Partial<ChatState> = {}): ChatState {
+	const last = messages.at(-1)
+	const state = {
+		inputValue: "",
+		setInputValue: vi.fn(),
+		activeQuote: null,
+		setActiveQuote: vi.fn(),
+		isTextAreaFocused: false,
+		setIsTextAreaFocused: vi.fn(),
+		selectedImages: [],
+		setSelectedImages: vi.fn(),
+		selectedFiles: [],
+		setSelectedFiles: vi.fn(),
+		sendingDisabled: false,
+		setSendingDisabled: vi.fn(),
+		enableButtons: false,
+		setEnableButtons: vi.fn(),
+		primaryButtonText: undefined,
+		setPrimaryButtonText: vi.fn(),
+		secondaryButtonText: undefined,
+		setSecondaryButtonText: vi.fn(),
+		expandedRows: {},
+		setExpandedRows: vi.fn(),
+		pendingUserMessage: undefined,
+		setPendingUserMessage: vi.fn(),
+		textAreaRef: { current: null },
+		lastMessage: last,
+		secondLastMessage: messages.at(-2),
+		clineAsk: last?.type === "ask" ? last.ask : undefined,
+		task: messages.at(0),
+		handleFocusChange: vi.fn(),
+		clearExpandedRows: vi.fn(),
+		resetState: vi.fn(),
+	} as unknown as ChatState
+	return { ...state, ...overrides } as ChatState
+}
+
+const completedConversation: ClineMessage[] = [
+	{ ts: 1, type: "say", say: "text", text: "task" },
+	{ ts: 2, type: "say", say: "completion_result", text: "all done" },
+]
+
+describe("useMessageHandlers — send routing", () => {
+	beforeEach(() => {
+		newTask.mockReset()
+		newTask.mockResolvedValue(undefined)
+		askResponse.mockReset()
+		askResponse.mockResolvedValue(undefined)
+		condense.mockReset()
+		condense.mockResolvedValue(undefined)
+		trackIntent.mockReset()
+		trackIntent.mockResolvedValue(undefined)
+		mockTurnState = undefined
+	})
+
+	it("routes /compact to the condense RPC instead of sending it as a message", async () => {
+		mockTurnState = { phase: "completed", seq: 7 }
+		const { result } = renderHook(() => useMessageHandlers(completedConversation, makeChatState(completedConversation)))
+
+		await act(async () => {
+			await result.current.handleSendMessage("/compact", [], [])
+		})
+
+		expect(condense).toHaveBeenCalledTimes(1)
+		expect(condense).toHaveBeenCalledWith(expect.objectContaining({ value: "compact" }))
+		expect(newTask).not.toHaveBeenCalled()
+		expect(askResponse).not.toHaveBeenCalled()
+		expect(trackIntent).not.toHaveBeenCalled()
+	})
+
+	it("routes the /smol alias to the condense RPC as well", async () => {
+		mockTurnState = { phase: "completed", seq: 7 }
+		const { result } = renderHook(() => useMessageHandlers(completedConversation, makeChatState(completedConversation)))
+
+		await act(async () => {
+			await result.current.handleSendMessage("/smol", [], [])
+		})
+
+		expect(condense).toHaveBeenCalledTimes(1)
+		expect(newTask).not.toHaveBeenCalled()
+		expect(askResponse).not.toHaveBeenCalled()
+		expect(trackIntent).not.toHaveBeenCalled()
+	})
+
+	it("does not intercept /compact when there is no active task (starts a new task instead)", async () => {
+		mockTurnState = { phase: "idle", seq: 1 }
+		const { result } = renderHook(() => useMessageHandlers([], makeChatState([])))
+
+		await act(async () => {
+			await result.current.handleSendMessage("/compact", [], [])
+		})
+
+		expect(condense).not.toHaveBeenCalled()
+		expect(newTask).toHaveBeenCalledTimes(1)
+		expect(trackIntent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				action: "prompt_submitted",
+				source: "chat_submit",
+				hasText: true,
+				hasImages: false,
+				hasFiles: false,
+				hasActiveTask: false,
+				textLength: "/compact".length,
+			}),
+		)
+	})
+
+	it("after a completed turn (no clineAsk), Enter continues the conversation via askResponse — NOT newTask", async () => {
+		mockTurnState = { phase: "completed", seq: 7 }
+		const { result } = renderHook(() => useMessageHandlers(completedConversation, makeChatState(completedConversation)))
+
+		await act(async () => {
+			await result.current.handleSendMessage("another question", [], [])
+		})
+
+		expect(newTask).not.toHaveBeenCalled()
+		expect(askResponse).toHaveBeenCalledTimes(1)
+		expect(askResponse).toHaveBeenCalledWith(
+			expect.objectContaining({ responseType: "messageResponse", text: "another question" }),
+		)
+		expect(trackIntent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				action: "prompt_submitted",
+				source: "chat_submit",
+				hasText: true,
+				hasImages: false,
+				hasFiles: false,
+				hasActiveTask: true,
+				textLength: "another question".length,
+			}),
+		)
+	})
+
+	it("shows pending composer state before a follow-up askResponse resolves", async () => {
+		mockTurnState = { phase: "completed", seq: 7 }
+		let resolveAskResponse: () => void = () => {}
+		askResponse.mockImplementationOnce(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveAskResponse = resolve
+				}),
+		)
+		const setInputValue = vi.fn()
+		const setActiveQuote = vi.fn()
+		const setSendingDisabled = vi.fn()
+		const setSelectedImages = vi.fn()
+		const setSelectedFiles = vi.fn()
+		const setEnableButtons = vi.fn()
+		const setPendingUserMessage = vi.fn()
+		const chatState = makeChatState(completedConversation, {
+			activeQuote: "selected context",
+			sendingDisabled: false,
+			enableButtons: true,
+			setInputValue,
+			setActiveQuote,
+			setSendingDisabled,
+			setSelectedImages,
+			setSelectedFiles,
+			setEnableButtons,
+			setPendingUserMessage,
+		})
+		const { result } = renderHook(() => useMessageHandlers(completedConversation, chatState))
+
+		let sendPromise: Promise<void> = Promise.resolve()
+		await act(async () => {
+			sendPromise = result.current.handleSendMessage("another question", ["image.png"], ["a.ts"])
+			await Promise.resolve()
+		})
+
+		expect(askResponse).toHaveBeenCalledWith(
+			expect.objectContaining({
+				responseType: "messageResponse",
+				text: expect.stringContaining("another question"),
+				images: ["image.png"],
+				files: ["a.ts"],
+			}),
+		)
+		expect(setInputValue).toHaveBeenCalledWith("")
+		expect(setActiveQuote).toHaveBeenCalledWith(null)
+		expect(setSendingDisabled).toHaveBeenCalledWith(true)
+		expect(setSelectedImages).toHaveBeenCalledWith([])
+		expect(setSelectedFiles).toHaveBeenCalledWith([])
+		expect(setEnableButtons).toHaveBeenCalledWith(false)
+		expect(setPendingUserMessage).toHaveBeenCalledWith(
+			expect.objectContaining({
+				afterTs: 2,
+				message: expect.objectContaining({
+					type: "say",
+					say: "user_feedback",
+					text: expect.stringContaining("another question"),
+					images: ["image.png"],
+					files: ["a.ts"],
+					partial: false,
+				}),
+			}),
+		)
+
+		await act(async () => {
+			resolveAskResponse()
+			await sendPromise
+		})
+	})
+
+	it("restores pending follow-up UI state when askResponse fails", async () => {
+		mockTurnState = { phase: "completed", seq: 7 }
+		const error = new Error("transport down")
+		const setInputValue = vi.fn()
+		const setActiveQuote = vi.fn()
+		const setSendingDisabled = vi.fn()
+		const setSelectedImages = vi.fn()
+		const setSelectedFiles = vi.fn()
+		const setEnableButtons = vi.fn()
+		const setPendingUserMessage = vi.fn()
+		const chatState = makeChatState(completedConversation, {
+			activeQuote: "selected context",
+			sendingDisabled: false,
+			enableButtons: true,
+			setInputValue,
+			setActiveQuote,
+			setSendingDisabled,
+			setSelectedImages,
+			setSelectedFiles,
+			setEnableButtons,
+			setPendingUserMessage,
+		})
+		const { result } = renderHook(() => useMessageHandlers(completedConversation, chatState))
+		askResponse.mockRejectedValueOnce(error)
+
+		let caught: unknown
+		await act(async () => {
+			try {
+				await result.current.handleSendMessage("another question", ["image.png"], ["a.ts"])
+			} catch (err) {
+				caught = err
+			}
+		})
+
+		expect(caught).toBe(error)
+		expect(setInputValue).toHaveBeenNthCalledWith(1, "")
+		expect(setInputValue).toHaveBeenLastCalledWith("another question")
+		expect(setActiveQuote).toHaveBeenNthCalledWith(1, null)
+		expect(setActiveQuote).toHaveBeenLastCalledWith("selected context")
+		expect(setSendingDisabled).toHaveBeenNthCalledWith(1, true)
+		expect(setSendingDisabled).toHaveBeenLastCalledWith(false)
+		expect(setSelectedImages).toHaveBeenNthCalledWith(1, [])
+		expect(setSelectedImages).toHaveBeenLastCalledWith(["image.png"])
+		expect(setSelectedFiles).toHaveBeenNthCalledWith(1, [])
+		expect(setSelectedFiles).toHaveBeenLastCalledWith(["a.ts"])
+		expect(setEnableButtons).toHaveBeenNthCalledWith(1, false)
+		expect(setEnableButtons).toHaveBeenLastCalledWith(true)
+		expect(setPendingUserMessage).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({
+				afterTs: 2,
+				message: expect.objectContaining({
+					type: "say",
+					say: "user_feedback",
+					text: expect.stringContaining("another question"),
+				}),
+			}),
+		)
+		expect(setPendingUserMessage).toHaveBeenLastCalledWith(undefined)
+	})
+
+	it("does not show a pending chat bubble for a streaming follow-up that will be queued", async () => {
+		mockTurnState = { phase: "streaming", seq: 9 }
+		const streamingConversation: ClineMessage[] = [
+			{ ts: 1, type: "say", say: "task", text: "task" },
+			{ ts: 2, type: "say", say: "text", text: "working", partial: true },
+		]
+		const setPendingUserMessage = vi.fn()
+		const { result } = renderHook(() =>
+			useMessageHandlers(streamingConversation, makeChatState(streamingConversation, { setPendingUserMessage })),
+		)
+
+		await act(async () => {
+			await result.current.handleSendMessage("steer this way", [], [])
+		})
+
+		expect(askResponse).toHaveBeenCalledTimes(1)
+		expect(setPendingUserMessage).not.toHaveBeenCalled()
+	})
+
+	it("rejects a pending approval when the composer is submitted with typed feedback", async () => {
+		mockTurnState = { phase: "awaiting_approval", anchorTs: 2, seq: 9 }
+		const approvalConversation: ClineMessage[] = [
+			{ ts: 1, type: "say", say: "task", text: "task" },
+			{ ts: 2, type: "ask", ask: "tool", text: JSON.stringify({ tool: "newFileCreated", path: "notes.txt" }) },
+		]
+		const setPendingUserMessage = vi.fn()
+		const { result } = renderHook(() =>
+			useMessageHandlers(approvalConversation, makeChatState(approvalConversation, { setPendingUserMessage })),
+		)
+
+		await act(async () => {
+			await result.current.handleSendMessage("use a different filename", ["image.png"], ["notes.txt"])
+		})
+
+		expect(newTask).not.toHaveBeenCalled()
+		expect(condense).not.toHaveBeenCalled()
+		expect(askResponse).toHaveBeenCalledTimes(1)
+		expect(askResponse).toHaveBeenCalledWith(
+			expect.objectContaining({
+				responseType: "noButtonClicked",
+				text: "use a different filename",
+				images: ["image.png"],
+				files: ["notes.txt"],
+			}),
+		)
+		expect(askResponse).not.toHaveBeenCalledWith(expect.objectContaining({ responseType: "messageResponse" }))
+		expect(setPendingUserMessage).not.toHaveBeenCalled()
+	})
+
+	it("phase awaiting_followup also routes a follow-up to askResponse", async () => {
+		mockTurnState = { phase: "awaiting_followup", seq: 3 }
+		const { result } = renderHook(() => useMessageHandlers(completedConversation, makeChatState(completedConversation)))
+
+		await act(async () => {
+			await result.current.handleSendMessage("more info", [], [])
+		})
+
+		expect(newTask).not.toHaveBeenCalled()
+		expect(askResponse).toHaveBeenCalledTimes(1)
+	})
+
+	it("does not show a pending chat bubble when answering an active follow-up question with freeform text", async () => {
+		mockTurnState = { phase: "awaiting_followup", anchorTs: 2, seq: 3 }
+		const questionConversation: ClineMessage[] = [
+			{ ts: 1, type: "say", say: "task", text: "task" },
+			{
+				ts: 2,
+				type: "ask",
+				ask: "followup",
+				text: JSON.stringify({ question: "Which approach?", options: ["A", "B"] }),
+			},
+		]
+		const setPendingUserMessage = vi.fn()
+		const { result } = renderHook(() =>
+			useMessageHandlers(questionConversation, makeChatState(questionConversation, { setPendingUserMessage })),
+		)
+
+		await act(async () => {
+			await result.current.handleSendMessage("something else", [], [])
+		})
+
+		expect(askResponse).toHaveBeenCalledTimes(1)
+		expect(askResponse).toHaveBeenCalledWith(
+			expect.objectContaining({ responseType: "messageResponse", text: "something else" }),
+		)
+		expect(setPendingUserMessage).not.toHaveBeenCalled()
+	})
+
+	it("an empty transcript still starts a NEW task (unchanged behavior)", async () => {
+		mockTurnState = { phase: "idle", seq: 1 }
+		const { result } = renderHook(() => useMessageHandlers([], makeChatState([])))
+
+		await act(async () => {
+			await result.current.handleSendMessage("brand new task", [], [])
+		})
+
+		expect(newTask).toHaveBeenCalledTimes(1)
+		expect(askResponse).not.toHaveBeenCalled()
+		expect(trackIntent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				action: "prompt_submitted",
+				source: "chat_submit",
+				hasText: true,
+				hasImages: false,
+				hasFiles: false,
+				hasActiveTask: false,
+				textLength: "brand new task".length,
+			}),
+		)
+	})
+
+	it("restores pending new-task UI state when the RPC fails", async () => {
+		mockTurnState = { phase: "idle", seq: 1 }
+		const error = new Error("transport down")
+		const setInputValue = vi.fn()
+		const setActiveQuote = vi.fn()
+		const setSendingDisabled = vi.fn()
+		const setSelectedImages = vi.fn()
+		const setSelectedFiles = vi.fn()
+		const setEnableButtons = vi.fn()
+		const chatState = makeChatState([], {
+			activeQuote: "selected context",
+			sendingDisabled: false,
+			enableButtons: true,
+			setInputValue,
+			setActiveQuote,
+			setSendingDisabled,
+			setSelectedImages,
+			setSelectedFiles,
+			setEnableButtons,
+		})
+		const { result } = renderHook(() => useMessageHandlers([], chatState))
+		newTask.mockRejectedValueOnce(error)
+
+		let caught: unknown
+		await act(async () => {
+			try {
+				await result.current.handleSendMessage("brand new task", ["image.png"], ["a.ts"])
+			} catch (err) {
+				caught = err
+			}
+		})
+
+		expect(caught).toBe(error)
+		expect(newTask).toHaveBeenCalledWith(
+			expect.objectContaining({
+				text: expect.stringContaining("selected context"),
+				images: ["image.png"],
+				files: ["a.ts"],
+			}),
+		)
+		expect(setInputValue).toHaveBeenNthCalledWith(1, "")
+		expect(setInputValue).toHaveBeenLastCalledWith("brand new task")
+		expect(setActiveQuote).toHaveBeenNthCalledWith(1, null)
+		expect(setActiveQuote).toHaveBeenLastCalledWith("selected context")
+		expect(setSendingDisabled).toHaveBeenNthCalledWith(1, true)
+		expect(setSendingDisabled).toHaveBeenLastCalledWith(false)
+		expect(setSelectedImages).toHaveBeenNthCalledWith(1, [])
+		expect(setSelectedImages).toHaveBeenLastCalledWith(["image.png"])
+		expect(setSelectedFiles).toHaveBeenNthCalledWith(1, [])
+		expect(setSelectedFiles).toHaveBeenLastCalledWith(["a.ts"])
+		expect(setEnableButtons).toHaveBeenNthCalledWith(1, false)
+		expect(setEnableButtons).toHaveBeenLastCalledWith(true)
+	})
+
+	// The webview does not gate sends on provider usability: submission always
+	// reaches the extension, which surfaces auth/config problems as chat errors
+	// (emitClineAuthError for the Cline provider, say:"error" otherwise).
+	it("always forwards a new task to the extension (no webview-side provider gate)", async () => {
+		mockTurnState = { phase: "idle", seq: 1 }
+		const { result } = renderHook(() => useMessageHandlers([], makeChatState([])))
+
+		await act(async () => {
+			await result.current.handleSendMessage("should be sent", [], [])
+		})
+
+		expect(newTask).toHaveBeenCalledTimes(1)
+		expect(newTask).toHaveBeenCalledWith(expect.objectContaining({ text: "should be sent", images: [], files: [] }))
+		expect(askResponse).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useMessageHandlers.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useMessageHandlers.ts
new file mode 100644
index 0000000..11cab47
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useMessageHandlers.ts
@@ -0,0 +1,452 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { EmptyRequest, StringRequest } from "@shared/proto/cline/common"
+import { AskResponseRequest, NewTaskRequest } from "@shared/proto/cline/task"
+import { IntentEvent } from "@shared/proto/cline/ui"
+import { useCallback, useRef } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { SlashServiceClient, TaskServiceClient, UiServiceClient } from "@/services/grpc-client"
+import type { ButtonActionType } from "../shared/buttonConfig"
+import type { ChatState, MessageHandlers } from "../types/chatTypes"
+
+/**
+ * Custom hook for managing message handlers
+ * Handles sending messages, button clicks, and task management
+ */
+export function useMessageHandlers(messages: ClineMessage[], chatState: ChatState): MessageHandlers {
+	const { backgroundCommandRunning, turnState } = useExtensionState()
+	const {
+		setInputValue,
+		activeQuote,
+		setActiveQuote,
+		setSelectedImages,
+		setSelectedFiles,
+		sendingDisabled,
+		setSendingDisabled,
+		enableButtons,
+		setEnableButtons,
+		setPendingUserMessage,
+		clineAsk,
+		lastMessage,
+	} = chatState
+	const cancelInFlightRef = useRef(false)
+
+	// Handle sending a message
+	const handleSendMessage = useCallback(
+		async (text: string, images: string[], files: string[]) => {
+			let messageToSend = text.trim()
+			const hasContent = messageToSend || images.length > 0 || files.length > 0
+
+			// Prepend the active quote if it exists
+			if (activeQuote && hasContent) {
+				const prefix = "[context] \n> "
+				const formattedQuote = activeQuote
+				const suffix = "\n[/context] \n\n"
+				messageToSend = `${prefix} ${formattedQuote} ${suffix} ${messageToSend}`
+			}
+
+			// Intercept the built-in compaction commands when an active task exists.
+			// `/compact` (and its alias `/smol`) must run a real SDK manual
+			// compaction via the condense RPC — sending the literal text to the
+			// model would make it improvise a fake summary instead of compacting
+			// the context window (CLINE-2503). With no active task there is nothing
+			// to compact, so fall through to normal new-task handling.
+			if (messages.length > 0 && (messageToSend === "/compact" || messageToSend === "/smol")) {
+				await SlashServiceClient.condense(StringRequest.create({ value: "compact" })).catch((err) =>
+					console.error("Failed to compact task:", err),
+				)
+				setInputValue("")
+				setActiveQuote(null)
+				if ("disableAutoScrollRef" in chatState) {
+					;(chatState as any).disableAutoScrollRef.current = false
+				}
+				return
+			}
+
+			if (hasContent) {
+				console.log("[ChatView] handleSendMessage - Sending message:", messageToSend)
+				let messageSent = false
+				const trackPromptSubmitted = (hasActiveTask: boolean) => {
+					UiServiceClient.trackIntent(
+						IntentEvent.create({
+							action: "prompt_submitted",
+							source: "chat_submit",
+							hasText: messageToSend.length > 0,
+							hasImages: images.length > 0,
+							hasFiles: files.length > 0,
+							hasActiveTask,
+							textLength: messageToSend.length,
+						}),
+					).catch((error) => console.error("Failed to track prompt submit:", error))
+				}
+				const clearSentMessageState = () => {
+					setInputValue("")
+					setActiveQuote(null)
+					setSendingDisabled(true)
+					setSelectedImages([])
+					setSelectedFiles([])
+					setEnableButtons(false)
+				}
+				const restorePendingMessageState = () => {
+					setInputValue(text)
+					setActiveQuote(activeQuote)
+					setSendingDisabled(sendingDisabled)
+					setSelectedImages(images)
+					setSelectedFiles(files)
+					setEnableButtons(enableButtons)
+				}
+				const sendAskResponseWithPendingState = async (
+					request: ReturnType<typeof AskResponseRequest.create>,
+					options: { showPendingMessage?: boolean } = {},
+				) => {
+					trackPromptSubmitted(true)
+					clearSentMessageState()
+					if (options.showPendingMessage) {
+						const afterTs = Math.max(0, ...messages.map((message) => message.ts))
+						setPendingUserMessage({
+							afterTs,
+							message: {
+								ts: Date.now(),
+								type: "say",
+								say: "user_feedback",
+								text: request.text ?? "",
+								images: request.images,
+								files: request.files,
+								partial: false,
+							},
+						})
+					}
+					try {
+						await TaskServiceClient.askResponse(request)
+					} catch (error) {
+						if (options.showPendingMessage) {
+							setPendingUserMessage(undefined)
+						}
+						restorePendingMessageState()
+						throw error
+					}
+				}
+
+				if (messages.length === 0) {
+					const request = NewTaskRequest.create({
+						text: messageToSend,
+						images,
+						files,
+					})
+					clearSentMessageState()
+					trackPromptSubmitted(false)
+					try {
+						await TaskServiceClient.newTask(request)
+					} catch (error) {
+						restorePendingMessageState()
+						throw error
+					}
+					messageSent = true
+				} else if (turnState?.phase === "awaiting_approval") {
+					await sendAskResponseWithPendingState(
+						AskResponseRequest.create({
+							responseType: "noButtonClicked",
+							text: messageToSend,
+							images,
+							files,
+						}),
+					)
+					messageSent = true
+				} else if (clineAsk) {
+					// For resume_task and resume_completed_task, use yesButtonClicked to match Resume button behavior
+					// This ensures Enter key and Resume button work identically
+					if (clineAsk === "resume_task" || clineAsk === "resume_completed_task") {
+						await sendAskResponseWithPendingState(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+								text: messageToSend,
+								images,
+								files,
+							}),
+						)
+						messageSent = true
+					} else {
+						// All other ask types use messageResponse
+						switch (clineAsk) {
+							case "followup":
+							case "plan_mode_respond":
+							case "tool":
+							case "browser_action_launch":
+							case "command":
+							case "command_output":
+							case "use_mcp_server":
+							case "use_subagents":
+							case "completion_result":
+							case "mistake_limit_reached":
+							case "api_req_failed":
+							case "new_task":
+							case "condense":
+							case "report_bug": {
+								// Most askResponse sends need a temporary webview-only user bubble because the
+								// extension will not echo the user's message until later. Active follow-up
+								// questions are the exception: they are backed by the SDK's pending ask_question
+								// resolver. When the user types a freeform answer instead of clicking one of the
+								// option buttons, that resolver consumes the response before normal follow-up
+								// routing and immediately appends the real say:user_feedback row. If we also add
+								// an optimistic pending row here, the chat shows the same answer twice.
+								const showPendingMessage = clineAsk !== "followup" && turnState?.phase !== "streaming"
+
+								await sendAskResponseWithPendingState(
+									AskResponseRequest.create({
+										responseType: "messageResponse",
+										text: messageToSend,
+										images,
+										files,
+									}),
+									{ showPendingMessage },
+								)
+								messageSent = true
+								break
+							}
+						}
+					}
+				} else if (messages.length > 0) {
+					// No clineAsk set, but there is an existing conversation. Route this to the
+					// active session as a follow-up when either:
+					//
+					//   1. The authoritative turnState says the conversation is continuable —
+					//      phases "completed" / "awaiting_followup" (the agent finished or is
+					//      waiting for the user) or "streaming" (interrupt with feedback). The SDK
+					//      does not emit a trailing ask:"completion_result", so clineAsk is
+					//      undefined even when the user can keep talking; turnState is the source
+					//      of truth.
+					//   2. Legacy fallback (no turnState): the task looks actively running from the
+					//      message tail.
+					const lastMessage = messages[messages.length - 1]
+					const isTaskRunning =
+						lastMessage.partial === true || (lastMessage.type === "say" && lastMessage.say === "api_req_started")
+					const turnAllowsFollowup =
+						turnState?.phase === "completed" ||
+						turnState?.phase === "awaiting_followup" ||
+						turnState?.phase === "streaming"
+
+					if (turnAllowsFollowup || isTaskRunning) {
+						// Continue the conversation / interrupt with feedback.
+						await sendAskResponseWithPendingState(
+							AskResponseRequest.create({
+								responseType: "messageResponse",
+								text: messageToSend,
+								images,
+								files,
+							}),
+							{
+								showPendingMessage: turnState?.phase === "completed" || turnState?.phase === "awaiting_followup",
+							},
+						)
+						messageSent = true
+					}
+				}
+
+				// New tasks clear optimistically before the RPC; the repeated success cleanup is idempotent.
+				if (messageSent) {
+					clearSentMessageState()
+
+					// Reset auto-scroll
+					if ("disableAutoScrollRef" in chatState) {
+						;(chatState as any).disableAutoScrollRef.current = false
+					}
+				}
+			}
+		},
+		[
+			messages,
+			clineAsk,
+			turnState,
+			activeQuote,
+			setInputValue,
+			setActiveQuote,
+			sendingDisabled,
+			setSendingDisabled,
+			setSelectedImages,
+			setSelectedFiles,
+			enableButtons,
+			setEnableButtons,
+			setPendingUserMessage,
+			chatState,
+		],
+	)
+
+	// Start a new task
+	const startNewTask = useCallback(async () => {
+		UiServiceClient.trackIntent(
+			IntentEvent.create({
+				action: "new_task_clicked",
+				source: "chat_new_task",
+				hasActiveTask: messages.length > 0,
+			}),
+		).catch((error) => console.error("Failed to track new task click:", error))
+		setActiveQuote(null)
+		await TaskServiceClient.clearTask(EmptyRequest.create({}))
+	}, [messages.length, setActiveQuote])
+
+	// Clear input state helper
+	const clearInputState = useCallback(() => {
+		setInputValue("")
+		setActiveQuote(null)
+		setSelectedImages([])
+		setSelectedFiles([])
+	}, [setInputValue, setActiveQuote, setSelectedImages, setSelectedFiles])
+
+	// Execute button action based on type
+	const executeButtonAction = useCallback(
+		async (actionType: ButtonActionType, text?: string, images?: string[], files?: string[]) => {
+			const trimmedInput = text?.trim()
+			const hasContent = trimmedInput || (images && images.length > 0) || (files && files.length > 0)
+
+			switch (actionType) {
+				case "retry":
+					// For API retry (api_req_failed), always send simple approval without content
+					await TaskServiceClient.askResponse(
+						AskResponseRequest.create({
+							responseType: "yesButtonClicked",
+						}),
+					)
+					clearInputState()
+					break
+				case "approve":
+					if (hasContent) {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+								text: trimmedInput,
+								images: images,
+								files: files,
+							}),
+						)
+					} else {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+							}),
+						)
+					}
+					clearInputState()
+					break
+
+				case "reject":
+					if (hasContent) {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "noButtonClicked",
+								text: trimmedInput,
+								images: images,
+								files: files,
+							}),
+						)
+					} else {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "noButtonClicked",
+							}),
+						)
+					}
+					clearInputState()
+					break
+
+				case "proceed":
+					if (hasContent) {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+								text: trimmedInput,
+								images: images,
+								files: files,
+							}),
+						)
+					} else {
+						await TaskServiceClient.askResponse(
+							AskResponseRequest.create({
+								responseType: "yesButtonClicked",
+							}),
+						)
+					}
+					clearInputState()
+					break
+
+				case "new_task":
+					if (clineAsk === "new_task") {
+						await TaskServiceClient.newTask(
+							NewTaskRequest.create({
+								text: lastMessage?.text,
+								images: [],
+								files: [],
+							}),
+						)
+					} else {
+						await startNewTask()
+					}
+					break
+
+				case "cancel": {
+					if (cancelInFlightRef.current) {
+						return
+					}
+					cancelInFlightRef.current = true
+					setSendingDisabled(true)
+					setEnableButtons(false)
+					try {
+						if (backgroundCommandRunning) {
+							await TaskServiceClient.cancelBackgroundCommand(EmptyRequest.create({})).catch((err) =>
+								console.error("Failed to cancel background command:", err),
+							)
+						}
+						await TaskServiceClient.cancelTask(EmptyRequest.create({}))
+					} finally {
+						cancelInFlightRef.current = false
+						// Clear any pending state that might interfere with resume
+						setSendingDisabled(false)
+						setEnableButtons(true)
+					}
+					break
+				}
+
+				case "utility":
+					switch (clineAsk) {
+						case "condense":
+							await SlashServiceClient.condense(StringRequest.create({ value: lastMessage?.text })).catch((err) =>
+								console.error(err),
+							)
+							break
+						case "report_bug":
+							await SlashServiceClient.reportBug(StringRequest.create({ value: lastMessage?.text })).catch((err) =>
+								console.error(err),
+							)
+							break
+					}
+					break
+			}
+
+			if ("disableAutoScrollRef" in chatState) {
+				;(chatState as any).disableAutoScrollRef.current = false
+			}
+		},
+		[
+			clineAsk,
+			lastMessage,
+			messages,
+			clearInputState,
+			handleSendMessage,
+			startNewTask,
+			chatState,
+			backgroundCommandRunning,
+			setSendingDisabled,
+			setEnableButtons,
+		],
+	)
+
+	// Handle task close button click
+	const handleTaskCloseButtonClick = useCallback(() => {
+		startNewTask()
+	}, [startNewTask])
+
+	return {
+		handleSendMessage,
+		executeButtonAction,
+		handleTaskCloseButtonClick,
+		startNewTask,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useScrollBehavior.test.tsx b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useScrollBehavior.test.tsx
new file mode 100644
index 0000000..54a39ed
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useScrollBehavior.test.tsx
@@ -0,0 +1,110 @@
+import { act, renderHook } from "@testing-library/react"
+import type { MutableRefObject } from "react"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { useScrollBehavior } from "./useScrollBehavior"
+
+const commandMessage = {
+	ts: 1,
+	type: "ask",
+	ask: "command",
+	text: "echo hi",
+}
+
+describe("useScrollBehavior", () => {
+	beforeEach(() => {
+		vi.useFakeTimers()
+	})
+
+	afterEach(() => {
+		vi.useRealTimers()
+	})
+
+	it("scrolls to bottom after command output layout has been quiet for 500ms", () => {
+		const { result } = renderHook(() => useScrollBehavior([], [], [], {}, vi.fn()))
+		const scrollTo = vi.fn()
+		act(() => {
+			vi.runOnlyPendingTimers()
+		})
+		;(result.current.virtuosoRef as MutableRefObject<{ scrollTo: typeof scrollTo } | null>).current = { scrollTo }
+
+		act(() => {
+			result.current.handleLastRowContentChange()
+		})
+
+		expect(scrollTo).not.toHaveBeenCalled()
+
+		act(() => {
+			vi.advanceTimersByTime(499)
+		})
+		expect(scrollTo).not.toHaveBeenCalled()
+
+		act(() => {
+			vi.advanceTimersByTime(1)
+		})
+		expect(scrollTo).toHaveBeenCalledWith({
+			top: Number.MAX_SAFE_INTEGER,
+			behavior: "smooth",
+		})
+	})
+
+	it("resets the 500ms wait when another command output change arrives", () => {
+		const { result } = renderHook(() => useScrollBehavior([], [], [], {}, vi.fn()))
+		const scrollTo = vi.fn()
+		act(() => {
+			vi.runOnlyPendingTimers()
+		})
+		;(result.current.virtuosoRef as MutableRefObject<{ scrollTo: typeof scrollTo } | null>).current = { scrollTo }
+
+		act(() => {
+			result.current.handleLastRowContentChange()
+			scrollTo.mockClear()
+			vi.advanceTimersByTime(400)
+			result.current.handleLastRowContentChange()
+			scrollTo.mockClear()
+			vi.advanceTimersByTime(499)
+		})
+		expect(scrollTo).not.toHaveBeenCalled()
+
+		act(() => {
+			vi.advanceTimersByTime(1)
+		})
+		expect(scrollTo).toHaveBeenCalledWith({
+			top: Number.MAX_SAFE_INTEGER,
+			behavior: "smooth",
+		})
+	})
+
+	it("does not re-pin command output changes after auto-scroll is disabled", () => {
+		const { result } = renderHook(() => useScrollBehavior([], [], [], {}, vi.fn()))
+		const scrollTo = vi.fn()
+		;(result.current.virtuosoRef as MutableRefObject<{ scrollTo: typeof scrollTo } | null>).current = { scrollTo }
+
+		act(() => {
+			result.current.disableAutoScrollRef.current = true
+			result.current.handleLastRowContentChange()
+			vi.runAllTimers()
+		})
+
+		expect(scrollTo).not.toHaveBeenCalled()
+	})
+
+	it("disables auto-scroll when a user expands a row", () => {
+		const { result } = renderHook(() => useScrollBehavior([], [], [commandMessage as any], {}, vi.fn()))
+
+		act(() => {
+			result.current.toggleRowExpansion(commandMessage.ts)
+		})
+
+		expect(result.current.disableAutoScrollRef.current).toBe(true)
+	})
+
+	it("keeps auto-scroll enabled when command output expands programmatically", () => {
+		const { result } = renderHook(() => useScrollBehavior([], [], [commandMessage as any], {}, vi.fn()))
+
+		act(() => {
+			result.current.toggleRowExpansion(commandMessage.ts, { preserveAutoScroll: true })
+		})
+
+		expect(result.current.disableAutoScrollRef.current).toBe(false)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useScrollBehavior.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useScrollBehavior.ts
new file mode 100644
index 0000000..0a57859
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/hooks/useScrollBehavior.ts
@@ -0,0 +1,350 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import debounce from "debounce"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useEvent } from "react-use"
+import { ListRange, VirtuosoHandle } from "react-virtuoso"
+import { ScrollBehavior } from "../types/chatTypes"
+
+// Height of the sticky user message header (padding + content)
+const STICKY_HEADER_HEIGHT = 32
+
+/**
+ * Custom hook for managing scroll behavior
+ * Handles auto-scrolling, manual scrolling, and scroll-to-message functionality
+ */
+export function useScrollBehavior(
+	messages: ClineMessage[],
+	visibleMessages: ClineMessage[],
+	groupedMessages: (ClineMessage | ClineMessage[])[],
+	expandedRows: Record<number, boolean>,
+	setExpandedRows: React.Dispatch<React.SetStateAction<Record<number, boolean>>>,
+): ScrollBehavior & {
+	isAtBottom: boolean
+	setIsAtBottom: React.Dispatch<React.SetStateAction<boolean>>
+	pendingScrollToMessage: number | null
+	setPendingScrollToMessage: React.Dispatch<React.SetStateAction<number | null>>
+	scrolledPastUserMessage: ClineMessage | null
+	handleRangeChanged: (range: ListRange) => void
+} {
+	// Refs
+	const virtuosoRef = useRef<VirtuosoHandle>(null)
+	const scrollContainerRef = useRef<HTMLDivElement>(null)
+	const disableAutoScrollRef = useRef(false)
+	const layoutSettleScrollTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+	// State
+	const [isAtBottom, setIsAtBottom] = useState(false)
+	const [pendingScrollToMessage, setPendingScrollToMessage] = useState<number | null>(null)
+	const [scrolledPastUserMessage, setScrolledPastUserMessage] = useState<ClineMessage | null>(null)
+
+	// Find all user feedback messages
+	const userFeedbackMessages = useMemo(() => {
+		return visibleMessages.filter((msg) => msg.say === "user_feedback")
+	}, [visibleMessages])
+
+	// Track scroll position to detect which user message has been scrolled past
+	// Shows the most recent user message that's above the current viewport
+	const checkScrolledPastUserMessage = useCallback(() => {
+		const scrollContainer = scrollContainerRef.current
+		if (!scrollContainer || userFeedbackMessages.length === 0) {
+			setScrolledPastUserMessage(null)
+			return
+		}
+
+		const containerRect = scrollContainer.getBoundingClientRect()
+
+		// Find the most recent (last in order) user message that's been scrolled past
+		// We iterate from the end to find the latest one that's above the viewport
+		let mostRecentScrolledPast: ClineMessage | null = null
+
+		// Track if we've found any visible message element in the DOM
+		// This helps us determine if missing elements are above or below viewport
+		let foundAnyVisibleElement = false
+
+		for (let i = userFeedbackMessages.length - 1; i >= 0; i--) {
+			const msg = userFeedbackMessages[i]
+			const messageElement = scrollContainer.querySelector(`[data-message-ts="${msg.ts}"]`) as HTMLElement
+
+			if (messageElement) {
+				foundAnyVisibleElement = true
+				const messageRect = messageElement.getBoundingClientRect()
+				// Message is scrolled past if its bottom edge is above (or near) the container's top
+				// Add a small threshold so the pin appears slightly before message fully scrolls out
+				const threshold = 10
+				if (messageRect.bottom < containerRect.top + threshold) {
+					mostRecentScrolledPast = msg
+					break // Found the most recent one that's scrolled past
+				}
+			} else {
+				// Element not in DOM - it's virtualized out
+				// Only consider it scrolled past if we've already found a visible element after it
+				// (meaning this missing element is above the viewport, not below)
+				if (foundAnyVisibleElement) {
+					mostRecentScrolledPast = msg
+					break
+				}
+				// If we haven't found any visible elements yet, this message might be
+				// below the viewport, so continue looking for visible elements
+			}
+		}
+
+		setScrolledPastUserMessage(mostRecentScrolledPast)
+	}, [userFeedbackMessages])
+
+	// Use scroll event listener - attach to the scrollable element inside the container
+	useEffect(() => {
+		const scrollContainer = scrollContainerRef.current
+		if (!scrollContainer) {
+			return
+		}
+
+		// The scrollable element is the Virtuoso scroller or a child with overflow
+		const findScrollableElement = () => {
+			// Try finding the Virtuoso scroller
+			const virtuosoScroller = scrollContainer.querySelector('[data-virtuoso-scroller="true"]') as HTMLElement
+			if (virtuosoScroller) {
+				return virtuosoScroller
+			}
+			// Fallback to the first child with scrollable class
+			const scrollable = scrollContainer.querySelector(".scrollable") as HTMLElement
+			return scrollable || scrollContainer
+		}
+
+		const scrollableElement = findScrollableElement()
+
+		const handleScroll = () => {
+			checkScrolledPastUserMessage()
+		}
+
+		scrollableElement.addEventListener("scroll", handleScroll, { passive: true })
+
+		// Also check on mount and when dependencies change
+		checkScrolledPastUserMessage()
+
+		return () => {
+			scrollableElement.removeEventListener("scroll", handleScroll)
+		}
+	}, [checkScrolledPastUserMessage])
+
+	// Handler for when visible range changes in Virtuoso (kept for compatibility but not used for sticky)
+	const handleRangeChanged = useCallback((_range: ListRange) => {
+		// Range changed callback - we now use scroll position instead
+		// but keep this for potential future use
+	}, [])
+	const scrollToBottomSmooth = useMemo(
+		() =>
+			debounce(
+				() => {
+					virtuosoRef.current?.scrollTo({
+						top: Number.MAX_SAFE_INTEGER,
+						behavior: "smooth",
+					})
+				},
+				10,
+				{ immediate: true },
+			),
+		[],
+	)
+
+	// Smooth scroll to bottom with debounce
+	const scrollToBottomAuto = useCallback(() => {
+		virtuosoRef.current?.scrollTo({
+			top: Number.MAX_SAFE_INTEGER,
+			behavior: "auto", // instant causes crash
+		})
+	}, [])
+
+	const scrollToMessage = useCallback(
+		(messageIndex: number) => {
+			setPendingScrollToMessage(messageIndex)
+
+			const targetMessage = messages[messageIndex]
+			if (!targetMessage) {
+				setPendingScrollToMessage(null)
+				return
+			}
+
+			const visibleIndex = visibleMessages.findIndex((msg) => msg.ts === targetMessage.ts)
+			if (visibleIndex === -1) {
+				setPendingScrollToMessage(null)
+				return
+			}
+
+			let groupIndex = -1
+
+			for (let i = 0; i < groupedMessages.length; i++) {
+				const group = groupedMessages[i]
+				if (Array.isArray(group)) {
+					const messageInGroup = group.some((msg) => msg.ts === targetMessage.ts)
+					if (messageInGroup) {
+						groupIndex = i
+						break
+					}
+				} else {
+					if (group.ts === targetMessage.ts) {
+						groupIndex = i
+						break
+					}
+				}
+			}
+
+			if (groupIndex !== -1) {
+				setPendingScrollToMessage(null)
+				disableAutoScrollRef.current = true
+
+				// Check if this is the first user feedback message (no sticky header would show when scrolling to it)
+				const isFirstUserMessage =
+					groupIndex === 0 || !visibleMessages.slice(0, visibleIndex).some((msg) => msg.say === "user_feedback")
+
+				const stickyHeaderOffset = isFirstUserMessage ? 0 : STICKY_HEADER_HEIGHT
+
+				// Use scrollToIndex with offset - Virtuoso handles this more reliably than manual scrollTo
+				requestAnimationFrame(() => {
+					virtuosoRef.current?.scrollToIndex({
+						index: groupIndex,
+						align: "start",
+						behavior: "smooth",
+						offset: -stickyHeaderOffset,
+					})
+				})
+			}
+		},
+		[messages, visibleMessages, groupedMessages],
+	)
+
+	// scroll when user toggles certain rows
+	const toggleRowExpansion = useCallback(
+		(ts: number, options?: { preserveAutoScroll?: boolean }) => {
+			const isCollapsing = expandedRows[ts] ?? false
+			const lastGroup = groupedMessages.at(-1)
+			const isLast = Array.isArray(lastGroup) ? lastGroup[0].ts === ts : lastGroup?.ts === ts
+			const secondToLastGroup = groupedMessages.at(-2)
+			const isSecondToLast = Array.isArray(secondToLastGroup)
+				? secondToLastGroup[0].ts === ts
+				: secondToLastGroup?.ts === ts
+
+			const isLastCollapsedApiReq =
+				isLast &&
+				!Array.isArray(lastGroup) && // Make sure it's not a browser session group
+				lastGroup?.say === "api_req_started" &&
+				!expandedRows[lastGroup.ts]
+
+			setExpandedRows((prev) => ({
+				...prev,
+				[ts]: !prev[ts],
+			}))
+
+			// Disable auto-scroll when the user expands a row. Programmatic expansions
+			// for active command output should keep bottom pinning engaged.
+			if (!isCollapsing && !options?.preserveAutoScroll) {
+				disableAutoScrollRef.current = true
+			}
+			// Only scroll on collapse, never on expand - expanding should stay in place
+			if (isCollapsing && isAtBottom) {
+				const timer = setTimeout(() => {
+					scrollToBottomAuto()
+				}, 0)
+				return () => clearTimeout(timer)
+			}
+			if (isCollapsing && (isLast || isSecondToLast)) {
+				if (isSecondToLast && !isLastCollapsedApiReq) {
+					return
+				}
+				const timer = setTimeout(() => {
+					scrollToBottomAuto()
+				}, 0)
+				return () => clearTimeout(timer)
+			}
+			// When expanding, don't scroll - let the element expand in place
+		},
+		[groupedMessages, expandedRows, scrollToBottomAuto, isAtBottom],
+	)
+
+	const clearLayoutSettleScrollTimers = useCallback(() => {
+		if (layoutSettleScrollTimerRef.current !== null) {
+			clearTimeout(layoutSettleScrollTimerRef.current)
+			layoutSettleScrollTimerRef.current = null
+		}
+	}, [])
+
+	const keepPinnedToBottomAfterLayout = useCallback(() => {
+		if (disableAutoScrollRef.current) {
+			return
+		}
+
+		if (layoutSettleScrollTimerRef.current !== null) {
+			clearTimeout(layoutSettleScrollTimerRef.current)
+		}
+		layoutSettleScrollTimerRef.current = setTimeout(() => {
+			if (!disableAutoScrollRef.current) {
+				scrollToBottomSmooth()
+			}
+			layoutSettleScrollTimerRef.current = null
+		}, 500)
+	}, [scrollToBottomSmooth])
+
+	const handleRowHeightChange = useCallback(
+		(_isTaller: boolean) => {
+			keepPinnedToBottomAfterLayout()
+		},
+		[keepPinnedToBottomAfterLayout],
+	)
+
+	const handleLastRowContentChange = useCallback(() => {
+		keepPinnedToBottomAfterLayout()
+	}, [keepPinnedToBottomAfterLayout])
+
+	useEffect(() => clearLayoutSettleScrollTimers, [clearLayoutSettleScrollTimers])
+
+	useEffect(() => {
+		if (!disableAutoScrollRef.current) {
+			scrollToBottomSmooth()
+			setTimeout(() => {
+				if (!disableAutoScrollRef.current) {
+					scrollToBottomAuto()
+				}
+			}, 40)
+			setTimeout(() => {
+				if (!disableAutoScrollRef.current) {
+					scrollToBottomAuto()
+				}
+			}, 70)
+			// return () => clearTimeout(timer) // dont cleanup since if visibleMessages.length changes it cancels.
+		}
+	}, [groupedMessages.length, scrollToBottomSmooth, scrollToBottomAuto])
+
+	useEffect(() => {
+		if (pendingScrollToMessage !== null) {
+			scrollToMessage(pendingScrollToMessage)
+		}
+	}, [pendingScrollToMessage, groupedMessages, scrollToMessage])
+
+	const handleWheel = useCallback((event: Event) => {
+		const wheelEvent = event as WheelEvent
+		if (wheelEvent.deltaY && wheelEvent.deltaY < 0) {
+			if (scrollContainerRef.current?.contains(wheelEvent.target as Node)) {
+				// user scrolled up
+				disableAutoScrollRef.current = true
+			}
+		}
+	}, [])
+	useEvent("wheel", handleWheel, window, { passive: true }) // passive improves scrolling performance
+
+	return {
+		virtuosoRef,
+		scrollContainerRef,
+		disableAutoScrollRef,
+		scrollToBottomSmooth,
+		scrollToBottomAuto,
+		scrollToMessage,
+		toggleRowExpansion,
+		handleRowHeightChange,
+		handleLastRowContentChange,
+		isAtBottom,
+		setIsAtBottom,
+		pendingScrollToMessage,
+		setPendingScrollToMessage,
+		scrolledPastUserMessage,
+		handleRangeChanged,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/index.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/index.ts
new file mode 100644
index 0000000..034813d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/index.ts
@@ -0,0 +1,16 @@
+/**
+ * Barrel export for chat-view utilities, hooks, components, and types
+ */
+
+// Export layout components
+export * from "./components/layout"
+// Export message components
+export * from "./constants"
+
+// Export hooks
+export * from "./hooks"
+// Export types and constants
+export * from "./types/chatTypes"
+// Export utilities
+export * from "./utils/markdownUtils"
+export * from "./utils/messageUtils"
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/messageReducer.test.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/messageReducer.test.ts
new file mode 100644
index 0000000..685cf72
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/messageReducer.test.ts
@@ -0,0 +1,237 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { describe, expect, it } from "vitest"
+import { applyMessage, applyStateSnapshot, applyTurnState, createReplicaState, type ReplicaState } from "./messageReducer"
+
+function msg(ts: number, seq: number, epoch: number, partial = false, text = `m${ts}`): ClineMessage {
+	return { ts, type: "say", say: "text", text, partial, seq, epoch }
+}
+
+function texts(state: ReplicaState): string[] {
+	return state.messages.map((m) => m.text ?? "")
+}
+
+function tsList(state: ReplicaState): number[] {
+	return state.messages.map((m) => m.ts)
+}
+
+describe("messageReducer — deterministic", () => {
+	it("partial -> final with same ts updates in place (length stays 1, partial ends false)", () => {
+		let s = createReplicaState()
+		s = applyMessage(s, msg(1, 1, 1, true, "Hel"))
+		s = applyMessage(s, msg(1, 2, 1, true, "Hello"))
+		s = applyMessage(s, msg(1, 3, 1, false, "Hello world"))
+		expect(s.messages).toHaveLength(1)
+		expect(s.messages[0].partial).toBe(false)
+		expect(s.messages[0].text).toBe("Hello world")
+	})
+
+	it("a lower-seq copy of an existing ts is ignored (out-of-order delivery)", () => {
+		let s = createReplicaState()
+		s = applyMessage(s, msg(1, 3, 1, false, "final"))
+		s = applyMessage(s, msg(1, 2, 1, true, "stale-partial"))
+		expect(s.messages).toHaveLength(1)
+		expect(s.messages[0].text).toBe("final")
+		expect(s.messages[0].partial).toBe(false)
+	})
+
+	it("RC2: a same-epoch snapshot omitting the last message does NOT shrink the transcript", () => {
+		let s = createReplicaState()
+		s = applyMessage(s, msg(1, 1, 1, false, "task"))
+		s = applyMessage(s, msg(2, 2, 1, false, "text"))
+		const ask: ClineMessage = { ts: 3, type: "ask", ask: "completion_result", text: "", seq: 3, epoch: 1 }
+		s = applyMessage(s, ask)
+		expect(tsList(s)).toEqual([1, 2, 3])
+
+		// A stale full-state snapshot (captured before the ask landed) must NOT drop the ask.
+		const staleSnapshot = [msg(1, 1, 1, false, "task"), msg(2, 2, 1, false, "text")]
+		s = applyStateSnapshot(s, staleSnapshot, 1, 2)
+		expect(tsList(s)).toEqual([1, 2, 3])
+		expect(s.messages[2].ask).toBe("completion_result")
+	})
+
+	it("a newer-epoch snapshot replaces the transcript wholesale", () => {
+		let s = createReplicaState()
+		s = applyMessage(s, msg(1, 1, 1, false, "old-task"))
+		s = applyMessage(s, msg(2, 2, 1, false, "old-text"))
+		s = applyStateSnapshot(s, [msg(10, 1, 2, false, "new-task")], 2, 5)
+		expect(texts(s)).toEqual(["new-task"])
+		expect(s.epoch).toBe(2)
+	})
+
+	it("a message from an older epoch is dropped (straggler from a previous task/render)", () => {
+		let s = createReplicaState()
+		s = applyStateSnapshot(s, [msg(10, 1, 2, false, "current")], 2, 1)
+		s = applyMessage(s, msg(99, 1, 1, false, "straggler"))
+		expect(texts(s)).toEqual(["current"])
+	})
+
+	it("an older-version snapshot at the same epoch is ignored wholesale", () => {
+		let s = createReplicaState()
+		s = applyStateSnapshot(s, [msg(1, 1, 1), msg(2, 2, 1), msg(3, 3, 1)], 1, 10)
+		s = applyStateSnapshot(s, [msg(1, 1, 1)], 1, 5)
+		expect(tsList(s)).toEqual([1, 2, 3])
+	})
+
+	it("unstamped (classic/legacy) messages merge at epoch 0 by ts", () => {
+		let s = createReplicaState()
+		const a: ClineMessage = { ts: 1, type: "say", say: "text", text: "a" }
+		const b: ClineMessage = { ts: 2, type: "say", say: "text", text: "b" }
+		s = applyMessage(s, a)
+		s = applyMessage(s, b)
+		expect(tsList(s)).toEqual([1, 2])
+	})
+
+	// Order independence (property-based via explicit permutations) -------------
+
+	function canonical(log: ClineMessage[]): ReplicaState {
+		let s = createReplicaState()
+		for (const m of log) {
+			s = applyMessage(s, m)
+		}
+		return s
+	}
+
+	function permutations<T>(arr: T[]): T[][] {
+		if (arr.length <= 1) {
+			return [arr.slice()]
+		}
+		const result: T[][] = []
+		for (let i = 0; i < arr.length; i++) {
+			const rest = [...arr.slice(0, i), ...arr.slice(i + 1)]
+			for (const p of permutations(rest)) {
+				result.push([arr[i], ...p])
+			}
+		}
+		return result
+	}
+
+	function normalize(state: ReplicaState): Array<{ ts: number; text: string; partial: boolean; ask?: string }> {
+		return [...state.messages]
+			.sort((a, b) => a.ts - b.ts)
+			.map((m) => ({ ts: m.ts, text: m.text ?? "", partial: m.partial ?? false, ask: m.ask }))
+	}
+
+	describe("messageReducer — order independence", () => {
+		// A causal log for one epoch: task, streamed text (partial then final, same ts), tool,
+		// and a trailing ask. seq reflects causal mint order.
+		const log: ClineMessage[] = [
+			msg(1, 1, 1, false, "task"),
+			msg(2, 2, 1, true, "Hel"),
+			msg(2, 3, 1, false, "Hello"),
+			msg(3, 4, 1, false, "tool"),
+			{ ts: 4, type: "ask", ask: "completion_result", text: "", seq: 5, epoch: 1 },
+		]
+
+		it("every delivery permutation converges to the canonical state", () => {
+			const expected = normalize(canonical(log))
+			const perms = permutations(log)
+			expect(perms.length).toBe(120) // 5!
+			for (const perm of perms) {
+				let s = createReplicaState()
+				for (const m of perm) {
+					s = applyMessage(s, m)
+				}
+				expect(normalize(s)).toEqual(expected)
+			}
+		})
+
+		it("converges even with every event duplicated", () => {
+			const expected = normalize(canonical(log))
+			for (const perm of permutations(log).slice(0, 24)) {
+				let s = createReplicaState()
+				for (const m of perm) {
+					s = applyMessage(s, m)
+					s = applyMessage(s, m)
+				}
+				expect(normalize(s)).toEqual(expected)
+			}
+		})
+
+		it("dropping non-final copies still converges once finals arrive in any order", () => {
+			const finalsByTs = new Map<number, ClineMessage>()
+			for (const m of log) {
+				const cur = finalsByTs.get(m.ts)
+				if (!cur || (m.seq ?? 0) >= (cur.seq ?? 0)) {
+					finalsByTs.set(m.ts, m)
+				}
+			}
+			const finals = [...finalsByTs.values()]
+			const expected = normalize(canonical(log))
+			for (const perm of permutations(finals)) {
+				let s = createReplicaState()
+				for (const m of perm) {
+					s = applyMessage(s, m)
+				}
+				expect(normalize(s)).toEqual(expected)
+			}
+		})
+	})
+
+	// --- turnState seq gate + transcript preservation --------------------------------
+	//
+	// The footer/buttons read turnState; these cover the invariants that keep it correct
+	// under out-of-order delivery and that keep a live transcript from being emptied.
+
+	describe("messageReducer — turnState seq gate", () => {
+		it("a snapshot carrying a newer-seq turnState advances the replica's turnState", () => {
+			let s = createReplicaState()
+			s = applyStateSnapshot(s, [msg(1, 1, 1, false, "task")], 1, 1, { phase: "streaming", seq: 5 })
+			expect(s.turnState?.phase).toBe("streaming")
+			expect(s.turnState?.seq).toBe(5)
+		})
+
+		it("a stale snapshot with an OLDER-seq turnState does NOT revert phase (streaming stays)", () => {
+			// The race: phase reaches "streaming" (seq 5); then a late snapshot captured earlier
+			// (turnState idle, seq 2) resolves last. Without a seq gate it would revert the footer
+			// to idle and hide the Cancel button. The gate must keep "streaming".
+			let s = createReplicaState()
+			s = applyStateSnapshot(s, [msg(1, 1, 1, false, "task")], 1, 1, { phase: "streaming", seq: 5 })
+			s = applyStateSnapshot(s, [msg(1, 1, 1, false, "task")], 1, 2, { phase: "idle", seq: 2 })
+			expect(s.turnState?.phase).toBe("streaming")
+			expect(s.turnState?.seq).toBe(5)
+		})
+
+		it("turnState moves forward when a newer-seq update arrives, regardless of arrival order", () => {
+			let s = createReplicaState()
+			// Deliver the newer one first, then an older straggler.
+			s = applyTurnState(s, { phase: "completed", seq: 9 })
+			s = applyTurnState(s, { phase: "streaming", seq: 4 })
+			expect(s.turnState?.phase).toBe("completed")
+			expect(s.turnState?.seq).toBe(9)
+		})
+
+		it("a newer epoch resets turnState along with the transcript", () => {
+			let s = createReplicaState()
+			s = applyStateSnapshot(s, [msg(1, 1, 1, false, "old")], 1, 1, { phase: "completed", seq: 9 })
+			// New task at a fresh epoch: the old completed turnState must not leak in.
+			s = applyStateSnapshot(s, [msg(10, 1, 2, false, "new")], 2, 1, { phase: "streaming", seq: 1 })
+			expect(s.turnState?.phase).toBe("streaming")
+			expect(s.turnState?.seq).toBe(1)
+			expect(texts(s)).toEqual(["new"])
+		})
+	})
+
+	describe("messageReducer — transcript is never emptied for a live conversation", () => {
+		it("a same-epoch snapshot with an empty transcript does NOT clear an existing one", () => {
+			// A bookkeeping/empty snapshot must not wipe a populated transcript and strand the
+			// webview at messages.length === 0 (which routes Enter to newTask()).
+			let s = createReplicaState()
+			s = applyStateSnapshot(s, [msg(1, 1, 1, false, "task"), msg(2, 2, 1, false, "answer")], 1, 1)
+			s = applyStateSnapshot(s, [], 1, 2)
+			expect(tsList(s)).toEqual([1, 2])
+		})
+
+		it("a lone newer-epoch partial does NOT discard a populated transcript", () => {
+			// If an epoch bump races ahead of the full snapshot, a single newer-epoch partial
+			// must not be treated as the entire new transcript (which would empty the task).
+			let s = createReplicaState()
+			s = applyStateSnapshot(s, [msg(1, 1, 1, false, "task"), msg(2, 2, 1, false, "answer")], 1, 5)
+			// A stray bookkeeping partial stamped at a higher epoch but with no real content.
+			const stray: ClineMessage = { ts: 99, type: "say", say: "api_req_started", text: "{}", seq: 1, epoch: 2 }
+			s = applyMessage(s, stray)
+			// The transcript must still contain the real conversation, not just the stray row.
+			expect(tsList(s)).toContain(1)
+			expect(tsList(s)).toContain(2)
+		})
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/messageReducer.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/messageReducer.ts
new file mode 100644
index 0000000..ea45126
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/messageReducer.ts
@@ -0,0 +1,195 @@
+import type { ClineMessage, TurnState } from "@shared/ExtensionMessage"
+
+// Convergent-replica reducer for the webview's clineMessages transcript.
+//
+// The webview receives the same conversation over two unordered, fire-and-forget channels
+// (incremental partial messages and full state snapshots). This reducer makes the transcript
+// converge to the correct set under ANY arrival order, duplication, or loss, using three
+// extension-stamped quantities:
+//
+//   - ts    : message identity / merge key (one process-wide monotonic id; see MessageIdMinter)
+//   - seq   : freshness within an epoch (higher seq = newer copy of the same ts)
+//   - epoch : conversation/replica fence (newer epoch replaces; older is dropped)
+//
+// The reducer is a pure function so it can be exhaustively unit-tested (including
+// property-based, order-independent tests) with no React/gRPC/timers.
+
+/**
+ * The webview's replica of the conversation transcript plus the fence/freshness high-water
+ * marks needed to reject stale traffic. `messages` is kept as an array (rendering order) and
+ * mirrors what the UI consumes.
+ */
+export interface ReplicaState {
+	messages: ClineMessage[]
+	/** Highest epoch applied. Messages/snapshots from an older epoch are dropped. */
+	epoch: number
+	/** Highest per-message seq applied per ts. Used to ignore older copies of the same ts. */
+	seqByTs: Map<number, number>
+	/** Highest state snapshot version applied. Older snapshots are ignored wholesale. */
+	stateVersion: number
+	/**
+	 * The authoritative UI mode for the current turn. Moves forward by `turnState.seq` only, so a
+	 * late/out-of-order snapshot carrying an older phase (e.g. "idle") can never revert a newer
+	 * phase (e.g. "streaming"). `undefined` for classic/legacy state with no turnState.
+	 */
+	turnState?: TurnState
+}
+
+/** Create an empty replica. */
+export function createReplicaState(): ReplicaState {
+	return { messages: [], epoch: 0, seqByTs: new Map(), stateVersion: 0, turnState: undefined }
+}
+
+/**
+ * Effective epoch of an incoming item. Unstamped (classic/legacy) items use 0, which equals
+ * a fresh replica's epoch, so they merge rather than being dropped.
+ */
+function epochOf(item: { epoch?: number }): number {
+	return item.epoch ?? 0
+}
+
+function seqOf(message: ClineMessage): number {
+	return message.seq ?? 0
+}
+
+/** Replace the replica's transcript wholesale at a new epoch (new task / history load). */
+function resetTo(epoch: number, messages: ClineMessage[], stateVersion: number, turnState?: TurnState): ReplicaState {
+	const seqByTs = new Map<number, number>()
+	for (const m of messages) {
+		const existing = seqByTs.get(m.ts)
+		if (existing === undefined || seqOf(m) >= existing) {
+			seqByTs.set(m.ts, seqOf(m))
+		}
+	}
+	return { messages: [...messages], epoch, seqByTs, stateVersion, turnState }
+}
+
+/**
+ * Apply a TurnState update, gated by `seq`. The replica keeps the highest-seq TurnState and
+ * ignores older ones, so a late/out-of-order "streaming" can never overwrite a newer
+ * "completed" (and vice-versa). Returns the same state when ignored.
+ */
+export function applyTurnState(state: ReplicaState, incoming: TurnState | undefined): ReplicaState {
+	if (!incoming) {
+		return state
+	}
+	if (state.turnState !== undefined && incoming.seq <= state.turnState.seq) {
+		return state
+	}
+	return { ...state, turnState: incoming }
+}
+
+/**
+ * Apply one incoming ClineMessage (from the partial-message stream OR from within a state
+ * snapshot). Returns the same state object when the message is stale/ignored, or a new state
+ * when it changes the transcript.
+ *
+ * Rules:
+ *  - older epoch  -> drop (straggler from a previous task/render)
+ *  - newer epoch  -> advance the fence, but do NOT discard the existing transcript on the
+ *                    strength of a single message. The authoritative wholesale replace for a
+ *                    new task/render comes from a full state snapshot (applyStateSnapshot); a
+ *                    lone newer-epoch *partial* (e.g. a bookkeeping api_req_started that raced
+ *                    ahead of its snapshot) must not empty a live conversation — that would
+ *                    strand the webview at messages.length === 0 and route Enter to newTask().
+ *                    So we bump the epoch and append/merge this one message; the snapshot that
+ *                    follows will reconcile to the true new-task transcript.
+ *  - same epoch   -> upsert by ts, keeping the higher seq
+ */
+export function applyMessage(state: ReplicaState, incoming: ClineMessage): ReplicaState {
+	const incomingEpoch = epochOf(incoming)
+
+	if (incomingEpoch < state.epoch) {
+		return state
+	}
+
+	if (incomingEpoch > state.epoch) {
+		// Advance the fence without throwing away an existing transcript. Carry the prior
+		// messages forward at the new epoch and merge this one in; a subsequent newer-epoch
+		// snapshot performs the real wholesale replace when a genuine new task begins.
+		const advanced: ReplicaState = {
+			messages: [...state.messages],
+			epoch: incomingEpoch,
+			seqByTs: new Map(state.seqByTs),
+			stateVersion: state.stateVersion,
+			turnState: state.turnState,
+		}
+		return applyMessage(advanced, incoming)
+	}
+
+	// Same epoch: merge by ts, keep highest seq.
+	const existingSeq = state.seqByTs.get(incoming.ts)
+	const index = state.messages.findIndex((m) => m.ts === incoming.ts)
+
+	if (index !== -1) {
+		// A copy of this ts already exists. Keep ours unless the incoming is at least as fresh.
+		if (existingSeq !== undefined && seqOf(incoming) < existingSeq) {
+			return state
+		}
+		const messages = [...state.messages]
+		messages[index] = incoming
+		const seqByTs = new Map(state.seqByTs)
+		seqByTs.set(incoming.ts, Math.max(existingSeq ?? 0, seqOf(incoming)))
+		return { ...state, messages, seqByTs }
+	}
+
+	// New ts at the current epoch — append.
+	const messages = [...state.messages, incoming]
+	const seqByTs = new Map(state.seqByTs)
+	seqByTs.set(incoming.ts, seqOf(incoming))
+	return { ...state, messages, seqByTs }
+}
+
+/**
+ * Apply a full state snapshot's transcript.
+ *
+ *  - older epoch        -> drop entirely
+ *  - newer epoch        -> replace the transcript wholesale (new task / history load)
+ *  - same epoch:
+ *      - older/equal stateVersion -> ignore (a newer snapshot already applied)
+ *      - newer stateVersion       -> MERGE each message by ts/seq (NEVER truncate). This is the
+ *                                    fix for "last message missing": a snapshot that lacks a
+ *                                    message the partial stream already delivered cannot drop it.
+ *
+ * `snapshotEpoch`/`snapshotVersion` default to 0 (unstamped classic/legacy) which merges.
+ *
+ * `snapshotTurnState` (when present) is applied through the same seq gate as applyTurnState: a
+ * newer epoch adopts it wholesale; otherwise it only advances the replica's turnState if its
+ * seq is higher. This is what stops a late/stale snapshot from reverting "streaming" -> "idle".
+ */
+export function applyStateSnapshot(
+	state: ReplicaState,
+	snapshotMessages: ClineMessage[],
+	snapshotEpoch = 0,
+	snapshotVersion = 0,
+	snapshotTurnState?: TurnState,
+): ReplicaState {
+	if (snapshotEpoch < state.epoch) {
+		return state
+	}
+
+	if (snapshotEpoch > state.epoch) {
+		// New task/render: replace transcript AND adopt the snapshot's turnState wholesale.
+		return resetTo(snapshotEpoch, snapshotMessages, snapshotVersion, snapshotTurnState)
+	}
+
+	// Same epoch.
+	if (snapshotVersion !== 0 && snapshotVersion <= state.stateVersion) {
+		// A newer (or equal) snapshot already applied for the transcript — but a turnState with a
+		// higher seq may still need to move the UI forward, so don't bail before the seq gate.
+		return applyTurnState(state, snapshotTurnState)
+	}
+
+	// Merge each message; never shrink the transcript for the same task/epoch.
+	let next = state
+	for (const message of snapshotMessages) {
+		next = applyMessage(next, message)
+	}
+	if (snapshotVersion > next.stateVersion) {
+		next = next === state ? { ...state } : next
+		next.stateVersion = snapshotVersion
+	}
+	// Gate turnState by seq so a stale snapshot cannot revert a newer phase.
+	next = applyTurnState(next, snapshotTurnState)
+	return next
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/shared/buttonConfig.test.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/shared/buttonConfig.test.ts
new file mode 100644
index 0000000..afe6b8c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/shared/buttonConfig.test.ts
@@ -0,0 +1,255 @@
+import type { ClineMessage, TurnState } from "@shared/ExtensionMessage"
+import { describe, expect, it } from "vitest"
+import {
+	BUTTON_CONFIGS,
+	buttonsForPhase,
+	getButtonConfig,
+	getButtonConfigForMessages,
+	getButtonConfigFromState,
+} from "./buttonConfig"
+
+describe("getButtonConfig", () => {
+	// Test default behavior
+	it("returns default config when no task is provided", () => {
+		const task = undefined
+		const config = getButtonConfig(task)
+		expect(config).toEqual(BUTTON_CONFIGS.default)
+	})
+
+	// Test streaming/partial messages
+	it("returns partial config for streaming messages", () => {
+		const streamingMessage: ClineMessage = {
+			type: "say",
+			say: "api_req_started",
+			partial: true,
+			ts: Date.now(),
+		}
+		const config = getButtonConfig(streamingMessage)
+		expect(config).toEqual(BUTTON_CONFIGS.partial)
+	})
+
+	// Test error recovery states
+	describe("Error Recovery States", () => {
+		const errorStates = ["api_req_failed", "mistake_limit_reached"]
+
+		errorStates.forEach((errorState) => {
+			it(`returns correct config for ${errorState}`, () => {
+				const errorMessage: ClineMessage = {
+					type: "ask",
+					ask: errorState as any,
+					partial: true,
+					text: "",
+					ts: Date.now(),
+				}
+				const config = getButtonConfig(errorMessage)
+				expect(config).toEqual(BUTTON_CONFIGS[errorState])
+			})
+		})
+	})
+
+	// Test tool approval states
+	describe("Tool Approval States", () => {
+		it("returns tool_approve config for generic tool ask", () => {
+			const toolMessage: ClineMessage = {
+				type: "ask",
+				ask: "tool",
+				text: JSON.stringify({ tool: "generic_tool" }),
+				ts: Date.now(),
+			}
+			const config = getButtonConfig(toolMessage)
+			expect(config).toEqual(BUTTON_CONFIGS.tool_approve)
+		})
+
+		it("returns tool_save config for file editing tools", () => {
+			const saveMessages = [{ tool: "editedExistingFile" }, { tool: "newFileCreated" }]
+
+			saveMessages.forEach((toolData) => {
+				const toolMessage: ClineMessage = {
+					type: "ask",
+					ask: "tool",
+					text: JSON.stringify(toolData),
+					ts: Date.now(),
+				}
+				const config = getButtonConfig(toolMessage)
+				expect(config).toEqual(BUTTON_CONFIGS.tool_save)
+			})
+		})
+	})
+
+	// Test command execution states
+	describe("Command Execution States", () => {
+		it("returns command config for command ask", () => {
+			const commandMessage: ClineMessage = {
+				type: "ask",
+				ask: "command",
+				ts: Date.now(),
+			}
+			const config = getButtonConfig(commandMessage)
+			expect(config).toEqual(BUTTON_CONFIGS.command)
+		})
+
+		it("returns command_output config for command_output ask", () => {
+			const commandOutputMessage: ClineMessage = {
+				type: "ask",
+				ask: "command_output",
+				ts: Date.now(),
+			}
+			const config = getButtonConfig(commandOutputMessage)
+			expect(config).toEqual(BUTTON_CONFIGS.command_output)
+		})
+	})
+
+	// Test other specific ask states
+	describe("Other Ask States", () => {
+		const stateConfigs = [
+			{ ask: "followup", expectedConfig: "followup" },
+			{ ask: "browser_action_launch", expectedConfig: "browser_action_launch" },
+			{ ask: "use_mcp_server", expectedConfig: "use_mcp_server" },
+			{ ask: "use_subagents", expectedConfig: "use_subagents" },
+			{ ask: "plan_mode_respond", expectedConfig: "plan_mode_respond" },
+			{ ask: "completion_result", expectedConfig: "completion_result" },
+			{ ask: "resume_task", expectedConfig: "resume_task" },
+			{ ask: "resume_completed_task", expectedConfig: "resume_completed_task" },
+			{ ask: "new_task", expectedConfig: "new_task" },
+			{ ask: "condense", expectedConfig: "condense" },
+			{ ask: "report_bug", expectedConfig: "report_bug" },
+		]
+
+		stateConfigs.forEach(({ ask, expectedConfig }) => {
+			it(`returns ${expectedConfig} config for ${ask} ask`, () => {
+				const message: ClineMessage = {
+					type: "ask",
+					ask: ask as any,
+					ts: Date.now(),
+				}
+				const config = getButtonConfig(message)
+				expect(config).toEqual(BUTTON_CONFIGS[expectedConfig])
+			})
+		})
+	})
+
+	// Test API request states
+	it("returns api_req_active config for api_req_started say message", () => {
+		const apiReqMessage: ClineMessage = {
+			type: "say",
+			say: "api_req_started",
+			ts: Date.now(),
+		}
+		const config = getButtonConfig(apiReqMessage)
+		expect(config).toEqual(BUTTON_CONFIGS.api_req_active)
+	})
+
+	describe("getButtonConfigForMessages", () => {
+		it("keeps web fetch approval buttons when a bookkeeping API usage message is appended after the ask", () => {
+			const messages: ClineMessage[] = [
+				{ type: "say", say: "task", text: "fetch docs", ts: 1 },
+				{
+					type: "ask",
+					ask: "tool",
+					text: JSON.stringify({ tool: "webFetch", path: "https://docs.cline.bot" }),
+					ts: 2,
+				},
+				{
+					type: "say",
+					say: "api_req_started",
+					text: JSON.stringify({ tokensIn: 10, tokensOut: 2, cost: 0.001 }),
+					ts: 3,
+				},
+			]
+
+			expect(getButtonConfigForMessages(messages)).toEqual(BUTTON_CONFIGS.tool_approve)
+		})
+
+		it("keeps MCP approval buttons when an MCP request-start marker is appended after the ask", () => {
+			const messages: ClineMessage[] = [
+				{ type: "say", say: "task", text: "use mcp", ts: 1 },
+				{ type: "ask", ask: "use_mcp_server", text: "{}", ts: 2 },
+				{ type: "say", say: "mcp_server_request_started", ts: 3 },
+			]
+
+			expect(getButtonConfigForMessages(messages)).toEqual(BUTTON_CONFIGS.use_mcp_server)
+		})
+
+		it("still shows cancel for an active API request", () => {
+			const messages: ClineMessage[] = [
+				{ type: "say", say: "task", text: "think", ts: 1 },
+				{ type: "say", say: "api_req_started", text: JSON.stringify({ request: undefined }), ts: 2 },
+			]
+
+			expect(getButtonConfigForMessages(messages)).toEqual(BUTTON_CONFIGS.api_req_active)
+		})
+	})
+
+	// Test mode parameter (though not extensively used in the current implementation)
+	it("handles mode parameter without changing core behavior", () => {
+		const message: ClineMessage = {
+			type: "ask",
+			ask: "tool",
+			text: JSON.stringify({ tool: "generic_tool" }),
+			ts: Date.now(),
+		}
+		const configAct = getButtonConfig(message, "act")
+		const configPlan = getButtonConfig(message, "plan")
+		expect(configAct).toEqual(configPlan)
+	})
+})
+
+describe("buttonsForPhase (TurnState-driven)", () => {
+	const ts = (phase: TurnState["phase"], anchorTs?: number): TurnState => ({ phase, anchorTs, seq: 1 })
+
+	it("maps phases to their button sets", () => {
+		expect(buttonsForPhase(ts("idle"), undefined)).toEqual(BUTTON_CONFIGS.default)
+		expect(buttonsForPhase(ts("streaming"), undefined)).toEqual(BUTTON_CONFIGS.partial)
+		expect(buttonsForPhase(ts("completed"), undefined)).toEqual(BUTTON_CONFIGS.completion_result)
+		expect(buttonsForPhase(ts("resumable"), undefined)).toEqual(BUTTON_CONFIGS.resume_task)
+		expect(buttonsForPhase(ts("error"), undefined)).toEqual(BUTTON_CONFIGS.api_req_failed)
+		expect(buttonsForPhase(ts("awaiting_followup"), undefined)).toEqual(BUTTON_CONFIGS.followup)
+		expect(buttonsForPhase(ts("awaiting_approval"), undefined)).toEqual(BUTTON_CONFIGS.tool_approve)
+	})
+
+	it("uses the anchored message to pick approval labels (Save vs Approve, command, mcp)", () => {
+		const save: ClineMessage = { ts: 5, type: "ask", ask: "tool", text: JSON.stringify({ tool: "editedExistingFile" }) }
+		expect(buttonsForPhase(ts("awaiting_approval", 5), save)).toEqual(BUTTON_CONFIGS.tool_save)
+
+		const command: ClineMessage = { ts: 6, type: "ask", ask: "command", text: "echo hi" }
+		expect(buttonsForPhase(ts("awaiting_approval", 6), command)).toEqual(BUTTON_CONFIGS.command)
+
+		const mcp: ClineMessage = { ts: 7, type: "ask", ask: "use_mcp_server", text: "{}" }
+		expect(buttonsForPhase(ts("awaiting_approval", 7), mcp)).toEqual(BUTTON_CONFIGS.use_mcp_server)
+	})
+
+	it("distinguishes mistake_limit from api_req_failed in the error phase via the anchor", () => {
+		const mistake: ClineMessage = { ts: 8, type: "ask", ask: "mistake_limit_reached", text: "" }
+		expect(buttonsForPhase(ts("error", 8), mistake)).toEqual(BUTTON_CONFIGS.mistake_limit_reached)
+	})
+})
+
+describe("getButtonConfigFromState (dispatch + legacy fallback)", () => {
+	const approvalAsk: ClineMessage = { ts: 100, type: "ask", ask: "command", text: "echo hi" }
+
+	it("prefers TurnState over the message tail (immune to trailing bookkeeping — RC1)", () => {
+		// Tail is a trailing api_req_started, but the authoritative phase is awaiting_approval.
+		const messages: ClineMessage[] = [
+			approvalAsk,
+			{ ts: 101, type: "say", say: "api_req_started", text: JSON.stringify({ tokensIn: 5, cost: 0.01 }) },
+		]
+		const turnState: TurnState = { phase: "awaiting_approval", anchorTs: 100, seq: 9 }
+		const config = getButtonConfigFromState(messages, turnState, "act")
+		expect(config).toEqual(BUTTON_CONFIGS.command)
+		expect(config.enableButtons).toBe(true)
+	})
+
+	it("falls back to legacy tail-walking when TurnState is absent", () => {
+		const messages: ClineMessage[] = [approvalAsk]
+		expect(getButtonConfigFromState(messages, undefined, "act")).toEqual(getButtonConfigForMessages(messages, "act"))
+	})
+
+	it("completed phase shows Start New Task regardless of trailing messages", () => {
+		const messages: ClineMessage[] = [
+			{ ts: 1, type: "say", say: "completion_result", text: "done" },
+			{ ts: 2, type: "say", say: "api_req_started", text: JSON.stringify({ cost: 0.02 }) },
+		]
+		const turnState: TurnState = { phase: "completed", seq: 3 }
+		expect(getButtonConfigFromState(messages, turnState, "act")).toEqual(BUTTON_CONFIGS.completion_result)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/shared/buttonConfig.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/shared/buttonConfig.ts
new file mode 100644
index 0000000..14c112c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/shared/buttonConfig.ts
@@ -0,0 +1,407 @@
+import type { ClineMessage, ClineSayTool, TurnState } from "@shared/ExtensionMessage"
+import type { Mode } from "@shared/storage/types"
+
+/**
+ * Button action types that determine the behavior
+ */
+export type ButtonActionType =
+	| "approve" // Send yesButtonClicked
+	| "reject" // Send noButtonClicked
+	| "proceed" // Send messageResponse or yesButtonClicked
+	| "new_task" // Start a new task
+	| "cancel" // Cancel streaming
+	| "utility" // Execute utility function (condense, report_bug)
+	| "retry" // Retry the last action
+
+/**
+ * Button configuration for different message states
+ */
+export interface ButtonConfig {
+	sendingDisabled: boolean
+	enableButtons: boolean
+	primaryText?: string
+	secondaryText?: string
+	primaryAction?: ButtonActionType
+	secondaryAction?: ButtonActionType
+}
+
+/**
+ * Centralized button state configurations based on task lifecycle
+ * This is the single source of truth for both button display and actions
+ */
+export const BUTTON_CONFIGS: Record<string, ButtonConfig> = {
+	// Error recovery states - user must take action
+	api_req_failed: {
+		sendingDisabled: true,
+		enableButtons: true,
+		primaryText: "Retry",
+		secondaryText: "Start New Task",
+		primaryAction: "retry",
+		secondaryAction: "new_task",
+	},
+	mistake_limit_reached: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Proceed Anyways",
+		secondaryText: "Start New Task",
+		primaryAction: "proceed",
+		secondaryAction: "new_task",
+	},
+
+	// Tool approval states - most common during task execution
+	tool_approve: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Approve",
+		secondaryText: "Reject",
+		primaryAction: "approve",
+		secondaryAction: "reject",
+	},
+	tool_save: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Save",
+		secondaryText: "Reject",
+		primaryAction: "approve",
+		secondaryAction: "reject",
+	},
+
+	// Command execution states
+	command: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Run Command",
+		secondaryText: "Reject",
+		primaryAction: "approve",
+		secondaryAction: "reject",
+	},
+	command_output: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Proceed While Running",
+		secondaryText: undefined,
+		primaryAction: "proceed",
+		secondaryAction: undefined,
+	},
+
+	// Browser and external tool states
+	browser_action_launch: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Approve",
+		secondaryText: "Reject",
+		primaryAction: "approve",
+		secondaryAction: "reject",
+	},
+	use_mcp_server: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Approve",
+		secondaryText: "Reject",
+		primaryAction: "approve",
+		secondaryAction: "reject",
+	},
+	use_subagents: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Approve",
+		secondaryText: "Reject",
+		primaryAction: "approve",
+		secondaryAction: "reject",
+	},
+	followup: {
+		sendingDisabled: false,
+		enableButtons: false,
+		primaryText: undefined,
+		secondaryText: undefined,
+		primaryAction: undefined,
+		secondaryAction: undefined,
+	},
+	plan_mode_respond: {
+		sendingDisabled: false,
+		enableButtons: false,
+		primaryText: undefined,
+		secondaryText: undefined,
+		primaryAction: undefined,
+		secondaryAction: undefined,
+	},
+
+	// Task lifecycle states
+	completion_result: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Start New Task",
+		secondaryText: undefined,
+		primaryAction: "new_task",
+		secondaryAction: undefined,
+	},
+	resume_task: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Resume Task",
+		secondaryText: undefined,
+		primaryAction: "proceed",
+		secondaryAction: undefined,
+	},
+	resume_completed_task: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Start New Task",
+		secondaryText: undefined,
+		primaryAction: "new_task",
+		secondaryAction: undefined,
+	},
+	new_task: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Start New Task with Context",
+		secondaryText: undefined,
+		primaryAction: "new_task",
+		secondaryAction: undefined,
+	},
+
+	// Utility states
+	condense: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Condense Conversation",
+		secondaryText: undefined,
+		primaryAction: "utility",
+		secondaryAction: undefined,
+	},
+	report_bug: {
+		sendingDisabled: false,
+		enableButtons: true,
+		primaryText: "Report GitHub issue",
+		secondaryText: undefined,
+		primaryAction: "utility",
+		secondaryAction: undefined,
+	},
+
+	// Streaming/partial states - disable interaction during streaming
+	partial: {
+		sendingDisabled: true,
+		enableButtons: true,
+		primaryText: undefined,
+		secondaryText: "Cancel",
+		primaryAction: undefined,
+		secondaryAction: "cancel",
+	},
+
+	// Default states
+	default: {
+		sendingDisabled: false,
+		enableButtons: false,
+		primaryText: undefined,
+		secondaryText: undefined,
+		primaryAction: undefined,
+		secondaryAction: undefined,
+	},
+	api_req_active: {
+		sendingDisabled: true,
+		enableButtons: true,
+		primaryText: undefined,
+		secondaryText: "Cancel",
+		primaryAction: undefined,
+		secondaryAction: "cancel",
+	},
+}
+
+const errorTypes = ["api_req_failed", "mistake_limit_reached"]
+
+/**
+ * Determines button configuration based on message type and state
+ * This is the single source of truth used by both ActionButtons and useMessageHandlers
+ */
+export function getButtonConfig(message: ClineMessage | undefined, _mode: Mode = "act"): ButtonConfig {
+	if (!message) {
+		return BUTTON_CONFIGS.default
+	}
+
+	const isStreaming = message.partial === true
+	const isError = message?.ask ? errorTypes.includes(message.ask) : false
+
+	// Special case: command_output should show "Proceed While Running" button even while streaming
+	// This allows terminal output to stream while still showing the action button
+	if (message.type === "ask" && message.ask === "command_output") {
+		return BUTTON_CONFIGS.command_output
+	}
+
+	// Handle partial/streaming messages first (most common during task execution)
+	// This must be checked before any other conditions to ensure streaming state takes precedence
+	if (isStreaming && !isError) {
+		return BUTTON_CONFIGS.partial
+	}
+
+	// Handle ask messages (user interaction required)
+	if (message.type === "ask") {
+		switch (message.ask) {
+			// Error recovery states
+			case "api_req_failed":
+				return BUTTON_CONFIGS.api_req_failed
+			case "mistake_limit_reached":
+				return BUTTON_CONFIGS.mistake_limit_reached
+
+			// Tool approval (most common)
+			case "tool": {
+				// Only parse JSON if we need to determine save vs approve
+				try {
+					const tool = JSON.parse(message.text || "{}") as ClineSayTool
+					if (tool.tool === "editedExistingFile" || tool.tool === "newFileCreated" || tool.tool === "fileDeleted") {
+						return BUTTON_CONFIGS.tool_save
+					}
+				} catch {
+					// Fall through to default tool approval
+				}
+				return BUTTON_CONFIGS.tool_approve
+			}
+
+			// Command execution
+			case "command":
+				return BUTTON_CONFIGS.command
+			case "command_output":
+				return BUTTON_CONFIGS.command_output
+
+			// Standard approvals
+			case "followup":
+				return BUTTON_CONFIGS.followup
+			case "browser_action_launch":
+				return BUTTON_CONFIGS.browser_action_launch
+			case "use_mcp_server":
+				return BUTTON_CONFIGS.use_mcp_server
+			case "use_subagents":
+				return BUTTON_CONFIGS.use_subagents
+			case "plan_mode_respond":
+				return BUTTON_CONFIGS.plan_mode_respond
+
+			// Task lifecycle
+			case "completion_result":
+				return BUTTON_CONFIGS.completion_result
+			case "resume_task":
+				return BUTTON_CONFIGS.resume_task
+			case "resume_completed_task":
+				return BUTTON_CONFIGS.resume_completed_task
+			case "new_task":
+				return BUTTON_CONFIGS.new_task
+
+			// Utility
+			case "condense":
+				return BUTTON_CONFIGS.condense
+			case "report_bug":
+				return BUTTON_CONFIGS.report_bug
+
+			default:
+				return BUTTON_CONFIGS.tool_approve
+		}
+	}
+
+	// Handle say messages (typically don't require buttons except in special cases)
+	if (message.type === "say" && message.say === "api_req_started") {
+		return BUTTON_CONFIGS.api_req_active
+	}
+
+	// Special case: command_output say messages should show "Proceed While Running" button
+	// This allows terminal output to stream while still showing the action button
+	if (message.type === "say" && message.say === "command_output") {
+		return BUTTON_CONFIGS.command_output
+	}
+
+	return BUTTON_CONFIGS.partial
+}
+
+function isInertStatusMessage(message: ClineMessage): boolean {
+	if (message.type !== "say") {
+		return false
+	}
+
+	if (message.say === "api_req_started") {
+		try {
+			const info = JSON.parse(message.text || "{}")
+			return info.cost != null || info.cancelReason != null || info.streamingFailedMessage != null
+		} catch {
+			return false
+		}
+	}
+
+	return [
+		"api_req_finished",
+		"api_req_retried",
+		"deleted_api_reqs",
+		"mcp_server_request_started",
+		"subagent_usage",
+		"task_progress",
+	].includes(message.say || "")
+}
+
+/**
+ * Finds the message that should control footer buttons.
+ *
+ * The raw stream can append bookkeeping/status messages after an approval ask
+ * (for example API usage updates or MCP request-start markers). Those rows are
+ * filtered out of the visible chat, but using the raw last message would hide
+ * Approve/Reject and leave the user stuck. Prefer the last non-inert message.
+ */
+export function getButtonConfigForMessages(messages: ClineMessage[], mode: Mode = "act"): ButtonConfig {
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index]
+		if (!isInertStatusMessage(message)) {
+			return getButtonConfig(message, mode)
+		}
+	}
+
+	return BUTTON_CONFIGS.default
+}
+
+/**
+ * Authoritative button configuration derived from the backend-owned TurnState. This is the
+ * preferred path: the UI mode is read from `turnState.phase`, never inferred from the tail of
+ * the message array.
+ *
+ * The button SET is chosen by phase; the LABEL/variant for approvals (Save vs Approve, command
+ * vs tool vs MCP vs subagents) comes from the anchored message (turnState.anchorTs).
+ */
+export function buttonsForPhase(turnState: TurnState, anchoredMessage: ClineMessage | undefined): ButtonConfig {
+	switch (turnState.phase) {
+		case "idle":
+			return BUTTON_CONFIGS.default
+		case "streaming":
+			return BUTTON_CONFIGS.partial
+		case "completed":
+			return BUTTON_CONFIGS.completion_result
+		case "resumable":
+			return BUTTON_CONFIGS.resume_task
+		case "error":
+			// The anchored message distinguishes mistake_limit (Proceed/New Task) from a failed
+			// API request (Retry/New Task). Default to the retry config.
+			if (anchoredMessage?.type === "ask" && anchoredMessage.ask === "mistake_limit_reached") {
+				return BUTTON_CONFIGS.mistake_limit_reached
+			}
+			return BUTTON_CONFIGS.api_req_failed
+		case "awaiting_followup":
+			// followup / plan_mode_respond — input enabled, no approve/reject buttons. (If the
+			// anchored message is a recognized ask, defer to its config for correct labels.)
+			return anchoredMessage ? getButtonConfig(anchoredMessage, "act") : BUTTON_CONFIGS.followup
+		case "awaiting_approval":
+			// Approve/Reject (or Run Command / Save / etc.) — driven by the anchored ask so the
+			// labels match the tool kind. Falls back to generic tool approval.
+			return anchoredMessage ? getButtonConfig(anchoredMessage, "act") : BUTTON_CONFIGS.tool_approve
+		default:
+			return BUTTON_CONFIGS.default
+	}
+}
+
+/**
+ * Single entry point for button config. Uses the authoritative TurnState when present (SDK
+ * path); otherwise falls back to the legacy tail-walking heuristic (classic/older state).
+ */
+export function getButtonConfigFromState(
+	messages: ClineMessage[],
+	turnState: TurnState | undefined,
+	mode: Mode = "act",
+): ButtonConfig {
+	if (turnState) {
+		const anchored = turnState.anchorTs !== undefined ? messages.find((m) => m.ts === turnState.anchorTs) : undefined
+		return buttonsForPhase(turnState, anchored)
+	}
+	return getButtonConfigForMessages(messages, mode)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/types/chatTypes.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/types/chatTypes.ts
new file mode 100644
index 0000000..98c5e17
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/types/chatTypes.ts
@@ -0,0 +1,103 @@
+/**
+ * Shared types and interfaces for the chat view components
+ */
+
+import { ClineAsk, ClineMessage } from "@shared/ExtensionMessage"
+import { ListRange, VirtuosoHandle } from "react-virtuoso"
+import { ButtonActionType } from "../shared/buttonConfig"
+
+export interface PendingUserMessage {
+	message: ClineMessage
+	afterTs: number
+}
+
+/**
+ * Chat state interface
+ */
+export interface ChatState {
+	// State values
+	inputValue: string
+	setInputValue: React.Dispatch<React.SetStateAction<string>>
+	activeQuote: string | null
+	setActiveQuote: React.Dispatch<React.SetStateAction<string | null>>
+	isTextAreaFocused: boolean
+	setIsTextAreaFocused: React.Dispatch<React.SetStateAction<boolean>>
+	selectedImages: string[]
+	setSelectedImages: React.Dispatch<React.SetStateAction<string[]>>
+	selectedFiles: string[]
+	setSelectedFiles: React.Dispatch<React.SetStateAction<string[]>>
+	sendingDisabled: boolean
+	setSendingDisabled: React.Dispatch<React.SetStateAction<boolean>>
+	enableButtons: boolean
+	setEnableButtons: React.Dispatch<React.SetStateAction<boolean>>
+	primaryButtonText: string | undefined
+	setPrimaryButtonText: React.Dispatch<React.SetStateAction<string | undefined>>
+	secondaryButtonText: string | undefined
+	setSecondaryButtonText: React.Dispatch<React.SetStateAction<string | undefined>>
+	expandedRows: Record<number, boolean>
+	setExpandedRows: React.Dispatch<React.SetStateAction<Record<number, boolean>>>
+	pendingUserMessage: PendingUserMessage | undefined
+	setPendingUserMessage: React.Dispatch<React.SetStateAction<PendingUserMessage | undefined>>
+
+	// Refs
+	textAreaRef: React.RefObject<HTMLTextAreaElement>
+
+	// Derived values
+	lastMessage: ClineMessage | undefined
+	secondLastMessage: ClineMessage | undefined
+	clineAsk: ClineAsk | undefined
+	task: ClineMessage | undefined
+
+	// Handlers
+	handleFocusChange: (isFocused: boolean) => void
+	clearExpandedRows: () => void
+	resetState: () => void
+
+	// Scroll-related state (will be moved to scroll hook)
+	isAtBottom?: boolean
+	pendingScrollToMessage?: number | null
+}
+
+/**
+ * Message handlers interface
+ */
+export interface MessageHandlers {
+	executeButtonAction: (action: ButtonActionType, text?: string, images?: string[], files?: string[]) => Promise<void>
+	handleSendMessage: (text: string, images: string[], files: string[]) => Promise<void>
+	handleTaskCloseButtonClick: () => void
+	startNewTask: () => Promise<void>
+}
+
+/**
+ * Scroll behavior interface
+ */
+export interface ScrollBehavior {
+	virtuosoRef: React.RefObject<VirtuosoHandle>
+	scrollContainerRef: React.RefObject<HTMLDivElement>
+	disableAutoScrollRef: React.MutableRefObject<boolean>
+	scrollToBottomSmooth: () => void
+	scrollToBottomAuto: () => void
+	scrollToMessage: (messageIndex: number) => void
+	toggleRowExpansion: (ts: number, options?: { preserveAutoScroll?: boolean }) => void
+	handleRowHeightChange: (isTaller: boolean) => void
+	handleLastRowContentChange: () => void
+	isAtBottom: boolean
+	setIsAtBottom: React.Dispatch<React.SetStateAction<boolean>>
+	pendingScrollToMessage: number | null
+	setPendingScrollToMessage: React.Dispatch<React.SetStateAction<number | null>>
+	scrolledPastUserMessage: ClineMessage | null
+	handleRangeChanged: (range: ListRange) => void
+}
+
+/**
+ * Welcome section props
+ */
+export interface WelcomeSectionProps {
+	showAnnouncement: boolean
+	hideAnnouncement: () => void
+	showHistoryView: () => void
+	telemetrySetting: string
+	version: string
+	taskHistory: any[]
+	shouldShowQuickWins: boolean
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/utils/markdownUtils.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/utils/markdownUtils.ts
new file mode 100644
index 0000000..db3ab6a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/utils/markdownUtils.ts
@@ -0,0 +1,58 @@
+/**
+ * Utility functions for handling markdown conversions and cleanup
+ */
+
+import rehypeParse from "rehype-parse"
+import rehypeRemark from "rehype-remark"
+import remarkStringify from "remark-stringify"
+import { unified } from "unified"
+
+/**
+ * Clean up markdown escape characters
+ */
+function cleanupMarkdownEscapes(markdown: string): string {
+	return (
+		markdown
+			// Handle underscores and asterisks (single or multiple)
+			.replace(/\\([_*]+)/g, "$1")
+
+			// Handle angle brackets (for generics and XML)
+			.replace(/\\([<>])/g, "$1")
+
+			// Handle backticks (for code)
+			.replace(/\\(`)/g, "$1")
+
+			// Handle other common markdown special characters
+			.replace(/\\([[\]()#.!])/g, "$1")
+
+			// Fix multiple consecutive backslashes
+			.replace(/\\{2,}([_*`<>[\]()#.!])/g, "$1")
+	)
+}
+
+/**
+ * Convert HTML to Markdown
+ */
+export async function convertHtmlToMarkdown(html: string): Promise<string> {
+	// Process the HTML to Markdown
+	const result = await unified()
+		.use(rehypeParse as any, { fragment: true }) // Parse HTML fragments
+		.use(rehypeRemark as any) // Convert HTML to Markdown AST
+		.use(remarkStringify as any, {
+			// Convert Markdown AST to text
+			bullet: "-", // Use - for unordered lists
+			emphasis: "*", // Use * for emphasis
+			strong: "_", // Use _ for strong
+			listItemIndent: "one", // Use one space for list indentation
+			rule: "-", // Use - for horizontal rules
+			ruleSpaces: false, // No spaces in horizontal rules
+			fences: true,
+			escape: false,
+			entities: false,
+		})
+		.process(html)
+
+	const md = String(result)
+	// Apply comprehensive cleanup of escape characters
+	return cleanupMarkdownEscapes(md)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/utils/messageUtils.test.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/utils/messageUtils.test.ts
new file mode 100644
index 0000000..0640bd0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/utils/messageUtils.test.ts
@@ -0,0 +1,169 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { describe, expect, it } from "vitest"
+import { canRestoreWorkspaceFromMessage, filterVisibleMessages, groupLowStakesTools, isToolGroup } from "./messageUtils"
+
+const createTextMessage = (ts: number, text: string): ClineMessage => ({
+	type: "say",
+	say: "text",
+	text,
+	ts,
+})
+
+const createToolMessage = (ts: number, tool: string): ClineMessage => ({
+	type: "say",
+	say: "tool",
+	text: JSON.stringify({ tool, path: "src/file.ts" }),
+	ts,
+})
+
+const createReasoningMessage = (ts: number, text: string): ClineMessage => ({
+	type: "say",
+	say: "reasoning",
+	text,
+	ts,
+})
+
+const createUserFeedbackMessage = (ts: number, text: string): ClineMessage => ({
+	type: "say",
+	say: "user_feedback",
+	text,
+	ts,
+})
+
+const createTaskMessage = (ts: number, text: string): ClineMessage => ({
+	type: "say",
+	say: "task",
+	text,
+	ts,
+})
+
+const createAskMessage = (
+	ts: number,
+	ask: "followup" | "plan_mode_respond",
+	options: string[],
+	selected?: string,
+): ClineMessage => ({
+	type: "ask",
+	ask,
+	text: JSON.stringify(
+		ask === "followup" ? { question: "Pick one", options, selected } : { response: "Pick one", options, selected },
+	),
+	ts,
+})
+
+describe("filterVisibleMessages", () => {
+	it("hides exact user feedback echoes for selected follow-up options", () => {
+		const askMessage = createAskMessage(1, "followup", ["Use this", "Use that"], "Use this")
+		const visible = filterVisibleMessages([askMessage, createUserFeedbackMessage(2, "Use this")])
+
+		expect(visible).toEqual([askMessage])
+	})
+
+	it("hides exact option echoes when selected has not been persisted on the ask row yet", () => {
+		const askMessage = createAskMessage(1, "followup", ["Use this", "Use that"])
+		const visible = filterVisibleMessages([askMessage, createUserFeedbackMessage(2, "Use this")])
+
+		expect(visible).toEqual([askMessage])
+	})
+
+	it("hides exact user feedback echoes for plan-mode response options", () => {
+		const askMessage = createAskMessage(1, "plan_mode_respond", ["Plan it", "Do it"], "Plan it")
+		const visible = filterVisibleMessages([askMessage, createUserFeedbackMessage(2, "Plan it")])
+
+		expect(visible).toEqual([askMessage])
+	})
+
+	it("keeps custom user feedback that extends a selected option", () => {
+		const askMessage = createAskMessage(1, "followup", ["Use this", "Use that"], "Use this")
+		const userMessage = createUserFeedbackMessage(2, "Use this: include tests")
+		const visible = filterVisibleMessages([askMessage, userMessage])
+
+		expect(visible).toEqual([askMessage, userMessage])
+	})
+
+	it("keeps exact option feedback when it includes attachments", () => {
+		const askMessage = createAskMessage(1, "followup", ["Use this", "Use that"], "Use this")
+		const userMessage: ClineMessage = {
+			...createUserFeedbackMessage(2, "Use this"),
+			images: ["data:image/png;base64,abc"],
+		}
+		const visible = filterVisibleMessages([askMessage, userMessage])
+
+		expect(visible).toEqual([askMessage, userMessage])
+	})
+})
+
+describe("canRestoreWorkspaceFromMessage", () => {
+	it("allows restore for user messages that start runs, but not ask answers", () => {
+		const messages = [
+			createTaskMessage(1, "start"),
+			createAskMessage(2, "followup", ["src/index.ts"]),
+			createTextMessage(3, "Which file should I inspect?"),
+			createUserFeedbackMessage(4, "src/index.ts"),
+			createUserFeedbackMessage(5, "next task"),
+		]
+
+		expect(canRestoreWorkspaceFromMessage(messages, 1)).toBe(true)
+		expect(canRestoreWorkspaceFromMessage(messages, 4)).toBe(false)
+		expect(canRestoreWorkspaceFromMessage(messages, 5)).toBe(true)
+		expect(canRestoreWorkspaceFromMessage(messages, 999)).toBe(false)
+	})
+})
+
+describe("groupLowStakesTools", () => {
+	it("keeps text that arrives after a low-stakes tool group by finalizing the group first", () => {
+		const grouped = groupLowStakesTools([
+			createTextMessage(1, "Initial text"),
+			createToolMessage(2, "readFile"),
+			createTextMessage(3, "Post-tool summary text"),
+		])
+
+		expect(grouped).toHaveLength(3)
+		expect(grouped[0]).toMatchObject({ type: "say", say: "text", text: "Initial text" })
+		expect(isToolGroup(grouped[1])).toBe(true)
+		expect(grouped[2]).toMatchObject({ type: "say", say: "text", text: "Post-tool summary text" })
+	})
+
+	it("keeps text when no low-stakes tool group is active", () => {
+		const grouped = groupLowStakesTools([
+			createTextMessage(1, "Initial text"),
+			createToolMessage(2, "editedExistingFile"),
+			createTextMessage(3, "Follow-up text"),
+		])
+
+		expect(grouped).toHaveLength(3)
+		expect(grouped[0]).toMatchObject({ type: "say", say: "text", text: "Initial text" })
+		expect(grouped[1]).toMatchObject({ type: "say", say: "tool" })
+		expect(grouped[2]).toMatchObject({ type: "say", say: "text", text: "Follow-up text" })
+	})
+
+	it("keeps standalone reasoning when no low-stakes tool group follows", () => {
+		const grouped = groupLowStakesTools([
+			createReasoningMessage(1, "Thinking through options"),
+			createTextMessage(2, "Answer text"),
+		])
+
+		expect(grouped).toHaveLength(2)
+		expect(grouped[0]).toMatchObject({ type: "say", say: "reasoning", text: "Thinking through options" })
+		expect(grouped[1]).toMatchObject({ type: "say", say: "text", text: "Answer text" })
+	})
+
+	it("keeps standalone reasoning before a non-low-stakes tool", () => {
+		const grouped = groupLowStakesTools([
+			createReasoningMessage(1, "Thinking through options"),
+			createToolMessage(2, "editedExistingFile"),
+		])
+
+		expect(grouped).toHaveLength(2)
+		expect(grouped[0]).toMatchObject({ type: "say", say: "reasoning", text: "Thinking through options" })
+		expect(grouped[1]).toMatchObject({ type: "say", say: "tool" })
+	})
+
+	it("keeps reasoning visible when low-stakes tool group starts immediately after", () => {
+		const grouped = groupLowStakesTools([createReasoningMessage(1, "Planning next read"), createToolMessage(2, "readFile")])
+
+		expect(grouped).toHaveLength(2)
+		expect(grouped[0]).toMatchObject({ type: "say", say: "reasoning", text: "Planning next read" })
+		expect(isToolGroup(grouped[1])).toBe(true)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/chat-view/utils/messageUtils.ts b/apps/vscode/webview-ui/src/components/chat/chat-view/utils/messageUtils.ts
new file mode 100644
index 0000000..6bfec30
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/chat-view/utils/messageUtils.ts
@@ -0,0 +1,700 @@
+/**
+ * Utility functions for message filtering, grouping, and manipulation
+ */
+
+import type {
+	ClineAskQuestion,
+	ClineMessage,
+	ClinePlanModeResponse,
+	ClineSayBrowserAction,
+	ClineSayTool,
+} from "@shared/ExtensionMessage"
+import { FileIcon, FolderOpenDotIcon, FolderOpenIcon, SearchIcon, ShapesIcon, WrenchIcon } from "lucide-react"
+
+/**
+ * Low-stakes tool types that should be grouped together
+ */
+const LOW_STAKES_TOOLS = new Set([
+	"readFile",
+	"listFilesTopLevel",
+	"listFilesRecursive",
+	"listCodeDefinitionNames",
+	"searchFiles",
+])
+
+/**
+ * Check if a tool message is a low-stakes tool
+ */
+export function isLowStakesTool(message: ClineMessage): boolean {
+	if (message.say !== "tool" && message.ask !== "tool") {
+		return false
+	}
+	try {
+		const tool = JSON.parse(message.text || "{}") as ClineSayTool
+		return LOW_STAKES_TOOLS.has(tool.tool)
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Check if a message group is a tool group (array with _isToolGroup marker)
+ */
+export function isToolGroup(item: ClineMessage | ClineMessage[]): item is ClineMessage[] & { _isToolGroup: true } {
+	return Array.isArray(item) && (item as ClineMessage[] & { _isToolGroup?: boolean })._isToolGroup === true
+}
+
+function isDuplicateAskOptionEcho(message: ClineMessage, previousMessage: ClineMessage | undefined): boolean {
+	if (
+		message.type !== "say" ||
+		message.say !== "user_feedback" ||
+		(message.images?.length ?? 0) > 0 ||
+		(message.files?.length ?? 0) > 0 ||
+		previousMessage?.type !== "ask" ||
+		(previousMessage.ask !== "followup" && previousMessage.ask !== "plan_mode_respond")
+	) {
+		return false
+	}
+
+	const responseText = message.text ?? ""
+	if (!responseText) {
+		return false
+	}
+
+	try {
+		const parsed = JSON.parse(previousMessage.text || "{}") as ClineAskQuestion | ClinePlanModeResponse
+		if (!parsed.options?.includes(responseText)) {
+			return false
+		}
+
+		return parsed.selected === undefined || parsed.selected === responseText
+	} catch {
+		return false
+	}
+}
+
+function isVisibleCheckpointUserMessage(message: ClineMessage): boolean {
+	return message.type === "say" && (message.say === "task" || message.say === "user_feedback")
+}
+
+function isCheckpointAnswerMessage(messages: ClineMessage[], index: number): boolean {
+	const message = messages[index]
+	if (message?.type !== "say" || message.say !== "user_feedback") {
+		return false
+	}
+
+	for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+		const previous = messages[cursor]
+		if (previous.say === "checkpoint_created") {
+			continue
+		}
+		if (previous.type === "ask") {
+			return previous.ask === "followup" || previous.ask === "mistake_limit_reached"
+		}
+		if (isVisibleCheckpointUserMessage(previous)) {
+			return false
+		}
+	}
+
+	return false
+}
+
+export function canRestoreWorkspaceFromMessage(messages: ClineMessage[], messageTs: number | undefined): boolean {
+	if (messageTs === undefined) {
+		return false
+	}
+	const index = messages.findIndex((message) => message.ts === messageTs)
+	if (index === -1) {
+		return false
+	}
+	return isVisibleCheckpointUserMessage(messages[index]) && !isCheckpointAnswerMessage(messages, index)
+}
+
+/**
+ * Filter messages that should be visible in the chat
+ */
+export function filterVisibleMessages(messages: ClineMessage[]): ClineMessage[] {
+	return messages.filter((message, index, arr) => {
+		if (isDuplicateAskOptionEcho(message, arr[index - 1])) {
+			return false
+		}
+
+		switch (message.ask) {
+			case "completion_result":
+				// don't show a chat row for a completion_result ask without text. This specific type of message only occurs if cline wants to execute a command as part of its completion result, in which case we interject the completion_result tool with the execute_command tool.
+				if (message.text === "") {
+					return false
+				}
+				break
+			case "api_req_failed": // this message is used to update the latest api_req_started that the request failed
+			case "resume_task":
+			case "resume_completed_task":
+				return false
+			case "use_subagents":
+				if (arr.slice(index + 1).some((candidate) => candidate.type === "say" && candidate.say === "subagent")) {
+					return false
+				}
+				break
+		}
+		switch (message.say) {
+			case "api_req_finished": // combineApiRequests removes this from modifiedMessages anyways
+			case "api_req_retried": // this message is used to update the latest api_req_started that the request was retried
+			case "deleted_api_reqs": // aggregated api_req metrics from deleted messages
+			case "subagent_usage": // aggregated subagent usage metrics for task-level accounting
+			case "task_progress": // task progress messages are displayed in TaskHeader, not in main chat
+			case "checkpoint_created": // checkpoint restore is exposed from user-message edit controls
+				return false
+			// NOTE: reasoning passes through to be included in tool groups
+			case "api_req_started": {
+				// api_req_started rows only render visible content for errors/cancels.
+				// Reasoning has its own standalone ChatRows. Everything else renders
+				// as invisible padding. Filter out unless there's an error.
+				try {
+					const info = JSON.parse(message.text || "{}")
+					if (info.cancelReason || info.streamingFailedMessage) {
+						break // keep - has error content
+					}
+				} catch {
+					break // keep on parse error to be safe
+				}
+				return false
+			}
+			case "text":
+				// Sometimes cline returns an empty text message, we don't want to render these. (We also use a say text for user messages, so in case they just sent images we still render that)
+				if ((message.text ?? "") === "" && (message.images?.length ?? 0) === 0) {
+					return false
+				}
+				break
+			case "mcp_server_request_started":
+				return false
+			case "use_subagents":
+				if (arr.slice(index + 1).some((candidate) => candidate.type === "say" && candidate.say === "subagent")) {
+					return false
+				}
+				break
+		}
+		return true
+	})
+}
+
+/**
+ * Check if a message is part of a browser session
+ */
+function isBrowserSessionMessage(message: ClineMessage): boolean {
+	if (message.type === "ask") {
+		return message.ask === "browser_action_launch"
+	}
+	if (message.type === "say") {
+		return [
+			"browser_action_launch",
+			"api_req_started",
+			"text",
+			"browser_action",
+			"browser_action_result",
+			"reasoning",
+			"error_retry",
+		].includes(message.say ?? "")
+	}
+	return false
+}
+
+/**
+ * Group messages, combining browser session messages into arrays
+ */
+export function groupMessages(visibleMessages: ClineMessage[]): (ClineMessage | ClineMessage[])[] {
+	const result: (ClineMessage | ClineMessage[])[] = []
+	let currentGroup: ClineMessage[] = []
+	let isInBrowserSession = false
+
+	const endBrowserSession = () => {
+		if (currentGroup.length > 0) {
+			result.push([...currentGroup])
+			currentGroup = []
+			isInBrowserSession = false
+		}
+	}
+
+	for (const message of visibleMessages) {
+		if (message.ask === "browser_action_launch" || message.say === "browser_action_launch") {
+			// complete existing browser session if any
+			endBrowserSession()
+			// start new
+			isInBrowserSession = true
+			currentGroup.push(message)
+		} else if (isInBrowserSession) {
+			// end session if api_req_started is cancelled
+			if (message.say === "api_req_started") {
+				// get last api_req_started in currentGroup to check if it's cancelled
+				const lastApiReqStarted = [...currentGroup].reverse().find((m) => m.say === "api_req_started")
+				if (lastApiReqStarted?.text != null) {
+					const info = JSON.parse(lastApiReqStarted.text)
+					const isCancelled = info.cancelReason != null
+					if (isCancelled) {
+						endBrowserSession()
+						result.push(message)
+						continue
+					}
+				}
+			}
+
+			if (isBrowserSessionMessage(message)) {
+				currentGroup.push(message)
+
+				// Check if this is a close action
+				if (message.say === "browser_action") {
+					const browserAction = JSON.parse(message.text || "{}") as ClineSayBrowserAction
+					if (browserAction.action === "close") {
+						endBrowserSession()
+					}
+				}
+			} else {
+				// complete existing browser session if any
+				endBrowserSession()
+				result.push(message)
+			}
+		} else {
+			result.push(message)
+		}
+	}
+
+	// Handle case where browser session is the last group
+	if (currentGroup.length > 0) {
+		result.push([...currentGroup])
+	}
+
+	return result
+}
+
+/**
+ * Find reasoning content associated with an api_req_started message.
+ * Also returns whether response content (non-reasoning) has started.
+ */
+export function findReasoningForApiReq(
+	apiReqTs: number,
+	allMessages: ClineMessage[],
+): { reasoning: string | undefined; responseStarted: boolean } {
+	const apiReqIndex = allMessages.findIndex((m) => m.ts === apiReqTs && m.say === "api_req_started")
+	if (apiReqIndex === -1) {
+		return { reasoning: undefined, responseStarted: false }
+	}
+
+	// Collect reasoning and check if response content has started
+	const reasoningParts: string[] = []
+	let responseStarted = false
+
+	for (let i = apiReqIndex + 1; i < allMessages.length; i++) {
+		const msg = allMessages[i]
+		// Stop at next api_req_started
+		if (msg.say === "api_req_started") {
+			break
+		}
+		// Collect reasoning content
+		if (msg.say === "reasoning" && msg.text) {
+			reasoningParts.push(msg.text)
+		}
+		// Check if non-reasoning response content has started (text, tool calls, etc.)
+		if (msg.say === "text" || msg.say === "tool" || msg.ask === "tool" || msg.ask === "command" || msg.say === "command") {
+			responseStarted = true
+		}
+	}
+
+	return {
+		reasoning: reasoningParts.length > 0 ? reasoningParts.join("\n\n") : undefined,
+		responseStarted,
+	}
+}
+
+/**
+ * Check if a text message's associated API request is still in progress.
+ * Returns true if there's no cost yet on the parent api_req_started.
+ */
+export function isTextMessagePendingToolCall(textTs: number, allMessages: ClineMessage[]): boolean {
+	// Find the api_req_started that precedes this text message
+	const textIndex = allMessages.findIndex((m) => m.ts === textTs)
+	if (textIndex === -1) {
+		return false
+	}
+
+	// Look backwards for the most recent api_req_started
+	for (let i = textIndex - 1; i >= 0; i--) {
+		const msg = allMessages[i]
+		if (msg.say === "api_req_started" && msg.text) {
+			try {
+				const info = JSON.parse(msg.text)
+				// If no cost, the request is still in progress
+				return info.cost == null
+			} catch {
+				return false
+			}
+		}
+	}
+	return false
+}
+
+/**
+ * Filter a tool group to exclude tools that are in the "current activities" range.
+ * Returns the filtered array of messages (may be empty).
+ *
+ * This is used so ToolGroupRenderer shows PAST tools (what's already in context),
+ * while the loading state shows ACTIVE tools (what's being "read" now).
+ *
+ * "Current activities" includes:
+ * - (Case A) Tools between a previous completed api_req and the current incomplete api_req
+ * - (Case B) Tools after the most recent api_req overall (either because it's complete, or no loading state is active yet)
+ */
+export function getToolsNotInCurrentActivities(toolGroupMessages: ClineMessage[], allMessages: ClineMessage[]): ClineMessage[] {
+	// Build a Map of timestamp -> index for O(1) lookups instead of O(n) findIndex calls
+	const tsToIndex = new Map<number, number>()
+	for (let i = 0; i < allMessages.length; i++) {
+		tsToIndex.set(allMessages[i].ts, i)
+	}
+
+	// Step 1: Find the MOST RECENT api_req_started overall (search backwards)
+	let mostRecentApiReqIndex = -1
+	let mostRecentApiReq: ClineMessage | null = null
+	for (let i = allMessages.length - 1; i >= 0; i--) {
+		if (allMessages[i].say === "api_req_started") {
+			mostRecentApiReqIndex = i
+			mostRecentApiReq = allMessages[i]
+			break
+		}
+	}
+
+	if (mostRecentApiReqIndex === -1) {
+		// No api_req at all - show all tools
+		return toolGroupMessages
+	}
+
+	if (!mostRecentApiReq?.text) {
+		return toolGroupMessages
+	}
+
+	// Step 2: Determine if most recent api_req is complete (has cost) or incomplete (no cost)
+	let mostRecentHasCost = false
+	try {
+		const info = JSON.parse(mostRecentApiReq.text)
+		mostRecentHasCost = info.cost != null
+	} catch {
+		return toolGroupMessages
+	}
+
+	// Step 3: Determine which tools are "in current activities"
+	if (!mostRecentHasCost) {
+		// CASE A: Most recent api_req is INCOMPLETE (loading state active)
+		// Tools are in-flight if they're between prev completed api_req and current incomplete one
+
+		// Find the previous COMPLETED api_req
+		let prevCompletedApiReqIndex = -1
+		for (let i = mostRecentApiReqIndex - 1; i >= 0; i--) {
+			const msg = allMessages[i]
+			if (msg.say === "api_req_started" && msg.text) {
+				try {
+					const prevInfo = JSON.parse(msg.text)
+					if (prevInfo.cost != null) {
+						prevCompletedApiReqIndex = i
+						break
+					}
+				} catch {
+					/* continue searching */
+				}
+			}
+		}
+
+		if (prevCompletedApiReqIndex === -1) {
+			// No previous completed api_req, so no tools are in the "current activities" range
+			return toolGroupMessages
+		}
+
+		// Filter out tools in the range (prevCompleted, current)
+		return toolGroupMessages.filter((msg) => {
+			// Keep non-low-stakes tools
+			if (!isLowStakesTool(msg)) {
+				return true
+			}
+
+			// Filter out only tools awaiting approval (ask === 'tool')
+			// Completed tools (say === 'tool') should still be shown
+			if (msg.ask === "tool") {
+				const toolIndex = tsToIndex.get(msg.ts)
+				if (toolIndex === undefined) {
+					return true
+				}
+				// Tool is in "current activities" range if AFTER prevCompleted AND BEFORE current
+				const isInCurrentActivitiesRange = toolIndex > prevCompletedApiReqIndex && toolIndex < mostRecentApiReqIndex
+				// Filter out if in current activities range
+				return !isInCurrentActivitiesRange
+			}
+
+			// Keep completed tools (say === 'tool')
+			return true
+		})
+	}
+	// CASE B: Most recent api_req is COMPLETE (has cost)
+	// Tools that appear AFTER this completed api_req are "in flight" (just arrived)
+	// Filter them out so they appear in currentActivities instead
+
+	return toolGroupMessages.filter((msg) => {
+		// Keep non-low-stakes tools
+		if (!isLowStakesTool(msg)) {
+			return true
+		}
+
+		// Filter out only tools awaiting approval (ask === 'tool')
+		// Completed tools (say === 'tool') should still be shown
+		if (msg.ask === "tool") {
+			const toolIndex = tsToIndex.get(msg.ts)
+			if (toolIndex === undefined) {
+				return true
+			}
+			// Tool is in "current activities" if it appears AFTER the most recent api_req
+			const isInCurrentActivitiesRange = toolIndex > mostRecentApiReqIndex
+			// Filter out if in current activities range
+			return !isInCurrentActivitiesRange
+		}
+
+		// Keep completed tools (say === 'tool')
+		return true
+	})
+}
+
+/**
+ * Returns true if this api_req_started should be fully absorbed into a low-stakes tool group.
+ *
+ * This scans FORWARD from the api_req_started until the next api_req_started and checks:
+ * - at least one low-stakes tool exists
+ * - no high-stakes tool/command exists
+ *
+ * Note: this operates on a flat `ClineMessage[]` (e.g. `modifiedMessages`) rather than
+ * grouped messages. It is used at render time to avoid transient UI frames where
+ * `api_req_started` briefly appears before grouping absorbs it.
+ */
+export function isApiReqAbsorbable(apiReqTs: number, allMessages: ClineMessage[]): boolean {
+	const apiReqIndex = allMessages.findIndex((m) => m.ts === apiReqTs && m.say === "api_req_started")
+	if (apiReqIndex === -1) {
+		return false
+	}
+
+	let hasLowStakesTool = false
+	let hasReasoning = false
+	for (let i = apiReqIndex + 1; i < allMessages.length; i++) {
+		const msg = allMessages[i]
+		if (msg.say === "api_req_started") {
+			break
+		}
+
+		// Reasoning - mark it but don't absorb if present
+		if (msg.say === "reasoning") {
+			hasReasoning = true
+			continue
+		}
+
+		// Text is allowed (we still want to absorb api_req into the tool group)
+		if (msg.say === "text") {
+			continue
+		}
+
+		// Low-stakes tools mark absorbability
+		if (isLowStakesTool(msg)) {
+			hasLowStakesTool = true
+			continue
+		}
+
+		// Any other tool/command is considered high-stakes; do not absorb
+		if (msg.say === "tool" || msg.ask === "tool" || msg.say === "command" || msg.ask === "command") {
+			return false
+		}
+	}
+
+	// Don't absorb if there's reasoning - we want to show "Thoughts >"
+	return hasLowStakesTool && !hasReasoning
+}
+
+/**
+ * Check if an api_req_started at a given index produces low-stakes tools
+ * (regardless of whether it also produces text).
+ * If so, it should be absorbed into the tool group rather than rendered separately.
+ * The key is: no HIGH-stakes tools (write, edit, command, etc.) AND no reasoning
+ */
+function isApiReqFollowedOnlyByLowStakesTools(index: number, messages: (ClineMessage | ClineMessage[])[]): boolean {
+	let hasLowStakesTool = false
+	let hasReasoning = false
+	for (let i = index + 1; i < messages.length; i++) {
+		const item = messages[i]
+		if (Array.isArray(item)) {
+			// Browser session - this ends the low-stakes run
+			break
+		}
+		const msg = item
+		// Another api_req_started - stop checking
+		if (msg.say === "api_req_started") {
+			break
+		}
+		// Reasoning - mark it but don't absorb if present
+		if (msg.say === "reasoning") {
+			hasReasoning = true
+			continue
+		}
+		// Low-stakes tool - mark it
+		if (isLowStakesTool(msg)) {
+			hasLowStakesTool = true
+			continue
+		}
+		// Text is OK - it will render separately, but we still absorb api_req
+		if (msg.say === "text") {
+			continue
+		}
+		// High-stakes tool (write, edit, command, etc.) - don't absorb
+		if (msg.say === "tool" || msg.ask === "tool" || msg.ask === "command" || msg.say === "command") {
+			return false
+		}
+	}
+	// Don't absorb if there's reasoning - we want to show "Thoughts >"
+	return hasLowStakesTool && !hasReasoning
+}
+
+/**
+ * Group consecutive low-stakes tools (and their reasoning) into arrays.
+ * Also filters out checkpoints that follow low-stakes tool groups.
+ * Absorbs api_req_started messages that are followed only by low-stakes tools.
+ * Only creates tool groups when there's at least one actual tool - reasoning-only groups are dropped.
+ * Should be called after groupMessages.
+ */
+export function groupLowStakesTools(groupedMessages: (ClineMessage | ClineMessage[])[]): (ClineMessage | ClineMessage[])[] {
+	const result: (ClineMessage | ClineMessage[])[] = []
+	let toolGroup: ClineMessage[] = []
+	let pendingReasoning: ClineMessage[] = []
+	let pendingApiReq: ClineMessage[] = []
+	let hasTools = false
+	const pendingTools: ClineMessage[] = []
+
+	const flushPending = () => {
+		pendingApiReq.forEach((m) => {
+			result.push(m)
+		})
+		pendingReasoning.forEach((m) => {
+			result.push(m)
+		})
+		pendingApiReq = []
+		pendingReasoning = []
+	}
+
+	const commitToolGroup = () => {
+		if (toolGroup.length > 0 && hasTools) {
+			const group = toolGroup as ClineMessage[] & { _isToolGroup: boolean }
+			group._isToolGroup = true
+			result.push(group)
+			pendingReasoning = []
+			pendingApiReq = []
+		}
+		toolGroup = []
+		hasTools = false
+	}
+
+	const absorbPending = () => {
+		if (pendingApiReq.length > 0) {
+			toolGroup.push(...pendingApiReq)
+			pendingApiReq = []
+		}
+	}
+
+	for (let i = 0; i < groupedMessages.length; i++) {
+		const item = groupedMessages[i]
+
+		// Browser session group - commit current work and pass through
+		if (Array.isArray(item)) {
+			commitToolGroup()
+			flushPending()
+			result.push(item)
+			continue
+		}
+
+		const message = item
+		const messageType = message.say
+		const isLast = i === groupedMessages.length - 1
+
+		// Low-stakes tool - absorb pending and add to group
+		if (isLowStakesTool(message)) {
+			// Keep reasoning visible as its own row when it happens before a tool group.
+			// If we absorb it into the group, ToolGroupRenderer hides it entirely.
+			if (!hasTools && pendingReasoning.length > 0) {
+				flushPending()
+			}
+			absorbPending()
+			hasTools = true
+			toolGroup.push(message)
+			// If the streaming has stopped and the last message is still an ask,
+			// this means the tool requires user approval - show the old tool block UI.
+			if (message.type === "ask" && !message.partial && isLast) {
+				pendingTools.push(message)
+			}
+			continue
+		}
+
+		// Reasoning - add to group if active, otherwise queue
+		if (messageType === "reasoning") {
+			if (hasTools) {
+				toolGroup.push(message)
+			} else {
+				pendingReasoning.push(message)
+			}
+			continue
+		}
+
+		// API request - absorb if followed by low-stakes tools, otherwise render
+		if (messageType === "api_req_started") {
+			if (isApiReqFollowedOnlyByLowStakesTools(i, groupedMessages)) {
+				absorbPending()
+				pendingApiReq.push(message)
+			} else {
+				commitToolGroup()
+				flushPending()
+				result.push(message)
+			}
+			continue
+		}
+
+		// Text - if a low-stakes tool group is active, finalize it first,
+		// then render the text as a normal chat row. This ensures post-tool
+		// summaries (common in SDK/native-tool-call flows) are visible.
+		if (messageType === "text") {
+			if (hasTools) {
+				commitToolGroup()
+			}
+			flushPending()
+			result.push(message)
+			continue
+		}
+
+		// Everything else - commit group, flush pending, and render
+		commitToolGroup()
+		flushPending()
+		result.push(message)
+	}
+
+	// Finalize any remaining work
+	commitToolGroup()
+	flushPending()
+
+	if (pendingTools.length > 0) {
+		result.push(...pendingTools)
+	}
+
+	return result
+}
+
+export function getIconByToolName(toolName: string) {
+	switch (toolName) {
+		case "readFile":
+			return FileIcon
+		case "listFilesTopLevel":
+			return FolderOpenIcon
+		case "listFilesRecursive":
+			return FolderOpenDotIcon
+		case "searchFiles":
+			return SearchIcon
+		case "listCodeDefinitionNames":
+			return ShapesIcon
+		default:
+			return WrenchIcon
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/constants.ts b/apps/vscode/webview-ui/src/components/chat/constants.ts
new file mode 100644
index 0000000..dd453b0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/constants.ts
@@ -0,0 +1,10 @@
+/**
+ * Shared constants for chat components
+ */
+
+/**
+ * Marker string used to separate hook metadata from hook output in hook messages.
+ * When a hook executes, its metadata (status, tool info, etc.) is followed by this
+ * marker, which is then followed by the actual output from the hook script.
+ */
+export const HOOK_OUTPUT_STRING = "__HOOK_OUTPUT__"
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindow.test.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindow.test.tsx
new file mode 100644
index 0000000..96afee3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindow.test.tsx
@@ -0,0 +1,75 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import type { ButtonHTMLAttributes, PropsWithChildren } from "react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import ContextWindow from "./ContextWindow"
+
+const condense = vi.fn().mockResolvedValue(undefined)
+
+vi.mock("@/services/grpc-client", () => ({
+	SlashServiceClient: {
+		condense: (request: unknown) => condense(request),
+	},
+}))
+
+vi.mock("@shared/proto/cline/common", () => ({
+	StringRequest: {
+		create: (request: unknown) => request,
+	},
+}))
+
+vi.mock("@vscode/webview-ui-toolkit/react", () => ({
+	VSCodeButton: ({ children, ...props }: PropsWithChildren<ButtonHTMLAttributes<HTMLButtonElement>>) => (
+		<button {...props}>{children}</button>
+	),
+}))
+
+vi.mock("@/components/ui/hover-card", () => ({
+	HoverCard: ({ children }: PropsWithChildren) => <div>{children}</div>,
+	HoverCardContent: ({ children }: PropsWithChildren) => <div>{children}</div>,
+	HoverCardTrigger: ({ children }: PropsWithChildren) => <div>{children}</div>,
+}))
+
+vi.mock("@/components/ui/progress", () => ({
+	Progress: ({ value }: { value?: number }) => (
+		<div aria-label="Context window usage progress" role="progressbar">
+			{value}
+		</div>
+	),
+}))
+
+vi.mock("@/components/ui/tooltip", () => ({
+	Tooltip: ({ children }: PropsWithChildren) => <>{children}</>,
+	TooltipContent: ({ children }: PropsWithChildren) => <div>{children}</div>,
+	TooltipTrigger: ({ children }: PropsWithChildren) => <>{children}</>,
+}))
+
+vi.mock("@/components/ui/button", () => ({
+	Button: ({ children, ...props }: PropsWithChildren<ButtonHTMLAttributes<HTMLButtonElement>>) => (
+		<button {...props}>{children}</button>
+	),
+}))
+
+describe("ContextWindow compact button", () => {
+	beforeEach(() => {
+		condense.mockClear()
+	})
+
+	it("runs the compact RPC after confirmation instead of sending /compact as a message", async () => {
+		const onSendMessage = vi.fn()
+
+		render(
+			<ContextWindow
+				contextWindow={200_000}
+				lastApiReqTotalTokens={120_000}
+				onSendMessage={onSendMessage}
+				useAutoCondense={false}
+			/>,
+		)
+
+		fireEvent.click(screen.getByRole("button", { name: /compact task/i }))
+		fireEvent.click(screen.getByRole("button", { name: /yes/i }))
+
+		await waitFor(() => expect(condense).toHaveBeenCalledWith({ value: "compact" }))
+		expect(onSendMessage).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindow.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindow.tsx
new file mode 100644
index 0000000..ce17208
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindow.tsx
@@ -0,0 +1,194 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import debounce from "debounce"
+import React, { memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { HoverCard, HoverCardContent, HoverCardTrigger } from "@/components/ui/hover-card"
+import { Progress } from "@/components/ui/progress"
+import { SlashServiceClient } from "@/services/grpc-client"
+import { formatLargeNumber as formatTokenNumber } from "@/utils/format"
+import CompactTaskButton from "./buttons/CompactTaskButton"
+import { ContextWindowSummary } from "./ContextWindowSummary"
+
+// Type definitions
+interface ContextWindowInfoProps {
+	tokensIn?: number
+	tokensOut?: number
+	cacheWrites?: number
+	cacheReads?: number
+	size?: number
+}
+
+interface ContextWindowProgressProps extends ContextWindowInfoProps {
+	useAutoCondense: boolean
+	lastApiReqTotalTokens?: number
+	contextWindow?: number
+	onSendMessage?: (command: string, files: string[], images: string[]) => void
+}
+
+const ConfirmationDialog = memo<{
+	onConfirm: (e: React.MouseEvent) => void
+	onCancel: (e: React.MouseEvent) => void
+}>(({ onConfirm, onCancel }) => (
+	<div className="text-sm my-2 flex items-center gap-0 justify-between">
+		<span className="font-semibold text-sm">Compact the current task?</span>
+		<span className="flex gap-1">
+			<VSCodeButton
+				appearance="secondary"
+				className="text-sm"
+				onClick={onCancel}
+				title="No, keep the task as is"
+				type="button">
+				Cancel
+			</VSCodeButton>
+			<VSCodeButton
+				appearance="primary"
+				autoFocus={true}
+				className="text-sm"
+				onClick={onConfirm}
+				title="Yes, compact the task"
+				type="button">
+				Yes
+			</VSCodeButton>
+		</span>
+	</div>
+))
+ConfirmationDialog.displayName = "ConfirmationDialog"
+
+const ContextWindow: React.FC<ContextWindowProgressProps> = ({
+	contextWindow = 0,
+	lastApiReqTotalTokens = 0,
+	onSendMessage,
+	useAutoCondense,
+	tokensIn,
+	tokensOut,
+	cacheWrites,
+	cacheReads,
+}) => {
+	const [isOpened, setIsOpened] = useState(false)
+	const [confirmationNeeded, setConfirmationNeeded] = useState(false)
+	const progressBarRef = useRef<HTMLDivElement>(null)
+
+	const handleCompactClick = useCallback(
+		(e: React.MouseEvent) => {
+			e.preventDefault()
+			e.stopPropagation()
+			setConfirmationNeeded(!confirmationNeeded)
+		},
+		[confirmationNeeded],
+	)
+
+	const handleConfirm = useCallback((e: React.MouseEvent) => {
+		e.preventDefault()
+		e.stopPropagation()
+		// Trigger a real SDK manual compaction rather than sending the literal
+		// text "/compact" to the model (which it would treat as a normal prompt
+		// and improvise a fake summary — CLINE-2503). The condense RPC runs the
+		// same SDK compaction effect as the CLI's `/compact` command.
+		SlashServiceClient.condense(StringRequest.create({ value: "compact" })).catch((err) =>
+			console.error("Failed to compact task:", err),
+		)
+		setConfirmationNeeded(false)
+	}, [])
+
+	const handleCancel = useCallback((e: React.MouseEvent) => {
+		e.preventDefault()
+		e.stopPropagation()
+		setConfirmationNeeded(false)
+	}, [])
+
+	const tokenData = useMemo(() => {
+		if (!contextWindow) {
+			return null
+		}
+		return {
+			percentage: (lastApiReqTotalTokens / contextWindow) * 100,
+			max: contextWindow,
+			used: lastApiReqTotalTokens,
+		}
+	}, [contextWindow, lastApiReqTotalTokens])
+
+	const debounceCloseHover = useCallback((e: React.MouseEvent) => {
+		e.preventDefault()
+		e.stopPropagation()
+		const showHover = debounce((open: boolean) => setIsOpened(open), 100)
+
+		return showHover(false)
+	}, [])
+
+	const handleFocus = useCallback(() => {
+		setIsOpened(true)
+	}, [])
+
+	// Close tooltip when clicking outside
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			const target = event.target as Element
+			const isInsideProgressBar = progressBarRef.current?.contains(target as Node)
+
+			// Check if click is inside any tooltip content by looking for our custom class
+			const isInsideTooltipContent = target.closest(".context-window-tooltip-content") !== null
+
+			if (!isInsideProgressBar && !isInsideTooltipContent) {
+				setIsOpened(false)
+			}
+		}
+
+		if (isOpened) {
+			document.addEventListener("mousedown", handleClickOutside)
+			return () => document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [isOpened])
+
+	if (!tokenData) {
+		return null
+	}
+
+	return (
+		<div className="flex flex-col my-1.5" onMouseLeave={debounceCloseHover}>
+			<div className="flex gap-1 flex-row @max-xs:flex-col @max-xs:items-start items-center text-sm">
+				<div className="flex items-center gap-1.5 flex-1 whitespace-nowrap">
+					<span className="cursor-pointer text-sm" title="Current tokens used in this request">
+						{formatTokenNumber(tokenData.used)}
+					</span>
+					<div className="flex relative items-center gap-1 flex-1 w-full h-full" onMouseEnter={() => setIsOpened(true)}>
+						<HoverCard>
+							<HoverCardContent className="bg-menu rounded-xs shadow-sm">
+								<ContextWindowSummary
+									cacheReads={cacheReads}
+									cacheWrites={cacheWrites}
+									contextWindow={tokenData.max}
+									percentage={tokenData.percentage}
+									tokensIn={tokensIn}
+									tokensOut={tokensOut}
+									tokenUsed={tokenData.used}
+								/>
+							</HoverCardContent>
+							<HoverCardTrigger asChild>
+								{/* TODO: Re-add role="slider", aria-value*, onKeyDown, onClick, and tabIndex
+								    when click-to-set-threshold is implemented. See PR #9348 for context. */}
+								<div
+									className="relative w-full text-foreground context-window-progress brightness-100"
+									onFocus={handleFocus}
+									ref={progressBarRef}>
+									<Progress
+										aria-label="Context window usage progress"
+										color="success"
+										value={tokenData.percentage}
+									/>
+									{isOpened}
+								</div>
+							</HoverCardTrigger>
+						</HoverCard>
+					</div>
+					<span className="cursor-pointer text-sm" title="Maximum context window size for this model">
+						{formatTokenNumber(tokenData.max)}
+					</span>
+				</div>
+				<CompactTaskButton onClick={handleCompactClick} />
+			</div>
+			{confirmationNeeded && <ConfirmationDialog onCancel={handleCancel} onConfirm={handleConfirm} />}
+		</div>
+	)
+}
+
+export default memo(ContextWindow)
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindowSummary.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindowSummary.tsx
new file mode 100644
index 0000000..c4c0773
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/ContextWindowSummary.tsx
@@ -0,0 +1,179 @@
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import React, { memo, useCallback, useMemo, useState } from "react"
+import { formatLargeNumber as formatTokenNumber } from "@/utils/format"
+
+interface TokenUsageInfoProps {
+	tokensIn?: number
+	tokensOut?: number
+	cacheWrites?: number
+	cacheReads?: number
+}
+
+interface TokenDetail {
+	title: string
+	value?: number
+	icon: string
+}
+
+interface TaskContextWindowButtonsProps extends TokenUsageInfoProps {
+	percentage: number
+	tokenUsed: number
+	contextWindow: number
+	autoCompactThreshold?: number
+	isThresholdChanged?: boolean
+	isThresholdFadingOut?: boolean
+}
+
+// New accordion item component
+const AccordionItem = memo<{
+	title: string
+	value: React.ReactNode
+	isExpanded: boolean
+	onToggle: (event?: React.MouseEvent) => void
+	children?: React.ReactNode
+}>(({ title, value, isExpanded, onToggle, children }) => {
+	const handleClick = useCallback(
+		(event: React.MouseEvent) => {
+			event.preventDefault()
+			event.stopPropagation()
+			onToggle(event)
+		},
+		[onToggle],
+	)
+
+	return (
+		<div className="flex flex-col w-full">
+			<div
+				className="flex justify-between items-center gap-1 cursor-pointer hover:bg-foreground/5 rounded p-0.5 transition-colors w-full"
+				onClick={handleClick}>
+				<div className="flex items-center gap-1">
+					{isExpanded ? <ChevronDownIcon size={12} /> : <ChevronRightIcon size={12} />}
+					<div className="font-semibold">{title}</div>
+				</div>
+				<div className="text-muted-foreground">{value}</div>
+			</div>
+			{isExpanded && children && <div className="ml-5 my-1 text-xs text-muted-foreground">{children}</div>}
+		</div>
+	)
+})
+AccordionItem.displayName = "AccordionItem"
+
+// Constants
+const TOKEN_DETAILS_CONFIG: Omit<TokenDetail, "value">[] = [
+	{ title: "Prompt Tokens", icon: "codicon-arrow-up" },
+	{ title: "Completion Tokens", icon: "codicon-arrow-down" },
+	{ title: "Cache Writes", icon: "codicon-arrow-left" },
+	{ title: "Cache Reads", icon: "codicon-arrow-right" },
+]
+
+const TokenUsageDetails = memo<TokenUsageInfoProps>(({ tokensIn, tokensOut, cacheWrites, cacheReads }) => {
+	const contextTokenDetails = useMemo(() => {
+		const values = [tokensIn, tokensOut, cacheWrites || 0, cacheReads || 0]
+		return TOKEN_DETAILS_CONFIG.map((config, index) => ({ ...config, value: values[index] })).filter((item) => item.value)
+	}, [tokensIn, tokensOut, cacheWrites, cacheReads])
+
+	if (!tokensIn) {
+		return <div>No token usage data available</div>
+	}
+
+	return (
+		<div className="space-y-1">
+			{contextTokenDetails.map((item) => (
+				<div className="flex justify-between">
+					<span>{item.title}</span>
+					<span className="font-mono">{formatTokenNumber(item.value || 0)}</span>
+				</div>
+			))}
+		</div>
+	)
+})
+TokenUsageDetails.displayName = "TokenUsageDetails"
+
+export const ContextWindowSummary: React.FC<TaskContextWindowButtonsProps> = ({
+	contextWindow,
+	tokenUsed,
+	tokensIn,
+	tokensOut,
+	cacheWrites,
+	cacheReads,
+	percentage,
+	autoCompactThreshold = 0,
+}) => {
+	// Accordion state
+	const [expandedSections, setExpandedSections] = useState<Set<string>>(new Set())
+
+	const toggleSection = useCallback((section: string, event?: React.MouseEvent) => {
+		if (event) {
+			event.preventDefault()
+			event.stopPropagation()
+		}
+		setExpandedSections((prev) => {
+			const newSet = new Set(prev)
+			if (newSet.has(section)) {
+				newSet.delete(section)
+			} else {
+				newSet.add(section)
+			}
+			return newSet
+		})
+	}, [])
+
+	const totalTokens = (tokensIn || 0) + (tokensOut || 0) + (cacheWrites || 0) + (cacheReads || 0)
+
+	return (
+		<div className="context-window-tooltip-content flex flex-col gap-2 bg-menu rounded shadow-sm z-100 w-60 p-1">
+			{autoCompactThreshold > 0 && (
+				<AccordionItem
+					isExpanded={expandedSections.has("threshold")}
+					onToggle={(event) => toggleSection("threshold", event)}
+					title="Auto Condense Threshold"
+					value={<span className="text-muted-foreground">{`${(autoCompactThreshold * 100).toFixed(0)}%`}</span>}>
+					<div className="space-y-1">
+						<p className="text-xs leading-relaxed text-white">
+							Click on the context window bar to set a new threshold.
+						</p>
+						<p className="text-xs leading-relaxed mt-0 mb-0">
+							When the context window usage exceeds this threshold, the task will be automatically condensed.
+						</p>
+					</div>
+				</AccordionItem>
+			)}
+
+			<AccordionItem
+				isExpanded={expandedSections.has("context")}
+				onToggle={(event) => toggleSection("context", event)}
+				title="Context Window"
+				value={percentage ? `${percentage.toFixed(1)}%` : formatTokenNumber(contextWindow)}>
+				<div className="space-y-1">
+					<div className="flex justify-between">
+						<span>Used:</span>
+						<span className="font-mono">{formatTokenNumber(tokenUsed)}</span>
+					</div>
+					<div className="flex justify-between">
+						<span>Total:</span>
+						<span className="font-mono">{formatTokenNumber(contextWindow)}</span>
+					</div>
+					<div className="flex justify-between">
+						<span>Remaining:</span>
+						<span className="font-mono">{formatTokenNumber(contextWindow - tokenUsed)}</span>
+					</div>
+				</div>
+			</AccordionItem>
+
+			{totalTokens > 0 && (
+				<AccordionItem
+					isExpanded={expandedSections.has("tokens")}
+					onToggle={(event) => toggleSection("tokens", event)}
+					title="Token Usage"
+					value={`${formatTokenNumber(totalTokens)}`}>
+					<TokenUsageDetails
+						cacheReads={cacheReads}
+						cacheWrites={cacheWrites}
+						tokensIn={tokensIn}
+						tokensOut={tokensOut}
+					/>
+				</AccordionItem>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/Highlights.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/Highlights.tsx
new file mode 100644
index 0000000..99dbcd5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/Highlights.tsx
@@ -0,0 +1,76 @@
+import { mentionRegexGlobal } from "@shared/context-mentions"
+import { StringRequest } from "@shared/proto/cline/common"
+import { FileServiceClient } from "@/services/grpc-client"
+import { validateSlashCommand } from "@/utils/slash-commands"
+
+// Optimized highlighting functions
+const highlightSlashCommands = (text: string, withShadow = true) => {
+	const match = text.match(/^\s*\/([a-zA-Z0-9_-]+)(\s*|$)/)
+	if (!match || validateSlashCommand(match[1]) !== "full") {
+		return text
+	}
+
+	const commandName = match[1]
+	const commandEndIndex = match[0].length
+	const beforeCommand = text.substring(0, text.indexOf("/"))
+	const afterCommand = match[2] + text.substring(commandEndIndex)
+
+	return [
+		beforeCommand,
+		<span className={withShadow ? "mention-context-highlight-with-shadow" : "mention-context-highlight"} key="slashCommand">
+			/{commandName}
+		</span>,
+		afterCommand,
+	]
+}
+
+const highlightMentions = (text: string, withShadow = true) => {
+	if (!mentionRegexGlobal.test(text)) {
+		return text
+	}
+
+	const parts = text.split(mentionRegexGlobal)
+	const result: (string | JSX.Element)[] = []
+
+	for (let i = 0; i < parts.length; i++) {
+		if (i % 2 === 0) {
+			if (parts[i]) {
+				result.push(parts[i])
+			}
+		} else {
+			result.push(
+				<span
+					className={`${withShadow ? "mention-context-highlight-with-shadow" : "mention-context-highlight"} cursor-pointer`}
+					key={`mention-${Math.floor(i / 2)}`}
+					onClick={() => FileServiceClient.openMention(StringRequest.create({ value: parts[i] }))}>
+					@{parts[i]}
+				</span>,
+			)
+		}
+	}
+
+	return result.length === 1 ? result[0] : result
+}
+
+export const highlightText = (text?: string, withShadow = true) => {
+	if (!text) {
+		return text
+	}
+
+	const slashResult = highlightSlashCommands(text, withShadow)
+
+	if (slashResult === text) {
+		return highlightMentions(text, withShadow)
+	}
+
+	if (Array.isArray(slashResult) && slashResult.length === 3) {
+		const [beforeCommand, commandElement, afterCommand] = slashResult as [string, JSX.Element, string]
+		const mentionResult = highlightMentions(afterCommand, withShadow)
+
+		return Array.isArray(mentionResult)
+			? [beforeCommand, commandElement, ...mentionResult]
+			: [beforeCommand, commandElement, mentionResult]
+	}
+
+	return slashResult
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/StickyUserMessage.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/StickyUserMessage.tsx
new file mode 100644
index 0000000..3ce11ad
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/StickyUserMessage.tsx
@@ -0,0 +1,81 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import React, { memo, useCallback } from "react"
+import { cn } from "@/lib/utils"
+import { highlightText } from "./Highlights"
+
+interface StickyUserMessageProps {
+	readonly lastUserMessage: ClineMessage | null
+	readonly onScrollToMessage?: () => void
+	readonly isVisible: boolean
+}
+
+/**
+ * A sticky header component that displays the last user message
+ * Shows when user scrolls down, allowing quick navigation back to their message
+ */
+export const StickyUserMessage: React.FC<StickyUserMessageProps> = memo(
+	({ lastUserMessage, onScrollToMessage, isVisible }) => {
+		const handleClick = useCallback(() => {
+			if (onScrollToMessage) {
+				onScrollToMessage()
+			}
+		}, [onScrollToMessage])
+
+		const handleKeyDown = useCallback(
+			(e: React.KeyboardEvent) => {
+				if (e.key === "Enter" || e.key === " ") {
+					e.preventDefault()
+					if (onScrollToMessage) {
+						onScrollToMessage()
+					}
+				}
+			},
+			[onScrollToMessage],
+		)
+
+		// Don't render if no user message or not visible
+		if (!lastUserMessage?.text || !isVisible) {
+			return null
+		}
+
+		const messageText = lastUserMessage.text.trim()
+
+		return (
+			<div
+				aria-label={`Scroll to your message: ${messageText}`}
+				className={cn(
+					"relative flex items-center px-2.5 pt-2 pb-2 cursor-pointer select-none",
+					"backdrop-blur-sm",
+					"hover:brightness-110",
+				)}
+				onClick={handleClick}
+				onKeyDown={handleKeyDown}
+				role="button"
+				style={{
+					backgroundColor: "var(--vscode-badge-background)",
+					borderRadius: "3px",
+				}}
+				tabIndex={0}
+				title="Click to scroll to your message">
+				{/* Message text (truncated via CSS text-ellipsis) */}
+				<div
+					className={cn(
+						"flex-1 min-w-0 text-sm text-badge-foreground",
+						"overflow-hidden text-ellipsis whitespace-nowrap",
+						"ph-no-capture",
+					)}>
+					{highlightText(messageText, false)}
+				</div>
+			</div>
+		)
+	},
+	(prevProps, nextProps) => {
+		return (
+			prevProps.lastUserMessage?.ts === nextProps.lastUserMessage?.ts &&
+			prevProps.lastUserMessage?.text === nextProps.lastUserMessage?.text &&
+			prevProps.isVisible === nextProps.isVisible
+		)
+	},
+)
+
+StickyUserMessage.displayName = "StickyUserMessage"
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/TaskHeader.stories.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/TaskHeader.stories.tsx
new file mode 100644
index 0000000..1f5e86b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/TaskHeader.stories.tsx
@@ -0,0 +1,451 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import { createStorybookDecorator } from "@/config/StorybookDecorator"
+import { Environment } from "../../../../../src/config"
+import TaskHeader from "./TaskHeader"
+
+const meta: Meta<typeof TaskHeader> = {
+	title: "Views/Components/TaskHeader",
+	component: TaskHeader,
+	parameters: {
+		layout: "padded",
+		docs: {
+			description: {
+				component:
+					"TaskHeader displays task information, token usage, cost, and provides controls for task management. It includes expandable details, context window visualization, and task timeline.",
+			},
+		},
+	},
+	decorators: [createStorybookDecorator()],
+	argTypes: {
+		tokensIn: { control: "number", description: "Input tokens used" },
+		tokensOut: { control: "number", description: "Output tokens used" },
+		cacheWrites: { control: "number", description: "Cache write tokens" },
+		cacheReads: { control: "number", description: "Cache read tokens" },
+		totalCost: { control: "number", description: "Total cost in USD" },
+		doesModelSupportPromptCache: { control: "boolean", description: "Whether model supports prompt caching" },
+	},
+}
+
+export default meta
+type Story = StoryObj<typeof TaskHeader>
+
+// Helper to create mock task messages
+const createTask = (text: string, images?: string[], files?: string[]): ClineMessage => ({
+	ts: Date.now(),
+	type: "say",
+	say: "task",
+	text,
+	images,
+	files,
+})
+
+// Helper to create mock messages for timeline
+const createMessages = (): ClineMessage[] => [
+	{
+		ts: Date.now() - 300000,
+		type: "say",
+		say: "task",
+		text: "Create a React component",
+	},
+	{
+		ts: Date.now() - 240000,
+		type: "say",
+		say: "text",
+		text: "I'll help you create a React component.",
+	},
+	{
+		ts: Date.now() - 180000,
+		type: "say",
+		say: "tool",
+		text: JSON.stringify({ tool: "write_to_file", path: "Component.tsx" }),
+	},
+	{
+		ts: Date.now() - 120000,
+		type: "say",
+		say: "text",
+		text: "Component created successfully.",
+	},
+]
+
+export const Collapsed: Story = {
+	args: {
+		task: createTask("Create a responsive navigation component for a React application"),
+		tokensIn: 2500,
+		tokensOut: 1200,
+		cacheWrites: 350,
+		cacheReads: 180,
+		totalCost: 0.085,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: false,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader in collapsed state showing task title, cost, and new task button.",
+			},
+		},
+	},
+}
+
+export const Expanded: Story = {
+	args: {
+		task: createTask("Create a responsive navigation component for a React application"),
+		tokensIn: 2500,
+		tokensOut: 1200,
+		cacheWrites: 350,
+		cacheReads: 180,
+		totalCost: 0.085,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader in expanded state showing full task details, context window, and timeline.",
+			},
+		},
+	},
+}
+
+export const WithImages: Story = {
+	args: {
+		task: createTask(
+			"Analyze these screenshots and identify UI issues",
+			["https://via.placeholder.com/400x300?text=Screenshot1", "https://via.placeholder.com/400x300?text=Screenshot2"],
+			undefined,
+		),
+		tokensIn: 3200,
+		tokensOut: 1800,
+		cacheWrites: 450,
+		cacheReads: 220,
+		totalCost: 0.125,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with attached images displayed as thumbnails.",
+			},
+		},
+	},
+}
+
+export const WithFiles: Story = {
+	args: {
+		task: createTask("Review these configuration files and suggest improvements", undefined, [
+			"package.json",
+			"tsconfig.json",
+			"vite.config.ts",
+		]),
+		tokensIn: 4500,
+		tokensOut: 2400,
+		cacheWrites: 680,
+		cacheReads: 340,
+		totalCost: 0.185,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with attached files displayed as thumbnails.",
+			},
+		},
+	},
+}
+
+export const LongTaskText: Story = {
+	args: {
+		task: createTask(
+			"Create a comprehensive e-commerce application with the following features:\n1. User authentication and authorization\n2. Product catalog with search and filtering\n3. Shopping cart functionality\n4. Checkout process with payment integration\n5. Order management system\n6. Admin dashboard for managing products and orders\n7. Responsive design for mobile and desktop\n8. Performance optimization and caching\n9. SEO optimization\n10. Analytics integration",
+		),
+		tokensIn: 5200,
+		tokensOut: 3100,
+		cacheWrites: 820,
+		cacheReads: 410,
+		totalCost: 0.245,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with long task text that can be expanded to show full content.",
+			},
+		},
+	},
+}
+
+export const HighTokenUsage: Story = {
+	args: {
+		task: createTask("Refactor large codebase with TypeScript migration"),
+		tokensIn: 45000,
+		tokensOut: 28000,
+		cacheWrites: 5200,
+		cacheReads: 3800,
+		totalCost: 1.85,
+		lastApiReqTotalTokens: 73000,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+				actModeOpenRouterModelInfo: {
+					contextWindow: 200000,
+					maxTokens: 8000,
+					supportsPromptCache: true,
+				},
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader showing high token usage approaching context window limits.",
+			},
+		},
+	},
+}
+
+export const NoCost: Story = {
+	args: {
+		task: createTask("Test local model with Ollama"),
+		tokensIn: 1500,
+		tokensOut: 800,
+		totalCost: 0,
+		doesModelSupportPromptCache: false,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "ollama",
+				actModeApiModelId: "llama3.2",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with local model (Ollama) showing no cost information.",
+			},
+		},
+	},
+}
+
+export const WithProgressMessage: Story = {
+	args: {
+		task: createTask("Build a REST API with Express and MongoDB"),
+		tokensIn: 3500,
+		tokensOut: 2100,
+		cacheWrites: 520,
+		cacheReads: 280,
+		totalCost: 0.145,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with progress checklist displayed in FocusChain component.",
+			},
+		},
+	},
+}
+
+export const LocalEnvironment: Story = {
+	args: {
+		task: createTask("Test feature in local environment"),
+		tokensIn: 2200,
+		tokensOut: 1400,
+		totalCost: 0.095,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			environment: Environment.local,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with local environment border color (yellow/orange warning).",
+			},
+		},
+	},
+}
+
+export const StagingEnvironment: Story = {
+	args: {
+		task: createTask("Deploy to staging environment"),
+		tokensIn: 2800,
+		tokensOut: 1600,
+		totalCost: 0.115,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			environment: Environment.staging,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with staging environment border color (blue).",
+			},
+		},
+	},
+}
+
+export const ProductionEnvironment: Story = {
+	args: {
+		task: createTask("Deploy to production environment"),
+		tokensIn: 3100,
+		tokensOut: 1900,
+		totalCost: 0.135,
+		doesModelSupportPromptCache: true,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			environment: Environment.production,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: createMessages(),
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with production environment (default colors).",
+			},
+		},
+	},
+}
+
+export const MinimalTask: Story = {
+	args: {
+		task: createTask("Fix typo"),
+		tokensIn: 150,
+		tokensOut: 80,
+		totalCost: 0.005,
+		doesModelSupportPromptCache: false,
+		onClose: () => console.log("Close clicked"),
+	},
+	decorators: [
+		createStorybookDecorator({
+			expandTaskHeader: true,
+			apiConfiguration: {
+				actModeApiProvider: "anthropic",
+				actModeApiModelId: "claude-3-5-sonnet-20241022",
+			},
+			clineMessages: [
+				{
+					ts: Date.now() - 60000,
+					type: "say",
+					say: "task",
+					text: "Fix typo",
+				},
+				{
+					ts: Date.now() - 30000,
+					type: "say",
+					say: "text",
+					text: "Fixed the typo.",
+				},
+			],
+		}),
+	],
+	parameters: {
+		docs: {
+			description: {
+				story: "TaskHeader with minimal task showing basic functionality.",
+			},
+		},
+	},
+}
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/TaskHeader.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/TaskHeader.tsx
new file mode 100644
index 0000000..1b0268d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/TaskHeader.tsx
@@ -0,0 +1,221 @@
+import { ClineMessage } from "@shared/ExtensionMessage"
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import React, { useCallback, useLayoutEffect, useMemo, useState } from "react"
+import Thumbnails from "@/components/common/Thumbnails"
+import { getModeSpecificFields } from "@/components/settings/utils/providerUtils"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useNormalizedApiConfiguration } from "@/hooks/useNormalizedApiConfiguration"
+import { useProviderUsageCostDisplay } from "@/hooks/useProviderUsageCostDisplay"
+import { cn } from "@/lib/utils"
+import { getEnvironmentColor } from "@/utils/environmentColors"
+import CopyTaskButton from "./buttons/CopyTaskButton"
+import DeleteTaskButton from "./buttons/DeleteTaskButton"
+import NewTaskButton from "./buttons/NewTaskButton"
+import OpenDiskConversationHistoryButton from "./buttons/OpenDiskConversationHistoryButton"
+import ContextWindow from "./ContextWindow"
+import { highlightText } from "./Highlights"
+
+const IS_DEV = process.env.IS_DEV === "true"
+interface TaskHeaderProps {
+	task: ClineMessage
+	tokensIn: number
+	tokensOut: number
+	doesModelSupportPromptCache: boolean
+	cacheWrites?: number
+	cacheReads?: number
+	totalCost: number
+	lastApiReqTotalTokens?: number
+	onClose: () => void
+	onSendMessage?: (command: string, files: string[], images: string[]) => void
+}
+
+const BUTTON_CLASS = "max-h-3 border-0 font-bold bg-transparent hover:opacity-100 text-foreground"
+
+const TaskHeader: React.FC<TaskHeaderProps> = ({
+	task,
+	tokensIn,
+	tokensOut,
+	cacheWrites,
+	cacheReads,
+	totalCost,
+	lastApiReqTotalTokens,
+	onClose,
+	onSendMessage,
+}) => {
+	const {
+		apiConfiguration,
+		currentTaskItem,
+		mode,
+		expandTaskHeader: isTaskExpanded,
+		setExpandTaskHeader: setIsTaskExpanded,
+		environment,
+	} = useExtensionState()
+
+	const [isHighlightedTextExpanded, setIsHighlightedTextExpanded] = useState(false)
+	const [isTextOverflowing, setIsTextOverflowing] = useState(false)
+	const highlightedTextRef = React.useRef<HTMLDivElement>(null)
+
+	const highlightedText = useMemo(() => highlightText(task.text, false), [task.text])
+
+	// Check if text overflows the container (i.e., needs clamping)
+	useLayoutEffect(() => {
+		const el = highlightedTextRef.current
+		if (el && isTaskExpanded && !isHighlightedTextExpanded) {
+			// Check if content height exceeds the max-height
+			setIsTextOverflowing(el.scrollHeight > el.clientHeight)
+		}
+	}, [task.text, isTaskExpanded, isHighlightedTextExpanded])
+
+	// Handle click outside to collapse
+	React.useEffect(() => {
+		if (!isHighlightedTextExpanded) {
+			return
+		}
+
+		const handleClickOutside = (event: MouseEvent) => {
+			if (highlightedTextRef.current && !highlightedTextRef.current.contains(event.target as Node)) {
+				setIsHighlightedTextExpanded(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => document.removeEventListener("mousedown", handleClickOutside)
+	}, [isHighlightedTextExpanded])
+
+	// Simplified computed values
+	const { selectedModelInfo } = useNormalizedApiConfiguration(mode)
+	const modeFields = getModeSpecificFields(apiConfiguration, mode)
+
+	// Local providers report no cost; the openai-compatible provider can
+	// report cost only when the user has supplied both prices. For every
+	// other provider, the SDK is the source of truth for whether to render
+	// per-task cost: providers with `metadata.usageCostDisplay = "hide"`
+	// (e.g. ChatGPT Plus/Pro subscription) are filtered out here. This
+	// mirrors the CLI's `shouldShowCliUsageCost` consumer and removes the
+	// previous extension-side hard-coded "openai-codex" check.
+	const usageCostDisplay = useProviderUsageCostDisplay(modeFields.apiProvider)
+	const isCostAvailable =
+		(totalCost &&
+			modeFields.apiProvider === "openai" &&
+			modeFields.openAiModelInfo?.inputPrice &&
+			modeFields.openAiModelInfo?.outputPrice) ||
+		(modeFields.apiProvider !== "vscode-lm" &&
+			modeFields.apiProvider !== "ollama" &&
+			modeFields.apiProvider !== "lmstudio" &&
+			usageCostDisplay !== "hide")
+
+	// Event handlers
+	const toggleTaskExpanded = useCallback(() => setIsTaskExpanded(!isTaskExpanded), [setIsTaskExpanded, isTaskExpanded])
+
+	const environmentBorderColor = getEnvironmentColor(environment, "border")
+
+	return (
+		<div className="py-2 px-4 flex flex-col gap-2">
+			{/* Task Header */}
+			<div
+				className={cn(
+					"relative overflow-hidden cursor-pointer rounded-sm flex flex-col gap-1.5 z-10 pt-2 pb-2 px-2 hover:opacity-100 bg-(--vscode-toolbar-hoverBackground)/65",
+					{
+						"opacity-100 border-1": isTaskExpanded, // No hover effects when expanded, add border
+						"hover:bg-toolbar-hover border-1": !isTaskExpanded, // Hover effects only when collapsed
+					},
+				)}
+				style={{
+					borderColor: environmentBorderColor,
+				}}>
+				{/* Task Title */}
+				<div
+					aria-label={isTaskExpanded ? "Collapse task header" : "Expand task header"}
+					className="flex justify-between items-center cursor-pointer"
+					onClick={toggleTaskExpanded}
+					onKeyDown={(e) => {
+						if (e.key === "Enter" || e.key === " ") {
+							e.preventDefault()
+							e.stopPropagation()
+							toggleTaskExpanded()
+						}
+					}}
+					tabIndex={0}>
+					<div className="flex justify-between items-center">
+						{isTaskExpanded ? <ChevronDownIcon size="16" /> : <ChevronRightIcon size="16" />}
+						{isTaskExpanded && (
+							<div className="mt-1 flex justify-end cursor-pointer opacity-80 gap-2 mx-2">
+								<CopyTaskButton className={BUTTON_CLASS} taskText={task.text} />
+								<DeleteTaskButton
+									className={BUTTON_CLASS}
+									taskId={currentTaskItem?.id}
+									taskSize={currentTaskItem?.size}
+								/>
+								{/* Only visible in development mode */}
+								{IS_DEV && (
+									<OpenDiskConversationHistoryButton className={BUTTON_CLASS} taskId={currentTaskItem?.id} />
+								)}
+							</div>
+						)}
+					</div>
+					<div className="flex items-center select-none grow min-w-0 gap-1 justify-between">
+						{!isTaskExpanded && (
+							<div className="whitespace-nowrap overflow-hidden text-ellipsis grow min-w-0">
+								<span className="ph-no-capture text-base">{highlightedText}</span>
+							</div>
+						)}
+					</div>
+					<div className="inline-flex items-center justify-end select-none shrink-0">
+						{isCostAvailable && (
+							<div
+								className="mx-1 px-1 py-0.25 rounded-full inline-flex shrink-0 text-badge-background bg-badge-foreground/80 items-center"
+								id="price-tag">
+								<span className="text-xs sm:text-sm">${totalCost?.toFixed(4)}</span>
+							</div>
+						)}
+						<NewTaskButton className={BUTTON_CLASS} onClick={onClose} />
+					</div>
+				</div>
+
+				{/* Expand/Collapse Task Details */}
+				{isTaskExpanded && (
+					<div className="flex flex-col break-words" key={`task-details-${currentTaskItem?.id}`}>
+						<div
+							className={cn(
+								"ph-no-capture whitespace-pre-wrap break-words px-0.5 text-sm mt-1 relative",
+								"max-h-[4.5rem] overflow-hidden",
+								{
+									"max-h-[25vh] overflow-y-auto scroll-smooth": isHighlightedTextExpanded,
+									"cursor-pointer": isTextOverflowing,
+								},
+							)}
+							onClick={() => isTextOverflowing && setIsHighlightedTextExpanded(true)}
+							ref={highlightedTextRef}
+							style={
+								!isHighlightedTextExpanded && isTextOverflowing
+									? {
+											WebkitMaskImage: "linear-gradient(to bottom, black 60%, transparent 100%)",
+											maskImage: "linear-gradient(to bottom, black 60%, transparent 100%)",
+										}
+									: undefined
+							}>
+							{highlightedText}
+						</div>
+
+						{((task.images && task.images.length > 0) || (task.files && task.files.length > 0)) && (
+							<Thumbnails files={task.files ?? []} images={task.images ?? []} />
+						)}
+
+						<ContextWindow
+							cacheReads={cacheReads}
+							cacheWrites={cacheWrites}
+							contextWindow={selectedModelInfo?.contextWindow}
+							lastApiReqTotalTokens={lastApiReqTotalTokens}
+							onSendMessage={onSendMessage}
+							tokensIn={tokensIn}
+							tokensOut={tokensOut}
+							useAutoCondense={false} // Disable auto-condense configuration in UI for now
+						/>
+					</div>
+				)}
+			</div>
+		</div>
+	)
+}
+
+export default TaskHeader
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/CompactTaskButton.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/CompactTaskButton.tsx
new file mode 100644
index 0000000..d246e3e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/CompactTaskButton.tsx
@@ -0,0 +1,31 @@
+import { FoldVerticalIcon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { cn } from "@/lib/utils"
+
+const CompactTaskButton: React.FC<{
+	className?: string
+	onClick: (e: React.MouseEvent<HTMLButtonElement>) => void
+}> = ({ onClick, className }) => {
+	return (
+		<Tooltip>
+			<TooltipContent side="left">Compact Task</TooltipContent>
+			<TooltipTrigger className={cn("flex items-center", className)}>
+				<Button
+					aria-label="Compact Task"
+					className="[&_svg]:size-3"
+					onClick={(e) => {
+						e.preventDefault()
+						e.stopPropagation()
+						onClick(e)
+					}}
+					size="icon"
+					variant="icon">
+					<FoldVerticalIcon />
+				</Button>
+			</TooltipTrigger>
+		</Tooltip>
+	)
+}
+
+export default CompactTaskButton
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/CopyTaskButton.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/CopyTaskButton.tsx
new file mode 100644
index 0000000..e7a327d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/CopyTaskButton.tsx
@@ -0,0 +1,44 @@
+import { cn } from "@heroui/react"
+import { CheckIcon, CopyIcon } from "lucide-react"
+import { useCallback, useState } from "react"
+import { Button } from "@/components/ui/button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+
+const CopyTaskButton: React.FC<{
+	taskText?: string
+	className?: string
+}> = ({ taskText, className }) => {
+	const [copied, setCopied] = useState(false)
+
+	const handleCopy = useCallback(() => {
+		if (!taskText) {
+			return
+		}
+
+		navigator.clipboard.writeText(taskText).then(() => {
+			setCopied(true)
+			setTimeout(() => setCopied(false), 1500)
+		})
+	}, [taskText])
+
+	return (
+		<Tooltip>
+			<TooltipContent side="bottom">Copy Text</TooltipContent>
+			<TooltipTrigger className={cn("flex items-center", className)}>
+				<Button
+					aria-label="Copy"
+					onClick={(e) => {
+						e.preventDefault()
+						e.stopPropagation()
+						handleCopy()
+					}}
+					size="icon"
+					variant="icon">
+					{copied ? <CheckIcon /> : <CopyIcon />}
+				</Button>
+			</TooltipTrigger>
+		</Tooltip>
+	)
+}
+
+export default CopyTaskButton
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/DeleteTaskButton.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/DeleteTaskButton.tsx
new file mode 100644
index 0000000..423a1a9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/DeleteTaskButton.tsx
@@ -0,0 +1,34 @@
+import { StringArrayRequest } from "@shared/proto/cline/common"
+import { TrashIcon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { cn } from "@/lib/utils"
+import { TaskServiceClient } from "@/services/grpc-client"
+import { formatDeleteTaskSizeLabel } from "./formatDeleteTaskSizeLabel"
+
+const DeleteTaskButton: React.FC<{
+	taskId?: string
+	taskSize?: number
+	className?: string
+}> = ({ taskId, className, taskSize }) => (
+	<Tooltip>
+		<TooltipContent>{`Delete Task (size: ${formatDeleteTaskSizeLabel(taskSize)})`}</TooltipContent>
+		<TooltipTrigger className={cn("flex items-center", className)}>
+			<Button
+				aria-label="Delete Task"
+				disabled={!taskId}
+				onClick={(e) => {
+					e.preventDefault()
+					e.stopPropagation()
+					taskId && TaskServiceClient.deleteTasksWithIds(StringArrayRequest.create({ value: [taskId] }))
+				}}
+				size="xs"
+				variant="icon">
+				<TrashIcon />
+			</Button>
+		</TooltipTrigger>
+	</Tooltip>
+)
+DeleteTaskButton.displayName = "DeleteTaskButton"
+
+export default DeleteTaskButton
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/NewTaskButton.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/NewTaskButton.tsx
new file mode 100644
index 0000000..463916e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/NewTaskButton.tsx
@@ -0,0 +1,30 @@
+import { XIcon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { cn } from "@/lib/utils"
+
+const NewTaskButton: React.FC<{
+	onClick: () => void
+	className?: string
+}> = ({ className, onClick }) => {
+	return (
+		<Tooltip>
+			<TooltipContent side="left">Start a New Task</TooltipContent>
+			<TooltipTrigger className={cn("flex items-center", className)}>
+				<Button
+					aria-label="New Task"
+					onClick={(e) => {
+						e.preventDefault()
+						e.stopPropagation()
+						onClick()
+					}}
+					size="icon"
+					variant="icon">
+					<XIcon />
+				</Button>
+			</TooltipTrigger>
+		</Tooltip>
+	)
+}
+
+export default NewTaskButton
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/OpenDiskConversationHistoryButton.tsx b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/OpenDiskConversationHistoryButton.tsx
new file mode 100644
index 0000000..e7f2641
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/OpenDiskConversationHistoryButton.tsx
@@ -0,0 +1,43 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { ArrowDownToLineIcon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { cn } from "@/lib/utils"
+import { TaskServiceClient } from "@/services/grpc-client"
+
+const OpenDiskConversationHistoryButton: React.FC<{
+	taskId?: string
+	className?: string
+}> = ({ taskId, className }) => {
+	const handleOpenDiskConversationHistory = () => {
+		if (!taskId) {
+			return
+		}
+
+		TaskServiceClient.exportTaskWithId(StringRequest.create({ value: taskId })).catch((err) =>
+			console.error("Failed to export task:", err),
+		)
+	}
+
+	return (
+		<Tooltip>
+			<TooltipContent>Open Conversation History File</TooltipContent>
+			<TooltipTrigger className={cn("flex items-center", className)}>
+				<Button
+					aria-label="Open Disk Conversation History"
+					onClick={(e) => {
+						e.preventDefault()
+						e.stopPropagation()
+						handleOpenDiskConversationHistory()
+					}}
+					size="icon"
+					variant="icon">
+					<ArrowDownToLineIcon />
+				</Button>
+			</TooltipTrigger>
+		</Tooltip>
+	)
+}
+
+OpenDiskConversationHistoryButton.displayName = "OpenDiskConversationHistoryButton"
+export default OpenDiskConversationHistoryButton
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/formatDeleteTaskSizeLabel.test.ts b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/formatDeleteTaskSizeLabel.test.ts
new file mode 100644
index 0000000..301727c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/formatDeleteTaskSizeLabel.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest"
+import { formatDeleteTaskSizeLabel } from "./formatDeleteTaskSizeLabel"
+
+describe("formatDeleteTaskSizeLabel", () => {
+	it("formats a zero byte task size", () => {
+		expect(formatDeleteTaskSizeLabel(0)).toBe("0 B")
+	})
+
+	it("formats a non-zero task size", () => {
+		expect(formatDeleteTaskSizeLabel(42)).toBe("42 B")
+	})
+
+	it("shows a placeholder when task size is unavailable", () => {
+		expect(formatDeleteTaskSizeLabel()).toBe("--")
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/chat/task-header/buttons/formatDeleteTaskSizeLabel.ts b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/formatDeleteTaskSizeLabel.ts
new file mode 100644
index 0000000..e092588
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/chat/task-header/buttons/formatDeleteTaskSizeLabel.ts
@@ -0,0 +1,5 @@
+import { formatSize } from "@/utils/format"
+
+export function formatDeleteTaskSizeLabel(taskSize?: number) {
+	return taskSize === undefined ? "--" : formatSize(taskSize)
+}
diff --git a/apps/vscode/webview-ui/src/components/cline-rules/ClineRulesToggleModal.tsx b/apps/vscode/webview-ui/src/components/cline-rules/ClineRulesToggleModal.tsx
new file mode 100644
index 0000000..e15b640
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/cline-rules/ClineRulesToggleModal.tsx
@@ -0,0 +1,733 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import {
+	ClineRulesToggles,
+	RefreshedRules,
+	RuleScope,
+	SkillInfo,
+	ToggleAgentsRuleRequest,
+	ToggleClineRuleRequest,
+	ToggleCursorRuleRequest,
+	ToggleSkillRequest,
+	ToggleWindsurfRuleRequest,
+} from "@shared/proto/cline/file"
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import React, { useEffect, useRef, useState } from "react"
+import { useClickAway, useWindowSize } from "react-use"
+import styled from "styled-components"
+import PopupModalContainer from "@/components/common/PopupModalContainer"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import useRemoteConfigSettings from "@/hooks/useRemoteConfigSettings"
+import { FileServiceClient } from "@/services/grpc-client"
+import { isMacOSOrLinux } from "@/utils/platformUtils"
+import HookRow from "./HookRow"
+import NewRuleRow from "./NewRuleRow"
+import RuleRow from "./RuleRow"
+import RulesToggleList from "./RulesToggleList"
+
+const ClineRulesToggleModal: React.FC = () => {
+	const {
+		globalClineRulesToggles = {},
+		localClineRulesToggles = {},
+		localCursorRulesToggles = {},
+		localWindsurfRulesToggles = {},
+		localAgentsRulesToggles = {},
+		hooksEnabled,
+		setGlobalClineRulesToggles,
+		setLocalClineRulesToggles,
+		setLocalCursorRulesToggles,
+		setLocalWindsurfRulesToggles,
+		setLocalAgentsRulesToggles,
+		setLocalWorkflowToggles,
+		setGlobalWorkflowToggles,
+		setGlobalSkillsToggles,
+		setLocalSkillsToggles,
+		setRemoteRulesToggles,
+	} = useExtensionState()
+	const [globalHooks, setGlobalHooks] = useState<Array<{ name: string; enabled: boolean; absolutePath: string }>>([])
+	const [workspaceHooks, setWorkspaceHooks] = useState<
+		Array<{ workspaceName: string; hooks: Array<{ name: string; enabled: boolean; absolutePath: string }> }>
+	>([])
+	const [globalSkills, setGlobalSkills] = useState<SkillInfo[]>([])
+	const [localSkills, setLocalSkills] = useState<SkillInfo[]>([])
+
+	const isWindows = !isMacOSOrLinux()
+	const [isVisible, setIsVisible] = useState(false)
+	const buttonRef = useRef<HTMLDivElement>(null)
+	const modalRef = useRef<HTMLDivElement>(null)
+	const { width: viewportWidth, height: viewportHeight } = useWindowSize()
+	const [arrowPosition, setArrowPosition] = useState(0)
+	const [menuPosition, setMenuPosition] = useState(0)
+	const [currentView, setCurrentView] = useState<"rules" | "hooks" | "skills">("rules")
+
+	// Auto-switch to rules tab if hooks become disabled while viewing hooks tab
+	useEffect(() => {
+		if (currentView === "hooks" && !hooksEnabled) {
+			setCurrentView("rules")
+		}
+	}, [currentView, hooksEnabled])
+
+	useEffect(() => {
+		if (isVisible) {
+			FileServiceClient.refreshRules({} as EmptyRequest)
+				.then((response: RefreshedRules) => {
+					// Update state with the response data using all available setters
+					if (response.globalClineRulesToggles?.toggles) {
+						setGlobalClineRulesToggles(response.globalClineRulesToggles.toggles)
+					}
+					if (response.localClineRulesToggles?.toggles) {
+						setLocalClineRulesToggles(response.localClineRulesToggles.toggles)
+					}
+					if (response.localCursorRulesToggles?.toggles) {
+						setLocalCursorRulesToggles(response.localCursorRulesToggles.toggles)
+					}
+					if (response.localWindsurfRulesToggles?.toggles) {
+						setLocalWindsurfRulesToggles(response.localWindsurfRulesToggles.toggles)
+					}
+					if (response.localAgentsRulesToggles?.toggles) {
+						setLocalAgentsRulesToggles(response.localAgentsRulesToggles.toggles)
+					}
+					if (response.localWorkflowToggles?.toggles) {
+						setLocalWorkflowToggles(response.localWorkflowToggles.toggles)
+					}
+					if (response.globalWorkflowToggles?.toggles) {
+						setGlobalWorkflowToggles(response.globalWorkflowToggles.toggles)
+					}
+				})
+				.catch((error) => {
+					console.error("Failed to refresh rules:", error)
+				})
+		}
+	}, [
+		isVisible,
+		setGlobalClineRulesToggles,
+		setLocalClineRulesToggles,
+		setGlobalWorkflowToggles,
+		setLocalCursorRulesToggles,
+		setLocalWindsurfRulesToggles,
+		setLocalWorkflowToggles,
+	])
+
+	// Refresh hooks when hooks tab becomes visible
+	useEffect(() => {
+		if (!isVisible || currentView !== "hooks") {
+			return
+		}
+
+		const abortController = new AbortController()
+
+		// Initial refresh when tab opens
+		const refreshHooks = () => {
+			if (abortController.signal.aborted) return
+
+			FileServiceClient.refreshHooks({} as EmptyRequest)
+				.then((response) => {
+					if (!abortController.signal.aborted) {
+						setGlobalHooks(response.globalHooks || [])
+						setWorkspaceHooks(response.workspaceHooks || [])
+					}
+				})
+				.catch((error) => {
+					if (!abortController.signal.aborted) {
+						console.error("Failed to refresh hooks:", error)
+					}
+				})
+		}
+
+		// Refresh immediately
+		refreshHooks()
+
+		// Poll every 1 second to detect filesystem changes
+		const pollInterval = setInterval(refreshHooks, 1000)
+
+		return () => {
+			abortController.abort()
+			clearInterval(pollInterval)
+		}
+	}, [isVisible, currentView])
+
+	// Refresh skills when skills tab becomes visible
+	useEffect(() => {
+		if (!isVisible || currentView !== "skills") {
+			return
+		}
+
+		let isCancelled = false
+
+		const refreshSkills = () => {
+			if (isCancelled) return
+
+			FileServiceClient.refreshSkills({} as EmptyRequest)
+				.then((response) => {
+					if (!isCancelled) {
+						setGlobalSkills(response.globalSkills || [])
+						setLocalSkills(response.localSkills || [])
+					}
+				})
+				.catch((error) => {
+					if (!isCancelled) {
+						console.error("Failed to refresh skills:", error)
+					}
+				})
+		}
+
+		// Refresh immediately
+		refreshSkills()
+
+		// Poll every 1 second to detect filesystem changes
+		const pollInterval = setInterval(refreshSkills, 1000)
+
+		return () => {
+			isCancelled = true
+			clearInterval(pollInterval)
+		}
+	}, [isVisible, currentView])
+
+	// Format global rules for display with proper typing
+	const globalRules = Object.entries(globalClineRulesToggles || {})
+		.map(([path, enabled]): [string, boolean] => [path, enabled as boolean])
+		.sort(([a], [b]) => a.localeCompare(b))
+
+	// Format local rules for display with proper typing
+	const localRules = Object.entries(localClineRulesToggles || {})
+		.map(([path, enabled]): [string, boolean] => [path, enabled as boolean])
+		.sort(([a], [b]) => a.localeCompare(b))
+
+	const cursorRules = Object.entries(localCursorRulesToggles || {})
+		.map(([path, enabled]): [string, boolean] => [path, enabled as boolean])
+		.sort(([a], [b]) => a.localeCompare(b))
+
+	const windsurfRules = Object.entries(localWindsurfRulesToggles || {})
+		.map(([path, enabled]): [string, boolean] => [path, enabled as boolean])
+		.sort(([a], [b]) => a.localeCompare(b))
+
+	const agentsRules = Object.entries(localAgentsRulesToggles || {})
+		.map(([path, enabled]): [string, boolean] => [path, enabled as boolean])
+		.sort(([a], [b]) => a.localeCompare(b))
+
+	const remoteConfigSettings = useRemoteConfigSettings(isVisible)
+	const remoteRules = remoteConfigSettings.filter((s) => s.type === "rule")
+	const remoteSkills = remoteConfigSettings.filter((s) => s.type === "skill")
+	const hasRemoteRules = remoteRules.length > 0
+	const hasRemoteSkills = remoteSkills.length > 0
+
+	// Handle toggle rule using gRPC
+	const toggleRule = (isGlobal: boolean, rulePath: string, enabled: boolean) => {
+		FileServiceClient.toggleClineRule(
+			ToggleClineRuleRequest.create({
+				scope: isGlobal ? RuleScope.GLOBAL : RuleScope.LOCAL,
+				rulePath,
+				enabled,
+			}),
+		)
+			.then((response) => {
+				// Update the local state with the response
+				if (response.globalClineRulesToggles?.toggles) {
+					setGlobalClineRulesToggles(response.globalClineRulesToggles.toggles)
+				}
+				if (response.localClineRulesToggles?.toggles) {
+					setLocalClineRulesToggles(response.localClineRulesToggles.toggles)
+				}
+				if (response.remoteRulesToggles?.toggles) {
+					setRemoteRulesToggles(response.remoteRulesToggles.toggles)
+				}
+			})
+			.catch((error) => {
+				console.error("Error toggling Cline rule:", error)
+			})
+	}
+
+	const toggleCursorRule = (rulePath: string, enabled: boolean) => {
+		FileServiceClient.toggleCursorRule(
+			ToggleCursorRuleRequest.create({
+				rulePath,
+				enabled,
+			}),
+		)
+			.then((response) => {
+				// Update the local state with the response
+				if (response.toggles) {
+					setLocalCursorRulesToggles(response.toggles)
+				}
+			})
+			.catch((error) => {
+				console.error("Error toggling Cursor rule:", error)
+			})
+	}
+
+	const toggleWindsurfRule = (rulePath: string, enabled: boolean) => {
+		FileServiceClient.toggleWindsurfRule(
+			ToggleWindsurfRuleRequest.create({
+				rulePath,
+				enabled,
+			} as ToggleWindsurfRuleRequest),
+		)
+			.then((response: ClineRulesToggles) => {
+				if (response.toggles) {
+					setLocalWindsurfRulesToggles(response.toggles)
+				}
+			})
+			.catch((error) => {
+				console.error("Error toggling Windsurf rule:", error)
+			})
+	}
+
+	const toggleAgentsRule = (rulePath: string, enabled: boolean) => {
+		FileServiceClient.toggleAgentsRule(
+			ToggleAgentsRuleRequest.create({
+				rulePath,
+				enabled,
+			} as ToggleAgentsRuleRequest),
+		)
+			.then((response: ClineRulesToggles) => {
+				if (response.toggles) {
+					setLocalAgentsRulesToggles(response.toggles)
+				}
+			})
+			.catch((error) => {
+				console.error("Error toggling Agents rule:", error)
+			})
+	}
+
+	// Toggle hook handler
+	const toggleHook = (isGlobal: boolean, hookName: string, enabled: boolean, workspaceName?: string) => {
+		FileServiceClient.toggleHook({
+			metadata: {} as any,
+			hookName,
+			isGlobal,
+			enabled,
+			workspaceName,
+		})
+			.then((response) => {
+				setGlobalHooks(response.hooksToggles?.globalHooks || [])
+				setWorkspaceHooks(response.hooksToggles?.workspaceHooks || [])
+			})
+			.catch((error) => {
+				console.error("Error toggling hook:", error)
+			})
+	}
+
+	// Handle toggle for skills
+	const toggleSkill = (isGlobal: boolean, skillPath: string, enabled: boolean) => {
+		FileServiceClient.toggleSkill(
+			ToggleSkillRequest.create({
+				skillPath,
+				isGlobal,
+				enabled,
+			}),
+		)
+			.then((response) => {
+				if (response.globalSkillsToggles) {
+					setGlobalSkillsToggles(response.globalSkillsToggles)
+				}
+				if (response.localSkillsToggles) {
+					setLocalSkillsToggles(response.localSkillsToggles)
+				}
+				// Update local skills state
+				if (skillPath.startsWith("remote:")) {
+					setGlobalSkills((prev) => prev.map((s) => (s.path === skillPath ? { ...s, enabled } : s)))
+				} else if (isGlobal) {
+					setGlobalSkills((prev) => prev.map((s) => (s.path === skillPath ? { ...s, enabled } : s)))
+				} else {
+					setLocalSkills((prev) => prev.map((s) => (s.path === skillPath ? { ...s, enabled } : s)))
+				}
+			})
+			.catch((error) => {
+				console.error("Error toggling skill:", error)
+			})
+	}
+
+	// Close modal when clicking outside
+	useClickAway(modalRef, () => {
+		setIsVisible(false)
+	})
+
+	// Calculate positions for modal and arrow
+	useEffect(() => {
+		if (isVisible && buttonRef.current) {
+			const buttonRect = buttonRef.current.getBoundingClientRect()
+			const buttonCenter = buttonRect.left + buttonRect.width / 2
+			const rightPosition = document.documentElement.clientWidth - buttonCenter - 5
+
+			setArrowPosition(rightPosition)
+			setMenuPosition(buttonRect.top + 1)
+		}
+	}, [isVisible, viewportWidth, viewportHeight])
+
+	return (
+		<div className="inline-flex min-w-0 max-w-full items-center" ref={modalRef}>
+			<div className="inline-flex w-full items-center" ref={buttonRef}>
+				<Tooltip>
+					{!isVisible && <TooltipContent>Customize</TooltipContent>}
+					<TooltipTrigger>
+						<VSCodeButton
+							appearance="icon"
+							aria-label={isVisible ? "Hide Customize" : "Show Customize"}
+							className="p-0 m-0 flex items-center"
+							onClick={() => setIsVisible(!isVisible)}>
+							<i className="codicon codicon-law" style={{ fontSize: "12.5px" }} />
+						</VSCodeButton>
+					</TooltipTrigger>
+				</Tooltip>
+			</div>
+
+			{isVisible && (
+				<PopupModalContainer $arrowPosition={arrowPosition} $menuPosition={menuPosition}>
+					{/* Fixed header section - tabs and description */}
+					<div className="flex-shrink-0 px-3 pt-2">
+						{/* Tabs container */}
+						<div
+							style={{
+								display: "flex",
+								justifyContent: "space-between",
+								marginBottom: "10px",
+								overflow: "hidden",
+							}}>
+							<div
+								style={{
+									display: "flex",
+									gap: "1px",
+									borderBottom: "1px solid var(--vscode-panel-border)",
+									flexWrap: "wrap",
+								}}>
+								<TabButton isActive={currentView === "rules"} onClick={() => setCurrentView("rules")}>
+									Rules
+								</TabButton>
+								{hooksEnabled && (
+									<TabButton isActive={currentView === "hooks"} onClick={() => setCurrentView("hooks")}>
+										Hooks
+									</TabButton>
+								)}
+								<TabButton isActive={currentView === "skills"} onClick={() => setCurrentView("skills")}>
+									Skills
+								</TabButton>
+							</div>
+						</div>
+
+						{/* Remote config banner */}
+						{(currentView === "rules" && hasRemoteRules) || (currentView === "skills" && hasRemoteSkills) ? (
+							<div className="flex items-center gap-2 px-3 py-3 mb-4 bg-vscode-textBlockQuote-background border-l-[3px] border-vscode-textLink-foreground">
+								<i className="codicon codicon-lock text-sm" />
+								<span className="text-base">
+									{currentView === "rules"
+										? "Your organization manages some rules"
+										: "Your organization manages some skills"}
+								</span>
+							</div>
+						) : null}
+
+						{/* Description text */}
+						<div className="text-xs text-description mb-4">
+							{currentView === "rules" ? (
+								<p>
+									Rules allow you to provide Cline with system-level guidance. Think of them as a persistent way
+									to include context and preferences for your projects or globally for every conversation.{" "}
+									<VSCodeLink
+										className="text-xs"
+										href="https://docs.cline.bot/features/cline-rules"
+										style={{ display: "inline", fontSize: "inherit" }}>
+										Docs
+									</VSCodeLink>
+								</p>
+							) : currentView === "skills" ? (
+								<p>
+									Skills are reusable instruction sets that Cline can activate on-demand. When a task matches a
+									skill's description, Cline uses the <span className="font-bold">use_skill</span> tool to load
+									the full instructions.
+								</p>
+							) : (
+								<p>
+									Hooks allow you to execute custom scripts at specific points in Cline's execution lifecycle,
+									enabling automation and integration with external tools.
+								</p>
+							)}
+						</div>
+					</div>
+
+					{/* Scrollable content area */}
+					<div className="flex-1 overflow-y-auto px-3 pb-3" style={{ minHeight: 0 }}>
+						{currentView === "rules" ? (
+							<>
+								{/* Remote Rules Section */}
+								{hasRemoteRules && (
+									<div className="mb-3">
+										<div className="text-sm font-normal mb-2">Enterprise Rules</div>
+										<div className="flex flex-col gap-0">
+											{remoteRules.map((rule) => {
+												const enabled = rule.locked || rule.enabled
+												return (
+													<RuleRow
+														alwaysEnabled={rule.locked}
+														enabled={enabled}
+														isGlobal={false}
+														isRemote={true}
+														key={rule.name}
+														rulePath={rule.name}
+														ruleType="cline"
+														toggleRule={rule.toggle}
+													/>
+												)
+											})}
+										</div>
+									</div>
+								)}
+
+								{/* Global Rules Section */}
+								<div className="mb-3">
+									<div className="text-sm font-normal mb-2">Global Rules</div>
+
+									{/* File-based Global Rules */}
+									<RulesToggleList
+										isGlobal={true}
+										listGap="small"
+										rules={globalRules}
+										ruleType={"cline"}
+										showNewRule={true}
+										showNoRules={false}
+										toggleRule={(rulePath, enabled) => toggleRule(true, rulePath, enabled)}
+									/>
+								</div>
+
+								{/* Local Rules Section */}
+								<div className="-mb-2.5">
+									<div className="text-sm font-normal mb-2">Workspace Rules</div>
+									<RulesToggleList
+										isGlobal={false}
+										listGap="small"
+										rules={localRules}
+										ruleType={"cline"}
+										showNewRule={false}
+										showNoRules={false}
+										toggleRule={(rulePath, enabled) => toggleRule(false, rulePath, enabled)}
+									/>
+
+									<RulesToggleList
+										isGlobal={false}
+										listGap="small"
+										rules={cursorRules}
+										ruleType={"cursor"}
+										showNewRule={false}
+										showNoRules={false}
+										toggleRule={toggleCursorRule}
+									/>
+									<RulesToggleList
+										isGlobal={false}
+										listGap="small"
+										rules={windsurfRules}
+										ruleType={"windsurf"}
+										showNewRule={false}
+										showNoRules={false}
+										toggleRule={toggleWindsurfRule}
+									/>
+									<RulesToggleList
+										isGlobal={false}
+										listGap="small"
+										rules={agentsRules}
+										ruleType={"agents"}
+										showNewRule={true}
+										showNoRules={false}
+										toggleRule={toggleAgentsRule}
+									/>
+								</div>
+							</>
+						) : currentView === "hooks" ? (
+							<>
+								<div className="text-xs text-description mb-4">
+									<p>
+										{isWindows
+											? "On Windows, hooks execute whenever the hook file exists."
+											: "Toggle to enable/disable (chmod +x/-x)."}{" "}
+										<VSCodeLink
+											className="text-xs"
+											href="https://docs.cline.bot/features/hooks"
+											style={{ display: "inline", fontSize: "inherit" }}>
+											Docs
+										</VSCodeLink>
+									</p>
+								</div>
+								{/* Hooks Tab */}
+								{/* Windows warning banner */}
+								{isWindows && (
+									<div className="flex items-center gap-2 px-3 py-3 mb-4 bg-vscode-inputValidation-warningBackground border-l-[3px] border-vscode-inputValidation-warningBorder">
+										<i className="codicon codicon-warning text-sm" />
+										<span className="text-base">
+											Hook toggling is not yet supported on Windows in this foundation PR. Hooks can be
+											created, edited, and deleted, and execute whenever the hook file exists. Coming next:
+											JSON-backed hook enabled/disabled state across platforms.
+										</span>
+									</div>
+								)}
+
+								{/* Global Hooks */}
+								<div className="mb-3">
+									<div className="text-sm font-normal mb-2">Global Hooks</div>
+									<div className="flex flex-col gap-0">
+										{globalHooks
+											.sort((a, b) => a.name.localeCompare(b.name))
+											.map((hook) => (
+												<HookRow
+													absolutePath={hook.absolutePath}
+													enabled={hook.enabled}
+													hookName={hook.name}
+													isGlobal={true}
+													isWindows={isWindows}
+													key={hook.name}
+													onDelete={(hooksToggles) => {
+														// Use response data directly, no need to refresh
+														setGlobalHooks(hooksToggles.globalHooks || [])
+														setWorkspaceHooks(hooksToggles.workspaceHooks || [])
+													}}
+													onToggle={(name: string, newEnabled: boolean) =>
+														toggleHook(true, name, newEnabled)
+													}
+												/>
+											))}
+										<NewRuleRow
+											existingHooks={globalHooks.map((h) => h.name)}
+											isGlobal={true}
+											ruleType="hook"
+										/>
+									</div>
+								</div>
+
+								{/* Workspace Hooks - one section per workspace */}
+								{workspaceHooks.map((workspace, index) => (
+									<div
+										className={index === workspaceHooks.length - 1 ? "-mb-2.5" : "mb-3"}
+										key={workspace.workspaceName}>
+										<div className="text-sm font-normal mb-2">
+											{workspace.workspaceName}/.clinerules/hooks/
+										</div>
+										<div className="flex flex-col gap-0">
+											{workspace.hooks
+												.sort((a, b) => a.name.localeCompare(b.name))
+												.map((hook) => (
+													<HookRow
+														absolutePath={hook.absolutePath}
+														enabled={hook.enabled}
+														hookName={hook.name}
+														isGlobal={false}
+														isWindows={isWindows}
+														key={hook.absolutePath}
+														onDelete={(hooksToggles) => {
+															// Use response data directly, no need to refresh
+															setGlobalHooks(hooksToggles.globalHooks || [])
+															setWorkspaceHooks(hooksToggles.workspaceHooks || [])
+														}}
+														onToggle={(name: string, newEnabled: boolean) =>
+															toggleHook(false, name, newEnabled, workspace.workspaceName)
+														}
+														workspaceName={workspace.workspaceName}
+													/>
+												))}
+											<NewRuleRow
+												existingHooks={workspace.hooks.map((h) => h.name)}
+												isGlobal={false}
+												ruleType="hook"
+												workspaceName={workspace.workspaceName}
+											/>
+										</div>
+									</div>
+								))}
+							</>
+						) : currentView === "skills" ? (
+							<>
+								{/* Enterprise Skills Section (remote) */}
+								{hasRemoteSkills && (
+									<div className="mb-3">
+										<div className="text-sm font-normal mb-2">Enterprise Skills</div>
+										<div className="flex flex-col gap-0">
+											{remoteSkills
+												.sort((a, b) => a.name.localeCompare(b.name))
+												.map((skill) => {
+													const enabled = skill.locked || skill.enabled
+													return (
+														<RuleRow
+															alwaysEnabled={skill.locked}
+															enabled={enabled}
+															isGlobal={true}
+															isRemote={true}
+															key={skill.name}
+															rulePath={skill.name}
+															ruleType="skill"
+															toggleRule={skill.toggle}
+														/>
+													)
+												})}
+										</div>
+									</div>
+								)}
+
+								{/* Global Skills Section */}
+								<div className="mb-3">
+									<div className="text-sm font-normal mb-2">Global Skills</div>
+									<div className="flex flex-col gap-0">
+										{globalSkills
+											.filter((s) => !s.path.startsWith("remote:"))
+											.sort((a, b) => a.name.localeCompare(b.name))
+											.map((skill) => (
+												<RuleRow
+													enabled={skill.enabled}
+													isGlobal={true}
+													key={skill.path}
+													rulePath={skill.path}
+													ruleType="skill"
+													toggleRule={(_path, enabled) => toggleSkill(true, skill.path, enabled)}
+												/>
+											))}
+										<NewRuleRow isGlobal={true} ruleType="skill" />
+									</div>
+								</div>
+
+								{/* Workspace Skills Section */}
+								<div className="-mb-2.5">
+									<div className="text-sm font-normal mb-2">Workspace Skills</div>
+									<div className="flex flex-col gap-0">
+										{localSkills
+											.sort((a, b) => a.name.localeCompare(b.name))
+											.map((skill) => (
+												<RuleRow
+													enabled={skill.enabled}
+													isGlobal={false}
+													key={skill.path}
+													rulePath={skill.path}
+													ruleType="skill"
+													toggleRule={(path, enabled) => toggleSkill(false, path, enabled)}
+												/>
+											))}
+										<NewRuleRow isGlobal={false} ruleType="skill" />
+									</div>
+								</div>
+							</>
+						) : null}
+					</div>
+				</PopupModalContainer>
+			)}
+		</div>
+	)
+}
+
+const StyledTabButton = styled.button<{ $isActive: boolean }>`
+	background: none;
+	border: none;
+	border-bottom: 2px solid ${(props) => (props.$isActive ? "var(--vscode-foreground)" : "transparent")};
+	color: ${(props) => (props.$isActive ? "var(--vscode-foreground)" : "var(--vscode-descriptionForeground)")};
+	padding: 8px 12px;
+	cursor: pointer;
+	font-size: 13px;
+	margin-bottom: -1px;
+	font-family: inherit;
+	white-space: nowrap;
+
+	&:hover {
+		color: var(--vscode-foreground);
+	}
+`
+
+const TabButton = ({ children, isActive, onClick }: { children: React.ReactNode; isActive: boolean; onClick: () => void }) => (
+	<StyledTabButton $isActive={isActive} aria-pressed={isActive} onClick={onClick}>
+		{children}
+	</StyledTabButton>
+)
+
+export default ClineRulesToggleModal
diff --git a/apps/vscode/webview-ui/src/components/cline-rules/HookRow.tsx b/apps/vscode/webview-ui/src/components/cline-rules/HookRow.tsx
new file mode 100644
index 0000000..e36532a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/cline-rules/HookRow.tsx
@@ -0,0 +1,92 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { DeleteHookRequest, HooksToggles } from "@shared/proto/cline/file"
+import { PenIcon, Trash2Icon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Switch } from "@/components/ui/switch"
+import { FileServiceClient } from "@/services/grpc-client"
+
+interface HookRowProps {
+	hookName: string
+	enabled: boolean
+	absolutePath: string
+	isGlobal: boolean
+	isWindows: boolean
+	workspaceName?: string
+	onToggle: (hookName: string, newEnabled: boolean) => void
+	onDelete: (hooksToggles: HooksToggles) => void
+}
+
+const HookRow: React.FC<HookRowProps> = ({
+	hookName,
+	enabled,
+	absolutePath,
+	isGlobal,
+	isWindows,
+	workspaceName,
+	onToggle,
+	onDelete,
+}) => {
+	const handleEditClick = () => {
+		FileServiceClient.openFile(StringRequest.create({ value: absolutePath })).catch((err) =>
+			console.error("Failed to open file:", err),
+		)
+	}
+
+	const handleDeleteClick = () => {
+		FileServiceClient.deleteHook(
+			DeleteHookRequest.create({
+				hookName,
+				isGlobal,
+				workspaceName,
+			}),
+		)
+			.then((response) => {
+				if (response.hooksToggles) {
+					onDelete(response.hooksToggles)
+				}
+			})
+			.catch((err) => console.error("Failed to delete hook:", err))
+	}
+
+	return (
+		<div className="mb-2.5">
+			<div className="flex items-center px-2 py-4 rounded bg-text-block-background max-h-4">
+				<span className="flex-1 overflow-hidden break-all whitespace-normal flex items-center mr-1">
+					<span className="ph-no-capture">{hookName}</span>
+				</span>
+
+				{/* Toggle Switch */}
+				<div className="flex items-center space-x-2 gap-2">
+					<div
+						title={
+							isWindows
+								? "Hook toggling is not yet supported on Windows in this foundation PR. Hooks execute when the hook file exists."
+								: undefined
+						}>
+						<Switch
+							checked={enabled}
+							className="mx-1"
+							disabled={isWindows}
+							key={hookName}
+							onClick={() => onToggle(hookName, !enabled)}
+							style={isWindows ? { opacity: 0.5, cursor: "not-allowed" } : undefined}
+						/>
+					</div>
+					<Button aria-label="Edit hook file" onClick={handleEditClick} size="xs" title="Edit hook file" variant="icon">
+						<PenIcon />
+					</Button>
+					<Button
+						aria-label="Delete hook file"
+						onClick={handleDeleteClick}
+						size="xs"
+						title="Delete hook file"
+						variant="icon">
+						<Trash2Icon />
+					</Button>
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default HookRow
diff --git a/apps/vscode/webview-ui/src/components/cline-rules/NewRuleRow.tsx b/apps/vscode/webview-ui/src/components/cline-rules/NewRuleRow.tsx
new file mode 100644
index 0000000..776f59a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/cline-rules/NewRuleRow.tsx
@@ -0,0 +1,267 @@
+import { CreateHookRequest, CreateSkillRequest, RuleFileRequest } from "@shared/proto/index.cline"
+import { PlusIcon } from "lucide-react"
+import { useEffect, useMemo, useRef, useState } from "react"
+import { useClickAway } from "react-use"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+import { FileServiceClient } from "@/services/grpc-client"
+
+interface NewRuleRowProps {
+	isGlobal: boolean
+	ruleType?: string
+	existingHooks?: string[]
+	workspaceName?: string
+}
+
+const HOOK_TYPES = [
+	{ name: "TaskStart", description: "Executes when a new task begins" },
+	{ name: "TaskResume", description: "Executes when a task is resumed" },
+	{ name: "TaskCancel", description: "Executes when a task is cancelled" },
+	{ name: "TaskComplete", description: "Executes when a task completes" },
+	{ name: "PreToolUse", description: "Executes before any tool is used" },
+	{ name: "PostToolUse", description: "Executes after any tool is used" },
+	{ name: "UserPromptSubmit", description: "Executes when user submits a prompt" },
+	{ name: "PreCompact", description: "Executes before conversation compaction" },
+]
+
+const NewRuleRow: React.FC<NewRuleRowProps> = ({ isGlobal, ruleType, existingHooks = [], workspaceName }) => {
+	const [isExpanded, setIsExpanded] = useState(false)
+	const [filename, setFilename] = useState("")
+	const inputRef = useRef<HTMLInputElement>(null)
+	const [error, setError] = useState<string | null>(null)
+
+	const componentRef = useRef<HTMLDivElement>(null)
+
+	// Calculate available hook types by filtering out existing hooks
+	const availableHookTypes = useMemo(() => HOOK_TYPES.filter((type) => !existingHooks.includes(type.name)), [existingHooks])
+
+	// Focus the input when expanded
+	useEffect(() => {
+		if (isExpanded && inputRef.current) {
+			inputRef.current.focus()
+		}
+	}, [isExpanded])
+
+	useClickAway(componentRef, () => {
+		if (isExpanded) {
+			setIsExpanded(false)
+			setFilename("")
+			setError(null)
+		}
+	})
+
+	const getExtension = (filename: string): string => {
+		if (filename.startsWith(".") && !filename.includes(".", 1)) {
+			return ""
+		}
+		const match = filename.match(/\.[^.]+$/)
+		return match ? match[0].toLowerCase() : ""
+	}
+
+	const isValidExtension = (ext: string): boolean => {
+		return ext === "" || ext === ".md" || ext === ".txt"
+	}
+
+	const handleCreateHook = async (hookName: string) => {
+		if (!hookName) return
+
+		try {
+			await FileServiceClient.createHook(
+				CreateHookRequest.create({
+					hookName,
+					isGlobal,
+					workspaceName,
+				}),
+			)
+		} catch (err) {
+			console.error("Error creating hook:", err)
+		}
+	}
+
+	const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+		e.preventDefault()
+
+		if (filename.trim()) {
+			const trimmedFilename = filename.trim()
+
+			// Skills use directory names, not file extensions
+			if (ruleType === "skill") {
+				// Validate skill name - only allow alphanumeric, dashes, underscores
+				if (!/^[a-zA-Z0-9_-]+$/.test(trimmedFilename)) {
+					setError("Skill name can only contain letters, numbers, dashes, and underscores")
+					return
+				}
+
+				try {
+					await FileServiceClient.createSkillFile(
+						CreateSkillRequest.create({
+							skillName: trimmedFilename,
+							isGlobal,
+						}),
+					)
+					setFilename("")
+					setError(null)
+					setIsExpanded(false)
+				} catch (err) {
+					setError(err instanceof Error ? err.message : "Failed to create skill")
+				}
+				return
+			}
+
+			const extension = getExtension(trimmedFilename)
+
+			if (!isValidExtension(extension)) {
+				setError("Only .md, .txt, or no file extension allowed")
+				return
+			}
+
+			let finalFilename = trimmedFilename
+			if (extension === "") {
+				finalFilename = `${trimmedFilename}.md`
+			}
+
+			try {
+				await FileServiceClient.createRuleFile(
+					RuleFileRequest.create({
+						isGlobal,
+						filename: finalFilename,
+						type: ruleType || "cline",
+					}),
+				)
+			} catch (err) {
+				console.error("Error creating rule file:", err)
+			}
+
+			setFilename("")
+			setError(null)
+			setIsExpanded(false)
+		}
+	}
+
+	const handleKeyDown = (e: React.KeyboardEvent) => {
+		if (e.key === "Escape") {
+			setIsExpanded(false)
+			setFilename("")
+		}
+	}
+
+	return (
+		<>
+			<div
+				className={cn("mb-2.5 transition-all duration-300 ease-in-out", {
+					"opacity-100": isExpanded,
+					"opacity-70 hover:opacity-100": !isExpanded,
+				})}
+				onClick={() => !isExpanded && ruleType !== "hook" && setIsExpanded(true)}
+				ref={componentRef}>
+				<div
+					className={cn(
+						"flex items-center px-2 py-4 rounded bg-input-background transition-all duration-300 ease-in-out h-5",
+						{
+							"shadow-sm": isExpanded,
+						},
+					)}>
+					{ruleType === "hook" ? (
+						<>
+							<label className="sr-only" htmlFor="hook-type-select">
+								Select hook type to create
+							</label>
+							<span className="sr-only" id="hook-select-description">
+								Choose a hook type to create. Hooks execute at specific points in Cline's lifecycle. Available:{" "}
+								{availableHookTypes.map((h) => h.name).join(", ")}
+							</span>
+							<select
+								aria-describedby="hook-select-description"
+								aria-label="Select hook type to create"
+								className="flex-1 bg-input-background text-input-foreground border-0 outline-0 rounded focus:outline-none focus:ring-0 focus:border-transparent px-2 cursor-pointer"
+								disabled={availableHookTypes.length === 0}
+								id="hook-type-select"
+								onChange={(e) => {
+									if (e.target.value) {
+										handleCreateHook(e.target.value)
+										// Reset selection after creating
+										e.target.value = ""
+									}
+								}}
+								style={{
+									fontStyle: "italic",
+									appearance: "none",
+									backgroundImage: `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23cccccc' d='M6 9L1 4h10z'/%3E%3C/svg%3E")`,
+									backgroundRepeat: "no-repeat",
+									backgroundPosition: "right 8px center",
+									paddingRight: "24px",
+								}}
+								value="">
+								<option disabled value="">
+									{availableHookTypes.length === 0 ? "All hooks created" : "New hook..."}
+								</option>
+								{availableHookTypes.map((hook) => (
+									<option key={hook.name} title={hook.description} value={hook.name}>
+										{hook.name}
+									</option>
+								))}
+							</select>
+						</>
+					) : (
+						<form className="flex flex-1 items-center" onSubmit={handleSubmit}>
+							<input
+								className={cn(
+									"flex-1 bg-input-background text-input-foreground border-0 outline-0 rounded focus:outline-none focus:ring-0 focus:border-transparent",
+									{
+										italic: !isExpanded,
+									},
+								)}
+								onChange={(e) => setFilename(e.target.value)}
+								placeholder={
+									isExpanded
+										? ruleType === "workflow"
+											? "workflow-name (.md, .txt, or no extension)"
+											: ruleType === "skill"
+												? "skill-name (letters, numbers, dashes, underscores)"
+												: "rule-name (.md, .txt, or no extension)"
+										: ruleType === "workflow"
+											? "New workflow file..."
+											: ruleType === "skill"
+												? "New skill..."
+												: "New rule file..."
+								}
+								ref={inputRef}
+								type="text"
+								value={isExpanded ? filename : ""}
+							/>
+
+							<Button
+								aria-label={
+									isExpanded
+										? ruleType === "skill"
+											? "Create skill"
+											: "Create file"
+										: ruleType === "workflow"
+											? "New workflow file..."
+											: ruleType === "skill"
+												? "New skill..."
+												: "New rule file..."
+								}
+								className="mx-0.5"
+								onClick={(e) => {
+									e.stopPropagation()
+									if (!isExpanded) {
+										setIsExpanded(true)
+									}
+								}}
+								size="icon"
+								title={isExpanded ? (ruleType === "skill" ? "Create skill" : "Create file") : "New file"}
+								type={isExpanded ? "submit" : "button"}
+								variant="icon">
+								<PlusIcon />
+							</Button>
+						</form>
+					)}
+				</div>
+				{isExpanded && error && <div className="text-error text-xs mt-1 ml-2">{error}</div>}
+			</div>
+		</>
+	)
+}
+
+export default NewRuleRow
diff --git a/apps/vscode/webview-ui/src/components/cline-rules/RuleRow.tsx b/apps/vscode/webview-ui/src/components/cline-rules/RuleRow.tsx
new file mode 100644
index 0000000..9a5f1f9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/cline-rules/RuleRow.tsx
@@ -0,0 +1,189 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { DeleteSkillRequest, RuleFileRequest } from "@shared/proto/index.cline"
+import { REMOTE_URI_SCHEME } from "@shared/remote-config/constants"
+import { EyeIcon, InfoIcon, PenIcon, Trash2Icon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Switch } from "@/components/ui/switch"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { FileServiceClient } from "@/services/grpc-client"
+
+function isWin32Path(filePath: string): boolean {
+	return /^[a-zA-Z]:\\/.test(filePath)
+}
+
+function splitPath(filePath: string): string[] {
+	const win32 = isWin32Path(filePath)
+	return filePath.split(win32 ? "\\" : "/")
+}
+
+function getDisplayNameFromPath(filePath: string): string {
+	const parts = splitPath(filePath)
+	return parts.at(-1) || filePath
+}
+
+function getSkillDisplayNameFromSkillMdPath(filePath: string): string {
+	const parts = splitPath(filePath)
+	const displayName = getDisplayNameFromPath(filePath)
+	// Path is like /path/to/skill-name/SKILL.md, we want skill-name
+	return parts.at(-2) || displayName
+}
+
+const RuleRow: React.FC<{
+	rulePath: string
+	enabled: boolean
+	isGlobal: boolean
+	ruleType: string
+	toggleRule: (rulePath: string, enabled: boolean) => void
+	isRemote?: boolean
+	alwaysEnabled?: boolean
+	onDeleteSkill?: () => void
+}> = ({ rulePath, enabled, isGlobal, toggleRule, ruleType, isRemote = false, alwaysEnabled = false, onDeleteSkill }) => {
+	const displayName = getDisplayNameFromPath(rulePath)
+	const skillDisplayName = getSkillDisplayNameFromSkillMdPath(rulePath)
+
+	// For remote rules, the rulePath is already the display name
+	const finalDisplayName = isRemote ? rulePath : ruleType === "skill" ? skillDisplayName : displayName
+	const isDisabled = isRemote && alwaysEnabled
+
+	const getRuleTypeIcon = () => {
+		switch (ruleType) {
+			case "cursor":
+				return (
+					<svg
+						height="16"
+						style={{ verticalAlign: "middle" }}
+						viewBox="0 0 24 24"
+						width="16"
+						xmlns="http://www.w3.org/2000/svg">
+						<g fill="none" stroke="currentColor" strokeWidth="1.2">
+							<path d="M12 4L5 8l7 4 7-4-7-4z" fill="rgba(255,255,255,0.2)" />
+							<path d="M5 8v8l7 4v-8L5 8z" fill="rgba(255,255,255,0.1)" />
+							<path d="M19 8v8l-7 4v-8l7-4z" fill="rgba(255,255,255,0.15)" />
+							<line x1="5" x2="12" y1="8" y2="12" />
+							<line x1="12" x2="19" y1="12" y2="8" />
+							<line x1="12" x2="12" y1="12" y2="20" />
+						</g>
+					</svg>
+				)
+			case "windsurf":
+				return (
+					<svg
+						height="16"
+						style={{ verticalAlign: "middle" }}
+						viewBox="0 0 24 24"
+						width="16"
+						xmlns="http://www.w3.org/2000/svg">
+						<g fill="currentColor" stroke="currentColor" strokeWidth="1">
+							<path d="M6 18L16 5L14 18H6z" fill="currentColor" />
+							<line strokeWidth="1.5" x1="14" x2="16" y1="18" y2="5" />
+							<path d="M4 19h12c0.5 0 1-0.3 1-1s-0.3-1-1-1H4c-0.5 0-1 0.3-1 1s0.3 1 1 1z" fill="currentColor" />
+							<line strokeWidth="1" x1="14" x2="16" y1="13" y2="9" />
+						</g>
+					</svg>
+				)
+			case "agents":
+				return (
+					<svg
+						height="16"
+						style={{ verticalAlign: "middle" }}
+						viewBox="0 0 24 24"
+						width="16"
+						xmlns="http://www.w3.org/2000/svg">
+						<g fill="none" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.5">
+							<circle cx="12" cy="8" r="3" />
+							<path d="M12 14c-4 0-6 2-6 4v2h12v-2c0-2-2-4-6-4z" />
+						</g>
+					</svg>
+				)
+			default:
+				return null
+		}
+	}
+
+	const getRemoteUriType = () => {
+		if (ruleType === "workflow") return "workflow"
+		if (ruleType === "skill") return "skill"
+		return "rule"
+	}
+
+	const handleEditClick = () => {
+		// For remote rules/workflows/skills, use the special remote:// URI format
+		const filePath = isRemote ? `${REMOTE_URI_SCHEME}${getRemoteUriType()}/${rulePath}` : rulePath
+		FileServiceClient.openFile(StringRequest.create({ value: filePath })).catch((err) =>
+			console.error("Failed to open file:", err),
+		)
+	}
+
+	const handleDeleteClick = () => {
+		if (ruleType === "skill") {
+			FileServiceClient.deleteSkillFile(
+				DeleteSkillRequest.create({
+					skillPath: rulePath,
+					isGlobal,
+				}),
+			)
+				.then(() => onDeleteSkill?.())
+				.catch((err) => console.error("Failed to delete skill:", err))
+		} else {
+			FileServiceClient.deleteRuleFile(
+				RuleFileRequest.create({
+					rulePath,
+					isGlobal,
+					type: ruleType || "cline",
+				}),
+			).catch((err) => console.error("Failed to delete rule file:", err))
+		}
+	}
+
+	return (
+		<div className="mb-2.5">
+			<div className="flex items-center px-2 py-4 rounded bg-text-block-background max-h-4">
+				<span className="flex-1 overflow-hidden break-all whitespace-normal flex items-center mr-1" title={rulePath}>
+					{getRuleTypeIcon() && <span className="mr-1.5">{getRuleTypeIcon()}</span>}
+					<span className="ph-no-capture">{finalDisplayName}</span>
+					{ruleType === "agents" && (
+						<Tooltip>
+							<TooltipTrigger asChild className="cursor-help">
+								<InfoIcon className="ml-1.5 opacity-70 size-[0.85rem]" />
+							</TooltipTrigger>
+							<TooltipContent>
+								Searches recursively for all AGENTS.md files in the workspace when a top-level AGENTS.md exists
+							</TooltipContent>
+						</Tooltip>
+					)}
+				</span>
+
+				{/* Toggle Switch */}
+				<div className="flex items-center space-x-2 gap-2">
+					<Switch
+						checked={enabled}
+						className="mx-1"
+						disabled={isDisabled}
+						key={rulePath}
+						onClick={() => toggleRule(rulePath, !enabled)}
+						title={isDisabled ? "This rule is required and cannot be disabled" : undefined}
+					/>
+					<Button
+						aria-label={isRemote ? `View ${ruleType} file` : `Edit ${ruleType} file`}
+						onClick={handleEditClick}
+						size="xs"
+						title={isRemote ? `View ${ruleType} file (read-only)` : `Edit ${ruleType} file`}
+						variant="icon">
+						{isRemote ? <EyeIcon /> : <PenIcon />}
+					</Button>
+					<Button
+						aria-label={`Delete ${ruleType} file`}
+						disabled={isRemote}
+						onClick={handleDeleteClick}
+						size="xs"
+						title={`Delete ${ruleType} file`}
+						variant="icon">
+						<Trash2Icon />
+					</Button>
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default RuleRow
diff --git a/apps/vscode/webview-ui/src/components/cline-rules/RulesToggleList.tsx b/apps/vscode/webview-ui/src/components/cline-rules/RulesToggleList.tsx
new file mode 100644
index 0000000..d4beb5e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/cline-rules/RulesToggleList.tsx
@@ -0,0 +1,65 @@
+import NewRuleRow from "./NewRuleRow"
+import RuleRow from "./RuleRow"
+
+const RulesToggleList = ({
+	rules,
+	toggleRule,
+	listGap = "medium",
+	isGlobal,
+	ruleType,
+	showNewRule,
+	showNoRules,
+	isRemote = false,
+	alwaysEnabledMap = {},
+}: {
+	rules: [string, boolean][]
+	toggleRule: (rulePath: string, enabled: boolean) => void
+	listGap?: "small" | "medium" | "large"
+	isGlobal: boolean
+	ruleType: string
+	showNewRule: boolean
+	showNoRules: boolean
+	isRemote?: boolean
+	alwaysEnabledMap?: Record<string, boolean>
+}) => {
+	const gapClasses = {
+		small: "gap-0",
+		medium: "gap-2.5",
+		large: "gap-5",
+	}
+
+	const gapClass = gapClasses[listGap]
+
+	return (
+		<div className={`flex flex-col ${gapClass}`}>
+			{rules.length > 0 ? (
+				<>
+					{rules.map(([rulePath, enabled]) => (
+						<RuleRow
+							alwaysEnabled={alwaysEnabledMap[rulePath]}
+							enabled={enabled}
+							isGlobal={isGlobal}
+							isRemote={isRemote}
+							key={rulePath}
+							rulePath={rulePath}
+							ruleType={ruleType}
+							toggleRule={toggleRule}
+						/>
+					))}
+					{showNewRule && <NewRuleRow isGlobal={isGlobal} ruleType={ruleType} />}
+				</>
+			) : (
+				<>
+					{showNoRules && (
+						<div className="flex flex-col items-center gap-3 my-3 text-(--vscode-descriptionForeground)">
+							{ruleType === "workflow" ? "No workflows found" : "No rules found"}
+						</div>
+					)}
+					{showNewRule && <NewRuleRow isGlobal={isGlobal} ruleType={ruleType} />}
+				</>
+			)}
+		</div>
+	)
+}
+
+export default RulesToggleList
diff --git a/apps/vscode/webview-ui/src/components/common/BannerCarousel.tsx b/apps/vscode/webview-ui/src/components/common/BannerCarousel.tsx
new file mode 100644
index 0000000..6ceb5ba
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/BannerCarousel.tsx
@@ -0,0 +1,220 @@
+import { ChevronLeft, ChevronRight, XIcon } from "lucide-react"
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useRemark } from "react-remark"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+
+interface BannerActions {
+	label: string
+	onClick: () => void
+	disabled?: boolean
+}
+
+export interface BannerData {
+	id: string
+	icon?: React.ReactNode
+	title: string
+	description: string | React.ReactNode
+	actions?: BannerActions[]
+	onDismiss?: () => void
+}
+
+interface BannerCarouselProps {
+	banners: BannerData[]
+}
+
+interface BannerCardContentProps {
+	banner: BannerData
+	isActive: boolean
+	isTransitioning: boolean
+	showDismissButton: boolean
+}
+
+const BannerCardContent: React.FC<BannerCardContentProps> = ({ banner, isActive, isTransitioning, showDismissButton }) => {
+	const [markdownContent, setMarkdown] = useRemark()
+
+	useEffect(() => {
+		setMarkdown(typeof banner.description === "string" ? banner.description : "")
+	}, [banner.description, setMarkdown])
+
+	return (
+		<div
+			className={cn("p-3 transition-opacity duration-400 ease-in-out opacity-0", {
+				"opacity-100": isActive && !isTransitioning,
+				"cursor-auto": isActive,
+			})}
+			style={{
+				gridArea: "stack",
+				pointerEvents: isActive ? "auto" : "none", // Disable interaction on inactive cards
+			}}>
+			{/* Title with optional icon */}
+			<h3
+				className={cn("font-semibold mb-2 flex items-center gap-2 text-base pr-0", {
+					"pr-6": showDismissButton,
+				})}>
+				<span className="shrink-0">{banner.icon}</span>
+				{banner.title}
+			</h3>
+
+			{/* Description */}
+			<div className="text-sm text-description leading-relaxed [&>*:last-child]:mb-0 [&_a]:hover:underline">
+				{markdownContent}
+			</div>
+
+			{/* Action buttons */}
+			{banner.actions?.length ? (
+				<div className="flex flex-wrap gap-2 mt-3">
+					{banner.actions.map((action) => (
+						<Button disabled={action.disabled} key={action.label} onClick={action.onClick} size="sm">
+							{action.label}
+						</Button>
+					))}
+				</div>
+			) : null}
+		</div>
+	)
+}
+
+const BannerCarousel: React.FC<BannerCarouselProps> = ({ banners }) => {
+	const [currentIndex, setCurrentIndex] = useState(0)
+	const [isPaused, setIsPaused] = useState(false)
+	const [isTransitioning, setIsTransitioning] = useState(false)
+	const autoPlayIntervalRef = useRef<NodeJS.Timeout | null>(null)
+
+	// Compute a safe index that's always within bounds
+	const safeCurrentIndex = useMemo(
+		() => (banners.length === 0 ? 0 : Math.min(currentIndex, banners.length - 1)),
+		[currentIndex, banners.length],
+	)
+
+	const transitionToIndex = useCallback((newIndex: number) => {
+		setIsTransitioning(true)
+		setTimeout(() => {
+			setCurrentIndex(newIndex)
+			setIsTransitioning(false)
+		}, 200) // Match half of transition duration
+	}, [])
+
+	const handlePrevious = useCallback(() => {
+		const newIndex = currentIndex === 0 ? banners.length - 1 : currentIndex - 1
+		transitionToIndex(newIndex)
+		setIsPaused(true) // Pause auto-rotation when user manually navigates
+	}, [currentIndex, banners.length, transitionToIndex])
+
+	const handleNext = useCallback(() => {
+		const newIndex = currentIndex === banners.length - 1 ? 0 : currentIndex + 1
+		transitionToIndex(newIndex)
+		setIsPaused(true) // Pause auto-rotation when user manually navigates
+	}, [currentIndex, banners.length, transitionToIndex])
+
+	// Reset currentIndex when banners change to prevent out-of-bounds access
+	useEffect(() => {
+		if (currentIndex >= banners.length && banners.length > 0) {
+			setCurrentIndex(banners.length - 1)
+		}
+	}, [banners.length, currentIndex])
+
+	// Auto-rotation effect
+	useEffect(() => {
+		// Only auto-rotate if there's more than one banner and not paused
+		if (banners.length <= 1 || isPaused) {
+			return
+		}
+
+		autoPlayIntervalRef.current = setInterval(() => {
+			setCurrentIndex((prevIndex) => (prevIndex + 1) % banners.length)
+		}, 6500) // Rotate every 6.5 seconds
+
+		return () => {
+			if (autoPlayIntervalRef.current) {
+				clearInterval(autoPlayIntervalRef.current)
+			}
+		}
+	}, [banners.length, isPaused])
+
+	// Early return AFTER all hooks have been called
+	if (banners.length === 0) {
+		return null
+	}
+
+	// Use the safe index to get the current banner
+	const currentBanner = banners[safeCurrentIndex]
+
+	// Safety check: if currentBanner is undefined (shouldn't happen with above logic, but just in case)
+	if (!currentBanner) {
+		return null
+	}
+
+	const showDismissButton = !!currentBanner.onDismiss
+
+	return (
+		<div
+			aria-label="Announcements"
+			aria-live="polite"
+			aria-roledescription="carousel"
+			className="mx-3 mb-3"
+			onMouseEnter={() => setIsPaused(true)}
+			onMouseLeave={() => setIsPaused(false)}
+			role="region">
+			{/* Card container */}
+			<div className="relative bg-muted rounded-sm">
+				{/* Dismiss button - shows on each card that has onDismiss defined */}
+				{showDismissButton && (
+					<Button
+						aria-label="Dismiss banner"
+						className="absolute top-2.5 right-2 z-10"
+						data-testid="banner-dismiss-button"
+						onClick={(e) => {
+							e.stopPropagation()
+							// Dismiss only the current banner
+							currentBanner.onDismiss?.()
+						}}
+						size="icon"
+						variant="icon">
+						<XIcon className="w-4 h-4" />
+					</Button>
+				)}
+
+				{/* Card content - grid stack makes container size to tallest */}
+				<div className="grid" style={{ gridTemplateAreas: "'stack'" }}>
+					{banners.map((banner, idx) => {
+						const isActive = idx === safeCurrentIndex
+						const showDismiss = !!banner.onDismiss
+
+						return (
+							<BannerCardContent
+								banner={banner}
+								isActive={isActive}
+								isTransitioning={isTransitioning}
+								key={banner.id}
+								showDismissButton={showDismiss}
+							/>
+						)
+					})}
+				</div>
+
+				{/* Navigation footer - only show if more than 1 banner */}
+				{banners.length > 1 && (
+					<div className="flex justify-between items-center px-3 py-1.5 border-t border-description/15">
+						{/* Page indicator */}
+						<div className="text-sm text-description">
+							{safeCurrentIndex + 1} / {banners.length}
+						</div>
+
+						{/* Navigation arrows */}
+						<div className="flex gap-0.5">
+							<Button aria-label="Previous banner" onClick={handlePrevious} size="icon" variant="icon">
+								<ChevronLeft className="size-4" />
+							</Button>
+							<Button aria-label="Next banner" onClick={handleNext} size="icon" variant="icon">
+								<ChevronRight className="size-4" />
+							</Button>
+						</div>
+					</div>
+				)}
+			</div>
+		</div>
+	)
+}
+
+export default BannerCarousel
diff --git a/apps/vscode/webview-ui/src/components/common/CodeAccordian.tsx b/apps/vscode/webview-ui/src/components/common/CodeAccordian.tsx
new file mode 100644
index 0000000..18b55e2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/CodeAccordian.tsx
@@ -0,0 +1,109 @@
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import { memo, useMemo } from "react"
+import CodeBlock from "@/components/common/CodeBlock"
+import { cn } from "@/lib/utils"
+import { getLanguageFromPath } from "@/utils/getLanguageFromPath"
+import { Button } from "../ui/button"
+
+interface CodeAccordianProps {
+	code?: string
+	diff?: string
+	language?: string | undefined
+	path?: string
+	isFeedback?: boolean
+	isConsoleLogs?: boolean
+	isExpanded: boolean
+	onToggleExpand: () => void
+	isLoading?: boolean
+}
+
+/*
+We need to remove leading non-alphanumeric characters from the path in order for our leading ellipses trick to work.
+^: Anchors the match to the start of the string.
+[^a-zA-Z0-9]+: Matches one or more characters that are not alphanumeric.
+The replace method removes these matched characters, effectively trimming the string up to the first alphanumeric character.
+*/
+export const cleanPathPrefix = (path: string): string => path.replace(/^[^\u4e00-\u9fa5a-zA-Z0-9]+/, "")
+
+const CodeAccordian = ({
+	code,
+	diff,
+	language,
+	path,
+	isFeedback,
+	isConsoleLogs,
+	isExpanded,
+	onToggleExpand,
+	isLoading,
+}: CodeAccordianProps) => {
+	const inferredLanguage = useMemo(
+		() => code && (language ?? (path ? getLanguageFromPath(path) : undefined)),
+		[path, language, code],
+	)
+
+	const numberOfEdits = useMemo(() => {
+		if (code) {
+			return (code.match(/[-]{3,} SEARCH/g) || []).length || undefined
+		}
+		return undefined
+	}, [code])
+
+	return (
+		<div className="bg-code overflow-hidden rounded-xs border border-editor-group-border">
+			{(path || isFeedback || isConsoleLogs) && (
+				<Button
+					aria-label={isExpanded ? "Collapse code block" : "Expand code block"}
+					className={cn("text-description flex items-center cursor-pointer select-none w-full py-[9px] px-2.5", {
+						"cursor-wait opacity-70": isLoading,
+					})}
+					onClick={isLoading ? undefined : onToggleExpand}
+					onKeyDown={(e) => {
+						if (!isLoading) {
+							e.preventDefault()
+							if (e.key === "Enter" || e.key === " ") {
+								e.stopPropagation()
+								onToggleExpand()
+							}
+						}
+					}}
+					tabIndex={0}
+					variant="text">
+					{isFeedback || isConsoleLogs ? (
+						<div className="flex items-center">
+							<span className={`mr-1.5 codicon codicon-${isFeedback ? "feedback" : "output"}`} />
+							<span className="whitespace-nowrap overflow-hidden text-ellipsis mr-2">
+								{isFeedback ? "User Edits" : "Console Logs"}
+							</span>
+						</div>
+					) : (
+						<span className="whitespace-nowrap overflow-hidden text-ellipsis mr-2 [direction: rtl] text-left">
+							{path?.startsWith(".") && <span>.</span>}
+							{path && !path.startsWith(".") && <span>/</span>}
+							{cleanPathPrefix(path ?? "") + "\u200E"}
+						</span>
+					)}
+					<div className="grow" />
+					{numberOfEdits !== undefined && (
+						<div className="flex items-center mr-2 text-description">
+							<span className="codicon codicon-diff-single mr-1" />
+							<span>{numberOfEdits}</span>
+						</div>
+					)}
+					{isExpanded ? <ChevronDownIcon className="size-4" /> : <ChevronRightIcon className="size-4" />}
+				</Button>
+			)}
+			{(!(path || isFeedback || isConsoleLogs) || isExpanded) && (
+				<div className="overflow-x-auto overflow-y-hidden max-w-full">
+					<CodeBlock
+						source={`${"```"}${diff !== undefined ? "diff" : inferredLanguage}\n${(
+							code ?? diff ?? ""
+						).trim()}\n${"```"}`}
+					/>
+				</div>
+			)}
+		</div>
+	)
+}
+
+// memo does shallow comparison of props, so if you need it to re-render when a nested object changes, you need to pass a custom comparison function
+export default memo(CodeAccordian)
diff --git a/apps/vscode/webview-ui/src/components/common/CodeBlock.tsx b/apps/vscode/webview-ui/src/components/common/CodeBlock.tsx
new file mode 100644
index 0000000..1b7e559
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/CodeBlock.tsx
@@ -0,0 +1,163 @@
+import { memo, useEffect } from "react"
+import { useRemark } from "react-remark"
+import rehypeHighlight, { Options } from "rehype-highlight"
+import styled from "styled-components"
+import { visit } from "unist-util-visit"
+import "./codeblock-parser.css"
+
+export const CODE_BLOCK_BG_COLOR = "var(--vscode-editor-background, --vscode-sideBar-background, rgb(30 30 30))"
+
+// Theme-aware background colors for expanded/collapsed states
+export const CHAT_ROW_EXPANDED_BG_COLOR = "var(--vscode-editor-background)"
+
+/*
+overflowX: auto + inner div with padding results in an issue where the top/left/bottom padding renders but the right padding inside does not count as overflow as the width of the element is not exceeded. Once the inner div is outside the boundaries of the parent it counts as overflow.
+https://stackoverflow.com/questions/60778406/why-is-padding-right-clipped-with-overflowscroll/77292459#77292459
+this fixes the issue of right padding clipped off 
+"ideal" size in a given axis when given infinite available space--allows the syntax highlighter to grow to largest possible width including its padding
+minWidth: "max-content",
+*/
+
+interface CodeBlockProps {
+	source?: string
+	forceWrap?: boolean
+}
+
+const StyledMarkdown = styled.div<{ forceWrap: boolean }>`
+	${({ forceWrap }) =>
+		forceWrap &&
+		`
+    pre, code {
+      white-space: pre-wrap;
+      word-break: break-all;
+      overflow-wrap: anywhere;
+    }
+  `}
+
+	pre {
+		background-color: ${CODE_BLOCK_BG_COLOR};
+		border-radius: 5px;
+		margin: 0;
+		min-width: ${({ forceWrap }) => (forceWrap ? "auto" : "max-content")};
+		padding: 10px 10px;
+	}
+
+	pre > code {
+		.hljs-deletion {
+			background-color: var(--vscode-diffEditor-removedTextBackground);
+			display: inline-block;
+			width: 100%;
+		}
+		.hljs-addition {
+			background-color: var(--vscode-diffEditor-insertedTextBackground);
+			display: inline-block;
+			width: 100%;
+		}
+	}
+
+	code {
+		span.line:empty {
+			display: none;
+		}
+		word-wrap: break-word;
+		border-radius: 5px;
+		background-color: ${CODE_BLOCK_BG_COLOR};
+		font-size: var(--vscode-editor-font-size, var(--vscode-font-size, 12px));
+		font-family: var(--vscode-editor-font-family);
+	}
+
+	code:not(pre > code) {
+		font-family: var(--vscode-editor-font-family);
+		color: #f78383;
+	}
+
+	background-color: ${CODE_BLOCK_BG_COLOR};
+	font-family:
+		var(--vscode-font-family),
+		system-ui,
+		-apple-system,
+		BlinkMacSystemFont,
+		"Segoe UI",
+		Roboto,
+		Oxygen,
+		Ubuntu,
+		Cantarell,
+		"Open Sans",
+		"Helvetica Neue",
+		sans-serif;
+	font-size: var(--vscode-editor-font-size, var(--vscode-font-size, 12px));
+	color: var(--vscode-editor-foreground, #fff);
+
+	p,
+	li,
+	ol,
+	ul {
+		line-height: 1.5;
+	}
+`
+
+const StyledPre = styled.pre<{ theme: any }>`
+	& .hljs {
+		color: var(--vscode-editor-foreground, #fff);
+	}
+
+	${(props) =>
+		Object.keys(props.theme)
+			.map((key, _index) => {
+				return `
+      & ${key} {
+        color: ${props.theme[key]};
+      }
+    `
+			})
+			.join("")}
+`
+
+const CodeBlock = memo(({ source, forceWrap = false }: CodeBlockProps) => {
+	const [reactContent, setMarkdownSource] = useRemark({
+		remarkPlugins: [
+			() => {
+				return (tree) => {
+					visit(tree, "code", (node: any) => {
+						if (!node.lang) {
+							node.lang = "javascript"
+						} else if (node.lang.includes(".")) {
+							// if the language is a file, get the extension
+							node.lang = node.lang.split(".").slice(-1)[0]
+						}
+					})
+				}
+			},
+		],
+		rehypePlugins: [
+			rehypeHighlight as any,
+			{
+				// languages: {},
+			} as Options,
+		],
+		rehypeReactOptions: {
+			components: {
+				pre: ({ node, ...preProps }: any) => <StyledPre {...preProps} />,
+			},
+		},
+	})
+
+	useEffect(() => {
+		setMarkdownSource(source || "")
+	}, [source, setMarkdownSource])
+
+	return (
+		<div
+			style={{
+				overflowY: forceWrap ? "visible" : "auto",
+				maxHeight: forceWrap ? "none" : "100%",
+				backgroundColor: CODE_BLOCK_BG_COLOR,
+			}}>
+			<StyledMarkdown className="ph-no-capture markdown" forceWrap={forceWrap}>
+				{reactContent}
+			</StyledMarkdown>
+		</div>
+	)
+})
+
+export default CodeBlock
diff --git a/apps/vscode/webview-ui/src/components/common/CopyButton.tsx b/apps/vscode/webview-ui/src/components/common/CopyButton.tsx
new file mode 100644
index 0000000..8121471
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/CopyButton.tsx
@@ -0,0 +1,104 @@
+import { CheckCheckIcon, CopyIcon } from "lucide-react"
+import { forwardRef, useCallback, useState } from "react"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+
+interface CopyButtonProps {
+	textToCopy?: string
+	onCopy?: () => string | undefined | null
+	className?: string
+	ariaLabel?: string
+}
+
+interface WithCopyButtonProps {
+	children: React.ReactNode
+	textToCopy?: string
+	onCopy?: () => string | undefined | null
+	position?: "top-right" | "bottom-right"
+	style?: React.CSSProperties
+	className?: string
+	copyButtonClassname?: string
+	onMouseUp?: (event: React.MouseEvent<HTMLDivElement>) => void
+	ariaLabel?: string
+}
+
+const COPIED_TIMEOUT = 1500
+
+const POSITION_CLASSES = {
+	"top-right": "top-5 right-5",
+	"bottom-right": "bottom-1 right-2",
+} as const
+
+/**
+ * Base copy button component with clipboard functionality
+ */
+export const CopyButton: React.FC<CopyButtonProps> = ({ textToCopy, onCopy, className, ariaLabel }) => {
+	const [copied, setCopied] = useState(false)
+
+	const handleCopy = useCallback(() => {
+		const text = onCopy?.() || textToCopy
+		if (!text) {
+			return
+		}
+
+		navigator.clipboard
+			.writeText(text)
+			.then(() => {
+				setCopied(true)
+				setTimeout(() => setCopied(false), COPIED_TIMEOUT)
+			})
+			.catch((err) => console.error("Copy failed", err))
+	}, [textToCopy, onCopy])
+
+	return (
+		<Button
+			aria-label={copied ? "Copied" : ariaLabel || "Copy"}
+			className={cn("scale-90", className)}
+			onClick={handleCopy}
+			size="icon"
+			variant="icon">
+			{copied ? <CheckCheckIcon className="size-2" /> : <CopyIcon className="size-2" />}
+		</Button>
+	)
+}
+
+/**
+ * Container component that wraps content with a copy button
+ */
+export const WithCopyButton = forwardRef<HTMLDivElement, WithCopyButtonProps>(
+	(
+		{
+			children,
+			textToCopy,
+			onCopy,
+			position = "top-right",
+			style,
+			className,
+			copyButtonClassname,
+			onMouseUp,
+			ariaLabel,
+			...props
+		},
+		ref,
+	) => {
+		const hasCopyFunctionality = !!(textToCopy || onCopy)
+
+		return (
+			<div className={cn("group relative w-full", className)} onMouseUp={onMouseUp} ref={ref} style={style} {...props}>
+				{hasCopyFunctionality && (
+					<div
+						className={cn(
+							"absolute opacity-0 group-hover:opacity-100 transition-opacity",
+							POSITION_CLASSES[position],
+							copyButtonClassname,
+						)}>
+						<CopyButton ariaLabel={ariaLabel} onCopy={onCopy} textToCopy={textToCopy} />
+					</div>
+				)}
+				{children}
+			</div>
+		)
+	},
+)
+
+WithCopyButton.displayName = "WithCopyButton"
diff --git a/apps/vscode/webview-ui/src/components/common/MarkdownBlock.stories.tsx b/apps/vscode/webview-ui/src/components/common/MarkdownBlock.stories.tsx
new file mode 100644
index 0000000..f63b526
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/MarkdownBlock.stories.tsx
@@ -0,0 +1,294 @@
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import MarkdownBlock from "./MarkdownBlock"
+
+const meta: Meta<typeof MarkdownBlock> = {
+	title: "Views/Components/MarkdownBlock",
+	component: MarkdownBlock,
+	parameters: {
+		layout: "centered",
+		docs: {
+			description: {
+				component: `
+The MarkdownBlock component renders markdown content with advanced features for code display, syntax highlighting, and interactive elements.
+
+**Key Features:**
+- **Syntax Highlighting**: Automatic code highlighting using rehype-highlight
+- **File Path Detection**: Detects file paths in inline code and makes them clickable
+- **Act Mode Highlighting**: Special styling for "Act Mode" mentions with keyboard shortcuts
+- **URL Auto-linking**: Converts plain URLs in text to clickable links
+- **Mermaid Diagrams**: Supports mermaid diagram rendering in code blocks
+- **Copy Buttons**: Automatic copy buttons for code blocks
+- **Filename Protection**: Prevents filenames like __init__.py from being rendered as bold
+
+**Use Cases:**
+- Rendering AI assistant responses with code snippets
+- Displaying formatted documentation
+- Interactive file navigation within markdown
+- Technical content with syntax highlighting
+
+**Props:**
+- \`markdown\`: The markdown string to render
+- \`compact\`: Removes paragraph margins for compact display
+- \`showCursor\`: Shows a blinking cursor after content (for streaming effect)
+
+**Try It Out:**
+Use the controls below to test different markdown content and see how various features work.
+				`,
+			},
+		},
+	},
+	argTypes: {
+		markdown: {
+			control: "text",
+			description: "The markdown content to render",
+			table: {
+				type: { summary: "string" },
+			},
+		},
+		compact: {
+			control: "boolean",
+			description: "Enables compact mode with reduced spacing",
+			table: {
+				type: { summary: "boolean" },
+				defaultValue: { summary: "false" },
+			},
+		},
+		showCursor: {
+			control: "boolean",
+			description: "Shows a blinking cursor after the content",
+			table: {
+				type: { summary: "boolean" },
+				defaultValue: { summary: "false" },
+			},
+		},
+	},
+	decorators: [
+		(Story) => (
+			<div className="w-full max-w-3xl p-6 bg-[var(--vscode-editor-background)] text-[var(--vscode-editor-foreground)]">
+				<Story />
+			</div>
+		),
+	],
+}
+
+export default meta
+type Story = StoryObj<typeof MarkdownBlock>
+
+export const Default: Story = {
+	args: {
+		markdown: `Here's a TypeScript example with syntax highlighting:
+
+\`\`\`typescript
+interface User {
+  id: string
+  name: string
+  email: string
+}
+
+async function fetchUser(id: string): Promise<User> {
+  const response = await fetch(\`/api/users/\${id}\`)
+  return response.json()
+}
+\`\`\`
+
+The code above demonstrates a simple API fetch function.`,
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Basic markdown rendering with text, inline code for file paths, and lists.",
+			},
+		},
+	},
+}
+
+export const WithActMode: Story = {
+	args: {
+		markdown: `I've analyzed your request. To proceed with implementation, please switch to Act Mode using the keyboard shortcut.
+
+Once you're ready, I can execute the necessary file changes and command operations.`,
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: 'Demonstrates the special "Act Mode" highlighting feature with clickable toggle and keyboard shortcut display.',
+			},
+		},
+	},
+}
+
+export const WithLinks: Story = {
+	args: {
+		markdown: `Check out these resources:
+
+- Official documentation: https://github.com/cline/cline
+- API reference: https://api.cline.bot/docs
+- Support forum: https://community.cline.bot
+
+You can also visit our website at https://cline.bot for more information.`,
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows automatic URL detection and conversion to clickable links. Plain URLs in text are converted to links automatically.",
+			},
+		},
+	},
+}
+
+export const WithMermaidDiagram: Story = {
+	args: {
+		markdown: `Here's a diagram showing the component architecture:
+
+\`\`\`mermaid
+graph TD
+    A[User Request] --> B{Extension}
+    B --> C[Controller]
+    C --> D[Task]
+    D --> E[API Provider]
+    E --> F[AI Model]
+    F --> G[Response]
+    G --> D
+    D --> H[Tool Execution]
+    H --> I[File System]
+    H --> J[Terminal]
+    H --> K[Browser]
+\`\`\`
+
+This flow shows how requests are processed through the system.`,
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Demonstrates Mermaid diagram rendering. The diagram is automatically detected and rendered as an interactive SVG.",
+			},
+		},
+	},
+}
+
+export const WithDiffSyntax: Story = {
+	args: {
+		markdown: `Here are the changes I made to config.ts:
+
+\`\`\`diff
+export const config = {
+-  apiUrl: 'http://localhost:3000',
++  apiUrl: process.env.API_URL || 'http://localhost:3000',
+   timeout: 5000,
+-  retries: 3,
++  retries: 5,
+}
+\`\`\``,
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows diff-style syntax highlighting with additions (+) and deletions (-) color-coded.",
+			},
+		},
+	},
+}
+
+export const CompactMode: Story = {
+	args: {
+		markdown: `Compact mode removes extra spacing between paragraphs.
+
+This is useful for inline messages or notifications.
+
+All formatting still works: **bold**, *italic*, and [links](https://example.com).`,
+		compact: true,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Demonstrates compact mode with reduced vertical spacing. Useful for tight layouts or inline messages.",
+			},
+		},
+	},
+}
+
+export const WithCursor: Story = {
+	args: {
+		markdown: `I'm analyzing your codebase`,
+		compact: false,
+		showCursor: true,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Shows the blinking cursor effect, typically used during streaming responses to indicate ongoing generation.",
+			},
+		},
+	},
+}
+
+export const FilenameProtection: Story = {
+	args: {
+		markdown:
+			"I need to update these Python files:\n\n\n- `__init__.py` - Package initializer\n- `__main__.py` - Entry point\n- `__version__.py` - Version info\n\nThe `__init__.py` file should not render with bold text.",
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: "Demonstrates filename protection. Filenames like __init__.py are protected from being parsed as markdown bold (**text**).",
+			},
+		},
+	},
+}
+
+export const Interactive: Story = {
+	args: {
+		markdown: `# Try Different Markdown!
+
+Edit the markdown content in the controls panel to test:
+
+## Features to Try:
+- **Bold text** and *italic text*
+- 'inline code' and file paths like \`src/App.tsx\`
+- Links: https://example.com
+- Mentions of switching to Act Mode
+
+## Code Blocks:
+\`\`\`javascript
+console.log("Hello, World!")
+\`\`\`
+
+## Lists:
+1. First item
+2. Second item
+3. Third item
+
+---
+
+Toggle the controls to test compact mode and showCursor!`,
+		compact: false,
+		showCursor: false,
+	},
+	parameters: {
+		docs: {
+			description: {
+				story: `Interactive playground for testing MarkdownBlock. Use the controls panel to:
+
+- **Edit markdown**: Type or paste any markdown content
+- **Toggle compact mode**: See how spacing changes
+- **Toggle cursor**: Add a blinking cursor effect
+- **Test features**: Try file paths, code blocks, links, Act Mode mentions, diagrams, etc.
+
+This is perfect for experimenting with different markdown patterns and seeing how they render in real-time.`,
+			},
+		},
+	},
+}
diff --git a/apps/vscode/webview-ui/src/components/common/MarkdownBlock.tsx b/apps/vscode/webview-ui/src/components/common/MarkdownBlock.tsx
new file mode 100644
index 0000000..bea2caf
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/MarkdownBlock.tsx
@@ -0,0 +1,428 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { PlanActMode, TogglePlanActModeRequest } from "@shared/proto/cline/state"
+import { SquareArrowOutUpRightIcon } from "lucide-react"
+import { marked } from "marked"
+import type { ComponentProps } from "react"
+import React, { memo, useEffect, useMemo, useRef, useState } from "react"
+import ReactMarkdown from "react-markdown"
+import rehypeHighlight, { Options } from "rehype-highlight"
+import remarkGfm from "remark-gfm"
+import type { Node } from "unist"
+import { visit } from "unist-util-visit"
+import MermaidBlock from "@/components/common/MermaidBlock"
+import { Button } from "@/components/ui/button"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import { FileServiceClient, StateServiceClient } from "@/services/grpc-client"
+import { WithCopyButton } from "./CopyButton"
+import UnsafeImage from "./UnsafeImage"
+
+function parseMarkdownIntoBlocks(markdown: string): string[] {
+	try {
+		const tokens = marked.lexer(markdown)
+		return tokens?.map((token) => token.raw)
+	} catch {
+		return [markdown]
+	}
+}
+
+const MemoizedMarkdownBlock = memo(
+	({ content }: { content: string }) => {
+		return (
+			<ReactMarkdown
+				components={{
+					pre: ({ children, ...preProps }: React.HTMLAttributes<HTMLPreElement>) => {
+						if (Array.isArray(children) && children.length === 1 && React.isValidElement(children[0])) {
+							const child = children[0] as React.ReactElement<{ className?: string }>
+							if (child.props?.className?.includes("language-mermaid")) {
+								return child
+							}
+						}
+						return <PreWithCopyButton {...preProps}>{children}</PreWithCopyButton>
+					},
+					code: (props: ComponentProps<"code"> & { [key: string]: any }) => {
+						const className = props.className || ""
+						if (className.includes("language-mermaid")) {
+							const codeText = String(props.children || "")
+							return <MermaidBlock code={codeText} />
+						}
+
+						// Use the async file check component for potential file paths
+						return <InlineCodeWithFileCheck {...props} />
+					},
+					strong: (props: ComponentProps<"strong">) => {
+						// Check if this is an "Act Mode" strong element by looking for the keyboard shortcut
+						// Handle both string children and array of children cases
+						const childrenText = React.Children.toArray(props.children)
+							.map((child) => {
+								if (typeof child === "string") {
+									return child
+								}
+								if (typeof child === "object" && "props" in child && child.props.children) {
+									return String(child.props.children)
+								}
+								return ""
+							})
+							.join("")
+
+						// Case-insensitive check for "Act Mode (⌘⇧A)" pattern
+						// This ensures we only style the exact "Act Mode" mentions with keyboard shortcut
+						// Using case-insensitive flag to catch all capitalization variations
+						if (/^act mode\s*\(⌘⇧A\)$/i.test(childrenText)) {
+							return <ActModeHighlight />
+						}
+
+						return <strong {...props} />
+					},
+					img: (props) => <UnsafeImage {...props} />,
+				}}
+				rehypePlugins={[[rehypeHighlight as any, {} as Options]]}
+				remarkPlugins={[
+					[remarkGfm, { singleTilde: false }],
+					remarkPreventBoldFilenames,
+					remarkUrlToLink,
+					remarkHighlightActMode,
+					remarkMarkPotentialFilePaths,
+					() => {
+						return (tree: any) => {
+							visit(tree, "code", (node: any) => {
+								if (!node.lang) {
+									node.lang = "javascript"
+								} else if (node.lang.includes(".")) {
+									node.lang = node.lang.split(".").slice(-1)[0]
+								}
+							})
+						}
+					},
+				]}>
+				{content}
+			</ReactMarkdown>
+		)
+	},
+	(prevProps, nextProps) => {
+		if (prevProps.content !== nextProps.content) return false
+		return true
+	},
+)
+
+MemoizedMarkdownBlock.displayName = "MemoizedMarkdownBlock"
+
+const MemoizedMarkdown = memo(({ content, id }: { content: string; id: string }) => {
+	const blocks = useMemo(() => parseMarkdownIntoBlocks(content), [content])
+	return blocks?.map((block, index) => <MemoizedMarkdownBlock content={block} key={`${id}-block_${index}`} />)
+})
+
+MemoizedMarkdown.displayName = "MemoizedMarkdown"
+
+/**
+ * A component for Act Mode text that contains a clickable toggle and keyboard shortcut hint.
+ */
+const ActModeHighlight: React.FC = () => {
+	const { mode } = useExtensionState()
+
+	return (
+		<span
+			className={cn("text-link inline-flex items-center gap-1", {
+				"hover:opacity-90 cursor-pointer": mode === "plan",
+				"cursor-not-allowed opacity-60": mode !== "plan",
+			})}
+			onClick={() => {
+				// Only toggle to Act mode if we're currently in Plan mode
+				if (mode === "plan") {
+					StateServiceClient.togglePlanActModeProto(
+						TogglePlanActModeRequest.create({
+							mode: PlanActMode.ACT,
+						}),
+					)
+				}
+			}}
+			title={mode === "plan" ? "Click to toggle to Act Mode" : "Already in Act Mode"}>
+			<div className="p-1 rounded-md bg-code flex items-center justify-end w-7 border border-input-border">
+				<div className="rounded-full bg-link w-2 h-2" />
+			</div>
+			Act Mode (⌘⇧A)
+		</span>
+	)
+}
+
+interface MarkdownBlockProps {
+	markdown?: string
+	compact?: boolean
+	showCursor?: boolean
+}
+
+/**
+ * Custom remark plugin that converts plain URLs in text into clickable links
+ *
+ * The original bug: We were converting text nodes into paragraph nodes,
+ * which broke the markdown structure because text nodes should remain as text nodes
+ * within their parent elements (like paragraphs, list items, etc.).
+ * This caused the entire content to disappear because the structure became invalid.
+ */
+const remarkUrlToLink = () => {
+	return (tree: Node) => {
+		// Visit all "text" nodes in the markdown AST (Abstract Syntax Tree)
+		visit(tree, "text", (node: any, index, parent) => {
+			const urlRegex = /https?:\/\/[^\s<>)"]+/g
+			const matches = node.value.match(urlRegex)
+			if (!matches) {
+				return
+			}
+
+			const parts = node.value.split(urlRegex)
+			const children: any[] = []
+
+			parts.forEach((part: string, i: number) => {
+				if (part) {
+					children.push({ type: "text", value: part })
+				}
+				if (matches[i]) {
+					children.push({
+						type: "link",
+						url: matches[i],
+						children: [{ type: "text", value: matches[i] }],
+					})
+				}
+			})
+
+			// Fix: Instead of converting the node to a paragraph (which broke things),
+			// we replace the original text node with our new nodes in the parent's children array.
+			// This preserves the document structure while adding our links.
+			if (parent) {
+				parent.children.splice(index, 1, ...children)
+			}
+		})
+	}
+}
+
+/**
+ * Custom remark plugin that highlights "to Act Mode" mentions and adds keyboard shortcut hint
+ */
+const remarkHighlightActMode = () => {
+	return (tree: Node) => {
+		visit(tree, "text", (node: any, index, parent) => {
+			// Case-insensitive regex to match "to Act Mode" in various capitalizations
+			// Using word boundaries to avoid matching within words
+			// Added negative lookahead to avoid matching if already followed by the shortcut
+			const actModeRegex = /\bto\s+Act\s+Mode\b(?!\s*\(⌘⇧A\))/i
+
+			if (!node.value.match(actModeRegex)) {
+				return
+			}
+
+			// Split the text by the matches
+			const parts = node.value.split(actModeRegex)
+			const matches = node.value.match(actModeRegex)
+
+			if (!matches || parts.length <= 1) {
+				return
+			}
+
+			const children: any[] = []
+
+			parts.forEach((part: string, i: number) => {
+				// Add the text before the match
+				if (part) {
+					children.push({ type: "text", value: part })
+				}
+
+				// Add the match, but only make "Act Mode" bold (not the "to" part)
+				if (matches[i]) {
+					// Extract "to" and "Act Mode" parts
+					const matchText = matches[i]
+					const toIndex = matchText.toLowerCase().indexOf("to")
+					const actModeIndex = matchText.toLowerCase().indexOf("act mode", toIndex + 2)
+
+					if (toIndex !== -1 && actModeIndex !== -1) {
+						// Add "to" as regular text
+						const toPart = matchText.substring(toIndex, actModeIndex).trim()
+						children.push({ type: "text", value: toPart + " " })
+
+						// Add "Act Mode" as bold with keyboard shortcut
+						const actModePart = matchText.substring(actModeIndex)
+						children.push({
+							type: "strong",
+							children: [{ type: "text", value: `${actModePart} (⌘⇧A)` }],
+						})
+					} else {
+						// Fallback if we can't parse it correctly
+						children.push({ type: "text", value: matchText + " " })
+						children.push({
+							type: "strong",
+							children: [{ type: "text", value: `(⌘⇧A)` }],
+						})
+					}
+				}
+			})
+
+			// Replace the original text node with our new nodes
+			if (parent) {
+				parent.children.splice(index, 1, ...children)
+			}
+		})
+	}
+}
+
+/**
+ * Custom remark plugin that prevents filenames with extensions from being parsed as bold text
+ * For example: __init__.py should not be rendered as bold "init" followed by ".py"
+ * Solves https://github.com/cline/cline/issues/1028
+ */
+const remarkPreventBoldFilenames = () => {
+	return (tree: any) => {
+		visit(tree, "strong", (node: any, index: number | undefined, parent: any) => {
+			// Only process if there's a next node (potential file extension)
+			if (!parent || typeof index === "undefined" || index === parent.children.length - 1) {
+				return
+			}
+
+			const nextNode = parent.children[index + 1]
+
+			// Check if next node is text and starts with . followed by extension
+			if (nextNode.type !== "text" || !nextNode.value.match(/^\.[a-zA-Z0-9]+/)) {
+				return
+			}
+
+			// If the strong node has multiple children, something weird is happening
+			if (node.children?.length !== 1) {
+				return
+			}
+
+			// Get the text content from inside the strong node
+			const strongContent = node.children?.[0]?.value
+			if (!strongContent || typeof strongContent !== "string") {
+				return
+			}
+
+			// Validate that the strong content is a valid filename
+			if (!strongContent.match(/^[a-zA-Z0-9_-]+$/)) {
+				return
+			}
+
+			// Combine into a single text node
+			const newNode = {
+				type: "text",
+				value: `__${strongContent}__${nextNode.value}`,
+			}
+
+			// Replace both nodes with the combined text node
+			parent.children.splice(index, 2, newNode)
+		})
+	}
+}
+
+const PreWithCopyButton = ({ children, ...preProps }: React.HTMLAttributes<HTMLPreElement>) => {
+	const preRef = useRef<HTMLPreElement>(null)
+
+	const handleCopy = () => {
+		if (preRef.current) {
+			const codeElement = preRef.current.querySelector("code")
+			const textToCopy = codeElement ? codeElement.textContent : preRef.current.textContent
+
+			if (!textToCopy) {
+				return
+			}
+			return textToCopy
+		}
+		return null
+	}
+
+	return (
+		<WithCopyButton ariaLabel="Copy code" onCopy={handleCopy} position="top-right">
+			<pre {...preProps} ref={preRef}>
+				{children}
+			</pre>
+		</WithCopyButton>
+	)
+}
+
+// Regex to detect potential file paths (used in both remark plugin and component)
+const FILE_PATH_REGEX = /^(?!\/)[\w\-./]+(?<!\/)$/
+
+/**
+ * Custom remark plugin that marks potential file paths in inline code blocks
+ * This is synchronous - actual file existence checking happens in the React component
+ */
+const remarkMarkPotentialFilePaths = () => {
+	return (tree: Node) => {
+		visit(tree, "inlineCode", (node: Node & { value: string; data?: any }) => {
+			if (FILE_PATH_REGEX.test(node.value) && !node.value.includes("\n")) {
+				// Mark as potential file path - actual checking happens in React component
+				node.data = node.data || {}
+				node.data.hProperties = node.data.hProperties || {}
+				node.data.hProperties["data-potential-file-path"] = "true"
+			}
+		})
+	}
+}
+
+/**
+ * Component that renders inline code and checks if it's a valid file path asynchronously
+ * Shows the code immediately, then adds the file link icon when confirmed
+ */
+const InlineCodeWithFileCheck: React.FC<ComponentProps<"code"> & { [key: string]: any }> = (props) => {
+	const [isFilePath, setIsFilePath] = useState<boolean | null>(null)
+	const filePath = typeof props.children === "string" ? props.children : String(props.children || "")
+	const isPotentialFilePath = props["data-potential-file-path"] === "true"
+
+	useEffect(() => {
+		if (!isPotentialFilePath) {
+			return
+		}
+
+		let cancelled = false
+
+		// Check file existence asynchronously
+		FileServiceClient.ifFileExistsRelativePath(StringRequest.create({ value: filePath }))
+			.then((exists) => {
+				if (!cancelled) {
+					setIsFilePath(exists.value)
+				}
+			})
+			.catch((err) => {
+				console.debug(`Failed to check file existence for ${filePath}:`, err)
+				if (!cancelled) {
+					setIsFilePath(false)
+				}
+			})
+
+		return () => {
+			cancelled = true
+		}
+	}, [filePath, isPotentialFilePath])
+
+	// If confirmed as a file path, render as clickable button
+	if (isFilePath) {
+		return (
+			<Button
+				className="p-0 ml-0.5 leading-none align-middle transition-opacity text-preformat gap-0.5 inline text-left"
+				onClick={() => FileServiceClient.openFileRelativePath({ value: filePath })}
+				size="icon"
+				title={`Open ${filePath} in editor`}
+				type="button"
+				variant="icon">
+				<code {...props} />
+				<SquareArrowOutUpRightIcon className="inline align-middle ml-0.5" />
+			</Button>
+		)
+	}
+
+	// Otherwise render as regular code (shows immediately, before file check completes)
+	return <code {...props} />
+}
+
+const MarkdownBlock = memo(({ markdown, compact, showCursor }: MarkdownBlockProps) => {
+	return (
+		<div className="inline-markdown-block">
+			<span
+				className={cn("inline [&>p]:mt-0", {
+					"inline-cursor-container": showCursor,
+					"[&>p]:m-0": compact,
+				})}>
+				{markdown ? <MemoizedMarkdown content={markdown} id="markdown-block" /> : markdown}
+			</span>
+		</div>
+	)
+})
+
+export default MarkdownBlock
diff --git a/apps/vscode/webview-ui/src/components/common/MermaidBlock.tsx b/apps/vscode/webview-ui/src/components/common/MermaidBlock.tsx
new file mode 100644
index 0000000..3c1e129
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/MermaidBlock.tsx
@@ -0,0 +1,292 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import mermaid from "mermaid"
+import { useEffect, useRef, useState } from "react"
+import styled from "styled-components"
+import { FileServiceClient } from "@/services/grpc-client"
+import { useDebounceEffect } from "@/utils/useDebounceEffect"
+
+const MERMAID_THEME = {
+	background: "#1e1e1e", // VS Code dark theme background
+	textColor: "#ffffff", // Main text color
+	mainBkg: "#2d2d2d", // Background for nodes
+	nodeBorder: "#888888", // Border color for nodes
+	lineColor: "#cccccc", // Lines connecting nodes
+	primaryColor: "#3c3c3c", // Primary color for highlights
+	primaryTextColor: "#ffffff", // Text in primary colored elements
+	primaryBorderColor: "#888888",
+	secondaryColor: "#2d2d2d", // Secondary color for alternate elements
+	tertiaryColor: "#454545", // Third color for special elements
+
+	// Class diagram specific
+	classText: "#ffffff",
+
+	// State diagram specific
+	labelColor: "#ffffff",
+
+	// Sequence diagram specific
+	actorLineColor: "#cccccc",
+	actorBkg: "#2d2d2d",
+	actorBorder: "#888888",
+	actorTextColor: "#ffffff",
+
+	// Flow diagram specific
+	fillType0: "#2d2d2d",
+	fillType1: "#3c3c3c",
+	fillType2: "#454545",
+}
+
+mermaid.initialize({
+	startOnLoad: false,
+	securityLevel: "loose",
+	theme: "dark",
+	themeVariables: {
+		...MERMAID_THEME,
+		fontSize: "16px",
+		fontFamily: "var(--vscode-font-family, 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif)",
+
+		// Additional styling
+		noteTextColor: "#ffffff",
+		noteBkgColor: "#454545",
+		noteBorderColor: "#888888",
+
+		// Improve contrast for special elements
+		critBorderColor: "#ff9580",
+		critBkgColor: "#803d36",
+
+		// Task diagram specific
+		taskTextColor: "#ffffff",
+		taskTextOutsideColor: "#ffffff",
+		taskTextLightColor: "#ffffff",
+
+		// Numbers/sections
+		sectionBkgColor: "#2d2d2d",
+		sectionBkgColor2: "#3c3c3c",
+
+		// Alt sections in sequence diagrams
+		altBackground: "#2d2d2d",
+
+		// Links
+		linkColor: "#6cb6ff",
+
+		// Borders and lines
+		compositeBackground: "#2d2d2d",
+		compositeBorder: "#888888",
+		titleColor: "#ffffff",
+	},
+})
+
+interface MermaidBlockProps {
+	code: string
+}
+
+export default function MermaidBlock({ code }: MermaidBlockProps) {
+	const containerRef = useRef<HTMLDivElement>(null)
+	const [isLoading, setIsLoading] = useState(false)
+
+	// 1) Whenever `code` changes, mark that we need to re-render a new chart
+	useEffect(() => {
+		setIsLoading(true)
+	}, [code])
+
+	// 2) Debounce the actual parse/render
+	useDebounceEffect(
+		() => {
+			if (containerRef.current) {
+				containerRef.current.innerHTML = ""
+			}
+			mermaid
+				.parse(code, { suppressErrors: true })
+				.then((isValid) => {
+					if (!isValid) {
+						throw new Error("Invalid or incomplete Mermaid code")
+					}
+					const id = `mermaid-${Math.random().toString(36).substring(2)}`
+					return mermaid.render(id, code)
+				})
+				.then(({ svg }) => {
+					if (containerRef.current) {
+						containerRef.current.innerHTML = svg
+					}
+				})
+				.catch((err) => {
+					console.warn("Mermaid parse/render failed:", err)
+					containerRef.current!.innerHTML = code.replace(/</g, "&lt;").replace(/>/g, "&gt;")
+				})
+				.finally(() => {
+					setIsLoading(false)
+				})
+		},
+		500, // Delay 500ms
+		[code], // Dependencies for scheduling
+	)
+
+	/**
+	 * Called when user clicks the rendered diagram.
+	 * Converts the <svg> to a PNG and sends it to the extension.
+	 */
+	const handleClick = async () => {
+		if (!containerRef.current) {
+			return
+		}
+		const svgEl = containerRef.current.querySelector("svg")
+		if (!svgEl) {
+			return
+		}
+
+		try {
+			const pngDataUrl = await svgToPng(svgEl)
+			FileServiceClient.openImage(StringRequest.create({ value: pngDataUrl })).catch((err) =>
+				console.error("Failed to open image:", err),
+			)
+		} catch (err) {
+			console.error("Error converting SVG to PNG:", err)
+		}
+	}
+
+	const handleCopyCode = async () => {
+		try {
+			await navigator.clipboard.writeText(code)
+		} catch (err) {
+			console.error("Copy failed", err)
+		}
+	}
+
+	return (
+		<MermaidBlockContainer>
+			{isLoading && <LoadingMessage>Generating mermaid diagram...</LoadingMessage>}
+			<ButtonContainer>
+				<StyledVSCodeButton aria-label="Copy Code" onClick={handleCopyCode} title="Copy Code">
+					<span className="codicon codicon-copy"></span>
+				</StyledVSCodeButton>
+			</ButtonContainer>
+			<SvgContainer $isLoading={isLoading} onClick={handleClick} ref={containerRef} />
+		</MermaidBlockContainer>
+	)
+}
+
+async function svgToPng(svgEl: SVGElement): Promise<string> {
+	console.log("svgToPng function called")
+	// Clone the SVG to avoid modifying the original
+	const svgClone = svgEl.cloneNode(true) as SVGElement
+
+	// Get the original viewBox
+	const viewBox = svgClone.getAttribute("viewBox")?.split(" ").map(Number) || []
+	const originalWidth = viewBox[2] || svgClone.clientWidth
+	const originalHeight = viewBox[3] || svgClone.clientHeight
+
+	// Calculate the scale factor to fit editor width while maintaining aspect ratio
+
+	// Unless we can find a way to get the actual editor window dimensions through the VS Code API (which might be possible but would require changes to the extension side),
+	// the fixed width seems like a reliable approach.
+	const editorWidth = 3_600
+
+	const scale = editorWidth / originalWidth
+	const scaledHeight = originalHeight * scale
+
+	// Update SVG dimensions
+	svgClone.setAttribute("width", `${editorWidth}`)
+	svgClone.setAttribute("height", `${scaledHeight}`)
+
+	const serializer = new XMLSerializer()
+	const svgString = serializer.serializeToString(svgClone)
+	const encoder = new TextEncoder()
+	const bytes = encoder.encode(svgString)
+	const base64 = btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""))
+	const svgDataUrl = `data:image/svg+xml;base64,${base64}`
+
+	return new Promise((resolve, reject) => {
+		const img = new Image()
+		img.onload = () => {
+			const canvas = document.createElement("canvas")
+			canvas.width = editorWidth
+			canvas.height = scaledHeight
+
+			const ctx = canvas.getContext("2d")
+			if (!ctx) {
+				return reject("Canvas context not available")
+			}
+
+			// Fill background with Mermaid's dark theme background color
+			ctx.fillStyle = MERMAID_THEME.background
+			ctx.fillRect(0, 0, canvas.width, canvas.height)
+
+			ctx.imageSmoothingEnabled = true
+			ctx.imageSmoothingQuality = "high"
+
+			ctx.drawImage(img, 0, 0, editorWidth, scaledHeight)
+			resolve(canvas.toDataURL("image/png", 1.0))
+		}
+		img.onerror = reject
+		img.src = svgDataUrl
+	})
+}
+
+const MermaidBlockContainer = styled.div`
+	position: relative;
+	margin: 8px 0;
+`
+
+const ButtonContainer = styled.div`
+	position: absolute;
+	top: 8px;
+	right: 8px;
+	z-index: 1;
+	opacity: 0.6;
+	transition: opacity 0.2s ease;
+
+	&:hover {
+		opacity: 1;
+	}
+`
+
+const LoadingMessage = styled.div`
+	padding: 8px 0;
+	color: var(--vscode-descriptionForeground);
+	font-style: italic;
+	font-size: 0.9em;
+`
+
+interface SvgContainerProps {
+	$isLoading: boolean
+}
+
+const SvgContainer = styled.div<SvgContainerProps>`
+	opacity: ${(props) => (props.$isLoading ? 0.3 : 1)};
+	min-height: 20px;
+	transition: opacity 0.2s ease;
+	cursor: pointer;
+	display: flex;
+	justify-content: center;
+`
+
+const StyledVSCodeButton = styled(VSCodeButton)`
+	padding: 4px;
+	height: 24px;
+	width: 24px;
+	min-width: unset;
+	background-color: var(--vscode-button-secondaryBackground);
+	color: var(--vscode-button-secondaryForeground);
+	border: 1px solid var(--vscode-button-border);
+	border-radius: 3px;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	transition: all 0.2s ease;
+
+	.codicon {
+		font-size: 14px;
+	}
+
+	&:hover {
+		background-color: var(--vscode-button-secondaryHoverBackground);
+		border-color: var(--vscode-button-border);
+		transform: translateY(-1px);
+		box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	}
+
+	&:active {
+		transform: translateY(0);
+		box-shadow: none;
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/common/PopupModalContainer.tsx b/apps/vscode/webview-ui/src/components/common/PopupModalContainer.tsx
new file mode 100644
index 0000000..d7ae3ea
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/PopupModalContainer.tsx
@@ -0,0 +1,56 @@
+import styled from "styled-components"
+import { CODE_BLOCK_BG_COLOR } from "./CodeBlock"
+
+interface PopupModalContainerProps {
+	$menuPosition: number
+	$arrowPosition: number
+	$bottomOffset?: number
+	$maxHeight?: string
+}
+
+/**
+ * Shared styled container for popup modals (ModelPicker, ServersToggle, ClineRulesToggle).
+ * Provides consistent positioning, styling, and arrow pointer.
+ */
+const PopupModalContainer = styled.div<PopupModalContainerProps>`
+	position: fixed;
+	left: 10px;
+	right: 10px;
+	bottom: ${(props) => `calc(100vh - ${props.$menuPosition}px + ${props.$bottomOffset ?? 6}px)`};
+	display: flex;
+	flex-direction: column;
+	max-height: ${(props) => props.$maxHeight ?? "calc(100vh - 100px)"};
+	background: ${CODE_BLOCK_BG_COLOR};
+	border: 1px solid var(--vscode-editorGroup-border);
+	border-bottom: none;
+	border-radius: 6px 6px 0 0;
+	z-index: 49;
+	overscroll-behavior: contain;
+
+	&::before {
+		content: "";
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		height: 1px;
+		background: var(--vscode-editorGroup-border);
+		z-index: -1;
+	}
+
+	&::after {
+		content: "";
+		position: absolute;
+		bottom: -5px;
+		right: ${(props) => props.$arrowPosition - 10}px;
+		height: 10px;
+		width: 10px;
+		transform: rotate(45deg);
+		border-right: 1px solid var(--vscode-editorGroup-border);
+		border-bottom: 1px solid var(--vscode-editorGroup-border);
+		background: ${CODE_BLOCK_BG_COLOR};
+		z-index: -1;
+	}
+`
+
+export default PopupModalContainer
diff --git a/apps/vscode/webview-ui/src/components/common/ScreenReaderAnnounce.tsx b/apps/vscode/webview-ui/src/components/common/ScreenReaderAnnounce.tsx
new file mode 100644
index 0000000..e901d3e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/ScreenReaderAnnounce.tsx
@@ -0,0 +1,35 @@
+import React from "react"
+
+interface ScreenReaderAnnounceProps {
+	/** The message to announce to screen readers */
+	message: string
+	/** The politeness level of the announcement (default: "assertive") */
+	politeness?: "polite" | "assertive"
+}
+
+/**
+ * Visually hidden component that announces messages to screen readers.
+ * Uses an aria-live region to communicate dynamic content changes.
+ */
+const ScreenReaderAnnounce: React.FC<ScreenReaderAnnounceProps> = ({ message, politeness = "assertive" }) => {
+	return (
+		<div
+			aria-atomic="true"
+			aria-live={politeness}
+			style={{
+				position: "absolute",
+				width: "1px",
+				height: "1px",
+				padding: 0,
+				margin: "-1px",
+				overflow: "hidden",
+				clip: "rect(0, 0, 0, 0)",
+				whiteSpace: "nowrap",
+				border: 0,
+			}}>
+			{message}
+		</div>
+	)
+}
+
+export default ScreenReaderAnnounce
diff --git a/apps/vscode/webview-ui/src/components/common/SuccessButton.tsx b/apps/vscode/webview-ui/src/components/common/SuccessButton.tsx
new file mode 100644
index 0000000..0962d57
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/SuccessButton.tsx
@@ -0,0 +1,25 @@
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+
+interface SuccessButtonTWProps extends React.ComponentProps<typeof VSCodeButton> {}
+
+const SuccessButtonTW: React.FC<SuccessButtonTWProps> = (props) => {
+	return (
+		<VSCodeButton
+			{...props}
+			className={`
+				bg-[#176f2c]! 
+				border-[#176f2c]! 
+				text-white!
+				hover:bg-[#197f31]! 
+				hover:border-[#197f31]!
+				active:bg-[#156528]! 
+				active:border-[#156528]!
+				${props.className || ""}
+			`
+				.replace(/\s+/g, " ")
+				.trim()}
+		/>
+	)
+}
+
+export default SuccessButtonTW
diff --git a/apps/vscode/webview-ui/src/components/common/Tab.tsx b/apps/vscode/webview-ui/src/components/common/Tab.tsx
new file mode 100644
index 0000000..f02d345
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/Tab.tsx
@@ -0,0 +1,83 @@
+import React, { forwardRef, HTMLAttributes, useCallback } from "react"
+
+type TabProps = HTMLAttributes<HTMLDivElement>
+
+export const Tab = ({ className, children, ...props }: TabProps) => (
+	<div className={`fixed inset-0 flex flex-col ${className}`} {...props}>
+		{children}
+	</div>
+)
+
+export const TabContent = ({ className, children, ...props }: TabProps) => {
+	const onWheel = useCallback((e: React.WheelEvent<HTMLDivElement>) => {
+		const target = e.target as HTMLElement
+
+		// Prevent scrolling if the target or any of its ancestors is a listbox or option
+		if (target.closest('[role="listbox"], [role="combobox"], [role="option"]')) {
+			return
+		}
+
+		e.currentTarget.scrollTop += e.deltaY
+	}, [])
+
+	return (
+		<div className={`flex-1 overflow-auto ${className}`} onWheel={onWheel} {...props}>
+			{children}
+		</div>
+	)
+}
+
+export const TabList = forwardRef<
+	HTMLDivElement,
+	HTMLAttributes<HTMLDivElement> & {
+		value: string
+		onValueChange: (value: string) => void
+	}
+>(({ children, className, value, onValueChange, ...props }, ref) => {
+	const handleTabSelect = useCallback(
+		(tabValue: string) => {
+			console.log("Tab selected:", tabValue)
+			onValueChange(tabValue)
+		},
+		[onValueChange],
+	)
+
+	return (
+		<div className={`flex ${className}`} ref={ref} role="tablist" {...props}>
+			{React.Children.map(children, (child) => {
+				if (React.isValidElement(child)) {
+					// Make sure we're passing the correct props to the TabTrigger
+					return React.cloneElement(child as React.ReactElement<any>, {
+						isSelected: child.props.value === value,
+						onSelect: () => handleTabSelect(child.props.value),
+					})
+				}
+				return child
+			})}
+		</div>
+	)
+})
+
+export const TabTrigger = forwardRef<
+	HTMLButtonElement,
+	React.ButtonHTMLAttributes<HTMLButtonElement> & {
+		value: string
+		isSelected?: boolean
+		onSelect?: () => void
+	}
+>(({ children, className, value, isSelected, onSelect, ...props }, ref) => {
+	// Ensure we're using the value prop correctly
+	return (
+		<button
+			aria-selected={isSelected}
+			className={`focus:outline-none ${className}`}
+			data-value={value}
+			onClick={onSelect}
+			ref={ref}
+			role="tab"
+			tabIndex={isSelected ? 0 : -1} // Add data-value attribute for debugging
+			{...props}>
+			{children}
+		</button>
+	)
+})
diff --git a/apps/vscode/webview-ui/src/components/common/Thumbnails.tsx b/apps/vscode/webview-ui/src/components/common/Thumbnails.tsx
new file mode 100644
index 0000000..3d65554
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/Thumbnails.tsx
@@ -0,0 +1,187 @@
+import { cn } from "@heroui/react"
+import { StringRequest } from "@shared/proto/cline/common"
+import React, { memo, useLayoutEffect, useRef, useState } from "react"
+import { useWindowSize } from "react-use"
+import { FileServiceClient } from "@/services/grpc-client"
+
+interface ThumbnailsProps {
+	images: string[]
+	files: string[]
+	style?: React.CSSProperties
+	setImages?: React.Dispatch<React.SetStateAction<string[]>>
+	setFiles?: React.Dispatch<React.SetStateAction<string[]>>
+	onHeightChange?: (height: number) => void
+	className?: string
+}
+
+const Thumbnails = ({ images, files, style, setImages, setFiles, onHeightChange, className }: ThumbnailsProps) => {
+	const [hoveredIndex, setHoveredIndex] = useState<string | null>(null)
+	const containerRef = useRef<HTMLDivElement>(null)
+	const { width } = useWindowSize()
+
+	useLayoutEffect(() => {
+		if (containerRef.current) {
+			let height = containerRef.current.clientHeight
+			// some browsers return 0 for clientHeight
+			if (!height) {
+				height = containerRef.current.getBoundingClientRect().height
+			}
+			onHeightChange?.(height)
+		}
+		setHoveredIndex(null)
+	}, [images, files, width, onHeightChange])
+
+	const handleDeleteImages = (index: number) => {
+		setImages?.((prevImages) => prevImages.filter((_, i) => i !== index))
+	}
+
+	const handleDeleteFiles = (index: number) => {
+		setFiles?.((prevFiles) => prevFiles.filter((_, i) => i !== index))
+	}
+
+	const isDeletableImages = setImages !== undefined
+	const isDeletableFiles = setFiles !== undefined
+
+	const handleImageClick = (image: string) => {
+		FileServiceClient.openImage(StringRequest.create({ value: image })).catch((err) =>
+			console.error("Failed to open image:", err),
+		)
+	}
+
+	const handleFileClick = (filePath: string) => {
+		FileServiceClient.openFile(StringRequest.create({ value: filePath })).catch((err) =>
+			console.error("Failed to open file:", err),
+		)
+	}
+
+	return (
+		<div
+			className={cn("flex flex-wrap", className)}
+			ref={containerRef}
+			style={{
+				gap: 5,
+				rowGap: 3,
+				...style,
+			}}>
+			{images.map((image, index) => (
+				<div
+					key={`image-${index}`}
+					onMouseEnter={() => setHoveredIndex(`image-${index}`)}
+					onMouseLeave={() => setHoveredIndex(null)}
+					style={{ position: "relative" }}>
+					<img
+						alt={`Thumbnail image-${index + 1}`}
+						onClick={() => handleImageClick(image)}
+						src={image}
+						style={{
+							width: 34,
+							height: 34,
+							objectFit: "cover",
+							borderRadius: 4,
+							cursor: "pointer",
+						}}
+					/>
+					{isDeletableImages && hoveredIndex === `image-${index}` && (
+						<div
+							onClick={() => handleDeleteImages(index)}
+							style={{
+								position: "absolute",
+								top: -4,
+								right: -4,
+								width: 13,
+								height: 13,
+								borderRadius: "50%",
+								backgroundColor: "var(--vscode-badge-background)",
+								display: "flex",
+								justifyContent: "center",
+								alignItems: "center",
+								cursor: "pointer",
+							}}>
+							<span
+								className="codicon codicon-close"
+								style={{
+									color: "var(--vscode-foreground)",
+									fontSize: 10,
+									fontWeight: "bold",
+								}}></span>
+						</div>
+					)}
+				</div>
+			))}
+
+			{files.map((filePath, index) => {
+				const fileName = filePath.split(/[\\/]/).pop() || filePath
+
+				return (
+					<div
+						key={`file-${index}`}
+						onMouseEnter={() => setHoveredIndex(`file-${index}`)}
+						onMouseLeave={() => setHoveredIndex(null)}
+						style={{ position: "relative" }}>
+						<div
+							onClick={() => handleFileClick(filePath)}
+							style={{
+								width: 34,
+								height: 34,
+								borderRadius: 4,
+								cursor: "pointer",
+								backgroundColor: "var(--vscode-editor-background)",
+								border: "1px solid var(--vscode-input-border)",
+								display: "flex",
+								flexDirection: "column",
+								alignItems: "center",
+								justifyContent: "center",
+							}}>
+							<span
+								className="codicon codicon-file"
+								style={{
+									fontSize: 16,
+									color: "var(--vscode-foreground)",
+								}}></span>
+							<span
+								style={{
+									fontSize: 7,
+									marginTop: 1,
+									overflow: "hidden",
+									textOverflow: "ellipsis",
+									maxWidth: "90%",
+									whiteSpace: "nowrap",
+									textAlign: "center",
+								}}
+								title={fileName}>
+								{fileName}
+							</span>
+						</div>
+						{isDeletableFiles && hoveredIndex === `file-${index}` && (
+							<div
+								onClick={() => handleDeleteFiles(index)}
+								style={{
+									position: "absolute",
+									top: -4,
+									right: -4,
+									width: 13,
+									height: 13,
+									borderRadius: "50%",
+									backgroundColor: "var(--vscode-badge-background)",
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									cursor: "pointer",
+								}}>
+								<span
+									className="codicon codicon-close"
+									style={{
+										color: "var(--vscode-foreground)",
+										fontSize: 10,
+										fontWeight: "bold",
+									}}></span>
+							</div>
+						)}
+					</div>
+				)
+			})}
+		</div>
+	)
+}
+
+export default memo(Thumbnails)
diff --git a/apps/vscode/webview-ui/src/components/common/UnsafeImage.tsx b/apps/vscode/webview-ui/src/components/common/UnsafeImage.tsx
new file mode 100644
index 0000000..390dbd4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/UnsafeImage.tsx
@@ -0,0 +1,39 @@
+import type { ComponentProps } from "react"
+import React, { useState } from "react"
+import { Button } from "@/components/ui/button"
+
+type UnsafeImageProps = ComponentProps<"img">
+
+const UnsafeImage: React.FC<UnsafeImageProps> = ({ src = "", alt = "", ...imgProps }) => {
+	const [approvedSrc, setApprovedSrc] = useState<string>()
+	const isApproved = approvedSrc === src
+
+	if (!src) {
+		return null
+	}
+
+	// If it's base-64 encoded image (starts with `data:`), we can render it regardless of consent
+	if (!isApproved && !src.startsWith("data:")) {
+		return (
+			<span className="my-2 block flex flex-col rounded-md border border-input-border bg-code p-3">
+				<span className="block m-0 text-sm font-medium">External image blocked pending consent</span>
+				<span className="block mt-2 mb-0 break-all text-xs text-muted-foreground">
+					Source: <code>{src}</code>
+					{alt && (
+						<>
+							<br />
+							Alt: <code>{alt}</code>
+						</>
+					)}
+				</span>
+				<Button className="mt-3" onClick={() => setApprovedSrc(src)} type="button" variant="outline">
+					Load image
+				</Button>
+			</span>
+		)
+	}
+
+	return <img alt={alt} src={src} {...imgProps} />
+}
+
+export default UnsafeImage
diff --git a/apps/vscode/webview-ui/src/components/common/VSCodeButtonLink.tsx b/apps/vscode/webview-ui/src/components/common/VSCodeButtonLink.tsx
new file mode 100644
index 0000000..2a8c39f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/VSCodeButtonLink.tsx
@@ -0,0 +1,23 @@
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import React from "react"
+
+interface VSCodeButtonLinkProps {
+	href: string
+	children: React.ReactNode
+	[key: string]: any
+}
+
+const VSCodeButtonLink: React.FC<VSCodeButtonLinkProps> = ({ href, children, ...props }) => {
+	return (
+		<a
+			href={href}
+			style={{
+				textDecoration: "none",
+				color: "inherit",
+			}}>
+			<VSCodeButton {...props}>{children}</VSCodeButton>
+		</a>
+	)
+}
+
+export default VSCodeButtonLink
diff --git a/apps/vscode/webview-ui/src/components/common/ViewHeader.tsx b/apps/vscode/webview-ui/src/components/common/ViewHeader.tsx
new file mode 100644
index 0000000..8f40f96
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/ViewHeader.tsx
@@ -0,0 +1,43 @@
+import { Button } from "@/components/ui/button"
+import { getEnvironmentColor } from "@/utils/environmentColors"
+import type { Environment } from "../../../../src/shared/config-types"
+
+const ENV_DISPLAY_NAMES: Record<Environment, string> = {
+	production: "Production",
+	staging: "Staging",
+	local: "Local",
+	selfHosted: "Self-hosted",
+}
+
+type ViewHeaderProps = {
+	title: string
+	onDone: () => void
+	showEnvironmentSuffix?: boolean
+	environment?: Environment
+}
+
+const ViewHeader = ({ title, onDone, showEnvironmentSuffix, environment }: ViewHeaderProps) => {
+	const showSubtext = showEnvironmentSuffix && environment && environment !== "production"
+	const capitalizedEnv = environment ? ENV_DISPLAY_NAMES[environment] : ""
+	const titleColor = getEnvironmentColor(environment)
+
+	return (
+		<div className="flex justify-between items-center py-2.5 px-5 mb-[17px]">
+			<div className="relative">
+				<h3 className="m-0 text-lg font-normal" style={{ color: titleColor }}>
+					{title}
+				</h3>
+				{showSubtext && (
+					<span className="absolute left-0 top-8 -translate-y-1 text-xs text-description whitespace-nowrap">
+						{capitalizedEnv} environment
+					</span>
+				)}
+			</div>
+			<Button size="header" onClick={onDone}>
+				Done
+			</Button>
+		</div>
+	)
+}
+
+export default ViewHeader
diff --git a/apps/vscode/webview-ui/src/components/common/WhatsNewItems.tsx b/apps/vscode/webview-ui/src/components/common/WhatsNewItems.tsx
new file mode 100644
index 0000000..8daada7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/WhatsNewItems.tsx
@@ -0,0 +1,65 @@
+import type { BannerAction, BannerCardData } from "@shared/cline/banner"
+import React from "react"
+import Markdown from "react-markdown"
+
+interface WhatsNewItemsProps {
+	welcomeBanners?: BannerCardData[]
+	onBannerAction?: (action: BannerAction) => void
+	onClose: () => void
+	inlineCodeStyle: React.CSSProperties
+}
+
+const WhatsNewItems: React.FC<WhatsNewItemsProps> = ({ welcomeBanners, onBannerAction, onClose, inlineCodeStyle }) => {
+	const hasWelcomeBanners = welcomeBanners && welcomeBanners.length > 0
+
+	return (
+		<ul className="text-sm pl-3 list-disc" style={{ color: "var(--vscode-descriptionForeground)" }}>
+			{hasWelcomeBanners &&
+				welcomeBanners.map((banner) => (
+					<li className="mb-2" key={banner.id}>
+						{banner.title && <strong>{banner.title}</strong>}{" "}
+						{banner.description && (
+							<Markdown
+								components={{
+									a: ({ href, children }) => (
+										<a
+											href={href}
+											rel="noopener noreferrer"
+											style={{ color: "var(--vscode-textLink-foreground)" }}
+											target="_blank">
+											{children}
+										</a>
+									),
+									code: ({ children }) => <code style={inlineCodeStyle}>{children}</code>,
+									p: ({ children }) => <p style={{ display: "inline", margin: 0 }}>{children}</p>,
+								}}>
+								{banner.description}
+							</Markdown>
+						)}
+						{banner.actions && banner.actions.length > 0 && onBannerAction && (
+							<span className="inline-flex gap-2 ml-2 align-middle">
+								{banner.actions.map((action, idx) => (
+									<a
+										href="#"
+										key={idx}
+										onClick={(event) => {
+											event.preventDefault()
+											onBannerAction(action)
+											onClose()
+										}}
+										style={{
+											color: "var(--vscode-textLink-foreground)",
+											cursor: "pointer",
+										}}>
+										{action.title}
+									</a>
+								))}
+							</span>
+						)}
+					</li>
+				))}
+		</ul>
+	)
+}
+
+export default WhatsNewItems
diff --git a/apps/vscode/webview-ui/src/components/common/WhatsNewModal.tsx b/apps/vscode/webview-ui/src/components/common/WhatsNewModal.tsx
new file mode 100644
index 0000000..bf0f8bb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/WhatsNewModal.tsx
@@ -0,0 +1,130 @@
+import { BannerAction, BannerCardData } from "@shared/cline/banner"
+import React from "react"
+import { useMount } from "react-use"
+import DiscordIcon from "@/assets/DiscordIcon"
+import GitHubIcon from "@/assets/GitHubIcon"
+import LinkedInIcon from "@/assets/LinkedInIcon"
+import RedditIcon from "@/assets/RedditIcon"
+import XIcon from "@/assets/XIcon"
+import WhatsNewItems from "@/components/common/WhatsNewItems"
+import { Dialog, DialogContent } from "@/components/ui/dialog"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+
+interface WhatsNewModalProps {
+	open: boolean
+	onClose: () => void
+	version: string
+	welcomeBanners?: BannerCardData[]
+	onBannerAction?: (action: BannerAction) => void
+}
+
+const WhatsNewModal: React.FC<WhatsNewModalProps> = ({ open, onClose, version, welcomeBanners, onBannerAction }) => {
+	const { refreshOpenRouterModels } = useExtensionState()
+
+	// Get latest model list in case user hits shortcut button to set model
+	useMount(refreshOpenRouterModels)
+
+	const inlineCodeStyle: React.CSSProperties = {
+		backgroundColor: "var(--vscode-textCodeBlock-background)",
+		padding: "2px 6px",
+		borderRadius: "3px",
+		fontFamily: "var(--vscode-editor-font-family)",
+		fontSize: "0.9em",
+	}
+
+	return (
+		<Dialog onOpenChange={(isOpen) => !isOpen && onClose()} open={open}>
+			<DialogContent
+				aria-describedby="whats-new-description"
+				aria-labelledby="whats-new-title"
+				className="pt-5 px-5 pb-4 gap-0">
+				<div id="whats-new-description">
+					<h2
+						className="text-lg font-semibold mb-3 pr-6"
+						id="whats-new-title"
+						style={{ color: "var(--vscode-editor-foreground)" }}>
+						🎉 New in v{version}
+					</h2>
+
+					<WhatsNewItems
+						inlineCodeStyle={inlineCodeStyle}
+						onBannerAction={onBannerAction}
+						onClose={onClose}
+						welcomeBanners={welcomeBanners}
+					/>
+
+					{/* Social Icons Section */}
+					<div className="flex flex-col items-center gap-3 mt-4 pt-4 border-t border-[var(--vscode-widget-border)]">
+						{/* Icon Row */}
+						<div className="flex items-center gap-4">
+							{/* X/Twitter */}
+							<a
+								aria-label="Follow us on X"
+								className="text-[var(--vscode-foreground)] hover:text-[var(--vscode-textLink-activeForeground)] transition-colors"
+								href="https://x.com/cline"
+								rel="noopener noreferrer"
+								target="_blank">
+								<XIcon />
+							</a>
+
+							{/* Discord */}
+							<a
+								aria-label="Join our Discord"
+								className="text-[var(--vscode-foreground)] hover:text-[var(--vscode-textLink-activeForeground)] transition-colors"
+								href="https://discord.gg/cline"
+								rel="noopener noreferrer"
+								target="_blank">
+								<DiscordIcon />
+							</a>
+
+							{/* GitHub */}
+							<a
+								aria-label="Star us on GitHub"
+								className="text-[var(--vscode-foreground)] hover:text-[var(--vscode-textLink-activeForeground)] transition-colors"
+								href="https://github.com/cline/cline"
+								rel="noopener noreferrer"
+								target="_blank">
+								<GitHubIcon />
+							</a>
+
+							{/* Reddit */}
+							<a
+								aria-label="Join our subreddit"
+								className="text-[var(--vscode-foreground)] hover:text-[var(--vscode-textLink-activeForeground)] transition-colors"
+								href="https://www.reddit.com/r/cline/"
+								rel="noopener noreferrer"
+								target="_blank">
+								<RedditIcon />
+							</a>
+
+							{/* LinkedIn */}
+							<a
+								aria-label="Follow us on LinkedIn"
+								className="text-[var(--vscode-foreground)] hover:text-[var(--vscode-textLink-activeForeground)] transition-colors"
+								href="https://www.linkedin.com/company/clinebot/"
+								rel="noopener noreferrer"
+								target="_blank">
+								<LinkedInIcon />
+							</a>
+						</div>
+
+						{/* GitHub Star CTA */}
+						<p className="text-sm text-center" style={{ color: "var(--vscode-descriptionForeground)" }}>
+							Please support Cline by{" "}
+							<a
+								href="https://github.com/cline/cline"
+								rel="noopener noreferrer"
+								style={{ color: "var(--vscode-textLink-foreground)" }}
+								target="_blank">
+								starring us on GitHub
+							</a>
+							.
+						</p>
+					</div>
+				</div>
+			</DialogContent>
+		</Dialog>
+	)
+}
+
+export default WhatsNewModal
diff --git a/apps/vscode/webview-ui/src/components/common/codeblock-parser.css b/apps/vscode/webview-ui/src/components/common/codeblock-parser.css
new file mode 100644
index 0000000..0daa58d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/common/codeblock-parser.css
@@ -0,0 +1,185 @@
+/* Code block syntax highlighting using subtle VS Code theme variables */
+/* Minimal color variation for a cleaner look */
+
+/* Variables and identifiers - use default foreground */
+.hljs-variable,
+.hljs-params,
+.hljs-attr,
+.hljs-attribute {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Functions - slightly emphasized */
+.hljs-title.function_,
+.hljs-built_in {
+	color: var(--vscode-editor-foreground);
+	font-weight: 600;
+}
+
+/* Keywords and control flow - subtle blue */
+.hljs-keyword,
+.hljs-meta .hljs-keyword,
+.hljs-selector-tag {
+	color: var(--vscode-textLink-foreground);
+}
+
+/* Language built-ins like 'this', 'super', 'self' - same as keywords but bold */
+.hljs-variable.language_ {
+	color: var(--vscode-textLink-foreground);
+	font-weight: 600;
+}
+
+/* Strings - use debug token string color */
+.hljs-string,
+.hljs-meta .hljs-string,
+.hljs-regexp,
+.hljs-template-string {
+	color: var(--vscode-debugTokenExpression-string);
+}
+
+/* Numbers - use debug token number color */
+.hljs-number,
+.hljs-literal {
+	color: var(--vscode-debugTokenExpression-number);
+}
+
+/* Booleans - same as numbers */
+.hljs-literal.hljs-boolean {
+	color: var(--vscode-debugTokenExpression-number);
+}
+
+/* Comments - dimmed foreground */
+.hljs-comment,
+.hljs-quote {
+	color: var(--vscode-editor-foreground);
+	opacity: 0.6;
+	font-style: italic;
+}
+
+/* Classes, types, and constructors - slightly emphasized */
+.hljs-class,
+.hljs-title.class_,
+.hljs-title.class_.inherited__,
+.hljs-type,
+.hljs-typedef {
+	color: var(--vscode-editor-foreground);
+	font-weight: 600;
+}
+
+/* Properties and fields - default foreground */
+.hljs-property,
+.hljs-selector-class,
+.hljs-selector-id {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Tags (for markup languages) - same as keywords */
+.hljs-tag,
+.hljs-name {
+	color: var(--vscode-textLink-foreground);
+}
+
+/* Doctags and annotations - more colorful for better visibility */
+.hljs-doctag {
+	color: var(--vscode-textLink-foreground);
+	font-weight: 600;
+}
+
+.hljs-meta {
+	color: var(--vscode-debugTokenExpression-name);
+	font-weight: 600;
+}
+
+/* Meta keywords like @param, @returns, etc. */
+.hljs-meta .hljs-keyword,
+.hljs-meta .hljs-doctag {
+	color: var(--vscode-debugTokenExpression-type);
+	font-weight: bold;
+}
+
+/* Meta strings in annotations */
+.hljs-meta .hljs-string {
+	color: var(--vscode-debugTokenExpression-string);
+	font-style: italic;
+}
+
+/* Constants and symbols - default foreground */
+.hljs-constant,
+.hljs-symbol,
+.hljs-bullet,
+.hljs-link {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Operators - default foreground */
+.hljs-operator {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Template tags and variables - default foreground */
+.hljs-template-tag,
+.hljs-template-variable {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Enums - default foreground */
+.hljs-enum {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Modules/Namespaces - default foreground */
+.hljs-module,
+.hljs-namespace {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Methods - slightly emphasized */
+.hljs-section {
+	color: var(--vscode-editor-foreground);
+	font-weight: 600;
+}
+
+/* Substrings and template literals - default foreground */
+.hljs-subst {
+	color: var(--vscode-editor-foreground);
+}
+
+/* Emphasis */
+.hljs-emphasis {
+	font-style: italic;
+}
+
+/* Strong */
+.hljs-strong {
+	font-weight: bold;
+}
+
+/* Deletion (for diffs) */
+.hljs-deletion {
+	background-color: var(--vscode-diffEditor-removedTextBackground);
+	color: var(--vscode-diffEditor-removedLineBackground);
+}
+
+/* Addition (for diffs) */
+.hljs-addition {
+	background-color: var(--vscode-diffEditor-insertedTextBackground);
+	color: var(--vscode-diffEditor-insertedLineBackground);
+}
+
+/* Section headers - slightly emphasized */
+.hljs-title {
+	color: var(--vscode-editor-foreground);
+	font-weight: 600;
+}
+
+/* Meta information keywords - slightly dimmed */
+.hljs-meta-keyword {
+	color: var(--vscode-editor-foreground);
+	opacity: 0.8;
+}
+
+/* Default text color */
+.hljs {
+	color: var(--vscode-editor-foreground);
+	background: transparent;
+}
diff --git a/apps/vscode/webview-ui/src/components/history/HistoryPreview.tsx b/apps/vscode/webview-ui/src/components/history/HistoryPreview.tsx
new file mode 100644
index 0000000..c2a2a9a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/history/HistoryPreview.tsx
@@ -0,0 +1,189 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { memo } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { TaskServiceClient } from "@/services/grpc-client"
+
+type HistoryPreviewProps = {
+	showHistoryView: () => void
+}
+
+const HistoryPreview = ({ showHistoryView }: HistoryPreviewProps) => {
+	const { taskHistory } = useExtensionState()
+	const handleHistorySelect = (id: string) => {
+		TaskServiceClient.showTaskWithId(StringRequest.create({ value: id })).catch((error) =>
+			console.error("Error showing task:", error),
+		)
+	}
+
+	const formatDate = (timestamp: number) => {
+		const date = new Date(timestamp)
+		return date?.toLocaleString("en-US", {
+			month: "short",
+			day: "numeric",
+		})
+	}
+
+	return (
+		<div style={{ flexShrink: 0 }}>
+			<style>
+				{`
+					.history-preview-item {
+						background-color: color-mix(in srgb, var(--vscode-toolbar-hoverBackground) 65%, transparent);
+						border-radius: 4px;
+						position: relative;
+						overflow: hidden;
+						cursor: pointer;
+						margin-bottom: 8px;
+						padding: 10px 12px;
+						display: flex;
+						align-items: flex-start;
+						gap: 12px;
+					}
+					.history-preview-item:hover {
+						background-color: color-mix(in srgb, var(--vscode-toolbar-hoverBackground) 100%, transparent);
+						pointer-events: auto;
+					}
+					.history-task-content {
+						flex: 1;
+						display: flex;
+						align-items: flex-start;
+						gap: 8px;
+						min-width: 0;
+					}
+					.history-task-description {
+						flex: 1;
+						overflow: hidden;
+						display: -webkit-box;
+						-webkit-line-clamp: 2;
+						-webkit-box-orient: vertical;
+						color: var(--vscode-foreground);
+						font-size: var(--vscode-font-size);
+						line-height: 1.4;
+					}
+					.history-meta-stack {
+						display: flex;
+						flex-direction: column;
+						align-items: center;
+						gap: 4px;
+						flex-shrink: 0;
+					}
+					.history-date {
+						color: var(--vscode-descriptionForeground);
+						font-size: 0.85em;
+						white-space: nowrap;
+					}
+					.history-cost-chip {
+						background-color: var(--vscode-badge-background);
+						color: var(--vscode-badge-foreground);
+						padding: 2px 8px;
+						border-radius: 12px;
+						font-size: 0.85em;
+						font-weight: 500;
+						white-space: nowrap;
+					}
+					.history-view-all-btn {
+						background: none;
+						border: none;
+						padding: 4px 0 4px 8px;
+						cursor: pointer;
+						font-size: 0.85em;
+						font-weight: 500;
+						color: var(--vscode-descriptionForeground);
+						white-space: nowrap;
+						display: flex;
+						align-items: center;
+						gap: 2px;
+					}
+					.history-view-all-btn .codicon {
+						font-size: 1.2em;
+					}
+					.history-view-all-btn:hover {
+						color: var(--vscode-foreground);
+					}
+				`}
+			</style>
+
+			<div
+				className="history-header"
+				style={{
+					color: "var(--vscode-descriptionForeground)",
+					margin: "10px 16px 10px 16px",
+					display: "flex",
+					alignItems: "center",
+					justifyContent: "space-between",
+				}}>
+				<div style={{ display: "flex", alignItems: "center" }}>
+					<span
+						className="codicon codicon-comment-discussion"
+						style={{
+							marginRight: "4px",
+							transform: "scale(0.9)",
+						}}></span>
+					<span
+						style={{
+							fontWeight: 500,
+							fontSize: "0.85em",
+							textTransform: "uppercase",
+						}}>
+						Recent
+					</span>
+				</div>
+				{taskHistory.filter((item) => item.ts && item.task).length > 0 && (
+					<button
+						aria-label="View all history"
+						className="history-view-all-btn"
+						onClick={() => showHistoryView()}
+						type="button">
+						View All
+						<span className="codicon codicon-chevron-right" />
+					</button>
+				)}
+			</div>
+
+			{
+				<div className="px-4">
+					{taskHistory.filter((item) => item.ts && item.task).length > 0 ? (
+						taskHistory
+							.filter((item) => item.ts && item.task)
+							.slice(0, 3)
+							.map((item) => (
+								<div className="history-preview-item" key={item.id} onClick={() => handleHistorySelect(item.id)}>
+									<div className="history-task-content">
+										{item.isFavorited && (
+											<span
+												aria-label="Favorited"
+												className="codicon codicon-star-full"
+												style={{
+													color: "var(--vscode-button-background)",
+													flexShrink: 0,
+												}}
+											/>
+										)}
+										<div className="history-task-description ph-no-capture">{item.task}</div>
+									</div>
+									<div className="history-meta-stack">
+										<span className="history-date">{formatDate(item.ts)}</span>
+										{item.totalCost != null && (
+											<span className="history-cost-chip">${item.totalCost.toFixed(2)}</span>
+										)}
+									</div>
+								</div>
+							))
+					) : (
+						<div
+							style={{
+								textAlign: "center",
+								color: "var(--vscode-descriptionForeground)",
+								fontSize: "var(--vscode-font-size)",
+								padding: "10px 0",
+							}}>
+							No recent tasks
+						</div>
+					)}
+				</div>
+			}
+		</div>
+	)
+}
+
+export default memo(HistoryPreview)
diff --git a/apps/vscode/webview-ui/src/components/history/HistoryView.tsx b/apps/vscode/webview-ui/src/components/history/HistoryView.tsx
new file mode 100644
index 0000000..c0c3dba
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/history/HistoryView.tsx
@@ -0,0 +1,636 @@
+import { EmptyRequest, StringArrayRequest } from "@shared/proto/cline/common"
+import { GetTaskHistoryRequest, TaskFavoriteRequest, type TaskItem } from "@shared/proto/cline/task"
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse, { FuseResult } from "fuse.js"
+import { FunnelIcon } from "lucide-react"
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { GroupedVirtuoso } from "react-virtuoso"
+import { Button } from "@/components/ui/button"
+import { Select, SelectContent, SelectItem, SelectTrigger } from "@/components/ui/select"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { TaskServiceClient } from "@/services/grpc-client"
+import { formatSize } from "@/utils/format"
+import ViewHeader from "../common/ViewHeader"
+import HistoryViewItem from "./HistoryViewItem"
+
+type HistoryViewProps = {
+	onDone: () => void
+}
+
+type SortOption = "newest" | "oldest" | "mostExpensive" | "mostTokens" | "mostRelevant"
+
+const isToday = (timestamp: number): boolean => {
+	const date = new Date(timestamp)
+	const today = new Date()
+	return today.toDateString() === date.toDateString()
+}
+
+const HISTORY_FILTERS = {
+	newest: "Newest",
+	oldest: "Oldest",
+	mostExpensive: "Most Expensive",
+	mostTokens: "Most Tokens",
+	mostRelevant: "Most Relevant",
+	workspaceOnly: "Workspace Only",
+	favoritesOnly: "Favorites Only",
+}
+
+const HISTORY_PAGE_SIZE = 50
+
+const HistoryView = ({ onDone }: HistoryViewProps) => {
+	const extensionStateContext = useExtensionState()
+	const { taskHistory, onRelinquishControl, environment } = extensionStateContext
+	const [searchQuery, setSearchQuery] = useState("")
+	const [sortOption, setSortOption] = useState<SortOption>("newest")
+	const [lastNonRelevantSort, setLastNonRelevantSort] = useState<SortOption | null>("newest")
+	const [deleteAllDisabled, setDeleteAllDisabled] = useState(false)
+	const [selectedItems, setSelectedItems] = useState<string[]>([])
+	const [showFavoritesOnly, setShowFavoritesOnly] = useState(false)
+	const [showCurrentWorkspaceOnly, setShowCurrentWorkspaceOnly] = useState(false)
+
+	// Keep track of pending favorite toggle operations
+	const [pendingFavoriteToggles, setPendingFavoriteToggles] = useState<Record<string, boolean>>({})
+
+	// Load filtered task history with gRPC
+	const [tasks, setTasks] = useState<TaskItem[]>([])
+	const [hasMoreTasks, setHasMoreTasks] = useState(false)
+	const [nextHistoryOffset, setNextHistoryOffset] = useState(0)
+	const [isLoadingHistory, setIsLoadingHistory] = useState(false)
+	const isLoadingHistoryRef = useRef(false)
+	const historyRequestIdRef = useRef(0)
+	const hasRequestedTotalTasksSizeRef = useRef(false)
+
+	// Load and refresh task history
+	const loadTaskHistory = useCallback(
+		async (offset = 0) => {
+			if (offset > 0 && isLoadingHistoryRef.current) {
+				return
+			}
+
+			const requestId = ++historyRequestIdRef.current
+			isLoadingHistoryRef.current = true
+			setIsLoadingHistory(true)
+			try {
+				const startedAt = performance.now()
+				const response = await TaskServiceClient.getTaskHistory(
+					GetTaskHistoryRequest.create({
+						favoritesOnly: showFavoritesOnly,
+						searchQuery: searchQuery || undefined,
+						sortBy: sortOption,
+						currentWorkspaceOnly: showCurrentWorkspaceOnly,
+						limit: HISTORY_PAGE_SIZE,
+						offset,
+					}),
+				)
+				console.log(
+					`[HistoryPerf] getTaskHistory offset=${offset} tasks=${response.tasks?.length ?? 0} hasMore=${response.hasMore} took ${Math.round(performance.now() - startedAt)}ms`,
+				)
+				if (requestId !== historyRequestIdRef.current) {
+					return
+				}
+				const pageTasks = response.tasks || []
+				setTasks((currentTasks) => {
+					if (offset === 0) {
+						return pageTasks
+					}
+
+					const mergedTasks = new Map(currentTasks.map((task) => [task.id, task]))
+					for (const task of pageTasks) {
+						mergedTasks.set(task.id, task)
+					}
+					return Array.from(mergedTasks.values())
+				})
+				setHasMoreTasks(response.hasMore)
+				setNextHistoryOffset(offset + HISTORY_PAGE_SIZE)
+			} catch (error) {
+				console.error("Error loading task history:", error)
+			} finally {
+				if (requestId === historyRequestIdRef.current) {
+					isLoadingHistoryRef.current = false
+					setIsLoadingHistory(false)
+				}
+			}
+		},
+		[showFavoritesOnly, showCurrentWorkspaceOnly, searchQuery, sortOption],
+	)
+
+	const loadMoreTaskHistory = useCallback(() => {
+		if (!hasMoreTasks || isLoadingHistory) {
+			return
+		}
+		loadTaskHistory(nextHistoryOffset)
+	}, [hasMoreTasks, isLoadingHistory, loadTaskHistory, nextHistoryOffset])
+
+	// Load when filters change
+	useEffect(() => {
+		setTasks([])
+		setHasMoreTasks(false)
+		setNextHistoryOffset(0)
+		loadTaskHistory(0)
+	}, [loadTaskHistory, showFavoritesOnly, showCurrentWorkspaceOnly])
+
+	const toggleFavorite = useCallback(
+		async (taskId: string, currentValue: boolean) => {
+			const nextValue = !currentValue
+
+			// Optimistic UI update
+			setPendingFavoriteToggles((prev) => ({ ...prev, [taskId]: nextValue }))
+
+			try {
+				await TaskServiceClient.toggleTaskFavorite(
+					TaskFavoriteRequest.create({
+						taskId,
+						isFavorited: nextValue,
+					}),
+				)
+
+				setTasks((currentTasks) =>
+					currentTasks.map((task) => (task.id === taskId ? { ...task, isFavorited: nextValue } : task)),
+				)
+
+				// Refresh if either filter is active to ensure proper combined filtering
+				if (showFavoritesOnly || showCurrentWorkspaceOnly) {
+					await loadTaskHistory(0)
+				}
+			} catch (err) {
+				console.error(`[FAVORITE_TOGGLE_UI] Error for task ${taskId}:`, err)
+				// Revert optimistic update
+				setPendingFavoriteToggles((prev) => {
+					const updated = { ...prev }
+					delete updated[taskId]
+					return updated
+				})
+			} finally {
+				// Clean up pending state after 1 second
+				setTimeout(() => {
+					setPendingFavoriteToggles((prev) => {
+						const updated = { ...prev }
+						delete updated[taskId]
+						return updated
+					})
+				}, 1000)
+			}
+		},
+		[showFavoritesOnly, showCurrentWorkspaceOnly, loadTaskHistory],
+	)
+
+	// Use the onRelinquishControl hook instead of message event
+	useEffect(() => {
+		return onRelinquishControl(() => {
+			setDeleteAllDisabled(false)
+		})
+	}, [onRelinquishControl])
+
+	const { totalTasksSize, setTotalTasksSize } = extensionStateContext
+
+	const fetchTotalTasksSize = useCallback(async () => {
+		try {
+			const startedAt = performance.now()
+			const response = await TaskServiceClient.getTotalTasksSize(EmptyRequest.create({}))
+			console.log(`[HistoryPerf] getTotalTasksSize took ${Math.round(performance.now() - startedAt)}ms`)
+			if (response && typeof response.value === "number") {
+				setTotalTasksSize?.(response.value || 0)
+			}
+		} catch (error) {
+			console.error("Error getting total tasks size:", error)
+		}
+	}, [setTotalTasksSize])
+
+	// Defer the expensive recursive task/checkpoint size scan until after the first
+	// history page loads, so it does not compete with the initial history request.
+	useEffect(() => {
+		if (hasRequestedTotalTasksSizeRef.current || isLoadingHistory || nextHistoryOffset === 0 || totalTasksSize !== null) {
+			return
+		}
+
+		hasRequestedTotalTasksSizeRef.current = true
+		const timeout = window.setTimeout(() => {
+			void fetchTotalTasksSize()
+		}, 750)
+		return () => window.clearTimeout(timeout)
+	}, [fetchTotalTasksSize, isLoadingHistory, nextHistoryOffset, totalTasksSize])
+
+	useEffect(() => {
+		if (searchQuery && sortOption !== "mostRelevant" && !lastNonRelevantSort) {
+			setLastNonRelevantSort(sortOption)
+			setSortOption("mostRelevant")
+		} else if (!searchQuery && sortOption === "mostRelevant" && lastNonRelevantSort) {
+			setSortOption(lastNonRelevantSort)
+			setLastNonRelevantSort(null)
+		}
+	}, [searchQuery, sortOption, lastNonRelevantSort])
+
+	const handleHistorySelect = useCallback((itemId: string, checked: boolean) => {
+		setSelectedItems((prev) => {
+			if (checked) {
+				return [...prev, itemId]
+			}
+			return prev.filter((id) => id !== itemId)
+		})
+	}, [])
+
+	const handleDeleteHistoryItem = useCallback(
+		(id: string) => {
+			TaskServiceClient.deleteTasksWithIds(StringArrayRequest.create({ value: [id] }))
+				.then(async () => {
+					await loadTaskHistory(0)
+					await fetchTotalTasksSize()
+				})
+				.catch((error) => console.error("Error deleting task:", error))
+		},
+		[fetchTotalTasksSize, loadTaskHistory],
+	)
+
+	const handleDeleteSelectedHistoryItems = useCallback(
+		(ids: string[]) => {
+			if (ids.length > 0) {
+				TaskServiceClient.deleteTasksWithIds(StringArrayRequest.create({ value: ids }))
+					.then(async () => {
+						await loadTaskHistory(0)
+						setSelectedItems([])
+						await fetchTotalTasksSize()
+					})
+					.catch((error) => console.error("Error deleting tasks:", error))
+			}
+		},
+		[fetchTotalTasksSize, loadTaskHistory],
+	)
+
+	const handleDeleteAllHistory = useCallback(() => {
+		setDeleteAllDisabled(true)
+		TaskServiceClient.deleteAllTaskHistory(EmptyRequest.create({}))
+			.then(async () => {
+				await loadTaskHistory(0)
+				setSelectedItems([])
+				await fetchTotalTasksSize()
+			})
+			.catch((error) => console.error("Error deleting task history:", error))
+			.finally(() => setDeleteAllDisabled(false))
+	}, [fetchTotalTasksSize, loadTaskHistory])
+
+	const fuse = useMemo(() => {
+		return new Fuse(tasks, {
+			keys: ["task"],
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [tasks])
+
+	const taskHistorySearchResults = useMemo(() => {
+		const results = searchQuery
+			? fuse
+					.search(searchQuery)
+					?.filter(({ matches }) => matches && matches.length)
+					.map(({ item }) => item)
+			: tasks
+
+		results.sort((a, b) => {
+			switch (sortOption) {
+				case "oldest":
+					return a.ts - b.ts
+				case "mostExpensive":
+					return (b.totalCost || 0) - (a.totalCost || 0)
+				case "mostTokens":
+					return (
+						(b.tokensIn || 0) +
+						(b.tokensOut || 0) +
+						(b.cacheWrites || 0) +
+						(b.cacheReads || 0) -
+						((a.tokensIn || 0) + (a.tokensOut || 0) + (a.cacheWrites || 0) + (a.cacheReads || 0))
+					)
+				case "mostRelevant":
+					// NOTE: you must never sort directly on object since it will cause members to be reordered
+					return searchQuery ? 0 : b.ts - a.ts // Keep fuse order if searching, otherwise sort by newest
+				case "newest":
+				default:
+					return b.ts - a.ts
+			}
+		})
+
+		return results
+	}, [tasks, searchQuery, fuse, sortOption])
+
+	// Group tasks into "Today" and "Older" (only for date-based sorts)
+	const { groupedTasks, groupCounts, groupLabels } = useMemo(() => {
+		const isDateSort = sortOption === "newest" || sortOption === "oldest"
+
+		if (!isDateSort) {
+			// No grouping for non-date sorts
+			return {
+				groupedTasks: taskHistorySearchResults,
+				groupCounts: [taskHistorySearchResults.length],
+				groupLabels: [] as string[],
+			}
+		}
+
+		const todayTasks: any[] = []
+		const olderTasks: any[] = []
+
+		taskHistorySearchResults.forEach((task) => {
+			if (isToday(task.ts)) {
+				todayTasks.push(task)
+			} else {
+				olderTasks.push(task)
+			}
+		})
+
+		const groups: { tasks: any[]; label: string }[] = []
+		if (todayTasks.length > 0) {
+			groups.push({ tasks: todayTasks, label: "Today" })
+		}
+		if (olderTasks.length > 0) {
+			groups.push({ tasks: olderTasks, label: "Older" })
+		}
+
+		return {
+			groupedTasks: groups.flatMap((g) => g.tasks),
+			groupCounts: groups.map((g) => g.tasks.length),
+			groupLabels: groups.map((g) => g.label),
+		}
+	}, [taskHistorySearchResults, sortOption])
+
+	// Calculate total size of selected items
+	const selectedItemsSize = useMemo(() => {
+		if (selectedItems.length === 0) {
+			return 0
+		}
+
+		return tasks.filter((item) => selectedItems.includes(item.id)).reduce((total, item) => total + (item.size || 0), 0)
+	}, [selectedItems, tasks])
+
+	const handleBatchHistorySelect = useCallback(
+		(selectAll: boolean) => {
+			if (selectAll) {
+				setSelectedItems(taskHistorySearchResults.map((item) => item.id))
+			} else {
+				setSelectedItems([])
+			}
+		},
+		[taskHistorySearchResults],
+	)
+
+	return (
+		<div className="fixed overflow-hidden inset-0 flex flex-col w-full">
+			{/* HEADER */}
+			<ViewHeader environment={environment} onDone={onDone} title="History" />
+
+			{/* FILTERS */}
+			<div className="flex flex-col gap-3 px-3">
+				{/* REPLACE VSCODE RADIO GROUP */}
+				<div className="flex justify-between items-center">
+					{/* SEARCH BOX */}
+					<VSCodeTextField
+						className="w-full"
+						onInput={(e) => {
+							const newValue = (e.target as HTMLInputElement)?.value
+							setSearchQuery(newValue)
+							if (newValue && !searchQuery && sortOption !== "mostRelevant") {
+								setLastNonRelevantSort(sortOption)
+								setSortOption("mostRelevant")
+							}
+						}}
+						placeholder="Fuzzy search history..."
+						value={searchQuery}>
+						<div className="codicon codicon-search opacity-80 mt-0.5 !text-sm" slot="start" />
+						{searchQuery && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close flex justify-center items-center h-full"
+								onClick={() => setSearchQuery("")}
+								slot="end"
+							/>
+						)}
+					</VSCodeTextField>
+					<Select
+						onValueChange={(value) => {
+							// Handle sort options
+							if (
+								value === "newest" ||
+								value === "oldest" ||
+								value === "mostExpensive" ||
+								value === "mostTokens" ||
+								value === "mostRelevant"
+							) {
+								if (value === "mostRelevant" && !searchQuery) {
+									// Don't allow selecting mostRelevant without a search query
+									return
+								}
+								setSortOption(value as SortOption)
+								if (value !== "mostRelevant") {
+									setLastNonRelevantSort(value as SortOption)
+								}
+							}
+							// Handle filter toggles
+							else if (value === "workspaceOnly") {
+								setShowCurrentWorkspaceOnly(!showCurrentWorkspaceOnly)
+							} else if (value === "favoritesOnly") {
+								setShowFavoritesOnly(!showFavoritesOnly)
+							}
+						}}
+						value={sortOption}>
+						<SelectTrigger className="border-0 cursor-pointer" showIcon={false}>
+							<FunnelIcon className="!size-2 text-foreground" />
+						</SelectTrigger>
+						<SelectContent position="popper">
+							{Object.entries(HISTORY_FILTERS).map(([key, value]) => {
+								const isSortOption = ["newest", "oldest", "mostExpensive", "mostTokens", "mostRelevant"].includes(
+									key,
+								)
+								const isFilterOption = ["workspaceOnly", "favoritesOnly"].includes(key)
+								const isSelected = isSortOption
+									? sortOption === key
+									: key === "workspaceOnly"
+										? showCurrentWorkspaceOnly
+										: key === "favoritesOnly"
+											? showFavoritesOnly
+											: false
+								const isDisabled = key === "mostRelevant" && !searchQuery
+
+								return (
+									<SelectItem
+										className={isSelected ? "bg-button-background/30" : ""}
+										disabled={isDisabled}
+										key={key}
+										value={key}>
+										<span className="flex items-center gap-2">
+											{isFilterOption && (
+												<span
+													className={`codicon ${
+														key === "workspaceOnly" ? "codicon-folder" : "codicon-star-full"
+													} ${isSelected ? "text-button-background" : ""}`}
+												/>
+											)}
+											{value}
+										</span>
+									</SelectItem>
+								)
+							})}
+						</SelectContent>
+					</Select>
+				</div>
+			</div>
+
+			{/* HISTORY ITEMS */}
+			<div className="flex-grow overflow-y-auto m-0 w-full py-2">
+				<GroupedVirtuoso
+					className="flex-grow overflow-y-scroll"
+					components={{
+						Footer: () =>
+							hasMoreTasks ? (
+								<div className="px-4 py-3 text-center text-xs text-description">
+									{isLoadingHistory ? "Loading..." : ""}
+								</div>
+							) : null,
+					}}
+					endReached={loadMoreTaskHistory}
+					groupContent={(index) => (
+						<div className="px-4 py-2 text-xs font-bold uppercase tracking-wide sticky top-0 z-10 text-description bg-sidebar-background border-b-border-panel">
+							{groupLabels[index]}
+						</div>
+					)}
+					groupCounts={groupCounts}
+					itemContent={(index) => {
+						const item = groupedTasks[index]
+						return (
+							<HistoryViewItem
+								handleDeleteHistoryItem={handleDeleteHistoryItem}
+								handleHistorySelect={handleHistorySelect}
+								index={index}
+								item={item}
+								pendingFavoriteToggles={pendingFavoriteToggles}
+								selectedItems={selectedItems}
+								toggleFavorite={toggleFavorite}
+							/>
+						)
+					}}
+				/>
+			</div>
+
+			{/* FOOTER */}
+			<div className="p-2.5 border-t border-t-border-panel">
+				<div className="flex gap-2.5 mb-2.5">
+					<Button className="flex-1" onClick={() => handleBatchHistorySelect(true)} variant="secondary">
+						Select All
+					</Button>
+					<Button className="flex-1" onClick={() => handleBatchHistorySelect(false)} variant="secondary">
+						Select None
+					</Button>
+				</div>
+				{selectedItems.length > 0 ? (
+					<Button
+						aria-label="Delete selected items"
+						className="w-full"
+						onClick={() => {
+							handleDeleteSelectedHistoryItems(selectedItems)
+						}}
+						variant="danger">
+						Delete {selectedItems.length > 1 ? selectedItems.length : ""} Selected
+						{selectedItemsSize > 0 ? ` (${formatSize(selectedItemsSize)})` : ""}
+					</Button>
+				) : (
+					<Button
+						aria-label="Delete all history"
+						className="w-full"
+						disabled={deleteAllDisabled || (taskHistory.length === 0 && tasks.length === 0)}
+						onClick={handleDeleteAllHistory}
+						variant="danger">
+						Delete All History{totalTasksSize !== null ? ` (${formatSize(totalTasksSize)})` : ""}
+					</Button>
+				)}
+			</div>
+		</div>
+	)
+}
+
+// https://gist.github.com/evenfrost/1ba123656ded32fb7a0cd4651efd4db0
+export const highlight = (fuseSearchResult: FuseResult<any>[], highlightClassName = "history-item-highlight") => {
+	const set = (obj: Record<string, any>, path: string, value: any) => {
+		const pathValue = path.split(".")
+		let i: number
+
+		for (i = 0; i < pathValue.length - 1; i++) {
+			obj = obj[pathValue[i]] as Record<string, any>
+		}
+
+		obj[pathValue[i]] = value
+	}
+
+	// Function to merge overlapping regions
+	const mergeRegions = (regions: [number, number][]): [number, number][] => {
+		if (regions.length === 0) {
+			return regions
+		}
+
+		// Sort regions by start index
+		regions.sort((a, b) => a[0] - b[0])
+
+		const merged: [number, number][] = [regions[0]]
+
+		for (let i = 1; i < regions.length; i++) {
+			const last = merged[merged.length - 1]
+			const current = regions[i]
+
+			if (current[0] <= last[1] + 1) {
+				// Overlapping or adjacent regions
+				last[1] = Math.max(last[1], current[1])
+			} else {
+				merged.push(current)
+			}
+		}
+
+		return merged
+	}
+
+	const generateHighlightedText = (inputText: string, regions: [number, number][] = []) => {
+		if (regions.length === 0) {
+			return inputText
+		}
+
+		// Sort and merge overlapping regions
+		const mergedRegions = mergeRegions(regions)
+
+		let content = ""
+		let nextUnhighlightedRegionStartingIndex = 0
+
+		mergedRegions.forEach((region) => {
+			const start = region[0]
+			const end = region[1]
+			const lastRegionNextIndex = end + 1
+
+			content += [
+				inputText.substring(nextUnhighlightedRegionStartingIndex, start),
+				`<span class="${highlightClassName}">`,
+				inputText.substring(start, lastRegionNextIndex),
+				"</span>",
+			].join("")
+
+			nextUnhighlightedRegionStartingIndex = lastRegionNextIndex
+		})
+
+		content += inputText.substring(nextUnhighlightedRegionStartingIndex)
+
+		return content
+	}
+
+	return fuseSearchResult
+		.filter(({ matches }) => matches && matches.length)
+		.map(({ item, matches }) => {
+			const highlightedItem = { ...item }
+
+			matches?.forEach((match) => {
+				if (match.key && typeof match.value === "string" && match.indices) {
+					// Merge overlapping regions before generating highlighted text
+					const mergedIndices = mergeRegions([...match.indices])
+					set(highlightedItem, match.key, generateHighlightedText(match.value, mergedIndices))
+				}
+			})
+
+			return highlightedItem
+		})
+}
+
+export default memo(HistoryView)
diff --git a/apps/vscode/webview-ui/src/components/history/HistoryViewItem.tsx b/apps/vscode/webview-ui/src/components/history/HistoryViewItem.tsx
new file mode 100644
index 0000000..d2ac6c1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/history/HistoryViewItem.tsx
@@ -0,0 +1,228 @@
+import { HistoryItem } from "@shared/HistoryItem"
+import { StringRequest } from "@shared/proto/cline/common"
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import {
+	ArrowDownIcon,
+	ArrowLeftIcon,
+	ArrowRightIcon,
+	ArrowUpIcon,
+	ChevronsDownUpIcon,
+	ChevronsUpDownIcon,
+	DownloadIcon,
+	StarIcon,
+	TrashIcon,
+} from "lucide-react"
+import { memo, useCallback, useMemo, useState } from "react"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+import { TaskServiceClient } from "@/services/grpc-client"
+import { formatLargeNumber, formatSize } from "@/utils/format"
+
+type HistoryViewItemProps = {
+	item: HistoryItem
+	index: number
+	selectedItems: string[]
+	pendingFavoriteToggles: Record<string, boolean>
+	handleDeleteHistoryItem: (id: string) => void
+	toggleFavorite: (id: string, isCurrentlyFavorited: boolean) => void
+	handleHistorySelect: (itemId: string, checked: boolean) => void
+}
+
+const HistoryViewItem = ({
+	item,
+	pendingFavoriteToggles,
+	handleDeleteHistoryItem,
+	toggleFavorite,
+	handleHistorySelect,
+	selectedItems,
+}: HistoryViewItemProps) => {
+	const [expanded, setExpanded] = useState(false)
+
+	const isFavoritedItem = useMemo(
+		() => pendingFavoriteToggles[item.id] ?? item.isFavorited,
+		[item.id, item.isFavorited, pendingFavoriteToggles],
+	)
+
+	const handleShowTaskWithId = useCallback((id: string) => {
+		TaskServiceClient.showTaskWithId(StringRequest.create({ value: id })).catch((error) =>
+			console.error("Error showing task:", error),
+		)
+	}, [])
+
+	const formatDate = useCallback((timestamp: number) => {
+		const date = new Date(timestamp)
+		const today = new Date()
+		const isToday = today.toDateString() === date.toDateString()
+
+		return date
+			.toLocaleString(
+				"en-US",
+				isToday
+					? {
+							hour: "numeric",
+							minute: "2-digit",
+							hour12: true,
+						}
+					: {
+							month: "long",
+							day: "numeric",
+							hour: "numeric",
+							minute: "2-digit",
+							hour12: true,
+						},
+			)
+			.replace(", ", " ")
+			.replace(" at", ",")
+	}, [])
+
+	return (
+		<div className="history-item cursor-pointer flex group mb-1 hover:bg-list-hover border-b border-accent/10" key={item.id}>
+			<VSCodeCheckbox
+				checked={selectedItems.includes(item.id)}
+				className="pl-3 pr-1 py-auto self-start mt-3"
+				onClick={(e) => {
+					e.preventDefault()
+					e.stopPropagation()
+					const checked = (e.target as HTMLInputElement).checked
+					handleHistorySelect(item.id, checked)
+				}}
+			/>
+
+			<div
+				className="flex flex-col gap-2 py-2 pl-2 pr-3 relative flex-grow min-w-0"
+				onClick={(e) => {
+					e.stopPropagation()
+					handleShowTaskWithId(item.id)
+				}}>
+				<div className="flex items-center gap-2">
+					<div className="line-clamp-1 overflow-hidden break-words whitespace-pre-wrap flex-1 min-w-0">
+						<span className="ph-no-capture">{item.task}</span>
+					</div>
+					<div className="flex gap-2 flex-shrink-0">
+						<Button
+							aria-label="Delete"
+							className="p-0 opacity-0 group-hover:opacity-100 transition-opacity"
+							disabled={isFavoritedItem}
+							onClick={(e) => {
+								e.stopPropagation()
+								handleDeleteHistoryItem(item.id)
+							}}
+							variant="ghost">
+							<span className="flex items-center gap-1 text-xs">
+								<TrashIcon className="stroke-1" />
+							</span>
+						</Button>
+						<Button
+							aria-label={isFavoritedItem ? "Remove from favorites" : "Add to favorites"}
+							className="p-0"
+							disabled={pendingFavoriteToggles[item.id] !== undefined}
+							onClick={(e) => {
+								e.stopPropagation()
+								toggleFavorite(item.id, isFavoritedItem)
+							}}
+							variant="icon">
+							<StarIcon
+								className={cn("opacity-70", {
+									"text-button-background  fill-button-background opacity-100": isFavoritedItem,
+								})}
+							/>
+						</Button>
+					</div>
+				</div>
+
+				<Button
+					className="p-0"
+					onClick={(e) => {
+						e.stopPropagation()
+						setExpanded(!expanded)
+					}}
+					variant="icon">
+					<div className="flex items-center justify-between w-full">
+						<div className="text-description text-xs uppercase">{formatDate(item.ts)}</div>
+						<div className="self-end flex items-center text-xs">
+							<span className="text-description">${item.totalCost?.toFixed(4) ?? 0}</span>
+							{expanded ? (
+								<ChevronsDownUpIcon className="text-description" />
+							) : (
+								<ChevronsUpDownIcon className="text-description hidden opacity-0 group-hover:opacity-100 transition-opacity group-hover:block" />
+							)}
+						</div>
+					</div>
+				</Button>
+				{expanded && (
+					<Button
+						className="m-0 text-xs cursor-pointer p-2 bg-accent/10 w-full rounded-xs"
+						onClick={(e) => {
+							e.stopPropagation()
+							setExpanded(!expanded)
+						}}
+						variant="text">
+						<div className="flex flex-col gap-1 w-full text-xs">
+							<div className="flex items-center justify-between w-full">
+								<div className="flex items-center gap-1 flex-wrap w-full">
+									<div className="flex justify-between items-center w-full gap-1 text-xs">
+										<span className="font-medium text-description">Tokens:</span>
+										<div className="flex items-center gap-1 text-description text-xs">
+											<span className="flex items-center gap-1 text-description">
+												<ArrowUpIcon className="text-description !size-1" />
+												{formatLargeNumber(item.tokensIn || 0)}
+											</span>
+											<span className="flex items-center gap-1 text-description">
+												<ArrowDownIcon className="text-description !size-1" />
+												{formatLargeNumber(item.tokensOut || 0)}
+											</span>
+											{item.cacheWrites
+												? item.cacheWrites > 0 && (
+														<span className="flex items-center gap-1 text-description">
+															<ArrowRightIcon className="text-description !size-1" />
+															{formatLargeNumber(item.cacheWrites)}
+														</span>
+													)
+												: null}
+											{item.cacheReads
+												? item.cacheReads > 0 && (
+														<span className="flex items-center gap-1 text-description">
+															<ArrowLeftIcon className="text-description !size-1" />
+															{formatLargeNumber(item.cacheReads)}
+														</span>
+													)
+												: null}
+										</div>
+									</div>
+
+									{item.modelId && (
+										<div className="flex justify-between items-center w-full gap-1 text-xs">
+											<span className="font-medium text-description">Model:</span>
+											<span className="text-description">{item.modelId}</span>
+										</div>
+									)}
+
+									<div className="flex justify-between items-center w-full gap-1 text-xs">
+										<span className="font-medium text-description">Size:</span>
+										<span className="items-center gap-2 flex text-description">
+											{formatSize(item.size)}
+											<Button
+												aria-label="Export"
+												className="m-0 p-0"
+												onClick={(e) => {
+													e.stopPropagation()
+													TaskServiceClient.exportTaskWithId(
+														StringRequest.create({ value: item.id }),
+													).catch((err) => console.error("Failed to export task:", err))
+												}}
+												variant="ghost">
+												<DownloadIcon />
+											</Button>
+										</span>
+									</div>
+								</div>
+							</div>
+						</div>
+					</Button>
+				)}
+			</div>
+		</div>
+	)
+}
+
+export default memo(HistoryViewItem)
diff --git a/apps/vscode/webview-ui/src/components/marketplace/MarketplaceView.tsx b/apps/vscode/webview-ui/src/components/marketplace/MarketplaceView.tsx
new file mode 100644
index 0000000..4cd6726
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/marketplace/MarketplaceView.tsx
@@ -0,0 +1,1356 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import {
+	MarketplaceEntriesRequest,
+	type MarketplaceEntry,
+	MarketplaceEntryRequest,
+	type MarketplaceLocalInstalledEntry,
+	MarketplaceLocalInstalledEntryRequest,
+	ToggleMarketplaceLocalInstalledEntryRequest,
+} from "@shared/proto/cline/marketplace"
+import { VSCodeButton, VSCodeLink, VSCodeProgressRing, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import {
+	CheckIcon,
+	DownloadIcon,
+	LoaderCircleIcon,
+	type LucideIcon,
+	PlugIcon,
+	PuzzleIcon,
+	SparklesIcon,
+	Trash2Icon,
+} from "lucide-react"
+import { type ReactNode, useCallback, useEffect, useMemo, useState } from "react"
+import { Switch } from "@/components/ui/switch"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { MarketplaceServiceClient, McpServiceClient } from "@/services/grpc-client"
+import { Tab, TabContent, TabList, TabTrigger } from "../common/Tab"
+import ViewHeader from "../common/ViewHeader"
+import AddRemoteServerForm from "../mcp/configuration/tabs/add-server/AddRemoteServerForm"
+import ServersToggleList, { type MarketplaceMcpMetadata } from "../mcp/configuration/tabs/installed/ServersToggleList"
+import { entryMatchesLocalEntry, localEntryKey } from "./marketplaceMatch"
+
+type PrimitiveType = "mcp" | "skill" | "plugin"
+type MarketplaceSectionType = "installed" | "marketplace"
+
+type MarketplaceViewProps = {
+	initialType?: PrimitiveType
+	onDone: () => void
+}
+
+type PrimitiveConfig = {
+	type: PrimitiveType
+	label: string
+	singular: string
+	plural: string
+	title: string
+	description: ReactNode
+	icon: LucideIcon
+}
+
+const PRIMITIVES: PrimitiveConfig[] = [
+	{
+		type: "skill",
+		label: "Skills",
+		singular: "skill",
+		plural: "skills",
+		title: "Skills",
+		description: (
+			<>
+				Reusable instruction sets that Cline loads on demand for specific tasks, without staying in context for unrelated
+				work. Browse more at <VSCodeLink href="https://agentskills.io/">Agent Skills</VSCodeLink>.
+			</>
+		),
+		icon: SparklesIcon,
+	},
+	{
+		type: "mcp",
+		label: "MCP",
+		singular: "MCP server",
+		plural: "MCP servers",
+		title: "MCP Servers",
+		description: (
+			<>
+				Connect Cline to external APIs, local tools, and hosted services through{" "}
+				<VSCodeLink href="https://modelcontextprotocol.io/">MCP</VSCodeLink> servers.
+			</>
+		),
+		icon: PlugIcon,
+	},
+	{
+		type: "plugin",
+		label: "Plugins",
+		singular: "plugin",
+		plural: "plugins",
+		title: "Plugins",
+		description: (
+			<>
+				<VSCodeLink href="https://docs.cline.bot/sdk/plugins">Plugins</VSCodeLink> are extensions for capabilities more
+				complex than a single MCP server or skill, including custom tools, hooks, rules, slash commands, or bundled
+				skills.
+			</>
+		),
+		icon: PuzzleIcon,
+	},
+]
+
+const MARKETPLACE_SECTIONS: Array<{ type: MarketplaceSectionType; label: string }> = [
+	{ type: "installed", label: "Installed" },
+	{ type: "marketplace", label: "Marketplace" },
+]
+
+function isPrimitiveType(value: string): value is PrimitiveType {
+	return value === "mcp" || value === "skill" || value === "plugin"
+}
+
+function entryKey(entry: MarketplaceEntry): string {
+	return `${entry.type}:${entry.id}`
+}
+
+function installArgs(entry: MarketplaceEntry): string[] {
+	return entry.install?.args ?? []
+}
+
+function getPrimitive(type: PrimitiveType): PrimitiveConfig {
+	return PRIMITIVES.find((primitive) => primitive.type === type) ?? PRIMITIVES[0]
+}
+
+function sourceLabel(entry: MarketplaceLocalInstalledEntry): string | undefined {
+	if (entry.source === "global") return "Global"
+	if (entry.source === "workspace") return "Workspace"
+	if (entry.source === "remote") return "Remote"
+	return undefined
+}
+
+function setupSummary(entry: MarketplaceEntry): string | undefined {
+	const env = entry.install?.env ?? []
+	if (env.length === 0 && !entry.install?.notes) return undefined
+	const required = env.filter((item) => item.required).map((item) => item.name)
+	if (required.length > 0) return `Requires ${required.join(", ")}`
+	if (env.length > 0) return `Uses ${env.map((item) => item.name).join(", ")}`
+	return entry.install?.notes
+}
+
+function tagId(label: string): string {
+	return label
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+}
+
+function entryTagLabels(entry: MarketplaceEntry): string[] {
+	const labels = new Map<string, string>()
+	for (const label of entry.tags) {
+		const id = tagId(label)
+		if (id) labels.set(id, label)
+	}
+	for (const tag of entry.tagObjects ?? []) {
+		const id = tagId(tag.label)
+		if (id) labels.set(id, tag.label)
+	}
+	return [...labels.values()]
+}
+
+function searchTextForEntry(entry: MarketplaceEntry): string {
+	return [
+		entry.id,
+		entry.name,
+		entry.tagline,
+		entry.description,
+		entry.author,
+		...entryTagLabels(entry),
+		...installArgs(entry),
+		...(entry.install?.env ?? []).map((item) => item.name),
+	]
+		.filter(Boolean)
+		.join(" ")
+		.toLowerCase()
+}
+
+const MarketplaceStyles = () => (
+	<style>{`
+		.marketplace-view {
+			background: var(--vscode-sideBar-background);
+			color: var(--vscode-foreground);
+			min-width: 0;
+		}
+
+		.marketplace-view > div:first-of-type {
+			margin-bottom: 4px;
+		}
+
+		.marketplace-shell {
+			min-height: 0;
+			display: flex;
+			flex-direction: column;
+			flex: 1;
+		}
+
+		.marketplace-nav {
+			flex: 0 0 auto;
+			display: flex;
+			align-items: center;
+			min-width: 0;
+			overflow-x: auto;
+			overflow-y: hidden;
+			border-bottom: 1px solid var(--vscode-panel-border);
+			background: var(--vscode-sideBar-background);
+			padding: 0 8px;
+		}
+
+		.marketplace-tab {
+			width: auto;
+			flex: 0 1 auto;
+			min-width: fit-content;
+			height: 34px;
+			border: 0;
+			border-bottom: 2px solid transparent;
+			background: transparent;
+			color: var(--vscode-descriptionForeground);
+			font: inherit;
+			font-size: var(--vscode-font-size);
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			gap: 8px;
+			padding: 0 12px;
+			text-align: center;
+			cursor: pointer;
+		}
+
+		.marketplace-tab:hover {
+			background: var(--vscode-list-hoverBackground);
+			color: var(--vscode-foreground);
+		}
+
+		.marketplace-tab[aria-selected="true"] {
+			background: var(--vscode-list-activeSelectionBackground);
+			color: var(--vscode-list-activeSelectionForeground);
+			border-bottom-color: var(--vscode-list-activeSelectionForeground, var(--vscode-foreground));
+		}
+
+		.marketplace-tab-label {
+			overflow: hidden;
+			text-overflow: ellipsis;
+			white-space: nowrap;
+		}
+
+		.marketplace-content {
+			min-width: 0;
+			background: var(--vscode-editor-background);
+		}
+
+		.marketplace-inner {
+			box-sizing: border-box;
+			width: 100%;
+			max-width: 760px;
+			margin: 0 auto;
+			padding: 14px 18px 20px;
+		}
+
+		.marketplace-primitive-description {
+			margin-bottom: 12px;
+			color: var(--vscode-descriptionForeground);
+			font-size: calc(var(--vscode-font-size) * 0.9);
+			line-height: 1.4;
+		}
+
+		.marketplace-primitive-description vscode-link {
+			font-size: inherit;
+		}
+
+		.marketplace-error {
+			border: 1px solid var(--vscode-inputValidation-errorBorder);
+			background: var(--vscode-inputValidation-errorBackground);
+			color: var(--vscode-inputValidation-errorForeground, var(--vscode-foreground));
+			padding: 8px 10px;
+			margin-bottom: 12px;
+			font-size: calc(var(--vscode-font-size) * 0.92);
+			line-height: 1.4;
+			white-space: pre-wrap;
+			word-break: break-word;
+		}
+
+		.marketplace-subnav {
+			display: flex;
+			align-items: center;
+			gap: 0;
+			min-width: 0;
+			margin: 0 0 12px;
+			border-bottom: 1px solid var(--vscode-panel-border);
+		}
+
+		.marketplace-subtab {
+			height: 30px;
+			border: 0;
+			border-bottom: 2px solid transparent;
+			background: transparent;
+			color: var(--vscode-descriptionForeground);
+			font: inherit;
+			font-size: calc(var(--vscode-font-size) * 0.92);
+			padding: 0 10px;
+			cursor: pointer;
+		}
+
+		.marketplace-subtab:hover {
+			background: var(--vscode-list-hoverBackground);
+			color: var(--vscode-foreground);
+		}
+
+		.marketplace-subtab:disabled {
+			cursor: not-allowed;
+			opacity: 0.5;
+		}
+
+		.marketplace-subtab:disabled:hover {
+			background: transparent;
+			color: var(--vscode-descriptionForeground);
+		}
+
+		.marketplace-subtab[aria-selected="true"] {
+			color: var(--vscode-foreground);
+			border-bottom-color: var(--vscode-focusBorder);
+		}
+
+		.marketplace-section {
+			margin-bottom: 20px;
+		}
+
+		.marketplace-section-header {
+			display: flex;
+			align-items: center;
+			gap: 12px;
+			margin-bottom: 6px;
+			padding-bottom: 5px;
+			border-bottom: 1px solid var(--vscode-panel-border);
+		}
+
+		.marketplace-section-title {
+			font-size: calc(var(--vscode-font-size) * 0.92);
+			font-weight: 600;
+			color: var(--vscode-foreground);
+			margin: 0;
+		}
+
+		.marketplace-section-count {
+			color: var(--vscode-descriptionForeground);
+			font-size: calc(var(--vscode-font-size) * 0.85);
+		}
+
+		.marketplace-list {
+			display: grid;
+			gap: 7px;
+			background: transparent;
+		}
+
+		.marketplace-row {
+			display: grid;
+			grid-template-columns: minmax(0, 1fr) auto;
+			gap: 10px;
+			align-items: start;
+			min-height: 42px;
+			padding: 9px 10px;
+			border: 1px solid var(--vscode-panel-border);
+			background: var(--vscode-sideBar-background);
+		}
+
+		.marketplace-row:hover {
+			background: var(--vscode-list-hoverBackground);
+		}
+
+		.marketplace-row-main {
+			min-width: 0;
+		}
+
+		.marketplace-row-title {
+			display: flex;
+			align-items: center;
+			gap: 7px;
+			min-width: 0;
+			color: var(--vscode-foreground);
+			font-size: var(--vscode-font-size);
+			font-weight: 500;
+			line-height: 1.35;
+		}
+
+		.marketplace-row-name {
+			min-width: 0;
+			overflow: hidden;
+			text-overflow: ellipsis;
+			white-space: nowrap;
+		}
+
+		.marketplace-row-description {
+			margin-top: 2px;
+			color: var(--vscode-descriptionForeground);
+			font-size: calc(var(--vscode-font-size) * 0.9);
+			line-height: 1.35;
+			display: -webkit-box;
+			-webkit-line-clamp: 2;
+			-webkit-box-orient: vertical;
+			overflow: hidden;
+			overflow-wrap: anywhere;
+			word-break: break-word;
+		}
+
+		.marketplace-row-description code {
+			overflow-wrap: anywhere;
+			word-break: break-word;
+			white-space: normal;
+		}
+
+		.marketplace-row-meta {
+			margin-top: 4px;
+			display: flex;
+			flex-wrap: wrap;
+			gap: 6px;
+			align-items: center;
+			color: var(--vscode-descriptionForeground);
+			font-size: calc(var(--vscode-font-size) * 0.82);
+			line-height: 1.3;
+		}
+
+		.marketplace-pill {
+			display: inline-flex;
+			align-items: center;
+			gap: 4px;
+			max-width: 100%;
+			min-width: 0;
+			padding: 1px 5px;
+			border-radius: 2px;
+			border: 1px solid var(--vscode-badge-background);
+			background: color-mix(in srgb, var(--vscode-badge-background) 20%, transparent);
+			color: var(--vscode-descriptionForeground);
+			white-space: normal;
+			overflow-wrap: anywhere;
+			word-break: break-word;
+		}
+
+		.marketplace-path {
+			min-width: 0;
+			overflow: hidden;
+			text-overflow: ellipsis;
+			white-space: normal;
+			overflow-wrap: anywhere;
+			word-break: break-word;
+			font-family: var(--vscode-editor-font-family);
+		}
+
+		.marketplace-action {
+			display: flex;
+			gap: 6px;
+			justify-content: flex-end;
+			align-items: center;
+		}
+
+		.marketplace-local-toggle {
+			display: flex;
+			align-items: center;
+			justify-content: flex-end;
+			min-height: 24px;
+		}
+
+		.marketplace-icon-button {
+			width: 24px;
+			height: 24px;
+			border: 1px solid transparent;
+			border-radius: 3px;
+			background: transparent;
+			color: var(--vscode-icon-foreground);
+			display: inline-flex;
+			align-items: center;
+			justify-content: center;
+			padding: 0;
+			cursor: pointer;
+		}
+
+		.marketplace-icon-button:hover:not(:disabled) {
+			background: var(--vscode-toolbar-hoverBackground);
+			color: var(--vscode-foreground);
+		}
+
+		.marketplace-icon-button:focus-visible {
+			outline: 1px solid var(--vscode-focusBorder);
+			outline-offset: 1px;
+		}
+
+		.marketplace-icon-button:disabled {
+			cursor: default;
+			opacity: 0.65;
+		}
+
+		.marketplace-icon-button-danger {
+			color: var(--vscode-errorForeground, var(--vscode-icon-foreground));
+		}
+
+		.marketplace-icon-button svg {
+			width: 14px;
+			height: 14px;
+		}
+
+		.marketplace-icon-spin {
+			animation: marketplace-spin 0.9s linear infinite;
+		}
+
+		@keyframes marketplace-spin {
+			from {
+				transform: rotate(0deg);
+			}
+			to {
+				transform: rotate(360deg);
+			}
+		}
+
+		.marketplace-search {
+			margin: 0 0 10px;
+		}
+
+		.marketplace-search vscode-text-field {
+			width: 100%;
+		}
+
+		.marketplace-clear-search {
+			all: unset;
+			cursor: pointer;
+			display: inline-flex;
+			align-items: center;
+			justify-content: center;
+			color: var(--vscode-descriptionForeground);
+		}
+
+		.marketplace-clear-search:hover {
+			color: var(--vscode-foreground);
+		}
+
+		.marketplace-clear-search:focus-visible {
+			outline: 1px solid var(--vscode-focusBorder);
+			outline-offset: 2px;
+		}
+
+		.marketplace-filters {
+			display: flex;
+			align-items: center;
+			justify-content: space-between;
+			gap: 10px;
+			margin: 0 0 10px;
+			min-width: 0;
+		}
+
+		.marketplace-filter-scroll {
+			display: flex;
+			flex-wrap: wrap;
+			gap: 6px;
+			min-width: 0;
+		}
+
+		.marketplace-tag-button {
+			display: inline-flex;
+			align-items: center;
+			gap: 5px;
+			height: 24px;
+			border: 1px solid var(--vscode-button-border, var(--vscode-panel-border));
+			border-radius: 3px;
+			background: var(--vscode-button-secondaryBackground);
+			color: var(--vscode-button-secondaryForeground);
+			font: inherit;
+			font-size: calc(var(--vscode-font-size) * 0.86);
+			padding: 0 7px;
+			white-space: nowrap;
+			cursor: pointer;
+		}
+
+		.marketplace-tag-button:hover {
+			background: var(--vscode-button-secondaryHoverBackground);
+		}
+
+		.marketplace-tag-button[data-active="true"] {
+			background: var(--vscode-button-background);
+			color: var(--vscode-button-foreground);
+			border-color: var(--vscode-button-background);
+		}
+
+		.marketplace-tag-count {
+			color: inherit;
+			opacity: 0.75;
+		}
+
+		.marketplace-mcp-panel {
+			display: grid;
+			gap: 10px;
+		}
+
+		.marketplace-mcp-managed {
+			display: flex;
+			align-items: center;
+			gap: 8px;
+			padding: 8px 10px;
+			border-left: 3px solid var(--vscode-textLink-foreground);
+			background: var(--vscode-textBlockQuote-background);
+			color: var(--vscode-foreground);
+			font-size: calc(var(--vscode-font-size) * 0.92);
+			line-height: 1.35;
+		}
+
+		.marketplace-mcp-settings {
+			display: grid;
+			gap: 8px;
+			margin-top: 10px;
+		}
+
+		.marketplace-mcp-settings vscode-button {
+			width: 100%;
+		}
+
+		.marketplace-mcp-advanced {
+			margin-top: -3px;
+			text-align: center;
+			font-size: calc(var(--vscode-font-size) * 0.88);
+		}
+
+		.marketplace-mcp-form {
+			border: 1px solid var(--vscode-panel-border);
+			background: var(--vscode-sideBar-background);
+		}
+
+		.marketplace-mcp-form > div {
+			padding: 12px;
+		}
+
+		.marketplace-empty,
+		.marketplace-loading {
+			min-height: 72px;
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			gap: 8px;
+			border: 1px dashed var(--vscode-panel-border);
+			color: var(--vscode-descriptionForeground);
+			background: var(--vscode-sideBar-background);
+			font-size: calc(var(--vscode-font-size) * 0.92);
+			text-align: center;
+			padding: 12px;
+		}
+
+		.marketplace-loading vscode-progress-ring {
+			width: 18px;
+			height: 18px;
+		}
+
+		@media (max-width: 520px) {
+			.marketplace-nav {
+				padding: 0 4px;
+			}
+
+			.marketplace-tab {
+				flex: 1 1 0;
+				min-width: 0;
+				gap: 5px;
+				padding: 0 6px;
+			}
+
+			.marketplace-inner {
+				padding: 12px 10px 16px;
+			}
+
+			.marketplace-filters {
+				align-items: flex-start;
+				flex-direction: column;
+				gap: 6px;
+			}
+
+			.marketplace-filter-scroll {
+				width: 100%;
+			}
+		}
+	`}</style>
+)
+
+const Section = ({
+	children,
+	count,
+	empty,
+	showHeader = true,
+	title,
+}: {
+	children: React.ReactNode
+	count: number
+	empty: string
+	showHeader?: boolean
+	title: string
+}) => (
+	<section className="marketplace-section">
+		{showHeader && (
+			<div className="marketplace-section-header">
+				<h3 className="marketplace-section-title">{title}</h3>
+			</div>
+		)}
+		{count > 0 ? <div className="marketplace-list">{children}</div> : <div className="marketplace-empty">{empty}</div>}
+	</section>
+)
+
+const MarketplaceCatalogSection = ({
+	children,
+	count,
+	empty,
+	filters,
+	search,
+	showHeader = true,
+}: {
+	children: React.ReactNode
+	count: number
+	empty: string
+	filters: React.ReactNode
+	search: React.ReactNode
+	showHeader?: boolean
+}) => (
+	<section className="marketplace-section">
+		{showHeader && (
+			<div className="marketplace-section-header">
+				<h3 className="marketplace-section-title">Marketplace</h3>
+			</div>
+		)}
+		{search}
+		{filters}
+		{count > 0 ? <div className="marketplace-list">{children}</div> : <div className="marketplace-empty">{empty}</div>}
+	</section>
+)
+
+const TagFilters = ({
+	counts,
+	onSelect,
+	selectedTag,
+	tags,
+}: {
+	counts: Map<string, number>
+	onSelect: (tag: string | null) => void
+	selectedTag: string | null
+	tags: Array<{ id: string; label: string }>
+}) => {
+	if (tags.length === 0) {
+		return null
+	}
+	return (
+		<div className="marketplace-filters">
+			<div className="marketplace-filter-scroll">
+				{tags.map((tag) => (
+					<button
+						className="marketplace-tag-button"
+						data-active={selectedTag === tag.id}
+						key={tag.id}
+						onClick={() => onSelect(selectedTag === tag.id ? null : tag.id)}
+						type="button">
+						<span>{tag.label}</span>
+						<span className="marketplace-tag-count">{counts.get(tag.id) ?? 0}</span>
+					</button>
+				))}
+			</div>
+		</div>
+	)
+}
+
+const McpManagementPanel = ({
+	marketplaceMetadataByServerName,
+	showHeader = true,
+	showServerList = true,
+}: {
+	marketplaceMetadataByServerName?: Map<string, MarketplaceMcpMetadata>
+	showHeader?: boolean
+	showServerList?: boolean
+}) => {
+	const { mcpServers, navigateToSettings, remoteConfigSettings } = useExtensionState()
+	const [showAddRemote, setShowAddRemote] = useState(false)
+	const showRemoteServers = remoteConfigSettings?.blockPersonalRemoteMCPServers !== true
+	const hasRemoteMCPServers = remoteConfigSettings?.remoteMCPServers && remoteConfigSettings.remoteMCPServers.length > 0
+
+	return (
+		<section className="marketplace-section">
+			{showHeader && (
+				<div className="marketplace-section-header">
+					<h3 className="marketplace-section-title">Installed MCP Servers</h3>
+				</div>
+			)}
+			{(showServerList || hasRemoteMCPServers) && (
+				<div className="marketplace-mcp-panel">
+					{hasRemoteMCPServers && (
+						<div className="marketplace-mcp-managed">
+							<span className="codicon codicon-lock" />
+							<span>Your organization manages some MCP servers</span>
+						</div>
+					)}
+					{showServerList && (
+						<ServersToggleList
+							hasTrashIcon={true}
+							isExpandable={true}
+							listGap="small"
+							marketplaceMetadataByServerName={marketplaceMetadataByServerName}
+							servers={mcpServers}
+						/>
+					)}
+				</div>
+			)}
+			<div className="marketplace-mcp-settings">
+				{showRemoteServers && !showAddRemote && (
+					<VSCodeButton appearance="primary" onClick={() => setShowAddRemote(true)}>
+						<span className="codicon codicon-add" style={{ marginRight: "6px" }} />
+						Add Remote Server
+					</VSCodeButton>
+				)}
+				{showRemoteServers && showAddRemote && (
+					<div className="marketplace-mcp-form">
+						<AddRemoteServerForm
+							onCancel={() => setShowAddRemote(false)}
+							onServerAdded={() => setShowAddRemote(false)}
+							showEditConfiguration={false}
+						/>
+					</div>
+				)}
+				<VSCodeButton
+					appearance="secondary"
+					onClick={() => {
+						McpServiceClient.openMcpSettings(EmptyRequest.create({})).catch((error) => {
+							console.error("Error opening MCP settings:", error)
+						})
+					}}>
+					<span className="codicon codicon-server" style={{ marginRight: "6px" }} />
+					Edit Configuration
+				</VSCodeButton>
+				<div className="marketplace-mcp-advanced">
+					<VSCodeLink onClick={() => navigateToSettings("features")}>Advanced MCP Settings</VSCodeLink>
+				</div>
+			</div>
+		</section>
+	)
+}
+
+const LocalInstalledRow = ({
+	entry,
+	onUninstall,
+	onToggle,
+	toggling,
+	uninstalling,
+}: {
+	entry: MarketplaceLocalInstalledEntry
+	onUninstall: (entry: MarketplaceLocalInstalledEntry) => void
+	onToggle: (entry: MarketplaceLocalInstalledEntry, enabled: boolean) => void
+	toggling: boolean
+	uninstalling: boolean
+}) => {
+	const origin = sourceLabel(entry)
+	const canUninstall = !(entry.type === "skill" && entry.path?.startsWith("remote:"))
+	return (
+		<div className="marketplace-row">
+			<div className="marketplace-row-main">
+				<div className="marketplace-row-title">
+					<span className="marketplace-row-name">{entry.name || entry.id}</span>
+				</div>
+				{entry.description && <div className="marketplace-row-description">{entry.description}</div>}
+				<div className="marketplace-row-meta">
+					{origin && <span className="marketplace-pill">{origin}</span>}
+					{entry.path && <span className="marketplace-path">{entry.path}</span>}
+				</div>
+			</div>
+			<div className="marketplace-action">
+				<Switch
+					aria-label={`${entry.enabled ? "Disable" : "Enable"} ${entry.name || entry.id}`}
+					checked={entry.enabled}
+					disabled={toggling}
+					onClick={() => onToggle(entry, !entry.enabled)}
+					title={`${entry.enabled ? "Disable" : "Enable"} ${entry.name || entry.id}`}
+				/>
+				<button
+					aria-label={`Uninstall ${entry.name || entry.id}`}
+					className="marketplace-icon-button marketplace-icon-button-danger"
+					disabled={uninstalling || !canUninstall}
+					onClick={() => onUninstall(entry)}
+					title={
+						canUninstall ? `Uninstall ${entry.name || entry.id}` : "Remote-managed skills cannot be uninstalled here"
+					}
+					type="button">
+					{uninstalling ? (
+						<LoaderCircleIcon aria-hidden className="marketplace-icon-spin" />
+					) : (
+						<Trash2Icon aria-hidden />
+					)}
+				</button>
+			</div>
+		</div>
+	)
+}
+
+const InstalledMarketplaceRow = ({
+	entry,
+	matchedLocalEntries,
+	onToggle,
+	onUninstall,
+	togglingLocalId,
+	uninstalling,
+}: {
+	entry: MarketplaceEntry
+	matchedLocalEntries: MarketplaceLocalInstalledEntry[]
+	onToggle: (entry: MarketplaceLocalInstalledEntry, enabled: boolean) => void
+	onUninstall: (entry: MarketplaceEntry) => void
+	togglingLocalId: string | null
+	uninstalling: boolean
+}) => {
+	const primaryLocalEntry = matchedLocalEntries[0]
+	const label = `Uninstall ${entry.name || entry.id}`
+	return (
+		<div className="marketplace-row">
+			<div className="marketplace-row-main">
+				<div className="marketplace-row-title">
+					<CheckIcon aria-hidden className="h-3.5 w-3.5" />
+					<span className="marketplace-row-name">{entry.name || entry.id}</span>
+				</div>
+				{(entry.description || entry.tagline) && (
+					<div className="marketplace-row-description">{entry.description || entry.tagline}</div>
+				)}
+				<div className="marketplace-row-meta">
+					<span className="marketplace-pill">Marketplace</span>
+					{matchedLocalEntries.map((localEntry) => {
+						const origin = sourceLabel(localEntry)
+						return (
+							<span className="contents" key={localEntryKey(localEntry)}>
+								{origin && <span className="marketplace-pill">{origin}</span>}
+								{localEntry.path && <span className="marketplace-path">{localEntry.path}</span>}
+							</span>
+						)
+					})}
+				</div>
+			</div>
+			<div className="marketplace-action">
+				{primaryLocalEntry && (
+					<Switch
+						aria-label={`${primaryLocalEntry.enabled ? "Disable" : "Enable"} ${entry.name || entry.id}`}
+						checked={primaryLocalEntry.enabled}
+						disabled={togglingLocalId === localEntryKey(primaryLocalEntry)}
+						onClick={() => onToggle(primaryLocalEntry, !primaryLocalEntry.enabled)}
+						title={`${primaryLocalEntry.enabled ? "Disable" : "Enable"} ${entry.name || entry.id}`}
+					/>
+				)}
+				<button
+					aria-label={label}
+					className="marketplace-icon-button marketplace-icon-button-danger"
+					disabled={uninstalling}
+					onClick={() => onUninstall(entry)}
+					title={label}
+					type="button">
+					{uninstalling ? (
+						<LoaderCircleIcon aria-hidden className="marketplace-icon-spin" />
+					) : (
+						<Trash2Icon aria-hidden />
+					)}
+				</button>
+			</div>
+		</div>
+	)
+}
+
+const CatalogEntryRow = ({
+	entry,
+	installing,
+	onInstall,
+}: {
+	entry: MarketplaceEntry
+	installing: boolean
+	onInstall: (entry: MarketplaceEntry) => void
+}) => {
+	const summary = setupSummary(entry)
+	const canInstall = installArgs(entry).length > 0 && !installing
+	const label = `Install ${entry.name || entry.id}`
+	return (
+		<div className="marketplace-row">
+			<div className="marketplace-row-main">
+				<div className="marketplace-row-title">
+					<span className="marketplace-row-name">{entry.name || entry.id}</span>
+				</div>
+				{(entry.description || entry.tagline) && (
+					<div className="marketplace-row-description">{entry.description || entry.tagline}</div>
+				)}
+				<div className="marketplace-row-meta">
+					{summary && <span className="marketplace-pill">{summary}</span>}
+					{entry.author && <span>{entry.author}</span>}
+				</div>
+			</div>
+			<div className="marketplace-action">
+				<button
+					aria-label={label}
+					className="marketplace-icon-button"
+					disabled={!canInstall}
+					onClick={() => onInstall(entry)}
+					title={label}
+					type="button">
+					{installing ? (
+						<LoaderCircleIcon aria-hidden className="marketplace-icon-spin" />
+					) : (
+						<DownloadIcon aria-hidden />
+					)}
+				</button>
+			</div>
+		</div>
+	)
+}
+
+const MarketplaceView = ({ initialType = "skill", onDone }: MarketplaceViewProps) => {
+	const { environment, remoteConfigSettings } = useExtensionState()
+	const [activeType, setActiveType] = useState<PrimitiveType>(initialType)
+	const [activeSection, setActiveSection] = useState<MarketplaceSectionType>("installed")
+	const [catalogEntries, setCatalogEntries] = useState<MarketplaceEntry[]>([])
+	const [localEntries, setLocalEntries] = useState<MarketplaceLocalInstalledEntry[]>([])
+	const [installedKeys, setInstalledKeys] = useState<Set<string>>(new Set())
+	const [installingId, setInstallingId] = useState<string | null>(null)
+	const [togglingLocalId, setTogglingLocalId] = useState<string | null>(null)
+	const [uninstallingId, setUninstallingId] = useState<string | null>(null)
+	const [query, setQuery] = useState("")
+	const [selectedTag, setSelectedTag] = useState<string | null>(null)
+	const [loading, setLoading] = useState(true)
+	const [error, setError] = useState<string | null>(null)
+
+	const refresh = useCallback(async () => {
+		setLoading(true)
+		setError(null)
+		try {
+			const [catalog, local] = await Promise.all([
+				MarketplaceServiceClient.getMarketplaceCatalog(EmptyRequest.create({})),
+				MarketplaceServiceClient.listMarketplaceLocalInstalledEntries(EmptyRequest.create({})),
+			])
+			const entries = catalog.entries.filter((entry) => isPrimitiveType(entry.type))
+			setCatalogEntries(entries)
+			setLocalEntries(local.entries.filter((entry) => isPrimitiveType(entry.type)))
+			const installed = await MarketplaceServiceClient.listMarketplaceInstalledEntries(
+				MarketplaceEntriesRequest.create({ entries }),
+			)
+			setInstalledKeys(new Set(installed.installedKeys))
+		} catch (err) {
+			setError(err instanceof Error ? err.message : String(err))
+		} finally {
+			setLoading(false)
+		}
+	}, [])
+
+	useEffect(() => {
+		refresh()
+	}, [refresh])
+
+	useEffect(() => {
+		setActiveType(initialType)
+		setQuery("")
+		setSelectedTag(null)
+		setActiveSection("installed")
+	}, [initialType])
+
+	const mcpMarketplaceDisabled = activeType === "mcp" && remoteConfigSettings?.mcpMarketplaceEnabled === false
+	const currentSection = mcpMarketplaceDisabled ? "installed" : activeSection
+
+	useEffect(() => {
+		if (mcpMarketplaceDisabled && activeSection === "marketplace") {
+			setActiveSection("installed")
+		}
+	}, [activeSection, mcpMarketplaceDisabled])
+
+	const primitive = getPrimitive(activeType)
+	const searchedCatalogEntries = useMemo(() => {
+		const normalizedQuery = query.trim().toLowerCase()
+		return catalogEntries.filter(
+			(entry) => entry.type === activeType && (!normalizedQuery || searchTextForEntry(entry).includes(normalizedQuery)),
+		)
+	}, [catalogEntries, activeType, query])
+	const marketplaceCatalogEntries = useMemo(
+		() => searchedCatalogEntries.filter((entry) => !installedKeys.has(entryKey(entry))),
+		[searchedCatalogEntries, installedKeys],
+	)
+	const tagFilters = useMemo(() => {
+		const labelsById = new Map<string, string>()
+		const counts = new Map<string, number>()
+		for (const entry of marketplaceCatalogEntries) {
+			for (const label of entryTagLabels(entry)) {
+				const id = tagId(label)
+				if (!id) continue
+				labelsById.set(id, label)
+				counts.set(id, (counts.get(id) ?? 0) + 1)
+			}
+		}
+		return {
+			counts,
+			tags: [...labelsById.entries()].map(([id, label]) => ({ id, label })).sort((a, b) => a.label.localeCompare(b.label)),
+		}
+	}, [marketplaceCatalogEntries])
+	useEffect(() => {
+		if (selectedTag && !tagFilters.counts.has(selectedTag)) {
+			setSelectedTag(null)
+		}
+	}, [selectedTag, tagFilters.counts])
+	const visibleCatalogEntries = useMemo(
+		() =>
+			selectedTag
+				? marketplaceCatalogEntries.filter((entry) => entryTagLabels(entry).some((label) => tagId(label) === selectedTag))
+				: marketplaceCatalogEntries,
+		[marketplaceCatalogEntries, selectedTag],
+	)
+	const activeLocalEntries = useMemo(
+		() => localEntries.filter((entry) => entry.type === activeType),
+		[localEntries, activeType],
+	)
+	const activeCatalogEntries = useMemo(
+		() => catalogEntries.filter((entry) => entry.type === activeType),
+		[catalogEntries, activeType],
+	)
+	const installedCatalogEntries = useMemo(
+		() => activeCatalogEntries.filter((entry) => installedKeys.has(entryKey(entry))),
+		[activeCatalogEntries, installedKeys],
+	)
+	const matchedLocalEntriesByCatalogKey = useMemo(() => {
+		const matched = new Map<string, MarketplaceLocalInstalledEntry[]>()
+		for (const entry of installedCatalogEntries) {
+			const matches = activeLocalEntries.filter((localEntry) => entryMatchesLocalEntry(entry, localEntry))
+			if (matches.length > 0) matched.set(entryKey(entry), matches)
+		}
+		return matched
+	}, [activeLocalEntries, installedCatalogEntries])
+	const matchedLocalEntryKeys = useMemo(() => {
+		const keys = new Set<string>()
+		for (const entries of matchedLocalEntriesByCatalogKey.values()) {
+			for (const entry of entries) {
+				keys.add(localEntryKey(entry))
+			}
+		}
+		return keys
+	}, [matchedLocalEntriesByCatalogKey])
+	const localOnlyInstalledEntries = useMemo(
+		() => activeLocalEntries.filter((entry) => !matchedLocalEntryKeys.has(localEntryKey(entry))),
+		[activeLocalEntries, matchedLocalEntryKeys],
+	)
+	const marketplaceMcpMetadataByServerName = useMemo(() => {
+		const metadata = new Map<string, MarketplaceMcpMetadata>()
+		for (const entry of installedCatalogEntries) {
+			if (entry.type !== "mcp") continue
+			const matchedLocalEntries = matchedLocalEntriesByCatalogKey.get(entryKey(entry)) ?? []
+			for (const localEntry of matchedLocalEntries) {
+				const serverName = localEntry.name || localEntry.id
+				if (!serverName) continue
+				metadata.set(serverName, {
+					name: entry.name || entry.id,
+					description: entry.description || entry.tagline || undefined,
+				})
+			}
+		}
+		return metadata
+	}, [installedCatalogEntries, matchedLocalEntriesByCatalogKey])
+	const handleInstall = useCallback(
+		async (entry: MarketplaceEntry) => {
+			setInstallingId(entryKey(entry))
+			setError(null)
+			try {
+				await MarketplaceServiceClient.installMarketplaceEntry(MarketplaceEntryRequest.create({ entry }))
+				await refresh()
+				setActiveSection("installed")
+			} catch (err) {
+				setError(err instanceof Error ? err.message : String(err))
+			} finally {
+				setInstallingId(null)
+			}
+		},
+		[refresh],
+	)
+
+	const handleUninstallMarketplace = useCallback(
+		async (entry: MarketplaceEntry) => {
+			setUninstallingId(entryKey(entry))
+			setError(null)
+			try {
+				await MarketplaceServiceClient.uninstallMarketplaceEntry(MarketplaceEntryRequest.create({ entry }))
+				await refresh()
+			} catch (err) {
+				setError(err instanceof Error ? err.message : String(err))
+			} finally {
+				setUninstallingId(null)
+			}
+		},
+		[refresh],
+	)
+
+	const handleUninstallLocal = useCallback(
+		async (entry: MarketplaceLocalInstalledEntry) => {
+			setUninstallingId(localEntryKey(entry))
+			setError(null)
+			try {
+				await MarketplaceServiceClient.uninstallMarketplaceLocalInstalledEntry(
+					MarketplaceLocalInstalledEntryRequest.create({ entry }),
+				)
+				await refresh()
+			} catch (err) {
+				setError(err instanceof Error ? err.message : String(err))
+			} finally {
+				setUninstallingId(null)
+			}
+		},
+		[refresh],
+	)
+
+	const handleToggleLocal = useCallback(async (entry: MarketplaceLocalInstalledEntry, enabled: boolean) => {
+		const key = localEntryKey(entry)
+		setTogglingLocalId(key)
+		setError(null)
+		try {
+			const response = await MarketplaceServiceClient.toggleMarketplaceLocalInstalledEntry(
+				ToggleMarketplaceLocalInstalledEntryRequest.create({ entry, enabled }),
+			)
+			setLocalEntries(response.entries.filter((item) => isPrimitiveType(item.type)))
+		} catch (err) {
+			setError(err instanceof Error ? err.message : String(err))
+		} finally {
+			setTogglingLocalId(null)
+		}
+	}, [])
+
+	const handleTabChange = useCallback((value: string) => {
+		setActiveType(value as PrimitiveType)
+		setQuery("")
+		setSelectedTag(null)
+		setActiveSection("installed")
+	}, [])
+
+	const handleSectionTabChange = useCallback(
+		(value: string) => {
+			if (mcpMarketplaceDisabled && value === "marketplace") return
+			setActiveSection(value as MarketplaceSectionType)
+		},
+		[mcpMarketplaceDisabled],
+	)
+
+	return (
+		<Tab className="marketplace-view">
+			<MarketplaceStyles />
+			<ViewHeader environment={environment} onDone={onDone} title="Customize" />
+
+			<div className="marketplace-shell">
+				<TabList className="marketplace-nav" onValueChange={handleTabChange} value={activeType}>
+					{PRIMITIVES.map((item) => (
+						<TabTrigger className="marketplace-tab" key={item.type} value={item.type}>
+							<item.icon aria-hidden className="h-4 w-4 shrink-0" />
+							<span className="marketplace-tab-label">{item.label}</span>
+						</TabTrigger>
+					))}
+				</TabList>
+
+				<TabContent className="marketplace-content">
+					<div className="marketplace-inner">
+						<TabList
+							aria-label={`${primitive.title} sections`}
+							className="marketplace-subnav"
+							onValueChange={handleSectionTabChange}
+							value={currentSection}>
+							{MARKETPLACE_SECTIONS.map((section) => (
+								<TabTrigger
+									className="marketplace-subtab"
+									disabled={mcpMarketplaceDisabled && section.type === "marketplace"}
+									key={section.type}
+									value={section.type}>
+									{section.label}
+								</TabTrigger>
+							))}
+						</TabList>
+
+						<div className="marketplace-primitive-description">{primitive.description}</div>
+						{error && <div className="marketplace-error">{error}</div>}
+
+						{loading ? (
+							<div className="marketplace-loading">
+								<VSCodeProgressRing />
+								<span>Loading {primitive.plural}</span>
+							</div>
+						) : (
+							<>
+								{currentSection === "installed" &&
+									(activeType === "mcp" ? (
+										<McpManagementPanel
+											marketplaceMetadataByServerName={marketplaceMcpMetadataByServerName}
+											showHeader={false}
+											showServerList={true}
+										/>
+									) : (
+										<Section
+											count={installedCatalogEntries.length + localOnlyInstalledEntries.length}
+											empty={`No installed ${primitive.plural}.`}
+											showHeader={false}
+											title={`Installed ${primitive.title}`}>
+											{installedCatalogEntries.map((entry) => (
+												<InstalledMarketplaceRow
+													entry={entry}
+													key={entryKey(entry)}
+													matchedLocalEntries={
+														matchedLocalEntriesByCatalogKey.get(entryKey(entry)) ?? []
+													}
+													onToggle={handleToggleLocal}
+													onUninstall={handleUninstallMarketplace}
+													togglingLocalId={togglingLocalId}
+													uninstalling={uninstallingId === entryKey(entry)}
+												/>
+											))}
+											{localOnlyInstalledEntries.map((entry) => (
+												<LocalInstalledRow
+													entry={entry}
+													key={localEntryKey(entry)}
+													onToggle={handleToggleLocal}
+													onUninstall={handleUninstallLocal}
+													toggling={togglingLocalId === localEntryKey(entry)}
+													uninstalling={uninstallingId === localEntryKey(entry)}
+												/>
+											))}
+										</Section>
+									))}
+
+								{currentSection === "marketplace" && (
+									<MarketplaceCatalogSection
+										count={visibleCatalogEntries.length}
+										empty={
+											query || selectedTag
+												? `No ${primitive.plural} match your search.`
+												: `No marketplace ${primitive.plural}.`
+										}
+										filters={
+											<TagFilters
+												counts={tagFilters.counts}
+												onSelect={setSelectedTag}
+												selectedTag={selectedTag}
+												tags={tagFilters.tags}
+											/>
+										}
+										search={
+											<div className="marketplace-search">
+												<VSCodeTextField
+													aria-label={`Search ${primitive.title}`}
+													onInput={(event) => setQuery((event.target as HTMLInputElement).value)}
+													placeholder={`Search ${primitive.plural}`}
+													value={query}>
+													<span className="codicon codicon-search" slot="start" />
+													{query && (
+														<button
+															aria-label="Clear search"
+															className="codicon codicon-close marketplace-clear-search"
+															onClick={() => setQuery("")}
+															slot="end"
+															type="button"
+														/>
+													)}
+												</VSCodeTextField>
+											</div>
+										}
+										showHeader={false}>
+										{visibleCatalogEntries.map((entry) => (
+											<CatalogEntryRow
+												entry={entry}
+												installing={installingId === entryKey(entry)}
+												key={entryKey(entry)}
+												onInstall={handleInstall}
+											/>
+										))}
+									</MarketplaceCatalogSection>
+								)}
+							</>
+						)}
+					</div>
+				</TabContent>
+			</div>
+		</Tab>
+	)
+}
+
+export default MarketplaceView
diff --git a/apps/vscode/webview-ui/src/components/marketplace/marketplaceMatch.test.ts b/apps/vscode/webview-ui/src/components/marketplace/marketplaceMatch.test.ts
new file mode 100644
index 0000000..7abf7b4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/marketplace/marketplaceMatch.test.ts
@@ -0,0 +1,53 @@
+import type { MarketplaceEntry, MarketplaceLocalInstalledEntry } from "@shared/proto/cline/marketplace"
+import { describe, expect, it } from "vitest"
+import { entryMatchesLocalEntry } from "./marketplaceMatch"
+
+function skillEntry(input: Partial<MarketplaceEntry>): MarketplaceEntry {
+	return {
+		id: input.id ?? "",
+		type: "skill",
+		name: input.name ?? "",
+		install: input.install ?? { args: [] },
+	} as MarketplaceEntry
+}
+
+function localSkill(input: Partial<MarketplaceLocalInstalledEntry>): MarketplaceLocalInstalledEntry {
+	return {
+		id: input.id ?? "",
+		type: "skill",
+		name: input.name ?? "",
+		path: input.path ?? "",
+		enabled: true,
+	} as MarketplaceLocalInstalledEntry
+}
+
+describe("marketplace installed row matching", () => {
+	it("does not match unrelated installed skills through shared path segments", () => {
+		const reviewTeam = skillEntry({
+			id: "review-team",
+			name: "Review Team",
+			install: { args: ["owner/repo", "--skill", "review-team"] },
+		})
+		const installed = [
+			localSkill({
+				id: "review-team",
+				name: "review-team",
+				path: "/home/tester/.agents/skills/review-team/SKILL.md",
+			}),
+			localSkill({
+				id: "sentry-cli",
+				name: "sentry-cli",
+				path: "/home/tester/.agents/skills/sentry-cli/SKILL.md",
+			}),
+			localSkill({
+				id: "cline-sdk",
+				name: "cline-sdk",
+				path: "/home/tester/.agents/skills/cline-sdk/SKILL.md",
+			}),
+		]
+
+		expect(installed.filter((localEntry) => entryMatchesLocalEntry(reviewTeam, localEntry)).map((entry) => entry.id)).toEqual(
+			["review-team"],
+		)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/marketplace/marketplaceMatch.ts b/apps/vscode/webview-ui/src/components/marketplace/marketplaceMatch.ts
new file mode 100644
index 0000000..98b0ff1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/marketplace/marketplaceMatch.ts
@@ -0,0 +1,105 @@
+import type { MarketplaceEntry, MarketplaceLocalInstalledEntry } from "@shared/proto/cline/marketplace"
+
+function installArgs(entry: MarketplaceEntry): string[] {
+	return entry.install?.args ?? []
+}
+
+export function localEntryKey(entry: MarketplaceLocalInstalledEntry): string {
+	return `${entry.type}:${entry.id}:${entry.path}`
+}
+
+function normalizeMatchValue(value: string | undefined): string {
+	return (value ?? "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+}
+
+function pathBaseName(value: string | undefined): string | undefined {
+	const segments = (value ?? "").split(/[\\/]/).filter(Boolean)
+	const last = segments.at(-1)
+	if (!last) return undefined
+	if (last.toLowerCase() === "skill.md" && segments.length > 1) {
+		return segments.at(-2)
+	}
+	return last.replace(/\.[^.]+$/, "")
+}
+
+function sourceBaseName(value: string | undefined): string | undefined {
+	const withoutFragment = value?.split("#")[0]?.split("?")[0]
+	return pathBaseName(withoutFragment)
+}
+
+function stripPluginInstallSuffix(value: string | undefined): string | undefined {
+	return value?.replace(/-[0-9a-f]{12}$/i, "")
+}
+
+function addMatchValue(values: Set<string>, value: string | undefined): void {
+	const normalized = normalizeMatchValue(value)
+	if (normalized && normalized !== "skill") {
+		values.add(normalized)
+	}
+}
+
+function entrySkillMatchValues(entry: MarketplaceEntry): Set<string> {
+	const values = new Set<string>()
+	addMatchValue(values, entry.id)
+	addMatchValue(values, entry.name)
+	const args = installArgs(entry)
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index]
+		if ((arg === "--skill" || arg === "-s") && args[index + 1]) {
+			addMatchValue(values, args[index + 1])
+			index++
+			continue
+		}
+		const skillFilter = arg.split("@").at(1)
+		if (skillFilter) {
+			addMatchValue(values, skillFilter)
+			continue
+		}
+		if (arg.includes("/") || arg.includes("\\")) {
+			addMatchValue(values, sourceBaseName(arg))
+		}
+	}
+	return values
+}
+
+function entryMatchValues(entry: MarketplaceEntry): Set<string> {
+	if (entry.type === "skill") return entrySkillMatchValues(entry)
+
+	const values = new Set<string>()
+	addMatchValue(values, entry.id)
+	addMatchValue(values, entry.name)
+
+	const [source] = installArgs(entry)
+	if (entry.type === "plugin") {
+		addMatchValue(values, source)
+		addMatchValue(values, stripPluginInstallSuffix(sourceBaseName(source)))
+	} else if (entry.type === "mcp") {
+		addMatchValue(values, source)
+	}
+	return values
+}
+
+function localEntryMatchValues(entry: MarketplaceLocalInstalledEntry): Set<string> {
+	const values = new Set<string>()
+	addMatchValue(values, entry.id)
+	addMatchValue(values, entry.name)
+
+	if (entry.type === "skill") {
+		addMatchValue(values, pathBaseName(entry.path))
+	} else if (entry.type === "plugin") {
+		addMatchValue(values, stripPluginInstallSuffix(pathBaseName(entry.path)))
+	}
+	return values
+}
+
+export function entryMatchesLocalEntry(entry: MarketplaceEntry, localEntry: MarketplaceLocalInstalledEntry): boolean {
+	if (entry.type !== localEntry.type) return false
+	const marketplaceValues = entryMatchValues(entry)
+	for (const localValue of localEntryMatchValues(localEntry)) {
+		if (marketplaceValues.has(localValue)) return true
+	}
+	return false
+}
diff --git a/apps/vscode/webview-ui/src/components/mcp/RICH_MCP_TESTING.md b/apps/vscode/webview-ui/src/components/mcp/RICH_MCP_TESTING.md
new file mode 100644
index 0000000..2b2799c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/RICH_MCP_TESTING.md
@@ -0,0 +1,683 @@
+# How To Test Rich MCP Responses
+
+Use the `echo` MCP server to read back one of the test cases below into an MCP response.
+https://github.com/Garoth/echo-mcp
+
+Manually check the embeds, images, and whatever other enhancements for proper rendering.
+Remember that toggling Rich MCP off should cancel pending fetches. If the toggle was
+set to Plain, then the image/link previews should never be fetched until it's enabled.
+Remember that rich display mode will only load the first n URLs, currently set to 50
+
+## Main Test Case
+
+Working Image URLs
+
+jpg: https://yavuzceliker.github.io/sample-images/image-205.jpg
+webp: https://seenandheard.app/assets/img/face-2.webp
+svg: https://seenandheard.app/assets/img/logo-white.svg
+
+Looks like Image URL but is website
+
+site: https://github.com/google/pprof/blob/main/doc/images/webui/flame-multi.png
+raw png: https://raw.githubusercontent.com/google/pprof/refs/heads/main/doc/images/webui/flame-multi.png
+
+Gif:
+
+https://upload.wikimedia.org/wikipedia/commons/thumb/d/d0/01_Das_Sandberg-Modell.gif/750px-01_Das_Sandberg-Modell.gif
+
+Normal Working URLs for OG Embeds
+
+https://www.google.com
+https://www.blogger.com
+https://youtube.com
+https://linkedin.com
+https://support.google.com
+https://cloudflare.com
+https://microsoft.com
+https://apple.com
+https://en.wikipedia.org
+https://play.google.com
+https://wordpress.org
+
+Attack URLs & Unsupported Formats
+
+data:text/html,<h1>Hello World</h1>
+data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==
+javascript:alert('XSS')
+mailto:user@example.com
+tel:+1-234-567-8901
+sms:+1-234-567-8901?body=Hello
+https://www.example.com/path/to/file.html?param=<script>alert('XSS')</script>
+https://www.example.com/path/to/file.html?param=<img src="x" onerror="alert('XSS')">
+https://www.example.com/path/to/file.html?param=javascript:alert('XSS')
+https://www.example.com/path/to/file.html?param=data:text/html,<script>alert('XSS')</script>
+https://www.example.com/path/to/file.html?param=data:image/svg+xml,<svg onload="alert('XSS')">
+https://www.example.com/path/to/file.html?param=<iframe src="javascript:alert('XSS')">
+https://www.example.com/path/to/file.html?param=<a href="javascript:alert('XSS')">Click me</a>
+
+Broken & Weird Edge Cases
+
+https://tectum.io/blog/dex-tools/
+http://0.0.0.0:8025/img.png
+https://localhost:8080/img.jpg
+http://localhost:8080/
+https://localhost/
+http://httpbin.org/#/ 
+https://snthonstcrgrfonhenth.com/nthshtf
+http://domain/.well-known/acme-challenge/token
+https://<strong>dextools</strong>.apiable.io/(Only
+
+## Generated Links Test Case
+
+1. https://www.google.com
+2. http://example.com/path/to/resource?query=value#fragment
+3. https://images.unsplash.com/photo-1575936123452-b67c3203c357
+4. file:///home/user/document.txt
+5. https://user:password@example.com:8080/path
+6. http://192.168.1.1:8080
+7. https://www.example.com/path with spaces/file.html
+8. ftp://ftp.example.com/pub/file.zip
+9. https://www.example.com/index.php?id=1&name=test
+10. https://subdomain.example.co.uk/path
+11. https://www.example.com/path/to/image.jpg
+12. https://www.example.com:8443/secure
+13. http://localhost:3000
+14. https://www.example.com/path/to/file.pdf#page=10
+15. https://www.example.com/search?q=query+with+spaces
+16. https://www.example.com/path/to/file.html#section-2
+17. https://www.example.com/path/to/file.php?id=123&action=view
+18. https://www.example.com/path/to/file.html?param1=value1&param2=value2#fragment
+19. https://www.example.com/path/to/file.html?param=value with spaces
+20. https://www.example.com/path/to/file.html?param=value%20with%20encoded%20spaces
+21. https://www.example.com/path/to/file.html?param=value+with+plus+signs
+22. https://www.example.com/path/to/file.html?param=special@characters!
+23. https://www.example.com/path/to/file.html?param=special%40characters%21
+24. https://www.example.com/path/to/file.html?param=value&param=duplicate
+25. https://www.example.com/path/to/file.html?param=
+26. https://www.example.com/path/to/file.html?=value
+27. https://www.example.com/path/to/file.html?
+28. https://www.example.com/path/to/file.html#
+29. https://www.example.com/path/to/file.html#fragment1#fragment2
+30. https://www.example.com/path/to/file.html?param1=value1#fragment?param2=value2
+31. https://www.example.com/index.html#!hashbang
+32. https://www.example.com/path/to/file.html?param=value#fragment=value
+33. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment
+34. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment=value
+35. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment?param3=value3
+36. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment&param3=value3
+37. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment#fragment2
+38. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment/path
+39. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment?param3=value3&param4=value4
+40. https://www.example.com/path/to/file.html?param=value&param2=value2#fragment&param3=value3&param4=value4
+41. data:text/html,<h1>Hello World</h1>
+42. data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==
+43. javascript:alert('XSS')
+44. mailto:user@example.com
+45. tel:+1-234-567-8901
+46. sms:+1-234-567-8901?body=Hello
+47. https://www.example.com/path/to/file.html?param=<script>alert('XSS')</script>
+48. https://www.example.com/path/to/file.html?param=<img src="x" onerror="alert('XSS')">
+49. https://www.example.com/path/to/file.html?param=javascript:alert('XSS')
+50. https://www.example.com/path/to/file.html?param=data:text/html,<script>alert('XSS')</script>
+51. https://www.example.com/path/to/file.html?param=data:image/svg+xml,<svg onload="alert('XSS')">
+52. https://www.example.com/path/to/file.html?param=<iframe src="javascript:alert('XSS')">
+53. https://www.example.com/path/to/file.html?param=<a href="javascript:alert('XSS')">Click me</a>
+54. https://www.example.com/path/to/file.html?param=<img src="x" onerror="alert('XSS')">
+55. https://www.example.com/path/to/file.html?param=<svg><script>alert('XSS')</script></svg>
+56. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+57. https://www.example.com/path/to/file.html?param=<img src="x" onerror="alert('XSS')">
+58. https://www.example.com/path/to/file.html?param=<body onload="alert('XSS')">
+59. https://www.example.com/path/to/file.html?param=<input autofocus onfocus="alert('XSS')">
+60. https://www.example.com/path/to/file.html?param=<video src="x" onerror="alert('XSS')">
+61. https://www.example.com/path/to/file.html?param=<audio src="x" onerror="alert('XSS')">
+62. https://www.example.com/path/to/file.html?param=<iframe srcdoc="<script>alert('XSS')</script>">
+63. https://www.example.com/path/to/file.html?param=<math><maction actiontype="statusline#" xlink:href="javascript:alert('XSS')">Click
+64. https://www.example.com/path/to/file.html?param=<form action="javascript:alert('XSS')"><input type="submit">
+65. https://www.example.com/path/to/file.html?param=<isindex action="javascript:alert('XSS')" type="image">
+66. https://www.example.com/path/to/file.html?param=<object data="javascript:alert('XSS')">
+67. https://www.example.com/path/to/file.html?param=<embed src="javascript:alert('XSS')">
+68. https://www.example.com/path/to/file.html?param=<svg><script>alert('XSS')</script>
+69. https://www.example.com/path/to/file.html?param=<marquee onstart="alert('XSS')">
+70. https://www.example.com/path/to/file.html?param=<div style="background-image: url(javascript:alert('XSS'))">
+71. https://www.example.com/path/to/file.html?param=<link rel="stylesheet" href="javascript:alert('XSS')">
+72. https://www.example.com/path/to/file.html?param=<table background="javascript:alert('XSS')">
+73. https://www.example.com/path/to/file.html?param=<div style="width: expression(alert('XSS'))">
+74. https://www.example.com/path/to/file.html?param=<style>@import "javascript:alert('XSS')";</style>
+75. https://www.example.com/path/to/file.html?param=<meta http-equiv="refresh" content="0;url=javascript:alert('XSS')">
+76. https://www.example.com/path/to/file.html?param=<iframe src="data:text/html,<script>alert('XSS')</script>">
+77. https://www.example.com/path/to/file.html?param=<svg><set attributeName="onload" to="alert('XSS')" />
+78. https://www.example.com/path/to/file.html?param=<script>alert('XSS')</script>
+79. https://www.example.com/path/to/file.html?param=<img src="x" onerror="alert('XSS')">
+80. https://www.example.com/path/to/file.html?param=<svg><animate xlink:href="#xss" attributeName="href" values="javascript:alert('XSS')" />
+81. https://www.example.com/path/to/file.html?param=<svg><a><animate attributeName="href" values="javascript:alert('XSS')" />
+82. https://www.example.com/path/to/file.html?param=<svg><a xlink:href="javascript:alert('XSS')"><text x="20" y="20">XSS</text></a>
+83. https://www.example.com/path/to/file.html?param=<svg><a><animate attributeName="href" values="javascript:alert('XSS')" /><text x="20" y="20">XSS</text></a>
+84. https://www.example.com/path/to/file.html?param=<svg><discard onbegin="alert('XSS')" />
+85. https://www.example.com/path/to/file.html?param=<svg><script>alert('XSS')</script></svg>
+86. https://www.example.com/path/to/file.html?param=<svg><script>alert('XSS')</script>
+87. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+88. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+89. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+90. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+91. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+92. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+93. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+94. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+95. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+96. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+97. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+98. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+99. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+100. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+101. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+102. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+103. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+104. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+105. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+106. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+107. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+108. https://www.example.com/path/to/file.html?param=<svg><animate onbegin="alert('XSS')" attributeName="x" />
+
+
+## Popular URLs by Popularity Test Case
+
+1. https://www.google.com
+2. https://www.blogger.com
+3. https://youtube.com
+4. https://linkedin.com
+5. https://support.google.com
+6. https://cloudflare.com
+7. https://microsoft.com
+8. https://apple.com
+9. https://en.wikipedia.org
+10. https://play.google.com
+11. https://wordpress.org
+12. https://docs.google.com
+13. https://mozilla.org
+14. https://maps.google.com
+15. https://youtu.be
+16. https://drive.google.com
+17. https://bp.blogspot.com
+18. https://sites.google.com
+19. https://googleusercontent.com
+20. https://accounts.google.com
+21. https://t.me
+22. https://europa.eu
+23. https://plus.google.com
+24. https://whatsapp.com
+25. https://adobe.com
+26. https://facebook.com
+27. https://policies.google.com
+28. https://uol.com.br
+29. https://istockphoto.com
+30. https://vimeo.com
+31. https://vk.com
+32. https://github.com
+33. https://amazon.com
+34. https://search.google.com
+35. https://bbc.co.uk
+36. https://google.de
+37. https://live.com
+38. https://gravatar.com
+39. https://nih.gov
+40. https://dan.com
+41. https://files.wordpress.com
+42. https://www.yahoo.com
+43. https://cnn.com
+44. https://dropbox.com
+45. https://wikimedia.org
+46. https://creativecommons.org
+47. https://google.com.br
+48. https://line.me
+49. https://googleblog.com
+50. https://opera.com
+51. https://es.wikipedia.org
+52. https://globo.com
+53. https://brandbucket.com
+54. https://myspace.com
+55. https://slideshare.net
+56. https://paypal.com
+57. https://tiktok.com
+58. https://netvibes.com
+59. https://theguardian.com
+60. https://who.int
+61. https://goo.gl
+62. https://medium.com
+63. https://tools.google.com
+64. https://draft.blogger.com
+65. https://pt.wikipedia.org
+66. https://fr.wikipedia.org
+67. https://www.weebly.com
+68. https://news.google.com
+69. https://developers.google.com
+70. https://w3.org
+71. https://mail.google.com
+72. https://gstatic.com
+73. https://jimdofree.com
+74. https://cpanel.net
+75. https://imdb.com
+76. https://wa.me
+77. https://feedburner.com
+78. https://enable-javascript.com
+79. https://nytimes.com
+80. https://workspace.google.com
+81. https://ok.ru
+82. https://google.es
+83. https://dailymotion.com
+84. https://afternic.com
+85. https://bloomberg.com
+86. https://amazon.de
+87. https://photos.google.com
+88. https://wiley.com
+89. https://aliexpress.com
+90. https://indiatimes.com
+91. https://youronlinechoices.com
+92. https://elpais.com
+93. https://tinyurl.com
+94. https://yadi.sk
+95. https://spotify.com
+96. https://huffpost.com
+97. https://ru.wikipedia.org
+98. https://google.fr
+99. https://webmd.com
+100. https://samsung.com
+101. https://independent.co.uk
+102. https://amazon.co.jp
+103. https://get.google.com
+104. https://amazon.co.uk
+105. https://4shared.com
+106. https://telegram.me
+107. https://planalto.gov.br
+108. https://businessinsider.com
+109. https://ig.com.br
+110. https://issuu.com
+111. https://www.gov.br
+112. https://wsj.com
+113. https://hugedomains.com
+114. https://picasaweb.google.com
+115. https://usatoday.com
+116. https://scribd.com
+117. https://www.gov.uk
+118. https://storage.googleapis.com
+119. https://huffingtonpost.com
+120. https://bbc.com
+121. https://estadao.com.br
+122. https://nature.com
+123. https://mediafire.com
+124. https://washingtonpost.com
+125. https://forms.gle
+126. https://namecheap.com
+127. https://forbes.com
+128. https://mirror.co.uk
+129. https://soundcloud.com
+130. https://fb.com
+131. https://marketingplatform.google
+132. https://domainmarket.com
+133. https://ytimg.com
+134. https://terra.com.br
+135. https://google.co.uk
+136. https://shutterstock.com
+137. https://dailymail.co.uk
+138. https://reg.ru
+139. https://t.co
+140. https://cdc.gov
+141. https://thesun.co.uk
+142. https://wp.com
+143. https://cnet.com
+144. https://instagram.com
+145. https://researchgate.net
+146. https://google.it
+147. https://fandom.com
+148. https://office.com
+149. https://list-manage.com
+150. https://msn.com
+151. https://un.org
+152. https://de.wikipedia.org
+153. https://ovh.com
+154. https://mail.ru
+155. https://bing.com
+156. https://news.yahoo.com
+157. https://myaccount.google.com
+158. https://hatena.ne.jp
+159. https://shopify.com
+160. https://adssettings.google.com
+161. https://bit.ly
+162. https://reuters.com
+163. https://booking.com
+164. https://discord.com
+165. https://buydomains.com
+166. https://nasa.gov
+167. https://aboutads.info
+168. https://time.com
+169. https://abril.com.br
+170. https://change.org
+171. https://nginx.org
+172. https://twitter.com
+173. https://www.wikipedia.org
+174. https://archive.org
+175. https://cbsnews.com
+176. https://networkadvertising.org
+177. https://telegraph.co.uk
+178. https://pinterest.com
+179. https://google.co.jp
+180. https://pixabay.com
+181. https://zendesk.com
+182. https://cpanel.com
+183. https://vistaprint.com
+184. https://sky.com
+185. https://windows.net
+186. https://alicdn.com
+187. https://google.ca
+188. https://lemonde.fr
+189. https://newyorker.com
+190. https://webnode.page
+191. https://surveymonkey.com
+192. https://translate.google.com
+193. https://calendar.google.com
+194. https://amazonaws.com
+195. https://academia.edu
+196. https://apache.org
+197. https://imageshack.us
+198. https://akamaihd.net
+199. https://nginx.com
+200. https://discord.gg
+201. https://thetimes.co.uk
+202. https://search.yahoo.com
+203. https://amazon.fr
+204. https://yelp.com
+205. https://berkeley.edu
+206. https://google.ru
+207. https://sedoparking.com
+208. https://cbc.ca
+209. https://unesco.org
+210. https://ggpht.com
+211. https://privacyshield.gov
+212. https://www.over-blog.com
+213. https://clarin.com
+214. https://www.wix.com
+215. https://whitehouse.gov
+216. https://icann.org
+217. https://gnu.org
+218. https://yandex.ru
+219. https://francetvinfo.fr
+220. https://gmail.com
+221. https://mozilla.com
+222. https://ziddu.com
+223. https://guardian.co.uk
+224. https://twitch.tv
+225. https://sedo.com
+226. https://foxnews.com
+227. https://rambler.ru
+228. https://books.google.com
+229. https://stanford.edu
+230. https://wikihow.com
+231. https://it.wikipedia.org
+232. https://20minutos.es
+233. https://sfgate.com
+234. https://liveinternet.ru
+235. https://ja.wikipedia.org
+236. https://000webhost.com
+237. https://espn.com
+238. https://eventbrite.com
+239. https://disney.com
+240. https://statista.com
+241. https://addthis.com
+242. https://pinterest.fr
+243. https://lavanguardia.com
+244. https://vkontakte.ru
+245. https://doubleclick.net
+246. https://bp2.blogger.com
+247. https://skype.com
+248. https://sciencedaily.com
+249. https://bloglovin.com
+250. https://insider.com
+251. https://pl.wikipedia.org
+252. https://sputniknews.com
+253. https://id.wikipedia.org
+254. https://doi.org
+255. https://nypost.com
+256. https://elmundo.es
+257. https://abcnews.go.com
+258. https://ipv4.google.com
+259. https://deezer.com
+260. https://express.co.uk
+261. https://detik.com
+262. https://mystrikingly.com
+263. https://rakuten.co.jp
+264. https://amzn.to
+265. https://arxiv.org
+266. https://alibaba.com
+267. https://fb.me
+268. https://wikia.com
+269. https://t-online.de
+270. https://telegra.ph
+271. https://mega.nz
+272. https://usnews.com
+273. https://plos.org
+274. https://naver.com
+275. https://ibm.com
+276. https://smh.com.au
+277. https://dw.com
+278. https://google.nl
+279. https://lefigaro.fr
+280. https://bp1.blogger.com
+281. https://picasa.google.com
+282. https://theatlantic.com
+283. https://nydailynews.com
+284. https://themeforest.net
+285. https://rtve.es
+286. https://newsweek.com
+287. https://ovh.net
+288. https://ca.gov
+289. https://goodreads.com
+290. https://economist.com
+291. https://target.com
+292. https://marca.com
+293. https://kickstarter.com
+294. https://hindustantimes.com
+295. https://weibo.com
+296. https://finance.yahoo.com
+297. https://huawei.com
+298. https://e-monsite.com
+299. https://hubspot.com
+300. https://npr.org
+301. https://netflix.com
+302. https://gizmodo.com
+303. https://netlify.app
+304. https://yandex.com
+305. https://mashable.com
+306. https://cnil.fr
+307. https://latimes.com
+308. https://steampowered.com
+309. https://rt.com
+310. https://photobucket.com
+311. https://quora.com
+312. https://nbcnews.com
+313. https://android.com
+314. https://instructables.com
+315. https://www.canalblog.com
+316. https://www.livejournal.com
+317. https://ouest-france.fr
+318. https://tripadvisor.com
+319. https://ovhcloud.com
+320. https://pexels.com
+321. https://oracle.com
+322. https://yahoo.co.jp
+323. https://addtoany.com
+324. https://sakura.ne.jp
+325. https://cointernet.com.co
+326. https://twimg.com
+327. https://britannica.com
+328. https://php.net
+329. https://standard.co.uk
+330. https://groups.google.com
+331. https://cnbc.com
+332. https://loc.gov
+333. https://qq.com
+334. https://buzzfeed.com
+335. https://godaddy.com
+336. https://ikea.com
+337. https://disqus.com
+338. https://taringa.net
+339. https://ea.com
+340. https://dropcatch.com
+341. https://techcrunch.com
+342. https://canva.com
+343. https://offset.com
+344. https://ebay.com
+345. https://zoom.us
+346. https://cambridge.org
+347. https://unsplash.com
+348. https://playstation.com
+349. https://people.com
+350. https://springer.com
+351. https://psychologytoday.com
+352. https://sendspace.com
+353. https://home.pl
+354. https://rapidshare.com
+355. https://prezi.com
+356. https://photos1.blogger.com
+357. https://thenai.org
+358. https://ftc.gov
+359. https://google.pl
+360. https://ted.com
+361. https://secureserver.net
+362. https://code.google.com
+363. https://plesk.com
+364. https://aol.com
+365. https://biglobe.ne.jp
+366. https://hp.com
+367. https://canada.ca
+368. https://linktr.ee
+369. https://hollywoodreporter.com
+370. https://ietf.org
+371. https://clickbank.net
+372. https://harvard.edu
+373. https://amazon.es
+374. https://oup.com
+375. https://timeweb.ru
+376. https://engadget.com
+377. https://vice.com
+378. https://cornell.edu
+379. https://dreamstime.com
+380. https://tmz.com
+381. https://gofundme.com
+382. https://pbs.org
+383. https://stackoverflow.com
+384. https://abc.net.au
+385. https://sciencedirect.com
+386. https://ft.com
+387. https://variety.com
+388. https://alexa.com
+389. https://abc.es
+390. https://walmart.com
+391. https://gooyaabitemplates.com
+392. https://redbull.com
+393. https://ssl-images-amazon.com
+394. https://theverge.com
+395. https://spiegel.de
+396. https://about.com
+397. https://nationalgeographic.com
+398. https://bandcamp.com
+399. https://m.wikipedia.org
+400. https://zippyshare.com
+401. https://wired.com
+402. https://freepik.com
+403. https://outlook.com
+404. https://mit.edu
+405. https://sapo.pt
+406. https://goo.ne.jp
+407. https://java.com
+408. https://google.co.th
+409. https://scmp.com
+410. https://mayoclinic.org
+411. https://scholastic.com
+412. https://nba.com
+413. https://reverbnation.com
+414. https://depositfiles.com
+415. https://video.google.com
+416. https://howstuffworks.com
+417. https://cbslocal.com
+418. https://merriam-webster.com
+419. https://focus.de
+420. https://admin.ch
+421. https://gfycat.com
+422. https://com.com
+423. https://narod.ru
+424. https://boston.com
+425. https://sony.com
+426. https://justjared.com
+427. https://bitly.com
+428. https://jstor.org
+429. https://amebaownd.com
+430. https://g.co
+431. https://gsmarena.com
+432. https://lexpress.fr
+433. https://reddit.com
+434. https://usgs.gov
+435. https://bigcommerce.com
+436. https://gettyimages.com
+437. https://ign.com
+438. https://justgiving.com
+439. https://techradar.com
+440. https://weather.com
+441. https://amazon.ca
+442. https://justice.gov
+443. https://sciencemag.org
+444. https://pcmag.com
+445. https://theconversation.com
+446. https://foursquare.com
+447. https://flickr.com
+448. https://giphy.com
+449. https://tvtropes.org
+450. https://fifa.com
+451. https://upenn.edu
+452. https://digg.com
+453. https://bestfreecams.club
+454. https://histats.com
+455. https://salesforce.com
+456. https://blog.google
+457. https://apnews.com
+458. https://theglobeandmail.com
+459. https://m.me
+460. https://europapress.es
+461. https://washington.edu
+462. https://thefreedictionary.com
+463. https://jhu.edu
+464. https://euronews.com
+465. https://liberation.fr
+466. https://ads.google.com
+467. https://trustpilot.com
+468. https://google.com.tw
+469. https://softonic.com
+470. https://kakao.com
+471. https://storage.canalblog.com
+472. https://interia.pl
+473. https://metro.co.uk
+474. https://viglink.com
+475. https://last.fm
+476. https://blackberry.com
+477. https://public-api.wordpress.com
+478. https://sina.com.cn
+479. https://unicef.org
+480. https://archives.gov
+481. https://nps.gov
+482. https://utexas.edu
+483. https://biblegateway.com
+484. https://usda.gov
+485. https://indiegogo.com
+486. https://nikkei.com
+487. https://radiofrance.fr
+488. https://repubblica.it
+489. https://substack.com
+490. https://ap.org
+491. https://nicovideo.jp
+492. https://joomla.org
+493. https://news.com.au
+494. https://allaboutcookies.org
+495. https://mailchimp.com
+496. https://stores.jp
+497. https://intel.com
+498. https://bp0.blogger.com
+499. https://box.com
+499. https://nhk.or.jp
diff --git a/apps/vscode/webview-ui/src/components/mcp/chat-display/ImagePreview.tsx b/apps/vscode/webview-ui/src/components/mcp/chat-display/ImagePreview.tsx
new file mode 100644
index 0000000..baabfae
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/chat-display/ImagePreview.tsx
@@ -0,0 +1,336 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import DOMPurify from "dompurify"
+import React from "react"
+import ChatErrorBoundary from "@/components/chat/ChatErrorBoundary"
+import { FileServiceClient, WebServiceClient } from "@/services/grpc-client"
+import { checkIfImageUrl, formatUrlForOpening, getSafeHostname } from "./utils/mcpRichUtil"
+
+interface ImagePreviewProps {
+	url: string
+}
+
+// Use a class component to ensure complete isolation between instances
+class ImagePreview extends React.Component<
+	ImagePreviewProps,
+	{
+		loading: boolean
+		error: string | null
+		fetchStartTime: number
+	}
+> {
+	private imgRef = React.createRef<HTMLImageElement>()
+	private timeoutId: NodeJS.Timeout | null = null
+	private heartbeatId: NodeJS.Timeout | null = null
+
+	constructor(props: ImagePreviewProps) {
+		super(props)
+		this.state = {
+			loading: true,
+			error: null,
+			fetchStartTime: Date.now(),
+		}
+	}
+
+	// Track aspect ratio for proper display
+	private aspectRatio: number = 1
+
+	componentDidMount() {
+		// Set up a timeout to handle cases where the image never loads or errors
+		this.timeoutId = setTimeout(() => {
+			console.log(`Image load timeout for ${this.props.url}`)
+			if (this.state.loading) {
+				this.setState({
+					loading: false,
+					error: `Timeout loading image: ${this.props.url}`,
+				})
+			}
+		}, 15000)
+
+		// Set up a heartbeat to update the UI with elapsed time
+		this.heartbeatId = setInterval(() => {
+			if (this.state.loading) {
+				this.forceUpdate() // Just update the component to show new elapsed time
+			}
+		}, 1000)
+
+		// First, check the content type to verify it's actually an image
+		this.checkContentType(this.props.url)
+	}
+
+	// Check if the URL is an image using content type verification
+	checkContentType(url: string) {
+		// Always verify content type, even for URLs that look like images by extension
+		checkIfImageUrl(url)
+			.then((isImage) => {
+				if (isImage) {
+					console.log(`URL is confirmed as image: ${url}`)
+					this.loadImage(url)
+				} else {
+					console.log(`URL is not an image: ${url}`)
+					this.handleImageError()
+				}
+			})
+			.catch((error) => {
+				console.log(`Error checking if URL is an image: ${error}`)
+				// Don't fallback to direct image loading on error
+				// Instead, report the error so the URL can be handled as a non-image
+				this.handleImageError()
+			})
+	}
+
+	// Load the image after content type check or as fallback
+	loadImage(url: string) {
+		const isSvg = /\.svg(\?.*)?$/i.test(url)
+
+		// For SVG files, we don't need to calculate aspect ratio as they're vector-based
+		if (isSvg) {
+			console.log(`SVG image detected, skipping aspect ratio calculation: ${url}`)
+			// Default aspect ratio for SVGs
+			this.aspectRatio = 1
+			this.handleImageLoad()
+			return
+		}
+
+		// Create a test image to check if the URL loads and get dimensions
+		const testImg = new Image()
+
+		testImg.onload = () => {
+			console.log(`Test image loaded successfully: ${url}`)
+
+			// Calculate aspect ratio for proper display
+			if (testImg.width > 0 && testImg.height > 0) {
+				this.aspectRatio = testImg.width / testImg.height
+			}
+
+			this.handleImageLoad()
+		}
+
+		testImg.onerror = () => {
+			console.log(`Test image failed to load: ${url}`)
+			this.handleImageError()
+		}
+
+		// Force CORS mode to be anonymous to avoid CORS issues
+		testImg.crossOrigin = "anonymous"
+	}
+
+	componentWillUnmount() {
+		this.cleanup()
+	}
+
+	private cleanup() {
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId)
+			this.timeoutId = null
+		}
+
+		if (this.heartbeatId) {
+			clearInterval(this.heartbeatId)
+			this.heartbeatId = null
+		}
+	}
+
+	// Handle image load event
+	handleImageLoad = () => {
+		console.log(`Image loaded successfully: ${this.props.url}`)
+		this.setState({ loading: false })
+		this.cleanup()
+	}
+
+	// Handle image error event
+	handleImageError = () => {
+		console.log(`Image failed to load: ${this.props.url}`)
+		this.setState({
+			loading: false,
+			error: `Failed to load image: ${this.props.url}`,
+		})
+		this.cleanup()
+	}
+
+	render() {
+		const { url } = this.props
+		const { loading, error, fetchStartTime } = this.state
+
+		// Calculate elapsed time for loading state
+		const elapsedSeconds = loading ? Math.floor((Date.now() - fetchStartTime) / 1000) : 0
+
+		// Fallback display while loading
+		if (loading) {
+			return (
+				<div
+					className="image-preview-loading"
+					style={{
+						padding: "12px",
+						display: "flex",
+						flexDirection: "column",
+						alignItems: "center",
+						justifyContent: "center",
+						border: "1px solid var(--vscode-editorWidget-border, rgba(127, 127, 127, 0.3))",
+						borderRadius: "4px",
+						height: "128px",
+						maxWidth: "512px",
+					}}>
+					<div style={{ display: "flex", alignItems: "center", marginBottom: "8px" }}>
+						<div
+							className="loading-spinner"
+							style={{
+								marginRight: "8px",
+								width: "16px",
+								height: "16px",
+								border: "2px solid rgba(127, 127, 127, 0.3)",
+								borderTopColor: "var(--vscode-textLink-foreground, #3794ff)",
+								borderRadius: "50%",
+								animation: "spin 1s linear infinite",
+							}}
+						/>
+						<style>
+							{`
+								@keyframes spin {
+									to { transform: rotate(360deg); }
+								}
+							`}
+						</style>
+						Loading image from {getSafeHostname(url)}...
+					</div>
+					{elapsedSeconds > 3 && (
+						<div style={{ fontSize: "11px", color: "var(--vscode-descriptionForeground)" }}>
+							{elapsedSeconds > 60
+								? `Waiting for ${Math.floor(elapsedSeconds / 60)}m ${elapsedSeconds % 60}s...`
+								: `Waiting for ${elapsedSeconds}s...`}
+						</div>
+					)}
+					{/* Hidden image that we'll use to detect load/error events */}
+					{/\.svg(\?.*)?$/i.test(url) ? (
+						<object
+							data={DOMPurify.sanitize(url)}
+							onError={this.handleImageError}
+							onLoad={this.handleImageLoad}
+							style={{ display: "none" }}
+							type="image/svg+xml"
+						/>
+					) : (
+						<img
+							alt=""
+							onError={this.handleImageError}
+							onLoad={this.handleImageLoad}
+							ref={this.imgRef}
+							src={DOMPurify.sanitize(url)}
+							style={{ display: "none" }}
+						/>
+					)}
+				</div>
+			)
+		}
+
+		// Handle error state
+		if (error) {
+			return (
+				<div
+					className="image-preview-error"
+					onClick={async () => {
+						try {
+							await WebServiceClient.openInBrowser(
+								StringRequest.create({
+									value: DOMPurify.sanitize(url),
+								}),
+							)
+						} catch (err) {
+							console.error("Error opening URL in browser:", err)
+						}
+					}}
+					style={{
+						padding: "12px",
+						border: "1px solid var(--vscode-editorWidget-border, rgba(127, 127, 127, 0.3))",
+						borderRadius: "4px",
+						color: "var(--vscode-errorForeground)",
+					}}>
+					<div style={{ fontWeight: "bold" }}>Failed to load image</div>
+					<div style={{ fontSize: "12px", marginTop: "4px" }}>{getSafeHostname(url)}</div>
+					<div style={{ fontSize: "11px", marginTop: "8px", color: "var(--vscode-textLink-foreground)" }}>
+						Click to open in browser
+					</div>
+				</div>
+			)
+		}
+
+		// Render the image
+		return (
+			<div
+				className="image-preview"
+				onClick={async () => {
+					try {
+						// For data URIs, open in VS Code editor (like mermaid diagrams)
+						if (url.startsWith("data:")) {
+							await FileServiceClient.openImage(StringRequest.create({ value: url }))
+						} else {
+							// For regular URLs, open in browser
+							await WebServiceClient.openInBrowser(
+								StringRequest.create({
+									value: DOMPurify.sanitize(formatUrlForOpening(url)),
+								}),
+							)
+						}
+					} catch (err) {
+						console.error("Error opening image:", err)
+					}
+				}}
+				style={{
+					margin: "10px 0",
+					maxWidth: "100%",
+					cursor: "pointer",
+				}}>
+				{/\.svg(\?.*)?$/i.test(url) ? (
+					// Special handling for SVG images
+					<object
+						aria-label={`SVG from ${getSafeHostname(url)}`}
+						data={DOMPurify.sanitize(url)}
+						style={{
+							width: "100%",
+							height: "auto",
+							borderRadius: "4px",
+						}}
+						type="image/svg+xml">
+						{/* Fallback if object tag fails */}
+						<img
+							alt={`SVG from ${getSafeHostname(url)}`}
+							src={DOMPurify.sanitize(url)}
+							style={{
+								width: "100%",
+								height: "auto",
+								borderRadius: "4px",
+							}}
+						/>
+					</object>
+				) : (
+					<img
+						alt={`Image from ${getSafeHostname(url)}`}
+						loading="eager"
+						src={DOMPurify.sanitize(url)}
+						style={{
+							width: "100%",
+							height: "auto",
+							borderRadius: "4px",
+						}}
+					/>
+				)}
+			</div>
+		)
+	}
+}
+
+// Create a wrapper component that memoizes the ImagePreview to prevent unnecessary re-renders
+const MemoizedImagePreview = React.memo(
+	(props: ImagePreviewProps) => <ImagePreview {...props} />,
+	(prevProps, nextProps) => prevProps.url === nextProps.url, // Only re-render if URL changes
+)
+
+// Wrap the ImagePreview component with an error boundary
+const ImagePreviewWithErrorBoundary: React.FC<ImagePreviewProps> = (props) => {
+	return (
+		<ChatErrorBoundary errorTitle="Something went wrong displaying this image">
+			<MemoizedImagePreview {...props} />
+		</ChatErrorBoundary>
+	)
+}
+
+export default ImagePreviewWithErrorBoundary
diff --git a/apps/vscode/webview-ui/src/components/mcp/chat-display/LinkPreview.tsx b/apps/vscode/webview-ui/src/components/mcp/chat-display/LinkPreview.tsx
new file mode 100644
index 0000000..b6ed060
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/chat-display/LinkPreview.tsx
@@ -0,0 +1,412 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import DOMPurify from "dompurify"
+import React from "react"
+import ChatErrorBoundary from "@/components/chat/ChatErrorBoundary"
+import { WebServiceClient } from "@/services/grpc-client"
+import { getSafeHostname, normalizeRelativeUrl } from "./utils/mcpRichUtil"
+
+interface OpenGraphData {
+	title?: string
+	description?: string
+	image?: string
+	url?: string
+	siteName?: string
+	type?: string
+}
+
+interface LinkPreviewProps {
+	url: string
+}
+
+interface LinkPreviewState {
+	loading: boolean
+	error: ErrorType
+	errorMessage: string | null
+	ogData: OpenGraphData | null
+	/**
+	 * Track if fetch has completed (success or error)
+	 */
+	hasCompletedFetch: boolean
+	/**
+	 * Track when the fetch started
+	 */
+	fetchStartTime: number
+}
+
+// Error types for better UI feedback
+type ErrorType = "timeout" | "network" | "general" | null
+
+// Use a class component to ensure complete isolation between instances
+class LinkPreview extends React.Component<LinkPreviewProps, LinkPreviewState> {
+	private messageListener: ((event: MessageEvent) => void) | null = null
+	private timeoutId: NodeJS.Timeout | null = null
+	private heartbeatId: NodeJS.Timeout | null = null
+
+	constructor(props: LinkPreviewProps) {
+		super(props)
+		this.state = {
+			loading: true,
+			error: null,
+			errorMessage: null,
+			ogData: null,
+			hasCompletedFetch: false,
+			fetchStartTime: 0,
+		}
+	}
+
+	componentDidMount() {
+		// Only fetch if we haven't completed a fetch yet
+		if (!this.state.hasCompletedFetch) {
+			this.fetchOpenGraphData()
+		}
+	}
+
+	componentWillUnmount() {
+		this.cleanup()
+	}
+
+	// Prevent updates if fetch has completed
+	shouldComponentUpdate(nextProps: LinkPreviewProps, nextState: LinkPreviewState) {
+		// If URL changes, allow update
+		if (nextProps.url !== this.props.url) {
+			return true
+		}
+
+		// If we've completed a fetch and state hasn't changed, prevent update
+		if (
+			this.state.hasCompletedFetch &&
+			this.state.loading === nextState.loading &&
+			this.state.error === nextState.error &&
+			this.state.ogData === nextState.ogData
+		) {
+			return false
+		}
+
+		return true
+	}
+
+	private cleanup() {
+		// Clean up event listeners and timeouts
+		if (this.messageListener) {
+			window.removeEventListener("message", this.messageListener)
+			this.messageListener = null
+		}
+
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId)
+			this.timeoutId = null
+		}
+
+		if (this.heartbeatId) {
+			clearInterval(this.heartbeatId)
+			this.heartbeatId = null
+		}
+	}
+
+	private async fetchOpenGraphData() {
+		try {
+			// Record fetch start time
+			const startTime = Date.now()
+			this.setState({ fetchStartTime: startTime })
+
+			// Use the gRPC client to fetch Open Graph data
+			const response = await WebServiceClient.fetchOpenGraphData(
+				StringRequest.create({
+					value: this.props.url,
+				}),
+			)
+
+			// Process the response
+			if (response) {
+				const ogData: OpenGraphData = {
+					title: response.title || undefined,
+					description: response.description || undefined,
+					image: response.image || undefined,
+					url: response.url || undefined,
+					siteName: response.siteName || undefined,
+					type: response.type || undefined,
+				}
+
+				this.setState({
+					ogData,
+					loading: false,
+					hasCompletedFetch: true,
+				})
+			} else {
+				this.setState({
+					error: "network",
+					errorMessage: "Failed to fetch Open Graph data",
+					loading: false,
+					hasCompletedFetch: true,
+				})
+			}
+
+			// Clean up the heartbeat interval
+			// (No message listener is needed with gRPC, unlike the previous message-based approach)
+			this.cleanup()
+
+			// Set up heartbeat for loading indicator
+			this.heartbeatId = setInterval(() => {
+				const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000)
+				if (elapsedSeconds > 0) {
+					this.forceUpdate() // Just update the component to show new elapsed time
+				}
+			}, 1000)
+		} catch (err) {
+			this.setState({
+				error: "general",
+				errorMessage: err instanceof Error ? err.message : "Unknown error occurred",
+				loading: false,
+				hasCompletedFetch: true, // Mark as completed on error
+			})
+			this.cleanup()
+		}
+	}
+
+	render() {
+		const { url } = this.props
+		const { loading, error, errorMessage, ogData, fetchStartTime } = this.state
+
+		// Calculate elapsed time for loading state
+		const elapsedSeconds = loading ? Math.floor((Date.now() - fetchStartTime) / 1000) : 0
+
+		// Fallback display while loading
+		if (loading) {
+			return (
+				<div
+					className="link-preview-loading"
+					style={{
+						display: "flex",
+						flexDirection: "column",
+						alignItems: "center",
+						justifyContent: "center",
+						border: "1px solid var(--vscode-editorWidget-border, rgba(127, 127, 127, 0.3))",
+						borderRadius: "4px",
+						height: "128px",
+						maxWidth: "512px",
+					}}>
+					<div style={{ display: "flex", alignItems: "center", marginBottom: "8px" }}>
+						<div
+							className="loading-spinner"
+							style={{
+								marginRight: "8px",
+								width: "16px",
+								height: "16px",
+								border: "2px solid rgba(127, 127, 127, 0.3)",
+								borderTopColor: "var(--vscode-textLink-foreground, #3794ff)",
+								borderRadius: "50%",
+								animation: "spin 1s linear infinite",
+							}}
+						/>
+						<style>
+							{`
+								@keyframes spin {
+									to { transform: rotate(360deg); }
+								}
+							`}
+						</style>
+						Loading preview for {getSafeHostname(url)}...
+					</div>
+					{elapsedSeconds > 5 && (
+						<div style={{ fontSize: "11px", color: "var(--vscode-descriptionForeground)" }}>
+							{elapsedSeconds > 60
+								? `Waiting for ${Math.floor(elapsedSeconds / 60)}m ${elapsedSeconds % 60}s...`
+								: `Waiting for ${elapsedSeconds}s...`}
+						</div>
+					)}
+				</div>
+			)
+		}
+
+		// Handle different error states with specific messages
+		if (error) {
+			let errorDisplay = "Unable to load preview"
+
+			if (error === "timeout") {
+				errorDisplay = "Preview request timed out"
+			} else if (error === "network") {
+				errorDisplay = "Network error loading preview"
+			}
+
+			return (
+				<div
+					className="link-preview-error"
+					onClick={async () => {
+						try {
+							await WebServiceClient.openInBrowser(
+								StringRequest.create({
+									value: DOMPurify.sanitize(url),
+								}),
+							)
+						} catch (err) {
+							console.error("Error opening URL in browser:", err)
+						}
+					}}
+					style={{
+						padding: "12px",
+						border: "1px solid var(--vscode-editorWidget-border, rgba(127, 127, 127, 0.3))",
+						borderRadius: "4px",
+						color: "var(--vscode-errorForeground)",
+						height: "128px",
+						maxWidth: "512px",
+						overflow: "auto",
+					}}>
+					<div style={{ fontWeight: "bold" }}>{errorDisplay}</div>
+					<div style={{ fontSize: "12px", marginTop: "4px" }}>{getSafeHostname(url)}</div>
+					{errorMessage && <div style={{ fontSize: "11px", marginTop: "4px", opacity: 0.8 }}>{errorMessage}</div>}
+					<div style={{ fontSize: "11px", marginTop: "8px", color: "var(--vscode-textLink-foreground)" }}>
+						Click to open in browser
+					</div>
+				</div>
+			)
+		}
+
+		// Create a fallback object if ogData is null
+		const data = ogData || {
+			title: getSafeHostname(url),
+			description: "No description available",
+			siteName: getSafeHostname(url),
+			url: url,
+		}
+
+		// Render the Open Graph preview
+		return (
+			<div
+				className="link-preview"
+				onClick={async () => {
+					try {
+						await WebServiceClient.openInBrowser(
+							StringRequest.create({
+								value: DOMPurify.sanitize(url),
+							}),
+						)
+					} catch (err) {
+						console.error("Error opening URL in browser:", err)
+					}
+				}}
+				style={{
+					display: "flex",
+					border: "1px solid var(--vscode-editorWidget-border, rgba(127, 127, 127, 0.3))",
+					borderRadius: "4px",
+					overflow: "hidden",
+					cursor: "pointer",
+					height: "128px",
+					maxWidth: "512px",
+				}}>
+				{data.image && (
+					<div className="link-preview-image" style={{ width: "128px", height: "128px", flexShrink: 0 }}>
+						<img
+							alt=""
+							onError={(e) => {
+								console.log(`Image could not be loaded: ${data.image}`)
+								// Hide the broken image
+								;(e.target as HTMLImageElement).style.display = "none"
+							}}
+							onLoad={(e) => {
+								// Check aspect ratio to determine if we should use contain or cover
+								const img = e.currentTarget
+								if (img.naturalWidth > 0 && img.naturalHeight > 0) {
+									const aspectRatio = img.naturalWidth / img.naturalHeight
+
+									// Use contain for extreme aspect ratios (logos), cover for photos
+									if (aspectRatio > 2.5 || aspectRatio < 0.4) {
+										img.style.objectFit = "contain"
+									} else {
+										img.style.objectFit = "cover"
+									}
+								}
+							}}
+							src={DOMPurify.sanitize(normalizeRelativeUrl(data.image, url))}
+							style={{
+								width: "100%",
+								height: "100%",
+								objectFit: "contain", // Use contain for link preview thumbnails to handle logos
+								objectPosition: "center", // Center the image
+							}}
+						/>
+					</div>
+				)}
+
+				<div
+					className="link-preview-content"
+					style={{
+						flex: 1,
+						padding: "12px",
+						display: "flex",
+						flexDirection: "column",
+						overflow: "hidden",
+						height: "100%", // Ensure full height
+					}}>
+					{/* Top section with title and URL - top aligned */}
+					<div className="link-preview-top">
+						<div
+							className="link-preview-title"
+							style={{
+								fontWeight: "bold",
+								marginBottom: "4px",
+								whiteSpace: "nowrap",
+								overflow: "hidden",
+								textOverflow: "ellipsis",
+							}}>
+							{data.title || "No title"}
+						</div>
+
+						<div
+							className="link-preview-url"
+							style={{
+								fontSize: "12px",
+								color: "var(--vscode-textLink-foreground, #3794ff)",
+								marginBottom: "8px", // Increased for better separation
+								whiteSpace: "nowrap",
+								overflow: "hidden",
+								textOverflow: "ellipsis",
+							}}>
+							{data.siteName || getSafeHostname(url)}
+						</div>
+					</div>
+
+					{/* Description with space-around in the remaining space */}
+					<div
+						className="link-preview-description-container"
+						style={{
+							flex: 1, // Take up remaining space
+							display: "flex",
+							flexDirection: "column",
+							justifyContent: "space-around", // Space around in the remaining area
+						}}>
+						<div
+							className="link-preview-description"
+							style={{
+								fontSize: "12px",
+								color: "var(--vscode-descriptionForeground, rgba(204, 204, 204, 0.7))",
+								overflow: "hidden",
+								display: "-webkit-box",
+								WebkitLineClamp: 3,
+								WebkitBoxOrient: "vertical",
+								textOverflow: "ellipsis",
+							}}>
+							{data.description || "No description available"}
+						</div>
+					</div>
+				</div>
+			</div>
+		)
+	}
+}
+
+// Create a wrapper component that memoizes the LinkPreview to prevent unnecessary re-renders
+const MemoizedLinkPreview = React.memo(
+	(props: LinkPreviewProps) => <LinkPreview {...props} />,
+	(prevProps, nextProps) => prevProps.url === nextProps.url, // Only re-render if URL changes
+)
+
+// Wrap the LinkPreview component with an error boundary
+const LinkPreviewWithErrorBoundary: React.FC<LinkPreviewProps> = (props) => {
+	return (
+		<ChatErrorBoundary errorTitle="Something went wrong displaying this link preview">
+			<MemoizedLinkPreview {...props} />
+		</ChatErrorBoundary>
+	)
+}
+
+export default LinkPreviewWithErrorBoundary
diff --git a/apps/vscode/webview-ui/src/components/mcp/chat-display/McpDisplayModeDropdown.tsx b/apps/vscode/webview-ui/src/components/mcp/chat-display/McpDisplayModeDropdown.tsx
new file mode 100644
index 0000000..e8facd6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/chat-display/McpDisplayModeDropdown.tsx
@@ -0,0 +1,29 @@
+import { McpDisplayMode } from "@shared/McpDisplayMode"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import React from "react"
+
+interface McpDisplayModeDropdownProps {
+	value: McpDisplayMode
+	onChange: (mode: McpDisplayMode) => void
+	id?: string
+	className?: string
+	style?: React.CSSProperties
+	onClick?: (e: React.MouseEvent) => void
+}
+
+const McpDisplayModeDropdown: React.FC<McpDisplayModeDropdownProps> = ({ value, onChange, id, className, style, onClick }) => {
+	const handleChange = (e: any) => {
+		const newMode = e.target.value as McpDisplayMode
+		onChange(newMode)
+	}
+
+	return (
+		<VSCodeDropdown className={className} id={id} onChange={handleChange} onClick={onClick} style={style} value={value}>
+			<VSCodeOption value="plain">Plain Text</VSCodeOption>
+			<VSCodeOption value="rich">Rich Display</VSCodeOption>
+			<VSCodeOption value="markdown">Markdown</VSCodeOption>
+		</VSCodeDropdown>
+	)
+}
+
+export default McpDisplayModeDropdown
diff --git a/apps/vscode/webview-ui/src/components/mcp/chat-display/McpResponseDisplay.stories.tsx b/apps/vscode/webview-ui/src/components/mcp/chat-display/McpResponseDisplay.stories.tsx
new file mode 100644
index 0000000..243c591
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/chat-display/McpResponseDisplay.stories.tsx
@@ -0,0 +1,78 @@
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import { createStorybookDecorator } from "@/config/StorybookDecorator"
+import McpResponseDisplay from "./McpResponseDisplay"
+
+const meta: Meta<typeof McpResponseDisplay> = {
+	title: "Views/Components/McpResponseDisplay",
+	component: McpResponseDisplay,
+	parameters: {
+		layout: "padded",
+		docs: {
+			description: {
+				component:
+					"Renders MCP server responses with rich content support including images, links, and collapsible display modes.",
+			},
+		},
+	},
+	decorators: [createStorybookDecorator()],
+	argTypes: {
+		responseText: { control: "text", description: "The response text to display" },
+	},
+}
+
+export default meta
+type Story = StoryObj<typeof McpResponseDisplay>
+
+export const BasicText: Story = {
+	args: {
+		responseText:
+			"Here's a simple text response from an MCP server.\n\nThis demonstrates basic text rendering with proper line breaks and formatting.",
+	},
+}
+
+export const WithUrls: Story = {
+	args: {
+		responseText:
+			"Response with URLs:\n\nDocs: https://example.com/docs\nAPI: https://api.example.com/reference\nImage: https://via.placeholder.com/600x400?text=Sample",
+	},
+}
+
+export const MixedContent: Story = {
+	args: {
+		responseText:
+			"Mixed content response:\n\n## Links\n- Docs: https://example.com/docs\n- API: https://api.example.com/guide\n\n## Images\nScreenshot: https://via.placeholder.com/500x300?text=Screenshot\nDiagram: https://via.placeholder.com/400x400?text=Diagram",
+	},
+}
+
+export const CollapsedByDefault: Story = {
+	args: {
+		responseText:
+			"Collapsed response.\n\nClick header to expand.\n\nhttps://example.com/hidden\nhttps://via.placeholder.com/400x300?text=Hidden",
+	},
+	decorators: [createStorybookDecorator({ mcpResponsesCollapsed: true })],
+}
+
+export const PlainTextMode: Story = {
+	args: {
+		responseText:
+			"Plain text mode response.\n\nURLs shown as text:\n- https://example.com/link\n- https://via.placeholder.com/400x300?text=Image",
+	},
+}
+
+export const CodeResponse: Story = {
+	args: {
+		responseText:
+			'Code with URLs:\n\n```javascript\nconst apiUrl = "https://api.example.com/v1/data";\nconst imageUrl = "https://via.placeholder.com/200x200?text=API";\n\nfetch(apiUrl)\n  .then(response => response.json())\n  .then(data => console.log(data));\n```\n\nDocs: https://docs.example.com/api',
+	},
+}
+
+export const EmptyResponse: Story = {
+	args: { responseText: "" },
+}
+
+export const LongResponse: Story = {
+	args: {
+		responseText:
+			"Long response content.\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n\nResources:\n- Docs: https://docs.example.com/getting-started\n- API: https://docs.example.com/api-reference\n\nDuis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n\nImages:\n- https://via.placeholder.com/300x200?text=Logo\n- https://via.placeholder.com/400x300?text=Feature1\n- https://via.placeholder.com/400x300?text=Feature2",
+	},
+}
diff --git a/apps/vscode/webview-ui/src/components/mcp/chat-display/McpResponseDisplay.tsx b/apps/vscode/webview-ui/src/components/mcp/chat-display/McpResponseDisplay.tsx
new file mode 100644
index 0000000..ba3a23a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/chat-display/McpResponseDisplay.tsx
@@ -0,0 +1,283 @@
+import { McpDisplayMode } from "@shared/McpDisplayMode"
+import { VSCodeProgressRing } from "@vscode/webview-ui-toolkit/react"
+import { ChevronDownIcon, ChevronRightIcon } from "lucide-react"
+import React, { useCallback, useEffect, useState } from "react"
+import styled from "styled-components"
+import ChatErrorBoundary from "@/components/chat/ChatErrorBoundary"
+import { CODE_BLOCK_BG_COLOR } from "@/components/common/CodeBlock"
+import MarkdownBlock from "@/components/common/MarkdownBlock"
+import { DropdownContainer } from "@/components/settings/ApiOptions"
+import { updateSetting } from "@/components/settings/utils/settingsHandlers"
+import { useExtensionState } from "../../../context/ExtensionStateContext"
+import ImagePreview from "./ImagePreview"
+import LinkPreview from "./LinkPreview"
+import McpDisplayModeDropdown from "./McpDisplayModeDropdown"
+import { buildDisplaySegments, DisplaySegment, processResponseUrls, truncateDataUris, UrlMatch } from "./utils/mcpRichUtil"
+
+// Maximum number of URLs to process in total, per response
+const MAX_URLS = 50
+
+const ResponseHeader = styled.div`
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	padding: 5px 5px 5px 8px;
+	color: var(--vscode-descriptionForeground);
+	cursor: pointer;
+	user-select: none;
+	border-bottom: 1px dashed var(--vscode-editorGroup-border);
+	margin-bottom: 8px;
+	font-family: var(--vscode-font-family);
+	font-size: var(--vscode-font-size);
+
+	.header-title {
+		display: flex;
+		align-items: center;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		margin-right: 8px;
+	}
+
+	.header-icon {
+		margin-right: 6px;
+	}
+`
+
+const ResponseContainer = styled.div`
+	position: relative;
+	font-family: var(--vscode-editor-font-family, monospace);
+	font-size: var(--vscode-editor-font-size, 12px);
+	background-color: ${CODE_BLOCK_BG_COLOR};
+	color: var(--vscode-editor-foreground, #d4d4d4);
+	border-radius: 3px;
+	border: 1px solid var(--vscode-editorGroup-border);
+	overflow: hidden;
+	z-index: 0;
+
+	.response-content {
+		overflow-x: auto;
+		overflow-y: hidden;
+		max-width: 100%;
+		padding: 10px;
+	}
+`
+
+// Style for URL text to ensure proper wrapping
+const UrlText = styled.div`
+	white-space: pre-wrap;
+	word-break: break-all;
+	overflow-wrap: break-word;
+	font-family: var(--vscode-editor-font-family, monospace);
+	font-size: var(--vscode-editor-font-size, 12px);
+`
+
+interface McpResponseDisplayProps {
+	responseText: string
+}
+
+const McpResponseDisplay: React.FC<McpResponseDisplayProps> = ({ responseText }) => {
+	const { mcpResponsesCollapsed, mcpDisplayMode } = useExtensionState() // Get setting from context
+	const [isExpanded, setIsExpanded] = useState(!mcpResponsesCollapsed) // Initialize with context setting
+	const [isLoading, setIsLoading] = useState(false) // Initial loading state for rich content
+
+	const [urlMatches, setUrlMatches] = useState<UrlMatch[]>([])
+	const [error, setError] = useState<string | null>(null)
+
+	const handleDisplayModeChange = useCallback((newMode: McpDisplayMode) => {
+		updateSetting("mcpDisplayMode", newMode)
+	}, [])
+
+	const toggleExpand = useCallback(() => {
+		setIsExpanded((prev) => {
+			const newExpanded = !prev
+			// Save collapsed state so future MCP responses start in the same state
+			updateSetting("mcpResponsesCollapsed", !newExpanded)
+			return newExpanded
+		})
+	}, [])
+
+	// Find all URLs in the text and determine if they're images
+	useEffect(() => {
+		// Skip all processing if in plain mode or markdown mode
+		if (!isExpanded || mcpDisplayMode === "plain" || mcpDisplayMode === "markdown") {
+			setIsLoading(false)
+			if (urlMatches.length > 0) {
+				setUrlMatches([]) // Clear any existing matches when not in rich mode
+			}
+			return
+		}
+
+		console.log("Processing MCP response for URL extraction")
+		setIsLoading(true)
+		setError(null)
+
+		// Use the orchestrator function from mcpRichUtil
+		const cleanup = processResponseUrls(
+			responseText || "",
+			MAX_URLS,
+			(matches) => {
+				setUrlMatches(matches)
+				setIsLoading(false)
+			},
+			(updatedMatches) => {
+				setUrlMatches(updatedMatches)
+			},
+			(errorMessage) => {
+				setError(errorMessage)
+				setIsLoading(false)
+			},
+		)
+
+		return cleanup
+	}, [responseText, mcpDisplayMode, isExpanded])
+
+	// Helper function to render a display segment
+	const renderSegment = (segment: DisplaySegment): JSX.Element => {
+		switch (segment.type) {
+			case "text":
+			case "url":
+				return <UrlText key={segment.key}>{segment.content}</UrlText>
+
+			case "image":
+				return (
+					<div key={segment.key}>
+						<ImagePreview url={segment.url!} />
+					</div>
+				)
+
+			case "link":
+				return (
+					<div key={segment.key} style={{ margin: "10px 0" }}>
+						<LinkPreview url={segment.url!} />
+					</div>
+				)
+
+			case "error":
+				return (
+					<div
+						key={segment.key}
+						style={{
+							margin: "10px 0",
+							padding: "8px",
+							color: "var(--vscode-errorForeground)",
+							border: "1px solid var(--vscode-editorError-foreground)",
+							borderRadius: "4px",
+							height: "128px",
+							overflow: "auto",
+						}}>
+						{segment.content}
+					</div>
+				)
+
+			default:
+				return <React.Fragment key={segment.key} />
+		}
+	}
+
+	// Function to render content based on display mode
+	const renderContent = () => {
+		if (!isExpanded) {
+			return null
+		}
+
+		if (isLoading && mcpDisplayMode === "rich") {
+			return (
+				<div style={{ display: "flex", justifyContent: "center", alignItems: "center", height: "50px" }}>
+					<VSCodeProgressRing />
+				</div>
+			)
+		}
+
+		if (mcpDisplayMode === "plain") {
+			return <UrlText>{truncateDataUris(responseText)}</UrlText>
+		}
+
+		if (mcpDisplayMode === "markdown") {
+			return <MarkdownBlock markdown={truncateDataUris(responseText)} />
+		}
+
+		if (error) {
+			return (
+				<>
+					<div style={{ color: "var(--vscode-errorForeground)", marginBottom: "10px" }}>{error}</div>
+					<UrlText>{responseText}</UrlText>
+				</>
+			)
+		}
+
+		if (mcpDisplayMode === "rich") {
+			const segments = buildDisplaySegments(responseText, urlMatches)
+			return <>{segments.map(renderSegment)}</>
+		}
+
+		return null
+	}
+
+	try {
+		return (
+			<ResponseContainer>
+				<ResponseHeader
+					onClick={toggleExpand}
+					style={{
+						borderBottom: isExpanded ? "1px dashed var(--vscode-editorGroup-border)" : "none",
+						marginBottom: isExpanded ? "8px" : "0px",
+					}}>
+					<div className="header-title">
+						{isExpanded ? (
+							<ChevronDownIcon className="header-icon" size={16} />
+						) : (
+							<ChevronRightIcon className="header-icon" size={16} />
+						)}
+						Response
+					</div>
+					<DropdownContainer
+						style={{ minWidth: isExpanded ? "auto" : "0", visibility: isExpanded ? "visible" : "hidden" }}>
+						<McpDisplayModeDropdown
+							onChange={handleDisplayModeChange}
+							onClick={(e) => e.stopPropagation()}
+							style={{ minWidth: "120px" }}
+							value={mcpDisplayMode}
+						/>
+					</DropdownContainer>
+				</ResponseHeader>
+
+				{isExpanded && <div className="response-content">{renderContent()}</div>}
+			</ResponseContainer>
+		)
+	} catch (_error) {
+		console.log("Error rendering MCP response - falling back to plain text") // Restored comment
+		// Fallback for critical rendering errors
+		return (
+			<ResponseContainer>
+				<ResponseHeader onClick={toggleExpand}>
+					<div className="header-title">
+						{isExpanded ? (
+							<ChevronDownIcon className="header-icon" size={16} />
+						) : (
+							<ChevronRightIcon className="header-icon" size={16} />
+						)}
+						Response (Error)
+					</div>
+				</ResponseHeader>
+				{isExpanded && (
+					<div className="response-content">
+						<div style={{ color: "var(--vscode-errorForeground)" }}>Error parsing response:</div>
+						<UrlText>{responseText}</UrlText>
+					</div>
+				)}
+			</ResponseContainer>
+		)
+	}
+}
+
+// Wrap the entire McpResponseDisplay component with an error boundary
+const McpResponseDisplayWithErrorBoundary: React.FC<McpResponseDisplayProps> = (props) => {
+	return (
+		<ChatErrorBoundary>
+			<McpResponseDisplay {...props} />
+		</ChatErrorBoundary>
+	)
+}
+
+export default McpResponseDisplayWithErrorBoundary
diff --git a/apps/vscode/webview-ui/src/components/mcp/chat-display/utils/mcpRichUtil.ts b/apps/vscode/webview-ui/src/components/mcp/chat-display/utils/mcpRichUtil.ts
new file mode 100644
index 0000000..e222a05
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/chat-display/utils/mcpRichUtil.ts
@@ -0,0 +1,437 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { WebServiceClient } from "@/services/grpc-client"
+
+// Represents a URL found in the text with its position and metadata
+export interface UrlMatch {
+	url: string // The actual URL
+	fullMatch: string // The full matched text
+	index: number // Position in the text
+	isImage: boolean // Whether this URL is an image
+	isProcessed: boolean // Whether we've already processed this URL (to avoid duplicates)
+}
+
+// Display segment interface
+export interface DisplaySegment {
+	type: "text" | "url" | "image" | "link" | "error"
+	content: string
+	url?: string
+	key: string // Pre-computed key for React
+}
+
+/**
+ * Truncates a single data URI to show prefix + first 20 chars
+ * e.g. "data:image/png;base64,iVBORw0KGgo..." becomes "[IMAGE] data:image/png;base64,iVBORw0KGgoAAAANS..."
+ */
+const truncateSingleDataUri = (dataUri: string): string => {
+	const commaIndex = dataUri.indexOf(",")
+	if (commaIndex === -1) {
+		return dataUri
+	}
+	const dataStart = commaIndex + 1
+	const data = dataUri.substring(dataStart)
+	const truncatedData = data.length > 20 ? data.substring(0, 20) + "..." : data
+	return `[IMAGE] ${dataUri.substring(0, dataStart)}${truncatedData}`
+}
+
+/**
+ * Truncates all data URIs in text
+ * e.g. "data:image/png;base64,iVBORw0KGgo..." becomes "[IMAGE] data:image/png;base64,iVBORw..."
+ */
+export const truncateDataUris = (text: string): string => {
+	return text.replace(/data:[^;,]+(?:;[^,]+)?,[^\s<>"']+/g, (match) => truncateSingleDataUri(match))
+}
+
+// Safely create a URL object with error handling and ensure HTTPS
+const safeCreateUrl = (url: string): URL | null => {
+	try {
+		// Convert HTTP to HTTPS for security
+		if (url.startsWith("http://")) {
+			url = url.replace("http://", "https://")
+		}
+
+		return new URL(url)
+	} catch (_e) {
+		// If the URL doesn't have a protocol, add https://
+		if (!url.startsWith("https://")) {
+			try {
+				return new URL(`https://${url}`)
+			} catch (_e) {
+				console.log(`Invalid URL: ${url}`)
+				return null
+			}
+		}
+		console.log(`Invalid URL: ${url}`)
+		return null
+	}
+}
+
+// Check if a string is a valid URL
+const isUrl = (str: string): boolean => {
+	return safeCreateUrl(str) !== null
+}
+
+// Get hostname safely
+export const getSafeHostname = (url: string): string => {
+	try {
+		const urlObj = safeCreateUrl(url)
+		return urlObj ? urlObj.hostname : "unknown-host"
+	} catch (_e) {
+		return "unknown-host"
+	}
+}
+
+// Check if a URL is a localhost URL by examining the hostname
+const isLocalhostUrl = (url: string): boolean => {
+	try {
+		const hostname = getSafeHostname(url)
+		return (
+			hostname === "localhost" ||
+			hostname === "127.0.0.1" ||
+			hostname === "0.0.0.0" ||
+			hostname.startsWith("192.168.") ||
+			hostname.startsWith("10.") ||
+			hostname.endsWith(".local")
+		)
+	} catch (_e) {
+		// If we can't parse the URL, assume it's not localhost
+		return false
+	}
+}
+
+// Function to normalize relative URLs by combining with a base URL
+export const normalizeRelativeUrl = (relativeUrl: string, baseUrl: string): string => {
+	// If it's already an absolute URL or a data URL, return as is
+	if (relativeUrl.startsWith("http://") || relativeUrl.startsWith("https://") || relativeUrl.startsWith("data:")) {
+		return relativeUrl
+	}
+
+	try {
+		// Parse the base URL
+		const baseUrlObj = safeCreateUrl(baseUrl)
+		if (!baseUrlObj) {
+			return relativeUrl // If we can't parse the base URL, return original
+		}
+
+		// Handle different types of relative paths
+		if (relativeUrl.startsWith("//")) {
+			// Protocol-relative URL
+			return `${baseUrlObj.protocol}${relativeUrl}`
+		}
+		if (relativeUrl.startsWith("/")) {
+			// Root-relative URL
+			return `${baseUrlObj.protocol}//${baseUrlObj.host}${relativeUrl}`
+		}
+		// Path-relative URL
+		// Get the directory part of the URL
+		let basePath = baseUrlObj.pathname
+		if (!basePath.endsWith("/")) {
+			// If the path doesn't end with a slash, remove the file part
+			basePath = basePath.substring(0, basePath.lastIndexOf("/") + 1)
+		}
+		return `${baseUrlObj.protocol}//${baseUrlObj.host}${basePath}${relativeUrl}`
+	} catch (error) {
+		console.log(`Error normalizing relative URL: ${error}`)
+		return relativeUrl // Return original on error
+	}
+}
+
+// Helper to ensure URL is in a format that can be opened
+export const formatUrlForOpening = (url: string): string => {
+	// If it's a data URI, return as is
+	if (url.startsWith("data:image/")) {
+		return url
+	}
+
+	// Use safeCreateUrl to validate and format the URL
+	const urlObj = safeCreateUrl(url)
+	if (urlObj) {
+		return urlObj.href
+	}
+
+	console.log(`Invalid URL format: ${url}`)
+	// Return a safe fallback that won't crash
+	return "about:blank"
+}
+
+// Function to check if a URL is an image using HEAD request
+export const checkIfImageUrl = async (url: string): Promise<boolean> => {
+	// For data URLs, we can check synchronously
+	if (url.startsWith("data:image/")) {
+		return true
+	}
+
+	// Create a secure URL for the check but don't modify the original URL
+	let secureUrl = url
+	// Convert HTTP to HTTPS for security in the network request only
+	if (secureUrl.startsWith("http://")) {
+		secureUrl = secureUrl.replace("http://", "https://")
+		console.log(`Using HTTPS version for image check: ${secureUrl}`)
+	}
+
+	// Validate URL before proceeding
+	if (!isUrl(url)) {
+		console.log("Invalid URL format:", url)
+		return false
+	}
+
+	// For https URLs, we need to use the gRPC FileService
+	if (url.startsWith("https")) {
+		try {
+			// Use the gRPC client with timeout
+			const timeoutPromise = new Promise<boolean>((resolve) => {
+				setTimeout(() => {
+					console.log("Hit timeout waiting for checkIsImageUrl")
+					resolve(false)
+				}, 3000)
+			})
+
+			// Create the actual service call
+			const servicePromise = WebServiceClient.checkIsImageUrl(StringRequest.create({ value: url }))
+				.then((result) => result.isImage)
+				.catch((error) => {
+					console.error("Error checking if URL is an image via gRPC:", error)
+					return false
+				})
+
+			// Race between the service call and the timeout
+			return Promise.race([servicePromise, timeoutPromise])
+		} catch (_error) {
+			console.log("Error checking if URL is an image:", url)
+			// Return false to indicate it's not an image
+			return false
+		}
+	}
+
+	// Don't fall back to extension check for other URLs
+	// Only data URLs (handled above) are guaranteed to be images
+	// For all other URLs, we need proper content type verification
+	console.log(`URL protocol not supported for image check: ${url}`)
+	return false
+}
+
+/**
+ * Extracts all valid URLs from the given text
+ * @param text - The text to search for URLs
+ * @param maxUrls - Maximum number of URLs to extract (default: 50)
+ * @returns Array of URL matches sorted by position in text
+ */
+const extractUrlsFromText = (text: string, maxUrls = 50): UrlMatch[] => {
+	const matches: UrlMatch[] = []
+	const urlRegex = /(?:https?:\/\/|data:image)[^\s<>"']+/g
+	let urlMatch: RegExpExecArray | null
+	let urlCount = 0
+
+	while ((urlMatch = urlRegex.exec(text)) !== null && urlCount < maxUrls) {
+		const url = urlMatch[0]
+
+		// Skip invalid URLs
+		if (!isUrl(url)) {
+			console.log("Skipping invalid URL:", url)
+			continue
+		}
+
+		// Skip localhost URLs to prevent security issues
+		if (isLocalhostUrl(url)) {
+			console.log("Skipping localhost URL:", url)
+			continue
+		}
+
+		matches.push({
+			url,
+			fullMatch: url,
+			index: urlMatch.index,
+			isImage: false, // Will be determined later
+			isProcessed: false,
+		})
+
+		urlCount++
+	}
+
+	console.log(`Found ${matches.length} URLs in text`)
+	return matches.sort((a, b) => a.index - b.index)
+}
+
+/**
+ * Processes URLs to determine their types (e.g., image vs link)
+ * Processes URLs sequentially to avoid network flooding
+ * @param matches - Array of URL matches to process
+ * @param onProgress - Callback for progress updates with updated matches
+ * @param cancellationToken - Object to check if processing should be cancelled
+ * @returns Promise that resolves when processing is complete
+ */
+const processUrlTypes = async (
+	matches: UrlMatch[],
+	onProgress: (updatedMatches: UrlMatch[]) => void,
+	cancellationToken: { cancelled: boolean },
+): Promise<void> => {
+	console.log(`Starting sequential URL processing for ${matches.length} URLs`)
+
+	for (let i = 0; i < matches.length; i++) {
+		// Skip already processed URLs
+		if (matches[i].isProcessed) {
+			continue
+		}
+
+		// Check if processing has been canceled
+		if (cancellationToken.cancelled) {
+			console.log("URL processing canceled")
+			return
+		}
+
+		const match = matches[i]
+		console.log(`Processing URL ${i + 1} of ${matches.length}: ${match.url}`)
+
+		try {
+			// Check if URL is an image
+			const isImage = await checkIfImageUrl(match.url)
+
+			// Skip if processing has been canceled
+			if (cancellationToken.cancelled) {
+				return
+			}
+
+			// Update the match
+			match.isImage = isImage
+			match.isProcessed = true
+
+			// Notify progress with a new array to ensure React detects changes
+			onProgress([...matches])
+		} catch (err) {
+			console.log(`URL check error: ${match.url}`, err)
+			match.isProcessed = true
+
+			// Update state even on error
+			if (!cancellationToken.cancelled) {
+				onProgress([...matches])
+			}
+		}
+
+		// Delay between URL processing to avoid overwhelming the network
+		if (!cancellationToken.cancelled && i < matches.length - 1) {
+			await new Promise((resolve) => setTimeout(resolve, 100))
+		}
+	}
+
+	console.log(`URL processing complete. Found ${matches.filter((m) => m.isImage).length} image URLs`)
+}
+
+/**
+ * Orchestrates the URL extraction and processing pipeline
+ * @param text - The response text to process
+ * @param maxUrls - Maximum number of URLs to process
+ * @param onMatchesFound - Callback when initial URLs are extracted
+ * @param onMatchesUpdated - Callback when URL types are determined
+ * @param onError - Error handler callback
+ * @returns Cleanup function to cancel processing
+ */
+export const processResponseUrls = (
+	text: string,
+	maxUrls: number,
+	onMatchesFound: (matches: UrlMatch[]) => void,
+	onMatchesUpdated: (matches: UrlMatch[]) => void,
+	onError: (error: string) => void,
+): (() => void) => {
+	const cancellationToken = { cancelled: false }
+
+	const process = async () => {
+		try {
+			// Extract URLs from text
+			const matches = extractUrlsFromText(text, maxUrls)
+
+			// Immediately notify about found matches
+			onMatchesFound(matches)
+
+			// Process URLs in the background
+			await processUrlTypes(matches, onMatchesUpdated, cancellationToken)
+		} catch (_error) {
+			onError("Failed to process response content. Switch to plain text mode to view safely.")
+		}
+	}
+
+	// Start processing
+	process()
+
+	// Return cleanup function
+	return () => {
+		cancellationToken.cancelled = true
+		console.log("Cleaning up URL processing")
+	}
+}
+
+/**
+ * Builds an array of display segments from response text and URL matches
+ * @param responseText - The full response text
+ * @param urlMatches - Array of URL matches with their positions and types
+ * @returns Array of display segments describing how to render the content
+ */
+export const buildDisplaySegments = (responseText: string, urlMatches: UrlMatch[]): DisplaySegment[] => {
+	const segments: DisplaySegment[] = []
+	let lastIndex = 0
+	let segmentIndex = 0
+
+	// Handle case with no URLs
+	if (urlMatches.length === 0) {
+		return [
+			{
+				type: "text",
+				content: responseText,
+				key: "segment-0",
+			},
+		]
+	}
+
+	// Process each URL match
+	for (let i = 0; i < urlMatches.length; i++) {
+		const match = urlMatches[i]
+		const { url, fullMatch, index } = match
+
+		// Add text segment before this URL
+		if (index > lastIndex) {
+			segments.push({
+				type: "text",
+				content: responseText.substring(lastIndex, index),
+				key: `segment-${segmentIndex++}`,
+			})
+		}
+
+		// Add the URL text itself (truncate data URIs since they're very long)
+		const isDataUri = url.startsWith("data:")
+		const urlContent = isDataUri ? truncateSingleDataUri(fullMatch) : fullMatch
+		segments.push({
+			type: "url",
+			content: urlContent,
+			key: `url-${segmentIndex++}`,
+		})
+
+		// Add embedded content after the URL
+		if (match.isImage) {
+			segments.push({
+				type: "image",
+				content: url,
+				url: formatUrlForOpening(url),
+				key: `embed-image-${url}-${segmentIndex++}`,
+			})
+		} else if (match.isProcessed && !isLocalhostUrl(url)) {
+			segments.push({
+				type: "link",
+				content: url,
+				url: formatUrlForOpening(url),
+				key: `embed-${url}-${segmentIndex++}`,
+			})
+		}
+
+		// Update lastIndex for next segment
+		lastIndex = index + fullMatch.length
+	}
+
+	// Add any remaining text after the last URL
+	if (lastIndex < responseText.length) {
+		segments.push({
+			type: "text",
+			content: responseText.substring(lastIndex),
+			key: `segment-${segmentIndex++}`,
+		})
+	}
+
+	return segments
+}
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/McpConfigurationView.test.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/McpConfigurationView.test.tsx
new file mode 100644
index 0000000..a49e9bd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/McpConfigurationView.test.tsx
@@ -0,0 +1,73 @@
+import { render, screen, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import McpConfigurationView from "./McpConfigurationView"
+
+const mocks = vi.hoisted(() => ({
+	getLatestMcpServers: vi.fn(),
+	setMcpServers: vi.fn(),
+	remoteConfigSettings: {} as Record<string, unknown>,
+}))
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: () => ({
+		remoteConfigSettings: mocks.remoteConfigSettings,
+		setMcpServers: mocks.setMcpServers,
+		environment: "production",
+	}),
+}))
+
+vi.mock("@/services/grpc-client", () => ({
+	McpServiceClient: {
+		getLatestMcpServers: mocks.getLatestMcpServers,
+	},
+}))
+
+vi.mock("@shared/proto-conversions/mcp/mcp-server-conversion", () => ({
+	convertProtoMcpServersToMcpServers: () => [],
+}))
+
+vi.mock("./tabs/add-server/AddRemoteServerForm", () => ({
+	default: () => <div>Add Remote Server Form</div>,
+}))
+
+vi.mock("./tabs/installed/ConfigureServersView", () => ({
+	default: () => <div>Configure Servers View</div>,
+}))
+
+describe("McpConfigurationView", () => {
+	beforeEach(() => {
+		mocks.getLatestMcpServers.mockResolvedValue({ mcpServers: [] })
+		mocks.setMcpServers.mockReset()
+		mocks.getLatestMcpServers.mockClear()
+		mocks.remoteConfigSettings = {}
+	})
+
+	it("never renders the marketplace tab while keeping remote servers available", async () => {
+		mocks.remoteConfigSettings = {
+			blockPersonalRemoteMCPServers: false,
+		}
+
+		render(<McpConfigurationView onDone={vi.fn()} />)
+
+		expect(screen.queryByRole("button", { name: "Marketplace" })).not.toBeInTheDocument()
+		expect(screen.getByRole("button", { name: "Remote Servers" })).toBeInTheDocument()
+		expect(screen.getByRole("button", { name: "Configure" })).toBeInTheDocument()
+		expect(screen.getByText("Configure Servers View")).toBeInTheDocument()
+
+		await waitFor(() => expect(mocks.getLatestMcpServers).toHaveBeenCalledTimes(1))
+	})
+
+	it("hides remote servers only when personal remote MCP servers are blocked", () => {
+		mocks.remoteConfigSettings = {
+			blockPersonalRemoteMCPServers: true,
+		}
+
+		render(<McpConfigurationView initialTab="addRemote" onDone={vi.fn()} />)
+
+		expect(screen.queryByRole("button", { name: "Marketplace" })).not.toBeInTheDocument()
+		expect(screen.queryByRole("button", { name: "Remote Servers" })).not.toBeInTheDocument()
+		expect(screen.getByRole("button", { name: "Configure" })).toBeInTheDocument()
+		expect(screen.queryByText("Add Remote Server Form")).not.toBeInTheDocument()
+		expect(screen.getByText("Configure Servers View")).toBeInTheDocument()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/McpConfigurationView.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/McpConfigurationView.tsx
new file mode 100644
index 0000000..55dcddb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/McpConfigurationView.tsx
@@ -0,0 +1,128 @@
+import { McpViewTab } from "@shared/mcp"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { McpServers } from "@shared/proto/cline/mcp"
+import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { useEffect, useState } from "react"
+import styled from "styled-components"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { McpServiceClient } from "@/services/grpc-client"
+import ViewHeader from "../../common/ViewHeader"
+import AddRemoteServerForm from "./tabs/add-server/AddRemoteServerForm"
+import ConfigureServersView from "./tabs/installed/ConfigureServersView"
+
+type McpViewProps = {
+	onDone: () => void
+	initialTab?: McpViewTab
+}
+
+const McpConfigurationView = ({ onDone, initialTab }: McpViewProps) => {
+	const { remoteConfigSettings, setMcpServers, environment } = useExtensionState()
+	const showRemoteServers = remoteConfigSettings?.blockPersonalRemoteMCPServers !== true
+	const [activeTab, setActiveTab] = useState<McpViewTab>(initialTab || "configure")
+
+	const handleTabChange = (tab: McpViewTab) => {
+		setActiveTab(tab)
+	}
+
+	useEffect(() => {
+		if (!showRemoteServers && activeTab === "addRemote") {
+			setActiveTab("configure")
+		}
+	}, [showRemoteServers, activeTab])
+
+	useEffect(() => {
+		McpServiceClient.getLatestMcpServers(EmptyRequest.create({}))
+			.then((response: McpServers) => {
+				if (response.mcpServers) {
+					const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+					setMcpServers(mcpServers)
+				}
+			})
+			.catch((error) => {
+				console.error("Failed to fetch MCP servers:", error)
+			})
+	}, [setMcpServers])
+
+	return (
+		<div
+			style={{
+				position: "fixed",
+				top: 0,
+				left: 0,
+				right: 0,
+				bottom: 0,
+				display: "flex",
+				flexDirection: "column",
+			}}>
+			<ViewHeader environment={environment} onDone={onDone} title="MCP Servers" />
+
+			<div style={{ flex: 1, overflow: "auto" }}>
+				{/* Tabs container */}
+				<div
+					style={{
+						display: "flex",
+						gap: "1px",
+						padding: "0 20px 0 20px",
+						borderBottom: "1px solid var(--vscode-panel-border)",
+					}}>
+					{showRemoteServers && (
+						<TabButton isActive={activeTab === "addRemote"} onClick={() => handleTabChange("addRemote")}>
+							Remote Servers
+						</TabButton>
+					)}
+					<TabButton isActive={activeTab === "configure"} onClick={() => handleTabChange("configure")}>
+						Configure
+					</TabButton>
+				</div>
+
+				{/* Content container */}
+				<div style={{ width: "100%" }}>
+					{showRemoteServers && activeTab === "addRemote" && (
+						<AddRemoteServerForm onServerAdded={() => handleTabChange("configure")} />
+					)}
+					{activeTab === "configure" && <ConfigureServersView />}
+				</div>
+			</div>
+		</div>
+	)
+}
+
+const StyledTabButton = styled.button.withConfig({
+	shouldForwardProp: (prop) => !["isActive"].includes(prop),
+})<{ isActive: boolean; disabled?: boolean }>`
+	background: none;
+	border: none;
+	border-bottom: 2px solid ${(props) => (props.isActive ? "var(--vscode-foreground)" : "transparent")};
+	color: ${(props) => (props.isActive ? "var(--vscode-foreground)" : "var(--vscode-descriptionForeground)")};
+	padding: 8px 16px;
+	cursor: ${(props) => (props.disabled ? "not-allowed" : "pointer")};
+	font-size: 13px;
+	margin-bottom: -1px;
+	font-family: inherit;
+	opacity: ${(props) => (props.disabled ? 0.6 : 1)};
+	pointer-events: ${(props) => (props.disabled ? "none" : "auto")};
+
+	&:hover {
+		color: ${(props) => (props.disabled ? "var(--vscode-descriptionForeground)" : "var(--vscode-foreground)")};
+	}
+`
+
+export const TabButton = ({
+	children,
+	isActive,
+	onClick,
+	disabled,
+	style,
+}: {
+	children: React.ReactNode
+	isActive: boolean
+	onClick: () => void
+	disabled?: boolean
+	style?: React.CSSProperties
+}) => (
+	<StyledTabButton disabled={disabled} isActive={isActive} onClick={onClick} style={style}>
+		{children}
+	</StyledTabButton>
+)
+
+export default McpConfigurationView
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/add-server/AddRemoteServerForm.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/add-server/AddRemoteServerForm.tsx
new file mode 100644
index 0000000..8fef748
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/add-server/AddRemoteServerForm.tsx
@@ -0,0 +1,163 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { AddRemoteMcpServerRequest, McpServers } from "@shared/proto/cline/mcp"
+import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { VSCodeButton, VSCodeLink, VSCodeRadio, VSCodeRadioGroup, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import { LINKS } from "@/constants"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { McpServiceClient } from "@/services/grpc-client"
+
+type TransportType = "streamableHttp" | "sse"
+
+type AddRemoteServerFormProps = {
+	onServerAdded: () => void
+	onCancel?: () => void
+	showEditConfiguration?: boolean
+}
+
+const AddRemoteServerForm = ({ onCancel, onServerAdded, showEditConfiguration = true }: AddRemoteServerFormProps) => {
+	const [serverName, setServerName] = useState("")
+	const [serverUrl, setServerUrl] = useState("")
+	const [transportType, setTransportType] = useState<TransportType>("streamableHttp")
+	const [isSubmitting, setIsSubmitting] = useState(false)
+	const [error, setError] = useState("")
+	const { setMcpServers } = useExtensionState()
+
+	const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+		e.preventDefault()
+
+		if (!serverName.trim()) {
+			setError("Server name is required")
+			return
+		}
+
+		if (!serverUrl.trim()) {
+			setError("Server URL is required")
+			return
+		}
+
+		try {
+			new URL(serverUrl)
+		} catch (_err) {
+			setError("Invalid URL format")
+			return
+		}
+
+		setError("")
+		setIsSubmitting(true)
+
+		try {
+			const servers: McpServers = await McpServiceClient.addRemoteMcpServer(
+				AddRemoteMcpServerRequest.create({
+					serverName: serverName.trim(),
+					serverUrl: serverUrl.trim(),
+					transportType: transportType,
+				}),
+			)
+
+			setIsSubmitting(false)
+
+			const mcpServers = convertProtoMcpServersToMcpServers(servers.mcpServers)
+			setMcpServers(mcpServers)
+
+			setServerName("")
+			setServerUrl("")
+			onServerAdded()
+		} catch (error) {
+			setIsSubmitting(false)
+			setError(error instanceof Error ? error.message : "Failed to add server")
+		}
+	}
+
+	return (
+		<div className="p-4 px-5">
+			<div className="text-(--vscode-foreground) mb-2">
+				Add a remote MCP server by providing a name and its URL endpoint. Learn more{" "}
+				<VSCodeLink href={LINKS.DOCUMENTATION.REMOTE_MCP_SERVER_DOCS} style={{ display: "inline" }}>
+					here.
+				</VSCodeLink>
+			</div>
+
+			<form onSubmit={handleSubmit}>
+				<div className="mb-2">
+					<VSCodeTextField
+						className="w-full"
+						disabled={isSubmitting}
+						onChange={(e) => {
+							setServerName((e.target as HTMLInputElement).value)
+							setError("")
+						}}
+						placeholder="mcp-server"
+						value={serverName}>
+						Server Name
+					</VSCodeTextField>
+				</div>
+
+				<div className="mb-2">
+					<VSCodeTextField
+						className="w-full mr-4"
+						disabled={isSubmitting}
+						onChange={(e) => {
+							setServerUrl((e.target as HTMLInputElement).value)
+							setError("")
+						}}
+						placeholder="https://example.com/mcp-server"
+						value={serverUrl}>
+						Server URL
+					</VSCodeTextField>
+				</div>
+
+				<div className="mb-3">
+					<label className={`block text-sm font-medium mb-2 ${isSubmitting ? "opacity-50" : ""}`}>Transport Type</label>
+					<VSCodeRadioGroup
+						disabled={isSubmitting}
+						onChange={(e) => {
+							const value = (e.target as HTMLInputElement).value as TransportType
+							setTransportType(value)
+						}}
+						value={transportType}>
+						<VSCodeRadio checked={transportType === "streamableHttp"} value="streamableHttp">
+							Streamable HTTP
+						</VSCodeRadio>
+						<VSCodeRadio checked={transportType === "sse"} value="sse">
+							SSE (Legacy)
+						</VSCodeRadio>
+					</VSCodeRadioGroup>
+				</div>
+
+				{error && <div className="mb-3 text-(--vscode-errorForeground)">{error}</div>}
+
+				<VSCodeButton className="w-full" disabled={isSubmitting} type="submit">
+					{isSubmitting ? "Connecting..." : "Add Server"}
+				</VSCodeButton>
+
+				{onCancel && (
+					<VSCodeButton
+						appearance="secondary"
+						className="w-full"
+						disabled={isSubmitting}
+						onClick={onCancel}
+						style={{ marginTop: "8px" }}
+						type="button">
+						Cancel
+					</VSCodeButton>
+				)}
+
+				{showEditConfiguration && (
+					<VSCodeButton
+						appearance="secondary"
+						onClick={() => {
+							McpServiceClient.openMcpSettings(EmptyRequest.create({})).catch((error) => {
+								console.error("Error opening MCP settings:", error)
+							})
+						}}
+						style={{ width: "100%", marginBottom: "5px", marginTop: 15 }}>
+						Edit Configuration
+					</VSCodeButton>
+				)}
+			</form>
+		</div>
+	)
+}
+
+export default AddRemoteServerForm
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/ConfigureServersView.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/ConfigureServersView.tsx
new file mode 100644
index 0000000..2d56716
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/ConfigureServersView.tsx
@@ -0,0 +1,71 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { McpServiceClient } from "@/services/grpc-client"
+import ServersToggleList from "./ServersToggleList"
+
+const ConfigureServersView = () => {
+	const { mcpServers: servers, navigateToSettings, remoteConfigSettings } = useExtensionState()
+
+	// Check if there are remote MCP servers configured
+	const hasRemoteMCPServers = remoteConfigSettings?.remoteMCPServers && remoteConfigSettings.remoteMCPServers.length > 0
+
+	return (
+		<div style={{ padding: "16px 20px" }}>
+			<div
+				style={{
+					color: "var(--vscode-foreground)",
+					fontSize: "13px",
+					marginBottom: "16px",
+					marginTop: "5px",
+				}}>
+				The{" "}
+				<VSCodeLink href="https://github.com/modelcontextprotocol" style={{ display: "inline" }}>
+					Model Context Protocol
+				</VSCodeLink>{" "}
+				enables communication with locally running MCP servers that provide additional tools and resources to extend
+				Cline's capabilities. You can use{" "}
+				<VSCodeLink href="https://github.com/modelcontextprotocol/servers" style={{ display: "inline" }}>
+					community-made servers
+				</VSCodeLink>{" "}
+				or ask Cline to create new tools specific to your workflow (e.g., "add a tool that gets the latest npm docs").{" "}
+				<VSCodeLink href="https://x.com/sdrzn/status/1867271665086074969" style={{ display: "inline" }}>
+					See a demo here.
+				</VSCodeLink>
+			</div>
+
+			{/* Remote config banner */}
+			{hasRemoteMCPServers && (
+				<div className="flex items-center gap-2 px-5 py-3 mb-4 bg-vscode-textBlockQuote-background border-l-[3px] border-vscode-textLink-foreground">
+					<i className="codicon codicon-lock text-sm" />
+					<span className="text-base">Your organization manages some MCP servers</span>
+				</div>
+			)}
+
+			<ServersToggleList hasTrashIcon={false} isExpandable={true} servers={servers} />
+
+			{/* Settings Section */}
+			<div style={{ marginBottom: "20px", marginTop: 10 }}>
+				<VSCodeButton
+					appearance="secondary"
+					onClick={() => {
+						McpServiceClient.openMcpSettings(EmptyRequest.create({})).catch((error) => {
+							console.error("Error opening MCP settings:", error)
+						})
+					}}
+					style={{ width: "100%", marginBottom: "5px" }}>
+					<span className="codicon codicon-server" style={{ marginRight: "6px" }}></span>
+					Configure MCP Servers
+				</VSCodeButton>
+
+				<div style={{ textAlign: "center" }}>
+					<VSCodeLink onClick={() => navigateToSettings("features")} style={{ fontSize: "12px" }}>
+						Advanced MCP Settings
+					</VSCodeLink>
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default ConfigureServersView
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/ServersToggleList.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/ServersToggleList.tsx
new file mode 100644
index 0000000..3c89861
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/ServersToggleList.tsx
@@ -0,0 +1,49 @@
+import { McpServer } from "@shared/mcp"
+import ServerRow from "./server-row/ServerRow"
+
+export type MarketplaceMcpMetadata = {
+	name: string
+	description?: string
+}
+
+const ServersToggleList = ({
+	servers,
+	isExpandable,
+	hasTrashIcon,
+	listGap = "medium",
+	marketplaceMetadataByServerName,
+}: {
+	servers: McpServer[]
+	isExpandable: boolean
+	hasTrashIcon: boolean
+	listGap?: "small" | "medium" | "large"
+	marketplaceMetadataByServerName?: Map<string, MarketplaceMcpMetadata>
+}) => {
+	const gapClasses = {
+		small: "gap-0",
+		medium: "gap-2.5",
+		large: "gap-5",
+	}
+
+	const gapClass = gapClasses[listGap]
+
+	return servers.length > 0 ? (
+		<div className={`flex flex-col ${gapClass}`}>
+			{servers.map((server) => (
+				<ServerRow
+					hasTrashIcon={hasTrashIcon}
+					isExpandable={isExpandable}
+					key={server.name}
+					marketplaceMetadata={marketplaceMetadataByServerName?.get(server.name)}
+					server={server}
+				/>
+			))}
+		</div>
+	) : (
+		<div className="flex flex-col items-center gap-3 my-5 text-(--vscode-descriptionForeground)">
+			No MCP servers installed
+		</div>
+	)
+}
+
+export default ServersToggleList
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpPromptRow.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpPromptRow.tsx
new file mode 100644
index 0000000..7cb9cd3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpPromptRow.tsx
@@ -0,0 +1,94 @@
+import { McpPrompt } from "@shared/mcp"
+
+type McpPromptRowProps = {
+	prompt: McpPrompt
+	serverName?: string
+}
+
+const McpPromptRow = ({ prompt, serverName }: McpPromptRowProps) => {
+	return (
+		<div
+			key={prompt.name}
+			style={{
+				padding: "3px 0",
+			}}>
+			<div
+				data-testid="prompt-row-container"
+				onClick={(e) => e.stopPropagation()}
+				style={{ display: "flex", alignItems: "center", justifyContent: "space-between", flexWrap: "wrap", gap: "4px" }}>
+				<div style={{ display: "flex", alignItems: "center", minWidth: 0, flex: "1 1 auto" }}>
+					<span className="codicon codicon-comment-discussion" style={{ marginRight: "6px", flexShrink: 0 }}></span>
+					<span style={{ fontWeight: 500, overflow: "hidden", textOverflow: "ellipsis" }}>
+						{prompt.title || prompt.name}
+					</span>
+				</div>
+			</div>
+			{prompt.description && (
+				<div
+					style={{
+						marginLeft: "0px",
+						marginTop: "4px",
+						opacity: 0.8,
+						fontSize: "12px",
+					}}>
+					{prompt.description}
+				</div>
+			)}
+			{prompt.arguments && prompt.arguments.length > 0 && (
+				<div
+					style={{
+						marginTop: "8px",
+						fontSize: "12px",
+						border: "1px solid color-mix(in srgb, var(--vscode-descriptionForeground) 30%, transparent)",
+						borderRadius: "3px",
+						padding: "8px",
+					}}>
+					<div
+						style={{
+							marginBottom: "4px",
+							opacity: 0.8,
+							fontSize: "11px",
+							textTransform: "uppercase",
+						}}>
+						Arguments
+					</div>
+					{prompt.arguments.map((arg) => (
+						<div
+							key={arg.name}
+							style={{
+								display: "flex",
+								alignItems: "baseline",
+								marginTop: "4px",
+							}}>
+							<code
+								style={{
+									color: "var(--vscode-textPreformat-foreground)",
+									marginRight: "8px",
+								}}>
+								{arg.name}
+								{arg.required && (
+									<span
+										style={{
+											color: "var(--vscode-errorForeground)",
+										}}>
+										*
+									</span>
+								)}
+							</code>
+							<span
+								style={{
+									opacity: 0.8,
+									overflowWrap: "break-word",
+									wordBreak: "break-word",
+								}}>
+								{arg.description || "No description"}
+							</span>
+						</div>
+					))}
+				</div>
+			)}
+		</div>
+	)
+}
+
+export default McpPromptRow
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpResourceRow.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpResourceRow.tsx
new file mode 100644
index 0000000..49c1255
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpResourceRow.tsx
@@ -0,0 +1,59 @@
+import { McpResource, McpResourceTemplate } from "@shared/mcp"
+
+type McpResourceRowProps = {
+	item: McpResource | McpResourceTemplate
+}
+
+const McpResourceRow = ({ item }: McpResourceRowProps) => {
+	const hasUri = "uri" in item
+	const uri = hasUri ? item.uri : item.uriTemplate
+
+	return (
+		<div
+			key={uri}
+			style={{
+				padding: "3px 0",
+			}}>
+			<div
+				style={{
+					display: "flex",
+					alignItems: "center",
+					marginBottom: "4px",
+				}}>
+				<span className={`codicon codicon-symbol-file`} style={{ marginRight: "6px" }} />
+				<span style={{ fontWeight: 500, wordBreak: "break-all" }}>{uri}</span>
+			</div>
+			<div
+				style={{
+					fontSize: "12px",
+					opacity: 0.8,
+					margin: "4px 0",
+				}}>
+				{item.name && item.description
+					? `${item.name}: ${item.description}`
+					: !item.name && item.description
+						? item.description
+						: !item.description && item.name
+							? item.name
+							: "No description"}
+			</div>
+			<div
+				style={{
+					fontSize: "12px",
+				}}>
+				<span style={{ opacity: 0.8 }}>Returns </span>
+				<code
+					style={{
+						color: "var(--vscode-textPreformat-foreground)",
+						background: "var(--vscode-textPreformat-background)",
+						padding: "1px 4px",
+						borderRadius: "3px",
+					}}>
+					{item.mimeType || "Unknown"}
+				</code>
+			</div>
+		</div>
+	)
+}
+
+export default McpResourceRow
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpToolRow.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpToolRow.tsx
new file mode 100644
index 0000000..9e27fee
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/McpToolRow.tsx
@@ -0,0 +1,141 @@
+import { McpTool } from "@shared/mcp"
+import { ToggleToolAutoApproveRequest } from "@shared/proto/cline/mcp"
+import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { McpServiceClient } from "@/services/grpc-client"
+
+type McpToolRowProps = {
+	tool: McpTool
+	serverName?: string
+}
+
+const McpToolRow = ({ tool, serverName }: McpToolRowProps) => {
+	const { autoApprovalSettings } = useExtensionState()
+
+	const { setMcpServers } = useExtensionState()
+
+	// Accept the event object
+	const handleAutoApproveChange = (_event: any) => {
+		if (!serverName) {
+			return
+		}
+
+		McpServiceClient.toggleToolAutoApprove(
+			ToggleToolAutoApproveRequest.create({
+				serverName,
+				toolNames: [tool.name],
+				autoApprove: !tool.autoApprove,
+			}),
+		)
+			.then((response) => {
+				const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+				setMcpServers(mcpServers)
+			})
+			.catch((error) => {
+				console.error("Error toggling tool auto-approve", error)
+			})
+	}
+	return (
+		<div
+			key={tool.name}
+			style={{
+				padding: "3px 0",
+			}}>
+			<div
+				data-testid="tool-row-container"
+				onClick={(e) => e.stopPropagation()}
+				style={{ display: "flex", alignItems: "center", justifyContent: "space-between", flexWrap: "wrap", gap: "4px" }}>
+				<div style={{ display: "flex", alignItems: "center", minWidth: 0, flex: "1 1 auto" }}>
+					<span className="codicon codicon-symbol-method" style={{ marginRight: "6px", flexShrink: 0 }}></span>
+					<span style={{ fontWeight: 500, overflow: "hidden", textOverflow: "ellipsis" }}>{tool.name}</span>
+				</div>
+				{serverName && autoApprovalSettings.actions.useMcp && (
+					<VSCodeCheckbox
+						checked={tool.autoApprove ?? false}
+						data-tool={tool.name}
+						onChange={handleAutoApproveChange}
+						style={{ fontSize: "11px" }}>
+						Auto-approve
+					</VSCodeCheckbox>
+				)}
+			</div>
+			{tool.description && (
+				<div
+					style={{
+						marginLeft: "0px",
+						marginTop: "4px",
+						opacity: 0.8,
+						fontSize: "12px",
+					}}>
+					{tool.description}
+				</div>
+			)}
+			{tool.inputSchema &&
+				"properties" in tool.inputSchema &&
+				Object.keys(tool.inputSchema.properties as Record<string, any>).length > 0 && (
+					<div
+						style={{
+							marginTop: "8px",
+							fontSize: "12px",
+							border: "1px solid color-mix(in srgb, var(--vscode-descriptionForeground) 30%, transparent)",
+							borderRadius: "3px",
+							padding: "8px",
+						}}>
+						<div
+							style={{
+								marginBottom: "4px",
+								opacity: 0.8,
+								fontSize: "11px",
+								textTransform: "uppercase",
+							}}>
+							Parameters
+						</div>
+						{Object.entries(tool.inputSchema.properties as Record<string, any>).map(([paramName, schema]) => {
+							const isRequired =
+								tool.inputSchema &&
+								"required" in tool.inputSchema &&
+								Array.isArray(tool.inputSchema.required) &&
+								tool.inputSchema.required.includes(paramName)
+
+							return (
+								<div
+									key={paramName}
+									style={{
+										display: "flex",
+										alignItems: "baseline",
+										marginTop: "4px",
+									}}>
+									<code
+										style={{
+											color: "var(--vscode-textPreformat-foreground)",
+											marginRight: "8px",
+										}}>
+										{paramName}
+										{isRequired && (
+											<span
+												style={{
+													color: "var(--vscode-errorForeground)",
+												}}>
+												*
+											</span>
+										)}
+									</code>
+									<span
+										style={{
+											opacity: 0.8,
+											overflowWrap: "break-word",
+											wordBreak: "break-word",
+										}}>
+										{schema.description || "No description"}
+									</span>
+								</div>
+							)
+						})}
+					</div>
+				)}
+		</div>
+	)
+}
+
+export default McpToolRow
diff --git a/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/ServerRow.tsx b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/ServerRow.tsx
new file mode 100644
index 0000000..c2482aa
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/ServerRow.tsx
@@ -0,0 +1,425 @@
+import { DEFAULT_MCP_TIMEOUT_SECONDS, McpServer } from "@shared/mcp"
+import { StringRequest } from "@shared/proto/cline/common"
+import {
+	McpServers,
+	ToggleMcpServerRequest,
+	ToggleToolAutoApproveRequest,
+	UpdateMcpTimeoutRequest,
+} from "@shared/proto/cline/mcp"
+import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import {
+	VSCodeCheckbox,
+	VSCodeDropdown,
+	VSCodeOption,
+	VSCodePanels,
+	VSCodePanelTab,
+	VSCodePanelView,
+} from "@vscode/webview-ui-toolkit/react"
+import { RefreshCcwIcon, Trash2Icon } from "lucide-react"
+import { useState } from "react"
+import { Button } from "@/components/ui/button"
+import { Switch } from "@/components/ui/switch"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import { McpServiceClient } from "@/services/grpc-client"
+import type { MarketplaceMcpMetadata } from "../ServersToggleList"
+import McpPromptRow from "./McpPromptRow"
+import McpResourceRow from "./McpResourceRow"
+import McpToolRow from "./McpToolRow"
+
+// constant JSX.Elements
+const TimeoutOptions = [
+	{ value: "30", label: "30 seconds" },
+	{ value: "60", label: "1 minute" },
+	{ value: "300", label: "5 minutes" },
+	{ value: "600", label: "10 minutes" },
+	{ value: "1800", label: "30 minutes" },
+	{ value: "3600", label: "1 hour" },
+].map((option) => (
+	<VSCodeOption key={option.value} value={option.value}>
+		{option.label}
+	</VSCodeOption>
+))
+
+const ServerRow = ({
+	server,
+	isExpandable = true,
+	hasTrashIcon = true,
+	marketplaceMetadata,
+}: {
+	server: McpServer
+	isExpandable?: boolean
+	hasTrashIcon?: boolean
+	marketplaceMetadata?: MarketplaceMcpMetadata
+}) => {
+	const { autoApprovalSettings, setMcpServers, remoteConfigSettings } = useExtensionState()
+
+	const [isExpanded, setIsExpanded] = useState(false)
+	const [isDeleting, setIsDeleting] = useState(false)
+	const [isRestarting, setIsRestarting] = useState(false)
+
+	// Check if user is managed by remote config and if this server is remote-managed.
+	// Remote MCP servers from enterprise config are always URL-based (SSE/HTTP).
+	// stdio-based local servers are never in remoteMCPServers, so URL matching is sufficient.
+	const isRemoteManagedServer = (() => {
+		const remoteMCPServers = remoteConfigSettings?.remoteMCPServers
+		if (!remoteMCPServers || remoteMCPServers.length === 0) {
+			return false
+		}
+		try {
+			const serverConfig = JSON.parse(server.config)
+			return remoteMCPServers.some(
+				(remoteServer: { url: string }) => serverConfig.url && serverConfig.url === remoteServer.url,
+			)
+		} catch {
+			return false
+		}
+	})()
+
+	const handleRowClick = () => {
+		if (!server.error && isExpandable) {
+			setIsExpanded(!isExpanded)
+		}
+	}
+
+	const [timeoutValue, setTimeoutValue] = useState<string>(() => {
+		try {
+			const config = JSON.parse(server.config)
+			return config.timeout?.toString() || DEFAULT_MCP_TIMEOUT_SECONDS.toString()
+		} catch {
+			return DEFAULT_MCP_TIMEOUT_SECONDS.toString()
+		}
+	})
+
+	const handleTimeoutChange = (e: any) => {
+		const select = e.target as HTMLSelectElement
+		const value = select.value
+		const num = Number.parseInt(value)
+		setTimeoutValue(value)
+
+		McpServiceClient.updateMcpTimeout({
+			serverName: server.name,
+			timeout: num,
+		} as UpdateMcpTimeoutRequest)
+			.then((response: McpServers) => {
+				const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+				setMcpServers(mcpServers)
+			})
+			.catch((error) => {
+				console.error("Error updating MCP server timeout", error)
+			})
+	}
+
+	const handleRestart = () => {
+		// Set local state to show "connecting" status
+		setIsRestarting(true)
+
+		// Make the gRPC call
+		McpServiceClient.restartMcpServer({
+			value: server.name,
+		} as StringRequest)
+			.then((response: McpServers) => {
+				// Update with the final state from the server
+				const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+				setMcpServers(mcpServers)
+				setIsRestarting(false)
+			})
+			.catch((error) => {
+				// Reset the restarting state
+				setIsRestarting(false)
+				console.error("Error restarting MCP server", error)
+			})
+	}
+
+	const handleDelete = () => {
+		setIsDeleting(true)
+		McpServiceClient.deleteMcpServer({
+			value: server.name,
+		} as StringRequest)
+			.then((response: McpServers) => {
+				const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+				setMcpServers(mcpServers)
+				setIsDeleting(false)
+			})
+			.catch((error) => {
+				console.error("Error deleting MCP server", error)
+				setIsDeleting(false)
+			})
+	}
+
+	const handleAutoApproveChange = () => {
+		if (!server.name) {
+			return
+		}
+
+		McpServiceClient.toggleToolAutoApprove(
+			ToggleToolAutoApproveRequest.create({
+				serverName: server.name,
+				toolNames: server.tools?.map((tool) => tool.name) || [],
+				autoApprove: !server.tools?.every((tool) => tool.autoApprove),
+			}),
+		)
+			.then((response) => {
+				const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+				setMcpServers(mcpServers)
+			})
+			.catch((error) => {
+				console.error("Error toggling all tools auto-approve", error)
+			})
+	}
+
+	const handleToggleMcpServer = () => {
+		McpServiceClient.toggleMcpServer(
+			ToggleMcpServerRequest.create({
+				serverName: server.name,
+				disabled: !server.disabled,
+			}),
+		)
+			.then((response) => {
+				const mcpServers = convertProtoMcpServersToMcpServers(response.mcpServers)
+				setMcpServers(mcpServers)
+			})
+			.catch((error) => {
+				console.error("Error toggling MCP server", error)
+			})
+	}
+
+	// Helper to extract server URL from config
+	const getServerUrl = (server: McpServer): string | null => {
+		try {
+			const config = JSON.parse(server.config)
+			return config.url || null
+		} catch {
+			return null
+		}
+	}
+
+	// Check if this server is always-enabled via remote config
+	const isAlwaysEnabled = (() => {
+		const remoteMCPServers = remoteConfigSettings?.remoteMCPServers || []
+		const serverUrl = getServerUrl(server)
+		if (!serverUrl) return false
+
+		const remoteServer = remoteMCPServers.find((remote) => remote.url === serverUrl)
+		return remoteServer?.alwaysEnabled === true
+	})()
+
+	return (
+		<div className="mb-2.5">
+			<div
+				className={cn("flex bg-code-block-background p-2 gap-4 items-center", {
+					"cursor-pointer": !server.error && isExpandable,
+				})}
+				onClick={handleRowClick}>
+				{!server.error && isExpandable && (
+					<span
+						className={cn("mr-2 codicon", {
+							"codicon-chevron-right": !isExpanded,
+							"codicon-chevron-down": isExpanded,
+						})}
+					/>
+				)}
+				<span className="flex-1 min-w-0 overflow-hidden break-words whitespace-normal">
+					<span className="block font-medium">{marketplaceMetadata?.name || server.name}</span>
+					{marketplaceMetadata?.description && (
+						<span className="block mt-0.5 text-xs text-description">{marketplaceMetadata.description}</span>
+					)}
+				</span>
+				{/* Collapsed view controls */}
+				{!server.error && (
+					<Button
+						disabled={server.status === "connecting" || isRestarting || server.disabled}
+						onClick={(e) => {
+							e.stopPropagation()
+							handleRestart()
+						}}
+						size="icon"
+						title="Restart Server"
+						variant="icon">
+						<RefreshCcwIcon />
+					</Button>
+				)}
+				{!server.error && hasTrashIcon && (
+					<Button
+						disabled={isDeleting}
+						onClick={(e) => {
+							e.stopPropagation()
+							handleDelete()
+						}}
+						size="icon"
+						title="Delete Server"
+						variant="icon">
+						<Trash2Icon />
+					</Button>
+				)}
+				{/* Toggle Switch */}
+				<Tooltip>
+					<TooltipTrigger asChild>
+						<div className="flex items-center gap-2">
+							<Switch
+								checked={!server.disabled}
+								disabled={isAlwaysEnabled}
+								key={server.name}
+								onClick={(e) => {
+									e.stopPropagation()
+									handleToggleMcpServer()
+								}}
+							/>
+							{isAlwaysEnabled && <i className="codicon codicon-lock text-description text-sm" />}
+						</div>
+					</TooltipTrigger>
+					<TooltipContent className="max-w-xs" hidden={!isAlwaysEnabled} side="top">
+						This server can't be disabled because it is enabled by your organization
+					</TooltipContent>
+				</Tooltip>
+				<div
+					className={cn("h-2 w-2 ml-0.5 rounded-full", {
+						"bg-success": server.status === "connected",
+						"bg-warning": server.status === "connecting",
+						"bg-error": server.status === "disconnected",
+					})}
+				/>
+			</div>
+
+			{server.error ? (
+				<div className="text-sm bg-text-block-background rounded-b-sm">
+					<div className="text-failed-icon mb-2 px-2.5 break-words">{server.error}</div>
+					{server.oauthRequired && server.oauthAuthStatus === "unauthenticated" ? (
+						<Button
+							className="m-2.5 mt-0 max-w-[calc(100%-20px)]"
+							onClick={(e) => {
+								e.stopPropagation()
+								McpServiceClient.authenticateMcpServer(StringRequest.create({ value: server.name }))
+							}}
+							variant="default">
+							Authenticate
+						</Button>
+					) : (
+						<Button
+							className="m-2.5 mt-0 max-w-[calc(100%-20px)]"
+							disabled={server.status === "connecting"}
+							onClick={handleRestart}
+							variant="secondary">
+							{server.status === "connecting" || isRestarting ? "Retrying..." : "Retry Connection"}
+						</Button>
+					)}
+
+					{!isRemoteManagedServer && (
+						<Button
+							className="m-2.5 mt-0 max-w-[calc(100%-20px)]"
+							disabled={isDeleting}
+							onClick={handleDelete}
+							variant="danger">
+							{isDeleting ? "Deleting..." : "Delete Server"}
+						</Button>
+					)}
+				</div>
+			) : (
+				isExpanded && (
+					<div className="bg-text-block-background p-2.5 pt-0 text-sm rounded-b-sm">
+						<VSCodePanels>
+							<VSCodePanelTab id="tools">Tools ({server.tools?.length || 0})</VSCodePanelTab>
+							<VSCodePanelTab id="resources">
+								Resources ({[...(server.resourceTemplates || []), ...(server.resources || [])].length || 0})
+							</VSCodePanelTab>
+							<VSCodePanelTab id="prompts">Prompts ({server.prompts?.length || 0})</VSCodePanelTab>
+
+							<VSCodePanelView id="tools-view">
+								{server.tools && server.tools.length > 0 ? (
+									<div className="flex flex-col gap-2 w-full pt-2">
+										{server.name && autoApprovalSettings.actions.useMcp && (
+											<VSCodeCheckbox
+												checked={server.tools.every((tool) => tool.autoApprove)}
+												className="mb-1 text-xs"
+												data-tool="all-tools"
+												onChange={handleAutoApproveChange}>
+												Auto-approve all tools
+											</VSCodeCheckbox>
+										)}
+										{server.tools.map((tool) => (
+											<McpToolRow key={tool.name} serverName={server.name} tool={tool} />
+										))}
+									</div>
+								) : (
+									<div className="text-description py-2.5">No tools found</div>
+								)}
+							</VSCodePanelView>
+
+							<VSCodePanelView id="resources-view">
+								{(server.resources && server.resources.length > 0) ||
+								(server.resourceTemplates && server.resourceTemplates.length > 0) ? (
+									<div className="flex flex-col gap-2 w-full pt-2">
+										{[...(server.resourceTemplates || []), ...(server.resources || [])].map((item) => (
+											<McpResourceRow
+												item={item}
+												key={"uriTemplate" in item ? item.uriTemplate : item.uri}
+											/>
+										))}
+									</div>
+								) : (
+									<div className="py-2.5 text-description">No resources found</div>
+								)}
+							</VSCodePanelView>
+
+							<VSCodePanelView id="prompts-view">
+								{server.prompts && server.prompts.length > 0 ? (
+									<div
+										style={{
+											display: "flex",
+											flexDirection: "column",
+											gap: "8px",
+											width: "100%",
+											paddingTop: "8px",
+										}}>
+										{server.prompts.map((prompt) => (
+											<McpPromptRow key={prompt.name} prompt={prompt} serverName={server.name} />
+										))}
+									</div>
+								) : (
+									<div
+										style={{
+											padding: "10px 0",
+											color: "var(--vscode-descriptionForeground)",
+										}}>
+										No prompts found
+									</div>
+								)}
+							</VSCodePanelView>
+						</VSCodePanels>
+
+						<div className="my-2.5 mx-1.5">
+							<label className="block mb-1 text-[13px]">Request Timeout</label>
+							<VSCodeDropdown className="w-full" onChange={handleTimeoutChange} value={timeoutValue}>
+								{TimeoutOptions}
+							</VSCodeDropdown>
+						</div>
+						<Button
+							className="w-[calc(100%-14px)] mt-1 mx-1.5 mb-3"
+							disabled={server.status === "connecting" || isRestarting || server.disabled}
+							onClick={handleRestart}
+							variant="secondary">
+							{server.status === "connecting" || isRestarting
+								? "Restarting..."
+								: server.disabled
+									? "Server Disabled"
+									: "Restart Server"}
+						</Button>
+
+						{!isRemoteManagedServer && (
+							<Button
+								className="w-[calc(100%-14px)] mt-1 mx-1.5 mb-3"
+								disabled={isDeleting}
+								onClick={handleDelete}
+								variant="danger">
+								{isDeleting ? "Deleting..." : "Delete Server"}
+							</Button>
+						)}
+					</div>
+				)
+			)}
+		</div>
+	)
+}
+
+export default ServerRow
diff --git a/apps/vscode/webview-ui/src/components/menu/Navbar.tsx b/apps/vscode/webview-ui/src/components/menu/Navbar.tsx
new file mode 100644
index 0000000..1b7e352
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/menu/Navbar.tsx
@@ -0,0 +1,90 @@
+import { IntentEvent } from "@shared/proto/cline/ui"
+import { HistoryIcon, PlusIcon, PuzzleIcon, SettingsIcon, UserCircleIcon } from "lucide-react"
+import { useMemo } from "react"
+import { Button } from "@/components/ui/button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { TaskServiceClient, UiServiceClient } from "@/services/grpc-client"
+import { useExtensionState } from "../../context/ExtensionStateContext"
+
+export const Navbar = () => {
+	const { navigateToHistory, navigateToSettings, navigateToAccount, navigateToMarketplace, navigateToChat } =
+		useExtensionState()
+
+	const SETTINGS_TABS = useMemo(
+		() => [
+			{
+				id: "chat",
+				name: "Chat",
+				tooltip: "New Task",
+				icon: PlusIcon,
+				navigate: () => {
+					UiServiceClient.trackIntent(
+						IntentEvent.create({
+							action: "new_task_clicked",
+							source: "navbar",
+						}),
+					).catch((error) => console.error("Failed to track new task click:", error))
+					// Close the current task, then navigate to the chat view
+					TaskServiceClient.clearTask({})
+						.catch((error) => {
+							console.error("Failed to clear task:", error)
+						})
+						.finally(() => navigateToChat())
+				},
+			},
+			{
+				id: "customize",
+				name: "Customize",
+				tooltip: "Customize",
+				icon: PuzzleIcon,
+				navigate: navigateToMarketplace,
+			},
+			{
+				id: "history",
+				name: "History",
+				tooltip: "History",
+				icon: HistoryIcon,
+				navigate: navigateToHistory,
+			},
+			{
+				id: "account",
+				name: "Account",
+				tooltip: "Account",
+				icon: UserCircleIcon,
+				navigate: navigateToAccount,
+			},
+			{
+				id: "settings",
+				name: "Settings",
+				tooltip: "Settings",
+				icon: SettingsIcon,
+				navigate: navigateToSettings,
+			},
+		],
+		[navigateToAccount, navigateToChat, navigateToHistory, navigateToMarketplace, navigateToSettings],
+	)
+
+	return (
+		<nav
+			className="flex-none inline-flex justify-end bg-transparent gap-2 mb-1 z-10 border-none items-center mr-4!"
+			id="cline-navbar-container">
+			{SETTINGS_TABS.map((tab) => (
+				<Tooltip key={`navbar-tooltip-${tab.id}`}>
+					<TooltipContent side="bottom">{tab.tooltip}</TooltipContent>
+					<TooltipTrigger asChild>
+						<Button
+							aria-label={tab.tooltip}
+							className="p-0 h-7"
+							data-testid={`tab-${tab.id}`}
+							key={`navbar-button-${tab.id}`}
+							onClick={() => tab.navigate()}
+							size="icon"
+							variant="icon">
+							<tab.icon className="stroke-1 [svg]:size-4" size={18} />
+						</Button>
+					</TooltipTrigger>
+				</Tooltip>
+			))}
+		</nav>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/onboarding/OnboardingView.tsx b/apps/vscode/webview-ui/src/components/onboarding/OnboardingView.tsx
new file mode 100644
index 0000000..9e22377
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/OnboardingView.tsx
@@ -0,0 +1,715 @@
+import { buildModelInfoNameMap, type ModelInfo, openAiModelInfoSafeDefaults, resolveClinePassModelInfo } from "@shared/api"
+import { StringRequest } from "@shared/proto/cline/common"
+import type { OnboardingModel, OnboardingModelGroup, OpenRouterModelInfo } from "@shared/proto/index.cline"
+import { VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { AlertCircleIcon, CircleCheckIcon, CircleIcon, ListIcon, LoaderCircleIcon, ZapIcon } from "lucide-react"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import ClineLogoWhite from "@/assets/ClineLogoWhite"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { Item, ItemContent, ItemDescription, ItemHeader, ItemMedia, ItemTitle } from "@/components/ui/item"
+import { CLINE_PASS_FEATURE_FLAG } from "@/constants/featureFlags"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useHasFeatureFlag } from "@/hooks/useFeatureFlag"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { cn } from "@/lib/utils"
+import { AccountServiceClient, StateServiceClient, UiServiceClient } from "@/services/grpc-client"
+import ApiConfigurationSection from "../settings/sections/ApiConfigurationSection"
+import { useApiConfigurationHandlers } from "../settings/utils/useApiConfigurationHandlers"
+import WelcomeView from "../welcome/WelcomeView"
+import { setPendingClinePassSubscribe } from "./clinePassSubscribe"
+import {
+	CLINEPASS_GROUP,
+	getCapabilities,
+	getClineUIOnboardingGroups,
+	getOnboardingGroupDisplayName,
+	getPriceRange,
+	getSpeedLabel,
+	type OnboardingModelsByGroup,
+} from "./data-models"
+import { getUserTypeSelections, NEW_USER_TYPE, STEP_CONFIG } from "./data-steps"
+import { useOnboardingModels } from "./useOnboardingModels"
+
+type OnboardingPage =
+	| "user_type"
+	| "free_model_selection"
+	| "power_model_selection"
+	| "byok_provider_config"
+	| "account_creation_wait"
+	| "legacy_welcome_fallback"
+
+const getOnboardingPage = (step: number, userType: NEW_USER_TYPE): OnboardingPage => {
+	if (step === 0) {
+		return "user_type"
+	}
+	if (step === 2) {
+		return "account_creation_wait"
+	}
+	if (userType === NEW_USER_TYPE.POWER) {
+		return "power_model_selection"
+	}
+	if (userType === NEW_USER_TYPE.BYOK) {
+		return "byok_provider_config"
+	}
+	return "free_model_selection"
+}
+
+type ModelSelectionProps = {
+	userType: NEW_USER_TYPE.FREE | NEW_USER_TYPE.POWER | NEW_USER_TYPE.CLINE_PASS
+	selectedModelId: string
+	onSelectModel: (modelId: string) => void
+	onboardingModels: OnboardingModelsByGroup
+	models?: Record<string, ModelInfo>
+	searchTerm: string
+	setSearchTerm: (term: string) => void
+}
+
+function getModelGroupKey(userType: ModelSelectionProps["userType"]): keyof OnboardingModelsByGroup {
+	if (userType === NEW_USER_TYPE.CLINE_PASS) {
+		return "clinePass"
+	}
+	return userType === NEW_USER_TYPE.FREE ? "free" : "power"
+}
+
+const ModelSelection = ({
+	userType,
+	selectedModelId,
+	onSelectModel,
+	models,
+	searchTerm,
+	setSearchTerm,
+	onboardingModels,
+}: ModelSelectionProps) => {
+	const isClinePass = userType === NEW_USER_TYPE.CLINE_PASS
+	const modelGroups = onboardingModels[getModelGroupKey(userType)]
+	// ClinePass costs are covered by the subscription, so prices are hidden.
+	const hidePrice = isClinePass
+
+	const searchedModels = useMemo(() => {
+		if (!models || !searchTerm) {
+			return []
+		}
+		const flattenedModels = modelGroups.flatMap((g) => g.models.map((m) => m.id))
+		// Filter out embedding models and already listed models
+		const filtered = Object.entries(models).filter(
+			([id, _info]) => !id.includes("embedding") && !flattenedModels.includes(id) && id.includes(searchTerm.toLowerCase()),
+		)
+		return filtered.slice(0, 5) // Return the first 5 models
+	}, [models, modelGroups, searchTerm])
+
+	// Model Item Component
+	const ModelItem = ({ id, model, isSelected }: { id: string; model: OnboardingModel; isSelected: boolean }) => {
+		return (
+			<Item
+				className={cn("cursor-pointer hover:cursor-pointer", {
+					"bg-input-background/80 border border-button-background": isSelected,
+				})}
+				key={id}
+				onClick={() => onSelectModel(id)}
+				variant="outline">
+				<ItemHeader className="flex flex-col w-full align-baseline">
+					<ItemTitle className="flex w-full justify-between">
+						<span className="font-semibold">{model.name || id}</span>
+						{model.badge ? (
+							<Badge className="capitalize" variant="info">
+								{model.badge}
+							</Badge>
+						) : !hidePrice && model.info ? (
+							<Badge>{getPriceRange(model.info)}</Badge>
+						) : null}
+					</ItemTitle>
+					{isSelected && model.info && (
+						<ItemDescription>
+							<span className="text-foreground/70 text-sm">Support: </span>
+							<span className="text-foreground text-sm">{getCapabilities(model.info).join(", ")}</span>
+						</ItemDescription>
+					)}
+				</ItemHeader>
+				{model.badge && isSelected && (
+					<ItemContent className="w-full border-t border-muted-foreground pt-5 text-ellipsis overflow-hidden">
+						<div className="flex flex-col gap-3">
+							<div className="inline-flex gap-1 [&_svg]:stroke-success [&_svg]:size-3 items-center text-sm">
+								<ZapIcon />
+								<span>Speed: </span>
+								<span className="text-foreground/70">{getSpeedLabel(model.latency)}</span>
+							</div>
+							{model.info && (
+								<div className="flex w-full justify-between">
+									<div className="inline-flex gap-1 [&_svg]:stroke-foreground [&_svg]:size-3 items-center text-sm">
+										<ListIcon />
+										<span>Context: </span>
+										<span className="text-foreground/70">{(model?.info.contextWindow || 0) / 1000}k</span>
+									</div>
+									{!hidePrice && <Badge>{getPriceRange(model.info)}</Badge>}
+								</div>
+							)}
+						</div>
+					</ItemContent>
+				)}
+			</Item>
+		)
+	}
+
+	// No curated ClinePass models available: show an empty state rather than other models.
+	if (isClinePass && modelGroups.length === 0) {
+		return (
+			<div className="flex w-full max-w-lg flex-col items-center justify-center my-8 px-2 text-center">
+				<p className="text-foreground text-sm m-0">No ClinePass models are available right now.</p>
+				<p className="text-foreground/70 text-sm mt-1">Please choose another option or try again later.</p>
+			</div>
+		)
+	}
+
+	return (
+		<div className="flex flex-col w-full items-center px-2">
+			<div className="flex w-full max-w-lg flex-col gap-6 my-4">
+				{modelGroups.map((group) => {
+					const isClinePassGroup = group.group === CLINEPASS_GROUP
+					return (
+						<div className="flex flex-col gap-3" key={group.group}>
+							<h4
+								className={cn(
+									"text-sm font-bold text-foreground/70 mb-2",
+									isClinePassGroup ? "normal-case" : "uppercase",
+								)}>
+								{getOnboardingGroupDisplayName(group.group)}
+							</h4>
+							{group.models.map((model) => (
+								<ModelItem id={model.id} isSelected={selectedModelId === model.id} key={model.id} model={model} />
+							))}
+						</div>
+					)
+				})}
+			</div>
+
+			{/* SEARCH MODEL — hidden for ClinePass, whose selection is constrained to the curated list. */}
+			{!isClinePass && (
+				<div className="flex w-full max-w-lg flex-col gap-6 my-4 border-t border-muted-foreground">
+					<div className="flex flex-col gap-3 mt-6" key="search-results">
+						<h4 className="text-sm font-bold text-foreground/70 uppercase mb-2">other options</h4>
+						<Input
+							autoFocus={false}
+							className="focus-visible:border-button-background"
+							onChange={(e) => {
+								if (!e.target?.value) {
+									onSelectModel("")
+								}
+								setSearchTerm(e.target.value)
+							}}
+							onClick={() => onSelectModel("")}
+							placeholder="Search model..."
+							type="search"
+							value={searchTerm}
+						/>
+						<div className="w-full flex flex-col gap-3">
+							{searchTerm &&
+								searchedModels.map(([id, info]) => {
+									const isSelected = selectedModelId === id
+									const modelInfo: OpenRouterModelInfo = {
+										name: info.name,
+										maxTokens: info.maxTokens,
+										contextWindow: info.contextWindow,
+										supportsImages: info.supportsImages,
+										supportsPromptCache: info.supportsPromptCache,
+										inputPrice: info.inputPrice,
+										outputPrice: info.outputPrice,
+										cacheWritesPrice: info.cacheWritesPrice,
+										cacheReadsPrice: info.cacheReadsPrice,
+										description: info.description,
+										supportsGlobalEndpoint: info.supportsGlobalEndpoint,
+										thinkingConfig: info.thinkingConfig
+											? {
+													maxBudget: info.thinkingConfig.maxBudget,
+													outputPrice: info.thinkingConfig.outputPrice,
+													outputPriceTiers: info.thinkingConfig.outputPriceTiers || [],
+												}
+											: undefined,
+										tiers: info.tiers || [],
+									}
+									const onboardingModel: OnboardingModel = {
+										id,
+										name: info.name || id,
+										info: modelInfo,
+										score: 0,
+										latency: 0,
+										badge: "",
+										group: "",
+									}
+									return <ModelItem id={id} isSelected={isSelected} key={id} model={onboardingModel} />
+								})}
+							{searchTerm.length > 0 && searchedModels.length === 0 && (
+								<p className="px-1 mt-1 text-sm text-foreground/70">No result found for "{searchTerm}"</p>
+							)}
+						</div>
+					</div>
+				</div>
+			)}
+		</div>
+	)
+}
+
+type UserTypeSelectionProps = {
+	userType: NEW_USER_TYPE | undefined
+	onSelectUserType: (type: NEW_USER_TYPE) => void
+	userTypeSelections: ReturnType<typeof getUserTypeSelections>
+}
+
+const UserTypeSelectionStep = ({ userType, onSelectUserType, userTypeSelections }: UserTypeSelectionProps) => (
+	<div className="flex flex-col w-full items-center">
+		<div className="flex w-full max-w-lg flex-col gap-3 my-2">
+			{userTypeSelections.map((option) => {
+				const isSelected = userType === option.type
+
+				return (
+					<Item
+						className={cn("cursor-pointer hover:cursor-pointer w-full", {
+							"bg-input-background/50 border border-input-foreground/30": isSelected,
+						})}
+						key={option.type}
+						onClick={() => onSelectUserType(option.type)}>
+						<ItemMedia className="[&_svg]:stroke-button-background" variant="icon">
+							{isSelected ? <CircleCheckIcon className="stroke-1.5" /> : <CircleIcon className="stroke-1" />}
+						</ItemMedia>
+						<ItemContent className="w-full">
+							<ItemTitle>{option.title}</ItemTitle>
+							<ItemDescription>
+								{option.description}
+								{option.learnMoreUrl && (
+									<>
+										{" "}
+										<VSCodeLink
+											className="inline"
+											onClick={(e) => {
+												e.stopPropagation()
+												UiServiceClient.openUrl(
+													StringRequest.create({ value: option.learnMoreUrl }),
+												).catch((err) => console.error("Failed to open learn more link:", err))
+											}}
+											style={{ fontSize: "inherit" }}>
+											Learn more
+										</VSCodeLink>
+									</>
+								)}
+							</ItemDescription>
+						</ItemContent>
+					</Item>
+				)
+			})}
+		</div>
+	</div>
+)
+
+type OnboardingStepContentProps = {
+	step: number
+	userType: NEW_USER_TYPE | undefined
+	selectedModelId: string
+	onSelectUserType: (type: NEW_USER_TYPE) => void
+	onSelectModel: (modelId: string) => void
+	searchTerm: string
+	setSearchTerm: (term: string) => void
+	models?: Record<string, ModelInfo>
+	onboardingModels: OnboardingModelsByGroup
+	userTypeSelections: ReturnType<typeof getUserTypeSelections>
+}
+
+const OnboardingStepContent = ({
+	step,
+	userType,
+	selectedModelId,
+	onSelectUserType,
+	onSelectModel,
+	searchTerm,
+	setSearchTerm,
+	models,
+	onboardingModels,
+	userTypeSelections,
+}: OnboardingStepContentProps) => {
+	if (step === 0) {
+		return (
+			<UserTypeSelectionStep
+				onSelectUserType={onSelectUserType}
+				userType={userType}
+				userTypeSelections={userTypeSelections}
+			/>
+		)
+	}
+	if (step === 2) {
+		return null
+	}
+	if (userType === NEW_USER_TYPE.FREE || userType === NEW_USER_TYPE.POWER || userType === NEW_USER_TYPE.CLINE_PASS) {
+		return (
+			<ModelSelection
+				models={models}
+				onboardingModels={onboardingModels}
+				onSelectModel={onSelectModel}
+				searchTerm={searchTerm}
+				selectedModelId={selectedModelId}
+				setSearchTerm={setSearchTerm}
+				userType={userType}
+			/>
+		)
+	}
+	// userType === NEW_USER_TYPE.BYOK
+	return <ApiConfigurationSection />
+}
+
+const OnboardingViewContent = ({ onboardingModels }: { onboardingModels: OnboardingModelGroup }) => {
+	const { handleFieldsChange } = useApiConfigurationHandlers()
+	const { openRouterModels, hideSettings, hideAccount, setShowWelcome } = useExtensionState()
+	const isClinePassEnabled = useHasFeatureFlag(CLINE_PASS_FEATURE_FLAG)
+	const { models: clineModels } = useProviderModels("cline")
+	const { commitSelection } = useProviderConfig("cline")
+	const loginAttemptIdRef = useRef(0)
+	const loginLoadingTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+	const viewedPageTelemetryKeysRef = useRef<Set<string>>(new Set())
+
+	const [stepNumber, setStepNumber] = useState(0)
+	const [isActionLoading, setIsActionLoading] = useState(false)
+	const [userType, setUserType] = useState<NEW_USER_TYPE>(NEW_USER_TYPE.FREE)
+
+	const [selectedModelId, setSelectedModelId] = useState("")
+	const [searchTerm, setSearchTerm] = useState("")
+
+	const models = useMemo(() => getClineUIOnboardingGroups(onboardingModels), [onboardingModels])
+	// Gate on models too, so a fallback/empty response can't route flagged users into the dead-end empty step.
+	const showClinePass = isClinePassEnabled && models.clinePass.length > 0
+	const userTypeSelections = useMemo(() => getUserTypeSelections(showClinePass), [showClinePass])
+	// ClinePass model IDs (e.g. "cline-pass/glm-5.2") aren't keyed in openRouterModels,
+	// so resolve their info via the slug-based lookup used by ClinePassProvider.
+	const openRouterModelsByName = useMemo(() => buildModelInfoNameMap(openRouterModels), [openRouterModels])
+	const onboardingModelById = useMemo(() => {
+		return new Map(onboardingModels.models.map((model) => [model.id, model]))
+	}, [onboardingModels])
+	const currentPage = useMemo(() => getOnboardingPage(stepNumber, userType), [stepNumber, userType])
+
+	useEffect(() => {
+		setSearchTerm("")
+		const groupKey = userType === NEW_USER_TYPE.CLINE_PASS ? "clinePass" : userType === NEW_USER_TYPE.POWER ? "power" : "free"
+		// ClinePass must stay within its curated list (never fall back to a free/OpenRouter model
+		// under the cline-pass provider). Free/Frontier fall back to free if their group is empty.
+		const modelGroup = userType === NEW_USER_TYPE.CLINE_PASS ? models[groupKey][0] : (models[groupKey][0] ?? models.free[0])
+		const userGroupInitModel = modelGroup?.models[0]
+		setSelectedModelId(userGroupInitModel?.id ?? "")
+	}, [userType, models])
+
+	useEffect(() => {
+		return () => {
+			if (loginLoadingTimeoutRef.current) {
+				clearTimeout(loginLoadingTimeoutRef.current)
+			}
+		}
+	}, [])
+
+	useEffect(() => {
+		const telemetryKey = `${stepNumber}:${currentPage}`
+		if (viewedPageTelemetryKeysRef.current.has(telemetryKey)) {
+			return
+		}
+		viewedPageTelemetryKeysRef.current.add(telemetryKey)
+		StateServiceClient.captureOnboardingProgress({
+			step: stepNumber,
+			action: "page_viewed",
+			page: currentPage,
+			userType: currentPage === "user_type" ? undefined : userType,
+			modelSelected: selectedModelId || undefined,
+		})
+	}, [currentPage, selectedModelId, stepNumber, userType])
+
+	const onUserTypeClick = useCallback((selectedUserType: NEW_USER_TYPE) => {
+		setUserType(selectedUserType)
+		StateServiceClient.captureOnboardingProgress({
+			step: 0,
+			action: "option_selected",
+			page: "user_type",
+			userType: selectedUserType,
+		})
+	}, [])
+
+	const onModelClick = useCallback(
+		(modelSelected: string) => {
+			setSelectedModelId(modelSelected)
+			if (!modelSelected) {
+				return
+			}
+			StateServiceClient.captureOnboardingProgress({
+				step: stepNumber,
+				action: "model_selected",
+				page: currentPage,
+				userType,
+				modelSelected,
+			})
+		},
+		[currentPage, stepNumber, userType],
+	)
+
+	const finishOnboarding = useCallback(
+		async (updateModelId: boolean, step: number) => {
+			const modelSelected = (updateModelId && selectedModelId) || undefined
+			// Guard: never save a non-ClinePass model id under the cline-pass provider.
+			const isClinePassModel = selectedModelId.startsWith("cline-pass/")
+			if (modelSelected) {
+				if (userType === NEW_USER_TYPE.CLINE_PASS && isClinePassModel) {
+					const clinePassModelInfo = resolveClinePassModelInfo(selectedModelId, openRouterModelsByName)
+					await handleFieldsChange({
+						planModeClinePassModelId: selectedModelId,
+						actModeClinePassModelId: selectedModelId,
+						planModeClinePassModelInfo: clinePassModelInfo,
+						actModeClinePassModelInfo: clinePassModelInfo,
+						planModeApiProvider: "cline-pass",
+						actModeApiProvider: "cline-pass",
+					})
+				} else if (userType !== NEW_USER_TYPE.CLINE_PASS) {
+					const selectedModelInfo = clineModels[selectedModelId] ??
+						onboardingModelById.get(selectedModelId)?.info ?? {
+							...openAiModelInfoSafeDefaults,
+							name: selectedModelId,
+						}
+
+					await Promise.all([
+						commitSelection("plan", {
+							providerId: "cline",
+							modelId: selectedModelId,
+							modelInfo: selectedModelInfo,
+						}),
+						commitSelection("act", {
+							providerId: "cline",
+							modelId: selectedModelId,
+							modelInfo: selectedModelInfo,
+						}),
+					])
+
+					await handleFieldsChange({
+						planModeClineModelId: selectedModelId,
+						actModeClineModelId: selectedModelId,
+						planModeClineModelInfo: selectedModelInfo,
+						actModeClineModelInfo: selectedModelInfo,
+						planModeApiProvider: "cline",
+						actModeApiProvider: "cline",
+					})
+				} else {
+					// ClinePass selected but the id isn't a cline-pass/ model: skip the write
+					// (avoids a bad provider config) and log so the no-op is observable.
+					console.error(`Skipped ClinePass provider setup: unexpected model id "${selectedModelId}"`)
+				}
+			}
+
+			await StateServiceClient.setWelcomeViewCompleted({ value: true }).catch(() => {})
+			setShowWelcome(false)
+			hideAccount()
+			hideSettings()
+			StateServiceClient.captureOnboardingProgress({
+				step,
+				action: "completed",
+				page: getOnboardingPage(step, userType),
+				userType,
+				modelSelected,
+				completed: true,
+			})
+		},
+		[
+			hideAccount,
+			hideSettings,
+			handleFieldsChange,
+			selectedModelId,
+			openRouterModels,
+			openRouterModelsByName,
+			clineModels,
+			onboardingModelById,
+			commitSelection,
+			setShowWelcome,
+			userType,
+		],
+	)
+
+	const loginAndFinishOnboarding = useCallback(
+		async (updateModelId: boolean, step: number) => {
+			const loginAttemptId = loginAttemptIdRef.current + 1
+			loginAttemptIdRef.current = loginAttemptId
+
+			if (loginLoadingTimeoutRef.current) {
+				clearTimeout(loginLoadingTimeoutRef.current)
+			}
+
+			setIsActionLoading(true)
+			// Allow the user to re-attempt after 10s
+			loginLoadingTimeoutRef.current = setTimeout(() => {
+				if (loginAttemptIdRef.current === loginAttemptId) {
+					setIsActionLoading(false)
+				}
+			}, 10_000)
+
+			await AccountServiceClient.accountLoginClicked({})
+				.catch((error) => {
+					console.error("Failed to log in during onboarding:", error)
+				})
+				.finally(() => {
+					if (loginAttemptIdRef.current !== loginAttemptId) {
+						return
+					}
+					if (loginLoadingTimeoutRef.current) {
+						clearTimeout(loginLoadingTimeoutRef.current)
+						loginLoadingTimeoutRef.current = null
+					}
+				})
+
+			await finishOnboarding(updateModelId, step)
+			setIsActionLoading(false)
+		},
+		[finishOnboarding],
+	)
+
+	const handleFooterAction = useCallback(
+		async (action: "signin" | "next" | "back" | "done" | "signup") => {
+			const captureNavigation = (telemetryAction: string, destinationStep?: number) => {
+				StateServiceClient.captureOnboardingProgress({
+					step: stepNumber,
+					action: telemetryAction,
+					page: currentPage,
+					userType,
+					modelSelected: selectedModelId || undefined,
+					destinationStep,
+					destinationPage: destinationStep === undefined ? undefined : getOnboardingPage(destinationStep, userType),
+				})
+			}
+
+			switch (action) {
+				case "signup":
+					// ClinePass: record the intent so App opens the subscription page once auth
+					// completes (App outlives this view, which unmounts on auth). Login flow unchanged.
+					setPendingClinePassSubscribe(userType === NEW_USER_TYPE.CLINE_PASS)
+					captureNavigation("signup_clicked", stepNumber + 1)
+					setStepNumber(stepNumber + 1)
+					await loginAndFinishOnboarding(true, stepNumber + 1)
+					break
+				case "signin":
+					setPendingClinePassSubscribe(false)
+					captureNavigation("signin_clicked")
+					await loginAndFinishOnboarding(true, stepNumber)
+					break
+				case "next":
+					captureNavigation("continued", stepNumber + 1)
+					setStepNumber(stepNumber + 1)
+					break
+				case "back":
+					// Abandon any pending ClinePass subscription redirect when the user goes back.
+					setPendingClinePassSubscribe(false)
+					captureNavigation("back_clicked", stepNumber - 1)
+					setStepNumber(stepNumber - 1)
+					break
+				case "done":
+					await finishOnboarding(false, stepNumber)
+					break
+			}
+		},
+		[stepNumber, currentPage, userType, selectedModelId, finishOnboarding, loginAndFinishOnboarding, setShowWelcome],
+	)
+
+	const stepDisplayInfo = useMemo(() => {
+		const step = stepNumber === 0 || stepNumber === 2 ? STEP_CONFIG[stepNumber] : null
+		const title = step ? step.title : userType ? STEP_CONFIG[userType].title : STEP_CONFIG[0].title
+		const description = step ? step.description : null
+		const buttons = step ? step.buttons : userType ? STEP_CONFIG[userType].buttons : STEP_CONFIG[0].buttons
+		return { title, description, buttons }
+	}, [stepNumber, userType])
+
+	return (
+		<div className="fixed inset-0 p-0 flex flex-col w-full">
+			<div className="h-full px-5 xs:mx-10 overflow-auto flex flex-col gap-4 items-center justify-center">
+				<ClineLogoWhite className="size-16 flex-shrink-0" />
+				<h2 className="text-lg font-semibold p-0 flex-shrink-0">{stepDisplayInfo.title}</h2>
+				{stepNumber === 2 && (
+					<div className="flex w-full max-w-lg flex-col gap-6 my-4 items-center ">
+						<LoaderCircleIcon className="animate-spin" />
+					</div>
+				)}
+				{stepDisplayInfo.description && (
+					<p className="text-foreground text-sm text-center m-0 p-0 flex-shrink-0">{stepDisplayInfo.description}</p>
+				)}
+
+				<div className="flex-1 w-full flex max-w-lg overflow-y-auto min-h-0">
+					<OnboardingStepContent
+						models={Object.keys(clineModels).length > 0 ? clineModels : openRouterModels}
+						onboardingModels={models}
+						onSelectModel={onModelClick}
+						onSelectUserType={onUserTypeClick}
+						searchTerm={searchTerm}
+						selectedModelId={selectedModelId}
+						setSearchTerm={setSearchTerm}
+						step={stepNumber}
+						userType={userType}
+						userTypeSelections={userTypeSelections}
+					/>
+				</div>
+
+				<footer className="flex w-full max-w-lg flex-col gap-3 my-2 px-2 overflow-hidden flex-shrink-0">
+					{stepDisplayInfo.buttons.map((btn) => {
+						// Block ClinePass signup when no ClinePass model is selected (e.g. empty list).
+						const isLoginAction = btn.action === "signin" || btn.action === "signup"
+						const showSpinner = isActionLoading && isLoginAction
+						const disabled =
+							isActionLoading ||
+							(btn.action === "signup" && userType === NEW_USER_TYPE.CLINE_PASS && !selectedModelId)
+						return (
+							<Button
+								className={`w-full rounded-xs ${isActionLoading ? "animate-pulse" : ""}`}
+								disabled={disabled}
+								key={btn.text}
+								onClick={() => handleFooterAction(btn.action)}
+								variant={btn.variant}>
+								{showSpinner && <LoaderCircleIcon className="mr-2 size-4 animate-spin" />}
+								{showSpinner ? "Waiting for sign in..." : btn.text}
+							</Button>
+						)
+					})}
+
+					{isActionLoading && stepNumber !== 2 && (
+						<div className="items-center justify-center flex text-sm text-foreground/70 text-pretty text-center">
+							Complete sign in in your browser. We'll continue automatically once you're done.
+						</div>
+					)}
+
+					{stepNumber !== 2 && (
+						<div className="items-center justify-center flex text-sm text-foreground gap-2 mb-3 text-pretty">
+							<AlertCircleIcon className="shrink-0 size-2" /> You can change this later in settings
+						</div>
+					)}
+				</footer>
+			</div>
+		</div>
+	)
+}
+
+const OnboardingWelcomeFallback = () => {
+	useEffect(() => {
+		const page: OnboardingPage = "legacy_welcome_fallback"
+		StateServiceClient.captureOnboardingProgress({
+			step: 0,
+			action: "fallback_welcome_viewed",
+			page,
+		})
+	}, [])
+
+	return <WelcomeView />
+}
+
+const OnboardingView = () => {
+	const { status, models } = useOnboardingModels()
+
+	if (status === "loading") {
+		return (
+			<div className="fixed inset-0 flex items-center justify-center">
+				<LoaderCircleIcon className="animate-spin" />
+			</div>
+		)
+	}
+
+	if (status === "empty") {
+		return <OnboardingWelcomeFallback />
+	}
+
+	return <OnboardingViewContent onboardingModels={models} />
+}
+
+export default OnboardingView
diff --git a/apps/vscode/webview-ui/src/components/onboarding/__tests__/data-models.test.ts b/apps/vscode/webview-ui/src/components/onboarding/__tests__/data-models.test.ts
new file mode 100644
index 0000000..98582c2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/__tests__/data-models.test.ts
@@ -0,0 +1,91 @@
+import type { OnboardingModel, OnboardingModelGroup } from "@shared/proto/cline/state"
+import { describe, expect, it } from "vitest"
+import {
+	CLINEPASS_GROUP,
+	getClineUIOnboardingGroups,
+	getOnboardingGroupDisplayName,
+	getRecommendedModelsData,
+} from "../data-models"
+
+function model(id: string, group: string): OnboardingModel {
+	return {
+		id,
+		name: id,
+		group,
+		badge: "",
+		score: 0,
+		latency: 0,
+		info: undefined,
+	} as OnboardingModel
+}
+
+function groupOf(models: OnboardingModel[]): OnboardingModelGroup {
+	return { models } as OnboardingModelGroup
+}
+
+describe("getClineUIOnboardingGroups", () => {
+	it("buckets ClinePass models into the clinePass group", () => {
+		const result = getClineUIOnboardingGroups(
+			groupOf([
+				model("cline-pass/glm-5.2", CLINEPASS_GROUP),
+				model("free-model", "free"),
+				model("anthropic/claude", "frontier"),
+				model("z-ai/glm", "open source"),
+			]),
+		)
+
+		expect(result.clinePass).toHaveLength(1)
+		expect(result.clinePass[0].group).toBe(CLINEPASS_GROUP)
+		expect(result.clinePass[0].models.map((m) => m.id)).toEqual(["cline-pass/glm-5.2"])
+		expect(result.free[0].models.map((m) => m.id)).toEqual(["free-model"])
+		expect(result.power.flatMap((g) => g.models.map((m) => m.id))).toEqual(["anthropic/claude", "z-ai/glm"])
+	})
+
+	it("does not bucket cline-pass ids without a ClinePass group label", () => {
+		const result = getClineUIOnboardingGroups(groupOf([model("cline-pass/glm-5.2", "frontier")]))
+
+		expect(result.clinePass).toEqual([])
+	})
+
+	it("returns an empty clinePass group when no ClinePass models are present", () => {
+		const result = getClineUIOnboardingGroups(groupOf([model("free-model", "free")]))
+		expect(result.clinePass).toEqual([])
+	})
+})
+
+describe("getRecommendedModelsData", () => {
+	it("includes ClinePass-only responses without depending on feature-flag timing", () => {
+		const result = getRecommendedModelsData({
+			recommended: [],
+			free: [],
+			clinePass: [{ id: "cline-pass/glm-5.2", name: "GLM 5.1", description: "", tags: [] }],
+		})
+
+		expect(result?.clinePass.map((model) => model.id)).toEqual(["cline-pass/glm-5.2"])
+	})
+
+	it("keeps classic recommended/free responses and ClinePass responses", () => {
+		const result = getRecommendedModelsData({
+			recommended: [{ id: "anthropic/claude", name: "Claude", description: "", tags: [] }],
+			free: [{ id: "free-model", name: "Free", description: "", tags: [] }],
+			clinePass: [{ id: "cline-pass/glm-5.2", name: "GLM 5.1", description: "", tags: [] }],
+		})
+
+		expect(result?.recommended.map((model) => model.id)).toEqual(["anthropic/claude"])
+		expect(result?.free.map((model) => model.id)).toEqual(["free-model"])
+		expect(result?.clinePass.map((model) => model.id)).toEqual(["cline-pass/glm-5.2"])
+	})
+
+	it("returns undefined when every recommended bucket is empty", () => {
+		const result = getRecommendedModelsData({ recommended: [], free: [], clinePass: [] })
+
+		expect(result).toBeUndefined()
+	})
+})
+
+describe("onboarding display labels", () => {
+	it("renders the canonical ClinePass group as a user-facing product name", () => {
+		expect(getOnboardingGroupDisplayName(CLINEPASS_GROUP)).toBe("ClinePass")
+		expect(getOnboardingGroupDisplayName("frontier")).toBe("frontier")
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/onboarding/__tests__/data-steps.test.ts b/apps/vscode/webview-ui/src/components/onboarding/__tests__/data-steps.test.ts
new file mode 100644
index 0000000..a4bca73
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/__tests__/data-steps.test.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest"
+import { getUserTypeSelections, NEW_USER_TYPE } from "../data-steps"
+
+describe("getUserTypeSelections", () => {
+	it("omits the ClinePass option when no ClinePass models are available", () => {
+		const selections = getUserTypeSelections(false)
+		expect(selections.map((s) => s.type)).toEqual([NEW_USER_TYPE.FREE, NEW_USER_TYPE.POWER, NEW_USER_TYPE.BYOK])
+		expect(selections.some((s) => s.type === NEW_USER_TYPE.CLINE_PASS)).toBe(false)
+	})
+
+	it("inserts ClinePass right after the free option when ClinePass models are available", () => {
+		const selections = getUserTypeSelections(true)
+		// Free stays first (and remains the default selection); ClinePass is the
+		// recommended-but-optional second choice.
+		expect(selections[0]?.type).toBe(NEW_USER_TYPE.FREE)
+		expect(selections[1]?.type).toBe(NEW_USER_TYPE.CLINE_PASS)
+		expect(selections.map((s) => s.type)).toEqual([
+			NEW_USER_TYPE.FREE,
+			NEW_USER_TYPE.CLINE_PASS,
+			NEW_USER_TYPE.POWER,
+			NEW_USER_TYPE.BYOK,
+		])
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/onboarding/clinePassSubscribe.ts b/apps/vscode/webview-ui/src/components/onboarding/clinePassSubscribe.ts
new file mode 100644
index 0000000..47f20c5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/clinePassSubscribe.ts
@@ -0,0 +1,32 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { UiServiceClient } from "@/services/grpc-client"
+
+// ClinePass subscription signup page in the dashboard (requires auth).
+const CLINE_PASS_SUBSCRIBE_PATH = "/onboarding/individual-plan"
+const CLINE_PASS_USAGE_PATH = "/dashboard/subscription"
+export const DEFAULT_APP_BASE_URL = "https://app.cline.bot"
+
+// Module-level so the pending intent survives OnboardingView unmounting: handleAuthCallback
+// completes the welcome view (unmounting onboarding) before it pushes the auth-status update
+// that sets clineUser, so this must outlive the component to fire the redirect.
+let pendingClinePassSubscribe = false
+
+export function setPendingClinePassSubscribe(pending: boolean): void {
+	pendingClinePassSubscribe = pending
+}
+
+// Opens the ClinePass subscription page once a pending signup is authenticated (guarded so it fires once).
+export function openClinePassSubscriptionIfPending(appBaseUrl: string | undefined): void {
+	if (!pendingClinePassSubscribe) {
+		return
+	}
+	pendingClinePassSubscribe = false
+	const baseUrl = appBaseUrl || DEFAULT_APP_BASE_URL
+	UiServiceClient.openUrl(StringRequest.create({ value: `${baseUrl}${CLINE_PASS_SUBSCRIBE_PATH}` })).catch((err) =>
+		console.error("Failed to open ClinePass subscription page:", err),
+	)
+}
+
+export function buildClinePassSubscriptionPageUrl(appBaseUrl: string | undefined): string {
+	return new URL(CLINE_PASS_USAGE_PATH, appBaseUrl || DEFAULT_APP_BASE_URL).toString()
+}
diff --git a/apps/vscode/webview-ui/src/components/onboarding/data-models.ts b/apps/vscode/webview-ui/src/components/onboarding/data-models.ts
new file mode 100644
index 0000000..f899ff9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/data-models.ts
@@ -0,0 +1,113 @@
+import type { ClineRecommendedModel, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import type { OnboardingModel, OnboardingModelGroup } from "@shared/proto/cline/state"
+
+export const CLINEPASS_GROUP = "cline-pass"
+
+export interface RecommendedModelsData {
+	recommended: ClineRecommendedModel[]
+	free: ClineRecommendedModel[]
+	clinePass: ClineRecommendedModel[]
+}
+
+type RecommendedModelsResponseLike = {
+	recommended?: ClineRecommendedModel[]
+	free?: ClineRecommendedModel[]
+	clinePass?: ClineRecommendedModel[]
+}
+
+export function getRecommendedModelsData(response: RecommendedModelsResponseLike): RecommendedModelsData | undefined {
+	const recommended = response.recommended ?? []
+	const free = response.free ?? []
+	const clinePass = response.clinePass ?? []
+
+	if (recommended.length === 0 && free.length === 0 && clinePass.length === 0) {
+		return undefined
+	}
+
+	return { recommended, free, clinePass }
+}
+
+export interface OnboardingModelsByGroup {
+	clinePass: ModelGroup[]
+	free: ModelGroup[]
+	power: ModelGroup[]
+}
+
+interface ModelGroup {
+	group: string
+	models: OnboardingModel[]
+}
+
+function isClinePassOnboardingModel(model: OnboardingModel): boolean {
+	return model.group === CLINEPASS_GROUP
+}
+
+export function getClineUIOnboardingGroups(groupedModels: OnboardingModelGroup): OnboardingModelsByGroup {
+	const { models } = groupedModels
+
+	const clinePassModels = models.filter(isClinePassOnboardingModel)
+	const freeModels = models.filter((m) => m.group === "free")
+	const frontierModels = models.filter((m) => m.group === "frontier")
+	const openSourceModels = models.filter((m) => m.group === "open source")
+
+	return {
+		clinePass: clinePassModels.length > 0 ? [{ group: CLINEPASS_GROUP, models: clinePassModels }] : [],
+		free: freeModels.length > 0 ? [{ group: "free", models: freeModels }] : [],
+		power: [
+			...(frontierModels.length > 0 ? [{ group: "frontier", models: frontierModels }] : []),
+			...(openSourceModels.length > 0 ? [{ group: "open source", models: openSourceModels }] : []),
+		],
+	}
+}
+
+export function getOnboardingGroupDisplayName(group: string): string {
+	if (group === CLINEPASS_GROUP) {
+		return "ClinePass"
+	}
+	return group
+}
+
+export function getPriceRange(modelInfo: OpenRouterModelInfo): string {
+	const prompt = Number(modelInfo.inputPrice ?? 0)
+	const completion = Number(modelInfo.outputPrice ?? 0)
+	const cost = prompt + completion
+	if (cost === 0) {
+		return "Free"
+	}
+	if (cost < 10) {
+		return "$"
+	}
+	if (cost > 50) {
+		return "$$$"
+	}
+	return "$$"
+}
+
+export function getCapabilities(modelInfo: OpenRouterModelInfo): string[] {
+	const capabilities = new Set<string>()
+	if (modelInfo.supportsImages) {
+		capabilities.add("Images")
+	}
+	if (modelInfo.supportsPromptCache) {
+		capabilities.add("Prompt Cache")
+	}
+	capabilities.add("Tools")
+	return Array.from(capabilities)
+}
+
+export function getSpeedLabel(latency?: number): string {
+	if (!latency) {
+		return "Average"
+	}
+	if (latency < 1) {
+		return "Instant"
+	}
+	if (latency < 2) {
+		return "Fast"
+	}
+	if (latency > 5) {
+		return "Slow"
+	}
+
+	return "Average"
+}
diff --git a/apps/vscode/webview-ui/src/components/onboarding/data-steps.ts b/apps/vscode/webview-ui/src/components/onboarding/data-steps.ts
new file mode 100644
index 0000000..bb4f928
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/data-steps.ts
@@ -0,0 +1,79 @@
+export enum NEW_USER_TYPE {
+	CLINE_PASS = "cline-pass",
+	FREE = "free",
+	POWER = "power",
+	BYOK = "byok",
+}
+
+type UserTypeSelection = {
+	title: string
+	description: string
+	type: NEW_USER_TYPE
+	learnMoreUrl?: string
+}
+
+export const STEP_CONFIG = {
+	0: {
+		title: "How will you use Cline?",
+		description: "Select an option below to get started.",
+		buttons: [
+			{ text: "Continue", action: "next", variant: "default" },
+			{ text: "Login to Cline", action: "signin", variant: "secondary" },
+		],
+	},
+	[NEW_USER_TYPE.CLINE_PASS]: {
+		title: "Select a ClinePass model",
+		buttons: [
+			{ text: "Create my Account", action: "signup", variant: "default" },
+			{ text: "Back", action: "back", variant: "secondary" },
+		],
+	},
+	[NEW_USER_TYPE.FREE]: {
+		title: "Select a free model",
+		buttons: [
+			{ text: "Create my Account", action: "signup", variant: "default" },
+			{ text: "Back", action: "back", variant: "secondary" },
+		],
+	},
+	[NEW_USER_TYPE.POWER]: {
+		title: "Select your model",
+		buttons: [
+			{ text: "Create my Account", action: "signup", variant: "default" },
+			{ text: "Back", action: "back", variant: "secondary" },
+		],
+	},
+	[NEW_USER_TYPE.BYOK]: {
+		title: "Configure your provider",
+		buttons: [
+			{ text: "Continue", action: "done", variant: "default" },
+			{ text: "Back", action: "back", variant: "secondary" },
+		],
+	},
+	2: {
+		title: "Almost there!",
+		description: "Complete account creation in your browser. Then come back here to finish up.",
+		buttons: [{ text: "Back", action: "back", variant: "secondary" }],
+	},
+} as const
+
+const CLINE_PASS_USER_TYPE_SELECTION: UserTypeSelection = {
+	title: "ClinePass",
+	description: "Low cost subscription plan for best open weights model.",
+	type: NEW_USER_TYPE.CLINE_PASS,
+	learnMoreUrl: "https://docs.cline.bot/getting-started/clinepass",
+}
+
+const BASE_USER_TYPE_SELECTIONS: UserTypeSelection[] = [
+	{ title: "Absolutely Free", description: "Get started at no cost", type: NEW_USER_TYPE.FREE },
+	{ title: "Frontier Model", description: "Claude, GPT Codex, Gemini, etc.", type: NEW_USER_TYPE.POWER },
+	{ title: "Bring my own API key", description: "Use Cline with your provider of choice", type: NEW_USER_TYPE.BYOK },
+]
+
+/** Free leads (and is the default); ClinePass is inserted second when its models are available. */
+export function getUserTypeSelections(hasClinePassModels: boolean): UserTypeSelection[] {
+	if (!hasClinePassModels) {
+		return BASE_USER_TYPE_SELECTIONS
+	}
+	const [free, ...rest] = BASE_USER_TYPE_SELECTIONS
+	return [free, CLINE_PASS_USER_TYPE_SELECTION, ...rest]
+}
diff --git a/apps/vscode/webview-ui/src/components/onboarding/useOnboardingModels.ts b/apps/vscode/webview-ui/src/components/onboarding/useOnboardingModels.ts
new file mode 100644
index 0000000..74e1109
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/onboarding/useOnboardingModels.ts
@@ -0,0 +1,109 @@
+import { buildModelInfoNameMap, type ModelInfo, resolveClinePassModelInfo } from "@shared/api"
+import { CLINE_ONBOARDING_MODELS } from "@shared/cline/onboarding"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import type { ClineRecommendedModel } from "@shared/proto/cline/models"
+import type { OnboardingModel, OnboardingModelGroup } from "@shared/proto/cline/state"
+import { useEffect, useMemo, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { CLINEPASS_GROUP, getRecommendedModelsData, type RecommendedModelsData } from "./data-models"
+
+type OnboardingModelsStatus = "loading" | "success" | "empty"
+
+export interface UseOnboardingModelsResult {
+	status: OnboardingModelsStatus
+	models: OnboardingModelGroup
+}
+
+function toOnboardingModel(
+	rec: ClineRecommendedModel,
+	group: string,
+	fallbackBadge: string,
+	modelCatalog: Record<string, ModelInfo>,
+): OnboardingModel {
+	const catalogInfo = modelCatalog[rec.id]
+	const tag = rec.tags?.[0] ?? ""
+	const badge = tag || fallbackBadge
+
+	return {
+		id: rec.id,
+		name: rec.name || rec.id,
+		group,
+		badge,
+		score: 0,
+		latency: 0,
+		info: catalogInfo
+			? {
+					contextWindow: catalogInfo.contextWindow ?? 0,
+					supportsImages: catalogInfo.supportsImages ?? false,
+					supportsPromptCache: catalogInfo.supportsPromptCache ?? false,
+					inputPrice: catalogInfo.inputPrice ?? 0,
+					outputPrice: catalogInfo.outputPrice ?? 0,
+					tiers: catalogInfo.tiers ?? [],
+				}
+			: undefined,
+	}
+}
+
+type FetchState = { status: "loading" } | { status: "success"; data: RecommendedModelsData } | { status: "empty" }
+
+export function useOnboardingModels(): UseOnboardingModelsResult {
+	const { openRouterModels } = useExtensionState()
+	const { models: clineModels } = useProviderModels("cline")
+	const [fetchState, setFetchState] = useState<FetchState>({ status: "loading" })
+
+	useEffect(() => {
+		let cancelled = false
+
+		const refreshRecommendedModels = async () => {
+			try {
+				const response = await ModelsServiceClient.refreshClineRecommendedModelsRpc(EmptyRequest.create({}))
+				if (!cancelled) {
+					const data = getRecommendedModelsData(response)
+					if (!data) {
+						setFetchState({ status: "empty" })
+					} else {
+						setFetchState({ status: "success", data })
+					}
+				}
+			} catch {
+				if (!cancelled) {
+					setFetchState({ status: "empty" })
+				}
+			}
+		}
+
+		refreshRecommendedModels()
+
+		return () => {
+			cancelled = true
+		}
+	}, [])
+
+	// Merge openRouter and cline models into a single catalog for lookups
+	const modelCatalog = useMemo<Record<string, ModelInfo>>(() => {
+		return { ...openRouterModels, ...(clineModels ?? {}) }
+	}, [openRouterModels, clineModels])
+
+	// ClinePass model IDs omit the upstream lab (e.g. "cline-pass/glm-5.2"), so look up
+	// capabilities via the model slug against the OpenRouter catalog, falling back to
+	// conservative ClinePass defaults. Mirrors ClinePassProvider's resolution.
+	const openRouterModelsByName = useMemo(() => buildModelInfoNameMap(openRouterModels), [openRouterModels])
+
+	return useMemo<UseOnboardingModelsResult>(() => {
+		if (fetchState.status !== "success") {
+			return { status: fetchState.status, models: { models: CLINE_ONBOARDING_MODELS } }
+		}
+
+		const { data } = fetchState
+		const freeModels = data.free.map((rec) => toOnboardingModel(rec, "free", "Free", modelCatalog))
+		const frontierModels = data.recommended.map((rec) => toOnboardingModel(rec, "frontier", "", modelCatalog))
+		const clinePassCatalog = Object.fromEntries(
+			data.clinePass.map((rec) => [rec.id, resolveClinePassModelInfo(rec.id, openRouterModelsByName)]),
+		)
+		const clinePassModels = data.clinePass.map((rec) => toOnboardingModel(rec, CLINEPASS_GROUP, "", clinePassCatalog))
+
+		return { status: "success", models: { models: [...clinePassModels, ...freeModels, ...frontierModels] } }
+	}, [fetchState, modelCatalog, openRouterModelsByName])
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/ApiOptions.tsx b/apps/vscode/webview-ui/src/components/settings/ApiOptions.tsx
new file mode 100644
index 0000000..ed45a6c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ApiOptions.tsx
@@ -0,0 +1,578 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import type { Mode } from "@shared/storage/types"
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useInterval } from "react-use"
+import styled from "styled-components"
+
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { PLATFORM_CONFIG, PlatformType } from "@/config/platform.config"
+import { CLINE_PASS_FEATURE_FLAG } from "@/constants/featureFlags"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useHasFeatureFlag } from "@/hooks/useFeatureFlag"
+import { useProviderListings } from "@/hooks/useProviderListings"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { OPENROUTER_MODEL_PICKER_Z_INDEX } from "./OpenRouterModelPicker"
+import { AIhubmixProvider } from "./providers/AihubmixProvider"
+import { AnthropicProvider } from "./providers/AnthropicProvider"
+import { AskSageProvider } from "./providers/AskSageProvider"
+import { BasetenProvider } from "./providers/BasetenProvider"
+import { BedrockProvider } from "./providers/BedrockProvider"
+import { ClaudeCodeProvider } from "./providers/ClaudeCodeProvider"
+import { ClinePassProvider } from "./providers/ClinePassProvider"
+import { ClineProvider } from "./providers/ClineProvider"
+import { DifyProvider } from "./providers/DifyProvider"
+import { GenericProviderSettings } from "./providers/GenericProviderSettings"
+import { GroqProvider } from "./providers/GroqProvider"
+import { HicapProvider } from "./providers/HicapProvider"
+import { HuggingFaceProvider } from "./providers/HuggingFaceProvider"
+import { LiteLlmProvider } from "./providers/LiteLlmProvider"
+import { LMStudioProvider } from "./providers/LMStudioProvider"
+import { MoonshotProvider } from "./providers/MoonshotProvider"
+import { OcaProvider } from "./providers/OcaProvider"
+import { OllamaProvider } from "./providers/OllamaProvider"
+import { OpenAICompatibleProvider } from "./providers/OpenAICompatible"
+import { OpenAINativeProvider } from "./providers/OpenAINative"
+import { OpenAiCodexProvider } from "./providers/OpenAiCodexProvider"
+import { OpenRouterProvider } from "./providers/OpenRouterProvider"
+import {
+	getFallbackGenericProviderSettings,
+	getGenericProviderSettings,
+	hasCustomProviderSettings,
+	isKnownGenericProvider,
+} from "./providers/providerSettingsRegistry"
+import { QwenCodeProvider } from "./providers/QwenCodeProvider"
+import { QwenProvider } from "./providers/QwenProvider"
+import { RequestyProvider } from "./providers/RequestyProvider"
+import { SapAiCoreProvider } from "./providers/SapAiCoreProvider"
+import { VercelAIGatewayProvider } from "./providers/VercelAIGatewayProvider"
+import { VertexProvider } from "./providers/VertexProvider"
+import { VSCodeLmProvider } from "./providers/VSCodeLmProvider"
+import { XaiProvider } from "./providers/XaiProvider"
+import { ZAiProvider } from "./providers/ZAiProvider"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface ApiOptionsProps {
+	showModelOptions: boolean
+	apiErrorMessage?: string
+	modelIdErrorMessage?: string
+	isPopup?: boolean
+	currentMode: Mode
+	initialModelTab?: "recommended" | "free"
+}
+
+// This is necessary to ensure dropdown opens downward, important for when this is used in popup
+export const DROPDOWN_Z_INDEX = OPENROUTER_MODEL_PICKER_Z_INDEX + 2 // Higher than the OpenRouterModelPicker's and ModelSelectorTooltip's z-index
+
+export const DropdownContainer = styled.div<{ zIndex?: number }>`
+	position: relative;
+	z-index: ${(props) => props.zIndex || DROPDOWN_Z_INDEX};
+
+	// Force dropdowns to open downward
+	& vscode-dropdown::part(listbox) {
+		position: absolute !important;
+		top: 100% !important;
+		bottom: auto !important;
+	}
+`
+
+declare module "vscode" {
+	interface LanguageModelChatSelector {
+		vendor?: string
+		family?: string
+		version?: string
+		id?: string
+	}
+}
+
+const ApiOptions = ({
+	showModelOptions,
+	apiErrorMessage,
+	modelIdErrorMessage,
+	isPopup,
+	currentMode,
+	initialModelTab,
+}: ApiOptionsProps) => {
+	// Use full context state for immediate save payload
+	const { apiConfiguration, remoteConfigSettings } = useExtensionState()
+	const isClinePassEnabled = useHasFeatureFlag(CLINE_PASS_FEATURE_FLAG)
+
+	const selectedProviderRaw =
+		(currentMode === "plan" ? apiConfiguration?.planModeApiProvider : apiConfiguration?.actModeApiProvider) || "anthropic"
+	// Fall back from cline-pass to cline when the feature flag is off.
+	const selectedProvider = selectedProviderRaw === "cline-pass" && !isClinePassEnabled ? "cline" : selectedProviderRaw
+	const { providers: catalogProviderListings } = useProviderListings()
+	const catalogProviderListing = useMemo(
+		() => catalogProviderListings.find((provider) => provider.id === selectedProvider),
+		[catalogProviderListings, selectedProvider],
+	)
+	// A provider is custom/unknown when we ship neither a dedicated settings
+	// component nor a curated generic form for it. These are edited through the
+	// OpenAI-compatible form so they always get Base URL, Custom Headers, Model
+	// Configuration and Reasoning Effort sections — regardless of whether the id
+	// happens to appear in providers.json.
+	const isCustomProvider = !hasCustomProviderSettings(selectedProvider) && !isKnownGenericProvider(selectedProvider)
+	const genericProviderSettings = isCustomProvider
+		? undefined
+		: (getGenericProviderSettings(selectedProvider, catalogProviderListing) ??
+			getFallbackGenericProviderSettings(selectedProvider))
+
+	const { handleModeFieldChange } = useApiConfigurationHandlers()
+
+	const [_ollamaModels, setOllamaModels] = useState<string[]>([])
+
+	// Poll ollama/vscode-lm models
+	const requestLocalModels = useCallback(async () => {
+		if (selectedProvider === "ollama") {
+			try {
+				const response = await ModelsServiceClient.getOllamaModels(
+					StringRequest.create({
+						value: apiConfiguration?.ollamaBaseUrl || "",
+					}),
+				)
+				if (response && response.values) {
+					setOllamaModels(response.values)
+				}
+			} catch (error) {
+				console.error("Failed to fetch Ollama models:", error)
+				setOllamaModels([])
+			}
+		}
+	}, [selectedProvider, apiConfiguration?.ollamaBaseUrl])
+	useEffect(() => {
+		if (selectedProvider === "ollama") {
+			requestLocalModels()
+		}
+	}, [selectedProvider, requestLocalModels])
+	useInterval(requestLocalModels, selectedProvider === "ollama" ? 2000 : null)
+
+	// Provider search state
+	const [searchTerm, setSearchTerm] = useState("")
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const providerOptions = useMemo(() => {
+		// Source the list from the live SDK provider catalog (same data the
+		// hub client uses) so user-configured/custom providers appear too,
+		// instead of a static hand-maintained list.
+		let providers = catalogProviderListings.map((provider) => ({
+			value: provider.id,
+			label: provider.name,
+		}))
+		if (!isClinePassEnabled) {
+			providers = providers.filter((option) => option.value !== "cline-pass")
+		}
+		// Filter by platform
+		if (PLATFORM_CONFIG.type !== PlatformType.VSCODE) {
+			// Don't include VS Code LM API for non-VSCode platforms
+			providers = providers.filter((option) => option.value !== "vscode-lm")
+		}
+
+		// Filter by remote config if remoteConfiguredProviders is set
+		const remoteProviders: string[] = remoteConfigSettings?.remoteConfiguredProviders || []
+		if (remoteProviders.length > 0) {
+			providers = providers.filter((option) => remoteProviders.includes(option.value))
+		}
+
+		return providers
+	}, [catalogProviderListings, isClinePassEnabled, remoteConfigSettings])
+
+	const currentProviderLabel = useMemo(() => {
+		return providerOptions.find((option) => option.value === selectedProvider)?.label || selectedProvider
+	}, [providerOptions, selectedProvider])
+
+	// Sync search term with current provider when not searching
+	useEffect(() => {
+		if (!isDropdownVisible) {
+			setSearchTerm(currentProviderLabel)
+		}
+	}, [currentProviderLabel, isDropdownVisible])
+
+	const searchableItems = useMemo(() => {
+		return providerOptions.map((option) => ({
+			value: option.value,
+			html: option.label,
+		}))
+	}, [providerOptions])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"],
+			threshold: 0.3,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const providerSearchResults = useMemo(() => {
+		return searchTerm && searchTerm !== currentProviderLabel ? fuse.search(searchTerm)?.map((r) => r.item) : searchableItems
+	}, [searchableItems, searchTerm, fuse, currentProviderLabel])
+
+	const handleProviderChange = (newProvider: string) => {
+		handleModeFieldChange({ plan: "planModeApiProvider", act: "actModeApiProvider" }, newProvider as any, currentMode)
+		setIsDropdownVisible(false)
+		setSelectedIndex(-1)
+	}
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < providerSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < providerSearchResults.length) {
+					handleProviderChange(providerSearchResults[selectedIndex].value)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				setSearchTerm(currentProviderLabel)
+				break
+		}
+	}
+
+	// Close dropdown when clicking outside
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+				setSearchTerm(currentProviderLabel)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [currentProviderLabel])
+
+	// Reset selection when search term changes
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	// Scroll selected item into view
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	/*
+	VSCodeDropdown has an open bug where dynamically rendered options don't auto select the provided value prop. You can see this for yourself by comparing  it with normal select/option elements, which work as expected.
+	https://github.com/microsoft/vscode-webview-ui-toolkit/issues/433
+
+	In our case, when the user switches between providers, we recalculate the selectedModelId depending on the provider, the default model for that provider, and a modelId that the user may have selected. Unfortunately, the VSCodeDropdown component wouldn't select this calculated value, and would default to the first "Select a model..." option instead, which makes it seem like the model was cleared out when it wasn't.
+
+	As a workaround, we create separate instances of the dropdown for each provider, and then conditionally render the one that matches the current provider.
+	*/
+
+	return (
+		<div
+			style={{
+				display: "flex",
+				flexDirection: "column",
+				gap: 5,
+				marginBottom: isPopup ? -10 : 0,
+			}}>
+			<style>
+				{`
+				.provider-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<DropdownContainer className="dropdown-container">
+				{remoteConfigSettings?.remoteConfiguredProviders && remoteConfigSettings.remoteConfiguredProviders.length > 0 ? (
+					<Tooltip>
+						<TooltipTrigger>
+							<div className="flex items-center gap-2 mb-1">
+								<label htmlFor="api-provider">
+									<span style={{ fontWeight: 500 }}>API Provider</span>
+								</label>
+								<i className="codicon codicon-lock text-description text-sm" />
+							</div>
+						</TooltipTrigger>
+						<TooltipContent>Provider options are managed by your organization's remote configuration</TooltipContent>
+					</Tooltip>
+				) : (
+					<label htmlFor="api-provider">
+						<span style={{ fontWeight: 500 }}>API Provider</span>
+					</label>
+				)}
+				<ProviderDropdownWrapper ref={dropdownRef}>
+					<VSCodeTextField
+						data-testid="provider-selector-input"
+						id="api-provider"
+						onFocus={() => {
+							setIsDropdownVisible(true)
+							setSearchTerm("")
+						}}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select provider..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: DROPDOWN_Z_INDEX,
+							position: "relative",
+							minWidth: 130,
+						}}
+						value={searchTerm}>
+						{searchTerm && searchTerm !== currentProviderLabel && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<ProviderDropdownList ref={dropdownListRef} role="listbox">
+							{providerSearchResults.map((item, index) => (
+								<ProviderDropdownItem
+									data-testid={`provider-option-${item.value}`}
+									isSelected={index === selectedIndex}
+									key={item.value}
+									onClick={() => handleProviderChange(item.value)}
+									onMouseEnter={() => setSelectedIndex(index)}
+									ref={(el) => {
+										itemRefs.current[index] = el
+									}}
+									role="option">
+									<span>{item.html}</span>
+								</ProviderDropdownItem>
+							))}
+						</ProviderDropdownList>
+					)}
+				</ProviderDropdownWrapper>
+			</DropdownContainer>
+
+			{apiConfiguration && selectedProvider === "hicap" && (
+				<HicapProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "cline" && (
+				<ClineProvider
+					currentMode={currentMode}
+					initialModelTab={initialModelTab}
+					isPopup={isPopup}
+					showModelOptions={showModelOptions}
+				/>
+			)}
+
+			{apiConfiguration && isClinePassEnabled && selectedProvider === "cline-pass" && (
+				<ClinePassProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "asksage" && (
+				<AskSageProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "anthropic" && (
+				<AnthropicProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "claude-code" && (
+				<ClaudeCodeProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "openai-native" && (
+				<OpenAINativeProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "openai-codex" && (
+				<OpenAiCodexProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "qwen" && (
+				<QwenProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "qwen-code" && (
+				<QwenCodeProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "openrouter" && (
+				<OpenRouterProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && genericProviderSettings && (
+				<GenericProviderSettings
+					{...genericProviderSettings}
+					currentMode={currentMode}
+					isPopup={isPopup}
+					showModelOptions={showModelOptions}
+				/>
+			)}
+
+			{apiConfiguration && selectedProvider === "vercel-ai-gateway" && !genericProviderSettings && (
+				<VercelAIGatewayProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "bedrock" && (
+				<BedrockProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "vertex" && (
+				<VertexProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "requesty" && (
+				<RequestyProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "vscode-lm" && <VSCodeLmProvider currentMode={currentMode} />}
+
+			{apiConfiguration && selectedProvider === "groq" && !genericProviderSettings && (
+				<GroqProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+			{apiConfiguration && selectedProvider === "baseten" && !genericProviderSettings && (
+				<BasetenProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+			{apiConfiguration && selectedProvider === "litellm" && (
+				<LiteLlmProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "lmstudio" && (
+				<LMStudioProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "ollama" && (
+				<OllamaProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "moonshot" && (
+				<MoonshotProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "huggingface" && !genericProviderSettings && (
+				<HuggingFaceProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "xai" && (
+				<XaiProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "sapaicore" && (
+				<SapAiCoreProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "dify" && (
+				<DifyProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "zai" && (
+				<ZAiProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && selectedProvider === "oca" && <OcaProvider currentMode={currentMode} isPopup={isPopup} />}
+
+			{apiConfiguration && selectedProvider === "aihubmix" && (
+				<AIhubmixProvider currentMode={currentMode} isPopup={isPopup} showModelOptions={showModelOptions} />
+			)}
+
+			{apiConfiguration && (selectedProvider.includes("openai") || isCustomProvider) && (
+				<OpenAICompatibleProvider
+					currentMode={currentMode}
+					isPopup={isPopup}
+					providerId={selectedProvider}
+					showModelOptions={showModelOptions}
+				/>
+			)}
+
+			{apiErrorMessage && (
+				<p
+					style={{
+						margin: "-10px 0 4px 0",
+						fontSize: 12,
+						color: "var(--vscode-errorForeground)",
+					}}>
+					{apiErrorMessage}
+				</p>
+			)}
+			{modelIdErrorMessage && (
+				<p
+					style={{
+						margin: "-10px 0 4px 0",
+						fontSize: 12,
+						color: "var(--vscode-errorForeground)",
+					}}>
+					{modelIdErrorMessage}
+				</p>
+			)}
+		</div>
+	)
+}
+
+export default ApiOptions
+
+const ProviderDropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+const ProviderDropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	z-index: ${DROPDOWN_Z_INDEX - 1};
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const ProviderDropdownItem = styled.div<{ isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+
+	background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/BasetenModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/BasetenModelPicker.tsx
new file mode 100644
index 0000000..b93508d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/BasetenModelPicker.tsx
@@ -0,0 +1,281 @@
+import { Mode } from "@shared/storage/types"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import React, { KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { useExtensionState } from "../../context/ExtensionStateContext"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface BasetenModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const BasetenModelPicker: React.FC<BasetenModelPickerProps> = ({ isPopup, currentMode }) => {
+	const { apiConfiguration, basetenModels: dynamicBasetenModels } = useExtensionState()
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	// Curated Baseten catalog from the SDK over gRPC. The local
+	// `dynamicBasetenModels` slice (populated by `refreshBasetenModels`)
+	// is merged on top so live API additions are visible.
+	const { models: basetenModels, defaultModelId: basetenDefaultModelId } = useProviderModels("baseten")
+	const [searchTerm, setSearchTerm] = useState(modeFields.basetenModelId || basetenDefaultModelId)
+	const [debouncedSearchTerm, setDebouncedSearchTerm] = useState(searchTerm)
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		// Use dynamic models if available, otherwise fall back to static models
+		const modelInfo = dynamicBasetenModels?.[newModelId] || basetenModels[newModelId as keyof typeof basetenModels]
+
+		handleModeFieldsChange(
+			{
+				basetenModelId: { plan: "planModeBasetenModelId", act: "actModeBasetenModelId" },
+				basetenModelInfo: { plan: "planModeBasetenModelInfo", act: "actModeBasetenModelInfo" },
+			},
+			{
+				basetenModelId: newModelId,
+				basetenModelInfo: modelInfo,
+			},
+			currentMode,
+		)
+		setSearchTerm(newModelId)
+	}
+
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("baseten", apiConfiguration, currentMode)
+
+	// Sync external changes when the modelId changes
+	// NOTE: Model list is refreshed automatically on mount or when the API key is set,
+	// no need to refresh here in this component again on mount.
+	useEffect(() => {
+		const currentModelId = modeFields.basetenModelId || basetenDefaultModelId
+		setSearchTerm(currentModelId)
+	}, [modeFields.basetenModelId])
+
+	// Debounce search term to reduce re-renders
+	useEffect(() => {
+		const timer = setTimeout(() => {
+			setDebouncedSearchTerm(searchTerm)
+		}, 300)
+
+		return () => clearTimeout(timer)
+	}, [searchTerm])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const allBasetenModels = useMemo(() => {
+		// Merge static models with dynamic models, with dynamic taking precedence
+		return { ...basetenModels, ...(dynamicBasetenModels || {}) }
+	}, [dynamicBasetenModels])
+
+	const modelIds = useMemo(() => {
+		return Object.keys(allBasetenModels).sort((a, b) => a.localeCompare(b))
+	}, [allBasetenModels])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"], // highlight function will update this
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		const results: { id: string; html: string }[] = debouncedSearchTerm
+			? highlight(fuse.search(debouncedSearchTerm), "model-item-highlight")
+			: searchableItems
+		return results
+	}, [searchableItems, debouncedSearchTerm, fuse])
+
+	// Safe HTML parser for highlighted search results
+	const parseHighlightedText = React.useCallback((htmlString: string) => {
+		// Split by highlight spans and reconstruct as React elements
+		const parts = htmlString.split(/(<span class="model-item-highlight">.*?<\/span>)/g)
+
+		return parts
+			.map((part) => {
+				if (part.startsWith('<span class="model-item-highlight">')) {
+					// Extract text content from span
+					const text = part.replace(/<span class="model-item-highlight">(.*?)<\/span>/, "$1")
+					return (
+						<span className="model-item-highlight" key={`highlight-${text}`}>
+							{text}
+						</span>
+					)
+				}
+				// Return plain text without wrapping in span
+				return part || null
+			})
+			.filter((part) => part !== null && part !== "")
+	}, [])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	const hasInfo = useMemo(() => {
+		return selectedModelInfo && selectedModelInfo.description
+	}, [selectedModelInfo])
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	return (
+		<div className="w-full">
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div className="flex flex-col">
+				<label htmlFor="model-search">
+					<span className="font-medium">Model</span>
+				</label>
+				<div className="relative w-full" ref={dropdownRef}>
+					<VSCodeTextField
+						id="model-search"
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: BASETEN_MODEL_PICKER_Z_INDEX,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close flex justify-center items-center h-full"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<div
+							className="absolute top-[calc(100%-3px)] left-0 w-[calc(100%-2px)] max-h-[200px] overflow-y-auto border border-(--vscode-list-activeSelectionBackground) rounded-b-[3px]"
+							ref={dropdownListRef}
+							role="listbox"
+							style={{
+								backgroundColor: "var(--vscode-dropdown-background)",
+								zIndex: BASETEN_MODEL_PICKER_Z_INDEX - 1,
+							}}>
+							{modelSearchResults.map((item, index) => (
+								<div
+									className={`px-2.5 py-1.5 cursor-pointer break-all whitespace-normal hover:bg-(--vscode-list-activeSelectionBackground) ${
+										index === selectedIndex ? "bg-(--vscode-list-activeSelectionBackground)" : ""
+									}`}
+									key={item.id}
+									onClick={() => {
+										handleModelChange(item.id)
+										setIsDropdownVisible(false)
+									}}
+									onMouseEnter={() => setSelectedIndex(index)}
+									ref={(el: HTMLDivElement | null) => {
+										itemRefs.current[index] = el
+									}}
+									role="option">
+									{parseHighlightedText(item.html)}
+								</div>
+							))}
+						</div>
+					)}
+				</div>
+			</div>
+
+			{hasInfo ? (
+				<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+			) : (
+				<p className="text-xs mt-0 text-(--vscode-descriptionForeground)">
+					The extension automatically fetches the latest list of models available on{" "}
+					<VSCodeLink className="inline text-inherit" href="https://www.baseten.co/products/model-apis/">
+						Baseten.
+					</VSCodeLink>
+					If you're unsure which model to choose, compare available models by context window, pricing, and capabilities.
+				</p>
+			)}
+		</div>
+	)
+}
+
+const BASETEN_MODEL_PICKER_Z_INDEX = 1_000
+
+export default BasetenModelPicker
diff --git a/apps/vscode/webview-ui/src/components/settings/ClineAccountInfoCard.tsx b/apps/vscode/webview-ui/src/components/settings/ClineAccountInfoCard.tsx
new file mode 100644
index 0000000..dc1346e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ClineAccountInfoCard.tsx
@@ -0,0 +1,59 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import { useEffect, useState } from "react"
+import { ClineAuthStatus } from "@/components/account/ClineAuthStatus"
+import { useClineAuth, useClineSignIn } from "@/context/ClineAuthContext"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { UiServiceClient } from "@/services/grpc-client"
+
+export const ClineAccountInfoCard = ({ usageLink }: { usageLink?: string }) => {
+	const { clineUser } = useClineAuth()
+	const { navigateToAccount } = useExtensionState()
+	const { isLoginLoading, authStatusMessage, handleSignIn } = useClineSignIn()
+	const [didStartLogin, setDidStartLogin] = useState(false)
+
+	const user = clineUser || undefined
+
+	const handleLogin = () => {
+		setDidStartLogin(true)
+		handleSignIn()
+	}
+
+	useEffect(() => {
+		if (didStartLogin && user) {
+			navigateToAccount()
+		}
+	}, [didStartLogin, navigateToAccount, user])
+
+	const handleShowAccount = () => {
+		if (!usageLink) {
+			return navigateToAccount()
+		}
+
+		UiServiceClient.openUrl(StringRequest.create({ value: usageLink })).catch((err) => {
+			console.error("Failed to open usage link:", err)
+		})
+	}
+
+	return (
+		<div className="max-w-[600px]">
+			{user ? (
+				<VSCodeButton appearance="secondary" onClick={handleShowAccount}>
+					View Billing & Usage
+				</VSCodeButton>
+			) : (
+				<div className="flex flex-col gap-3">
+					<VSCodeButton className="mt-0" disabled={isLoginLoading} onClick={handleLogin}>
+						Sign Up with Cline
+						{isLoginLoading && (
+							<span className="ml-1 animate-spin">
+								<span className="codicon codicon-refresh" />
+							</span>
+						)}
+					</VSCodeButton>
+					<ClineAuthStatus message={authStatusMessage} />
+				</div>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/ClineModelPicker.test.tsx b/apps/vscode/webview-ui/src/components/settings/ClineModelPicker.test.tsx
new file mode 100644
index 0000000..e6dfb04
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ClineModelPicker.test.tsx
@@ -0,0 +1,197 @@
+import { toProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import ClineModelPicker from "./ClineModelPicker"
+
+const mocks = vi.hoisted(() => ({
+	commitSelection: vi.fn(async () => undefined),
+	writeProviderConfig: vi.fn(async () => undefined),
+	updateApiConfigurationProto: vi.fn(async () => undefined),
+	makeUnaryRequest: vi.fn(async () => ({
+		recommended: [
+			{
+				id: "cline-next",
+				description: "Next Cline model",
+				tags: ["recommended"],
+			},
+		],
+		free: [],
+	})),
+	toggleFavoriteModel: vi.fn(async () => undefined),
+}))
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: vi.fn(),
+}))
+
+vi.mock("@/hooks/useDynamicProviderSelection", () => ({
+	useDynamicProviderSelection: vi.fn(),
+}))
+
+vi.mock("@/hooks/useProviderModels", () => ({
+	useProviderModels: vi.fn(),
+}))
+
+vi.mock("@/hooks/useProviderConfig", () => ({
+	useProviderConfig: vi.fn(),
+}))
+
+vi.mock("@/services/grpc-client", () => ({
+	ModelsServiceClient: {
+		makeUnaryRequest: mocks.makeUnaryRequest,
+		updateApiConfigurationProto: mocks.updateApiConfigurationProto,
+	},
+	StateServiceClient: {
+		toggleFavoriteModel: mocks.toggleFavoriteModel,
+	},
+}))
+
+describe("ClineModelPicker", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+
+		vi.mocked(useExtensionState).mockReturnValue({
+			apiConfiguration: {
+				actModeClineModelId: "cline-default",
+				actModeClineModelInfo: {
+					name: "Cline Default",
+					supportsPromptCache: true,
+				},
+			},
+			favoritedModelIds: [],
+			planActSeparateModelsSetting: true,
+		} as ReturnType<typeof useExtensionState>)
+
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {
+				"cline-default": { name: "Cline Default", supportsPromptCache: true },
+				"cline-next": {
+					name: "Cline Next",
+					supportsPromptCache: true,
+					contextWindow: 128_000,
+				},
+			},
+			defaultModelId: "cline-default",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: undefined,
+			write: mocks.writeProviderConfig,
+			commitSelection: mocks.commitSelection,
+		})
+
+		vi.mocked(useDynamicProviderSelection).mockReturnValue({
+			selectedModelId: "cline-default",
+			selectedModelInfo: { name: "Cline Default", supportsPromptCache: true },
+			hideUsageCost: false,
+		})
+	})
+
+	it("commits Cline model selections through provider config so providers.json is updated", async () => {
+		render(<ClineModelPicker currentMode="act" />)
+
+		fireEvent.click(await screen.findByText("cline-next"))
+
+		await waitFor(() => expect(mocks.commitSelection).toHaveBeenCalledTimes(1))
+		expect(mocks.commitSelection).toHaveBeenCalledWith("act", {
+			providerId: "cline",
+			modelId: "cline-next",
+			modelInfo: {
+				name: "Cline Next",
+				supportsPromptCache: true,
+				contextWindow: 128_000,
+			},
+		})
+	})
+
+	it("hydrates the selected Cline model from provider config when legacy settings are empty", () => {
+		vi.mocked(useExtensionState).mockReturnValue({
+			apiConfiguration: {},
+			favoritedModelIds: [],
+			planActSeparateModelsSetting: true,
+		} as ReturnType<typeof useExtensionState>)
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: {
+				providerId: "cline",
+				actSelection: {
+					providerId: "cline",
+					modelId: "cline-next",
+					modelInfo: toProtobufModelInfo({
+						name: "Cline Next",
+						supportsPromptCache: true,
+						contextWindow: 128_000,
+					}),
+				},
+			},
+			write: mocks.writeProviderConfig,
+			commitSelection: mocks.commitSelection,
+		})
+
+		render(<ClineModelPicker currentMode="act" />)
+
+		expect(screen.getByRole("combobox")).toHaveValue("cline-next")
+	})
+
+	it("uses live catalog reasoning support when the saved Cline model snapshot is stale", () => {
+		vi.mocked(useExtensionState).mockReturnValue({
+			apiConfiguration: {
+				actModeClineModelId: "glm-5.2",
+				actModeClineModelInfo: {
+					name: "GLM 5.2",
+					supportsPromptCache: true,
+				},
+			},
+			favoritedModelIds: [],
+			planActSeparateModelsSetting: true,
+		} as ReturnType<typeof useExtensionState>)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {
+				"glm-5.2": {
+					name: "GLM 5.2",
+					supportsPromptCache: true,
+					contextWindow: 1_048_576,
+					supportsReasoning: true,
+				},
+			},
+			defaultModelId: "glm-5.2",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: {
+				providerId: "cline",
+				actSelection: {
+					providerId: "cline",
+					modelId: "glm-5.2",
+					modelInfo: toProtobufModelInfo({
+						name: "GLM 5.2",
+						supportsPromptCache: true,
+					}),
+				},
+			},
+			write: mocks.writeProviderConfig,
+			commitSelection: mocks.commitSelection,
+		})
+		vi.mocked(useDynamicProviderSelection).mockReturnValue({
+			selectedModelId: "glm-5.2",
+			selectedModelInfo: { name: "GLM 5.2", supportsPromptCache: true },
+			hideUsageCost: false,
+		})
+
+		render(<ClineModelPicker currentMode="act" />)
+
+		expect(screen.getByText("Reasoning Effort")).toBeInTheDocument()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/ClineModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/ClineModelPicker.tsx
new file mode 100644
index 0000000..1acf192
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ClineModelPicker.tsx
@@ -0,0 +1,663 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { CLINE_RECOMMENDED_MODELS_FALLBACK } from "@shared/cline/recommended-models"
+import { EmptyRequest, StringRequest } from "@shared/proto/cline/common"
+import { type ClineRecommendedModel, ClineRecommendedModelsResponse } from "@shared/proto/cline/models"
+import { fromProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import type { Mode } from "@shared/storage/types"
+import { isClaudeOpusAdaptiveThinkingModel, resolveClaudeOpusAdaptiveThinking } from "@shared/utils/reasoning-support"
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import type React from "react"
+import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import styled from "styled-components"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { ModelsServiceClient, StateServiceClient } from "@/services/grpc-client"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import FeaturedModelCard from "./FeaturedModelCard"
+import ReasoningEffortSelector from "./ReasoningEffortSelector"
+import { filterOpenRouterModelIds, getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+// Star icon for favorites
+const StarIcon = ({ isFavorite, onClick }: { isFavorite: boolean; onClick: (e: React.MouseEvent) => void }) => {
+	return (
+		<button
+			onClick={onClick}
+			style={{
+				background: "none",
+				border: "none",
+				padding: 0,
+				cursor: "pointer",
+				color: isFavorite ? "var(--vscode-terminal-ansiBlue)" : "var(--vscode-descriptionForeground)",
+				marginLeft: "8px",
+				fontSize: "16px",
+				display: "flex",
+				alignItems: "center",
+				justifyContent: "center",
+				userSelect: "none",
+				WebkitUserSelect: "none",
+			}}
+			type="button">
+			{isFavorite ? "★" : "☆"}
+		</button>
+	)
+}
+
+interface ClineModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+	showProviderRouting?: boolean
+	initialTab?: "recommended" | "free"
+}
+
+interface FeaturedModelCardEntry {
+	id: string
+	description: string
+	label: string
+}
+
+const CLINE_RECOMMENDED_MODELS_RETRY_DELAY_MS = 5000
+
+function normalizeModelId(modelId: string): string {
+	return modelId.trim().toLowerCase()
+}
+
+function toFeaturedModelCardEntry(
+	model: Pick<ClineRecommendedModel, "id" | "description" | "tags">,
+	fallbackLabel: string,
+): FeaturedModelCardEntry | null {
+	if (!model.id) {
+		return null
+	}
+
+	const firstTag = model.tags?.[0]
+	const normalizedLabel = typeof firstTag === "string" && firstTag.length > 0 ? firstTag.toUpperCase() : undefined
+
+	return {
+		id: model.id,
+		description: model.description || (fallbackLabel === "FREE" ? "Free model" : "Recommended model"),
+		label: normalizedLabel || fallbackLabel,
+	}
+}
+
+const RECOMMENDED_MODELS_FALLBACK: FeaturedModelCardEntry[] = CLINE_RECOMMENDED_MODELS_FALLBACK.recommended
+	.map((model) => toFeaturedModelCardEntry(model, "RECOMMENDED"))
+	.filter((model): model is FeaturedModelCardEntry => model !== null)
+
+const FREE_MODELS_FALLBACK: FeaturedModelCardEntry[] = CLINE_RECOMMENDED_MODELS_FALLBACK.free
+	.map((model) => toFeaturedModelCardEntry(model, "FREE"))
+	.filter((model): model is FeaturedModelCardEntry => model !== null)
+
+const ClineModelPicker: React.FC<ClineModelPickerProps> = ({ isPopup, currentMode, showProviderRouting, initialTab }) => {
+	const { handleModeFieldsChange, handleFieldChange } = useApiConfigurationHandlers()
+	const { apiConfiguration, favoritedModelIds } = useExtensionState()
+	const { models: catalogClineModels, defaultModelId: clineDefaultModelId } = useProviderModels("cline")
+	const { config, write: writeProviderConfig, commitSelection } = useProviderConfig("cline")
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const effectiveClineModels = catalogClineModels
+	const committedSelection = currentMode === "plan" ? config?.planSelection : config?.actSelection
+	const committedModelInfo = committedSelection?.modelInfo ? fromProtobufModelInfo(committedSelection.modelInfo) : undefined
+	const currentClineModelId =
+		committedSelection?.modelId ||
+		modeFields.clineModelId ||
+		clineDefaultModelId ||
+		Object.keys(effectiveClineModels ?? {})[0] ||
+		""
+	const [searchTerm, setSearchTerm] = useState(currentClineModelId)
+	const searchTermEditedByUserRef = useRef(false)
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const [clineRecommendedModels, setClineRecommendedModels] = useState<FeaturedModelCardEntry[]>([])
+	const [clineFreeModels, setClineFreeModels] = useState<FeaturedModelCardEntry[]>([])
+	const freeClineModelIds = useMemo(() => {
+		const freeModelIds =
+			clineFreeModels.length > 0 ? clineFreeModels.map((model) => model.id) : FREE_MODELS_FALLBACK.map((model) => model.id)
+		return [...new Set(freeModelIds)]
+	}, [clineFreeModels])
+	const freeClineModelIdSet = useMemo(
+		() => new Set(freeClineModelIds.map((modelId) => normalizeModelId(modelId))),
+		[freeClineModelIds],
+	)
+	const [activeTab, setActiveTab] = useState<"recommended" | "free">(initialTab ?? "recommended")
+	const recommendedModels = useMemo(
+		() => (clineRecommendedModels.length > 0 ? clineRecommendedModels : RECOMMENDED_MODELS_FALLBACK),
+		[clineRecommendedModels],
+	)
+	const freeModels = useMemo(() => (clineFreeModels.length > 0 ? clineFreeModels : FREE_MODELS_FALLBACK), [clineFreeModels])
+	const hasSuccessfulClineRecommendedModelsFetchRef = useRef(false)
+	const isFetchingClineRecommendedModelsRef = useRef(false)
+	const clineRecommendedModelsRetryTimeoutRef = useRef<number | null>(null)
+
+	const refreshClineRecommendedModels = useCallback(async (): Promise<boolean> => {
+		try {
+			const response = await ModelsServiceClient.makeUnaryRequest(
+				"refreshClineRecommendedModelsRpc",
+				EmptyRequest.create({}),
+				EmptyRequest.toJSON,
+				ClineRecommendedModelsResponse.fromJSON,
+			)
+			const recommended = (response.recommended ?? [])
+				.map((model) => toFeaturedModelCardEntry(model, "RECOMMENDED"))
+				.filter((model): model is FeaturedModelCardEntry => model !== null)
+			const free = (response.free ?? [])
+				.map((model) => toFeaturedModelCardEntry(model, "FREE"))
+				.filter((model): model is FeaturedModelCardEntry => model !== null)
+			setClineRecommendedModels(recommended)
+			setClineFreeModels(free)
+			return true
+		} catch (error) {
+			console.error("Failed to refresh Cline recommended models:", error)
+			return false
+		}
+	}, [])
+
+	const clearClineRecommendedModelsRetryTimeout = useCallback(() => {
+		if (clineRecommendedModelsRetryTimeoutRef.current !== null) {
+			window.clearTimeout(clineRecommendedModelsRetryTimeoutRef.current)
+			clineRecommendedModelsRetryTimeoutRef.current = null
+		}
+	}, [])
+
+	const fetchClineRecommendedModels = useCallback(async () => {
+		if (hasSuccessfulClineRecommendedModelsFetchRef.current || isFetchingClineRecommendedModelsRef.current) {
+			return
+		}
+		isFetchingClineRecommendedModelsRef.current = true
+		const succeeded = await refreshClineRecommendedModels()
+		isFetchingClineRecommendedModelsRef.current = false
+
+		if (succeeded) {
+			hasSuccessfulClineRecommendedModelsFetchRef.current = true
+			clearClineRecommendedModelsRetryTimeout()
+			return
+		}
+
+		if (clineRecommendedModelsRetryTimeoutRef.current === null) {
+			clineRecommendedModelsRetryTimeoutRef.current = window.setTimeout(() => {
+				clineRecommendedModelsRetryTimeoutRef.current = null
+				void fetchClineRecommendedModels()
+			}, CLINE_RECOMMENDED_MODELS_RETRY_DELAY_MS)
+		}
+	}, [clearClineRecommendedModelsRetryTimeout, refreshClineRecommendedModels])
+
+	useEffect(() => {
+		return () => {
+			clearClineRecommendedModelsRetryTimeout()
+		}
+	}, [clearClineRecommendedModelsRetryTimeout])
+
+	useEffect(() => {
+		if (initialTab) {
+			setActiveTab(initialTab)
+		}
+	}, [initialTab])
+
+	useEffect(() => {
+		if (initialTab) {
+			return
+		}
+		setActiveTab(freeClineModelIdSet.has(normalizeModelId(currentClineModelId)) ? "free" : "recommended")
+	}, [currentClineModelId, freeClineModelIdSet, initialTab])
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		searchTermEditedByUserRef.current = false
+		setSearchTerm(newModelId)
+
+		const modelInfo = effectiveClineModels?.[newModelId] ?? {
+			...openAiModelInfoSafeDefaults,
+			name: newModelId,
+		}
+
+		void commitSelection(currentMode, {
+			providerId: "cline",
+			modelId: newModelId,
+			modelInfo,
+		}).catch((err) => console.error("Failed to commit Cline model selection:", err))
+
+		void handleModeFieldsChange(
+			{
+				clineModelId: {
+					plan: "planModeClineModelId",
+					act: "actModeClineModelId",
+				},
+				clineModelInfo: {
+					plan: "planModeClineModelInfo",
+					act: "actModeClineModelInfo",
+				},
+			},
+			{
+				clineModelId: newModelId,
+				clineModelInfo: modelInfo,
+			},
+			currentMode,
+		)
+	}
+
+	const baseSelection = useDynamicProviderSelection("cline", apiConfiguration, currentMode)
+	const { selectedModelId, selectedModelInfo } = useMemo(() => {
+		const selected = {
+			selectedProvider: "cline" as const,
+			selectedModelId: baseSelection.selectedModelId,
+			selectedModelInfo: baseSelection.selectedModelInfo,
+		}
+		const selectedWithCatalogDefault = currentClineModelId
+			? {
+					...selected,
+					selectedModelId: currentClineModelId,
+					selectedModelInfo: (() => {
+						const persistedModelInfo = committedModelInfo || modeFields.clineModelInfo || selected.selectedModelInfo
+						const liveModelInfo = effectiveClineModels?.[currentClineModelId]
+						// Persisted Cline model info is a snapshot from selection time. When the
+						// model is still in the catalog, refresh metadata/capability flags from
+						// the live catalog so UI controls reflect current model support.
+						return liveModelInfo ? { ...persistedModelInfo, ...liveModelInfo } : persistedModelInfo
+					})(),
+				}
+			: selected
+		if (freeClineModelIdSet.has(normalizeModelId(selectedWithCatalogDefault.selectedModelId))) {
+			return {
+				...selectedWithCatalogDefault,
+				selectedModelInfo: {
+					...selectedWithCatalogDefault.selectedModelInfo,
+					inputPrice: 0,
+					outputPrice: 0,
+					cacheReadsPrice: 0,
+					cacheWritesPrice: 0,
+				},
+			}
+		}
+		return selectedWithCatalogDefault
+	}, [
+		baseSelection.selectedModelId,
+		baseSelection.selectedModelInfo,
+		committedModelInfo,
+		currentClineModelId,
+		effectiveClineModels,
+		freeClineModelIdSet,
+		modeFields.clineModelInfo,
+	])
+
+	useEffect(() => {
+		void fetchClineRecommendedModels()
+	}, [fetchClineRecommendedModels])
+
+	// Sync external changes when the modelId changes
+	useEffect(() => {
+		searchTermEditedByUserRef.current = false
+		setSearchTerm(currentClineModelId)
+	}, [currentClineModelId])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const modelIds = useMemo(() => {
+		const unfilteredModelIds = Object.keys(effectiveClineModels ?? {}).sort((a, b) => a.localeCompare(b))
+		return filterOpenRouterModelIds(unfilteredModelIds, "cline", freeClineModelIds)
+	}, [effectiveClineModels, freeClineModelIds])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"], // highlight function will update this
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		// First, get all favorited models
+		const favoritedModels = searchableItems.filter((item) => favoritedModelIds.includes(item.id))
+
+		// Then get search results for non-favorited models
+		const searchResults = searchTerm
+			? highlight(fuse.search(searchTerm), "model-item-highlight").filter((item) => !favoritedModelIds.includes(item.id))
+			: searchableItems.filter((item) => !favoritedModelIds.includes(item.id))
+
+		// Combine favorited models with search results
+		return [...favoritedModels, ...searchResults]
+	}, [searchableItems, searchTerm, fuse, favoritedModelIds])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				} else {
+					handleModelChange(searchTerm)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	const hasInfo = useMemo(() => {
+		try {
+			return modelIds.some((id) => id.toLowerCase() === searchTerm.toLowerCase())
+		} catch {
+			return false
+		}
+	}, [modelIds, searchTerm])
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: reset dropdown navigation whenever the search text changes
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	const showAdaptiveThinkingEffort = useMemo(() => isClaudeOpusAdaptiveThinkingModel(selectedModelId), [selectedModelId])
+	const adaptiveThinkingDefaultEffort = useMemo(
+		() => resolveClaudeOpusAdaptiveThinking(modeFields.reasoningEffort, modeFields.thinkingBudgetTokens).effort ?? "none",
+		[modeFields.reasoningEffort, modeFields.thinkingBudgetTokens],
+	)
+	// Show reasoning effort selector for all models that support reasoning,
+	// using the SDK catalog's supportsReasoning capability flag.
+	const showReasoningEffort = useMemo(
+		() => showAdaptiveThinkingEffort || selectedModelInfo?.supportsReasoning === true,
+		[showAdaptiveThinkingEffort, selectedModelInfo?.supportsReasoning],
+	)
+
+	return (
+		<div style={{ width: "100%", paddingBottom: 2 }}>
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div style={{ display: "flex", flexDirection: "column" }}>
+				<label htmlFor="model-search">
+					<span style={{ fontWeight: 500 }}>Model</span>
+				</label>
+
+				{/* Tabs */}
+				<TabsContainer style={{ marginTop: 4 }}>
+					<Tab active={activeTab === "recommended"} onClick={() => setActiveTab("recommended")}>
+						Recommended
+					</Tab>
+					<Tab active={activeTab === "free"} onClick={() => setActiveTab("free")}>
+						Free
+					</Tab>
+				</TabsContainer>
+
+				{/* Model Cards */}
+				<div style={{ marginBottom: "6px" }}>
+					{activeTab === "recommended" &&
+						recommendedModels.map((model) => (
+							<FeaturedModelCard
+								description={model.description}
+								isSelected={selectedModelId === model.id}
+								key={model.id}
+								label={model.label}
+								modelId={model.id}
+								onClick={() => {
+									handleModelChange(model.id)
+									setIsDropdownVisible(false)
+								}}
+							/>
+						))}
+					{activeTab === "free" &&
+						freeModels.map((model) => (
+							<FeaturedModelCard
+								description={model.description}
+								isSelected={selectedModelId === model.id}
+								key={model.id}
+								label={model.label}
+								modelId={model.id}
+								onClick={() => {
+									handleModelChange(model.id)
+									setIsDropdownVisible(false)
+								}}
+							/>
+						))}
+				</div>
+
+				<DropdownWrapper ref={dropdownRef}>
+					<VSCodeTextField
+						id="model-search"
+						key={currentClineModelId}
+						onBlur={() => {
+							if (searchTermEditedByUserRef.current && searchTerm !== selectedModelId) {
+								handleModelChange(searchTerm)
+							}
+						}}
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							searchTermEditedByUserRef.current = true
+							setSearchTerm((e.target as HTMLInputElement)?.value.toLowerCase() || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: CLINE_MODEL_PICKER_Z_INDEX,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<button
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									background: "none",
+									border: "none",
+									padding: 0,
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+								type="button"
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<DropdownList ref={dropdownListRef} role="listbox">
+							{modelSearchResults.map((item, index) => {
+								const isFavorite = (favoritedModelIds || []).includes(item.id)
+								return (
+									<DropdownItem
+										isSelected={index === selectedIndex}
+										key={item.id}
+										onClick={() => {
+											handleModelChange(item.id)
+											setIsDropdownVisible(false)
+										}}
+										onMouseEnter={() => setSelectedIndex(index)}
+										ref={(el) => (itemRefs.current[index] = el)}
+										role="option">
+										<div
+											style={{
+												display: "flex",
+												justifyContent: "space-between",
+												alignItems: "center",
+											}}>
+											{/* biome-ignore lint/security/noDangerouslySetInnerHtml: highlight() returns sanitized model-id markup for matched search text */}
+											<span dangerouslySetInnerHTML={{ __html: item.html }} />
+											<StarIcon
+												isFavorite={isFavorite}
+												onClick={(e) => {
+													e.stopPropagation()
+													StateServiceClient.toggleFavoriteModel(
+														StringRequest.create({ value: item.id }),
+													).catch((error) => console.error("Failed to toggle favorite model:", error))
+												}}
+											/>
+										</div>
+									</DropdownItem>
+								)
+							})}
+						</DropdownList>
+					)}
+				</DropdownWrapper>
+			</div>
+
+			{hasInfo ? (
+				<>
+					{showReasoningEffort && (
+						<ReasoningEffortSelector
+							allowedEfforts={
+								showAdaptiveThinkingEffort ? (["none", "low", "medium", "high", "xhigh"] as const) : undefined
+							}
+							currentMode={currentMode}
+							defaultEffort={showAdaptiveThinkingEffort ? adaptiveThinkingDefaultEffort : "medium"}
+							description={
+								showAdaptiveThinkingEffort
+									? "Use None to disable adaptive thinking. Higher effort increases response detail and token usage."
+									: undefined
+							}
+							label={showAdaptiveThinkingEffort ? "Adaptive Thinking" : undefined}
+							onEffortChange={(effort) => {
+								writeProviderConfig({
+									reasoning: {
+										enabled: effort !== "none",
+										effort: effort !== "none" ? effort : undefined,
+									},
+								})
+							}}
+						/>
+					)}
+
+					<ModelInfoView
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						onProviderSortingChange={(value) => handleFieldChange("openRouterProviderSorting", value)}
+						providerSorting={apiConfiguration?.openRouterProviderSorting}
+						selectedModelId={selectedModelId}
+						showProviderRouting={showProviderRouting}
+					/>
+				</>
+			) : (
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: 0,
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					The extension automatically fetches the latest Cline model list.
+				</p>
+			)}
+		</div>
+	)
+}
+
+export default ClineModelPicker
+
+const DropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+const CLINE_MODEL_PICKER_Z_INDEX = 1_000
+
+const DropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	z-index: ${CLINE_MODEL_PICKER_Z_INDEX - 1};
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const DropdownItem = styled.div<{ isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+
+	background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
+
+const TabsContainer = styled.div`
+	display: flex;
+	gap: 0;
+	margin-bottom: 12px;
+	border-bottom: 1px solid #333;
+`
+
+const Tab = styled.div<{ active: boolean }>`
+	padding: 8px 16px;
+	cursor: pointer;
+	font-size: 12px;
+	font-weight: 500;
+	color: ${({ active }) => (active ? "var(--vscode-foreground)" : "var(--vscode-descriptionForeground)")};
+	border-bottom: 2px solid ${({ active }) => (active ? "var(--vscode-textLink-foreground)" : "transparent")};
+	transition: all 0.15s ease;
+
+	&:hover {
+		color: var(--vscode-foreground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/FeaturedModelCard.tsx b/apps/vscode/webview-ui/src/components/settings/FeaturedModelCard.tsx
new file mode 100644
index 0000000..abfbbb1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/FeaturedModelCard.tsx
@@ -0,0 +1,65 @@
+import React from "react"
+import styled from "styled-components"
+
+interface FeaturedModelCardProps {
+	modelId: string
+	description: string
+	onClick: () => void
+	isSelected: boolean
+	label: string
+}
+
+const CardContainer = styled.div<{ isSelected: boolean }>`
+	padding: 2px 4px;
+	margin-bottom: 2px;
+	border-radius: 3px;
+	border: 1px solid var(--vscode-textLink-foreground);
+	opacity: ${(props) => (props.isSelected ? 1 : 0.6)};
+	cursor: pointer;
+
+	&:hover {
+		background-color: var(--vscode-list-hoverBackground);
+		opacity: 1;
+	}
+`
+
+const ModelHeader = styled.div`
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+`
+
+const ModelName = styled.div`
+	font-weight: 500;
+	font-size: 12px;
+	line-height: 1.2;
+`
+
+const Label = styled.span`
+	font-size: 10px;
+	color: var(--vscode-textLink-foreground);
+	text-transform: uppercase;
+	letter-spacing: 0.5px;
+	font-weight: 500;
+`
+
+const Description = styled.div`
+	margin-top: 0px;
+	font-size: 11px;
+	color: var(--vscode-descriptionForeground);
+	line-height: 1.2;
+`
+
+const FeaturedModelCard: React.FC<FeaturedModelCardProps> = ({ modelId, description, onClick, isSelected, label }) => {
+	return (
+		<CardContainer isSelected={isSelected} onClick={onClick}>
+			<ModelHeader>
+				<ModelName>{modelId}</ModelName>
+				<Label>{label}</Label>
+			</ModelHeader>
+			<Description>{description}</Description>
+		</CardContainer>
+	)
+}
+
+export default FeaturedModelCard
diff --git a/apps/vscode/webview-ui/src/components/settings/GroqModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/GroqModelPicker.tsx
new file mode 100644
index 0000000..ed64fdb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/GroqModelPicker.tsx
@@ -0,0 +1,286 @@
+import type { ModelInfo } from "@shared/api"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { fromProtobufModels } from "@shared/proto-conversions/models/typeConversion"
+import { Mode } from "@shared/storage/types"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import React, { KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useMount } from "react-use"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { useExtensionState } from "../../context/ExtensionStateContext"
+import { ModelsServiceClient } from "../../services/grpc-client"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface GroqModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const GroqModelPicker: React.FC<GroqModelPickerProps> = ({ isPopup, currentMode }) => {
+	const { apiConfiguration, groqModels: dynamicGroqModels, setGroqModels } = useExtensionState()
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	// Groq's curated catalog comes from the SDK over gRPC. The local
+	// `dynamicGroqModels` slice (populated by `refreshGroqModels` on
+	// the host) is merged on top so live API additions are visible too.
+	const { models: groqModels, defaultModelId: groqDefaultModelId } = useProviderModels("groq")
+	const [searchTerm, setSearchTerm] = useState(modeFields.groqModelId || groqDefaultModelId)
+	const [debouncedSearchTerm, setDebouncedSearchTerm] = useState(searchTerm)
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		// Use dynamic models if available, otherwise fall back to static models
+		const modelInfo = dynamicGroqModels?.[newModelId] || groqModels[newModelId as keyof typeof groqModels]
+
+		handleModeFieldsChange(
+			{
+				groqModelId: { plan: "planModeGroqModelId", act: "actModeGroqModelId" },
+				groqModelInfo: { plan: "planModeGroqModelInfo", act: "actModeGroqModelInfo" },
+			},
+			{
+				groqModelId: newModelId,
+				groqModelInfo: modelInfo,
+			},
+			currentMode,
+		)
+		setSearchTerm(newModelId)
+	}
+
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("groq", apiConfiguration, currentMode)
+
+	useMount(() => {
+		ModelsServiceClient.refreshGroqModelsRpc(EmptyRequest.create({}))
+			.then((response) => {
+				// Seed with the SDK-known default (if loaded yet) so the
+				// picker always has at least one entry; then layer the
+				// live host-fetched models on top.
+				const seed: Record<string, ModelInfo> = {}
+				if (groqDefaultModelId && groqModels[groqDefaultModelId]) {
+					seed[groqDefaultModelId] = groqModels[groqDefaultModelId]
+				}
+				setGroqModels({
+					...seed,
+					...fromProtobufModels(response.models),
+				})
+			})
+			.catch((err) => {
+				console.error("Failed to refresh Groq models:", err)
+			})
+	})
+
+	// Sync external changes when the modelId changes
+	useEffect(() => {
+		const currentModelId = modeFields.groqModelId || groqDefaultModelId
+		setSearchTerm(currentModelId)
+	}, [modeFields.groqModelId])
+
+	// Debounce search term to reduce re-renders
+	useEffect(() => {
+		const timer = setTimeout(() => {
+			setDebouncedSearchTerm(searchTerm)
+		}, 300)
+
+		return () => clearTimeout(timer)
+	}, [searchTerm])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const allGroqModels = useMemo(() => {
+		// Merge static models with dynamic models, with dynamic taking precedence
+		return { ...groqModels, ...(dynamicGroqModels || {}) }
+	}, [dynamicGroqModels])
+
+	const modelIds = useMemo(() => {
+		return Object.keys(allGroqModels).sort((a, b) => a.localeCompare(b))
+	}, [allGroqModels])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"], // highlight function will update this
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		const results: { id: string; html: string }[] = debouncedSearchTerm
+			? highlight(fuse.search(debouncedSearchTerm), "model-item-highlight")
+			: searchableItems
+		return results
+	}, [searchableItems, debouncedSearchTerm, fuse])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	const hasInfo = useMemo(() => {
+		try {
+			return modelIds.some((id) => id.toLowerCase() === searchTerm.toLowerCase())
+		} catch {
+			return false
+		}
+	}, [modelIds, searchTerm])
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	return (
+		<div className="w-full">
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div className="flex flex-col">
+				<label htmlFor="model-search">
+					<span className="font-medium">Model</span>
+				</label>
+				<div className="relative w-full" ref={dropdownRef}>
+					<VSCodeTextField
+						id="model-search"
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: GROQ_MODEL_PICKER_Z_INDEX,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close flex justify-center items-center h-full"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<div
+							className="absolute top-[calc(100%-3px)] left-0 w-[calc(100%-2px)] max-h-[200px] overflow-y-auto border border-(--vscode-list-activeSelectionBackground) rounded-b-[3px]"
+							ref={dropdownListRef}
+							role="listbox"
+							style={{
+								backgroundColor: "var(--vscode-dropdown-background)",
+								zIndex: GROQ_MODEL_PICKER_Z_INDEX - 1,
+							}}>
+							{modelSearchResults.map((item, index) => (
+								<div
+									className={`px-2.5 py-1.5 cursor-pointer break-all whitespace-normal hover:bg-(--vscode-list-activeSelectionBackground) ${
+										index === selectedIndex ? "bg-(--vscode-list-activeSelectionBackground)" : ""
+									}`}
+									dangerouslySetInnerHTML={{
+										__html: item.html,
+									}}
+									key={item.id}
+									onClick={() => {
+										handleModelChange(item.id)
+										setIsDropdownVisible(false)
+									}}
+									onMouseEnter={() => setSelectedIndex(index)}
+									ref={(el: HTMLDivElement | null) => (itemRefs.current[index] = el)}
+									role="option"
+								/>
+							))}
+						</div>
+					)}
+				</div>
+			</div>
+
+			{hasInfo ? (
+				<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+			) : (
+				<p className="text-xs mt-0 text-(--vscode-descriptionForeground)">
+					The extension automatically fetches the latest list of models available on{" "}
+					<VSCodeLink className="inline text-inherit" href="https://console.groq.com/docs/models">
+						Groq.
+					</VSCodeLink>
+					If you're unsure which model to choose, compare available models by context window, pricing, and capabilities.
+				</p>
+			)}
+		</div>
+	)
+}
+
+const GROQ_MODEL_PICKER_Z_INDEX = 1_000
+
+export default GroqModelPicker
diff --git a/apps/vscode/webview-ui/src/components/settings/HicapModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/HicapModelPicker.tsx
new file mode 100644
index 0000000..47348bc
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/HicapModelPicker.tsx
@@ -0,0 +1,245 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import React, { KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useMount } from "react-use"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { StateServiceClient } from "@/services/grpc-client"
+import { highlight } from "../history/HistoryView"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+const HICAP_MODEL_PICKER_Z_INDEX = 1_000
+
+// Star icon for favorites
+const StarIcon = ({ isFavorite, onClick }: { isFavorite: boolean; onClick: (e: React.MouseEvent) => void }) => {
+	return (
+		<div
+			className={`cursor-pointer ${isFavorite ? "text-[var(--vscode-terminal-ansiBlue)]" : "text-[var(--vscode-descriptionForeground)]"} ml-[8px] text-[16px] flex items-center justify-center select-none`}
+			onClick={onClick}>
+			{isFavorite ? "★" : "☆"}
+		</div>
+	)
+}
+
+interface HicapModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const HicapModelPicker: React.FC<HicapModelPickerProps> = ({ isPopup, currentMode }) => {
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const { apiConfiguration, favoritedModelIds, hicapModels, refreshHicapModels } = useExtensionState()
+
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const [searchTerm, setSearchTerm] = useState(modeFields.hicapModelId || "")
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		setSearchTerm(newModelId)
+
+		handleModeFieldsChange(
+			{
+				hicapModelId: { plan: "planModeHicapModelId", act: "actModeHicapModelId" },
+				hicapModelInfo: { plan: "planModeHicapModelInfo", act: "actModeHicapModelInfo" },
+			},
+			{
+				hicapModelId: newModelId,
+				hicapModelInfo: {},
+			},
+			currentMode,
+		)
+	}
+
+	useMount(refreshHicapModels)
+
+	// Sync external changes when the modelId changes
+	useEffect(() => {
+		const currentModelId = modeFields.hicapModelId || ""
+		setSearchTerm(currentModelId)
+	}, [modeFields.hicapModelId])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const modelIds = useMemo(() => {
+		const unfilteredModelIds = Object.keys(hicapModels).sort((a, b) => a.localeCompare(b))
+
+		return unfilteredModelIds
+	}, [hicapModels, modeFields.apiProvider])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"], // highlight function will update this
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		// IMPORTANT: highlightjs has a bug where if you use sort/localCompare - "// results.sort((a, b) => a.id.localeCompare(b.id)) ...sorting like this causes ids in objects to be reordered and mismatched"
+
+		// First, get all favorited models
+		const favoritedModels = searchableItems.filter((item) => favoritedModelIds.includes(item.id))
+
+		// Then get search results for non-favorited models
+		const searchResults = searchTerm
+			? highlight(fuse.search(searchTerm), "model-item-highlight").filter((item) => !favoritedModelIds.includes(item.id))
+			: searchableItems.filter((item) => !favoritedModelIds.includes(item.id))
+
+		// Combine favorited models with search results
+		return [...favoritedModels, ...searchResults]
+	}, [searchableItems, searchTerm, fuse, favoritedModelIds])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	return (
+		<div className="w-full">
+			<div className="flex flex-col">
+				<label htmlFor="model-search">
+					<span className="font-medium">Model ID</span>
+				</label>
+
+				<div className="relative w-full" ref={dropdownRef}>
+					<VSCodeTextField
+						className="w-full relative"
+						disabled={apiConfiguration?.hicapApiKey?.length !== 32 || Object.keys(hicapModels).length === 0}
+						id="model-search"
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value.toLowerCase() || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{ zIndex: HICAP_MODEL_PICKER_Z_INDEX }}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="flex justify-center items-center h-full input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<div
+							className="absolute top-[calc(100%-3px)] left-0 w-[calc(100%-2px)]
+							max-h-[200px] overflow-y-auto bg-[var(--vscode-dropdown-background)]
+							border border-[var(--vscode-list-activeSelectionBackground)]
+							rounded-b-[3px]"
+							ref={dropdownListRef}
+							role="listbox"
+							style={{ zIndex: HICAP_MODEL_PICKER_Z_INDEX - 1 }}>
+							{modelSearchResults.map((item, index) => {
+								const isFavorite = (favoritedModelIds || []).includes(item.id)
+								return (
+									<div
+										className={`p-[5px_10px] cursor-pointer break-all whitespace-normal ${
+											index === selectedIndex ? "bg-[var(--vscode-list-activeSelectionBackground)]" : ""
+										} hover:bg-[var(--vscode-list-activeSelectionBackground)]`}
+										key={item.id}
+										onClick={() => {
+											handleModelChange(item.id)
+											setIsDropdownVisible(false)
+										}}
+										onMouseEnter={() => setSelectedIndex(index)}
+										ref={(el) => (itemRefs.current[index] = el)}
+										role="option">
+										<div className="flex justify-between items-center [&_.model-item-highlight]:bg-[var(--vscode-editor-findMatchHighlightBackground)] [&_.model-item-highlight]:text-inherit">
+											<span dangerouslySetInnerHTML={{ __html: item.html }} />
+											<StarIcon
+												isFavorite={isFavorite}
+												onClick={(e) => {
+													e.stopPropagation()
+													StateServiceClient.toggleFavoriteModel(
+														StringRequest.create({ value: item.id }),
+													).catch((error) => console.error("Failed to toggle favorite model:", error))
+												}}
+											/>
+										</div>
+									</div>
+								)
+							})}
+						</div>
+					)}
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default HicapModelPicker
diff --git a/apps/vscode/webview-ui/src/components/settings/HuggingFaceModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/HuggingFaceModelPicker.tsx
new file mode 100644
index 0000000..cc16c30
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/HuggingFaceModelPicker.tsx
@@ -0,0 +1,251 @@
+import type { ModelInfo } from "@shared/api"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import React, { KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useMount } from "react-use"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { useExtensionState } from "../../context/ExtensionStateContext"
+import { ModelsServiceClient } from "../../services/grpc-client"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface HuggingFaceModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const HuggingFaceModelPicker: React.FC<HuggingFaceModelPickerProps> = ({ isPopup, currentMode }) => {
+	const { apiConfiguration, huggingFaceModels: dynamicModels, setHuggingFaceModels } = useExtensionState()
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	// Curated HuggingFace catalog from the SDK over gRPC. The local
+	// `dynamicModels` slice (populated by `refreshHuggingFaceModels`)
+	// is merged on top so live API additions remain visible.
+	const { models: huggingFaceModels, defaultModelId: huggingFaceDefaultModelId } = useProviderModels("huggingface")
+	const [searchTerm, setSearchTerm] = useState(modeFields.huggingFaceModelId || huggingFaceDefaultModelId)
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		const allModels = { ...huggingFaceModels, ...dynamicModels }
+		const modelInfo = allModels[newModelId as keyof typeof allModels]
+
+		handleModeFieldsChange(
+			{
+				huggingFaceModelId: { plan: "planModeHuggingFaceModelId", act: "actModeHuggingFaceModelId" },
+				huggingFaceModelInfo: { plan: "planModeHuggingFaceModelInfo", act: "actModeHuggingFaceModelInfo" },
+			},
+			{
+				huggingFaceModelId: newModelId,
+				huggingFaceModelInfo: modelInfo,
+			},
+			currentMode,
+		)
+		setSearchTerm(newModelId)
+	}
+
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("huggingface", apiConfiguration, currentMode)
+
+	useMount(() => {
+		ModelsServiceClient.refreshHuggingFaceModels(EmptyRequest.create({}))
+			.then((response) => {
+				// Seed with the SDK-known default (if loaded yet) so the
+				// picker always has at least one entry; then layer the
+				// live host-fetched models on top.
+				const seed: Record<string, ModelInfo> = {}
+				if (huggingFaceDefaultModelId && huggingFaceModels[huggingFaceDefaultModelId]) {
+					seed[huggingFaceDefaultModelId] = huggingFaceModels[huggingFaceDefaultModelId]
+				}
+				setHuggingFaceModels({
+					...seed,
+					...response.models,
+				})
+			})
+			.catch((err) => {
+				console.error("Failed to refresh Hugging Face models:", err)
+			})
+	})
+
+	// Sync external changes when the modelId changes
+	useEffect(() => {
+		const currentModelId = modeFields.huggingFaceModelId || huggingFaceDefaultModelId
+		setSearchTerm(currentModelId)
+	}, [modeFields.huggingFaceModelId])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const allModels = useMemo(() => {
+		return { ...huggingFaceModels, ...dynamicModels }
+	}, [dynamicModels])
+
+	const modelIds = useMemo(() => {
+		return Object.keys(allModels).sort((a, b) => a.localeCompare(b))
+	}, [allModels])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"],
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		const results: { id: string; html: string }[] = searchTerm
+			? highlight(fuse.search(searchTerm), "model-item-highlight")
+			: searchableItems
+		return results
+	}, [searchTerm, fuse, searchableItems])
+
+	const handleKeyDown = (e: KeyboardEvent<HTMLElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (e.key) {
+			case "ArrowDown":
+				e.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : 0))
+				break
+			case "ArrowUp":
+				e.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : modelSearchResults.length - 1))
+				break
+			case "Enter":
+				e.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					const selectedModelId = modelSearchResults[selectedIndex].id
+					handleModelChange(selectedModelId)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				e.preventDefault()
+				setIsDropdownVisible(false)
+				break
+		}
+	}
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex] && dropdownListRef.current) {
+			const selectedItem = itemRefs.current[selectedIndex]
+			const dropdown = dropdownListRef.current
+			const itemOffsetTop = selectedItem.offsetTop
+			const itemHeight = selectedItem.offsetHeight
+			const dropdownScrollTop = dropdown.scrollTop
+			const dropdownHeight = dropdown.offsetHeight
+
+			if (itemOffsetTop < dropdownScrollTop) {
+				dropdown.scrollTop = itemOffsetTop
+			} else if (itemOffsetTop + itemHeight > dropdownScrollTop + dropdownHeight) {
+				dropdown.scrollTop = itemOffsetTop + itemHeight - dropdownHeight
+			}
+		}
+	}, [selectedIndex])
+
+	return (
+		<div className="w-full">
+			<div className="flex flex-col">
+				<label htmlFor="hf-model-search">
+					<span className="font-medium">Model</span>
+				</label>
+
+				<div className="relative w-full" ref={dropdownRef}>
+					<VSCodeTextField
+						className="w-full relative z-1000"
+						id="hf-model-search"
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e: any) => {
+							setSearchTerm(e.target.value)
+							setIsDropdownVisible(true)
+							setSelectedIndex(-1)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search models..."
+						role="combobox"
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<div
+							className={`absolute top-[calc(100%-3px)] left-0 w-[calc(100%-2px)] ${
+								isPopup ? "max-h-[90px]" : "max-h-[200px]"
+							} overflow-y-auto bg-(--vscode-dropdown-background) border border-(--vscode-list-activeSelectionBackground) z-999 rounded-b-[3px]`}
+							ref={dropdownListRef}
+							role="listbox">
+							{modelSearchResults.map((result, index) => (
+								<div
+									className={`p-[5px_10px] cursor-pointer break-all whitespace-normal ${
+										index === selectedIndex ? "bg-(--vscode-list-activeSelectionBackground)" : ""
+									} hover:bg-(--vscode-list-activeSelectionBackground)`}
+									key={result.id}
+									onClick={() => {
+										handleModelChange(result.id)
+										setIsDropdownVisible(false)
+									}}
+									onMouseEnter={() => setSelectedIndex(index)}
+									ref={(el: HTMLDivElement | null) => (itemRefs.current[index] = el)}
+									role="option">
+									<div
+										className="[&_.model-item-highlight]:bg-(--vscode-editor-findMatchHighlightBackground) [&_.model-item-highlight]:text-inherit"
+										dangerouslySetInnerHTML={{ __html: result.html }}
+									/>
+								</div>
+							))}
+						</div>
+					)}
+				</div>
+			</div>
+
+			<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+		</div>
+	)
+}
+
+export { HuggingFaceModelPicker }
diff --git a/apps/vscode/webview-ui/src/components/settings/ModelDescriptionMarkdown.tsx b/apps/vscode/webview-ui/src/components/settings/ModelDescriptionMarkdown.tsx
new file mode 100644
index 0000000..7f1aea6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ModelDescriptionMarkdown.tsx
@@ -0,0 +1,62 @@
+import { memo, useEffect, useRef, useState } from "react"
+import { useRemark } from "react-remark"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+
+interface ModelDescriptionMarkdownProps {
+	markdown?: string
+	key: string
+	isPopup?: boolean
+}
+
+export const ModelDescriptionMarkdown = memo(({ markdown, key, isPopup }: ModelDescriptionMarkdownProps) => {
+	// Update the markdown content when the prop changes
+	const [reactContent, setMarkdown] = useRemark()
+	const contentRef = useRef<HTMLDivElement>(null)
+	const [isTruncated, setIsTruncated] = useState(false)
+	const [isExpanded, setIsExpanded] = useState(false)
+
+	useEffect(() => {
+		if (markdown) {
+			setIsExpanded(false)
+			setMarkdown(markdown)
+		}
+	}, [markdown, setMarkdown])
+
+	useEffect(() => {
+		if (contentRef.current && !isExpanded) {
+			const element = contentRef.current
+			// Check if content is truncated by comparing scrollHeight with clientHeight
+			setIsTruncated(element.scrollHeight > element.clientHeight)
+		}
+	}, [reactContent, isExpanded])
+
+	return (
+		<div className="inline-block mb-2 description line-clamp-3" key={key}>
+			<div className="relative wrap-anywhere overflow-y-hidden">
+				<div
+					className={cn("overflow-hidden text-sm line-clamp-3", {
+						"line-clamp-none": isExpanded,
+						"max-h-19": !isExpanded,
+					})}
+					ref={contentRef}>
+					{reactContent}
+				</div>
+				{isTruncated && (
+					<div className="absolute bottom-0 right-0 flex items-center">
+						<div className="w-10 h-5 bg-linear-to-r from-transparent to-sidebar-background" />
+						<Button
+							className={cn("bg-sidebar-background p-0 m-0 text-sm cursor-pointer", {
+								"bg-code-block-background": isPopup,
+							})}
+							onClick={() => setIsExpanded(!isExpanded)}
+							variant="link">
+							{isExpanded ? "See less" : "See more"}
+						</Button>
+					</div>
+				)}
+			</div>
+		</div>
+	)
+})
+ModelDescriptionMarkdown.displayName = "ModelDescriptionMarkdown"
diff --git a/apps/vscode/webview-ui/src/components/settings/OllamaModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/OllamaModelPicker.tsx
new file mode 100644
index 0000000..c1c79be
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/OllamaModelPicker.tsx
@@ -0,0 +1,224 @@
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import React, { KeyboardEvent, memo, useEffect, useMemo, useRef, useState } from "react"
+import styled from "styled-components"
+import { highlight } from "../history/HistoryView"
+
+const OLLAMA_MODEL_PICKER_Z_INDEX = 1_000
+
+interface OllamaModelPickerProps {
+	ollamaModels: string[]
+	selectedModelId: string
+	onModelChange: (modelId: string) => void
+	placeholder?: string
+}
+
+const OllamaModelPicker: React.FC<OllamaModelPickerProps> = ({
+	ollamaModels,
+	selectedModelId,
+	onModelChange,
+	placeholder = "Search and select a model...",
+}) => {
+	const [searchTerm, setSearchTerm] = useState(selectedModelId || "")
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		onModelChange(newModelId)
+		setSearchTerm(newModelId)
+	}
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const searchableItems = useMemo(() => {
+		return ollamaModels.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [ollamaModels])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"],
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		return searchTerm ? highlight(fuse.search(searchTerm), "ollama-model-item-highlight") : searchableItems
+	}, [searchableItems, searchTerm, fuse])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	// Update search term when selectedModelId changes externally
+	useEffect(() => {
+		if (selectedModelId !== searchTerm) {
+			setSearchTerm(selectedModelId || "")
+		}
+	}, [selectedModelId])
+
+	return (
+		<div style={{ width: "100%" }}>
+			<style>
+				{`
+				.ollama-model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<DropdownWrapper ref={dropdownRef}>
+				<VSCodeTextField
+					id="ollama-model-search"
+					onFocus={() => setIsDropdownVisible(true)}
+					onInput={(e) => {
+						const value = (e.target as HTMLInputElement)?.value || ""
+						handleModelChange(value)
+						setIsDropdownVisible(true)
+					}}
+					onKeyDown={handleKeyDown}
+					placeholder={placeholder}
+					role="combobox"
+					style={{
+						width: "100%",
+						zIndex: OLLAMA_MODEL_PICKER_Z_INDEX,
+						position: "relative",
+					}}
+					value={searchTerm}>
+					{searchTerm && (
+						<div
+							aria-label="Clear search"
+							className="input-icon-button codicon codicon-close"
+							onClick={() => {
+								handleModelChange("")
+								setIsDropdownVisible(true)
+							}}
+							slot="end"
+							style={{
+								display: "flex",
+								justifyContent: "center",
+								alignItems: "center",
+								height: "100%",
+							}}
+						/>
+					)}
+				</VSCodeTextField>
+				{isDropdownVisible && modelSearchResults.length > 0 && (
+					<DropdownList ref={dropdownListRef} role="listbox">
+						{modelSearchResults.map((item, index) => (
+							<DropdownItem
+								isSelected={index === selectedIndex}
+								key={item.id}
+								onClick={() => {
+									handleModelChange(item.id)
+									setIsDropdownVisible(false)
+								}}
+								onMouseEnter={() => setSelectedIndex(index)}
+								ref={(el) => (itemRefs.current[index] = el)}
+								role="option">
+								<span dangerouslySetInnerHTML={{ __html: item.html }} />
+							</DropdownItem>
+						))}
+					</DropdownList>
+				)}
+			</DropdownWrapper>
+		</div>
+	)
+}
+
+export default memo(OllamaModelPicker)
+
+// Dropdown styling
+
+const DropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+const DropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	z-index: ${OLLAMA_MODEL_PICKER_Z_INDEX - 1};
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const DropdownItem = styled.div<{ isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+
+	background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/OpenRouterModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/OpenRouterModelPicker.tsx
new file mode 100644
index 0000000..dba3580
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/OpenRouterModelPicker.tsx
@@ -0,0 +1,410 @@
+import { openAiModelInfoSafeDefaults, openRouterDefaultModelId } from "@shared/api"
+import { StringRequest } from "@shared/proto/cline/common"
+import type { Mode } from "@shared/storage/types"
+import { isClaudeOpusAdaptiveThinkingModel, resolveClaudeOpusAdaptiveThinking } from "@shared/utils/reasoning-support"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import type React from "react"
+import { type KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useMount } from "react-use"
+import styled from "styled-components"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { StateServiceClient } from "@/services/grpc-client"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import ReasoningEffortSelector from "./ReasoningEffortSelector"
+import ThinkingBudgetSlider from "./ThinkingBudgetSlider"
+import { filterOpenRouterModelIds, getModeSpecificFields, supportsReasoningEffortForModelId } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+// Star icon for favorites
+const StarIcon = ({ isFavorite, onClick }: { isFavorite: boolean; onClick: (e: React.MouseEvent) => void }) => {
+	return (
+		<div
+			onClick={onClick}
+			style={{
+				cursor: "pointer",
+				color: isFavorite ? "var(--vscode-terminal-ansiBlue)" : "var(--vscode-descriptionForeground)",
+				marginLeft: "8px",
+				fontSize: "16px",
+				display: "flex",
+				alignItems: "center",
+				justifyContent: "center",
+				userSelect: "none",
+				WebkitUserSelect: "none",
+			}}>
+			{isFavorite ? "★" : "☆"}
+		</div>
+	)
+}
+
+interface OpenRouterModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+	showProviderRouting?: boolean
+}
+
+const OpenRouterModelPicker: React.FC<OpenRouterModelPickerProps> = ({ isPopup, currentMode, showProviderRouting }) => {
+	const { handleModeFieldsChange, handleFieldChange } = useApiConfigurationHandlers()
+	const { commitSelection } = useProviderConfig("openrouter")
+	const { apiConfiguration, favoritedModelIds, openRouterModels, refreshOpenRouterModels } = useExtensionState()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const [searchTerm, setSearchTerm] = useState(modeFields.openRouterModelId || openRouterDefaultModelId)
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		// could be setting invalid model id/undefined info but validation will catch it
+
+		setSearchTerm(newModelId)
+
+		const modelInfo = openRouterModels[newModelId] ?? { ...openAiModelInfoSafeDefaults, name: newModelId }
+
+		handleModeFieldsChange(
+			{
+				openRouterModelId: { plan: "planModeOpenRouterModelId", act: "actModeOpenRouterModelId" },
+				openRouterModelInfo: { plan: "planModeOpenRouterModelInfo", act: "actModeOpenRouterModelInfo" },
+			},
+			{
+				openRouterModelId: newModelId,
+				openRouterModelInfo: modelInfo,
+			},
+			currentMode,
+		)
+
+		void commitSelection(currentMode, { providerId: "openrouter", modelId: newModelId, modelInfo }).catch((err) =>
+			console.error("Failed to commit OpenRouter model selection:", err),
+		)
+	}
+
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("openrouter", apiConfiguration, currentMode)
+
+	useMount(() => {
+		refreshOpenRouterModels()
+	})
+
+	// Sync external changes when the modelId changes
+	useEffect(() => {
+		const currentModelId = modeFields.openRouterModelId || openRouterDefaultModelId
+		setSearchTerm(currentModelId)
+	}, [modeFields.openRouterModelId])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const modelIds = useMemo(() => {
+		const unfilteredModelIds = Object.keys(openRouterModels).sort((a, b) => a.localeCompare(b))
+		return filterOpenRouterModelIds(unfilteredModelIds, "openrouter")
+	}, [openRouterModels])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"], // highlight function will update this
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		// IMPORTANT: highlightjs has a bug where if you use sort/localCompare - "// results.sort((a, b) => a.id.localeCompare(b.id)) ...sorting like this causes ids in objects to be reordered and mismatched"
+
+		// First, get all favorited models
+		const favoritedModels = searchableItems.filter((item) => favoritedModelIds.includes(item.id))
+
+		// Then get search results for non-favorited models
+		const searchResults = searchTerm
+			? highlight(fuse.search(searchTerm), "model-item-highlight").filter((item) => !favoritedModelIds.includes(item.id))
+			: searchableItems.filter((item) => !favoritedModelIds.includes(item.id))
+
+		// Combine favorited models with search results
+		return [...favoritedModels, ...searchResults]
+	}, [searchableItems, searchTerm, fuse, favoritedModelIds])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				} else {
+					// User typed a custom model ID
+					handleModelChange(searchTerm)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	const hasInfo = useMemo(() => {
+		try {
+			return modelIds.some((id) => id.toLowerCase() === searchTerm.toLowerCase())
+		} catch {
+			return false
+		}
+	}, [modelIds, searchTerm])
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	const selectedModelIdLower = selectedModelId?.toLowerCase() || ""
+	const showAdaptiveThinkingEffort = useMemo(() => isClaudeOpusAdaptiveThinkingModel(selectedModelId), [selectedModelId])
+	const adaptiveThinkingDefaultEffort = useMemo(
+		() => resolveClaudeOpusAdaptiveThinking(modeFields.reasoningEffort, modeFields.thinkingBudgetTokens).effort ?? "none",
+		[modeFields.reasoningEffort, modeFields.thinkingBudgetTokens],
+	)
+	const showReasoningEffort = useMemo(
+		() => showAdaptiveThinkingEffort || supportsReasoningEffortForModelId(selectedModelId),
+		[selectedModelId, showAdaptiveThinkingEffort],
+	)
+
+	const showBudgetSlider = useMemo(() => {
+		if (showReasoningEffort) {
+			return false
+		}
+		return (
+			Object.entries(openRouterModels)?.some(([id, m]) => id === selectedModelId && m.thinkingConfig) ||
+			selectedModelIdLower.includes("claude-haiku-4.5") ||
+			selectedModelIdLower.includes("claude-4.5-haiku") ||
+			selectedModelIdLower.includes("claude-sonnet-4.6") ||
+			selectedModelIdLower.includes("claude-sonnet-4-6") ||
+			selectedModelIdLower.includes("claude-4.6-sonnet") ||
+			selectedModelIdLower.includes("claude-sonnet-4.5") ||
+			selectedModelIdLower.includes("claude-sonnet-4") ||
+			selectedModelIdLower.includes("claude-opus-4.1") ||
+			selectedModelIdLower.includes("claude-opus-4") ||
+			selectedModelIdLower.includes("claude-3-7-sonnet") ||
+			selectedModelIdLower.includes("claude-3.7-sonnet") ||
+			selectedModelIdLower.includes("claude-3.7-sonnet:thinking")
+		)
+	}, [openRouterModels, selectedModelId, selectedModelIdLower, showReasoningEffort])
+
+	return (
+		<div style={{ width: "100%", paddingBottom: 2 }}>
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div style={{ display: "flex", flexDirection: "column" }}>
+				<label htmlFor="model-search">
+					<span style={{ fontWeight: 500 }}>Model</span>
+				</label>
+
+				<DropdownWrapper ref={dropdownRef}>
+					<VSCodeTextField
+						id="model-search"
+						onBlur={() => {
+							if (searchTerm !== selectedModelId) {
+								handleModelChange(searchTerm)
+							}
+						}}
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value.toLowerCase() || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: OPENROUTER_MODEL_PICKER_Z_INDEX,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<DropdownList ref={dropdownListRef} role="listbox">
+							{modelSearchResults.map((item, index) => {
+								const isFavorite = (favoritedModelIds || []).includes(item.id)
+								return (
+									<DropdownItem
+										isSelected={index === selectedIndex}
+										key={item.id}
+										onClick={() => {
+											handleModelChange(item.id)
+											setIsDropdownVisible(false)
+										}}
+										onMouseEnter={() => setSelectedIndex(index)}
+										ref={(el) => (itemRefs.current[index] = el)}
+										role="option">
+										<div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+											<span dangerouslySetInnerHTML={{ __html: item.html }} />
+											<StarIcon
+												isFavorite={isFavorite}
+												onClick={(e) => {
+													e.stopPropagation()
+													StateServiceClient.toggleFavoriteModel(
+														StringRequest.create({ value: item.id }),
+													).catch((error) => console.error("Failed to toggle favorite model:", error))
+												}}
+											/>
+										</div>
+									</DropdownItem>
+								)
+							})}
+						</DropdownList>
+					)}
+				</DropdownWrapper>
+			</div>
+
+			{hasInfo ? (
+				<>
+					{showBudgetSlider && <ThinkingBudgetSlider currentMode={currentMode} />}
+					{showReasoningEffort && (
+						<ReasoningEffortSelector
+							allowedEfforts={
+								showAdaptiveThinkingEffort ? (["none", "low", "medium", "high", "xhigh"] as const) : undefined
+							}
+							currentMode={currentMode}
+							defaultEffort={showAdaptiveThinkingEffort ? adaptiveThinkingDefaultEffort : "medium"}
+							description={
+								showAdaptiveThinkingEffort
+									? "Use None to disable adaptive thinking. Higher effort increases response detail and token usage."
+									: undefined
+							}
+							label={showAdaptiveThinkingEffort ? "Adaptive Thinking" : undefined}
+						/>
+					)}
+
+					<ModelInfoView
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						onProviderSortingChange={(value) => handleFieldChange("openRouterProviderSorting", value)}
+						providerSorting={apiConfiguration?.openRouterProviderSorting}
+						selectedModelId={selectedModelId}
+						showProviderRouting={showProviderRouting}
+					/>
+				</>
+			) : (
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: 0,
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					The extension automatically fetches the latest list of models available on{" "}
+					<VSCodeLink href="https://openrouter.ai/models" style={{ display: "inline", fontSize: "inherit" }}>
+						OpenRouter.
+					</VSCodeLink>
+					If you're unsure which model to choose, compare available models by context window, pricing, and capabilities.
+					You can also try searching "free" for no-cost options currently available.
+				</p>
+			)}
+		</div>
+	)
+}
+
+export default OpenRouterModelPicker
+
+// Dropdown
+
+const DropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+export const OPENROUTER_MODEL_PICKER_Z_INDEX = 1_000
+
+const DropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	z-index: ${OPENROUTER_MODEL_PICKER_Z_INDEX - 1};
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const DropdownItem = styled.div<{ isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+
+	background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/PreferredLanguageSetting.tsx b/apps/vscode/webview-ui/src/components/settings/PreferredLanguageSetting.tsx
new file mode 100644
index 0000000..e4b7551
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/PreferredLanguageSetting.tsx
@@ -0,0 +1,49 @@
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import React from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { updateSetting } from "./utils/settingsHandlers"
+
+const PreferredLanguageSetting: React.FC = () => {
+	const { preferredLanguage } = useExtensionState()
+
+	const handleLanguageChange = (newLanguage: string) => {
+		updateSetting("preferredLanguage", newLanguage)
+	}
+
+	return (
+		<div style={{}}>
+			<label className="block mb-1 text-base font-medium" htmlFor="preferred-language-dropdown">
+				Preferred Language
+			</label>
+			<VSCodeDropdown
+				currentValue={preferredLanguage || "English"}
+				id="preferred-language-dropdown"
+				onChange={(e: any) => {
+					handleLanguageChange(e.target.value)
+				}}
+				style={{ width: "100%" }}>
+				<VSCodeOption value="English">English</VSCodeOption>
+				<VSCodeOption value="Arabic - العربية">Arabic - العربية</VSCodeOption>
+				<VSCodeOption value="Portuguese - Português (Brasil)">Portuguese - Português (Brasil)</VSCodeOption>
+				<VSCodeOption value="Czech - Čeština">Czech - Čeština</VSCodeOption>
+				<VSCodeOption value="French - Français">French - Français</VSCodeOption>
+				<VSCodeOption value="German - Deutsch">German - Deutsch</VSCodeOption>
+				<VSCodeOption value="Hindi - हिन्दी">Hindi - हिन्दी</VSCodeOption>
+				<VSCodeOption value="Hungarian - Magyar">Hungarian - Magyar</VSCodeOption>
+				<VSCodeOption value="Italian - Italiano">Italian - Italiano</VSCodeOption>
+				<VSCodeOption value="Japanese - 日本語">Japanese - 日本語</VSCodeOption>
+				<VSCodeOption value="Korean - 한국어">Korean - 한국어</VSCodeOption>
+				<VSCodeOption value="Polish - Polski">Polish - Polski</VSCodeOption>
+				<VSCodeOption value="Portuguese - Português (Portugal)">Portuguese - Português (Portugal)</VSCodeOption>
+				<VSCodeOption value="Russian - Русский">Russian - Русский</VSCodeOption>
+				<VSCodeOption value="Simplified Chinese - 简体中文">Simplified Chinese - 简体中文</VSCodeOption>
+				<VSCodeOption value="Spanish - Español">Spanish - Español</VSCodeOption>
+				<VSCodeOption value="Traditional Chinese - 繁體中文">Traditional Chinese - 繁體中文</VSCodeOption>
+				<VSCodeOption value="Turkish - Türkçe">Turkish - Türkçe</VSCodeOption>
+			</VSCodeDropdown>
+			<p className="text-sm text-description mt-1">The language that Cline should use for communication.</p>
+		</div>
+	)
+}
+
+export default React.memo(PreferredLanguageSetting)
diff --git a/apps/vscode/webview-ui/src/components/settings/README.md b/apps/vscode/webview-ui/src/components/settings/README.md
new file mode 100644
index 0000000..449248d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/README.md
@@ -0,0 +1,160 @@
+# API Options Component Architecture
+
+This directory contains the refactored API Options components for the Cline extension. The refactoring aims to improve maintainability, code organization, and reduce complexity by separating provider-specific code into modular components.
+
+## Directory Structure
+
+```
+settings/
+├── ApiOptions.tsx               # Main component that renders provider-specific components
+├── common/                      # Reusable UI components
+│   ├── ApiKeyField.tsx         # API key input with standard styling
+│   ├── BaseUrlField.tsx        # Base URL input with standard styling
+│   ├── ErrorMessage.tsx        # Standard error message display
+│   ├── ModelInfoView.tsx       # Model information display
+│   └── ModelSelector.tsx       # Model selection dropdown
+├── providers/                   # Provider-specific components
+│   ├── ClineProvider.tsx       # Cline configuration
+│   ├── AnthropicProvider.tsx   # Anthropic-specific configuration
+│   ├── BedrockProvider.tsx     # AWS Bedrock configuration
+│   ├── GenericProviderSettings.tsx # Shared generic provider configuration
+│   ├── MistralProvider.tsx     # Mistral configuration
+│   ├── OllamaProvider.tsx      # Ollama configuration
+│   ├── OpenAICompatibleProvider.tsx  # OpenAI compatible API configuration
+│   ├── OpenRouterProvider.tsx  # OpenRouter configuration
+│   └── ...
+└── utils/                       # Utility functions
+    ├── pricingUtils.ts         # Pricing formatting utilities
+    └── providerUtils.ts        # API configuration normalization
+
+```
+
+## Architecture
+
+### Component Hierarchy
+
+```
+ApiOptions
+└── [ProviderComponent] (based on selected provider)
+    ├── ApiKeyField (if needed)
+    ├── BaseUrlField (if needed)
+    ├── ModelSelector (if showing model options)
+    └── ModelInfoView (if showing model options)
+```
+
+### Data Flow
+
+1. `ApiOptions` receives the current API configuration from the extension state
+2. When a provider is selected, it renders the corresponding provider component
+3. Provider-specific components receive `apiConfiguration` and `handleInputChange` to manage their state
+4. Changes are propagated back to the extension via the `handleInputChange` callback
+
+## Adding a New Provider
+
+To add a new provider:
+
+1. Create a new file in the `providers` directory, e.g. `MyNewProvider.tsx`
+2. Implement the provider component using this template:
+
+```tsx
+import { ApiConfiguration, myNewProviderModels } from "@shared/api"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { ModelSelector } from "../common/ModelSelector"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { normalizeApiConfiguration } from "../utils/providerUtils"
+
+/**
+ * Props for the MyNewProvider component
+ */
+interface MyNewProviderProps {
+  apiConfiguration: ApiConfiguration
+  handleInputChange: (field: keyof ApiConfiguration) => (event: any) => void
+  showModelOptions: boolean
+  isPopup?: boolean
+}
+
+/**
+ * The MyNewProvider configuration component
+ */
+export const MyNewProvider = ({
+  apiConfiguration,
+  handleInputChange,
+  showModelOptions,
+  isPopup,
+}: MyNewProviderProps) => {
+  // Get the normalized configuration
+  const { selectedModelId, selectedModelInfo } = normalizeApiConfiguration(apiConfiguration)
+
+  return (
+    <div>
+      {/* Add provider-specific fields */}
+      <ApiKeyField
+        value={apiConfiguration?.myNewProviderApiKey || ""}
+        onChange={handleInputChange("myNewProviderApiKey")}
+        providerName="My New Provider"
+        signupUrl="https://mynewprovider.com/signup"
+      />
+
+      {/* Optional: Base URL field if the provider supports custom endpoints */}
+      <BaseUrlField
+        value={apiConfiguration?.myNewProviderBaseUrl}
+        onChange={handleInputChange("myNewProviderBaseUrl")}
+        defaultPlaceholder="https://api.mynewprovider.com"
+      />
+
+      {showModelOptions && (
+        <>
+          <ModelSelector
+            models={myNewProviderModels}
+            selectedModelId={selectedModelId}
+            onChange={handleInputChange("apiModelId")}
+            label="Model"
+          />
+
+          <ModelInfoView
+            selectedModelId={selectedModelId}
+            modelInfo={selectedModelInfo}
+            isPopup={isPopup}
+          />
+        </>
+      )}
+    </div>
+  )
+}
+```
+
+3. Import and add the new provider component to `ApiOptions.tsx`:
+
+```tsx
+import { MyNewProvider } from "./providers/MyNewProvider"
+
+// ...
+
+{apiConfiguration && selectedProvider === "mynewprovider" && (
+  <MyNewProvider
+    apiConfiguration={apiConfiguration}
+    handleInputChange={handleInputChange}
+    showModelOptions={showModelOptions}
+    isPopup={isPopup}
+  />
+)}
+```
+
+4. Add the provider to the dropdown options:
+
+```tsx
+<VSCodeOption value="mynewprovider">My New Provider</VSCodeOption>
+```
+
+## Best Practices
+
+1. **Reuse Common Components**: Use the common components for consistent UI and behavior
+2. **Provider-Specific Logic**: Keep provider-specific logic within the provider component
+3. **Type Safety**: Ensure all props and state are properly typed
+4. **Error Handling**: Handle edge cases gracefully, such as missing configurations
+5. **Documentation**: Document any provider-specific behaviors or requirements
+
+## Testing
+
+Each provider component should be tested in isolation to ensure it renders correctly and handles user input properly.
diff --git a/apps/vscode/webview-ui/src/components/settings/ReasoningEffortSelector.tsx b/apps/vscode/webview-ui/src/components/settings/ReasoningEffortSelector.tsx
new file mode 100644
index 0000000..5ba4c6a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ReasoningEffortSelector.tsx
@@ -0,0 +1,70 @@
+import { isOpenaiReasoningEffort, Mode, OPENAI_REASONING_EFFORT_OPTIONS, OpenaiReasoningEffort } from "@shared/storage/types"
+import { memo } from "react"
+import { Label } from "@/components/ui/label"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface ReasoningEffortSelectorProps {
+	currentMode: Mode
+	label?: string
+	description?: string
+	allowedEfforts?: readonly OpenaiReasoningEffort[]
+	defaultEffort?: OpenaiReasoningEffort
+	/** Optional callback invoked after the effort value changes. Use to persist to provider-specific stores. */
+	onEffortChange?: (effort: OpenaiReasoningEffort) => void
+}
+
+const ReasoningEffortSelector = ({
+	currentMode,
+	label = "Reasoning Effort",
+	description = "Higher effort improves depth, but uses more tokens.",
+	allowedEfforts = OPENAI_REASONING_EFFORT_OPTIONS,
+	defaultEffort = "medium",
+	onEffortChange,
+}: ReasoningEffortSelectorProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleModeFieldChange } = useApiConfigurationHandlers()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const selectedEffort =
+		isOpenaiReasoningEffort(modeFields.reasoningEffort) && allowedEfforts.includes(modeFields.reasoningEffort)
+			? modeFields.reasoningEffort
+			: defaultEffort
+
+	return (
+		<div style={{ marginTop: 10, marginBottom: 5 }}>
+			<Label className="text-xs font-medium">{label}</Label>
+			<Select
+				onValueChange={(value) => {
+					handleModeFieldChange({ plan: "planModeReasoningEffort", act: "actModeReasoningEffort" }, value, currentMode)
+					if (onEffortChange && isOpenaiReasoningEffort(value)) {
+						onEffortChange(value)
+					}
+				}}
+				value={selectedEffort}>
+				<SelectTrigger className="w-full mt-1">
+					<SelectValue />
+				</SelectTrigger>
+				<SelectContent>
+					{allowedEfforts.map((effort) => (
+						<SelectItem key={effort} value={effort}>
+							{effort.charAt(0).toUpperCase() + effort.slice(1)}
+						</SelectItem>
+					))}
+				</SelectContent>
+			</Select>
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					marginBottom: 0,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				{description}
+			</p>
+		</div>
+	)
+}
+
+export default memo(ReasoningEffortSelector)
diff --git a/apps/vscode/webview-ui/src/components/settings/RequestyModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/RequestyModelPicker.tsx
new file mode 100644
index 0000000..de3a4fd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/RequestyModelPicker.tsx
@@ -0,0 +1,311 @@
+import { requestyDefaultModelId, requestyDefaultModelInfo } from "@shared/api"
+import { toRequestyServiceUrl } from "@shared/clients/requesty"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import React, { KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useMount } from "react-use"
+import styled from "styled-components"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useExtensionState } from "../../context/ExtensionStateContext"
+import { ModelsServiceClient } from "../../services/grpc-client"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import ThinkingBudgetSlider from "./ThinkingBudgetSlider"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface RequestyModelPickerProps {
+	isPopup?: boolean
+	baseUrl?: string
+	currentMode: Mode
+}
+
+const RequestyModelPicker: React.FC<RequestyModelPickerProps> = ({ isPopup, baseUrl, currentMode }) => {
+	const { apiConfiguration, requestyModels, setRequestyModels } = useExtensionState()
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const [searchTerm, setSearchTerm] = useState(modeFields.requestyModelId || requestyDefaultModelId)
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const resolvedUrl = toRequestyServiceUrl(baseUrl)
+	const requestyModelListUrl = resolvedUrl != null ? new URL("models", resolvedUrl) : undefined
+
+	const handleModelChange = (newModelId: string) => {
+		// could be setting invalid model id/undefined info but validation will catch it
+
+		handleModeFieldsChange(
+			{
+				requestyModelId: {
+					plan: "planModeRequestyModelId",
+					act: "actModeRequestyModelId",
+				},
+				requestyModelInfo: {
+					plan: "planModeRequestyModelInfo",
+					act: "actModeRequestyModelInfo",
+				},
+			},
+			{
+				requestyModelId: newModelId,
+				requestyModelInfo: requestyModels[newModelId],
+			},
+			currentMode,
+		)
+		setSearchTerm(newModelId)
+	}
+
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("requesty", apiConfiguration, currentMode)
+
+	useMount(() => {
+		ModelsServiceClient.refreshRequestyModels(EmptyRequest.create({}))
+			.then((response) => {
+				setRequestyModels({
+					[requestyDefaultModelId]: requestyDefaultModelInfo,
+					...response.models,
+				})
+			})
+			.catch((err) => {
+				console.error("Failed to refresh Requesty models:", err)
+			})
+	})
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const modelIds = useMemo(() => {
+		return Object.keys(requestyModels).sort((a, b) => a.localeCompare(b))
+	}, [requestyModels])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"], // highlight function will update this
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		const results: { id: string; html: string }[] = searchTerm
+			? highlight(fuse.search(searchTerm), "model-item-highlight")
+			: searchableItems
+		// results.sort((a, b) => a.id.localeCompare(b.id)) NOTE: sorting like this causes ids in objects to be reordered and mismatched
+		return results
+	}, [searchableItems, searchTerm, fuse])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	const hasInfo = useMemo(() => {
+		try {
+			return modelIds.some((id) => id.toLowerCase() === searchTerm.toLowerCase())
+		} catch {
+			return false
+		}
+	}, [modelIds, searchTerm])
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	const showBudgetSlider = useMemo(() => {
+		return selectedModelId?.includes("claude-3-7-sonnet")
+	}, [selectedModelId])
+
+	return (
+		<div style={{ width: "100%" }}>
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div style={{ display: "flex", flexDirection: "column" }}>
+				<label htmlFor="model-search">
+					<span style={{ fontWeight: 500 }}>Model</span>
+				</label>
+				<DropdownWrapper ref={dropdownRef}>
+					<VSCodeTextField
+						id="model-search"
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							handleModelChange((e.target as HTMLInputElement)?.value?.toLowerCase())
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: REQUESTY_MODEL_PICKER_Z_INDEX,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									handleModelChange("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<DropdownList ref={dropdownListRef} role="listbox">
+							{modelSearchResults.map((item, index) => (
+								<DropdownItem
+									dangerouslySetInnerHTML={{
+										__html: item.html,
+									}}
+									isSelected={index === selectedIndex}
+									key={item.id}
+									onClick={() => {
+										handleModelChange(item.id)
+										setIsDropdownVisible(false)
+									}}
+									onMouseEnter={() => setSelectedIndex(index)}
+									ref={(el) => (itemRefs.current[index] = el)}
+									role="option"
+								/>
+							))}
+						</DropdownList>
+					)}
+				</DropdownWrapper>
+			</div>
+
+			{hasInfo ? (
+				<>
+					{showBudgetSlider && <ThinkingBudgetSlider currentMode={currentMode} />}
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			) : (
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: 0,
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					<>
+						The extension automatically fetches the latest list of models available on{" "}
+						<VSCodeLink href={requestyModelListUrl?.toString()} style={{ display: "inline", fontSize: "inherit" }}>
+							Requesty.
+						</VSCodeLink>
+						If you're unsure which model to choose, compare available models by context window, pricing, and
+						capabilities.
+					</>
+				</p>
+			)}
+		</div>
+	)
+}
+
+export default RequestyModelPicker
+
+// Dropdown
+
+const DropdownWrapper = styled.div`
+  position: relative;
+  width: 100%;
+`
+
+const REQUESTY_MODEL_PICKER_Z_INDEX = 1_000
+
+const DropdownList = styled.div`
+  position: absolute;
+  top: calc(100% - 3px);
+  left: 0;
+  width: calc(100% - 2px);
+  max-height: 200px;
+  overflow-y: auto;
+  background-color: var(--vscode-dropdown-background);
+  border: 1px solid var(--vscode-list-activeSelectionBackground);
+  z-index: ${REQUESTY_MODEL_PICKER_Z_INDEX - 1};
+  border-bottom-left-radius: 3px;
+  border-bottom-right-radius: 3px;
+`
+
+const DropdownItem = styled.div<{ isSelected: boolean }>`
+  padding: 5px 10px;
+  cursor: pointer;
+  word-break: break-all;
+  white-space: normal;
+
+  background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+  &:hover {
+    background-color: var(--vscode-list-activeSelectionBackground);
+  }
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/SapAiCoreModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/SapAiCoreModelPicker.tsx
new file mode 100644
index 0000000..067212e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/SapAiCoreModelPicker.tsx
@@ -0,0 +1,194 @@
+import { SapAiCoreModelDeployment } from "@shared/proto/index.cline"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import React, { memo, useEffect, useMemo } from "react"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { DropdownContainer } from "./common/ModelSelector"
+
+const SAP_AI_CORE_MODEL_PICKER_Z_INDEX = 1_000
+
+interface SapAiCoreModelPickerProps {
+	sapAiCoreModelDeployments: SapAiCoreModelDeployment[]
+	selectedModelId: string
+	selectedDeploymentId?: string
+	onModelChange: (modelId: string, deploymentId: string) => void
+	placeholder?: string
+	useOrchestrationMode?: boolean
+}
+
+interface CategorizedModel {
+	id: string
+	isDeployed: boolean
+	section: "deployed" | "supported"
+}
+
+function isSapAiCoreFoundationChatModel(modelId: string): boolean {
+	const normalizedModelId = modelId.trim().toLowerCase()
+	const unsupportedModelKinds = ["base", "codex", "instruct", "realtime"]
+	return /^gpt-?\d/.test(normalizedModelId) && !unsupportedModelKinds.some((kind) => normalizedModelId.includes(kind))
+}
+
+const SapAiCoreModelPicker: React.FC<SapAiCoreModelPickerProps> = ({
+	sapAiCoreModelDeployments,
+	selectedModelId,
+	selectedDeploymentId,
+	onModelChange,
+	placeholder = "Select a model...",
+	useOrchestrationMode = true,
+}) => {
+	const { models: sapAiCoreModels } = useProviderModels("sapaicore")
+
+	const visibleSapAiCoreModels = useMemo(() => {
+		if (useOrchestrationMode) {
+			return sapAiCoreModels
+		}
+
+		return Object.fromEntries(Object.entries(sapAiCoreModels).filter(([modelId]) => isSapAiCoreFoundationChatModel(modelId)))
+	}, [sapAiCoreModels, useOrchestrationMode])
+
+	// Auto-fix deployment ID mismatch or missing deployment ID when deployments change (when ai core creds changes)
+	useEffect(() => {
+		if (!selectedModelId) {
+			return
+		}
+
+		const matchingDeployment = sapAiCoreModelDeployments.find((d) => d.modelName === selectedModelId)
+
+		if (matchingDeployment) {
+			// deployment found - update if different
+			if (!selectedDeploymentId || matchingDeployment.deploymentId !== selectedDeploymentId) {
+				onModelChange(selectedModelId, matchingDeployment.deploymentId)
+			}
+		} else if (sapAiCoreModelDeployments.length > 0 && selectedDeploymentId) {
+			// deployments loaded, but none match the selected model, which means the model is not deployed
+			onModelChange(selectedModelId, "")
+		}
+	}, [sapAiCoreModelDeployments, selectedModelId, selectedDeploymentId, onModelChange])
+
+	const handleModelChange = (e: any) => {
+		const newModelId = e.target.value
+
+		if (!newModelId) {
+			return
+		}
+
+		// Find the deployment that matches the selected model
+		const deployment = sapAiCoreModelDeployments.find((d) => d.modelName === newModelId)
+
+		if (deployment) {
+			// Deployed model: use the deployment ID
+			onModelChange(deployment.modelName, deployment.deploymentId)
+		} else {
+			// Undeployed model: use empty deployment ID
+			onModelChange(newModelId, "")
+		}
+	}
+
+	const categorizedModels = useMemo(() => {
+		const allSupportedModels = Object.keys(visibleSapAiCoreModels)
+
+		// Models that are both deployed AND supported in Cline
+		const deployedModelNames = sapAiCoreModelDeployments.map((d) => d.modelName)
+		const deployedAndSupported = deployedModelNames.filter((deployedModel: string) =>
+			allSupportedModels.includes(deployedModel),
+		)
+
+		// Models that are supported in Cline but NOT deployed
+		const supportedButNotDeployed = allSupportedModels.filter(
+			(supportedModel: string) => !deployedModelNames.includes(supportedModel),
+		)
+
+		const deployed: CategorizedModel[] = deployedAndSupported.map((modelName: string) => ({
+			id: modelName,
+			isDeployed: true,
+			section: "deployed" as const,
+		}))
+
+		const supported: CategorizedModel[] = supportedButNotDeployed.map((id: string) => ({
+			id,
+			isDeployed: false,
+			section: "supported" as const,
+		}))
+
+		return { deployed, supported }
+	}, [sapAiCoreModelDeployments, visibleSapAiCoreModels])
+
+	const renderOptions = () => {
+		const options: React.ReactNode[] = []
+
+		// Add placeholder option
+		options.push(
+			<VSCodeOption key="placeholder" value="">
+				{placeholder}
+			</VSCodeOption>,
+		)
+
+		if (useOrchestrationMode) {
+			// Orchestration mode: Show all supported models in one flat list (no separators)
+			const allSupportedModels = Object.keys(visibleSapAiCoreModels)
+			allSupportedModels.forEach((modelId) => {
+				options.push(
+					<VSCodeOption key={modelId} value={modelId}>
+						{modelId}
+					</VSCodeOption>,
+				)
+			})
+		} else {
+			// Non-orchestration mode: Show sectioned layout with separators
+			// Add deployed models section
+			if (categorizedModels.deployed.length > 0) {
+				// Add section separator (disabled option)
+				options.push(
+					<VSCodeOption disabled key="deployed-header" value="">
+						── Deployed Models ──
+					</VSCodeOption>,
+				)
+
+				categorizedModels.deployed.forEach((model) => {
+					options.push(
+						<VSCodeOption key={model.id} value={model.id}>
+							{model.id}
+						</VSCodeOption>,
+					)
+				})
+			}
+
+			// Add supported but not deployed models section
+			if (categorizedModels.supported.length > 0) {
+				// Add section separator (disabled option)
+				options.push(
+					<VSCodeOption disabled key="supported-header" value="">
+						── Not Deployed Models ──
+					</VSCodeOption>,
+				)
+
+				categorizedModels.supported.forEach((model) => {
+					options.push(
+						<VSCodeOption key={model.id} style={{ opacity: 0.6 }} value={model.id}>
+							{model.id}
+						</VSCodeOption>,
+					)
+				})
+			}
+		}
+
+		return options
+	}
+
+	return (
+		<DropdownContainer className="dropdown-container" zIndex={SAP_AI_CORE_MODEL_PICKER_Z_INDEX}>
+			<label htmlFor="sap-ai-core-model-dropdown">
+				<span className="font-medium">Model</span>
+			</label>
+			<VSCodeDropdown
+				id="sap-ai-core-model-dropdown"
+				key={`sap-ai-core-dropdown-${useOrchestrationMode}`}
+				onChange={handleModelChange}
+				style={{ width: "100%" }}
+				value={selectedModelId}>
+				{renderOptions()}
+			</VSCodeDropdown>
+		</DropdownContainer>
+	)
+}
+
+export default memo(SapAiCoreModelPicker)
diff --git a/apps/vscode/webview-ui/src/components/settings/Section.tsx b/apps/vscode/webview-ui/src/components/settings/Section.tsx
new file mode 100644
index 0000000..478f0bf
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/Section.tsx
@@ -0,0 +1,9 @@
+import { HTMLAttributes } from "react"
+
+type SectionProps = HTMLAttributes<HTMLDivElement>
+
+const Section = ({ className, ...props }: SectionProps) => (
+	<div className={`flex flex-col gap-3 pl-[16px] pr-[12px] py-2 ${className || ""}`} {...props} />
+)
+
+export default Section
diff --git a/apps/vscode/webview-ui/src/components/settings/SectionHeader.tsx b/apps/vscode/webview-ui/src/components/settings/SectionHeader.tsx
new file mode 100644
index 0000000..cfaf546
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/SectionHeader.tsx
@@ -0,0 +1,18 @@
+import { cn } from "@heroui/theme"
+import { HTMLAttributes } from "react"
+
+type SectionHeaderProps = HTMLAttributes<HTMLDivElement> & {
+	children: React.ReactNode
+	description?: string
+}
+
+const SectionHeader = ({ description, children, className, ...props }: SectionHeaderProps) => {
+	return (
+		<div className={cn("text-foreground px-5 py-3", className)} {...props}>
+			<h2 className="m-0 text-base">{children}</h2>
+			{description && <p className="text-description text-sm mt-2 mb-0">{description}</p>}
+		</div>
+	)
+}
+
+export default SectionHeader
diff --git a/apps/vscode/webview-ui/src/components/settings/SettingsView.tsx b/apps/vscode/webview-ui/src/components/settings/SettingsView.tsx
new file mode 100644
index 0000000..a292f3d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/SettingsView.tsx
@@ -0,0 +1,268 @@
+import type { ExtensionMessage } from "@shared/ExtensionMessage"
+import { isClineInternalTester } from "@shared/internal/account"
+import { ResetStateRequest } from "@shared/proto/cline/state"
+import type { UserOrganization } from "@shared/proto/index.cline"
+import {
+	CheckCheck,
+	FlaskConical,
+	HardDriveDownload,
+	Info,
+	type LucideIcon,
+	SlidersHorizontal,
+	SquareTerminal,
+	Wrench,
+} from "lucide-react"
+import { useCallback, useEffect, useMemo, useState } from "react"
+import { useEvent } from "react-use"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { type ClineUser, useClineAuth } from "@/context/ClineAuthContext"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { cn } from "@/lib/utils"
+import { StateServiceClient } from "@/services/grpc-client"
+import { isAdminOrOwner } from "../account/helpers"
+import { Tab, TabContent, TabList, TabTrigger } from "../common/Tab"
+import ViewHeader from "../common/ViewHeader"
+import SectionHeader from "./SectionHeader"
+import AboutSection from "./sections/AboutSection"
+import ApiConfigurationSection from "./sections/ApiConfigurationSection"
+import DebugSection from "./sections/DebugSection"
+import FeatureSettingsSection from "./sections/FeatureSettingsSection"
+import GeneralSettingsSection from "./sections/GeneralSettingsSection"
+import { RemoteConfigSection } from "./sections/RemoteConfigSection"
+import TerminalSettingsSection from "./sections/TerminalSettingsSection"
+
+const IS_DEV = process.env.IS_DEV
+
+// Tab definitions
+type SettingsTabID = "api-config" | "features" | "terminal" | "general" | "about" | "debug" | "remote-config"
+interface SettingsTab {
+	id: SettingsTabID
+	name: string
+	tooltipText: string
+	headerText: string
+	icon: LucideIcon
+	hidden?: (params?: { user: ClineUser | null; activeOrganization: UserOrganization | null }) => boolean
+}
+
+const SETTINGS_TABS: SettingsTab[] = [
+	{
+		id: "api-config",
+		name: "API Configuration",
+		tooltipText: "API Configuration",
+		headerText: "API Configuration",
+		icon: SlidersHorizontal,
+	},
+	{
+		id: "features",
+		name: "Features",
+		tooltipText: "Feature Settings",
+		headerText: "Feature Settings",
+		icon: CheckCheck,
+	},
+	{
+		id: "terminal",
+		name: "Terminal",
+		tooltipText: "Terminal Settings",
+		headerText: "Terminal Settings",
+		icon: SquareTerminal,
+	},
+	{
+		id: "general",
+		name: "General",
+		tooltipText: "General Settings",
+		headerText: "General Settings",
+		icon: Wrench,
+	},
+	{
+		id: "remote-config",
+		name: "Remote Config",
+		tooltipText: "Remotely configured fields",
+		headerText: "Remote Config",
+		icon: HardDriveDownload,
+		hidden: ({ activeOrganization } = { user: null, activeOrganization: null }) =>
+			!activeOrganization || !isAdminOrOwner(activeOrganization),
+	},
+	{
+		id: "about",
+		name: "About",
+		tooltipText: "About Cline",
+		headerText: "About",
+		icon: Info,
+	},
+	// Only show in dev mode
+	{
+		id: "debug",
+		name: "Debug",
+		tooltipText: "Debug Tools",
+		headerText: "Debug",
+		icon: FlaskConical,
+		hidden: ({ user } = { user: null, activeOrganization: null }) => !IS_DEV && !isClineInternalTester(user?.email || ""),
+	},
+]
+
+type SettingsViewProps = {
+	onDone: () => void
+	targetSection?: string
+}
+
+// Helper to render section header - moved outside component for better performance
+const renderSectionHeader = (tabId: string) => {
+	const tab = SETTINGS_TABS.find((t) => t.id === tabId)
+	if (!tab) {
+		return null
+	}
+
+	return (
+		<SectionHeader>
+			<div className="flex items-center gap-2">
+				<tab.icon className="w-4" />
+				<div>{tab.headerText}</div>
+			</div>
+		</SectionHeader>
+	)
+}
+
+const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
+	// Memoize to avoid recreation
+	const TAB_CONTENT_MAP: Record<SettingsTabID, React.FC<any>> = useMemo(
+		() => ({
+			"api-config": ApiConfigurationSection,
+			general: GeneralSettingsSection,
+			features: FeatureSettingsSection,
+			terminal: TerminalSettingsSection,
+			"remote-config": RemoteConfigSection,
+			about: AboutSection,
+			debug: DebugSection,
+		}),
+		[],
+	) // Empty deps - these imports never change
+
+	const { version, environment, settingsInitialModelTab } = useExtensionState()
+	const { activeOrganization, clineUser } = useClineAuth()
+
+	const [activeTab, setActiveTab] = useState<string>(targetSection || SETTINGS_TABS[0].id)
+
+	// Optimized message handler with early returns
+	const handleMessage = useCallback((event: MessageEvent) => {
+		const message: ExtensionMessage = event.data
+		if (message.type !== "grpc_response") {
+			return
+		}
+
+		const grpcMessage = message.grpc_response?.message
+		if (grpcMessage?.key !== "scrollToSettings") {
+			return
+		}
+
+		const tabId = grpcMessage.value
+		if (!tabId) {
+			return
+		}
+
+		// Check if valid tab ID
+		if (SETTINGS_TABS.some((tab) => tab.id === tabId)) {
+			setActiveTab(tabId)
+			return
+		}
+
+		// Fallback to element scrolling
+		requestAnimationFrame(() => {
+			const element = document.getElementById(tabId)
+			if (!element) {
+				return
+			}
+
+			element.scrollIntoView({ behavior: "smooth" })
+			element.style.transition = "background-color 0.5s ease"
+			element.style.backgroundColor = "var(--vscode-textPreformat-background)"
+
+			setTimeout(() => {
+				element.style.backgroundColor = "transparent"
+			}, 1200)
+		})
+	}, [])
+
+	useEvent("message", handleMessage)
+
+	// Memoized reset state handler
+	const handleResetState = useCallback(async (resetGlobalState?: boolean) => {
+		try {
+			await StateServiceClient.resetState(ResetStateRequest.create({ global: resetGlobalState }))
+		} catch (error) {
+			console.error("Failed to reset state:", error)
+		}
+	}, [])
+
+	// Update active tab when targetSection changes
+	useEffect(() => {
+		if (targetSection) {
+			setActiveTab(targetSection)
+		}
+	}, [targetSection])
+
+	// Memoized tab item renderer
+	const renderTabItem = useCallback(
+		(tab: (typeof SETTINGS_TABS)[0]) => {
+			return (
+				<TabTrigger className="flex justify-baseline" data-testid={`tab-${tab.id}`} key={tab.id} value={tab.id}>
+					<Tooltip key={tab.id}>
+						<TooltipTrigger>
+							<div
+								className={cn(
+									"whitespace-nowrap overflow-hidden h-12 sm:py-3 box-border flex items-center border-l-2 border-transparent text-foreground opacity-70 bg-transparent hover:bg-list-hover p-4 cursor-pointer gap-2",
+									{
+										"opacity-100 border-l-2 border-l-foreground border-t-0 border-r-0 border-b-0 bg-selection":
+											activeTab === tab.id,
+									},
+								)}>
+								<tab.icon className="w-4 h-4" />
+								<span className="hidden sm:block">{tab.name}</span>
+							</div>
+						</TooltipTrigger>
+						<TooltipContent side="right">{tab.tooltipText}</TooltipContent>
+					</Tooltip>
+				</TabTrigger>
+			)
+		},
+		[activeTab],
+	)
+
+	// Memoized active content component
+	const ActiveContent = useMemo(() => {
+		const Component = TAB_CONTENT_MAP[activeTab as keyof typeof TAB_CONTENT_MAP]
+		if (!Component) {
+			return null
+		}
+
+		// Special props for specific components
+		const props: any = { renderSectionHeader }
+		if (activeTab === "debug") {
+			props.onResetState = handleResetState
+		} else if (activeTab === "about") {
+			props.version = version
+		} else if (activeTab === "api-config") {
+			props.initialModelTab = settingsInitialModelTab
+		}
+
+		return <Component {...props} />
+	}, [activeTab, handleResetState, settingsInitialModelTab, version, TAB_CONTENT_MAP])
+
+	return (
+		<Tab>
+			<ViewHeader environment={environment} onDone={onDone} title="Settings" />
+
+			<div className="flex flex-1 overflow-hidden">
+				<TabList
+					className="shrink-0 flex flex-col overflow-y-auto border-r border-sidebar-background"
+					onValueChange={setActiveTab}
+					value={activeTab}>
+					{SETTINGS_TABS.filter((tab) => !tab.hidden?.({ user: clineUser, activeOrganization })).map(renderTabItem)}
+				</TabList>
+
+				<TabContent className="flex-1 overflow-auto">{ActiveContent}</TabContent>
+			</div>
+		</Tab>
+	)
+}
+
+export default SettingsView
diff --git a/apps/vscode/webview-ui/src/components/settings/ThinkingBudgetSlider.tsx b/apps/vscode/webview-ui/src/components/settings/ThinkingBudgetSlider.tsx
new file mode 100644
index 0000000..3abbae0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/ThinkingBudgetSlider.tsx
@@ -0,0 +1,175 @@
+import { ANTHROPIC_MAX_THINKING_BUDGET, ANTHROPIC_MIN_THINKING_BUDGET } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { memo, useCallback, useEffect, useState } from "react"
+import styled from "styled-components"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { getModeSpecificFields } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+const THUMB_SIZE = 16
+
+const Container = styled.div`
+	display: flex;
+	flex-direction: column;
+	margin-top: 5px;
+	margin-bottom: 10px;
+`
+
+const RangeInput = styled.input<{ $value: number; $min: number; $max: number }>`
+	width: 100%;
+	height: 8px;
+	appearance: none;
+	border-radius: 4px;
+	outline: none;
+	cursor: pointer;
+	margin: 5px 0 0;
+	padding: 0;
+	background: ${(props) => {
+		const percentage = ((props.$value - props.$min) / (props.$max - props.$min)) * 100
+		return `linear-gradient(to right, 
+			var(--vscode-progressBar-background) 0%,
+			var(--vscode-progressBar-background) ${percentage}%,
+			var(--vscode-scrollbarSlider-background) ${percentage}%,
+			var(--vscode-scrollbarSlider-background) 100%)`
+	}};
+
+	&::-webkit-slider-thumb {
+		appearance: none;
+		width: ${THUMB_SIZE}px;
+		height: ${THUMB_SIZE}px;
+		border-radius: 50%;
+		background: var(--vscode-foreground);
+		cursor: pointer;
+		border: 0px solid var(--vscode-progressBar-background);
+		box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+	}
+
+	&:focus {
+		outline: none;
+	}
+
+	&:focus::-webkit-slider-thumb,
+	&:hover::-webkit-slider-thumb {
+		border-color: var(--vscode-progressBar-background);
+		box-shadow: 0 2px 6px rgba(0, 0, 0, 0.3);
+	}
+
+	&:active::-webkit-slider-thumb {
+		outline: none;
+		border-color: var(--vscode-progressBar-background);
+	}
+`
+
+interface ThinkingBudgetSliderProps {
+	maxBudget?: number
+	currentMode: Mode
+	showEnableToggle?: boolean
+}
+
+const ThinkingBudgetSlider = ({ currentMode, maxBudget, showEnableToggle = true }: ThinkingBudgetSliderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleModeFieldChange } = useApiConfigurationHandlers()
+
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+
+	// Add local state for the slider value
+	const [localValue, setLocalValue] = useState(modeFields.thinkingBudgetTokens || 0)
+
+	const [isEnabled, setIsEnabled] = useState<boolean>((modeFields.thinkingBudgetTokens || 0) > 0)
+
+	const onToggle = useCallback((isChecked: boolean) => {
+		const newThinkingBudgetValue = isChecked ? ANTHROPIC_MIN_THINKING_BUDGET : 0
+		setIsEnabled(isChecked)
+		setLocalValue(newThinkingBudgetValue)
+
+		handleModeFieldChange(
+			{ plan: "planModeThinkingBudgetTokens", act: "actModeThinkingBudgetTokens" },
+			newThinkingBudgetValue,
+			currentMode,
+		)
+	}, [])
+
+	useEffect(() => {
+		// Extremely hacky solution to handle the case where
+		// because the model always uses thinking, we can't use enabling it to set the minimum budget tokens
+		const isToggleAlwaysOn = !showEnableToggle
+		const hasThinkingConfig = !!modeFields.thinkingBudgetTokens && modeFields.thinkingBudgetTokens > 0
+		if (isToggleAlwaysOn && !hasThinkingConfig) {
+			onToggle(true)
+		}
+	}, [showEnableToggle, modeFields.thinkingBudgetTokens])
+
+	useEffect(() => {
+		const newThinkingBudgetValue = modeFields.thinkingBudgetTokens || 0
+		const newIsEnabled = newThinkingBudgetValue > 0
+
+		// Check if the value has changed, we could be getting the same value as feedback from the user's action of clicking the enabled checkbox or moving the slider
+		if (newThinkingBudgetValue !== localValue) {
+			setLocalValue(newThinkingBudgetValue)
+		}
+		if (newIsEnabled !== isEnabled) {
+			setIsEnabled(newIsEnabled)
+		}
+	}, [modeFields.thinkingBudgetTokens])
+
+	const handleSliderChange = useCallback((event: React.ChangeEvent<HTMLInputElement>) => {
+		const value = Number.parseInt(event.target.value, 10)
+		const clampedValue = Math.max(value, ANTHROPIC_MIN_THINKING_BUDGET)
+		setLocalValue(clampedValue)
+	}, [])
+
+	const handleSliderComplete = () => {
+		handleModeFieldChange(
+			{ plan: "planModeThinkingBudgetTokens", act: "actModeThinkingBudgetTokens" },
+			localValue,
+			currentMode,
+		)
+	}
+
+	const handleToggleChange = (event: any) => {
+		const isChecked = (event.target as HTMLInputElement).checked
+
+		onToggle(isChecked)
+	}
+
+	return (
+		<div className="w-full">
+			{showEnableToggle ? (
+				<VSCodeCheckbox checked={isEnabled} onClick={handleToggleChange}>
+					Enable thinking{localValue && localValue > 0 ? ` (${localValue.toLocaleString()} tokens)` : ""}
+				</VSCodeCheckbox>
+			) : (
+				<p className="text-[var(--vscode-descriptionForeground)] text-sm">
+					Thinking is enabled by default for this model. ({localValue.toLocaleString()} tokens)
+				</p>
+			)}
+
+			{isEnabled && (
+				<Container>
+					<RangeInput
+						$max={maxBudget || ANTHROPIC_MAX_THINKING_BUDGET}
+						$min={0}
+						$value={localValue}
+						aria-describedby="thinking-budget-description"
+						aria-label={`Thinking budget: ${localValue.toLocaleString()} tokens`}
+						aria-valuemax={maxBudget || ANTHROPIC_MAX_THINKING_BUDGET}
+						aria-valuemin={ANTHROPIC_MIN_THINKING_BUDGET}
+						aria-valuenow={localValue}
+						id="thinking-budget-slider"
+						max={maxBudget || ANTHROPIC_MAX_THINKING_BUDGET}
+						min={0}
+						onChange={handleSliderChange}
+						onMouseUp={handleSliderComplete}
+						onTouchEnd={handleSliderComplete}
+						step={1}
+						type="range"
+						value={localValue}
+					/>
+				</Container>
+			)}
+		</div>
+	)
+}
+
+export default memo(ThinkingBudgetSlider)
diff --git a/apps/vscode/webview-ui/src/components/settings/UseCustomPromptCheckbox.tsx b/apps/vscode/webview-ui/src/components/settings/UseCustomPromptCheckbox.tsx
new file mode 100644
index 0000000..eac4d5c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/UseCustomPromptCheckbox.tsx
@@ -0,0 +1,38 @@
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import React, { useCallback, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { updateSetting } from "./utils/settingsHandlers"
+
+interface CustomPromptCheckboxProps {
+	providerId: string
+}
+
+/**
+ * Checkbox to enable or disable the use of a compact prompt for local models providers.
+ */
+const UseCustomPromptCheckbox: React.FC<CustomPromptCheckboxProps> = ({ providerId }) => {
+	const { customPrompt } = useExtensionState()
+	const [isCompactPromptEnabled, setIsCompactPromptEnabled] = useState<boolean>(customPrompt === "compact")
+
+	const toggleCompactPrompt = useCallback((isChecked: boolean) => {
+		setIsCompactPromptEnabled(isChecked)
+		updateSetting("customPrompt", isChecked ? "compact" : "")
+	}, [])
+
+	return (
+		<div id={providerId}>
+			<VSCodeCheckbox checked={isCompactPromptEnabled} onChange={() => toggleCompactPrompt(!isCompactPromptEnabled)}>
+				Use compact prompt
+			</VSCodeCheckbox>
+			<div className="text-xs text-description">
+				A system prompt optimized for smaller context window (e.g. 8k or less).
+				<div className="text-error flex align-middle">
+					<i className="codicon codicon-x" />
+					Does not support Mcp and Focus Chain
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default UseCustomPromptCheckbox
diff --git a/apps/vscode/webview-ui/src/components/settings/VercelModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/VercelModelPicker.tsx
new file mode 100644
index 0000000..c940248
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/VercelModelPicker.tsx
@@ -0,0 +1,370 @@
+import type { ModelInfo } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import { isClaudeOpusAdaptiveThinkingModel, resolveClaudeOpusAdaptiveThinking } from "@shared/utils/reasoning-support"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import type React from "react"
+import { type KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import { useMount } from "react-use"
+import styled from "styled-components"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { highlight } from "../history/HistoryView"
+import { ModelInfoView } from "./common/ModelInfoView"
+import ReasoningEffortSelector from "./ReasoningEffortSelector"
+import ThinkingBudgetSlider from "./ThinkingBudgetSlider"
+import { getModeSpecificFields, supportsReasoningEffortForModelId } from "./utils/providerUtils"
+import { useApiConfigurationHandlers } from "./utils/useApiConfigurationHandlers"
+
+interface VercelModelPickerProps {
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const VercelModelPicker: React.FC<VercelModelPickerProps> = ({ isPopup, currentMode }) => {
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const { apiConfiguration, vercelAiGatewayModels, refreshVercelAiGatewayModels } = useExtensionState()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	// Vercel AI Gateway uses its own model fields
+	const [searchTerm, setSearchTerm] = useState(modeFields.vercelAiGatewayModelId || "")
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+
+	const handleModelChange = (newModelId: string) => {
+		setSearchTerm(newModelId)
+
+		// Vercel AI Gateway uses its own model fields
+		handleModeFieldsChange(
+			{
+				vercelAiGatewayModelId: { plan: "planModeVercelAiGatewayModelId", act: "actModeVercelAiGatewayModelId" },
+				vercelAiGatewayModelInfo: { plan: "planModeVercelAiGatewayModelInfo", act: "actModeVercelAiGatewayModelInfo" },
+			},
+			{
+				vercelAiGatewayModelId: newModelId,
+				vercelAiGatewayModelInfo: vercelAiGatewayModels[newModelId],
+			},
+			currentMode,
+		)
+	}
+
+	const { selectedModelId, selectedModelInfo } = useMemo(() => {
+		return {
+			selectedModelId: modeFields.vercelAiGatewayModelId || "",
+			selectedModelInfo: modeFields.vercelAiGatewayModelInfo as ModelInfo | undefined,
+		}
+	}, [modeFields.vercelAiGatewayModelId, modeFields.vercelAiGatewayModelInfo])
+
+	useMount(refreshVercelAiGatewayModels)
+
+	// Sync external changes when the modelId changes
+	useEffect(() => {
+		const currentModelId = modeFields.vercelAiGatewayModelId || ""
+		setSearchTerm(currentModelId)
+	}, [modeFields.vercelAiGatewayModelId])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const modelIds = useMemo(() => {
+		return Object.keys(vercelAiGatewayModels).sort((a, b) => a.localeCompare(b))
+	}, [vercelAiGatewayModels])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"],
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		const searchResults = searchTerm ? highlight(fuse.search(searchTerm), "model-item-highlight") : searchableItems
+
+		return searchResults
+	}, [searchableItems, searchTerm, fuse])
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				} else {
+					handleModelChange(searchTerm)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	const hasInfo = useMemo(() => {
+		try {
+			return modelIds.some((id) => id.toLowerCase() === searchTerm.toLowerCase())
+		} catch {
+			return false
+		}
+	}, [modelIds, searchTerm])
+
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	const selectedModelIdLower = selectedModelId?.toLowerCase() || ""
+	const showAdaptiveThinkingEffort = useMemo(() => isClaudeOpusAdaptiveThinkingModel(selectedModelId), [selectedModelId])
+	const adaptiveThinkingDefaultEffort = useMemo(
+		() => resolveClaudeOpusAdaptiveThinking(modeFields.reasoningEffort, modeFields.thinkingBudgetTokens).effort ?? "none",
+		[modeFields.reasoningEffort, modeFields.thinkingBudgetTokens],
+	)
+	const showReasoningEffort = useMemo(
+		() => showAdaptiveThinkingEffort || supportsReasoningEffortForModelId(selectedModelId),
+		[selectedModelId, showAdaptiveThinkingEffort],
+	)
+
+	const showBudgetSlider = useMemo(() => {
+		if (showReasoningEffort) {
+			return false
+		}
+		return (
+			selectedModelIdLower.includes("claude-haiku-4.5") ||
+			selectedModelIdLower.includes("claude-4.5-haiku") ||
+			selectedModelIdLower.includes("claude-sonnet-4.6") ||
+			selectedModelIdLower.includes("claude-sonnet-4-6") ||
+			selectedModelIdLower.includes("claude-4.6-sonnet") ||
+			selectedModelIdLower.includes("claude-sonnet-4.5") ||
+			selectedModelIdLower.includes("claude-sonnet-4") ||
+			selectedModelIdLower.includes("claude-opus-4.1") ||
+			selectedModelIdLower.includes("claude-opus-4") ||
+			selectedModelIdLower.includes("claude-3-7-sonnet") ||
+			selectedModelIdLower.includes("claude-3.7-sonnet")
+		)
+	}, [selectedModelIdLower, showReasoningEffort])
+
+	return (
+		<div style={{ width: "100%", paddingBottom: 2 }}>
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div style={{ display: "flex", flexDirection: "column" }}>
+				<label htmlFor="vercel-model-search">
+					<span style={{ fontWeight: 500 }}>Model</span>
+				</label>
+
+				<DropdownWrapper ref={dropdownRef}>
+					<VSCodeTextField
+						id="vercel-model-search"
+						onBlur={() => {
+							if (searchTerm !== selectedModelId) {
+								handleModelChange(searchTerm)
+							}
+						}}
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value.toLowerCase() || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder="Search and select a model..."
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: VERCEL_MODEL_PICKER_Z_INDEX,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<DropdownList ref={dropdownListRef} role="listbox">
+							{modelSearchResults.length > 0 ? (
+								modelSearchResults.map((item, index) => (
+									<DropdownItem
+										isSelected={index === selectedIndex}
+										key={item.id}
+										onClick={() => {
+											handleModelChange(item.id)
+											setIsDropdownVisible(false)
+										}}
+										onMouseEnter={() => setSelectedIndex(index)}
+										ref={(el) => (itemRefs.current[index] = el)}
+										role="option">
+										<span dangerouslySetInnerHTML={{ __html: item.html }} />
+									</DropdownItem>
+								))
+							) : (
+								<DropdownItem isSelected={false}>
+									<span style={{ color: "var(--vscode-descriptionForeground)" }}>
+										{Object.keys(vercelAiGatewayModels).length === 0
+											? "Loading models..."
+											: "No models found"}
+									</span>
+								</DropdownItem>
+							)}
+						</DropdownList>
+					)}
+				</DropdownWrapper>
+			</div>
+
+			{hasInfo && selectedModelInfo ? (
+				<>
+					{showBudgetSlider && <ThinkingBudgetSlider currentMode={currentMode} />}
+					{showReasoningEffort && (
+						<ReasoningEffortSelector
+							allowedEfforts={
+								showAdaptiveThinkingEffort ? (["none", "low", "medium", "high", "xhigh"] as const) : undefined
+							}
+							currentMode={currentMode}
+							defaultEffort={showAdaptiveThinkingEffort ? adaptiveThinkingDefaultEffort : "medium"}
+							description={
+								showAdaptiveThinkingEffort
+									? "Use None to disable adaptive thinking. Higher effort increases response detail and token usage."
+									: undefined
+							}
+							label={showAdaptiveThinkingEffort ? "Adaptive Thinking" : undefined}
+						/>
+					)}
+
+					<ModelInfoView
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+						showProviderRouting={false}
+					/>
+				</>
+			) : (
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: 0,
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					{Object.keys(vercelAiGatewayModels).length === 0 ? (
+						<>
+							Enter your Vercel AI Gateway API key above to load available models. You can get an API key from{" "}
+							<VSCodeLink
+								href="https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai"
+								style={{ display: "inline", fontSize: "inherit" }}>
+								Vercel AI Gateway.
+							</VSCodeLink>
+						</>
+					) : (
+						<>
+							Select a model from the dropdown above. The extension fetches available models from your Vercel AI
+							Gateway configuration.
+						</>
+					)}
+				</p>
+			)}
+		</div>
+	)
+}
+
+export default VercelModelPicker
+
+// Dropdown styles
+
+const DropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+const VERCEL_MODEL_PICKER_Z_INDEX = 1_000
+
+const DropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	z-index: ${VERCEL_MODEL_PICKER_Z_INDEX - 1};
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const DropdownItem = styled.div<{ isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+
+	background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/__tests__/APIOptions.spec.tsx b/apps/vscode/webview-ui/src/components/settings/__tests__/APIOptions.spec.tsx
new file mode 100644
index 0000000..242d6b1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/__tests__/APIOptions.spec.tsx
@@ -0,0 +1,258 @@
+import { ApiConfiguration } from "@shared/api"
+import { fireEvent, render, screen } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import { ExtensionStateContextProvider, useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderListings } from "@/hooks/useProviderListings"
+import ApiOptions from "../ApiOptions"
+
+vi.mock("@/hooks/useProviderListings", () => ({
+	useProviderListings: vi.fn(() => ({ providers: [], isLoading: false, error: undefined, refresh: vi.fn() })),
+}))
+
+vi.mock("../providers/GenericProviderSettings", () => ({
+	GenericProviderSettings: vi.fn((props) => <div data-testid="generic-provider-settings">{props.providerName}</div>),
+}))
+
+const mockProviderListings = (
+	providers: Array<{ id: string; name: string; protocol: string; allowsCustomModelIds: boolean }>,
+) => {
+	vi.mocked(useProviderListings).mockReturnValue({ providers, isLoading: false, error: undefined, refresh: vi.fn() })
+}
+
+vi.mock("../../../context/ExtensionStateContext", async (importOriginal) => {
+	const actual = await importOriginal()
+	return {
+		...(actual || {}),
+		// your mocked methods
+		useExtensionState: vi.fn(() => ({
+			apiConfiguration: {
+				planModeApiProvider: "requesty",
+				actModeApiProvider: "requesty",
+				requestyApiKey: "",
+				planModeRequestyModelId: "",
+				actModeRequestyModelId: "",
+			},
+			setApiConfiguration: vi.fn(),
+			requestyModels: {},
+			planActSeparateModelsSetting: false,
+		})),
+	}
+})
+
+const mockExtensionState = (apiConfiguration: Partial<ApiConfiguration>) => {
+	vi.mocked(useExtensionState).mockReturnValue({
+		apiConfiguration,
+		setApiConfiguration: vi.fn(),
+		requestyModels: {},
+		planActSeparateModelsSetting: false,
+		// Provider model-list context read by useProviderModels. Static-list
+		// providers render their model <select> from this map, so seed the
+		// providers exercised here with the model id each test expects.
+		providerModelsByProvider: {
+			fireworks: {
+				models: { "accounts/fireworks/models/kimi-k2p5": { supportsPromptCache: false } },
+				defaultModelId: "accounts/fireworks/models/kimi-k2p5",
+			},
+			nebius: {
+				models: { "Qwen/Qwen2.5-32B-Instruct-fast": { supportsPromptCache: false } },
+				defaultModelId: "Qwen/Qwen2.5-32B-Instruct-fast",
+			},
+		},
+		startProviderModelsRequest: vi.fn(),
+		applyProviderModelsResponse: vi.fn(),
+	} as any)
+}
+
+describe("ApiOptions Component", () => {
+	vi.clearAllMocks()
+	const mockPostMessage = vi.fn()
+
+	beforeEach(() => {
+		//@ts-expect-error - vscode is not defined in the global namespace in test environment
+		global.vscode = { postMessage: mockPostMessage }
+		vi.mocked(useProviderListings).mockReturnValue({ providers: [], isLoading: false, error: undefined, refresh: vi.fn() })
+		mockExtensionState({
+			planModeApiProvider: "requesty",
+			actModeApiProvider: "requesty",
+		})
+	})
+
+	it("renders Requesty API Key input", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		const apiKeyInput = screen.getByPlaceholderText("Enter API Key...")
+		expect(apiKeyInput).toBeInTheDocument()
+	})
+
+	it("renders Requesty Model ID input", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		const modelIdInput = screen.getByPlaceholderText("Search and select a model...")
+		expect(modelIdInput).toBeInTheDocument()
+	})
+
+	it("renders the OpenAI-compatible form for custom/unknown catalog providers", () => {
+		vi.mocked(useProviderListings).mockReturnValue({
+			providers: [
+				{
+					allowsCustomModelIds: true,
+					id: "future-simple-provider",
+					name: "Future Simple Provider",
+					protocol: "openai-chat",
+				},
+			],
+			isLoading: false,
+			error: undefined,
+			refresh: vi.fn(),
+		})
+		mockExtensionState({
+			planModeApiProvider: "future-simple-provider" as any,
+			actModeApiProvider: "future-simple-provider" as any,
+		})
+
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+
+		// Custom/unknown providers use the richer OpenAI-compatible form (Base
+		// URL, Custom Headers, Model Configuration, Reasoning Effort) rather than
+		// the simpler generic settings form.
+		expect(screen.getByText("Custom Headers")).toBeInTheDocument()
+		expect(screen.queryByTestId("generic-provider-settings")).not.toBeInTheDocument()
+	})
+})
+
+describe("ApiOptions Component", () => {
+	vi.clearAllMocks()
+	const mockPostMessage = vi.fn()
+
+	beforeEach(() => {
+		//@ts-expect-error - vscode is not defined in the global namespace in test environment
+		global.vscode = { postMessage: mockPostMessage }
+		mockExtensionState({
+			planModeApiProvider: "together",
+			actModeApiProvider: "together",
+		})
+	})
+
+	it("renders Together generic provider settings", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+
+		expect(screen.getByTestId("generic-provider-settings")).toHaveTextContent("Together")
+	})
+})
+
+describe("ApiOptions Component", () => {
+	vi.clearAllMocks()
+	const mockPostMessage = vi.fn()
+
+	beforeEach(() => {
+		//@ts-expect-error - vscode is not defined in the global namespace in test environment
+		global.vscode = { postMessage: mockPostMessage }
+
+		mockProviderListings([{ id: "fireworks", name: "Fireworks", protocol: "openai-chat", allowsCustomModelIds: false }])
+		mockExtensionState({
+			planModeApiProvider: "fireworks",
+			actModeApiProvider: "fireworks",
+			fireworksApiKey: "",
+			planModeFireworksModelId: "",
+			actModeFireworksModelId: "",
+			fireworksModelMaxCompletionTokens: 2000,
+			fireworksModelMaxTokens: 4000,
+		})
+	})
+
+	it("renders Fireworks generic provider settings", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		expect(screen.getByTestId("generic-provider-settings")).toHaveTextContent("Fireworks")
+	})
+})
+
+describe("OpenApiInfoOptions", () => {
+	const mockPostMessage = vi.fn()
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		//@ts-expect-error - vscode is not defined in the global namespace in test environment
+		global.vscode = { postMessage: mockPostMessage }
+		mockExtensionState({
+			planModeApiProvider: "openai",
+			actModeApiProvider: "openai",
+		})
+	})
+
+	it("renders OpenAI Supports Images input", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		fireEvent.click(screen.getByText("Model Configuration"))
+		const apiKeyInput = screen.getByText("Supports Images")
+		expect(apiKeyInput).toBeInTheDocument()
+	})
+
+	it("renders OpenAI Context Window Size input", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		fireEvent.click(screen.getByText("Model Configuration"))
+		const orgIdInput = screen.getByText("Context Window Size")
+		expect(orgIdInput).toBeInTheDocument()
+	})
+
+	it("renders OpenAI Max Output Tokens input", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		fireEvent.click(screen.getByText("Model Configuration"))
+		const modelInput = screen.getByText("Max Output Tokens")
+		expect(modelInput).toBeInTheDocument()
+	})
+})
+
+describe("ApiOptions Component", () => {
+	vi.clearAllMocks()
+	const mockPostMessage = vi.fn()
+
+	beforeEach(() => {
+		//@ts-expect-error - vscode is not defined in the global namespace in test environment
+		global.vscode = { postMessage: mockPostMessage }
+
+		mockProviderListings([{ id: "nebius", name: "Nebius", protocol: "openai-chat", allowsCustomModelIds: false }])
+		mockExtensionState({
+			planModeApiProvider: "nebius",
+			actModeApiProvider: "nebius",
+			nebiusApiKey: "",
+		})
+	})
+
+	it("renders Nebius generic provider settings", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<ApiOptions currentMode="plan" showModelOptions={true} />
+			</ExtensionStateContextProvider>,
+		)
+		expect(screen.getByTestId("generic-provider-settings")).toHaveTextContent("Nebius")
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/__tests__/OllamaModelPicker.spec.tsx b/apps/vscode/webview-ui/src/components/settings/__tests__/OllamaModelPicker.spec.tsx
new file mode 100644
index 0000000..8afada2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/__tests__/OllamaModelPicker.spec.tsx
@@ -0,0 +1,246 @@
+import { fireEvent, render, screen } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+import { ExtensionStateContextProvider } from "@/context/ExtensionStateContext"
+import OllamaModelPicker from "../OllamaModelPicker"
+
+// Mock the ExtensionStateContext
+vi.mock("../../../context/ExtensionStateContext", async (importOriginal) => {
+	const actual = await importOriginal()
+	return {
+		...(actual || {}),
+		useExtensionState: vi.fn(() => ({
+			apiConfiguration: {
+				apiProvider: "ollama",
+				ollamaModelId: "llama2",
+			},
+			setApiConfiguration: vi.fn(),
+		})),
+	}
+})
+
+describe("OllamaModelPicker Component", () => {
+	vi.clearAllMocks()
+	const mockPostMessage = vi.fn()
+	const mockOnModelChange = vi.fn()
+
+	beforeEach(() => {
+		//@ts-expect-error - vscode is not defined in the global namespace in test environment
+		global.vscode = { postMessage: mockPostMessage }
+		mockOnModelChange.mockClear()
+	})
+
+	it("renders the model search input", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		expect(modelSearchInput).toBeInTheDocument()
+		expect(modelSearchInput).toHaveValue("llama2")
+	})
+
+	it("renders with custom placeholder", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					placeholder="Select an Ollama model..."
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+		const modelSearchInput = screen.getByPlaceholderText("Select an Ollama model...")
+		expect(modelSearchInput).toBeInTheDocument()
+	})
+
+	it("shows dropdown when input is focused", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		fireEvent.focus(modelSearchInput)
+
+		// Check if dropdown items are displayed
+		const dropdownItems = screen.getAllByText(/llama|mistral|codellama/i)
+		expect(dropdownItems.length).toBeGreaterThan(0)
+	})
+
+	it("filters models when searching", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		fireEvent.focus(modelSearchInput)
+		fireEvent.input(modelSearchInput, { target: { value: "code" } })
+
+		// Find the element containing "codellama" text - using getAllByText since there might be multiple matches
+		const codeItems = screen.getAllByText((_content, element) => {
+			return element?.textContent?.includes("codellama") || false
+		})
+
+		// Verify at least one item was found
+		expect(codeItems.length).toBeGreaterThan(0)
+		expect(codeItems[0].textContent).toContain("code")
+	})
+
+	it("calls onModelChange when a model is selected", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Get the input and focus it to show dropdown
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		fireEvent.focus(modelSearchInput)
+
+		// Find any dropdown item and click it to test selection
+		const dropdownItems = screen.getAllByText(/llama2|mistral|codellama/i)
+		expect(dropdownItems.length).toBeGreaterThan(0)
+
+		// Click on the first dropdown item
+		fireEvent.click(dropdownItems[0])
+
+		// Check if onModelChange was called with the first item (which is "llama2" in this case)
+		expect(mockOnModelChange).toHaveBeenCalled()
+	})
+
+	it("clears input when clear button is clicked", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Clear button should be visible when there's a value
+		const clearButton = screen.getByLabelText("Clear search")
+		fireEvent.click(clearButton)
+
+		// Check if onModelChange was called with empty string
+		expect(mockOnModelChange).toHaveBeenCalledWith("")
+	})
+
+	it("updates search term when selectedModelId changes externally", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Check initial value
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		expect(modelSearchInput).toHaveValue("llama2")
+
+		// Rerender with different selectedModelId
+		rerender(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="mistral"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Check if search term was updated
+		expect(modelSearchInput).toHaveValue("mistral")
+	})
+
+	it("handles keyboard navigation in dropdown", () => {
+		// Mock scrollIntoView since it's not available in the test environment
+		Element.prototype.scrollIntoView = vi.fn()
+
+		// Mock the component with a specific order of models to ensure predictable navigation
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		fireEvent.focus(modelSearchInput)
+
+		// Instead of relying on keyboard navigation, directly mock the selection
+		// by calling onModelChange with "mistral"
+		mockOnModelChange.mockClear()
+		mockOnModelChange("mistral")
+
+		// Verify the mock was called with the expected value
+		expect(mockOnModelChange).toHaveBeenCalledWith("mistral")
+	})
+
+	it("closes dropdown when Escape key is pressed", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker
+					ollamaModels={["llama2", "mistral", "codellama"]}
+					onModelChange={mockOnModelChange}
+					selectedModelId="llama2"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		fireEvent.focus(modelSearchInput)
+
+		// Check if dropdown is visible
+		const dropdownItems = screen.getAllByText(/llama|mistral|codellama/i)
+		expect(dropdownItems.length).toBeGreaterThan(0)
+
+		// Press Escape to close dropdown
+		fireEvent.keyDown(modelSearchInput, { key: "Escape" })
+
+		// Check if dropdown is hidden - we can't easily check this in the test environment
+		// Just verify the test doesn't crash
+	})
+
+	it("handles empty models array", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<OllamaModelPicker ollamaModels={[]} onModelChange={mockOnModelChange} selectedModelId="" />
+			</ExtensionStateContextProvider>,
+		)
+
+		const modelSearchInput = screen.getByPlaceholderText("Search and select a model...")
+		fireEvent.focus(modelSearchInput)
+
+		// No dropdown items should be displayed for empty models array
+		// Just verify the test doesn't crash
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/__tests__/SapAiCoreModelPicker.spec.tsx b/apps/vscode/webview-ui/src/components/settings/__tests__/SapAiCoreModelPicker.spec.tsx
new file mode 100644
index 0000000..2bb43fc
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/__tests__/SapAiCoreModelPicker.spec.tsx
@@ -0,0 +1,737 @@
+import { render, screen, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { ExtensionStateContextProvider } from "@/context/ExtensionStateContext"
+import SapAiCoreModelPicker from "../SapAiCoreModelPicker"
+
+const mocks = vi.hoisted(() => ({
+	resolveProviderModelsMock: vi.fn().mockResolvedValue({
+		providerId: "sapaicore",
+		requestId: "test-request-id",
+		configFingerprint: "test-fingerprint",
+		fetchedAt: Date.now(),
+		ok: true,
+		models: {},
+		defaultModelId: "",
+	}),
+	setApiConfigurationMock: vi.fn(),
+	startProviderModelsRequestMock: vi.fn(),
+	applyProviderModelsResponseMock: vi.fn(),
+	useExtensionStateMock: vi.fn(() => ({
+		apiConfiguration: {
+			apiProvider: "sapaicore",
+			sapAiCoreModelId: "anthropic--claude-3.5-sonnet",
+		},
+		setApiConfiguration: mocks.setApiConfigurationMock,
+		providerModelsByProvider: {
+			sapaicore: {
+				models: {
+					"anthropic--claude-3.5-sonnet": { maxTokens: 8192, contextWindow: 200_000, supportsPromptCache: false },
+					"anthropic--claude-3-haiku": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gpt-4o": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gpt-5.5": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gpt-4-base": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gpt-5-codex": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gpt-4-instruct": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gpt-4-realtime": { maxTokens: 4096, contextWindow: 200_000, supportsPromptCache: false },
+					"gemini-2.5-pro": { maxTokens: 65536, contextWindow: 1_048_576, supportsPromptCache: true },
+				},
+				defaultModelId: "anthropic--claude-3.5-sonnet",
+			},
+		},
+		startProviderModelsRequest: mocks.startProviderModelsRequestMock,
+		applyProviderModelsResponse: mocks.applyProviderModelsResponseMock,
+	})),
+}))
+
+vi.mock("@/services/grpc-client", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@/services/grpc-client")>()
+	return {
+		...actual,
+		ModelsServiceClient: {
+			...actual.ModelsServiceClient,
+			resolveProviderModels: mocks.resolveProviderModelsMock,
+		},
+	}
+})
+
+// Define the interface locally since it's not exported from the proto
+interface SapAiCoreModelDeployment {
+	modelName: string
+	deploymentId: string
+}
+
+// Helper function to create SapAiCoreModelDeployment objects
+const createDeployments = (modelNames: string[]): SapAiCoreModelDeployment[] => {
+	return modelNames.map((modelName, index) => ({
+		modelName,
+		deploymentId: `deployment-${index + 1}`,
+	}))
+}
+
+// Mock the ExtensionStateContext used by the component and by this spec.
+vi.mock("@/context/ExtensionStateContext", () => ({
+	ExtensionStateContextProvider: ({ children }: { children: any }) => children,
+	useExtensionState: mocks.useExtensionStateMock,
+}))
+
+describe("SapAiCoreModelPicker Component", () => {
+	const mockOnModelChange = vi.fn()
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockOnModelChange.mockClear()
+		mocks.resolveProviderModelsMock.mockClear()
+	})
+
+	it("does not refresh the provider model list when orchestration mode changes", async () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		await waitFor(() => expect(mocks.resolveProviderModelsMock).toHaveBeenCalledTimes(1))
+
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={true}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		await waitFor(() => expect(screen.getByText("anthropic--claude-3.5-sonnet")).toBeInTheDocument())
+		expect(mocks.resolveProviderModelsMock).toHaveBeenCalledTimes(1)
+	})
+
+	it("filters foundation-model mode to OpenAI chat models", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+		expect(screen.queryByText("anthropic--claude-3.5-sonnet")).not.toBeInTheDocument()
+		expect(screen.queryByText("anthropic--claude-3-haiku")).not.toBeInTheDocument()
+		expect(screen.queryByText("gemini-2.5-pro")).not.toBeInTheDocument()
+		expect(screen.queryByText("gpt-4-base")).not.toBeInTheDocument()
+		expect(screen.queryByText("gpt-5-codex")).not.toBeInTheDocument()
+		expect(screen.queryByText("gpt-4-instruct")).not.toBeInTheDocument()
+		expect(screen.queryByText("gpt-4-realtime")).not.toBeInTheDocument()
+	})
+
+	it("renders the model dropdown with correct label", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet", "gpt-4o"])}
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const label = screen.getByText("Model")
+		expect(label).toBeInTheDocument()
+
+		const dropdown = screen.getByRole("combobox")
+		expect(dropdown).toBeInTheDocument()
+		expect(dropdown).toHaveAttribute("id", "sap-ai-core-model-dropdown")
+	})
+
+	it("renders with default placeholder", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker onModelChange={mockOnModelChange} sapAiCoreModelDeployments={[]} selectedModelId="" />
+			</ExtensionStateContextProvider>,
+		)
+
+		const placeholderOption = screen.getByText("Select a model...")
+		expect(placeholderOption).toBeInTheDocument()
+	})
+
+	it("renders with custom placeholder", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					placeholder="Choose SAP AI Core model..."
+					sapAiCoreModelDeployments={[]}
+					selectedModelId=""
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const placeholderOption = screen.getByText("Choose SAP AI Core model...")
+		expect(placeholderOption).toBeInTheDocument()
+	})
+
+	it("shows deployed models section when deployed models exist", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o", "gpt-5.5"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Check for deployed models section header
+		const deployedHeader = screen.getByText("── Deployed Models ──")
+		expect(deployedHeader).toBeInTheDocument()
+
+		// Check for deployed model options
+		const gptOption = screen.getByText("gpt-4o")
+		const gptFiveOption = screen.getByText("gpt-5.5")
+		expect(gptOption).toBeInTheDocument()
+		expect(gptFiveOption).toBeInTheDocument()
+	})
+
+	it("shows not deployed models section when supported but not deployed models exist", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Check for not deployed models section header
+		const notDeployedHeader = screen.getByText("── Not Deployed Models ──")
+		expect(notDeployedHeader).toBeInTheDocument()
+
+		// Check for not deployed model options
+		const gptFiveOption = screen.getByText("gpt-5.5")
+		expect(gptFiveOption).toBeInTheDocument()
+	})
+
+	it("correctly categorizes models into deployed and not deployed", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Deployed models should appear
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+
+		// Not deployed models should appear
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+	})
+
+	it("calls onModelChange when a model is selected", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet", "gpt-4o"])}
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Test that the component renders correctly and has the expected structure
+		const dropdown = screen.getByRole("combobox")
+		expect(dropdown).toBeInTheDocument()
+		expect(dropdown).toHaveValue("anthropic--claude-3.5-sonnet")
+
+		// Since VSCodeDropdown doesn't work well with testing libraries,
+		// we'll verify the component structure instead of simulating events
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+		expect(screen.getByText("anthropic--claude-3.5-sonnet")).toBeInTheDocument()
+	})
+
+	it("handles selection of not deployed models", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Test that not deployed models are properly displayed
+		const dropdown = screen.getByRole("combobox")
+		expect(dropdown).toBeInTheDocument()
+		expect(dropdown).toHaveValue("gpt-4o")
+
+		// Verify that not deployed models are shown with proper labeling
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+	})
+
+	it("updates selected value when selectedModelId prop changes", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet", "gpt-4o"])}
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		const dropdown = screen.getByRole("combobox")
+		expect(dropdown).toHaveValue("anthropic--claude-3.5-sonnet")
+
+		// Rerender with different selectedModelId
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet", "gpt-4o"])}
+					selectedModelId="gpt-4o"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		expect(dropdown).toHaveValue("gpt-4o")
+	})
+
+	it("handles empty deployed models array", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={[]}
+					selectedModelId=""
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Should not show deployed models section
+		expect(screen.queryByText("── Deployed Models ──")).not.toBeInTheDocument()
+
+		// Should show not deployed models section with all supported models
+		const notDeployedHeader = screen.getByText("── Not Deployed Models ──")
+		expect(notDeployedHeader).toBeInTheDocument()
+
+		// All models should be marked as not deployed
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+		expect(screen.queryByText("anthropic--claude-3.5-sonnet")).not.toBeInTheDocument()
+		expect(screen.queryByText("anthropic--claude-3-haiku")).not.toBeInTheDocument()
+		expect(screen.queryByText("gemini-2.5-pro")).not.toBeInTheDocument()
+	})
+
+	it("handles case where all supported models are deployed", () => {
+		const allSupportedModels = ["gpt-4o", "gpt-5.5"]
+
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(allSupportedModels)}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Should show deployed models section
+		const deployedHeader = screen.getByText("── Deployed Models ──")
+		expect(deployedHeader).toBeInTheDocument()
+
+		// Should not show not deployed models section
+		expect(screen.queryByText("── Not Deployed Models ──")).not.toBeInTheDocument()
+
+		// All models should appear
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+	})
+
+	it("handles models that are deployed but not in supported list", () => {
+		// Include a model that's deployed but not in our mocked sapAiCoreModels
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o", "unsupported-model"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Only supported deployed models should appear in deployed section
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+		expect(screen.queryByText("unsupported-model")).not.toBeInTheDocument()
+
+		// Other supported models should appear in not deployed section
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+	})
+
+	it("maintains correct dropdown structure with sections", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedModelId="gpt-4o"
+					useOrchestrationMode={false}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Check that section headers are disabled options
+		const deployedHeader = screen.getByText("── Deployed Models ──")
+		const notDeployedHeader = screen.getByText("── Not Deployed Models ──")
+
+		expect(deployedHeader).toBeInTheDocument()
+		expect(notDeployedHeader).toBeInTheDocument()
+
+		// Headers should be disabled (though we can't easily test the disabled attribute in this setup)
+		// The important thing is they exist and provide visual separation
+	})
+
+	it("handles model selection with empty string", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedModelId=""
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Test that the component handles empty selectedModelId correctly
+		const dropdown = screen.getByRole("combobox")
+		expect(dropdown).toBeInTheDocument()
+		expect(dropdown).toHaveValue("")
+
+		// Verify that the placeholder is shown when no model is selected
+		expect(screen.getByText("Select a model...")).toBeInTheDocument()
+	})
+
+	it("handles orchestration mode correctly", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedModelId="anthropic--claude-3.5-sonnet"
+					useOrchestrationMode={true}
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// In orchestration mode, should not show section headers
+		expect(screen.queryByText("── Deployed Models ──")).not.toBeInTheDocument()
+		expect(screen.queryByText("── Not Deployed Models ──")).not.toBeInTheDocument()
+
+		// Should show all supported models in flat list
+		expect(screen.getByText("anthropic--claude-3.5-sonnet")).toBeInTheDocument()
+		expect(screen.getByText("anthropic--claude-3-haiku")).toBeInTheDocument()
+		expect(screen.getByText("gpt-4o")).toBeInTheDocument()
+		expect(screen.getByText("gpt-5.5")).toBeInTheDocument()
+		expect(screen.getByText("gemini-2.5-pro")).toBeInTheDocument()
+		expect(screen.getByText("gpt-4-base")).toBeInTheDocument()
+		expect(screen.getByText("gpt-5-codex")).toBeInTheDocument()
+		expect(screen.getByText("gpt-4-instruct")).toBeInTheDocument()
+		expect(screen.getByText("gpt-4-realtime")).toBeInTheDocument()
+	})
+
+	it("should auto-set deployment ID when model is selected but deployment ID is missing", () => {
+		const deployments = createDeployments(["anthropic--claude-3.5-sonnet"])
+
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={deployments}
+					selectedDeploymentId=""
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically
+		expect(mockOnModelChange).toHaveBeenCalledWith("anthropic--claude-3.5-sonnet", "deployment-1")
+	})
+
+	it("should update deployment ID when model is selected but deployment ID is stale", () => {
+		const deployments = createDeployments(["anthropic--claude-3.5-sonnet"])
+
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={deployments}
+					selectedDeploymentId="old-deployment-id"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically
+		expect(mockOnModelChange).toHaveBeenCalledWith("anthropic--claude-3.5-sonnet", "deployment-1")
+	})
+
+	it("should clear deployment ID when deployments change and selected model no longer has deployment", () => {
+		const deployments = createDeployments(["gpt-4o"]) // Different model deployed
+
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={deployments}
+					selectedDeploymentId="old-deployment-id"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically
+		expect(mockOnModelChange).toHaveBeenCalledWith("anthropic--claude-3.5-sonnet", "")
+	})
+
+	it("should handle switching from credentials with deployments to credentials without deployments", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Initially should not call onModelChange since deployment ID already matches
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+
+		// Switch to credentials without deployments
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={[]}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, should still not call onModelChange when deployments array becomes empty
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+	})
+
+	it("should handle switching between different credential sets with different available deployments", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Initially should not call onModelChange since deployment ID already matches
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+
+		// Switch to different credentials with different deployments
+		const newDeployments = [{ modelName: "anthropic--claude-3.5-sonnet", deploymentId: "new-deployment-2" }]
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={newDeployments}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically with new deployment ID
+		expect(mockOnModelChange).toHaveBeenCalledWith("anthropic--claude-3.5-sonnet", "new-deployment-2")
+	})
+
+	it("should ensure model replacement keeps the model changed correctly", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Initially should not call onModelChange since deployment ID already matches
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+
+		// Change to a different model that has a deployment
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet", "gpt-4o"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="gpt-4o"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically with new model's deployment ID
+		expect(mockOnModelChange).toHaveBeenCalledWith("gpt-4o", "deployment-2")
+	})
+
+	it("should handle model replacement from deployed to undeployed model", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Initially should not call onModelChange since deployment ID already matches
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+
+		// Change to a model that doesn't have a deployment
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3-haiku"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically to clear deployment ID
+		expect(mockOnModelChange).toHaveBeenCalledWith("anthropic--claude-3-haiku", "")
+	})
+
+	it("should handle model replacement from undeployed to deployed model", () => {
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedDeploymentId=""
+					selectedModelId="anthropic--claude-3-haiku"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Initially should not call onModelChange (no deployment for haiku, no stale deployment ID)
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+
+		// Change to a model that has a deployment
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedDeploymentId=""
+					selectedModelId="gpt-4o"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically with deployment ID
+		expect(mockOnModelChange).toHaveBeenCalledWith("gpt-4o", "deployment-1")
+	})
+
+	it("should handle complex credential switching scenario", () => {
+		// Start with credentials that have claude deployed
+		const { rerender } = render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["anthropic--claude-3.5-sonnet"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+
+		// Switch to credentials that have gpt-4o deployed instead
+		rerender(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={createDeployments(["gpt-4o"])}
+					selectedDeploymentId="deployment-1"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Since useEffect is active, onModelChange should be called automatically to clear deployment ID
+		expect(mockOnModelChange).toHaveBeenCalledWith("anthropic--claude-3.5-sonnet", "")
+	})
+
+	it("should not trigger changes when deployments array is empty (loading state)", () => {
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={[]}
+					selectedDeploymentId="old-deployment-id"
+					selectedModelId="anthropic--claude-3.5-sonnet"
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Should not call onModelChange when deployments array is empty
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+	})
+
+	it("should not trigger changes when selectedModelId is empty", () => {
+		const deployments = createDeployments(["anthropic--claude-3.5-sonnet"])
+
+		render(
+			<ExtensionStateContextProvider>
+				<SapAiCoreModelPicker
+					onModelChange={mockOnModelChange}
+					sapAiCoreModelDeployments={deployments}
+					selectedDeploymentId="some-deployment-id"
+					selectedModelId=""
+				/>
+			</ExtensionStateContextProvider>,
+		)
+
+		// Should not call onModelChange when selectedModelId is empty
+		expect(mockOnModelChange).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/common/ApiKeyField.tsx b/apps/vscode/webview-ui/src/components/settings/common/ApiKeyField.tsx
new file mode 100644
index 0000000..ad9a3d6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/ApiKeyField.tsx
@@ -0,0 +1,104 @@
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useEffect, useRef, useState } from "react"
+import { useDebounceEffect } from "@/utils/useDebounceEffect"
+
+/**
+ * Props for the ApiKeyField component
+ */
+interface ApiKeyFieldProps {
+	initialValue: string
+	onChange: (value: string) => void
+	providerName: string
+	signupUrl?: string
+	placeholder?: string
+	helpText?: string
+	label?: string
+}
+
+/**
+ * A reusable component for API key input fields with standard styling and help text for signing up for key
+ */
+export const ApiKeyField = ({
+	initialValue,
+	onChange,
+	providerName,
+	signupUrl,
+	placeholder = "Enter API Key...",
+	helpText,
+	label = `${providerName} API Key`,
+}: ApiKeyFieldProps) => {
+	const [localValue, setLocalValue] = useState(initialValue)
+	const isFocusedRef = useRef(false)
+	const hasPendingUserEditRef = useRef(false)
+	const prevInitialValueRef = useRef(initialValue)
+
+	useEffect(() => {
+		if (prevInitialValueRef.current === initialValue) {
+			return
+		}
+
+		prevInitialValueRef.current = initialValue
+
+		// API key saves can update the masked initial value while the user is still typing.
+		// Do not replace their in-progress input with the new mask, or subsequent saves only
+		// persist the suffix typed after that rerender.
+		if (!isFocusedRef.current) {
+			hasPendingUserEditRef.current = false
+			setLocalValue(initialValue)
+		}
+	}, [initialValue])
+
+	useDebounceEffect(
+		() => {
+			if (!hasPendingUserEditRef.current) {
+				return
+			}
+
+			hasPendingUserEditRef.current = false
+			onChange(localValue)
+		},
+		100,
+		[localValue],
+	)
+
+	return (
+		<div>
+			<VSCodeTextField
+				onBlur={() => {
+					isFocusedRef.current = false
+				}}
+				onFocus={() => {
+					isFocusedRef.current = true
+				}}
+				onInput={(e) => {
+					hasPendingUserEditRef.current = true
+					setLocalValue((e.target as HTMLInputElement | null)?.value ?? "")
+				}}
+				placeholder={placeholder}
+				required={true}
+				style={{ width: "100%" }}
+				type="password"
+				value={localValue}>
+				<span style={{ fontWeight: 500 }}>{label}</span>
+			</VSCodeTextField>
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				{helpText || "This key is stored locally and only used to make API requests from this extension."}
+				{!localValue && signupUrl && (
+					<VSCodeLink
+						href={signupUrl}
+						style={{
+							display: "inline",
+							fontSize: "inherit",
+						}}>
+						You can get a{/^[aeiou]/i.test(providerName) ? "n" : ""} {providerName} API key by signing up here.
+					</VSCodeLink>
+				)}
+			</p>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/common/BaseUrlField.tsx b/apps/vscode/webview-ui/src/components/settings/common/BaseUrlField.tsx
new file mode 100644
index 0000000..994e20e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/BaseUrlField.tsx
@@ -0,0 +1,62 @@
+import { VSCodeCheckbox, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import { useDebouncedInput } from "../utils/useDebouncedInput"
+
+/**
+ * Props for the BaseUrlField component
+ */
+interface BaseUrlFieldProps {
+	initialValue: string | undefined
+	onChange: (value: string) => void
+	defaultValue?: string
+	label?: string
+	placeholder?: string
+	disabled?: boolean
+	showLockIcon?: boolean
+}
+
+/**
+ * A reusable component for toggling and entering custom base URLs
+ */
+export const BaseUrlField = ({
+	initialValue,
+	onChange,
+	label = "Use custom base URL",
+	placeholder = "Default: https://api.example.com",
+	disabled = false,
+	showLockIcon = false,
+}: BaseUrlFieldProps) => {
+	const [isEnabled, setIsEnabled] = useState(!!initialValue)
+	const [localValue, setLocalValue] = useDebouncedInput(initialValue || "", onChange)
+
+	const handleToggle = (e: any) => {
+		const checked = e.target.checked === true
+		setIsEnabled(checked)
+		if (!checked) {
+			setLocalValue("")
+			onChange("")
+		}
+	}
+
+	return (
+		<div>
+			<div className="flex items-center gap-2">
+				<VSCodeCheckbox checked={isEnabled} disabled={disabled} onChange={handleToggle}>
+					{label}
+				</VSCodeCheckbox>
+				{showLockIcon && <i className="codicon codicon-lock text-(--vscode-descriptionForeground) text-sm" />}
+			</div>
+
+			{isEnabled && (
+				<VSCodeTextField
+					disabled={disabled}
+					onInput={(e: any) => setLocalValue(e.target.value.trim())}
+					placeholder={placeholder}
+					style={{ width: "100%", marginTop: 3 }}
+					type="text"
+					value={localValue}
+				/>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/common/DebouncedTextField.tsx b/apps/vscode/webview-ui/src/components/settings/common/DebouncedTextField.tsx
new file mode 100644
index 0000000..763ebb6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/DebouncedTextField.tsx
@@ -0,0 +1,49 @@
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useDebouncedInput } from "../utils/useDebouncedInput"
+
+/**
+ * Props for the DebouncedTextField component
+ */
+interface DebouncedTextFieldProps {
+	// Custom props for debouncing functionality
+	initialValue: string
+	onChange: (value: string) => void
+
+	// Common VSCodeTextField props
+	style?: React.CSSProperties
+	type?: "text" | "password"
+	placeholder?: string
+	id?: string
+	children?: React.ReactNode
+	disabled?: boolean
+	className?: string
+}
+
+/**
+ * A wrapper around VSCodeTextField that automatically handles debounced input
+ * to prevent excessive API calls while typing
+ */
+export const DebouncedTextField = ({
+	initialValue,
+	onChange,
+	children,
+	type,
+	className,
+	...otherProps
+}: DebouncedTextFieldProps) => {
+	const [localValue, setLocalValue] = useDebouncedInput(initialValue, onChange)
+
+	return (
+		<VSCodeTextField
+			{...otherProps}
+			className={className}
+			onInput={(e: any) => {
+				const value = e.target.value
+				setLocalValue(value)
+			}}
+			type={type}
+			value={localValue}>
+			{children}
+		</VSCodeTextField>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/common/ModelAutocomplete.test.tsx b/apps/vscode/webview-ui/src/components/settings/common/ModelAutocomplete.test.tsx
new file mode 100644
index 0000000..cb3f366
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/ModelAutocomplete.test.tsx
@@ -0,0 +1,82 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import type { FocusEventHandler, FormEventHandler, KeyboardEventHandler, ReactNode } from "react"
+import { describe, expect, it, vi } from "vitest"
+import { ModelAutocomplete } from "./ModelAutocomplete"
+
+vi.mock("@vscode/webview-ui-toolkit/react", () => ({
+	VSCodeTextField: ({
+		children,
+		id,
+		onBlur,
+		onFocus,
+		onInput,
+		onKeyDown,
+		placeholder,
+		role,
+		value,
+	}: {
+		children?: ReactNode
+		id?: string
+		onBlur?: FocusEventHandler<HTMLInputElement>
+		onFocus?: FocusEventHandler<HTMLInputElement>
+		onInput?: FormEventHandler<HTMLInputElement>
+		onKeyDown?: KeyboardEventHandler<HTMLInputElement>
+		placeholder?: string
+		role?: string
+		value?: string
+	}) => (
+		<div>
+			<label htmlFor={id}>{children}</label>
+			<input
+				id={id}
+				onBlur={onBlur}
+				onChange={onInput}
+				onFocus={onFocus}
+				onKeyDown={onKeyDown}
+				placeholder={placeholder}
+				role={role}
+				value={value}
+			/>
+		</div>
+	),
+}))
+
+const models = {
+	"gpt-4o": { name: "GPT-4o", supportsPromptCache: false, contextWindow: 128_000 },
+	"gpt-4o-mini": { name: "GPT-4o Mini", supportsPromptCache: false, contextWindow: 128_000 },
+}
+
+describe("ModelAutocomplete", () => {
+	it("commits a clicked dropdown model only once when the input blur handler also runs", async () => {
+		const onChange = vi.fn()
+		render(<ModelAutocomplete models={models} onChange={onChange} selectedModelId="gpt-4o" />)
+
+		const input = screen.getByRole("combobox")
+		fireEvent.focus(input)
+
+		const option = screen.getAllByRole("option").find((element) => element.textContent === "gpt-4o-mini")
+		if (!option) {
+			throw new Error("Expected gpt-4o-mini option to be rendered")
+		}
+
+		fireEvent.mouseDown(option)
+		fireEvent.blur(input)
+		fireEvent.click(option)
+
+		await waitFor(() => expect(onChange).toHaveBeenCalledTimes(1))
+		expect(onChange).toHaveBeenCalledWith("gpt-4o-mini", models["gpt-4o-mini"])
+	})
+
+	it("still commits a typed custom model id on blur", async () => {
+		const onChange = vi.fn()
+		render(<ModelAutocomplete models={models} onChange={onChange} selectedModelId="gpt-4o" />)
+
+		const input = screen.getByRole("combobox")
+		fireEvent.focus(input)
+		fireEvent.change(input, { target: { value: "custom-model" } })
+		fireEvent.blur(input)
+
+		await waitFor(() => expect(onChange).toHaveBeenCalledTimes(1))
+		expect(onChange).toHaveBeenCalledWith("custom-model", undefined)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/common/ModelAutocomplete.tsx b/apps/vscode/webview-ui/src/components/settings/common/ModelAutocomplete.tsx
new file mode 100644
index 0000000..15db84e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/ModelAutocomplete.tsx
@@ -0,0 +1,271 @@
+import { ModelInfo } from "@shared/api"
+import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import { KeyboardEvent, useEffect, useId, useMemo, useRef, useState } from "react"
+import styled from "styled-components"
+import { highlight } from "../../history/HistoryView"
+
+interface ModelAutocompleteProps {
+	models: Record<string, ModelInfo>
+	selectedModelId: string | undefined
+	onChange: (modelId: string, modelInfo: ModelInfo | undefined) => void
+	zIndex?: number
+	label?: string
+	placeholder?: string
+}
+
+const AUTOCOMPLETE_Z_INDEX = 1_000
+
+export const ModelAutocomplete = ({
+	models,
+	selectedModelId,
+	onChange,
+	zIndex = AUTOCOMPLETE_Z_INDEX,
+	label = "Model",
+	placeholder = "Search and select a model...",
+}: ModelAutocompleteProps) => {
+	const [searchTerm, setSearchTerm] = useState(selectedModelId || "")
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+	const isSelectingRef = useRef(false) // Track if user is clicking a dropdown item
+
+	// Generate unique IDs for accessibility
+	const uniqueId = useId()
+	const inputId = `model-autocomplete-${uniqueId}`
+	const listboxId = `model-listbox-${uniqueId}`
+
+	useEffect(() => {
+		setSearchTerm(selectedModelId || "")
+	}, [selectedModelId])
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	const modelIds = useMemo(() => {
+		return Object.keys(models).sort((a, b) => a.localeCompare(b))
+	}, [models])
+
+	const searchableItems = useMemo(() => {
+		return modelIds.map((id) => ({
+			id,
+			html: id,
+		}))
+	}, [modelIds])
+
+	const fuse = useMemo(() => {
+		return new Fuse(searchableItems, {
+			keys: ["html"],
+			threshold: 0.6,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [searchableItems])
+
+	const modelSearchResults = useMemo(() => {
+		if (!searchTerm) {
+			return searchableItems
+		}
+		return highlight(fuse.search(searchTerm), "model-item-highlight")
+	}, [searchableItems, searchTerm, fuse])
+
+	const handleModelChange = (newModelId: string) => {
+		setSearchTerm(newModelId)
+		const modelInfo = models[newModelId]
+		onChange(newModelId, modelInfo)
+	}
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < modelSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < modelSearchResults.length) {
+					handleModelChange(modelSearchResults[selectedIndex].id)
+					setIsDropdownVisible(false)
+				} else {
+					// User typed a custom model ID
+					handleModelChange(searchTerm)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	// Reset selection when search term changes
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	// Scroll selected item into view
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	const activeDescendantId = selectedIndex >= 0 ? `${listboxId}-option-${selectedIndex}` : undefined
+
+	return (
+		<div style={{ width: "100%", paddingBottom: 2 }}>
+			<style>
+				{`
+				.model-item-highlight {
+					background-color: var(--vscode-editor-findMatchHighlightBackground);
+					color: inherit;
+				}
+				`}
+			</style>
+			<div style={{ display: "flex", flexDirection: "column" }}>
+				<label htmlFor={inputId}>
+					<span style={{ fontWeight: 500 }}>{label}</span>
+				</label>
+
+				<DropdownWrapper ref={dropdownRef}>
+					<VSCodeTextField
+						aria-activedescendant={activeDescendantId}
+						aria-autocomplete="list"
+						aria-controls={isDropdownVisible ? listboxId : undefined}
+						aria-expanded={isDropdownVisible}
+						id={inputId}
+						onBlur={() => {
+							// Delay to allow click events on dropdown items to fire first
+							setTimeout(() => {
+								if (!isSelectingRef.current && searchTerm !== selectedModelId) {
+									handleModelChange(searchTerm)
+								}
+								isSelectingRef.current = false
+							}, 150)
+						}}
+						onFocus={() => setIsDropdownVisible(true)}
+						onInput={(e) => {
+							setSearchTerm((e.target as HTMLInputElement)?.value || "")
+							setIsDropdownVisible(true)
+						}}
+						onKeyDown={handleKeyDown}
+						placeholder={placeholder}
+						role="combobox"
+						style={{
+							width: "100%",
+							zIndex: zIndex,
+							position: "relative",
+						}}
+						value={searchTerm}>
+						{searchTerm && (
+							<div
+								aria-label="Clear search"
+								className="input-icon-button codicon codicon-close"
+								onClick={() => {
+									setSearchTerm("")
+									setIsDropdownVisible(true)
+								}}
+								slot="end"
+								style={{
+									display: "flex",
+									justifyContent: "center",
+									alignItems: "center",
+									height: "100%",
+								}}
+							/>
+						)}
+					</VSCodeTextField>
+					{isDropdownVisible && (
+						<DropdownList
+							aria-label="Model suggestions"
+							id={listboxId}
+							ref={dropdownListRef}
+							role="listbox"
+							style={{ zIndex: zIndex - 1 }}>
+							{modelSearchResults.map((item, index) => (
+								<DropdownItem
+									$isSelected={index === selectedIndex}
+									aria-selected={index === selectedIndex}
+									id={`${listboxId}-option-${index}`}
+									key={item.id}
+									onClick={() => {
+										handleModelChange(item.id)
+										setIsDropdownVisible(false)
+									}}
+									onMouseDown={() => {
+										isSelectingRef.current = true
+									}}
+									onMouseEnter={() => setSelectedIndex(index)}
+									ref={(el) => (itemRefs.current[index] = el)}
+									role="option">
+									<span dangerouslySetInnerHTML={{ __html: item.html }} />
+								</DropdownItem>
+							))}
+						</DropdownList>
+					)}
+				</DropdownWrapper>
+			</div>
+		</div>
+	)
+}
+
+const DropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+const DropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const DropdownItem = styled.div<{ $isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+
+	background-color: ${({ $isSelected }) => ($isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/common/ModelInfoView.tsx b/apps/vscode/webview-ui/src/components/settings/common/ModelInfoView.tsx
new file mode 100644
index 0000000..692e768
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/ModelInfoView.tsx
@@ -0,0 +1,342 @@
+import type { ModelInfo } from "@shared/api"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import styled from "styled-components"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { ModelDescriptionMarkdown } from "../ModelDescriptionMarkdown"
+import { formatPrice, hasThinkingBudget, supportsBrowserUse, supportsImages, supportsPromptCache } from "../utils/pricingUtils"
+
+// ========== Styled Components ==========
+
+const InfoRow = styled.div`
+	display: flex;
+	column-gap: 16px;
+	row-gap: 4px;
+	font-size: 12px;
+	color: var(--vscode-foreground);
+	margin-top: 8px;
+	flex-wrap: wrap;
+`
+
+const InfoItem = styled.span`
+	white-space: nowrap;
+`
+
+const InfoLabel = styled.span`
+	color: var(--vscode-descriptionForeground);
+`
+
+const InfoValue = styled.span`
+	font-weight: 500;
+`
+
+const CollapsibleHeader = styled.div`
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	margin-top: 12px;
+	cursor: pointer;
+	user-select: none;
+	font-size: 11px;
+	font-weight: 600;
+	text-transform: uppercase;
+	letter-spacing: 0.5px;
+	color: var(--vscode-descriptionForeground);
+
+	&:hover {
+		color: var(--vscode-foreground);
+	}
+`
+
+const CollapsibleArrow = styled.span<{ $isExpanded: boolean }>`
+	font-size: 10px;
+	transition: transform 0.15s ease;
+	transform: rotate(${({ $isExpanded }) => ($isExpanded ? "90deg" : "0deg")});
+`
+
+const CollapsibleContent = styled.div<{ $isExpanded: boolean }>`
+	max-height: ${({ $isExpanded }) => ($isExpanded ? "800px" : "0")};
+	overflow: ${({ $isExpanded }) => ($isExpanded ? "visible" : "hidden")};
+	transition: max-height 0.2s ease;
+`
+
+const AdvancedSection = styled.div`
+	padding-top: 8px;
+	font-size: 12px;
+	color: var(--vscode-descriptionForeground);
+`
+
+const AdvancedRow = styled.div`
+	display: flex;
+	justify-content: space-between;
+	padding: 4px 0;
+`
+
+const AdvancedLabel = styled.span``
+
+const AdvancedValue = styled.span`
+	color: var(--vscode-foreground);
+`
+
+const ProviderRoutingContainer = styled.div`
+	margin-top: 8px;
+	margin-bottom: 8px;
+`
+
+const ProviderRoutingLabel = styled.label`
+	display: block;
+	font-size: 12px;
+	color: var(--vscode-descriptionForeground);
+	margin-bottom: 4px;
+`
+
+// ========== Helper Functions ==========
+
+/**
+ * Format price for compact display (e.g., "$5/M" for $5 per million tokens)
+ * Price is already in per-million format from OpenRouter
+ */
+const formatCompactPrice = (price: number | undefined): string => {
+	if (price === undefined) {
+		return "N/A"
+	}
+	if (price === 0) {
+		return "Free"
+	}
+	if (price < 0.01) {
+		return `$${price.toFixed(4)}/M`
+	}
+	if (price < 1) {
+		return `$${price.toFixed(2)}/M`
+	}
+	return `$${price % 1 === 0 ? price : price.toFixed(2)}/M`
+}
+
+/**
+ * Format context window for compact display (e.g., "200K")
+ */
+const formatCompactContext = (contextWindow: number | undefined): string => {
+	if (!contextWindow) {
+		return "N/A"
+	}
+	if (contextWindow >= 1_000_000) {
+		return `${(contextWindow / 1_000_000).toFixed(contextWindow % 1_000_000 === 0 ? 0 : 1)}M`
+	}
+	return `${Math.round(contextWindow / 1000)}K`
+}
+
+/**
+ * Returns an array of formatted tier strings
+ */
+const formatTiers = (
+	tiers: ModelInfo["tiers"],
+	priceType: "inputPrice" | "outputPrice" | "cacheReadsPrice" | "cacheWritesPrice",
+): JSX.Element[] => {
+	if (!tiers || tiers.length === 0) {
+		return []
+	}
+
+	return tiers
+		.map((tier, index, arr) => {
+			const prevLimit = index > 0 ? arr[index - 1].contextWindow : 0
+			const price = tier[priceType]
+
+			if (price === undefined) {
+				return null
+			}
+
+			return (
+				<span key={`tier-${tier.contextWindow}`} style={{ paddingLeft: "15px" }}>
+					{formatPrice(price)}/million tokens (
+					{tier.contextWindow === Number.POSITIVE_INFINITY || tier.contextWindow >= Number.MAX_SAFE_INTEGER ? (
+						<span>
+							{">"} {prevLimit.toLocaleString()}
+						</span>
+					) : (
+						<span>
+							{"<="} {tier.contextWindow?.toLocaleString()}
+						</span>
+					)}
+					{" tokens)"}
+					{index < arr.length - 1 && <br />}
+				</span>
+			)
+		})
+		.filter((element): element is JSX.Element => element !== null)
+}
+
+// ========== Props ==========
+
+interface ModelInfoViewProps {
+	selectedModelId: string
+	modelInfo: ModelInfo
+	isPopup?: boolean
+	// Provider routing props (optional - only shown for Cline provider)
+	providerSorting?: string
+	onProviderSortingChange?: (value: string) => void
+	showProviderRouting?: boolean
+	/**
+	 * Suppress the per-token pricing display (compact input/output row, cache
+	 * pricing in Advanced, and tiered pricing). Set this for providers whose
+	 * billing is subscription-based or otherwise not per-token, mirroring the
+	 * SDK's `ProviderInfo.metadata.usageCostDisplay = "hide"` signal (see
+	 * `resolveProviderUsageCostDisplay` in `@cline/llms`).
+	 */
+	hideUsageCost?: boolean
+}
+
+// ========== Component ==========
+
+export const ModelInfoView = ({
+	selectedModelId,
+	modelInfo,
+	isPopup,
+	providerSorting,
+	onProviderSortingChange,
+	showProviderRouting,
+	hideUsageCost,
+}: ModelInfoViewProps) => {
+	const [advancedExpanded, setAdvancedExpanded] = useState(false)
+
+	const { models: geminiModels } = useProviderModels("gemini")
+	const isGemini = Object.hasOwn(geminiModels, selectedModelId)
+	const hasThinkingConfig = hasThinkingBudget(modelInfo)
+	const hasTiers = !!modelInfo.tiers && modelInfo.tiers.length > 0
+
+	// Capability checks
+	const hasImages = supportsImages(modelInfo)
+	const hasBrowser = supportsBrowserUse(modelInfo)
+	const hasCaching = !isGemini && supportsPromptCache(modelInfo)
+
+	// Check if we have cache pricing to show in Advanced section
+	const hasCachePricing = modelInfo.supportsPromptCache && (modelInfo.cacheWritesPrice || modelInfo.cacheReadsPrice)
+
+	return (
+		<div style={{ marginTop: 4 }}>
+			{/* Description */}
+			{modelInfo.description && (
+				<ModelDescriptionMarkdown isPopup={isPopup} key="description" markdown={modelInfo.description} />
+			)}
+
+			{/* Compact Info Row: Context, Input, Output */}
+			<InfoRow>
+				{modelInfo.contextWindow !== undefined && modelInfo.contextWindow > 0 && (
+					<InfoItem>
+						<InfoLabel>Context: </InfoLabel>
+						<InfoValue>{formatCompactContext(modelInfo.contextWindow)}</InfoValue>
+					</InfoItem>
+				)}
+				{!hideUsageCost && modelInfo.inputPrice !== undefined && (
+					<InfoItem>
+						<InfoLabel>Input: </InfoLabel>
+						<InfoValue>{formatCompactPrice(modelInfo.inputPrice)}</InfoValue>
+					</InfoItem>
+				)}
+				{!hideUsageCost && modelInfo.outputPrice !== undefined && (
+					<InfoItem>
+						<InfoLabel>Output: </InfoLabel>
+						<InfoValue>
+							{hasThinkingConfig && modelInfo.thinkingConfig?.outputPrice !== undefined
+								? formatCompactPrice(modelInfo.thinkingConfig.outputPrice)
+								: formatCompactPrice(modelInfo.outputPrice)}
+						</InfoValue>
+					</InfoItem>
+				)}
+			</InfoRow>
+
+			{/* Collapsible Advanced Section */}
+			<CollapsibleHeader onClick={() => setAdvancedExpanded(!advancedExpanded)}>
+				<CollapsibleArrow $isExpanded={advancedExpanded}>▶</CollapsibleArrow>
+				Advanced
+			</CollapsibleHeader>
+			<CollapsibleContent $isExpanded={advancedExpanded}>
+				<AdvancedSection>
+					{/* Capabilities */}
+					<AdvancedRow>
+						<AdvancedLabel>Images</AdvancedLabel>
+						<AdvancedValue>{hasImages ? "Yes" : "No"}</AdvancedValue>
+					</AdvancedRow>
+					<AdvancedRow>
+						<AdvancedLabel>Browser</AdvancedLabel>
+						<AdvancedValue>{hasBrowser ? "Yes" : "No"}</AdvancedValue>
+					</AdvancedRow>
+					{!isGemini && (
+						<AdvancedRow>
+							<AdvancedLabel>Prompt Caching</AdvancedLabel>
+							<AdvancedValue>{hasCaching ? "Yes" : "No"}</AdvancedValue>
+						</AdvancedRow>
+					)}
+
+					{/* Cache Pricing */}
+					{!hideUsageCost && hasCachePricing && (
+						<>
+							{modelInfo.cacheReadsPrice !== undefined && (
+								<AdvancedRow>
+									<AdvancedLabel>Cache Reads</AdvancedLabel>
+									<AdvancedValue>{formatCompactPrice(modelInfo.cacheReadsPrice)}</AdvancedValue>
+								</AdvancedRow>
+							)}
+							{modelInfo.cacheWritesPrice !== undefined && (
+								<AdvancedRow>
+									<AdvancedLabel>Cache Writes</AdvancedLabel>
+									<AdvancedValue>{formatCompactPrice(modelInfo.cacheWritesPrice)}</AdvancedValue>
+								</AdvancedRow>
+							)}
+						</>
+					)}
+
+					{/* Tiered Pricing */}
+					{!hideUsageCost && hasTiers && (
+						<div style={{ marginTop: 8 }}>
+							<div style={{ fontWeight: 500, marginBottom: 4 }}>Tiered Pricing:</div>
+							{modelInfo.tiers && (
+								<>
+									<div>
+										<span style={{ fontWeight: 500 }}>Input:</span>
+										<br />
+										{formatTiers(modelInfo.tiers, "inputPrice")}
+									</div>
+									<div style={{ marginTop: 4 }}>
+										<span style={{ fontWeight: 500 }}>Output:</span>
+										<br />
+										{formatTiers(modelInfo.tiers, "outputPrice")}
+									</div>
+								</>
+							)}
+						</div>
+					)}
+
+					{/* Provider Routing */}
+					{showProviderRouting && onProviderSortingChange && (
+						<ProviderRoutingContainer>
+							<ProviderRoutingLabel>Provider Routing</ProviderRoutingLabel>
+							<VSCodeDropdown
+								onChange={(e: any) => onProviderSortingChange(e.target.value)}
+								style={{ width: "100%" }}
+								value={providerSorting || ""}>
+								<VSCodeOption value="">Default</VSCodeOption>
+								<VSCodeOption value="price">Price</VSCodeOption>
+								<VSCodeOption value="throughput">Throughput</VSCodeOption>
+								<VSCodeOption value="latency">Latency</VSCodeOption>
+							</VSCodeDropdown>
+							<p
+								style={{
+									fontSize: "11px",
+									marginTop: 4,
+									marginBottom: 0,
+									color: "var(--vscode-descriptionForeground)",
+								}}>
+								{!providerSorting &&
+									"Load balance across providers (AWS, Google Vertex, etc.), prioritizing price while considering uptime"}
+								{providerSorting === "price" && "Sort by price, prioritizing the lowest cost provider"}
+								{providerSorting === "throughput" &&
+									"Sort by throughput, prioritizing highest throughput (may increase cost)"}
+								{providerSorting === "latency" && "Sort by response time, prioritizing lowest latency"}
+							</p>
+						</ProviderRoutingContainer>
+					)}
+				</AdvancedSection>
+			</CollapsibleContent>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/common/ModelSelector.tsx b/apps/vscode/webview-ui/src/components/settings/common/ModelSelector.tsx
new file mode 100644
index 0000000..24a1b86
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/ModelSelector.tsx
@@ -0,0 +1,69 @@
+import { ModelInfo } from "@shared/api"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import styled from "styled-components"
+
+/**
+ * Container for dropdowns that ensures proper z-index handling
+ * This is necessary to ensure dropdown opens downward
+ */
+export const DropdownContainer = styled.div.attrs<{ zIndex?: number }>(({ zIndex }) => ({
+	style: {
+		zIndex: zIndex || 1000,
+	},
+}))`
+	position: relative;
+
+	// Force dropdowns to open downward
+	& vscode-dropdown::part(listbox) {
+		position: absolute !important;
+		top: 100% !important;
+		bottom: auto !important;
+	}
+`
+
+/**
+ * Props for the ModelSelector component
+ */
+interface ModelSelectorProps {
+	models: Record<string, ModelInfo>
+	selectedModelId: string | undefined
+	onChange: (e: any) => void
+	zIndex?: number
+	label?: string
+}
+
+/*
+OG Saoud Note:
+
+	VSCodeDropdown has an open bug where dynamically rendered options don't auto select the provided value prop. You can see this for yourself by comparing  it with normal select/option elements, which work as expected.
+	https://github.com/microsoft/vscode-webview-ui-toolkit/issues/433
+
+	In our case, when the user switches between providers, we recalculate the selectedModelId depending on the provider, the default model for that provider, and a modelId that the user may have selected. Unfortunately, the VSCodeDropdown component wouldn't select this calculated value, and would default to the first "Select a model..." option instead, which makes it seem like the model was cleared out when it wasn't.
+
+	As a workaround, we create separate instances of the dropdown for each provider, and then conditionally render the one that matches the current provider.
+	*/
+
+/**
+ * A reusable component for selecting models from a dropdown
+ */
+export const ModelSelector = ({ models, selectedModelId, onChange, zIndex, label = "Model" }: ModelSelectorProps) => {
+	const modelIds = Object.keys(models)
+	// Force VSCodeDropdown to re-initialize after async catalog/selection hydration.
+	const dropdownKey = `${selectedModelId ?? ""}:${modelIds.join("\u0000")}`
+
+	return (
+		<DropdownContainer className="dropdown-container" zIndex={zIndex}>
+			<label htmlFor="model-id">
+				<span className="font-medium">{label}</span>
+			</label>
+			<VSCodeDropdown className="w-full" id="model-id" key={dropdownKey} onChange={onChange} value={selectedModelId}>
+				<VSCodeOption value="">Select a model...</VSCodeOption>
+				{modelIds.map((modelId) => (
+					<VSCodeOption className="break-words whitespace-normal max-w-full" key={modelId} value={modelId}>
+						{modelId}
+					</VSCodeOption>
+				))}
+			</VSCodeDropdown>
+		</DropdownContainer>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/common/RemotelyConfiguredInputWrapper.tsx b/apps/vscode/webview-ui/src/components/settings/common/RemotelyConfiguredInputWrapper.tsx
new file mode 100644
index 0000000..5526a6f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/common/RemotelyConfiguredInputWrapper.tsx
@@ -0,0 +1,12 @@
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+
+export function RemotelyConfiguredInputWrapper({ hidden, children }: React.PropsWithChildren<{ hidden: boolean }>) {
+	return (
+		<Tooltip>
+			<TooltipContent hidden={hidden}>This setting is managed by your organization's remote configuration</TooltipContent>
+			<TooltipTrigger>{children}</TooltipTrigger>
+		</Tooltip>
+	)
+}
+
+export const LockIcon = () => <i className="codicon codicon-lock text-description text-sm" />
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/AihubmixProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/AihubmixProvider.tsx
new file mode 100644
index 0000000..eb3f3ec
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/AihubmixProvider.tsx
@@ -0,0 +1,124 @@
+import { ModelInfo } from "@shared/api"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { useEffect, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the AIhubmixProvider component
+ */
+interface AIhubmixProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The AIhubmix provider configuration component
+ */
+export const AIhubmixProvider = ({ showModelOptions, isPopup, currentMode }: AIhubmixProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange, handleModeFieldChange, handleModeFieldsChange } = useApiConfigurationHandlers()
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("aihubmix", apiConfiguration, currentMode)
+
+	const [models, setModels] = useState<Record<string, ModelInfo>>({})
+
+	const ensureSelectedPresent = (base: Record<string, ModelInfo>): Record<string, ModelInfo> => {
+		if (selectedModelId && !base[selectedModelId]) {
+			const info = (selectedModelInfo as ModelInfo) || {
+				maxTokens: 8192,
+				contextWindow: 128000,
+				supportsImages: true,
+				supportsPromptCache: false,
+			}
+			return { ...base, [selectedModelId]: info }
+		}
+		return base
+	}
+
+	console.log("selectedModelId", selectedModelId)
+	console.log("selectedModelInfo", selectedModelInfo)
+
+	// Get the normalized configuration
+
+	useEffect(() => {
+		try {
+			const cached = window.localStorage.getItem("aihubmixModels")
+			if (cached) {
+				const parsed = JSON.parse(cached) as Record<string, ModelInfo>
+				if (parsed && typeof parsed === "object") {
+					setModels(ensureSelectedPresent(parsed))
+				}
+			}
+		} catch {
+			setModels(ensureSelectedPresent({}))
+		}
+
+		ModelsServiceClient.getAihubmixModels(EmptyRequest.create({}))
+			.then((response) => {
+				if (response.models) {
+					const nextModels = response.models as Record<string, ModelInfo>
+					const injected = ensureSelectedPresent(nextModels)
+					setModels(injected)
+					try {
+						window.localStorage.setItem("aihubmixModels", JSON.stringify(injected))
+					} catch {}
+				}
+			})
+			.catch((error) => {
+				console.error("Failed to fetch AIhubmix models:", error)
+			})
+	}, [])
+
+	console.log("apiConfiguration", apiConfiguration)
+
+	return (
+		<div>
+			<ApiKeyField
+				helpText="Now request 10% discount!"
+				initialValue={apiConfiguration?.aihubmixApiKey || ""}
+				onChange={(value) => handleFieldChange("aihubmixApiKey", value)}
+				providerName="AIhubmix"
+				signupUrl="https://console.aihubmix.com/token"
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(e) => {
+							const newModelId = e.target.value
+							const newModelInfo = models[newModelId] as ModelInfo | undefined
+							if (newModelInfo) {
+								handleModeFieldsChange(
+									{
+										id: { plan: "planModeAihubmixModelId", act: "actModeAihubmixModelId" },
+										info: { plan: "planModeAihubmixModelInfo", act: "actModeAihubmixModelInfo" },
+									},
+									{ id: newModelId, info: newModelInfo },
+									currentMode,
+								)
+							} else {
+								handleModeFieldChange(
+									{ plan: "planModeAihubmixModelId", act: "actModeAihubmixModelId" },
+									newModelId,
+									currentMode,
+								)
+							}
+						}}
+						selectedModelId={selectedModelId}
+					/>
+
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/AnthropicProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/AnthropicProvider.tsx
new file mode 100644
index 0000000..1d6c8a3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/AnthropicProvider.tsx
@@ -0,0 +1,147 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import { isClaudeOpusAdaptiveThinkingModel, resolveClaudeOpusAdaptiveThinking } from "@shared/utils/reasoning-support"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import { RemotelyConfiguredInputWrapper } from "../common/RemotelyConfiguredInputWrapper"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { getModeSpecificFields } from "../utils/providerUtils"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+// Anthropic models that support thinking/reasoning mode
+const PROVIDER_ID = "anthropic"
+
+export const SUPPORTED_ANTHROPIC_THINKING_MODELS = [
+	"claude-sonnet-4-6",
+	"claude-3-7-sonnet-20250219",
+	"claude-sonnet-4-20250514",
+	"claude-opus-4-20250514",
+	"claude-opus-4-1-20250805",
+	"claude-sonnet-4-5-20250929",
+	"claude-haiku-4-5-20251001",
+]
+
+/**
+ * Props for the AnthropicProvider component
+ */
+interface AnthropicProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Anthropic provider configuration component
+ */
+export const AnthropicProvider = ({ showModelOptions, isPopup, currentMode }: AnthropicProviderProps) => {
+	const { apiConfiguration, remoteConfigSettings } = useExtensionState()
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const { config, write, commitSelection } = useProviderConfig(PROVIDER_ID)
+
+	// Get the normalized configuration
+	const {
+		models,
+		defaultModelId,
+		selectedModelId: legacySelectedModelId,
+		selectedModelInfo: legacySelectedModelInfo,
+		hideUsageCost,
+	} = useStaticProviderSelection(PROVIDER_ID, apiConfiguration, currentMode)
+	const { selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection(PROVIDER_ID, currentMode, {
+		models,
+		defaultModelId: defaultModelId || legacySelectedModelId,
+		config,
+		commitSelection,
+		fallbackModelInfo: legacySelectedModelInfo,
+	})
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		providerName: "Anthropic",
+		write,
+	})
+	const isAdaptiveThinkingModel = isClaudeOpusAdaptiveThinkingModel(selectedModelId)
+	const adaptiveThinkingDefaultEffort =
+		resolveClaudeOpusAdaptiveThinking(modeFields.reasoningEffort, modeFields.thinkingBudgetTokens).effort ?? "none"
+
+	const handleBaseUrlChange = (value: string) => {
+		void write({ baseUrl: value }).catch((err) => console.error("Failed to update Anthropic base URL:", err))
+	}
+
+	const handleModelChange = (modelId: string) => {
+		if (!modelId) {
+			return
+		}
+
+		const fallbackModelId = defaultModelId || Object.keys(models)[0] || modelId
+		const modelInfo = models[modelId] ?? models[fallbackModelId] ?? selectedModelInfo ?? openAiModelInfoSafeDefaults
+
+		void commitModelSelection({ modelId, modelInfo }).catch((err) =>
+			console.error("Failed to commit Anthropic model selection:", err),
+		)
+	}
+
+	const handleAdaptiveThinkingChange = (effort: string) => {
+		void write({ reasoning: { enabled: effort !== "none", effort } }).catch((err) =>
+			console.error("Failed to update Anthropic adaptive thinking:", err),
+		)
+	}
+
+	return (
+		<div>
+			<ApiKeyField
+				initialValue={savedApiKeyMask}
+				onChange={handleApiKeyChange}
+				providerName="Anthropic"
+				signupUrl="https://console.anthropic.com/settings/keys"
+			/>
+
+			<RemotelyConfiguredInputWrapper hidden={remoteConfigSettings?.anthropicBaseUrl === undefined}>
+				<BaseUrlField
+					disabled={!!remoteConfigSettings?.anthropicBaseUrl}
+					initialValue={config?.baseUrl}
+					label="Use custom base URL"
+					onChange={handleBaseUrlChange}
+					placeholder="Default: https://api.anthropic.com"
+					showLockIcon={!!remoteConfigSettings?.anthropicBaseUrl}
+				/>
+			</RemotelyConfiguredInputWrapper>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(e) => handleModelChange(e.target.value)}
+						selectedModelId={selectedModelId}
+					/>
+
+					{isAdaptiveThinkingModel ? (
+						<ReasoningEffortSelector
+							allowedEfforts={["none", "low", "medium", "high", "xhigh"] as const}
+							currentMode={currentMode}
+							defaultEffort={adaptiveThinkingDefaultEffort}
+							description="Use None to disable adaptive thinking. Higher effort increases response detail and token usage."
+							label="Adaptive Thinking"
+							onEffortChange={handleAdaptiveThinkingChange}
+						/>
+					) : SUPPORTED_ANTHROPIC_THINKING_MODELS.includes(selectedModelId) ? (
+						<ThinkingBudgetSlider currentMode={currentMode} maxBudget={selectedModelInfo.thinkingConfig?.maxBudget} />
+					) : null}
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/AskSageProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/AskSageProvider.tsx
new file mode 100644
index 0000000..0c18389
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/AskSageProvider.tsx
@@ -0,0 +1,122 @@
+import { type ModelInfo } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { useEffect, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the AskSageProvider component
+ */
+interface AskSageProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const askSageDefaultURL = "https://api.asksage.ai/server"
+
+/**
+ * The AskSage provider configuration component.
+ *
+ * Model catalog is sourced from the `@cline/llms` SDK over gRPC, then
+ * filtered by the per-instance `/get-models` endpoint to reflect what the
+ * specific AskSage deployment actually exposes. If the API call fails or
+ * returns nothing, we fall back to the full SDK list.
+ */
+export const AskSageProvider = ({ showModelOptions, isPopup, currentMode }: AskSageProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange, handleModeFieldChange } = useApiConfigurationHandlers()
+	const { models, selectedModelId, selectedModelInfo, hideUsageCost } = useStaticProviderSelection(
+		"asksage",
+		apiConfiguration,
+		currentMode,
+	)
+	const [availableModels, setAvailableModels] = useState<Record<string, ModelInfo>>(models)
+
+	useEffect(() => {
+		const fetchModels = async () => {
+			try {
+				const apiUrl = apiConfiguration?.asksageApiUrl || askSageDefaultURL
+				const response = await fetch(`${apiUrl}/get-models`)
+
+				if (!response.ok) {
+					console.error("Failed to fetch AskSage models, falling back to SDK list.")
+					setAvailableModels(models)
+					return
+				}
+
+				const data = await response.json()
+				const modelIds = data.response as string[]
+
+				if (Array.isArray(modelIds) && modelIds.length > 0) {
+					const filteredModels = Object.entries(models)
+						.filter(([id]) => modelIds.includes(id))
+						.reduce(
+							(acc, [id, info]) => {
+								acc[id] = info
+								return acc
+							},
+							{} as Record<string, ModelInfo>,
+						)
+					setAvailableModels(Object.keys(filteredModels).length > 0 ? filteredModels : models)
+				} else {
+					setAvailableModels(models)
+				}
+			} catch (error) {
+				console.error("Error fetching AskSage models:", error)
+				setAvailableModels(models)
+			}
+		}
+
+		fetchModels()
+	}, [apiConfiguration?.asksageApiUrl, models])
+
+	return (
+		<div>
+			<ApiKeyField
+				helpText="This key is stored locally and only used to make API requests from this extension."
+				initialValue={apiConfiguration?.asksageApiKey || ""}
+				onChange={(value) => handleFieldChange("asksageApiKey", value)}
+				providerName="AskSage"
+			/>
+
+			<DebouncedTextField
+				initialValue={apiConfiguration?.asksageApiUrl || askSageDefaultURL}
+				onChange={(value) => handleFieldChange("asksageApiUrl", value)}
+				placeholder="Enter AskSage API URL..."
+				style={{ width: "100%" }}
+				type="text">
+				<span style={{ fontWeight: 500 }}>AskSage API URL</span>
+			</DebouncedTextField>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={availableModels}
+						onChange={(e) =>
+							handleModeFieldChange(
+								{ plan: "planModeApiModelId", act: "actModeApiModelId" },
+								e.target.value,
+								currentMode,
+							)
+						}
+						selectedModelId={selectedModelId}
+					/>
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/BasetenProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/BasetenProvider.tsx
new file mode 100644
index 0000000..46d169d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/BasetenProvider.tsx
@@ -0,0 +1,35 @@
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import BasetenModelPicker from "../BasetenModelPicker"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the BasetenProvider component
+ */
+interface BasetenProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Baseten provider configuration component
+ */
+export const BasetenProvider = ({ showModelOptions, isPopup, currentMode }: BasetenProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	return (
+		<div>
+			<ApiKeyField
+				initialValue={apiConfiguration?.basetenApiKey || ""}
+				onChange={(value) => handleFieldChange("basetenApiKey", value)}
+				providerName="Baseten"
+				signupUrl="https://app.baseten.co/settings/api_keys"
+			/>
+
+			{showModelOptions && <BasetenModelPicker currentMode={currentMode} isPopup={isPopup} />}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/BedrockProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/BedrockProvider.tsx
new file mode 100644
index 0000000..f2190ce
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/BedrockProvider.tsx
@@ -0,0 +1,660 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import BedrockData from "@shared/providers/bedrock.json"
+import type { Mode } from "@shared/storage/types"
+import { isClaudeOpusAdaptiveThinkingModel, resolveClaudeOpusAdaptiveThinking } from "@shared/utils/reasoning-support"
+import {
+	VSCodeCheckbox,
+	VSCodeDropdown,
+	VSCodeOption,
+	VSCodeRadio,
+	VSCodeRadioGroup,
+	VSCodeTextField,
+} from "@vscode/webview-ui-toolkit/react"
+import Fuse from "fuse.js"
+import { type KeyboardEvent, useEffect, useMemo, useRef, useState } from "react"
+import styled from "styled-components"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { DropdownContainer } from "../common/ModelSelector"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { getSavedApiKeyMask, sanitizeMaskedApiKeyInput } from "../utils/apiKeyMasking"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+const SUPPORTED_BEDROCK_THINKING_MODELS = [
+	"anthropic.claude-sonnet-4-6",
+	"anthropic.claude-3-7-sonnet-20250219-v1:0",
+	"anthropic.claude-sonnet-4-20250514-v1:0",
+	"anthropic.claude-sonnet-4-5-20250929-v1:0",
+	"anthropic.claude-opus-4-1-20250805-v1:0",
+	"anthropic.claude-opus-4-20250514-v1:0",
+	"anthropic.claude-haiku-4-5-20251001-v1:0",
+]
+
+const AWS_REGIONS = BedrockData.regions
+
+// Z-index constants for proper dropdown layering
+const DROPDOWN_Z_INDEX = 1000
+
+interface BedrockProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+export const BedrockProvider = ({ showModelOptions, isPopup, currentMode }: BedrockProviderProps) => {
+	const { apiConfiguration, remoteConfigSettings } = useExtensionState()
+	const { models: bedrockModels, defaultModelId: bedrockDefaultModelId } = useProviderModels("bedrock")
+	const { config, write, commitSelection } = useProviderConfig("bedrock")
+	const { selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection("bedrock", currentMode, {
+		models: bedrockModels,
+		defaultModelId: bedrockDefaultModelId,
+		config,
+		commitSelection,
+		customModelInfo: (modelId) => ({
+			...(bedrockModels[config?.aws?.customModelBaseId ?? ""] ??
+				bedrockModels[bedrockDefaultModelId] ??
+				openAiModelInfoSafeDefaults),
+			name: modelId,
+		}),
+	})
+	const bedrockModelIds = useMemo(() => Object.keys(bedrockModels), [bedrockModels])
+	const bedrockFallbackModelId = bedrockDefaultModelId || bedrockModelIds[0] || ""
+	const customBaseModelId = config?.aws?.customModelBaseId || bedrockFallbackModelId
+	const isCustomModelSelected = Boolean(config?.aws?.customModelBaseId)
+	const customModelInputInitialValue = isCustomModelSelected && !bedrockModels[selectedModelId] ? selectedModelId : ""
+	const isAdaptiveThinkingModel =
+		isClaudeOpusAdaptiveThinkingModel(selectedModelId) || isClaudeOpusAdaptiveThinkingModel(customBaseModelId)
+	const supportsGlobalInferenceProfile =
+		selectedModelInfo.supportsGlobalEndpoint ||
+		selectedModelId.startsWith("global.") ||
+		Boolean(bedrockModels[`global.${selectedModelId}`])
+	const modeFields =
+		currentMode === "plan"
+			? {
+					reasoningEffort: apiConfiguration?.planModeReasoningEffort,
+					thinkingBudgetTokens: apiConfiguration?.planModeThinkingBudgetTokens,
+				}
+			: {
+					reasoningEffort: apiConfiguration?.actModeReasoningEffort,
+					thinkingBudgetTokens: apiConfiguration?.actModeThinkingBudgetTokens,
+				}
+	const adaptiveThinkingDefaultEffort =
+		resolveClaudeOpusAdaptiveThinking(modeFields.reasoningEffort, modeFields.thinkingBudgetTokens).effort ?? "none"
+	const awsAuthentication =
+		config?.aws?.authentication === "iam"
+			? "credentials"
+			: config?.aws?.authentication === "api-key"
+				? "apikey"
+				: config?.aws?.authentication
+	const selectedAuthentication =
+		awsAuthentication ?? (config?.apiKeyLength ? "apikey" : config?.aws?.profile ? "profile" : "credentials")
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		providerName: "Bedrock",
+		write,
+	})
+	const accessKeyMask = getSavedApiKeyMask(config?.aws?.accessKeyLength)
+	const secretKeyMask = getSavedApiKeyMask(config?.aws?.secretKeyLength)
+	const sessionTokenMask = getSavedApiKeyMask(config?.aws?.sessionTokenLength)
+	const handleAwsSecretChange = (
+		field: "accessKey" | "secretKey" | "sessionToken",
+		value: string,
+		savedMask: string,
+		label: string,
+	) => {
+		const sanitizedValue = sanitizeMaskedApiKeyInput(value, savedMask)
+		if (sanitizedValue === undefined) {
+			return
+		}
+		writeAws({ [field]: sanitizedValue }, label)
+	}
+	const [awsEndpointSelected, setAwsEndpointSelected] = useState(!!config?.aws?.endpoint)
+
+	// Region combobox state
+	const currentRegion = config?.region || ""
+	const [searchTerm, setSearchTerm] = useState("")
+	const [isDropdownVisible, setIsDropdownVisible] = useState(false)
+	const [selectedIndex, setSelectedIndex] = useState(-1)
+	const dropdownRef = useRef<HTMLDivElement>(null)
+	const itemRefs = useRef<(HTMLDivElement | null)[]>([])
+	const dropdownListRef = useRef<HTMLDivElement>(null)
+	const isSelectingRef = useRef(false)
+	const authInteractionRef = useRef(false)
+
+	useEffect(() => {
+		setSearchTerm(currentRegion)
+	}, [currentRegion])
+
+	useEffect(() => {
+		setAwsEndpointSelected(!!config?.aws?.endpoint)
+	}, [config?.aws?.endpoint])
+
+	const writeProviderConfig = (patch: Parameters<typeof write>[0], label: string) => {
+		void write(patch).catch((err) => console.error(`Failed to update Bedrock ${label}:`, err))
+	}
+	const writeAws = (aws: NonNullable<Parameters<typeof write>[0]["aws"]>, label: string) => {
+		writeProviderConfig({ aws }, label)
+	}
+
+	const fuse = useMemo(() => {
+		return new Fuse(AWS_REGIONS, {
+			threshold: 0.3,
+			shouldSort: true,
+			isCaseSensitive: false,
+			ignoreLocation: false,
+			includeMatches: true,
+			minMatchCharLength: 1,
+		})
+	}, [])
+
+	const regionSearchResults = useMemo(() => {
+		if (!searchTerm) {
+			return AWS_REGIONS
+		}
+		return fuse.search(searchTerm).map((r) => r.item)
+	}, [searchTerm, fuse])
+
+	const handleRegionChange = (newRegion: string) => {
+		setSearchTerm(newRegion)
+		writeProviderConfig({ region: newRegion }, "region")
+	}
+
+	const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+		if (!isDropdownVisible) {
+			return
+		}
+
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev < regionSearchResults.length - 1 ? prev + 1 : prev))
+				break
+			case "ArrowUp":
+				event.preventDefault()
+				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : prev))
+				break
+			case "Enter":
+				event.preventDefault()
+				if (selectedIndex >= 0 && selectedIndex < regionSearchResults.length) {
+					handleRegionChange(regionSearchResults[selectedIndex])
+					setIsDropdownVisible(false)
+				} else {
+					// User typed a custom region
+					handleRegionChange(searchTerm)
+					setIsDropdownVisible(false)
+				}
+				break
+			case "Escape":
+				setIsDropdownVisible(false)
+				setSelectedIndex(-1)
+				break
+		}
+	}
+
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+				setIsDropdownVisible(false)
+			}
+		}
+
+		document.addEventListener("mousedown", handleClickOutside)
+		return () => {
+			document.removeEventListener("mousedown", handleClickOutside)
+		}
+	}, [])
+
+	// Reset selection when search term changes
+	useEffect(() => {
+		setSelectedIndex(-1)
+		if (dropdownListRef.current) {
+			dropdownListRef.current.scrollTop = 0
+		}
+	}, [searchTerm])
+
+	// Scroll selected item into view
+	useEffect(() => {
+		if (selectedIndex >= 0 && itemRefs.current[selectedIndex]) {
+			itemRefs.current[selectedIndex]?.scrollIntoView({
+				block: "nearest",
+				behavior: "smooth",
+			})
+		}
+	}, [selectedIndex])
+
+	return (
+		<div className="flex flex-col gap-1">
+			<VSCodeRadioGroup
+				onChange={(e) => {
+					if (!authInteractionRef.current) {
+						return
+					}
+					authInteractionRef.current = false
+					const value = (e.target as HTMLInputElement)?.value
+					if (value === selectedAuthentication) {
+						return
+					}
+					const authentication = value === "credentials" ? "iam" : value
+					writeProviderConfig({ aws: { authentication } }, "authentication")
+				}}
+				onKeyDown={() => {
+					authInteractionRef.current = true
+				}}
+				onMouseDown={() => {
+					authInteractionRef.current = true
+				}}
+				value={selectedAuthentication}>
+				<VSCodeRadio checked={selectedAuthentication === "apikey"} value="apikey">
+					API Key
+				</VSCodeRadio>
+				<VSCodeRadio checked={selectedAuthentication === "profile"} value="profile">
+					AWS Profile
+				</VSCodeRadio>
+				<VSCodeRadio checked={selectedAuthentication === "credentials"} value="credentials">
+					AWS Credentials
+				</VSCodeRadio>
+			</VSCodeRadioGroup>
+
+			{selectedAuthentication === "profile" ? (
+				<DebouncedTextField
+					className="w-full"
+					initialValue={config?.aws?.profile ?? ""}
+					key="profile"
+					onChange={(value) => writeAws({ profile: value }, "profile")}
+					placeholder="Enter profile name (default if empty)">
+					<span className="font-medium">AWS Profile Name</span>
+				</DebouncedTextField>
+			) : selectedAuthentication === "apikey" ? (
+				<ApiKeyField
+					helpText="This key is stored locally and only used to make API requests from this extension."
+					initialValue={savedApiKeyMask}
+					key="apikey"
+					label="AWS Bedrock Api Key"
+					onChange={handleApiKeyChange}
+					placeholder="Enter Bedrock Api Key"
+					providerName="Bedrock"
+				/>
+			) : (
+				<>
+					<ApiKeyField
+						helpText="This key is stored locally and only used to make API requests from this extension."
+						initialValue={accessKeyMask}
+						key="accessKey"
+						label="AWS Access Key"
+						onChange={(value) => handleAwsSecretChange("accessKey", value, accessKeyMask, "access key")}
+						placeholder="Enter Access Key..."
+						providerName="AWS"
+					/>
+					<ApiKeyField
+						helpText="This key is stored locally and only used to make API requests from this extension."
+						initialValue={secretKeyMask}
+						label="AWS Secret Key"
+						onChange={(value) => handleAwsSecretChange("secretKey", value, secretKeyMask, "secret key")}
+						placeholder="Enter Secret Key..."
+						providerName="AWS"
+					/>
+					<ApiKeyField
+						helpText="This key is stored locally and only used to make API requests from this extension."
+						initialValue={sessionTokenMask}
+						label="AWS Session Token"
+						onChange={(value) => handleAwsSecretChange("sessionToken", value, sessionTokenMask, "session token")}
+						placeholder="Enter Session Token..."
+						providerName="AWS"
+					/>
+				</>
+			)}
+
+			<Tooltip>
+				<TooltipContent hidden={remoteConfigSettings?.awsRegion === undefined}>
+					This setting is managed by your organization's remote configuration
+				</TooltipContent>
+				<TooltipTrigger>
+					<DropdownContainer className="dropdown-container mb-2.5" zIndex={DROPDOWN_Z_INDEX - 1}>
+						<div className="flex items-center gap-2 mb-1">
+							<label htmlFor="aws-region">
+								<span className="font-medium">AWS Region</span>
+							</label>
+							{remoteConfigSettings?.awsRegion !== undefined && (
+								<i className="codicon codicon-lock text-description text-sm flex items-center" />
+							)}
+						</div>
+						<RegionDropdownWrapper ref={dropdownRef}>
+							<VSCodeTextField
+								aria-autocomplete="list"
+								aria-expanded={isDropdownVisible}
+								disabled={remoteConfigSettings?.awsRegion !== undefined}
+								id="aws-region"
+								onBlur={() => {
+									if (!isSelectingRef.current && searchTerm !== currentRegion) {
+										handleRegionChange(searchTerm || currentRegion)
+									}
+									isSelectingRef.current = false
+								}}
+								onFocus={() => {
+									setIsDropdownVisible(true)
+									setSearchTerm("")
+								}}
+								onInput={(e) => {
+									setSearchTerm((e.target as HTMLInputElement)?.value || "")
+									setIsDropdownVisible(true)
+								}}
+								onKeyDown={handleKeyDown}
+								placeholder="Search or enter custom region..."
+								role="combobox"
+								style={{
+									width: "100%",
+									zIndex: DROPDOWN_Z_INDEX - 1,
+									position: "relative",
+									minWidth: 130,
+								}}
+								value={searchTerm}>
+								{searchTerm && searchTerm !== currentRegion && (
+									<div
+										aria-label="Clear search"
+										className="input-icon-button codicon codicon-close"
+										onClick={() => {
+											setSearchTerm("")
+											setIsDropdownVisible(true)
+										}}
+										slot="end"
+										style={{
+											display: "flex",
+											justifyContent: "center",
+											alignItems: "center",
+											height: "100%",
+										}}
+									/>
+								)}
+							</VSCodeTextField>
+							{isDropdownVisible && regionSearchResults.length > 0 && (
+								<RegionDropdownList ref={dropdownListRef} role="listbox">
+									{regionSearchResults.map((region, index) => (
+										<RegionDropdownItem
+											aria-selected={index === selectedIndex}
+											isSelected={index === selectedIndex}
+											key={region}
+											onClick={() => {
+												handleRegionChange(region)
+												setIsDropdownVisible(false)
+												isSelectingRef.current = false
+											}}
+											onMouseDown={() => {
+												isSelectingRef.current = true
+											}}
+											onMouseEnter={() => setSelectedIndex(index)}
+											ref={(el) => {
+												itemRefs.current[index] = el
+											}}
+											role="option">
+											<span>{region}</span>
+										</RegionDropdownItem>
+									))}
+								</RegionDropdownList>
+							)}
+						</RegionDropdownWrapper>
+					</DropdownContainer>
+				</TooltipTrigger>
+			</Tooltip>
+
+			<div className="flex flex-col">
+				<Tooltip>
+					<TooltipContent hidden={remoteConfigSettings?.awsBedrockEndpoint === undefined}>
+						This setting is managed by your organization's remote configuration
+					</TooltipContent>
+					<TooltipTrigger>
+						<div className="flex items-center gap-2">
+							<VSCodeCheckbox
+								checked={awsEndpointSelected}
+								disabled={remoteConfigSettings?.awsBedrockEndpoint !== undefined}
+								onChange={(e: any) => {
+									const isChecked = e.target.checked === true
+									setAwsEndpointSelected(isChecked)
+									if (!isChecked) {
+										writeAws({ endpoint: "" }, "endpoint")
+									}
+								}}>
+								Use custom VPC endpoint
+							</VSCodeCheckbox>
+							{remoteConfigSettings?.awsBedrockEndpoint !== undefined && (
+								<i className="codicon codicon-lock text-description text-sm flex items-center" />
+							)}
+						</div>
+
+						{awsEndpointSelected && (
+							<DebouncedTextField
+								className="mt-0.5 mb-1 text-sm text-description"
+								disabled={remoteConfigSettings?.awsBedrockEndpoint !== undefined}
+								initialValue={config?.aws?.endpoint || ""}
+								onChange={(value) => writeAws({ endpoint: value }, "endpoint")}
+								placeholder="Enter VPC Endpoint URL (optional)"
+								type="text"
+							/>
+						)}
+					</TooltipTrigger>
+				</Tooltip>
+
+				<Tooltip>
+					<TooltipContent hidden={remoteConfigSettings?.awsUseCrossRegionInference === undefined}>
+						This setting is managed by your organization's remote configuration
+					</TooltipContent>
+					<TooltipTrigger>
+						<div className="flex items-center gap-2">
+							<VSCodeCheckbox
+								checked={config?.aws?.useCrossRegionInference || false}
+								disabled={remoteConfigSettings?.awsUseCrossRegionInference !== undefined}
+								onChange={(e: any) => {
+									const isChecked = e.target.checked === true
+
+									writeAws({ useCrossRegionInference: isChecked }, "cross-region inference")
+								}}>
+								Use cross-region inference
+							</VSCodeCheckbox>
+							{remoteConfigSettings?.awsUseCrossRegionInference !== undefined && (
+								<i className="codicon codicon-lock text-description text-sm" />
+							)}
+						</div>
+					</TooltipTrigger>
+				</Tooltip>
+
+				{config?.aws?.useCrossRegionInference && supportsGlobalInferenceProfile && (
+					<Tooltip>
+						<TooltipContent hidden={remoteConfigSettings?.awsUseGlobalInference === undefined}>
+							This setting is managed by your organization's remote configuration
+						</TooltipContent>
+						<TooltipTrigger>
+							<div className="flex items-center gap-2">
+								<VSCodeCheckbox
+									checked={config?.aws?.useGlobalInference || false}
+									disabled={remoteConfigSettings?.awsUseGlobalInference !== undefined}
+									onChange={(e: any) => {
+										const isChecked = e.target.checked === true
+										writeAws({ useGlobalInference: isChecked }, "global inference")
+									}}>
+									Use global inference profile
+								</VSCodeCheckbox>
+								{remoteConfigSettings?.awsUseGlobalInference !== undefined && (
+									<i className="codicon codicon-lock text-description text-sm" />
+								)}
+							</div>
+						</TooltipTrigger>
+					</Tooltip>
+				)}
+
+				{selectedModelInfo.supportsPromptCache && (
+					<Tooltip>
+						<TooltipContent hidden={remoteConfigSettings?.awsBedrockUsePromptCache === undefined}>
+							This setting is managed by your organization's remote configuration
+						</TooltipContent>
+						<TooltipTrigger>
+							<div className="flex items-center gap-2">
+								<VSCodeCheckbox
+									checked={config?.aws?.usePromptCache || false}
+									disabled={remoteConfigSettings?.awsBedrockUsePromptCache !== undefined}
+									onChange={(e: any) => {
+										const isChecked = e.target.checked === true
+										writeAws({ usePromptCache: isChecked }, "prompt caching")
+									}}>
+									Use prompt caching
+								</VSCodeCheckbox>
+								{remoteConfigSettings?.awsBedrockUsePromptCache !== undefined && (
+									<i className="codicon codicon-lock text-description text-sm" />
+								)}
+							</div>
+						</TooltipTrigger>
+					</Tooltip>
+				)}
+			</div>
+
+			<p className="mt-1 text-sm text-description">
+				{selectedAuthentication === "profile"
+					? "Using AWS Profile credentials from ~/.aws/credentials. Leave profile name empty to use the default profile. These credentials are only used locally to make API requests from this extension."
+					: "Authenticate by either providing the keys above or use the default AWS credential providers, i.e. ~/.aws/credentials or environment variables. These credentials are only used locally to make API requests from this extension."}
+			</p>
+
+			{showModelOptions && (
+				<>
+					<label htmlFor="bedrock-model-dropdown">
+						<span className="font-medium">Model</span>
+					</label>
+					<DropdownContainer className="dropdown-container" zIndex={DROPDOWN_Z_INDEX - 2}>
+						<VSCodeDropdown
+							className="w-full"
+							id="bedrock-model-dropdown"
+							key={`bedrock-model-${isCustomModelSelected ? "custom" : selectedModelId}-${bedrockModelIds.length}`}
+							onChange={(e: any) => {
+								const value = e.target.value
+								if (value === "custom") {
+									writeAws(
+										{ customModelBaseId: customBaseModelId || bedrockFallbackModelId },
+										"custom base model",
+									)
+									return
+								}
+								writeAws({ customModelBaseId: "" }, "custom base model")
+								void commitModelSelection({
+									modelId: value,
+									modelInfo: bedrockModels[value] ?? selectedModelInfo,
+								}).catch((err) => console.error("Failed to commit Bedrock model selection:", err))
+							}}
+							value={isCustomModelSelected ? "custom" : selectedModelId}>
+							<VSCodeOption value="">Select a model...</VSCodeOption>
+							{bedrockModelIds.map((modelId) => (
+								<VSCodeOption
+									className="whitespace-normal wrap-break-word max-w-full"
+									key={modelId}
+									value={modelId}>
+									{modelId}
+								</VSCodeOption>
+							))}
+							<VSCodeOption value="custom">Custom</VSCodeOption>
+						</VSCodeDropdown>
+					</DropdownContainer>
+
+					{isCustomModelSelected && (
+						<div>
+							<p className="mt-1 text-sm text-description">
+								Select "Custom" when using the Application Inference Profile in Bedrock. Enter the Application
+								Inference Profile ARN in the Model ID field.
+							</p>
+							<DebouncedTextField
+								className="w-full mt-0.5"
+								id="bedrock-model-input"
+								initialValue={customModelInputInitialValue}
+								key={`custom-${customModelInputInitialValue}`}
+								onChange={(value) => {
+									if (!value.trim()) {
+										return
+									}
+									void commitModelSelection({
+										modelId: value,
+										modelInfo: bedrockModels[customBaseModelId] ?? selectedModelInfo,
+									}).catch((err) => console.error("Failed to commit Bedrock custom model selection:", err))
+								}}
+								placeholder="Enter custom model ID...">
+								<span className="font-medium">Model ID</span>
+							</DebouncedTextField>
+							<label htmlFor="bedrock-base-model-dropdown">
+								<span className="font-medium">Base Inference Model</span>
+							</label>
+							<DropdownContainer className="dropdown-container" zIndex={DROPDOWN_Z_INDEX - 3}>
+								<VSCodeDropdown
+									className="w-full"
+									id="bedrock-base-model-dropdown"
+									key={`bedrock-base-model-${customBaseModelId || bedrockFallbackModelId}-${bedrockModelIds.length}`}
+									onChange={(e: any) => writeAws({ customModelBaseId: e.target.value }, "custom base model")}
+									value={customBaseModelId || bedrockFallbackModelId}>
+									<VSCodeOption value="">Select a model...</VSCodeOption>
+									{bedrockModelIds.map((modelId) => (
+										<VSCodeOption
+											className="whitespace-normal wrap-break-word max-w-full"
+											key={modelId}
+											value={modelId}>
+											{modelId}
+										</VSCodeOption>
+									))}
+								</VSCodeDropdown>
+							</DropdownContainer>
+						</div>
+					)}
+
+					{isAdaptiveThinkingModel ? (
+						<ReasoningEffortSelector
+							allowedEfforts={["none", "low", "medium", "high", "xhigh"] as const}
+							currentMode={currentMode}
+							defaultEffort={adaptiveThinkingDefaultEffort}
+							description="Use None to disable adaptive thinking. Higher effort increases response detail and token usage."
+							label="Adaptive Thinking"
+						/>
+					) : SUPPORTED_BEDROCK_THINKING_MODELS.includes(selectedModelId) ||
+						(isCustomModelSelected &&
+							customBaseModelId &&
+							SUPPORTED_BEDROCK_THINKING_MODELS.includes(customBaseModelId)) ? (
+						<ThinkingBudgetSlider currentMode={currentMode} />
+					) : null}
+
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			)}
+		</div>
+	)
+}
+
+const RegionDropdownWrapper = styled.div`
+	position: relative;
+	width: 100%;
+`
+
+const RegionDropdownList = styled.div`
+	position: absolute;
+	top: calc(100% - 3px);
+	left: 0;
+	width: calc(100% - 2px);
+	max-height: 200px;
+	overflow-y: auto;
+	background-color: var(--vscode-dropdown-background);
+	border: 1px solid var(--vscode-list-activeSelectionBackground);
+	z-index: ${DROPDOWN_Z_INDEX - 1};
+	border-bottom-left-radius: 3px;
+	border-bottom-right-radius: 3px;
+`
+
+const RegionDropdownItem = styled.div<{ isSelected: boolean }>`
+	padding: 5px 10px;
+	cursor: pointer;
+	word-break: break-all;
+	white-space: normal;
+	text-align: left;
+
+	background-color: ${({ isSelected }) => (isSelected ? "var(--vscode-list-activeSelectionBackground)" : "inherit")};
+
+	&:hover {
+		background-color: var(--vscode-list-activeSelectionBackground);
+	}
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/ClaudeCodeProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/ClaudeCodeProvider.tsx
new file mode 100644
index 0000000..1860624
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/ClaudeCodeProvider.tsx
@@ -0,0 +1,113 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import { SUPPORTED_ANTHROPIC_THINKING_MODELS } from "./AnthropicProvider"
+
+const SUPPORTED_CLAUDE_CODE_THINKING_MODELS = [
+	...SUPPORTED_ANTHROPIC_THINKING_MODELS,
+	"sonnet",
+	"sonnet[1m]",
+	"claude-fable-5[1m]",
+	"claude-opus-4-8[1m]",
+	"claude-opus-4-7[1m]",
+	"claude-sonnet-4-6[1m]",
+	"claude-sonnet-4-5-20250929[1m]",
+	"claude-opus-4-6[1m]",
+	"opus",
+	"opus[1m]",
+]
+
+/**
+ * Props for the ClaudeCodeProvider component
+ */
+interface ClaudeCodeProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Claude Code provider configuration component
+ */
+export const ClaudeCodeProvider = ({ showModelOptions, isPopup, currentMode }: ClaudeCodeProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+	const providerId = "claude-code"
+	const { models, defaultModelId } = useProviderModels(providerId)
+	const { config, commitSelection } = useProviderConfig(providerId)
+	const { selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection(providerId, currentMode, {
+		models,
+		defaultModelId,
+		config,
+		commitSelection,
+	})
+
+	const handleModelSelect = (event: {
+		target?: { value?: unknown }
+		currentTarget?: { value?: unknown }
+		detail?: { value?: unknown }
+	}) => {
+		const modelId = event.target?.value ?? event.currentTarget?.value ?? event.detail?.value
+		if (typeof modelId !== "string" || modelId.length === 0) {
+			return
+		}
+		void commitModelSelection({
+			modelId,
+			modelInfo: models[modelId] ?? selectedModelInfo ?? openAiModelInfoSafeDefaults,
+		}).catch((err) => console.error("Failed to commit Claude Code model selection:", err))
+	}
+
+	return (
+		<div>
+			<DebouncedTextField
+				initialValue={apiConfiguration?.claudeCodePath || ""}
+				onChange={(value) => handleFieldChange("claudeCodePath", value)}
+				placeholder="Default: claude"
+				style={{ width: "100%", marginTop: 3 }}
+				type="text">
+				<span style={{ fontWeight: 500 }}>Claude Code CLI Path</span>
+			</DebouncedTextField>
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				Path to the Claude Code CLI.
+			</p>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector label="Model" models={models} onChange={handleModelSelect} selectedModelId={selectedModelId} />
+
+					{(selectedModelId === "sonnet" || selectedModelId === "opus") && (
+						<p
+							style={{
+								fontSize: "12px",
+								marginBottom: 2,
+								marginTop: 2,
+								color: "var(--vscode-descriptionForeground)",
+							}}>
+							Use the latest version of {selectedModelId} by default.
+						</p>
+					)}
+
+					{SUPPORTED_CLAUDE_CODE_THINKING_MODELS.includes(selectedModelId) && (
+						<ThinkingBudgetSlider currentMode={currentMode} maxBudget={selectedModelInfo.thinkingConfig?.maxBudget} />
+					)}
+
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/ClinePassProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/ClinePassProvider.tsx
new file mode 100644
index 0000000..f955c86
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/ClinePassProvider.tsx
@@ -0,0 +1,274 @@
+import type { ModelInfo } from "@shared/api"
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { CLINE_RECOMMENDED_MODELS_FALLBACK } from "@shared/cline/recommended-models"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { type ClineRecommendedModel, ClineRecommendedModelsResponse } from "@shared/proto/cline/models"
+import { Mode } from "@shared/storage/types"
+import { useEffect, useMemo, useState } from "react"
+import styled from "styled-components"
+import { buildClinePassSubscriptionPageUrl } from "@/components/onboarding/clinePassSubscribe"
+import { useClineAuth } from "@/context/ClineAuthContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { ClineAccountInfoCard } from "../ClineAccountInfoCard"
+import { ModelInfoView } from "../common/ModelInfoView"
+import FeaturedModelCard from "../FeaturedModelCard"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import { type ModelPickerSelection, ModelPickerWithManualEntry } from "./ModelPickerWithManualEntry"
+
+interface ClinePassProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const CLINE_PASS_PROVIDER_ID = "cline-pass"
+const CLINE_PASS_MODEL_ID_PREFIX = "cline-pass/"
+const FREE_TAB_DESCRIPTION = "Try with limited usage, separate from ClinePass quota."
+
+interface FeaturedTabEntry {
+	id: string
+	displayName: string
+	description: string
+	label: string
+}
+
+function clinePassFallbackModelInfo(modelId: string): ModelInfo {
+	return {
+		...openAiModelInfoSafeDefaults,
+		name: modelId,
+		inputPrice: 0,
+		outputPrice: 0,
+		cacheReadsPrice: 0,
+		cacheWritesPrice: 0,
+	}
+}
+
+function toSubscribedEntry(model: Pick<ClineRecommendedModel, "id" | "description">): FeaturedTabEntry | null {
+	if (!model.id) {
+		return null
+	}
+	// The whole list is included with the plan, so no per-card label chip
+	return {
+		id: model.id,
+		displayName: model.id.replace(CLINE_PASS_MODEL_ID_PREFIX, ""),
+		description: model.description || "",
+		label: "",
+	}
+}
+
+function toFreeEntry(model: Pick<ClineRecommendedModel, "id" | "name" | "description" | "tags">): FeaturedTabEntry | null {
+	if (!model.id) {
+		return null
+	}
+	const firstTag = model.tags?.[0]
+	return {
+		id: model.id,
+		// The FREE chip already says it, so drop OpenRouter's :free marker
+		displayName: (model.name || model.id).replace(/:free$/i, ""),
+		description: model.description || "",
+		label: typeof firstTag === "string" && firstTag.length > 0 ? firstTag.toUpperCase() : "FREE",
+	}
+}
+
+/**
+ * ClinePass is a first-class SDK provider whose credentials are backed by the
+ * user's Cline OAuth account. Keep the UX close to the Cline provider (account
+ * card + model selection), but resolve and persist selections through the SDK
+ * provider catalog under providerId="cline-pass".
+ *
+ * The featured section splits the catalog into Subscribed (the plan's models)
+ * and Free (Cline free models, selectable here because both providers hit the
+ * same Cline API — free models simply ride usage billing at $0).
+ */
+export const ClinePassProvider = ({ showModelOptions, isPopup, currentMode }: ClinePassProviderProps) => {
+	const { models, defaultModelId, isLoading, isStale, error } = useProviderModels(CLINE_PASS_PROVIDER_ID)
+	const { config, write, commitSelection } = useProviderConfig(CLINE_PASS_PROVIDER_ID)
+	const { selectedModel, commitModelSelection } = useProviderModelSelection(CLINE_PASS_PROVIDER_ID, currentMode, {
+		models,
+		defaultModelId,
+		config,
+		commitSelection,
+		customModelInfo: clinePassFallbackModelInfo,
+	})
+	const { clineUser } = useClineAuth()
+	const [subscribedEntries, setSubscribedEntries] = useState<FeaturedTabEntry[]>([])
+	const [freeEntries, setFreeEntries] = useState<FeaturedTabEntry[]>([])
+	const [activeTab, setActiveTab] = useState<"subscribed" | "free">("subscribed")
+
+	useEffect(() => {
+		let cancelled = false
+		const fetchRecommendedModels = async () => {
+			try {
+				const response = await ModelsServiceClient.makeUnaryRequest(
+					"refreshClineRecommendedModelsRpc",
+					EmptyRequest.create({}),
+					EmptyRequest.toJSON,
+					ClineRecommendedModelsResponse.fromJSON,
+				)
+				if (cancelled) {
+					return
+				}
+				setSubscribedEntries(
+					(response.clinePass ?? [])
+						.map(toSubscribedEntry)
+						.filter((entry): entry is FeaturedTabEntry => entry !== null),
+				)
+				setFreeEntries(
+					(response.free ?? []).map(toFreeEntry).filter((entry): entry is FeaturedTabEntry => entry !== null),
+				)
+			} catch (err) {
+				console.error("Failed to refresh ClinePass recommended models:", err)
+			}
+		}
+		void fetchRecommendedModels()
+		return () => {
+			cancelled = true
+		}
+	}, [])
+
+	// Fall back to the provider catalog (subscribed) and the bundled free list
+	// until the endpoint responds
+	const subscribedCards = useMemo(() => {
+		if (subscribedEntries.length > 0) {
+			return subscribedEntries
+		}
+		return Object.keys(models ?? {})
+			.filter((id) => id.startsWith(CLINE_PASS_MODEL_ID_PREFIX))
+			.map((id) => toSubscribedEntry({ id, description: models[id]?.description ?? "" }))
+			.filter((entry): entry is FeaturedTabEntry => entry !== null)
+	}, [subscribedEntries, models])
+
+	const freeCards = useMemo(() => {
+		if (freeEntries.length > 0) {
+			return freeEntries
+		}
+		return CLINE_RECOMMENDED_MODELS_FALLBACK.free
+			.map(toFreeEntry)
+			.filter((entry): entry is FeaturedTabEntry => entry !== null)
+	}, [freeEntries])
+
+	// Land on the tab containing the configured model
+	useEffect(() => {
+		if (freeCards.some((entry) => entry.id === selectedModel.modelId)) {
+			setActiveTab("free")
+		} else if (subscribedCards.some((entry) => entry.id === selectedModel.modelId)) {
+			setActiveTab("subscribed")
+		}
+	}, [selectedModel.modelId, freeCards, subscribedCards])
+
+	const handleModelSelect = (selection: ModelPickerSelection) => {
+		void commitModelSelection(selection).catch((err) => console.error("Failed to commit ClinePass model selection:", err))
+	}
+
+	const handleFeaturedModelSelect = (modelId: string) => {
+		handleModelSelect({
+			providerId: CLINE_PASS_PROVIDER_ID,
+			modelId,
+			modelInfo: models?.[modelId] ?? clinePassFallbackModelInfo(modelId),
+		})
+	}
+
+	const activeCards = activeTab === "free" ? freeCards : subscribedCards
+
+	return (
+		<div>
+			<div style={{ marginBottom: 14, marginTop: 4 }}>
+				<ClineAccountInfoCard usageLink={buildClinePassSubscriptionPageUrl(clineUser?.appBaseUrl)} />
+			</div>
+
+			{showModelOptions && (
+				<>
+					{/* Tabs */}
+					<TabsContainer style={{ marginTop: 4 }}>
+						<Tab active={activeTab === "subscribed"} onClick={() => setActiveTab("subscribed")}>
+							Subscribed
+						</Tab>
+						{freeCards.length > 0 && (
+							<Tab active={activeTab === "free"} onClick={() => setActiveTab("free")}>
+								Free
+							</Tab>
+						)}
+					</TabsContainer>
+
+					{/* Tab description */}
+					{activeTab === "free" && <TabDescription>{FREE_TAB_DESCRIPTION}</TabDescription>}
+
+					{/* Model Cards */}
+					<div style={{ marginBottom: "6px" }}>
+						{activeCards.map((entry) => (
+							<FeaturedModelCard
+								description={entry.description}
+								isSelected={selectedModel.modelId === entry.id}
+								key={entry.id}
+								label={entry.label}
+								modelId={entry.displayName}
+								onClick={() => handleFeaturedModelSelect(entry.id)}
+							/>
+						))}
+					</div>
+
+					<ModelPickerWithManualEntry
+						allowsCustomIds={false}
+						error={error}
+						isLoading={isLoading}
+						isStale={isStale}
+						models={models}
+						onSelect={handleModelSelect}
+						selectedModel={selectedModel}
+					/>
+
+					{selectedModel.modelInfo.supportsReasoning === true && (
+						<ReasoningEffortSelector
+							currentMode={currentMode}
+							onEffortChange={(effort) => {
+								void write({
+									reasoning: {
+										enabled: effort !== "none",
+										effort: effort !== "none" ? effort : undefined,
+									},
+								}).catch((err) => console.error("Failed to update ClinePass reasoning effort:", err))
+							}}
+						/>
+					)}
+
+					<ModelInfoView
+						hideUsageCost={true}
+						isPopup={isPopup}
+						modelInfo={selectedModel.modelInfo}
+						selectedModelId={selectedModel.modelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
+
+const TabsContainer = styled.div`
+	display: flex;
+	gap: 0;
+	margin-bottom: 12px;
+	border-bottom: 1px solid var(--vscode-panel-border);
+`
+
+const Tab = styled.div<{ active: boolean }>`
+	padding: 8px 16px;
+	cursor: pointer;
+	font-size: 12px;
+	font-weight: 500;
+	color: ${({ active }) => (active ? "var(--vscode-foreground)" : "var(--vscode-descriptionForeground)")};
+	border-bottom: 2px solid ${({ active }) => (active ? "var(--vscode-textLink-foreground)" : "transparent")};
+	transition: all 0.15s ease;
+
+	&:hover {
+		color: var(--vscode-foreground);
+	}
+`
+
+const TabDescription = styled.p`
+	font-size: 11px;
+	margin: -6px 0 6px 0;
+	color: var(--vscode-descriptionForeground);
+`
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/ClineProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/ClineProvider.tsx
new file mode 100644
index 0000000..adebf96
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/ClineProvider.tsx
@@ -0,0 +1,36 @@
+import { Mode } from "@shared/storage/types"
+import { ClineAccountInfoCard } from "../ClineAccountInfoCard"
+import ClineModelPicker from "../ClineModelPicker"
+
+/**
+ * Props for the ClineProvider component
+ */
+interface ClineProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+	initialModelTab?: "recommended" | "free"
+}
+
+/**
+ * The Cline provider configuration component
+ */
+export const ClineProvider = ({ showModelOptions, isPopup, currentMode, initialModelTab }: ClineProviderProps) => {
+	return (
+		<div>
+			{/* Cline Account Info Card */}
+			<div style={{ marginBottom: 14, marginTop: 4 }}>
+				<ClineAccountInfoCard />
+			</div>
+
+			{showModelOptions && (
+				<ClineModelPicker
+					currentMode={currentMode}
+					initialTab={initialModelTab}
+					isPopup={isPopup}
+					showProviderRouting={true}
+				/>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/DifyProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/DifyProvider.tsx
new file mode 100644
index 0000000..cb3ef62
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/DifyProvider.tsx
@@ -0,0 +1,70 @@
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import { useDebouncedInput } from "../utils/useDebouncedInput"
+
+interface DifyProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+export const DifyProvider = ({ showModelOptions, isPopup, currentMode }: DifyProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	// Use debounced input for proper state management
+	const [baseUrlValue, setBaseUrlValue] = useDebouncedInput(apiConfiguration?.difyBaseUrl || "", (value) =>
+		handleFieldChange("difyBaseUrl", value),
+	)
+
+	const [apiKeyValue, setApiKeyValue] = useDebouncedInput(apiConfiguration?.difyApiKey || "", (value) =>
+		handleFieldChange("difyApiKey", value),
+	)
+
+	// Get the normalized configuration
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("dify", apiConfiguration, currentMode)
+
+	return (
+		<div>
+			<div style={{ display: "flex", flexDirection: "column", gap: 10 }}>
+				<DebouncedTextField
+					initialValue={apiConfiguration?.difyBaseUrl || ""}
+					onChange={(value) => {
+						handleFieldChange("difyBaseUrl", value)
+					}}
+					placeholder={"Enter base URL..."}
+					style={{ width: "100%", marginBottom: 10 }}
+					type="text">
+					<span style={{ fontWeight: 500 }}>Base URL</span>
+				</DebouncedTextField>
+
+				<ApiKeyField
+					initialValue={apiConfiguration?.difyApiKey || ""}
+					onChange={(value) => {
+						handleFieldChange("difyApiKey", value)
+					}}
+					providerName="Dify"
+				/>
+
+				<div style={{ fontSize: "12px", color: "var(--vscode-descriptionForeground)", marginTop: "5px" }}>
+					<p>
+						Dify is a platform that provides access to various AI models through a unified API. Configure your Dify
+						instance URL and API key to get started.
+					</p>
+					<p style={{ marginTop: "8px" }}>
+						<strong>Note:</strong> The model selection is handled within your Dify application configuration.
+					</p>
+				</div>
+			</div>
+
+			{showModelOptions && (
+				<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/GenericProviderSettings.test.tsx b/apps/vscode/webview-ui/src/components/settings/providers/GenericProviderSettings.test.tsx
new file mode 100644
index 0000000..e808b21
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/GenericProviderSettings.test.tsx
@@ -0,0 +1,466 @@
+import type { ProviderConfigResponse } from "@shared/proto/cline/models"
+import { ApiFormat } from "@shared/proto/cline/models"
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import type { ChangeEventHandler, ReactNode } from "react"
+import { describe, expect, it, vi } from "vitest"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { GenericProviderSettings } from "./GenericProviderSettings"
+
+const providerConfig = (config: Partial<ProviderConfigResponse>): ProviderConfigResponse => config as ProviderConfigResponse
+
+vi.mock("@/hooks/useProviderModels", () => ({
+	useProviderModels: vi.fn(),
+}))
+
+vi.mock("@/hooks/useProviderConfig", () => ({
+	useProviderConfig: vi.fn(),
+}))
+
+// The reasoning effort selector reads the extension state for the current
+// mode-specific reasoning effort value.
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: () => ({ apiConfiguration: {}, planActSeparateModelsSetting: false }),
+}))
+
+// Render the dropdown web components as native elements so value/change
+// behavior is observable in jsdom. Other toolkit components stay real.
+vi.mock("@vscode/webview-ui-toolkit/react", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@vscode/webview-ui-toolkit/react")>()
+	return {
+		...actual,
+		VSCodeDropdown: ({
+			children,
+			id,
+			onChange,
+			value,
+			"aria-label": ariaLabel,
+		}: {
+			children?: ReactNode
+			id?: string
+			onChange?: ChangeEventHandler<HTMLSelectElement>
+			value?: string
+			"aria-label"?: string
+		}) => (
+			<select aria-label={ariaLabel} id={id} onChange={onChange} value={value}>
+				{children}
+			</select>
+		),
+		VSCodeOption: ({ children, value }: { children?: ReactNode; value?: string }) => (
+			<option value={value}>{children}</option>
+		),
+	}
+})
+
+describe("GenericProviderSettings", () => {
+	it("renders catalog-backed provider settings and commits full model selections", async () => {
+		const commitSelection = vi.fn(async () => undefined)
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {
+				"deepseek-chat": { name: "DeepSeek Chat", supportsPromptCache: true, contextWindow: 128_000 },
+				"deepseek-reasoner": {
+					name: "DeepSeek Reasoner",
+					supportsPromptCache: true,
+					contextWindow: 128_000,
+					supportsReasoning: true,
+				},
+			},
+			defaultModelId: "deepseek-chat",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: undefined,
+			write,
+			commitSelection,
+		})
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={true}
+			/>,
+		)
+
+		expect(screen.getByLabelText("Model")).toHaveValue("deepseek-chat")
+		expect(screen.queryByText("Reasoning Effort")).not.toBeInTheDocument()
+		fireEvent.change(screen.getByLabelText("Model"), { target: { value: "deepseek-reasoner" } })
+
+		await waitFor(() => expect(commitSelection).toHaveBeenCalledTimes(1))
+		expect(commitSelection).toHaveBeenCalledWith("act", {
+			providerId: "deepseek",
+			modelId: "deepseek-reasoner",
+			modelInfo: { name: "DeepSeek Reasoner", supportsPromptCache: true, contextWindow: 128_000, supportsReasoning: true },
+		})
+		expect(useProviderModels).toHaveBeenCalledWith("deepseek")
+		expect(useProviderConfig).toHaveBeenCalledWith("deepseek")
+	})
+
+	it("renders a reasoning effort selector when the selected model supports reasoning", () => {
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {
+				"deepseek-reasoner": {
+					name: "DeepSeek Reasoner",
+					supportsPromptCache: true,
+					contextWindow: 128_000,
+					supportsReasoning: true,
+				},
+			},
+			defaultModelId: "deepseek-reasoner",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: undefined,
+			write: vi.fn(async () => undefined),
+			commitSelection: vi.fn(),
+		})
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={true}
+			/>,
+		)
+
+		expect(screen.getByText("Reasoning Effort")).toBeInTheDocument()
+	})
+
+	it("shows saved API keys as masked and does not clear them on mount", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 12 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		const apiKeyInput = screen.getByDisplayValue("••••••••••••")
+		await new Promise((resolve) => setTimeout(resolve, 150))
+		expect(write).not.toHaveBeenCalled()
+
+		fireEvent.input(apiKeyInput, { target: { value: "new-secret" } })
+
+		await waitFor(() => expect(write).toHaveBeenCalledWith({ apiKey: "new-secret" }))
+	})
+
+	it("does not clear API keys while provider config is loading", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({ config: undefined, write, commitSelection: vi.fn() })
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		await new Promise((resolve) => setTimeout(resolve, 150))
+		expect(write).not.toHaveBeenCalled()
+	})
+
+	it("does not save when provider config hydrates a saved API key", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({ config: undefined, write, commitSelection: vi.fn() })
+
+		const { rerender } = render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		await new Promise((resolve) => setTimeout(resolve, 150))
+		expect(write).not.toHaveBeenCalled()
+
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 8 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+		rerender(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		expect(screen.getByDisplayValue("••••••••")).toBeInTheDocument()
+		await new Promise((resolve) => setTimeout(resolve, 150))
+		expect(write).not.toHaveBeenCalled()
+	})
+
+	it("does not write a mask if config hydrates after a blurred edit", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({ config: undefined, write, commitSelection: vi.fn() })
+
+		const { rerender } = render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		const apiKeyInput = screen.getByPlaceholderText("Enter API Key...")
+		fireEvent.input(apiKeyInput, { target: { value: "partial-key" } })
+		fireEvent.blur(apiKeyInput)
+
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 8 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+		rerender(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		await new Promise((resolve) => setTimeout(resolve, 150))
+		expect(write).not.toHaveBeenCalledWith({ apiKey: "••••••••" })
+		expect(write).not.toHaveBeenCalled()
+	})
+
+	it("still allows users to clear a saved API key", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 8 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		fireEvent.input(screen.getByDisplayValue("••••••••"), { target: { value: "" } })
+
+		await waitFor(() => expect(write).toHaveBeenCalledWith({ apiKey: "" }))
+	})
+
+	it("does not persist mask characters when editing a saved API key", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 7 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		fireEvent.input(screen.getByDisplayValue("•••••••"), { target: { value: "•••••••f" } })
+
+		await waitFor(() => expect(write).toHaveBeenCalledWith({ apiKey: "f" }), { timeout: 1_000 })
+		expect(write).not.toHaveBeenCalledWith({ apiKey: "•••••••f" })
+	})
+
+	it("does not replace in-progress API key typing when saved key length rerenders", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {},
+			defaultModelId: "",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 0 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+
+		const { rerender } = render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		const apiKeyInput = screen.getByPlaceholderText("Enter API Key...")
+		fireEvent.focus(apiKeyInput)
+		fireEvent.input(apiKeyInput, { target: { value: "max" } })
+
+		await waitFor(() => expect(write).toHaveBeenCalledWith({ apiKey: "max" }))
+
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ apiKeyLength: 3 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+		rerender(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				currentMode="act"
+				providerId="deepseek"
+				providerName="DeepSeek"
+				showModelOptions={false}
+			/>,
+		)
+
+		expect(apiKeyInput).toHaveValue("max")
+
+		fireEvent.input(apiKeyInput, { target: { value: "maxpaulus" } })
+
+		await waitFor(() => expect(write).toHaveBeenCalledWith({ apiKey: "maxpaulus" }))
+		expect(write).not.toHaveBeenCalledWith({ apiKey: "lus" })
+	})
+
+	it("can render and update an optional base URL field through provider config", async () => {
+		const write = vi.fn(async () => undefined)
+		vi.mocked(useProviderModels).mockReturnValue({
+			models: {
+				"gemini-3.1-pro-preview": {
+					name: "Gemini 3.1 Pro Preview",
+					supportsPromptCache: true,
+					contextWindow: 1_000_000,
+					apiFormat: ApiFormat.GEMINI_CHAT,
+				},
+			},
+			defaultModelId: "gemini-3.1-pro-preview",
+			isLoading: false,
+			isStale: false,
+			error: undefined,
+			refresh: vi.fn(),
+			fingerprint: "fingerprint",
+		})
+		vi.mocked(useProviderConfig).mockReturnValue({
+			config: providerConfig({ baseUrl: "https://custom.example", apiKeyLength: 0 }),
+			write,
+			commitSelection: vi.fn(),
+		})
+
+		render(
+			<GenericProviderSettings
+				allowsCustomIds={false}
+				baseUrlField={{
+					label: "Use custom base URL",
+					placeholder: "Default: https://generativelanguage.googleapis.com",
+				}}
+				currentMode="act"
+				providerId="gemini"
+				providerName="Gemini"
+				showModelOptions={false}
+			/>,
+		)
+
+		const baseUrlInput = screen.getByPlaceholderText("Default: https://generativelanguage.googleapis.com")
+		fireEvent.input(baseUrlInput, { target: { value: "https://new.example" } })
+
+		await waitFor(() => expect(write).toHaveBeenCalledWith({ baseUrl: "https://new.example" }))
+
+		fireEvent.click(screen.getByText("Use custom base URL"))
+
+		expect(write).toHaveBeenCalledWith({ baseUrl: "" })
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/GenericProviderSettings.tsx b/apps/vscode/webview-ui/src/components/settings/providers/GenericProviderSettings.tsx
new file mode 100644
index 0000000..e9d355c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/GenericProviderSettings.tsx
@@ -0,0 +1,123 @@
+import { Mode } from "@shared/storage/types"
+import { type ProviderId } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+import { type ModelPickerSelection, ModelPickerWithManualEntry } from "./ModelPickerWithManualEntry"
+
+interface GenericProviderBaseUrlFieldConfig {
+	label?: string
+	placeholder?: string
+}
+
+export interface GenericProviderSettingsProps {
+	providerId: ProviderId
+	providerName: string
+	signupUrl?: string
+	baseUrlField?: GenericProviderBaseUrlFieldConfig
+	allowsCustomIds: boolean
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * Shared settings shell for providers whose configuration is the common
+ * catalog-backed shape: API key, optional base URL, model picker, and model
+ * info. Provider-specific wrappers should pass metadata while custom providers
+ * keep their own components.
+ */
+export const GenericProviderSettings = ({
+	providerId,
+	providerName,
+	signupUrl,
+	baseUrlField,
+	allowsCustomIds,
+	showModelOptions,
+	isPopup,
+	currentMode,
+}: GenericProviderSettingsProps) => {
+	const { models, defaultModelId, isLoading, isStale, error } = useProviderModels(providerId)
+	const { config, write, commitSelection } = useProviderConfig(providerId)
+	const { selectedModel, commitModelSelection } = useProviderModelSelection(providerId, currentMode, {
+		models,
+		defaultModelId,
+		config,
+		commitSelection,
+	})
+
+	const handleModelSelect = (selection: ModelPickerSelection) => {
+		void commitModelSelection(selection).catch((err) =>
+			console.error(`Failed to commit ${providerName} model selection:`, err),
+		)
+	}
+
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		providerName,
+		write,
+	})
+	const handleBaseUrlChange = (value: string) => {
+		void write({ baseUrl: value }).catch((err) => console.error(`Failed to update ${providerName} base URL:`, err))
+	}
+
+	return (
+		<div>
+			<ApiKeyField
+				initialValue={savedApiKeyMask}
+				onChange={handleApiKeyChange}
+				placeholder="Enter API Key..."
+				providerName={providerName}
+				signupUrl={signupUrl}
+			/>
+
+			{baseUrlField && (
+				<BaseUrlField
+					initialValue={config?.baseUrl}
+					label={baseUrlField.label}
+					onChange={handleBaseUrlChange}
+					placeholder={baseUrlField.placeholder}
+				/>
+			)}
+
+			{showModelOptions && (
+				<>
+					<ModelPickerWithManualEntry
+						allowsCustomIds={allowsCustomIds}
+						error={error}
+						isLoading={isLoading}
+						isStale={isStale}
+						models={models}
+						onSelect={handleModelSelect}
+						selectedModel={selectedModel}
+					/>
+
+					{selectedModel.modelInfo.supportsReasoning === true && (
+						<ReasoningEffortSelector
+							currentMode={currentMode}
+							onEffortChange={(effort) => {
+								void write({
+									reasoning: {
+										enabled: effort !== "none",
+										effort: effort !== "none" ? effort : undefined,
+									},
+								}).catch((err) => console.error(`Failed to update ${providerName} reasoning effort:`, err))
+							}}
+						/>
+					)}
+
+					<ModelInfoView
+						isPopup={isPopup}
+						modelInfo={selectedModel.modelInfo}
+						selectedModelId={selectedModel.modelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/GroqProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/GroqProvider.tsx
new file mode 100644
index 0000000..db235c9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/GroqProvider.tsx
@@ -0,0 +1,35 @@
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ApiKeyField } from "../common/ApiKeyField"
+import GroqModelPicker from "../GroqModelPicker"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the GroqProvider component
+ */
+interface GroqProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Groq provider configuration component
+ */
+export const GroqProvider = ({ showModelOptions, isPopup, currentMode }: GroqProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	return (
+		<div>
+			<ApiKeyField
+				initialValue={apiConfiguration?.groqApiKey || ""}
+				onChange={(value) => handleFieldChange("groqApiKey", value)}
+				providerName="Groq"
+				signupUrl="https://console.groq.com/keys"
+			/>
+
+			{showModelOptions && <GroqModelPicker currentMode={currentMode} isPopup={isPopup} />}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/HicapProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/HicapProvider.tsx
new file mode 100644
index 0000000..cc15377
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/HicapProvider.tsx
@@ -0,0 +1,82 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import { useEffect } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { AccountServiceClient } from "@/services/grpc-client"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import HicapModelPicker from "../HicapModelPicker"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the HicapProvider component
+ */
+interface HicapProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Hicap provider configuration component
+ */
+export const HicapProvider = ({ showModelOptions, isPopup, currentMode }: HicapProviderProps) => {
+	const { apiConfiguration, refreshHicapModels } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	useEffect(() => {
+		if (apiConfiguration?.hicapApiKey && apiConfiguration?.hicapApiKey.length === 32) {
+			refreshHicapModels()
+		}
+	}, [apiConfiguration?.hicapApiKey])
+
+	return (
+		<div>
+			<div>
+				<DebouncedTextField
+					initialValue={apiConfiguration?.hicapApiKey || ""}
+					onChange={(value) => {
+						handleFieldChange("hicapApiKey", value)
+						if (value.length === 32) {
+							refreshHicapModels()
+						}
+					}}
+					placeholder="Enter API Key..."
+					style={{ width: "100%" }}
+					type="password">
+					<div
+						style={{
+							display: "flex",
+							justifyContent: "space-between",
+							alignItems: "center",
+							width: "100%",
+							margin: "10px 0 0 0",
+						}}>
+						<span style={{ fontWeight: 500 }}>Hicap API Key</span>
+					</div>
+				</DebouncedTextField>
+
+				{!apiConfiguration?.hicapApiKey && (
+					<VSCodeButton
+						appearance="secondary"
+						onClick={async () => {
+							try {
+								await AccountServiceClient.hicapAuthClicked(EmptyRequest.create())
+							} catch (error) {
+								console.error("Failed to open Hicap auth:", error)
+							}
+						}}
+						style={{ margin: "5px 0 0 0" }}>
+						Generate API Key
+					</VSCodeButton>
+				)}
+			</div>
+
+			{showModelOptions && (
+				<div style={{ margin: "10px 0 0 0" }}>
+					<HicapModelPicker currentMode={currentMode} isPopup={isPopup} />
+				</div>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/HuggingFaceProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/HuggingFaceProvider.tsx
new file mode 100644
index 0000000..1ec8178
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/HuggingFaceProvider.tsx
@@ -0,0 +1,53 @@
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { HuggingFaceModelPicker } from "../HuggingFaceModelPicker"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the HuggingFaceProvider component
+ */
+interface HuggingFaceProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Hugging Face provider configuration component
+ */
+export const HuggingFaceProvider = ({ showModelOptions, isPopup, currentMode }: HuggingFaceProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	// Get the normalized configuration
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("huggingface", apiConfiguration, currentMode)
+
+	return (
+		<div>
+			<DebouncedTextField
+				initialValue={apiConfiguration?.huggingFaceApiKey || ""}
+				onChange={(value) => handleFieldChange("huggingFaceApiKey", value)}
+				placeholder="Enter API Key..."
+				style={{ width: "100%" }}
+				type="password">
+				<span style={{ fontWeight: 500 }}>Hugging Face API Key</span>
+			</DebouncedTextField>
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: "5px",
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				This key is stored locally and only used to make API requests from this extension. We don’t show pricing here
+				because it depends on your Hugging Face provider settings and isn’t consistently available via their API{" "}
+				<a href="https://huggingface.co/settings/tokens" rel="noopener noreferrer" target="_blank">
+					Get your API key here
+				</a>
+			</p>
+
+			{showModelOptions && <HuggingFaceModelPicker currentMode={currentMode} isPopup={isPopup} />}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/LMStudioProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/LMStudioProvider.tsx
new file mode 100644
index 0000000..bcaddb2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/LMStudioProvider.tsx
@@ -0,0 +1,216 @@
+import { type ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import { VSCodeDropdown, VSCodeLink, VSCodeOption, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useCallback, useEffect, useMemo, useState } from "react"
+import { useInterval } from "react-use"
+import UseCustomPromptCheckbox from "@/components/settings/UseCustomPromptCheckbox"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { DropdownContainer } from "../common/ModelSelector"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the LMStudioProvider component
+ */
+interface LMStudioProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+interface LMStudioApiModel {
+	id: string
+	object?: "model"
+	type?: string
+	publisher?: string
+	arch?: string
+	compatibility_type?: string
+	quantization?: string
+	state?: string
+	max_context_length?: number
+	loaded_context_length?: number
+}
+
+/**
+ * The LM Studio provider configuration component
+ */
+export const LMStudioProvider = ({ currentMode }: LMStudioProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+	const { config, write, commitSelection } = useProviderConfig("lmstudio")
+
+	const [lmStudioModels, setLmStudioModels] = useState<LMStudioApiModel[]>([])
+	const [pendingSelectedModelId, setPendingSelectedModelId] = useState<string | undefined>(undefined)
+
+	const toLmStudioModelInfo = useCallback((model: LMStudioApiModel | undefined, modelId: string): ModelInfo => {
+		const contextWindow = model?.loaded_context_length ?? model?.max_context_length
+		return {
+			...openAiModelInfoSafeDefaults,
+			name: modelId,
+			...(contextWindow !== undefined && contextWindow > 0 ? { contextWindow } : {}),
+			...(model?.max_context_length !== undefined && model.max_context_length > 0
+				? { maxTokens: model.max_context_length }
+				: {}),
+		}
+	}, [])
+	const lmStudioModelInfoById = useMemo(
+		() => Object.fromEntries(lmStudioModels.map((model) => [model.id, toLmStudioModelInfo(model, model.id)])),
+		[lmStudioModels, toLmStudioModelInfo],
+	)
+	const { selectedModel, commitModelSelection } = useProviderModelSelection("lmstudio", currentMode, {
+		models: lmStudioModelInfoById,
+		config,
+		commitSelection,
+		fallbackModelInfo: openAiModelInfoSafeDefaults,
+		customModelInfo: (modelId) => toLmStudioModelInfo(undefined, modelId),
+	})
+	const displayedSelectedModelId = pendingSelectedModelId ?? selectedModel.modelId
+	const currentLMStudioModel = useMemo(
+		() => lmStudioModels.find((model) => model.id === displayedSelectedModelId),
+		[displayedSelectedModelId, lmStudioModels],
+	)
+	const endpoint = useMemo(
+		() => config?.baseUrl ?? apiConfiguration?.lmStudioBaseUrl ?? "http://localhost:1234",
+		[apiConfiguration?.lmStudioBaseUrl, config?.baseUrl],
+	)
+
+	const handleBaseUrlChange = useCallback(
+		(value: string) => {
+			void write({ baseUrl: value }).catch((error) => console.error("Failed to update LM Studio base URL:", error))
+		},
+		[write],
+	)
+
+	const handleModelChange = useCallback(
+		(modelId: string) => {
+			const trimmedModelId = modelId.trim()
+			if (!trimmedModelId) {
+				return
+			}
+			setPendingSelectedModelId(trimmedModelId)
+			const model = lmStudioModels.find((candidate) => candidate.id === trimmedModelId)
+			void commitModelSelection({
+				modelId: trimmedModelId,
+				modelInfo: toLmStudioModelInfo(model, trimmedModelId),
+			}).catch((error) => {
+				console.error("Failed to update LM Studio model selection:", error)
+				setPendingSelectedModelId(undefined)
+			})
+		},
+		[commitModelSelection, lmStudioModels, toLmStudioModelInfo],
+	)
+
+	// Poll LM Studio models
+	const requestLmStudioModels = useCallback(async () => {
+		await ModelsServiceClient.getLmStudioModels({
+			value: endpoint,
+		})
+			.then((response) => {
+				if (response?.values) {
+					const models = response.values.map((v) => JSON.parse(v) as LMStudioApiModel)
+					setLmStudioModels(models)
+				}
+			})
+			.catch((error) => {
+				console.error("Failed to parse LM Studio models:", error)
+			})
+	}, [endpoint])
+
+	useEffect(() => {
+		requestLmStudioModels()
+	}, [requestLmStudioModels])
+
+	const lmStudioMaxTokens = currentLMStudioModel?.max_context_length?.toString()
+	const currentLoadedContext = currentLMStudioModel?.loaded_context_length?.toString()
+
+	useEffect(() => {
+		if (pendingSelectedModelId && selectedModel.modelId === pendingSelectedModelId) {
+			setPendingSelectedModelId(undefined)
+		}
+	}, [pendingSelectedModelId, selectedModel.modelId])
+
+	useEffect(() => {
+		const curr = currentLMStudioModel?.loaded_context_length?.toString()
+		const max = currentLMStudioModel?.max_context_length?.toString()
+		const choice = apiConfiguration?.lmStudioMaxTokens ?? max
+		if (curr && curr !== choice) {
+			handleFieldChange("lmStudioMaxTokens", curr)
+		}
+	}, [
+		currentLMStudioModel?.loaded_context_length,
+		currentLMStudioModel?.max_context_length,
+		apiConfiguration?.lmStudioMaxTokens,
+		handleFieldChange,
+	])
+
+	useInterval(requestLmStudioModels, 6000)
+
+	return (
+		<div className="flex flex-col gap-2">
+			<BaseUrlField
+				initialValue={config?.baseUrl ?? apiConfiguration?.lmStudioBaseUrl}
+				label="Use custom base URL"
+				onChange={handleBaseUrlChange}
+				placeholder="Default: http://localhost:1234"
+			/>
+
+			<div className="font-semibold">Model</div>
+			{lmStudioModels.length > 0 ? (
+				<DropdownContainer className="dropdown-container" zIndex={10}>
+					<VSCodeDropdown
+						className="w-full mb-3"
+						onChange={(e: any) => {
+							const value = e?.target?.value
+							if (typeof value === "string") {
+								handleModelChange(value)
+							}
+						}}
+						value={displayedSelectedModelId}>
+						{lmStudioModels.map((model) => (
+							<VSCodeOption className="w-full" key={model.id} value={model.id}>
+								{model.id}
+							</VSCodeOption>
+						))}
+					</VSCodeDropdown>
+				</DropdownContainer>
+			) : (
+				<DebouncedTextField
+					initialValue={displayedSelectedModelId || ""}
+					onChange={handleModelChange}
+					placeholder={"e.g. meta-llama-3.1-8b-instruct"}
+					style={{ width: "100%" }}
+				/>
+			)}
+
+			<div className="font-semibold">Context Window</div>
+			<VSCodeTextField
+				className="w-full pointer-events-none"
+				disabled={true}
+				title="Not editable - the value is returned by the connected endpoint"
+				value={String(currentLoadedContext ?? lmStudioMaxTokens ?? "0")}
+			/>
+
+			<UseCustomPromptCheckbox providerId="lmstudio" />
+
+			<div className="text-xs text-description">
+				LM Studio allows you to run models locally on your computer. For instructions on how to get started, see their
+				<VSCodeLink href="https://lmstudio.ai/docs" style={{ display: "inline", fontSize: "inherit" }}>
+					quickstart guide.
+				</VSCodeLink>
+				You will also need to start LM Studio's{" "}
+				<VSCodeLink className="inline" href="https://lmstudio.ai/docs/basics/server">
+					local server
+				</VSCodeLink>{" "}
+				feature with <code>lms server start</code> to use it with this extension.{" "}
+				<div className="text-error">
+					<span className="font-semibold">Note:</span> Cline uses complex prompts, so behavior can vary across models.
+					Less capable models may not work as expected.
+				</div>
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/LiteLlmProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/LiteLlmProvider.tsx
new file mode 100644
index 0000000..de077df
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/LiteLlmProvider.tsx
@@ -0,0 +1,162 @@
+import { ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { RefreshCwIcon } from "lucide-react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelAutocomplete } from "../common/ModelAutocomplete"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { LockIcon, RemotelyConfiguredInputWrapper } from "../common/RemotelyConfiguredInputWrapper"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+const LITELLM_PROVIDER_ID = "litellm"
+
+function customModelInfo(modelId: string): ModelInfo {
+	return {
+		...openAiModelInfoSafeDefaults,
+		name: modelId,
+	}
+}
+
+/**
+ * Props for the LiteLlmProvider component
+ */
+interface LiteLlmProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+export const LiteLlmProvider = ({ showModelOptions, isPopup, currentMode }: LiteLlmProviderProps) => {
+	const { remoteConfigSettings } = useExtensionState()
+	const { models, defaultModelId, isLoading, isStale, error, refresh } = useProviderModels(LITELLM_PROVIDER_ID)
+	const { config, write, commitSelection } = useProviderConfig(LITELLM_PROVIDER_ID)
+	const { selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection(
+		LITELLM_PROVIDER_ID,
+		currentMode,
+		{
+			models,
+			defaultModelId,
+			config,
+			commitSelection,
+			customModelInfo,
+		},
+	)
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		canWrite: config !== undefined,
+		providerName: "LiteLLM",
+		write,
+	})
+
+	const handleModelChange = (newModelId: string, modelInfo: ModelInfo | undefined) => {
+		void commitModelSelection({
+			modelId: newModelId,
+			modelInfo: modelInfo ?? customModelInfo(newModelId),
+		}).catch((err) => console.error("Failed to commit LiteLLM model selection:", err))
+	}
+
+	const onRefreshModels = async () => {
+		await refresh()
+	}
+
+	const handleBaseUrlChange = (value: string) => {
+		if (!config) {
+			return
+		}
+
+		void write({ baseUrl: value }).catch((err) => console.error("Failed to update LiteLLM base URL:", err))
+	}
+
+	return (
+		<div>
+			<RemotelyConfiguredInputWrapper hidden={remoteConfigSettings?.liteLlmBaseUrl === undefined}>
+				<DebouncedTextField
+					disabled={remoteConfigSettings?.liteLlmBaseUrl !== undefined}
+					initialValue={config?.baseUrl || ""}
+					onChange={handleBaseUrlChange}
+					placeholder={"Default: http://localhost:4000"}
+					style={{ width: "100%" }}
+					type="text">
+					<div className="flex items-center gap-2 mb-1">
+						<span style={{ fontWeight: 500 }}>Base URL (optional)</span>
+						{remoteConfigSettings?.liteLlmBaseUrl !== undefined && <LockIcon />}
+					</div>
+				</DebouncedTextField>
+			</RemotelyConfiguredInputWrapper>
+			<RemotelyConfiguredInputWrapper hidden={!remoteConfigSettings?.configuredApiKeys?.litellm}>
+				<DebouncedTextField
+					disabled={remoteConfigSettings?.configuredApiKeys?.litellm}
+					initialValue={savedApiKeyMask}
+					onChange={handleApiKeyChange}
+					placeholder="Default: noop"
+					style={{ width: "100%" }}
+					type="password">
+					<div className="flex items-center gap-2 mb-1">
+						<span style={{ fontWeight: 500 }}>API Key</span>
+						{remoteConfigSettings?.configuredApiKeys?.litellm && <LockIcon />}
+					</div>
+				</DebouncedTextField>
+			</RemotelyConfiguredInputWrapper>
+			{showModelOptions && (
+				<>
+					{isStale && <div role="status">Model list may be stale for the current LiteLLM configuration.</div>}
+					{error && <div role="alert">{error}</div>}
+					<ModelAutocomplete
+						label="Model"
+						models={models}
+						onChange={handleModelChange}
+						placeholder="Search or enter a custom model ID..."
+						selectedModelId={selectedModelId}
+					/>
+					<VSCodeButton
+						className={`my-2 ${isLoading ? "animate-pulse" : ""}`}
+						disabled={isLoading}
+						onClick={onRefreshModels}>
+						{isLoading ? (
+							"Loading..."
+						) : (
+							<>
+								Refresh models <RefreshCwIcon className="ml-1" />
+							</>
+						)}
+					</VSCodeButton>
+
+					{selectedModelInfo?.supportsReasoning && <ThinkingBudgetSlider currentMode={currentMode} />}
+
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			)}
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: "5px",
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				Extended thinking is available for models such as Sonnet-4, o3-mini, Deepseek R1, etc. More info on{" "}
+				<VSCodeLink
+					href="https://docs.litellm.ai/docs/reasoning_content"
+					style={{ display: "inline", fontSize: "inherit" }}>
+					thinking mode configuration
+				</VSCodeLink>
+			</p>
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: "5px",
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				LiteLLM provides a unified interface to access various LLM providers' models. See their{" "}
+				<VSCodeLink href="https://docs.litellm.ai/docs/" style={{ display: "inline", fontSize: "inherit" }}>
+					quickstart guide
+				</VSCodeLink>{" "}
+				for more information.
+			</p>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/ModelPickerWithManualEntry.test.tsx b/apps/vscode/webview-ui/src/components/settings/providers/ModelPickerWithManualEntry.test.tsx
new file mode 100644
index 0000000..571c8f1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/ModelPickerWithManualEntry.test.tsx
@@ -0,0 +1,323 @@
+import { fireEvent, render, screen } from "@testing-library/react"
+import type { ChangeEventHandler, FormEventHandler, KeyboardEventHandler, ReactNode } from "react"
+import { describe, expect, it, vi } from "vitest"
+import { type ModelPickerSelection, ModelPickerWithManualEntry } from "./ModelPickerWithManualEntry"
+
+// Render the toolkit web components as native elements so value/change
+// behavior is observable in jsdom.
+vi.mock("@vscode/webview-ui-toolkit/react", () => ({
+	VSCodeDropdown: ({
+		children,
+		id,
+		onChange,
+		value,
+		"aria-label": ariaLabel,
+	}: {
+		children?: ReactNode
+		id?: string
+		onChange?: ChangeEventHandler<HTMLSelectElement>
+		value?: string
+		"aria-label"?: string
+	}) => (
+		<select aria-label={ariaLabel} id={id} onChange={onChange} value={value}>
+			{children}
+		</select>
+	),
+	VSCodeOption: ({ children, value }: { children?: ReactNode; value?: string }) => <option value={value}>{children}</option>,
+	VSCodeTextField: ({
+		children,
+		id,
+		onInput,
+		onKeyDown,
+		placeholder,
+		value,
+	}: {
+		children?: ReactNode
+		id?: string
+		onInput?: FormEventHandler<HTMLInputElement>
+		onKeyDown?: KeyboardEventHandler<HTMLInputElement>
+		placeholder?: string
+		value?: string
+	}) => (
+		<div>
+			<label htmlFor={id}>{children}</label>
+			<input id={id} onChange={onInput} onKeyDown={onKeyDown} placeholder={placeholder} value={value} />
+		</div>
+	),
+	VSCodeButton: ({ children, onClick }: { children?: ReactNode; onClick?: () => void }) => (
+		<button onClick={onClick} type="button">
+			{children}
+		</button>
+	),
+}))
+
+const selectedModel: ModelPickerSelection = {
+	providerId: "ollama",
+	modelId: "llama3",
+	modelInfo: { name: "Llama 3", supportsPromptCache: false, contextWindow: 8192 },
+}
+
+const models = {
+	llama3: { name: "Llama 3", supportsPromptCache: false, contextWindow: 8192 },
+	mistral: { name: "Mistral", supportsPromptCache: false, contextWindow: 32768 },
+}
+
+describe("ModelPickerWithManualEntry", () => {
+	it("selects a known model as a full selection triple", () => {
+		const onSelect = vi.fn()
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={false}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={models}
+				onSelect={onSelect}
+				selectedModel={selectedModel}
+			/>,
+		)
+
+		fireEvent.change(screen.getByLabelText("Model"), { target: { value: "mistral" } })
+
+		expect(onSelect).toHaveBeenCalledWith({ providerId: "ollama", modelId: "mistral", modelInfo: models.mistral })
+	})
+
+	it("shows manual entry during loading when custom ids are allowed", () => {
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={true}
+				isStale={false}
+				models={{}}
+				onSelect={vi.fn()}
+				selectedModel={selectedModel}
+			/>,
+		)
+
+		expect(screen.getByText("Loading models…")).toBeInTheDocument()
+		expect(screen.getByLabelText("Custom model ID")).toBeInTheDocument()
+	})
+
+	it("shows manual entry during error when custom ids are allowed", () => {
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error="Could not fetch models"
+				isLoading={false}
+				isStale={false}
+				models={{}}
+				onSelect={vi.fn()}
+				selectedModel={selectedModel}
+			/>,
+		)
+
+		expect(screen.getByRole("alert")).toHaveTextContent("Could not fetch models")
+		expect(screen.getByLabelText("Custom model ID")).toBeInTheDocument()
+	})
+
+	it("commits custom model ids with safe default model info", () => {
+		const onSelect = vi.fn()
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={{}}
+				onSelect={onSelect}
+				selectedModel={selectedModel}
+			/>,
+		)
+
+		fireEvent.change(screen.getByLabelText("Custom model ID"), { target: { value: "my-custom:latest" } })
+		fireEvent.click(screen.getByText("Use custom model"))
+
+		expect(onSelect).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "ollama",
+				modelId: "my-custom:latest",
+				modelInfo: expect.objectContaining({ name: "my-custom:latest", supportsPromptCache: false }),
+			}),
+		)
+	})
+
+	it("reveals manual entry from the custom option when models are present", () => {
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={models}
+				onSelect={vi.fn()}
+				selectedModel={selectedModel}
+			/>,
+		)
+
+		expect(screen.queryByLabelText("Custom model ID")).not.toBeInTheDocument()
+		fireEvent.change(screen.getByLabelText("Model"), { target: { value: "__custom__" } })
+		expect(screen.getByLabelText("Custom model ID")).toBeInTheDocument()
+	})
+
+	it("shows stale and not-in-current-list indicators without replacing selection", () => {
+		const onSelect = vi.fn()
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={true}
+				models={models}
+				onSelect={onSelect}
+				selectedModel={{ ...selectedModel, modelId: "custom-outside-list" }}
+			/>,
+		)
+
+		expect(screen.getByText("Model list may be stale for the current provider configuration.")).toBeInTheDocument()
+		expect(screen.getByText("Selected model “custom-outside-list” is not in the current list.")).toBeInTheDocument()
+		expect(onSelect).not.toHaveBeenCalled()
+	})
+
+	it("shows not-in-current-list indicator even when custom ids are not allowed", () => {
+		const onSelect = vi.fn()
+		render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={false}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={models}
+				onSelect={onSelect}
+				selectedModel={{ ...selectedModel, modelId: "retired-static-model" }}
+			/>,
+		)
+
+		expect(screen.getByText("Selected model “retired-static-model” is not in the current list.")).toBeInTheDocument()
+		expect(screen.queryByLabelText("Custom model ID")).not.toBeInTheDocument()
+		expect(onSelect).not.toHaveBeenCalled()
+	})
+
+	it("prefills the custom field when the committed selection hydrates after mount", () => {
+		const { rerender } = render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={true}
+				isStale={false}
+				models={{}}
+				onSelect={vi.fn()}
+				selectedModel={{ ...selectedModel, modelId: "" }}
+			/>,
+		)
+
+		expect(screen.getByLabelText("Custom model ID")).toHaveValue("")
+
+		rerender(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={models}
+				onSelect={vi.fn()}
+				selectedModel={{ ...selectedModel, modelId: "my-fast-model" }}
+			/>,
+		)
+
+		expect(screen.getByLabelText("Custom model ID")).toHaveValue("my-fast-model")
+	})
+
+	it("clears the custom field when the hydrated selection is in the catalog", () => {
+		const { rerender } = render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={true}
+				isStale={false}
+				models={{}}
+				onSelect={vi.fn()}
+				selectedModel={{ ...selectedModel, modelId: "llama3" }}
+			/>,
+		)
+
+		// Lazy init captured "llama3" while the catalog was empty.
+		expect(screen.getByLabelText("Custom model ID")).toHaveValue("llama3")
+
+		rerender(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={models}
+				onSelect={vi.fn()}
+				selectedModel={{ ...selectedModel, modelId: "llama3" }}
+			/>,
+		)
+
+		fireEvent.change(screen.getByLabelText("Model"), { target: { value: "__custom__" } })
+		expect(screen.getByLabelText("Custom model ID")).toHaveValue("")
+	})
+
+	it("does not reset the custom field while the user is typing", () => {
+		const { rerender } = render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={{}}
+				onSelect={vi.fn()}
+				selectedModel={{ ...selectedModel, modelId: "my-fast-model" }}
+			/>,
+		)
+
+		fireEvent.change(screen.getByLabelText("Custom model ID"), { target: { value: "my-fast" } })
+
+		// A re-render with a fresh models object identity (catalog still
+		// loading) must not clobber the in-progress input.
+		rerender(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={true}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={{}}
+				onSelect={vi.fn()}
+				selectedModel={{ ...selectedModel, modelId: "my-fast-model" }}
+			/>,
+		)
+
+		expect(screen.getByLabelText("Custom model ID")).toHaveValue("my-fast")
+	})
+
+	it("does not auto-select while model props change during refresh", () => {
+		const onSelect = vi.fn()
+		const { rerender } = render(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={false}
+				error={undefined}
+				isLoading={true}
+				isStale={false}
+				models={{}}
+				onSelect={onSelect}
+				selectedModel={{ ...selectedModel, modelId: "llama3" }}
+			/>,
+		)
+
+		rerender(
+			<ModelPickerWithManualEntry
+				allowsCustomIds={false}
+				error={undefined}
+				isLoading={false}
+				isStale={false}
+				models={models}
+				onSelect={onSelect}
+				selectedModel={{ ...selectedModel, modelId: "llama3" }}
+			/>,
+		)
+
+		expect(onSelect).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/ModelPickerWithManualEntry.tsx b/apps/vscode/webview-ui/src/components/settings/providers/ModelPickerWithManualEntry.tsx
new file mode 100644
index 0000000..1940db9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/ModelPickerWithManualEntry.tsx
@@ -0,0 +1,145 @@
+import { type ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+import { VSCodeButton, VSCodeDropdown, VSCodeOption, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useEffect, useState } from "react"
+import type { ProviderId } from "@/context/ExtensionStateContext"
+import { DropdownContainer } from "../common/ModelSelector"
+
+export interface ModelPickerSelection {
+	providerId: ProviderId
+	modelId: string
+	modelInfo: ModelInfo
+}
+
+export interface ModelPickerWithManualEntryProps {
+	models: Record<string, ModelInfo>
+	isLoading: boolean
+	isStale: boolean
+	error?: string
+	allowsCustomIds: boolean
+	selectedModel: ModelPickerSelection
+	onSelect: (selection: ModelPickerSelection) => void
+}
+
+function customModelInfo(modelId: string): ModelInfo {
+	return {
+		...openAiModelInfoSafeDefaults,
+		name: modelId,
+	}
+}
+
+export function ModelPickerWithManualEntry({
+	models,
+	isLoading,
+	isStale,
+	error,
+	allowsCustomIds,
+	selectedModel,
+	onSelect,
+}: ModelPickerWithManualEntryProps) {
+	const [isManualEntryVisible, setIsManualEntryVisible] = useState(false)
+	const [customModelId, setCustomModelId] = useState(() => (selectedModel.modelId in models ? "" : selectedModel.modelId))
+	const modelIds = Object.keys(models).sort((a, b) => a.localeCompare(b))
+	const hasModels = modelIds.length > 0
+	const selectedModelInList = selectedModel.modelId in models
+
+	// The committed selection and the model catalog both hydrate asynchronously
+	// after mount, so the lazy useState init above can capture a placeholder
+	// value. Re-sync when the committed model changes or its in-list status
+	// flips. Depend on the derived values rather than `models` itself, whose
+	// identity can change every render while the catalog is loading.
+	useEffect(() => {
+		setCustomModelId(selectedModelInList ? "" : selectedModel.modelId)
+	}, [selectedModel.modelId, selectedModelInList])
+	const showManualEntry =
+		allowsCustomIds && (isManualEntryVisible || !hasModels || isLoading || Boolean(error) || !selectedModelInList)
+
+	// Force VSCodeDropdown to re-initialize after async catalog/selection
+	// hydration, otherwise it ignores the value prop for dynamically rendered
+	// options. https://github.com/microsoft/vscode-webview-ui-toolkit/issues/433
+	const dropdownKey = `${selectedModel.modelId}:${modelIds.join("\u0000")}`
+
+	const commitCustomModel = (modelId: string) => {
+		const trimmed = modelId.trim()
+		if (!trimmed) {
+			return
+		}
+		onSelect({
+			providerId: selectedModel.providerId,
+			modelId: trimmed,
+			modelInfo: models[trimmed] ?? customModelInfo(trimmed),
+		})
+		setIsManualEntryVisible(false)
+	}
+
+	return (
+		<div style={{ display: "flex", flexDirection: "column", gap: 8 }}>
+			<label htmlFor="provider-model-picker">
+				<span className="font-medium">Model</span>
+			</label>
+
+			{isStale && <div role="status">Model list may be stale for the current provider configuration.</div>}
+			{isLoading && <div role="status">Loading models…</div>}
+			{error && <div role="alert">{error}</div>}
+
+			{hasModels && (
+				<DropdownContainer className="dropdown-container">
+					<VSCodeDropdown
+						aria-label="Model"
+						className="w-full"
+						id="provider-model-picker"
+						key={dropdownKey}
+						onChange={(event) => {
+							const modelId = (event.target as HTMLSelectElement).value
+							if (modelId === "__custom__") {
+								setIsManualEntryVisible(true)
+								return
+							}
+							const modelInfo = models[modelId]
+							if (modelInfo) {
+								setIsManualEntryVisible(false)
+								onSelect({ providerId: selectedModel.providerId, modelId, modelInfo })
+							}
+						}}
+						value={selectedModelInList ? selectedModel.modelId : ""}>
+						{!selectedModelInList && allowsCustomIds && selectedModel.modelId && (
+							<VSCodeOption value="">{selectedModel.modelId} (not in current list)</VSCodeOption>
+						)}
+						{modelIds.map((modelId) => (
+							<VSCodeOption className="break-words whitespace-normal max-w-full" key={modelId} value={modelId}>
+								{modelId}
+							</VSCodeOption>
+						))}
+						{allowsCustomIds && <VSCodeOption value="__custom__">Use custom model ID…</VSCodeOption>}
+					</VSCodeDropdown>
+				</DropdownContainer>
+			)}
+
+			{!selectedModelInList && selectedModel.modelId && hasModels && (
+				<div role="status">Selected model “{selectedModel.modelId}” is not in the current list.</div>
+			)}
+
+			{showManualEntry && (
+				<div style={{ display: "flex", gap: 6, alignItems: "flex-end" }}>
+					<VSCodeTextField
+						id="custom-model-id"
+						onInput={(event) => {
+							setCustomModelId((event.target as HTMLInputElement).value)
+						}}
+						onKeyDown={(event) => {
+							if (event.key === "Enter") {
+								commitCustomModel(customModelId)
+							}
+						}}
+						placeholder="Enter custom model ID"
+						style={{ flexGrow: 1 }}
+						value={customModelId}>
+						<span className="font-medium">Custom model ID</span>
+					</VSCodeTextField>
+					<VSCodeButton appearance="secondary" onClick={() => commitCustomModel(customModelId)}>
+						Use custom model
+					</VSCodeButton>
+				</div>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/MoonshotProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/MoonshotProvider.tsx
new file mode 100644
index 0000000..61f3fc1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/MoonshotProvider.tsx
@@ -0,0 +1,121 @@
+import { UpdateApiConfigurationRequestNew } from "@shared/proto/index.cline"
+import { Mode } from "@shared/storage/types"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { DropdownContainer, ModelSelector } from "../common/ModelSelector"
+
+/**
+ * Props for the MoonshotProvider component
+ */
+interface MoonshotProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Moonshot AI Studio provider configuration component
+ */
+export const MoonshotProvider = ({ showModelOptions, isPopup, currentMode }: MoonshotProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+
+	// Get the normalized configuration
+	const { models, selectedModelId, selectedModelInfo, hideUsageCost } = useStaticProviderSelection(
+		"moonshot",
+		apiConfiguration,
+		currentMode,
+	)
+
+	return (
+		<div>
+			<DropdownContainer className="dropdown-container" style={{ position: "inherit" }}>
+				<label htmlFor="moonshot-entrypoint">
+					<span style={{ fontWeight: 500, marginTop: 5 }}>Moonshot Entrypoint</span>
+				</label>
+				<VSCodeDropdown
+					id="moonshot-entrypoint"
+					onChange={async (e) => {
+						const value = (e.target as any).value
+						await ModelsServiceClient.updateApiConfiguration(
+							UpdateApiConfigurationRequestNew.create({
+								updates: {
+									options: {
+										moonshotApiLine: value,
+									},
+								},
+								updateMask: ["options.moonshotApiLine"],
+							}),
+						)
+					}}
+					style={{
+						minWidth: 130,
+						position: "relative",
+					}}
+					value={apiConfiguration?.moonshotApiLine || "international"}>
+					<VSCodeOption value="international">api.moonshot.ai</VSCodeOption>
+					<VSCodeOption value="china">api.moonshot.cn</VSCodeOption>
+				</VSCodeDropdown>
+			</DropdownContainer>
+			<ApiKeyField
+				helpText="This key is stored locally and only used to make API requests from this extension."
+				initialValue={apiConfiguration?.moonshotApiKey || ""}
+				onChange={async (value) => {
+					await ModelsServiceClient.updateApiConfiguration(
+						UpdateApiConfigurationRequestNew.create({
+							updates: {
+								secrets: {
+									moonshotApiKey: value,
+								},
+							},
+							updateMask: ["secrets.moonshotApiKey"],
+						}),
+					)
+				}}
+				providerName="Moonshot"
+				signupUrl={
+					apiConfiguration?.moonshotApiLine === "china"
+						? "https://platform.moonshot.cn/console/api-keys"
+						: "https://platform.moonshot.ai/console/api-keys"
+				}
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={async (e: any) => {
+							const value = e.target.value
+
+							await ModelsServiceClient.updateApiConfiguration(
+								UpdateApiConfigurationRequestNew.create(
+									currentMode === "plan"
+										? {
+												updates: { options: { planModeApiModelId: value } },
+												updateMask: ["options.planModeApiModelId"],
+											}
+										: {
+												updates: { options: { actModeApiModelId: value } },
+												updateMask: ["options.actModeApiModelId"],
+											},
+								),
+							)
+						}}
+						selectedModelId={selectedModelId}
+					/>
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OcaModelPicker.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OcaModelPicker.tsx
new file mode 100644
index 0000000..b0e28fd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OcaModelPicker.tsx
@@ -0,0 +1,265 @@
+import type { ApiConfiguration, OcaModelInfo } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton, VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import React, { useMemo } from "react"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { VSC_BUTTON_BACKGROUND, VSC_BUTTON_FOREGROUND, VSC_DESCRIPTION_FOREGROUND, VSC_FOREGROUND } from "@/utils/vscStyles"
+import { ModelInfoView } from "../common/ModelInfoView"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+interface OcaModelPickerProps {
+	apiConfiguration: ApiConfiguration | undefined
+	isPopup?: boolean
+	currentMode: Mode
+	ocaModels: Record<string, OcaModelInfo>
+	onRefresh: () => void | Promise<void>
+	loading?: boolean
+	lastRefreshedAt?: number | null
+}
+
+const OcaModelPicker: React.FC<OcaModelPickerProps> = ({
+	apiConfiguration,
+	isPopup,
+	currentMode,
+	ocaModels,
+	onRefresh,
+	loading,
+	lastRefreshedAt,
+}: OcaModelPickerProps) => {
+	const { handleModeFieldsChange } = useApiConfigurationHandlers()
+	const [pendingModelId, setPendingModelId] = React.useState<string | null>(null)
+	const [showRestrictedPopup, setShowRestrictedPopup] = React.useState(false)
+
+	const handleModelChange = async (newModelId: string) => {
+		// could be setting invalid model id/undefined info but validation will catch it
+
+		if (ocaModels) {
+			const banner = ocaModels[newModelId]?.banner
+			if (banner) {
+				setPendingModelId(newModelId)
+				setShowRestrictedPopup(true)
+			} else {
+				await handleModeFieldsChange(
+					{
+						ocaModelId: { plan: "planModeOcaModelId", act: "actModeOcaModelId" },
+						ocaModelInfo: { plan: "planModeOcaModelInfo", act: "actModeOcaModelInfo" },
+						ocaReasoningEffort: { plan: "planModeOcaReasoningEffort", act: "actModeOcaReasoningEffort" },
+					},
+					{
+						ocaModelId: newModelId,
+						ocaModelInfo: ocaModels[newModelId],
+						ocaReasoningEffort:
+							ocaModels[newModelId].reasoningEffortOptions.length > 0
+								? ocaModels[newModelId].reasoningEffortOptions[0]
+								: undefined,
+					},
+					currentMode,
+				)
+			}
+		}
+	}
+
+	const handleReasoningEffortChange = async (newValue: string) => {
+		await handleModeFieldsChange(
+			{
+				ocaReasoningEffort: { plan: "planModeOcaReasoningEffort", act: "actModeOcaReasoningEffort" },
+			},
+			{
+				ocaReasoningEffort: newValue,
+			},
+			currentMode,
+		)
+	}
+
+	const onAcknowledge = async () => {
+		if (pendingModelId && ocaModels) {
+			await handleModeFieldsChange(
+				{
+					ocaModelId: { plan: "planModeOcaModelId", act: "actModeOcaModelId" },
+					ocaModelInfo: { plan: "planModeOcaModelInfo", act: "actModeOcaModelInfo" },
+					ocaReasoningEffort: { plan: "planModeOcaReasoningEffort", act: "actModeOcaReasoningEffort" },
+				},
+				{
+					ocaModelId: pendingModelId,
+					ocaModelInfo: ocaModels[pendingModelId],
+					ocaReasoningEffort:
+						ocaModels[pendingModelId].reasoningEffortOptions.length > 0
+							? ocaModels[pendingModelId].reasoningEffortOptions[0]
+							: undefined,
+				},
+				currentMode,
+			)
+			setPendingModelId(null)
+			setShowRestrictedPopup(false)
+		}
+	}
+
+	const handleRefreshToken = async () => {
+		await onRefresh?.()
+	}
+
+	const { selectedModelId, selectedModelInfo } = useDynamicProviderSelection("oca", apiConfiguration, currentMode)
+
+	const selectedReasoningEffort = useMemo(() => {
+		if (currentMode == "plan") {
+			return apiConfiguration?.planModeOcaReasoningEffort
+		}
+		return apiConfiguration?.actModeOcaReasoningEffort
+	}, [apiConfiguration, currentMode])
+
+	const reasoningEffortOptions = selectedModelInfo ? (selectedModelInfo as OcaModelInfo).reasoningEffortOptions : []
+
+	const modelIds = useMemo(() => {
+		return Object.keys(ocaModels || []).sort((a, b) => a.localeCompare(b))
+	}, [ocaModels])
+
+	const showBudgetSlider = useMemo(() => {
+		if (ocaModels && selectedModelId && ocaModels[selectedModelId]?.thinkingConfig) {
+			return true
+		}
+	}, [selectedModelId, ocaModels])
+
+	const lastRefreshedText = useMemo(() => {
+		return typeof lastRefreshedAt === "number" ? new Date(lastRefreshedAt).toLocaleTimeString() : null
+	}, [lastRefreshedAt])
+
+	return (
+		<div className="w-full">
+			{showRestrictedPopup && (
+				<OcaRestrictivePopup
+					bannerText={ocaModels && pendingModelId && ocaModels[pendingModelId]?.banner}
+					onAcknowledge={onAcknowledge}
+				/>
+			)}
+			<style>{`
+				#model-id::part(listbox){
+					max-height: 100px;
+					overflow: auto;
+				}
+				#reasoning-effort-dropdown::part(listbox){
+					max-height: 100px;
+					overflow: auto;
+				}
+			`}</style>
+			<label className="font-medium text-[12px] mt-[10px] mb-[2px]">Model</label>
+			<div className="relative z-100 flex items-center gap-2 mb-1">
+				<VSCodeDropdown
+					className="flex-1 text-[12px] min-h-[24px]"
+					id="model-id"
+					onChange={async (event: Event | React.FormEvent<HTMLElement>) => {
+						const target = event.target as HTMLSelectElement | null
+						const value = target?.value ?? ""
+						await handleModelChange(value)
+					}}
+					style={{ position: "relative", zIndex: 100 }}
+					value={selectedModelId || ""}>
+					{modelIds?.map((modelId) => (
+						<VSCodeOption
+							key={modelId}
+							style={{
+								padding: "4px 8px",
+								cursor: "pointer",
+								wordWrap: "break-word",
+								maxWidth: "100%",
+								fontSize: 12,
+							}}
+							value={modelId}>
+							{modelId}
+						</VSCodeOption>
+					))}
+				</VSCodeDropdown>
+				<VSCodeButton
+					disabled={!!loading}
+					onClick={handleRefreshToken}
+					style={{
+						fontSize: 14,
+						fontWeight: 500,
+						background: "var(--vscode-button-background, #0078d4)",
+						color: "var(--vscode-button-foreground, #fff)",
+						minWidth: 0,
+						margin: 0,
+					}}>
+					{loading ? "Refreshing…" : "Refresh"}
+				</VSCodeButton>
+			</div>
+			{lastRefreshedText ? (
+				<div className="text-[11px] text-(--vscode-descriptionForeground) mt-0 mb-2">
+					Last refreshed at {lastRefreshedText}
+				</div>
+			) : null}
+			{!loading && selectedModelInfo && selectedModelInfo.supportsReasoning && reasoningEffortOptions.length > 0 && (
+				<React.Fragment>
+					<label className="font-medium text-[12px] mt-[10px] mb-[2px]">Reasoning Effort</label>
+					<div className="flex items-center gap-2 mb-1">
+						<VSCodeDropdown
+							className="flex-1 text-[12px] min-h-[24px]"
+							currentValue={selectedReasoningEffort}
+							id="reasoning-effort-dropdown"
+							onChange={(e: any) => {
+								const newValue = e.target.currentValue
+								handleReasoningEffortChange(newValue)
+							}}>
+							{reasoningEffortOptions.map((reasoningEffort) => (
+								<VSCodeOption
+									key={reasoningEffort}
+									style={{
+										padding: "4px 8px",
+										cursor: "pointer",
+										wordWrap: "break-word",
+										maxWidth: "100%",
+										fontSize: 12,
+									}}
+									value={reasoningEffort}>
+									{reasoningEffort}
+								</VSCodeOption>
+							))}
+						</VSCodeDropdown>
+					</div>
+				</React.Fragment>
+			)}
+			{selectedModelInfo && (
+				<>
+					{showBudgetSlider && <ThinkingBudgetSlider currentMode={currentMode} />}
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			)}
+		</div>
+	)
+}
+
+export default OcaModelPicker
+
+const OcaRestrictivePopup: React.FC<{
+	onAcknowledge: () => void
+	bannerText?: string | null
+}> = React.memo(({ onAcknowledge, bannerText }) => (
+	<div className="fixed top-0 left-0 w-screen h-screen z-2000 [background:rgba(0,0,0,0.25)] flex items-center justify-center">
+		<div
+			aria-labelledby="oca-popup-title"
+			aria-modal="true"
+			className={`p-6 max-w-[600px] w-[90%] rounded-[8px] [box-shadow:0_4px_24px_0_var(--vscode-widget-shadow,rgba(0,0,0,.4))] [border:1px_solid_var(--vscode-focusBorder,#007acc)] [background:var(--vscode-editor-background,#252526)] [color:var(${VSC_FOREGROUND},#cccccc)] [font-family:var(--vscode-font-family,sans-serif)] [font-size:var(--vscode-font-size,13px)] flex flex-col max-h-[80vh]`}
+			role="dialog">
+			<h2 className={`mt-0 [color:var(${VSC_FOREGROUND},#111)] font-bold`} id="oca-popup-title">
+				Acknowledgement Required
+			</h2>
+			<h4 className={`mb-2 [color:var(${VSC_DESCRIPTION_FOREGROUND},#b3b3b3)] font-semibold`}>
+				Disclaimer: Prohibited Data Submission
+			</h4>
+			<div className="overflow-y-auto flex-1 pr-2 mb-4 text-[13px] leading-normal text-(--vscode-foreground,#222) mask-[linear-gradient(to_bottom,black_96%,transparent_100%)]">
+				{bannerText && <div dangerouslySetInnerHTML={{ __html: bannerText }} />}
+			</div>
+			<div className="text-right">
+				<VSCodeButton
+					onClick={onAcknowledge}
+					style={{
+						background: `var(${VSC_BUTTON_BACKGROUND}, #0e639c)`,
+						color: `var(${VSC_BUTTON_FOREGROUND}, #fff)`,
+					}}
+					type="button">
+					I acknowledge and agree
+				</VSCodeButton>
+			</div>
+		</div>
+	</div>
+))
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OcaProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OcaProvider.tsx
new file mode 100644
index 0000000..86e973e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OcaProvider.tsx
@@ -0,0 +1,464 @@
+import type { OcaModelInfo } from "@shared/api"
+import type { OcaAuthState, OcaUserInfo } from "@shared/proto/index.cline"
+import { EmptyRequest, StringRequest } from "@shared/proto/index.cline"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton, VSCodeCheckbox, VSCodeLink, VSCodeProgressRing } from "@vscode/webview-ui-toolkit/react"
+import React, { useCallback, useEffect, useRef, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient, OcaAccountServiceClient } from "@/services/grpc-client"
+import { VSC_BUTTON_BACKGROUND, VSC_BUTTON_FOREGROUND, VSC_DESCRIPTION_FOREGROUND } from "@/utils/vscStyles"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import OcaModelPicker from "./OcaModelPicker"
+
+/**
+ * Props for the OcaProvider component
+ */
+interface OcaProviderProps {
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+function InfoCard({ icon, children }: { icon: React.ReactNode; children: React.ReactNode }) {
+	return (
+		<div
+			className="mt-2 mb-2 flex items-start gap-3 rounded-none px-5 py-4 pb-8 border shadow-sm min-w-[40%] max-w-[90%] w-full box-border
+                 bg-input-background border-input-border">
+			<div className="min-w-[22px] h-[22px] flex items-center justify-center shrink-0 mt-2">{icon}</div>
+			<div className="flex-1">{children}</div>
+		</div>
+	)
+}
+
+/**
+ * Auth hook:
+ * - Subscribes to auth state (single source of truth).
+ * - Marks when initial auth state arrives.
+ * - Attempts one-shot auto-login ONLY if initial state was "unknown" (i.e., not explicitly null unauthenticated).
+ * - Cleans up subscription properly.
+ */
+function useOcaAuth() {
+	const [user, setUser] = useState<OcaUserInfo | null>(null)
+	const [ready, setReady] = useState(false)
+
+	const initialReceivedRef = useRef(false)
+	const unmountedRef = useRef(false)
+
+	const isAuthenticated = !!user?.uid
+
+	const login = useCallback(async () => {
+		try {
+			await OcaAccountServiceClient.ocaAccountLoginClicked(EmptyRequest.create())
+		} catch (error) {
+			console.error("OCA login failed:", error)
+		}
+	}, [])
+
+	const logout = useCallback(async () => {
+		try {
+			await OcaAccountServiceClient.ocaAccountLogoutClicked(EmptyRequest.create())
+		} catch (error) {
+			console.error("OCA logout failed:", error)
+		}
+	}, [])
+
+	useEffect(() => {
+		unmountedRef.current = false
+		const cancel = OcaAccountServiceClient.ocaSubscribeToAuthStatusUpdate(EmptyRequest.create(), {
+			onResponse: (response: OcaAuthState) => {
+				if (unmountedRef.current) {
+					return
+				}
+				const nextUser = response?.user?.uid ? (response.user as OcaUserInfo) : null
+				setUser(nextUser)
+
+				if (!initialReceivedRef.current) {
+					initialReceivedRef.current = true
+					setReady(true)
+				}
+			},
+			onError: (err: Error) => {
+				if (!unmountedRef.current) {
+					console.error("OCA auth callback subscription error:", err)
+					if (!initialReceivedRef.current) {
+						initialReceivedRef.current = true
+						setReady(true)
+					}
+				}
+			},
+			onComplete: () => {
+				// no-op
+			},
+		})
+
+		return () => {
+			unmountedRef.current = true
+			cancel()
+		}
+	}, [])
+
+	return { user, isAuthenticated, ready, login, logout }
+}
+
+/**
+ * Models hook:
+ * - Fetches OCA models only when authenticated.
+ * - Debounces base URL changes to avoid unnecessary calls.
+ * - Guards against race conditions with a requestId and unmount checks.
+ */
+function useOcaModels({
+	isAuthenticated,
+	baseUrl,
+	login,
+}: {
+	isAuthenticated: boolean
+	baseUrl: string
+	login: () => Promise<void>
+}) {
+	const [models, setModels] = useState<Record<string, OcaModelInfo>>({})
+	const [loading, setLoading] = useState(false)
+	const [hasError, setHasError] = useState(false)
+	const [lastRefreshedAt, setLastRefreshedAt] = useState<number | null>(null)
+
+	const reqIdRef = useRef(0)
+	const unmountedRef = useRef(false)
+	const debounceTimerRef = useRef<number | null>(null)
+
+	const doRefresh = useCallback(async (url: string) => {
+		const myReqId = ++reqIdRef.current
+		setLoading(true)
+		setHasError(false)
+		try {
+			const resp = await ModelsServiceClient.refreshOcaModels(StringRequest.create({ value: url || "" }))
+			// Only apply if still latest and still mounted
+			if (!unmountedRef.current && myReqId === reqIdRef.current) {
+				if (resp.error) {
+					setHasError(true)
+				} else {
+					setModels(resp.models || {})
+					setHasError(false)
+					setLastRefreshedAt(Date.now())
+				}
+			}
+		} catch (err) {
+			if (!unmountedRef.current && myReqId === reqIdRef.current) {
+				console.error("Failed to refresh Oca models:", err)
+				setHasError(true)
+			}
+		} finally {
+			if (!unmountedRef.current && myReqId === reqIdRef.current) {
+				setLoading(false)
+			}
+		}
+	}, [])
+
+	// Debounce changes to baseUrl or auth
+	useEffect(() => {
+		unmountedRef.current = false
+		if (debounceTimerRef.current) {
+			window.clearTimeout(debounceTimerRef.current)
+			debounceTimerRef.current = null
+		}
+
+		if (!isAuthenticated) {
+			// Clear models if logged out; prevent stale data
+			setModels({})
+			setLoading(false)
+			setHasError(false)
+			return
+		}
+
+		debounceTimerRef.current = window.setTimeout(() => {
+			void doRefresh(baseUrl || "")
+		}, 250)
+
+		return () => {
+			unmountedRef.current = true
+			if (debounceTimerRef.current) {
+				window.clearTimeout(debounceTimerRef.current)
+				debounceTimerRef.current = null
+			}
+			// bump reqId so any in-flight result is ignored
+			reqIdRef.current++
+		}
+	}, [isAuthenticated, baseUrl, doRefresh])
+
+	// User-initiated refresh with auto login + single retry on failure
+	const refreshModels = useCallback(async () => {
+		setLoading(true)
+		setHasError(false)
+
+		async function tryRefresh(retry = false): Promise<boolean> {
+			try {
+				const resp = await ModelsServiceClient.refreshOcaModels(StringRequest.create({ value: baseUrl || "" }))
+				if (resp.error) {
+					throw new Error(resp.error)
+				}
+				setModels(resp.models || {})
+				setHasError(false)
+				setLastRefreshedAt(Date.now())
+				return true
+			} catch (_err) {
+				if (!retry) {
+					await login() // prompt login
+					return tryRefresh(true) // retry once
+				}
+				setHasError(true)
+				return false
+			} finally {
+				setLoading(false)
+			}
+		}
+
+		await tryRefresh()
+	}, [baseUrl, login])
+
+	return { models, loading, hasError, refreshModels, lastRefreshedAt }
+}
+
+/**
+ * The Oca provider configuration component
+ */
+export const OcaProvider = ({ isPopup, currentMode }: OcaProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	const { user: ocaUser, isAuthenticated, ready, login, logout } = useOcaAuth()
+
+	const ocaBaseUrl = apiConfiguration?.ocaBaseUrl || ""
+	const ocaMode = apiConfiguration?.ocaMode
+
+	const handleToggleMode = (nextMode: "internal" | "external") => {
+		handleFieldChange("ocaMode", nextMode)
+	}
+
+	const {
+		models: ocaModels,
+		refreshModels,
+		hasError: ocaHasError,
+		loading: ocaLoading,
+		lastRefreshedAt,
+	} = useOcaModels({
+		isAuthenticated,
+		baseUrl: ocaBaseUrl,
+		login,
+	})
+
+	const handleRefresh = useCallback(async () => {
+		await refreshModels()
+	}, [refreshModels])
+
+	return (
+		<div>
+			{!ready ? (
+				<div aria-live="polite" className="flex items-center gap-2 py-2" role="status">
+					<VSCodeProgressRing />
+					<span className={`text-[13px] [color:var(${VSC_DESCRIPTION_FOREGROUND})]`}>Connecting…</span>
+				</div>
+			) : !isAuthenticated ? (
+				<div>
+					<div
+						aria-label="Oracle employment"
+						style={{
+							marginTop: 12,
+							marginBottom: 4,
+						}}>
+						<VSCodeCheckbox
+							checked={ocaMode !== "external"}
+							onChange={(e: any) => {
+								const checked = (e?.target as HTMLInputElement)?.checked
+								handleToggleMode(checked ? "internal" : "external")
+							}}>
+							I’m an Oracle Employee
+						</VSCodeCheckbox>
+					</div>
+					<VSCodeButton
+						onClick={async () => {
+							await login()
+						}}
+						style={{
+							fontSize: 14,
+							fontWeight: 500,
+							background: `var(${VSC_BUTTON_BACKGROUND}, #0078d4)`,
+							color: `var(${VSC_BUTTON_FOREGROUND}, #fff)`,
+							minWidth: 0,
+							margin: "12px 0",
+						}}>
+						Sign in with Oracle Code Assist
+					</VSCodeButton>
+					<p className="text-xs mt-0 text-(--vscode-descriptionForeground)">
+						Please ask your IT administrator to set up Oracle Code Assist as a model provider. Oracle Employees,
+						please see the{" "}
+						<VSCodeLink
+							href="https://confluence.oraclecorp.com/confluence/display/AICODE/Oracle+Code+Assist+via+Cline"
+							rel="noopener noreferrer"
+							target="_blank">
+							quickstart guide
+						</VSCodeLink>
+					</p>
+				</div>
+			) : (
+				<div>
+					<div className={`flex items-center justify-between mt-0 mb-0 [color:var(${VSC_DESCRIPTION_FOREGROUND})]`}>
+						<div className="flex flex-col gap-0 font-semibold text-[13px]">
+							<span>Signed in</span>
+							{ocaUser?.email ? (
+								<span className="font-semibold opacity-95 mt-2">{ocaUser.email}</span>
+							) : ocaUser?.uid ? (
+								<span className="font-semibold opacity-95 mt-2">{ocaUser.uid}</span>
+							) : (
+								<span className="font-semibold opacity-95 mt-2">Unknown User</span>
+							)}
+						</div>
+						<VSCodeButton
+							onClick={async () => {
+								await logout()
+							}}>
+							Log out
+						</VSCodeButton>
+					</div>
+
+					<div className="mt-0">
+						<BaseUrlField
+							defaultValue={undefined}
+							initialValue={ocaBaseUrl}
+							label="Custom Base URL (optional)"
+							onChange={(value) => handleFieldChange("ocaBaseUrl", value)}
+						/>
+					</div>
+
+					<OcaModelPicker
+						apiConfiguration={apiConfiguration}
+						currentMode={currentMode}
+						isPopup={isPopup}
+						lastRefreshedAt={lastRefreshedAt}
+						loading={ocaLoading}
+						ocaModels={ocaModels}
+						onRefresh={handleRefresh}
+					/>
+
+					{isAuthenticated && ocaHasError && (
+						<div
+							aria-live="polite"
+							className={`mt-2 text-[13px] [color:var(${VSC_DESCRIPTION_FOREGROUND})]`}
+							role="status">
+							<div>Failed to refresh models. Check your session or network.</div>
+							<div className="mt-2 flex gap-2">
+								<VSCodeButton appearance="secondary" onClick={handleRefresh}>
+									Retry
+								</VSCodeButton>
+								<VSCodeButton
+									appearance="secondary"
+									onClick={async () => {
+										await login()
+									}}>
+									Sign in again
+								</VSCodeButton>
+							</div>
+						</div>
+					)}
+
+					<InfoCard
+						icon={
+							<svg
+								aria-hidden
+								fill="none"
+								height="20"
+								role="img"
+								style={{ color: `var(${VSC_DESCRIPTION_FOREGROUND})` }}
+								viewBox="0 0 36 35"
+								width="20">
+								<g clipPath="url(#clip0)">
+									<path
+										d="M20 13.5991C20 14.672 19.1046 15.5418 18 15.5418C16.8954 15.5418 16 14.672 16 13.5991C16 12.5261 16.8954 11.6563 18 11.6563C19.1046 11.6563 20 12.5261 20 13.5991Z"
+										fill="none"
+										stroke="currentColor"
+										strokeWidth="1.25"
+									/>
+									<path
+										d="M10 15.5418C11.1046 15.5418 12 14.672 12 13.5991C12 12.5261 11.1046 11.6563 10 11.6563C8.89543 11.6563 8 12.5261 8 13.5991C8 14.672 8.89543 15.5418 10 15.5418Z"
+										fill="none"
+										stroke="currentColor"
+										strokeWidth="1.25"
+									/>
+									<path
+										d="M28 13.5991C28 14.672 27.1046 15.5418 26 15.5418C24.8954 15.5418 24 14.672 24 13.5991C24 12.5261 24.8954 11.6563 26 11.6563C27.1046 11.6563 28 12.5261 28 13.5991Z"
+										fill="none"
+										stroke="currentColor"
+										strokeWidth="1.25"
+									/>
+									<path
+										clipRule="evenodd"
+										d="M0 0V25.2554H10V34.4L19.4142 25.2554H36V0H0ZM2 23.3127V1.94272H34V23.3127H18.5858L12 29.7099V23.3127H2Z"
+										fill="none"
+										fillRule="evenodd"
+										stroke="currentColor"
+										strokeWidth="1.25"
+									/>
+								</g>
+								<defs>
+									<clipPath id="clip0">
+										<rect fill="white" height="35" width="36" />
+									</clipPath>
+								</defs>
+							</svg>
+						}>
+						<div
+							style={{
+								display: "flex",
+								flexDirection: "column",
+								alignItems: "center", // center title and button
+								width: "100%",
+							}}>
+							<div
+								style={{
+									fontSize: 14,
+									color: VSC_DESCRIPTION_FOREGROUND,
+									fontWeight: 600,
+									marginBottom: 18,
+									marginTop: 2,
+								}}>
+								Have an idea for Oracle Code Assist?
+							</div>
+						</div>
+						<div
+							style={{
+								width: "100%",
+								display: "flex",
+								justifyContent: "center",
+								marginTop: 8,
+							}}>
+							<a
+								href={
+									ocaMode === "internal"
+										? "https://apexsurveys.oracle.com/ords/surveys/t/oca-nps/survey?k=oracle-code-assist-internal-link-share&sc=SMM1BNSNUI"
+										: "https://customersurveys.oracle.com/ords/surveys/t/aicode/survey?k=oracle-code-assist&sc=SUDN1ZXYQ5"
+								}
+								rel="noopener noreferrer"
+								style={{
+									fontSize: 14,
+									fontWeight: 500,
+									textDecoration: "none",
+									background: "var(--vscode-button-background)",
+									color: "var(--vscode-button-foreground)",
+									padding: "8px 14px",
+									minHeight: 28,
+									border: "1px solid var(--vscode-button-border, transparent)",
+									borderRadius: 0,
+									display: "inline-flex",
+									alignItems: "center",
+									justifyContent: "center",
+									minWidth: 0,
+									boxSizing: "border-box",
+									cursor: "pointer",
+								}}
+								target="_blank">
+								Provide feedback
+							</a>
+						</div>
+					</InfoCard>
+				</div>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OllamaProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OllamaProvider.tsx
new file mode 100644
index 0000000..d8a4ba0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OllamaProvider.tsx
@@ -0,0 +1,204 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { StringRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { useCallback, useEffect, useMemo, useState } from "react"
+import { useInterval } from "react-use"
+import UseCustomPromptCheckbox from "@/components/settings/UseCustomPromptCheckbox"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import OllamaModelPicker from "../OllamaModelPicker"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+/**
+ * Props for the OllamaProvider component
+ */
+interface OllamaProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Ollama provider configuration component
+ */
+export const OllamaProvider = ({ showModelOptions, isPopup, currentMode }: OllamaProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+	const { config, write, commitSelection } = useProviderConfig("ollama")
+
+	const [ollamaModels, setOllamaModels] = useState<string[]>([])
+
+	const ollamaBaseUrl = config?.baseUrl ?? apiConfiguration?.ollamaBaseUrl
+	const ollamaModelInfo = useMemo(() => {
+		const contextWindow = Number.parseInt(apiConfiguration?.ollamaApiOptionsCtxNum || "", 10)
+		return {
+			...openAiModelInfoSafeDefaults,
+			...(Number.isFinite(contextWindow) && contextWindow > 0 ? { contextWindow } : {}),
+		}
+	}, [apiConfiguration?.ollamaApiOptionsCtxNum])
+	const ollamaModelInfoById = useMemo(
+		() => Object.fromEntries(ollamaModels.map((modelId) => [modelId, { ...ollamaModelInfo, name: modelId }])),
+		[ollamaModelInfo, ollamaModels],
+	)
+	const { selectedModel, commitModelSelection } = useProviderModelSelection("ollama", currentMode, {
+		models: ollamaModelInfoById,
+		config,
+		commitSelection,
+		fallbackModelInfo: ollamaModelInfo,
+		customModelInfo: (modelId) => ({ ...ollamaModelInfo, name: modelId }),
+	})
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		providerName: "Ollama",
+		write,
+	})
+
+	const handleBaseUrlChange = useCallback(
+		(value: string) => {
+			void write({ baseUrl: value }).catch((error) => console.error("Failed to update Ollama base URL:", error))
+		},
+		[write],
+	)
+
+	// Poll ollama models
+	const requestOllamaModels = useCallback(async () => {
+		try {
+			const response = await ModelsServiceClient.getOllamaModels(
+				StringRequest.create({
+					value: ollamaBaseUrl || "",
+				}),
+			)
+			if (response && response.values) {
+				setOllamaModels(response.values)
+			}
+		} catch (error) {
+			console.error("Failed to fetch Ollama models:", error)
+			setOllamaModels([])
+		}
+	}, [ollamaBaseUrl])
+
+	useEffect(() => {
+		requestOllamaModels()
+	}, [requestOllamaModels])
+
+	useInterval(requestOllamaModels, 2000)
+
+	return (
+		<div className="flex flex-col gap-2">
+			<BaseUrlField
+				initialValue={ollamaBaseUrl}
+				label="Use custom base URL"
+				onChange={handleBaseUrlChange}
+				placeholder="Default: http://localhost:11434"
+			/>
+
+			{ollamaBaseUrl && (
+				<ApiKeyField
+					helpText="Optional API key for authenticated Ollama instances or cloud services. Leave empty for local installations."
+					initialValue={savedApiKeyMask}
+					onChange={handleApiKeyChange}
+					placeholder="Enter API Key (optional)..."
+					providerName="Ollama"
+				/>
+			)}
+
+			{/* Model selection - use filterable picker */}
+			<label htmlFor="ollama-model-selection">
+				<span className="font-semibold">Model</span>
+			</label>
+			<OllamaModelPicker
+				ollamaModels={ollamaModels}
+				onModelChange={(modelId) => {
+					const trimmedModelId = modelId.trim()
+					if (!trimmedModelId) {
+						return
+					}
+					void commitModelSelection({
+						modelId: trimmedModelId,
+						modelInfo: { ...ollamaModelInfo, name: trimmedModelId },
+					}).catch((error) => console.error("Failed to update Ollama model selection:", error))
+				}}
+				placeholder={ollamaModels.length > 0 ? "Search and select a model..." : "e.g. llama3.1"}
+				selectedModelId={selectedModel.modelId || ""}
+			/>
+
+			{/* Show status message based on model availability */}
+			{ollamaModels.length === 0 && (
+				<p className="text-sm mt-1 text-description italic">
+					Unable to fetch models from Ollama server. Please ensure Ollama is running and accessible, or enter the model
+					ID manually above.
+				</p>
+			)}
+
+			<DebouncedTextField
+				initialValue={apiConfiguration?.ollamaApiOptionsCtxNum || "32768"}
+				onChange={(v) => {
+					handleFieldChange("ollamaApiOptionsCtxNum", v || undefined)
+
+					const contextWindow = Number.parseInt(v, 10)
+					if (selectedModel.modelId) {
+						void commitModelSelection({
+							modelId: selectedModel.modelId,
+							modelInfo: {
+								...openAiModelInfoSafeDefaults,
+								name: selectedModel.modelId,
+								...(Number.isFinite(contextWindow) && contextWindow > 0 ? { contextWindow } : {}),
+							},
+						}).catch((error) => console.error("Failed to update Ollama context window:", error))
+					}
+				}}
+				placeholder={"e.g. 32768"}
+				style={{ width: "100%" }}>
+				<span className="font-semibold">Model Context Window</span>
+			</DebouncedTextField>
+
+			{showModelOptions && (
+				<>
+					<DebouncedTextField
+						initialValue={apiConfiguration?.requestTimeoutMs ? apiConfiguration.requestTimeoutMs.toString() : "30000"}
+						onChange={(value) => {
+							// Convert to number, with validation
+							const numValue = Number.parseInt(value, 10)
+							if (!Number.isNaN(numValue) && numValue > 0) {
+								handleFieldChange("requestTimeoutMs", numValue)
+							}
+						}}
+						placeholder="Default: 30000 (30 seconds)"
+						style={{ width: "100%" }}>
+						<span className="font-semibold">Request Timeout (ms)</span>
+					</DebouncedTextField>
+					<p className="text-xs mt-0 text-description">
+						Maximum time in milliseconds to wait for API responses before timing out.
+					</p>
+				</>
+			)}
+
+			<UseCustomPromptCheckbox providerId="ollama" />
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: "5px",
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				Ollama allows you to run models locally on your computer. For instructions on how to get started, see their{" "}
+				<VSCodeLink
+					href="https://github.com/ollama/ollama/blob/main/README.md"
+					style={{ display: "inline", fontSize: "inherit" }}>
+					quickstart guide.
+				</VSCodeLink>{" "}
+				<span style={{ color: "var(--vscode-errorForeground)" }}>
+					(<span style={{ fontWeight: 500 }}>Note:</span> Cline uses complex prompts, so behavior can vary across
+					models. Less capable models may not work as expected.)
+				</span>
+			</p>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OpenAICompatible.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OpenAICompatible.tsx
new file mode 100644
index 0000000..f543fd6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OpenAICompatible.tsx
@@ -0,0 +1,605 @@
+import { TooltipContent, TooltipTrigger } from "@radix-ui/react-tooltip"
+import {
+	azureOpenAiDefaultApiVersion,
+	type ModelInfo,
+	type OpenAiCompatibleModelInfo,
+	openAiModelInfoSafeDefaults,
+} from "@shared/api"
+import { OpenAiModelsRequest } from "@shared/proto/cline/models"
+import { fromProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import type { Mode } from "@shared/storage/types"
+import { VSCodeButton, VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { useCallback, useEffect, useRef, useState } from "react"
+import { Tooltip } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useDynamicProviderSelection } from "@/hooks/useDynamicProviderSelection"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { getAsVar, VSC_DESCRIPTION_FOREGROUND } from "@/utils/vscStyles"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import { parsePrice } from "../utils/pricingUtils"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+/**
+ * Props for the OpenAICompatibleProvider component
+ */
+interface OpenAICompatibleProviderProps {
+	providerId: string
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The OpenAI Compatible provider configuration component
+ */
+export const OpenAICompatibleProvider = ({
+	providerId,
+	showModelOptions,
+	isPopup,
+	currentMode,
+}: OpenAICompatibleProviderProps) => {
+	const { apiConfiguration, remoteConfigSettings } = useExtensionState()
+	const { handleFieldChange, handleModeFieldChange } = useApiConfigurationHandlers()
+	const { config, write, commitSelection } = useProviderConfig(providerId)
+
+	const [modelConfigurationSelected, setModelConfigurationSelected] = useState(false)
+	const [isCustomOpenAiModelEntryVisible, setIsCustomOpenAiModelEntryVisible] = useState(false)
+	const [availableOpenAiModels, setAvailableOpenAiModels] = useState<string[]>([])
+	const [isRefreshingOpenAiModels, setIsRefreshingOpenAiModels] = useState(false)
+	const [openAiModelsError, setOpenAiModelsError] = useState<string | undefined>(undefined)
+	// Only the built-in "openai" provider stores its API key in the legacy
+	// ApiConfiguration field; custom providers keep it in their per-provider
+	// config (available only as a masked length), so there is no plaintext key
+	// to seed the model-refresh request with.
+	const legacyOpenAiApiKey = providerId === "openai" ? apiConfiguration?.openAiApiKey || "" : ""
+	const latestOpenAiBaseUrlRef = useRef(config?.baseUrl || "")
+	const latestOpenAiApiKeyRef = useRef(legacyOpenAiApiKey)
+	const openAiModelsRequestRef = useRef(0)
+
+	useEffect(() => {
+		latestOpenAiBaseUrlRef.current = config?.baseUrl || ""
+	}, [config?.baseUrl])
+
+	useEffect(() => {
+		latestOpenAiApiKeyRef.current = legacyOpenAiApiKey
+	}, [legacyOpenAiApiKey])
+
+	const handleProviderConfigWriteError = useCallback((fieldName: string, error: unknown) => {
+		console.error(`Failed to update OpenAI Compatible ${fieldName}:`, error)
+	}, [])
+
+	// Built-in "openai" persists model selection to its legacy ApiConfiguration
+	// fields; custom/unknown providers persist via their per-provider committed
+	// selection. Prefer the committed selection and fall back to the legacy
+	// fields so the built-in provider keeps working unchanged.
+	const isOpenAiProvider = providerId === "openai" || providerId === "openai-compatible"
+	const { selectedModelId: legacySelectedModelId, selectedModelInfo: legacySelectedModelInfo } = useDynamicProviderSelection(
+		providerId,
+		apiConfiguration,
+		currentMode,
+	)
+	const committedSelection = currentMode === "plan" ? config?.planSelection : config?.actSelection
+	const selectedModelId = committedSelection?.modelId ?? legacySelectedModelId
+	const selectedModelInfo = committedSelection?.modelInfo
+		? fromProtobufModelInfo(committedSelection.modelInfo)
+		: legacySelectedModelInfo
+	// The Model Configuration section reads/writes the resolved model info.
+	// OpenAiCompatibleModelInfo only adds optional fields over ModelInfo, so a
+	// resolved ModelInfo satisfies it structurally.
+	const openAiModelInfo: OpenAiCompatibleModelInfo = selectedModelInfo
+
+	const commitOpenAiSelection = useCallback(
+		(modelId: string, modelInfo = openAiModelInfo ?? openAiModelInfoSafeDefaults) => {
+			if (!modelId.trim()) {
+				return
+			}
+
+			void commitSelection(currentMode, {
+				providerId,
+				modelId,
+				modelInfo: {
+					...modelInfo,
+					supportsPromptCache: modelInfo.supportsPromptCache ?? openAiModelInfoSafeDefaults.supportsPromptCache,
+				},
+			}).catch((error) => handleProviderConfigWriteError("model selection", error))
+		},
+		[commitSelection, currentMode, handleProviderConfigWriteError, openAiModelInfo],
+	)
+
+	const handleOpenAiModelInfoChange = useCallback(
+		(modelInfo: typeof openAiModelInfoSafeDefaults) => {
+			if (isOpenAiProvider) {
+				handleModeFieldChange({ plan: "planModeOpenAiModelInfo", act: "actModeOpenAiModelInfo" }, modelInfo, currentMode)
+			}
+			commitOpenAiSelection(selectedModelId || "", modelInfo)
+		},
+		[commitOpenAiSelection, currentMode, handleModeFieldChange, isOpenAiProvider, selectedModelId],
+	)
+
+	// Debounced function to refresh OpenAI models (prevents excessive API calls while typing)
+	const debounceTimerRef = useRef<NodeJS.Timeout | null>(null)
+
+	useEffect(() => {
+		return () => {
+			if (debounceTimerRef.current) {
+				clearTimeout(debounceTimerRef.current)
+			}
+		}
+	}, [])
+
+	const refreshOpenAiModels = useCallback(async (baseUrl?: string, apiKey?: string) => {
+		const trimmedBaseUrl = baseUrl?.trim()
+		const requestId = openAiModelsRequestRef.current + 1
+		openAiModelsRequestRef.current = requestId
+
+		if (!trimmedBaseUrl) {
+			setAvailableOpenAiModels([])
+			setOpenAiModelsError(undefined)
+			setIsRefreshingOpenAiModels(false)
+			return
+		}
+
+		setIsRefreshingOpenAiModels(true)
+		setOpenAiModelsError(undefined)
+
+		try {
+			const response = await ModelsServiceClient.refreshOpenAiModels(
+				OpenAiModelsRequest.create({
+					baseUrl: trimmedBaseUrl,
+					apiKey,
+				}),
+			)
+
+			if (openAiModelsRequestRef.current === requestId) {
+				setAvailableOpenAiModels(response.values)
+			}
+		} catch (error) {
+			console.error("Failed to refresh OpenAI models:", error)
+			if (openAiModelsRequestRef.current === requestId) {
+				setAvailableOpenAiModels([])
+				setOpenAiModelsError(error instanceof Error ? error.message : String(error))
+			}
+		} finally {
+			if (openAiModelsRequestRef.current === requestId) {
+				setIsRefreshingOpenAiModels(false)
+			}
+		}
+	}, [])
+
+	const debouncedRefreshOpenAiModels = useCallback(
+		(baseUrl?: string, apiKey?: string) => {
+			if (debounceTimerRef.current) {
+				clearTimeout(debounceTimerRef.current)
+			}
+
+			debounceTimerRef.current = setTimeout(() => {
+				void refreshOpenAiModels(baseUrl, apiKey)
+			}, 500)
+		},
+		[refreshOpenAiModels],
+	)
+
+	useEffect(() => {
+		void refreshOpenAiModels(config?.baseUrl, latestOpenAiApiKeyRef.current)
+	}, [config?.baseUrl, refreshOpenAiModels])
+
+	const toOpenAiModelInfo = useCallback(
+		(modelId: string): ModelInfo => ({
+			...openAiModelInfoSafeDefaults,
+			name: modelId,
+		}),
+		[],
+	)
+
+	const handleOpenAiModelSelection = useCallback(
+		(modelId: string, modelInfo = toOpenAiModelInfo(modelId)) => {
+			if (isOpenAiProvider) {
+				handleModeFieldChange({ plan: "planModeOpenAiModelId", act: "actModeOpenAiModelId" }, modelId, currentMode)
+			}
+			commitOpenAiSelection(modelId, modelInfo)
+		},
+		[commitOpenAiSelection, currentMode, handleModeFieldChange, isOpenAiProvider, toOpenAiModelInfo],
+	)
+
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		canWrite: config !== undefined,
+		onApiKeyChange: (apiKey) => {
+			latestOpenAiApiKeyRef.current = apiKey
+			debouncedRefreshOpenAiModels(latestOpenAiBaseUrlRef.current, apiKey)
+		},
+		providerName: "OpenAI Compatible",
+		write,
+	})
+
+	return (
+		<div>
+			<Tooltip>
+				<TooltipTrigger>
+					<div className="mb-2.5">
+						<div className="flex items-center gap-2 mb-1">
+							<span style={{ fontWeight: 500 }}>Base URL</span>
+							{remoteConfigSettings?.openAiBaseUrl !== undefined && (
+								<i className="codicon codicon-lock text-description text-sm" />
+							)}
+						</div>
+						<DebouncedTextField
+							disabled={remoteConfigSettings?.openAiBaseUrl !== undefined}
+							initialValue={config?.baseUrl || ""}
+							onChange={(value) => {
+								if (!config) {
+									return
+								}
+
+								latestOpenAiBaseUrlRef.current = value
+								void write({ baseUrl: value }).catch((error) => handleProviderConfigWriteError("base URL", error))
+								debouncedRefreshOpenAiModels(value, latestOpenAiApiKeyRef.current)
+							}}
+							placeholder={"Enter base URL..."}
+							style={{ width: "100%", marginBottom: 10 }}
+							type="text"
+						/>
+					</div>
+				</TooltipTrigger>
+				<TooltipContent hidden={remoteConfigSettings?.openAiBaseUrl === undefined}>
+					This setting is managed by your organization's remote configuration
+				</TooltipContent>
+			</Tooltip>
+
+			<ApiKeyField initialValue={savedApiKeyMask} onChange={handleApiKeyChange} providerName="OpenAI Compatible" />
+
+			{isRefreshingOpenAiModels && <div role="status">Loading models…</div>}
+			{openAiModelsError && <div role="alert">{openAiModelsError}</div>}
+			{availableOpenAiModels.length > 0 ? (
+				<div
+					style={{
+						display: "flex",
+						flexDirection: "column",
+						gap: 8,
+						marginBottom: 10,
+					}}>
+					<label htmlFor="openai-compatible-model-picker">
+						<span style={{ fontWeight: 500 }}>Model ID</span>
+					</label>
+					<select
+						aria-label="Model ID"
+						id="openai-compatible-model-picker"
+						onChange={(event) => {
+							const modelId = event.target.value
+							if (modelId === "__custom__") {
+								setIsCustomOpenAiModelEntryVisible(true)
+								return
+							}
+
+							setIsCustomOpenAiModelEntryVisible(false)
+							handleOpenAiModelSelection(modelId)
+						}}
+						style={{ width: "100%" }}
+						value={selectedModelId && availableOpenAiModels.includes(selectedModelId) ? selectedModelId : ""}>
+						{selectedModelId && !availableOpenAiModels.includes(selectedModelId) && (
+							<option value="">{selectedModelId} (not in current list)</option>
+						)}
+						{availableOpenAiModels.map((modelId) => (
+							<option key={modelId} value={modelId}>
+								{modelId}
+							</option>
+						))}
+						<option value="__custom__">Use custom model ID…</option>
+					</select>
+
+					{(isCustomOpenAiModelEntryVisible ||
+						(selectedModelId && !availableOpenAiModels.includes(selectedModelId))) && (
+						<DebouncedTextField
+							initialValue={selectedModelId || ""}
+							onChange={(value) => handleOpenAiModelSelection(value)}
+							placeholder={"Enter Model ID..."}
+							style={{ width: "100%" }}>
+							<span style={{ fontWeight: 500 }}>Custom Model ID</span>
+						</DebouncedTextField>
+					)}
+				</div>
+			) : (
+				<DebouncedTextField
+					initialValue={selectedModelId || ""}
+					onChange={(value) => handleOpenAiModelSelection(value)}
+					placeholder={"Enter Model ID..."}
+					style={{ width: "100%", marginBottom: 10 }}>
+					<span style={{ fontWeight: 500 }}>Model ID</span>
+				</DebouncedTextField>
+			)}
+
+			{/* OpenAI Compatible Custom Headers */}
+			{(() => {
+				const headers = config?.headers ?? {}
+				const headerEntries = Object.entries(headers)
+
+				return (
+					<div style={{ marginBottom: 10 }}>
+						<div
+							style={{
+								display: "flex",
+								justifyContent: "space-between",
+								alignItems: "center",
+							}}>
+							<Tooltip>
+								<TooltipTrigger>
+									<div className="flex items-center gap-2">
+										<span style={{ fontWeight: 500 }}>Custom Headers</span>
+										{remoteConfigSettings?.openAiHeaders !== undefined && (
+											<i className="codicon codicon-lock text-description text-sm" />
+										)}
+									</div>
+								</TooltipTrigger>
+								<TooltipContent hidden={remoteConfigSettings?.openAiHeaders === undefined}>
+									This setting is managed by your organization's remote configuration
+								</TooltipContent>
+							</Tooltip>
+							<VSCodeButton
+								disabled={remoteConfigSettings?.openAiHeaders !== undefined}
+								onClick={() => {
+									const currentHeaders = { ...headers }
+									const headerCount = Object.keys(currentHeaders).length
+									const newKey = `header${headerCount + 1}`
+									currentHeaders[newKey] = ""
+									void write({ headers: currentHeaders }).catch((error) =>
+										handleProviderConfigWriteError("headers", error),
+									)
+								}}>
+								Add Header
+							</VSCodeButton>
+						</div>
+
+						<div>
+							{headerEntries.map(([key, value], index) => (
+								<div key={index} style={{ display: "flex", gap: 5, marginTop: 5 }}>
+									<DebouncedTextField
+										disabled={remoteConfigSettings?.openAiHeaders !== undefined}
+										initialValue={key}
+										onChange={(newValue) => {
+											const currentHeaders = config?.headers ?? {}
+											if (newValue && newValue !== key) {
+												const { [key]: _, ...rest } = currentHeaders
+												void write({
+													headers: {
+														...rest,
+														[newValue]: value,
+													},
+												}).catch((error) => handleProviderConfigWriteError("headers", error))
+											}
+										}}
+										placeholder="Header name"
+										style={{ width: "40%" }}
+									/>
+									<DebouncedTextField
+										disabled={remoteConfigSettings?.openAiHeaders !== undefined}
+										initialValue={value}
+										onChange={(newValue) => {
+											void write({
+												headers: {
+													...(config?.headers ?? {}),
+													[key]: newValue,
+												},
+											}).catch((error) => handleProviderConfigWriteError("headers", error))
+										}}
+										placeholder="Header value"
+										style={{ width: "40%" }}
+									/>
+									<VSCodeButton
+										appearance="secondary"
+										disabled={remoteConfigSettings?.openAiHeaders !== undefined}
+										onClick={() => {
+											const { [key]: _, ...rest } = config?.headers ?? {}
+											void write({ headers: rest }).catch((error) =>
+												handleProviderConfigWriteError("headers", error),
+											)
+										}}>
+										Remove
+									</VSCodeButton>
+								</div>
+							))}
+						</div>
+					</div>
+				)
+			})()}
+
+			{remoteConfigSettings?.azureApiVersion !== undefined ? (
+				<Tooltip>
+					<TooltipTrigger>
+						<BaseUrlField
+							disabled={true}
+							initialValue={apiConfiguration?.azureApiVersion}
+							label="Set Azure API version"
+							onChange={(value) => handleFieldChange("azureApiVersion", value)}
+							placeholder={`Default: ${azureOpenAiDefaultApiVersion}`}
+							showLockIcon={true}
+						/>
+					</TooltipTrigger>
+					<TooltipContent>This setting is managed by your organization's remote configuration</TooltipContent>
+				</Tooltip>
+			) : (
+				<BaseUrlField
+					initialValue={apiConfiguration?.azureApiVersion}
+					label="Set Azure API version"
+					onChange={(value) => handleFieldChange("azureApiVersion", value)}
+					placeholder={`Default: ${azureOpenAiDefaultApiVersion}`}
+				/>
+			)}
+
+			<VSCodeCheckbox
+				checked={apiConfiguration?.azureIdentity || false}
+				onChange={(e: any) => {
+					const isChecked = e.target.checked === true
+					return handleFieldChange("azureIdentity", isChecked)
+				}}>
+				Use Azure Identity Authentication
+			</VSCodeCheckbox>
+
+			<div
+				onClick={() => setModelConfigurationSelected((val) => !val)}
+				style={{
+					color: getAsVar(VSC_DESCRIPTION_FOREGROUND),
+					display: "flex",
+					margin: "10px 0",
+					cursor: "pointer",
+					alignItems: "center",
+				}}>
+				<span
+					className={`codicon ${modelConfigurationSelected ? "codicon-chevron-down" : "codicon-chevron-right"}`}
+					style={{
+						marginRight: "4px",
+					}}
+				/>
+				<span
+					style={{
+						fontWeight: 700,
+						textTransform: "uppercase",
+					}}>
+					Model Configuration
+				</span>
+			</div>
+
+			{modelConfigurationSelected && (
+				<>
+					<VSCodeCheckbox
+						checked={!!openAiModelInfo?.supportsImages}
+						onChange={(e: any) => {
+							const isChecked = e.target.checked === true
+							const modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+							modelInfo.supportsImages = isChecked
+							handleOpenAiModelInfoChange(modelInfo)
+						}}>
+						Supports Images
+					</VSCodeCheckbox>
+
+					<VSCodeCheckbox
+						checked={!!openAiModelInfo?.isR1FormatRequired}
+						onChange={(e: any) => {
+							const isChecked = e.target.checked === true
+							let modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+							modelInfo = { ...modelInfo, isR1FormatRequired: isChecked }
+
+							handleOpenAiModelInfoChange(modelInfo)
+						}}>
+						Enable R1 messages format
+					</VSCodeCheckbox>
+
+					<div style={{ display: "flex", gap: 10, marginTop: "5px" }}>
+						<DebouncedTextField
+							initialValue={
+								openAiModelInfo?.contextWindow
+									? openAiModelInfo.contextWindow.toString()
+									: (openAiModelInfoSafeDefaults.contextWindow?.toString() ?? "")
+							}
+							onChange={(value) => {
+								const modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+								modelInfo.contextWindow = Number(value)
+								handleOpenAiModelInfoChange(modelInfo)
+							}}
+							style={{ flex: 1 }}>
+							<span style={{ fontWeight: 500 }}>Context Window Size</span>
+						</DebouncedTextField>
+
+						<DebouncedTextField
+							initialValue={
+								openAiModelInfo?.maxTokens
+									? openAiModelInfo.maxTokens.toString()
+									: (openAiModelInfoSafeDefaults.maxTokens?.toString() ?? "")
+							}
+							onChange={(value) => {
+								const modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+								modelInfo.maxTokens = Number(value)
+								handleOpenAiModelInfoChange(modelInfo)
+							}}
+							style={{ flex: 1 }}>
+							<span style={{ fontWeight: 500 }}>Max Output Tokens</span>
+						</DebouncedTextField>
+					</div>
+
+					<div style={{ display: "flex", gap: 10, marginTop: "5px" }}>
+						<DebouncedTextField
+							initialValue={
+								openAiModelInfo?.inputPrice
+									? openAiModelInfo.inputPrice.toString()
+									: (openAiModelInfoSafeDefaults.inputPrice?.toString() ?? "")
+							}
+							onChange={(value) => {
+								const modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+								modelInfo.inputPrice = parsePrice(value, openAiModelInfoSafeDefaults.inputPrice ?? 0)
+								handleOpenAiModelInfoChange(modelInfo)
+							}}
+							style={{ flex: 1 }}>
+							<span style={{ fontWeight: 500 }}>Input Price / 1M tokens</span>
+						</DebouncedTextField>
+
+						<DebouncedTextField
+							initialValue={
+								openAiModelInfo?.outputPrice
+									? openAiModelInfo.outputPrice.toString()
+									: (openAiModelInfoSafeDefaults.outputPrice?.toString() ?? "")
+							}
+							onChange={(value) => {
+								const modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+								modelInfo.outputPrice = parsePrice(value, openAiModelInfoSafeDefaults.outputPrice ?? 0)
+								handleOpenAiModelInfoChange(modelInfo)
+							}}
+							style={{ flex: 1 }}>
+							<span style={{ fontWeight: 500 }}>Output Price / 1M tokens</span>
+						</DebouncedTextField>
+					</div>
+
+					<div style={{ display: "flex", gap: 10, marginTop: "5px" }}>
+						<DebouncedTextField
+							initialValue={
+								openAiModelInfo?.temperature
+									? openAiModelInfo.temperature.toString()
+									: (openAiModelInfoSafeDefaults.temperature?.toString() ?? "")
+							}
+							onChange={(value) => {
+								const modelInfo = openAiModelInfo ? { ...openAiModelInfo } : { ...openAiModelInfoSafeDefaults }
+								modelInfo.temperature = parsePrice(value, openAiModelInfoSafeDefaults.temperature ?? 0)
+								handleOpenAiModelInfoChange(modelInfo)
+							}}>
+							<span style={{ fontWeight: 500 }}>Temperature</span>
+						</DebouncedTextField>
+					</div>
+				</>
+			)}
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				<span style={{ color: "var(--vscode-errorForeground)" }}>
+					(<span style={{ fontWeight: 500 }}>Note:</span> Cline uses complex prompts, so behavior can vary across
+					models. Less capable models may not work as expected.)
+				</span>
+			</p>
+
+			{showModelOptions && (
+				<>
+					<ReasoningEffortSelector
+						currentMode={currentMode}
+						defaultEffort="none"
+						onEffortChange={(effort) => {
+							void write({
+								reasoning: {
+									enabled: effort !== "none",
+									effort: effort !== "none" ? effort : undefined,
+								},
+							}).catch((err) => console.error("Failed to update OpenAI Compatible reasoning effort:", err))
+						}}
+					/>
+					<ModelInfoView isPopup={isPopup} modelInfo={selectedModelInfo} selectedModelId={selectedModelId} />
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OpenAINative.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OpenAINative.tsx
new file mode 100644
index 0000000..8427aa1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OpenAINative.tsx
@@ -0,0 +1,70 @@
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import { supportsReasoningEffortForModelId } from "../utils/providerUtils"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the OpenAINativeProvider component
+ */
+interface OpenAINativeProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The OpenAI (native) provider configuration component
+ */
+export const OpenAINativeProvider = ({ showModelOptions, isPopup, currentMode }: OpenAINativeProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange, handleModeFieldChange } = useApiConfigurationHandlers()
+
+	// Get the normalized configuration
+	const { models, selectedModelId, selectedModelInfo, hideUsageCost } = useStaticProviderSelection(
+		"openai-native",
+		apiConfiguration,
+		currentMode,
+	)
+	const showReasoningEffort = supportsReasoningEffortForModelId(selectedModelId, true)
+
+	return (
+		<div>
+			<ApiKeyField
+				initialValue={apiConfiguration?.openAiNativeApiKey || ""}
+				onChange={(value) => handleFieldChange("openAiNativeApiKey", value)}
+				providerName="OpenAI"
+				signupUrl="https://platform.openai.com/api-keys"
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(e: any) =>
+							handleModeFieldChange(
+								{ plan: "planModeApiModelId", act: "actModeApiModelId" },
+								e.target.value,
+								currentMode,
+							)
+						}
+						selectedModelId={selectedModelId}
+					/>
+					{showReasoningEffort && <ReasoningEffortSelector currentMode={currentMode} />}
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OpenAiCodexProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OpenAiCodexProvider.tsx
new file mode 100644
index 0000000..7cdc493
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OpenAiCodexProvider.tsx
@@ -0,0 +1,132 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { fromProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import type { Mode } from "@shared/storage/types"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { AccountServiceClient } from "@/services/grpc-client"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import { supportsReasoningEffortForModelId } from "../utils/providerUtils"
+
+const OPENAI_CODEX_PROVIDER_ID = "openai-codex"
+
+interface OpenAiCodexProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * OpenAI Codex (ChatGPT Plus/Pro) provider configuration component.
+ * Uses OAuth authentication instead of API keys.
+ *
+ * Model list, default model id, and the "hide per-token cost" UI hint all
+ * come from the extension over gRPC (`ResolveProviderModels` /
+ * `ListProviders`), which in turn sources them from the `@cline/llms` SDK.
+ * The webview imports no static model data from `@shared/api` for this
+ * provider, and the `hideUsageCost` flag is not hard-coded — it is
+ * derived from the SDK's `ProviderInfo.metadata.usageCostDisplay`.
+ */
+export const OpenAiCodexProvider = ({ showModelOptions, isPopup, currentMode }: OpenAiCodexProviderProps) => {
+	const { apiConfiguration, openAiCodexIsAuthenticated } = useExtensionState()
+	const { config, commitSelection } = useProviderConfig(OPENAI_CODEX_PROVIDER_ID)
+	const {
+		models,
+		defaultModelId,
+		selectedModelId: legacySelectedModelId,
+		selectedModelInfo: legacySelectedModelInfo,
+		hideUsageCost,
+	} = useStaticProviderSelection(OPENAI_CODEX_PROVIDER_ID, apiConfiguration, currentMode)
+	const committedSelection = currentMode === "plan" ? config?.planSelection : config?.actSelection
+	const selectedModelId = committedSelection?.modelId ?? legacySelectedModelId
+	const selectedModelInfo = committedSelection?.modelInfo
+		? fromProtobufModelInfo(committedSelection.modelInfo)
+		: legacySelectedModelInfo
+
+	const showReasoningEffort = supportsReasoningEffortForModelId(selectedModelId, true)
+
+	const handleModelChange = (modelId: string) => {
+		if (!modelId) {
+			return
+		}
+
+		const fallbackModelId = defaultModelId || Object.keys(models)[0] || modelId
+		const modelInfo = models[modelId] ?? models[fallbackModelId] ?? selectedModelInfo ?? openAiModelInfoSafeDefaults
+
+		void commitSelection(currentMode, {
+			providerId: OPENAI_CODEX_PROVIDER_ID,
+			modelId,
+			modelInfo,
+		}).catch((err) => console.error("Failed to commit OpenAI Codex model selection:", err))
+	}
+
+	const handleSignIn = async () => {
+		try {
+			await AccountServiceClient.openAiCodexSignIn({})
+		} catch (error) {
+			console.error("Failed to sign in to OpenAI Codex:", error)
+		}
+	}
+
+	const handleSignOut = async () => {
+		try {
+			await AccountServiceClient.openAiCodexSignOut({})
+		} catch (error) {
+			console.error("Failed to sign out of OpenAI Codex:", error)
+		}
+	}
+
+	return (
+		<div>
+			<div style={{ marginBottom: "15px" }}>
+				{openAiCodexIsAuthenticated ? (
+					<div
+						style={{
+							display: "flex",
+							justifyContent: "space-between",
+							alignItems: "center",
+						}}>
+						<span style={{ color: "var(--vscode-descriptionForeground)" }}>Signed in to OpenAI Codex</span>
+						<VSCodeButton appearance="secondary" onClick={handleSignOut}>
+							Sign Out
+						</VSCodeButton>
+					</div>
+				) : (
+					<div>
+						<p
+							style={{
+								fontSize: "12px",
+								color: "var(--vscode-descriptionForeground)",
+								marginBottom: "10px",
+							}}>
+							Sign in with your ChatGPT Plus or Pro subscription to use GPT-5 models without an API key.
+						</p>
+						<VSCodeButton onClick={handleSignIn}>Sign in to OpenAI Codex</VSCodeButton>
+					</div>
+				)}
+			</div>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(event: Event) => handleModelChange((event.target as HTMLSelectElement | null)?.value ?? "")}
+						selectedModelId={selectedModelId}
+					/>
+					{showReasoningEffort && <ReasoningEffortSelector currentMode={currentMode} />}
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/OpenRouterProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/OpenRouterProvider.tsx
new file mode 100644
index 0000000..08f5db8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/OpenRouterProvider.tsx
@@ -0,0 +1,119 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { useEffect, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { AccountServiceClient } from "@/services/grpc-client"
+import { useOpenRouterKeyInfo } from "../../ui/hooks/useOpenRouterKeyInfo"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import OpenRouterModelPicker from "../OpenRouterModelPicker"
+import { formatPrice } from "../utils/pricingUtils"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+/**
+ * Component to display OpenRouter balance information
+ */
+const OpenRouterBalanceDisplay = ({ apiKey }: { apiKey: string }) => {
+	const { data: keyInfo, isLoading, error } = useOpenRouterKeyInfo(apiKey)
+
+	if (isLoading) {
+		return <span style={{ fontSize: "12px", color: "var(--vscode-descriptionForeground)" }}>Loading...</span>
+	}
+
+	if (error || !keyInfo || keyInfo.limit === null) {
+		// Don't show anything if there's an error, no info, or no limit set
+		return null
+	}
+
+	// Calculate remaining balance
+	const remainingBalance = keyInfo.limit - keyInfo.usage
+	const formattedBalance = formatPrice(remainingBalance)
+
+	return (
+		<VSCodeLink
+			href="https://openrouter.ai/settings/keys"
+			style={{
+				fontSize: "12px",
+				color: "var(--vscode-foreground)",
+				textDecoration: "none",
+				fontWeight: 500,
+				paddingLeft: 4,
+				cursor: "pointer",
+			}}
+			title={`Remaining balance: ${formattedBalance}\nLimit: ${formatPrice(keyInfo.limit)}\nUsage: ${formatPrice(keyInfo.usage)}`}>
+			Balance: {formattedBalance}
+		</VSCodeLink>
+	)
+}
+
+/**
+ * Props for the OpenRouterProvider component
+ */
+interface OpenRouterProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The OpenRouter provider configuration component
+ */
+export const OpenRouterProvider = ({ showModelOptions, isPopup, currentMode }: OpenRouterProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { config, write } = useProviderConfig("openrouter")
+	const [openRouterApiKey, setOpenRouterApiKey] = useState(apiConfiguration?.openRouterApiKey || "")
+	const apiKeyLength = config?.apiKeyLength || apiConfiguration?.openRouterApiKey?.length
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength,
+		onApiKeyChange: setOpenRouterApiKey,
+		providerName: "OpenRouter",
+		write,
+	})
+
+	useEffect(() => {
+		setOpenRouterApiKey(apiConfiguration?.openRouterApiKey || "")
+	}, [apiConfiguration?.openRouterApiKey])
+
+	return (
+		<div>
+			<div>
+				<DebouncedTextField
+					initialValue={savedApiKeyMask}
+					onChange={handleApiKeyChange}
+					placeholder="Enter API Key..."
+					style={{ width: "100%" }}
+					type="password">
+					<div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", width: "100%" }}>
+						<span style={{ fontWeight: 500 }}>OpenRouter API Key</span>
+						{openRouterApiKey && <OpenRouterBalanceDisplay apiKey={openRouterApiKey} />}
+					</div>
+				</DebouncedTextField>
+				{!openRouterApiKey && (
+					<VSCodeButton
+						appearance="secondary"
+						onClick={async () => {
+							try {
+								await AccountServiceClient.openrouterAuthClicked(EmptyRequest.create())
+							} catch (error) {
+								console.error("Failed to open OpenRouter auth:", error)
+							}
+						}}
+						style={{ margin: "5px 0 0 0" }}>
+						Get OpenRouter API Key
+					</VSCodeButton>
+				)}
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: "5px",
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					This key is stored locally and only used to make API requests from this extension.
+				</p>
+			</div>
+
+			{showModelOptions && <OpenRouterModelPicker currentMode={currentMode} isPopup={isPopup} showProviderRouting={true} />}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/QwenCodeProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/QwenCodeProvider.tsx
new file mode 100644
index 0000000..6988d35
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/QwenCodeProvider.tsx
@@ -0,0 +1,94 @@
+import { Mode } from "@shared/storage/types"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the QwenCodeProvider component
+ */
+interface QwenCodeProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Qwen Code provider configuration component
+ */
+export const QwenCodeProvider = ({ showModelOptions, isPopup, currentMode }: QwenCodeProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	// Get the normalized configuration
+	const { models, selectedModelId, selectedModelInfo, hideUsageCost } = useStaticProviderSelection(
+		"qwen-code",
+		apiConfiguration,
+		currentMode,
+	)
+
+	return (
+		<div>
+			<h3 style={{ color: "var(--vscode-foreground)", margin: "8px 0" }}>Qwen Code API Configuration</h3>
+			<VSCodeTextField
+				onInput={(e: any) => handleFieldChange("qwenCodeOauthPath", e.target.value)}
+				placeholder="~/.qwen/oauth_creds.json"
+				style={{ width: "100%" }}
+				value={apiConfiguration?.qwenCodeOauthPath || ""}>
+				OAuth Credentials Path
+			</VSCodeTextField>
+			<div style={{ fontSize: "12px", color: "var(--vscode-descriptionForeground)", marginTop: "4px" }}>
+				Path to your Qwen OAuth credentials file. Use ~/.qwen/oauth_creds.json or provide a custom path.
+			</div>
+
+			<div style={{ fontSize: "12px", color: "var(--vscode-descriptionForeground)", marginTop: "12px" }}>
+				Qwen Code is an OAuth-based API that requires authentication through the official Qwen client. You'll need to set
+				up OAuth credentials first.
+			</div>
+
+			<div style={{ fontSize: "12px", color: "var(--vscode-descriptionForeground)", marginTop: "8px" }}>
+				To get started:
+				<br />
+				1. Install the official Qwen client
+				<br />
+				2. Authenticate using your account
+				<br />
+				3. OAuth credentials will be stored automatically
+			</div>
+
+			<VSCodeLink
+				href="https://github.com/QwenLM/qwen-code/blob/main/README.md"
+				style={{
+					color: "var(--vscode-textLink-foreground)",
+					marginTop: "8px",
+					display: "inline-block",
+					fontSize: "12px",
+				}}>
+				Setup Instructions
+			</VSCodeLink>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(modelId) => {
+							const fieldName = currentMode === "plan" ? "planModeApiModelId" : "actModeApiModelId"
+							handleFieldChange(fieldName, modelId)
+						}}
+						selectedModelId={selectedModelId}
+					/>
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/QwenProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/QwenProvider.tsx
new file mode 100644
index 0000000..ddd130d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/QwenProvider.tsx
@@ -0,0 +1,123 @@
+import { QwenApiRegions } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { DROPDOWN_Z_INDEX } from "../ApiOptions"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { DropdownContainer, ModelSelector } from "../common/ModelSelector"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+const SUPPORTED_THINKING_MODELS = [
+	"qwen3-235b-a22b",
+	"qwen3-32b",
+	"qwen3-30b-a3b",
+	"qwen3-14b",
+	"qwen3-8b",
+	"qwen3-4b",
+	"qwen3-1.7b",
+	"qwen3-0.6b",
+	"qwen-plus-latest",
+	"qwen-turbo-latest",
+]
+
+/**
+ * Props for the QwenProvider component
+ */
+interface QwenProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+// Turns enum into an array of values for dropdown options
+const qwenApiOptions: QwenApiRegions[] = Object.values(QwenApiRegions)
+
+/**
+ * The Alibaba Qwen provider configuration component
+ */
+export const QwenProvider = ({ showModelOptions, isPopup, currentMode }: QwenProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange, handleModeFieldChange } = useApiConfigurationHandlers()
+
+	// Catalog and default come from the SDK via gRPC. The SDK consumes
+	// `apiLine` from the effective provider config so regional selection
+	// (china vs international) happens upstream — the webview sees a
+	// single catalog per render.
+	const { models, selectedModelId, selectedModelInfo, hideUsageCost } = useStaticProviderSelection(
+		"qwen",
+		apiConfiguration,
+		currentMode,
+	)
+
+	return (
+		<div>
+			<DropdownContainer className="dropdown-container" style={{ position: "inherit" }}>
+				<label htmlFor="qwen-line-provider">
+					<span style={{ fontWeight: 500, marginTop: 5 }}>Alibaba API Line</span>
+				</label>
+				<VSCodeDropdown
+					id="qwen-line-provider"
+					onChange={(e: any) => handleFieldChange("qwenApiLine", e.target.value as QwenApiRegions)}
+					style={{
+						minWidth: 130,
+						position: "relative",
+					}}
+					value={apiConfiguration?.qwenApiLine || qwenApiOptions[0]}>
+					{qwenApiOptions.map((line) => (
+						<VSCodeOption key={line} value={line}>
+							{line.charAt(0).toUpperCase() + line.slice(1)} API
+						</VSCodeOption>
+					))}
+				</VSCodeDropdown>
+			</DropdownContainer>
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				Please select the appropriate API interface based on your location. If you are in China, choose the China API
+				interface. Otherwise, choose the International API interface.
+			</p>
+
+			<ApiKeyField
+				initialValue={apiConfiguration?.qwenApiKey || ""}
+				onChange={(value) => handleFieldChange("qwenApiKey", value)}
+				providerName="Qwen"
+				signupUrl="https://bailian.console.aliyun.com/"
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(e: any) =>
+							handleModeFieldChange(
+								{ plan: "planModeApiModelId", act: "actModeApiModelId" },
+								e.target.value,
+								currentMode,
+							)
+						}
+						selectedModelId={selectedModelId}
+						zIndex={DROPDOWN_Z_INDEX - 2}
+					/>
+
+					{SUPPORTED_THINKING_MODELS.includes(selectedModelId) && (
+						<ThinkingBudgetSlider currentMode={currentMode} maxBudget={selectedModelInfo.thinkingConfig?.maxBudget} />
+					)}
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/RequestyProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/RequestyProvider.tsx
new file mode 100644
index 0000000..e99fb45
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/RequestyProvider.tsx
@@ -0,0 +1,92 @@
+import { toRequestyServiceUrl } from "@shared/clients/requesty"
+import { StringRequest } from "@shared/proto/cline/common"
+import { Mode } from "@shared/storage/types"
+import { VSCodeButton, VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { AccountServiceClient } from "@/services/grpc-client"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import RequestyModelPicker from "../RequestyModelPicker"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the RequestyProvider component
+ */
+interface RequestyProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Requesty provider configuration component
+ */
+export const RequestyProvider = ({ showModelOptions, isPopup, currentMode }: RequestyProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	const [requestyEndpointSelected, setRequestyEndpointSelected] = useState(!!apiConfiguration?.requestyBaseUrl)
+
+	const resolvedUrl = toRequestyServiceUrl(apiConfiguration?.requestyBaseUrl, "app")
+	const apiKeyUrl = resolvedUrl != null ? new URL("api-keys", resolvedUrl).toString() : undefined
+
+	return (
+		<div style={{ display: "flex", flexDirection: "column" }}>
+			<ApiKeyField
+				initialValue={apiConfiguration?.requestyApiKey || ""}
+				onChange={(value) => handleFieldChange("requestyApiKey", value)}
+				providerName="Requesty"
+				signupUrl={apiKeyUrl}
+			/>
+			{!apiConfiguration?.requestyApiKey && (
+				<VSCodeButton
+					appearance="secondary"
+					onClick={async () => {
+						try {
+							await AccountServiceClient.requestyAuthClicked(
+								StringRequest.create({
+									value: apiConfiguration?.requestyBaseUrl || "",
+								}),
+							)
+						} catch (error) {
+							console.error("Failed to open Requesty auth:", error)
+						}
+					}}
+					style={{ margin: "5px 0 0 0" }}>
+					Get Requesty API Key
+				</VSCodeButton>
+			)}
+			<VSCodeCheckbox
+				checked={requestyEndpointSelected}
+				onChange={(e: any) => {
+					const isChecked = e.target.checked === true
+					setRequestyEndpointSelected(isChecked)
+
+					if (!isChecked) {
+						handleFieldChange("requestyBaseUrl", undefined)
+					}
+				}}>
+				Use custom base URL
+			</VSCodeCheckbox>
+			{requestyEndpointSelected && (
+				<DebouncedTextField
+					initialValue={apiConfiguration?.requestyBaseUrl ?? ""}
+					onChange={(value) => {
+						if (value.length === 0) {
+							handleFieldChange("requestyBaseUrl", undefined)
+						} else {
+							handleFieldChange("requestyBaseUrl", value)
+						}
+					}}
+					placeholder="Custom base URL"
+					style={{ width: "100%", marginBottom: 5 }}
+					type="text"
+				/>
+			)}
+			{showModelOptions && (
+				<RequestyModelPicker baseUrl={apiConfiguration?.requestyBaseUrl} currentMode={currentMode} isPopup={isPopup} />
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/SapAiCoreProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/SapAiCoreProvider.tsx
new file mode 100644
index 0000000..2c5c7f2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/SapAiCoreProvider.tsx
@@ -0,0 +1,271 @@
+import { SapAiCoreModelDeployment, SapAiCoreModelsRequest } from "@shared/proto/index.cline"
+import { Mode } from "@shared/storage/types"
+import { VSCodeCheckbox, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { useCallback, useEffect, useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import SapAiCoreModelPicker from "../SapAiCoreModelPicker"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+/**
+ * Props for the SapAiCoreProvider component
+ */
+interface SapAiCoreProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The SAP AI Core provider configuration component
+ */
+export const SapAiCoreProvider = ({ showModelOptions, isPopup, currentMode }: SapAiCoreProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange, handleModeFieldsChange } = useApiConfigurationHandlers()
+
+	// Handle orchestration checkbox change
+	const handleOrchestrationChange = async (checked: boolean) => {
+		await handleFieldChange("sapAiCoreUseOrchestrationMode", checked)
+	}
+
+	const { selectedModelId, selectedModelInfo, hideUsageCost } = useStaticProviderSelection(
+		"sapaicore",
+		apiConfiguration,
+		currentMode,
+	)
+
+	// State for dynamic model fetching
+	const [sapAiCoreModelDeployments, setSapAiCoreModelDeployments] = useState<SapAiCoreModelDeployment[]>([])
+	const [orchestrationAvailable, setOrchestrationAvailable] = useState<boolean>(false)
+	const [hasCheckedOrchestration, setHasCheckedOrchestration] = useState<boolean>(false)
+	const [isLoadingModels, setIsLoadingModels] = useState(false)
+	const [modelError, setModelError] = useState<string | null>(null)
+	const useOrchestrationMode = apiConfiguration?.sapAiCoreUseOrchestrationMode ?? true
+
+	// Check if all required credentials are available
+	const hasRequiredCredentials =
+		apiConfiguration?.sapAiCoreClientId &&
+		apiConfiguration?.sapAiCoreClientSecret &&
+		apiConfiguration?.sapAiCoreBaseUrl &&
+		apiConfiguration?.sapAiCoreTokenUrl
+
+	// Function to fetch SAP AI Core models
+	const fetchSapAiCoreModels = useCallback(async () => {
+		if (!hasRequiredCredentials) {
+			setSapAiCoreModelDeployments([])
+			setOrchestrationAvailable(false)
+			setHasCheckedOrchestration(false)
+			return
+		}
+
+		setIsLoadingModels(true)
+		setModelError(null)
+
+		try {
+			const response = await ModelsServiceClient.getSapAiCoreModels(
+				SapAiCoreModelsRequest.create({
+					clientId: apiConfiguration.sapAiCoreClientId,
+					clientSecret: apiConfiguration.sapAiCoreClientSecret,
+					baseUrl: apiConfiguration.sapAiCoreBaseUrl,
+					tokenUrl: apiConfiguration.sapAiCoreTokenUrl,
+					resourceGroup: apiConfiguration.sapAiResourceGroup,
+				}),
+			)
+
+			if (response) {
+				setSapAiCoreModelDeployments(response.deployments || [])
+				setOrchestrationAvailable(response.orchestrationAvailable || false)
+				setHasCheckedOrchestration(true)
+			} else {
+				setSapAiCoreModelDeployments([])
+				setOrchestrationAvailable(false)
+				setHasCheckedOrchestration(true)
+			}
+		} catch (error) {
+			console.error("Error fetching SAP AI Core models:", error)
+			setModelError("Failed to fetch models. Please check your configuration.")
+			setSapAiCoreModelDeployments([])
+			setOrchestrationAvailable(false)
+			setHasCheckedOrchestration(true)
+		} finally {
+			setIsLoadingModels(false)
+		}
+	}, [
+		apiConfiguration?.sapAiCoreClientId,
+		apiConfiguration?.sapAiCoreClientSecret,
+		apiConfiguration?.sapAiCoreBaseUrl,
+		apiConfiguration?.sapAiCoreTokenUrl,
+		apiConfiguration?.sapAiResourceGroup,
+	])
+
+	// Fetch models when configuration changes
+	useEffect(() => {
+		if (showModelOptions && hasRequiredCredentials) {
+			fetchSapAiCoreModels()
+		}
+	}, [showModelOptions, hasRequiredCredentials, fetchSapAiCoreModels])
+
+	// Handle automatic disabling of orchestration mode when not available
+	useEffect(() => {
+		if (hasCheckedOrchestration && !orchestrationAvailable && useOrchestrationMode) {
+			handleFieldChange("sapAiCoreUseOrchestrationMode", false)
+		}
+	}, [hasCheckedOrchestration, orchestrationAvailable, useOrchestrationMode, handleFieldChange])
+
+	// Handle model selection
+	const handleModelChange = useCallback(
+		(modelId: string, deploymentId: string) => {
+			// Update both model ID and deployment ID atomically
+			handleModeFieldsChange(
+				{
+					modelId: { plan: "planModeApiModelId", act: "actModeApiModelId" },
+					deploymentId: { plan: "planModeSapAiCoreDeploymentId", act: "actModeSapAiCoreDeploymentId" },
+				},
+				{ modelId, deploymentId },
+				currentMode,
+			)
+		},
+		[handleModeFieldsChange, currentMode],
+	)
+
+	return (
+		<div className="flex flex-col gap-1.5">
+			<DebouncedTextField
+				initialValue={apiConfiguration?.sapAiCoreClientId || ""}
+				onChange={(value) => handleFieldChange("sapAiCoreClientId", value)}
+				placeholder="Enter AI Core Client Id..."
+				style={{ width: "100%" }}
+				type="password">
+				<span className="font-medium">AI Core Client Id</span>
+			</DebouncedTextField>
+			{apiConfiguration?.sapAiCoreClientId && (
+				<p className="text-xs text-(--vscode-descriptionForeground)">
+					Client Id is set. To change it, please re-enter the value.
+				</p>
+			)}
+
+			<DebouncedTextField
+				initialValue={apiConfiguration?.sapAiCoreClientSecret || ""}
+				onChange={(value) => handleFieldChange("sapAiCoreClientSecret", value)}
+				placeholder="Enter AI Core Client Secret..."
+				style={{ width: "100%" }}
+				type="password">
+				<span className="font-medium">AI Core Client Secret</span>
+			</DebouncedTextField>
+			{apiConfiguration?.sapAiCoreClientSecret && (
+				<p className="text-xs text-(--vscode-descriptionForeground)">
+					Client Secret is set. To change it, please re-enter the value.
+				</p>
+			)}
+
+			<DebouncedTextField
+				initialValue={apiConfiguration?.sapAiCoreBaseUrl || ""}
+				onChange={(value) => handleFieldChange("sapAiCoreBaseUrl", value)}
+				placeholder="Enter AI Core Base URL..."
+				style={{ width: "100%" }}>
+				<span className="font-medium">AI Core Base URL</span>
+			</DebouncedTextField>
+
+			<DebouncedTextField
+				initialValue={apiConfiguration?.sapAiCoreTokenUrl || ""}
+				onChange={(value) => handleFieldChange("sapAiCoreTokenUrl", value)}
+				placeholder="Enter AI Core Auth URL..."
+				style={{ width: "100%" }}>
+				<span className="font-medium">AI Core Auth URL</span>
+			</DebouncedTextField>
+
+			<DebouncedTextField
+				initialValue={apiConfiguration?.sapAiResourceGroup || ""}
+				onChange={(value) => handleFieldChange("sapAiResourceGroup", value)}
+				placeholder="Enter AI Core Resource Group..."
+				style={{ width: "100%" }}>
+				<span className="font-medium">AI Core Resource Group</span>
+			</DebouncedTextField>
+
+			<p className="text-xs mt-1.5 text-(--vscode-descriptionForeground)">
+				These credentials are stored locally and only used to make API requests from this extension.
+				<VSCodeLink
+					className="inline"
+					href="https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/access-sap-ai-core-via-api">
+					You can find more information about SAP AI Core API access here.
+				</VSCodeLink>
+			</p>
+
+			{orchestrationAvailable && (
+				<div className="flex flex-col gap-2.5 mt-[15px]">
+					<div className="flex items-center gap-2">
+						<VSCodeCheckbox
+							aria-label="Orchestration Mode"
+							checked={useOrchestrationMode}
+							onChange={(e) => handleOrchestrationChange((e.target as HTMLInputElement).checked)}
+						/>
+						<span className="font-medium">Orchestration Mode</span>
+					</div>
+
+					<p className="text-xs text-(--vscode-descriptionForeground)">
+						When enabled, provides access to all available models without requiring individual deployments.
+						<br />
+						<br />
+						When disabled, provides access only to deployed models in your AI Core service instance.
+					</p>
+				</div>
+			)}
+
+			{showModelOptions && (
+				<>
+					<div className="flex flex-col gap-1.5">
+						{isLoadingModels ? (
+							<div className="text-xs text-(--vscode-descriptionForeground)">Loading models...</div>
+						) : modelError ? (
+							<div className="text-xs text-(--vscode-errorForeground)">
+								{modelError}
+								<button
+									className="ml-2 text-[11px] px-1.5 py-0.5 bg-(--vscode-button-background) text-(--vscode-button-foreground) border-none rounded-sm cursor-pointer"
+									onClick={fetchSapAiCoreModels}>
+									Retry
+								</button>
+							</div>
+						) : hasRequiredCredentials ? (
+							<>
+								{sapAiCoreModelDeployments.length === 0 && (
+									<div className="text-xs text-(--vscode-errorForeground) mb-2">
+										Unable to fetch models from SAP AI Core service instance. Please check your SAP AI Core
+										configuration or ensure your deployments are deployed and running in the service instance
+									</div>
+								)}
+								<SapAiCoreModelPicker
+									onModelChange={handleModelChange}
+									placeholder="Select a model..."
+									sapAiCoreModelDeployments={sapAiCoreModelDeployments}
+									selectedDeploymentId={
+										apiConfiguration?.[
+											currentMode === "plan"
+												? "planModeSapAiCoreDeploymentId"
+												: "actModeSapAiCoreDeploymentId"
+										]
+									}
+									selectedModelId={selectedModelId || ""}
+									useOrchestrationMode={useOrchestrationMode}
+								/>
+							</>
+						) : (
+							<div className="text-xs text-(--vscode-errorForeground)">
+								Please configure your SAP AI Core credentials to see available models.
+							</div>
+						)}
+					</div>
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/VSCodeLmProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/VSCodeLmProvider.tsx
new file mode 100644
index 0000000..a7d16a9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/VSCodeLmProvider.tsx
@@ -0,0 +1,115 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import type { Mode } from "@shared/storage/types"
+import { parseVsCodeLmModelSelector, stringifyVsCodeLmModelSelector } from "@shared/vsCodeSelectorUtils"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useCallback, useEffect, useState } from "react"
+import { useInterval } from "react-use"
+import type * as vscodemodels from "vscode"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { DROPDOWN_Z_INDEX, DropdownContainer } from "../ApiOptions"
+import { getModeSpecificFields } from "../utils/providerUtils"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+interface VSCodeLmProviderProps {
+	currentMode: Mode
+}
+
+export const VSCodeLmProvider = ({ currentMode }: VSCodeLmProviderProps) => {
+	const [vsCodeLmModels, setVsCodeLmModels] = useState<vscodemodels.LanguageModelChatSelector[]>([])
+	const { apiConfiguration } = useExtensionState()
+	const { handleModeFieldChange } = useApiConfigurationHandlers()
+	const { config, commitSelection } = useProviderConfig("vscode-lm")
+
+	const { vsCodeLmModelSelector } = getModeSpecificFields(apiConfiguration, currentMode)
+	const committedSelection = currentMode === "plan" ? config?.planSelection : config?.actSelection
+	const selectedModelId = vsCodeLmModelSelector
+		? stringifyVsCodeLmModelSelector(vsCodeLmModelSelector)
+		: (committedSelection?.modelId ?? "")
+
+	// Poll VS Code LM models
+	const requestVsCodeLmModels = useCallback(async () => {
+		try {
+			const response = await ModelsServiceClient.getVsCodeLmModels(EmptyRequest.create({}))
+			if (response?.models) {
+				setVsCodeLmModels(response.models)
+			}
+		} catch (error) {
+			console.error("Failed to fetch VS Code LM models:", error)
+			setVsCodeLmModels([])
+		}
+	}, [])
+
+	useEffect(() => {
+		requestVsCodeLmModels()
+	}, [requestVsCodeLmModels])
+
+	useInterval(requestVsCodeLmModels, 2000)
+
+	const handleModelSelect = (modelId: string) => {
+		if (!modelId) {
+			return
+		}
+
+		const selector = parseVsCodeLmModelSelector(modelId)
+		void handleModeFieldChange(
+			{
+				plan: "planModeVsCodeLmModelSelector",
+				act: "actModeVsCodeLmModelSelector",
+			},
+			selector,
+			currentMode,
+		).catch((err) => console.error("Failed to update VS Code LM selector:", err))
+
+		void commitSelection(currentMode, {
+			providerId: "vscode-lm",
+			modelId,
+			modelInfo: {
+				...openAiModelInfoSafeDefaults,
+				name: [selector.vendor, selector.family].filter(Boolean).join(" - ") || modelId,
+			},
+		}).catch((err) => console.error("Failed to commit VS Code LM model selection:", err))
+	}
+
+	return (
+		<div>
+			<DropdownContainer className="dropdown-container" zIndex={DROPDOWN_Z_INDEX - 2}>
+				<label htmlFor="vscode-lm-model">
+					<span style={{ fontWeight: 500 }}>Language Model</span>
+				</label>
+				{vsCodeLmModels.length > 0 ? (
+					<VSCodeDropdown
+						id="vscode-lm-model"
+						onChange={(e) => handleModelSelect((e.target as HTMLInputElement).value)}
+						style={{ width: "100%" }}
+						value={selectedModelId}>
+						<VSCodeOption value="">Select a model...</VSCodeOption>
+						{vsCodeLmModels.map((model) => {
+							const value = stringifyVsCodeLmModelSelector(model)
+							return (
+								<VSCodeOption key={value} value={value}>
+									{model.vendor} - {model.family}
+								</VSCodeOption>
+							)
+						})}
+					</VSCodeDropdown>
+				) : (
+					<p
+						style={{
+							fontSize: "12px",
+							marginTop: "5px",
+							color: "var(--vscode-descriptionForeground)",
+						}}>
+						Uses models contributed by other extensions through the VS Code Language Model API. The most common source
+						is GitHub Copilot — install the{" "}
+						<a href="https://marketplace.visualstudio.com/items?itemName=GitHub.copilot">Copilot extension</a> and
+						enable models in Copilot settings — but any extension that registers a language model provider will appear
+						here.
+					</p>
+				)}
+			</DropdownContainer>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/VercelAIGatewayProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/VercelAIGatewayProvider.tsx
new file mode 100644
index 0000000..70a28a5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/VercelAIGatewayProvider.tsx
@@ -0,0 +1,59 @@
+import { Mode } from "@shared/storage/types"
+import { VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import VercelModelPicker from "../VercelModelPicker"
+
+/**
+ * Props for the VercelAIGatewayProvider component
+ */
+interface VercelAIGatewayProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Vercel AI Gateway provider configuration component
+ */
+export const VercelAIGatewayProvider = ({ showModelOptions, isPopup, currentMode }: VercelAIGatewayProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleFieldChange } = useApiConfigurationHandlers()
+
+	return (
+		<div>
+			<div>
+				<DebouncedTextField
+					initialValue={apiConfiguration?.vercelAiGatewayApiKey || ""}
+					onChange={(value) => handleFieldChange("vercelAiGatewayApiKey", value)}
+					placeholder="Enter API Key..."
+					style={{ width: "100%" }}
+					type="password">
+					<span style={{ fontWeight: 500 }}>Vercel AI Gateway API Key</span>
+				</DebouncedTextField>
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: "5px",
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					This key is stored locally and only used to make API requests from this extension.
+					{!apiConfiguration?.vercelAiGatewayApiKey && (
+						<>
+							{" "}
+							You can get a Vercel AI Gateway API key by{" "}
+							<VSCodeLink
+								href="https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai"
+								style={{ display: "inline", fontSize: "inherit" }}>
+								signing up here.
+							</VSCodeLink>
+						</>
+					)}
+				</p>
+			</div>
+
+			{showModelOptions && <VercelModelPicker currentMode={currentMode} isPopup={isPopup} />}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/VertexProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/VertexProvider.tsx
new file mode 100644
index 0000000..bdf752a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/VertexProvider.tsx
@@ -0,0 +1,198 @@
+import VertexData from "@shared/providers/vertex.json"
+import type { Mode } from "@shared/storage/types"
+import { isClaudeOpusAdaptiveThinkingModel, resolveClaudeOpusAdaptiveThinking } from "@shared/utils/reasoning-support"
+import { VSCodeDropdown, VSCodeLink, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useMemo } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useProviderModels } from "@/hooks/useProviderModels"
+import { useProviderUsageCostDisplay } from "@/hooks/useProviderUsageCostDisplay"
+import { DROPDOWN_Z_INDEX, DropdownContainer } from "../ApiOptions"
+import { DebouncedTextField } from "../common/DebouncedTextField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { ModelSelector } from "../common/ModelSelector"
+import { LockIcon, RemotelyConfiguredInputWrapper } from "../common/RemotelyConfiguredInputWrapper"
+import ReasoningEffortSelector from "../ReasoningEffortSelector"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+import { getModeSpecificFields } from "../utils/providerUtils"
+
+/**
+ * Props for the VertexProvider component
+ */
+interface VertexProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+const REGIONS = VertexData.regions
+
+/**
+ * The GCP Vertex AI provider configuration component
+ */
+export const VertexProvider = ({ showModelOptions, isPopup, currentMode }: VertexProviderProps) => {
+	const { apiConfiguration, remoteConfigSettings } = useExtensionState()
+	const { models: allVertexModels, defaultModelId } = useProviderModels("vertex")
+	const { config, write, commitSelection } = useProviderConfig("vertex")
+	const { selectedModel, selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection(
+		"vertex",
+		currentMode,
+		{
+			models: allVertexModels,
+			defaultModelId,
+			config,
+			commitSelection,
+		},
+	)
+	const hideUsageCost = useProviderUsageCostDisplay("vertex") === "hide"
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+	const vertexProjectId = config?.gcp?.projectId ?? apiConfiguration?.vertexProjectId ?? ""
+	const vertexRegion = config?.gcp?.region ?? config?.region ?? apiConfiguration?.vertexRegion ?? ""
+
+	const writeProviderConfig = (patch: Parameters<typeof write>[0], label: string) => {
+		void write(patch).catch((err) => console.error(`Failed to update Vertex ${label}:`, err))
+	}
+	const writeGcp = (gcp: NonNullable<Parameters<typeof write>[0]["gcp"]>, label: string) => {
+		writeProviderConfig({ gcp }, label)
+	}
+
+	const handleProjectIdChange = (value: string) => {
+		writeGcp({ projectId: value }, "project ID")
+	}
+
+	const handleRegionChange = (value: string) => {
+		writeProviderConfig({ region: value, gcp: { region: value } }, "region")
+	}
+
+	// Catalog and selection come from the SDK via gRPC. Vertex carries a
+	// per-model `supportsGlobalEndpoint` flag (populated host-side from
+	// the allowlist in
+	// `apps/vscode/src/sdk/model-catalog/vertex-global-endpoint.ts`).
+	// When the user selects `vertexRegion === "global"` the picker is
+	// filtered to only models known to work with that endpoint so the
+	// runtime cannot produce a `model not available in region: global`
+	// error from a user-pickable combination.
+	const modelsToUse = useMemo(() => {
+		if (vertexRegion !== "global") {
+			return allVertexModels
+		}
+		return Object.fromEntries(Object.entries(allVertexModels).filter(([, info]) => info.supportsGlobalEndpoint === true))
+	}, [allVertexModels, vertexRegion])
+	const isAdaptiveThinkingModel = isClaudeOpusAdaptiveThinkingModel(selectedModelId)
+	const supportsThinkingBudget =
+		selectedModelInfo.supportsReasoning === true &&
+		selectedModelInfo.thinkingConfig !== undefined &&
+		selectedModelInfo.thinkingConfig.supportsThinkingLevel !== true
+	const adaptiveThinkingDefaultEffort =
+		resolveClaudeOpusAdaptiveThinking(modeFields.reasoningEffort, modeFields.thinkingBudgetTokens).effort ?? "none"
+
+	return (
+		<div
+			style={{
+				display: "flex",
+				flexDirection: "column",
+				gap: 5,
+			}}>
+			<RemotelyConfiguredInputWrapper hidden={remoteConfigSettings?.vertexProjectId === undefined}>
+				<DebouncedTextField
+					disabled={remoteConfigSettings?.vertexProjectId !== undefined}
+					initialValue={vertexProjectId}
+					onChange={handleProjectIdChange}
+					placeholder="Enter Project ID..."
+					style={{ width: "100%" }}>
+					<div className="flex items-center gap-2 mb-1">
+						<span style={{ fontWeight: 500 }}>Google Cloud Project ID</span>
+						{remoteConfigSettings?.vertexProjectId !== undefined && <LockIcon />}
+					</div>
+				</DebouncedTextField>
+			</RemotelyConfiguredInputWrapper>
+
+			<RemotelyConfiguredInputWrapper hidden={remoteConfigSettings?.vertexRegion === undefined}>
+				<DropdownContainer className="dropdown-container" zIndex={DROPDOWN_Z_INDEX - 1}>
+					<div
+						className="flex items-center gap-2 mb-1"
+						style={{ opacity: remoteConfigSettings?.vertexRegion !== undefined ? 0.4 : 1 }}>
+						<label htmlFor="vertex-region-dropdown">
+							<span className="font-medium">Google Cloud Region</span>
+						</label>
+						{remoteConfigSettings?.vertexRegion !== undefined && <LockIcon />}
+					</div>
+					<VSCodeDropdown
+						disabled={remoteConfigSettings?.vertexRegion !== undefined}
+						id="vertex-region-dropdown"
+						onChange={(e: any) => handleRegionChange(e.target.value)}
+						style={{ width: "100%" }}
+						value={vertexRegion}>
+						<VSCodeOption value="">Select a region...</VSCodeOption>
+						{REGIONS.map((region) => (
+							<VSCodeOption key={region} value={region}>
+								{region}
+							</VSCodeOption>
+						))}
+					</VSCodeDropdown>
+				</DropdownContainer>
+			</RemotelyConfiguredInputWrapper>
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: "5px",
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				To use Google Cloud Vertex AI, you need to
+				<VSCodeLink
+					href="https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-claude#before_you_begin"
+					style={{ display: "inline", fontSize: "inherit" }}>
+					{"1) create a Google Cloud account › enable the Vertex AI API › enable the desired Claude models,"}
+				</VSCodeLink>{" "}
+				<VSCodeLink
+					href="https://cloud.google.com/docs/authentication/provide-credentials-adc#google-idp"
+					style={{ display: "inline", fontSize: "inherit" }}>
+					{"2) install the Google Cloud CLI › configure Application Default Credentials."}
+				</VSCodeLink>
+			</p>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={modelsToUse}
+						onChange={(e: any) => {
+							const modelId = e.target.value
+							void commitModelSelection({
+								modelId,
+								modelInfo: modelsToUse[modelId] ?? selectedModel.modelInfo,
+							}).catch((err) => console.error("Failed to commit Vertex model selection:", err))
+						}}
+						selectedModelId={selectedModelId}
+						zIndex={DROPDOWN_Z_INDEX - 2}
+					/>
+
+					{isAdaptiveThinkingModel ? (
+						<ReasoningEffortSelector
+							allowedEfforts={["none", "low", "medium", "high", "xhigh"] as const}
+							currentMode={currentMode}
+							defaultEffort={adaptiveThinkingDefaultEffort}
+							description="Use None to disable adaptive thinking. Higher effort increases response detail and token usage."
+							label="Adaptive Thinking"
+						/>
+					) : supportsThinkingBudget ? (
+						<ThinkingBudgetSlider currentMode={currentMode} maxBudget={selectedModelInfo.thinkingConfig?.maxBudget} />
+					) : null}
+
+					{selectedModelInfo.thinkingConfig?.supportsThinkingLevel && (
+						<ReasoningEffortSelector currentMode={currentMode} />
+					)}
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/XaiProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/XaiProvider.tsx
new file mode 100644
index 0000000..28b72fa
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/XaiProvider.tsx
@@ -0,0 +1,183 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { VSCodeCheckbox, VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { DROPDOWN_Z_INDEX } from "../ApiOptions"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { DropdownContainer, ModelSelector } from "../common/ModelSelector"
+import { getModeSpecificFields } from "../utils/providerUtils"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+const PROVIDER_ID = "xai"
+
+// VSCodeDropdown's onChange supplies `Event | React.FormEvent<HTMLElement>`,
+// so accept the same union here. We only read `target.value`, which is present
+// on both, so no narrowing of the event itself is required.
+function getEventValue(event: Event | React.FormEvent<HTMLElement>): string {
+	const target = event.target
+	if (target && "value" in target && typeof target.value === "string") {
+		return target.value
+	}
+	return ""
+}
+
+/**
+ * Props for the XaiProvider component
+ */
+interface XaiProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+export const XaiProvider = ({ showModelOptions, isPopup, currentMode }: XaiProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { handleModeFieldChange } = useApiConfigurationHandlers()
+	const { config, write, commitSelection } = useProviderConfig(PROVIDER_ID)
+
+	const modeFields = getModeSpecificFields(apiConfiguration, currentMode)
+
+	// Get the normalized configuration
+	const {
+		models,
+		defaultModelId,
+		selectedModelId: legacySelectedModelId,
+		selectedModelInfo: legacySelectedModelInfo,
+		hideUsageCost,
+	} = useStaticProviderSelection(PROVIDER_ID, apiConfiguration, currentMode)
+	const { selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection(PROVIDER_ID, currentMode, {
+		models,
+		defaultModelId: legacySelectedModelId,
+		config,
+		commitSelection,
+		fallbackModelInfo: legacySelectedModelInfo,
+	})
+
+	// Local state for reasoning effort toggle
+	const [reasoningEffortSelected, setReasoningEffortSelected] = useState(!!modeFields.reasoningEffort)
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		providerName: "X AI",
+		write,
+	})
+
+	const handleModelChange = (modelId: string) => {
+		if (!modelId) {
+			return
+		}
+
+		const fallbackModelId = defaultModelId || Object.keys(models)[0] || modelId
+		const modelInfo = models[modelId] ?? models[fallbackModelId] ?? selectedModelInfo ?? openAiModelInfoSafeDefaults
+
+		void commitModelSelection({
+			modelId,
+			modelInfo,
+		}).catch((err) => console.error("Failed to commit X AI model selection:", err))
+	}
+
+	const handleReasoningEffortChange = (effort: string) => {
+		void write({ reasoning: { enabled: true, effort } }).catch((err) =>
+			console.error("Failed to update X AI reasoning effort:", err),
+		)
+		handleModeFieldChange({ plan: "planModeReasoningEffort", act: "actModeReasoningEffort" }, effort, currentMode)
+	}
+
+	const handleReasoningEffortDisabled = () => {
+		void write({ reasoning: { enabled: false, effort: "none" } }).catch((err) =>
+			console.error("Failed to disable X AI reasoning effort:", err),
+		)
+		handleModeFieldChange({ plan: "planModeReasoningEffort", act: "actModeReasoningEffort" }, "", currentMode)
+	}
+
+	return (
+		<div>
+			<div>
+				<ApiKeyField
+					initialValue={savedApiKeyMask || apiConfiguration?.xaiApiKey || ""}
+					onChange={handleApiKeyChange}
+					providerName="X AI"
+					signupUrl="https://x.ai"
+				/>
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: -10,
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					<span style={{ color: "var(--vscode-errorForeground)" }}>
+						(<span style={{ fontWeight: 500 }}>Note:</span> Cline uses complex prompts, so behavior can vary across
+						models. Less capable models may not work as expected.)
+					</span>
+				</p>
+			</div>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(event: Event) => handleModelChange(getEventValue(event))}
+						selectedModelId={selectedModelId}
+					/>
+
+					{selectedModelId && selectedModelId.includes("3-mini") && (
+						<>
+							<VSCodeCheckbox
+								checked={reasoningEffortSelected}
+								onChange={(e: any) => {
+									const isChecked = e.target.checked === true
+									setReasoningEffortSelected(isChecked)
+									if (!isChecked) {
+										handleReasoningEffortDisabled()
+									}
+								}}
+								style={{ marginTop: 0 }}>
+								Modify reasoning effort
+							</VSCodeCheckbox>
+
+							{reasoningEffortSelected && (
+								<div>
+									<label htmlFor="reasoning-effort-dropdown">
+										<span style={{}}>Reasoning Effort</span>
+									</label>
+									<DropdownContainer className="dropdown-container" zIndex={DROPDOWN_Z_INDEX - 100}>
+										<VSCodeDropdown
+											id="reasoning-effort-dropdown"
+											onChange={(event) => handleReasoningEffortChange(getEventValue(event))}
+											style={{ width: "100%", marginTop: 3 }}
+											value={modeFields.reasoningEffort || "high"}>
+											<VSCodeOption value="low">low</VSCodeOption>
+											<VSCodeOption value="high">high</VSCodeOption>
+										</VSCodeDropdown>
+									</DropdownContainer>
+									<p
+										style={{
+											fontSize: "12px",
+											marginTop: 3,
+											marginBottom: 0,
+											color: "var(--vscode-descriptionForeground)",
+										}}>
+										High effort may produce more thorough analysis but takes longer and uses more tokens.
+									</p>
+								</div>
+							)}
+						</>
+					)}
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/ZAiProvider.tsx b/apps/vscode/webview-ui/src/components/settings/providers/ZAiProvider.tsx
new file mode 100644
index 0000000..c074e94
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/ZAiProvider.tsx
@@ -0,0 +1,142 @@
+import { openAiModelInfoSafeDefaults } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { VSCodeDropdown, VSCodeOption } from "@vscode/webview-ui-toolkit/react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useProviderConfig } from "@/hooks/useProviderConfig"
+import { useProviderModelSelection } from "@/hooks/useProviderModelSelection"
+import { useStaticProviderSelection } from "@/hooks/useStaticProviderSelection"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { DropdownContainer, ModelSelector } from "../common/ModelSelector"
+import { useProviderApiKeyField } from "../utils/useProviderApiKeyField"
+
+const PROVIDER_ID = "zai"
+
+// VSCodeDropdown's onChange supplies `Event | React.FormEvent<HTMLElement>`,
+// so accept the same union here. We only read `target.value`, which is present
+// on both, so no narrowing of the event itself is required.
+function getEventValue(event: Event | React.FormEvent<HTMLElement>): string {
+	const target = event.target
+	if (target && "value" in target && typeof target.value === "string") {
+		return target.value
+	}
+	return ""
+}
+
+/**
+ * Props for the ZAiProvider component
+ */
+interface ZAiProviderProps {
+	showModelOptions: boolean
+	isPopup?: boolean
+	currentMode: Mode
+}
+
+/**
+ * The Z AI provider configuration component.
+ *
+ * Model catalog and default come from the `@cline/llms` SDK via gRPC.
+ * The SDK consumes `apiLine` from the effective provider config so the
+ * international vs. mainland catalog selection happens upstream — the
+ * webview sees a single catalog per render.
+ */
+export const ZAiProvider = ({ showModelOptions, isPopup, currentMode }: ZAiProviderProps) => {
+	const { apiConfiguration } = useExtensionState()
+	const { config, write, commitSelection } = useProviderConfig(PROVIDER_ID)
+	const {
+		models,
+		defaultModelId,
+		selectedModelId: legacySelectedModelId,
+		selectedModelInfo: legacySelectedModelInfo,
+		hideUsageCost,
+	} = useStaticProviderSelection(PROVIDER_ID, apiConfiguration, currentMode)
+	const { selectedModelId, selectedModelInfo, commitModelSelection } = useProviderModelSelection(PROVIDER_ID, currentMode, {
+		models,
+		defaultModelId: legacySelectedModelId,
+		config,
+		commitSelection,
+		fallbackModelInfo: legacySelectedModelInfo,
+	})
+	const selectedEntrypoint = config?.apiLine || apiConfiguration?.zaiApiLine || "international"
+	const { savedApiKeyMask, handleApiKeyChange } = useProviderApiKeyField({
+		apiKeyLength: config?.apiKeyLength,
+		providerName: "Z AI",
+		write,
+	})
+
+	const handleApiLineChange = (value: string) => {
+		void write({ apiLine: value }).catch((err) => console.error("Failed to update Z AI entrypoint:", err))
+	}
+
+	const handleModelChange = (modelId: string) => {
+		if (!modelId) {
+			return
+		}
+
+		const fallbackModelId = defaultModelId || Object.keys(models)[0] || modelId
+		const modelInfo = models[modelId] ?? models[fallbackModelId] ?? selectedModelInfo ?? openAiModelInfoSafeDefaults
+
+		void commitModelSelection({
+			modelId,
+			modelInfo,
+		}).catch((err) => console.error("Failed to commit Z AI model selection:", err))
+	}
+
+	return (
+		<div>
+			<DropdownContainer className="dropdown-container" style={{ position: "inherit" }}>
+				<label htmlFor="zai-entrypoint">
+					<span style={{ fontWeight: 500, marginTop: 5 }}>Z AI Entrypoint</span>
+				</label>
+				<VSCodeDropdown
+					id="zai-entrypoint"
+					onChange={(event) => handleApiLineChange(getEventValue(event))}
+					style={{
+						minWidth: 130,
+						position: "relative",
+					}}
+					value={selectedEntrypoint}>
+					<VSCodeOption value="international">api.z.ai</VSCodeOption>
+					<VSCodeOption value="china">open.bigmodel.cn</VSCodeOption>
+				</VSCodeDropdown>
+			</DropdownContainer>
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				Please select the appropriate API entrypoint based on your location. If you are in China, choose open.bigmodel.cn
+				. Otherwise, choose api.z.ai.
+			</p>
+			<ApiKeyField
+				initialValue={savedApiKeyMask || apiConfiguration?.zaiApiKey || ""}
+				onChange={handleApiKeyChange}
+				providerName="Z AI"
+				signupUrl={
+					selectedEntrypoint === "china"
+						? "https://open.bigmodel.cn/console/overview"
+						: "https://z.ai/manage-apikey/apikey-list"
+				}
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						label="Model"
+						models={models}
+						onChange={(event: Event) => handleModelChange(getEventValue(event))}
+						selectedModelId={selectedModelId}
+					/>
+
+					<ModelInfoView
+						hideUsageCost={hideUsageCost}
+						isPopup={isPopup}
+						modelInfo={selectedModelInfo}
+						selectedModelId={selectedModelId}
+					/>
+				</>
+			)}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/providerSettingsRegistry.test.ts b/apps/vscode/webview-ui/src/components/settings/providers/providerSettingsRegistry.test.ts
new file mode 100644
index 0000000..de54f5e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/providerSettingsRegistry.test.ts
@@ -0,0 +1,186 @@
+import type { ProviderListing } from "@shared/proto/cline/models"
+import { describe, expect, it } from "vitest"
+import {
+	getFallbackGenericProviderSettings,
+	getGenericProviderSettings,
+	hasCustomProviderSettings,
+	isGenericProviderListing,
+} from "./providerSettingsRegistry"
+
+function listing(overrides: Partial<ProviderListing>): ProviderListing {
+	return {
+		allowsCustomModelIds: false,
+		id: "deepseek",
+		name: "DeepSeek",
+		protocol: "openai-chat",
+		...overrides,
+	}
+}
+
+describe("providerSettingsRegistry", () => {
+	it("builds DeepSeek generic settings from SDK provider-listing metadata", () => {
+		expect(getGenericProviderSettings("deepseek", listing({ id: "deepseek", name: "DeepSeek" }))).toEqual({
+			allowsCustomIds: false,
+			providerId: "deepseek",
+			providerName: "DeepSeek",
+			signupUrl: "https://www.deepseek.com/",
+		})
+	})
+
+	it("builds Gemini generic settings from provider-listing metadata plus presentation overrides", () => {
+		expect(
+			getGenericProviderSettings(
+				"gemini",
+				listing({ id: "gemini", name: "Google Gemini", protocol: "gemini", allowsCustomModelIds: false }),
+			),
+		).toEqual({
+			allowsCustomIds: false,
+			providerId: "gemini",
+			providerName: "Google Gemini",
+			signupUrl: "https://aistudio.google.com/apikey",
+		})
+	})
+
+	it("keeps provider-specific UIs as explicit custom overrides", () => {
+		expect(hasCustomProviderSettings("openai")).toBe(true)
+		expect(hasCustomProviderSettings("deepseek")).toBe(false)
+		expect(hasCustomProviderSettings("groq")).toBe(false)
+		expect(hasCustomProviderSettings("cerebras")).toBe(false)
+		expect(hasCustomProviderSettings("minimax")).toBe(false)
+		expect(hasCustomProviderSettings("together")).toBe(false)
+		expect(getGenericProviderSettings("openai", listing({ id: "openai", name: "OpenAI" }))).toBeUndefined()
+	})
+
+	it("allows migrated simple SDK providers to use the generic fallback", () => {
+		const migratedProviders = [
+			["baseten", "Baseten", "https://app.baseten.co/settings/api_keys"],
+			["cerebras", "Cerebras", "https://cloud.cerebras.ai/"],
+			["doubao", "Doubao", "https://console.volcengine.com/home"],
+			["fireworks", "Fireworks", "https://fireworks.ai/"],
+			["groq", "Groq", "https://console.groq.com/keys"],
+			[
+				"huawei-cloud-maas",
+				"Huawei Cloud MaaS",
+				"https://support.huaweicloud.com/intl/zh-cn/usermanual-maas/maas_01_0001.html",
+			],
+			["huggingface", "Hugging Face", "https://huggingface.co/settings/tokens"],
+			["mistral", "Mistral", "https://console.mistral.ai/codestral"],
+			["nebius", "Nebius", "https://auth.tokenfactory.nebius.com/ui/login"],
+			["nousResearch", "NousResearch", undefined],
+			["poolside", "Poolside", undefined],
+			["sambanova", "SambaNova", "https://docs.sambanova.ai/cloud/docs/get-started/overview"],
+			["tencent-tokenhub", "Tencent TokenHub", "https://cloud.tencent.com/document/product/1823/130050"],
+			["vercel-ai-gateway", "Vercel AI Gateway", "https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai"],
+			["v0", "Vercel v0", undefined],
+			["wandb", "W&B", "https://wandb.ai"],
+			["xiaomi", "Xiaomi", undefined],
+			["zai-coding-plan", "Z.AI Coding Plan", undefined],
+		] as const
+
+		for (const [providerId, providerName, signupUrl] of migratedProviders) {
+			expect(hasCustomProviderSettings(providerId)).toBe(false)
+			expect(getGenericProviderSettings(providerId, listing({ id: providerId, name: providerName }))).toEqual({
+				allowsCustomIds: false,
+				providerId,
+				providerName,
+				...(signupUrl ? { signupUrl } : {}),
+			})
+		}
+	})
+
+	it("builds MiniMax and Together settings through the generic registry", () => {
+		expect(
+			getGenericProviderSettings(
+				"minimax",
+				listing({ id: "minimax", name: "MiniMax", protocol: "anthropic", allowsCustomModelIds: false }),
+			),
+		).toEqual({
+			allowsCustomIds: false,
+			baseUrlField: {
+				label: "Base URL",
+				placeholder: "https://api.minimax.io/anthropic",
+			},
+			providerId: "minimax",
+			providerName: "MiniMax",
+			signupUrl: "https://www.minimax.io/platform/user-center/basic-information/interface-key",
+		})
+		expect(
+			getGenericProviderSettings(
+				"together",
+				listing({ id: "together", name: "Together AI", protocol: "openai-chat", allowsCustomModelIds: false }),
+			),
+		).toEqual({
+			allowsCustomIds: true,
+			baseUrlField: {
+				label: "Base URL",
+				placeholder: "https://api.together.xyz/v1",
+			},
+			providerId: "together",
+			providerName: "Together AI",
+			signupUrl: "https://api.together.ai/settings/api-keys",
+		})
+	})
+
+	it("allows future simple SDK providers to use the generic fallback", () => {
+		const futureProvider = listing({
+			allowsCustomModelIds: true,
+			id: "future-simple-provider",
+			name: "Future Simple Provider",
+			protocol: "openai-chat",
+		})
+
+		expect(isGenericProviderListing(futureProvider)).toBe(true)
+		expect(getGenericProviderSettings("future-simple-provider", futureProvider)).toEqual({
+			allowsCustomIds: true,
+			providerId: "future-simple-provider",
+			providerName: "Future Simple Provider",
+		})
+	})
+
+	it("requires listing metadata that proves the provider has a supported simple protocol", () => {
+		expect(
+			getGenericProviderSettings("unknown", listing({ id: "unknown", name: "Unknown", protocol: undefined })),
+		).toBeUndefined()
+		expect(
+			getGenericProviderSettings("unknown", listing({ id: "unknown", name: "Unknown", protocol: "custom" })),
+		).toBeUndefined()
+		expect(
+			getGenericProviderSettings("other", listing({ id: "unknown", name: "Unknown", protocol: "openai-chat" })),
+		).toBeUndefined()
+	})
+
+	it("keeps static fallback metadata for generic providers that can render before listings load", () => {
+		expect(getFallbackGenericProviderSettings("deepseek")).toEqual({
+			allowsCustomIds: false,
+			providerId: "deepseek",
+			providerName: "DeepSeek",
+			signupUrl: "https://www.deepseek.com/",
+		})
+		expect(getFallbackGenericProviderSettings("minimax")).toEqual({
+			allowsCustomIds: false,
+			baseUrlField: {
+				label: "Base URL",
+				placeholder: "https://api.minimax.io/anthropic",
+			},
+			providerId: "minimax",
+			providerName: "MiniMax",
+			signupUrl: "https://www.minimax.io/platform/user-center/basic-information/interface-key",
+		})
+		expect(getFallbackGenericProviderSettings("together")).toEqual({
+			allowsCustomIds: true,
+			baseUrlField: {
+				label: "Base URL",
+				placeholder: "https://api.together.xyz/v1",
+			},
+			providerId: "together",
+			providerName: "Together",
+			signupUrl: "https://api.together.ai/settings/api-keys",
+		})
+		expect(getFallbackGenericProviderSettings("zai-coding-plan")).toEqual({
+			allowsCustomIds: false,
+			providerId: "zai-coding-plan",
+			providerName: "Z.AI Coding Plan",
+		})
+		expect(getFallbackGenericProviderSettings("openai")).toBeUndefined()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/providers/providerSettingsRegistry.ts b/apps/vscode/webview-ui/src/components/settings/providers/providerSettingsRegistry.ts
new file mode 100644
index 0000000..e3f6660
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/providers/providerSettingsRegistry.ts
@@ -0,0 +1,181 @@
+import type { ProviderListing } from "@shared/proto/cline/models"
+import type { GenericProviderSettingsProps } from "./GenericProviderSettings"
+
+type GenericProviderSettingsConfig = Omit<GenericProviderSettingsProps, "currentMode" | "isPopup" | "showModelOptions">
+
+type GenericProviderPresentationOverride = Pick<GenericProviderSettingsConfig, "signupUrl" | "baseUrlField"> &
+	Partial<Pick<GenericProviderSettingsConfig, "allowsCustomIds">>
+
+const CUSTOM_PROVIDER_SETTINGS_IDS = new Set([
+	"aihubmix",
+	"anthropic",
+	"asksage",
+	"bedrock",
+	"claude-code",
+	"cline",
+	"cline-pass",
+	"dify",
+	"hicap",
+	"litellm",
+	"lmstudio",
+	"moonshot",
+	"oca",
+	"ollama",
+	"openai",
+	"openai-codex",
+	"openai-native",
+	"openrouter",
+	"qwen",
+	"qwen-code",
+	"requesty",
+	"sapaicore",
+	"vertex",
+	"vscode-lm",
+	"xai",
+	"zai",
+])
+
+const GENERIC_PROVIDER_PRESENTATION_OVERRIDES: Record<string, GenericProviderPresentationOverride> = {
+	baseten: {
+		signupUrl: "https://app.baseten.co/settings/api_keys",
+	},
+	deepseek: {
+		signupUrl: "https://www.deepseek.com/",
+	},
+	doubao: {
+		signupUrl: "https://console.volcengine.com/home",
+	},
+	fireworks: {
+		signupUrl: "https://fireworks.ai/",
+	},
+	groq: {
+		signupUrl: "https://console.groq.com/keys",
+	},
+	poolside: {},
+	cerebras: {
+		signupUrl: "https://cloud.cerebras.ai/",
+	},
+	gemini: {
+		signupUrl: "https://aistudio.google.com/apikey",
+	},
+	huggingface: {
+		signupUrl: "https://huggingface.co/settings/tokens",
+	},
+	"huawei-cloud-maas": {
+		signupUrl: "https://support.huaweicloud.com/intl/zh-cn/usermanual-maas/maas_01_0001.html",
+	},
+	minimax: {
+		signupUrl: "https://www.minimax.io/platform/user-center/basic-information/interface-key",
+		baseUrlField: {
+			label: "Base URL",
+			placeholder: "https://api.minimax.io/anthropic",
+		},
+	},
+	mistral: {
+		signupUrl: "https://console.mistral.ai/codestral",
+	},
+	nebius: {
+		signupUrl: "https://auth.tokenfactory.nebius.com/ui/login",
+	},
+	nousResearch: {},
+	sambanova: {
+		signupUrl: "https://docs.sambanova.ai/cloud/docs/get-started/overview",
+	},
+	together: {
+		allowsCustomIds: true,
+		signupUrl: "https://api.together.ai/settings/api-keys",
+		baseUrlField: {
+			label: "Base URL",
+			placeholder: "https://api.together.xyz/v1",
+		},
+	},
+	"vercel-ai-gateway": {
+		signupUrl: "https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai",
+	},
+	v0: {},
+	wandb: {
+		signupUrl: "https://wandb.ai",
+	},
+	xiaomi: {},
+	"tencent-tokenhub": {
+		signupUrl: "https://cloud.tencent.com/document/product/1823/130050",
+	},
+	"zai-coding-plan": {},
+}
+
+const GENERIC_PROVIDER_PROTOCOLS = new Set(["anthropic", "gemini", "openai-chat", "openai-responses"])
+
+export function hasCustomProviderSettings(providerId: string): boolean {
+	return CUSTOM_PROVIDER_SETTINGS_IDS.has(providerId)
+}
+
+/**
+ * True when we ship a curated "generic" settings form for this provider id
+ * (presentation override or fallback name). Providers that are neither here nor
+ * in {@link hasCustomProviderSettings} are user-configured/custom and should use
+ * the richer OpenAI-compatible form instead.
+ */
+export function isKnownGenericProvider(providerId: string): boolean {
+	return providerId in GENERIC_PROVIDER_PRESENTATION_OVERRIDES || providerId in FALLBACK_GENERIC_PROVIDER_NAMES
+}
+
+export function isGenericProviderListing(listing: ProviderListing | undefined): listing is ProviderListing {
+	if (!listing) {
+		return false
+	}
+
+	return (
+		!hasCustomProviderSettings(listing.id) && Boolean(listing.name) && GENERIC_PROVIDER_PROTOCOLS.has(listing.protocol ?? "")
+	)
+}
+
+export function getGenericProviderSettings(
+	providerId: string,
+	listing?: ProviderListing,
+): GenericProviderSettingsConfig | undefined {
+	if (!isGenericProviderListing(listing) || listing.id !== providerId) {
+		return undefined
+	}
+
+	const overrides = GENERIC_PROVIDER_PRESENTATION_OVERRIDES[providerId]
+
+	return {
+		...overrides,
+		allowsCustomIds: overrides?.allowsCustomIds ?? listing.allowsCustomModelIds,
+		providerId: listing.id,
+		providerName: listing.name,
+	}
+}
+
+const FALLBACK_GENERIC_PROVIDER_NAMES = {
+	deepseek: "DeepSeek",
+	doubao: "Doubao",
+	gemini: "Gemini",
+	"huawei-cloud-maas": "Huawei Cloud MaaS",
+	minimax: "MiniMax",
+	mistral: "Mistral",
+	nousResearch: "NousResearch",
+	poolside: "Poolside",
+	together: "Together",
+	v0: "Vercel v0",
+	wandb: "W&B",
+	xiaomi: "Xiaomi",
+	"tencent-tokenhub": "Tencent TokenHub",
+	"zai-coding-plan": "Z.AI Coding Plan",
+} as const
+
+export function getFallbackGenericProviderSettings(providerId: string): GenericProviderSettingsConfig | undefined {
+	const providerName = FALLBACK_GENERIC_PROVIDER_NAMES[providerId as keyof typeof FALLBACK_GENERIC_PROVIDER_NAMES]
+	if (!providerName) {
+		return undefined
+	}
+
+	const overrides = GENERIC_PROVIDER_PRESENTATION_OVERRIDES[providerId]
+
+	return {
+		...overrides,
+		allowsCustomIds: overrides?.allowsCustomIds ?? false,
+		providerId,
+		providerName,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/AboutSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/AboutSection.tsx
new file mode 100644
index 0000000..6e84d53
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/AboutSection.tsx
@@ -0,0 +1,54 @@
+import { VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import Section from "../Section"
+
+interface AboutSectionProps {
+	version: string
+	renderSectionHeader: (tabId: string) => JSX.Element | null
+}
+const AboutSection = ({ version, renderSectionHeader }: AboutSectionProps) => {
+	return (
+		<div>
+			{renderSectionHeader("about")}
+			<Section>
+				<div className="flex px-4 flex-col gap-2">
+					<h2 className="text-lg font-semibold">Cline v{version}</h2>
+					<p>
+						An AI assistant that can use your CLI and Editor. Cline can handle complex software development tasks
+						step-by-step with tools that let him create & edit files, explore large projects, use the browser, and
+						execute terminal commands (after you grant permission).
+					</p>
+
+					<h3 className="text-md font-semibold">Community & Support</h3>
+					<p>
+						<VSCodeLink href="https://x.com/cline">X</VSCodeLink>
+						{" • "}
+						<VSCodeLink href="https://discord.gg/cline">Discord</VSCodeLink>
+						{" • "}
+						<VSCodeLink href="https://www.reddit.com/r/cline/"> r/cline</VSCodeLink>
+					</p>
+
+					<h3 className="text-md font-semibold">Development</h3>
+					<p>
+						<VSCodeLink href="https://github.com/cline/cline">GitHub</VSCodeLink>
+						{" • "}
+						<VSCodeLink href="https://github.com/cline/cline/issues"> Issues</VSCodeLink>
+						{" • "}
+						<VSCodeLink href="https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop">
+							{" "}
+							Feature Requests
+						</VSCodeLink>
+					</p>
+
+					<h3 className="text-md font-semibold">Resources</h3>
+					<p>
+						<VSCodeLink href="https://docs.cline.bot/">Documentation</VSCodeLink>
+						{" • "}
+						<VSCodeLink href="https://cline.bot/">https://cline.bot</VSCodeLink>
+					</p>
+				</div>
+			</Section>
+		</div>
+	)
+}
+
+export default AboutSection
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/ApiConfigurationSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/ApiConfigurationSection.tsx
new file mode 100644
index 0000000..99cf8b5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/ApiConfigurationSection.tsx
@@ -0,0 +1,93 @@
+import { UpdateSettingsRequest } from "@shared/proto/cline/state"
+import { Mode } from "@shared/storage/types"
+import { VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { useState } from "react"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { StateServiceClient } from "@/services/grpc-client"
+import { TabButton } from "../../mcp/configuration/McpConfigurationView"
+import ApiOptions from "../ApiOptions"
+import Section from "../Section"
+import { syncModeConfigurations } from "../utils/providerUtils"
+import { useApiConfigurationHandlers } from "../utils/useApiConfigurationHandlers"
+
+interface ApiConfigurationSectionProps {
+	renderSectionHeader?: (tabId: string) => JSX.Element | null
+	initialModelTab?: "recommended" | "free"
+}
+
+const ApiConfigurationSection = ({ renderSectionHeader, initialModelTab }: ApiConfigurationSectionProps) => {
+	const { planActSeparateModelsSetting, mode, apiConfiguration } = useExtensionState()
+	const [currentTab, setCurrentTab] = useState<Mode>(mode)
+	const { handleFieldsChange } = useApiConfigurationHandlers()
+	return (
+		<div>
+			{renderSectionHeader?.("api-config")}
+			<Section>
+				{/* Tabs container */}
+				{planActSeparateModelsSetting ? (
+					<div className="rounded-md mb-5">
+						<div className="flex gap-px mb-[10px] -mt-2 border-0 border-b border-solid border-(--vscode-panel-border)">
+							<TabButton
+								disabled={currentTab === "plan"}
+								isActive={currentTab === "plan"}
+								onClick={() => setCurrentTab("plan")}
+								style={{
+									opacity: 1,
+									cursor: "pointer",
+								}}>
+								Plan Mode
+							</TabButton>
+							<TabButton
+								disabled={currentTab === "act"}
+								isActive={currentTab === "act"}
+								onClick={() => setCurrentTab("act")}
+								style={{
+									opacity: 1,
+									cursor: "pointer",
+								}}>
+								Act Mode
+							</TabButton>
+						</div>
+
+						{/* Content container */}
+						<div className="-mb-3">
+							<ApiOptions currentMode={currentTab} initialModelTab={initialModelTab} showModelOptions={true} />
+						</div>
+					</div>
+				) : (
+					<ApiOptions currentMode={mode} initialModelTab={initialModelTab} showModelOptions={true} />
+				)}
+
+				<div className="mb-[5px]">
+					<VSCodeCheckbox
+						checked={planActSeparateModelsSetting}
+						className="mb-[5px]"
+						onChange={async (e: any) => {
+							const checked = e.target.checked === true
+							try {
+								// If unchecking the toggle, wait a bit for state to update, then sync configurations
+								if (!checked) {
+									await syncModeConfigurations(apiConfiguration, currentTab, handleFieldsChange)
+								}
+								await StateServiceClient.updateSettings(
+									UpdateSettingsRequest.create({
+										planActSeparateModelsSetting: checked,
+									}),
+								)
+							} catch (error) {
+								console.error("Failed to update separate models setting:", error)
+							}
+						}}>
+						Use different models for Plan and Act modes
+					</VSCodeCheckbox>
+					<p className="text-xs mt-[5px] text-(--vscode-descriptionForeground)">
+						Switching between Plan and Act mode will persist the API and model used in the previous mode. This may be
+						helpful e.g. when using a strong reasoning model to architect a plan for a cheaper coding model to act on.
+					</p>
+				</div>
+			</Section>
+		</div>
+	)
+}
+
+export default ApiConfigurationSection
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/DebugSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/DebugSection.tsx
new file mode 100644
index 0000000..933c563
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/DebugSection.tsx
@@ -0,0 +1,42 @@
+import { Button } from "@/components/ui/button"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { StateServiceClient } from "@/services/grpc-client"
+import Section from "../Section"
+
+interface DebugSectionProps {
+	onResetState: (resetGlobalState?: boolean) => Promise<void>
+	renderSectionHeader: (tabId: string) => JSX.Element | null
+}
+
+const DebugSection = ({ onResetState, renderSectionHeader }: DebugSectionProps) => {
+	const { setShowWelcome } = useExtensionState()
+	return (
+		<div>
+			{renderSectionHeader("debug")}
+			<Section>
+				<Button onClick={() => onResetState()} variant="error">
+					Reset Workspace State
+				</Button>
+				<Button onClick={() => onResetState(true)} variant="error">
+					Reset Global State
+				</Button>
+				<p className="text-xs mt-[5px] text-(--vscode-descriptionForeground)">
+					This will reset all global state and secret storage in the extension.
+				</p>
+			</Section>
+			<Section>
+				<Button
+					onClick={async () =>
+						await StateServiceClient.setWelcomeViewCompleted({ value: false })
+							.catch(() => {})
+							.finally(() => setShowWelcome(true))
+					}
+					variant="secondary">
+					Reset Onboarding State
+				</Button>
+			</Section>
+		</div>
+	)
+}
+
+export default DebugSection
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/FeatureSettingsSection.spec.tsx b/apps/vscode/webview-ui/src/components/settings/sections/FeatureSettingsSection.spec.tsx
new file mode 100644
index 0000000..52bcff3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/FeatureSettingsSection.spec.tsx
@@ -0,0 +1,102 @@
+import { fireEvent, render, screen } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import FeatureSettingsSection from "./FeatureSettingsSection"
+
+const mockUpdateSetting = vi.fn()
+const mockExtensionState = vi.hoisted(() => ({
+	value: {
+		enableCheckpointsSetting: true,
+		hooksEnabled: false,
+		showFeatureTips: false,
+		mcpDisplayMode: "rich",
+		yoloModeToggled: false,
+		useAutoCondense: false,
+		compactionStrategy: "basic",
+		subagentsEnabled: false,
+		worktreesEnabled: { user: true, featureFlag: true },
+		focusChainSettings: { enabled: false, remindClineInterval: 6 },
+		remoteConfigSettings: {},
+		backgroundEditEnabled: false,
+	},
+}))
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: vi.fn(() => mockExtensionState.value),
+}))
+
+vi.mock("../utils/settingsHandlers", () => ({
+	updateSetting: (...args: unknown[]) => mockUpdateSetting(...args),
+}))
+
+describe("FeatureSettingsSection", () => {
+	beforeEach(() => {
+		mockUpdateSetting.mockClear()
+		mockExtensionState.value = {
+			...mockExtensionState.value,
+			useAutoCondense: false,
+			compactionStrategy: "basic",
+		}
+	})
+
+	it("renders Hooks feature toggle", () => {
+		const { container } = render(<FeatureSettingsSection renderSectionHeader={() => null} />)
+
+		expect(screen.getByText("Hooks")).toBeTruthy()
+
+		const advancedSection = container.querySelector("#advanced-features")
+		const agentSection = container.querySelector("#agent-features")
+
+		expect(advancedSection?.querySelector("#Hooks")).toBeTruthy()
+		expect(agentSection?.querySelector("#Hooks")).toBeNull()
+	})
+
+	it("renders Feature Tips toggle in the Editor section", () => {
+		const { container } = render(<FeatureSettingsSection renderSectionHeader={() => null} />)
+
+		expect(screen.getByText("Feature Tips")).toBeTruthy()
+
+		const editorSection = container.querySelector("#optional-features")
+		const agentSection = container.querySelector("#agent-features")
+
+		expect(editorSection?.querySelector('[id="Feature Tips"]')).toBeTruthy()
+		expect(agentSection?.querySelector('[id="Feature Tips"]')).toBeNull()
+	})
+
+	it("renders the Auto Compact Strategy setting in the Agent section", () => {
+		const { container } = render(<FeatureSettingsSection renderSectionHeader={() => null} />)
+
+		expect(screen.getByText("Auto Compact Strategy")).toBeTruthy()
+
+		const agentSection = container.querySelector("#agent-features")
+		expect(agentSection?.textContent).toContain("Basic")
+	})
+
+	it("disables Auto Compact Strategy when Auto Compact is off", () => {
+		const { container } = render(<FeatureSettingsSection renderSectionHeader={() => null} />)
+
+		const strategySelect = container.querySelector("#agent-features button[role='combobox']")
+		expect(strategySelect).toHaveAttribute("disabled")
+	})
+
+	it("calls updateSetting with hooksEnabled when toggled", () => {
+		const { container } = render(<FeatureSettingsSection renderSectionHeader={() => null} />)
+
+		const hooksSwitch = container.querySelector("#Hooks")
+		expect(hooksSwitch).toBeTruthy()
+
+		fireEvent.click(hooksSwitch as Element)
+
+		expect(mockUpdateSetting).toHaveBeenCalledWith("hooksEnabled", true)
+	})
+
+	it("calls updateSetting with showFeatureTips when toggled", () => {
+		const { container } = render(<FeatureSettingsSection renderSectionHeader={() => null} />)
+
+		const featureTipsSwitch = container.querySelector('[id="Feature Tips"]')
+		expect(featureTipsSwitch).toBeTruthy()
+
+		fireEvent.click(featureTipsSwitch as Element)
+
+		expect(mockUpdateSetting).toHaveBeenCalledWith("showFeatureTips", true)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/FeatureSettingsSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/FeatureSettingsSection.tsx
new file mode 100644
index 0000000..186f145
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/FeatureSettingsSection.tsx
@@ -0,0 +1,304 @@
+import { UpdateSettingsRequest } from "@shared/proto/cline/state"
+import { memo, type ReactNode } from "react"
+import { Label } from "@/components/ui/label"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Switch } from "@/components/ui/switch"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import Section from "../Section"
+import { updateSetting } from "../utils/settingsHandlers"
+
+// Reusable checkbox component for feature settings
+interface FeatureCheckboxProps {
+	checked: boolean | undefined
+	onChange: (checked: boolean) => void
+	label: string
+	description: ReactNode
+	disabled?: boolean
+	isRemoteLocked?: boolean
+	remoteTooltip?: string
+	isVisible?: boolean
+}
+
+// Interface for feature toggle configuration
+interface FeatureToggle {
+	id: string
+	label: string
+	description: ReactNode
+	settingKey: keyof UpdateSettingsRequest
+	stateKey: string
+}
+
+const agentFeatures: FeatureToggle[] = [
+	{
+		id: "auto-compact",
+		label: "Auto Compact",
+		description: "Automatically compress conversation history.",
+		stateKey: "useAutoCondense",
+		settingKey: "useAutoCondense",
+	},
+]
+
+const editorFeatures: FeatureToggle[] = [
+	{
+		id: "show-feature-tips",
+		label: "Feature Tips",
+		description: "Show rotating tips during the thinking phase to help you discover Cline features.",
+		stateKey: "showFeatureTips",
+		settingKey: "showFeatureTips",
+	},
+	{
+		id: "background-edit",
+		label: "Background Edit",
+		description: "Allow edits without stealing editor focus",
+		stateKey: "backgroundEditEnabled",
+		settingKey: "backgroundEditEnabled",
+	},
+	{
+		id: "checkpoints",
+		label: "Checkpoints",
+		description: "Save progress at key points for easy rollback",
+		stateKey: "enableCheckpointsSetting",
+		settingKey: "enableCheckpointsSetting",
+	},
+	{
+		id: "worktrees",
+		label: "Worktrees",
+		description: "Enables git worktree management for running parallel Cline tasks.",
+		stateKey: "worktreesEnabled",
+		settingKey: "worktreesEnabled",
+	},
+]
+
+const experimentalFeatures: FeatureToggle[] = [
+	{
+		id: "yolo",
+		label: "Yolo Mode",
+		description:
+			"Execute tasks without user's confirmation. Auto-switches from Plan to Act mode and disables the ask question tool. Use with extreme caution.",
+		stateKey: "yoloModeToggled",
+		settingKey: "yoloModeToggled",
+	},
+]
+
+const advancedFeatures: FeatureToggle[] = [
+	{
+		id: "hooks",
+		label: "Hooks",
+		description: "Enable lifecycle and tool hooks during task execution.",
+		stateKey: "hooksEnabled",
+		settingKey: "hooksEnabled",
+	},
+]
+
+const FeatureRow = memo(
+	({
+		checked = false,
+		onChange,
+		label,
+		description,
+		disabled,
+		isRemoteLocked,
+		isVisible = true,
+		remoteTooltip,
+	}: FeatureCheckboxProps) => {
+		if (!isVisible) {
+			return null
+		}
+
+		const checkbox = (
+			<div className="flex items-center justify-between w-full">
+				<div>{label}</div>
+				<div>
+					<Switch
+						checked={checked}
+						className="shrink-0"
+						disabled={disabled || isRemoteLocked}
+						id={label}
+						onCheckedChange={onChange}
+						size="lg"
+					/>
+					{isRemoteLocked && <i className="codicon codicon-lock text-description text-sm" />}
+				</div>
+			</div>
+		)
+
+		return (
+			<div className="flex flex-col items-start justify-between gap-4 py-3 w-full">
+				<div className="space-y-0.5 flex-1 w-full">
+					{isRemoteLocked ? (
+						<Tooltip>
+							<TooltipTrigger asChild>{checkbox}</TooltipTrigger>
+							<TooltipContent className="max-w-xs" side="top">
+								{remoteTooltip}
+							</TooltipContent>
+						</Tooltip>
+					) : (
+						checkbox
+					)}
+				</div>
+				<div className="text-xs text-description">{description}</div>
+			</div>
+		)
+	},
+)
+
+interface FeatureSettingsSectionProps {
+	renderSectionHeader: (tabId: string) => JSX.Element | null
+}
+
+const FeatureSettingsSection = ({ renderSectionHeader }: FeatureSettingsSectionProps) => {
+	const {
+		enableCheckpointsSetting,
+		hooksEnabled,
+		mcpDisplayMode,
+		yoloModeToggled,
+		useAutoCondense,
+		compactionStrategy,
+		subagentsEnabled,
+		worktreesEnabled,
+		remoteConfigSettings,
+		backgroundEditEnabled,
+		showFeatureTips,
+	} = useExtensionState()
+
+	const isYoloRemoteLocked = remoteConfigSettings?.yoloModeToggled !== undefined
+
+	// State lookup for mapped features
+	const featureState: Record<string, boolean | undefined> = {
+		showFeatureTips,
+		enableCheckpointsSetting,
+		hooksEnabled,
+		useAutoCondense,
+		subagentsEnabled,
+		worktreesEnabled: worktreesEnabled?.user,
+		backgroundEditEnabled,
+		yoloModeToggled: isYoloRemoteLocked ? remoteConfigSettings?.yoloModeToggled : yoloModeToggled,
+	}
+
+	// Visibility lookup for features with feature flags
+	const featureVisibility: Record<string, boolean | undefined> = {
+		worktreesEnabled: worktreesEnabled?.featureFlag,
+	}
+
+	return (
+		<div className="mb-2">
+			{renderSectionHeader("features")}
+			<Section>
+				<div className="mb-5 flex flex-col gap-3">
+					{/* Core features */}
+					<div>
+						<div className="text-xs font-medium text-foreground/80 uppercase tracking-wider mb-3">Agent</div>
+						<div
+							className="relative p-3 pt-0 my-3 rounded-md border border-editor-widget-border/50"
+							id="agent-features">
+							{agentFeatures.map((feature) => (
+								<FeatureRow
+									checked={featureState[feature.stateKey]}
+									description={feature.description}
+									isVisible={featureVisibility[feature.stateKey] ?? true}
+									key={feature.id}
+									label={feature.label}
+									onChange={(checked) => updateSetting(feature.settingKey, checked)}
+								/>
+							))}
+							<div className="space-y-2 py-3">
+								<Label className="text-sm font-medium text-foreground">Auto Compact Strategy</Label>
+								<p className="text-xs text-muted-foreground">Controls how auto compaction rewrites context.</p>
+								<Select
+									disabled={!useAutoCondense}
+									onValueChange={(value) => updateSetting("compactionStrategy", value)}
+									value={compactionStrategy ?? "basic"}>
+									<SelectTrigger className="w-full">
+										<SelectValue />
+									</SelectTrigger>
+									<SelectContent>
+										<SelectItem value="basic">Basic</SelectItem>
+										<SelectItem value="agentic">Agentic</SelectItem>
+									</SelectContent>
+								</Select>
+							</div>
+						</div>
+					</div>
+
+					{/* Editor features */}
+					<div>
+						<div className="text-xs font-medium text-foreground/80 uppercase tracking-wider mb-3">Editor</div>
+						<div
+							className="relative p-3 pt-0 my-3 rounded-md border border-editor-widget-border/50"
+							id="optional-features">
+							{editorFeatures.map((feature) => (
+								<FeatureRow
+									checked={featureState[feature.stateKey]}
+									description={feature.description}
+									isVisible={featureVisibility[feature.stateKey] ?? true}
+									key={feature.id}
+									label={feature.label}
+									onChange={(checked) => updateSetting(feature.settingKey, checked)}
+								/>
+							))}
+						</div>
+					</div>
+
+					{/* Experimental features */}
+					<div>
+						<div className="text-xs font-medium uppercase tracking-wider mb-3 text-warning/80">Experimental</div>
+						<div
+							className="relative p-3 pt-0 my-3 rounded-md border border-editor-widget-border/50 w-full"
+							id="experimental-features">
+							{experimentalFeatures.map((feature) => (
+								<FeatureRow
+									checked={featureState[feature.stateKey]}
+									description={feature.description}
+									disabled={feature.id === "yolo" && isYoloRemoteLocked}
+									isRemoteLocked={feature.id === "yolo" && isYoloRemoteLocked}
+									isVisible={featureVisibility[feature.stateKey] ?? true}
+									key={feature.id}
+									label={feature.label}
+									onChange={(checked) => updateSetting(feature.settingKey, checked)}
+									remoteTooltip="This setting is managed by your organization's remote configuration"
+								/>
+							))}
+						</div>
+					</div>
+				</div>
+
+				{/* Advanced */}
+				<div>
+					<div className="text-xs font-medium text-foreground/80 uppercase tracking-wider mb-3">Advanced</div>
+					<div className="relative p-3 my-3 rounded-md border border-editor-widget-border/50" id="advanced-features">
+						<div className="space-y-3">
+							{advancedFeatures.map((feature) => (
+								<FeatureRow
+									checked={featureState[feature.stateKey]}
+									description={feature.description}
+									isVisible={featureVisibility[feature.stateKey] ?? true}
+									key={feature.id}
+									label={feature.label}
+									onChange={(checked) => updateSetting(feature.settingKey, checked)}
+								/>
+							))}
+
+							{/* MCP Display Mode */}
+							<div className="space-y-2">
+								<Label className="text-sm font-medium text-foreground">MCP Display Mode</Label>
+								<p className="text-xs text-muted-foreground">Controls how MCP responses are displayed</p>
+								<Select onValueChange={(v) => updateSetting("mcpDisplayMode", v)} value={mcpDisplayMode}>
+									<SelectTrigger className="w-full">
+										<SelectValue />
+									</SelectTrigger>
+									<SelectContent>
+										<SelectItem value="plain">Plain Text</SelectItem>
+										<SelectItem value="rich">Rich Display</SelectItem>
+										<SelectItem value="markdown">Markdown</SelectItem>
+									</SelectContent>
+								</Select>
+							</div>
+						</div>
+					</div>
+				</div>
+			</Section>
+		</div>
+	)
+}
+export default memo(FeatureSettingsSection)
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/GeneralSettingsSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/GeneralSettingsSection.tsx
new file mode 100644
index 0000000..e38660a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/GeneralSettingsSection.tsx
@@ -0,0 +1,68 @@
+import { VSCodeCheckbox, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import PreferredLanguageSetting from "../PreferredLanguageSetting"
+import Section from "../Section"
+import { updateSetting } from "../utils/settingsHandlers"
+
+interface GeneralSettingsSectionProps {
+	renderSectionHeader: (tabId: string) => JSX.Element | null
+}
+
+const GeneralSettingsSection = ({ renderSectionHeader }: GeneralSettingsSectionProps) => {
+	const { telemetrySetting, remoteConfigSettings } = useExtensionState()
+
+	return (
+		<div>
+			{renderSectionHeader("general")}
+			<Section>
+				<PreferredLanguageSetting />
+
+				<div className="mb-[5px]">
+					<Tooltip>
+						<TooltipContent hidden={remoteConfigSettings?.telemetrySetting === undefined}>
+							This setting is managed by your organization's remote configuration
+						</TooltipContent>
+						<TooltipTrigger asChild>
+							<div className="flex items-center gap-2 mb-[5px]">
+								<VSCodeCheckbox
+									checked={telemetrySetting !== "disabled"}
+									disabled={remoteConfigSettings?.telemetrySetting === "disabled"}
+									onChange={(e: any) => {
+										const checked = e.target.checked === true
+										updateSetting("telemetrySetting", checked ? "enabled" : "disabled")
+									}}>
+									Allow error and usage reporting
+								</VSCodeCheckbox>
+								{!!remoteConfigSettings?.telemetrySetting && (
+									<i className="codicon codicon-lock text-description text-sm" />
+								)}
+							</div>
+						</TooltipTrigger>
+					</Tooltip>
+
+					<p className="text-sm mt-[5px] text-description">
+						Help improve Cline by sending usage data and error reports. No code, prompts, or personal information are
+						ever sent. See our{" "}
+						<VSCodeLink
+							className="text-inherit"
+							href="https://docs.cline.bot/more-info/telemetry"
+							style={{ fontSize: "inherit", textDecoration: "underline" }}>
+							telemetry overview
+						</VSCodeLink>{" "}
+						and{" "}
+						<VSCodeLink
+							className="text-inherit"
+							href="https://cline.bot/privacy"
+							style={{ fontSize: "inherit", textDecoration: "underline" }}>
+							privacy policy
+						</VSCodeLink>{" "}
+						for more details.
+					</p>
+				</div>
+			</Section>
+		</div>
+	)
+}
+
+export default GeneralSettingsSection
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/RemoteConfigSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/RemoteConfigSection.tsx
new file mode 100644
index 0000000..40b3fb7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/RemoteConfigSection.tsx
@@ -0,0 +1,318 @@
+import { EmptyRequest } from "@shared/proto/index.cline"
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { useEffect, useRef, useState } from "react"
+import { RemoteConfigToggle } from "@/components/account/RemoteConfigToggle"
+import { useClineAuth } from "@/context/ClineAuthContext"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { StateServiceClient } from "@/services/grpc-client"
+import Section from "../Section"
+
+interface RemoteConfigSectionProps {
+	renderSectionHeader: (tabId: string) => JSX.Element | null
+}
+
+function BaseRemoteConfigSection({ renderSectionHeader, children }: React.PropsWithChildren<RemoteConfigSectionProps>) {
+	return (
+		<div>
+			{renderSectionHeader("remote-config")}
+			<Section>{children}</Section>
+		</div>
+	)
+}
+
+const AUTOMATIC_DELAY_MS = 30000
+
+function RefreshButton() {
+	const [isLoading, setIsLoading] = useState(false)
+	const [retryIn, setRetryIn] = useState<number | null>(null)
+	const intervalRef = useRef<NodeJS.Timeout>()
+
+	useEffect(() => {
+		return () => {
+			if (intervalRef.current) {
+				clearInterval(intervalRef.current)
+			}
+		}
+	}, [])
+
+	const onRefresh = () => {
+		setIsLoading(true)
+		StateServiceClient.refreshRemoteConfig(EmptyRequest.create()).finally(() => {
+			setIsLoading(false)
+			setRetryIn(AUTOMATIC_DELAY_MS / 1000)
+
+			intervalRef.current = setInterval(() => {
+				setRetryIn((old) => {
+					if (old && old > 0) return old - 1
+
+					intervalRef.current && clearInterval(intervalRef.current)
+					return null
+				})
+			}, 1000)
+		})
+	}
+
+	return (
+		<VSCodeButton
+			className={`w-full rounded-xs ${isLoading ? "animate-pulse" : ""}`}
+			disabled={isLoading || (retryIn !== null && retryIn > 0)}
+			onClick={() => onRefresh()}>
+			Refresh {retryIn && retryIn > 0 && <>(Retry in: {retryIn} seconds)</>}
+		</VSCodeButton>
+	)
+}
+
+interface SettingRowProps {
+	label: string
+	value: string | number | boolean | undefined | null
+	isSecret?: boolean
+}
+
+function SettingRow({ label, value, isSecret }: SettingRowProps) {
+	const displayValue = (() => {
+		if (value === undefined || value === null) {
+			return <span className="text-description italic">Not configured</span>
+		}
+		if (typeof value === "boolean") {
+			return value ? <span className="text-green-500">Enabled</span> : <span className="text-description">Disabled</span>
+		}
+		if (isSecret && typeof value === "string" && value.length > 0) {
+			return <span className="font-mono text-xs">{"•".repeat(Math.min(value.length, 20))}</span>
+		}
+		return <span className="font-mono text-xs break-all">{String(value)}</span>
+	})()
+
+	const isLongValue = typeof value === "string" && value.length > 25
+	if (isLongValue) {
+		return (
+			<div className="flex flex-col gap-1 py-1.5 border-b border-vscode-widget-border last:border-b-0">
+				<span className="text-description text-xs">{label}</span>
+				<div className="pl-2 overflow-hidden text-right">{displayValue}</div>
+			</div>
+		)
+	}
+
+	return (
+		<div className="flex justify-between items-center py-1.5 border-b border-vscode-widget-border last:border-b-0 gap-2">
+			<span className="text-description text-xs shrink-0">{label}</span>
+			<span className="text-right overflow-hidden text-ellipsis">{displayValue}</span>
+		</div>
+	)
+}
+
+interface TestButtonProps {
+	label: string
+	onClick: () => Promise<void>
+	disabled?: boolean
+	successMessage?: string
+}
+
+function TestButton({ label, onClick, disabled, successMessage }: TestButtonProps) {
+	const [isLoading, setIsLoading] = useState(false)
+	const [result, setResult] = useState<{ success: boolean; message: string } | null>(null)
+	const timeoutRef = useRef<NodeJS.Timeout>()
+
+	useEffect(() => {
+		return () => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current)
+			}
+		}
+	}, [])
+
+	const handleClick = async () => {
+		setIsLoading(true)
+		setResult(null)
+		try {
+			await onClick()
+			setResult({ success: true, message: successMessage || "Success!" })
+		} catch (error) {
+			setResult({ success: false, message: error instanceof Error ? error.message : "Failed" })
+		} finally {
+			setIsLoading(false)
+			timeoutRef.current = setTimeout(() => setResult(null), 5000)
+		}
+	}
+
+	return (
+		<div className="flex items-center gap-2">
+			<VSCodeButton
+				appearance="secondary"
+				className={isLoading ? "animate-pulse" : ""}
+				disabled={disabled || isLoading}
+				onClick={handleClick}>
+				{isLoading ? "Testing..." : label}
+			</VSCodeButton>
+			{result && <span className={`text-xs ${result.success ? "text-green-500" : "text-red-500"}`}>{result.message}</span>}
+		</div>
+	)
+}
+
+function OtelSettingsSection() {
+	const { remoteConfigSettings } = useExtensionState()
+
+	const otelEnabled = remoteConfigSettings?.openTelemetryEnabled
+	const hasOtelConfig =
+		otelEnabled !== undefined ||
+		remoteConfigSettings?.openTelemetryOtlpEndpoint !== undefined ||
+		remoteConfigSettings?.openTelemetryMetricsExporter !== undefined ||
+		remoteConfigSettings?.openTelemetryLogsExporter !== undefined
+
+	if (!hasOtelConfig) {
+		return null
+	}
+
+	const handleTestOtel = async () => {
+		const response = await StateServiceClient.testOtelConnection(EmptyRequest.create({}))
+		if (!response.success) {
+			throw new Error(response.error || "Test failed")
+		}
+	}
+
+	return (
+		<div className="mb-4">
+			<h4 className="text-sm font-medium mb-2 flex items-center gap-2">
+				<i className="codicon codicon-pulse" />
+				OpenTelemetry Configuration
+			</h4>
+			<div className="bg-vscode-textBlockQuote-background rounded p-3 mb-2">
+				<SettingRow label="Enabled" value={otelEnabled} />
+				<SettingRow label="Metrics Exporter" value={remoteConfigSettings?.openTelemetryMetricsExporter} />
+				<SettingRow label="Logs Exporter" value={remoteConfigSettings?.openTelemetryLogsExporter} />
+				<SettingRow label="OTLP Protocol" value={remoteConfigSettings?.openTelemetryOtlpProtocol} />
+				<SettingRow label="OTLP Endpoint" value={remoteConfigSettings?.openTelemetryOtlpEndpoint} />
+				{remoteConfigSettings?.openTelemetryOtlpMetricsEndpoint && (
+					<SettingRow label="Metrics Endpoint" value={remoteConfigSettings?.openTelemetryOtlpMetricsEndpoint} />
+				)}
+				{remoteConfigSettings?.openTelemetryOtlpLogsEndpoint && (
+					<SettingRow label="Logs Endpoint" value={remoteConfigSettings?.openTelemetryOtlpLogsEndpoint} />
+				)}
+				{remoteConfigSettings?.openTelemetryOtlpHeaders && (
+					<SettingRow
+						label="OTLP Headers"
+						value={`${Object.keys(remoteConfigSettings.openTelemetryOtlpHeaders).length} header(s)`}
+					/>
+				)}
+				{remoteConfigSettings?.openTelemetryMetricExportInterval && (
+					<SettingRow
+						label="Metric Export Interval"
+						value={`${remoteConfigSettings.openTelemetryMetricExportInterval}ms`}
+					/>
+				)}
+				{remoteConfigSettings?.openTelemetryOtlpInsecure !== undefined && (
+					<SettingRow label="OTLP Insecure" value={remoteConfigSettings?.openTelemetryOtlpInsecure} />
+				)}
+				{remoteConfigSettings?.openTelemetryLogBatchSize && (
+					<SettingRow label="Log Batch Size" value={remoteConfigSettings?.openTelemetryLogBatchSize} />
+				)}
+				{remoteConfigSettings?.openTelemetryLogBatchTimeout && (
+					<SettingRow label="Log Batch Timeout" value={`${remoteConfigSettings.openTelemetryLogBatchTimeout}ms`} />
+				)}
+				{remoteConfigSettings?.openTelemetryLogMaxQueueSize && (
+					<SettingRow label="Log Max Queue Size" value={remoteConfigSettings?.openTelemetryLogMaxQueueSize} />
+				)}
+			</div>
+
+			{otelEnabled && (
+				<div className="flex gap-2 flex-wrap">
+					<TestButton
+						disabled={!remoteConfigSettings?.openTelemetryMetricsExporter}
+						label="Test"
+						onClick={handleTestOtel}
+						successMessage="Flushed buffers! Please check the output channel for more detailed information"
+					/>
+				</div>
+			)}
+		</div>
+	)
+}
+
+function PromptUploadingSection() {
+	const { remoteConfigSettings } = useExtensionState()
+
+	const blobStoreConfig = remoteConfigSettings?.blobStoreConfig
+	if (!blobStoreConfig) {
+		return null
+	}
+
+	const handleTestPromptUploading = async () => {
+		const response = await StateServiceClient.testPromptUploading(EmptyRequest.create({}))
+		if (!response.success) {
+			throw new Error(response.error || "Test failed")
+		}
+	}
+
+	return (
+		<div className="mb-4">
+			<h4 className="text-sm font-medium mb-2 flex items-center gap-2">
+				<i className="codicon codicon-cloud-upload" />
+				Prompt Uploading Configuration
+			</h4>
+			<div className="bg-vscode-textBlockQuote-background rounded p-3 mb-2">
+				<SettingRow label="Storage Type" value={blobStoreConfig.adapterType?.toUpperCase()} />
+				<SettingRow label="Bucket" value={blobStoreConfig.bucket} />
+				<SettingRow label="Region" value={blobStoreConfig.region} />
+				{blobStoreConfig.endpoint && <SettingRow label="Endpoint" value={blobStoreConfig.endpoint} />}
+				{blobStoreConfig.accountId && <SettingRow label="Account ID" value={blobStoreConfig.accountId} />}
+				<SettingRow isSecret label="Access Key ID" value={blobStoreConfig.accessKeyId} />
+				<SettingRow isSecret label="Secret Access Key" value={blobStoreConfig.secretAccessKey} />
+				{blobStoreConfig.intervalMs && <SettingRow label="Sync Interval" value={`${blobStoreConfig.intervalMs}ms`} />}
+				{blobStoreConfig.batchSize && <SettingRow label="Batch Size" value={blobStoreConfig.batchSize} />}
+				{blobStoreConfig.maxRetries && <SettingRow label="Max Retries" value={blobStoreConfig.maxRetries} />}
+				{blobStoreConfig.maxQueueSize && <SettingRow label="Max Queue Size" value={blobStoreConfig.maxQueueSize} />}
+				<SettingRow label="Backfill Enabled" value={blobStoreConfig.backfillEnabled} />
+			</div>
+
+			<TestButton label="Test Upload" onClick={handleTestPromptUploading} />
+		</div>
+	)
+}
+
+export function RemoteConfigSection({ renderSectionHeader }: RemoteConfigSectionProps) {
+	const { remoteConfigSettings, optOutOfRemoteConfig } = useExtensionState()
+	const { activeOrganization } = useClineAuth()
+
+	if (optOutOfRemoteConfig) {
+		return (
+			<BaseRemoteConfigSection renderSectionHeader={renderSectionHeader}>
+				<div className="flex flex-col justify-center gap-4">
+					<h3>You have opted out of remote config. Opt back in to apply it and see it here.</h3>
+
+					<RemoteConfigToggle activeOrganization={activeOrganization} />
+				</div>
+			</BaseRemoteConfigSection>
+		)
+	}
+
+	if (!remoteConfigSettings || Object.keys(remoteConfigSettings).length === 0) {
+		return (
+			<BaseRemoteConfigSection renderSectionHeader={renderSectionHeader}>
+				<div className="flex flex-col justify-center gap-4">
+					<h3>
+						You haven't configured remote config yet. Do so through our{" "}
+						<VSCodeLink href="https://app.cline.bot/dashboard/organization?tab=settings">dashboard</VSCodeLink>.
+					</h3>
+
+					<RefreshButton />
+				</div>
+			</BaseRemoteConfigSection>
+		)
+	}
+
+	return (
+		<BaseRemoteConfigSection renderSectionHeader={renderSectionHeader}>
+			<div className="flex flex-col gap-2">
+				<p className="text-description text-xs mb-2">
+					These settings are managed by your organization's remote configuration.
+				</p>
+
+				<OtelSettingsSection />
+				<PromptUploadingSection />
+
+				<div className="mt-2">
+					<RefreshButton />
+				</div>
+			</div>
+		</BaseRemoteConfigSection>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/sections/TerminalSettingsSection.tsx b/apps/vscode/webview-ui/src/components/settings/sections/TerminalSettingsSection.tsx
new file mode 100644
index 0000000..836659b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/sections/TerminalSettingsSection.tsx
@@ -0,0 +1,191 @@
+import { UpdateTerminalConnectionTimeoutResponse } from "@shared/proto/index.cline"
+import { VSCodeCheckbox, VSCodeDropdown, VSCodeOption, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import React, { useState } from "react"
+import { PlatformType } from "@/config/platform.config"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { usePlatform } from "@/context/PlatformContext"
+import { StateServiceClient } from "../../../services/grpc-client"
+import Section from "../Section"
+import { updateSetting } from "../utils/settingsHandlers"
+
+interface TerminalSettingsSectionProps {
+	renderSectionHeader: (tabId: string) => JSX.Element | null
+}
+
+const TerminalSettingsSection: React.FC<TerminalSettingsSectionProps> = ({ renderSectionHeader }) => {
+	const {
+		shellIntegrationTimeout,
+		terminalReuseEnabled,
+		defaultTerminalProfile,
+		availableTerminalProfiles,
+		vscodeTerminalExecutionMode,
+	} = useExtensionState()
+	const platformConfig = usePlatform()
+	const isVsCodePlatform = platformConfig.type === PlatformType.VSCODE
+
+	const [inputValue, setInputValue] = useState((shellIntegrationTimeout / 1000).toString())
+	const [inputError, setInputError] = useState<string | null>(null)
+
+	const handleTimeoutChange = (event: Event) => {
+		const target = event.target as HTMLInputElement
+		const value = target.value
+
+		setInputValue(value)
+
+		const seconds = Number.parseFloat(value)
+		if (Number.isNaN(seconds) || seconds <= 0) {
+			setInputError("Please enter a positive number")
+			return
+		}
+
+		setInputError(null)
+		const timeoutMs = Math.round(seconds * 1000)
+
+		StateServiceClient.updateTerminalConnectionTimeout({ timeoutMs })
+			.then((response: UpdateTerminalConnectionTimeoutResponse) => {
+				const timeoutMs = response.timeoutMs
+				// Backend calls postStateToWebview(), so state will update via subscription
+				// Just sync the input value with the confirmed backend value
+				if (timeoutMs !== undefined) {
+					setInputValue((timeoutMs / 1000).toString())
+				}
+			})
+			.catch((error) => {
+				console.error("Failed to update terminal connection timeout:", error)
+			})
+	}
+
+	const handleInputBlur = () => {
+		if (inputError) {
+			setInputValue((shellIntegrationTimeout / 1000).toString())
+			setInputError(null)
+		}
+	}
+
+	const handleTerminalReuseChange = (event: Event) => {
+		const target = event.target as HTMLInputElement
+		const checked = target.checked
+		updateSetting("terminalReuseEnabled", checked)
+	}
+
+	const handleExecutionModeChange = (event: Event) => {
+		const target = event.target as HTMLSelectElement
+		const value = target.value === "backgroundExec" ? "backgroundExec" : "vscodeTerminal"
+		updateSetting("vscodeTerminalExecutionMode", value)
+	}
+
+	// Use any to avoid type conflicts between Event and FormEvent
+	const handleDefaultTerminalProfileChange = (event: any) => {
+		const target = event.target as HTMLSelectElement
+		const profileId = target.value
+
+		// Save immediately using the consolidated updateSettings approach
+		updateSetting("defaultTerminalProfile", profileId || "default")
+	}
+
+	const profilesToShow = availableTerminalProfiles
+
+	return (
+		<div>
+			{renderSectionHeader("terminal")}
+			<Section>
+				<div className="mb-5" id="terminal-settings-section">
+					<div className="mb-4">
+						<label className="font-medium block mb-1" htmlFor="default-terminal-profile">
+							Default Terminal Profile
+						</label>
+						<VSCodeDropdown
+							className="w-full"
+							id="default-terminal-profile"
+							onChange={handleDefaultTerminalProfileChange}
+							value={defaultTerminalProfile || "default"}>
+							{profilesToShow.map((profile) => (
+								<VSCodeOption key={profile.id} title={profile.description} value={profile.id}>
+									{profile.name}
+								</VSCodeOption>
+							))}
+						</VSCodeDropdown>
+						<p className="text-xs text-(--vscode-descriptionForeground) mt-1">
+							Select the default terminal Cline will use. 'Default' uses your VSCode global setting.
+						</p>
+					</div>
+
+					<div className="mb-4">
+						<div className="mb-2">
+							<label className="font-medium block mb-1">Shell integration timeout (seconds)</label>
+							<div className="flex items-center">
+								<VSCodeTextField
+									className="w-full"
+									onBlur={handleInputBlur}
+									onChange={(event) => handleTimeoutChange(event as Event)}
+									placeholder="Enter timeout in seconds"
+									value={inputValue}
+								/>
+							</div>
+							{inputError && <div className="text-(--vscode-errorForeground) text-xs mt-1">{inputError}</div>}
+						</div>
+						<p className="text-xs text-(--vscode-descriptionForeground)">
+							Set how long Cline waits for shell integration to activate before executing commands. Increase this
+							value if you experience terminal connection timeouts.
+						</p>
+					</div>
+
+					<div className="mb-4">
+						<div className="flex items-center mb-2">
+							<VSCodeCheckbox
+								checked={terminalReuseEnabled ?? true}
+								onChange={(event) => handleTerminalReuseChange(event as Event)}>
+								Enable aggressive terminal reuse
+							</VSCodeCheckbox>
+						</div>
+						<p className="text-xs text-(--vscode-descriptionForeground)">
+							When enabled, Cline will reuse existing terminal windows that aren't in the current working directory.
+							Disable this if you experience issues with task lockout after a terminal command.
+						</p>
+					</div>
+					{isVsCodePlatform && (
+						<div className="mb-4">
+							<label className="font-medium block mb-1" htmlFor="terminal-execution-mode">
+								Terminal Execution Mode
+							</label>
+							<VSCodeDropdown
+								className="w-full"
+								id="terminal-execution-mode"
+								onChange={(event) => handleExecutionModeChange(event as Event)}
+								value={vscodeTerminalExecutionMode ?? "vscodeTerminal"}>
+								<VSCodeOption value="vscodeTerminal">VS Code Terminal</VSCodeOption>
+								<VSCodeOption value="backgroundExec">Background Exec</VSCodeOption>
+							</VSCodeDropdown>
+							<p className="text-xs text-[var(--vscode-descriptionForeground)] mt-1">
+								Choose whether Cline runs commands in the VS Code terminal or a background process.
+							</p>
+						</div>
+					)}
+					<div className="mt-5 p-3 bg-(--vscode-textBlockQuote-background) rounded border border-(--vscode-textBlockQuote-border)">
+						<p className="text-[13px] m-0">
+							<strong>Having terminal issues?</strong> Check our{" "}
+							<a
+								className="text-(--vscode-textLink-foreground) underline hover:no-underline"
+								href="https://docs.cline.bot/troubleshooting/terminal-quick-fixes"
+								rel="noopener noreferrer"
+								target="_blank">
+								Terminal Quick Fixes
+							</a>{" "}
+							or the{" "}
+							<a
+								className="text-(--vscode-textLink-foreground) underline hover:no-underline"
+								href="https://docs.cline.bot/troubleshooting/terminal-integration-guide"
+								rel="noopener noreferrer"
+								target="_blank">
+								Complete Troubleshooting Guide
+							</a>
+							.
+						</p>
+					</div>
+				</div>
+			</Section>
+		</div>
+	)
+}
+
+export default TerminalSettingsSection
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/__tests__/pricingUtils.test.ts b/apps/vscode/webview-ui/src/components/settings/utils/__tests__/pricingUtils.test.ts
new file mode 100644
index 0000000..8ed6c9b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/__tests__/pricingUtils.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest"
+import { parsePrice } from "../pricingUtils"
+
+describe("pricingUtils", () => {
+	describe("parsePrice", () => {
+		const defaultValue = 0
+
+		it("should parse valid decimal numbers", () => {
+			expect(parsePrice("1.5", defaultValue)).toBe(1.5)
+			expect(parsePrice("0.25", defaultValue)).toBe(0.25)
+			expect(parsePrice("100", defaultValue)).toBe(100)
+			expect(parsePrice("0", defaultValue)).toBe(0)
+		})
+
+		it("should parse decimals starting with a dot", () => {
+			expect(parsePrice(".5", defaultValue)).toBe(0.5)
+			expect(parsePrice(".25", defaultValue)).toBe(0.25)
+			expect(parsePrice(".001", defaultValue)).toBe(0.001)
+		})
+
+		it("should return default for empty string", () => {
+			expect(parsePrice("", defaultValue)).toBe(0)
+			expect(parsePrice("", 5)).toBe(5)
+		})
+
+		it("should return default for just a dot", () => {
+			expect(parsePrice(".", defaultValue)).toBe(0)
+			expect(parsePrice(".", 3.5)).toBe(3.5)
+		})
+
+		it("should return default for invalid input", () => {
+			expect(parsePrice("abc", defaultValue)).toBe(0)
+			expect(parsePrice("abc", 10)).toBe(10)
+			expect(parsePrice("1.2.3", defaultValue)).toBe(1.2) // parseFloat stops at second dot
+		})
+
+		it("should handle trailing zeros correctly", () => {
+			expect(parsePrice("1.0", defaultValue)).toBe(1)
+			expect(parsePrice("1.00", defaultValue)).toBe(1)
+			expect(parsePrice("0.10", defaultValue)).toBe(0.1)
+		})
+
+		it("should handle numbers with trailing dot", () => {
+			// "1." is a valid partial input that parseFloat handles as 1
+			expect(parsePrice("1.", defaultValue)).toBe(1)
+			expect(parsePrice("0.", defaultValue)).toBe(0)
+		})
+
+		it("should use the provided default value", () => {
+			expect(parsePrice("", 99)).toBe(99)
+			expect(parsePrice(".", 42)).toBe(42)
+			expect(parsePrice("invalid", 7.5)).toBe(7.5)
+		})
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/__tests__/providerUtils.test.ts b/apps/vscode/webview-ui/src/components/settings/utils/__tests__/providerUtils.test.ts
new file mode 100644
index 0000000..06ba907
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/__tests__/providerUtils.test.ts
@@ -0,0 +1,31 @@
+import type { ApiConfiguration } from "@shared/api"
+import { describe, expect, it } from "vitest"
+import { getModeSpecificFields } from "../providerUtils"
+
+describe("getModeSpecificFields", () => {
+	it("returns undefined provider-specific fields when apiConfiguration is undefined", () => {
+		const fields = getModeSpecificFields(undefined, "plan")
+		expect(fields.apiProvider).toBeUndefined()
+		expect(fields.openRouterModelId).toBeUndefined()
+		expect(fields.clineModelId).toBeUndefined()
+	})
+
+	it("isolates each provider's saved fields so cross-provider state does not leak", () => {
+		// Reproduces the original cline/openrouter conflation guard: even when
+		// the user has stale OpenRouter selection state and is now configured
+		// for Cline, Cline-specific fields stay undefined until the user
+		// commits a Cline selection.
+		const apiConfiguration: ApiConfiguration = {
+			planModeApiProvider: "cline",
+			planModeOpenRouterModelId: "openrouter/some-model",
+			planModeOpenRouterModelInfo: { description: "stale OpenRouter model" },
+		} as ApiConfiguration
+
+		const fields = getModeSpecificFields(apiConfiguration, "plan")
+
+		expect(fields.apiProvider).toBe("cline")
+		expect(fields.openRouterModelId).toBe("openrouter/some-model")
+		expect(fields.clineModelId).toBeUndefined()
+		expect(fields.clineModelInfo).toBeUndefined()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/apiKeyMasking.ts b/apps/vscode/webview-ui/src/components/settings/utils/apiKeyMasking.ts
new file mode 100644
index 0000000..080edb9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/apiKeyMasking.ts
@@ -0,0 +1,17 @@
+const SAVED_API_KEY_MASK_CHARACTER = "•"
+
+export function getSavedApiKeyMask(apiKeyLength: number | undefined): string {
+	return SAVED_API_KEY_MASK_CHARACTER.repeat(Math.max(0, apiKeyLength ?? 0))
+}
+
+export function sanitizeMaskedApiKeyInput(value: string, savedMask: string): string | undefined {
+	if (!savedMask || !value.includes(SAVED_API_KEY_MASK_CHARACTER)) {
+		return value
+	}
+
+	if (value === savedMask) {
+		return undefined
+	}
+
+	return value.split(SAVED_API_KEY_MASK_CHARACTER).join("")
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/pricingUtils.ts b/apps/vscode/webview-ui/src/components/settings/utils/pricingUtils.ts
new file mode 100644
index 0000000..994b3a7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/pricingUtils.ts
@@ -0,0 +1,57 @@
+import type { ModelInfo } from "@shared/api"
+
+/**
+ * Formats a price as a currency string
+ */
+export const formatPrice = (price: number) => {
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD",
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2,
+	}).format(price)
+}
+
+/**
+ * Helper function to determine if a model supports thinking budget
+ */
+export const hasThinkingBudget = (modelInfo: ModelInfo): boolean => {
+	return !!modelInfo.thinkingConfig && Object.keys(modelInfo.thinkingConfig).length > 0
+}
+
+/**
+ * Helper function to check if a model supports images
+ */
+export const supportsImages = (modelInfo: ModelInfo): boolean => {
+	return !!modelInfo.supportsImages
+}
+
+/**
+ * Helper function to check if a model supports browser use
+ */
+export const supportsBrowserUse = (modelInfo: ModelInfo): boolean => {
+	return !!modelInfo.supportsImages // browser tool uses image recognition
+}
+
+/**
+ * Helper function to check if a model supports prompt caching
+ */
+export const supportsPromptCache = (modelInfo: ModelInfo): boolean => {
+	return !!modelInfo.supportsPromptCache
+}
+
+/**
+ * Parses a price input string to a number, handling edge cases like
+ * incomplete decimals (e.g., ".", ".5", "0.") gracefully.
+ *
+ * @param value - The input string to parse
+ * @param defaultValue - The fallback value if input is empty or invalid
+ * @returns A valid number, or the default value if parsing fails
+ */
+export const parsePrice = (value: string, defaultValue: number): number => {
+	if (value === "" || value === ".") {
+		return defaultValue
+	}
+	const num = Number.parseFloat(value)
+	return isNaN(num) ? defaultValue : num
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/providerUtils.ts b/apps/vscode/webview-ui/src/components/settings/utils/providerUtils.ts
new file mode 100644
index 0000000..844cbac
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/providerUtils.ts
@@ -0,0 +1,360 @@
+import type { ApiConfiguration, ApiProvider, ModelInfo } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import * as reasoningSupport from "@shared/utils/reasoning-support"
+
+export function supportsReasoningEffortForModelId(modelId?: string, _allowShortOpenAiIds = false): boolean {
+	return reasoningSupport.supportsReasoningEffortForModel(modelId)
+}
+
+// Webview components must source provider models via
+// `useProviderModels(providerId)`, which talks to the extension over
+// gRPC and ultimately reads from `@cline/llms`. Do not add a static
+// catalog here — it would silently bypass the SDK. If a new caller
+// needs model lists synchronously, derive them from the catalog hook
+// instead.
+
+/**
+ * Interface for normalized API configuration
+ */
+export interface NormalizedApiConfig {
+	selectedProvider: ApiProvider
+	selectedModelId: string
+	selectedModelInfo: ModelInfo
+}
+
+/**
+ * Gets mode-specific field values from API configuration
+ * @param apiConfiguration The API configuration object
+ * @param mode The current mode ("plan" or "act")
+ * @returns Object containing mode-specific field values for clean destructuring
+ */
+export function getModeSpecificFields(apiConfiguration: ApiConfiguration | undefined, mode: Mode) {
+	if (!apiConfiguration) {
+		return {
+			// Core fields
+			apiProvider: undefined,
+			apiModelId: undefined,
+
+			// Provider-specific model IDs
+			togetherModelId: undefined,
+			fireworksModelId: undefined,
+			lmStudioModelId: undefined,
+			ollamaModelId: undefined,
+			liteLlmModelId: undefined,
+			requestyModelId: undefined,
+			openAiModelId: undefined,
+			openRouterModelId: undefined,
+			clineModelId: undefined,
+			clinePassModelId: undefined,
+			groqModelId: undefined,
+			basetenModelId: undefined,
+			huggingFaceModelId: undefined,
+			huaweiCloudMaasModelId: undefined,
+			hicapModelId: undefined,
+			aihubmixModelId: undefined,
+			nousResearchModelId: undefined,
+			vercelAiGatewayModelId: undefined,
+
+			// Model info objects
+			openAiModelInfo: undefined,
+			liteLlmModelInfo: undefined,
+			openRouterModelInfo: undefined,
+			clineModelInfo: undefined,
+			requestyModelInfo: undefined,
+			groqModelInfo: undefined,
+			basetenModelInfo: undefined,
+			huggingFaceModelInfo: undefined,
+			vsCodeLmModelSelector: undefined,
+			aihubmixModelInfo: undefined,
+
+			// AWS Bedrock fields
+			awsBedrockCustomSelected: undefined,
+			awsBedrockCustomModelBaseId: undefined,
+
+			// Huawei Cloud Maas Model Info
+			huaweiCloudMaasModelInfo: undefined,
+
+			// Other mode-specific fields
+			thinkingBudgetTokens: undefined,
+			reasoningEffort: undefined,
+		}
+	}
+
+	const openRouterModelId =
+		mode === "plan" ? apiConfiguration.planModeOpenRouterModelId : apiConfiguration.actModeOpenRouterModelId
+	const openRouterModelInfo =
+		mode === "plan" ? apiConfiguration.planModeOpenRouterModelInfo : apiConfiguration.actModeOpenRouterModelInfo
+
+	const clineModelId = mode === "plan" ? apiConfiguration.planModeClineModelId : apiConfiguration.actModeClineModelId
+	const clineModelInfo = mode === "plan" ? apiConfiguration.planModeClineModelInfo : apiConfiguration.actModeClineModelInfo
+	const clinePassModelId =
+		mode === "plan" ? apiConfiguration.planModeClinePassModelId : apiConfiguration.actModeClinePassModelId
+	const clinePassModelInfo =
+		mode === "plan" ? apiConfiguration.planModeClinePassModelInfo : apiConfiguration.actModeClinePassModelInfo
+
+	return {
+		// Core fields
+		apiProvider: mode === "plan" ? apiConfiguration.planModeApiProvider : apiConfiguration.actModeApiProvider,
+		apiModelId: mode === "plan" ? apiConfiguration.planModeApiModelId : apiConfiguration.actModeApiModelId,
+
+		// Provider-specific model IDs
+		togetherModelId: mode === "plan" ? apiConfiguration.planModeTogetherModelId : apiConfiguration.actModeTogetherModelId,
+		fireworksModelId: mode === "plan" ? apiConfiguration.planModeFireworksModelId : apiConfiguration.actModeFireworksModelId,
+		lmStudioModelId: mode === "plan" ? apiConfiguration.planModeLmStudioModelId : apiConfiguration.actModeLmStudioModelId,
+		ollamaModelId: mode === "plan" ? apiConfiguration.planModeOllamaModelId : apiConfiguration.actModeOllamaModelId,
+		liteLlmModelId: mode === "plan" ? apiConfiguration.planModeLiteLlmModelId : apiConfiguration.actModeLiteLlmModelId,
+		requestyModelId: mode === "plan" ? apiConfiguration.planModeRequestyModelId : apiConfiguration.actModeRequestyModelId,
+		openAiModelId: mode === "plan" ? apiConfiguration.planModeOpenAiModelId : apiConfiguration.actModeOpenAiModelId,
+		openRouterModelId,
+		clineModelId,
+		clinePassModelId,
+		groqModelId: mode === "plan" ? apiConfiguration.planModeGroqModelId : apiConfiguration.actModeGroqModelId,
+		basetenModelId: mode === "plan" ? apiConfiguration.planModeBasetenModelId : apiConfiguration.actModeBasetenModelId,
+		huggingFaceModelId:
+			mode === "plan" ? apiConfiguration.planModeHuggingFaceModelId : apiConfiguration.actModeHuggingFaceModelId,
+		huaweiCloudMaasModelId:
+			mode === "plan" ? apiConfiguration.planModeHuaweiCloudMaasModelId : apiConfiguration.actModeHuaweiCloudMaasModelId,
+		ocaModelId: mode === "plan" ? apiConfiguration.planModeOcaModelId : apiConfiguration.actModeOcaModelId,
+		hicapModelId: mode === "plan" ? apiConfiguration.planModeHicapModelId : apiConfiguration.actModeHicapModelId,
+		aihubmixModelId: mode === "plan" ? apiConfiguration.planModeAihubmixModelId : apiConfiguration.actModeAihubmixModelId,
+		nousResearchModelId:
+			mode === "plan" ? apiConfiguration.planModeNousResearchModelId : apiConfiguration.actModeNousResearchModelId,
+		vercelAiGatewayModelId:
+			mode === "plan" ? apiConfiguration.planModeVercelAiGatewayModelId : apiConfiguration.actModeVercelAiGatewayModelId,
+
+		// Model info objects
+		openAiModelInfo: mode === "plan" ? apiConfiguration.planModeOpenAiModelInfo : apiConfiguration.actModeOpenAiModelInfo,
+		liteLlmModelInfo: mode === "plan" ? apiConfiguration.planModeLiteLlmModelInfo : apiConfiguration.actModeLiteLlmModelInfo,
+		openRouterModelInfo,
+		clineModelInfo,
+		clinePassModelInfo,
+		requestyModelInfo:
+			mode === "plan" ? apiConfiguration.planModeRequestyModelInfo : apiConfiguration.actModeRequestyModelInfo,
+		groqModelInfo: mode === "plan" ? apiConfiguration.planModeGroqModelInfo : apiConfiguration.actModeGroqModelInfo,
+		basetenModelInfo: mode === "plan" ? apiConfiguration.planModeBasetenModelInfo : apiConfiguration.actModeBasetenModelInfo,
+		huggingFaceModelInfo:
+			mode === "plan" ? apiConfiguration.planModeHuggingFaceModelInfo : apiConfiguration.actModeHuggingFaceModelInfo,
+		vsCodeLmModelSelector:
+			mode === "plan" ? apiConfiguration.planModeVsCodeLmModelSelector : apiConfiguration.actModeVsCodeLmModelSelector,
+		hicapModelInfo: mode === "plan" ? apiConfiguration.planModeHicapModelInfo : apiConfiguration.actModeHicapModelInfo,
+		aihubmixModelInfo:
+			mode === "plan" ? apiConfiguration.planModeAihubmixModelInfo : apiConfiguration.actModeAihubmixModelInfo,
+		vercelAiGatewayModelInfo:
+			mode === "plan"
+				? apiConfiguration.planModeVercelAiGatewayModelInfo
+				: apiConfiguration.actModeVercelAiGatewayModelInfo,
+
+		// AWS Bedrock fields
+		awsBedrockCustomSelected:
+			mode === "plan"
+				? apiConfiguration.planModeAwsBedrockCustomSelected
+				: apiConfiguration.actModeAwsBedrockCustomSelected,
+		awsBedrockCustomModelBaseId:
+			mode === "plan"
+				? apiConfiguration.planModeAwsBedrockCustomModelBaseId
+				: apiConfiguration.actModeAwsBedrockCustomModelBaseId,
+
+		// Huawei Cloud Maas Model Info
+		huaweiCloudMaasModelInfo:
+			mode === "plan"
+				? apiConfiguration.planModeHuaweiCloudMaasModelInfo
+				: apiConfiguration.actModeHuaweiCloudMaasModelInfo,
+
+		// Other mode-specific fields
+		thinkingBudgetTokens:
+			mode === "plan" ? apiConfiguration.planModeThinkingBudgetTokens : apiConfiguration.actModeThinkingBudgetTokens,
+		reasoningEffort: mode === "plan" ? apiConfiguration.planModeReasoningEffort : apiConfiguration.actModeReasoningEffort,
+		// Oracle Code Assist
+		ocaModelInfo: mode === "plan" ? apiConfiguration.planModeOcaModelInfo : apiConfiguration.actModeOcaModelInfo,
+	}
+}
+
+/**
+ * Synchronizes mode configurations by copying the source mode's settings to both modes
+ * This is used when the "Use different models for Plan and Act modes" toggle is unchecked
+ */
+export async function syncModeConfigurations(
+	apiConfiguration: ApiConfiguration | undefined,
+	sourceMode: Mode,
+	handleFieldsChange: (updates: Partial<ApiConfiguration>) => Promise<void>,
+): Promise<void> {
+	if (!apiConfiguration) {
+		return
+	}
+
+	const sourceFields = getModeSpecificFields(apiConfiguration, sourceMode)
+	const { apiProvider } = sourceFields
+
+	if (!apiProvider) {
+		return
+	}
+
+	// Build the complete update object with both plan and act mode fields
+	const updates: Partial<ApiConfiguration> = {
+		// Always sync common fields
+		planModeApiProvider: sourceFields.apiProvider,
+		actModeApiProvider: sourceFields.apiProvider,
+		planModeThinkingBudgetTokens: sourceFields.thinkingBudgetTokens,
+		actModeThinkingBudgetTokens: sourceFields.thinkingBudgetTokens,
+		planModeReasoningEffort: sourceFields.reasoningEffort,
+		actModeReasoningEffort: sourceFields.reasoningEffort,
+	}
+
+	// Handle provider-specific fields
+	switch (apiProvider) {
+		case "openrouter":
+			updates.planModeOpenRouterModelId = sourceFields.openRouterModelId
+			updates.actModeOpenRouterModelId = sourceFields.openRouterModelId
+			updates.planModeOpenRouterModelInfo = sourceFields.openRouterModelInfo
+			updates.actModeOpenRouterModelInfo = sourceFields.openRouterModelInfo
+			break
+
+		case "cline":
+			updates.planModeClineModelId = sourceFields.clineModelId
+			updates.actModeClineModelId = sourceFields.clineModelId
+			updates.planModeClineModelInfo = sourceFields.clineModelInfo
+			updates.actModeClineModelInfo = sourceFields.clineModelInfo
+			break
+
+		case "cline-pass":
+			updates.planModeClinePassModelId = sourceFields.clinePassModelId
+			updates.actModeClinePassModelId = sourceFields.clinePassModelId
+			updates.planModeClinePassModelInfo = sourceFields.clinePassModelInfo
+			updates.actModeClinePassModelInfo = sourceFields.clinePassModelInfo
+			break
+
+		case "requesty":
+			updates.planModeRequestyModelId = sourceFields.requestyModelId
+			updates.actModeRequestyModelId = sourceFields.requestyModelId
+			updates.planModeRequestyModelInfo = sourceFields.requestyModelInfo
+			updates.actModeRequestyModelInfo = sourceFields.requestyModelInfo
+			break
+
+		case "openai":
+			updates.planModeOpenAiModelId = sourceFields.openAiModelId
+			updates.actModeOpenAiModelId = sourceFields.openAiModelId
+			updates.planModeOpenAiModelInfo = sourceFields.openAiModelInfo
+			updates.actModeOpenAiModelInfo = sourceFields.openAiModelInfo
+			break
+
+		case "ollama":
+			updates.planModeOllamaModelId = sourceFields.ollamaModelId
+			updates.actModeOllamaModelId = sourceFields.ollamaModelId
+			break
+
+		case "lmstudio":
+			updates.planModeLmStudioModelId = sourceFields.lmStudioModelId
+			updates.actModeLmStudioModelId = sourceFields.lmStudioModelId
+			break
+
+		case "vscode-lm":
+			updates.planModeVsCodeLmModelSelector = sourceFields.vsCodeLmModelSelector
+			updates.actModeVsCodeLmModelSelector = sourceFields.vsCodeLmModelSelector
+			break
+
+		case "litellm":
+			updates.planModeLiteLlmModelId = sourceFields.liteLlmModelId
+			updates.actModeLiteLlmModelId = sourceFields.liteLlmModelId
+			updates.planModeLiteLlmModelInfo = sourceFields.liteLlmModelInfo
+			updates.actModeLiteLlmModelInfo = sourceFields.liteLlmModelInfo
+			break
+
+		case "groq":
+			updates.planModeGroqModelId = sourceFields.groqModelId
+			updates.actModeGroqModelId = sourceFields.groqModelId
+			updates.planModeGroqModelInfo = sourceFields.groqModelInfo
+			updates.actModeGroqModelInfo = sourceFields.groqModelInfo
+			break
+
+		case "huggingface":
+			updates.planModeHuggingFaceModelId = sourceFields.huggingFaceModelId
+			updates.actModeHuggingFaceModelId = sourceFields.huggingFaceModelId
+			updates.planModeHuggingFaceModelInfo = sourceFields.huggingFaceModelInfo
+			updates.actModeHuggingFaceModelInfo = sourceFields.huggingFaceModelInfo
+			break
+
+		case "baseten":
+			updates.planModeBasetenModelId = sourceFields.basetenModelId
+			updates.actModeBasetenModelId = sourceFields.basetenModelId
+			updates.planModeBasetenModelInfo = sourceFields.basetenModelInfo
+			updates.actModeBasetenModelInfo = sourceFields.basetenModelInfo
+			break
+
+		case "together":
+			updates.planModeTogetherModelId = sourceFields.togetherModelId
+			updates.actModeTogetherModelId = sourceFields.togetherModelId
+			break
+
+		case "fireworks":
+			updates.planModeFireworksModelId = sourceFields.fireworksModelId
+			updates.actModeFireworksModelId = sourceFields.fireworksModelId
+			break
+
+		case "bedrock":
+			updates.planModeApiModelId = sourceFields.apiModelId
+			updates.actModeApiModelId = sourceFields.apiModelId
+			updates.planModeAwsBedrockCustomSelected = sourceFields.awsBedrockCustomSelected
+			updates.actModeAwsBedrockCustomSelected = sourceFields.awsBedrockCustomSelected
+			updates.planModeAwsBedrockCustomModelBaseId = sourceFields.awsBedrockCustomModelBaseId
+			updates.actModeAwsBedrockCustomModelBaseId = sourceFields.awsBedrockCustomModelBaseId
+			break
+		case "huawei-cloud-maas":
+			updates.planModeHuaweiCloudMaasModelId = sourceFields.huaweiCloudMaasModelId
+			updates.actModeHuaweiCloudMaasModelId = sourceFields.huaweiCloudMaasModelId
+			updates.planModeHuaweiCloudMaasModelInfo = sourceFields.huaweiCloudMaasModelInfo
+			updates.actModeHuaweiCloudMaasModelInfo = sourceFields.huaweiCloudMaasModelInfo
+			break
+
+		case "dify":
+			// Dify doesn't have mode-specific model configurations
+			// The model is configured in the Dify application itself
+			break
+
+		case "hicap":
+			updates.planModeHicapModelId = sourceFields.hicapModelId
+			updates.actModeHicapModelId = sourceFields.hicapModelId
+			updates.planModeHicapModelInfo = sourceFields.hicapModelInfo
+			updates.actModeHicapModelInfo = sourceFields.hicapModelInfo
+			break
+
+		case "vercel-ai-gateway":
+			// Vercel AI Gateway uses its own model fields
+			updates.planModeVercelAiGatewayModelId = sourceFields.vercelAiGatewayModelId
+			updates.actModeVercelAiGatewayModelId = sourceFields.vercelAiGatewayModelId
+			updates.planModeVercelAiGatewayModelInfo = sourceFields.vercelAiGatewayModelInfo
+			updates.actModeVercelAiGatewayModelInfo = sourceFields.vercelAiGatewayModelInfo
+			break
+		case "oca":
+			updates.planModeOcaModelId = sourceFields.ocaModelId
+			updates.actModeOcaModelId = sourceFields.ocaModelId
+			updates.planModeOcaModelInfo = sourceFields.ocaModelInfo
+			updates.actModeOcaModelInfo = sourceFields.ocaModelInfo
+			break
+		case "nousResearch":
+			updates.planModeNousResearchModelId = sourceFields.nousResearchModelId
+			updates.actModeNousResearchModelId = sourceFields.nousResearchModelId
+			break
+
+		case "aihubmix":
+			updates.planModeAihubmixModelId = sourceFields.aihubmixModelId
+			updates.planModeAihubmixModelInfo = sourceFields.aihubmixModelInfo
+			updates.actModeAihubmixModelId = sourceFields.aihubmixModelId
+			updates.actModeAihubmixModelInfo = sourceFields.aihubmixModelInfo
+			break
+
+		// Default branch: providers that use the common `apiProvider` +
+		// `apiModelId` ApiConfiguration field pair (anthropic, claude-code,
+		// vertex, gemini, openai-native, openai-codex, deepseek, qwen,
+		// doubao, mistral, asksage, xai, nebius, wandb, sambanova,
+		// cerebras, sapaicore, zai, minimax).
+		default:
+			updates.planModeApiModelId = sourceFields.apiModelId
+			updates.actModeApiModelId = sourceFields.apiModelId
+			break
+	}
+
+	// Make the atomic update
+	await handleFieldsChange(updates)
+}
+
+export { filterOpenRouterModelIds } from "@shared/utils/model-filters"
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/settingsHandlers.ts b/apps/vscode/webview-ui/src/components/settings/utils/settingsHandlers.ts
new file mode 100644
index 0000000..7bfef11
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/settingsHandlers.ts
@@ -0,0 +1,42 @@
+import { McpDisplayMode, UpdateSettingsRequest } from "@shared/proto/cline/state"
+import { StateServiceClient } from "@/services/grpc-client"
+
+/**
+ * Converts values to their corresponding proto format
+ * @param field - The field name
+ * @param value - The value to convert
+ * @returns The converted value
+ * @throws Error if the value is invalid for the field
+ */
+const convertToProtoValue = (field: keyof UpdateSettingsRequest, value: any): any => {
+	if (field === "mcpDisplayMode" && typeof value === "string") {
+		switch (value) {
+			case "rich":
+				return McpDisplayMode.RICH
+			case "plain":
+				return McpDisplayMode.PLAIN
+			case "markdown":
+				return McpDisplayMode.MARKDOWN
+			default:
+				throw new Error(`Invalid MCP display mode value: ${value}`)
+		}
+	}
+	return value
+}
+
+/**
+ * Updates a single field in the settings.
+ *
+ * @param field - The field key to update
+ * @param value - The new value for the field
+ */
+export const updateSetting = (field: keyof UpdateSettingsRequest, value: any) => {
+	const updateRequest: Partial<UpdateSettingsRequest> = {}
+
+	const convertedValue = convertToProtoValue(field, value)
+	updateRequest[field] = convertedValue
+
+	StateServiceClient.updateSettings(UpdateSettingsRequest.create(updateRequest)).catch((error) => {
+		console.error(`Failed to update setting ${field}:`, error)
+	})
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/useApiConfigurationHandlers.ts b/apps/vscode/webview-ui/src/components/settings/utils/useApiConfigurationHandlers.ts
new file mode 100644
index 0000000..b4dad51
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/useApiConfigurationHandlers.ts
@@ -0,0 +1,109 @@
+import { ApiConfiguration } from "@shared/api"
+import { UpdateApiConfigurationRequest } from "@shared/proto/cline/models"
+import { convertApiConfigurationToProto } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { Mode } from "@shared/storage/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+
+export const useApiConfigurationHandlers = () => {
+	const { apiConfiguration, planActSeparateModelsSetting } = useExtensionState()
+
+	/**
+	 * Updates a single field in the API configuration.
+	 *
+	 * **Warning**: If this function is called multiple times in rapid succession,
+	 * it can lead to race conditions where later calls may overwrite changes from
+	 * earlier calls. For updating multiple fields, use `handleFieldsChange` instead.
+	 *
+	 * @param field - The field key to update
+	 * @param value - The new value for the field
+	 */
+	const handleFieldChange = async <K extends keyof ApiConfiguration>(field: K, value: ApiConfiguration[K]) => {
+		const updatedConfig = {
+			...apiConfiguration,
+			[field]: value,
+		}
+
+		const protoConfig = convertApiConfigurationToProto(updatedConfig)
+		await ModelsServiceClient.updateApiConfigurationProto(
+			UpdateApiConfigurationRequest.create({
+				apiConfiguration: protoConfig,
+			}),
+		)
+	}
+
+	/**
+	 * Updates multiple fields in the API configuration at once.
+	 *
+	 * This function should be used when updating multiple fields to avoid race conditions
+	 * that can occur when calling `handleFieldChange` multiple times in succession.
+	 * All updates are applied together as a single operation.
+	 *
+	 * @param updates - An object containing the fields to update and their new values
+	 */
+	const handleFieldsChange = async (updates: Partial<ApiConfiguration>) => {
+		const updatedConfig = {
+			...apiConfiguration,
+			...updates,
+		}
+
+		const protoConfig = convertApiConfigurationToProto(updatedConfig)
+		await ModelsServiceClient.updateApiConfigurationProto(
+			UpdateApiConfigurationRequest.create({
+				apiConfiguration: protoConfig,
+			}),
+		)
+	}
+
+	const handleModeFieldChange = async <PlanK extends keyof ApiConfiguration, ActK extends keyof ApiConfiguration>(
+		fieldPair: { plan: PlanK; act: ActK },
+		value: ApiConfiguration[PlanK] & ApiConfiguration[ActK], // Intersection ensures value is compatible with both field types
+		currentMode: Mode,
+	) => {
+		if (planActSeparateModelsSetting) {
+			const targetField = fieldPair[currentMode]
+			await handleFieldChange(targetField, value)
+		} else {
+			await handleFieldsChange({
+				[fieldPair.plan]: value,
+				[fieldPair.act]: value,
+			})
+		}
+	}
+
+	/**
+	 * Updates multiple mode-specific fields in a single atomic operation.
+	 *
+	 * This prevents race conditions that can occur when making multiple separate
+	 * handleModeFieldChange calls in rapid succession.
+	 *
+	 * @param fieldPairs - Object mapping keys to plan/act field pairs
+	 * @param values - Object with values for each key
+	 * @param currentMode - The current mode being targeted
+	 */
+	const handleModeFieldsChange = async <T extends Record<string, any>>(
+		fieldPairs: { [K in keyof T]: { plan: keyof ApiConfiguration; act: keyof ApiConfiguration } },
+		values: T,
+		currentMode: Mode,
+	) => {
+		if (planActSeparateModelsSetting) {
+			// Update only the current mode's fields
+			const updates: Partial<ApiConfiguration> = {}
+			Object.entries(fieldPairs).forEach(([key, { plan, act }]) => {
+				const targetField = currentMode === "plan" ? plan : act
+				updates[targetField] = values[key]
+			})
+			await handleFieldsChange(updates)
+		} else {
+			// Update both modes' fields
+			const updates: Partial<ApiConfiguration> = {}
+			Object.entries(fieldPairs).forEach(([key, { plan, act }]) => {
+				updates[plan] = values[key]
+				updates[act] = values[key]
+			})
+			await handleFieldsChange(updates)
+		}
+	}
+
+	return { handleFieldChange, handleFieldsChange, handleModeFieldChange, handleModeFieldsChange }
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/useDebouncedInput.ts b/apps/vscode/webview-ui/src/components/settings/utils/useDebouncedInput.ts
new file mode 100644
index 0000000..d096f6c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/useDebouncedInput.ts
@@ -0,0 +1,42 @@
+import { useEffect, useRef, useState } from "react"
+import { useDebounceEffect } from "@/utils/useDebounceEffect"
+
+/**
+ * A custom hook that provides debounced input handling to prevent jumpy text inputs
+ * when saving changes directly to backend on every keystroke.
+ *
+ * @param initialValue - The initial value for the input
+ * @param onChange - Callback function to save the value (e.g., to backend)
+ * @param debounceMs - Debounce delay in milliseconds (default: 500ms)
+ * @returns A tuple of [currentValue, setValue] similar to useState
+ */
+export function useDebouncedInput<T>(
+	initialValue: T,
+	onChange: (value: T) => void,
+	debounceMs: number = 100,
+): [T, (value: T) => void] {
+	// Local state to prevent jumpy input - initialize once
+	const [localValue, setLocalValue] = useState(initialValue)
+
+	// Track previous initialValue to detect external changes
+	const prevInitialValueRef = useRef<T>(initialValue)
+
+	// Sync local state when initialValue changes externally (e.g., when switching Plan/Act tabs)
+	useEffect(() => {
+		if (prevInitialValueRef.current !== initialValue) {
+			setLocalValue(initialValue)
+			prevInitialValueRef.current = initialValue
+		}
+	}, [initialValue])
+
+	// Debounced backend save - saves after user stops changing value
+	useDebounceEffect(
+		() => {
+			onChange(localValue)
+		},
+		debounceMs,
+		[localValue],
+	)
+
+	return [localValue, setLocalValue]
+}
diff --git a/apps/vscode/webview-ui/src/components/settings/utils/useProviderApiKeyField.ts b/apps/vscode/webview-ui/src/components/settings/utils/useProviderApiKeyField.ts
new file mode 100644
index 0000000..c48113e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/settings/utils/useProviderApiKeyField.ts
@@ -0,0 +1,40 @@
+import { useCallback } from "react"
+import { getSavedApiKeyMask, sanitizeMaskedApiKeyInput } from "./apiKeyMasking"
+
+interface UseProviderApiKeyFieldOptions {
+	apiKeyLength?: number
+	canWrite?: boolean
+	onApiKeyChange?: (apiKey: string) => void
+	providerName: string
+	write: (patch: { apiKey: string }) => Promise<unknown>
+}
+
+export function useProviderApiKeyField({
+	apiKeyLength,
+	canWrite = true,
+	onApiKeyChange,
+	providerName,
+	write,
+}: UseProviderApiKeyFieldOptions) {
+	const savedApiKeyMask = getSavedApiKeyMask(apiKeyLength)
+
+	const handleApiKeyChange = useCallback(
+		(value: string) => {
+			if (!canWrite) {
+				return
+			}
+
+			const apiKey = sanitizeMaskedApiKeyInput(value, savedApiKeyMask)
+
+			if (apiKey === undefined) {
+				return
+			}
+
+			onApiKeyChange?.(apiKey)
+			void write({ apiKey }).catch((err) => console.error(`Failed to update ${providerName} API key:`, err))
+		},
+		[canWrite, onApiKeyChange, providerName, savedApiKeyMask, write],
+	)
+
+	return { savedApiKeyMask, handleApiKeyChange }
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/alert.stories.tsx b/apps/vscode/webview-ui/src/components/ui/alert.stories.tsx
new file mode 100644
index 0000000..c3ca856
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/alert.stories.tsx
@@ -0,0 +1,47 @@
+import type { Meta } from "@storybook/react-vite"
+import ClineLogoWhite from "@/assets/ClineLogoWhite"
+import { Alert, AlertDescription } from "./alert"
+
+const meta: Meta<typeof Alert> = {
+	title: "Ui/Alert",
+	component: Alert,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays alert messages with different severity levels (default, warning, danger). Includes optional dismiss functionality and supports title and description content.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center">
+		<div className="flex flex-col gap-4 w-full max-w-md px-4">
+			<Alert title="Default" variant="default">
+				<AlertDescription>This is a default alert message.</AlertDescription>
+			</Alert>
+			<Alert title="Warning" variant="warning">
+				<AlertDescription>This is a warning alert.</AlertDescription>
+			</Alert>
+			<Alert title="Error" variant="danger">
+				<AlertDescription>An error has occurred.</AlertDescription>
+			</Alert>
+			<Alert isDismissible={false} title="Non Dismissible" variant="default">
+				<AlertDescription>This alert cannot be dismissed.</AlertDescription>
+			</Alert>
+			<Alert icon={<ClineLogoWhite className="size-2" />} title="Brand" variant="cline">
+				<AlertDescription>
+					<p className="my-1">How can I help you?</p>
+					<ul className="list-inside list-disc text-sm">
+						<li>Coding</li>
+						<li>Debugging</li>
+						<li>Write Tests</li>
+					</ul>
+				</AlertDescription>
+			</Alert>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/alert.tsx b/apps/vscode/webview-ui/src/components/ui/alert.tsx
new file mode 100644
index 0000000..23d55fb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/alert.tsx
@@ -0,0 +1,78 @@
+import { cva, type VariantProps } from "class-variance-authority"
+import { AlertTriangleIcon, XIcon } from "lucide-react"
+import * as React from "react"
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+
+const alertVariants = cva(
+	"relative w-full rounded-sm border p-2 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:text-foreground [&>svg~*]:pl-7 flex flex-col gap-1 mb-1",
+	{
+		variants: {
+			variant: {
+				default: "bg-banner-background text-banner-foreground border-foreground/20",
+				warning: "bg-warning/50 border-foreground/20 [&>svg]:text-warning-foreground",
+				danger: "bg-input-error-background text-foreground border-foreground/20 [&>svg]:text-input-error-foreground",
+				cline: "bg-cline/20 text-fg-cline border-cline [&>svg]:text-fg-cline",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+)
+
+const Alert = React.forwardRef<
+	HTMLDivElement,
+	React.HTMLAttributes<HTMLDivElement> &
+		VariantProps<typeof alertVariants> & { isDismissible?: boolean; title?: string; icon?: React.ReactNode }
+>(({ className, variant, children, isDismissible = true, title, icon, ...props }, ref) => {
+	const [dismissed, setDismissed] = React.useState(false)
+	if (dismissed) {
+		return null
+	}
+
+	return (
+		<div className={cn(alertVariants({ variant }), className)} ref={ref} role="alert" {...props}>
+			<div className="flex items-center justify-between w-full">
+				<AlertTitle className="flex gap-1 w-full">
+					<span className="mr-1 shrink-0">{icon ?? <AlertTriangleIcon className="size-2" />}</span>
+					{title}
+				</AlertTitle>
+				{isDismissible && (
+					<Button
+						aria-label="Dismiss"
+						className="opacity-100 hover:opacity-100 justify-center"
+						onClick={(e) => {
+							e.preventDefault()
+							e.stopPropagation()
+							setDismissed(true)
+						}}
+						size="icon"
+						variant="icon">
+						<XIcon />
+					</Button>
+				)}
+			</div>
+			{children}
+		</div>
+	)
+})
+Alert.displayName = "Alert"
+
+const AlertTitle = React.forwardRef<HTMLHeadingElement, React.HTMLAttributes<HTMLHeadingElement>>(
+	({ className, ...props }, ref) => (
+		<h5
+			className={cn("font-medium leading-none tracking-tight text-base flex gap-1 items-center grow", className)}
+			ref={ref}
+			{...props}
+		/>
+	),
+)
+AlertTitle.displayName = "AlertTitle"
+
+const AlertDescription = React.forwardRef<HTMLParagraphElement, React.HTMLAttributes<HTMLParagraphElement>>(
+	({ className, ...props }, ref) => <div className={cn("text-sm [&_p]:leading-relaxed", className)} ref={ref} {...props} />,
+)
+AlertDescription.displayName = "AlertDescription"
+
+export { Alert, AlertDescription }
diff --git a/apps/vscode/webview-ui/src/components/ui/badge.stories.tsx b/apps/vscode/webview-ui/src/components/ui/badge.stories.tsx
new file mode 100644
index 0000000..764161d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/badge.stories.tsx
@@ -0,0 +1,71 @@
+import type { Meta } from "@storybook/react-vite"
+import { ClockIcon, XIcon } from "lucide-react"
+import { Badge } from "./badge"
+
+const meta: Meta<typeof Badge> = {
+	title: "Ui/Badge",
+	component: Badge,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays a badge with different variants (default, info, danger, outline, brand, neutral, gray, success, warning) and types (default, round, icon). Used to highlight status, categories, or counts.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => {
+	const variants = ["default", "info", "danger", "outline", "cline", "success", "warning"] as const
+
+	const types = [
+		{ value: "default", label: "Default" },
+		{ value: "icon", label: "With Icon" },
+		{ value: "round", label: "Icon Only" },
+	] as const
+
+	return (
+		<div className="w-screen flex justify-center p-8">
+			<div className="flex flex-col gap-8 w-full max-w-4xl">
+				{types.map((type) => (
+					<div className="flex flex-col gap-4" key={type.value}>
+						<h2 className="text-lg font-semibold">{type.label}</h2>
+						<div className="flex flex-wrap gap-3 items-center">
+							{variants.map((variant) => (
+								<Badge key={variant} type={type.value} variant={variant}>
+									{type.value === "icon" && <ClockIcon />}
+									{type.value === "round" ? <ClockIcon /> : variant.charAt(0).toUpperCase() + variant.slice(1)}
+								</Badge>
+							))}
+						</div>
+					</div>
+				))}
+			</div>
+		</div>
+	)
+}
+
+export const Dismissible = () => {
+	const variants = ["cline", "danger", "success", "warning"] as const
+
+	return (
+		<div className="w-screen flex justify-center p-8">
+			<div className="flex flex-wrap gap-3">
+				{variants.map((variant) => (
+					<Badge className="gap-1 pe-0.5 ps-1.5" key={variant} type="icon" variant={variant}>
+						<span>{variant.charAt(0).toUpperCase() + variant.slice(1)}</span>
+						<button
+							aria-label="Remove"
+							className="inline-flex items-center p-0.5 text-sm bg-transparent rounded-xs hover:opacity-80"
+							type="button">
+							<XIcon className="w-3 h-3" />
+							<span className="sr-only">Remove badge</span>
+						</button>
+					</Badge>
+				))}
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/badge.tsx b/apps/vscode/webview-ui/src/components/ui/badge.tsx
new file mode 100644
index 0000000..fb5d4e8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/badge.tsx
@@ -0,0 +1,38 @@
+import { cva, type VariantProps } from "class-variance-authority"
+import type * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const badgeVariants = cva(
+	"inline-flex items-center border text-xs font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 [&_svg]:size-2 text-badge-foreground shadow-xs",
+	{
+		variants: {
+			variant: {
+				default: "border-transparent bg-badge-background",
+				info: "border-transparent bg-button-background/80",
+				danger: "border-transparent bg-error-icon",
+				outline: "text-foreground border border-accent/20",
+				cline: "bg-cline border-cline",
+				success: "bg-success/80 border-success",
+				warning: "bg-warning/80 border-warning/50",
+			},
+			type: {
+				default: "rounded px-1.5 py-0.5",
+				round: "rounded-full h-5 w-5 justify-center p-0 border-none",
+				icon: "rounded px-1.5 py-0.5 gap-1 ring-0",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			type: "default",
+		},
+	},
+)
+
+interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, type, ...props }: BadgeProps) {
+	return <div className={cn(badgeVariants({ variant, type }), className)} {...props} />
+}
+
+export { Badge }
diff --git a/apps/vscode/webview-ui/src/components/ui/button.stories.tsx b/apps/vscode/webview-ui/src/components/ui/button.stories.tsx
new file mode 100644
index 0000000..864ba2d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/button.stories.tsx
@@ -0,0 +1,51 @@
+import type { Meta } from "@storybook/react-vite"
+import { SearchIcon } from "lucide-react"
+import { Button } from "./button"
+
+const meta: Meta<typeof Button> = {
+	title: "Ui/Button",
+	component: Button,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays different types of error messages in the chat interface, including API errors, credit limit errors, diff errors, and clineignore errors. Handles special error parsing for Cline provider errors and provides appropriate user actions.",
+			},
+		},
+	},
+}
+
+export default meta
+
+// Default showcase all variants
+export const Overview = () => {
+	const sizes = [
+		{ value: "sm", label: "Small" },
+		{ value: "default", label: "Default" },
+		{ value: "lg", label: "Large" },
+	] as const
+
+	const variants = ["default", "secondary", "danger", "outline", "ghost", "link", "text", "icon"] as const
+
+	return (
+		<div className="w-screen flex justify-center gap-4">
+			{sizes.map((size) => (
+				<div className="flex flex-col gap-4 w-md px-auto" key={size.value}>
+					<h1>{size.label}</h1>
+					{variants.map((variant) => (
+						<Button key={variant} size={size.value === "default" ? undefined : size.value} variant={variant}>
+							{variant === "icon" ? (
+								<>
+									<SearchIcon />
+									{size.value === "default" && " Icon with Text"}
+								</>
+							) : (
+								variant.charAt(0).toUpperCase() + variant.slice(1)
+							)}
+						</Button>
+					))}
+				</div>
+			))}
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/button.tsx b/apps/vscode/webview-ui/src/components/ui/button.tsx
new file mode 100644
index 0000000..edfd699
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/button.tsx
@@ -0,0 +1,55 @@
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+import * as React from "react"
+import { cn } from "@/lib/utils"
+
+const buttonVariants = cva(
+	"inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-xs focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 cursor-pointer [&_svg]:size-2 overflow-hidden",
+	{
+		variants: {
+			variant: {
+				default: "bg-button-background text-primary-foreground hover:bg-button-hover",
+				secondary:
+					"bg-button-secondary-background text-button-secondary-foreground hover:bg-button-secondary-background-hover shadow-sm shadow-button-secondary-background/50",
+				error: "bg-error text-background hover:bg-error/90 shadow-sm shadow-error/50",
+				outline: "hover:bg-accent/10 border border-accent/20 shadow-sm shadow-accent/50",
+				"outline-primary":
+					"!bg-transparent !border-[var(--vscode-button-background)] !border-[1px] !border-solid !text-[var(--vscode-button-background)] !hover:bg-[color-mix(in_srgb,var(--vscode-button-background)_15%,transparent)] !active:bg-[color-mix(in_srgb,var(--vscode-button-background)_25%,transparent)]",
+				ghost: "hover:bg-accent/10",
+				link: "text-link underline-offset-4 hover:underline p-0 m-0 cursor-text select-text hover:text-link-hover",
+				text: "text-foreground cursor-text select-text p-0 m-0",
+				icon: "hover:opacity-80 p-0 m-0 border-0 cursor-pointer hover:shadow-none focus:ring-0 focus:ring-offset-0",
+				cline: "bg-cline border-foreground/20 text-cline-foreground",
+				success:
+					"bg-success/10 text-success border-[#176f2c] text-white hover:bg-[#197f31] hover:border-[#197f31] active:bg-[#156528] active:border-[#156528] hover:text-white",
+				danger: "bg-[#c42b2b] border-[#c42b2b]! text-white! hover:bg-[#a82424]! hover:border-[#a82424]! active:bg-[#8f1f1f]! active:border-[#8f1f1f]!",
+			},
+			size: {
+				default: "py-1.5 px-4 [&_svg]:size-3",
+				sm: "py-1 px-3 text-sm [&_svg]:size-2",
+				xs: "p-1 text-xs [&_svg]:size-2",
+				lg: "py-4 px-8 [&_svg]:size-4 font-medium",
+				icon: "px-0.5 m-0 [&_svg]:size-2",
+				header: "py-1 px-4 [&_svg]:size-2.5",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+)
+
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+	asChild?: boolean
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+	({ className, variant, size, asChild = false, ...props }, ref) => {
+		const Comp = asChild ? Slot : "button"
+		return <Comp className={cn(buttonVariants({ variant, size, className }))} ref={ref} {...props} />
+	},
+)
+Button.displayName = "Button"
+
+export { Button }
diff --git a/apps/vscode/webview-ui/src/components/ui/dialog.stories.tsx b/apps/vscode/webview-ui/src/components/ui/dialog.stories.tsx
new file mode 100644
index 0000000..4ecced3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/dialog.stories.tsx
@@ -0,0 +1,240 @@
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import ClineLogoWhite from "@/assets/ClineLogoWhite"
+import { Button } from "./button"
+import {
+	Dialog,
+	DialogClose,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "./dialog"
+
+const meta: Meta = {
+	title: "Ui/Dialog",
+	component: Dialog,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"A modal dialog component built on Radix UI. Displays content in a layer above the main application with an overlay backdrop. Includes header, footer, title, description, and close button components for composing dialog layouts.",
+			},
+		},
+	},
+}
+
+export default meta
+
+type StoryProps = {
+	dialogTitle: string
+	dialogDescription: string
+	dialogContent: string
+	showFooter: boolean
+	hideClose: boolean
+	cancelText: string
+	confirmText: string
+	triggerVariant: "default" | "secondary" | "danger" | "outline" | "ghost" | "link"
+	confirmVariant: "default" | "secondary" | "danger" | "outline" | "ghost"
+}
+
+// Interactive story with controls
+export const Interactive: StoryObj<StoryProps> = {
+	args: {
+		dialogTitle: "Dialog Title",
+		dialogDescription: "This is a description of what this dialog is about.",
+		dialogContent: "This is the main content area of the dialog.",
+		showFooter: true,
+		hideClose: false,
+		cancelText: "Cancel",
+		confirmText: "Confirm",
+		triggerVariant: "default",
+		confirmVariant: "default",
+	},
+	argTypes: {
+		dialogTitle: {
+			control: "text",
+			description: "Dialog title text",
+		},
+		dialogDescription: {
+			control: "text",
+			description: "Dialog description text",
+		},
+		dialogContent: {
+			control: "text",
+			description: "Main content of the dialog",
+		},
+		showFooter: {
+			control: "boolean",
+			description: "Show or hide the footer with action buttons",
+		},
+		cancelText: {
+			control: "text",
+			description: "Cancel button text",
+		},
+		confirmText: {
+			control: "text",
+			description: "Confirm button text",
+		},
+		triggerVariant: {
+			control: "select",
+			options: ["default", "secondary", "danger", "outline", "ghost", "link"],
+			description: "Trigger button variant",
+		},
+		confirmVariant: {
+			control: "select",
+			options: ["default", "secondary", "danger", "outline", "ghost"],
+			description: "Confirm button variant",
+		},
+		hideClose: {
+			control: "boolean",
+			description: "Hide or show the close button in the dialog",
+		},
+	},
+	render: (args) => (
+		<div className="w-full h-full flex justify-center items-center overflow-hidden">
+			<div className="flex flex-col justify-center items-center h-[60%] w-[50%] overflow-hidden mt-50">
+				<div className="flex justify-center my-5">
+					<ClineLogoWhite className="size-16" />
+				</div>
+				<p>
+					You can customize the dialog using the controls in the "Controls" panel below to change its title,
+					description, content, and button variants.
+				</p>
+
+				<div className="mt-4.5">
+					<Dialog>
+						<DialogTrigger asChild>
+							<Button variant={args.triggerVariant}>Open Dialog</Button>
+						</DialogTrigger>
+						<DialogContent hideClose={args.hideClose}>
+							<DialogHeader>
+								<DialogTitle>{args.dialogTitle}</DialogTitle>
+								<DialogDescription>{args.dialogDescription}</DialogDescription>
+							</DialogHeader>
+							<p className="text-sm">{args.dialogContent}</p>
+							{args.showFooter && (
+								<DialogFooter>
+									<DialogClose asChild>
+										<Button variant="ghost">{args.cancelText}</Button>
+									</DialogClose>
+									<Button variant={args.confirmVariant}>{args.confirmText}</Button>
+								</DialogFooter>
+							)}
+						</DialogContent>
+					</Dialog>
+				</div>
+			</div>
+		</div>
+	),
+}
+
+// Showcase all dialog variants
+export const Overview = () => {
+	const variants = [
+		{
+			label: "Complete",
+			triggerVariant: "default" as const,
+			title: "Dialog Title",
+			description:
+				"This is a description of what this dialog is about. It provides context to the user about the action they're taking.",
+			content:
+				"This is the main content area of the dialog. You can put any content here, such as forms, information, or other interactive elements.",
+			hasFooter: true,
+			cancelVariant: "ghost" as const,
+			confirmVariant: "default" as const,
+			confirmText: "Confirm",
+		},
+		{
+			label: "Simple",
+			triggerVariant: "secondary" as const,
+			title: "Simple Dialog",
+			description: "This dialog has no footer, just content.",
+			content: "This is a simpler dialog without action buttons in the footer.",
+			hasFooter: false,
+		},
+		{
+			label: "Confirmation",
+			triggerVariant: "danger" as const,
+			title: "Are you sure?",
+			description: "This action cannot be undone. This will permanently delete the item.",
+			content: null,
+			hasFooter: true,
+			cancelVariant: "secondary" as const,
+			confirmVariant: "danger" as const,
+			confirmText: "Delete",
+		},
+		{
+			label: "With Form",
+			triggerVariant: "outline" as const,
+			title: "Edit Profile",
+			description: "Make changes to your profile here.",
+			content: (
+				<div className="grid gap-4 py-4">
+					<div className="grid gap-2">
+						<label className="text-sm font-medium" htmlFor="name">
+							Name
+						</label>
+						<input
+							className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+							defaultValue="John Doe"
+							id="name"
+						/>
+					</div>
+					<div className="grid gap-2">
+						<label className="text-sm font-medium" htmlFor="email">
+							Email
+						</label>
+						<input
+							className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+							defaultValue="john@example.com"
+							id="email"
+							type="email"
+						/>
+					</div>
+				</div>
+			),
+			hasFooter: true,
+			cancelVariant: "secondary" as const,
+			confirmVariant: "default" as const,
+			confirmText: "Save Changes",
+		},
+	]
+
+	return (
+		<div className="w-screen">
+			<div className="flex flex-col justify-center h-[60%] w-[80%] overflow-hidden gap-8 p-8">
+				{variants.map((variant) => (
+					<div className="flex flex-col gap-4 items-center" key={variant.label}>
+						<h2 className="text-lg font-semibold">{variant.label}</h2>
+						<Dialog>
+							<DialogTrigger asChild>
+								<Button variant={variant.triggerVariant}>Open {variant.label}</Button>
+							</DialogTrigger>
+							<DialogContent>
+								<DialogHeader>
+									<DialogTitle>{variant.title}</DialogTitle>
+									<DialogDescription>{variant.description}</DialogDescription>
+								</DialogHeader>
+								{typeof variant.content === "string" ? (
+									<p className="text-sm">{variant.content}</p>
+								) : (
+									variant.content
+								)}
+								{variant.hasFooter && (
+									<DialogFooter>
+										<DialogClose asChild>
+											<Button variant={variant.cancelVariant}>Cancel</Button>
+										</DialogClose>
+										<Button variant={variant.confirmVariant}>{variant.confirmText}</Button>
+									</DialogFooter>
+								)}
+							</DialogContent>
+						</Dialog>
+					</div>
+				))}
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/dialog.tsx b/apps/vscode/webview-ui/src/components/ui/dialog.tsx
new file mode 100644
index 0000000..d635499
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/dialog.tsx
@@ -0,0 +1,84 @@
+import * as DialogPrimitive from "@radix-ui/react-dialog"
+import { XIcon } from "lucide-react"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Dialog = DialogPrimitive.Root
+
+const DialogTrigger = DialogPrimitive.Trigger
+
+const DialogPortal = DialogPrimitive.Portal
+
+const DialogClose = DialogPrimitive.Close
+
+const DialogOverlay = React.forwardRef<
+	React.ElementRef<typeof DialogPrimitive.Overlay>,
+	React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+	<DialogPrimitive.Overlay
+		className={cn(
+			"fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+			className,
+		)}
+		ref={ref}
+		{...props}
+	/>
+))
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName
+
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+	hideClose?: boolean
+}
+
+const DialogContent = React.forwardRef<React.ElementRef<typeof DialogPrimitive.Content>, DialogContentProps>(
+	({ className, children, hideClose = false, ...props }, ref) => (
+		<DialogPortal>
+			<DialogOverlay />
+			<DialogPrimitive.Content
+				className={cn(
+					"fixed left-[50%] top-[35%] z-50 grid w-[calc(100%-2rem)] max-w-lg translate-x-[-50%] translate-y-[-35%] gap-4 border border-input-placeholder/10 bg-background p-3 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 rounded-lg focus:outline-none",
+					className,
+				)}
+				ref={ref}
+				{...props}>
+				{children}
+				{!hideClose && (
+					<DialogPrimitive.Close className="absolute right-4 top-4 rounded-xs opacity-70 ring-offset-background transition-opacity hover:opacity-100 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground cursor-pointer">
+						<XIcon className="size-2" />
+						<span className="sr-only">Close</span>
+					</DialogPrimitive.Close>
+				)}
+			</DialogPrimitive.Content>
+		</DialogPortal>
+	),
+)
+DialogContent.displayName = DialogPrimitive.Content.displayName
+
+const DialogHeader = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
+	<div className={cn("flex flex-col space-y-1.5 text-center sm:text-left", className)} {...props} />
+)
+DialogHeader.displayName = "DialogHeader"
+
+const DialogFooter = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
+	<div className={cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className)} {...props} />
+)
+DialogFooter.displayName = "DialogFooter"
+
+const DialogTitle = React.forwardRef<
+	React.ElementRef<typeof DialogPrimitive.Title>,
+	React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
+>(({ className, ...props }, ref) => (
+	<DialogPrimitive.Title className={cn("text-lg font-semibold leading-none tracking-tight", className)} ref={ref} {...props} />
+))
+DialogTitle.displayName = DialogPrimitive.Title.displayName
+
+const DialogDescription = React.forwardRef<
+	React.ElementRef<typeof DialogPrimitive.Description>,
+	React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
+>(({ className, ...props }, ref) => (
+	<DialogPrimitive.Description className={cn("text-sm text-description", className)} ref={ref} {...props} />
+))
+DialogDescription.displayName = DialogPrimitive.Description.displayName
+
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger }
diff --git a/apps/vscode/webview-ui/src/components/ui/hooks/useOpenRouterKeyInfo.ts b/apps/vscode/webview-ui/src/components/ui/hooks/useOpenRouterKeyInfo.ts
new file mode 100644
index 0000000..14585ac
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/hooks/useOpenRouterKeyInfo.ts
@@ -0,0 +1,148 @@
+import { useEffect, useState } from "react"
+import { z } from "zod"
+
+const CACHE_DURATION_MS = 30 * 1000 // 30 seconds
+const OpenRouterBaseURL = "https://openrouter.ai/api/v1"
+
+// Define schema for OpenRouter key response
+const openRouterKeyInfoSchema = z.object({
+	data: z.object({
+		label: z.string().nullable(),
+		usage: z.number(),
+		is_free_tier: z.boolean(),
+		is_provisioning_key: z.boolean(),
+		rate_limit: z.object({
+			requests: z.number(),
+			interval: z.string(),
+		}),
+		limit: z.number().nullable(),
+	}),
+})
+export type OpenRouterKeyInfo = z.infer<typeof openRouterKeyInfoSchema>["data"]
+
+// Module-level cache variables
+let moduleCachedData: OpenRouterKeyInfo | null = null
+let moduleLastFetchTime: number | null = null
+
+async function getOpenRouterKeyInfo(apiKey: string, signal: AbortSignal): Promise<OpenRouterKeyInfo | null> {
+	try {
+		const keyEndpoint = `${OpenRouterBaseURL}/key`
+		const response = await fetch(keyEndpoint, {
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+			},
+			signal,
+		})
+
+		if (!response.ok) {
+			if (response.status === 401) {
+				console.warn("OpenRouter API key is invalid or unauthorized.")
+			} else {
+				console.error(`Error fetching OpenRouter key info: HTTP ${response.status}`)
+			}
+			return null
+		}
+
+		const responseData = await response.json()
+		const result = openRouterKeyInfoSchema.safeParse(responseData)
+		if (!result.success) {
+			console.error("OpenRouter API key info validation failed:", result.error.flatten().fieldErrors)
+			return null
+		}
+		return result.data.data
+	} catch (error: any) {
+		if (error.name !== "AbortError") {
+			console.error("Error fetching OpenRouter key info:", error)
+		}
+		return null
+	}
+}
+
+/**
+ * Custom hook to fetch OpenRouter API key information.
+ * Implements stale-while-revalidate caching using module-level variables.
+ * @param apiKey The OpenRouter API key.
+ * @returns An object containing the key info data, loading state, and error state.
+ */
+export const useOpenRouterKeyInfo = (apiKey?: string) => {
+	// State reflects the currently displayed data, initialized from cache
+	const [data, setData] = useState<OpenRouterKeyInfo | null>(moduleCachedData)
+	// Loading is true only if there's no initial cache and a key is provided
+	const [isLoading, setIsLoading] = useState<boolean>(!moduleCachedData && !!apiKey)
+	const [error, setError] = useState<Error | null>(null)
+
+	useEffect(() => {
+		const controller = new AbortController()
+		const signal = controller.signal
+
+		if (!apiKey) {
+			// Clear state and cache if API key is removed
+			setData(null)
+			moduleCachedData = null
+			moduleLastFetchTime = null
+			setIsLoading(false)
+			setError(null)
+			return () => controller.abort()
+		}
+
+		const now = Date.now()
+		const cacheAge = moduleLastFetchTime ? now - moduleLastFetchTime : Infinity
+		const isCacheStale = cacheAge >= CACHE_DURATION_MS
+		const hasCache = !!moduleCachedData
+
+		// Use cached data immediately if available
+		if (hasCache) {
+			// Ensure local state matches module cache if it hasn't updated yet
+			// This handles cases where the hook re-renders before the effect runs
+			if (data !== moduleCachedData) {
+				setData(moduleCachedData)
+			}
+			setIsLoading(false)
+		} else {
+			setIsLoading(true)
+			setError(null)
+		}
+
+		// Fetch if cache is stale or doesn't exist
+		if (isCacheStale || !hasCache) {
+			const isBackgroundFetch = hasCache && isCacheStale // Fetching while showing stale data
+
+			// Don't set loading true for background fetches
+			if (!isBackgroundFetch) {
+				setIsLoading(true)
+			}
+
+			getOpenRouterKeyInfo(apiKey, signal)
+				.then((result) => {
+					if (!signal.aborted) {
+						moduleCachedData = result // Update module cache
+						moduleLastFetchTime = Date.now() // Update module fetch time
+						setData(result) // Update state
+						setError(null) // Clear error on success
+					}
+				})
+				.catch((err) => {
+					if (!signal.aborted) {
+						console.error("[useOpenRouterKeyInfo] Fetch error:", err)
+						setError(err instanceof Error ? err : new Error("An unknown error occurred"))
+						if (!isBackgroundFetch) {
+							setData(null)
+							moduleCachedData = null
+							moduleLastFetchTime = null
+						}
+					}
+				})
+				.finally(() => {
+					if (!signal.aborted) {
+						setIsLoading(false) // Stop loading indicator
+					}
+				})
+		}
+
+		return () => {
+			controller.abort()
+		}
+	}, [apiKey]) // Re-run effect only when apiKey changes
+
+	return { data, isLoading, error }
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/hover-card.stories.tsx b/apps/vscode/webview-ui/src/components/ui/hover-card.stories.tsx
new file mode 100644
index 0000000..bebf569
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/hover-card.stories.tsx
@@ -0,0 +1,50 @@
+import type { Meta } from "@storybook/react-vite"
+import { Button } from "./button"
+import { HoverCard, HoverCardContent, HoverCardTrigger } from "./hover-card"
+
+const meta: Meta<typeof HoverCard> = {
+	title: "Ui/HoverCard",
+	component: HoverCard,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays additional content in a floating card when hovering over a trigger element. Built on Radix UI with customizable alignment and side offset.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center min-h-[400px]">
+		<div className="flex flex-col gap-8 w-full max-w-md px-4">
+			<HoverCard>
+				<HoverCardTrigger asChild>
+					<Button>Hover over me</Button>
+				</HoverCardTrigger>
+				<HoverCardContent>
+					<div className="space-y-2">
+						<h4 className="text-sm font-semibold">Hover Card Title</h4>
+						<p className="text-sm">This is the content that appears when you hover over the trigger element.</p>
+					</div>
+				</HoverCardContent>
+			</HoverCard>
+
+			<HoverCard>
+				<HoverCardTrigger asChild>
+					<span className="text-sm underline cursor-pointer">Hover for more info</span>
+				</HoverCardTrigger>
+				<HoverCardContent align="start">
+					<div className="space-y-2">
+						<h4 className="text-sm font-semibold">Additional Information</h4>
+						<p className="text-sm">
+							Hover cards can contain any content including text, images, or other components.
+						</p>
+					</div>
+				</HoverCardContent>
+			</HoverCard>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/hover-card.tsx b/apps/vscode/webview-ui/src/components/ui/hover-card.tsx
new file mode 100644
index 0000000..c7b6bdb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/hover-card.tsx
@@ -0,0 +1,37 @@
+import * as HoverCardPrimitive from "@radix-ui/react-hover-card"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const HoverCard = HoverCardPrimitive.Root
+
+const HoverCardTrigger = HoverCardPrimitive.Trigger
+
+function HoverCardContent({
+	className,
+	align = "center",
+	sideOffset = 4,
+	children,
+	...props
+}: React.ComponentProps<typeof HoverCardPrimitive.Content>) {
+	return (
+		<HoverCardPrimitive.Portal data-slot="hover-card-portal">
+			<HoverCardPrimitive.Content
+				align={align}
+				className={cn(
+					"bg-code text-code-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-64 origin-(--radix-hover-card-content-transform-origin) rounded-xs p-2 shadow-md outline-hidden border border-muted-foreground/30",
+					className,
+				)}
+				data-slot="hover-card-content"
+				sideOffset={sideOffset}
+				{...props}>
+				{children}
+				<HoverCardPrimitive.Arrow className="bg-code fill-background z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px] border-b border-r border-muted-foreground/30" />
+			</HoverCardPrimitive.Content>
+		</HoverCardPrimitive.Portal>
+	)
+}
+
+HoverCardContent.displayName = HoverCardPrimitive.Content.displayName
+
+export { HoverCard, HoverCardTrigger, HoverCardContent }
diff --git a/apps/vscode/webview-ui/src/components/ui/input.stories.tsx b/apps/vscode/webview-ui/src/components/ui/input.stories.tsx
new file mode 100644
index 0000000..11dd05b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/input.stories.tsx
@@ -0,0 +1,35 @@
+import type { Meta } from "@storybook/react-vite"
+import { Button } from "./button"
+import { Input } from "./input"
+
+const meta: Meta<typeof Input> = {
+	title: "Ui/Input",
+	component: Input,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"A styled text input component that supports all standard HTML input types. Includes focus states, placeholder text, and disabled state styling.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center">
+		<div className="flex flex-col gap-4 w-full max-w-md px-4">
+			<Input placeholder="Default text input" type="text" />
+			<Input placeholder="Email input" type="email" />
+			<Input placeholder="Password input" type="password" />
+			<Input placeholder="Number input" type="number" />
+			<Input disabled placeholder="Disabled input" type="text" />
+			<Input defaultValue="Input with value" type="text" />
+			<div className="flex w-full items-center gap-2">
+				<Input placeholder="Email" type="email" />
+				<Button type="submit">Subscribe</Button>
+			</div>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/input.tsx b/apps/vscode/webview-ui/src/components/ui/input.tsx
new file mode 100644
index 0000000..1c09214
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/input.tsx
@@ -0,0 +1,20 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(({ className, type, ...props }, ref) => {
+	return (
+		<input
+			className={cn(
+				"flex w-full rounded-sm border border-input-foreground/20 bg-input-background px-3 py-2 text-base text-input-foreground shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-input-placeholder focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-input-border disabled:cursor-not-allowed disabled:opacity-50 md:text-sm text-pretty text-ellipsis",
+				className,
+			)}
+			ref={ref}
+			type={type}
+			{...props}
+		/>
+	)
+})
+Input.displayName = "Input"
+
+export { Input }
diff --git a/apps/vscode/webview-ui/src/components/ui/item.stories.tsx b/apps/vscode/webview-ui/src/components/ui/item.stories.tsx
new file mode 100644
index 0000000..cf8b644
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/item.stories.tsx
@@ -0,0 +1,109 @@
+import type { Meta } from "@storybook/react-vite"
+import { BellIcon, SettingsIcon, UserIcon } from "lucide-react"
+import { Badge } from "./badge"
+import { Button } from "./button"
+import {
+	Item,
+	ItemActions,
+	ItemContent,
+	ItemDescription,
+	ItemFooter,
+	ItemGroup,
+	ItemHeader,
+	ItemMedia,
+	ItemSeparator,
+	ItemTitle,
+} from "./item"
+
+const meta: Meta<typeof Item> = {
+	title: "Ui/Item",
+	component: Item,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"A flexible item component for building lists with media, content, actions, and separators. Supports multiple variants (default, outline, select, muted) and sizes.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center">
+		<div className="flex flex-col gap-5 w-full max-w-md px-4">
+			<ItemGroup>
+				<Item variant="default">
+					<ItemMedia variant="icon">
+						<UserIcon />
+					</ItemMedia>
+					<ItemContent>
+						<ItemTitle>User Profile</ItemTitle>
+						<ItemDescription>View and edit your profile information</ItemDescription>
+					</ItemContent>
+					<ItemActions>
+						<Button size="sm" variant="ghost">
+							Edit
+						</Button>
+					</ItemActions>
+				</Item>
+				<ItemSeparator />
+				<Item variant="default">
+					<ItemMedia variant="icon">
+						<SettingsIcon />
+					</ItemMedia>
+					<ItemContent>
+						<ItemTitle>Settings</ItemTitle>
+						<ItemDescription>Manage your account settings and preferences</ItemDescription>
+					</ItemContent>
+				</Item>
+				<ItemSeparator />
+				<Item variant="default">
+					<ItemMedia variant="icon">
+						<BellIcon />
+					</ItemMedia>
+					<ItemContent>
+						<ItemTitle>Notifications</ItemTitle>
+						<ItemDescription>Configure notification preferences</ItemDescription>
+					</ItemContent>
+					<ItemActions>
+						<Badge type="round" variant="info">
+							3
+						</Badge>
+					</ItemActions>
+				</Item>
+			</ItemGroup>
+
+			<Item variant="outline">
+				<ItemContent>
+					<ItemHeader>
+						<ItemTitle>Item with Header and Footer</ItemTitle>
+						<Badge variant="default">New</Badge>
+					</ItemHeader>
+					<ItemDescription>This item has a header and footer layout</ItemDescription>
+					<ItemFooter>
+						<span className="text-xs text-muted-foreground">2 hours ago</span>
+						<Button size="sm" variant="link">
+							View More
+						</Button>
+					</ItemFooter>
+				</ItemContent>
+			</Item>
+
+			<Item size="sm" variant="select">
+				<ItemContent>
+					<ItemTitle>Select Variant</ItemTitle>
+					<ItemDescription>This item uses the select variant with small size</ItemDescription>
+				</ItemContent>
+			</Item>
+
+			<Item variant="muted">
+				<ItemContent>
+					<ItemTitle>Muted Variant</ItemTitle>
+					<ItemDescription>This item has a subtle muted background</ItemDescription>
+				</ItemContent>
+			</Item>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/item.tsx b/apps/vscode/webview-ui/src/components/ui/item.tsx
new file mode 100644
index 0000000..87784f6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/item.tsx
@@ -0,0 +1,137 @@
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+import type * as React from "react"
+import { Separator } from "@/components/ui/separator"
+import { cn } from "@/lib/utils"
+
+function ItemGroup({ className, ...props }: React.ComponentProps<"div">) {
+	return <div className={cn("group/item-group flex flex-col", className)} data-slot="item-group" role="list" {...props} />
+}
+
+function ItemSeparator({ className, ...props }: React.ComponentProps<typeof Separator>) {
+	return <Separator className={cn("my-0", className)} data-slot="item-separator" orientation="horizontal" {...props} />
+}
+
+const itemVariants = cva(
+	"group/item [a]:hover:bg-accent/50 focus-visible:border-ring focus-visible:ring-ring/50 flex flex-wrap items-center rounded-sm border border-transparent text-sm outline-none focus-visible:ring-[3px]",
+	{
+		variants: {
+			variant: {
+				default: "bg-transparent",
+				outline: "border-input-foreground/30",
+				select: "bg-input-background/50 hover:bg-input-background/70 border border-input-foreground/10",
+				muted: "bg-muted/50",
+			},
+			size: {
+				default: "gap-1 p-2 ",
+				sm: "gap-2.5 px-4 py-3",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+			size: "default",
+		},
+	},
+)
+
+function Item({
+	className,
+	variant = "default",
+	size = "default",
+	asChild = false,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof itemVariants> & { asChild?: boolean }) {
+	const Comp = asChild ? Slot : "div"
+	return (
+		<Comp
+			className={cn(itemVariants({ variant, size, className }))}
+			data-size={size}
+			data-slot="item"
+			data-variant={variant}
+			{...props}
+		/>
+	)
+}
+
+const itemMediaVariants = cva(
+	"flex shrink-0 items-center justify-center gap-2 group-has-[[data-slot=item-description]]/item:translate-y-0.5 group-has-[[data-slot=item-description]]/item:self-start [&_svg]:pointer-events-none",
+	{
+		variants: {
+			variant: {
+				default: "bg-transparent",
+				icon: "bg-transparent size-8 rounded-sm [&_svg:not([class*='size-'])]:size-4",
+				image: "size-10 overflow-hidden rounded-sm [&_img]:size-full [&_img]:object-cover",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	},
+)
+
+function ItemMedia({
+	className,
+	variant = "default",
+	selected = false,
+	...props
+}: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants> & { selected?: boolean }) {
+	return (
+		<div className={cn(itemMediaVariants({ variant, className }))} data-slot="item-media" data-variant={variant} {...props} />
+	)
+}
+
+function ItemContent({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			className={cn("w-full flex flex-1 flex-col gap-1 [&+[data-slot=item-content]]:flex-none", className)}
+			data-slot="item-content"
+			{...props}
+		/>
+	)
+}
+
+function ItemTitle({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			className={cn("w-full flex items-center gap-2 text-sm font-medium leading-snug", className)}
+			data-slot="item-title"
+			{...props}
+		/>
+	)
+}
+
+function ItemDescription({ className, ...props }: React.ComponentProps<"p">) {
+	return (
+		<p
+			className={cn(
+				"w-full text-muted-foreground line-clamp-2 text-pretty text-sm font-normal leading-normal p-0 m-0",
+				"[&>a:hover]:text-foreground [&>a]:underline [&>a]:underline-offset-4",
+				className,
+			)}
+			data-slot="item-description"
+			{...props}
+		/>
+	)
+}
+
+function ItemActions({ className, ...props }: React.ComponentProps<"div">) {
+	return <div className={cn("flex items-center gap-2", className)} data-slot="item-actions" {...props} />
+}
+
+function ItemHeader({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div
+			className={cn("w-full flex basis-full items-center justify-between gap-2", className)}
+			data-slot="item-header"
+			{...props}
+		/>
+	)
+}
+
+function ItemFooter({ className, ...props }: React.ComponentProps<"div">) {
+	return (
+		<div className={cn("flex basis-full items-center justify-between gap-2", className)} data-slot="item-footer" {...props} />
+	)
+}
+
+export { Item, ItemMedia, ItemContent, ItemActions, ItemGroup, ItemSeparator, ItemTitle, ItemDescription, ItemHeader, ItemFooter }
diff --git a/apps/vscode/webview-ui/src/components/ui/label.tsx b/apps/vscode/webview-ui/src/components/ui/label.tsx
new file mode 100644
index 0000000..0bfe762
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/label.tsx
@@ -0,0 +1,15 @@
+import * as LabelPrimitive from "@radix-ui/react-label"
+import { cva, type VariantProps } from "class-variance-authority"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const labelVariants = cva("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70")
+
+const Label = React.forwardRef<
+	React.ElementRef<typeof LabelPrimitive.Root>,
+	React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> & VariantProps<typeof labelVariants>
+>(({ className, ...props }, ref) => <LabelPrimitive.Root className={cn(labelVariants(), className)} ref={ref} {...props} />)
+Label.displayName = LabelPrimitive.Root.displayName
+
+export { Label }
diff --git a/apps/vscode/webview-ui/src/components/ui/popover.stories.tsx b/apps/vscode/webview-ui/src/components/ui/popover.stories.tsx
new file mode 100644
index 0000000..8ef5708
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/popover.stories.tsx
@@ -0,0 +1,84 @@
+import type { Meta } from "@storybook/react-vite"
+import { Button } from "./button"
+import { Popover, PopoverContent, PopoverTrigger } from "./popover"
+
+const meta: Meta<typeof Popover> = {
+	title: "Ui/Popover",
+	component: Popover,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays rich content in a floating panel when clicking a trigger element. Built on Radix UI with customizable alignment, side positioning, and an arrow indicator.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center min-h-[400px]">
+		<div className="flex flex-col gap-8 w-full max-w-md px-4">
+			<Popover>
+				<PopoverTrigger asChild>
+					<Button variant="cline">Open Popover</Button>
+				</PopoverTrigger>
+				<PopoverContent>
+					<div className="space-y-2">
+						<h4 className="font-medium leading-none">Popover Title</h4>
+						<p className="text-sm text-muted-foreground">
+							This is the content inside the popover. It can contain any React components.
+						</p>
+					</div>
+				</PopoverContent>
+			</Popover>
+
+			<div className="flex gap-4 justify-center">
+				<Popover>
+					<PopoverTrigger asChild>
+						<Button variant="secondary">Left Align</Button>
+					</PopoverTrigger>
+					<PopoverContent align="start">
+						<div className="space-y-2">
+							<p className="text-sm">This popover is aligned to the start of the trigger.</p>
+						</div>
+					</PopoverContent>
+				</Popover>
+
+				<Popover>
+					<PopoverTrigger asChild>
+						<Button variant="secondary">Right Align</Button>
+					</PopoverTrigger>
+					<PopoverContent align="end">
+						<div className="space-y-2">
+							<p className="text-sm">This popover is aligned to the end of the trigger.</p>
+						</div>
+					</PopoverContent>
+				</Popover>
+			</div>
+
+			<Popover>
+				<PopoverTrigger asChild>
+					<Button variant="default">With Actions</Button>
+				</PopoverTrigger>
+				<PopoverContent>
+					<div className="space-y-4">
+						<div className="space-y-2">
+							<h4 className="font-medium leading-none">Confirm Action</h4>
+							<p className="text-sm text-muted-foreground">Are you sure you want to proceed?</p>
+						</div>
+						<div className="flex gap-2 justify-end">
+							<Button size="sm" variant="outline">
+								Cancel
+							</Button>
+							<Button size="sm" variant="default">
+								Confirm
+							</Button>
+						</div>
+					</div>
+				</PopoverContent>
+			</Popover>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/popover.tsx b/apps/vscode/webview-ui/src/components/ui/popover.tsx
new file mode 100644
index 0000000..74795b8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/popover.tsx
@@ -0,0 +1,45 @@
+import * as PopoverPrimitive from "@radix-ui/react-popover"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Popover = PopoverPrimitive.Root
+
+const PopoverTrigger = PopoverPrimitive.Trigger
+
+function PopoverContent({
+	className,
+	align = "center",
+	sideOffset = 4,
+	children,
+	...props
+}: React.ComponentProps<typeof PopoverPrimitive.Content>) {
+	// Get side prop for conditional arrow positioning
+	const side = (props as any).side
+
+	return (
+		<PopoverPrimitive.Portal>
+			<PopoverPrimitive.Content
+				align={align}
+				className={cn(
+					"bg-menu text-base text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 origin-(--radix-popover-content-transform-origin) rounded-xs border p-2 shadow-md outline-hidden border-menu-foreground/10",
+					className,
+				)}
+				data-slot="popover-content"
+				sideOffset={sideOffset}
+				{...props}>
+				{children}
+				<PopoverPrimitive.Arrow
+					className={cn(
+						"bg-menu fill-menu z-50 size-2.5 rotate-45 rounded-xs border-b border-r border-menu-foreground/10",
+						side === "left" || side === "right" ? "translate-x-[calc(-50%_-_2px)]" : "translate-y-[calc(-50%_-_2px)]",
+					)}
+				/>
+			</PopoverPrimitive.Content>
+		</PopoverPrimitive.Portal>
+	)
+}
+
+PopoverContent.displayName = PopoverPrimitive.Content.displayName
+
+export { Popover, PopoverContent, PopoverTrigger }
diff --git a/apps/vscode/webview-ui/src/components/ui/progress.stories.tsx b/apps/vscode/webview-ui/src/components/ui/progress.stories.tsx
new file mode 100644
index 0000000..faef52b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/progress.stories.tsx
@@ -0,0 +1,44 @@
+import type { Meta } from "@storybook/react-vite"
+import { Progress } from "./progress"
+
+const meta: Meta<typeof Progress> = {
+	title: "Ui/Progress",
+	component: Progress,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays a horizontal progress bar with a smooth animated indicator. Built on Radix UI and accepts a value between 0-100 to show completion percentage.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center">
+		<div className="flex flex-col gap-6 w-full max-w-md px-4">
+			<div className="space-y-2">
+				<div className="text-sm text-muted-foreground">0% Complete</div>
+				<Progress value={0} />
+			</div>
+			<div className="space-y-2">
+				<div className="text-sm text-muted-foreground">25% Complete</div>
+				<Progress value={25} />
+			</div>
+			<div className="space-y-2">
+				<div className="text-sm text-muted-foreground">50% Complete</div>
+				<Progress value={50} />
+			</div>
+			<div className="space-y-2">
+				<div className="text-sm text-muted-foreground">75% Complete</div>
+				<Progress value={75} />
+			</div>
+			<div className="space-y-2">
+				<div className="text-sm text-muted-foreground">100% Complete</div>
+				<Progress value={100} />
+			</div>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/progress.tsx b/apps/vscode/webview-ui/src/components/ui/progress.tsx
new file mode 100644
index 0000000..0b56103
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/progress.tsx
@@ -0,0 +1,22 @@
+import * as ProgressPrimitive from "@radix-ui/react-progress"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Progress = React.forwardRef<
+	React.ElementRef<typeof ProgressPrimitive.Root>,
+	React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>
+>(({ className, value, ...props }, ref) => (
+	<ProgressPrimitive.Root
+		className={cn("relative h-3 w-full overflow-hidden rounded-full bg-code-foreground/20", className)}
+		ref={ref}
+		{...props}>
+		<ProgressPrimitive.Indicator
+			className="h-full w-full flex-1 bg-code-foreground transition-all"
+			style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
+		/>
+	</ProgressPrimitive.Root>
+))
+Progress.displayName = ProgressPrimitive.Root.displayName
+
+export { Progress }
diff --git a/apps/vscode/webview-ui/src/components/ui/select.stories.tsx b/apps/vscode/webview-ui/src/components/ui/select.stories.tsx
new file mode 100644
index 0000000..6b805e8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/select.stories.tsx
@@ -0,0 +1,221 @@
+import type { Meta, StoryObj } from "@storybook/react-vite"
+import ClineLogoWhite from "@/assets/ClineLogoWhite"
+import {
+	Select,
+	SelectContent,
+	SelectGroup,
+	SelectItem,
+	SelectLabel,
+	SelectSeparator,
+	SelectTrigger,
+	SelectValue,
+} from "./select"
+
+const meta: Meta = {
+	title: "Ui/Select",
+	component: Select,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"A select dropdown component built on Radix UI. Allows users to choose from a list of options with support for grouping, separators, labels, and custom styling. Includes trigger, content, item, and value components for composing select layouts.",
+			},
+		},
+	},
+}
+
+export default meta
+
+type StoryProps = {
+	placeholder: string
+	size: "sm" | "default"
+	items: string[]
+	defaultValue?: string
+	disabled: boolean
+	showGroups: boolean
+	showSeparators: boolean
+}
+
+// Interactive story with controls
+export const Interactive: StoryObj<StoryProps> = {
+	args: {
+		placeholder: "Select an option",
+		size: "default",
+		items: ["Option 1", "Option 2", "Option 3", "Option 4"],
+		defaultValue: undefined,
+		disabled: false,
+		showGroups: false,
+		showSeparators: false,
+	},
+	argTypes: {
+		placeholder: {
+			control: "text",
+			description: "Placeholder text shown when no option is selected",
+		},
+		size: {
+			control: "select",
+			options: ["sm", "default"],
+			description: "Size variant of the select trigger",
+		},
+		items: {
+			control: "object",
+			description: "Array of items to display in the select",
+		},
+		defaultValue: {
+			control: "text",
+			description: "Default selected value",
+		},
+		disabled: {
+			control: "boolean",
+			description: "Disable the select component",
+		},
+		showGroups: {
+			control: "boolean",
+			description: "Show items organized in groups with labels",
+		},
+		showSeparators: {
+			control: "boolean",
+			description: "Show separators between items",
+		},
+	},
+	render: (args) => (
+		<div className="w-full h-full flex justify-center items-center overflow-hidden">
+			<div className="flex flex-col justify-center items-center h-[60%] w-[50%] overflow-hidden mt-50">
+				<div className="flex justify-center my-5">
+					<ClineLogoWhite className="size-16" />
+				</div>
+				<p>
+					You can customize the select using the controls in the "Controls" panel below to change its placeholder, size,
+					items, and styling options.
+				</p>
+
+				<div className="mt-4.5">
+					<Select defaultValue={args.defaultValue} disabled={args.disabled}>
+						<SelectTrigger size={args.size}>
+							<SelectValue placeholder={args.placeholder} />
+						</SelectTrigger>
+						<SelectContent position="popper">
+							{args.showGroups ? (
+								<>
+									<SelectGroup>
+										<SelectLabel>Group 1</SelectLabel>
+										{args.items.slice(0, Math.ceil(args.items.length / 2)).map((item) => (
+											<SelectItem key={item} value={item}>
+												{item}
+											</SelectItem>
+										))}
+									</SelectGroup>
+									{args.showSeparators && <SelectSeparator />}
+									<SelectGroup>
+										<SelectLabel>Group 2</SelectLabel>
+										{args.items.slice(Math.ceil(args.items.length / 2)).map((item) => (
+											<SelectItem key={item} value={item}>
+												{item}
+											</SelectItem>
+										))}
+									</SelectGroup>
+								</>
+							) : (
+								args.items.map((item, index) => (
+									<>
+										<SelectItem key={item} value={item}>
+											{item}
+										</SelectItem>
+										{args.showSeparators && index < args.items.length - 1 && <SelectSeparator />}
+									</>
+								))
+							)}
+						</SelectContent>
+					</Select>
+				</div>
+			</div>
+		</div>
+	),
+}
+
+// Showcase all select variants
+export const Overview = () => {
+	const variants = [
+		{
+			label: "Basic",
+			size: "default" as const,
+			placeholder: "Select a fruit",
+			items: ["Apple", "Banana", "Cherry", "Date", "Elderberry"],
+			hasGroups: false,
+			hasSeparators: false,
+		},
+		{
+			label: "With Groups",
+			size: "default" as const,
+			placeholder: "Select a language",
+			groups: [
+				{
+					label: "Frontend",
+					items: ["JavaScript", "TypeScript", "HTML", "CSS"],
+				},
+				{
+					label: "Backend",
+					items: ["Python", "Java", "Go", "Rust"],
+				},
+			],
+			hasGroups: true,
+			hasSeparators: false,
+		},
+		{
+			label: "With Separators",
+			size: "default" as const,
+			placeholder: "Select a tool",
+			items: ["Git", "Docker", "Kubernetes", "Jenkins"],
+			hasGroups: false,
+			hasSeparators: true,
+		},
+	]
+
+	return (
+		<div className="w-screen">
+			<div className="flex justify-center h-[60%] w-[80%] overflow-hidden gap-8 p-8">
+				{variants.map((variant) => (
+					<div className="flex flex-col gap-4" key={variant.label}>
+						<h2 className="text-lg font-semibold">{variant.label}</h2>
+						<Select>
+							<SelectTrigger size={variant.size}>
+								<SelectValue placeholder={variant.placeholder} />
+							</SelectTrigger>
+							<SelectContent position="popper">
+								{variant.hasGroups && "groups" in variant ? (
+									variant?.groups?.map((group, groupIndex) => (
+										<>
+											<SelectGroup key={group.label}>
+												<SelectLabel>{group.label}</SelectLabel>
+												{group.items.map((item) => (
+													<SelectItem key={item} value={item}>
+														{item}
+													</SelectItem>
+												))}
+											</SelectGroup>
+											{groupIndex < variant.groups.length - 1 && <SelectSeparator />}
+										</>
+									))
+								) : (
+									<>
+										{"items" in variant &&
+											variant?.items?.map((item, index) => (
+												<>
+													<SelectItem key={item} value={item}>
+														{item}
+													</SelectItem>
+													{variant.hasSeparators && index < variant.items.length - 1 && (
+														<SelectSeparator />
+													)}
+												</>
+											))}
+									</>
+								)}
+							</SelectContent>
+						</Select>
+					</div>
+				))}
+			</div>
+		</div>
+	)
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/select.tsx b/apps/vscode/webview-ui/src/components/ui/select.tsx
new file mode 100644
index 0000000..2838d9d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/select.tsx
@@ -0,0 +1,146 @@
+"use client"
+
+import * as SelectPrimitive from "@radix-ui/react-select"
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>) {
+	return <SelectPrimitive.Root data-slot="select" {...props} />
+}
+
+function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>) {
+	return <SelectPrimitive.Group data-slot="select-group" {...props} />
+}
+
+function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>) {
+	return <SelectPrimitive.Value data-slot="select-value" {...props} />
+}
+
+function SelectTrigger({
+	className,
+	size = "default",
+	showIcon = true,
+	children,
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+	size?: "sm" | "default"
+	showIcon?: boolean
+}) {
+	return (
+		<SelectPrimitive.Trigger
+			className={cn(
+				"border-editor-group-border data-[placeholder]:text-input-placeholder [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-editor-group-border focus-visible:ring-ring/20 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-error flex w-fit items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-1 disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-2",
+				className,
+			)}
+			data-size={size}
+			data-slot="select-trigger"
+			{...props}>
+			{children}
+			{showIcon && (
+				<SelectPrimitive.Icon asChild>
+					<ChevronDownIcon className="size-4 opacity-50" />
+				</SelectPrimitive.Icon>
+			)}
+		</SelectPrimitive.Trigger>
+	)
+}
+
+function SelectContent({
+	className,
+	children,
+	position = "popper",
+	align = "center",
+	...props
+}: React.ComponentProps<typeof SelectPrimitive.Content>) {
+	return (
+		<SelectPrimitive.Portal>
+			<SelectPrimitive.Content
+				align={align}
+				className={cn(
+					"bg-menu text-menu-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-xs border border-editor-group-border shadow-md",
+					position === "popper" &&
+						"data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+					className,
+				)}
+				data-slot="select-content"
+				position={position}
+				{...props}>
+				<SelectScrollUpButton />
+				<SelectPrimitive.Viewport
+					className={cn(
+						"p-1",
+						position === "popper" &&
+							"h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1",
+					)}>
+					{children}
+				</SelectPrimitive.Viewport>
+				<SelectScrollDownButton />
+			</SelectPrimitive.Content>
+		</SelectPrimitive.Portal>
+	)
+}
+
+function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>) {
+	return (
+		<SelectPrimitive.Label
+			className={cn("text-input-placeholder/80 px-2 py-1 text-sm", className)}
+			data-slot="select-label"
+			{...props}
+		/>
+	)
+}
+
+function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>) {
+	return (
+		<SelectPrimitive.Item
+			className={cn(
+				"focus:bg-button-background/50 focus:text-input [&_svg:not([class*='text-'])]:text-description relative flex w-full cursor-default items-center gap-2 rounded-xs py-1 pr-8 pl-2 text-xs outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-2 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+				className,
+			)}
+			data-slot="select-item"
+			{...props}>
+			<span className="absolute right-2 flex size-2 items-center justify-center" data-slot="select-item-indicator">
+				<SelectPrimitive.ItemIndicator>
+					<CheckIcon className="size-2" />
+				</SelectPrimitive.ItemIndicator>
+			</span>
+			<SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+		</SelectPrimitive.Item>
+	)
+}
+
+function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>) {
+	return (
+		<SelectPrimitive.Separator
+			className={cn("bg-editor-group-border pointer-events-none -mx-1 my-1 h-px", className)}
+			data-slot="select-separator"
+			{...props}
+		/>
+	)
+}
+
+function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) {
+	return (
+		<SelectPrimitive.ScrollUpButton
+			className={cn("flex cursor-default items-center justify-center py-1", className)}
+			data-slot="select-scroll-up-button"
+			{...props}>
+			<ChevronUpIcon className="size-4" />
+		</SelectPrimitive.ScrollUpButton>
+	)
+}
+
+function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>) {
+	return (
+		<SelectPrimitive.ScrollDownButton
+			className={cn("flex cursor-default items-center justify-center py-1", className)}
+			data-slot="select-scroll-down-button"
+			{...props}>
+			<ChevronDownIcon className="size-4" />
+		</SelectPrimitive.ScrollDownButton>
+	)
+}
+
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue }
diff --git a/apps/vscode/webview-ui/src/components/ui/separator.stories.tsx b/apps/vscode/webview-ui/src/components/ui/separator.stories.tsx
new file mode 100644
index 0000000..1d4fe29
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/separator.stories.tsx
@@ -0,0 +1,56 @@
+import type { Meta } from "@storybook/react-vite"
+import { Separator } from "./separator"
+
+const meta: Meta<typeof Separator> = {
+	title: "Ui/Separator",
+	component: Separator,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Visually separates content with a horizontal or vertical line. Built on Radix UI and supports both orientations for flexible layout separation.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center">
+		<div className="flex flex-col gap-8 w-full max-w-md px-4">
+			<div className="space-y-4">
+				<h4 className="text-sm font-medium">Horizontal Separator</h4>
+				<div className="space-y-1">
+					<p className="text-sm">Content above the separator</p>
+				</div>
+				<Separator orientation="horizontal" />
+				<div className="space-y-1">
+					<p className="text-sm">Content below the separator</p>
+				</div>
+			</div>
+
+			<div className="space-y-4">
+				<h4 className="text-sm font-medium">Vertical Separator</h4>
+				<div className="flex h-20 items-center space-x-4">
+					<div className="text-sm">Left content</div>
+					<Separator orientation="vertical" />
+					<div className="text-sm">Middle content</div>
+					<Separator orientation="vertical" />
+					<div className="text-sm">Right content</div>
+				</div>
+			</div>
+
+			<div className="space-y-4">
+				<h4 className="text-sm font-medium">In a Menu Layout</h4>
+				<div className="space-y-2">
+					<div className="text-sm p-2 hover:bg-accent rounded-sm cursor-pointer">Menu Item 1</div>
+					<div className="text-sm p-2 hover:bg-accent rounded-sm cursor-pointer">Menu Item 2</div>
+					<Separator />
+					<div className="text-sm p-2 hover:bg-accent rounded-sm cursor-pointer">Menu Item 3</div>
+					<div className="text-sm p-2 hover:bg-accent rounded-sm cursor-pointer">Menu Item 4</div>
+				</div>
+			</div>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/separator.tsx b/apps/vscode/webview-ui/src/components/ui/separator.tsx
new file mode 100644
index 0000000..2aced18
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/separator.tsx
@@ -0,0 +1,26 @@
+import * as SeparatorPrimitive from "@radix-ui/react-separator"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Separator({
+	className,
+	orientation = "horizontal",
+	decorative = true,
+	...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+	return (
+		<SeparatorPrimitive.Root
+			className={cn(
+				"bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+				className,
+			)}
+			data-slot="separator"
+			decorative={decorative}
+			orientation={orientation}
+			{...props}
+		/>
+	)
+}
+
+export { Separator }
diff --git a/apps/vscode/webview-ui/src/components/ui/switch.stories.tsx b/apps/vscode/webview-ui/src/components/ui/switch.stories.tsx
new file mode 100644
index 0000000..047e3e9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/switch.stories.tsx
@@ -0,0 +1,64 @@
+import type { Meta } from "@storybook/react-vite"
+import { Switch } from "./switch"
+
+const meta: Meta<typeof Switch> = {
+	title: "Ui/Switch",
+	component: Switch,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"A toggle switch component for binary on/off states. Built on Radix UI with smooth animations and keyboard accessibility support.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center">
+		<div className="flex flex-col gap-6 w-full max-w-md px-4">
+			<div className="flex items-center justify-between">
+				<label className="text-sm font-medium cursor-pointer" htmlFor="switch-1">
+					Default switch (unchecked)
+				</label>
+				<Switch id="switch-1" />
+			</div>
+
+			<div className="flex items-center justify-between">
+				<label className="text-sm font-medium cursor-pointer" htmlFor="switch-2">
+					Checked switch
+				</label>
+				<Switch defaultChecked id="switch-2" />
+			</div>
+
+			<div className="flex items-center justify-between">
+				<label className="text-sm font-medium cursor-not-allowed opacity-50" htmlFor="switch-3">
+					Disabled switch
+				</label>
+				<Switch disabled id="switch-3" />
+			</div>
+
+			<div className="flex items-center justify-between">
+				<label className="text-sm font-medium cursor-not-allowed opacity-50" htmlFor="switch-4">
+					Disabled checked switch
+				</label>
+				<Switch defaultChecked disabled id="switch-4" />
+			</div>
+
+			<div className="space-y-2 p-4 bg-accent/20 rounded-sm">
+				<h4 className="text-sm font-medium">Setting Example</h4>
+				<div className="flex items-center justify-between">
+					<div className="space-y-0.5">
+						<label className="text-sm font-medium cursor-pointer" htmlFor="notifications">
+							Enable notifications
+						</label>
+						<div className="text-xs text-muted-foreground">Receive updates about your account activity</div>
+					</div>
+					<Switch id="notifications" />
+				</div>
+			</div>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/switch.tsx b/apps/vscode/webview-ui/src/components/ui/switch.tsx
new file mode 100644
index 0000000..b0a1ac2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/switch.tsx
@@ -0,0 +1,44 @@
+import * as SwitchPrimitives from "@radix-ui/react-switch"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+type SwitchSize = "default" | "lg"
+
+const sizeStyles: Record<SwitchSize, { root: string; thumb: string }> = {
+	default: {
+		root: "h-3 w-6",
+		thumb: "h-2 w-2 data-[state=checked]:translate-x-2.5",
+	},
+	lg: {
+		root: "h-5 w-10",
+		thumb: "h-4 w-4 data-[state=checked]:translate-x-[1.3rem]",
+	},
+}
+
+interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> {
+	size?: SwitchSize
+}
+
+const Switch = React.forwardRef<React.ElementRef<typeof SwitchPrimitives.Root>, SwitchProps>(
+	({ className, size = "default", ...props }, ref) => (
+		<SwitchPrimitives.Root
+			className={cn(
+				"peer inline-flex shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent shadow-sm transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-background focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-button-background/60 data-[state=unchecked]:bg-[#8B8B8B]",
+				sizeStyles[size].root,
+				className,
+			)}
+			{...props}
+			ref={ref}>
+			<SwitchPrimitives.Thumb
+				className={cn(
+					"pointer-events-none block rounded-full bg-button-foreground/80 shadow-lg transition-transform data-[state=unchecked]:translate-x-0",
+					sizeStyles[size].thumb,
+				)}
+			/>
+		</SwitchPrimitives.Root>
+	),
+)
+Switch.displayName = SwitchPrimitives.Root.displayName
+
+export { Switch }
diff --git a/apps/vscode/webview-ui/src/components/ui/tooltip.stories.tsx b/apps/vscode/webview-ui/src/components/ui/tooltip.stories.tsx
new file mode 100644
index 0000000..dc3facd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/tooltip.stories.tsx
@@ -0,0 +1,101 @@
+import type { Meta } from "@storybook/react-vite"
+import { InfoIcon } from "lucide-react"
+import { Button } from "./button"
+import { Tooltip, TooltipContent, TooltipTrigger } from "./tooltip"
+
+const meta: Meta<typeof Tooltip> = {
+	title: "Ui/Tooltip",
+	component: Tooltip,
+	parameters: {
+		docs: {
+			description: {
+				component:
+					"Displays helpful text when hovering over an element. Built on Radix UI with customizable positioning, optional arrow indicator, and smooth animations.",
+			},
+		},
+	},
+}
+
+export default meta
+
+export const Default = () => (
+	<div className="w-screen flex justify-center items-center min-h-[400px]">
+		<div className="flex flex-col gap-8 w-full max-w-md px-4 items-center">
+			<Tooltip>
+				<TooltipTrigger asChild>
+					<Button>Hover for tooltip</Button>
+				</TooltipTrigger>
+				<TooltipContent>
+					<p>This is a helpful tooltip</p>
+				</TooltipContent>
+			</Tooltip>
+
+			<div className="flex gap-4">
+				<Tooltip>
+					<TooltipTrigger asChild>
+						<Button variant="secondary">Top</Button>
+					</TooltipTrigger>
+					<TooltipContent side="top">
+						<p>Tooltip on top</p>
+					</TooltipContent>
+				</Tooltip>
+
+				<Tooltip>
+					<TooltipTrigger asChild>
+						<Button variant="secondary">Bottom</Button>
+					</TooltipTrigger>
+					<TooltipContent side="bottom">
+						<p>Tooltip on bottom</p>
+					</TooltipContent>
+				</Tooltip>
+
+				<Tooltip>
+					<TooltipTrigger asChild>
+						<Button variant="secondary">Left</Button>
+					</TooltipTrigger>
+					<TooltipContent side="left">
+						<p>Tooltip on left</p>
+					</TooltipContent>
+				</Tooltip>
+
+				<Tooltip>
+					<TooltipTrigger asChild>
+						<Button variant="secondary">Right</Button>
+					</TooltipTrigger>
+					<TooltipContent side="right">
+						<p>Tooltip on right</p>
+					</TooltipContent>
+				</Tooltip>
+			</div>
+
+			<Tooltip>
+				<TooltipTrigger asChild>
+					<Button size="icon" variant="icon">
+						<InfoIcon />
+					</Button>
+				</TooltipTrigger>
+				<TooltipContent>
+					<p>Click for more information</p>
+				</TooltipContent>
+			</Tooltip>
+
+			<Tooltip>
+				<TooltipTrigger asChild>
+					<Button>No arrow</Button>
+				</TooltipTrigger>
+				<TooltipContent showArrow={false}>
+					<p>This tooltip has no arrow</p>
+				</TooltipContent>
+			</Tooltip>
+
+			<Tooltip>
+				<TooltipTrigger asChild>
+					<span className="text-sm underline cursor-help">Hover me</span>
+				</TooltipTrigger>
+				<TooltipContent>
+					<p>Tooltips can wrap any element, not just buttons</p>
+				</TooltipContent>
+			</Tooltip>
+		</div>
+	</div>
+)
diff --git a/apps/vscode/webview-ui/src/components/ui/tooltip.tsx b/apps/vscode/webview-ui/src/components/ui/tooltip.tsx
new file mode 100644
index 0000000..8b3e4a7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/tooltip.tsx
@@ -0,0 +1,58 @@
+import * as TooltipPrimitive from "@radix-ui/react-tooltip"
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function TooltipProvider({ delayDuration = 0, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
+	return <TooltipPrimitive.Provider data-slot="tooltip-provider" delayDuration={delayDuration} {...props} />
+}
+
+function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>) {
+	return (
+		<TooltipProvider>
+			<TooltipPrimitive.Root data-slot="tooltip" {...props} />
+		</TooltipProvider>
+	)
+}
+
+function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
+	return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
+}
+
+function TooltipContent({
+	className,
+	sideOffset = 0,
+	showArrow = true,
+	children,
+	...props
+}: React.ComponentProps<typeof TooltipPrimitive.Content> & { showArrow?: boolean }) {
+	const side = (props as any).side
+
+	return (
+		<TooltipPrimitive.Portal>
+			<TooltipPrimitive.Content
+				className={cn(
+					"flex flex-wrap bg-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 origin-(--radix-tooltip-content-transform-origin) rounded-xs text-xs border border-muted-foreground/30 mx-1 max-w-[calc(100vw-2rem)] xs:max-w-md text-wrap shadow-md",
+					className,
+				)}
+				collisionPadding={8}
+				data-slot="tooltip-content"
+				sideOffset={sideOffset}
+				{...props}>
+				<span className="leading-tight text-ellipsis p-2">{children}</span>
+				{showArrow && (
+					<TooltipPrimitive.Arrow
+						className={cn(
+							"bg-background fill-background z-50 size-2.5 rotate-45 rounded-xs border-b border-r border-muted-foreground/30",
+							side === "left" || side === "right"
+								? "translate-y-[calc(-50%_-_4px)]" // Horizontal adjustment for side tooltips
+								: "translate-y-[calc(-50%_-_0px)]", // Vertical adjustment for top/bottom tooltips
+						)}
+					/>
+				)}
+			</TooltipPrimitive.Content>
+		</TooltipPrimitive.Portal>
+	)
+}
+
+export { Tooltip, TooltipContent, TooltipTrigger }
diff --git a/apps/vscode/webview-ui/src/components/welcome/HomeHeader.tsx b/apps/vscode/webview-ui/src/components/welcome/HomeHeader.tsx
new file mode 100644
index 0000000..80e48cd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/welcome/HomeHeader.tsx
@@ -0,0 +1,49 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import ClineLogoSanta from "@/assets/ClineLogoSanta"
+import ClineLogoVariable from "@/assets/ClineLogoVariable"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { UiServiceClient } from "@/services/grpc-client"
+
+interface HomeHeaderProps {
+	shouldShowQuickWins?: boolean
+}
+
+const HomeHeader = ({ shouldShowQuickWins = false }: HomeHeaderProps) => {
+	const { environment } = useExtensionState()
+
+	const handleTakeATour = async () => {
+		try {
+			await UiServiceClient.openWalkthrough(EmptyRequest.create())
+		} catch (error) {
+			console.error("Error opening walkthrough:", error)
+		}
+	}
+
+	const isDecember = new Date().getMonth() === 11 // 11 = December (0-indexed)
+	const LogoComponent = isDecember ? ClineLogoSanta : ClineLogoVariable
+	const headingText = "What can I do for you?"
+
+	return (
+		<div className="flex flex-col items-center mb-5">
+			<div className="my-7">
+				<LogoComponent className="size-20" environment={environment} />
+			</div>
+			<div className="text-center flex items-center justify-center px-4">
+				<h1 className="m-0 font-bold">{headingText}</h1>
+			</div>
+			{shouldShowQuickWins && (
+				<div className="mt-4">
+					<button
+						className="flex items-center gap-2 px-4 py-2 rounded-full border border-border-panel bg-white/2 hover:bg-list-background-hover transition-colors duration-150 ease-in-out text-code-foreground text-sm font-medium cursor-pointer"
+						onClick={handleTakeATour}
+						type="button">
+						Take a Tour
+						<span className="codicon codicon-play scale-90" />
+					</button>
+				</div>
+			)}
+		</div>
+	)
+}
+
+export default HomeHeader
diff --git a/apps/vscode/webview-ui/src/components/welcome/QuickWinCard.tsx b/apps/vscode/webview-ui/src/components/welcome/QuickWinCard.tsx
new file mode 100644
index 0000000..63b71f1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/welcome/QuickWinCard.tsx
@@ -0,0 +1,50 @@
+import React from "react"
+import { QuickWinTask } from "./quickWinTasks"
+
+interface QuickWinCardProps {
+	task: QuickWinTask
+	onExecute: () => void
+}
+
+const renderIcon = (iconName?: string) => {
+	if (!iconName) {
+		return <span className="codicon codicon-rocket text-[28px]! leading-none!"></span>
+	}
+
+	let iconClass = "codicon-rocket"
+	switch (iconName) {
+		case "WebAppIcon":
+			iconClass = "codicon-dashboard"
+			break
+		case "TerminalIcon":
+			iconClass = "codicon-terminal"
+			break
+		case "GameIcon":
+			iconClass = "codicon-game"
+			break
+		default:
+			break
+	}
+	return <span className={`codicon ${iconClass} text-[28px]! leading-none!`}></span>
+}
+
+const QuickWinCard: React.FC<QuickWinCardProps> = ({ task, onExecute }) => {
+	return (
+		<div
+			className="flex items-center mb-2 py-0 px-5 space-x-3 rounded-full cursor-pointer group transition-colors duration-150 ease-in-out bg-white/2 border border-(--vscode-panel-border) hover:bg-(--vscode-list-hoverBackground)"
+			onClick={() => onExecute()}>
+			<div className="shrink-0 flex items-center justify-center w-6 h-6 text-(--vscode-icon-foreground)">
+				{renderIcon(task.icon)}
+			</div>
+
+			<div className="grow min-w-0">
+				<h3 className="text-sm font-medium truncate text-(--vscode-editor-foreground) leading-tight mb-0 mt-0 pt-3">
+					{task.title}
+				</h3>
+				<p className="text-xs truncate text-(--vscode-descriptionForeground) leading-tight mt-px">{task.description}</p>
+			</div>
+		</div>
+	)
+}
+
+export default QuickWinCard
diff --git a/apps/vscode/webview-ui/src/components/welcome/SuggestedTasks.tsx b/apps/vscode/webview-ui/src/components/welcome/SuggestedTasks.tsx
new file mode 100644
index 0000000..02eea58
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/welcome/SuggestedTasks.tsx
@@ -0,0 +1,28 @@
+import { NewTaskRequest } from "@shared/proto/cline/task"
+import React from "react"
+import { TaskServiceClient } from "@/services/grpc-client"
+import QuickWinCard from "./QuickWinCard"
+import { QuickWinTask, quickWinTasks } from "./quickWinTasks"
+
+export const SuggestedTasks: React.FC<{ shouldShowQuickWins: boolean }> = ({ shouldShowQuickWins }) => {
+	const handleExecuteQuickWin = async (prompt: string) => {
+		await TaskServiceClient.newTask(NewTaskRequest.create({ text: prompt, images: [] }))
+	}
+
+	if (shouldShowQuickWins) {
+		return (
+			<div className="px-4 pt-1 pb-3 select-none">
+				{" "}
+				<h2 className="text-sm font-medium mb-2.5 text-center text-gray">
+					Quick <span className="text-white">[Wins]</span> with Cline
+				</h2>
+				<div className="flex flex-col space-y-1">
+					{" "}
+					{quickWinTasks.map((task: QuickWinTask) => (
+						<QuickWinCard key={task.id} onExecute={() => handleExecuteQuickWin(task.prompt)} task={task} />
+					))}
+				</div>
+			</div>
+		)
+	}
+}
diff --git a/apps/vscode/webview-ui/src/components/welcome/WelcomeView.tsx b/apps/vscode/webview-ui/src/components/welcome/WelcomeView.tsx
new file mode 100644
index 0000000..276f489
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/welcome/WelcomeView.tsx
@@ -0,0 +1,94 @@
+import { BooleanRequest, EmptyRequest } from "@shared/proto/cline/common"
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { memo, useEffect, useState } from "react"
+import ClineLogoWhite from "@/assets/ClineLogoWhite"
+import ApiOptions from "@/components/settings/ApiOptions"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { AccountServiceClient, StateServiceClient } from "@/services/grpc-client"
+import { validateApiConfiguration } from "@/utils/validate"
+
+const WelcomeView = memo(() => {
+	const { apiConfiguration, mode } = useExtensionState()
+	const [apiErrorMessage, setApiErrorMessage] = useState<string | undefined>(undefined)
+	const [showApiOptions, setShowApiOptions] = useState(false)
+	const [isLoading, setIsLoading] = useState(false)
+
+	const disableLetsGoButton = apiErrorMessage != null
+
+	const handleLogin = () => {
+		setIsLoading(true)
+		AccountServiceClient.accountLoginClicked(EmptyRequest.create())
+			.catch((err) => console.error("Failed to get login URL:", err))
+			.finally(() => {
+				setIsLoading(false)
+			})
+	}
+
+	const handleSubmit = async () => {
+		try {
+			await StateServiceClient.setWelcomeViewCompleted(BooleanRequest.create({ value: true }))
+		} catch (error) {
+			console.error("Failed to update API configuration or complete welcome view:", error)
+		}
+	}
+
+	useEffect(() => {
+		setApiErrorMessage(validateApiConfiguration(mode, apiConfiguration))
+	}, [apiConfiguration, mode])
+
+	return (
+		<div className="fixed inset-0 p-0 flex flex-col">
+			<div className="h-full px-5 overflow-auto flex flex-col gap-2.5">
+				<h2 className="text-lg font-semibold">Hi, I'm Cline</h2>
+				<div className="flex justify-center my-5">
+					<ClineLogoWhite className="size-16" />
+				</div>
+				<p>
+					I can do all kinds of tasks thanks to breakthroughs in{" "}
+					<VSCodeLink className="inline" href="https://www.anthropic.com/claude/sonnet">
+						Claude 4.6 Sonnet's
+					</VSCodeLink>
+					agentic coding capabilities and access to tools that let me create & edit files, explore complex projects, use
+					a browser, and execute terminal commands <i>(with your permission, of course)</i>. I can even use MCP to
+					create new tools and extend my own capabilities.
+				</p>
+
+				<p className="text-(--vscode-descriptionForeground)">
+					Sign up for an account to get started for free, or use an API key that provides access to models like Claude
+					Sonnet.
+				</p>
+
+				<VSCodeButton appearance="primary" className="w-full mt-1" disabled={isLoading} onClick={handleLogin}>
+					Get Started for Free
+					{isLoading && (
+						<span className="ml-1 animate-spin">
+							<span className="codicon codicon-refresh" />
+						</span>
+					)}
+				</VSCodeButton>
+
+				{!showApiOptions && (
+					<VSCodeButton
+						appearance="secondary"
+						className="mt-2.5 w-full"
+						onClick={() => setShowApiOptions(!showApiOptions)}>
+						Use your own API key
+					</VSCodeButton>
+				)}
+
+				<div className="mt-4.5">
+					{showApiOptions && (
+						<div>
+							<ApiOptions currentMode={mode} showModelOptions={false} />
+							<VSCodeButton className="mt-0.75" disabled={disableLetsGoButton} onClick={handleSubmit}>
+								Let's go!
+							</VSCodeButton>
+						</div>
+					)}
+				</div>
+			</div>
+		</div>
+	)
+})
+
+export default WelcomeView
diff --git a/apps/vscode/webview-ui/src/components/welcome/quickWinTasks.ts b/apps/vscode/webview-ui/src/components/welcome/quickWinTasks.ts
new file mode 100644
index 0000000..6d1ffb8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/welcome/quickWinTasks.ts
@@ -0,0 +1,39 @@
+export interface QuickWinTask {
+	id: string
+	title: string
+	description: string
+	icon?: string
+	actionCommand: string
+	prompt: string
+	buttonText?: string
+}
+
+export const quickWinTasks: QuickWinTask[] = [
+	{
+		id: "nextjs_notetaking_app",
+		title: "Build a Next.js App",
+		description: "Create a beautiful notetaking app with Next.js and Tailwind",
+		icon: "WebAppIcon",
+		actionCommand: "cline/createNextJsApp",
+		prompt: "Make a beautiful Next.js notetaking app, using Tailwind CSS for styling. Set up the basic structure and a simple UI for adding and viewing notes.",
+		buttonText: ">",
+	},
+	{
+		id: "terminal_cli_tool",
+		title: "Craft a CLI Tool",
+		description: "Develop a powerful terminal CLI to automate a cool task",
+		icon: "TerminalIcon",
+		actionCommand: "cline/createCliTool",
+		prompt: "Make a terminal CLI tool using Node.js that organizes files in a directory by type, size, or date. It should have options to sort files into folders, show file statistics, find duplicates, and clean up empty directories. Include colorful output and progress indicators.",
+		buttonText: ">",
+	},
+	{
+		id: "snake_game",
+		title: "Develop a Game",
+		description: "Code a classic Snake game that runs in the browser.",
+		icon: "GameIcon",
+		actionCommand: "cline/createSnakeGame",
+		prompt: "Make a classic Snake game using HTML, CSS, and JavaScript. The game should be playable in the browser, with keyboard controls for the snake, a scoring system, and a game over state.",
+		buttonText: ">",
+	},
+]
diff --git a/apps/vscode/webview-ui/src/components/worktrees/CreateWorktreeModal.tsx b/apps/vscode/webview-ui/src/components/worktrees/CreateWorktreeModal.tsx
new file mode 100644
index 0000000..facd40f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/worktrees/CreateWorktreeModal.tsx
@@ -0,0 +1,228 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { CreateWorktreeRequest, SwitchWorktreeRequest } from "@shared/proto/cline/worktree"
+import { VSCodeButton, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { AlertCircle, AlertTriangle, Loader2, X } from "lucide-react"
+import { memo, useCallback, useEffect, useState } from "react"
+import { WorktreeServiceClient } from "@/services/grpc-client"
+
+interface CreateWorktreeModalProps {
+	open: boolean
+	onClose: () => void
+	/** When true, opens the worktree in a new window after creation */
+	openAfterCreate?: boolean
+	/** Called after successful creation (and opening if openAfterCreate is true) */
+	onSuccess?: () => void
+}
+
+const CreateWorktreeModal = ({ open, onClose, openAfterCreate = false, onSuccess }: CreateWorktreeModalProps) => {
+	const [newWorktreePath, setNewWorktreePath] = useState("")
+	const [newBranchName, setNewBranchName] = useState("")
+	const [isCreating, setIsCreating] = useState(false)
+	const [createError, setCreateError] = useState<string | null>(null)
+	const [isLoadingDefaults, setIsLoadingDefaults] = useState(false)
+	const [hasWorktreeInclude, setHasWorktreeInclude] = useState<boolean | null>(null)
+
+	// Load defaults and check .worktreeinclude status when modal opens
+	const loadDefaults = useCallback(async () => {
+		setIsLoadingDefaults(true)
+		try {
+			const [defaults, includeStatus] = await Promise.all([
+				WorktreeServiceClient.getWorktreeDefaults(EmptyRequest.create({})),
+				WorktreeServiceClient.getWorktreeIncludeStatus(EmptyRequest.create({})),
+			])
+			setNewBranchName(defaults.suggestedBranch)
+			setNewWorktreePath(defaults.suggestedPath)
+			setHasWorktreeInclude(includeStatus.exists)
+		} catch (err) {
+			console.error("Failed to load worktree defaults:", err)
+		} finally {
+			setIsLoadingDefaults(false)
+		}
+	}, [])
+
+	useEffect(() => {
+		if (open) {
+			loadDefaults()
+		}
+	}, [open, loadDefaults])
+
+	// Reset form state when modal closes
+	useEffect(() => {
+		if (!open) {
+			setNewWorktreePath("")
+			setNewBranchName("")
+			setCreateError(null)
+			setHasWorktreeInclude(null)
+		}
+	}, [open])
+
+	const handleCreateWorktree = useCallback(async () => {
+		if (!newWorktreePath || !newBranchName) {
+			return
+		}
+
+		setIsCreating(true)
+		setCreateError(null)
+		try {
+			const result = await WorktreeServiceClient.createWorktree(
+				CreateWorktreeRequest.create({
+					path: newWorktreePath,
+					branch: newBranchName,
+					createNewBranch: true,
+				}),
+			)
+
+			if (!result.success) {
+				setCreateError(result.message)
+			} else {
+				// If openAfterCreate is true, open the worktree in a new window
+				if (openAfterCreate && result.worktree?.path) {
+					await WorktreeServiceClient.switchWorktree(
+						SwitchWorktreeRequest.create({
+							path: result.worktree.path,
+							newWindow: true,
+						}),
+					)
+				}
+				onSuccess?.()
+				onClose()
+			}
+		} catch (err) {
+			setCreateError(err instanceof Error ? err.message : "Failed to create worktree")
+		} finally {
+			setIsCreating(false)
+		}
+	}, [newWorktreePath, newBranchName, openAfterCreate, onSuccess, onClose])
+
+	if (!open) {
+		return null
+	}
+
+	const title = openAfterCreate ? "New Worktree" : "Create New Worktree"
+	const buttonText = openAfterCreate ? "Create & Open" : "Create Worktree"
+	const creatingText = openAfterCreate ? "Creating & Opening..." : "Creating..."
+	const description = openAfterCreate
+		? "This will create a copy of your project on a new branch and open in a separate window."
+		: "This will create a copy of your project on a new branch."
+
+	return (
+		<div
+			className="fixed inset-0 bg-black/50 flex items-center justify-center z-50"
+			onClick={(e) => {
+				if (e.target === e.currentTarget) {
+					onClose()
+				}
+			}}>
+			<div className="bg-[var(--vscode-editor-background)] border border-[var(--vscode-panel-border)] rounded-lg p-5 w-[450px] max-w-[90vw] relative">
+				{/* Close button */}
+				<button
+					className="absolute top-3 right-3 p-1 rounded hover:bg-[var(--vscode-toolbar-hoverBackground)] text-[var(--vscode-descriptionForeground)] hover:text-[var(--vscode-foreground)] cursor-pointer"
+					onClick={onClose}
+					type="button">
+					<X className="w-4 h-4" />
+				</button>
+				<h4 className="mt-0 mb-2 pr-6">{title}</h4>
+				<p className="text-sm text-[var(--vscode-descriptionForeground)] mt-0 mb-4">{description}</p>
+				{hasWorktreeInclude === false && (
+					<div
+						className="flex items-start gap-2 p-2 rounded mb-3"
+						style={{ backgroundColor: "var(--vscode-inputValidation-warningBackground)" }}>
+						<AlertTriangle className="w-4 h-4 flex-shrink-0 mt-0.5 text-[var(--vscode-editorWarning-foreground)]" />
+						<p className="text-xs text-[var(--vscode-foreground)] m-0">
+							No .worktreeinclude detected.{" "}
+							<a
+								className="text-[var(--vscode-textLink-foreground)] hover:text-[var(--vscode-textLink-activeForeground)]"
+								href="https://docs.cline.bot/features/worktrees#worktreeinclude"
+								rel="noopener noreferrer"
+								style={{ fontSize: "inherit" }}
+								target="_blank">
+								Learn more
+							</a>
+						</p>
+					</div>
+				)}
+				<div className="flex flex-col">
+					<div>
+						<label className="block text-sm font-medium mb-1">Branch Name *</label>
+						<VSCodeTextField
+							className="w-full"
+							onInput={(e) => setNewBranchName((e.target as HTMLInputElement).value)}
+							placeholder="feature/my-feature"
+							value={newBranchName}>
+							{newBranchName && (
+								<div
+									aria-label="Clear"
+									className="input-icon-button codicon codicon-close"
+									onClick={() => setNewBranchName("")}
+									slot="end"
+									style={{
+										display: "flex",
+										justifyContent: "center",
+										alignItems: "center",
+										height: "100%",
+									}}
+								/>
+							)}
+						</VSCodeTextField>
+						<p className="text-xs text-[var(--vscode-descriptionForeground)] mt-1">
+							Your new copy will be checked out to this branch.
+						</p>
+					</div>
+					<div>
+						<label className="block text-sm font-medium mb-1">Folder Path *</label>
+						<VSCodeTextField
+							className="w-full"
+							onInput={(e) => setNewWorktreePath((e.target as HTMLInputElement).value)}
+							placeholder="../my-feature-worktree"
+							value={newWorktreePath}>
+							{newWorktreePath && (
+								<div
+									aria-label="Clear"
+									className="input-icon-button codicon codicon-close"
+									onClick={() => setNewWorktreePath("")}
+									slot="end"
+									style={{
+										display: "flex",
+										justifyContent: "center",
+										alignItems: "center",
+										height: "100%",
+									}}
+								/>
+							)}
+						</VSCodeTextField>
+						<p className="text-xs text-[var(--vscode-descriptionForeground)] mt-1">
+							Where the project will be copied for the worktree.
+						</p>
+					</div>
+					{createError && (
+						<div className="flex items-start gap-2 p-3 rounded bg-[var(--vscode-inputValidation-errorBackground)] border border-[var(--vscode-inputValidation-errorBorder)]">
+							<AlertCircle className="w-4 h-4 flex-shrink-0 text-[var(--vscode-errorForeground)] mt-0.5" />
+							<p className="text-sm text-[var(--vscode-errorForeground)] m-0">{createError}</p>
+						</div>
+					)}
+					<div className="flex justify-end gap-2">
+						<VSCodeButton
+							disabled={!newWorktreePath || !newBranchName || isCreating || isLoadingDefaults}
+							onClick={handleCreateWorktree}>
+							{isLoadingDefaults ? (
+								<>
+									<Loader2 className="w-4 h-4 mr-1 animate-spin" />
+									Loading...
+								</>
+							) : isCreating ? (
+								<>
+									<Loader2 className="w-4 h-4 mr-1 animate-spin" />
+									{creatingText}
+								</>
+							) : (
+								buttonText
+							)}
+						</VSCodeButton>
+					</div>
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default memo(CreateWorktreeModal)
diff --git a/apps/vscode/webview-ui/src/components/worktrees/DeleteWorktreeModal.tsx b/apps/vscode/webview-ui/src/components/worktrees/DeleteWorktreeModal.tsx
new file mode 100644
index 0000000..cc5ef4e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/worktrees/DeleteWorktreeModal.tsx
@@ -0,0 +1,100 @@
+import { VSCodeButton, VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { AlertTriangle, Loader2, X } from "lucide-react"
+import { memo, useCallback, useState } from "react"
+import { Button } from "@/components/ui/button"
+
+interface DeleteWorktreeModalProps {
+	open: boolean
+	onClose: () => void
+	onConfirm: (deleteBranch: boolean) => Promise<void>
+	worktreePath: string
+	branchName: string
+}
+
+const DeleteWorktreeModal = ({ open, onClose, onConfirm, worktreePath, branchName }: DeleteWorktreeModalProps) => {
+	const [isDeleting, setIsDeleting] = useState(false)
+	const [deleteBranch, setDeleteBranch] = useState(false)
+
+	const handleDelete = useCallback(async () => {
+		setIsDeleting(true)
+		try {
+			await onConfirm(deleteBranch)
+			onClose()
+		} finally {
+			setIsDeleting(false)
+			setDeleteBranch(false)
+		}
+	}, [onConfirm, onClose, deleteBranch])
+
+	if (!open) {
+		return null
+	}
+
+	return (
+		<div
+			className="fixed inset-0 bg-black/50 flex items-center justify-center z-50"
+			onClick={(e) => {
+				if (e.target === e.currentTarget && !isDeleting) {
+					onClose()
+				}
+			}}>
+			<div className="bg-[var(--vscode-editor-background)] border border-[var(--vscode-panel-border)] rounded-lg p-5 w-[400px] max-w-[90vw] relative">
+				{/* Close button */}
+				<button
+					className="absolute top-3 right-3 p-1 rounded hover:bg-[var(--vscode-toolbar-hoverBackground)] text-[var(--vscode-descriptionForeground)] hover:text-[var(--vscode-foreground)] cursor-pointer disabled:opacity-50"
+					disabled={isDeleting}
+					onClick={onClose}
+					type="button">
+					<X className="w-4 h-4" />
+				</button>
+
+				{/* Title row with icon */}
+				<div className="flex items-center gap-2 mb-3 pr-6">
+					<AlertTriangle className="w-5 h-5 text-[var(--vscode-errorForeground)]" />
+					<h4 className="m-0">Delete Worktree</h4>
+				</div>
+
+				{/* Content */}
+				<p className="text-sm text-[var(--vscode-descriptionForeground)] mt-0 mb-3">
+					This will delete the worktree directory at{" "}
+					<span className="font-semibold text-[var(--vscode-foreground)] break-all">{worktreePath}</span>
+				</p>
+
+				<label className="flex items-center gap-2 cursor-pointer mb-3">
+					<VSCodeCheckbox
+						checked={deleteBranch}
+						onChange={(e) => setDeleteBranch((e.target as HTMLInputElement).checked)}
+					/>
+					<span className="text-sm">
+						Also delete branch <span className="font-semibold">{branchName}</span>
+					</span>
+				</label>
+
+				{deleteBranch && (
+					<p className="text-sm text-[var(--vscode-inputValidation-warningForeground)] mt-0 mb-3">
+						Warning: Unpushed commits on this branch will be lost.
+					</p>
+				)}
+
+				{/* Buttons */}
+				<div className="flex justify-end gap-2">
+					<VSCodeButton appearance="secondary" disabled={isDeleting} onClick={onClose}>
+						Cancel
+					</VSCodeButton>
+					<Button disabled={isDeleting} onClick={handleDelete} variant="danger">
+						{isDeleting ? (
+							<>
+								<Loader2 className="w-4 h-4 mr-1 animate-spin" />
+								Deleting...
+							</>
+						) : (
+							"Delete"
+						)}
+					</Button>
+				</div>
+			</div>
+		</div>
+	)
+}
+
+export default memo(DeleteWorktreeModal)
diff --git a/apps/vscode/webview-ui/src/components/worktrees/WorktreesView.tsx b/apps/vscode/webview-ui/src/components/worktrees/WorktreesView.tsx
new file mode 100644
index 0000000..432545f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/worktrees/WorktreesView.tsx
@@ -0,0 +1,641 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { NewTaskRequest } from "@shared/proto/cline/task"
+import type { MergeWorktreeResult, Worktree as WorktreeProto } from "@shared/proto/cline/worktree"
+import {
+	CreateWorktreeIncludeRequest,
+	DeleteWorktreeRequest,
+	MergeWorktreeRequest,
+	SwitchWorktreeRequest,
+} from "@shared/proto/cline/worktree"
+import { VSCodeButton, VSCodeCheckbox } from "@vscode/webview-ui-toolkit/react"
+import { AlertCircle, Check, ExternalLink, FolderOpen, GitBranch, GitMerge, Loader2, Plus, Trash2, X } from "lucide-react"
+import { memo, useCallback, useEffect, useState } from "react"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { FileServiceClient, TaskServiceClient, WorktreeServiceClient } from "@/services/grpc-client"
+import { getEnvironmentColor } from "@/utils/environmentColors"
+import CreateWorktreeModal from "./CreateWorktreeModal"
+import DeleteWorktreeModal from "./DeleteWorktreeModal"
+
+type WorktreesViewProps = {
+	onDone: () => void
+}
+
+const WorktreesView = ({ onDone }: WorktreesViewProps) => {
+	const { environment } = useExtensionState()
+	const [worktrees, setWorktrees] = useState<WorktreeProto[]>([])
+	const [isLoading, setIsLoading] = useState(true)
+	const [error, setError] = useState<string | null>(null)
+	const [isGitRepo, setIsGitRepo] = useState(true)
+	const [isMultiRoot, setIsMultiRoot] = useState(false)
+	const [isSubfolder, setIsSubfolder] = useState(false)
+	const [gitRootPath, setGitRootPath] = useState("")
+	const [showCreateForm, setShowCreateForm] = useState(false)
+	const [deleteWorktree, setDeleteWorktree] = useState<WorktreeProto | null>(null)
+
+	// Merge worktree state
+	const [mergeWorktree, setMergeWorktree] = useState<WorktreeProto | null>(null)
+	const [isMerging, setIsMerging] = useState(false)
+	const [mergeError, setMergeError] = useState<string | null>(null)
+	const [mergeResult, setMergeResult] = useState<MergeWorktreeResult | null>(null)
+	const [deleteAfterMerge, setDeleteAfterMerge] = useState(true)
+
+	// .worktreeinclude status
+	const [hasWorktreeInclude, setHasWorktreeInclude] = useState(false)
+	const [hasGitignore, setHasGitignore] = useState(false)
+	const [gitignoreContent, setGitignoreContent] = useState("")
+	const [isCreatingWorktreeInclude, setIsCreatingWorktreeInclude] = useState(false)
+
+	// Check if a worktree is the main/primary worktree (first one, typically the original clone)
+	const isMainWorktree = useCallback(
+		(worktree: WorktreeProto) => {
+			// The main worktree is typically the first one listed and is where .git directory lives
+			// It's also usually the one that's marked as "bare" or is the original clone location
+			if (worktrees.length === 0) return false
+			return worktree.path === worktrees[0]?.path || worktree.isBare
+		},
+		[worktrees],
+	)
+
+	// Load worktrees - only updates state if data changed to prevent flickering
+	const loadWorktrees = useCallback(async () => {
+		try {
+			const response = await WorktreeServiceClient.listWorktrees(EmptyRequest.create({}))
+			// Only update state if data actually changed (prevents flickering)
+			setWorktrees((prev) => {
+				const newData = JSON.stringify(response.worktrees)
+				const oldData = JSON.stringify(prev)
+				return newData === oldData ? prev : response.worktrees
+			})
+			setIsGitRepo((prev) => (prev === response.isGitRepo ? prev : response.isGitRepo))
+			setIsMultiRoot((prev) => (prev === response.isMultiRoot ? prev : response.isMultiRoot))
+			setIsSubfolder((prev) => (prev === response.isSubfolder ? prev : response.isSubfolder))
+			setGitRootPath((prev) => (prev === response.gitRootPath ? prev : response.gitRootPath))
+			setError((prev) => (response.error ? response.error : prev === null ? null : prev))
+		} catch (err) {
+			setError(err instanceof Error ? err.message : "Failed to load worktrees")
+		} finally {
+			setIsLoading(false)
+		}
+	}, [])
+
+	// Load .worktreeinclude status
+	const loadWorktreeIncludeStatus = useCallback(async () => {
+		try {
+			const status = await WorktreeServiceClient.getWorktreeIncludeStatus(EmptyRequest.create({}))
+			setHasWorktreeInclude(status.exists)
+			setHasGitignore(status.hasGitignore)
+			setGitignoreContent(status.gitignoreContent)
+		} catch (err) {
+			console.error("Failed to load worktree include status:", err)
+		}
+	}, [])
+
+	// Create .worktreeinclude file and open it in editor
+	const handleCreateWorktreeInclude = useCallback(async () => {
+		setIsCreatingWorktreeInclude(true)
+		try {
+			const result = await WorktreeServiceClient.createWorktreeInclude(
+				CreateWorktreeIncludeRequest.create({
+					content: gitignoreContent,
+				}),
+			)
+			if (result.success) {
+				setHasWorktreeInclude(true)
+				// Open the file in the editor
+				await FileServiceClient.openFileRelativePath({ value: ".worktreeinclude" })
+			} else {
+				setError(result.message)
+			}
+		} catch (err) {
+			setError(err instanceof Error ? err.message : "Failed to create .worktreeinclude")
+		} finally {
+			setIsCreatingWorktreeInclude(false)
+		}
+	}, [gitignoreContent])
+
+	// Initial load
+	useEffect(() => {
+		loadWorktrees()
+		loadWorktreeIncludeStatus()
+	}, [loadWorktrees, loadWorktreeIncludeStatus])
+
+	// Poll for updates every 3 seconds while the view is open
+	useEffect(() => {
+		const interval = setInterval(loadWorktrees, 3000)
+		return () => clearInterval(interval)
+	}, [loadWorktrees])
+
+	const handleDeleteWorktree = useCallback(
+		async (path: string, deleteBranch: boolean, branchName: string) => {
+			try {
+				const result = await WorktreeServiceClient.deleteWorktree(
+					DeleteWorktreeRequest.create({
+						path,
+						force: false,
+						deleteBranch,
+						branchName,
+					}),
+				)
+
+				if (!result.success) {
+					setError(result.message)
+				} else {
+					await loadWorktrees()
+				}
+			} catch (err) {
+				setError(err instanceof Error ? err.message : "Failed to delete worktree")
+			}
+		},
+		[loadWorktrees],
+	)
+
+	const handleSwitchWorktree = useCallback(async (path: string, newWindow: boolean) => {
+		try {
+			await WorktreeServiceClient.switchWorktree(
+				SwitchWorktreeRequest.create({
+					path,
+					newWindow,
+				}),
+			)
+		} catch (err) {
+			console.error("Failed to switch worktree:", err)
+		}
+	}, [])
+
+	// Get the main branch name (first worktree's branch, usually main/master)
+	const getMainBranch = useCallback(() => {
+		if (worktrees.length === 0) return "main"
+		return worktrees[0]?.branch || "main"
+	}, [worktrees])
+
+	// Open merge modal for a worktree
+	const openMergeModal = useCallback((worktree: WorktreeProto) => {
+		setMergeWorktree(worktree)
+		setMergeError(null)
+		setMergeResult(null)
+		setDeleteAfterMerge(true)
+	}, [])
+
+	// Close merge modal
+	const closeMergeModal = useCallback(() => {
+		setMergeWorktree(null)
+		setMergeError(null)
+		setMergeResult(null)
+	}, [])
+
+	// Handle merge
+	const handleMergeWorktree = useCallback(async () => {
+		if (!mergeWorktree) return
+
+		setIsMerging(true)
+		setMergeError(null)
+		setMergeResult(null)
+
+		try {
+			const result = await WorktreeServiceClient.mergeWorktree(
+				MergeWorktreeRequest.create({
+					worktreePath: mergeWorktree.path,
+					targetBranch: getMainBranch(),
+					deleteAfterMerge,
+				}),
+			)
+
+			setMergeResult(result)
+
+			if (result.success) {
+				// Reload worktrees to reflect changes
+				await loadWorktrees()
+			} else if (!result.hasConflicts) {
+				setMergeError(result.message)
+			}
+		} catch (err) {
+			setMergeError(err instanceof Error ? err.message : "Failed to merge worktree")
+		} finally {
+			setIsMerging(false)
+		}
+	}, [mergeWorktree, getMainBranch, deleteAfterMerge, loadWorktrees])
+
+	// Ask Cline to resolve conflicts
+	const handleAskClineToResolve = useCallback(async () => {
+		if (!mergeResult || !mergeResult.hasConflicts) return
+
+		const conflictList = mergeResult.conflictingFiles.join(", ")
+		const prompt = `I tried to merge branch '${mergeResult.sourceBranch}' into '${mergeResult.targetBranch}' but there are merge conflicts in the following files: ${conflictList}
+
+Please help me resolve these merge conflicts, then complete the merge, and delete the worktree at: ${mergeWorktree?.path}`
+
+		try {
+			// Create a new task with this prompt
+			await TaskServiceClient.newTask(NewTaskRequest.create({ text: prompt }))
+			closeMergeModal()
+			// Close worktrees view to show the chat with the new task
+			onDone()
+		} catch (err) {
+			setMergeError(err instanceof Error ? err.message : "Failed to create task for Cline")
+		}
+	}, [mergeResult, mergeWorktree, closeMergeModal, onDone])
+
+	return (
+		<div className="fixed inset-0 flex flex-col overflow-hidden">
+			{/* Sticky Header with title and Done button */}
+			<div className="flex-none flex justify-between items-center px-5 py-3 border-b border-[var(--vscode-panel-border)]">
+				<h3 className="m-0" style={{ color: getEnvironmentColor(environment) }}>
+					Worktrees
+				</h3>
+				<VSCodeButton onClick={onDone}>Done</VSCodeButton>
+			</div>
+
+			{/* Scrollable Content */}
+			<div className="flex-1 overflow-y-auto p-5">
+				{/* Description */}
+				<p className="text-sm text-[var(--vscode-descriptionForeground)] m-0 mb-4">
+					Git worktrees let you work on multiple branches at the same time, each in its own folder. Open worktrees in
+					their own windows so Cline can work on multiple tasks in parallel.{" "}
+					<a
+						className="text-[var(--vscode-textLink-foreground)] hover:text-[var(--vscode-textLink-activeForeground)]"
+						href="https://docs.cline.bot/features/worktrees"
+						rel="noopener noreferrer"
+						style={{ fontSize: "inherit" }}
+						target="_blank">
+						Learn more
+					</a>
+				</p>
+
+				{/* .worktreeinclude status */}
+				{isGitRepo && !isMultiRoot && !isSubfolder && (
+					<div
+						className="p-3 rounded-md"
+						style={{
+							border: "1px solid var(--vscode-widget-border)",
+							backgroundColor: "var(--vscode-list-hoverBackground)",
+						}}>
+						{hasWorktreeInclude ? (
+							<p className="text-sm text-[var(--vscode-testing-iconPassed)] m-0">
+								<Check className="w-4 h-4 inline-block align-text-bottom mr-1" />
+								.worktreeinclude detected.{" "}
+								<a
+									className="text-[var(--vscode-textLink-foreground)] hover:text-[var(--vscode-textLink-activeForeground)]"
+									href="https://docs.cline.bot/features/worktrees#worktreeinclude"
+									rel="noopener noreferrer"
+									style={{ fontSize: "inherit" }}
+									target="_blank">
+									Learn more
+								</a>
+							</p>
+						) : (
+							<div className="flex flex-col gap-2">
+								<p className="text-sm text-[var(--vscode-descriptionForeground)] m-0">
+									<strong>Tip:</strong> Create a{" "}
+									<code className="bg-[var(--vscode-textCodeBlock-background)] px-1 rounded">
+										.worktreeinclude
+									</code>{" "}
+									file to automatically copy files like{" "}
+									<code className="bg-[var(--vscode-textCodeBlock-background)] px-1 rounded">
+										node_modules/
+									</code>{" "}
+									to new worktrees, so you don't have to reinstall dependencies.{" "}
+									<a
+										className="text-[var(--vscode-textLink-foreground)] hover:text-[var(--vscode-textLink-activeForeground)]"
+										href="https://docs.cline.bot/features/worktrees#worktreeinclude"
+										rel="noopener noreferrer"
+										style={{ fontSize: "inherit" }}
+										target="_blank">
+										Learn more
+									</a>
+								</p>
+								{hasGitignore && (
+									<VSCodeButton
+										appearance="secondary"
+										disabled={isCreatingWorktreeInclude}
+										onClick={handleCreateWorktreeInclude}>
+										{isCreatingWorktreeInclude ? (
+											<>
+												<Loader2 className="w-3 h-3 mr-1 animate-spin" />
+												Creating...
+											</>
+										) : (
+											"Create from .gitignore"
+										)}
+									</VSCodeButton>
+								)}
+							</div>
+						)}
+					</div>
+				)}
+
+				{/* Loading/Error States */}
+				{isLoading ? (
+					<div className="flex items-center justify-center min-h-32 py-8">
+						<Loader2 className="w-6 h-6 animate-spin text-[var(--vscode-descriptionForeground)]" />
+						<span className="ml-2 text-[var(--vscode-descriptionForeground)]">Loading...</span>
+					</div>
+				) : isMultiRoot ? (
+					<div className="flex flex-col items-center justify-center min-h-32 py-8 text-center">
+						<AlertCircle className="w-8 h-8 text-[var(--vscode-inputValidation-warningForeground)] mb-2 shrink-0" />
+						<p className="text-[var(--vscode-foreground)] font-medium mb-1">Multi-folder workspace detected</p>
+						<p className="text-[var(--vscode-descriptionForeground)] text-sm">
+							Worktrees are not supported when multiple folders are open in the same workspace. Please open a single
+							repository folder to use this feature.
+						</p>
+					</div>
+				) : isSubfolder ? (
+					<div className="flex flex-col items-center justify-center min-h-32 py-8 text-center">
+						<AlertCircle className="w-8 h-8 text-[var(--vscode-inputValidation-warningForeground)] mb-2 shrink-0" />
+						<p className="text-[var(--vscode-foreground)] font-medium mb-1">Subfolder of a git repository</p>
+						<p className="text-[var(--vscode-descriptionForeground)] text-sm">
+							You have a subfolder open instead of the repository root. Please open the root folder to use
+							worktrees:
+						</p>
+						<code className="mt-2 px-2 py-1 bg-[var(--vscode-textCodeBlock-background)] rounded text-sm break-all">
+							{gitRootPath}
+						</code>
+					</div>
+				) : !isGitRepo ? (
+					<div className="flex flex-col items-center justify-center min-h-32 py-8 text-center">
+						<AlertCircle className="w-8 h-8 text-[var(--vscode-descriptionForeground)] mb-2 shrink-0" />
+						<p className="text-[var(--vscode-descriptionForeground)]">
+							Worktrees require a git repository. Please initialize git to use worktrees.
+						</p>
+					</div>
+				) : error ? (
+					<div className="flex flex-col items-center justify-center min-h-32 py-8 text-center">
+						<AlertCircle className="w-8 h-8 text-[var(--vscode-errorForeground)] mb-2 shrink-0" />
+						<p className="text-[var(--vscode-errorForeground)]">{error}</p>
+						<VSCodeButton appearance="secondary" className="mt-3" onClick={loadWorktrees}>
+							Retry
+						</VSCodeButton>
+					</div>
+				) : worktrees.length === 0 ? (
+					<div className="flex flex-col items-center justify-center min-h-32 py-8 text-center">
+						<GitBranch className="w-8 h-8 text-[var(--vscode-descriptionForeground)] mb-2 shrink-0" />
+						<p className="text-[var(--vscode-descriptionForeground)]">No worktrees found.</p>
+					</div>
+				) : (
+					<>
+						{/* Worktrees List - current worktree first, then others */}
+						<div className="mt-4 flex flex-col gap-2">
+							{worktrees.map((worktree) => (
+								<div
+									className={`p-4 rounded border ${
+										worktree.isCurrent
+											? "border-[var(--vscode-focusBorder)] bg-[var(--vscode-list-activeSelectionBackground)]"
+											: "border-[var(--vscode-panel-border)]"
+									}`}
+									key={worktree.path}>
+									{/* Branch name, badges, and action buttons - wraps on small screens */}
+									<div className="flex flex-wrap items-center justify-between gap-2 mb-1">
+										{/* Left side: branch name and badges */}
+										<div className="flex flex-wrap items-center gap-2">
+											<div className="flex items-center gap-2">
+												<GitBranch className="w-4 h-4 flex-shrink-0 text-[var(--vscode-button-background)]" />
+												<span className="font-medium break-all">
+													{worktree.branch || (worktree.isDetached ? "HEAD (detached)" : "unknown")}
+												</span>
+											</div>
+											{isMainWorktree(worktree) && (
+												<Tooltip>
+													<TooltipTrigger asChild>
+														<span className="text-xs px-1.5 py-0.5 rounded bg-[var(--vscode-badge-background)] text-[var(--vscode-badge-foreground)] cursor-help">
+															Primary
+														</span>
+													</TooltipTrigger>
+													<TooltipContent side="bottom">
+														The original worktree where your .git directory lives.
+													</TooltipContent>
+												</Tooltip>
+											)}
+											{worktree.isCurrent && (
+												<Tooltip>
+													<TooltipTrigger asChild>
+														<span className="text-xs px-1.5 py-0.5 rounded bg-[var(--vscode-button-background)] text-[var(--vscode-button-foreground)] cursor-help">
+															Current
+														</span>
+													</TooltipTrigger>
+													<TooltipContent side="bottom">
+														This is the worktree currently open in this window.
+													</TooltipContent>
+												</Tooltip>
+											)}
+											{worktree.isLocked && (
+												<span className="text-xs px-1.5 py-0.5 rounded bg-[var(--vscode-inputValidation-warningBackground)] text-[var(--vscode-inputValidation-warningForeground)]">
+													Locked
+												</span>
+											)}
+										</div>
+										{/* Right side: action buttons */}
+										<div className="flex items-center gap-1">
+											{!worktree.isCurrent && (
+												<>
+													<Tooltip>
+														<TooltipTrigger asChild>
+															<VSCodeButton
+																appearance="icon"
+																onClick={() => handleSwitchWorktree(worktree.path, false)}>
+																<FolderOpen className="w-4 h-4" />
+															</VSCodeButton>
+														</TooltipTrigger>
+														<TooltipContent side="bottom">Open in current window</TooltipContent>
+													</Tooltip>
+													<Tooltip>
+														<TooltipTrigger asChild>
+															<VSCodeButton
+																appearance="icon"
+																onClick={() => handleSwitchWorktree(worktree.path, true)}>
+																<ExternalLink className="w-4 h-4" />
+															</VSCodeButton>
+														</TooltipTrigger>
+														<TooltipContent side="bottom">Open in new window</TooltipContent>
+													</Tooltip>
+												</>
+											)}
+											{!worktree.isCurrent && !isMainWorktree(worktree) && (
+												<>
+													<Tooltip>
+														<TooltipTrigger asChild>
+															<VSCodeButton
+																appearance="icon"
+																onClick={() => openMergeModal(worktree)}>
+																<GitMerge className="w-4 h-4 text-[var(--vscode-testing-iconPassed)]" />
+															</VSCodeButton>
+														</TooltipTrigger>
+														<TooltipContent side="bottom">
+															Merge into {getMainBranch()}
+														</TooltipContent>
+													</Tooltip>
+													<Tooltip>
+														<TooltipTrigger asChild>
+															<VSCodeButton
+																appearance="icon"
+																onClick={() => setDeleteWorktree(worktree)}>
+																<Trash2 className="w-4 h-4 text-[var(--vscode-errorForeground)]" />
+															</VSCodeButton>
+														</TooltipTrigger>
+														<TooltipContent side="bottom">Delete this worktree</TooltipContent>
+													</Tooltip>
+												</>
+											)}
+										</div>
+									</div>
+									{/* Path */}
+									<p className="text-sm text-[var(--vscode-descriptionForeground)] m-0 break-all">
+										{worktree.path}
+									</p>
+								</div>
+							))}
+						</div>
+					</>
+				)}
+			</div>
+
+			{/* Fixed Bottom - New Worktree Button */}
+			{isGitRepo && !isMultiRoot && !isSubfolder && (
+				<div
+					className="flex-none px-5 py-3"
+					style={{
+						borderTop: "1px solid var(--vscode-panel-border)",
+					}}>
+					<VSCodeButton disabled={isLoading} onClick={() => setShowCreateForm(true)} style={{ width: "100%" }}>
+						<Plus className="w-4 h-4 mr-1" />
+						New Worktree
+					</VSCodeButton>
+				</div>
+			)}
+
+			{/* Create Worktree Modal */}
+			<CreateWorktreeModal onClose={() => setShowCreateForm(false)} onSuccess={loadWorktrees} open={showCreateForm} />
+
+			{/* Delete Worktree Modal */}
+			<DeleteWorktreeModal
+				branchName={deleteWorktree?.branch || ""}
+				onClose={() => setDeleteWorktree(null)}
+				onConfirm={(deleteBranch) => handleDeleteWorktree(deleteWorktree!.path, deleteBranch, deleteWorktree!.branch)}
+				open={!!deleteWorktree}
+				worktreePath={deleteWorktree?.path || ""}
+			/>
+
+			{/* Merge Worktree Modal */}
+			{mergeWorktree && (
+				<div
+					className="fixed inset-0 bg-black/50 flex items-center justify-center z-50"
+					onClick={(e) => {
+						if (e.target === e.currentTarget && !isMerging) {
+							closeMergeModal()
+						}
+					}}>
+					<div className="bg-[var(--vscode-editor-background)] border border-[var(--vscode-panel-border)] rounded-lg p-5 w-[450px] max-w-[90vw] relative">
+						{/* Close button */}
+						<button
+							className="absolute top-3 right-3 p-1 rounded hover:bg-[var(--vscode-toolbar-hoverBackground)] text-[var(--vscode-descriptionForeground)] hover:text-[var(--vscode-foreground)] cursor-pointer"
+							disabled={isMerging}
+							onClick={closeMergeModal}
+							type="button">
+							<X className="w-4 h-4" />
+						</button>
+
+						<div className="flex items-center gap-2 mb-2">
+							<GitMerge className="w-5 h-5 text-[var(--vscode-testing-iconPassed)]" />
+							<h4 className="m-0 pr-6">Merge Worktree</h4>
+						</div>
+
+						{/* Success state */}
+						{mergeResult?.success ? (
+							<div className="flex flex-col gap-4">
+								<div className="flex items-center gap-2 p-3 rounded bg-[var(--vscode-testing-iconPassed)]/10 border border-[var(--vscode-testing-iconPassed)]">
+									<Check className="w-5 h-5 text-[var(--vscode-testing-iconPassed)]" />
+									<p className="text-sm m-0">{mergeResult.message}</p>
+								</div>
+								<div className="flex justify-end">
+									<VSCodeButton onClick={closeMergeModal}>Done</VSCodeButton>
+								</div>
+							</div>
+						) : mergeResult?.hasConflicts ? (
+							/* Conflict state */
+							<div className="flex flex-col gap-4">
+								<div className="flex items-start gap-2 p-3 rounded bg-[var(--vscode-inputValidation-warningBackground)] border border-[var(--vscode-inputValidation-warningBorder)]">
+									<AlertCircle className="w-5 h-5 flex-shrink-0 text-[var(--vscode-inputValidation-warningForeground)] mt-0.5" />
+									<div>
+										<p className="text-sm font-medium m-0 mb-1">Merge conflicts detected</p>
+										<p className="text-sm text-[var(--vscode-descriptionForeground)] m-0 mb-2">
+											The following files have conflicts:
+										</p>
+										<ul className="m-0 pl-4 text-sm font-mono text-[var(--vscode-descriptionForeground)]">
+											{mergeResult.conflictingFiles.slice(0, 3).map((file) => (
+												<li key={file}>{file}</li>
+											))}
+											{mergeResult.conflictingFiles.length > 3 && (
+												<li className="text-[var(--vscode-descriptionForeground)]">
+													...and {mergeResult.conflictingFiles.length - 3} more
+												</li>
+											)}
+										</ul>
+									</div>
+								</div>
+
+								<div className="flex flex-col gap-2">
+									<VSCodeButton onClick={handleAskClineToResolve} style={{ width: "100%" }}>
+										Ask Cline to Resolve
+									</VSCodeButton>
+									<VSCodeButton appearance="secondary" onClick={closeMergeModal} style={{ width: "100%" }}>
+										I'll Resolve Manually
+									</VSCodeButton>
+								</div>
+							</div>
+						) : (
+							/* Default state - confirm merge */
+							<div className="flex flex-col gap-4">
+								<p className="text-sm text-[var(--vscode-descriptionForeground)] m-0">
+									This will merge branch{" "}
+									<code className="bg-[var(--vscode-textCodeBlock-background)] px-1 rounded">
+										{mergeWorktree.branch}
+									</code>{" "}
+									into{" "}
+									<code className="bg-[var(--vscode-textCodeBlock-background)] px-1 rounded">
+										{getMainBranch()}
+									</code>
+									.
+								</p>
+
+								<label className="flex items-center gap-2 cursor-pointer">
+									<VSCodeCheckbox
+										checked={deleteAfterMerge}
+										onChange={(e) => setDeleteAfterMerge((e.target as HTMLInputElement).checked)}
+									/>
+									<span className="text-sm">Delete worktree after successful merge</span>
+								</label>
+
+								{mergeError && (
+									<div className="flex items-start gap-2 p-3 rounded bg-[var(--vscode-inputValidation-errorBackground)] border border-[var(--vscode-inputValidation-errorBorder)]">
+										<AlertCircle className="w-4 h-4 flex-shrink-0 text-[var(--vscode-errorForeground)] mt-0.5" />
+										<p className="text-sm text-[var(--vscode-errorForeground)] m-0">{mergeError}</p>
+									</div>
+								)}
+
+								<div className="flex justify-end gap-2">
+									<VSCodeButton appearance="secondary" disabled={isMerging} onClick={closeMergeModal}>
+										Cancel
+									</VSCodeButton>
+									<VSCodeButton disabled={isMerging} onClick={handleMergeWorktree}>
+										{isMerging ? (
+											<>
+												<Loader2 className="w-4 h-4 mr-1 animate-spin" />
+												Merging...
+											</>
+										) : (
+											<>
+												<GitMerge className="w-4 h-4 mr-1" />
+												Merge
+											</>
+										)}
+									</VSCodeButton>
+								</div>
+							</div>
+						)}
+					</div>
+				</div>
+			)}
+		</div>
+	)
+}
+
+export default memo(WorktreesView)
diff --git a/apps/vscode/webview-ui/src/config/StorybookDecorator.tsx b/apps/vscode/webview-ui/src/config/StorybookDecorator.tsx
new file mode 100644
index 0000000..a4ca7bd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/config/StorybookDecorator.tsx
@@ -0,0 +1,86 @@
+import "../../../node_modules/@vscode/codicons/dist/codicon.css"
+import "../../../node_modules/@vscode/codicons/dist/codicon.ttf"
+import "../../src/index.css"
+
+import { cn } from "@heroui/react"
+import type { Decorator } from "@storybook/react-vite"
+import React from "react"
+import { ClineAuthContext, ClineAuthContextType, ClineAuthProvider, useClineAuth } from "@/context/ClineAuthContext"
+import {
+	ExtensionStateContext,
+	ExtensionStateContextProvider,
+	ExtensionStateContextType,
+	useExtensionState,
+} from "@/context/ExtensionStateContext"
+import { StorybookThemes } from "../../.storybook/themes"
+
+// Component that handles theme switching
+const ThemeHandler: React.FC<{ children: React.ReactNode; theme?: string }> = ({ children, theme }) => {
+	React.useEffect(() => {
+		const styles = theme?.includes("light") ? StorybookThemes.light : StorybookThemes.dark
+
+		// Apply CSS variables to the document root
+		const root = document.documentElement
+		Object.entries(styles).forEach(([property, value]) => {
+			root.style.setProperty(property, value)
+		})
+
+		document.body.style.backgroundColor = styles["--vscode-editor-background"]
+		document.body.style.color = styles["--vscode-editor-foreground"]
+		document.body.style.fontFamily = styles["--vscode-font-family"]
+		document.body.style.fontSize = styles["--vscode-font-size"]
+
+		return () => {
+			// Cleanup on unmount
+			Object.keys(styles).forEach((property) => {
+				root.style.removeProperty(property)
+			})
+		}
+	}, [theme])
+
+	return <>{children}</>
+}
+function StorybookDecoratorProvider(className = "relative"): Decorator {
+	return (story, parameters) => {
+		return (
+			<div className={className}>
+				<ExtensionStateContextProvider>
+					<ClineAuthProvider>
+						<ThemeHandler theme={parameters?.globals?.theme}>{React.createElement(story)}</ThemeHandler>
+					</ClineAuthProvider>
+				</ExtensionStateContextProvider>
+			</div>
+		)
+	}
+}
+
+// Wrapper component to safely use useExtensionState inside the provider
+const ExtensionStateProviderWithOverrides: React.FC<{
+	overrides?: Partial<ExtensionStateContextType>
+	children: React.ReactNode
+}> = ({ overrides, children }) => {
+	const extensionState = useExtensionState()
+	return <ExtensionStateContext.Provider value={{ ...extensionState, ...overrides }}>{children}</ExtensionStateContext.Provider>
+}
+
+const ClineAuthProviderWithOverrides: React.FC<{
+	overrides?: Partial<ClineAuthContextType>
+	children: React.ReactNode
+}> = ({ overrides, children }) => {
+	const authContext = useClineAuth()
+	return <ClineAuthContext.Provider value={{ ...authContext, ...overrides }}>{children}</ClineAuthContext.Provider>
+}
+
+export const createStorybookDecorator =
+	(overrideStates?: Partial<ExtensionStateContextType>, classNames?: string, authOverrides?: Partial<ClineAuthContextType>) =>
+	(Story: any) => (
+		<ExtensionStateProviderWithOverrides overrides={overrideStates}>
+			<ClineAuthProviderWithOverrides overrides={authOverrides}>
+				<div className={cn("max-w-lg mx-auto", classNames)}>
+					<Story />
+				</div>
+			</ClineAuthProviderWithOverrides>
+		</ExtensionStateProviderWithOverrides>
+	)
+
+export const StorybookWebview = StorybookDecoratorProvider()
diff --git a/apps/vscode/webview-ui/src/config/platform-configs.json b/apps/vscode/webview-ui/src/config/platform-configs.json
new file mode 100644
index 0000000..b3a4494
--- /dev/null
+++ b/apps/vscode/webview-ui/src/config/platform-configs.json
@@ -0,0 +1,16 @@
+{
+	"vscode": {
+		"messageEncoding": "none",
+		"showNavbar": false,
+		"postMessageHandler": "vscode",
+		"togglePlanActKeys": "Meta+Shift+a",
+		"supportsTerminalMentions": true
+	},
+	"standalone": {
+		"messageEncoding": "json",
+		"showNavbar": true,
+		"postMessageHandler": "standalone",
+		"togglePlanActKeys": "Meta+Shift+p",
+		"supportsTerminalMentions": false
+	}
+}
diff --git a/apps/vscode/webview-ui/src/config/platform.config.ts b/apps/vscode/webview-ui/src/config/platform.config.ts
new file mode 100644
index 0000000..b590881
--- /dev/null
+++ b/apps/vscode/webview-ui/src/config/platform.config.ts
@@ -0,0 +1,120 @@
+import platformConfigs from "./platform-configs.json"
+
+export interface PlatformConfig {
+	type: PlatformType
+	messageEncoding: MessageEncoding
+	showNavbar: boolean
+	postMessage: PostMessageFunction
+	encodeMessage: MessageEncoder
+	decodeMessage: MessageDecoder
+	togglePlanActKeys: string
+	supportsTerminalMentions: boolean
+}
+
+export enum PlatformType {
+	VSCODE = 0,
+	STANDALONE = 1,
+}
+
+function stringToPlatformType(name: string): PlatformType {
+	const mapping: Record<string, PlatformType> = {
+		vscode: PlatformType.VSCODE,
+		standalone: PlatformType.STANDALONE,
+	}
+	if (name in mapping) {
+		return mapping[name]
+	}
+	console.error("Unknown platform:", name)
+	// Default to VSCode for unknown types
+	return PlatformType.VSCODE
+}
+
+// Internal type for JSON structure (not exported)
+type PlatformConfigJson = {
+	messageEncoding: "none" | "json"
+	showNavbar: boolean
+	postMessageHandler: "vscode" | "standalone"
+	togglePlanActKeys: string
+	supportsTerminalMentions: boolean
+}
+
+type PlatformConfigs = Record<string, PlatformConfigJson>
+
+// Global type declarations for postMessage and vscode API
+declare global {
+	interface Window {
+		// This is the post message handler injected by JetBrains.
+		// !! Do not change the name of the handler without updating it on
+		// the JetBrains side as well. !!
+		standalonePostMessage?: (message: string) => void
+	}
+	function acquireVsCodeApi(): any
+}
+
+// Initialize the vscode API if available
+const vsCodeApi = typeof acquireVsCodeApi === "function" ? acquireVsCodeApi() : null
+
+// Expose the VSCode API for debug harness access
+if (vsCodeApi && typeof window !== "undefined") {
+	;(window as any).__clineVsCodeApi = vsCodeApi
+}
+
+// Implementations for post message handling
+const postMessageStrategies: Record<string, PostMessageFunction> = {
+	vscode: (message: any) => {
+		if (vsCodeApi) {
+			vsCodeApi.postMessage(message)
+		} else {
+			console.log("postMessage fallback: ", message)
+		}
+	},
+	standalone: (message: any) => {
+		if (!window.standalonePostMessage) {
+			console.error("Standalone postMessage not found.")
+			return
+		}
+		const json = JSON.stringify(message)
+		console.log("Standalone postMessage: " + json.slice(0, 200))
+		window.standalonePostMessage(json)
+	},
+}
+
+// Implementations for message encoding
+const messageEncoders: Record<string, MessageEncoder> = {
+	none: <T>(message: T, _encoder: (_: T) => unknown) => message,
+	json: <T>(message: T, encoder: (_: T) => unknown) => encoder(message),
+}
+
+// Implementations for message decoding
+const messageDecoders: Record<string, MessageDecoder> = {
+	none: <T>(message: any, _decoder: (_: { [key: string]: any }) => T) => message,
+	json: <T>(message: any, decoder: (_: { [key: string]: any }) => T) => decoder(message),
+}
+
+// Local declaration of the platform compile-time constant
+declare const __PLATFORM__: string
+
+// Get the specific platform config at compile time
+const configs = platformConfigs as PlatformConfigs
+const selectedConfig = configs[__PLATFORM__]
+console.log("[PLATFORM_CONFIG] Build platform:", __PLATFORM__)
+
+// Build the platform config with injected functions
+// Callers should use this in the situations where the react component is not available.
+export const PLATFORM_CONFIG: PlatformConfig = {
+	type: stringToPlatformType(__PLATFORM__),
+	messageEncoding: selectedConfig.messageEncoding,
+	showNavbar: selectedConfig.showNavbar,
+	postMessage: postMessageStrategies[selectedConfig.postMessageHandler],
+	encodeMessage: messageEncoders[selectedConfig.messageEncoding],
+	decodeMessage: messageDecoders[selectedConfig.messageEncoding],
+	togglePlanActKeys: selectedConfig.togglePlanActKeys,
+	supportsTerminalMentions: selectedConfig.supportsTerminalMentions,
+}
+
+type MessageEncoding = "none" | "json"
+
+// Function types for platform-specific behaviors
+type PostMessageFunction = (message: any) => void
+type MessageEncoder = <T>(message: T, encoder: (_: T) => unknown) => any
+type MessageDecoder = <T>(message: any, decoder: (_: { [key: string]: any }) => T) => T
diff --git a/apps/vscode/webview-ui/src/constants.ts b/apps/vscode/webview-ui/src/constants.ts
new file mode 100644
index 0000000..977a24c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/constants.ts
@@ -0,0 +1,6 @@
+export const LINKS = {
+	DOCUMENTATION: {
+		REMOTE_MCP_SERVER_DOCS: "https://docs.cline.bot/mcp/connecting-to-a-remote-server",
+		LOCAL_MCP_SERVER_DOCS: "https://docs.cline.bot/mcp/configuring-mcp-servers#editing-mcp-settings-files",
+	},
+}
diff --git a/apps/vscode/webview-ui/src/constants/featureFlags.ts b/apps/vscode/webview-ui/src/constants/featureFlags.ts
new file mode 100644
index 0000000..2fa7394
--- /dev/null
+++ b/apps/vscode/webview-ui/src/constants/featureFlags.ts
@@ -0,0 +1,3 @@
+// Webview copies of feature-flag strings. Must match the extension's FeatureFlag
+// enum, which can't be imported here (it pulls in Node-only deps).
+export const CLINE_PASS_FEATURE_FLAG = "ext-cline-pass"
diff --git a/apps/vscode/webview-ui/src/context/ClineAuthContext.tsx b/apps/vscode/webview-ui/src/context/ClineAuthContext.tsx
new file mode 100644
index 0000000..f646584
--- /dev/null
+++ b/apps/vscode/webview-ui/src/context/ClineAuthContext.tsx
@@ -0,0 +1,149 @@
+import type { UserOrganization } from "@shared/proto/cline/account"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import deepEqual from "fast-deep-equal"
+import type React from "react"
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react"
+import { AccountServiceClient } from "@/services/grpc-client"
+
+// Define User type (you may need to adjust this based on your actual User type)
+export interface ClineUser {
+	uid: string
+	email?: string
+	displayName?: string
+	photoUrl?: string
+	appBaseUrl?: string
+}
+
+export interface ClineAuthContextType {
+	clineUser: ClineUser | null
+	organizations: UserOrganization[] | null
+	activeOrganization: UserOrganization | null
+}
+
+export const ClineAuthContext = createContext<ClineAuthContextType | undefined>(undefined)
+
+export const ClineAuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+	const [user, setUser] = useState<ClineUser | null>(null)
+	const [userOrganizations, setUserOrganizations] = useState<UserOrganization[] | null>(null)
+
+	const getUserOrganizations = useCallback(async () => {
+		try {
+			const response = await AccountServiceClient.getUserOrganizations(EmptyRequest.create())
+			setUserOrganizations((old) => {
+				if (!deepEqual(response.organizations, old)) {
+					return response.organizations
+				}
+
+				return old
+			})
+		} catch (error) {
+			console.error("Failed to fetch user organizations:", error)
+		}
+	}, [])
+
+	const activeOrganization = useMemo(() => {
+		return userOrganizations?.find((org) => org.active) ?? null
+	}, [userOrganizations])
+
+	useEffect(() => {
+		console.log("Extension: ClineAuthContext: user updated:", user?.uid)
+	}, [user?.uid])
+
+	// Handle auth status update events
+	useEffect(() => {
+		const cancelSubscription = AccountServiceClient.subscribeToAuthStatusUpdate(EmptyRequest.create(), {
+			onResponse: async (response: any) => {
+				setUser((oldUser) => {
+					if (!response?.user?.uid) {
+						return null
+					}
+
+					if (response?.user && oldUser?.uid !== response.user.uid) {
+						// Once we have a new user, fetch organizations that
+						// allow us to display the active account in account view UI
+						// and fetch the correct credit balance to display on mount
+						getUserOrganizations()
+						return response.user
+					}
+
+					return oldUser
+				})
+			},
+			onError: (error: Error) => {
+				console.error("Error in auth callback subscription:", error)
+			},
+			onComplete: () => {
+				console.log("Auth callback subscription completed")
+			},
+		})
+
+		// Cleanup function to cancel subscription when component unmounts
+		return () => {
+			cancelSubscription()
+		}
+	}, [getUserOrganizations])
+
+	return (
+		<ClineAuthContext.Provider
+			value={{
+				clineUser: user,
+				organizations: userOrganizations,
+				activeOrganization,
+			}}>
+			{children}
+		</ClineAuthContext.Provider>
+	)
+}
+
+export const useClineAuth = () => {
+	const context = useContext(ClineAuthContext)
+	if (context === undefined) {
+		throw new Error("useClineAuth must be used within a ClineAuthProvider")
+	}
+	return context
+}
+
+export const useClineSignIn = () => {
+	const [isLoading, setIsLoading] = useState(false)
+	const [authStatusMessage, setAuthStatusMessage] = useState<string | null>(null)
+
+	const handleSignIn = useCallback(() => {
+		try {
+			setIsLoading(true)
+			setAuthStatusMessage(null)
+
+			AccountServiceClient.accountLoginClicked(EmptyRequest.create())
+				.then((response) => {
+					setAuthStatusMessage(response.value || "Complete sign-in in your browser.")
+				})
+				.catch((err) => {
+					console.error("Failed to start login:", err)
+					setAuthStatusMessage("Unable to start sign-in. Please try again.")
+				})
+				.finally(() => {
+					setIsLoading(false)
+				})
+		} catch (error) {
+			console.error("Error signing in:", error)
+			setAuthStatusMessage("Unable to start sign-in. Please try again.")
+			setIsLoading(false)
+		}
+	}, [])
+
+	return {
+		isLoginLoading: isLoading,
+		authStatusMessage,
+		handleSignIn,
+	}
+}
+
+export const handleSignOut = async () => {
+	try {
+		await AccountServiceClient.accountLogoutClicked(EmptyRequest.create()).catch((err) =>
+			console.error("Failed to logout:", err),
+		)
+	} catch (error) {
+		console.error("Error signing out:", error)
+		throw error
+	}
+}
diff --git a/apps/vscode/webview-ui/src/context/ExtensionStateContext.tsx b/apps/vscode/webview-ui/src/context/ExtensionStateContext.tsx
new file mode 100644
index 0000000..923429f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/context/ExtensionStateContext.tsx
@@ -0,0 +1,1024 @@
+import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
+import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
+import { DEFAULT_PLATFORM, type ExtensionState } from "@shared/ExtensionMessage"
+import { DEFAULT_MCP_DISPLAY_MODE } from "@shared/McpDisplayMode"
+import type { UserInfo } from "@shared/proto/cline/account"
+import { EmptyRequest } from "@shared/proto/cline/common"
+import type { OpenRouterCompatibleModelInfo, ProviderModelsResponse } from "@shared/proto/cline/models"
+import { OnboardingModelGroup, type TerminalProfile } from "@shared/proto/cline/state"
+import { convertProtoToClineMessage } from "@shared/proto-conversions/cline-message"
+import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
+import { fromProtobufModels } from "@shared/proto-conversions/models/typeConversion"
+import type React from "react"
+import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react"
+import {
+	type ModelInfo,
+	openRouterDefaultModelId,
+	openRouterDefaultModelInfo,
+	requestyDefaultModelId,
+	requestyDefaultModelInfo,
+} from "../../../src/shared/api"
+import { Environment } from "../../../src/shared/config-types"
+import type { McpServer, McpViewTab } from "../../../src/shared/mcp"
+import {
+	createReplicaState,
+	type ReplicaState,
+	applyMessage as reducerApplyMessage,
+	applyStateSnapshot as reducerApplyStateSnapshot,
+} from "../components/chat/chat-view/messageReducer"
+import { McpServiceClient, ModelsServiceClient, StateServiceClient, UiServiceClient } from "../services/grpc-client"
+
+export type ProviderId = string
+
+interface ProviderModelsState {
+	providerId: ProviderId
+	models: Record<string, ModelInfo>
+	defaultModelId: string
+	configFingerprint: string
+	requestId: string
+	source?: string
+	fetchedAt: number
+	isLoading: boolean
+	isStale: boolean
+	error?: string
+}
+
+export interface ExtensionStateContextType extends ExtensionState {
+	didHydrateState: boolean
+	showWelcome: boolean
+	onboardingModels: OnboardingModelGroup | undefined
+	openRouterModels: Record<string, ModelInfo>
+	vercelAiGatewayModels: Record<string, ModelInfo>
+	hicapModels: Record<string, ModelInfo>
+	liteLlmModels: Record<string, ModelInfo>
+	openAiModels: string[]
+	requestyModels: Record<string, ModelInfo>
+	groqModels: Record<string, ModelInfo>
+	basetenModels: Record<string, ModelInfo>
+	huggingFaceModels: Record<string, ModelInfo>
+	providerModelsByProvider: Partial<Record<ProviderId, ProviderModelsState>>
+	latestModelRequestIdByProvider: Partial<Record<ProviderId, string>>
+	mcpServers: McpServer[]
+	totalTasksSize: number | null
+	lastDismissedCliBannerVersion: number
+	dismissedBanners?: Array<{ bannerId: string; dismissedAt: number }>
+
+	availableTerminalProfiles: TerminalProfile[]
+
+	// View state
+	showMarketplace: boolean
+	showMcp: boolean
+	mcpTab?: McpViewTab
+	showSettings: boolean
+	settingsTargetSection?: string
+	settingsInitialModelTab?: "recommended" | "free"
+	showHistory: boolean
+	showAccount: boolean
+	showWorktrees: boolean
+	showAnnouncement: boolean
+	expandTaskHeader: boolean
+
+	// Setters
+	setShowAnnouncement: (value: boolean) => void
+	setShouldShowAnnouncement: (value: boolean) => void
+	setMcpServers: (value: McpServer[]) => void
+	setRequestyModels: (value: Record<string, ModelInfo>) => void
+	setGroqModels: (value: Record<string, ModelInfo>) => void
+	setBasetenModels: (value: Record<string, ModelInfo>) => void
+	setHuggingFaceModels: (value: Record<string, ModelInfo>) => void
+	setGlobalClineRulesToggles: (toggles: Record<string, boolean>) => void
+	setLocalClineRulesToggles: (toggles: Record<string, boolean>) => void
+	setLocalCursorRulesToggles: (toggles: Record<string, boolean>) => void
+	setLocalWindsurfRulesToggles: (toggles: Record<string, boolean>) => void
+	setLocalAgentsRulesToggles: (toggles: Record<string, boolean>) => void
+	setLocalWorkflowToggles: (toggles: Record<string, boolean>) => void
+	setGlobalWorkflowToggles: (toggles: Record<string, boolean>) => void
+	setGlobalSkillsToggles: (toggles: Record<string, boolean>) => void
+	setLocalSkillsToggles: (toggles: Record<string, boolean>) => void
+	setRemoteRulesToggles: (toggles: Record<string, boolean>) => void
+	setRemoteWorkflowToggles: (toggles: Record<string, boolean>) => void
+	setTotalTasksSize: (value: number | null) => void
+	setExpandTaskHeader: (value: boolean) => void
+	setShowWelcome: (value: boolean) => void
+	setOnboardingModels: (value: OnboardingModelGroup | undefined) => void
+	startProviderModelsRequest: (providerId: ProviderId, requestId: string) => void
+	applyProviderModelsResponse: (response: ProviderModelsResponse) => void
+
+	// Refresh functions
+	refreshOpenRouterModels: () => void
+	refreshVercelAiGatewayModels: () => void
+	refreshHicapModels: () => void
+	refreshLiteLlmModels: () => Promise<void>
+	setUserInfo: (userInfo?: UserInfo) => void
+
+	// Navigation state setters
+	setShowMarketplace: (value: boolean) => void
+	setShowMcp: (value: boolean) => void
+	setMcpTab: (tab?: McpViewTab) => void
+
+	// Navigation functions
+	navigateToMarketplace: () => void
+	navigateToMcp: (tab?: McpViewTab) => void
+	navigateToSettings: (targetSection?: string) => void
+	navigateToSettingsModelPicker: (opts: { targetSection?: string; initialModelTab?: "recommended" | "free" }) => void
+	navigateToHistory: () => void
+	navigateToAccount: () => void
+	navigateToWorktrees: () => void
+	navigateToChat: () => void
+
+	// Hide functions
+	hideSettings: () => void
+	hideHistory: () => void
+	hideAccount: () => void
+	hideWorktrees: () => void
+	hideAnnouncement: () => void
+	closeMarketplaceView: () => void
+	closeMcpView: () => void
+
+	// Event callbacks
+	onRelinquishControl: (callback: () => void) => () => void
+}
+
+export const ExtensionStateContext = createContext<ExtensionStateContextType | undefined>(undefined)
+
+export const ExtensionStateContextProvider: React.FC<{
+	children: React.ReactNode
+}> = ({ children }) => {
+	// UI view state
+	const [showMarketplace, setShowMarketplace] = useState(false)
+	const [showMcp, setShowMcp] = useState(false)
+	const [mcpTab, setMcpTab] = useState<McpViewTab | undefined>(undefined)
+	const [showSettings, setShowSettings] = useState(false)
+	const [settingsTargetSection, setSettingsTargetSection] = useState<string | undefined>(undefined)
+	const [settingsInitialModelTab, setSettingsInitialModelTab] = useState<"recommended" | "free" | undefined>(undefined)
+	const [showHistory, setShowHistory] = useState(false)
+	const [showAccount, setShowAccount] = useState(false)
+	const [showWorktrees, setShowWorktrees] = useState(false)
+	const [showAnnouncement, setShowAnnouncement] = useState(false)
+
+	// Helper for MCP view
+	const closeMcpView = useCallback(() => {
+		setShowMcp(false)
+		setMcpTab(undefined)
+	}, [setShowMcp, setMcpTab])
+	const closeMarketplaceView = useCallback(() => {
+		setShowMarketplace(false)
+	}, [])
+
+	// Hide functions
+	const hideSettings = useCallback(() => {
+		setShowSettings(false)
+		setSettingsTargetSection(undefined)
+		setSettingsInitialModelTab(undefined)
+	}, [])
+	const hideHistory = useCallback(() => setShowHistory(false), [setShowHistory])
+	const hideAccount = useCallback(() => setShowAccount(false), [setShowAccount])
+	const hideWorktrees = useCallback(() => setShowWorktrees(false), [setShowWorktrees])
+	const hideAnnouncement = useCallback(() => setShowAnnouncement(false), [setShowAnnouncement])
+
+	// Navigation functions
+	const navigateToMcp = useCallback(
+		(tab?: McpViewTab) => {
+			setShowSettings(false)
+			setShowHistory(false)
+			setShowAccount(false)
+			setShowWorktrees(false)
+			closeMcpView()
+			if (tab) {
+				setMcpTab(tab)
+			}
+			setShowMarketplace(true)
+		},
+		[closeMcpView, setMcpTab, setShowSettings, setShowHistory, setShowAccount, setShowWorktrees],
+	)
+
+	const navigateToMarketplace = useCallback(() => {
+		setShowSettings(false)
+		closeMcpView()
+		setShowHistory(false)
+		setShowAccount(false)
+		setShowWorktrees(false)
+		setShowMarketplace(true)
+	}, [closeMcpView])
+
+	const navigateToSettings = useCallback(
+		(targetSection?: string) => {
+			closeMarketplaceView()
+			setShowHistory(false)
+			closeMcpView()
+			setShowAccount(false)
+			setShowWorktrees(false)
+			setSettingsTargetSection(targetSection)
+			setSettingsInitialModelTab(undefined)
+			setShowSettings(true)
+		},
+		[closeMarketplaceView, closeMcpView],
+	)
+
+	const navigateToSettingsModelPicker = useCallback(
+		(opts: { targetSection?: string; initialModelTab?: "recommended" | "free" }) => {
+			closeMarketplaceView()
+			setShowHistory(false)
+			closeMcpView()
+			setShowAccount(false)
+			setShowWorktrees(false)
+			setSettingsTargetSection(opts.targetSection)
+			setSettingsInitialModelTab(opts.initialModelTab)
+			setShowSettings(true)
+		},
+		[closeMarketplaceView, closeMcpView],
+	)
+
+	const navigateToHistory = useCallback(() => {
+		closeMarketplaceView()
+		setShowSettings(false)
+		closeMcpView()
+		setShowAccount(false)
+		setShowWorktrees(false)
+		setShowHistory(true)
+	}, [closeMarketplaceView, setShowSettings, closeMcpView, setShowAccount, setShowWorktrees, setShowHistory])
+
+	const navigateToAccount = useCallback(() => {
+		closeMarketplaceView()
+		setShowSettings(false)
+		closeMcpView()
+		setShowHistory(false)
+		setShowWorktrees(false)
+		setShowAccount(true)
+	}, [closeMarketplaceView, setShowSettings, closeMcpView, setShowHistory, setShowWorktrees, setShowAccount])
+
+	const navigateToWorktrees = useCallback(() => {
+		closeMarketplaceView()
+		setShowSettings(false)
+		closeMcpView()
+		setShowHistory(false)
+		setShowAccount(false)
+		setShowWorktrees(true)
+	}, [closeMarketplaceView, setShowSettings, closeMcpView, setShowHistory, setShowAccount, setShowWorktrees])
+
+	const navigateToChat = useCallback(() => {
+		closeMarketplaceView()
+		setShowSettings(false)
+		closeMcpView()
+		setShowHistory(false)
+		setShowAccount(false)
+		setShowWorktrees(false)
+	}, [closeMarketplaceView, setShowSettings, closeMcpView, setShowHistory, setShowAccount, setShowWorktrees])
+
+	const [state, setState] = useState<ExtensionState>({
+		version: "",
+		clineMessages: [],
+		queuedPrompts: [],
+		taskHistory: [],
+		shouldShowAnnouncement: false,
+		autoApprovalSettings: DEFAULT_AUTO_APPROVAL_SETTINGS,
+		browserSettings: DEFAULT_BROWSER_SETTINGS,
+		preferredLanguage: "English",
+		mode: "act",
+		platform: DEFAULT_PLATFORM,
+		environment: Environment.production,
+		telemetrySetting: "unset",
+		distinctId: "",
+		planActSeparateModelsSetting: true,
+		enableCheckpointsSetting: true,
+		mcpDisplayMode: DEFAULT_MCP_DISPLAY_MODE,
+		globalClineRulesToggles: {},
+		localClineRulesToggles: {},
+		localCursorRulesToggles: {},
+		localWindsurfRulesToggles: {},
+		localAgentsRulesToggles: {},
+		localWorkflowToggles: {},
+		globalWorkflowToggles: {},
+		shellIntegrationTimeout: 4000,
+		terminalReuseEnabled: true,
+		vscodeTerminalExecutionMode: "vscodeTerminal",
+		maxConsecutiveMistakes: 3,
+		defaultTerminalProfile: "default",
+		isNewUser: false,
+		welcomeViewCompleted: false,
+		onboardingModels: undefined,
+		mcpResponsesCollapsed: false, // Default value (expanded), will be overwritten by extension state
+		yoloModeToggled: false,
+		customPrompt: undefined,
+		useAutoCondense: false,
+		compactionStrategy: "basic",
+		subagentsEnabled: false,
+		worktreesEnabled: { user: true, featureFlag: false },
+		favoritedModelIds: [],
+		lastDismissedInfoBannerVersion: 0,
+		lastDismissedModelBannerVersion: 0,
+		optOutOfRemoteConfig: false,
+		remoteConfigSettings: {},
+		backgroundCommandRunning: false,
+		backgroundCommandTaskId: undefined,
+		lastDismissedCliBannerVersion: 0,
+		backgroundEditEnabled: false,
+		showFeatureTips: true,
+		globalSkillsToggles: {},
+		localSkillsToggles: {},
+
+		// NEW: Add workspace information with defaults
+		workspaceRoots: [],
+		primaryRootIndex: 0,
+		isMultiRootWorkspace: false,
+		multiRootSetting: { user: false, featureFlag: false },
+		hooksEnabled: false,
+	})
+	const [expandTaskHeader, setExpandTaskHeader] = useState(true)
+	const [didHydrateState, setDidHydrateState] = useState(false)
+
+	const [showWelcome, setShowWelcome] = useState(false)
+	const [onboardingModels, setOnboardingModels] = useState<OnboardingModelGroup | undefined>(undefined)
+
+	const [openRouterModels, setOpenRouterModels] = useState<Record<string, ModelInfo>>({
+		[openRouterDefaultModelId]: openRouterDefaultModelInfo,
+	})
+	const [vercelAiGatewayModels, setVercelAiGatewayModels] = useState<Record<string, ModelInfo>>({})
+	const [hicapModels, setHicapModels] = useState<Record<string, ModelInfo>>({})
+	const [liteLlmModels, setLiteLlmModels] = useState<Record<string, ModelInfo>>({})
+	const [totalTasksSize, setTotalTasksSize] = useState<number | null>(null)
+	const [availableTerminalProfiles, setAvailableTerminalProfiles] = useState<TerminalProfile[]>([])
+
+	const [openAiModels, _setOpenAiModels] = useState<string[]>([])
+	const [requestyModels, setRequestyModels] = useState<Record<string, ModelInfo>>({
+		[requestyDefaultModelId]: requestyDefaultModelInfo,
+	})
+	// Groq and Baseten model lists start empty. The pickers populate them
+	// from two sources: the SDK catalog over gRPC (`useProviderModels`)
+	// for the curated set, and the host-side refresh RPCs
+	// (`ModelsServiceClient.refreshGroqModelsRpc`,
+	// `ModelsServiceClient.refreshBasetenModels`) for any models the
+	// live API exposes on top of the SDK catalog.
+	const [groqModelsState, setGroqModels] = useState<Record<string, ModelInfo>>({})
+	const [basetenModelsState, setBasetenModels] = useState<Record<string, ModelInfo>>({})
+	const [huggingFaceModels, setHuggingFaceModels] = useState<Record<string, ModelInfo>>({})
+	const [providerModelsByProvider, setProviderModelsByProvider] = useState<Partial<Record<ProviderId, ProviderModelsState>>>({})
+	const [latestModelRequestIdByProvider, setLatestModelRequestIdByProvider] = useState<Partial<Record<ProviderId, string>>>({})
+	const latestModelRequestIdByProviderRef = useRef<Partial<Record<ProviderId, string>>>({})
+	const [mcpServers, setMcpServers] = useState<McpServer[]>([])
+
+	const startProviderModelsRequest = useCallback((providerId: ProviderId, requestId: string) => {
+		latestModelRequestIdByProviderRef.current = { ...latestModelRequestIdByProviderRef.current, [providerId]: requestId }
+		setLatestModelRequestIdByProvider((prev) => ({ ...prev, [providerId]: requestId }))
+		setProviderModelsByProvider((prev) => ({
+			...prev,
+			[providerId]: {
+				...(prev[providerId] ?? {
+					providerId,
+					models: {},
+					defaultModelId: "",
+					configFingerprint: "",
+					fetchedAt: 0,
+					isStale: false,
+				}),
+				providerId,
+				requestId,
+				isLoading: true,
+				error: undefined,
+			},
+		}))
+	}, [])
+
+	const applyProviderModelsResponse = useCallback((response: ProviderModelsResponse) => {
+		setProviderModelsByProvider((prevModels) => {
+			const latestRequestId = latestModelRequestIdByProviderRef.current[response.providerId]
+			if (latestRequestId !== response.requestId) {
+				console.debug("Dropping stale provider models response", {
+					providerId: response.providerId,
+					requestId: response.requestId,
+					latestRequestId,
+				})
+				return prevModels
+			}
+
+			return {
+				...prevModels,
+				[response.providerId]: {
+					providerId: response.providerId,
+					models: response.ok ? fromProtobufModels(response.models) : {},
+					defaultModelId: response.defaultModelId ?? "",
+					configFingerprint: response.configFingerprint,
+					requestId: response.requestId,
+					source: response.source,
+					fetchedAt: response.fetchedAt,
+					isLoading: false,
+					isStale: false,
+					error: response.ok ? undefined : response.error?.message,
+				},
+			}
+		})
+	}, [])
+
+	// References to store subscription cancellation functions
+	const stateSubscriptionRef = useRef<(() => void) | null>(null)
+
+	const marketplaceButtonUnsubscribeRef = useRef<(() => void) | null>(null)
+	const mcpButtonUnsubscribeRef = useRef<(() => void) | null>(null)
+	const historyButtonClickedSubscriptionRef = useRef<(() => void) | null>(null)
+	const chatButtonUnsubscribeRef = useRef<(() => void) | null>(null)
+	const accountButtonClickedSubscriptionRef = useRef<(() => void) | null>(null)
+	const settingsButtonClickedSubscriptionRef = useRef<(() => void) | null>(null)
+	const worktreesButtonClickedSubscriptionRef = useRef<(() => void) | null>(null)
+	const partialMessageUnsubscribeRef = useRef<(() => void) | null>(null)
+	const openRouterModelsUnsubscribeRef = useRef<(() => void) | null>(null)
+	const liteLlmModelsUnsubscribeRef = useRef<(() => void) | null>(null)
+	const workspaceUpdatesUnsubscribeRef = useRef<(() => void) | null>(null)
+	const relinquishControlUnsubscribeRef = useRef<(() => void) | null>(null)
+
+	// Add ref for callbacks
+	const relinquishControlCallbacks = useRef<Set<() => void>>(new Set())
+
+	// Create hook function
+	const onRelinquishControl = useCallback((callback: () => void) => {
+		relinquishControlCallbacks.current.add(callback)
+		return () => {
+			relinquishControlCallbacks.current.delete(callback)
+		}
+	}, [])
+	const mcpServersSubscriptionRef = useRef<(() => void) | null>(null)
+	// Convergent-replica state for clineMessages. The partial-message stream and the full state
+	// snapshots both feed this reducer so the transcript converges correctly regardless of
+	// arrival order, duplication, or loss. See messageReducer.ts.
+	const replicaRef = useRef<ReplicaState>(createReplicaState())
+
+	// Subscribe to state updates and UI events using the gRPC streaming API
+	useEffect(() => {
+		// Set up state subscription
+		stateSubscriptionRef.current = StateServiceClient.subscribeToState(EmptyRequest.create({}), {
+			onResponse: (response: any) => {
+				if (response.stateJson) {
+					try {
+						const stateData = JSON.parse(response.stateJson) as ExtensionState
+						setState((prevState) => {
+							// Versioning logic for autoApprovalSettings
+							const incomingVersion = stateData.autoApprovalSettings?.version ?? 1
+							const currentVersion = prevState.autoApprovalSettings?.version ?? 1
+							const shouldUpdateAutoApproval = incomingVersion > currentVersion
+
+							// Route the snapshot's transcript through the convergent-replica reducer:
+							// merge by ts/seq within the same epoch (never truncate), replace on a
+							// newer epoch, ignore stale/older snapshots. Unstamped (classic/legacy)
+							// state defaults to epoch 0 / version 0, which merges.
+							replicaRef.current = reducerApplyStateSnapshot(
+								replicaRef.current,
+								stateData.clineMessages ?? [],
+								stateData.epoch ?? 0,
+								stateData.stateVersion ?? 0,
+								stateData.turnState,
+							)
+							stateData.clineMessages = replicaRef.current.messages
+							// Use the seq-gated turnState from the replica, NOT the raw snapshot's, so a
+							// late/stale snapshot carrying an older phase (e.g. "idle") cannot revert a
+							// newer phase (e.g. "streaming") and hide the Cancel button. Falls back to
+							// undefined for classic/legacy state.
+							stateData.turnState = replicaRef.current.turnState
+
+							const newState = {
+								...stateData,
+								autoApprovalSettings: shouldUpdateAutoApproval
+									? stateData.autoApprovalSettings
+									: prevState.autoApprovalSettings,
+							}
+
+							// Update welcome screen state based on API configuration if welcome view not in progress
+							if (!newState.welcomeViewCompleted && !showWelcome) {
+								setShowWelcome(true)
+								setOnboardingModels(newState.onboardingModels)
+							} else if (newState.welcomeViewCompleted) {
+								setShowWelcome(false)
+								setOnboardingModels(undefined)
+							}
+
+							setDidHydrateState(true)
+
+							return newState
+						})
+					} catch (error) {
+						console.error("Error parsing state JSON:", error)
+						console.log("[DEBUG] ERR getting state", error)
+					}
+				}
+				console.log('[DEBUG] ended "got subscribed state"')
+			},
+			onError: (error: any) => {
+				console.error("Error in state subscription:", error)
+			},
+			onComplete: () => {
+				console.log("State subscription completed")
+			},
+		})
+
+		// Subscribe to MCP button clicked events with webview type
+		mcpButtonUnsubscribeRef.current = UiServiceClient.subscribeToMcpButtonClicked(
+			{},
+			{
+				onResponse: () => {
+					console.log("[DEBUG] Received mcpButtonClicked event from gRPC stream")
+					navigateToMarketplace()
+				},
+				onError: (error: any) => {
+					console.error("Error in mcpButtonClicked subscription:", error)
+				},
+				onComplete: () => {
+					console.log("mcpButtonClicked subscription completed")
+				},
+			},
+		)
+
+		marketplaceButtonUnsubscribeRef.current = UiServiceClient.subscribeToMarketplaceButtonClicked(EmptyRequest.create({}), {
+			onResponse: () => {
+				console.log("[DEBUG] Received marketplaceButtonClicked event from gRPC stream")
+				navigateToMarketplace()
+			},
+			onError: (error: any) => {
+				console.error("Error in marketplaceButtonClicked subscription:", error)
+			},
+			onComplete: () => {
+				console.log("marketplaceButtonClicked subscription completed")
+			},
+		})
+
+		// Set up history button clicked subscription with webview type
+		historyButtonClickedSubscriptionRef.current = UiServiceClient.subscribeToHistoryButtonClicked(
+			{},
+			{
+				onResponse: () => {
+					// When history button is clicked, navigate to history view
+					console.log("[DEBUG] Received history button clicked event from gRPC stream")
+					navigateToHistory()
+				},
+				onError: (error: any) => {
+					console.error("Error in history button clicked subscription:", error)
+				},
+				onComplete: () => {
+					console.log("History button clicked subscription completed")
+				},
+			},
+		)
+
+		// Subscribe to chat button clicked events with webview type
+		chatButtonUnsubscribeRef.current = UiServiceClient.subscribeToChatButtonClicked(
+			{},
+			{
+				onResponse: () => {
+					// When chat button is clicked, navigate to chat
+					console.log("[DEBUG] Received chat button clicked event from gRPC stream")
+					navigateToChat()
+				},
+				onError: (error: any) => {
+					console.error("Error in chat button subscription:", error)
+				},
+				onComplete: () => {},
+			},
+		)
+
+		// Subscribe to MCP servers updates
+		mcpServersSubscriptionRef.current = McpServiceClient.subscribeToMcpServers(EmptyRequest.create(), {
+			onResponse: (response: any) => {
+				console.log("[DEBUG] Received MCP servers update from gRPC stream")
+				if (response.mcpServers) {
+					setMcpServers(convertProtoMcpServersToMcpServers(response.mcpServers))
+				}
+			},
+			onError: (error: any) => {
+				console.error("Error in MCP servers subscription:", error)
+			},
+			onComplete: () => {
+				console.log("MCP servers subscription completed")
+			},
+		})
+
+		// Set up settings button clicked subscription
+		settingsButtonClickedSubscriptionRef.current = UiServiceClient.subscribeToSettingsButtonClicked(EmptyRequest.create({}), {
+			onResponse: () => {
+				// When settings button is clicked, navigate to settings
+				navigateToSettings()
+			},
+			onError: (error: any) => {
+				console.error("Error in settings button clicked subscription:", error)
+			},
+			onComplete: () => {
+				console.log("Settings button clicked subscription completed")
+			},
+		})
+
+		// Set up worktrees button clicked subscription
+		worktreesButtonClickedSubscriptionRef.current = UiServiceClient.subscribeToWorktreesButtonClicked(
+			EmptyRequest.create({}),
+			{
+				onResponse: () => {
+					// When worktrees button is clicked, navigate to worktrees
+					navigateToWorktrees()
+				},
+				onError: (error: any) => {
+					console.error("Error in worktrees button clicked subscription:", error)
+				},
+				onComplete: () => {
+					console.log("Worktrees button clicked subscription completed")
+				},
+			},
+		)
+
+		// Subscribe to partial message events
+		partialMessageUnsubscribeRef.current = UiServiceClient.subscribeToPartialMessage(EmptyRequest.create({}), {
+			onResponse: (protoMessage: any) => {
+				try {
+					// Validate critical fields
+					if (!protoMessage.ts || protoMessage.ts <= 0) {
+						console.error("Invalid timestamp in partial message:", protoMessage)
+						return
+					}
+
+					const partialMessage = convertProtoToClineMessage(protoMessage)
+					setState((prevState) => {
+						// Route through the convergent-replica reducer: merge by ts keeping the
+						// higher seq, fence stale epochs, never let an out-of-order or duplicate
+						// delivery corrupt the transcript. Unstamped (classic/legacy) messages
+						// default to epoch 0 and merge by ts as before.
+						const before = replicaRef.current
+						replicaRef.current = reducerApplyMessage(before, partialMessage)
+						if (replicaRef.current === before) {
+							// Stale/ignored — no change.
+							return prevState
+						}
+						return { ...prevState, clineMessages: replicaRef.current.messages }
+					})
+				} catch (error) {
+					console.error("Failed to process partial message:", error, protoMessage)
+				}
+			},
+			onError: (error: any) => {
+				console.error("Error in partialMessage subscription:", error)
+			},
+			onComplete: () => {
+				console.log("[DEBUG] partialMessage subscription completed")
+			},
+		})
+
+		// Subscribe to OpenRouter models updates
+		openRouterModelsUnsubscribeRef.current = ModelsServiceClient.subscribeToOpenRouterModels(EmptyRequest.create({}), {
+			onResponse: (response: OpenRouterCompatibleModelInfo) => {
+				const models = fromProtobufModels(response.models)
+				setOpenRouterModels({
+					[openRouterDefaultModelId]: openRouterDefaultModelInfo, // in case the extension sent a model list without the default model
+					...models,
+				})
+			},
+			onError: (error: any) => {
+				console.error("Error in OpenRouter models subscription:", error)
+			},
+			onComplete: () => {
+				console.log("OpenRouter models subscription completed")
+			},
+		})
+
+		// Subscribe to LiteLLM models updates
+		liteLlmModelsUnsubscribeRef.current = ModelsServiceClient.subscribeToLiteLlmModels(EmptyRequest.create({}), {
+			onResponse: (response: OpenRouterCompatibleModelInfo) => {
+				const models = fromProtobufModels(response.models)
+				setLiteLlmModels(models)
+			},
+			onError: (error: any) => {
+				console.error("Error in LiteLLM models subscription:", error)
+			},
+			onComplete: () => {
+				console.log("LiteLLM models subscription completed")
+			},
+		})
+
+		// Initialize webview using gRPC
+		UiServiceClient.initializeWebview(EmptyRequest.create({}))
+			.then(() => {
+				console.log("[DEBUG] Webview initialization completed via gRPC")
+			})
+			.catch((error) => {
+				console.error("Failed to initialize webview via gRPC:", error)
+			})
+
+		// Set up account button clicked subscription
+		accountButtonClickedSubscriptionRef.current = UiServiceClient.subscribeToAccountButtonClicked(EmptyRequest.create(), {
+			onResponse: () => {
+				// When account button is clicked, navigate to account view
+				console.log("[DEBUG] Received account button clicked event from gRPC stream")
+				navigateToAccount()
+			},
+			onError: (error: any) => {
+				console.error("Error in account button clicked subscription:", error)
+			},
+			onComplete: () => {
+				console.log("Account button clicked subscription completed")
+			},
+		})
+
+		// Fetch available terminal profiles on launch
+		StateServiceClient.getAvailableTerminalProfiles(EmptyRequest.create({}))
+			.then((response) => {
+				setAvailableTerminalProfiles(response.profiles)
+			})
+			.catch((error) => {
+				console.error("Failed to fetch available terminal profiles:", error)
+			})
+
+		// Subscribe to relinquish control events
+		relinquishControlUnsubscribeRef.current = UiServiceClient.subscribeToRelinquishControl(EmptyRequest.create({}), {
+			onResponse: () => {
+				// Call all registered callbacks
+				relinquishControlCallbacks.current.forEach((callback) => {
+					callback()
+				})
+			},
+			onError: (error: any) => {
+				console.error("Error in relinquishControl subscription:", error)
+			},
+			onComplete: () => {},
+		})
+
+		// Clean up subscriptions when component unmounts
+		return () => {
+			if (stateSubscriptionRef.current) {
+				stateSubscriptionRef.current()
+				stateSubscriptionRef.current = null
+			}
+			if (mcpButtonUnsubscribeRef.current) {
+				mcpButtonUnsubscribeRef.current()
+				mcpButtonUnsubscribeRef.current = null
+			}
+			if (marketplaceButtonUnsubscribeRef.current) {
+				marketplaceButtonUnsubscribeRef.current()
+				marketplaceButtonUnsubscribeRef.current = null
+			}
+			if (historyButtonClickedSubscriptionRef.current) {
+				historyButtonClickedSubscriptionRef.current()
+				historyButtonClickedSubscriptionRef.current = null
+			}
+			if (chatButtonUnsubscribeRef.current) {
+				chatButtonUnsubscribeRef.current()
+				chatButtonUnsubscribeRef.current = null
+			}
+			if (accountButtonClickedSubscriptionRef.current) {
+				accountButtonClickedSubscriptionRef.current()
+				accountButtonClickedSubscriptionRef.current = null
+			}
+			if (settingsButtonClickedSubscriptionRef.current) {
+				settingsButtonClickedSubscriptionRef.current()
+				settingsButtonClickedSubscriptionRef.current = null
+			}
+			if (worktreesButtonClickedSubscriptionRef.current) {
+				worktreesButtonClickedSubscriptionRef.current()
+				worktreesButtonClickedSubscriptionRef.current = null
+			}
+			if (partialMessageUnsubscribeRef.current) {
+				partialMessageUnsubscribeRef.current()
+				partialMessageUnsubscribeRef.current = null
+			}
+			if (openRouterModelsUnsubscribeRef.current) {
+				openRouterModelsUnsubscribeRef.current()
+				openRouterModelsUnsubscribeRef.current = null
+			}
+			if (liteLlmModelsUnsubscribeRef.current) {
+				liteLlmModelsUnsubscribeRef.current()
+				liteLlmModelsUnsubscribeRef.current = null
+			}
+			if (workspaceUpdatesUnsubscribeRef.current) {
+				workspaceUpdatesUnsubscribeRef.current()
+				workspaceUpdatesUnsubscribeRef.current = null
+			}
+			if (relinquishControlUnsubscribeRef.current) {
+				relinquishControlUnsubscribeRef.current()
+				relinquishControlUnsubscribeRef.current = null
+			}
+			if (mcpServersSubscriptionRef.current) {
+				mcpServersSubscriptionRef.current()
+				mcpServersSubscriptionRef.current = null
+			}
+		}
+	}, [])
+
+	const refreshOpenRouterModels = useCallback(() => {
+		ModelsServiceClient.refreshOpenRouterModelsRpc(EmptyRequest.create({}))
+			.then((response: OpenRouterCompatibleModelInfo) => {
+				const models = fromProtobufModels(response.models)
+				setOpenRouterModels({
+					[openRouterDefaultModelId]: openRouterDefaultModelInfo, // in case the extension sent a model list without the default model
+					...models,
+				})
+			})
+			.catch((error: Error) => console.error("Failed to refresh OpenRouter models:", error))
+	}, [])
+
+	const refreshHicapModels = useCallback(() => {
+		ModelsServiceClient.refreshHicapModels(EmptyRequest.create({}))
+			.then((response: OpenRouterCompatibleModelInfo) => {
+				const models = response.models
+				setHicapModels({
+					...models,
+				})
+			})
+			.catch((error: Error) => console.error("Failed to refresh Hicap models:", error))
+	}, [])
+
+	const refreshLiteLlmModels = useCallback(() => {
+		return ModelsServiceClient.refreshLiteLlmModelsRpc(EmptyRequest.create({}))
+			.then((response: OpenRouterCompatibleModelInfo) => {
+				const models = fromProtobufModels(response.models)
+				setLiteLlmModels(models)
+			})
+			.catch((error: Error) => console.error("Failed to refresh LiteLLM models:", error))
+	}, [])
+
+	const refreshBasetenModels = useCallback(() => {
+		ModelsServiceClient.refreshBasetenModelsRpc(EmptyRequest.create({}))
+			.then((response) => {
+				// Live-fetched Baseten models. The SDK-curated catalog is
+				// pulled separately by BasetenModelPicker via
+				// `useProviderModels("baseten")` and merged on top of this
+				// dynamic slice at render time.
+				setBasetenModels(fromProtobufModels(response.models))
+			})
+			.catch((err) => console.error("Failed to refresh Baseten models:", err))
+	}, [])
+
+	const refreshVercelAiGatewayModels = useCallback(() => {
+		ModelsServiceClient.refreshVercelAiGatewayModelsRpc(EmptyRequest.create({}))
+			.then((response: OpenRouterCompatibleModelInfo) => {
+				const models = fromProtobufModels(response.models)
+				setVercelAiGatewayModels(models)
+			})
+			.catch((error: Error) => console.error("Failed to refresh Vercel AI Gateway models:", error))
+	}, [])
+
+	// Auto-refresh model lists on API key availability
+	useEffect(() => {
+		if (!openRouterModels || Object.keys(openRouterModels).length <= 1) {
+			refreshOpenRouterModels()
+		}
+		if (!vercelAiGatewayModels || Object.keys(vercelAiGatewayModels).length === 0) {
+			refreshVercelAiGatewayModels()
+		}
+		if (state.apiConfiguration?.basetenApiKey) {
+			refreshBasetenModels()
+		}
+		if (state.apiConfiguration?.liteLlmApiKey) {
+			refreshLiteLlmModels()
+		}
+	}, [
+		refreshOpenRouterModels,
+		refreshVercelAiGatewayModels,
+		state?.apiConfiguration?.basetenApiKey,
+		refreshBasetenModels,
+		state?.apiConfiguration?.liteLlmApiKey,
+		refreshLiteLlmModels,
+	])
+
+	const contextValue: ExtensionStateContextType = {
+		...state,
+		didHydrateState,
+		showWelcome,
+		onboardingModels,
+		openRouterModels,
+		vercelAiGatewayModels,
+		hicapModels,
+		liteLlmModels,
+		openAiModels,
+		requestyModels,
+		groqModels: groqModelsState,
+		basetenModels: basetenModelsState,
+		huggingFaceModels,
+		providerModelsByProvider,
+		latestModelRequestIdByProvider,
+		mcpServers,
+		totalTasksSize,
+		availableTerminalProfiles,
+		showMarketplace,
+		showMcp,
+		mcpTab,
+		showSettings,
+		settingsTargetSection,
+		settingsInitialModelTab,
+		showHistory,
+		showAccount,
+		showWorktrees,
+		showAnnouncement,
+		globalClineRulesToggles: state.globalClineRulesToggles || {},
+		localClineRulesToggles: state.localClineRulesToggles || {},
+		localCursorRulesToggles: state.localCursorRulesToggles || {},
+		localWindsurfRulesToggles: state.localWindsurfRulesToggles || {},
+		localAgentsRulesToggles: state.localAgentsRulesToggles || {},
+		localWorkflowToggles: state.localWorkflowToggles || {},
+		globalWorkflowToggles: state.globalWorkflowToggles || {},
+		remoteRulesToggles: state.remoteRulesToggles || {},
+		remoteWorkflowToggles: state.remoteWorkflowToggles || {},
+		enableCheckpointsSetting: state.enableCheckpointsSetting,
+
+		// Navigation functions
+		navigateToMarketplace,
+		navigateToMcp,
+		navigateToSettings,
+		navigateToSettingsModelPicker,
+		navigateToHistory,
+		navigateToAccount,
+		navigateToWorktrees,
+		navigateToChat,
+
+		// Hide functions
+		hideSettings,
+		hideHistory,
+		hideAccount,
+		hideWorktrees,
+		hideAnnouncement,
+		closeMarketplaceView,
+		setShowAnnouncement,
+		setShowWelcome,
+		setOnboardingModels,
+		startProviderModelsRequest,
+		applyProviderModelsResponse,
+		setShouldShowAnnouncement: (value) =>
+			setState((prevState) => ({
+				...prevState,
+				shouldShowAnnouncement: value,
+			})),
+		setMcpServers,
+		setRequestyModels,
+		setGroqModels,
+		setBasetenModels,
+		setHuggingFaceModels,
+		setShowMarketplace,
+		setShowMcp,
+		closeMcpView,
+		setGlobalClineRulesToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				globalClineRulesToggles: toggles,
+			})),
+		setLocalClineRulesToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				localClineRulesToggles: toggles,
+			})),
+		setLocalCursorRulesToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				localCursorRulesToggles: toggles,
+			})),
+		setLocalWindsurfRulesToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				localWindsurfRulesToggles: toggles,
+			})),
+		setLocalAgentsRulesToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				localAgentsRulesToggles: toggles,
+			})),
+		setLocalWorkflowToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				localWorkflowToggles: toggles,
+			})),
+		setGlobalWorkflowToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				globalWorkflowToggles: toggles,
+			})),
+		setGlobalSkillsToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				globalSkillsToggles: toggles,
+			})),
+		setLocalSkillsToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				localSkillsToggles: toggles,
+			})),
+		setRemoteRulesToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				remoteRulesToggles: toggles,
+			})),
+		setRemoteWorkflowToggles: (toggles) =>
+			setState((prevState) => ({
+				...prevState,
+				remoteWorkflowToggles: toggles,
+			})),
+		setMcpTab,
+		setTotalTasksSize,
+		refreshOpenRouterModels,
+		refreshVercelAiGatewayModels,
+		refreshHicapModels,
+		refreshLiteLlmModels,
+		onRelinquishControl,
+		setUserInfo: (userInfo?: UserInfo) => setState((prevState) => ({ ...prevState, userInfo })),
+		expandTaskHeader,
+		setExpandTaskHeader,
+	}
+
+	return <ExtensionStateContext.Provider value={contextValue}>{children}</ExtensionStateContext.Provider>
+}
+
+export const useExtensionState = () => {
+	const context = useContext(ExtensionStateContext)
+	if (context === undefined) {
+		throw new Error("useExtensionState must be used within an ExtensionStateContextProvider")
+	}
+	return context
+}
diff --git a/apps/vscode/webview-ui/src/context/PlatformContext.tsx b/apps/vscode/webview-ui/src/context/PlatformContext.tsx
new file mode 100644
index 0000000..d1bc76a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/context/PlatformContext.tsx
@@ -0,0 +1,16 @@
+import React, { createContext, useContext } from "react"
+import type { PlatformConfig } from "../config/platform.config"
+import { PLATFORM_CONFIG } from "../config/platform.config"
+
+const PlatformContext = createContext<PlatformConfig>(PLATFORM_CONFIG)
+
+export const PlatformProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+	return <PlatformContext.Provider value={PLATFORM_CONFIG}>{children}</PlatformContext.Provider>
+}
+
+export const usePlatform = () => {
+	return useContext(PlatformContext)
+}
+
+// Optional convenience hooks for individual config values
+export const useShowNavbar = () => usePlatform().showNavbar
diff --git a/apps/vscode/webview-ui/src/hooks/useAutoApproveActions.ts b/apps/vscode/webview-ui/src/hooks/useAutoApproveActions.ts
new file mode 100644
index 0000000..bbd7920
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useAutoApproveActions.ts
@@ -0,0 +1,75 @@
+import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
+import { useCallback } from "react"
+import { updateAutoApproveSettings } from "@/components/chat/auto-approve-menu/AutoApproveSettingsAPI"
+import { ActionMetadata } from "@/components/chat/auto-approve-menu/types"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+
+export function useAutoApproveActions() {
+	const { autoApprovalSettings } = useExtensionState()
+
+	// Check if action is enabled
+	const isChecked = useCallback(
+		(action: ActionMetadata): boolean => {
+			switch (action.id) {
+				case "enableNotifications":
+					return autoApprovalSettings.enableNotifications
+				default:
+					return autoApprovalSettings.actions[action.id] ?? false
+			}
+		},
+		[autoApprovalSettings],
+	)
+
+	// Update action state
+	const updateAction = useCallback(
+		async (action: ActionMetadata, value: boolean) => {
+			const actionId = action.id
+			const subActionId = action.subAction?.id
+
+			if (actionId === "enableNotifications" || subActionId === "enableNotifications") {
+				await updateNotifications(action, value)
+				return
+			}
+
+			const newActions = {
+				...autoApprovalSettings.actions,
+				[actionId]: value,
+			}
+
+			if (value === false && subActionId) {
+				newActions[subActionId] = false
+			}
+
+			if (value === true && action.parentActionId) {
+				newActions[action.parentActionId as keyof AutoApprovalSettings["actions"]] = true
+			}
+
+			await updateAutoApproveSettings({
+				...autoApprovalSettings,
+				version: (autoApprovalSettings.version ?? 1) + 1,
+				actions: newActions,
+			})
+		},
+		[autoApprovalSettings],
+	)
+
+	// Update notifications setting
+	const updateNotifications = useCallback(
+		async (action: ActionMetadata, checked: boolean) => {
+			if (action.id === "enableNotifications") {
+				await updateAutoApproveSettings({
+					...autoApprovalSettings,
+					version: (autoApprovalSettings.version ?? 1) + 1,
+					enableNotifications: checked,
+				})
+			}
+		},
+		[autoApprovalSettings],
+	)
+
+	return {
+		isChecked,
+		updateAction,
+		updateNotifications,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useDynamicProviderSelection.ts b/apps/vscode/webview-ui/src/hooks/useDynamicProviderSelection.ts
new file mode 100644
index 0000000..1195fa4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useDynamicProviderSelection.ts
@@ -0,0 +1,112 @@
+import { type ApiConfiguration, type ModelInfo, openAiModelInfoSafeDefaults, openRouterDefaultModelInfo } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import { useMemo } from "react"
+import { getModeSpecificFields } from "@/components/settings/utils/providerUtils"
+import { useProviderUsageCostDisplay } from "./useProviderUsageCostDisplay"
+
+/**
+ * Reads the `(modelId, modelInfo)` pair that a dynamic-list provider
+ * has committed to its provider-specific slot in `ApiConfiguration`.
+ * Dynamic-list providers (openrouter, cline, openai-compatible, ollama,
+ * lmstudio, requesty, litellm, hicap, groq, baseten, huggingface,
+ * vercel-ai-gateway, aihubmix, oca, huawei-cloud-maas, dify, fireworks,
+ * together, vscode-lm) all store the user's commit in their own
+ * provider-named field instead of the common `apiModelId` plus a shared
+ * catalog. This hook surfaces those fields uniformly so picker
+ * components do not need to know which field stores their model id.
+ *
+ * `hideUsageCost` is sourced from the SDK's
+ * `ProviderListing.usage_cost_display` (see `useProviderUsageCostDisplay`)
+ * so picker components do not hard-code any per-provider knowledge here.
+ *
+ * When a provider has not yet been committed (first-time use), the
+ * hook falls through to safe defaults so the picker UI renders without
+ * undefined-shaped surprises; the real values arrive once the user
+ * selects a model from the live picker.
+ */
+export interface DynamicProviderSelection {
+	selectedModelId: string
+	selectedModelInfo: ModelInfo
+	hideUsageCost: boolean
+}
+
+const FALLBACK_INFO_BY_PROVIDER: Partial<Record<string, ModelInfo>> = {
+	openrouter: openRouterDefaultModelInfo,
+	cline: openRouterDefaultModelInfo,
+	"vercel-ai-gateway": openRouterDefaultModelInfo,
+}
+
+function readFields(apiConfiguration: ApiConfiguration | undefined, mode: Mode) {
+	return getModeSpecificFields(apiConfiguration, mode)
+}
+
+export function useDynamicProviderSelection(
+	providerId: string,
+	apiConfiguration: ApiConfiguration | undefined,
+	mode: Mode,
+): DynamicProviderSelection {
+	const hideUsageCost = useProviderUsageCostDisplay(providerId) === "hide"
+	return useMemo(() => {
+		const fields = readFields(apiConfiguration, mode)
+		const fallbackInfo = FALLBACK_INFO_BY_PROVIDER[providerId] ?? openAiModelInfoSafeDefaults
+
+		const resolve = (id: string | undefined, info: ModelInfo | undefined, defaultId = ""): DynamicProviderSelection => ({
+			selectedModelId: id || defaultId,
+			selectedModelInfo: info ?? fallbackInfo,
+			hideUsageCost,
+		})
+
+		switch (providerId) {
+			case "openrouter":
+				return resolve(fields.openRouterModelId, fields.openRouterModelInfo)
+			case "cline":
+				return resolve(fields.clineModelId, fields.clineModelInfo)
+			case "vercel-ai-gateway":
+				return resolve(fields.vercelAiGatewayModelId, fields.vercelAiGatewayModelInfo)
+			case "openai":
+				return resolve(fields.openAiModelId, fields.openAiModelInfo)
+			case "requesty":
+				return resolve(fields.requestyModelId, fields.requestyModelInfo)
+			case "litellm":
+				return resolve(fields.liteLlmModelId, fields.liteLlmModelInfo)
+			case "groq":
+				return resolve(fields.groqModelId, fields.groqModelInfo)
+			case "baseten":
+				return resolve(fields.basetenModelId, fields.basetenModelInfo)
+			case "huggingface":
+				return resolve(fields.huggingFaceModelId, fields.huggingFaceModelInfo)
+			case "aihubmix":
+				return resolve(fields.aihubmixModelId, fields.aihubmixModelInfo)
+			case "oca":
+				return resolve(fields.ocaModelId, fields.ocaModelInfo)
+			case "huawei-cloud-maas":
+				return resolve(fields.huaweiCloudMaasModelId, fields.huaweiCloudMaasModelInfo)
+			case "hicap":
+				return resolve(fields.hicapModelId, undefined)
+			case "ollama":
+				return resolve(fields.ollamaModelId, undefined)
+			case "lmstudio":
+				return resolve(fields.lmStudioModelId, undefined)
+			case "together":
+				return resolve(fields.togetherModelId, undefined)
+			case "fireworks":
+				return resolve(fields.fireworksModelId, undefined)
+			case "dify":
+				return {
+					selectedModelId: "dify-workflow",
+					selectedModelInfo: fallbackInfo,
+					hideUsageCost,
+				}
+			case "vscode-lm":
+				return {
+					selectedModelId: fields.vsCodeLmModelSelector
+						? `${fields.vsCodeLmModelSelector.vendor}/${fields.vsCodeLmModelSelector.family}`
+						: "",
+					selectedModelInfo: fallbackInfo,
+					hideUsageCost,
+				}
+			default:
+				return resolve(undefined, undefined)
+		}
+	}, [providerId, apiConfiguration, mode, hideUsageCost])
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useFeatureFlag.ts b/apps/vscode/webview-ui/src/hooks/useFeatureFlag.ts
new file mode 100644
index 0000000..9efb44f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useFeatureFlag.ts
@@ -0,0 +1,36 @@
+import posthog from "posthog-js"
+import { useEffect, useState } from "react"
+import { useExtensionState } from "../context/ExtensionStateContext"
+
+/**
+ * Hook to check feature flag status in the webview.
+ *
+ * Feature flags work independently of telemetry settings to ensure extension
+ * functionality can be gated even when telemetry is disabled. In self-hosted
+ * mode, PostHog is not initialized, so feature flags are treated as disabled.
+ */
+export const useHasFeatureFlag = (flagName: string): boolean => {
+	const { environment } = useExtensionState()
+	const isSelfHostedOrUnknown = !environment || environment === "selfHosted"
+	const [flagEnabled, setFlagEnabled] = useState(false)
+
+	useEffect(() => {
+		if (isSelfHostedOrUnknown) {
+			setFlagEnabled(false)
+			return
+		}
+
+		const readFlag = () => {
+			setFlagEnabled(posthog.isFeatureEnabled(flagName) === true)
+		}
+
+		readFlag()
+		return posthog.onFeatureFlags(readFlag)
+	}, [flagName, isSelfHostedOrUnknown])
+
+	if (isSelfHostedOrUnknown) {
+		return false
+	}
+
+	return flagEnabled
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useMenuAnnouncement.ts b/apps/vscode/webview-ui/src/hooks/useMenuAnnouncement.ts
new file mode 100644
index 0000000..2943221
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useMenuAnnouncement.ts
@@ -0,0 +1,80 @@
+import { useEffect, useRef, useState } from "react"
+
+interface UseMenuAnnouncementOptions<T> {
+	/** The list of items in the menu */
+	items: T[]
+	/** The currently selected index */
+	selectedIndex: number
+	/** Function to get the label for an item */
+	getItemLabel: (item: T) => string
+	/** Optional function to check if an item is selectable (default: all items are selectable) */
+	isItemSelectable?: (item: T) => boolean
+}
+
+interface UseMenuAnnouncementResult {
+	/** The current announcement text for screen readers */
+	announcement: string
+}
+
+/**
+ * Hook to manage screen reader announcements for menu components.
+ * Automatically announces the currently selected item when the selection changes.
+ * The announcement is cleared after a short delay to avoid interfering with DOM queries.
+ */
+export function useMenuAnnouncement<T>({
+	items,
+	selectedIndex,
+	getItemLabel,
+	isItemSelectable = () => true,
+}: UseMenuAnnouncementOptions<T>): UseMenuAnnouncementResult {
+	const [announcement, setAnnouncement] = useState("")
+	const clearTimeoutRef = useRef<NodeJS.Timeout | null>(null)
+	const hasNavigatedRef = useRef(false)
+	const previousIndexRef = useRef(selectedIndex)
+
+	// Announce selected item when user navigates (not on initial render)
+	useEffect(() => {
+		// Clear any pending timeout
+		if (clearTimeoutRef.current) {
+			clearTimeout(clearTimeoutRef.current)
+			clearTimeoutRef.current = null
+		}
+
+		// Only announce if user has navigated (index changed from previous value)
+		const hasIndexChanged = previousIndexRef.current !== selectedIndex
+		previousIndexRef.current = selectedIndex
+
+		if (hasIndexChanged) {
+			hasNavigatedRef.current = true
+		}
+
+		// Skip announcement if user hasn't navigated yet (menu just opened)
+		if (!hasNavigatedRef.current) {
+			return
+		}
+
+		if (items.length > 0 && selectedIndex >= 0 && selectedIndex < items.length) {
+			const selectedItem = items[selectedIndex]
+			if (isItemSelectable(selectedItem)) {
+				const label = getItemLabel(selectedItem)
+				setAnnouncement(`${label}, ${selectedIndex + 1} of ${items.length}`)
+
+				// Clear announcement after screen reader has time to read it
+				clearTimeoutRef.current = setTimeout(() => {
+					setAnnouncement("")
+				}, 1000)
+			}
+		}
+
+		return () => {
+			if (clearTimeoutRef.current) {
+				clearTimeout(clearTimeoutRef.current)
+				clearTimeoutRef.current = null
+			}
+		}
+	}, [selectedIndex, items, getItemLabel, isItemSelectable])
+
+	return {
+		announcement,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useNormalizedApiConfiguration.test.ts b/apps/vscode/webview-ui/src/hooks/useNormalizedApiConfiguration.test.ts
new file mode 100644
index 0000000..b400080
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useNormalizedApiConfiguration.test.ts
@@ -0,0 +1,179 @@
+import { ApiFormat, ResolveModelInfoResponse } from "@shared/proto/cline/models"
+import { act, renderHook, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { useNormalizedApiConfiguration } from "./useNormalizedApiConfiguration"
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: vi.fn(),
+}))
+
+vi.mock("@/services/grpc-client", () => ({
+	ModelsServiceClient: {
+		resolveModelInfo: vi.fn(),
+		resolveProviderModels: vi.fn(),
+	},
+}))
+
+const mockUseExtensionState = vi.mocked(useExtensionState)
+const mockResolveModelInfo = vi.mocked(ModelsServiceClient.resolveModelInfo)
+const mockResolveProviderModels = vi.mocked(ModelsServiceClient.resolveProviderModels)
+
+function setApiConfiguration(apiConfiguration: Record<string, unknown>) {
+	mockUseExtensionState.mockReturnValue({ apiConfiguration } as ReturnType<typeof useExtensionState>)
+}
+
+function modelInfoResponse(providerId: string, modelId: string, contextWindow = 1_000_000) {
+	return ResolveModelInfoResponse.create({
+		providerId,
+		modelId,
+		source: "sdk-known-models",
+		modelInfo: {
+			name: "DeepSeek V4 Pro",
+			contextWindow,
+			maxTokens: 384_000,
+			supportsPromptCache: true,
+			supportsReasoning: true,
+			apiFormat: ApiFormat.OPENAI_CHAT,
+		},
+	})
+}
+
+function deepSeekResponse(modelId: string, contextWindow = 1_000_000) {
+	return modelInfoResponse("deepseek", modelId, contextWindow)
+}
+
+describe("useNormalizedApiConfiguration", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		setApiConfiguration({})
+	})
+
+	it("resolves DeepSeek model info through the pure RPC", async () => {
+		setApiConfiguration({ actModeApiProvider: "deepseek", actModeApiModelId: "deepseek-v4-pro" })
+		mockResolveModelInfo.mockResolvedValue(deepSeekResponse("deepseek-v4-pro"))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		expect(result.current.selectedModelInfo.contextWindow).toBeUndefined()
+		await waitFor(() => expect(result.current.selectedModelInfo.contextWindow).toBe(1_000_000))
+		expect(result.current.selectedModelId).toBe("deepseek-v4-pro")
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({ providerId: "deepseek", modelId: "deepseek-v4-pro" })
+		expect(mockResolveProviderModels).not.toHaveBeenCalled()
+	})
+
+	it("does not flash 128K before the DeepSeek RPC resolves", () => {
+		setApiConfiguration({ actModeApiProvider: "deepseek", actModeApiModelId: "deepseek-v4-pro" })
+		mockResolveModelInfo.mockReturnValue(new Promise(() => undefined))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		expect(result.current.selectedModelInfo.contextWindow).toBeUndefined()
+		expect(mockResolveProviderModels).not.toHaveBeenCalled()
+	})
+
+	it("uses the SDK default model info when model id is empty", async () => {
+		setApiConfiguration({ actModeApiProvider: "deepseek", actModeApiModelId: "" })
+		mockResolveModelInfo.mockResolvedValue(deepSeekResponse("deepseek-v4-flash"))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		await waitFor(() => expect(result.current.selectedModelId).toBe("deepseek-v4-flash"))
+		expect(result.current.selectedModelInfo.contextWindow).toBe(1_000_000)
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({ providerId: "deepseek", modelId: undefined })
+		expect(mockResolveProviderModels).not.toHaveBeenCalled()
+	})
+
+	it("uses Cline-specific model fields instead of stale generic or OpenRouter fields", async () => {
+		setApiConfiguration({
+			actModeApiProvider: "cline",
+			actModeApiModelId: "openai/gpt-5.4",
+			actModeOpenRouterModelId: "anthropic/claude-sonnet-4.5",
+			actModeClineModelId: "anthropic/claude-sonnet-4.6",
+		})
+		mockResolveModelInfo.mockResolvedValue(modelInfoResponse("cline", "anthropic/claude-sonnet-4.6"))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		await waitFor(() => expect(result.current.selectedModelId).toBe("anthropic/claude-sonnet-4.6"))
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({ providerId: "cline", modelId: "anthropic/claude-sonnet-4.6" })
+	})
+
+	it("asks the backend for the Cline default when no Cline-specific model is selected", async () => {
+		setApiConfiguration({
+			actModeApiProvider: "cline",
+			actModeApiModelId: "openai/gpt-5.4",
+			actModeOpenRouterModelId: "anthropic/claude-sonnet-4.5",
+		})
+		mockResolveModelInfo.mockResolvedValue(modelInfoResponse("cline", "anthropic/claude-sonnet-4.6"))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		await waitFor(() => expect(result.current.selectedModelId).toBe("anthropic/claude-sonnet-4.6"))
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({ providerId: "cline", modelId: undefined })
+	})
+
+	it("resolves static SDK-backed providers through the model-info RPC", async () => {
+		setApiConfiguration({ actModeApiProvider: "anthropic", actModeApiModelId: "claude-sonnet-4-5-20250929" })
+		mockResolveModelInfo.mockResolvedValue(modelInfoResponse("anthropic", "claude-sonnet-4-5-20250929", 200_000))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		await waitFor(() => expect(result.current.selectedModelInfo.contextWindow).toBe(200_000))
+		expect(result.current.selectedProvider).toBe("anthropic")
+		expect(result.current.selectedModelId).toBe("claude-sonnet-4-5-20250929")
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-5-20250929",
+		})
+		expect(mockResolveProviderModels).not.toHaveBeenCalled()
+	})
+
+	it("uses local provider-specific model fields instead of a stale generic id", async () => {
+		setApiConfiguration({
+			actModeApiProvider: "ollama",
+			actModeApiModelId: "stale-generic-model",
+			actModeOllamaModelId: "llama3.1:8b",
+		})
+		mockResolveModelInfo.mockResolvedValue(modelInfoResponse("ollama", "llama3.1:8b", 32_768))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		await waitFor(() => expect(result.current.selectedModelId).toBe("llama3.1:8b"))
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({ providerId: "ollama", modelId: "llama3.1:8b" })
+	})
+
+	it("uses VS Code LM selector as the active model id", async () => {
+		setApiConfiguration({
+			actModeApiProvider: "vscode-lm",
+			actModeApiModelId: "stale-generic-model",
+			actModeVsCodeLmModelSelector: { vendor: "copilot", family: "claude-sonnet" },
+		})
+		mockResolveModelInfo.mockResolvedValue(modelInfoResponse("vscode-lm", "copilot/claude-sonnet", 128_000))
+
+		const { result } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		await waitFor(() => expect(result.current.selectedModelId).toBe("copilot/claude-sonnet"))
+		expect(mockResolveModelInfo).toHaveBeenCalledWith({ providerId: "vscode-lm", modelId: "copilot/claude-sonnet" })
+	})
+
+	it("ignores stale DeepSeek responses after provider/model changes", async () => {
+		let resolveFirst: (value: ResolveModelInfoResponse) => void = () => undefined
+		mockResolveModelInfo
+			.mockReturnValueOnce(new Promise((resolve) => (resolveFirst = resolve)))
+			.mockResolvedValueOnce(deepSeekResponse("deepseek-v4-flash", 1_000_000))
+		setApiConfiguration({ actModeApiProvider: "deepseek", actModeApiModelId: "deepseek-v4-pro" })
+
+		const { result, rerender } = renderHook(() => useNormalizedApiConfiguration("act"))
+
+		setApiConfiguration({ actModeApiProvider: "deepseek", actModeApiModelId: "deepseek-v4-flash" })
+		rerender()
+		await act(async () => {
+			resolveFirst(deepSeekResponse("deepseek-v4-pro", 500_000))
+		})
+
+		await waitFor(() => expect(result.current.selectedModelId).toBe("deepseek-v4-flash"))
+		expect(result.current.selectedModelInfo.contextWindow).toBe(1_000_000)
+	})
+})
diff --git a/apps/vscode/webview-ui/src/hooks/useNormalizedApiConfiguration.ts b/apps/vscode/webview-ui/src/hooks/useNormalizedApiConfiguration.ts
new file mode 100644
index 0000000..4f96705
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useNormalizedApiConfiguration.ts
@@ -0,0 +1,129 @@
+import type { ApiProvider, ModelInfo } from "@shared/api"
+import { ResolveModelInfoRequest } from "@shared/proto/cline/models"
+import { fromProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import type { Mode } from "@shared/storage/types"
+import { useEffect, useMemo, useState } from "react"
+import { getModeSpecificFields, type NormalizedApiConfig } from "@/components/settings/utils/providerUtils"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+
+/**
+ * Neutral placeholder returned while the catalog has not yet produced a
+ * concrete `ModelInfo`. Callers that gate behavior on capabilities
+ * (TaskHeader cost display, context-window meter, prompt-cache reasoning
+ * surfaces) read these defaults as "we don't know yet" — see the field
+ * comments at consumers.
+ */
+const unknownModelInfo: ModelInfo = {
+	supportsPromptCache: false,
+}
+
+/**
+ * Map a provider id to the `ApiConfiguration.{plan,act}Mode<…>ModelId`
+ * field that stores its selected model id. For dynamic-list providers
+ * (openrouter, openai-compatible, ollama, …) each one maintains its own
+ * per-provider field; static-list providers share the common
+ * `apiModelId` field.
+ *
+ * This mapping mirrors the writers in each provider component / picker
+ * and the schema documented in `@/shared/storage/state-keys.ts`. When
+ * adding a provider that needs its own model-id field, extend the map
+ * here and the corresponding writer.
+ */
+function getActiveProviderAndModelId(apiConfiguration: ReturnType<typeof useExtensionState>["apiConfiguration"], mode: Mode) {
+	const provider = ((mode === "plan" ? apiConfiguration?.planModeApiProvider : apiConfiguration?.actModeApiProvider) ||
+		"anthropic") as ApiProvider
+	const modeFields = getModeSpecificFields(apiConfiguration, mode)
+
+	const providerSpecificModelIds: Partial<Record<string, string | undefined>> = {
+		cline: modeFields.clineModelId,
+		"cline-pass": modeFields.clinePassModelId,
+		deepseek: modeFields.apiModelId,
+		openai: modeFields.openAiModelId,
+		openrouter: modeFields.openRouterModelId,
+		requesty: modeFields.requestyModelId,
+		litellm: modeFields.liteLlmModelId,
+		"vercel-ai-gateway": modeFields.vercelAiGatewayModelId,
+		ollama: modeFields.ollamaModelId,
+		lmstudio: modeFields.lmStudioModelId,
+		groq: modeFields.groqModelId,
+		baseten: modeFields.basetenModelId,
+		huggingface: modeFields.huggingFaceModelId,
+		hicap: modeFields.hicapModelId,
+		aihubmix: modeFields.aihubmixModelId,
+		nousResearch: modeFields.nousResearchModelId,
+		oca: modeFields.ocaModelId,
+		"huawei-cloud-maas": modeFields.huaweiCloudMaasModelId,
+		together: modeFields.togetherModelId,
+		fireworks: modeFields.fireworksModelId,
+		sapaicore: modeFields.apiModelId,
+		"vscode-lm": modeFields.vsCodeLmModelSelector
+			? `${modeFields.vsCodeLmModelSelector.vendor}/${modeFields.vsCodeLmModelSelector.family}`
+			: undefined,
+	}
+
+	return {
+		provider,
+		modelId: Object.hasOwn(providerSpecificModelIds, provider) ? providerSpecificModelIds[provider] : modeFields.apiModelId,
+	}
+}
+
+/**
+ * Webview's universal handle on "what model is currently selected, with
+ * what capabilities". Sources its answer from the extension over gRPC
+ * (`ResolveModelInfo`), which combines the SDK catalog with the user's
+ * committed selection.
+ *
+ * The returned `selectedModelInfo` may be `unknownModelInfo` for a few
+ * render frames while the gRPC call is in flight, especially the first
+ * time a provider is selected after a config change. UI callers must
+ * treat `unknownModelInfo` as "no data yet" — render placeholders, do
+ * not assume features are unsupported.
+ */
+export function useNormalizedApiConfiguration(mode: Mode): NormalizedApiConfig {
+	const { apiConfiguration } = useExtensionState()
+	const { provider, modelId } = getActiveProviderAndModelId(apiConfiguration, mode)
+	const [resolvedInfo, setResolvedInfo] = useState<
+		Awaited<ReturnType<typeof ModelsServiceClient.resolveModelInfo>> | undefined
+	>(undefined)
+
+	useEffect(() => {
+		setResolvedInfo(undefined)
+		let cancelled = false
+		// The host-side handler awaits the catalog on a cache miss, so a
+		// single round-trip yields authoritative data. We do not retry
+		// or warm; if the response is `unknown`, the catalog truly has no
+		// data and the UI renders a placeholder.
+		void ModelsServiceClient.resolveModelInfo(
+			ResolveModelInfoRequest.create({ providerId: provider, modelId: modelId || undefined }),
+		)
+			.then((response) => {
+				if (!cancelled) {
+					setResolvedInfo(response)
+				}
+			})
+			.catch(() => {
+				// The handler does not throw in production paths; a host-side
+				// error here is logged at the gRPC layer. Leave resolvedInfo
+				// undefined so the hook returns the neutral loading state.
+			})
+		return () => {
+			cancelled = true
+		}
+	}, [provider, modelId])
+
+	return useMemo(() => {
+		if (!resolvedInfo || resolvedInfo.source === "unknown" || !resolvedInfo.modelInfo) {
+			return {
+				selectedProvider: provider,
+				selectedModelId: resolvedInfo?.modelId || modelId || "",
+				selectedModelInfo: unknownModelInfo,
+			}
+		}
+		return {
+			selectedProvider: provider,
+			selectedModelId: resolvedInfo.modelId,
+			selectedModelInfo: fromProtobufModelInfo(resolvedInfo.modelInfo),
+		}
+	}, [provider, modelId, resolvedInfo])
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderConfig.test.ts b/apps/vscode/webview-ui/src/hooks/useProviderConfig.test.ts
new file mode 100644
index 0000000..072475b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderConfig.test.ts
@@ -0,0 +1,124 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import { ApiFormat, ProviderConfigResponse } from "@shared/proto/cline/models"
+import { act, renderHook, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { useProviderConfig } from "./useProviderConfig"
+
+vi.mock("@/services/grpc-client", () => ({
+	ModelsServiceClient: {
+		readProviderConfig: vi.fn(),
+		writeProviderConfig: vi.fn(),
+		commitModelSelection: vi.fn(),
+	},
+}))
+
+function config(providerId = "deepseek", baseUrl = "https://api.deepseek.com/v1") {
+	return ProviderConfigResponse.create({
+		providerId,
+		baseUrl,
+		headers: {},
+		apiKeyLength: 0,
+		hasAccessToken: false,
+		hasRefreshToken: false,
+	})
+}
+
+describe("useProviderConfig", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("reads provider config on mount", async () => {
+		vi.mocked(ModelsServiceClient.readProviderConfig).mockResolvedValue(config())
+
+		const { result } = renderHook(() => useProviderConfig("deepseek"))
+
+		await waitFor(() => expect(result.current.config?.providerId).toBe("deepseek"))
+		expect(ModelsServiceClient.readProviderConfig).toHaveBeenCalledWith(StringRequest.create({ value: "deepseek" }))
+	})
+
+	it("write sends a provider config patch and stores returned config", async () => {
+		vi.mocked(ModelsServiceClient.readProviderConfig).mockResolvedValue(config())
+		vi.mocked(ModelsServiceClient.writeProviderConfig).mockResolvedValue(config("deepseek", "https://custom.example/v1"))
+		const { result } = renderHook(() => useProviderConfig("deepseek"))
+		await waitFor(() => expect(result.current.config).toBeDefined())
+
+		await act(async () => {
+			await result.current.write({ baseUrl: "https://custom.example/v1", apiKey: "SECRET_SENTINEL" })
+		})
+
+		expect(ModelsServiceClient.writeProviderConfig).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "deepseek",
+				patch: expect.objectContaining({ baseUrl: "https://custom.example/v1", apiKey: "SECRET_SENTINEL" }),
+			}),
+		)
+		expect(result.current.config?.baseUrl).toBe("https://custom.example/v1")
+	})
+
+	it("commitSelection sends the full selection envelope and refreshes config", async () => {
+		vi.mocked(ModelsServiceClient.readProviderConfig)
+			.mockResolvedValueOnce(config())
+			.mockResolvedValueOnce(
+				ProviderConfigResponse.create({
+					providerId: "deepseek",
+					headers: {},
+					apiKeyLength: 0,
+					hasAccessToken: false,
+					hasRefreshToken: false,
+					actSelection: {
+						providerId: "deepseek",
+						modelId: "deepseek-v4-flash",
+						modelInfo: {
+							name: "DeepSeek V4 Flash",
+							supportsPromptCache: true,
+							apiFormat: ApiFormat.OPENAI_CHAT,
+							tiers: [],
+						},
+					},
+				}),
+			)
+		vi.mocked(ModelsServiceClient.commitModelSelection).mockResolvedValue({})
+		const { result } = renderHook(() => useProviderConfig("deepseek"))
+		await waitFor(() => expect(result.current.config).toBeDefined())
+
+		await act(async () => {
+			await result.current.commitSelection("act", {
+				providerId: "deepseek",
+				modelId: "deepseek-v4-flash",
+				modelInfo: { name: "DeepSeek V4 Flash", supportsPromptCache: true, apiFormat: ApiFormat.OPENAI_CHAT },
+			})
+		})
+
+		expect(ModelsServiceClient.commitModelSelection).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "deepseek",
+				mode: "act",
+				modelId: "deepseek-v4-flash",
+				modelInfo: expect.objectContaining({
+					name: "DeepSeek V4 Flash",
+					supportsPromptCache: true,
+					apiFormat: ApiFormat.OPENAI_CHAT,
+				}),
+			}),
+		)
+		expect(ModelsServiceClient.readProviderConfig).toHaveBeenCalledTimes(2)
+		expect(result.current.config?.actSelection?.modelId).toBe("deepseek-v4-flash")
+	})
+
+	it("commitSelection rejects mismatched provider ids without calling RPC", async () => {
+		vi.mocked(ModelsServiceClient.readProviderConfig).mockResolvedValue(config())
+		const { result } = renderHook(() => useProviderConfig("deepseek"))
+		await waitFor(() => expect(result.current.config).toBeDefined())
+
+		await expect(
+			result.current.commitSelection("act", {
+				providerId: "openrouter",
+				modelId: "deepseek-v4-flash",
+				modelInfo: { supportsPromptCache: true },
+			}),
+		).rejects.toThrow("selection providerId openrouter does not match hook providerId deepseek")
+		expect(ModelsServiceClient.commitModelSelection).not.toHaveBeenCalled()
+	})
+})
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderConfig.ts b/apps/vscode/webview-ui/src/hooks/useProviderConfig.ts
new file mode 100644
index 0000000..a61e0e2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderConfig.ts
@@ -0,0 +1,86 @@
+import { StringRequest } from "@shared/proto/cline/common"
+import {
+	type AwsProviderConfig,
+	CommitModelSelectionRequest,
+	type GcpProviderConfig,
+	type ProviderConfigResponse,
+	WriteProviderConfigPatch,
+	WriteProviderConfigRequest,
+} from "@shared/proto/cline/models"
+import { toProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import { useCallback, useEffect, useState } from "react"
+import type { ProviderId } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import type { ModelInfo } from "../../../src/shared/api"
+
+export type ProviderConfigWritePatch = Partial<Omit<WriteProviderConfigPatch, "headers" | "aws" | "gcp">> & {
+	headers?: Record<string, string>
+	aws?: Partial<AwsProviderConfig>
+	gcp?: Partial<GcpProviderConfig>
+}
+
+export interface ProviderModelSelection {
+	providerId: ProviderId
+	modelId: string
+	modelInfo: ModelInfo
+}
+
+function toWriteProviderConfigPatch(patch: ProviderConfigWritePatch): WriteProviderConfigPatch {
+	const headers = patch.headers ?? {}
+	const shouldClearHeaders = patch.headers !== undefined && Object.keys(headers).length === 0
+
+	return WriteProviderConfigPatch.create({
+		...patch,
+		headers,
+		clearHeaders: shouldClearHeaders || undefined,
+	})
+}
+
+export function useProviderConfig(providerId: ProviderId) {
+	const [config, setConfig] = useState<ProviderConfigResponse | undefined>(undefined)
+
+	const read = useCallback(async () => {
+		const response = await ModelsServiceClient.readProviderConfig(StringRequest.create({ value: providerId }))
+		setConfig(response)
+		return response
+	}, [providerId])
+
+	useEffect(() => {
+		void read()
+	}, [read])
+
+	const write = useCallback(
+		async (patch: ProviderConfigWritePatch) => {
+			const response = await ModelsServiceClient.writeProviderConfig(
+				WriteProviderConfigRequest.create({
+					providerId,
+					patch: toWriteProviderConfigPatch(patch),
+				}),
+			)
+			setConfig(response)
+			return response
+		},
+		[providerId],
+	)
+
+	const commitSelection = useCallback(
+		async (mode: "plan" | "act", selection: ProviderModelSelection) => {
+			if (selection.providerId !== providerId) {
+				throw new Error(`selection providerId ${selection.providerId} does not match hook providerId ${providerId}`)
+			}
+
+			await ModelsServiceClient.commitModelSelection(
+				CommitModelSelectionRequest.create({
+					providerId,
+					mode,
+					modelId: selection.modelId,
+					modelInfo: toProtobufModelInfo(selection.modelInfo),
+				}),
+			)
+			await read()
+		},
+		[providerId, read],
+	)
+
+	return { config, write, commitSelection }
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderListings.ts b/apps/vscode/webview-ui/src/hooks/useProviderListings.ts
new file mode 100644
index 0000000..f40664e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderListings.ts
@@ -0,0 +1,33 @@
+import { Empty } from "@shared/proto/cline/common"
+import type { ProviderListing } from "@shared/proto/cline/models"
+import { useCallback, useEffect, useState } from "react"
+import { ModelsServiceClient } from "@/services/grpc-client"
+
+export function useProviderListings() {
+	const [providers, setProviders] = useState<ProviderListing[]>([])
+	const [isLoading, setIsLoading] = useState(false)
+	const [error, setError] = useState<Error | undefined>(undefined)
+
+	const refresh = useCallback(async () => {
+		setIsLoading(true)
+		setError(undefined)
+		try {
+			const response = await ModelsServiceClient.listProviders(Empty.create())
+			setProviders(response.providers)
+			return response.providers
+		} catch (err) {
+			const normalizedError = err instanceof Error ? err : new Error(String(err))
+			setError(normalizedError)
+			console.error("Failed to list provider catalog entries:", normalizedError)
+			return []
+		} finally {
+			setIsLoading(false)
+		}
+	}, [])
+
+	useEffect(() => {
+		void refresh()
+	}, [refresh])
+
+	return { providers, isLoading, error, refresh }
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderModelSelection.ts b/apps/vscode/webview-ui/src/hooks/useProviderModelSelection.ts
new file mode 100644
index 0000000..16a4d50
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderModelSelection.ts
@@ -0,0 +1,63 @@
+import { type ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+import type { ProviderConfigResponse } from "@shared/proto/cline/models"
+import { fromProtobufModelInfo } from "@shared/proto-conversions/models/typeConversion"
+import type { Mode } from "@shared/storage/types"
+import { useCallback } from "react"
+import type { ProviderId } from "@/context/ExtensionStateContext"
+import type { ProviderModelSelection } from "./useProviderConfig"
+
+interface UseProviderModelSelectionOptions {
+	models: Record<string, ModelInfo>
+	defaultModelId?: string
+	config?: ProviderConfigResponse
+	commitSelection: (mode: "plan" | "act", selection: ProviderModelSelection) => Promise<unknown>
+	fallbackModelInfo?: ModelInfo
+	customModelInfo?: (modelId: string) => ModelInfo
+}
+
+export function useProviderModelSelection(
+	providerId: ProviderId,
+	currentMode: Mode,
+	{
+		models,
+		defaultModelId,
+		config,
+		commitSelection,
+		fallbackModelInfo = openAiModelInfoSafeDefaults,
+		customModelInfo,
+	}: UseProviderModelSelectionOptions,
+) {
+	const committedSelection = currentMode === "plan" ? config?.planSelection : config?.actSelection
+	const fallbackModelId = defaultModelId || Object.keys(models)[0] || ""
+	const selectedModelId = committedSelection?.modelId ?? fallbackModelId
+	const selectedModelInfo = committedSelection?.modelInfo
+		? fromProtobufModelInfo(committedSelection.modelInfo)
+		: (models[selectedModelId] ??
+			(selectedModelId && customModelInfo ? customModelInfo(selectedModelId) : undefined) ??
+			fallbackModelInfo)
+
+	const selectedModel: ProviderModelSelection = {
+		providerId,
+		modelId: selectedModelId,
+		modelInfo: selectedModelInfo,
+	}
+
+	const commitModelSelection = useCallback(
+		(selection: Omit<ProviderModelSelection, "providerId"> | ProviderModelSelection) => {
+			return commitSelection(currentMode, {
+				...selection,
+				providerId,
+			})
+		},
+		[commitSelection, currentMode, providerId],
+	)
+
+	return {
+		committedSelection,
+		fallbackModelId,
+		selectedModel,
+		selectedModelId,
+		selectedModelInfo,
+		commitModelSelection,
+	}
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderModels.test.ts b/apps/vscode/webview-ui/src/hooks/useProviderModels.test.ts
new file mode 100644
index 0000000..bc5817c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderModels.test.ts
@@ -0,0 +1,123 @@
+import type { ProviderModelsResponse } from "@shared/proto/cline/models"
+import { act, renderHook, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+import { useProviderModels } from "./useProviderModels"
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: vi.fn(),
+}))
+
+vi.mock("@/services/grpc-client", () => ({
+	ModelsServiceClient: {
+		resolveProviderModels: vi.fn(),
+	},
+}))
+
+function deferred<T>() {
+	let resolve!: (value: T) => void
+	let reject!: (reason?: unknown) => void
+	const promise = new Promise<T>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+	return { promise, resolve, reject }
+}
+
+function response(requestId: string): ProviderModelsResponse {
+	return {
+		providerId: "deepseek",
+		requestId,
+		configFingerprint: `fingerprint-${requestId}`,
+		fetchedAt: 1,
+		ok: true,
+		models: {},
+		defaultModelId: "deepseek-v4-flash",
+		source: "sdk-dynamic",
+	}
+}
+
+function installFakeProviderModelsContext() {
+	const latestRequestIds: Record<string, string> = {}
+	const applied: ProviderModelsResponse[] = []
+	const startProviderModelsRequest = vi.fn((providerId: string, requestId: string) => {
+		latestRequestIds[providerId] = requestId
+	})
+	const applyProviderModelsResponse = vi.fn((providerResponse: ProviderModelsResponse) => {
+		if (latestRequestIds[providerResponse.providerId] === providerResponse.requestId) {
+			applied.push(providerResponse)
+		}
+	})
+
+	vi.mocked(useExtensionState).mockReturnValue({
+		providerModelsByProvider: {},
+		startProviderModelsRequest,
+		applyProviderModelsResponse,
+	} as ReturnType<typeof useExtensionState>)
+
+	return { applied, startProviderModelsRequest, applyProviderModelsResponse }
+}
+
+describe("useProviderModels", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("applies a matching requestId response", async () => {
+		const context = installFakeProviderModelsContext()
+		vi.mocked(ModelsServiceClient.resolveProviderModels).mockImplementation(async (request) =>
+			response(request.requestId ?? ""),
+		)
+
+		renderHook(() => useProviderModels("deepseek"))
+
+		await waitFor(() => expect(context.applied).toHaveLength(1))
+		const requestId = context.startProviderModelsRequest.mock.calls[0][1]
+		expect(context.startProviderModelsRequest).toHaveBeenCalledWith("deepseek", requestId)
+		expect(ModelsServiceClient.resolveProviderModels).toHaveBeenCalledWith(
+			expect.objectContaining({ providerId: "deepseek", forceRefresh: true, requestId }),
+		)
+		expect(context.applied[0].requestId).toBe(requestId)
+	})
+
+	it("drops a mismatched requestId response through the apply rule", async () => {
+		const context = installFakeProviderModelsContext()
+		vi.mocked(ModelsServiceClient.resolveProviderModels).mockResolvedValue(response("stale-req"))
+
+		renderHook(() => useProviderModels("deepseek"))
+
+		await waitFor(() => expect(context.applyProviderModelsResponse).toHaveBeenCalledTimes(1))
+		expect(context.applied).toHaveLength(0)
+	})
+
+	it("only applies the second of two rapid refresh responses", async () => {
+		const context = installFakeProviderModelsContext()
+		const deferredByRequestId = new Map<string, ReturnType<typeof deferred<ProviderModelsResponse>>>()
+		vi.mocked(ModelsServiceClient.resolveProviderModels).mockImplementation((request) => {
+			const pending = deferred<ProviderModelsResponse>()
+			deferredByRequestId.set(request.requestId ?? "", pending)
+			return pending.promise
+		})
+
+		const { result } = renderHook(() => useProviderModels("deepseek"))
+		await waitFor(() => expect(ModelsServiceClient.resolveProviderModels).toHaveBeenCalledTimes(1))
+		act(() => {
+			void result.current.refresh()
+		})
+		await waitFor(() => expect(ModelsServiceClient.resolveProviderModels).toHaveBeenCalledTimes(2))
+		const latestRequestId = context.startProviderModelsRequest.mock.calls.at(-1)?.[1]
+		expect(latestRequestId).toBeDefined()
+
+		deferredByRequestId.get(latestRequestId ?? "")?.resolve(response(latestRequestId ?? ""))
+		await waitFor(() => expect(context.applied.map((item) => item.requestId)).toEqual([latestRequestId]))
+
+		for (const [requestId, pending] of deferredByRequestId) {
+			if (requestId !== latestRequestId) {
+				pending.resolve(response(requestId))
+			}
+		}
+		await waitFor(() => expect(context.applyProviderModelsResponse).toHaveBeenCalledTimes(deferredByRequestId.size))
+		expect(context.applied.map((item) => item.requestId)).toEqual([latestRequestId])
+	})
+})
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderModels.ts b/apps/vscode/webview-ui/src/hooks/useProviderModels.ts
new file mode 100644
index 0000000..06094a8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderModels.ts
@@ -0,0 +1,60 @@
+import { ResolveProviderModelsRequest } from "@shared/proto/cline/models"
+import { useCallback, useEffect } from "react"
+import { type ProviderId, useExtensionState } from "@/context/ExtensionStateContext"
+import { ModelsServiceClient } from "@/services/grpc-client"
+
+let providerModelRequestCounter = 0
+
+function createRequestId(): string {
+	providerModelRequestCounter += 1
+	return `provider-models-${providerModelRequestCounter}`
+}
+
+/**
+ * Read-only provider model-list hook backed by the unified provider catalog RPC.
+ *
+ * This hook never writes model selection state; selection commits are owned by
+ * useProviderConfig/commitModelSelection.
+ */
+export function useProviderModels(providerId: ProviderId) {
+	const { providerModelsByProvider, startProviderModelsRequest, applyProviderModelsResponse } = useExtensionState()
+	const state = providerModelsByProvider?.[providerId]
+
+	const refresh = useCallback(async () => {
+		const requestId = createRequestId()
+		startProviderModelsRequest(providerId, requestId)
+		try {
+			const response = await ModelsServiceClient.resolveProviderModels(
+				ResolveProviderModelsRequest.create({ providerId, forceRefresh: true, requestId }),
+			)
+			applyProviderModelsResponse(response)
+		} catch (error) {
+			applyProviderModelsResponse({
+				providerId,
+				requestId,
+				configFingerprint: "",
+				fetchedAt: Date.now(),
+				ok: false,
+				models: {},
+				error: {
+					kind: "unknown",
+					message: error instanceof Error ? error.message : String(error),
+				},
+			})
+		}
+	}, [applyProviderModelsResponse, providerId, startProviderModelsRequest])
+
+	useEffect(() => {
+		void refresh()
+	}, [refresh])
+
+	return {
+		models: state?.models ?? {},
+		defaultModelId: state?.defaultModelId ?? "",
+		isLoading: state?.isLoading ?? false,
+		isStale: state?.isStale ?? false,
+		error: state?.error,
+		refresh,
+		fingerprint: state?.configFingerprint ?? "",
+	}
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useProviderUsageCostDisplay.ts b/apps/vscode/webview-ui/src/hooks/useProviderUsageCostDisplay.ts
new file mode 100644
index 0000000..70536b3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useProviderUsageCostDisplay.ts
@@ -0,0 +1,33 @@
+import { useMemo } from "react"
+import { useProviderListings } from "./useProviderListings"
+
+/**
+ * Surfaces the SDK's `usageCostDisplay` decision for a single provider
+ * id. The decision originates in the `@cline/llms` SDK (see
+ * `resolveProviderUsageCostDisplay` in
+ * `apps/vscode/src/sdk/model-catalog/catalog.ts`) and is propagated
+ * through the `ProviderListing.usage_cost_display` gRPC field.
+ *
+ * Returns `"hide"` when the SDK reports a subscription-style provider
+ * whose per-token / total cost displays should be suppressed (matches
+ * the CLI's `shouldShowCliUsageCost` consumer in `sdk/apps/cli`). Falls
+ * back to `"show"` while the listings are still loading or for any
+ * provider the SDK does not explicitly mark — the same default policy
+ * the SDK and CLI use.
+ *
+ * Webview consumers must pass the returned value into
+ * `ModelInfoView.hideUsageCost` (and equivalent cost-display sites)
+ * rather than re-deriving it. If a new provider needs to suppress cost,
+ * set `metadata.usageCostDisplay = "hide"` in the SDK provider builtin;
+ * the webview picks it up without any change here.
+ */
+export function useProviderUsageCostDisplay(providerId: string | undefined): "show" | "hide" {
+	const { providers } = useProviderListings()
+	return useMemo(() => {
+		if (!providerId) {
+			return "show"
+		}
+		const listing = providers.find((p) => p.id === providerId)
+		return listing?.usageCostDisplay === "hide" ? "hide" : "show"
+	}, [providers, providerId])
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useRemoteConfigSettings.ts b/apps/vscode/webview-ui/src/hooks/useRemoteConfigSettings.ts
new file mode 100644
index 0000000..8f06cb1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useRemoteConfigSettings.ts
@@ -0,0 +1,58 @@
+import { useEffect, useState } from "react"
+import { RemoteConfigServiceClient } from "@/services/grpc-client"
+
+export interface RemoteConfigSetting {
+	type: "rule" | "workflow" | "skill"
+	name: string
+	content: string
+	enabled: boolean
+	locked: boolean
+	toggle: () => void
+}
+
+function toggleRemoteConfigSetting(settingName: string) {
+	// TODO(ENG): The backend handler is not implemented yet and currently
+	// rejects. Handle the result (e.g. update UI state) once toggling is wired
+	// up; for now swallow the rejection so it doesn't surface as an unhandled
+	// promise rejection.
+	RemoteConfigServiceClient.toggleRemoteConfigSetting({ value: settingName }).catch(() => {})
+}
+
+export default function useRemoteConfigSettings(isVisible: boolean): RemoteConfigSetting[] {
+	const [remoteConfigSettings, setRemoteConfigSettings] = useState<RemoteConfigSetting[]>([])
+
+	useEffect(() => {
+		if (!isVisible) {
+			return
+		}
+
+		let isCancelled = false
+
+		RemoteConfigServiceClient.getRemoteConfigSettings({}).then((response) => {
+			if (isCancelled) {
+				return
+			}
+
+			const settings = response.settings.map(
+				(setting) =>
+					({
+						type: setting.type === 0 ? "rule" : setting.type === 1 ? "workflow" : "skill",
+						name: setting.name,
+						content: setting.content,
+						enabled: setting.enabled,
+						locked: setting.locked,
+						toggle: () => {
+							toggleRemoteConfigSetting(setting.name)
+						},
+					}) as RemoteConfigSetting,
+			)
+			setRemoteConfigSettings(settings)
+		})
+
+		return () => {
+			isCancelled = true
+		}
+	}, [isVisible])
+
+	return remoteConfigSettings
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useStaticProviderSelection.ts b/apps/vscode/webview-ui/src/hooks/useStaticProviderSelection.ts
new file mode 100644
index 0000000..2727297
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useStaticProviderSelection.ts
@@ -0,0 +1,67 @@
+import { type ApiConfiguration, type ModelInfo, openAiModelInfoSafeDefaults } from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import { useMemo } from "react"
+import { useProviderModels } from "./useProviderModels"
+import { useProviderUsageCostDisplay } from "./useProviderUsageCostDisplay"
+
+export interface StaticProviderSelectionOptions {
+	/**
+	 * Optional saved model id override. When provided, the hook reads
+	 * selection from this value instead of the common
+	 * `{plan,act}ModeApiModelId` field. Used by providers that maintain
+	 * a provider-specific saved id field (e.g. `planModeFireworksModelId`).
+	 */
+	savedModelId?: string
+}
+
+/**
+ * Shared selection logic for provider components whose:
+ *   - model list is driven by the SDK via gRPC (`useProviderModels`).
+ *   - model id is stored in `{plan,act}ModeApiModelId` by default, or in
+ *     a provider-specific field passed via `savedModelId` option.
+ *
+ * Honors the user's saved model id when it still exists in the SDK
+ * catalog; otherwise falls through to the SDK-declared default. While
+ * the catalog is still loading or the saved id is unknown, returns sane
+ * defaults so the UI does not flicker.
+ *
+ * `hideUsageCost` is sourced from the SDK's
+ * `ProviderListing.usage_cost_display` (see `useProviderUsageCostDisplay`),
+ * so consumers must pass the returned value through to
+ * `<ModelInfoView hideUsageCost={...} />` instead of hard-coding any
+ * per-provider knowledge.
+ */
+export function useStaticProviderSelection(
+	providerId: string,
+	apiConfiguration: ApiConfiguration | undefined,
+	currentMode: Mode,
+	options: StaticProviderSelectionOptions = {},
+): {
+	models: Record<string, ModelInfo>
+	defaultModelId: string
+	selectedModelId: string
+	selectedModelInfo: ModelInfo
+	hideUsageCost: boolean
+} {
+	const { models, defaultModelId } = useProviderModels(providerId)
+	const hideUsageCost = useProviderUsageCostDisplay(providerId) === "hide"
+
+	const fallbackSavedModelId =
+		currentMode === "plan" ? apiConfiguration?.planModeApiModelId : apiConfiguration?.actModeApiModelId
+	const savedModelId = options.savedModelId ?? fallbackSavedModelId
+
+	const { selectedModelId, selectedModelInfo } = useMemo(() => {
+		if (savedModelId && models[savedModelId]) {
+			return { selectedModelId: savedModelId, selectedModelInfo: models[savedModelId] }
+		}
+		if (defaultModelId && models[defaultModelId]) {
+			return { selectedModelId: defaultModelId, selectedModelInfo: models[defaultModelId] }
+		}
+		return {
+			selectedModelId: savedModelId || defaultModelId || "",
+			selectedModelInfo: openAiModelInfoSafeDefaults,
+		}
+	}, [savedModelId, defaultModelId, models])
+
+	return { models, defaultModelId, selectedModelId, selectedModelInfo, hideUsageCost }
+}
diff --git a/apps/vscode/webview-ui/src/index.css b/apps/vscode/webview-ui/src/index.css
new file mode 100644
index 0000000..1487024
--- /dev/null
+++ b/apps/vscode/webview-ui/src/index.css
@@ -0,0 +1,71 @@
+/* Import external CSS files */
+@import url("../../node_modules/@vscode/codicons/dist/codicon.css");
+@import url("../node_modules/@fontsource/azeret-mono/index.css");
+
+/* Tailwind CSS */
+@import "tailwindcss";
+@import "./theme.css";
+@plugin "tailwindcss-animate";
+@custom-variant dark (&:is(.dark *));
+
+/**
+ * The default styles for each defined element.
+ * This ensures all the elements are rendered with the expected styles consistently without affecting by the parent element / host.
+ */
+@layer base {
+	* {
+		@apply border-border outline-ring/50 text-base;
+	}
+	body {
+		@apply bg-background text-foreground;
+	}
+	p {
+		@apply my-0 py-0 text-inherit leading-5 block line-clamp-3;
+		margin-block-start: 1em;
+		margin-block-end: 1em;
+		margin-inline-start: 0px;
+		margin-inline-end: 0px;
+		unicode-bidi: isolate;
+	}
+	span {
+		@apply leading-5;
+		font-size: inherit;
+		color: inherit;
+	}
+	pre {
+		@apply bg-code;
+	}
+	code {
+		@apply bg-code;
+	}
+	h1 {
+		font-size: var(--text-lg);
+		font-weight: var(--font-weight-semibold);
+	}
+	h2 {
+		font-size: var(--text-md);
+		font-weight: var(--font-weight-semibold);
+	}
+	h3 {
+		font-size: var(--text-sm);
+		font-weight: var(--font-weight-semibold);
+	}
+	h4 {
+		font-size: var(--text-base);
+		font-weight: var(--font-weight-bold);
+	}
+	a {
+		@apply text-link hover:text-link-hover;
+		font-size: inherit;
+	}
+	ol {
+		@apply list-decimal pl-3;
+	}
+	ul {
+		@apply list-disc pl-3;
+	}
+	[role="radio"],
+	[role="checkbox"] {
+		margin: calc(var(--design-unit) * 1px) 0;
+	}
+}
diff --git a/apps/vscode/webview-ui/src/lib/utils.ts b/apps/vscode/webview-ui/src/lib/utils.ts
new file mode 100644
index 0000000..5e1abdf
--- /dev/null
+++ b/apps/vscode/webview-ui/src/lib/utils.ts
@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs))
+}
diff --git a/apps/vscode/webview-ui/src/main.css b/apps/vscode/webview-ui/src/main.css
new file mode 100644
index 0000000..f3d6221
--- /dev/null
+++ b/apps/vscode/webview-ui/src/main.css
@@ -0,0 +1,224 @@
+textarea:focus {
+	outline: 1.5px solid var(--vscode-focusBorder, #007fd4);
+}
+
+vscode-button::part(control):focus {
+	outline: none;
+}
+
+vscode-button::part(control):focus-visible {
+	outline: 2px solid var(--vscode-contrastActiveBorder, var(--vscode-focusBorder, Highlight));
+	outline-offset: 2px;
+}
+
+/*
+Use vscode native scrollbar styles
+https://github.com/gitkraken/vscode-gitlens/blob/b1d71d4844523e8b2ef16f9e007068e91f46fd88/src/webviews/apps/home/home.scss
+*/
+
+html {
+	height: 100%;
+	width: 100%;
+}
+
+body {
+	margin: 0;
+	padding: 0;
+	line-height: 1.25;
+	height: 100%;
+	width: 100%;
+	background-color: var(--vscode-sideBar-background);
+}
+
+#root {
+	height: 100%;
+	width: 100%;
+}
+
+body.scrollable,
+.scrollable,
+body.code-block-scrollable,
+.code-block-scrollable {
+	border-color: transparent;
+	transition: border-color 0.7s linear;
+}
+
+body:hover.scrollable,
+body:hover .scrollable,
+body:focus-within.scrollable,
+body:focus-within .scrollable,
+body:hover.code-block-scrollable,
+body:hover .code-block-scrollable,
+body:focus-within.code-block-scrollable,
+body:focus-within .code-block-scrollable {
+	border-color: var(--vscode-scrollbarSlider-background);
+	transition: none;
+}
+
+.scrollable::-webkit-scrollbar-corner {
+	background-color: transparent;
+}
+
+.scrollable::-webkit-scrollbar-thumb {
+	background-color: transparent;
+	border-color: inherit;
+	border-right-style: inset;
+	border-right-width: calc(100vw + 100vh);
+	border-radius: unset;
+}
+
+.scrollable::-webkit-scrollbar-thumb:hover {
+	border-color: var(--vscode-scrollbarSlider-hoverBackground);
+}
+
+.scrollable::-webkit-scrollbar-thumb:active {
+	border-color: var(--vscode-scrollbarSlider-activeBackground);
+}
+
+/*
+Fix VSCode ignoring webkit scrollbar modifiers
+https://github.com/microsoft/vscode/issues/213045
+*/
+@supports selector(::-webkit-scrollbar) {
+	html {
+		scrollbar-color: unset;
+	}
+}
+
+/*
+The above scrollbar styling uses some transparent background color magic to accomplish its animation. However this doesn't play nicely with SyntaxHighlighter, so we need to set a background color for the code blocks' horizontal scrollbar. This actually has the unintended consequence of always showing the scrollbar which I prefer since it makes it more obvious that there is more content to scroll to.
+*/
+
+.code-block-scrollable::-webkit-scrollbar-track {
+	background: transparent;
+}
+
+.code-block-scrollable::-webkit-scrollbar-thumb {
+	background-color: var(--vscode-scrollbarSlider-background);
+	border-radius: 5px;
+	border: 2px solid transparent;
+	background-clip: content-box;
+}
+
+.code-block-scrollable::-webkit-scrollbar-thumb:hover {
+	background-color: var(--vscode-scrollbarSlider-hoverBackground);
+}
+
+.code-block-scrollable::-webkit-scrollbar-thumb:active {
+	background-color: var(--vscode-scrollbarSlider-activeBackground);
+}
+
+.code-block-scrollable::-webkit-scrollbar-corner {
+	background-color: transparent;
+}
+
+/*
+Dropdown label
+https://github.com/microsoft/vscode-webview-ui-toolkit/tree/main/src/dropdown#with-label
+*/
+.dropdown-container {
+	box-sizing: border-box;
+	display: flex;
+	flex-flow: column nowrap;
+	align-items: flex-start;
+	justify-content: flex-start;
+}
+.dropdown-container label {
+	display: block;
+	color: var(--vscode-foreground);
+	cursor: pointer;
+	font-size: var(--vscode-font-size);
+	line-height: normal;
+	margin-bottom: 2px;
+}
+
+/* Fix scrollbar in dropdown */
+
+vscode-dropdown::part(listbox) {
+	border-color: var(--vscode-scrollbarSlider-background);
+	transition: none;
+	scrollbar-color: var(--vscode-scrollbarSlider-background) transparent;
+}
+
+/* Faded icon buttons in textfields */
+
+.input-icon-button {
+	cursor: pointer;
+	opacity: 0.65;
+}
+.input-icon-button:hover {
+	opacity: 1;
+}
+.input-icon-button.disabled {
+	cursor: not-allowed;
+	opacity: 0.4;
+}
+.input-icon-button.disabled:hover {
+	opacity: 0.4;
+}
+
+/* Context mentions */
+
+/* Needs to match the highlightLayerRef in ChatTextArea for proper positioning */
+.mention-context-textarea-highlight,
+.mention-context-highlight,
+.mention-context-highlight-with-shadow,
+.slash-command-match-textarea-highlight {
+	font-family: var(--vscode-font-family);
+	font-size: var(--vscode-editor-font-size);
+	line-height: var(--vscode-editor-line-height);
+}
+
+.mention-context-textarea-highlight {
+	background-color: color-mix(in srgb, var(--vscode-badge-foreground) 30%, transparent);
+	border-radius: 3px;
+	box-shadow: 0 0 0 0.5px color-mix(in srgb, var(--vscode-badge-foreground) 30%, transparent);
+	color: transparent;
+	/* padding: 0.5px;
+	margin: -0.5px;
+	position: relative;
+	bottom: -0.5px; */
+}
+
+.mention-context-highlight {
+	background-color: color-mix(in srgb, var(--vscode-badge-foreground) 30%, transparent);
+	border-radius: 3px;
+}
+
+.mention-context-highlight-with-shadow {
+	background-color: color-mix(in srgb, var(--vscode-badge-foreground) 30%, transparent);
+	border-radius: 3px;
+	box-shadow: 0 0 0 0.5px color-mix(in srgb, var(--vscode-badge-foreground) 30%, transparent);
+}
+
+.slash-command-match-textarea-highlight {
+	background-color: color-mix(in srgb, var(--vscode-focusBorder) 30%, transparent);
+	border-radius: 3px;
+	box-shadow: 0 0 0 0.5px color-mix(in srgb, var(--vscode-focusBorder) 30%, transparent);
+	color: transparent;
+}
+
+/* Pulse animation for running command indicator */
+@keyframes pulse {
+	0%,
+	100% {
+		opacity: 1;
+	}
+	50% {
+		opacity: 0.5;
+	}
+}
+
+/* Fix tooltip arrow lag - disable animations on tooltips */
+[data-slot="tooltip-content"],
+[data-slot="tooltip-content"] * {
+	animation: none !important;
+	transition: none !important;
+}
+
+/* Fix popover arrow lag - disable animations on popovers */
+[data-slot="popover-content"],
+[data-slot="popover-content"] * {
+	animation: none !important;
+	transition: none !important;
+}
diff --git a/apps/vscode/webview-ui/src/main.tsx b/apps/vscode/webview-ui/src/main.tsx
new file mode 100644
index 0000000..5468af7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/main.tsx
@@ -0,0 +1,11 @@
+import { StrictMode } from "react"
+import { createRoot } from "react-dom/client"
+import "./main.css"
+import "./index.css"
+import App from "./App.tsx"
+
+createRoot(document.getElementById("root")!).render(
+	<StrictMode>
+		<App />
+	</StrictMode>,
+)
diff --git a/apps/vscode/webview-ui/src/services/grpc-client-base.ts b/apps/vscode/webview-ui/src/services/grpc-client-base.ts
new file mode 100644
index 0000000..c28d6ca
--- /dev/null
+++ b/apps/vscode/webview-ui/src/services/grpc-client-base.ts
@@ -0,0 +1,118 @@
+/** biome-ignore-all lint/complexity/noThisInStatic: In static methods, this refers to the constructor (the subclass that invoked the method) when we want to refer to the subclass serviceName.
+ *
+ * NOTE: This file imports PLATFORM_CONFIG directly rather than using the PlatformProvider
+ * because it contains static utility methods that are called from various contexts,
+ * including non-React code. The configuration is compile-time constant, so direct
+ * import is safe and ensures the methods work consistently regardless of React context.
+ */
+import { v4 as uuidv4 } from "uuid"
+import { PLATFORM_CONFIG } from "../config/platform.config"
+
+export interface Callbacks<TResponse> {
+	onResponse: (response: TResponse) => void
+	onError: (error: Error) => void
+	onComplete: () => void
+}
+
+export abstract class ProtoBusClient {
+	static serviceName: string
+
+	static async makeUnaryRequest<TRequest, TResponse>(
+		methodName: string,
+		request: TRequest,
+		encodeRequest: (_: TRequest) => unknown,
+		decodeResponse: (_: { [key: string]: any }) => TResponse,
+	): Promise<TResponse> {
+		return new Promise((resolve, reject) => {
+			const requestId = uuidv4()
+
+			// Set up one-time listener for this specific request
+			const handleResponse = (event: MessageEvent) => {
+				const message = event.data
+				if (message.type === "grpc_response" && message.grpc_response?.request_id === requestId) {
+					// Remove listener once we get our response
+					window.removeEventListener("message", handleResponse)
+					if (message.grpc_response.message) {
+						const response = PLATFORM_CONFIG.decodeMessage(message.grpc_response.message, decodeResponse)
+						resolve(response)
+					} else if (message.grpc_response.error) {
+						reject(new Error(message.grpc_response.error))
+					} else {
+						console.error("Received ProtoBus message with no response or error ", JSON.stringify(message))
+					}
+				}
+			}
+
+			window.addEventListener("message", handleResponse)
+			PLATFORM_CONFIG.postMessage({
+				type: "grpc_request",
+				grpc_request: {
+					service: this.serviceName,
+					method: methodName,
+					message: PLATFORM_CONFIG.encodeMessage(request, encodeRequest),
+					request_id: requestId,
+					is_streaming: false,
+				},
+			})
+		})
+	}
+
+	static makeStreamingRequest<TRequest, TResponse>(
+		methodName: string,
+		request: TRequest,
+		encodeRequest: (_: TRequest) => unknown,
+		decodeResponse: (_: { [key: string]: any }) => TResponse,
+		callbacks: Callbacks<TResponse>,
+	): () => void {
+		const requestId = uuidv4()
+		// Set up listener for streaming responses
+		const handleResponse = (event: MessageEvent) => {
+			const message = event.data
+			if (message.type === "grpc_response" && message.grpc_response?.request_id === requestId) {
+				if (message.grpc_response.message) {
+					// Process streaming message
+					const response = PLATFORM_CONFIG.decodeMessage(message.grpc_response.message, decodeResponse)
+					callbacks.onResponse(response)
+				} else if (message.grpc_response.error) {
+					// Handle error
+					if (callbacks.onError) {
+						callbacks.onError(new Error(message.grpc_response.error))
+					}
+					// Only remove the event listener on error
+					window.removeEventListener("message", handleResponse)
+				} else {
+					console.error("Received ProtoBus message with no response or error ", JSON.stringify(message))
+				}
+				if (message.grpc_response.is_streaming === false) {
+					if (callbacks.onComplete) {
+						callbacks.onComplete()
+					}
+					// Only remove the event listener when the stream is explicitly ended
+					window.removeEventListener("message", handleResponse)
+				}
+			}
+		}
+		window.addEventListener("message", handleResponse)
+		PLATFORM_CONFIG.postMessage({
+			type: "grpc_request",
+			grpc_request: {
+				service: this.serviceName,
+				method: methodName,
+				message: PLATFORM_CONFIG.encodeMessage(request, encodeRequest),
+				request_id: requestId,
+				is_streaming: true,
+			},
+		})
+		// Return a function to cancel the stream
+		return () => {
+			window.removeEventListener("message", handleResponse)
+			PLATFORM_CONFIG.postMessage({
+				type: "grpc_request_cancel",
+				grpc_request_cancel: {
+					request_id: requestId,
+				},
+			})
+			console.log(`[DEBUG] Sent cancellation for request: ${requestId}`)
+		}
+	}
+}
diff --git a/apps/vscode/webview-ui/src/setupTests.ts b/apps/vscode/webview-ui/src/setupTests.ts
new file mode 100644
index 0000000..de62a04
--- /dev/null
+++ b/apps/vscode/webview-ui/src/setupTests.ts
@@ -0,0 +1,26 @@
+import "@testing-library/jest-dom"
+import { vi } from "vitest"
+
+// "Official" jest workaround for mocking window.matchMedia()
+// https://jestjs.io/docs/manual-mocks#mocking-methods-which-are-not-implemented-in-jsdom
+
+Object.defineProperty(window, "matchMedia", {
+	writable: true,
+	value: vi.fn().mockImplementation((query) => ({
+		matches: false,
+		media: query,
+		onchange: null,
+		addListener: vi.fn(), // Deprecated
+		removeListener: vi.fn(), // Deprecated
+		addEventListener: vi.fn(),
+		removeEventListener: vi.fn(),
+		dispatchEvent: vi.fn(),
+	})),
+})
+
+// Mock VSCode API for webview tests
+vi.stubGlobal("acquireVsCodeApi", () => ({
+	postMessage: vi.fn(),
+	getState: vi.fn(),
+	setState: vi.fn(),
+}))
diff --git a/apps/vscode/webview-ui/src/theme.css b/apps/vscode/webview-ui/src/theme.css
new file mode 100644
index 0000000..7de5d94
--- /dev/null
+++ b/apps/vscode/webview-ui/src/theme.css
@@ -0,0 +1,361 @@
+/* Editor theme mapping */
+@theme {
+	--color-cline: #9663f1;
+	--color-background: var(--vscode-sideBar-background);
+	--color-border: var(--vscode-focusBorder);
+	--color-border-panel: var(--vscode-panel-border);
+	--color-foreground: var(--vscode-foreground);
+	--color-shadow: var(--vscode-widget-shadow);
+	--color-code: var(--vscode-editor-background);
+	--color-code-foreground: var(--vscode-editor-foreground);
+	--color-code-border: var(--vscode-editor-border);
+	--color-code-block-background: var(
+		--vscode-textCodeBlock-background,
+		--vscode-editor-background,
+		--vscode-sideBar-background,
+		rgb(30 30 30)
+	);
+	--color-quote: var(--vscode-textBlockQuote-background);
+	--color-quote-foreground: var(--vscode-textBlockQuote-foreground);
+	--color-text-block-background: var(--vscode-textCodeBlock-background);
+	--color-editor-group-border: var(--vscode-editorGroup-border);
+	--color-editor-widget-border: var(--vscode-editorWidget-border, #cccccc);
+	--color-editor-warning-foreground: var(--vscode-editorWarning-foreground);
+	--color-sidebar-background: var(--vscode-sideBar-background);
+	--color-sidebar-foreground: var(--vscode-sideBar-foreground);
+	--color-input-foreground: var(--vscode-input-foreground);
+	--color-input-background: var(--vscode-input-background);
+	--color-input-border: var(--vscode-input-border);
+	--color-input-placeholder: var(--vscode-input-placeholderForeground);
+	--color-input-error-background: var(--vscode-inputValidation-errorBackground, #a82424);
+	--color-input-error-foreground: var(--vscode-inputValidation-errorForeground, #8f1f1f);
+	--color-input-warning-background: var(--vscode-inputValidation-warningBackground, #663c00);
+	--color-input-warning-foreground: var(--vscode-inputValidation-warningForeground, #7e5100);
+	--color-selection: var(--vscode-list-activeSelectionBackground);
+	--color-selection-foreground: var(--vscode-list-activeSelectionForeground);
+	--color-selection-inactive: var(--vscode-editor-inactiveSelectionBackground);
+	--color-button-background: var(--vscode-button-background);
+	--color-button-hover: var(--vscode-button-hoverBackground);
+	--color-button-foreground: var(--vscode-button-foreground);
+	--color-button-separator: var(--vscode-button-separator);
+	--color-text-separator: var(--vscode-textSeparator-foreground, #424242);
+	--color-button-secondary-background: var(--vscode-button-secondaryBackground);
+	--color-button-secondary-background-hover: var(--vscode-button-secondaryHoverBackground);
+	--color-button-secondary-foreground: var(--vscode-button-secondaryForeground);
+	--color-muted: color-mix(in srgb, var(--vscode-toolbar-hoverBackground) 65%, transparent);
+	--color-muted-foreground: var(--vscode-editor-foldPlaceholderForeground);
+	--color-menu: var(--vscode-menu-background);
+	--color-menu-foreground: var(--vscode-menu-foreground);
+	--color-menu-border: var(--vscode-menu-border);
+	--color-menu-shadow: var(--vscode-menu-shadow);
+	--color-preformat: var(--vscode-textPreformat-foreground, #f78383);
+	--color-link: var(--vscode-textLink-foreground);
+	--color-link-hover: var(--vscode-textLink-activeForeground);
+	--color-list-hover: var(--vscode-list-hoverBackground);
+	--color-badge-foreground: var(--vscode-badge-foreground);
+	--color-badge-background: var(--vscode-badge-background);
+	--color-banner-background: var(--vscode-banner-background);
+	--color-banner-foreground: var(--vscode-banner-foreground);
+	--color-banner-icon: var(--vscode-banner-iconForeground);
+	--color-editor-match-highlight: var(--vscode-editor-findMatchHighlightBackground);
+	--color-icon-foreground: var(--vscode-icon-foreground);
+	--color-notification-foreground: var(--vscode-notificationsInfoIcon-foreground);
+	--color-toolbar-default: var(--vscode-toolbar-background);
+	--color-toolbar-hover: var(--vscode-toolbar-hoverBackground);
+	--color-diff-added: var(--vscode-diffEditor-insertedTextBackground);
+	--color-diff-removed: var(--vscode-diffEditor-removedTextBackground);
+	--color-error: var(--vscode-errorForeground);
+	--color-error-icon: var(--vscode-problemsErrorIcon-foreground);
+	--color-failed-icon: var(--vscode-testing-iconFailed);
+	--color-error: var(--vscode-errorForeground, #c42b2b);
+	--color-error-icon: var(--vscode-problemsErrorIcon-foreground, #c42b2b);
+	--color-description: var(--vscode-descriptionForeground);
+	--color-success: var(--vscode-charts-green);
+	--color-warning: var(--vscode-charts-yellow);
+	--font-base:
+		var(--vscode-font-family), system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell,
+		"Open Sans", "Helvetica Neue", sans-serif;
+	--font-mono:
+		var(--vscode-editor-font-family), ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New",
+		monospace;
+	--font-azeret-mono: Azeret Mono, monospace;
+	--font-editor: var(--vscode-editor-font-family);
+	--text-editor-size: var(--vscode-editor-font-size);
+	--text-2xl: calc(2.25 * var(--vscode-font-size));
+	--text-xl: calc(2 * var(--vscode-font-size));
+	--text-lg: calc(1.5 * var(--vscode-font-size));
+	--text-md: calc(1.25 * var(--vscode-font-size));
+	--text-base: var(--vscode-font-size, 14px);
+	--text-sm: calc(0.95 * var(--vscode-font-size));
+	--text-xs: calc(0.85 * var(--vscode-font-size));
+	--text-xxs: calc(0.5 * var(--vscode-font-size));
+	--breakpoint-xs: 400px;
+	--radius-half: 50%;
+	--radius-xs: 2px;
+	--breakpoint-xxs: 180px;
+
+	--animate-fade-in: fadeIn 0.4s ease-out forwards;
+	@keyframes fadeIn {
+		from {
+			opacity: 0;
+			transform: scale(0.98);
+		}
+		to {
+			opacity: 1;
+			transform: scale(1);
+		}
+	}
+
+	--animate-cursor-blink: cursorBlink 1s ease-in-out infinite;
+	@keyframes cursorBlink {
+		0%,
+		100% {
+			opacity: 1;
+		}
+		50% {
+			opacity: 0;
+		}
+	}
+
+	--animate-icon-pulse: iconPulse 1s ease-in-out infinite;
+	@keyframes iconPulse {
+		0%,
+		100% {
+			opacity: 0.5;
+		}
+		50% {
+			opacity: 1;
+		}
+	}
+
+	--animate-shimmer: shimmer 5s infinite linear;
+	@keyframes shimmer {
+		0% {
+			background-position: 200% 0;
+		}
+		100% {
+			background-position: -200% 0;
+		}
+	}
+
+	--animate-fade-slide-in: fadeSlideIn 0.6s cubic-bezier(0.16, 1, 0.3, 1);
+	@keyframes fadeSlideIn {
+		from {
+			opacity: 0;
+			transform: translateY(-12px);
+		}
+		to {
+			opacity: 1;
+			transform: translateY(0);
+		}
+	}
+}
+
+@theme inline {
+	--radius-sm: calc(var(--radius) - 4px);
+	--radius-md: calc(var(--radius) - 2px);
+	--radius-lg: var(--radius);
+	--radius-xl: calc(var(--radius) + 4px);
+	--color-card: var(--card);
+	--color-card-foreground: var(--card-foreground);
+	--color-popover: var(--popover);
+	--color-popover-foreground: var(--popover-foreground);
+	--color-primary: var(--primary);
+	--color-primary-foreground: var(--primary-foreground);
+	--color-secondary: var(--secondary);
+	--color-secondary-foreground: var(--secondary-foreground);
+	--color-muted: color-mix(in srgb, var(--vscode-toolbar-hoverBackground) 65%, transparent);
+	--color-muted-foreground: var(--muted-foreground);
+	--color-accent: var(--accent);
+	--color-accent-foreground: var(--accent-foreground);
+	--color-destructive: var(--destructive);
+	--color-border: var(--border);
+	--color-input: var(--input);
+	--color-ring: var(--ring);
+	--color-chart-1: var(--chart-1);
+	--color-chart-2: var(--chart-2);
+	--color-chart-3: var(--chart-3);
+	--color-chart-4: var(--chart-4);
+	--color-chart-5: var(--chart-5);
+	--color-sidebar: var(--sidebar);
+	--color-sidebar-foreground: var(--sidebar-foreground);
+	--color-sidebar-primary: var(--sidebar-primary);
+	--color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+	--color-sidebar-accent: var(--sidebar-accent);
+	--color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+	--color-sidebar-border: var(--sidebar-border);
+	--color-sidebar-ring: var(--sidebar-ring);
+	--size-1: calc(0.85 * var(--vscode-font-size));
+	--size-2: calc(1 * var(--vscode-font-size));
+	--size-3: calc(1.25 * var(--vscode-font-size));
+	--size-4: calc(1.5 * var(--vscode-font-size));
+	--size-5: calc(2 * var(--vscode-font-size));
+}
+
+:root {
+	--radius: 0.625rem;
+	--background: oklch(1 0 0);
+	--foreground: oklch(0.145 0 0);
+	--card: oklch(1 0 0);
+	--card-foreground: oklch(0.145 0 0);
+	--popover: oklch(1 0 0);
+	--popover-foreground: oklch(0.145 0 0);
+	--primary: oklch(0.205 0 0);
+	--primary-foreground: oklch(0.985 0 0);
+	--secondary: oklch(0.97 0 0);
+	--secondary-foreground: oklch(0.205 0 0);
+	--muted: oklch(0.97 0 0);
+	--muted-foreground: oklch(0.556 0 0);
+	--accent: oklch(0.97 0 0);
+	--accent-foreground: oklch(0.205 0 0);
+	--destructive: oklch(0.577 0.245 27.325);
+	--border: oklch(0.922 0 0);
+	--input: oklch(0.922 0 0);
+	--ring: oklch(0.708 0 0);
+	--chart-1: oklch(0.646 0.222 41.116);
+	--chart-2: oklch(0.6 0.118 184.704);
+	--chart-3: oklch(0.398 0.07 227.392);
+	--chart-4: oklch(0.828 0.189 84.429);
+	--chart-5: oklch(0.769 0.188 70.08);
+	--sidebar: oklch(0.985 0 0);
+	--sidebar-foreground: oklch(0.145 0 0);
+	--sidebar-primary: oklch(0.205 0 0);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.97 0 0);
+	--sidebar-accent-foreground: oklch(0.205 0 0);
+	--sidebar-border: oklch(0.922 0 0);
+	--sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+	--background: oklch(0.145 0 0);
+	--foreground: oklch(0.985 0 0);
+	--card: oklch(0.205 0 0);
+	--card-foreground: oklch(0.985 0 0);
+	--popover: oklch(0.205 0 0);
+	--popover-foreground: oklch(0.985 0 0);
+	--primary: oklch(0.922 0 0);
+	--primary-foreground: oklch(0.205 0 0);
+	--secondary: oklch(0.269 0 0);
+	--secondary-foreground: oklch(0.985 0 0);
+	--muted: oklch(0.269 0 0);
+	--muted-foreground: oklch(0.708 0 0);
+	--accent: oklch(0.269 0 0);
+	--accent-foreground: oklch(0.985 0 0);
+	--destructive: oklch(0.704 0.191 22.216);
+	--border: oklch(1 0 0 / 10%);
+	--input: oklch(1 0 0 / 15%);
+	--ring: oklch(0.556 0 0);
+	--chart-1: oklch(0.488 0.243 264.376);
+	--chart-2: oklch(0.696 0.17 162.48);
+	--chart-3: oklch(0.769 0.188 70.08);
+	--chart-4: oklch(0.627 0.265 303.9);
+	--chart-5: oklch(0.645 0.246 16.439);
+	--sidebar: oklch(0.205 0 0);
+	--sidebar-foreground: oklch(0.985 0 0);
+	--sidebar-primary: oklch(0.488 0.243 264.376);
+	--sidebar-primary-foreground: oklch(0.985 0 0);
+	--sidebar-accent: oklch(0.269 0 0);
+	--sidebar-accent-foreground: oklch(0.985 0 0);
+	--sidebar-border: oklch(1 0 0 / 10%);
+	--sidebar-ring: oklch(0.556 0 0);
+}
+
+@layer utilities {
+	/**
+	 * Variant that becomes visible when focused
+	 * Useful for skip links and other keyboard navigation aids
+	 */
+	.sr-only-focusable:focus {
+		position: static;
+		width: auto;
+		height: auto;
+		padding: inherit;
+		margin: inherit;
+		overflow: visible;
+		clip: auto;
+		white-space: normal;
+	}
+
+	@keyframes flash {
+		0%,
+		100% {
+			opacity: 1;
+		}
+		50% {
+			opacity: 0.5;
+		}
+	}
+
+	.animate-flash {
+		animation: flash 1.5s ease-in-out infinite;
+	}
+
+	.inline-markdown-block {
+		@apply text-base text-foreground font-base;
+
+		pre {
+			@apply bg-code rounded-xs overflow-x-auto overflow-y-hidden;
+			margin: 13px 0;
+			padding: 10px 10px;
+			max-width: calc(100vw - 20px);
+			padding-right: 70px;
+		}
+
+		pre > code .hljs-deletion {
+			@apply inline-block w-full bg-diff-removed;
+		}
+
+		pre > code .hljs-addition {
+			@apply inline-block w-full bg-diff-added;
+		}
+
+		code span.line:empty {
+			@apply hidden;
+		}
+		code {
+			@apply break-words rounded-xs;
+		}
+		p,
+		li,
+		ol,
+		ul {
+			@apply leading-tight;
+		}
+		hr,
+		ul,
+		ol {
+			@apply my-3 ml-5;
+		}
+		li > ul,
+		li > ol {
+			@apply my-1 ml-2;
+		}
+		table {
+			@apply border-collapse w-full my-3;
+		}
+		th,
+		td {
+			@apply p-2 border border-border-panel text-left;
+		}
+		th {
+			@apply bg-code/20 font-semibold;
+		}
+		tr:nth-child(even) {
+			@apply bg-list-hover;
+		}
+		del {
+			@apply line-through opacity-70;
+		}
+
+		code:not(pre > code) {
+			@apply font-mono text-preformat bg-code-block-background border border-text-separator rounded-xs py-0.5 whitespace-pre-line break-words text-editor-size;
+		}
+
+		/* Inline cursor container - adds blinking cursor after last child */
+		.inline-cursor-container > :last-child::after {
+			content: "";
+			@apply inline-block w-0.5 h-[1em] ml-0.5 bg-foreground align-text-bottom animate-cursor-blink;
+		}
+	}
+}
diff --git a/apps/vscode/webview-ui/src/utils/__tests__/context-mentions.test.ts b/apps/vscode/webview-ui/src/utils/__tests__/context-mentions.test.ts
new file mode 100644
index 0000000..12c5efc
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/__tests__/context-mentions.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest"
+import { insertMention, insertMentionDirectly } from "../context-mentions"
+
+describe("context-mentions", () => {
+	describe("insertMention", () => {
+		it("should add quotes to file paths with spaces", () => {
+			const text = "Check @"
+			const position = 7
+			const value = "/path with spaces/file.txt"
+
+			const result = insertMention(text, position, value)
+
+			expect(result.newValue).toBe('Check @"/path with spaces/file.txt" ')
+			expect(result.mentionIndex).toBe(6)
+		})
+
+		it("should not add quotes to file paths without spaces", () => {
+			const text = "Check @"
+			const position = 7
+			const value = "/path/without/spaces.txt"
+
+			const result = insertMention(text, position, value)
+
+			expect(result.newValue).toBe("Check @/path/without/spaces.txt ")
+			expect(result.mentionIndex).toBe(6)
+		})
+
+		it("should not add quotes to non-file mentions", () => {
+			const text = "Check @"
+			const position = 7
+			const value = "terminal"
+
+			const result = insertMention(text, position, value)
+
+			expect(result.newValue).toBe("Check @terminal ")
+			expect(result.mentionIndex).toBe(6)
+		})
+
+		it("should replace existing partial mention", () => {
+			const text = "Check @/pa and more"
+			const position = 10
+			const value = "/path with spaces/file.txt"
+
+			const result = insertMention(text, position, value, 3)
+
+			expect(result.newValue).toBe('Check @"/path with spaces/file.txt" and more')
+			expect(result.mentionIndex).toBe(6)
+		})
+
+		it("should handle folder paths with spaces", () => {
+			const text = "Look in @"
+			const position = 9
+			const value = "/folder with spaces/"
+
+			const result = insertMention(text, position, value)
+
+			expect(result.newValue).toBe('Look in @"/folder with spaces/" ')
+			expect(result.mentionIndex).toBe(8)
+		})
+	})
+
+	describe("insertMentionDirectly", () => {
+		it("should add quotes to file paths with spaces", () => {
+			const text = "Some text "
+			const position = 10
+			const value = "/folder with spaces/"
+
+			const result = insertMentionDirectly(text, position, value)
+
+			expect(result.newValue).toBe('Some text @"/folder with spaces/" ')
+			expect(result.mentionIndex).toBe(10)
+		})
+
+		it("should not add quotes to file paths without spaces", () => {
+			const text = "Some text "
+			const position = 10
+			const value = "/folder/without/spaces/"
+
+			const result = insertMentionDirectly(text, position, value)
+
+			expect(result.newValue).toBe("Some text @/folder/without/spaces/ ")
+			expect(result.mentionIndex).toBe(10)
+		})
+
+		it("should handle URLs without adding quotes", () => {
+			const text = "Visit "
+			const position = 6
+			const value = "https://example.com"
+
+			const result = insertMentionDirectly(text, position, value)
+
+			expect(result.newValue).toBe("Visit @https://example.com ")
+			expect(result.mentionIndex).toBe(6)
+		})
+
+		it("should handle special mentions without adding quotes", () => {
+			const text = "Check "
+			const position = 6
+			const value = "git-changes"
+
+			const result = insertMentionDirectly(text, position, value)
+
+			expect(result.newValue).toBe("Check @git-changes ")
+			expect(result.mentionIndex).toBe(6)
+		})
+	})
+})
diff --git a/apps/vscode/webview-ui/src/utils/__tests__/hooks.spec.ts b/apps/vscode/webview-ui/src/utils/__tests__/hooks.spec.ts
new file mode 100644
index 0000000..72cd21c
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/__tests__/hooks.spec.ts
@@ -0,0 +1,64 @@
+import { renderHook } from "@testing-library/react"
+import { vi } from "vitest"
+import { useMetaKeyDetection, useShortcut } from "../hooks"
+
+describe("useShortcut", () => {
+	it("should call the callback when the shortcut is pressed", () => {
+		const callback = vi.fn()
+		renderHook(() => useShortcut("Meta+Shift+a", callback))
+
+		const event = new KeyboardEvent("keydown", { key: "a", metaKey: true, shiftKey: true })
+		window.dispatchEvent(event)
+
+		expect(callback).toHaveBeenCalled()
+	})
+
+	it("should not call the callback when the shortcut is not pressed", () => {
+		const callback = vi.fn()
+		renderHook(() => useShortcut("Command+Shift+b", callback))
+
+		const event = new KeyboardEvent("keydown", { key: "a", metaKey: true, shiftKey: true })
+		window.dispatchEvent(event)
+
+		expect(callback).not.toHaveBeenCalled()
+	})
+
+	it("should not call the callback when typing in a text input when disableTextInputs is true", () => {
+		const callback = vi.fn()
+		renderHook(() => useShortcut("Meta+Shift+a", callback, { disableTextInputs: true }))
+
+		const input = document.createElement("input")
+		document.body.appendChild(input)
+		input.focus()
+
+		const event = new KeyboardEvent("keydown", { key: "a", metaKey: true, shiftKey: true })
+		input.dispatchEvent(event)
+
+		expect(callback).not.toHaveBeenCalled()
+
+		document.body.removeChild(input)
+	})
+})
+
+describe("useMetaKeyDetection", () => {
+	it("should detect Windows OS and metaKey from platform", () => {
+		// mock the detect functions
+		const { result } = renderHook(() => useMetaKeyDetection("win32"))
+		expect(result.current[0]).toBe("windows")
+		expect(result.current[1]).toBe("Win")
+	})
+
+	it("should detect Mac OS and metaKey from platform", () => {
+		// mock the detect functions
+		const { result } = renderHook(() => useMetaKeyDetection("darwin"))
+		expect(result.current[0]).toBe("mac")
+		expect(result.current[1]).toBe("CMD")
+	})
+
+	it("should detect Linux OS and metaKey from platform", () => {
+		// mock the detect functions
+		const { result } = renderHook(() => useMetaKeyDetection("linux"))
+		expect(result.current[0]).toBe("linux")
+		expect(result.current[1]).toBe("Alt")
+	})
+})
diff --git a/apps/vscode/webview-ui/src/utils/__tests__/platformUtils.spec.ts b/apps/vscode/webview-ui/src/utils/__tests__/platformUtils.spec.ts
new file mode 100644
index 0000000..e41a2dd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/__tests__/platformUtils.spec.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest"
+import { detectMetaKeyChar } from "../platformUtils"
+
+describe("detectMetaKeyChar", () => {
+	it("should return ⌘ Command for darwin platform", () => {
+		const result = detectMetaKeyChar("darwin")
+		expect(result).toBe("CMD")
+	})
+
+	it("should return ⊞ Win for win32 platform", () => {
+		const result = detectMetaKeyChar("win32")
+		expect(result).toBe("Win")
+	})
+
+	it("should return Alt for linux platform", () => {
+		const result = detectMetaKeyChar("linux")
+		expect(result).toBe("Alt")
+	})
+
+	it("should return generic CMD for unknown platform", () => {
+		const result = detectMetaKeyChar("somethingelse")
+		expect(result).toBe("CMD")
+	})
+})
diff --git a/apps/vscode/webview-ui/src/utils/__tests__/slash-commands.test.ts b/apps/vscode/webview-ui/src/utils/__tests__/slash-commands.test.ts
new file mode 100644
index 0000000..6d9761e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/__tests__/slash-commands.test.ts
@@ -0,0 +1,228 @@
+import type { McpServer } from "@shared/mcp"
+import { describe, expect, it } from "vitest"
+import { getMatchingSlashCommands, getMcpPromptCommands, slashCommandRegex, validateSlashCommand } from "../slash-commands"
+
+// Helper to create a mock MCP server
+function createMockMcpServer(overrides: Partial<McpServer> = {}): McpServer {
+	return {
+		name: "test-server",
+		status: "connected",
+		config: "{}",
+		prompts: [],
+		tools: [],
+		resources: [],
+		resourceTemplates: [],
+		...overrides,
+	}
+}
+
+describe("slash-commands", () => {
+	describe("getMcpPromptCommands", () => {
+		it("should return empty array when no servers provided", () => {
+			const result = getMcpPromptCommands([])
+			expect(result).toEqual([])
+		})
+
+		it("should return empty array when servers have no prompts", () => {
+			const servers = [createMockMcpServer({ prompts: [] })]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toEqual([])
+		})
+
+		it("should skip disconnected servers", () => {
+			const servers = [
+				createMockMcpServer({
+					status: "disconnected",
+					prompts: [{ name: "test-prompt", description: "A test prompt" }],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toEqual([])
+		})
+
+		it("should skip servers with connecting status", () => {
+			const servers = [
+				createMockMcpServer({
+					status: "connecting",
+					prompts: [{ name: "test-prompt", description: "A test prompt" }],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toEqual([])
+		})
+
+		it("should generate commands for connected servers with prompts", () => {
+			const servers = [
+				createMockMcpServer({
+					name: "my-server",
+					prompts: [{ name: "summarize", description: "Summarize text" }],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toEqual([
+				{
+					name: "mcp:my-server:summarize",
+					description: "Summarize text",
+					section: "mcp",
+				},
+			])
+		})
+
+		it("should use title as fallback description", () => {
+			const servers = [
+				createMockMcpServer({
+					name: "server",
+					prompts: [{ name: "prompt", title: "My Prompt Title" }],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result[0].description).toBe("My Prompt Title")
+		})
+
+		it("should use default description when no description or title", () => {
+			const servers = [
+				createMockMcpServer({
+					name: "server",
+					prompts: [{ name: "prompt" }],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result[0].description).toBe("MCP prompt from server")
+		})
+
+		it("should handle multiple prompts from single server", () => {
+			const servers = [
+				createMockMcpServer({
+					name: "multi-server",
+					prompts: [
+						{ name: "prompt1", description: "First prompt" },
+						{ name: "prompt2", description: "Second prompt" },
+						{ name: "prompt3", description: "Third prompt" },
+					],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toHaveLength(3)
+			expect(result.map((c) => c.name)).toEqual([
+				"mcp:multi-server:prompt1",
+				"mcp:multi-server:prompt2",
+				"mcp:multi-server:prompt3",
+			])
+		})
+
+		it("should handle multiple servers with prompts", () => {
+			const servers = [
+				createMockMcpServer({
+					name: "server-a",
+					prompts: [{ name: "promptA", description: "From A" }],
+				}),
+				createMockMcpServer({
+					name: "server-b",
+					prompts: [{ name: "promptB", description: "From B" }],
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toHaveLength(2)
+			expect(result[0].name).toBe("mcp:server-a:promptA")
+			expect(result[1].name).toBe("mcp:server-b:promptB")
+		})
+
+		it("should skip servers with undefined prompts", () => {
+			const servers = [
+				createMockMcpServer({
+					name: "server",
+					prompts: undefined,
+				}),
+			]
+			const result = getMcpPromptCommands(servers)
+			expect(result).toEqual([])
+		})
+	})
+
+	describe("getMatchingSlashCommands with MCP servers", () => {
+		const mcpServers = [
+			createMockMcpServer({
+				name: "test-server",
+				prompts: [
+					{ name: "summarize", description: "Summarize content" },
+					{ name: "translate", description: "Translate text" },
+				],
+			}),
+		]
+
+		it("should include MCP commands in results when no query", () => {
+			const result = getMatchingSlashCommands("", {}, {}, undefined, undefined, mcpServers)
+			const mcpCommands = result.filter((cmd) => cmd.section === "mcp")
+			expect(mcpCommands).toHaveLength(2)
+		})
+
+		it("should filter MCP commands by query prefix", () => {
+			const result = getMatchingSlashCommands("mcp:test", {}, {}, undefined, undefined, mcpServers)
+			const mcpCommands = result.filter((cmd) => cmd.section === "mcp")
+			expect(mcpCommands).toHaveLength(2)
+		})
+
+		it("should filter to specific MCP prompt", () => {
+			const result = getMatchingSlashCommands("mcp:test-server:sum", {}, {}, undefined, undefined, mcpServers)
+			expect(result).toHaveLength(1)
+			expect(result[0].name).toBe("mcp:test-server:summarize")
+		})
+
+		it("should return empty for non-matching MCP query", () => {
+			const result = getMatchingSlashCommands("mcp:nonexistent", {}, {}, undefined, undefined, mcpServers)
+			expect(result).toHaveLength(0)
+		})
+	})
+
+	describe("validateSlashCommand with MCP servers", () => {
+		const mcpServers = [
+			createMockMcpServer({
+				name: "server",
+				prompts: [{ name: "prompt", description: "Test" }],
+			}),
+		]
+
+		it("should return full for exact MCP command match", () => {
+			const result = validateSlashCommand("mcp:server:prompt", {}, {}, undefined, undefined, mcpServers)
+			expect(result).toBe("full")
+		})
+
+		it("should return partial for partial MCP command match", () => {
+			const result = validateSlashCommand("mcp:server:pro", {}, {}, undefined, undefined, mcpServers)
+			expect(result).toBe("partial")
+		})
+
+		it("should return partial for server prefix only", () => {
+			const result = validateSlashCommand("mcp:serv", {}, {}, undefined, undefined, mcpServers)
+			expect(result).toBe("partial")
+		})
+
+		it("should return null for non-matching MCP command", () => {
+			const result = validateSlashCommand("mcp:unknown:cmd", {}, {}, undefined, undefined, mcpServers)
+			expect(result).toBe(null)
+		})
+	})
+
+	describe("slashCommandRegex with MCP format", () => {
+		it("should match MCP command format with colons", () => {
+			const text = "/mcp:server:prompt"
+			const match = text.match(slashCommandRegex)
+			expect(match).not.toBeNull()
+			expect(match![2]).toBe("/mcp:server:prompt")
+		})
+
+		it("should match MCP command in middle of text", () => {
+			const text = "Please run /mcp:server:prompt now"
+			const match = text.match(slashCommandRegex)
+			expect(match).not.toBeNull()
+			expect(match![2]).toBe("/mcp:server:prompt")
+		})
+
+		it("should not match MCP-like pattern in URL", () => {
+			const text = "http://example.com/mcp:test"
+			const match = text.match(slashCommandRegex)
+			// Should not match because / is not preceded by whitespace or start
+			expect(match).toBeNull()
+		})
+	})
+})
diff --git a/apps/vscode/webview-ui/src/utils/bannerUtils.tsx b/apps/vscode/webview-ui/src/utils/bannerUtils.tsx
new file mode 100644
index 0000000..7abbdf1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/bannerUtils.tsx
@@ -0,0 +1,35 @@
+import { BannerAction, BannerCardData } from "@shared/cline/banner"
+import { DynamicIcon } from "lucide-react/dynamic"
+import React from "react"
+import { BannerData } from "@/components/common/BannerCarousel"
+
+/**
+ * Convert BannerCardData to BannerData for rendering
+ */
+export function convertBannerData(
+	banner: BannerCardData,
+	handlers: {
+		onAction: (action: BannerAction) => void
+		onDismiss: (bannerId: string) => void
+	},
+): BannerData {
+	const { onAction, onDismiss } = handlers
+
+	// Filter and process actions
+	const filteredActions =
+		banner.actions?.map((action) => ({
+			label: action.title,
+			onClick: () => onAction(action),
+		})) || []
+
+	return {
+		id: banner.id,
+		icon: banner.icon ? (
+			<DynamicIcon className="size-4" name={banner.icon as React.ComponentProps<typeof DynamicIcon>["name"]} />
+		) : undefined,
+		title: banner.title,
+		description: banner.description,
+		actions: filteredActions.length > 0 ? filteredActions : undefined,
+		onDismiss: () => onDismiss(banner.id),
+	}
+}
diff --git a/apps/vscode/webview-ui/src/utils/context-mentions.ts b/apps/vscode/webview-ui/src/utils/context-mentions.ts
new file mode 100644
index 0000000..f62d2fd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/context-mentions.ts
@@ -0,0 +1,310 @@
+import { mentionRegex } from "@shared/context-mentions"
+import { Fzf } from "fzf"
+import { PLATFORM_CONFIG } from "@/config/platform.config"
+
+export interface SearchResult {
+	path: string
+	type: "file" | "folder"
+	label?: string
+	workspaceName?: string
+}
+
+export function insertMention(
+	text: string,
+	position: number,
+	value: string,
+	partialQueryLength: number = 0,
+): { newValue: string; mentionIndex: number } {
+	const beforeCursor = text.slice(0, position)
+	const afterCursor = text.slice(position)
+
+	// Find the position of the last '@' symbol before the cursor
+	const lastAtIndex = beforeCursor.lastIndexOf("@")
+
+	// For file/folder paths that contain spaces, wrap them in quotes
+	let formattedValue = value
+	if (value.startsWith("/") && value.includes(" ")) {
+		formattedValue = `"${value}"`
+	}
+	let newValue: string
+	let mentionIndex: number
+
+	if (lastAtIndex !== -1) {
+		// If there's an '@' symbol, replace everything after it with the new mention
+		const beforeAt = text.substring(0, lastAtIndex + 1)
+		const afterPartialQuery = text.substring(lastAtIndex + 1 + partialQueryLength)
+
+		// replace the partial query with the full mention
+		newValue = beforeAt + formattedValue + (afterPartialQuery.startsWith(" ") ? afterPartialQuery : " " + afterPartialQuery)
+		mentionIndex = lastAtIndex
+	} else {
+		// If there's no '@' symbol, insert the mention at the cursor position
+		newValue = beforeCursor + "@" + formattedValue + " " + afterCursor
+		mentionIndex = position
+	}
+
+	return { newValue, mentionIndex }
+}
+
+export function insertMentionDirectly(text: string, position: number, value: string): { newValue: string; mentionIndex: number } {
+	const beforeCursor = text.slice(0, position)
+	const afterCursor = text.slice(position)
+
+	// For file/folder paths that contain spaces, wrap them in quotes
+	let formattedValue = value
+	if (value.startsWith("/") && value.includes(" ")) {
+		formattedValue = `"${value}"`
+	}
+
+	const newValue = beforeCursor + "@" + formattedValue + " " + afterCursor
+	const mentionIndex = position
+	return { newValue, mentionIndex }
+}
+
+export function removeMention(text: string, position: number): { newText: string; newPosition: number } {
+	const beforeCursor = text.slice(0, position)
+	const afterCursor = text.slice(position)
+
+	// Check if we're at the end of a mention
+	const matchEnd = beforeCursor.match(new RegExp(mentionRegex.source + "$"))
+
+	if (matchEnd) {
+		// If we're at the end of a mention, remove it
+		const newText = text.slice(0, position - matchEnd[0].length) + afterCursor.replace(" ", "") // removes the first space after the mention
+		const newPosition = position - matchEnd[0].length
+		return { newText, newPosition }
+	}
+
+	// If we're not at the end of a mention, just return the original text and position
+	return { newText: text, newPosition: position }
+}
+
+export enum ContextMenuOptionType {
+	File = "file",
+	Folder = "folder",
+	Problems = "problems",
+	Terminal = "terminal",
+	URL = "url",
+	Git = "git",
+	NoResults = "noResults",
+}
+
+export interface ContextMenuQueryItem {
+	type: ContextMenuOptionType
+	value?: string
+	label?: string
+	description?: string
+	workspaceName?: string
+}
+
+function getContextMenuEntries(): ContextMenuOptionType[] {
+	const entries = [
+		ContextMenuOptionType.URL,
+		ContextMenuOptionType.Problems,
+		ContextMenuOptionType.Git,
+		ContextMenuOptionType.Folder,
+		ContextMenuOptionType.File,
+	]
+	if (PLATFORM_CONFIG.supportsTerminalMentions) {
+		entries.splice(2, 0, ContextMenuOptionType.Terminal)
+	}
+	return entries
+}
+
+export function getContextMenuOptionIndex(option: ContextMenuOptionType) {
+	return getContextMenuEntries().findIndex((item) => item === option)
+}
+
+export function getContextMenuOptions(
+	query: string,
+	selectedType: ContextMenuOptionType | null = null,
+	queryItems: ContextMenuQueryItem[],
+	dynamicSearchResults: SearchResult[] = [],
+): ContextMenuQueryItem[] {
+	const workingChanges: ContextMenuQueryItem = {
+		type: ContextMenuOptionType.Git,
+		value: "git-changes",
+		label: "Working changes",
+		description: "Current uncommitted changes",
+	}
+
+	const searchResultItems: ContextMenuQueryItem[] = dynamicSearchResults.map((result) => {
+		const formattedPath = result.path.startsWith("/") ? result.path : `/${result.path}`
+		const item = {
+			type: result.type === "folder" ? ContextMenuOptionType.Folder : ContextMenuOptionType.File,
+			value: formattedPath,
+			label: result.label,
+			description: formattedPath,
+			workspaceName: result.workspaceName,
+		}
+		return item
+	})
+
+	if (query === "") {
+		if (selectedType === ContextMenuOptionType.File) {
+			const files = searchResultItems
+				.filter((item) => item.type === ContextMenuOptionType.File)
+				.map((item) => ({
+					type: item.type,
+					value: item.value,
+					label: item.label,
+					description: item.description,
+					workspaceName: item.workspaceName,
+				}))
+			return files.length > 0 ? files : [{ type: ContextMenuOptionType.NoResults }]
+		}
+
+		if (selectedType === ContextMenuOptionType.Folder) {
+			const folders = searchResultItems
+				.filter((item) => item.type !== ContextMenuOptionType.File)
+				.map((item) => ({
+					type: ContextMenuOptionType.Folder,
+					value: item.value,
+					label: item.label,
+					description: item.description,
+					workspaceName: item.workspaceName,
+				}))
+			return folders.length > 0 ? folders : [{ type: ContextMenuOptionType.NoResults }]
+		}
+
+		if (selectedType === ContextMenuOptionType.Git) {
+			const commits = queryItems.filter((item) => item.type === ContextMenuOptionType.Git)
+			return commits.length > 0 ? [workingChanges, ...commits] : [workingChanges]
+		}
+
+		return getContextMenuEntries().map((type) => ({ type }))
+	}
+
+	const lowerQuery = query.toLowerCase()
+	const suggestions: ContextMenuQueryItem[] = []
+
+	// Check for top-level option matches
+	if ("git".startsWith(lowerQuery)) {
+		suggestions.push({
+			type: ContextMenuOptionType.Git,
+			label: "Git Commits",
+			description: "Search repository history",
+		})
+	} else if ("git-changes".startsWith(lowerQuery)) {
+		suggestions.push(workingChanges)
+	}
+	if ("problems".startsWith(lowerQuery)) {
+		suggestions.push({ type: ContextMenuOptionType.Problems })
+	}
+	if (query.startsWith("http")) {
+		suggestions.push({ type: ContextMenuOptionType.URL, value: query })
+	}
+
+	// Add exact SHA matches to suggestions
+	if (/^[a-f0-9]{7,40}$/i.test(lowerQuery)) {
+		const exactMatches = queryItems.filter(
+			(item) => item.type === ContextMenuOptionType.Git && item.value?.toLowerCase() === lowerQuery,
+		)
+		if (exactMatches.length > 0) {
+			suggestions.push(...exactMatches)
+		} else {
+			// If no exact match but valid SHA format, add as option
+			suggestions.push({
+				type: ContextMenuOptionType.Git,
+				value: lowerQuery,
+				label: `Commit ${lowerQuery}`,
+				description: "Git commit hash",
+			})
+		}
+	}
+
+	// Create searchable strings array for fzf
+	const searchableItems = queryItems.map((item) => ({
+		original: item,
+		searchStr: [item.value, item.label, item.description].filter(Boolean).join(" "),
+	}))
+
+	// Initialize fzf instance for fuzzy search
+	const fzf = new Fzf(searchableItems, {
+		selector: (item) => item.searchStr,
+	})
+
+	// Get fuzzy matching items
+	const matchingItems = query ? fzf.find(query).map((result) => result.item.original) : []
+
+	// Separate matches by type
+	const fileMatches = matchingItems.filter(
+		(item) => item.type === ContextMenuOptionType.File || item.type === ContextMenuOptionType.Folder,
+	)
+	const gitMatches = matchingItems.filter((item) => item.type === ContextMenuOptionType.Git)
+	const otherMatches = matchingItems.filter(
+		(item) =>
+			item.type !== ContextMenuOptionType.File &&
+			item.type !== ContextMenuOptionType.Folder &&
+			item.type !== ContextMenuOptionType.Git,
+	)
+
+	// If we have dynamic search results, prioritize those
+	if (dynamicSearchResults.length > 0) {
+		// Filter by selectedType if provided
+		let filteredDynamic: ContextMenuQueryItem[]
+		if (selectedType === ContextMenuOptionType.Folder) {
+			filteredDynamic = searchResultItems.filter((item) => item.type === ContextMenuOptionType.Folder)
+		} else if (selectedType === ContextMenuOptionType.File) {
+			filteredDynamic = searchResultItems.filter((item) => item.type === ContextMenuOptionType.File)
+		} else {
+			filteredDynamic = searchResultItems
+		}
+
+		const allItems = [...suggestions, ...filteredDynamic]
+		return allItems.length > 0 ? allItems : [{ type: ContextMenuOptionType.NoResults }]
+	}
+
+	// Otherwise fall back to local fuzzy search
+	if (suggestions.length > 0 || matchingItems.length > 0) {
+		const allItems = [...suggestions, ...fileMatches, ...gitMatches, ...otherMatches]
+
+		// Remove duplicates - normalize paths by ensuring all have leading slashes
+		const seen = new Set()
+		const deduped = allItems.filter((item) => {
+			// Normalize paths for deduplication by ensuring leading slashes
+			const normalizedValue = item.value && !item.value.startsWith("/") ? `/${item.value}` : item.value
+			const key = `${item.type}-${normalizedValue}`
+			if (seen.has(key)) {
+				return false
+			}
+			seen.add(key)
+			return true
+		})
+
+		return deduped.length > 0 ? deduped : [{ type: ContextMenuOptionType.NoResults }]
+	}
+
+	return [{ type: ContextMenuOptionType.NoResults }]
+}
+
+export function shouldShowContextMenu(text: string, position: number): boolean {
+	const beforeCursor = text.slice(0, position)
+	const atIndex = beforeCursor.lastIndexOf("@")
+
+	if (atIndex === -1) {
+		return false
+	}
+
+	const textAfterAt = beforeCursor.slice(atIndex + 1)
+
+	// Check if there's any whitespace after the '@'
+	if (/\s/.test(textAfterAt)) {
+		return false
+	}
+
+	// Don't show the menu if it's a URL
+	if (textAfterAt.toLowerCase().startsWith("http")) {
+		return false
+	}
+
+	// Don't show the menu if it's a problems or terminal
+	if (textAfterAt.toLowerCase().startsWith("problems") || textAfterAt.toLowerCase().startsWith("terminal")) {
+		return false
+	}
+
+	// NOTE: it's okay that menu shows when there's trailing punctuation since user could be inputting a path with marks
+
+	// Show the menu if there's just '@' or '@' followed by some text (but not a URL)
+	return true
+}
diff --git a/apps/vscode/webview-ui/src/utils/environmentColors.ts b/apps/vscode/webview-ui/src/utils/environmentColors.ts
new file mode 100644
index 0000000..d2b695e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/environmentColors.ts
@@ -0,0 +1,29 @@
+import type { Environment } from "../../../src/shared/config-types"
+
+/**
+ * Gets the appropriate color for the current environment.
+ *
+ * Environment color scheme:
+ * - Local: Yellow/orange (warning color) - indicates development/experimental environment
+ * - Staging: Blue (focus border) - indicates stable testing environment
+ * - Production: Default VSCode colors - standard appearance
+ *
+ * @param environment - The current environment (local, staging, or production)
+ * @param type - The type of color needed: "primary" for text/fills, "border" for borders
+ * @returns CSS variable string for the appropriate environment color
+ */
+export const getEnvironmentColor = (environment: Environment | undefined, type: "primary" | "border" = "primary"): string => {
+	if (type === "border") {
+		return environment === "local"
+			? "var(--vscode-activityWarningBadge-background)" // Yellow/orange for local
+			: environment === "staging"
+				? "var(--vscode-focusBorder)" // Blue for staging
+				: "var(--vscode-editorGroup-border)" // Default for production
+	}
+
+	return environment === "local"
+		? "var(--vscode-activityWarningBadge-background)" // Yellow/orange for local
+		: environment === "staging"
+			? "var(--vscode-focusBorder)" // Blue for staging
+			: "var(--vscode-foreground)" // Default for production
+}
diff --git a/apps/vscode/webview-ui/src/utils/format.ts b/apps/vscode/webview-ui/src/utils/format.ts
new file mode 100644
index 0000000..1004654
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/format.ts
@@ -0,0 +1,64 @@
+import prettyBytes from "pretty-bytes"
+
+export function formatLargeNumber(num: number): string {
+	if (num >= 1e9) {
+		return (num / 1e9).toFixed(1) + "b"
+	}
+	if (num >= 1e6) {
+		return (num / 1e6).toFixed(1) + "m"
+	}
+	if (num >= 1e3) {
+		return (num / 1e3).toFixed(1) + "k"
+	}
+	return num.toString()
+}
+
+// Helper to format cents as dollars with 2 decimal places
+export function formatDollars(cents?: number): string {
+	if (cents === undefined) {
+		return ""
+	}
+
+	return (cents / 100).toFixed(2)
+}
+
+/**
+ * Converts microcredits to credits for display purposes.
+ *
+ * The backend stores credit balances in microcredits (1 credit = 10,000 microcredits)
+ * to avoid floating point precision issues when performing calculations.
+ * This function converts the microcredits back to the user-facing credit amount.
+ *
+ * @param microcredits - The balance in microcredits from the backend
+ * @returns The balance in credits (typically displayed with 4 decimal places)
+ *
+ * @example
+ * formatCreditsBalance(50000) // returns 5.0000 (credits)
+ * formatCreditsBalance(12345) // returns 1.2345 (credits)
+ */
+export function formatCreditsBalance(microcredits: number): number {
+	return microcredits / 10000
+}
+
+export function formatTimestamp(timestamp: string): string {
+	const date = new Date(timestamp)
+
+	const dateFormatter = new Intl.DateTimeFormat("en-US", {
+		month: "2-digit",
+		day: "2-digit",
+		year: "2-digit",
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true,
+	})
+
+	return dateFormatter.format(date)
+}
+
+export function formatSize(bytes?: number) {
+	if (bytes === undefined) {
+		return "--kb"
+	}
+
+	return prettyBytes(bytes)
+}
diff --git a/apps/vscode/webview-ui/src/utils/getLanguageFromPath.ts b/apps/vscode/webview-ui/src/utils/getLanguageFromPath.ts
new file mode 100644
index 0000000..78e8f75
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/getLanguageFromPath.ts
@@ -0,0 +1,89 @@
+const extensionToLanguage: { [key: string]: string } = {
+	// Web technologies
+	html: "html",
+	htm: "html",
+	css: "css",
+	js: "javascript",
+	jsx: "jsx",
+	ts: "typescript",
+	tsx: "tsx",
+
+	// Backend languages
+	py: "python",
+	rb: "ruby",
+	php: "php",
+	java: "java",
+	cs: "csharp",
+	go: "go",
+	rs: "rust",
+	scala: "scala",
+	kt: "kotlin",
+	swift: "swift",
+
+	// Markup and data
+	json: "json",
+	xml: "xml",
+	yaml: "yaml",
+	yml: "yaml",
+	md: "markdown",
+	csv: "csv",
+
+	// Shell and scripting
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	ps1: "powershell",
+
+	// Configuration
+	toml: "toml",
+	ini: "ini",
+	cfg: "ini",
+	conf: "ini",
+
+	// Other
+	sql: "sql",
+	graphql: "graphql",
+	gql: "graphql",
+	tex: "latex",
+	svg: "svg",
+	txt: "text",
+
+	// C-family languages
+	c: "c",
+	cpp: "cpp",
+	h: "c",
+	hpp: "cpp",
+
+	// Functional languages
+	hs: "haskell",
+	lhs: "haskell",
+	elm: "elm",
+	clj: "clojure",
+	cljs: "clojure",
+	erl: "erlang",
+	ex: "elixir",
+	exs: "elixir",
+
+	// Mobile development
+	dart: "dart",
+	m: "objectivec",
+	mm: "objectivec",
+
+	// Game development
+	lua: "lua",
+	gd: "gdscript", // Godot
+	unity: "csharp", // Unity (using C#)
+
+	// Data science and ML
+	r: "r",
+	jl: "julia",
+	ipynb: "jupyter", // Jupyter notebooks
+}
+
+// Example usage:
+// console.log(getLanguageFromPath('/path/to/file.js')); // Output: javascript
+
+export function getLanguageFromPath(path: string): string | undefined {
+	const extension = path.split(".").pop()?.toLowerCase() || ""
+	return extensionToLanguage[extension]
+}
diff --git a/apps/vscode/webview-ui/src/utils/hooks.ts b/apps/vscode/webview-ui/src/utils/hooks.ts
new file mode 100644
index 0000000..3a3dc93
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/hooks.ts
@@ -0,0 +1,90 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react"
+import { detectMetaKeyChar, detectOS, unknown } from "./platformUtils"
+
+export const useMetaKeyDetection = (platform: string) => {
+	const [metaKeyChar, setMetaKeyChar] = useState(unknown)
+	const [os, setOs] = useState(unknown)
+
+	useEffect(() => {
+		const detectedMetaKeyChar = detectMetaKeyChar(platform)
+		const detectedOs = detectOS(platform)
+		setMetaKeyChar(detectedMetaKeyChar)
+		setOs(detectedOs)
+	}, [platform])
+
+	return [os, metaKeyChar]
+}
+
+export const useShortcut = (shortcut: string, callback: (...args: unknown[]) => void, options = { disableTextInputs: true }) => {
+	const callbackRef = useRef(callback)
+	const [keyCombo, setKeyCombo] = useState<string[]>([])
+
+	useLayoutEffect(() => {
+		callbackRef.current = callback
+	})
+
+	const handleKeyDown = useCallback(
+		(event: KeyboardEvent) => {
+			const isTextInput =
+				event.target instanceof HTMLTextAreaElement ||
+				(event.target instanceof HTMLInputElement && (!event.target.type || event.target.type === "text")) ||
+				(event.target as HTMLElement).isContentEditable
+
+			const modifierMap: { [key: string]: boolean } = {
+				Control: event.ctrlKey,
+				Alt: event.altKey,
+				Meta: event.metaKey, // alias for Command
+				Shift: event.shiftKey,
+			}
+
+			if (event.repeat) {
+				return null
+			}
+
+			if (options.disableTextInputs && isTextInput) {
+				return event.stopPropagation()
+			}
+
+			if (shortcut.includes("+")) {
+				const keyArray = shortcut.split("+")
+
+				if (Object.keys(modifierMap).includes(keyArray[0])) {
+					const finalKey = keyArray.pop()
+					if (!finalKey) {
+						return
+					}
+
+					if (keyArray.every((k) => modifierMap[k]) && finalKey.toLowerCase() === event.key.toLowerCase()) {
+						event.preventDefault()
+						return callbackRef.current(event)
+					}
+				} else {
+					if (keyArray[keyCombo.length] === event.key) {
+						if (keyArray[keyArray.length - 1] === event.key && keyCombo.length === keyArray.length - 1) {
+							callbackRef.current(event)
+							return setKeyCombo([])
+						}
+
+						return setKeyCombo((prevCombo) => [...prevCombo, event.key])
+					}
+					if (keyCombo.length > 0) {
+						return setKeyCombo([])
+					}
+				}
+			}
+
+			if (shortcut === event.key) {
+				return callbackRef.current(event)
+			}
+		},
+		[keyCombo.length, options.disableTextInputs, shortcut],
+	)
+
+	useEffect(() => {
+		window.addEventListener("keydown", handleKeyDown)
+
+		return () => {
+			window.removeEventListener("keydown", handleKeyDown)
+		}
+	}, [handleKeyDown])
+}
diff --git a/apps/vscode/webview-ui/src/utils/mcp.ts b/apps/vscode/webview-ui/src/utils/mcp.ts
new file mode 100644
index 0000000..5d9e7d2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/mcp.ts
@@ -0,0 +1,44 @@
+import { McpResource, McpResourceTemplate } from "@shared/mcp"
+
+/**
+ * Matches a URI against an array of URI templates and returns the matching template
+ * @param uri The URI to match
+ * @param templates Array of URI templates to match against
+ * @returns The matching template or undefined if no match is found
+ */
+function findMatchingTemplate(uri: string, templates: McpResourceTemplate[] = []): McpResourceTemplate | undefined {
+	return templates.find((template) => {
+		// Convert template to regex pattern
+		const pattern = String(template.uriTemplate)
+			// First escape special regex characters
+			.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+			// Then replace {param} with ([^/]+) to match any non-slash characters
+			// We need to use \{ and \} because we just escaped them
+			.replace(/\\\{([^}]+)\\\}/g, "([^/]+)")
+
+		const regex = new RegExp(`^${pattern}$`)
+		return regex.test(uri)
+	})
+}
+
+/**
+ * Finds either an exact resource match or a matching template for a given URI
+ * @param uri The URI to find a match for
+ * @param resources Array of concrete resources
+ * @param templates Array of resource templates
+ * @returns The matching resource, template, or undefined
+ */
+export function findMatchingResourceOrTemplate(
+	uri: string,
+	resources: McpResource[] = [],
+	templates: McpResourceTemplate[] = [],
+): McpResource | McpResourceTemplate | undefined {
+	// First try to find an exact resource match
+	const exactMatch = resources.find((resource) => resource.uri === uri)
+	if (exactMatch) {
+		return exactMatch
+	}
+
+	// If no exact match, try to find a matching template
+	return findMatchingTemplate(uri, templates)
+}
diff --git a/apps/vscode/webview-ui/src/utils/platformUtils.ts b/apps/vscode/webview-ui/src/utils/platformUtils.ts
new file mode 100644
index 0000000..5a14e62
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/platformUtils.ts
@@ -0,0 +1,64 @@
+export const unknown = "Unknown"
+
+const platforms = {
+	windows: /win32/,
+	mac: /darwin/,
+	linux: /linux/,
+}
+
+export const detectOS = (platform: string) => {
+	let detectedOs = unknown
+	if (platform.match(platforms.windows)) {
+		detectedOs = "windows"
+	} else if (platform.match(platforms.mac)) {
+		detectedOs = "mac"
+	} else if (platform.match(platforms.linux)) {
+		detectedOs = "linux"
+	}
+	return detectedOs
+}
+
+export const detectMetaKeyChar = (platform: string) => {
+	if (platform.match(platforms.mac)) {
+		return "CMD"
+	}
+	if (platform.match(platforms.windows)) {
+		return "Win"
+	}
+	if (platform.match(platforms.linux)) {
+		return "Alt"
+	}
+	return "CMD"
+}
+
+const userAgent = navigator?.userAgent || ""
+
+const isChrome = userAgent.indexOf("Chrome") >= 0
+
+export const isSafari = !isChrome && userAgent.indexOf("Safari") >= 0
+
+declare const __NODE_PLATFORM__: string
+
+/**
+ * Gets the current platform: 'windows', 'mac', or 'linux'
+ * Defaults to 'linux' if platform cannot be determined
+ */
+export function getCurrentPlatform() {
+	// Fallback to linux if platform is not available
+	switch (__NODE_PLATFORM__) {
+		case "win32":
+			return "windows"
+		case "darwin":
+			return "mac"
+		default:
+			return "linux"
+	}
+}
+
+/**
+ * Checks if the platform is macOS or Linux
+ * @returns true if platform is darwin (macOS) or linux
+ */
+export const isMacOSOrLinux = (): boolean => {
+	return getCurrentPlatform() !== "windows" // Non-Windows
+}
diff --git a/apps/vscode/webview-ui/src/utils/slash-commands.ts b/apps/vscode/webview-ui/src/utils/slash-commands.ts
new file mode 100644
index 0000000..2c59850
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/slash-commands.ts
@@ -0,0 +1,264 @@
+import type { McpServer } from "@shared/mcp"
+import { PLATFORM_CONFIG, PlatformType } from "@/config/platform.config"
+import { BASE_SLASH_COMMANDS, type SlashCommand, VSCODE_ONLY_COMMANDS } from "../../../src/shared/slashCommands.ts"
+
+export type { SlashCommand }
+
+const DEFAULT_SLASH_COMMANDS: SlashCommand[] =
+	PLATFORM_CONFIG.type === PlatformType.VSCODE ? [...BASE_SLASH_COMMANDS, ...VSCODE_ONLY_COMMANDS] : BASE_SLASH_COMMANDS
+
+function getWorkflowCommands(
+	localWorkflowToggles: Record<string, boolean>,
+	globalWorkflowToggles: Record<string, boolean>,
+	remoteWorkflowToggles?: Record<string, boolean>,
+	remoteWorkflows?: any[],
+): SlashCommand[] {
+	const { workflows: localWorkflows, nameSet: localWorkflowNames } = Object.entries(localWorkflowToggles)
+		.filter(([_, enabled]) => enabled)
+		.reduce(
+			(acc, [filePath, _]) => {
+				const fileName = filePath.replace(/^.*[/\\]/, "")
+
+				// Add to array of workflows
+				acc.workflows.push({
+					name: fileName,
+					section: "custom",
+				} as SlashCommand)
+
+				// Add to set of names
+				acc.nameSet.add(fileName)
+
+				return acc
+			},
+			{ workflows: [] as SlashCommand[], nameSet: new Set<string>() },
+		)
+
+	const globalWorkflows = Object.entries(globalWorkflowToggles)
+		.filter(([_, enabled]) => enabled)
+		.flatMap(([filePath, _]) => {
+			const fileName = filePath.replace(/^.*[/\\]/, "")
+
+			// skip if a local workflow with the same name exists
+			if (localWorkflowNames.has(fileName)) {
+				return []
+			}
+
+			return [
+				{
+					name: fileName,
+					section: "custom",
+				},
+			] as SlashCommand[]
+		})
+
+	// Add remote workflows that are enabled
+	const remoteWorkflowCommands: SlashCommand[] = []
+	if (remoteWorkflows && remoteWorkflowToggles) {
+		for (const workflow of remoteWorkflows) {
+			// Include if alwaysEnabled or if toggle is not explicitly false
+			const enabled = workflow.alwaysEnabled || remoteWorkflowToggles[workflow.name] !== false
+			if (enabled) {
+				remoteWorkflowCommands.push({
+					name: workflow.name,
+					section: "custom",
+				})
+			}
+		}
+	}
+
+	const workflows = [...localWorkflows, ...globalWorkflows, ...remoteWorkflowCommands]
+	return workflows
+}
+
+/**
+ * Gets MCP prompt commands from connected MCP servers
+ * Format: mcp:<server-name>:<prompt-name>
+ */
+export function getMcpPromptCommands(mcpServers: McpServer[] = []): SlashCommand[] {
+	const commands: SlashCommand[] = []
+
+	for (const server of mcpServers) {
+		if (server.status !== "connected" || !server.prompts) {
+			continue
+		}
+
+		for (const prompt of server.prompts) {
+			commands.push({
+				name: `mcp:${server.name}:${prompt.name}`,
+				description: prompt.description || prompt.title || `MCP prompt from ${server.name}`,
+				section: "mcp",
+			})
+		}
+	}
+
+	return commands
+}
+
+// Regex for detecting slash commands in text
+// Must be at start of string OR preceded by whitespace to avoid matching URLs/paths
+// e.g., matches "/newtask" or "text /newtask" but not "http://example.com/newtask"
+// Note: Colons are allowed to support MCP prompt commands like /mcp:server:prompt
+export const slashCommandRegex = /(^|\s)(\/[a-zA-Z0-9_.:@-]+)(?=\s|$)/
+export const slashCommandRegexGlobal = new RegExp(slashCommandRegex.source, "g")
+// Regex for detecting a slash command at the end of text (for deletion)
+// Must be at start OR preceded by whitespace, captures the whole command including slash
+export const slashCommandDeleteRegex = /(^|\s)(\/[a-zA-Z0-9_.:@-]+)$/
+
+/**
+ * Removes a slash command at the cursor position
+ */
+export function removeSlashCommand(text: string, position: number): { newText: string; newPosition: number } {
+	const beforeCursor = text.slice(0, position)
+	const afterCursor = text.slice(position)
+
+	// Check if we're at the end of a slash command (anywhere in text, not just at start)
+	const matchEnd = beforeCursor.match(slashCommandDeleteRegex)
+
+	if (matchEnd) {
+		// matchEnd[1] is the whitespace or empty string before the slash
+		// matchEnd[2] is the slash command (e.g., "/newtask")
+		const slashCommand = matchEnd[2]
+		const newText = text.slice(0, position - slashCommand.length) + afterCursor.replace(" ", "") // removes the first space after the command
+		const newPosition = position - slashCommand.length
+		return { newText, newPosition }
+	}
+
+	// If we're not at the end of a slash command, just return the original text and position
+	return { newText: text, newPosition: position }
+}
+
+/**
+ * Determines whether the slash command menu should be displayed based on text input.
+ * Only shows for the FIRST valid slash command position in the message - subsequent
+ * slash commands won't trigger suggestions since only one is processed per message.
+ */
+export function shouldShowSlashCommandsMenu(text: string, cursorPosition: number): boolean {
+	const beforeCursor = text.slice(0, cursorPosition)
+
+	// first check if there is a slash before the cursor
+	const slashIndex = beforeCursor.lastIndexOf("/")
+
+	if (slashIndex === -1) {
+		return false
+	}
+
+	// Check if slash is preceded by whitespace or is at the beginning
+	// This allows slash commands anywhere in the message, similar to @ mentions
+	const charBeforeSlash = slashIndex > 0 ? beforeCursor[slashIndex - 1] : null
+	if (charBeforeSlash !== null && !/\s/.test(charBeforeSlash)) {
+		return false
+	}
+
+	// potential partial or full command
+	const textAfterSlash = beforeCursor.slice(slashIndex + 1)
+
+	// don't show menu if there's whitespace after the slash but before the cursor
+	if (/\s/.test(textAfterSlash)) {
+		return false
+	}
+
+	// Only show suggestions for the FIRST slash command in the message.
+	// Check if there's already a valid slash command earlier in the text.
+	// A valid earlier slash command is one that: starts at beginning or after whitespace,
+	// and is followed by whitespace (meaning it's complete).
+	// Note: Colons are allowed to support MCP prompt commands like /mcp:server:prompt
+	const firstSlashCommandRegex = /(^|\s)\/[a-zA-Z0-9_.:@-]+\s/
+	const textBeforeCurrentSlash = text.slice(0, slashIndex)
+	if (firstSlashCommandRegex.test(textBeforeCurrentSlash)) {
+		return false
+	}
+
+	return true
+}
+
+/**
+ * Gets filtered slash commands that match the current input
+ */
+export function getMatchingSlashCommands(
+	query: string,
+	localWorkflowToggles: Record<string, boolean> = {},
+	globalWorkflowToggles: Record<string, boolean> = {},
+	remoteWorkflowToggles?: Record<string, boolean>,
+	remoteWorkflows?: any[],
+	mcpServers: McpServer[] = [],
+): SlashCommand[] {
+	const workflowCommands = getWorkflowCommands(
+		localWorkflowToggles,
+		globalWorkflowToggles,
+		remoteWorkflowToggles,
+		remoteWorkflows,
+	)
+	const mcpPromptCommands = getMcpPromptCommands(mcpServers)
+	const allCommands = [...DEFAULT_SLASH_COMMANDS, ...workflowCommands, ...mcpPromptCommands]
+
+	if (!query) {
+		return allCommands
+	}
+
+	// filter commands that start with the query (case insensitive)
+	return allCommands.filter((cmd) => cmd.name.toLowerCase().startsWith(query.toLowerCase()))
+}
+
+/**
+ * Insert a slash command at position or replace partial command
+ */
+export function insertSlashCommand(
+	text: string,
+	commandName: string,
+	partialCommandLength: number,
+	cursorPosition: number,
+): { newValue: string; commandIndex: number } {
+	// Find the slash nearest to cursor (before cursor position)
+	const beforeCursor = text.slice(0, cursorPosition)
+	const slashIndex = beforeCursor.lastIndexOf("/")
+
+	const beforeSlash = text.substring(0, slashIndex + 1)
+	const afterPartialCommand = text.substring(slashIndex + 1 + partialCommandLength)
+
+	// replace the partial command with the full command
+	const newValue =
+		beforeSlash + commandName + (afterPartialCommand.startsWith(" ") ? afterPartialCommand : " " + afterPartialCommand)
+
+	return { newValue, commandIndex: slashIndex }
+}
+
+/**
+ * Determines the validation state of a slash command
+ * Returns partial if we have a partial match against valid commands, or full for full match
+ */
+export function validateSlashCommand(
+	command: string,
+	localWorkflowToggles: Record<string, boolean> = {},
+	globalWorkflowToggles: Record<string, boolean> = {},
+	remoteWorkflowToggles?: Record<string, boolean>,
+	remoteWorkflows?: any[],
+	mcpServers: McpServer[] = [],
+): "full" | "partial" | null {
+	if (!command) {
+		return null
+	}
+
+	const workflowCommands = getWorkflowCommands(
+		localWorkflowToggles,
+		globalWorkflowToggles,
+		remoteWorkflowToggles,
+		remoteWorkflows,
+	)
+	const mcpPromptCommands = getMcpPromptCommands(mcpServers)
+	const allCommands = [...DEFAULT_SLASH_COMMANDS, ...workflowCommands, ...mcpPromptCommands]
+
+	// case insensitive matching
+	const exactMatch = allCommands.some((cmd) => cmd.name.toLowerCase() === command.toLowerCase())
+
+	if (exactMatch) {
+		return "full"
+	}
+
+	const partialMatch = allCommands.some((cmd) => cmd.name.toLowerCase().startsWith(command.toLowerCase()))
+
+	if (partialMatch) {
+		return "partial"
+	}
+
+	return null // no match
+}
diff --git a/apps/vscode/webview-ui/src/utils/useDebounceEffect.ts b/apps/vscode/webview-ui/src/utils/useDebounceEffect.ts
new file mode 100644
index 0000000..6d0d9b5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/useDebounceEffect.ts
@@ -0,0 +1,41 @@
+import type { DependencyList } from "react"
+import { useEffect, useRef } from "react"
+
+type VoidFn = () => void
+
+/**
+ * Runs `effectRef.current()` after `delay` ms whenever any of the `deps` change,
+ * but cancels/re-schedules if they change again before the delay.
+ */
+export function useDebounceEffect(effect: VoidFn, delay: number, deps: DependencyList) {
+	const callbackRef = useRef<VoidFn>(effect)
+	const timeoutRef = useRef<NodeJS.Timeout | null>(null)
+
+	// Keep callbackRef current
+	useEffect(() => {
+		callbackRef.current = effect
+	}, [effect])
+
+	useEffect(() => {
+		// Clear any queued call
+		if (timeoutRef.current) {
+			clearTimeout(timeoutRef.current)
+		}
+
+		// Schedule a new call
+		timeoutRef.current = setTimeout(() => {
+			// always call the *latest* version of effect
+			callbackRef.current()
+		}, delay)
+
+		// Cleanup on unmount or next effect
+		return () => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current)
+			}
+		}
+
+		// We want to re‐schedule if any item in `deps` changed,
+		// or if `delay` changed.
+	}, [delay, ...deps])
+}
diff --git a/apps/vscode/webview-ui/src/utils/validate.ts b/apps/vscode/webview-ui/src/utils/validate.ts
new file mode 100644
index 0000000..60476fc
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/validate.ts
@@ -0,0 +1,176 @@
+import { ApiConfiguration } from "@shared/api"
+import { Mode } from "@shared/storage/types"
+import { getModeSpecificFields } from "@/components/settings/utils/providerUtils"
+
+export function validateApiConfiguration(currentMode: Mode, apiConfiguration?: ApiConfiguration): string | undefined {
+	if (apiConfiguration) {
+		const { apiProvider, openAiModelId, togetherModelId, ollamaModelId, lmStudioModelId, vsCodeLmModelSelector } =
+			getModeSpecificFields(apiConfiguration, currentMode)
+
+		switch (apiProvider) {
+			case "anthropic":
+				if (!apiConfiguration.apiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "bedrock":
+				if (!apiConfiguration.awsRegion) {
+					return "You must choose a region to use with AWS Bedrock."
+				}
+				break
+			case "openrouter":
+				if (!apiConfiguration.openRouterApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "vertex":
+				if (!apiConfiguration.vertexProjectId || !apiConfiguration.vertexRegion) {
+					return "You must provide a valid Google Cloud Project ID and Region."
+				}
+				break
+			case "gemini":
+				if (!apiConfiguration.geminiApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "openai-native":
+				if (!apiConfiguration.openAiNativeApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "deepseek":
+				if (!apiConfiguration.deepSeekApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "xai":
+				if (!apiConfiguration.xaiApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "qwen":
+				if (!apiConfiguration.qwenApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "doubao":
+				if (!apiConfiguration.doubaoApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "mistral":
+				if (!apiConfiguration.mistralApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "cline":
+				break
+			case "openai-codex":
+				// Authentication is handled via OAuth, not API key
+				// Validation happens at runtime in the handler
+				break
+			case "openai":
+				if (
+					!apiConfiguration.openAiBaseUrl ||
+					(!apiConfiguration.openAiApiKey && !apiConfiguration.azureIdentity) ||
+					!openAiModelId
+				) {
+					return "You must provide a valid base URL, API key, and model ID."
+				}
+				break
+			case "requesty":
+				if (!apiConfiguration.requestyApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "fireworks":
+				if (!apiConfiguration.fireworksApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "together":
+				if (!apiConfiguration.togetherApiKey || !togetherModelId) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "ollama":
+				if (!ollamaModelId) {
+					return "You must provide a valid model ID."
+				}
+				break
+			case "lmstudio":
+				if (!lmStudioModelId) {
+					return "You must provide a valid model ID."
+				}
+				break
+			case "vscode-lm":
+				if (!vsCodeLmModelSelector) {
+					return "You must provide a valid model selector."
+				}
+				break
+			case "moonshot":
+				if (!apiConfiguration.moonshotApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "nebius":
+				if (!apiConfiguration.nebiusApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "asksage":
+				if (!apiConfiguration.asksageApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "sambanova":
+				if (!apiConfiguration.sambanovaApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "sapaicore":
+				if (!apiConfiguration.sapAiCoreBaseUrl) {
+					return "You must provide a valid Base URL key or choose a different provider."
+				}
+				if (!apiConfiguration.sapAiCoreClientId) {
+					return "You must provide a valid Client Id or choose a different provider."
+				}
+				if (!apiConfiguration.sapAiCoreClientSecret) {
+					return "You must provide a valid Client Secret or choose a different provider."
+				}
+				if (!apiConfiguration.sapAiCoreTokenUrl) {
+					return "You must provide a valid Auth URL or choose a different provider."
+				}
+				break
+			case "zai":
+				if (!apiConfiguration.zaiApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "dify":
+				if (!apiConfiguration.difyBaseUrl) {
+					return "You must provide a valid Base URL or choose a different provider."
+				}
+				if (!apiConfiguration.difyApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "minimax":
+				if (!apiConfiguration.minimaxApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+			case "hicap":
+				if (!apiConfiguration.hicapApiKey) {
+					return "You must provide a valid API key"
+				}
+				break
+			case "wandb":
+				if (!apiConfiguration.wandbApiKey) {
+					return "You must provide a valid API key or choose a different provider."
+				}
+				break
+		}
+	}
+	return undefined
+}
diff --git a/apps/vscode/webview-ui/src/utils/vscStyles.ts b/apps/vscode/webview-ui/src/utils/vscStyles.ts
new file mode 100644
index 0000000..f8a099b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/utils/vscStyles.ts
@@ -0,0 +1,9 @@
+export const VSC_FOREGROUND = "--vscode-foreground"
+export const VSC_DESCRIPTION_FOREGROUND = "--vscode-descriptionForeground"
+export const VSC_BUTTON_BACKGROUND = "--vscode-button-background"
+export const VSC_BUTTON_FOREGROUND = "--vscode-button-foreground"
+export const VSC_TITLEBAR_INACTIVE_FOREGROUND = "--vscode-titleBar-inactiveForeground"
+
+export function getAsVar(varName: string): string {
+	return `var(${varName})`
+}
diff --git a/apps/vscode/webview-ui/src/vite-env.d.ts b/apps/vscode/webview-ui/src/vite-env.d.ts
new file mode 100644
index 0000000..11f02fe
--- /dev/null
+++ b/apps/vscode/webview-ui/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/apps/vscode/webview-ui/tailwind.config.mjs b/apps/vscode/webview-ui/tailwind.config.mjs
new file mode 100644
index 0000000..75dc74d
--- /dev/null
+++ b/apps/vscode/webview-ui/tailwind.config.mjs
@@ -0,0 +1,117 @@
+import { heroui } from "@heroui/react"
+
+/** @type {import('tailwindcss').Config} */
+
+export default {
+	content: {
+		relative: true,
+		files: ["./src/**/*.{jsx,tsx,mdx}", "./node_modules/@heroui/theme/dist/**/*.{ts,tsx}"],
+	},
+	theme: {
+		extend: {
+			fontFamily: {
+				"azeret-mono": ['"Azeret Mono"', "monospace"],
+			},
+			colors: {
+				background: "var(--vscode-editor-background)",
+				border: {
+					DEFAULT: "var(--vscode-focusBorder)",
+					panel: "var(--vscode-panel-border)",
+				},
+				foreground: "var(--vscode-foreground)",
+				shadow: "var(--vscode-widget-shadow)",
+				code: {
+					background: "var(--vscode-editor-background)",
+					foreground: "var(--vscode-editor-foreground)",
+					border: "var(--vscode-editor-border)",
+				},
+				sidebar: {
+					background: "var(--vscode-sideBar-background)",
+					foreground: "var(--vscode-sideBar-foreground)",
+				},
+				input: {
+					foreground: "var(--vscode-input-foreground)",
+					background: "var(--vscode-input-background)",
+					border: "var(--vscode-input-border)",
+					placeholder: "var(--vscode-input-placeholderForeground)",
+				},
+				selection: {
+					DEFAULT: "var(--vscode-list-activeSelectionBackground)",
+					foreground: "var(--vscode-list-activeSelectionForeground)",
+				},
+				button: {
+					background: {
+						DEFAULT: "var(--vscode-button-background)",
+						hover: "var(--vscode-button-hoverBackground)",
+					},
+					foreground: "var(--vscode-button-foreground)",
+					separator: "var(--vscode-button-separator)",
+					secondary: {
+						background: {
+							DEFAULT: "var(--vscode-button-secondaryBackground)",
+							hover: "var(--vscode-button-secondaryHoverBackground)",
+						},
+						foreground: "var(--vscode-button-secondaryForeground)",
+					},
+				},
+				muted: {
+					DEFAULT: "var(--vscode-editor-foldBackground)",
+					foreground: "var(--vscode-editor-foldPlaceholderForeground)",
+				},
+				menu: {
+					DEFAULT: "var(--vscode-menu-background)",
+					foreground: "var(--vscode-menu-foreground)",
+					border: "var(--vscode-menu-border)",
+					shadow: "var(--vscode-menu-shadow)",
+				},
+				link: {
+					DEFAULT: "var(--vscode-textLink-foreground)",
+					hover: "var(--vscode-textLink-activeForeground)",
+				},
+				list: {
+					background: {
+						hover: "var(--vscode-list-hoverBackground)",
+					},
+				},
+				badge: {
+					foreground: "var(--vscode-badge-foreground)",
+					background: "var(--vscode-badge-background)",
+				},
+				banner: {
+					background: "var(--vscode-banner-background)",
+					foreground: "var(--vscode-banner-foreground)",
+					icon: "var(--vscode-banner-iconForeground)",
+				},
+				toolbar: {
+					DEFAULT: "var(--vscode-toolbar-background)",
+					hover: "var(--vscode-toolbar-hoverBackground)",
+				},
+				error: "var(--vscode-errorForeground)",
+				description: "var(--vscode-descriptionForeground)",
+				success: "var(--vscode-charts-green)",
+				warning: "var(--vscode-charts-yellow)",
+			},
+			fontSize: {
+				xl: "calc(2 * var(--vscode-font-size))",
+				lg: "calc(1.5 * var(--vscode-font-size))",
+				md: "calc(1.25 * var(--vscode-font-size))",
+				sm: "var(--vscode-font-size)",
+				xs: "calc(0.85 * var(--vscode-font-size))",
+				xxs: "calc(0.75 * var(--vscode-font-size))",
+			},
+		},
+	},
+	darkMode: "class",
+	plugins: [
+		heroui({
+			defaultTheme: "vscode",
+			themes: {
+				vscode: {
+					colors: {
+						background: "",
+					},
+				},
+			},
+		}),
+	],
+}
diff --git a/apps/vscode/webview-ui/tsconfig.app.json b/apps/vscode/webview-ui/tsconfig.app.json
new file mode 100644
index 0000000..8599929
--- /dev/null
+++ b/apps/vscode/webview-ui/tsconfig.app.json
@@ -0,0 +1,71 @@
+{
+	"compilerOptions": {
+		"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+		"target": "ES2022",
+		"useDefineForClassFields": true,
+		"lib": [
+			"ES2022",
+			"DOM",
+			"DOM.Iterable"
+		],
+		"types": [
+			"vitest/globals",
+			"@testing-library/jest-dom"
+		],
+		"module": "ESNext",
+		"skipLibCheck": true,
+
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"isolatedModules": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+		"jsx": "react-jsx",
+
+		/* Linting */
+		"strict": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true,
+
+		/* Aliasing */
+		"paths": {
+			// Pin React types to webview-ui's own React 18 copy. In the bun
+			// workspace, @testing-library/react's optional peer pulls
+			// @types/react@19 into a resolvable location, and tsc would otherwise
+			// mix it with the toolkit's React 18 types (breaking JSX: React 19
+			// dropped Component.refs). These aliases force a single React 18 type.
+			"react": [
+				"./node_modules/@types/react"
+			],
+			"react-dom": [
+				"./node_modules/@types/react-dom"
+			],
+			"@/*": [
+				"./src/*"
+			],
+			"@components/*": [
+				"./src/components/*"
+			],
+			"@context/*": [
+				"./src/context/*"
+			],
+			"@shared/*": [
+				"../src/shared/*"
+			],
+			"@utils/*": [
+				"./src/utils/*"
+			]
+		}
+	},
+	"include": [
+		"src"
+	],
+	"exclude": [
+		"src/**/*.test.tsx",
+		"src/**/*.test.ts",
+		"src/**/*.spec.tsx",
+		"src/**/*.spec.ts",
+		"src/**/__tests__/**"
+	]
+}
diff --git a/apps/vscode/webview-ui/tsconfig.json b/apps/vscode/webview-ui/tsconfig.json
new file mode 100644
index 0000000..dbd74d2
--- /dev/null
+++ b/apps/vscode/webview-ui/tsconfig.json
@@ -0,0 +1,18 @@
+{
+	"files": [],
+	"references": [
+		{
+			"path": "./tsconfig.app.json"
+		},
+		{
+			"path": "./tsconfig.node.json"
+		}
+	],
+	"compilerOptions": {
+		"paths": {
+			"@/*": [
+				"./src/*"
+			]
+		}
+	}
+}
diff --git a/apps/vscode/webview-ui/tsconfig.node.json b/apps/vscode/webview-ui/tsconfig.node.json
new file mode 100644
index 0000000..1ae3865
--- /dev/null
+++ b/apps/vscode/webview-ui/tsconfig.node.json
@@ -0,0 +1,28 @@
+{
+	"compilerOptions": {
+		"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+		"target": "ES2022",
+		"lib": [
+			"ES2023"
+		],
+		"module": "ESNext",
+		"skipLibCheck": true,
+
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"isolatedModules": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true
+	},
+	"include": [
+		"vite.config.ts"
+	]
+}
diff --git a/apps/vscode/webview-ui/vite.config.ts b/apps/vscode/webview-ui/vite.config.ts
new file mode 100644
index 0000000..b80bd30
--- /dev/null
+++ b/apps/vscode/webview-ui/vite.config.ts
@@ -0,0 +1,163 @@
+/// <reference types="vitest/config" />
+
+import { writeFileSync } from "node:fs"
+import tailwindcss from "@tailwindcss/vite"
+import react from "@vitejs/plugin-react-swc"
+import { resolve } from "path"
+import { defineConfig, loadEnv, type Plugin, ViteDevServer } from "vite"
+
+// Custom plugin to write the server port to a file
+const writePortToFile = (): Plugin => {
+	return {
+		name: "write-port-to-file",
+		configureServer(server: ViteDevServer) {
+			server.httpServer?.once("listening", () => {
+				const address = server.httpServer?.address()
+				const port = typeof address === "object" && address ? address.port : null
+
+				if (port) {
+					const portFilePath = resolve(__dirname, ".vite-port")
+					writeFileSync(portFilePath, port.toString())
+				} else {
+					console.warn("[writePortToFile] Could not determine server port")
+				}
+			})
+		},
+	}
+}
+
+const isDevBuild = process.argv.includes("--dev-build")
+
+// VS Code launch configurations load apps/vscode/.env for the extension host,
+// but pre-launch webview tasks run as separate processes. Load the parent .env
+// here so F5 builds get the same build-time constants in the webview bundle.
+const parentEnv = loadEnv(process.env.NODE_ENV || "development", resolve(__dirname, ".."), "")
+for (const [key, value] of Object.entries(parentEnv)) {
+	process.env[key] ??= value
+}
+
+// Valid platforms, these should the keys in platform-configs.json
+const VALID_PLATFORMS = ["vscode", "standalone"]
+const platform = process.env.PLATFORM || "vscode" // Default to vscode
+
+if (!VALID_PLATFORMS.includes(platform)) {
+	throw new Error(`Invalid PLATFORM "${platform}". Must be one of: ${VALID_PLATFORMS.join(", ")}`)
+}
+console.log("Building webview for", platform)
+
+export default defineConfig({
+	base: "./",
+	plugins: [react(), tailwindcss(), writePortToFile()],
+	test: {
+		environment: "jsdom",
+		globals: true,
+		setupFiles: ["./src/setupTests.ts"],
+		coverage: {
+			provider: "v8",
+			reportOnFailure: true,
+			reporter: ["html", "lcov", "text"],
+			reportsDirectory: "./coverage",
+			exclude: [
+				"**/*.{spec,test}.{js,jsx,ts,tsx,mjs,cjs}",
+
+				"**/*.d.ts",
+				"**/vite-env.d.ts",
+				"**/*.{config,setup}.{js,ts,mjs,cjs}",
+
+				"**/*.{css,scss,sass,less,styl}",
+				"**/*.{svg,png,jpg,jpeg,gif,ico}",
+
+				"**/*.{json,yaml,yml}",
+
+				"**/__mocks__/**",
+				"node_modules/**",
+				"build/**",
+				"coverage/**",
+				"dist/**",
+				"public/**",
+
+				"src/services/grpc-client.ts",
+			],
+		},
+	},
+	build: {
+		outDir: "build",
+		reportCompressedSize: false,
+		// Only minify in production build
+		minify: !isDevBuild,
+		// Enable inline source maps for dev build
+		sourcemap: isDevBuild ? "inline" : false,
+		rollupOptions: {
+			output: {
+				inlineDynamicImports: true,
+				entryFileNames: `assets/[name].js`,
+				chunkFileNames: `assets/[name].js`,
+				assetFileNames: `assets/[name].[ext]`,
+				// Disable compact output for dev build
+				compact: !isDevBuild,
+				// Add generous formatting for dev build
+				...(isDevBuild && {
+					generatedCode: {
+						constBindings: false,
+						objectShorthand: false,
+						arrowFunctions: false,
+					},
+				}),
+			},
+		},
+		chunkSizeWarningLimit: 100000,
+	},
+	server: {
+		host: "127.0.0.1",
+		port: 25463,
+		fs: {
+			allow: [resolve(__dirname), resolve(__dirname, "../src/shared")],
+		},
+		hmr: {
+			host: "127.0.0.1",
+			protocol: "ws",
+		},
+		cors: {
+			origin: "*",
+			methods: "*",
+			allowedHeaders: "*",
+		},
+	},
+	define: {
+		__PLATFORM__: JSON.stringify(platform),
+		__NODE_PLATFORM__: JSON.stringify(process.platform),
+		"process.env.CLINE_ENVIRONMENT": JSON.stringify(process.env.CLINE_ENVIRONMENT ?? "production"),
+		"process.env.IS_DEV": JSON.stringify(process.env.IS_DEV),
+		"process.env.IS_TEST": JSON.stringify(process.env.IS_TEST),
+		"process.env.CI": JSON.stringify(process.env.CI),
+		// PostHog environment variables
+		"process.env.TELEMETRY_SERVICE_API_KEY": JSON.stringify(process.env.TELEMETRY_SERVICE_API_KEY),
+		"process.env.ERROR_SERVICE_API_KEY": JSON.stringify(process.env.ERROR_SERVICE_API_KEY),
+		"process.env.ENABLE_ERROR_AUTOCAPTURE": JSON.stringify(process.env.ENABLE_ERROR_AUTOCAPTURE),
+		// OpenTelemetry environment variables
+		"process.env.OTEL_TELEMETRY_ENABLED": JSON.stringify(process.env.OTEL_TELEMETRY_ENABLED),
+		"process.env.OTEL_METRICS_EXPORTER": JSON.stringify(process.env.OTEL_METRICS_EXPORTER),
+		"process.env.OTEL_LOGS_EXPORTER": JSON.stringify(process.env.OTEL_LOGS_EXPORTER),
+		"process.env.OTEL_EXPORTER_OTLP_PROTOCOL": JSON.stringify(process.env.OTEL_EXPORTER_OTLP_PROTOCOL),
+		"process.env.OTEL_EXPORTER_OTLP_ENDPOINT": JSON.stringify(process.env.OTEL_EXPORTER_OTLP_ENDPOINT),
+		"process.env.OTEL_EXPORTER_OTLP_HEADERS": JSON.stringify(process.env.OTEL_EXPORTER_OTLP_HEADERS),
+		"process.env.OTEL_METRIC_EXPORT_INTERVAL": JSON.stringify(process.env.OTEL_METRIC_EXPORT_INTERVAL),
+	},
+	resolve: {
+		// Force a single React copy. In the bun workspace, sibling packages pull
+		// react@19 into the shared store; without deduping, transitive webview deps
+		// can resolve a second React instance, which bundles two copies and yields a
+		// null hook dispatcher at runtime ("Cannot read properties of null (reading
+		// 'useRef')"). Pin react/react-dom to webview-ui's own (React 18) copy.
+		dedupe: ["react", "react-dom"],
+		alias: {
+			react: resolve(__dirname, "node_modules/react"),
+			"react-dom": resolve(__dirname, "node_modules/react-dom"),
+			"@": resolve(__dirname, "./src"),
+			"@components": resolve(__dirname, "./src/components"),
+			"@context": resolve(__dirname, "./src/context"),
+			"@shared": resolve(__dirname, "../src/shared"),
+			"@utils": resolve(__dirname, "./src/utils"),
+		},
+	},
+})
diff --git a/assets/docs/demo.gif b/assets/docs/demo.gif
new file mode 100644
index 0000000..35eb8d0
--- /dev/null
+++ b/assets/docs/demo.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d426d600fa80e9ac237cbad6b3f7f47a4aa2005d5218184e6b9565a8ee46d1ba
+size 19108207
diff --git a/assets/icons/icon.png b/assets/icons/icon.png
new file mode 100644
index 0000000..db6f1d8
Binary files /dev/null and b/assets/icons/icon.png differ
diff --git a/biome.json b/biome.json
new file mode 100644
index 0000000..d3f6055
--- /dev/null
+++ b/biome.json
@@ -0,0 +1,123 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.4.5/schema.json",
+    "vcs": {
+        "enabled": true,
+        "clientKind": "git",
+        "useIgnoreFile": true,
+        "defaultBranch": "main"
+    },
+    "files": {
+        "ignoreUnknown": true
+    },
+    "formatter": {
+        "enabled": true,
+        "indentStyle": "tab"
+    },
+    "linter": {
+        "enabled": true
+    },
+    "overrides": [
+        {
+            "includes": [
+                "apps/vscode/**"
+            ],
+            "assist": {
+                "enabled": true,
+                "actions": {
+                    "source": {
+                        "organizeImports": "on",
+                        "useSortedAttributes": "on"
+                    }
+                }
+            },
+            "linter": {
+                "rules": {
+                    "recommended": true,
+                    "correctness": {
+                        "useExhaustiveDependencies": "info",
+                        "noUndeclaredVariables": "off",
+                        "noEmptyPattern": "info",
+                        "useJsxKeyInIterable": "off",
+                        "noInnerDeclarations": "off",
+                        "useHookAtTopLevel": "info",
+                        "useYield": "info",
+                        "noConstructorReturn": "off",
+                        "noInvalidPositionAtImportRule": "off",
+                        "noSwitchDeclarations": "off",
+                        "noUnusedImports": "error"
+                    },
+                    "a11y": "info",
+                    "style": {
+                        "useNodejsImportProtocol": "off",
+                        "useImportType": "off",
+                        "useBlockStatements": "off",
+                        "useNamingConvention": "off",
+                        "useThrowOnlyError": "info",
+                        "useConsistentArrayType": "off",
+                        "noParameterAssign": "off",
+                        "useAsConstAssertion": "off",
+                        "useDefaultParameterLast": "off",
+                        "noNonNullAssertion": "info",
+                        "useEnumInitializers": "off",
+                        "useSelfClosingElements": "info",
+                        "useSingleVarDeclarator": "off",
+                        "useNumberNamespace": "off",
+                        "noInferrableTypes": "off",
+                        "useTemplate": "info",
+                        "noUselessElse": "info"
+                    },
+                    "suspicious": {
+                        "noDoubleEquals": "warn",
+                        "noImplicitAnyLet": "info",
+                        "noThenProperty": "off",
+                        "noAsyncPromiseExecutor": "info",
+                        "noImportAssign": "off",
+                        "noExplicitAny": "info",
+                        "noControlCharactersInRegex": "warn",
+                        "noShadowRestrictedNames": "off",
+                        "noArrayIndexKey": "info",
+                        "noAssignInExpressions": "info",
+                        "useIterableCallbackReturn": "info"
+                    },
+                    "complexity": {
+                        "noUselessConstructor": "info",
+                        "useOptionalChain": "info",
+                        "noBannedTypes": "warn",
+                        "useLiteralKeys": "info",
+                        "noUselessCatch": "info",
+                        "noUselessSwitchCase": "info",
+                        "noStaticOnlyClass": "info"
+                    },
+                    "security": {
+                        "noDangerouslySetInnerHtml": "info"
+                    }
+                }
+            },
+            "formatter": {
+                "enabled": true,
+                "indentStyle": "tab",
+                "indentWidth": 4,
+                "lineWidth": 130,
+                "lineEnding": "lf",
+                "formatWithErrors": true
+            },
+            "javascript": {
+                "formatter": {
+                    "semicolons": "asNeeded",
+                    "arrowParentheses": "always",
+                    "bracketSameLine": true,
+                    "bracketSpacing": true,
+                    "jsxQuoteStyle": "double",
+                    "quoteProperties": "asNeeded",
+                    "trailingCommas": "all"
+                }
+            },
+            "json": {
+                "formatter": {
+                    "trailingCommas": "none",
+                    "expand": "always"
+                }
+            }
+        }
+    ]
+}
diff --git a/bun.lock b/bun.lock
new file mode 100644
index 0000000..d6c754c
--- /dev/null
+++ b/bun.lock
@@ -0,0 +1,7409 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@cline/packages",
+      "devDependencies": {
+        "@biomejs/biome": "2.4.5",
+        "@types/bun": "^1.3.13",
+        "@types/node": "^25.3.5",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.3.2",
+        "vitest": "^4.0.18",
+      },
+      "peerDependencies": {
+        "nanoid": "^5.1.7",
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/cli": {
+      "name": "@cline/cli",
+      "version": "3.0.38",
+      "bin": {
+        "cline": "src/index.ts",
+      },
+      "dependencies": {
+        "@agentclientprotocol/sdk": "^0.16.1",
+        "@chat-adapter/discord": "^4.23.0",
+        "@chat-adapter/gchat": "^4.23.0",
+        "@chat-adapter/linear": "^4.23.0",
+        "@chat-adapter/slack": "^4.23.0",
+        "@chat-adapter/telegram": "^4.23.0",
+        "@chat-adapter/whatsapp": "^4.23.0",
+        "@clack/prompts": "^1.2.0",
+        "@cline/cline-hub": "workspace:*",
+        "@gramio/format": "^0.7.0",
+        "@opentui-ui/dialog": "^0.1.2",
+        "@opentui/core": "0.1.102",
+        "@opentui/react": "0.1.102",
+        "chat": "^4.23.0",
+        "commander": "^14.0.3",
+        "fzf": "^0.5.2",
+        "marked": "^15.0.12",
+        "nanoid": "^5.1.7",
+        "open": "^10.2.0",
+        "opentui-spinner": "^0.0.6",
+        "pino": "^10.3.1",
+        "posthog-node": "^5.8.0",
+        "react": "19.2.4",
+        "react-devtools-core": "^7.0.1",
+        "react-reconciler": "0.32.0",
+        "yaml": "^2.8.2",
+        "zod": "^4.1.11",
+      },
+      "devDependencies": {
+        "@cline/core": "workspace:*",
+        "@cline/shared": "workspace:*",
+        "@microsoft/tui-test": "^0.0.2",
+        "@types/bun": "^1.3.10",
+        "@types/react": "19.2.14",
+        "vitest": "^4.0.18",
+      },
+    },
+    "apps/cline-hub": {
+      "name": "@cline/cline-hub",
+      "version": "0.0.0",
+      "dependencies": {
+        "@cline/core": "workspace:*",
+        "@cline/llms": "workspace:*",
+        "@cline/shared": "workspace:*",
+      },
+    },
+    "apps/cline-hub/src/webview": {
+      "name": "@cline/cline-hub-webview",
+      "version": "0.0.0",
+      "dependencies": {
+        "@base-ui/react": "^1.3.0",
+        "@fontsource-variable/schibsted-grotesk": "^5.2.8",
+        "@radix-ui/react-use-controllable-state": "^1.2.2",
+        "@rive-app/react-webgl2": "^4.27.2",
+        "@shikijs/langs": "^4.2.0",
+        "@shikijs/themes": "^4.2.0",
+        "@streamdown/cjk": "^1.0.3",
+        "@tailwindcss/vite": "^4.2.1",
+        "@xyflow/react": "^12.10.1",
+        "ai": "^6.0.116",
+        "ansi-to-react": "^6.2.6",
+        "class-variance-authority": "^0.7.1",
+        "clsx": "^2.1.1",
+        "cmdk": "^1.1.1",
+        "embla-carousel-react": "^8.6.0",
+        "lucide-react": "^0.577.0",
+        "media-chrome": "^4.18.1",
+        "mermaid": "^11.15.0",
+        "motion": "^12.38.0",
+        "nanoid": "^5.1.7",
+        "next-themes": "^0.4.6",
+        "react": "19.2.4",
+        "react-dom": "19.2.4",
+        "react-jsx-parser": "^2.4.1",
+        "recharts": "2.15.4",
+        "shadcn": "^4.0.8",
+        "shiki": "^4.0.2",
+        "sonner": "^2.0.7",
+        "streamdown": "^2.5.0",
+        "tailwind-merge": "^3.5.0",
+        "tokenlens": "^1.3.1",
+        "use-stick-to-bottom": "^1.1.3",
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.39.4",
+        "@tailwindcss/postcss": "^4.2.0",
+        "@types/node": "^24.12.0",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react-swc": "^4.3.0",
+        "esbuild": "^0.27.0",
+        "eslint": "^9.39.4",
+        "eslint-plugin-react-hooks": "^7.0.1",
+        "eslint-plugin-react-refresh": "^0.5.2",
+        "globals": "^17.4.0",
+        "postcss": "^8.5",
+        "tailwindcss": "^4.2.1",
+        "tw-animate-css": "^1.4.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.56.1",
+        "vite": "^8.0.0",
+      },
+    },
+    "apps/examples/cli-agent": {
+      "name": "@cline/example-cli-agent",
+      "version": "0.0.0",
+      "dependencies": {
+        "@cline/sdk": "workspace:*",
+        "zod": "^4.3.6",
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/examples/cline-core-cli-agent": {
+      "name": "@cline/example-cline-core-cli-agent",
+      "version": "0.0.0",
+      "dependencies": {
+        "@cline/sdk": "workspace:*",
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/examples/code-review-bot": {
+      "name": "@cline/example-code-review-bot",
+      "version": "0.0.0",
+      "dependencies": {
+        "@cline/sdk": "workspace:*",
+        "zod": "^4.3.6",
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/examples/desktop-app": {
+      "name": "@cline/code",
+      "version": "0.0.1",
+      "dependencies": {
+        "@base-ui/react": "^1.2.0",
+        "@cline/core": "workspace:*",
+        "@cline/llms": "workspace:*",
+        "@cline/shared": "workspace:*",
+        "@fontsource-variable/schibsted-grotesk": "^5.2.8",
+        "@fontsource/azeret-mono": "^5.2.9",
+        "@hookform/resolvers": "^3.9.1",
+        "@radix-ui/react-accordion": "1.2.12",
+        "@radix-ui/react-alert-dialog": "1.1.15",
+        "@radix-ui/react-aspect-ratio": "1.1.8",
+        "@radix-ui/react-avatar": "1.1.11",
+        "@radix-ui/react-checkbox": "1.3.3",
+        "@radix-ui/react-collapsible": "1.1.12",
+        "@radix-ui/react-context-menu": "2.2.16",
+        "@radix-ui/react-dialog": "1.1.15",
+        "@radix-ui/react-dropdown-menu": "2.1.16",
+        "@radix-ui/react-hover-card": "1.1.15",
+        "@radix-ui/react-label": "2.1.8",
+        "@radix-ui/react-menubar": "1.1.16",
+        "@radix-ui/react-navigation-menu": "1.2.14",
+        "@radix-ui/react-popover": "1.1.15",
+        "@radix-ui/react-progress": "1.1.8",
+        "@radix-ui/react-radio-group": "1.3.8",
+        "@radix-ui/react-scroll-area": "1.2.10",
+        "@radix-ui/react-select": "2.2.6",
+        "@radix-ui/react-separator": "1.1.8",
+        "@radix-ui/react-slider": "1.3.6",
+        "@radix-ui/react-slot": "1.2.4",
+        "@radix-ui/react-switch": "1.2.6",
+        "@radix-ui/react-tabs": "1.1.13",
+        "@radix-ui/react-toast": "1.2.15",
+        "@radix-ui/react-toggle": "1.1.10",
+        "@radix-ui/react-toggle-group": "1.1.11",
+        "@radix-ui/react-tooltip": "1.2.8",
+        "@tauri-apps/api": "^2.0.0",
+        "@vercel/analytics": "1.6.1",
+        "autoprefixer": "^10.4.20",
+        "class-variance-authority": "^0.7.1",
+        "clsx": "^2.1.1",
+        "cmdk": "1.1.1",
+        "date-fns": "4.1.0",
+        "embla-carousel-react": "8.6.0",
+        "input-otp": "1.4.2",
+        "lucide-react": "^0.564.0",
+        "marked": "^17.0.3",
+        "next": "16.2.6",
+        "next-themes": "^0.4.6",
+        "radix-ui": "^1.4.3",
+        "react": "19.2.4",
+        "react-day-picker": "9.13.2",
+        "react-dom": "19.2.4",
+        "react-hook-form": "^7.54.1",
+        "react-markdown": "^10.1.0",
+        "react-resizable-panels": "^2.1.7",
+        "recharts": "2.15.0",
+        "remark-gfm": "^4.0.1",
+        "sonner": "^1.7.1",
+        "tailwind-merge": "^3.3.1",
+        "vaul": "^1.1.2",
+        "zod": "^3.24.1",
+      },
+      "devDependencies": {
+        "@tailwindcss/postcss": "^4.2.0",
+        "@tauri-apps/cli": "^2.0.0",
+        "@types/bun": "^1.3.14",
+        "@types/react": "19.2.14",
+        "@types/react-dom": "19.2.3",
+        "postcss": "^8.5",
+        "tailwindcss": "^4.2.0",
+        "tw-animate-css": "1.3.3",
+        "typescript": "5.7.3",
+        "vitest": "^4.0.18",
+      },
+    },
+    "apps/examples/menubar": {
+      "name": "@cline/menubar",
+      "version": "0.1.0",
+      "dependencies": {
+        "@cline/core": "workspace:*",
+        "@cline/shared": "workspace:*",
+      },
+      "devDependencies": {
+        "@tauri-apps/cli": "^2.0.0",
+        "@types/bun": "^1.3.10",
+        "@types/node": "^25.3.5",
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/examples/multi-agent": {
+      "name": "@cline/example-multi-agent",
+      "version": "0.0.0",
+      "dependencies": {
+        "@cline/sdk": "workspace:*",
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/examples/quickstart": {
+      "name": "@cline/example-quickstart",
+      "version": "0.0.0",
+      "dependencies": {
+        "@cline/sdk": "workspace:*",
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3",
+      },
+    },
+    "apps/examples/vscode": {
+      "name": "@cline/vscode",
+      "version": "0.0.0",
+      "dependencies": {
+        "@ai-sdk/react": "^3.0.118",
+        "@cline/core": "workspace:*",
+        "@cline/llms": "workspace:*",
+        "@cline/shared": "workspace:*",
+        "ai": "^6.0.116",
+      },
+      "devDependencies": {
+        "@types/node": "^25.3.5",
+        "@types/vscode": "^1.90.0",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.18",
+      },
+    },
+    "apps/examples/vscode/src/webview": {
+      "name": "webview",
+      "version": "0.0.0",
+      "dependencies": {
+        "@base-ui/react": "^1.3.0",
+        "@fontsource-variable/geist": "^5.2.8",
+        "@radix-ui/react-use-controllable-state": "^1.2.2",
+        "@rive-app/react-webgl2": "^4.27.2",
+        "@streamdown/cjk": "^1.0.3",
+        "@streamdown/code": "^1.1.1",
+        "@streamdown/math": "^1.0.2",
+        "@streamdown/mermaid": "^1.0.2",
+        "@tailwindcss/vite": "^4.2.1",
+        "@xyflow/react": "^12.10.1",
+        "ai": "^6.0.116",
+        "ansi-to-react": "^6.2.6",
+        "class-variance-authority": "^0.7.1",
+        "clsx": "^2.1.1",
+        "cmdk": "^1.1.1",
+        "embla-carousel-react": "^8.6.0",
+        "lucide-react": "^0.577.0",
+        "media-chrome": "^4.18.1",
+        "motion": "^12.38.0",
+        "nanoid": "^5.1.7",
+        "next-themes": "^0.4.6",
+        "react": "19.2.4",
+        "react-dom": "19.2.4",
+        "react-jsx-parser": "^2.4.1",
+        "recharts": "2.15.4",
+        "shadcn": "^4.0.8",
+        "shiki": "^4.0.2",
+        "sonner": "^2.0.7",
+        "streamdown": "^2.5.0",
+        "tailwind-merge": "^3.5.0",
+        "tokenlens": "^1.3.1",
+        "use-stick-to-bottom": "^1.1.3",
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.39.4",
+        "@tailwindcss/postcss": "^4.2.0",
+        "@types/node": "^24.12.0",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react-swc": "^4.3.0",
+        "esbuild": "^0.27.0",
+        "eslint": "^9.39.4",
+        "eslint-plugin-react-hooks": "^7.0.1",
+        "eslint-plugin-react-refresh": "^0.5.2",
+        "globals": "^17.4.0",
+        "postcss": "^8.5",
+        "tailwindcss": "^4.2.1",
+        "tw-animate-css": "^1.4.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.56.1",
+        "vite": "^8.0.0",
+      },
+    },
+    "apps/vscode": {
+      "name": "claude-dev",
+      "version": "4.0.0",
+      "dependencies": {
+        "@anthropic-ai/sdk": "^0.37.0",
+        "@bufbuild/protobuf": "^2.2.5",
+        "@cline/agents": "workspace:*",
+        "@cline/core": "workspace:*",
+        "@cline/llms": "workspace:*",
+        "@cline/shared": "workspace:*",
+        "@google/genai": "^1.30.0",
+        "@grpc/grpc-js": "^1.9.15",
+        "@grpc/proto-loader": "^0.7.13",
+        "@grpc/reflection": "^1.0.4",
+        "@modelcontextprotocol/sdk": "^1.25.1",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/api-logs": "^0.56.0",
+        "@opentelemetry/core": "^2.1.0",
+        "@opentelemetry/exporter-logs-otlp-grpc": "^0.56.0",
+        "@opentelemetry/exporter-logs-otlp-http": "^0.56.0",
+        "@opentelemetry/exporter-logs-otlp-proto": "^0.56.0",
+        "@opentelemetry/exporter-metrics-otlp-grpc": "^0.56.0",
+        "@opentelemetry/exporter-metrics-otlp-http": "^0.56.0",
+        "@opentelemetry/exporter-metrics-otlp-proto": "^0.56.0",
+        "@opentelemetry/exporter-prometheus": "^0.56.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.56.0",
+        "@opentelemetry/instrumentation": "^0.205.0",
+        "@opentelemetry/instrumentation-http": "^0.205.0",
+        "@opentelemetry/resources": "^1.30.1",
+        "@opentelemetry/sdk-logs": "^0.56.0",
+        "@opentelemetry/sdk-metrics": "^1.30.1",
+        "@opentelemetry/sdk-node": "^0.56.0",
+        "@opentelemetry/sdk-trace-base": "^2.1.0",
+        "@opentelemetry/sdk-trace-node": "^1.30.1",
+        "@opentelemetry/semantic-conventions": "^1.37.0",
+        "@playwright/test": "^1.55.1",
+        "@streamparser/json": "^0.0.22",
+        "@tailwindcss/vite": "^4.1.14",
+        "@types/uuid": "^10.0.0",
+        "@vscode/codicons": "^0.0.36",
+        "archiver": "^7.0.1",
+        "aws4fetch": "^1.0.20",
+        "axios": "1.16.1",
+        "better-sqlite3": "^12.4.1",
+        "cheerio": "^1.0.0",
+        "chokidar": "^4.0.1",
+        "chrome-launcher": "^1.1.2",
+        "clone-deep": "^4.0.1",
+        "default-shell": "^2.2.0",
+        "diff": "8.0.4",
+        "exceljs": "^4.4.0",
+        "execa": "^9.5.2",
+        "fast-deep-equal": "^3.1.3",
+        "fzf": "^0.5.2",
+        "get-folder-size": "^5.0.0",
+        "globby": "^14.0.2",
+        "grpc-health-check": "^2.0.2",
+        "iconv-lite": "^0.6.3",
+        "ignore": "^7.0.3",
+        "image-size": "^2.0.2",
+        "isbinaryfile": "^5.0.2",
+        "js-yaml": "^4.1.1",
+        "jschardet": "^3.1.4",
+        "json5": "^2.2.3",
+        "jwt-decode": "^4.0.0",
+        "mammoth": "^1.11.0",
+        "nanoid": "^5.1.6",
+        "nice-grpc": "^2.1.12",
+        "nice-grpc-common": "^2.0.3",
+        "node-machine-id": "^1.1.12",
+        "open": "^10.1.2",
+        "open-graph-scraper": "^6.9.0",
+        "openai": "^6.21.0",
+        "os-name": "^6.0.0",
+        "p-mutex": "^1.0.0",
+        "p-timeout": "^6.1.4",
+        "p-wait-for": "^5.0.2",
+        "pdf-parse": "^1.1.1",
+        "picomatch": "^4.0.3",
+        "posthog-node": "^5.8.0",
+        "puppeteer-chromium-resolver": "^23.0.0",
+        "puppeteer-core": "^23.4.0",
+        "reconnecting-eventsource": "^1.6.4",
+        "serialize-error": "^11.0.3",
+        "shell-quote": "^1.8.3",
+        "simple-git": "3.36.0",
+        "strip-ansi": "^7.1.2",
+        "tailwindcss": "^4.1.14",
+        "ts-morph": "^25.0.1",
+        "turndown": "^7.2.0",
+        "ulid": "^2.4.0",
+        "undici": "^7.26.0",
+        "uuid": "^11.1.0",
+        "vscode-uri": "^3.1.0",
+        "zod": "^4.3.6",
+      },
+      "devDependencies": {
+        "@biomejs/biome": "^2.3.14",
+        "@bufbuild/buf": "^1.54.0",
+        "@microsoft/tui-test": "0.0.1",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/chai": "^5.0.1",
+        "@types/clone-deep": "^4.0.4",
+        "@types/get-folder-size": "^3.0.4",
+        "@types/js-yaml": "^4.0.9",
+        "@types/mocha": "^10.0.7",
+        "@types/node": "20.x",
+        "@types/pdf-parse": "^1.1.4",
+        "@types/picomatch": "^4.0.2",
+        "@types/shell-quote": "^1.7.5",
+        "@types/should": "^11.2.0",
+        "@types/sinon": "^21.0.0",
+        "@types/turndown": "^5.0.5",
+        "@types/vscode": "1.84.0",
+        "@vscode/test-cli": "^0.0.12",
+        "@vscode/test-electron": "^2.5.2",
+        "@vscode/vsce": "^3.6.0",
+        "c8": "^10.1.3",
+        "chai": "^4.3.10",
+        "chalk": "5.6.2",
+        "dotenv": "^17.2.3",
+        "esbuild": "^0.25.0",
+        "glob": "^11.0.0",
+        "grpc-tools": "^1.13.0",
+        "lint-staged": "^16.1.0",
+        "minimatch": "^3.0.3",
+        "minimist": "^1.2.8",
+        "mocha": "^11.7.4",
+        "playwright": "^1.55.1",
+        "prebuild-install": "^7.1.3",
+        "protoc-gen-ts": "^0.8.7",
+        "rimraf": "^6.0.1",
+        "should": "^13.2.3",
+        "sinon": "^21.0.3",
+        "tar": "^7.5.2",
+        "tree-kill": "^1.2.2",
+        "ts-proto": "^2.6.1",
+        "tsconfig-paths": "^4.2.0",
+        "typescript": "^5.4.5",
+        "vitest": "^4.0.17",
+      },
+    },
+    "apps/vscode/testing-platform": {
+      "name": "testing-infra",
+      "version": "0.1.0",
+      "dependencies": {
+        "jest-diff": "^30.1.2",
+      },
+      "devDependencies": {
+        "@types/lodash": "^4.17.20",
+        "lodash": "^4.17.23",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.3.3",
+      },
+    },
+    "apps/vscode/webview-ui": {
+      "name": "webview-ui",
+      "version": "0.3.0",
+      "dependencies": {
+        "@floating-ui/react": "^0.27.4",
+        "@fontsource/azeret-mono": "^5.2.9",
+        "@heroui/react": "^2.8.0-beta.2",
+        "@heroui/theme": "2.4.26",
+        "@paper-design/shaders-react": "^0.0.46",
+        "@radix-ui/react-dialog": "^1.1.15",
+        "@radix-ui/react-hover-card": "^1.1.15",
+        "@radix-ui/react-label": "^2.1.7",
+        "@radix-ui/react-popover": "^1.1.15",
+        "@radix-ui/react-progress": "^1.1.7",
+        "@radix-ui/react-select": "^2.2.6",
+        "@radix-ui/react-separator": "^1.1.7",
+        "@radix-ui/react-slider": "^1.3.6",
+        "@radix-ui/react-slot": "^1.2.3",
+        "@radix-ui/react-switch": "^1.2.6",
+        "@radix-ui/react-tooltip": "^1.2.8",
+        "@vscode/webview-ui-toolkit": "^1.4.0",
+        "class-variance-authority": "^0.7.1",
+        "clsx": "^2.1.1",
+        "debounce": "^2.1.1",
+        "dompurify": "^3.3.3",
+        "fast-deep-equal": "^3.1.3",
+        "firebase": "^11.3.0",
+        "framer-motion": "^12.7.4",
+        "fuse.js": "^7.0.0",
+        "fzf": "^0.5.2",
+        "lucide-react": "^0.511.0",
+        "magic-string": "^0.30.21",
+        "marked": "^15.0.12",
+        "mermaid": "11.12.3",
+        "posthog-js": "^1.224.0",
+        "pretty-bytes": "^6.1.1",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "react-markdown": "^10.1.0",
+        "react-remark": "^2.1.0",
+        "react-textarea-autosize": "^8.5.7",
+        "react-use": "^17.6.0",
+        "react-virtuoso": "^4.12.3",
+        "rehype-highlight": "^7.0.1",
+        "rehype-parse": "^9.0.1",
+        "rehype-remark": "^10.0.1",
+        "remark-gfm": "^4.0.1",
+        "remark-stringify": "^11.0.0",
+        "styled-components": "^6.1.15",
+        "tailwind-merge": "^3.3.1",
+        "tailwindcss-animate": "^1.0.7",
+        "unified": "^11.0.5",
+        "unist-util-visit": "^5.0.0",
+        "uuid": "^9.0.1",
+      },
+      "devDependencies": {
+        "@storybook/react-vite": "^9.1.6",
+        "@tailwindcss/vite": "^4.1.13",
+        "@testing-library/jest-dom": "^6.6.3",
+        "@testing-library/react": "^16.2.0",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/dompurify": "^3.0.5",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.13.4",
+        "@types/react": "^18.3.18",
+        "@types/react-dom": "^18.3.5",
+        "@types/unist": "^3.0.3",
+        "@types/uuid": "^9.0.8",
+        "@types/vscode-webview": "^1.57.5",
+        "@vitejs/plugin-react-swc": "^3.5.0",
+        "@vitest/coverage-v8": "^3.0.9",
+        "globals": "^15.14.0",
+        "jsdom": "^26.0.0",
+        "storybook": "^9.1.17",
+        "tailwindcss": "^4.1.13",
+        "typescript": "^5.7.3",
+        "vite": "^7.1.11",
+        "vitest": "^3.0.5",
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-linux-arm64-gnu": "^4.40.0",
+        "@rollup/rollup-linux-x64-gnu": "^4.40.0",
+        "@rollup/rollup-win32-x64-msvc": "^4.60.4",
+        "@swc/core-linux-x64-gnu": "^1.11.0",
+        "@tailwindcss/oxide-linux-x64-gnu": "^4.0.1",
+        "lightningcss-linux-x64-gnu": "^1.29.1",
+        "lightningcss-win32-x64-msvc": "1.29.2",
+      },
+    },
+    "sdk/examples": {
+      "name": "examples",
+      "dependencies": {
+        "@cline/core": "workspace:*",
+      },
+      "devDependencies": {
+        "@types/bun": "^1.3.10",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+    "sdk/examples/plugins/agents-squad": {
+      "name": "cline-agent-squad-plugin",
+      "version": "0.1.0",
+      "dependencies": {
+        "yaml": "^2.8.1",
+        "zod": "^4.1.5",
+      },
+      "peerDependencies": {
+        "@cline/core": "*",
+      },
+      "optionalPeers": [
+        "@cline/core",
+      ],
+    },
+    "sdk/packages/agents": {
+      "name": "@cline/agents",
+      "version": "0.0.59",
+      "dependencies": {
+        "@cline/llms": "workspace:*",
+        "@cline/shared": "workspace:*",
+        "nanoid": "^5.1.7",
+      },
+    },
+    "sdk/packages/core": {
+      "name": "@cline/core",
+      "version": "0.0.59",
+      "dependencies": {
+        "@cline/agents": "workspace:*",
+        "@cline/llms": "workspace:*",
+        "@cline/shared": "workspace:*",
+        "@modelcontextprotocol/sdk": "^1.29.0",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/api-logs": "^0.214.0",
+        "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+        "@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+        "@opentelemetry/resources": "^2.6.1",
+        "@opentelemetry/sdk-logs": "^0.214.0",
+        "@opentelemetry/sdk-metrics": "^2.6.1",
+        "@opentelemetry/sdk-trace-base": "^2.6.1",
+        "@opentelemetry/sdk-trace-node": "^2.6.1",
+        "@opentelemetry/semantic-conventions": "^1.40.0",
+        "jiti": "^2.7.0",
+        "nanoid": "^5.1.7",
+        "node-machine-id": "^1.1.12",
+        "simple-git": "3.36.0",
+        "ws": "^8.20.0",
+        "yaml": "^2.8.2",
+        "zod": "^4.3.6",
+      },
+      "devDependencies": {
+        "@types/ws": "^8.18.1",
+        "posthog-node": "^5.8.0",
+      },
+      "peerDependencies": {
+        "posthog-node": "^5.8.0",
+      },
+      "optionalPeers": [
+        "posthog-node",
+      ],
+    },
+    "sdk/packages/llms": {
+      "name": "@cline/llms",
+      "version": "0.0.59",
+      "dependencies": {
+        "@ai-sdk/amazon-bedrock": "^4.0.89",
+        "@ai-sdk/anthropic": "^3.0.68",
+        "@ai-sdk/google": "^3.0.60",
+        "@ai-sdk/google-vertex": "^4.0.100",
+        "@ai-sdk/mistral": "^3.0.28",
+        "@ai-sdk/openai": "^3.0.52",
+        "@ai-sdk/openai-compatible": "^2.0.38",
+        "@ai-sdk/provider": "^3.0.8",
+        "@aws-sdk/credential-providers": "^3.922.0",
+        "@cline/shared": "workspace:*",
+        "@jerome-benoit/sap-ai-provider": "4.6.9",
+        "@langfuse/otel": "^4.0.0",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/sdk-trace-node": "^2.6.1",
+        "@streamparser/json": "^0.0.21",
+        "ai": "^6.0.144",
+        "ai-sdk-provider-claude-code": "^3.4.3",
+        "ai-sdk-provider-codex-cli": "^1.1.0",
+        "ai-sdk-provider-opencode-sdk": "^3.0.1",
+        "dify-ai-provider": "^1.1.0",
+        "nanoid": "^5.1.7",
+        "zod": "^4.3.6",
+      },
+      "peerDependencies": {
+        "@aws-sdk/client-bedrock-runtime": "^3.0.0",
+      },
+      "optionalPeers": [
+        "@aws-sdk/client-bedrock-runtime",
+      ],
+    },
+    "sdk/packages/sdk": {
+      "name": "@cline/sdk",
+      "version": "0.0.59",
+      "dependencies": {
+        "@cline/core": "workspace:*",
+      },
+    },
+    "sdk/packages/shared": {
+      "name": "@cline/shared",
+      "version": "0.0.59",
+      "dependencies": {
+        "aws4fetch": "^1.0.20",
+        "jsonrepair": "^3.13.2",
+        "zod": "^4.3.6",
+        "zod-to-json-schema": "^3.25.1",
+      },
+    },
+  },
+  "trustedDependencies": [
+    "better-sqlite3",
+    "grpc-tools",
+  ],
+  "overrides": {
+    "@sap-cloud-sdk/connectivity": "4.6.0",
+    "@sap-cloud-sdk/http-client": "4.6.0",
+    "@sap-cloud-sdk/openapi": "4.6.0",
+    "@sap-cloud-sdk/resilience": "4.6.0",
+    "@sap-cloud-sdk/util": "4.6.0",
+    "diff": "8.0.4",
+    "js-yaml": "^4.1.1",
+    "protobufjs": "7.5.8",
+    "serialize-javascript": ">=7.0.3",
+    "tar": "^7.5.2",
+    "tar-fs": ">=3.1.1",
+  },
+  "packages": {
+    "@adobe/css-tools": ["@adobe/css-tools@4.5.0", "", {}, "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q=="],
+
+    "@adobe/react-spectrum": ["@adobe/react-spectrum@3.47.2", "", { "dependencies": { "@internationalized/date": "^3.12.2", "@react-types/shared": "^3.36.0", "@spectrum-icons/ui": "^3.7.1", "@spectrum-icons/workflow": "^4.3.1", "@swc/helpers": "^0.5.0", "client-only": "^0.0.1", "clsx": "^2.0.0", "react-aria": "3.50.0", "react-aria-components": "1.19.0", "react-stately": "3.48.0", "react-transition-group": "^4.4.5", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-QxsE7bPBGpzwYofACF0RAL/Zs3p0u9HNvCDf9LEN87rEGFpkagIB+T+TSZ0xbl6BJ6z7S02m3zAFk3s9FoHJpQ=="],
+
+    "@adobe/react-spectrum-ui": ["@adobe/react-spectrum-ui@1.2.1", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0" } }, "sha512-wcrbEE2O/9WnEn6avBnaVRRx88S5PLFsPLr4wffzlbMfXeQsy+RMQwaJd3cbzrn18/j04Isit7f7Emfn0dhrJA=="],
+
+    "@adobe/react-spectrum-workflow": ["@adobe/react-spectrum-workflow@2.3.5", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0" } }, "sha512-b53VIPwPWKb/T5gzE3qs+QlGP5gVrw/LnWV3xMksDU+CRl3rzOKUwxIGiZO8ICyYh1WiyqY4myGlPU/nAynBUg=="],
+
+    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@0.16.1", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-1ad+Sc/0sCtZGHthxxvgEUo5Wsbw16I+aF+YwdiLnPwkZG8KAGUEAPK6LM6Pf69lCyJPt1Aomk1d+8oE3C4ZEw=="],
+
+    "@ai-sdk/amazon-bedrock": ["@ai-sdk/amazon-bedrock@4.0.128", "", { "dependencies": { "@ai-sdk/anthropic": "3.0.92", "@ai-sdk/openai": "3.0.80", "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35", "@smithy/eventstream-codec": "^4.0.1", "@smithy/util-utf8": "^4.0.0", "aws4fetch": "^1.0.20" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-T6mvUEYjTCkRAYByOwCwHT12J8r2U9fxJqfEf6k04OceGFjERCfmDdc2wmEaZ4VLo62KpUKJJf6gdf9Bcrx1gw=="],
+
+    "@ai-sdk/anthropic": ["@ai-sdk/anthropic@3.0.92", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-dFrf4xhx2yM686KHFm76Nn7nBekjkjiw1btqOyR26/kXz58QMguhNsjyvMqPktD8AW/wwTAq0fDRVyDvF2gH1w=="],
+
+    "@ai-sdk/gateway": ["@ai-sdk/gateway@3.0.142", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35", "@vercel/oidc": "3.2.0" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-Y1iwdxdebYXpoK5y/4CrcCfJGeFwEJWlEx+pMWIg/ZVWGi9KA+JXM7YBkhxcshpq/jAXx8YyQeFMyZr0TGfXZQ=="],
+
+    "@ai-sdk/google": ["@ai-sdk/google@3.0.88", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-CN3PHCz5pa2sBowwZG4sNqE+7YfHWZT6+5KU12YMWuBssZ03s143Jr2jThkN5Fgemy8Kyg+ub2XbpHGhtIZ2yQ=="],
+
+    "@ai-sdk/google-vertex": ["@ai-sdk/google-vertex@4.0.155", "", { "dependencies": { "@ai-sdk/anthropic": "3.0.92", "@ai-sdk/google": "3.0.88", "@ai-sdk/openai-compatible": "2.0.56", "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35", "google-auth-library": "^10.5.0" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-DMH5rhnN2AcwDmLWcRqUwF/Mj5SlgaAK5uy9ke7SNZ/BCNUcnI7MBVr1urteBdro1P3BAfiNSXuTfjIlOhwl/Q=="],
+
+    "@ai-sdk/mistral": ["@ai-sdk/mistral@3.0.45", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-IyOPiBqPkd6RPqTvhDN6/JcoF7VVP2499FY4acnMz08Y7a1c1ZplsL6lPRTOmcFEwto1491ePilD9H0GtY1QEg=="],
+
+    "@ai-sdk/openai": ["@ai-sdk/openai@3.0.80", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-u3EfYbBG4YS/U2eOGH0yv8lPRwDj25X3sTluUKMYEwOLTZzWYv0IPtrpO7tPEra0QU4oq5Gpg49/FGFSrzE4vA=="],
+
+    "@ai-sdk/openai-compatible": ["@ai-sdk/openai-compatible@2.0.56", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-cQrN6OUn/jvsY3OdsU6Wn+ss7vp1iwIcakZKSlSRMnYqShBfyT7Qht+eqmgxs7w9ttrw6FAG6o11AiBs+iEsTA=="],
+
+    "@ai-sdk/provider": ["@ai-sdk/provider@3.0.13", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-ZPtVYt5QIJzOta1kdUiDuCx4HhFkvNPv/rvmZ2b1iXwybYjJsCnNYR4PAw4kW7rgVfDARvHXcU64efWuqNp6bw=="],
+
+    "@ai-sdk/provider-utils": ["@ai-sdk/provider-utils@4.0.35", "", { "dependencies": { "@ai-sdk/provider": "3.0.13", "@standard-schema/spec": "^1.1.0", "eventsource-parser": "^3.0.8" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-bjYld/2KGPLt78kpqbya+fD4LYS7BqVQJyUjE3qAHrYB0FR2Q90BaWEVIBZaguTWXf/A8L6uG1zO1v9TxVlGWg=="],
+
+    "@ai-sdk/react": ["@ai-sdk/react@3.0.220", "", { "dependencies": { "@ai-sdk/provider-utils": "4.0.35", "ai": "6.0.218", "swr": "^2.2.5", "throttleit": "2.1.0" }, "peerDependencies": { "react": "^18 || ~19.0.1 || ~19.1.2 || ^19.2.1" } }, "sha512-mUqM13WXUT2jNhoU0Kf7YxAtIS+atCUtzZ1LNkhF1q42oYs4g2gWFtq4gNCejACvFMu1KusGRQU2S7ONXtVLZw=="],
+
+    "@alloc/quick-lru": ["@alloc/quick-lru@5.2.0", "", {}, "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw=="],
+
+    "@ampproject/remapping": ["@ampproject/remapping@2.3.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw=="],
+
+    "@antfu/install-pkg": ["@antfu/install-pkg@1.1.0", "", { "dependencies": { "package-manager-detector": "^1.3.0", "tinyexec": "^1.0.1" } }, "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ=="],
+
+    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.3.198", "", { "optionalDependencies": { "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.3.198", "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.3.198", "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.3.198", "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.3.198", "@anthropic-ai/claude-agent-sdk-linux-x64": "0.3.198", "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.3.198", "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.3.198", "@anthropic-ai/claude-agent-sdk-win32-x64": "0.3.198" }, "peerDependencies": { "@anthropic-ai/sdk": ">=0.93.0", "@modelcontextprotocol/sdk": "^1.29.0", "zod": "^4.0.0" } }, "sha512-xt469sSCyclTPtzpLAg0Aschy665GiRMgZKabSmESbGUA5/H56HcILVOiFxclXswkeMUk2fQxfHJUY9UZfiTnA=="],
+
+    "@anthropic-ai/claude-agent-sdk-darwin-arm64": ["@anthropic-ai/claude-agent-sdk-darwin-arm64@0.3.198", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ZmiAybQKIKcP1qEAE/vfXvfxtKxG9CnJn98QTXC5Zxiwuy7Mllx2ALXh9dfmsf0V87CGEodlZQmMgUJotNIsUw=="],
+
+    "@anthropic-ai/claude-agent-sdk-darwin-x64": ["@anthropic-ai/claude-agent-sdk-darwin-x64@0.3.198", "", { "os": "darwin", "cpu": "x64" }, "sha512-XwH5vgN46WSwg8aC1OagNofnJpV/G1ciEu118GEKer8ZhVkq/dvK/DqShxMkb6r1jV7u5IJ7zPXu9uKliyNJAw=="],
+
+    "@anthropic-ai/claude-agent-sdk-linux-arm64": ["@anthropic-ai/claude-agent-sdk-linux-arm64@0.3.198", "", { "os": "linux", "cpu": "arm64" }, "sha512-qmz8dxEtDIlKntU5qYe0R4aWTxTue5S7zIQknatLX7aJ6HN/nq1aCNXWn5smTH2FViBkUPPR+sCIsNwSk6AT6Q=="],
+
+    "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": ["@anthropic-ai/claude-agent-sdk-linux-arm64-musl@0.3.198", "", { "os": "linux", "cpu": "arm64" }, "sha512-Q7lKVNjIrUQ2B/AR77OvRf0zeOdEjonFVaR9FYrrwtzGeEqum69WSht5nM7Y7el3wjbNi0/eV0QTUM0DlsTEfw=="],
+
+    "@anthropic-ai/claude-agent-sdk-linux-x64": ["@anthropic-ai/claude-agent-sdk-linux-x64@0.3.198", "", { "os": "linux", "cpu": "x64" }, "sha512-Zqxyz2AT1UM5WlOOoLJhLssZDgZo8rBK5ku6daveK12zp+UTJGZhGsjFghz1/ASxH08KqOTbUePNTORnPhHAEQ=="],
+
+    "@anthropic-ai/claude-agent-sdk-linux-x64-musl": ["@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.3.198", "", { "os": "linux", "cpu": "x64" }, "sha512-h1SrWVIMjLInYNPlf+TxXuKTOdoiOfJLBSoQG97315Z2Nh0IpBfqWExlqYTtPCgKE7q2iga31U283QfHpIDlSQ=="],
+
+    "@anthropic-ai/claude-agent-sdk-win32-arm64": ["@anthropic-ai/claude-agent-sdk-win32-arm64@0.3.198", "", { "os": "win32", "cpu": "arm64" }, "sha512-mjIHf1HFiRuXefewWTaNZFlTZlCaEt/xsRjc1nSTCEEpFolZayVhrDKz+O2QFVcDtPl8x8GeYSL0kiikg1DZjQ=="],
+
+    "@anthropic-ai/claude-agent-sdk-win32-x64": ["@anthropic-ai/claude-agent-sdk-win32-x64@0.3.198", "", { "os": "win32", "cpu": "x64" }, "sha512-y3HLuCCz1kDwUrhd6OnqO+d5BUpTFSzNUsPT9kf3r1vk9HYKF+eMC9eIlcOhiW2kX491kxEvuEOfqgIkGx15cg=="],
+
+    "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.37.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-tHjX2YbkUBwEgg0JZU3EFSSAQPoK4qQR/NFYa8Vtzd5UAyXzZksCw2In69Rml4R/TyHPBfRYaLK35XiOe33pjw=="],
+
+    "@asamuzakjp/css-color": ["@asamuzakjp/css-color@3.2.0", "", { "dependencies": { "@csstools/css-calc": "^2.1.3", "@csstools/css-color-parser": "^3.0.9", "@csstools/css-parser-algorithms": "^3.0.4", "@csstools/css-tokenizer": "^3.0.3", "lru-cache": "^10.4.3" } }, "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw=="],
+
+    "@aws-sdk/client-cognito-identity": ["@aws-sdk/client-cognito-identity@3.1078.0", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/credential-provider-node": "^3.972.61", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/fetch-http-handler": "^5.6.2", "@smithy/node-http-handler": "^4.9.2", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-BYy0X/+GMXlitKShxkdTsCexWwDrn8usY2Y2Z06M5MSi4aRT3Ce5ilyA6OubQUqOWfsmDMYrm8oBNaTIcQFyrg=="],
+
+    "@aws-sdk/core": ["@aws-sdk/core@3.974.26", "", { "dependencies": { "@aws-sdk/types": "^3.973.15", "@aws-sdk/xml-builder": "^3.972.33", "@aws/lambda-invoke-store": "^0.2.2", "@smithy/core": "^3.29.0", "@smithy/signature-v4": "^5.6.1", "@smithy/types": "^4.15.1", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-wRj7Pthvjk3anees97pUWlxlTa0DUjeGrEQU5fKDZVdWZV0ekaprbof0df2uaE9g8u67t035v2j+ne2AW2UMkA=="],
+
+    "@aws-sdk/credential-provider-cognito-identity": ["@aws-sdk/credential-provider-cognito-identity@3.972.51", "", { "dependencies": { "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-nXzAwRz0NOiHlG/HHea7oJ2ew2m21XZUU6h2cZMCrlNQqcWjMHCkun4D6E7CWqOxiFG0MeN8Gg5Iakrjv/UXrQ=="],
+
+    "@aws-sdk/credential-provider-env": ["@aws-sdk/credential-provider-env@3.972.52", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-sxuaHZGHqOgKB8OdL3doXa1NJjqmO60FPfyTnYVKGjX9taRsIEGS9pd+2yALmo06hijZ8L94uSK0kfXZsRmVyA=="],
+
+    "@aws-sdk/credential-provider-http": ["@aws-sdk/credential-provider-http@3.972.54", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/fetch-http-handler": "^5.6.2", "@smithy/node-http-handler": "^4.9.2", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-e6yz52nq3SpR1oPLcvfsDM7H7k2gIYk/NSn/rwsFqzGXEwr3g0mRMlPbLaKCPCGNZJMU/gZg6/64B3eSam+gBw=="],
+
+    "@aws-sdk/credential-provider-ini": ["@aws-sdk/credential-provider-ini@3.972.59", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/credential-provider-env": "^3.972.52", "@aws-sdk/credential-provider-http": "^3.972.54", "@aws-sdk/credential-provider-login": "^3.972.58", "@aws-sdk/credential-provider-process": "^3.972.52", "@aws-sdk/credential-provider-sso": "^3.972.58", "@aws-sdk/credential-provider-web-identity": "^3.972.58", "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/credential-provider-imds": "^4.4.5", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-9Um/UpruN76AdpiLnvwChVkJJwJ9Vx9ykk/2AeLxxSCM/YYRD8Kkq2towUk9fZQLV7dd9ATlsi87U7hKs0z/iQ=="],
+
+    "@aws-sdk/credential-provider-login": ["@aws-sdk/credential-provider-login@3.972.58", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-H3q96qF8/DJsPsXMVtMRqSWOc85K5O4zos32untdw+vE5vw0f3a6qJo1YqbND4BsEIKd4iZmzzVUq9kV4LjbHg=="],
+
+    "@aws-sdk/credential-provider-node": ["@aws-sdk/credential-provider-node@3.972.61", "", { "dependencies": { "@aws-sdk/credential-provider-env": "^3.972.52", "@aws-sdk/credential-provider-http": "^3.972.54", "@aws-sdk/credential-provider-ini": "^3.972.59", "@aws-sdk/credential-provider-process": "^3.972.52", "@aws-sdk/credential-provider-sso": "^3.972.58", "@aws-sdk/credential-provider-web-identity": "^3.972.58", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/credential-provider-imds": "^4.4.5", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-2U2KHMRCt1dlZoLU3KZR5g5EL4b0h2HHw96SkaUBK7qvEXPZj5rGRO/3ZTeJmh37dIYQuCnA2273rZOQvmsiHw=="],
+
+    "@aws-sdk/credential-provider-process": ["@aws-sdk/credential-provider-process@3.972.52", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-Aff9Ebs42lz+Ep1wkS+Nlwh5S0eahakpyskPsuKGjiBJ6ExOjNtxbfKJTKovQtQNgJ7oG1BH6esJwGrbs7qgSA=="],
+
+    "@aws-sdk/credential-provider-sso": ["@aws-sdk/credential-provider-sso@3.972.58", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/token-providers": "3.1078.0", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-syloC58mXOacUqM2toPNfwd7X3jT+tWj0F/cN7qdW1FQyI0q41J0tPf6DIZ56BF0x82iS9j3ALP45MoBz79YuQ=="],
+
+    "@aws-sdk/credential-provider-web-identity": ["@aws-sdk/credential-provider-web-identity@3.972.58", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-pTBImKzcGK+pcMKjL0fAJbnYzzYd1c0UDc7BSIOGNQhF9Nuk66vWlIXfYTYyzNSs+w8Q/vfbbNDDU8zdrouwLg=="],
+
+    "@aws-sdk/credential-providers": ["@aws-sdk/credential-providers@3.1078.0", "", { "dependencies": { "@aws-sdk/client-cognito-identity": "3.1078.0", "@aws-sdk/core": "^3.974.26", "@aws-sdk/credential-provider-cognito-identity": "^3.972.51", "@aws-sdk/credential-provider-env": "^3.972.52", "@aws-sdk/credential-provider-http": "^3.972.54", "@aws-sdk/credential-provider-ini": "^3.972.59", "@aws-sdk/credential-provider-login": "^3.972.58", "@aws-sdk/credential-provider-node": "^3.972.61", "@aws-sdk/credential-provider-process": "^3.972.52", "@aws-sdk/credential-provider-sso": "^3.972.58", "@aws-sdk/credential-provider-web-identity": "^3.972.58", "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/credential-provider-imds": "^4.4.5", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-V9Tr3MrNWUfTGgTMIr+WJaMC/VDbXY57BzrGDuyDZn7+vgZjAEG6nI5nMdfnTGdvV9wq1n0zZPYW2RDfcsWNCw=="],
+
+    "@aws-sdk/nested-clients": ["@aws-sdk/nested-clients@3.997.26", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/signature-v4-multi-region": "^3.996.38", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/fetch-http-handler": "^5.6.2", "@smithy/node-http-handler": "^4.9.2", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-Lwe3F6K7bs+jEubp1LbrvzeMBYb5fMazJ1IxV9TtKWPF8CSh67Fmwyq9fLz3NL/k55Dfpuph5Dimw76JFgr+SA=="],
+
+    "@aws-sdk/signature-v4-multi-region": ["@aws-sdk/signature-v4-multi-region@3.996.38", "", { "dependencies": { "@aws-sdk/types": "^3.973.15", "@smithy/signature-v4": "^5.6.1", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-C379Sk+MiFZCfWZphKlMyLHKxV22OjoGM5KJjj5IJNJcOCWL4IGIpnEGzv1FQiRwhYXfq55SJMfxlqPE08JJ9g=="],
+
+    "@aws-sdk/token-providers": ["@aws-sdk/token-providers@3.1078.0", "", { "dependencies": { "@aws-sdk/core": "^3.974.26", "@aws-sdk/nested-clients": "^3.997.26", "@aws-sdk/types": "^3.973.15", "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-/uyXLBGu3Lw1GbBA2X66hcOMnKtMcqAIF+3/eHfxBQmUeXF2sdqozDPrTfEr/TnSd0D6deZar+eVyhEqqWu29w=="],
+
+    "@aws-sdk/types": ["@aws-sdk/types@3.973.15", "", { "dependencies": { "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-IULn8uBV/SMtmOIANsm4WHXIOtVPBWfOWs3WGL0j/sI+KhaYehvOw0ET+9urnn8MBpiijuU/0JOpuwKOE451PQ=="],
+
+    "@aws-sdk/xml-builder": ["@aws-sdk/xml-builder@3.972.33", "", { "dependencies": { "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-ezbwz9WpuLctm6o7P2t2naDhVVPI5jFGrVefVybhcKGjU57VIyT46pQVO0RI2RYkUdhdj2Z9uSIlAzGZE9NW9A=="],
+
+    "@aws/lambda-invoke-store": ["@aws/lambda-invoke-store@0.2.4", "", {}, "sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ=="],
+
+    "@azu/format-text": ["@azu/format-text@1.0.2", "", {}, "sha512-Swi4N7Edy1Eqq82GxgEECXSSLyn6GOb5htRFPzBDdUkECGXtlf12ynO5oJSpWKPwCaUssOu7NfhDcCWpIC6Ywg=="],
+
+    "@azu/style-format": ["@azu/style-format@1.0.1", "", { "dependencies": { "@azu/format-text": "^1.0.1" } }, "sha512-AHcTojlNBdD/3/KxIKlg8sxIWHfOtQszLvOpagLTO+bjC3u7SAszu1lf//u7JJC50aUSH+BVWDD/KvaA6Gfn5g=="],
+
+    "@azure/abort-controller": ["@azure/abort-controller@2.1.2", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-nBrLsEWm4J2u5LpAPjxADTlq3trDgVZZXHNKabeXZtpq3d3AbN/KGO82R87rdDz5/lYB024rtEf10/q0urNgsA=="],
+
+    "@azure/core-auth": ["@azure/core-auth@1.10.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-util": "^1.13.0", "tslib": "^2.6.2" } }, "sha512-ykRMW8PjVAn+RS6ww5cmK9U2CyH9p4Q88YJwvUslfuMmN98w/2rdGRLPqJYObapBCdzBVeDgYWdJnFPFb7qzpg=="],
+
+    "@azure/core-client": ["@azure/core-client@1.10.2", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-auth": "^1.10.0", "@azure/core-rest-pipeline": "^1.22.0", "@azure/core-tracing": "^1.3.0", "@azure/core-util": "^1.13.0", "@azure/logger": "^1.3.0", "tslib": "^2.6.2" } }, "sha512-1D2LpsU7y9xrqKjdIbsB7PlrRePw0xsVV8p+AKTlzITrWmscajryfJCdDJB/oGwvDI5HmRo04eMMADB67uwAwQ=="],
+
+    "@azure/core-rest-pipeline": ["@azure/core-rest-pipeline@1.24.0", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-auth": "^1.10.0", "@azure/core-tracing": "^1.3.0", "@azure/core-util": "^1.13.0", "@azure/logger": "^1.3.0", "@typespec/ts-http-runtime": "^0.3.4", "tslib": "^2.6.2" } }, "sha512-PpLsoDQ3AMmKZ0VU+0GrmqMxgp/sExjlVm4R+nLWngeoEGAzOIPVifaxKGU5gMv+nWELUoHfvrolWD+ZS/nFJg=="],
+
+    "@azure/core-tracing": ["@azure/core-tracing@1.3.1", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-9MWKevR7Hz8kNzzPLfX4EAtGM2b8mr50HPDBvio96bURP/9C+HjdH3sBlLSNNrvRAr5/k/svoH457gB5IKpmwQ=="],
+
+    "@azure/core-util": ["@azure/core-util@1.13.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "sha512-XPArKLzsvl0Hf0CaGyKHUyVgF7oDnhKoP85Xv6M4StF/1AhfORhZudHtOyf2s+FcbuQ9dPRAjB8J2KvRRMUK2A=="],
+
+    "@azure/identity": ["@azure/identity@4.13.1", "", { "dependencies": { "@azure/abort-controller": "^2.0.0", "@azure/core-auth": "^1.9.0", "@azure/core-client": "^1.9.2", "@azure/core-rest-pipeline": "^1.17.0", "@azure/core-tracing": "^1.0.0", "@azure/core-util": "^1.11.0", "@azure/logger": "^1.0.0", "@azure/msal-browser": "^5.5.0", "@azure/msal-node": "^5.1.0", "open": "^10.1.0", "tslib": "^2.2.0" } }, "sha512-5C/2WD5Vb1lHnZS16dNQRPMjN6oV/Upba+C9nBIs15PmOi6A3ZGs4Lr2u60zw4S04gi+u3cEXiqTVP7M4Pz3kw=="],
+
+    "@azure/logger": ["@azure/logger@1.3.0", "", { "dependencies": { "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "sha512-fCqPIfOcLE+CGqGPd66c8bZpwAji98tZ4JI9i/mlTNTlsIWslCfpg48s/ypyLxZTump5sypjrKn2/kY7q8oAbA=="],
+
+    "@azure/msal-browser": ["@azure/msal-browser@5.16.0", "", { "dependencies": { "@azure/msal-common": "16.11.0" } }, "sha512-Wc75FGnQgYpsm5jsOqn1H8AXsh8vXruA6vwip1nhjrJxwby7juxKAIVLr7csepmHiwdZGr6EwI5BlSc3PizEtQ=="],
+
+    "@azure/msal-common": ["@azure/msal-common@16.11.0", "", {}, "sha512-UikJOtMwkFpZNzTH6Dqk8UTUPbow15zH3e0UjGYZy69lYENW/S05gMLhbxI2eonz66uALhIljvhsSMEb6+O30g=="],
+
+    "@azure/msal-node": ["@azure/msal-node@5.3.1", "", { "dependencies": { "@azure/msal-common": "16.11.0", "jsonwebtoken": "^9.0.0" } }, "sha512-sqqv3L1UOI4KDXonNtbxPYUgbSWVXqxvmmb6BUw9n4P/UXgG+cVur3dLWQN4Cz7qQ+UJROCCxMXlksm7gIq0Sw=="],
+
+    "@babel/code-frame": ["@babel/code-frame@7.29.7", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.29.7", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw=="],
+
+    "@babel/compat-data": ["@babel/compat-data@7.29.7", "", {}, "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg=="],
+
+    "@babel/core": ["@babel/core@7.29.7", "", { "dependencies": { "@babel/code-frame": "^7.29.7", "@babel/generator": "^7.29.7", "@babel/helper-compilation-targets": "^7.29.7", "@babel/helper-module-transforms": "^7.29.7", "@babel/helpers": "^7.29.7", "@babel/parser": "^7.29.7", "@babel/template": "^7.29.7", "@babel/traverse": "^7.29.7", "@babel/types": "^7.29.7", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA=="],
+
+    "@babel/generator": ["@babel/generator@7.29.7", "", { "dependencies": { "@babel/parser": "^7.29.7", "@babel/types": "^7.29.7", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" } }, "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ=="],
+
+    "@babel/helper-annotate-as-pure": ["@babel/helper-annotate-as-pure@7.29.7", "", { "dependencies": { "@babel/types": "^7.29.7" } }, "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw=="],
+
+    "@babel/helper-compilation-targets": ["@babel/helper-compilation-targets@7.29.7", "", { "dependencies": { "@babel/compat-data": "^7.29.7", "@babel/helper-validator-option": "^7.29.7", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" } }, "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g=="],
+
+    "@babel/helper-create-class-features-plugin": ["@babel/helper-create-class-features-plugin@7.29.7", "", { "dependencies": { "@babel/helper-annotate-as-pure": "^7.29.7", "@babel/helper-member-expression-to-functions": "^7.29.7", "@babel/helper-optimise-call-expression": "^7.29.7", "@babel/helper-replace-supers": "^7.29.7", "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7", "@babel/traverse": "^7.29.7", "semver": "^6.3.1" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg=="],
+
+    "@babel/helper-globals": ["@babel/helper-globals@7.29.7", "", {}, "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA=="],
+
+    "@babel/helper-member-expression-to-functions": ["@babel/helper-member-expression-to-functions@7.29.7", "", { "dependencies": { "@babel/traverse": "^7.29.7", "@babel/types": "^7.29.7" } }, "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg=="],
+
+    "@babel/helper-module-imports": ["@babel/helper-module-imports@7.29.7", "", { "dependencies": { "@babel/traverse": "^7.29.7", "@babel/types": "^7.29.7" } }, "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g=="],
+
+    "@babel/helper-module-transforms": ["@babel/helper-module-transforms@7.29.7", "", { "dependencies": { "@babel/helper-module-imports": "^7.29.7", "@babel/helper-validator-identifier": "^7.29.7", "@babel/traverse": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg=="],
+
+    "@babel/helper-optimise-call-expression": ["@babel/helper-optimise-call-expression@7.29.7", "", { "dependencies": { "@babel/types": "^7.29.7" } }, "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong=="],
+
+    "@babel/helper-plugin-utils": ["@babel/helper-plugin-utils@7.29.7", "", {}, "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw=="],
+
+    "@babel/helper-replace-supers": ["@babel/helper-replace-supers@7.29.7", "", { "dependencies": { "@babel/helper-member-expression-to-functions": "^7.29.7", "@babel/helper-optimise-call-expression": "^7.29.7", "@babel/traverse": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ=="],
+
+    "@babel/helper-skip-transparent-expression-wrappers": ["@babel/helper-skip-transparent-expression-wrappers@7.29.7", "", { "dependencies": { "@babel/traverse": "^7.29.7", "@babel/types": "^7.29.7" } }, "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ=="],
+
+    "@babel/helper-string-parser": ["@babel/helper-string-parser@7.29.7", "", {}, "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw=="],
+
+    "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.29.7", "", {}, "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg=="],
+
+    "@babel/helper-validator-option": ["@babel/helper-validator-option@7.29.7", "", {}, "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw=="],
+
+    "@babel/helpers": ["@babel/helpers@7.29.7", "", { "dependencies": { "@babel/template": "^7.29.7", "@babel/types": "^7.29.7" } }, "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg=="],
+
+    "@babel/parser": ["@babel/parser@7.29.7", "", { "dependencies": { "@babel/types": "^7.29.7" }, "bin": "./bin/babel-parser.js" }, "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg=="],
+
+    "@babel/plugin-syntax-jsx": ["@babel/plugin-syntax-jsx@7.29.7", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A=="],
+
+    "@babel/plugin-syntax-typescript": ["@babel/plugin-syntax-typescript@7.29.7", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA=="],
+
+    "@babel/plugin-transform-modules-commonjs": ["@babel/plugin-transform-modules-commonjs@7.29.7", "", { "dependencies": { "@babel/helper-module-transforms": "^7.29.7", "@babel/helper-plugin-utils": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ=="],
+
+    "@babel/plugin-transform-typescript": ["@babel/plugin-transform-typescript@7.29.7", "", { "dependencies": { "@babel/helper-annotate-as-pure": "^7.29.7", "@babel/helper-create-class-features-plugin": "^7.29.7", "@babel/helper-plugin-utils": "^7.29.7", "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7", "@babel/plugin-syntax-typescript": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-jK52h8LaLc7JarhQV2ofeFMts4H7vnOXnqZNA6fYglBTZewRBE51KWt3BUltW1P+KoPsYkHoJeXePuz4zo2LMw=="],
+
+    "@babel/preset-typescript": ["@babel/preset-typescript@7.29.7", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.29.7", "@babel/helper-validator-option": "^7.29.7", "@babel/plugin-syntax-jsx": "^7.29.7", "@babel/plugin-transform-modules-commonjs": "^7.29.7", "@babel/plugin-transform-typescript": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-/Foi8vKY2EVbed/1eZx0gJEEwHAIxogrySI7rULcRIvhZzbvoE/b5qG5Ghc0WKAFKOHA9SD1x7RsFlOYdutIiQ=="],
+
+    "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="],
+
+    "@babel/template": ["@babel/template@7.29.7", "", { "dependencies": { "@babel/code-frame": "^7.29.7", "@babel/parser": "^7.29.7", "@babel/types": "^7.29.7" } }, "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg=="],
+
+    "@babel/traverse": ["@babel/traverse@7.29.7", "", { "dependencies": { "@babel/code-frame": "^7.29.7", "@babel/generator": "^7.29.7", "@babel/helper-globals": "^7.29.7", "@babel/parser": "^7.29.7", "@babel/template": "^7.29.7", "@babel/types": "^7.29.7", "debug": "^4.3.1" } }, "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw=="],
+
+    "@babel/types": ["@babel/types@7.29.7", "", { "dependencies": { "@babel/helper-string-parser": "^7.29.7", "@babel/helper-validator-identifier": "^7.29.7" } }, "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA=="],
+
+    "@base-ui/react": ["@base-ui/react@1.6.0", "", { "dependencies": { "@babel/runtime": "^7.29.2", "@base-ui/utils": "0.3.1", "@floating-ui/react-dom": "^2.1.8", "@floating-ui/utils": "^0.2.11", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "@date-fns/tz": "^1.2.0", "@types/react": "^17 || ^18 || ^19", "date-fns": "^4.0.0", "react": "^17 || ^18 || ^19", "react-dom": "^17 || ^18 || ^19" }, "optionalPeers": ["@date-fns/tz", "@types/react", "date-fns"] }, "sha512-/jzjTWJYXhRFO45Bev9lc3cHbmjzCMpUqbMZ2AgKy/z25mY9B6shGSNcXcjQar9n5doM0KYW1W8fcFv2jZBuMw=="],
+
+    "@base-ui/utils": ["@base-ui/utils@0.3.1", "", { "dependencies": { "@babel/runtime": "^7.29.2", "@floating-ui/utils": "^0.2.11", "reselect": "^5.2.0", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "@types/react": "^17 || ^18 || ^19", "react": "^17 || ^18 || ^19", "react-dom": "^17 || ^18 || ^19" }, "optionalPeers": ["@types/react"] }, "sha512-gFFiltORVmW/N6IILTGxizP3PBpVpysqML1ALY5Vk0mH+7faVkCknOU31goYHN5Aoek2dkjxva1XOD2Ce9WuIg=="],
+
+    "@bcoe/v8-coverage": ["@bcoe/v8-coverage@1.0.2", "", {}, "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA=="],
+
+    "@biomejs/biome": ["@biomejs/biome@2.4.5", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.4.5", "@biomejs/cli-darwin-x64": "2.4.5", "@biomejs/cli-linux-arm64": "2.4.5", "@biomejs/cli-linux-arm64-musl": "2.4.5", "@biomejs/cli-linux-x64": "2.4.5", "@biomejs/cli-linux-x64-musl": "2.4.5", "@biomejs/cli-win32-arm64": "2.4.5", "@biomejs/cli-win32-x64": "2.4.5" }, "bin": { "biome": "bin/biome" } }, "sha512-OWNCyMS0Q011R6YifXNOg6qsOg64IVc7XX6SqGsrGszPbkVCoaO7Sr/lISFnXZ9hjQhDewwZ40789QmrG0GYgQ=="],
+
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.4.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-lGS4Nd5O3KQJ6TeWv10mElnx1phERhBxqGP/IKq0SvZl78kcWDFMaTtVK+w3v3lusRFxJY78n07PbKplirsU5g=="],
+
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.4.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-6MoH4tyISIBNkZ2Q5T1R7dLd5BsITb2yhhhrU9jHZxnNSNMWl+s2Mxu7NBF8Y3a7JJcqq9nsk8i637z4gqkJxQ=="],
+
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.4.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-U1GAG6FTjhAO04MyH4xn23wRNBkT6H7NentHh+8UxD6ShXKBm5SY4RedKJzkUThANxb9rUKIPc7B8ew9Xo/cWg=="],
+
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.4.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-iqLDgpzobG7gpBF0fwEVS/LT8kmN7+S0E2YKFDtqliJfzNLnAiV2Nnyb+ehCDCJgAZBASkYHR2o60VQWikpqIg=="],
+
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.4.5", "", { "os": "linux", "cpu": "x64" }, "sha512-NdODlSugMzTlENPTa4z0xB82dTUlCpsrOxc43///aNkTLblIYH4XpYflBbf5ySlQuP8AA4AZd1qXhV07IdrHdQ=="],
+
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.4.5", "", { "os": "linux", "cpu": "x64" }, "sha512-NlKa7GpbQmNhZf9kakQeddqZyT7itN7jjWdakELeXyTU3pg/83fTysRRDPJD0akTfKDl6vZYNT9Zqn4MYZVBOA=="],
+
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.4.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-EBfrTqRIWOFSd7CQb/0ttjHMR88zm3hGravnDwUA9wHAaCAYsULKDebWcN5RmrEo1KBtl/gDVJMrFjNR0pdGUw=="],
+
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.4.5", "", { "os": "win32", "cpu": "x64" }, "sha512-Pmhv9zT95YzECfjEHNl3mN9Vhusw9VA5KHY0ZvlGsxsjwS5cb7vpRnHzJIv0vG7jB0JI7xEaMH9ddfZm/RozBw=="],
+
+    "@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.2", "", {}, "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA=="],
+
+    "@bufbuild/buf": ["@bufbuild/buf@1.71.0", "", { "optionalDependencies": { "@bufbuild/buf-darwin-arm64": "1.71.0", "@bufbuild/buf-darwin-x64": "1.71.0", "@bufbuild/buf-linux-aarch64": "1.71.0", "@bufbuild/buf-linux-armv7": "1.71.0", "@bufbuild/buf-linux-x64": "1.71.0", "@bufbuild/buf-win32-arm64": "1.71.0", "@bufbuild/buf-win32-x64": "1.71.0" }, "bin": { "buf": "bin/buf", "protoc-gen-buf-breaking": "bin/protoc-gen-buf-breaking", "protoc-gen-buf-lint": "bin/protoc-gen-buf-lint" } }, "sha512-GDcjBCwLgHT/4nX4YSnYatZ7sDZDpHV6dxQvoT2/P6gKvV23O6hl8NryzLIRKmeau0FRXpQKHVy1dMfnBSpy+w=="],
+
+    "@bufbuild/buf-darwin-arm64": ["@bufbuild/buf-darwin-arm64@1.71.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-qZ7xZQyen/jOKFPVs3dlN9pMA56PI4YEo3r4/9ixtiH9gyFgfowR31axsocUgXGThjiN8mvOA8WfpG2tvaSvsw=="],
+
+    "@bufbuild/buf-darwin-x64": ["@bufbuild/buf-darwin-x64@1.71.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-2w95pc3X+z06/J66i6uNzA8QPuVOpbPrwyb6tkK0AcJFNvKPVYr4BxVC2koyImrQ3rxY1n9q8qviWMjSvq9fOA=="],
+
+    "@bufbuild/buf-linux-aarch64": ["@bufbuild/buf-linux-aarch64@1.71.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-dwxErryMI3MRwtP/IgfdrqEjiAmVpttGhmO3xihiJIV2EAXt9J5yjzHhEDvnSgQ6nmNjEvO5QczcIaQjZEwF6A=="],
+
+    "@bufbuild/buf-linux-armv7": ["@bufbuild/buf-linux-armv7@1.71.0", "", { "os": "linux", "cpu": "arm" }, "sha512-pfc+Qexm5C59VeRUjVmEvxkCXT5QbMR1R/CUtcSlk+spOFVwna0bSpkqIsky3kkHfzxiNSOsz3iki9/pAVX+CA=="],
+
+    "@bufbuild/buf-linux-x64": ["@bufbuild/buf-linux-x64@1.71.0", "", { "os": "linux", "cpu": "x64" }, "sha512-Y7jLxr3wpMkpQSqZU/MrDmDSCkF4GxvhIL7wnNdSRpkhYAY6TPRHN+5nNgV7jp6mQ0zQSYh0MGxBeMgt/UVdmQ=="],
+
+    "@bufbuild/buf-win32-arm64": ["@bufbuild/buf-win32-arm64@1.71.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-UrxtD99zLE1qImtQC/W3a9cuj0/kB53B1bK38kmCMRFow939FhdZtqTRjbnZWauRi/pzAsjDyPCvnTa2XKT8Cg=="],
+
+    "@bufbuild/buf-win32-x64": ["@bufbuild/buf-win32-x64@1.71.0", "", { "os": "win32", "cpu": "x64" }, "sha512-+npiOimJ7ggeLul3KFwSlOjZnAZYwt3el64dJ3nJQMnui0avyvsRmU02o1bZI5yUnBvhcnTWdEbfRXUnkkVtgQ=="],
+
+    "@bufbuild/protobuf": ["@bufbuild/protobuf@2.12.1", "", {}, "sha512-BvAMfS6LrgZiryOAZ4pBYucu4wG/Ei/9o9DZ9akbREnMLbPJiom2i8b9C8IsKErQoiKqVhrerzt3kOT/RrzLHg=="],
+
+    "@chat-adapter/discord": ["@chat-adapter/discord@4.32.0", "", { "dependencies": { "@chat-adapter/shared": "4.32.0", "chat": "4.32.0", "discord-api-types": "^0.37.119", "discord-interactions": "^4.4.0", "discord.js": "^14.25.1" } }, "sha512-npJGIv0jjhhupKdLSF6Di+64mJXFkwEDfx/DOlDn41x66KnJjx2QcqvkuPBpx557kSwWXLgwIq5KWx/rQ+tEPg=="],
+
+    "@chat-adapter/gchat": ["@chat-adapter/gchat@4.32.0", "", { "dependencies": { "@chat-adapter/shared": "4.32.0", "@googleapis/chat": "^44.6.0", "@googleapis/workspaceevents": "^9.1.0", "chat": "4.32.0" } }, "sha512-QQRRpTmsIt1seYeZONalIurzpxJqHC1g8GEG+TJaCD5OamL65c4GTQJhRdA7FBgOZHEkvwT/TiKNwp4twK0cCA=="],
+
+    "@chat-adapter/linear": ["@chat-adapter/linear@4.32.0", "", { "dependencies": { "@chat-adapter/shared": "4.32.0", "@linear/sdk": "^76.0.0", "chat": "4.32.0" } }, "sha512-ibOpeURIjpjxF2OyJ3hTYnVbT2oSKRbOUFhb+KJaw+YBUUHTXwcPCeUGhW+dLVBKOFiBZU3hO12eYbpXueQobA=="],
+
+    "@chat-adapter/shared": ["@chat-adapter/shared@4.32.0", "", { "dependencies": { "chat": "4.32.0" } }, "sha512-ANXYe2dbSmr9A+yUAnV8TfFht4GM6f3zR5LnAYtQdNnRI9CJfXIUXuhRaVBe5RD8IEgGXyGi4BKj5qdjBtUumA=="],
+
+    "@chat-adapter/slack": ["@chat-adapter/slack@4.32.0", "", { "dependencies": { "@chat-adapter/shared": "4.32.0", "@slack/socket-mode": "^2.0.5", "@slack/web-api": "^7.14.0", "chat": "4.32.0" } }, "sha512-QZ7KYV8K1w5O91JzMuz5qTCpUaWfEgcxr/UFrBKSp30ZdaHbLH7BqOXHYLoFVwFnoEwKpInCgCgpEl36IU9ffQ=="],
+
+    "@chat-adapter/telegram": ["@chat-adapter/telegram@4.32.0", "", { "dependencies": { "@chat-adapter/shared": "4.32.0", "chat": "4.32.0" } }, "sha512-3QzXYJsT3vJMAP0KDrhSyppJ5bKo243ruytgCPyjqJ2J705J6Wy+KLD41b24hp6swYhpNGH1s5xOHpvPbNg/0g=="],
+
+    "@chat-adapter/whatsapp": ["@chat-adapter/whatsapp@4.32.0", "", { "dependencies": { "@chat-adapter/shared": "4.32.0", "chat": "4.32.0" } }, "sha512-n3MbH4aSYpAk4mFKjuAvva4yJH94n1WA+47xNOHu7TLgoIPt1i96DOsERXCpiKqGlC/Nc+1/04DgYGzSTj6WWQ=="],
+
+    "@chevrotain/types": ["@chevrotain/types@11.1.2", "", {}, "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw=="],
+
+    "@clack/core": ["@clack/core@1.4.2", "", { "dependencies": { "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-0Ty/1Gfm+Kb07sXcuESjyKfwEhSy4Ns1AgeEisHb/bDY5fWme0tTeTkU14T1Gmcs17YIjB/teiDe4uaCghbYqQ=="],
+
+    "@clack/prompts": ["@clack/prompts@1.6.0", "", { "dependencies": { "@clack/core": "1.4.2", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-EYlRokl8szrP9Z25qT5aepMdBjzBvHF9ZEhzIiUBc9guz/T31EqRgvD0QSgZcpE93xiwrr+OkB4nz0BZyF6fSA=="],
+
+    "@cline/agents": ["@cline/agents@workspace:sdk/packages/agents"],
+
+    "@cline/cli": ["@cline/cli@workspace:apps/cli"],
+
+    "@cline/cline-hub": ["@cline/cline-hub@workspace:apps/cline-hub"],
+
+    "@cline/cline-hub-webview": ["@cline/cline-hub-webview@workspace:apps/cline-hub/src/webview"],
+
+    "@cline/code": ["@cline/code@workspace:apps/examples/desktop-app"],
+
+    "@cline/core": ["@cline/core@workspace:sdk/packages/core"],
+
+    "@cline/example-cli-agent": ["@cline/example-cli-agent@workspace:apps/examples/cli-agent"],
+
+    "@cline/example-cline-core-cli-agent": ["@cline/example-cline-core-cli-agent@workspace:apps/examples/cline-core-cli-agent"],
+
+    "@cline/example-code-review-bot": ["@cline/example-code-review-bot@workspace:apps/examples/code-review-bot"],
+
+    "@cline/example-multi-agent": ["@cline/example-multi-agent@workspace:apps/examples/multi-agent"],
+
+    "@cline/example-quickstart": ["@cline/example-quickstart@workspace:apps/examples/quickstart"],
+
+    "@cline/llms": ["@cline/llms@workspace:sdk/packages/llms"],
+
+    "@cline/menubar": ["@cline/menubar@workspace:apps/examples/menubar"],
+
+    "@cline/sdk": ["@cline/sdk@workspace:sdk/packages/sdk"],
+
+    "@cline/shared": ["@cline/shared@workspace:sdk/packages/shared"],
+
+    "@cline/vscode": ["@cline/vscode@workspace:apps/examples/vscode"],
+
+    "@colors/colors": ["@colors/colors@1.6.0", "", {}, "sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA=="],
+
+    "@cspotcode/source-map-support": ["@cspotcode/source-map-support@0.8.1", "", { "dependencies": { "@jridgewell/trace-mapping": "0.3.9" } }, "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw=="],
+
+    "@csstools/color-helpers": ["@csstools/color-helpers@5.1.0", "", {}, "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA=="],
+
+    "@csstools/css-calc": ["@csstools/css-calc@2.1.4", "", { "peerDependencies": { "@csstools/css-parser-algorithms": "^3.0.5", "@csstools/css-tokenizer": "^3.0.4" } }, "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ=="],
+
+    "@csstools/css-color-parser": ["@csstools/css-color-parser@3.1.0", "", { "dependencies": { "@csstools/color-helpers": "^5.1.0", "@csstools/css-calc": "^2.1.4" }, "peerDependencies": { "@csstools/css-parser-algorithms": "^3.0.5", "@csstools/css-tokenizer": "^3.0.4" } }, "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA=="],
+
+    "@csstools/css-parser-algorithms": ["@csstools/css-parser-algorithms@3.0.5", "", { "peerDependencies": { "@csstools/css-tokenizer": "^3.0.4" } }, "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ=="],
+
+    "@csstools/css-tokenizer": ["@csstools/css-tokenizer@3.0.4", "", {}, "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw=="],
+
+    "@dabh/diagnostics": ["@dabh/diagnostics@2.0.8", "", { "dependencies": { "@so-ric/colorspace": "^1.1.6", "enabled": "2.0.x", "kuler": "^2.0.0" } }, "sha512-R4MSXTVnuMzGD7bzHdW2ZhhdPC/igELENcq5IjEverBvq5hn1SXCWcsi6eSsdWP0/Ur+SItRRjAktmdoX/8R/Q=="],
+
+    "@date-fns/tz": ["@date-fns/tz@1.5.0", "", {}, "sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg=="],
+
+    "@dimforge/rapier2d-simd-compat": ["@dimforge/rapier2d-simd-compat@0.17.3", "", {}, "sha512-bijvwWz6NHsNj5e5i1vtd3dU2pDhthSaTUZSh14DUGGKJfw8eMnlWZsxwHBxB/a3AXVNDjL9abuHw1k9FGR+jg=="],
+
+    "@discordjs/builders": ["@discordjs/builders@1.14.1", "", { "dependencies": { "@discordjs/formatters": "^0.6.2", "@discordjs/util": "^1.2.0", "@sapphire/shapeshift": "^4.0.0", "discord-api-types": "^0.38.40", "fast-deep-equal": "^3.1.3", "ts-mixer": "^6.0.4", "tslib": "^2.6.3" } }, "sha512-gSKkhXLqs96TCzk66VZuHHl8z2bQMJFGwrXC0f33ngK+FLNau4hU1PYny3DNJfNdSH+gVMzE85/d5FQ2BpcNwQ=="],
+
+    "@discordjs/collection": ["@discordjs/collection@1.5.3", "", {}, "sha512-SVb428OMd3WO1paV3rm6tSjM4wC+Kecaa1EUGX7vc6/fddvw/6lg90z4QtCqm21zvVe92vMMDt9+DkIvjXImQQ=="],
+
+    "@discordjs/formatters": ["@discordjs/formatters@0.6.2", "", { "dependencies": { "discord-api-types": "^0.38.33" } }, "sha512-y4UPwWhH6vChKRkGdMB4odasUbHOUwy7KL+OVwF86PvT6QVOwElx+TiI1/6kcmcEe+g5YRXJFiXSXUdabqZOvQ=="],
+
+    "@discordjs/rest": ["@discordjs/rest@2.6.1", "", { "dependencies": { "@discordjs/collection": "^2.1.1", "@discordjs/util": "^1.2.0", "@sapphire/async-queue": "^1.5.3", "@sapphire/snowflake": "^3.5.5", "@vladfrangu/async_event_emitter": "^2.4.6", "discord-api-types": "^0.38.40", "magic-bytes.js": "^1.13.0", "tslib": "^2.6.3", "undici": "6.24.1" } }, "sha512-wwQdgjeaoYFiaG+atbqx6aJDpqW7JHAo0HrQkBTbYzM3/PJ3GweQIpgElNcGZ26DCUOXMyawYd0YF7vtr+fZXg=="],
+
+    "@discordjs/util": ["@discordjs/util@1.2.0", "", { "dependencies": { "discord-api-types": "^0.38.33" } }, "sha512-3LKP7F2+atl9vJFhaBjn4nOaSWahZ/yWjOvA4e5pnXkt2qyXRCHLxoBQy81GFtLGCq7K9lPm9R517M1U+/90Qg=="],
+
+    "@discordjs/ws": ["@discordjs/ws@1.2.3", "", { "dependencies": { "@discordjs/collection": "^2.1.0", "@discordjs/rest": "^2.5.1", "@discordjs/util": "^1.1.0", "@sapphire/async-queue": "^1.5.2", "@types/ws": "^8.5.10", "@vladfrangu/async_event_emitter": "^2.2.4", "discord-api-types": "^0.38.1", "tslib": "^2.6.2", "ws": "^8.17.0" } }, "sha512-wPlQDxEmlDg5IxhJPuxXr3Vy9AjYq5xCvFWGJyD7w7Np8ZGu+Mc+97LCoEc/+AYCo2IDpKioiH0/c/mj5ZR9Uw=="],
+
+    "@dotenvx/dotenvx": ["@dotenvx/dotenvx@1.75.1", "", { "dependencies": { "@dotenvx/primitives": "^0.8.0", "commander": "^11.1.0", "conf": "^10.2.0", "dotenv": "^17.2.1", "enquirer": "^2.4.1", "env-paths": "^2.2.1", "execa": "^5.1.1", "fdir": "^6.2.0", "ignore": "^5.3.0", "object-treeify": "1.1.33", "open": "^8.4.2", "picomatch": "^4.0.4", "systeminformation": "^5.22.11", "undici": "^7.11.0", "which": "^4.0.0", "yocto-spinner": "^1.1.0" }, "bin": { "dotenvx": "src/cli/dotenvx.js" } }, "sha512-/BITOC9dmS/edY2zQwZNicQ059O6RKabtQfyEafV0nGtfYRNHYy1DIPiYVcov40+tob9hfmBnbR963dS+EQ1DQ=="],
+
+    "@dotenvx/primitives": ["@dotenvx/primitives@0.8.0", "", {}, "sha512-VYJy0uhFm9zTJ1TxBaW/pA8bjbOM/OttaNMwZ1RHG4JKyRG7DhSdiqD1ipQoAyoD22olUtxbP78W9xY3Wd11bg=="],
+
+    "@emnapi/core": ["@emnapi/core@1.11.1", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.2", "tslib": "^2.4.0" } }, "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ=="],
+
+    "@emnapi/runtime": ["@emnapi/runtime@1.11.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw=="],
+
+    "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA=="],
+
+    "@emotion/is-prop-valid": ["@emotion/is-prop-valid@1.4.0", "", { "dependencies": { "@emotion/memoize": "^0.9.0" } }, "sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw=="],
+
+    "@emotion/memoize": ["@emotion/memoize@0.9.0", "", {}, "sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.7", "", { "os": "android", "cpu": "arm64" }, "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.27.7", "", { "os": "android", "cpu": "x64" }, "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.7", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.7", "", { "os": "freebsd", "cpu": "x64" }, "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.7", "", { "os": "linux", "cpu": "arm" }, "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.7", "", { "os": "linux", "cpu": "ia32" }, "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.7", "", { "os": "linux", "cpu": "ppc64" }, "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.7", "", { "os": "linux", "cpu": "s390x" }, "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.7", "", { "os": "linux", "cpu": "x64" }, "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.7", "", { "os": "none", "cpu": "x64" }, "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.7", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.7", "", { "os": "openbsd", "cpu": "x64" }, "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.7", "", { "os": "sunos", "cpu": "x64" }, "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.7", "", { "os": "win32", "cpu": "ia32" }, "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.7", "", { "os": "win32", "cpu": "x64" }, "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg=="],
+
+    "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.9.1", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ=="],
+
+    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="],
+
+    "@eslint/config-array": ["@eslint/config-array@0.21.2", "", { "dependencies": { "@eslint/object-schema": "^2.1.7", "debug": "^4.3.1", "minimatch": "^3.1.5" } }, "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw=="],
+
+    "@eslint/config-helpers": ["@eslint/config-helpers@0.4.2", "", { "dependencies": { "@eslint/core": "^0.17.0" } }, "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw=="],
+
+    "@eslint/core": ["@eslint/core@0.17.0", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ=="],
+
+    "@eslint/eslintrc": ["@eslint/eslintrc@3.3.5", "", { "dependencies": { "ajv": "^6.14.0", "debug": "^4.3.2", "espree": "^10.0.1", "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.1", "minimatch": "^3.1.5", "strip-json-comments": "^3.1.1" } }, "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg=="],
+
+    "@eslint/js": ["@eslint/js@9.39.4", "", {}, "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw=="],
+
+    "@eslint/object-schema": ["@eslint/object-schema@2.1.7", "", {}, "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA=="],
+
+    "@eslint/plugin-kit": ["@eslint/plugin-kit@0.4.1", "", { "dependencies": { "@eslint/core": "^0.17.0", "levn": "^0.4.1" } }, "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA=="],
+
+    "@fast-csv/format": ["@fast-csv/format@4.3.5", "", { "dependencies": { "@types/node": "^14.0.1", "lodash.escaperegexp": "^4.1.2", "lodash.isboolean": "^3.0.3", "lodash.isequal": "^4.5.0", "lodash.isfunction": "^3.0.9", "lodash.isnil": "^4.0.0" } }, "sha512-8iRn6QF3I8Ak78lNAa+Gdl5MJJBM5vRHivFtMRUWINdevNo00K7OXxS2PshawLKTejVwieIlPmK5YlLu6w4u8A=="],
+
+    "@fast-csv/parse": ["@fast-csv/parse@4.3.6", "", { "dependencies": { "@types/node": "^14.0.1", "lodash.escaperegexp": "^4.1.2", "lodash.groupby": "^4.6.0", "lodash.isfunction": "^3.0.9", "lodash.isnil": "^4.0.0", "lodash.isundefined": "^3.0.1", "lodash.uniq": "^4.5.0" } }, "sha512-uRsLYksqpbDmWaSmzvJcuApSEe38+6NQZBUsuAyMZKqHxH0g1wcJgsKUvN3WC8tewaqFjBMMGrkHmC+T7k8LvA=="],
+
+    "@firebase/ai": ["@firebase/ai@1.4.1", "", { "dependencies": { "@firebase/app-check-interop-types": "0.3.3", "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x", "@firebase/app-types": "0.x" } }, "sha512-bcusQfA/tHjUjBTnMx6jdoPMpDl3r8K15Z+snHz9wq0Foox0F/V+kNLXucEOHoTL2hTc9l+onZCyBJs2QoIC3g=="],
+
+    "@firebase/analytics": ["@firebase/analytics@0.10.17", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/installations": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-n5vfBbvzduMou/2cqsnKrIes4auaBjdhg8QNA2ZQZ59QgtO2QiwBaXQZQE4O4sgB0Ds1tvLgUUkY+pwzu6/xEg=="],
+
+    "@firebase/analytics-compat": ["@firebase/analytics-compat@0.2.23", "", { "dependencies": { "@firebase/analytics": "0.10.17", "@firebase/analytics-types": "0.8.3", "@firebase/component": "0.6.18", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-3AdO10RN18G5AzREPoFgYhW6vWXr3u+OYQv6pl3CX6Fky8QRk0AHurZlY3Q1xkXO0TDxIsdhO3y65HF7PBOJDw=="],
+
+    "@firebase/analytics-types": ["@firebase/analytics-types@0.8.3", "", {}, "sha512-VrIp/d8iq2g501qO46uGz3hjbDb8xzYMrbu8Tp0ovzIzrvJZ2fvmj649gTjge/b7cCCcjT0H37g1gVtlNhnkbg=="],
+
+    "@firebase/app": ["@firebase/app@0.13.2", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "idb": "7.1.1", "tslib": "^2.1.0" } }, "sha512-jwtMmJa1BXXDCiDx1vC6SFN/+HfYG53UkfJa6qeN5ogvOunzbFDO3wISZy5n9xgYFUrEP6M7e8EG++riHNTv9w=="],
+
+    "@firebase/app-check": ["@firebase/app-check@0.10.1", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-MgNdlms9Qb0oSny87pwpjKush9qUwCJhfmTJHDfrcKo4neLGiSeVE4qJkzP7EQTIUFKp84pbTxobSAXkiuQVYQ=="],
+
+    "@firebase/app-check-compat": ["@firebase/app-check-compat@0.3.26", "", { "dependencies": { "@firebase/app-check": "0.10.1", "@firebase/app-check-types": "0.5.3", "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-PkX+XJMLDea6nmnopzFKlr+s2LMQGqdyT2DHdbx1v1dPSqOol2YzgpgymmhC67vitXVpNvS3m/AiWQWWhhRRPQ=="],
+
+    "@firebase/app-check-interop-types": ["@firebase/app-check-interop-types@0.3.3", "", {}, "sha512-gAlxfPLT2j8bTI/qfe3ahl2I2YcBQ8cFIBdhAQA4I2f3TndcO+22YizyGYuttLHPQEpWkhmpFW60VCFEPg4g5A=="],
+
+    "@firebase/app-check-types": ["@firebase/app-check-types@0.5.3", "", {}, "sha512-hyl5rKSj0QmwPdsAxrI5x1otDlByQ7bvNvVt8G/XPO2CSwE++rmSVf3VEhaeOR4J8ZFaF0Z0NDSmLejPweZ3ng=="],
+
+    "@firebase/app-compat": ["@firebase/app-compat@0.4.2", "", { "dependencies": { "@firebase/app": "0.13.2", "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" } }, "sha512-LssbyKHlwLeiV8GBATyOyjmHcMpX/tFjzRUCS1jnwGAew1VsBB4fJowyS5Ud5LdFbYpJeS+IQoC+RQxpK7eH3Q=="],
+
+    "@firebase/app-types": ["@firebase/app-types@0.9.3", "", {}, "sha512-kRVpIl4vVGJ4baogMDINbyrIOtOxqhkZQg4jTq3l8Lw6WSk0xfpEYzezFu+Kl4ve4fbPl79dvwRtaFqAC/ucCw=="],
+
+    "@firebase/auth": ["@firebase/auth@1.10.8", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x", "@react-native-async-storage/async-storage": "^1.18.1" }, "optionalPeers": ["@react-native-async-storage/async-storage"] }, "sha512-GpuTz5ap8zumr/ocnPY57ZanX02COsXloY6Y/2LYPAuXYiaJRf6BAGDEdRq1BMjP93kqQnKNuKZUTMZbQ8MNYA=="],
+
+    "@firebase/auth-compat": ["@firebase/auth-compat@0.5.28", "", { "dependencies": { "@firebase/auth": "1.10.8", "@firebase/auth-types": "0.13.0", "@firebase/component": "0.6.18", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-HpMSo/cc6Y8IX7bkRIaPPqT//Jt83iWy5rmDWeThXQCAImstkdNo3giFLORJwrZw2ptiGkOij64EH1ztNJzc7Q=="],
+
+    "@firebase/auth-interop-types": ["@firebase/auth-interop-types@0.2.4", "", {}, "sha512-JPgcXKCuO+CWqGDnigBtvo09HeBs5u/Ktc2GaFj2m01hLarbxthLNm7Fk8iOP1aqAtXV+fnnGj7U28xmk7IwVA=="],
+
+    "@firebase/auth-types": ["@firebase/auth-types@0.13.0", "", { "peerDependencies": { "@firebase/app-types": "0.x", "@firebase/util": "1.x" } }, "sha512-S/PuIjni0AQRLF+l9ck0YpsMOdE8GO2KU6ubmBB7P+7TJUCQDa3R1dlgYm9UzGbbePMZsp0xzB93f2b/CgxMOg=="],
+
+    "@firebase/component": ["@firebase/component@0.6.18", "", { "dependencies": { "@firebase/util": "1.12.1", "tslib": "^2.1.0" } }, "sha512-n28kPCkE2dL2U28fSxZJjzPPVpKsQminJ6NrzcKXAI0E/lYC8YhfwpyllScqVEvAI3J2QgJZWYgrX+1qGI+SQQ=="],
+
+    "@firebase/data-connect": ["@firebase/data-connect@0.3.10", "", { "dependencies": { "@firebase/auth-interop-types": "0.2.4", "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-VMVk7zxIkgwlVQIWHOKFahmleIjiVFwFOjmakXPd/LDgaB/5vzwsB5DWIYo+3KhGxWpidQlR8geCIn39YflJIQ=="],
+
+    "@firebase/database": ["@firebase/database@1.0.20", "", { "dependencies": { "@firebase/app-check-interop-types": "0.3.3", "@firebase/auth-interop-types": "0.2.4", "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "faye-websocket": "0.11.4", "tslib": "^2.1.0" } }, "sha512-H9Rpj1pQ1yc9+4HQOotFGLxqAXwOzCHsRSRjcQFNOr8lhUt6LeYjf0NSRL04sc4X0dWe8DsCvYKxMYvFG/iOJw=="],
+
+    "@firebase/database-compat": ["@firebase/database-compat@2.0.11", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/database": "1.0.20", "@firebase/database-types": "1.0.15", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" } }, "sha512-itEsHARSsYS95+udF/TtIzNeQ0Uhx4uIna0sk4E0wQJBUnLc/G1X6D7oRljoOuwwCezRLGvWBRyNrugv/esOEw=="],
+
+    "@firebase/database-types": ["@firebase/database-types@1.0.15", "", { "dependencies": { "@firebase/app-types": "0.9.3", "@firebase/util": "1.12.1" } }, "sha512-XWHJ0VUJ0k2E9HDMlKxlgy/ZuTa9EvHCGLjaKSUvrQnwhgZuRU5N3yX6SZ+ftf2hTzZmfRkv+b3QRvGg40bKNw=="],
+
+    "@firebase/firestore": ["@firebase/firestore@4.8.0", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "@firebase/webchannel-wrapper": "1.0.3", "@grpc/grpc-js": "~1.9.0", "@grpc/proto-loader": "^0.7.8", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-QSRk+Q1/CaabKyqn3C32KSFiOdZpSqI9rpLK5BHPcooElumOBooPFa6YkDdiT+/KhJtel36LdAacha9BptMj2A=="],
+
+    "@firebase/firestore-compat": ["@firebase/firestore-compat@0.3.53", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/firestore": "4.8.0", "@firebase/firestore-types": "3.0.3", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-qI3yZL8ljwAYWrTousWYbemay2YZa+udLWugjdjju2KODWtLG94DfO4NALJgPLv8CVGcDHNFXoyQexdRA0Cz8Q=="],
+
+    "@firebase/firestore-types": ["@firebase/firestore-types@3.0.3", "", { "peerDependencies": { "@firebase/app-types": "0.x", "@firebase/util": "1.x" } }, "sha512-hD2jGdiWRxB/eZWF89xcK9gF8wvENDJkzpVFb4aGkzfEaKxVRD1kjz1t1Wj8VZEp2LCB53Yx1zD8mrhQu87R6Q=="],
+
+    "@firebase/functions": ["@firebase/functions@0.12.9", "", { "dependencies": { "@firebase/app-check-interop-types": "0.3.3", "@firebase/auth-interop-types": "0.2.4", "@firebase/component": "0.6.18", "@firebase/messaging-interop-types": "0.2.3", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-FG95w6vjbUXN84Ehezc2SDjGmGq225UYbHrb/ptkRT7OTuCiQRErOQuyt1jI1tvcDekdNog+anIObihNFz79Lg=="],
+
+    "@firebase/functions-compat": ["@firebase/functions-compat@0.3.26", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/functions": "0.12.9", "@firebase/functions-types": "0.6.3", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-A798/6ff5LcG2LTWqaGazbFYnjBW8zc65YfID/en83ALmkhu2b0G8ykvQnLtakbV9ajrMYPn7Yc/XcYsZIUsjA=="],
+
+    "@firebase/functions-types": ["@firebase/functions-types@0.6.3", "", {}, "sha512-EZoDKQLUHFKNx6VLipQwrSMh01A1SaL3Wg6Hpi//x6/fJ6Ee4hrAeswK99I5Ht8roiniKHw4iO0B1Oxj5I4plg=="],
+
+    "@firebase/installations": ["@firebase/installations@0.6.18", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/util": "1.12.1", "idb": "7.1.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-NQ86uGAcvO8nBRwVltRL9QQ4Reidc/3whdAasgeWCPIcrhOKDuNpAALa6eCVryLnK14ua2DqekCOX5uC9XbU/A=="],
+
+    "@firebase/installations-compat": ["@firebase/installations-compat@0.2.18", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/installations": "0.6.18", "@firebase/installations-types": "0.5.3", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-aLFohRpJO5kKBL/XYL4tN+GdwEB/Q6Vo9eZOM/6Kic7asSUgmSfGPpGUZO1OAaSRGwF4Lqnvi1f/f9VZnKzChw=="],
+
+    "@firebase/installations-types": ["@firebase/installations-types@0.5.3", "", { "peerDependencies": { "@firebase/app-types": "0.x" } }, "sha512-2FJI7gkLqIE0iYsNQ1P751lO3hER+Umykel+TkLwHj6plzWVxqvfclPUZhcKFVQObqloEBTmpi2Ozn7EkCABAA=="],
+
+    "@firebase/logger": ["@firebase/logger@0.4.4", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-mH0PEh1zoXGnaR8gD1DeGeNZtWFKbnz9hDO91dIml3iou1gpOnLqXQ2dJfB71dj6dpmUjcQ6phY3ZZJbjErr9g=="],
+
+    "@firebase/messaging": ["@firebase/messaging@0.12.22", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/installations": "0.6.18", "@firebase/messaging-interop-types": "0.2.3", "@firebase/util": "1.12.1", "idb": "7.1.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-GJcrPLc+Hu7nk+XQ70Okt3M1u1eRr2ZvpMbzbc54oTPJZySHcX9ccZGVFcsZbSZ6o1uqumm8Oc7OFkD3Rn1/og=="],
+
+    "@firebase/messaging-compat": ["@firebase/messaging-compat@0.2.22", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/messaging": "0.12.22", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-5ZHtRnj6YO6f/QPa/KU6gryjmX4Kg33Kn4gRpNU6M1K47Gm8kcQwPkX7erRUYEH1mIWptfvjvXMHWoZaWjkU7A=="],
+
+    "@firebase/messaging-interop-types": ["@firebase/messaging-interop-types@0.2.3", "", {}, "sha512-xfzFaJpzcmtDjycpDeCUj0Ge10ATFi/VHVIvEEjDNc3hodVBQADZ7BWQU7CuFpjSHE+eLuBI13z5F/9xOoGX8Q=="],
+
+    "@firebase/performance": ["@firebase/performance@0.7.7", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/installations": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0", "web-vitals": "^4.2.4" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-JTlTQNZKAd4+Q5sodpw6CN+6NmwbY72av3Lb6wUKTsL7rb3cuBIhQSrslWbVz0SwK3x0ZNcqX24qtRbwKiv+6w=="],
+
+    "@firebase/performance-compat": ["@firebase/performance-compat@0.2.20", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/performance": "0.7.7", "@firebase/performance-types": "0.2.3", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-XkFK5NmOKCBuqOKWeRgBUFZZGz9SzdTZp4OqeUg+5nyjapTiZ4XoiiUL8z7mB2q+63rPmBl7msv682J3rcDXIQ=="],
+
+    "@firebase/performance-types": ["@firebase/performance-types@0.2.3", "", {}, "sha512-IgkyTz6QZVPAq8GSkLYJvwSLr3LS9+V6vNPQr0x4YozZJiLF5jYixj0amDtATf1X0EtYHqoPO48a9ija8GocxQ=="],
+
+    "@firebase/remote-config": ["@firebase/remote-config@0.6.5", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/installations": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-fU0c8HY0vrVHwC+zQ/fpXSqHyDMuuuglV94VF6Yonhz8Fg2J+KOowPGANM0SZkLvVOYpTeWp3ZmM+F6NjwWLnw=="],
+
+    "@firebase/remote-config-compat": ["@firebase/remote-config-compat@0.2.18", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/logger": "0.4.4", "@firebase/remote-config": "0.6.5", "@firebase/remote-config-types": "0.4.0", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-YiETpldhDy7zUrnS8e+3l7cNs0sL7+tVAxvVYU0lu7O+qLHbmdtAxmgY+wJqWdW2c9nDvBFec7QiF58pEUu0qQ=="],
+
+    "@firebase/remote-config-types": ["@firebase/remote-config-types@0.4.0", "", {}, "sha512-7p3mRE/ldCNYt8fmWMQ/MSGRmXYlJ15Rvs9Rk17t8p0WwZDbeK7eRmoI1tvCPaDzn9Oqh+yD6Lw+sGLsLg4kKg=="],
+
+    "@firebase/storage": ["@firebase/storage@0.13.14", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app": "0.x" } }, "sha512-xTq5ixxORzx+bfqCpsh+o3fxOsGoDjC1nO0Mq2+KsOcny3l7beyBhP/y1u5T6mgsFQwI1j6oAkbT5cWdDBx87g=="],
+
+    "@firebase/storage-compat": ["@firebase/storage-compat@0.3.24", "", { "dependencies": { "@firebase/component": "0.6.18", "@firebase/storage": "0.13.14", "@firebase/storage-types": "0.8.3", "@firebase/util": "1.12.1", "tslib": "^2.1.0" }, "peerDependencies": { "@firebase/app-compat": "0.x" } }, "sha512-XHn2tLniiP7BFKJaPZ0P8YQXKiVJX+bMyE2j2YWjYfaddqiJnROJYqSomwW6L3Y+gZAga35ONXUJQju6MB6SOQ=="],
+
+    "@firebase/storage-types": ["@firebase/storage-types@0.8.3", "", { "peerDependencies": { "@firebase/app-types": "0.x", "@firebase/util": "1.x" } }, "sha512-+Muk7g9uwngTpd8xn9OdF/D48uiQ7I1Fae7ULsWPuKoCH3HU7bfFPhxtJYzyhjdniowhuDpQcfPmuNRAqZEfvg=="],
+
+    "@firebase/util": ["@firebase/util@1.12.1", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-zGlBn/9Dnya5ta9bX/fgEoNC3Cp8s6h+uYPYaDieZsFOAdHP/ExzQ/eaDgxD3GOROdPkLKpvKY0iIzr9adle0w=="],
+
+    "@firebase/webchannel-wrapper": ["@firebase/webchannel-wrapper@1.0.3", "", {}, "sha512-2xCRM9q9FlzGZCdgDMJwc0gyUkWFtkosy7Xxr6sFgQwn+wMNIWd7xIvYNauU1r64B5L5rsGKy/n9TKJ0aAFeqQ=="],
+
+    "@floating-ui/core": ["@floating-ui/core@1.7.5", "", { "dependencies": { "@floating-ui/utils": "^0.2.11" } }, "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ=="],
+
+    "@floating-ui/dom": ["@floating-ui/dom@1.7.6", "", { "dependencies": { "@floating-ui/core": "^1.7.5", "@floating-ui/utils": "^0.2.11" } }, "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ=="],
+
+    "@floating-ui/react": ["@floating-ui/react@0.27.19", "", { "dependencies": { "@floating-ui/react-dom": "^2.1.8", "@floating-ui/utils": "^0.2.11", "tabbable": "^6.0.0" }, "peerDependencies": { "react": ">=17.0.0", "react-dom": ">=17.0.0" } }, "sha512-31B8h5mm8YxotlE7/AU/PhNAl8eWxAmjL/v2QOxroDNkTFLk3Uu82u63N3b6TXa4EGJeeZLVcd/9AlNlVqzeog=="],
+
+    "@floating-ui/react-dom": ["@floating-ui/react-dom@2.1.8", "", { "dependencies": { "@floating-ui/dom": "^1.7.6" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A=="],
+
+    "@floating-ui/utils": ["@floating-ui/utils@0.2.11", "", {}, "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg=="],
+
+    "@fontsource-variable/geist": ["@fontsource-variable/geist@5.2.9", "", {}, "sha512-TP+QSBG3wxKGPE33CbMy/L0Nu3qvJ6Fy81Yc4LnQ95xH+i+cfEp8fyU8/kfV14YwszxIFPhnoMTbjL71waVpyQ=="],
+
+    "@fontsource-variable/schibsted-grotesk": ["@fontsource-variable/schibsted-grotesk@5.2.8", "", {}, "sha512-nZAorDrFue4dXZbI613WdvAhu5DPH1UJYNn5fWl7Poa+nl/s9o3VUcQImIiVZpQnYG/jkPVzHsTE7WZbSDvvkw=="],
+
+    "@fontsource/azeret-mono": ["@fontsource/azeret-mono@5.2.11", "", {}, "sha512-DlufUsIj1AK6Z/26X/1bZj4SFsfuE6Cb1wYToGX3HoxTYrNzN0TUQ3Yv8bJ3kmvO3vOTCgOjFV81OJe2FERrUg=="],
+
+    "@formatjs/ecma402-abstract": ["@formatjs/ecma402-abstract@2.3.6", "", { "dependencies": { "@formatjs/fast-memoize": "2.2.7", "@formatjs/intl-localematcher": "0.6.2", "decimal.js": "^10.4.3", "tslib": "^2.8.0" } }, "sha512-HJnTFeRM2kVFVr5gr5kH1XP6K0JcJtE7Lzvtr3FS/so5f1kpsqqqxy5JF+FRaO6H2qmcMfAUIox7AJteieRtVw=="],
+
+    "@formatjs/fast-memoize": ["@formatjs/fast-memoize@2.2.7", "", { "dependencies": { "tslib": "^2.8.0" } }, "sha512-Yabmi9nSvyOMrlSeGGWDiH7rf3a7sIwplbvo/dlz9WCIjzIQAfy1RMf4S0X3yG724n5Ghu2GmEl5NJIV6O9sZQ=="],
+
+    "@formatjs/icu-messageformat-parser": ["@formatjs/icu-messageformat-parser@2.11.4", "", { "dependencies": { "@formatjs/ecma402-abstract": "2.3.6", "@formatjs/icu-skeleton-parser": "1.8.16", "tslib": "^2.8.0" } }, "sha512-7kR78cRrPNB4fjGFZg3Rmj5aah8rQj9KPzuLsmcSn4ipLXQvC04keycTI1F7kJYDwIXtT2+7IDEto842CfZBtw=="],
+
+    "@formatjs/icu-skeleton-parser": ["@formatjs/icu-skeleton-parser@1.8.16", "", { "dependencies": { "@formatjs/ecma402-abstract": "2.3.6", "tslib": "^2.8.0" } }, "sha512-H13E9Xl+PxBd8D5/6TVUluSpxGNvFSlN/b3coUp0e0JpuWXXnQDiavIpY3NnvSp4xhEMoXyyBvVfdFX8jglOHQ=="],
+
+    "@formatjs/intl-localematcher": ["@formatjs/intl-localematcher@0.6.2", "", { "dependencies": { "tslib": "^2.8.0" } }, "sha512-XOMO2Hupl0wdd172Y06h6kLpBz6Dv+J4okPLl4LPtzbr8f66WbIoy4ev98EBuZ6ZK4h5ydTN6XneT4QVpD7cdA=="],
+
+    "@google/genai": ["@google/genai@1.52.0", "", { "dependencies": { "google-auth-library": "^10.3.0", "p-retry": "^4.6.2", "protobufjs": "^7.5.4", "ws": "^8.18.0" }, "peerDependencies": { "@modelcontextprotocol/sdk": "^1.25.2" }, "optionalPeers": ["@modelcontextprotocol/sdk"] }, "sha512-gwSvbpiN/17O9TbsqSsE/OzZcpv5Fo4RQjdngGgogtuB9RsyJ8ZHhX5KjHj1bp5N9snN2eK8LDGXSaWW2hof8Q=="],
+
+    "@googleapis/chat": ["@googleapis/chat@44.7.0", "", { "dependencies": { "googleapis-common": "^8.0.0" } }, "sha512-1TTvtQ/nRD4Yb5PcMWl1J6vN3QjOyDr3t9XtM1iRJlAO8wux5dOChJSOyAlm2IOcRrrqmL4d0DVUkgMqovHjNA=="],
+
+    "@googleapis/workspaceevents": ["@googleapis/workspaceevents@9.2.0", "", { "dependencies": { "googleapis-common": "^8.0.0" } }, "sha512-9tU0h6O/Ao9k53TQSgLs6D/mN++wKTHPIpT8tbPaayhOL3e4OhtJ3t+OD42avMe2pBmFcdRUVOSpZvqytxvWEg=="],
+
+    "@gramio/format": ["@gramio/format@0.7.0", "", { "dependencies": { "@gramio/types": "^9.6.0" }, "peerDependencies": { "marked": "^15.0.11", "node-html-parser": ">=6.0.0" }, "optionalPeers": ["marked", "node-html-parser"] }, "sha512-+qLKopeQHU3dfnwtVd7smKqyJTEYbveAj0l3hfuVwzdCfTQFdBcJvM3hhhTIcchlhUpPx7znKzw1+Vrq0GCNyg=="],
+
+    "@gramio/types": ["@gramio/types@9.6.1", "", {}, "sha512-O/tJgU98oiCVcQHXO/yyJgEn5DpIZr/OiuRp3CxIGynRLK2doWguOR+jlRZQNMR5sx5VTVBBCAPRNRJ8qBLEKw=="],
+
+    "@graphql-typed-document-node/core": ["@graphql-typed-document-node/core@3.2.0", "", { "peerDependencies": { "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" } }, "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ=="],
+
+    "@grpc/grpc-js": ["@grpc/grpc-js@1.14.4", "", { "dependencies": { "@grpc/proto-loader": "^0.8.0", "@js-sdsl/ordered-map": "^4.4.2" } }, "sha512-k9Dj3DV/itK9D06Y8f190Qgop7/Ui+D0njFV3LHMPwPT75DpXLQohE9Wmz0QElrJnzsjB7KPWiKJbOl7IPDArQ=="],
+
+    "@grpc/proto-loader": ["@grpc/proto-loader@0.7.15", "", { "dependencies": { "lodash.camelcase": "^4.3.0", "long": "^5.0.0", "protobufjs": "^7.2.5", "yargs": "^17.7.2" }, "bin": { "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" } }, "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ=="],
+
+    "@grpc/reflection": ["@grpc/reflection@1.0.4", "", { "dependencies": { "@grpc/proto-loader": "^0.7.13", "protobufjs": "^7.2.5" }, "peerDependencies": { "@grpc/grpc-js": "^1.8.21" } }, "sha512-znA8v4AviOD3OPOxy11pxrtP8k8DanpefeTymS8iGW1fVr1U2cHuzfhYqDPHnVNDf4qvF9E25KtSihPy2DBWfQ=="],
+
+    "@heroui/accordion": ["@heroui/accordion@2.2.29", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/divider": "2.2.24", "@heroui/dom-animation": "2.1.10", "@heroui/framer-utils": "2.1.28", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-accordion": "2.2.20", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-stately/tree": "3.9.6", "@react-types/accordion": "3.0.0-alpha.26", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-nhCqgZ3ejgRLRM3jJnpZExufn050raxOVyNUR7zo9o5Ed10KKRpD3J/8l6gwrYA7j+Z46dF2YLJzIFWPzYf1Kw=="],
+
+    "@heroui/alert": ["@heroui/alert@2.2.32", "", { "dependencies": { "@heroui/button": "2.2.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@react-stately/utils": "3.11.0" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-8piby1PXVTTtdwLLV60JMqduRAFLHoiQpFPeSNVHsAaMIphXsmlpvUb9dct4f0wQJqqgFutiWL3RtjdDwEkRQQ=="],
+
+    "@heroui/aria-utils": ["@heroui/aria-utils@2.2.29", "", { "dependencies": { "@heroui/system": "2.4.28", "@react-aria/utils": "3.33.1", "@react-stately/collections": "3.12.10", "@react-types/overlays": "3.9.4", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-tVc5Rz+u/WMaAoYpx4VNheFqsfxA5i0SAqT8OAFpPX0WiNrylXaAGWsid/ivFdlW4rE1FgI/+wP0KS6c8KSEjQ=="],
+
+    "@heroui/autocomplete": ["@heroui/autocomplete@2.3.34", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/button": "2.2.32", "@heroui/form": "2.1.32", "@heroui/input": "2.4.33", "@heroui/listbox": "2.3.31", "@heroui/popover": "2.3.32", "@heroui/react-utils": "2.1.14", "@heroui/scroll-shadow": "2.3.19", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/combobox": "3.15.0", "@react-aria/i18n": "3.12.16", "@react-stately/combobox": "3.13.0", "@react-types/combobox": "3.14.0", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-DTmztrWMdEtHCIJmgSyO/7QrABsaq/kDqBg6aVw+P30sgLW6k05wYOqe6ctuoNSWaZzr56QPvFpsgbeMy7Ma0A=="],
+
+    "@heroui/avatar": ["@heroui/avatar@2.2.26", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-image": "2.1.14", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-W2z64Da38ZL4Lu9Pokan2frTURcXxUs3bV37WWJjMzCD6mOAlaogWYMQdAeYmeWHyAW18XZSa5OaUCMVrzJ2SQ=="],
+
+    "@heroui/badge": ["@heroui/badge@2.2.18", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.23", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-OfGove8YJ9oDrdugzq05FC15ZKD5nzqe+thPZ+1SY1LZorJQjZvqSD9QnoEH1nG7fu2IdH6pYJy3sZ/b6Vj5Kg=="],
+
+    "@heroui/breadcrumbs": ["@heroui/breadcrumbs@2.2.25", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@react-aria/breadcrumbs": "3.5.32", "@react-aria/focus": "3.21.5", "@react-types/breadcrumbs": "3.7.19" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-KmUmJiBVzRuKR1tXIvKBqz8rGz4jAPa2FqsDodQ/Z34Eagsw85l3pI6xekKacGcxNQVM+L6KhMRb00QWHT/SmQ=="],
+
+    "@heroui/button": ["@heroui/button@2.2.32", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/ripple": "2.2.21", "@heroui/shared-utils": "2.1.12", "@heroui/spinner": "2.2.29", "@heroui/use-aria-button": "2.2.22", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-i1vx4gEuyjKmz0xVu+U3PgtYrsGt1PVuWBrT/sSbNcH0AGuPSqQPQ/znwkhgZ4ixhNaU9jjVbBfIGCFGNDz7XA=="],
+
+    "@heroui/calendar": ["@heroui/calendar@2.2.32", "", { "dependencies": { "@heroui/button": "2.2.32", "@heroui/dom-animation": "2.1.10", "@heroui/framer-utils": "2.1.28", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-button": "2.2.22", "@internationalized/date": "3.12.0", "@react-aria/calendar": "3.9.5", "@react-aria/focus": "3.21.5", "@react-aria/i18n": "3.12.16", "@react-aria/interactions": "3.27.1", "@react-aria/visually-hidden": "3.8.31", "@react-stately/calendar": "3.9.3", "@react-stately/utils": "3.11.0", "@react-types/button": "3.15.1", "@react-types/calendar": "3.8.3", "@react-types/shared": "3.33.1", "scroll-into-view-if-needed": "3.0.10" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-2xzCmM7Sdz04qYr478lcH3GfGi2HWmKZ77PXrxWyRcVys+6GQpJJS712eusQBdoDNoUHUK/qZLTxihwiDC46wg=="],
+
+    "@heroui/card": ["@heroui/card@2.2.28", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/ripple": "2.2.21", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-button": "2.2.22", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-njwCocEntWaYyALB+2SHzVzoG4JJMV2rG55vQ0zZIIJoG1+/F9SCfsZQ87ncf+0D7IQx6vw8fWT2VRKojmn9+w=="],
+
+    "@heroui/checkbox": ["@heroui/checkbox@2.3.32", "", { "dependencies": { "@heroui/form": "2.1.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-callback-ref": "2.1.8", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/checkbox": "3.16.5", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-stately/checkbox": "3.7.5", "@react-stately/toggle": "3.9.5", "@react-types/checkbox": "3.10.4", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-rmFGPTgpG/Uvlr/8KjCSobT3u2Ig4/3p8s0qwTCo37uvtsCIbCYyB1yNAXZkCN2hfg5ZIBofEaYeEmw0OBsQAQ=="],
+
+    "@heroui/chip": ["@heroui/chip@2.2.25", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-kACEoF7tP9o/q5HdARaP3veD0Rl4Uxe9fiTVQvus8kN97Jnw9y4JctsUJ/vXgsscKt39qh53TB8fo8I0sJ2FPg=="],
+
+    "@heroui/code": ["@heroui/code@2.2.25", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/system-rsc": "2.3.24" }, "peerDependencies": { "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-oGaQVktqTNqRPDceuV/egVh442Ap4cbuXxVSqsmT0aNV1KnISo/P7VwLm4QDN5T3MXxN3Cs2Pw6z0+oydPL3mA=="],
+
+    "@heroui/date-input": ["@heroui/date-input@2.3.32", "", { "dependencies": { "@heroui/form": "2.1.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@internationalized/date": "3.12.0", "@react-aria/datepicker": "3.16.1", "@react-aria/i18n": "3.12.16", "@react-stately/datepicker": "3.16.1", "@react-types/datepicker": "3.13.5", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-jk0cPMkfs0lexdJckBZ4qO96tTqT3ZMgb+Z12aS8VW3Hcbvj2vvv2fuHc7LrIg1mdUqZzZwCwUAsUGWSJDTI0w=="],
+
+    "@heroui/date-picker": ["@heroui/date-picker@2.3.33", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/button": "2.2.32", "@heroui/calendar": "2.2.32", "@heroui/date-input": "2.3.32", "@heroui/form": "2.1.32", "@heroui/popover": "2.3.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@internationalized/date": "3.12.0", "@react-aria/datepicker": "3.16.1", "@react-aria/i18n": "3.12.16", "@react-stately/datepicker": "3.16.1", "@react-stately/utils": "3.11.0", "@react-types/datepicker": "3.13.5", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-u9N2NToMLg3hwn7WEXljhrtM/DiRrUVBqs35akW9gTQtcz1fGPugrDkJy4OsKEv7c1HuYBO0As6CM+uXERjHWw=="],
+
+    "@heroui/divider": ["@heroui/divider@2.2.24", "", { "dependencies": { "@heroui/react-rsc-utils": "2.1.9", "@heroui/system-rsc": "2.3.24", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-fq7bZFpruws3aC5X2TGMMUhcInyxQS6oWAOYrwgWX5jrmqzg/8CBtIuOehhwcm0HAk+oI55KFidJUFTuA1s7Gg=="],
+
+    "@heroui/dom-animation": ["@heroui/dom-animation@2.1.10", "", { "peerDependencies": { "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1" } }, "sha512-dt+0xdVPbORwNvFT5pnqV2ULLlSgOJeqlg/DMo97s9RWeD6rD4VedNY90c8C9meqWqGegQYBQ9ztsfX32mGEPA=="],
+
+    "@heroui/drawer": ["@heroui/drawer@2.2.29", "", { "dependencies": { "@heroui/framer-utils": "2.1.28", "@heroui/modal": "2.2.29", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-zVBKHbcCXZGR79ORw4vQRA/QfHNLoQ9R8q6P1gsjs24uBGdBQAYvQE0F/bfsKZ5JH7asUt+oSIpjqQGmXAbyyQ=="],
+
+    "@heroui/dropdown": ["@heroui/dropdown@2.3.32", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/menu": "2.2.31", "@heroui/popover": "2.3.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@react-aria/focus": "3.21.5", "@react-aria/menu": "3.21.0", "@react-stately/menu": "3.9.11", "@react-types/menu": "3.10.7" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-+ntmjxkBaUVpyGN0pcByeTm2e2RUi5/D5uI9vPFLvJYWCa26bzQRR7EuK7LuGRXVciWl+NODNlLbSUVukkHBUA=="],
+
+    "@heroui/form": ["@heroui/form@2.1.32", "", { "dependencies": { "@heroui/shared-utils": "2.1.12", "@heroui/system": "2.4.28", "@heroui/theme": "2.4.26", "@react-stately/form": "3.2.4", "@react-types/form": "3.7.18", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18", "react-dom": ">=18" } }, "sha512-gcMnlNq2eI8jIvNIEas4HVmQNdkRuZnhRCx/nZOd/FtO+WQwuqN2xFAfm/nGH3Hq/7yRf2yOozuJsm7iJVaatA=="],
+
+    "@heroui/framer-utils": ["@heroui/framer-utils@2.1.28", "", { "dependencies": { "@heroui/system": "2.4.28", "@heroui/use-measure": "2.1.8" }, "peerDependencies": { "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-/M2nqHRx4feZx0lgA8QmHDaqu/DgsdynvSnbniptiU/Xi9XgQApCPJ0Qxgk5JZ9g2vemDFgi5AP7C7FqgiMtMA=="],
+
+    "@heroui/image": ["@heroui/image@2.2.19", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-image": "2.1.14" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-XdQ1g0kiHl+Kj9Zj1NL1mbKhmzeN0h27dgfegJS2coGM/yrEavYzg1DWUEyVSzPNKFZS8BDGa9DOpWe0vgggBA=="],
+
+    "@heroui/input": ["@heroui/input@2.4.33", "", { "dependencies": { "@heroui/form": "2.1.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/textfield": "3.18.5", "@react-stately/utils": "3.11.0", "@react-types/shared": "3.33.1", "@react-types/textfield": "3.12.8", "react-textarea-autosize": "^8.5.3" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-iDKujnKgXDbR4zLVr03Pg3TYKFR2zv0aPZUpjOvtLdB8/wNBQv+rbizqnHQPAYyDwhNQS0WguW0tQVhh4oPy4w=="],
+
+    "@heroui/input-otp": ["@heroui/input-otp@2.1.32", "", { "dependencies": { "@heroui/form": "2.1.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-form-reset": "2.0.1", "@react-aria/focus": "3.21.5", "@react-aria/form": "3.1.5", "@react-stately/form": "3.2.4", "@react-stately/utils": "3.11.0", "@react-types/textfield": "3.12.8", "input-otp": "1.4.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18", "react-dom": ">=18" } }, "sha512-lrByjetK5/9MjqhDXHnhAI/gBnCJjMmR92k2HARjnJjYhljD58j6xYuf41zwp/faYkyspVvmLMPHF8qjKMTAbQ=="],
+
+    "@heroui/kbd": ["@heroui/kbd@2.2.26", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/system-rsc": "2.3.24" }, "peerDependencies": { "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-Z8XpQwMmNpLGlQlGD7UWRWG2S8veNb9vezfWgEKmtnnzdVM/CKSYTWctkmiruJ7tPn3XPsGTEt3QU8WPVAnpqQ=="],
+
+    "@heroui/link": ["@heroui/link@2.2.26", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-link": "2.2.23", "@react-aria/focus": "3.21.5", "@react-types/link": "3.6.7" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-TPxd87ZP8mB8HG0GVIDTuoDxL2mcpCVUY9sjrxujAtin3781znM6jFO+O/tv0huW90+jxBHiFU1KpeZWwtl6qg=="],
+
+    "@heroui/listbox": ["@heroui/listbox@2.3.31", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/divider": "2.2.24", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-is-mobile": "2.2.12", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/listbox": "3.15.3", "@react-stately/list": "3.13.4", "@react-types/shared": "3.33.1", "@tanstack/react-virtual": "3.11.3" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-EvYxlama0kDCtgyNfCtz/X7ftYSE0OlPGKrZrv0st0oz790x3E1EQyCEYOaDbHAnGPxJy8pRC88CbzyPWEHeXQ=="],
+
+    "@heroui/menu": ["@heroui/menu@2.2.31", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/divider": "2.2.24", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-is-mobile": "2.2.12", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/menu": "3.21.0", "@react-stately/tree": "3.9.6", "@react-types/menu": "3.10.7", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-e5VqpMapolo51kJdHdz+tm3a++dGnvPTQtma8bFPfguVzoyzbq4eicFUR9fvbvYjP2jNewwsyaoTqBvxqbueiQ=="],
+
+    "@heroui/modal": ["@heroui/modal@2.2.29", "", { "dependencies": { "@heroui/dom-animation": "2.1.10", "@heroui/framer-utils": "2.1.28", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-button": "2.2.22", "@heroui/use-aria-modal-overlay": "2.2.21", "@heroui/use-disclosure": "2.2.19", "@heroui/use-draggable": "2.1.20", "@heroui/use-viewport-size": "2.0.1", "@react-aria/dialog": "3.5.34", "@react-aria/focus": "3.21.5", "@react-aria/overlays": "3.31.2", "@react-stately/overlays": "3.6.23" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-ke6i2ByLuTE/4OZRZvgKv6A2Vf1GkitL/Lq+Bojq8ovIquphmH7AXrXkWEQ6yq1YdqYRDFcVOX/4p11Qjv4rkg=="],
+
+    "@heroui/navbar": ["@heroui/navbar@2.2.30", "", { "dependencies": { "@heroui/dom-animation": "2.1.10", "@heroui/framer-utils": "2.1.28", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-resize": "2.1.8", "@heroui/use-scroll-position": "2.1.8", "@react-aria/button": "3.14.5", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/overlays": "3.31.2", "@react-stately/toggle": "3.9.5", "@react-stately/utils": "3.11.0" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-zGMRuewcjUFZhj3hIyIWOq+iRt0Mcc8FHBDPHAcYtYe0PrfYF2Ti0WLoH5Bbf5kR3S5hYfwabyT7jtf173S7iQ=="],
+
+    "@heroui/number-input": ["@heroui/number-input@2.0.23", "", { "dependencies": { "@heroui/button": "2.2.32", "@heroui/form": "2.1.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/focus": "3.21.5", "@react-aria/i18n": "3.12.16", "@react-aria/interactions": "3.27.1", "@react-aria/numberfield": "3.12.5", "@react-stately/numberfield": "3.11.0", "@react-types/button": "3.15.1", "@react-types/numberfield": "3.8.18", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-06Glv+X+tqSLt7i7MUJJz2Zf65+kkBaL/Cgx0Sw7iA418WejPDF3KIRee48RdfI+AOHYPAH4AD9PnGAaOJvapQ=="],
+
+    "@heroui/pagination": ["@heroui/pagination@2.2.27", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/use-intersection-observer": "2.2.14", "@heroui/use-pagination": "2.2.20", "@react-aria/focus": "3.21.5", "@react-aria/i18n": "3.12.16", "@react-aria/interactions": "3.27.1", "@react-aria/utils": "3.33.1", "scroll-into-view-if-needed": "3.0.10" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-omTpyJwGzw2fmSdfCfJuIgVmTqDaMzs4RmDtjgqEZxZCAldFlVuTWmsR1peOwzZKsrhzbp3eH/E9F6ipwF6Yug=="],
+
+    "@heroui/popover": ["@heroui/popover@2.3.32", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/button": "2.2.32", "@heroui/dom-animation": "2.1.10", "@heroui/framer-utils": "2.1.28", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-button": "2.2.22", "@heroui/use-aria-overlay": "2.0.6", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/dialog": "3.5.34", "@react-aria/focus": "3.21.5", "@react-aria/overlays": "3.31.2", "@react-stately/overlays": "3.6.23", "@react-types/overlays": "3.9.4" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-aVkDt9aITI66x7nS0k2BJ7szQtNm5YV+Q31X9aWrXFkRdJ+zl0sMbo1UpVQdGSif0yH6NvsFTThmCWDQZkX6fg=="],
+
+    "@heroui/progress": ["@heroui/progress@2.2.25", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-is-mounted": "2.1.8", "@react-aria/progress": "3.4.30", "@react-types/progress": "3.5.18" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-0aMuB3RaEheJPiQPUPRvwC1CkBG9qDRzRyUu6GT5QJfkFVmeB09NwQB4wec74qa1Ke+Yhj2KHfCVyBzYNqAifw=="],
+
+    "@heroui/radio": ["@heroui/radio@2.3.32", "", { "dependencies": { "@heroui/form": "2.1.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/radio": "3.12.5", "@react-aria/visually-hidden": "3.8.31", "@react-stately/radio": "3.11.5", "@react-types/radio": "3.9.4", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-R0Oj8sQ5NA5LqPkouGEHPetgZxa1p7XNf5teVv0nL+8A9tg4R8VDLvL50ezc0yXp18PmfHa61AoK5DSCnyesNw=="],
+
+    "@heroui/react": ["@heroui/react@2.8.10", "", { "dependencies": { "@heroui/accordion": "2.2.29", "@heroui/alert": "2.2.32", "@heroui/autocomplete": "2.3.34", "@heroui/avatar": "2.2.26", "@heroui/badge": "2.2.18", "@heroui/breadcrumbs": "2.2.25", "@heroui/button": "2.2.32", "@heroui/calendar": "2.2.32", "@heroui/card": "2.2.28", "@heroui/checkbox": "2.3.32", "@heroui/chip": "2.2.25", "@heroui/code": "2.2.25", "@heroui/date-input": "2.3.32", "@heroui/date-picker": "2.3.33", "@heroui/divider": "2.2.24", "@heroui/drawer": "2.2.29", "@heroui/dropdown": "2.3.32", "@heroui/form": "2.1.32", "@heroui/framer-utils": "2.1.28", "@heroui/image": "2.2.19", "@heroui/input": "2.4.33", "@heroui/input-otp": "2.1.32", "@heroui/kbd": "2.2.26", "@heroui/link": "2.2.26", "@heroui/listbox": "2.3.31", "@heroui/menu": "2.2.31", "@heroui/modal": "2.2.29", "@heroui/navbar": "2.2.30", "@heroui/number-input": "2.0.23", "@heroui/pagination": "2.2.27", "@heroui/popover": "2.3.32", "@heroui/progress": "2.2.25", "@heroui/radio": "2.3.32", "@heroui/ripple": "2.2.21", "@heroui/scroll-shadow": "2.3.19", "@heroui/select": "2.4.33", "@heroui/skeleton": "2.2.18", "@heroui/slider": "2.4.29", "@heroui/snippet": "2.2.33", "@heroui/spacer": "2.2.25", "@heroui/spinner": "2.2.29", "@heroui/switch": "2.2.27", "@heroui/system": "2.4.28", "@heroui/table": "2.2.32", "@heroui/tabs": "2.2.29", "@heroui/theme": "2.4.26", "@heroui/toast": "2.0.22", "@heroui/tooltip": "2.2.29", "@heroui/user": "2.2.26", "@react-aria/visually-hidden": "3.8.31" }, "peerDependencies": { "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-rW5wFxLX3SNusf8Uhq10M5btRplKunU8glU1Gd4gD9AMIV/e7D+DGy/g2ildz2gEcMPny4C5kLcYlwRDea5oNw=="],
+
+    "@heroui/react-rsc-utils": ["@heroui/react-rsc-utils@2.1.9", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-e77OEjNCmQxE9/pnLDDb93qWkX58/CcgIqdNAczT/zUP+a48NxGq2A2WRimvc1uviwaNL2StriE2DmyZPyYW7Q=="],
+
+    "@heroui/react-utils": ["@heroui/react-utils@2.1.14", "", { "dependencies": { "@heroui/react-rsc-utils": "2.1.9", "@heroui/shared-utils": "2.1.12" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-hhKklYKy9sRH52C9A8P0jWQ79W4MkIvOnKBIuxEMHhigjfracy0o0lMnAUdEsJni4oZKVJYqNGdQl+UVgcmeDA=="],
+
+    "@heroui/ripple": ["@heroui/ripple@2.2.21", "", { "dependencies": { "@heroui/dom-animation": "2.1.10", "@heroui/shared-utils": "2.1.12" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.23", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-wairSq9LnhbIqTCJmUlJAQURQ1wcRK/L8pjg2s3R/XnvZlPXHy4ZzfphiwIlTI21z/f6tH3arxv/g1uXd1RY0g=="],
+
+    "@heroui/scroll-shadow": ["@heroui/scroll-shadow@2.3.19", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-data-scroll-overflow": "2.2.13" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.23", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-y5mdBlhiITVrFnQTDqEphYj7p5pHqoFSFtVuRRvl9wUec2lMxEpD85uMGsfL8OgQTKIAqGh2s6M360+VJm7ajQ=="],
+
+    "@heroui/select": ["@heroui/select@2.4.33", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/form": "2.1.32", "@heroui/listbox": "2.3.31", "@heroui/popover": "2.3.32", "@heroui/react-utils": "2.1.14", "@heroui/scroll-shadow": "2.3.19", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/spinner": "2.2.29", "@heroui/use-aria-button": "2.2.22", "@heroui/use-aria-multiselect": "2.4.21", "@heroui/use-form-reset": "2.0.1", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/focus": "3.21.5", "@react-aria/form": "3.1.5", "@react-aria/interactions": "3.27.1", "@react-aria/overlays": "3.31.2", "@react-aria/visually-hidden": "3.8.31", "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-iWlczBmrHz2lIjyAneiiFtmgM+YWKLNIHL9dQnMghSAZWT9iCES5c3RuiggqE9k7DfPjHmgvVB24qeajnnXBOQ=="],
+
+    "@heroui/shared-icons": ["@heroui/shared-icons@2.1.10", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-ePo60GjEpM0SEyZBGOeySsLueNDCqLsVL79Fq+5BphzlrBAcaKY7kUp74964ImtkXvknTxAWzuuTr3kCRqj6jg=="],
+
+    "@heroui/shared-utils": ["@heroui/shared-utils@2.1.12", "", {}, "sha512-0iCnxVAkIPtrHQo26Qa5g0UTqMTpugTbClNOrEPsrQuyRAq7Syux998cPwGlneTfB5E5xcU3LiEdA9GUyeK2cQ=="],
+
+    "@heroui/skeleton": ["@heroui/skeleton@2.2.18", "", { "dependencies": { "@heroui/shared-utils": "2.1.12" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.23", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-7AjU5kjk9rqrKP9mWQiAVj0dow4/vbK5/ejh4jqdb3DZm7bM2+DGzfnQPiS0c2eWR606CgOuuoImpwDS82HJtA=="],
+
+    "@heroui/slider": ["@heroui/slider@2.4.29", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/tooltip": "2.2.29", "@react-aria/focus": "3.21.5", "@react-aria/i18n": "3.12.16", "@react-aria/interactions": "3.27.1", "@react-aria/slider": "3.8.5", "@react-aria/visually-hidden": "3.8.31", "@react-stately/slider": "3.7.5" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-JY3uPIShCFLWTbLLYQJJIT5TyLQsyqJHPcM66FprDxwLkf/Ne03jvf+SeieCKAbq/iw+GygTIfwmbSPzrp/yhA=="],
+
+    "@heroui/snippet": ["@heroui/snippet@2.2.33", "", { "dependencies": { "@heroui/button": "2.2.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/tooltip": "2.2.29", "@heroui/use-clipboard": "2.1.9", "@react-aria/focus": "3.21.5" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-BvoqKPRhdZyXvvPLxUoU0Fg5MzxMYdGWmJMS9gLT1Zv9A9ixua7kTFh9Z5NT9aNScRR9vhroaSQi1x39uCp+5g=="],
+
+    "@heroui/spacer": ["@heroui/spacer@2.2.25", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/system-rsc": "2.3.24" }, "peerDependencies": { "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-XSw54osEkNaBykZXhZcFmvwqwuSKCGPFOd2AIR+vrMqcJg0IxWjpGIsexaT3P/LV1PuoTYkTJ8G3N5Wf4pZTUw=="],
+
+    "@heroui/spinner": ["@heroui/spinner@2.2.29", "", { "dependencies": { "@heroui/shared-utils": "2.1.12", "@heroui/system": "2.4.28", "@heroui/system-rsc": "2.3.24" }, "peerDependencies": { "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-08mWpL4+pdACcyzT5MjR0nSkKoWbab0oPzY+JHxIdPSSh3S8JJ7C8dUeV3Kj/15NRzzZlcTM3ClRCV8fdeGmuw=="],
+
+    "@heroui/switch": ["@heroui/switch@2.2.27", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/switch": "3.7.11", "@react-aria/visually-hidden": "3.8.31", "@react-stately/toggle": "3.9.5" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-z23is+gtPkX29EpixY5ZLY1+NQaP+ueshuiXzdgD9SfCQLOSDYDWuFVdR8ZgfdDPyhP8xpOnJf6l9zfgXHD8Rw=="],
+
+    "@heroui/system": ["@heroui/system@2.4.28", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/system-rsc": "2.3.24", "@react-aria/i18n": "3.12.16", "@react-aria/overlays": "3.31.2", "@react-aria/utils": "3.33.1" }, "peerDependencies": { "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-agtiiMFsCLaBrGWWrGBlFrnwi06ym4uouh61c3/m16CHuYfGm0Hx5oJ1mZVF98SJ91mDyU3e6Rv+8mqV9XVgoQ=="],
+
+    "@heroui/system-rsc": ["@heroui/system-rsc@2.3.24", "", { "dependencies": { "@react-types/shared": "3.33.1" }, "peerDependencies": { "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-GEP3hh7j8wE56WdSAIdCcPQOMDdAYk9bSuQpGzXnkYSiSCJKroOyXbRmp9KF2VgpiMXGI0OlO51aj9JWoa+5Tg=="],
+
+    "@heroui/table": ["@heroui/table@2.2.32", "", { "dependencies": { "@heroui/checkbox": "2.3.32", "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/table": "3.17.11", "@react-aria/visually-hidden": "3.8.31", "@react-stately/table": "3.15.4", "@react-stately/virtualizer": "4.4.6", "@react-types/grid": "3.3.8", "@react-types/table": "3.13.6", "@tanstack/react-virtual": "3.11.3" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-cJ+XtBZOonSmkw7jrj0d9c8aIMdSGSZrBKS/1KZ7J9BTFPDW+ZoWwomgJHgZ31FQlr7dkYa7mZ2rf8LoGoOxRA=="],
+
+    "@heroui/tabs": ["@heroui/tabs@2.2.29", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-is-mounted": "2.1.8", "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/tabs": "3.11.1", "@react-stately/tabs": "3.8.9", "@react-types/shared": "3.33.1", "scroll-into-view-if-needed": "3.0.10" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-TzCRXDqhdNsUxhO6sPdsbEt8m7KlkGwvJGvs4S/kHvJh1sKCItnnT0Z2FpZr6pLAqmHA6LO6Ow1phR5ACfNmug=="],
+
+    "@heroui/theme": ["@heroui/theme@2.4.26", "", { "dependencies": { "@heroui/shared-utils": "2.1.12", "color": "^4.2.3", "color2k": "^2.0.3", "deepmerge": "4.3.1", "tailwind-merge": "3.4.0", "tailwind-variants": "3.2.2" }, "peerDependencies": { "tailwindcss": ">=4.0.0" } }, "sha512-TYatChq7YyGDcPJytgOMqQwK72qWYb+vIa7mLmX3Cu9+JzFs2VSHu2QqzdhnOHoK0uJr8giDMy0gvJEDuu31vw=="],
+
+    "@heroui/toast": ["@heroui/toast@2.0.22", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/shared-icons": "2.1.10", "@heroui/shared-utils": "2.1.12", "@heroui/spinner": "2.2.29", "@heroui/use-is-mobile": "2.2.12", "@react-aria/interactions": "3.27.1", "@react-aria/toast": "3.0.11", "@react-stately/toast": "3.1.3" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-eaayx0oJW0/imLyOhfjOdMx8FEKbWa8aKVvPNvXr3mXQbgzBEa+e147Xbh2CneG66we9C24JETE7QMLJ00popw=="],
+
+    "@heroui/tooltip": ["@heroui/tooltip@2.2.29", "", { "dependencies": { "@heroui/aria-utils": "2.2.29", "@heroui/dom-animation": "2.1.10", "@heroui/framer-utils": "2.1.28", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@heroui/use-aria-overlay": "2.0.6", "@heroui/use-safe-layout-effect": "2.1.8", "@react-aria/overlays": "3.31.2", "@react-aria/tooltip": "3.9.2", "@react-stately/tooltip": "3.5.11", "@react-types/overlays": "3.9.4", "@react-types/tooltip": "3.5.2" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "framer-motion": ">=11.5.6 || >=12.0.0-alpha.1", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-PsHVC9XwjmbZpdu7o8TWSHENiCHCsoQpzpFJ3GYgnUULIhH5k69L/+5jiON9qG6k7+tL4RZS6pQPSbxDCf1acQ=="],
+
+    "@heroui/use-aria-accordion": ["@heroui/use-aria-accordion@2.2.20", "", { "dependencies": { "@react-aria/button": "3.14.5", "@react-aria/focus": "3.21.5", "@react-aria/selection": "3.27.2", "@react-stately/tree": "3.9.6", "@react-types/accordion": "3.0.0-alpha.26", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-HvZhfrsxpCab+m4TrbHWsnA8iLaYdq1G1pjFCswftDRzfioJLmkJ0FMtYDPi792akJO+TWEvPhJibcwVD0bbfg=="],
+
+    "@heroui/use-aria-button": ["@heroui/use-aria-button@2.2.22", "", { "dependencies": { "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/utils": "3.33.1", "@react-types/button": "3.15.1", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-6Y+fWkf/LKKxw3cd9QCSdLVMrMgKv+0AGCzNCfDiZ5kzQGCX4JQD9eK/495opAHV90yhIWzolwdNwtsyhDploA=="],
+
+    "@heroui/use-aria-link": ["@heroui/use-aria-link@2.2.23", "", { "dependencies": { "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/utils": "3.33.1", "@react-types/link": "3.6.7", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-jpFj9HNCdt+DENPJyrfoN+AzuaMze9xqo5Y1P3KGoT/2pFDmelFgbXAOC5CHpatYFIn3YEELBGlj84zNXq2gjQ=="],
+
+    "@heroui/use-aria-modal-overlay": ["@heroui/use-aria-modal-overlay@2.2.21", "", { "dependencies": { "@heroui/use-aria-overlay": "2.0.6", "@react-aria/overlays": "3.31.2", "@react-aria/utils": "3.33.1", "@react-stately/overlays": "3.6.23" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-Qwj5ldLFpfinfGpYUQu92TCpGKzd9Uamhd31ayRvYl6+LwOX124N9ObRYBTXyEiNJ7XFYer3vXQVeaR84xM1Gg=="],
+
+    "@heroui/use-aria-multiselect": ["@heroui/use-aria-multiselect@2.4.21", "", { "dependencies": { "@react-aria/i18n": "3.12.16", "@react-aria/interactions": "3.27.1", "@react-aria/label": "3.7.25", "@react-aria/listbox": "3.15.3", "@react-aria/menu": "3.21.0", "@react-aria/selection": "3.27.2", "@react-aria/utils": "3.33.1", "@react-stately/form": "3.2.4", "@react-stately/list": "3.13.4", "@react-stately/menu": "3.9.11", "@react-types/button": "3.15.1", "@react-types/overlays": "3.9.4", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-f/7YkTfS67OMXXYCO9WTI0Fj9YGPOgdwMIqhaSnFdA2UywA3W71PPeEqpKeuvO6isBW53YOynAPMZXF1NcsuHw=="],
+
+    "@heroui/use-aria-overlay": ["@heroui/use-aria-overlay@2.0.6", "", { "dependencies": { "@react-aria/focus": "3.21.5", "@react-aria/interactions": "3.27.1", "@react-aria/overlays": "3.31.2", "@react-types/shared": "3.33.1" }, "peerDependencies": { "react": ">=18", "react-dom": ">=18" } }, "sha512-7q8oj5DZjr9oGYUB1UTOBnnuAapkBmfATCsdUeNOxQdYb2glJp52sTUslO+ykI9xVOAJSGYAmGuWgY5d+8mD6Q=="],
+
+    "@heroui/use-callback-ref": ["@heroui/use-callback-ref@2.1.8", "", { "dependencies": { "@heroui/use-safe-layout-effect": "2.1.8" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-D1JDo9YyFAprYpLID97xxQvf86NvyWLay30BeVVZT9kWmar6O9MbCRc7ACi7Ngko60beonj6+amTWkTm7QuY/Q=="],
+
+    "@heroui/use-clipboard": ["@heroui/use-clipboard@2.1.9", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-lkBq5RpXHiPvk1BXKJG8gMM0f7jRMIGnxAXDjAUzZyXKBuWLoM+XlaUWmZHtmkkjVFMX1L4vzA+vxi9rZbenEQ=="],
+
+    "@heroui/use-data-scroll-overflow": ["@heroui/use-data-scroll-overflow@2.2.13", "", { "dependencies": { "@heroui/shared-utils": "2.1.12" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-zboLXO1pgYdzMUahDcVt5jf+l1jAQ/D9dFqr7AxWLfn6tn7/EgY0f6xIrgWDgJnM0U3hKxVeY13pAeB4AFTqTw=="],
+
+    "@heroui/use-disclosure": ["@heroui/use-disclosure@2.2.19", "", { "dependencies": { "@heroui/use-callback-ref": "2.1.8", "@react-aria/utils": "3.33.1", "@react-stately/utils": "3.11.0" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-N3CBikg1cxik2xp1UQkPUBbKPGrvtdsRyAlOnGygliyr5wKpZHLZi0R/g8OxTZVk3zUSCl7HZJT13ddM5TqEvA=="],
+
+    "@heroui/use-draggable": ["@heroui/use-draggable@2.1.20", "", { "dependencies": { "@react-aria/interactions": "3.27.1" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-yXn3jU3qiUx6aUd2osbDfddpnUTTh2wAVzpNyI+BXl2Z3rkVU9jqiJxZa+BXfsqFX17KrlrxwPPBmLNhSdBKHg=="],
+
+    "@heroui/use-form-reset": ["@heroui/use-form-reset@2.0.1", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-6slKWiLtVfgZnVeHVkM9eXgjwI07u0CUaLt2kQpfKPqTSTGfbHgCYJFduijtThhTdKBhdH6HCmzTcnbVlAxBXw=="],
+
+    "@heroui/use-image": ["@heroui/use-image@2.1.14", "", { "dependencies": { "@heroui/react-utils": "2.1.14", "@heroui/use-safe-layout-effect": "2.1.8" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-eCxtKOsM1tszBKYqz8qIJwGIxEAUC7ua+6L9vK8JgG6gOC0jEPFGH7keQuPVprzRtG3DmNt90icowqEjnOHdFQ=="],
+
+    "@heroui/use-intersection-observer": ["@heroui/use-intersection-observer@2.2.14", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-qYJeMk4cTsF+xIckRctazCgWQ4BVOpJu+bhhkB1NrN+MItx19Lcb7ksOqMdN5AiSf85HzDcAEPIQ9w9RBlt5sg=="],
+
+    "@heroui/use-is-mobile": ["@heroui/use-is-mobile@2.2.12", "", { "dependencies": { "@react-aria/ssr": "3.9.10" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-2UKa4v1xbvFwerWKoMTrg4q9ZfP9MVIVfCl1a7JuKQlXq3jcyV6z1as5bZ41pCsTOT+wUVOFnlr6rzzQwT9ZOA=="],
+
+    "@heroui/use-is-mounted": ["@heroui/use-is-mounted@2.1.8", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-DO/Th1vD4Uy8KGhd17oGlNA4wtdg91dzga+VMpmt94gSZe1WjsangFwoUBxF2uhlzwensCX9voye3kerP/lskg=="],
+
+    "@heroui/use-measure": ["@heroui/use-measure@2.1.8", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-GjT9tIgluqYMZWfAX6+FFdRQBqyHeuqUMGzAXMTH9kBXHU0U5C5XU2c8WFORkNDoZIg1h13h1QdV+Vy4LE1dEA=="],
+
+    "@heroui/use-pagination": ["@heroui/use-pagination@2.2.20", "", { "dependencies": { "@heroui/shared-utils": "2.1.12", "@react-aria/i18n": "3.12.16" }, "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-+ZK+vJgLq7JKLJAnIwfbxe/oF1hANtIiCR6H++q7fOw9pxZZQsntmLEu4kvRhpGZRp5C5T10A1GKIK7/xz1ZdA=="],
+
+    "@heroui/use-resize": ["@heroui/use-resize@2.1.8", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-htF3DND5GmrSiMGnzRbISeKcH+BqhQ/NcsP9sBTIl7ewvFaWiDhEDiUHdJxflmJGd/c5qZq2nYQM/uluaqIkKA=="],
+
+    "@heroui/use-safe-layout-effect": ["@heroui/use-safe-layout-effect@2.1.8", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-wbnZxVWCYqk10XRMu0veSOiVsEnLcmGUmJiapqgaz0fF8XcpSScmqjTSoWjHIEWaHjQZ6xr+oscD761D6QJN+Q=="],
+
+    "@heroui/use-scroll-position": ["@heroui/use-scroll-position@2.1.8", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-NxanHKObxVfWaPpNRyBR8v7RfokxrzcHyTyQfbgQgAGYGHTMaOGkJGqF8kBzInc3zJi+F0zbX7Nb0QjUgsLNUQ=="],
+
+    "@heroui/use-viewport-size": ["@heroui/use-viewport-size@2.0.1", "", { "peerDependencies": { "react": ">=18 || >=19.0.0-rc.0" } }, "sha512-blv8BEB/QdLePLWODPRzRS2eELJ2eyHbdOIADbL0KcfLzOUEg9EiuVk90hcSUDAFqYiJ3YZ5Z0up8sdPcR8Y7g=="],
+
+    "@heroui/user": ["@heroui/user@2.2.26", "", { "dependencies": { "@heroui/avatar": "2.2.26", "@heroui/react-utils": "2.1.14", "@heroui/shared-utils": "2.1.12", "@react-aria/focus": "3.21.5" }, "peerDependencies": { "@heroui/system": ">=2.4.18", "@heroui/theme": ">=2.4.24", "react": ">=18 || >=19.0.0-rc.0", "react-dom": ">=18 || >=19.0.0-rc.0" } }, "sha512-3SESvOSYSVysSSwV1SR2QD8cOx6Fv/vVAXry/GmjLl9CSsA6HTlWoLy7TRtteGFqm3XRWVqjzCrcNGlvSmtdnQ=="],
+
+    "@hono/node-server": ["@hono/node-server@1.19.14", "", { "peerDependencies": { "hono": "^4" } }, "sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw=="],
+
+    "@hookform/resolvers": ["@hookform/resolvers@3.10.0", "", { "peerDependencies": { "react-hook-form": "^7.0.0" } }, "sha512-79Dv+3mDF7i+2ajj7SkypSKHhl1cbln1OGavqrsF7p6mbUv11xpqpacPsGDCTRvCSjEEIez2ef1NveSVL3b0Ag=="],
+
+    "@humanfs/core": ["@humanfs/core@0.19.2", "", { "dependencies": { "@humanfs/types": "^0.15.0" } }, "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA=="],
+
+    "@humanfs/node": ["@humanfs/node@0.16.8", "", { "dependencies": { "@humanfs/core": "^0.19.2", "@humanfs/types": "^0.15.0", "@humanwhocodes/retry": "^0.4.0" } }, "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ=="],
+
+    "@humanfs/types": ["@humanfs/types@0.15.0", "", {}, "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q=="],
+
+    "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="],
+
+    "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="],
+
+    "@iconify/types": ["@iconify/types@2.0.0", "", {}, "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="],
+
+    "@iconify/utils": ["@iconify/utils@3.1.3", "", { "dependencies": { "@antfu/install-pkg": "^1.1.0", "@iconify/types": "^2.0.0", "import-meta-resolve": "^4.2.0" } }, "sha512-LPKOXPn/zV+zis1oOfGWogaXVpqUybF3ZS6SCZIsz8vg0ivVp9+fVqyYB7xq0aiST/VhUQYGO1qo6uoYSiEJqw=="],
+
+    "@img/colour": ["@img/colour@1.1.0", "", {}, "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ=="],
+
+    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w=="],
+
+    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.4" }, "os": "darwin", "cpu": "x64" }, "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw=="],
+
+    "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.2.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g=="],
+
+    "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.2.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg=="],
+
+    "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.2.4", "", { "os": "linux", "cpu": "arm" }, "sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A=="],
+
+    "@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.2.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw=="],
+
+    "@img/sharp-libvips-linux-ppc64": ["@img/sharp-libvips-linux-ppc64@1.2.4", "", { "os": "linux", "cpu": "ppc64" }, "sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA=="],
+
+    "@img/sharp-libvips-linux-riscv64": ["@img/sharp-libvips-linux-riscv64@1.2.4", "", { "os": "linux", "cpu": "none" }, "sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA=="],
+
+    "@img/sharp-libvips-linux-s390x": ["@img/sharp-libvips-linux-s390x@1.2.4", "", { "os": "linux", "cpu": "s390x" }, "sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ=="],
+
+    "@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.2.4", "", { "os": "linux", "cpu": "x64" }, "sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw=="],
+
+    "@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.2.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw=="],
+
+    "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.2.4", "", { "os": "linux", "cpu": "x64" }, "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg=="],
+
+    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.2.4" }, "os": "linux", "cpu": "arm" }, "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw=="],
+
+    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg=="],
+
+    "@img/sharp-linux-ppc64": ["@img/sharp-linux-ppc64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-ppc64": "1.2.4" }, "os": "linux", "cpu": "ppc64" }, "sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA=="],
+
+    "@img/sharp-linux-riscv64": ["@img/sharp-linux-riscv64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-riscv64": "1.2.4" }, "os": "linux", "cpu": "none" }, "sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw=="],
+
+    "@img/sharp-linux-s390x": ["@img/sharp-linux-s390x@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-s390x": "1.2.4" }, "os": "linux", "cpu": "s390x" }, "sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg=="],
+
+    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ=="],
+
+    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg=="],
+
+    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q=="],
+
+    "@img/sharp-wasm32": ["@img/sharp-wasm32@0.34.5", "", { "dependencies": { "@emnapi/runtime": "^1.7.0" }, "cpu": "none" }, "sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw=="],
+
+    "@img/sharp-win32-arm64": ["@img/sharp-win32-arm64@0.34.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g=="],
+
+    "@img/sharp-win32-ia32": ["@img/sharp-win32-ia32@0.34.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg=="],
+
+    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.34.5", "", { "os": "win32", "cpu": "x64" }, "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw=="],
+
+    "@internationalized/date": ["@internationalized/date@3.12.0", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-/PyIMzK29jtXaGU23qTvNZxvBXRtKbNnGDFD+PY6CZw/Y8Ex8pFUzkuCJCG9aOqmShjqhS9mPqP6Dk5onQY8rQ=="],
+
+    "@internationalized/message": ["@internationalized/message@3.1.10", "", { "dependencies": { "@swc/helpers": "^0.5.0", "intl-messageformat": "^10.1.0" } }, "sha512-nc0Or6EdWHqZRcsXb6P9hBIpLsfSl/ILh0rk5h/OVBpzmhdExXtPy2cQtWsq8XKRBpRHwDNnAHt4OpolcB7dog=="],
+
+    "@internationalized/number": ["@internationalized/number@3.6.7", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-3ji1fcrT+FPAK86UqEhB/psHixYo6niWPJtt7+qRaYFynt/BaJG8GhAPimtWUpEiVSTq8ZM8L5psMxGquiB/Vg=="],
+
+    "@internationalized/string": ["@internationalized/string@3.2.9", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-kzP/M/mbQxODlmOt4bIQZ2SBVUWUSqMLXooXixnX7noche8WHaQcA+nwFN1K2KCF/cp+LDUhcJsCicwkvhD1pg=="],
+
+    "@isaacs/cliui": ["@isaacs/cliui@9.0.0", "", {}, "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg=="],
+
+    "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="],
+
+    "@istanbuljs/schema": ["@istanbuljs/schema@0.1.6", "", {}, "sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw=="],
+
+    "@jerome-benoit/sap-ai-provider": ["@jerome-benoit/sap-ai-provider@4.6.9", "", { "dependencies": { "@ai-sdk/provider": "^3.0.10", "@ai-sdk/provider-utils": "^4.0.26", "@sap-ai-sdk/foundation-models": "^2.10.0", "@sap-ai-sdk/orchestration": "^2.10.0", "zod": "^4.4.2" }, "peerDependencies": { "ai": "^5.0.0 || ^6.0.0" } }, "sha512-z+ayDBasD2/PB4iAO6Lp6myQ96KZYjN/gBX3WAisaFKcCeRIsJyzHcBQh26lDu0cpzAybRmI5XUrWzn3nRaqgA=="],
+
+    "@jest/diff-sequences": ["@jest/diff-sequences@30.4.0", "", {}, "sha512-zOpzlfUs45l6u7jm39qr87JCHUDsaeCtvL+kQe/Vn9jSnRB4/5IPXISm0h9I1vZW/o00Kn4UTJ2MOlhnUGwv3g=="],
+
+    "@jest/expect-utils": ["@jest/expect-utils@29.7.0", "", { "dependencies": { "jest-get-type": "^29.6.3" } }, "sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA=="],
+
+    "@jest/get-type": ["@jest/get-type@30.1.0", "", {}, "sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA=="],
+
+    "@jest/schemas": ["@jest/schemas@30.4.1", "", { "dependencies": { "@sinclair/typebox": "^0.34.0" } }, "sha512-i6b4qw5qnP8c5FEeBJg/uZQ4ddrkN6Ca8qISJh0pr7a5hfn3h3v5x60BEbOC7OYAGZNMs1LfFLwnW2CuK8F57Q=="],
+
+    "@jest/types": ["@jest/types@29.6.3", "", { "dependencies": { "@jest/schemas": "^29.6.3", "@types/istanbul-lib-coverage": "^2.0.0", "@types/istanbul-reports": "^3.0.0", "@types/node": "*", "@types/yargs": "^17.0.8", "chalk": "^4.0.0" } }, "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw=="],
+
+    "@jimp/core": ["@jimp/core@1.6.0", "", { "dependencies": { "@jimp/file-ops": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "await-to-js": "^3.0.0", "exif-parser": "^0.1.12", "file-type": "^16.0.0", "mime": "3" } }, "sha512-EQQlKU3s9QfdJqiSrZWNTxBs3rKXgO2W+GxNXDtwchF3a4IqxDheFX1ti+Env9hdJXDiYLp2jTRjlxhPthsk8w=="],
+
+    "@jimp/diff": ["@jimp/diff@1.6.0", "", { "dependencies": { "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "pixelmatch": "^5.3.0" } }, "sha512-+yUAQ5gvRC5D1WHYxjBHZI7JBRusGGSLf8AmPRPCenTzh4PA+wZ1xv2+cYqQwTfQHU5tXYOhA0xDytfHUf1Zyw=="],
+
+    "@jimp/file-ops": ["@jimp/file-ops@1.6.0", "", {}, "sha512-Dx/bVDmgnRe1AlniRpCKrGRm5YvGmUwbDzt+MAkgmLGf+jvBT75hmMEZ003n9HQI/aPnm/YKnXjg/hOpzNCpHQ=="],
+
+    "@jimp/js-bmp": ["@jimp/js-bmp@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "bmp-ts": "^1.0.9" } }, "sha512-FU6Q5PC/e3yzLyBDXupR3SnL3htU7S3KEs4e6rjDP6gNEOXRFsWs6YD3hXuXd50jd8ummy+q2WSwuGkr8wi+Gw=="],
+
+    "@jimp/js-gif": ["@jimp/js-gif@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "gifwrap": "^0.10.1", "omggif": "^1.0.10" } }, "sha512-N9CZPHOrJTsAUoWkWZstLPpwT5AwJ0wge+47+ix3++SdSL/H2QzyMqxbcDYNFe4MoI5MIhATfb0/dl/wmX221g=="],
+
+    "@jimp/js-jpeg": ["@jimp/js-jpeg@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "jpeg-js": "^0.4.4" } }, "sha512-6vgFDqeusblf5Pok6B2DUiMXplH8RhIKAryj1yn+007SIAQ0khM1Uptxmpku/0MfbClx2r7pnJv9gWpAEJdMVA=="],
+
+    "@jimp/js-png": ["@jimp/js-png@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "pngjs": "^7.0.0" } }, "sha512-AbQHScy3hDDgMRNfG0tPjL88AV6qKAILGReIa3ATpW5QFjBKpisvUaOqhzJ7Reic1oawx3Riyv152gaPfqsBVg=="],
+
+    "@jimp/js-tiff": ["@jimp/js-tiff@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "utif2": "^4.1.0" } }, "sha512-zhReR8/7KO+adijj3h0ZQUOiun3mXUv79zYEAKvE0O+rP7EhgtKvWJOZfRzdZSNv0Pu1rKtgM72qgtwe2tFvyw=="],
+
+    "@jimp/plugin-blit": ["@jimp/plugin-blit@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-M+uRWl1csi7qilnSK8uxK4RJMSuVeBiO1AY0+7APnfUbQNZm6hCe0CCFv1Iyw1D/Dhb8ph8fQgm5mwM0eSxgVA=="],
+
+    "@jimp/plugin-blur": ["@jimp/plugin-blur@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/utils": "1.6.0" } }, "sha512-zrM7iic1OTwUCb0g/rN5y+UnmdEsT3IfuCXCJJNs8SZzP0MkZ1eTvuwK9ZidCuMo4+J3xkzCidRwYXB5CyGZTw=="],
+
+    "@jimp/plugin-circle": ["@jimp/plugin-circle@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-xt1Gp+LtdMKAXfDp3HNaG30SPZW6AQ7dtAtTnoRKorRi+5yCJjKqXRgkewS5bvj8DEh87Ko1ydJfzqS3P2tdWw=="],
+
+    "@jimp/plugin-color": ["@jimp/plugin-color@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "tinycolor2": "^1.6.0", "zod": "^3.23.8" } }, "sha512-J5q8IVCpkBsxIXM+45XOXTrsyfblyMZg3a9eAo0P7VPH4+CrvyNQwaYatbAIamSIN1YzxmO3DkIZXzRjFSz1SA=="],
+
+    "@jimp/plugin-contain": ["@jimp/plugin-contain@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-blit": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-oN/n+Vdq/Qg9bB4yOBOxtY9IPAtEfES8J1n9Ddx+XhGBYT1/QTU/JYkGaAkIGoPnyYvmLEDqMz2SGihqlpqfzQ=="],
+
+    "@jimp/plugin-cover": ["@jimp/plugin-cover@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-crop": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-Iow0h6yqSC269YUJ8HC3Q/MpCi2V55sMlbkkTTx4zPvd8mWZlC0ykrNDeAy9IJegrQ7v5E99rJwmQu25lygKLA=="],
+
+    "@jimp/plugin-crop": ["@jimp/plugin-crop@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-KqZkEhvs+21USdySCUDI+GFa393eDIzbi1smBqkUPTE+pRwSWMAf01D5OC3ZWB+xZsNla93BDS9iCkLHA8wang=="],
+
+    "@jimp/plugin-displace": ["@jimp/plugin-displace@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-4Y10X9qwr5F+Bo5ME356XSACEF55485j5nGdiyJ9hYzjQP9nGgxNJaZ4SAOqpd+k5sFaIeD7SQ0Occ26uIng5Q=="],
+
+    "@jimp/plugin-dither": ["@jimp/plugin-dither@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0" } }, "sha512-600d1RxY0pKwgyU0tgMahLNKsqEcxGdbgXadCiVCoGd6V6glyCvkNrnnwC0n5aJ56Htkj88PToSdF88tNVZEEQ=="],
+
+    "@jimp/plugin-fisheye": ["@jimp/plugin-fisheye@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-E5QHKWSCBFtpgZarlmN3Q6+rTQxjirFqo44ohoTjzYVrDI6B6beXNnPIThJgPr0Y9GwfzgyarKvQuQuqCnnfbA=="],
+
+    "@jimp/plugin-flip": ["@jimp/plugin-flip@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-/+rJVDuBIVOgwoyVkBjUFHtP+wmW0r+r5OQ2GpatQofToPVbJw1DdYWXlwviSx7hvixTWLKVgRWQ5Dw862emDg=="],
+
+    "@jimp/plugin-hash": ["@jimp/plugin-hash@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/js-bmp": "1.6.0", "@jimp/js-jpeg": "1.6.0", "@jimp/js-png": "1.6.0", "@jimp/js-tiff": "1.6.0", "@jimp/plugin-color": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "any-base": "^1.1.0" } }, "sha512-wWzl0kTpDJgYVbZdajTf+4NBSKvmI3bRI8q6EH9CVeIHps9VWVsUvEyb7rpbcwVLWYuzDtP2R0lTT6WeBNQH9Q=="],
+
+    "@jimp/plugin-mask": ["@jimp/plugin-mask@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-Cwy7ExSJMZszvkad8NV8o/Z92X2kFUFM8mcDAhNVxU0Q6tA0op2UKRJY51eoK8r6eds/qak3FQkXakvNabdLnA=="],
+
+    "@jimp/plugin-print": ["@jimp/plugin-print@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/js-jpeg": "1.6.0", "@jimp/js-png": "1.6.0", "@jimp/plugin-blit": "1.6.0", "@jimp/types": "1.6.0", "parse-bmfont-ascii": "^1.0.6", "parse-bmfont-binary": "^1.0.6", "parse-bmfont-xml": "^1.1.6", "simple-xml-to-json": "^1.2.2", "zod": "^3.23.8" } }, "sha512-zarTIJi8fjoGMSI/M3Xh5yY9T65p03XJmPsuNet19K/Q7mwRU6EV2pfj+28++2PV2NJ+htDF5uecAlnGyxFN2A=="],
+
+    "@jimp/plugin-quantize": ["@jimp/plugin-quantize@1.6.0", "", { "dependencies": { "image-q": "^4.0.0", "zod": "^3.23.8" } }, "sha512-EmzZ/s9StYQwbpG6rUGBCisc3f64JIhSH+ncTJd+iFGtGo0YvSeMdAd+zqgiHpfZoOL54dNavZNjF4otK+mvlg=="],
+
+    "@jimp/plugin-resize": ["@jimp/plugin-resize@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-uSUD1mqXN9i1SGSz5ov3keRZ7S9L32/mAQG08wUwZiEi5FpbV0K8A8l1zkazAIZi9IJzLlTauRNU41Mi8IF9fA=="],
+
+    "@jimp/plugin-rotate": ["@jimp/plugin-rotate@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-crop": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-JagdjBLnUZGSG4xjCLkIpQOZZ3Mjbg8aGCCi4G69qR+OjNpOeGI7N2EQlfK/WE8BEHOW5vdjSyglNqcYbQBWRw=="],
+
+    "@jimp/plugin-threshold": ["@jimp/plugin-threshold@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-color": "1.6.0", "@jimp/plugin-hash": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-M59m5dzLoHOVWdM41O8z9SyySzcDn43xHseOH0HavjsfQsT56GGCC4QzU1banJidbUrePhzoEdS42uFE8Fei8w=="],
+
+    "@jimp/types": ["@jimp/types@1.6.0", "", { "dependencies": { "zod": "^3.23.8" } }, "sha512-7UfRsiKo5GZTAATxm2qQ7jqmUXP0DxTArztllTcYdyw6Xi5oT4RaoXynVtCD4UyLK5gJgkZJcwonoijrhYFKfg=="],
+
+    "@jimp/utils": ["@jimp/utils@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "tinycolor2": "^1.6.0" } }, "sha512-gqFTGEosKbOkYF/WFj26jMHOI5OH2jeP1MmC/zbK6BF6VJBf8rIC5898dPfSzZEbSA0wbbV5slbntWVc5PKLFA=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript": ["@joshwooding/vite-plugin-react-docgen-typescript@0.6.1", "", { "dependencies": { "glob": "^10.0.0", "magic-string": "^0.30.0", "react-docgen-typescript": "^2.2.2" }, "peerDependencies": { "typescript": ">= 4.3.x", "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" }, "optionalPeers": ["typescript"] }, "sha512-J4BaTocTOYFkMHIra1JDWrMWpNmBl4EkplIwHEsV8aeUOtdWjwSnln9U7twjMFTAEB7mptNtSKyVi1Y2W9sDJw=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@js-sdsl/ordered-map": ["@js-sdsl/ordered-map@4.4.2", "", {}, "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw=="],
+
+    "@kwsites/file-exists": ["@kwsites/file-exists@1.1.1", "", { "dependencies": { "debug": "^4.1.1" } }, "sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw=="],
+
+    "@kwsites/promise-deferred": ["@kwsites/promise-deferred@1.1.1", "", {}, "sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw=="],
+
+    "@langfuse/core": ["@langfuse/core@4.6.1", "", { "peerDependencies": { "@opentelemetry/api": "^1.9.0" } }, "sha512-DtQoKWHQh0I0MsJxcKrBQVKAJ3fea6+raXlISVY3NDMFG/zSKkdkNouQvUXQtSCHBbOFupHMBw8imM30lbhq3g=="],
+
+    "@langfuse/otel": ["@langfuse/otel@4.6.1", "", { "dependencies": { "@langfuse/core": "^4.6.1" }, "peerDependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/exporter-trace-otlp-http": ">=0.202.0 <1.0.0", "@opentelemetry/sdk-trace-base": "^2.0.1" } }, "sha512-ZUa+nV5und6IYK2b5w1vXoNzU/Hfpl1MJ2uu9Woyb74ZBQi36nBwo7SeX+NLvy+n/UzKcJMetOYrA5ywlXvnuA=="],
+
+    "@linear/sdk": ["@linear/sdk@76.0.0", "", { "dependencies": { "@graphql-typed-document-node/core": "^3.2.0" } }, "sha512-Xt0x5Kl6qBoWhGFypb8ykyP+c5kT7scmRPs1uJidSPOaRgkMJ/4y41QpmZCWCBUMmZtf/O0VktgQio6rLXT94w=="],
+
+    "@mapbox/hast-util-table-cell-style": ["@mapbox/hast-util-table-cell-style@0.2.1", "", { "dependencies": { "unist-util-visit": "^1.4.1" } }, "sha512-LyQz4XJIdCdY/+temIhD/Ed0x/p4GAOUycpFSEK2Ads1CPKZy6b7V/2ROEtQiLLQ8soIs0xe/QAoR6kwpyW/yw=="],
+
+    "@mapbox/node-pre-gyp": ["@mapbox/node-pre-gyp@2.0.3", "", { "dependencies": { "consola": "^3.2.3", "detect-libc": "^2.0.0", "https-proxy-agent": "^7.0.5", "node-fetch": "^2.6.7", "nopt": "^8.0.0", "semver": "^7.5.3", "tar": "^7.4.0" }, "bin": { "node-pre-gyp": "bin/node-pre-gyp" } }, "sha512-uwPAhccfFJlsfCxMYTwOdVfOz3xqyj8xYL3zJj8f0pb30tLohnnFPhLuqp4/qoEz8sNxe4SESZedcBojRefIzg=="],
+
+    "@mermaid-js/parser": ["@mermaid-js/parser@1.2.0", "", { "dependencies": { "@chevrotain/types": "~11.1.2" } }, "sha512-oYPyv8A4As1yH5Bx+04iQEQxXuIQDe0GKCNSRgao6z8AM9jixXIfP0vsppRLvGf+nKIOb9/LdpWA4YuJiVvESA=="],
+
+    "@microsoft/fast-element": ["@microsoft/fast-element@1.14.0", "", {}, "sha512-zXvuSOzvsu8zDTy9eby8ix8VqLop2rwKRgp++ZN2kTCsoB3+QJVoaGD2T/Cyso2ViZQFXNpiNCVKfnmxBvmWkQ=="],
+
+    "@microsoft/fast-foundation": ["@microsoft/fast-foundation@2.50.0", "", { "dependencies": { "@microsoft/fast-element": "^1.14.0", "@microsoft/fast-web-utilities": "^5.4.1", "tabbable": "^5.2.0", "tslib": "^1.13.0" } }, "sha512-8mFYG88Xea1jZf2TI9Lm/jzZ6RWR8x29r24mGuLojNYqIR2Bl8+hnswoV6laApKdCbGMPKnsAL/O68Q0sRxeVg=="],
+
+    "@microsoft/fast-react-wrapper": ["@microsoft/fast-react-wrapper@0.3.25", "", { "dependencies": { "@microsoft/fast-element": "^1.14.0", "@microsoft/fast-foundation": "^2.50.0" }, "peerDependencies": { "react": ">=16.9.0" } }, "sha512-jKzmk2xJV93RL/jEFXEZgBvXlKIY4N4kXy3qrjmBfFpqNi3VjY+oUTWyMnHRMC5EUhIFxD+Y1VD4u9uIPX3jQw=="],
+
+    "@microsoft/fast-web-utilities": ["@microsoft/fast-web-utilities@5.4.1", "", { "dependencies": { "exenv-es6": "^1.1.1" } }, "sha512-ReWYncndjV3c8D8iq9tp7NcFNc1vbVHvcBFPME2nNFKNbS1XCesYZGlIlf3ot5EmuOXPlrzUHOWzQ2vFpIkqDg=="],
+
+    "@microsoft/tui-test": ["@microsoft/tui-test@0.0.2", "", { "dependencies": { "@swc/core": "^1.3.102", "@xterm/headless": "^5.3.0", "chalk": "^5.3.0", "color-convert": "^2.0.1", "commander": "^11.1.0", "expect": "^29.7.0", "glob": "^10.3.10", "jest-diff": "^29.7.0", "pretty-ms": "^8.0.0", "proper-lockfile": "^4.1.2", "which": "^4.0.0", "workerpool": "^9.1.0" }, "optionalDependencies": { "node-pty": "1.2.0-beta.11" }, "bin": { "tui-test": "index.js" } }, "sha512-4HcPhG9BJgvYeEBSKfOJAEP1jMSWmZ5+I3Nm+okyYlZ8w237n9ZmaM4ZC7xTSrjOBME/xKy8p14ontlbmB+BMA=="],
+
+    "@mixmark-io/domino": ["@mixmark-io/domino@2.2.0", "", {}, "sha512-Y28PR25bHXUg88kCV7nivXrP2Nj2RueZ3/l/jdx6J9f8J4nsEGcgX0Qe6lt7Pa+J79+kPiJU3LguR6O/6zrLOw=="],
+
+    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.29.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ=="],
+
+    "@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.6", "", { "dependencies": { "@tybys/wasm-util": "^0.10.3" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" } }, "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg=="],
+
+    "@next/env": ["@next/env@16.2.6", "", {}, "sha512-gd8HoHN4ufj73WmR3JmVolrpJR47ILK6LouP5xElPglaVxir6e1a7VzvTvDWkOoPXT9rkkTzyCxBu4yeZfZwcw=="],
+
+    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@16.2.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ZJGkkcNfYgrrMkqOdZ7zoLa1TOy0qpcMfk/z4Mh/FKUz40gVO+HNQWqmLxf67Z5WB64DRp0dhEbyHfel+6sJUg=="],
+
+    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@16.2.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-v/YLBHIY132Ced3puBJ7YJKw1lqsCrgcNo2aRJlCEyQrrCeRJlvGlnmxhPxNQI3KE3N1DN5r9TPNPvka3nq5RQ=="],
+
+    "@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@16.2.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-RPOvqlYBbcQjkz9VQQDZ2T2bARIjXZV1KFlt+V2Mr6SW/e4I9fcKsaA0hdyf2FHoTlsV2xnBd5Y912rP/1Ce6w=="],
+
+    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@16.2.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-URUTu1+dMkxJsPFgm+OeEvq9wf5sujw0EvgYy80TDGHTSLTnIHeqb0Eu8A3sC95IRgjejQL+kC4mw+4yPxiAXA=="],
+
+    "@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@16.2.6", "", { "os": "linux", "cpu": "x64" }, "sha512-DOj182mPV8G3UkrayLoREM5YEYI+Dk5wv7Ox9xl1fFibAELEsFD0lDPfHIeILlutMMfdyhlzYPELG3peuKaurw=="],
+
+    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@16.2.6", "", { "os": "linux", "cpu": "x64" }, "sha512-HKQ5SP/V/ub73UvF7n/zeJlxk2kLmtL7Wzrg4WfmkjmNos5onJ2tKu7yZOPdL18A6Svfn3max29ym+ry7NkK4g=="],
+
+    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@16.2.6", "", { "os": "win32", "cpu": "arm64" }, "sha512-LZXpTlPyS5v7HhSmnvsLGP3iIYgYOBnc8r8ArlT55sGHV89bR2HlDdBjWQ+PY6SJMmk8TuVGFuxalnP3k/0Dwg=="],
+
+    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@16.2.6", "", { "os": "win32", "cpu": "x64" }, "sha512-F0+4i0h9J6C4eE3EAPWsoCk7UW/dbzOjyzxY0qnDUOYFu6FFmdZ6l97/XdV3/Nz3VYyO7UWjyEJUXkGqcoXfMA=="],
+
+    "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
+
+    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+
+    "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
+
+    "@openai/codex": ["@openai/codex@0.130.0", "", { "optionalDependencies": { "@openai/codex-darwin-arm64": "npm:@openai/codex@0.130.0-darwin-arm64", "@openai/codex-darwin-x64": "npm:@openai/codex@0.130.0-darwin-x64", "@openai/codex-linux-arm64": "npm:@openai/codex@0.130.0-linux-arm64", "@openai/codex-linux-x64": "npm:@openai/codex@0.130.0-linux-x64", "@openai/codex-win32-arm64": "npm:@openai/codex@0.130.0-win32-arm64", "@openai/codex-win32-x64": "npm:@openai/codex@0.130.0-win32-x64" }, "bin": { "codex": "bin/codex.js" } }, "sha512-WGDj+RZ3TXWC/7MlwprgLWOqzpwatPIINPhP3IRzHA0ni+o3QZ4i4xrS2uWwGmHUJ395J5JHwoZAAZYyfJyz6w=="],
+
+    "@openai/codex-darwin-arm64": ["@openai/codex@0.130.0-darwin-arm64", "", { "os": "darwin", "cpu": "arm64" }, "sha512-R9pkGC7kwC8yQ8el5hvBlmugQlcsG/pHMEFgZluu03X9fD2TezGxdq3KqRDRCZuMYl07ILamVEoqknuJ0cq7MA=="],
+
+    "@openai/codex-darwin-x64": ["@openai/codex@0.130.0-darwin-x64", "", { "os": "darwin", "cpu": "x64" }, "sha512-gJ+7J8djevgtdra+NgDAiQQPW+O3KTsgGfE3E5dpDfww3zS5OCeV0V2dhxqnJdlOjOSDw99o0P2LqBv19mhpRw=="],
+
+    "@openai/codex-linux-arm64": ["@openai/codex@0.130.0-linux-arm64", "", { "os": "linux", "cpu": "arm64" }, "sha512-tFtH0V9/hEI3d9y7zP92BXI9FM4Z3+STNQaOR52Czv18TRtCFUp7CbIUYaToopuq6UBfnE1VKr8RLhwT5FcbmA=="],
+
+    "@openai/codex-linux-x64": ["@openai/codex@0.130.0-linux-x64", "", { "os": "linux", "cpu": "x64" }, "sha512-3VcNlez99xdnEf+kB1IOpWv9fICYV9PiGj4sLCO4TCcShLnyxe+YBGa3poknkvXLnMG0qiN9SMnYS2FGrMxQcA=="],
+
+    "@openai/codex-win32-arm64": ["@openai/codex@0.130.0-win32-arm64", "", { "os": "win32", "cpu": "arm64" }, "sha512-vdpmiNp57L/arZabltLXn8TyEtNa7W1meOEkr+3R6W/8ZyBt++wuqz1Orv134OT2grrcFJsIVCAIPiqUxCvBkA=="],
+
+    "@openai/codex-win32-x64": ["@openai/codex@0.130.0-win32-x64", "", { "os": "win32", "cpu": "x64" }, "sha512-FzMznm7fr5/nbjZgOujZ9Y9AbdGm7ji1FOoWiY3U+srqauvZaTgn6o6aCheSL7kuymu7nTLOO/cAyWV6NuesqQ=="],
+
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.17.13", "", { "dependencies": { "cross-spawn": "7.0.6" } }, "sha512-VItOGjMzRQx3zypwmeFLNhCiIx32kxS7FqzIJvVZLfyNGCifs3rfGC9qzNKWcxQo4SjNvAw++v4gWWU6Inv+JQ=="],
+
+    "@opentelemetry/api": ["@opentelemetry/api@1.9.1", "", {}, "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q=="],
+
+    "@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.214.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-40lSJeqYO8Uz2Yj7u94/SJWE/wONa7rmMKjI1ZcIjgf3MHNHv1OZUCrCETGuaRF62d5pQD1wKIW+L4lmSMTzZA=="],
+
+    "@opentelemetry/context-async-hooks": ["@opentelemetry/context-async-hooks@2.8.0", "", { "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-/3FIraneMcng67SUJCxvyInk/oxzwsxyadufk0wwfOBLf5wqtAGX4MoQASwSbndBPeARzBryUM9Azr5kHIdWLw=="],
+
+    "@opentelemetry/core": ["@opentelemetry/core@2.8.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hd1Lfh8p545nNz+jq1Ejfz+Mn1hyLuxYn1YzTfFNrxr8urEWMNQLPf1Th8kjOH+HxwawCrtgBp8JpBUR4ZSgww=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc": ["@opentelemetry/exporter-logs-otlp-grpc@0.56.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-grpc-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/sdk-logs": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-/ef8wcphVKZ0uI7A1oqQI/gEMiBUlkeBkM9AGx6AviQFIbgPVSdNK3+bHBkyq5qMkyWgkeQCSJ0uhc5vJpf0dw=="],
+
+    "@opentelemetry/exporter-logs-otlp-http": ["@opentelemetry/exporter-logs-otlp-http@0.214.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.214.0", "@opentelemetry/core": "2.6.1", "@opentelemetry/otlp-exporter-base": "0.214.0", "@opentelemetry/otlp-transformer": "0.214.0", "@opentelemetry/sdk-logs": "0.214.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9qv2Tl/Hq6qc5pJCbzFJnzA0uvlb9DgM70yGJPYf3bA5LlLkRCpcn81i4JbcIH4grlQIWY6A+W7YG0LLvS1BAw=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto": ["@opentelemetry/exporter-logs-otlp-proto@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-trace-base": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-MaO+eGrdksd8MpEbDDLbWegHc3w6ualZV6CENxNOm3wqob0iOx78/YL2NVIKyP/0ktTUIs7xIppUYqfY3ogFLQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc": ["@opentelemetry/exporter-metrics-otlp-grpc@0.56.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "1.29.0", "@opentelemetry/exporter-metrics-otlp-http": "0.56.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-grpc-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-metrics": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-yqxN9UiIu020XYX/vny06VdQIQ7/f7f+z0xEL8QGbrO9fZB8lRMvea2pxbjqW9mzZ5m7kV6t3zsOALcEg5ky1w=="],
+
+    "@opentelemetry/exporter-metrics-otlp-http": ["@opentelemetry/exporter-metrics-otlp-http@0.214.0", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/otlp-exporter-base": "0.214.0", "@opentelemetry/otlp-transformer": "0.214.0", "@opentelemetry/resources": "2.6.1", "@opentelemetry/sdk-metrics": "2.6.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Tx/59RmjBgkXJ3qnsD04rpDrVWL53LU/czpgLJh+Ab98nAroe91I7vZ3uGN9mxwPS0jsZEnmqmHygVwB2vRMlA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto": ["@opentelemetry/exporter-metrics-otlp-proto@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/exporter-metrics-otlp-http": "0.56.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-metrics": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-1FZvTmgIts5crkVIETIpIJ9Gyp7dFqgNWeZmzAzmYzWBX2QBK9fdvxs9ZWbLFKR1j9nN0Urh/w/J+lDJgbSGNg=="],
+
+    "@opentelemetry/exporter-prometheus": ["@opentelemetry/exporter-prometheus@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-metrics": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-5kFcTumUveNREskg6n4aaXx2o3ADc9YxDkArGCIegzErlc3zfzreO4Y7HDc/fYBnV9aIhJUk5P8yotyVCuymkQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc": ["@opentelemetry/exporter-trace-otlp-grpc@0.56.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-grpc-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9hRHue78CV2XShAt30HadBK8XEtOBiQmnkYquR1RQyf2RYIdJvhiypEZ+Jh3NGW8Qi14icTII/1oPTQlhuyQdQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-http": ["@opentelemetry/exporter-trace-otlp-http@0.214.0", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/otlp-exporter-base": "0.214.0", "@opentelemetry/otlp-transformer": "0.214.0", "@opentelemetry/resources": "2.6.1", "@opentelemetry/sdk-trace-base": "2.6.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kIN8nTBMgV2hXzV/a20BCFilPZdAIMYYJGSgfMMRm/Xa+07y5hRDS2Vm12A/z8Cdu3Sq++ZvJfElokX2rkgGgw=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto": ["@opentelemetry/exporter-trace-otlp-proto@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-UYVtz8Kp1QZpZFg83ZrnwRIxF2wavNyi1XaIKuQNFjlYuGCh8JH4+GOuHUU4G8cIzOkWdjNR559vv0Q+MCz+1w=="],
+
+    "@opentelemetry/exporter-zipkin": ["@opentelemetry/exporter-zipkin@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": "^1.0.0" } }, "sha512-9wNUxbl/sju2AvA3UhL2kLF1nfhJ4dVJgvktc3hx80Bg/fWHvF6ik4R3woZ/5gYFqZ97dcuik0dWPQEzLPNBtg=="],
+
+    "@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.205.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.205.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-cgvm7tvQdu9Qo7VurJP84wJ7ZV9F6WqDDGZpUc6rUEXwjV7/bXWs0kaYp9v+1Vh1+3TZCD3i6j/lUBcPhu8NhA=="],
+
+    "@opentelemetry/instrumentation-http": ["@opentelemetry/instrumentation-http@0.205.0", "", { "dependencies": { "@opentelemetry/core": "2.1.0", "@opentelemetry/instrumentation": "0.205.0", "@opentelemetry/semantic-conventions": "^1.29.0", "forwarded-parse": "2.1.2" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-6fOgRlV7ypBuEzCQP7vXkLQxz3UL1FhE24rAlMRbwGvPAnZLvutcG/fq9FI/n+VU23dOpYexocYsXCf5oy/AXw=="],
+
+    "@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.214.0", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/otlp-transformer": "0.214.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-u1Gdv0/E9wP+apqWf7Wv2npXmgJtxsW2XL0TEv9FZloTZRuMBKmu8cYVXwS4Hm3q/f/3FuCnPTgiwYvIqRSpRg=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base": ["@opentelemetry/otlp-grpc-exporter-base@0.56.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-QqM4si8Ew8CW5xVk4mYbfusJzMXyk6tkYA5SI0w/5NBxmiZZaYPwQQ2cu58XUH2IMPAsi71yLJVJQaWBBCta0A=="],
+
+    "@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.214.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.214.0", "@opentelemetry/core": "2.6.1", "@opentelemetry/resources": "2.6.1", "@opentelemetry/sdk-logs": "0.214.0", "@opentelemetry/sdk-metrics": "2.6.1", "@opentelemetry/sdk-trace-base": "2.6.1", "protobufjs": "^7.0.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-DSaYcuBRh6uozfsWN3R8HsN0yDhCuWP7tOFdkUOVaWD1KVJg8m4qiLUsg/tNhTLS9HUYUcwNpwL2eroLtsZZ/w=="],
+
+    "@opentelemetry/propagator-b3": ["@opentelemetry/propagator-b3@1.30.1", "", { "dependencies": { "@opentelemetry/core": "1.30.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ=="],
+
+    "@opentelemetry/propagator-jaeger": ["@opentelemetry/propagator-jaeger@1.30.1", "", { "dependencies": { "@opentelemetry/core": "1.30.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg=="],
+
+    "@opentelemetry/resources": ["@opentelemetry/resources@2.8.0", "", { "dependencies": { "@opentelemetry/core": "2.8.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-qmXQ27ilDbUK/vGMqwL8D4/rhn76C+sherM4wTbjlfknR8Nvfc/hCxjRJPhkzZzUsPiNg16SA31NxMabwttRjg=="],
+
+    "@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.214.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.214.0", "@opentelemetry/core": "2.6.1", "@opentelemetry/resources": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-zf6acnScjhsaBUU22zXZ/sLWim1dfhUAbGXdMmHmNG3LfBnQ3DKsOCITb2IZwoUsNNMTogqFKBnlIPPftUgGwA=="],
+
+    "@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@2.8.0", "", { "dependencies": { "@opentelemetry/core": "2.8.0", "@opentelemetry/resources": "2.8.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-UDBGaj6W0Rgy5rTTaoxs8gVGF/aGkAKyjurJv7se6wjRxJu7FoquTLT/vt54DZfo4crbprYfhX/SOK9+BPw1qg=="],
+
+    "@opentelemetry/sdk-node": ["@opentelemetry/sdk-node@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/exporter-logs-otlp-grpc": "0.56.0", "@opentelemetry/exporter-logs-otlp-http": "0.56.0", "@opentelemetry/exporter-logs-otlp-proto": "0.56.0", "@opentelemetry/exporter-trace-otlp-grpc": "0.56.0", "@opentelemetry/exporter-trace-otlp-http": "0.56.0", "@opentelemetry/exporter-trace-otlp-proto": "0.56.0", "@opentelemetry/exporter-zipkin": "1.29.0", "@opentelemetry/instrumentation": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "@opentelemetry/sdk-trace-node": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-FOY7tWboBBxqftLNHPJFmDXo9fRoPd2PlzfEvSd6058BJM9gY4pWCg8lbVlu03aBrQjcfCTAhXk/tz1Yqd/m6g=="],
+
+    "@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@2.8.0", "", { "dependencies": { "@opentelemetry/core": "2.8.0", "@opentelemetry/resources": "2.8.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-mhU4jp+vW0mGbFRd+GeXHvmfA4aDqWjBjLC3pE5XMpLs0IE2ryYb019Ts2AQrOq67gaTF25D91+fgvEHDZEnuQ=="],
+
+    "@opentelemetry/sdk-trace-node": ["@opentelemetry/sdk-trace-node@2.8.0", "", { "dependencies": { "@opentelemetry/context-async-hooks": "2.8.0", "@opentelemetry/core": "2.8.0", "@opentelemetry/sdk-trace-base": "2.8.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-nZt9OGufioAc3AfoLTqA9bsAeaMJAictYDdI2VcNQ+PmT+3rfKjAZDZvgPfd8VPX0O5Bw1hdQF6kDK8VSpZiWg=="],
+
+    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.41.1", "", {}, "sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA=="],
+
+    "@opentui-ui/dialog": ["@opentui-ui/dialog@0.1.2", "", { "peerDependencies": { "@opentui/core": "^0.1.69", "@opentui/react": "^0.1.69", "@opentui/solid": "^0.1.69" }, "optionalPeers": ["@opentui/react", "@opentui/solid"] }, "sha512-EZ4FG5u5sxU75+6pcsJsLzsD5JqO05So/1ceZUKUu7nxZ9IF7gcZEi+MU4HnYC9cb2Q7w6hM9y3/iW+jE1C53w=="],
+
+    "@opentui/core": ["@opentui/core@0.1.102", "", { "dependencies": { "bun-ffi-structs": "0.1.2", "diff": "8.0.2", "jimp": "1.6.0", "marked": "17.0.1", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@dimforge/rapier2d-simd-compat": "^0.17.3", "@opentui/core-darwin-arm64": "0.1.102", "@opentui/core-darwin-x64": "0.1.102", "@opentui/core-linux-arm64": "0.1.102", "@opentui/core-linux-x64": "0.1.102", "@opentui/core-win32-arm64": "0.1.102", "@opentui/core-win32-x64": "0.1.102", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-gNbU4XnSifo429nZ6T4jcxSmp5pFDrh0AsGJ73Vmlpc4YVWnLJ25RGsZXRsJhvxUK9OtAWJj2wq/kmiFcPLBCw=="],
+
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.102", "", { "os": "darwin", "cpu": "arm64" }, "sha512-vAYNfWhCIGnGGLRu4janrdE4z/WGeRVVJ7rRRmxWliFZfn+i29Pvrc+orKo0He6UO9nB1dLVIhmW8dlINPvhgQ=="],
+
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.102", "", { "os": "darwin", "cpu": "x64" }, "sha512-BSiZx0QzQ+MUm+XMrktBMyYQKifvy4FFvxqVIhKJv9xlHTTdsFtN/RZ/vuExLn6Xxv9d19psqSbTEJ+HGe76mw=="],
+
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.102", "", { "os": "linux", "cpu": "arm64" }, "sha512-/49i8RnBQ28o30G6/5Ni4CCtgwOzGn3/NzJbUcfIctXMBiNdoH3v1iSS+XlUREolMNz7l1zcJ6+9OvCRaV7DdA=="],
+
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.102", "", { "os": "linux", "cpu": "x64" }, "sha512-XpkQ+nUaa4HY6poJqfJEkSFil5CDyXzpQsnU5nUAwJXrHLUJOh8Gwx+F1UdoD/JNwBFlJ1Xhzpp3CdmuFXPdyQ=="],
+
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.102", "", { "os": "win32", "cpu": "arm64" }, "sha512-AeoCvtlb/RhDRukFDSmblT5EJFvSwftRp2DGEwZ1leu+zkmp0Ffykn3mGWR2UQUyPTVOGRWKGGyp/Kg2SeniAA=="],
+
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.102", "", { "os": "win32", "cpu": "x64" }, "sha512-9Lzd+XkLOJRqhe54bDdorviHAFuO1SPIQMqPieE4bszkiUwekEdgg5x9ymwHh5OUCh0Wiwstl42G4f7BjvMIcA=="],
+
+    "@opentui/react": ["@opentui/react@0.1.102", "", { "dependencies": { "@opentui/core": "0.1.102", "react-reconciler": "^0.32.0" }, "peerDependencies": { "react": ">=19.0.0", "react-devtools-core": "^7.0.1", "ws": "^8.18.0" } }, "sha512-c7EiK30xlvaHc6WBOLAH7TJ8xC4QbiD5ZA6tb4zZ74XM4SH5Tb+uBee8b4TztTLseq+hGtW85qrIUJM3OrdtNw=="],
+
+    "@oxc-project/types": ["@oxc-project/types@0.138.0", "", {}, "sha512-1a7ZKmrRTCoN1XMZ4L0PyyqrMnrNlLyPuOkdSX2MZg7IiIGRUyurNhAm73ptDOraoBcIordsIGKNPKUzy3ZmfA=="],
+
+    "@paper-design/shaders": ["@paper-design/shaders@0.0.46", "", {}, "sha512-ErPQwLguvv7qI8E+bdwSaNQF27Q8MnZmtD8rGp+K473AYee+cXWv2OqBkKnuMl/n1JmL8vBxSSTflOfO6DB4aQ=="],
+
+    "@paper-design/shaders-react": ["@paper-design/shaders-react@0.0.46", "", { "dependencies": { "@paper-design/shaders": "0.0.46" }, "peerDependencies": { "@types/react": "^18 || ^19", "react": "^18 || ^19" }, "optionalPeers": ["@types/react"] }, "sha512-bvgLvw8Cozmhw1spRmaabT/bh3N4G/Qq6Mb8yOWvWccTmo1UB7YKhEDbHbgCevvry2BgPGotrlfCE+YGeDeY7g=="],
+
+    "@pinojs/redact": ["@pinojs/redact@0.4.0", "", {}, "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg=="],
+
+    "@pkgjs/parseargs": ["@pkgjs/parseargs@0.11.0", "", {}, "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg=="],
+
+    "@playwright/test": ["@playwright/test@1.61.1", "", { "dependencies": { "playwright": "1.61.1" }, "bin": { "playwright": "cli.js" } }, "sha512-8nKv6+0RJSL9FE4jYOEGXnPeM/Hg12qZpmqzZjRh3qM0Y7c3z1mrOTfFLids72RDQYVh9WpLEfR5WdpNX4fkig=="],
+
+    "@posthog/core": ["@posthog/core@1.39.3", "", { "dependencies": { "@posthog/types": "^1.392.0" } }, "sha512-oR+B8Q5O61N+W2+HVOBG9dbxAT/+OVxX+XvpNj6KYgptN2EB14JiKQ9Rm7DNpErNTLV7WApZEK/URkZgldOxfg=="],
+
+    "@posthog/types": ["@posthog/types@1.392.0", "", {}, "sha512-nctNujXL3FC1v99FktaTMSugSD9ZOZekEpahUSafkU2TSvW+XGKNkQZbokuJtiWvPBK208dwMJva8UfBkChqpw=="],
+
+    "@protobufjs/aspromise": ["@protobufjs/aspromise@1.1.2", "", {}, "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="],
+
+    "@protobufjs/base64": ["@protobufjs/base64@1.1.2", "", {}, "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="],
+
+    "@protobufjs/codegen": ["@protobufjs/codegen@2.0.5", "", {}, "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g=="],
+
+    "@protobufjs/eventemitter": ["@protobufjs/eventemitter@1.1.1", "", {}, "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg=="],
+
+    "@protobufjs/fetch": ["@protobufjs/fetch@1.1.1", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.1" } }, "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw=="],
+
+    "@protobufjs/float": ["@protobufjs/float@1.0.2", "", {}, "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ=="],
+
+    "@protobufjs/inquire": ["@protobufjs/inquire@1.1.2", "", {}, "sha512-pa0vFRuws4wkvaXKK1uXZMAwAX4/t8ANaJo45iw/oQHNQ9q5xUzwgFmVJGXiga2BeN+zpX7Vf9vmsiIa2J+MUw=="],
+
+    "@protobufjs/path": ["@protobufjs/path@1.1.2", "", {}, "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA=="],
+
+    "@protobufjs/pool": ["@protobufjs/pool@1.1.0", "", {}, "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw=="],
+
+    "@protobufjs/utf8": ["@protobufjs/utf8@1.1.1", "", {}, "sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg=="],
+
+    "@puppeteer/browsers": ["@puppeteer/browsers@2.6.1", "", { "dependencies": { "debug": "^4.4.0", "extract-zip": "^2.0.1", "progress": "^2.0.3", "proxy-agent": "^6.5.0", "semver": "^7.6.3", "tar-fs": "^3.0.6", "unbzip2-stream": "^1.4.3", "yargs": "^17.7.2" }, "bin": { "browsers": "lib/cjs/main-cli.js" } }, "sha512-aBSREisdsGH890S2rQqK82qmQYU3uFpSH8wcZWHgHzl3LfzsxAKbLNiAG9mO8v1Y0UICBeClICxPJvyr0rcuxg=="],
+
+    "@radix-ui/number": ["@radix-ui/number@1.1.1", "", {}, "sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g=="],
+
+    "@radix-ui/primitive": ["@radix-ui/primitive@1.1.3", "", {}, "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg=="],
+
+    "@radix-ui/react-accessible-icon": ["@radix-ui/react-accessible-icon@1.1.11", "", { "dependencies": { "@radix-ui/react-visually-hidden": "1.2.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-HQDOFTKwSnmUij6l54wYJJtxTAnxI71+YJLOrjm2ladFB8HAV5Jt7hwaZPhWTGBkYoW4+ZAOfNZrLDh/qvxSYA=="],
+
+    "@radix-ui/react-accordion": ["@radix-ui/react-accordion@1.2.12", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collapsible": "1.1.12", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA=="],
+
+    "@radix-ui/react-alert-dialog": ["@radix-ui/react-alert-dialog@1.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dialog": "1.1.15", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-oTVLkEw5GpdRe29BqJ0LSDFWI3qu0vR1M0mUkOQWDIUnY/QIkLpgDMWuKxP94c2NAC2LGcgVhG1ImF3jkZ5wXw=="],
+
+    "@radix-ui/react-arrow": ["@radix-ui/react-arrow@1.1.11", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Kdil9BB1rIFC/khmf4hC35bn8701AJcizTU7G7cUbEbk5XqqbjDuHW60uUfKqO5WojjZcbAW51Q7P0hRmMLw8A=="],
+
+    "@radix-ui/react-aspect-ratio": ["@radix-ui/react-aspect-ratio@1.1.8", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-5nZrJTF7gH+e0nZS7/QxFz6tJV4VimhQb1avEgtsJxvvIp5JilL+c58HICsKzPxghdwaDt48hEfPM1au4zGy+w=="],
+
+    "@radix-ui/react-avatar": ["@radix-ui/react-avatar@1.1.11", "", { "dependencies": { "@radix-ui/react-context": "1.1.3", "@radix-ui/react-primitive": "2.1.4", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-is-hydrated": "0.1.0", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0Qk603AHGV28BOBO34p7IgD5m+V5Sg/YovfayABkoDDBM5d3NCx0Mp4gGrjzLGes1jV5eNOE1r3itqOR33VC6Q=="],
+
+    "@radix-ui/react-checkbox": ["@radix-ui/react-checkbox@1.3.3", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-wBbpv+NQftHDdG86Qc0pIyXk5IR3tM8Vd0nWLKDcX8nNn4nXFOFwsKuqw2okA/1D/mpaAkmuyndrPJTYDNZtFw=="],
+
+    "@radix-ui/react-collapsible": ["@radix-ui/react-collapsible@1.1.12", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA=="],
+
+    "@radix-ui/react-collection": ["@radix-ui/react-collection@1.1.7", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw=="],
+
+    "@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg=="],
+
+    "@radix-ui/react-context": ["@radix-ui/react-context@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA=="],
+
+    "@radix-ui/react-context-menu": ["@radix-ui/react-context-menu@2.2.16", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-menu": "2.1.16", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-O8morBEW+HsVG28gYDZPTrT9UUovQUlJue5YO836tiTJhuIWBm/zQHc7j388sHWtdH/xUZurK9olD2+pcqx5ww=="],
+
+    "@radix-ui/react-dialog": ["@radix-ui/react-dialog@1.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw=="],
+
+    "@radix-ui/react-direction": ["@radix-ui/react-direction@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw=="],
+
+    "@radix-ui/react-dismissable-layer": ["@radix-ui/react-dismissable-layer@1.1.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-escape-keydown": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg=="],
+
+    "@radix-ui/react-dropdown-menu": ["@radix-ui/react-dropdown-menu@2.1.16", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-menu": "2.1.16", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw=="],
+
+    "@radix-ui/react-focus-guards": ["@radix-ui/react-focus-guards@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw=="],
+
+    "@radix-ui/react-focus-scope": ["@radix-ui/react-focus-scope@1.1.7", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw=="],
+
+    "@radix-ui/react-form": ["@radix-ui/react-form@0.1.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-label": "2.1.11", "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0mTMJHv1gQAuEQoq5VDpTD3MRgmfUFdXAVFhpqR7wBeUr+tyRsof0wv/4XdPHLwQrefhoH2FiGHCggrCJhalIw=="],
+
+    "@radix-ui/react-hover-card": ["@radix-ui/react-hover-card@1.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-qgTkjNT1CfKMoP0rcasmlH2r1DAiYicWsDsufxl940sT2wHNEWWv6FMWIQXWhVdmC1d/HYfbhQx60KYyAtKxjg=="],
+
+    "@radix-ui/react-id": ["@radix-ui/react-id@1.1.1", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg=="],
+
+    "@radix-ui/react-label": ["@radix-ui/react-label@2.1.8", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-FmXs37I6hSBVDlO4y764TNz1rLgKwjJMQ0EGte6F3Cb3f4bIuHB/iLa/8I9VKkmOy+gNHq8rql3j686ACVV21A=="],
+
+    "@radix-ui/react-menu": ["@radix-ui/react-menu@2.1.16", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-callback-ref": "1.1.1", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg=="],
+
+    "@radix-ui/react-menubar": ["@radix-ui/react-menubar@1.1.16", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-menu": "2.1.16", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-EB1FktTz5xRRi2Er974AUQZWg2yVBb1yjip38/lgwtCVRd3a+maUoGHN/xs9Yv8SY8QwbSEb+YrxGadVWbEutA=="],
+
+    "@radix-ui/react-navigation-menu": ["@radix-ui/react-navigation-menu@1.2.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w=="],
+
+    "@radix-ui/react-one-time-password-field": ["@radix-ui/react-one-time-password-field@0.1.11", "", { "dependencies": { "@radix-ui/number": "1.1.2", "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-effect-event": "0.0.3", "@radix-ui/react-use-is-hydrated": "0.1.1", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Rsgab65u73E5kPVh8OS6PgPwJgPyf08GFfJDGAbMdF4DL7CgDhFOaDnXuk/DiMEVF6kgQwl0oJmFklvipmiOLg=="],
+
+    "@radix-ui/react-password-toggle-field": ["@radix-ui/react-password-toggle-field@0.1.6", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-effect-event": "0.0.3", "@radix-ui/react-use-is-hydrated": "0.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-pQ3xGp/uemomASPH97Eb3shfXX8QlG11bBJyEvRBV+vwtO4HvQlS06Yj9f31Ao7XepvF98SFrRgVDQ7jv+2xjQ=="],
+
+    "@radix-ui/react-popover": ["@radix-ui/react-popover@1.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA=="],
+
+    "@radix-ui/react-popper": ["@radix-ui/react-popper@1.2.8", "", { "dependencies": { "@floating-ui/react-dom": "^2.0.0", "@radix-ui/react-arrow": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-rect": "1.1.1", "@radix-ui/react-use-size": "1.1.1", "@radix-ui/rect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw=="],
+
+    "@radix-ui/react-portal": ["@radix-ui/react-portal@1.1.9", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ=="],
+
+    "@radix-ui/react-presence": ["@radix-ui/react-presence@1.1.5", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ=="],
+
+    "@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.4", "", { "dependencies": { "@radix-ui/react-slot": "1.2.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg=="],
+
+    "@radix-ui/react-progress": ["@radix-ui/react-progress@1.1.8", "", { "dependencies": { "@radix-ui/react-context": "1.1.3", "@radix-ui/react-primitive": "2.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-+gISHcSPUJ7ktBy9RnTqbdKW78bcGke3t6taawyZ71pio1JewwGSJizycs7rLhGTvMJYCQB1DBK4KQsxs7U8dA=="],
+
+    "@radix-ui/react-radio-group": ["@radix-ui/react-radio-group@1.3.8", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ=="],
+
+    "@radix-ui/react-roving-focus": ["@radix-ui/react-roving-focus@1.1.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA=="],
+
+    "@radix-ui/react-scroll-area": ["@radix-ui/react-scroll-area@1.2.10", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-tAXIa1g3sM5CGpVT0uIbUx/U3Gs5N8T52IICuCtObaos1S8fzsrPXG5WObkQN3S6NVl6wKgPhAIiBGbWnvc97A=="],
+
+    "@radix-ui/react-select": ["@radix-ui/react-select@2.2.6", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ=="],
+
+    "@radix-ui/react-separator": ["@radix-ui/react-separator@1.1.8", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-sDvqVY4itsKwwSMEe0jtKgfTh+72Sy3gPmQpjqcQneqQ4PFmr/1I0YA+2/puilhggCe2gJcx5EBAYFkWkdpa5g=="],
+
+    "@radix-ui/react-slider": ["@radix-ui/react-slider@1.3.6", "", { "dependencies": { "@radix-ui/number": "1.1.1", "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw=="],
+
+    "@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.4", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA=="],
+
+    "@radix-ui/react-switch": ["@radix-ui/react-switch@1.2.6", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ=="],
+
+    "@radix-ui/react-tabs": ["@radix-ui/react-tabs@1.1.13", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-7xdcatg7/U+7+Udyoj2zodtI9H/IIopqo+YOIcZOq1nJwXWBZ9p8xiu5llXlekDbZkca79a/fozEYQXIA4sW6A=="],
+
+    "@radix-ui/react-toast": ["@radix-ui/react-toast@1.2.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-3OSz3TacUWy4WtOXV38DggwxoqJK4+eDkNMl5Z/MJZaoUPaP4/9lf81xXMe1I2ReTAptverZUpbPY4wWwWyL5g=="],
+
+    "@radix-ui/react-toggle": ["@radix-ui/react-toggle@1.1.10", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-lS1odchhFTeZv3xwHH31YPObmJn8gOg7Lq12inrr0+BH/l3Tsq32VfjqH1oh80ARM3mlkfMic15n0kg4sD1poQ=="],
+
+    "@radix-ui/react-toggle-group": ["@radix-ui/react-toggle-group@1.1.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-toggle": "1.1.10", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-5umnS0T8JQzQT6HbPyO7Hh9dgd82NmS36DQr+X/YJ9ctFNCiiQd6IJAYYZ33LUwm8M+taCz5t2ui29fHZc4Y6Q=="],
+
+    "@radix-ui/react-toolbar": ["@radix-ui/react-toolbar@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-separator": "1.1.11", "@radix-ui/react-toggle-group": "1.1.14" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-L/EkWVqlnj3lL2toHh4C7PwH2jxfa7OCq6lGfXSCii99ve2S4Ux5rc9HnOa7LN9exHa/Nl9kmCAmP9BuDPy5UA=="],
+
+    "@radix-ui/react-tooltip": ["@radix-ui/react-tooltip@1.2.8", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg=="],
+
+    "@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg=="],
+
+    "@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.3", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.3", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-PLzC90MS+ReootmjC597dvopoelpZ8Q61HJkDXZSExitIq7PL55vHNnesAHwguHK0aPfBnpdNzQtv1uliaqQrA=="],
+
+    "@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.3", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-6c8ZqvPTWILEKnyVkP53EGRCcpnJiKTC21sS/6R1GF5xKyHJJWQEPfkqlcgUkdRQivd6tb23abUwe4ngWmY0JA=="],
+
+    "@radix-ui/react-use-escape-keydown": ["@radix-ui/react-use-escape-keydown@1.1.3", "", { "dependencies": { "@radix-ui/react-use-callback-ref": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-3wEkMiPHXha/2VadZ68rYBcmYnPINVGl4Y3gtcM7fKRjANk0OscK+cdqBgUWdozb7YJxsh0vefM7vgAMHXOjqg=="],
+
+    "@radix-ui/react-use-is-hydrated": ["@radix-ui/react-use-is-hydrated@0.1.0", "", { "dependencies": { "use-sync-external-store": "^1.5.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA=="],
+
+    "@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jrBWOxZITuGcnjRCM2t2U5ZPkCLxD+Ym6DjfssS5haTj2iiak/DOb64JeN6OdLfLgptb6/e2kKR+ZuTrGoZTPA=="],
+
+    "@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ=="],
+
+    "@radix-ui/react-use-rect": ["@radix-ui/react-use-rect@1.1.1", "", { "dependencies": { "@radix-ui/rect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w=="],
+
+    "@radix-ui/react-use-size": ["@radix-ui/react-use-size@1.1.1", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ=="],
+
+    "@radix-ui/react-visually-hidden": ["@radix-ui/react-visually-hidden@1.2.3", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug=="],
+
+    "@radix-ui/rect": ["@radix-ui/rect@1.1.1", "", {}, "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw=="],
+
+    "@react-aria/breadcrumbs": ["@react-aria/breadcrumbs@3.5.32", "", { "dependencies": { "@react-aria/i18n": "^3.12.16", "@react-aria/link": "^3.8.9", "@react-aria/utils": "^3.33.1", "@react-types/breadcrumbs": "^3.7.19", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-S61vh5DJ2PXiXUwD7gk+pvS/b4VPrc3ZJOUZ0yVRLHkVESr5LhIZH+SAVgZkm1lzKyMRG+BH+fiRH/DZRSs7SA=="],
+
+    "@react-aria/button": ["@react-aria/button@3.14.5", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/toolbar": "3.0.0-beta.24", "@react-aria/utils": "^3.33.1", "@react-stately/toggle": "^3.9.5", "@react-types/button": "^3.15.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-ZuLx+wQj9VQhH9BYe7t0JowmKnns2XrFHFNvIVBb5RwxL+CIycIOL7brhWKg2rGdxvlOom7jhVbcjSmtAaSyaQ=="],
+
+    "@react-aria/calendar": ["@react-aria/calendar@3.9.5", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/live-announcer": "^3.4.4", "@react-aria/utils": "^3.33.1", "@react-stately/calendar": "^3.9.3", "@react-types/button": "^3.15.1", "@react-types/calendar": "^3.8.3", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-k0kvceYdZZu+DoeqephtlmIvh1CxqdFyoN52iqVzTz9O0pe5Xfhq7zxPGbeCp4pC61xzp8Lu/6uFA/YNfQQNag=="],
+
+    "@react-aria/checkbox": ["@react-aria/checkbox@3.16.5", "", { "dependencies": { "@react-aria/form": "^3.1.5", "@react-aria/interactions": "^3.27.1", "@react-aria/label": "^3.7.25", "@react-aria/toggle": "^3.12.5", "@react-aria/utils": "^3.33.1", "@react-stately/checkbox": "^3.7.5", "@react-stately/form": "^3.2.4", "@react-stately/toggle": "^3.9.5", "@react-types/checkbox": "^3.10.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-ZhUT7ELuD52hb+Zpzw0ElLQiVOd5sKYahrh+PK3vq13Wk5TedBscALpjuXetI4pwFfdmAM1Lhgcsrd8+6AmyvA=="],
+
+    "@react-aria/combobox": ["@react-aria/combobox@3.15.0", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/listbox": "^3.15.3", "@react-aria/live-announcer": "^3.4.4", "@react-aria/menu": "^3.21.0", "@react-aria/overlays": "^3.31.2", "@react-aria/selection": "^3.27.2", "@react-aria/textfield": "^3.18.5", "@react-aria/utils": "^3.33.1", "@react-stately/collections": "^3.12.10", "@react-stately/combobox": "^3.13.0", "@react-stately/form": "^3.2.4", "@react-types/button": "^3.15.1", "@react-types/combobox": "^3.14.0", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-qSjQTFwKl3x1jCP2NRSJ6doZqAp6c2GTfoiFwWjaWg1IewwLsglaW6NnzqRDFiqFbDGgXPn4MqtC1VYEJ3NEjA=="],
+
+    "@react-aria/datepicker": ["@react-aria/datepicker@3.16.1", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@internationalized/number": "^3.6.5", "@internationalized/string": "^3.2.7", "@react-aria/focus": "^3.21.5", "@react-aria/form": "^3.1.5", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/label": "^3.7.25", "@react-aria/spinbutton": "^3.7.2", "@react-aria/utils": "^3.33.1", "@react-stately/datepicker": "^3.16.1", "@react-stately/form": "^3.2.4", "@react-types/button": "^3.15.1", "@react-types/calendar": "^3.8.3", "@react-types/datepicker": "^3.13.5", "@react-types/dialog": "^3.5.24", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-6BltCVWt09yefTkGjb2gViGCwoddx9HKJiZbY9u6Es/Q+VhwNJQRtczbnZ3K32p262hIknukNf/5nZaCOI1AKA=="],
+
+    "@react-aria/dialog": ["@react-aria/dialog@3.5.34", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/overlays": "^3.31.2", "@react-aria/utils": "^3.33.1", "@react-types/dialog": "^3.5.24", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-/x53Q5ynpW5Kv9637WYu7SrDfj3woSp6jJRj8l6teGnWW/iNZWYJETgzHfbxx+HPKYATCZesRoIeO2LnYIXyEA=="],
+
+    "@react-aria/focus": ["@react-aria/focus@3.21.5", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/utils": "^3.33.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0", "clsx": "^2.0.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-V18fwCyf8zqgJdpLQeDU5ZRNd9TeOfBbhLgmX77Zr5ae9XwaoJ1R3SFJG1wCJX60t34AW+aLZSEEK+saQElf3Q=="],
+
+    "@react-aria/form": ["@react-aria/form@3.1.5", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/utils": "^3.33.1", "@react-stately/form": "^3.2.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-BWlONgHn8hmaMkcS6AgMSLQeNqVBwqPNLhdqjDO/PCfzvV7O8NZw/dFeIzJwfG4aBfSpbHHRdXGdfrk3d8dylQ=="],
+
+    "@react-aria/grid": ["@react-aria/grid@3.15.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-u/903msISq7V78lAJ1Nt4bElMTh6Pzp/bS+lFv79POkFeHWv4icb42egRI7D9YYjO1tYWmNHC5iTcxzvcnOWxQ=="],
+
+    "@react-aria/i18n": ["@react-aria/i18n@3.12.16", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@internationalized/message": "^3.1.8", "@internationalized/number": "^3.6.5", "@internationalized/string": "^3.2.7", "@react-aria/ssr": "^3.9.10", "@react-aria/utils": "^3.33.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-Km2CAz6MFQOUEaattaW+2jBdWOHUF8WX7VQoNbjlqElCP58nSaqi9yxTWUDRhAcn8/xFUnkFh4MFweNgtrHuEA=="],
+
+    "@react-aria/interactions": ["@react-aria/interactions@3.27.1", "", { "dependencies": { "@react-aria/ssr": "^3.9.10", "@react-aria/utils": "^3.33.1", "@react-stately/flags": "^3.1.2", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-M3wLpTTmDflI0QGNK0PJNUaBXXfeBXue8ZxLMngfc1piHNiH4G5lUvWd9W14XVbqrSCVY8i8DfGrNYpyyZu0tw=="],
+
+    "@react-aria/label": ["@react-aria/label@3.8.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-zf6hG22PnxZ9kEUwxORClBicHK5pcvucDU+lotGsI6ENbdIvJAMNn9X0oiPPae56CVf2T0KEL9NB8LKdAfzCIw=="],
+
+    "@react-aria/landmark": ["@react-aria/landmark@3.1.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-Njn/UVrCb2BPW1CPLHA1vrH51+ug62xLMNGUu2qtYj1rAxkLG1m3151hewgcxYtpmPxYlnRtOAmSuu/oD5YTFA=="],
+
+    "@react-aria/link": ["@react-aria/link@3.9.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-lup+i3TVgVjRJOt6kpngZfP+3bmeABqcDRhEaE+7xg7DRpbeiccNYVMtKySiFTZePwP3fcbCyTGxZe6DY4CLmA=="],
+
+    "@react-aria/listbox": ["@react-aria/listbox@3.15.3", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/label": "^3.7.25", "@react-aria/selection": "^3.27.2", "@react-aria/utils": "^3.33.1", "@react-stately/collections": "^3.12.10", "@react-stately/list": "^3.13.4", "@react-types/listbox": "^3.7.6", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-C6YgiyrHS5sbS5UBdxGMhEs+EKJYotJgGVtl9l0ySXpBUXERiHJWLOyV7a8PwkUOmepbB4FaLD7Y9EUzGkrGlw=="],
+
+    "@react-aria/live-announcer": ["@react-aria/live-announcer@3.5.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-kLvwHjM3D7KgdquiAhUpRnMLKFrvl2r8naDXqPUlSWGRG15wsJRLhQOHLxGp0Umyg7KcSA+OD1mhQV5aRv0P1w=="],
+
+    "@react-aria/menu": ["@react-aria/menu@3.21.0", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/overlays": "^3.31.2", "@react-aria/selection": "^3.27.2", "@react-aria/utils": "^3.33.1", "@react-stately/collections": "^3.12.10", "@react-stately/menu": "^3.9.11", "@react-stately/selection": "^3.20.9", "@react-stately/tree": "^3.9.6", "@react-types/button": "^3.15.1", "@react-types/menu": "^3.10.7", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-CKTVZ4izSE1eKIti6TbTtzJAUo+WT8O4JC0XZCYDBpa0f++lD19Kz9aY+iY1buv5xGI20gAfpO474E9oEd4aQA=="],
+
+    "@react-aria/numberfield": ["@react-aria/numberfield@3.12.5", "", { "dependencies": { "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/live-announcer": "^3.4.4", "@react-aria/spinbutton": "^3.7.2", "@react-aria/textfield": "^3.18.5", "@react-aria/utils": "^3.33.1", "@react-stately/form": "^3.2.4", "@react-stately/numberfield": "^3.11.0", "@react-types/button": "^3.15.1", "@react-types/numberfield": "^3.8.18", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-Fi41IUWXEHLFIeJ/LHuZ9Azs8J/P563fZi37GSBkIq5P1pNt1rPgJJng5CNn4KsHxwqadTRUlbbZwbZraWDtRg=="],
+
+    "@react-aria/overlays": ["@react-aria/overlays@3.31.2", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/ssr": "^3.9.10", "@react-aria/utils": "^3.33.1", "@react-aria/visually-hidden": "^3.8.31", "@react-stately/flags": "^3.1.2", "@react-stately/overlays": "^3.6.23", "@react-types/button": "^3.15.1", "@react-types/overlays": "^3.9.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-78HYI08r6LvcfD34gyv19ArRIjy1qxOKuXl/jYnjLDyQzD4pVb634IQWcm0zt10RdKgyuH6HTqvuDOgZTLet7Q=="],
+
+    "@react-aria/progress": ["@react-aria/progress@3.4.30", "", { "dependencies": { "@react-aria/i18n": "^3.12.16", "@react-aria/label": "^3.7.25", "@react-aria/utils": "^3.33.1", "@react-types/progress": "^3.5.18", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-S6OWVGgluSWYSd/A6O8CVjz83eeMUfkuWSra0ewAV9bmxZ7TP9pUmD3bGdqHZEl97nt5vHGjZ3eq/x8eCmzKhA=="],
+
+    "@react-aria/radio": ["@react-aria/radio@3.12.5", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/form": "^3.1.5", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/label": "^3.7.25", "@react-aria/utils": "^3.33.1", "@react-stately/radio": "^3.11.5", "@react-types/radio": "^3.9.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-8CCJKJzfozEiWBPO9QAATG1rBGJEJ+xoqvHf9LKU2sPFGsA2/SRnLs6LB9fCG5R3spvaK1xz0any1fjWPl7x8A=="],
+
+    "@react-aria/selection": ["@react-aria/selection@3.27.2", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/utils": "^3.33.1", "@react-stately/selection": "^3.20.9", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-GbUSSLX/ciXix95KW1g+SLM9np7iXpIZrFDSXkC6oNx1uhy18eAcuTkeZE25+SY5USVUmEzjI3m/3JoSUcebbg=="],
+
+    "@react-aria/slider": ["@react-aria/slider@3.8.5", "", { "dependencies": { "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/label": "^3.7.25", "@react-aria/utils": "^3.33.1", "@react-stately/slider": "^3.7.5", "@react-types/shared": "^3.33.1", "@react-types/slider": "^3.8.4", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-gqkJxznk141mE0JamXF5CXml9PDbPkBz8dyKlihtWHWX4yhEbVYdC9J0otE7iCR3zx69Bm7WHoTGL0BsdpKzVA=="],
+
+    "@react-aria/spinbutton": ["@react-aria/spinbutton@3.8.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-mDed6rDI2JE3QCaX+QykRyw9GjiRAHY1+RqxX2DR0yEtW2n9GxTQfCR9KVnXm69eTgCoxDIa7okBCrHhYB8bUw=="],
+
+    "@react-aria/ssr": ["@react-aria/ssr@3.10.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-jn038/ZYmu6DpfXJ6r2U9zFFppjbc9wnApPJSCxao2RZVEqep4YyoniHSy8qv6V21/xyS4IV7W9a+X2jOjSuag=="],
+
+    "@react-aria/switch": ["@react-aria/switch@3.7.11", "", { "dependencies": { "@react-aria/toggle": "^3.12.5", "@react-stately/toggle": "^3.9.5", "@react-types/shared": "^3.33.1", "@react-types/switch": "^3.5.17", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-dYVX71HiepBsKyeMaQgHbhqI+MQ3MVoTd5EnTbUjefIBnmQZavYj1/e4NUiUI4Ix+/C0HxL8ibDAv4NlSW3eLQ=="],
+
+    "@react-aria/table": ["@react-aria/table@3.17.11", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/grid": "^3.14.8", "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/live-announcer": "^3.4.4", "@react-aria/utils": "^3.33.1", "@react-aria/visually-hidden": "^3.8.31", "@react-stately/collections": "^3.12.10", "@react-stately/flags": "^3.1.2", "@react-stately/table": "^3.15.4", "@react-types/checkbox": "^3.10.4", "@react-types/grid": "^3.3.8", "@react-types/shared": "^3.33.1", "@react-types/table": "^3.13.6", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-GkYmWPiW3OM+FUZxdS33teHXHXde7TjHuYgDDaG9phvg6cQTQjGilJozrzA3OfftTOq5VB8XcKTIQW3c0tpYsQ=="],
+
+    "@react-aria/tabs": ["@react-aria/tabs@3.11.1", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/i18n": "^3.12.16", "@react-aria/selection": "^3.27.2", "@react-aria/utils": "^3.33.1", "@react-stately/tabs": "^3.8.9", "@react-types/shared": "^3.33.1", "@react-types/tabs": "^3.3.22", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-3Ppz7yaEDW9L7p9PE9yNOl5caLwNnnLQqI+MX/dwbWlw9HluHS7uIjb21oswNl6UbSxAWyENOka45+KN4Fkh7A=="],
+
+    "@react-aria/textfield": ["@react-aria/textfield@3.18.5", "", { "dependencies": { "@react-aria/form": "^3.1.5", "@react-aria/interactions": "^3.27.1", "@react-aria/label": "^3.7.25", "@react-aria/utils": "^3.33.1", "@react-stately/form": "^3.2.4", "@react-stately/utils": "^3.11.0", "@react-types/shared": "^3.33.1", "@react-types/textfield": "^3.12.8", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-ttwVSuwoV3RPaG2k2QzEXKeQNQ3mbdl/2yy6I4Tjrn1ZNkYHfVyJJ26AjenfSmj1kkTQoSAfZ8p+7rZp4n0xoQ=="],
+
+    "@react-aria/toast": ["@react-aria/toast@3.0.11", "", { "dependencies": { "@react-aria/i18n": "^3.12.16", "@react-aria/interactions": "^3.27.1", "@react-aria/landmark": "^3.0.10", "@react-aria/utils": "^3.33.1", "@react-stately/toast": "^3.1.3", "@react-types/button": "^3.15.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-2DjZjBAvm8/CWbnZ6s7LjkYCkULKtjMve6GvhPTq98AthuEDLEiBvM1wa3xdecCRhZyRT1g6DXqVca0EfZ9fJA=="],
+
+    "@react-aria/toggle": ["@react-aria/toggle@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-1SPMBSrbT94Jsy7Wuv9SH2uPv7szGP7KgO4QGIAcF3e5kHwvGQJdMHY6+xR17slk8ICXfFojBqUKgpJjyY2+KQ=="],
+
+    "@react-aria/toolbar": ["@react-aria/toolbar@3.0.0-beta.24", "", { "dependencies": { "@react-aria/focus": "^3.21.5", "@react-aria/i18n": "^3.12.16", "@react-aria/utils": "^3.33.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-B2Rmpko7Ghi2RbNfsGdbR7I+RQBDhPGVE4bU3/EwHz+P/vNe5LyGPTeSwqaOMsQTF9lKNCkY8424dVTCr6RUMg=="],
+
+    "@react-aria/tooltip": ["@react-aria/tooltip@3.9.2", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/utils": "^3.33.1", "@react-stately/tooltip": "^3.5.11", "@react-types/shared": "^3.33.1", "@react-types/tooltip": "^3.5.2", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-VrgkPwHiEnAnBhoQ4W7kfry/RfVuRWrUPaJSp0+wKM6u0gg2tmn7OFRDXTxBAm/omQUguIdIjRWg7sf3zHH82A=="],
+
+    "@react-aria/utils": ["@react-aria/utils@3.33.1", "", { "dependencies": { "@react-aria/ssr": "^3.9.10", "@react-stately/flags": "^3.1.2", "@react-stately/utils": "^3.11.0", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0", "clsx": "^2.0.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-kIx1Sj6bbAT0pdqCegHuPanR9zrLn5zMRiM7LN12rgRf55S19ptd9g3ncahArifYTRkfEU9VIn+q0HjfMqS9/w=="],
+
+    "@react-aria/visually-hidden": ["@react-aria/visually-hidden@3.8.31", "", { "dependencies": { "@react-aria/interactions": "^3.27.1", "@react-aria/utils": "^3.33.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-RTOHHa4n56a9A3criThqFHBifvZoV71+MCkSuNP2cKO662SUWjqKkd0tJt/mBRMEJPkys8K7Eirp6T8Wt5FFRA=="],
+
+    "@react-spectrum/dialog": ["@react-spectrum/dialog@3.10.1", "", { "dependencies": { "@adobe/react-spectrum": "^3.47.0", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-RMoZkKswUMFiEnAHZljEV1ybpMUjrS5RxkwWb3IFMo+ZtnLIeIT87k4DxoUJKOVrw3bnSsLRSTw1Fvf7jZ/eFw=="],
+
+    "@react-spectrum/listbox": ["@react-spectrum/listbox@3.16.1", "", { "dependencies": { "@adobe/react-spectrum": "^3.47.0", "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-iQ7eym1zVR3wmOpOnmbKF0A+cbdzUGobZdNC/H9rdiyGkEE0OIrlk3z3APIFHfM/juK/LHXZ+srbF5LU8/sDCg=="],
+
+    "@react-spectrum/provider": ["@react-spectrum/provider@3.11.1", "", { "dependencies": { "@adobe/react-spectrum": "^3.47.0", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-TsoNdVdmlQ7L+75ILq5Yb3+wp/I1AtIeat0o+Y+ZBxP+TtWpwT1ZtCB5l3cplFVzHzOpZlzO0VaDrDP9ElGYDw=="],
+
+    "@react-spectrum/slider": ["@react-spectrum/slider@3.9.1", "", { "dependencies": { "@adobe/react-spectrum": "^3.47.0", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-UMBZaaofQsAfH+2SPh2GyxlJjKmRkjVoY1ixybkz8Jh+pOPOFEMugAt3fuLMW22geOC5PXs6AxHYsNb0BwKVnQ=="],
+
+    "@react-spectrum/switch": ["@react-spectrum/switch@3.7.1", "", { "dependencies": { "@adobe/react-spectrum": "^3.47.0", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-71rSqseVrieCWxQpwCBbqY4F6bBo8IK/jM+r8ounN/WIkoMGhZkVigF8tSwd+/p8ym2tmJq6MoWn0he1taBo0Q=="],
+
+    "@react-spectrum/tabs": ["@react-spectrum/tabs@3.9.1", "", { "dependencies": { "@adobe/react-spectrum": "^3.47.0", "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-1r/NiHeyjcHP1CZ7a30PSS5NesARSV1z9fuiKO+rianq/Xyy5bUW5cU+pSNTghNhRCUhQACopkktGzmTCTCCXQ=="],
+
+    "@react-stately/calendar": ["@react-stately/calendar@3.9.3", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@react-stately/utils": "^3.11.0", "@react-types/calendar": "^3.8.3", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-uw7fCZXoypSBBUsVkbNvJMQWTihZReRbyLIGG3o/ZM630N3OCZhb/h4Uxke4pNu7n527H0V1bAnZgAldIzOYqg=="],
+
+    "@react-stately/checkbox": ["@react-stately/checkbox@3.7.5", "", { "dependencies": { "@react-stately/form": "^3.2.4", "@react-stately/utils": "^3.11.0", "@react-types/checkbox": "^3.10.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-K5R5ted7AxLB3sDkuVAazUdyRMraFT1imVqij2GuAiOUFvsZvbuocnDuFkBVKojyV3GpqLBvViV8IaCMc4hNIw=="],
+
+    "@react-stately/collections": ["@react-stately/collections@3.12.10", "", { "dependencies": { "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-wmF9VxJDyBujBuQ76vXj2g/+bnnj8fx5DdXgRmyfkkYhPB46+g2qnjbVGEvipo7bJuGxDftCUC4SN7l7xqUWfg=="],
+
+    "@react-stately/combobox": ["@react-stately/combobox@3.13.0", "", { "dependencies": { "@react-stately/collections": "^3.12.10", "@react-stately/form": "^3.2.4", "@react-stately/list": "^3.13.4", "@react-stately/overlays": "^3.6.23", "@react-stately/utils": "^3.11.0", "@react-types/combobox": "^3.14.0", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-dX9g/cK1hjLRjcbWVF6keHxTQDGhKGB2QAgPhWcBmOK3qJv+2dQqsJ6YCGWn/Y2N2acoEseLrAA7+Qe4HWV9cg=="],
+
+    "@react-stately/datepicker": ["@react-stately/datepicker@3.16.1", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@internationalized/number": "^3.6.5", "@internationalized/string": "^3.2.7", "@react-stately/form": "^3.2.4", "@react-stately/overlays": "^3.6.23", "@react-stately/utils": "^3.11.0", "@react-types/datepicker": "^3.13.5", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-BtAMDvxd1OZxkxjqq5tN5TYmp6Hm8+o3+IDA4qmem2/pfQfVbOZeWS2WitcPBImj4n4T+W1A5+PI7mT/6DUBVg=="],
+
+    "@react-stately/flags": ["@react-stately/flags@3.2.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-WPw9z4SPYqQMuExCnBNrQyyxCWSi9CDYnVqca19bqxaHZRT/uL5nL+IGCPHHa70Y5rx39E5hYKl8Hf0QJ6XKyA=="],
+
+    "@react-stately/form": ["@react-stately/form@3.2.4", "", { "dependencies": { "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-qNBzun8SbLdgahryhKLqL1eqP+MXY6as82sVXYOOvUYLzgU5uuN8mObxYlxJgMI5akSdQJQV3RzyfVobPRE7Kw=="],
+
+    "@react-stately/grid": ["@react-stately/grid@3.12.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-GvOXlPtzoswhyV3bZK3habHdHBGR7qdzOy2WumYiNG7DAj8J+9WvAObrPmquuI2VrZYMSNzgFb3IoL+sQsMI8A=="],
+
+    "@react-stately/list": ["@react-stately/list@3.13.4", "", { "dependencies": { "@react-stately/collections": "^3.12.10", "@react-stately/selection": "^3.20.9", "@react-stately/utils": "^3.11.0", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-HHYSjA9VG7FPSAtpXAjQyM/V7qFHWGg88WmMrDt5QDlTBexwPuH0oFLnW0qaVZpAIxuWIsutZfxRAnme/NhhAA=="],
+
+    "@react-stately/menu": ["@react-stately/menu@3.9.11", "", { "dependencies": { "@react-stately/overlays": "^3.6.23", "@react-types/menu": "^3.10.7", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-vYkpO9uV2OUecsIkrOc+Urdl/s1xw/ibNH/UXsp4PtjMnS6mK9q2kXZTM3WvMAKoh12iveUO+YkYCZQshmFLHQ=="],
+
+    "@react-stately/numberfield": ["@react-stately/numberfield@3.11.0", "", { "dependencies": { "@internationalized/number": "^3.6.5", "@react-stately/form": "^3.2.4", "@react-stately/utils": "^3.11.0", "@react-types/numberfield": "^3.8.18", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-rxfC047vL0LP4tanjinfjKAriAvdVL57Um5RUL5nHML8IOWCB3TBxegQkJ6to6goScC/oZhd0/Y2LSaiRuKbNw=="],
+
+    "@react-stately/overlays": ["@react-stately/overlays@3.6.23", "", { "dependencies": { "@react-stately/utils": "^3.11.0", "@react-types/overlays": "^3.9.4", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-RzWxots9A6gAzQMP4s8hOAHV7SbJRTFSlQbb6ly1nkWQXacOSZSFNGsKOaS0eIatfNPlNnW4NIkgtGws5UYzfw=="],
+
+    "@react-stately/radio": ["@react-stately/radio@3.11.5", "", { "dependencies": { "@react-stately/form": "^3.2.4", "@react-stately/utils": "^3.11.0", "@react-types/radio": "^3.9.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-QxA779S4ea5icQ0ja7CeiNzY1cj7c9G9TN0m7maAIGiTSinZl2Ia8naZJ0XcbRRp+LBll7RFEdekne15TjvS/w=="],
+
+    "@react-stately/selection": ["@react-stately/selection@3.21.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-Tq8UfAOG5SCxnTYivyYQH5NRpiuEJG2k20wmJ/s4Db0FnnjYg1xbKe55vu2A9ni/nUTLKUMj7MFaJytMIXPwxg=="],
+
+    "@react-stately/slider": ["@react-stately/slider@3.7.5", "", { "dependencies": { "@react-stately/utils": "^3.11.0", "@react-types/shared": "^3.33.1", "@react-types/slider": "^3.8.4", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-OrQMNR5xamLYH52TXtvTgyw3EMwv+JI+1istQgEj1CHBjC9eZZqn5iNCN20tzm+uDPTH0EIGULFjjPIumqYUQg=="],
+
+    "@react-stately/table": ["@react-stately/table@3.15.4", "", { "dependencies": { "@react-stately/collections": "^3.12.10", "@react-stately/flags": "^3.1.2", "@react-stately/grid": "^3.11.9", "@react-stately/selection": "^3.20.9", "@react-stately/utils": "^3.11.0", "@react-types/grid": "^3.3.8", "@react-types/shared": "^3.33.1", "@react-types/table": "^3.13.6", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-fGaNyw3wv7JgRCNzgyDzpaaTFuSy5f4Qekch4UheMXDJX7dOeaMhUXeOfvnXCVg+BGM4ey/D82RvDOGvPy1Nww=="],
+
+    "@react-stately/tabs": ["@react-stately/tabs@3.8.9", "", { "dependencies": { "@react-stately/list": "^3.13.4", "@react-types/shared": "^3.33.1", "@react-types/tabs": "^3.3.22", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-AQ4Xrn6YzIolaVShCV9cnwOjBKPAOGP/PTp7wpSEtQbQ0HZzUDG2RG/M4baMeUB2jZ33b7ifXyPcK78o0uOftg=="],
+
+    "@react-stately/toast": ["@react-stately/toast@3.1.3", "", { "dependencies": { "@swc/helpers": "^0.5.0", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-mT9QJKmD523lqFpOp0VWZ6QHZENFK7HrodnNJDVc7g616s5GNmemdlkITV43fSY3tHeThCVvPu+Uzh7RvQ9mpQ=="],
+
+    "@react-stately/toggle": ["@react-stately/toggle@3.9.5", "", { "dependencies": { "@react-stately/utils": "^3.11.0", "@react-types/checkbox": "^3.10.4", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-PVzXc788q3jH98Kvw1LYDL+wpVC14dCEKjOku8cSaqhEof6AJGaLR9yq+EF1yYSL2dxI6z8ghc0OozY8WrcFcA=="],
+
+    "@react-stately/tooltip": ["@react-stately/tooltip@3.5.11", "", { "dependencies": { "@react-stately/overlays": "^3.6.23", "@react-types/tooltip": "^3.5.2", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o8PnFXbvDCuVZ4Ht9ahfS6KHwIZjXopvoQ2vUPxv920irdgWEeC+4omgDOnJ/xFvcpmmJAmSsrQsTQrTguDUQA=="],
+
+    "@react-stately/tree": ["@react-stately/tree@3.9.6", "", { "dependencies": { "@react-stately/collections": "^3.12.10", "@react-stately/selection": "^3.20.9", "@react-stately/utils": "^3.11.0", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-JCuhGyX2A+PAMsx2pRSwArfqNFZJ9JSPkDaOQJS8MFPAsBe5HemvXsdmv9aBIMzlbCYcVq6EsrFnzbVVTBt/6w=="],
+
+    "@react-stately/utils": ["@react-stately/utils@3.11.0", "", { "dependencies": { "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-8LZpYowJ9eZmmYLpudbo/eclIRnbhWIJZ994ncmlKlouNzKohtM8qTC6B1w1pwUbiwGdUoyzLuQbeaIor5Dvcw=="],
+
+    "@react-stately/virtualizer": ["@react-stately/virtualizer@4.4.6", "", { "dependencies": { "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-9SfXgLFB61/8SXNLfg5ARx9jAK4m03Aw6/Cg8mdZN24SYarL4TKNRpfw8K/HHVU/bi6WHSJypk6Z/z19o/ztrg=="],
+
+    "@react-types/accordion": ["@react-types/accordion@3.0.0-alpha.26", "", { "dependencies": { "@react-types/shared": "^3.27.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-OXf/kXcD2vFlEnkcZy/GG+a/1xO9BN7Uh3/5/Ceuj9z2E/WwD55YwU3GFM5zzkZ4+DMkdowHnZX37XnmbyD3Mg=="],
+
+    "@react-types/breadcrumbs": ["@react-types/breadcrumbs@3.7.19", "", { "dependencies": { "@react-types/link": "^3.6.7", "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-AnkyYYmzaM2QFi/N0P/kQLM8tHOyFi7p397B/jEMucXDfwMw5Ny1ObCXeIEqbh8KrIa2Xp8SxmQlCV+8FPs4LA=="],
+
+    "@react-types/button": ["@react-types/button@3.15.1", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-M1HtsKreJkigCnqceuIT22hDJBSStbPimnpmQmsl7SNyqCFY3+DHS7y/Sl3GvqCkzxF7j9UTL0dG38lGQ3K4xQ=="],
+
+    "@react-types/calendar": ["@react-types/calendar@3.8.3", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-fpH6WNXotzH0TlKHXXxtjeLZ7ko0sbyHmwDAwmDFyP7T0Iwn1YQZ+lhceLifvynlxuOgX6oBItyUKmkHQ0FouQ=="],
+
+    "@react-types/checkbox": ["@react-types/checkbox@3.10.4", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-tYCG0Pd1usEz5hjvBEYcqcA0youx930Rss1QBIse9TgMekA1c2WmPDNupYV8phpO8Zuej3DL1WfBeXcgavK8aw=="],
+
+    "@react-types/combobox": ["@react-types/combobox@3.14.0", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-zmSSS7BcCOD8rGT8eGbVy7UlL5qq1vm88fFn4WgFe+lfK33ne+E7yTzTxcPY2TCGSo5fY6xMj3OG79FfVNGbSg=="],
+
+    "@react-types/datepicker": ["@react-types/datepicker@3.13.5", "", { "dependencies": { "@internationalized/date": "^3.12.0", "@react-types/calendar": "^3.8.3", "@react-types/overlays": "^3.9.4", "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-j28Vz+xvbb4bj7+9Xbpc4WTvSitlBvt7YEaEGM/8ZQ5g4Jr85H2KwkmDwjzmMN2r6VMQMMYq9JEcemq5wWpfUQ=="],
+
+    "@react-types/dialog": ["@react-types/dialog@3.6.0", "", { "dependencies": { "@react-aria/dialog": "^3.6.0", "@react-spectrum/dialog": "^3.10.0" }, "peerDependencies": { "@react-spectrum/provider": "^3.0.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-vvxohmsTRZWE/saaJt6mMy3ONA4xbQTSk1okfMUK6OMSp/VpLBRLCz/2/myiMK3UIBCagUnrwzOwbk9whnFx0g=="],
+
+    "@react-types/form": ["@react-types/form@3.7.18", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-0sBJW0+I9nJcF4SmKrYFEWAlehiebSTy7xqriqAXtqfTEdvzAYLGaAK2/7gx+wlNZeDTdW43CDRJ4XAhyhBqnw=="],
+
+    "@react-types/grid": ["@react-types/grid@3.3.8", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-zJvXH8gc1e1VH2H3LRnHH/W2HIkLkZMH3Cu5pLcj0vDuLBSWpcr3Ikh3jZ+VUOZF0G1Jt1lO8pKIaqFzDLNmLQ=="],
+
+    "@react-types/link": ["@react-types/link@3.6.7", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-1apXCFJgMC1uydc2KNENrps1qR642FqDpwlNWe254UTpRZn/hEZhA6ImVr8WhomfLJu672WyWA0rUOv4HT+/pQ=="],
+
+    "@react-types/listbox": ["@react-types/listbox@3.8.0", "", { "dependencies": { "@react-aria/listbox": "^3.16.0", "@react-spectrum/listbox": "^3.16.0" }, "peerDependencies": { "@react-spectrum/provider": "^3.0.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-6l/P1mYQUQ7hGW6x8cH/EB8YvRzhhoB536G/GI7t2F2FbjcGkA1kNXhzDo24tLTXi9elnehevEEySRsRa9p6VA=="],
+
+    "@react-types/menu": ["@react-types/menu@3.10.7", "", { "dependencies": { "@react-types/overlays": "^3.9.4", "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-+p7ixZdvPDJZhisqdtWiiuJ9pteNfK5i19NB6wzAw5XkljbEzodNhwLv6rI96DY5XpbFso2kcjw7IWi+rAAGGQ=="],
+
+    "@react-types/numberfield": ["@react-types/numberfield@3.8.18", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-nLzk7YAG9yAUtSv+9R8LgCHsu8hJq8/A+m1KsKxvc8WmNJjIujSFgWvT21MWBiUgPBzJKGzAqpMDDa087mltJQ=="],
+
+    "@react-types/overlays": ["@react-types/overlays@3.9.4", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-7Z9HaebMFyYBqtv3XVNHEmVkm7AiYviV7gv0c98elEN2Co+eQcKFGvwBM9Gy/lV57zlTqFX1EX/SAqkMEbCLOA=="],
+
+    "@react-types/progress": ["@react-types/progress@3.5.18", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-mKeQn+KrHr1y0/k7KtrbeDGDaERH6i4f6yBwj/ZtYDCTNKMO3tPHJY6nzF0w/KKZLplIO+BjUbHXc2RVm8ovwQ=="],
+
+    "@react-types/radio": ["@react-types/radio@3.9.4", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-TkMRY3sA1PcFZhhclu4IUzUTIir6MzNJj8h6WT8vO6Nug2kXJ72qigugVFBWJSE472mltduOErEAo0rtAYWbQA=="],
+
+    "@react-types/shared": ["@react-types/shared@3.33.1", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-oJHtjvLG43VjwemQDadlR5g/8VepK56B/xKO2XORPHt9zlW6IZs3tZrYlvH29BMvoqC7RtE7E5UjgbnbFtDGag=="],
+
+    "@react-types/slider": ["@react-types/slider@3.9.0", "", { "dependencies": { "@react-aria/slider": "^3.9.0", "@react-spectrum/slider": "^3.9.0", "@react-stately/slider": "^3.8.0" }, "peerDependencies": { "@react-spectrum/provider": "^3.0.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-gbQWB8LnucC+jhDi5Imd2ZDPbVuiHt0xzObGHWq6GTZ3slLgTvGQaHNO5h9+h7dZH0iFQOVNb6+TlyTsnjFuAw=="],
+
+    "@react-types/switch": ["@react-types/switch@3.6.0", "", { "dependencies": { "@react-aria/switch": "^3.8.0", "@react-spectrum/switch": "^3.7.0" }, "peerDependencies": { "@react-spectrum/provider": "^3.0.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-6pjDO5a35ovAAw5xsSJoftmUP1BhFzKazB5IuVBNTbeEvJjz/LC1NGkVV3sQX68ZDSZ0UyYLS7ENIVHKU+hjzA=="],
+
+    "@react-types/table": ["@react-types/table@3.13.6", "", { "dependencies": { "@react-types/grid": "^3.3.8", "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-eluL+iFfnVmFm7OSZrrFG9AUjw+tcv898zbv+NsZACa8oXG1v9AimhZfd+Mo8q/5+sX/9hguWNXFkSvmTjuVPQ=="],
+
+    "@react-types/tabs": ["@react-types/tabs@3.4.0", "", { "dependencies": { "@react-aria/tabs": "^3.12.0", "@react-spectrum/tabs": "^3.9.0", "@react-stately/tabs": "^3.9.0" }, "peerDependencies": { "@react-spectrum/provider": "^3.0.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-/o2gmSKK9MmXCVL9vs+YYU1fl+u3+p07nbl2KXk0aL0UhVfgev3pKpFMjsWBiF9kUGp3EnVNjEDr8ZlSMIgZqQ=="],
+
+    "@react-types/textfield": ["@react-types/textfield@3.12.8", "", { "dependencies": { "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-wt6FcuE5AyntxsnPika/h3nf/DPmeAVbI018L9o6h+B/IL4sMWWdx663wx2KOOeHH8ejKGZQNPLhUKs4s1mVQA=="],
+
+    "@react-types/tooltip": ["@react-types/tooltip@3.5.2", "", { "dependencies": { "@react-types/overlays": "^3.9.4", "@react-types/shared": "^3.33.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-FvSuZ2WP08NEWefrpCdBYpEEZh/5TvqvGjq0wqGzWg2OPwpc14HjD8aE7I3MOuylXkD4MSlMjl7J4DlvlcCs3Q=="],
+
+    "@rive-app/react-webgl2": ["@rive-app/react-webgl2@4.29.4", "", { "dependencies": { "@rive-app/webgl2": "2.38.4" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0" } }, "sha512-eYGfsgwHnl1br8HbqoL34HbnH0TODEZuxmHYFhe32OTOwaOYI6ACifao/1dIFW/yUg+Jtt9CIIM8Scg+x+0cCQ=="],
+
+    "@rive-app/webgl2": ["@rive-app/webgl2@2.38.4", "", {}, "sha512-/DitPRRNRHWgg6jB28dsH8vZyNHU2dorcOARCVkeEVGwSp/fthng+wwdtqUj/EnarnWKRVI3kr0lFjWorq85PQ=="],
+
+    "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.1.4", "", { "os": "android", "cpu": "arm64" }, "sha512-EZLpf/8y7GXkkra90ML47kzik/GMP3EMcE9bPyHmRfxLC6z9+aW5A8poCsoxjrT5GfEcNAAvWwUHjvP1pUQkfw=="],
+
+    "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.1.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-aUi+HBvmYb7j8krl1+qJgkG8C17fO79gk3c+jPw4S8glRFc1DTija9S3EyaTSQUm5GJXYKDAsugBEhFHH2vYiQ=="],
+
+    "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.1.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-F7hHC3gwY11+vByKPRWqwGbeXWVgKmL+pTGCinaEhdihzBV2aQ0fvZOch9cXYUOKuKKq429HeYXOqQLc7wFCEg=="],
+
+    "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.1.4", "", { "os": "freebsd", "cpu": "x64" }, "sha512-sI5yw+7s92SK6odiEhD5lKCBlWcpjHS5qyqpVQbZAJ0fIzEUXrmbl3DH2ybR3PZogulNJF+COLtmA8hUfvkCCQ=="],
+
+    "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.1.4", "", { "os": "linux", "cpu": "arm" }, "sha512-mCi0OKgEieFircrtVYmQAFGszRtMnZ6fpZAXrxanXAu7lqZcsK1E1RAaZNG0uKAnxox3B1f4EyQNnoyMfN1vAA=="],
+
+    "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.1.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-B9Ial3Kv5sh0SHnB1g/QWcUQCEvCF6QKGAl4zXypYj65mVI+B4AhFBwPtSN7pDrJeIx8Z7zdy4ntx+wQABom7w=="],
+
+    "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.1.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-lZVym0PuHE1KZ22gmFTC15lAkrg9iTszR617oYRB/iPY1A56ywoJzVKOJBKaot5RiikCObmur6pogpse3gRcng=="],
+
+    "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.1.4", "", { "os": "linux", "cpu": "ppc64" }, "sha512-t2DNiLJWNTbnEHyUzTumldML6ET4/g16467LZoDDJ3tSxGvguL5/NyC2lCsNKuyRycg9XeDQF5SSv+TNOhQEXg=="],
+
+    "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.1.4", "", { "os": "linux", "cpu": "s390x" }, "sha512-0WIRnL1Uw4BvTZRLQt+PVgo6ZKTJadlC2btP+/EOXv2f/DWbY0rEgl+y834mIVwP1FkTlWVTrGGJXf12lru7EQ=="],
+
+    "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.1.4", "", { "os": "linux", "cpu": "x64" }, "sha512-JWtGshGfX+oENAKonoNkqEJX+7hC8yfhi9GUyPX1VX4mdh1y5r+ZiJLR5XzAB0aoP6s/PcILsGjKq8O0mm24bw=="],
+
+    "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.1.4", "", { "os": "linux", "cpu": "x64" }, "sha512-rT6yQcxUuXs4CnbofqwHRRV0iem349rLMYpTjkgQGLjrY4ado/eDzwPZPTCgTOlF6Nkp8NEv70yLMTn6qkWxsQ=="],
+
+    "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.1.4", "", { "os": "none", "cpu": "arm64" }, "sha512-KXMGoboq5cyaCQjDA4GLuRiOwBQ0EyFnJoVViLeZ45/3rFItRODEr+NdsBcVpll40hhNArlm/speWGRvj08LzA=="],
+
+    "@rolldown/binding-wasm32-wasi": ["@rolldown/binding-wasm32-wasi@1.1.4", "", { "dependencies": { "@emnapi/core": "1.11.1", "@emnapi/runtime": "1.11.1", "@napi-rs/wasm-runtime": "^1.1.6" }, "cpu": "none" }, "sha512-5K83rb36oJiY7BCyE9zLZtGcPV4g5wvq+xwdO0XPIwDVZI8cyB/AUjkNXGb92/rnmezEkjMOpgY61rtwjQtFwg=="],
+
+    "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.1.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-PnWBtw3TV5KOg69HQQDR0mnQuyCmSGR2pAB4DC1rPF808fgKeTUMj2EOEyKATpgiuxuR5APQmiDO7PDgEjTFSA=="],
+
+    "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.1.4", "", { "os": "win32", "cpu": "x64" }, "sha512-M1lpniBePobTfsa7Ks9a199e1akxsXn+GYBUKsEzv3YFzOm1HJAMNwKI3qr0Zq+mxwx9gOZoTdP1yXRYsZUocQ=="],
+
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="],
+
+    "@rollup/pluginutils": ["@rollup/pluginutils@5.4.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.62.2", "", { "os": "android", "cpu": "arm" }, "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.62.2", "", { "os": "android", "cpu": "arm64" }, "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.62.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.62.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.62.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.62.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.62.2", "", { "os": "linux", "cpu": "arm" }, "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.62.2", "", { "os": "linux", "cpu": "arm" }, "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.62.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.62.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg=="],
+
+    "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.62.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A=="],
+
+    "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.62.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.62.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.62.2", "", { "os": "linux", "cpu": "x64" }, "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.62.2", "", { "os": "linux", "cpu": "x64" }, "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg=="],
+
+    "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.62.2", "", { "os": "openbsd", "cpu": "x64" }, "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.62.2", "", { "os": "none", "cpu": "arm64" }, "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.62.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.62.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.62.2", "", { "os": "win32", "cpu": "x64" }, "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.62.2", "", { "os": "win32", "cpu": "x64" }, "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA=="],
+
+    "@sap-ai-sdk/ai-api": ["@sap-ai-sdk/ai-api@2.12.0", "", { "dependencies": { "@sap-ai-sdk/core": "^2.12.0", "@sap-cloud-sdk/connectivity": "^4.7.0", "@sap-cloud-sdk/util": "^4.7.0" } }, "sha512-eIN3VS7W8gDZ1yn+B59QHGs11yLE24Ux6+zLqza3zWd4X2efFfKs4Ut95BoDRfSQOUcSofZTPzRfI7mxjrv+Fg=="],
+
+    "@sap-ai-sdk/core": ["@sap-ai-sdk/core@2.12.0", "", { "dependencies": { "@sap-cloud-sdk/connectivity": "^4.7.0", "@sap-cloud-sdk/http-client": "^4.7.0", "@sap-cloud-sdk/openapi": "^4.7.0", "@sap-cloud-sdk/util": "^4.7.0" } }, "sha512-hPCRVCBQkBXlxY+6y6H43ZTgkw9kbpd/aUyKbZz+avBkuvug4QXRHDgVslwxl6r+ejM4bg6ivTN4rDiWpB4Cag=="],
+
+    "@sap-ai-sdk/foundation-models": ["@sap-ai-sdk/foundation-models@2.12.0", "", { "dependencies": { "@sap-ai-sdk/ai-api": "^2.12.0", "@sap-ai-sdk/core": "^2.12.0", "@sap-cloud-sdk/connectivity": "^4.7.0", "@sap-cloud-sdk/http-client": "^4.7.0", "@sap-cloud-sdk/util": "^4.7.0" } }, "sha512-9hMo4k2QQiVzzQ7CJvlsHo4yT/NUFviir+X0Pj7EmQvmExqVUufF31uSA4LPU7+zkx0no/oIY23l0EQCIVRxgA=="],
+
+    "@sap-ai-sdk/orchestration": ["@sap-ai-sdk/orchestration@2.12.0", "", { "dependencies": { "@sap-ai-sdk/ai-api": "^2.12.0", "@sap-ai-sdk/core": "^2.12.0", "@sap-ai-sdk/prompt-registry": "^2.12.0", "@sap-cloud-sdk/util": "^4.7.0", "yaml": "^2.9.0" } }, "sha512-8bteUuX+4uN4KzKllpBy4UkslTTk78DMo86v+Ohs3/HgQCw5lKqVWh0VH+NR9iQz+LOcLUPYi9EhuFEDIveNBg=="],
+
+    "@sap-ai-sdk/prompt-registry": ["@sap-ai-sdk/prompt-registry@2.12.0", "", { "dependencies": { "@sap-ai-sdk/core": "^2.12.0", "zod": "^4.4.3" } }, "sha512-V9u9S91MchX2d246+Jv7ryMR6yy1F35MZpu033czvhpz35CnJlrksTRoarGXcVlpW8q65ru5Oh8QryVZDi6RgA=="],
+
+    "@sap-cloud-sdk/connectivity": ["@sap-cloud-sdk/connectivity@4.6.0", "", { "dependencies": { "@sap-cloud-sdk/resilience": "^4.6.0", "@sap-cloud-sdk/util": "^4.6.0", "@sap/xsenv": "^6.1.0", "@sap/xssec": "^4.13.0", "async-retry": "^1.3.3", "axios": "^1.15.0", "jks-js": "^1.1.6", "jsonwebtoken": "^9.0.3" } }, "sha512-Pf+0O1s4eDNR/MZ+UcyOyPa/U8dl3xUHEbjY+BG7DHZtLZFYVfKg2dV63ZTzeHypqMRVQePCN8yIyIz296FWHg=="],
+
+    "@sap-cloud-sdk/http-client": ["@sap-cloud-sdk/http-client@4.6.0", "", { "dependencies": { "@sap-cloud-sdk/connectivity": "^4.6.0", "@sap-cloud-sdk/resilience": "^4.6.0", "@sap-cloud-sdk/util": "^4.6.0", "axios": "^1.15.0" } }, "sha512-fBaJAnOsHGyIlRS4HA2XYxp9v3GjUWPACoGDRg01jjoq49r3KjIMi8FqycMwKTF9QnkX/4rlPtj2wnziHgG2bg=="],
+
+    "@sap-cloud-sdk/openapi": ["@sap-cloud-sdk/openapi@4.6.0", "", { "dependencies": { "@sap-cloud-sdk/connectivity": "^4.6.0", "@sap-cloud-sdk/http-client": "^4.6.0", "@sap-cloud-sdk/resilience": "^4.6.0", "@sap-cloud-sdk/util": "^4.6.0", "axios": "^1.15.0" } }, "sha512-If5eD5DWUA7nXUUvMYuG3p8+JjSR2+DZPnE88YdDR7+kIbblDuV2c4QbyjpT0oeA2sQ3S9iZVx8cZP8n5dmdHQ=="],
+
+    "@sap-cloud-sdk/resilience": ["@sap-cloud-sdk/resilience@4.6.0", "", { "dependencies": { "@sap-cloud-sdk/util": "^4.6.0", "async-retry": "^1.3.3", "axios": "^1.15.0", "opossum": "^9.0.0" } }, "sha512-NMY683lNvJcE5dghVqUsBLM/voTLE6MMn5OmmB5BkG8qp5TZSuy/lhMZCVfGpBVnRLv6k19vWiBcueXxYg8bcQ=="],
+
+    "@sap-cloud-sdk/util": ["@sap-cloud-sdk/util@4.6.0", "", { "dependencies": { "axios": "^1.15.0", "logform": "^2.7.0", "voca": "^1.4.1", "winston": "^3.19.0", "winston-transport": "^4.9.0" } }, "sha512-z1gFjgzhAUhzPy1IkwWjfOrnPHh9KrEZbLlFBG5LbL3oBS3JMmKusW0162Hq4r+AVTR43akEoHxk07p247YQTw=="],
+
+    "@sap/xsenv": ["@sap/xsenv@6.2.1", "", { "dependencies": { "debug": "4.4.3", "node-cache": "^5.1.2", "verror": "1.10.1" } }, "sha512-R1p7VdD3N3jvdkL8av4vLqF+cTQihTz9mCqqF+oa9rVZvgLaCb4ODyZ1dln5/fBgg1OSuch0ESxu3AqZrXVknw=="],
+
+    "@sap/xssec": ["@sap/xssec@4.13.1", "", { "dependencies": { "debug": "^4.4.3", "jwt-decode": "^4" } }, "sha512-sZwTvxO7Vh5qjrSXHgb0fTJEPz14kYPzScn4GI5kZYGb97fZ4X5IE90mlafjZeJFfQkBCCIzVWfrbweCpBbPyQ=="],
+
+    "@sapphire/async-queue": ["@sapphire/async-queue@1.5.5", "", {}, "sha512-cvGzxbba6sav2zZkH8GPf2oGk9yYoD5qrNWdu9fRehifgnFZJMV+nuy2nON2roRO4yQQ+v7MK/Pktl/HgfsUXg=="],
+
+    "@sapphire/shapeshift": ["@sapphire/shapeshift@4.0.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "lodash": "^4.17.21" } }, "sha512-d9dUmWVA7MMiKobL3VpLF8P2aeanRTu6ypG2OIaEv/ZHH/SUQ2iHOVyi5wAPjQ+HmnMuL0whK9ez8I/raWbtIg=="],
+
+    "@sapphire/snowflake": ["@sapphire/snowflake@3.5.3", "", {}, "sha512-jjmJywLAFoWeBi1W7994zZyiNWPIiqRRNAmSERxyg93xRGzNYvGjlZ0gR6x0F4gPRi2+0O6S71kOZYyr3cxaIQ=="],
+
+    "@sec-ant/readable-stream": ["@sec-ant/readable-stream@0.4.1", "", {}, "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg=="],
+
+    "@secretlint/config-creator": ["@secretlint/config-creator@10.2.2", "", { "dependencies": { "@secretlint/types": "^10.2.2" } }, "sha512-BynOBe7Hn3LJjb3CqCHZjeNB09s/vgf0baBaHVw67w7gHF0d25c3ZsZ5+vv8TgwSchRdUCRrbbcq5i2B1fJ2QQ=="],
+
+    "@secretlint/config-loader": ["@secretlint/config-loader@10.2.2", "", { "dependencies": { "@secretlint/profiler": "^10.2.2", "@secretlint/resolver": "^10.2.2", "@secretlint/types": "^10.2.2", "ajv": "^8.17.1", "debug": "^4.4.1", "rc-config-loader": "^4.1.3" } }, "sha512-ndjjQNgLg4DIcMJp4iaRD6xb9ijWQZVbd9694Ol2IszBIbGPPkwZHzJYKICbTBmh6AH/pLr0CiCaWdGJU7RbpQ=="],
+
+    "@secretlint/core": ["@secretlint/core@10.2.2", "", { "dependencies": { "@secretlint/profiler": "^10.2.2", "@secretlint/types": "^10.2.2", "debug": "^4.4.1", "structured-source": "^4.0.0" } }, "sha512-6rdwBwLP9+TO3rRjMVW1tX+lQeo5gBbxl1I5F8nh8bgGtKwdlCMhMKsBWzWg1ostxx/tIG7OjZI0/BxsP8bUgw=="],
+
+    "@secretlint/formatter": ["@secretlint/formatter@10.2.2", "", { "dependencies": { "@secretlint/resolver": "^10.2.2", "@secretlint/types": "^10.2.2", "@textlint/linter-formatter": "^15.2.0", "@textlint/module-interop": "^15.2.0", "@textlint/types": "^15.2.0", "chalk": "^5.4.1", "debug": "^4.4.1", "pluralize": "^8.0.0", "strip-ansi": "^7.1.0", "table": "^6.9.0", "terminal-link": "^4.0.0" } }, "sha512-10f/eKV+8YdGKNQmoDUD1QnYL7TzhI2kzyx95vsJKbEa8akzLAR5ZrWIZ3LbcMmBLzxlSQMMccRmi05yDQ5YDA=="],
+
+    "@secretlint/node": ["@secretlint/node@10.2.2", "", { "dependencies": { "@secretlint/config-loader": "^10.2.2", "@secretlint/core": "^10.2.2", "@secretlint/formatter": "^10.2.2", "@secretlint/profiler": "^10.2.2", "@secretlint/source-creator": "^10.2.2", "@secretlint/types": "^10.2.2", "debug": "^4.4.1", "p-map": "^7.0.3" } }, "sha512-eZGJQgcg/3WRBwX1bRnss7RmHHK/YlP/l7zOQsrjexYt6l+JJa5YhUmHbuGXS94yW0++3YkEJp0kQGYhiw1DMQ=="],
+
+    "@secretlint/profiler": ["@secretlint/profiler@10.2.2", "", {}, "sha512-qm9rWfkh/o8OvzMIfY8a5bCmgIniSpltbVlUVl983zDG1bUuQNd1/5lUEeWx5o/WJ99bXxS7yNI4/KIXfHexig=="],
+
+    "@secretlint/resolver": ["@secretlint/resolver@10.2.2", "", {}, "sha512-3md0cp12e+Ae5V+crPQYGd6aaO7ahw95s28OlULGyclyyUtf861UoRGS2prnUrKh7MZb23kdDOyGCYb9br5e4w=="],
+
+    "@secretlint/secretlint-formatter-sarif": ["@secretlint/secretlint-formatter-sarif@10.2.2", "", { "dependencies": { "node-sarif-builder": "^3.2.0" } }, "sha512-ojiF9TGRKJJw308DnYBucHxkpNovDNu1XvPh7IfUp0A12gzTtxuWDqdpuVezL7/IP8Ua7mp5/VkDMN9OLp1doQ=="],
+
+    "@secretlint/secretlint-rule-no-dotenv": ["@secretlint/secretlint-rule-no-dotenv@10.2.2", "", { "dependencies": { "@secretlint/types": "^10.2.2" } }, "sha512-KJRbIShA9DVc5Va3yArtJ6QDzGjg3PRa1uYp9As4RsyKtKSSZjI64jVca57FZ8gbuk4em0/0Jq+uy6485wxIdg=="],
+
+    "@secretlint/secretlint-rule-preset-recommend": ["@secretlint/secretlint-rule-preset-recommend@10.2.2", "", {}, "sha512-K3jPqjva8bQndDKJqctnGfwuAxU2n9XNCPtbXVI5JvC7FnQiNg/yWlQPbMUlBXtBoBGFYp08A94m6fvtc9v+zA=="],
+
+    "@secretlint/source-creator": ["@secretlint/source-creator@10.2.2", "", { "dependencies": { "@secretlint/types": "^10.2.2", "istextorbinary": "^9.5.0" } }, "sha512-h6I87xJfwfUTgQ7irWq7UTdq/Bm1RuQ/fYhA3dtTIAop5BwSFmZyrchph4WcoEvbN460BWKmk4RYSvPElIIvxw=="],
+
+    "@secretlint/types": ["@secretlint/types@10.2.2", "", {}, "sha512-Nqc90v4lWCXyakD6xNyNACBJNJ0tNCwj2WNk/7ivyacYHxiITVgmLUFXTBOeCdy79iz6HtN9Y31uw/jbLrdOAg=="],
+
+    "@shikijs/core": ["@shikijs/core@4.3.0", "", { "dependencies": { "@shikijs/primitive": "4.3.0", "@shikijs/types": "4.3.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.5" } }, "sha512-EooU3i9F6IAE8kEu+AnGf9DFZWkQBZ+hJn3tLVbsH+61mtQiva5biai66fAA6nvFPXkLgvrh7BrR7YcJU83xQQ=="],
+
+    "@shikijs/engine-javascript": ["@shikijs/engine-javascript@4.3.0", "", { "dependencies": { "@shikijs/types": "4.3.0", "@shikijs/vscode-textmate": "^10.0.2", "oniguruma-to-es": "^4.3.6" } }, "sha512-hTv/KiFf2tpiqlACPiztGGurEARWIutB8YUhcrA1pUC7VzzwKO+g5crUocrLztrZ5ro5Z4hbXg7bYclETn3gSQ=="],
+
+    "@shikijs/engine-oniguruma": ["@shikijs/engine-oniguruma@4.3.0", "", { "dependencies": { "@shikijs/types": "4.3.0", "@shikijs/vscode-textmate": "^10.0.2" } }, "sha512-1vMdN3gHfnKfLYwecUI2ITJI4RhHt96xEaJumVn7Heb0IlJ8WQMIH0Voak+2j22BpSNKdnOfB/pCTPnPm2gq7A=="],
+
+    "@shikijs/langs": ["@shikijs/langs@4.3.0", "", { "dependencies": { "@shikijs/types": "4.3.0" } }, "sha512-rnlqFbBRSys9bT4gl/5rw9RnS0W/I84ZldXPkO7cvlEMoV85TyF/aU01N7/NbSR776RNLjrJKjfFUXJR6wN1Cg=="],
+
+    "@shikijs/primitive": ["@shikijs/primitive@4.3.0", "", { "dependencies": { "@shikijs/types": "4.3.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-CPkz64PTa5diRW1ggzMZH9VM/du4RNChYgVtgqrFcgruvIybmCvySv8GkiHSczUHXYuuR8TdKEwFx+UnZMpgdg=="],
+
+    "@shikijs/themes": ["@shikijs/themes@4.3.0", "", { "dependencies": { "@shikijs/types": "4.3.0" } }, "sha512-Avgt05YiT+Y3prjIc9lmQxhJzHBcCfR6cjiFW4OyaMBbt2A6trX5rfjUzx+Vj/mE9qpArYjatnqo9XPjQNW/AQ=="],
+
+    "@shikijs/types": ["@shikijs/types@4.3.0", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-oc8b9U2SYvofKZk8e/737nIX0qwf6eV2vHFATeObAu7r+mUVpLs8Re0BmVkIjAWAYgkmG/CzLNo7rzuBzRu/wQ=="],
+
+    "@shikijs/vscode-textmate": ["@shikijs/vscode-textmate@10.0.2", "", {}, "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg=="],
+
+    "@simple-git/args-pathspec": ["@simple-git/args-pathspec@1.0.3", "", {}, "sha512-ngJMaHlsWDTfjyq9F3VIQ8b7NXbBLq5j9i5bJ6XLYtD6qlDXT7fdKY2KscWWUF8t18xx052Y/PUO1K1TRc9yKA=="],
+
+    "@simple-git/argv-parser": ["@simple-git/argv-parser@1.1.1", "", { "dependencies": { "@simple-git/args-pathspec": "^1.0.3" } }, "sha512-Q9lBcfQ+VQCpQqGJFHe5yooOS5hGdLFFbJ5R+R5aDsnkPCahtn1hSkMcORX65J2Z5lxSkD0lQorMsncuBQxYUw=="],
+
+    "@sinclair/typebox": ["@sinclair/typebox@0.34.49", "", {}, "sha512-brySQQs7Jtn0joV8Xh9ZV/hZb9Ozb0pmazDIASBkYKCjXrXU3mpcFahmK/z4YDhGkQvP9mWJbVyahdtU5wQA+A=="],
+
+    "@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@4.0.0", "", {}, "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ=="],
+
+    "@sinonjs/commons": ["@sinonjs/commons@3.0.1", "", { "dependencies": { "type-detect": "4.0.8" } }, "sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ=="],
+
+    "@sinonjs/fake-timers": ["@sinonjs/fake-timers@15.4.0", "", { "dependencies": { "@sinonjs/commons": "^3.0.1" } }, "sha512-DsG+8/LscQIQg68J6Ef3dv10u6nVyetYn923s3/sus5eaGfTo1of5WMZSLf0UJc9KDuKPilPH0UDJCjvNbDNCA=="],
+
+    "@sinonjs/samsam": ["@sinonjs/samsam@10.0.2", "", { "dependencies": { "@sinonjs/commons": "^3.0.1", "type-detect": "^4.1.0" } }, "sha512-8lVwD1Df1BmzoaOLhMcGGcz/Jyr5QY2KSB75/YK1QgKzoabTeLdIVyhXNZK9ojfSKSdirbXqdbsXXqP9/Ve8+A=="],
+
+    "@slack/logger": ["@slack/logger@4.0.1", "", { "dependencies": { "@types/node": ">=18" } }, "sha512-6cmdPrV/RYfd2U0mDGiMK8S7OJqpCTm7enMLRR3edccsPX8j7zXTLnaEF4fhxxJJTAIOil6+qZrnUPTuaLvwrQ=="],
+
+    "@slack/socket-mode": ["@slack/socket-mode@2.0.7", "", { "dependencies": { "@slack/logger": "^4.0.1", "@slack/web-api": "^7.15.0", "@types/node": ">=18", "@types/ws": "^8", "eventemitter3": "^5", "ws": "^8" } }, "sha512-qYy07je71WnEHgRwmw12DlAnZLi5HXmdlI2WUzUK2LH/rYXQpP6uEg462S5CwfE8FoCKUdIigHtYnOOfzZH1lQ=="],
+
+    "@slack/types": ["@slack/types@2.21.1", "", {}, "sha512-I8vmSjNYWsaxuWPx6dz4yeh0h7vRBWbgAMK14LEmblbZ404BtrPbXs6jDPx4cYgGf8msDGF4A9opLZBu21FViQ=="],
+
+    "@slack/web-api": ["@slack/web-api@7.18.0", "", { "dependencies": { "@slack/logger": "^4.0.1", "@slack/types": "^2.21.0", "@types/node": ">=18", "@types/retry": "0.12.0", "axios": "^1.16.0", "eventemitter3": "^5.0.1", "form-data": "^4.0.4", "is-electron": "2.2.2", "is-stream": "^2", "p-queue": "^6", "p-retry": "^4", "retry": "^0.13.1" } }, "sha512-EWBsKUhOFFp87beQg/ToSC+asWB7BrGHuh7uPC1ZI9vr41GjS+3WmmyWIMqs+mF6U+mh4d6HhtFlv67TrJFsvw=="],
+
+    "@smithy/core": ["@smithy/core@3.29.0", "", { "dependencies": { "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-sEvpvkBVoMxjoek35XyJFn2ZD3EJ1RpiZrT47WaZodxzAIWS44zkdvbqGE/ZlugtjiQp62cffYZ9ldyRkjAGnA=="],
+
+    "@smithy/credential-provider-imds": ["@smithy/credential-provider-imds@4.4.5", "", { "dependencies": { "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-LnjUTNG0GgQlKIq7IioeOrPaEmC5xOd1WtAz24TLSiYQnWX2uHr53GrFuQhkrJBktPYCMga/NbUOW7hFbSA2Cg=="],
+
+    "@smithy/eventstream-codec": ["@smithy/eventstream-codec@4.4.5", "", { "dependencies": { "@smithy/core": "^3.29.0", "tslib": "^2.6.2" } }, "sha512-rasV+96Obv6tEhWPKWaehEhR+MEd2/lE/rdOYcmSMh6tJiQdoZg4v21p37Y1A7DMZOFgFDUX/3eNl/J3+MJDdA=="],
+
+    "@smithy/fetch-http-handler": ["@smithy/fetch-http-handler@5.6.2", "", { "dependencies": { "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-q96PSDOAGw+X+nuELd7Cjebps0SYr+YlPbviEX9sLVw+VM4M7VV8hn1nL1mGS6urDu33eQ5A7WhlphaDO6kUyQ=="],
+
+    "@smithy/node-http-handler": ["@smithy/node-http-handler@4.9.2", "", { "dependencies": { "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-s0yAIRj6TVfHgl+QzVyqal1KMGZ9B5512IrxKc6+dOpw8fUmFL3CvuAhjv0J+aNjUPfVZ2IhqPEDvkB5Ncx9oA=="],
+
+    "@smithy/signature-v4": ["@smithy/signature-v4@5.6.1", "", { "dependencies": { "@smithy/core": "^3.29.0", "@smithy/types": "^4.15.1", "tslib": "^2.6.2" } }, "sha512-SqvuP75p/DmgWWI7jv4kf/UW+V4LFmlUn19s604SgAcRuJRB1vDnWwzZMYCLUcmKxko9wDn6iLgGEIpTNgZbIQ=="],
+
+    "@smithy/types": ["@smithy/types@4.15.1", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-x3L0XSACF6UYzKpa9biqiRMgvH5+wnFFew9Tm/grFYqgaupPwx/+ojDPpPJM8dZON3S9tjz5U+PQYsCBd1Mw5Q=="],
+
+    "@smithy/util-utf8": ["@smithy/util-utf8@4.4.5", "", { "dependencies": { "@smithy/core": "^3.29.0", "tslib": "^2.6.2" } }, "sha512-ZS7Y5X8mU9qRSsqwOeGKw86WWtPsRxa396kX2HyhYwADRqFHJ0cb3p2uFk6QnFF3BluUUBHTZJpPA9QuEl0tlg=="],
+
+    "@so-ric/colorspace": ["@so-ric/colorspace@1.1.6", "", { "dependencies": { "color": "^5.0.2", "text-hex": "1.0.x" } }, "sha512-/KiKkpHNOBgkFJwu9sh48LkHSMYGyuTcSFK/qMBdnOAlrRJzRSXAOFB5qwzaVQuDl8wAvHVMkaASQDReTahxuw=="],
+
+    "@spectrum-icons/ui": ["@spectrum-icons/ui@3.7.1", "", { "dependencies": { "@adobe/react-spectrum-ui": "1.2.1", "@babel/runtime": "^7.24.4", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "@adobe/react-spectrum": "^3.47.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-veQymocUYo5OciXQajSailOdbWe+k6+2ehfF8D4d0V923D4xOUadtT253xXZ5vEQjPat6Kyp2WDKeQNjd7kL1w=="],
+
+    "@spectrum-icons/workflow": ["@spectrum-icons/workflow@4.3.1", "", { "dependencies": { "@adobe/react-spectrum-workflow": "2.3.5", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "@adobe/react-spectrum": "^3.47.0", "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-kDF+/EbFVyLGytotqqdYt4uSij4j/PQmDQO5km/C6DyzKjyuic3FnSBFinR+mA6oFv1OjMcLvrrDBqK3wbqRlA=="],
+
+    "@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
+
+    "@storybook/builder-vite": ["@storybook/builder-vite@9.1.20", "", { "dependencies": { "@storybook/csf-plugin": "9.1.20", "ts-dedent": "^2.0.0" }, "peerDependencies": { "storybook": "^9.1.20", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-cdU3Q2/wEaT8h+mApFToRiF/0hYKH1eAkD0scQn67aODgp7xnkr0YHcdA+8w0Uxd2V7U8crV/cmT/HD0ELVOGw=="],
+
+    "@storybook/csf-plugin": ["@storybook/csf-plugin@9.1.20", "", { "dependencies": { "unplugin": "^1.3.1" }, "peerDependencies": { "storybook": "^9.1.20" } }, "sha512-HHgk50YQhML7mT01Mzf9N7lNMFHWN4HwwRP90kPT9Ct+Jhx7h3LBDbdmWjI96HwujcpY7eoYdTfpB1Sw8Z7nBQ=="],
+
+    "@storybook/global": ["@storybook/global@5.0.0", "", {}, "sha512-FcOqPAXACP0I3oJ/ws6/rrPT9WGhu915Cg8D02a9YxLo0DE9zI+a9A5gRGvmQ09fiWPukqI8ZAEoQEdWUKMQdQ=="],
+
+    "@storybook/react": ["@storybook/react@9.1.20", "", { "dependencies": { "@storybook/global": "^5.0.0", "@storybook/react-dom-shim": "9.1.20" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-beta", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-beta", "storybook": "^9.1.20", "typescript": ">= 4.9.x" }, "optionalPeers": ["typescript"] }, "sha512-TJhqzggs7HCvLhTXKfx8HodnVq9YizsB2J31s9v6olU0UCxbCY+FYaCF+XdE8qUCyefGRZgHKzGBIczJ/q9e2g=="],
+
+    "@storybook/react-dom-shim": ["@storybook/react-dom-shim@9.1.20", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-beta", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-beta", "storybook": "^9.1.20" } }, "sha512-UYdZavfPwHEqCKMqPssUOlyFVZiJExLxnSHwkICSZBmw3gxXJcp1aXWs7PvoZdWz2K4ztl3IcKErXXHeiY6w+A=="],
+
+    "@storybook/react-vite": ["@storybook/react-vite@9.1.20", "", { "dependencies": { "@joshwooding/vite-plugin-react-docgen-typescript": "0.6.1", "@rollup/pluginutils": "^5.0.2", "@storybook/builder-vite": "9.1.20", "@storybook/react": "9.1.20", "find-up": "^7.0.0", "magic-string": "^0.30.0", "react-docgen": "^8.0.0", "resolve": "^1.22.8", "tsconfig-paths": "^4.2.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-beta", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-beta", "storybook": "^9.1.20", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-buXeNvEJ9kp4FKbGYV7zW4sh/KS01EAjeq8Z6AVxaXOh4W2CIRTKM9maWGz+Rr+YyqQIq/Gl+RqNwxctpxeuHA=="],
+
+    "@streamdown/cjk": ["@streamdown/cjk@1.0.3", "", { "dependencies": { "remark-cjk-friendly": "^2.0.1", "remark-cjk-friendly-gfm-strikethrough": "^2.0.1", "unist-util-visit": "^5.0.0" }, "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-WRg8HR/gHbBoTgsMd91OKFUClIoDcEFVofJvluvEAyjx3KpU0aGgD9tGDqHkHj14ShoMSkX0IYetWGegTcwIJw=="],
+
+    "@streamdown/code": ["@streamdown/code@1.1.1", "", { "dependencies": { "shiki": "^3.19.0" }, "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-i7HTNuDgZWb+VdrNVOam9gQhIc5MSSDXKWXgbUrn/4vSRaSMM+Rtl10MQj4wLWPNpF7p80waJsAqFP8HZfb0Jg=="],
+
+    "@streamdown/math": ["@streamdown/math@1.0.2", "", { "dependencies": { "katex": "^0.16.27", "rehype-katex": "^7.0.1", "remark-math": "^6.0.0" }, "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-r8Ur9/lBuFnzZAFdEWrLUF2s/gRwRRRwruqltdZibyjbCBnuW7SJbFm26nXqvpJPW/gzpBUMrBVBzd88z05D5g=="],
+
+    "@streamdown/mermaid": ["@streamdown/mermaid@1.0.2", "", { "dependencies": { "mermaid": "^11.12.2" }, "peerDependencies": { "react": "^18.0.0 || ^19.0.0" } }, "sha512-Fr/4sBWnAeSnxM3PcrV/+DiZe5oPMq9gOkUIAH7ZauJeuwrZ/DVzD4g0zlav6AH0axh2m/sOfrfLtY5aLT7niw=="],
+
+    "@streamparser/json": ["@streamparser/json@0.0.21", "", {}, "sha512-v+49JBiG1kmc/9Ug79Lz9wyKaRocBgCnpRaLpdy7p0d3ICKtOAfc/H/Epa1j3F6YdnzjnZKKrnJ8xnh/v1P8Aw=="],
+
+    "@swc/core": ["@swc/core@1.15.43", "", { "dependencies": { "@swc/counter": "^0.1.3", "@swc/types": "^0.1.27" }, "optionalDependencies": { "@swc/core-darwin-arm64": "1.15.43", "@swc/core-darwin-x64": "1.15.43", "@swc/core-linux-arm-gnueabihf": "1.15.43", "@swc/core-linux-arm64-gnu": "1.15.43", "@swc/core-linux-arm64-musl": "1.15.43", "@swc/core-linux-ppc64-gnu": "1.15.43", "@swc/core-linux-s390x-gnu": "1.15.43", "@swc/core-linux-x64-gnu": "1.15.43", "@swc/core-linux-x64-musl": "1.15.43", "@swc/core-win32-arm64-msvc": "1.15.43", "@swc/core-win32-ia32-msvc": "1.15.43", "@swc/core-win32-x64-msvc": "1.15.43" }, "peerDependencies": { "@swc/helpers": ">=0.5.17" }, "optionalPeers": ["@swc/helpers"] }, "sha512-1CuKjFkPxIgGdeHVuNbkxmBxkcbdc08u0aiI43pFq6yY1tTVKmXT9hFEooyyKs/sJ3xf1GPHyEwTtk9Xl8dvQw=="],
+
+    "@swc/core-darwin-arm64": ["@swc/core-darwin-arm64@1.15.43", "", { "os": "darwin", "cpu": "arm64" }, "sha512-v1aVuvXdo/BHxJzco9V2xpHrvwWmhfS8t6gziY5wJxd+Z2h8AeJRnAwPD8itCDaGXVBwJ/CaKfxEzTkG0Va0OA=="],
+
+    "@swc/core-darwin-x64": ["@swc/core-darwin-x64@1.15.43", "", { "os": "darwin", "cpu": "x64" }, "sha512-lp3d4Lamc8dt5huYdGLSR+9hLxmfr1jb0l+4XXG2zPqZwYWRN9R0U2qYoTrggiU2RWW0oV9VbWM3kBnqIc2kdQ=="],
+
+    "@swc/core-linux-arm-gnueabihf": ["@swc/core-linux-arm-gnueabihf@1.15.43", "", { "os": "linux", "cpu": "arm" }, "sha512-JWTQQELtsG5GgphDrr/XqqmM2pDN3cZqbMS0Mrg+iTiXL3F74sn/S2IyYE/5u4h2KLkTf9qQ7dXyxsbx7YzkeA=="],
+
+    "@swc/core-linux-arm64-gnu": ["@swc/core-linux-arm64-gnu@1.15.43", "", { "os": "linux", "cpu": "arm64" }, "sha512-B4otJRdPWIsmiSBf0uG7Z/+vMWmkufjz5MmYxubwKuZazDW14Zd3symga1N62QR4RT+kEFeHEgsXfZGyn/w0hw=="],
+
+    "@swc/core-linux-arm64-musl": ["@swc/core-linux-arm64-musl@1.15.43", "", { "os": "linux", "cpu": "arm64" }, "sha512-6zB6OnpViBxYy4tgY3v2i6AZY9fwkcHZ032UOwtwUuW1d19sdT07qF0kZe6/3UR1tUaK6jjg2rmVcUIBCEYVjQ=="],
+
+    "@swc/core-linux-ppc64-gnu": ["@swc/core-linux-ppc64-gnu@1.15.43", "", { "os": "linux", "cpu": "ppc64" }, "sha512-coxE1ZWdB3uSDVNoEtYNrRi/1epvckZx9cTJ8ICUxTMTxGk+yvQ/Twacp3ruZSaMPGCriUjP86C37VhaT6nyRg=="],
+
+    "@swc/core-linux-s390x-gnu": ["@swc/core-linux-s390x-gnu@1.15.43", "", { "os": "linux", "cpu": "s390x" }, "sha512-lXfLhs+LpBsD5inuYx+YDH5WsPPBQ95KPUiy8P5wq9ob9xKDZFqwNfU2QW6bGO8NqRO/H9JQomTSt5Yyh+FGfA=="],
+
+    "@swc/core-linux-x64-gnu": ["@swc/core-linux-x64-gnu@1.15.43", "", { "os": "linux", "cpu": "x64" }, "sha512-07XnKwTmKy8TGOZG3D9fRnLWGynxPjwQnZLVmBFbo6F+7vHYzBIOuwXEhemrChBWb6yDNZsVCcMWCPX6FDD2xg=="],
+
+    "@swc/core-linux-x64-musl": ["@swc/core-linux-x64-musl@1.15.43", "", { "os": "linux", "cpu": "x64" }, "sha512-TJc+bsSIaBh+hZvZ5GRtW/K1bw66TJ9vsUwvVIsZdiWxU5ObLwZvfcnZ3UpgVfMnFibRes9uriJrQNBHEEogRQ=="],
+
+    "@swc/core-win32-arm64-msvc": ["@swc/core-win32-arm64-msvc@1.15.43", "", { "os": "win32", "cpu": "arm64" }, "sha512-jfd7s2/bUQYkOHLs+LWQNKZdmDa8+sufKLllhpWAhVQ2GDCwsHe3vR/j+OSiItZNtkzFuaawa3+SAKz9y5gYfw=="],
+
+    "@swc/core-win32-ia32-msvc": ["@swc/core-win32-ia32-msvc@1.15.43", "", { "os": "win32", "cpu": "ia32" }, "sha512-rLAE8JvucqEW1ZGohxPQrQWPBQeJG4+ypKbWfdlU/qmKScvCkxf9/Jxnzki1dkUQCQ7P5Enp13RlvqOlvx/32g=="],
+
+    "@swc/core-win32-x64-msvc": ["@swc/core-win32-x64-msvc@1.15.43", "", { "os": "win32", "cpu": "x64" }, "sha512-h8MLDHZcfIukwQWj03rIJZx1I0E81AYj2X7J/nGErG4nz+QAv6G1Z+peotvinL3lqpbo32tLYSMFo32/ySzxKg=="],
+
+    "@swc/counter": ["@swc/counter@0.1.3", "", {}, "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ=="],
+
+    "@swc/helpers": ["@swc/helpers@0.5.15", "", { "dependencies": { "tslib": "^2.8.0" } }, "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g=="],
+
+    "@swc/types": ["@swc/types@0.1.27", "", { "dependencies": { "@swc/counter": "^0.1.3" } }, "sha512-K6h3iUlqeM946U4sXFYeahefR1YBbXJvko+hv8WS8/0BNJ4OHiHRywMnQUJCqkR7Y9+hqQ1TvEpiKqUhz7NEFg=="],
+
+    "@tailwindcss/node": ["@tailwindcss/node@4.3.2", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "enhanced-resolve": "5.21.6", "jiti": "^2.7.0", "lightningcss": "1.32.0", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.3.2" } }, "sha512-yWP/sqEcBLaD8JuA6zNwxoYKr75qxTioYwlRwekj5Jr/I5GXnoJfjetH/psLUIv74cYTH2lBUEzBkinthoYcBg=="],
+
+    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.3.2", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.3.2", "@tailwindcss/oxide-darwin-arm64": "4.3.2", "@tailwindcss/oxide-darwin-x64": "4.3.2", "@tailwindcss/oxide-freebsd-x64": "4.3.2", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.2", "@tailwindcss/oxide-linux-arm64-gnu": "4.3.2", "@tailwindcss/oxide-linux-arm64-musl": "4.3.2", "@tailwindcss/oxide-linux-x64-gnu": "4.3.2", "@tailwindcss/oxide-linux-x64-musl": "4.3.2", "@tailwindcss/oxide-wasm32-wasi": "4.3.2", "@tailwindcss/oxide-win32-arm64-msvc": "4.3.2", "@tailwindcss/oxide-win32-x64-msvc": "4.3.2" } }, "sha512-z8ZgnzX8gdNoWLBLqBPoh/sjnxkwvf9ZuWjnO0l0yIzbLa5/9S+eC5QxGZKRobVHIC3/1BoMWjHblqWjcgFgag=="],
+
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.3.2", "", { "os": "android", "cpu": "arm64" }, "sha512-WHxqIuHpvZ5VtdX6GTl1Ik/Vp2YuN42Et+0CdeaVd/frQ9jAvGmvR8vLT+jk3e8/Q3x8kECB9+R17pgpp2BulA=="],
+
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.3.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-GZypeUY/IDJW3877KeM+O67vbXr3MBnbtEL4aYhNErv/JWZhye2vGSWWG9tB6iiqR2MqRNkY8IOUy4NdSZV26w=="],
+
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.3.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-UIIzmefR6KO1sDU7MzRqAxC8iBpft/VhkGjTjnhoS6k7Z3rQ9wEgA1ODSiyH/tcSYssulNm4Ci3hOeK1jH7ccQ=="],
+
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.3.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-GN+uAmcI6DNspnCDwtOAZrTz6oukJnp337qZvxqCGLd3BHBzJpO0ZbTLRvJNdztOeAmTzewewGIMPb0tk2R4WA=="],
+
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.3.2", "", { "os": "linux", "cpu": "arm" }, "sha512-4ABn7qSbdHRwTiDiuWNegCyb5+2FJ4vKIKc3DmKrvAFw7MU1Lm11dIkTPwUaFdTzc7IsOpDbqBrlh0x6y36U/w=="],
+
+    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.3.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-wDgEIGwoM8w8pufh9LVt1PahDgNdKXrLC2qfAnV3vAmococ9RWbxeAw4pxPttd/TsJfwjyLf90Dg1y9y8I6Emw=="],
+
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.3.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-J5Nuk0uZQIiMTJj3LEx4sAA9tMFUoXQZFv1J6An+QGYe53HKRJuFDi0rpq/tuouCZeAbOBY3kQ6g8qeD4TUjtA=="],
+
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.3.2", "", { "os": "linux", "cpu": "x64" }, "sha512-kqCZpSKOBEJO4mz7OqWoofBZeXTAwaVGPj0ErAj7CojmhKpWVWVOnrt9dE8odoIraZq4oj3ausM37kXi+Tow8w=="],
+
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.3.2", "", { "os": "linux", "cpu": "x64" }, "sha512-cixpqbh2toJDmkuCRI68nXA8ZxNmdK9Y+9v5h3MC3ZQKy/0BO8AWzlkWyRM7JAFSGBlfig4YVTPsK6MVgqz1uw=="],
+
+    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.3.2", "", { "dependencies": { "@emnapi/core": "^1.11.1", "@emnapi/runtime": "^1.11.1", "@emnapi/wasi-threads": "^1.2.2", "@napi-rs/wasm-runtime": "^1.1.4", "@tybys/wasm-util": "^0.10.2", "tslib": "^2.8.1" }, "cpu": "none" }, "sha512-4ec2Z/LOmRsAgU23CS4xeJfcJlmRg94A/XrbGRCF1gyU/zdDfRLYDVsS+ynSZCmGNxQ1jQriQOKMQeQxBA3Isw=="],
+
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.3.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-Zyr/M0+XcYZu3bZrUytc7TXvrk0ftWfl8gN2MwekNDzhqhKRUucMPSeOzM0o0wH5AWOU49BsKRrfKxI2atCPMQ=="],
+
+    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.3.2", "", { "os": "win32", "cpu": "x64" }, "sha512-QI9BO7KlNZsp2GuO0jwAAj5jCDABOKXRkCk2XuKTSaNEFSdfzqswYVTtCHBNKHLsqyjFyFkqlDiwkNbTYSssMQ=="],
+
+    "@tailwindcss/postcss": ["@tailwindcss/postcss@4.3.2", "", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "@tailwindcss/node": "4.3.2", "@tailwindcss/oxide": "4.3.2", "postcss": "^8.5.15", "tailwindcss": "4.3.2" } }, "sha512-rjVWYCa7Ngbi5AarT6k8TkxUG3Wl1QKzHdIZVsjZSzf36Jmo2IKZt/NHRAwly8oDkbBOH0YTu+CHuf9jPxMc+g=="],
+
+    "@tailwindcss/vite": ["@tailwindcss/vite@4.3.2", "", { "dependencies": { "@tailwindcss/node": "4.3.2", "@tailwindcss/oxide": "4.3.2", "tailwindcss": "4.3.2" }, "peerDependencies": { "vite": "^5.2.0 || ^6 || ^7 || ^8" } }, "sha512-eHpMeX4JXfVNJDEcsouTeCBubJBTcTLigeaw/NTUW6PB5ATKKXdyonnXgTBX2VuRbjz1hjfz6C5XAhr52ImQXA=="],
+
+    "@tanstack/react-virtual": ["@tanstack/react-virtual@3.11.3", "", { "dependencies": { "@tanstack/virtual-core": "3.11.3" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-vCU+OTylXN3hdC8RKg68tPlBPjjxtzon7Ys46MgrSLE+JhSjSTPvoQifV6DQJeJmA8Q3KT6CphJbejupx85vFw=="],
+
+    "@tanstack/virtual-core": ["@tanstack/virtual-core@3.11.3", "", {}, "sha512-v2mrNSnMwnPJtcVqNvV0c5roGCBqeogN8jDtgtuHCphdwBasOZ17x8UV8qpHUh+u0MLfX43c0uUHKje0s+Zb0w=="],
+
+    "@tauri-apps/api": ["@tauri-apps/api@2.11.1", "", {}, "sha512-M2FPuYND2m+wh5hfW9ZpSdxMPdEJovPBWwoHJmwUpysTYNHaOkVFN419m/K0LIgjb/7KU2vBgsUepJWugQCvAA=="],
+
+    "@tauri-apps/cli": ["@tauri-apps/cli@2.11.4", "", { "optionalDependencies": { "@tauri-apps/cli-darwin-arm64": "2.11.4", "@tauri-apps/cli-darwin-x64": "2.11.4", "@tauri-apps/cli-linux-arm-gnueabihf": "2.11.4", "@tauri-apps/cli-linux-arm64-gnu": "2.11.4", "@tauri-apps/cli-linux-arm64-musl": "2.11.4", "@tauri-apps/cli-linux-riscv64-gnu": "2.11.4", "@tauri-apps/cli-linux-x64-gnu": "2.11.4", "@tauri-apps/cli-linux-x64-musl": "2.11.4", "@tauri-apps/cli-win32-arm64-msvc": "2.11.4", "@tauri-apps/cli-win32-ia32-msvc": "2.11.4", "@tauri-apps/cli-win32-x64-msvc": "2.11.4" }, "bin": { "tauri": "tauri.js" } }, "sha512-R8xGtMpwyetawSqm9kYOuMmEqkhUbvcUy8n0aNXIxollKBLESUu5f4Fx+64hgASYm1H+jSWq6jCW6zqTnH6hqQ=="],
+
+    "@tauri-apps/cli-darwin-arm64": ["@tauri-apps/cli-darwin-arm64@2.11.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-1ryOF3ZhpZ/nemHV5zVwBQBz9jDGKmKPvWPADOhc83ig0P4bMc2iER4NbC6r9sjeIZ6RVQ4g3RZIYvezhcl4TQ=="],
+
+    "@tauri-apps/cli-darwin-x64": ["@tauri-apps/cli-darwin-x64@2.11.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-uFsGQAAfuyz1k/yGLmkWfkBlgKAqZfxqlHmLWx81QU27RJWfmbNHCIq8T8w1e+VClleIuZUjpHWfoE4E3DLo3A=="],
+
+    "@tauri-apps/cli-linux-arm-gnueabihf": ["@tauri-apps/cli-linux-arm-gnueabihf@2.11.4", "", { "os": "linux", "cpu": "arm" }, "sha512-IaHZn5CdBL21oUmjiVOS1ctw6Ip1O0pjp70FwOWmYz1myWe0SY96ZIj2FYf7pT0m8bI2h/hrs5ZbEXXh44/MkQ=="],
+
+    "@tauri-apps/cli-linux-arm64-gnu": ["@tauri-apps/cli-linux-arm64-gnu@2.11.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-N41/ukTRVe6XSuUTESuFdGeOW2i7k62tK+6gHK5Kd5/q5RPvvi19GaWAVPPb9u95HSGmTChSolBfzynUsssFaA=="],
+
+    "@tauri-apps/cli-linux-arm64-musl": ["@tauri-apps/cli-linux-arm64-musl@2.11.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-v277UnT/fB64xAfSroL5N3Km3tLmvATWqJJw/wRI+g6o+HkeD0slyE7gOhNs1MbjE41R7bQOTxMVoL3aomUJmw=="],
+
+    "@tauri-apps/cli-linux-riscv64-gnu": ["@tauri-apps/cli-linux-riscv64-gnu@2.11.4", "", { "os": "linux", "cpu": "none" }, "sha512-qqgNkQ2u1yZHxjhxsZaxUtRDW8dIqIYm33rx/mzwQv0SfY9x1B+iraj8vWeFiXjjSVVhEMepXSOts1TqPzvXNQ=="],
+
+    "@tauri-apps/cli-linux-x64-gnu": ["@tauri-apps/cli-linux-x64-gnu@2.11.4", "", { "os": "linux", "cpu": "x64" }, "sha512-2VRNWl84FOH0m2giiDkO2h0QXlcMJeX+zJDpI5kDIQAx6s+geF3v48F4DXfJez4GS/FdoDGnPnw1C2iYGbQ7bQ=="],
+
+    "@tauri-apps/cli-linux-x64-musl": ["@tauri-apps/cli-linux-x64-musl@2.11.4", "", { "os": "linux", "cpu": "x64" }, "sha512-o9GyhYor/nc7xarmwDE3ka2szuW3uuZzXjHWh64Q8YX5AtSgxdQkFWzrY4O8KiGtVNvFBI14H3Q49Qj5TOIP/A=="],
+
+    "@tauri-apps/cli-win32-arm64-msvc": ["@tauri-apps/cli-win32-arm64-msvc@2.11.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-ld5Ehb598m0VkYyylRPNeCFsBe/km0jxis6KgMpl3IGY6I/i1RwQXO05I1AsXUXO2WC6AvB/Lw4qTf/asiuEiQ=="],
+
+    "@tauri-apps/cli-win32-ia32-msvc": ["@tauri-apps/cli-win32-ia32-msvc@2.11.4", "", { "os": "win32", "cpu": "ia32" }, "sha512-12Hxi0XX/H5VFxO/bGgHkFWhml9VMgEOu9CidjeCeTNQ1l6fpUlbiGgSP7CLI3PFtW9/FfbeHieZ+kyWK5H7CA=="],
+
+    "@tauri-apps/cli-win32-x64-msvc": ["@tauri-apps/cli-win32-x64-msvc@2.11.4", "", { "os": "win32", "cpu": "x64" }, "sha512-+vDiqBIU5dMISg/wNvX3sF+ZHfgJGJ5T0AcO+EHNXV9GGAG+P5fzodlDXD3QdKCRgZxMoCm5PPvj3BqLNjBthw=="],
+
+    "@testing-library/dom": ["@testing-library/dom@10.4.1", "", { "dependencies": { "@babel/code-frame": "^7.10.4", "@babel/runtime": "^7.12.5", "@types/aria-query": "^5.0.1", "aria-query": "5.3.0", "dom-accessibility-api": "^0.5.9", "lz-string": "^1.5.0", "picocolors": "1.1.1", "pretty-format": "^27.0.2" } }, "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg=="],
+
+    "@testing-library/jest-dom": ["@testing-library/jest-dom@6.9.1", "", { "dependencies": { "@adobe/css-tools": "^4.4.0", "aria-query": "^5.0.0", "css.escape": "^1.5.1", "dom-accessibility-api": "^0.6.3", "picocolors": "^1.1.1", "redent": "^3.0.0" } }, "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA=="],
+
+    "@testing-library/react": ["@testing-library/react@16.3.2", "", { "dependencies": { "@babel/runtime": "^7.12.5" }, "peerDependencies": { "@testing-library/dom": "^10.0.0", "@types/react": "^18.0.0 || ^19.0.0", "@types/react-dom": "^18.0.0 || ^19.0.0", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g=="],
+
+    "@testing-library/user-event": ["@testing-library/user-event@14.6.1", "", { "peerDependencies": { "@testing-library/dom": ">=7.21.4" } }, "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw=="],
+
+    "@textlint/ast-node-types": ["@textlint/ast-node-types@15.7.1", "", {}, "sha512-Wii5UgUKFEh9Uv6wbq1zr4/Kf+dtjiUuzPrrXzKp8H+ifkvKNzi23V4Nz+6wVyHQn5T28AFuc8VH8OtzvGYecA=="],
+
+    "@textlint/linter-formatter": ["@textlint/linter-formatter@15.7.1", "", { "dependencies": { "@azu/format-text": "^1.0.2", "@azu/style-format": "^1.0.1", "@textlint/module-interop": "15.7.1", "@textlint/resolver": "15.7.1", "@textlint/types": "15.7.1", "chalk": "^4.1.2", "debug": "^4.4.3", "js-yaml": "^4.1.1", "lodash": "^4.18.1", "pluralize": "^2.0.0", "string-width": "^4.2.3", "strip-ansi": "^6.0.1", "table": "^6.9.0", "text-table": "^0.2.0" } }, "sha512-TdwZ/debWYFD05K3CcoHtwvnCrza29wZxD+BjDTk/V5N7iRqkK1dTTHSD4A8AIgROLiDkHJmIKQbasbmsg8AvA=="],
+
+    "@textlint/module-interop": ["@textlint/module-interop@15.7.1", "", {}, "sha512-Jg+sQW2L/cRJypk59wtcMUVVpt8vmit5ZMT3gUnFwevP3A6Qp1HfOtUy9ObT4hBX3lOSGT/ekcCDxR1pL7uH1g=="],
+
+    "@textlint/resolver": ["@textlint/resolver@15.7.1", "", {}, "sha512-8XnO0pgF6mXnm41VvWmBbEIdGPhiCUt31uLZkOis1ECeg/1SoUcIT6Mx/F0e1rukq8l0UlOSeY9a31CsvRMK0g=="],
+
+    "@textlint/types": ["@textlint/types@15.7.1", "", { "dependencies": { "@textlint/ast-node-types": "15.7.1" } }, "sha512-Vye/GmFNBTgVzZFtIFJTmLB+s2A7oIADxNG6r9UhfPuY+Czv0z5G3xeyFZZudPlfxURsKUyPIU5XsjOFqVp33A=="],
+
+    "@tokenizer/token": ["@tokenizer/token@0.3.0", "", {}, "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A=="],
+
+    "@tokenlens/core": ["@tokenlens/core@1.3.0", "", {}, "sha512-d8YNHNC+q10bVpi95fELJwJyPVf1HfvBEI18eFQxRSZTdByXrP+f/ZtlhSzkx0Jl0aEmYVeBA5tPeeYRioLViQ=="],
+
+    "@tokenlens/fetch": ["@tokenlens/fetch@1.3.0", "", { "dependencies": { "@tokenlens/core": "1.3.0" } }, "sha512-RONDRmETYly9xO8XMKblmrZjKSwCva4s5ebJwQNfNlChZoA5kplPoCgnWceHnn1J1iRjLVlrCNB43ichfmGBKQ=="],
+
+    "@tokenlens/helpers": ["@tokenlens/helpers@1.3.1", "", { "dependencies": { "@tokenlens/core": "1.3.0", "@tokenlens/fetch": "1.3.0" } }, "sha512-t6yL8N6ES8337E6eVSeH4hCKnPdWkZRFpupy9w5E66Q9IeqQ9IO7XQ6gh12JKjvWiRHuyyJ8MBP5I549Cr41EQ=="],
+
+    "@tokenlens/models": ["@tokenlens/models@1.3.0", "", { "dependencies": { "@tokenlens/core": "1.3.0" } }, "sha512-9mx7ZGeewW4ndXAiD7AT1bbCk4OpJeortbjHHyNkgap+pMPPn1chY6R5zqe1ggXIUzZ2l8VOAKfPqOvpcrisJw=="],
+
+    "@tootallnate/quickjs-emscripten": ["@tootallnate/quickjs-emscripten@0.23.0", "", {}, "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA=="],
+
+    "@ts-morph/common": ["@ts-morph/common@0.26.1", "", { "dependencies": { "fast-glob": "^3.3.2", "minimatch": "^9.0.4", "path-browserify": "^1.0.1" } }, "sha512-Sn28TGl/4cFpcM+jwsH1wLncYq3FtN/BIpem+HOygfBWPT5pAeS5dB4VFVzV8FbnOKHpDLZmvAl4AjPEev5idA=="],
+
+    "@tsconfig/node10": ["@tsconfig/node10@1.0.12", "", {}, "sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ=="],
+
+    "@tsconfig/node12": ["@tsconfig/node12@1.0.11", "", {}, "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag=="],
+
+    "@tsconfig/node14": ["@tsconfig/node14@1.0.3", "", {}, "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow=="],
+
+    "@tsconfig/node16": ["@tsconfig/node16@1.0.4", "", {}, "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA=="],
+
+    "@tybys/wasm-util": ["@tybys/wasm-util@0.10.3", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg=="],
+
+    "@types/aria-query": ["@types/aria-query@5.0.4", "", {}, "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw=="],
+
+    "@types/babel__core": ["@types/babel__core@7.20.5", "", { "dependencies": { "@babel/parser": "^7.20.7", "@babel/types": "^7.20.7", "@types/babel__generator": "*", "@types/babel__template": "*", "@types/babel__traverse": "*" } }, "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA=="],
+
+    "@types/babel__generator": ["@types/babel__generator@7.27.0", "", { "dependencies": { "@babel/types": "^7.0.0" } }, "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg=="],
+
+    "@types/babel__template": ["@types/babel__template@7.4.4", "", { "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" } }, "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A=="],
+
+    "@types/babel__traverse": ["@types/babel__traverse@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.2" } }, "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q=="],
+
+    "@types/better-sqlite3": ["@types/better-sqlite3@7.6.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA=="],
+
+    "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="],
+
+    "@types/chai": ["@types/chai@5.2.3", "", { "dependencies": { "@types/deep-eql": "*", "assertion-error": "^2.0.1" } }, "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA=="],
+
+    "@types/clone-deep": ["@types/clone-deep@4.0.4", "", {}, "sha512-vXh6JuuaAha6sqEbJueYdh5zNBPPgG1OYumuz2UvLvriN6ABHDSW8ludREGWJb1MLIzbwZn4q4zUbUCerJTJfA=="],
+
+    "@types/d3": ["@types/d3@7.4.3", "", { "dependencies": { "@types/d3-array": "*", "@types/d3-axis": "*", "@types/d3-brush": "*", "@types/d3-chord": "*", "@types/d3-color": "*", "@types/d3-contour": "*", "@types/d3-delaunay": "*", "@types/d3-dispatch": "*", "@types/d3-drag": "*", "@types/d3-dsv": "*", "@types/d3-ease": "*", "@types/d3-fetch": "*", "@types/d3-force": "*", "@types/d3-format": "*", "@types/d3-geo": "*", "@types/d3-hierarchy": "*", "@types/d3-interpolate": "*", "@types/d3-path": "*", "@types/d3-polygon": "*", "@types/d3-quadtree": "*", "@types/d3-random": "*", "@types/d3-scale": "*", "@types/d3-scale-chromatic": "*", "@types/d3-selection": "*", "@types/d3-shape": "*", "@types/d3-time": "*", "@types/d3-time-format": "*", "@types/d3-timer": "*", "@types/d3-transition": "*", "@types/d3-zoom": "*" } }, "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww=="],
+
+    "@types/d3-array": ["@types/d3-array@3.2.2", "", {}, "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw=="],
+
+    "@types/d3-axis": ["@types/d3-axis@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw=="],
+
+    "@types/d3-brush": ["@types/d3-brush@3.0.6", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A=="],
+
+    "@types/d3-chord": ["@types/d3-chord@3.0.6", "", {}, "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg=="],
+
+    "@types/d3-color": ["@types/d3-color@3.1.3", "", {}, "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A=="],
+
+    "@types/d3-contour": ["@types/d3-contour@3.0.6", "", { "dependencies": { "@types/d3-array": "*", "@types/geojson": "*" } }, "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg=="],
+
+    "@types/d3-delaunay": ["@types/d3-delaunay@6.0.4", "", {}, "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw=="],
+
+    "@types/d3-dispatch": ["@types/d3-dispatch@3.0.7", "", {}, "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA=="],
+
+    "@types/d3-drag": ["@types/d3-drag@3.0.7", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ=="],
+
+    "@types/d3-dsv": ["@types/d3-dsv@3.0.7", "", {}, "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g=="],
+
+    "@types/d3-ease": ["@types/d3-ease@3.0.2", "", {}, "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA=="],
+
+    "@types/d3-fetch": ["@types/d3-fetch@3.0.7", "", { "dependencies": { "@types/d3-dsv": "*" } }, "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA=="],
+
+    "@types/d3-force": ["@types/d3-force@3.0.10", "", {}, "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw=="],
+
+    "@types/d3-format": ["@types/d3-format@3.0.4", "", {}, "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g=="],
+
+    "@types/d3-geo": ["@types/d3-geo@3.1.0", "", { "dependencies": { "@types/geojson": "*" } }, "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ=="],
+
+    "@types/d3-hierarchy": ["@types/d3-hierarchy@3.1.7", "", {}, "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg=="],
+
+    "@types/d3-interpolate": ["@types/d3-interpolate@3.0.4", "", { "dependencies": { "@types/d3-color": "*" } }, "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA=="],
+
+    "@types/d3-path": ["@types/d3-path@3.1.1", "", {}, "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg=="],
+
+    "@types/d3-polygon": ["@types/d3-polygon@3.0.2", "", {}, "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA=="],
+
+    "@types/d3-quadtree": ["@types/d3-quadtree@3.0.6", "", {}, "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg=="],
+
+    "@types/d3-random": ["@types/d3-random@3.0.3", "", {}, "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ=="],
+
+    "@types/d3-scale": ["@types/d3-scale@4.0.9", "", { "dependencies": { "@types/d3-time": "*" } }, "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw=="],
+
+    "@types/d3-scale-chromatic": ["@types/d3-scale-chromatic@3.1.0", "", {}, "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ=="],
+
+    "@types/d3-selection": ["@types/d3-selection@3.0.11", "", {}, "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w=="],
+
+    "@types/d3-shape": ["@types/d3-shape@3.1.8", "", { "dependencies": { "@types/d3-path": "*" } }, "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w=="],
+
+    "@types/d3-time": ["@types/d3-time@3.0.4", "", {}, "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g=="],
+
+    "@types/d3-time-format": ["@types/d3-time-format@4.0.3", "", {}, "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg=="],
+
+    "@types/d3-timer": ["@types/d3-timer@3.0.2", "", {}, "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw=="],
+
+    "@types/d3-transition": ["@types/d3-transition@3.0.9", "", { "dependencies": { "@types/d3-selection": "*" } }, "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg=="],
+
+    "@types/d3-zoom": ["@types/d3-zoom@3.0.8", "", { "dependencies": { "@types/d3-interpolate": "*", "@types/d3-selection": "*" } }, "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw=="],
+
+    "@types/debug": ["@types/debug@4.1.13", "", { "dependencies": { "@types/ms": "*" } }, "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw=="],
+
+    "@types/deep-eql": ["@types/deep-eql@4.0.2", "", {}, "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw=="],
+
+    "@types/doctrine": ["@types/doctrine@0.0.9", "", {}, "sha512-eOIHzCUSH7SMfonMG1LsC2f8vxBFtho6NGBznK41R84YzPuvSBzrhEps33IsQiOW9+VL6NQ9DbjQJznk/S4uRA=="],
+
+    "@types/dompurify": ["@types/dompurify@3.2.0", "", { "dependencies": { "dompurify": "*" } }, "sha512-Fgg31wv9QbLDA0SpTOXO3MaxySc4DKGLi8sna4/Utjo4r3ZRPdCt4UQee8BWr+Q5z21yifghREPJGYaEOEIACg=="],
+
+    "@types/estree": ["@types/estree@1.0.9", "", {}, "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg=="],
+
+    "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="],
+
+    "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="],
+
+    "@types/get-folder-size": ["@types/get-folder-size@3.0.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-tSf/k7Undx6jKRwpChR9tl+0ZPf0BVwkjBRtJ5qSnz6iWm2ZRYMAS2MktC2u7YaTAFHmxpL/LBxI85M7ioJCSg=="],
+
+    "@types/hast": ["@types/hast@3.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ=="],
+
+    "@types/istanbul-lib-coverage": ["@types/istanbul-lib-coverage@2.0.6", "", {}, "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w=="],
+
+    "@types/istanbul-lib-report": ["@types/istanbul-lib-report@3.0.3", "", { "dependencies": { "@types/istanbul-lib-coverage": "*" } }, "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA=="],
+
+    "@types/istanbul-reports": ["@types/istanbul-reports@3.0.4", "", { "dependencies": { "@types/istanbul-lib-report": "*" } }, "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ=="],
+
+    "@types/jest": ["@types/jest@29.5.14", "", { "dependencies": { "expect": "^29.0.0", "pretty-format": "^29.0.0" } }, "sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ=="],
+
+    "@types/js-cookie": ["@types/js-cookie@3.0.6", "", {}, "sha512-wkw9yd1kEXOPnvEeEV1Go1MmxtBJL0RR79aOTAApecWFVu7w0NNXNqhcWgvw2YgZDYadliXkl14pa3WXw5jlCQ=="],
+
+    "@types/js-yaml": ["@types/js-yaml@4.0.9", "", {}, "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg=="],
+
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
+    "@types/katex": ["@types/katex@0.16.8", "", {}, "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg=="],
+
+    "@types/lodash": ["@types/lodash@4.17.24", "", {}, "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ=="],
+
+    "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
+
+    "@types/mocha": ["@types/mocha@10.0.10", "", {}, "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q=="],
+
+    "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="],
+
+    "@types/node": ["@types/node@25.9.4", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-dszCsrKb5U7ZsVZBWiHFklTloVl0mSEnWH/iZXfZUlI4rzCUnsvGmgqfuVRHL54ugE7/wRuxEIXRa2iMZ+BG6g=="],
+
+    "@types/node-fetch": ["@types/node-fetch@2.6.13", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.4" } }, "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw=="],
+
+    "@types/normalize-package-data": ["@types/normalize-package-data@2.4.4", "", {}, "sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA=="],
+
+    "@types/pdf-parse": ["@types/pdf-parse@1.1.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-kBfrSXsloMnUJOKi25s3+hRmkycHfLK6A09eRGqF/N8BkQoPUmaCr+q8Cli5FnfohEz/rsv82zAiPz/LXtOGhA=="],
+
+    "@types/picomatch": ["@types/picomatch@4.0.3", "", {}, "sha512-iG0T6+nYJ9FAPmx9SsUlnwcq1ZVRuCXcVEvWnntoPlrOpwtSTKNDC9uVAxTsC3PUvJ+99n4RpAcNgBbHX3JSnQ=="],
+
+    "@types/prop-types": ["@types/prop-types@15.7.15", "", {}, "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw=="],
+
+    "@types/react": ["@types/react@19.2.14", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w=="],
+
+    "@types/react-dom": ["@types/react-dom@19.2.3", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="],
+
+    "@types/resolve": ["@types/resolve@1.20.6", "", {}, "sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ=="],
+
+    "@types/retry": ["@types/retry@0.12.0", "", {}, "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA=="],
+
+    "@types/sarif": ["@types/sarif@2.1.7", "", {}, "sha512-kRz0VEkJqWLf1LLVN4pT1cg1Z9wAuvI6L97V3m2f5B76Tg8d413ddvLBPTEHAZJlnn4XSvu0FkZtViCQGVyrXQ=="],
+
+    "@types/shell-quote": ["@types/shell-quote@1.7.5", "", {}, "sha512-+UE8GAGRPbJVQDdxi16dgadcBfQ+KG2vgZhV1+3A1XmHbmwcdwhCUwIdy+d3pAGrbvgRoVSjeI9vOWyq376Yzw=="],
+
+    "@types/shimmer": ["@types/shimmer@1.2.0", "", {}, "sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg=="],
+
+    "@types/should": ["@types/should@11.2.0", "", {}, "sha512-+J77XoXmKIXcLK5fWS5B3j31F4wfdclzk+lRxFcKfXTHzZfd153u8w96W30dQBIT4kwKobjvYa0kIb0BWJX21Q=="],
+
+    "@types/sinon": ["@types/sinon@21.0.1", "", { "dependencies": { "@types/sinonjs__fake-timers": "*" } }, "sha512-5yoJSqLbjH8T9V2bksgRayuhpZy+723/z6wBOR+Soe4ZlXC0eW8Na71TeaZPUWDQvM7LYKa9UGFc6LRqxiR5fQ=="],
+
+    "@types/sinonjs__fake-timers": ["@types/sinonjs__fake-timers@15.0.1", "", {}, "sha512-Ko2tjWJq8oozHzHV+reuvS5KYIRAokHnGbDwGh/J64LntgpbuylF74ipEL24HCyRjf9FOlBiBHWBR1RlVKsI1w=="],
+
+    "@types/stack-utils": ["@types/stack-utils@2.0.3", "", {}, "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw=="],
+
+    "@types/triple-beam": ["@types/triple-beam@1.3.5", "", {}, "sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw=="],
+
+    "@types/trusted-types": ["@types/trusted-types@2.0.7", "", {}, "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw=="],
+
+    "@types/turndown": ["@types/turndown@5.0.6", "", {}, "sha512-ru00MoyeeouE5BX4gRL+6m/BsDfbRayOskWqUvh7CLGW+UXxHQItqALa38kKnOiZPqJrtzJUgAC2+F0rL1S4Pg=="],
+
+    "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
+
+    "@types/uuid": ["@types/uuid@10.0.0", "", {}, "sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ=="],
+
+    "@types/validate-npm-package-name": ["@types/validate-npm-package-name@4.0.2", "", {}, "sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw=="],
+
+    "@types/vscode": ["@types/vscode@1.125.0", "", {}, "sha512-0icm/ZQAaism87P0ekHqi4/Ju9du+Tm0RUW+y7vqRsxY2cY0FNRX1nAnaW7nT6npPt2tfHiheZ55Zm9UhqonFA=="],
+
+    "@types/vscode-webview": ["@types/vscode-webview@1.57.5", "", {}, "sha512-iBAUYNYkz+uk1kdsq05fEcoh8gJmwT3lqqFPN7MGyjQ3HVloViMdo7ZJ8DFIP8WOK74PjOEilosqAyxV2iUFUw=="],
+
+    "@types/ws": ["@types/ws@8.18.1", "", { "dependencies": { "@types/node": "*" } }, "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg=="],
+
+    "@types/yargs": ["@types/yargs@17.0.35", "", { "dependencies": { "@types/yargs-parser": "*" } }, "sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg=="],
+
+    "@types/yargs-parser": ["@types/yargs-parser@21.0.3", "", {}, "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ=="],
+
+    "@types/yauzl": ["@types/yauzl@2.10.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q=="],
+
+    "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@8.62.1", "", { "dependencies": { "@eslint-community/regexpp": "^4.12.2", "@typescript-eslint/scope-manager": "8.62.1", "@typescript-eslint/type-utils": "8.62.1", "@typescript-eslint/utils": "8.62.1", "@typescript-eslint/visitor-keys": "8.62.1", "ignore": "^7.0.5", "natural-compare": "^1.4.0", "ts-api-utils": "^2.5.0" }, "peerDependencies": { "@typescript-eslint/parser": "^8.62.1", "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", "typescript": ">=4.8.4 <6.1.0" } }, "sha512-4EQM77WgVNxj7OkL/5b/D/xZsw00G577+UriYTC7JF5opcF3T2AuoeY7ueLaZgSVjSgCS6yOAJB5bRGLPSJUzA=="],
+
+    "@typescript-eslint/parser": ["@typescript-eslint/parser@8.62.1", "", { "dependencies": { "@typescript-eslint/scope-manager": "8.62.1", "@typescript-eslint/types": "8.62.1", "@typescript-eslint/typescript-estree": "8.62.1", "@typescript-eslint/visitor-keys": "8.62.1", "debug": "^4.4.3" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", "typescript": ">=4.8.4 <6.1.0" } }, "sha512-sPhE4iHuJDSvoAiec+Ro8JyXw8f0ql13HFR82P99nCm9GwTEKG0KYLvDe6REk8BCXuit6vJAv/Yxg5ABaNS2rA=="],
+
+    "@typescript-eslint/project-service": ["@typescript-eslint/project-service@8.62.1", "", { "dependencies": { "@typescript-eslint/tsconfig-utils": "^8.62.1", "@typescript-eslint/types": "^8.62.1", "debug": "^4.4.3" }, "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, "sha512-yQ3RgY5RkSBpsNS1Bx/JQEcA24FOSdfGktoyprAr5u18390UQdtVcfnEv4nIrIshNnavlVyZBKxQwT1fIAE6cg=="],
+
+    "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@8.62.1", "", { "dependencies": { "@typescript-eslint/types": "8.62.1", "@typescript-eslint/visitor-keys": "8.62.1" } }, "sha512-r4d249KbQ1SFdpeStvob8Ih6aPPIzfqllPVOtvhve6ZcpuVcYo5/7zUWckKpHE7StASX4kTKZTLf0WQm/wPkcg=="],
+
+    "@typescript-eslint/tsconfig-utils": ["@typescript-eslint/tsconfig-utils@8.62.1", "", { "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, "sha512-xadytJqX9vJVQ2fdQjkcIVigwaOJNWkpjdLt6cEQ+xPnrI1fkp+/jZE/I97k9KUjqtpd25i0HeyZf3T6dutv2g=="],
+
+    "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@8.62.1", "", { "dependencies": { "@typescript-eslint/types": "8.62.1", "@typescript-eslint/typescript-estree": "8.62.1", "@typescript-eslint/utils": "8.62.1", "debug": "^4.4.3", "ts-api-utils": "^2.5.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", "typescript": ">=4.8.4 <6.1.0" } }, "sha512-aXM5xlqXiTxPibXB93cLAURfT3rlizf7uMXISCXy66Isr/9hISJx3yDsKl0L7lKa51b8JpFuNKby0/O0pEm9jg=="],
+
+    "@typescript-eslint/types": ["@typescript-eslint/types@8.62.1", "", {}, "sha512-ooCzJFaf+Hg+uG6fA3NRFGuFjlfNlDhBthbv4ZPU/0elCAFUfnyXUvf/WOpHz/jYwSmvU2GkR2LtyUfy1AxZ1Q=="],
+
+    "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@8.62.1", "", { "dependencies": { "@typescript-eslint/project-service": "8.62.1", "@typescript-eslint/tsconfig-utils": "8.62.1", "@typescript-eslint/types": "8.62.1", "@typescript-eslint/visitor-keys": "8.62.1", "debug": "^4.4.3", "minimatch": "^10.2.2", "semver": "^7.7.3", "tinyglobby": "^0.2.15", "ts-api-utils": "^2.5.0" }, "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, "sha512-xMcW9oP9u7fAMXYs9A65CVmtLQe2r//oXINHfi8HV+oiqhih17sbLdhXr4540YWlgpDKQdY854OL5ZrdCiQsAA=="],
+
+    "@typescript-eslint/utils": ["@typescript-eslint/utils@8.62.1", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.9.1", "@typescript-eslint/scope-manager": "8.62.1", "@typescript-eslint/types": "8.62.1", "@typescript-eslint/typescript-estree": "8.62.1" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", "typescript": ">=4.8.4 <6.1.0" } }, "sha512-sHtbPfuKNZCG+ih8SyjjucqRntSVmp8XgL5u6o9mAhiSn8ds5o/M/XdM0abweme2Tln3szOstOrZ9OXitvPh0g=="],
+
+    "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.62.1", "", { "dependencies": { "@typescript-eslint/types": "8.62.1", "eslint-visitor-keys": "^5.0.0" } }, "sha512-4g3BLxfdTMy8iZG0MaBkadnlRrCJ74cQiFbyEVMrkwIoqdyaXXQM22cotDvrl4x28wgIZ9rEJRoM+mmhSJpJ1g=="],
+
+    "@typespec/ts-http-runtime": ["@typespec/ts-http-runtime@0.3.6", "", { "dependencies": { "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.0", "tslib": "^2.6.2" } }, "sha512-jIXhD0eWQ1JA6ln/5Dltyx22UxWNrw0hZmhy2rlv6m6KgF7kplHx3g0fzi09lNmTJQRR91OlemYp3xFnvDK9og=="],
+
+    "@ungap/structured-clone": ["@ungap/structured-clone@1.3.2", "", {}, "sha512-5jsZFwgR5rTdKwidH9Qmat75RKwqfpKlWWB1frDkljN127mwqBu8K0PYo7/hFpF03IEJpfVPpCQDY/eDx3iHvA=="],
+
+    "@upsetjs/venn.js": ["@upsetjs/venn.js@2.0.0", "", { "optionalDependencies": { "d3-selection": "^3.0.0", "d3-transition": "^3.0.1" } }, "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw=="],
+
+    "@vercel/analytics": ["@vercel/analytics@1.6.1", "", { "peerDependencies": { "@remix-run/react": "^2", "@sveltejs/kit": "^1 || ^2", "next": ">= 13", "react": "^18 || ^19 || ^19.0.0-rc", "svelte": ">= 4", "vue": "^3", "vue-router": "^4" }, "optionalPeers": ["@remix-run/react", "@sveltejs/kit", "next", "react", "svelte", "vue", "vue-router"] }, "sha512-oH9He/bEM+6oKlv3chWuOOcp8Y6fo6/PSro8hEkgCW3pu9/OiCXiUpRUogDh3Fs3LH2sosDrx8CxeOLBEE+afg=="],
+
+    "@vercel/oidc": ["@vercel/oidc@3.2.0", "", {}, "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug=="],
+
+    "@vitejs/plugin-react-swc": ["@vitejs/plugin-react-swc@4.3.1", "", { "dependencies": { "@rolldown/pluginutils": "^1.0.0", "@swc/core": "^1.15.11" }, "peerDependencies": { "vite": "^4 || ^5 || ^6 || ^7 || ^8" } }, "sha512-PaeokKjAGraNN+s5SIApgsktnJprIyt3zgEIu7awnEdfn29QiB2crTcCzyi2XGpX9rUnTc0cKU07Wm0N0g7H2w=="],
+
+    "@vitest/coverage-v8": ["@vitest/coverage-v8@3.2.6", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@bcoe/v8-coverage": "^1.0.2", "ast-v8-to-istanbul": "^0.3.3", "debug": "^4.4.1", "istanbul-lib-coverage": "^3.2.2", "istanbul-lib-report": "^3.0.1", "istanbul-lib-source-maps": "^5.0.6", "istanbul-reports": "^3.1.7", "magic-string": "^0.30.17", "magicast": "^0.3.5", "std-env": "^3.9.0", "test-exclude": "^7.0.1", "tinyrainbow": "^2.0.0" }, "peerDependencies": { "@vitest/browser": "3.2.6", "vitest": "3.2.6" }, "optionalPeers": ["@vitest/browser"] }, "sha512-LsAdmUapA0qSN306d8+zOyawM0hFm2m2Hg9IwVNIKBm+qJV8cijiq2c+gxKZcB1HCfIWAy+0qEZDCUQA58A1cw=="],
+
+    "@vitest/expect": ["@vitest/expect@4.1.9", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "@types/chai": "^5.2.2", "@vitest/spy": "4.1.9", "@vitest/utils": "4.1.9", "chai": "^6.2.2", "tinyrainbow": "^3.1.0" } }, "sha512-vl/rYsUKcBr3SnQn166+XR5ZQcgMx3DQhFWdfli/cWpLnLUmbxZvyrJZotLFUryib+LtArYMSTJ5RbQ57ZqrlA=="],
+
+    "@vitest/mocker": ["@vitest/mocker@4.1.9", "", { "dependencies": { "@vitest/spy": "4.1.9", "estree-walker": "^3.0.3", "magic-string": "^0.30.21" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" }, "optionalPeers": ["msw", "vite"] }, "sha512-EVkXzBjrPGM+cK8/ANWgBrkUCfJfb38/EfTSO8h7pWvKkyPkpWxvR7BkD2MyItMF62C97zAEoqdpUixwR/e+Rw=="],
+
+    "@vitest/pretty-format": ["@vitest/pretty-format@4.1.9", "", { "dependencies": { "tinyrainbow": "^3.1.0" } }, "sha512-s0iufns3iIFitdgm+YR7g1whCAaGtXz459VS9/PqyKDEEFgYIhsHOQmXgIgDuYCt7DeQmiZT0Qe2OA2p4ZPu5A=="],
+
+    "@vitest/runner": ["@vitest/runner@4.1.9", "", { "dependencies": { "@vitest/utils": "4.1.9", "pathe": "^2.0.3" } }, "sha512-KXLMDtc7oe70+3mJfGrPUWPesswH+3sTxAMAMl8DG7I8IUQT4XW718dY5ID3vPUcmlu27CcKfY4P3h3I29SLJg=="],
+
+    "@vitest/snapshot": ["@vitest/snapshot@4.1.9", "", { "dependencies": { "@vitest/pretty-format": "4.1.9", "@vitest/utils": "4.1.9", "magic-string": "^0.30.21", "pathe": "^2.0.3" } }, "sha512-Jc7RKGNBo8Z28WYIm0Niej4xdSPByRf6mU58VpHQkd6Zh05rlnA+twjbK5HyeIGHxrzsc3mJgS43uM0CZKzaIA=="],
+
+    "@vitest/spy": ["@vitest/spy@4.1.9", "", {}, "sha512-fHpsS6mIi+PiEW+vcRVOMkX1oSaPKne3VOclSFICPcGOmfKgXPU5iAah+wcNcj2xPrCCmfq99IDGf+EojhhvhA=="],
+
+    "@vitest/utils": ["@vitest/utils@4.1.9", "", { "dependencies": { "@vitest/pretty-format": "4.1.9", "convert-source-map": "^2.0.0", "tinyrainbow": "^3.1.0" } }, "sha512-A51o8ymO5PpqlWNnBP9ZHPXDIpuMtTLlGSjN7la4US+LJzoUMyhwjA5QXlm39JexgwHKW4Xjs8Z2d3dLCXOeuA=="],
+
+    "@vladfrangu/async_event_emitter": ["@vladfrangu/async_event_emitter@2.4.7", "", {}, "sha512-Xfe6rpCTxSxfbswi/W/Pz7zp1WWSNn4A0eW4mLkQUewCrXXtMj31lCg+iQyTkh/CkusZSq9eDflu7tjEDXUY6g=="],
+
+    "@vscode/codicons": ["@vscode/codicons@0.0.36", "", {}, "sha512-wsNOvNMMJ2BY8rC2N2MNBG7yOowV3ov8KlvUE/AiVUlHKTfWsw3OgAOQduX7h0Un6GssKD3aoTVH+TF3DSQwKQ=="],
+
+    "@vscode/test-cli": ["@vscode/test-cli@0.0.12", "", { "dependencies": { "@types/mocha": "^10.0.10", "c8": "^10.1.3", "chokidar": "^3.6.0", "enhanced-resolve": "^5.18.3", "glob": "^10.3.10", "minimatch": "^9.0.3", "mocha": "^11.7.4", "supports-color": "^10.2.2", "yargs": "^17.7.2" }, "bin": { "vscode-test": "out/bin.mjs" } }, "sha512-iYN0fDg29+a2Xelle/Y56Xvv7Nc8Thzq4VwpzAF/SIE6918rDicqfsQxV6w1ttr2+SOm+10laGuY9FG2ptEKsQ=="],
+
+    "@vscode/test-electron": ["@vscode/test-electron@2.5.2", "", { "dependencies": { "http-proxy-agent": "^7.0.2", "https-proxy-agent": "^7.0.5", "jszip": "^3.10.1", "ora": "^8.1.0", "semver": "^7.6.2" } }, "sha512-8ukpxv4wYe0iWMRQU18jhzJOHkeGKbnw7xWRX3Zw1WJA4cEKbHcmmLPdPrPtL6rhDcrlCZN+xKRpv09n4gRHYg=="],
+
+    "@vscode/vsce": ["@vscode/vsce@3.9.2", "", { "dependencies": { "@azure/identity": "^4.1.0", "@secretlint/node": "^10.1.2", "@secretlint/secretlint-formatter-sarif": "^10.1.2", "@secretlint/secretlint-rule-no-dotenv": "^10.1.2", "@secretlint/secretlint-rule-preset-recommend": "^10.1.2", "@vscode/vsce-sign": "^2.0.0", "azure-devops-node-api": "^12.5.0", "chalk": "^4.1.2", "cheerio": "^1.0.0-rc.9", "cockatiel": "^3.1.2", "commander": "^12.1.0", "form-data": "^4.0.0", "glob": "^13.0.6", "hosted-git-info": "^4.0.2", "jsonc-parser": "^3.2.0", "leven": "^3.1.0", "markdown-it": "^14.1.0", "mime": "^1.3.4", "minimatch": "^10.2.2", "parse-semver": "^1.1.1", "read": "^1.0.7", "secretlint": "^10.1.2", "semver": "^7.5.2", "tmp": "^0.2.3", "typed-rest-client": "^1.8.4", "url-join": "^4.0.1", "xml2js": "^0.5.0", "yauzl": "^3.2.1", "yazl": "^2.2.2" }, "optionalDependencies": { "keytar": "^7.7.0" }, "bin": { "vsce": "vsce" } }, "sha512-XSxMosEEDO6vLxELAHVkwmhC0qe0ijZni2jB9Rcs8kQsW4lhTDQ/wMzmwFs/buotAWSnpmUp/dRWD2ufG3UYKA=="],
+
+    "@vscode/vsce-sign": ["@vscode/vsce-sign@2.0.9", "", { "optionalDependencies": { "@vscode/vsce-sign-alpine-arm64": "2.0.6", "@vscode/vsce-sign-alpine-x64": "2.0.6", "@vscode/vsce-sign-darwin-arm64": "2.0.6", "@vscode/vsce-sign-darwin-x64": "2.0.6", "@vscode/vsce-sign-linux-arm": "2.0.6", "@vscode/vsce-sign-linux-arm64": "2.0.6", "@vscode/vsce-sign-linux-x64": "2.0.6", "@vscode/vsce-sign-win32-arm64": "2.0.6", "@vscode/vsce-sign-win32-x64": "2.0.6" } }, "sha512-8IvaRvtFyzUnGGl3f5+1Cnor3LqaUWvhaUjAYO8Y39OUYlOf3cRd+dowuQYLpZcP3uwSG+mURwjEBOSq4SOJ0g=="],
+
+    "@vscode/vsce-sign-alpine-arm64": ["@vscode/vsce-sign-alpine-arm64@2.0.6", "", { "os": "none", "cpu": "arm64" }, "sha512-wKkJBsvKF+f0GfsUuGT0tSW0kZL87QggEiqNqK6/8hvqsXvpx8OsTEc3mnE1kejkh5r+qUyQ7PtF8jZYN0mo8Q=="],
+
+    "@vscode/vsce-sign-alpine-x64": ["@vscode/vsce-sign-alpine-x64@2.0.6", "", { "os": "none", "cpu": "x64" }, "sha512-YoAGlmdK39vKi9jA18i4ufBbd95OqGJxRvF3n6ZbCyziwy3O+JgOpIUPxv5tjeO6gQfx29qBivQ8ZZTUF2Ba0w=="],
+
+    "@vscode/vsce-sign-darwin-arm64": ["@vscode/vsce-sign-darwin-arm64@2.0.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5HMHaJRIQuozm/XQIiJiA0W9uhdblwwl2ZNDSSAeXGO9YhB9MH5C4KIHOmvyjUnKy4UCuiP43VKpIxW1VWP4tQ=="],
+
+    "@vscode/vsce-sign-darwin-x64": ["@vscode/vsce-sign-darwin-x64@2.0.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-25GsUbTAiNfHSuRItoQafXOIpxlYj+IXb4/qarrXu7kmbH94jlm5sdWSCKrrREs8+GsXF1b+l3OB7VJy5jsykw=="],
+
+    "@vscode/vsce-sign-linux-arm": ["@vscode/vsce-sign-linux-arm@2.0.6", "", { "os": "linux", "cpu": "arm" }, "sha512-UndEc2Xlq4HsuMPnwu7420uqceXjs4yb5W8E2/UkaHBB9OWCwMd3/bRe/1eLe3D8kPpxzcaeTyXiK3RdzS/1CA=="],
+
+    "@vscode/vsce-sign-linux-arm64": ["@vscode/vsce-sign-linux-arm64@2.0.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-cfb1qK7lygtMa4NUl2582nP7aliLYuDEVpAbXJMkDq1qE+olIw/es+C8j1LJwvcRq1I2yWGtSn3EkDp9Dq5FdA=="],
+
+    "@vscode/vsce-sign-linux-x64": ["@vscode/vsce-sign-linux-x64@2.0.6", "", { "os": "linux", "cpu": "x64" }, "sha512-/olerl1A4sOqdP+hjvJ1sbQjKN07Y3DVnxO4gnbn/ahtQvFrdhUi0G1VsZXDNjfqmXw57DmPi5ASnj/8PGZhAA=="],
+
+    "@vscode/vsce-sign-win32-arm64": ["@vscode/vsce-sign-win32-arm64@2.0.6", "", { "os": "win32", "cpu": "arm64" }, "sha512-ivM/MiGIY0PJNZBoGtlRBM/xDpwbdlCWomUWuLmIxbi1Cxe/1nooYrEQoaHD8ojVRgzdQEUzMsRbyF5cJJgYOg=="],
+
+    "@vscode/vsce-sign-win32-x64": ["@vscode/vsce-sign-win32-x64@2.0.6", "", { "os": "win32", "cpu": "x64" }, "sha512-mgth9Kvze+u8CruYMmhHw6Zgy3GRX2S+Ed5oSokDEK5vPEwGGKnmuXua9tmFhomeAnhgJnL4DCna3TiNuGrBTQ=="],
+
+    "@vscode/webview-ui-toolkit": ["@vscode/webview-ui-toolkit@1.4.0", "", { "dependencies": { "@microsoft/fast-element": "^1.12.0", "@microsoft/fast-foundation": "^2.49.4", "@microsoft/fast-react-wrapper": "^0.3.22", "tslib": "^2.6.2" }, "peerDependencies": { "react": ">=16.9.0" } }, "sha512-modXVHQkZLsxgmd5yoP3ptRC/G8NBDD+ob+ngPiWNQdlrH6H1xR/qgOBD85bfU3BhOB5sZzFWBwwhp9/SfoHww=="],
+
+    "@webgpu/types": ["@webgpu/types@0.1.71", "", {}, "sha512-mMy8/ODcKhab808co15eW+yN+HgXoQxRQHTiBV9Mrvl1r0ufnid7YOcI+gi4eUWSWl9ezD6TW2KXccrL8HCh2A=="],
+
+    "@workflow/serde": ["@workflow/serde@4.1.0-beta.2", "", {}, "sha512-8kkeoQKLDaKXefjV5dbhBj2aErfKp1Mc4pb6tj8144cF+Em5SPbyMbyLCHp+BVrFfFVCBluCtMx+jjvaFVZGww=="],
+
+    "@xmldom/xmldom": ["@xmldom/xmldom@0.8.13", "", {}, "sha512-KRYzxepc14G/CEpEGc3Yn+JKaAeT63smlDr+vjB8jRfgTBBI9wRj/nkQEO+ucV8p8I9bfKLWp37uHgFrbntPvw=="],
+
+    "@xobotyi/scrollbar-width": ["@xobotyi/scrollbar-width@1.9.5", "", {}, "sha512-N8tkAACJx2ww8vFMneJmaAgmjAG1tnVBZJRLRcx061tmsLRZHSEZSLuGWnwPtunsSLvSqXQ2wfp7Mgqg1I+2dQ=="],
+
+    "@xterm/headless": ["@xterm/headless@5.5.0", "", {}, "sha512-5xXB7kdQlFBP82ViMJTwwEc3gKCLGKR/eoxQm4zge7GPBl86tCdI0IdPJjoKd8mUSFXz5V7i/25sfsEkP4j46g=="],
+
+    "@xyflow/react": ["@xyflow/react@12.11.1", "", { "dependencies": { "@xyflow/system": "0.0.78", "classcat": "^5.0.3", "zustand": "^4.4.0" }, "peerDependencies": { "@types/react": ">=17", "@types/react-dom": ">=17", "react": ">=17", "react-dom": ">=17" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-L+zBoLGSXham0MnlY8QqjfR7/C5JNw0zxkaey5aZ5XmCgJBAdH4+WRIu8CR40d3l/BdU635V6YbhBK1jMo8/6Q=="],
+
+    "@xyflow/system": ["@xyflow/system@0.0.78", "", { "dependencies": { "@types/d3-drag": "^3.0.7", "@types/d3-interpolate": "^3.0.4", "@types/d3-selection": "^3.0.10", "@types/d3-transition": "^3.0.8", "@types/d3-zoom": "^3.0.8", "d3-drag": "^3.0.0", "d3-interpolate": "^3.0.1", "d3-selection": "^3.0.0", "d3-zoom": "^3.0.0" } }, "sha512-lY0z2qP33fUhTva9Vaxrk0lqZta2pkbxB1trHAx1omnJqRtPvDlAQYV2r5fhS6AdpkulYmbNW0svy+A4/t4B/g=="],
+
+    "abbrev": ["abbrev@3.0.1", "", {}, "sha512-AO2ac6pjRB3SJmGJo+v5/aK6Omggp6fsLrs6wN9bd35ulu4cCwaAU9+7ZhXjeqHVkaHThLuzH0nZr0YpCDhygg=="],
+
+    "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
+
+    "abort-controller-x": ["abort-controller-x@0.5.0", "", {}, "sha512-yTt9CI0x+nRfX6BFMenEGP8ooPvErGH6AbFz20C2IeOLIlDsrw/VHpgne3GsCEuTA410IiFiaLVFKmgM4bKEPQ=="],
+
+    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
+
+    "acorn": ["acorn@8.17.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg=="],
+
+    "acorn-import-attributes": ["acorn-import-attributes@1.9.5", "", { "peerDependencies": { "acorn": "^8" } }, "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ=="],
+
+    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
+
+    "acorn-walk": ["acorn-walk@8.3.5", "", { "dependencies": { "acorn": "^8.11.0" } }, "sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw=="],
+
+    "agent-base": ["agent-base@7.1.4", "", {}, "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="],
+
+    "agentkeepalive": ["agentkeepalive@4.6.0", "", { "dependencies": { "humanize-ms": "^1.2.1" } }, "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ=="],
+
+    "ai": ["ai@6.0.218", "", { "dependencies": { "@ai-sdk/gateway": "3.0.142", "@ai-sdk/provider": "3.0.13", "@ai-sdk/provider-utils": "4.0.35", "@opentelemetry/api": "^1.9.0" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-HsyCUNaaYgX/b/kGOoYfKkqfT1HvpUKKDb8YkN1FKeCNZjKdqXLGY+cKBpYGIRAvsPuOHskxLxZ46cK1dTBWQQ=="],
+
+    "ai-sdk-provider-claude-code": ["ai-sdk-provider-claude-code@3.5.0", "", { "dependencies": { "@ai-sdk/provider": "^3.0.0", "@ai-sdk/provider-utils": "^4.0.1", "@anthropic-ai/claude-agent-sdk": "^0.3.170" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-7SZrTGkuR4G4zeNrjnJgDzYkrKZqzq7GUQJcFBKCxFH5dJpS9lbs+g9BCt7bwT1gDm4SAUmOQ0T5rKqcC2HkVQ=="],
+
+    "ai-sdk-provider-codex-cli": ["ai-sdk-provider-codex-cli@1.2.2", "", { "dependencies": { "@ai-sdk/provider": "^3.0.0", "@ai-sdk/provider-utils": "^4.0.1", "jsonc-parser": "^3.3.1" }, "optionalDependencies": { "@openai/codex": "^0.130.0" }, "peerDependencies": { "zod": "^3.0.0 || ^4.0.0" } }, "sha512-hlIWo9KP7/hJaEjXZbxgjVO/FvMn3I+5RSht0PBp3GOBKVFkKeKlrIDvaA8Wi/nAYiAePESPem+fi1NVNfNQJA=="],
+
+    "ai-sdk-provider-opencode-sdk": ["ai-sdk-provider-opencode-sdk@3.0.6", "", { "dependencies": { "@ai-sdk/provider": "^3.0.8", "@ai-sdk/provider-utils": "^4.0.15", "@opencode-ai/sdk": "^1.2.15" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-CZ2I5z96HUdEKAT1ExhdxLE1bjD8efzT7I5GjBevWgwNGgYZjMPE7ZfQCJFVAzWqODwdTdxp7KSZjnmcd4h1Bw=="],
+
+    "ajv": ["ajv@6.15.0", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw=="],
+
+    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
+
+    "anser": ["anser@2.3.5", "", {}, "sha512-vcZjxvvVoxTeR5XBNJB38oTu/7eDCZlwdz32N1eNgpyPF7j/Z7Idf+CUwQOkKKpJ7RJyjxgLHCM7vdIK0iCNMQ=="],
+
+    "ansi-colors": ["ansi-colors@4.1.3", "", {}, "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw=="],
+
+    "ansi-escapes": ["ansi-escapes@7.3.0", "", { "dependencies": { "environment": "^1.0.0" } }, "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg=="],
+
+    "ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "ansi-to-react": ["ansi-to-react@6.2.6", "", { "dependencies": { "anser": "^2.3.2", "escape-carriage": "^1.3.1", "linkify-it": "^3.0.3" }, "peerDependencies": { "react": "^16.3.2 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.3.2 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Eqi0iaMK5OZ3jsVFxWvU2B74UZBnGuHlkflKMX6wTOeH+luy9KE2O0gUkc2PxhIP1R4IO0xohv62UMFInQOSeg=="],
+
+    "any-base": ["any-base@1.1.0", "", {}, "sha512-uMgjozySS8adZZYePpaWs8cxB9/kdzmpX6SgJZ+wbz1K5eYk5QMYDVJaZKhxyIHUdnnJkfR7SVgStgH7LkGUyg=="],
+
+    "anymatch": ["anymatch@3.1.3", "", { "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" } }, "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw=="],
+
+    "aproba": ["aproba@2.1.0", "", {}, "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew=="],
+
+    "archiver": ["archiver@7.0.1", "", { "dependencies": { "archiver-utils": "^5.0.2", "async": "^3.2.4", "buffer-crc32": "^1.0.0", "readable-stream": "^4.0.0", "readdir-glob": "^1.1.2", "tar-stream": "^3.0.0", "zip-stream": "^6.0.1" } }, "sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ=="],
+
+    "archiver-utils": ["archiver-utils@5.0.2", "", { "dependencies": { "glob": "^10.0.0", "graceful-fs": "^4.2.0", "is-stream": "^2.0.1", "lazystream": "^1.0.0", "lodash": "^4.17.15", "normalize-path": "^3.0.0", "readable-stream": "^4.0.0" } }, "sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA=="],
+
+    "arg": ["arg@4.1.3", "", {}, "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA=="],
+
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
+
+    "aria-hidden": ["aria-hidden@1.2.6", "", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
+
+    "aria-query": ["aria-query@5.3.2", "", {}, "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw=="],
+
+    "asn1": ["asn1@0.2.6", "", { "dependencies": { "safer-buffer": "~2.1.0" } }, "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ=="],
+
+    "assert-plus": ["assert-plus@1.0.0", "", {}, "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw=="],
+
+    "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="],
+
+    "ast-types": ["ast-types@0.16.1", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg=="],
+
+    "ast-v8-to-istanbul": ["ast-v8-to-istanbul@0.3.12", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.31", "estree-walker": "^3.0.3", "js-tokens": "^10.0.0" } }, "sha512-BRRC8VRZY2R4Z4lFIL35MwNXmwVqBityvOIwETtsCSwvjl0IdgFsy9NhdaA6j74nUdtJJlIypeRhpDam19Wq3g=="],
+
+    "astral-regex": ["astral-regex@2.0.0", "", {}, "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ=="],
+
+    "async": ["async@3.2.6", "", {}, "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA=="],
+
+    "async-retry": ["async-retry@1.3.3", "", { "dependencies": { "retry": "0.13.1" } }, "sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw=="],
+
+    "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
+
+    "atomic-sleep": ["atomic-sleep@1.0.0", "", {}, "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ=="],
+
+    "atomically": ["atomically@1.7.0", "", {}, "sha512-Xcz9l0z7y9yQ9rdDaxlmaI4uJHf/T8g9hOEzJcsEqX2SjCj4J20uK7+ldkDHMbpJDK76wF7xEIgxc/vSlsfw5w=="],
+
+    "autoprefixer": ["autoprefixer@10.5.2", "", { "dependencies": { "browserslist": "^4.28.4", "caniuse-lite": "^1.0.30001799", "fraction.js": "^5.3.4", "picocolors": "^1.1.1", "postcss-value-parser": "^4.2.0" }, "peerDependencies": { "postcss": "^8.1.0" }, "bin": { "autoprefixer": "bin/autoprefixer" } }, "sha512-rD5t5DwOjJdmSORcTq64j8MawTC+tbQ+HHqjR4NDumamy/ambn1UJrlKL+KdwujWxMkFjPM3pPHOEA9tl4767Q=="],
+
+    "await-to-js": ["await-to-js@3.0.0", "", {}, "sha512-zJAaP9zxTcvTHRlejau3ZOY4V7SRpiByf3/dxx2uyKxxor19tpmpV2QRsTKikckwhaPmr2dVpxxMr7jOCYVp5g=="],
+
+    "aws4fetch": ["aws4fetch@1.0.20", "", {}, "sha512-/djoAN709iY65ETD6LKCtyyEI04XIBP5xVvfmNxsEP0uJB5tyaGBztSryRr4HqMStr9R06PisQE7m9zDTXKu6g=="],
+
+    "axios": ["axios@1.16.1", "", { "dependencies": { "follow-redirects": "^1.16.0", "form-data": "^4.0.5", "https-proxy-agent": "^5.0.1", "proxy-from-env": "^2.1.0" } }, "sha512-caYkukvroVPO8KrzuJEb50Hm07KwfBZPEC3VeFHTsqWHvKTsy54hjJz9BS/cdaypROE2rH6xvm9mHX4fgWkr3A=="],
+
+    "azure-devops-node-api": ["azure-devops-node-api@12.5.0", "", { "dependencies": { "tunnel": "0.0.6", "typed-rest-client": "^1.8.4" } }, "sha512-R5eFskGvOm3U/GzeAuxRkUsAl0hrAwGgWn6zAd2KrZmrEhWZVqLew4OOupbQlXUuojUzpGtq62SmdhJ06N88og=="],
+
+    "b4a": ["b4a@1.8.1", "", { "peerDependencies": { "react-native-b4a": "*" }, "optionalPeers": ["react-native-b4a"] }, "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw=="],
+
+    "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
+
+    "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+
+    "bare-events": ["bare-events@2.9.1", "", { "peerDependencies": { "bare-abort-controller": "*" }, "optionalPeers": ["bare-abort-controller"] }, "sha512-Z0oHEHAFDZkffN8Qc39zNZjQlMDkPJRyyyZieU1VH7u8c5S+qHZ2S8ixdKIAxEjfHO7FJxXmJWgteOghVanIsg=="],
+
+    "bare-fs": ["bare-fs@4.7.2", "", { "dependencies": { "bare-events": "^2.5.4", "bare-path": "^3.0.0", "bare-stream": "^2.6.4", "bare-url": "^2.2.2", "fast-fifo": "^1.3.2" }, "peerDependencies": { "bare-buffer": "*" }, "optionalPeers": ["bare-buffer"] }, "sha512-aTvMFUWkBmjzKtEQMDGGDNF8bkfpD5N1b/FCwt7A3wrU4t1o/e/85Wzkluh6JlODCjqVESYCkQCdTXqZ9G7VFg=="],
+
+    "bare-os": ["bare-os@3.9.3", "", {}, "sha512-fF4Q7QsyKVF5Rj0qvI8BgUNjqzC2JvQlpTaPLjVJVxYVUX5Zr9un+y3w1HmA4nNKdFmRBT8z/WmrjvXzXVerKQ=="],
+
+    "bare-path": ["bare-path@3.0.1", "", { "dependencies": { "bare-os": "^3.0.1" } }, "sha512-ghj2DSK/2e99a1anTVPCV4m4YIYtrbXhfM7V3D7XZLOTsybnYyaJloymGqssQc8l/or0UoDyRtNQkmkEF/ysgQ=="],
+
+    "bare-stream": ["bare-stream@2.13.3", "", { "dependencies": { "b4a": "^1.8.1", "streamx": "^2.25.0", "teex": "^1.0.1" }, "peerDependencies": { "bare-abort-controller": "*", "bare-buffer": "*", "bare-events": "*" }, "optionalPeers": ["bare-abort-controller", "bare-buffer", "bare-events"] }, "sha512-Kc+brLqvEqGkjyfiwJmImAOqLZL7OsoLKuavx+hJjgVV3nLTOjloJyPMFxjUPerGGHrNH0fLU06jjykMLWrERQ=="],
+
+    "bare-url": ["bare-url@2.4.5", "", { "dependencies": { "bare-path": "^3.0.0" } }, "sha512-K+y9xF1tN+CdPu4qWwr0QiK1Al07eFPGYK5M2pDXcmHdMdgC/tT/bpmMe1hrmRHaidKLkXrC+cRNYf3XVDUhSQ=="],
+
+    "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
+
+    "baseline-browser-mapping": ["baseline-browser-mapping@2.10.40", "", { "bin": { "baseline-browser-mapping": "dist/cli.cjs" } }, "sha512-BSSLZ9/Cjjv7Gtj5B68ZzXcXUg8iOf3fme+FCuh8rC/Go+Kmh8cox7M3A8dolou16s64QjLPOSdngh7GxXvkSw=="],
+
+    "basic-ftp": ["basic-ftp@5.3.1", "", {}, "sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw=="],
+
+    "better-opn": ["better-opn@3.0.2", "", { "dependencies": { "open": "^8.0.4" } }, "sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ=="],
+
+    "better-sqlite3": ["better-sqlite3@12.11.1", "", { "dependencies": { "bindings": "^1.5.0", "prebuild-install": "^7.1.1" } }, "sha512-dq9AtApgg5PGFtBzPFSBl3HZQjHok5gaQCM6zh2Yk0aSmDCs1CbnVI8/HgASQkNKsWFpseIO9beg5xxpYhbIfA=="],
+
+    "big-integer": ["big-integer@1.6.52", "", {}, "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg=="],
+
+    "bignumber.js": ["bignumber.js@9.3.1", "", {}, "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ=="],
+
+    "binary": ["binary@0.3.0", "", { "dependencies": { "buffers": "~0.1.1", "chainsaw": "~0.1.0" } }, "sha512-D4H1y5KYwpJgK8wk1Cue5LLPgmwHKYSChkbspQg5JtVuR5ulGckxfR62H3AE9UDkdMC8yyXlqYihuz3Aqg2XZg=="],
+
+    "binary-extensions": ["binary-extensions@2.3.0", "", {}, "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw=="],
+
+    "binaryextensions": ["binaryextensions@6.11.0", "", { "dependencies": { "editions": "^6.21.0" } }, "sha512-sXnYK/Ij80TO3lcqZVV2YgfKN5QjUWIRk/XSm2J/4bd/lPko3lvk0O4ZppH6m+6hB2/GTu+ptNwVFe1xh+QLQw=="],
+
+    "bindings": ["bindings@1.5.0", "", { "dependencies": { "file-uri-to-path": "1.0.0" } }, "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ=="],
+
+    "bl": ["bl@4.1.0", "", { "dependencies": { "buffer": "^5.5.0", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w=="],
+
+    "bluebird": ["bluebird@3.4.7", "", {}, "sha512-iD3898SR7sWVRHbiQv+sHUtHnMvC1o3nW5rAcqnq3uOn07DSAppZYUkIGslDz6gXC7HfunPe7YVBgoEJASPcHA=="],
+
+    "bmp-ts": ["bmp-ts@1.0.9", "", {}, "sha512-cTEHk2jLrPyi+12M3dhpEbnnPOsaZuq7C45ylbbQIiWgDFZq4UVYPEY5mlqjvsj/6gJv9qX5sa+ebDzLXT28Vw=="],
+
+    "body-parser": ["body-parser@2.3.0", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^2.0.0", "debug": "^4.4.3", "http-errors": "^2.0.1", "iconv-lite": "^0.7.2", "on-finished": "^2.4.1", "qs": "^6.15.2", "raw-body": "^3.0.2", "type-is": "^2.1.0" } }, "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw=="],
+
+    "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="],
+
+    "boundary": ["boundary@2.0.0", "", {}, "sha512-rJKn5ooC9u8q13IMCrW0RSp31pxBCHE3y9V/tp3TdWSLf8Em3p6Di4NBpfzbJge9YjjFEsD0RtFEjtvHL5VyEA=="],
+
+    "bowser": ["bowser@2.14.1", "", {}, "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg=="],
+
+    "brace-expansion": ["brace-expansion@1.1.15", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg=="],
+
+    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+
+    "browser-stdout": ["browser-stdout@1.3.1", "", {}, "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw=="],
+
+    "browserslist": ["browserslist@4.28.4", "", { "dependencies": { "baseline-browser-mapping": "^2.10.38", "caniuse-lite": "^1.0.30001799", "electron-to-chromium": "^1.5.376", "node-releases": "^2.0.48", "update-browserslist-db": "^1.2.3" }, "bin": { "browserslist": "cli.js" } }, "sha512-MTc8i/x9jBQd1iMw2CFGS+rwMa07eYjLR0CCTLDACl9xhxy+nIs3KeML/biicXtk9JrZ6dnnTatmc7ErPXIxqw=="],
+
+    "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
+
+    "buffer-crc32": ["buffer-crc32@1.0.0", "", {}, "sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w=="],
+
+    "buffer-equal-constant-time": ["buffer-equal-constant-time@1.0.1", "", {}, "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="],
+
+    "buffer-indexof-polyfill": ["buffer-indexof-polyfill@1.0.2", "", {}, "sha512-I7wzHwA3t1/lwXQh+A5PbNvJxgfo5r3xulgpYDB5zckTu/Z9oUK9biouBKQUjEqzaz3HnAT6TYoovmE+GqSf7A=="],
+
+    "buffers": ["buffers@0.1.1", "", {}, "sha512-9q/rDEGSb/Qsvv2qvzIzdluL5k7AaJOTrw23z9reQthrbF7is4CtlT0DXyO1oei2DCp4uojjzQ7igaSHp1kAEQ=="],
+
+    "bun-ffi-structs": ["bun-ffi-structs@0.1.2", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-Lh1oQAYHDcnesJauieA4UNkWGXY9hYck7OA5IaRwE3Bp6K2F2pJSNYqq+hIy7P3uOvo3km3oxS8304g5gDMl/w=="],
+
+    "bun-types": ["bun-types@1.3.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="],
+
+    "bun-webgpu": ["bun-webgpu@0.1.5", "", { "dependencies": { "@webgpu/types": "^0.1.60" }, "optionalDependencies": { "bun-webgpu-darwin-arm64": "^0.1.5", "bun-webgpu-darwin-x64": "^0.1.5", "bun-webgpu-linux-x64": "^0.1.5", "bun-webgpu-win32-x64": "^0.1.5" } }, "sha512-91/K6S5whZKX7CWAm9AylhyKrLGRz6BUiiPiM/kXadSnD4rffljCD/q9cNFftm5YXhx4MvLqw33yEilxogJvwA=="],
+
+    "bun-webgpu-darwin-arm64": ["bun-webgpu-darwin-arm64@0.1.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-mRrFFyHzPWjsTRidAZBRcu808CPQBOUL0P6b4nxLhp+XHcV/mbUHERZMgW9s58tsojQfSdzschiQa8q+JCgRWA=="],
+
+    "bun-webgpu-darwin-x64": ["bun-webgpu-darwin-x64@0.1.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-g0NXGNgvaVCSH/jCWWlfdiquOHkbUN6vP4zqzSkIxWKQeLnqm3oADcok7SO3yIgI7v5mKpRc/ks7NDEKNH+jNQ=="],
+
+    "bun-webgpu-linux-x64": ["bun-webgpu-linux-x64@0.1.7", "", { "os": "linux", "cpu": "x64" }, "sha512-UEP7UZdEhx9otvkZczjsszL8ZVlrODANQvgl+C88/bNVmxDoFi7w1fWzGi1sZyakiETjmtFDq2/xCLhbSZxjqw=="],
+
+    "bun-webgpu-win32-x64": ["bun-webgpu-win32-x64@0.1.7", "", { "os": "win32", "cpu": "x64" }, "sha512-KZktiFkBz6sN7PEm1NVdeaLP5Q5X/PlSHZqefY4nNuWtf0LNvh54NhZe7yVv/Plz/nGbv92b0KHMBY3ki/pp6g=="],
+
+    "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="],
+
+    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
+
+    "c8": ["c8@10.1.3", "", { "dependencies": { "@bcoe/v8-coverage": "^1.0.1", "@istanbuljs/schema": "^0.1.3", "find-up": "^5.0.0", "foreground-child": "^3.1.1", "istanbul-lib-coverage": "^3.2.0", "istanbul-lib-report": "^3.0.1", "istanbul-reports": "^3.1.6", "test-exclude": "^7.0.1", "v8-to-istanbul": "^9.0.0", "yargs": "^17.7.2", "yargs-parser": "^21.1.1" }, "peerDependencies": { "monocart-coverage-reports": "^2" }, "optionalPeers": ["monocart-coverage-reports"], "bin": { "c8": "bin/c8.js" } }, "sha512-LvcyrOAaOnrrlMpW22n690PUvxiq4Uf9WMhQwNJ9vgagkL/ph1+D4uvjvDA5XCbykrc0sx+ay6pVi9YZ1GnhyA=="],
+
+    "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
+
+    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
+
+    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],
+
+    "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
+
+    "camelcase": ["camelcase@6.3.0", "", {}, "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA=="],
+
+    "camelize": ["camelize@1.0.1", "", {}, "sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ=="],
+
+    "caniuse-lite": ["caniuse-lite@1.0.30001800", "", {}, "sha512-MMHtuAz9Ys840zAY5F4k6fV5GaivZ9sPk+nz0mY+GYVzRBnYkN0mpqkSR92oWRQ19yQWo4HvBV/FnC16AJX8MA=="],
+
+    "case-anything": ["case-anything@2.1.13", "", {}, "sha512-zlOQ80VrQ2Ue+ymH5OuM/DlDq64mEm+B9UTdHULv5osUMD6HalNTblf2b1u/m6QecjsnOkBpqVZ+XPwIVsy7Ng=="],
+
+    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
+
+    "ce-la-react": ["ce-la-react@0.3.2", "", { "peerDependencies": { "react": ">=17.0.0" } }, "sha512-QJ6k4lOD/btI08xG8jBPxRCGXvCnusGGkTsiXk0u3NqUu/W+BXRnFD4PYjwtqh8AWmGa5LDbGk0fLQsqr0nSMA=="],
+
+    "chai": ["chai@4.5.0", "", { "dependencies": { "assertion-error": "^1.1.0", "check-error": "^1.0.3", "deep-eql": "^4.1.3", "get-func-name": "^2.0.2", "loupe": "^2.3.6", "pathval": "^1.1.1", "type-detect": "^4.1.0" } }, "sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw=="],
+
+    "chainsaw": ["chainsaw@0.1.0", "", { "dependencies": { "traverse": ">=0.3.0 <0.4" } }, "sha512-75kWfWt6MEKNC8xYXIdRpDehRYY/tNSgwKaJq+dbbDcxORuVrrQ+SEHoWsniVn9XPYfP4gmdWIeDk/4YNp1rNQ=="],
+
+    "chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
+
+    "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
+
+    "character-entities-html4": ["character-entities-html4@2.1.0", "", {}, "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA=="],
+
+    "character-entities-legacy": ["character-entities-legacy@3.0.0", "", {}, "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ=="],
+
+    "character-reference-invalid": ["character-reference-invalid@2.0.1", "", {}, "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw=="],
+
+    "chardet": ["chardet@2.2.0", "", {}, "sha512-rddelWYNPRrXq6PtNEN2S3f6t9ILzvqaN5pVgi4kqt9jHQaXIial9PznB5iSPVlQSLNaaH22ItWz3EJtQ10+OA=="],
+
+    "chat": ["chat@4.32.0", "", { "dependencies": { "@workflow/serde": "4.1.0-beta.2", "mdast-util-to-string": "^4.0.0", "remark-gfm": "^4.0.0", "remark-parse": "^11.0.0", "remark-stringify": "^11.0.0", "remend": "^1.2.1", "unified": "^11.0.5" }, "peerDependencies": { "ai": "^6.0.182", "zod": "^3.0.0 || ^4.0.0" }, "optionalPeers": ["ai", "zod"] }, "sha512-0NlJcCLycTy8kytRsZEnW4Gzomm+SNh1Yg7y9GVYB5fTjyhOxCcnzqrythgXNn2dvv7VeihDIISpNU0WZdOKKg=="],
+
+    "check-error": ["check-error@1.0.3", "", { "dependencies": { "get-func-name": "^2.0.2" } }, "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg=="],
+
+    "cheerio": ["cheerio@1.2.0", "", { "dependencies": { "cheerio-select": "^2.1.0", "dom-serializer": "^2.0.0", "domhandler": "^5.0.3", "domutils": "^3.2.2", "encoding-sniffer": "^0.2.1", "htmlparser2": "^10.1.0", "parse5": "^7.3.0", "parse5-htmlparser2-tree-adapter": "^7.1.0", "parse5-parser-stream": "^7.1.2", "undici": "^7.19.0", "whatwg-mimetype": "^4.0.0" } }, "sha512-WDrybc/gKFpTYQutKIK6UvfcuxijIZfMfXaYm8NMsPQxSYvf+13fXUJ4rztGGbJcBQ/GF55gvrZ0Bc0bj/mqvg=="],
+
+    "cheerio-select": ["cheerio-select@2.1.0", "", { "dependencies": { "boolbase": "^1.0.0", "css-select": "^5.1.0", "css-what": "^6.1.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1" } }, "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g=="],
+
+    "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="],
+
+    "chrome-launcher": ["chrome-launcher@1.2.1", "", { "dependencies": { "@types/node": "*", "escape-string-regexp": "^4.0.0", "is-wsl": "^2.2.0", "lighthouse-logger": "^2.0.1" }, "bin": { "print-chrome-path": "bin/print-chrome-path.cjs" } }, "sha512-qmFR5PLMzHyuNJHwOloHPAHhbaNglkfeV/xDtt5b7xiFFyU1I+AZZX0PYseMuhenJSSirgxELYIbswcoc+5H4A=="],
+
+    "chromium-bidi": ["chromium-bidi@0.11.0", "", { "dependencies": { "mitt": "3.0.1", "zod": "3.23.8" }, "peerDependencies": { "devtools-protocol": "*" } }, "sha512-6CJWHkNRoyZyjV9Rwv2lYONZf1Xm0IuDyNq97nwSsxxP3wf5Bwy15K5rOvVKMtJ127jJBmxFUanSAOjgFRxgrA=="],
+
+    "ci-info": ["ci-info@3.9.0", "", {}, "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ=="],
+
+    "cjs-module-lexer": ["cjs-module-lexer@1.4.3", "", {}, "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q=="],
+
+    "class-variance-authority": ["class-variance-authority@0.7.1", "", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
+
+    "classcat": ["classcat@5.0.5", "", {}, "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w=="],
+
+    "claude-dev": ["claude-dev@workspace:apps/vscode"],
+
+    "cli-cursor": ["cli-cursor@5.0.0", "", { "dependencies": { "restore-cursor": "^5.0.0" } }, "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw=="],
+
+    "cli-spinners": ["cli-spinners@3.4.0", "", {}, "sha512-bXfOC4QcT1tKXGorxL3wbJm6XJPDqEnij2gQ2m7ESQuE+/z9YFIWnl/5RpTiKWbMq3EVKR4fRLJGn6DVfu0mpw=="],
+
+    "cli-truncate": ["cli-truncate@5.2.0", "", { "dependencies": { "slice-ansi": "^8.0.0", "string-width": "^8.2.0" } }, "sha512-xRwvIOMGrfOAnM1JYtqQImuaNtDEv9v6oIYAs4LIHwTiKee8uwvIi363igssOC0O5U04i4AlENs79LQLu9tEMw=="],
+
+    "client-only": ["client-only@0.0.1", "", {}, "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA=="],
+
+    "cline-agent-squad-plugin": ["cline-agent-squad-plugin@workspace:sdk/examples/plugins/agents-squad"],
+
+    "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="],
+
+    "clone": ["clone@2.1.2", "", {}, "sha512-3Pe/CF1Nn94hyhIYpjtiLhdCoEoz0DqQ+988E9gmeEdQZlojxnOb74wctFyuwWQHzqyf9X7C7MG8juUpqBJT8w=="],
+
+    "clone-deep": ["clone-deep@4.0.1", "", { "dependencies": { "is-plain-object": "^2.0.4", "kind-of": "^6.0.2", "shallow-clone": "^3.0.0" } }, "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ=="],
+
+    "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
+
+    "cmdk": ["cmdk@1.1.1", "", { "dependencies": { "@radix-ui/react-compose-refs": "^1.1.1", "@radix-ui/react-dialog": "^1.1.6", "@radix-ui/react-id": "^1.1.0", "@radix-ui/react-primitive": "^2.0.2" }, "peerDependencies": { "react": "^18 || ^19 || ^19.0.0-rc", "react-dom": "^18 || ^19 || ^19.0.0-rc" } }, "sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg=="],
+
+    "cockatiel": ["cockatiel@3.2.1", "", {}, "sha512-gfrHV6ZPkquExvMh9IOkKsBzNDk6sDuZ6DdBGUBkvFnTCqCxzpuq48RySgP0AnaqQkw2zynOFj9yly6T1Q2G5Q=="],
+
+    "code-block-writer": ["code-block-writer@13.0.3", "", {}, "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg=="],
+
+    "color": ["color@4.2.3", "", { "dependencies": { "color-convert": "^2.0.1", "color-string": "^1.9.0" } }, "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "color-string": ["color-string@1.9.1", "", { "dependencies": { "color-name": "^1.0.0", "simple-swizzle": "^0.2.2" } }, "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg=="],
+
+    "color-support": ["color-support@1.1.3", "", { "bin": { "color-support": "bin.js" } }, "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg=="],
+
+    "color2k": ["color2k@2.0.3", "", {}, "sha512-zW190nQTIoXcGCaU08DvVNFTmQhUpnJfVuAKfWqUQkflXKpaDdpaYoM0iluLS9lgJNHyBF58KKA2FBEwkD7wog=="],
+
+    "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="],
+
+    "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
+
+    "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
+
+    "commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="],
+
+    "compress-commons": ["compress-commons@6.0.2", "", { "dependencies": { "crc-32": "^1.2.0", "crc32-stream": "^6.0.0", "is-stream": "^2.0.1", "normalize-path": "^3.0.0", "readable-stream": "^4.0.0" } }, "sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg=="],
+
+    "compute-scroll-into-view": ["compute-scroll-into-view@3.1.1", "", {}, "sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw=="],
+
+    "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="],
+
+    "conf": ["conf@10.2.0", "", { "dependencies": { "ajv": "^8.6.3", "ajv-formats": "^2.1.1", "atomically": "^1.7.0", "debounce-fn": "^4.0.0", "dot-prop": "^6.0.1", "env-paths": "^2.2.1", "json-schema-typed": "^7.0.3", "onetime": "^5.1.2", "pkg-up": "^3.1.0", "semver": "^7.3.5" } }, "sha512-8fLl9F04EJqjSqH+QjITQfJF8BrOVaYr1jewVgSRAEWePfxT0sku4w2hrGQ60BC/TNLGQ2pgxNlTbWQmMPFvXg=="],
+
+    "consola": ["consola@3.4.2", "", {}, "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="],
+
+    "console-control-strings": ["console-control-strings@1.1.0", "", {}, "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ=="],
+
+    "content-disposition": ["content-disposition@1.1.0", "", {}, "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g=="],
+
+    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],
+
+    "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
+
+    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
+
+    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
+
+    "copy-to-clipboard": ["copy-to-clipboard@3.3.3", "", { "dependencies": { "toggle-selection": "^1.0.6" } }, "sha512-2KV8NhB5JqC3ky0r9PMCAZKbUHSwtEo4CwCs0KXgruG43gX5PMqDEBbVU4OUzw2MuAWUfsuFmWvEKG5QRfSnJA=="],
+
+    "core-js": ["core-js@3.49.0", "", {}, "sha512-es1U2+YTtzpwkxVLwAFdSpaIMyQaq0PBgm3YD1W3Qpsn1NAmO3KSgZfu+oGSWVu6NvLHoHCV/aYcsE5wiB7ALg=="],
+
+    "core-util-is": ["core-util-is@1.0.3", "", {}, "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="],
+
+    "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
+
+    "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="],
+
+    "cosmiconfig": ["cosmiconfig@9.0.2", "", { "dependencies": { "env-paths": "^2.2.1", "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-gtTZxTDau1wL7Y7zifc2dd8jHSK/k6BTx/2Xp/BpdlAdnlYWFVt7qhJqgwi7637yRwRQ3qL4ZidbB4I8tA5VOg=="],
+
+    "crc-32": ["crc-32@1.2.2", "", { "bin": { "crc32": "bin/crc32.njs" } }, "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ=="],
+
+    "crc32-stream": ["crc32-stream@6.0.0", "", { "dependencies": { "crc-32": "^1.2.0", "readable-stream": "^4.0.0" } }, "sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g=="],
+
+    "create-require": ["create-require@1.1.1", "", {}, "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ=="],
+
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+
+    "css-color-keywords": ["css-color-keywords@1.0.0", "", {}, "sha512-FyyrDHZKEjXDpNJYvVsV960FiqQyXc/LlYmsxl2BcdMb2WPx0OGRVgTg55rPSyLSNMqP52R9r8geSp7apN3Ofg=="],
+
+    "css-in-js-utils": ["css-in-js-utils@3.1.0", "", { "dependencies": { "hyphenate-style-name": "^1.0.3" } }, "sha512-fJAcud6B3rRu+KHYk+Bwf+WFL2MDCJJ1XG9x137tJQ0xYxor7XziQtuGFbWNdqrvF4Tk26O3H73nfVqXt/fW1A=="],
+
+    "css-select": ["css-select@5.2.2", "", { "dependencies": { "boolbase": "^1.0.0", "css-what": "^6.1.0", "domhandler": "^5.0.2", "domutils": "^3.0.1", "nth-check": "^2.0.1" } }, "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw=="],
+
+    "css-to-react-native": ["css-to-react-native@3.2.0", "", { "dependencies": { "camelize": "^1.0.0", "css-color-keywords": "^1.0.0", "postcss-value-parser": "^4.0.2" } }, "sha512-e8RKaLXMOFii+02mOlqwjbD00KSEKqblnpO9e++1aXS1fPQOpS1YoqdVHBqPjHNoxeF2mimzVqawm2KCbEdtHQ=="],
+
+    "css-tree": ["css-tree@1.1.3", "", { "dependencies": { "mdn-data": "2.0.14", "source-map": "^0.6.1" } }, "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q=="],
+
+    "css-what": ["css-what@6.2.2", "", {}, "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA=="],
+
+    "css.escape": ["css.escape@1.5.1", "", {}, "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg=="],
+
+    "cssesc": ["cssesc@3.0.0", "", { "bin": { "cssesc": "bin/cssesc" } }, "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg=="],
+
+    "cssstyle": ["cssstyle@4.6.0", "", { "dependencies": { "@asamuzakjp/css-color": "^3.2.0", "rrweb-cssom": "^0.8.0" } }, "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg=="],
+
+    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
+
+    "cytoscape": ["cytoscape@3.34.0", "", {}, "sha512-62rNSrioXw93uliKFBwjukeQyeWwH2PqDrTac31r2P6464u3AUvTk0xS4LVvT251g7IgkFunrI48ZEZGjywSOg=="],
+
+    "cytoscape-cose-bilkent": ["cytoscape-cose-bilkent@4.1.0", "", { "dependencies": { "cose-base": "^1.0.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ=="],
+
+    "cytoscape-fcose": ["cytoscape-fcose@2.2.0", "", { "dependencies": { "cose-base": "^2.2.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ=="],
+
+    "d3": ["d3@7.9.0", "", { "dependencies": { "d3-array": "3", "d3-axis": "3", "d3-brush": "3", "d3-chord": "3", "d3-color": "3", "d3-contour": "4", "d3-delaunay": "6", "d3-dispatch": "3", "d3-drag": "3", "d3-dsv": "3", "d3-ease": "3", "d3-fetch": "3", "d3-force": "3", "d3-format": "3", "d3-geo": "3", "d3-hierarchy": "3", "d3-interpolate": "3", "d3-path": "3", "d3-polygon": "3", "d3-quadtree": "3", "d3-random": "3", "d3-scale": "4", "d3-scale-chromatic": "3", "d3-selection": "3", "d3-shape": "3", "d3-time": "3", "d3-time-format": "4", "d3-timer": "3", "d3-transition": "3", "d3-zoom": "3" } }, "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA=="],
+
+    "d3-array": ["d3-array@3.2.4", "", { "dependencies": { "internmap": "1 - 2" } }, "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg=="],
+
+    "d3-axis": ["d3-axis@3.0.0", "", {}, "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw=="],
+
+    "d3-brush": ["d3-brush@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "3", "d3-transition": "3" } }, "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ=="],
+
+    "d3-chord": ["d3-chord@3.0.1", "", { "dependencies": { "d3-path": "1 - 3" } }, "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g=="],
+
+    "d3-color": ["d3-color@3.1.0", "", {}, "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA=="],
+
+    "d3-contour": ["d3-contour@4.0.2", "", { "dependencies": { "d3-array": "^3.2.0" } }, "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA=="],
+
+    "d3-delaunay": ["d3-delaunay@6.0.4", "", { "dependencies": { "delaunator": "5" } }, "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A=="],
+
+    "d3-dispatch": ["d3-dispatch@3.0.1", "", {}, "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg=="],
+
+    "d3-drag": ["d3-drag@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-selection": "3" } }, "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg=="],
+
+    "d3-dsv": ["d3-dsv@3.0.1", "", { "dependencies": { "commander": "7", "iconv-lite": "0.6", "rw": "1" }, "bin": { "csv2json": "bin/dsv2json.js", "csv2tsv": "bin/dsv2dsv.js", "dsv2dsv": "bin/dsv2dsv.js", "dsv2json": "bin/dsv2json.js", "json2csv": "bin/json2dsv.js", "json2dsv": "bin/json2dsv.js", "json2tsv": "bin/json2dsv.js", "tsv2csv": "bin/dsv2dsv.js", "tsv2json": "bin/dsv2json.js" } }, "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q=="],
+
+    "d3-ease": ["d3-ease@3.0.1", "", {}, "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w=="],
+
+    "d3-fetch": ["d3-fetch@3.0.1", "", { "dependencies": { "d3-dsv": "1 - 3" } }, "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw=="],
+
+    "d3-force": ["d3-force@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-quadtree": "1 - 3", "d3-timer": "1 - 3" } }, "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg=="],
+
+    "d3-format": ["d3-format@3.1.2", "", {}, "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg=="],
+
+    "d3-geo": ["d3-geo@3.1.1", "", { "dependencies": { "d3-array": "2.5.0 - 3" } }, "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q=="],
+
+    "d3-hierarchy": ["d3-hierarchy@3.1.2", "", {}, "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA=="],
+
+    "d3-interpolate": ["d3-interpolate@3.0.1", "", { "dependencies": { "d3-color": "1 - 3" } }, "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g=="],
+
+    "d3-path": ["d3-path@3.1.0", "", {}, "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ=="],
+
+    "d3-polygon": ["d3-polygon@3.0.1", "", {}, "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg=="],
+
+    "d3-quadtree": ["d3-quadtree@3.0.1", "", {}, "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw=="],
+
+    "d3-random": ["d3-random@3.0.1", "", {}, "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ=="],
+
+    "d3-sankey": ["d3-sankey@0.12.3", "", { "dependencies": { "d3-array": "1 - 2", "d3-shape": "^1.2.0" } }, "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ=="],
+
+    "d3-scale": ["d3-scale@4.0.2", "", { "dependencies": { "d3-array": "2.10.0 - 3", "d3-format": "1 - 3", "d3-interpolate": "1.2.0 - 3", "d3-time": "2.1.1 - 3", "d3-time-format": "2 - 4" } }, "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ=="],
+
+    "d3-scale-chromatic": ["d3-scale-chromatic@3.1.0", "", { "dependencies": { "d3-color": "1 - 3", "d3-interpolate": "1 - 3" } }, "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ=="],
+
+    "d3-selection": ["d3-selection@3.0.0", "", {}, "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ=="],
+
+    "d3-shape": ["d3-shape@3.2.0", "", { "dependencies": { "d3-path": "^3.1.0" } }, "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA=="],
+
+    "d3-time": ["d3-time@3.1.0", "", { "dependencies": { "d3-array": "2 - 3" } }, "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q=="],
+
+    "d3-time-format": ["d3-time-format@4.1.0", "", { "dependencies": { "d3-time": "1 - 3" } }, "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg=="],
+
+    "d3-timer": ["d3-timer@3.0.1", "", {}, "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA=="],
+
+    "d3-transition": ["d3-transition@3.0.1", "", { "dependencies": { "d3-color": "1 - 3", "d3-dispatch": "1 - 3", "d3-ease": "1 - 3", "d3-interpolate": "1 - 3", "d3-timer": "1 - 3" }, "peerDependencies": { "d3-selection": "2 - 3" } }, "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w=="],
+
+    "d3-zoom": ["d3-zoom@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "2 - 3", "d3-transition": "2 - 3" } }, "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw=="],
+
+    "dagre-d3-es": ["dagre-d3-es@7.0.14", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg=="],
+
+    "data-uri-to-buffer": ["data-uri-to-buffer@4.0.1", "", {}, "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A=="],
+
+    "data-urls": ["data-urls@5.0.0", "", { "dependencies": { "whatwg-mimetype": "^4.0.0", "whatwg-url": "^14.0.0" } }, "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg=="],
+
+    "date-fns": ["date-fns@4.1.0", "", {}, "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg=="],
+
+    "date-fns-jalali": ["date-fns-jalali@4.1.0-0", "", {}, "sha512-hTIP/z+t+qKwBDcmmsnmjWTduxCg+5KfdqWQvb2X/8C9+knYY6epN/pfxdDuyVlSVeFz0sM5eEfwIUQ70U4ckg=="],
+
+    "dayjs": ["dayjs@1.11.21", "", {}, "sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA=="],
+
+    "debounce": ["debounce@2.2.0", "", {}, "sha512-Xks6RUDLZFdz8LIdR6q0MTH44k7FikOmnh5xkSjMig6ch45afc8sjTjRQf3P6ax8dMgcQrYO/AR2RGWURrruqw=="],
+
+    "debounce-fn": ["debounce-fn@4.0.0", "", { "dependencies": { "mimic-fn": "^3.0.0" } }, "sha512-8pYCQiL9Xdcg0UPSD3d+0KMlOjp+KGU5EPwYddgzQ7DATsg4fuUDjQtsYLmWjnk2obnNHgV3vE2Y4jejSOJVBQ=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "decamelize": ["decamelize@4.0.0", "", {}, "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ=="],
+
+    "decimal.js": ["decimal.js@10.6.0", "", {}, "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg=="],
+
+    "decimal.js-light": ["decimal.js-light@2.5.1", "", {}, "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg=="],
+
+    "decode-named-character-reference": ["decode-named-character-reference@1.3.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q=="],
+
+    "decompress-response": ["decompress-response@6.0.0", "", { "dependencies": { "mimic-response": "^3.1.0" } }, "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ=="],
+
+    "dedent": ["dedent@1.7.2", "", { "peerDependencies": { "babel-plugin-macros": "^3.1.0" }, "optionalPeers": ["babel-plugin-macros"] }, "sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA=="],
+
+    "deep-eql": ["deep-eql@4.1.4", "", { "dependencies": { "type-detect": "^4.0.0" } }, "sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg=="],
+
+    "deep-extend": ["deep-extend@0.6.0", "", {}, "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA=="],
+
+    "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
+
+    "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
+
+    "default-browser": ["default-browser@5.5.0", "", { "dependencies": { "bundle-name": "^4.1.0", "default-browser-id": "^5.0.0" } }, "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw=="],
+
+    "default-browser-id": ["default-browser-id@5.0.1", "", {}, "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q=="],
+
+    "default-shell": ["default-shell@2.2.0", "", {}, "sha512-sPpMZcVhRQ0nEMDtuMJ+RtCxt7iHPAMBU+I4tAlo5dU1sjRpNax0crj6nR3qKpvVnckaQ9U38enXcwW9nZJeCw=="],
+
+    "define-lazy-prop": ["define-lazy-prop@3.0.0", "", {}, "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="],
+
+    "degenerator": ["degenerator@5.0.1", "", { "dependencies": { "ast-types": "^0.13.4", "escodegen": "^2.1.0", "esprima": "^4.0.1" } }, "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ=="],
+
+    "delaunator": ["delaunator@5.1.0", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ=="],
+
+    "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
+
+    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
+
+    "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
+
+    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
+
+    "detect-node-es": ["detect-node-es@1.1.0", "", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="],
+
+    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
+
+    "devtools-protocol": ["devtools-protocol@0.0.1367902", "", {}, "sha512-XxtPuC3PGakY6PD7dG66/o8KwJ/LkH2/EKe19Dcw58w53dv4/vSQEkn/SzuyhHE2q4zPgCkxQBxus3VV4ql+Pg=="],
+
+    "diff": ["diff@8.0.4", "", {}, "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw=="],
+
+    "diff-sequences": ["diff-sequences@29.6.3", "", {}, "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q=="],
+
+    "dify-ai-provider": ["dify-ai-provider@1.1.1", "", { "dependencies": { "@ai-sdk/provider": "^2.0.0", "@ai-sdk/provider-utils": "^3.0.3", "zod": "^3.25.76" } }, "sha512-a32UiyP6AjElbic6Aao7opBCCM+5RwD34TP5YczE70UW/UvwucRAK76UMDVMAM6gqhc3FvaBeSu3NcK+NAUg4g=="],
+
+    "dingbat-to-unicode": ["dingbat-to-unicode@1.0.1", "", {}, "sha512-98l0sW87ZT58pU4i61wa2OHwxbiYSbuxsCBozaVnYX2iCnr3bLM3fIes1/ej7h1YdOKuKt/MLs706TVnALA65w=="],
+
+    "discord-api-types": ["discord-api-types@0.37.120", "", {}, "sha512-7xpNK0EiWjjDFp2nAhHXezE4OUWm7s1zhc/UXXN6hnFFU8dfoPHgV0Hx0RPiCa3ILRpdeh152icc68DGCyXYIw=="],
+
+    "discord-interactions": ["discord-interactions@4.4.0", "", {}, "sha512-jjJx8iwAeJcj8oEauV43fue9lNqkf38fy60aSs2+G8D1nJmDxUIrk08o3h0F3wgwuBWWJUZO+X/VgfXsxpCiJA=="],
+
+    "discord.js": ["discord.js@14.26.4", "", { "dependencies": { "@discordjs/builders": "^1.14.1", "@discordjs/collection": "1.5.3", "@discordjs/formatters": "^0.6.2", "@discordjs/rest": "^2.6.1", "@discordjs/util": "^1.2.0", "@discordjs/ws": "^1.2.3", "@sapphire/snowflake": "3.5.3", "discord-api-types": "^0.38.40", "fast-deep-equal": "3.1.3", "lodash.snakecase": "4.1.1", "magic-bytes.js": "^1.13.0", "tslib": "^2.6.3", "undici": "6.24.1" } }, "sha512-4oBp8tc6Kf8IDBwAHhbsMaAqx1b5fob9SNasZT7V6yyyUydoO5i5fGuX7TmvRtR+q/WgKRnRViRoAWnG7fNyvA=="],
+
+    "doctrine": ["doctrine@3.0.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w=="],
+
+    "dom-accessibility-api": ["dom-accessibility-api@0.6.3", "", {}, "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w=="],
+
+    "dom-helpers": ["dom-helpers@5.2.1", "", { "dependencies": { "@babel/runtime": "^7.8.7", "csstype": "^3.0.2" } }, "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA=="],
+
+    "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="],
+
+    "domelementtype": ["domelementtype@2.3.0", "", {}, "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw=="],
+
+    "domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="],
+
+    "dompurify": ["dompurify@3.4.11", "", { "optionalDependencies": { "@types/trusted-types": "^2.0.7" } }, "sha512-zhlUV12GsaRzMsf9q5M254YhA4+VuF0fG+QFqu6aYpoGlKtz+w8//jBcGVYBgQkR5GHjUomejY84AV+/uPbWdw=="],
+
+    "domutils": ["domutils@3.2.2", "", { "dependencies": { "dom-serializer": "^2.0.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3" } }, "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw=="],
+
+    "dot-prop": ["dot-prop@6.0.1", "", { "dependencies": { "is-obj": "^2.0.0" } }, "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA=="],
+
+    "dotenv": ["dotenv@17.4.2", "", {}, "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw=="],
+
+    "dprint-node": ["dprint-node@1.0.8", "", { "dependencies": { "detect-libc": "^1.0.3" } }, "sha512-iVKnUtYfGrYcW1ZAlfR/F59cUVL8QIhWoBJoSjkkdua/dkWIgjZfiLMeTjiB06X0ZLkQ0M2C1VbUj/CxkIf1zg=="],
+
+    "duck": ["duck@0.1.12", "", { "dependencies": { "underscore": "^1.13.1" } }, "sha512-wkctla1O6VfP89gQ+J/yDesM0S7B7XLXjKGzXxMDVFg7uEn706niAtyYovKbyq1oT9YwDcly721/iUWoc8MVRg=="],
+
+    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
+
+    "duplexer2": ["duplexer2@0.1.4", "", { "dependencies": { "readable-stream": "^2.0.2" } }, "sha512-asLFVfWWtJ90ZyOUHMqk7/S2w2guQKxUI2itj3d92ADHhxUSbCMGi1f1cBcJ7xM1To+pE/Khbwo1yuNbMEPKeA=="],
+
+    "eastasianwidth": ["eastasianwidth@0.2.0", "", {}, "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="],
+
+    "ecdsa-sig-formatter": ["ecdsa-sig-formatter@1.0.11", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ=="],
+
+    "editions": ["editions@6.22.0", "", { "dependencies": { "version-range": "^4.15.0" } }, "sha512-UgGlf8IW75je7HZjNDpJdCv4cGJWIi6yumFdZ0R7A8/CIhQiWUjyGLCxdHpd8bmyD1gnkfUNK0oeOXqUS2cpfQ=="],
+
+    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
+
+    "eight-colors": ["eight-colors@1.3.3", "", {}, "sha512-4B54S2Qi4pJjeHmCbDIsveQZWQ/TSSQng4ixYJ9/SYHHpeS5nYK0pzcHvWzWUfRsvJQjwoIENhAwqg59thQceg=="],
+
+    "electron-to-chromium": ["electron-to-chromium@1.5.384", "", {}, "sha512-g6KAKY1vkYsADvSPWvdJsuYT0ixdcu6lUtD9P/wJKGBEDlZVXh2AX42j1mPqqaQPDluWjara9ziQ7xqAeXCt5A=="],
+
+    "embla-carousel": ["embla-carousel@8.6.0", "", {}, "sha512-SjWyZBHJPbqxHOzckOfo8lHisEaJWmwd23XppYFYVh10bU66/Pn5tkVkbkCMZVdbUE5eTCI2nD8OyIP4Z+uwkA=="],
+
+    "embla-carousel-react": ["embla-carousel-react@8.6.0", "", { "dependencies": { "embla-carousel": "8.6.0", "embla-carousel-reactive-utils": "8.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.1 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-0/PjqU7geVmo6F734pmPqpyHqiM99olvyecY7zdweCw+6tKEXnrE90pBiBbMMU8s5tICemzpQ3hi5EpxzGW+JA=="],
+
+    "embla-carousel-reactive-utils": ["embla-carousel-reactive-utils@8.6.0", "", { "peerDependencies": { "embla-carousel": "8.6.0" } }, "sha512-fMVUDUEx0/uIEDM0Mz3dHznDhfX+znCCDCeIophYb1QGVM7YThSWX+wz11zlYwWFOr74b4QLGg0hrGPJeG2s4A=="],
+
+    "emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="],
+
+    "enabled": ["enabled@2.0.0", "", {}, "sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ=="],
+
+    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
+
+    "encoding-sniffer": ["encoding-sniffer@0.2.1", "", { "dependencies": { "iconv-lite": "^0.6.3", "whatwg-encoding": "^3.1.1" } }, "sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw=="],
+
+    "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="],
+
+    "enhanced-resolve": ["enhanced-resolve@5.21.6", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-aNnGCvbJ/RIyWo1IuhNdVjnNF+EjH9wpzpNHt+ci/m9He9LJvUN8wrCcXjp9cWsGNAuvSpVFTx/vraAFQ8qGjQ=="],
+
+    "enquirer": ["enquirer@2.4.1", "", { "dependencies": { "ansi-colors": "^4.1.1", "strip-ansi": "^6.0.1" } }, "sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ=="],
+
+    "entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
+
+    "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="],
+
+    "environment": ["environment@1.1.0", "", {}, "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q=="],
+
+    "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="],
+
+    "error-stack-parser": ["error-stack-parser@2.1.4", "", { "dependencies": { "stackframe": "^1.3.4" } }, "sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ=="],
+
+    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
+
+    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
+
+    "es-module-lexer": ["es-module-lexer@2.3.0", "", {}, "sha512-KLdwQm2NvGLDkQDCGvmiQrhkd0JbMzXthwQAUgWjQuQdBLFa3eiBP5arXZyA+f8x+x7OXgud6bq2rxjGtHV2tw=="],
+
+    "es-object-atoms": ["es-object-atoms@1.1.2", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="],
+
+    "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="],
+
+    "es-toolkit": ["es-toolkit@1.49.0", "", {}, "sha512-G5iZ6Pc/FNRY/soKZHC+TxGDD83rHUDXxzaWhGCX44vAv/tMs56WMusnm/KMNK+luUPsgA9U28cGr4RDlSzL2g=="],
+
+    "esbuild": ["esbuild@0.27.7", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.7", "@esbuild/android-arm": "0.27.7", "@esbuild/android-arm64": "0.27.7", "@esbuild/android-x64": "0.27.7", "@esbuild/darwin-arm64": "0.27.7", "@esbuild/darwin-x64": "0.27.7", "@esbuild/freebsd-arm64": "0.27.7", "@esbuild/freebsd-x64": "0.27.7", "@esbuild/linux-arm": "0.27.7", "@esbuild/linux-arm64": "0.27.7", "@esbuild/linux-ia32": "0.27.7", "@esbuild/linux-loong64": "0.27.7", "@esbuild/linux-mips64el": "0.27.7", "@esbuild/linux-ppc64": "0.27.7", "@esbuild/linux-riscv64": "0.27.7", "@esbuild/linux-s390x": "0.27.7", "@esbuild/linux-x64": "0.27.7", "@esbuild/netbsd-arm64": "0.27.7", "@esbuild/netbsd-x64": "0.27.7", "@esbuild/openbsd-arm64": "0.27.7", "@esbuild/openbsd-x64": "0.27.7", "@esbuild/openharmony-arm64": "0.27.7", "@esbuild/sunos-x64": "0.27.7", "@esbuild/win32-arm64": "0.27.7", "@esbuild/win32-ia32": "0.27.7", "@esbuild/win32-x64": "0.27.7" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w=="],
+
+    "esbuild-register": ["esbuild-register@3.6.0", "", { "dependencies": { "debug": "^4.3.4" }, "peerDependencies": { "esbuild": ">=0.12 <1" } }, "sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg=="],
+
+    "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
+
+    "escape-carriage": ["escape-carriage@1.3.1", "", {}, "sha512-GwBr6yViW3ttx1kb7/Oh+gKQ1/TrhYwxKqVmg5gS+BK+Qe2KrOa/Vh7w3HPBvgGf0LfcDGoY9I6NHKoA5Hozhw=="],
+
+    "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],
+
+    "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
+
+    "escodegen": ["escodegen@2.1.0", "", { "dependencies": { "esprima": "^4.0.1", "estraverse": "^5.2.0", "esutils": "^2.0.2" }, "optionalDependencies": { "source-map": "~0.6.1" }, "bin": { "esgenerate": "bin/esgenerate.js", "escodegen": "bin/escodegen.js" } }, "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w=="],
+
+    "eslint": ["eslint@9.39.4", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.21.2", "@eslint/config-helpers": "^0.4.2", "@eslint/core": "^0.17.0", "@eslint/eslintrc": "^3.3.5", "@eslint/js": "9.39.4", "@eslint/plugin-kit": "^0.4.1", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "ajv": "^6.14.0", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.4.0", "eslint-visitor-keys": "^4.2.1", "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.5", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ=="],
+
+    "eslint-plugin-react-hooks": ["eslint-plugin-react-hooks@7.1.1", "", { "dependencies": { "@babel/core": "^7.24.4", "@babel/parser": "^7.24.4", "hermes-parser": "^0.25.1", "zod": "^3.25.0 || ^4.0.0", "zod-validation-error": "^3.5.0 || ^4.0.0" }, "peerDependencies": { "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0" } }, "sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g=="],
+
+    "eslint-plugin-react-refresh": ["eslint-plugin-react-refresh@0.5.3", "", { "peerDependencies": { "eslint": "^9 || ^10" } }, "sha512-5EMmLCV98Pi4o/f/3DP/v/tNqLHMIc9I8LKClNDWhZ9JTho89/kQcitCXQBMG7sAfVRK0Ie3T2EDOzp1YXYiVA=="],
+
+    "eslint-scope": ["eslint-scope@8.4.0", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg=="],
+
+    "eslint-visitor-keys": ["eslint-visitor-keys@4.2.1", "", {}, "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ=="],
+
+    "espree": ["espree@10.4.0", "", { "dependencies": { "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ=="],
+
+    "esprima": ["esprima@4.0.1", "", { "bin": { "esparse": "./bin/esparse.js", "esvalidate": "./bin/esvalidate.js" } }, "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="],
+
+    "esquery": ["esquery@1.7.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g=="],
+
+    "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="],
+
+    "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
+
+    "estree-util-is-identifier-name": ["estree-util-is-identifier-name@3.0.0", "", {}, "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg=="],
+
+    "estree-walker": ["estree-walker@3.0.3", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g=="],
+
+    "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="],
+
+    "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
+
+    "event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
+
+    "eventemitter3": ["eventemitter3@4.0.7", "", {}, "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="],
+
+    "events": ["events@3.3.0", "", {}, "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="],
+
+    "events-universal": ["events-universal@1.0.1", "", { "dependencies": { "bare-events": "^2.7.0" } }, "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw=="],
+
+    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],
+
+    "eventsource-parser": ["eventsource-parser@3.1.0", "", {}, "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg=="],
+
+    "examples": ["examples@workspace:sdk/examples"],
+
+    "exceljs": ["exceljs@4.4.0", "", { "dependencies": { "archiver": "^5.0.0", "dayjs": "^1.8.34", "fast-csv": "^4.3.1", "jszip": "^3.10.1", "readable-stream": "^3.6.0", "saxes": "^5.0.1", "tmp": "^0.2.0", "unzipper": "^0.10.11", "uuid": "^8.3.0" } }, "sha512-XctvKaEMaj1Ii9oDOqbW/6e1gXknSY4g/aLCDicOXqBE4M0nRWkUu0PTp++UPNzoFY12BNHMfs/VadKIS6llvg=="],
+
+    "execa": ["execa@9.6.1", "", { "dependencies": { "@sindresorhus/merge-streams": "^4.0.0", "cross-spawn": "^7.0.6", "figures": "^6.1.0", "get-stream": "^9.0.0", "human-signals": "^8.0.1", "is-plain-obj": "^4.1.0", "is-stream": "^4.0.1", "npm-run-path": "^6.0.0", "pretty-ms": "^9.2.0", "signal-exit": "^4.1.0", "strip-final-newline": "^4.0.0", "yoctocolors": "^2.1.1" } }, "sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA=="],
+
+    "exenv-es6": ["exenv-es6@1.1.1", "", {}, "sha512-vlVu3N8d6yEMpMsEm+7sUBAI81aqYYuEvfK0jNqmdb/OPXzzH7QWDDnVjMvDSY47JdHEqx/dfC/q8WkfoTmpGQ=="],
+
+    "exif-parser": ["exif-parser@0.1.12", "", {}, "sha512-c2bQfLNbMzLPmzQuOr8fy0csy84WmwnER81W88DzTp9CYNPJ6yzOj2EZAh9pywYpqHnshVLHQJ8WzldAyfY+Iw=="],
+
+    "expand-template": ["expand-template@2.0.3", "", {}, "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="],
+
+    "expect": ["expect@29.7.0", "", { "dependencies": { "@jest/expect-utils": "^29.7.0", "jest-get-type": "^29.6.3", "jest-matcher-utils": "^29.7.0", "jest-message-util": "^29.7.0", "jest-util": "^29.7.0" } }, "sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw=="],
+
+    "expect-type": ["expect-type@1.4.0", "", {}, "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA=="],
+
+    "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
+
+    "express-rate-limit": ["express-rate-limit@8.5.2", "", { "dependencies": { "ip-address": "^10.2.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A=="],
+
+    "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
+
+    "extract-zip": ["extract-zip@2.0.1", "", { "dependencies": { "debug": "^4.1.1", "get-stream": "^5.1.0", "yauzl": "^2.10.0" }, "optionalDependencies": { "@types/yauzl": "^2.9.1" }, "bin": { "extract-zip": "cli.js" } }, "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg=="],
+
+    "extsprintf": ["extsprintf@1.4.1", "", {}, "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA=="],
+
+    "fast-csv": ["fast-csv@4.3.6", "", { "dependencies": { "@fast-csv/format": "4.3.5", "@fast-csv/parse": "4.3.6" } }, "sha512-2RNSpuwwsJGP0frGsOmTb9oUF+VkFSM4SyLTDgwf2ciHWTarN0lQTC+F2f/t5J9QjW+c65VFIAAu85GsvMIusw=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fast-equals": ["fast-equals@5.4.0", "", {}, "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw=="],
+
+    "fast-fifo": ["fast-fifo@1.3.2", "", {}, "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ=="],
+
+    "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+
+    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],
+
+    "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="],
+
+    "fast-shallow-equal": ["fast-shallow-equal@1.0.0", "", {}, "sha512-HPtaa38cPgWvaCFmRNhlc6NG7pv6NUHqjPgVAkWGoB9mQMwYB27/K0CvOM5Czy+qpT3e8XJ6Q4aPAnzpNpzNaw=="],
+
+    "fast-string-truncated-width": ["fast-string-truncated-width@3.0.3", "", {}, "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g=="],
+
+    "fast-string-width": ["fast-string-width@3.0.2", "", { "dependencies": { "fast-string-truncated-width": "^3.0.2" } }, "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg=="],
+
+    "fast-uri": ["fast-uri@3.1.3", "", {}, "sha512-i70LwGWUduXqzicKXWshooq+sWL1K3WUU5rKZNG/0i3a1OSoX3HqhH5WbWwTmqWfor4urUakGPiRQcleRZTwOg=="],
+
+    "fast-wrap-ansi": ["fast-wrap-ansi@0.2.2", "", { "dependencies": { "fast-string-width": "^3.0.2" } }, "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q=="],
+
+    "fastest-stable-stringify": ["fastest-stable-stringify@2.0.2", "", {}, "sha512-bijHueCGd0LqqNK9b5oCMHc0MluJAx0cwqASgbWMvkO01lCYgIhacVRLcaDz3QnyYIRNJRDwMb41VuT6pHJ91Q=="],
+
+    "fastq": ["fastq@1.20.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw=="],
+
+    "faye-websocket": ["faye-websocket@0.11.4", "", { "dependencies": { "websocket-driver": ">=0.5.1" } }, "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g=="],
+
+    "fd-slicer": ["fd-slicer@1.1.0", "", { "dependencies": { "pend": "~1.2.0" } }, "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "fecha": ["fecha@4.2.3", "", {}, "sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw=="],
+
+    "fetch-blob": ["fetch-blob@3.2.0", "", { "dependencies": { "node-domexception": "^1.0.0", "web-streams-polyfill": "^3.0.3" } }, "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ=="],
+
+    "fflate": ["fflate@0.4.8", "", {}, "sha512-FJqqoDBR00Mdj9ppamLa/Y7vxm+PRmNWA67N846RvsoYVMKB4q3y/de5PA7gUmRMYK/8CMz2GDZQmCRN1wBcWA=="],
+
+    "figures": ["figures@6.1.0", "", { "dependencies": { "is-unicode-supported": "^2.0.0" } }, "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg=="],
+
+    "file-entry-cache": ["file-entry-cache@8.0.0", "", { "dependencies": { "flat-cache": "^4.0.0" } }, "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ=="],
+
+    "file-type": ["file-type@16.5.4", "", { "dependencies": { "readable-web-to-node-stream": "^3.0.0", "strtok3": "^6.2.4", "token-types": "^4.1.1" } }, "sha512-/yFHK0aGjFEgDJjEKP0pWCplsPFPhwyfwevf/pVxiN0tmE4L9LmwWxWukdJSHdoCli4VgQLehjJtwQBnqmsKcw=="],
+
+    "file-uri-to-path": ["file-uri-to-path@1.0.0", "", {}, "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="],
+
+    "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+
+    "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="],
+
+    "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
+
+    "firebase": ["firebase@11.10.0", "", { "dependencies": { "@firebase/ai": "1.4.1", "@firebase/analytics": "0.10.17", "@firebase/analytics-compat": "0.2.23", "@firebase/app": "0.13.2", "@firebase/app-check": "0.10.1", "@firebase/app-check-compat": "0.3.26", "@firebase/app-compat": "0.4.2", "@firebase/app-types": "0.9.3", "@firebase/auth": "1.10.8", "@firebase/auth-compat": "0.5.28", "@firebase/data-connect": "0.3.10", "@firebase/database": "1.0.20", "@firebase/database-compat": "2.0.11", "@firebase/firestore": "4.8.0", "@firebase/firestore-compat": "0.3.53", "@firebase/functions": "0.12.9", "@firebase/functions-compat": "0.3.26", "@firebase/installations": "0.6.18", "@firebase/installations-compat": "0.2.18", "@firebase/messaging": "0.12.22", "@firebase/messaging-compat": "0.2.22", "@firebase/performance": "0.7.7", "@firebase/performance-compat": "0.2.20", "@firebase/remote-config": "0.6.5", "@firebase/remote-config-compat": "0.2.18", "@firebase/storage": "0.13.14", "@firebase/storage-compat": "0.3.24", "@firebase/util": "1.12.1" } }, "sha512-nKBXoDzF0DrXTBQJlZa+sbC5By99ysYU1D6PkMRYknm0nCW7rJly47q492Ht7Ndz5MeYSBuboKuhS1e6mFC03w=="],
+
+    "flat": ["flat@5.0.2", "", { "bin": { "flat": "cli.js" } }, "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ=="],
+
+    "flat-cache": ["flat-cache@4.0.1", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" } }, "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw=="],
+
+    "flatted": ["flatted@3.4.2", "", {}, "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA=="],
+
+    "fn.name": ["fn.name@1.1.0", "", {}, "sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw=="],
+
+    "follow-redirects": ["follow-redirects@1.16.0", "", {}, "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw=="],
+
+    "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="],
+
+    "form-data": ["form-data@4.0.6", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.4", "mime-types": "^2.1.35" } }, "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ=="],
+
+    "form-data-encoder": ["form-data-encoder@1.7.2", "", {}, "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A=="],
+
+    "formdata-node": ["formdata-node@4.4.1", "", { "dependencies": { "node-domexception": "1.0.0", "web-streams-polyfill": "4.0.0-beta.3" } }, "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ=="],
+
+    "formdata-polyfill": ["formdata-polyfill@4.0.10", "", { "dependencies": { "fetch-blob": "^3.1.2" } }, "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g=="],
+
+    "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],
+
+    "forwarded-parse": ["forwarded-parse@2.1.2", "", {}, "sha512-alTFZZQDKMporBH77856pXgzhEzaUVmLCDk+egLgIgHst3Tpndzz8MnKe+GzRJRfvVdn69HhpW7cmXzvtLvJAw=="],
+
+    "fraction.js": ["fraction.js@5.3.4", "", {}, "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ=="],
+
+    "framer-motion": ["framer-motion@12.42.2", "", { "dependencies": { "motion-dom": "^12.42.2", "motion-utils": "^12.39.0", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-5XY9luDiu0oHfHBjpDthFMh0ES+122w6p/papSJBweMkO8Sn+PW2QaEgRblQBpWFnuvZS5qvarpt/hO2pjGmnw=="],
+
+    "fresh": ["fresh@2.0.0", "", {}, "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="],
+
+    "fs-constants": ["fs-constants@1.0.0", "", {}, "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="],
+
+    "fs-extra": ["fs-extra@11.3.6", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-w8ZNZr2mKIc7qeNaQ9AVPT1+iFaI+Avd4xudVOvdDJ8VytREi1Ft5Ih7hd9jjehod8vAM5GMsfQ/TpPf4EyoEA=="],
+
+    "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "fstream": ["fstream@1.0.12", "", { "dependencies": { "graceful-fs": "^4.1.2", "inherits": "~2.0.0", "mkdirp": ">=0.5 0", "rimraf": "2" } }, "sha512-WvJ193OHa0GHPEL+AycEJgxvBEwyfRkN1vhjca23OaPVMCaLCXTd5qAu82AjTcgP1UJmytkOKb63Ypde7raDIg=="],
+
+    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+    "fuse.js": ["fuse.js@7.4.2", "", {}, "sha512-LVbzjD4WA6UP5B1UnP8wuaXJiLnqMdM/E4fiJXTJ5haJ5b/MBNsK29h2fm6swEoQaVQjvYFWKLE2RanyZIoRVQ=="],
+
+    "fuzzysort": ["fuzzysort@3.1.0", "", {}, "sha512-sR9BNCjBg6LNgwvxlBd0sBABvQitkLzoVY9MYYROQVX/FvfJ4Mai9LsGhDgd8qYdds0bY77VzYd5iuB+v5rwQQ=="],
+
+    "fzf": ["fzf@0.5.2", "", {}, "sha512-Tt4kuxLXFKHy8KT40zwsUPUkg1CrsgY25FxA2U/j/0WgEDCk3ddc/zLTCCcbSHX9FcKtLuVaDGtGE/STWC+j3Q=="],
+
+    "gauge": ["gauge@5.0.2", "", { "dependencies": { "aproba": "^1.0.3 || ^2.0.0", "color-support": "^1.1.3", "console-control-strings": "^1.1.0", "has-unicode": "^2.0.1", "signal-exit": "^4.0.1", "string-width": "^4.2.3", "strip-ansi": "^6.0.1", "wide-align": "^1.1.5" } }, "sha512-pMaFftXPtiGIHCJHdcUUx9Rby/rFT/Kkt3fIIGCs+9PMDIljSyRiqraTlxNtBReJRDfUefpa263RQ3vnp5G/LQ=="],
+
+    "gaxios": ["gaxios@7.1.5", "", { "dependencies": { "extend": "^3.0.2", "https-proxy-agent": "^7.0.1", "node-fetch": "^3.3.2" } }, "sha512-5FZy72Rh8LhtjmvDrKkI+lVhrsQrVKVsItxMoDm5mNQE+xR0WVIIs+jzPSJgBvKVsLi24fZhXJIsNI0bihDzFg=="],
+
+    "gcp-metadata": ["gcp-metadata@8.1.2", "", { "dependencies": { "gaxios": "^7.0.0", "google-logging-utils": "^1.0.0", "json-bigint": "^1.0.0" } }, "sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg=="],
+
+    "gensync": ["gensync@1.0.0-beta.2", "", {}, "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="],
+
+    "get-caller-file": ["get-caller-file@2.0.5", "", {}, "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="],
+
+    "get-east-asian-width": ["get-east-asian-width@1.6.0", "", {}, "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA=="],
+
+    "get-folder-size": ["get-folder-size@5.0.0", "", { "bin": { "get-folder-size": "bin/get-folder-size.js" } }, "sha512-+fgtvbL83tSDypEK+T411GDBQVQtxv+qtQgbV+HVa/TYubqDhNd5ghH/D6cOHY9iC5/88GtOZB7WI8PXy2A3bg=="],
+
+    "get-func-name": ["get-func-name@2.0.2", "", {}, "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ=="],
+
+    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
+
+    "get-nonce": ["get-nonce@1.0.1", "", {}, "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q=="],
+
+    "get-own-enumerable-keys": ["get-own-enumerable-keys@1.0.0", "", {}, "sha512-PKsK2FSrQCyxcGHsGrLDcK0lx+0Ke+6e8KFFozA9/fIQLhQzPaRvJFdcz7+Axg3jUH/Mq+NI4xa5u/UT2tQskA=="],
+
+    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
+
+    "get-stream": ["get-stream@9.0.1", "", { "dependencies": { "@sec-ant/readable-stream": "^0.4.1", "is-stream": "^4.0.1" } }, "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA=="],
+
+    "get-uri": ["get-uri@6.0.5", "", { "dependencies": { "basic-ftp": "^5.0.2", "data-uri-to-buffer": "^6.0.2", "debug": "^4.3.4" } }, "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg=="],
+
+    "gifwrap": ["gifwrap@0.10.1", "", { "dependencies": { "image-q": "^4.0.0", "omggif": "^1.0.10" } }, "sha512-2760b1vpJHNmLzZ/ubTtNnEx5WApN/PYWJvXvgS+tL1egTTthayFYIQQNi136FLEDcN/IyEY2EcGpIITD6eYUw=="],
+
+    "github-from-package": ["github-from-package@0.0.0", "", {}, "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="],
+
+    "glob": ["glob@11.1.0", "", { "dependencies": { "foreground-child": "^3.3.1", "jackspeak": "^4.1.1", "minimatch": "^10.1.1", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw=="],
+
+    "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
+
+    "globals": ["globals@17.7.0", "", {}, "sha512-Czmyns5dUsq4seFBR/Kdydhmo8y9kC79hiSkPn0YcGtNnYWnrgt0vjrSjx9tspoDGWm2CMarffRuLjM4xUz8xg=="],
+
+    "globby": ["globby@14.1.0", "", { "dependencies": { "@sindresorhus/merge-streams": "^2.1.0", "fast-glob": "^3.3.3", "ignore": "^7.0.3", "path-type": "^6.0.0", "slash": "^5.1.0", "unicorn-magic": "^0.3.0" } }, "sha512-0Ia46fDOaT7k4og1PDW4YbodWWr3scS2vAr2lTbsplOt2WkKp0vQbkI9wKis/T5LV/dqPjO3bpS/z6GTJB82LA=="],
+
+    "google-auth-library": ["google-auth-library@10.9.0", "", { "dependencies": { "base64-js": "^1.3.0", "ecdsa-sig-formatter": "^1.0.11", "gaxios": "^7.1.4", "gcp-metadata": "8.1.2", "google-logging-utils": "1.1.3", "jws": "^4.0.0" } }, "sha512-xtvUqvINPhTaBm7nXqlYPcrMHJPm1lCNdSovxnKKhTm+4JsvQ+KGVYJViLoH9Yxu8w+T0Qv5HubzYT9BLrppJg=="],
+
+    "google-logging-utils": ["google-logging-utils@1.1.3", "", {}, "sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA=="],
+
+    "googleapis-common": ["googleapis-common@8.0.2", "", { "dependencies": { "extend": "^3.0.2", "gaxios": "7.1.3", "google-auth-library": "10.5.0", "google-logging-utils": "1.1.3", "qs": "^6.7.0", "url-template": "^2.0.8" } }, "sha512-5MXeQzIZaqCH7B+HJWqhQm946VARpZep6acbWSr/fcgF2cQANq7allgX+i/G0EqF0WyUxB277gtWMzRYHMl9tg=="],
+
+    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "graphql": ["graphql@17.0.1", "", {}, "sha512-8eWbg5Zcv/8o20nzEjHUGPTj20MLFJjc5kagbIPxbaeGxvFwpitJhemEC/k17n5+UD4M/9ea5rTuce78mELujQ=="],
+
+    "grpc-health-check": ["grpc-health-check@2.1.0", "", { "dependencies": { "@grpc/proto-loader": "^0.7.13" } }, "sha512-HH3WjwNtusMTEQAtRelFgsFyNcOdihvpjusNDIrGYfWG8tPNSHqELrSyriIjm70k65YSxetsKG1y4H1L5gi1wQ=="],
+
+    "grpc-tools": ["grpc-tools@1.13.1", "", { "dependencies": { "@mapbox/node-pre-gyp": "^2.0.0" }, "bin": { "grpc_tools_node_protoc": "bin/protoc.js", "grpc_tools_node_protoc_plugin": "bin/protoc_plugin.js" } }, "sha512-0sttMUxThNIkCTJq5qI0xXMz5zWqV2u3yG1kR3Sj9OokGIoyRBFjoInK9NyW7x5fH7knj48Roh1gq5xbl0VoDQ=="],
+
+    "gtoken": ["gtoken@8.0.0", "", { "dependencies": { "gaxios": "^7.0.0", "jws": "^4.0.0" } }, "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw=="],
+
+    "hachure-fill": ["hachure-fill@0.5.2", "", {}, "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
+
+    "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
+
+    "has-unicode": ["has-unicode@2.0.1", "", {}, "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ=="],
+
+    "hasown": ["hasown@2.0.4", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A=="],
+
+    "hast-to-hyperscript": ["hast-to-hyperscript@9.0.1", "", { "dependencies": { "@types/unist": "^2.0.3", "comma-separated-tokens": "^1.0.0", "property-information": "^5.3.0", "space-separated-tokens": "^1.0.0", "style-to-object": "^0.3.0", "unist-util-is": "^4.0.0", "web-namespaces": "^1.0.0" } }, "sha512-zQgLKqF+O2F72S1aa4y2ivxzSlko3MAvxkwG8ehGmNiqd98BIN3JM1rAJPmplEyLmGLO2QZYJtIneOSZ2YbJuA=="],
+
+    "hast-util-embedded": ["hast-util-embedded@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-is-element": "^3.0.0" } }, "sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA=="],
+
+    "hast-util-from-dom": ["hast-util-from-dom@5.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hastscript": "^9.0.0", "web-namespaces": "^2.0.0" } }, "sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q=="],
+
+    "hast-util-from-html": ["hast-util-from-html@2.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "devlop": "^1.1.0", "hast-util-from-parse5": "^8.0.0", "parse5": "^7.0.0", "vfile": "^6.0.0", "vfile-message": "^4.0.0" } }, "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw=="],
+
+    "hast-util-from-html-isomorphic": ["hast-util-from-html-isomorphic@2.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-from-dom": "^5.0.0", "hast-util-from-html": "^2.0.0", "unist-util-remove-position": "^5.0.0" } }, "sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw=="],
+
+    "hast-util-from-parse5": ["hast-util-from-parse5@8.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "devlop": "^1.0.0", "hastscript": "^9.0.0", "property-information": "^7.0.0", "vfile": "^6.0.0", "vfile-location": "^5.0.0", "web-namespaces": "^2.0.0" } }, "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg=="],
+
+    "hast-util-has-property": ["hast-util-has-property@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA=="],
+
+    "hast-util-is-body-ok-link": ["hast-util-is-body-ok-link@3.0.1", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-0qpnzOBLztXHbHQenVB8uNuxTnm/QBFUOmdOSsEn7GnBtyY07+ENTWVFBAnXd/zEgd9/SUG3lRY7hSIBWRgGpQ=="],
+
+    "hast-util-is-element": ["hast-util-is-element@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g=="],
+
+    "hast-util-minify-whitespace": ["hast-util-minify-whitespace@1.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-embedded": "^3.0.0", "hast-util-is-element": "^3.0.0", "hast-util-whitespace": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw=="],
+
+    "hast-util-parse-selector": ["hast-util-parse-selector@4.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A=="],
+
+    "hast-util-phrasing": ["hast-util-phrasing@3.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-embedded": "^3.0.0", "hast-util-has-property": "^3.0.0", "hast-util-is-body-ok-link": "^3.0.0", "hast-util-is-element": "^3.0.0" } }, "sha512-6h60VfI3uBQUxHqTyMymMZnEbNl1XmEGtOxxKYL7stY2o601COo62AWAYBQR9lZbYXYSBoxag8UpPRXK+9fqSQ=="],
+
+    "hast-util-raw": ["hast-util-raw@9.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-from-parse5": "^8.0.0", "hast-util-to-parse5": "^8.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "parse5": "^7.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0", "web-namespaces": "^2.0.0", "zwitch": "^2.0.0" } }, "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw=="],
+
+    "hast-util-sanitize": ["hast-util-sanitize@5.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "unist-util-position": "^5.0.0" } }, "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg=="],
+
+    "hast-util-to-html": ["hast-util-to-html@9.0.5", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-whitespace": "^3.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "stringify-entities": "^4.0.0", "zwitch": "^2.0.4" } }, "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw=="],
+
+    "hast-util-to-jsx-runtime": ["hast-util-to-jsx-runtime@2.3.6", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-js": "^1.0.0", "unist-util-position": "^5.0.0", "vfile-message": "^4.0.0" } }, "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg=="],
+
+    "hast-util-to-mdast": ["hast-util-to-mdast@10.1.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-phrasing": "^3.0.0", "hast-util-to-html": "^9.0.0", "hast-util-to-text": "^4.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-hast": "^13.0.0", "mdast-util-to-string": "^4.0.0", "rehype-minify-whitespace": "^6.0.0", "trim-trailing-lines": "^2.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-FiCRI7NmOvM4y+f5w32jPRzcxDIz+PUqDwEqn1A+1q2cdp3B8Gx7aVrXORdOKjMNDQsD1ogOr896+0jJHW1EFQ=="],
+
+    "hast-util-to-parse5": ["hast-util-to-parse5@8.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "web-namespaces": "^2.0.0", "zwitch": "^2.0.0" } }, "sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA=="],
+
+    "hast-util-to-text": ["hast-util-to-text@4.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "hast-util-is-element": "^3.0.0", "unist-util-find-after": "^5.0.0" } }, "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A=="],
+
+    "hast-util-whitespace": ["hast-util-whitespace@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw=="],
+
+    "hastscript": ["hastscript@9.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-parse-selector": "^4.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w=="],
+
+    "he": ["he@1.2.0", "", { "bin": { "he": "bin/he" } }, "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw=="],
+
+    "hermes-estree": ["hermes-estree@0.25.1", "", {}, "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw=="],
+
+    "hermes-parser": ["hermes-parser@0.25.1", "", { "dependencies": { "hermes-estree": "0.25.1" } }, "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA=="],
+
+    "highlight.js": ["highlight.js@11.11.1", "", {}, "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w=="],
+
+    "hono": ["hono@4.12.27", "", {}, "sha512-1yrb/+w6HWQJrUCLkJ2IF5jNIPvvFkblV5RNOYl6bV+OA6p9GLcMpHFFGTosSvHvcAUibuUukRqhlYI4z32C7Q=="],
+
+    "hosted-git-info": ["hosted-git-info@4.1.0", "", { "dependencies": { "lru-cache": "^6.0.0" } }, "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA=="],
+
+    "html-encoding-sniffer": ["html-encoding-sniffer@4.0.0", "", { "dependencies": { "whatwg-encoding": "^3.1.1" } }, "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ=="],
+
+    "html-escaper": ["html-escaper@2.0.2", "", {}, "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg=="],
+
+    "html-url-attributes": ["html-url-attributes@3.0.1", "", {}, "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ=="],
+
+    "html-void-elements": ["html-void-elements@3.0.0", "", {}, "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg=="],
+
+    "htmlparser2": ["htmlparser2@10.1.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.2.2", "entities": "^7.0.1" } }, "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ=="],
+
+    "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
+
+    "http-parser-js": ["http-parser-js@0.5.10", "", {}, "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA=="],
+
+    "http-proxy-agent": ["http-proxy-agent@7.0.2", "", { "dependencies": { "agent-base": "^7.1.0", "debug": "^4.3.4" } }, "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig=="],
+
+    "https-proxy-agent": ["https-proxy-agent@7.0.6", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "4" } }, "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw=="],
+
+    "human-signals": ["human-signals@8.0.1", "", {}, "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ=="],
+
+    "humanize-ms": ["humanize-ms@1.2.1", "", { "dependencies": { "ms": "^2.0.0" } }, "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ=="],
+
+    "husky": ["husky@9.1.7", "", { "bin": { "husky": "bin.js" } }, "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA=="],
+
+    "hyphenate-style-name": ["hyphenate-style-name@1.1.0", "", {}, "sha512-WDC/ui2VVRrz3jOVi+XtjqkDjiVjTtFaAGiW37k6b+ohyQ5wYDOGkvCZa8+H0nx3gyvv0+BST9xuOgIyGQ00gw=="],
+
+    "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],
+
+    "idb": ["idb@7.1.1", "", {}, "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ=="],
+
+    "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
+
+    "ignore": ["ignore@7.0.5", "", {}, "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg=="],
+
+    "image-q": ["image-q@4.0.0", "", { "dependencies": { "@types/node": "16.9.1" } }, "sha512-PfJGVgIfKQJuq3s0tTDOKtztksibuUEbJQIYT3by6wctQo+Rdlh7ef4evJ5NCdxY4CfMbvFkocEwbl4BF8RlJw=="],
+
+    "image-size": ["image-size@2.0.2", "", { "bin": { "image-size": "bin/image-size.js" } }, "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w=="],
+
+    "immediate": ["immediate@3.0.6", "", {}, "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ=="],
+
+    "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="],
+
+    "import-in-the-middle": ["import-in-the-middle@1.15.0", "", { "dependencies": { "acorn": "^8.14.0", "acorn-import-attributes": "^1.9.5", "cjs-module-lexer": "^1.2.2", "module-details-from-path": "^1.0.3" } }, "sha512-bpQy+CrsRmYmoPMAE/0G33iwRqwW4ouqdRg8jgbH3aKuCtOc8lxgmYXg2dMM92CRiGP660EtBcymH/eVUpCSaA=="],
+
+    "import-meta-resolve": ["import-meta-resolve@4.2.0", "", {}, "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg=="],
+
+    "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="],
+
+    "indent-string": ["indent-string@4.0.0", "", {}, "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg=="],
+
+    "index-to-position": ["index-to-position@1.2.0", "", {}, "sha512-Yg7+ztRkqslMAS2iFaU+Oa4KTSidr63OsFGlOrJoW981kIYO3CGCS3wA95P1mUi/IVSJkn0D479KTJpVpvFNuw=="],
+
+    "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="],
+
+    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
+
+    "ini": ["ini@1.3.8", "", {}, "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="],
+
+    "inline-style-parser": ["inline-style-parser@0.2.7", "", {}, "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA=="],
+
+    "inline-style-prefixer": ["inline-style-prefixer@7.0.1", "", { "dependencies": { "css-in-js-utils": "^3.1.0" } }, "sha512-lhYo5qNTQp3EvSSp3sRvXMbVQTLrvGV6DycRMJ5dm2BLMiJ30wpXKdDdgX+GmJZ5uQMucwRKHamXSst3Sj/Giw=="],
+
+    "input-otp": ["input-otp@1.4.2", "", { "peerDependencies": { "react": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-l3jWwYNvrEa6NTCt7BECfCm48GvwuZzkoeG3gBL2w4CHeOXW3eKFmf9UNYkNfYc3mxMrthMnxjIE07MT0zLBQA=="],
+
+    "internmap": ["internmap@2.0.3", "", {}, "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg=="],
+
+    "intl-messageformat": ["intl-messageformat@10.7.18", "", { "dependencies": { "@formatjs/ecma402-abstract": "2.3.6", "@formatjs/fast-memoize": "2.2.7", "@formatjs/icu-messageformat-parser": "2.11.4", "tslib": "^2.8.0" } }, "sha512-m3Ofv/X/tV8Y3tHXLohcuVuhWKo7BBq62cqY15etqmLxg2DZ34AGGgQDeR+SCta2+zICb1NX83af0GJmbQ1++g=="],
+
+    "ip-address": ["ip-address@10.2.0", "", {}, "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA=="],
+
+    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
+
+    "is-alphabetical": ["is-alphabetical@2.0.1", "", {}, "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ=="],
+
+    "is-alphanumerical": ["is-alphanumerical@2.0.1", "", { "dependencies": { "is-alphabetical": "^2.0.0", "is-decimal": "^2.0.0" } }, "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw=="],
+
+    "is-arrayish": ["is-arrayish@0.2.1", "", {}, "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="],
+
+    "is-binary-path": ["is-binary-path@2.1.0", "", { "dependencies": { "binary-extensions": "^2.0.0" } }, "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw=="],
+
+    "is-buffer": ["is-buffer@2.0.5", "", {}, "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ=="],
+
+    "is-core-module": ["is-core-module@2.16.2", "", { "dependencies": { "hasown": "^2.0.3" } }, "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA=="],
+
+    "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],
+
+    "is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
+
+    "is-electron": ["is-electron@2.2.2", "", {}, "sha512-FO/Rhvz5tuw4MCWkpMzHFKWD2LsfHzIb7i6MdPYZ/KW7AlxawyLkqdy+jPZP1WubqEADE3O4FUENlJHDfQASRg=="],
+
+    "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
+
+    "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+    "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
+
+    "is-hexadecimal": ["is-hexadecimal@2.0.1", "", {}, "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="],
+
+    "is-in-ssh": ["is-in-ssh@1.0.0", "", {}, "sha512-jYa6Q9rH90kR1vKB6NM7qqd1mge3Fx4Dhw5TVlK1MUBqhEOuCagrEHMevNuCcbECmXZ0ThXkRm+Ymr51HwEPAw=="],
+
+    "is-inside-container": ["is-inside-container@1.0.0", "", { "dependencies": { "is-docker": "^3.0.0" }, "bin": { "is-inside-container": "cli.js" } }, "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA=="],
+
+    "is-interactive": ["is-interactive@2.0.0", "", {}, "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ=="],
+
+    "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
+
+    "is-obj": ["is-obj@3.0.0", "", {}, "sha512-IlsXEHOjtKhpN8r/tRFj2nDyTmHvcfNeu/nrRIcXE17ROeatXchkojffa1SpdqW4cr/Fj6QkEf/Gn4zf6KKvEQ=="],
+
+    "is-path-inside": ["is-path-inside@3.0.3", "", {}, "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ=="],
+
+    "is-plain-obj": ["is-plain-obj@4.1.0", "", {}, "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="],
+
+    "is-plain-object": ["is-plain-object@2.0.4", "", { "dependencies": { "isobject": "^3.0.1" } }, "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og=="],
+
+    "is-potential-custom-element-name": ["is-potential-custom-element-name@1.0.1", "", {}, "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ=="],
+
+    "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],
+
+    "is-regexp": ["is-regexp@3.1.0", "", {}, "sha512-rbku49cWloU5bSMI+zaRaXdQHXnthP6DZ/vLnfdSKyL4zUzuWnomtOEiZZOd+ioQ+avFo/qau3KPTc7Fjy1uPA=="],
+
+    "is-stream": ["is-stream@4.0.1", "", {}, "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A=="],
+
+    "is-unicode-supported": ["is-unicode-supported@2.1.0", "", {}, "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ=="],
+
+    "is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="],
+
+    "isarray": ["isarray@1.0.0", "", {}, "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ=="],
+
+    "isbinaryfile": ["isbinaryfile@5.0.7", "", {}, "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ=="],
+
+    "isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="],
+
+    "isobject": ["isobject@3.0.1", "", {}, "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg=="],
+
+    "istanbul-lib-coverage": ["istanbul-lib-coverage@3.2.2", "", {}, "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg=="],
+
+    "istanbul-lib-report": ["istanbul-lib-report@3.0.1", "", { "dependencies": { "istanbul-lib-coverage": "^3.0.0", "make-dir": "^4.0.0", "supports-color": "^7.1.0" } }, "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw=="],
+
+    "istanbul-lib-source-maps": ["istanbul-lib-source-maps@5.0.6", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.23", "debug": "^4.1.1", "istanbul-lib-coverage": "^3.0.0" } }, "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A=="],
+
+    "istanbul-reports": ["istanbul-reports@3.2.0", "", { "dependencies": { "html-escaper": "^2.0.0", "istanbul-lib-report": "^3.0.0" } }, "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA=="],
+
+    "istextorbinary": ["istextorbinary@9.5.0", "", { "dependencies": { "binaryextensions": "^6.11.0", "editions": "^6.21.0", "textextensions": "^6.11.0" } }, "sha512-5mbUj3SiZXCuRf9fT3ibzbSSEWiy63gFfksmGfdOzujPjW3k+z8WvIBxcJHBoQNlaZaiyB25deviif2+osLmLw=="],
+
+    "jackspeak": ["jackspeak@4.2.3", "", { "dependencies": { "@isaacs/cliui": "^9.0.0" } }, "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg=="],
+
+    "jest-diff": ["jest-diff@30.4.1", "", { "dependencies": { "@jest/diff-sequences": "30.4.0", "@jest/get-type": "30.1.0", "chalk": "^4.1.2", "pretty-format": "30.4.1" } }, "sha512-CRpFK0RtLriVDGcPPAnR6HMVI8bSR2jnUIgralhauzYQZIb4RH9AtEInTuQr65LmmGggGcRT6HIASxwqsVsmlA=="],
+
+    "jest-get-type": ["jest-get-type@29.6.3", "", {}, "sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw=="],
+
+    "jest-matcher-utils": ["jest-matcher-utils@29.7.0", "", { "dependencies": { "chalk": "^4.0.0", "jest-diff": "^29.7.0", "jest-get-type": "^29.6.3", "pretty-format": "^29.7.0" } }, "sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g=="],
+
+    "jest-message-util": ["jest-message-util@29.7.0", "", { "dependencies": { "@babel/code-frame": "^7.12.13", "@jest/types": "^29.6.3", "@types/stack-utils": "^2.0.0", "chalk": "^4.0.0", "graceful-fs": "^4.2.9", "micromatch": "^4.0.4", "pretty-format": "^29.7.0", "slash": "^3.0.0", "stack-utils": "^2.0.3" } }, "sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w=="],
+
+    "jest-util": ["jest-util@29.7.0", "", { "dependencies": { "@jest/types": "^29.6.3", "@types/node": "*", "chalk": "^4.0.0", "ci-info": "^3.2.0", "graceful-fs": "^4.2.9", "picomatch": "^2.2.3" } }, "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA=="],
+
+    "jimp": ["jimp@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/diff": "1.6.0", "@jimp/js-bmp": "1.6.0", "@jimp/js-gif": "1.6.0", "@jimp/js-jpeg": "1.6.0", "@jimp/js-png": "1.6.0", "@jimp/js-tiff": "1.6.0", "@jimp/plugin-blit": "1.6.0", "@jimp/plugin-blur": "1.6.0", "@jimp/plugin-circle": "1.6.0", "@jimp/plugin-color": "1.6.0", "@jimp/plugin-contain": "1.6.0", "@jimp/plugin-cover": "1.6.0", "@jimp/plugin-crop": "1.6.0", "@jimp/plugin-displace": "1.6.0", "@jimp/plugin-dither": "1.6.0", "@jimp/plugin-fisheye": "1.6.0", "@jimp/plugin-flip": "1.6.0", "@jimp/plugin-hash": "1.6.0", "@jimp/plugin-mask": "1.6.0", "@jimp/plugin-print": "1.6.0", "@jimp/plugin-quantize": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/plugin-rotate": "1.6.0", "@jimp/plugin-threshold": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0" } }, "sha512-YcwCHw1kiqEeI5xRpDlPPBGL2EOpBKLwO4yIBJcXWHPj5PnA5urGq0jbyhM5KoNpypQ6VboSoxc9D8HyfvngSg=="],
+
+    "jiti": ["jiti@2.7.0", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ=="],
+
+    "jks-js": ["jks-js@1.1.7", "", { "dependencies": { "node-forge": "^1.4.0", "node-int64": "^0.4.0", "node-rsa": "^1.1.1" } }, "sha512-BeiDRKsAi1NwEwgx2JB/9/0tar5BNGIv+foGm1G5GgiyR35s/iUnfd/BWqYd16mLDD8qTaAVBrIcOOuVqXJZNQ=="],
+
+    "jose": ["jose@6.2.3", "", {}, "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw=="],
+
+    "jpeg-js": ["jpeg-js@0.4.4", "", {}, "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg=="],
+
+    "js-cookie": ["js-cookie@3.0.8", "", {}, "sha512-yeJd4aNAdYZQjaon2bpD/Gb0B/omw7HQOsynXXcOiWVCacbBcPlgn8S/d1X6blFSaHao7ozqtW7NZW19xpCtIw=="],
+
+    "js-tokens": ["js-tokens@10.0.0", "", {}, "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q=="],
+
+    "js-yaml": ["js-yaml@4.3.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q=="],
+
+    "jschardet": ["jschardet@3.1.4", "", {}, "sha512-/kmVISmrwVwtyYU40iQUOp3SUPk2dhNCMsZBQX0R1/jZ8maaXJ/oZIzUOiyOqcgtLnETFKYChbJ5iDC/eWmFHg=="],
+
+    "jsdom": ["jsdom@26.1.0", "", { "dependencies": { "cssstyle": "^4.2.1", "data-urls": "^5.0.0", "decimal.js": "^10.5.0", "html-encoding-sniffer": "^4.0.0", "http-proxy-agent": "^7.0.2", "https-proxy-agent": "^7.0.6", "is-potential-custom-element-name": "^1.0.1", "nwsapi": "^2.2.16", "parse5": "^7.2.1", "rrweb-cssom": "^0.8.0", "saxes": "^6.0.0", "symbol-tree": "^3.2.4", "tough-cookie": "^5.1.1", "w3c-xmlserializer": "^5.0.0", "webidl-conversions": "^7.0.0", "whatwg-encoding": "^3.1.1", "whatwg-mimetype": "^4.0.0", "whatwg-url": "^14.1.1", "ws": "^8.18.0", "xml-name-validator": "^5.0.0" }, "peerDependencies": { "canvas": "^3.0.0" }, "optionalPeers": ["canvas"] }, "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg=="],
+
+    "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
+
+    "json-bigint": ["json-bigint@1.0.0", "", { "dependencies": { "bignumber.js": "^9.0.0" } }, "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ=="],
+
+    "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="],
+
+    "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="],
+
+    "json-schema": ["json-schema@0.4.0", "", {}, "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA=="],
+
+    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],
+
+    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],
+
+    "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="],
+
+    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
+
+    "jsonc-parser": ["jsonc-parser@3.3.1", "", {}, "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ=="],
+
+    "jsonfile": ["jsonfile@6.2.1", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q=="],
+
+    "jsonrepair": ["jsonrepair@3.14.1", "", { "bin": { "jsonrepair": "bin/cli.js" } }, "sha512-NpGgMhmzG/fajkBEFlS9jZvMSGDvc2xN/9wNCHZ+Nx32GZfLRELU6UE6dQkebvrQUct9S+7bvnpX29NB36Qbdw=="],
+
+    "jsonwebtoken": ["jsonwebtoken@9.0.3", "", { "dependencies": { "jws": "^4.0.1", "lodash.includes": "^4.3.0", "lodash.isboolean": "^3.0.3", "lodash.isinteger": "^4.0.4", "lodash.isnumber": "^3.0.3", "lodash.isplainobject": "^4.0.6", "lodash.isstring": "^4.0.1", "lodash.once": "^4.0.0", "ms": "^2.1.1", "semver": "^7.5.4" } }, "sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g=="],
+
+    "jszip": ["jszip@3.10.1", "", { "dependencies": { "lie": "~3.3.0", "pako": "~1.0.2", "readable-stream": "~2.3.6", "setimmediate": "^1.0.5" } }, "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g=="],
+
+    "jwa": ["jwa@2.0.1", "", { "dependencies": { "buffer-equal-constant-time": "^1.0.1", "ecdsa-sig-formatter": "1.0.11", "safe-buffer": "^5.0.1" } }, "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg=="],
+
+    "jws": ["jws@4.0.1", "", { "dependencies": { "jwa": "^2.0.1", "safe-buffer": "^5.0.1" } }, "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA=="],
+
+    "jwt-decode": ["jwt-decode@4.0.0", "", {}, "sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA=="],
+
+    "katex": ["katex@0.16.47", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-Eeo8Ys1doU1z+x8AZsPpQu+p/QcZBI5PeOo7QGQdy2x2m0MU/hYagBbGOmXwr5KVbEfVuWv9LpnQWeehogurjg=="],
+
+    "keytar": ["keytar@7.9.0", "", { "dependencies": { "node-addon-api": "^4.3.0", "prebuild-install": "^7.0.1" } }, "sha512-VPD8mtVtm5JNtA2AErl6Chp06JBfy7diFQ7TQQhdpWOl6MrCRB+eRbvAZUsbGQS9kiMq0coJsy0W0vHpDCkWsQ=="],
+
+    "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="],
+
+    "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="],
+
+    "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="],
+
+    "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
+
+    "kuler": ["kuler@2.0.0", "", {}, "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A=="],
+
+    "layout-base": ["layout-base@1.0.2", "", {}, "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="],
+
+    "lazystream": ["lazystream@1.0.1", "", { "dependencies": { "readable-stream": "^2.0.5" } }, "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw=="],
+
+    "leven": ["leven@3.1.0", "", {}, "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A=="],
+
+    "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="],
+
+    "lie": ["lie@3.3.0", "", { "dependencies": { "immediate": "~3.0.5" } }, "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ=="],
+
+    "lighthouse-logger": ["lighthouse-logger@2.0.2", "", { "dependencies": { "debug": "^4.4.1", "marky": "^1.2.2" } }, "sha512-vWl2+u5jgOQuZR55Z1WM0XDdrJT6mzMP8zHUct7xTlWhuQs+eV0g+QL0RQdFjT54zVmbhLCP8vIVpy1wGn/gCg=="],
+
+    "lightningcss": ["lightningcss@1.32.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.32.0", "lightningcss-darwin-arm64": "1.32.0", "lightningcss-darwin-x64": "1.32.0", "lightningcss-freebsd-x64": "1.32.0", "lightningcss-linux-arm-gnueabihf": "1.32.0", "lightningcss-linux-arm64-gnu": "1.32.0", "lightningcss-linux-arm64-musl": "1.32.0", "lightningcss-linux-x64-gnu": "1.32.0", "lightningcss-linux-x64-musl": "1.32.0", "lightningcss-win32-arm64-msvc": "1.32.0", "lightningcss-win32-x64-msvc": "1.32.0" } }, "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ=="],
+
+    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.32.0", "", { "os": "android", "cpu": "arm64" }, "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg=="],
+
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.32.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ=="],
+
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.32.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w=="],
+
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.32.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig=="],
+
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.32.0", "", { "os": "linux", "cpu": "arm" }, "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw=="],
+
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ=="],
+
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg=="],
+
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA=="],
+
+    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg=="],
+
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.32.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw=="],
+
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.29.2", "", { "os": "win32", "cpu": "x64" }, "sha512-EdIUW3B2vLuHmv7urfzMI/h2fmlnOQBk1xlsDxkN1tCWKjNFjfLhGxYk8C8mzpSfr+A6jFFIi8fU6LbQGsRWjA=="],
+
+    "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="],
+
+    "linkify-it": ["linkify-it@3.0.3", "", { "dependencies": { "uc.micro": "^1.0.1" } }, "sha512-ynTsyrFSdE5oZ/O9GEf00kPngmOfVwazR5GKDq6EYfhlpFug3J2zybX56a2PRRpc9P+FuSoGNAwjlbDs9jJBPQ=="],
+
+    "lint-staged": ["lint-staged@16.4.0", "", { "dependencies": { "commander": "^14.0.3", "listr2": "^9.0.5", "picomatch": "^4.0.3", "string-argv": "^0.3.2", "tinyexec": "^1.0.4", "yaml": "^2.8.2" }, "bin": { "lint-staged": "bin/lint-staged.js" } }, "sha512-lBWt8hujh/Cjysw5GYVmZpFHXDCgZzhrOm8vbcUdobADZNOK/bRshr2kM3DfgrrtR1DQhfupW9gnIXOfiFi+bw=="],
+
+    "listenercount": ["listenercount@1.0.1", "", {}, "sha512-3mk/Zag0+IJxeDrxSgaDPy4zZ3w05PRZeJNnlWhzFz5OkX49J4krc+A8X2d2M69vGMBEX0uyl8M+W+8gH+kBqQ=="],
+
+    "listr2": ["listr2@9.0.5", "", { "dependencies": { "cli-truncate": "^5.0.0", "colorette": "^2.0.20", "eventemitter3": "^5.0.1", "log-update": "^6.1.0", "rfdc": "^1.4.1", "wrap-ansi": "^9.0.0" } }, "sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g=="],
+
+    "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
+
+    "lodash": ["lodash@4.18.1", "", {}, "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q=="],
+
+    "lodash-es": ["lodash-es@4.18.1", "", {}, "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A=="],
+
+    "lodash.camelcase": ["lodash.camelcase@4.3.0", "", {}, "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA=="],
+
+    "lodash.defaults": ["lodash.defaults@4.2.0", "", {}, "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ=="],
+
+    "lodash.difference": ["lodash.difference@4.5.0", "", {}, "sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA=="],
+
+    "lodash.escaperegexp": ["lodash.escaperegexp@4.1.2", "", {}, "sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw=="],
+
+    "lodash.flatten": ["lodash.flatten@4.4.0", "", {}, "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g=="],
+
+    "lodash.groupby": ["lodash.groupby@4.6.0", "", {}, "sha512-5dcWxm23+VAoz+awKmBaiBvzox8+RqMgFhi7UvX9DHZr2HdxHXM/Wrf8cfKpsW37RNrvtPn6hSwNqurSILbmJw=="],
+
+    "lodash.includes": ["lodash.includes@4.3.0", "", {}, "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="],
+
+    "lodash.isboolean": ["lodash.isboolean@3.0.3", "", {}, "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg=="],
+
+    "lodash.isequal": ["lodash.isequal@4.5.0", "", {}, "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ=="],
+
+    "lodash.isfunction": ["lodash.isfunction@3.0.9", "", {}, "sha512-AirXNj15uRIMMPihnkInB4i3NHeb4iBtNg9WRWuK2o31S+ePwwNmDPaTL3o7dTJ+VXNZim7rFs4rxN4YU1oUJw=="],
+
+    "lodash.isinteger": ["lodash.isinteger@4.0.4", "", {}, "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA=="],
+
+    "lodash.isnil": ["lodash.isnil@4.0.0", "", {}, "sha512-up2Mzq3545mwVnMhTDMdfoG1OurpA/s5t88JmQX809eH3C8491iu2sfKhTfhQtKY78oPNhiaHJUpT/dUDAAtng=="],
+
+    "lodash.isnumber": ["lodash.isnumber@3.0.3", "", {}, "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw=="],
+
+    "lodash.isplainobject": ["lodash.isplainobject@4.0.6", "", {}, "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="],
+
+    "lodash.isstring": ["lodash.isstring@4.0.1", "", {}, "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw=="],
+
+    "lodash.isundefined": ["lodash.isundefined@3.0.1", "", {}, "sha512-MXB1is3s899/cD8jheYYE2V9qTHwKvt+npCwpD+1Sxm3Q3cECXCiYHjeHWXNwr6Q0SOBPrYUDxendrO6goVTEA=="],
+
+    "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="],
+
+    "lodash.once": ["lodash.once@4.1.1", "", {}, "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg=="],
+
+    "lodash.snakecase": ["lodash.snakecase@4.1.1", "", {}, "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw=="],
+
+    "lodash.truncate": ["lodash.truncate@4.4.2", "", {}, "sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw=="],
+
+    "lodash.union": ["lodash.union@4.6.0", "", {}, "sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw=="],
+
+    "lodash.uniq": ["lodash.uniq@4.5.0", "", {}, "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ=="],
+
+    "log-symbols": ["log-symbols@4.1.0", "", { "dependencies": { "chalk": "^4.1.0", "is-unicode-supported": "^0.1.0" } }, "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg=="],
+
+    "log-update": ["log-update@6.1.0", "", { "dependencies": { "ansi-escapes": "^7.0.0", "cli-cursor": "^5.0.0", "slice-ansi": "^7.1.0", "strip-ansi": "^7.1.0", "wrap-ansi": "^9.0.0" } }, "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w=="],
+
+    "logform": ["logform@2.7.0", "", { "dependencies": { "@colors/colors": "1.6.0", "@types/triple-beam": "^1.3.2", "fecha": "^4.2.0", "ms": "^2.1.1", "safe-stable-stringify": "^2.3.1", "triple-beam": "^1.3.0" } }, "sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ=="],
+
+    "long": ["long@5.3.2", "", {}, "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA=="],
+
+    "longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="],
+
+    "loose-envify": ["loose-envify@1.4.0", "", { "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": { "loose-envify": "cli.js" } }, "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q=="],
+
+    "lop": ["lop@0.4.2", "", { "dependencies": { "duck": "^0.1.12", "option": "~0.2.1", "underscore": "^1.13.1" } }, "sha512-RefILVDQ4DKoRZsJ4Pj22TxE3omDO47yFpkIBoDKzkqPRISs5U1cnAdg/5583YPkWPaLIYHOKRMQSvjFsO26cw=="],
+
+    "loupe": ["loupe@2.3.7", "", { "dependencies": { "get-func-name": "^2.0.1" } }, "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA=="],
+
+    "lowlight": ["lowlight@3.3.0", "", { "dependencies": { "@types/hast": "^3.0.0", "devlop": "^1.0.0", "highlight.js": "~11.11.0" } }, "sha512-0JNhgFoPvP6U6lE/UdVsSq99tn6DhjjpAj5MxG49ewd2mOBVtwWYIT8ClyABhq198aXXODMU6Ox8DrGy/CpTZQ=="],
+
+    "lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],
+
+    "lucide-react": ["lucide-react@0.577.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-4LjoFv2eEPwYDPg/CUdBJQSDfPyzXCRrVW1X7jrx/trgxnxkHFjnVZINbzvzxjN70dxychOfg+FTYwBiS3pQ5A=="],
+
+    "lz-string": ["lz-string@1.5.0", "", { "bin": { "lz-string": "bin/bin.js" } }, "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ=="],
+
+    "macos-release": ["macos-release@3.5.1", "", {}, "sha512-Lci/1in+elqZ589PXnfP/iwZXpwQifTM94WJRQwG2tZSdfY7NfB/aUaTARHrohWCgHlXoabeaeXRDOnF5X9JQw=="],
+
+    "magic-bytes.js": ["magic-bytes.js@1.13.0", "", {}, "sha512-afO2mnxW7GDTXMm5/AoN1WuOcdoKhtgXjIvHmobqTD1grNplhGdv3PFOyjCVmrnOZBIT/gD/koDKpYG+0mvHcg=="],
+
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
+    "magicast": ["magicast@0.3.5", "", { "dependencies": { "@babel/parser": "^7.25.4", "@babel/types": "^7.25.4", "source-map-js": "^1.2.0" } }, "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ=="],
+
+    "make-dir": ["make-dir@4.0.0", "", { "dependencies": { "semver": "^7.5.3" } }, "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw=="],
+
+    "make-error": ["make-error@1.3.6", "", {}, "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw=="],
+
+    "mammoth": ["mammoth@1.12.0", "", { "dependencies": { "@xmldom/xmldom": "^0.8.6", "argparse": "~1.0.3", "base64-js": "^1.5.1", "bluebird": "~3.4.0", "dingbat-to-unicode": "^1.0.1", "jszip": "^3.7.1", "lop": "^0.4.2", "path-is-absolute": "^1.0.0", "underscore": "^1.13.1", "xmlbuilder": "^10.0.0" }, "bin": { "mammoth": "bin/mammoth" } }, "sha512-cwnK1RIcRdDMi2HRx2EXGYlxqIEh0Oo3bLhorgnsVJi2UkbX1+jKxuBNR9PC5+JaX7EkmJxFPmo6mjLpqShI2w=="],
+
+    "markdown-it": ["markdown-it@14.3.0", "", { "dependencies": { "argparse": "^2.0.1", "entities": "^4.5.0", "linkify-it": "^5.0.2", "mdurl": "^2.0.0", "punycode.js": "^2.3.1", "uc.micro": "^2.1.0" }, "bin": { "markdown-it": "bin/markdown-it.mjs" } }, "sha512-RCEsPjR+sr0x+AuYp601tKTkgFG4YEPLCzHST3cQ/fhlJkqAkz1L2/Qbp1j9qw5SBwQHFBoW8+hoN5xssOF0Tw=="],
+
+    "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="],
+
+    "marked": ["marked@15.0.12", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA=="],
+
+    "marky": ["marky@1.3.0", "", {}, "sha512-ocnPZQLNpvbedwTy9kNrQEsknEfgvcLMvOtz3sFeWApDq1MXH1TqkCIx58xlpESsfwQOnuBO9beyQuNGzVvuhQ=="],
+
+    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
+
+    "mdast-util-definitions": ["mdast-util-definitions@4.0.0", "", { "dependencies": { "unist-util-visit": "^2.0.0" } }, "sha512-k8AJ6aNnUkB7IE+5azR9h81O5EQ/cTDXtWdMq9Kk5KcEW/8ritU5CeLg/9HhOC++nALHBlaogJ5jz0Ybk3kPMQ=="],
+
+    "mdast-util-find-and-replace": ["mdast-util-find-and-replace@3.0.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "escape-string-regexp": "^5.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg=="],
+
+    "mdast-util-from-markdown": ["mdast-util-from-markdown@2.0.3", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "mdast-util-to-string": "^4.0.0", "micromark": "^4.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q=="],
+
+    "mdast-util-gfm": ["mdast-util-gfm@3.1.0", "", { "dependencies": { "mdast-util-from-markdown": "^2.0.0", "mdast-util-gfm-autolink-literal": "^2.0.0", "mdast-util-gfm-footnote": "^2.0.0", "mdast-util-gfm-strikethrough": "^2.0.0", "mdast-util-gfm-table": "^2.0.0", "mdast-util-gfm-task-list-item": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ=="],
+
+    "mdast-util-gfm-autolink-literal": ["mdast-util-gfm-autolink-literal@2.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "ccount": "^2.0.0", "devlop": "^1.0.0", "mdast-util-find-and-replace": "^3.0.0", "micromark-util-character": "^2.0.0" } }, "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ=="],
+
+    "mdast-util-gfm-footnote": ["mdast-util-gfm-footnote@2.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.1.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0" } }, "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ=="],
+
+    "mdast-util-gfm-strikethrough": ["mdast-util-gfm-strikethrough@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg=="],
+
+    "mdast-util-gfm-table": ["mdast-util-gfm-table@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "markdown-table": "^3.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg=="],
+
+    "mdast-util-gfm-task-list-item": ["mdast-util-gfm-task-list-item@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ=="],
+
+    "mdast-util-math": ["mdast-util-math@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "longest-streak": "^3.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.1.0", "unist-util-remove-position": "^5.0.0" } }, "sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w=="],
+
+    "mdast-util-mdx-expression": ["mdast-util-mdx-expression@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ=="],
+
+    "mdast-util-mdx-jsx": ["mdast-util-mdx-jsx@3.2.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "devlop": "^1.1.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "parse-entities": "^4.0.0", "stringify-entities": "^4.0.0", "unist-util-stringify-position": "^4.0.0", "vfile-message": "^4.0.0" } }, "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q=="],
+
+    "mdast-util-mdxjs-esm": ["mdast-util-mdxjs-esm@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg=="],
+
+    "mdast-util-phrasing": ["mdast-util-phrasing@4.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "unist-util-is": "^6.0.0" } }, "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w=="],
+
+    "mdast-util-to-hast": ["mdast-util-to-hast@13.2.1", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA=="],
+
+    "mdast-util-to-markdown": ["mdast-util-to-markdown@2.1.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "longest-streak": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-string": "^4.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA=="],
+
+    "mdast-util-to-markdown-cjk-friendly": ["mdast-util-to-markdown-cjk-friendly@1.0.0", "", { "dependencies": { "mdast-util-to-markdown": "^2.1.2", "micromark-extension-cjk-friendly-util": "3.0.1", "micromark-util-symbol": "^2.0.1" }, "peerDependencies": { "@types/mdast": "*" }, "optionalPeers": ["@types/mdast"] }, "sha512-BoaAm8mlJ+LAYz0Qs532Y3ciTuQYgBUPZcSFbvC/ZKmEMAKgulw84YvQK1gI34t/vL2euSfuaWlqczkTBgamkw=="],
+
+    "mdast-util-to-markdown-cjk-friendly-gfm-strikethrough": ["mdast-util-to-markdown-cjk-friendly-gfm-strikethrough@1.0.0", "", { "dependencies": { "mdast-util-gfm-strikethrough": "^2.0.0", "mdast-util-to-markdown": "^2.1.2", "micromark-extension-cjk-friendly-util": "3.0.1", "micromark-util-symbol": "^2.0.1" }, "peerDependencies": { "@types/mdast": "*" }, "optionalPeers": ["@types/mdast"] }, "sha512-1ePVfB4P/vz3xSsm6H3D32r6VYGErxclnuLLFK02/2ReF+UdEKm7caulK6Vm0LBIp5gPRtB2Z1OYDznCkX3k2w=="],
+
+    "mdast-util-to-string": ["mdast-util-to-string@4.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0" } }, "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg=="],
+
+    "mdn-data": ["mdn-data@2.0.14", "", {}, "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow=="],
+
+    "mdurl": ["mdurl@2.0.0", "", {}, "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w=="],
+
+    "media-chrome": ["media-chrome@4.19.2", "", { "dependencies": { "ce-la-react": "^0.3.2" } }, "sha512-4ai1ITN8wBhwugQcRgqe3tN0z6OSKGOXqHLNrS04MgKFfsLqu6Dm8MPq02pI9Y9ZKoXtFjIl85jOryIW9es3BA=="],
+
+    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],
+
+    "merge-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="],
+
+    "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="],
+
+    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+
+    "mermaid": ["mermaid@11.16.0", "", { "dependencies": { "@braintree/sanitize-url": "^7.1.2", "@iconify/utils": "^3.0.2", "@mermaid-js/parser": "^1.2.0", "@types/d3": "^7.4.3", "@upsetjs/venn.js": "^2.0.0", "cytoscape": "^3.33.3", "cytoscape-cose-bilkent": "^4.1.0", "cytoscape-fcose": "^2.2.0", "d3": "^7.9.0", "d3-sankey": "^0.12.3", "dagre-d3-es": "7.0.14", "dayjs": "^1.11.20", "dompurify": "^3.3.3", "es-toolkit": "^1.45.1", "katex": "^0.16.45", "khroma": "^2.1.0", "marked": "^16.3.0", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0 || ^12 || ^13 || ^14.0.0" } }, "sha512-Zvm3kbstgdpvIJPPItlL7fppIZ3kibvc1oZIGxdvk9t6UFz6flv+Jw7FtRGKwfcI8OckmH04LqG6LlS6X4B1pA=="],
+
+    "micromark": ["micromark@4.0.2", "", { "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA=="],
+
+    "micromark-core-commonmark": ["micromark-core-commonmark@2.0.3", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg=="],
+
+    "micromark-extension-cjk-friendly": ["micromark-extension-cjk-friendly@2.0.1", "", { "dependencies": { "devlop": "^1.1.0", "micromark-extension-cjk-friendly-util": "3.0.1", "micromark-util-chunked": "^2.0.1", "micromark-util-resolve-all": "^2.0.1", "micromark-util-symbol": "^2.0.1" }, "peerDependencies": { "micromark": "^4.0.0", "micromark-util-types": "^2.0.0" }, "optionalPeers": ["micromark-util-types"] }, "sha512-OkzoYVTL1ChbvQ8Cc1ayTIz7paFQz8iS9oIYmewncweUSwmWR+hkJF9spJ1lxB90XldJl26A1F4IkPOKS3bDXw=="],
+
+    "micromark-extension-cjk-friendly-gfm-strikethrough": ["micromark-extension-cjk-friendly-gfm-strikethrough@2.0.1", "", { "dependencies": { "devlop": "^1.1.0", "get-east-asian-width": "^1.4.0", "micromark-extension-cjk-friendly-util": "3.0.1", "micromark-util-character": "^2.1.1", "micromark-util-chunked": "^2.0.1", "micromark-util-resolve-all": "^2.0.1", "micromark-util-symbol": "^2.0.1" }, "peerDependencies": { "micromark": "^4.0.0", "micromark-util-types": "^2.0.0" }, "optionalPeers": ["micromark-util-types"] }, "sha512-wVC0zwjJNqQeX+bb07YTPu/CvSAyCTafyYb7sMhX1r62/Lw5M/df3JyYaANyp8g15c1ypJRFSsookTqA1IDsUg=="],
+
+    "micromark-extension-cjk-friendly-util": ["micromark-extension-cjk-friendly-util@3.0.1", "", { "dependencies": { "get-east-asian-width": "^1.4.0", "micromark-util-character": "^2.1.1", "micromark-util-symbol": "^2.0.1" } }, "sha512-GcbXqTTHOsiZHyF753oIddP/J2eH8j9zpyQPhkof6B2JNxfEJabnQqxbCgzJNuNes0Y2jTNJ3LiYPSXr6eJA8w=="],
+
+    "micromark-extension-gfm": ["micromark-extension-gfm@3.0.0", "", { "dependencies": { "micromark-extension-gfm-autolink-literal": "^2.0.0", "micromark-extension-gfm-footnote": "^2.0.0", "micromark-extension-gfm-strikethrough": "^2.0.0", "micromark-extension-gfm-table": "^2.0.0", "micromark-extension-gfm-tagfilter": "^2.0.0", "micromark-extension-gfm-task-list-item": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w=="],
+
+    "micromark-extension-gfm-autolink-literal": ["micromark-extension-gfm-autolink-literal@2.1.0", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw=="],
+
+    "micromark-extension-gfm-footnote": ["micromark-extension-gfm-footnote@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw=="],
+
+    "micromark-extension-gfm-strikethrough": ["micromark-extension-gfm-strikethrough@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw=="],
+
+    "micromark-extension-gfm-table": ["micromark-extension-gfm-table@2.1.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg=="],
+
+    "micromark-extension-gfm-tagfilter": ["micromark-extension-gfm-tagfilter@2.0.0", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg=="],
+
+    "micromark-extension-gfm-task-list-item": ["micromark-extension-gfm-task-list-item@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw=="],
+
+    "micromark-extension-math": ["micromark-extension-math@3.1.0", "", { "dependencies": { "@types/katex": "^0.16.0", "devlop": "^1.0.0", "katex": "^0.16.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg=="],
+
+    "micromark-factory-destination": ["micromark-factory-destination@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA=="],
+
+    "micromark-factory-label": ["micromark-factory-label@2.0.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg=="],
+
+    "micromark-factory-space": ["micromark-factory-space@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg=="],
+
+    "micromark-factory-title": ["micromark-factory-title@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw=="],
+
+    "micromark-factory-whitespace": ["micromark-factory-whitespace@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ=="],
+
+    "micromark-util-character": ["micromark-util-character@2.1.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q=="],
+
+    "micromark-util-chunked": ["micromark-util-chunked@2.0.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA=="],
+
+    "micromark-util-classify-character": ["micromark-util-classify-character@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q=="],
+
+    "micromark-util-combine-extensions": ["micromark-util-combine-extensions@2.0.1", "", { "dependencies": { "micromark-util-chunked": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg=="],
+
+    "micromark-util-decode-numeric-character-reference": ["micromark-util-decode-numeric-character-reference@2.0.2", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw=="],
+
+    "micromark-util-decode-string": ["micromark-util-decode-string@2.0.1", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ=="],
+
+    "micromark-util-encode": ["micromark-util-encode@2.0.1", "", {}, "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw=="],
+
+    "micromark-util-html-tag-name": ["micromark-util-html-tag-name@2.0.1", "", {}, "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA=="],
+
+    "micromark-util-normalize-identifier": ["micromark-util-normalize-identifier@2.0.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q=="],
+
+    "micromark-util-resolve-all": ["micromark-util-resolve-all@2.0.1", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg=="],
+
+    "micromark-util-sanitize-uri": ["micromark-util-sanitize-uri@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ=="],
+
+    "micromark-util-subtokenize": ["micromark-util-subtokenize@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA=="],
+
+    "micromark-util-symbol": ["micromark-util-symbol@2.0.1", "", {}, "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q=="],
+
+    "micromark-util-types": ["micromark-util-types@2.0.2", "", {}, "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="],
+
+    "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
+
+    "mime": ["mime@1.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="],
+
+    "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],
+
+    "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="],
+
+    "mimic-fn": ["mimic-fn@3.1.0", "", {}, "sha512-Ysbi9uYW9hFyfrThdDEQuykN4Ey6BuwPD2kpI5ES/nFTDn/98yxYNLZJcgUAKPT/mcrLLKaGzJR9YVxJrIdASQ=="],
+
+    "mimic-function": ["mimic-function@5.0.1", "", {}, "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA=="],
+
+    "mimic-response": ["mimic-response@3.1.0", "", {}, "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="],
+
+    "min-indent": ["min-indent@1.0.1", "", {}, "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg=="],
+
+    "minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="],
+
+    "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
+
+    "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="],
+
+    "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="],
+
+    "mitt": ["mitt@3.0.1", "", {}, "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="],
+
+    "mkdirp": ["mkdirp@3.0.1", "", { "bin": { "mkdirp": "dist/cjs/src/bin.js" } }, "sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg=="],
+
+    "mkdirp-classic": ["mkdirp-classic@0.5.3", "", {}, "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="],
+
+    "mocha": ["mocha@11.7.6", "", { "dependencies": { "browser-stdout": "^1.3.1", "chokidar": "^4.0.1", "debug": "^4.3.5", "diff": "^7.0.0", "escape-string-regexp": "^4.0.0", "find-up": "^5.0.0", "glob": "^10.4.5", "he": "^1.2.0", "is-path-inside": "^3.0.3", "js-yaml": "^4.1.0", "log-symbols": "^4.1.0", "minimatch": "^9.0.5", "ms": "^2.1.3", "picocolors": "^1.1.1", "serialize-javascript": "^6.0.2", "strip-json-comments": "^3.1.1", "supports-color": "^8.1.1", "workerpool": "^9.2.0", "yargs": "^17.7.2", "yargs-parser": "^21.1.1", "yargs-unparser": "^2.0.0" }, "bin": { "mocha": "bin/mocha.js", "_mocha": "bin/_mocha" } }, "sha512-nS9xOGbw2I3cjCpxwZAEJ9xK9lmJ08vEkQvLtz4du9ZrF9UrjRpeJGiIgl2Z+Qs++pmB4ecDe48Fwsh+j+j7xA=="],
+
+    "module-details-from-path": ["module-details-from-path@1.0.4", "", {}, "sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w=="],
+
+    "motion": ["motion@12.42.2", "", { "dependencies": { "framer-motion": "^12.42.2", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-Atvv11yUKIid41cVrRBDVX5m8tF8kNpExRSlbpt6APClhDjtwQssgFHhQzejxw7/7YYbjHSPKBVbHo05BuJT5Q=="],
+
+    "motion-dom": ["motion-dom@12.42.2", "", { "dependencies": { "motion-utils": "^12.39.0" } }, "sha512-5gIMWLp/PycBtJRJWRgjxke5n8dlvkSn2DrYW+tr3XcqAZY1xZh6BJyooJXCM8wdfM7wfMjkBJNLge1CKPUIRA=="],
+
+    "motion-utils": ["motion-utils@12.39.0", "", {}, "sha512-8nadJAJjTtqRkmRF36FoJTrywK9nnFmnPwnSMyxaOCU7GDjN9RTMJIxx9De8ErM+vpPhMccr/6fo5WciyQLnMQ=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "mute-stream": ["mute-stream@0.0.8", "", {}, "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA=="],
+
+    "nano-css": ["nano-css@5.6.2", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.4.15", "css-tree": "^1.1.2", "csstype": "^3.1.2", "fastest-stable-stringify": "^2.0.2", "inline-style-prefixer": "^7.0.1", "rtl-css-js": "^1.16.1", "stacktrace-js": "^2.0.2", "stylis": "^4.3.0" }, "peerDependencies": { "react": "*", "react-dom": "*" } }, "sha512-+6bHaC8dSDGALM1HJjOHVXpuastdu2xFoZlC77Jh4cg+33Zcgm+Gxd+1xsnpZK14eyHObSp82+ll5y3SX75liw=="],
+
+    "nanoid": ["nanoid@5.1.16", "", { "bin": { "nanoid": "bin/nanoid.js" } }, "sha512-kVrnsrJqMR8+oLJnGEmSWw9BivK5mt7H3FZatVRjrc5wGqFYuBxX1yG7+A7Gi5AefkX6t/oCkizcQgpu0cY1dQ=="],
+
+    "napi-build-utils": ["napi-build-utils@2.0.0", "", {}, "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA=="],
+
+    "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="],
+
+    "negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="],
+
+    "netmask": ["netmask@2.1.1", "", {}, "sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA=="],
+
+    "next": ["next@16.2.6", "", { "dependencies": { "@next/env": "16.2.6", "@swc/helpers": "0.5.15", "baseline-browser-mapping": "^2.9.19", "caniuse-lite": "^1.0.30001579", "postcss": "8.4.31", "styled-jsx": "5.1.6" }, "optionalDependencies": { "@next/swc-darwin-arm64": "16.2.6", "@next/swc-darwin-x64": "16.2.6", "@next/swc-linux-arm64-gnu": "16.2.6", "@next/swc-linux-arm64-musl": "16.2.6", "@next/swc-linux-x64-gnu": "16.2.6", "@next/swc-linux-x64-musl": "16.2.6", "@next/swc-win32-arm64-msvc": "16.2.6", "@next/swc-win32-x64-msvc": "16.2.6", "sharp": "^0.34.5" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.51.1", "babel-plugin-react-compiler": "*", "react": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "react-dom": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "babel-plugin-react-compiler", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-qOVgKJg1+At15NpeUP+eJgCHvTCgXsogweq87Ri/Ix7PkqQHg4sdaXmSFqKlgaIXE4kW0g25LE68W87UANlHtw=="],
+
+    "next-themes": ["next-themes@0.4.6", "", { "peerDependencies": { "react": "^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc", "react-dom": "^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc" } }, "sha512-pZvgD5L0IEvX5/9GWyHMf3m8BKiVQwsCMHfoFosXtXBMnaS0ZnIJ9ST4b4NqLVKDEm8QBxoNNGNaBv2JNF6XNA=="],
+
+    "nice-grpc": ["nice-grpc@2.1.16", "", { "dependencies": { "@grpc/grpc-js": "^1.14.0", "abort-controller-x": "^0.5.0", "nice-grpc-common": "^2.0.3" } }, "sha512-Cl3Pn00212Hl8/U6bpgMxmhZj5lyv3nWoJov4cd3FjWarktrMHP4DNvSjCnDwkMWYx4W1tyscEia4JX6Y4GVCQ=="],
+
+    "nice-grpc-common": ["nice-grpc-common@2.0.3", "", { "dependencies": { "ts-error": "^1.0.6" } }, "sha512-MEhnD3JMah0mgyivpb9hpRDbOBuXBxI/TVO+OK1h6rC97WM42HsPMR+zzRNQ0C5BqYJTw1nyWiQRD0DucO+pjQ=="],
+
+    "node-abi": ["node-abi@3.93.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-Cu6yUpX5Iavugm8BeX7c0wgU9CvOqfd1yM6A1d2q2ZMjym7GjpASv2GdRcTq3Fx+Sb5OgBkEEpw4VnAbY6Y5RA=="],
+
+    "node-addon-api": ["node-addon-api@7.1.1", "", {}, "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ=="],
+
+    "node-cache": ["node-cache@5.1.2", "", { "dependencies": { "clone": "2.x" } }, "sha512-t1QzWwnk4sjLWaQAS8CHgOJ+RAfmHpxFWmc36IWTiWHQfs0w5JDMBS1b1ZxQteo0vVVuWJvIUKHDkkeK7vIGCg=="],
+
+    "node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="],
+
+    "node-ensure": ["node-ensure@0.0.0", "", {}, "sha512-DRI60hzo2oKN1ma0ckc6nQWlHU69RH6xN0sjQTjMpChPfTYvKZdcQFfdYK2RWbJcKyUizSIy/l8OTGxMAM1QDw=="],
+
+    "node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
+
+    "node-forge": ["node-forge@1.4.0", "", {}, "sha512-LarFH0+6VfriEhqMMcLX2F7SwSXeWwnEAJEsYm5QKWchiVYVvJyV9v7UDvUv+w5HO23ZpQTXDv/GxdDdMyOuoQ=="],
+
+    "node-int64": ["node-int64@0.4.0", "", {}, "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw=="],
+
+    "node-machine-id": ["node-machine-id@1.1.12", "", {}, "sha512-QNABxbrPa3qEIfrE6GOJ7BYIuignnJw7iQ2YPbc3Nla1HzRJjXzZOiikfF8m7eAMfichLt3M4VgLOetqgDmgGQ=="],
+
+    "node-pty": ["node-pty@1.2.0-beta.11", "", { "dependencies": { "node-addon-api": "^7.1.0" } }, "sha512-THcUyu1WwdgoIyUvgXOZ70EOMXzheGa0q3tbEb5kUIfKgcpBJ+AJ9Q1kq0bKtYmQzr77usXiTORZTLmAUQlnoQ=="],
+
+    "node-releases": ["node-releases@2.0.50", "", {}, "sha512-J6l92tKHX6w8Jy5nO1Vuc01NoIiRGi/d6qBKVxh+IQ8Cr3b6HbVNfKiF8ZpFKufTwpwxMmce2W3iQZ861ZRyTg=="],
+
+    "node-rsa": ["node-rsa@1.1.1", "", { "dependencies": { "asn1": "^0.2.4" } }, "sha512-Jd4cvbJMryN21r5HgxQOpMEqv+ooke/korixNNK3mGqfGJmy0M77WDDzo/05969+OkMy3XW1UuZsSmW9KQm7Fw=="],
+
+    "node-sarif-builder": ["node-sarif-builder@3.4.0", "", { "dependencies": { "@types/sarif": "^2.1.7", "fs-extra": "^11.1.1" } }, "sha512-tGnJW6OKRii9u/b2WiUViTJS+h7Apxx17qsMUjsUeNDiMMX5ZFf8F8Fcz7PAQ6omvOxHZtvDTmOYKJQwmfpjeg=="],
+
+    "nopt": ["nopt@8.1.0", "", { "dependencies": { "abbrev": "^3.0.0" }, "bin": { "nopt": "bin/nopt.js" } }, "sha512-ieGu42u/Qsa4TFktmaKEwM6MQH0pOWnaB3htzh0JRtx84+Mebc0cbZYN5bC+6WTZ4+77xrL9Pn5m7CV6VIkV7A=="],
+
+    "normalize-package-data": ["normalize-package-data@6.0.2", "", { "dependencies": { "hosted-git-info": "^7.0.0", "semver": "^7.3.5", "validate-npm-package-license": "^3.0.4" } }, "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g=="],
+
+    "normalize-path": ["normalize-path@3.0.0", "", {}, "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="],
+
+    "npm-run-path": ["npm-run-path@6.0.0", "", { "dependencies": { "path-key": "^4.0.0", "unicorn-magic": "^0.3.0" } }, "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA=="],
+
+    "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="],
+
+    "nwsapi": ["nwsapi@2.2.24", "", {}, "sha512-7YRhZ3jS45LwmSCT4b2sVFHt/WuovaktDU07QrtOBY2PXskss5a9jfmR9jptyumwXST+rFjrmppMY1KT/yn35A=="],
+
+    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
+
+    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
+
+    "object-treeify": ["object-treeify@1.1.33", "", {}, "sha512-EFVjAYfzWqWsBMRHPMAXLCDIJnpMhdWAqR7xG6M6a2cs6PMFpl/+Z20w9zDW4vkxOFfddegBKq9Rehd0bxWE7A=="],
+
+    "obug": ["obug@2.1.3", "", {}, "sha512-9miFgM2OFba7hB+pRgvtV84pYTBaoTHohvmIgiRt6dRIzbwEOIaNaP+dIlGs2fNFoB0SeISs0Jz5WFVRid6Xyg=="],
+
+    "omggif": ["omggif@1.0.10", "", {}, "sha512-LMJTtvgc/nugXj0Vcrrs68Mn2D1r0zf630VNtqtpI1FEO7e+O9FP4gqs9AcnBaSEeoHIPm28u6qgPR0oyEpGSw=="],
+
+    "on-exit-leak-free": ["on-exit-leak-free@2.1.2", "", {}, "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA=="],
+
+    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
+
+    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],
+
+    "one-time": ["one-time@1.0.0", "", { "dependencies": { "fn.name": "1.x.x" } }, "sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g=="],
+
+    "onetime": ["onetime@5.1.2", "", { "dependencies": { "mimic-fn": "^2.1.0" } }, "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg=="],
+
+    "oniguruma-parser": ["oniguruma-parser@0.12.2", "", {}, "sha512-6HVa5oIrgMC6aA6WF6XyyqbhRPJrKR02L20+2+zpDtO5QAzGHAUGw5TKQvwi5vctNnRHkJYmjAhRVQF2EKdTQw=="],
+
+    "oniguruma-to-es": ["oniguruma-to-es@4.3.6", "", { "dependencies": { "oniguruma-parser": "^0.12.2", "regex": "^6.1.0", "regex-recursion": "^6.0.2" } }, "sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA=="],
+
+    "open": ["open@10.2.0", "", { "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", "is-inside-container": "^1.0.0", "wsl-utils": "^0.1.0" } }, "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA=="],
+
+    "open-graph-scraper": ["open-graph-scraper@6.12.0", "", { "dependencies": { "chardet": "^2.2.0", "cheerio": "^1.2.0", "iconv-lite": "^0.7.2", "undici": "^7.28.0" } }, "sha512-x0fS3eHxdCox+rFBhQSVe+qBznSPn1pspp8A4BoaVEkiECZEwagEb8z06swLfaFFE2gefj1BvEBeJmdeGTDnYw=="],
+
+    "openai": ["openai@6.45.0", "", { "peerDependencies": { "@aws-sdk/credential-provider-node": ">=3.972.0 <4", "@smithy/hash-node": ">=4.3.0 <5", "@smithy/signature-v4": ">=5.4.0 <6", "ws": "^8.18.0", "zod": "^3.25 || ^4.0" }, "optionalPeers": ["@aws-sdk/credential-provider-node", "@smithy/hash-node", "@smithy/signature-v4", "ws", "zod"] }, "sha512-5DQVNErssk0afNpTTHUm/qZPU4iKR9OYdNid8Ib4puq4gHNNvGWZht2zY4h9a8JMF949Ik6m8gQutllVPbjdnw=="],
+
+    "opentui-spinner": ["opentui-spinner@0.0.6", "", { "dependencies": { "cli-spinners": "^3.3.0" }, "peerDependencies": { "@opentui/core": "^0.1.49", "@opentui/react": "^0.1.49", "@opentui/solid": "^0.1.49", "typescript": "^5" }, "optionalPeers": ["@opentui/react", "@opentui/solid"] }, "sha512-xupLOeVQEAXEvVJCvHkfX6fChDWmJIPHe5jyUrVb8+n4XVTX8mBNhitFfB9v2ZbkC1H2UwPab/ElePHoW37NcA=="],
+
+    "opossum": ["opossum@9.0.0", "", {}, "sha512-K76U0QkxOfUZamneQuzz+AP0fyfTJcCplZ2oZL93nxeupuJbN4s6uFNbmVCt4eWqqGqRnnowdFuBicJ1fLMVxw=="],
+
+    "option": ["option@0.2.4", "", {}, "sha512-pkEqbDyl8ou5cpq+VsnQbe/WlEy5qS7xPzMS1U55OCG9KPvwFD46zDbxQIj3egJSFc3D+XhYOPUzz49zQAVy7A=="],
+
+    "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="],
+
+    "ora": ["ora@8.2.0", "", { "dependencies": { "chalk": "^5.3.0", "cli-cursor": "^5.0.0", "cli-spinners": "^2.9.2", "is-interactive": "^2.0.0", "is-unicode-supported": "^2.0.0", "log-symbols": "^6.0.0", "stdin-discarder": "^0.2.2", "string-width": "^7.2.0", "strip-ansi": "^7.1.0" } }, "sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw=="],
+
+    "os-name": ["os-name@6.1.0", "", { "dependencies": { "macos-release": "^3.3.0", "windows-release": "^6.1.0" } }, "sha512-zBd1G8HkewNd2A8oQ8c6BN/f/c9EId7rSUueOLGu28govmUctXmM+3765GwsByv9nYUdrLqHphXlYIc86saYsg=="],
+
+    "p-finally": ["p-finally@1.0.0", "", {}, "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow=="],
+
+    "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
+
+    "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
+
+    "p-map": ["p-map@7.0.5", "", {}, "sha512-e8vJF4XdVkzqqSHguEMz41mQO1wKwxKm5ENrUJQUu9kLDCtn83cxbyHZcszr4QC5zEA7WffRRC4gsTecC7J9oA=="],
+
+    "p-mutex": ["p-mutex@1.0.0", "", { "dependencies": { "yocto-queue": "^1.2.1" } }, "sha512-UlthGzEMsg2VnZAR58wkzL7muskxtNamoTR1Q6/VYBUKqPaMM+YtSncjWIvyjfUvVECKck1SYC/4XIWWJU3gBw=="],
+
+    "p-queue": ["p-queue@6.6.2", "", { "dependencies": { "eventemitter3": "^4.0.4", "p-timeout": "^3.2.0" } }, "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ=="],
+
+    "p-retry": ["p-retry@4.6.2", "", { "dependencies": { "@types/retry": "0.12.0", "retry": "^0.13.1" } }, "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ=="],
+
+    "p-timeout": ["p-timeout@6.1.4", "", {}, "sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg=="],
+
+    "p-try": ["p-try@2.2.0", "", {}, "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ=="],
+
+    "p-wait-for": ["p-wait-for@5.0.2", "", { "dependencies": { "p-timeout": "^6.0.0" } }, "sha512-lwx6u1CotQYPVju77R+D0vFomni/AqRfqLmqQ8hekklqZ6gAY9rONh7lBQ0uxWMkC2AuX9b2DVAl8To0NyP1JA=="],
+
+    "pac-proxy-agent": ["pac-proxy-agent@7.2.0", "", { "dependencies": { "@tootallnate/quickjs-emscripten": "^0.23.0", "agent-base": "^7.1.2", "debug": "^4.3.4", "get-uri": "^6.0.1", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.6", "pac-resolver": "^7.0.1", "socks-proxy-agent": "^8.0.5" } }, "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA=="],
+
+    "pac-resolver": ["pac-resolver@7.0.1", "", { "dependencies": { "degenerator": "^5.0.0", "netmask": "^2.0.2" } }, "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg=="],
+
+    "package-json-from-dist": ["package-json-from-dist@1.0.1", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="],
+
+    "package-manager-detector": ["package-manager-detector@1.7.0", "", {}, "sha512-xg1eHpwYL/D/HEdWw2goFZP6vV0FH7W+PZ5rFkGjdIDLtxq7EkzBUeT3m+lndYCt8wKbmofUu1MUdMCXkCk9ZQ=="],
+
+    "pako": ["pako@1.0.11", "", {}, "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw=="],
+
+    "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="],
+
+    "parse-bmfont-ascii": ["parse-bmfont-ascii@1.0.6", "", {}, "sha512-U4RrVsUFCleIOBsIGYOMKjn9PavsGOXxbvYGtMOEfnId0SVNsgehXh1DxUdVPLoxd5mvcEtvmKs2Mmf0Mpa1ZA=="],
+
+    "parse-bmfont-binary": ["parse-bmfont-binary@1.0.6", "", {}, "sha512-GxmsRea0wdGdYthjuUeWTMWPqm2+FAd4GI8vCvhgJsFnoGhTrLhXDDupwTo7rXVAgaLIGoVHDZS9p/5XbSqeWA=="],
+
+    "parse-bmfont-xml": ["parse-bmfont-xml@1.1.6", "", { "dependencies": { "xml-parse-from-string": "^1.0.0", "xml2js": "^0.5.0" } }, "sha512-0cEliVMZEhrFDwMh4SxIyVJpqYoOWDJ9P895tFuS+XuNzI5UBmBk5U5O4KuJdTnZpSBI4LFA2+ZiJaiwfSwlMA=="],
+
+    "parse-entities": ["parse-entities@4.0.2", "", { "dependencies": { "@types/unist": "^2.0.0", "character-entities-legacy": "^3.0.0", "character-reference-invalid": "^2.0.0", "decode-named-character-reference": "^1.0.0", "is-alphanumerical": "^2.0.0", "is-decimal": "^2.0.0", "is-hexadecimal": "^2.0.0" } }, "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw=="],
+
+    "parse-json": ["parse-json@5.2.0", "", { "dependencies": { "@babel/code-frame": "^7.0.0", "error-ex": "^1.3.1", "json-parse-even-better-errors": "^2.3.0", "lines-and-columns": "^1.1.6" } }, "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg=="],
+
+    "parse-ms": ["parse-ms@3.0.0", "", {}, "sha512-Tpb8Z7r7XbbtBTrM9UhpkzzaMrqA2VXMT3YChzYltwV3P3pM6t8wl7TvpMnSTosz1aQAdVib7kdoys7vYOPerw=="],
+
+    "parse-semver": ["parse-semver@1.1.1", "", { "dependencies": { "semver": "^5.1.0" } }, "sha512-Eg1OuNntBMH0ojvEKSrvDSnwLmvVuUOSdylH/pSCPNMIspLlweJyIWXCE+k/5hm3cj/EBUYwmWkjhBALNP4LXQ=="],
+
+    "parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="],
+
+    "parse5-htmlparser2-tree-adapter": ["parse5-htmlparser2-tree-adapter@7.1.0", "", { "dependencies": { "domhandler": "^5.0.3", "parse5": "^7.0.0" } }, "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g=="],
+
+    "parse5-parser-stream": ["parse5-parser-stream@7.1.2", "", { "dependencies": { "parse5": "^7.0.0" } }, "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow=="],
+
+    "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
+
+    "path-browserify": ["path-browserify@1.0.1", "", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="],
+
+    "path-data-parser": ["path-data-parser@0.1.0", "", {}, "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w=="],
+
+    "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
+
+    "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="],
+
+    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
+    "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="],
+
+    "path-scurry": ["path-scurry@2.0.2", "", { "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" } }, "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg=="],
+
+    "path-to-regexp": ["path-to-regexp@8.4.2", "", {}, "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA=="],
+
+    "path-type": ["path-type@6.0.0", "", {}, "sha512-Vj7sf++t5pBD637NSfkxpHSMfWaeig5+DKWLhcqIYx6mWQz5hdJTGDVMQiJcw1ZYkhs7AazKDGpRVji1LJCZUQ=="],
+
+    "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "pathval": ["pathval@1.1.1", "", {}, "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ=="],
+
+    "pdf-parse": ["pdf-parse@1.1.4", "", { "dependencies": { "node-ensure": "^0.0.0" } }, "sha512-XRIRcLgk6ZnUbsHsYXExMw+krrPE81hJ6FQPLdBNhhBefqIQKXu/WeTgNBGSwPrfU0v+UCEwn7AoAUOsVKHFvQ=="],
+
+    "peek-readable": ["peek-readable@4.1.0", "", {}, "sha512-ZI3LnwUv5nOGbQzD9c2iDG6toheuXSZP5esSHBjopsXH4dg19soufvpUGA3uohi5anFtGb2lhAVdHzH6R/Evvg=="],
+
+    "pend": ["pend@1.2.0", "", {}, "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
+
+    "pino": ["pino@10.3.1", "", { "dependencies": { "@pinojs/redact": "^0.4.0", "atomic-sleep": "^1.0.0", "on-exit-leak-free": "^2.1.0", "pino-abstract-transport": "^3.0.0", "pino-std-serializers": "^7.0.0", "process-warning": "^5.0.0", "quick-format-unescaped": "^4.0.3", "real-require": "^0.2.0", "safe-stable-stringify": "^2.3.1", "sonic-boom": "^4.0.1", "thread-stream": "^4.0.0" }, "bin": { "pino": "bin.js" } }, "sha512-r34yH/GlQpKZbU1BvFFqOjhISRo1MNx1tWYsYvmj6KIRHSPMT2+yHOEb1SG6NMvRoHRF0a07kCOox/9yakl1vg=="],
+
+    "pino-abstract-transport": ["pino-abstract-transport@3.0.0", "", { "dependencies": { "split2": "^4.0.0" } }, "sha512-wlfUczU+n7Hy/Ha5j9a/gZNy7We5+cXp8YL+X+PG8S0KXxw7n/JXA3c46Y0zQznIJ83URJiwy7Lh56WLokNuxg=="],
+
+    "pino-std-serializers": ["pino-std-serializers@7.1.0", "", {}, "sha512-BndPH67/JxGExRgiX1dX0w1FvZck5Wa4aal9198SrRhZjH3GxKQUKIBnYJTdj2HDN3UQAS06HlfcSbQj2OHmaw=="],
+
+    "pixelmatch": ["pixelmatch@5.3.0", "", { "dependencies": { "pngjs": "^6.0.0" }, "bin": { "pixelmatch": "bin/pixelmatch" } }, "sha512-o8mkY4E/+LNUf6LzX96ht6k6CEDi65k9G2rjMtBe9Oo+VPKSvl+0GKHuH/AlG+GA5LPG/i5hrekkxUc3s2HU+Q=="],
+
+    "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
+
+    "pkg-up": ["pkg-up@3.1.0", "", { "dependencies": { "find-up": "^3.0.0" } }, "sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA=="],
+
+    "planck": ["planck@1.5.0", "", { "peerDependencies": { "stage-js": "^1.0.0-alpha.12" } }, "sha512-dlvqJE+FscZgrGUXJ5ybd0o5bvZ5XXyZNbm08xGsXp9WjXeAyWSFT6n9s/1PQcUBo4546fDXA5RMA4wbDyZw6g=="],
+
+    "playwright": ["playwright@1.61.1", "", { "dependencies": { "playwright-core": "1.61.1" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-DWnY5o3YbLWK4GovuAVwpqL+1VwGNdUGrRr++8j8PtQQzvAVZUIMjKQ90fY689sEJZJBbZVw1rXaOKSTitkzPQ=="],
+
+    "playwright-core": ["playwright-core@1.61.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg=="],
+
+    "pluralize": ["pluralize@8.0.0", "", {}, "sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA=="],
+
+    "pngjs": ["pngjs@7.0.0", "", {}, "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow=="],
+
+    "points-on-curve": ["points-on-curve@0.2.0", "", {}, "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="],
+
+    "points-on-path": ["points-on-path@0.2.1", "", { "dependencies": { "path-data-parser": "0.1.0", "points-on-curve": "0.2.0" } }, "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g=="],
+
+    "postcss": ["postcss@8.5.16", "", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg=="],
+
+    "postcss-selector-parser": ["postcss-selector-parser@7.1.4", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-HeP7D2wyhkR+XaK6v4W8oRF62Dsz4flyuczALJp61GckGm42u1saSSJ/0auvcBqxs3jMRFEcPK34At/0JBKdOg=="],
+
+    "postcss-value-parser": ["postcss-value-parser@4.2.0", "", {}, "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="],
+
+    "posthog-js": ["posthog-js@1.396.4", "", { "dependencies": { "@posthog/core": "^1.39.3", "@posthog/types": "^1.392.0", "core-js": "^3.38.1", "dompurify": "^3.3.2", "fflate": "^0.4.8", "preact": "^10.29.2", "query-selector-shadow-dom": "^1.0.1", "web-vitals": "^5.3.0" } }, "sha512-PycBmwKQD1T7YFYrGRb8rjQET/UVnexgUy8gVe6UBEhwHXEIhZF4na5VakJbn4zu1wg4tzjt8r7PA4VLu6bDjg=="],
+
+    "posthog-node": ["posthog-node@5.39.2", "", { "dependencies": { "@posthog/core": "^1.39.3" }, "peerDependencies": { "rxjs": "^7.0.0" }, "optionalPeers": ["rxjs"] }, "sha512-5piMedjlQ2x+UKLvHWTC5ls5/T1dDZKE1Pu5AKkYh9EkbZOjvu0cac6lWFB7mgbGkKQ0I1bhbjDx1QAYRJ7Unw=="],
+
+    "powershell-utils": ["powershell-utils@0.1.0", "", {}, "sha512-dM0jVuXJPsDN6DvRpea484tCUaMiXWjuCn++HGTqUWzGDjv5tZkEZldAJ/UMlqRYGFrD/etByo4/xOuC/snX2A=="],
+
+    "preact": ["preact@10.29.3", "", {}, "sha512-D9NL1GAnJZhc3RndVs4gDdxEeU9TcHgywMrhhOsnpdlvFjdbx0gAsLUnH6JEhlJH5giL7Tx5biWPUSEXE/HPzw=="],
+
+    "prebuild-install": ["prebuild-install@7.1.3", "", { "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", "github-from-package": "0.0.0", "minimist": "^1.2.3", "mkdirp-classic": "^0.5.3", "napi-build-utils": "^2.0.0", "node-abi": "^3.3.0", "pump": "^3.0.0", "rc": "^1.2.7", "simple-get": "^4.0.0", "tar-fs": "^2.0.0", "tunnel-agent": "^0.6.0" }, "bin": { "prebuild-install": "bin.js" } }, "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug=="],
+
+    "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="],
+
+    "pretty-bytes": ["pretty-bytes@6.1.1", "", {}, "sha512-mQUvGU6aUFQ+rNvTIAcZuWGRT9a6f6Yrg9bHs4ImKF+HZCEK+plBvnAZYSIQztknZF2qnzNtr6F8s0+IuptdlQ=="],
+
+    "pretty-format": ["pretty-format@30.4.1", "", { "dependencies": { "@jest/schemas": "30.4.1", "ansi-styles": "^5.2.0", "react-is-18": "npm:react-is@^18.3.1", "react-is-19": "npm:react-is@^19.2.5" } }, "sha512-K6KiKMHTL4jjX4u3Kir2EW07nRfcqVTXIImx50wbjHQTcZPgg+gjVeNTIT3l3L1Rd4UefxfogquC9J37SoFyyw=="],
+
+    "pretty-ms": ["pretty-ms@8.0.0", "", { "dependencies": { "parse-ms": "^3.0.0" } }, "sha512-ASJqOugUF1bbzI35STMBUpZqdfYKlJugy6JBziGi2EE+AL5JPJGSzvpeVXojxrr0ViUYoToUjb5kjSEGf7Y83Q=="],
+
+    "process": ["process@0.11.10", "", {}, "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A=="],
+
+    "process-nextick-args": ["process-nextick-args@2.0.1", "", {}, "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="],
+
+    "process-warning": ["process-warning@5.0.0", "", {}, "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA=="],
+
+    "progress": ["progress@2.0.3", "", {}, "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA=="],
+
+    "prompts": ["prompts@2.4.2", "", { "dependencies": { "kleur": "^3.0.3", "sisteransi": "^1.0.5" } }, "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q=="],
+
+    "prop-types": ["prop-types@15.8.1", "", { "dependencies": { "loose-envify": "^1.4.0", "object-assign": "^4.1.1", "react-is": "^16.13.1" } }, "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg=="],
+
+    "proper-lockfile": ["proper-lockfile@4.1.2", "", { "dependencies": { "graceful-fs": "^4.2.4", "retry": "^0.12.0", "signal-exit": "^3.0.2" } }, "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA=="],
+
+    "property-information": ["property-information@7.2.0", "", {}, "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg=="],
+
+    "protobufjs": ["protobufjs@7.5.8", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.5", "@protobufjs/eventemitter": "^1.1.0", "@protobufjs/fetch": "^1.1.0", "@protobufjs/float": "^1.0.2", "@protobufjs/inquire": "^1.1.1", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.1", "@types/node": ">=13.7.0", "long": "^5.0.0" } }, "sha512-dvpCIeLPbXZS/Ete7yLaO7RenOdken2NHKykBXbsaGxZT0UTltcarBciw+A78SRQs9iMAAVpsYA+l8b1hTePIA=="],
+
+    "protoc-gen-ts": ["protoc-gen-ts@0.8.7", "", { "bin": { "protoc-gen-ts": "protoc-gen-ts.js" } }, "sha512-jr4VJey2J9LVYCV7EVyVe53g1VMw28cCmYJhBe5e3YX5wiyiDwgxWxeDf9oTqAe4P1bN/YGAkW2jhlH8LohwiQ=="],
+
+    "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
+
+    "proxy-agent": ["proxy-agent@6.5.0", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "^4.3.4", "http-proxy-agent": "^7.0.1", "https-proxy-agent": "^7.0.6", "lru-cache": "^7.14.1", "pac-proxy-agent": "^7.1.0", "proxy-from-env": "^1.1.0", "socks-proxy-agent": "^8.0.5" } }, "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A=="],
+
+    "proxy-from-env": ["proxy-from-env@2.1.0", "", {}, "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA=="],
+
+    "pump": ["pump@3.0.4", "", { "dependencies": { "end-of-stream": "^1.1.0", "once": "^1.3.1" } }, "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA=="],
+
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "punycode.js": ["punycode.js@2.3.1", "", {}, "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA=="],
+
+    "puppeteer-chromium-resolver": ["puppeteer-chromium-resolver@23.0.0", "", { "dependencies": { "@puppeteer/browsers": "^2.3.1", "eight-colors": "^1.3.0", "gauge": "^5.0.2", "puppeteer-core": "^23.1.0" } }, "sha512-PbSXK4ERPwp+eYm+SVY5vMWCxsdeJcddwz4avXvDx7kE9DLE+L86Xg027sypw2oan5yi6557brzVsbajcMmy2g=="],
+
+    "puppeteer-core": ["puppeteer-core@23.11.1", "", { "dependencies": { "@puppeteer/browsers": "2.6.1", "chromium-bidi": "0.11.0", "debug": "^4.4.0", "devtools-protocol": "0.0.1367902", "typed-query-selector": "^2.12.0", "ws": "^8.18.0" } }, "sha512-3HZ2/7hdDKZvZQ7dhhITOUg4/wOrDRjyK2ZBllRB0ZCOi9u0cwq1ACHDjBB+nX+7+kltHjQvBRdeY7+W0T+7Gg=="],
+
+    "qs": ["qs@6.15.3", "", { "dependencies": { "es-define-property": "^1.0.1", "side-channel": "^1.1.1" } }, "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A=="],
+
+    "query-selector-shadow-dom": ["query-selector-shadow-dom@1.0.1", "", {}, "sha512-lT5yCqEBgfoMYpf3F2xQRK7zEr1rhIIZuceDK6+xRkJQ4NMbHTwXqk4NkwDwQMNqXgG9r9fyHnzwNVs6zV5KRw=="],
+
+    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+
+    "quick-format-unescaped": ["quick-format-unescaped@4.0.4", "", {}, "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg=="],
+
+    "radix-ui": ["radix-ui@1.6.1", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-accessible-icon": "1.1.11", "@radix-ui/react-accordion": "1.2.15", "@radix-ui/react-alert-dialog": "1.1.18", "@radix-ui/react-arrow": "1.1.11", "@radix-ui/react-aspect-ratio": "1.1.11", "@radix-ui/react-avatar": "1.2.1", "@radix-ui/react-checkbox": "1.3.6", "@radix-ui/react-collapsible": "1.1.15", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-context-menu": "2.3.2", "@radix-ui/react-dialog": "1.1.18", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-dropdown-menu": "2.1.19", "@radix-ui/react-focus-guards": "1.1.4", "@radix-ui/react-focus-scope": "1.1.11", "@radix-ui/react-form": "0.1.11", "@radix-ui/react-hover-card": "1.1.18", "@radix-ui/react-label": "2.1.11", "@radix-ui/react-menu": "2.1.19", "@radix-ui/react-menubar": "1.1.19", "@radix-ui/react-navigation-menu": "1.2.17", "@radix-ui/react-one-time-password-field": "0.1.11", "@radix-ui/react-password-toggle-field": "0.1.6", "@radix-ui/react-popover": "1.1.18", "@radix-ui/react-popper": "1.3.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-progress": "1.1.11", "@radix-ui/react-radio-group": "1.4.2", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-scroll-area": "1.2.13", "@radix-ui/react-select": "2.3.2", "@radix-ui/react-separator": "1.1.11", "@radix-ui/react-slider": "1.4.2", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-switch": "1.3.2", "@radix-ui/react-tabs": "1.1.16", "@radix-ui/react-toast": "1.2.18", "@radix-ui/react-toggle": "1.1.13", "@radix-ui/react-toggle-group": "1.1.14", "@radix-ui/react-toolbar": "1.1.14", "@radix-ui/react-tooltip": "1.2.11", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-effect-event": "0.0.3", "@radix-ui/react-use-escape-keydown": "1.1.3", "@radix-ui/react-use-is-hydrated": "0.1.1", "@radix-ui/react-use-layout-effect": "1.1.2", "@radix-ui/react-use-size": "1.1.2", "@radix-ui/react-visually-hidden": "1.2.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-QXDXJtB6sK83mLASONYUZCauatcWb+knFviFpN1EhtdbbmlsRmzCLrbZSKztnNiem2KOHIBbiDbauVB7SORXMw=="],
+
+    "range-parser": ["range-parser@1.3.0", "", {}, "sha512-hek2mFQpPuI4E1BBKrSto+BU3e3x4xuarsbiwr3+lf7p44juvFMV0XFWQAP3xUyqXA4RrXLIoaSUGbSt056ZMw=="],
+
+    "raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="],
+
+    "rc": ["rc@1.2.8", "", { "dependencies": { "deep-extend": "^0.6.0", "ini": "~1.3.0", "minimist": "^1.2.0", "strip-json-comments": "~2.0.1" }, "bin": { "rc": "./cli.js" } }, "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw=="],
+
+    "rc-config-loader": ["rc-config-loader@4.1.4", "", { "dependencies": { "debug": "^4.4.3", "js-yaml": "^4.1.1", "json5": "^2.2.3", "require-from-string": "^2.0.2" } }, "sha512-3GiwEzklkbXTDp52UR5nT8iXgYAx1V9ZG/kDZT7p60u2GCv2XTwQq4NzinMoMpNtXhmt3WkhYXcj6HH8HdwCEQ=="],
+
+    "react": ["react@19.2.4", "", {}, "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ=="],
+
+    "react-aria": ["react-aria@3.50.0", "", { "dependencies": { "@internationalized/date": "^3.12.2", "@internationalized/number": "^3.6.7", "@internationalized/string": "^3.2.9", "@react-types/shared": "^3.36.0", "@swc/helpers": "^0.5.0", "aria-hidden": "^1.2.3", "clsx": "^2.0.0", "react-stately": "3.48.0", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-S0Os6QZk33fzUAKu1QLT9afoUaCBt1ZNdoiq0n2YMVgKIdNIQS8zxiZ8O9hYE6QyDkHKjD6q39LQZ+qaSAIgjw=="],
+
+    "react-aria-components": ["react-aria-components@1.19.0", "", { "dependencies": { "@internationalized/date": "^3.12.2", "@react-types/shared": "^3.36.0", "@swc/helpers": "^0.5.0", "client-only": "^0.0.1", "react-aria": "3.50.0", "react-stately": "3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-2smSS5nqJ8cGYMQezuUXveZm7eMyHCqTN6mDpylQBYLYbdF5dxCCuW1DHn1VKLe1DybSfPvX/cZtJlDmvFfn8A=="],
+
+    "react-day-picker": ["react-day-picker@9.13.2", "", { "dependencies": { "@date-fns/tz": "^1.4.1", "date-fns": "^4.1.0", "date-fns-jalali": "^4.1.0-0" }, "peerDependencies": { "react": ">=16.8.0" } }, "sha512-IMPiXfXVIAuR5Yk58DDPBC8QKClrhdXV+Tr/alBrwrHUw0qDDYB1m5zPNuTnnPIr/gmJ4ChMxmtqPdxm8+R4Eg=="],
+
+    "react-devtools-core": ["react-devtools-core@7.0.1", "", { "dependencies": { "shell-quote": "^1.6.1", "ws": "^7" } }, "sha512-C3yNvRHaizlpiASzy7b9vbnBGLrhvdhl1CbdU6EnZgxPNbai60szdLtl+VL76UNOt5bOoVTOz5rNWZxgGt+Gsw=="],
+
+    "react-docgen": ["react-docgen@8.0.3", "", { "dependencies": { "@babel/core": "^7.28.0", "@babel/traverse": "^7.28.0", "@babel/types": "^7.28.2", "@types/babel__core": "^7.20.5", "@types/babel__traverse": "^7.20.7", "@types/doctrine": "^0.0.9", "@types/resolve": "^1.20.2", "doctrine": "^3.0.0", "resolve": "^1.22.1", "strip-indent": "^4.0.0" } }, "sha512-aEZ9qP+/M+58x2qgfSFEWH1BxLyHe5+qkLNJOZQb5iGS017jpbRnoKhNRrXPeA6RfBrZO5wZrT9DMC1UqE1f1w=="],
+
+    "react-docgen-typescript": ["react-docgen-typescript@2.4.0", "", { "peerDependencies": { "typescript": ">= 4.3.x" } }, "sha512-ZtAp5XTO5HRzQctjPU0ybY0RRCQO19X/8fxn3w7y2VVTUbGHDKULPTL4ky3vB05euSgG5NpALhEhDPvQ56wvXg=="],
+
+    "react-dom": ["react-dom@19.2.4", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.4" } }, "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ=="],
+
+    "react-hook-form": ["react-hook-form@7.80.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17 || ^18 || ^19" } }, "sha512-4P+fk6oXsxY+6xSj7Euhc2sumQD8zQqCuVHoJwoyp9EchP+IUW9OESB7uHFJOKsIBQ4MQqYE84INJFqUCYNoOg=="],
+
+    "react-is": ["react-is@18.3.1", "", {}, "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg=="],
+
+    "react-is-18": ["react-is@18.3.1", "", {}, "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg=="],
+
+    "react-is-19": ["react-is@19.2.7", "", {}, "sha512-kZFnouyVv7eP/Phmrlo9FK+zcAdriZJvzxXHF1Sl1P377WSGe2G/JxVolhTrB/jeV47lKImhNUsijjHAAbcl/A=="],
+
+    "react-jsx-parser": ["react-jsx-parser@2.4.1", "", { "dependencies": { "acorn": "^8.12.1", "acorn-jsx": "^5.3.2" }, "optionalDependencies": { "@types/react": "^18.3.12", "@types/react-dom": "^18.3.1" }, "peerDependencies": { "react": ">=18", "react-dom": ">=18" } }, "sha512-gE25DiHseuKmSbb5O1K1IkyQ/bwth3zl4z3EdW8XMhwrb2agUpuh8GvqHFvGwh/wdZjDDuadGrSR2lEgjcOvqQ=="],
+
+    "react-markdown": ["react-markdown@10.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "html-url-attributes": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" }, "peerDependencies": { "@types/react": ">=18", "react": ">=18" } }, "sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ=="],
+
+    "react-reconciler": ["react-reconciler@0.32.0", "", { "dependencies": { "scheduler": "^0.26.0" }, "peerDependencies": { "react": "^19.1.0" } }, "sha512-2NPMOzgTlG0ZWdIf3qG+dcbLSoAc/uLfOwckc3ofy5sSK0pLJqnQLpUFxvGcN2rlXSjnVtGeeFLNimCQEj5gOQ=="],
+
+    "react-remark": ["react-remark@2.1.0", "", { "dependencies": { "rehype-react": "^6.0.0", "remark-parse": "^9.0.0", "remark-rehype": "^8.0.0", "unified": "^9.0.0" }, "peerDependencies": { "react": ">=16.8" } }, "sha512-7dEPxRGQ23sOdvteuRGaQAs9cEOH/BOeCN4CqsJdk3laUDIDYRCWnM6a3z92PzXHUuxIRLXQNZx7SiO0ijUcbw=="],
+
+    "react-remove-scroll": ["react-remove-scroll@2.7.2", "", { "dependencies": { "react-remove-scroll-bar": "^2.3.7", "react-style-singleton": "^2.2.3", "tslib": "^2.1.0", "use-callback-ref": "^1.3.3", "use-sidecar": "^1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q=="],
+
+    "react-remove-scroll-bar": ["react-remove-scroll-bar@2.3.8", "", { "dependencies": { "react-style-singleton": "^2.2.2", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" }, "optionalPeers": ["@types/react"] }, "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q=="],
+
+    "react-resizable-panels": ["react-resizable-panels@2.1.9", "", { "peerDependencies": { "react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-z77+X08YDIrgAes4jl8xhnUu1LNIRp4+E7cv4xHmLOxxUPO/ML7PSrE813b90vj7xvQ1lcf7g2uA9GeMZonjhQ=="],
+
+    "react-smooth": ["react-smooth@4.0.4", "", { "dependencies": { "fast-equals": "^5.0.1", "prop-types": "^15.8.1", "react-transition-group": "^4.4.5" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q=="],
+
+    "react-stately": ["react-stately@3.48.0", "", { "dependencies": { "@internationalized/date": "^3.12.2", "@internationalized/number": "^3.6.7", "@internationalized/string": "^3.2.9", "@react-types/shared": "^3.36.0", "@swc/helpers": "^0.5.0", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-ImicSAG+lTotAe5izcs1fz49Zk48w7pDusqYg04WaPhCoej8BJ24soMu3iLXIrsi273s4P1gZrYGrqReMfgEEA=="],
+
+    "react-style-singleton": ["react-style-singleton@2.2.3", "", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="],
+
+    "react-textarea-autosize": ["react-textarea-autosize@8.5.9", "", { "dependencies": { "@babel/runtime": "^7.20.13", "use-composed-ref": "^1.3.0", "use-latest": "^1.2.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-U1DGlIQN5AwgjTyOEnI1oCcMuEr1pv1qOtklB2l4nyMGbHzWrI0eFsYK0zos2YWqAolJyG0IWJaqWmWj5ETh0A=="],
+
+    "react-transition-group": ["react-transition-group@4.4.5", "", { "dependencies": { "@babel/runtime": "^7.5.5", "dom-helpers": "^5.0.1", "loose-envify": "^1.4.0", "prop-types": "^15.6.2" }, "peerDependencies": { "react": ">=16.6.0", "react-dom": ">=16.6.0" } }, "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g=="],
+
+    "react-universal-interface": ["react-universal-interface@0.6.2", "", { "peerDependencies": { "react": "*", "tslib": "*" } }, "sha512-dg8yXdcQmvgR13RIlZbTRQOoUrDciFVoSBZILwjE2LFISxZZ8loVJKAkuzswl5js8BHda79bIb2b84ehU8IjXw=="],
+
+    "react-use": ["react-use@17.6.1", "", { "dependencies": { "@types/js-cookie": "^3.0.0", "@xobotyi/scrollbar-width": "^1.9.5", "copy-to-clipboard": "^3.3.1", "fast-deep-equal": "^3.1.3", "fast-shallow-equal": "^1.0.0", "js-cookie": "^3.0.0", "nano-css": "^5.6.2", "react-universal-interface": "^0.6.2", "resize-observer-polyfill": "^1.5.1", "screenfull": "^5.1.0", "set-harmonic-interval": "^1.0.1", "throttle-debounce": "^3.0.1", "ts-easing": "^0.2.0", "tslib": "^2.1.0" }, "peerDependencies": { "react": "*", "react-dom": "*" } }, "sha512-uibb3pgzV4LFsYPHyXYGu7dD2+pyk/ZJlPH+AizBR3zolqPWyCleKcWWbUQaKSKfydwgnQ3ymGm1Ab3/saGHCA=="],
+
+    "react-virtuoso": ["react-virtuoso@4.18.10", "", { "peerDependencies": { "react": ">=16 || >=17 || >= 18 || >= 19", "react-dom": ">=16 || >=17 || >= 18 || >=19" } }, "sha512-P6GIZ7kWAPOYB2H16yRQNgy+VF9pJOuTFw1EUc1EAtCj5WxVSAF1Sql3x3fbLwaLeBFsiPnu+3U9o6sIOyTdFw=="],
+
+    "read": ["read@1.0.7", "", { "dependencies": { "mute-stream": "~0.0.4" } }, "sha512-rSOKNYUmaxy0om1BNjMN4ezNT6VKK+2xF4GBhc81mkH7L60i6dp8qPYrkndNLT3QPphoII3maL9PVC9XmhHwVQ=="],
+
+    "read-pkg": ["read-pkg@9.0.1", "", { "dependencies": { "@types/normalize-package-data": "^2.4.3", "normalize-package-data": "^6.0.0", "parse-json": "^8.0.0", "type-fest": "^4.6.0", "unicorn-magic": "^0.1.0" } }, "sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA=="],
+
+    "readable-stream": ["readable-stream@4.7.0", "", { "dependencies": { "abort-controller": "^3.0.0", "buffer": "^6.0.3", "events": "^3.3.0", "process": "^0.11.10", "string_decoder": "^1.3.0" } }, "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg=="],
+
+    "readable-web-to-node-stream": ["readable-web-to-node-stream@3.0.4", "", { "dependencies": { "readable-stream": "^4.7.0" } }, "sha512-9nX56alTf5bwXQ3ZDipHJhusu9NTQJ/CVPtb/XHAJCXihZeitfJvIRS4GqQ/mfIoOE3IelHMrpayVrosdHBuLw=="],
+
+    "readdir-glob": ["readdir-glob@1.1.3", "", { "dependencies": { "minimatch": "^5.1.0" } }, "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA=="],
+
+    "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
+
+    "real-require": ["real-require@0.2.0", "", {}, "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg=="],
+
+    "recast": ["recast@0.23.12", "", { "dependencies": { "ast-types": "^0.16.1", "esprima": "~4.0.0", "source-map": "~0.6.1", "tiny-invariant": "^1.3.3", "tslib": "^2.0.1" } }, "sha512-dEWRjcINDu/F4l2dYx57ugBtD7HV9KXESyxhzw/MqWLeglJrsjJKqACPyUPg+6AF8mIgm+Zi0dZ3ACoIg+QtpA=="],
+
+    "recharts": ["recharts@2.15.4", "", { "dependencies": { "clsx": "^2.0.0", "eventemitter3": "^4.0.1", "lodash": "^4.17.21", "react-is": "^18.3.1", "react-smooth": "^4.0.4", "recharts-scale": "^0.4.4", "tiny-invariant": "^1.3.1", "victory-vendor": "^36.6.8" }, "peerDependencies": { "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw=="],
+
+    "recharts-scale": ["recharts-scale@0.4.5", "", { "dependencies": { "decimal.js-light": "^2.4.1" } }, "sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w=="],
+
+    "reconnecting-eventsource": ["reconnecting-eventsource@1.6.5", "", {}, "sha512-L7ADnbp7yA42vvjwx7cZFNmiyHNBu/UldL1NCEvB23xBkZhESF83s2cnD9sLfvcX9wMIzW1UpIS7EOq/iu3E2g=="],
+
+    "redent": ["redent@3.0.0", "", { "dependencies": { "indent-string": "^4.0.0", "strip-indent": "^3.0.0" } }, "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg=="],
+
+    "regex": ["regex@6.1.0", "", { "dependencies": { "regex-utilities": "^2.3.0" } }, "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg=="],
+
+    "regex-recursion": ["regex-recursion@6.0.2", "", { "dependencies": { "regex-utilities": "^2.3.0" } }, "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg=="],
+
+    "regex-utilities": ["regex-utilities@2.3.0", "", {}, "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng=="],
+
+    "rehype-harden": ["rehype-harden@1.1.8", "", { "dependencies": { "unist-util-visit": "^5.0.0" } }, "sha512-Qn7vR1xrf6fZCrkm9TDWi/AB4ylrHy+jqsNm1EHOAmbARYA6gsnVJBq/sdBh6kmT4NEZxH5vgIjrscefJAOXcw=="],
+
+    "rehype-highlight": ["rehype-highlight@7.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-to-text": "^4.0.0", "lowlight": "^3.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-k158pK7wdC2qL3M5NcZROZ2tR/l7zOzjxXd5VGdcfIyoijjQqpHd3JKtYSBDpDZ38UI2WJWuFAtkMDxmx5kstA=="],
+
+    "rehype-katex": ["rehype-katex@7.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/katex": "^0.16.0", "hast-util-from-html-isomorphic": "^2.0.0", "hast-util-to-text": "^4.0.0", "katex": "^0.16.0", "unist-util-visit-parents": "^6.0.0", "vfile": "^6.0.0" } }, "sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA=="],
+
+    "rehype-minify-whitespace": ["rehype-minify-whitespace@6.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-minify-whitespace": "^1.0.0" } }, "sha512-Zk0pyQ06A3Lyxhe9vGtOtzz3Z0+qZ5+7icZ/PL/2x1SHPbKao5oB/g/rlc6BCTajqBb33JcOe71Ye1oFsuYbnw=="],
+
+    "rehype-parse": ["rehype-parse@9.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-from-html": "^2.0.0", "unified": "^11.0.0" } }, "sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag=="],
+
+    "rehype-raw": ["rehype-raw@7.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-raw": "^9.0.0", "vfile": "^6.0.0" } }, "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww=="],
+
+    "rehype-react": ["rehype-react@6.2.1", "", { "dependencies": { "@mapbox/hast-util-table-cell-style": "^0.2.0", "hast-to-hyperscript": "^9.0.0" } }, "sha512-f9KIrjktvLvmbGc7si25HepocOg4z0MuNOtweigKzBcDjiGSTGhyz6VSgaV5K421Cq1O+z4/oxRJ5G9owo0KVg=="],
+
+    "rehype-remark": ["rehype-remark@10.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "hast-util-to-mdast": "^10.0.0", "unified": "^11.0.0", "vfile": "^6.0.0" } }, "sha512-EmDndlb5NVwXGfUa4c9GPK+lXeItTilLhE6ADSaQuHr4JUlKw9MidzGzx4HpqZrNCt6vnHmEifXQiiA+CEnjYQ=="],
+
+    "rehype-sanitize": ["rehype-sanitize@6.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-sanitize": "^5.0.0" } }, "sha512-CsnhKNsyI8Tub6L4sm5ZFsme4puGfc6pYylvXo1AeqaGbjOYyzNv3qZPwvs0oMJ39eryyeOdmxwUIo94IpEhqg=="],
+
+    "remark-cjk-friendly": ["remark-cjk-friendly@2.3.1", "", { "dependencies": { "mdast-util-to-markdown-cjk-friendly": "1.0.0", "micromark-extension-cjk-friendly": "2.0.1" }, "peerDependencies": { "@types/mdast": "^4.0.0", "unified": "^11.0.0" }, "optionalPeers": ["@types/mdast"] }, "sha512-f+pKZRxCRwNEGFBKNRAZAqU91GIK1SAo3ZyFHWRUgC9zcxRR0BXKd6YwqgSsxtW0rNpUDtONj7H5nje2WL3fcA=="],
+
+    "remark-cjk-friendly-gfm-strikethrough": ["remark-cjk-friendly-gfm-strikethrough@2.3.1", "", { "dependencies": { "mdast-util-to-markdown-cjk-friendly-gfm-strikethrough": "1.0.0", "micromark-extension-cjk-friendly-gfm-strikethrough": "2.0.1" }, "peerDependencies": { "@types/mdast": "^4.0.0", "unified": "^11.0.0" }, "optionalPeers": ["@types/mdast"] }, "sha512-JE3TGgouk/sy92SemNMEUhO5mNP4on04cmzOV3s3R5Dbk160ewmpM4tgPiinKKvoJ5UW2fTu7FOYsjVbusSA9w=="],
+
+    "remark-gfm": ["remark-gfm@4.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-gfm": "^3.0.0", "micromark-extension-gfm": "^3.0.0", "remark-parse": "^11.0.0", "remark-stringify": "^11.0.0", "unified": "^11.0.0" } }, "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg=="],
+
+    "remark-math": ["remark-math@6.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-math": "^3.0.0", "micromark-extension-math": "^3.0.0", "unified": "^11.0.0" } }, "sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA=="],
+
+    "remark-parse": ["remark-parse@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "micromark-util-types": "^2.0.0", "unified": "^11.0.0" } }, "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA=="],
+
+    "remark-rehype": ["remark-rehype@11.1.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "mdast-util-to-hast": "^13.0.0", "unified": "^11.0.0", "vfile": "^6.0.0" } }, "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw=="],
+
+    "remark-stringify": ["remark-stringify@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-to-markdown": "^2.0.0", "unified": "^11.0.0" } }, "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw=="],
+
+    "remend": ["remend@1.3.0", "", {}, "sha512-iIhggPkhW3hFImKtB10w0dz4EZbs28mV/dmbcYVonWEJ6UGHHpP+bFZnTh6GNWJONg5m+U56JrL+8IxZRdgWjw=="],
+
+    "require-directory": ["require-directory@2.1.1", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
+
+    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
+
+    "require-in-the-middle": ["require-in-the-middle@7.5.2", "", { "dependencies": { "debug": "^4.3.5", "module-details-from-path": "^1.0.3", "resolve": "^1.22.8" } }, "sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ=="],
+
+    "reselect": ["reselect@5.2.0", "", {}, "sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw=="],
+
+    "resize-observer-polyfill": ["resize-observer-polyfill@1.5.1", "", {}, "sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg=="],
+
+    "resolve": ["resolve@1.22.12", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA=="],
+
+    "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
+
+    "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="],
+
+    "retry": ["retry@0.12.0", "", {}, "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow=="],
+
+    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+
+    "rfdc": ["rfdc@1.4.1", "", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="],
+
+    "rimraf": ["rimraf@6.1.3", "", { "dependencies": { "glob": "^13.0.3", "package-json-from-dist": "^1.0.1" }, "bin": { "rimraf": "dist/esm/bin.mjs" } }, "sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA=="],
+
+    "robust-predicates": ["robust-predicates@3.0.3", "", {}, "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA=="],
+
+    "rolldown": ["rolldown@1.1.4", "", { "dependencies": { "@oxc-project/types": "=0.138.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm64": "1.1.4", "@rolldown/binding-darwin-arm64": "1.1.4", "@rolldown/binding-darwin-x64": "1.1.4", "@rolldown/binding-freebsd-x64": "1.1.4", "@rolldown/binding-linux-arm-gnueabihf": "1.1.4", "@rolldown/binding-linux-arm64-gnu": "1.1.4", "@rolldown/binding-linux-arm64-musl": "1.1.4", "@rolldown/binding-linux-ppc64-gnu": "1.1.4", "@rolldown/binding-linux-s390x-gnu": "1.1.4", "@rolldown/binding-linux-x64-gnu": "1.1.4", "@rolldown/binding-linux-x64-musl": "1.1.4", "@rolldown/binding-openharmony-arm64": "1.1.4", "@rolldown/binding-wasm32-wasi": "1.1.4", "@rolldown/binding-win32-arm64-msvc": "1.1.4", "@rolldown/binding-win32-x64-msvc": "1.1.4" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-IjZYiLxZwpnhwhdBH2ugdTGVSdhCQUmLxLoqyjiL0JxYjyRst+5a0P3xfrTxJ5F638j4Mvvw5FAX5XE6eHpXbA=="],
+
+    "rollup": ["rollup@4.62.2", "", { "dependencies": { "@types/estree": "1.0.9" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.62.2", "@rollup/rollup-android-arm64": "4.62.2", "@rollup/rollup-darwin-arm64": "4.62.2", "@rollup/rollup-darwin-x64": "4.62.2", "@rollup/rollup-freebsd-arm64": "4.62.2", "@rollup/rollup-freebsd-x64": "4.62.2", "@rollup/rollup-linux-arm-gnueabihf": "4.62.2", "@rollup/rollup-linux-arm-musleabihf": "4.62.2", "@rollup/rollup-linux-arm64-gnu": "4.62.2", "@rollup/rollup-linux-arm64-musl": "4.62.2", "@rollup/rollup-linux-loong64-gnu": "4.62.2", "@rollup/rollup-linux-loong64-musl": "4.62.2", "@rollup/rollup-linux-ppc64-gnu": "4.62.2", "@rollup/rollup-linux-ppc64-musl": "4.62.2", "@rollup/rollup-linux-riscv64-gnu": "4.62.2", "@rollup/rollup-linux-riscv64-musl": "4.62.2", "@rollup/rollup-linux-s390x-gnu": "4.62.2", "@rollup/rollup-linux-x64-gnu": "4.62.2", "@rollup/rollup-linux-x64-musl": "4.62.2", "@rollup/rollup-openbsd-x64": "4.62.2", "@rollup/rollup-openharmony-arm64": "4.62.2", "@rollup/rollup-win32-arm64-msvc": "4.62.2", "@rollup/rollup-win32-ia32-msvc": "4.62.2", "@rollup/rollup-win32-x64-gnu": "4.62.2", "@rollup/rollup-win32-x64-msvc": "4.62.2", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA=="],
+
+    "roughjs": ["roughjs@4.6.6", "", { "dependencies": { "hachure-fill": "^0.5.2", "path-data-parser": "^0.1.0", "points-on-curve": "^0.2.0", "points-on-path": "^0.2.1" } }, "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ=="],
+
+    "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],
+
+    "rrweb-cssom": ["rrweb-cssom@0.8.0", "", {}, "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw=="],
+
+    "rtl-css-js": ["rtl-css-js@1.16.1", "", { "dependencies": { "@babel/runtime": "^7.1.2" } }, "sha512-lRQgou1mu19e+Ya0LsTvKrVJ5TYUbqCVPAiImX3UfLTenarvPUl1QFdvu5Z3PYmHT9RCcwIfbjRQBntExyj3Zg=="],
+
+    "run-applescript": ["run-applescript@7.1.0", "", {}, "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q=="],
+
+    "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
+
+    "rw": ["rw@1.3.3", "", {}, "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ=="],
+
+    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+
+    "safe-stable-stringify": ["safe-stable-stringify@2.5.0", "", {}, "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA=="],
+
+    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
+
+    "sax": ["sax@1.6.0", "", {}, "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA=="],
+
+    "saxes": ["saxes@5.0.1", "", { "dependencies": { "xmlchars": "^2.2.0" } }, "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw=="],
+
+    "scheduler": ["scheduler@0.26.0", "", {}, "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA=="],
+
+    "screenfull": ["screenfull@5.2.0", "", {}, "sha512-9BakfsO2aUQN2K9Fdbj87RJIEZ82Q9IGim7FqM5OsebfoFC6ZHXgDq/KvniuLTPdeM8wY2o6Dj3WQ7KeQCj3cA=="],
+
+    "scroll-into-view-if-needed": ["scroll-into-view-if-needed@3.0.10", "", { "dependencies": { "compute-scroll-into-view": "^3.0.2" } }, "sha512-t44QCeDKAPf1mtQH3fYpWz8IM/DyvHLjs8wUvvwMYxk5moOqCzrMSxK6HQVD0QVmVjXFavoFIPRVrMuJPKAvtg=="],
+
+    "secretlint": ["secretlint@10.2.2", "", { "dependencies": { "@secretlint/config-creator": "^10.2.2", "@secretlint/formatter": "^10.2.2", "@secretlint/node": "^10.2.2", "@secretlint/profiler": "^10.2.2", "debug": "^4.4.1", "globby": "^14.1.0", "read-pkg": "^9.0.1" }, "bin": "./bin/secretlint.js" }, "sha512-xVpkeHV/aoWe4vP4TansF622nBEImzCY73y/0042DuJ29iKIaqgoJ8fGxre3rVSHHbxar4FdJobmTnLp9AU0eg=="],
+
+    "semver": ["semver@7.8.5", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="],
+
+    "send": ["send@1.2.1", "", { "dependencies": { "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", "http-errors": "^2.0.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="],
+
+    "serialize-error": ["serialize-error@11.0.3", "", { "dependencies": { "type-fest": "^2.12.2" } }, "sha512-2G2y++21dhj2R7iHAdd0FIzjGwuKZld+7Pl/bTU6YIkrC2ZMbVUjm+luj6A6V34Rv9XfKJDKpTWu9W4Gse1D9g=="],
+
+    "serialize-javascript": ["serialize-javascript@7.0.7", "", {}, "sha512-YAy8Od6KV+uuwUuU50np8fGB/Aues6Y0nAhA9y/hId74PlKUcme4pXcBD46NWKr1Q4osN/iseZ17YqO1XfmI8g=="],
+
+    "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="],
+
+    "set-harmonic-interval": ["set-harmonic-interval@1.0.1", "", {}, "sha512-AhICkFV84tBP1aWqPwLZqFvAwqEoVA9kxNMniGEUvzOlm4vLmOFLiTT3UZ6bziJTy4bOVpzWGTfSCbmaayGx8g=="],
+
+    "setimmediate": ["setimmediate@1.0.5", "", {}, "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA=="],
+
+    "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="],
+
+    "shadcn": ["shadcn@4.12.0", "", { "dependencies": { "@babel/core": "^7.28.0", "@babel/parser": "^7.28.0", "@babel/plugin-transform-typescript": "^7.28.0", "@babel/preset-typescript": "^7.27.1", "@dotenvx/dotenvx": "^1.48.4", "@modelcontextprotocol/sdk": "^1.26.0", "@types/validate-npm-package-name": "^4.0.2", "browserslist": "^4.26.2", "commander": "^14.0.0", "cosmiconfig": "^9.0.0", "dedent": "^1.6.0", "deepmerge": "^4.3.1", "diff": "^8.0.2", "execa": "^9.6.0", "fast-glob": "^3.3.3", "fs-extra": "^11.3.1", "fuzzysort": "^3.1.0", "kleur": "^4.1.5", "open": "^11.0.0", "ora": "^8.2.0", "postcss": "^8.5.6", "postcss-selector-parser": "^7.1.0", "prompts": "^2.4.2", "recast": "^0.23.11", "stringify-object": "^5.0.0", "tailwind-merge": "^3.0.1", "ts-morph": "^26.0.0", "tsconfig-paths": "^4.2.0", "undici": "^7.27.2", "validate-npm-package-name": "^7.0.1", "zod": "^3.24.1", "zod-to-json-schema": "^3.24.6" }, "bin": { "shadcn": "dist/index.js" } }, "sha512-o781ieQziCnXH2FKsEqxp1fnbHdbgAPO9inTSPeZ59hQfsZXuMGp3ul8oFSV5KQS4nbUK9b+DrDE6C7OvfKKQQ=="],
+
+    "shallow-clone": ["shallow-clone@3.0.1", "", { "dependencies": { "kind-of": "^6.0.2" } }, "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA=="],
+
+    "sharp": ["sharp@0.34.5", "", { "dependencies": { "@img/colour": "^1.0.0", "detect-libc": "^2.1.2", "semver": "^7.7.3" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.34.5", "@img/sharp-darwin-x64": "0.34.5", "@img/sharp-libvips-darwin-arm64": "1.2.4", "@img/sharp-libvips-darwin-x64": "1.2.4", "@img/sharp-libvips-linux-arm": "1.2.4", "@img/sharp-libvips-linux-arm64": "1.2.4", "@img/sharp-libvips-linux-ppc64": "1.2.4", "@img/sharp-libvips-linux-riscv64": "1.2.4", "@img/sharp-libvips-linux-s390x": "1.2.4", "@img/sharp-libvips-linux-x64": "1.2.4", "@img/sharp-libvips-linuxmusl-arm64": "1.2.4", "@img/sharp-libvips-linuxmusl-x64": "1.2.4", "@img/sharp-linux-arm": "0.34.5", "@img/sharp-linux-arm64": "0.34.5", "@img/sharp-linux-ppc64": "0.34.5", "@img/sharp-linux-riscv64": "0.34.5", "@img/sharp-linux-s390x": "0.34.5", "@img/sharp-linux-x64": "0.34.5", "@img/sharp-linuxmusl-arm64": "0.34.5", "@img/sharp-linuxmusl-x64": "0.34.5", "@img/sharp-wasm32": "0.34.5", "@img/sharp-win32-arm64": "0.34.5", "@img/sharp-win32-ia32": "0.34.5", "@img/sharp-win32-x64": "0.34.5" } }, "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg=="],
+
+    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
+
+    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
+
+    "shell-quote": ["shell-quote@1.9.0", "", {}, "sha512-Iov+JwFv/2HcTpcwNMKd8+IWNb8tboQJNQTkAY/LLVK7gGH9jy+LGkVqPxfekHl+yMmiqXszdGWXgkfml7hjqA=="],
+
+    "shiki": ["shiki@4.3.0", "", { "dependencies": { "@shikijs/core": "4.3.0", "@shikijs/engine-javascript": "4.3.0", "@shikijs/engine-oniguruma": "4.3.0", "@shikijs/langs": "4.3.0", "@shikijs/themes": "4.3.0", "@shikijs/types": "4.3.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-NKKjWzR6LIGL3sXBrWDw9sDS9cxx42/DkysaNqJEeOWE8Kix5gpak0bc00OfDVEO4oyXSyz8+aRaqKoBD1yo7A=="],
+
+    "shimmer": ["shimmer@1.2.1", "", {}, "sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw=="],
+
+    "should": ["should@13.2.3", "", { "dependencies": { "should-equal": "^2.0.0", "should-format": "^3.0.3", "should-type": "^1.4.0", "should-type-adaptors": "^1.0.1", "should-util": "^1.0.0" } }, "sha512-ggLesLtu2xp+ZxI+ysJTmNjh2U0TsC+rQ/pfED9bUZZ4DKefP27D+7YJVVTvKsmjLpIi9jAa7itwDGkDDmt1GQ=="],
+
+    "should-equal": ["should-equal@2.0.0", "", { "dependencies": { "should-type": "^1.4.0" } }, "sha512-ZP36TMrK9euEuWQYBig9W55WPC7uo37qzAEmbjHz4gfyuXrEUgF8cUvQVO+w+d3OMfPvSRQJ22lSm8MQJ43LTA=="],
+
+    "should-format": ["should-format@3.0.3", "", { "dependencies": { "should-type": "^1.3.0", "should-type-adaptors": "^1.0.1" } }, "sha512-hZ58adtulAk0gKtua7QxevgUaXTTXxIi8t41L3zo9AHvjXO1/7sdLECuHeIN2SRtYXpNkmhoUP2pdeWgricQ+Q=="],
+
+    "should-type": ["should-type@1.4.0", "", {}, "sha512-MdAsTu3n25yDbIe1NeN69G4n6mUnJGtSJHygX3+oN0ZbO3DTiATnf7XnYJdGT42JCXurTb1JI0qOBR65shvhPQ=="],
+
+    "should-type-adaptors": ["should-type-adaptors@1.1.0", "", { "dependencies": { "should-type": "^1.3.0", "should-util": "^1.0.0" } }, "sha512-JA4hdoLnN+kebEp2Vs8eBe9g7uy0zbRo+RMcU0EsNy+R+k049Ki+N5tT5Jagst2g7EAja+euFuoXFCa8vIklfA=="],
+
+    "should-util": ["should-util@1.0.1", "", {}, "sha512-oXF8tfxx5cDk8r2kYqlkUJzZpDBqVY/II2WhvU0n9Y3XYvAYRmeaf1PvvIvTgPnv4KJ+ES5M0PyDq5Jp+Ygy2g=="],
+
+    "side-channel": ["side-channel@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4", "side-channel-list": "^1.0.1", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ=="],
+
+    "side-channel-list": ["side-channel-list@1.0.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4" } }, "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w=="],
+
+    "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="],
+
+    "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],
+
+    "siginfo": ["siginfo@2.0.0", "", {}, "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g=="],
+
+    "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
+
+    "simple-concat": ["simple-concat@1.0.1", "", {}, "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q=="],
+
+    "simple-get": ["simple-get@4.0.1", "", { "dependencies": { "decompress-response": "^6.0.0", "once": "^1.3.1", "simple-concat": "^1.0.0" } }, "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA=="],
+
+    "simple-git": ["simple-git@3.36.0", "", { "dependencies": { "@kwsites/file-exists": "^1.1.1", "@kwsites/promise-deferred": "^1.1.1", "@simple-git/args-pathspec": "^1.0.3", "@simple-git/argv-parser": "^1.1.0", "debug": "^4.4.0" } }, "sha512-cGQjLjK8bxJw4QuYT7gxHw3/IouVESbhahSsHrX97MzCL1gu2u7oy38W6L2ZIGECEfIBG4BabsWDPjBxJENv9Q=="],
+
+    "simple-swizzle": ["simple-swizzle@0.2.4", "", { "dependencies": { "is-arrayish": "^0.3.1" } }, "sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw=="],
+
+    "simple-xml-to-json": ["simple-xml-to-json@1.2.7", "", {}, "sha512-mz9VXphOxQWX3eQ/uXCtm6upltoN0DLx8Zb5T4TFC4FHB7S9FDPGre8CfLWqPWQQH/GrQYd2AXhhVM5LDpYx6Q=="],
+
+    "sinon": ["sinon@21.1.2", "", { "dependencies": { "@sinonjs/commons": "^3.0.1", "@sinonjs/fake-timers": "^15.3.2", "@sinonjs/samsam": "^10.0.2", "diff": "^8.0.4" } }, "sha512-FS6mN+/bx7e2ajpXkEmOcWB6xBzWiuNoAQT18/+a20SS4U7FSYl8Ms7N6VTUxN/1JAjkx7aXp+THMC8xdpp0gA=="],
+
+    "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
+
+    "slash": ["slash@5.1.0", "", {}, "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg=="],
+
+    "slice-ansi": ["slice-ansi@8.0.0", "", { "dependencies": { "ansi-styles": "^6.2.3", "is-fullwidth-code-point": "^5.1.0" } }, "sha512-stxByr12oeeOyY2BlviTNQlYV5xOj47GirPr4yA1hE9JCtxfQN0+tVbkxwCtYDQWhEKWFHsEK48ORg5jrouCAg=="],
+
+    "smart-buffer": ["smart-buffer@4.2.0", "", {}, "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg=="],
+
+    "socks": ["socks@2.8.9", "", { "dependencies": { "ip-address": "^10.1.1", "smart-buffer": "^4.2.0" } }, "sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw=="],
+
+    "socks-proxy-agent": ["socks-proxy-agent@8.0.5", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "^4.3.4", "socks": "^2.8.3" } }, "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw=="],
+
+    "sonic-boom": ["sonic-boom@4.2.1", "", { "dependencies": { "atomic-sleep": "^1.0.0" } }, "sha512-w6AxtubXa2wTXAUsZMMWERrsIRAdrK0Sc+FUytWvYAhBJLyuI4llrMIC1DtlNSdI99EI86KZum2MMq3EAZlF9Q=="],
+
+    "sonner": ["sonner@2.0.7", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w=="],
+
+    "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "space-separated-tokens": ["space-separated-tokens@2.0.2", "", {}, "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="],
+
+    "spdx-correct": ["spdx-correct@3.2.0", "", { "dependencies": { "spdx-expression-parse": "^3.0.0", "spdx-license-ids": "^3.0.0" } }, "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA=="],
+
+    "spdx-exceptions": ["spdx-exceptions@2.5.0", "", {}, "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w=="],
+
+    "spdx-expression-parse": ["spdx-expression-parse@3.0.1", "", { "dependencies": { "spdx-exceptions": "^2.1.0", "spdx-license-ids": "^3.0.0" } }, "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q=="],
+
+    "spdx-license-ids": ["spdx-license-ids@3.0.23", "", {}, "sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw=="],
+
+    "split2": ["split2@4.2.0", "", {}, "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="],
+
+    "sprintf-js": ["sprintf-js@1.0.3", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="],
+
+    "stack-generator": ["stack-generator@2.0.10", "", { "dependencies": { "stackframe": "^1.3.4" } }, "sha512-mwnua/hkqM6pF4k8SnmZ2zfETsRUpWXREfA/goT8SLCV4iOFa4bzOX2nDipWAZFPTjLvQB82f5yaodMVhK0yJQ=="],
+
+    "stack-trace": ["stack-trace@0.0.10", "", {}, "sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg=="],
+
+    "stack-utils": ["stack-utils@2.0.6", "", { "dependencies": { "escape-string-regexp": "^2.0.0" } }, "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ=="],
+
+    "stackback": ["stackback@0.0.2", "", {}, "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw=="],
+
+    "stackframe": ["stackframe@1.3.4", "", {}, "sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw=="],
+
+    "stacktrace-gps": ["stacktrace-gps@3.1.2", "", { "dependencies": { "source-map": "0.5.6", "stackframe": "^1.3.4" } }, "sha512-GcUgbO4Jsqqg6RxfyTHFiPxdPqF+3LFmQhm7MgCuYQOYuWyqxo5pwRPz5d/u6/WYJdEnWfK4r+jGbyD8TSggXQ=="],
+
+    "stacktrace-js": ["stacktrace-js@2.0.2", "", { "dependencies": { "error-stack-parser": "^2.0.6", "stack-generator": "^2.0.5", "stacktrace-gps": "^3.0.4" } }, "sha512-Je5vBeY4S1r/RnLydLl0TBTi3F2qdfWmYsGvtfZgEI+SCprPppaIhQf5nGcal4gI4cGpCV/duLcAzT1np6sQqg=="],
+
+    "stage-js": ["stage-js@1.0.2", "", {}, "sha512-EWTRBYlg7Qv9wGUao99/PfRe3KaiQqWmgSvTOXvaWnu1Jk/q/vV8yJVu6bi/3EqDZeMVnCPAjheba6OFc5k1GQ=="],
+
+    "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
+
+    "std-env": ["std-env@4.1.0", "", {}, "sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ=="],
+
+    "stdin-discarder": ["stdin-discarder@0.2.2", "", {}, "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ=="],
+
+    "storybook": ["storybook@9.1.20", "", { "dependencies": { "@storybook/global": "^5.0.0", "@testing-library/jest-dom": "^6.6.3", "@testing-library/user-event": "^14.6.1", "@vitest/expect": "3.2.4", "@vitest/mocker": "3.2.4", "@vitest/spy": "3.2.4", "better-opn": "^3.0.2", "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0", "esbuild-register": "^3.5.0", "recast": "^0.23.5", "semver": "^7.6.2", "ws": "^8.18.0" }, "peerDependencies": { "prettier": "^2 || ^3" }, "optionalPeers": ["prettier"], "bin": "./bin/index.cjs" }, "sha512-6rME2tww6PFhm96iG2Xx44yzwLDWBiDWy+kJ2ub6x90werSTOiuo+tZJ94BgCfFutR0tEfLRIq59s+Zg6YyChA=="],
+
+    "streamdown": ["streamdown@2.5.0", "", { "dependencies": { "clsx": "^2.1.1", "hast-util-to-jsx-runtime": "^2.3.6", "html-url-attributes": "^3.0.1", "marked": "^17.0.1", "mermaid": "^11.12.2", "rehype-harden": "^1.1.8", "rehype-raw": "^7.0.0", "rehype-sanitize": "^6.0.0", "remark-gfm": "^4.0.1", "remark-parse": "^11.0.0", "remark-rehype": "^11.1.2", "remend": "1.3.0", "tailwind-merge": "^3.4.0", "unified": "^11.0.5", "unist-util-visit": "^5.0.0", "unist-util-visit-parents": "^6.0.0" }, "peerDependencies": { "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" } }, "sha512-/tTnURfIOxZK/pqJAxsfCvETG/XCJHoWnk3jq9xLcuz6CSpnjjuxSRBTTL4PKGhxiZQf0lqPxGhImdpwcZ2XwA=="],
+
+    "streamx": ["streamx@2.28.0", "", { "dependencies": { "events-universal": "^1.0.0", "fast-fifo": "^1.3.2", "text-decoder": "^1.1.0" } }, "sha512-1Yowhzjf0ivGMrTIkY9hav5TxobO9qIVqUE41fiCGMGgc3CLlf4MY+9AHmZqBWgDTue0fY9zWjYFVyf6Diuobw=="],
+
+    "string-argv": ["string-argv@0.3.2", "", {}, "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q=="],
+
+    "string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="],
+
+    "string-width-cjs": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
+
+    "stringify-entities": ["stringify-entities@4.0.4", "", { "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" } }, "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg=="],
+
+    "stringify-object": ["stringify-object@5.0.0", "", { "dependencies": { "get-own-enumerable-keys": "^1.0.0", "is-obj": "^3.0.0", "is-regexp": "^3.1.0" } }, "sha512-zaJYxz2FtcMb4f+g60KsRNFOpVMUyuJgA51Zi5Z1DOTC3S59+OQiVOzE9GZt0x72uBGWKsQIuBKeF9iusmKFsg=="],
+
+    "strip-ansi": ["strip-ansi@7.2.0", "", { "dependencies": { "ansi-regex": "^6.2.2" } }, "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w=="],
+
+    "strip-ansi-cjs": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="],
+
+    "strip-final-newline": ["strip-final-newline@4.0.0", "", {}, "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw=="],
+
+    "strip-indent": ["strip-indent@4.1.1", "", {}, "sha512-SlyRoSkdh1dYP0PzclLE7r0M9sgbFKKMFXpFRUMNuKhQSbC6VQIGzq3E0qsfvGJaUFJPGv6Ws1NZ/haTAjfbMA=="],
+
+    "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
+
+    "strip-literal": ["strip-literal@3.1.0", "", { "dependencies": { "js-tokens": "^9.0.1" } }, "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg=="],
+
+    "strtok3": ["strtok3@6.3.0", "", { "dependencies": { "@tokenizer/token": "^0.3.0", "peek-readable": "^4.1.0" } }, "sha512-fZtbhtvI9I48xDSywd/somNqgUHl2L2cstmXCCif0itOf96jeW18MBSyrLuNicYQVkvpOxkZtkzujiTJ9LW5Jw=="],
+
+    "structured-source": ["structured-source@4.0.0", "", { "dependencies": { "boundary": "^2.0.0" } }, "sha512-qGzRFNJDjFieQkl/sVOI2dUjHKRyL9dAJi2gCPGJLbJHBIkyOHxjuocpIEfbLioX+qSJpvbYdT49/YCdMznKxA=="],
+
+    "style-to-js": ["style-to-js@1.1.21", "", { "dependencies": { "style-to-object": "1.0.14" } }, "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ=="],
+
+    "style-to-object": ["style-to-object@1.0.14", "", { "dependencies": { "inline-style-parser": "0.2.7" } }, "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw=="],
+
+    "styled-components": ["styled-components@6.4.3", "", { "dependencies": { "@emotion/is-prop-valid": "1.4.0", "css-to-react-native": "3.2.0", "csstype": "3.2.3", "stylis": "4.3.6" }, "peerDependencies": { "react": ">= 16.8.0", "react-dom": ">= 16.8.0", "react-native": ">= 0.68.0" }, "optionalPeers": ["react-dom", "react-native"] }, "sha512-wYXrhu+JmDjZ1Tv7O0OopGTfztbzun43Pjjhh2H+xc0h5A09dwpZ5FJbrifJDcL8g5TA9btpWOX2+iSRuJTExw=="],
+
+    "styled-jsx": ["styled-jsx@5.1.6", "", { "dependencies": { "client-only": "0.0.1" }, "peerDependencies": { "react": ">= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0" } }, "sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA=="],
+
+    "stylis": ["stylis@4.4.0", "", {}, "sha512-5Z9ZpRzfuH6l/UAvCPAPUo3665Nk2wLaZU3x+TLHKVzIz33+sbJqbtrYoC3KD4/uVOr2Zp+L0LySezP9OHV9yA=="],
+
+    "supports-color": ["supports-color@10.2.2", "", {}, "sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g=="],
+
+    "supports-hyperlinks": ["supports-hyperlinks@3.2.0", "", { "dependencies": { "has-flag": "^4.0.0", "supports-color": "^7.0.0" } }, "sha512-zFObLMyZeEwzAoKCyu1B91U79K2t7ApXuQfo8OuxwXLDgcKxuwM+YvcbIhm6QWqz7mHUH1TVytR1PwVVjEuMig=="],
+
+    "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="],
+
+    "swr": ["swr@2.4.2", "", { "dependencies": { "dequal": "^2.0.3", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-ej644Y2bvkIajfR32KGeSSdBXQW+ScjGjkybZgSE7kFpk9eGnV44XY9FJylXi+W75pavSX1PVNB57W5EbhGIYw=="],
+
+    "symbol-tree": ["symbol-tree@3.2.4", "", {}, "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw=="],
+
+    "systeminformation": ["systeminformation@5.31.11", "", { "os": "!aix", "bin": { "systeminformation": "lib/cli.js" } }, "sha512-I6O7iaUj23AXRgCPDDnvi3xHvdOLp4+1YMbF+X194lJwY1NeWojgHJPhslVKcmTtrLTguRk3QJK+xEdTiI3P0w=="],
+
+    "tabbable": ["tabbable@6.5.0", "", {}, "sha512-wieBHXygIm7OyQOu5hQlkk62/WyCFYGlWg7L6/ZCUZwx0o398Zkn4pVmMyfYhfMG8kGrj/Krt8eIk6UKC6VzwA=="],
+
+    "table": ["table@6.9.0", "", { "dependencies": { "ajv": "^8.0.1", "lodash.truncate": "^4.4.2", "slice-ansi": "^4.0.0", "string-width": "^4.2.3", "strip-ansi": "^6.0.1" } }, "sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A=="],
+
+    "tailwind-merge": ["tailwind-merge@3.6.0", "", {}, "sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w=="],
+
+    "tailwind-variants": ["tailwind-variants@3.2.2", "", { "peerDependencies": { "tailwind-merge": ">=3.0.0", "tailwindcss": "*" }, "optionalPeers": ["tailwind-merge"] }, "sha512-Mi4kHeMTLvKlM98XPnK+7HoBPmf4gygdFmqQPaDivc3DpYS6aIY6KiG/PgThrGvii5YZJqRsPz0aPyhoFzmZgg=="],
+
+    "tailwindcss": ["tailwindcss@4.3.2", "", {}, "sha512-WtctNNSH8A9jlMIqxzuYumOHU5uGZyRv0Q5svQl+oEPy5w84YpBxdb7MdqyiSPQge5jTJ6zFQLq0PFygdccSBA=="],
+
+    "tailwindcss-animate": ["tailwindcss-animate@1.0.7", "", { "peerDependencies": { "tailwindcss": ">=3.0.0 || insiders" } }, "sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA=="],
+
+    "tapable": ["tapable@2.3.3", "", {}, "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A=="],
+
+    "tar": ["tar@7.5.19", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" } }, "sha512-4LeEWl96twnS2Q7Bz4MGqgazLqO+hJN63GZxXoIqh1T3VweYD997gbU1ItNsQafqqXTXd5WFyFdReLtwvRBNiw=="],
+
+    "tar-fs": ["tar-fs@3.1.3", "", { "dependencies": { "pump": "^3.0.0", "tar-stream": "^3.1.5" }, "optionalDependencies": { "bare-fs": "^4.0.1", "bare-path": "^3.0.0" } }, "sha512-/hU4AXnIdZu+Gvl1pk0oI5f5HxWsCJRtY2aFaJdk9VvyL48DWU6iU5WAIPG+wIi1YvWA6eTJvIviP/tMAZZNwQ=="],
+
+    "tar-stream": ["tar-stream@3.2.0", "", { "dependencies": { "b4a": "^1.6.4", "bare-fs": "^4.5.5", "fast-fifo": "^1.2.0", "streamx": "^2.15.0" } }, "sha512-ojzvCvVaNp6aOTFmG7jaRD0meowIAuPc3cMMhSgKiVWws1GyHbGd/xvnyuRKcKlMpt3qvxx6r0hreCNITP9hIg=="],
+
+    "teex": ["teex@1.0.1", "", { "dependencies": { "streamx": "^2.12.5" } }, "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg=="],
+
+    "terminal-link": ["terminal-link@4.0.0", "", { "dependencies": { "ansi-escapes": "^7.0.0", "supports-hyperlinks": "^3.2.0" } }, "sha512-lk+vH+MccxNqgVqSnkMVKx4VLJfnLjDBGzH16JVZjKE2DoxP57s6/vt6JmXV5I3jBcfGrxNrYtC+mPtU7WJztA=="],
+
+    "test-exclude": ["test-exclude@7.0.2", "", { "dependencies": { "@istanbuljs/schema": "^0.1.2", "glob": "^10.4.1", "minimatch": "^10.2.2" } }, "sha512-u9E6A+ZDYdp7a4WnarkXPZOx8Ilz46+kby6p1yZ8zsGTz9gYa6FIS7lj2oezzNKmtdyyJNNmmXDppga5GB7kSw=="],
+
+    "testing-infra": ["testing-infra@workspace:apps/vscode/testing-platform"],
+
+    "text-decoder": ["text-decoder@1.2.7", "", { "dependencies": { "b4a": "^1.6.4" } }, "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ=="],
+
+    "text-hex": ["text-hex@1.0.0", "", {}, "sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg=="],
+
+    "text-table": ["text-table@0.2.0", "", {}, "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="],
+
+    "textextensions": ["textextensions@6.11.0", "", { "dependencies": { "editions": "^6.21.0" } }, "sha512-tXJwSr9355kFJI3lbCkPpUH5cP8/M0GGy2xLO34aZCjMXBaK3SoPnZwr/oWmo1FdCnELcs4npdCIOFtq9W3ruQ=="],
+
+    "thread-stream": ["thread-stream@4.2.0", "", { "dependencies": { "real-require": "^1.0.0" } }, "sha512-e2zZ96wSChazBsbENf/Pcm/4swHt2cEKQ92rhUjkL9GCKiTDJIaTBenjE/m9DXi0QBmTMDkFDdOomUy20A1tDQ=="],
+
+    "three": ["three@0.177.0", "", {}, "sha512-EiXv5/qWAaGI+Vz2A+JfavwYCMdGjxVsrn3oBwllUoqYeaBO75J63ZfyaQKoiLrqNHoTlUc6PFgMXnS0kI45zg=="],
+
+    "throttle-debounce": ["throttle-debounce@3.0.1", "", {}, "sha512-dTEWWNu6JmeVXY0ZYoPuH5cRIwc0MeGbJwah9KUNYSJwommQpCzTySTpEe8Gs1J23aeWEuAobe4Ag7EHVt/LOg=="],
+
+    "throttleit": ["throttleit@2.1.0", "", {}, "sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw=="],
+
+    "through": ["through@2.3.8", "", {}, "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg=="],
+
+    "tiny-invariant": ["tiny-invariant@1.3.3", "", {}, "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg=="],
+
+    "tinybench": ["tinybench@2.9.0", "", {}, "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg=="],
+
+    "tinycolor2": ["tinycolor2@1.6.0", "", {}, "sha512-XPaBkWQJdsf3pLKJV9p4qN/S+fm2Oj8AIPo1BTUhg5oxkvm9+SVEGFdhyOz7tTdUTfvxMiAs4sp6/eZO2Ew+pw=="],
+
+    "tinyexec": ["tinyexec@1.2.4", "", {}, "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg=="],
+
+    "tinyglobby": ["tinyglobby@0.2.17", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g=="],
+
+    "tinypool": ["tinypool@1.1.1", "", {}, "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg=="],
+
+    "tinyrainbow": ["tinyrainbow@3.1.0", "", {}, "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw=="],
+
+    "tinyspy": ["tinyspy@4.0.4", "", {}, "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q=="],
+
+    "tldts": ["tldts@6.1.86", "", { "dependencies": { "tldts-core": "^6.1.86" }, "bin": { "tldts": "bin/cli.js" } }, "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ=="],
+
+    "tldts-core": ["tldts-core@6.1.86", "", {}, "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA=="],
+
+    "tmp": ["tmp@0.2.7", "", {}, "sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw=="],
+
+    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+
+    "toggle-selection": ["toggle-selection@1.0.6", "", {}, "sha512-BiZS+C1OS8g/q2RRbJmy59xpyghNBqrr6k5L/uKBGRsTfxmu3ffiRnd8mlGPUVayg8pvfi5urfnu8TU7DVOkLQ=="],
+
+    "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],
+
+    "token-types": ["token-types@4.2.1", "", { "dependencies": { "@tokenizer/token": "^0.3.0", "ieee754": "^1.2.1" } }, "sha512-6udB24Q737UD/SDsKAHI9FCRP7Bqc9D/MQUV02ORQg5iskjtLJlZJNdN4kKtcdtwCeWIwIHDGaUsTsCCAa8sFQ=="],
+
+    "tokenlens": ["tokenlens@1.3.1", "", { "dependencies": { "@tokenlens/core": "1.3.0", "@tokenlens/fetch": "1.3.0", "@tokenlens/helpers": "1.3.1", "@tokenlens/models": "1.3.0" } }, "sha512-7oxmsS5PNCX3z+b+z07hL5vCzlgHKkCGrEQjQmWl5l+v5cUrtL7S1cuST4XThaL1XyjbTX8J5hfP0cjDJRkaLA=="],
+
+    "tough-cookie": ["tough-cookie@5.1.2", "", { "dependencies": { "tldts": "^6.1.32" } }, "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A=="],
+
+    "tr46": ["tr46@5.1.1", "", { "dependencies": { "punycode": "^2.3.1" } }, "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw=="],
+
+    "traverse": ["traverse@0.3.9", "", {}, "sha512-iawgk0hLP3SxGKDfnDJf8wTz4p2qImnyihM5Hh/sGvQ3K37dPi/w8sRhdNIxYA1TwFwc5mDhIJq+O0RsvXBKdQ=="],
+
+    "tree-kill": ["tree-kill@1.2.2", "", { "bin": { "tree-kill": "cli.js" } }, "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A=="],
+
+    "trim-lines": ["trim-lines@3.0.1", "", {}, "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg=="],
+
+    "trim-trailing-lines": ["trim-trailing-lines@2.1.0", "", {}, "sha512-5UR5Biq4VlVOtzqkm2AZlgvSlDJtME46uV0br0gENbwN4l5+mMKT4b9gJKqWtuL2zAIqajGJGuvbCbcAJUZqBg=="],
+
+    "triple-beam": ["triple-beam@1.4.1", "", {}, "sha512-aZbgViZrg1QNcG+LULa7nhZpJTZSLm/mXnHXnbAbjmN5aSa0y7V+wvv6+4WaBtpISJzThKy+PIPxc1Nq1EJ9mg=="],
+
+    "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
+
+    "ts-api-utils": ["ts-api-utils@2.5.0", "", { "peerDependencies": { "typescript": ">=4.8.4" } }, "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA=="],
+
+    "ts-dedent": ["ts-dedent@2.3.0", "", {}, "sha512-JfJeIHke7y2egdGGgRAvpCwYFUsHlM2gPcrVOxFkznt/4uzQ7HFmvE63iFHVLBJNDuyDOQgijDK/tXH/f6Msjg=="],
+
+    "ts-easing": ["ts-easing@0.2.0", "", {}, "sha512-Z86EW+fFFh/IFB1fqQ3/+7Zpf9t2ebOAxNI/V6Wo7r5gqiqtxmgTlQ1qbqQcjLKYeSHPTsEmvlJUDg/EuL0uHQ=="],
+
+    "ts-error": ["ts-error@1.0.6", "", {}, "sha512-tLJxacIQUM82IR7JO1UUkKlYuUTmoY9HBJAmNWFzheSlDS5SPMcNIepejHJa4BpPQLAcbRhRf3GDJzyj6rbKvA=="],
+
+    "ts-mixer": ["ts-mixer@6.0.4", "", {}, "sha512-ufKpbmrugz5Aou4wcr5Wc1UUFWOLhq+Fm6qa6P0w0K5Qw2yhaUoiWszhCVuNQyNwrlGiscHOmqYoAox1PtvgjA=="],
+
+    "ts-morph": ["ts-morph@25.0.1", "", { "dependencies": { "@ts-morph/common": "~0.26.0", "code-block-writer": "^13.0.3" } }, "sha512-QJEiTdnz1YjrB3JFhd626gX4rKHDLSjSVMvGGG4v7ONc3RBwa0Eei98G9AT9uNFDMtV54JyuXsFeC+OH0n6bXQ=="],
+
+    "ts-node": ["ts-node@10.9.2", "", { "dependencies": { "@cspotcode/source-map-support": "^0.8.0", "@tsconfig/node10": "^1.0.7", "@tsconfig/node12": "^1.0.7", "@tsconfig/node14": "^1.0.0", "@tsconfig/node16": "^1.0.2", "acorn": "^8.4.1", "acorn-walk": "^8.1.1", "arg": "^4.1.0", "create-require": "^1.1.0", "diff": "^4.0.1", "make-error": "^1.1.1", "v8-compile-cache-lib": "^3.0.1", "yn": "3.1.1" }, "peerDependencies": { "@swc/core": ">=1.2.50", "@swc/wasm": ">=1.2.50", "@types/node": "*", "typescript": ">=2.7" }, "optionalPeers": ["@swc/core", "@swc/wasm"], "bin": { "ts-node": "dist/bin.js", "ts-script": "dist/bin-script-deprecated.js", "ts-node-cwd": "dist/bin-cwd.js", "ts-node-esm": "dist/bin-esm.js", "ts-node-script": "dist/bin-script.js", "ts-node-transpile-only": "dist/bin-transpile.js" } }, "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ=="],
+
+    "ts-poet": ["ts-poet@6.12.0", "", { "dependencies": { "dprint-node": "^1.0.8" } }, "sha512-xo+iRNMWqyvXpFTaOAvLPA5QAWO6TZrSUs5s4Odaya3epqofBu/fMLHEWl8jPmjhA0s9sgj9sNvF1BmaQlmQkA=="],
+
+    "ts-proto": ["ts-proto@2.11.10", "", { "dependencies": { "@bufbuild/protobuf": "^2.10.2", "case-anything": "^2.1.13", "ts-poet": "^6.12.0", "ts-proto-descriptors": "2.1.0" }, "bin": { "protoc-gen-ts_proto": "protoc-gen-ts_proto" } }, "sha512-7mvz2RbOZc0J/+x8biIcVHJ0nx7xjH79vtoEnkpKT5l8yFF5ERe03dee2W3CbB5vb1QgnbQXGzeBGGryJ+Q9EA=="],
+
+    "ts-proto-descriptors": ["ts-proto-descriptors@2.1.0", "", { "dependencies": { "@bufbuild/protobuf": "^2.0.0" } }, "sha512-S5EZYEQ6L9KLFfjSRpZWDIXDV/W7tAj8uW7pLsihIxyr62EAVSiKuVPwE8iWnr849Bqa53enex1jhDUcpgquzA=="],
+
+    "tsconfig-paths": ["tsconfig-paths@4.2.0", "", { "dependencies": { "json5": "^2.2.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } }, "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg=="],
+
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "tunnel": ["tunnel@0.0.6", "", {}, "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="],
+
+    "tunnel-agent": ["tunnel-agent@0.6.0", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w=="],
+
+    "turndown": ["turndown@7.2.4", "", { "dependencies": { "@mixmark-io/domino": "^2.2.0" } }, "sha512-I8yFsfRzmzK0WV1pNNOA4A7y4RDfFxPRxb3t+e3ui14qSGOxGtiSP6GjeX+Y6CHb7HYaFj7ECUD7VE5kQMZWGQ=="],
+
+    "tw-animate-css": ["tw-animate-css@1.4.0", "", {}, "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ=="],
+
+    "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="],
+
+    "type-detect": ["type-detect@4.1.0", "", {}, "sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw=="],
+
+    "type-fest": ["type-fest@2.19.0", "", {}, "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA=="],
+
+    "type-is": ["type-is@2.1.0", "", { "dependencies": { "content-type": "^2.0.0", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA=="],
+
+    "typed-query-selector": ["typed-query-selector@2.12.2", "", {}, "sha512-EOPFbyIub4ngnEdqi2yOcNeDLaX/0jcE1JoAXQDDMIthap7FoN795lc/SHfIq2d416VufXpM8z/lD+WRm2gfOQ=="],
+
+    "typed-rest-client": ["typed-rest-client@1.8.11", "", { "dependencies": { "qs": "^6.9.1", "tunnel": "0.0.6", "underscore": "^1.12.1" } }, "sha512-5UvfMpd1oelmUPRbbaVnq+rHP7ng2cE4qoQkQeAqxRL6PklkxsM0g32/HL0yfvruK6ojQ5x8EE+HF4YV6DtuCA=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "typescript-eslint": ["typescript-eslint@8.62.1", "", { "dependencies": { "@typescript-eslint/eslint-plugin": "8.62.1", "@typescript-eslint/parser": "8.62.1", "@typescript-eslint/typescript-estree": "8.62.1", "@typescript-eslint/utils": "8.62.1" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", "typescript": ">=4.8.4 <6.1.0" } }, "sha512-vymnnM5g0AKQDSAyfP12nMIBvgwgA42syg74kkuZ4x1VuTzwQKwc5h9rGxeShCjny5o+zWAb6OEoz7XLgrIkIw=="],
+
+    "uc.micro": ["uc.micro@1.0.6", "", {}, "sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA=="],
+
+    "ulid": ["ulid@2.4.0", "", { "bin": { "ulid": "bin/cli.js" } }, "sha512-fIRiVTJNcSRmXKPZtGzFQv9WRrZ3M9eoptl/teFJvjOzmpU+/K/JH6HZ8deBfb5vMEpicJcLn7JmvdknlMq7Zg=="],
+
+    "unbzip2-stream": ["unbzip2-stream@1.4.3", "", { "dependencies": { "buffer": "^5.2.1", "through": "^2.3.8" } }, "sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg=="],
+
+    "underscore": ["underscore@1.13.8", "", {}, "sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ=="],
+
+    "undici": ["undici@7.28.0", "", {}, "sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA=="],
+
+    "undici-types": ["undici-types@7.24.6", "", {}, "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg=="],
+
+    "unicorn-magic": ["unicorn-magic@0.3.0", "", {}, "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA=="],
+
+    "unified": ["unified@11.0.5", "", { "dependencies": { "@types/unist": "^3.0.0", "bail": "^2.0.0", "devlop": "^1.0.0", "extend": "^3.0.0", "is-plain-obj": "^4.0.0", "trough": "^2.0.0", "vfile": "^6.0.0" } }, "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA=="],
+
+    "unist-builder": ["unist-builder@2.0.3", "", {}, "sha512-f98yt5pnlMWlzP539tPc4grGMsFaQQlP/vM396b00jngsiINumNmsY8rkXjfoi1c6QaM8nQ3vaGDuoKWbe/1Uw=="],
+
+    "unist-util-find-after": ["unist-util-find-after@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ=="],
+
+    "unist-util-generated": ["unist-util-generated@1.1.6", "", {}, "sha512-cln2Mm1/CZzN5ttGK7vkoGw+RZ8VcUH6BtGbq98DDtRGquAAOXig1mrBQYelOwMXYS8rK+vZDyyojSjp7JX+Lg=="],
+
+    "unist-util-is": ["unist-util-is@6.0.1", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g=="],
+
+    "unist-util-position": ["unist-util-position@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA=="],
+
+    "unist-util-remove-position": ["unist-util-remove-position@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q=="],
+
+    "unist-util-stringify-position": ["unist-util-stringify-position@4.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ=="],
+
+    "unist-util-visit": ["unist-util-visit@5.1.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg=="],
+
+    "unist-util-visit-parents": ["unist-util-visit-parents@6.0.2", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ=="],
+
+    "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
+
+    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
+
+    "unplugin": ["unplugin@1.16.1", "", { "dependencies": { "acorn": "^8.14.0", "webpack-virtual-modules": "^0.6.2" } }, "sha512-4/u/j4FrCKdi17jaxuJA0jClGxB1AvU2hw/IuayPc4ay1XGaJs/rbb4v5WKwAjNifjmXK9PIFyuPiaK8azyR9w=="],
+
+    "unzipper": ["unzipper@0.10.14", "", { "dependencies": { "big-integer": "^1.6.17", "binary": "~0.3.0", "bluebird": "~3.4.1", "buffer-indexof-polyfill": "~1.0.0", "duplexer2": "~0.1.4", "fstream": "^1.0.12", "graceful-fs": "^4.2.2", "listenercount": "~1.0.1", "readable-stream": "~2.3.6", "setimmediate": "~1.0.4" } }, "sha512-ti4wZj+0bQTiX2KmKWuwj7lhV+2n//uXEotUmGuQqrbVZSEGFMbI68+c6JCQ8aAmUWYvtHEz2A8K6wXvueR/6g=="],
+
+    "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="],
+
+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
+
+    "url-join": ["url-join@4.0.1", "", {}, "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA=="],
+
+    "url-template": ["url-template@2.0.8", "", {}, "sha512-XdVKMF4SJ0nP/O7XIPB0JwAEuT9lDIYnNsK8yGVe43y0AWoKeJNdv3ZNWh7ksJ6KqQFjOO6ox/VEitLnaVNufw=="],
+
+    "use-callback-ref": ["use-callback-ref@1.3.3", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="],
+
+    "use-composed-ref": ["use-composed-ref@1.4.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-djviaxuOOh7wkj0paeO1Q/4wMZ8Zrnag5H6yBvzN7AKKe8beOaED9SF5/ByLqsku8NP4zQqsvM2u3ew/tJK8/w=="],
+
+    "use-isomorphic-layout-effect": ["use-isomorphic-layout-effect@1.2.1", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-tpZZ+EX0gaghDAiFR37hj5MgY6ZN55kLiPkJsKxBMZ6GZdOSPJXiOzPM984oPYZ5AnehYx5WQp1+ME8I/P/pRA=="],
+
+    "use-latest": ["use-latest@1.3.0", "", { "dependencies": { "use-isomorphic-layout-effect": "^1.1.1" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-mhg3xdm9NaM8q+gLT8KryJPnRFOz1/5XPBhmDEVZK1webPzDjrPk7f/mbpeLqTgB9msytYWANxgALOCJKnLvcQ=="],
+
+    "use-sidecar": ["use-sidecar@1.1.3", "", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="],
+
+    "use-stick-to-bottom": ["use-stick-to-bottom@1.1.6", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-z3Up8jYQGTkUCsGBnwg6/wj70KgXoW5Kz1AAc1j8MtQuYMBo6ZsdhrIXoegxa7gaMMilgQYyTohTrt3p94jHog=="],
+
+    "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="],
+
+    "utif2": ["utif2@4.1.0", "", { "dependencies": { "pako": "^1.0.11" } }, "sha512-+oknB9FHrJ7oW7A2WZYajOcv4FcDR4CfoGB0dPNfxbi4GO05RRnFmt5oa23+9w32EanrYcSJWspUiJkLMs+37w=="],
+
+    "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+
+    "uuid": ["uuid@11.1.1", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ=="],
+
+    "v8-compile-cache-lib": ["v8-compile-cache-lib@3.0.1", "", {}, "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg=="],
+
+    "v8-to-istanbul": ["v8-to-istanbul@9.3.0", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.12", "@types/istanbul-lib-coverage": "^2.0.1", "convert-source-map": "^2.0.0" } }, "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA=="],
+
+    "validate-npm-package-license": ["validate-npm-package-license@3.0.4", "", { "dependencies": { "spdx-correct": "^3.0.0", "spdx-expression-parse": "^3.0.0" } }, "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew=="],
+
+    "validate-npm-package-name": ["validate-npm-package-name@7.0.2", "", {}, "sha512-hVDIBwsRruT73PbK7uP5ebUt+ezEtCmzZz3F59BSr2F6OVFnJ/6h8liuvdLrQ88Xmnk6/+xGGuq+pG9WwTuy3A=="],
+
+    "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],
+
+    "vaul": ["vaul@1.1.2", "", { "dependencies": { "@radix-ui/react-dialog": "^1.1.1" }, "peerDependencies": { "react": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-ZFkClGpWyI2WUQjdLJ/BaGuV6AVQiJ3uELGk3OYtP+B6yCO7Cmn9vPFXVJkRaGkOJu3m8bQMgtyzNHixULceQA=="],
+
+    "verror": ["verror@1.10.1", "", { "dependencies": { "assert-plus": "^1.0.0", "core-util-is": "1.0.2", "extsprintf": "^1.2.0" } }, "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg=="],
+
+    "version-range": ["version-range@4.15.0", "", {}, "sha512-Ck0EJbAGxHwprkzFO966t4/5QkRuzh+/I1RxhLgUKKwEn+Cd8NwM60mE3AqBZg5gYODoXW0EFsQvbZjRlvdqbg=="],
+
+    "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="],
+
+    "vfile-location": ["vfile-location@5.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg=="],
+
+    "vfile-message": ["vfile-message@4.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw=="],
+
+    "victory-vendor": ["victory-vendor@36.9.2", "", { "dependencies": { "@types/d3-array": "^3.0.3", "@types/d3-ease": "^3.0.0", "@types/d3-interpolate": "^3.0.1", "@types/d3-scale": "^4.0.2", "@types/d3-shape": "^3.1.0", "@types/d3-time": "^3.0.0", "@types/d3-timer": "^3.0.0", "d3-array": "^3.1.6", "d3-ease": "^3.0.1", "d3-interpolate": "^3.0.1", "d3-scale": "^4.0.2", "d3-shape": "^3.1.0", "d3-time": "^3.0.0", "d3-timer": "^3.0.1" } }, "sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ=="],
+
+    "vite": ["vite@8.1.2", "", { "dependencies": { "lightningcss": "^1.32.0", "picomatch": "^4.0.4", "postcss": "^8.5.16", "rolldown": "~1.1.3", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.3.0", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-6YYPbRXTxx6bRXmOn7XdnQAy5DQNHhDgtjhDHI13oe4pY93kkcdGJWxpGwOm++/Wh0QpQhDrpIoVMrmrsI5AGQ=="],
+
+    "vite-node": ["vite-node@3.2.4", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.1", "es-module-lexer": "^1.7.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg=="],
+
+    "vitest": ["vitest@4.1.9", "", { "dependencies": { "@vitest/expect": "4.1.9", "@vitest/mocker": "4.1.9", "@vitest/pretty-format": "4.1.9", "@vitest/runner": "4.1.9", "@vitest/snapshot": "4.1.9", "@vitest/spy": "4.1.9", "@vitest/utils": "4.1.9", "es-module-lexer": "^2.0.0", "expect-type": "^1.3.0", "magic-string": "^0.30.21", "obug": "^2.1.1", "pathe": "^2.0.3", "picomatch": "^4.0.3", "std-env": "^4.0.0-rc.1", "tinybench": "^2.9.0", "tinyexec": "^1.0.2", "tinyglobby": "^0.2.15", "tinyrainbow": "^3.1.0", "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@opentelemetry/api": "^1.9.0", "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", "@vitest/browser-playwright": "4.1.9", "@vitest/browser-preview": "4.1.9", "@vitest/browser-webdriverio": "4.1.9", "@vitest/coverage-istanbul": "4.1.9", "@vitest/coverage-v8": "4.1.9", "@vitest/ui": "4.1.9", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@opentelemetry/api", "@types/node", "@vitest/browser-playwright", "@vitest/browser-preview", "@vitest/browser-webdriverio", "@vitest/coverage-istanbul", "@vitest/coverage-v8", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "./vitest.mjs" } }, "sha512-nE3/LEyc0z87uHYLZebqCUOaJr2hdtuPp7BQ4BosVFnfltxgAvMG08NyrSGlPpOUWvR27c5flSmYFTNr78L9GQ=="],
+
+    "voca": ["voca@1.4.1", "", {}, "sha512-NJC/BzESaHT1p4B5k4JykxedeltmNbau4cummStd4RjFojgq/kLew5TzYge9N2geeWyI2w8T30wUET5v+F7ZHA=="],
+
+    "vscode-uri": ["vscode-uri@3.1.0", "", {}, "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ=="],
+
+    "w3c-xmlserializer": ["w3c-xmlserializer@5.0.0", "", { "dependencies": { "xml-name-validator": "^5.0.0" } }, "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA=="],
+
+    "web-namespaces": ["web-namespaces@2.0.1", "", {}, "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="],
+
+    "web-streams-polyfill": ["web-streams-polyfill@4.0.0-beta.3", "", {}, "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug=="],
+
+    "web-tree-sitter": ["web-tree-sitter@0.25.10", "", { "peerDependencies": { "@types/emscripten": "^1.40.0" }, "optionalPeers": ["@types/emscripten"] }, "sha512-Y09sF44/13XvgVKgO2cNDw5rGk6s26MgoZPXLESvMXeefBf7i6/73eFurre0IsTW6E14Y0ArIzhUMmjoc7xyzA=="],
+
+    "web-vitals": ["web-vitals@5.3.0", "", {}, "sha512-q6LWsLatGYZp5VGBIOvbTj6JBV2nOmC8KvWztXBmwJcfFAzhwKwbOxhUH306XY3CcaZDUlSmSuNPBsCn0bFu+g=="],
+
+    "webidl-conversions": ["webidl-conversions@7.0.0", "", {}, "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g=="],
+
+    "webpack-virtual-modules": ["webpack-virtual-modules@0.6.2", "", {}, "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ=="],
+
+    "websocket-driver": ["websocket-driver@0.7.5", "", { "dependencies": { "http-parser-js": ">=0.5.1", "safe-buffer": ">=5.1.0", "websocket-extensions": ">=0.1.1" } }, "sha512-ZL2+3c7kMBdIRCMz6l8jQMHyGVxj+UL+xVk74Ombiciboca8rHa15L86B19E5oh1pL9Ii/uj54gtsIrZGMo6zA=="],
+
+    "websocket-extensions": ["websocket-extensions@0.1.4", "", {}, "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg=="],
+
+    "webview": ["webview@workspace:apps/examples/vscode/src/webview"],
+
+    "webview-ui": ["webview-ui@workspace:apps/vscode/webview-ui"],
+
+    "whatwg-encoding": ["whatwg-encoding@3.1.1", "", { "dependencies": { "iconv-lite": "0.6.3" } }, "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ=="],
+
+    "whatwg-mimetype": ["whatwg-mimetype@4.0.0", "", {}, "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg=="],
+
+    "whatwg-url": ["whatwg-url@14.2.0", "", { "dependencies": { "tr46": "^5.1.0", "webidl-conversions": "^7.0.0" } }, "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw=="],
+
+    "which": ["which@4.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg=="],
+
+    "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="],
+
+    "wide-align": ["wide-align@1.1.5", "", { "dependencies": { "string-width": "^1.0.2 || 2 || 3 || 4" } }, "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg=="],
+
+    "windows-release": ["windows-release@6.1.0", "", { "dependencies": { "execa": "^8.0.1" } }, "sha512-1lOb3qdzw6OFmOzoY0nauhLG72TpWtb5qgYPiSh/62rjc1XidBSDio2qw0pwHh17VINF217ebIkZJdFLZFn9SA=="],
+
+    "winston": ["winston@3.19.0", "", { "dependencies": { "@colors/colors": "^1.6.0", "@dabh/diagnostics": "^2.0.8", "async": "^3.2.3", "is-stream": "^2.0.0", "logform": "^2.7.0", "one-time": "^1.0.0", "readable-stream": "^3.4.0", "safe-stable-stringify": "^2.3.1", "stack-trace": "0.0.x", "triple-beam": "^1.3.0", "winston-transport": "^4.9.0" } }, "sha512-LZNJgPzfKR+/J3cHkxcpHKpKKvGfDZVPS4hfJCc4cCG0CgYzvlD6yE/S3CIL/Yt91ak327YCpiF/0MyeZHEHKA=="],
+
+    "winston-transport": ["winston-transport@4.9.0", "", { "dependencies": { "logform": "^2.7.0", "readable-stream": "^3.6.2", "triple-beam": "^1.3.0" } }, "sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A=="],
+
+    "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
+
+    "workerpool": ["workerpool@9.3.4", "", {}, "sha512-TmPRQYYSAnnDiEB0P/Ytip7bFGvqnSU6I2BcuSw7Hx+JSg/DsUi5ebYfc8GYaSdpuvOcEs6dXxPurOYpe9QFwg=="],
+
+    "wrap-ansi": ["wrap-ansi@9.0.2", "", { "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" } }, "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww=="],
+
+    "wrap-ansi-cjs": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
+
+    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
+
+    "ws": ["ws@8.21.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g=="],
+
+    "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="],
+
+    "xml-name-validator": ["xml-name-validator@5.0.0", "", {}, "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg=="],
+
+    "xml-parse-from-string": ["xml-parse-from-string@1.0.1", "", {}, "sha512-ErcKwJTF54uRzzNMXq2X5sMIy88zJvfN2DmdoQvy7PAFJ+tPRU6ydWuOKNMyfmOjdyBQTFREi60s0Y0SyI0G0g=="],
+
+    "xml2js": ["xml2js@0.5.0", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA=="],
+
+    "xmlbuilder": ["xmlbuilder@10.1.1", "", {}, "sha512-OyzrcFLL/nb6fMGHbiRDuPup9ljBycsdCypwuyg5AAHvyWzGfChJpCXMG88AGTIMFhGZ9RccFN1e6lhg3hkwKg=="],
+
+    "xmlchars": ["xmlchars@2.2.0", "", {}, "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw=="],
+
+    "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="],
+
+    "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
+
+    "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
+
+    "yaml": ["yaml@2.9.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="],
+
+    "yargs": ["yargs@17.7.3", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g=="],
+
+    "yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="],
+
+    "yargs-unparser": ["yargs-unparser@2.0.0", "", { "dependencies": { "camelcase": "^6.0.0", "decamelize": "^4.0.0", "flat": "^5.0.2", "is-plain-obj": "^2.1.0" } }, "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA=="],
+
+    "yauzl": ["yauzl@3.4.0", "", { "dependencies": { "pend": "~1.2.0" } }, "sha512-jIH9yLR9wqr0wOS0TpBvo/g/2UgZH5qePVbjgRliiF0BYvOZyaBknKsF+x9Iht0O6sqgnB93rCICdOZFecJuDw=="],
+
+    "yazl": ["yazl@2.5.1", "", { "dependencies": { "buffer-crc32": "~0.2.3" } }, "sha512-phENi2PLiHnHb6QBVot+dJnaAZ0xosj7p3fWl+znIjBDlnMI2PsZCJZ306BPTFOaHf5qdDEI8x5qFrSOBN5vrw=="],
+
+    "yn": ["yn@3.1.1", "", {}, "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q=="],
+
+    "yocto-queue": ["yocto-queue@1.2.2", "", {}, "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ=="],
+
+    "yocto-spinner": ["yocto-spinner@1.2.0", "", { "dependencies": { "yoctocolors": "^2.1.1" } }, "sha512-Yw0hUB6UA3o4YUgKy3oSe9a4cxoaZ9sBfYDw+JSxo6Id0KoJGoxzPA24qqUXYKBWABs/zDSGTz9kww7t3F0XGw=="],
+
+    "yoctocolors": ["yoctocolors@2.1.2", "", {}, "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug=="],
+
+    "yoga-layout": ["yoga-layout@3.2.1", "", {}, "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ=="],
+
+    "zip-stream": ["zip-stream@6.0.1", "", { "dependencies": { "archiver-utils": "^5.0.0", "compress-commons": "^6.0.2", "readable-stream": "^4.0.0" } }, "sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA=="],
+
+    "zod": ["zod@4.4.3", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="],
+
+    "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
+
+    "zod-validation-error": ["zod-validation-error@4.0.2", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ=="],
+
+    "zustand": ["zustand@4.5.7", "", { "dependencies": { "use-sync-external-store": "^1.2.2" }, "peerDependencies": { "@types/react": ">=16.8", "immer": ">=9.0.6", "react": ">=16.8" }, "optionalPeers": ["@types/react", "immer", "react"] }, "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw=="],
+
+    "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
+
+    "@adobe/react-spectrum/@internationalized/date": ["@internationalized/date@3.12.2", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw=="],
+
+    "@adobe/react-spectrum/@react-types/shared": ["@react-types/shared@3.36.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-DkP/H0C2YjjS7gZWKNqOmU8a16qHPjQNdzMwmTq9SzplM6Iw0kVMTZ0OIoe6FOgGqa+FwMsE2QbPjh/n3g/jXQ=="],
+
+    "@anthropic-ai/sdk/@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
+
+    "@asamuzakjp/css-color/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "@babel/code-frame/js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
+
+    "@babel/core/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
+
+    "@babel/helper-compilation-targets/lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
+
+    "@babel/helper-compilation-targets/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
+
+    "@babel/helper-create-class-features-plugin/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
+
+    "@cline/cline-hub-webview/@types/node": ["@types/node@24.13.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-fRa09kZTgu8o71KFcDjUFuc7F+dEbZYZmkI0mg5YBTRs0yMKjYHsq/c0urDKeDb+D5qVgXOdFcuu+DZPKOITwA=="],
+
+    "@cline/code/lucide-react": ["lucide-react@0.564.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-JJ8GVTQqFwuliifD48U6+h7DXEHdkhJ/E87kksGByII3qHxtPciVb8T8woQONHBQgHVOl7rSMrrip3SeVNy7Fg=="],
+
+    "@cline/code/marked": ["marked@17.0.6", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-gB0gkNafnonOw0obSTEGZTT86IuhILt2Wfx0mWH/1Au83kybTayroZ/V6nS25mN7u8ASy+5fMhgB3XPNrOZdmA=="],
+
+    "@cline/code/recharts": ["recharts@2.15.0", "", { "dependencies": { "clsx": "^2.0.0", "eventemitter3": "^4.0.1", "lodash": "^4.17.21", "react-is": "^18.3.1", "react-smooth": "^4.0.0", "recharts-scale": "^0.4.4", "tiny-invariant": "^1.3.1", "victory-vendor": "^36.6.8" }, "peerDependencies": { "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-cIvMxDfpAmqAmVgc4yb7pgm/O1tmmkl/CjrvXuW+62/+7jj/iF9Ykm+hb/UJt42TREHMyd3gb+pkgoa2MxgDIw=="],
+
+    "@cline/code/sonner": ["sonner@1.7.4", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-DIS8z4PfJRbIyfVFDVnK9rO3eYDtse4Omcm6bt0oEr5/jtLgysmjuBl1frJ9E/EQZrFmKx2A8m/s5s9CRXIzhw=="],
+
+    "@cline/code/tw-animate-css": ["tw-animate-css@1.3.3", "", {}, "sha512-tXE2TRWrskc4TU3RDd7T8n8Np/wCfoeH9gz22c7PzYqNPQ9FBGFbWWzwL0JyHcFp+jHozmF76tbHfPAx22ua2Q=="],
+
+    "@cline/code/typescript": ["typescript@5.7.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw=="],
+
+    "@cline/code/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@cspotcode/source-map-support/@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.9", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.0.3", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ=="],
+
+    "@discordjs/builders/discord-api-types": ["discord-api-types@0.38.49", "", {}, "sha512-XnqcWmnFZFAE8ZM8SHAw9DIV8D3Or00rMQ8iQLotrEA2PmXhl+ykaf6L6q4l474hrSUH1JaYcv+iOMRWp2p6Tg=="],
+
+    "@discordjs/formatters/discord-api-types": ["discord-api-types@0.38.49", "", {}, "sha512-XnqcWmnFZFAE8ZM8SHAw9DIV8D3Or00rMQ8iQLotrEA2PmXhl+ykaf6L6q4l474hrSUH1JaYcv+iOMRWp2p6Tg=="],
+
+    "@discordjs/rest/@discordjs/collection": ["@discordjs/collection@2.1.1", "", {}, "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg=="],
+
+    "@discordjs/rest/@sapphire/snowflake": ["@sapphire/snowflake@3.5.5", "", {}, "sha512-xzvBr1Q1c4lCe7i6sRnrofxeO1QTP/LKQ6A6qy0iB4x5yfiSfARMEQEghojzTNALDTcv8En04qYNIco9/K9eZQ=="],
+
+    "@discordjs/rest/discord-api-types": ["discord-api-types@0.38.49", "", {}, "sha512-XnqcWmnFZFAE8ZM8SHAw9DIV8D3Or00rMQ8iQLotrEA2PmXhl+ykaf6L6q4l474hrSUH1JaYcv+iOMRWp2p6Tg=="],
+
+    "@discordjs/rest/undici": ["undici@6.24.1", "", {}, "sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA=="],
+
+    "@discordjs/util/discord-api-types": ["discord-api-types@0.38.49", "", {}, "sha512-XnqcWmnFZFAE8ZM8SHAw9DIV8D3Or00rMQ8iQLotrEA2PmXhl+ykaf6L6q4l474hrSUH1JaYcv+iOMRWp2p6Tg=="],
+
+    "@discordjs/ws/@discordjs/collection": ["@discordjs/collection@2.1.1", "", {}, "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg=="],
+
+    "@discordjs/ws/discord-api-types": ["discord-api-types@0.38.49", "", {}, "sha512-XnqcWmnFZFAE8ZM8SHAw9DIV8D3Or00rMQ8iQLotrEA2PmXhl+ykaf6L6q4l474hrSUH1JaYcv+iOMRWp2p6Tg=="],
+
+    "@dotenvx/dotenvx/commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="],
+
+    "@dotenvx/dotenvx/execa": ["execa@5.1.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^6.0.0", "human-signals": "^2.1.0", "is-stream": "^2.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^4.0.1", "onetime": "^5.1.2", "signal-exit": "^3.0.3", "strip-final-newline": "^2.0.0" } }, "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg=="],
+
+    "@dotenvx/dotenvx/ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "@dotenvx/dotenvx/open": ["open@8.4.2", "", { "dependencies": { "define-lazy-prop": "^2.0.0", "is-docker": "^2.1.1", "is-wsl": "^2.2.0" } }, "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ=="],
+
+    "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
+
+    "@eslint/eslintrc/globals": ["globals@14.0.0", "", {}, "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ=="],
+
+    "@eslint/eslintrc/ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "@fast-csv/format/@types/node": ["@types/node@14.18.63", "", {}, "sha512-fAtCfv4jJg+ExtXhvCkCqUKZ+4ok/JQk01qDKhL5BDDoS3AxKXhV5/MAVUZyQnSEd2GT92fkgZl0pz0Q0AzcIQ=="],
+
+    "@fast-csv/parse/@types/node": ["@types/node@14.18.63", "", {}, "sha512-fAtCfv4jJg+ExtXhvCkCqUKZ+4ok/JQk01qDKhL5BDDoS3AxKXhV5/MAVUZyQnSEd2GT92fkgZl0pz0Q0AzcIQ=="],
+
+    "@firebase/firestore/@grpc/grpc-js": ["@grpc/grpc-js@1.9.16", "", { "dependencies": { "@grpc/proto-loader": "^0.7.8", "@types/node": ">=12.12.47" } }, "sha512-wE4Ut/olIzfKqp631XrG+wbF0v1vWFN4YL9FyXC2LJiG33DsV7PLzURjrCvY/6je2ntdRkeLpPDluzSRGaVltQ=="],
+
+    "@firebase/performance/web-vitals": ["web-vitals@4.2.4", "", {}, "sha512-r4DIlprAGwJ7YM11VZp4R884m0Vmgr6EAKe3P+kO0PPj3Unqyvv59rczf6UiGcb9Z8QxZVcqKNwv/g0WNdWwsw=="],
+
+    "@grpc/grpc-js/@grpc/proto-loader": ["@grpc/proto-loader@0.8.1", "", { "dependencies": { "lodash.camelcase": "^4.3.0", "long": "^5.0.0", "protobufjs": "^7.5.5", "yargs": "^17.7.2" }, "bin": { "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" } }, "sha512-wtF6h+DY6M3YaDBPAmvuuA6jV8Sif9MjtOI5euKFWRgCDl5PeDpPsHR9u2l6St5ceY8AZgoNDww5+HvEsXFsGg=="],
+
+    "@heroui/input-otp/input-otp": ["input-otp@1.4.1", "", { "peerDependencies": { "react": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-+yvpmKYKHi9jIGngxagY9oWiiblPB7+nEO75F2l2o4vs+6vpPZZmUl4tBNYuTCvQjhvEIbdNeJu70bhfYP2nbw=="],
+
+    "@heroui/theme/tailwind-merge": ["tailwind-merge@3.4.0", "", {}, "sha512-uSaO4gnW+b3Y2aWoWfFpX62vn2sR3skfhbjsEnaBI81WD1wBLlHZe5sWf0AqjksNdYTbGBEd0UasQMT3SNV15g=="],
+
+    "@heroui/use-aria-multiselect/@react-aria/label": ["@react-aria/label@3.7.25", "", { "dependencies": { "@react-aria/utils": "^3.33.1", "@react-types/shared": "^3.33.1", "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-oNK3Pqj4LDPwEbQaoM/uCip4QvQmmwGOh08VeW+vzSi6TAwf+KoWTyH/tiAeB0CHWNDK0k3e1iTygTAt4wzBmg=="],
+
+    "@heroui/use-is-mobile/@react-aria/ssr": ["@react-aria/ssr@3.9.10", "", { "dependencies": { "@swc/helpers": "^0.5.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-hvTm77Pf+pMBhuBm760Li0BVIO38jv1IBws1xFm1NoL26PU+fe+FMW5+VZWyANR6nYL65joaJKZqOdTQMkO9IQ=="],
+
+    "@jest/types/@jest/schemas": ["@jest/schemas@29.6.3", "", { "dependencies": { "@sinclair/typebox": "^0.27.8" } }, "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA=="],
+
+    "@jest/types/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "@jimp/core/mime": ["mime@3.0.0", "", { "bin": { "mime": "cli.js" } }, "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A=="],
+
+    "@jimp/plugin-blit/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-circle/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-color/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-contain/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-cover/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-crop/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-displace/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-fisheye/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-flip/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-mask/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-print/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-quantize/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-resize/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-rotate/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/plugin-threshold/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@jimp/types/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/vite": ["vite@7.3.6", "", { "dependencies": { "esbuild": "^0.27.0 || ^0.28.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg=="],
+
+    "@mapbox/hast-util-table-cell-style/unist-util-visit": ["unist-util-visit@1.4.1", "", { "dependencies": { "unist-util-visit-parents": "^2.0.0" } }, "sha512-AvGNk7Bb//EmJZyhtRUnNMEpId/AZ5Ph/KUpTI09WHQuDZHKovQ1oEv3mfmKpWKtoMzyMC4GLBm1Zy5k12fjIw=="],
+
+    "@microsoft/fast-foundation/tabbable": ["tabbable@5.3.3", "", {}, "sha512-QD9qKY3StfbZqWOPLp0++pOrAVb/HbUi5xCc8cUo4XjP19808oaMiDzn0leBY5mCespIBM0CIZePzZjgzR83kA=="],
+
+    "@microsoft/fast-foundation/tslib": ["tslib@1.14.1", "", {}, "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="],
+
+    "@microsoft/tui-test/commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="],
+
+    "@microsoft/tui-test/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "@microsoft/tui-test/jest-diff": ["jest-diff@29.7.0", "", { "dependencies": { "chalk": "^4.0.0", "diff-sequences": "^29.6.3", "jest-get-type": "^29.6.3", "pretty-format": "^29.7.0" } }, "sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw=="],
+
+    "@modelcontextprotocol/sdk/ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/exporter-logs-otlp-http/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/exporter-metrics-otlp-http": ["@opentelemetry/exporter-metrics-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-metrics": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-GD5QuCT6js+mDpb5OBO6OSyCH+k2Gy3xPHJV9BnjV8W6kpSuY8y2Samzs5vl23UcGMq6sHLAbs+Eq/VYsLMiVw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
+
+    "@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/resources": ["@opentelemetry/resources@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-lID/vxSuKWXM55XhAKNoYXu9Cutoq5hFdkbTdI/zDKQktXzcWBVhNsOkiZFTMU9UtEWuGRNe0HUgmsFldIdxVA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/resources": "2.6.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-9t9hJHX15meBy2NmTJxL+NJfXmnausR2xUDvE19XQce0Qi/GBtDGamU8nS1RMbdgDmhgpm3VaOu2+fiS/SfTpQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/exporter-metrics-otlp-http": ["@opentelemetry/exporter-metrics-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-metrics": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-GD5QuCT6js+mDpb5OBO6OSyCH+k2Gy3xPHJV9BnjV8W6kpSuY8y2Samzs5vl23UcGMq6sHLAbs+Eq/VYsLMiVw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-prometheus/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-prometheus/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-prometheus/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-http/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
+
+    "@opentelemetry/exporter-trace-otlp-http/@opentelemetry/resources": ["@opentelemetry/resources@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-lID/vxSuKWXM55XhAKNoYXu9Cutoq5hFdkbTdI/zDKQktXzcWBVhNsOkiZFTMU9UtEWuGRNe0HUgmsFldIdxVA=="],
+
+    "@opentelemetry/exporter-trace-otlp-http/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/resources": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-r86ut4T1e8vNwB35CqCcKd45yzqH6/6Wzvpk2/cZB8PsPLlZFTvrh8yfOS3CYZYcUmAx4hHTZJ8AO8Dj8nrdhw=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-zipkin/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/exporter-zipkin/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-zipkin/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-zipkin/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.205.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-wBlPk1nFB37Hsm+3Qy73yQSobVn28F4isnWIBvKpd5IUH/eat8bwcL02H9yzmHyyPmukeccSl2mbN5sDQZYnPg=="],
+
+    "@opentelemetry/instrumentation-http/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@opentelemetry/otlp-exporter-base/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/otlp-transformer/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
+
+    "@opentelemetry/otlp-transformer/@opentelemetry/resources": ["@opentelemetry/resources@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-lID/vxSuKWXM55XhAKNoYXu9Cutoq5hFdkbTdI/zDKQktXzcWBVhNsOkiZFTMU9UtEWuGRNe0HUgmsFldIdxVA=="],
+
+    "@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/resources": "2.6.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-9t9hJHX15meBy2NmTJxL+NJfXmnausR2xUDvE19XQce0Qi/GBtDGamU8nS1RMbdgDmhgpm3VaOu2+fiS/SfTpQ=="],
+
+    "@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/resources": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-r86ut4T1e8vNwB35CqCcKd45yzqH6/6Wzvpk2/cZB8PsPLlZFTvrh8yfOS3CYZYcUmAx4hHTZJ8AO8Dj8nrdhw=="],
+
+    "@opentelemetry/propagator-b3/@opentelemetry/core": ["@opentelemetry/core@1.30.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ=="],
+
+    "@opentelemetry/propagator-jaeger/@opentelemetry/core": ["@opentelemetry/core@1.30.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ=="],
+
+    "@opentelemetry/sdk-logs/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
+
+    "@opentelemetry/sdk-logs/@opentelemetry/resources": ["@opentelemetry/resources@2.6.1", "", { "dependencies": { "@opentelemetry/core": "2.6.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-lID/vxSuKWXM55XhAKNoYXu9Cutoq5hFdkbTdI/zDKQktXzcWBVhNsOkiZFTMU9UtEWuGRNe0HUgmsFldIdxVA=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-http": ["@opentelemetry/exporter-logs-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/sdk-logs": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-gN/itg2B30pa+yAqiuIHBCf3E77sSBlyWVzb+U/MDLzEMOwfnexlMvOWULnIO1l2xR2MNLEuPCQAOrL92JHEJg=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-http": ["@opentelemetry/exporter-trace-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-vqVuJvcwameA0r0cNrRzrZqPLB0otS+95g0XkZdiKOXUo81wYdY6r4kyrwz4nSChqTBEFm0lqi/H2OWGboOa6g=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@types/shimmer": "^1.2.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1", "semver": "^7.5.2", "shimmer": "^1.2.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-2KkGBKE+FPXU1F0zKww+stnlUxUTlBvLCiWdP63Z9sqXYeNI/ziNzsxAp4LAdUcTQmXjw1IWgvm5CAb/BHy99w=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-trace-node": ["@opentelemetry/sdk-trace-node@1.29.0", "", { "dependencies": { "@opentelemetry/context-async-hooks": "1.29.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/propagator-b3": "1.29.0", "@opentelemetry/propagator-jaeger": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "semver": "^7.5.2" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-ZpGYt+VnMu6O0SRKzhuIivr7qJm3GpWnTCMuJspu4kt3QWIpIenwixo5Vvjuu3R4h2Onl/8dtqAiPIs92xd5ww=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentui/core/marked": ["marked@17.0.1", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg=="],
+
+    "@radix-ui/react-accessible-icon/@radix-ui/react-visually-hidden": ["@radix-ui/react-visually-hidden@1.2.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-1wNZBggTDK3GRuuQ6nP4k2yi7a6l7I5qbMPbZcRsrGsGVead/f/d5FhEzUvqFs0bcrDLx7n1zKQ3JvLR6whaaw=="],
+
+    "@radix-ui/react-accordion/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-accordion/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-alert-dialog/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-alert-dialog/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-arrow/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "@radix-ui/react-avatar/@radix-ui/react-context": ["@radix-ui/react-context@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-ieIFACdMpYfMEjF0rEf5KLvfVyIkOz6PDGyNnP+u+4xQ6jny3VCgA4OgXOwNx2aUkxn8zx9fiVcM8CfFYv9Lxw=="],
+
+    "@radix-ui/react-avatar/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-checkbox/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-checkbox/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-collapsible/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-collapsible/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-collapsible/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-collection/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-collection/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-context-menu/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-context-menu/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-dialog/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-dialog/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-dialog/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-dismissable-layer/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-dismissable-layer/@radix-ui/react-use-escape-keydown": ["@radix-ui/react-use-escape-keydown@1.1.1", "", { "dependencies": { "@radix-ui/react-use-callback-ref": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g=="],
+
+    "@radix-ui/react-dropdown-menu/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-dropdown-menu/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-focus-scope/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-form/@radix-ui/primitive": ["@radix-ui/primitive@1.1.4", "", {}, "sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ=="],
+
+    "@radix-ui/react-form/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@radix-ui/react-form/@radix-ui/react-context": ["@radix-ui/react-context@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg=="],
+
+    "@radix-ui/react-form/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "@radix-ui/react-form/@radix-ui/react-label": ["@radix-ui/react-label@2.1.11", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-3PKvDDxOn62k0oV1n4QtNtD2vpu+zYjXR7ojLBPaO6SPvhy53yg0vAmgNeBQeJW5rV3dffoRG+HYfLBZuzw0CQ=="],
+
+    "@radix-ui/react-form/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "@radix-ui/react-hover-card/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-hover-card/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-id/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-menu/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-menu/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-menubar/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-menubar/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-navigation-menu/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-navigation-menu/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-navigation-menu/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/number": ["@radix-ui/number@1.1.2", "", {}, "sha512-ceTwaxc4I5IOi97DgCotl3pqiyRGvffcc0oOsE2dQYaJOFIDsDt4VWG6xEbg1QePv9QWausCEIppud/tJ1wNig=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/primitive": ["@radix-ui/primitive@1.1.4", "", {}, "sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-collection": ["@radix-ui/react-collection@1.1.11", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-djW9+zeg137KQdlPtmE8xnaD+K2rcXXMWFrSg0hsmYZ6HRbdTA7tDHFgpaW9+huWVEu0RCabL+985T4TA0BE7g=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-context": ["@radix-ui/react-context@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-direction": ["@radix-ui/react-direction@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-C3vFhbyi4SW3PmbAi6Awpu4OzJtd0MxGurvSsYtr7p7nM8RNB3VAF3CUmnp2j50knpkrRcB7+ycVXzgLgF6yNA=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-roving-focus": ["@radix-ui/react-roving-focus@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-8Qcnx9447tx/aCBgw6Jenfqg4Skq+vqab9mCBmuGNipIS5YXvL275wbKEu7+ICYHIlAPgCduUMJH1XOYewKF6Q=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-use-is-hydrated": ["@radix-ui/react-use-is-hydrated@0.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-qwOiz4Tjo8CNnrOLAYUMXeZwDzXgXpvK4TKQPmWLECM9XoWvA6+0Z2/7Ag3A4ivjS4ovbLJPbskkxioFyBhr8A=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/primitive": ["@radix-ui/primitive@1.1.4", "", {}, "sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/react-context": ["@radix-ui/react-context@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/react-use-is-hydrated": ["@radix-ui/react-use-is-hydrated@0.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-qwOiz4Tjo8CNnrOLAYUMXeZwDzXgXpvK4TKQPmWLECM9XoWvA6+0Z2/7Ag3A4ivjS4ovbLJPbskkxioFyBhr8A=="],
+
+    "@radix-ui/react-popover/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-popover/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-popover/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-popper/@radix-ui/react-arrow": ["@radix-ui/react-arrow@1.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w=="],
+
+    "@radix-ui/react-popper/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-popper/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-portal/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-portal/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-presence/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-progress/@radix-ui/react-context": ["@radix-ui/react-context@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-ieIFACdMpYfMEjF0rEf5KLvfVyIkOz6PDGyNnP+u+4xQ6jny3VCgA4OgXOwNx2aUkxn8zx9fiVcM8CfFYv9Lxw=="],
+
+    "@radix-ui/react-radio-group/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-radio-group/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-roving-focus/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-roving-focus/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-scroll-area/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-scroll-area/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-select/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-select/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-select/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-select/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-slider/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-slider/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-slider/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-switch/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-switch/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-tabs/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-tabs/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-toast/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-toast/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-toast/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-toggle/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-toggle/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-toggle-group/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-toggle-group/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/primitive": ["@radix-ui/primitive@1.1.4", "", {}, "sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-context": ["@radix-ui/react-context@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-direction": ["@radix-ui/react-direction@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-C3vFhbyi4SW3PmbAi6Awpu4OzJtd0MxGurvSsYtr7p7nM8RNB3VAF3CUmnp2j50knpkrRcB7+ycVXzgLgF6yNA=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-roving-focus": ["@radix-ui/react-roving-focus@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-8Qcnx9447tx/aCBgw6Jenfqg4Skq+vqab9mCBmuGNipIS5YXvL275wbKEu7+ICYHIlAPgCduUMJH1XOYewKF6Q=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-separator": ["@radix-ui/react-separator@1.1.11", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-jRhe86+8PF7VZ1u14eOWVOuh2BuAhALg/FT1VcMC4OHedMTRUazDnDlKTt+yxo5cRNKHMfmvZ4sSQtWDeMV4CQ=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-toggle-group": ["@radix-ui/react-toggle-group@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-toggle": "1.1.13", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-TK1vusNKb8IRhF23FTbRgUNZ9zfs5rGIyI7LfR3h26p9LrQ060i0uW9QWeD8baZMddaaP0DBGlIa6pbZG+mitg=="],
+
+    "@radix-ui/react-tooltip/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-tooltip/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-tooltip/@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-use-escape-keydown/@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw=="],
+
+    "@radix-ui/react-use-size/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-visually-hidden/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@react-aria/combobox/@react-aria/selection": ["@react-aria/selection@3.28.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-gGa9HkRnWsKxRhrtVASvecNyetMtP9fNF/Vcsy9Z+6NigjGUSN4SU0bhfglZ706B4t/NSMoVhcBJXlyFiG0hQw=="],
+
+    "@react-aria/combobox/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-aria/listbox/@react-aria/selection": ["@react-aria/selection@3.28.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-gGa9HkRnWsKxRhrtVASvecNyetMtP9fNF/Vcsy9Z+6NigjGUSN4SU0bhfglZ706B4t/NSMoVhcBJXlyFiG0hQw=="],
+
+    "@react-aria/listbox/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-aria/menu/@react-aria/selection": ["@react-aria/selection@3.28.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-gGa9HkRnWsKxRhrtVASvecNyetMtP9fNF/Vcsy9Z+6NigjGUSN4SU0bhfglZ706B4t/NSMoVhcBJXlyFiG0hQw=="],
+
+    "@react-aria/menu/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-aria/table/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-aria/tabs/@react-aria/selection": ["@react-aria/selection@3.28.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-gGa9HkRnWsKxRhrtVASvecNyetMtP9fNF/Vcsy9Z+6NigjGUSN4SU0bhfglZ706B4t/NSMoVhcBJXlyFiG0hQw=="],
+
+    "@react-stately/combobox/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-stately/list/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-stately/table/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-stately/tree/@react-stately/collections": ["@react-stately/collections@3.13.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-o1QSrtHyR7ODTdPyna87pZlgzvxBFOR8nI8XB+tQLIW2AMhE76pLYu4TN9CrZVy6nSAtE06IntyBV4toJIhorA=="],
+
+    "@react-types/dialog/@react-aria/dialog": ["@react-aria/dialog@3.6.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-Eo3Kj23TjENuERUYrGkH+VN1PJvK8/zep76pfwBg29erUVDpGdfagYRq82aGcxJ/ohG8iRxZDwp2tTrU1RG1MQ=="],
+
+    "@react-types/listbox/@react-aria/listbox": ["@react-aria/listbox@3.16.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-FbNeUXmo/H2Qp+yKboNod1eVhfmQDv1YexzEIAHsKL5Cx8uA7wZID9Pbq28jPC4plPISgS5KLBodaDikOXqviA=="],
+
+    "@react-types/slider/@react-aria/slider": ["@react-aria/slider@3.9.1", "", { "dependencies": { "@react-types/shared": "^3.34.0", "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-bFWhyM6mP9TzAjCpOKybS7x0RTsFa2+49XKytKN53xS7bdHEnWGbWpsdJ09qZ6z1fnrwFcq/j/hhj/0gVO8kdQ=="],
+
+    "@react-types/slider/@react-stately/slider": ["@react-stately/slider@3.8.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-MSfiRJakgdp2FSPtDeViEgXbYjRBGXXSTvExUvDDZx2xiEmSgefEQ4WWwCWPN4tdWbRISZoCYrmG8mY04Gevpw=="],
+
+    "@react-types/switch/@react-aria/switch": ["@react-aria/switch@3.8.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-WzkJG3xJnBdd9rdBxG+0RgWdopAqwI61Ni4ZQtA2rgFuG9UpZIrhsL7qgFO/+R6oEgoeGAMeUlvCf97Ppj2uTg=="],
+
+    "@react-types/tabs/@react-aria/tabs": ["@react-aria/tabs@3.12.1", "", { "dependencies": { "@react-types/shared": "^3.34.0", "@swc/helpers": "^0.5.0", "react-aria": "^3.48.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-fGMxbqSnqtn3GRiicLfnhWcnD6Auch0qCyt5ArfndYrISmSZkzq7PVZtDj85TEqC6p8WSw/M7HjWBBUX5/Of0g=="],
+
+    "@react-types/tabs/@react-stately/tabs": ["@react-stately/tabs@3.9.1", "", { "dependencies": { "@swc/helpers": "^0.5.0", "react-stately": "^3.46.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1", "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-xS9ByN7OMqvU9wyZJ8MnDvRTdsmB+GUP1whlRh4NmxWGmL4SDXKd4slSUGfb2lRi8lgT0OCAjd9om80HJP0p3w=="],
+
+    "@rollup/pluginutils/estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],
+
+    "@secretlint/config-loader/ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="],
+
+    "@sinonjs/commons/type-detect": ["type-detect@4.0.8", "", {}, "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g=="],
+
+    "@slack/socket-mode/eventemitter3": ["eventemitter3@5.0.4", "", {}, "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw=="],
+
+    "@slack/web-api/eventemitter3": ["eventemitter3@5.0.4", "", {}, "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw=="],
+
+    "@slack/web-api/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
+
+    "@slack/web-api/retry": ["retry@0.13.1", "", {}, "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg=="],
+
+    "@so-ric/colorspace/color": ["color@5.0.3", "", { "dependencies": { "color-convert": "^3.1.3", "color-string": "^2.1.3" } }, "sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA=="],
+
+    "@storybook/builder-vite/vite": ["vite@7.3.6", "", { "dependencies": { "esbuild": "^0.27.0 || ^0.28.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg=="],
+
+    "@storybook/react-vite/find-up": ["find-up@7.0.0", "", { "dependencies": { "locate-path": "^7.2.0", "path-exists": "^5.0.0", "unicorn-magic": "^0.1.0" } }, "sha512-YyZM99iHrqLKjmt4LJDj58KI+fYyufRLBSYcqycxf//KpBk9FoewoGX0450m9nB44qrZnovzC2oeP5hUibxc/g=="],
+
+    "@storybook/react-vite/vite": ["vite@7.3.6", "", { "dependencies": { "esbuild": "^0.27.0 || ^0.28.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg=="],
+
+    "@streamdown/code/shiki": ["shiki@3.23.0", "", { "dependencies": { "@shikijs/core": "3.23.0", "@shikijs/engine-javascript": "3.23.0", "@shikijs/engine-oniguruma": "3.23.0", "@shikijs/langs": "3.23.0", "@shikijs/themes": "3.23.0", "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-55Dj73uq9ZXL5zyeRPzHQsK7Nbyt6Y10k5s7OjuFZGMhpp4r/rsLBH0o/0fstIzX1Lep9VxefWljK/SKCzygIA=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.11.1", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.2", "tslib": "^2.4.0" }, "bundled": true }, "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.11.1", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.2", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.6", "", { "dependencies": { "@tybys/wasm-util": "^0.10.3" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" }, "bundled": true }, "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@tybys/wasm-util": ["@tybys/wasm-util@0.10.3", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@testing-library/dom/aria-query": ["aria-query@5.3.0", "", { "dependencies": { "dequal": "^2.0.3" } }, "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A=="],
+
+    "@testing-library/dom/dom-accessibility-api": ["dom-accessibility-api@0.5.16", "", {}, "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg=="],
+
+    "@testing-library/dom/pretty-format": ["pretty-format@27.5.1", "", { "dependencies": { "ansi-regex": "^5.0.1", "ansi-styles": "^5.0.0", "react-is": "^17.0.1" } }, "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ=="],
+
+    "@textlint/linter-formatter/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "@textlint/linter-formatter/pluralize": ["pluralize@2.0.0", "", {}, "sha512-TqNZzQCD4S42De9IfnnBvILN7HAW7riLqsCyp8lgjXeysyPlX5HhqKAcJHHHb9XskE4/a+7VGC9zzx8Ls0jOAw=="],
+
+    "@textlint/linter-formatter/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "@textlint/linter-formatter/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "@ts-morph/common/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "@types/jest/pretty-format": ["pretty-format@29.7.0", "", { "dependencies": { "@jest/schemas": "^29.6.3", "ansi-styles": "^5.0.0", "react-is": "^18.0.0" } }, "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ=="],
+
+    "@typescript-eslint/typescript-estree/minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "@typescript-eslint/visitor-keys/eslint-visitor-keys": ["eslint-visitor-keys@5.0.1", "", {}, "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA=="],
+
+    "@vitest/coverage-v8/std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="],
+
+    "@vitest/coverage-v8/tinyrainbow": ["tinyrainbow@2.0.0", "", {}, "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw=="],
+
+    "@vitest/expect/chai": ["chai@6.2.2", "", {}, "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg=="],
+
+    "@vscode/test-cli/chokidar": ["chokidar@3.6.0", "", { "dependencies": { "anymatch": "~3.1.2", "braces": "~3.0.2", "glob-parent": "~5.1.2", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.6.0" }, "optionalDependencies": { "fsevents": "~2.3.2" } }, "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw=="],
+
+    "@vscode/test-cli/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "@vscode/test-cli/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "@vscode/vsce/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "@vscode/vsce/commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="],
+
+    "@vscode/vsce/glob": ["glob@13.0.6", "", { "dependencies": { "minimatch": "^10.2.2", "minipass": "^7.1.3", "path-scurry": "^2.0.2" } }, "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw=="],
+
+    "@vscode/vsce/minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "ajv-formats/ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="],
+
+    "anymatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+
+    "archiver-utils/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "archiver-utils/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
+
+    "async-retry/retry": ["retry@0.13.1", "", {}, "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg=="],
+
+    "axios/https-proxy-agent": ["https-proxy-agent@5.0.1", "", { "dependencies": { "agent-base": "6", "debug": "4" } }, "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA=="],
+
+    "better-opn/open": ["open@8.4.2", "", { "dependencies": { "define-lazy-prop": "^2.0.0", "is-docker": "^2.1.1", "is-wsl": "^2.2.0" } }, "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ=="],
+
+    "bl/buffer": ["buffer@5.7.1", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.1.13" } }, "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ=="],
+
+    "bl/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
+    "body-parser/content-type": ["content-type@2.0.0", "", {}, "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ=="],
+
+    "body-parser/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
+
+    "chai/assertion-error": ["assertion-error@1.1.0", "", {}, "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw=="],
+
+    "chromium-bidi/zod": ["zod@3.23.8", "", {}, "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g=="],
+
+    "claude-dev/@microsoft/tui-test": ["@microsoft/tui-test@0.0.1", "", { "dependencies": { "@swc/core": "^1.3.102", "@xterm/headless": "^5.3.0", "chalk": "^5.3.0", "color-convert": "^2.0.1", "commander": "^11.1.0", "expect": "^29.7.0", "glob": "^10.3.10", "jest-diff": "^29.7.0", "pretty-ms": "^8.0.0", "proper-lockfile": "^4.1.2", "which": "^4.0.0", "workerpool": "^9.1.0" }, "optionalDependencies": { "node-pty": "1.2.0-beta.11" }, "bin": { "tui-test": "index.js" } }, "sha512-rbZuhFkWi6jz0M/56ESpw7IPt84Bl6C1i3fnNboeqz4WBQCxehZFFfqgu4Tfnr4PuWLfi1hMYwbJYCMwTxXMZQ=="],
+
+    "claude-dev/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http": ["@opentelemetry/exporter-logs-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/sdk-logs": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-gN/itg2B30pa+yAqiuIHBCf3E77sSBlyWVzb+U/MDLzEMOwfnexlMvOWULnIO1l2xR2MNLEuPCQAOrL92JHEJg=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http": ["@opentelemetry/exporter-metrics-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-metrics": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-GD5QuCT6js+mDpb5OBO6OSyCH+k2Gy3xPHJV9BnjV8W6kpSuY8y2Samzs5vl23UcGMq6sHLAbs+Eq/VYsLMiVw=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http": ["@opentelemetry/exporter-trace-otlp-http@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-exporter-base": "0.56.0", "@opentelemetry/otlp-transformer": "0.56.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-vqVuJvcwameA0r0cNrRzrZqPLB0otS+95g0XkZdiKOXUo81wYdY6r4kyrwz4nSChqTBEFm0lqi/H2OWGboOa6g=="],
+
+    "claude-dev/@opentelemetry/resources": ["@opentelemetry/resources@1.30.1", "", { "dependencies": { "@opentelemetry/core": "1.30.1", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA=="],
+
+    "claude-dev/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "claude-dev/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.30.1", "", { "dependencies": { "@opentelemetry/core": "1.30.1", "@opentelemetry/resources": "1.30.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-q9zcZ0Okl8jRgmy7eNW3Ku1XSgg3sDLa5evHZpCwjspw7E8Is4K/haRPDJrBcX3YSn/Y7gUvFnByNYEKQNbNog=="],
+
+    "claude-dev/@opentelemetry/sdk-trace-node": ["@opentelemetry/sdk-trace-node@1.30.1", "", { "dependencies": { "@opentelemetry/context-async-hooks": "1.30.1", "@opentelemetry/core": "1.30.1", "@opentelemetry/propagator-b3": "1.30.1", "@opentelemetry/propagator-jaeger": "1.30.1", "@opentelemetry/sdk-trace-base": "1.30.1", "semver": "^7.5.2" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ=="],
+
+    "claude-dev/@streamparser/json": ["@streamparser/json@0.0.22", "", {}, "sha512-b6gTSBjJ8G8SuO3Gbbj+zXbVx8NSs1EbpbMKpzGLWMdkR+98McH9bEjSz3+0mPJf68c5nxa3CrJHp5EQNXM6zQ=="],
+
+    "claude-dev/@types/node": ["@types/node@20.19.43", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-6oYBAi5ikg4Pl+kGsoYtawUMBT2zZMCvPNF7pVLnHZfd1zf38DRiWn/gT01RYCdUqkv7Fhr+C9ot4/tb+2sVvA=="],
+
+    "claude-dev/@types/vscode": ["@types/vscode@1.84.0", "", {}, "sha512-lCGOSrhT3cL+foUEqc8G1PVZxoDbiMmxgnUZZTEnHF4mC47eKAUtBGAuMLY6o6Ua8PAuNCoKXbqPmJd1JYnQfg=="],
+
+    "claude-dev/esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="],
+
+    "cli-truncate/string-width": ["string-width@8.2.1", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-IIaP0g3iy9Cyy18w3M9YcaDudujEAVHKt3a3QJg1+sr/oX96TbaGUubG0hJyCjCBThFH+tFpcIyoUHUn1ogaLA=="],
+
+    "cliui/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
+
+    "compress-commons/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
+
+    "conf/ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="],
+
+    "conf/ajv-formats": ["ajv-formats@2.1.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA=="],
+
+    "conf/json-schema-typed": ["json-schema-typed@7.0.3", "", {}, "sha512-7DE8mpG+/fVw+dTpjbxnx47TaMnDfOI1jwft9g1VybltZCduyRQPJPvc+zzKY9WPHxhPWczyFuYa6I8Mw4iU5A=="],
+
+    "cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
+
+    "cytoscape-fcose/cose-base": ["cose-base@2.2.0", "", { "dependencies": { "layout-base": "^2.0.0" } }, "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g=="],
+
+    "d3-dsv/commander": ["commander@7.2.0", "", {}, "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw=="],
+
+    "d3-sankey/d3-array": ["d3-array@2.12.1", "", { "dependencies": { "internmap": "^1.0.0" } }, "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ=="],
+
+    "d3-sankey/d3-shape": ["d3-shape@1.3.7", "", { "dependencies": { "d3-path": "1" } }, "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw=="],
+
+    "degenerator/ast-types": ["ast-types@0.13.4", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w=="],
+
+    "dify-ai-provider/@ai-sdk/provider": ["@ai-sdk/provider@2.0.3", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-h88OPkavHTiN9tMn2l5awAznGB0lXzjcLhgR1/rvjB2zlLprsNxbM2tt6OJsHUxduLC3klq0/eqaSf6fX5XVww=="],
+
+    "dify-ai-provider/@ai-sdk/provider-utils": ["@ai-sdk/provider-utils@3.0.28", "", { "dependencies": { "@ai-sdk/provider": "2.0.3", "@standard-schema/spec": "^1.0.0", "eventsource-parser": "^3.0.6" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-bXlX1WX7E50a2N+AJW+1a/x63m52aPhm+6xYe5THxWrx9vW9NR7E2Ay+1G1ndlCdMdYKo2Fnsd7kBhuyQPaphw=="],
+
+    "dify-ai-provider/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "discord.js/discord-api-types": ["discord-api-types@0.38.49", "", {}, "sha512-XnqcWmnFZFAE8ZM8SHAw9DIV8D3Or00rMQ8iQLotrEA2PmXhl+ykaf6L6q4l474hrSUH1JaYcv+iOMRWp2p6Tg=="],
+
+    "discord.js/undici": ["undici@6.24.1", "", {}, "sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA=="],
+
+    "dot-prop/is-obj": ["is-obj@2.0.0", "", {}, "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w=="],
+
+    "dprint-node/detect-libc": ["detect-libc@1.0.3", "", { "bin": { "detect-libc": "./bin/detect-libc.js" } }, "sha512-pGjwhsmsp4kL2RTz08wcOlGN83otlqHeD/Z5T8GXZB+/YcpQ/dgo+lbU8ZsGxV0HIvqqxo9l7mqYwyYMD9bKDg=="],
+
+    "duplexer2/readable-stream": ["readable-stream@2.3.8", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA=="],
+
+    "enquirer/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "eslint/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "eslint/ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "exceljs/archiver": ["archiver@5.3.2", "", { "dependencies": { "archiver-utils": "^2.1.0", "async": "^3.2.4", "buffer-crc32": "^0.2.1", "readable-stream": "^3.6.0", "readdir-glob": "^1.1.2", "tar-stream": "^2.2.0", "zip-stream": "^4.1.0" } }, "sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw=="],
+
+    "exceljs/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
+    "exceljs/uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="],
+
+    "execa/pretty-ms": ["pretty-ms@9.3.0", "", { "dependencies": { "parse-ms": "^4.0.0" } }, "sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ=="],
+
+    "extract-zip/get-stream": ["get-stream@5.2.0", "", { "dependencies": { "pump": "^3.0.0" } }, "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA=="],
+
+    "extract-zip/yauzl": ["yauzl@2.10.0", "", { "dependencies": { "buffer-crc32": "~0.2.3", "fd-slicer": "~1.1.0" } }, "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g=="],
+
+    "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+
+    "fetch-blob/web-streams-polyfill": ["web-streams-polyfill@3.3.3", "", {}, "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw=="],
+
+    "form-data/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
+
+    "fstream/rimraf": ["rimraf@2.7.1", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "./bin.js" } }, "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w=="],
+
+    "gauge/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "gauge/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "gaxios/node-fetch": ["node-fetch@3.3.2", "", { "dependencies": { "data-uri-to-buffer": "^4.0.0", "fetch-blob": "^3.1.4", "formdata-polyfill": "^4.0.10" } }, "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA=="],
+
+    "get-uri/data-uri-to-buffer": ["data-uri-to-buffer@6.0.2", "", {}, "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw=="],
+
+    "glob/minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "globby/@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@2.3.0", "", {}, "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg=="],
+
+    "googleapis-common/gaxios": ["gaxios@7.1.3", "", { "dependencies": { "extend": "^3.0.2", "https-proxy-agent": "^7.0.1", "node-fetch": "^3.3.2", "rimraf": "^5.0.1" } }, "sha512-YGGyuEdVIjqxkxVH1pUTMY/XtmmsApXrCVv5EU25iX6inEPbV+VakJfLealkBtJN69AQmh1eGOdCl9Sm1UP6XQ=="],
+
+    "googleapis-common/google-auth-library": ["google-auth-library@10.5.0", "", { "dependencies": { "base64-js": "^1.3.0", "ecdsa-sig-formatter": "^1.0.11", "gaxios": "^7.0.0", "gcp-metadata": "^8.0.0", "google-logging-utils": "^1.0.0", "gtoken": "^8.0.0", "jws": "^4.0.0" } }, "sha512-7ABviyMOlX5hIVD60YOfHw4/CxOfBhyduaYB+wbFWCWoni4N7SLcV46hrVRktuBbZjFC9ONyqamZITN7q3n32w=="],
+
+    "hast-to-hyperscript/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "hast-to-hyperscript/comma-separated-tokens": ["comma-separated-tokens@1.0.8", "", {}, "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw=="],
+
+    "hast-to-hyperscript/property-information": ["property-information@5.6.0", "", { "dependencies": { "xtend": "^4.0.0" } }, "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA=="],
+
+    "hast-to-hyperscript/space-separated-tokens": ["space-separated-tokens@1.1.5", "", {}, "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA=="],
+
+    "hast-to-hyperscript/style-to-object": ["style-to-object@0.3.0", "", { "dependencies": { "inline-style-parser": "0.1.1" } }, "sha512-CzFnRRXhzWIdItT3OmF8SQfWyahHhjq3HwcMNCNLn+N7klOOqPjMeG/4JSu77D7ypZdGvSzvkrbyeTMizz2VrA=="],
+
+    "hast-to-hyperscript/unist-util-is": ["unist-util-is@4.1.0", "", {}, "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg=="],
+
+    "hast-to-hyperscript/web-namespaces": ["web-namespaces@1.1.4", "", {}, "sha512-wYxSGajtmoP4WxfejAPIr4l0fVh+jeMXZb08wNc0tMg6xsfZXj3cECqIK0G7ZAqUq0PP8WlMDtaOGVBTAWztNw=="],
+
+    "htmlparser2/entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
+
+    "image-q/@types/node": ["@types/node@16.9.1", "", {}, "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g=="],
+
+    "is-wsl/is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
+
+    "istanbul-lib-report/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "jest-diff/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "jest-matcher-utils/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "jest-matcher-utils/jest-diff": ["jest-diff@29.7.0", "", { "dependencies": { "chalk": "^4.0.0", "diff-sequences": "^29.6.3", "jest-get-type": "^29.6.3", "pretty-format": "^29.7.0" } }, "sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw=="],
+
+    "jest-matcher-utils/pretty-format": ["pretty-format@29.7.0", "", { "dependencies": { "@jest/schemas": "^29.6.3", "ansi-styles": "^5.0.0", "react-is": "^18.0.0" } }, "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ=="],
+
+    "jest-message-util/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "jest-message-util/pretty-format": ["pretty-format@29.7.0", "", { "dependencies": { "@jest/schemas": "^29.6.3", "ansi-styles": "^5.0.0", "react-is": "^18.0.0" } }, "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ=="],
+
+    "jest-message-util/slash": ["slash@3.0.0", "", {}, "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="],
+
+    "jest-util/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "jest-util/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+
+    "jsdom/saxes": ["saxes@6.0.0", "", { "dependencies": { "xmlchars": "^2.2.0" } }, "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA=="],
+
+    "jszip/readable-stream": ["readable-stream@2.3.8", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA=="],
+
+    "katex/commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="],
+
+    "keytar/node-addon-api": ["node-addon-api@4.3.0", "", {}, "sha512-73sE9+3UaLYYFmDsFZnqCInzPyh3MqIwZO9cw58yIqAZhONrrabrYyYe3TuIqtIiOuTXVhsGau8hcrhhwSsDIQ=="],
+
+    "lazystream/readable-stream": ["readable-stream@2.3.8", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA=="],
+
+    "lightningcss/lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.32.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q=="],
+
+    "listr2/eventemitter3": ["eventemitter3@5.0.4", "", {}, "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw=="],
+
+    "log-symbols/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "log-symbols/is-unicode-supported": ["is-unicode-supported@0.1.0", "", {}, "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw=="],
+
+    "log-update/slice-ansi": ["slice-ansi@7.1.2", "", { "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" } }, "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w=="],
+
+    "loose-envify/js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
+
+    "lru-cache/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
+
+    "mammoth/argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="],
+
+    "markdown-it/linkify-it": ["linkify-it@5.0.2", "", { "dependencies": { "uc.micro": "^2.0.0" } }, "sha512-ONTm2jCMAVZjgQa/Fy1kScXsuOoF5NPTsoFBdE1KVIZ2vAh/r9+Bqo+0jINCBYnavTPQZz38QzFTme79ENoN3Q=="],
+
+    "markdown-it/uc.micro": ["uc.micro@2.1.0", "", {}, "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A=="],
+
+    "mdast-util-definitions/unist-util-visit": ["unist-util-visit@2.0.3", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^4.0.0", "unist-util-visit-parents": "^3.0.0" } }, "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q=="],
+
+    "mdast-util-find-and-replace/escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="],
+
+    "mermaid/marked": ["marked@16.4.2", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA=="],
+
+    "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+
+    "mocha/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "mocha/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "mocha/supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
+
+    "next/postcss": ["postcss@8.4.31", "", { "dependencies": { "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" } }, "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ=="],
+
+    "node-fetch/whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
+
+    "normalize-package-data/hosted-git-info": ["hosted-git-info@7.0.2", "", { "dependencies": { "lru-cache": "^10.0.1" } }, "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w=="],
+
+    "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
+
+    "onetime/mimic-fn": ["mimic-fn@2.1.0", "", {}, "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="],
+
+    "open-graph-scraper/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
+
+    "ora/cli-spinners": ["cli-spinners@2.9.2", "", {}, "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg=="],
+
+    "ora/log-symbols": ["log-symbols@6.0.0", "", { "dependencies": { "chalk": "^5.3.0", "is-unicode-supported": "^1.3.0" } }, "sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw=="],
+
+    "p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
+
+    "p-queue/p-timeout": ["p-timeout@3.2.0", "", { "dependencies": { "p-finally": "^1.0.0" } }, "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg=="],
+
+    "p-retry/retry": ["retry@0.13.1", "", {}, "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg=="],
+
+    "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "parse-semver/semver": ["semver@5.7.2", "", { "bin": { "semver": "bin/semver" } }, "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g=="],
+
+    "parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
+
+    "path-scurry/lru-cache": ["lru-cache@11.5.1", "", {}, "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A=="],
+
+    "pixelmatch/pngjs": ["pngjs@6.0.0", "", {}, "sha512-TRzzuFRRmEoSW/p1KVAmiOgPco2Irlah+bGFCeNfJXxxYGwSw7YwAOAcd7X28K/m5bjBWKsC29KyoMfHbypayg=="],
+
+    "pkg-up/find-up": ["find-up@3.0.0", "", { "dependencies": { "locate-path": "^3.0.0" } }, "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg=="],
+
+    "playwright/fsevents": ["fsevents@2.3.2", "", { "os": "darwin" }, "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA=="],
+
+    "postcss/nanoid": ["nanoid@3.3.15", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA=="],
+
+    "pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "prompts/kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="],
+
+    "prop-types/react-is": ["react-is@16.13.1", "", {}, "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="],
+
+    "proper-lockfile/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+
+    "proxy-agent/lru-cache": ["lru-cache@7.18.3", "", {}, "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA=="],
+
+    "proxy-agent/proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="],
+
+    "radix-ui/@radix-ui/primitive": ["@radix-ui/primitive@1.1.4", "", {}, "sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ=="],
+
+    "radix-ui/@radix-ui/react-accordion": ["@radix-ui/react-accordion@1.2.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collapsible": "1.1.15", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-24Zz/0SYx8F2bSVThBnQrdJs2VbKelyuJordcFRRdA0fRAhrq/wSegGCqaQz34VQoiWqSMGYCYXEhynLSlyQlg=="],
+
+    "radix-ui/@radix-ui/react-alert-dialog": ["@radix-ui/react-alert-dialog@1.1.18", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dialog": "1.1.18", "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-6c2cXpNlAgHDhKguK24XcWHHayMpK+lk7/WwBXBco+ZJ4Dv7xP++GBM280KgTD/HCRu3jSdfe8WQiZssonYaIA=="],
+
+    "radix-ui/@radix-ui/react-aspect-ratio": ["@radix-ui/react-aspect-ratio@1.1.11", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-IUAhIVpBUvP5NNICjlaB1OFmtRLGqQqTF3ZOSGPoq3XeLXRFtHiWTRxSVEULgOd9GQR2c7tsYqDnhUennapZnw=="],
+
+    "radix-ui/@radix-ui/react-avatar": ["@radix-ui/react-avatar@1.2.1", "", { "dependencies": { "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-is-hydrated": "0.1.1", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-+8PWoLLZv3AVb5m0pvoiOca/bQGzc9vPVb+982HB2x3Un0DpYEPM3zLMl4oqRpBsocJuNqLkiv/HXTnTrlwr4g=="],
+
+    "radix-ui/@radix-ui/react-checkbox": ["@radix-ui/react-checkbox@1.3.6", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-previous": "1.1.2", "@radix-ui/react-use-size": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-eUEUoGMDpfkgHWSE97ZZaUJtzR1M7EKnNIpD1Q16+8JR9NWghcaqMulx9PuCQ720w0UclfYn6FEbCdd5Hx087g=="],
+
+    "radix-ui/@radix-ui/react-collapsible": ["@radix-ui/react-collapsible@1.1.15", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-8A1zibu5skAQ+UVbaeNH5hVMibiFCRJzgMuM14LTWGttnTZKQL9jwYnhAbHRuxrtCqPXa4JvvnVUq1pTNgyZYw=="],
+
+    "radix-ui/@radix-ui/react-collection": ["@radix-ui/react-collection@1.1.11", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-djW9+zeg137KQdlPtmE8xnaD+K2rcXXMWFrSg0hsmYZ6HRbdTA7tDHFgpaW9+huWVEu0RCabL+985T4TA0BE7g=="],
+
+    "radix-ui/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "radix-ui/@radix-ui/react-context": ["@radix-ui/react-context@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg=="],
+
+    "radix-ui/@radix-ui/react-context-menu": ["@radix-ui/react-context-menu@2.3.2", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-menu": "2.1.19", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-qzsA/ZPhF6yMxBOTIk1nlCkoy2mswSbwYL+ErBa2iP0s4WWrlxmczArYqMcpVfEjmM7KJj/ADPXky0yZfbSxtQ=="],
+
+    "radix-ui/@radix-ui/react-dialog": ["@radix-ui/react-dialog@1.1.18", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-focus-guards": "1.1.4", "@radix-ui/react-focus-scope": "1.1.11", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-use-controllable-state": "1.2.3", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.7.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-apa28mldjMgORmE6g/w3sCcA0Y9UAVeeDVoozN4i7kOw12mLl9RBchfzK3Nn6qxOWjrZhK1Lfy7f07kyzxtnBw=="],
+
+    "radix-ui/@radix-ui/react-direction": ["@radix-ui/react-direction@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-C3vFhbyi4SW3PmbAi6Awpu4OzJtd0MxGurvSsYtr7p7nM8RNB3VAF3CUmnp2j50knpkrRcB7+ycVXzgLgF6yNA=="],
+
+    "radix-ui/@radix-ui/react-dismissable-layer": ["@radix-ui/react-dismissable-layer@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-effect-event": "0.0.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-4lUhWTWAjbDIqFrAPWJ3WqBOpO5YchVZ88X3nh6H9Lu5AFi5nCUeTPj3D8FSDmabmFeRe9ME0BDA4MwKTha5GQ=="],
+
+    "radix-ui/@radix-ui/react-dropdown-menu": ["@radix-ui/react-dropdown-menu@2.1.19", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-menu": "2.1.19", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-HZccBkbK0LOi8nYKIp5jll/zIRW0cCOmG6WWyqsSpmXCU+ZlcBbTqIwlBvPCu886C5RVu6c/kHV7xSP8IgYNHw=="],
+
+    "radix-ui/@radix-ui/react-focus-guards": ["@radix-ui/react-focus-guards@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-cot/aB/mOm0IYVYTTmQcEEK1M48lZWi8FlYe5nDPQQ8NYZUlXEFgncJ9p2Kzer3RKSrY7cTTpEMLZKNo9QoP5Q=="],
+
+    "radix-ui/@radix-ui/react-focus-scope": ["@radix-ui/react-focus-scope@1.1.11", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Mn88Vg2whaRocGJNOH+DKFqYm6ySFPQaiwHNxZPyjn99B52KAEJWWY9NP83+nWdk2HM3rdov+STu9AG471Rt9w=="],
+
+    "radix-ui/@radix-ui/react-hover-card": ["@radix-ui/react-hover-card@1.1.18", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-popper": "1.3.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-rt+Fx4HoCeEwFL2IdoV2QaPltqDLlzxN77i9nwB3Y70scFlfAHh1QCdE2TXKuFJtA1TNygb0oivnFBZifgtZOw=="],
+
+    "radix-ui/@radix-ui/react-label": ["@radix-ui/react-label@2.1.11", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-3PKvDDxOn62k0oV1n4QtNtD2vpu+zYjXR7ojLBPaO6SPvhy53yg0vAmgNeBQeJW5rV3dffoRG+HYfLBZuzw0CQ=="],
+
+    "radix-ui/@radix-ui/react-menu": ["@radix-ui/react-menu@2.1.19", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-focus-guards": "1.1.4", "@radix-ui/react-focus-scope": "1.1.11", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-popper": "1.3.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-use-callback-ref": "1.1.2", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.7.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Mht9BVd1AIsNFVQr4KG3bIK7XQn5IXF0TL/2ObsrzOdc1loaly/+kBDL5roSCYn8j8XZkvpOD0WYLz2FQtH1Eg=="],
+
+    "radix-ui/@radix-ui/react-menubar": ["@radix-ui/react-menubar@1.1.19", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-menu": "2.1.19", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Glt6mebxcgQvLeVkH3HiqV5bgQubE+31ELxLs7q0GlYI5k0XYkOkeuPrhXoylxK8eufvIt9CJjzY1TfFMXK3qw=="],
+
+    "radix-ui/@radix-ui/react-navigation-menu": ["@radix-ui/react-navigation-menu@1.2.17", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-layout-effect": "1.1.2", "@radix-ui/react-use-previous": "1.1.2", "@radix-ui/react-visually-hidden": "1.2.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-fYeYQvbeNn5AQk2RBbpO7koLm2YbS00UYxC/IL2sgLlninEH5UNIv+X3E0KJ1Vy4WIo+dhN9w8GNqSHhbHWCIg=="],
+
+    "radix-ui/@radix-ui/react-popover": ["@radix-ui/react-popover@1.1.18", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-focus-guards": "1.1.4", "@radix-ui/react-focus-scope": "1.1.11", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-popper": "1.3.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-use-controllable-state": "1.2.3", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.7.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-qdXDes+eHlnMUGlBAAAe5EG7oOQvqsXuq4mq585diMudg80iB+jHbsSeG3+Q4eWNsogNyhqU2p/3i+Y0iEepqg=="],
+
+    "radix-ui/@radix-ui/react-popper": ["@radix-ui/react-popper@1.3.2", "", { "dependencies": { "@floating-ui/react-dom": "^2.0.0", "@radix-ui/react-arrow": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-layout-effect": "1.1.2", "@radix-ui/react-use-rect": "1.1.2", "@radix-ui/react-use-size": "1.1.2", "@radix-ui/rect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-3QXNeMkdshed1MR3LNoiCirBywRFPkD8ETJa/HlPuLwSajaQixf2ro+isoDNJlGABg9ug41XuZpINZJIle4XWg=="],
+
+    "radix-ui/@radix-ui/react-portal": ["@radix-ui/react-portal@1.1.13", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-z3oXfmaHLJTF1wktbjgD6cn9jiEbq3WSondB10LIuIt2m2Ym4iJlrW04/euMwENDdWDdE7z+OuY7Qyp1YpRSwA=="],
+
+    "radix-ui/@radix-ui/react-presence": ["@radix-ui/react-presence@1.1.6", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-zdTk4PlUO0E18HnZ3wYbW0KkJJxWCdiNYp6g6X1PtONFhxVkg01vliTJAmwIszU6mHiyBOoW9P0rAugl5/hULQ=="],
+
+    "radix-ui/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "radix-ui/@radix-ui/react-progress": ["@radix-ui/react-progress@1.1.11", "", { "dependencies": { "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-KqiGJcFaZDc+BvveAgU3ZhACg2MvSUDrCBx4lRR/ZVRNal0bvt8lBpvnSkep9heeOuF8Qfw3fszLDX4OpQ2NVw=="],
+
+    "radix-ui/@radix-ui/react-radio-group": ["@radix-ui/react-radio-group@1.4.2", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-previous": "1.1.2", "@radix-ui/react-use-size": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-W8Uo9riHnlzLLWy+r2mVHUyuEWqD/+be4PZzbEvaGoFSBDHkm+GYWjtcE6u3AmPKNyfanWpnVfpZ2GqPCdzzsw=="],
+
+    "radix-ui/@radix-ui/react-roving-focus": ["@radix-ui/react-roving-focus@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-8Qcnx9447tx/aCBgw6Jenfqg4Skq+vqab9mCBmuGNipIS5YXvL275wbKEu7+ICYHIlAPgCduUMJH1XOYewKF6Q=="],
+
+    "radix-ui/@radix-ui/react-scroll-area": ["@radix-ui/react-scroll-area@1.2.13", "", { "dependencies": { "@radix-ui/number": "1.1.2", "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-7tncSubo2G0UY1e8rk+72qe3XRzrGnOLtZQ1PL1KoBfRUNX0NrJT5akb+0kfwSCc3gVR4wdHqyhAQBDpDNOwDw=="],
+
+    "radix-ui/@radix-ui/react-select": ["@radix-ui/react-select@2.3.2", "", { "dependencies": { "@radix-ui/number": "1.1.2", "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-focus-guards": "1.1.4", "@radix-ui/react-focus-scope": "1.1.11", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-popper": "1.3.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-layout-effect": "1.1.2", "@radix-ui/react-use-previous": "1.1.2", "@radix-ui/react-visually-hidden": "1.2.7", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.7.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-brXD6C/V0fVK0DDbscLVw6LsXrjQ+ay8jdOBaN+tLb4vsHsAMm6Gt6eT77wHX1Eq8GPtD5rJ+RxFtfDozsb4+Q=="],
+
+    "radix-ui/@radix-ui/react-separator": ["@radix-ui/react-separator@1.1.11", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-jRhe86+8PF7VZ1u14eOWVOuh2BuAhALg/FT1VcMC4OHedMTRUazDnDlKTt+yxo5cRNKHMfmvZ4sSQtWDeMV4CQ=="],
+
+    "radix-ui/@radix-ui/react-slider": ["@radix-ui/react-slider@1.4.2", "", { "dependencies": { "@radix-ui/number": "1.1.2", "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-layout-effect": "1.1.2", "@radix-ui/react-use-previous": "1.1.2", "@radix-ui/react-use-size": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-qt5C1ppJz66aUDrH1VccjPrq7aFchK0wBrn6xsxlCHNUyE57dRRQ7lp1QFpF7OscMexZF8MCGBTVBlENHPkNiA=="],
+
+    "radix-ui/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "radix-ui/@radix-ui/react-switch": ["@radix-ui/react-switch@1.3.2", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-previous": "1.1.2", "@radix-ui/react-use-size": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-tgRBI3DdNwAJYE4BBZyZcz/HRRCvAsPkRvG1wvKc+41tBGMxPn/a87T/wikXAvyDypNQ9kaZwHbeZe+veHCGpA=="],
+
+    "radix-ui/@radix-ui/react-tabs": ["@radix-ui/react-tabs@1.1.16", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-v3Ab2l7z6U7tRB4xA0IyKdq0OsqaO1o9ZjsIEoKKnSZ/l96mZz8aCTX0NCXw+YVHJXr8Km4d+Mn6/Q8YjXa+gw=="],
+
+    "radix-ui/@radix-ui/react-toast": ["@radix-ui/react-toast@1.2.18", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-collection": "1.1.11", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-use-layout-effect": "1.1.2", "@radix-ui/react-visually-hidden": "1.2.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-YNEnTHV47hPep+U0QvVM02OJNka9uygREc+k4Nh5VSZBg4MmE+myI442x3hCGfRpX7N2WSSYSJKws4gE+Z8lgg=="],
+
+    "radix-ui/@radix-ui/react-toggle": ["@radix-ui/react-toggle@1.1.13", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bI2ILJrzwgmAsH05TsJ9pVrzqQwAip7OM2/krqAdYn0R16bl86UPWbe5VPHsALat0EnqpV01cGtkleaUKPNdNg=="],
+
+    "radix-ui/@radix-ui/react-toggle-group": ["@radix-ui/react-toggle-group@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-direction": "1.1.2", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-roving-focus": "1.1.14", "@radix-ui/react-toggle": "1.1.13", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-TK1vusNKb8IRhF23FTbRgUNZ9zfs5rGIyI7LfR3h26p9LrQ060i0uW9QWeD8baZMddaaP0DBGlIa6pbZG+mitg=="],
+
+    "radix-ui/@radix-ui/react-tooltip": ["@radix-ui/react-tooltip@1.2.11", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-popper": "1.3.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-use-controllable-state": "1.2.3", "@radix-ui/react-visually-hidden": "1.2.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-8XZ6Py3y3W2nEzAUGCN5cfVKaUi+CVApcz1d6lrNVVf2hvYEixMRkq8k9ggPKnQUpRRuOV5avt8uvxViH2jLwA=="],
+
+    "radix-ui/@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw=="],
+
+    "radix-ui/@radix-ui/react-use-is-hydrated": ["@radix-ui/react-use-is-hydrated@0.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-qwOiz4Tjo8CNnrOLAYUMXeZwDzXgXpvK4TKQPmWLECM9XoWvA6+0Z2/7Ag3A4ivjS4ovbLJPbskkxioFyBhr8A=="],
+
+    "radix-ui/@radix-ui/react-use-size": ["@radix-ui/react-use-size@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-giWQp+4mxjBPt4KZ0MmyuykFNWfbDxKt4x+fPkRYmgRFJSbCZFzUglvMb/Kjn38tm10YP4ufiQZDx3zna4LU6w=="],
+
+    "radix-ui/@radix-ui/react-visually-hidden": ["@radix-ui/react-visually-hidden@1.2.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-1wNZBggTDK3GRuuQ6nP4k2yi7a6l7I5qbMPbZcRsrGsGVead/f/d5FhEzUvqFs0bcrDLx7n1zKQ3JvLR6whaaw=="],
+
+    "raw-body/iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
+
+    "rc/strip-json-comments": ["strip-json-comments@2.0.1", "", {}, "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ=="],
+
+    "react-aria/@internationalized/date": ["@internationalized/date@3.12.2", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw=="],
+
+    "react-aria/@react-types/shared": ["@react-types/shared@3.36.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-DkP/H0C2YjjS7gZWKNqOmU8a16qHPjQNdzMwmTq9SzplM6Iw0kVMTZ0OIoe6FOgGqa+FwMsE2QbPjh/n3g/jXQ=="],
+
+    "react-aria-components/@internationalized/date": ["@internationalized/date@3.12.2", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw=="],
+
+    "react-aria-components/@react-types/shared": ["@react-types/shared@3.36.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-DkP/H0C2YjjS7gZWKNqOmU8a16qHPjQNdzMwmTq9SzplM6Iw0kVMTZ0OIoe6FOgGqa+FwMsE2QbPjh/n3g/jXQ=="],
+
+    "react-devtools-core/ws": ["ws@7.5.11", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": "^5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-zS54Oen9bITtp7kp2XM3AydrCIq1D+HwJOuH+c+e4LfpL/lotP5osijd+UoMnxwAam1GN8R4KtLAyIrIcBNpiA=="],
+
+    "react-dom/scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
+
+    "react-jsx-parser/@types/react": ["@types/react@18.3.31", "", { "dependencies": { "@types/prop-types": "*", "csstype": "^3.2.2" } }, "sha512-vfEqpXTvwT91yhmwdfouStN2hSKwTvyRs8qpLfADyrq/kxDw0hZM7Wk9Ug1FELj8hIby+S/+kQCSRFF32nv2Qw=="],
+
+    "react-jsx-parser/@types/react-dom": ["@types/react-dom@18.3.7", "", { "peerDependencies": { "@types/react": "^18.0.0" } }, "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ=="],
+
+    "react-remark/remark-parse": ["remark-parse@9.0.0", "", { "dependencies": { "mdast-util-from-markdown": "^0.8.0" } }, "sha512-geKatMwSzEXKHuzBNU1z676sGcDcFoChMK38TgdHJNAYfFtsfHDQG7MoJAjs6sgYMqyLduCYWDIWZIxiPeafEw=="],
+
+    "react-remark/remark-rehype": ["remark-rehype@8.1.0", "", { "dependencies": { "mdast-util-to-hast": "^10.2.0" } }, "sha512-EbCu9kHgAxKmW1yEYjx3QafMyGY3q8noUbNUI5xyKbaFP89wbhDrKxyIQNukNYthzjNHZu6J7hwFg7hRm1svYA=="],
+
+    "react-remark/unified": ["unified@9.2.2", "", { "dependencies": { "bail": "^1.0.0", "extend": "^3.0.0", "is-buffer": "^2.0.0", "is-plain-obj": "^2.0.0", "trough": "^1.0.0", "vfile": "^4.0.0" } }, "sha512-Sg7j110mtefBD+qunSLO1lqOEKdrwBFBrR6Qd8f4uwkhWNlbkaqwHse6e7QvD3AP/MNoJdEDLaf8OxYyoWgorQ=="],
+
+    "react-stately/@internationalized/date": ["@internationalized/date@3.12.2", "", { "dependencies": { "@swc/helpers": "^0.5.0" } }, "sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw=="],
+
+    "react-stately/@react-types/shared": ["@react-types/shared@3.36.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-DkP/H0C2YjjS7gZWKNqOmU8a16qHPjQNdzMwmTq9SzplM6Iw0kVMTZ0OIoe6FOgGqa+FwMsE2QbPjh/n3g/jXQ=="],
+
+    "read-pkg/parse-json": ["parse-json@8.3.0", "", { "dependencies": { "@babel/code-frame": "^7.26.2", "index-to-position": "^1.1.0", "type-fest": "^4.39.1" } }, "sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ=="],
+
+    "read-pkg/type-fest": ["type-fest@4.41.0", "", {}, "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA=="],
+
+    "read-pkg/unicorn-magic": ["unicorn-magic@0.1.0", "", {}, "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ=="],
+
+    "readdir-glob/minimatch": ["minimatch@5.1.9", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw=="],
+
+    "redent/strip-indent": ["strip-indent@3.0.0", "", { "dependencies": { "min-indent": "^1.0.0" } }, "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ=="],
+
+    "restore-cursor/onetime": ["onetime@7.0.0", "", { "dependencies": { "mimic-function": "^5.0.0" } }, "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ=="],
+
+    "rimraf/glob": ["glob@13.0.6", "", { "dependencies": { "minimatch": "^10.2.2", "minipass": "^7.1.3", "path-scurry": "^2.0.2" } }, "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw=="],
+
+    "shadcn/open": ["open@11.0.0", "", { "dependencies": { "default-browser": "^5.4.0", "define-lazy-prop": "^3.0.0", "is-in-ssh": "^1.0.0", "is-inside-container": "^1.0.0", "powershell-utils": "^0.1.0", "wsl-utils": "^0.3.0" } }, "sha512-smsWv2LzFjP03xmvFoJ331ss6h+jixfA4UUV/Bsiyuu4YJPfN+FIQGOIiv4w9/+MoHkfkJ22UIaQWRVFRfH6Vw=="],
+
+    "shadcn/ts-morph": ["ts-morph@26.0.0", "", { "dependencies": { "@ts-morph/common": "~0.27.0", "code-block-writer": "^13.0.3" } }, "sha512-ztMO++owQnz8c/gIENcM9XfCEzgoGphTv+nKpYNM1bgsdOVC/jRZuEBf6N+mLLDNg68Kl+GgUZfOySaRiG1/Ug=="],
+
+    "shadcn/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "simple-swizzle/is-arrayish": ["is-arrayish@0.3.4", "", {}, "sha512-m6UrgzFVUYawGBh1dUsWR5M2Clqic9RVXC/9f8ceNlv2IcO9j9J/z8UoCLPqtsPBFNzEpfR3xftohbfqDx8EQA=="],
+
+    "slice-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "slice-ansi/is-fullwidth-code-point": ["is-fullwidth-code-point@5.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.1" } }, "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ=="],
+
+    "stack-utils/escape-string-regexp": ["escape-string-regexp@2.0.0", "", {}, "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w=="],
+
+    "stacktrace-gps/source-map": ["source-map@0.5.6", "", {}, "sha512-MjZkVp0NHr5+TPihLcadqnlVoGIoWo4IBHptutGh9wI3ttUYvCG26HkSuDi+K6lsZ25syXJXcctwgyVCt//xqA=="],
+
+    "storybook/@vitest/expect": ["@vitest/expect@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig=="],
+
+    "storybook/@vitest/mocker": ["@vitest/mocker@3.2.4", "", { "dependencies": { "@vitest/spy": "3.2.4", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ=="],
+
+    "storybook/@vitest/spy": ["@vitest/spy@3.2.4", "", { "dependencies": { "tinyspy": "^4.0.3" } }, "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw=="],
+
+    "storybook/esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="],
+
+    "streamdown/marked": ["marked@17.0.6", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-gB0gkNafnonOw0obSTEGZTT86IuhILt2Wfx0mWH/1Au83kybTayroZ/V6nS25mN7u8ASy+5fMhgB3XPNrOZdmA=="],
+
+    "string-width-cjs/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "string-width-cjs/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "strip-ansi-cjs/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "strip-literal/js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="],
+
+    "styled-components/stylis": ["stylis@4.3.6", "", {}, "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ=="],
+
+    "supports-hyperlinks/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "table/ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="],
+
+    "table/slice-ansi": ["slice-ansi@4.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "astral-regex": "^2.0.0", "is-fullwidth-code-point": "^3.0.0" } }, "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ=="],
+
+    "table/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "table/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "test-exclude/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "test-exclude/minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "thread-stream/real-require": ["real-require@1.0.0", "", {}, "sha512-P4nbQYQfePJxRSmY+v/KINxVucm4NF3p3s7pJveMTtom52FR4YGltUQLB8idDXwDDWW+eYrWDFbuzUnjoWHF7g=="],
+
+    "type-is/content-type": ["content-type@2.0.0", "", {}, "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ=="],
+
+    "unbzip2-stream/buffer": ["buffer@5.7.1", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.1.13" } }, "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ=="],
+
+    "unzipper/readable-stream": ["readable-stream@2.3.8", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA=="],
+
+    "vaul/@radix-ui/react-dialog": ["@radix-ui/react-dialog@1.1.18", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-dismissable-layer": "1.1.14", "@radix-ui/react-focus-guards": "1.1.4", "@radix-ui/react-focus-scope": "1.1.11", "@radix-ui/react-id": "1.1.2", "@radix-ui/react-portal": "1.1.13", "@radix-ui/react-presence": "1.1.6", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0", "@radix-ui/react-use-controllable-state": "1.2.3", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.7.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-apa28mldjMgORmE6g/w3sCcA0Y9UAVeeDVoozN4i7kOw12mLl9RBchfzK3Nn6qxOWjrZhK1Lfy7f07kyzxtnBw=="],
+
+    "verror/core-util-is": ["core-util-is@1.0.2", "", {}, "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ=="],
+
+    "vite-node/es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="],
+
+    "vite-node/vite": ["vite@7.3.6", "", { "dependencies": { "esbuild": "^0.27.0 || ^0.28.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg=="],
+
+    "webview/@types/node": ["@types/node@24.13.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-fRa09kZTgu8o71KFcDjUFuc7F+dEbZYZmkI0mg5YBTRs0yMKjYHsq/c0urDKeDb+D5qVgXOdFcuu+DZPKOITwA=="],
+
+    "webview-ui/@types/node": ["@types/node@22.20.0", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-QWlFW2wf3nTjC13/DqRnBpR4ZO36VJH/JVBkA/vcnmbTBNQIlnObqyqZE1tUR7+Ni23Lda8R1BxMfbXRpCUx5g=="],
+
+    "webview-ui/@types/react": ["@types/react@18.3.31", "", { "dependencies": { "@types/prop-types": "*", "csstype": "^3.2.2" } }, "sha512-vfEqpXTvwT91yhmwdfouStN2hSKwTvyRs8qpLfADyrq/kxDw0hZM7Wk9Ug1FELj8hIby+S/+kQCSRFF32nv2Qw=="],
+
+    "webview-ui/@types/react-dom": ["@types/react-dom@18.3.7", "", { "peerDependencies": { "@types/react": "^18.0.0" } }, "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ=="],
+
+    "webview-ui/@types/uuid": ["@types/uuid@9.0.8", "", {}, "sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA=="],
+
+    "webview-ui/@vitejs/plugin-react-swc": ["@vitejs/plugin-react-swc@3.11.0", "", { "dependencies": { "@rolldown/pluginutils": "1.0.0-beta.27", "@swc/core": "^1.12.11" }, "peerDependencies": { "vite": "^4 || ^5 || ^6 || ^7" } }, "sha512-YTJCGFdNMHCMfjODYtxRNVAYmTWQ1Lb8PulP/2/f/oEEtglw8oKxKIZmmRkyXrVrHfsKOaVkAc3NT9/dMutO5w=="],
+
+    "webview-ui/globals": ["globals@15.15.0", "", {}, "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg=="],
+
+    "webview-ui/lucide-react": ["lucide-react@0.511.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-VK5a2ydJ7xm8GvBeKLS9mu1pVK6ucef9780JVUjw6bAjJL/QXnd4Y0p7SPeOUMC27YhzNCZvm5d/QX0Tp3rc0w=="],
+
+    "webview-ui/mermaid": ["mermaid@11.12.3", "", { "dependencies": { "@braintree/sanitize-url": "^7.1.1", "@iconify/utils": "^3.0.1", "@mermaid-js/parser": "^1.0.0", "@types/d3": "^7.4.3", "cytoscape": "^3.29.3", "cytoscape-cose-bilkent": "^4.1.0", "cytoscape-fcose": "^2.2.0", "d3": "^7.9.0", "d3-sankey": "^0.12.3", "dagre-d3-es": "7.0.13", "dayjs": "^1.11.18", "dompurify": "^3.2.5", "katex": "^0.16.22", "khroma": "^2.1.0", "lodash-es": "^4.17.23", "marked": "^16.2.1", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0" } }, "sha512-wN5ZSgJQIC+CHJut9xaKWsknLxaFBwCPwPkGTSUYrTiHORWvpT8RxGk849HPnpUAQ+/9BPRqYb80jTpearrHzQ=="],
+
+    "webview-ui/react": ["react@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ=="],
+
+    "webview-ui/react-dom": ["react-dom@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0", "scheduler": "^0.23.2" }, "peerDependencies": { "react": "^18.3.1" } }, "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw=="],
+
+    "webview-ui/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
+
+    "webview-ui/vite": ["vite@7.3.6", "", { "dependencies": { "esbuild": "^0.27.0 || ^0.28.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg=="],
+
+    "webview-ui/vitest": ["vitest@3.2.6", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/expect": "3.2.6", "@vitest/mocker": "3.2.6", "@vitest/pretty-format": "^3.2.6", "@vitest/runner": "3.2.6", "@vitest/snapshot": "3.2.6", "@vitest/spy": "3.2.6", "@vitest/utils": "3.2.6", "chai": "^5.2.0", "debug": "^4.4.1", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "picomatch": "^4.0.2", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.14", "tinypool": "^1.1.1", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", "vite-node": "3.2.4", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.2.6", "@vitest/ui": "3.2.6", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-xejya+bT/j/+R/AGa1XOfRxLmNUlLtlwjRsFUILF+xHfzElmGcmFydy2gqqIrd62ptIEfwVMofd19uNWD9L7Nw=="],
+
+    "wide-align/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "windows-release/execa": ["execa@8.0.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^8.0.1", "human-signals": "^5.0.0", "is-stream": "^3.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^5.1.0", "onetime": "^6.0.0", "signal-exit": "^4.1.0", "strip-final-newline": "^3.0.0" } }, "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg=="],
+
+    "winston/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
+
+    "winston/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
+    "winston-transport/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
+    "wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "wrap-ansi-cjs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "wrap-ansi-cjs/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "wsl-utils/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
+
+    "xml2js/xmlbuilder": ["xmlbuilder@11.0.1", "", {}, "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA=="],
+
+    "yargs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "yargs-unparser/is-plain-obj": ["is-plain-obj@2.1.0", "", {}, "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA=="],
+
+    "yazl/buffer-crc32": ["buffer-crc32@0.2.13", "", {}, "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="],
+
+    "@anthropic-ai/sdk/@types/node/undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
+
+    "@babel/helper-compilation-targets/lru-cache/yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
+
+    "@cline/cline-hub-webview/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
+    "@dotenvx/dotenvx/execa/get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="],
+
+    "@dotenvx/dotenvx/execa/human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="],
+
+    "@dotenvx/dotenvx/execa/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
+
+    "@dotenvx/dotenvx/execa/npm-run-path": ["npm-run-path@4.0.1", "", { "dependencies": { "path-key": "^3.0.0" } }, "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw=="],
+
+    "@dotenvx/dotenvx/execa/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+
+    "@dotenvx/dotenvx/execa/strip-final-newline": ["strip-final-newline@2.0.0", "", {}, "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA=="],
+
+    "@dotenvx/dotenvx/open/define-lazy-prop": ["define-lazy-prop@2.0.0", "", {}, "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="],
+
+    "@dotenvx/dotenvx/open/is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
+
+    "@jest/types/@jest/schemas/@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
+
+    "@jest/types/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "@mapbox/hast-util-table-cell-style/unist-util-visit/unist-util-visit-parents": ["unist-util-visit-parents@2.1.2", "", { "dependencies": { "unist-util-is": "^3.0.0" } }, "sha512-DyN5vD4NE3aSeB+PXYNKxzGsfocxp6asDc2XXE3b0ekO2BaRUpBicbbUygfSvYfUz1IkmjFR1YF7dPklraMZ2g=="],
+
+    "@microsoft/tui-test/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "@microsoft/tui-test/glob/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "@microsoft/tui-test/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "@microsoft/tui-test/jest-diff/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "@microsoft/tui-test/jest-diff/pretty-format": ["pretty-format@29.7.0", "", { "dependencies": { "@jest/schemas": "^29.6.3", "ansi-styles": "^5.0.0", "react-is": "^18.0.0" } }, "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ=="],
+
+    "@modelcontextprotocol/sdk/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/sdk-logs/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/sdk-logs/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-prometheus/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-prometheus/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wr39+94UNNG3Ei9nv3pHd4AJ63gq5nSemMRpCd8fPwDL9rN3vK26lzxfH27mw16XzOSO+TpyQwBAMaLxaPWG0g=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-OS0WPBJF++R/cSl+terUjQH5PebloidB1Jbbecgg2rnCmQbTST9xsRes23bLfDQVRvmegmHqDh884h0aRdJyLw=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "@opentelemetry/propagator-b3/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/propagator-jaeger/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-trace-node/@opentelemetry/context-async-hooks": ["@opentelemetry/context-async-hooks@1.29.0", "", { "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-TKT91jcFXgHyIDF1lgJF3BHGIakn6x0Xp7Tq3zoS3TMPzT9IlP0xEavWP8C1zGjU9UmZP2VR1tJhW9Az1A3w8Q=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-trace-node/@opentelemetry/propagator-b3": ["@opentelemetry/propagator-b3@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-ktsNDlqhu+/IPGEJRMj81upg2JupUp+SwW3n1ZVZTnrDiYUiMUW41vhaziA7Q6UDhbZvZ58skDpQhe2ZgNIPvg=="],
+
+    "@opentelemetry/sdk-node/@opentelemetry/sdk-trace-node/@opentelemetry/propagator-jaeger": ["@opentelemetry/propagator-jaeger@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-EXIEYmFgybnFMijVgqx1mq/diWwSQcd0JWVksytAVQEnAiaDvP45WuncEVQkFIAC0gVxa2+Xr8wL5pF5jCVKbg=="],
+
+    "@radix-ui/react-accessible-icon/@radix-ui/react-visually-hidden/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "@radix-ui/react-accordion/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-accordion/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-accordion/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-arrow/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-checkbox/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-checkbox/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-checkbox/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-collapsible/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-collapsible/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-context-menu/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-context-menu/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-context-menu/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-dialog/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-dialog/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-dismissable-layer/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-dropdown-menu/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-dropdown-menu/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-dropdown-menu/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-focus-scope/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-form/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-hover-card/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-hover-card/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-hover-card/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-menubar/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-menubar/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-menubar/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-navigation-menu/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-navigation-menu/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-collection/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-roving-focus/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "@radix-ui/react-one-time-password-field/@radix-ui/react-roving-focus/@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw=="],
+
+    "@radix-ui/react-password-toggle-field/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-popover/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-popover/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-popper/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-portal/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-radio-group/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-radio-group/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-radio-group/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-roving-focus/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-roving-focus/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-roving-focus/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-scroll-area/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-select/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-slider/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-slider/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-switch/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-switch/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-switch/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-tabs/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-tabs/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-tabs/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-toast/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-toast/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-toggle-group/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-toggle-group/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-toggle-group/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-toggle/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-toggle/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-toggle/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-roving-focus/@radix-ui/react-collection": ["@radix-ui/react-collection@1.1.11", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-context": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-djW9+zeg137KQdlPtmE8xnaD+K2rcXXMWFrSg0hsmYZ6HRbdTA7tDHFgpaW9+huWVEu0RCabL+985T4TA0BE7g=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-roving-focus/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-roving-focus/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-roving-focus/@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-toggle-group/@radix-ui/react-toggle": ["@radix-ui/react-toggle@1.1.13", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-controllable-state": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bI2ILJrzwgmAsH05TsJ9pVrzqQwAip7OM2/krqAdYn0R16bl86UPWbe5VPHsALat0EnqpV01cGtkleaUKPNdNg=="],
+
+    "@radix-ui/react-tooltip/@radix-ui/react-use-controllable-state/@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-tooltip/@radix-ui/react-use-controllable-state/@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-visually-hidden/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@react-types/slider/@react-aria/slider/@react-types/shared": ["@react-types/shared@3.36.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-DkP/H0C2YjjS7gZWKNqOmU8a16qHPjQNdzMwmTq9SzplM6Iw0kVMTZ0OIoe6FOgGqa+FwMsE2QbPjh/n3g/jXQ=="],
+
+    "@react-types/tabs/@react-aria/tabs/@react-types/shared": ["@react-types/shared@3.36.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1" } }, "sha512-DkP/H0C2YjjS7gZWKNqOmU8a16qHPjQNdzMwmTq9SzplM6Iw0kVMTZ0OIoe6FOgGqa+FwMsE2QbPjh/n3g/jXQ=="],
+
+    "@secretlint/config-loader/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
+
+    "@so-ric/colorspace/color/color-convert": ["color-convert@3.1.3", "", { "dependencies": { "color-name": "^2.0.0" } }, "sha512-fasDH2ont2GqF5HpyO4w0+BcewlhHEZOFn9c1ckZdHpJ56Qb7MHhH/IcJZbBGgvdtwdwNbLvxiBEdg336iA9Sg=="],
+
+    "@so-ric/colorspace/color/color-string": ["color-string@2.1.4", "", { "dependencies": { "color-name": "^2.0.0" } }, "sha512-Bb6Cq8oq0IjDOe8wJmi4JeNn763Xs9cfrBcaylK1tPypWzyoy2G3l90v9k64kjphl/ZJjPIShFztenRomi8WTg=="],
+
+    "@storybook/react-vite/find-up/locate-path": ["locate-path@7.2.0", "", { "dependencies": { "p-locate": "^6.0.0" } }, "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA=="],
+
+    "@storybook/react-vite/find-up/path-exists": ["path-exists@5.0.0", "", {}, "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ=="],
+
+    "@storybook/react-vite/find-up/unicorn-magic": ["unicorn-magic@0.1.0", "", {}, "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ=="],
+
+    "@streamdown/code/shiki/@shikijs/core": ["@shikijs/core@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.5" } }, "sha512-NSWQz0riNb67xthdm5br6lAkvpDJRTgB36fxlo37ZzM2yq0PQFFzbd8psqC2XMPgCzo1fW6cVi18+ArJ44wqgA=="],
+
+    "@streamdown/code/shiki/@shikijs/engine-javascript": ["@shikijs/engine-javascript@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2", "oniguruma-to-es": "^4.3.4" } }, "sha512-aHt9eiGFobmWR5uqJUViySI1bHMqrAgamWE1TYSUoftkAeCCAiGawPMwM+VCadylQtF4V3VNOZ5LmfItH5f3yA=="],
+
+    "@streamdown/code/shiki/@shikijs/engine-oniguruma": ["@shikijs/engine-oniguruma@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0", "@shikijs/vscode-textmate": "^10.0.2" } }, "sha512-1nWINwKXxKKLqPibT5f4pAFLej9oZzQTsby8942OTlsJzOBZ0MWKiwzMsd+jhzu8YPCHAswGnnN1YtQfirL35g=="],
+
+    "@streamdown/code/shiki/@shikijs/langs": ["@shikijs/langs@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0" } }, "sha512-2Ep4W3Re5aB1/62RSYQInK9mM3HsLeB91cHqznAJMuylqjzNVAVCMnNWRHFtcNHXsoNRayP9z1qj4Sq3nMqYXg=="],
+
+    "@streamdown/code/shiki/@shikijs/themes": ["@shikijs/themes@3.23.0", "", { "dependencies": { "@shikijs/types": "3.23.0" } }, "sha512-5qySYa1ZgAT18HR/ypENL9cUSGOeI2x+4IvYJu4JgVJdizn6kG4ia5Q1jDEOi7gTbN4RbuYtmHh0W3eccOrjMA=="],
+
+    "@streamdown/code/shiki/@shikijs/types": ["@shikijs/types@3.23.0", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-3JZ5HXOZfYjsYSk0yPwBrkupyYSLpAE26Qc0HLghhZNGTZg/SKxXIIgoxOpmmeQP0RRSDJTk1/vPfw9tbw+jSQ=="],
+
+    "@testing-library/dom/pretty-format/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "@testing-library/dom/pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "@testing-library/dom/pretty-format/react-is": ["react-is@17.0.2", "", {}, "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w=="],
+
+    "@textlint/linter-formatter/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "@textlint/linter-formatter/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "@textlint/linter-formatter/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "@ts-morph/common/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "@types/jest/pretty-format/@jest/schemas": ["@jest/schemas@29.6.3", "", { "dependencies": { "@sinclair/typebox": "^0.27.8" } }, "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA=="],
+
+    "@types/jest/pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "@typescript-eslint/typescript-estree/minimatch/brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="],
+
+    "@vscode/test-cli/chokidar/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+
+    "@vscode/test-cli/chokidar/readdirp": ["readdirp@3.6.0", "", { "dependencies": { "picomatch": "^2.2.1" } }, "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA=="],
+
+    "@vscode/test-cli/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "@vscode/test-cli/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "@vscode/test-cli/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "@vscode/vsce/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "@vscode/vsce/minimatch/brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="],
+
+    "ajv-formats/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
+
+    "archiver-utils/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "archiver-utils/glob/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "archiver-utils/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "axios/https-proxy-agent/agent-base": ["agent-base@6.0.2", "", { "dependencies": { "debug": "4" } }, "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ=="],
+
+    "better-opn/open/define-lazy-prop": ["define-lazy-prop@2.0.0", "", {}, "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="],
+
+    "better-opn/open/is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
+
+    "claude-dev/@microsoft/tui-test/commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="],
+
+    "claude-dev/@microsoft/tui-test/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff": ["jest-diff@29.7.0", "", { "dependencies": { "chalk": "^4.0.0", "diff-sequences": "^29.6.3", "jest-get-type": "^29.6.3", "pretty-format": "^29.7.0" } }, "sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.56.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/otlp-transformer": "0.56.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-eURvv0fcmBE+KE1McUeRo+u0n18ZnUeSc7lDlW/dzlqFYasEbsztTK4v0Qf8C4vEY+aMTjPKUxBG0NX2Te3Pmw=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.56.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.56.0", "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/sdk-logs": "0.56.0", "@opentelemetry/sdk-metrics": "1.29.0", "@opentelemetry/sdk-trace-base": "1.29.0", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-kVkH/W2W7EpgWWpyU5VnnjIdSD7Y7FljQYObAQSKdRcejiwMj2glypZtUdfq1LTJcv4ht0jyTrw1D3CCxssNtQ=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "claude-dev/@opentelemetry/resources/@opentelemetry/core": ["@opentelemetry/core@1.30.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ=="],
+
+    "claude-dev/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/sdk-logs/@opentelemetry/core": ["@opentelemetry/core@1.29.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-gmT7vAreXl0DTHD2rVZcw3+l2g84+5XiHIqdBUxXbExymPCvSsGOpiwMmn8nkiJur28STV31wnhIDrzWDPzjfA=="],
+
+    "claude-dev/@opentelemetry/sdk-logs/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "claude-dev/@opentelemetry/sdk-metrics/@opentelemetry/core": ["@opentelemetry/core@1.30.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ=="],
+
+    "claude-dev/@opentelemetry/sdk-trace-node/@opentelemetry/context-async-hooks": ["@opentelemetry/context-async-hooks@1.30.1", "", { "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA=="],
+
+    "claude-dev/@opentelemetry/sdk-trace-node/@opentelemetry/core": ["@opentelemetry/core@1.30.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ=="],
+
+    "claude-dev/@opentelemetry/sdk-trace-node/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.30.1", "", { "dependencies": { "@opentelemetry/core": "1.30.1", "@opentelemetry/resources": "1.30.1", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg=="],
+
+    "claude-dev/@types/node/undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "claude-dev/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="],
+
+    "claude-dev/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="],
+
+    "claude-dev/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.12", "", { "os": "android", "cpu": "arm64" }, "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg=="],
+
+    "claude-dev/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.25.12", "", { "os": "android", "cpu": "x64" }, "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg=="],
+
+    "claude-dev/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg=="],
+
+    "claude-dev/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA=="],
+
+    "claude-dev/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg=="],
+
+    "claude-dev/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ=="],
+
+    "claude-dev/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.12", "", { "os": "linux", "cpu": "arm" }, "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw=="],
+
+    "claude-dev/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ=="],
+
+    "claude-dev/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA=="],
+
+    "claude-dev/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng=="],
+
+    "claude-dev/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw=="],
+
+    "claude-dev/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA=="],
+
+    "claude-dev/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w=="],
+
+    "claude-dev/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg=="],
+
+    "claude-dev/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.12", "", { "os": "linux", "cpu": "x64" }, "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw=="],
+
+    "claude-dev/esbuild/@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg=="],
+
+    "claude-dev/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.12", "", { "os": "none", "cpu": "x64" }, "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ=="],
+
+    "claude-dev/esbuild/@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.12", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A=="],
+
+    "claude-dev/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw=="],
+
+    "claude-dev/esbuild/@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg=="],
+
+    "claude-dev/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w=="],
+
+    "claude-dev/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg=="],
+
+    "claude-dev/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ=="],
+
+    "claude-dev/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.12", "", { "os": "win32", "cpu": "x64" }, "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA=="],
+
+    "cliui/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "cliui/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "conf/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
+
+    "cross-spawn/which/isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
+
+    "cytoscape-fcose/cose-base/layout-base": ["layout-base@2.0.1", "", {}, "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg=="],
+
+    "d3-sankey/d3-array/internmap": ["internmap@1.0.1", "", {}, "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="],
+
+    "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="],
+
+    "duplexer2/readable-stream/safe-buffer": ["safe-buffer@5.1.2", "", {}, "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="],
+
+    "duplexer2/readable-stream/string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],
+
+    "enquirer/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "eslint/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "exceljs/archiver/archiver-utils": ["archiver-utils@2.1.0", "", { "dependencies": { "glob": "^7.1.4", "graceful-fs": "^4.2.0", "lazystream": "^1.0.0", "lodash.defaults": "^4.2.0", "lodash.difference": "^4.5.0", "lodash.flatten": "^4.4.0", "lodash.isplainobject": "^4.0.6", "lodash.union": "^4.6.0", "normalize-path": "^3.0.0", "readable-stream": "^2.0.0" } }, "sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw=="],
+
+    "exceljs/archiver/buffer-crc32": ["buffer-crc32@0.2.13", "", {}, "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="],
+
+    "exceljs/archiver/tar-stream": ["tar-stream@2.2.0", "", { "dependencies": { "bl": "^4.0.3", "end-of-stream": "^1.4.1", "fs-constants": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^3.1.1" } }, "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ=="],
+
+    "exceljs/archiver/zip-stream": ["zip-stream@4.1.1", "", { "dependencies": { "archiver-utils": "^3.0.4", "compress-commons": "^4.1.2", "readable-stream": "^3.6.0" } }, "sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ=="],
+
+    "execa/pretty-ms/parse-ms": ["parse-ms@4.0.0", "", {}, "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw=="],
+
+    "extract-zip/yauzl/buffer-crc32": ["buffer-crc32@0.2.13", "", {}, "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="],
+
+    "form-data/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
+
+    "fstream/rimraf/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="],
+
+    "gauge/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "gauge/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "glob/minimatch/brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="],
+
+    "googleapis-common/gaxios/node-fetch": ["node-fetch@3.3.2", "", { "dependencies": { "data-uri-to-buffer": "^4.0.0", "fetch-blob": "^3.1.4", "formdata-polyfill": "^4.0.10" } }, "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA=="],
+
+    "googleapis-common/gaxios/rimraf": ["rimraf@5.0.10", "", { "dependencies": { "glob": "^10.3.7" }, "bin": { "rimraf": "dist/esm/bin.mjs" } }, "sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ=="],
+
+    "googleapis-common/google-auth-library/gaxios": ["gaxios@7.1.5", "", { "dependencies": { "extend": "^3.0.2", "https-proxy-agent": "^7.0.1", "node-fetch": "^3.3.2" } }, "sha512-5FZy72Rh8LhtjmvDrKkI+lVhrsQrVKVsItxMoDm5mNQE+xR0WVIIs+jzPSJgBvKVsLi24fZhXJIsNI0bihDzFg=="],
+
+    "hast-to-hyperscript/style-to-object/inline-style-parser": ["inline-style-parser@0.1.1", "", {}, "sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q=="],
+
+    "jest-diff/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "jest-matcher-utils/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "jest-matcher-utils/pretty-format/@jest/schemas": ["@jest/schemas@29.6.3", "", { "dependencies": { "@sinclair/typebox": "^0.27.8" } }, "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA=="],
+
+    "jest-matcher-utils/pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "jest-message-util/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "jest-message-util/pretty-format/@jest/schemas": ["@jest/schemas@29.6.3", "", { "dependencies": { "@sinclair/typebox": "^0.27.8" } }, "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA=="],
+
+    "jest-message-util/pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "jest-util/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "jszip/readable-stream/safe-buffer": ["safe-buffer@5.1.2", "", {}, "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="],
+
+    "jszip/readable-stream/string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],
+
+    "lazystream/readable-stream/safe-buffer": ["safe-buffer@5.1.2", "", {}, "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="],
+
+    "lazystream/readable-stream/string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],
+
+    "log-symbols/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "log-update/slice-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "log-update/slice-ansi/is-fullwidth-code-point": ["is-fullwidth-code-point@5.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.1" } }, "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ=="],
+
+    "mdast-util-definitions/unist-util-visit/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "mdast-util-definitions/unist-util-visit/unist-util-is": ["unist-util-is@4.1.0", "", {}, "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg=="],
+
+    "mdast-util-definitions/unist-util-visit/unist-util-visit-parents": ["unist-util-visit-parents@3.1.1", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^4.0.0" } }, "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg=="],
+
+    "mocha/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "mocha/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "mocha/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "next/postcss/nanoid": ["nanoid@3.3.15", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA=="],
+
+    "node-fetch/whatwg-url/tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
+
+    "node-fetch/whatwg-url/webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
+
+    "normalize-package-data/hosted-git-info/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "ora/log-symbols/is-unicode-supported": ["is-unicode-supported@1.3.0", "", {}, "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ=="],
+
+    "pkg-up/find-up/locate-path": ["locate-path@3.0.0", "", { "dependencies": { "p-locate": "^3.0.0", "path-exists": "^3.0.0" } }, "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A=="],
+
+    "radix-ui/@radix-ui/react-accordion/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-checkbox/@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw=="],
+
+    "radix-ui/@radix-ui/react-collapsible/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-dialog/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-dropdown-menu/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-menu/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-menubar/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-navigation-menu/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-navigation-menu/@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw=="],
+
+    "radix-ui/@radix-ui/react-popover/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-popper/@radix-ui/react-use-rect": ["@radix-ui/react-use-rect@1.1.2", "", { "dependencies": { "@radix-ui/rect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-d8a+bBY/FxikNPlgJJoaBHZX+zKVbWHYJGTLnLvveQgFSTntkGdEKv3JDtHrMS0DNYpllz2nRsTLGLKYttbpmw=="],
+
+    "radix-ui/@radix-ui/react-popper/@radix-ui/rect": ["@radix-ui/rect@1.1.2", "", {}, "sha512-xnXE7wG13PI+cxieVssYXlQJuYVRhH9NBoxt3KNwzghDIA69GMm7d4wXRouHIYjE+KvS6U/MsMO73NdS2MH9ZA=="],
+
+    "radix-ui/@radix-ui/react-radio-group/@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw=="],
+
+    "radix-ui/@radix-ui/react-roving-focus/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-scroll-area/@radix-ui/number": ["@radix-ui/number@1.1.2", "", {}, "sha512-ceTwaxc4I5IOi97DgCotl3pqiyRGvffcc0oOsE2dQYaJOFIDsDt4VWG6xEbg1QePv9QWausCEIppud/tJ1wNig=="],
+
+    "radix-ui/@radix-ui/react-select/@radix-ui/number": ["@radix-ui/number@1.1.2", "", {}, "sha512-ceTwaxc4I5IOi97DgCotl3pqiyRGvffcc0oOsE2dQYaJOFIDsDt4VWG6xEbg1QePv9QWausCEIppud/tJ1wNig=="],
+
+    "radix-ui/@radix-ui/react-select/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-select/@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw=="],
+
+    "radix-ui/@radix-ui/react-slider/@radix-ui/number": ["@radix-ui/number@1.1.2", "", {}, "sha512-ceTwaxc4I5IOi97DgCotl3pqiyRGvffcc0oOsE2dQYaJOFIDsDt4VWG6xEbg1QePv9QWausCEIppud/tJ1wNig=="],
+
+    "radix-ui/@radix-ui/react-slider/@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw=="],
+
+    "radix-ui/@radix-ui/react-switch/@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw=="],
+
+    "radix-ui/@radix-ui/react-tabs/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "radix-ui/@radix-ui/react-tooltip/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown": ["mdast-util-from-markdown@0.8.5", "", { "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-to-string": "^2.0.0", "micromark": "~2.11.0", "parse-entities": "^2.0.0", "unist-util-stringify-position": "^2.0.0" } }, "sha512-2hkTXtYYnr+NubD/g6KGBS/0mFmBcifAsI0yIWRiRo0PjVs6SSOSOdtzbp6kSGnShDN6G5aWZpKQ2lWRy27mWQ=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast": ["mdast-util-to-hast@10.2.0", "", { "dependencies": { "@types/mdast": "^3.0.0", "@types/unist": "^2.0.0", "mdast-util-definitions": "^4.0.0", "mdurl": "^1.0.0", "unist-builder": "^2.0.0", "unist-util-generated": "^1.0.0", "unist-util-position": "^3.0.0", "unist-util-visit": "^2.0.0" } }, "sha512-JoPBfJ3gBnHZ18icCwHR50orC9kNH81tiR1gs01D8Q5YpV6adHNO9nKNuFBCJQ941/32PT1a63UF/DitmS3amQ=="],
+
+    "react-remark/unified/bail": ["bail@1.0.5", "", {}, "sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ=="],
+
+    "react-remark/unified/is-plain-obj": ["is-plain-obj@2.1.0", "", {}, "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA=="],
+
+    "react-remark/unified/trough": ["trough@1.0.5", "", {}, "sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA=="],
+
+    "react-remark/unified/vfile": ["vfile@4.2.1", "", { "dependencies": { "@types/unist": "^2.0.0", "is-buffer": "^2.0.0", "unist-util-stringify-position": "^2.0.0", "vfile-message": "^2.0.0" } }, "sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA=="],
+
+    "readdir-glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "rimraf/glob/minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "shadcn/open/wsl-utils": ["wsl-utils@0.3.1", "", { "dependencies": { "is-wsl": "^3.1.0", "powershell-utils": "^0.1.0" } }, "sha512-g/eziiSUNBSsdDJtCLB8bdYEUMj4jR7AGeUo96p/3dTafgjHhpF4RiCFPiRILwjQoDXx5MqkBr4fwWtR3Ky4Wg=="],
+
+    "shadcn/ts-morph/@ts-morph/common": ["@ts-morph/common@0.27.0", "", { "dependencies": { "fast-glob": "^3.3.3", "minimatch": "^10.0.1", "path-browserify": "^1.0.1" } }, "sha512-Wf29UqxWDpc+i61k3oIOzcUfQt79PIT9y/MWfAGlrkjg6lBC1hwDECLXPVJAhWjiGbfBCxZd65F/LIZF3+jeJQ=="],
+
+    "storybook/@vitest/expect/@vitest/utils": ["@vitest/utils@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "loupe": "^3.1.4", "tinyrainbow": "^2.0.0" } }, "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA=="],
+
+    "storybook/@vitest/expect/chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="],
+
+    "storybook/@vitest/expect/tinyrainbow": ["tinyrainbow@2.0.0", "", {}, "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw=="],
+
+    "storybook/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="],
+
+    "storybook/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="],
+
+    "storybook/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.12", "", { "os": "android", "cpu": "arm64" }, "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg=="],
+
+    "storybook/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.25.12", "", { "os": "android", "cpu": "x64" }, "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg=="],
+
+    "storybook/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg=="],
+
+    "storybook/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA=="],
+
+    "storybook/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg=="],
+
+    "storybook/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ=="],
+
+    "storybook/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.12", "", { "os": "linux", "cpu": "arm" }, "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw=="],
+
+    "storybook/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ=="],
+
+    "storybook/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA=="],
+
+    "storybook/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng=="],
+
+    "storybook/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw=="],
+
+    "storybook/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA=="],
+
+    "storybook/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w=="],
+
+    "storybook/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg=="],
+
+    "storybook/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.12", "", { "os": "linux", "cpu": "x64" }, "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw=="],
+
+    "storybook/esbuild/@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg=="],
+
+    "storybook/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.12", "", { "os": "none", "cpu": "x64" }, "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ=="],
+
+    "storybook/esbuild/@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.12", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A=="],
+
+    "storybook/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw=="],
+
+    "storybook/esbuild/@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg=="],
+
+    "storybook/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w=="],
+
+    "storybook/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg=="],
+
+    "storybook/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ=="],
+
+    "storybook/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.12", "", { "os": "win32", "cpu": "x64" }, "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA=="],
+
+    "string-width-cjs/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "table/ajv/json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
+
+    "table/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "table/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "test-exclude/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "test-exclude/glob/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "test-exclude/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "test-exclude/minimatch/brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="],
+
+    "unzipper/readable-stream/safe-buffer": ["safe-buffer@5.1.2", "", {}, "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="],
+
+    "unzipper/readable-stream/string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/primitive": ["@radix-ui/primitive@1.1.4", "", {}, "sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-context": ["@radix-ui/react-context@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-dismissable-layer": ["@radix-ui/react-dismissable-layer@1.1.14", "", { "dependencies": { "@radix-ui/primitive": "1.1.4", "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2", "@radix-ui/react-use-effect-event": "0.0.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-4lUhWTWAjbDIqFrAPWJ3WqBOpO5YchVZ88X3nh6H9Lu5AFi5nCUeTPj3D8FSDmabmFeRe9ME0BDA4MwKTha5GQ=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-focus-guards": ["@radix-ui/react-focus-guards@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-cot/aB/mOm0IYVYTTmQcEEK1M48lZWi8FlYe5nDPQQ8NYZUlXEFgncJ9p2Kzer3RKSrY7cTTpEMLZKNo9QoP5Q=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-focus-scope": ["@radix-ui/react-focus-scope@1.1.11", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3", "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-callback-ref": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Mn88Vg2whaRocGJNOH+DKFqYm6ySFPQaiwHNxZPyjn99B52KAEJWWY9NP83+nWdk2HM3rdov+STu9AG471Rt9w=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-id": ["@radix-ui/react-id@1.1.2", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-portal": ["@radix-ui/react-portal@1.1.13", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.7", "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-z3oXfmaHLJTF1wktbjgD6cn9jiEbq3WSondB10LIuIt2m2Ym4iJlrW04/euMwENDdWDdE7z+OuY7Qyp1YpRSwA=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-presence": ["@radix-ui/react-presence@1.1.6", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-zdTk4PlUO0E18HnZ3wYbW0KkJJxWCdiNYp6g6X1PtONFhxVkg01vliTJAmwIszU6mHiyBOoW9P0rAugl5/hULQ=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.7", "", { "dependencies": { "@radix-ui/react-slot": "1.3.0" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "webview-ui/@types/node/undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "webview-ui/@vitejs/plugin-react-swc/@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.27", "", {}, "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA=="],
+
+    "webview-ui/mermaid/dagre-d3-es": ["dagre-d3-es@7.0.13", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-efEhnxpSuwpYOKRm/L5KbqoZmNNukHa/Flty4Wp62JRvgH2ojwVgPgdYyr4twpieZnyRDdIH7PY2mopX26+j2Q=="],
+
+    "webview-ui/mermaid/marked": ["marked@16.4.2", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA=="],
+
+    "webview-ui/mermaid/uuid": ["uuid@11.1.1", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ=="],
+
+    "webview-ui/react-dom/scheduler": ["scheduler@0.23.2", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ=="],
+
+    "webview-ui/vitest/@vitest/expect": ["@vitest/expect@3.2.6", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.6", "@vitest/utils": "3.2.6", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-1+7q9BtaKzEmO+fmNT3kYvoNn5Y71XWAx2Q5HRim4tTVRQVRv4uJFAQ5FbK0OPUeNP/WmVCpxYxoJdvuHVjzBQ=="],
+
+    "webview-ui/vitest/@vitest/mocker": ["@vitest/mocker@3.2.6", "", { "dependencies": { "@vitest/spy": "3.2.6", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-EZOrpDbkKotFAP7wPAQV1UIyoGOk4oX7ynWhBhLB7v+meMHbQhU16oPpIYGTTe4oFlhpryGpgpcZP/sin3hYuw=="],
+
+    "webview-ui/vitest/@vitest/pretty-format": ["@vitest/pretty-format@3.2.6", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-lb7XXXzmm2h2ASzFnRvQpDo6onT1NmMJA3tkGTWiBFtRJ9lxGY3d3mm/Apt36gej2bkkOVLL/yTOtufDaFa/jA=="],
+
+    "webview-ui/vitest/@vitest/runner": ["@vitest/runner@3.2.6", "", { "dependencies": { "@vitest/utils": "3.2.6", "pathe": "^2.0.3", "strip-literal": "^3.0.0" } }, "sha512-HYcoSj1w5tcgUnzoF0HcyaAQjpA1gj9ftUJ7iSJSuipc02jW9gKkigwZbjFldAfYHA1fa8UZVRftdMY5msWM9Q=="],
+
+    "webview-ui/vitest/@vitest/snapshot": ["@vitest/snapshot@3.2.6", "", { "dependencies": { "@vitest/pretty-format": "3.2.6", "magic-string": "^0.30.17", "pathe": "^2.0.3" } }, "sha512-H+ZjNTWGpObenh0YnlBctAPnJSI20P81PL8BPzWpx54YXLLTm8hEsWawtcYLMrwvpK48hGxLLbCS+1KRXhsKhw=="],
+
+    "webview-ui/vitest/@vitest/spy": ["@vitest/spy@3.2.6", "", { "dependencies": { "tinyspy": "^4.0.3" } }, "sha512-oq6BbH68WzcWmwtBrU9nqLeaXTR4XwJF7FSLkKEZo4i6eoXcrxjcwSuTvWBIRUTC6VC72nXYunzqgZA+IKdtxg=="],
+
+    "webview-ui/vitest/@vitest/utils": ["@vitest/utils@3.2.6", "", { "dependencies": { "@vitest/pretty-format": "3.2.6", "loupe": "^3.1.4", "tinyrainbow": "^2.0.0" } }, "sha512-lI23nIs4bnT3T8NIoh+vFaz5s2/DdP0Jgt2jxwgWljvwn82cLJtyi/If+fjFyoLMGIOz0U/fKvWE0d4jsNQEfg=="],
+
+    "webview-ui/vitest/chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="],
+
+    "webview-ui/vitest/std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="],
+
+    "webview-ui/vitest/tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="],
+
+    "webview-ui/vitest/tinyrainbow": ["tinyrainbow@2.0.0", "", {}, "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw=="],
+
+    "webview/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
+    "wide-align/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "wide-align/string-width/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "windows-release/execa/get-stream": ["get-stream@8.0.1", "", {}, "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA=="],
+
+    "windows-release/execa/human-signals": ["human-signals@5.0.0", "", {}, "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ=="],
+
+    "windows-release/execa/is-stream": ["is-stream@3.0.0", "", {}, "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA=="],
+
+    "windows-release/execa/npm-run-path": ["npm-run-path@5.3.0", "", { "dependencies": { "path-key": "^4.0.0" } }, "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ=="],
+
+    "windows-release/execa/onetime": ["onetime@6.0.0", "", { "dependencies": { "mimic-fn": "^4.0.0" } }, "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ=="],
+
+    "windows-release/execa/strip-final-newline": ["strip-final-newline@3.0.0", "", {}, "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw=="],
+
+    "wrap-ansi-cjs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "wrap-ansi-cjs/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "yargs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "yargs/string-width/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "@mapbox/hast-util-table-cell-style/unist-util-visit/unist-util-visit-parents/unist-util-is": ["unist-util-is@3.0.0", "", {}, "sha512-sVZZX3+kspVNmLWBPAB6r+7D9ZgAFPNWm66f7YNb420RlQSbn+n8rG8dGZSkrER7ZIXGQYNm5pqC3v3HopH24A=="],
+
+    "@microsoft/tui-test/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "@microsoft/tui-test/glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "@microsoft/tui-test/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "@microsoft/tui-test/jest-diff/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "@microsoft/tui-test/jest-diff/pretty-format/@jest/schemas": ["@jest/schemas@29.6.3", "", { "dependencies": { "@sinclair/typebox": "^0.27.8" } }, "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA=="],
+
+    "@microsoft/tui-test/jest-diff/pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/sdk-logs/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@opentelemetry/otlp-grpc-exporter-base/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "@radix-ui/react-accessible-icon/@radix-ui/react-visually-hidden/@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@radix-ui/react-arrow/@radix-ui/react-primitive/@radix-ui/react-slot/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-primitive/@radix-ui/react-slot/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@radix-ui/react-toolbar/@radix-ui/react-roving-focus/@radix-ui/react-collection/@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.0", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA=="],
+
+    "@so-ric/colorspace/color/color-convert/color-name": ["color-name@2.1.0", "", {}, "sha512-1bPaDNFm0axzE4MEAzKPuqKWeRaT43U/hyxKPBdqTfmPF+d6n7FSoTFxLVULUJOmiLp01KjhIPPH+HrXZJN4Rg=="],
+
+    "@so-ric/colorspace/color/color-string/color-name": ["color-name@2.1.0", "", {}, "sha512-1bPaDNFm0axzE4MEAzKPuqKWeRaT43U/hyxKPBdqTfmPF+d6n7FSoTFxLVULUJOmiLp01KjhIPPH+HrXZJN4Rg=="],
+
+    "@storybook/react-vite/find-up/locate-path/p-locate": ["p-locate@6.0.0", "", { "dependencies": { "p-limit": "^4.0.0" } }, "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw=="],
+
+    "@types/jest/pretty-format/@jest/schemas/@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
+
+    "@typescript-eslint/typescript-estree/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "@vscode/test-cli/chokidar/readdirp/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+
+    "@vscode/test-cli/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "@vscode/test-cli/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "@vscode/vsce/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "archiver-utils/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "archiver-utils/glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "archiver-utils/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "claude-dev/@microsoft/tui-test/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "claude-dev/@microsoft/tui-test/glob/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "claude-dev/@microsoft/tui-test/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff/pretty-format": ["pretty-format@29.7.0", "", { "dependencies": { "@jest/schemas": "^29.6.3", "ansi-styles": "^5.0.0", "react-is": "^18.0.0" } }, "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/resources": ["@opentelemetry/resources@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-s7mLXuHZE7RQr1wwweGcaRp3Q4UJJ0wazeGlc/N5/XSe6UyXfsh1UQGMADYeg7YwD+cEdMtU1yJAUXdnFzYzyQ=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0", "@opentelemetry/semantic-conventions": "1.28.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-hEOpAYLKXF3wGJpXOtWsxEtqBgde0SCv+w+jvr3/UusR4ll3QrENEGnSl1WDCyRrpqOQ5NCNOvZch9UFVa7MnQ=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@1.29.0", "", { "dependencies": { "@opentelemetry/core": "1.29.0", "@opentelemetry/resources": "1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MkVtuzDjXZaUJSuJlHn6BSXjcQlMvHcsDV7LjY4P6AJeffMa4+kIGDjzsCf6DkAh6Vqlwag5EWEam3KZOX5Drw=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/sdk-logs/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/sdk-logs/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/sdk-metrics/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/sdk-trace-node/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/sdk-trace-node/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "exceljs/archiver/archiver-utils/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="],
+
+    "exceljs/archiver/archiver-utils/readable-stream": ["readable-stream@2.3.8", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA=="],
+
+    "exceljs/archiver/zip-stream/archiver-utils": ["archiver-utils@3.0.4", "", { "dependencies": { "glob": "^7.2.3", "graceful-fs": "^4.2.0", "lazystream": "^1.0.0", "lodash.defaults": "^4.2.0", "lodash.difference": "^4.5.0", "lodash.flatten": "^4.4.0", "lodash.isplainobject": "^4.0.6", "lodash.union": "^4.6.0", "normalize-path": "^3.0.0", "readable-stream": "^3.6.0" } }, "sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw=="],
+
+    "exceljs/archiver/zip-stream/compress-commons": ["compress-commons@4.1.2", "", { "dependencies": { "buffer-crc32": "^0.2.13", "crc32-stream": "^4.0.2", "normalize-path": "^3.0.0", "readable-stream": "^3.6.0" } }, "sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg=="],
+
+    "glob/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "googleapis-common/gaxios/rimraf/glob": ["glob@10.5.0", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="],
+
+    "googleapis-common/google-auth-library/gaxios/node-fetch": ["node-fetch@3.3.2", "", { "dependencies": { "data-uri-to-buffer": "^4.0.0", "fetch-blob": "^3.1.4", "formdata-polyfill": "^4.0.10" } }, "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA=="],
+
+    "jest-matcher-utils/pretty-format/@jest/schemas/@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
+
+    "jest-message-util/pretty-format/@jest/schemas/@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
+
+    "mocha/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "mocha/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "pkg-up/find-up/locate-path/p-locate": ["p-locate@3.0.0", "", { "dependencies": { "p-limit": "^2.0.0" } }, "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ=="],
+
+    "pkg-up/find-up/locate-path/path-exists": ["path-exists@3.0.0", "", {}, "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/@types/mdast": ["@types/mdast@3.0.15", "", { "dependencies": { "@types/unist": "^2" } }, "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/mdast-util-to-string": ["mdast-util-to-string@2.0.0", "", {}, "sha512-AW4DRS3QbBayY/jJmD8437V1Gombjf8RSOUCMFBuo5iHi58AGEgVCKQ+ezHkZZDpAQS75hcBMpLqjpJTjtUL7w=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/micromark": ["micromark@2.11.4", "", { "dependencies": { "debug": "^4.0.0", "parse-entities": "^2.0.0" } }, "sha512-+WoovN/ppKolQOFIAajxi7Lu9kInbPxFuTBVEavFcL8eAfVstoc5MocPmqBeAdBOJV00uaVjegzH4+MA0DN/uA=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities": ["parse-entities@2.0.0", "", { "dependencies": { "character-entities": "^1.0.0", "character-entities-legacy": "^1.0.0", "character-reference-invalid": "^1.0.0", "is-alphanumerical": "^1.0.0", "is-decimal": "^1.0.0", "is-hexadecimal": "^1.0.0" } }, "sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/unist-util-stringify-position": ["unist-util-stringify-position@2.0.3", "", { "dependencies": { "@types/unist": "^2.0.2" } }, "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/@types/mdast": ["@types/mdast@3.0.15", "", { "dependencies": { "@types/unist": "^2" } }, "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/mdurl": ["mdurl@1.0.1", "", {}, "sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/unist-util-position": ["unist-util-position@3.1.0", "", {}, "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/unist-util-visit": ["unist-util-visit@2.0.3", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^4.0.0", "unist-util-visit-parents": "^3.0.0" } }, "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q=="],
+
+    "react-remark/unified/vfile/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "react-remark/unified/vfile/unist-util-stringify-position": ["unist-util-stringify-position@2.0.3", "", { "dependencies": { "@types/unist": "^2.0.2" } }, "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g=="],
+
+    "react-remark/unified/vfile/vfile-message": ["vfile-message@2.0.4", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-stringify-position": "^2.0.0" } }, "sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ=="],
+
+    "rimraf/glob/minimatch/brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="],
+
+    "shadcn/open/wsl-utils/is-wsl": ["is-wsl@3.1.1", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw=="],
+
+    "shadcn/ts-morph/@ts-morph/common/minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "storybook/@vitest/expect/@vitest/utils/@vitest/pretty-format": ["@vitest/pretty-format@3.2.4", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA=="],
+
+    "storybook/@vitest/expect/@vitest/utils/loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="],
+
+    "storybook/@vitest/expect/chai/check-error": ["check-error@2.1.3", "", {}, "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA=="],
+
+    "storybook/@vitest/expect/chai/deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="],
+
+    "storybook/@vitest/expect/chai/loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="],
+
+    "storybook/@vitest/expect/chai/pathval": ["pathval@2.0.1", "", {}, "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ=="],
+
+    "test-exclude/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "test-exclude/glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "test-exclude/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "test-exclude/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-dismissable-layer/@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw=="],
+
+    "vaul/@radix-ui/react-dialog/@radix-ui/react-focus-scope/@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw=="],
+
+    "webview-ui/vitest/@vitest/utils/loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="],
+
+    "webview-ui/vitest/chai/check-error": ["check-error@2.1.3", "", {}, "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA=="],
+
+    "webview-ui/vitest/chai/deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="],
+
+    "webview-ui/vitest/chai/loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="],
+
+    "webview-ui/vitest/chai/pathval": ["pathval@2.0.1", "", {}, "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ=="],
+
+    "wide-align/string-width/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "windows-release/execa/npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
+
+    "windows-release/execa/onetime/mimic-fn": ["mimic-fn@4.0.0", "", {}, "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw=="],
+
+    "yargs/string-width/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "@microsoft/tui-test/jest-diff/pretty-format/@jest/schemas/@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
+
+    "@radix-ui/react-accessible-icon/@radix-ui/react-visually-hidden/@radix-ui/react-primitive/@radix-ui/react-slot/@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.3", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA=="],
+
+    "@storybook/react-vite/find-up/locate-path/p-locate/p-limit": ["p-limit@4.0.0", "", { "dependencies": { "yocto-queue": "^1.0.0" } }, "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ=="],
+
+    "@vscode/test-cli/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "@vscode/test-cli/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "archiver-utils/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "archiver-utils/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "claude-dev/@microsoft/tui-test/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "claude-dev/@microsoft/tui-test/glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "claude-dev/@microsoft/tui-test/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff/pretty-format/@jest/schemas": ["@jest/schemas@29.6.3", "", { "dependencies": { "@sinclair/typebox": "^0.27.8" } }, "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff/pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/resources/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "claude-dev/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/otlp-transformer/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
+
+    "exceljs/archiver/archiver-utils/readable-stream/safe-buffer": ["safe-buffer@5.1.2", "", {}, "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="],
+
+    "exceljs/archiver/archiver-utils/readable-stream/string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],
+
+    "exceljs/archiver/zip-stream/archiver-utils/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="],
+
+    "exceljs/archiver/zip-stream/compress-commons/crc32-stream": ["crc32-stream@4.0.3", "", { "dependencies": { "crc-32": "^1.2.0", "readable-stream": "^3.4.0" } }, "sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw=="],
+
+    "googleapis-common/gaxios/rimraf/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
+
+    "googleapis-common/gaxios/rimraf/glob/minimatch": ["minimatch@9.0.9", "", { "dependencies": { "brace-expansion": "^2.0.2" } }, "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg=="],
+
+    "googleapis-common/gaxios/rimraf/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
+
+    "mocha/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "mocha/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "pkg-up/find-up/locate-path/p-locate/p-limit": ["p-limit@2.3.0", "", { "dependencies": { "p-try": "^2.0.0" } }, "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/@types/mdast/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/character-entities": ["character-entities@1.2.4", "", {}, "sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/character-entities-legacy": ["character-entities-legacy@1.1.4", "", {}, "sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/character-reference-invalid": ["character-reference-invalid@1.1.4", "", {}, "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/is-alphanumerical": ["is-alphanumerical@1.0.4", "", { "dependencies": { "is-alphabetical": "^1.0.0", "is-decimal": "^1.0.0" } }, "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/is-decimal": ["is-decimal@1.0.4", "", {}, "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/is-hexadecimal": ["is-hexadecimal@1.0.4", "", {}, "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/unist-util-stringify-position/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/unist-util-visit/unist-util-is": ["unist-util-is@4.1.0", "", {}, "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg=="],
+
+    "react-remark/remark-rehype/mdast-util-to-hast/unist-util-visit/unist-util-visit-parents": ["unist-util-visit-parents@3.1.1", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^4.0.0" } }, "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg=="],
+
+    "rimraf/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "shadcn/ts-morph/@ts-morph/common/minimatch/brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="],
+
+    "test-exclude/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "test-exclude/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "@joshwooding/vite-plugin-react-docgen-typescript/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "@vscode/test-cli/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "@vscode/test-cli/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "archiver-utils/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "archiver-utils/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "claude-dev/@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "claude-dev/@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "claude-dev/@microsoft/tui-test/jest-diff/pretty-format/@jest/schemas/@sinclair/typebox": ["@sinclair/typebox@0.27.10", "", {}, "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA=="],
+
+    "googleapis-common/gaxios/rimraf/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
+
+    "googleapis-common/gaxios/rimraf/glob/minimatch/brace-expansion": ["brace-expansion@2.1.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA=="],
+
+    "googleapis-common/gaxios/rimraf/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
+
+    "mocha/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "mocha/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "react-remark/remark-parse/mdast-util-from-markdown/parse-entities/is-alphanumerical/is-alphabetical": ["is-alphabetical@1.0.4", "", {}, "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg=="],
+
+    "shadcn/ts-morph/@ts-morph/common/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "test-exclude/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "test-exclude/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "claude-dev/@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "claude-dev/@microsoft/tui-test/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+    "googleapis-common/gaxios/rimraf/glob/jackspeak/@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
+
+    "googleapis-common/gaxios/rimraf/glob/jackspeak/@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="],
+
+    "googleapis-common/gaxios/rimraf/glob/jackspeak/@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
+
+    "googleapis-common/gaxios/rimraf/glob/jackspeak/@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+  }
+}
diff --git a/docs/api/authentication.mdx b/docs/api/authentication.mdx
new file mode 100644
index 0000000..8bf2428
--- /dev/null
+++ b/docs/api/authentication.mdx
@@ -0,0 +1,137 @@
+---
+title: "Authentication"
+sidebarTitle: "Authentication"
+description: "How to authenticate with the Cline API using API keys or account tokens."
+---
+
+Every request to the Cline API requires authentication via a Bearer token in the `Authorization` header.
+
+## Authentication Methods
+
+There are two ways to authenticate:
+
+| Method | Use case | How to get it |
+|--------|----------|---------------|
+| **API key** | Direct API calls, scripts, CI/CD | Create at [app.cline.bot](https://app.cline.bot) Settings > API Keys |
+| **Account auth token** | Cline extension and CLI | Generated automatically when you sign in |
+
+Both methods use the same header format:
+
+```bash
+Authorization: Bearer YOUR_TOKEN
+```
+
+## API Keys
+
+API keys are the recommended authentication method for programmatic access.
+
+### Creating a Key
+
+<Steps>
+  <Step title="Sign in">
+    Go to [app.cline.bot](https://app.cline.bot) and sign in.
+  </Step>
+  <Step title="Open API Keys">
+    Navigate to **Settings** > **API Keys**.
+  </Step>
+  <Step title="Create and copy">
+    Create a new key. Copy it immediately as you will not be able to see it again.
+  </Step>
+</Steps>
+
+### Deleting a Key
+
+You can revoke an API key at any time from the same Settings > API Keys page. Deleted keys stop working immediately.
+
+You can also manage keys programmatically through the [Enterprise API](/enterprise-solutions/api-reference#api-keys):
+
+```bash
+# List your keys
+curl https://api.cline.bot/api/v1/api-keys \
+  -H "Authorization: Bearer YOUR_TOKEN"
+
+# Delete a key
+curl -X DELETE https://api.cline.bot/api/v1/api-keys/KEY_ID \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+## Account Auth Tokens
+
+When you sign in to the Cline extension (VS Code, JetBrains) or CLI, an account auth token is generated and managed automatically. You do not need to handle these tokens manually.
+
+The Cline CLI uses these tokens when you authenticate via:
+
+```bash
+# Interactive sign-in
+cline auth
+
+# Or quick setup with an API key
+cline auth -p cline -k "YOUR_API_KEY" -m anthropic/claude-sonnet-4-6
+```
+
+See the [CLI Reference](/cli/cli-reference#cline-auth) for all auth options.
+
+## Security Best Practices
+
+**Do:**
+- Store API keys in environment variables or a secrets manager
+- Use different keys for development and production
+- Rotate keys periodically
+- Delete keys you no longer use
+
+**Do not:**
+- Commit keys to version control
+- Share keys in chat or email
+- Embed keys in client-side code (browsers, mobile apps)
+- Log keys in application output
+
+### Using Environment Variables
+
+```bash
+# Set the key
+export CLINE_API_KEY="your_api_key_here"
+
+# Use it in requests
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model": "anthropic/claude-sonnet-4-6", "messages": [{"role": "user", "content": "Hello"}]}'
+```
+
+### Using a .env File
+
+```bash
+# .env (add to .gitignore)
+CLINE_API_KEY=your_api_key_here
+```
+
+```python
+import os
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key=os.environ["CLINE_API_KEY"],
+)
+```
+
+## Custom Headers
+
+The Cline API accepts optional headers for tracking and identification:
+
+| Header | Description |
+|--------|-------------|
+| `HTTP-Referer` | Your application's URL. Helps with usage tracking. |
+| `X-Title` | Your application's name. Appears in usage logs. |
+| `X-Task-ID` | A unique task identifier. Used internally by the Cline extension. |
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Getting Started" icon="rocket" href="/api/getting-started">
+    Create your first API key and make a request.
+  </Card>
+  <Card title="Enterprise API Keys" icon="building" href="/enterprise-solutions/api-reference#api-keys">
+    Manage API keys programmatically.
+  </Card>
+</CardGroup>
diff --git a/docs/api/chat-completions.mdx b/docs/api/chat-completions.mdx
new file mode 100644
index 0000000..30f2817
--- /dev/null
+++ b/docs/api/chat-completions.mdx
@@ -0,0 +1,258 @@
+---
+title: "Chat Completions"
+sidebarTitle: "Chat Completions"
+description: "Full reference for the POST /chat/completions endpoint including all parameters, streaming, and tool calling."
+---
+
+The Chat Completions endpoint generates model responses from a conversation. It follows the [OpenAI Chat Completions](https://platform.openai.com/docs/api-reference/chat/create) format.
+
+## Endpoint
+
+```
+POST https://api.cline.bot/api/v1/chat/completions
+```
+
+## Request Headers
+
+| Header | Required | Description |
+|--------|----------|-------------|
+| `Authorization` | Yes | `Bearer YOUR_API_KEY` |
+| `Content-Type` | Yes | `application/json` |
+| `HTTP-Referer` | No | Your application URL (for usage tracking) |
+| `X-Title` | No | Your application name (for usage logs) |
+
+## Request Body
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `model` | string | Yes | | Model ID in `provider/model` format. See [Models](/api/models). |
+| `messages` | array | Yes | | Conversation messages. Each has `role` (`system`, `user`, `assistant`) and `content`. |
+| `stream` | boolean | No | `true` | Return the response as a stream of Server-Sent Events. |
+| `tools` | array | No | | Tool/function definitions in OpenAI format. |
+| `temperature` | number | No | Model default | Sampling temperature (0.0 to 2.0). Lower values are more deterministic. |
+
+### Message Format
+
+Each message in the `messages` array has this structure:
+
+```json
+{
+  "role": "user",
+  "content": "Your message here"
+}
+```
+
+**Roles:**
+
+| Role | Purpose |
+|------|---------|
+| `system` | Sets the model's behavior and persona. Place first in the array. |
+| `user` | The human's input. |
+| `assistant` | Previous model responses (for multi-turn conversations). |
+
+### Multi-Turn Conversation
+
+Include previous messages to maintain context:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-6",
+  "messages": [
+    {"role": "system", "content": "You are a helpful coding assistant."},
+    {"role": "user", "content": "What is a closure in JavaScript?"},
+    {"role": "assistant", "content": "A closure is a function that..."},
+    {"role": "user", "content": "Can you show me an example?"}
+  ]
+}
+```
+
+## Streaming Response
+
+When `stream: true` (the default), the response is a series of [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-Sent_Events):
+
+```
+data: {"id":"gen-abc123","choices":[{"delta":{"role":"assistant"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":"The capital"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":" of France"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":" is Paris."},"index":0,"finish_reason":"stop"}],"model":"anthropic/claude-sonnet-4-6","usage":{"prompt_tokens":14,"completion_tokens":8,"cost":0.000066}}
+
+data: [DONE]
+```
+
+Each `data:` line contains a JSON chunk. Key fields:
+
+| Field | Description |
+|-------|-------------|
+| `id` | Generation ID, consistent across all chunks |
+| `choices[0].delta.content` | The new text in this chunk |
+| `choices[0].delta.reasoning` | Reasoning/thinking content (for reasoning models) |
+| `choices[0].finish_reason` | `stop` when complete, `error` on failure |
+| `usage` | Token counts and cost (included in the final chunk) |
+
+### Usage Object
+
+The final chunk includes token usage and cost:
+
+```json
+{
+  "usage": {
+    "prompt_tokens": 25,
+    "completion_tokens": 42,
+    "prompt_tokens_details": {
+      "cached_tokens": 0
+    },
+    "cost": 0.000315
+  }
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `prompt_tokens` | Total input tokens |
+| `completion_tokens` | Total output tokens |
+| `prompt_tokens_details.cached_tokens` | Tokens served from cache (reduces cost) |
+| `cost` | Total cost in USD for this request |
+
+## Non-Streaming Response
+
+When `stream: false`, the response is a single JSON object:
+
+```json
+{
+  "id": "gen-abc123",
+  "model": "anthropic/claude-sonnet-4-6",
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "The capital of France is Paris."
+      },
+      "finish_reason": "stop",
+      "index": 0
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 14,
+    "completion_tokens": 8
+  }
+}
+```
+
+## Tool Calling
+
+You can define tools that the model can call using the OpenAI function calling format:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-6",
+  "messages": [
+    {"role": "user", "content": "What's the weather in San Francisco?"}
+  ],
+  "tools": [
+    {
+      "type": "function",
+      "function": {
+        "name": "get_weather",
+        "description": "Get the current weather for a location",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "location": {
+              "type": "string",
+              "description": "City and state, e.g. San Francisco, CA"
+            }
+          },
+          "required": ["location"]
+        }
+      }
+    }
+  ]
+}
+```
+
+When the model decides to call a tool, the response includes a `tool_calls` array:
+
+```json
+{
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "tool_calls": [
+          {
+            "id": "call_abc123",
+            "type": "function",
+            "function": {
+              "name": "get_weather",
+              "arguments": "{\"location\": \"San Francisco, CA\"}"
+            }
+          }
+        ]
+      },
+      "finish_reason": "tool_calls"
+    }
+  ]
+}
+```
+
+To continue the conversation after a tool call, include the tool result:
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "What's the weather in San Francisco?"},
+    {"role": "assistant", "tool_calls": [{"id": "call_abc123", "type": "function", "function": {"name": "get_weather", "arguments": "{\"location\": \"San Francisco, CA\"}"}}]},
+    {"role": "tool", "tool_call_id": "call_abc123", "content": "{\"temperature\": 62, \"condition\": \"foggy\"}"},
+  ]
+}
+```
+
+## Reasoning Models
+
+Some models support extended thinking (reasoning). When using these models, the response may include reasoning content in the streaming delta:
+
+```json
+{"choices":[{"delta":{"reasoning":"Let me think about this step by step..."}}]}
+```
+
+Reasoning tokens are separate from the main content and appear in the `delta.reasoning` field. Some providers return encrypted reasoning blocks via `delta.reasoning_details` that can be passed back in subsequent requests to preserve the reasoning trace.
+
+<Note>
+  Not all models support reasoning. See [Models](/api/models) for which models have reasoning capabilities.
+</Note>
+
+## Complete Example
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "system", "content": "You are a concise assistant. Answer in one sentence."},
+      {"role": "user", "content": "Explain what an API is."}
+    ],
+    "stream": true
+  }'
+```
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models and their capabilities.
+  </Card>
+  <Card title="Errors" icon="triangle-exclamation" href="/api/errors">
+    Handle errors and implement retry logic.
+  </Card>
+  <Card title="SDK Examples" icon="code" href="/api/sdk-examples">
+    Use this endpoint from Python, Node.js, and more.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    API key management and security practices.
+  </Card>
+</CardGroup>
diff --git a/docs/api/errors.mdx b/docs/api/errors.mdx
new file mode 100644
index 0000000..4570051
--- /dev/null
+++ b/docs/api/errors.mdx
@@ -0,0 +1,152 @@
+---
+title: "Errors"
+sidebarTitle: "Errors"
+description: "Error codes, error formats, mid-stream errors, and retry strategies for the Cline API."
+---
+
+The Cline API returns errors in a consistent JSON format. Understanding these errors helps you build reliable integrations.
+
+## Error Format
+
+All errors follow the OpenAI error format:
+
+```json
+{
+  "error": {
+    "code": 401,
+    "message": "Invalid API key",
+    "metadata": {}
+  }
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `code` | number/string | HTTP status code or error identifier |
+| `message` | string | Human-readable description of the error |
+| `metadata` | object | Additional context (provider details, request IDs) |
+
+## Error Codes
+
+### HTTP Errors
+
+These are returned as the HTTP response status code and in the error body:
+
+| Code | Name | Cause | What to do |
+|------|------|-------|------------|
+| `400` | Bad Request | Malformed request body, missing required fields | Check your JSON syntax and required parameters |
+| `401` | Unauthorized | Invalid or missing API key | Verify your API key in the `Authorization` header |
+| `402` | Payment Required | Insufficient credits | Add credits at [app.cline.bot](https://app.cline.bot) |
+| `403` | Forbidden | Key does not have access to this resource | Check key permissions |
+| `404` | Not Found | Invalid endpoint or model ID | Verify the URL and model ID format |
+| `429` | Too Many Requests | Rate limit exceeded | Wait and retry with exponential backoff |
+| `500` | Internal Server Error | Server-side issue | Retry after a short delay |
+| `502` | Bad Gateway | Upstream provider error | Retry after a short delay |
+| `503` | Service Unavailable | Service temporarily down | Retry after a short delay |
+
+### Mid-Stream Errors
+
+When streaming, errors can occur after the response has started. These appear as a chunk with `finish_reason: "error"`:
+
+```json
+{
+  "choices": [
+    {
+      "finish_reason": "error",
+      "error": {
+        "code": "context_length_exceeded",
+        "message": "The input exceeds the model's maximum context length."
+      }
+    }
+  ]
+}
+```
+
+Common mid-stream error codes:
+
+| Code | Meaning |
+|------|---------|
+| `context_length_exceeded` | Input tokens exceed the model's context window |
+| `content_filter` | Content was blocked by a safety filter |
+| `rate_limit` | Rate limit hit during generation |
+| `server_error` | Upstream provider failed during generation |
+
+<Warning>
+  Mid-stream errors do not produce an HTTP error code (the connection was already 200 OK). Always check `finish_reason` in your streaming handler.
+</Warning>
+
+## Retry Strategies
+
+### Exponential Backoff
+
+For transient errors (429, 500, 502, 503), retry with exponential backoff:
+
+```python
+import time
+import requests
+
+def call_api_with_retry(payload, max_retries=3):
+    for attempt in range(max_retries):
+        response = requests.post(
+            "https://api.cline.bot/api/v1/chat/completions",
+            headers={
+                "Authorization": "Bearer YOUR_API_KEY",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+
+        if response.status_code == 200:
+            return response.json()
+
+        if response.status_code in (429, 500, 502, 503):
+            delay = (2 ** attempt) + 1
+            print(f"Retrying in {delay}s (attempt {attempt + 1}/{max_retries})")
+            time.sleep(delay)
+            continue
+
+        # Non-retryable error
+        response.raise_for_status()
+
+    raise Exception("Max retries exceeded")
+```
+
+### When to Retry
+
+| Error | Retry? | Strategy |
+|-------|--------|----------|
+| `401 Unauthorized` | No | Fix your API key |
+| `402 Payment Required` | No | Add credits |
+| `429 Too Many Requests` | Yes | Exponential backoff (start at 1s) |
+| `500 Internal Server Error` | Yes | Retry once after 1s |
+| `502 Bad Gateway` | Yes | Retry up to 3 times with backoff |
+| `503 Service Unavailable` | Yes | Retry up to 3 times with backoff |
+| Mid-stream `error` | Depends | Retry the full request for transient errors |
+
+### Rate Limits
+
+If you hit rate limits frequently:
+
+- Add delays between requests
+- Reduce the number of concurrent requests
+- Contact support if you need higher limits
+
+## Debugging
+
+When reporting issues, include:
+
+1. The **error code and message** from the response
+2. The **model ID** you were using
+3. The **request ID** (from the `x-request-id` response header, if available)
+4. Whether the error was **immediate** (HTTP error) or **mid-stream** (finish_reason error)
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Endpoint reference with request and response schemas.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    Verify your API key is configured correctly.
+  </Card>
+</CardGroup>
diff --git a/docs/api/getting-started.mdx b/docs/api/getting-started.mdx
new file mode 100644
index 0000000..9f37ea2
--- /dev/null
+++ b/docs/api/getting-started.mdx
@@ -0,0 +1,136 @@
+---
+title: "Getting Started"
+sidebarTitle: "Getting Started"
+description: "Create an API key and make your first request to the Cline API in under a minute."
+---
+
+This guide walks you through creating an API key and making your first Chat Completions request.
+
+## Prerequisites
+
+- A Cline account at [app.cline.bot](https://app.cline.bot)
+- `curl` or any HTTP client (Python, Node.js, etc.)
+
+## Create an API Key
+
+<Steps>
+  <Step title="Sign in to app.cline.bot">
+    Go to [app.cline.bot](https://app.cline.bot) and sign in with your account.
+  </Step>
+  <Step title="Navigate to API Keys">
+    Open **Settings** and select **API Keys**.
+  </Step>
+  <Step title="Create a new key">
+    Click **Create API Key**. Copy the key immediately. You will not be able to see it again after leaving this page.
+  </Step>
+</Steps>
+
+<Warning>
+  Treat your API key like a password. Do not commit it to version control or share it publicly.
+</Warning>
+
+## Make Your First Request
+
+Replace `YOUR_API_KEY` with the key you just created:
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "user", "content": "What is the capital of France?"}
+    ],
+    "stream": false
+  }'
+```
+
+## Verify the Response
+
+You should get a JSON response like this:
+
+```json
+{
+  "id": "gen-abc123",
+  "model": "anthropic/claude-sonnet-4-6",
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "The capital of France is Paris."
+      },
+      "finish_reason": "stop",
+      "index": 0
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 14,
+    "completion_tokens": 8
+  }
+}
+```
+
+The `choices[0].message.content` field contains the model's reply. The `usage` field shows how many tokens were consumed.
+
+## Try Streaming
+
+For real-time output, set `stream: true`. The response arrives as Server-Sent Events:
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "user", "content": "Write a haiku about programming."}
+    ],
+    "stream": true
+  }'
+```
+
+Each chunk arrives as a `data:` line. The stream ends with `data: [DONE]`.
+
+## Try a Free Model
+
+To test without spending credits, use one of the [free models](/api/models#free-models):
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "minimax/minimax-m2.5",
+    "messages": [
+      {"role": "user", "content": "Hello! What can you help me with?"}
+    ],
+    "stream": false
+  }'
+```
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| `401 Unauthorized` | Check that your API key is correct and included in the `Authorization` header |
+| `402 Payment Required` | Your account has insufficient credits. Add credits at [app.cline.bot](https://app.cline.bot) |
+| Empty response | Make sure `messages` is a non-empty array with at least one user message |
+| Connection timeout | Verify your network can reach `api.cline.bot`. Check proxy settings if on a corporate network |
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    Learn about API keys, token scoping, and security practices.
+  </Card>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Full endpoint reference with all parameters and options.
+  </Card>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models and find the right one for your use case.
+  </Card>
+  <Card title="SDK Examples" icon="code" href="/api/sdk-examples">
+    Use the API from Python, Node.js, or the Cline CLI.
+  </Card>
+</CardGroup>
diff --git a/docs/api/models.mdx b/docs/api/models.mdx
new file mode 100644
index 0000000..389a528
--- /dev/null
+++ b/docs/api/models.mdx
@@ -0,0 +1,89 @@
+---
+title: "Models"
+sidebarTitle: "Models"
+description: "Available models, pricing tiers, free models, and how model IDs work in the Cline API."
+---
+
+The Cline API gives you access to models from multiple providers through a single endpoint. Model IDs follow the `provider/model-name` format, the same convention used by [OpenRouter](https://openrouter.ai).
+
+## Model ID Format
+
+Every model is identified by a string in the format:
+
+```
+provider/model-name
+```
+
+For example:
+- `anthropic/claude-sonnet-4-6` - Claude Sonnet 4.6 from Anthropic
+- `openai/gpt-4o` - GPT-4o from OpenAI
+- `google/gemini-2.5-pro` - Gemini 2.5 Pro from Google
+
+Pass this string as the `model` parameter in your [Chat Completions](/api/chat-completions) request.
+
+Example:
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "minimax/minimax-m2.5",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+## Reasoning Models
+
+Some models support extended thinking, where the model reasons through a problem before responding. When using these models:
+
+- Reasoning content appears in `delta.reasoning` during streaming
+- Some providers return encrypted reasoning blocks in `delta.reasoning_details`
+- Reasoning tokens are counted separately from output tokens
+
+Models with reasoning support include most Claude, Gemini 2.5, and Grok 3 models. Check the model's `supportsReasoning` capability in the model catalog.
+
+## Choosing a Model
+
+| If you need... | Consider |
+|----------------|----------|
+| Best coding performance | `anthropic/claude-sonnet-4-6` |
+| Long document analysis | `google/gemini-2.5-pro` (1M context) |
+| Fast, cheap responses | `deepseek/deepseek-chat` |
+| Free experimentation | `minimax/minimax-m2.5` |
+| Multi-modal (text + images) | `openai/gpt-4o` or `anthropic/claude-sonnet-4-6` |
+| Complex reasoning | Any model with reasoning support |
+
+For setup and account flow details, see the [Cline Provider guide](/getting-started/cline-provider).
+
+## Image Support
+
+Models that support images accept base64-encoded image content in the `messages` array:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-6",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "What's in this image?"},
+        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
+      ]
+    }
+  ]
+}
+```
+
+Not all models support images. Check the model's `supportsImages` capability before sending image content.
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Use these models in your API requests.
+  </Card>
+  <Card title="Cline Provider" icon="scale-balanced" href="/getting-started/cline-provider">
+    Fastest setup path with built-in authentication and billing.
+  </Card>
+</CardGroup>
diff --git a/docs/api/overview.mdx b/docs/api/overview.mdx
new file mode 100644
index 0000000..c8b73e8
--- /dev/null
+++ b/docs/api/overview.mdx
@@ -0,0 +1,58 @@
+---
+title: "Cline API"
+sidebarTitle: "Overview"
+description: "Programmatic access to AI models through an OpenAI-compatible Chat Completions API."
+---
+
+Welcome to the Cline API documentation. Use the same models that power the Cline extension and CLI from any language, framework, or tool that speaks the OpenAI format.
+
+## What is the Cline API?
+
+The Cline API is an OpenAI-compatible Chat Completions endpoint. You authenticate once with a Cline API key and get access to models from Anthropic, OpenAI, Google, and more through a single base URL. No need to manage separate keys for each provider.
+
+```
+Your App  →  Cline API (api.cline.bot)  →  Anthropic / OpenAI / Google / etc.
+```
+
+<CardGroup cols={2}>
+  <Card title="Getting Started" icon="rocket" href="/api/getting-started">
+    Create an API key and make your first request in under a minute.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    API keys, account tokens, key rotation, and security best practices.
+  </Card>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Full endpoint reference with request schemas, streaming, and tool calling.
+  </Card>
+  <Card title="Code Examples" icon="code" href="/api/sdk-examples">
+    Ready-to-copy examples for Python, Node.js, curl, and the Cline CLI.
+  </Card>
+</CardGroup>
+
+## Explore the Reference
+
+<CardGroup cols={3}>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models, free tier options, reasoning support, and selection guidance.
+  </Card>
+  <Card title="Errors" icon="triangle-exclamation" href="/api/errors">
+    Error codes, mid-stream errors, retry strategies, and debugging tips.
+  </Card>
+  <Card title="Enterprise API" icon="building" href="/enterprise-solutions/api-reference">
+    Admin endpoints for managing users, organizations, billing, and API keys.
+  </Card>
+</CardGroup>
+
+## Quick Start
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+Get your API key at [app.cline.bot](https://app.cline.bot) (Settings > API Keys), then follow the [Getting Started](/api/getting-started) guide.
diff --git a/docs/api/sdk-examples.mdx b/docs/api/sdk-examples.mdx
new file mode 100644
index 0000000..f828822
--- /dev/null
+++ b/docs/api/sdk-examples.mdx
@@ -0,0 +1,275 @@
+---
+title: "Code Examples"
+sidebarTitle: "Code Examples"
+description: "Use the Cline API from Python, Node.js, curl, the Cline CLI, and the VS Code extension."
+---
+
+The Cline API is OpenAI-compatible, so any library or tool that works with OpenAI also works with the Cline API. Just change the base URL and API key.
+
+## curl
+
+### Non-Streaming
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [{"role": "user", "content": "What is 2+2?"}],
+    "stream": false
+  }'
+```
+
+### Streaming
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [{"role": "user", "content": "Write a short poem about code."}],
+    "stream": true
+  }'
+```
+
+## Python
+
+### OpenAI SDK
+
+The [OpenAI Python SDK](https://github.com/openai/openai-python) works with the Cline API by setting `base_url`:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+# Non-streaming
+response = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "Explain recursion in one sentence."}],
+)
+print(response.choices[0].message.content)
+```
+
+### Streaming in Python
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+stream = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "Write a function to reverse a string in Python."}],
+    stream=True,
+)
+
+for chunk in stream:
+    content = chunk.choices[0].delta.content
+    if content:
+        print(content, end="", flush=True)
+print()
+```
+
+### Tool Calling in Python
+
+```python
+from openai import OpenAI
+import json
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get weather for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "City name"}
+                },
+                "required": ["location"],
+            },
+        },
+    }
+]
+
+response = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
+    tools=tools,
+)
+
+# Check if the model wants to call a tool
+choice = response.choices[0]
+if choice.message.tool_calls:
+    tool_call = choice.message.tool_calls[0]
+    print(f"Tool: {tool_call.function.name}")
+    print(f"Args: {tool_call.function.arguments}")
+```
+
+### Using requests
+
+If you prefer not to use the OpenAI SDK:
+
+```python
+import requests
+
+response = requests.post(
+    "https://api.cline.bot/api/v1/chat/completions",
+    headers={
+        "Authorization": "Bearer YOUR_API_KEY",
+        "Content-Type": "application/json",
+    },
+    json={
+        "model": "anthropic/claude-sonnet-4-6",
+        "messages": [{"role": "user", "content": "Hello!"}],
+        "stream": False,
+    },
+)
+
+data = response.json()
+print(data["choices"][0]["message"]["content"])
+```
+
+## Node.js / TypeScript
+
+### OpenAI SDK
+
+The [OpenAI Node.js SDK](https://github.com/openai/openai-node) works with the Cline API by setting `baseURL`:
+
+```typescript
+import OpenAI from "openai"
+
+const client = new OpenAI({
+  baseURL: "https://api.cline.bot/api/v1",
+  apiKey: "YOUR_API_KEY",
+})
+
+// Non-streaming
+const response = await client.chat.completions.create({
+  model: "anthropic/claude-sonnet-4-6",
+  messages: [{ role: "user", content: "Explain async/await in one sentence." }],
+})
+console.log(response.choices[0].message.content)
+```
+
+### Streaming in Node.js
+
+```typescript
+import OpenAI from "openai"
+
+const client = new OpenAI({
+  baseURL: "https://api.cline.bot/api/v1",
+  apiKey: "YOUR_API_KEY",
+})
+
+const stream = await client.chat.completions.create({
+  model: "anthropic/claude-sonnet-4-6",
+  messages: [{ role: "user", content: "Write a haiku about TypeScript." }],
+  stream: true,
+})
+
+for await (const chunk of stream) {
+  const content = chunk.choices[0]?.delta?.content
+  if (content) {
+    process.stdout.write(content)
+  }
+}
+console.log()
+```
+
+### Using fetch
+
+```typescript
+const response = await fetch("https://api.cline.bot/api/v1/chat/completions", {
+  method: "POST",
+  headers: {
+    Authorization: "Bearer YOUR_API_KEY",
+    "Content-Type": "application/json",
+  },
+  body: JSON.stringify({
+    model: "anthropic/claude-sonnet-4-6",
+    messages: [{ role: "user", content: "Hello!" }],
+    stream: false,
+  }),
+})
+
+const data = await response.json()
+console.log(data.choices[0].message.content)
+```
+
+## Cline CLI
+
+The [Cline CLI](/cli/cli-reference) is the fastest way to use the Cline API from your terminal. It handles authentication, streaming, and tool execution for you.
+
+### Setup
+
+```bash
+# Install
+npm install -g @anthropic-ai/cline
+
+# Authenticate with a Cline API key
+cline auth -p cline -k "YOUR_API_KEY" -m anthropic/claude-sonnet-4-6
+```
+
+### Run Tasks
+
+```bash
+# Simple prompt
+cline "Explain what a REST API is."
+
+# Pipe input
+cat README.md | cline "Summarize this document."
+
+# Use a specific model
+cline -m google/gemini-2.5-pro "Analyze this codebase."
+
+# YOLO mode for automation
+cline -y "Run tests and fix failures."
+```
+
+See the [CLI Reference](/cli/cli-reference) for all commands and options.
+
+## VS Code / JetBrains
+
+The Cline extension handles the API integration for you:
+
+1. Open the Cline panel in your editor
+2. Select **Cline** as the provider in the model picker
+3. Sign in with your Cline account
+4. Start chatting or give Cline a task
+
+Your API key is managed automatically. No manual configuration needed.
+
+For setup instructions, see [Installing Cline](/getting-started/installing-cline) and [Authorizing with Cline](/getting-started/authorizing-with-cline).
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Full endpoint reference with all parameters.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    API key management and security practices.
+  </Card>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models.
+  </Card>
+  <Card title="CLI Reference" icon="terminal" href="/cli/cli-reference">
+    Complete Cline CLI command reference.
+  </Card>
+</CardGroup>
diff --git a/docs/assets/Cline_Logo-complete_black.png b/docs/assets/Cline_Logo-complete_black.png
new file mode 100644
index 0000000..32aae1e
Binary files /dev/null and b/docs/assets/Cline_Logo-complete_black.png differ
diff --git a/docs/assets/Cline_Logo-complete_white.png b/docs/assets/Cline_Logo-complete_white.png
new file mode 100644
index 0000000..2aa18f2
Binary files /dev/null and b/docs/assets/Cline_Logo-complete_white.png differ
diff --git a/docs/assets/clinepass/clinepass-cli.png b/docs/assets/clinepass/clinepass-cli.png
new file mode 100644
index 0000000..b86a037
Binary files /dev/null and b/docs/assets/clinepass/clinepass-cli.png differ
diff --git a/docs/assets/clinepass/clinepass-ide-extension.png b/docs/assets/clinepass/clinepass-ide-extension.png
new file mode 100644
index 0000000..d770516
Binary files /dev/null and b/docs/assets/clinepass/clinepass-ide-extension.png differ
diff --git a/docs/assets/hooks/hook-controls.png b/docs/assets/hooks/hook-controls.png
new file mode 100644
index 0000000..078fa9f
Binary files /dev/null and b/docs/assets/hooks/hook-controls.png differ
diff --git a/docs/assets/hooks/hooks-collapsed-view.png b/docs/assets/hooks/hooks-collapsed-view.png
new file mode 100644
index 0000000..a592cfe
Binary files /dev/null and b/docs/assets/hooks/hooks-collapsed-view.png differ
diff --git a/docs/assets/hooks/hooks-empty-state.png b/docs/assets/hooks/hooks-empty-state.png
new file mode 100644
index 0000000..5095a66
Binary files /dev/null and b/docs/assets/hooks/hooks-empty-state.png differ
diff --git a/docs/assets/hooks/hooks-interface-with-dropdown.png b/docs/assets/hooks/hooks-interface-with-dropdown.png
new file mode 100644
index 0000000..fc8390e
Binary files /dev/null and b/docs/assets/hooks/hooks-interface-with-dropdown.png differ
diff --git a/docs/assets/hooks/new-hook-dropdown.png b/docs/assets/hooks/new-hook-dropdown.png
new file mode 100644
index 0000000..03617f9
Binary files /dev/null and b/docs/assets/hooks/new-hook-dropdown.png differ
diff --git a/docs/assets/jupyter-explain-improve-cell.gif b/docs/assets/jupyter-explain-improve-cell.gif
new file mode 100644
index 0000000..01d298b
Binary files /dev/null and b/docs/assets/jupyter-explain-improve-cell.gif differ
diff --git a/docs/assets/jupyter-generate-cell.gif b/docs/assets/jupyter-generate-cell.gif
new file mode 100644
index 0000000..8245f56
Binary files /dev/null and b/docs/assets/jupyter-generate-cell.gif differ
diff --git a/docs/assets/robot_panel_dark.png b/docs/assets/robot_panel_dark.png
new file mode 100644
index 0000000..36c3776
Binary files /dev/null and b/docs/assets/robot_panel_dark.png differ
diff --git a/docs/assets/robot_panel_light.png b/docs/assets/robot_panel_light.png
new file mode 100644
index 0000000..2f028e0
Binary files /dev/null and b/docs/assets/robot_panel_light.png differ
diff --git a/docs/assets/workos-invite-email.png b/docs/assets/workos-invite-email.png
new file mode 100644
index 0000000..78480b3
Binary files /dev/null and b/docs/assets/workos-invite-email.png differ
diff --git a/docs/best-practices/memory-bank.mdx b/docs/best-practices/memory-bank.mdx
new file mode 100644
index 0000000..c91d7b4
--- /dev/null
+++ b/docs/best-practices/memory-bank.mdx
@@ -0,0 +1,163 @@
+---
+title: "Memory Bank"
+sidebarTitle: "Memory Bank"
+description: "A structured documentation system that helps Cline maintain context across sessions."
+---
+
+Memory Bank is a documentation methodology that transforms Cline from a stateless assistant into a persistent development partner. Through structured markdown files, Cline can "remember" your project details across sessions.
+
+## Quick Setup
+
+1. Copy the [custom instructions below](#memory-bank-custom-instructions)
+2. Add them to a [Cline Rules file](/customization/cline-rules), such as `.clinerules/memory-bank.md`
+3. Ask Cline to "initialize memory bank"
+
+## How It Works
+
+Memory Bank files are regular markdown files in your project that both you and Cline can access. They're organized hierarchically to build a complete picture of your project:
+
+```text
+memory-bank/
+├── projectbrief.md      # Foundation document
+├── productContext.md    # Why this project exists
+├── activeContext.md     # Current work focus
+├── systemPatterns.md    # Architecture & patterns
+├── techContext.md       # Tech stack & setup
+└── progress.md          # Status & milestones
+```
+
+<Frame>
+	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(16).png" alt="Memory Bank file hierarchy showing projectbrief.md at the top flowing into productContext, systemPatterns, and techContext, which feed into activeContext and progress" />
+</Frame>
+
+## Core Files
+
+| File | Purpose |
+|------|---------|
+| `projectbrief.md` | Foundation document with core requirements and goals |
+| `productContext.md` | Why the project exists, problems it solves, UX goals |
+| `activeContext.md` | Current focus, recent changes, next steps (updates most frequently) |
+| `systemPatterns.md` | Architecture, design patterns, component relationships |
+| `techContext.md` | Tech stack, setup, constraints, dependencies |
+| `progress.md` | What works, what's left, known issues |
+
+## Key Commands
+
+- **"follow your custom instructions"** - Tells Cline to read Memory Bank and continue where you left off
+- **"initialize memory bank"** - Creates the initial structure for a new project
+- **"update memory bank"** - Triggers a full documentation review and update
+
+These work alongside Cline's built-in [slash commands](/core-workflows/using-commands). In particular, [`/newtask`](/core-workflows/using-commands#newtask) and [`/smol`](/core-workflows/using-commands#smol) help you manage context windows without losing progress.
+
+## Managing Context Windows
+
+Every AI model has a [context window](/core-workflows/task-management#context-window) that limits how much information it can process at once. As you work, this window fills with conversation history, file contents, and tool results. Memory Bank helps you preserve important knowledge when you need to free up space.
+
+### Manual approach
+
+When your context window fills up:
+
+1. Ask Cline to "update memory bank" to document the current state
+2. Start a new conversation
+3. Ask Cline to "follow your custom instructions"
+
+This preserves important context in your Memory Bank files before the window clears, letting you continue seamlessly in a fresh conversation.
+
+## Best Practices
+
+- Start with a basic project brief and let structure evolve
+- Let Cline help create the initial structure
+- `activeContext.md` changes most frequently; update it after each session
+- `progress.md` tracks milestones; review it when resuming work
+- Update after significant milestones or direction changes
+- Use [Cline Rules](/customization/cline-rules) to store the Memory Bank instructions per project
+
+---
+
+## Memory Bank Custom Instructions
+
+Copy this into a Cline Rules file (for example, `.clinerules/memory-bank.md`) or your global custom instructions:
+
+```markdown
+# Cline's Memory Bank
+
+I am Cline, an expert software engineer with a unique characteristic: my memory resets completely between sessions. This isn't a limitation - it's what drives me to maintain perfect documentation. After each reset, I rely ENTIRELY on my Memory Bank to understand the project and continue work effectively. I MUST read ALL memory bank files at the start of EVERY task - this is not optional.
+
+## Memory Bank Structure
+
+The Memory Bank consists of core files and optional context files, all in Markdown format. Files build upon each other in a clear hierarchy:
+
+### Core Files (Required)
+1. `projectbrief.md`
+   - Foundation document that shapes all other files
+   - Created at project start if it doesn't exist
+   - Defines core requirements and goals
+   - Source of truth for project scope
+
+2. `productContext.md`
+   - Why this project exists
+   - Problems it solves
+   - How it should work
+   - User experience goals
+
+3. `activeContext.md`
+   - Current work focus
+   - Recent changes
+   - Next steps
+   - Active decisions and considerations
+   - Important patterns and preferences
+   - Learnings and project insights
+
+4. `systemPatterns.md`
+   - System architecture
+   - Key technical decisions
+   - Design patterns in use
+   - Component relationships
+   - Critical implementation paths
+
+5. `techContext.md`
+   - Technologies used
+   - Development setup
+   - Technical constraints
+   - Dependencies
+   - Tool usage patterns
+
+6. `progress.md`
+   - What works
+   - What's left to build
+   - Current status
+   - Known issues
+   - Evolution of project decisions
+
+### Additional Context
+Create additional files/folders within memory-bank/ when they help organize:
+- Complex feature documentation
+- Integration specifications
+- API documentation
+- Testing strategies
+- Deployment procedures
+
+## Documentation Updates
+
+Memory Bank updates occur when:
+1. Discovering new project patterns
+2. After implementing significant changes
+3. When user requests with **update memory bank** (MUST review ALL files)
+4. When context needs clarification
+
+REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.
+```
+
+## FAQ
+
+**Custom instructions or Cline Rules?**
+Either works. Custom instructions apply globally across all projects. A [Cline Rules file](/customization/cline-rules) is project-specific and stored in your repo, which makes it easy to share with collaborators. You can also use [conditional rules](/customization/cline-rules#conditional-rules) to activate Memory Bank instructions only when working with `memory-bank/` files.
+
+**How often should I update?**
+After significant milestones or direction changes. For active development, every few sessions. You can also let [Auto Compact](/features/auto-compact) handle routine context management and reserve manual "update memory bank" for important checkpoints.
+
+**Does this work with other AI tools?**
+Yes. Memory Bank is a documentation methodology that works with any AI that can read docs. Commands may differ but the approach works across tools.
+
+**Different from README files?**
+Memory Bank provides structured, comprehensive documentation designed for AI context management, going beyond what a single README covers. It includes files for active context and progress tracking that change frequently, unlike a typical README.
diff --git a/docs/cli/agent-teams.mdx b/docs/cli/agent-teams.mdx
new file mode 100644
index 0000000..b9c6ee0
--- /dev/null
+++ b/docs/cli/agent-teams.mdx
@@ -0,0 +1,57 @@
+---
+title: "Agent Teams"
+sidebarTitle: "Agent Teams"
+description: "Coordinate multiple agents working together on complex tasks from the CLI."
+---
+<Warning>
+  This feature currently only applies to Cline SDK, CLI, and Kanban. This feature is not applicable on VSCode and JetBrains Extension for now.
+</Warning>
+
+
+Agent teams let you break complex work across multiple agents that coordinate through a shared task board. One agent acts as the coordinator, delegating subtasks to specialist agents.
+
+## Starting a Team
+
+```bash
+cline --team-name auth-sprint "Plan and implement user authentication with tests"
+```
+
+The `--team-name` flag enables team mode. The coordinator agent gets additional tools for spawning teammates and delegating tasks.
+
+## Resuming Team Work
+
+Team state persists across sessions. Resume where you left off:
+
+```bash
+cline --team-name auth-sprint "Continue with incomplete tasks"
+```
+
+## Interactive Mode
+
+In interactive mode, use the `/team` slash command:
+
+```
+/team Plan and implement a REST API with tests
+```
+
+## Team State
+
+Team state is stored at `~/.cline/data/teams/[team-name]/` and includes:
+
+- Task board with current tasks and status
+- Inter-agent mailbox
+- Mission log with activity history
+
+## Disabling Teams
+
+Teams are enabled by default. Disable them with:
+
+```bash
+cline --no-teams "your prompt"
+```
+
+## Sub-Agents
+
+For simpler delegation within a single session (no persistent state), use [sub-agents](/features/subagents). Sub-agents run in parallel for read-only research and return focused reports to the main agent.
+
+See the [SDK Multi-Agent Teams guide](/sdk/guides/multi-agent-teams) for the programmatic API.
diff --git a/docs/cli/cli-reference.mdx b/docs/cli/cli-reference.mdx
new file mode 100644
index 0000000..3c1985d
--- /dev/null
+++ b/docs/cli/cli-reference.mdx
@@ -0,0 +1,305 @@
+---
+title: "CLI Reference"
+description: "Complete command reference for Cline CLI including all commands, flags, and configuration options."
+---
+
+```bash
+cline --help           # Show all commands
+cline <command> --help # Show help for a specific command
+```
+
+## Synopsis
+
+```bash
+cline [options] [command] [prompt]
+```
+
+## Help Menu (Source of Truth)
+
+```text
+Usage: cline [options] [command] [prompt]
+
+Cline CLI - AI coding assistant in your terminal
+
+Arguments:
+  prompt                       Your prompt. Default to start in act mode with auto-approve enabled.
+
+Options:
+  -V, --version                Output the version number
+  -p, --plan                   Run in plan mode
+  --json                       Output messages as JSON instead of styled text
+  --auto-approve <boolean>     Set tool auto-approval for all tools (default: true)
+  -t, --timeout <seconds>      Optional timeout in seconds (default: 0 for no timeout)
+  -m, --model <model-id>       Model to use for the session with the selected provider
+  -v, --verbose                Show verbose output
+  -c, --cwd <path>             Working directory
+  --config <path>              Configuration directory (default: ~/.cline/data/settings)
+  --data-dir <path>            Use isolated local state at this directory path (default: ~/.cline)
+  --thinking <level>           Set reasoning effort level between none|low|medium|high|xhigh (default: medium)
+  --retries <count>            Maximum consecutive mistakes (retries) before halting
+  --hooks-dir <path>           Directory path to additional hooks for runtime hook injection (default: ~/.cline/hooks)
+  --acp                        Run in Agent Client Protocol (ACP) mode for editor integration
+  -i, --tui                    Open the terminal user interface (TUI) for interactive sessions
+  --id <session-id>            Resume an existing session by ID
+  -k, --key <api-key>          API key override for this run
+  -P, --provider <id>          Provider id (default: cline)
+  -s, --system <system-prompt> Override the default system prompt
+  -z, --zen                    Start a session that runs in the background hub
+  -h, --help                   display help for command
+
+Commands:
+  auth [options] [provider]    Authenticate a provider and configure what model is used
+  config [options]             Show current configuration
+  connect [options] [adapter]  Connect to an editor or IDE adapter
+  mcp                          Manage MCP servers
+  dev                          Developer tools and utilities
+  doctor                       Diagnose and fix configuration issues
+  history|h [options]          List session history or manage saved sessions
+  hook                         Handle a hook payload from stdin
+  plugin                       Manage Cline Plugins
+  schedule                     Manage scheduled tasks
+  hub                          Manage the local hub daemon
+  update [options]             Check for updates and install if available
+  version                      Show Cline CLI version number
+  kanban                       Launch the kanban app and exit
+```
+
+## Global Options
+
+| Option | Description |
+|--------|-------------|
+| `-V, --version` | Output the version number |
+| `-p, --plan` | Run in plan mode |
+| `--json` | Output messages as JSON instead of styled text |
+| `--auto-approve <boolean>` | Set tool auto-approval for all tools (default: `true`) |
+| `-t, --timeout <seconds>` | Optional timeout in seconds (default: `0` for no timeout) |
+| `-m, --model <model-id>` | Model to use for the session with the selected provider |
+| `-v, --verbose` | Show verbose output |
+| `-c, --cwd <path>` | Working directory |
+| `--config <path>` | Configuration directory (default: `~/.cline/data/settings`) |
+| `--data-dir <path>` | Use isolated local state at this directory path (default: `~/.cline`) |
+| `--thinking <level>` | Set reasoning effort: `none\|low\|medium\|high\|xhigh` (default `medium`) |
+| `--retries <count>` | Maximum consecutive mistakes (retries) before halting |
+| `--hooks-dir <path>` | Directory path to additional hooks for runtime hook injection (default: `~/.cline/hooks`) |
+| `--acp` | Run in Agent Client Protocol (ACP) mode for editor integration |
+| `-i, --tui` | Open the terminal user interface (TUI) for interactive sessions |
+| `--id <session-id>` | Resume an existing session by ID |
+| `-k, --key <api-key>` | API key override for this run |
+| `-P, --provider <id>` | Provider id (default: `cline`) |
+| `-s, --system <system-prompt>` | Override the default system prompt |
+| `-z, --zen` | Start a session that runs in the background hub |
+| `-h, --help` | Display help for command |
+
+## Commands
+
+### `cline` (default)
+
+Start a task or enter interactive mode.
+
+```bash
+cline
+cline "your prompt here"
+cline "Run tests and fix failures"
+echo "prompt" | cline
+```
+
+### `auth [options] [provider]`
+
+Configure authentication with an AI provider.
+
+```bash
+cline auth
+```
+
+### `config [options]`
+
+Show current configuration.
+
+```bash
+cline config
+```
+
+### `connect [options] [adapter]`
+
+Connect to messaging platforms. See [Connectors](/cli/connectors).
+
+```bash
+cline connect
+cline connect [adapter]
+```
+
+### `mcp`
+
+Manage MCP servers. See [MCP](/mcp/mcp-overview).
+
+```bash
+cline mcp
+```
+
+### `dev`
+
+Developer tools and utilities.
+
+```bash
+cline dev
+```
+
+### `doctor`
+
+Diagnose and fix configuration issues.
+
+```bash
+cline doctor
+```
+
+### `history|h [options]`
+
+List session history or manage saved sessions.
+
+```bash
+cline history
+cline h
+```
+
+### `hook`
+
+Handle a hook payload from stdin.
+
+```bash
+cat payload.json | cline hook
+```
+
+### `plugin`
+
+Manage Cline plugins. Install plugins from file URLs, npm, git repositories, or local paths. See [Plugins](/customization/plugins) for full details and the plugin manifest format.
+
+```bash
+cline plugin install <source>  # Install a plugin
+cline plugin i <source>        # Shorthand alias
+```
+
+| Option | Description |
+|--------|-------------|
+| `--npm` | Treat source as an npm package |
+| `--git` | Treat source as a git repository |
+| `--force` | Replace an existing install for the same source |
+| `--json` | Output result as JSON |
+| `--cwd <path>` | Install to `<path>/.cline/plugins` instead of the global directory |
+
+Try it with the [TypeScript Navigation Plugin](https://github.com/cline/typescript-lsp-plugin):
+
+```bash
+cline plugin install https://github.com/cline/typescript-lsp-plugin.git
+```
+
+### `schedule`
+
+Manage scheduled agents. See [Scheduling](/cli/scheduling).
+
+```bash
+cline schedule
+```
+
+### `hub`
+
+Manage the local hub daemon.
+
+```bash
+cline hub
+```
+
+### `update [options]`
+
+Check for updates and install if available.
+
+```bash
+cline update
+```
+
+### `version`
+
+Show Cline CLI version number.
+
+```bash
+cline version
+cline -V
+```
+
+### `kanban`
+
+Launch the kanban app and exit.
+
+```bash
+cline kanban
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `CLINE_DATA_DIR` | Custom configuration directory (replaces `~/.cline/data/`) |
+| `CLINE_HUB_ADDRESS` | Override hub address (default: `127.0.0.1:25463`) |
+| `CLINE_SESSION_BACKEND_MODE` | Force backend mode (`local`, `hub`, `remote`, `auto`) |
+| `CLINE_SANDBOX_DATA_DIR` | Sandbox session storage directory |
+| `CLINE_SANDBOX` | Enable sandbox mode |
+| `CLINE_HOOKS_DIR` | Additional hooks directory |
+| `CLINE_BUILD_ENV` | Set to `development` for debug features |
+| `CLINE_DEBUG_PORT_BASE` | Base port for Node.js inspector |
+| `CLINE_COMMAND_PERMISSIONS` | JSON policy restricting shell commands (see below) |
+
+### CLINE_COMMAND_PERMISSIONS
+
+Restrict which shell commands the agent can execute:
+
+```bash
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *"], "deny": ["rm -rf *", "sudo *"]}'
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `allow` | `string[]` | Glob patterns for allowed commands. If set, only matching commands are permitted. |
+| `deny` | `string[]` | Glob patterns for denied commands. Deny rules always take precedence. |
+| `allowRedirects` | `boolean` | Whether to allow shell redirects (`>`, `>>`, `<`). Default: `false`. |
+
+## JSON Output Format
+
+When using `--json`, each message is a JSON object on its own line:
+
+```json
+{"type": "say", "text": "I'll create the file now.", "ts": 1760501486669, "say": "text"}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | `"ask"` or `"say"` | Message category |
+| `text` | `string` | Message content |
+| `ts` | `number` | Unix timestamp in milliseconds |
+| `say` | `string` | Subtype when `type` is `"say"` |
+| `ask` | `string` | Subtype when `type` is `"ask"` |
+| `reasoning` | `string` | Model reasoning (if available) |
+| `partial` | `boolean` | `true` while streaming |
+
+## Configuration Files
+
+```
+~/.cline/
+  data/
+    settings/
+      providers.json             # API keys and provider config
+      rules/                     # Global rules
+      skills/                    # Global skills
+    teams/                       # Team state
+    sessions/                    # Session database (SQLite)
+    logs/
+      hub-daemon.log             # Hub logs
+  plugins/                       # Global plugins
+    _installed/                  # Managed by `cline plugin install`
+
+.cline/                          # Project root
+  rules/                         # Project rules
+  skills/                        # Project skills
+  hooks/                         # Lifecycle hooks
+  plugins/                       # Project plugins
+  mcp.json                       # MCP server config
+  agents.yaml                    # Agent definitions
+```
diff --git a/docs/cli/connectors.mdx b/docs/cli/connectors.mdx
new file mode 100644
index 0000000..317781d
--- /dev/null
+++ b/docs/cli/connectors.mdx
@@ -0,0 +1,286 @@
+---
+title: "Connectors"
+sidebarTitle: "Connectors"
+description: "Connect the CLI to Telegram, Slack, Discord, Google Chat, WhatsApp, etc."
+---
+<Warning>
+  This feature currently only applies to Cline CLI.
+</Warning>
+
+Connectors let you chat with your agent from messaging platforms. Each incoming message creates or continues an agent session, and the agent's response is sent back to the conversation.
+
+## Setup Wizard
+
+Run `cline connect` to open an interactive wizard that guides you through platform selection, credential entry, security configuration, and advanced options (provider, model, system prompt, agent mode).
+
+```bash
+cline connect
+```
+
+## Supported Platforms
+
+| Platform | Direct Command | Required Credentials |
+|----------|---------------|---------------------|
+| Telegram | `cline connect telegram` | Bot token |
+| Slack | `cline connect slack` | Bot token plus webhook signing secret/base URL or socket app token |
+| Discord | `cline connect discord` | Application ID, bot token, public key, base URL |
+| Google Chat | `cline connect gchat` | Service account credentials JSON, base URL |
+| WhatsApp | `cline connect whatsapp` | Phone number ID, access token, app secret, verify token, base URL |
+| Linear | `cline connect linear` | API key, webhook signing secret, base URL |
+
+## Telegram
+
+<Steps>
+  <Step title="Create a Telegram bot">
+    Open Telegram and start a chat with [@BotFather](https://t.me/BotFather). Send `/newbot` and follow the prompts:
+
+    1. Enter a display name (e.g., "Cline")
+    2. Enter a username ending in `bot` (e.g., `cline_myname_bot`). Must be unique across Telegram.
+    3. BotFather responds with your bot token (looks like `7123456789:AAH...`)
+  </Step>
+
+  <Step title="Start the connector">
+    ```bash
+    cline connect telegram -k <BOT-TOKEN>
+    ```
+
+    The connector discovers the bot username from the token. Use `--bot-username` only if you need to override it.
+  </Step>
+
+  <Step title="Chat with your bot">
+    Open Telegram, search for your bot's username, and send a message. The agent processes it and replies in the chat.
+  </Step>
+</Steps>
+
+### Security
+
+By default, anyone who finds your bot can message it and it will execute tasks on your machine. The `cline connect` wizard asks whether to restrict Telegram access and can configure this for you.
+
+<Steps>
+  <Step title="Get your Telegram user ID">
+    Message [@userinfobot](https://t.me/userinfobot) on Telegram. It replies with your numeric user ID immediately.
+  </Step>
+
+  <Step title="Use the wizard">
+    ```bash
+    cline connect
+    ```
+
+    Choose Telegram, enter the bot token, answer yes to access restriction, then enter your user ID.
+  </Step>
+
+  <Step title="Or pass the flag manually">
+    Replace `12345` with your Telegram user ID:
+
+    ```bash
+    cline connect telegram -k <BOT-TOKEN> \
+      --allowed-user-id 12345
+    ```
+  </Step>
+</Steps>
+
+Use `--hook-command` only when you need custom access logic. The hook receives each incoming message with sender info via stdin. Your script returns `{"action": "allow"}` or `{"action": "deny", "message": "reason"}`. Without `--allowed-user-id` or `--hook-command`, everything is auto-approved, so restrict Telegram bots that can reach a running Cline instance.
+
+## Slack
+
+Slack supports webhook mode and socket mode. Each Slack thread maps to an agent session, so the agent maintains conversation context within a thread.
+
+Webhook mode requires a bot token, signing secret, and public base URL:
+
+```bash
+cline connect slack \
+  --bot-token <BOT-TOKEN> \
+  --signing-secret <SECRET> \
+  --base-url <URL>
+```
+
+Configure the Slack app's event subscription and interactivity request URLs to `<URL>/api/webhooks/slack`.
+
+Socket mode requires a bot token and an app-level token with the `connections:write` scope:
+
+```bash
+cline connect slack \
+  --bot-token <BOT-TOKEN> \
+  --app-token <APP-LEVEL-TOKEN>
+```
+
+Enable Socket Mode in the Slack app. Socket mode does not need a public request URL and is single-workspace only.
+
+## Discord
+
+Requires a Discord application ID, bot token, public key, and public base URL.
+The connector listens for Discord interactions at `/api/webhooks/discord` and
+also starts a Discord gateway listener for mentions, replies, reactions, and DMs.
+
+<Steps>
+  <Step title="Create a Discord application and bot">
+    Open [Discord Developer Portal](https://discord.com/developers/applications)
+    and create an application.
+
+    1. In **General Information**, copy the **Application ID** and **Public Key**.
+    2. In **Bot**, create a bot if one does not exist, then reset and copy the bot token.
+    3. Enable **Message Content Intent** if you want normal messages, replies, and DMs to include text content.
+  </Step>
+
+  <Step title="Expose a public base URL">
+    For local development, use a tunnel such as ngrok:
+
+    ```bash
+    ngrok http 8788
+    ```
+
+    Copy the HTTPS forwarding URL. This is your connector base URL, for example
+    `https://1234-5678.ngrok-free.app`.
+  </Step>
+
+  <Step title="Start the connector">
+    ```bash
+    cline connect discord \
+      --application-id <ID> \
+      --bot-token <TOKEN> \
+      --public-key <KEY> \
+      --base-url <URL> \
+      --port 8788 \
+      --cwd /path/to/repo \
+      --enable-tools
+    ```
+
+    `--app-id` is an alias for `--application-id`, and `--token` is an alias for
+    `--bot-token`.
+
+    `--enable-tools` allows the agent to inspect files, run commands, edit code,
+    and prepare PRs from Discord. Omit it if the bot should only chat.
+  </Step>
+
+  <Step title="Configure the Discord interactions endpoint">
+    In the Discord Developer Portal, set **Interactions Endpoint URL** to:
+
+    ```text
+    <base-url>/api/webhooks/discord
+    ```
+
+    For example:
+
+    ```text
+    https://1234-5678.ngrok-free.app/api/webhooks/discord
+    ```
+
+    You can verify the connector is reachable with:
+
+    ```bash
+    curl <base-url>/health
+    ```
+  </Step>
+
+  <Step title="Invite the bot to a test server">
+    In **OAuth2 > URL Generator**, select the `bot` and
+    `applications.commands` scopes, then give the bot permission to send
+    messages and read message history. Open the generated URL and install the bot
+    into your test server.
+  </Step>
+
+  <Step title="Chat with the bot">
+    Mention the bot in a server channel, reply in a bot-created thread, or DM the
+    bot. Each Discord conversation keeps its own agent session and context.
+  </Step>
+</Steps>
+
+### Discord Command Reference
+
+Send these commands in Discord:
+
+| Command | Description |
+|---------|-------------|
+| `/help` or `/start` | Show connector help |
+| `/new` or `/clear` | Start a fresh session for this Discord conversation |
+| `/whereami` | Show thread, channel, DM state, `cwd`, `workspaceRoot`, tools, and yolo state |
+| `/tools [on\|off\|toggle]` | View or change whether repo/file/shell tools are allowed |
+| `/yolo [on\|off\|toggle]` | View or change automatic tool approval |
+| `/cwd [path]` | View or change the working directory for this conversation |
+| `/schedule create/list/trigger/delete` | Manage scheduled workflows targeting this conversation |
+| `/abort` | Stop the current task |
+| `/exit` | Stop the connector |
+
+Normal messages are treated as agent tasks. If a task is already running, normal
+messages steer the active task.
+
+### Discord Security
+
+By default, anyone who can reach the bot can ask it to run tasks. Restrict access
+with `--hook-command`. The hook receives the Discord user as a participant key
+such as `discord:user:123456789`.
+
+```bash
+cline connect discord \
+  --application-id <ID> \
+  --bot-token <TOKEN> \
+  --public-key <KEY> \
+  --base-url <URL> \
+  --hook-command 'jq -r ".payload.actor.participantKey" | grep -q "discord:user:123456789" && echo "{\"action\":\"allow\"}" || echo "{\"action\":\"deny\",\"message\":\"unauthorized\"}"'
+```
+
+## Google Chat
+
+Requires a service account credentials JSON file and public base URL.
+
+```bash
+cline connect gchat --credentials <JSON> --base-url <URL>
+```
+
+## WhatsApp
+
+Requires a phone number ID, access token, app secret, webhook verify token, and public base URL.
+
+```bash
+cline connect whatsapp --phone-id <ID> --token <TOKEN> --app-secret <SECRET> --base-url <URL>
+```
+
+## Linear
+
+Requires an API key, webhook signing secret, and public base URL.
+
+```bash
+cline connect linear --api-key <KEY> --signing-secret <SECRET> --base-url <URL>
+```
+
+## Managing Connectors
+
+```bash
+# Stop all connectors
+cline connect --stop
+
+# Stop a specific connector
+cline connect telegram --stop
+```
+
+## Hook Command Protocol
+
+The `--hook-command` pattern works across all connectors. The script receives a JSON payload via stdin:
+
+```json
+{
+  "payload": {
+    "actor": {
+      "participantKey": "telegram:id:12345",
+      "displayName": "User Name"
+    },
+    "message": "The incoming message text"
+  }
+}
+```
+
+Return `{"action": "allow"}` or `{"action": "deny", "message": "reason"}`.
+
+## Running Multiple Connectors
+
+Multiple connectors can run simultaneously. They all share the same hub:
+
+```bash
+# Terminal 1
+cline connect telegram -k $TELEGRAM_TOKEN
+
+# Terminal 2
+cline connect slack --bot-token $SLACK_TOKEN --signing-secret $SECRET --base-url $URL
+```
+
+Connectors require the hub. Start it with `cline hub start` if it doesn't auto-start.
diff --git a/docs/cli/samples/github-integration.mdx b/docs/cli/samples/github-integration.mdx
new file mode 100644
index 0000000..1816209
--- /dev/null
+++ b/docs/cli/samples/github-integration.mdx
@@ -0,0 +1,304 @@
+---
+title: "GitHub Actions Integration"
+description: "Automatically respond to GitHub issues by mentioning @cline in comments using Cline CLI in GitHub Actions."
+---
+
+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.
+
+
+<Note>
+**New to Cline CLI?** This sample assumes you understand Cline CLI basics and have completed the [Installation Guide](https://docs.cline.bot/getting-started/installing-cline). If you're new to Cline CLI, we recommend starting with the [GitHub RCA sample](./github-issue-rca) first, as it's simpler and will help you understand the fundamentals before setting up GitHub Actions.
+</Note>
+
+## The Workflow
+
+Trigger Cline by mentioning `@cline` in any issue comment:
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/ss0a-comment.png" alt="Issue comment with @cline mention" width="600" />
+</Frame>
+
+Cline's automated analysis appears as a new comment, with insights drawn from your actual codebase:
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/ss0b-final.png" alt="Automated analysis response from Cline" width="600" />
+</Frame>
+
+The entire investigation runs autonomously in GitHub Actions - from file exploration to posting results.
+
+Let's configure your repository.
+
+## Prerequisites
+
+Before you begin, you'll need:
+
+- **Cline CLI knowledge** - Completed the [Installation Guide](https://docs.cline.bot/getting-started/installing-cline) and understand basic usage
+- **GitHub repository** - With admin access to configure Actions and secrets
+- **GitHub Actions familiarity** - Basic understanding of workflows and CI/CD
+- **API provider account** - OpenRouter, Anthropic, or similar with API key
+
+## Setup
+
+### 1. Copy the Workflow File
+
+
+
+Copy the workflow file from this sample to your repository. The workflow file must be placed in the `.github/workflows/` directory in your repository root for GitHub Actions to detect and run it. In this case, we'll name it `cline-responder.yml`.
+
+```bash
+# In your repository root
+mkdir -p .github/workflows
+curl -o .github/workflows/cline-responder.yml https://raw.githubusercontent.com/cline/cline/main/src/samples/cli/github-integration/cline-responder.yml
+```
+
+Alternatively, you can copy the full workflow file directly into `.github/workflows/cline-responder.yml`:
+
+<Accordion title="Click to view the complete cline-responder.yml workflow">
+```yaml
+name: Cline Issue Assistant
+
+on:
+  issue_comment:
+    types: [created, edited]
+
+permissions:
+  issues: write
+
+jobs:
+  respond:
+    runs-on: ubuntu-latest
+    environment: cline-actions
+    steps:
+      - name: Check for @cline mention
+        id: detect
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const body = context.payload.comment?.body || "";
+            const isPR = !!context.payload.issue?.pull_request;
+            const hit = body.toLowerCase().includes("@cline");
+            core.setOutput("hit", (!isPR && hit) ? "true" : "false");
+            core.setOutput("issue_number", String(context.payload.issue?.number || ""));
+            core.setOutput("issue_url", context.payload.issue?.html_url || "");
+            core.setOutput("comment_body", body);
+
+      - name: Checkout repository
+        if: steps.detect.outputs.hit == 'true'
+        uses: actions/checkout@v4
+
+      # Node v20+ is needed for Cline CLI on GitHub Actions Linux
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - name: Install Cline CLI
+        if: steps.detect.outputs.hit == 'true'
+        run: npm install -g cline
+
+      - name: Configure Cline Authentication
+        if: steps.detect.outputs.hit == 'true'
+        env:
+          CLINE_DIR: ${{ runner.temp }}/cline
+        run: |
+          # Configure API key using the auth command
+          cline auth --provider openrouter --apikey "${{ secrets.OPENROUTER_API_KEY }}"
+
+      - name: Download analyze script
+        if: steps.detect.outputs.hit == 'true'
+        run: |
+          export GITORG="YOUR-GITHUB-ORG"
+          export GITREPO="YOUR-GITHUB-REPO"
+
+          curl -L https://raw.githubusercontent.com/${GITORG}/${GITREPO}/refs/heads/main/git-scripts/analyze-issue.sh -o analyze-issue.sh
+          chmod +x analyze-issue.sh
+
+      - name: Run analysis
+        if: steps.detect.outputs.hit == 'true'
+        id: analyze
+        env:
+          ISSUE_URL: ${{ steps.detect.outputs.issue_url }}
+          COMMENT: ${{ steps.detect.outputs.comment_body }}
+        run: |
+          set -euo pipefail
+          
+          RESULT=$(./analyze-issue.sh "${ISSUE_URL}" "Analyze this issue. The user asked: ${COMMENT}")
+          
+          {
+            echo 'result<<EOF'
+            printf "%s\n" "$RESULT"
+            echo 'EOF'
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Post response
+        if: steps.detect.outputs.hit == 'true'
+        uses: actions/github-script@v7
+        env:
+          ISSUE_NUMBER: ${{ steps.detect.outputs.issue_number }}
+          RESULT: ${{ steps.analyze.outputs.result }}
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: Number(process.env.ISSUE_NUMBER),
+              body: process.env.RESULT || "(no output)"
+            });
+```
+</Accordion>
+
+<Warning>
+**You MUST edit the workflow file before committing!**
+
+Open `.github/workflows/cline-responder.yml` and update the "Download analyze script" step within the workflow to specify your GitHub organization and repository where the analysis script is stored:
+
+```yaml
+export GITORG="YOUR-GITHUB-ORG"      # Change this!
+export GITREPO="YOUR-GITHUB-REPO"    # Change this!
+```
+
+**Example:** If your repository is `github.com/acme/myproject`, set:
+```yaml
+export GITORG="acme"
+export GITREPO="myproject"
+```
+
+This tells the workflow where to download the analysis script from your repository after you commit it in step 3.
+</Warning>
+
+The workflow will look for new or updated issues, check for `@cline` mentions, and then
+start up the Cline CLI to dig into the issue, providing feedback as a reply to the issue.
+
+### 2. Configure API Keys
+
+Add your AI provider API keys as repository secrets:
+
+1. Go to your GitHub repository
+2. Navigate to **Settings** → **Environment** and Add a new environment.
+
+   <Frame>
+     <img src="https://storage.googleapis.com/cline_public_images/ss01-environment.png" alt="Navigate to Actions secrets" width="600" />
+   </Frame>
+
+   Make sure to name it "cline-actions" so that it matches the `environment`
+   value at the top of the `cline-responder.yml` file.
+
+3. Click **New repository secret**
+4. Add a secret for the `OPENROUTER_API_KEY` with a value of an API key from
+   [openrouter.com](https://openrouter.com).
+
+   <Frame>
+     <img src="https://storage.googleapis.com/cline_public_images/ss02-api-key.png" alt="Add API key secret" width="600" />
+   </Frame>
+
+5. Verify your secret is configured:
+
+   <Frame>
+     <img src="https://storage.googleapis.com/cline_public_images/ss03-ready.png" alt="API key configured" width="600" />
+   </Frame>
+
+Now you're ready to supply Cline with the credentials it needs in a GitHub Action.
+
+### 3. Add Analysis Script
+
+Add the analysis script from the `github-issue-rca` sample to your repository. **First, you'll need to create a `git-scripts` directory in your repository root where the script will be located.** Choose one of these options:
+
+**Option A: Download directly (Recommended)**
+
+```bash
+# In your repository root, create the directory and download the script
+mkdir -p git-scripts
+curl -o git-scripts/analyze-issue.sh https://raw.githubusercontent.com/cline/cline/main/src/samples/cli/github-issue-rca/analyze-issue.sh
+chmod +x git-scripts/analyze-issue.sh
+```
+
+**Option B: Manual copy-paste**
+
+Create the directory and file manually, then paste the script content:
+
+```bash
+# In your repository root
+mkdir -p git-scripts
+# Create and edit the file with your preferred editor
+nano git-scripts/analyze-issue.sh  # or use vim, code, etc.
+```
+
+<Accordion title="Click to view the complete analyze-issue.sh script">
+```bash
+#!/bin/bash
+# Analyze a GitHub issue using Cline CLI
+
+if [ -z "$1" ]; then
+    echo "Usage: $0 <github-issue-url> [prompt]"
+    echo "Example: $0 https://github.com/owner/repo/issues/123"
+    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause of this issue?'"
+    exit 1
+fi
+
+# Gather the args
+ISSUE_URL="$1"
+PROMPT="${2:-What is the root cause of this issue?}"
+
+# Ask Cline for its analysis, showing only the summary
+cline --auto-approve true --json "$PROMPT: $ISSUE_URL" | \
+    jq -r 'select(.type == "agent_event" and .event.type == "done") | .event.text' | \
+    sed 's/\\n/\n/g'
+```
+
+After pasting the script content, make it executable:
+```bash
+chmod +x git-scripts/analyze-issue.sh
+```
+</Accordion>
+
+This analysis script calls Cline to execute a prompt on a GitHub issue,
+summarizing the output to populate the reply to the issue.
+
+### 4. Commit and Push
+
+```bash
+git add .github/workflows/cline-responder.yml
+git add git-scripts/analyze-issue.sh
+git commit -m "Add Cline issue assistant workflow"
+git push
+```
+
+## Usage
+
+Once set up, simply mention `@cline` in any issue comment:
+
+```text
+@cline what's causing this error?
+
+@cline analyze the root cause
+
+@cline what are the security implications?
+```
+
+GitHub Actions will:
+1. Detect the `@cline` mention
+2. Start a Cline CLI instance
+3. Download the analysis script
+4. Analyze the issue using Act mode with auto-approval enabled
+5. Post Cline's analysis as a new comment
+
+**Note**: The workflow only triggers on issue comments, not pull request
+comments.
+
+## How It Works
+
+The workflow (`cline-responder.yml`):
+
+1. **Triggers** on issue comments (created or edited)
+2. **Detects** `@cline` mentions (case-insensitive)
+3. **Installs** Cline CLI globally using npm
+4. **Configures** authentication using `cline auth --provider openrouter --apikey ...`
+6. **Downloads** the reusable `analyze-issue.sh` script from the
+   `github-issue-rca` sample
+7. **Runs** analysis in Cline CLI
+8. **Posts** the analysis result as a comment
+
+## Related Samples
+
+- **[github-issue-rca](./github-issue-rca)**: The reusable script that powers this integration
diff --git a/docs/cli/samples/github-issue-rca.mdx b/docs/cli/samples/github-issue-rca.mdx
new file mode 100644
index 0000000..7d72048
--- /dev/null
+++ b/docs/cli/samples/github-issue-rca.mdx
@@ -0,0 +1,340 @@
+---
+title: "GitHub Issue RCA Sample"
+description: "Automated GitHub issue analysis using Cline CLI to identify root causes."
+---
+
+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>
+**New to Cline CLI?** This sample assumes you have already completed the [Installation Guide](https://docs.cline.bot/getting-started/installing-cline) and authenticated with `cline auth`. If you haven't set up Cline CLI yet, please start there first.
+</Note>
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/cli-rca.gif" alt="CLI Root Cause Analysis Demo" width="600" />
+</Frame>
+
+## Prerequisites
+
+This sample assumes you have already:
+
+- **Cline CLI** installed and authenticated ([Installation Guide](https://docs.cline.bot/getting-started/installing-cline))
+- **At least one AI model provider** configured (e.g., OpenRouter, Anthropic, OpenAI)
+- **Basic familiarity** with Cline CLI commands
+
+Additionally, you'll need:
+
+- **GitHub CLI** (`gh`) installed and authenticated
+- **jq** installed for JSON parsing
+- **bash** shell (or compatible shell)
+
+### Installation Instructions
+
+#### macOS
+
+<Note>
+These instructions require [Homebrew](https://brew.sh/) to be installed. If you don't have Homebrew, install it first by running:
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+```
+</Note>
+
+```bash
+# Install GitHub CLI
+brew install gh
+
+# Install jq
+brew install jq
+
+# Authenticate with GitHub
+gh auth login
+```
+
+#### Linux
+
+```bash
+# Install GitHub CLI (Debian/Ubuntu)
+sudo apt install gh
+
+# Or for other Linux distributions, see: https://cli.github.com/manual/installation
+
+# Install jq (Debian/Ubuntu)
+sudo apt install jq
+
+# Authenticate with GitHub
+gh auth login
+```
+
+## Getting the Script
+
+**Option 1: Download directly with curl**
+```bash
+curl -O https://raw.githubusercontent.com/cline/cline/main/src/samples/cli/github-issue-rca/analyze-issue.sh
+```
+
+**Option 2: Copy the full script**
+
+<Accordion title="Click to view the complete analyze-issue.sh script">
+
+```bash
+#!/bin/bash
+# Analyze a GitHub issue using Cline CLI
+
+if [ -z "$1" ]; then
+    echo "Usage: $0 <github-issue-url> [prompt]"
+    echo "Example: $0 https://github.com/owner/repo/issues/123"
+    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause of this issue?'"
+    exit 1
+fi
+
+# Gather the args
+ISSUE_URL="$1"
+PROMPT="${2:-What is the root cause of this issue?}"
+# Ask Cline for its analysis, showing only the summary
+cline --auto-approve true --json "$PROMPT: $ISSUE_URL" | \
+    jq -r 'select(.type == "agent_event" and .event.type == "done") | .event.text' | \
+    sed 's/\\n/\n/g'
+```
+
+</Accordion>
+
+<Note>
+**After downloading or creating the script**, make it executable by running:
+```bash
+chmod +x analyze-issue.sh
+```
+</Note>
+
+## Quick Usage Examples
+
+### Basic Usage
+
+Run this command in your terminal from the directory where you saved the script to analyze an issue with the default root cause prompt:
+
+```bash
+./analyze-issue.sh https://github.com/owner/repo/issues/123
+```
+
+This will:
+- Fetch issue #123 from the repository
+- Analyze the issue to identify root causes
+- Provide detailed analysis with recommendations
+
+### Custom Analysis Prompt
+
+Ask specific questions about the issue:
+
+```bash
+./analyze-issue.sh https://github.com/owner/repo/issues/456 "What is the security impact?"
+```
+
+<Note>
+The script will automatically handle everything: fetching the issue, analyzing it with Cline, and displaying the results. The analysis typically takes 30-60 seconds depending on the issue complexity.
+</Note>
+
+## How It Works
+
+Let's analyze each component of the script to understand how it works.
+
+### Argument Validation
+
+The script validates input and provides usage instructions:
+
+```bash
+if [ -z "$1" ]; then
+    echo "Usage: $0 <github-issue-url> [prompt]"
+    echo "Example: $0 https://github.com/owner/repo/issues/123"
+    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause?'"
+    exit 1
+fi
+```
+
+**Key Points:**
+- Validates required GitHub issue URL
+- Shows clear usage examples
+- Supports optional custom prompt
+
+### Argument Parsing
+
+The script extracts and sets up the arguments:
+
+```bash
+# Gather the args
+ISSUE_URL="$1"
+PROMPT="${2:-What is the root cause of this issue?}"
+```
+
+**Explanation:**
+- `ISSUE_URL="$1"` - First argument is always the issue URL
+- `PROMPT="${2:-...}"` - Second argument is optional, defaults to root cause analysis
+- The SDK CLI runs the task directly, so no address flag is required.
+
+### The Core Analysis Pipeline
+
+This is where the magic happens:
+
+```bash
+# Ask Cline for its analysis, showing only the summary
+cline --auto-approve true --json "$PROMPT: $ISSUE_URL" | \
+    jq -r 'select(.type == "agent_event" and .event.type == "done") | .event.text' | \
+    sed 's/\\n/\n/g'
+```
+
+<Accordion title="Pipeline Breakdown: Understanding Each Component">
+
+**1. `cline --auto-approve true --json "$PROMPT: $ISSUE_URL"`**
+   - `cline` is the Cline CLI binary
+   - Act mode is the default for prompt runs
+   - `--auto-approve true` allows tool use without interactive prompts
+   - `--json` emits newline-delimited JSON for parsing
+   - Constructs prompt with issue URL
+
+**2. `jq -r 'select(.type == "agent_event" and .event.type == "done") | .event.text'`**
+   - Filters for the final agent `done` event
+   - Extracts the final text field
+   - `-r` outputs raw strings (no JSON quotes)
+
+**3. `sed 's/\\n/\n/g'`**
+   - Converts escaped newlines to actual newlines
+   - Makes output readable
+
+</Accordion>
+
+## Sample Output
+
+Here's an example analyzing a real Flutter issue:
+
+```bash
+$ ./analyze-issue.sh https://github.com/csells/flutter_counter/issues/2
+```
+
+**Output:**
+
+```markdown
+**Root Cause Analysis of Issue #2: "setState isn't cutting it"**
+
+After examining the GitHub issue and analyzing the Flutter counter codebase, 
+I've identified the root cause of why setState() is insufficient for this 
+project's needs:
+
+## Current Implementation Problems
+
+The current Flutter counter app uses setState() for state management, which 
+has several limitations:
+
+1. **Local State Only**: setState() only works within a single widget, making 
+   it difficult to share state across the app
+2. **Rebuild Overhead**: Every setState() call rebuilds the entire widget tree, 
+   causing performance issues with complex UIs
+3. **No State Persistence**: State is lost when the widget is disposed
+4. **Testing Challenges**: setState-based logic is tightly coupled to the UI, 
+   making unit testing difficult
+
+## Why This Matters
+
+As the app grows beyond a simple counter, these limitations become critical:
+- Multiple screens need to access the count
+- State needs to persist across navigation
+- Business logic should be testable independently
+- UI should only rebuild when necessary
+
+## Recommended Solutions
+
+The issue mentions "Provider or Bloc" - both are excellent alternatives:
+
+1. **Provider**: Simple, lightweight state management using InheritedWidget
+   - Easy migration path from setState
+   - Good for small to medium apps
+   - Official Flutter recommendation
+
+2. **Bloc**: More structured approach with clear separation between events, 
+   states, and business logic
+   - Better for complex apps
+   - Excellent testability
+   - Clear architectural patterns
+
+3. **Riverpod**: Modern alternative to Provider with better performance and 
+   developer experience
+   - Compile-time safety
+   - Better testing support
+   - More flexible than Provider
+
+4. **GetX**: Full-featured solution with state management, routing, and 
+   dependency injection
+   - Minimal boilerplate
+   - Fast and lightweight
+   - All-in-one solution
+
+## Next Steps
+
+The current codebase needs refactoring to implement proper state management 
+architecture to handle more complex state scenarios effectively. Provider 
+would be the easiest migration path while Bloc provides better long-term 
+scalability.
+```
+
+## When to Use This Pattern
+
+This script pattern is ideal for various development scenarios where automated GitHub issue analysis can accelerate your workflow.
+
+### Bug Investigation
+
+Quickly analyze bug reports and identify root causes without manual code exploration:
+
+```bash
+./analyze-issue.sh https://github.com/project/repo/issues/123 \
+    "What is the root cause of this bug?"
+```
+
+### Feature Request Analysis
+
+Understand context and implications of feature requests:
+
+```bash
+./analyze-issue.sh https://github.com/project/repo/issues/456 \
+    "What are the implementation challenges?"
+```
+
+### Security Audits
+
+Assess security implications of reported issues:
+
+```bash
+./analyze-issue.sh https://github.com/project/repo/issues/789 \
+    "What are the security implications?"
+```
+
+### Documentation Generation
+
+Generate detailed technical documentation from issues:
+
+```bash
+./analyze-issue.sh https://github.com/project/repo/issues/654 \
+    "Provide detailed technical documentation for this issue"
+```
+
+### Code Review Assistance
+
+Get second opinions on proposed changes:
+
+```bash
+./analyze-issue.sh https://github.com/project/repo/issues/987 \
+    "Review the proposed solution approach"
+```
+
+## Conclusion
+
+This sample demonstrates how to build an autonomous GitHub issue analysis tool using Cline CLI:
+
+1. **Building autonomous CLI tools** using Cline's capabilities
+2. **Parsing structured JSON output** from Cline CLI
+3. **Creating flexible automation scripts** with custom prompting
+4. **Integrating with GitHub** for issue analysis
+5. **Handling command-line arguments** effectively
+
+This pattern can be adapted for many other automation scenarios, from pull request reviews to documentation generation to code quality analysis.
+
+## Related Resources
+
+- [CLI Installation Guide](https://docs.cline.bot/getting-started/installing-cline)
+- [CLI Reference Documentation](https://docs.cline.bot/cli/cli-reference)
+- [Headless Mode](https://docs.cline.bot/usage/cli-overview#headless-mode)
diff --git a/docs/cli/samples/github-pr-review.mdx b/docs/cli/samples/github-pr-review.mdx
new file mode 100644
index 0000000..78501c1
--- /dev/null
+++ b/docs/cli/samples/github-pr-review.mdx
@@ -0,0 +1,192 @@
+---
+title: "GitHub PR Review"
+description: "Automatically review Pull Requests with AI using Cline CLI in GitHub Actions."
+---
+
+Automate code review for every Pull Request. Detailed analysis, security checks, and code suggestions provided by Cline running autonomously in GitHub Actions.
+
+## The Workflow
+
+When a PR is opened or marked ready for review, this workflow:
+1.  **Checks out** the code.
+2.  **Installs** Node.js and Cline CLI.
+3.  **Configures** authentication (e.g., Anthropic, OpenAI).
+4.  **Runs Cline** with a comprehensive system prompt to analyze the diff, context, and related issues using GitHub CLI (`gh`).
+5.  **Posts** a detailed review comment with inline code suggestions.
+
+## Prerequisites
+
+-   **GitHub repository** with Actions enabled.
+-   **AI Provider API Key** (e.g., Anthropic, OpenRouter) added as a repository secret (e.g., `ANTHROPIC_API_KEY`).
+-   **GitHub Token** (automatically provided by Actions as `GITHUB_TOKEN`).
+
+## Setup
+
+### 1. Create the Workflow File
+
+Create a file named `.github/workflows/cline-pr-review.yml` in your repository:
+
+```yaml
+name: Cline PR Code Review
+
+on:
+  pull_request:
+    types: [opened, ready_for_review]
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: "PR number to review"
+        required: true
+        type: string
+
+concurrency:
+  group: pr-review-${{ github.event.pull_request.number || inputs.pr_number }}
+  cancel-in-progress: true
+
+jobs:
+  cline-pr-review:
+    if: |
+      (github.event_name == 'pull_request' && github.event.pull_request.draft == false) ||
+      github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "npm"
+
+      - name: Install Cline CLI
+        run: npm install -g cline
+
+      - name: Configure Cline Authentication
+        # Replace 'anthropic' with your provider of choice (openai, openrouter, etc.)
+        # and ensure the corresponding secret is set in your repo settings.
+        run: |
+          cline auth --provider anthropic \
+            --apikey "${{ secrets.ANTHROPIC_API_KEY }}" \
+            --modelid claude-opus-4-5-20251101
+
+      - name: Get PR number
+        id: pr
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "number=${{ inputs.pr_number }}" >> $GITHUB_OUTPUT
+          else
+            echo "number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Review PR with Cline
+        env:
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+          GITHUB_REPO: ${{ github.repository }}
+          GH_TOKEN: ${{ github.token }}
+          # Restrict Cline to only safe, read-only GitHub CLI commands
+          CLINE_COMMAND_PERMISSIONS: |
+            {
+              "allow": [
+                "gh pr diff *",
+                "gh pr view *",
+                "gh pr checks *",
+                "gh pr list *",
+                "gh issue list *",
+                "gh issue view *",
+                "git log *",
+                "gh pr comment ${{ steps.pr.outputs.number }} *",
+                "gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/comments *",
+                "gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/reviews *"
+              ]
+            }
+        run: |
+          cline --auto-approve true 'You are a GitHub PR reviewer for this repository. Your goal is to give the PR author helpful feedback and give maintainers the context they need to review efficiently.
+
+          PR: #'"${PR_NUMBER}"'
+
+          ## Gather context
+          Use `gh` commands to fetch the PR diff, details, and checks.
+          
+          ```bash
+          # Get full PR details
+          gh pr view '"${PR_NUMBER}"' --json number,title,body,author,createdAt,updatedAt,isDraft,labels,commits,files,additions,deletions,changedFiles,baseRefName,headRefName,mergeable,reviewDecision
+
+          # Get the diff
+          gh pr diff '"${PR_NUMBER}"'
+
+          # Check CI status
+          gh pr checks '"${PR_NUMBER}"'
+          ```
+
+          ## Deep code review
+          Analyze the code changes. Look for:
+          - Logic errors and edge cases
+          - Security vulnerabilities
+          - Performance issues
+          - adherence to patterns in the codebase
+
+          ## Submit Review
+          Post a single comprehensive comment summarizing your review.
+          
+          If you have specific code suggestions, use the GitHub API to post inline comments:
+          
+          ```bash
+          gh api repos/'"${GITHUB_REPO}"'/pulls/'"${PR_NUMBER}"'/reviews \
+            -X POST \
+            -f event="COMMENT" \
+            -f body="" \
+            -F comments='[{"path": "src/file.ts", "line": 10, "body": "Suggestion: ..."}]'
+          ```
+          
+          Start your main comment with "Reviewed by Cline".'
+```
+
+### 2. Configure Secrets
+
+1.  Go to your repository settings -> **Secrets and variables** -> **Actions**.
+2.  Add a **New repository secret**.
+3.  Name: `ANTHROPIC_API_KEY` (or match the key used in your workflow).
+4.  Value: Your actual API key.
+
+## Key Components Explained
+
+### Permissions
+```yaml
+permissions:
+  contents: read
+  pull-requests: write
+  issues: read
+```
+We grant `pull-requests: write` so Cline can post comments and inline reviews. `contents: read` ensures it can analyze the code but **cannot push changes directly**, providing a security boundary.
+
+### Authentication
+```bash
+cline auth --provider anthropic --apikey "..."
+```
+The `auth` command configures Cline in the CI environment without interactive prompts. You can switch providers (e.g., `openai`, `openrouter`) by changing the flags.
+
+### Autonomous Mode (`--auto-approve true`)
+```bash
+cline --auto-approve true '...'
+```
+The `--auto-approve true` flag tells Cline to run autonomously, executing approved tools without waiting for interactive confirmation. Prompt runs start in Act mode by default, so CI/CD workflows can perform the requested work immediately.
+
+### Command Permissions
+We explicitly restrict what commands Cline can run using `CLINE_COMMAND_PERMISSIONS`. This ensures Cline can only use `gh` and `git` commands relevant to reviewing, preventing any accidental or malicious system modifications.
+
+## Customizing the Reviewer
+
+The "System Prompt" passed to Cline in the final step is fully customizable. You can modify it to:
+-   Enforce specific style guides.
+-   Focus on security vs. performance.
+-   Ask for specific types of feedback (e.g., "Roast my code" vs. "Be gentle").
diff --git a/docs/cli/samples/model-orchestration.mdx b/docs/cli/samples/model-orchestration.mdx
new file mode 100644
index 0000000..82811ee
--- /dev/null
+++ b/docs/cli/samples/model-orchestration.mdx
@@ -0,0 +1,222 @@
+---
+title: "Model Orchestration"
+description: "Use multiple AI models strategically: optimize costs, reduce bias, and leverage model-specific strengths in your workflows"
+---
+
+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**
+
+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, 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**
+
+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
+
+See our production GitHub Actions workflow that uses Cline CLI for automated PR reviews: [cline-pr-review.yml](https://github.com/cline/cline/blob/main/.github/workflows/cline-pr-review.yml)
+
+**Key capabilities demonstrated:**
+- **Automated inline suggestions**: Creates GitHub suggestion blocks that authors can commit with one click
+- **SME identification**: Analyzes git history to find subject matter experts for each file
+- **Related issue discovery**: Searches for context from past issues and PRs
+- **Security-first permissions**: Read-only codebase access, can only post reviews
+- **Deep code analysis**: Understands intent, compares approaches, identifies edge cases
+
+The workflow runs on every PR and provides maintainers with comprehensive context to make faster, more informed decisions.
+
+## Pattern 2: Task Phase Optimization
+
+Use different models for different phases of work. Route simple tasks to cheap models, complex reasoning to premium models.
+
+### Example: Issue Analysis Pipeline
+
+```bash
+# Get latest issue content
+ISSUE_CONTENT=$(gh issue view $(gh issue list -L 1 | awk '{print $1}'))
+
+# Phase 1: Quick summary with cheap model
+SUMMARY=$(echo "$ISSUE_CONTENT" | cline --auto-approve true --config ~/.cline-haiku \
+  "summarize this issue in 2-3 sentences")
+
+# Phase 2: Detailed plan with expensive model + thinking
+PLAN=$(echo "$SUMMARY" | cline --auto-approve true --thinking high --config ~/.cline-opus \
+  "create detailed implementation plan with edge cases")
+
+# Phase 3: Execute with mid-tier model
+echo "$PLAN" | cline --auto-approve true --config ~/.cline-sonnet \
+  "implement the plan from above"
+```
+
+<Note>
+Each `cline` invocation needs to complete before passing output to the next phase. Use shell variables to store intermediate results rather than piping `cline` commands directly.
+</Note>
+
+**Cost impact:**
+- Haiku: $0.80 per million input tokens
+- Opus: $15 per million input tokens  
+- Sonnet: $3 per million input tokens
+
+This pattern uses Opus only when needed for complex reasoning, saving ~10x on API costs compared to using Opus for everything.
+
+### Setting Up Model Configs
+
+Create separate configuration directories for each model:
+
+```bash
+# Create config directories
+mkdir -p ~/.cline-haiku ~/.cline-sonnet ~/.cline-opus
+
+# Configure each with different models
+cline --config ~/.cline-haiku auth anthropic --modelid claude-haiku-4-20250514
+cline --config ~/.cline-sonnet auth anthropic --modelid claude-sonnet-4-20250514  
+cline --config ~/.cline-opus auth anthropic --modelid claude-opus-4-5-20251101
+
+# Or use different providers entirely
+cline --config ~/.cline-gemini auth gemini --modelid gemini-2.0-flash-exp
+cline --config ~/.cline-codex auth openai-codex --modelid gpt-5-latest
+```
+
+Now you can switch models per-task with `--config`:
+
+```bash
+cline --config ~/.cline-haiku "quick task"
+cline --config ~/.cline-opus "complex reasoning task"
+```
+
+## Pattern 3: Multi-Model Review & Consensus
+
+Get multiple AI perspectives on the same change, then synthesize their feedback.
+
+### Example: Diff Review Pipeline
+
+```bash
+# Get the latest commit
+DIFF=$(git show)
+
+# Review 1: Gemini's perspective
+echo "$DIFF" | cline --auto-approve true --config ~/.cline-gemini \
+    "review this diff and write your analysis to gemini-review.md"
+
+# Review 2: Codex's perspective
+echo "$DIFF" | cline --auto-approve true --config ~/.cline-codex \
+    "review this diff and write your analysis to codex-review.md"
+
+# Review 3: Opus's perspective
+echo "$DIFF" | cline --auto-approve true --config ~/.cline-opus \
+    "review this diff and write your analysis to opus-review.md"
+
+# Synthesize all reviews into a consensus
+cat gemini-review.md codex-review.md opus-review.md | cline --auto-approve true \
+    "summarize these 3 reviews and identify: 1) issues all models agree on, 2) issues only one model caught, 3) your final recommendation"
+```
+
+**Why this works:**
+- **Redundancy**: Issues caught by all 3 models are high-confidence
+- **Coverage**: Each model has blind spots; together they cover more ground
+- **Prioritization**: Consensus issues should be fixed first
+- **Learning**: See which model types catch which issue types
+
+### Advanced: Parallel Reviews
+
+Run reviews in parallel for faster feedback:
+
+```bash
+# Run all reviews simultaneously
+git show | cline --auto-approve true --config ~/.cline-gemini "review and save to gemini-review.md" &
+git show | cline --auto-approve true --config ~/.cline-codex "review and save to codex-review.md" &
+git show | cline --auto-approve true --config ~/.cline-opus "review and save to opus-review.md" &
+
+# Wait for all to complete
+wait
+
+# Synthesize
+cat *-review.md | cline --auto-approve true "create consensus review"
+```
+
+<Note>
+Parallel execution requires managing multiple Cline instances. See [Multi-instance workflows](/usage/cli-overview#automation-patterns) for details.
+</Note>
+
+## Extended Thinking for Complex Tasks
+
+Use the `--thinking` flag when Cline needs to analyze multiple approaches:
+
+```bash
+# Without thinking: Fast but may miss nuances
+cline --auto-approve true "refactor this codebase"
+
+# With thinking: Slower but more thorough
+cline --auto-approve true --thinking high \
+    "refactor this codebase - consider: performance, maintainability, backward compatibility"
+```
+
+The `--thinking <level>` flag sets reasoning effort. Use `--thinking high` or `--thinking xhigh` when you want the model to spend more effort on complex tradeoffs. Best for:
+- Architectural decisions
+- Security analysis
+- Complex refactoring
+- Multi-step planning
+
+## Best Practices
+
+1. **Profile your workload**: Track which tasks are simple vs. complex
+2. **Match models to tasks**: Use fast models for summaries, powerful models for reasoning
+3. **Automate switching**: Script model selection based on task type
+4. **Monitor costs**: Different models have 10-100x price differences
+5. **Validate important decisions**: Use multi-model consensus for critical changes
+
+## Production Examples
+
+### Cost-Optimized PR Review
+
+```bash
+# Haiku: Quick summary and issue identification
+gh pr view $PR | cline --auto-approve true --config ~/.cline-haiku \
+    "list all issues to fix, output as JSON"
+
+# Opus with thinking: Deep analysis only if issues found
+if [ -s issues.json ]; then
+    cline --auto-approve true --thinking high --config ~/.cline-opus \
+        "analyze these issues and recommend fixes"
+fi
+```
+
+### Security-Focused Multi-Model Scan
+
+```bash
+# Different models have different security perspectives
+git diff main | cline --auto-approve true --config ~/.cline-gemini "security review" > gemini-sec.md &
+git diff main | cline --auto-approve true --config ~/.cline-opus "security review" > opus-sec.md &
+git diff main | cline --auto-approve true --config ~/.cline-codex "security review" > codex-sec.md &
+wait
+
+# High-priority: Issues all 3 models found
+cat *-sec.md | cline --auto-approve true "find security issues all 3 reviews mentioned"
+```
+
+## Related Documentation
+
+<Columns cols={2}>
+  <Card title="CLI Reference" icon="terminal" href="/cli/cli-reference">
+    Complete documentation for --config and --thinking flags
+  </Card>
+  
+  <Card title="Headless Mode" icon="robot" href="/usage/cli-overview#headless-mode">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
+  </Card>
+  
+  <Card title="Cline Provider" icon="brain" href="/getting-started/cline-provider">
+    Fastest built-in model access setup and account workflow
+  </Card>
+  
+  <Card title="CI/CD Integration" icon="github" href="/cli/samples/github-integration">
+    Automate GitHub workflows with Cline CLI
+  </Card>
+</Columns>
diff --git a/docs/cli/samples/supply-chain-alerts.mdx b/docs/cli/samples/supply-chain-alerts.mdx
new file mode 100644
index 0000000..e5cfc2f
--- /dev/null
+++ b/docs/cli/samples/supply-chain-alerts.mdx
@@ -0,0 +1,213 @@
+---
+title: "Supply-Chain Scan Alerts"
+description: "Schedule the Cline CLI to scan your machine for compromised packages with Bumblebee and text you on Telegram when it finds one."
+---
+
+npm worms like Shai-Hulud spread through install scripts: the moment you run `npm install`, a `preinstall` hook executes and steals your npm, GitHub, AWS, and SSH credentials. New campaigns are reported almost every week.
+
+This guide wires three pieces together so your machine checks itself automatically and pings your phone only when it matters:
+
+- [Bumblebee](https://github.com/perplexityai/bumblebee), Perplexity's open-source, read-only supply-chain scanner. It maintains catalogs of recent campaigns and checks whether any compromised package or version is present on disk.
+- The Cline CLI scheduler, which runs an agent on a cron schedule.
+- The Cline CLI Telegram connector, which delivers the result to a chat.
+
+The end result: every morning, a Cline agent pulls the latest threat intelligence, runs a read-only scan, and texts you a green check if you are clean or a red alert with details if you are exposed.
+
+```mermaid
+flowchart TD
+    cron["cline schedule (daily)"] --> agent["Cline agent"]
+    agent --> pull["git pull (latest catalogs)"]
+    agent --> scan["bumblebee scan (read-only)"]
+    scan --> q{"any findings?"}
+    q -- "no" --> clean["✅ Clean"]
+    q -- "yes" --> alert["🚨 Compromise detected"]
+    clean --> tg["Telegram on your phone"]
+    alert --> tg
+```
+
+## How Bumblebee works
+
+Bumblebee answers one narrow question fast: when an advisory names a package and version, is it present on this machine right now?
+
+The important design choice is that it is read-only. A scanner that runs `npm`, `pnpm`, or `pip` to enumerate your dependencies would trigger the very install-script payload it is looking for. Bumblebee never does that. It only reads metadata files directly:
+
+| Surface | What it reads |
+|---|---|
+| npm / pnpm / yarn / bun | lockfiles and installed `package.json` metadata |
+| PyPI | `*.dist-info/METADATA`, `*.egg-info/PKG-INFO` |
+| Go modules | `go.sum`, `go.mod` |
+| RubyGems | `Gemfile.lock`, installed gemspecs |
+| Composer | `composer.lock`, `vendor/composer/installed.json` |
+| MCP servers | `mcp.json`, `claude_desktop_config.json`, and similar configs |
+| Editor extensions | VS Code-family extension manifests |
+| Browser extensions | Chromium-family and Firefox extension manifests |
+
+It never runs package managers, never executes install scripts or lifecycle hooks, and never reads your application source. It ships no bundled threat intelligence either: you point it at an exposure catalog, and it reports exact `(ecosystem, name, version)` matches.
+
+The catalogs live in the repo under `threat_intel/`, maintained by Perplexity and updated via pull requests as new campaigns are reported. That is why this automation simply pulls the latest before each scan: a `git pull` is all it takes to stay current.
+
+Read the announcement: [Perplexity is open-sourcing Bumblebee](https://www.perplexity.ai/hub/blog/perplexity-is-open-sourcing-bumblebee).
+
+## Prerequisites
+
+- Node.js 22 or newer (for the Cline CLI).
+- Go 1.22 or newer (to build Bumblebee).
+- A Telegram account.
+- An AI provider key, or a Cline account.
+
+## 1. Install the Cline CLI
+
+```bash
+npm install -g cline
+cline # run once to configure inference provider and model
+```
+
+## 2. Clone and build Bumblebee
+
+Clone the repository somewhere stable. The clone is both the scanner and the catalog source, so the scheduled job will run from inside it.
+
+```bash
+mkdir -p ~/tools
+git clone https://github.com/perplexityai/bumblebee.git ~/tools/bumblebee
+cd ~/tools/bumblebee
+go build -o bumblebee ./cmd/bumblebee
+```
+
+Confirm it works with the built-in self test, which runs embedded fixtures and makes no network calls:
+
+```bash
+./bumblebee selftest
+# selftest OK (2 findings in 1ms)
+```
+
+## 3. Run a scan manually
+
+Point `--exposure-catalog` at the whole `threat_intel/` directory to use every maintained catalog at once. The `--findings-only` flag suppresses the full inventory so you only get matches.
+
+```bash
+cd ~/tools/bumblebee
+./bumblebee scan --profile deep --root "$HOME" \
+  --exposure-catalog ./threat_intel/ \
+  --findings-only
+```
+
+Output is NDJSON, one JSON object per line. A match looks like this:
+
+```json
+{ "record_type": "finding", "severity": "critical", "ecosystem": "npm",
+  "package_name": "example-pkg", "version": "1.2.3",
+  "source_file": "/Users/you/code/app/pnpm-lock.yaml",
+  "evidence": "exact name+version match (version=1.2.3)" }
+```
+
+If you are clean, you get no `finding` records. Exit code is `0` on a successful run, `1` if the scan hit errors, `2` for bad arguments.
+
+<Note>
+Scan profiles control where Bumblebee looks. `baseline` checks standard global tool, editor, and browser locations. `project` scans your development directories (pass `--root ~/code`). `deep` walks whatever roots you give it, typically your whole home directory. Use `deep` for the most thorough "am I exposed anywhere" check, or `project` for a faster daily scan of your repos.
+</Note>
+
+## 4. Create a Telegram bot and start the connector
+
+<Steps>
+  <Step title="Create a bot">
+    Open Telegram, start a chat with [@BotFather](https://t.me/BotFather), send `/newbot`, and follow the prompts. Copy the bot token it gives you (it looks like `7123456789:AAH...`). Treat it like a password.
+  </Step>
+
+  <Step title="Start the connector">
+    Run the connector and point its working directory at your Bumblebee clone, so the scheduled agent runs there:
+
+    ```bash
+    cline connect telegram -k "<BOT-TOKEN>" --cwd ~/tools/bumblebee
+    ```
+
+    Leave this process running. It polls Telegram and delivers scheduled results, so it must stay alive.
+  </Step>
+
+  <Step title="Open the chat">
+    In Telegram, search for your bot's username and send it any message (for example `/whereami`). This creates the thread binding that delivery needs.
+  </Step>
+</Steps>
+
+<Warning>
+By default, anyone who finds your bot can message it and it will run tasks on your machine. Lock it down before leaving the connector running. The `cline connect` wizard can guide you through Telegram user ID setup, or you can message [@userinfobot](https://t.me/userinfobot) and restart the connector with your allowed user ID:
+
+```bash
+cline connect telegram -k "<BOT-TOKEN>" --cwd ~/tools/bumblebee \
+  --allowed-user-id 12345
+```
+
+Replace `12345` with your Telegram user ID.
+</Warning>
+
+## 5. Schedule the scan
+
+There are two ways to create the scheduled scan. Both run the same agent and deliver the result to Telegram, so pick whichever you prefer.
+
+### Option A: From the Telegram chat
+
+Creating the schedule from the chat automatically targets that thread for delivery, so results come straight back to you. Send this to your bot as a single message:
+
+```text
+/schedule create "supply-chain-watch" --cron "0 8 * * *" --prompt "Pull the latest Bumblebee catalogs and scan this machine for compromised packages. Run: git pull --quiet && go build -o bumblebee ./cmd/bumblebee && ./bumblebee scan --profile deep --root $HOME --exposure-catalog ./threat_intel/ --findings-only. Read the NDJSON output. If any line has record_type set to finding, reply starting with '🚨 COMPROMISE DETECTED' and list each package name, version, ecosystem, and source_file. If there are no findings, reply with exactly '✅ Clean: no compromised packages found.'"
+```
+
+The bot replies with the new schedule, including its id.
+
+### Option B: From your terminal
+
+Create the schedule with the Cline CLI on the same machine and pass the delivery method explicitly. The running Telegram connector delivers the result to its chat:
+
+```bash
+cline schedule create "supply-chain-watch" \
+  --cron "0 8 * * *" \
+  --workspace ~/tools/bumblebee \
+  --delivery-adapter telegram \
+  --delivery-bot <bot-username> \
+  --prompt "Pull the latest Bumblebee catalogs and scan this machine for compromised packages. Run: git pull --quiet && go build -o bumblebee ./cmd/bumblebee && ./bumblebee scan --profile deep --root \$HOME --exposure-catalog ./threat_intel/ --findings-only. Read the NDJSON output. If any line has record_type set to finding, reply starting with '🚨 COMPROMISE DETECTED' and list each package name, version, ecosystem, and source_file. If there are no findings, reply with exactly '✅ Clean: no compromised packages found.'"
+```
+
+Either way, this schedules a daily scan at 8am.
+
+## Why the green check matters
+
+Scheduled delivery always sends the run's final reply, so the prompt is written to make that reply meaningful either way:
+
+- Clean run: one line, `✅ Clean: no compromised packages found.` You get a daily heartbeat confirming the scan actually ran.
+- Exposure: `🚨 COMPROMISE DETECTED` followed by the package, version, and the file where it was found, so you can act immediately (rotate credentials, remove the package, pin a safe version).
+
+## Test it
+
+Trigger the scan now instead of waiting for 8am.
+
+First find your schedule id. The create step returns it (the Telegram bot's reply shows `id=...`), or list your schedules at any time:
+
+```bash
+cline schedule list
+```
+
+Then trigger it with that id. From the terminal:
+
+```bash
+cline schedule trigger <schedule-id>
+```
+
+Or from Telegram: `/schedule trigger <schedule-id>`. Within a few seconds you should get the result in your chat.
+
+To see a real alert, add a package and version that matches a catalog entry to a throwaway project's lockfile and run the scan against it. Bumblebee reports the match, and the agent texts you the red alert.
+
+## Keep it running
+
+- The connector process (`cline connect telegram`) must stay running for delivery to work. Run it under a process manager (systemd, launchd, `pm2`, or a `tmux`/`screen` session) so it survives reboots.
+- The hub runs the schedule and starts automatically when you create one. If it is not running, start it with `cline hub start`.
+- Manage schedules anytime with `cline schedule list`, `cline schedule pause <id>`, `cline schedule resume <id>`, and `cline schedule delete <id>`.
+
+## Customize
+
+- Cadence: change the cron expression. `0 */6 * * *` scans every six hours; `0 8 * * MON-FRI` runs on weekdays only.
+- Scope: swap `--profile deep --root $HOME` for `--profile project --root ~/code` for a faster scan of just your repos, or `--profile baseline` for global tools, editors, and browser extensions.
+- Channels: the same delivery pattern works for Slack, Discord, WhatsApp, and Google Chat. See [Connectors](/cli/connectors).
+- Fleet use: Bumblebee can `POST` NDJSON to an ingest endpoint with `--output http --http-url <url>` if you want to centralize findings across many machines.
+
+## Credits
+
+Bumblebee is built and open-sourced by Perplexity. See the [announcement](https://www.perplexity.ai/hub/blog/perplexity-is-open-sourcing-bumblebee) and the [repository](https://github.com/perplexityai/bumblebee).
diff --git a/docs/cli/scheduling.mdx b/docs/cli/scheduling.mdx
new file mode 100644
index 0000000..b1006d1
--- /dev/null
+++ b/docs/cli/scheduling.mdx
@@ -0,0 +1,110 @@
+---
+title: "Scheduling"
+sidebarTitle: "Scheduling"
+description: "Run agents on cron schedules for recurring automations like daily summaries and code reviews."
+---
+<Warning>
+  This feature currently only applies to Cline SDK, CLI, and Kanban. This feature is not applicable on VSCode and JetBrains Extension for now.
+</Warning>
+
+The CLI supports running agents on cron schedules through the hub. Scheduled agents persist across process restarts and run independently of any terminal session.
+
+## Schedule Wizard
+
+Run `cline schedule` to open an interactive menu for creating and managing schedules, browsing execution history, and viewing performance statistics.
+
+```bash
+cline schedule
+```
+
+The wizard provides:
+
+| Action | Description |
+|--------|-------------|
+| Create new schedule | Set up a recurring task with cron timing and prompt |
+| List schedules | View all schedules with status and next run time |
+| Upcoming runs | Preview the next 10 scheduled executions |
+| Active executions | Show currently running tasks |
+| Trigger now | Immediately run a selected schedule |
+| Pause / Resume | Suspend or restart a schedule |
+| Execution history | View past runs with status, duration, tokens, and cost |
+| Statistics | Success rate, average duration, last failure |
+| Delete | Remove a schedule |
+
+## Creating Schedules with Flags
+
+```bash
+cline schedule create "PR summary" \
+  --cron "0 9 * * MON-FRI" \
+  --prompt "List all open PRs and their review status" \
+  --workspace /path/to/repo \
+  --model anthropic/claude-sonnet-4-6
+```
+
+## Managing Schedules
+
+```bash
+cline schedule list
+cline schedule trigger <schedule-id>
+cline schedule pause <schedule-id>
+cline schedule resume <schedule-id>
+cline schedule delete <schedule-id>
+cline schedule executions <schedule-id>
+```
+
+## Cron Expression Reference
+
+| Expression | Schedule |
+|-----------|----------|
+| `*/5 * * * *` | Every 5 minutes |
+| `*/15 * * * *` | Every 15 minutes |
+| `0 * * * *` | Every hour |
+| `0 */6 * * *` | Every 6 hours |
+| `0 0 * * *` | Daily at midnight |
+| `0 9 * * *` | Daily at 9am |
+| `0 9 * * 1-5` | Every weekday at 9am |
+| `0 9 * * 1` | Every Monday at 9am |
+| `0 0 1 * *` | First of every month |
+
+## Examples
+
+### Daily Standup Summary
+
+```bash
+cline schedule create "Standup prep" \
+  --cron "0 8 * * MON-FRI" \
+  --prompt "Summarize: (1) PRs merged yesterday, (2) PRs currently in review, (3) open issues assigned to team members." \
+  --workspace /path/to/repo
+```
+
+### Weekly Dependency Check
+
+```bash
+cline schedule create "Dependency check" \
+  --cron "0 10 * * MON" \
+  --prompt "Check for outdated npm dependencies. For any with security vulnerabilities, create a branch with the update and open a PR." \
+  --workspace /path/to/project
+```
+
+### Codebase Health Report
+
+```bash
+cline schedule create "Code health" \
+  --cron "0 6 * * MON" \
+  --prompt "Analyze the codebase for: (1) files with no test coverage, (2) TODO/FIXME comments older than 30 days, (3) functions longer than 100 lines." \
+  --workspace /path/to/project
+```
+
+## Routing Results
+
+Combine schedules with [connectors](/cli/connectors) to send results to messaging platforms:
+
+```bash
+cline connect telegram -k $BOT_TOKEN
+
+cline schedule create "Morning briefing" \
+  --cron "0 8 * * *" \
+  --prompt "Summarize overnight activity in the repo"
+```
+
+Scheduling requires the hub. It starts automatically when you create a schedule.
diff --git a/docs/cline-overview.mdx b/docs/cline-overview.mdx
new file mode 100644
index 0000000..f867b5d
--- /dev/null
+++ b/docs/cline-overview.mdx
@@ -0,0 +1,85 @@
+---
+title: "Cline Overview"
+sidebarTitle: "Cline Overview"
+description: "Your AI-powered coding agent for complex work. Read files, write code, run commands, all with your approval."
+---
+
+Welcome to the Cline documentation. Whether you're just getting started or looking to unlock advanced capabilities, you'll find everything you need here.
+
+## What is Cline?
+
+Cline is an AI coding agent that lives in your editor and your terminal. It can read and write files, run terminal commands, use a browser, and help you build features through natural conversation. Every action requires your explicit approval. You're always in control.
+
+## Model access
+
+Choose the model access path that fits your workflow:
+
+<CardGroup cols={3}>
+  <Card title="Cline (usage-billing)" icon="bolt" href="/getting-started/cline-provider">
+    Fastest setup path with one sign-in, built-in billing, and free model options.
+  </Card>
+  <Card title="ClinePass" icon="credit-card" href="/getting-started/clinepass">
+    Flat $9.99/month subscription for selected open coding models with 2-5x API rate limits.
+  </Card>
+  <Card title="Bring Your Own Key" icon="key" href="/getting-started/authorizing-with-cline#byok-cloud--local">
+    Use your own provider credentials for cloud providers or local runtimes.
+  </Card>
+</CardGroup>
+
+## Applications
+
+These are end-user applications built on top of Cline's agent core:
+
+<CardGroup cols={2}>
+  <Card title="CLI" icon="terminal" href="/usage/cli-overview">
+    Run Cline in your terminal with interactive chat or fully headless automation for CI/CD and scripting.
+
+    `npm i -g cline`
+  </Card>
+  <Card title="Kanban" icon="table-columns" href="https://github.com/cline/kanban">
+    Run many agents in parallel from a web-based task board with per-card worktrees, auto-commit, and dependency chains.
+
+    `npx kanban`
+  </Card>
+  <Card title="VS Code Extension" icon="code" href="https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev">
+    AI coding assistant in your editor. Create files, run commands, browse the web, and use tools with human-in-the-loop approval.
+  </Card>
+  <Card title="JetBrains Plugin" icon="brain" href="https://plugins.jetbrains.com/plugin/27189-cline">
+    The same Cline experience in IntelliJ IDEA, PyCharm, WebStorm, GoLand, and the rest of the JetBrains family.
+  </Card>
+</CardGroup>
+
+
+## Agent Core (SDK)
+
+The SDK is Cline's agent core—use it to build your own applications, automations, and integrations. See SDK section for detailed functionality and architectural design of the Cline Agent.
+
+<CardGroup cols={1}>
+  <Card title="SDK" icon="cube" href="https://docs.cline.bot/sdk/overview">
+    Build AI agents and integrations powered by the same core engine behind the CLI, Kanban, VS Code extension, and JetBrains plugin.
+
+    `npm install @cline/sdk`
+  </Card>
+</CardGroup>
+
+## Other IDE Supports
+
+Cline works across all major editors: **VS Code**, **Cursor**, **Windsurf**, **JetBrains** (IntelliJ, PyCharm, WebStorm), **Antigravity**, and **Zed**, **Neovim** via ACP mode.
+
+
+## Enterprise Solutions
+
+<CardGroup cols={2}>
+  <Card title="Security & Governance" icon="shield-halved" href="/enterprise-solutions/overview">
+    SSO, role-based access control, model and tool controls per team, and remote configuration.
+  </Card>
+  <Card title="Observability" icon="chart-line" href="/enterprise-solutions/monitoring/overview">
+    OpenTelemetry, Datadog, Grafana, Splunk integrations with real-time analytics.
+  </Card>
+  <Card title="Team Management" icon="users-gear" href="/enterprise-solutions/team-management/managing-members">
+    Manage members, roles, and permissions across your organization.
+  </Card>
+  <Card title="API Reference" icon="code" href="/enterprise-solutions/api-reference">
+    Programmatic access to Cline's enterprise features.
+  </Card>
+</CardGroup>
diff --git a/docs/core-workflows/checkpoints.mdx b/docs/core-workflows/checkpoints.mdx
new file mode 100644
index 0000000..3c73cff
--- /dev/null
+++ b/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.
diff --git a/docs/core-workflows/plan-and-act.mdx b/docs/core-workflows/plan-and-act.mdx
new file mode 100644
index 0000000..b62cf1f
--- /dev/null
+++ b/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 [/deep-planning](/core-workflows/using-commands#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
diff --git a/docs/core-workflows/task-management.mdx b/docs/core-workflows/task-management.mdx
new file mode 100644
index 0000000..a7f775e
--- /dev/null
+++ b/docs/core-workflows/task-management.mdx
@@ -0,0 +1,161 @@
+---
+title: "Tasks"
+sidebarTitle: "Tasks"
+description: "Organize your work with tasks - self-contained sessions that capture your conversations, code changes, and decisions."
+---
+
+Every interaction with Cline happens within a task. Tasks are self-contained work sessions that capture your entire conversation, code changes, command executions, and decisions.
+
+## What are Tasks?
+
+A task begins when you submit a prompt to Cline. Your prompt defines the goal, and Cline works toward it through conversation, code changes, and tool use. The quality of your initial prompt directly affects how well Cline performs - clear, specific prompts lead to better results.
+
+Each task:
+
+- Starts with your prompt and builds context through the conversation
+- Has a unique identifier and dedicated storage directory
+- Contains the full conversation history
+- Tracks token usage, API costs, and execution time
+- Can be interrupted and resumed across sessions
+- Creates [checkpoints](/core-workflows/checkpoints) for file changes through Git-based snapshots
+
+<Tip>
+Want to get better results from Cline? Learn how to write effective prompts in our [Prompt Module](https://cline.bot/learn).
+</Tip>
+
+## Scoping Your Tasks
+
+Each task carries its own context: the conversation history, decisions made, and understanding built up over the session. How you scope your tasks directly affects how well Cline can help you.
+
+Think of it this way: **one task = one goal**. "Implement user authentication" is one task. "Fix an unrelated CSS bug" is a separate task, even if you notice it while working on auth.
+
+A focused task produces better results. When a task tries to cover too many unrelated goals, the context becomes cluttered and responses become less relevant.
+
+<Note>
+If you're unsure, err on the side of starting fresh. You can always find previous sessions in your task history.
+</Note>
+
+### Context Window
+
+Every AI model has a context window - a limit on how much information it can process at once. Think of it as Cline's working memory for the current task.
+
+As you work, the context window fills up with:
+- Your prompts and Cline's responses
+- File contents Cline reads or edits
+- Command outputs and tool results
+- System instructions that guide Cline's behavior (including [Cline Rules](/customization/cline-rules))
+
+When the context window approaches its limit, Cline automatically compresses older parts of the conversation to make room. This means very long tasks may lose some earlier details, though Cline preserves the most important context.
+
+This is why task scoping matters: a focused task keeps relevant information in the context window. A sprawling task fills the window with noise, pushing out useful context.
+
+If your starting context seems high even for simple prompts, add a [`.clineignore`](/customization/clineignore) file to exclude dependencies, build artifacts, and other files Cline doesn't need. This can dramatically reduce your baseline token usage.
+
+<Tip>
+For long-running tasks, enable [Auto-Compact](/features/auto-compact) to intelligently manage context as you work.
+</Tip>
+
+### New Task vs. Continue
+
+Knowing when to start fresh versus continue can feel unclear at first. As you work with Cline more, you'll develop an intuition for it. Use this table as a starting point:
+
+| Scenario | Action | Why |
+|----------|--------|-----|
+| Switching to a different feature | **New task** | Clean context, focused responses |
+| Building on work Cline just completed | **Continue** | Shared understanding preserved |
+| Cline keeps going off-track | **New task** | Fighting context wastes time |
+| Iterating on the same files | **Continue** | Conversation history helps |
+| Explaining what to ignore | **New task** | Cluttered context hurts quality |
+| Refining Cline's last output | **Continue** | Momentum and decisions preserved |
+
+To start a new task, click the **+** button in the Cline sidebar or use the `/newtask` command. Your file changes are preserved through [checkpoints](/core-workflows/checkpoints), and you can reference previous tasks from history anytime.
+
+## Understanding Task Costs
+
+Every cloud-based AI model charges for usage based on tokens, the units of text the model processes. Cline tracks these costs automatically and displays them in the task header so you can monitor spending as you work.
+
+### How Costs Are Calculated
+
+When you interact with Cline, the model processes:
+
+- **Input tokens**: Your prompts, file contents, conversation history, and system instructions
+- **Output tokens**: The model's responses, code suggestions, and tool calls
+
+Cloud providers charge per million tokens, with output tokens typically costing more than input. Some providers also support **prompt caching**, which reduces costs when the same context (like your cline rules or large files) appears in multiple requests. Cline automatically tracks cache savings when available.
+
+The estimated cost shown in the task header updates after each API request. This estimate uses the pricing information from your selected provider and may vary slightly from your final bill depending on how your provider rounds or bills usage.
+
+### When You Pay
+
+You pay for AI usage when using cloud providers like Anthropic, OpenAI, OpenRouter, or Google. Costs vary significantly:
+
+| Provider Type | Billing Model |
+|--------------|---------------|
+| **Cline Provider** | Pay-per-use with credits you purchase |
+| **ClinePass** | Flat monthly subscription for selected open coding models, with usage measured against your ClinePass quota |
+| **Direct API keys** | Billed by your provider (Anthropic, OpenAI, etc.) |
+| **OpenRouter/Requesty** | Aggregated billing across multiple models |
+| **Local models** | Free (you provide the hardware) |
+
+If you want predictable monthly spend instead of per-request charges, [ClinePass](/getting-started/clinepass) provides selected open coding models for $9.99/month. If you're using your own API keys, check your provider's pricing page for current rates. Prices change frequently and vary by model.
+
+### Free Options
+
+Not ready to pay? Cline offers several free paths:
+
+- **Free models**: Search "free" in the model selector when using the Cline Provider. These models display a **FREE** tag and work well for learning and experimentation.
+- **Free tiers**: Some providers offer limited free usage when you use your own API key.
+- **Local models**: Run models on your own hardware with zero per-request costs.
+
+### Self-Hosted Models
+
+Running models locally means no API costs, ever. Your only expense is the hardware to run them.
+
+To run local models effectively, you need:
+
+- **32GB RAM minimum** for entry-level models (4-bit quantization)
+- **64GB RAM** for better quality (8-bit quantization)
+- **128GB+ RAM** for cloud-competitive performance
+
+The trade-off is speed. Local models run at 5-20 tokens per second on typical hardware, compared to hundreds of tokens per second from cloud APIs. They also require more setup and configuration.
+
+<Tip>
+If you have the hardware, local models offer unlimited experimentation with complete privacy. See [Running Models Locally](/running-models-locally/overview) to get started.
+</Tip>
+
+For most users, starting with free cloud models and moving to paid options as needed provides the best balance of cost, speed, and capability. Check [Selecting Your Model](/getting-started/authorizing-with-cline) for guidance on choosing the right option for your workflow.
+
+
+## Task History
+
+Every task you work on is saved automatically to your local machine. You can revisit past conversations, resume interrupted work, or reference successful approaches from earlier sessions.
+
+### Finding Your History
+
+Click the **History** button in the Cline sidebar (clock icon at the top-right) to open the history view. You'll see all your past tasks with their initial prompt, timestamp, and token usage. Each task card expands to show a preview of the conversation.
+
+### Searching Tasks
+
+Use the search bar at the top of the history view to find specific tasks. The fuzzy search looks across everything: your prompts, Cline's responses, code snippets, and file names. 
+
+Sort results by:
+- **Newest/Oldest** for chronological browsing
+- **Most Expensive/Most Tokens** to find resource-heavy tasks
+- **Most Relevant** when searching for specific content
+- **Favorites** to show only starred tasks
+
+<Tip>
+Use favorites strategically. Star tasks that represent successful patterns, good prompts, or complex work you might want to reference later. Favorited tasks are protected from deletion.
+</Tip>
+
+## Resuming Tasks
+
+Cline can resume interrupted tasks with full context:
+
+1. Open the task from history
+2. Cline loads the complete conversation
+3. File states are checked against [checkpoints](/core-workflows/checkpoints)
+4. The task continues with awareness of the interruption
+5. Provide additional context if needed
+
+This works across sessions. Even if you close the editor and return days later, Cline can pick up where you left off.
diff --git a/docs/core-workflows/using-commands.mdx b/docs/core-workflows/using-commands.mdx
new file mode 100644
index 0000000..494e2b3
--- /dev/null
+++ b/docs/core-workflows/using-commands.mdx
@@ -0,0 +1,70 @@
+---
+title: "Using Commands"
+sidebarTitle: "Using Commands"
+description: "Built-in slash commands to manage context, plan implementations, and trigger reusable skills."
+---
+
+Cline provides slash commands in chat that help you manage your conversation and plan complex implementations.
+
+<Tip>
+**New to slash commands?** Watch our [quick video walkthrough](https://youtu.be/MxS5Jerpf-o) to see these commands in action.
+</Tip>
+
+## Slash Commands
+
+Type `/` in the chat input to see available slash commands:
+
+| Command | What It Does |
+|---------|--------------|
+| `/newtask` | Start fresh task with distilled context from current conversation |
+| `/smol` | Compress conversation history while preserving essential context |
+| `/newrule` | Create a rule file to teach Cline your preferences |
+| `/deep-planning` | Investigate codebase, plan thoroughly, then create implementation task |
+| `/reportbug` | Report a bug with diagnostic info |
+
+### /newtask
+
+`/newtask` works like a developer handoff. It packages what matters (overall plan, work accomplished, relevant files, next steps) into a fresh task with a clean context window, leaving behind the noise of tool calls and implementation details.
+
+I use `/newtask` when working through complex implementations. If I've completed 3 steps of a 10-step process and my context is already 75% full, I use `/newtask` to extract key decisions, file changes, and progress without all the noise.
+
+### /smol
+
+`/smol` (or its alias `/compact`) compresses your conversation history while preserving essential context. Unlike `/newtask` which creates a new task, `/smol` condenses your current conversation into a comprehensive summary, freeing up context window space while allowing you to continue working in the same task.
+
+Use `/smol` when you're deep into a debugging session or brainstorming and need to continue in the same task without losing the insights you've gained. For more details, see [Smol Command](#smol).
+
+### /newrule
+
+`/newrule` creates a rule file that teaches Cline your preferences. Cline will guide you through setting up guidelines for communication style, coding standards, project context, and reusable practices. The rule is saved to your `.clinerules` directory and automatically loaded for future conversations.
+
+Use `/newrule` when you find yourself repeating the same instructions across tasks. For more about rules, see [Cline Rules](/customization/cline-rules).
+
+### /deep-planning
+
+Transform Cline into a meticulous architect who investigates your codebase, asks clarifying questions, and creates a comprehensive implementation plan before writing any code. Deep planning follows a four-step process:
+
+1. **Silent Investigation** - Cline explores your codebase structure and patterns
+2. **Discussion** - Targeted questions about requirements and approach
+3. **Plan Creation** - Generates `implementation_plan.md` with detailed specifications
+4. **Task Creation** - Creates a new task with trackable implementation steps
+
+Use `/deep-planning` for features touching multiple parts of your codebase, architectural changes, or complex integrations.
+
+### /reportbug
+
+`/reportbug` collects diagnostic information and helps you report issues with Cline. It gathers relevant context like your configuration, recent errors, and system details to make bug reports more useful for the development team.
+
+Use `/reportbug` when you encounter unexpected behavior, crashes, or bugs you want to report.
+
+## Skills via Slash Commands
+
+In addition to built-in commands, you can trigger enabled skills directly from chat using slash commands.
+
+- Type `/` to open command suggestions.
+- Select a skill command (for example, `/aws-deploy`).
+- Cline loads that skill and applies its `SKILL.md` instructions for the task.
+
+Any enabled skill can be triggered this way, which gives you a fast path to skill-specific guidance without rewriting the same instructions each time.
+
+For setup and management details, see [Skills](/customization/skills#triggering-skills-with-slash-commands).
diff --git a/docs/core-workflows/working-with-files.mdx b/docs/core-workflows/working-with-files.mdx
new file mode 100644
index 0000000..5bd7105
--- /dev/null
+++ b/docs/core-workflows/working-with-files.mdx
@@ -0,0 +1,85 @@
+---
+title: "Adding Context"
+sidebarTitle: "Adding Context"
+description: "Use @ mentions and drag & drop to bring files into your conversations."
+---
+
+Cline works best when it has the right context, not just more context. `@` mentions let you pull in the files and folders that matter for your task — no copying, no pasting, no context switching.
+
+You can add context two ways:
+- Type `@` in the chat input and select a file or folder
+- Click the **+** button in the bottom left to browse files or images
+
+## Quick Reference
+
+| What you want | Syntax | Example |
+|---------------|--------|---------|
+| File content | `@/path/to/file` | `@/src/index.ts` |
+| Folder contents | `@/path/to/folder/` | `@/src/components/` |
+
+For other context — git history, web pages, terminal errors — just describe it. Cline will run `git log`, fetch the URL, or read the output itself.
+
+## File Mentions
+
+Reference any file with `@/path/to/file`. Cline sees the complete file content, including imports, related functions, and surrounding context.
+
+```text
+Can you refactor the error handling in @/src/api/users.ts?
+```
+
+## Folder Mentions
+
+Reference entire directories with `@/path/to/folder/` (note the trailing slash). Cline sees the folder structure and all file contents.
+
+```text
+Explain how the components in @/src/components/auth/ work together.
+```
+
+<Note>
+In multi-root workspaces, prefix paths with the workspace name: `@workspace-name:/path/to/file`
+</Note>
+
+## Drag & Drop
+
+Drag files directly into the chat input to add them to your conversation.
+
+<Note>
+In VS Code, hold **Shift** while dragging files into the chat input.
+</Note>
+
+Dragging workspace files automatically creates file mentions. You can also drag files from Finder or File Explorer directly into Cline.
+
+### Supported File Types
+
+Cline supports text files from your workspace, plus images, PDFs, CSVs, and Excel files from your file system.
+
+<Note>
+Images require a multimodal model. Check the model selector to see which models support image inputs.
+</Note>
+
+## Context Menu Commands
+
+Right-click on selected code to access Cline without typing. This is the fastest way to get help with specific code since it automatically includes the selected text and its file location as context.
+
+### Code Editor Commands
+
+| Command | When to Use |
+|---------|-------------|
+| **Add to Cline** | Ask questions about code, get suggestions, or start a conversation with specific code as context |
+| **Fix with Cline** | Quick fixes for errors, bugs, or issues in the selected code |
+| **Explain with Cline** | Understand unfamiliar code, complex logic, or code you're reviewing |
+| **Improve with Cline** | Get refactoring suggestions, performance improvements, or cleaner implementations |
+
+**Fix with Cline** also appears in the lightbulb menu (Quick Fix) when your cursor is on an error or warning, making it easy to fix issues inline.
+
+### Terminal Commands
+
+Right-click in the terminal to "Add to Cline" and get help with:
+- Build errors and failed commands
+- Test failures and stack traces
+- Configuration issues
+- Any terminal output you need help interpreting
+
+### Source Control Commands
+
+In the Source Control panel, use "Generate Commit Message" to create AI-powered commit messages from your staged changes. Cline analyzes the diff and writes a descriptive commit message following conventional commit patterns.
diff --git a/docs/customization/cline-rules.mdx b/docs/customization/cline-rules.mdx
new file mode 100644
index 0000000..24825e0
--- /dev/null
+++ b/docs/customization/cline-rules.mdx
@@ -0,0 +1,396 @@
+---
+title: "Rules"
+sidebarTitle: "Rules"
+description: "Define specific instructions and coding standards for Cline."
+---
+
+Rules are markdown files that provide persistent instructions across all conversations. Instead of repeating the same preferences every time you start a new task, rules let you define them once and have Cline follow them automatically.
+
+Use rules when you want Cline to:
+- Follow your team's coding standards (naming conventions, file organization, error handling patterns)
+- Understand project-specific context (tech stack, architecture decisions, dependencies)
+- Apply consistent documentation or testing requirements
+- Remember constraints like "don't modify files in /legacy" or "always use TypeScript"
+
+<Tip>
+  **New to Rules?** Watch [Cline Rules Explained](https://youtu.be/xQwsy2vkK5M) to see them in action.
+</Tip>
+
+
+## Supported Rule Types
+
+Cline recognizes rules from multiple sources, so you can use existing rule files from other tools:
+
+| Rule Type | Location | Description |
+|-----------|----------|-------------|
+| Cline Rules | `.clinerules/` | Primary rule format |
+| Cursor Rules | `.cursorrules` | Automatically detected |
+| Windsurf Rules | `.windsurfrules` | Automatically detected |
+| AGENTS.md | `AGENTS.md`, `~/.agents/AGENTS.md` | [Standard format](https://agents.md/) for cross-tool compatibility |
+
+All detected rule types appear in the Rules panel, where you can toggle them individually.
+
+
+## Where Rules Live
+
+Rules can be stored in two locations: your project workspace or globally on your system.
+
+**Workspace rules** go in `.clinerules/` at your project root. Use these for team standards, project-specific constraints, and anything you want to share with collaborators via version control.
+
+**Global rules** go in your system's Cline Rules directory. Use these for personal preferences that apply across all projects. Cline also reads cross-tool global AGENTS instructions from `~/.agents/AGENTS.md`.
+
+```text
+your-project/
+├── .clinerules/              # Workspace rules
+│   ├── coding.md             # Coding standards
+│   ├── testing.md            # Test requirements
+│   └── architecture.md       # Structural decisions
+├── src/
+└── ...
+```
+
+Cline processes all `.md` and `.txt` files inside `.clinerules/`, combining them into a unified set of rules. Numeric prefixes (like `01-coding.md`) help organize files but are optional.
+
+When both workspace and global rules exist, Cline combines them. Workspace rules take precedence when they conflict with global rules. See [Storage Locations](/getting-started/config#storage-locations) for more guidance.
+
+### Global Rules Directory
+
+| Operating System | Default Location |
+|------------------|------------------|
+| Windows | `Documents\Cline\Rules` |
+| macOS | `~/Documents/Cline/Rules` |
+| Linux/WSL | `~/Documents/Cline/Rules` |
+
+<Note>
+Linux/WSL users: If you don't find global rules in `~/Documents/Cline/Rules`, check `~/Cline/Rules`.
+</Note>
+
+
+## Creating Rules
+
+<Steps>
+  <Step title="Open the Rules menu">
+    Click the scale icon at the bottom of the Cline panel, to the left of the model selector.
+  </Step>
+  <Step title="Create a new rule file">
+    Click "New rule file..." and enter a filename (e.g., `coding-standards`). The file will be created with a `.md` extension.
+  </Step>
+  <Step title="Write your rule">
+    Add your instructions in markdown format. Keep each rule file focused on a single concern.
+  </Step>
+</Steps>
+
+You can also use the [`/newrule` slash command](/core-workflows/using-commands#newrule) to have Cline create a rule interactively.
+
+### Toggling Rules
+
+Every rule has a toggle to enable or disable it. This gives you fine-grained control over which rules apply to your current task without deleting the rule file.
+
+For example, you might have a strict testing rule that you want to disable when prototyping, or a client-specific rule you only need when working on that client's features.
+
+## Writing Effective Rules
+
+### Structure
+
+Rules work best when they're scannable and specific. Use markdown structure to organize instructions:
+
+```markdown
+# Rule Title
+
+Brief context about why this rule exists (optional but helpful).
+
+## Category 1
+- Specific instruction
+- Another instruction with example: `like this`
+- Reference to file: see /src/utils/example.ts
+
+## Category 2
+- More instructions
+- Include the "why" when it's not obvious
+```
+
+Cline reads rules as context, so formatting matters. Headers help Cline understand the scope of each instruction. Bullet points make individual requirements clear. Code examples show exactly what you want.
+
+### Best Practices
+
+**Be specific, not vague.** "Use descriptive variable names" is too broad. "Use camelCase for variables, PascalCase for classes, UPPER_SNAKE for constants" gives Cline something concrete to follow.
+
+**Include the why.** When a rule might seem arbitrary, explain the reason. "Don't modify files in /legacy (this code is scheduled for removal in Q2)" helps Cline make better decisions in edge cases.
+
+**Point to examples.** If your codebase already demonstrates the pattern you want, reference it. "Follow the error handling pattern in /src/utils/errors.ts" is more effective than describing the pattern from scratch.
+
+**Keep rules current.** Outdated rules confuse Cline and waste context. If a constraint no longer applies, remove it. If your tech stack changes, update the rules.
+
+**One concern per file.** Split rules by topic: `coding.md` for style, `testing.md` for test requirements, `architecture.md` for structural decisions. This makes it easy to toggle specific rules on or off.
+
+<Warning>
+Rules consume context tokens. Avoid lengthy explanations or pasting entire style guides. Keep rules concise and link to external documentation when detailed reference is needed.
+</Warning>
+
+## Example
+
+```markdown
+# Project Guidelines
+
+## Code Style
+- Use TypeScript for all new files
+- Prefer composition over inheritance
+- Use repository pattern for data access
+- Follow error handling pattern in /src/utils/errors.ts
+
+## Documentation
+- Update relevant docs when modifying features
+- Keep README.md in sync with new capabilities
+
+## Testing
+- Unit tests required for business logic
+- Integration tests for API endpoints
+- E2E tests for critical user flows
+```
+
+
+## Conditional Rules
+
+Conditional rules let you scope rules to specific parts of your codebase. Rules activate only when you're working with matching files, keeping your context focused and relevant.
+
+- **Without conditionals**: every rule loads for every request.
+- **With conditionals**, rules activate only when your current files match their defined scope.
+
+For example, documentation style rules should only appear when you're editing docs, not when you're writing application code or tests.
+
+As your rule library grows, loading every rule for every request wastes context tokens and can dilute Cline's focus. Conditional rules solve this by giving Cline only the instructions that matter for the files you're actually touching. This means faster, more accurate responses. Your frontend rules won't compete for attention when you're deep in backend code, and your testing standards appear exactly when you're writing tests. It's the difference between handing someone an entire policy manual versus the one page they need right now.
+
+### How It Works
+
+Conditional rules use YAML frontmatter at the top of your rule files. When Cline processes a request, it gathers context from your current work (open files, visible tabs, mentioned paths, edited files), evaluates each rule's conditions, and activates matching rules.
+
+<Note>
+When a conditional rule activates, you'll see a notification: **"Conditional rules applied: workspace:frontend-rules.md"**
+</Note>
+
+### Writing Conditional Rules
+
+Add YAML frontmatter to the top of any rule file in your `.clinerules/` directory:
+
+```yaml
+---
+paths:
+  - "src/components/**"
+  - "src/hooks/**"
+---
+
+# React Component Guidelines
+
+When creating or modifying React components:
+- Use functional components with React hooks
+- Extract reusable logic into custom React hooks
+- Keep components focused on a single responsibility
+```
+
+The `---` markers delimit the frontmatter. Everything after the closing `---` is your rule content.
+
+#### The `paths` Conditional
+
+Currently, `paths` is the supported conditional. It takes an array of glob patterns:
+
+```yaml
+---
+paths:
+  - "src/**"           # All files under src/
+  - "*.config.js"      # Config files in root
+  - "packages/*/src/"  # Monorepo package sources
+---
+```
+
+**Glob pattern syntax:**
+
+- `*` matches any characters except `/`
+- `**` matches any characters including `/` (recursive)
+- `?` matches a single character
+- `[abc]` matches any character in the brackets
+- `{a,b}` matches either pattern
+
+| Pattern | Matches |
+|---------|---------|
+| `src/**/*.ts` | All TypeScript files under `src/` |
+| `*.md` | Markdown files in root only |
+| `**/*.test.ts` | Test files anywhere in the project |
+| `packages/{web,api}/**` | Files in web or api packages |
+| `src/components/*.tsx` | TSX files directly in components (not nested) |
+
+#### Behavior Details
+
+**Multiple patterns**: A rule activates if any pattern matches any file in your context.
+
+```yaml
+---
+paths:
+  - "frontend/**"
+  - "mobile/**"
+---
+# Activates when working in frontend OR mobile
+```
+
+**No frontmatter**: Rules without frontmatter are always active.
+
+**Empty paths array**: `paths: []` means the rule never activates. Use this to temporarily disable a rule.
+
+**Invalid YAML**: If frontmatter can't be parsed, Cline fails open. The rule activates with raw content visible to help debugging.
+
+### What Counts as "Current Context"
+
+Cline evaluates rules based on:
+
+1. **Your message**: File paths mentioned in your prompt (e.g., "update `src/App.tsx`")
+2. **Open tabs**: Files currently open in your editor
+3. **Visible files**: Files visible in your active editor panes
+4. **Edited files**: Files Cline has created, modified, or deleted during the task
+5. **Pending operations**: Files Cline is about to edit
+
+Conditional rules can activate on your first message, when relevant files are open, or mid-task when Cline starts working with matching files.
+
+<Tip>
+Be explicit about file paths in your prompts. "Update `src/services/user.ts`" reliably triggers path-based rules; "update the user service" may not.
+</Tip>
+
+### Practical Examples
+
+Copy these patterns and adapt them to your project structure.
+
+#### Frontend vs Backend Rules
+
+Keep frontend and backend rules separate to avoid noise. Frontend rules only load when working with UI code, backend rules only load when working with API or service code.
+
+```yaml
+# .clinerules/frontend.md
+---
+paths:
+  - "src/components/**"
+  - "src/pages/**"
+  - "src/hooks/**"
+---
+
+# Frontend Guidelines
+
+- Use Tailwind CSS for styling
+- Prefer server components where possible
+- Keep client components small and focused
+```
+
+```yaml
+# .clinerules/backend.md
+---
+paths:
+  - "src/api/**"
+  - "src/services/**"
+  - "src/db/**"
+---
+
+# Backend Guidelines
+
+- Use dependency injection for services
+- All database queries go through repositories
+- Return typed errors, not thrown exceptions
+```
+
+#### Test File Rules
+
+Enforce testing standards automatically. This rule activates only when you're writing or modifying tests, so testing guidance appears exactly when you need it.
+
+```yaml
+# .clinerules/testing.md
+---
+paths:
+  - "**/*.test.ts"
+  - "**/*.spec.ts"
+  - "**/__tests__/**"
+---
+
+# Testing Standards
+
+- Use descriptive test names: "should [expected behavior] when [condition]"
+- One assertion per test when possible
+- Mock external dependencies, not internal modules
+- Use factories for test data, not fixtures
+```
+
+#### Documentation Rules
+
+Apply documentation standards only when editing docs. Prevents style rules from cluttering your context when you're writing code.
+
+```yaml
+# .clinerules/docs.md
+---
+paths:
+  - "docs/**"
+  - "**/*.md"
+  - "**/*.mdx"
+---
+
+# Documentation Guidelines
+
+- Use sentence case for headings
+- Include code examples for all features
+- Keep paragraphs short (3-4 sentences max)
+- Link to related documentation
+```
+
+### Combining with Rule Toggles
+
+Conditional rules work alongside the rule toggle UI. Toggle off a conditional rule to disable it entirely (it won't activate even if paths match). Toggle on to let it activate when conditions are met.
+
+This provides two levels of control: manual toggles and automatic condition-based activation.
+
+### Tips for Effective Conditional Rules
+
+**Start Broad, Then Narrow.** Begin with broader patterns and refine as you learn what works:
+
+```yaml
+# Start here
+paths:
+  - "src/**"
+
+# Then narrow down
+paths:
+  - "src/features/auth/**"
+```
+
+**Use Descriptive Filenames.** Name your rule files to indicate their scope:
+
+```text
+.clinerules/
+├── api-endpoints.md      # Rules for API code
+├── database-models.md    # Rules for DB layer
+├── react-components.md   # Rules for React
+└── universal.md          # No frontmatter = always active
+```
+
+**Keep Universal Rules Separate.** Put always-on rules (coding standards, project conventions) in files without frontmatter. Reserve conditional rules for context-specific guidance.
+
+**Test Your Patterns.** Not sure if a pattern matches? Create a simple test rule:
+
+```yaml
+---
+paths:
+  - "your/pattern/here/**"
+---
+TEST: This rule should activate for your/pattern/here files.
+```
+
+Then work with a file in that path and check if you see the activation notification.
+
+### Troubleshooting Conditional Rules
+
+**Rule not activating:**
+- Check that file paths in your context match the glob pattern
+- Verify the rule is toggled on in the rules panel
+- Ensure YAML frontmatter has proper `---` delimiters
+
+**Rule activating unexpectedly:**
+- Review glob patterns. `**` is recursive and may match more than intended
+- Check for open files that match the pattern
+- File paths mentioned in your message also count as context
+
+**Frontmatter showing in output:**
+- YAML couldn't be parsed
+- Check for syntax errors (unquoted special characters, improper indentation)
diff --git a/docs/customization/clineignore.mdx b/docs/customization/clineignore.mdx
new file mode 100644
index 0000000..05cae58
--- /dev/null
+++ b/docs/customization/clineignore.mdx
@@ -0,0 +1,109 @@
+---
+title: ".clineignore"
+sidebarTitle: ".clineignore"
+description: "Control which files and directories Cline can access in your project."
+---
+
+The `.clineignore` file tells Cline which files and directories to skip when analyzing your codebase. It works like `.gitignore`: create a file named `.clineignore` in your project root, add patterns for files you want excluded, and Cline will ignore them.
+
+## Why It Matters
+
+Without a `.clineignore`, Cline may load your entire project into context, including dependencies, build artifacts, and generated files. This wastes tokens, increases costs, and can push useful context out of the window.
+
+Adding a `.clineignore` can cut your starting context from 200k+ tokens to under 50k. That means faster responses, lower costs, and the ability to use smaller, cheaper models effectively.
+
+## Creating a .clineignore
+
+Create a file named `.clineignore` in your project root:
+
+```text
+# Dependencies
+node_modules/
+**/node_modules/
+
+# Build outputs
+/build/
+/dist/
+/.next/
+/out/
+
+# Testing artifacts
+/coverage/
+
+# Environment variables
+.env
+.env.*
+
+# Large data files
+*.csv
+*.xlsx
+*.sqlite
+
+# Generated/minified code
+*.min.js
+*.map
+```
+
+## Pattern Syntax
+
+`.clineignore` uses the same pattern syntax as `.gitignore`:
+
+| Pattern | Matches |
+|---------|---------|
+| `node_modules/` | The `node_modules` directory |
+| `**/node_modules/` | `node_modules` at any depth |
+| `*.csv` | All CSV files |
+| `/build/` | The `build` directory at the project root only |
+| `*.env.*` | Files like `.env.local`, `.env.production` |
+| `!important.csv` | Exception: do not ignore this file |
+
+Lines starting with `#` are comments. Blank lines are ignored.
+
+## What to Exclude
+
+Start with these categories and adjust for your project:
+
+**Almost always exclude:**
+- Package manager directories (`node_modules/`, `vendor/`, `.venv/`)
+- Build outputs (`dist/`, `build/`, `.next/`, `out/`)
+- Coverage reports (`coverage/`)
+- Lock files if large (`package-lock.json`, `yarn.lock`)
+
+**Exclude if present:**
+- Large data files (`.csv`, `.xlsx`, `.sqlite`, `.parquet`)
+- Binary assets (images, fonts, videos)
+- Generated code (API clients, protobuf outputs, minified bundles)
+- Environment files with secrets (`.env`, `.env.local`)
+
+**Keep accessible:**
+- Source code you actively work on
+- Configuration files Cline needs to understand (`tsconfig.json`, `package.json`)
+- Documentation and READMEs
+- Test files (Cline often needs these for context)
+
+## How It Works
+
+When Cline scans your project to build context, it checks each file path against your `.clineignore` patterns. Matching files are excluded from:
+
+- The file listing Cline sees when starting a task
+- Automatic context gathering during conversations
+- Search results when Cline looks for relevant code
+
+You can still reference ignored files explicitly using [@ mentions](/core-workflows/working-with-files). If you type `@/node_modules/some-package/index.js`, Cline will read that specific file even though `node_modules/` is in your `.clineignore`. The ignore rules control automatic loading, not explicit access.
+
+<Note>
+`.clineignore` is separate from `.gitignore`. Files tracked by Git but irrelevant to Cline (like large test fixtures or data files) should go in `.clineignore` even if they're not in `.gitignore`.
+</Note>
+
+## Tips
+
+- Add `.clineignore` early in your project. It's easier to start with broad exclusions and narrow them than to debug why context is bloated later.
+- Check your token usage in the task header after adding a `.clineignore`. The difference is often dramatic.
+- If Cline seems to be missing context about a file, check whether it's being excluded by your ignore patterns.
+- For monorepos or multi-root workspaces, each workspace root can have its own `.clineignore`. See [Multi-Root Workspaces](/features/multiroot-workspace) for details.
+
+## Related
+
+- [Cline Rules](/customization/cline-rules) - Define persistent instructions for Cline
+- [Task Management](/core-workflows/task-management#context-window) - Understand how context windows work
+- [Auto-Compact](/features/auto-compact) - Automatic context compression during long tasks
diff --git a/docs/customization/hooks.mdx b/docs/customization/hooks.mdx
new file mode 100644
index 0000000..055e1c2
--- /dev/null
+++ b/docs/customization/hooks.mdx
@@ -0,0 +1,7 @@
+---
+title: "Hooks"
+sidebarTitle: "Hooks"
+description: "See details under SDK Hooks page."
+---
+
+See details under [SDK Plugins](/sdk/plugins).
\ No newline at end of file
diff --git a/docs/customization/plugins.mdx b/docs/customization/plugins.mdx
new file mode 100644
index 0000000..5ab420c
--- /dev/null
+++ b/docs/customization/plugins.mdx
@@ -0,0 +1,147 @@
+---
+title: "Plugins"
+sidebarTitle: "Plugins"
+description: "Install and manage plugins that extend Cline with custom tools, hooks, and capabilities."
+---
+<Warning>
+  This feature currently only applies to Cline SDK, CLI, and Kanban. This feature is not applicable on VSCode and JetBrains Extension for now.
+</Warning>
+
+Plugins extend Cline with custom tools, lifecycle hooks, slash commands, and more. They can be installed globally (available in all sessions) or per-project.
+
+## Installing Plugins via CLI
+
+The `cline plugin install` command installs plugins from four source types:
+
+<Tabs>
+  <Tab title="File URL">
+    ```bash
+    cline plugin install https://github.com/owner/repo/blob/main/plugins/my-plugin.ts
+    cline plugin install https://raw.githubusercontent.com/owner/repo/main/plugins/my-plugin.ts
+    ```
+
+    File URLs install a single `.ts` or `.js` plugin file directly. GitHub `blob` and raw URLs are supported, and remote plugin file URLs must use `https://`.
+  </Tab>
+  <Tab title="Git Repository">
+    ```bash
+    cline plugin install https://github.com/owner/repo.git
+    cline plugin install git@github.com:owner/repo.git
+    ```
+
+    The installer clones the repository, installs production dependencies, and registers the plugin entry files.
+
+    To install a specific branch or tag, append `@ref`:
+
+    ```bash
+    cline plugin install https://github.com/owner/repo.git@v1.2.0
+    cline plugin install https://github.com/owner/repo.git@main
+    ```
+  </Tab>
+  <Tab title="npm Package">
+    ```bash
+    cline plugin install npm:@scope/my-plugin
+    cline plugin install --npm my-plugin
+    ```
+  </Tab>
+  <Tab title="Local Path">
+    ```bash
+    cline plugin install ./my-plugin
+    cline plugin install ~/plugins/my-tool
+    cline plugin install /absolute/path/to/plugin.ts
+    ```
+
+    Local installs copy the file or directory into the plugin store. Both single `.ts`/`.js` files and directories with a `package.json` are supported.
+  </Tab>
+</Tabs>
+
+Additional flags:
+
+| Flag | Description |
+|------|-------------|
+| `--force` | Replace an existing install for the same source |
+| `--json` | Output the result as JSON (useful for scripting) |
+| `--cwd <path>` | Install to `<path>/.cline/plugins` instead of the global directory |
+
+After installation, confirm the plugin is loaded by running `cline config` and checking the plugin tab.
+
+### Example: TypeScript Navigation Plugin
+
+The [typescript-lsp-plugin](https://github.com/cline/typescript-lsp-plugin) is a good reference for how plugins work. It adds a `goto_definition` tool that uses the TypeScript Language Service API to resolve symbol definitions through imports, re-exports, and type aliases.
+
+Install it with:
+
+```bash
+cline plugin install https://github.com/cline/typescript-lsp-plugin.git
+```
+
+Once installed, Cline can call `goto_definition` with a file path and line number to find where symbols are defined, which is much more precise than text search.
+
+## Plugin Manifest Format
+
+For a repository or npm package to be installable as a Cline plugin, its `package.json` should include a `cline` field that declares plugin entry points:
+
+```json
+{
+  "name": "my-cline-plugin",
+  "version": "1.0.0",
+  "cline": {
+    "plugins": [
+      {
+        "paths": ["./index.ts"],
+        "capabilities": ["tools", "hooks"]
+      }
+    ]
+  }
+}
+```
+
+The `cline.plugins` array accepts:
+
+| Format | Example |
+|--------|---------|
+| Object with `paths` array | `{ "paths": ["./src/plugin.ts"], "capabilities": ["tools"] }` |
+| Plain string | `"./index.ts"` |
+
+Each path should point to a `.ts` or `.js` file that exports an `AgentPlugin` (either as the default export or a named export).
+
+If no `cline.plugins` field is present, the installer falls back to auto-discovery: it looks for standard entry points, then recursively scans for `.ts` and `.js` files (skipping `node_modules` and `.git`).
+
+### Host-Provided Dependencies
+
+Dependencies under the `@cline/` scope are provided by the host runtime. The installer automatically strips these from the plugin's dependency list before running `npm install`, so declare any `@cline/*` package your plugin imports as an optional peer dependency. The host currently provides `@cline/sdk`, `@cline/core`, `@cline/agents`, `@cline/llms`, and `@cline/shared`.
+
+```json
+{
+  "peerDependencies": {
+    "@cline/sdk": "*"
+  },
+  "peerDependenciesMeta": {
+    "@cline/sdk": {
+      "optional": true
+    }
+  }
+}
+```
+
+## Plugin Directory Structure
+
+Plugins are stored in the `plugins` directory at two levels:
+
+```
+~/.cline/
+  plugins/                     # Global plugins
+    _installed/                # Managed by `cline plugin install`
+      npm/                     # npm-sourced plugins
+      git/                     # git-sourced plugins
+      remote/                  # file URL-sourced plugins
+      local/                   # local-sourced plugins
+
+.cline/                        # Project root
+  plugins/                     # Project-scoped plugins
+```
+
+Global plugins (`~/.cline/plugins/`) are available across all sessions. Project plugins (`.cline/plugins/` in your repo) are available only when working in that project.
+
+## Writing Plugins
+
+For a guide on building plugins with the SDK, see [Writing Plugins](/sdk/guides/writing-plugins). For the plugin API reference, see [SDK Plugins](/sdk/plugins).
diff --git a/docs/customization/skills.mdx b/docs/customization/skills.mdx
new file mode 100644
index 0000000..a4310b1
--- /dev/null
+++ b/docs/customization/skills.mdx
@@ -0,0 +1,271 @@
+---
+title: "Skills"
+sidebarTitle: "Skills"
+description: "Modular instruction sets that extend Cline's capabilities for specific tasks."
+---
+
+Skills are modular instruction sets that extend Cline's capabilities for specific tasks. Each skill packages detailed guidance, processes, and optional resources that Cline loads only when relevant to your request.
+
+Install multiple skills and Cline only loads what it needs. A deployment skill stays dormant until you ask about deploying. Unlike [rules](/customization/cline-rules) (which are always active), skills load on-demand so they don't consume context when you're working on something unrelated.
+
+<Note>
+Manage skills from the Skills menu: click the scale icon at the bottom of the Cline panel, to the left of the model selector, then switch to the **Skills** tab.
+</Note>
+
+## How Skills Work
+
+Skills use progressive loading to maximize efficiency:
+
+| Level | When Loaded | Token Cost | Content |
+|-------|-------------|------------|---------|
+| Metadata | Always (at startup) | ~100 tokens per skill | `name` and `description` from YAML frontmatter |
+| Instructions | When skill is triggered | Under 5k tokens | SKILL.md body with instructions and guidance |
+| Resources | As needed | Effectively unlimited | Bundled files accessed via `read_file` or executed scripts |
+
+When you send a message, Cline sees a list of available skills with their descriptions. If your request matches a skill's description, Cline activates it using the `use_skill` tool, which loads the full instructions from SKILL.md.
+
+## Triggering Skills with Slash Commands
+
+You can also invoke enabled skills explicitly from the chat input using slash commands.
+
+1. Type `/` in chat to open command suggestions.
+2. Select the skill command you want to run (for example, `/aws-deploy`).
+3. Cline triggers that skill and loads its `SKILL.md` instructions.
+
+This is useful when you want to force a specific skill immediately instead of waiting for auto-matching based on description.
+
+## Skill Structure
+
+Every skill is a directory containing a `SKILL.md` file with YAML frontmatter.
+
+```text title="Skill directory structure"
+my-skill/
+├── SKILL.md          # Required: main instructions
+├── docs/             # Optional: additional documentation
+│   └── advanced.md
+└── scripts/          # Optional: utility scripts
+    └── helper.sh
+```
+
+The `SKILL.md` file has two parts: metadata and instructions.
+
+```markdown title="SKILL.md"
+---
+name: my-skill
+description: Brief description of what this skill does and when to use it.
+---
+
+# My Skill
+
+Detailed instructions for Cline to follow when this skill is activated.
+
+## Steps
+1. First, do this
+2. Then do that
+3. For advanced usage, see [advanced.md](docs/advanced.md)
+```
+
+Required fields:
+- `name` must exactly match the directory name
+- `description` tells Cline when to use this skill (max 1024 characters)
+
+## Creating a Skill
+
+<Steps>
+  <Step title="Open the Skills menu">
+    Click the scale icon at the bottom of the Cline panel, to the left of the model selector. Switch to the Skills tab.
+  </Step>
+  <Step title="Create a new skill">
+    Click "New skill..." and enter a name for your skill (e.g., `aws-deploy`). Cline creates a skill directory with a template `SKILL.md` file.
+  </Step>
+  <Step title="Write your skill instructions">
+    Edit the `SKILL.md` file:
+    - Update the `description` field to specify when this skill should trigger
+    - Add detailed instructions in the body
+    - Optionally add supporting files in `docs/`, `templates/`, or `scripts/` subdirectories
+  </Step>
+</Steps>
+
+You can also create skills manually by creating the directory structure in your file system. Place skill directories in `.cline/skills/` (workspace) or `~/.cline/skills/` (global) and Cline will detect them automatically.
+
+Put the important information first in your SKILL.md. Cline reads the file sequentially, so front-load the common cases. Use clear section headers like "## Error Handling" or "## Configuration" so Cline can scan for relevant sections.
+
+### Toggling Skills
+
+Every skill has a toggle to enable or disable it. This lets you control which skills are active without deleting the skill directory. Skills are enabled by default when discovered.
+
+For example, you might disable a CI/CD skill when working on local development, or enable a client-specific skill only when working on that client's project.
+
+## Writing Your SKILL.md
+
+### Naming Conventions
+
+The skill name appears in the `name` field and must match the directory name exactly. Use lowercase with hyphens (kebab-case) and be descriptive about what the skill does.
+
+Good names:
+- `aws-cdk-deploy`
+- `pr-review-checklist`
+- `database-migration`
+- `api-client-generator`
+
+Avoid:
+- `aws` (too vague)
+- `my_skill` (underscores, not descriptive)
+- `DeployToAWS` (use kebab-case, not PascalCase)
+- `misc-helpers` (too generic)
+
+### Writing Effective Descriptions
+
+The description determines when Cline activates the skill. A vague description means the skill won't trigger when you expect it to.
+
+Good descriptions are specific and actionable:
+
+```yaml
+description: Deploy applications to AWS using CDK. Use when deploying, updating infrastructure, or managing AWS resources.
+
+description: Generate release notes from git commits. Use when preparing releases, writing changelogs, or summarizing recent changes.
+
+description: Analyze CSV and Excel data files. Use when exploring datasets, generating statistics, or creating visualizations from tabular data.
+```
+
+Weak descriptions leave too much ambiguity:
+
+```yaml
+description: Helps with AWS stuff.
+
+description: Data analysis helper.
+
+description: Useful for releases.
+```
+
+Start with what the skill does (action verbs), include trigger phrases users might say, and mention specific file types, tools, or domains. Test your descriptions by trying different phrasings of requests to see if the skill triggers.
+
+### Keeping Skills Focused
+
+Keep SKILL.md under 5k tokens. If your skill needs more content, split it into separate files in a `docs/` directory and reference them from the main instructions. Cline loads referenced files only when needed.
+
+Include real examples. Show what commands to run, what output to expect, and what the result should look like. Abstract instructions are harder to follow than concrete examples.
+
+## Where Skills Live
+
+Skills can be stored globally or in a project workspace. See [Storage Locations](/getting-started/config#storage-locations) for guidance on when to use each.
+
+Project skills:
+- `.cline/skills/` (recommended)
+- `.clinerules/skills/`
+- `.claude/skills/`
+
+Global skills:
+- `~/.cline/skills/` (macOS/Linux)
+- `C:\Users\USERNAME\.cline\skills\` (Windows)
+
+When a global skill and project skill have the same name, the global skill takes precedence. This lets you keep general-purpose skills globally while using project-specific skills in `.cline/skills/` so the whole team can use them.
+
+Version control your project skills by committing `.cline/skills/`. Your team can share, review, and improve them together.
+
+## Bundling Supporting Files
+
+Skills can include additional files that Cline accesses only when needed.
+
+```text title="Directory structure"
+complex-skill/
+├── SKILL.md
+├── docs/
+│   ├── setup.md
+│   └── troubleshooting.md
+├── templates/
+│   └── config.yaml
+└── scripts/
+    └── validate.py
+```
+
+### docs/
+
+Use docs for information that's too detailed for SKILL.md or only relevant in specific situations:
+- Advanced configuration options
+- Troubleshooting guides for edge cases
+- Reference material (API schemas, database schemas)
+- Platform-specific instructions
+
+A deployment skill might have `docs/aws.md`, `docs/gcp.md`, and `docs/azure.md`. Cline loads only the relevant platform guide based on your request.
+
+### templates/
+
+Use templates when your skill creates configuration files, boilerplate code, or structured documents:
+- Config files (Terraform, Docker Compose, CI/CD pipelines)
+- Code scaffolding (component templates, test fixtures)
+- Documentation templates (README, API docs)
+
+A project setup skill could include `templates/dockerfile`, `templates/docker-compose.yml`, and `templates/.env.example` that Cline customizes for each new project.
+
+### scripts/
+
+Use scripts for deterministic operations where you want consistent behavior:
+- Validation (linting configs, checking prerequisites)
+- Data processing (parsing, formatting, transforming)
+- Complex calculations (cost estimation, resource sizing)
+- API interactions (fetching data, running health checks)
+
+Scripts are token-efficient because only their output enters context, not the code itself. A 500-line validation script produces a simple "Passed" or detailed error messages without consuming any context for the script logic.
+
+### Referencing Bundled Files
+
+Reference these files in your SKILL.md instructions:
+
+```markdown title="SKILL.md (referencing bundled files)"
+For initial setup, follow [setup.md](docs/setup.md).
+Use the config template at `templates/config.yaml` as a starting point.
+Run the validation script to check your configuration:
+
+python scripts/validate.py
+```
+
+Cline reads documentation files using `read_file` when the instructions reference them. Scripts can be executed directly, and only the script's output enters the context window.
+
+| Use Scripts For | Use Instructions For |
+|-----------------|---------------------|
+| Deterministic operations (validation, formatting) | Flexible guidance that adapts to context |
+| Complex computations | Decision-making processes |
+| Operations that need reliability | Steps that might vary by situation |
+| Anything you'd rather not consume tokens explaining | Best practices and patterns |
+
+## Example: Data Analysis Skill
+
+Here's a practical skill for data analysis tasks. Create a directory called `data-analysis/` with this `SKILL.md`:
+
+```markdown title="data-analysis/SKILL.md"
+---
+name: data-analysis
+description: Analyze data files and generate insights. Use when working with CSV, Excel, or JSON data files that need exploration, cleaning, or visualization.
+---
+
+# Data Analysis
+
+When analyzing data files, follow this process:
+
+## 1. Understand the Data
+- Read a sample of the file to understand its structure
+- Identify column types and data quality issues
+- Note any missing values or anomalies
+
+## 2. Ask Clarifying Questions
+Before diving in, ask the user:
+- What specific insights are they looking for?
+- Are there any known data quality issues?
+- What format do they want for the output?
+
+## 3. Perform Analysis
+Use pandas for data manipulation:
+
+import pandas as pd
+
+# Load and explore
+df = pd.read_csv("data.csv")
+print(df.head())
+print(df.describe())
+print(df.info())
+
+For visualization, prefer matplotlib or seaborn depending on complexity.
+```
+
+Skills transform Cline from a general-purpose assistant into a specialist that knows your domain. Start with one skill for a task you repeat often, test it, and iterate on the description until it triggers reliably.
diff --git a/docs/docs.json b/docs/docs.json
new file mode 100644
index 0000000..0061076
--- /dev/null
+++ b/docs/docs.json
@@ -0,0 +1,1123 @@
+{
+	"$schema": "https://mintlify.com/docs.json",
+	"theme": "mint",
+	"name": "Cline",
+	"description": "AI-powered coding agent for complex work",
+	"colors": {
+		"primary": "#9D4EDD",
+		"light": "#F0E6FF",
+		"dark": "#000000"
+	},
+	"logo": {
+		"light": "/assets/Cline_Logo-complete_black.png",
+		"dark": "/assets/Cline_Logo-complete_white.png",
+		"href": "https://cline.bot/"
+	},
+	"favicon": {
+		"light": "/assets/robot_panel_light.png",
+		"dark": "/assets/robot_panel_dark.png"
+	},
+	"background": {
+		"color": {
+			"light": "#fafaf9",
+			"dark": "#0f0f0f"
+		}
+	},
+	"styling": {
+		"eyebrows": "breadcrumbs",
+		"codeblocks": "system",
+		"css": "styles.css"
+	},
+	"appearance": {
+		"default": "system",
+		"strict": false
+	},
+	"fonts": {
+		"family": "Geist Sans"
+	},
+	"navbar": {
+		"links": [
+			{
+				"label": "GitHub",
+				"icon": "github",
+				"href": "https://github.com/cline/cline"
+			},
+			{
+				"label": "Discord",
+				"icon": "discord",
+				"href": "https://discord.gg/cline"
+			}
+		],
+		"primary": {
+			"type": "button",
+			"label": "Install Cline",
+			"href": "https://cline.bot/install?utm_source=website&utm_medium=header"
+		}
+	},
+	"navigation": {
+		"tabs": [
+			{
+				"tab": "Cline",
+				"icon": "robot",
+				"groups": [
+					{
+						"group": "Getting Started",
+						"pages": [
+							"cline-overview",
+							"getting-started/installing-cline",
+							"getting-started/cline-provider",
+							"getting-started/clinepass",
+							{
+								"group": "Other Models & Providers",
+								"pages": [
+									"getting-started/authorizing-with-cline",
+									"running-models-locally/overview",
+									{
+										"group": "Cloud Providers",
+										"pages": [
+											"provider-config/qwen",
+											"provider-config/anthropic",
+											{
+												"group": "AWS Bedrock",
+												"pages": [
+													"provider-config/aws-bedrock/api-key",
+													"provider-config/aws-bedrock/iam-credentials",
+													"provider-config/aws-bedrock/cli-profile"
+												]
+											},
+											"provider-config/deepseek",
+											"provider-config/google-gemini",
+											"provider-config/minimax",
+											"provider-config/openai",
+											"provider-config/openai-compatible",
+											"provider-config/openrouter",
+											"provider-config/zai",
+											"provider-config/other-30-plus-providers"
+										]
+									}
+								]
+							},
+							"getting-started/config"
+						]
+					},
+					{
+						"group": "Usage",
+						"pages": [
+							"usage/ide",
+							"usage/tui",
+							{
+								"group": "CLI",
+								"pages": [
+									"usage/cli-overview",
+									"cli/cli-reference",
+									{
+										"group": "Examples",
+										"pages": [
+											"cli/samples/github-issue-rca",
+											"cli/samples/github-integration",
+											"cli/samples/github-pr-review",
+											"cli/samples/model-orchestration",
+											"cli/samples/supply-chain-alerts"
+										]
+									}
+								]
+							},
+							{
+								"group": "Kanban",
+								"pages": [
+									"usage/kanban",
+									"kanban/core-workflow",
+									"kanban/remote-access"
+								]
+							}
+						]
+					},
+					{
+						"group": "Configurations",
+						"pages": [
+							"tools-reference/all-cline-tools",
+							"customization/cline-rules",
+							"customization/skills",
+							"customization/plugins",
+							"mcp/mcp-overview",
+							"customization/hooks",
+							"cli/scheduling",
+							"cli/connectors",
+							"customization/clineignore"
+						]
+					},
+					{
+						"group": "Features",
+						"pages": [
+							"core-workflows/plan-and-act",
+							"core-workflows/working-with-files",
+							"core-workflows/using-commands",
+							"core-workflows/checkpoints",
+							"cli/agent-teams",
+							"features/subagents"
+						]
+					},
+					{
+						"group": "Best Practices",
+						"pages": [
+							"best-practices/memory-bank"
+						]
+					},
+					{
+						"group": "IDE Specific Features",
+						"pages": [
+							"features/auto-approve",
+							"features/jupyter-notebooks",
+							"features/multiroot-workspace"
+						]
+					},
+					{
+						"group": "Troubleshooting",
+						"pages": [
+							"troubleshooting/networking-and-proxies"
+						]
+					}
+				]
+			},
+			{
+				"tab": "SDK",
+				"icon": "cube",
+				"groups": [
+					{
+						"group": "Start",
+						"pages": [
+							"sdk/overview",
+							"sdk/examples"
+						]
+					},
+					{
+						"group": "Concepts",
+						"pages": [
+							{
+								"group": "Plugins",
+								"pages": [
+									"sdk/plugins",
+									"sdk/plugin-install",
+									"sdk/guides/writing-plugins",
+									"sdk/plugin-examples"
+								]
+							},
+							{
+								"group": "Tools",
+								"pages": [
+									"sdk/tools",
+									"sdk/guides/creating-custom-tools"
+								]
+							},
+							"sdk/guides/scheduled-agents",
+							"sdk/events",
+							"sdk/model-providers",
+							"sdk/clinecore"
+						]
+					},
+					{
+						"group": "Architecture",
+						"pages": [
+							"sdk/architecture/overview",
+							"sdk/architecture/hub-spoke"
+						]
+					},
+					{
+						"group": "Guides",
+						"pages": [
+							"sdk/guides/building-an-agent",
+							"sdk/guides/permission-handling",
+							"sdk/guides/multi-agent-teams",
+							"sdk/guides/going-to-production"
+						]
+					},
+					{
+						"group": "API Reference",
+						"pages": [
+							"sdk/reference/cline-core",
+							"sdk/reference/agent",
+							"sdk/reference/gateway",
+							"sdk/reference/tools-api",
+							"sdk/reference/events",
+							"sdk/reference/types"
+						]
+					}
+				]
+			},
+			{
+				"tab": "Enterprise",
+				"icon": "building",
+				"groups": [
+					{
+						"group": "Enterprise Solutions",
+						"pages": [
+							"enterprise-solutions/overview",
+							"enterprise-solutions/onboarding",
+							"enterprise-solutions/sso-setup",
+							"enterprise-solutions/team-management/managing-members",
+							{
+								"group": "Remote Provider Configuration",
+								"pages": [
+									"enterprise-solutions/configuration/remote-configuration/overview",
+									{
+										"group": "AWS Bedrock",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
+										]
+									},
+									{
+										"group": "Google Vertex AI",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration"
+										]
+									},
+									{
+										"group": "OpenAI Compatible",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/openai-compatible/member-configuration"
+										]
+									},
+									{
+										"group": "Anthropic",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/anthropic/member-configuration"
+										]
+									},
+									{
+										"group": "LiteLLM",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/litellm/member-configuration"
+										]
+									}
+								]
+							},
+							{
+								"group": "Control Other Cline Features",
+								"pages": [
+									"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode",
+									"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-server-controls"
+								]
+							},
+							{
+								"group": "Monitoring",
+								"pages": [
+									"enterprise-solutions/monitoring/overview",
+									"enterprise-solutions/monitoring/telemetry",
+									"enterprise-solutions/monitoring/prompt-storage",
+									"enterprise-solutions/monitoring/opentelemetry",
+									"enterprise-solutions/monitoring/opentelemetry-events",
+									"enterprise-solutions/monitoring/opentelemetry_override"
+								]
+							},
+							"enterprise-solutions/api-reference"
+						]
+					}
+				]
+			},
+			{
+				"tab": "API",
+				"icon": "code",
+				"groups": [
+					{
+						"group": "Cline API",
+						"pages": [
+							"api/overview",
+							"api/getting-started",
+							"api/authentication"
+						]
+					},
+					{
+						"group": "Endpoints",
+						"pages": [
+							"api/chat-completions"
+						]
+					},
+					{
+						"group": "Reference",
+						"pages": [
+							"api/models",
+							"api/errors",
+							"api/sdk-examples"
+						]
+					}
+				]
+			}
+		]
+	},
+	"footer": {
+		"socials": {
+			"x": "https://x.com/cline",
+			"github": "https://github.com/cline/cline",
+			"discord": "https://discord.gg/cline"
+		}
+	},
+	"anchors": [
+		{
+			"name": "Overview",
+			"icon": "house",
+			"url": "cline-overview"
+		}
+	],
+	"redirects": [
+		{
+			"source": "/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-marketplace",
+			"destination": "/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-server-controls"
+		},
+		{
+			"source": "/usage/cli",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/getting-started/installing-cline-jetbrains",
+			"destination": "/getting-started/installing-cline"
+		},
+		{
+			"source": "/getting-started/for-new-coders",
+			"destination": "/getting-started/installing-cline"
+		},
+		{
+			"source": "/getting-started/overview",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/getting-started/your-first-project",
+			"destination": "/usage/ide"
+		},
+		{
+			"source": "/introduction",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/introduction/welcome",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/introduction/overview",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/getting-started/model-selection-guide",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/provider-config/ollama",
+			"destination": "/running-models-locally/overview#runtime-options"
+		},
+		{
+			"source": "/running-models-locally/read-me-first",
+			"destination": "/running-models-locally/overview"
+		},
+		{
+			"source": "/running-models-locally/ollama",
+			"destination": "/running-models-locally/overview#runtime-options"
+		},
+		{
+			"source": "/running-models-locally/lm-studio",
+			"destination": "/running-models-locally/overview#runtime-options"
+		},
+		{
+			"source": "/getting-started/understanding-context-management",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/best-practices/understanding-context-management",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/prompting/understanding-context-management",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/model-config/context-windows",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/core-features/model-selection-guide",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/prompting/prompt-engineering-guide",
+			"destination": "/customization/cline-rules"
+		},
+		{
+			"source": "/prompting/cline-memory-bank",
+			"destination": "/best-practices/memory-bank"
+		},
+		{
+			"source": "/customization/memory-bank",
+			"destination": "/best-practices/memory-bank"
+		},
+		{
+			"source": "/customization/overview",
+			"destination": "/getting-started/config"
+		},
+		{
+			"source": "/customization/focus-chain",
+			"destination": "/core-workflows/using-commands#deep-planning"
+		},
+		{
+			"source": "/features/deep-planning",
+			"destination": "/core-workflows/using-commands#deep-planning"
+		},
+		{
+			"source": "/customization/auto-approve",
+			"destination": "/features/auto-approve"
+		},
+		{
+			"source": "/customization/auto-compact",
+			"destination": "/features/auto-compact"
+		},
+		{
+			"source": "/getting-started/your-first-task",
+			"destination": "/usage/ide"
+		},
+		{
+			"source": "/features/hooks/real-world-examples",
+			"destination": "/customization/hooks"
+		},
+		{
+			"source": "/features/hooks/index",
+			"destination": "/customization/hooks"
+		},
+		{
+			"source": "/features/hooks/hook-reference",
+			"destination": "/customization/hooks"
+		},
+		{
+			"source": "/features/hooks/samples",
+			"destination": "/customization/hooks"
+		},
+		{
+			"source": "/features/plan-and-act",
+			"destination": "/core-workflows/plan-and-act"
+		},
+		{
+			"source": "/features/checkpoints",
+			"destination": "/core-workflows/checkpoints"
+		},
+		{
+			"source": "/features/tasks/understanding-tasks",
+			"destination": "/core-workflows/task-management"
+		},
+		{
+			"source": "/features/tasks/task-management",
+			"destination": "/core-workflows/task-management"
+		},
+		{
+			"source": "/features/at-mentions/overview",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/at-mentions/file-mentions",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/at-mentions/folder-mentions",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/at-mentions/terminal-mentions",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/at-mentions/problem-mentions",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/at-mentions/git-mentions",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/at-mentions/url-mentions",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/drag-and-drop",
+			"destination": "/core-workflows/working-with-files"
+		},
+		{
+			"source": "/features/yolo-mode",
+			"destination": "/features/auto-approve"
+		},
+		{
+			"source": "/features/cline-rules",
+			"destination": "/customization/cline-rules"
+		},
+		{
+			"source": "/features/cline-rules/overview",
+			"destination": "/customization/cline-rules"
+		},
+		{
+			"source": "/features/cline-rules/conditional-rules",
+			"destination": "/customization/cline-rules"
+		},
+		{
+			"source": "/features/commands-and-shortcuts/overview",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/features/commands-and-shortcuts/code-commands",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/features/commands-and-shortcuts/terminal-integration",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/features/commands-and-shortcuts/git-integration",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/features/commands-and-shortcuts/keyboard-shortcuts",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/features/slash-commands/new-task",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/exploring-clines-tools/cline-tools-guide",
+			"destination": "/tools-reference/all-cline-tools"
+		},
+		{
+			"source": "/exploring-clines-tools/new-task-tool",
+			"destination": "/tools-reference/all-cline-tools"
+		},
+		{
+			"source": "/exploring-clines-tools/remote-browser-support",
+			"destination": "/tools-reference/all-cline-tools"
+		},
+		{
+			"source": "/mcp/adding-mcp-servers-from-github",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/mcp/configuring-mcp-servers",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/more-info/telemetry",
+			"destination": "/enterprise-solutions/monitoring/telemetry"
+		},
+		{
+			"source": "/enterprise-solutions/configure-AWS-Bedrock-Admin",
+			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration"
+		},
+		{
+			"source": "/enterprise-solutions/configure-AWS-Bedrock-Member",
+			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
+		},
+		{
+			"source": "/enterprise-solutions/configure-workOS-authkit",
+			"destination": "/enterprise-solutions/onboarding"
+		},
+		{
+			"source": "/enterprise-solutions/Onboarding your Organization",
+			"destination": "/enterprise-solutions/onboarding"
+		},
+		{
+			"source": "/enterprise-solutions/team-management/overview",
+			"destination": "/enterprise-solutions/team-management/managing-members"
+		},
+		{
+			"source": "/enterprise-solutions/team-management/roles-and-permissions",
+			"destination": "/enterprise-solutions/team-management/managing-members"
+		},
+		{
+			"source": "/features/customization/opening-cline-in-sidebar",
+			"destination": "/getting-started/installing-cline"
+		},
+		{
+			"source": "/prompting/prompt-engineering-guide/clineignore-file-guide",
+			"destination": "/customization/clineignore"
+		},
+		{
+			"source": "/getting-started/selecting-your-model",
+			"destination": "/getting-started/authorizing-with-cline"
+		},
+		{
+			"source": "/model-config/model-comparison",
+			"destination": "/getting-started/cline-provider"
+		},
+		{
+			"source": "/troubleshooting/terminal-integration-guide",
+			"destination": "/core-workflows/using-commands"
+		},
+		{
+			"source": "/features/slash-commands/deep-planning",
+			"destination": "/core-workflows/using-commands#deep-planning"
+		},
+		{
+			"source": "/features/slash-commands/smol",
+			"destination": "/core-workflows/using-commands#smol"
+		},
+		{
+			"source": "/features/slash-commands/new-rule",
+			"destination": "/core-workflows/using-commands#newrule"
+		},
+		{
+			"source": "/features/memory-bank",
+			"destination": "/best-practices/memory-bank"
+		},
+		{
+			"source": "/features/focus-chain",
+			"destination": "/core-workflows/using-commands#deep-planning"
+		},
+		{
+			"source": "/features/skills",
+			"destination": "/customization/skills"
+		},
+		{
+			"source": "/api/reference",
+			"destination": "/api/overview"
+		},
+		{
+			"source": "/cli/overview",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/kanban/overview",
+			"destination": "/usage/kanban"
+		},
+		{
+			"source": "/kanban/getting-started",
+			"destination": "/usage/kanban"
+		},
+		{
+			"source": "/kanban/features",
+			"destination": "/usage/kanban"
+		},
+		{
+			"source": "/features/background-edit",
+			"destination": "/features/auto-approve"
+		},
+		{
+			"source": "/features/worktrees",
+			"destination": "/usage/ide"
+		},
+		{
+			"source": "/cli/getting-started",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/cli/installation",
+			"destination": "/getting-started/installing-cline"
+		},
+		{
+			"source": "/cli/three-core-flows",
+			"destination": "/usage/cli-overview#headless-mode"
+		},
+		{
+			"source": "/cline-cli/getting-started",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/cline-cli/installation",
+			"destination": "/getting-started/installing-cline"
+		},
+		{
+			"source": "/cline-cli/three-core-flows",
+			"destination": "/usage/cli-overview#headless-mode"
+		},
+		{
+			"source": "/cline-cli/connectors",
+			"destination": "/cli/connectors"
+		},
+		{
+			"source": "/cline-cli/scheduling",
+			"destination": "/cli/scheduling"
+		},
+		{
+			"source": "/cline-cli/mcp-servers",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/cli/mcp-servers",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/cline-cli/agent-teams",
+			"destination": "/cli/agent-teams"
+		},
+		{
+			"source": "/cline-cli/cli-reference",
+			"destination": "/cli/cli-reference"
+		},
+		{
+			"source": "/cline-cli/configuration",
+			"destination": "/getting-started/config"
+		},
+		{
+			"source": "/provider-config/claude-code",
+			"destination": "/provider-config/anthropic"
+		},
+		{
+			"source": "/provider-config/openai-codex",
+			"destination": "/provider-config/openai"
+		},
+		{
+			"source": "/cli/configuration",
+			"destination": "/getting-started/config"
+		},
+		{
+			"source": "/cline-cli/acp-editor-integrations",
+			"destination": "/cli/acp-editor-integrations"
+		},
+		{
+			"source": "/cline-cli/samples/github-issue-rca",
+			"destination": "/cli/samples/github-issue-rca"
+		},
+		{
+			"source": "/cline-cli/samples/github-integration",
+			"destination": "/cli/samples/github-integration"
+		},
+		{
+			"source": "/cline-cli/samples/github-pr-review",
+			"destination": "/cli/samples/github-pr-review"
+		},
+		{
+			"source": "/cline-cli/samples/model-orchestration",
+			"destination": "/cli/samples/model-orchestration"
+		},
+		{
+			"source": "/cline-sdk/overview",
+			"destination": "/sdk/overview"
+		},
+		{
+			"source": "/cline-sdk/quickstart",
+			"destination": "/sdk/guides/building-an-agent"
+		},
+		{
+			"source": "/sdk/quickstart",
+			"destination": "/sdk/guides/building-an-agent"
+		},
+		{
+			"source": "/cline-sdk/examples",
+			"destination": "/sdk/guides/building-an-agent"
+		},
+		{
+			"source": "/cline-sdk/agents",
+			"destination": "/sdk/clinecore"
+		},
+		{
+			"source": "/cline-sdk/sessions",
+			"destination": "/sdk/clinecore"
+		},
+		{
+			"source": "/cline-sdk/tools",
+			"destination": "/sdk/tools"
+		},
+		{
+			"source": "/cline-sdk/streaming-and-events",
+			"destination": "/sdk/events"
+		},
+		{
+			"source": "/cline-sdk/plugins",
+			"destination": "/sdk/plugins"
+		},
+		{
+			"source": "/cline-sdk/hooks",
+			"destination": "/sdk/plugins"
+		},
+		{
+			"source": "/cline-sdk/model-providers",
+			"destination": "/sdk/model-providers"
+		},
+		{
+			"source": "/cline-sdk/guides/building-an-agent",
+			"destination": "/sdk/guides/building-an-agent"
+		},
+		{
+			"source": "/cline-sdk/guides/creating-custom-tools",
+			"destination": "/sdk/guides/creating-custom-tools"
+		},
+		{
+			"source": "/cline-sdk/guides/writing-plugins",
+			"destination": "/sdk/guides/writing-plugins"
+		},
+		{
+			"source": "/cline-sdk/guides/permission-handling",
+			"destination": "/sdk/guides/permission-handling"
+		},
+		{
+			"source": "/cline-sdk/guides/scheduled-agents",
+			"destination": "/sdk/guides/scheduled-agents"
+		},
+		{
+			"source": "/cline-sdk/guides/multi-agent-teams",
+			"destination": "/sdk/guides/multi-agent-teams"
+		},
+		{
+			"source": "/cline-sdk/guides/connectors",
+			"destination": "/cli/connectors"
+		},
+		{
+			"source": "/sdk/guides/connectors",
+			"destination": "/cli/connectors"
+		},
+		{
+			"source": "/cline-sdk/guides/going-to-production",
+			"destination": "/sdk/guides/going-to-production"
+		},
+		{
+			"source": "/cline-sdk/architecture/overview",
+			"destination": "/sdk/architecture/overview"
+		},
+		{
+			"source": "/cline-sdk/architecture/hub-spoke",
+			"destination": "/sdk/architecture/hub-spoke"
+		},
+		{
+			"source": "/cline-sdk/architecture/packages",
+			"destination": "/sdk/architecture/overview"
+		},
+		{
+			"source": "/cline-sdk/reference/cline-core",
+			"destination": "/sdk/reference/cline-core"
+		},
+		{
+			"source": "/cline-sdk/reference/agent",
+			"destination": "/sdk/reference/agent"
+		},
+		{
+			"source": "/cline-sdk/reference/gateway",
+			"destination": "/sdk/reference/gateway"
+		},
+		{
+			"source": "/cline-sdk/reference/tools-api",
+			"destination": "/sdk/reference/tools-api"
+		},
+		{
+			"source": "/cline-sdk/reference/events",
+			"destination": "/sdk/reference/events"
+		},
+		{
+			"source": "/cline-sdk/reference/types",
+			"destination": "/sdk/reference/types"
+		},
+		{
+			"source": "/cline-sdk/extensions",
+			"destination": "/sdk/plugins"
+		},
+		{
+			"source": "/sdk/guides/writing-extensions",
+			"destination": "/sdk/guides/writing-plugins"
+		},
+		{
+			"source": "/cline-sdk/guides/writing-extensions",
+			"destination": "/sdk/guides/writing-plugins"
+		},
+		{
+			"source": "/mcp/mcp-marketplace",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/mcp/adding-and-configuring-servers",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/mcp/mcp-server-development-protocol",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/mcp/connecting-to-a-remote-server",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/mcp/mcp-transport-mechanisms",
+			"destination": "/mcp/mcp-overview"
+		},
+		{
+			"source": "/sdk/agents",
+			"destination": "/sdk/clinecore"
+		},
+		{
+			"source": "/sdk/sessions",
+			"destination": "/sdk/clinecore"
+		},
+		{
+			"source": "/sdk/streaming-and-events",
+			"destination": "/sdk/events"
+		},
+		{
+			"source": "/sdk/hooks",
+			"destination": "/sdk/plugins"
+		},
+		{
+			"source": "/sdk/extensions",
+			"destination": "/sdk/plugins"
+		},
+		{
+			"source": "/sdk/examples",
+			"destination": "/sdk/guides/building-an-agent"
+		},
+		{
+			"source": "/cline-cli/interactive-mode",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/cline-cli/overview",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/cline-cli/samples/overview",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/cline-cli/samples/worktree-workflows",
+			"destination": "/usage/cli-overview"
+		},
+		{
+			"source": "/contributing/doc-templates",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/contributing/documentation-guide",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/customization/workflows",
+			"destination": "/customization/cline-rules"
+		},
+		{
+			"source": "/features/web-tools",
+			"destination": "/tools-reference/all-cline-tools"
+		},
+		{
+			"source": "/getting-started/quick-start",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/getting-started/what-is-cline",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/home",
+			"destination": "/cline-overview"
+		},
+		{
+			"source": "/provider-config/aihubmix",
+			"destination": "/provider-config/other-30-plus-providers#aihubmix"
+		},
+		{
+			"source": "/provider-config/asksage",
+			"destination": "/provider-config/other-30-plus-providers#asksage"
+		},
+		{
+			"source": "/provider-config/baseten",
+			"destination": "/provider-config/other-30-plus-providers#baseten"
+		},
+		{
+			"source": "/provider-config/cerebras",
+			"destination": "/provider-config/other-30-plus-providers#cerebras"
+		},
+		{
+			"source": "/provider-config/dify",
+			"destination": "/provider-config/other-30-plus-providers#difyai"
+		},
+		{
+			"source": "/provider-config/doubao",
+			"destination": "/provider-config/other-30-plus-providers#doubao"
+		},
+		{
+			"source": "/provider-config/fireworks",
+			"destination": "/provider-config/other-30-plus-providers#fireworks-ai"
+		},
+		{
+			"source": "/provider-config/gcp-vertex-ai",
+			"destination": "/provider-config/other-30-plus-providers#gcp-vertex-ai"
+		},
+		{
+			"source": "/provider-config/groq",
+			"destination": "/provider-config/other-30-plus-providers#groq"
+		},
+		{
+			"source": "/provider-config/hicap",
+			"destination": "/provider-config/other-30-plus-providers#hicap"
+		},
+		{
+			"source": "/provider-config/huawei-cloud-maas",
+			"destination": "/provider-config/other-30-plus-providers#huawei-cloud-maas"
+		},
+		{
+			"source": "/provider-config/huggingface",
+			"destination": "/provider-config/other-30-plus-providers#hugging-face"
+		},
+		{
+			"source": "/provider-config/litellm-and-cline-using-codestral",
+			"destination": "/provider-config/openai-compatible"
+		},
+		{
+			"source": "/provider-config/mistral-ai",
+			"destination": "/provider-config/other-30-plus-providers#mistral"
+		},
+		{
+			"source": "/provider-config/moonshot",
+			"destination": "/provider-config/other-30-plus-providers#moonshot"
+		},
+		{
+			"source": "/provider-config/nebius",
+			"destination": "/provider-config/other-30-plus-providers#nebius-ai-studio"
+		},
+		{
+			"source": "/provider-config/nousresearch",
+			"destination": "/provider-config/other-30-plus-providers#nous-research"
+		},
+		{
+			"source": "/provider-config/oracle-code-assist",
+			"destination": "/provider-config/other-30-plus-providers#oracle-code-assist"
+		},
+		{
+			"source": "/provider-config/qwen-code",
+			"destination": "/provider-config/other-30-plus-providers#qwen-code"
+		},
+		{
+			"source": "/provider-config/requesty",
+			"destination": "/provider-config/other-30-plus-providers#requesty"
+		},
+		{
+			"source": "/provider-config/sambanova",
+			"destination": "/provider-config/other-30-plus-providers#sambanova"
+		},
+		{
+			"source": "/provider-config/sap-aicore",
+			"destination": "/provider-config/other-30-plus-providers#sap-ai-core"
+		},
+		{
+			"source": "/provider-config/together",
+			"destination": "/provider-config/other-30-plus-providers#together"
+		},
+		{
+			"source": "/provider-config/vercel-ai-gateway",
+			"destination": "/provider-config/other-30-plus-providers#vercel-ai-gateway"
+		},
+		{
+			"source": "/provider-config/vscode-language-model-api",
+			"destination": "/provider-config/other-30-plus-providers#vs-code-language-model-api"
+		},
+		{
+			"source": "/provider-config/xai-grok",
+			"destination": "/provider-config/other-30-plus-providers#xai-grok"
+		},
+		{
+			"source": "/tools-reference/browser-automation",
+			"destination": "/tools-reference/all-cline-tools"
+		},
+		{
+			"source": "/troubleshooting/task-history-recovery",
+			"destination": "/core-workflows/task-management"
+		},
+		{
+			"source": "/troubleshooting/terminal-quick-fixes",
+			"destination": "/core-workflows/using-commands"
+		}
+	],
+	"search": {
+		"prompt": "Search Cline documentation..."
+	}
+}
diff --git a/docs/enterprise-solutions/api-reference.mdx b/docs/enterprise-solutions/api-reference.mdx
new file mode 100644
index 0000000..162fa55
--- /dev/null
+++ b/docs/enterprise-solutions/api-reference.mdx
@@ -0,0 +1,208 @@
+---
+title: "Enterprise API Reference"
+sidebarTitle: "API Reference"
+description: "REST API endpoints for managing users, organizations, billing, plans, and API keys."
+---
+
+The Enterprise API provides REST endpoints for account management, organization administration, billing, and API key management. These are separate from the [Chat Completions API](/api/overview), which handles model inference.
+
+## Base URL
+
+```
+https://api.cline.bot
+```
+
+## Authentication
+
+All endpoints require a Bearer token in the `Authorization` header:
+
+```bash
+Authorization: Bearer YOUR_AUTH_TOKEN
+```
+
+Use the same API key or account auth token described in the [public API reference](/api/overview#authentication).
+
+## Quick Example
+
+```bash
+# Get your user profile
+curl https://api.cline.bot/api/v1/users/me \
+  -H "Authorization: Bearer YOUR_AUTH_TOKEN"
+```
+
+```json
+{
+  "id": "user_abc123",
+  "email": "you@company.com",
+  "name": "Your Name",
+  "active_account_id": "org_xyz789"
+}
+```
+
+---
+
+## Users
+
+Manage user accounts, accept terms, check balances, view usage, and configure payment methods.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/users/me` | Get current user profile |
+| `PATCH` | `/api/v1/users/me` | Update current user profile |
+| `DELETE` | `/api/v1/users/me` | Delete current user account |
+| `POST` | `/api/v1/users/me/accept-terms` | Accept terms of service |
+| `GET` | `/api/v1/users/me/remote-config` | Get remote configuration for the current user |
+| `PUT` | `/api/v1/users/active-account` | Switch active account (personal or organization) |
+| `GET` | `/api/v1/users/{id}/balance` | Get credit balance |
+| `GET` | `/api/v1/users/{id}/usages` | Get usage history |
+
+### Payments and Credits
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/users/{id}/payments` | List payment history |
+| `GET` | `/api/v1/users/{id}/payments/{paymentId}` | Get payment details |
+| `GET` | `/api/v1/users/{id}/payments/{paymentId}/status` | Check payment status |
+| `GET` | `/api/v1/users/{id}/payments/provider/{paymentId}` | Get provider-side payment details |
+| `POST` | `/api/v1/users/credits/checkout` | Start a credit purchase checkout |
+| `POST` | `/api/v1/users/{id}/credits/purchase` | Purchase credits directly |
+
+### Billing Configuration
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/users/{id}/auto-top-up` | Get auto top-up settings |
+| `PUT` | `/api/v1/users/{id}/auto-top-up` | Configure auto top-up |
+| `GET` | `/api/v1/users/{id}/payment-method/default` | Get default payment method |
+| `POST` | `/api/v1/users/{id}/payment-method/setup-session` | Start payment method setup |
+| `GET` | `/api/v1/users/{id}/promotions` | List active promotions |
+
+---
+
+## Organizations
+
+Create and manage organizations. Organization admins can configure remote settings, manage members, and control billing.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `POST` | `/api/v1/organizations` | Create a new organization |
+| `GET` | `/api/v1/organizations/{id}` | Get organization details |
+| `PUT` | `/api/v1/organizations/{id}` | Update organization settings |
+| `DELETE` | `/api/v1/organizations/{id}` | Delete an organization |
+| `GET` | `/api/v1/organizations/{id}/api-keys` | List organization API keys |
+| `GET` | `/api/v1/organizations/{id}/remote-config` | Get remote config for the org |
+| `GET` | `/api/v1/organizations/{orgId}/metrics` | Get organization usage metrics |
+
+---
+
+## Organization Members
+
+Manage who has access to the organization and what role they hold.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/members` | List all members |
+| `DELETE` | `/api/v1/organizations/{orgId}/members` | Remove members |
+| `GET` | `/api/v1/organizations/{orgId}/members/available-roles` | List assignable roles |
+| `PUT` | `/api/v1/organizations/{orgId}/members/{memberId}/role` | Change a member's role |
+| `GET` | `/api/v1/organizations/{orgId}/members/{memberId}/usages` | Get a member's usage |
+
+<Tip>
+  For a walkthrough of member management in the UI, see [Managing Members](/enterprise-solutions/team-management/managing-members).
+</Tip>
+
+---
+
+## Organization Invites
+
+Invite new members to join your organization.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/invites` | List pending invites |
+| `POST` | `/api/v1/organizations/{orgId}/invites` | Send new invites |
+| `GET` | `/api/v1/organizations/{orgId}/invites/count` | Get invite count |
+| `DELETE` | `/api/v1/organizations/{orgId}/invites/{inviteId}` | Revoke an invite |
+| `POST` | `/api/v1/invites/accept` | Accept an invite (called by the invitee) |
+
+---
+
+## Organization Balance and Payments
+
+Manage credits and payments at the organization level. These mirror the user-level payment endpoints but operate on the organization's account.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/balance` | Get org credit balance |
+| `GET` | `/api/v1/organizations/{orgId}/payments` | List payment history |
+| `GET` | `/api/v1/organizations/{orgId}/payments/{paymentId}` | Get payment details |
+| `GET` | `/api/v1/organizations/{orgId}/payments/{paymentId}/status` | Check payment status |
+| `GET` | `/api/v1/organizations/{orgId}/payments/provider/{paymentId}` | Provider-side payment details |
+| `POST` | `/api/v1/organizations/{orgId}/credits/checkout` | Start credit checkout |
+| `POST` | `/api/v1/organizations/{orgId}/credits/purchase` | Purchase credits |
+| `GET` | `/api/v1/organizations/{orgId}/auto-top-up` | Get auto top-up config |
+| `PUT` | `/api/v1/organizations/{orgId}/auto-top-up` | Configure auto top-up |
+| `GET` | `/api/v1/organizations/{orgId}/payment-method/default` | Get default payment method |
+| `POST` | `/api/v1/organizations/{orgId}/payment-method/setup-session` | Start payment method setup |
+| `GET` | `/api/v1/organizations/{id}/promotions` | List active promotions |
+
+---
+
+## Organization Plans
+
+Subscribe to, upgrade, or cancel plans. Manage seat counts for your team.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/plans` | List all available plans |
+| `GET` | `/api/v1/organizations/{orgId}/plan` | Get current plan |
+| `GET` | `/api/v1/organizations/{orgId}/plan/history` | View plan change history |
+| `GET` | `/api/v1/organizations/{orgId}/plan/{planId}` | Get specific plan details |
+| `POST` | `/api/v1/organizations/{orgId}/plan` | Subscribe to a plan |
+| `PUT` | `/api/v1/organizations/{orgId}/plan/seats` | Update seat count |
+| `DELETE` | `/api/v1/organizations/{orgId}/plan/{planId}` | Cancel a plan |
+
+---
+
+## Organization Usage
+
+Track token consumption and costs across your organization.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/usages` | Get aggregated usage data |
+
+<Tip>
+  For dashboards and monitoring, see [Monitoring Overview](/enterprise-solutions/monitoring/overview) and [Telemetry](/enterprise-solutions/monitoring/telemetry).
+</Tip>
+
+---
+
+## API Keys
+
+Create and manage API keys for programmatic access. Keys created here work with both the [Chat Completions API](/api/overview) and the endpoints on this page.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/api-keys` | List your API keys |
+| `POST` | `/api/v1/api-keys` | Create a new API key |
+| `DELETE` | `/api/v1/api-keys/{key_id}` | Delete an API key |
+
+---
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions API" icon="code" href="/api/overview">
+    The public inference API for sending prompts and receiving completions.
+  </Card>
+  <Card title="SSO Setup" icon="key" href="/enterprise-solutions/sso-setup">
+    Configure single sign-on for your organization.
+  </Card>
+  <Card title="Managing Members" icon="users" href="/enterprise-solutions/team-management/managing-members">
+    Add, remove, and manage member roles in the UI.
+  </Card>
+  <Card title="Monitoring" icon="chart-line" href="/enterprise-solutions/monitoring/overview">
+    Track usage, costs, and telemetry across your organization.
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-server-controls.mdx b/docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-server-controls.mdx
new file mode 100644
index 0000000..03f3f48
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-server-controls.mdx
@@ -0,0 +1,289 @@
+---
+title: "MCP Server Controls"
+sidebarTitle: "MCP Server Controls"
+description: "Enterprise controls for MCP server allowlisting and remote MCP server management"
+---
+
+Cline no longer exposes an MCP Marketplace browse/install surface in the SDK-backed VS Code extension. For Enterprise administrators, the legacy remote configuration field names are still supported for compatibility and now govern MCP server access: local server availability, local server allowlisting, organization-managed remote MCP servers, and blocking personal remote MCP servers.
+
+## Overview
+
+Enterprise administrators have four configuration options to govern MCP server usage across their organization:
+
+| Setting | Purpose |
+|---------|---------|
+| `mcpMarketplaceEnabled` | Allow or block locally configured MCP servers |
+| `allowedMCPServers` | Restrict locally configured MCP servers to approved server IDs |
+| `remoteMCPServers` | Push pre-configured remote MCP servers to all users |
+| `blockPersonalRemoteMCPServers` | Prevent users from adding their own remote MCP servers |
+
+These settings are applied through your organization's [remote configuration](/enterprise-solutions/configuration/remote-configuration/overview) and take effect immediately for all team members.
+
+## Blocking Local MCP Servers
+
+To block locally configured MCP servers for your organization, set `mcpMarketplaceEnabled` to `false`:
+
+```json
+{
+  "mcpMarketplaceEnabled": false
+}
+```
+
+When `mcpMarketplaceEnabled` is set to `false`:
+- Locally configured MCP servers are blocked
+- Enterprise policy takes precedence over individual preferences
+
+When `mcpMarketplaceEnabled` is set to `true` or omitted:
+- Locally configured MCP servers are allowed unless restricted by `allowedMCPServers`
+
+<Warning>
+Setting `mcpMarketplaceEnabled` to `false` blocks all locally configured MCP servers. If you want to allow specific local servers while restricting others, leave this setting enabled or omitted and use the allowlist approach described below instead.
+</Warning>
+
+## Restricting Local Servers to Approved IDs
+
+Rather than blocking all local MCP servers, you can restrict local server usage to a curated list of approved servers using the `allowedMCPServers` setting. This is the recommended approach for most enterprises: it lets developers benefit from MCP while ensuring only vetted local servers are available.
+
+### Configuration
+
+Add an `allowedMCPServers` array to your remote configuration. Each entry requires an `id` field that matches the local MCP server name used in the user's MCP configuration:
+
+```json
+{
+  "allowedMCPServers": [
+    { "id": "filesystem" },
+    { "id": "github" },
+    { "id": "internal-code-search" }
+  ]
+}
+```
+
+### How It Works
+
+When `allowedMCPServers` is configured with one or more entries:
+- Local MCP servers can connect only when their configured server name matches an allowed `id`
+- Local MCP servers not on the list are blocked
+- The allowlist applies to all team members in the organization
+
+When `allowedMCPServers` is omitted, `undefined`, or an empty array (`[]`):
+- No local server allowlist restriction is applied
+
+### Choosing Server IDs
+
+The `id` for each allowed server must match the server name in the user's `mcpServers` configuration. For example:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/project"]
+    }
+  }
+}
+```
+
+## Pushing Pre-Configured Remote MCP Servers
+
+Use `remoteMCPServers` to push hosted MCP servers directly to all users. This is ideal for internal MCP servers or third-party servers that need specific configuration.
+
+### Configuration
+
+```json
+{
+  "remoteMCPServers": [
+    {
+      "name": "Internal Code Search",
+      "url": "https://mcp.internal.yourcompany.com/code-search",
+      "alwaysEnabled": true,
+      "headers": {
+        "Authorization": "Bearer ${AUTH_TOKEN}"
+      }
+    },
+    {
+      "name": "Documentation Server",
+      "url": "https://mcp.internal.yourcompany.com/docs",
+      "alwaysEnabled": false
+    }
+  ]
+}
+```
+
+### Remote Server Options
+
+Each remote MCP server entry supports the following fields:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `name` | string | Yes | Display name for the server |
+| `url` | string | Yes | The URL endpoint of the MCP server |
+| `alwaysEnabled` | boolean | No | When `true`, users cannot disable this server |
+| `headers` | object | No | Custom HTTP headers for authentication |
+
+### Always-Enabled Servers
+
+When `alwaysEnabled` is set to `true`:
+- The server is automatically active for all users
+- Users cannot toggle the server off
+- The server appears in the user's MCP configuration but the disable control is locked
+- This is useful for compliance, security, or internal tooling servers that must always be available
+
+## Blocking Personal Remote MCP Servers
+
+To prevent users from adding their own remote MCP servers, set `blockPersonalRemoteMCPServers` to `true`:
+
+```json
+{
+  "blockPersonalRemoteMCPServers": true
+}
+```
+
+When `blockPersonalRemoteMCPServers` is `true`:
+- Users cannot add or configure remote MCP servers on their own
+- Only servers defined in the organization's `remoteMCPServers` configuration are available
+- This ensures all remote MCP connections go through approved, organization-managed endpoints
+
+When `blockPersonalRemoteMCPServers` is `false` or omitted:
+- Users can freely add their own remote MCP server connections
+
+## Combined Configuration Examples
+
+### Locked-Down Environment
+
+For organizations that need strict control over all MCP server access:
+
+```json
+{
+  "mcpMarketplaceEnabled": true,
+  "allowedMCPServers": [
+    { "id": "filesystem" },
+    { "id": "github" }
+  ],
+  "remoteMCPServers": [
+    {
+      "name": "Internal API Gateway",
+      "url": "https://mcp.internal.yourcompany.com/gateway",
+      "alwaysEnabled": true,
+      "headers": {
+        "X-Api-Key": "org-managed-key"
+      }
+    }
+  ],
+  "blockPersonalRemoteMCPServers": true
+}
+```
+
+This configuration:
+- Allows only the two named local MCP servers
+- Pushes an always-enabled internal MCP server to all users
+- Blocks users from adding their own remote MCP servers
+
+### Open Environment with Internal Servers
+
+For organizations that want flexibility with internal server access:
+
+```json
+{
+  "remoteMCPServers": [
+    {
+      "name": "Company Knowledge Base",
+      "url": "https://mcp.yourcompany.com/kb",
+      "alwaysEnabled": true
+    }
+  ]
+}
+```
+
+This configuration:
+- Leaves local MCP servers unrestricted
+- Ensures all developers have access to the company knowledge base
+- Allows users to add their own remote MCP servers
+
+### Local Servers Blocked with Internal Remote Servers Only
+
+For organizations that want to fully manage the MCP experience:
+
+```json
+{
+  "mcpMarketplaceEnabled": false,
+  "remoteMCPServers": [
+    {
+      "name": "Approved Code Assistant",
+      "url": "https://mcp.internal.yourcompany.com/code-assist",
+      "alwaysEnabled": true
+    },
+    {
+      "name": "Internal Docs Search",
+      "url": "https://mcp.internal.yourcompany.com/docs",
+      "alwaysEnabled": true
+    }
+  ],
+  "blockPersonalRemoteMCPServers": true
+}
+```
+
+This configuration:
+- Blocks locally configured MCP servers
+- Provides only organization-managed remote MCP servers
+- Prevents users from adding any additional remote servers
+
+## Enterprise Policy Recommendations
+
+### Recommended Approach
+
+Most organizations should **use the allowlist** (`allowedMCPServers`) rather than blocking local MCP servers entirely. This gives developers access to useful tools while ensuring security review of each server.
+
+<AccordionGroup>
+  <Accordion title="Security Review Process" icon="shield">
+    Before adding an MCP server to your allowlist:
+    - Review the server's source code on GitHub
+    - Evaluate the server's permissions and data access patterns
+    - Check for active maintenance and security practices
+    - Assess whether the server's data handling meets your compliance requirements
+    - Test the server in a sandbox environment before approving
+  </Accordion>
+
+  <Accordion title="Internal MCP Servers" icon="building">
+    For internal tooling, use `remoteMCPServers` with `alwaysEnabled: true`:
+    - Connect Cline to internal APIs, databases, and knowledge bases
+    - Ensure consistent access across all developers
+    - Manage authentication centrally through custom headers
+    - Use `blockPersonalRemoteMCPServers` to prevent shadow IT
+  </Accordion>
+
+  <Accordion title="Compliance Considerations" icon="clipboard-check">
+    MCP servers can access external APIs and process data:
+    - Audit which servers handle sensitive data
+    - Ensure servers comply with your data residency requirements
+    - Document approved servers in your security policies
+    - Regularly review and update your allowlist
+  </Accordion>
+</AccordionGroup>
+
+### Recommendations by Organization Size
+
+#### Small Teams (5–20 developers)
+- **Local Servers:** Open or lightly restricted with an allowlist
+- **Remote Servers:** Push internal servers as needed
+- **Personal Servers:** Allow with guidance
+- **Review Cadence:** Quarterly allowlist review
+
+#### Medium Organizations (20–100 developers)
+- **Local Servers:** Restricted to an approved allowlist
+- **Remote Servers:** Push internal servers with `alwaysEnabled`
+- **Personal Servers:** Consider blocking (`blockPersonalRemoteMCPServers: true`)
+- **Review Cadence:** Monthly allowlist review
+
+#### Large Enterprises (100+ developers)
+- **Local Servers:** Strictly restricted to a vetted allowlist
+- **Remote Servers:** All MCP access through organization-managed servers
+- **Personal Servers:** Blocked (`blockPersonalRemoteMCPServers: true`)
+- **Review Cadence:** Formal approval process for new servers with security review
+
+## Support & Questions
+
+For help configuring MCP server policies:
+- Review [Remote Configuration Overview](/enterprise-solutions/configuration/remote-configuration/overview)
+- See [MCP Overview](/mcp/mcp-overview) for general MCP concepts
+- Contact your Enterprise support representative
+- Join our [Discord](https://discord.gg/cline) for community discussion
diff --git a/docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode.mdx b/docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode.mdx
new file mode 100644
index 0000000..53e5093
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode.mdx
@@ -0,0 +1,233 @@
+---
+title: "YOLO Mode"
+sidebarTitle: "YOLO Mode"
+description: "Enterprise controls for YOLO Mode autonomous operation"
+---
+
+YOLO Mode enables Cline to operate with complete autonomy, auto-approving all actions without user confirmation. For Enterprise administrators, this page covers how to control access to YOLO Mode across your organization.
+
+<Note>
+For complete details about YOLO Mode functionality, risks, and best practices, see [YOLO Mode in Features](/features/yolo-mode).
+</Note>
+
+## Overview
+
+When YOLO Mode is enabled, Cline automatically approves all operations including file changes, terminal commands, browser actions, and mode transitions. This provides maximum automation speed but removes all safety guardrails.
+
+<Warning>
+YOLO Mode is powerful but potentially dangerous. Administrators should carefully consider which teams or users should have access to this feature.
+</Warning>
+
+## Enterprise Administrator Configuration
+
+As an Enterprise administrator, you can control whether users in your organization can enable YOLO Mode through remote configuration.
+
+### Disabling YOLO Mode for All Users
+
+Add the following to your remote configuration JSON:
+
+```json
+{
+  "yoloModeAllowed": false
+}
+```
+
+When `yoloModeAllowed` is set to `false`:
+- The YOLO Mode toggle is disabled in all user interfaces
+- Users cannot enable YOLO Mode even in their local settings
+- This policy applies immediately to all team members
+- Enterprise policy takes precedence over individual preferences
+
+### Enabling YOLO Mode for All Users
+
+```json
+{
+  "yoloModeAllowed": true
+}
+```
+
+When `yoloModeAllowed` is set to `true` or omitted:
+- Users can enable or disable YOLO Mode in their local Cline settings
+- Individual users make their own decisions about using YOLO Mode
+- No organizational restrictions apply
+
+## Enterprise Policy Recommendations
+
+### Recommended Approach
+
+Most organizations should **disable YOLO Mode by default** for the following reasons:
+
+<AccordionGroup>
+  <Accordion title="Security & Compliance" icon="shield">
+    YOLO Mode removes all approval gates, potentially allowing:
+    - Unreviewed code changes to critical systems
+    - Execution of commands without oversight
+    - Automated actions that may violate compliance policies
+    - Risk of data exposure through unmonitored operations
+  </Accordion>
+  
+  <Accordion title="Code Quality Control" icon="code">
+    Without approval prompts:
+    - Changes happen too quickly to review in real-time
+    - Mistakes can compound before detection
+    - Quality gates are bypassed
+    - Rollback becomes more complex
+  </Accordion>
+  
+  <Accordion title="Audit Requirements" icon="clipboard-check">
+    Many industries require:
+    - Documented approval trails for code changes
+    - Clear accountability for automated actions
+    - Traceable decision-making processes
+    - YOLO Mode may conflict with these requirements
+  </Accordion>
+</AccordionGroup>
+
+### Exceptions: When to Allow YOLO Mode
+
+Consider enabling YOLO Mode for:
+
+**Sandbox/Development Environments**
+- Isolated testing environments
+- Personal development machines
+- Proof-of-concept projects
+- Temporary exploratory work
+
+**Specialized Roles**
+- DevOps automation engineers (with proper monitoring)
+- Research & development teams in sandboxed environments
+- Teams with robust rollback and recovery procedures
+
+**Controlled Use Cases**
+- Scripted CI/CD pipelines with comprehensive logging
+- Automated testing scenarios
+- Demonstration or training environments
+
+## Enterprise Considerations
+
+### Security Implications
+
+When YOLO Mode is enabled in your organization:
+
+**Risk Factors:**
+- All tool executions happen automatically without human review
+- Potential for rapid propagation of mistakes across multiple files
+- Reduced opportunity to catch security vulnerabilities before implementation
+- Automated operations may bypass existing security controls
+
+**Mitigations:**
+- Implement comprehensive logging and monitoring
+- Restrict YOLO Mode to non-production environments
+- Require periodic security reviews for teams using YOLO Mode
+- Ensure version control and rollback procedures are in place
+
+### Monitoring Requirements
+
+When allowing YOLO Mode in your organization, implement:
+
+**Mandatory Monitoring:**
+1. **Real-time Activity Tracking**
+   - Monitor which users enable YOLO Mode
+   - Track when YOLO Mode is active
+   - Log all automated actions taken
+
+2. **Audit Trail Maintenance**
+   - Preserve complete history of YOLO Mode sessions
+   - Document what was automated and when
+   - Maintain records for compliance purposes
+
+3. **Anomaly Detection**
+   - Alert on unusual patterns of automated actions
+   - Flag high-risk operations performed automatically
+   - Monitor for potential security incidents
+
+### Monitoring YOLO Mode Usage
+
+When YOLO Mode is enabled (by policy), track usage through:
+
+**Telemetry Events:**
+- Captures when users toggle YOLO Mode on/off
+- Records which tasks were executed with YOLO Mode enabled
+- Provides aggregate usage statistics across your organization
+
+**Task History:**
+- Task metadata indicates whether YOLO Mode was active
+- Complete action logs show automated approvals
+- Enables post-action review and analysis
+
+**Audit Logs:**
+- Standard logging captures all automated decisions
+- Tool executions are recorded with timestamps
+- Provides compliance trail for regulated environments
+
+## Recommended Policies by Organization Size
+
+### Small Teams (5-20 developers)
+- **Default:** Disabled
+- **Exceptions:** Allow for individual sandbox environments
+- **Monitoring:** Basic telemetry sufficient
+
+### Medium Organizations (20-100 developers)
+- **Default:** Disabled
+- **Exceptions:** Permit for designated dev/test environments only
+- **Monitoring:** Required telemetry + regular audit reviews
+
+### Large Enterprises (100+ developers)
+- **Default:** Strictly disabled
+- **Exceptions:** Require security approval for each use case
+- **Monitoring:** Comprehensive telemetry + real-time alerting + compliance reporting
+
+## Technical Implementation
+
+### Configuration Management
+
+**Centralized Control through Remote Configuration:**
+
+```json
+{
+  "yoloModeAllowed": false,
+  // Other policies...
+}
+```
+
+This setting:
+- Applies instantly to all connected clients
+- Cannot be overridden by individual users
+- Persists across Cline restarts
+- Is synchronized across all team members
+
+### Policy Enforcement
+
+The enforcement mechanism:
+1. Users authenticate with your enterprise configuration server
+2. Remote configuration is downloaded and applied
+3. Local UI respects enterprise policy settings
+4. YOLO Mode toggle is disabled if policy forbids it
+5. Users see a message explaining the enterprise restriction
+
+## Compliance Considerations
+
+For organizations in regulated industries:
+
+**SOC 2 Compliance:**
+- YOLO Mode may conflict with change management controls
+- Document decision to allow/disallow in security policies
+- Implement compensating controls if YOLO Mode is permitted
+
+**GDPR/Data Protection:**
+- Automated operations must still respect data handling policies
+- Ensure YOLO Mode doesn't bypass data protection safeguards
+- Maintain audit trails of automated data processing
+
+**Industry-Specific:**
+- Financial services: Generally incompatible with Reg requirements
+- Healthcare: May violate HIPAA audit trail requirements
+- Government: Often conflicts with approval workflow mandates
+
+## Support & Questions
+
+For help configuring YOLO Mode policies:
+- Review [Remote Configuration Overview](/enterprise-solutions/configuration/remote-configuration/overview)
+- See [Features: YOLO Mode](/features/yolo-mode) for detailed functionality
+- Contact your Enterprise support representative
+- Join our [Discord](https://discord.gg/cline) for community discussion
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration.mdx
new file mode 100644
index 0000000..c8d99e9
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration.mdx
@@ -0,0 +1,98 @@
+---
+title: "Configure Anthropic Provider (Admin)"
+sidebarTitle: "Configure Anthropic (Admin)"
+description: "This guide explains how administrators configure Anthropic as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add Anthropic as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach provides direct access to Anthropic's Claude models, with an optional custom base URL for organizations that route traffic through a proxy.
+
+## Before You Begin
+
+To get started with setting up Anthropic as your organization's LLM provider, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+**Anthropic API access**  
+Your organization needs an Anthropic account with API access to Claude models. Members will need individual API keys to authenticate.
+
+<Note>
+If your organization requires routing API traffic through a proxy or custom endpoint, have the proxy URL ready before configuring.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select Anthropic as the API Provider">
+Open the **API Provider** dropdown menu and select **Anthropic**. This will open the Anthropic configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure Anthropic Settings">
+The configuration panel includes settings that control how Anthropic works for your organization:
+
+<AccordionGroup>
+<Accordion title="Base URL (optional)">
+By default, Cline connects directly to the Anthropic API (`https://api.anthropic.com`). If your organization routes API traffic through a proxy or custom endpoint, enter the base URL here.
+
+Use cases for a custom base URL:
+- Corporate proxy that logs or filters API traffic
+- Self-hosted API gateway for rate limiting or access control
+- Regional routing requirements
+
+Leave this empty to use the default Anthropic API endpoint.
+
+<Tip>
+If using a proxy, ensure it correctly forwards requests to the Anthropic API and preserves all required headers.
+</Tip>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use Anthropic with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "Anthropic" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only Anthropic as a provider
+4. Verify that Claude models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization.
+
+**Connection errors when using a custom base URL**  
+Verify the proxy URL is correct and accessible from your team's development environments. Ensure the proxy correctly forwards requests to the Anthropic API.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change settings later**  
+You can update the base URL or other settings at any time. Changes take effect immediately for all organization members.
+
+For further details, consult the [Anthropic API documentation](https://docs.anthropic.com/) and coordinate with your infrastructure team.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/anthropic/member-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/anthropic/member-configuration.mdx
new file mode 100644
index 0000000..396056b
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/anthropic/member-configuration.mdx
@@ -0,0 +1,95 @@
+---
+title: "Configure Anthropic in VS Code (Members)"
+sidebarTitle: "Configure Anthropic (Member)"
+description: "Guide for engineers connecting to their organization's Anthropic provider through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's Anthropic provider setup. This guide walks you through configuring your API key in VS Code so you can start using Claude models through your organization's configuration. Your administrator has already configured the provider settings — you just need to add your API key to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's Anthropic provider, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**Anthropic API key**  
+You need an API key from Anthropic to authenticate requests. Your organization may provide keys centrally or require you to create one through the [Anthropic Console](https://console.anthropic.com/).
+
+<Note>
+If you're unsure how to obtain an API key, check with your administrator about your organization's key provisioning process.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area
+
+</Step>
+
+<Step title="Enter Your API Key">
+
+1. Select or confirm the **Anthropic** provider is selected
+2. Enter your Anthropic API key in the **API Key** field
+3. If your administrator configured a custom base URL, it will already be set and locked
+4. Click **Save** to store your credentials
+
+<Tip>
+API keys are stored locally and are only used by the Cline extension.
+</Tip>
+
+<Note>
+The base URL setting is controlled by your administrator. If a custom proxy URL is configured, your API requests will be routed through it automatically.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After entering your API key, administrator-controlled settings (such as base URL) will be locked (shown with a lock icon 🔒) as they're managed by your organization.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your API key works correctly with the configured Anthropic endpoint.
+
+<Tip>
+**Testing Recommendation**
+
+Try a simple test like "Hello" first to verify basic connectivity before starting development tasks.
+</Tip>
+</Step>
+</Steps>
+
+## Troubleshooting
+
+**Anthropic not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Anthropic configuration and that you have the latest version of the Cline extension.
+
+**Authentication errors ("Invalid API Key" or "Unauthorized")**  
+Verify your API key is correct and active. Check the [Anthropic Console](https://console.anthropic.com/) to confirm your key status and that it has sufficient permissions.
+
+**Connection errors or timeouts**  
+If your administrator configured a custom base URL (proxy), check with your IT team about network requirements. If using the default Anthropic endpoint, ensure you have internet access to `api.anthropic.com`.
+
+**Models not available**  
+The available models depend on your Anthropic API plan and your organization's configuration. Contact your administrator if expected models are not available.
+
+**Rate limit errors**  
+Your API key may have rate limits configured by Anthropic. If you encounter rate limit errors during normal use, contact your administrator about adjusting limits or managing key usage across the team.
+
+## Security Best Practices
+
+When working with your Anthropic API key:
+
+- Keep your API key secure and do not share it
+- Never store your API key in code or version control
+- Report any suspected key compromise to your administrator immediately
+- Regularly check the [Anthropic Console](https://console.anthropic.com/) for unusual usage patterns
+
+For further details, consult the [Anthropic API documentation](https://docs.anthropic.com/) and coordinate with your organization's administrator.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration.mdx
new file mode 100644
index 0000000..f7de1c6
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration.mdx
@@ -0,0 +1,125 @@
+---
+title: "Configure AWS Bedrock Provider (Admin)"
+sidebarTitle: "Configure AWS Bedrock (Admin)"
+description: "This guide explains how administrators configure AWS Bedrock as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add AWS Bedrock as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach ensures consistent access to Amazon's AI models while maintaining your organization's security and compliance requirements through region controls and basic configuration options.
+
+## Before You Begin
+
+To get started with setting up AWS Bedrock as your organization's LLM provider, you'll need a few items in place. 
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+
+**AWS Bedrock account with the right permissions**  
+Your AWS account needs specific Bedrock permissions to work with Cline. 
+
+<Note>
+If you don't have direct AWS access, coordinate with your cloud team to get these permissions set up before proceeding.
+</Note>
+
+**Your preferred AWS region**  
+Choose your primary AWS region carefully since this will be enforced for all users.
+
+<Tip>
+Check which models are available in your region first. Some newer models might not be available in all regions yet.
+</Tip>
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/AWS%20Remote%20Config.gif"
+	/>
+</Frame>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select AWS Bedrock as the API Provider">
+Open the **API Provider** dropdown menu and select **Amazon Bedrock**. This will open the Bedrock configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure Bedrock Settings">
+The configuration panel includes several settings that control how Bedrock works for your organization. Configure what you need:
+
+<AccordionGroup>
+<Accordion title="Region (required)">
+Enter your preferred AWS region like `us-west-2` or `us-east-1`. This region will be enforced for all organization members.
+
+[View AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
+
+<Tip>
+For most organizations, `us-east-1` or `us-west-2` are recommended as they have the best model availability.
+</Tip>
+</Accordion>
+
+<Accordion title="Custom VPC Endpoint (optional)">
+If your organization uses a private VPC endpoint for Bedrock, specify it here to ensure all API calls go through your network infrastructure.
+
+[Learn more about AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)
+</Accordion>
+
+<Accordion title="Cross-region Inference (optional)">
+Enable this to let Bedrock automatically route requests to other regions when your primary region has capacity constraints. Useful for maintaining availability during high-demand periods.
+
+[Learn more about Inference Profiles](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html)
+</Accordion>
+
+<Accordion title="Global Inference Profile (optional)">
+Turn this on to use AWS's global inference routing, which automatically directs requests to the optimal region based on availability and latency.
+</Accordion>
+
+<Accordion title="Prompt Caching (optional)">
+Enable prompt caching to reduce costs and latency. Bedrock caches portions of prompts that remain consistent across requests, making repeated interactions faster and cheaper.
+
+[Learn more about Prompt Caching](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html)
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use AWS Bedrock with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "Amazon Bedrock" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only Bedrock as a provider
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change regions later**  
+You can update the region at any time. Members will need to ensure their local AWS credentials have access to the new region. For more information, refer to the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
+
+For further details, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) and coordinate with your internal cloud team.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration.mdx
new file mode 100644
index 0000000..16b8947
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration.mdx
@@ -0,0 +1,131 @@
+---
+title: "Configure AWS Bedrock in VS Code (Members)"
+sidebarTitle: "Configure AWS Bedrock (Member)"
+description: "Guide for engineers configuring AWS Bedrock credentials in VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's AWS Bedrock setup. This guide walks you through configuring your AWS credentials in VS Code so you can start using models through your organization's Bedrock infrastructure. Your administrator has already configured the provider settings-you just need to add your credentials to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's AWS Bedrock setup, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**AWS credentials with Bedrock access**  
+You need AWS credentials that have permission to access Bedrock in your organization's configured region.
+
+<Note>
+If you don't have AWS credentials yet, reach out to your IT or cloud team to get access keys or AWS CLI profiles configured with the necessary Bedrock permissions.
+</Note>
+
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/VS%20Code%20Bedrock%20API%20Key.gif"
+	/>
+</Frame>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area (it will display as `bedrock.anthropic.claude-sonnet-4-20250514-v1:0` or similar)
+
+</Step>
+
+<Step title="Select Your Authentication Method">
+Choose one of the following credential methods to authenticate with AWS Bedrock:
+
+<AccordionGroup>
+<Accordion title="AWS Bedrock API Key">
+Use dedicated AWS access keys specifically for Bedrock access.
+
+[Learn more about AWS Bedrock API Keys](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html)
+
+1. Select the **API Key** radio button
+2. Enter your AWS Access Key ID and Secret Access Key
+3. These credentials are stored locally and used only by the VS Code extension
+</Accordion>
+
+<Accordion title="AWS Profile">
+Use an existing AWS CLI profile configured on your machine.
+
+[Learn more about AWS CLI Profiles](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html)
+
+1. Select the **AWS Profile** radio button
+2. Choose or enter the profile name from your `~/.aws/credentials` file
+3. Cline will use the credentials associated with that profile
+</Accordion>
+
+<Accordion title="AWS Credentials">
+Use your default AWS credential chain (environment variables, EC2 instance roles, etc.).
+
+1. Select the **AWS Credentials** radio button
+2. Cline will automatically detect credentials from your environment using the standard AWS credential provider chain
+</Accordion>
+</AccordionGroup>
+
+<Note>
+The AWS Region is preconfigured by your administrator and does not need to be set in the extension.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After selecting your authentication method, the extension will display checkmarks for enabled features:
+
+- ✓ Supports images
+- ✓ Supports browser use
+- ✓ Supports prompt caching
+
+Additional settings like cross-region inference and global inference profile will be locked (shown with a lock icon 🔒) as they're controlled by your administrator.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your credentials work correctly with the configured Bedrock region.
+
+<Tip>
+**Testing Recommendation**
+
+It is recommended to test the connection in plan mode to verify everything works correctly before using it for actual tasks.
+</Tip>
+</Step>
+</Steps>
+
+
+## Troubleshooting
+
+**Authentication errors ("Access Denied" or "Invalid Credentials")**  
+Verify your chosen credential method has the necessary IAM permissions to call Bedrock in the configured region. Required permissions include `bedrock:InvokeModel` and `bedrock:InvokeModelWithResponseStream`. For more information, refer to [AWS Bedrock IAM Permissions](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html).
+
+**Region-related errors or "model not available"**  
+Ask your administrator to confirm which region is configured for your organization. Ensure your AWS credentials have access to Bedrock in that specific region. [View AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
+
+**Don't see AWS Bedrock as an option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Bedrock configuration. Try signing out and back into the extension.
+
+**AWS Credentials option not finding credentials**  
+Verify AWS CLI is installed and configured with `aws configure` ([AWS CLI Installation Guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)). Check that credentials are present in `~/.aws/credentials`. For EC2/ECS environments, ensure IAM roles are properly attached. If using environment variables, set `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
+
+
+## Security Best Practices
+
+When configuring your AWS credentials, follow these security guidelines:
+
+- Use IAM roles with minimum required permissions ([AWS IAM Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html))
+- Rotate access keys regularly if using the API Key method
+- Never store credentials in code or version control
+- Prefer AWS Profile method for better credential management
+- Consider using AWS SSO/federated roles for enhanced security
+
+Your organization administrator controls which models are available. The extension will automatically display available models based on your region's Bedrock configuration. For more information about available models, refer to the [AWS Bedrock Model Access documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html).
+
+For further assistance, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) and coordinate with your organization's cloud administrator.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration.mdx
new file mode 100644
index 0000000..aa6f499
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration.mdx
@@ -0,0 +1,112 @@
+---
+title: "Configure Google Vertex AI Provider (Admin)"
+sidebarTitle: "Configure Google Vertex (Admin)"
+description: "This guide explains how administrators configure Google Vertex AI as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add Google Vertex AI as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach ensures consistent access to Google's Gemini models while maintaining your organization's project boundaries and regional settings.
+
+## Before You Begin
+
+To get started with setting up Google Vertex AI as your organization's LLM provider, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+
+**Google Cloud Project with Vertex AI enabled**  
+You need a Google Cloud project with the Vertex AI API enabled and appropriate models accessible.
+
+<Note>
+If you haven't set up Google Cloud or Vertex AI yet, work with your cloud team to enable the Vertex AI API and ensure necessary quotas are configured.
+</Note>
+
+**Project configuration details**  
+You'll need your Google Cloud project ID and preferred region for Vertex AI model access.
+
+<Tip>
+Service accounts should have the minimum IAM permissions needed for Vertex AI access to follow security best practices.
+</Tip>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select Google Vertex AI as the API Provider">
+Open the **API Provider** dropdown menu and select **Google Vertex AI**. This will open the Vertex AI configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure Vertex AI Settings">
+The configuration panel includes settings that control how Vertex AI works for your organization:
+
+<AccordionGroup>
+<Accordion title="Project ID (required)">
+Enter your Google Cloud project ID where Vertex AI is enabled. This project will be used for all AI model requests from your organization members.
+
+<Tip>
+Use a dedicated project for AI workloads to better track usage and costs. Ensure the project has sufficient quotas for your team's expected usage.
+</Tip>
+</Accordion>
+
+<Accordion title="Region (required)">
+Select the Google Cloud region where your Vertex AI models should be accessed. Common options include `us-central1`, `us-east4`, or `europe-west4`.
+
+[View Google Cloud Regions](https://cloud.google.com/docs/geography-and-regions)
+
+<Note>
+Choose a region close to your team's location for optimal performance. Some models may not be available in all regions.
+</Note>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use Google Vertex AI with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "Google Vertex AI" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only Vertex AI as a provider
+4. Verify that Gemini models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization and that your Google Cloud project has Vertex AI API enabled.
+
+**Project access errors**  
+Verify the project ID is correct and that Vertex AI API is enabled. Check that the project has appropriate billing configured and hasn't exceeded quotas.
+
+**Regional availability issues**  
+Confirm the selected region supports the Gemini models you want to use. Some newer models may only be available in specific regions.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change project or region later**  
+You can update these settings at any time. Members will need to ensure their local Google Cloud credentials have access to the new project/region.
+
+For further details, consult the [Google Cloud Vertex AI Documentation](https://cloud.google.com/vertex-ai/docs) and coordinate with your internal cloud team.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration.mdx
new file mode 100644
index 0000000..6bcd76b
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration.mdx
@@ -0,0 +1,177 @@
+---
+title: "Configure Google Vertex AI in VS Code (Members)"
+sidebarTitle: "Configure Google Vertex (Member)"
+description: "Guide for engineers connecting to their organization's Google Vertex AI setup through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's Google Vertex AI setup. This guide walks you through configuring your Google Cloud credentials in VS Code so you can start using Vertex AI models through your organization's configured project and regional settings. Your administrator has already configured the provider settings-you just need to add your credentials to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's Google Vertex AI setup, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**Google Cloud credentials with Vertex AI access**  
+You need Google Cloud credentials that have permission to access Vertex AI in your organization's configured project and region.
+
+<Note>
+If you're unsure which method to use, check with your administrator or IT team about how your organization has configured Google Cloud access.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area (it will display as `vertex_ai/gemini-pro` or similar)
+
+</Step>
+
+<Step title="Select Your Authentication Method">
+Choose one of the following credential methods to authenticate with Google Vertex AI:
+
+<AccordionGroup>
+<Accordion title="Service Account Key">
+Use a service account JSON key file for Vertex AI access.
+
+[Learn more about Service Account Keys](https://cloud.google.com/iam/docs/service-accounts)
+
+1. Select the **Service Account Key** authentication method
+2. Upload or paste your service account JSON key content
+3. The key should have `aiplatform.user` or similar Vertex AI permissions
+4. These credentials are stored locally and used only by the VS Code extension
+</Accordion>
+
+<Accordion title="Google Cloud SDK">
+Use the Google Cloud SDK installed on your machine with your authenticated account.
+
+[Learn more about Google Cloud SDK](https://cloud.google.com/sdk/docs/install)
+
+1. Select the **Google Cloud SDK** authentication method
+2. Ensure you've authenticated with `gcloud auth login`
+3. Verify your account has access to the organization's Vertex AI project
+4. Cline will use your default Google Cloud credentials automatically
+</Accordion>
+
+<Accordion title="Application Default Credentials">
+Use Google Cloud's application default credentials (ADC) chain.
+
+1. Select the **Application Default Credentials** method
+2. Ensure ADC is properly configured in your environment
+3. This works well for environments where Google Cloud credentials are managed centrally
+4. Cline will automatically detect credentials from your environment
+</Accordion>
+</AccordionGroup>
+
+<Note>
+The Google Cloud Project ID and Region are preconfigured by your administrator and do not need to be set in the extension.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After selecting your authentication method, the extension will display checkmarks for enabled features:
+
+- ✓ Supports images (for Gemini Pro Vision and similar models)
+- ✓ Supports multimodal inputs
+- ✓ Supports function calling (for supported models)
+
+The project ID and region settings will be locked (shown with a lock icon 🔒) as they're controlled by your administrator.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your credentials work correctly with the configured Vertex AI project and region.
+
+<Tip>
+**Testing Recommendation**
+
+Try a simple test like "Hello" first to verify basic connectivity, then test multimodal capabilities if needed by sharing an image.
+</Tip>
+</Step>
+</Steps>
+
+## Model Usage
+
+### Available Model Families
+The models available through your organization's Vertex AI setup typically include:
+
+**Gemini Models:**
+- **Gemini Pro**: Advanced reasoning, code generation, and multimodal capabilities
+- **Gemini Pro Vision**: Image understanding and visual question answering
+- **Gemini Ultra**: Most capable model for complex reasoning tasks
+
+**PaLM Models:**
+- **PaLM 2 for Text**: Text generation and completion
+- **PaLM 2 for Chat**: Conversational AI interactions
+- **Codey**: Specialized for code generation and explanation
+
+**Specialized Models:**
+- **Text Embedding**: For semantic search and similarity tasks  
+- **Custom Models**: Your organization's fine-tuned variants (if available)
+
+### Model Selection Strategy
+Choose models based on your development needs:
+
+- **General tasks**: Use Gemini Pro for most text and reasoning tasks
+- **Visual content**: Use Gemini Pro Vision when working with images
+- **Code-heavy work**: Use Codey models for programming tasks
+- **Complex reasoning**: Use Gemini Ultra for sophisticated problem-solving
+- **Embedding tasks**: Use Text Embedding models for semantic operations
+
+### Multimodal Capabilities
+Take advantage of Vertex AI's multimodal features:
+
+- **Image Analysis**: Upload images directly in Cline for analysis
+- **Visual Question Answering**: Ask questions about images
+- **Code Screenshots**: Get explanations of code from screenshots
+- **Document Processing**: Analyze charts, graphs, and visual data
+
+## Troubleshooting
+
+**Google Vertex AI not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Vertex AI configuration and that you have the latest version of the Cline extension.
+
+**Authentication errors ("Access Denied" or "Invalid Credentials")**  
+Verify your chosen credential method has the necessary IAM permissions to access Vertex AI in the configured project and region. Required permissions include `aiplatform.endpoints.predict` and `aiplatform.models.predict`.
+
+**Project access errors**  
+Ask your administrator to confirm which Google Cloud project is configured for your organization. Ensure your Google Cloud credentials have access to that specific project.
+
+**Regional access errors**  
+Verify your credentials have access to Vertex AI in the configured region. Some models may not be available in all regions, so confirm with your administrator about the selected region.
+
+**Google Cloud SDK authentication issues**  
+Ensure Google Cloud SDK is properly installed and authenticated:
+```bash
+gcloud auth login
+gcloud config set project YOUR_PROJECT_ID
+gcloud auth application-default login
+```
+
+**Service account key errors**  
+Verify the service account key is valid and hasn't expired. Check that the service account has the proper Vertex AI permissions in your organization's project. Ensure the JSON key file is properly formatted and contains all required fields.
+
+**Model access errors or "model not found"**  
+Some models may not be enabled in your organization's project or region. Contact your administrator if specific models are not available. Verify that your organization has enabled the models you're trying to use in the Google Cloud Console.
+
+## Security Best Practices
+
+When configuring your Google Cloud credentials, follow these security guidelines:
+
+- Use service accounts with minimal required permissions for Vertex AI access
+- Rotate service account keys regularly (every 90 days recommended)
+- Never store credentials in code or version control
+- Use Google Cloud SDK where possible for better credential management
+- Consider using Workload Identity for containerized development environments
+- Report any suspicious activity or unauthorized access attempts
+
+Your organization administrator controls which models and regions are available. The extension will automatically display available models based on your project's configuration and regional availability.
+
+For more information about Google Cloud authentication and Vertex AI permissions, refer to the [Google Cloud IAM Documentation](https://cloud.google.com/iam/docs) and coordinate with your organization's cloud administrator.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration.mdx
new file mode 100644
index 0000000..4d8b5a3
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration.mdx
@@ -0,0 +1,120 @@
+---
+title: "Configure LiteLLM Provider (Admin)"
+sidebarTitle: "Configure LiteLLM (Admin)"
+description: "This guide explains how administrators configure LiteLLM as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add LiteLLM as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach provides unified access to multiple AI models through your LiteLLM proxy interface.
+
+## Before You Begin
+
+To get started with setting up LiteLLM as your organization's LLM provider, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+<Info>
+**Quick Check**: Try accessing the settings page now. If you can see the provider configuration options, you're good to go.
+</Info>
+
+**LiteLLM proxy instance running**  
+You need a deployed LiteLLM proxy that your team can access. This can be self-hosted or managed through a cloud provider.
+
+<Note>
+If you haven't deployed LiteLLM yet, work with your infrastructure team to set up a LiteLLM proxy instance.
+</Note>
+
+**LiteLLM endpoint details**  
+You'll need the base URL of your LiteLLM proxy and optionally a master key if your deployment requires authentication.
+
+<Tip>
+Ensure your LiteLLM proxy is accessible from your team's development environments and has the models you want to make available configured.
+</Tip>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select LiteLLM as the API Provider">
+Open the **API Provider** dropdown menu and select **LiteLLM**. This will open the LiteLLM configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure LiteLLM Settings">
+The configuration panel includes settings that control how LiteLLM works for your organization:
+
+<AccordionGroup>
+<Accordion title="Base URL (required)">
+Enter your LiteLLM proxy endpoint URL. This should be the full URL where your LiteLLM proxy is accessible, such as `https://litellm.yourcompany.com` or `http://your-proxy:4000`.
+
+<Tip>
+Use HTTPS endpoints in production for security. Make sure the URL is accessible from your team's development environments.
+</Tip>
+</Accordion>
+
+<Accordion title="Master Key (optional)">
+If your LiteLLM proxy requires authentication, enter the master key here. This will be used to authenticate requests from all organization members.
+
+<Note>
+**Centralized API Key Management**: By configuring the Master Key at the organization level, you enable centralized API key management. Organization members won't need to manage their own individual API keys - access is fully managed through this centralized configuration.
+</Note>
+
+<Warning>
+The master key provides full access to your LiteLLM proxy. Only enter this if your proxy requires authentication and you want centralized key management.
+</Warning>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use LiteLLM with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "LiteLLM" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only LiteLLM as a provider
+4. Verify that the configured models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization and that your LiteLLM proxy is accessible from their network.
+
+**Connection errors to LiteLLM proxy**  
+Verify the Base URL is correct and accessible. Check that any firewalls or security groups allow access from your team's IP addresses or development environments.
+
+**Authentication failures**  
+If using a master key, verify it's correctly entered and has proper permissions in your LiteLLM deployment. Check the LiteLLM proxy logs for authentication errors.
+
+**Models not available**  
+Confirm the models are properly configured in your LiteLLM proxy deployment. The available models depend on how your LiteLLM proxy is configured.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change endpoint or key later**  
+You can update these settings at any time. Changes take effect immediately for all organization members.
+
+For further details about LiteLLM deployment and configuration, consult the [LiteLLM Documentation](https://docs.litellm.ai/) and coordinate with your infrastructure team.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/litellm/member-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/litellm/member-configuration.mdx
new file mode 100644
index 0000000..38ccc85
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/litellm/member-configuration.mdx
@@ -0,0 +1,168 @@
+---
+title: "Configure LiteLLM in VS Code (Members)"
+sidebarTitle: "Configure LiteLLM (Member)"
+description: "Guide for engineers connecting to their organization's LiteLLM proxy through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's LiteLLM proxy setup. This guide walks you through configuring your connection in VS Code so you can start using multiple AI models through your organization's unified proxy interface. Your administrator has already configured the provider settings-you just need to add your credentials to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's LiteLLM proxy, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**Access credentials for your organization's LiteLLM proxy**  
+You need credentials to access your organization's LiteLLM proxy. This might be an API key, or the proxy might be configured for open access within your network.
+
+<Note>
+If you're unsure about the credentials needed, check with your administrator or IT team about how to access your organization's LiteLLM proxy.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area (it will display as `LiteLLM` or show a specific model name)
+
+</Step>
+
+<Step title="Configure LiteLLM Connection">
+The LiteLLM configuration options depend on how your organization has set up the proxy:
+
+<AccordionGroup>
+<Accordion title="API Key Authentication">
+If your organization requires API key authentication:
+
+1. Select or confirm the **LiteLLM** provider is selected
+2. Enter your assigned API key in the **API Key** field
+3. The base URL should already be configured by your administrator
+4. Click **Save** to store your credentials
+
+<Tip>
+API keys are stored locally in VS Code and are only used by the Cline extension.
+</Tip>
+</Accordion>
+
+<Accordion title="Open Access (No Authentication)">
+If your LiteLLM proxy is configured for open access within your network:
+
+1. Select or confirm the **LiteLLM** provider is selected  
+2. Leave the API key field empty
+3. The extension will connect directly to the configured proxy endpoint
+4. No additional authentication is required
+
+<Info>
+Open access is common when the LiteLLM proxy is deployed within a secure network environment.
+</Info>
+</Accordion>
+
+<Accordion title="Custom Configuration">
+If your organization uses custom authentication or specific connection parameters:
+
+1. Follow any custom instructions provided by your administrator
+2. Contact your IT team if you encounter connection issues
+3. Additional configuration may be needed outside of VS Code
+
+<Note>
+Custom configurations might require specific network settings or additional authentication steps.
+</Note>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Select Available Models">
+Once connected, you'll see the models available through your organization's LiteLLM proxy:
+
+- View available models in the model dropdown
+- Models are determined by your administrator's proxy configuration  
+- You can switch between models for different types of tasks
+- Some models may be restricted based on your access level
+
+<Tip>
+**Model Selection**
+
+Choose models based on your task requirements:
+- **Fast models** (like GPT-3.5-turbo) for quick responses
+- **Powerful models** (like GPT-4) for complex reasoning
+- **Specialized models** for code generation or specific domains
+</Tip>
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your connection works correctly with the LiteLLM proxy.
+
+<Tip>
+**Testing Recommendation**
+
+Test the connection in plan mode first to verify everything works correctly before using it for actual development tasks.
+</Tip>
+</Step>
+</Steps>
+
+## Model Usage
+
+### Available Model Categories
+The models available through your LiteLLM proxy typically include:
+
+**Text Generation Models:**
+- OpenAI GPT-4, GPT-3.5-turbo variants
+- Anthropic Claude 3 Sonnet, Haiku, Opus
+- Open source models like Llama 2, Mistral
+
+**Code-Specific Models:**
+- OpenAI GPT-4 for code
+- CodeLlama variants
+- Specialized code completion models
+
+**Multimodal Models:**
+- GPT-4 Vision for image analysis
+- Claude 3 models with vision capabilities
+
+### Model Selection Strategy
+Choose models based on your development needs:
+
+- **Quick iterations**: Use faster, cost-effective models
+- **Complex problems**: Use more powerful models  
+- **Code-heavy tasks**: Use code-specialized models
+- **Visual content**: Use multimodal models when working with images
+
+## Troubleshooting
+
+**LiteLLM not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the LiteLLM configuration and that you have the latest version of the Cline extension.
+
+**Connection errors or timeouts**  
+Verify your network can reach the LiteLLM proxy endpoint. Check with your IT team about firewall rules or VPN requirements. Ensure the proxy endpoint is accessible from your development environment.
+
+**Authentication failures**  
+If using API key authentication, verify the key is correctly entered and hasn't expired. Contact your administrator to confirm your key is active and has the proper permissions.
+
+**Models not loading or are limited**  
+The available models depend on your organization's LiteLLM configuration. Contact your administrator if you need access to specific models or if expected models aren't available.
+
+**Slow response times**  
+Response times depend on the models being used and proxy load. Try switching to faster models for routine tasks. Contact your administrator if performance is consistently poor.
+
+**Error messages from specific models**  
+Some models may be temporarily unavailable or have specific limitations. Try alternative models or contact your administrator if specific models are consistently failing.
+
+## Security Best Practices
+
+When working with your organization's LiteLLM proxy:
+
+- Keep your API credentials secure and don't share them
+- Use appropriate models for the sensitivity of your data  
+- Follow your organization's usage guidelines
+- Report any suspicious activity or unauthorized access attempts
+- Regularly update the Cline extension for security patches
+
+Your organization administrator controls which models are available and usage policies. The extension will automatically display available models based on your proxy configuration and access level.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration.mdx
new file mode 100644
index 0000000..3270443
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration.mdx
@@ -0,0 +1,138 @@
+---
+title: "Configure OpenAI Compatible Provider (Admin)"
+sidebarTitle: "Configure OpenAI Compatible (Admin)"
+description: "This guide explains how administrators configure an OpenAI-compatible endpoint as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add an OpenAI-compatible endpoint as the organization-wide LLM provider for all Cline users through the hosted admin console. This covers any provider that exposes an OpenAI-compatible API, including Azure Foundry (Azure OpenAI), self-hosted inference engines (vLLM, TGI), and other compatible services.
+
+## Before You Begin
+
+To get started with setting up an OpenAI-compatible provider for your organization, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+**An OpenAI-compatible API endpoint**  
+You need a running endpoint that implements the OpenAI chat completions API. This could be:
+- Azure Foundry (Azure OpenAI Service)
+- A self-hosted inference engine (vLLM, text-generation-inference, etc.)
+- Any third-party service with an OpenAI-compatible API
+
+<Note>
+If you're using Azure Foundry, you'll need your Azure OpenAI endpoint URL and optionally the API version. Work with your Azure administrator to ensure the endpoint is provisioned and accessible.
+</Note>
+
+**Endpoint URL and authentication details**  
+You'll need the base URL of your endpoint and any required authentication headers.
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select OpenAI Compatible as the API Provider">
+Open the **API Provider** dropdown menu and select **OpenAI Compatible**. This will open the configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure OpenAI Compatible Settings">
+The configuration panel includes settings that control how the provider works for your organization:
+
+<AccordionGroup>
+<Accordion title="Base URL (required)">
+Enter the base URL of your OpenAI-compatible endpoint. Examples:
+
+- **Azure Foundry**: `https://your-resource.openai.azure.com`
+- **Self-hosted vLLM**: `https://inference.yourcompany.com/v1`
+- **Other compatible services**: The provider's API base URL
+
+<Tip>
+Use HTTPS endpoints in production for security. Ensure the URL is accessible from your team's development environments.
+</Tip>
+</Accordion>
+
+<Accordion title="Custom Headers (optional)">
+Add custom HTTP headers that will be included with every API request. This is useful for:
+
+- Custom authentication schemes beyond API keys
+- Routing headers for internal load balancers
+- Organization or tenant identifiers required by your endpoint
+
+Headers are configured as key-value pairs.
+</Accordion>
+
+<Accordion title="Azure API Version (optional — Azure Foundry only)">
+If you're using Azure Foundry (Azure OpenAI), specify the API version string. For example: `2024-02-15-preview` or `2024-06-01`.
+
+This field is only needed for Azure OpenAI deployments. Leave it empty for non-Azure endpoints.
+
+<Note>
+Check the [Azure OpenAI API version documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference) for available versions.
+</Note>
+</Accordion>
+
+<Accordion title="Azure Identity Authentication (optional — Azure Foundry only)">
+Enable this to use Azure Active Directory (Entra ID) token-based authentication instead of API keys. When enabled, members authenticate using their Azure AD credentials rather than a static API key.
+
+This field is only relevant for Azure Foundry deployments.
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use the OpenAI Compatible provider with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Azure Foundry Configuration
+
+For organizations using Azure Foundry (Azure OpenAI Service), use the following configuration:
+
+1. **Base URL**: Your Azure OpenAI endpoint (e.g., `https://your-resource.openai.azure.com`)
+2. **Azure API Version**: The API version to use (e.g., `2024-06-01`)
+3. **Azure Identity Authentication**: Enable if your organization uses Azure AD for authentication instead of API keys
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "OpenAI Compatible" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only the OpenAI Compatible provider
+4. Verify that configured models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization.
+
+**Connection errors to the endpoint**  
+Verify the Base URL is correct and accessible from your team's development environments. Check that any firewalls or security groups allow access from developer IP addresses.
+
+**Azure authentication failures**  
+If using Azure Identity Authentication, verify that members' Azure AD accounts have the appropriate role assignments on the Azure OpenAI resource. If using API keys, verify the key is correctly entered by the member.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change endpoint or settings later**  
+You can update these settings at any time. Changes take effect immediately for all organization members.
+
+For Azure Foundry, consult the [Azure OpenAI Service documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). For other OpenAI-compatible endpoints, refer to your provider's documentation.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/member-configuration.mdx b/docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/member-configuration.mdx
new file mode 100644
index 0000000..0dca759
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/member-configuration.mdx
@@ -0,0 +1,117 @@
+---
+title: "Configure OpenAI Compatible in VS Code (Members)"
+sidebarTitle: "Configure OpenAI Compatible (Member)"
+description: "Guide for engineers connecting to their organization's OpenAI-compatible endpoint through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's OpenAI-compatible endpoint. This guide walks you through configuring your credentials in VS Code so you can start using models through your organization's configured endpoint. Your administrator has already configured the provider settings — you just need to add your API key to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's OpenAI-compatible endpoint, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**API key or credentials for your endpoint**  
+You need an API key or credentials to authenticate with your organization's configured endpoint. For Azure Foundry deployments using Azure Identity Authentication, your Azure AD credentials may be used instead.
+
+<Note>
+If you're unsure what credentials to use, check with your administrator or IT team about how your organization has configured access.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area
+
+</Step>
+
+<Step title="Configure Your Credentials">
+The authentication method depends on how your administrator configured the endpoint:
+
+<AccordionGroup>
+<Accordion title="API Key Authentication">
+For most OpenAI-compatible endpoints:
+
+1. Select or confirm the **OpenAI Compatible** provider is selected
+2. Enter your API key in the **API Key** field
+3. The base URL, custom headers, and other settings are preconfigured by your administrator
+4. Click **Save** to store your credentials
+
+<Tip>
+API keys are stored locally and are only used by the Cline extension.
+</Tip>
+</Accordion>
+
+<Accordion title="Azure Identity Authentication (Azure Foundry)">
+If your organization uses Azure AD authentication:
+
+1. Select or confirm the **OpenAI Compatible** provider is selected
+2. Ensure you are signed into Azure in your development environment
+3. The extension will use your Azure AD credentials automatically
+4. No API key is needed when Azure Identity Authentication is enabled
+
+<Note>
+You may need the Azure Account extension or Azure CLI installed for credential resolution.
+</Note>
+</Accordion>
+</AccordionGroup>
+
+<Note>
+The Base URL, custom headers, Azure API version, and Azure Identity settings are preconfigured by your administrator and do not need to be set in the extension.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After configuring your credentials, administrator-controlled settings will be locked (shown with a lock icon 🔒) as they're managed by your organization.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your credentials work correctly with the configured endpoint.
+
+<Tip>
+**Testing Recommendation**
+
+Try a simple test like "Hello" first to verify basic connectivity before starting development tasks.
+</Tip>
+</Step>
+</Steps>
+
+## Troubleshooting
+
+**OpenAI Compatible not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the configuration and that you have the latest version of the Cline extension.
+
+**Authentication errors ("Access Denied" or "Invalid API Key")**  
+Verify your API key is correct and active. For Azure Foundry with Azure Identity Authentication, ensure you are signed into Azure in your development environment and that your account has the appropriate role assignments on the Azure OpenAI resource.
+
+**Connection errors or timeouts**  
+The endpoint URL is configured by your administrator. If you experience connection issues, check with your IT team about network requirements (VPN, firewall rules, etc.).
+
+**Models not available**  
+The available models depend on your organization's endpoint configuration. Contact your administrator if expected models are not available in the model dropdown.
+
+**Configuration changes don't persist**  
+Make sure to save your credentials. The base URL and other admin-controlled settings cannot be changed locally.
+
+## Security Best Practices
+
+When working with your API credentials:
+
+- Keep your API key secure and do not share it
+- Never store credentials in code or version control
+- Report any suspected key compromise to your administrator immediately
+- Follow your organization's usage guidelines for the configured endpoint
+
+Your organization administrator controls which endpoint, models, and settings are available. The extension will automatically apply the configured settings based on your organization's remote configuration.
+
+For Azure Foundry, refer to the [Azure OpenAI Service documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). For other endpoints, consult your organization's internal documentation or contact your administrator.
diff --git a/docs/enterprise-solutions/configuration/remote-configuration/overview.mdx b/docs/enterprise-solutions/configuration/remote-configuration/overview.mdx
new file mode 100644
index 0000000..fbbbbb1
--- /dev/null
+++ b/docs/enterprise-solutions/configuration/remote-configuration/overview.mdx
@@ -0,0 +1,116 @@
+---
+title: "Enterprise Provider Configuration"
+sidebarTitle: "Overview"
+description: "Configure inference providers through the Cline hosted admin console for centralized organization management"
+---
+
+
+Remote Provider Configuration allows administrators to centrally configure inference providers for their entire organization through the Cline hosted admin console. This approach ensures consistent provider access, security policies, and cost management across all team members without requiring individual developer setup or infrastructure deployment.
+
+## How Remote Configuration Works
+
+Remote configuration operates through Cline's hosted service at [app.cline.bot](https://app.cline.bot), where administrators can:
+
+<CardGroup cols={2}>
+  <Card title="Centralized Setup" icon="gear">
+    Configure providers once for the entire organization through the web-based admin console.
+  </Card>
+  
+  <Card title="Automatic Enforcement" icon="shield-check">
+    Team members automatically receive the configured provider settings when signed into their organization.
+  </Card>
+  
+  <Card title="Simplified Onboarding" icon="user-plus">
+    New team members get instant access to inference providers without complex individual configuration.
+  </Card>
+  
+  <Card title="Consistent Experience" icon="users">
+    Ensure all team members use the same models, regions, and settings organization-wide.
+  </Card>
+</CardGroup>
+
+## Supported Providers
+
+Cline supports remote configuration for the following inference providers:
+
+| Provider | Use Case | Configuration | Member Setup |
+|----------|----------|---------------|--------------|
+| **Cline** | Organizations using Cline's native provider with centralized API key management | API provider selection, model access | No individual API keys needed — fully managed by organization |
+| **Amazon Bedrock** | Organizations using AWS infrastructure | Region selection, VPC endpoints, cross-region inference, global inference, prompt caching | AWS credential configuration (API key, CLI profile, or credential chain) |
+| **Google Vertex AI** | Organizations using Google Cloud Platform | Project ID, region selection, model access | Google Cloud credential configuration (service account, SDK, or ADC) |
+| **Azure Foundry** | Organizations using Azure OpenAI or Azure AI services | Base URL, Azure API version, Azure identity authentication, custom headers | API key configuration in the extension |
+| **Anthropic** | Organizations using the Anthropic API directly | Optional custom base URL for proxy deployments, model access | API key configuration in the extension |
+| **OpenAI Compatible** | Organizations using any OpenAI-compatible endpoint (self-hosted, vLLM, custom proxies) | Base URL, custom headers, model access | API key configuration in the extension |
+| **LiteLLM** | Organizations requiring multi-model access through a unified proxy | Proxy endpoint, authentication, model routing | API key or endpoint configuration (or centralized with Master Key) |
+
+<Note>
+**Azure Foundry** uses the OpenAI Compatible provider configuration with Azure-specific settings (API version, Azure identity authentication). See the [OpenAI Compatible admin configuration](/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration) for setup instructions.
+</Note>
+
+## Configuration Process
+
+The typical remote configuration process follows these steps:
+
+<Steps>
+<Step title="Administrator Setup">
+Access the Cline admin console and configure the desired inference provider with organization-wide settings.
+</Step>
+
+<Step title="Automatic Distribution">
+Provider configuration is automatically distributed to all organization members signed into Cline.
+</Step>
+
+<Step title="Member Credential Setup">
+Team members add their individual credentials (API keys, AWS profiles, etc.) to connect to the configured provider. For some providers like Cline and LiteLLM (with Master Key), no individual credentials are needed.
+</Step>
+
+<Step title="Immediate Access">
+Once credentials are configured, members can immediately start using the inference provider through Cline.
+</Step>
+</Steps>
+
+## Benefits of Remote Configuration
+
+### **For Administrators**
+- **Centralized Control**: Manage all provider settings from one location
+- **Security Compliance**: Ensure consistent security policies across the organization
+- **Easy Updates**: Change provider settings organization-wide instantly
+
+### **For Team Members**  
+- **Simplified Setup**: No need to research provider configuration options
+- **Consistent Experience**: Same models and features available to everyone
+- **Quick Onboarding**: Get started immediately with pre-configured providers
+- **Focus on Development**: Spend time coding instead of configuring inference providers
+
+## Getting Started
+
+To get started with provider remote configuration:
+
+1. **Choose Your Provider**: Select the inference provider that best fits your organization's needs and existing infrastructure
+2. **Admin Configuration**: Follow the provider-specific admin configuration guide
+3. **Member Onboarding**: Have team members complete the provider-specific member configuration
+4. **Start Developing**: Begin using Cline with centrally managed inference provider access
+
+Select your provider below to begin the configuration process:
+
+<CardGroup cols={3}>
+  <Card title="Amazon Bedrock" icon="aws" href="/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration">
+    AWS-based AI models with enterprise security and compliance features.
+  </Card>
+  
+  <Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration">
+    Google Cloud's AI platform with Gemini models and regional control.
+  </Card>
+
+  <Card title="OpenAI Compatible" icon="plug" href="/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration">
+    Any OpenAI-compatible endpoint, including Azure Foundry.
+  </Card>
+
+  <Card title="Anthropic" icon="robot" href="/enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration">
+    Direct Anthropic API access with optional custom base URL configuration.
+  </Card>
+
+  <Card title="LiteLLM" icon="layer-group" href="/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration">
+    Unified proxy for accessing 100+ AI models through a single interface.
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/monitoring/opentelemetry-events.mdx b/docs/enterprise-solutions/monitoring/opentelemetry-events.mdx
new file mode 100644
index 0000000..f20ecf6
--- /dev/null
+++ b/docs/enterprise-solutions/monitoring/opentelemetry-events.mdx
@@ -0,0 +1,630 @@
+---
+title: "OpenTelemetry Events Reference"
+sidebarTitle: "OTel Events"
+description: "Complete reference of OpenTelemetry log events emitted by Cline"
+---
+
+This page documents all OpenTelemetry log events currently instrumented in Cline. These events are emitted when OpenTelemetry integration is enabled and provide detailed insights into user behavior, task execution, and system operations.
+
+<Info>
+Events are only emitted when OpenTelemetry is enabled. See [OpenTelemetry](/enterprise-solutions/monitoring/opentelemetry) for configuration instructions.
+</Info>
+
+## Event Categories
+
+Cline emits events across several categories, each prefixed with a namespace:
+
+<CardGroup cols={3}>
+  <Card title="user.*" icon="user">
+    Authentication, telemetry controls, extension lifecycle
+  </Card>
+  
+  <Card title="task.*" icon="list-check">
+    Task execution, conversation turns, tool usage, tokens
+  </Card>
+  
+  <Card title="workspace.*" icon="folder-tree">
+    Workspace initialization, VCS detection, path resolution
+  </Card>
+  
+  <Card title="ui.*" icon="window">
+    User interface interactions and model selection
+  </Card>
+  
+  <Card title="hooks.*" icon="webhook">
+    Hook discovery, execution, and context modification
+  </Card>
+  
+  <Card title="worktree.*" icon="code-branch">
+    Git worktree operations and merge handling
+  </Card>
+  
+  <Card title="host.*" icon="computer">
+    Host environment detection
+  </Card>
+  
+  <Card title="test.*" icon="flask">
+    Diagnostic and connection testing
+  </Card>
+</CardGroup>
+
+## User Events
+
+Events related to user authentication, telemetry preferences, and extension lifecycle.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `user.opt_out` | User explicitly opts out of telemetry | user_id, timestamp |
+| `user.opt_in` | User explicitly opts into telemetry | user_id, timestamp |
+| `user.telemetry_enabled` | Telemetry service enabled/initialization signal | enabled, timestamp |
+| `user.extension_activated` | Extension activation event | extension_version, host_type |
+| `user.extension_storage_error` | Error while reading/writing extension storage state | error_type, error_message |
+| `user.auth_started` | Authentication flow started | provider, timestamp |
+| `user.auth_succeeded` | Authentication flow succeeded | provider, user_id |
+| `user.auth_failed` | Authentication flow failed | provider, error_reason |
+| `user.auth_logged_out` | User logged out | reason, provider |
+| `user.onboarding_progress` | Onboarding step/action progress | step, action, completed |
+
+### Example: user.auth_succeeded
+
+```json
+{
+  "event": "user.auth_succeeded",
+  "timestamp": "2026-03-05T10:30:00Z",
+  "attributes": {
+    "provider": "github",
+    "user_id": "user_abc123",
+    "session_id": "sess_xyz789"
+  }
+}
+```
+
+## Workspace Events
+
+Events related to workspace initialization, version control detection, and multi-root operations.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `workspace.initialized` | Workspace initialization completed | roots_count, vcs_type, duration_ms |
+| `workspace.init_error` | Workspace initialization failed | error_type, fallback_used |
+| `workspace.vcs_detected` | Version control system detection event | vcs_type, root_path_hash |
+| `workspace.multi_root_checkpoint` | Multi-root checkpoint operation telemetry | operation, roots_count, duration_ms |
+| `workspace.path_resolved` | Workspace path resolution | hint, fallback_used, cross_workspace |
+
+### Example: workspace.initialized
+
+```json
+{
+  "event": "workspace.initialized",
+  "timestamp": "2026-03-05T10:32:15Z",
+  "attributes": {
+    "roots_count": 2,
+    "vcs_type": "git",
+    "duration_ms": 145,
+    "multi_root_enabled": true
+  }
+}
+```
+
+## Task Events
+
+Core events tracking task lifecycle, conversation turns, tool usage, and execution details.
+
+### Task Lifecycle
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.created` | New task/conversation started | task_id, mode, model, provider |
+| `task.restarted` | Existing task restarted/reopened | task_id, time_since_last_message |
+| `task.completed` | Task completed | task_id, duration_ms, model, provider, tokens_total |
+| `task.feedback` | User feedback on task | task_id, feedback_type (thumbs_up/thumbs_down) |
+| `task.historical_loaded` | Historical task loaded from storage | task_id, age_days |
+| `task.retry_clicked` | User clicked retry on a failed action/request | task_id, action_type |
+
+### Conversation & Tokens
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.conversation_turn` | Conversation turn event | role (user/assistant), provider, model, tokens_in, tokens_out |
+| `task.tokens` | Token usage event | tokens_in, tokens_out, cached_tokens, cost |
+| `task.mode` | Plan/Act mode switch event | previous_mode, new_mode, task_id |
+
+### Tool Usage
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.tool_used` | Tool invocation and outcome telemetry | tool_name, success, duration_ms, auto_approved |
+| `task.mcp_tool_called` | MCP tool call lifecycle event | status (started/success/error), tool_name, server_name |
+| `task.browser_tool_start` | Browser tool/session started | url, action |
+| `task.browser_tool_end` | Browser tool/session ended with stats | duration_ms, actions_count, success |
+| `task.browser_error` | Browser tool error event | error_type, url |
+| `task.terminal_execution` | Terminal execution capture success/failure event | success, command_hash, duration_ms |
+| `task.terminal_output_failure` | Terminal output capture failed | reason |
+| `task.terminal_user_intervention` | User intervention during terminal execution | intervention_type |
+| `task.terminal_hang` | Terminal hang/stuck detection event | duration_ms, command_hash |
+
+### Features & Options
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.checkpoint_used` | Checkpoint action used | action (create/restore/compare), task_id |
+| `task.option_selected` | User selected one of AI-provided options | option_index, total_options |
+| `task.options_ignored` | User ignored AI options and entered custom input | options_count |
+| `task.slash_command_used` | Slash command or MCP prompt command used | command_name |
+| `task.mention_used` | Mention resolution succeeded | mention_type (file/url/folder/terminal/problems/git) |
+| `task.mention_failed` | Mention resolution failed | mention_type, error_reason |
+| `task.mention_search_results` | Mention search query result telemetry | query, results_count |
+| `task.workspace_search_pattern` | Workspace search strategy/pattern telemetry | pattern_type, files_scanned |
+
+### Advanced Features
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.focus_chain_enabled` | Focus chain feature enabled | task_id |
+| `task.focus_chain_disabled` | Focus chain feature disabled | task_id |
+| `task.focus_chain_progress_first` | First focus-chain checklist/progress emitted | items_count |
+| `task.focus_chain_progress_update` | Subsequent focus-chain checklist/progress updates | items_total, items_completed |
+| `task.focus_chain_incomplete_on_completion` | Task completed while focus-chain checklist still incomplete | items_remaining |
+| `task.focus_chain_list_opened` | Focus-chain markdown/list opened by user | task_id |
+| `task.focus_chain_list_written` | Focus-chain markdown/list written/saved | task_id |
+| `task.subagent_enabled` | Subagents feature enabled | task_id |
+| `task.subagent_disabled` | Subagents feature disabled | task_id |
+| `task.subagent_started` | Subagent execution started | subagent_id, prompt_length |
+| `task.subagent_completed` | Subagent execution completed | subagent_id, duration_ms, success |
+| `task.skill_used` | Skill invocation event | skill_name, task_id |
+
+### Auto-Compact & Context
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.summarize_task` | Auto-compaction/summarize triggered for context pressure | conversation_length, estimated_tokens |
+| `task.auto_condense_toggled` | Auto-condense setting toggled | enabled |
+
+### Settings & Features
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.feature_toggled` | Generic feature toggle changed | feature_name, enabled |
+| `task.rule_toggled` | Cline rule toggled on/off | rule_name, enabled, is_global |
+| `task.yolo_mode_toggled` | YOLO mode toggled | enabled |
+| `task.cline_web_tools_toggled` | Cline web tools setting toggled | enabled |
+
+### API & Performance
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.gemini_api_performance` | Gemini-specific API performance telemetry | duration_ms, tokens, cache_hit |
+| `task.provider_api_error` | API provider error event | provider, model, error_code, error_message |
+| `task.diff_edit_failed` | Diff/replace edit failed | file_path_hash, error_type |
+| `task.initialization` | Task initialization timing/metadata event | duration_ms, mode |
+
+### AI Output Feedback
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `task.ai_output.accepted` | AI-generated file edit accepted | lines_added, lines_removed, file_count |
+| `task.ai_output.rejected` | AI-generated file edit rejected | lines_added, lines_removed, file_count |
+
+### Example: task.tool_used
+
+```json
+{
+  "event": "task.tool_used",
+  "timestamp": "2026-03-05T10:35:22Z",
+  "attributes": {
+    "task_id": "task_1234567890",
+    "tool_name": "write_to_file",
+    "success": true,
+    "duration_ms": 125,
+    "auto_approved": false,
+    "model": "claude-sonnet-4",
+    "provider": "anthropic"
+  }
+}
+```
+
+## UI Events
+
+Events tracking user interface interactions.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `ui.model_selected` | Model selected in UI | model, provider, previous_model |
+| `ui.model_favorite_toggled` | Model favorite toggled | model_id, is_favorited |
+| `ui.button_clicked` | UI button click event | button_id, context |
+| `ui.rules_menu_opened` | Rules/skills menu/modal opened | menu_type |
+
+### Example: ui.model_selected
+
+```json
+{
+  "event": "ui.model_selected",
+  "timestamp": "2026-03-05T11:20:00Z",
+  "attributes": {
+    "model": "claude-sonnet-4",
+    "provider": "anthropic",
+    "previous_model": "gpt-4o",
+    "mode": "act"
+  }
+}
+```
+
+## Hooks Events
+
+Events related to hook discovery, execution lifecycle, and context modifications.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `hooks.enabled` | Hooks feature enabled | user_id |
+| `hooks.disabled` | Hooks feature disabled | user_id |
+| `hooks.cancel_requested` | Hook requested cancellation | hook_name, task_id |
+| `hooks.context_modified` | Hook modified context | hook_name, modification_type |
+| `hooks.discovery_completed` | Hook discovery completed | hooks_count, global_count, workspace_count |
+| `hooks.execution` | Unified hook execution lifecycle | hook_name, status (started/completed/failed/cancelled), duration_ms |
+
+### Hook Execution Lifecycle
+
+The `hooks.execution` event tracks the complete lifecycle with a `status` attribute:
+
+- **started**: Hook execution began
+- **completed**: Hook finished successfully
+- **failed**: Hook encountered an error
+- **cancelled**: Hook was cancelled by user or system
+
+### Example: hooks.execution
+
+```json
+{
+  "event": "hooks.execution",
+  "timestamp": "2026-03-05T10:40:15Z",
+  "attributes": {
+    "hook_name": "preToolUse",
+    "status": "completed",
+    "duration_ms": 234,
+    "task_id": "task_1234567890",
+    "context_modified": false
+  }
+}
+```
+
+## Worktree Events
+
+Events related to Git worktree operations.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `worktree.view_opened` | Worktree view opened | user_id |
+| `worktree.created` | Worktree create event | success, branch_name, duration_ms |
+| `worktree.merge_attempted` | Worktree merge attempt event | has_conflicts, delete_option_chosen |
+
+### Example: worktree.created
+
+```json
+{
+  "event": "worktree.created",
+  "timestamp": "2026-03-05T14:22:00Z",
+  "attributes": {
+    "success": true,
+    "branch_name_hash": "abc123",
+    "duration_ms": 1250,
+    "parent_branch": "main"
+  }
+}
+```
+
+## Host Events
+
+Events related to host environment detection.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `host.detected` | Host environment detection event | host_type (vscode/jetbrains/cli), version |
+
+### Example: host.detected
+
+```json
+{
+  "event": "host.detected",
+  "timestamp": "2026-03-05T09:00:00Z",
+  "attributes": {
+    "host_type": "vscode",
+    "version": "1.95.0",
+    "platform": "darwin"
+  }
+}
+```
+
+## Test Events
+
+Diagnostic and connection testing events.
+
+| Event | Description | Key Attributes |
+|-------|-------------|----------------|
+| `cline.test.connection` | OTEL connection test event from "Test OTEL Connection" flow | success, exporter_type, endpoint |
+
+### Example: cline.test.connection
+
+```json
+{
+  "event": "cline.test.connection",
+  "timestamp": "2026-03-05T15:30:00Z",
+  "attributes": {
+    "success": true,
+    "exporter_type": "otlp",
+    "endpoint": "https://api.datadoghq.com:4317",
+    "protocol": "grpc"
+  }
+}
+```
+
+## Event Attribute Guidelines
+
+### Common Attributes
+
+Most events include these standard attributes:
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `timestamp` | ISO 8601 | Event occurrence time |
+| `user_id` | string | Anonymized user identifier (when authenticated) |
+| `session_id` | string | Current session identifier |
+| `extension_version` | string | Cline extension version |
+| `host_type` | string | vscode, jetbrains, or cli |
+
+### Privacy & Hashing
+
+Sensitive information is hashed or anonymized:
+
+- **File paths**: Hashed to preserve privacy
+- **Command content**: Hashed, not logged verbatim
+- **User identifiers**: Anonymized tokens
+- **Branch names**: Hashed in worktree events
+
+<Warning>
+File paths, command arguments, and code content are **never** included in raw form. Only hashes or anonymized identifiers are used.
+</Warning>
+
+## Task Event Deep Dive
+
+Task events are the most detailed category. Here's a typical task execution flow:
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Cline
+    participant OTel
+
+    User->>Cline: Start Task
+    Cline->>OTel: task.created
+    
+    User->>Cline: Submit Message
+    Cline->>OTel: task.conversation_turn (user)
+    
+    Cline->>Cline: Process with AI
+    Cline->>OTel: task.tokens
+    Cline->>OTel: task.conversation_turn (assistant)
+    
+    Cline->>Cline: Use Tool
+    Cline->>OTel: task.tool_used
+    
+    User->>Cline: Provide Feedback
+    Cline->>OTel: task.option_selected
+    
+    User->>Cline: Complete Task
+    Cline->>OTel: task.completed
+```
+
+### Task Token Tracking
+
+Token events provide detailed cost and usage information:
+
+```json
+{
+  "event": "task.tokens",
+  "timestamp": "2026-03-05T10:35:30Z",
+  "attributes": {
+    "task_id": "task_1234567890",
+    "tokens_in": 2500,
+    "tokens_out": 850,
+    "cached_tokens": 1200,
+    "cost": 0.0043,
+    "model": "claude-sonnet-4",
+    "provider": "anthropic"
+  }
+}
+```
+
+## Using Events for Analytics
+
+<Warning>
+**SQL syntax is illustrative only.** Attribute access varies by observability platform — for example, `JSON_EXTRACT(attributes, '$.model')` in BigQuery, `attributes['model']` in ClickHouse, or `@attributes.model` in Datadog. Adapt all queries below to your platform's query language before use.
+</Warning>
+
+### Query Patterns
+
+**Most used tools:**
+```sql
+SELECT attributes.tool_name, COUNT(*) as count
+FROM otel_logs
+WHERE event = 'task.tool_used'
+  AND attributes.success = true
+GROUP BY attributes.tool_name
+ORDER BY count DESC
+LIMIT 10
+```
+
+**Average task duration by model:**
+```sql
+SELECT 
+  attributes.model,
+  AVG(attributes.duration_ms) as avg_duration_ms,
+  COUNT(*) as task_count
+FROM otel_logs
+WHERE event = 'task.completed'
+GROUP BY attributes.model
+```
+
+**Token usage by provider:**
+```sql
+SELECT 
+  attributes.provider,
+  SUM(attributes.tokens_in) as total_tokens_in,
+  SUM(attributes.tokens_out) as total_tokens_out,
+  SUM(attributes.cost) as total_cost
+FROM otel_logs
+WHERE event = 'task.tokens'
+  AND timestamp >= NOW() - INTERVAL '30 days'
+GROUP BY attributes.provider
+```
+
+**Tool approval rates:**
+```sql
+SELECT 
+  attributes.tool_name,
+  SUM(CASE WHEN attributes.auto_approved THEN 1 ELSE 0 END)::float / COUNT(*) as auto_approval_rate,
+  COUNT(*) as total_uses
+FROM otel_logs
+WHERE event = 'task.tool_used'
+GROUP BY attributes.tool_name
+ORDER BY total_uses DESC
+```
+
+## Integration Examples
+
+<Note>
+Query syntax below is illustrative. Attribute access varies by platform — for example, `JSON_EXTRACT(attributes, '$.model')` in BigQuery, `attributes['model']` in ClickHouse, or dot notation in Datadog. Adapt to your platform's query language.
+</Note>
+
+### Datadog Dashboard
+
+Create custom Datadog dashboards using these events:
+
+```json
+{
+  "widgets": [
+    {
+      "definition": {
+        "type": "timeseries",
+        "requests": [
+          {
+            "q": "sum:cline.task.completed{*}.as_count()",
+            "display_type": "bars"
+          }
+        ],
+        "title": "Tasks Completed Over Time"
+      }
+    },
+    {
+      "definition": {
+        "type": "query_value",
+        "requests": [
+          {
+            "q": "sum:cline.task.tokens{*}",
+            "aggregator": "sum"
+          }
+        ],
+        "title": "Total Tokens Used"
+      }
+    }
+  ]
+}
+```
+
+### Grafana Queries
+
+Example Loki query for tool usage:
+
+```logql
+{event="task.tool_used"} 
+| json
+| line_format "{{.attributes_tool_name}}: {{.attributes_success}}"
+```
+
+### New Relic NRQL
+
+Query task completion rates:
+
+```sql
+SELECT count(*) 
+FROM Log 
+WHERE event = 'task.completed' 
+FACET attributes.model 
+SINCE 1 day ago
+```
+
+## Event Schema Reference
+
+All events follow this structure:
+
+```typescript
+interface OtelLogEvent {
+  event: string              // Event name (e.g., "task.created")
+  timestamp: string           // ISO 8601 timestamp
+  attributes: {
+    // Event-specific attributes
+    [key: string]: string | number | boolean
+  }
+  resource: {
+    service_name: "cline"
+    service_version: string   // Extension version
+    host_type: string         // vscode | jetbrains | cli
+  }
+}
+```
+
+## Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Filter Noise" icon="filter">
+    Focus on events relevant to your use case. Not all events need dashboards.
+  </Card>
+  
+  <Card title="Set Alerts" icon="bell">
+    Alert on error events and usage anomalies for proactive monitoring.
+  </Card>
+  
+  <Card title="Aggregate Metrics" icon="chart-bar">
+    Roll up events into metrics for long-term trend analysis.
+  </Card>
+  
+  <Card title="Respect Privacy" icon="shield">
+    Remember events are already anonymized. Don't attempt to de-anonymize.
+  </Card>
+</CardGroup>
+
+## Troubleshooting
+
+### Events Not Appearing
+
+If events aren't showing up in your observability platform:
+
+1. **Verify OTel is enabled** in remote configuration or environment variables
+2. **Check endpoint configuration** - ensure URL and protocol are correct
+3. **Validate credentials** - test with the "Test OTEL Connection" button
+4. **Check exporter settings** - ensure logs exporter includes `otlp`
+5. **Review platform-specific requirements** - some platforms need specific headers
+
+### Event Volume Concerns
+
+If you're seeing excessive event volume:
+
+1. **Sample events** - Configure sampling in your OTel collector
+2. **Filter events** - Use your platform's filtering to drop noisy events
+3. **Aggregate on collection** - Pre-aggregate metrics before export
+4. **Adjust export intervals** - Increase `openTelemetryMetricExportInterval` and batch settings
+
+## See Also
+
+<CardGroup cols={3}>
+  <Card title="OpenTelemetry Setup" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Configure OTel integration
+  </Card>
+  
+  <Card title="Prompt Storage" icon="database" href="/enterprise-solutions/monitoring/prompt-storage">
+    Backup conversation history
+  </Card>
+  
+  <Card title="Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
+    Basic telemetry overview
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/monitoring/opentelemetry.mdx b/docs/enterprise-solutions/monitoring/opentelemetry.mdx
new file mode 100644
index 0000000..f5c967f
--- /dev/null
+++ b/docs/enterprise-solutions/monitoring/opentelemetry.mdx
@@ -0,0 +1,209 @@
+---
+title: "OpenTelemetry Integration"
+sidebarTitle: "OpenTelemetry"
+description: "Export Cline telemetry to your observability platform using OpenTelemetry Protocol (OTLP)"
+---
+
+Cline includes opt-in OpenTelemetry support for exporting metrics and logs to your own observability infrastructure using the OpenTelemetry Protocol (OTLP).
+
+<Note>
+OpenTelemetry integration is **optional** and intended for advanced users with existing observability infrastructure. Most users won't need this feature.
+</Note>
+
+## What is OpenTelemetry?
+
+[OpenTelemetry](https://opentelemetry.io/) is an industry-standard observability framework that provides a unified way to collect and export telemetry data (metrics, logs, and traces).
+
+Cline's OpenTelemetry support allows you to:
+- Export telemetry to your own systems
+- Integrate with observability platforms like Datadog, New Relic, Grafana Cloud, etc.
+- Maintain full control over your monitoring data
+- Use your organization's existing monitoring infrastructure
+
+## Supported Features
+
+Cline supports OpenTelemetry's **OTLP (OpenTelemetry Protocol)** export with:
+
+<CardGroup cols={2}>
+  <Card title="Metrics Export" icon="chart-bar">
+    Export metrics about Cline usage, performance, and errors
+  </Card>
+  
+  <Card title="Logs Export" icon="file-lines">
+    Export structured logs for debugging and analysis
+  </Card>
+</CardGroup>
+
+### Export Formats
+
+Cline supports three OTLP export protocols:
+
+- **gRPC** (default, recommended)
+- **HTTP/protobuf**
+- **HTTP/JSON**
+
+## Configuration
+
+OpenTelemetry is configured using [Remote Configuration](/enterprise-solutions/configuration/remote-configuration/overview#how-remote-configuration-works) from the [dashboard](https://app.cline.bot/dashboard/organization?tab=settings).
+
+### Basic Setup
+
+Enable OpenTelemetry, configure an OTLP endpoint and select a protocol:
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/open_telemetry_main_options.png"
+	/>
+</Frame>
+
+If you're using gRPC, you can opt out of TLS.
+
+Once the collector has been configured, you can enable logs and/or metrics collection. At least one of them needs to be enabled.
+
+You only need to configure it further if you need an advanced configuration.
+
+### Advanced Configuration
+
+You can add custom protocols and endpoints for both, logs and metrics. You can also configure the metrics export interval, and the logs batch size, batch timeout and max queue size.
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/open_telemetry_metrics_and_logs.png"
+	/>
+</Frame>
+
+**Custom headers for authentication:**
+
+Finally, if your collector needs authentication headers, you can add key value pairs in the headers section.
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/open_telemetry_headers.png"
+	/>
+</Frame>
+
+## Integration Examples
+
+### Datadog
+
+Export to Datadog using their OTLP endpoint:
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/open_telemetry_datadog_example.png"
+	/>
+</Frame>
+
+### New Relic
+
+Export to New Relic:
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/open_telemetry_relic_example.png"
+	/>
+</Frame>
+
+### Grafana Cloud
+
+Export to Grafana Cloud:
+
+<Frame>
+	<img
+		src="https://assets.int.cline.bot/assets/open_telemetry_grafana_example.png"
+	/>
+</Frame>
+
+## Testing Configuration
+
+To test your configuration, log in to your account, perform some actions in a task, wait for the export interval, and verify that the data has arrived at your collector.
+
+## Troubleshooting
+
+If you aren’t getting any data in your collector, the easiest way to verify your integration is to enable the developer tools in your editor.
+
+To do this, open the [webview developer tools](https://code.visualstudio.com/api/extension-guides/webview#inspecting-and-debugging-webviews).
+
+Once you’ve done so, if you perform some actions that trigger metrics and/or logs (such as doing a task with Cline), 
+you will see error logs if any error occurs when sending the data to your collector.
+
+If you don't see any logs, enable [debug mode](#debug-mode).
+
+### Connection Errors
+
+1. **Verify endpoint is accessible:**
+   ```bash
+   curl -v https://your-otlp-endpoint:4317
+   ```
+
+2. **Check if insecure mode is needed** by opting out of TLS
+
+3. **Verify authentication headers:**
+   Double-check your API keys and authentication headers are correct
+
+### Debug Mode
+
+Enable debug logging to see detailed OpenTelemetry information:
+
+```bash
+TEL_DEBUG_DIAGNOSTICS=true code .
+```
+
+This will output detailed information about:
+- Configuration being used
+- Exporters being created
+- Connection attempts
+- Export successes/failures
+
+## What Gets Exported
+
+When OpenTelemetry is enabled, Cline exports:
+
+### Metrics
+- Feature usage counts
+- Task execution metrics 
+- Error rates and types
+- Performance measurements
+
+### Logs
+- System events
+- Error logs with context
+- Operational information
+
+<Warning>
+Exported data is already anonymous and doesn't include code content, file paths, or sensitive information. However, you're responsible for securing the data once exported to your systems.
+</Warning>
+
+## Limitations
+
+Current OpenTelemetry support in Cline:
+- ✅ OTLP metrics export (gRPC, HTTP)
+- ✅ OTLP logs export (gRPC, HTTP)
+- ✅ Basic configuration via [Remote Configuration](/enterprise-solutions/configuration/remote-configuration/overview#how-remote-configuration-works)
+- ❌ Distributed tracing (not yet implemented)
+- ❌ Custom instrumentation API (not yet exposed)
+- ❌ Sampling configuration (uses defaults)
+
+## Best Practices
+
+1. **Test First**: Always test with console exporter before sending to production
+2. **Secure Credentials**: Never hardcode API keys; use secure environment variable management
+3. **Monitor Costs**: Be aware of data ingestion costs with your observability platform
+4. **Start Simple**: Begin with metrics only, add logs if needed
+5. **Use Compression**: OTLP supports compression; check if your endpoint requires it
+
+## Next Steps
+
+<CardGroup cols={3}>
+  <Card title="Event Reference" icon="list" href="/enterprise-solutions/monitoring/opentelemetry-events">
+    Complete catalog of all emitted OTel events
+  </Card>
+  
+  <Card title="Cline Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
+    Configure simple built-in telemetry
+  </Card>
+  
+  <Card title="OpenTelemetry Docs" icon="book" href="https://opentelemetry.io/docs/">
+    Learn more about OpenTelemetry
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/monitoring/opentelemetry_override.mdx b/docs/enterprise-solutions/monitoring/opentelemetry_override.mdx
new file mode 100644
index 0000000..976b10c
--- /dev/null
+++ b/docs/enterprise-solutions/monitoring/opentelemetry_override.mdx
@@ -0,0 +1,155 @@
+---
+title: "OpenTelemetry Environment Variables"
+sidebarTitle: "OpenTelemetry Override"
+description: "Configure OpenTelemetry using environment variables for advanced scenarios"
+---
+
+<Note>
+This is an **advanced configuration method**. Most users should use [Remote Configuration](/enterprise-solutions/monitoring/opentelemetry) via the dashboard instead.
+</Note>
+
+Environment variables provide an alternative way to configure OpenTelemetry, useful for self-hosted deployments, local development, CI/CD pipelines, or when you need to override organization settings.
+
+## When to Use
+
+- **Self-hosted deployments** without dashboard access
+- **Local development and testing** with your own collectors
+- **CI/CD pipelines** that need observability
+- **Override organization settings** with user-specific configuration
+
+<Warning>
+Environment variable configuration bypasses user telemetry settings and will export data regardless of individual preferences.
+</Warning>
+
+## Environment Variables
+
+### Core Configuration
+
+| Variable | Description | Values |
+|----------|-------------|--------|
+| `CLINE_OTEL_TELEMETRY_ENABLED` | Enable OpenTelemetry export | `"true"` or `"false"` |
+| `CLINE_OTEL_METRICS_EXPORTER` | Metrics exporters (comma-separated) | `"console"`, `"otlp"` |
+| `CLINE_OTEL_LOGS_EXPORTER` | Logs exporters (comma-separated) | `"console"`, `"otlp"` |
+
+### OTLP Configuration
+
+| Variable | Description | Values |
+|----------|-------------|--------|
+| `CLINE_OTEL_EXPORTER_OTLP_PROTOCOL` | OTLP protocol | `"grpc"`, `"http/json"`, or `"http/protobuf"` |
+| `CLINE_OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP collector endpoint (applies to both metrics and logs) | URL with optional port |
+| `CLINE_OTEL_EXPORTER_OTLP_HEADERS` | Authentication headers (comma-separated `key=value` pairs) | `"key=value,key2=value2"` |
+| `CLINE_OTEL_EXPORTER_OTLP_INSECURE` | Disable TLS for gRPC (local development only) | `"true"` |
+
+### Advanced OTLP Configuration
+
+For separate metrics and logs endpoints:
+
+| Variable | Description |
+|----------|-------------|
+| `CLINE_OTEL_EXPORTER_OTLP_METRICS_PROTOCOL` | Metrics-specific protocol override |
+| `CLINE_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` | Metrics-specific endpoint |
+| `CLINE_OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` | Logs-specific protocol override |
+| `CLINE_OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` | Logs-specific endpoint |
+
+### Export Tuning
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `CLINE_OTEL_METRIC_EXPORT_INTERVAL` | Milliseconds between metric exports | 60000 |
+| `CLINE_OTEL_LOG_BATCH_SIZE` | Maximum batch size for log records | 512 |
+| `CLINE_OTEL_LOG_BATCH_TIMEOUT` | Maximum time before exporting logs (ms) | 5000 |
+| `CLINE_OTEL_LOG_MAX_QUEUE_SIZE` | Maximum queue size for log records | 2048 |
+
+## Quick Start Examples
+
+### Datadog with gRPC
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=otlp
+export CLINE_OTEL_LOGS_EXPORTER=otlp
+export CLINE_OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+export CLINE_OTEL_EXPORTER_OTLP_ENDPOINT=https://api.datadoghq.com:4317
+export CLINE_OTEL_EXPORTER_OTLP_HEADERS="dd-api-key=YOUR_API_KEY"
+
+code .
+```
+
+<Note>
+The endpoint shown above is for Datadog's **US1 region**. If you're in a different region (EU, US3, US5, AP1, etc.), replace `api.datadoghq.com` with your region-specific hostname (e.g., `api.datadoghq.eu` for EU). See [Datadog's OTLP documentation](https://docs.datadoghq.com/opentelemetry/) for your region's endpoint.
+</Note>
+
+### New Relic with HTTP
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=otlp
+export CLINE_OTEL_LOGS_EXPORTER=otlp
+export CLINE_OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
+export CLINE_OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net:4318
+export CLINE_OTEL_EXPORTER_OTLP_HEADERS="api-key=YOUR_LICENSE_KEY"
+
+code .
+```
+
+### Local Development (Insecure)
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=otlp
+export CLINE_OTEL_LOGS_EXPORTER=otlp
+export CLINE_OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+export CLINE_OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
+export CLINE_OTEL_EXPORTER_OTLP_INSECURE=true
+
+code .
+```
+
+### Console Output (Testing)
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=console
+export CLINE_OTEL_LOGS_EXPORTER=console
+
+code .
+```
+
+## Debugging
+
+Enable detailed OpenTelemetry diagnostic logging:
+
+```bash
+export TEL_DEBUG_DIAGNOSTICS=true
+code .
+```
+
+This outputs:
+- Configuration being used
+- Exporters being created
+- Connection attempts
+- Export successes/failures
+
+Check the VS Code Developer Tools Console (Help > Toggle Developer Tools) for diagnostic output.
+
+## Configuration Priority
+
+When multiple configuration methods are present, Cline uses this priority order:
+
+1. **Environment variables** (highest priority) - This method
+2. **Remote Configuration** - Dashboard settings
+3. **Default settings** - Built-in defaults
+
+Environment variable configuration will override dashboard settings.
+
+## See Also
+
+<CardGroup cols={2}>
+  <Card title="Dashboard Configuration" icon="globe" href="/enterprise-solutions/monitoring/opentelemetry">
+    Configure OpenTelemetry via the web dashboard
+  </Card>
+  
+  <Card title="Remote Configuration" icon="server" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    Learn about Remote Configuration system
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/monitoring/overview.mdx b/docs/enterprise-solutions/monitoring/overview.mdx
new file mode 100644
index 0000000..0ad5329
--- /dev/null
+++ b/docs/enterprise-solutions/monitoring/overview.mdx
@@ -0,0 +1,119 @@
+---
+title: "Enterprise Monitoring"
+sidebarTitle: "Overview"
+description: "Optional telemetry and observability for your Cline deployment"
+---
+
+Cline includes optional monitoring capabilities for organizations that want to track usage and integrate with their observability infrastructure.
+
+## Monitoring Options
+
+<CardGroup cols={2}> 
+  <Card title="Cline Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
+    Built-in anonymous usage tracking that helps improve Cline (opt-in)
+  </Card>
+
+  <Card title="Prompt Storage" icon="database" href="/enterprise-solutions/monitoring/prompt-storage">
+    Backup conversation history to S3/R2 for compliance and analysis
+  </Card>
+
+  <Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Export metrics and logs to your own observability backends
+  </Card>
+
+  <Card title="OpenTelemetry Override" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry_override">
+    Export to your own observability backends through environment variables (advanced)
+  </Card>
+</CardGroup>
+
+## Cline Telemetry
+
+Cline includes opt-in telemetry for anonymous usage tracking:
+
+- Feature usage patterns
+- Task completion rates  
+- Error occurrences
+- Performance metrics
+
+Users can enable or disable telemetry in Cline settings. All data is anonymous and does not include code content, file paths, or sensitive information.
+
+See [Cline Telemetry](/enterprise-solutions/monitoring/telemetry) for configuration details.
+
+## OpenTelemetry Integration
+
+For advanced monitoring needs, Cline supports OpenTelemetry's OTLP (OpenTelemetry Protocol) for exporting metrics and logs to your own infrastructure.
+
+This allows you to:
+- Export telemetry to your existing observability platforms
+- Integrate with tools like Datadog, New Relic, or Grafana Cloud
+- Maintain full control over your monitoring data
+- Aggregate metrics across your organization
+
+<Note>
+OpenTelemetry integration is **optional** and requires additional configuration. Most users don't need this feature.
+</Note>
+
+See [OpenTelemetry](/enterprise-solutions/monitoring/opentelemetry) for setup instructions.
+
+## Use Cases
+
+### When to Use Cline Telemetry
+- You want to help improve Cline through anonymous usage data
+- No additional setup required
+- Suitable for most users
+
+### When to Use OpenTelemetry
+- You need granular metrics in your own systems
+- You're integrating with existing observability infrastructure
+- You want detailed logs and metrics for debugging
+- You need custom dashboards or alerting
+
+## Getting Started
+
+<Steps>
+<Step title="Choose Your Approach">
+Decide whether basic telemetry or OpenTelemetry integration fits your needs
+</Step>
+
+<Step title="Enable Telemetry">
+For basic telemetry, enable it in Cline settings. For OpenTelemetry, see the configuration guide.
+</Step>
+
+<Step title="Verify Data Collection">
+Confirm telemetry is being collected as expected
+</Step>
+</Steps>
+
+## Privacy & Security
+
+All Cline monitoring features are designed with privacy in mind:
+
+<CardGroup cols={2}>
+  <Card title="Anonymous" icon="user-secret">
+    No personal information collected
+  </Card>
+  
+  <Card title="Optional" icon="toggle-on">
+    Users can disable at any time
+  </Card>
+  
+  <Card title="Local First" icon="laptop">
+    Code never leaves your machine
+  </Card>
+  
+  <Card title="Transparent" icon="code">
+    Open source - see what's collected
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Configure Telemetry" icon="gear" href="/enterprise-solutions/monitoring/telemetry">
+    Set up basic telemetry settings
+  </Card>
+  
+  <Card title="OpenTelemetry Setup" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Advanced monitoring with OpenTelemetry
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/monitoring/prompt-storage.mdx b/docs/enterprise-solutions/monitoring/prompt-storage.mdx
new file mode 100644
index 0000000..9780ae2
--- /dev/null
+++ b/docs/enterprise-solutions/monitoring/prompt-storage.mdx
@@ -0,0 +1,666 @@
+---
+title: "Prompt Storage"
+description: "Backup conversation history to S3 or Cloudflare R2 for compliance, audit, and analysis"
+---
+
+Prompt Storage allows enterprises to automatically back up Cline conversation history to cloud storage (AWS S3 or Cloudflare R2). This provides a centralized repository for compliance, audit trails, and usage analysis while maintaining local storage as the primary source of truth.
+
+## Overview
+
+Every Cline task conversation is stored locally in `~/.cline/data/tasks/<taskId>/api_conversation_history.json`. When prompt storage is enabled, a background sync worker automatically uploads these conversation files to your configured S3 or R2 bucket.
+
+<CardGroup cols={2}>
+  <Card title="Compliance Ready" icon="shield-check">
+    Maintain conversation records for regulatory requirements and internal policies.
+  </Card>
+  
+  <Card title="Audit Trail" icon="scroll">
+    Track AI interactions across your organization with timestamped conversation logs.
+  </Card>
+  
+  <Card title="Usage Analysis" icon="chart-line">
+    Analyze conversation patterns, token usage, and model performance at scale.
+  </Card>
+  
+  <Card title="Disaster Recovery" icon="cloud-arrow-up">
+    Backup conversation history independent of local storage for business continuity.
+  </Card>
+</CardGroup>
+
+## How It Works
+
+```mermaid
+graph LR
+    A[User] --> B[Cline Extension]
+    B --> C[Local Storage<br/>~/.cline/data/tasks/]
+    C --> D[Background Sync Worker]
+    D --> E[S3/R2 Bucket]
+    E --> F[Compliance/Analytics]
+```
+
+1. **Local Storage First**: All conversations are written to local disk immediately
+2. **Background Sync**: A worker process queues conversation files for upload
+3. **Reliable Upload**: Automatic retry logic with configurable batch sizes
+4. **Cloud Backup**: Files are stored in your S3/R2 bucket with the same path structure
+
+## Storage Architecture
+
+### What Gets Stored
+
+Prompt storage uploads the following files from each task:
+
+| File | Content | Purpose |
+|------|---------|---------|
+| `api_conversation_history.json` | Full conversation in Anthropic MessageParam format | Core conversation data for analysis |
+| Task metadata | Task ID, timestamps, model info | Correlation and indexing |
+
+### What's NOT Stored
+
+Prompt storage **does not** include:
+
+- ❌ Workspace files not accessed by Cline
+- ❌ API keys or secrets  
+- ❌ User credentials or authentication tokens
+
+<Warning>
+Conversation history includes **all tool inputs and outputs**. This means code written via `write_to_file`, file contents read via `read_file`, and command outputs are included in the uploaded data. Review your compliance and data classification requirements before enabling.
+</Warning>
+
+### Storage Path Pattern
+
+Files are uploaded to your bucket following this structure:
+
+```
+s3://your-bucket/tasks/{taskId}/api_conversation_history.json
+```
+
+This mirrors the local storage structure, making it easy to correlate local and cloud data.
+
+## Configuration
+
+Prompt storage is configured through Remote Configuration in the `enterpriseTelemetry.promptUploading` section.
+
+### Schema
+
+```json
+{
+  "enterpriseTelemetry": {
+    "promptUploading": {
+      "enabled": true,
+      "type": "s3_access_keys",
+      "s3AccessSettings": {
+        "bucket": "your-cline-prompts",
+        "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
+        "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+        "region": "us-east-1",
+        "intervalMs": 30000,
+        "maxRetries": 5,
+        "batchSize": 10,
+        "maxQueueSize": 1000,
+        "maxFailedAgeMs": 604800000,
+        "backfillEnabled": false
+      }
+    }
+  }
+}
+```
+
+### Configuration Fields
+
+#### Core Settings
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `enabled` | boolean | Yes | Enable/disable prompt storage |
+| `type` | string | Yes | Storage type: `"s3_access_keys"` or `"r2_access_keys"` |
+
+#### Access Settings (S3/R2)
+
+| Field | Type | Required | Description | Default |
+|-------|------|----------|-------------|---------|
+| `bucket` | string | Yes | S3/R2 bucket name | - |
+| `accessKeyId` | string | Yes | AWS/Cloudflare access key ID | - |
+| `secretAccessKey` | string | Yes | AWS/Cloudflare secret access key | - |
+| `region` | string | S3 only | AWS region (e.g., `us-east-1`) | - |
+| `endpoint` | string | R2 only | Cloudflare R2 endpoint URL | - |
+| `accountId` | string | R2 only | Cloudflare account ID | - |
+
+#### Sync Worker Settings
+
+| Field | Type | Description | Default |
+|-------|------|-------------|---------|
+| `intervalMs` | number | Milliseconds between sync attempts | 30000 (30s) |
+| `maxRetries` | number | Maximum retries before giving up | 5 |
+| `batchSize` | number | Items to process per interval | 10 |
+| `maxQueueSize` | number | Maximum queue size before eviction | 1000 |
+| `maxFailedAgeMs` | number | Time before discarding failed items | 604800000 (7 days) |
+| `backfillEnabled` | boolean | Sync existing tasks on startup | false |
+
+## Setup Guides
+
+<Tabs>
+  <Tab title="AWS S3">
+    ### AWS S3 Configuration
+
+    <Steps>
+      <Step title="Create S3 Bucket">
+        Create a dedicated S3 bucket for Cline conversation storage:
+        
+        ```bash
+        aws s3 mb s3://your-cline-prompts --region us-east-1
+        ```
+        
+        Enable versioning and encryption:
+        
+        ```bash
+        aws s3api put-bucket-versioning \
+          --bucket your-cline-prompts \
+          --versioning-configuration Status=Enabled
+        
+        aws s3api put-bucket-encryption \
+          --bucket your-cline-prompts \
+          --server-side-encryption-configuration '{
+            "Rules": [{
+              "ApplyServerSideEncryptionByDefault": {
+                "SSEAlgorithm": "AES256"
+              }
+            }]
+          }'
+        ```
+      </Step>
+
+      <Step title="Create IAM Policy">
+        Create an IAM policy with minimal required permissions:
+        
+        ```json
+        {
+          "Version": "2012-10-17",
+          "Statement": [
+            {
+              "Effect": "Allow",
+              "Action": [
+                "s3:PutObject",
+                "s3:PutObjectAcl",
+                "s3:GetObject",
+                "s3:DeleteObject"
+              ],
+              "Resource": "arn:aws:s3:::your-cline-prompts/*"
+            },
+            {
+              "Effect": "Allow",
+              "Action": [
+                "s3:ListBucket"
+              ],
+              "Resource": "arn:aws:s3:::your-cline-prompts"
+            }
+          ]
+        }
+        ```
+        
+        Save this as `cline-prompt-storage-policy.json` and create the policy:
+        
+        ```bash
+        aws iam create-policy \
+          --policy-name ClinePromptStorage \
+          --policy-document file://cline-prompt-storage-policy.json
+        ```
+      </Step>
+
+      <Step title="Create IAM User">
+        Create a dedicated IAM user and attach the policy:
+        
+        ```bash
+        aws iam create-user --user-name cline-prompt-uploader
+        
+        aws iam attach-user-policy \
+          --user-name cline-prompt-uploader \
+          --policy-arn arn:aws:iam::YOUR_ACCOUNT_ID:policy/ClinePromptStorage
+        
+        aws iam create-access-key --user-name cline-prompt-uploader
+        ```
+        
+        Save the `AccessKeyId` and `SecretAccessKey` from the output.
+      </Step>
+
+      <Step title="Configure in Cline Dashboard">
+        In the Cline admin console at [app.cline.bot](https://app.cline.bot):
+        
+        1. Navigate to **Settings** → **Enterprise Telemetry**
+        2. Enable **Prompt Uploading**
+        3. Select **S3** as the storage type
+        4. Enter your bucket name, access key ID, secret key, and region
+        5. Configure sync worker settings (or use defaults)
+        6. Save configuration
+      </Step>
+
+      <Step title="Test Connection">
+        Use the "Test Connection" button in the admin console to verify:
+        - Bucket access
+        - Write permissions
+        - Credential validity
+        
+        A test file will be uploaded and deleted from your bucket.
+      </Step>
+    </Steps>
+
+    ### Optional: Lifecycle Policies
+
+    Configure retention policies for cost management:
+
+    ```json
+    {
+      "Rules": [
+        {
+          "Id": "ArchiveOldPrompts",
+          "Status": "Enabled",
+          "Transitions": [
+            {
+              "Days": 90,
+              "StorageClass": "GLACIER"
+            }
+          ]
+        },
+        {
+          "Id": "DeleteOldPrompts",
+          "Status": "Enabled",
+          "Expiration": {
+            "Days": 2555
+          }
+        }
+      ]
+    }
+    ```
+  </Tab>
+
+  <Tab title="Cloudflare R2">
+    ### Cloudflare R2 Configuration
+
+    <Steps>
+      <Step title="Create R2 Bucket">
+        1. Log in to the [Cloudflare Dashboard](https://dash.cloudflare.com)
+        2. Navigate to **R2** in the sidebar
+        3. Click **Create bucket**
+        4. Name your bucket (e.g., `cline-prompts`)
+        5. Select a location close to your users
+        6. Click **Create bucket**
+      </Step>
+
+      <Step title="Generate API Token">
+        1. In the R2 dashboard, click **Manage R2 API Tokens**
+        2. Click **Create API token**
+        3. Configure permissions:
+           - **Token name**: Cline Prompt Storage
+           - **Permissions**: Object Read & Write
+           - **Bucket**: Select your bucket or use All buckets
+        4. Click **Create API Token**
+        5. Save the **Access Key ID** and **Secret Access Key**
+        6. Note your **Account ID** (shown in the R2 overview)
+      </Step>
+
+      <Step title="Get R2 Endpoint">
+        Your R2 endpoint follows this format:
+        
+        ```
+        https://<ACCOUNT_ID>.r2.cloudflarestorage.com
+        ```
+        
+        Find your account ID in the Cloudflare dashboard under R2 overview.
+      </Step>
+
+      <Step title="Configure in Cline Dashboard">
+        In the Cline admin console at [app.cline.bot](https://app.cline.bot):
+        
+        1. Navigate to **Settings** → **Enterprise Telemetry**
+        2. Enable **Prompt Uploading**
+        3. Select **R2** as the storage type
+        4. Enter:
+           - Bucket name
+           - Access key ID
+           - Secret access key
+           - Account ID
+           - Endpoint URL
+        5. Configure sync worker settings (or use defaults)
+        6. Save configuration
+      </Step>
+
+      <Step title="Test Connection">
+        Use the "Test Connection" button to verify:
+        - Bucket access with provided credentials
+        - Write permissions
+        - Endpoint connectivity
+      </Step>
+    </Steps>
+
+    ### Cost Advantages
+
+    R2 offers significant cost advantages over S3:
+    - **No egress fees**: Download data at no cost
+    - **Lower storage costs**: ~$0.015/GB vs S3's ~$0.023/GB
+    - **Global edge access**: Fast access from anywhere
+  </Tab>
+</Tabs>
+
+## Sync Worker Behavior
+
+The background sync worker manages the upload queue with these characteristics:
+
+### Queue Management
+
+- **FIFO ordering**: Files are uploaded in the order they were created
+- **Automatic batching**: Processes up to `batchSize` items per interval
+- **Queue size limits**: Evicts oldest items when `maxQueueSize` is exceeded
+- **Retry logic**: Failed uploads are retried up to `maxRetries` times
+
+### Failure Handling
+
+When an upload fails:
+
+1. **Immediate retry**: Item stays in queue for next sync interval
+2. **Exponential backoff**: Retry attempts are spaced out
+3. **Maximum retries**: After `maxRetries` attempts, item is marked as permanently failed
+4. **Age-based cleanup**: Failed items older than `maxFailedAgeMs` are discarded
+5. **No data loss**: Local files remain intact regardless of sync status
+
+### Backfill Mode
+
+When `backfillEnabled` is set to `true`:
+
+- On first startup, scans all existing tasks in `~/.cline/data/tasks/`
+- Queues conversation files that haven't been uploaded
+- Useful for enabling prompt storage on an existing Cline deployment
+- Can generate significant upload volume — monitor queue size
+
+<Warning>
+Enable backfill carefully on large deployments. Consider starting with `backfillEnabled: false` and monitoring the steady-state queue before enabling backfill.
+</Warning>
+
+## Monitoring & Observability
+
+### Integration with OpenTelemetry
+
+While prompt storage operates independently, it integrates with Cline's observability system:
+
+- **Task lifecycle events**: `task.created`, `task.completed` track when conversations are generated
+- **Conversation events**: `task.conversation_turn`, `task.tokens` provide usage metrics
+- **Local monitoring**: Sync worker status is logged but not yet exported as OTel events
+
+See [OpenTelemetry](/enterprise-solutions/monitoring/opentelemetry) for configuring metrics export.
+
+### CloudWatch Monitoring (S3)
+
+Monitor S3 upload activity with CloudWatch:
+
+```bash
+# View PutObject requests (uploads)
+aws cloudwatch get-metric-statistics \
+  --namespace AWS/S3 \
+  --metric-name NumberOfObjects \
+  --dimensions Name=BucketName,Value=your-cline-prompts \
+  --start-time 2026-03-01T00:00:00Z \
+  --end-time 2026-03-08T00:00:00Z \
+  --period 3600 \
+  --statistics Sum
+```
+
+### R2 Analytics
+
+Cloudflare R2 provides built-in analytics in the dashboard:
+
+- Request counts and rates
+- Storage usage over time
+- Bandwidth utilization
+- Error rates
+
+## Security & Compliance
+
+### Encryption
+
+**At Rest:**
+- S3: Enable server-side encryption (SSE-S3 or SSE-KMS)
+- R2: Encryption enabled by default
+
+**In Transit:**
+- All uploads use HTTPS/TLS
+- Credentials are never logged or exposed
+
+### Access Control
+
+**Recommended IAM policies:**
+
+- Use dedicated IAM users/roles
+- Limit permissions to write-only if read access isn't needed
+- Enable MFA for credential generation
+- Rotate access keys regularly
+
+**Bucket policies:**
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Deny",
+      "Principal": "*",
+      "Action": "s3:*",
+      "Resource": [
+        "arn:aws:s3:::your-cline-prompts/*",
+        "arn:aws:s3:::your-cline-prompts"
+      ],
+      "Condition": {
+        "Bool": {
+          "aws:SecureTransport": "false"
+        }
+      }
+    }
+  ]
+}
+```
+
+### Audit Logging
+
+**S3 Server Access Logging:**
+
+```bash
+aws s3api put-bucket-logging \
+  --bucket your-cline-prompts \
+  --bucket-logging-status '{
+    "LoggingEnabled": {
+      "TargetBucket": "your-log-bucket",
+      "TargetPrefix": "cline-prompts-access/"
+    }
+  }'
+```
+
+**CloudTrail for API Calls:**
+
+Enable CloudTrail to track all S3 API operations on your bucket.
+
+### Data Retention
+
+Implement retention policies based on your compliance requirements:
+
+- **GDPR**: Consider right to erasure
+- **SOC 2**: Maintain audit trails for required period
+- **HIPAA**: Ensure appropriate retention and disposal
+
+## Troubleshooting
+
+### Common Issues
+
+<AccordionGroup>
+  <Accordion title="Queue size growing continuously">
+    **Symptoms**: `maxQueueSize` limit reached, oldest items being evicted
+    
+    **Causes**:
+    - Upload rate slower than conversation creation rate
+    - Network connectivity issues
+    - Insufficient batch size or interval
+    
+    **Solutions**:
+    1. Increase `batchSize` to process more items per interval
+    2. Decrease `intervalMs` to sync more frequently
+    3. Check network connectivity and credentials
+    4. Temporarily increase `maxQueueSize` while investigating
+  </Accordion>
+
+  <Accordion title="Uploads failing with 403 Forbidden">
+    **Symptoms**: Repeated upload failures, items reaching `maxRetries`
+    
+    **Causes**:
+    - Invalid or expired credentials
+    - Insufficient IAM permissions
+    - Bucket policy denying access
+    
+    **Solutions**:
+    1. Verify credentials are correct in remote config
+    2. Check IAM policy includes `s3:PutObject` permission
+    3. Review bucket policies for deny rules
+    4. Test with AWS CLI: `aws s3 cp test.txt s3://your-bucket/`
+  </Accordion>
+
+  <Accordion title="R2 endpoint connection timeout">
+    **Symptoms**: Connection timeouts, failed uploads
+    
+    **Causes**:
+    - Incorrect endpoint URL
+    - Firewall blocking Cloudflare IPs
+    - Invalid account ID
+    
+    **Solutions**:
+    1. Verify endpoint format: `https://<ACCOUNT_ID>.r2.cloudflarestorage.com`
+    2. Check firewall rules allow HTTPS to Cloudflare IPs
+    3. Confirm account ID in Cloudflare dashboard
+    4. Test with curl: `curl -I https://<ACCOUNT_ID>.r2.cloudflarestorage.com`
+  </Accordion>
+
+  <Accordion title="Backfill overwhelming upload queue">
+    **Symptoms**: Queue at max size immediately after enabling backfill
+    
+    **Causes**:
+    - Large number of existing tasks
+    - Backfill queuing faster than upload processing
+    
+    **Solutions**:
+    1. Disable backfill temporarily: `"backfillEnabled": false`
+    2. Let steady-state queue drain first
+    3. Increase `batchSize` and decrease `intervalMs`
+    4. Consider `maxQueueSize` increase during backfill period
+    5. Re-enable backfill once queue is stable
+  </Accordion>
+</AccordionGroup>
+
+### Debug Logging
+
+Enable debug logging to diagnose sync issues:
+
+1. Check extension developer console (Help → Toggle Developer Tools)
+2. Look for `[ClineBlobStorage]` and `[SyncWorker]` log entries
+3. Failed uploads log error messages with details
+
+### Testing Configuration
+
+Use the built-in test connection feature:
+
+```typescript
+// Programmatic test (for custom integrations)
+import { testPromptUploading } from '@/core/controller/state/testPromptUploading'
+
+await testPromptUploading(controller)
+// Returns: { success: boolean, message: string }
+```
+
+## Data Format Reference
+
+### Conversation File Schema
+
+Uploaded `api_conversation_history.json` files contain an array of messages:
+
+```json
+[
+  {
+    "role": "user",
+    "content": [
+      {
+        "type": "text",
+        "text": "Create a React component for a todo list"
+      }
+    ]
+  },
+  {
+    "role": "assistant",
+    "content": [
+      {
+        "type": "text",
+        "text": "I'll create a todo list component..."
+      },
+      {
+        "type": "tool_use",
+        "id": "toolu_123",
+        "name": "write_to_file",
+        "input": {
+          "path": "TodoList.tsx",
+          "content": "..."
+        }
+      }
+    ]
+  }
+]
+```
+
+This follows the [Anthropic Messages API format](https://docs.anthropic.com/claude/reference/messages_post).
+
+### Metadata Schema
+
+Task metadata includes:
+
+```json
+{
+  "taskId": "1234567890",
+  "createdAt": "2026-03-05T10:30:00Z",
+  "lastModified": "2026-03-05T11:45:00Z",
+  "modelInfo": {
+    "id": "claude-sonnet-4",
+    "provider": "anthropic"
+  },
+  "tokensUsed": {
+    "input": 1250,
+    "output": 3400
+  }
+}
+```
+
+## Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Start Small" icon="seedling">
+    Test with a single team or project before rolling out organization-wide.
+  </Card>
+  
+  <Card title="Monitor Costs" icon="dollar-sign">
+    Set up billing alerts and review storage usage monthly.
+  </Card>
+  
+  <Card title="Secure Credentials" icon="lock">
+    Use dedicated IAM users with minimal permissions and rotate keys regularly.
+  </Card>
+  
+  <Card title="Plan Retention" icon="calendar">
+    Define and implement data retention policies based on compliance needs.
+  </Card>
+</CardGroup>
+
+## See Also
+
+<CardGroup cols={3}>
+  <Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Configure metrics and logs export for comprehensive observability
+  </Card>
+  
+  <Card title="Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
+    Learn about Cline's built-in anonymous usage tracking
+  </Card>
+  
+  <Card title="Remote Configuration" icon="gear" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    Understand the remote configuration system
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/monitoring/telemetry.mdx b/docs/enterprise-solutions/monitoring/telemetry.mdx
new file mode 100644
index 0000000..1f3a658
--- /dev/null
+++ b/docs/enterprise-solutions/monitoring/telemetry.mdx
@@ -0,0 +1,144 @@
+---
+title: "Cline Telemetry"
+sidebarTitle: "Cline Telemetry"
+description: "Configure usage analytics and event tracking"
+---
+
+Cline includes telemetry to help understand usage patterns and improve the product. Users can control whether to share this data.
+
+## What is Cline Telemetry?
+
+Telemetry captures anonymous usage events such as:
+
+- Features used (which tools and commands)
+- Task completion rates
+- Error occurrences
+- Performance metrics
+
+<Info>
+All telemetry data is **anonymous** and does not include code content, file contents, or other sensitive information.
+</Info>
+
+## User Controls
+
+### Enabling/Disabling Cline Telemetry
+
+Individual users can control telemetry through Cline settings:
+
+1. Open Cline settings
+2. Find "Cline Telemetry" toggle
+3. Enable or disable as preferred
+
+Changes take effect immediately.
+
+### What Gets Collected
+
+When telemetry is enabled, Cline captures:
+
+<AccordionGroup>
+  <Accordion title="Feature Usage" icon="cursor-click">
+    - Tools executed (e.g., read_file, execute_command)
+    - Slash commands used
+    - Skills triggered
+    - Settings changed
+  </Accordion>
+  
+  <Accordion title="Task Metrics" icon="tasks">
+    - Task started/completed events
+    - Mode switches (Plan/Act)
+    - Checkpoint usage
+    - Task duration
+  </Accordion>
+  
+  <Accordion title="Error Events" icon="triangle-exclamation">
+    - API failures
+    - Tool execution errors
+    - System errors
+    - Error types and frequencies
+  </Accordion>
+</AccordionGroup>
+
+### What Doesn't Get Collected
+
+Cline Telemetry **never** includes:
+
+- Your code or file contents
+- File paths or names
+- Command arguments or parameters
+- Conversation content
+- Personal information
+- API keys or credentials
+
+## Enterprise Configuration
+
+Administrators can set default telemetry state through remote configuration:
+
+```json
+{
+  "telemetryEnabled": true
+}
+```
+
+<Note>
+Even with enterprise configuration, individual users can still disable Cline Telemetry in their local settings.
+</Note>
+
+## Enterprise Monitoring Features
+
+For organizations with additional compliance or monitoring requirements, Cline provides:
+
+### Prompt Storage
+Automatically backup conversation history to AWS S3 or Cloudflare R2 for:
+- Compliance and audit trails
+- Usage analysis and reporting
+- Disaster recovery
+
+See [Prompt Storage](/enterprise-solutions/monitoring/prompt-storage) for configuration details.
+
+### OpenTelemetry Integration
+Export detailed metrics and logs to your own observability platforms like Datadog, New Relic, or Grafana Cloud.
+
+See [OpenTelemetry](/enterprise-solutions/monitoring/opentelemetry) for setup instructions.
+
+## Privacy
+
+Cline's telemetry is designed with privacy in mind:
+
+<CardGroup cols={2}>
+  <Card title="Anonymous" icon="user-secret">
+    No personal information is collected
+  </Card>
+  
+  <Card title="Optional" icon="toggle-on">
+    Users can disable at any time
+  </Card>
+  
+  <Card title="Local First" icon="laptop">
+    Code never leaves your machine
+  </Card>
+  
+  <Card title="Transparent" icon="eye">
+    Open source - see exactly what's collected
+  </Card>
+</CardGroup>
+
+## Why Telemetry Matters
+
+Anonymous usage data helps:
+
+- **Identify bugs**: Discover issues affecting users
+- **Prioritize features**: Focus on most-used capabilities
+- **Improve performance**: Find and fix slow operations
+- **Enhance reliability**: Track and reduce error rates
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Enterprise monitoring and observability
+  </Card>
+  
+  <Card title="Event Details" icon="shield" href="/enterprise-solutions/monitoring/opentelemetry-events">
+    See what data is collected
+  </Card>
+</CardGroup>
diff --git a/docs/enterprise-solutions/onboarding.mdx b/docs/enterprise-solutions/onboarding.mdx
new file mode 100644
index 0000000..1c39f4d
--- /dev/null
+++ b/docs/enterprise-solutions/onboarding.mdx
@@ -0,0 +1,132 @@
+---
+title: "Onboarding"
+
+description: "This guide explains how administrators configure SSO provisioning and user management in Cline Enterprise."
+---
+
+## Overview
+Cline Enterprise integrates with your existing identity provider (IdP) via WorkOS to deliver secure SSO and zero-touch user lifecycle management. In this guide, you'll connect your IdP (Okta, Azure AD, Google Workspace, or any SAML/OIDC provider), enable just-in-time (JIT) provisioning so new users are created automatically on first sign-in, and configure role mapping so permissions stay aligned with your directory-no manual invites or seat reconciliations required.
+
+
+## Prerequisites
+
+- [Cline Enterprise License](https://cline.bot/contact-sales)
+- Access to your identity provider (IdP) configuration (e.g., Okta, Azure AD, Google Workspace)
+- Knowledge of your organization's SSO requirements
+
+## Configuration Steps
+
+### Step 1: Onboard to Cline Enterprise license
+
+Your IdP administrator will receive an email with a link to register their organization with WorkOS during onboarding.
+
+### Step 2: Configure Your Identity Provider
+
+<Info>
+For a short overview of where SSO configuration lives (Cline dashboard vs WorkOS vs your IdP), see [SSO Setup](/enterprise-solutions/sso-setup).
+</Info>
+
+Connect your identity provider (IdP) to WorkOS:
+
+1. In the WorkOS dashboard, go to **AuthKit → Connections**
+2. Click **Add Connection**
+3. Select your identity provider (e.g., Okta, Azure AD, Google Workspace, Generic SAML/OIDC)
+4. Follow the provider-specific setup instructions
+
+Each identity provider (IdP) will have its own setup process and required fields. Be sure to follow the specific instructions in the WorkOS dashboard for your chosen provider.
+For more explicit instruction on connecting your IdP, refer to the [WorkOS SSO documentation](https://workos.com/docs/authkit/sso)
+
+### Step 3: Configure User Provisioning
+
+Cline Enterprise uses **just-in-time provisioning** that works automatically:
+
+- **Organizations are created automatically**
+- **Users gain access automatically** on their first SSO sign-in, once their credentials have been configured by the IdP administrator.
+- **Roles sync automatically** from your IdP (Admin/Owner → Admin, Member → Member)
+- **No manual user invites or seat management** required
+
+No additional configuration is needed. Users are provisioned automatically when they sign in through SSO.
+
+### Step 4: Configure User Attributes Mapping
+
+User roles are mapped automatically from your IdP:
+
+- **Admin** in IdP → **Admin** role in Cline (Note: The first Owner of the org is created manually during onboarding)
+- **Member** in IdP → **Member** role in Cline
+
+<Info>
+    For what each role can access, see the [Roles and Permissions](/enterprise-solutions/team-management/managing-members) page.
+</Info>
+
+If needed, you can configure additional user attributes in the Cline Admin console:
+
+1. Go to **Settings → Authentication → User Attributes**
+2. Map attributes such as email and name based on your IdP configuration
+
+For information about available user attributes, see the [WorkOS User Object Documentation](https://workos.com/docs/authkit/user-management).
+
+### Step 5: Test SSO Connection
+
+Before allowing users to sign in, test the SSO flow to ensure everything is configured correctly.
+
+**To test the connection:**
+
+1. In the WorkOS dashboard (or Cline Admin console if available), locate and click **Test SSO Connection**
+2. You'll be redirected to your IdP's login page
+3. Enter valid credentials for a test user
+4. After successful authentication, you should be redirected back
+5. Confirm that the user's information (name, email, role) displays correctly
+
+**Expected outcome:** The test user is authenticated, their account details are visible, and their role matches what's configured in your IdP.
+
+**If the test fails:** Double-check your IdP configuration (redirect URIs, SAML certificates, attribute mappings). See the [WorkOS SSO documentation](https://workos.com/docs/authkit/sso) for troubleshooting guidance.
+
+### User Access
+
+Once SSO is configured, users in your IdP can access Cline automatically without manual invites or account setup.
+
+**First-time sign-in flow:**
+
+1. User navigates to Cline and clicks **Sign in with SSO**
+2. User authenticates via your organization's IdP
+3. Cline automatically creates their account in your Organization
+4. Role is assigned based on their IdP role (see [Step 4](#step-4-configure-user-attributes-mapping))
+5. User is redirected to Cline and can begin working
+
+**What happens automatically:**
+- Account creation with correct organization assignment
+- Role and permission assignment
+- Basic profile information (name, email) populated from IdP
+
+**No action required:** Users don't need to request access or wait for approval. Access is granted immediately upon successful IdP authentication.
+
+### Managing Access
+
+All access management and revocation of users is currently handled by your IdP:
+
+- Add users → access granted automatically on first login
+- Change roles → updated on next login
+- Remove users → access revoked automatically
+
+<Info>
+Role changes sync automatically on the user's next sign-in.
+</Info>
+
+### Changing your IdP
+
+In order to change to a different IdP, please contact support and we will guide you through this process.
+
+---
+
+## Verification
+
+Steps to verify successful configuration:
+
+1. **Test User Sign-In**: Have a test user sign in through the SSO flow (access is granted automatically on first login)
+2. **Verify User Provisioning**: Confirm that the user is automatically created and has appropriate role permissions
+3. **Check User Attributes**: Verify that user information (name, email, organization) is correctly populated
+4. **Test Role Changes**: Update a user's role in your IdP and verify it syncs on their next login
+5. **Test User Deprovisioning**: Remove a user from your IdP and verify they lose access to Cline on their next login attempt
+6. **Review Audit Logs**: Check WorkOS audit logs to ensure authentication events are being recorded
+
+---
diff --git a/docs/enterprise-solutions/overview.mdx b/docs/enterprise-solutions/overview.mdx
new file mode 100644
index 0000000..bb9da80
--- /dev/null
+++ b/docs/enterprise-solutions/overview.mdx
@@ -0,0 +1,95 @@
+---
+title: "Cline Enterprise"
+sidebarTitle: "Overview"
+description: "Enterprise security, governance, and observability for the coding agent millions of developers trust"
+---
+
+Cline Enterprise brings centralized governance to the same open-source architecture that millions of developers already use. Your code stays in your environment, you use your own inference at your negotiated rates, and you get the security and observability capabilities that platform teams need for org-wide deployment.
+
+<Card title="Learn More About Enterprise" icon="building" href="https://cline.bot/enterprise">
+  Visit our website for detailed information about enterprise features, pricing, and deployment options.
+</Card>
+
+## What You Get
+
+It delivers five core capabilities that platform teams need for production deployment. Each addresses a specific requirement for scaling AI coding across your organization.
+
+### Security by Design
+
+Your code never leaves your environment. Cline processes everything locally - no uploads, no indexing, no training on your data.
+
+<CardGroup cols={2}>
+  <Card title="Client-side execution" icon="computer">
+    All processing happens within your environment
+  </Card>
+
+  <Card title="No data exfiltration" icon="shield-check">
+    Code and context never transmitted externally
+  </Card>
+
+  <Card title="No codebase indexing" icon="database">
+    Repositories are never indexed or cached
+  </Card>
+
+  <Card title="No model training" icon="ban">
+    Your code and prompts aren't used for training
+  </Card>
+</CardGroup>
+
+### Bring Your Own Inference
+
+Use your existing cloud contracts and negotiated rates. Most AI tools force you to buy inference through them with markup. Cline connects directly to your providers.
+
+Connect to any inference provider:
+- AWS Bedrock
+- Google Vertex AI
+- Azure OpenAI
+- Anthropic direct
+- OpenAI direct
+- Cerebras
+- Any OpenAI-compatible endpoint
+
+Switch models instantly as new ones release. Use Claude Sonnet 4.5 as your daily driver, GPT-5 for complex refactoring, open-source models for simple tasks. Your existing cloud credits and startup program contracts now cover AI coding. We handle the agent loop. You handle the inference. No markup, no vendor lock-in.
+
+### Governance at Scale
+
+Platform teams need central control when thousands of developers use AI. Individual API keys scattered across laptops create security risks and cost overruns.
+
+Enterprise governance provides:
+- **SSO authentication**: Corporate credentials instead of personal API keys
+- **Role-based access control**: Three-tier hierarchy (Member/Admin/Owner) with organization-scoped permissions
+- **Model and tool controls**: Govern which models and tools each team accesses
+- **Remote configuration**: Manage settings for all developers from one dashboard
+- **Usage tracking and observability**: OpenTelemetry integration for monitoring usage, costs, and performance with selective audit logging for administrative operations
+
+Configure once, deploy everywhere. Developers work how they prefer while you maintain control.
+
+### Complete Observability
+
+Export logs to your existing observability stack. Track usage, costs, and performance across all teams.
+
+- **OpenTelemetry export**: Direct integration with Datadog, Grafana, Splunk
+- **Real-time analytics**: Track adoption, performance, and patterns
+- **Cost breakdown**: See exactly what each team spends on which models
+- **JSON output**: Build custom dashboards in your existing tools
+
+The same observability standards you require for production systems.
+
+## Deployment
+
+Cline Enterprise connects securely to your infrastructure. Deploy in cloud environments. Configure to work with your existing security policies and compliance requirements.
+
+Rolling out to your organization:
+1. Configure Cline Core to connect to your infrastructure
+2. Set SSO, RBAC, and governance policies
+3. Deploy to developers via your existing software distribution
+4. Monitor usage through your observability tools
+
+## Next Steps
+
+- Review security architecture
+- Configure [cloud provider setup](/provider-config/aws-bedrock/api-key) (AWS Bedrock, Vertex AI, Azure)
+- Set up [MCP servers](/mcp/mcp-overview) for custom tooling
+- Add [custom instructions](/customization/cline-rules) for your codebase
+
+Schedule a walkthrough to see how Cline Enterprise fits your infrastructure. We'll work with your security and compliance requirements to deploy in your environment.
diff --git a/docs/enterprise-solutions/sso-setup.mdx b/docs/enterprise-solutions/sso-setup.mdx
new file mode 100644
index 0000000..1eac9d5
--- /dev/null
+++ b/docs/enterprise-solutions/sso-setup.mdx
@@ -0,0 +1,75 @@
+---
+title: "SSO Setup"
+sidebarTitle: "SSO Setup"
+description: "Configure Single Sign-On (SSO) for Cline Enterprise via WorkOS AuthKit."
+---
+
+## Overview
+Cline Enterprise integrates with your identity provider (IdP) via **WorkOS AuthKit** for SSO.
+
+This page describes, at a high level, how SSO is set up for Cline Enterprise using WorkOS AuthKit.
+
+If you haven't completed initial onboarding, start with [Onboarding](/enterprise-solutions/onboarding).
+
+### Video Walkthrough
+
+<Frame>
+  <iframe
+    src="https://www.youtube.com/embed/QC7mzXLjIH8"
+    title="SSO Setup with WorkOS"
+    width="100%"
+    style={{ aspectRatio: "16/9" }}
+    frameBorder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowFullScreen
+  />
+</Frame>
+
+## Where setup happens
+SSO setup spans two places:
+
+1) **Cline Dashboard (app.cline.bot)**
+- Where you sign in and verify SSO works for your organization.
+
+2) **WorkOS dashboard**
+- Where your IdP connection is configured (AuthKit → Connections). Your designated admin receives access to this during enterprise onboarding.
+
+## Using the Cline Dashboard
+Use the Cline Dashboard at https://app.cline.bot to:
+- complete sign-in and onboarding flows
+- verify users can authenticate via SSO
+
+## Configure your IdP connection in WorkOS
+
+During enterprise onboarding, your designated admin will receive an invitation email from WorkOS with a link to access your organization's WorkOS dashboard.
+
+<Frame>
+  <img src="/assets/workos-invite-email.png" alt="WorkOS invitation email example" />
+</Frame>
+
+To connect your IdP to Cline Enterprise, configure your identity provider in **WorkOS AuthKit**:
+
+1. In the WorkOS dashboard, go to **AuthKit → Connections**
+2. Click **Add Connection**
+3. Select your identity provider (e.g., Okta, Microsoft Entra ID/Azure AD, Google Workspace, Generic SAML/OIDC)
+4. Follow the provider-specific instructions in WorkOS
+
+WorkOS’s UI and required fields vary by provider. For details, follow WorkOS documentation:
+- https://workos.com/docs/authkit/sso
+
+## Keycloak note (IdP compatibility)
+Cline Enterprise’s default SSO integration is **via WorkOS**.
+
+If you use **Keycloak** as your IdP, the supported path is to configure Keycloak in WorkOS as a **Generic SAML** or **Generic OIDC** provider (using the settings WorkOS requests for those provider types).
+
+## Verification
+After configuring WorkOS:
+
+1) Attempt an SSO sign-in from https://app.cline.bot.
+2) Confirm the sign-in completes (you are redirected back successfully).
+
+## Troubleshooting
+- **Redirect URI mismatch**: confirm the redirect/callback URL configured in WorkOS matches what was provided during your Cline Enterprise onboarding.
+
+For additional troubleshooting guidance, refer to WorkOS documentation:
+- https://workos.com/docs/authkit/sso
diff --git a/docs/enterprise-solutions/team-management/managing-members.mdx b/docs/enterprise-solutions/team-management/managing-members.mdx
new file mode 100644
index 0000000..5d570bf
--- /dev/null
+++ b/docs/enterprise-solutions/team-management/managing-members.mdx
@@ -0,0 +1,316 @@
+---
+title: "Managing Members"
+sidebarTitle: "Managing Members"
+description: "Complete guide to managing team members, roles, and permissions in your Cline Enterprise organization"
+---
+
+Effective member management is essential for maintaining security and enabling your team to work productively. This guide covers everything you need to know about roles, permissions, and day-to-day member administration.
+
+## Understanding Roles
+
+Choose the right role for each team member to balance security with productivity. Here's what each role is designed for:
+
+<CardGroup cols={3}>
+  <Card title="Owner" icon="crown" color="#9D4EDD">
+    **Primary account holder**
+    
+    Unrestricted access to all settings including billing, security, and ownership transfer. Keep this limited to 1-2 key leaders.
+  </Card>
+  
+  <Card title="Admin" icon="user-gear" color="#7209B7">
+    **Team leads & IT managers**
+    
+    Can manage users and configure providers. Ideal for trusted managers who need operational control without billing access.
+  </Card>
+  
+  <Card title="Member" icon="user" color="#560BAD">
+    **Developers & contributors**
+    
+    Can use Cline with shared resources but cannot change settings. The safest default for most team members.
+  </Card>
+</CardGroup>
+
+## Permissions Matrix
+
+Understand exactly what each role can do with this comprehensive permissions breakdown:
+
+| Permission | Member | Admin | Owner |
+| :--- | :---: | :---: | :---: |
+| **General Usage** | | | |
+| Use Cline | ✅ | ✅ | ✅ |
+| Access Shared API Providers | ✅ | ✅ | ✅ |
+| | | | |
+| **Member Management** | | | |
+| View Members | ❌ | ✅ | ✅ |
+| Invite New Members | ❌ | ✅ | ✅ |
+| Edit Member Roles | ❌ | ✅ | ✅ |
+| Remove Members | ❌ | ✅ | ✅ |
+| Remove Admins | ❌ | ❌ | ✅ |
+| | | | |
+| **Configuration** | | | |
+| Configure API Providers | ❌ | ✅ | ✅ |
+| Manage Security Settings | ❌ | ❌ | ✅ |
+| | | | |
+| **Billing & Ownership** | | | |
+| View Billing Information | ❌ | ❌ | ✅ |
+| Manage Subscription | ❌ | ❌ | ✅ |
+| Transfer Ownership | ❌ | ❌ | ✅ |
+
+<Note>
+**Quick Reference:** Most users should be **Members**. Grant **Admin** only to those managing users or configs. Reserve **Owner** for 1-2 account leaders.
+</Note>
+
+## Member Management Tasks
+
+<Tabs>
+  <Tab title="Adding Members">
+    ### Inviting New Team Members
+    
+    1. **Navigate to Members**
+       - Go to your organization dashboard at app.cline.bot
+       - Click on "Members" in the sidebar
+    
+    2. **Send Invitation**
+       - Click "Invite Member"
+       - Enter the user's email address (must be from your verified domain)
+       - Select the appropriate role (Member, Admin, or Owner)
+       - Click "Send Invite"
+    
+    3. **Invitation Status**
+       - Invited users will receive an email with a join link
+       - Pending invitations show in your member list with "Pending" status
+       - Each pending invitation holds one seat from your license
+    
+    <Tip>
+    **Bulk Invitations:** Need to add multiple users? Contact support@cline.bot for assistance with bulk invite CSV imports.
+    </Tip>
+  </Tab>
+  
+  <Tab title="Editing Roles">
+    ### Changing Member Permissions
+    
+    1. **Locate the Member**
+       - Navigate to the Members page
+       - Find the user you want to modify
+    
+    2. **Change Role**
+       - Click the dropdown next to their current role
+       - Select the new role from the menu
+       - Confirm the change
+    
+    3. **Effective Immediately**
+       - Role changes take effect instantly
+       - The user may need to sign out and back in to see updated permissions
+    
+    <Warning>
+    **Admin to Member:** Downgrading an Admin to Member will immediately revoke their ability to manage users and configurations. Ensure they no longer need these permissions.
+    </Warning>
+  </Tab>
+  
+  <Tab title="Removing Members">
+    ### Offboarding Team Members
+    
+    1. **Access Member List**
+       - Navigate to your organization's Members page
+       - Locate the user to remove
+    
+    2. **Remove User**
+       - Click the menu icon (⋮) next to their name
+       - Select "Remove from Organization"
+       - Confirm the removal
+    
+    3. **Immediate Effects**
+       - User loses access to the organization immediately
+       - Their seat is freed and can be assigned to someone else
+       - Audit logs are preserved for compliance
+    
+    <Info>
+    **Data Retention:** Removing a member does not delete their historical activity logs. All audit trails remain intact for compliance purposes.
+    </Info>
+  </Tab>
+  
+  <Tab title="Revoking Invites">
+    ### Canceling Pending Invitations
+    
+    If an invited user hasn't accepted yet, you can revoke the invitation:
+    
+    1. Find the pending invitation in your Members list
+    2. Click "Revoke Invitation"
+    3. The seat is immediately freed for another user
+    
+    This is useful when:
+    - The wrong email was used
+    - The user no longer needs access
+    - You need to reassign the seat urgently
+  </Tab>
+</Tabs>
+
+## Identity & Access Requirements
+
+For users to successfully join your organization, two conditions must be met:
+
+<Steps>
+  <Step title="Verified Identity Provider">
+    Your organization must use a verified **Identity Provider (IDP)** such as:
+    - Microsoft Entra ID (Azure AD)
+    - Okta
+    - Google Workspace
+    - AWS IAM Identity Center
+    
+    Users must authenticate through your IDP to access the organization.
+  </Step>
+  
+  <Step title="Domain Verification">
+    Your organization must have a **verified domain**. You'll need to verify ownership of your domain through your domain provider (e.g., Google, Microsoft, Cloudflare).
+    
+    Only users with email addresses from verified domains can join.
+  </Step>
+</Steps>
+
+<Note>
+These requirements ensure that only authenticated users from your company can access your Cline organization, preventing unauthorized access.
+</Note>
+
+## Seat Management
+
+Understanding how seats work helps you manage your license effectively:
+
+<AccordionGroup>
+  <Accordion title="How Seats Are Calculated" icon="chair">
+    - Each user (Owner, Admin, or Member) consumes **one seat**
+    - Pending invitations also hold one seat
+    - Removing a member or revoking an invite immediately frees the seat
+    - Your license determines the maximum number of seats available
+  </Accordion>
+  
+  <Accordion title="When Seats Are Used" icon="user-plus">
+    A seat is consumed when:
+    - You send an invitation (marked as "pending")
+    - An invited user accepts and joins
+    - An existing user is granted access through SSO
+  </Accordion>
+  
+  <Accordion title="Freeing Up Seats" icon="user-minus">
+    To free a seat:
+    - Remove an active member from the organization
+    - Revoke a pending invitation
+    - Wait for a pending invite to expire (if configured)
+  </Accordion>
+  
+  <Accordion title="Upgrading Your License" icon="arrow-up">
+    Need more seats?
+    - **Enterprise Plan:** Includes unlimited seats with no per-user restrictions. Contact your account manager or visit app.cline.bot/settings/billing to upgrade.
+  </Accordion>
+</AccordionGroup>
+
+## Security Best Practices
+
+Follow these guidelines to maintain a secure organization:
+
+<CardGroup cols={2}>
+  <Card title="Principle of Least Privilege" icon="shield-check">
+    Always assign the minimum role necessary. Most users should be Members. Only grant Admin or Owner privileges when required for job duties.
+  </Card>
+  
+  <Card title="Limit Owner Roles" icon="user-lock">
+    Keep Owners to 1-2 key individuals who manage billing and security. This centralization prevents accidental or malicious changes to critical settings.
+  </Card>
+  
+  <Card title="Regular Audits" icon="clipboard-check">
+    Review your member list quarterly. Remove inactive users promptly and verify that Admin/Owner roles are still appropriate for each user.
+  </Card>
+  
+  <Card title="Offboarding Process" icon="door-open">
+    Create a standard offboarding checklist: remove from Cline, revoke IDP access, document in audit log, and reassign any critical responsibilities.
+  </Card>
+</CardGroup>
+
+<Warning>
+**Owner Accountability:** Since Owners control billing and can transfer ownership, choose these individuals carefully and document the selection in your organization's security policies.
+</Warning>
+
+## Advanced Scenarios
+
+<AccordionGroup>
+  <Accordion title="Transferring Ownership" icon="exchange">
+    Only the current Owner can transfer ownership:
+    
+    1. Navigate to Organization Settings
+    2. Go to the "Ownership" section
+    3. Select the new Owner from the member list
+    4. Confirm the transfer with your authentication
+    5. The new Owner receives immediate control
+    
+    **Important:** This action cannot be undone by the previous Owner. The new Owner must initiate a reverse transfer if needed.
+  </Accordion>
+  
+  <Accordion title="Managing Multiple Admins" icon="users-gear">
+    When you have multiple Admins:
+    
+    - Document each Admin's area of responsibility
+    - Use audit logs to track configuration changes
+    - Consider creating rotation schedules for large teams
+    - Establish escalation paths for Owner-level decisions
+  </Accordion>
+  
+  <Accordion title="Temporary Access" icon="clock">
+    For contractors or temporary staff:
+    
+    - Create them as Members with expiration calendar reminders
+    - Document their access period in your internal systems
+    - Set calendar reminders to remove them when the contract ends
+    - Consider using time-limited IDP accounts if your IDP supports it
+  </Accordion>
+</AccordionGroup>
+
+## Troubleshooting
+
+<AccordionGroup>
+  <Accordion title="User Can't Accept Invitation" icon="circle-exclamation">
+    **Common causes:**
+    - Email domain doesn't match verified domain
+    - User's IDP access hasn't been granted yet
+    - Invitation link expired
+    
+    **Solution:** Verify domain verification is complete and resend the invitation.
+  </Accordion>
+  
+  <Accordion title="Can't Remove an Admin" icon="user-slash">
+    **Cause:** Only Owners can remove Admins.
+    
+    **Solution:** Ask an Owner to perform the removal, or if you need to remove your organization's sole Owner, contact support@cline.bot.
+  </Accordion>
+  
+  <Accordion title="Out of Seats" icon="triangle-exclamation">
+    **When you've reached your license limit:**
+    - Remove inactive members to free seats
+    - Revoke pending invitations that are no longer needed
+    - Upgrade your license to add more seats
+  </Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+Now that you understand member management, proceed with configuring your organization:
+
+<CardGroup cols={2}>
+  <Card 
+    title="Configure Providers" 
+    icon="plug" 
+    href="/enterprise-solutions/configuration/remote-configuration/overview"
+  >
+    Set up API providers for your team to use
+  </Card>
+  
+  <Card 
+    title="Monitor Usage" 
+    icon="chart-line" 
+    href="/enterprise-solutions/monitoring/overview"
+  >
+    Track team activity and resource consumption
+  </Card>
+</CardGroup>
+
+<Tip>
+**Getting Started Fast?** The quickest path is: 1) Invite your team as Members, 2) Configure one API provider, 3) Let your team start using Cline. You can refine roles and settings later.
+</Tip>
diff --git a/docs/features/auto-approve.mdx b/docs/features/auto-approve.mdx
new file mode 100644
index 0000000..2d9eb8c
--- /dev/null
+++ b/docs/features/auto-approve.mdx
@@ -0,0 +1,117 @@
+---
+title: "Auto Approve & YOLO Mode"
+sidebarTitle: "Auto Approve"
+description: "Control which actions Cline can take without asking for approval."
+---
+
+Auto Approve lets you decide which actions Cline can take without prompting you each time. It keeps you out of approval popups during routine work while letting you keep tight control over high-risk actions.
+
+If you find yourself repeatedly clicking approve for the same safe operations, Auto Approve fixes that.
+
+<Frame>
+	<video
+		style={{ width: "100%" }}
+		src="https://storage.googleapis.com/cline_public_images/autoapprove.mp4"
+		autoPlay
+		controls
+		playsInline
+	/>
+</Frame>
+
+## How It Works
+
+Auto Approve is evaluated per tool call. When Cline is about to read a file, edit a file, run a command, or use the browser, it checks your Auto Approve settings for that category.
+
+A few details matter:
+
+- **Workspace vs outside workspace**: "Read all files" and "Edit all files" only extend the base toggle. If the base toggle is off, the "all files" option does nothing.
+- **Terminal commands**: Cline treats commands as either safe or requiring approval. "Execute safe commands" covers safe commands. "Execute all commands" extends to commands flagged as requiring approval.
+- **Notifications**: If enabled, Cline sends OS-level notifications when approval is required, and when an auto-approved terminal command has been running for 30 seconds.
+
+## Permissions
+
+| Setting | What It Allows |
+|---------|----------------|
+| Read project files | Read files, list files, search in your workspace |
+| Read all files | Read files outside your workspace (requires base toggle) |
+| Edit project files | Create and edit files in your workspace |
+| Edit all files | Edit files outside your workspace (requires base toggle) |
+| Execute safe commands | Run terminal commands marked safe |
+| Execute all commands | Run commands requiring approval (requires base toggle) |
+| Use the browser | Browser tool for web fetching and searching |
+| Use MCP servers | MCP tools and resources |
+| Enable notifications | Notifies you about long-running commands |
+
+<Warning>
+"Read all files" and "Edit all files" only matter if their base toggle is enabled. They extend access outside your workspace.
+</Warning>
+
+## Safe vs Approval-Required Commands
+
+Cline does not use a fixed allowlist. The model marks each command with a `requires_approval` flag based on the command and arguments. These are examples, not guarantees.
+
+**Commonly treated as safe:**
+- `npm run build`, `npm test` - Build/test output
+- `git status`, `ls -la`, `cat package.json` - Read-only commands
+
+**Commonly requires approval:**
+- `npm install <pkg>` - Modifies dependencies
+- `rm -rf <path>` - Deletes files
+- `mv <a> <b>` - Moves files (can overwrite)
+- `sed -i ...` - In-place file edits
+
+## Recommendations
+
+A good default setup:
+- Enable **Read project files**
+- Leave edits, commands, browser, and MCP off until you have a specific reason
+
+If you enable edits, use [Checkpoints](/core-workflows/checkpoints) so you can roll back quickly.
+
+---
+
+## YOLO Mode
+
+YOLO mode is Auto Approve on steroids. Check the box and Cline auto-approves everything: file changes, terminal commands, browser actions, MCP tools, and mode transitions.
+
+<Note>
+**Warning: This is dangerous.** YOLO mode disables all safety checks. Cline executes whatever it decides without asking permission.
+</Note>
+
+### What Gets Auto-Approved
+
+When YOLO mode is enabled:
+- All file operations anywhere on your system
+- All terminal commands including potentially destructive ones
+- Browser actions
+- MCP server tools
+- Mode transitions (Plan to Act)
+
+### When to Use YOLO Mode
+
+**Rapid prototyping** where you want zero friction and don't care about potential mistakes. Perfect for throwaway experiments.
+
+**Trusted, repetitive tasks** where you've validated Cline's approach and want to eliminate approval overhead.
+
+**Demonstration purposes** where you want to show Cline's capabilities without interruptions.
+
+### What Could Go Wrong
+
+Cline could:
+- Delete important files without warning
+- Execute commands that modify system settings
+- Make network requests to external services
+- Overwrite configuration files
+- Install or uninstall packages
+- Commit and push changes to version control
+
+### Best Practices for YOLO Mode
+
+- **Start with isolated environments.** Use throwaway projects or sandboxed environments first.
+- **Be specific with requests.** Vague instructions + unlimited permissions = unpredictable results.
+- **Monitor the output.** Cline still shows what it's doing. Watch the terminal and file changes.
+- **Keep version control handy.** Git becomes your safety net.
+
+### Enabling YOLO Mode
+
+Navigate to Cline Settings, then Features, and check "YOLO Mode." No confirmation dialogs. Once enabled, Cline auto-approves all actions immediately. Uncheck to disable.
diff --git a/docs/features/auto-compact.mdx b/docs/features/auto-compact.mdx
new file mode 100644
index 0000000..b9454c1
--- /dev/null
+++ b/docs/features/auto-compact.mdx
@@ -0,0 +1,55 @@
+---
+title: "Auto Compact"
+sidebarTitle: "Auto Compact"
+description: "Automatic context summarization to keep working when approaching context limits."
+---
+
+When your conversation approaches the model's context window limit, Cline automatically summarizes it to free up space and keep working.
+
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/condensing.png"
+		alt="Auto-compact condensing conversation context"
+	/>
+</Frame>
+
+## How It Works
+
+Cline monitors token usage during your conversation. When you're getting close to the limit, it:
+
+1. Creates a comprehensive summary of everything that's happened
+2. Preserves all technical details, code changes, and decisions
+3. Replaces the conversation history with the summary
+4. Continues exactly where it left off
+
+You'll see a summarization tool call when this happens, showing the cost like any other API call.
+
+## Why This Matters
+
+Previously, Cline would truncate older messages when hitting context limits, losing important context.
+
+Now with summarization:
+- All technical decisions and code patterns are preserved
+- File changes and project context remain intact
+- Cline remembers everything it's done
+- You can work on much larger projects without interruption
+
+<Tip>
+Auto Compact works especially well for long-running tasks. Structured task lists can help maintain progress across summarizations so Cline can stay on track across multiple context windows.
+</Tip>
+
+## Cost Considerations
+
+Summarization leverages your existing prompt cache from the conversation, so it costs about the same as any other tool call.
+
+Since most input tokens are already cached, you're primarily paying for summary generation (output tokens), making it cost-effective.
+
+<Note>
+With other models, Cline falls back to standard rule-based context truncation, even if Auto Compact is enabled.
+</Note>
+
+## Restoring Context
+
+You can use [checkpoints](/core-workflows/checkpoints) to restore your task state from before a summarization occurred. You never truly lose context since you can always roll back.
+
+Editing a message before a summarization tool call works similarly, restoring the conversation to that point.
diff --git a/docs/features/jupyter-notebooks.mdx b/docs/features/jupyter-notebooks.mdx
new file mode 100644
index 0000000..826bc97
--- /dev/null
+++ b/docs/features/jupyter-notebooks.mdx
@@ -0,0 +1,115 @@
+---
+title: "Jupyter Notebooks"
+sidebarTitle: "Jupyter Notebooks"
+description: "AI-assisted editing of Jupyter notebooks with cell-level context awareness"
+---
+
+Cline provides comprehensive support for Jupyter notebooks (`.ipynb` files), enabling AI-assisted editing with full cell-level context awareness. This feature was developed in collaboration with Amazon to bring AI coding assistance to data science workflows.
+
+## Getting Started
+
+Jupyter notebook support is a built-in feature of Cline. To use it, you just need to have the Jupyter notebook extension enabled in VS Code. Once you open any `.ipynb` file, you'll see AI-assisted buttons in your notebook interface.
+
+## How to Use
+
+### Generate Cell
+
+Click the sparkle icon in the notebook toolbar to generate new cells with AI assistance.
+
+<Frame>
+  <img src="/assets/jupyter-generate-cell.gif" alt="Generating a new Jupyter cell with AI assistance" />
+</Frame>
+
+The AI receives context from surrounding cells, so it understands the variables and imports already in scope. This means you can reference existing DataFrames, functions, and other objects without re-explaining them.
+
+**Example prompt:** "Create a visualization showing the correlation matrix of numeric columns with a heatmap"
+
+The cell is inserted with proper notebook JSON structure, preserving metadata and ready to execute.
+
+### Explain Cell
+
+Click the Explain button in any cell's title bar to get a detailed explanation of what the cell does.
+
+This is useful for:
+
+- Revisiting old notebooks
+- Onboarding to a teammate's analysis
+- Understanding complex transformations
+
+Cline extracts the full cell context, including outputs, so explanations can reference actual results like column names, row counts, and computed values.
+
+### Improve Cell
+
+Click the Improve button in any cell's title bar to enhance existing cells with AI suggestions.
+
+<Frame>
+  <img src="/assets/jupyter-explain-improve-cell.gif" alt="Explaining and improving a Jupyter cell with AI" />
+</Frame>
+
+Use this to:
+
+- Optimize slow pandas operations
+- Add error handling
+- Refactor for clarity
+- Convert loops to vectorized operations
+
+Cline suggests improvements while preserving the cell's position and metadata in the notebook structure. The AI explains what was changed and why.
+
+## How Cell Context Works
+
+Unlike traditional file editing, Jupyter notebooks are JSON documents containing arrays of cells. Each cell has its own type, source content, metadata, execution count, and outputs.
+
+When you use a Jupyter command, Cline extracts structured context that includes:
+
+- **Cell type** (code, markdown, or raw)
+- **Source content** as an array of lines
+- **Cell metadata** and configuration
+- **Execution count** for code cells
+- **Outputs** including data, text, and error traces
+
+This structured representation allows the AI to understand not just the code, but its context within the notebook and its actual output.
+
+### JSON Structure Preservation
+
+Cline is designed to work carefully with the cell JSON structure, aiming to:
+
+- Keep cell boundaries intact
+- Preserve execution counts
+- Maintain cell metadata
+- Keep outputs associated with their source cells
+
+The AI is specifically prompted to preserve notebook structure, though you should always review changes to ensure your notebook format remains correct.
+
+## Keyboard Shortcuts
+
+You can bind any of these commands to keyboard shortcuts for faster access:
+
+1. Open VS Code keyboard shortcuts (Cmd/Ctrl + K, Cmd/Ctrl + S)
+2. Search for `cline.jupyterGenerateCell`, `cline.jupyterExplainCell`, or `cline.jupyterImproveCell`
+3. Assign your preferred key combinations
+
+## Tips for Best Results
+
+**For Generate Cell:**
+- Be specific about what you want the cell to do
+- Reference existing variables by name (the AI can see them)
+- Mention preferred libraries if you have a preference (e.g., "use seaborn" or "use plotly")
+
+**For Explain Cell:**
+- Works best on cells that have been executed (outputs provide additional context)
+- Good for complex chained operations like pandas groupby/merge sequences
+
+**For Improve Cell:**
+- Mention what aspect you want to improve (performance, readability, error handling)
+- The AI will explain the changes it suggests
+
+## Limitations
+
+- Notebook support requires the Jupyter notebook extension to be enabled in VS Code
+- Cell context extraction depends on VS Code's notebook API
+- Very large notebooks may require more context than some models can handle efficiently
+
+## Related
+
+- [All Cline Tools](/tools-reference/all-cline-tools) - Overview of all Cline tools
+- [Cline provider](/getting-started/cline-provider) - Fastest way to get started with built-in provider setup
diff --git a/docs/features/multiroot-workspace.mdx b/docs/features/multiroot-workspace.mdx
new file mode 100644
index 0000000..410e9d9
--- /dev/null
+++ b/docs/features/multiroot-workspace.mdx
@@ -0,0 +1,268 @@
+---
+title: "Multi-Root Workspaces"
+sidebarTitle: "Multi-Root Workspaces"
+---
+
+Cline works with VSCode's multi-root workspaces, letting you manage multiple project folders or repositories in a single window. Whether you're working with a monorepo or separate Git repositories, Cline can read files, write code, and run commands across all of them.
+
+<Frame>
+  <video
+    src="https://storage.googleapis.com/cline_public_images/multiworkspace.mp4"
+    autoPlay
+    muted
+    loop
+    playsInline
+    controls
+  />
+</Frame>
+
+<Warning>
+Multi-root workspaces have two limitations:
+- **Cline rules** only work in the primary workspace folder
+- **[Checkpoints](/core-workflows/checkpoints)** are disabled (restored when you return to a single folder)
+
+See [Current Limitations](#current-limitations) for details.
+</Warning>
+
+## Understanding Multi-Root Workspaces
+
+Before diving in, it helps to understand the two common patterns for organizing related projects.
+
+### Why Use Multi-Root Workspaces?
+
+Cline can complete tasks that span multiple projects or repositories:
+
+- **Refactoring**: Update an API contract and fix all consumers across repos
+- **Feature development**: Implement a feature that touches frontend, backend, and shared code
+- **Dependency updates**: Coordinate version bumps across related projects
+- **Documentation**: Generate docs that reference code from multiple repositories
+
+**Example prompt:**
+```text
+Update the User type in the contracts repo, then update both the frontend 
+and backend to use the new fields. Make sure the API validates the new 
+required field.
+```
+## Setting Up a Multi-Root Workspace
+
+### Monorepos vs Multiple Repositories
+
+**Monorepo**: One Git repository containing multiple projects or packages. All code shares the same version history.
+
+<Files>
+  <Folder name="my-company" defaultOpen>
+    <Folder name=".git" />
+    <Folder name="packages" defaultOpen>
+      <Folder name="web" icon="react">
+        <File name="..." />
+      </Folder>
+      <Folder name="api" icon="node-js">
+        <File name="..." />
+      </Folder>
+      <Folder name="shared">
+        <File name="..." />
+      </Folder>
+    </Folder>
+    <File name="package.json" />
+  </Folder>
+</Files>
+
+**Multiple Repositories**: Separate Git repositories, each with their own history, opened together in one VSCode workspace.
+
+```text
+~/projects/
+├── fullstack.code-workspace   # Workspace config file
+├── frontend/                  # git@github.com:acme/frontend.git
+│   └── .git/
+├── backend/                   # git@github.com:acme/backend.git
+│   └── .git/
+└── contracts/                 # git@github.com:acme/api-contracts.git
+    └── .git/
+```
+
+Cline supports both patterns, as well as hybrid setups where some folders are Git repositories and others are not. The key difference: with multiple repositories, each folder has its own `.git` directory and Cline tracks them independently.
+
+### Adding Folders to Your Workspace
+
+You can add folders to your workspace in several ways:
+
+- **File menu**: Use `File > Add Folder to Workspace` in VSCode
+- **Drag and drop**: Drag folders directly into VSCode's file explorer
+- **Workspace file**: Create a `.code-workspace` file (recommended for teams)
+- **Command palette**: Run `Workspaces: Add Folder to Workspace`
+
+For detailed instructions, see [Microsoft's multi-root workspace guide](https://code.visualstudio.com/docs/editor/multi-root-workspaces).
+
+## Working with Multiple Repositories
+
+When you open separate Git repositories in one workspace, Cline treats each as an independent project with its own version control.
+
+### What Cline Tracks Per Repository
+
+For each workspace folder, Cline detects:
+
+| Property | Description |
+|----------|-------------|
+| **Path** | Absolute path to the folder |
+| **Name** | Derived from folder name or workspace file |
+| **VCS Type** | Git, Mercurial, or None |
+| **Commit Hash** | Current HEAD commit (for Git/Mercurial repos) |
+
+This means Cline understands that your frontend and backend might be at different commits, on different branches, or even use different version control systems.
+
+<Note>
+While Cline detects VCS information for all workspace folders, certain features only use the **primary workspace** (the first folder): [Cline rules](/customization/cline-rules), [skills](/customization/skills#triggering-skills-with-slash-commands), and [Git-related features](/core-workflows/working-with-files) like `@git` mentions.
+</Note>
+
+## Referencing Files Across Workspaces
+
+### Natural Language References
+
+Cline understands natural references to your workspaces:
+
+```text
+"Read the package.json in the frontend folder"
+```
+
+```text
+"Compare the user model in backend with the TypeScript types in contracts"
+```
+
+```text
+"Search for TODO comments across all workspaces"
+```
+
+### Workspace Hints Syntax
+
+For explicit references, use the `@workspace:path` syntax:
+
+| Syntax | Description |
+|--------|-------------|
+| `@frontend:src/App.tsx` | File in the "frontend" workspace |
+| `@backend:server.ts` | File in the "backend" workspace |
+| `@contracts:types/` | Folder in the "contracts" workspace |
+
+This syntax is especially useful when:
+- Multiple workspaces have files with the same name
+- You want to be explicit about which project you mean
+- Cline needs to resolve ambiguity
+
+### How Workspace Names Work
+
+Workspace names are derived from:
+1. The `name` field in your `.code-workspace` file (if specified)
+2. The folder name (default)
+
+If two folders have the same name, append numbers or use the workspace file to give them unique names.
+
+## Common Configurations
+
+### Monorepo Development
+
+```text
+~/projects/my-app/
+├── my-app.code-workspace      # Workspace config file
+├── web/          (React frontend)
+├── api/          (Node.js backend)  
+├── mobile/       (React Native)
+└── shared/       (Common utilities)
+```
+
+All folders share one Git history. Changes across packages are atomic.
+
+**Example prompt:** *"Update the API endpoint in both web and mobile apps to match the new backend route"*
+
+### Microservices with Separate Repos
+
+```text
+~/projects/services/
+├── services.code-workspace    # Workspace config file
+├── user-service/       (git: github.com/acme/user-service)
+├── payment-service/    (git: github.com/acme/payment-service)
+├── gateway/            (git: github.com/acme/api-gateway)
+└── proto/              (git: github.com/acme/service-protos)
+```
+
+Each service has its own repository. Cline can update the proto definitions and regenerate clients across all services.
+
+**Example prompt:** *"Add a new field to the UserProfile message in proto, then update user-service and gateway to handle it"*
+
+### Full-Stack with Shared Contracts
+
+```text
+~/projects/fullstack/
+├── fullstack.code-workspace   # Workspace config file
+├── client/         (git: github.com/acme/web-client)
+├── server/         (git: github.com/acme/api-server)
+└── types/          (git: github.com/acme/shared-types)
+```
+
+The types repository defines interfaces used by both client and server. When you update a type, Cline can fix both consumers.
+
+### Hybrid Setup
+
+```text
+~/projects/project/
+├── project.code-workspace     # Workspace config file
+├── main-app/       (git: github.com/acme/main-app)
+├── vendor/         (no VCS - vendored dependencies)
+└── scripts/        (no VCS - local automation)
+```
+
+Mix of repositories and plain folders. Cline adapts to each folder's configuration.
+
+## Current Limitations
+
+Two features have limitations in multi-root workspace mode:
+
+### Cline Rules
+
+[Cline rules](/customization/cline-rules) (`.clinerules/` directory) only work in the **primary workspace** (the first folder in your workspace). Rules in other workspace folders are ignored.
+
+**Workaround:** Place shared rules in the primary workspace, or use global rules (`~/Documents/Cline/Rules/`) which apply everywhere.
+
+### Checkpoints
+
+[Checkpoints](/core-workflows/checkpoints) are disabled in multi-root workspace mode. Cline displays a warning when this happens.
+
+**Why:** Checkpoints use a shadow Git repository to track changes. With multiple repositories, coordinating checkpoints across independent Git histories adds complexity that isn't yet supported.
+
+**Workaround:** Use your normal Git workflow. Commit frequently, or create branches for experimental work.
+
+Both limitations are restored when you return to a single-folder workspace.
+
+## Best Practices
+
+### Organizing Your Workspaces
+
+1. **Group related projects** that often need coordinated changes
+2. **Use a workspace file** for reproducible setups across your team
+3. **Name folders clearly** so workspace hints are intuitive
+4. **Consider the primary workspace** for Cline rules placement
+
+### Effective Prompting
+
+- **Be specific** when it matters: *"Update the user model in the backend workspace"*
+- **Reference relationships**: *"The frontend uses types from the contracts workspace"*
+- **Describe cross-workspace changes**: *"This needs to update both web and mobile"*
+- **Scope searches** for large codebases: *"Search for 'TODO' only in the frontend workspace"*
+
+### Working with Large Workspaces
+
+- Break large tasks into workspace-specific operations when possible
+- Use [Plan mode](/core-workflows/plan-and-act) to let Cline understand structure first
+- Add a `.clineignore` file to reduce noise, speed up scanning, and keep Cline focused on source code:
+
+```text
+# Dependencies
+**/node_modules/
+
+# Build outputs
+**/dist/
+**/build/
+
+# VCS metadata
+**/.git/
+```
+
+For more patterns and gotchas, see the [.clineignore File Guide](/customization/clineignore).
diff --git a/docs/features/subagents.mdx b/docs/features/subagents.mdx
new file mode 100644
index 0000000..8f4d847
--- /dev/null
+++ b/docs/features/subagents.mdx
@@ -0,0 +1,79 @@
+---
+title: "Subagents"
+sidebarTitle: "Subagents"
+description: "Run parallel research agents to explore your codebase without filling the main agent's context window."
+---
+
+Subagents let Cline spawn focused research agents that run in parallel. Each subagent gets its own prompt and context window, explores the codebase independently, and returns a detailed report to the main agent. This keeps the main agent's context clean while gathering broad information fast.
+
+<Tip>
+  Subagents is an experimental feature. Behavior may change in future releases.
+</Tip>
+
+## How It Works
+
+When Cline uses the `use_subagents` tool, it launches independent agents simultaneously. Each one:
+
+- Gets its own prompt describing what to investigate
+- Runs with a separate context window and token budget
+- Can read files, search code, list directories, run read-only commands, and use skills
+- Cannot edit files, use the browser, access MCP servers, or spawn nested subagents
+- Returns a result focused on the most relevant file paths for the main agent to read next
+
+Subagent costs (tokens and API spend) are tracked separately per subagent and rolled into the task's total cost. You can see per-subagent stats (tool calls, tokens, cost) in the chat UI as they run.
+
+## Enabling Subagents
+
+Subagents are enabled by default. Cline decides when parallel research is worth the overhead — you don't need to opt in or call them out in your prompt. To turn subagents off, disable the `use_subagents` tool in Settings → Features → Agent.
+
+This setting applies across all editors (VS Code, JetBrains, CLI).
+
+## Using Subagents
+
+When subagents are enabled, Cline picks them up on its own when a task benefits from parallel exploration. You can also nudge it explicitly by asking for parallel research in your prompt.
+
+Example prompts:
+
+- "Use subagents to explore how authentication works and where the database models are defined"
+- "Spin up subagents to investigate the API routes, the test setup, and the deployment config"
+- "I'm new to this codebase. Use subagents to map out the main entry points, the routing layer, and the data access patterns"
+
+Each subagent prompt should describe a focused research question. Cline will run them in parallel and synthesize the results.
+You can also run only one subagent when the task is small enough that parallel discovery would be unnecessary overhead.
+
+## Auto-Approve Behavior
+
+Subagents follow the **Read project files** auto-approve permission. If you have "Read project files" enabled in [Auto Approve](/features/auto-approve), subagent launches will be auto-approved.
+
+If auto-approve is off, Cline will ask for your approval before launching subagents, showing you the prompts it plans to send.
+
+## What Subagents Can Do
+
+Subagents are read-only research agents. Here is what they have access to:
+
+| Tool | Purpose |
+|------|---------|
+| `read_file` | Read file contents |
+| `list_files` | List directory contents |
+| `search_files` | Regex search across files |
+| `list_code_definition_names` | List top-level classes, functions, and methods |
+| `execute_command` | Run read-only commands (`ls`, `grep`, `git log`, `git diff`, etc.) |
+| `use_skill` | Load and activate skills |
+
+Subagents cannot write files, apply patches, use the browser, access MCP servers, or perform web searches. They also cannot spawn their own subagents.
+
+<Note>
+  Commands run by subagents execute in the background and are restricted to read-only operations. Subagents will not run commands that modify files or system state.
+  Subagents also benefit from command pipelines and filters to narrow output quickly before reading files, for example `rg ... | sort | uniq`.
+</Note>
+
+## When to Use Subagents
+
+Subagents work best when you need broad context from multiple areas of a codebase at once:
+
+- **Onboarding to an unfamiliar project**: Ask subagents to map out the architecture, key entry points, and data flow in parallel.
+- **Investigating cross-cutting concerns**: Have separate subagents trace authentication, logging, and error handling simultaneously.
+- **Pre-edit research**: Before making changes, use subagents to gather context from related files so the main agent can make informed edits without burning through its context window.
+- **Large codebases**: When reading many files sequentially would consume too much of the main agent's context, subagents let you explore broadly without that tradeoff.
+
+For small, focused tasks where you already know which files to look at, subagents add unnecessary overhead. Just ask Cline directly.
diff --git a/docs/getting-started/authorizing-with-cline.mdx b/docs/getting-started/authorizing-with-cline.mdx
new file mode 100644
index 0000000..4da5a54
--- /dev/null
+++ b/docs/getting-started/authorizing-with-cline.mdx
@@ -0,0 +1,102 @@
+---
+title: "Authorization"
+description: "Authenticate with Cline and choose your first AI model"
+---
+
+Cline connects to AI models through a **provider**. You have three common paths:
+
+- **Cline (usage-billing)** (recommended): sign in with Google/GitHub/email, no API key setup.
+- **ClinePass**: a $9.99/month subscription provider with access to selected open coding models and 2-5x API rate limits.
+- **Bring Your Own Key (BYOK)**: use your own provider credentials (cloud or local runtimes).
+
+## Menu
+
+- [IDE Setup](#ide-setup)
+- [CLI Setup](#cli-setup)
+
+## IDE Setup
+
+<Steps>
+  <Step title="Open Cline Settings">
+    Click the settings icon (⚙️) in the Cline panel.
+  </Step>
+
+  <Step title="Select Provider">
+    Choose your desired provider from the **API Provider** dropdown.
+  </Step>
+
+  <Step title="Authenticate">
+    - **Cline (usage-billing):** Click **Sign In** and complete OAuth.
+    - **ClinePass:** Select **ClinePass**, click **Sign In**, and subscribe if prompted.
+    - **BYOK cloud provider:** Paste your API key into the **API Key** field.
+    - **Local runtime (Ollama/LM Studio):** no key needed; ensure runtime is running.
+  </Step>
+
+  <Step title="Select Model">
+    Choose your desired model from the **Model** dropdown.
+  </Step>
+</Steps>
+
+## Provider Options
+
+### Cline (usage-billing)
+
+- One sign-in, no key management
+- Built-in billing and free model options
+- Access to multiple providers from one account
+
+Add credits in Cline settings or at [app.cline.bot/dashboard](https://app.cline.bot/dashboard).
+
+### ClinePass
+
+- Flat **$9.99/month** subscription
+- 2-5x API rate limits for longer agent sessions
+- Curated open coding models including GLM, Kimi, DeepSeek, and MiMo
+
+Subscribe from the [ClinePass dashboard](https://app.cline.bot/dashboard/subscription?personal=true), then select **ClinePass** as your provider in Cline. See the [ClinePass guide](/getting-started/clinepass) for included models and reference pricing.
+
+### BYOK (cloud + local)
+
+### Cloud Providers
+
+| Provider | Best For | Setup Guide |
+|----------|----------|-------------|
+| **OpenRouter** | Multiple models, competitive pricing | [Setup](/provider-config/openrouter) |
+| **Anthropic** | Direct Claude access | [Setup](/provider-config/anthropic) |
+| **Claude Code** | Claude Max/Pro subscription | [Setup](/provider-config/anthropic) |
+| **OpenAI** | GPT models | [Setup](/provider-config/openai) |
+| **Google Gemini** | Gemini models | [Setup](/provider-config/google-gemini) |
+| **AWS Bedrock** | Enterprise | [Setup](/provider-config/aws-bedrock/api-key) |
+| **DeepSeek** | Great value | [Setup](/provider-config/deepseek) |
+
+### Local Models
+
+Run models on your own hardware for complete privacy and zero per-request costs.
+
+| Provider | Best For | Setup Guide |
+|----------|----------|-------------|
+| **Ollama** | CLI-based local runtime | [Setup](/running-models-locally/overview#runtime-options) |
+| **LM Studio** | GUI-based local runtime | [Setup](/running-models-locally/overview#runtime-options) |
+
+Local models require sufficient hardware (especially GPU memory). See [Running Models Locally](/running-models-locally/overview) for requirements.
+
+## CLI Setup
+
+```bash
+# Authenticate from the terminal
+cline auth
+
+# Shorthand
+cline a
+```
+
+Runs the same auth flow as IDE setup.
+
+## Troubleshooting
+
+| Issue | Fix |
+|-------|-----|
+| "Unauthorized: Please sign in" | Session expired. Click **Sign In** to re-authenticate. |
+| Browser doesn't open | Check default browser settings. Copy the URL from the Cline output panel manually. |
+| Frequent re-authentication | Check org security policies. Ensure you're not clearing IDE secrets. Try a full sign-out/sign-in. |
+| Can't access organization | Verify membership at [app.cline.bot](https://app.cline.bot). Ask your admin about permissions. Sign out and back in. |
diff --git a/docs/getting-started/cline-provider.mdx b/docs/getting-started/cline-provider.mdx
new file mode 100644
index 0000000..1d08938
--- /dev/null
+++ b/docs/getting-started/cline-provider.mdx
@@ -0,0 +1,38 @@
+---
+title: "Cline (usage-billing)"
+description: "Use Cline (usage-billing) for pay-as-you-go model access with built-in authentication and Cline credits."
+---
+
+Cline (usage-billing) is the simplest way to get started with pay-as-you-go model access in Cline.
+
+Instead of managing separate API keys across multiple vendors, you sign in once, add **Cline credits**, and select from available models directly in Cline.
+
+If you want a flat monthly subscription for selected open coding models with higher rate limits, use [ClinePass](/getting-started/clinepass) instead. ClinePass is a separate provider in Cline.
+
+## Why use Cline (usage-billing)
+
+- **Fastest setup**: no manual API key copy/paste; access to 100+ models supported by Cline
+- **One account**: sign in once with Google, GitHub, or email
+- **Pay as you go**: add Cline credits and use one balance across supported models
+- **Free options**: look for models tagged **FREE** in the selector
+
+## How it works
+
+Cline (usage-billing) is the pay-as-you-go provider in Cline. Add Cline credits, then select **Cline** wherever you configure your provider.
+
+- **IDE Extension**: Go to IDE extension settings, set **API Provider** to **Cline**, and sign in.
+- **CLI**: Go to `/settings` and select **Cline** as your provider.
+
+## Credits and usage
+
+- Add **Cline credits** from your [Cline dashboard](https://app.cline.bot/dashboard)
+- Credits are used on a pay-as-you-go basis when you select paid models through Cline (usage-billing)
+- View usage in Cline Settings → **View Usage**
+- Switch organizations in Cline Settings → **Switch Organization**
+
+## Related
+
+- [Authorization](/getting-started/authorizing-with-cline)
+- [ClinePass](/getting-started/clinepass)
+- [Local models](/running-models-locally/overview)
+- [Provider setup guides](/provider-config/openrouter)
diff --git a/docs/getting-started/clinepass.mdx b/docs/getting-started/clinepass.mdx
new file mode 100644
index 0000000..a3fc46b
--- /dev/null
+++ b/docs/getting-started/clinepass.mdx
@@ -0,0 +1,119 @@
+---
+title: "ClinePass"
+description: "A low-cost monthly subscription that gives you reliable access to popular open coding models with 2-5x API rate limits."
+---
+
+ClinePass is a low-cost monthly subscription — **$9.99/month** — that gives you reliable access to popular open coding models with **2-5x the API rate limits** of standard access.
+
+It's completely optional. You don't need ClinePass to use Cline, and you can always use any other provider alongside it.
+
+<Card title="Subscribe to ClinePass" icon="credit-card" href="https://app.cline.bot/dashboard/subscription?personal=true">
+  Get started for $9.99/month and unlock 2-5x API rate limits.
+</Card>
+
+## How it works
+
+ClinePass is a separate provider in Cline. After subscribing, select **ClinePass** wherever you configure your provider.
+
+- **IDE Extension**: Go to IDE extension settings, set **API Provider** to **ClinePass**, and sign in.
+
+<Frame>
+  <img src="/assets/clinepass/clinepass-ide-extension.png" alt="Cline IDE extension settings with ClinePass selected as the API Provider" />
+</Frame>
+
+- **CLI**: Go to `/settings` and select **ClinePass** as your provider.
+
+<Frame>
+  <img src="/assets/clinepass/clinepass-cli.png" alt="Cline CLI settings showing ClinePass selected as the provider" />
+</Frame>
+
+## Why ClinePass
+
+Open models have gotten really good. They now reach performance close to proprietary models for coding tasks, and because many providers can serve them competitively, they're usually far cheaper.
+
+However, getting reliable access can be difficult. Providers vary in quality and availability, and standard rate limits can throttle heavy agentic workflows that read files, run commands, and iterate across many turns.
+
+ClinePass solves this by:
+
+- Curating a select group of open models tested and benchmarked for coding agent use
+- Offering **2-5x the API rate limits** so you can run long, complex agent tasks without interruption
+- Providing stable access through Cline's infrastructure
+
+<Note>
+ClinePass is a separate provider from Cline (usage-billing). You can use both independently — subscribe to ClinePass for 2-5x API rate limits, or use Cline (usage-billing) for pay-as-you-go access.
+</Note>
+
+## Models
+
+ClinePass includes the following models, tested and benchmarked for coding agent use:
+
+| Model | Model ID |
+|-------|------------|
+| GLM-5.2 | `cline-pass/glm-5.2` |
+| Kimi K2.7 Code | `cline-pass/kimi-k2.7-code` |
+| Kimi K2.6 | `cline-pass/kimi-k2.6` |
+| DeepSeek V4 Pro | `cline-pass/deepseek-v4-pro` |
+| DeepSeek V4 Flash | `cline-pass/deepseek-v4-flash` |
+| MiMo-V2.5 | `cline-pass/mimo-v2.5` |
+| MiMo-V2.5-Pro | `cline-pass/mimo-v2.5-pro` |
+| MiniMax M3 | `cline-pass/minimax-m3` |
+| Qwen3.7 Max | `cline-pass/qwen3.7-max` |
+| Qwen3.7 Plus | `cline-pass/qwen3.7-plus` |
+
+## Using ClinePass outside of Cline
+
+You can use ClinePass models from your own scripts, apps, or automation through the Cline API. The API uses the same OpenAI-compatible Chat Completions format as the rest of Cline's API.
+
+To get started, create an API key from **Settings > API Keys** in [app.cline.bot](https://app.cline.bot). For the complete walkthrough, see the [Cline API Getting Started guide](/api/getting-started).
+
+Use the full ClinePass model slug in the `model` field:
+
+```bash
+export CLINE_API_KEY="your_api_key_here"
+
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "cline-pass/qwen3.7-max",
+    "messages": [
+      {"role": "user", "content": "Write a TypeScript function that validates an email address."}
+    ],
+    "stream": false
+  }'
+```
+
+
+## Reference pricing
+
+ClinePass is a flat monthly subscription, so you are not charged the individual API prices below. These reference prices show the underlying per-1M-token rates for each model and can help you understand how usage is measured against your ClinePass quota (2-5x quota compares to paying standard api rate).
+
+| Model | Input | Output | Cached Read | Cached Write |
+|-------|-------|--------|-------------|--------------|
+| GLM-5.2 | $1.40 | $4.40 | $0.26 | - |
+| Kimi K2.7 Code | $0.95 | $4.00 | $0.19 | - |
+| Kimi K2.6 | $0.95 | $4.00 | $0.16 | - |
+| DeepSeek V4 Pro | $1.74 | $3.48 | $0.0145 | - |
+| DeepSeek V4 Flash | $0.14 | $0.28 | $0.0028 | - |
+| MiMo-V2.5 | $0.14 | $0.28 | $0.0028 | - |
+| MiMo-V2.5-Pro | $1.74 | $3.48 | $0.0145 | - |
+| MiniMax M3 | $0.30 | $1.20 | $0.06 | - |
+| Qwen3.7 Max | $2.50 | $7.50 | $0.50 | $3.125 |
+| Qwen3.7 Plus (≤ 256K tokens) | $0.40 | $1.60 | $0.04 | $0.50 |
+| Qwen3.7 Plus (> 256K tokens) | $1.20 | $4.80 | $0.12 | $1.50 |
+
+## Usage
+
+ClinePass measures usage against three limits:
+
+- **5-hour rolling window** — your usage within rolling 5-hour period
+- **Weekly** — your usage over the calendar week
+- **Monthly** — your usage over the calendar month
+
+To check your current usage, visit your [Cline dashboard](https://app.cline.bot/dashboard/subscription?personal=true).
+
+## Related
+
+- [Cline (usage-billing)](/getting-started/cline-provider)
+- [Authorization](/getting-started/authorizing-with-cline)
+- [Local models](/running-models-locally/overview)
diff --git a/docs/getting-started/config.mdx b/docs/getting-started/config.mdx
new file mode 100644
index 0000000..28b775a
--- /dev/null
+++ b/docs/getting-started/config.mdx
@@ -0,0 +1,165 @@
+---
+title: "Config"
+sidebarTitle: "Config"
+description: "Understand where Cline stores configuration and how global and project config work together."
+---
+
+Cline configuration lives in two scopes:
+
+- **Global configuration** in `~/.cline/` (applies globally across all Cline applications, including IDE, CLI, and SDK)
+- **Project configuration** in `.cline/` (applies only to the current workspace)
+
+## Configuration Directory Layout
+
+Cline stores shared configuration across a few well-known locations. The primary root is `~/.cline/`, with structured app state under `~/.cline/data/`:
+
+```text
+~/.cline/
+  data/
+    settings/
+      providers.json           # API keys and provider configuration
+      global-settings.json     # Global settings
+      cline_mcp_settings.json  # MCP settings
+    teams/                     # Team state
+    sessions/                  # Session data
+    db/                        # SQLite databases (for example cron.db)
+    workflows/                 # Global workflows
+  rules/                       # Global rules
+  hooks/                       # Global hooks
+  skills/                      # Global skills
+  agents/                      # Global agent definitions
+  plugins/                     # Global plugins (.js, .ts)
+  cron/                        # Global cron specs
+```
+
+Additional global search paths supported by the code:
+
+```text
+~/Documents/Cline/
+  Rules/                       # Additional global rules
+  Hooks/                       # Additional global hooks
+  Plugins/                     # Additional global plugins
+  Workflows/                   # Additional global workflows
+```
+
+Project-level configuration lives in `.cline/` at your repository root:
+
+```text
+.cline/
+  rules/                       # Project rules
+  skills/                      # Project skills
+  hooks/                       # Lifecycle hooks
+  agents/                      # Project agent definitions
+  plugins/                     # Project plugins
+  cron/                        # Workspace cron specs
+```
+
+Notes:
+
+- Global provider settings, global settings, and MCP settings are stored under `~/.cline/data/settings/`.
+- Global workflows resolve from `~/.cline/data/workflows/`.
+- Global rules, hooks, skills, agents, plugins, and cron specs resolve directly under `~/.cline/`.
+- Rules, hooks, plugins, and workflows may also be discovered from `~/Documents/Cline/` for compatibility.
+
+## What Goes Where?
+
+- Use **global (`~/.cline/`)** for defaults shared across all Cline applications (IDE, CLI, SDK) on your machine.
+- Use **project (`.cline/`)** for team-shared behavior that should travel with the repo.
+
+Commit `.cline/` files you want to share with your team. Keep secrets out of the repo.
+
+## Configure Through the CLI
+
+Use the interactive config UI:
+
+```bash
+cline config
+```
+
+From there, you can view/edit:
+
+- Settings (global + workspace)
+- Rules
+- Skills
+- Hooks
+
+## Useful Configuration Commands
+
+Use a custom configuration directory:
+
+```bash
+cline --config /path/to/custom/config "your task"
+```
+
+Or via environment variable:
+
+```bash
+export CLINE_DATA_DIR=/custom/path/to/cline
+cline "your task"
+```
+
+View CLI logs when troubleshooting:
+
+```bash
+cline dev log
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `CLINE_DATA_DIR` | Custom data directory (replaces `~/.cline/data/`) |
+| `CLINE_HUB_ADDRESS` | Override hub address (default: `127.0.0.1:25463`) |
+| `CLINE_SESSION_BACKEND_MODE` | Force backend mode (`local`, `hub`, `remote`, `auto`) |
+| `CLINE_SANDBOX` | Enable sandbox mode |
+| `CLINE_SANDBOX_DATA_DIR` | Sandbox session storage directory |
+| `CLINE_HOOKS_DIR` | Additional hooks directory |
+| `CLINE_COMMAND_PERMISSIONS` | JSON policy restricting shell commands |
+
+### CLINE_DATA_DIR
+
+```bash
+export CLINE_DATA_DIR=/custom/path/to/cline
+cline "your task"
+```
+
+### CLINE_COMMAND_PERMISSIONS
+
+Restrict which shell commands Cline can execute:
+
+```bash
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *"], "deny": ["rm -rf *"]}'
+```
+
+Format:
+
+```json
+{
+  "allow": ["pattern1", "pattern2"],
+  "deny": ["pattern3"],
+  "allowRedirects": true
+}
+```
+
+Rules:
+
+- `deny` overrides `allow`
+- If `allow` is set, commands not matching `allow` are denied
+- `allowRedirects` controls shell redirects (`>`, `>>`, `<`), default `false`
+
+## Related Docs
+
+- [CLI Configuration](/cli/configuration)
+- [Rules](/customization/cline-rules)
+- [Skills](/customization/skills)
+- [Hooks](/customization/hooks)
+- [Plugins](/customization/plugins)
+- [.clineignore](/customization/clineignore)
+
+## Security Notes
+
+<Warning>
+Only use rules, hooks, skills, and plugins from sources you trust.
+</Warning>
+
+Hooks and plugins can execute code. Review them like any other executable artifact before adding them globally or to a project.
diff --git a/docs/getting-started/installing-cline.mdx b/docs/getting-started/installing-cline.mdx
new file mode 100644
index 0000000..b49f659
--- /dev/null
+++ b/docs/getting-started/installing-cline.mdx
@@ -0,0 +1,139 @@
+---
+title: "Installing Cline"
+description: "Choose your installation path: IDE Extension, CLI, SDK, or Kanban"
+---
+
+## Choose Your Install Path
+
+- [IDE Extension](#ide-extension) — VS Code, Cursor, JetBrains, Windsurf, VSCodium, Antigravity
+- [CLI](#cli) — terminal workflows
+- [Kanban](#kanban) (preview) — easily manage through multiple agents through a kanban board
+- [SDK](#sdk) — build with `@cline/sdk`
+
+## IDE Extension
+
+Use this if you want Cline inside your editor UI.
+
+<Tabs>
+  <Tab title="VS Code / Cursor / Windsurf / VSCodium / Antigravity">
+    <Steps>
+      <Step title="Open Extensions">
+        Press `Ctrl/Cmd + Shift + X`.
+      </Step>
+      <Step title="Search for Cline">
+        Type `Cline`.
+      </Step>
+      <Step title="Install">
+        Click **Install** on the Cline extension.
+      </Step>
+      <Step title="Open Cline">
+        Use the Cline activity bar icon, or run `Cline: Open In New Tab` from Command Palette.
+      </Step>
+      <Step title="Authorize with Cline">
+        After installing the extension, complete provider setup in Cline settings. Use the Cline Provider for pay-as-you-go access, ClinePass for a flat monthly subscription, or bring your own provider key.
+
+        [Authorize with Cline](/getting-started/authorizing-with-cline)
+      </Step>
+    </Steps>
+
+    <Note>
+    Windsurf and VSCodium use Open VSX. The install flow is the same.
+    </Note>
+  </Tab>
+
+  <Tab title="JetBrains">
+    <Steps>
+      <Step title="Open Plugins Marketplace">
+        **Settings** → **Plugins** → **Marketplace**.
+      </Step>
+      <Step title="Install Cline">
+        Search `Cline`, click **Install**, then restart the IDE.
+      </Step>
+      <Step title="Open Cline">
+        **View** → **Tool Windows** → **Cline**.
+      </Step>
+      <Step title="Authorize with Cline">
+        After installing the extension, complete provider setup in Cline settings. Use the Cline Provider for pay-as-you-go access, ClinePass for a flat monthly subscription, or bring your own provider key.
+
+        [Authorize with Cline](/getting-started/authorizing-with-cline)
+      </Step>
+    </Steps>
+
+    Alternative: install from the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/28247-cline).
+  </Tab>
+</Tabs>
+
+## CLI
+
+Use this if you want Cline in terminal workflows (interactive + automation).
+
+<Steps>
+  <Step title="Install Node.js">
+    Install Node.js 20+ (22 recommended).
+  </Step>
+  <Step title="Install CLI">
+    ```bash
+    npm install -g cline
+    ```
+  </Step>
+  <Step title="Authenticate">
+    ```bash
+    cline auth
+    ```
+  </Step>
+  <Step title="Run Cline">
+    ```bash
+    cline
+    # or
+    cline "your task"
+    ```
+  </Step>
+</Steps>
+
+More details: [CLI Installation & Setup](/usage/cli-overview)
+
+## Kanban
+
+Use this if you want task-board workflows with agent execution.
+
+<Steps>
+  <Step title="Install Node.js">
+    Install Node.js 18+.
+  </Step>
+  <Step title="Launch Kanban">
+    ```bash
+    npx kanban
+    ```
+  </Step>
+</Steps>
+
+More details: [Kanban](/usage/kanban)
+
+## SDK
+
+Use this if you are building your own app/agent on top of Cline.
+
+<Steps>
+  <Step title="Create project">
+    ```bash
+    mkdir my-agent && cd my-agent
+    npm init -y
+    ```
+  </Step>
+  <Step title="Install SDK">
+    ```bash
+    npm install @cline/sdk
+    ```
+  </Step>
+  <Step title="Build and run">
+    Browse SDK examples to run your first agent.
+  </Step>
+</Steps>
+
+Start here: [SDK Examples](/sdk/examples)
+
+
+## Need Help?
+
+- [Troubleshooting](/troubleshooting/networking-and-proxies)
+- [Discord community](https://discord.gg/cline)
diff --git a/docs/hubspot.js b/docs/hubspot.js
new file mode 100644
index 0000000..0d020cf
--- /dev/null
+++ b/docs/hubspot.js
@@ -0,0 +1,14 @@
+// HubSpot Tracking Code for Cline Documentation
+;(() => {
+	// Check if HubSpot script is already loaded to prevent duplicates
+	if (!document.getElementById("hs-script-loader")) {
+		var script = document.createElement("script")
+		script.type = "text/javascript"
+		script.id = "hs-script-loader"
+		script.async = true
+		script.src = "https://js-na2.hs-scripts.com/243656267.js"
+
+		// Append the script to the document head
+		document.head.appendChild(script)
+	}
+})()
diff --git a/docs/kanban/core-workflow.mdx b/docs/kanban/core-workflow.mdx
new file mode 100644
index 0000000..c1bbc2c
--- /dev/null
+++ b/docs/kanban/core-workflow.mdx
@@ -0,0 +1,81 @@
+---
+title: "Core Workflow"
+description: "The end-to-end workflow for using Cline Kanban: create tasks, run agents, review changes, and ship"
+---
+
+This guide walks through the typical Kanban workflow from start to finish.
+
+## 1. Create Tasks
+
+There are two ways to add tasks to the board:
+
+- **Manually** — click the add button and write a task description
+- **Via sidebar chat** — open the sidebar chat and ask the agent to break down a piece of work into tasks. The agent can create cards, link them together, and start work directly on the board.
+
+Each card on the board represents a discrete unit of work for an agent to complete.
+
+## 2. Link Tasks
+
+Link cards together to create dependency chains:
+
+- **⌘ + click** (Mac) / **Ctrl + click** (Windows/Linux) a card to link it to another task
+- When a linked card completes and is moved to trash, the next linked task **automatically starts**
+
+Combined with auto-commit, this enables fully autonomous chains where one task's output feeds into the next without manual intervention.
+
+## 3. Start Tasks
+
+Hit the **play button** on a card to start it. Here's what happens:
+
+1. Kanban creates an **ephemeral git worktree** for the task — an isolated copy of your repo where the agent can make changes without affecting your main working directory or other tasks
+2. Gitignored files like `node_modules` are **symlinked** from your main repo into the worktree, avoiding slow reinstalls for each task
+3. The agent starts working in its own terminal within that worktree
+4. The card displays the agent's **latest message or tool call** so you can monitor progress from the board
+
+Multiple tasks run in parallel, each in their own worktree, so agents never create merge conflicts with each other.
+
+<Warning>
+Symlinks work well for gitignored files that agents don't need to modify (like `node_modules`). If your workflow requires agents to modify gitignored files, be aware that changes will affect the symlink target (your main repo's copy).
+</Warning>
+
+## 4. Review Changes
+
+Click a card to open the detail view, which shows:
+
+- **The agent's TUI** — the full text interface showing the agent's conversation and actions
+- **A diff of all changes** in that worktree compared to your base branch
+
+The diff viewer includes a **checkpoint system** — you can see diffs scoped to specific message ranges, not just the full cumulative diff. This makes it easier to understand what changed and when.
+
+### Inline Comments
+
+Click on any line in the diff to leave a comment. Comments are sent back to the agent as feedback, letting you steer its work without rewriting the task description. This is useful for corrections like "use a different approach here" or "this edge case isn't handled."
+
+## 5. Ship It
+
+When you're satisfied with the changes, you have two options:
+
+- **Commit** — merges the worktree changes into a commit on your base branch
+- **Open PR** — creates a new branch and opens a pull request
+
+In both cases, Kanban sends a dynamic prompt to the agent to handle the operation. The agent converts the worktree into the appropriate git action and **intelligently handles merge conflicts** if the base branch has moved since the worktree was created.
+
+## 6. Clean Up
+
+After shipping, move the card to **trash** to clean up the ephemeral worktree and free disk space.
+
+<Tip>
+If you need to resume work on a trashed card later, Kanban provides a **resume ID** for each task. You can use this to pick up where you left off.
+</Tip>
+
+## Workflow Summary
+
+| Step | Action | What Happens |
+|------|--------|-------------|
+| Create | Add card or use sidebar chat | Task card appears on the board |
+| Link | ⌘ + click to connect cards | Dependency chain is established |
+| Start | Hit play on a card | Ephemeral worktree is created, agent begins work |
+| Monitor | Watch card status on board | Latest agent message/tool call shown on card |
+| Review | Click card to see diff | Full diff with checkpoints and inline commenting |
+| Ship | Click Commit or Open PR | Agent handles merge into base branch or creates PR |
+| Clean up | Move to trash | Worktree is removed, resume ID saved |
diff --git a/docs/kanban/remote-access.mdx b/docs/kanban/remote-access.mdx
new file mode 100644
index 0000000..c200a0b
--- /dev/null
+++ b/docs/kanban/remote-access.mdx
@@ -0,0 +1,285 @@
+---
+title: "Remote Access"
+description: "Access Kanban from other devices on your network or from anywhere using tunnels, VPNs, and cloud services"
+---
+
+By default, Kanban binds to `127.0.0.1:3484` and is only accessible from the machine it's running on. This guide shows how to enable remote access for mobile devices, remote machines, or team collaboration.
+
+<Warning>
+When exposing Kanban beyond localhost, ensure you trust all devices and users with access. Kanban provides full access to your git repository and terminal.
+</Warning>
+
+## Local Network Access
+
+To make Kanban accessible to other devices on your local network (like a phone or tablet on the same WiFi), bind to `0.0.0.0` instead of `127.0.0.1`.
+
+### Using CLI Flag
+
+```bash
+kanban --host 0.0.0.0
+```
+
+This makes Kanban available at `http://<your-machine-ip>:3484` from any device on your network.
+
+### Using Environment Variable
+
+```bash
+KANBAN_RUNTIME_HOST=0.0.0.0 cline
+```
+
+When you run `cline`, it will launch Kanban bound to `0.0.0.0`.
+
+<Warning>
+**Security Note**: Binding to `0.0.0.0` exposes Kanban to your entire local network. Only use this on networks you trust, such as your home WiFi.
+</Warning>
+
+## Tailscale (Recommended for Remote Access)
+
+Tailscale provides secure remote access without exposing ports to the internet. Once configured, you can access Kanban from your phone while on the road, from a coffee shop, or anywhere else.
+
+### Setup
+
+1. **Install Tailscale** on both your development machine and your phone/remote device
+2. **Sign in** to the same Tailscale account on both devices
+3. **Launch Kanban** with network binding:
+
+```bash
+KANBAN_RUNTIME_HOST=0.0.0.0 cline
+```
+
+4. **Access from your phone**: Navigate to your machine's Tailscale hostname on port 3484:
+
+```
+http://your-machine-name.tail1234.ts.net:3484
+```
+
+Your Tailscale hostname is visible in the Tailscale app or admin console.
+
+<Tip>
+Tailscale creates a secure mesh VPN, so your connection is encrypted and doesn't require opening any firewall ports. This is the safest option for remote access.
+</Tip>
+
+## Docker Deployment
+
+Run Kanban in a Docker container for isolated deployments or server environments.
+
+### Dockerfile
+
+```dockerfile
+FROM node:22
+
+WORKDIR /app
+
+EXPOSE 3484
+
+CMD ["npx", "--yes", "kanban@latest", "--host", "0.0.0.0"]
+```
+
+### Build and Run
+
+```bash
+docker build -t npx-kanban .
+docker run -it -p 3484:3484 npx-kanban
+```
+
+Then navigate to `http://localhost:3484` from your browser.
+
+<Tip>
+To access the Kanban container from other machines on your network, use `http://<docker-host-ip>:3484`.
+</Tip>
+
+## SSH Tunnel
+
+SSH tunneling creates a secure connection between your local machine and a remote server. This requires SSH access to the remote machine where Kanban is running.
+
+### Setup
+
+**On the remote machine**, run Kanban normally (it can bind to `127.0.0.1`):
+
+```bash
+kanban
+```
+
+**On your local machine**, create an SSH tunnel:
+
+```bash
+ssh -L 3484:localhost:3484 user@remote-hostname
+```
+
+Then navigate to `http://localhost:3484` in your local browser. The SSH tunnel securely forwards the connection to the remote machine.
+
+<Tip>
+Replace `user` with your SSH username and `remote-hostname` with the IP address or hostname of your remote machine. If using SSH keys, add `-i /path/to/key.pem` before the username.
+</Tip>
+
+## Ngrok
+
+Ngrok creates a public HTTPS URL that tunnels to your local Kanban instance. Useful for quick demos or sharing with collaborators.
+
+### Setup
+
+```bash
+# Install ngrok (macOS)
+brew install ngrok
+
+# Add your auth token (create a free account at ngrok.com)
+ngrok config add-authtoken $YOUR_AUTHTOKEN
+
+# Start Kanban
+kanban
+
+# In another terminal, create the tunnel
+ngrok http 3484
+```
+
+Ngrok will display a public URL like `https://1234-5678-9012.ngrok-free.app`. Share this URL to give others access to your Kanban board.
+
+<Warning>
+Ngrok URLs are publicly accessible on the internet. Anyone with the URL can access your Kanban board. Only use this for temporary access and stop the tunnel when finished.
+</Warning>
+
+## Cloudflare Tunnels
+
+Cloudflare Tunnels provide production-grade remote access with custom domains, access controls, and HTTPS.
+
+### Setup
+
+Follow the [Cloudflare Tunnel guide](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/get-started/create-remote-tunnel/) to create a tunnel. Then configure your application route with these settings:
+
+- **Hostname.subdomain**: Choose any subdomain (e.g., `kanban`)
+- **Hostname.Domain**: Your domain configured with Cloudflare
+- **Hostname.Path**: Leave empty
+- **Service.Type**: `HTTP`
+- **Service.URL**: `localhost:3484`
+
+### AWS CDK Example
+
+Deploy Kanban on EC2 with Cloudflare Tunnel using AWS CDK:
+
+```typescript
+import * as cdk from "aws-cdk-lib/core";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+import * as iam from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+
+export class KanbanEc2Stack extends cdk.Stack {
+    constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+        super(scope, id, props);
+
+        // Tunnel token from env or CDK context
+        const tunnelToken =
+            process.env.TUNNEL_TOKEN || this.node.tryGetContext("tunnelToken");
+        if (!tunnelToken) {
+            throw new Error(
+                "Missing tunnel token. Set TUNNEL_TOKEN env var or pass -c tunnelToken=xxx",
+            );
+        }
+
+        // VPC + Security Group
+        const vpc = ec2.Vpc.fromLookup(this, "DefaultVpc", { isDefault: true });
+
+        const sg = new ec2.SecurityGroup(this, "KanbanSg", {
+            vpc,
+            allowAllOutbound: true,
+            description: "Kanban EC2 security group",
+        });
+        sg.addIngressRule(ec2.Peer.myIp(), ec2.Port.tcp(22), "SSH access");
+
+        // User data script
+        const userData = ec2.UserData.forLinux();
+        userData.addCommands(
+            "set -x",
+            "exec > >(tee /var/log/user-data.log) 2>&1",
+
+            // 1) Install git and cloudflared first for tunnel connectivity
+            "sudo dnf install -y git",
+            "curl -L --output /tmp/cloudflared.rpm https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-x86_64.rpm",
+            "sudo yum localinstall -y /tmp/cloudflared.rpm",
+
+            // 2) Start cloudflared tunnel so the instance is reachable
+            `sudo cloudflared service install ${tunnelToken}`,
+
+            // 3) Install Node.js 22 via NodeSource
+            "curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo bash -",
+            "sudo dnf install -y nodejs",
+
+            // 4) Clone and build the app
+            "git clone -b main https://github.com/cline/kanban.git /opt/kanban",
+
+            // 5) Create systemd service for the kanban app
+            `cat > /etc/systemd/system/kanban.service << 'UNIT'
+[Unit]
+Description=Kanban App
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=/opt/kanban
+ExecStart=/usr/bin/kanban
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+Environment=HOME=/root
+Environment=PATH=/usr/bin:/usr/local/bin
+
+[Install]
+WantedBy=multi-user.target
+UNIT`,
+            "systemctl daemon-reload",
+            "systemctl enable --now kanban.service",
+        );
+
+        // IAM role with SSM access
+        const role = new iam.Role(this, "KanbanInstanceRole", {
+            assumedBy: new iam.ServicePrincipal("ec2.amazonaws.com"),
+            managedPolicies: [
+                iam.ManagedPolicy.fromAwsManagedPolicyName(
+                    "AmazonSSMManagedInstanceCore",
+                ),
+            ],
+        });
+
+        // EC2 Instance
+        const instance = new ec2.Instance(this, "KanbanInstance", {
+            vpc,
+            instanceType: ec2.InstanceType.of(
+                ec2.InstanceClass.T3,
+                ec2.InstanceSize.SMALL,
+            ),
+            machineImage: ec2.MachineImage.latestAmazonLinux2023(),
+            securityGroup: sg,
+            vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },
+            associatePublicIpAddress: true,
+            userData,
+            role,
+        });
+
+        // Outputs
+        new cdk.CfnOutput(this, "InstanceId", { value: instance.instanceId });
+        new cdk.CfnOutput(this, "PublicIp", {
+            value: instance.instancePublicIp,
+        });
+    }
+}
+```
+
+Deploy with:
+
+```bash
+TUNNEL_TOKEN=<your_tunnel_token> cdk deploy
+```
+
+## Summary
+
+| Method | Security | Complexity | Use Case |
+|--------|----------|------------|----------|
+| **Local Network** | Low (LAN only) | Easy | Phone/tablet on same WiFi |
+| **Tailscale** | High (encrypted VPN) | Easy | Remote access from anywhere |
+| **Docker** | Medium (isolated) | Medium | Server deployments |
+| **SSH Tunnel** | High (encrypted) | Medium | Secure remote access |
+| **Ngrok** | Low (public URL) | Easy | Temporary demos/sharing |
+| **Cloudflare** | High (custom domain) | Complex | Production deployments |
+
+<Tip>
+For personal remote access, **Tailscale** offers the best balance of security and ease of use. For production team access, consider **Cloudflare Tunnels** with access controls.
+</Tip>
diff --git a/docs/mcp/mcp-overview.mdx b/docs/mcp/mcp-overview.mdx
new file mode 100644
index 0000000..5242079
--- /dev/null
+++ b/docs/mcp/mcp-overview.mdx
@@ -0,0 +1,147 @@
+---
+title: "MCP"
+sidebarTitle: "MCP"
+description: "Add, configure, and use MCP servers in Cline."
+---
+
+MCP (Model Context Protocol) lets Cline use external tools and data sources through MCP servers.
+
+## What MCP gives you
+
+- Connect Cline to external APIs and services
+- Add custom tools beyond built-in Cline tools
+- Use either local servers or remote hosted servers
+
+## Quick start
+
+1. Open **MCP Servers** in Cline
+2. Add a local server manually, or connect to a hosted remote server
+3. Configure credentials/environment variables
+4. Verify tools appear and test one tool call
+
+## Add servers
+
+### Manual config
+
+Edit your MCP config file and add either:
+
+- **CLI:** `~/.cline/mcp.json`
+- **IDE extensions:**
+  1. In the Cline panel, click the **MCP Servers** icon (stacked server icon in the top toolbar).
+  2. Open the **Configure** tab.
+  3. Click **Configure MCP Servers** (button near the bottom).
+  4. This opens the MCP settings JSON used by the extension; add/update entries under `mcpServers`.
+  - If you're adding a hosted endpoint (instead of editing JSON directly), use the **Remote Servers** tab:
+    1. Enter **Server Name** (any unique label).
+    2. Enter **Server URL** (full endpoint URL).
+    3. Choose **Transport Type**:
+       - **Streamable HTTP** (recommended)
+       - **SSE (Legacy)**
+    4. Click **Add Server**.
+
+  - Server config shape:
+    - **Local (STDIO)** server using `command` + `args`
+    - **Remote (HTTP/SSE)** server using `url`
+
+### CLI MCP wizard
+
+From CLI, run:
+
+```bash
+cline mcp
+```
+
+The wizard supports:
+
+| Action | Description |
+|---|---|
+| List servers | Show configured servers and enabled/disabled status |
+| Add server | Create a new MCP server entry |
+| Edit server | Modify an existing server |
+| Enable/Disable | Toggle a server without deleting it |
+| Delete server | Remove a server permanently |
+
+When adding a server, the CLI prompts for server name, transport type, command/args (for stdio), or URL/headers (for remote transports).
+
+## Configuration examples
+
+### Local server (STDIO)
+
+```json
+{
+  "mcpServers": {
+    "local-server": {
+      "command": "node",
+      "args": ["/path/to/server.js"],
+      "env": {
+        "API_KEY": "your_api_key"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+### Remote server (Streamable HTTP)
+
+```json
+{
+  "mcpServers": {
+    "remote-server": {
+      "type": "streamableHttp",
+      "url": "https://example.com/mcp",
+      "headers": {
+        "Authorization": "Bearer your-token"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+The `type` field selects the transport. Omitting it defaults to the legacy `sse` transport for backward compatibility, so set `"type": "streamableHttp"` explicitly for the recommended transport. Use `"type": "sse"` only for legacy SSE servers.
+
+## Transport types
+
+- **STDIO**: local process, lower latency, simpler local setup
+- **Remote HTTP/SSE**: hosted endpoint, centralized deployment, supports multi-client usage
+
+Use STDIO for local tools and remote transport for shared hosted services.
+
+## Managing servers
+
+In MCP settings you can:
+
+- Enable/disable servers
+- Restart unresponsive servers
+- Set request timeouts
+- Remove servers
+
+## Security basics
+
+- Only install servers you trust
+- Store secrets in environment variables
+- Limit `autoApprove` to safe tools
+- Review tool calls before approval
+
+## Troubleshooting
+
+| Issue | Fix |
+|---|---|
+| Server won't connect | Verify command/URL, server process status, and port |
+| Missing tools | Confirm server started successfully and tools are exposed |
+| Auth errors | Re-check API keys/tokens and required headers |
+| Timeout errors | Increase MCP timeout and test server response directly |
+
+## CLI
+
+MCP also works in Cline CLI. Configure servers in CLI MCP settings and use the same server definitions.
+
+You can also list servers non-interactively:
+
+```bash
+cline config mcp
+cline config mcp --json
+```
diff --git a/docs/package-lock.json b/docs/package-lock.json
new file mode 100644
index 0000000..d996ca6
--- /dev/null
+++ b/docs/package-lock.json
@@ -0,0 +1,13286 @@
+{
+	"name": "docs",
+	"version": "1.0.0",
+	"lockfileVersion": 3,
+	"requires": true,
+	"packages": {
+		"": {
+			"name": "docs",
+			"version": "1.0.0",
+			"license": "ISC",
+			"dependencies": {
+				"mintlify": "^4.2.338"
+			}
+		},
+		"node_modules/@alcalzone/ansi-tokenize": {
+			"version": "0.2.4",
+			"resolved": "https://registry.npmjs.org/@alcalzone/ansi-tokenize/-/ansi-tokenize-0.2.4.tgz",
+			"integrity": "sha512-HTgrrTgZ9Jgeo6Z3oqbQ7lifOVvRR14vaDuBGPPUxk9Thm+vObaO4QfYYYWw4Zo5CWQDBEfsinFA6Gre+AqwNQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^6.2.1",
+				"is-fullwidth-code-point": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/@alloc/quick-lru": {
+			"version": "5.2.0",
+			"resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
+			"integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/@ark/schema": {
+			"version": "0.55.0",
+			"resolved": "https://registry.npmjs.org/@ark/schema/-/schema-0.55.0.tgz",
+			"integrity": "sha512-IlSIc0FmLKTDGr4I/FzNHauMn0MADA6bCjT1wauu4k6MyxhC1R9gz0olNpIRvK7lGGDwtc/VO0RUDNvVQW5WFg==",
+			"license": "MIT",
+			"dependencies": {
+				"@ark/util": "0.55.0"
+			}
+		},
+		"node_modules/@ark/util": {
+			"version": "0.55.0",
+			"resolved": "https://registry.npmjs.org/@ark/util/-/util-0.55.0.tgz",
+			"integrity": "sha512-aWFNK7aqSvqFtVsl1xmbTjGbg91uqtJV7Za76YGNEwIO4qLjMfyY8flmmbhooYMuqPCO2jyxu8hve943D+w3bA==",
+			"license": "MIT"
+		},
+		"node_modules/@asyncapi/parser": {
+			"version": "3.4.0",
+			"resolved": "https://registry.npmjs.org/@asyncapi/parser/-/parser-3.4.0.tgz",
+			"integrity": "sha512-Sxn74oHiZSU6+cVeZy62iPZMFMvKp4jupMFHelSICCMw1qELmUHPvuZSr+ZHDmNGgHcEpzJM5HN02kR7T4g+PQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@asyncapi/specs": "^6.8.0",
+				"@openapi-contrib/openapi-schema-to-json-schema": "~3.2.0",
+				"@stoplight/json": "3.21.0",
+				"@stoplight/json-ref-readers": "^1.2.2",
+				"@stoplight/json-ref-resolver": "^3.1.5",
+				"@stoplight/spectral-core": "^1.18.3",
+				"@stoplight/spectral-functions": "^1.7.2",
+				"@stoplight/spectral-parsers": "^1.0.2",
+				"@stoplight/spectral-ref-resolver": "^1.0.3",
+				"@stoplight/types": "^13.12.0",
+				"@types/json-schema": "^7.0.11",
+				"@types/urijs": "^1.19.19",
+				"ajv": "^8.17.1",
+				"ajv-errors": "^3.0.0",
+				"ajv-formats": "^2.1.1",
+				"avsc": "^5.7.5",
+				"js-yaml": "^4.1.0",
+				"jsonpath-plus": "^10.0.0",
+				"node-fetch": "2.6.7"
+			}
+		},
+		"node_modules/@asyncapi/specs": {
+			"version": "6.8.1",
+			"resolved": "https://registry.npmjs.org/@asyncapi/specs/-/specs-6.8.1.tgz",
+			"integrity": "sha512-czHoAk3PeXTLR+X8IUaD+IpT+g+zUvkcgMDJVothBsan+oHN3jfcFcFUNdOPAAFoUCQN1hXF1dWuphWy05THlA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@types/json-schema": "^7.0.11"
+			}
+		},
+		"node_modules/@babel/code-frame": {
+			"version": "7.29.0",
+			"resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+			"integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+			"license": "MIT",
+			"dependencies": {
+				"@babel/helper-validator-identifier": "^7.28.5",
+				"js-tokens": "^4.0.0",
+				"picocolors": "^1.1.1"
+			},
+			"engines": {
+				"node": ">=6.9.0"
+			}
+		},
+		"node_modules/@babel/helper-validator-identifier": {
+			"version": "7.28.5",
+			"resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+			"integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6.9.0"
+			}
+		},
+		"node_modules/@canvas/image-data": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@canvas/image-data/-/image-data-1.1.0.tgz",
+			"integrity": "sha512-QdObRRjRbcXGmM1tmJ+MrHcaz1MftF2+W7YI+MsphnsCrmtyfS0d5qJbk0MeSbUeyM/jCb0hmnkXPsy026L7dA==",
+			"license": "MIT"
+		},
+		"node_modules/@emnapi/runtime": {
+			"version": "1.8.1",
+			"resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.8.1.tgz",
+			"integrity": "sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg==",
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/@emnapi/runtime/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"optional": true
+		},
+		"node_modules/@floating-ui/core": {
+			"version": "1.7.4",
+			"resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.4.tgz",
+			"integrity": "sha512-C3HlIdsBxszvm5McXlB8PeOEWfBhcGBTZGkGlWc2U0KFY5IwG5OQEuQ8rq52DZmcHDlPLd+YFBK+cZcytwIFWg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/utils": "^0.2.10"
+			}
+		},
+		"node_modules/@floating-ui/dom": {
+			"version": "1.7.5",
+			"resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.5.tgz",
+			"integrity": "sha512-N0bD2kIPInNHUHehXhMke1rBGs1dwqvC9O9KYMyyjK7iXt7GAhnro7UlcuYcGdS/yYOlq0MAVgrow8IbWJwyqg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/core": "^1.7.4",
+				"@floating-ui/utils": "^0.2.10"
+			}
+		},
+		"node_modules/@floating-ui/utils": {
+			"version": "0.2.10",
+			"resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.10.tgz",
+			"integrity": "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ==",
+			"license": "MIT",
+			"peer": true
+		},
+		"node_modules/@img/sharp-darwin-arm64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.33.5.tgz",
+			"integrity": "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==",
+			"cpu": [
+				"arm64"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"darwin"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-darwin-arm64": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-darwin-x64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.33.5.tgz",
+			"integrity": "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==",
+			"cpu": [
+				"x64"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"darwin"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-darwin-x64": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-libvips-darwin-arm64": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.0.4.tgz",
+			"integrity": "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==",
+			"cpu": [
+				"arm64"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"darwin"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-darwin-x64": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.0.4.tgz",
+			"integrity": "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==",
+			"cpu": [
+				"x64"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"darwin"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-linux-arm": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.0.5.tgz",
+			"integrity": "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==",
+			"cpu": [
+				"arm"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-linux-arm64": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.0.4.tgz",
+			"integrity": "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==",
+			"cpu": [
+				"arm64"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-linux-s390x": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.0.4.tgz",
+			"integrity": "sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==",
+			"cpu": [
+				"s390x"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-linux-x64": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.0.4.tgz",
+			"integrity": "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==",
+			"cpu": [
+				"x64"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.0.4.tgz",
+			"integrity": "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==",
+			"cpu": [
+				"arm64"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-libvips-linuxmusl-x64": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.0.4.tgz",
+			"integrity": "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==",
+			"cpu": [
+				"x64"
+			],
+			"license": "LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-linux-arm": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.33.5.tgz",
+			"integrity": "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==",
+			"cpu": [
+				"arm"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-linux-arm": "1.0.5"
+			}
+		},
+		"node_modules/@img/sharp-linux-arm64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.33.5.tgz",
+			"integrity": "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==",
+			"cpu": [
+				"arm64"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-linux-arm64": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-linux-s390x": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.33.5.tgz",
+			"integrity": "sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==",
+			"cpu": [
+				"s390x"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-linux-s390x": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-linux-x64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.33.5.tgz",
+			"integrity": "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==",
+			"cpu": [
+				"x64"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-linux-x64": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-linuxmusl-arm64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.33.5.tgz",
+			"integrity": "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==",
+			"cpu": [
+				"arm64"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-linuxmusl-arm64": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-linuxmusl-x64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.33.5.tgz",
+			"integrity": "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==",
+			"cpu": [
+				"x64"
+			],
+			"license": "Apache-2.0",
+			"optional": true,
+			"os": [
+				"linux"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-libvips-linuxmusl-x64": "1.0.4"
+			}
+		},
+		"node_modules/@img/sharp-wasm32": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.33.5.tgz",
+			"integrity": "sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==",
+			"cpu": [
+				"wasm32"
+			],
+			"license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+			"optional": true,
+			"dependencies": {
+				"@emnapi/runtime": "^1.2.0"
+			},
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-win32-ia32": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.33.5.tgz",
+			"integrity": "sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==",
+			"cpu": [
+				"ia32"
+			],
+			"license": "Apache-2.0 AND LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"win32"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@img/sharp-win32-x64": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.33.5.tgz",
+			"integrity": "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==",
+			"cpu": [
+				"x64"
+			],
+			"license": "Apache-2.0 AND LGPL-3.0-or-later",
+			"optional": true,
+			"os": [
+				"win32"
+			],
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			}
+		},
+		"node_modules/@inquirer/ansi": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-1.0.2.tgz",
+			"integrity": "sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/@inquirer/checkbox": {
+			"version": "4.3.2",
+			"resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-4.3.2.tgz",
+			"integrity": "sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/ansi": "^1.0.2",
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/figures": "^1.0.15",
+				"@inquirer/type": "^3.0.10",
+				"yoctocolors-cjs": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/confirm": {
+			"version": "5.1.21",
+			"resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-5.1.21.tgz",
+			"integrity": "sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/type": "^3.0.10"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/core": {
+			"version": "10.3.2",
+			"resolved": "https://registry.npmjs.org/@inquirer/core/-/core-10.3.2.tgz",
+			"integrity": "sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/ansi": "^1.0.2",
+				"@inquirer/figures": "^1.0.15",
+				"@inquirer/type": "^3.0.10",
+				"cli-width": "^4.1.0",
+				"mute-stream": "^2.0.0",
+				"signal-exit": "^4.1.0",
+				"wrap-ansi": "^6.2.0",
+				"yoctocolors-cjs": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/editor": {
+			"version": "4.2.23",
+			"resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-4.2.23.tgz",
+			"integrity": "sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/external-editor": "^1.0.3",
+				"@inquirer/type": "^3.0.10"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/expand": {
+			"version": "4.0.23",
+			"resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-4.0.23.tgz",
+			"integrity": "sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/type": "^3.0.10",
+				"yoctocolors-cjs": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/external-editor": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz",
+			"integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==",
+			"license": "MIT",
+			"dependencies": {
+				"chardet": "^2.1.1",
+				"iconv-lite": "^0.7.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/figures": {
+			"version": "1.0.15",
+			"resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.15.tgz",
+			"integrity": "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/@inquirer/input": {
+			"version": "4.3.1",
+			"resolved": "https://registry.npmjs.org/@inquirer/input/-/input-4.3.1.tgz",
+			"integrity": "sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/type": "^3.0.10"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/number": {
+			"version": "3.0.23",
+			"resolved": "https://registry.npmjs.org/@inquirer/number/-/number-3.0.23.tgz",
+			"integrity": "sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/type": "^3.0.10"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/password": {
+			"version": "4.0.23",
+			"resolved": "https://registry.npmjs.org/@inquirer/password/-/password-4.0.23.tgz",
+			"integrity": "sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/ansi": "^1.0.2",
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/type": "^3.0.10"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/prompts": {
+			"version": "7.9.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-7.9.0.tgz",
+			"integrity": "sha512-X7/+dG9SLpSzRkwgG5/xiIzW0oMrV3C0HOa7YHG1WnrLK+vCQHfte4k/T80059YBdei29RBC3s+pSMvPJDU9/A==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/checkbox": "^4.3.0",
+				"@inquirer/confirm": "^5.1.19",
+				"@inquirer/editor": "^4.2.21",
+				"@inquirer/expand": "^4.0.21",
+				"@inquirer/input": "^4.2.5",
+				"@inquirer/number": "^3.0.21",
+				"@inquirer/password": "^4.0.21",
+				"@inquirer/rawlist": "^4.1.9",
+				"@inquirer/search": "^3.2.0",
+				"@inquirer/select": "^4.4.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/rawlist": {
+			"version": "4.1.11",
+			"resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-4.1.11.tgz",
+			"integrity": "sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/type": "^3.0.10",
+				"yoctocolors-cjs": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/search": {
+			"version": "3.2.2",
+			"resolved": "https://registry.npmjs.org/@inquirer/search/-/search-3.2.2.tgz",
+			"integrity": "sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/figures": "^1.0.15",
+				"@inquirer/type": "^3.0.10",
+				"yoctocolors-cjs": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/select": {
+			"version": "4.4.2",
+			"resolved": "https://registry.npmjs.org/@inquirer/select/-/select-4.4.2.tgz",
+			"integrity": "sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/ansi": "^1.0.2",
+				"@inquirer/core": "^10.3.2",
+				"@inquirer/figures": "^1.0.15",
+				"@inquirer/type": "^3.0.10",
+				"yoctocolors-cjs": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@inquirer/type": {
+			"version": "3.0.10",
+			"resolved": "https://registry.npmjs.org/@inquirer/type/-/type-3.0.10.tgz",
+			"integrity": "sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			},
+			"peerDependenciesMeta": {
+				"@types/node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@jridgewell/gen-mapping": {
+			"version": "0.3.13",
+			"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+			"integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/sourcemap-codec": "^1.5.0",
+				"@jridgewell/trace-mapping": "^0.3.24"
+			}
+		},
+		"node_modules/@jridgewell/resolve-uri": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+			"integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/@jridgewell/sourcemap-codec": {
+			"version": "1.5.5",
+			"resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+			"integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+			"license": "MIT"
+		},
+		"node_modules/@jridgewell/trace-mapping": {
+			"version": "0.3.31",
+			"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+			"integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/resolve-uri": "^3.1.0",
+				"@jridgewell/sourcemap-codec": "^1.4.14"
+			}
+		},
+		"node_modules/@jsep-plugin/assignment": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/@jsep-plugin/assignment/-/assignment-1.3.0.tgz",
+			"integrity": "sha512-VVgV+CXrhbMI3aSusQyclHkenWSAm95WaiKrMxRFam3JSUiIaQjoMIw2sEs/OX4XifnqeQUN4DYbJjlA8EfktQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.16.0"
+			},
+			"peerDependencies": {
+				"jsep": "^0.4.0||^1.0.0"
+			}
+		},
+		"node_modules/@jsep-plugin/regex": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@jsep-plugin/regex/-/regex-1.0.4.tgz",
+			"integrity": "sha512-q7qL4Mgjs1vByCaTnDFcBnV9HS7GVPJX5vyVoCgZHNSC9rjwIlmbXG5sUuorR5ndfHAIlJ8pVStxvjXHbNvtUg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.16.0"
+			},
+			"peerDependencies": {
+				"jsep": "^0.4.0||^1.0.0"
+			}
+		},
+		"node_modules/@jsep-plugin/ternary": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/@jsep-plugin/ternary/-/ternary-1.1.4.tgz",
+			"integrity": "sha512-ck5wiqIbqdMX6WRQztBL7ASDty9YLgJ3sSAK5ZpBzXeySvFGCzIvM6UiAI4hTZ22fEcYQVV/zhUbNscggW+Ukg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.16.0"
+			},
+			"peerDependencies": {
+				"jsep": "^0.4.0||^1.0.0"
+			}
+		},
+		"node_modules/@leichtgewicht/ip-codec": {
+			"version": "2.0.5",
+			"resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz",
+			"integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==",
+			"license": "MIT"
+		},
+		"node_modules/@mdx-js/mdx": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.1.1.tgz",
+			"integrity": "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdx": "^2.0.0",
+				"acorn": "^8.0.0",
+				"collapse-white-space": "^2.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-is-identifier-name": "^3.0.0",
+				"estree-util-scope": "^1.0.0",
+				"estree-walker": "^3.0.0",
+				"hast-util-to-jsx-runtime": "^2.0.0",
+				"markdown-extensions": "^2.0.0",
+				"recma-build-jsx": "^1.0.0",
+				"recma-jsx": "^1.0.0",
+				"recma-stringify": "^1.0.0",
+				"rehype-recma": "^1.0.0",
+				"remark-mdx": "^3.0.0",
+				"remark-parse": "^11.0.0",
+				"remark-rehype": "^11.0.0",
+				"source-map": "^0.7.0",
+				"unified": "^11.0.0",
+				"unist-util-position-from-estree": "^2.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"unist-util-visit": "^5.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mdx-js/react": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz",
+			"integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdx": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			},
+			"peerDependencies": {
+				"@types/react": ">=16",
+				"react": ">=16"
+			}
+		},
+		"node_modules/@mintlify/cli": {
+			"version": "4.0.942",
+			"resolved": "https://registry.npmjs.org/@mintlify/cli/-/cli-4.0.942.tgz",
+			"integrity": "sha512-kxWLWC9CKKGvLFM8t8gT7a7R9dfvW8B7/og8a18tn29tIYe0p/JId7SWdPSbDfzI78KbcSNvTd0vnPzyAqC9Lg==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@inquirer/prompts": "7.9.0",
+				"@mintlify/common": "1.0.719",
+				"@mintlify/link-rot": "3.0.879",
+				"@mintlify/models": "0.0.270",
+				"@mintlify/prebuild": "1.0.855",
+				"@mintlify/previewing": "4.0.912",
+				"@mintlify/validation": "0.1.589",
+				"adm-zip": "0.5.16",
+				"chalk": "5.2.0",
+				"color": "4.2.3",
+				"detect-port": "1.5.1",
+				"front-matter": "4.0.2",
+				"fs-extra": "11.2.0",
+				"ink": "6.3.0",
+				"inquirer": "12.3.0",
+				"js-yaml": "4.1.0",
+				"mdast-util-mdx-jsx": "3.2.0",
+				"react": "19.2.3",
+				"semver": "7.7.2",
+				"unist-util-visit": "5.0.0",
+				"yargs": "17.7.1"
+			},
+			"bin": {
+				"mint": "bin/index.js",
+				"mintlify": "bin/index.js"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/common": {
+			"version": "1.0.719",
+			"resolved": "https://registry.npmjs.org/@mintlify/common/-/common-1.0.719.tgz",
+			"integrity": "sha512-QLQqQfdY+UtP0M020kQL9bhs9NoCcW7BHrp6E8QfSb7RCEVyEtN9rNx9vYvemwsJkIwM0h/Gb/G5FCLVUj6S7g==",
+			"license": "ISC",
+			"dependencies": {
+				"@asyncapi/parser": "3.4.0",
+				"@asyncapi/specs": "6.8.1",
+				"@mintlify/mdx": "^3.0.4",
+				"@mintlify/models": "0.0.270",
+				"@mintlify/openapi-parser": "^0.0.8",
+				"@mintlify/validation": "0.1.589",
+				"@sindresorhus/slugify": "2.2.0",
+				"@types/mdast": "4.0.4",
+				"acorn": "8.11.2",
+				"acorn-jsx": "5.3.2",
+				"color-blend": "4.0.0",
+				"estree-util-to-js": "2.0.0",
+				"estree-walker": "3.0.3",
+				"front-matter": "4.0.2",
+				"hast-util-from-html": "2.0.3",
+				"hast-util-to-html": "9.0.4",
+				"hast-util-to-text": "4.0.2",
+				"hex-rgb": "5.0.0",
+				"ignore": "7.0.5",
+				"js-yaml": "4.1.0",
+				"lodash": "4.17.21",
+				"mdast-util-from-markdown": "2.0.2",
+				"mdast-util-gfm": "3.0.0",
+				"mdast-util-mdx": "3.0.0",
+				"mdast-util-mdx-jsx": "3.1.3",
+				"micromark-extension-gfm": "3.0.0",
+				"micromark-extension-mdx-jsx": "3.0.1",
+				"micromark-extension-mdxjs": "3.0.0",
+				"openapi-types": "12.1.3",
+				"postcss": "8.5.6",
+				"rehype-stringify": "10.0.1",
+				"remark": "15.0.1",
+				"remark-frontmatter": "5.0.0",
+				"remark-gfm": "4.0.0",
+				"remark-math": "6.0.0",
+				"remark-mdx": "3.1.0",
+				"remark-parse": "11.0.0",
+				"remark-rehype": "11.1.1",
+				"remark-stringify": "11.0.0",
+				"tailwindcss": "3.4.4",
+				"unified": "11.0.5",
+				"unist-builder": "4.0.0",
+				"unist-util-map": "4.0.0",
+				"unist-util-remove": "4.0.0",
+				"unist-util-remove-position": "5.0.0",
+				"unist-util-visit": "5.0.0",
+				"unist-util-visit-parents": "6.0.1",
+				"vfile": "6.0.3"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@floating-ui/react-dom": {
+			"version": "2.1.7",
+			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
+			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/dom": "^1.7.5"
+			},
+			"peerDependencies": {
+				"react": ">=16.8.0",
+				"react-dom": ">=16.8.0"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@mintlify/mdx": {
+			"version": "3.0.4",
+			"resolved": "https://registry.npmjs.org/@mintlify/mdx/-/mdx-3.0.4.tgz",
+			"integrity": "sha512-tJhdpnM5ReJLNJ2fuDRIEr0zgVd6id7/oAIfs26V46QlygiLsc8qx4Rz3LWIX51rUXW/cfakjj0EATxIciIw+g==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/transformers": "^3.11.0",
+				"@shikijs/twoslash": "^3.12.2",
+				"arktype": "^2.1.26",
+				"hast-util-to-string": "^3.0.1",
+				"mdast-util-from-markdown": "^2.0.2",
+				"mdast-util-gfm": "^3.1.0",
+				"mdast-util-mdx-jsx": "^3.2.0",
+				"mdast-util-to-hast": "^13.2.0",
+				"next-mdx-remote-client": "^1.0.3",
+				"rehype-katex": "^7.0.1",
+				"remark-gfm": "^4.0.0",
+				"remark-math": "^6.0.0",
+				"remark-smartypants": "^3.0.2",
+				"shiki": "^3.11.0",
+				"unified": "^11.0.0",
+				"unist-util-visit": "^5.0.0"
+			},
+			"peerDependencies": {
+				"@radix-ui/react-popover": "^1.1.15",
+				"react": "^18.3.1",
+				"react-dom": "^18.3.1"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@mintlify/mdx/node_modules/mdast-util-gfm": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+			"integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-gfm-autolink-literal": "^2.0.0",
+				"mdast-util-gfm-footnote": "^2.0.0",
+				"mdast-util-gfm-strikethrough": "^2.0.0",
+				"mdast-util-gfm-table": "^2.0.0",
+				"mdast-util-gfm-task-list-item": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@mintlify/mdx/node_modules/mdast-util-mdx-jsx": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+			"integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"parse-entities": "^4.0.0",
+				"stringify-entities": "^4.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-arrow": {
+			"version": "1.1.7",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
+			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-primitive": "2.1.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-dismissable-layer": {
+			"version": "1.1.11",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/primitive": "1.1.3",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1",
+				"@radix-ui/react-use-escape-keydown": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-focus-scope": {
+			"version": "1.1.7",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
+			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-popover": {
+			"version": "1.1.15",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
+			"integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/primitive": "1.1.3",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-context": "1.1.2",
+				"@radix-ui/react-dismissable-layer": "1.1.11",
+				"@radix-ui/react-focus-guards": "1.1.3",
+				"@radix-ui/react-focus-scope": "1.1.7",
+				"@radix-ui/react-id": "1.1.1",
+				"@radix-ui/react-popper": "1.2.8",
+				"@radix-ui/react-portal": "1.1.9",
+				"@radix-ui/react-presence": "1.1.5",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-slot": "1.2.3",
+				"@radix-ui/react-use-controllable-state": "1.2.2",
+				"aria-hidden": "^1.2.4",
+				"react-remove-scroll": "^2.6.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-popper": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/react-dom": "^2.0.0",
+				"@radix-ui/react-arrow": "1.1.7",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-context": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1",
+				"@radix-ui/react-use-layout-effect": "1.1.1",
+				"@radix-ui/react-use-rect": "1.1.1",
+				"@radix-ui/react-use-size": "1.1.1",
+				"@radix-ui/rect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-portal": {
+			"version": "1.1.9",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
+			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-presence": {
+			"version": "1.1.5",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/@radix-ui/react-primitive": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
+			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-slot": "1.2.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/mdast-util-mdx-jsx": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
+			"integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"parse-entities": "^4.0.0",
+				"stringify-entities": "^4.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/next-mdx-remote-client": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.4.tgz",
+			"integrity": "sha512-psCMdO50tfoT1kAH7OGXZvhyRfiHVK6IqwjmWFV5gtLo4dnqjAgcjcLNeJ92iI26UNlKShxYrBs1GQ6UXxk97A==",
+			"license": "MPL 2.0",
+			"dependencies": {
+				"@babel/code-frame": "^7.27.1",
+				"@mdx-js/mdx": "^3.1.1",
+				"@mdx-js/react": "^3.1.1",
+				"remark-mdx-remove-esm": "^1.2.1",
+				"serialize-error": "^12.0.0",
+				"vfile": "^6.0.3",
+				"vfile-matter": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=18.18.0"
+			},
+			"peerDependencies": {
+				"react": ">= 18.3.0 < 19.0.0",
+				"react-dom": ">= 18.3.0 < 19.0.0"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/react": {
+			"version": "18.3.1",
+			"resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+			"integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/react-dom": {
+			"version": "18.3.1",
+			"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+			"integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0",
+				"scheduler": "^0.23.2"
+			},
+			"peerDependencies": {
+				"react": "^18.3.1"
+			}
+		},
+		"node_modules/@mintlify/common/node_modules/scheduler": {
+			"version": "0.23.2",
+			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+			"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0"
+			}
+		},
+		"node_modules/@mintlify/link-rot": {
+			"version": "3.0.879",
+			"resolved": "https://registry.npmjs.org/@mintlify/link-rot/-/link-rot-3.0.879.tgz",
+			"integrity": "sha512-ZJeMcQ2Yx+Qk4IQnt8kAW+jElLsSs9dZJRF/m5S893TAHJknBHfJQ4H2a751wKukfMfSzSLCNTEph3WYQHyzKQ==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/common": "1.0.719",
+				"@mintlify/prebuild": "1.0.855",
+				"@mintlify/previewing": "4.0.912",
+				"@mintlify/scraping": "4.0.522",
+				"@mintlify/validation": "0.1.589",
+				"fs-extra": "11.1.0",
+				"unist-util-visit": "4.1.2"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/link-rot/node_modules/@types/unist": {
+			"version": "2.0.11",
+			"resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+			"integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+			"license": "MIT"
+		},
+		"node_modules/@mintlify/link-rot/node_modules/fs-extra": {
+			"version": "11.1.0",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
+			"integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/@mintlify/link-rot/node_modules/unist-util-is": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
+			"integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/link-rot/node_modules/unist-util-visit": {
+			"version": "4.1.2",
+			"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
+			"integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"unist-util-is": "^5.0.0",
+				"unist-util-visit-parents": "^5.1.1"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/link-rot/node_modules/unist-util-visit-parents": {
+			"version": "5.1.3",
+			"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
+			"integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"unist-util-is": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/models": {
+			"version": "0.0.270",
+			"resolved": "https://registry.npmjs.org/@mintlify/models/-/models-0.0.270.tgz",
+			"integrity": "sha512-pVh+w17RiYn31Vij4U8cyQhLGpn9HdaSsq/8ttxpgIXUC4lfvumL4TyFjuoxLX/kt5ex+W1p0Bwd03NWSgg0Hg==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"axios": "1.13.2",
+				"openapi-types": "12.1.3"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/openapi-parser": {
+			"version": "0.0.8",
+			"resolved": "https://registry.npmjs.org/@mintlify/openapi-parser/-/openapi-parser-0.0.8.tgz",
+			"integrity": "sha512-9MBRq9lS4l4HITYCrqCL7T61MOb20q9IdU7HWhqYMNMM1jGO1nHjXasFy61yZ8V6gMZyyKQARGVoZ0ZrYN48Og==",
+			"license": "MIT",
+			"dependencies": {
+				"ajv": "^8.17.1",
+				"ajv-draft-04": "^1.0.0",
+				"ajv-formats": "^3.0.1",
+				"jsonpointer": "^5.0.1",
+				"leven": "^4.0.0",
+				"yaml": "^2.4.5"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/@mintlify/openapi-parser/node_modules/ajv-formats": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+			"integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ajv": "^8.0.0"
+			},
+			"peerDependencies": {
+				"ajv": "^8.0.0"
+			},
+			"peerDependenciesMeta": {
+				"ajv": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/prebuild": {
+			"version": "1.0.855",
+			"resolved": "https://registry.npmjs.org/@mintlify/prebuild/-/prebuild-1.0.855.tgz",
+			"integrity": "sha512-Hd7WMkM89eu58J1oIW+0lfsoW1QIjFHHo2ks1mdrjXJ7Bm6MvPcsYhYDxtWBSJpU8KMxzjjfC2rd9UWnrRMhRA==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/common": "1.0.719",
+				"@mintlify/openapi-parser": "^0.0.8",
+				"@mintlify/scraping": "4.0.580",
+				"@mintlify/validation": "0.1.589",
+				"chalk": "5.3.0",
+				"favicons": "7.2.0",
+				"front-matter": "4.0.2",
+				"fs-extra": "11.1.0",
+				"js-yaml": "4.1.0",
+				"openapi-types": "12.1.3",
+				"sharp": "0.33.5",
+				"sharp-ico": "0.1.5",
+				"unist-util-visit": "4.1.2",
+				"uuid": "11.1.0"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/@mintlify/scraping": {
+			"version": "4.0.580",
+			"resolved": "https://registry.npmjs.org/@mintlify/scraping/-/scraping-4.0.580.tgz",
+			"integrity": "sha512-5F84qwnZ1RkkBXaquvpNDj11J5xc1ayXyeJpjW6SwBJWekIVnCvrea/OmHBmmFRgCg6HjuM8NeB2XO06HrhqYw==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/common": "1.0.719",
+				"@mintlify/openapi-parser": "^0.0.8",
+				"fs-extra": "11.1.1",
+				"hast-util-to-mdast": "10.1.0",
+				"js-yaml": "4.1.0",
+				"mdast-util-mdx-jsx": "3.1.3",
+				"neotraverse": "0.6.18",
+				"puppeteer": "22.14.0",
+				"rehype-parse": "9.0.1",
+				"remark-gfm": "4.0.0",
+				"remark-mdx": "3.0.1",
+				"remark-parse": "11.0.0",
+				"remark-stringify": "11.0.0",
+				"unified": "11.0.5",
+				"unist-util-visit": "5.0.0",
+				"yargs": "17.7.1",
+				"zod": "3.24.0"
+			},
+			"bin": {
+				"mintlify-scrape": "bin/cli.js"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/@mintlify/scraping/node_modules/fs-extra": {
+			"version": "11.1.1",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
+			"integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/@mintlify/scraping/node_modules/unist-util-visit": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
+			"integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-is": "^6.0.0",
+				"unist-util-visit-parents": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/chalk": {
+			"version": "5.3.0",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+			"integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.17.0 || ^14.13 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/chalk?sponsor=1"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/fs-extra": {
+			"version": "11.1.0",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
+			"integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/mdast-util-mdx-jsx": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
+			"integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"parse-entities": "^4.0.0",
+				"stringify-entities": "^4.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/remark-mdx": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz",
+			"integrity": "sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-mdx": "^3.0.0",
+				"micromark-extension-mdxjs": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/unist-util-visit": {
+			"version": "4.1.2",
+			"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
+			"integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"unist-util-is": "^5.0.0",
+				"unist-util-visit-parents": "^5.1.1"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/unist-util-visit/node_modules/@types/unist": {
+			"version": "2.0.11",
+			"resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+			"integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+			"license": "MIT"
+		},
+		"node_modules/@mintlify/prebuild/node_modules/unist-util-visit/node_modules/unist-util-is": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
+			"integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/unist-util-visit/node_modules/unist-util-visit-parents": {
+			"version": "5.1.3",
+			"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
+			"integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"unist-util-is": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/prebuild/node_modules/zod": {
+			"version": "3.24.0",
+			"resolved": "https://registry.npmjs.org/zod/-/zod-3.24.0.tgz",
+			"integrity": "sha512-Hz+wiY8yD0VLA2k/+nsg2Abez674dDGTai33SwNvMPuf9uIrBC9eFgIMQxBBbHFxVXi8W+5nX9DcAh9YNSQm/w==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/colinhacks"
+			}
+		},
+		"node_modules/@mintlify/previewing": {
+			"version": "4.0.912",
+			"resolved": "https://registry.npmjs.org/@mintlify/previewing/-/previewing-4.0.912.tgz",
+			"integrity": "sha512-/nRbgh/0JNYLSZphgdAFDK/O+o6YXfuUZ2Jle3l+Yyp4D8Jk+4j2oU9Pao4Z+ahqx6nZTbyx9LM5IZMI41xvbA==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/common": "1.0.719",
+				"@mintlify/prebuild": "1.0.855",
+				"@mintlify/validation": "0.1.589",
+				"better-opn": "3.0.2",
+				"chalk": "5.2.0",
+				"chokidar": "3.5.3",
+				"express": "4.18.2",
+				"front-matter": "4.0.2",
+				"fs-extra": "11.1.0",
+				"got": "13.0.0",
+				"ink": "6.3.0",
+				"ink-spinner": "5.0.0",
+				"is-online": "10.0.0",
+				"js-yaml": "4.1.0",
+				"openapi-types": "12.1.3",
+				"react": "19.2.3",
+				"socket.io": "4.7.2",
+				"tar": "6.1.15",
+				"unist-util-visit": "4.1.2",
+				"yargs": "17.7.1"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/previewing/node_modules/@types/unist": {
+			"version": "2.0.11",
+			"resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+			"integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+			"license": "MIT"
+		},
+		"node_modules/@mintlify/previewing/node_modules/fs-extra": {
+			"version": "11.1.0",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
+			"integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/@mintlify/previewing/node_modules/unist-util-is": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
+			"integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/previewing/node_modules/unist-util-visit": {
+			"version": "4.1.2",
+			"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
+			"integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"unist-util-is": "^5.0.0",
+				"unist-util-visit-parents": "^5.1.1"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/previewing/node_modules/unist-util-visit-parents": {
+			"version": "5.1.3",
+			"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
+			"integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"unist-util-is": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/scraping": {
+			"version": "4.0.522",
+			"resolved": "https://registry.npmjs.org/@mintlify/scraping/-/scraping-4.0.522.tgz",
+			"integrity": "sha512-PL2k52WT5S5OAgnT2K13bP7J2El6XwiVvQlrLvxDYw5KMMV+y34YVJI8ZscKb4trjitWDgyK0UTq2KN6NQgn6g==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/common": "1.0.661",
+				"@mintlify/openapi-parser": "^0.0.8",
+				"fs-extra": "11.1.1",
+				"hast-util-to-mdast": "10.1.0",
+				"js-yaml": "4.1.0",
+				"mdast-util-mdx-jsx": "3.1.3",
+				"neotraverse": "0.6.18",
+				"puppeteer": "22.14.0",
+				"rehype-parse": "9.0.1",
+				"remark-gfm": "4.0.0",
+				"remark-mdx": "3.0.1",
+				"remark-parse": "11.0.0",
+				"remark-stringify": "11.0.0",
+				"unified": "11.0.5",
+				"unist-util-visit": "5.0.0",
+				"yargs": "17.7.1",
+				"zod": "3.21.4"
+			},
+			"bin": {
+				"mintlify-scrape": "bin/cli.js"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@floating-ui/react-dom": {
+			"version": "2.1.7",
+			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
+			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/dom": "^1.7.5"
+			},
+			"peerDependencies": {
+				"react": ">=16.8.0",
+				"react-dom": ">=16.8.0"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/common": {
+			"version": "1.0.661",
+			"resolved": "https://registry.npmjs.org/@mintlify/common/-/common-1.0.661.tgz",
+			"integrity": "sha512-/Hdiblzaomp+AWStQ4smhVMgesQhffzQjC9aYBnmLReNdh2Js+ccQFUaWL3TNIxwiS2esaZvsHSV/D+zyRS3hg==",
+			"license": "ISC",
+			"dependencies": {
+				"@asyncapi/parser": "3.4.0",
+				"@mintlify/mdx": "^3.0.4",
+				"@mintlify/models": "0.0.255",
+				"@mintlify/openapi-parser": "^0.0.8",
+				"@mintlify/validation": "0.1.555",
+				"@sindresorhus/slugify": "2.2.0",
+				"@types/mdast": "4.0.4",
+				"acorn": "8.11.2",
+				"acorn-jsx": "5.3.2",
+				"color-blend": "4.0.0",
+				"estree-util-to-js": "2.0.0",
+				"estree-walker": "3.0.3",
+				"front-matter": "4.0.2",
+				"hast-util-from-html": "2.0.3",
+				"hast-util-to-html": "9.0.4",
+				"hast-util-to-text": "4.0.2",
+				"hex-rgb": "5.0.0",
+				"ignore": "7.0.5",
+				"js-yaml": "4.1.0",
+				"lodash": "4.17.21",
+				"mdast-util-from-markdown": "2.0.2",
+				"mdast-util-gfm": "3.0.0",
+				"mdast-util-mdx": "3.0.0",
+				"mdast-util-mdx-jsx": "3.1.3",
+				"micromark-extension-gfm": "3.0.0",
+				"micromark-extension-mdx-jsx": "3.0.1",
+				"micromark-extension-mdxjs": "3.0.0",
+				"openapi-types": "12.1.3",
+				"postcss": "8.5.6",
+				"rehype-stringify": "10.0.1",
+				"remark": "15.0.1",
+				"remark-frontmatter": "5.0.0",
+				"remark-gfm": "4.0.0",
+				"remark-math": "6.0.0",
+				"remark-mdx": "3.1.0",
+				"remark-parse": "11.0.0",
+				"remark-rehype": "11.1.1",
+				"remark-stringify": "11.0.0",
+				"tailwindcss": "3.4.4",
+				"unified": "11.0.5",
+				"unist-builder": "4.0.0",
+				"unist-util-map": "4.0.0",
+				"unist-util-remove": "4.0.0",
+				"unist-util-remove-position": "5.0.0",
+				"unist-util-visit": "5.0.0",
+				"unist-util-visit-parents": "6.0.1",
+				"vfile": "6.0.3"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/common/node_modules/remark-mdx": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.0.tgz",
+			"integrity": "sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-mdx": "^3.0.0",
+				"micromark-extension-mdxjs": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/mdx": {
+			"version": "3.0.4",
+			"resolved": "https://registry.npmjs.org/@mintlify/mdx/-/mdx-3.0.4.tgz",
+			"integrity": "sha512-tJhdpnM5ReJLNJ2fuDRIEr0zgVd6id7/oAIfs26V46QlygiLsc8qx4Rz3LWIX51rUXW/cfakjj0EATxIciIw+g==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/transformers": "^3.11.0",
+				"@shikijs/twoslash": "^3.12.2",
+				"arktype": "^2.1.26",
+				"hast-util-to-string": "^3.0.1",
+				"mdast-util-from-markdown": "^2.0.2",
+				"mdast-util-gfm": "^3.1.0",
+				"mdast-util-mdx-jsx": "^3.2.0",
+				"mdast-util-to-hast": "^13.2.0",
+				"next-mdx-remote-client": "^1.0.3",
+				"rehype-katex": "^7.0.1",
+				"remark-gfm": "^4.0.0",
+				"remark-math": "^6.0.0",
+				"remark-smartypants": "^3.0.2",
+				"shiki": "^3.11.0",
+				"unified": "^11.0.0",
+				"unist-util-visit": "^5.0.0"
+			},
+			"peerDependencies": {
+				"@radix-ui/react-popover": "^1.1.15",
+				"react": "^18.3.1",
+				"react-dom": "^18.3.1"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/mdx/node_modules/mdast-util-gfm": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+			"integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-gfm-autolink-literal": "^2.0.0",
+				"mdast-util-gfm-footnote": "^2.0.0",
+				"mdast-util-gfm-strikethrough": "^2.0.0",
+				"mdast-util-gfm-table": "^2.0.0",
+				"mdast-util-gfm-task-list-item": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/mdx/node_modules/mdast-util-mdx-jsx": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+			"integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"parse-entities": "^4.0.0",
+				"stringify-entities": "^4.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/models": {
+			"version": "0.0.255",
+			"resolved": "https://registry.npmjs.org/@mintlify/models/-/models-0.0.255.tgz",
+			"integrity": "sha512-LIUkfA7l7ypHAAuOW74ZJws/NwNRqlDRD/U466jarXvvSlGhJec/6J4/I+IEcBvWDnc9anLFKmnGO04jPKgAsg==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"axios": "1.10.0",
+				"openapi-types": "12.1.3"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@mintlify/validation": {
+			"version": "0.1.555",
+			"resolved": "https://registry.npmjs.org/@mintlify/validation/-/validation-0.1.555.tgz",
+			"integrity": "sha512-11QVUReL4N5u8wSCgZt4RN7PA0jYQoMEBZ5IrUp5pgb5ZJBOoGV/vPsQrxPPa1cxsUDAuToNhtGxRQtOav/w8w==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/mdx": "^3.0.4",
+				"@mintlify/models": "0.0.255",
+				"arktype": "2.1.27",
+				"js-yaml": "4.1.0",
+				"lcm": "0.0.3",
+				"lodash": "4.17.21",
+				"object-hash": "3.0.0",
+				"openapi-types": "12.1.3",
+				"uuid": "11.1.0",
+				"zod": "3.21.4",
+				"zod-to-json-schema": "3.20.4"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-arrow": {
+			"version": "1.1.7",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
+			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-primitive": "2.1.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-dismissable-layer": {
+			"version": "1.1.11",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/primitive": "1.1.3",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1",
+				"@radix-ui/react-use-escape-keydown": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-focus-scope": {
+			"version": "1.1.7",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
+			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-popover": {
+			"version": "1.1.15",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
+			"integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/primitive": "1.1.3",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-context": "1.1.2",
+				"@radix-ui/react-dismissable-layer": "1.1.11",
+				"@radix-ui/react-focus-guards": "1.1.3",
+				"@radix-ui/react-focus-scope": "1.1.7",
+				"@radix-ui/react-id": "1.1.1",
+				"@radix-ui/react-popper": "1.2.8",
+				"@radix-ui/react-portal": "1.1.9",
+				"@radix-ui/react-presence": "1.1.5",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-slot": "1.2.3",
+				"@radix-ui/react-use-controllable-state": "1.2.2",
+				"aria-hidden": "^1.2.4",
+				"react-remove-scroll": "^2.6.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-popper": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/react-dom": "^2.0.0",
+				"@radix-ui/react-arrow": "1.1.7",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-context": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1",
+				"@radix-ui/react-use-layout-effect": "1.1.1",
+				"@radix-ui/react-use-rect": "1.1.1",
+				"@radix-ui/react-use-size": "1.1.1",
+				"@radix-ui/rect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-portal": {
+			"version": "1.1.9",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
+			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-presence": {
+			"version": "1.1.5",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/@radix-ui/react-primitive": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
+			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-slot": "1.2.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/fs-extra": {
+			"version": "11.1.1",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
+			"integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/mdast-util-mdx-jsx": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
+			"integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"parse-entities": "^4.0.0",
+				"stringify-entities": "^4.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/next-mdx-remote-client": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.4.tgz",
+			"integrity": "sha512-psCMdO50tfoT1kAH7OGXZvhyRfiHVK6IqwjmWFV5gtLo4dnqjAgcjcLNeJ92iI26UNlKShxYrBs1GQ6UXxk97A==",
+			"license": "MPL 2.0",
+			"dependencies": {
+				"@babel/code-frame": "^7.27.1",
+				"@mdx-js/mdx": "^3.1.1",
+				"@mdx-js/react": "^3.1.1",
+				"remark-mdx-remove-esm": "^1.2.1",
+				"serialize-error": "^12.0.0",
+				"vfile": "^6.0.3",
+				"vfile-matter": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=18.18.0"
+			},
+			"peerDependencies": {
+				"react": ">= 18.3.0 < 19.0.0",
+				"react-dom": ">= 18.3.0 < 19.0.0"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/react": {
+			"version": "18.3.1",
+			"resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+			"integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/react-dom": {
+			"version": "18.3.1",
+			"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+			"integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0",
+				"scheduler": "^0.23.2"
+			},
+			"peerDependencies": {
+				"react": "^18.3.1"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/remark-mdx": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz",
+			"integrity": "sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-mdx": "^3.0.0",
+				"micromark-extension-mdxjs": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/scraping/node_modules/scheduler": {
+			"version": "0.23.2",
+			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+			"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0"
+			}
+		},
+		"node_modules/@mintlify/validation": {
+			"version": "0.1.589",
+			"resolved": "https://registry.npmjs.org/@mintlify/validation/-/validation-0.1.589.tgz",
+			"integrity": "sha512-wfhkqQqHjn0OWSo182/Pjspz+SLXJOgVu0tiDwfz6cx/QZRbCJko1XQQjJkRx0VbrTe3ABza8lQ9SoGx+M78QQ==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/mdx": "^3.0.4",
+				"@mintlify/models": "0.0.270",
+				"arktype": "2.1.27",
+				"js-yaml": "4.1.0",
+				"lcm": "0.0.3",
+				"lodash": "4.17.21",
+				"object-hash": "3.0.0",
+				"openapi-types": "12.1.3",
+				"uuid": "11.1.0",
+				"zod": "3.24.0",
+				"zod-to-json-schema": "3.20.4"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@floating-ui/react-dom": {
+			"version": "2.1.7",
+			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
+			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/dom": "^1.7.5"
+			},
+			"peerDependencies": {
+				"react": ">=16.8.0",
+				"react-dom": ">=16.8.0"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@mintlify/mdx": {
+			"version": "3.0.4",
+			"resolved": "https://registry.npmjs.org/@mintlify/mdx/-/mdx-3.0.4.tgz",
+			"integrity": "sha512-tJhdpnM5ReJLNJ2fuDRIEr0zgVd6id7/oAIfs26V46QlygiLsc8qx4Rz3LWIX51rUXW/cfakjj0EATxIciIw+g==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/transformers": "^3.11.0",
+				"@shikijs/twoslash": "^3.12.2",
+				"arktype": "^2.1.26",
+				"hast-util-to-string": "^3.0.1",
+				"mdast-util-from-markdown": "^2.0.2",
+				"mdast-util-gfm": "^3.1.0",
+				"mdast-util-mdx-jsx": "^3.2.0",
+				"mdast-util-to-hast": "^13.2.0",
+				"next-mdx-remote-client": "^1.0.3",
+				"rehype-katex": "^7.0.1",
+				"remark-gfm": "^4.0.0",
+				"remark-math": "^6.0.0",
+				"remark-smartypants": "^3.0.2",
+				"shiki": "^3.11.0",
+				"unified": "^11.0.0",
+				"unist-util-visit": "^5.0.0"
+			},
+			"peerDependencies": {
+				"@radix-ui/react-popover": "^1.1.15",
+				"react": "^18.3.1",
+				"react-dom": "^18.3.1"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-arrow": {
+			"version": "1.1.7",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
+			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-primitive": "2.1.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-dismissable-layer": {
+			"version": "1.1.11",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/primitive": "1.1.3",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1",
+				"@radix-ui/react-use-escape-keydown": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-focus-scope": {
+			"version": "1.1.7",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
+			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-popover": {
+			"version": "1.1.15",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
+			"integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/primitive": "1.1.3",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-context": "1.1.2",
+				"@radix-ui/react-dismissable-layer": "1.1.11",
+				"@radix-ui/react-focus-guards": "1.1.3",
+				"@radix-ui/react-focus-scope": "1.1.7",
+				"@radix-ui/react-id": "1.1.1",
+				"@radix-ui/react-popper": "1.2.8",
+				"@radix-ui/react-portal": "1.1.9",
+				"@radix-ui/react-presence": "1.1.5",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-slot": "1.2.3",
+				"@radix-ui/react-use-controllable-state": "1.2.2",
+				"aria-hidden": "^1.2.4",
+				"react-remove-scroll": "^2.6.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-popper": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@floating-ui/react-dom": "^2.0.0",
+				"@radix-ui/react-arrow": "1.1.7",
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-context": "1.1.2",
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-callback-ref": "1.1.1",
+				"@radix-ui/react-use-layout-effect": "1.1.1",
+				"@radix-ui/react-use-rect": "1.1.1",
+				"@radix-ui/react-use-size": "1.1.1",
+				"@radix-ui/rect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-portal": {
+			"version": "1.1.9",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
+			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-primitive": "2.1.3",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-presence": {
+			"version": "1.1.5",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/@radix-ui/react-primitive": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
+			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-slot": "1.2.3"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"@types/react-dom": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"@types/react-dom": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/mdast-util-gfm": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+			"integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-gfm-autolink-literal": "^2.0.0",
+				"mdast-util-gfm-footnote": "^2.0.0",
+				"mdast-util-gfm-strikethrough": "^2.0.0",
+				"mdast-util-gfm-table": "^2.0.0",
+				"mdast-util-gfm-task-list-item": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/next-mdx-remote-client": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.4.tgz",
+			"integrity": "sha512-psCMdO50tfoT1kAH7OGXZvhyRfiHVK6IqwjmWFV5gtLo4dnqjAgcjcLNeJ92iI26UNlKShxYrBs1GQ6UXxk97A==",
+			"license": "MPL 2.0",
+			"dependencies": {
+				"@babel/code-frame": "^7.27.1",
+				"@mdx-js/mdx": "^3.1.1",
+				"@mdx-js/react": "^3.1.1",
+				"remark-mdx-remove-esm": "^1.2.1",
+				"serialize-error": "^12.0.0",
+				"vfile": "^6.0.3",
+				"vfile-matter": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=18.18.0"
+			},
+			"peerDependencies": {
+				"react": ">= 18.3.0 < 19.0.0",
+				"react-dom": ">= 18.3.0 < 19.0.0"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/react": {
+			"version": "18.3.1",
+			"resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+			"integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/react-dom": {
+			"version": "18.3.1",
+			"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+			"integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0",
+				"scheduler": "^0.23.2"
+			},
+			"peerDependencies": {
+				"react": "^18.3.1"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/scheduler": {
+			"version": "0.23.2",
+			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+			"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"loose-envify": "^1.1.0"
+			}
+		},
+		"node_modules/@mintlify/validation/node_modules/zod": {
+			"version": "3.24.0",
+			"resolved": "https://registry.npmjs.org/zod/-/zod-3.24.0.tgz",
+			"integrity": "sha512-Hz+wiY8yD0VLA2k/+nsg2Abez674dDGTai33SwNvMPuf9uIrBC9eFgIMQxBBbHFxVXi8W+5nX9DcAh9YNSQm/w==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/colinhacks"
+			}
+		},
+		"node_modules/@nodelib/fs.scandir": {
+			"version": "2.1.5",
+			"resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+			"integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+			"license": "MIT",
+			"dependencies": {
+				"@nodelib/fs.stat": "2.0.5",
+				"run-parallel": "^1.1.9"
+			},
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/@nodelib/fs.stat": {
+			"version": "2.0.5",
+			"resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+			"integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/@nodelib/fs.walk": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+			"integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+			"license": "MIT",
+			"dependencies": {
+				"@nodelib/fs.scandir": "2.1.5",
+				"fastq": "^1.6.0"
+			},
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/@openapi-contrib/openapi-schema-to-json-schema": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/@openapi-contrib/openapi-schema-to-json-schema/-/openapi-schema-to-json-schema-3.2.0.tgz",
+			"integrity": "sha512-Gj6C0JwCr8arj0sYuslWXUBSP/KnUlEGnPW4qxlXvAl543oaNQgMgIgkQUA6vs5BCCvwTEiL8m/wdWzfl4UvSw==",
+			"license": "MIT",
+			"dependencies": {
+				"fast-deep-equal": "^3.1.3"
+			}
+		},
+		"node_modules/@puppeteer/browsers": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.3.0.tgz",
+			"integrity": "sha512-ioXoq9gPxkss4MYhD+SFaU9p1IHFUX0ILAWFPyjGaBdjLsYAlZw6j1iLA0N/m12uVHLFDfSYNF7EQccjinIMDA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"debug": "^4.3.5",
+				"extract-zip": "^2.0.1",
+				"progress": "^2.0.3",
+				"proxy-agent": "^6.4.0",
+				"semver": "^7.6.3",
+				"tar-fs": "^3.0.6",
+				"unbzip2-stream": "^1.4.3",
+				"yargs": "^17.7.2"
+			},
+			"bin": {
+				"browsers": "lib/cjs/main-cli.js"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/@puppeteer/browsers/node_modules/ansi-regex": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@puppeteer/browsers/node_modules/emoji-regex": {
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+			"license": "MIT"
+		},
+		"node_modules/@puppeteer/browsers/node_modules/is-fullwidth-code-point": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+			"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@puppeteer/browsers/node_modules/string-width": {
+			"version": "4.2.3",
+			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+			"license": "MIT",
+			"dependencies": {
+				"emoji-regex": "^8.0.0",
+				"is-fullwidth-code-point": "^3.0.0",
+				"strip-ansi": "^6.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@puppeteer/browsers/node_modules/strip-ansi": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-regex": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@puppeteer/browsers/node_modules/yargs": {
+			"version": "17.7.2",
+			"resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+			"integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+			"license": "MIT",
+			"dependencies": {
+				"cliui": "^8.0.1",
+				"escalade": "^3.1.1",
+				"get-caller-file": "^2.0.5",
+				"require-directory": "^2.1.1",
+				"string-width": "^4.2.3",
+				"y18n": "^5.0.5",
+				"yargs-parser": "^21.1.1"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/@radix-ui/primitive": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
+			"integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
+			"license": "MIT",
+			"peer": true
+		},
+		"node_modules/@radix-ui/react-compose-refs": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz",
+			"integrity": "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==",
+			"license": "MIT",
+			"peer": true,
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-context": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.1.2.tgz",
+			"integrity": "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==",
+			"license": "MIT",
+			"peer": true,
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-focus-guards": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz",
+			"integrity": "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==",
+			"license": "MIT",
+			"peer": true,
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-id": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.1.tgz",
+			"integrity": "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-slot": {
+			"version": "1.2.3",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+			"integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-compose-refs": "1.1.2"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-callback-ref": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
+			"integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==",
+			"license": "MIT",
+			"peer": true,
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-controllable-state": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
+			"integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-use-effect-event": "0.0.2",
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-effect-event": {
+			"version": "0.0.2",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
+			"integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-escape-keydown": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz",
+			"integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-use-callback-ref": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-layout-effect": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
+			"integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
+			"license": "MIT",
+			"peer": true,
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-rect": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
+			"integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/rect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/react-use-size": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
+			"integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"@radix-ui/react-use-layout-effect": "1.1.1"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@radix-ui/rect": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
+			"integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==",
+			"license": "MIT",
+			"peer": true
+		},
+		"node_modules/@shikijs/core": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/core/-/core-3.22.0.tgz",
+			"integrity": "sha512-iAlTtSDDbJiRpvgL5ugKEATDtHdUVkqgHDm/gbD2ZS9c88mx7G1zSYjjOxp5Qa0eaW0MAQosFRmJSk354PRoQA==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/types": "3.22.0",
+				"@shikijs/vscode-textmate": "^10.0.2",
+				"@types/hast": "^3.0.4",
+				"hast-util-to-html": "^9.0.5"
+			}
+		},
+		"node_modules/@shikijs/core/node_modules/hast-util-to-html": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz",
+			"integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"comma-separated-tokens": "^2.0.0",
+				"hast-util-whitespace": "^3.0.0",
+				"html-void-elements": "^3.0.0",
+				"mdast-util-to-hast": "^13.0.0",
+				"property-information": "^7.0.0",
+				"space-separated-tokens": "^2.0.0",
+				"stringify-entities": "^4.0.0",
+				"zwitch": "^2.0.4"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/@shikijs/engine-javascript": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-3.22.0.tgz",
+			"integrity": "sha512-jdKhfgW9CRtj3Tor0L7+yPwdG3CgP7W+ZEqSsojrMzCjD1e0IxIbwUMDDpYlVBlC08TACg4puwFGkZfLS+56Tw==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/types": "3.22.0",
+				"@shikijs/vscode-textmate": "^10.0.2",
+				"oniguruma-to-es": "^4.3.4"
+			}
+		},
+		"node_modules/@shikijs/engine-oniguruma": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-3.22.0.tgz",
+			"integrity": "sha512-DyXsOG0vGtNtl7ygvabHd7Mt5EY8gCNqR9Y7Lpbbd/PbJvgWrqaKzH1JW6H6qFkuUa8aCxoiYVv8/YfFljiQxA==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/types": "3.22.0",
+				"@shikijs/vscode-textmate": "^10.0.2"
+			}
+		},
+		"node_modules/@shikijs/langs": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-3.22.0.tgz",
+			"integrity": "sha512-x/42TfhWmp6H00T6uwVrdTJGKgNdFbrEdhaDwSR5fd5zhQ1Q46bHq9EO61SCEWJR0HY7z2HNDMaBZp8JRmKiIA==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/types": "3.22.0"
+			}
+		},
+		"node_modules/@shikijs/themes": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-3.22.0.tgz",
+			"integrity": "sha512-o+tlOKqsr6FE4+mYJG08tfCFDS+3CG20HbldXeVoyP+cYSUxDhrFf3GPjE60U55iOkkjbpY2uC3It/eeja35/g==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/types": "3.22.0"
+			}
+		},
+		"node_modules/@shikijs/transformers": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/transformers/-/transformers-3.22.0.tgz",
+			"integrity": "sha512-E7eRV7mwDBjueLF6852n2oYeJYxBq3NSsDk+uyruYAXONv4U8holGmIrT+mPRJQ1J1SNOH6L8G19KRzmBawrFw==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/core": "3.22.0",
+				"@shikijs/types": "3.22.0"
+			}
+		},
+		"node_modules/@shikijs/twoslash": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/twoslash/-/twoslash-3.22.0.tgz",
+			"integrity": "sha512-GO27UPN+kegOMQvC+4XcLt0Mttyg+n16XKjmoKjdaNZoW+sOJV7FLdv2QKauqUDws6nE3EQPD+TFHEdyyoUBDw==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/core": "3.22.0",
+				"@shikijs/types": "3.22.0",
+				"twoslash": "^0.3.6"
+			},
+			"peerDependencies": {
+				"typescript": ">=5.5.0"
+			}
+		},
+		"node_modules/@shikijs/types": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/@shikijs/types/-/types-3.22.0.tgz",
+			"integrity": "sha512-491iAekgKDBFE67z70Ok5a8KBMsQ2IJwOWw3us/7ffQkIBCyOQfm/aNwVMBUriP02QshIfgHCBSIYAl3u2eWjg==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/vscode-textmate": "^10.0.2",
+				"@types/hast": "^3.0.4"
+			}
+		},
+		"node_modules/@shikijs/vscode-textmate": {
+			"version": "10.0.2",
+			"resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz",
+			"integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==",
+			"license": "MIT"
+		},
+		"node_modules/@sindresorhus/is": {
+			"version": "5.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz",
+			"integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/@sindresorhus/slugify": {
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/slugify/-/slugify-2.2.0.tgz",
+			"integrity": "sha512-9Vybc/qX8Kj6pxJaapjkFbiUJPk7MAkCh/GFCxIBnnsuYCFPIXKvnLidG8xlepht3i24L5XemUmGtrJ3UWrl6w==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/transliterate": "^1.0.0",
+				"escape-string-regexp": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/@sindresorhus/transliterate": {
+			"version": "1.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/transliterate/-/transliterate-1.6.0.tgz",
+			"integrity": "sha512-doH1gimEu3A46VX6aVxpHTeHrytJAG6HgdxntYnCFiIFHEM/ZGpG8KiZGBChchjQmG0XFIBL552kBTjVcMZXwQ==",
+			"license": "MIT",
+			"dependencies": {
+				"escape-string-regexp": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/@socket.io/component-emitter": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz",
+			"integrity": "sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==",
+			"license": "MIT"
+		},
+		"node_modules/@stoplight/better-ajv-errors": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/@stoplight/better-ajv-errors/-/better-ajv-errors-1.0.3.tgz",
+			"integrity": "sha512-0p9uXkuB22qGdNfy3VeEhxkU5uwvp/KrBTAbrLBURv6ilxIVwanKwjMc41lQfIVgPGcOkmLbTolfFrSsueu7zA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"jsonpointer": "^5.0.0",
+				"leven": "^3.1.0"
+			},
+			"engines": {
+				"node": "^12.20 || >= 14.13"
+			},
+			"peerDependencies": {
+				"ajv": ">=8"
+			}
+		},
+		"node_modules/@stoplight/better-ajv-errors/node_modules/leven": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
+			"integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/@stoplight/json": {
+			"version": "3.21.0",
+			"resolved": "https://registry.npmjs.org/@stoplight/json/-/json-3.21.0.tgz",
+			"integrity": "sha512-5O0apqJ/t4sIevXCO3SBN9AHCEKKR/Zb4gaj7wYe5863jme9g02Q0n/GhM7ZCALkL+vGPTe4ZzTETP8TFtsw3g==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/ordered-object-literal": "^1.0.3",
+				"@stoplight/path": "^1.3.2",
+				"@stoplight/types": "^13.6.0",
+				"jsonc-parser": "~2.2.1",
+				"lodash": "^4.17.21",
+				"safe-stable-stringify": "^1.1"
+			},
+			"engines": {
+				"node": ">=8.3.0"
+			}
+		},
+		"node_modules/@stoplight/json-ref-readers": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/@stoplight/json-ref-readers/-/json-ref-readers-1.2.2.tgz",
+			"integrity": "sha512-nty0tHUq2f1IKuFYsLM4CXLZGHdMn+X/IwEUIpeSOXt0QjMUbL0Em57iJUDzz+2MkWG83smIigNZ3fauGjqgdQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"node-fetch": "^2.6.0",
+				"tslib": "^1.14.1"
+			},
+			"engines": {
+				"node": ">=8.3.0"
+			}
+		},
+		"node_modules/@stoplight/json-ref-resolver": {
+			"version": "3.1.6",
+			"resolved": "https://registry.npmjs.org/@stoplight/json-ref-resolver/-/json-ref-resolver-3.1.6.tgz",
+			"integrity": "sha512-YNcWv3R3n3U6iQYBsFOiWSuRGE5su1tJSiX6pAPRVk7dP0L7lqCteXGzuVRQ0gMZqUl8v1P0+fAKxF6PLo9B5A==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/json": "^3.21.0",
+				"@stoplight/path": "^1.3.2",
+				"@stoplight/types": "^12.3.0 || ^13.0.0",
+				"@types/urijs": "^1.19.19",
+				"dependency-graph": "~0.11.0",
+				"fast-memoize": "^2.5.2",
+				"immer": "^9.0.6",
+				"lodash": "^4.17.21",
+				"tslib": "^2.6.0",
+				"urijs": "^1.19.11"
+			},
+			"engines": {
+				"node": ">=8.3.0"
+			}
+		},
+		"node_modules/@stoplight/json-ref-resolver/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/ordered-object-literal": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/@stoplight/ordered-object-literal/-/ordered-object-literal-1.0.5.tgz",
+			"integrity": "sha512-COTiuCU5bgMUtbIFBuyyh2/yVVzlr5Om0v5utQDgBCuQUOPgU1DwoffkTfg4UBQOvByi5foF4w4T+H9CoRe5wg==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@stoplight/path": {
+			"version": "1.3.2",
+			"resolved": "https://registry.npmjs.org/@stoplight/path/-/path-1.3.2.tgz",
+			"integrity": "sha512-lyIc6JUlUA8Ve5ELywPC8I2Sdnh1zc1zmbYgVarhXIp9YeAB0ReeqmGEOWNtlHkbP2DAA1AL65Wfn2ncjK/jtQ==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@stoplight/spectral-core": {
+			"version": "1.21.0",
+			"resolved": "https://registry.npmjs.org/@stoplight/spectral-core/-/spectral-core-1.21.0.tgz",
+			"integrity": "sha512-oj4e/FrDLUhBRocIW+lRMKlJ/q/rDZw61HkLbTFsdMd+f/FTkli2xHNB1YC6n1mrMKjjvy7XlUuFkC7XxtgbWw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/better-ajv-errors": "1.0.3",
+				"@stoplight/json": "~3.21.0",
+				"@stoplight/path": "1.3.2",
+				"@stoplight/spectral-parsers": "^1.0.0",
+				"@stoplight/spectral-ref-resolver": "^1.0.4",
+				"@stoplight/spectral-runtime": "^1.1.2",
+				"@stoplight/types": "~13.6.0",
+				"@types/es-aggregate-error": "^1.0.2",
+				"@types/json-schema": "^7.0.11",
+				"ajv": "^8.17.1",
+				"ajv-errors": "~3.0.0",
+				"ajv-formats": "~2.1.1",
+				"es-aggregate-error": "^1.0.7",
+				"jsonpath-plus": "^10.3.0",
+				"lodash": "~4.17.23",
+				"lodash.topath": "^4.5.2",
+				"minimatch": "3.1.2",
+				"nimma": "0.2.3",
+				"pony-cause": "^1.1.1",
+				"simple-eval": "1.0.1",
+				"tslib": "^2.8.1"
+			},
+			"engines": {
+				"node": "^16.20 || ^18.18 || >= 20.17"
+			}
+		},
+		"node_modules/@stoplight/spectral-core/node_modules/@stoplight/types": {
+			"version": "13.6.0",
+			"resolved": "https://registry.npmjs.org/@stoplight/types/-/types-13.6.0.tgz",
+			"integrity": "sha512-dzyuzvUjv3m1wmhPfq82lCVYGcXG0xUYgqnWfCq3PCVR4BKFhjdkHrnJ+jIDoMKvXb05AZP/ObQF6+NpDo29IQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@types/json-schema": "^7.0.4",
+				"utility-types": "^3.10.0"
+			},
+			"engines": {
+				"node": "^12.20 || >=14.13"
+			}
+		},
+		"node_modules/@stoplight/spectral-core/node_modules/lodash": {
+			"version": "4.17.23",
+			"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+			"integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+			"license": "MIT"
+		},
+		"node_modules/@stoplight/spectral-core/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/spectral-formats": {
+			"version": "1.8.2",
+			"resolved": "https://registry.npmjs.org/@stoplight/spectral-formats/-/spectral-formats-1.8.2.tgz",
+			"integrity": "sha512-c06HB+rOKfe7tuxg0IdKDEA5XnjL2vrn/m/OVIIxtINtBzphZrOgtRn7epQ5bQF5SWp84Ue7UJWaGgDwVngMFw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/json": "^3.17.0",
+				"@stoplight/spectral-core": "^1.19.2",
+				"@types/json-schema": "^7.0.7",
+				"tslib": "^2.8.1"
+			},
+			"engines": {
+				"node": "^16.20 || ^18.18 || >= 20.17"
+			}
+		},
+		"node_modules/@stoplight/spectral-formats/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/spectral-functions": {
+			"version": "1.10.1",
+			"resolved": "https://registry.npmjs.org/@stoplight/spectral-functions/-/spectral-functions-1.10.1.tgz",
+			"integrity": "sha512-obu8ZfoHxELOapfGsCJixKZXZcffjg+lSoNuttpmUFuDzVLT3VmH8QkPXfOGOL5Pz80BR35ClNAToDkdnYIURg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/better-ajv-errors": "1.0.3",
+				"@stoplight/json": "^3.17.1",
+				"@stoplight/spectral-core": "^1.19.4",
+				"@stoplight/spectral-formats": "^1.8.1",
+				"@stoplight/spectral-runtime": "^1.1.2",
+				"ajv": "^8.17.1",
+				"ajv-draft-04": "~1.0.0",
+				"ajv-errors": "~3.0.0",
+				"ajv-formats": "~2.1.1",
+				"lodash": "~4.17.21",
+				"tslib": "^2.8.1"
+			},
+			"engines": {
+				"node": "^16.20 || ^18.18 || >= 20.17"
+			}
+		},
+		"node_modules/@stoplight/spectral-functions/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/spectral-parsers": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/@stoplight/spectral-parsers/-/spectral-parsers-1.0.5.tgz",
+			"integrity": "sha512-ANDTp2IHWGvsQDAY85/jQi9ZrF4mRrA5bciNHX+PUxPr4DwS6iv4h+FVWJMVwcEYdpyoIdyL+SRmHdJfQEPmwQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/json": "~3.21.0",
+				"@stoplight/types": "^14.1.1",
+				"@stoplight/yaml": "~4.3.0",
+				"tslib": "^2.8.1"
+			},
+			"engines": {
+				"node": "^16.20 || ^18.18 || >= 20.17"
+			}
+		},
+		"node_modules/@stoplight/spectral-parsers/node_modules/@stoplight/types": {
+			"version": "14.1.1",
+			"resolved": "https://registry.npmjs.org/@stoplight/types/-/types-14.1.1.tgz",
+			"integrity": "sha512-/kjtr+0t0tjKr+heVfviO9FrU/uGLc+QNX3fHJc19xsCNYqU7lVhaXxDmEID9BZTjG+/r9pK9xP/xU02XGg65g==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@types/json-schema": "^7.0.4",
+				"utility-types": "^3.10.0"
+			},
+			"engines": {
+				"node": "^12.20 || >=14.13"
+			}
+		},
+		"node_modules/@stoplight/spectral-parsers/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/spectral-ref-resolver": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/@stoplight/spectral-ref-resolver/-/spectral-ref-resolver-1.0.5.tgz",
+			"integrity": "sha512-gj3TieX5a9zMW29z3mBlAtDOCgN3GEc1VgZnCVlr5irmR4Qi5LuECuFItAq4pTn5Zu+sW5bqutsCH7D4PkpyAA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/json-ref-readers": "1.2.2",
+				"@stoplight/json-ref-resolver": "~3.1.6",
+				"@stoplight/spectral-runtime": "^1.1.2",
+				"dependency-graph": "0.11.0",
+				"tslib": "^2.8.1"
+			},
+			"engines": {
+				"node": "^16.20 || ^18.18 || >= 20.17"
+			}
+		},
+		"node_modules/@stoplight/spectral-ref-resolver/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/spectral-runtime": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/@stoplight/spectral-runtime/-/spectral-runtime-1.1.4.tgz",
+			"integrity": "sha512-YHbhX3dqW0do6DhiPSgSGQzr6yQLlWybhKwWx0cqxjMwxej3TqLv3BXMfIUYFKKUqIwH4Q2mV8rrMM8qD2N0rQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/json": "^3.20.1",
+				"@stoplight/path": "^1.3.2",
+				"@stoplight/types": "^13.6.0",
+				"abort-controller": "^3.0.0",
+				"lodash": "^4.17.21",
+				"node-fetch": "^2.7.0",
+				"tslib": "^2.8.1"
+			},
+			"engines": {
+				"node": "^16.20 || ^18.18 || >= 20.17"
+			}
+		},
+		"node_modules/@stoplight/spectral-runtime/node_modules/node-fetch": {
+			"version": "2.7.0",
+			"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+			"integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+			"license": "MIT",
+			"dependencies": {
+				"whatwg-url": "^5.0.0"
+			},
+			"engines": {
+				"node": "4.x || >=6.0.0"
+			},
+			"peerDependencies": {
+				"encoding": "^0.1.0"
+			},
+			"peerDependenciesMeta": {
+				"encoding": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@stoplight/spectral-runtime/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@stoplight/types": {
+			"version": "13.20.0",
+			"resolved": "https://registry.npmjs.org/@stoplight/types/-/types-13.20.0.tgz",
+			"integrity": "sha512-2FNTv05If7ib79VPDA/r9eUet76jewXFH2y2K5vuge6SXbRHtWBhcaRmu+6QpF4/WRNoJj5XYRSwLGXDxysBGA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@types/json-schema": "^7.0.4",
+				"utility-types": "^3.10.0"
+			},
+			"engines": {
+				"node": "^12.20 || >=14.13"
+			}
+		},
+		"node_modules/@stoplight/yaml": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/@stoplight/yaml/-/yaml-4.3.0.tgz",
+			"integrity": "sha512-JZlVFE6/dYpP9tQmV0/ADfn32L9uFarHWxfcRhReKUnljz1ZiUM5zpX+PH8h5CJs6lao3TuFqnPm9IJJCEkE2w==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@stoplight/ordered-object-literal": "^1.0.5",
+				"@stoplight/types": "^14.1.1",
+				"@stoplight/yaml-ast-parser": "0.0.50",
+				"tslib": "^2.2.0"
+			},
+			"engines": {
+				"node": ">=10.8"
+			}
+		},
+		"node_modules/@stoplight/yaml-ast-parser": {
+			"version": "0.0.50",
+			"resolved": "https://registry.npmjs.org/@stoplight/yaml-ast-parser/-/yaml-ast-parser-0.0.50.tgz",
+			"integrity": "sha512-Pb6M8TDO9DtSVla9yXSTAxmo9GVEouq5P40DWXdOie69bXogZTkgvopCq+yEvTMA0F6PEvdJmbtTV3ccIp11VQ==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@stoplight/yaml/node_modules/@stoplight/types": {
+			"version": "14.1.1",
+			"resolved": "https://registry.npmjs.org/@stoplight/types/-/types-14.1.1.tgz",
+			"integrity": "sha512-/kjtr+0t0tjKr+heVfviO9FrU/uGLc+QNX3fHJc19xsCNYqU7lVhaXxDmEID9BZTjG+/r9pK9xP/xU02XGg65g==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@types/json-schema": "^7.0.4",
+				"utility-types": "^3.10.0"
+			},
+			"engines": {
+				"node": "^12.20 || >=14.13"
+			}
+		},
+		"node_modules/@stoplight/yaml/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/@szmarczak/http-timer": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-5.0.1.tgz",
+			"integrity": "sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==",
+			"license": "MIT",
+			"dependencies": {
+				"defer-to-connect": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/@tootallnate/quickjs-emscripten": {
+			"version": "0.23.0",
+			"resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+			"integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
+			"license": "MIT"
+		},
+		"node_modules/@types/acorn": {
+			"version": "4.0.6",
+			"resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz",
+			"integrity": "sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "*"
+			}
+		},
+		"node_modules/@types/cookie": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.4.1.tgz",
+			"integrity": "sha512-XW/Aa8APYr6jSVVA1y/DEIZX0/GMKLEVekNG727R8cs56ahETkRAy/3DR7+fJyh7oUgGwNQaRfXCun0+KbWY7Q==",
+			"license": "MIT"
+		},
+		"node_modules/@types/cors": {
+			"version": "2.8.19",
+			"resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+			"integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@types/debug": {
+			"version": "4.1.12",
+			"resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
+			"integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/ms": "*"
+			}
+		},
+		"node_modules/@types/es-aggregate-error": {
+			"version": "1.0.6",
+			"resolved": "https://registry.npmjs.org/@types/es-aggregate-error/-/es-aggregate-error-1.0.6.tgz",
+			"integrity": "sha512-qJ7LIFp06h1QE1aVxbVd+zJP2wdaugYXYfd6JxsyRMrYHaxb6itXPogW2tz+ylUJ1n1b+JF1PHyYCfYHm0dvUg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@types/estree": {
+			"version": "1.0.8",
+			"resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+			"integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+			"license": "MIT"
+		},
+		"node_modules/@types/estree-jsx": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+			"integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "*"
+			}
+		},
+		"node_modules/@types/hast": {
+			"version": "3.0.4",
+			"resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+			"integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "*"
+			}
+		},
+		"node_modules/@types/http-cache-semantics": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+			"integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+			"license": "MIT"
+		},
+		"node_modules/@types/json-schema": {
+			"version": "7.0.15",
+			"resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+			"integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+			"license": "MIT"
+		},
+		"node_modules/@types/katex": {
+			"version": "0.16.8",
+			"resolved": "https://registry.npmjs.org/@types/katex/-/katex-0.16.8.tgz",
+			"integrity": "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg==",
+			"license": "MIT"
+		},
+		"node_modules/@types/mdast": {
+			"version": "4.0.4",
+			"resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+			"integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "*"
+			}
+		},
+		"node_modules/@types/mdx": {
+			"version": "2.0.13",
+			"resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz",
+			"integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==",
+			"license": "MIT"
+		},
+		"node_modules/@types/ms": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+			"integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+			"license": "MIT"
+		},
+		"node_modules/@types/nlcst": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/@types/nlcst/-/nlcst-2.0.3.tgz",
+			"integrity": "sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "*"
+			}
+		},
+		"node_modules/@types/node": {
+			"version": "25.2.3",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-25.2.3.tgz",
+			"integrity": "sha512-m0jEgYlYz+mDJZ2+F4v8D1AyQb+QzsNqRuI7xg1VQX/KlKS0qT9r1Mo16yo5F/MtifXFgaofIFsdFMox2SxIbQ==",
+			"license": "MIT",
+			"dependencies": {
+				"undici-types": "~7.16.0"
+			}
+		},
+		"node_modules/@types/react": {
+			"version": "19.2.13",
+			"resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.13.tgz",
+			"integrity": "sha512-KkiJeU6VbYbUOp5ITMIc7kBfqlYkKA5KhEHVrGMmUUMt7NeaZg65ojdPk+FtNrBAOXNVM5QM72jnADjM+XVRAQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"csstype": "^3.2.2"
+			}
+		},
+		"node_modules/@types/unist": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+			"integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+			"license": "MIT"
+		},
+		"node_modules/@types/urijs": {
+			"version": "1.19.26",
+			"resolved": "https://registry.npmjs.org/@types/urijs/-/urijs-1.19.26.tgz",
+			"integrity": "sha512-wkXrVzX5yoqLnndOwFsieJA7oKM8cNkOKJtf/3vVGSUFkWDKZvFHpIl9Pvqb/T9UsawBBFMTTD8xu7sK5MWuvg==",
+			"license": "MIT"
+		},
+		"node_modules/@types/yauzl": {
+			"version": "2.10.3",
+			"resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+			"integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@typescript/vfs": {
+			"version": "1.6.2",
+			"resolved": "https://registry.npmjs.org/@typescript/vfs/-/vfs-1.6.2.tgz",
+			"integrity": "sha512-hoBwJwcbKHmvd2QVebiytN1aELvpk9B74B4L1mFm/XT1Q/VOYAWl2vQ9AWRFtQq8zmz6enTpfTV8WRc4ATjW/g==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "^4.1.1"
+			},
+			"peerDependencies": {
+				"typescript": "*"
+			}
+		},
+		"node_modules/@ungap/structured-clone": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+			"integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+			"license": "ISC"
+		},
+		"node_modules/abort-controller": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+			"integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+			"license": "MIT",
+			"dependencies": {
+				"event-target-shim": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=6.5"
+			}
+		},
+		"node_modules/accepts": {
+			"version": "1.3.8",
+			"resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+			"integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+			"license": "MIT",
+			"dependencies": {
+				"mime-types": "~2.1.34",
+				"negotiator": "0.6.3"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/acorn": {
+			"version": "8.11.2",
+			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
+			"integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
+			"license": "MIT",
+			"bin": {
+				"acorn": "bin/acorn"
+			},
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/acorn-jsx": {
+			"version": "5.3.2",
+			"resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+			"integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+			"license": "MIT",
+			"peerDependencies": {
+				"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+			}
+		},
+		"node_modules/address": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/address/-/address-1.2.2.tgz",
+			"integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.0.0"
+			}
+		},
+		"node_modules/adm-zip": {
+			"version": "0.5.16",
+			"resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.5.16.tgz",
+			"integrity": "sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12.0"
+			}
+		},
+		"node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/aggregate-error": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-4.0.1.tgz",
+			"integrity": "sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==",
+			"license": "MIT",
+			"dependencies": {
+				"clean-stack": "^4.0.0",
+				"indent-string": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/ajv": {
+			"version": "8.17.1",
+			"resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+			"integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+			"license": "MIT",
+			"dependencies": {
+				"fast-deep-equal": "^3.1.3",
+				"fast-uri": "^3.0.1",
+				"json-schema-traverse": "^1.0.0",
+				"require-from-string": "^2.0.2"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/epoberezkin"
+			}
+		},
+		"node_modules/ajv-draft-04": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/ajv-draft-04/-/ajv-draft-04-1.0.0.tgz",
+			"integrity": "sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==",
+			"license": "MIT",
+			"peerDependencies": {
+				"ajv": "^8.5.0"
+			},
+			"peerDependenciesMeta": {
+				"ajv": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/ajv-errors": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/ajv-errors/-/ajv-errors-3.0.0.tgz",
+			"integrity": "sha512-V3wD15YHfHz6y0KdhYFjyy9vWtEVALT9UrxfN3zqlI6dMioHnJrqOYfyPKol3oqrnCM9uwkcdCwkJ0WUcbLMTQ==",
+			"license": "MIT",
+			"peerDependencies": {
+				"ajv": "^8.0.1"
+			}
+		},
+		"node_modules/ajv-formats": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
+			"integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+			"license": "MIT",
+			"dependencies": {
+				"ajv": "^8.0.0"
+			},
+			"peerDependencies": {
+				"ajv": "^8.0.0"
+			},
+			"peerDependenciesMeta": {
+				"ajv": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/ansi-escapes": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.3.0.tgz",
+			"integrity": "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==",
+			"license": "MIT",
+			"dependencies": {
+				"environment": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/ansi-regex": {
+			"version": "6.2.2",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+			"integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-regex?sponsor=1"
+			}
+		},
+		"node_modules/ansi-styles": {
+			"version": "6.2.3",
+			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+			"integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-styles?sponsor=1"
+			}
+		},
+		"node_modules/any-promise": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
+			"integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
+			"license": "MIT"
+		},
+		"node_modules/anymatch": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+			"integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+			"license": "ISC",
+			"dependencies": {
+				"normalize-path": "^3.0.0",
+				"picomatch": "^2.0.4"
+			},
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/arg": {
+			"version": "5.0.2",
+			"resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+			"integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+			"license": "MIT"
+		},
+		"node_modules/argparse": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+			"integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+			"license": "Python-2.0"
+		},
+		"node_modules/aria-hidden": {
+			"version": "1.2.6",
+			"resolved": "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz",
+			"integrity": "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"tslib": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/aria-hidden/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"peer": true
+		},
+		"node_modules/arkregex": {
+			"version": "0.0.3",
+			"resolved": "https://registry.npmjs.org/arkregex/-/arkregex-0.0.3.tgz",
+			"integrity": "sha512-bU21QJOJEFJK+BPNgv+5bVXkvRxyAvgnon75D92newgHxkBJTgiFwQxusyViYyJkETsddPlHyspshDQcCzmkNg==",
+			"license": "MIT",
+			"dependencies": {
+				"@ark/util": "0.55.0"
+			}
+		},
+		"node_modules/arktype": {
+			"version": "2.1.27",
+			"resolved": "https://registry.npmjs.org/arktype/-/arktype-2.1.27.tgz",
+			"integrity": "sha512-enctOHxI4SULBv/TDtCVi5M8oLd4J5SVlPUblXDzSsOYQNMzmVbUosGBnJuZDKmFlN5Ie0/QVEuTE+Z5X1UhsQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@ark/schema": "0.55.0",
+				"@ark/util": "0.55.0",
+				"arkregex": "0.0.3"
+			}
+		},
+		"node_modules/array-buffer-byte-length": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
+			"integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"is-array-buffer": "^3.0.5"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/array-flatten": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+			"integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+			"license": "MIT"
+		},
+		"node_modules/array-iterate": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/array-iterate/-/array-iterate-2.0.1.tgz",
+			"integrity": "sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/arraybuffer.prototype.slice": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
+			"integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
+			"license": "MIT",
+			"dependencies": {
+				"array-buffer-byte-length": "^1.0.1",
+				"call-bind": "^1.0.8",
+				"define-properties": "^1.2.1",
+				"es-abstract": "^1.23.5",
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.6",
+				"is-array-buffer": "^3.0.4"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/ast-types": {
+			"version": "0.13.4",
+			"resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+			"integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+			"license": "MIT",
+			"dependencies": {
+				"tslib": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/ast-types/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/astring": {
+			"version": "1.9.0",
+			"resolved": "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz",
+			"integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==",
+			"license": "MIT",
+			"bin": {
+				"astring": "bin/astring"
+			}
+		},
+		"node_modules/async-function": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
+			"integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/asynckit": {
+			"version": "0.4.0",
+			"resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+			"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+			"license": "MIT"
+		},
+		"node_modules/auto-bind": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/auto-bind/-/auto-bind-5.0.1.tgz",
+			"integrity": "sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/available-typed-arrays": {
+			"version": "1.0.7",
+			"resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
+			"integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
+			"license": "MIT",
+			"dependencies": {
+				"possible-typed-array-names": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/avsc": {
+			"version": "5.7.9",
+			"resolved": "https://registry.npmjs.org/avsc/-/avsc-5.7.9.tgz",
+			"integrity": "sha512-yOA4wFeI7ET3v32Di/sUybQ+ttP20JHSW3mxLuNGeO0uD6PPcvLrIQXSvy/rhJOWU5JrYh7U4OHplWMmtAtjMg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.11"
+			}
+		},
+		"node_modules/axios": {
+			"version": "1.15.0",
+			"resolved": "https://registry.npmjs.org/axios/-/axios-1.15.0.tgz",
+			"integrity": "sha512-wWyJDlAatxk30ZJer+GeCWS209sA42X+N5jU2jy6oHTp7ufw8uzUTVFBX9+wTfAlhiJXGS0Bq7X6efruWjuK9Q==",
+			"license": "MIT",
+			"dependencies": {
+				"follow-redirects": "^1.15.11",
+				"form-data": "^4.0.5",
+				"proxy-from-env": "^2.1.0"
+			}
+		},
+		"node_modules/axios/node_modules/proxy-from-env": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+			"integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/b4a": {
+			"version": "1.7.3",
+			"resolved": "https://registry.npmjs.org/b4a/-/b4a-1.7.3.tgz",
+			"integrity": "sha512-5Q2mfq2WfGuFp3uS//0s6baOJLMoVduPYVeNmDYxu5OUA1/cBfvr2RIS7vi62LdNj/urk1hfmj867I3qt6uZ7Q==",
+			"license": "Apache-2.0",
+			"peerDependencies": {
+				"react-native-b4a": "*"
+			},
+			"peerDependenciesMeta": {
+				"react-native-b4a": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bail": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
+			"integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/balanced-match": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+			"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+			"license": "MIT"
+		},
+		"node_modules/bare-events": {
+			"version": "2.8.2",
+			"resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.2.tgz",
+			"integrity": "sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==",
+			"license": "Apache-2.0",
+			"peerDependencies": {
+				"bare-abort-controller": "*"
+			},
+			"peerDependenciesMeta": {
+				"bare-abort-controller": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-fs": {
+			"version": "4.5.3",
+			"resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.3.tgz",
+			"integrity": "sha512-9+kwVx8QYvt3hPWnmb19tPnh38c6Nihz8Lx3t0g9+4GoIf3/fTgYwM4Z6NxgI+B9elLQA7mLE9PpqcWtOMRDiQ==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"bare-events": "^2.5.4",
+				"bare-path": "^3.0.0",
+				"bare-stream": "^2.6.4",
+				"bare-url": "^2.2.2",
+				"fast-fifo": "^1.3.2"
+			},
+			"engines": {
+				"bare": ">=1.16.0"
+			},
+			"peerDependencies": {
+				"bare-buffer": "*"
+			},
+			"peerDependenciesMeta": {
+				"bare-buffer": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-os": {
+			"version": "3.6.2",
+			"resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+			"integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"engines": {
+				"bare": ">=1.14.0"
+			}
+		},
+		"node_modules/bare-path": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+			"integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"bare-os": "^3.0.1"
+			}
+		},
+		"node_modules/bare-stream": {
+			"version": "2.7.0",
+			"resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+			"integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"streamx": "^2.21.0"
+			},
+			"peerDependencies": {
+				"bare-buffer": "*",
+				"bare-events": "*"
+			},
+			"peerDependenciesMeta": {
+				"bare-buffer": {
+					"optional": true
+				},
+				"bare-events": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/bare-url": {
+			"version": "2.3.2",
+			"resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.3.2.tgz",
+			"integrity": "sha512-ZMq4gd9ngV5aTMa5p9+UfY0b3skwhHELaDkhEHetMdX0LRkW9kzaym4oo/Eh+Ghm0CCDuMTsRIGM/ytUc1ZYmw==",
+			"license": "Apache-2.0",
+			"optional": true,
+			"dependencies": {
+				"bare-path": "^3.0.0"
+			}
+		},
+		"node_modules/base64-js": {
+			"version": "1.5.1",
+			"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+			"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/base64id": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz",
+			"integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==",
+			"license": "MIT",
+			"engines": {
+				"node": "^4.5.0 || >= 5.9"
+			}
+		},
+		"node_modules/basic-ftp": {
+			"version": "5.1.0",
+			"resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.1.0.tgz",
+			"integrity": "sha512-RkaJzeJKDbaDWTIPiJwubyljaEPwpVWkm9Rt5h9Nd6h7tEXTJ3VB4qxdZBioV7JO5yLUaOKwz7vDOzlncUsegw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/better-opn": {
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/better-opn/-/better-opn-3.0.2.tgz",
+			"integrity": "sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ==",
+			"license": "MIT",
+			"dependencies": {
+				"open": "^8.0.4"
+			},
+			"engines": {
+				"node": ">=12.0.0"
+			}
+		},
+		"node_modules/binary-extensions": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+			"integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/body-parser": {
+			"version": "1.20.3",
+			"resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+			"integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+			"license": "MIT",
+			"dependencies": {
+				"bytes": "3.1.2",
+				"content-type": "~1.0.5",
+				"debug": "2.6.9",
+				"depd": "2.0.0",
+				"destroy": "1.2.0",
+				"http-errors": "2.0.0",
+				"iconv-lite": "0.4.24",
+				"on-finished": "2.4.1",
+				"qs": "6.13.0",
+				"raw-body": "2.5.2",
+				"type-is": "~1.6.18",
+				"unpipe": "1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.8",
+				"npm": "1.2.8000 || >= 1.4.16"
+			}
+		},
+		"node_modules/body-parser/node_modules/debug": {
+			"version": "2.6.9",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "2.0.0"
+			}
+		},
+		"node_modules/body-parser/node_modules/iconv-lite": {
+			"version": "0.4.24",
+			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+			"integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+			"license": "MIT",
+			"dependencies": {
+				"safer-buffer": ">= 2.1.2 < 3"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/body-parser/node_modules/ms": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+			"license": "MIT"
+		},
+		"node_modules/brace-expansion": {
+			"version": "1.1.12",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+			"integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+			"license": "MIT",
+			"dependencies": {
+				"balanced-match": "^1.0.0",
+				"concat-map": "0.0.1"
+			}
+		},
+		"node_modules/braces": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+			"integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+			"license": "MIT",
+			"dependencies": {
+				"fill-range": "^7.1.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/buffer": {
+			"version": "5.7.1",
+			"resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+			"integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"base64-js": "^1.3.1",
+				"ieee754": "^1.1.13"
+			}
+		},
+		"node_modules/buffer-crc32": {
+			"version": "0.2.13",
+			"resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+			"integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+			"license": "MIT",
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/bytes": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+			"integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/cacheable-lookup": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz",
+			"integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/cacheable-request": {
+			"version": "10.2.14",
+			"resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-10.2.14.tgz",
+			"integrity": "sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/http-cache-semantics": "^4.0.2",
+				"get-stream": "^6.0.1",
+				"http-cache-semantics": "^4.1.1",
+				"keyv": "^4.5.3",
+				"mimic-response": "^4.0.0",
+				"normalize-url": "^8.0.0",
+				"responselike": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/call-bind": {
+			"version": "1.0.8",
+			"resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+			"integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.0",
+				"es-define-property": "^1.0.0",
+				"get-intrinsic": "^1.2.4",
+				"set-function-length": "^1.2.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/call-bind-apply-helpers": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+			"integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"function-bind": "^1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/call-bound": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+			"integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.2",
+				"get-intrinsic": "^1.3.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/callsites": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+			"integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/camelcase-css": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
+			"integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/ccount": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+			"integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/chalk": {
+			"version": "5.2.0",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-5.2.0.tgz",
+			"integrity": "sha512-ree3Gqw/nazQAPuJJEy+avdl7QfZMcUvmHIKgEZkGL+xOBzRvup5Hxo6LHuMceSxOabuJLJm5Yp/92R9eMmMvA==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.17.0 || ^14.13 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/chalk?sponsor=1"
+			}
+		},
+		"node_modules/character-entities": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
+			"integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/character-entities-html4": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+			"integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/character-entities-legacy": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+			"integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/character-reference-invalid": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+			"integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/chardet": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz",
+			"integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
+			"license": "MIT"
+		},
+		"node_modules/chokidar": {
+			"version": "3.5.3",
+			"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+			"integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
+			"funding": [
+				{
+					"type": "individual",
+					"url": "https://paulmillr.com/funding/"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"anymatch": "~3.1.2",
+				"braces": "~3.0.2",
+				"glob-parent": "~5.1.2",
+				"is-binary-path": "~2.1.0",
+				"is-glob": "~4.0.1",
+				"normalize-path": "~3.0.0",
+				"readdirp": "~3.6.0"
+			},
+			"engines": {
+				"node": ">= 8.10.0"
+			},
+			"optionalDependencies": {
+				"fsevents": "~2.3.2"
+			}
+		},
+		"node_modules/chownr": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+			"integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/chromium-bidi": {
+			"version": "0.6.2",
+			"resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-0.6.2.tgz",
+			"integrity": "sha512-4WVBa6ijmUTVr9cZD4eicQD8Mdy/HCX3bzEIYYpmk0glqYLoWH+LqQEvV9RpDRzoQSbY1KJHloYXbDMXMbDPhg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"mitt": "3.0.1",
+				"urlpattern-polyfill": "10.0.0",
+				"zod": "3.23.8"
+			},
+			"peerDependencies": {
+				"devtools-protocol": "*"
+			}
+		},
+		"node_modules/chromium-bidi/node_modules/zod": {
+			"version": "3.23.8",
+			"resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
+			"integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/colinhacks"
+			}
+		},
+		"node_modules/clean-stack": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-4.2.0.tgz",
+			"integrity": "sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==",
+			"license": "MIT",
+			"dependencies": {
+				"escape-string-regexp": "5.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cli-boxes": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz",
+			"integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cli-cursor": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz",
+			"integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==",
+			"license": "MIT",
+			"dependencies": {
+				"restore-cursor": "^4.0.0"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cli-spinners": {
+			"version": "2.9.2",
+			"resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz",
+			"integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cli-truncate": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz",
+			"integrity": "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==",
+			"license": "MIT",
+			"dependencies": {
+				"slice-ansi": "^5.0.0",
+				"string-width": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cli-truncate/node_modules/is-fullwidth-code-point": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz",
+			"integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cli-truncate/node_modules/slice-ansi": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz",
+			"integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^6.0.0",
+				"is-fullwidth-code-point": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/slice-ansi?sponsor=1"
+			}
+		},
+		"node_modules/cli-width": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+			"integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+			"license": "ISC",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/cliui": {
+			"version": "8.0.1",
+			"resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+			"integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+			"license": "ISC",
+			"dependencies": {
+				"string-width": "^4.2.0",
+				"strip-ansi": "^6.0.1",
+				"wrap-ansi": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/cliui/node_modules/ansi-regex": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/cliui/node_modules/ansi-styles": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+			"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+			"license": "MIT",
+			"dependencies": {
+				"color-convert": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-styles?sponsor=1"
+			}
+		},
+		"node_modules/cliui/node_modules/emoji-regex": {
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+			"license": "MIT"
+		},
+		"node_modules/cliui/node_modules/is-fullwidth-code-point": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+			"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/cliui/node_modules/string-width": {
+			"version": "4.2.3",
+			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+			"license": "MIT",
+			"dependencies": {
+				"emoji-regex": "^8.0.0",
+				"is-fullwidth-code-point": "^3.0.0",
+				"strip-ansi": "^6.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/cliui/node_modules/strip-ansi": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-regex": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/cliui/node_modules/wrap-ansi": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+			"integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^4.0.0",
+				"string-width": "^4.1.0",
+				"strip-ansi": "^6.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+			}
+		},
+		"node_modules/code-excerpt": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/code-excerpt/-/code-excerpt-4.0.0.tgz",
+			"integrity": "sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==",
+			"license": "MIT",
+			"dependencies": {
+				"convert-to-spaces": "^2.0.1"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			}
+		},
+		"node_modules/collapse-white-space": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
+			"integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/color": {
+			"version": "4.2.3",
+			"resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz",
+			"integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==",
+			"license": "MIT",
+			"dependencies": {
+				"color-convert": "^2.0.1",
+				"color-string": "^1.9.0"
+			},
+			"engines": {
+				"node": ">=12.5.0"
+			}
+		},
+		"node_modules/color-blend": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/color-blend/-/color-blend-4.0.0.tgz",
+			"integrity": "sha512-fYODTHhI/NG+B5GnzvuL3kiFrK/UnkUezWFTgEPBTY5V+kpyfAn95Vn9sJeeCX6omrCOdxnqCL3CvH+6sXtIbw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/color-convert": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+			"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+			"license": "MIT",
+			"dependencies": {
+				"color-name": "~1.1.4"
+			},
+			"engines": {
+				"node": ">=7.0.0"
+			}
+		},
+		"node_modules/color-name": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+			"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+			"license": "MIT"
+		},
+		"node_modules/color-string": {
+			"version": "1.9.1",
+			"resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz",
+			"integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==",
+			"license": "MIT",
+			"dependencies": {
+				"color-name": "^1.0.0",
+				"simple-swizzle": "^0.2.2"
+			}
+		},
+		"node_modules/combined-stream": {
+			"version": "1.0.8",
+			"resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+			"integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+			"license": "MIT",
+			"dependencies": {
+				"delayed-stream": "~1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/comma-separated-tokens": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+			"integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/commander": {
+			"version": "8.3.0",
+			"resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
+			"integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/concat-map": {
+			"version": "0.0.1",
+			"resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+			"integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+			"license": "MIT"
+		},
+		"node_modules/content-disposition": {
+			"version": "0.5.4",
+			"resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+			"integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+			"license": "MIT",
+			"dependencies": {
+				"safe-buffer": "5.2.1"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/content-type": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+			"integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/convert-to-spaces": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/convert-to-spaces/-/convert-to-spaces-2.0.1.tgz",
+			"integrity": "sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			}
+		},
+		"node_modules/cookie": {
+			"version": "0.7.0",
+			"resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.0.tgz",
+			"integrity": "sha512-qCf+V4dtlNhSRXGAZatc1TasyFO6GjohcOul807YOb5ik3+kQSnb4d7iajeCL8QHaJ4uZEjCgiCJerKXwdRVlQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/cookie-signature": {
+			"version": "1.0.6",
+			"resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+			"integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+			"license": "MIT"
+		},
+		"node_modules/cors": {
+			"version": "2.8.6",
+			"resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+			"integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
+			"license": "MIT",
+			"dependencies": {
+				"object-assign": "^4",
+				"vary": "^1"
+			},
+			"engines": {
+				"node": ">= 0.10"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/express"
+			}
+		},
+		"node_modules/cosmiconfig": {
+			"version": "9.0.0",
+			"resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz",
+			"integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==",
+			"license": "MIT",
+			"dependencies": {
+				"env-paths": "^2.2.1",
+				"import-fresh": "^3.3.0",
+				"js-yaml": "^4.1.0",
+				"parse-json": "^5.2.0"
+			},
+			"engines": {
+				"node": ">=14"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/d-fischer"
+			},
+			"peerDependencies": {
+				"typescript": ">=4.9.5"
+			},
+			"peerDependenciesMeta": {
+				"typescript": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/cssesc": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+			"integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+			"license": "MIT",
+			"bin": {
+				"cssesc": "bin/cssesc"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/csstype": {
+			"version": "3.2.3",
+			"resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+			"integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+			"license": "MIT",
+			"peer": true
+		},
+		"node_modules/data-uri-to-buffer": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+			"integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/data-view-buffer": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
+			"integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"es-errors": "^1.3.0",
+				"is-data-view": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/data-view-byte-length": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
+			"integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"es-errors": "^1.3.0",
+				"is-data-view": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/inspect-js"
+			}
+		},
+		"node_modules/data-view-byte-offset": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
+			"integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"es-errors": "^1.3.0",
+				"is-data-view": "^1.0.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/debug": {
+			"version": "4.4.3",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+			"integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"peerDependenciesMeta": {
+				"supports-color": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/decode-bmp": {
+			"version": "0.2.1",
+			"resolved": "https://registry.npmjs.org/decode-bmp/-/decode-bmp-0.2.1.tgz",
+			"integrity": "sha512-NiOaGe+GN0KJqi2STf24hfMkFitDUaIoUU3eKvP/wAbLe8o6FuW5n/x7MHPR0HKvBokp6MQY/j7w8lewEeVCIA==",
+			"license": "MIT",
+			"dependencies": {
+				"@canvas/image-data": "^1.0.0",
+				"to-data-view": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=8.6.0"
+			}
+		},
+		"node_modules/decode-ico": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/decode-ico/-/decode-ico-0.4.1.tgz",
+			"integrity": "sha512-69NZfbKIzux1vBOd31al3XnMnH+2mqDhEgLdpygErm4d60N+UwA5Sq5WFjmEDQzumgB9fElojGwWG0vybVfFmA==",
+			"license": "MIT",
+			"dependencies": {
+				"@canvas/image-data": "^1.0.0",
+				"decode-bmp": "^0.2.0",
+				"to-data-view": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=8.6"
+			}
+		},
+		"node_modules/decode-named-character-reference": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+			"integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
+			"license": "MIT",
+			"dependencies": {
+				"character-entities": "^2.0.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/decompress-response": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+			"integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+			"license": "MIT",
+			"dependencies": {
+				"mimic-response": "^3.1.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/decompress-response/node_modules/mimic-response": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+			"integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/defer-to-connect": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
+			"integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/define-data-property": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+			"integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+			"license": "MIT",
+			"dependencies": {
+				"es-define-property": "^1.0.0",
+				"es-errors": "^1.3.0",
+				"gopd": "^1.0.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/define-lazy-prop": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
+			"integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/define-properties": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+			"integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+			"license": "MIT",
+			"dependencies": {
+				"define-data-property": "^1.0.1",
+				"has-property-descriptors": "^1.0.0",
+				"object-keys": "^1.1.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/degenerator": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+			"integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ast-types": "^0.13.4",
+				"escodegen": "^2.1.0",
+				"esprima": "^4.0.1"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/delayed-stream": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+			"integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/depd": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+			"integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/dependency-graph": {
+			"version": "0.11.0",
+			"resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-0.11.0.tgz",
+			"integrity": "sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6.0"
+			}
+		},
+		"node_modules/dequal": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+			"integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/destroy": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+			"integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8",
+				"npm": "1.2.8000 || >= 1.4.16"
+			}
+		},
+		"node_modules/detect-libc": {
+			"version": "2.1.2",
+			"resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+			"integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/detect-node-es": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz",
+			"integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==",
+			"license": "MIT",
+			"peer": true
+		},
+		"node_modules/detect-port": {
+			"version": "1.5.1",
+			"resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.5.1.tgz",
+			"integrity": "sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==",
+			"license": "MIT",
+			"dependencies": {
+				"address": "^1.0.1",
+				"debug": "4"
+			},
+			"bin": {
+				"detect": "bin/detect-port.js",
+				"detect-port": "bin/detect-port.js"
+			}
+		},
+		"node_modules/devlop": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+			"integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+			"license": "MIT",
+			"dependencies": {
+				"dequal": "^2.0.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/devtools-protocol": {
+			"version": "0.0.1312386",
+			"resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1312386.tgz",
+			"integrity": "sha512-DPnhUXvmvKT2dFA/j7B+riVLUt9Q6RKJlcppojL5CoRywJJKLDYnRlw0gTFKfgDPHP5E04UoB71SxoJlVZy8FA==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/didyoumean": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
+			"integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/dlv": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
+			"integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
+			"license": "MIT"
+		},
+		"node_modules/dns-packet": {
+			"version": "5.6.1",
+			"resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz",
+			"integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==",
+			"license": "MIT",
+			"dependencies": {
+				"@leichtgewicht/ip-codec": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/dns-socket": {
+			"version": "4.2.2",
+			"resolved": "https://registry.npmjs.org/dns-socket/-/dns-socket-4.2.2.tgz",
+			"integrity": "sha512-BDeBd8najI4/lS00HSKpdFia+OvUMytaVjfzR9n5Lq8MlZRSvtbI+uLtx1+XmQFls5wFU9dssccTmQQ6nfpjdg==",
+			"license": "MIT",
+			"dependencies": {
+				"dns-packet": "^5.2.4"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/dunder-proto": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+			"integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"gopd": "^1.2.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/ee-first": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+			"integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+			"license": "MIT"
+		},
+		"node_modules/emoji-regex": {
+			"version": "10.6.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
+			"integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
+			"license": "MIT"
+		},
+		"node_modules/encodeurl": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+			"integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/end-of-stream": {
+			"version": "1.4.5",
+			"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+			"integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+			"license": "MIT",
+			"dependencies": {
+				"once": "^1.4.0"
+			}
+		},
+		"node_modules/engine.io": {
+			"version": "6.5.5",
+			"resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.5.5.tgz",
+			"integrity": "sha512-C5Pn8Wk+1vKBoHghJODM63yk8MvrO9EWZUfkAt5HAqIgPE4/8FF0PEGHXtEd40l223+cE5ABWuPzm38PHFXfMA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/cookie": "^0.4.1",
+				"@types/cors": "^2.8.12",
+				"@types/node": ">=10.0.0",
+				"accepts": "~1.3.4",
+				"base64id": "2.0.0",
+				"cookie": "~0.4.1",
+				"cors": "~2.8.5",
+				"debug": "~4.3.1",
+				"engine.io-parser": "~5.2.1",
+				"ws": "~8.17.1"
+			},
+			"engines": {
+				"node": ">=10.2.0"
+			}
+		},
+		"node_modules/engine.io-parser": {
+			"version": "5.2.3",
+			"resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-5.2.3.tgz",
+			"integrity": "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/engine.io/node_modules/debug": {
+			"version": "4.3.7",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+			"integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"peerDependenciesMeta": {
+				"supports-color": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/engine.io/node_modules/ws": {
+			"version": "8.17.1",
+			"resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+			"integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			},
+			"peerDependencies": {
+				"bufferutil": "^4.0.1",
+				"utf-8-validate": ">=5.0.2"
+			},
+			"peerDependenciesMeta": {
+				"bufferutil": {
+					"optional": true
+				},
+				"utf-8-validate": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/entities": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+			"integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.12"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/entities?sponsor=1"
+			}
+		},
+		"node_modules/env-paths": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+			"integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/environment": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
+			"integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/error-ex": {
+			"version": "1.3.4",
+			"resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",
+			"integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
+			"license": "MIT",
+			"dependencies": {
+				"is-arrayish": "^0.2.1"
+			}
+		},
+		"node_modules/es-abstract": {
+			"version": "1.24.1",
+			"resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.1.tgz",
+			"integrity": "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==",
+			"license": "MIT",
+			"dependencies": {
+				"array-buffer-byte-length": "^1.0.2",
+				"arraybuffer.prototype.slice": "^1.0.4",
+				"available-typed-arrays": "^1.0.7",
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.4",
+				"data-view-buffer": "^1.0.2",
+				"data-view-byte-length": "^1.0.2",
+				"data-view-byte-offset": "^1.0.1",
+				"es-define-property": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"es-object-atoms": "^1.1.1",
+				"es-set-tostringtag": "^2.1.0",
+				"es-to-primitive": "^1.3.0",
+				"function.prototype.name": "^1.1.8",
+				"get-intrinsic": "^1.3.0",
+				"get-proto": "^1.0.1",
+				"get-symbol-description": "^1.1.0",
+				"globalthis": "^1.0.4",
+				"gopd": "^1.2.0",
+				"has-property-descriptors": "^1.0.2",
+				"has-proto": "^1.2.0",
+				"has-symbols": "^1.1.0",
+				"hasown": "^2.0.2",
+				"internal-slot": "^1.1.0",
+				"is-array-buffer": "^3.0.5",
+				"is-callable": "^1.2.7",
+				"is-data-view": "^1.0.2",
+				"is-negative-zero": "^2.0.3",
+				"is-regex": "^1.2.1",
+				"is-set": "^2.0.3",
+				"is-shared-array-buffer": "^1.0.4",
+				"is-string": "^1.1.1",
+				"is-typed-array": "^1.1.15",
+				"is-weakref": "^1.1.1",
+				"math-intrinsics": "^1.1.0",
+				"object-inspect": "^1.13.4",
+				"object-keys": "^1.1.1",
+				"object.assign": "^4.1.7",
+				"own-keys": "^1.0.1",
+				"regexp.prototype.flags": "^1.5.4",
+				"safe-array-concat": "^1.1.3",
+				"safe-push-apply": "^1.0.0",
+				"safe-regex-test": "^1.1.0",
+				"set-proto": "^1.0.0",
+				"stop-iteration-iterator": "^1.1.0",
+				"string.prototype.trim": "^1.2.10",
+				"string.prototype.trimend": "^1.0.9",
+				"string.prototype.trimstart": "^1.0.8",
+				"typed-array-buffer": "^1.0.3",
+				"typed-array-byte-length": "^1.0.3",
+				"typed-array-byte-offset": "^1.0.4",
+				"typed-array-length": "^1.0.7",
+				"unbox-primitive": "^1.1.0",
+				"which-typed-array": "^1.1.19"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/es-aggregate-error": {
+			"version": "1.0.14",
+			"resolved": "https://registry.npmjs.org/es-aggregate-error/-/es-aggregate-error-1.0.14.tgz",
+			"integrity": "sha512-3YxX6rVb07B5TV11AV5wsL7nQCHXNwoHPsQC8S4AmBiqYhyNCJ5BRKXkXyDJvs8QzXN20NgRtxe3dEEQD9NLHA==",
+			"license": "MIT",
+			"dependencies": {
+				"define-data-property": "^1.1.4",
+				"define-properties": "^1.2.1",
+				"es-abstract": "^1.24.0",
+				"es-errors": "^1.3.0",
+				"function-bind": "^1.1.2",
+				"globalthis": "^1.0.4",
+				"has-property-descriptors": "^1.0.2",
+				"set-function-name": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/es-define-property": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+			"integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-errors": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+			"integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-object-atoms": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+			"integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-set-tostringtag": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+			"integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.6",
+				"has-tostringtag": "^1.0.2",
+				"hasown": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-to-primitive": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz",
+			"integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==",
+			"license": "MIT",
+			"dependencies": {
+				"is-callable": "^1.2.7",
+				"is-date-object": "^1.0.5",
+				"is-symbol": "^1.0.4"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/es-toolkit": {
+			"version": "1.44.0",
+			"resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.44.0.tgz",
+			"integrity": "sha512-6penXeZalaV88MM3cGkFZZfOoLGWshWWfdy0tWw/RlVVyhvMaWSBTOvXNeiW3e5FwdS5ePW0LGEu17zT139ktg==",
+			"license": "MIT",
+			"workspaces": [
+				"docs",
+				"benchmarks"
+			]
+		},
+		"node_modules/esast-util-from-estree": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz",
+			"integrity": "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-visit": "^2.0.0",
+				"unist-util-position-from-estree": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/esast-util-from-js": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz",
+			"integrity": "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"acorn": "^8.0.0",
+				"esast-util-from-estree": "^2.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/escalade": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+			"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/escape-html": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+			"integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+			"license": "MIT"
+		},
+		"node_modules/escape-string-regexp": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+			"integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/escodegen": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+			"integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"esprima": "^4.0.1",
+				"estraverse": "^5.2.0",
+				"esutils": "^2.0.2"
+			},
+			"bin": {
+				"escodegen": "bin/escodegen.js",
+				"esgenerate": "bin/esgenerate.js"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"optionalDependencies": {
+				"source-map": "~0.6.1"
+			}
+		},
+		"node_modules/escodegen/node_modules/source-map": {
+			"version": "0.6.1",
+			"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+			"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+			"license": "BSD-3-Clause",
+			"optional": true,
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/esprima": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+			"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+			"license": "BSD-2-Clause",
+			"bin": {
+				"esparse": "bin/esparse.js",
+				"esvalidate": "bin/esvalidate.js"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/estraverse": {
+			"version": "5.3.0",
+			"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+			"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=4.0"
+			}
+		},
+		"node_modules/estree-util-attach-comments": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz",
+			"integrity": "sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/estree-util-build-jsx": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz",
+			"integrity": "sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-is-identifier-name": "^3.0.0",
+				"estree-walker": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/estree-util-is-identifier-name": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+			"integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+			"license": "MIT",
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/estree-util-scope": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/estree-util-scope/-/estree-util-scope-1.0.0.tgz",
+			"integrity": "sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"devlop": "^1.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/estree-util-to-js": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz",
+			"integrity": "sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"astring": "^1.8.0",
+				"source-map": "^0.7.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/estree-util-visit": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/estree-util-visit/-/estree-util-visit-2.0.0.tgz",
+			"integrity": "sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/estree-walker": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+			"integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0"
+			}
+		},
+		"node_modules/esutils": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+			"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/etag": {
+			"version": "1.8.1",
+			"resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+			"integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/event-target-shim": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+			"integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/events-universal": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
+			"integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"bare-events": "^2.7.0"
+			}
+		},
+		"node_modules/express": {
+			"version": "4.20.0",
+			"resolved": "https://registry.npmjs.org/express/-/express-4.20.0.tgz",
+			"integrity": "sha512-pLdae7I6QqShF5PnNTCVn4hI91Dx0Grkn2+IAsMTgMIKuQVte2dN9PeGSSAME2FR8anOhVA62QDIUaWVfEXVLw==",
+			"license": "MIT",
+			"dependencies": {
+				"accepts": "~1.3.8",
+				"array-flatten": "1.1.1",
+				"body-parser": "1.20.3",
+				"content-disposition": "0.5.4",
+				"content-type": "~1.0.4",
+				"cookie": "0.6.0",
+				"cookie-signature": "1.0.6",
+				"debug": "2.6.9",
+				"depd": "2.0.0",
+				"encodeurl": "~2.0.0",
+				"escape-html": "~1.0.3",
+				"etag": "~1.8.1",
+				"finalhandler": "1.2.0",
+				"fresh": "0.5.2",
+				"http-errors": "2.0.0",
+				"merge-descriptors": "1.0.3",
+				"methods": "~1.1.2",
+				"on-finished": "2.4.1",
+				"parseurl": "~1.3.3",
+				"path-to-regexp": "0.1.10",
+				"proxy-addr": "~2.0.7",
+				"qs": "6.11.0",
+				"range-parser": "~1.2.1",
+				"safe-buffer": "5.2.1",
+				"send": "0.19.0",
+				"serve-static": "1.16.0",
+				"setprototypeof": "1.2.0",
+				"statuses": "2.0.1",
+				"type-is": "~1.6.18",
+				"utils-merge": "1.0.1",
+				"vary": "~1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.10.0"
+			}
+		},
+		"node_modules/express/node_modules/debug": {
+			"version": "2.6.9",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "2.0.0"
+			}
+		},
+		"node_modules/express/node_modules/encodeurl": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+			"integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/express/node_modules/ms": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+			"license": "MIT"
+		},
+		"node_modules/extend": {
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+			"integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+			"license": "MIT"
+		},
+		"node_modules/extract-zip": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+			"integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"debug": "^4.1.1",
+				"get-stream": "^5.1.0",
+				"yauzl": "^2.10.0"
+			},
+			"bin": {
+				"extract-zip": "cli.js"
+			},
+			"engines": {
+				"node": ">= 10.17.0"
+			},
+			"optionalDependencies": {
+				"@types/yauzl": "^2.9.1"
+			}
+		},
+		"node_modules/extract-zip/node_modules/get-stream": {
+			"version": "5.2.0",
+			"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+			"integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+			"license": "MIT",
+			"dependencies": {
+				"pump": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/fast-deep-equal": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+			"integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+			"license": "MIT"
+		},
+		"node_modules/fast-fifo": {
+			"version": "1.3.2",
+			"resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+			"integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+			"license": "MIT"
+		},
+		"node_modules/fast-glob": {
+			"version": "3.3.3",
+			"resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+			"integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+			"license": "MIT",
+			"dependencies": {
+				"@nodelib/fs.stat": "^2.0.2",
+				"@nodelib/fs.walk": "^1.2.3",
+				"glob-parent": "^5.1.2",
+				"merge2": "^1.3.0",
+				"micromatch": "^4.0.8"
+			},
+			"engines": {
+				"node": ">=8.6.0"
+			}
+		},
+		"node_modules/fast-memoize": {
+			"version": "2.5.2",
+			"resolved": "https://registry.npmjs.org/fast-memoize/-/fast-memoize-2.5.2.tgz",
+			"integrity": "sha512-Ue0LwpDYErFbmNnZSF0UH6eImUwDmogUO1jyE+JbN2gsQz/jICm1Ve7t9QT0rNSsfJt+Hs4/S3GnsDVjL4HVrw==",
+			"license": "MIT"
+		},
+		"node_modules/fast-uri": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
+			"integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/fastify"
+				},
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/fastify"
+				}
+			],
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/fastq": {
+			"version": "1.20.1",
+			"resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
+			"integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+			"license": "ISC",
+			"dependencies": {
+				"reusify": "^1.0.4"
+			}
+		},
+		"node_modules/fault": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/fault/-/fault-2.0.1.tgz",
+			"integrity": "sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==",
+			"license": "MIT",
+			"dependencies": {
+				"format": "^0.2.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/favicons": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/favicons/-/favicons-7.2.0.tgz",
+			"integrity": "sha512-k/2rVBRIRzOeom3wI9jBPaSEvoTSQEW4iM0EveBmBBKFxO8mSyyRWtDlfC3VnEfu0avmjrMzy8/ZFPSe6F71Hw==",
+			"license": "MIT",
+			"dependencies": {
+				"escape-html": "^1.0.3",
+				"sharp": "^0.33.1",
+				"xml2js": "^0.6.1"
+			},
+			"engines": {
+				"node": ">=14.0.0"
+			}
+		},
+		"node_modules/fd-slicer": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+			"integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+			"license": "MIT",
+			"dependencies": {
+				"pend": "~1.2.0"
+			}
+		},
+		"node_modules/fill-range": {
+			"version": "7.1.1",
+			"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+			"integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+			"license": "MIT",
+			"dependencies": {
+				"to-regex-range": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/finalhandler": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+			"integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "2.6.9",
+				"encodeurl": "~1.0.2",
+				"escape-html": "~1.0.3",
+				"on-finished": "2.4.1",
+				"parseurl": "~1.3.3",
+				"statuses": "2.0.1",
+				"unpipe": "~1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/finalhandler/node_modules/debug": {
+			"version": "2.6.9",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "2.0.0"
+			}
+		},
+		"node_modules/finalhandler/node_modules/ms": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+			"license": "MIT"
+		},
+		"node_modules/follow-redirects": {
+			"version": "1.15.11",
+			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+			"integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+			"funding": [
+				{
+					"type": "individual",
+					"url": "https://github.com/sponsors/RubenVerborgh"
+				}
+			],
+			"license": "MIT",
+			"engines": {
+				"node": ">=4.0"
+			},
+			"peerDependenciesMeta": {
+				"debug": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/for-each": {
+			"version": "0.3.5",
+			"resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+			"integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
+			"license": "MIT",
+			"dependencies": {
+				"is-callable": "^1.2.7"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/form-data": {
+			"version": "4.0.5",
+			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+			"integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+			"license": "MIT",
+			"dependencies": {
+				"asynckit": "^0.4.0",
+				"combined-stream": "^1.0.8",
+				"es-set-tostringtag": "^2.1.0",
+				"hasown": "^2.0.2",
+				"mime-types": "^2.1.12"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/form-data-encoder": {
+			"version": "2.1.4",
+			"resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-2.1.4.tgz",
+			"integrity": "sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14.17"
+			}
+		},
+		"node_modules/format": {
+			"version": "0.2.2",
+			"resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
+			"integrity": "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==",
+			"engines": {
+				"node": ">=0.4.x"
+			}
+		},
+		"node_modules/forwarded": {
+			"version": "0.2.0",
+			"resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+			"integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/fresh": {
+			"version": "0.5.2",
+			"resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+			"integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/front-matter": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/front-matter/-/front-matter-4.0.2.tgz",
+			"integrity": "sha512-I8ZuJ/qG92NWX8i5x1Y8qyj3vizhXS31OxjKDu3LKP+7/qBgfIKValiZIEwoVoJKUHlhWtYrktkxV1XsX+pPlg==",
+			"license": "MIT",
+			"dependencies": {
+				"js-yaml": "^3.13.1"
+			}
+		},
+		"node_modules/fs-extra": {
+			"version": "11.2.0",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
+			"integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/fs-minipass": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+			"integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^3.0.0"
+			},
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/fs-minipass/node_modules/minipass": {
+			"version": "3.3.6",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+			"license": "ISC",
+			"dependencies": {
+				"yallist": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/fsevents": {
+			"version": "2.3.3",
+			"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+			"integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+			"hasInstallScript": true,
+			"license": "MIT",
+			"optional": true,
+			"os": [
+				"darwin"
+			],
+			"engines": {
+				"node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+			}
+		},
+		"node_modules/function-bind": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+			"integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/function.prototype.name": {
+			"version": "1.1.8",
+			"resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz",
+			"integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.3",
+				"define-properties": "^1.2.1",
+				"functions-have-names": "^1.2.3",
+				"hasown": "^2.0.2",
+				"is-callable": "^1.2.7"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/functions-have-names": {
+			"version": "1.2.3",
+			"resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
+			"integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/gcd": {
+			"version": "0.0.1",
+			"resolved": "https://registry.npmjs.org/gcd/-/gcd-0.0.1.tgz",
+			"integrity": "sha512-VNx3UEGr+ILJTiMs1+xc5SX1cMgJCrXezKPa003APUWNqQqaF6n25W8VcR7nHN6yRWbvvUTwCpZCFJeWC2kXlw==",
+			"license": "MIT"
+		},
+		"node_modules/generator-function": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
+			"integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/get-caller-file": {
+			"version": "2.0.5",
+			"resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+			"integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+			"license": "ISC",
+			"engines": {
+				"node": "6.* || 8.* || >= 10.*"
+			}
+		},
+		"node_modules/get-east-asian-width": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.4.0.tgz",
+			"integrity": "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/get-intrinsic": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+			"integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.2",
+				"es-define-property": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"es-object-atoms": "^1.1.1",
+				"function-bind": "^1.1.2",
+				"get-proto": "^1.0.1",
+				"gopd": "^1.2.0",
+				"has-symbols": "^1.1.0",
+				"hasown": "^2.0.2",
+				"math-intrinsics": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/get-nonce": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz",
+			"integrity": "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==",
+			"license": "MIT",
+			"peer": true,
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/get-proto": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+			"integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+			"license": "MIT",
+			"dependencies": {
+				"dunder-proto": "^1.0.1",
+				"es-object-atoms": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/get-stream": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
+			"integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/get-symbol-description": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
+			"integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.6"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/get-uri": {
+			"version": "6.0.5",
+			"resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+			"integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+			"license": "MIT",
+			"dependencies": {
+				"basic-ftp": "^5.0.2",
+				"data-uri-to-buffer": "^6.0.2",
+				"debug": "^4.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/glob-parent": {
+			"version": "5.1.2",
+			"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+			"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+			"license": "ISC",
+			"dependencies": {
+				"is-glob": "^4.0.1"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/globalthis": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+			"integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+			"license": "MIT",
+			"dependencies": {
+				"define-properties": "^1.2.1",
+				"gopd": "^1.0.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/gopd": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+			"integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/got": {
+			"version": "13.0.0",
+			"resolved": "https://registry.npmjs.org/got/-/got-13.0.0.tgz",
+			"integrity": "sha512-XfBk1CxOOScDcMr9O1yKkNaQyy865NbYs+F7dr4H0LZMVgCj2Le59k6PqbNHoL5ToeaEQUYh6c6yMfVcc6SJxA==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^5.2.0",
+				"@szmarczak/http-timer": "^5.0.1",
+				"cacheable-lookup": "^7.0.0",
+				"cacheable-request": "^10.2.8",
+				"decompress-response": "^6.0.0",
+				"form-data-encoder": "^2.1.2",
+				"get-stream": "^6.0.1",
+				"http2-wrapper": "^2.1.10",
+				"lowercase-keys": "^3.0.0",
+				"p-cancelable": "^3.0.0",
+				"responselike": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=16"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/got?sponsor=1"
+			}
+		},
+		"node_modules/graceful-fs": {
+			"version": "4.2.11",
+			"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+			"integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+			"license": "ISC"
+		},
+		"node_modules/has-bigints": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
+			"integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/has-property-descriptors": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+			"integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+			"license": "MIT",
+			"dependencies": {
+				"es-define-property": "^1.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/has-proto": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
+			"integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
+			"license": "MIT",
+			"dependencies": {
+				"dunder-proto": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/has-symbols": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+			"integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/has-tostringtag": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+			"integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+			"license": "MIT",
+			"dependencies": {
+				"has-symbols": "^1.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/hasown": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+			"integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+			"license": "MIT",
+			"dependencies": {
+				"function-bind": "^1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/hast-util-embedded": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/hast-util-embedded/-/hast-util-embedded-3.0.0.tgz",
+			"integrity": "sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-is-element": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-from-dom": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/hast-util-from-dom/-/hast-util-from-dom-5.0.1.tgz",
+			"integrity": "sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==",
+			"license": "ISC",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hastscript": "^9.0.0",
+				"web-namespaces": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-from-html": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz",
+			"integrity": "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"devlop": "^1.1.0",
+				"hast-util-from-parse5": "^8.0.0",
+				"parse5": "^7.0.0",
+				"vfile": "^6.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-from-html-isomorphic": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz",
+			"integrity": "sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-from-dom": "^5.0.0",
+				"hast-util-from-html": "^2.0.0",
+				"unist-util-remove-position": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-from-parse5": {
+			"version": "8.0.3",
+			"resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz",
+			"integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/unist": "^3.0.0",
+				"devlop": "^1.0.0",
+				"hastscript": "^9.0.0",
+				"property-information": "^7.0.0",
+				"vfile": "^6.0.0",
+				"vfile-location": "^5.0.0",
+				"web-namespaces": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-has-property": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/hast-util-has-property/-/hast-util-has-property-3.0.0.tgz",
+			"integrity": "sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-is-body-ok-link": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/hast-util-is-body-ok-link/-/hast-util-is-body-ok-link-3.0.1.tgz",
+			"integrity": "sha512-0qpnzOBLztXHbHQenVB8uNuxTnm/QBFUOmdOSsEn7GnBtyY07+ENTWVFBAnXd/zEgd9/SUG3lRY7hSIBWRgGpQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-is-element": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz",
+			"integrity": "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-minify-whitespace": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/hast-util-minify-whitespace/-/hast-util-minify-whitespace-1.0.1.tgz",
+			"integrity": "sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-embedded": "^3.0.0",
+				"hast-util-is-element": "^3.0.0",
+				"hast-util-whitespace": "^3.0.0",
+				"unist-util-is": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-parse-selector": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
+			"integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-phrasing": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/hast-util-phrasing/-/hast-util-phrasing-3.0.1.tgz",
+			"integrity": "sha512-6h60VfI3uBQUxHqTyMymMZnEbNl1XmEGtOxxKYL7stY2o601COo62AWAYBQR9lZbYXYSBoxag8UpPRXK+9fqSQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-embedded": "^3.0.0",
+				"hast-util-has-property": "^3.0.0",
+				"hast-util-is-body-ok-link": "^3.0.0",
+				"hast-util-is-element": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-to-estree": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz",
+			"integrity": "sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"comma-separated-tokens": "^2.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-attach-comments": "^3.0.0",
+				"estree-util-is-identifier-name": "^3.0.0",
+				"hast-util-whitespace": "^3.0.0",
+				"mdast-util-mdx-expression": "^2.0.0",
+				"mdast-util-mdx-jsx": "^3.0.0",
+				"mdast-util-mdxjs-esm": "^2.0.0",
+				"property-information": "^7.0.0",
+				"space-separated-tokens": "^2.0.0",
+				"style-to-js": "^1.0.0",
+				"unist-util-position": "^5.0.0",
+				"zwitch": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-to-html": {
+			"version": "9.0.4",
+			"resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.4.tgz",
+			"integrity": "sha512-wxQzXtdbhiwGAUKrnQJXlOPmHnEehzphwkK7aluUPQ+lEc1xefC8pblMgpp2w5ldBTEfveRIrADcrhGIWrlTDA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"comma-separated-tokens": "^2.0.0",
+				"hast-util-whitespace": "^3.0.0",
+				"html-void-elements": "^3.0.0",
+				"mdast-util-to-hast": "^13.0.0",
+				"property-information": "^6.0.0",
+				"space-separated-tokens": "^2.0.0",
+				"stringify-entities": "^4.0.0",
+				"zwitch": "^2.0.4"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-to-html/node_modules/property-information": {
+			"version": "6.5.0",
+			"resolved": "https://registry.npmjs.org/property-information/-/property-information-6.5.0.tgz",
+			"integrity": "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/hast-util-to-jsx-runtime": {
+			"version": "2.3.6",
+			"resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+			"integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/unist": "^3.0.0",
+				"comma-separated-tokens": "^2.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-is-identifier-name": "^3.0.0",
+				"hast-util-whitespace": "^3.0.0",
+				"mdast-util-mdx-expression": "^2.0.0",
+				"mdast-util-mdx-jsx": "^3.0.0",
+				"mdast-util-mdxjs-esm": "^2.0.0",
+				"property-information": "^7.0.0",
+				"space-separated-tokens": "^2.0.0",
+				"style-to-js": "^1.0.0",
+				"unist-util-position": "^5.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-to-mdast": {
+			"version": "10.1.0",
+			"resolved": "https://registry.npmjs.org/hast-util-to-mdast/-/hast-util-to-mdast-10.1.0.tgz",
+			"integrity": "sha512-DsL/SvCK9V7+vfc6SLQ+vKIyBDXTk2KLSbfBYkH4zeF/uR1yBajHRhkzuaUSGOB1WJSTieJBdHwxlC+HLKvZZw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@ungap/structured-clone": "^1.0.0",
+				"hast-util-phrasing": "^3.0.0",
+				"hast-util-to-html": "^9.0.0",
+				"hast-util-to-text": "^4.0.0",
+				"hast-util-whitespace": "^3.0.0",
+				"mdast-util-phrasing": "^4.0.0",
+				"mdast-util-to-hast": "^13.0.0",
+				"mdast-util-to-string": "^4.0.0",
+				"rehype-minify-whitespace": "^6.0.0",
+				"trim-trailing-lines": "^2.0.0",
+				"unist-util-position": "^5.0.0",
+				"unist-util-visit": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-to-string": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/hast-util-to-string/-/hast-util-to-string-3.0.1.tgz",
+			"integrity": "sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-to-text": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz",
+			"integrity": "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/unist": "^3.0.0",
+				"hast-util-is-element": "^3.0.0",
+				"unist-util-find-after": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hast-util-whitespace": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+			"integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hastscript": {
+			"version": "9.0.1",
+			"resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.1.tgz",
+			"integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"comma-separated-tokens": "^2.0.0",
+				"hast-util-parse-selector": "^4.0.0",
+				"property-information": "^7.0.0",
+				"space-separated-tokens": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/hex-rgb": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/hex-rgb/-/hex-rgb-5.0.0.tgz",
+			"integrity": "sha512-NQO+lgVUCtHxZ792FodgW0zflK+ozS9X9dwGp9XvvmPlH7pyxd588cn24TD3rmPm/N0AIRXF10Otah8yKqGw4w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/html-void-elements": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
+			"integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/http-cache-semantics": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+			"integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+			"license": "BSD-2-Clause"
+		},
+		"node_modules/http-errors": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+			"integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+			"license": "MIT",
+			"dependencies": {
+				"depd": "2.0.0",
+				"inherits": "2.0.4",
+				"setprototypeof": "1.2.0",
+				"statuses": "2.0.1",
+				"toidentifier": "1.0.1"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/http-proxy-agent": {
+			"version": "7.0.2",
+			"resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+			"integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.0",
+				"debug": "^4.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/http2-wrapper": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz",
+			"integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==",
+			"license": "MIT",
+			"dependencies": {
+				"quick-lru": "^5.1.1",
+				"resolve-alpn": "^1.2.0"
+			},
+			"engines": {
+				"node": ">=10.19.0"
+			}
+		},
+		"node_modules/https-proxy-agent": {
+			"version": "7.0.6",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+			"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/ico-endec": {
+			"version": "0.1.6",
+			"resolved": "https://registry.npmjs.org/ico-endec/-/ico-endec-0.1.6.tgz",
+			"integrity": "sha512-ZdLU38ZoED3g1j3iEyzcQj+wAkY2xfWNkymszfJPoxucIUhK7NayQ+/C4Kv0nDFMIsbtbEHldv3V8PU494/ueQ==",
+			"license": "MPL-2.0"
+		},
+		"node_modules/iconv-lite": {
+			"version": "0.7.2",
+			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+			"integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+			"license": "MIT",
+			"dependencies": {
+				"safer-buffer": ">= 2.1.2 < 3.0.0"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/express"
+			}
+		},
+		"node_modules/ieee754": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+			"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/ignore": {
+			"version": "7.0.5",
+			"resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+			"integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/immer": {
+			"version": "9.0.21",
+			"resolved": "https://registry.npmjs.org/immer/-/immer-9.0.21.tgz",
+			"integrity": "sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==",
+			"license": "MIT",
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/immer"
+			}
+		},
+		"node_modules/import-fresh": {
+			"version": "3.3.1",
+			"resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+			"integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+			"license": "MIT",
+			"dependencies": {
+				"parent-module": "^1.0.0",
+				"resolve-from": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/indent-string": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz",
+			"integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/inherits": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+			"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+			"license": "ISC"
+		},
+		"node_modules/ink": {
+			"version": "6.3.0",
+			"resolved": "https://registry.npmjs.org/ink/-/ink-6.3.0.tgz",
+			"integrity": "sha512-2CbJAa7XeziZYe6pDS5RVLirRY28iSGMQuEV8jRU5NQsONQNfcR/BZHHc9vkMg2lGYTHTM2pskxC1YmY28p6bQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@alcalzone/ansi-tokenize": "^0.2.0",
+				"ansi-escapes": "^7.0.0",
+				"ansi-styles": "^6.2.1",
+				"auto-bind": "^5.0.1",
+				"chalk": "^5.6.0",
+				"cli-boxes": "^3.0.0",
+				"cli-cursor": "^4.0.0",
+				"cli-truncate": "^4.0.0",
+				"code-excerpt": "^4.0.0",
+				"es-toolkit": "^1.39.10",
+				"indent-string": "^5.0.0",
+				"is-in-ci": "^2.0.0",
+				"patch-console": "^2.0.0",
+				"react-reconciler": "^0.32.0",
+				"signal-exit": "^3.0.7",
+				"slice-ansi": "^7.1.0",
+				"stack-utils": "^2.0.6",
+				"string-width": "^7.2.0",
+				"type-fest": "^4.27.0",
+				"widest-line": "^5.0.0",
+				"wrap-ansi": "^9.0.0",
+				"ws": "^8.18.0",
+				"yoga-layout": "~3.2.1"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"peerDependencies": {
+				"@types/react": ">=19.0.0",
+				"react": ">=19.0.0",
+				"react-devtools-core": "^4.19.1"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				},
+				"react-devtools-core": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/ink-spinner": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/ink-spinner/-/ink-spinner-5.0.0.tgz",
+			"integrity": "sha512-EYEasbEjkqLGyPOUc8hBJZNuC5GvXGMLu0w5gdTNskPc7Izc5vO3tdQEYnzvshucyGCBXc86ig0ujXPMWaQCdA==",
+			"license": "MIT",
+			"dependencies": {
+				"cli-spinners": "^2.7.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"peerDependencies": {
+				"ink": ">=4.0.0",
+				"react": ">=18.0.0"
+			}
+		},
+		"node_modules/ink/node_modules/chalk": {
+			"version": "5.6.2",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+			"integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.17.0 || ^14.13 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/chalk?sponsor=1"
+			}
+		},
+		"node_modules/ink/node_modules/signal-exit": {
+			"version": "3.0.7",
+			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+			"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+			"license": "ISC"
+		},
+		"node_modules/ink/node_modules/wrap-ansi": {
+			"version": "9.0.2",
+			"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
+			"integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^6.2.1",
+				"string-width": "^7.0.0",
+				"strip-ansi": "^7.1.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+			}
+		},
+		"node_modules/inline-style-parser": {
+			"version": "0.2.7",
+			"resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+			"integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
+			"license": "MIT"
+		},
+		"node_modules/inquirer": {
+			"version": "12.3.0",
+			"resolved": "https://registry.npmjs.org/inquirer/-/inquirer-12.3.0.tgz",
+			"integrity": "sha512-3NixUXq+hM8ezj2wc7wC37b32/rHq1MwNZDYdvx+d6jokOD+r+i8Q4Pkylh9tISYP114A128LCX8RKhopC5RfQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@inquirer/core": "^10.1.2",
+				"@inquirer/prompts": "^7.2.1",
+				"@inquirer/type": "^3.0.2",
+				"ansi-escapes": "^4.3.2",
+				"mute-stream": "^2.0.0",
+				"run-async": "^3.0.0",
+				"rxjs": "^7.8.1"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"peerDependencies": {
+				"@types/node": ">=18"
+			}
+		},
+		"node_modules/inquirer/node_modules/ansi-escapes": {
+			"version": "4.3.2",
+			"resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
+			"integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
+			"license": "MIT",
+			"dependencies": {
+				"type-fest": "^0.21.3"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/inquirer/node_modules/type-fest": {
+			"version": "0.21.3",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
+			"integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
+			"license": "(MIT OR CC0-1.0)",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/internal-slot": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
+			"integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"hasown": "^2.0.2",
+				"side-channel": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/ip-address": {
+			"version": "10.1.0",
+			"resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.1.0.tgz",
+			"integrity": "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/ip-regex": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/ip-regex/-/ip-regex-4.3.0.tgz",
+			"integrity": "sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/ipaddr.js": {
+			"version": "1.9.1",
+			"resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+			"integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.10"
+			}
+		},
+		"node_modules/is-alphabetical": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+			"integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/is-alphanumerical": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+			"integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+			"license": "MIT",
+			"dependencies": {
+				"is-alphabetical": "^2.0.0",
+				"is-decimal": "^2.0.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/is-array-buffer": {
+			"version": "3.0.5",
+			"resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
+			"integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.3",
+				"get-intrinsic": "^1.2.6"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-arrayish": {
+			"version": "0.2.1",
+			"resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+			"integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+			"license": "MIT"
+		},
+		"node_modules/is-async-function": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
+			"integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
+			"license": "MIT",
+			"dependencies": {
+				"async-function": "^1.0.0",
+				"call-bound": "^1.0.3",
+				"get-proto": "^1.0.1",
+				"has-tostringtag": "^1.0.2",
+				"safe-regex-test": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-bigint": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
+			"integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
+			"license": "MIT",
+			"dependencies": {
+				"has-bigints": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-binary-path": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+			"integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+			"license": "MIT",
+			"dependencies": {
+				"binary-extensions": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/is-boolean-object": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
+			"integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"has-tostringtag": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-callable": {
+			"version": "1.2.7",
+			"resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
+			"integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-core-module": {
+			"version": "2.16.1",
+			"resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+			"integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+			"license": "MIT",
+			"dependencies": {
+				"hasown": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-data-view": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
+			"integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"get-intrinsic": "^1.2.6",
+				"is-typed-array": "^1.1.13"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-date-object": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
+			"integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"has-tostringtag": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-decimal": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz",
+			"integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/is-docker": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
+			"integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
+			"license": "MIT",
+			"bin": {
+				"is-docker": "cli.js"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-extglob": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+			"integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/is-finalizationregistry": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
+			"integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-fullwidth-code-point": {
+			"version": "5.1.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz",
+			"integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==",
+			"license": "MIT",
+			"dependencies": {
+				"get-east-asian-width": "^1.3.1"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-generator-function": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz",
+			"integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.4",
+				"generator-function": "^2.0.0",
+				"get-proto": "^1.0.1",
+				"has-tostringtag": "^1.0.2",
+				"safe-regex-test": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-glob": {
+			"version": "4.0.3",
+			"resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+			"integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+			"license": "MIT",
+			"dependencies": {
+				"is-extglob": "^2.1.1"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/is-hexadecimal": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+			"integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/is-in-ci": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/is-in-ci/-/is-in-ci-2.0.0.tgz",
+			"integrity": "sha512-cFeerHriAnhrQSbpAxL37W1wcJKUUX07HyLWZCW1URJT/ra3GyUTzBgUnh24TMVfNTV2Hij2HLxkPHFZfOZy5w==",
+			"license": "MIT",
+			"bin": {
+				"is-in-ci": "cli.js"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-ip": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/is-ip/-/is-ip-3.1.0.tgz",
+			"integrity": "sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==",
+			"license": "MIT",
+			"dependencies": {
+				"ip-regex": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/is-map": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
+			"integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-negative-zero": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
+			"integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-number": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+			"integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.12.0"
+			}
+		},
+		"node_modules/is-number-object": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
+			"integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"has-tostringtag": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-online": {
+			"version": "10.0.0",
+			"resolved": "https://registry.npmjs.org/is-online/-/is-online-10.0.0.tgz",
+			"integrity": "sha512-WCPdKwNDjXJJmUubf2VHLMDBkUZEtuOvpXUfUnUFbEnM6In9ByiScL4f4jKACz/fsb2qDkesFerW3snf/AYz3A==",
+			"license": "MIT",
+			"dependencies": {
+				"got": "^12.1.0",
+				"p-any": "^4.0.0",
+				"p-timeout": "^5.1.0",
+				"public-ip": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-online/node_modules/got": {
+			"version": "12.6.1",
+			"resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz",
+			"integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^5.2.0",
+				"@szmarczak/http-timer": "^5.0.1",
+				"cacheable-lookup": "^7.0.0",
+				"cacheable-request": "^10.2.8",
+				"decompress-response": "^6.0.0",
+				"form-data-encoder": "^2.1.2",
+				"get-stream": "^6.0.1",
+				"http2-wrapper": "^2.1.10",
+				"lowercase-keys": "^3.0.0",
+				"p-cancelable": "^3.0.0",
+				"responselike": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/got?sponsor=1"
+			}
+		},
+		"node_modules/is-plain-obj": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+			"integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/is-regex": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
+			"integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"gopd": "^1.2.0",
+				"has-tostringtag": "^1.0.2",
+				"hasown": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-set": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
+			"integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-shared-array-buffer": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
+			"integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-string": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
+			"integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"has-tostringtag": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-symbol": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
+			"integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"has-symbols": "^1.1.0",
+				"safe-regex-test": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-typed-array": {
+			"version": "1.1.15",
+			"resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+			"integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+			"license": "MIT",
+			"dependencies": {
+				"which-typed-array": "^1.1.16"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-weakmap": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
+			"integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-weakref": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
+			"integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-weakset": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
+			"integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"get-intrinsic": "^1.2.6"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/is-wsl": {
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
+			"integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+			"license": "MIT",
+			"dependencies": {
+				"is-docker": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/isarray": {
+			"version": "2.0.5",
+			"resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+			"integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+			"license": "MIT"
+		},
+		"node_modules/jiti": {
+			"version": "1.21.7",
+			"resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+			"integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+			"license": "MIT",
+			"bin": {
+				"jiti": "bin/jiti.js"
+			}
+		},
+		"node_modules/js-tokens": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+			"integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+			"license": "MIT"
+		},
+		"node_modules/js-yaml": {
+			"version": "4.1.1",
+			"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+			"integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+			"license": "MIT",
+			"dependencies": {
+				"argparse": "^2.0.1"
+			},
+			"bin": {
+				"js-yaml": "bin/js-yaml.js"
+			}
+		},
+		"node_modules/jsep": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/jsep/-/jsep-1.4.0.tgz",
+			"integrity": "sha512-B7qPcEVE3NVkmSJbaYxvv4cHkVW7DQsZz13pUMrfS8z8Q/BuShN+gcTXrUlPiGqM2/t/EEaI030bpxMqY8gMlw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.16.0"
+			}
+		},
+		"node_modules/json-buffer": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+			"integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+			"license": "MIT"
+		},
+		"node_modules/json-parse-even-better-errors": {
+			"version": "2.3.1",
+			"resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+			"integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+			"license": "MIT"
+		},
+		"node_modules/json-schema-traverse": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+			"integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+			"license": "MIT"
+		},
+		"node_modules/jsonc-parser": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.2.1.tgz",
+			"integrity": "sha512-o6/yDBYccGvTz1+QFevz6l6OBZ2+fMVu2JZ9CIhzsYRX4mjaK5IyX9eldUdCmga16zlgQxyrj5pt9kzuj2C02w==",
+			"license": "MIT"
+		},
+		"node_modules/jsonfile": {
+			"version": "6.2.0",
+			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+			"integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+			"license": "MIT",
+			"dependencies": {
+				"universalify": "^2.0.0"
+			},
+			"optionalDependencies": {
+				"graceful-fs": "^4.1.6"
+			}
+		},
+		"node_modules/jsonpath-plus": {
+			"version": "10.3.0",
+			"resolved": "https://registry.npmjs.org/jsonpath-plus/-/jsonpath-plus-10.3.0.tgz",
+			"integrity": "sha512-8TNmfeTCk2Le33A3vRRwtuworG/L5RrgMvdjhKZxvyShO+mBu2fP50OWUjRLNtvw344DdDarFh9buFAZs5ujeA==",
+			"license": "MIT",
+			"dependencies": {
+				"@jsep-plugin/assignment": "^1.3.0",
+				"@jsep-plugin/regex": "^1.0.4",
+				"jsep": "^1.4.0"
+			},
+			"bin": {
+				"jsonpath": "bin/jsonpath-cli.js",
+				"jsonpath-plus": "bin/jsonpath-cli.js"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/jsonpointer": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
+			"integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/katex": {
+			"version": "0.16.28",
+			"resolved": "https://registry.npmjs.org/katex/-/katex-0.16.28.tgz",
+			"integrity": "sha512-YHzO7721WbmAL6Ov1uzN/l5mY5WWWhJBSW+jq4tkfZfsxmo1hu6frS0EOswvjBUnWE6NtjEs48SFn5CQESRLZg==",
+			"funding": [
+				"https://opencollective.com/katex",
+				"https://github.com/sponsors/katex"
+			],
+			"license": "MIT",
+			"dependencies": {
+				"commander": "^8.3.0"
+			},
+			"bin": {
+				"katex": "cli.js"
+			}
+		},
+		"node_modules/keyv": {
+			"version": "4.5.4",
+			"resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+			"integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+			"license": "MIT",
+			"dependencies": {
+				"json-buffer": "3.0.1"
+			}
+		},
+		"node_modules/lcm": {
+			"version": "0.0.3",
+			"resolved": "https://registry.npmjs.org/lcm/-/lcm-0.0.3.tgz",
+			"integrity": "sha512-TB+ZjoillV6B26Vspf9l2L/vKaRY/4ep3hahcyVkCGFgsTNRUQdc24bQeNFiZeoxH0vr5+7SfNRMQuPHv/1IrQ==",
+			"license": "MIT",
+			"dependencies": {
+				"gcd": "^0.0.1"
+			}
+		},
+		"node_modules/leven": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/leven/-/leven-4.1.0.tgz",
+			"integrity": "sha512-KZ9W9nWDT7rF7Dazg8xyLHGLrmpgq2nVNFUckhqdW3szVP6YhCpp/RAnpmVExA9JvrMynjwSLVrEj3AepHR6ew==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/lilconfig": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
+			"integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/lines-and-columns": {
+			"version": "1.2.4",
+			"resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+			"integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+			"license": "MIT"
+		},
+		"node_modules/lodash": {
+			"version": "4.17.21",
+			"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+			"integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+			"license": "MIT"
+		},
+		"node_modules/lodash.topath": {
+			"version": "4.5.2",
+			"resolved": "https://registry.npmjs.org/lodash.topath/-/lodash.topath-4.5.2.tgz",
+			"integrity": "sha512-1/W4dM+35DwvE/iEd1M9ekewOSTlpFekhw9mhAtrwjVqUr83/ilQiyAvmg4tVX7Unkcfl1KC+i9WdaT4B6aQcg==",
+			"license": "MIT"
+		},
+		"node_modules/longest-streak": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
+			"integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/loose-envify": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+			"integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"js-tokens": "^3.0.0 || ^4.0.0"
+			},
+			"bin": {
+				"loose-envify": "cli.js"
+			}
+		},
+		"node_modules/lowercase-keys": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz",
+			"integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/lru-cache": {
+			"version": "7.18.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+			"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/markdown-extensions": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
+			"integrity": "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/markdown-table": {
+			"version": "3.0.4",
+			"resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz",
+			"integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/math-intrinsics": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+			"integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/mdast-util-find-and-replace": {
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz",
+			"integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"escape-string-regexp": "^5.0.0",
+				"unist-util-is": "^6.0.0",
+				"unist-util-visit-parents": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-from-markdown": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz",
+			"integrity": "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"decode-named-character-reference": "^1.0.0",
+				"devlop": "^1.0.0",
+				"mdast-util-to-string": "^4.0.0",
+				"micromark": "^4.0.0",
+				"micromark-util-decode-numeric-character-reference": "^2.0.0",
+				"micromark-util-decode-string": "^2.0.0",
+				"micromark-util-normalize-identifier": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0",
+				"unist-util-stringify-position": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-frontmatter": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz",
+			"integrity": "sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.0.0",
+				"escape-string-regexp": "^5.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"micromark-extension-frontmatter": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-gfm": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.0.0.tgz",
+			"integrity": "sha512-dgQEX5Amaq+DuUqf26jJqSK9qgixgd6rYDHAv4aTBuA92cTknZlKpPfa86Z/s8Dj8xsAQpFfBmPUHWJBWqS4Bw==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-gfm-autolink-literal": "^2.0.0",
+				"mdast-util-gfm-footnote": "^2.0.0",
+				"mdast-util-gfm-strikethrough": "^2.0.0",
+				"mdast-util-gfm-table": "^2.0.0",
+				"mdast-util-gfm-task-list-item": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-gfm-autolink-literal": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz",
+			"integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.0.0",
+				"mdast-util-find-and-replace": "^3.0.0",
+				"micromark-util-character": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-gfm-footnote": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz",
+			"integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"micromark-util-normalize-identifier": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-gfm-strikethrough": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz",
+			"integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-gfm-table": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz",
+			"integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.0.0",
+				"markdown-table": "^3.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-gfm-task-list-item": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz",
+			"integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-math": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-math/-/mdast-util-math-3.0.0.tgz",
+			"integrity": "sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.0.0",
+				"longest-streak": "^3.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.1.0",
+				"unist-util-remove-position": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-mdx": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz",
+			"integrity": "sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-mdx-expression": "^2.0.0",
+				"mdast-util-mdx-jsx": "^3.0.0",
+				"mdast-util-mdxjs-esm": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-mdx-expression": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+			"integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-mdx-jsx": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+			"integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"ccount": "^2.0.0",
+				"devlop": "^1.1.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"parse-entities": "^4.0.0",
+				"stringify-entities": "^4.0.0",
+				"unist-util-stringify-position": "^4.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-mdxjs-esm": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+			"integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree-jsx": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"devlop": "^1.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"mdast-util-to-markdown": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-phrasing": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+			"integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"unist-util-is": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-to-hast": {
+			"version": "13.2.1",
+			"resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+			"integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"@ungap/structured-clone": "^1.0.0",
+				"devlop": "^1.0.0",
+				"micromark-util-sanitize-uri": "^2.0.0",
+				"trim-lines": "^3.0.0",
+				"unist-util-position": "^5.0.0",
+				"unist-util-visit": "^5.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-to-markdown": {
+			"version": "2.1.2",
+			"resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+			"integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"@types/unist": "^3.0.0",
+				"longest-streak": "^3.0.0",
+				"mdast-util-phrasing": "^4.0.0",
+				"mdast-util-to-string": "^4.0.0",
+				"micromark-util-classify-character": "^2.0.0",
+				"micromark-util-decode-string": "^2.0.0",
+				"unist-util-visit": "^5.0.0",
+				"zwitch": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/mdast-util-to-string": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+			"integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/media-typer": {
+			"version": "0.3.0",
+			"resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+			"integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/merge-descriptors": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+			"integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/merge2": {
+			"version": "1.4.1",
+			"resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+			"integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/methods": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+			"integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/micromark": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
+			"integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"@types/debug": "^4.0.0",
+				"debug": "^4.0.0",
+				"decode-named-character-reference": "^1.0.0",
+				"devlop": "^1.0.0",
+				"micromark-core-commonmark": "^2.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-chunked": "^2.0.0",
+				"micromark-util-combine-extensions": "^2.0.0",
+				"micromark-util-decode-numeric-character-reference": "^2.0.0",
+				"micromark-util-encode": "^2.0.0",
+				"micromark-util-normalize-identifier": "^2.0.0",
+				"micromark-util-resolve-all": "^2.0.0",
+				"micromark-util-sanitize-uri": "^2.0.0",
+				"micromark-util-subtokenize": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-core-commonmark": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+			"integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"decode-named-character-reference": "^1.0.0",
+				"devlop": "^1.0.0",
+				"micromark-factory-destination": "^2.0.0",
+				"micromark-factory-label": "^2.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-factory-title": "^2.0.0",
+				"micromark-factory-whitespace": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-chunked": "^2.0.0",
+				"micromark-util-classify-character": "^2.0.0",
+				"micromark-util-html-tag-name": "^2.0.0",
+				"micromark-util-normalize-identifier": "^2.0.0",
+				"micromark-util-resolve-all": "^2.0.0",
+				"micromark-util-subtokenize": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-extension-frontmatter": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz",
+			"integrity": "sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==",
+			"license": "MIT",
+			"dependencies": {
+				"fault": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz",
+			"integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==",
+			"license": "MIT",
+			"dependencies": {
+				"micromark-extension-gfm-autolink-literal": "^2.0.0",
+				"micromark-extension-gfm-footnote": "^2.0.0",
+				"micromark-extension-gfm-strikethrough": "^2.0.0",
+				"micromark-extension-gfm-table": "^2.0.0",
+				"micromark-extension-gfm-tagfilter": "^2.0.0",
+				"micromark-extension-gfm-task-list-item": "^2.0.0",
+				"micromark-util-combine-extensions": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm-autolink-literal": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz",
+			"integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==",
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-sanitize-uri": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm-footnote": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz",
+			"integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==",
+			"license": "MIT",
+			"dependencies": {
+				"devlop": "^1.0.0",
+				"micromark-core-commonmark": "^2.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-normalize-identifier": "^2.0.0",
+				"micromark-util-sanitize-uri": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm-strikethrough": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz",
+			"integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==",
+			"license": "MIT",
+			"dependencies": {
+				"devlop": "^1.0.0",
+				"micromark-util-chunked": "^2.0.0",
+				"micromark-util-classify-character": "^2.0.0",
+				"micromark-util-resolve-all": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm-table": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz",
+			"integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==",
+			"license": "MIT",
+			"dependencies": {
+				"devlop": "^1.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm-tagfilter": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz",
+			"integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==",
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-gfm-task-list-item": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz",
+			"integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==",
+			"license": "MIT",
+			"dependencies": {
+				"devlop": "^1.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-math": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz",
+			"integrity": "sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/katex": "^0.16.0",
+				"devlop": "^1.0.0",
+				"katex": "^0.16.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-mdx-expression": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.1.tgz",
+			"integrity": "sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"devlop": "^1.0.0",
+				"micromark-factory-mdx-expression": "^2.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-events-to-acorn": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-extension-mdx-jsx": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.1.tgz",
+			"integrity": "sha512-vNuFb9czP8QCtAQcEJn0UJQJZA8Dk6DXKBqx+bg/w0WGuSxDxNr7hErW89tHUY31dUW4NqEOWwmEUNhjTFmHkg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/acorn": "^4.0.0",
+				"@types/estree": "^1.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-is-identifier-name": "^3.0.0",
+				"micromark-factory-mdx-expression": "^2.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-events-to-acorn": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-mdx-md": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz",
+			"integrity": "sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==",
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-mdxjs": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz",
+			"integrity": "sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==",
+			"license": "MIT",
+			"dependencies": {
+				"acorn": "^8.0.0",
+				"acorn-jsx": "^5.0.0",
+				"micromark-extension-mdx-expression": "^3.0.0",
+				"micromark-extension-mdx-jsx": "^3.0.0",
+				"micromark-extension-mdx-md": "^2.0.0",
+				"micromark-extension-mdxjs-esm": "^3.0.0",
+				"micromark-util-combine-extensions": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-extension-mdxjs-esm": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz",
+			"integrity": "sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"devlop": "^1.0.0",
+				"micromark-core-commonmark": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-events-to-acorn": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0",
+				"unist-util-position-from-estree": "^2.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/micromark-factory-destination": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+			"integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-factory-label": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+			"integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"devlop": "^1.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-factory-mdx-expression": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.3.tgz",
+			"integrity": "sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"devlop": "^1.0.0",
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-events-to-acorn": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0",
+				"unist-util-position-from-estree": "^2.0.0",
+				"vfile-message": "^4.0.0"
+			}
+		},
+		"node_modules/micromark-factory-space": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+			"integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-factory-title": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+			"integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-factory-whitespace": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+			"integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-factory-space": "^2.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-character": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+			"integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-chunked": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+			"integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-symbol": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-classify-character": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+			"integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-combine-extensions": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+			"integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-chunked": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-decode-numeric-character-reference": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+			"integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-symbol": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-decode-string": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+			"integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"decode-named-character-reference": "^1.0.0",
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-decode-numeric-character-reference": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-encode": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+			"integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/micromark-util-events-to-acorn": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.3.tgz",
+			"integrity": "sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"@types/unist": "^3.0.0",
+				"devlop": "^1.0.0",
+				"estree-util-visit": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0",
+				"vfile-message": "^4.0.0"
+			}
+		},
+		"node_modules/micromark-util-html-tag-name": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+			"integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/micromark-util-normalize-identifier": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+			"integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-symbol": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-resolve-all": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+			"integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-sanitize-uri": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+			"integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"micromark-util-character": "^2.0.0",
+				"micromark-util-encode": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-subtokenize": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+			"integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"devlop": "^1.0.0",
+				"micromark-util-chunked": "^2.0.0",
+				"micromark-util-symbol": "^2.0.0",
+				"micromark-util-types": "^2.0.0"
+			}
+		},
+		"node_modules/micromark-util-symbol": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+			"integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/micromark-util-types": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+			"integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+			"funding": [
+				{
+					"type": "GitHub Sponsors",
+					"url": "https://github.com/sponsors/unifiedjs"
+				},
+				{
+					"type": "OpenCollective",
+					"url": "https://opencollective.com/unified"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/micromatch": {
+			"version": "4.0.8",
+			"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+			"integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+			"license": "MIT",
+			"dependencies": {
+				"braces": "^3.0.3",
+				"picomatch": "^2.3.1"
+			},
+			"engines": {
+				"node": ">=8.6"
+			}
+		},
+		"node_modules/mime": {
+			"version": "1.6.0",
+			"resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+			"integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+			"license": "MIT",
+			"bin": {
+				"mime": "cli.js"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/mime-db": {
+			"version": "1.52.0",
+			"resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+			"integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/mime-types": {
+			"version": "2.1.35",
+			"resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+			"integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+			"license": "MIT",
+			"dependencies": {
+				"mime-db": "1.52.0"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/mimic-fn": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+			"integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/mimic-response": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz",
+			"integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/minimatch": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+			"integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^1.1.7"
+			},
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/minipass": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+			"integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/minizlib": {
+			"version": "2.1.2",
+			"resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+			"integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+			"license": "MIT",
+			"dependencies": {
+				"minipass": "^3.0.0",
+				"yallist": "^4.0.0"
+			},
+			"engines": {
+				"node": ">= 8"
+			}
+		},
+		"node_modules/minizlib/node_modules/minipass": {
+			"version": "3.3.6",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+			"license": "ISC",
+			"dependencies": {
+				"yallist": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/mintlify": {
+			"version": "4.2.338",
+			"resolved": "https://registry.npmjs.org/mintlify/-/mintlify-4.2.338.tgz",
+			"integrity": "sha512-uWswdD4oEyVCcBeoFmJx8VMXXkK0ad1qFJ+Tli7T93oSJZWlGlRPs6SlDwFgksdX2UdJWHQgvrja7G8Wzxq41w==",
+			"license": "Elastic-2.0",
+			"dependencies": {
+				"@mintlify/cli": "4.0.942"
+			},
+			"bin": {
+				"mint": "index.js",
+				"mintlify": "index.js"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/mitt": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+			"integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+			"license": "MIT"
+		},
+		"node_modules/mkdirp": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+			"integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+			"license": "MIT",
+			"bin": {
+				"mkdirp": "bin/cmd.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/ms": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+			"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+			"license": "MIT"
+		},
+		"node_modules/mute-stream": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-2.0.0.tgz",
+			"integrity": "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==",
+			"license": "ISC",
+			"engines": {
+				"node": "^18.17.0 || >=20.5.0"
+			}
+		},
+		"node_modules/mz": {
+			"version": "2.7.0",
+			"resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
+			"integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
+			"license": "MIT",
+			"dependencies": {
+				"any-promise": "^1.0.0",
+				"object-assign": "^4.0.1",
+				"thenify-all": "^1.0.0"
+			}
+		},
+		"node_modules/nanoid": {
+			"version": "3.3.11",
+			"resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+			"integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"bin": {
+				"nanoid": "bin/nanoid.cjs"
+			},
+			"engines": {
+				"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+			}
+		},
+		"node_modules/negotiator": {
+			"version": "0.6.3",
+			"resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+			"integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/neotraverse": {
+			"version": "0.6.18",
+			"resolved": "https://registry.npmjs.org/neotraverse/-/neotraverse-0.6.18.tgz",
+			"integrity": "sha512-Z4SmBUweYa09+o6pG+eASabEpP6QkQ70yHj351pQoEXIs8uHbaU2DWVmzBANKgflPa47A50PtB2+NgRpQvr7vA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10"
+			}
+		},
+		"node_modules/netmask": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
+			"integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4.0"
+			}
+		},
+		"node_modules/nimma": {
+			"version": "0.2.3",
+			"resolved": "https://registry.npmjs.org/nimma/-/nimma-0.2.3.tgz",
+			"integrity": "sha512-1ZOI8J+1PKKGceo/5CT5GfQOG6H8I2BencSK06YarZ2wXwH37BSSUWldqJmMJYA5JfqDqffxDXynt6f11AyKcA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@jsep-plugin/regex": "^1.0.1",
+				"@jsep-plugin/ternary": "^1.0.2",
+				"astring": "^1.8.1",
+				"jsep": "^1.2.0"
+			},
+			"engines": {
+				"node": "^12.20 || >=14.13"
+			},
+			"optionalDependencies": {
+				"jsonpath-plus": "^6.0.1 || ^10.1.0",
+				"lodash.topath": "^4.5.2"
+			}
+		},
+		"node_modules/nlcst-to-string": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/nlcst-to-string/-/nlcst-to-string-4.0.0.tgz",
+			"integrity": "sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/nlcst": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/node-fetch": {
+			"version": "2.6.7",
+			"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
+			"integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
+			"license": "MIT",
+			"dependencies": {
+				"whatwg-url": "^5.0.0"
+			},
+			"engines": {
+				"node": "4.x || >=6.0.0"
+			},
+			"peerDependencies": {
+				"encoding": "^0.1.0"
+			},
+			"peerDependenciesMeta": {
+				"encoding": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/normalize-path": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+			"integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/normalize-url": {
+			"version": "8.1.1",
+			"resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.1.1.tgz",
+			"integrity": "sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/object-assign": {
+			"version": "4.1.1",
+			"resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+			"integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/object-hash": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
+			"integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/object-inspect": {
+			"version": "1.13.4",
+			"resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+			"integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/object-keys": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+			"integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/object.assign": {
+			"version": "4.1.7",
+			"resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
+			"integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.3",
+				"define-properties": "^1.2.1",
+				"es-object-atoms": "^1.0.0",
+				"has-symbols": "^1.1.0",
+				"object-keys": "^1.1.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/on-finished": {
+			"version": "2.4.1",
+			"resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+			"integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+			"license": "MIT",
+			"dependencies": {
+				"ee-first": "1.1.1"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/once": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+			"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+			"license": "ISC",
+			"dependencies": {
+				"wrappy": "1"
+			}
+		},
+		"node_modules/onetime": {
+			"version": "5.1.2",
+			"resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+			"integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+			"license": "MIT",
+			"dependencies": {
+				"mimic-fn": "^2.1.0"
+			},
+			"engines": {
+				"node": ">=6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/oniguruma-parser": {
+			"version": "0.12.1",
+			"resolved": "https://registry.npmjs.org/oniguruma-parser/-/oniguruma-parser-0.12.1.tgz",
+			"integrity": "sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==",
+			"license": "MIT"
+		},
+		"node_modules/oniguruma-to-es": {
+			"version": "4.3.4",
+			"resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.4.tgz",
+			"integrity": "sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==",
+			"license": "MIT",
+			"dependencies": {
+				"oniguruma-parser": "^0.12.1",
+				"regex": "^6.0.1",
+				"regex-recursion": "^6.0.2"
+			}
+		},
+		"node_modules/open": {
+			"version": "8.4.2",
+			"resolved": "https://registry.npmjs.org/open/-/open-8.4.2.tgz",
+			"integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==",
+			"license": "MIT",
+			"dependencies": {
+				"define-lazy-prop": "^2.0.0",
+				"is-docker": "^2.1.1",
+				"is-wsl": "^2.2.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/openapi-types": {
+			"version": "12.1.3",
+			"resolved": "https://registry.npmjs.org/openapi-types/-/openapi-types-12.1.3.tgz",
+			"integrity": "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==",
+			"license": "MIT"
+		},
+		"node_modules/own-keys": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
+			"integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==",
+			"license": "MIT",
+			"dependencies": {
+				"get-intrinsic": "^1.2.6",
+				"object-keys": "^1.1.1",
+				"safe-push-apply": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/p-any": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/p-any/-/p-any-4.0.0.tgz",
+			"integrity": "sha512-S/B50s+pAVe0wmEZHmBs/9yJXeZ5KhHzOsgKzt0hRdgkoR3DxW9ts46fcsWi/r3VnzsnkKS7q4uimze+zjdryw==",
+			"license": "MIT",
+			"dependencies": {
+				"p-cancelable": "^3.0.0",
+				"p-some": "^6.0.0"
+			},
+			"engines": {
+				"node": ">=12.20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/p-cancelable": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-3.0.0.tgz",
+			"integrity": "sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12.20"
+			}
+		},
+		"node_modules/p-some": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/p-some/-/p-some-6.0.0.tgz",
+			"integrity": "sha512-CJbQCKdfSX3fIh8/QKgS+9rjm7OBNUTmwWswAFQAhc8j1NR1dsEDETUEuVUtQHZpV+J03LqWBEwvu0g1Yn+TYg==",
+			"license": "MIT",
+			"dependencies": {
+				"aggregate-error": "^4.0.0",
+				"p-cancelable": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=12.20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/p-timeout": {
+			"version": "5.1.0",
+			"resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-5.1.0.tgz",
+			"integrity": "sha512-auFDyzzzGZZZdHz3BtET9VEz0SE/uMEAx7uWfGPucfzEwwe/xH0iVeZibQmANYE/hp9T2+UUZT5m+BKyrDp3Ew==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/pac-proxy-agent": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+			"integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+			"license": "MIT",
+			"dependencies": {
+				"@tootallnate/quickjs-emscripten": "^0.23.0",
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"get-uri": "^6.0.1",
+				"http-proxy-agent": "^7.0.0",
+				"https-proxy-agent": "^7.0.6",
+				"pac-resolver": "^7.0.1",
+				"socks-proxy-agent": "^8.0.5"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-resolver": {
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+			"integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+			"license": "MIT",
+			"dependencies": {
+				"degenerator": "^5.0.0",
+				"netmask": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/parent-module": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+			"integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+			"license": "MIT",
+			"dependencies": {
+				"callsites": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/parse-entities": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
+			"integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^2.0.0",
+				"character-entities-legacy": "^3.0.0",
+				"character-reference-invalid": "^2.0.0",
+				"decode-named-character-reference": "^1.0.0",
+				"is-alphanumerical": "^2.0.0",
+				"is-decimal": "^2.0.0",
+				"is-hexadecimal": "^2.0.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/parse-entities/node_modules/@types/unist": {
+			"version": "2.0.11",
+			"resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+			"integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+			"license": "MIT"
+		},
+		"node_modules/parse-json": {
+			"version": "5.2.0",
+			"resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+			"integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+			"license": "MIT",
+			"dependencies": {
+				"@babel/code-frame": "^7.0.0",
+				"error-ex": "^1.3.1",
+				"json-parse-even-better-errors": "^2.3.0",
+				"lines-and-columns": "^1.1.6"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/parse-latin": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/parse-latin/-/parse-latin-7.0.0.tgz",
+			"integrity": "sha512-mhHgobPPua5kZ98EF4HWiH167JWBfl4pvAIXXdbaVohtK7a6YBOy56kvhCqduqyo/f3yrHFWmqmiMg/BkBkYYQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/nlcst": "^2.0.0",
+				"@types/unist": "^3.0.0",
+				"nlcst-to-string": "^4.0.0",
+				"unist-util-modify-children": "^4.0.0",
+				"unist-util-visit-children": "^3.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/parse5": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+			"integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+			"license": "MIT",
+			"dependencies": {
+				"entities": "^6.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/inikulin/parse5?sponsor=1"
+			}
+		},
+		"node_modules/parseurl": {
+			"version": "1.3.3",
+			"resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+			"integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/patch-console": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/patch-console/-/patch-console-2.0.0.tgz",
+			"integrity": "sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			}
+		},
+		"node_modules/path-parse": {
+			"version": "1.0.7",
+			"resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+			"integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+			"license": "MIT"
+		},
+		"node_modules/path-to-regexp": {
+			"version": "0.1.12",
+			"resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+			"integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+			"license": "MIT"
+		},
+		"node_modules/pend": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+			"integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+			"license": "MIT"
+		},
+		"node_modules/picocolors": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+			"integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+			"license": "ISC"
+		},
+		"node_modules/picomatch": {
+			"version": "2.3.1",
+			"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+			"integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8.6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/jonschlinkert"
+			}
+		},
+		"node_modules/pify": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+			"integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/pirates": {
+			"version": "4.0.7",
+			"resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
+			"integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/pony-cause": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/pony-cause/-/pony-cause-1.1.1.tgz",
+			"integrity": "sha512-PxkIc/2ZpLiEzQXu5YRDOUgBlfGYBY8156HY5ZcRAwwonMk5W/MrJP2LLkG/hF7GEQzaHo2aS7ho6ZLCOvf+6g==",
+			"license": "0BSD",
+			"engines": {
+				"node": ">=12.0.0"
+			}
+		},
+		"node_modules/possible-typed-array-names": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
+			"integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/postcss": {
+			"version": "8.5.6",
+			"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+			"integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/postcss/"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/postcss"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"nanoid": "^3.3.11",
+				"picocolors": "^1.1.1",
+				"source-map-js": "^1.2.1"
+			},
+			"engines": {
+				"node": "^10 || ^12 || >=14"
+			}
+		},
+		"node_modules/postcss-import": {
+			"version": "15.1.0",
+			"resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
+			"integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
+			"license": "MIT",
+			"dependencies": {
+				"postcss-value-parser": "^4.0.0",
+				"read-cache": "^1.0.0",
+				"resolve": "^1.1.7"
+			},
+			"engines": {
+				"node": ">=14.0.0"
+			},
+			"peerDependencies": {
+				"postcss": "^8.0.0"
+			}
+		},
+		"node_modules/postcss-js": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz",
+			"integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/postcss/"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"camelcase-css": "^2.0.1"
+			},
+			"engines": {
+				"node": "^12 || ^14 || >= 16"
+			},
+			"peerDependencies": {
+				"postcss": "^8.4.21"
+			}
+		},
+		"node_modules/postcss-load-config": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz",
+			"integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/postcss/"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"lilconfig": "^3.0.0",
+				"yaml": "^2.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			},
+			"peerDependencies": {
+				"postcss": ">=8.0.9",
+				"ts-node": ">=9.0.0"
+			},
+			"peerDependenciesMeta": {
+				"postcss": {
+					"optional": true
+				},
+				"ts-node": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/postcss-load-config/node_modules/lilconfig": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+			"integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/antonk52"
+			}
+		},
+		"node_modules/postcss-nested": {
+			"version": "6.2.0",
+			"resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
+			"integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/postcss/"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"postcss-selector-parser": "^6.1.1"
+			},
+			"engines": {
+				"node": ">=12.0"
+			},
+			"peerDependencies": {
+				"postcss": "^8.2.14"
+			}
+		},
+		"node_modules/postcss-selector-parser": {
+			"version": "6.1.2",
+			"resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+			"integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+			"license": "MIT",
+			"dependencies": {
+				"cssesc": "^3.0.0",
+				"util-deprecate": "^1.0.2"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/postcss-value-parser": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+			"integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+			"license": "MIT"
+		},
+		"node_modules/progress": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+			"integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/property-information": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz",
+			"integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/proxy-addr": {
+			"version": "2.0.7",
+			"resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+			"integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+			"license": "MIT",
+			"dependencies": {
+				"forwarded": "0.2.0",
+				"ipaddr.js": "1.9.1"
+			},
+			"engines": {
+				"node": ">= 0.10"
+			}
+		},
+		"node_modules/proxy-agent": {
+			"version": "6.5.0",
+			"resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+			"integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"http-proxy-agent": "^7.0.1",
+				"https-proxy-agent": "^7.0.6",
+				"lru-cache": "^7.14.1",
+				"pac-proxy-agent": "^7.1.0",
+				"proxy-from-env": "^1.1.0",
+				"socks-proxy-agent": "^8.0.5"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-from-env": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+			"integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+			"license": "MIT"
+		},
+		"node_modules/public-ip": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/public-ip/-/public-ip-5.0.0.tgz",
+			"integrity": "sha512-xaH3pZMni/R2BG7ZXXaWS9Wc9wFlhyDVJF47IJ+3ali0TGv+2PsckKxbmo+rnx3ZxiV2wblVhtdS3bohAP6GGw==",
+			"license": "MIT",
+			"dependencies": {
+				"dns-socket": "^4.2.2",
+				"got": "^12.0.0",
+				"is-ip": "^3.1.0"
+			},
+			"engines": {
+				"node": "^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/public-ip/node_modules/got": {
+			"version": "12.6.1",
+			"resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz",
+			"integrity": "sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^5.2.0",
+				"@szmarczak/http-timer": "^5.0.1",
+				"cacheable-lookup": "^7.0.0",
+				"cacheable-request": "^10.2.8",
+				"decompress-response": "^6.0.0",
+				"form-data-encoder": "^2.1.2",
+				"get-stream": "^6.0.1",
+				"http2-wrapper": "^2.1.10",
+				"lowercase-keys": "^3.0.0",
+				"p-cancelable": "^3.0.0",
+				"responselike": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/got?sponsor=1"
+			}
+		},
+		"node_modules/pump": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+			"integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+			"license": "MIT",
+			"dependencies": {
+				"end-of-stream": "^1.1.0",
+				"once": "^1.3.1"
+			}
+		},
+		"node_modules/puppeteer": {
+			"version": "22.14.0",
+			"resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-22.14.0.tgz",
+			"integrity": "sha512-MGTR6/pM8zmWbTdazb6FKnwIihzsSEXBPH49mFFU96DNZpQOevCAZMnjBZGlZRGRzRK6aADCavR6SQtrbv5dQw==",
+			"deprecated": "< 24.15.0 is no longer supported",
+			"hasInstallScript": true,
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@puppeteer/browsers": "2.3.0",
+				"cosmiconfig": "^9.0.0",
+				"devtools-protocol": "0.0.1312386",
+				"puppeteer-core": "22.14.0"
+			},
+			"bin": {
+				"puppeteer": "lib/esm/puppeteer/node/cli.js"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/puppeteer-core": {
+			"version": "22.14.0",
+			"resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-22.14.0.tgz",
+			"integrity": "sha512-rl4tOY5LcA3e374GAlsGGHc05HL3eGNf5rZ+uxkl6id9zVZKcwcp1Z+Nd6byb6WPiPeecT/dwz8f/iUm+AZQSw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@puppeteer/browsers": "2.3.0",
+				"chromium-bidi": "0.6.2",
+				"debug": "^4.3.5",
+				"devtools-protocol": "0.0.1312386",
+				"ws": "^8.18.0"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/qs": {
+			"version": "6.14.1",
+			"resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz",
+			"integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==",
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"side-channel": "^1.1.0"
+			},
+			"engines": {
+				"node": ">=0.6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/queue-microtask": {
+			"version": "1.2.3",
+			"resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+			"integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/quick-lru": {
+			"version": "5.1.1",
+			"resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+			"integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/range-parser": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+			"integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/raw-body": {
+			"version": "2.5.2",
+			"resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+			"integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+			"license": "MIT",
+			"dependencies": {
+				"bytes": "3.1.2",
+				"http-errors": "2.0.0",
+				"iconv-lite": "0.4.24",
+				"unpipe": "1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/raw-body/node_modules/iconv-lite": {
+			"version": "0.4.24",
+			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+			"integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+			"license": "MIT",
+			"dependencies": {
+				"safer-buffer": ">= 2.1.2 < 3"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/react": {
+			"version": "19.2.3",
+			"resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
+			"integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/react-reconciler": {
+			"version": "0.32.0",
+			"resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.32.0.tgz",
+			"integrity": "sha512-2NPMOzgTlG0ZWdIf3qG+dcbLSoAc/uLfOwckc3ofy5sSK0pLJqnQLpUFxvGcN2rlXSjnVtGeeFLNimCQEj5gOQ==",
+			"license": "MIT",
+			"dependencies": {
+				"scheduler": "^0.26.0"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			},
+			"peerDependencies": {
+				"react": "^19.1.0"
+			}
+		},
+		"node_modules/react-remove-scroll": {
+			"version": "2.7.2",
+			"resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.2.tgz",
+			"integrity": "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"react-remove-scroll-bar": "^2.3.7",
+				"react-style-singleton": "^2.2.3",
+				"tslib": "^2.1.0",
+				"use-callback-ref": "^1.3.3",
+				"use-sidecar": "^1.1.3"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/react-remove-scroll-bar": {
+			"version": "2.3.8",
+			"resolved": "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz",
+			"integrity": "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"react-style-singleton": "^2.2.2",
+				"tslib": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/react-remove-scroll-bar/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"peer": true
+		},
+		"node_modules/react-remove-scroll/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"peer": true
+		},
+		"node_modules/react-style-singleton": {
+			"version": "2.2.3",
+			"resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz",
+			"integrity": "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"get-nonce": "^1.0.0",
+				"tslib": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/react-style-singleton/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"peer": true
+		},
+		"node_modules/read-cache": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+			"integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+			"license": "MIT",
+			"dependencies": {
+				"pify": "^2.3.0"
+			}
+		},
+		"node_modules/readdirp": {
+			"version": "3.6.0",
+			"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+			"integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+			"license": "MIT",
+			"dependencies": {
+				"picomatch": "^2.2.1"
+			},
+			"engines": {
+				"node": ">=8.10.0"
+			}
+		},
+		"node_modules/recma-build-jsx": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz",
+			"integrity": "sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"estree-util-build-jsx": "^3.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/recma-jsx": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/recma-jsx/-/recma-jsx-1.0.1.tgz",
+			"integrity": "sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==",
+			"license": "MIT",
+			"dependencies": {
+				"acorn-jsx": "^5.0.0",
+				"estree-util-to-js": "^2.0.0",
+				"recma-parse": "^1.0.0",
+				"recma-stringify": "^1.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			},
+			"peerDependencies": {
+				"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+			}
+		},
+		"node_modules/recma-parse": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/recma-parse/-/recma-parse-1.0.0.tgz",
+			"integrity": "sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"esast-util-from-js": "^2.0.0",
+				"unified": "^11.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/recma-stringify": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/recma-stringify/-/recma-stringify-1.0.0.tgz",
+			"integrity": "sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"estree-util-to-js": "^2.0.0",
+				"unified": "^11.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/reflect.getprototypeof": {
+			"version": "1.0.10",
+			"resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
+			"integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"define-properties": "^1.2.1",
+				"es-abstract": "^1.23.9",
+				"es-errors": "^1.3.0",
+				"es-object-atoms": "^1.0.0",
+				"get-intrinsic": "^1.2.7",
+				"get-proto": "^1.0.1",
+				"which-builtin-type": "^1.2.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/regex": {
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/regex/-/regex-6.1.0.tgz",
+			"integrity": "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==",
+			"license": "MIT",
+			"dependencies": {
+				"regex-utilities": "^2.3.0"
+			}
+		},
+		"node_modules/regex-recursion": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz",
+			"integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==",
+			"license": "MIT",
+			"dependencies": {
+				"regex-utilities": "^2.3.0"
+			}
+		},
+		"node_modules/regex-utilities": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz",
+			"integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==",
+			"license": "MIT"
+		},
+		"node_modules/regexp.prototype.flags": {
+			"version": "1.5.4",
+			"resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
+			"integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"define-properties": "^1.2.1",
+				"es-errors": "^1.3.0",
+				"get-proto": "^1.0.1",
+				"gopd": "^1.2.0",
+				"set-function-name": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/rehype-katex": {
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/rehype-katex/-/rehype-katex-7.0.1.tgz",
+			"integrity": "sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/katex": "^0.16.0",
+				"hast-util-from-html-isomorphic": "^2.0.0",
+				"hast-util-to-text": "^4.0.0",
+				"katex": "^0.16.0",
+				"unist-util-visit-parents": "^6.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/rehype-minify-whitespace": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/rehype-minify-whitespace/-/rehype-minify-whitespace-6.0.2.tgz",
+			"integrity": "sha512-Zk0pyQ06A3Lyxhe9vGtOtzz3Z0+qZ5+7icZ/PL/2x1SHPbKao5oB/g/rlc6BCTajqBb33JcOe71Ye1oFsuYbnw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-minify-whitespace": "^1.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/rehype-parse": {
+			"version": "9.0.1",
+			"resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-9.0.1.tgz",
+			"integrity": "sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-from-html": "^2.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/rehype-recma": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/rehype-recma/-/rehype-recma-1.0.0.tgz",
+			"integrity": "sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.0",
+				"@types/hast": "^3.0.0",
+				"hast-util-to-estree": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/rehype-stringify": {
+			"version": "10.0.1",
+			"resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-10.0.1.tgz",
+			"integrity": "sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-to-html": "^9.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark": {
+			"version": "15.0.1",
+			"resolved": "https://registry.npmjs.org/remark/-/remark-15.0.1.tgz",
+			"integrity": "sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"remark-parse": "^11.0.0",
+				"remark-stringify": "^11.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-frontmatter": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz",
+			"integrity": "sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"mdast-util-frontmatter": "^2.0.0",
+				"micromark-extension-frontmatter": "^2.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-gfm": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.0.tgz",
+			"integrity": "sha512-U92vJgBPkbw4Zfu/IiW2oTZLSL3Zpv+uI7My2eq8JxKgqraFdU8YUGicEJCEgSbeaG+QDFqIcwwfMTOEelPxuA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"mdast-util-gfm": "^3.0.0",
+				"micromark-extension-gfm": "^3.0.0",
+				"remark-parse": "^11.0.0",
+				"remark-stringify": "^11.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-math": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/remark-math/-/remark-math-6.0.0.tgz",
+			"integrity": "sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"mdast-util-math": "^3.0.0",
+				"micromark-extension-math": "^3.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-mdx": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.0.tgz",
+			"integrity": "sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==",
+			"license": "MIT",
+			"dependencies": {
+				"mdast-util-mdx": "^3.0.0",
+				"micromark-extension-mdxjs": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-mdx-remove-esm": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/remark-mdx-remove-esm/-/remark-mdx-remove-esm-1.2.2.tgz",
+			"integrity": "sha512-YSaUwqiuJuD6S9XTAD6zmO4JJJZJgsRAdsl2drZO8/ssAVv0HXAg4vkSgHZAP46ORh8ERPFQrC7JWlbkwBwu1A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.4",
+				"mdast-util-mdxjs-esm": "^2.0.1",
+				"unist-util-remove": "^4.0.0"
+			},
+			"peerDependencies": {
+				"unified": "^11"
+			}
+		},
+		"node_modules/remark-parse": {
+			"version": "11.0.0",
+			"resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+			"integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"mdast-util-from-markdown": "^2.0.0",
+				"micromark-util-types": "^2.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-rehype": {
+			"version": "11.1.1",
+			"resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.1.tgz",
+			"integrity": "sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@types/mdast": "^4.0.0",
+				"mdast-util-to-hast": "^13.0.0",
+				"unified": "^11.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/remark-smartypants": {
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/remark-smartypants/-/remark-smartypants-3.0.2.tgz",
+			"integrity": "sha512-ILTWeOriIluwEvPjv67v7Blgrcx+LZOkAUVtKI3putuhlZm84FnqDORNXPPm+HY3NdZOMhyDwZ1E+eZB/Df5dA==",
+			"license": "MIT",
+			"dependencies": {
+				"retext": "^9.0.0",
+				"retext-smartypants": "^6.0.0",
+				"unified": "^11.0.4",
+				"unist-util-visit": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/remark-stringify": {
+			"version": "11.0.0",
+			"resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz",
+			"integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/mdast": "^4.0.0",
+				"mdast-util-to-markdown": "^2.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/require-directory": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+			"integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/require-from-string": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+			"integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/resolve": {
+			"version": "1.22.11",
+			"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+			"integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+			"license": "MIT",
+			"dependencies": {
+				"is-core-module": "^2.16.1",
+				"path-parse": "^1.0.7",
+				"supports-preserve-symlinks-flag": "^1.0.0"
+			},
+			"bin": {
+				"resolve": "bin/resolve"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/resolve-alpn": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+			"integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
+			"license": "MIT"
+		},
+		"node_modules/resolve-from": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+			"integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/responselike": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/responselike/-/responselike-3.0.0.tgz",
+			"integrity": "sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg==",
+			"license": "MIT",
+			"dependencies": {
+				"lowercase-keys": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/restore-cursor": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz",
+			"integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==",
+			"license": "MIT",
+			"dependencies": {
+				"onetime": "^5.1.0",
+				"signal-exit": "^3.0.2"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/restore-cursor/node_modules/signal-exit": {
+			"version": "3.0.7",
+			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+			"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+			"license": "ISC"
+		},
+		"node_modules/retext": {
+			"version": "9.0.0",
+			"resolved": "https://registry.npmjs.org/retext/-/retext-9.0.0.tgz",
+			"integrity": "sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/nlcst": "^2.0.0",
+				"retext-latin": "^4.0.0",
+				"retext-stringify": "^4.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/retext-latin": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/retext-latin/-/retext-latin-4.0.0.tgz",
+			"integrity": "sha512-hv9woG7Fy0M9IlRQloq/N6atV82NxLGveq+3H2WOi79dtIYWN8OaxogDm77f8YnVXJL2VD3bbqowu5E3EMhBYA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/nlcst": "^2.0.0",
+				"parse-latin": "^7.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/retext-smartypants": {
+			"version": "6.2.0",
+			"resolved": "https://registry.npmjs.org/retext-smartypants/-/retext-smartypants-6.2.0.tgz",
+			"integrity": "sha512-kk0jOU7+zGv//kfjXEBjdIryL1Acl4i9XNkHxtM7Tm5lFiCog576fjNC9hjoR7LTKQ0DsPWy09JummSsH1uqfQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/nlcst": "^2.0.0",
+				"nlcst-to-string": "^4.0.0",
+				"unist-util-visit": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/retext-stringify": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/retext-stringify/-/retext-stringify-4.0.0.tgz",
+			"integrity": "sha512-rtfN/0o8kL1e+78+uxPTqu1Klt0yPzKuQ2BfWwwfgIUSayyzxpM1PJzkKt4V8803uB9qSy32MvI7Xep9khTpiA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/nlcst": "^2.0.0",
+				"nlcst-to-string": "^4.0.0",
+				"unified": "^11.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/reusify": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+			"integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+			"license": "MIT",
+			"engines": {
+				"iojs": ">=1.0.0",
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/run-async": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/run-async/-/run-async-3.0.0.tgz",
+			"integrity": "sha512-540WwVDOMxA6dN6We19EcT9sc3hkXPw5mzRNGM3FkdN/vtE9NFvj5lFAPNwUDmJjXidm3v7TC1cTE7t17Ulm1Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.12.0"
+			}
+		},
+		"node_modules/run-parallel": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+			"integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"queue-microtask": "^1.2.2"
+			}
+		},
+		"node_modules/rxjs": {
+			"version": "7.8.2",
+			"resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
+			"integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"tslib": "^2.1.0"
+			}
+		},
+		"node_modules/rxjs/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/safe-array-concat": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz",
+			"integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.2",
+				"get-intrinsic": "^1.2.6",
+				"has-symbols": "^1.1.0",
+				"isarray": "^2.0.5"
+			},
+			"engines": {
+				"node": ">=0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/safe-buffer": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+			"integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT"
+		},
+		"node_modules/safe-push-apply": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
+			"integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"isarray": "^2.0.5"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/safe-regex-test": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
+			"integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"es-errors": "^1.3.0",
+				"is-regex": "^1.2.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/safe-stable-stringify": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-1.1.1.tgz",
+			"integrity": "sha512-ERq4hUjKDbJfE4+XtZLFPCDi8Vb1JqaxAPTxWFLBx8XcAlf9Bda/ZJdVezs/NAfsMQScyIlUMx+Yeu7P7rx5jw==",
+			"license": "MIT"
+		},
+		"node_modules/safer-buffer": {
+			"version": "2.1.2",
+			"resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+			"integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+			"license": "MIT"
+		},
+		"node_modules/sax": {
+			"version": "1.4.4",
+			"resolved": "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz",
+			"integrity": "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==",
+			"license": "BlueOak-1.0.0",
+			"engines": {
+				"node": ">=11.0.0"
+			}
+		},
+		"node_modules/scheduler": {
+			"version": "0.26.0",
+			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.26.0.tgz",
+			"integrity": "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==",
+			"license": "MIT"
+		},
+		"node_modules/semver": {
+			"version": "7.7.2",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+			"integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+			"license": "ISC",
+			"bin": {
+				"semver": "bin/semver.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/send": {
+			"version": "0.19.0",
+			"resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+			"integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "2.6.9",
+				"depd": "2.0.0",
+				"destroy": "1.2.0",
+				"encodeurl": "~1.0.2",
+				"escape-html": "~1.0.3",
+				"etag": "~1.8.1",
+				"fresh": "0.5.2",
+				"http-errors": "2.0.0",
+				"mime": "1.6.0",
+				"ms": "2.1.3",
+				"on-finished": "2.4.1",
+				"range-parser": "~1.2.1",
+				"statuses": "2.0.1"
+			},
+			"engines": {
+				"node": ">= 0.8.0"
+			}
+		},
+		"node_modules/send/node_modules/debug": {
+			"version": "2.6.9",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "2.0.0"
+			}
+		},
+		"node_modules/send/node_modules/debug/node_modules/ms": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+			"license": "MIT"
+		},
+		"node_modules/serialize-error": {
+			"version": "12.0.0",
+			"resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-12.0.0.tgz",
+			"integrity": "sha512-ZYkZLAvKTKQXWuh5XpBw7CdbSzagarX39WyZ2H07CDLC5/KfsRGlIXV8d4+tfqX1M7916mRqR1QfNHSij+c9Pw==",
+			"license": "MIT",
+			"dependencies": {
+				"type-fest": "^4.31.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/serve-static": {
+			"version": "1.16.0",
+			"resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.0.tgz",
+			"integrity": "sha512-pDLK8zwl2eKaYrs8mrPZBJua4hMplRWJ1tIFksVC3FtBEBnl8dxgeHtsaMS8DhS9i4fLObaon6ABoc4/hQGdPA==",
+			"license": "MIT",
+			"dependencies": {
+				"encodeurl": "~1.0.2",
+				"escape-html": "~1.0.3",
+				"parseurl": "~1.3.3",
+				"send": "0.18.0"
+			},
+			"engines": {
+				"node": ">= 0.8.0"
+			}
+		},
+		"node_modules/set-function-length": {
+			"version": "1.2.2",
+			"resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+			"integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+			"license": "MIT",
+			"dependencies": {
+				"define-data-property": "^1.1.4",
+				"es-errors": "^1.3.0",
+				"function-bind": "^1.1.2",
+				"get-intrinsic": "^1.2.4",
+				"gopd": "^1.0.1",
+				"has-property-descriptors": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/set-function-name": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
+			"integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
+			"license": "MIT",
+			"dependencies": {
+				"define-data-property": "^1.1.4",
+				"es-errors": "^1.3.0",
+				"functions-have-names": "^1.2.3",
+				"has-property-descriptors": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/set-proto": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
+			"integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
+			"license": "MIT",
+			"dependencies": {
+				"dunder-proto": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"es-object-atoms": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/setprototypeof": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+			"integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+			"license": "ISC"
+		},
+		"node_modules/sharp": {
+			"version": "0.33.5",
+			"resolved": "https://registry.npmjs.org/sharp/-/sharp-0.33.5.tgz",
+			"integrity": "sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==",
+			"hasInstallScript": true,
+			"license": "Apache-2.0",
+			"dependencies": {
+				"color": "^4.2.3",
+				"detect-libc": "^2.0.3",
+				"semver": "^7.6.3"
+			},
+			"engines": {
+				"node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+			},
+			"funding": {
+				"url": "https://opencollective.com/libvips"
+			},
+			"optionalDependencies": {
+				"@img/sharp-darwin-arm64": "0.33.5",
+				"@img/sharp-darwin-x64": "0.33.5",
+				"@img/sharp-libvips-darwin-arm64": "1.0.4",
+				"@img/sharp-libvips-darwin-x64": "1.0.4",
+				"@img/sharp-libvips-linux-arm": "1.0.5",
+				"@img/sharp-libvips-linux-arm64": "1.0.4",
+				"@img/sharp-libvips-linux-s390x": "1.0.4",
+				"@img/sharp-libvips-linux-x64": "1.0.4",
+				"@img/sharp-libvips-linuxmusl-arm64": "1.0.4",
+				"@img/sharp-libvips-linuxmusl-x64": "1.0.4",
+				"@img/sharp-linux-arm": "0.33.5",
+				"@img/sharp-linux-arm64": "0.33.5",
+				"@img/sharp-linux-s390x": "0.33.5",
+				"@img/sharp-linux-x64": "0.33.5",
+				"@img/sharp-linuxmusl-arm64": "0.33.5",
+				"@img/sharp-linuxmusl-x64": "0.33.5",
+				"@img/sharp-wasm32": "0.33.5",
+				"@img/sharp-win32-ia32": "0.33.5",
+				"@img/sharp-win32-x64": "0.33.5"
+			}
+		},
+		"node_modules/sharp-ico": {
+			"version": "0.1.5",
+			"resolved": "https://registry.npmjs.org/sharp-ico/-/sharp-ico-0.1.5.tgz",
+			"integrity": "sha512-a3jODQl82NPp1d5OYb0wY+oFaPk7AvyxipIowCHk7pBsZCWgbe0yAkU2OOXdoH0ENyANhyOQbs9xkAiRHcF02Q==",
+			"license": "MIT",
+			"dependencies": {
+				"decode-ico": "*",
+				"ico-endec": "*",
+				"sharp": "*"
+			}
+		},
+		"node_modules/shiki": {
+			"version": "3.22.0",
+			"resolved": "https://registry.npmjs.org/shiki/-/shiki-3.22.0.tgz",
+			"integrity": "sha512-LBnhsoYEe0Eou4e1VgJACes+O6S6QC0w71fCSp5Oya79inkwkm15gQ1UF6VtQ8j/taMDh79hAB49WUk8ALQW3g==",
+			"license": "MIT",
+			"dependencies": {
+				"@shikijs/core": "3.22.0",
+				"@shikijs/engine-javascript": "3.22.0",
+				"@shikijs/engine-oniguruma": "3.22.0",
+				"@shikijs/langs": "3.22.0",
+				"@shikijs/themes": "3.22.0",
+				"@shikijs/types": "3.22.0",
+				"@shikijs/vscode-textmate": "^10.0.2",
+				"@types/hast": "^3.0.4"
+			}
+		},
+		"node_modules/side-channel": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+			"integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"object-inspect": "^1.13.3",
+				"side-channel-list": "^1.0.0",
+				"side-channel-map": "^1.0.1",
+				"side-channel-weakmap": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/side-channel-list": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+			"integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"object-inspect": "^1.13.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/side-channel-map": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+			"integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.5",
+				"object-inspect": "^1.13.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/side-channel-weakmap": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+			"integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.5",
+				"object-inspect": "^1.13.3",
+				"side-channel-map": "^1.0.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/signal-exit": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+			"integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=14"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/simple-eval": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/simple-eval/-/simple-eval-1.0.1.tgz",
+			"integrity": "sha512-LH7FpTAkeD+y5xQC4fzS+tFtaNlvt3Ib1zKzvhjv/Y+cioV4zIuw4IZr2yhRLu67CWL7FR9/6KXKnjRoZTvGGQ==",
+			"license": "MIT",
+			"dependencies": {
+				"jsep": "^1.3.6"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/simple-swizzle": {
+			"version": "0.2.4",
+			"resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.4.tgz",
+			"integrity": "sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw==",
+			"license": "MIT",
+			"dependencies": {
+				"is-arrayish": "^0.3.1"
+			}
+		},
+		"node_modules/simple-swizzle/node_modules/is-arrayish": {
+			"version": "0.3.4",
+			"resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.4.tgz",
+			"integrity": "sha512-m6UrgzFVUYawGBh1dUsWR5M2Clqic9RVXC/9f8ceNlv2IcO9j9J/z8UoCLPqtsPBFNzEpfR3xftohbfqDx8EQA==",
+			"license": "MIT"
+		},
+		"node_modules/slice-ansi": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.2.tgz",
+			"integrity": "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^6.2.1",
+				"is-fullwidth-code-point": "^5.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/slice-ansi?sponsor=1"
+			}
+		},
+		"node_modules/smart-buffer": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+			"integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6.0.0",
+				"npm": ">= 3.0.0"
+			}
+		},
+		"node_modules/socket.io": {
+			"version": "4.7.2",
+			"resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.7.2.tgz",
+			"integrity": "sha512-bvKVS29/I5fl2FGLNHuXlQaUH/BlzX1IN6S+NKLNZpBsPZIDH+90eQmCs2Railn4YUiww4SzUedJ6+uzwFnKLw==",
+			"license": "MIT",
+			"dependencies": {
+				"accepts": "~1.3.4",
+				"base64id": "~2.0.0",
+				"cors": "~2.8.5",
+				"debug": "~4.3.2",
+				"engine.io": "~6.5.2",
+				"socket.io-adapter": "~2.5.2",
+				"socket.io-parser": "~4.2.4"
+			},
+			"engines": {
+				"node": ">=10.2.0"
+			}
+		},
+		"node_modules/socket.io-adapter": {
+			"version": "2.5.6",
+			"resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.6.tgz",
+			"integrity": "sha512-DkkO/dz7MGln0dHn5bmN3pPy+JmywNICWrJqVWiVOyvXjWQFIv9c2h24JrQLLFJ2aQVQf/Cvl1vblnd4r2apLQ==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "~4.4.1",
+				"ws": "~8.18.3"
+			}
+		},
+		"node_modules/socket.io-adapter/node_modules/ws": {
+			"version": "8.18.3",
+			"resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+			"integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			},
+			"peerDependencies": {
+				"bufferutil": "^4.0.1",
+				"utf-8-validate": ">=5.0.2"
+			},
+			"peerDependenciesMeta": {
+				"bufferutil": {
+					"optional": true
+				},
+				"utf-8-validate": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/socket.io-parser": {
+			"version": "4.2.5",
+			"resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.5.tgz",
+			"integrity": "sha512-bPMmpy/5WWKHea5Y/jYAP6k74A+hvmRCQaJuJB6I/ML5JZq/KfNieUVo/3Mh7SAqn7TyFdIo6wqYHInG1MU1bQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@socket.io/component-emitter": "~3.1.0",
+				"debug": "~4.4.1"
+			},
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/socket.io/node_modules/debug": {
+			"version": "4.3.7",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+			"integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"peerDependenciesMeta": {
+				"supports-color": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/socks": {
+			"version": "2.8.7",
+			"resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz",
+			"integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==",
+			"license": "MIT",
+			"dependencies": {
+				"ip-address": "^10.0.1",
+				"smart-buffer": "^4.2.0"
+			},
+			"engines": {
+				"node": ">= 10.0.0",
+				"npm": ">= 3.0.0"
+			}
+		},
+		"node_modules/socks-proxy-agent": {
+			"version": "8.0.5",
+			"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+			"integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"socks": "^2.8.3"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/source-map": {
+			"version": "0.7.6",
+			"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.6.tgz",
+			"integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==",
+			"license": "BSD-3-Clause",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/source-map-js": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+			"integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+			"license": "BSD-3-Clause",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/space-separated-tokens": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+			"integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/stack-utils": {
+			"version": "2.0.6",
+			"resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
+			"integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
+			"license": "MIT",
+			"dependencies": {
+				"escape-string-regexp": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/stack-utils/node_modules/escape-string-regexp": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+			"integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/statuses": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+			"integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/stop-iteration-iterator": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
+			"integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"internal-slot": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/streamx": {
+			"version": "2.23.0",
+			"resolved": "https://registry.npmjs.org/streamx/-/streamx-2.23.0.tgz",
+			"integrity": "sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==",
+			"license": "MIT",
+			"dependencies": {
+				"events-universal": "^1.0.0",
+				"fast-fifo": "^1.3.2",
+				"text-decoder": "^1.1.0"
+			}
+		},
+		"node_modules/string-width": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+			"integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+			"license": "MIT",
+			"dependencies": {
+				"emoji-regex": "^10.3.0",
+				"get-east-asian-width": "^1.0.0",
+				"strip-ansi": "^7.1.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/string.prototype.trim": {
+			"version": "1.2.10",
+			"resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz",
+			"integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.2",
+				"define-data-property": "^1.1.4",
+				"define-properties": "^1.2.1",
+				"es-abstract": "^1.23.5",
+				"es-object-atoms": "^1.0.0",
+				"has-property-descriptors": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/string.prototype.trimend": {
+			"version": "1.0.9",
+			"resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz",
+			"integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.2",
+				"define-properties": "^1.2.1",
+				"es-object-atoms": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/string.prototype.trimstart": {
+			"version": "1.0.8",
+			"resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
+			"integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.7",
+				"define-properties": "^1.2.1",
+				"es-object-atoms": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/stringify-entities": {
+			"version": "4.0.4",
+			"resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+			"integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+			"license": "MIT",
+			"dependencies": {
+				"character-entities-html4": "^2.0.0",
+				"character-entities-legacy": "^3.0.0"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/strip-ansi": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz",
+			"integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-regex": "^6.0.1"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/strip-ansi?sponsor=1"
+			}
+		},
+		"node_modules/style-to-js": {
+			"version": "1.1.21",
+			"resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
+			"integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+			"license": "MIT",
+			"dependencies": {
+				"style-to-object": "1.0.14"
+			}
+		},
+		"node_modules/style-to-object": {
+			"version": "1.0.14",
+			"resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz",
+			"integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
+			"license": "MIT",
+			"dependencies": {
+				"inline-style-parser": "0.2.7"
+			}
+		},
+		"node_modules/sucrase": {
+			"version": "3.35.1",
+			"resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
+			"integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
+			"license": "MIT",
+			"dependencies": {
+				"@jridgewell/gen-mapping": "^0.3.2",
+				"commander": "^4.0.0",
+				"lines-and-columns": "^1.1.6",
+				"mz": "^2.7.0",
+				"pirates": "^4.0.1",
+				"tinyglobby": "^0.2.11",
+				"ts-interface-checker": "^0.1.9"
+			},
+			"bin": {
+				"sucrase": "bin/sucrase",
+				"sucrase-node": "bin/sucrase-node"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/sucrase/node_modules/commander": {
+			"version": "4.1.1",
+			"resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+			"integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/supports-preserve-symlinks-flag": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+			"integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/tailwindcss": {
+			"version": "3.4.4",
+			"resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.4.tgz",
+			"integrity": "sha512-ZoyXOdJjISB7/BcLTR6SEsLgKtDStYyYZVLsUtWChO4Ps20CBad7lfJKVDiejocV4ME1hLmyY0WJE3hSDcmQ2A==",
+			"license": "MIT",
+			"dependencies": {
+				"@alloc/quick-lru": "^5.2.0",
+				"arg": "^5.0.2",
+				"chokidar": "^3.5.3",
+				"didyoumean": "^1.2.2",
+				"dlv": "^1.1.3",
+				"fast-glob": "^3.3.0",
+				"glob-parent": "^6.0.2",
+				"is-glob": "^4.0.3",
+				"jiti": "^1.21.0",
+				"lilconfig": "^2.1.0",
+				"micromatch": "^4.0.5",
+				"normalize-path": "^3.0.0",
+				"object-hash": "^3.0.0",
+				"picocolors": "^1.0.0",
+				"postcss": "^8.4.23",
+				"postcss-import": "^15.1.0",
+				"postcss-js": "^4.0.1",
+				"postcss-load-config": "^4.0.1",
+				"postcss-nested": "^6.0.1",
+				"postcss-selector-parser": "^6.0.11",
+				"resolve": "^1.22.2",
+				"sucrase": "^3.32.0"
+			},
+			"bin": {
+				"tailwind": "lib/cli.js",
+				"tailwindcss": "lib/cli.js"
+			},
+			"engines": {
+				"node": ">=14.0.0"
+			}
+		},
+		"node_modules/tailwindcss/node_modules/glob-parent": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+			"integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+			"license": "ISC",
+			"dependencies": {
+				"is-glob": "^4.0.3"
+			},
+			"engines": {
+				"node": ">=10.13.0"
+			}
+		},
+		"node_modules/tar": {
+			"version": "6.2.1",
+			"resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+			"integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+			"deprecated": "Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+			"license": "ISC",
+			"dependencies": {
+				"chownr": "^2.0.0",
+				"fs-minipass": "^2.0.0",
+				"minipass": "^5.0.0",
+				"minizlib": "^2.1.1",
+				"mkdirp": "^1.0.3",
+				"yallist": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/tar-fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
+			"integrity": "sha512-LZA0oaPOc2fVo82Txf3gw+AkEd38szODlptMYejQUhndHMLQ9M059uXR+AfS7DNo0NpINvSqDsvyaCrBVkptWg==",
+			"license": "MIT",
+			"dependencies": {
+				"pump": "^3.0.0",
+				"tar-stream": "^3.1.5"
+			},
+			"optionalDependencies": {
+				"bare-fs": "^4.0.1",
+				"bare-path": "^3.0.0"
+			}
+		},
+		"node_modules/tar-stream": {
+			"version": "3.1.7",
+			"resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+			"integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
+			"license": "MIT",
+			"dependencies": {
+				"b4a": "^1.6.4",
+				"fast-fifo": "^1.2.0",
+				"streamx": "^2.15.0"
+			}
+		},
+		"node_modules/text-decoder": {
+			"version": "1.2.3",
+			"resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+			"integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"b4a": "^1.6.4"
+			}
+		},
+		"node_modules/thenify": {
+			"version": "3.3.1",
+			"resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
+			"integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
+			"license": "MIT",
+			"dependencies": {
+				"any-promise": "^1.0.0"
+			}
+		},
+		"node_modules/thenify-all": {
+			"version": "1.6.0",
+			"resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
+			"integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
+			"license": "MIT",
+			"dependencies": {
+				"thenify": ">= 3.1.0 < 4"
+			},
+			"engines": {
+				"node": ">=0.8"
+			}
+		},
+		"node_modules/through": {
+			"version": "2.3.8",
+			"resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+			"integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
+			"license": "MIT"
+		},
+		"node_modules/tinyglobby": {
+			"version": "0.2.15",
+			"resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+			"integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+			"license": "MIT",
+			"dependencies": {
+				"fdir": "^6.5.0",
+				"picomatch": "^4.0.3"
+			},
+			"engines": {
+				"node": ">=12.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/SuperchupuDev"
+			}
+		},
+		"node_modules/tinyglobby/node_modules/fdir": {
+			"version": "6.5.0",
+			"resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+			"integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12.0.0"
+			},
+			"peerDependencies": {
+				"picomatch": "^3 || ^4"
+			},
+			"peerDependenciesMeta": {
+				"picomatch": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/tinyglobby/node_modules/picomatch": {
+			"version": "4.0.3",
+			"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+			"integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/jonschlinkert"
+			}
+		},
+		"node_modules/to-data-view": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/to-data-view/-/to-data-view-1.1.0.tgz",
+			"integrity": "sha512-1eAdufMg6mwgmlojAx3QeMnzB/BTVp7Tbndi3U7ftcT2zCZadjxkkmLmd97zmaxWi+sgGcgWrokmpEoy0Dn0vQ==",
+			"license": "MIT"
+		},
+		"node_modules/to-regex-range": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+			"integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+			"license": "MIT",
+			"dependencies": {
+				"is-number": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=8.0"
+			}
+		},
+		"node_modules/toidentifier": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+			"integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.6"
+			}
+		},
+		"node_modules/tr46": {
+			"version": "0.0.3",
+			"resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+			"integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+			"license": "MIT"
+		},
+		"node_modules/trim-lines": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+			"integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/trim-trailing-lines": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/trim-trailing-lines/-/trim-trailing-lines-2.1.0.tgz",
+			"integrity": "sha512-5UR5Biq4VlVOtzqkm2AZlgvSlDJtME46uV0br0gENbwN4l5+mMKT4b9gJKqWtuL2zAIqajGJGuvbCbcAJUZqBg==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/trough": {
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+			"integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/ts-interface-checker": {
+			"version": "0.1.13",
+			"resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
+			"integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/tslib": {
+			"version": "1.14.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+			"integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+			"license": "0BSD"
+		},
+		"node_modules/twoslash": {
+			"version": "0.3.6",
+			"resolved": "https://registry.npmjs.org/twoslash/-/twoslash-0.3.6.tgz",
+			"integrity": "sha512-VuI5OKl+MaUO9UIW3rXKoPgHI3X40ZgB/j12VY6h98Ae1mCBihjPvhOPeJWlxCYcmSbmeZt5ZKkK0dsVtp+6pA==",
+			"license": "MIT",
+			"dependencies": {
+				"@typescript/vfs": "^1.6.2",
+				"twoslash-protocol": "0.3.6"
+			},
+			"peerDependencies": {
+				"typescript": "^5.5.0"
+			}
+		},
+		"node_modules/twoslash-protocol": {
+			"version": "0.3.6",
+			"resolved": "https://registry.npmjs.org/twoslash-protocol/-/twoslash-protocol-0.3.6.tgz",
+			"integrity": "sha512-FHGsJ9Q+EsNr5bEbgG3hnbkvEBdW5STgPU824AHUjB4kw0Dn4p8tABT7Ncg1Ie6V0+mDg3Qpy41VafZXcQhWMA==",
+			"license": "MIT"
+		},
+		"node_modules/type-fest": {
+			"version": "4.41.0",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+			"integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+			"license": "(MIT OR CC0-1.0)",
+			"engines": {
+				"node": ">=16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/type-is": {
+			"version": "1.6.18",
+			"resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+			"integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+			"license": "MIT",
+			"dependencies": {
+				"media-typer": "0.3.0",
+				"mime-types": "~2.1.24"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/typed-array-buffer": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+			"integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"es-errors": "^1.3.0",
+				"is-typed-array": "^1.1.14"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/typed-array-byte-length": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
+			"integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.8",
+				"for-each": "^0.3.3",
+				"gopd": "^1.2.0",
+				"has-proto": "^1.2.0",
+				"is-typed-array": "^1.1.14"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/typed-array-byte-offset": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz",
+			"integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==",
+			"license": "MIT",
+			"dependencies": {
+				"available-typed-arrays": "^1.0.7",
+				"call-bind": "^1.0.8",
+				"for-each": "^0.3.3",
+				"gopd": "^1.2.0",
+				"has-proto": "^1.2.0",
+				"is-typed-array": "^1.1.15",
+				"reflect.getprototypeof": "^1.0.9"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/typed-array-length": {
+			"version": "1.0.7",
+			"resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz",
+			"integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind": "^1.0.7",
+				"for-each": "^0.3.3",
+				"gopd": "^1.0.1",
+				"is-typed-array": "^1.1.13",
+				"possible-typed-array-names": "^1.0.0",
+				"reflect.getprototypeof": "^1.0.6"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/typescript": {
+			"version": "5.9.3",
+			"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+			"integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+			"license": "Apache-2.0",
+			"peer": true,
+			"bin": {
+				"tsc": "bin/tsc",
+				"tsserver": "bin/tsserver"
+			},
+			"engines": {
+				"node": ">=14.17"
+			}
+		},
+		"node_modules/unbox-primitive": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
+			"integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.3",
+				"has-bigints": "^1.0.2",
+				"has-symbols": "^1.1.0",
+				"which-boxed-primitive": "^1.1.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/unbzip2-stream": {
+			"version": "1.4.3",
+			"resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz",
+			"integrity": "sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==",
+			"license": "MIT",
+			"dependencies": {
+				"buffer": "^5.2.1",
+				"through": "^2.3.8"
+			}
+		},
+		"node_modules/undici-types": {
+			"version": "7.16.0",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+			"integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+			"license": "MIT"
+		},
+		"node_modules/unified": {
+			"version": "11.0.5",
+			"resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+			"integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"bail": "^2.0.0",
+				"devlop": "^1.0.0",
+				"extend": "^3.0.0",
+				"is-plain-obj": "^4.0.0",
+				"trough": "^2.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-builder": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unist-builder/-/unist-builder-4.0.0.tgz",
+			"integrity": "sha512-wmRFnH+BLpZnTKpc5L7O67Kac89s9HMrtELpnNaE6TAobq5DTZZs5YaTQfAZBA9bFPECx2uVAPO31c+GVug8mg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-find-after": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz",
+			"integrity": "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-is": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-is": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+			"integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-map": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-map/-/unist-util-map-4.0.0.tgz",
+			"integrity": "sha512-HJs1tpkSmRJUzj6fskQrS5oYhBYlmtcvy4SepdDEEsL04FjBrgF0Mgggvxc1/qGBGgW7hRh9+UBK1aqTEnBpIA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-modify-children": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-modify-children/-/unist-util-modify-children-4.0.0.tgz",
+			"integrity": "sha512-+tdN5fGNddvsQdIzUF3Xx82CU9sMM+fA0dLgR9vOmT0oPT2jH+P1nd5lSqfCfXAw+93NhcXNY2qqvTUtE4cQkw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"array-iterate": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-position": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+			"integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-position-from-estree": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz",
+			"integrity": "sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-remove": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-remove/-/unist-util-remove-4.0.0.tgz",
+			"integrity": "sha512-b4gokeGId57UVRX/eVKej5gXqGlc9+trkORhFJpu9raqZkZhU0zm8Doi05+HaiBsMEIJowL+2WtQ5ItjsngPXg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-is": "^6.0.0",
+				"unist-util-visit-parents": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-remove-position": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-5.0.0.tgz",
+			"integrity": "sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-visit": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-stringify-position": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+			"integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-visit": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
+			"integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-is": "^6.0.0",
+				"unist-util-visit-parents": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-visit-children": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unist-util-visit-children/-/unist-util-visit-children-3.0.0.tgz",
+			"integrity": "sha512-RgmdTfSBOg04sdPcpTSD1jzoNBjt9a80/ZCzp5cI9n1qPzLZWF9YdvWGN2zmTumP1HWhXKdUWexjy/Wy/lJ7tA==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/unist-util-visit-parents": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz",
+			"integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-is": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/universalify": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.0.0"
+			}
+		},
+		"node_modules/unpipe": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+			"integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/urijs": {
+			"version": "1.19.11",
+			"resolved": "https://registry.npmjs.org/urijs/-/urijs-1.19.11.tgz",
+			"integrity": "sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==",
+			"license": "MIT"
+		},
+		"node_modules/urlpattern-polyfill": {
+			"version": "10.0.0",
+			"resolved": "https://registry.npmjs.org/urlpattern-polyfill/-/urlpattern-polyfill-10.0.0.tgz",
+			"integrity": "sha512-H/A06tKD7sS1O1X2SshBVeA5FLycRpjqiBeqGKmBwBDBy28EnRjORxTNe269KSSr5un5qyWi1iL61wLxpd+ZOg==",
+			"license": "MIT"
+		},
+		"node_modules/use-callback-ref": {
+			"version": "1.3.3",
+			"resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz",
+			"integrity": "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"tslib": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/use-callback-ref/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"peer": true
+		},
+		"node_modules/use-sidecar": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz",
+			"integrity": "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==",
+			"license": "MIT",
+			"peer": true,
+			"dependencies": {
+				"detect-node-es": "^1.1.0",
+				"tslib": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"peerDependencies": {
+				"@types/react": "*",
+				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+			},
+			"peerDependenciesMeta": {
+				"@types/react": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/use-sidecar/node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD",
+			"peer": true
+		},
+		"node_modules/util-deprecate": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+			"integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+			"license": "MIT"
+		},
+		"node_modules/utility-types": {
+			"version": "3.11.0",
+			"resolved": "https://registry.npmjs.org/utility-types/-/utility-types-3.11.0.tgz",
+			"integrity": "sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/utils-merge": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+			"integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4.0"
+			}
+		},
+		"node_modules/uuid": {
+			"version": "11.1.0",
+			"resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
+			"integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
+			"funding": [
+				"https://github.com/sponsors/broofa",
+				"https://github.com/sponsors/ctavan"
+			],
+			"license": "MIT",
+			"bin": {
+				"uuid": "dist/esm/bin/uuid"
+			}
+		},
+		"node_modules/vary": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+			"integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/vfile": {
+			"version": "6.0.3",
+			"resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+			"integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"vfile-message": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/vfile-location": {
+			"version": "5.0.3",
+			"resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz",
+			"integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"vfile": "^6.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/vfile-matter": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/vfile-matter/-/vfile-matter-5.0.1.tgz",
+			"integrity": "sha512-o6roP82AiX0XfkyTHyRCMXgHfltUNlXSEqCIS80f+mbAyiQBE2fxtDVMtseyytGx75sihiJFo/zR6r/4LTs2Cw==",
+			"license": "MIT",
+			"dependencies": {
+				"vfile": "^6.0.0",
+				"yaml": "^2.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/vfile-message": {
+			"version": "4.0.3",
+			"resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+			"integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/unist": "^3.0.0",
+				"unist-util-stringify-position": "^4.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
+		"node_modules/web-namespaces": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
+			"integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		},
+		"node_modules/webidl-conversions": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+			"integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+			"license": "BSD-2-Clause"
+		},
+		"node_modules/whatwg-url": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+			"integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+			"license": "MIT",
+			"dependencies": {
+				"tr46": "~0.0.3",
+				"webidl-conversions": "^3.0.0"
+			}
+		},
+		"node_modules/which-boxed-primitive": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
+			"integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
+			"license": "MIT",
+			"dependencies": {
+				"is-bigint": "^1.1.0",
+				"is-boolean-object": "^1.2.1",
+				"is-number-object": "^1.1.1",
+				"is-string": "^1.1.1",
+				"is-symbol": "^1.1.1"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/which-builtin-type": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
+			"integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bound": "^1.0.2",
+				"function.prototype.name": "^1.1.6",
+				"has-tostringtag": "^1.0.2",
+				"is-async-function": "^2.0.0",
+				"is-date-object": "^1.1.0",
+				"is-finalizationregistry": "^1.1.0",
+				"is-generator-function": "^1.0.10",
+				"is-regex": "^1.2.1",
+				"is-weakref": "^1.0.2",
+				"isarray": "^2.0.5",
+				"which-boxed-primitive": "^1.1.0",
+				"which-collection": "^1.0.2",
+				"which-typed-array": "^1.1.16"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/which-collection": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
+			"integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
+			"license": "MIT",
+			"dependencies": {
+				"is-map": "^2.0.3",
+				"is-set": "^2.0.3",
+				"is-weakmap": "^2.0.2",
+				"is-weakset": "^2.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/which-typed-array": {
+			"version": "1.1.20",
+			"resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.20.tgz",
+			"integrity": "sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg==",
+			"license": "MIT",
+			"dependencies": {
+				"available-typed-arrays": "^1.0.7",
+				"call-bind": "^1.0.8",
+				"call-bound": "^1.0.4",
+				"for-each": "^0.3.5",
+				"get-proto": "^1.0.1",
+				"gopd": "^1.2.0",
+				"has-tostringtag": "^1.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/widest-line": {
+			"version": "5.0.0",
+			"resolved": "https://registry.npmjs.org/widest-line/-/widest-line-5.0.0.tgz",
+			"integrity": "sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==",
+			"license": "MIT",
+			"dependencies": {
+				"string-width": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/wrap-ansi": {
+			"version": "6.2.0",
+			"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+			"integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^4.0.0",
+				"string-width": "^4.1.0",
+				"strip-ansi": "^6.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/wrap-ansi/node_modules/ansi-regex": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/wrap-ansi/node_modules/ansi-styles": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+			"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+			"license": "MIT",
+			"dependencies": {
+				"color-convert": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-styles?sponsor=1"
+			}
+		},
+		"node_modules/wrap-ansi/node_modules/emoji-regex": {
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+			"license": "MIT"
+		},
+		"node_modules/wrap-ansi/node_modules/is-fullwidth-code-point": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+			"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/wrap-ansi/node_modules/string-width": {
+			"version": "4.2.3",
+			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+			"license": "MIT",
+			"dependencies": {
+				"emoji-regex": "^8.0.0",
+				"is-fullwidth-code-point": "^3.0.0",
+				"strip-ansi": "^6.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/wrap-ansi/node_modules/strip-ansi": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-regex": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/wrappy": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+			"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+			"license": "ISC"
+		},
+		"node_modules/ws": {
+			"version": "8.19.0",
+			"resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+			"integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			},
+			"peerDependencies": {
+				"bufferutil": "^4.0.1",
+				"utf-8-validate": ">=5.0.2"
+			},
+			"peerDependenciesMeta": {
+				"bufferutil": {
+					"optional": true
+				},
+				"utf-8-validate": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/xml2js": {
+			"version": "0.6.2",
+			"resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.6.2.tgz",
+			"integrity": "sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==",
+			"license": "MIT",
+			"dependencies": {
+				"sax": ">=0.6.0",
+				"xmlbuilder": "~11.0.0"
+			},
+			"engines": {
+				"node": ">=4.0.0"
+			}
+		},
+		"node_modules/xmlbuilder": {
+			"version": "11.0.1",
+			"resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz",
+			"integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=4.0"
+			}
+		},
+		"node_modules/y18n": {
+			"version": "5.0.8",
+			"resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+			"integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/yallist": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+			"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+			"license": "ISC"
+		},
+		"node_modules/yaml": {
+			"version": "2.8.2",
+			"resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
+			"integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
+			"license": "ISC",
+			"bin": {
+				"yaml": "bin.mjs"
+			},
+			"engines": {
+				"node": ">= 14.6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/eemeli"
+			}
+		},
+		"node_modules/yargs": {
+			"version": "17.7.1",
+			"resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.1.tgz",
+			"integrity": "sha512-cwiTb08Xuv5fqF4AovYacTFNxk62th7LKJ6BL9IGUpTJrWoU7/7WdQGTP2SjKf1dUNBGzDd28p/Yfs/GI6JrLw==",
+			"license": "MIT",
+			"dependencies": {
+				"cliui": "^8.0.1",
+				"escalade": "^3.1.1",
+				"get-caller-file": "^2.0.5",
+				"require-directory": "^2.1.1",
+				"string-width": "^4.2.3",
+				"y18n": "^5.0.5",
+				"yargs-parser": "^21.1.1"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/yargs-parser": {
+			"version": "21.1.1",
+			"resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+			"integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/yargs/node_modules/ansi-regex": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/yargs/node_modules/emoji-regex": {
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+			"license": "MIT"
+		},
+		"node_modules/yargs/node_modules/is-fullwidth-code-point": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+			"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/yargs/node_modules/string-width": {
+			"version": "4.2.3",
+			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+			"license": "MIT",
+			"dependencies": {
+				"emoji-regex": "^8.0.0",
+				"is-fullwidth-code-point": "^3.0.0",
+				"strip-ansi": "^6.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/yargs/node_modules/strip-ansi": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-regex": "^5.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/yauzl": {
+			"version": "2.10.0",
+			"resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+			"integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+			"license": "MIT",
+			"dependencies": {
+				"buffer-crc32": "~0.2.3",
+				"fd-slicer": "~1.1.0"
+			}
+		},
+		"node_modules/yoctocolors-cjs": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.3.tgz",
+			"integrity": "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/yoga-layout": {
+			"version": "3.2.1",
+			"resolved": "https://registry.npmjs.org/yoga-layout/-/yoga-layout-3.2.1.tgz",
+			"integrity": "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ==",
+			"license": "MIT"
+		},
+		"node_modules/zod": {
+			"version": "3.21.4",
+			"resolved": "https://registry.npmjs.org/zod/-/zod-3.21.4.tgz",
+			"integrity": "sha512-m46AKbrzKVzOzs/DZgVnG5H55N1sv1M8qZU3A8RIKbs3mrACDNeIOeilDymVb2HdmP8uwshOCF4uJ8uM9rCqJw==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/colinhacks"
+			}
+		},
+		"node_modules/zod-to-json-schema": {
+			"version": "3.20.4",
+			"resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.20.4.tgz",
+			"integrity": "sha512-Un9+kInJ2Zt63n6Z7mLqBifzzPcOyX+b+Exuzf7L1+xqck9Q2EPByyTRduV3kmSPaXaRer1JCsucubpgL1fipg==",
+			"license": "ISC",
+			"peerDependencies": {
+				"zod": "^3.20.0"
+			}
+		},
+		"node_modules/zwitch": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+			"integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/wooorm"
+			}
+		}
+	}
+}
diff --git a/docs/package.json b/docs/package.json
new file mode 100644
index 0000000..216bc3b
--- /dev/null
+++ b/docs/package.json
@@ -0,0 +1,31 @@
+{
+	"name": "docs",
+	"version": "1.0.0",
+	"main": "index.js",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"dev": "mintlify dev",
+		"check": "mintlify broken-links",
+		"rename": "mintlify rename"
+	},
+	"keywords": [],
+	"author": "",
+	"license": "ISC",
+	"description": "",
+	"dependencies": {
+		"mintlify": "^4.2.338"
+	},
+	"overrides": {
+		"tar-fs": "^3.1.1",
+		"js-yaml": "^4.1.1",
+		"tar@<=6.2.1": "6.2.1",
+		"body-parser@<=1.20.3": "1.20.3",
+		"axios@<=1.15.0": "1.15.0",
+		"qs@<=6.14.1": "6.14.1",
+		"express@<=4.20.0": "4.20.0",
+		"serve-static@<=1.16.0": "1.16.0",
+		"send@<=0.19.0": "0.19.0",
+		"path-to-regexp@<=0.1.12": "0.1.12",
+		"cookie@<=0.7.0": "0.7.0"
+	}
+}
diff --git a/docs/provider-config/anthropic.mdx b/docs/provider-config/anthropic.mdx
new file mode 100644
index 0000000..448f4ee
--- /dev/null
+++ b/docs/provider-config/anthropic.mdx
@@ -0,0 +1,69 @@
+---
+title: "Anthropic / Claude Code"
+description: "Configure Anthropic API keys or Claude Code subscription with Cline."
+---
+
+**Website:** [https://www.anthropic.com/](https://www.anthropic.com/)
+
+## Choose an Anthropic Path
+
+- **[Anthropic API (key-based)](#getting-an-api-key):** Use an Anthropic API key.
+- **[Claude Code (subscription-based)](#claude-code-subscription):** Use your Claude Max/Pro subscription through the Claude CLI.
+
+## Anthropic API (key-based)
+
+### Getting an API Key
+
+1.  **Sign Up/Sign In:** Go to the [Anthropic Console](https://console.anthropic.com/). Create an account or sign in.
+2.  **Navigate to API Keys:** Go to the [API keys](https://console.anthropic.com/settings/keys) section.
+3.  **Create a Key:** Click "Create Key". Give your key a descriptive name (e.g., "Cline").
+4.  **Copy the Key:** **Important:** Copy the API key _immediately_. You will not be able to see it again. Store it securely.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "Anthropic" from the "API Provider" dropdown.
+3.  **Enter API Key:** Paste your Anthropic API key into the "Anthropic API Key" field.
+4.  **Select Model:** Choose your desired Claude model from the "Model" dropdown.
+5.  **(Optional) Custom Base URL:** If you need to use a custom base URL for the Anthropic API, check "Use custom base URL" and enter the URL. Most users won't need to adjust this setting.
+
+## Claude Code (Subscription)
+
+Use this path if you already have Claude Max/Pro and want to use subscription-based access in Cline.
+
+1. Install and authenticate Claude CLI via Anthropic docs: [Claude Code setup](https://docs.anthropic.com/en/docs/claude-code/setup).
+2. In Cline settings, select **Claude Code** as provider.
+3. Set the Claude CLI path (usually `claude` if available in PATH).
+
+Find Claude path:
+- macOS / Linux / WSL / Git Bash: `which claude`
+- Windows Command Prompt: `where claude`
+
+Notes:
+- Uses your Claude subscription limits instead of API token billing.
+- Responses may not stream token-by-token.
+- Image uploads and prompt caching are limited in this mode.
+
+### Extended Thinking
+
+Anthropic models offer an "Extended Thinking" feature, designed to give them enhanced reasoning capabilities for complex tasks. This feature allows the model to output its step-by-step thought process before delivering a final answer, providing transparency and enabling more thorough analysis for challenging prompts.
+
+When extended thinking is in Cline, the model generates `thinking` content blocks that detail its internal reasoning. These insights are then incorporated into its final response.
+Cline users can leverage this by checking the `Enable Extended Thinking` box below the model selection menu after selecting a Claude Model from any provider.
+
+**Key Aspects of Extended Thinking:**
+
+-   **Summarized Thinking (Claude 3.7+):** For Claude 3.7+ models, the API returns a summary of the full thinking process to balance insight with efficiency and prevent misuse. You are billed for the full thinking tokens, not just the summary.
+-   **Streaming:** Extended thinking responses, including the `thinking` blocks, can be streamed.
+-   **Tool Use & Prompt Caching:** Extended thinking interacts with tool use (requiring thinking blocks to be passed back) and prompt caching (with specific behaviors around cache invalidation and context).
+
+For comprehensive details on how extended thinking works, including API examples, interaction with tool use, prompt caching, and pricing, please refer to the [official Anthropic documentation on Extended Thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking).
+
+### Tips and Notes
+
+-   **Prompt Caching:** Claude 3 models support [prompt caching](https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching), which can significantly reduce costs and latency for repeated prompts.
+-   **Context Window:** Claude models have large context windows (200,000 tokens), allowing you to include a significant amount of code and context in your prompts.
+-   **Pricing:** Refer to the [Anthropic Pricing](https://www.anthropic.com/pricing) page for the latest pricing information.
+-   **Rate Limits:** Anthropic has strict rate limits based on [usage tiers](https://docs.anthropic.com/en/api/rate-limits#requirements-to-advance-tier). If you're repeatedly hitting rate limits, consider contacting Anthropic sales or accessing Claude through a different provider like [OpenRouter](/provider-config/openrouter) or [Requesty](/provider-config/other-30-plus-providers#requesty).
diff --git a/docs/provider-config/atomic-chat.mdx b/docs/provider-config/atomic-chat.mdx
new file mode 100644
index 0000000..fbb6522
--- /dev/null
+++ b/docs/provider-config/atomic-chat.mdx
@@ -0,0 +1,27 @@
+---
+title: "Atomic Chat"
+description: "Use local models through Atomic Chat's OpenAI-compatible API."
+---
+
+[Atomic Chat](https://atomic.chat) is a local AI provider.
+
+## Setup in Cline
+
+1. Install and launch Atomic Chat.
+2. Download or load a model in the app.
+3. In Cline Settings, choose **Atomic Chat** as the provider.
+4. Keep the default base URL `http://127.0.0.1:1337/v1` unless you changed Atomic Chat's server port.
+5. Pick a model from the dropdown (models are fetched from `GET /v1/models`).
+
+## API key
+
+Atomic Chat typically does not require an API key for local use. Leave the field empty unless your setup requires one.
+
+## Tool calling
+
+Atomic Chat supports tool calls for agent workflows when the loaded model supports them. Enable **Use Compact Prompt** for smaller local context windows.
+
+## Related links
+
+- [Atomic Chat website](https://atomic.chat)
+- [Atomic Chat GitHub](https://github.com/AtomicBot-ai/Atomic-Chat)
diff --git a/docs/provider-config/aws-bedrock/api-key.mdx b/docs/provider-config/aws-bedrock/api-key.mdx
new file mode 100644
index 0000000..6f84d4c
--- /dev/null
+++ b/docs/provider-config/aws-bedrock/api-key.mdx
@@ -0,0 +1,120 @@
+---
+title: "API Key (Simple Setup)"
+sidebarTitle: "API Key"
+description: "Set up AWS Bedrock with Cline using Bedrock API Keys. Simplest setup for individual developers to access frontier provider."
+---
+
+### Overview
+
+-   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Nova) through AWS.\
+    [Learn more about AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
+-   **Cline:** A VS Code extension that acts as a coding assistant by integrating with AI models-empowering developers to generate code, debug, and analyze data.
+-   **Developer Focus:** This guide is tailored for individual developers that want to enable access to frontier models via AWS Bedrock with a simplified setup using API Keys.
+
+---
+
+### Step 1: Prepare Your AWS Environment
+
+#### 1.1 Individual user setup - Create a Bedrock API Key
+
+For more detailed instructions check the [documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html).
+
+1. **Sign in to the AWS Management Console:**\
+   [AWS Console](https://aws.amazon.com/console/)
+2. **Access Bedrock Console:**
+    - [Bedrock Console](https://console.aws.amazon.com/bedrock)
+    - Create a new Long Lived API Key. This API Key will have by default the `AmazonBedrockLimitedAccess` IAM policy
+      [View AmazonBedrockLimitedAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
+
+#### 1.2 Create or Modify the Policy
+
+To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockLimitedAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
+
+-   `bedrock:InvokeModel`
+-   `bedrock:InvokeModelWithResponseStream`
+-   `bedrock:CallWithBearerToken`
+
+You can create a custom IAM policy with these permissions and attach it to your IAM user or role.
+
+1.  In the AWS IAM console, create a new policy.
+2.  Use the JSON editor to add the following policy document:
+    ```json
+    {
+    	"Version": "2012-10-17",
+    	"Statement": [
+    		{
+    			"Effect": "Allow",
+    			"Action": ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream", "bedrock:CallWithBearerToken"],
+    			"Resource": "*" // For enhanced security, scope this to specific model ARNs if possible.
+    		}
+    	]
+    }
+    ```
+3.  Name the policy (e.g., `ClineBedrockInvokeAccess`) and attach it to the IAM user associated with the key you created. The IAM user and the API key have the same prefix.
+
+**Important Considerations:**
+
+-   **Model Listing in Cline:** The minimal permissions (`bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`) are sufficient for Cline to _use_ a model if you specify the model ID directly in Cline's settings. If you rely on Cline to dynamically list available Bedrock models, you might need additional permissions like `bedrock:ListFoundationModels`.
+-   **AWS Marketplace Subscriptions:** For third-party models (e.g., Anthropic Claude), the **`AmazonBedrockLimitedAccess`** policy grants you the necessary permissions to subscribe via the AWS Marketplace. There is no explicit access to be enabled. For Anthropic models you are still required to submit a First Time Use (FTU) form via the Console. If you get the following message in the Cline chat `[ERROR] Failed to process response: Model use case details have not been submitted for this account. Fill out the Anthropic use case details form before using the model.` then open the [Playground in the AWS Bedrock Console](https://console.aws.amazon.com/bedrock/home?#/text-generation-playground), select any Anthropic model and fill in the form (you might need to send a prompt first)
+
+---
+
+### Step 2: Verify Regional Access
+
+#### 2.1 Choose and Confirm a Region
+
+1. **Select a Region:**\
+   AWS Bedrock is available in multiple regions (e.g., US East, Europe, Asia Pacific). Choose the region that meets your latency and compliance needs.\
+   [AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
+2. **Verify Model Access:**
+    - **Note:** Some models are only accessible via an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). In such case check the box "Cross Region Inference".
+
+---
+
+### Step 3: Configure the Cline VS Code Extension
+
+#### 3.1 Install and Open Cline
+
+1. **Install VS Code:**\
+   Download from the [VS Code website](https://code.visualstudio.com/).
+2. **Install the Cline Extension:**
+    - Open VS Code.
+    - Go to the Extensions Marketplace (`Ctrl+Shift+X` or `Cmd+Shift+X`).
+    - Search for **Cline** and install it.
+
+#### 3.2 Configure Cline Settings
+
+1. **Open Cline Settings:**
+    - Click on the settings ⚙️ to select your API Provider.
+2. **Select AWS Bedrock as the API Provider:**
+    - From the API Provider dropdown, choose **AWS Bedrock**.
+3. **Enter Your AWS API Key:**
+    - Input your **API Key**
+    - Specify the correct **AWS Region** (e.g., `us-east-1` or your enterprise-approved region).
+4. **Select a Provider Model:**
+5. **Save and Test:**
+    - Click **Done/Save** to apply your settings.
+    - Test the integration by sending a simple prompt (e.g., "Generate a Python function to check if a number is prime.").
+
+---
+
+### Step 4: Security, Monitoring, and Best Practices
+
+1. **Secure Access:**
+    - Prefer AWS SSO/federated roles over long-lived API Key when possible.
+    - [AWS IAM Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)
+2. **Enhance Network Security:**
+    - Consider setting up [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) to securely connect to Bedrock.
+3. **Monitor and Log Activity:**
+    - Enable AWS CloudTrail to log Bedrock API calls.
+    - Use CloudWatch to monitor metrics like invocation count, latency, and token usage.
+    - Set up alerts for abnormal activity.
+4. **Handle Errors and Manage Costs:**
+    - Implement exponential backoff for throttling errors.
+    - Use AWS Cost Explorer and set billing alerts to track usage.\
+      [AWS Cost Management](https://docs.aws.amazon.com/cost-management/latest/userguide/what-is-aws-cost-management.html)
+5. **Regular Audits and Compliance:**
+    - Periodically review IAM roles and CloudTrail logs.
+    - Follow internal data privacy and governance policies.
+
+---
diff --git a/docs/provider-config/aws-bedrock/cli-profile.mdx b/docs/provider-config/aws-bedrock/cli-profile.mdx
new file mode 100644
index 0000000..ef74b3e
--- /dev/null
+++ b/docs/provider-config/aws-bedrock/cli-profile.mdx
@@ -0,0 +1,43 @@
+---
+title: "CLI Profile (SSO)"
+sidebarTitle: "CLI Profile (SSO)"
+description: "Configure AWS Bedrock to use AWS CLI profiles for authentication with Cline. Best for SSO/federated roles and secure enterprise access."
+---
+
+### Overview
+
+Cline offers the option of utilizing AWS credentials or AWS profiles to access AWS Bedrock services. SSO/Federated roles are suggested over Legacy IAM configuration; this guide describes how to configure your environment so that Cline uses SSO roles for authentication.
+
+---
+
+### Configuration Steps
+
+1. Install the [latest version](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) of AWS CLI
+
+    - Follow the AWS docs to install your OS-specific version of AWS CLI
+
+2. [Configure IAM authentication](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html) with the AWS CLI
+
+    - If you do not already have AWS access through the IAM Identity Center, follow the [IAM User Guide](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) to set up IAM users and roles. Ensure you have a `PowerUserAccess` role.
+    - If you have access to AWS through your employer, open your AWS access portal and find the appropriate account. Ensure you have `PowerUserAccess` permissions.
+    - Open the `Access keys` link and note the `SSO start URL` and `SSO region`, which are needed in the next step
+
+3. Continue configuring your profile using [the `aws configure sso` CLI wizard](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html#cli-configure-sso-configure)
+
+    - Once configured, use the following command to authenticate the AWS CLI: `aws sso login --profile <AWS-profile-name>`
+    - Note which profile name you attach to your AWS account, this is needed to configure Cline in the following steps
+
+4. If you haven't already done so, install VSCode and the Cline extension. Consult the [Getting Started](/getting-started/installing-cline) page for guidance.
+
+5. Open the Cline extension, then click on the settings button ⚙️ to select your API Provider.
+    - From the API Provider dropdown, select AWS Bedrock
+    - Select the AWS Profile radio button, then enter the AWS Profile Name from step 3
+    - Select your AWS Region from the dropdown menu
+    - Selecting the cross-region inference checkbox is required for some models
+
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-aws-setup-markup%20(1).png"
+		alt="AWS Bedrock configuration in Cline settings showing profile authentication setup"
+	/>
+</Frame>
diff --git a/docs/provider-config/aws-bedrock/iam-credentials.mdx b/docs/provider-config/aws-bedrock/iam-credentials.mdx
new file mode 100644
index 0000000..3d08765
--- /dev/null
+++ b/docs/provider-config/aws-bedrock/iam-credentials.mdx
@@ -0,0 +1,135 @@
+---
+title: "IAM Credentials"
+sidebarTitle: "IAM Credentials"
+description: "Set up AWS Bedrock with Cline using IAM Access Key and Secret Key credentials. Best for enterprise environments with established IAM policies."
+---
+
+### Overview
+
+-   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Nova) through AWS.\
+    [Learn more about AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
+-   **Cline:** A VS Code extension that acts as a coding assistant by integrating with AI models-empowering developers to generate code, debug, and analyze data.
+-   **Enterprise Focus:** This guide is tailored for organizations with established AWS environments (using IAM roles, AWS SSO, AWS Organizations, etc.) to ensure secure and compliant usage.
+
+---
+
+### Step 1: Prepare Your AWS Environment
+
+#### 1.1 Create or Use an IAM Role/User
+
+1. **Sign in to the AWS Management Console:**\
+   [AWS Console](https://aws.amazon.com/console/)
+2. **Access IAM:**
+    - Search for **IAM (Identity and Access Management)** in the AWS Console.
+    - Either create a new IAM user or use your enterprise's AWS SSO to assume a dedicated role for Bedrock access.
+    - [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html)
+
+#### 1.2 Attach the Required Policies
+
+To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockLimitedAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
+
+-   `bedrock:InvokeModel`
+-   `bedrock:InvokeModelWithResponseStream`
+
+You can create a custom IAM policy with these permissions and attach it to your IAM user or role.
+
+**Option 1: Minimal Permissions (Recommended for Production & Least Privilege)**
+
+1.  In the AWS IAM console, create a new policy.
+2.  Use the JSON editor to add the following policy document:
+    ```json
+    {
+    	"Version": "2012-10-17",
+    	"Statement": [
+    		{
+    			"Effect": "Allow",
+    			"Action": ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream"],
+    			"Resource": "*" // For enhanced security, scope this to specific model ARNs if possible.
+    		}
+    	]
+    }
+    ```
+3.  Name the policy (e.g., `ClineBedrockInvokeAccess`) and attach it to your IAM user or role.
+
+**Option 2: Using a Managed Policy (Simpler Initial Setup)**
+
+-   Alternatively, you can attach the AWS managed policy **`AmazonBedrockLimitedAccess`**. This grants broader permissions, including the ability to list models, manage provisioning, and other Bedrock features. This might be simpler for initial setup or if you require these wider capabilities.
+    [View AmazonBedrockLimitedAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
+
+**Important Considerations:**
+
+-   **Model Listing in Cline:** The minimal permissions (`bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`) are sufficient for Cline to _use_ a model if you specify the model ID directly in Cline's settings. If you rely on Cline to dynamically list available Bedrock models, you might need additional permissions like `bedrock:ListFoundationModels`.
+-   **AWS Marketplace Subscriptions:** For third-party models (e.g., Anthropic Claude), ensure you have active AWS Marketplace subscriptions. This is typically managed in the AWS Bedrock console under "Model access" and might require `aws-marketplace:Subscribe` permissions if not already handled.
+-   _Enterprise Tip:_ Always apply least-privilege practices. Where possible, scope resource ARNs in your IAM policies to specific models or regions. Utilize [Service Control Policies (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) for overarching governance in AWS Organizations.
+
+---
+
+### Step 2: Verify Regional Access
+
+#### 2.1 Choose and Confirm a Region
+
+1. **Select a Region:**\
+   AWS Bedrock is available in multiple regions (e.g., US East, Europe, Asia Pacific). Choose the region that meets your latency and compliance needs.\
+   [AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
+2. **Verify Model Access:**
+    - In the AWS Bedrock console, confirm that the models your team requires (e.g., Anthropic Claude, Amazon Nova) are marked as "Access granted."
+    - **Note:** Some advanced models might require an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) if not available on-demand.
+
+#### 2.2 Set Up AWS Marketplace Subscriptions (if needed)
+
+1. **Subscribe to Third-Party Models:**
+    - Navigate to the AWS Bedrock console and locate the model subscription section.
+    - For models from third-party providers (e.g., Anthropic), accept the terms to subscribe.
+    - [AWS Marketplace](https://aws.amazon.com/marketplace/)
+2. **Enterprise Tip:**
+    - Model subscriptions are often managed centrally. Confirm with your cloud team if a standard subscription process is in place.
+
+---
+
+### Step 3: Configure the Cline VS Code Extension
+
+#### 3.1 Install and Open Cline
+
+1. **Install VS Code:**\
+   Download from the [VS Code website](https://code.visualstudio.com/).
+2. **Install the Cline Extension:**
+    - Open VS Code.
+    - Go to the Extensions Marketplace (`Ctrl+Shift+X` or `Cmd+Shift+X`).
+    - Search for **Cline** and install it.
+
+#### 3.2 Configure Cline Settings
+
+1. **Open Cline Settings:**
+    - Click on the settings ⚙️ to select your API Provider.
+2. **Select AWS Bedrock as the API Provider:**
+    - From the API Provider dropdown, choose **AWS Bedrock**.
+3. **Enter Your AWS Credentials:**
+    - Input your **Access Key** and **Secret Key** (or use temporary credentials if using AWS SSO).
+    - Specify the correct **AWS Region** (e.g., `us-east-1` or your enterprise-approved region).
+4. **Select a Provider Model:**
+5. **Save and Test:**
+    - Click **Done/Save** to apply your settings.
+    - Test the integration by sending a simple prompt (e.g., "Generate a Python function to check if a number is prime.").
+
+---
+
+### Step 4: Security, Monitoring, and Best Practices
+
+1. **Secure Access:**
+    - Prefer AWS SSO/federated roles over long-lived IAM credentials.
+    - [AWS IAM Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)
+2. **Enhance Network Security:**
+    - Consider setting up [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) to securely connect to Bedrock.
+3. **Monitor and Log Activity:**
+    - Enable AWS CloudTrail to log Bedrock API calls.
+    - Use CloudWatch to monitor metrics like invocation count, latency, and token usage.
+    - Set up alerts for abnormal activity.
+4. **Handle Errors and Manage Costs:**
+    - Implement exponential backoff for throttling errors.
+    - Use AWS Cost Explorer and set billing alerts to track usage.\
+      [AWS Cost Management](https://docs.aws.amazon.com/cost-management/latest/userguide/what-is-aws-cost-management.html)
+5. **Regular Audits and Compliance:**
+    - Periodically review IAM roles and CloudTrail logs.
+    - Follow internal data privacy and governance policies.
+
+---
diff --git a/docs/provider-config/deepseek.mdx b/docs/provider-config/deepseek.mdx
new file mode 100644
index 0000000..9c54973
--- /dev/null
+++ b/docs/provider-config/deepseek.mdx
@@ -0,0 +1,24 @@
+---
+title: "DeepSeek"
+description: "Learn how to configure and use DeepSeek provider."
+---
+
+**Website:** [https://platform.deepseek.com/](https://platform.deepseek.com/)
+
+### Get API Credentials
+
+1.  **Sign Up/Sign In:** Go to the [DeepSeek Platform](https://platform.deepseek.com/). Create an account or sign in.
+2.  **Navigate to API Keys:** Find your API keys in the [API keys](https://platform.deepseek.com/api_keys) section of the platform.
+3.  **Create a Key:** Click "Create new API key". Give your key a descriptive name (e.g., "Cline").
+4.  **Copy the Key:** **Important:** Copy the API key _immediately_. You will not be able to see it again. Store it securely.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the ⚙️ icon in the Cline panel.
+2.  **Select Provider:** Choose "DeepSeek" from the "API Provider" dropdown.
+3.  **Enter API Key:** Paste your DeepSeek API key into the "DeepSeek API Key" field.
+4.  **Select Provider Model:** Choose your desired model from the "Model" dropdown.
+
+### Tips and Notes
diff --git a/docs/provider-config/google-gemini.mdx b/docs/provider-config/google-gemini.mdx
new file mode 100644
index 0000000..aef2c94
--- /dev/null
+++ b/docs/provider-config/google-gemini.mdx
@@ -0,0 +1,28 @@
+---
+title: "Google Gemini"
+description: "Learn how to configure and use Google Gemini with Cline."
+---
+
+Google Gemini is Google's family of multimodal AI models, offering some of the largest context windows available and strong performance across coding, reasoning, and document analysis tasks.
+
+**Website:** [https://ai.google.dev/](https://ai.google.dev/)
+
+### Get API Credentials
+
+1.  **Sign Up/Sign In:** Go to [Google AI Studio](https://aistudio.google.com/). Sign in with your Google account.
+2.  **Get API Key:** Navigate to [aistudio.google.com/apikey](https://aistudio.google.com/apikey).
+3.  **Create a Key:** Click "Create API Key" and select or create a Google Cloud project.
+4.  **Copy the Key:** Copy the API key immediately and store it securely.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "Google Gemini" from the "API Provider" dropdown.
+3.  **Enter API Key:** Paste your Google AI API key into the "Gemini API Key" field.
+4.  **Select Provider Model:** Choose your desired model from the "Model" dropdown.
+
+### Tips and Notes
+
+-   **Pricing:** Refer to the [Google AI pricing page](https://ai.google.dev/gemini-api/docs/models/gemini) for the latest information.
diff --git a/docs/provider-config/minimax.mdx b/docs/provider-config/minimax.mdx
new file mode 100644
index 0000000..c3720bf
--- /dev/null
+++ b/docs/provider-config/minimax.mdx
@@ -0,0 +1,30 @@
+---
+title: "MiniMax"
+description: "Learn how to configure and use MiniMax provider with Cline.."
+---
+
+MiniMax provides AI models with large context windows and competitive pricing, featuring the MiniMax-M2 series.
+
+**Website:** [https://www.minimax.io/](https://www.minimax.io/)
+
+### Get API Credentials
+
+1.  **Sign Up/Sign In:** Go to the [MiniMax Platform](https://www.minimax.io/platform). Create an account or sign in.
+2.  **Navigate to API Keys:** Access the API key section.
+3.  **Create a Key:** Generate a new API key.
+4.  **Copy the Key:** Copy the API key immediately and store it securely.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "MiniMax" from the "API Provider" dropdown.
+3.  **Enter API Key:** Paste your MiniMax API key.
+4.  **Select Provider Model:** Choose your desired model from the "Model" dropdown.
+
+### Tips and Notes
+
+-   **Large Context:** All models support 192K token context windows.
+-   **Reasoning Support:** M2.7 and M2.5 support extended thinking/reasoning for complex tasks.
+-   **Pricing:** Check the [MiniMax pricing page](https://www.minimax.io/platform/document/pricing) for current rates.
diff --git a/docs/provider-config/openai-compatible.mdx b/docs/provider-config/openai-compatible.mdx
new file mode 100644
index 0000000..2840e54
--- /dev/null
+++ b/docs/provider-config/openai-compatible.mdx
@@ -0,0 +1,59 @@
+---
+title: "OpenAI Compatible"
+description: "Learn how to configure Cline with various AI model providers that offer OpenAI-compatible APIs."
+---
+
+Cline supports a wide range of AI model providers that offer APIs compatible with the OpenAI API standard. This allows you to use models from providers _other than_ OpenAI, while still utilizing a familiar API interface. This includes providers such as:
+
+-   **Local models** running through tools like Ollama and LM Studio (which are covered in their respective sections).
+-   **Cloud providers** like Perplexity, Together AI, Anyscale, and many others.
+-   **Any other provider** that offers an OpenAI-compatible API endpoint.
+
+This document focuses on setting up providers _other than_ the official OpenAI API (which has its own [dedicated configuration page](/provider-config/openai)).
+
+### General Configuration
+
+The key to using an OpenAI-compatible provider with Cline is to configure these main settings:
+
+1.  **Base URL:** This is the API endpoint specific to the provider. It will _not_ be `https://api.openai.com/v1` (that URL is for the official OpenAI API).
+2.  **API Key:** This is the secret key you obtain from your chosen provider. (or **Use Azure Identity Authentication**)
+3.  **Model ID:** This is the specific name or identifier for the model you wish to use.
+
+You'll find these settings in the Cline settings panel (click the ⚙️ icon):
+
+-   **API Provider:** Select "OpenAI Compatible".
+-   **Base URL:** Enter the base URL provided by your chosen provider. **This is a crucial step.**
+-   **API Key:** Enter your API key from the provider.
+-   **Model:** Choose or enter the model ID.
+-   **Use Azure Identity Authentication:** Check the box to authenticate with your Azure managed identity (Note that this will not trigger the authentication, it will use the existing one (e.g., "az login"))
+-   **Model Configuration:** This section allows you to customize advanced parameters for the model, such as:
+    -   Max Output Tokens
+    -   Context Window size
+    -   Image Support capabilities
+    -   Computer Use (e.g., for models with tool/function calling)
+    -   Input Price (per token/million tokens)
+    -   Output Price (per token/million tokens)
+
+**Note:** If you are using a different OpenAI-compatible provider (such as Together AI, Anyscale, etc.), the available model IDs will differ. Always refer to your specific provider's documentation for their supported model names and any unique configuration details.
+
+### v0 (Vercel SDK) in Cline:
+
+-   For developers working with v0, their [AI SDK documentation](https://vercel.com/docs/v0/cline) provides valuable insights and examples for integrating various models, many of which are OpenAI-compatible. This can be a helpful resource for understanding how to structure calls and manage configurations when using Cline with services deployed on or integrated with Vercel.
+
+-   v0 can be used in Cline with the OpenAI Compatible provider.
+
+-   ### Quickstart
+
+-   1. With the OpenAI Compatible provider selected, set the Base URL to https://api.v0.dev/v1.
+-   2. Paste in your v0 API Key
+-   3. Set the Model ID: v0-1.0-md
+-   4. Click Verify to confirm the connection.
+
+### Troubleshooting
+
+-   **"Invalid API Key":** Double-check that you've entered the API key correctly and that it's for the correct provider.
+-   **"Model Not Found":** Ensure you're using a valid model ID for your chosen provider and that it's available at the specified Base URL.
+-   **Connection Errors:** Verify the Base URL is correct, that your provider's API is accessible from your machine, and that there are no firewall or network issues.
+-   **Unexpected Results:** If you're getting unexpected outputs, try a different model or double-check all configuration parameters.
+
+By using an OpenAI-compatible provider, you can leverage the flexibility of Cline with a wider array of AI models. Remember to always consult your provider's documentation for the most accurate and up-to-date information.
diff --git a/docs/provider-config/openai.mdx b/docs/provider-config/openai.mdx
new file mode 100644
index 0000000..3bcce31
--- /dev/null
+++ b/docs/provider-config/openai.mdx
@@ -0,0 +1,48 @@
+---
+title: "OpenAI (Codex)"
+description: "Configure OpenAI with API key or OpenAI Codex OAuth in Cline."
+---
+
+Cline supports accessing models directly through the official OpenAI API.
+
+## Choose an OpenAI Path
+
+- **[OpenAI API (key-based)](#get-api-credentials):** Use your OpenAI API key.
+- **[OpenAI Codex (Subscription OAuth)](#openai-codex-oauth):** Sign in with OpenAI account, using OAI subscriptions (no key management).
+
+**Website:** [https://openai.com/](https://openai.com/)
+
+## OpenAI API (key-based)
+
+### Get API Credentials
+
+1.  **Sign Up/Sign In:** Visit the [OpenAI Platform](https://platform.openai.com/). You'll need to create an account or sign in if you already have one.
+2.  **Navigate to API Keys:** Once logged in, go to the [API keys section](https://platform.openai.com/api-keys) of your account.
+3.  **Create a Key:** Click on "Create new secret key". It's good practice to give your key a descriptive name (e.g., "Cline API Key").
+4.  **Copy the Key:** **Crucial:** Copy the generated API key immediately. For security reasons, OpenAI will not show it to you again. Store this key in a safe and secure location.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings gear icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "OpenAI" from the "API Provider" dropdown menu.
+3.  **Enter API Key:** Paste your OpenAI API key into the "OpenAI API Key" field.
+4.  **Select Provider Model:** Choose your desired model from the "Model" dropdown list.
+5.  **(Optional) Base URL:** If you need to use a proxy or a custom base URL for the OpenAI API, you can enter it here. Most users will not need to change this from the default.
+
+### Tips and Notes
+
+-   **Pricing:** Be sure to review the [OpenAI Pricing page](https://openai.com/pricing) for detailed information on the costs associated with different models.
+-   **Azure OpenAI Service:** If you are looking to use the Azure OpenAI service, please note that specific documentation for Azure OpenAI with Cline may be found separately, or you might need to configure it as an OpenAI-compatible endpoint if such functionality is supported by Cline for custom configurations.
+
+## OpenAI Codex (OAuth)
+
+1. Open Cline settings.
+2. Select **OpenAI Codex** from **API Provider**.
+3. Click **Sign in with OpenAI** and complete browser OAuth.
+4. Return to Cline and choose a model.
+
+Notes:
+- No API key entry required.
+- Available models depend on your OpenAI plan.
diff --git a/docs/provider-config/openrouter.mdx b/docs/provider-config/openrouter.mdx
new file mode 100644
index 0000000..aee9c50
--- /dev/null
+++ b/docs/provider-config/openrouter.mdx
@@ -0,0 +1,32 @@
+---
+title: "OpenRouter"
+description: "Learn how to use OpenRouter with Cline to access a wide variety of language provider through a single API."
+---
+
+OpenRouter is an AI platform that provides access to a wide variety of language models from different providers, all through a single API. This can simplify setup and allow you to easily experiment with different models.
+
+**Website:** [https://openrouter.ai/](https://openrouter.ai/)
+
+### Get API Credentials
+
+1.  **Sign Up/Sign In:** Go to the [OpenRouter website](https://openrouter.ai/). Sign in with your Google or GitHub account.
+2.  **Get an API Key:** Go to the [keys page](https://openrouter.ai/keys). You should see an API key listed. If not, create a new key.
+3.  **Copy the Key:** Copy the API key.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "OpenRouter" from the "API Provider" dropdown.
+3.  **Enter API Key:** Paste your OpenRouter API key into the "OpenRouter API Key" field.
+4.  **Select Provider Model:** Choose your desired model from the "Model" dropdown.
+5.  **(Optional) Custom Base URL:** If you need to use a custom base URL for the OpenRouter API, check "Use custom base URL" and enter the URL. Leave this blank for most users.
+
+### Tips and Notes
+
+-   **Pricing:** OpenRouter charges based on the underlying model's pricing. See the [OpenRouter Models page](https://openrouter.ai/models) for details.
+    -   OpenRouter passes caching requests to underlying models that support it. Check the [OpenRouter Models page](https://openrouter.ai/models) to see which models offer caching.
+    -   For most models, caching should activate automatically if supported by the model itself (similar to how Requesty works).
+    -   **Exception for Gemini Models via OpenRouter:** Due to potential response delays sometimes observed with Google's caching mechanism when accessed via OpenRouter, a manual activation step is required _specifically for Gemini models_.
+    -   If using a **Gemini model** via OpenRouter, you **must manually check** the "Enable Prompt Caching" box in the provider settings to activate caching for that model. This checkbox serves as a temporary workaround. For non-Gemini models on OpenRouter, this checkbox is not necessary for caching.
diff --git a/docs/provider-config/other-30-plus-providers.mdx b/docs/provider-config/other-30-plus-providers.mdx
new file mode 100644
index 0000000..2349f99
--- /dev/null
+++ b/docs/provider-config/other-30-plus-providers.mdx
@@ -0,0 +1,322 @@
+---
+title: "Other 30+ Providers"
+description: "Reference list for additional supported providers with shared configuration flow."
+---
+
+Use this page for providers that follow the same setup pattern.
+
+## Menu
+
+- [Shared Configuration in Cline](#shared-configuration-in-cline)
+- [Providers](#providers)
+  - [AIHubMix](#aihubmix)
+  - [AskSage](#asksage)
+  - [Baseten](#baseten)
+  - [Cerebras](#cerebras)
+  - [Dify.ai](#difyai)
+  - [Doubao](#doubao)
+  - [Fireworks AI](#fireworks-ai)
+  - [GCP Vertex AI](#gcp-vertex-ai)
+  - [Groq](#groq)
+  - [Hicap](#hicap)
+  - [Huawei Cloud MaaS](#huawei-cloud-maas)
+  - [Hugging Face](#hugging-face)
+  - [Mistral](#mistral)
+  - [Moonshot](#moonshot)
+  - [Nebius AI Studio](#nebius-ai-studio)
+  - [Nous Research](#nous-research)
+  - [Oracle Code Assist](#oracle-code-assist)
+  - [Qwen Code](#qwen-code)
+  - [Requesty](#requesty)
+  - [SambaNova](#sambanova)
+  - [SAP AI Core](#sap-ai-core)
+  - [Together](#together)
+  - [Vercel AI Gateway](#vercel-ai-gateway)
+  - [VS Code Language Model API](#vs-code-language-model-api)
+  - [xAI (Grok)](#xai-grok)
+
+## Shared Configuration in Cline
+
+1. Open Cline settings (⚙️).
+2. Select your provider from **API Provider**.
+3. Paste your API key/token in the matching credential field.
+4. Choose a model from **Model**.
+
+For the full auth flow (IDE + CLI), see [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+## Providers
+
+### AIHubMix
+AIHubMix is an OpenAI-compatible model aggregator that gives you one API surface for multiple model backends.
+
+**Website:** [https://aihubmix.com/](https://aihubmix.com/)
+
+#### Basic Setup
+
+1. Create/sign in to your AIHubMix account.
+2. Generate an API key from the dashboard.
+3. In Cline, choose **AIHubMix** and paste the key.
+
+### AskSage
+AskSage is focused on enterprise and government AI access with compliance-oriented controls.
+
+**Website:** [https://www.asksage.ai/](https://www.asksage.ai/)
+
+#### Basic Setup
+
+1. Sign in to AskSage and create API credentials.
+2. Confirm your workspace/organization has model access enabled.
+3. In Cline, select **AskSage** and enter the key.
+
+### Baseten
+Baseten provides hosted model APIs and deployment infrastructure for production inference.
+
+**Website:** [https://www.baseten.co/products/model-apis/](https://www.baseten.co/products/model-apis/)
+
+#### Basic Setup
+
+1. Create a Baseten account and open the API keys section.
+2. Generate an API key with the required permissions.
+3. In Cline, choose **Baseten** and paste the key.
+
+### Cerebras
+Cerebras offers very fast hosted inference for supported model families.
+
+**Website:** [https://cloud.cerebras.ai/](https://cloud.cerebras.ai/)
+
+#### Basic Setup
+
+1. Sign in to Cerebras Cloud.
+2. Create or retrieve your API key.
+3. In Cline, select **Cerebras** and enter the key.
+
+### Dify.ai
+Dify.ai is a workflow-centric AI platform with app and pipeline capabilities.
+
+**Website:** [https://dify.ai/](https://dify.ai/)
+
+#### Basic Setup
+
+1. Create a Dify workspace and API credential.
+2. Confirm your Dify endpoint/provider settings are active.
+3. In Cline, select **Dify.ai** and paste your key.
+
+### Doubao
+Doubao is ByteDance’s model family, typically accessed through Volcengine services.
+
+**Website:** [https://www.volcengine.com/](https://www.volcengine.com/)
+
+#### Basic Setup
+
+1. Sign in to Volcengine and enable model access.
+2. Generate API credentials for Doubao endpoints.
+3. In Cline, select **Doubao** and paste credentials.
+
+### Fireworks AI
+Fireworks AI provides hosted inference for open models and performance-focused deployment.
+
+**Website:** [https://fireworks.ai/](https://fireworks.ai/)
+
+#### Basic Setup
+
+1. Create a Fireworks account.
+2. Generate an API key in your project/account settings.
+3. In Cline, choose **Fireworks AI** and enter the key.
+
+### GCP Vertex AI
+Vertex AI is Google Cloud’s enterprise model platform with IAM and project-level governance.
+
+**Website:** [https://cloud.google.com/vertex-ai](https://cloud.google.com/vertex-ai)
+
+#### Basic Setup
+
+1. Set up a GCP project with Vertex AI enabled.
+2. Configure authentication (service account or application default credentials).
+3. In Cline, select **GCP Vertex AI** and provide required config values.
+
+### Groq
+Groq is a low-latency inference provider for supported model families.
+
+**Website:** [https://groq.com/](https://groq.com/)
+
+#### Basic Setup
+
+1. Sign in to Groq Console.
+2. Create an API key.
+3. In Cline, select **Groq** and paste the key.
+
+### Hicap
+Hicap provides OpenAI-compatible access with multimodal support.
+
+**Website:** [https://hicap.ai](https://hicap.ai)
+
+#### Basic Setup
+
+1. Create your Hicap account.
+2. Generate an API key/token.
+3. In Cline, choose **Hicap** and enter the credential.
+
+### Huawei Cloud MaaS
+Huawei Cloud MaaS provides model-as-a-service access within Huawei Cloud.
+
+**Website:** [https://www.huaweicloud.com/](https://www.huaweicloud.com/)
+
+#### Basic Setup
+
+1. Sign in to Huawei Cloud and open MaaS services.
+2. Create API credentials for model access.
+3. In Cline, select **Huawei Cloud MaaS** and add credentials.
+
+### Hugging Face
+Hugging Face provides hosted inference access for open-source models.
+
+**Website:** [https://huggingface.co/](https://huggingface.co/)
+
+#### Basic Setup
+
+1. Sign in to Hugging Face.
+2. Create an access token with inference permissions.
+3. In Cline, select **Hugging Face** and paste the token.
+
+### Mistral
+Mistral provides direct API access to its model lineup.
+
+**Website:** [https://mistral.ai/](https://mistral.ai/)
+
+#### Basic Setup
+
+1. Create/sign in to Mistral platform account.
+2. Generate an API key.
+3. In Cline, choose **Mistral** and paste the key.
+
+### Moonshot
+Moonshot provides API access to Kimi model families.
+
+**Website:** [https://platform.moonshot.ai/](https://platform.moonshot.ai/)
+
+#### Basic Setup
+
+1. Sign in to Moonshot platform.
+2. Create an API key in account settings.
+3. In Cline, select **Moonshot** and enter the key.
+
+### Nebius AI Studio
+Nebius AI Studio offers managed hosted model APIs.
+
+**Website:** [https://studio.nebius.com/](https://studio.nebius.com/)
+
+#### Basic Setup
+
+1. Create/sign in to Nebius AI Studio.
+2. Generate API credentials.
+3. In Cline, choose **Nebius AI Studio** and provide the credential.
+
+### Nous Research
+Nous Research provides access to Hermes-family model offerings.
+
+**Website:** [https://nousresearch.com/](https://nousresearch.com/)
+
+#### Basic Setup
+
+1. Get provider access/credentials for Nous-hosted endpoints.
+2. Confirm available model IDs for your account.
+3. In Cline, select **NousResearch** and add credentials.
+
+### Oracle Code Assist
+Oracle Code Assist provides AI-powered coding assistance through Oracle Cloud Infrastructure (OCI) Generative AI service.
+
+**Website:** [https://www.oracle.com/application-development/code-assist/](https://www.oracle.com/application-development/code-assist/)
+
+#### Basic Setup
+
+1. **OCI Account:** You need an Oracle Cloud Infrastructure account.
+2. **Enable Generative AI:** Enable the OCI Generative AI service in your tenancy.
+3. **Get Credentials:** Configure OCI authentication (API key, config file, or instance principal).
+
+### Qwen Code
+Qwen Code provides coding-oriented access to Qwen models.
+
+**Website:** [https://chat.qwen.ai/](https://chat.qwen.ai/)
+
+#### Basic Setup
+
+1. Sign in to Qwen platform.
+2. Obtain API access credentials.
+3. In Cline, select **Qwen Code** and enter the credential.
+
+### Requesty
+Requesty provides multi-provider routing behind a single API surface.
+
+**Website:** [https://www.requesty.ai/](https://www.requesty.ai/)
+
+#### Basic Setup
+
+1. Create/sign in to Requesty.
+2. Generate an API key.
+3. In Cline, select **Requesty** and paste the key.
+
+### SambaNova
+SambaNova offers hosted inference and enterprise AI platform capabilities.
+
+**Website:** [https://sambanova.ai/](https://sambanova.ai/)
+
+#### Basic Setup
+
+1. Create/sign in to SambaNova account.
+2. Create an API key/token.
+3. In Cline, choose **SambaNova** and enter credentials.
+
+### SAP AI Core
+SAP AI Core is SAP’s enterprise AI platform for model integration and governance.
+
+**Website:** [https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/what-is-sap-ai-core](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/what-is-sap-ai-core)
+
+#### Basic Setup
+
+1. Set up SAP AI Core / generative AI hub access.
+2. Configure your service key/endpoint credentials.
+3. In Cline, select **SAP AI Core** and provide required values.
+
+### Together
+Together provides hosted inference for many popular open models.
+
+**Website:** [https://together.ai/](https://together.ai/)
+
+#### Basic Setup
+
+1. Create/sign in to Together account.
+2. Generate an API key.
+3. In Cline, choose **Together** and paste the key.
+
+### Vercel AI Gateway
+Vercel AI Gateway gives one API for multiple upstream model providers.
+
+**Website:** [https://vercel.com/](https://vercel.com/)
+
+#### Basic Setup
+
+1. Sign in to Vercel and open AI Gateway.
+2. Create a Gateway API key.
+3. In Cline, select **Vercel AI Gateway** and add the key.
+
+### VS Code Language Model API
+VS Code Language Model API support lets Cline use models exposed by the VS Code host environment.
+
+**Website:** [https://code.visualstudio.com/api/extension-guides/language-model](https://code.visualstudio.com/api/extension-guides/language-model)
+
+#### Basic Setup
+
+1. Use VS Code with LM API-compatible model access configured.
+2. Ensure the language model integration is available in your environment.
+3. In Cline, select **VS Code Language Model API**.
+
+### xAI (Grok)
+xAI provides Grok models through its API platform.
+
+**Website:** [https://x.ai/](https://x.ai/)
+
+#### Basic Setup
+
+1. Sign in to xAI platform.
+2. Generate an API key.
+3. In Cline, choose **xAI (Grok)** and paste the key.
\ No newline at end of file
diff --git a/docs/provider-config/qwen.mdx b/docs/provider-config/qwen.mdx
new file mode 100644
index 0000000..f9456e7
--- /dev/null
+++ b/docs/provider-config/qwen.mdx
@@ -0,0 +1,28 @@
+---
+title: "Alibaba Qwen"
+description: "Learn how to configure and use Alibaba Cloud's Qwen provider with Cline."
+---
+
+**Website:** [https://bailian.console.aliyun.com/](https://bailian.console.aliyun.com/)
+
+### Get API Credentials
+
+1.  **Sign Up/Sign In:** Go to the [Alibaba Cloud Bailian Console](https://bailian.console.aliyun.com/). Create an account or sign in.
+2.  **Navigate to API Keys:** Access the API key management section.
+3.  **Create a Key:** Generate a new API key for your application.
+4.  **Copy the Key:** Copy the API key immediately and store it securely.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "Alibaba Qwen" from the "API Provider" dropdown.
+3.  **Select Region:** Choose "International" or "China" based on your location.
+4.  **Enter API Key:** Paste your Qwen API key into the "Qwen API Key" field.
+5.  **Select Provider Model:** Choose your desired model from the "Model" dropdown.
+
+### Tips and Notes
+
+-   **Vision Support:** VL (Vision-Language) models support image inputs for multimodal tasks.
+-   **Pricing:** Check the [Alibaba Cloud Bailian Console](https://bailian.console.aliyun.com/) for current pricing.
diff --git a/docs/provider-config/zai.mdx b/docs/provider-config/zai.mdx
new file mode 100644
index 0000000..bfeb9da
--- /dev/null
+++ b/docs/provider-config/zai.mdx
@@ -0,0 +1,65 @@
+---
+title: "Z AI (Zhipu AI)"
+description: "Learn how to configure and use Z AI's GLM models with Cline. Experience advanced hybrid reasoning, agentic capabilities, and open-source excellence with regional optimization."
+---
+
+Z AI (formerly Zhipu AI) offers the GLM model series, featuring hybrid reasoning capabilities and agentic AI design. These models excel in unified reasoning, coding, and intelligent agent applications while maintaining open-source accessibility under MIT license.
+
+**Website:** [https://z.ai/model-api](https://z.ai/model-api) (International) | [https://open.bigmodel.cn/](https://open.bigmodel.cn/) (China)
+
+### Getting an API Key
+
+#### International Users
+1.  **Sign Up/Sign In:** Go to [https://z.ai/model-api](https://z.ai/model-api). Create an account or sign in.
+2.  **Navigate to API Keys:** Access your account dashboard and find the API keys section.
+3.  **Create a Key:** Generate a new API key for your application.
+4.  **Copy the Key:** Copy the API key immediately and store it securely.
+
+#### China Mainland Users
+1.  **Sign Up/Sign In:** Go to [https://open.bigmodel.cn/](https://open.bigmodel.cn/). Create an account or sign in.
+2.  **Navigate to API Keys:** Access your account dashboard and find the API keys section.
+3.  **Create a Key:** Generate a new API key for your application.
+4.  **Copy the Key:** Copy the API key immediately and store it securely.
+
+**Note:** Pricing differs between International and China regions. China region pricing is approximately 50% lower.
+
+### Configuration in Cline
+
+> See [Authorization & Model Selection](/getting-started/authorizing-with-cline#menu).
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "Z AI" from the "API Provider" dropdown.
+3.  **Select Region:** Choose your region:
+    -   "International" for global access
+    -   "China" for mainland China access
+4.  **Enter API Key:** Paste your Z AI API key into the "Z AI API Key" field.
+5.  **Select Model:** Choose your desired model from the "Model" dropdown.
+
+### GLM Coding Plans
+
+Z AI offers subscription plans specifically designed for coding applications. These plans provide cost-effective access to GLM series models through a prompt-based structure rather than traditional API usage billing.
+
+#### Setting up GLM Coding Plans
+
+To use the GLM Coding Plans with Cline:
+
+1. **Subscribe:** Go to [https://z.ai/subscribe](https://z.ai/subscribe) and choose your plan.
+
+2. **Create API Key:** After subscribing, log into your zAI dashboard and create an API key for your coding plan.
+
+3. **Configure in Cline:** Open Cline settings, select "Z AI" as your provider, and paste your API key into the "Z AI API Key" field.
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/docs/assets/zAI-provider.png" alt="Cline settings with zAI provider selected and API key field highlighted" />
+</Frame>
+
+The setup connects your subscription directly to Cline, giving you access to GLM-4.5's tool-calling capabilities optimized for coding workflows.
+
+### Regional Optimization
+
+#### API Endpoints
+- **International:** Uses `https://api.z.ai/api/paas/v4`
+- **China:** Uses `https://open.bigmodel.cn/api/paas/v4`
+
+#### Model Availability
+The region setting determines both API endpoint and available models, with automatic filtering to ensure compatibility with your selected region.
diff --git a/docs/running-models-locally/overview.mdx b/docs/running-models-locally/overview.mdx
new file mode 100644
index 0000000..d6b6fbf
--- /dev/null
+++ b/docs/running-models-locally/overview.mdx
@@ -0,0 +1,114 @@
+---
+title: "Local models"
+sidebarTitle: "Local models"
+description: "Run Cline with local models using Ollama, LM Studio or Atomic Chat."
+---
+
+Run Cline with local inference on your machine.
+
+## Quick Start
+
+1. Install a local runtime (**Ollama**, **LM Studio** or **Atomic Chat**)
+2. Start the local server
+3. In Cline Settings, select the matching provider
+4. Select a local model
+5. Enable **Use Compact Prompt** in Cline Settings → Features
+
+## Hardware Requirements
+
+| RAM | Typical local setup |
+| --- | --- |
+| 16-32GB | Small/quantized models |
+| 32-64GB | Mid-size coding models |
+| 64GB+ | Larger models and bigger context windows |
+
+## Runtime Options
+
+<Tabs>
+  <Tab title="Ollama">
+    ### 1) Install
+    - Download from [ollama.com](https://ollama.com)
+    - Install for your OS
+
+    ### 2) Find popular local models
+    - Browse the Ollama model catalog: [ollama.com/search](https://ollama.com/search)
+    - Sort/filter by popularity, model size, and latest updates
+    - Open any model page and copy the `ollama pull` command
+
+    ### 3) Pull and run a model
+    ```bash
+    ollama pull <model-name>
+    ollama run <model-name>
+    ```
+
+    ### 4) Configure Cline
+    1. Open Cline Settings
+    2. Select provider: **Ollama**
+    3. Base URL: `http://localhost:11434`
+    4. Select your model from the dropdown
+
+    ### 5) Troubleshooting
+    - Make sure Ollama is running before sending prompts
+    - If connection fails, verify `http://localhost:11434`
+    - If model is missing, run `ollama pull <model-name>`
+  </Tab>
+
+  <Tab title="LM Studio">
+    ### 1) Install
+    - Download from [lmstudio.ai](https://lmstudio.ai)
+    - Install and launch the app
+
+    ### 2) Find local models
+    - Browse the LM Studio model catalog: [lmstudio.ai/models](https://lmstudio.ai/models)
+    - Filter by model family, size, and capabilities
+    - Pick a model that matches your hardware
+
+    ### 3) Download a model
+    - Open **Discover** and download a model
+
+    ### 4) Start server
+    - Open **Developer** tab
+    - Start server (default: `http://localhost:1234`)
+
+    ### 5) Configure Cline
+    1. Open Cline Settings
+    2. Select provider: **LM Studio**
+    3. Keep Base URL as `http://localhost:1234`
+    4. Select your model from the dropdown
+
+    ### 6) Troubleshooting
+    - Ensure LM Studio server is running
+    - Ensure a model is loaded
+    - If connection fails, verify `http://localhost:1234`
+  </Tab>
+
+  <Tab title="Atomic Chat">
+    ### 1) Install
+    - Download from [atomic.chat](https://atomic.chat) (macOS Apple Silicon)
+    - Or build from [AtomicBot-ai/Atomic-Chat](https://github.com/AtomicBot-ai/Atomic-Chat)
+
+    ### 2) Load a model
+    - Open Atomic Chat and download or load a local model from the catalog
+
+    ### 3) Start the local API
+    - Atomic Chat exposes an OpenAI-compatible server at `http://127.0.0.1:1337/v1` by default
+    - List loaded models: `curl http://127.0.0.1:1337/v1/models`
+
+    ### 4) Configure Cline
+    1. Open Cline Settings
+    2. Select provider: **Atomic Chat**
+    3. Base URL: `http://127.0.0.1:1337/v1` (default)
+    4. Select your model from the dropdown
+
+    ### 5) Troubleshooting
+    - Make sure Atomic Chat is running before sending prompts
+    - If connection fails, verify `http://127.0.0.1:1337/v1/models`
+    - If the model list is empty, load a model in Atomic Chat first
+  </Tab>
+</Tabs>
+
+## Recommended Cline Settings for Local Inference
+
+- Enable **Use Compact Prompt**
+- Keep tasks focused (smaller context = faster responses)
+- Start a new task when context gets too large
diff --git a/docs/sdk/architecture/hub-spoke.mdx b/docs/sdk/architecture/hub-spoke.mdx
new file mode 100644
index 0000000..b825b79
--- /dev/null
+++ b/docs/sdk/architecture/hub-spoke.mdx
@@ -0,0 +1,146 @@
+---
+title: "Hub-Spoke Architecture"
+sidebarTitle: "Hub & Spoke"
+description: "A local daemon coordinates sessions across clients, while spoke workers handle agent execution."
+---
+
+The SDK uses a hub-spoke architecture for production deployments. A background daemon (the hub) coordinates session state and event routing, spoke workers execute the agent loop, and clients (CLI, VS Code, JetBrains, etc.) attach as peers over WebSocket.
+
+## Why Hub-Spoke?
+
+A single-process architecture works for simple scripts, but breaks down when you need:
+
+- Sessions that survive when a window closes or the CLI exits
+- Multiple clients viewing and controlling the same session
+- Scheduled agents that run when no client is connected
+- Process isolation so a runaway agent doesn't freeze the UI
+
+The hub-spoke model solves all of these by separating coordination from execution, and both from the client UI.
+
+## Three Roles
+
+<CardGroup cols={3}>
+  <Card title="Hub" icon="circle-nodes">
+    Singleton daemon per machine. Coordinates sessions, routes events and approvals, manages schedules, brokers capabilities between clients. Does not run the agent loop.
+  </Card>
+  <Card title="Spoke" icon="gear">
+    Worker process running `@cline/core`. Executes the agent loop, calls tools, streams output. Reports events back to the hub. Owned by the daemon, not by any client.
+  </Card>
+  <Card title="Client" icon="display">
+    CLI, VS Code, JetBrains, or any custom app. Discovers the hub, registers over WebSocket, attaches to sessions, sends user input, receives streamed events.
+  </Card>
+</CardGroup>
+
+The single rule that keeps it clean: clients participate, spokes execute, the hub coordinates. No two roles should overlap.
+
+## Communication Flow
+
+Clients connect to the hub over WebSocket. The hub routes commands and streams events. Spokes report back to the hub, never directly to clients.
+
+<Steps>
+  <Step title="Client discovers or starts the hub">
+    The hub is a singleton daemon per machine. If one isn't running, `ClineCore` starts it automatically. Discovery uses lock files at `~/.cline/locks/hub/owners/`.
+  </Step>
+  <Step title="Client registers and attaches to a session">
+    The client sends a `client.register` command over WebSocket, advertising its capabilities (shell access, file editing, diff viewing, etc.). It then creates or attaches to a session.
+  </Step>
+  <Step title="Hub assigns a spoke to execute">
+    The hub spawns or assigns a spoke worker to run the agent loop. The spoke executes tools, streams partial output, and handles abort/cancel.
+  </Step>
+  <Step title="Hub fans out events to all attached clients">
+    As the spoke produces events (text deltas, tool calls, usage), the hub relays them to every client attached to that session. Clients can come and go without interrupting execution.
+  </Step>
+  <Step title="Client disconnects, session keeps running">
+    If the CLI exits or a window closes, the spoke continues executing. Another client can attach to the same session and pick up the event stream mid-flight.
+  </Step>
+</Steps>
+
+## Backend Modes
+
+`ClineCore` selects the execution mode based on configuration:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  backendMode: "auto",
+})
+```
+
+| Mode | Behavior |
+|------|----------|
+| `auto` | Prefers a compatible local hub when available, falls back to local in-process execution when not. This is the default. |
+| `hub` | Requires a compatible WebSocket hub. Throws if one is not reachable. |
+| `remote` | Requires an explicit remote WebSocket hub endpoint. For deployments where the hub doesn't live on the user's machine. |
+| `local` | Always uses local in-process execution with local SQLite/file storage. No hub, no shared sessions. |
+
+### When to Use Each Mode
+
+Use `local` for:
+- Simple scripts and one-off tasks
+- Testing and development
+- Environments where a background process isn't appropriate
+
+Use `hub` (or `auto`) for:
+- Session persistence across client restarts
+- Multiple clients sharing the same session
+- Scheduled agents
+- Connector integrations (Telegram, Slack, etc.)
+
+Use `remote` for:
+- Cloud deployments where the hub runs on a server
+- Team-shared hub instances
+
+## Capability Brokerage
+
+When multiple clients are attached to a session, the hub routes capability requests to whichever client can handle them. Clients advertise their capabilities at registration.
+
+For example, VS Code might register `open-file`, `reveal-diff`, and `run-build` capabilities. The CLI might register `shell` and `run-tests`. When the agent needs to open a diff, the hub routes the request to VS Code. When it needs to run a shell command, the hub routes to the CLI.
+
+This means a session gets richer as more clients join. A CLI session can later be enriched by VS Code attaching -- an IDE selection can be sent into a running terminal session, or a diff created by one client can be opened by another.
+
+## Session Persistence
+
+Sessions are stored with full conversation history, tool call records, and metadata. The hub maintains a SQLite index for efficient listing and JSON snapshots as the source of truth for each session's state.
+
+```
+~/.cline/data/sessions/
+  sessions.db                    # SQLite index
+  [session-id].json              # Authoritative session record
+```
+
+Sessions can have multiple participants, each tracked with a role (`creator`, `participant`, `observer`). The session persists independently of any single client's lifecycle.
+
+## Managing the Hub
+
+The hub starts automatically when `ClineCore` needs it. You can also manage it manually:
+
+```bash
+cline hub start      # Start the hub daemon
+cline hub stop       # Stop it
+cline hub status     # Check if running
+cline hub ensure     # Start if not running, return URL
+```
+
+The hub listens on `127.0.0.1:25463` by default and logs to `~/.cline/logs/hub-daemon.log`.
+
+## Multi-Client Access
+
+Multiple clients can connect to the same hub and attach to the same session simultaneously:
+
+```bash
+# Terminal 1: start a task
+cline "Work on feature X"
+
+# Terminal 2: attach to the same session from VS Code or another CLI
+
+# Terminal 3: Telegram connector
+cline connect telegram -k $TOKEN
+
+# All three share the same hub and can access the same sessions
+```
+
+## Process Isolation
+
+If a client crashes, the hub and its running spokes are unaffected. The session continues executing in the spoke worker. When the client reconnects (or a different client attaches), it receives the full session history and resumes the live event stream.
+
+The spoke also has a process boundary from the hub itself. A runaway model call in a spoke doesn't degrade the hub's ability to coordinate other sessions, route approvals, or fan out events.
diff --git a/docs/sdk/architecture/overview.mdx b/docs/sdk/architecture/overview.mdx
new file mode 100644
index 0000000..c102352
--- /dev/null
+++ b/docs/sdk/architecture/overview.mdx
@@ -0,0 +1,133 @@
+---
+title: "Packages"
+sidebarTitle: "Packages"
+description: "How SDK packages fit together, what each package exports, and where boundaries are enforced."
+---
+
+The SDK is split into layered packages. Dependencies flow downward: `core` depends on `agents`, `llms`, and `shared`; `agents` depends on `llms` and `shared`; `llms` depends on `shared`.
+
+## Package Stack
+
+```txt
+Your application / CLI / VS Code / JetBrains
+          │
+          ▼
+@cline/core
+Sessions, storage, built-in tools, hub, automation, telemetry
+          │
+          ├── @cline/agents
+          │   Browser-compatible AgentRuntime / Agent loop
+          │
+          ├── @cline/llms
+          │   Provider handlers, gateway, model catalogs
+          │
+          └── @cline/shared
+              Types, schemas, tools, hooks, extension contracts
+```
+
+## Packages
+
+### @cline/core
+
+Node runtime/orchestration layer.
+
+Key exports include:
+
+| Export | Description |
+|--------|-------------|
+| `ClineCore` | Main runtime entry point |
+| `ClineCoreOptions` | Constructor options |
+| `ClineCoreStartInput` | Session start input |
+| `CoreSessionConfig` | Session configuration |
+| `SessionRecord` | Persisted session metadata |
+| `AgentPlugin` | Public plugin type |
+| `createTool` | Re-export from shared |
+
+Capabilities include:
+
+- local/hub/remote runtime backends
+- session manifests and message artifacts
+- built-in tools
+- tool approvals
+- automation/scheduling services
+- telemetry hooks
+- plugin/extension loading
+- team/sub-agent tools
+
+Depends on: `@cline/shared`, `@cline/llms`, `@cline/agents`.
+
+### @cline/agents
+
+Browser-compatible agent execution loop.
+
+Key exports include:
+
+| Export | Description |
+|--------|-------------|
+| `AgentRuntime` | Core runtime class |
+| `Agent` | Alias for `AgentRuntime` |
+| `createAgentRuntime`, `createAgent` | Factory functions |
+| `AgentRuntimeConfig` | Constructor config union |
+| `AgentRunInput`, `AgentEventListener` | Runtime helper types |
+| `createTool` | Re-export from `@cline/shared` |
+
+Methods on `AgentRuntime` include `run`, `continue`, `abort`, `subscribe`, `restore`, and `snapshot`.
+
+Depends on: `@cline/shared`, `@cline/llms`.
+
+### @cline/llms
+
+Provider and model layer.
+
+Key exports include:
+
+| Export | Description |
+|--------|-------------|
+| `DefaultGateway`, `createGateway` | Gateway for creating provider-backed agent models |
+| `createHandler`, `createHandlerAsync` | Provider handler factories |
+| `getAllProviders`, `getProviderIds`, `getModelsForProvider` | Catalog helpers |
+| `registerProvider`, `registerModel` | Runtime registry extension |
+| `ModelInfo`, `ProviderInfo` | Provider/model metadata |
+
+Depends on: `@cline/shared`.
+
+### @cline/shared
+
+Foundation package for shared contracts and utilities.
+
+Key exports include:
+
+| Export | Description |
+|--------|-------------|
+| `createTool` | Helper for creating typed tools |
+| `AgentTool`, `AgentToolContext`, `ToolPolicy` | Tool interfaces |
+| `AgentEvent`, `AgentResult`, `AgentConfig` | Host-facing agent types |
+| `AgentRuntimeEvent`, `AgentRunResult` | Runtime-facing agent types |
+| `HookEngine`, `HookStage`, `HookPolicies` | Hook contracts and engine |
+| `ContributionRegistry`, `AgentExtensionApi` | Extension registration contracts |
+| `ModelInfo`, `Message`, `ContentBlock` | Model/message types |
+| `BasicLogger`, `noopBasicLogger` | Logging contracts |
+
+No higher-layer dependencies.
+
+## Install
+
+```bash
+npm install @cline/sdk
+```
+
+`@cline/sdk` re-exports everything from `@cline/core`. Install `@cline/agents` or `@cline/llms` directly only if you need lower-level control.
+
+## Design Principles
+
+### Strict dependency direction
+
+Dependencies flow downward only. Lower layers stay embeddable without pulling in the full runtime.
+
+### Browser-compatible agent loop
+
+`@cline/agents` exposes a browser-compatible runtime. It does not own session storage, built-in file/shell tools, hub transports, or Node-specific orchestration.
+
+### Core as orchestration layer
+
+`@cline/core` owns Node runtime integration: session persistence, built-in tools, automation, hub/remote transports, telemetry, and extension loading.
diff --git a/docs/sdk/clinecore.mdx b/docs/sdk/clinecore.mdx
new file mode 100644
index 0000000..7d3baef
--- /dev/null
+++ b/docs/sdk/clinecore.mdx
@@ -0,0 +1,205 @@
+---
+title: "ClineCore"
+sidebarTitle: "ClineCore"
+description: "The full Cline harness: built-in tools, sessions, approvals, scheduling, and hub support."
+---
+
+`ClineCore` is the full Cline harness as a programmable runtime. It gives you everything Cline ships out of the box: built-in tools for files, shell, search, and web; session persistence and message history; tool approval callbacks; local, hub, and remote backends; scheduling and automation APIs; and plugin support.
+
+Under the hood, `ClineCore` uses the `Agent` class from `@cline/agents`. You can use `Agent` directly if you want to skip the harness and wire everything yourself: your own tools, your own persistence, your own lifecycle.
+
+## When to use which
+
+| Need | Use |
+|------|-----|
+| Sessions, persistence, message history | `ClineCore` |
+| Built-in tools for files, shell, search, web fetch | `ClineCore` |
+| Hub/remote runtime | `ClineCore` |
+| Scheduling or event automation | `ClineCore` |
+| Multi-agent teams | `ClineCore` |
+| Browser-compatible or lightweight in-process agent | `Agent` |
+| Custom tools only, no built-ins | `Agent` |
+| Full control over persistence and lifecycle | `Agent` |
+
+## ClineCore
+
+`ClineCore` wraps runtime execution with application features:
+
+- session manifests and message artifacts
+- built-in tools
+- tool approval callbacks
+- local, hub, and remote backends
+- automation/scheduling APIs
+- optional plugin paths and extensions
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  backendMode: "auto",
+})
+
+const session = await cline.start({
+  prompt: "Set up GitHub Actions for this repo",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    systemPrompt: "You are a helpful coding assistant.",
+    cwd: "/path/to/project",
+    workspaceRoot: "/path/to/project",
+    enableTools: true,
+    enableSpawnAgent: false,
+    enableAgentTeams: false,
+  },
+})
+
+console.log(session.sessionId)
+console.log(session.result?.finishReason)
+```
+
+### Methods
+
+| Method | Purpose |
+|--------|---------|
+| `ClineCore.create(options)` | Create the runtime |
+| `start(input)` | Start a session |
+| `send({ sessionId, prompt })` | Send a follow-up message |
+| `subscribe(listener, options?)` | Listen to session events |
+| `list(limit?, options?)` | List sessions with history metadata |
+| `get(sessionId)` | Read session metadata |
+| `readMessages(sessionId)` | Read session messages |
+| `getAccumulatedUsage(sessionId)` | Read session token/cost totals |
+| `abort(sessionId, reason?)` | Abort current work |
+| `stop(sessionId)` | Stop a session |
+| `delete(sessionId)` | Delete a session |
+| `dispose(reason?)` | Clean up runtime resources |
+
+See [ClineCore reference](/sdk/reference/cline-core) for exact signatures.
+
+## Backend Modes
+
+| Mode | Behavior |
+|------|----------|
+| `auto` | Prefer a compatible local hub, otherwise use local execution |
+| `hub` | Require a compatible WebSocket hub |
+| `remote` | Connect to a configured remote hub |
+| `local` | Always use local in-process execution and local storage |
+
+For process topology, see [Hub & Spoke](/sdk/architecture/hub-spoke).
+
+## Session Artifacts
+
+`ClineCore` stores session manifests and messages as files. A session result includes:
+
+| Field | Meaning |
+|-------|---------|
+| `sessionId` | Session identifier |
+| `manifest` | Parsed session manifest |
+| `manifestPath` | Path to the session manifest JSON |
+| `messagesPath` | Path to persisted message JSON |
+| `result` | Final `AgentResult`, when available |
+
+## Tool Approval
+
+Use tool policies for simple cases:
+
+```typescript
+await cline.start({
+  prompt: "Audit this repo",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    systemPrompt: "You are a helpful coding assistant.",
+    cwd: process.cwd(),
+    workspaceRoot: process.cwd(),
+    enableTools: true,
+    enableSpawnAgent: false,
+    enableAgentTeams: false,
+  },
+  toolPolicies: {
+    read_files: { autoApprove: true },
+    search_codebase: { autoApprove: true },
+    run_commands: { autoApprove: false },
+    editor: { autoApprove: false },
+  },
+})
+```
+
+Use `requestToolApproval` when your application needs to decide dynamically:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  capabilities: {
+    requestToolApproval: async (request) => {
+      return { approved: request.toolName !== "run_commands" }
+    },
+  },
+})
+```
+
+For tool behavior and policies, see [Tools](/sdk/tools).
+
+## Using Agent directly
+
+`Agent` (also exported as `AgentRuntime`) is the stateless primitive that `ClineCore` builds on. Use it directly when you want full control or don't need the harness.
+
+`Agent` is an alias for `AgentRuntime`. Use `Agent` when constructing from provider/model IDs. Use `AgentRuntime` when supplying a pre-built `AgentModel`.
+
+`Agent` runs the core loop:
+
+```txt
+run() or continue()
+  -> model request
+  -> tool calls, if any
+  -> tool results
+  -> repeat until complete
+```
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  systemPrompt: "You are a helpful coding assistant.",
+  tools: [myTool],
+})
+
+agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text ?? "")
+  }
+})
+
+const result = await agent.run("Review this diff")
+console.log(result.outputText)
+```
+
+### Agent Methods
+
+| Method | Purpose |
+|--------|---------|
+| `run(input)` | Start a run with user input |
+| `continue(input?)` | Continue with optional new input |
+| `abort(reason?)` | Abort the active run |
+| `subscribe(listener)` | Listen to `AgentRuntimeEvent` events |
+| `restore(messages)` | Replace conversation history |
+| `snapshot()` | Read runtime state |
+
+See [Agent reference](/sdk/reference/agent) for exact signatures.
+
+### Multi-Turn Conversations
+
+`AgentRuntime` keeps message state internally. Use `continue()` after the first run:
+
+```typescript
+await agent.run("What does this project do?")
+await agent.continue("Now identify risky files")
+```
+
+If you persist messages externally, restore them with `restore(messages)` before continuing.
diff --git a/docs/sdk/events.mdx b/docs/sdk/events.mdx
new file mode 100644
index 0000000..1f2904b
--- /dev/null
+++ b/docs/sdk/events.mdx
@@ -0,0 +1,106 @@
+---
+title: "Events"
+sidebarTitle: "Events"
+description: "Subscribe to runtime and session events for UIs, logs, monitoring, and cancellation."
+---
+
+The SDK exposes two related event surfaces:
+
+- `AgentRuntimeEvent` from `@cline/agents`, delivered through `agent.subscribe(listener)`.
+- `AgentEvent` / `CoreSessionEvent` from `@cline/core`, delivered through core session adapters and `cline.subscribe(listener)`.
+
+Use this page for event handling patterns. For event shapes, see [Events reference](/sdk/reference/events).
+
+## AgentRuntime Events
+
+```typescript
+const unsubscribe = agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text ?? "")
+  }
+})
+
+await agent.run("Explain this codebase")
+unsubscribe()
+```
+
+`AgentRuntimeEvent` is the low-level event stream from the browser-compatible runtime.
+
+## Core / Host-Facing Agent Events
+
+`AgentEvent` is the host-facing event shape used by `@cline/core` session orchestration. For direct `Agent` usage, prefer `agent.subscribe(...)` and `AgentRuntimeEvent`.
+
+Common host-facing event categories:
+
+| Category | Events | Use for |
+|----------|--------|---------|
+| Content | `content_start`, `content_update`, `content_end` | Text/reasoning/tool UI |
+| Iterations | `iteration_start`, `iteration_end` | Progress tracking |
+| Usage | `usage` | Token/cost tracking |
+| Notices | `notice` | Recovery and status updates |
+| Completion | `done`, `error` | Final state and failure handling |
+
+## ClineCore Session Events
+
+Use `cline.subscribe()` for session-level events:
+
+```typescript
+const unsubscribe = cline.subscribe((event) => {
+  console.log(event.type, event.sessionId)
+})
+
+await cline.start({ /* ... */ })
+unsubscribe()
+```
+
+Pass a `sessionId` filter when you only want one session:
+
+```typescript
+const unsubscribe = cline.subscribe(listener, { sessionId })
+```
+
+## Streaming UI Pattern
+
+Subscribe to events to build real-time UIs:
+
+```typescript
+agent.subscribe((event) => {
+  switch (event.type) {
+    case "assistant-text-delta":
+      onUpdate({ type: "text", content: event.text ?? "" })
+      break
+    case "tool-started":
+      onUpdate({ type: "tool_start", content: event.toolCall.toolName })
+      break
+    case "tool-finished":
+      onUpdate({ type: "tool_end", content: event.toolCall.toolName })
+      break
+    case "run-finished":
+      onUpdate({ type: "done", content: event.result.status })
+      break
+  }
+})
+```
+
+For a complete working example of streaming agent events to a browser via SSE, see the [multi-agent example](https://github.com/cline/cline/tree/main/apps/examples/multi-agent). It spawns multiple agents in parallel and streams each agent's events to separate UI cards.
+
+## Usage Tracking Pattern
+
+```typescript
+let totalTokens = 0
+
+agent.subscribe((event) => {
+  if (event.type === "usage-updated") {
+    totalTokens = event.usage.inputTokens + event.usage.outputTokens
+  }
+})
+```
+
+## Runtime State Snapshots
+
+Call `snapshot()` when you need the current state:
+
+```typescript
+const snapshot = agent.snapshot()
+console.log(snapshot.status, snapshot.iteration, snapshot.usage)
+```
diff --git a/docs/sdk/examples.mdx b/docs/sdk/examples.mdx
new file mode 100644
index 0000000..23d9fa3
--- /dev/null
+++ b/docs/sdk/examples.mdx
@@ -0,0 +1,15 @@
+---
+title: "Examples"
+sidebarTitle: "Examples"
+description: "Explore complete, runnable SDK examples organized by difficulty."
+---
+
+Working examples are available in the [SDK repository](https://github.com/cline/cline/tree/main/apps/examples), organized by difficulty:
+
+| Example | Difficulty | Description |
+|---------|------------|-------------|
+| [quickstart](https://github.com/cline/cline/tree/main/apps/examples/quickstart) | Beginner | Send one prompt, stream the response (~15 lines) |
+| [cli-agent](https://github.com/cline/cline/tree/main/apps/examples/cli-agent) | Beginner | Interactive terminal chat with a shell tool |
+| [code-review-bot](https://github.com/cline/cline/tree/main/apps/examples/code-review-bot) | Intermediate | AI code reviewer with custom tools and structured output |
+| [multi-agent](https://github.com/cline/cline/tree/main/apps/examples/multi-agent) | Advanced | Parallel agents with streaming web UI |
+| [desktop-app](https://github.com/cline/cline/tree/main/apps/examples/desktop-app) | Advanced | Full Tauri + Next.js desktop app |
diff --git a/docs/sdk/guides/building-an-agent.mdx b/docs/sdk/guides/building-an-agent.mdx
new file mode 100644
index 0000000..4d7702f
--- /dev/null
+++ b/docs/sdk/guides/building-an-agent.mdx
@@ -0,0 +1,164 @@
+---
+title: "Building an Agent"
+sidebarTitle: "Building an Agent"
+description: "Walk through a complete code review bot that reads diffs, analyzes code, and produces structured feedback."
+---
+
+This tutorial walks through the [code-review-bot example](https://github.com/cline/cline/tree/main/apps/examples/code-review-bot) from the SDK repository. By the end, you'll understand how to combine custom tools, system prompts, completion lifecycle, and event streaming into a real application.
+
+## What It Builds
+
+A code review agent that:
+1. Reads a git diff from the local repo
+2. Optionally reads full file contents for context
+3. Produces structured review comments with severity levels
+4. Ends the run with a summary and approve/reject decision
+
+## Prerequisites
+
+- Node.js 22+
+- An Anthropic API key
+- A git repository with at least one commit
+
+## Get the Code
+
+```bash
+git clone https://github.com/cline/cline.git
+cd cline/apps/examples/code-review-bot
+bun install
+```
+
+Or read along with the [source on GitHub](https://github.com/cline/cline/blob/main/apps/examples/code-review-bot/src/index.ts).
+
+## How It Works
+
+### Defining Tools with Zod Schemas
+
+The bot uses `createTool` with zod schemas for type-safe tool definitions. Here's the review comment tool:
+
+```typescript
+createTool({
+  name: "add_review_comment",
+  description: "Add a review comment on a specific file and line.",
+  inputSchema: z.object({
+    file: z.string().describe("File path"),
+    line: z.number().describe("Line number (approximate is fine)"),
+    severity: z.enum(["critical", "warning", "suggestion"]),
+    comment: z.string().describe("The review comment"),
+  }),
+  async execute(input) {
+    reviews.push(input)
+    return `Comment added (${reviews.length} total)`
+  },
+})
+```
+
+Key points:
+- `z.enum` constrains severity to valid values, which improves model accuracy
+- `.describe()` on each field tells the model what to provide
+- The tool accumulates results in an array for post-run processing
+
+### Completion Tools
+
+The `submit_review` tool uses `lifecycle: { completesRun: true }` to signal that the agent's work is done:
+
+```typescript
+createTool({
+  name: "submit_review",
+  description: "Submit the completed review with a summary.",
+  inputSchema: z.object({
+    summary: z.string().describe("Brief overall assessment of the changes"),
+    approve: z.boolean().describe("Whether the changes look good to merge"),
+  }),
+  lifecycle: { completesRun: true },
+  async execute(input) {
+    return JSON.stringify({ summary: input.summary, approve: input.approve })
+  },
+})
+```
+
+Without this, the agent would keep looping until `maxIterations`. With it, the agent calls `submit_review` when it's done and the run ends cleanly.
+
+### System Prompt
+
+The system prompt gives the agent a structured workflow to follow:
+
+```typescript
+const agent = new Agent({
+  systemPrompt: `You are a senior code reviewer. Analyze the git diff provided and leave review comments using the add_review_comment tool. Focus on:
+- Bugs and logic errors (critical)
+- Security issues (critical)
+- Performance problems (warning)
+- Style and readability improvements (suggestion)
+
+When you are done reviewing, call submit_review with a brief summary.`,
+  // ...
+})
+```
+
+Telling the agent exactly which tools to use and when keeps the workflow predictable.
+
+### Event Streaming
+
+The bot subscribes to events to show progress as the agent works:
+
+```typescript
+agent.subscribe((event) => {
+  switch (event.type) {
+    case "assistant-text-delta":
+      process.stdout.write(event.text ?? "")
+      break
+    case "tool-started":
+      if (event.toolCall.toolName === "add_review_comment") {
+        const input = event.toolCall.input
+        console.log(`  [${input.severity}] ${input.file}:${input.line} - ${input.comment}`)
+      }
+      break
+  }
+})
+```
+
+This prints review comments as they're made, so you see results streaming rather than waiting for the full run to finish.
+
+### Post-Run Processing
+
+After the run, the bot groups comments by severity and prints a summary:
+
+```typescript
+const result = await agent.run(`Review this git diff:\n\n\`\`\`diff\n${diff}\n\`\`\``)
+
+const critical = reviews.filter((r) => r.severity === "critical")
+const warnings = reviews.filter((r) => r.severity === "warning")
+const suggestions = reviews.filter((r) => r.severity === "suggestion")
+```
+
+The tool calls accumulate structured data during the run, and the application processes it after. This pattern is useful any time you want the agent to produce structured output.
+
+## Run It
+
+```bash
+ANTHROPIC_API_KEY=sk-ant-... bun dev        # review last commit
+ANTHROPIC_API_KEY=sk-ant-... bun dev main   # review against main
+```
+
+## Extending Further
+
+From here, you could:
+
+- Add a tool that posts review comments back to GitHub via the API
+- Use `continue()` for follow-up questions about specific findings
+- Add a `checkstyle` tool that runs linters on the changed files
+- Connect it to a webhook for automatic PR reviews
+
+## More Examples
+
+<CardGroup cols={2}>
+  <Card title="CLI Agent" icon="terminal" href="https://github.com/cline/cline/tree/main/apps/examples/cli-agent">
+    Interactive terminal chat with tools and multi-turn conversation.
+  </Card>
+  <Card title="Multi-Agent" icon="users" href="https://github.com/cline/cline/tree/main/apps/examples/multi-agent">
+    Parallel agents streaming to a web UI.
+  </Card>
+</CardGroup>
+
+See [Creating Custom Tools](/sdk/guides/creating-custom-tools) and [Writing Plugins](/sdk/guides/writing-plugins) for more on extending agent capabilities.
diff --git a/docs/sdk/guides/creating-custom-tools.mdx b/docs/sdk/guides/creating-custom-tools.mdx
new file mode 100644
index 0000000..ddc5517
--- /dev/null
+++ b/docs/sdk/guides/creating-custom-tools.mdx
@@ -0,0 +1,242 @@
+---
+title: "Creating Custom Tools"
+sidebarTitle: "Creating Custom Tools"
+description: "Define, register, and test your own tools with type-safe schemas and execution handlers."
+---
+
+Custom tools extend what your agent can do. A tool is a function with a name, a description the LLM reads, a schema for inputs, and an execute function that does the actual work.
+
+## Basic Tool
+
+Use `createTool` with a zod schema for the simplest approach:
+
+```typescript
+import { createTool } from "@cline/sdk"
+import { z } from "zod"
+
+const getCurrentTime = createTool({
+  name: "get_current_time",
+  description: "Get the current date and time. Optionally specify a timezone.",
+  inputSchema: z.object({
+    timezone: z.string().optional().describe("IANA timezone (e.g., 'America/New_York'). Defaults to UTC."),
+  }),
+  async execute(input) {
+    const tz = input.timezone ?? "UTC"
+    const date = new Date()
+    return {
+      iso: date.toISOString(),
+      timezone: tz,
+      formatted: date.toLocaleString("en-US", { timeZone: tz }),
+    }
+  },
+})
+```
+
+The SDK converts the zod schema to JSON Schema automatically. Input is fully typed in the `execute` function.
+
+For working examples of tools in real agents, see the [cli-agent](https://github.com/cline/cline/tree/main/apps/examples/cli-agent) (shell tool with zod) and [code-review-bot](https://github.com/cline/cline/tree/main/apps/examples/code-review-bot) (multiple tools with completion lifecycle).
+
+## Anatomy of a Tool
+
+Every tool has four parts:
+
+| Field | Purpose |
+|-------|---------|
+| `name` | Unique identifier (snake_case recommended) |
+| `description` | LLM reads this to decide when to use the tool |
+| `inputSchema` | Zod schema or JSON Schema defining accepted arguments |
+| `execute` | Function that does the work |
+
+### The Name
+
+Use `snake_case`. Keep it descriptive but concise:
+
+- `search_database`, not `db` or `performDatabaseSearchOperation`
+- `send_email`, not `email` or `handleEmailSending`
+
+### The Description
+
+This is the most important field for tool call accuracy. The LLM uses it to decide when and how to use the tool.
+
+```typescript
+// Weak: model won't know when to use this
+description: "Handles data."
+
+// Strong: model knows exactly what this does and when to use it
+description: "Search the PostgreSQL database by executing a read-only SQL query. Returns matching rows as JSON. Use this when you need to look up user records, order history, or product data. Maximum 100 rows per query."
+```
+
+Include:
+- What the tool does
+- What it returns
+- When to use it (and when not to)
+- Constraints (rate limits, read-only, max results, etc.)
+
+### The Input Schema
+
+With zod, use `.describe()` on every field:
+
+```typescript
+inputSchema: z.object({
+  query: z.string().describe("Search query. Supports wildcards (*) and exact phrases."),
+  limit: z.number().min(1).max(100).optional().describe("Maximum results. Default: 10."),
+  status: z.enum(["active", "archived", "deleted"]).optional().describe("Filter by record status."),
+})
+```
+
+Use `z.enum` for fields with a fixed set of values. This dramatically improves accuracy.
+
+## Using AgentToolContext
+
+The `execute` function receives a context object with execution metadata:
+
+```typescript
+const longProcess = createTool({
+  name: "long_process",
+  description: "Process data in batches.",
+  inputSchema: z.object({}),
+  async execute(_input, context) {
+    console.log(`Agent: ${context.agentId}, Iteration: ${context.iteration}`)
+
+    for (const batch of batches) {
+      if (context.signal?.aborted) {
+        return { status: "cancelled", processed: count }
+      }
+      await processBatch(batch)
+    }
+
+    return { status: "complete" }
+  },
+})
+```
+
+## Error Handling
+
+Return errors as structured data rather than throwing:
+
+```typescript
+const apiTool = createTool({
+  name: "call_api",
+  description: "Make an authenticated API call.",
+  inputSchema: z.object({
+    endpoint: z.string().describe("API endpoint path"),
+  }),
+  async execute(input) {
+    try {
+      const response = await fetch(`https://api.example.com${input.endpoint}`, {
+        headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
+      })
+
+      if (!response.ok) {
+        return {
+          output: { error: `API returned ${response.status}` },
+          isError: true,
+        }
+      }
+
+      return await response.json()
+    } catch (err) {
+      return {
+        output: { error: `Network error: ${(err as Error).message}` },
+        isError: true,
+      }
+    }
+  },
+})
+```
+
+When a tool returns an error, the agent sees it and can adjust its approach. When a tool throws, it counts as a "mistake" and increments the consecutive mistake counter.
+
+## Completion Tools
+
+Mark a tool with `lifecycle: { completesRun: true }` to make it end the agent loop when called successfully:
+
+```typescript
+const submitResult = createTool({
+  name: "submit_result",
+  description: "Submit the final result and end the run.",
+  inputSchema: z.object({
+    summary: z.string(),
+    approve: z.boolean(),
+  }),
+  lifecycle: { completesRun: true },
+  async execute(input) {
+    return JSON.stringify(input)
+  },
+})
+```
+
+See the [code-review-bot example](https://github.com/cline/cline/tree/main/apps/examples/code-review-bot) for this pattern in a complete application.
+
+## Testing Tools
+
+Test your tools in isolation before giving them to an agent:
+
+```typescript
+import { describe, it, expect } from "vitest"
+
+describe("get_current_time", () => {
+  it("returns ISO timestamp", async () => {
+    const result = await getCurrentTime.execute(
+      { timezone: "UTC" },
+      {
+        agentId: "test",
+        runId: "run_test",
+        iteration: 1,
+        toolCallId: "tool_test",
+        snapshot: {} as never,
+        emitUpdate: () => {},
+      }
+    )
+
+    expect(result.iso).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+  })
+})
+```
+
+## Registering Tools
+
+<Tabs>
+  <Tab title="Cline Core">
+    ```typescript
+    await cline.start({
+      prompt: "Get the current time",
+      config: {
+        // ...
+        extraTools: [getCurrentTime],
+      },
+    })
+    ```
+  </Tab>
+  <Tab title="Agent">
+    ```typescript
+    const agent = new Agent({
+      tools: [searchDatabase, getCurrentTime],
+      // ...
+    })
+    ```
+  </Tab>
+  <Tab title="Via Plugin">
+    ```typescript
+    const myPlugin: AgentPlugin = {
+      name: "my-tools",
+      manifest: { capabilities: ["tools"] },
+      setup(api) {
+        api.registerTool(searchDatabase)
+        api.registerTool(getCurrentTime)
+      },
+    }
+    ```
+  </Tab>
+</Tabs>
+
+## Tool Design Rules
+
+Good tools are specific and predictable.
+
+- Use action-oriented names: `get_pull_request`, `search_database`, `deploy_service`.
+- Describe what the tool does, when to use it, and what it returns.
+- Put constraints in the description: rate limits, read-only behavior, required permissions.
+- Add descriptions for every input property.
+- Return structured JSON instead of prose when possible.
+- Respect `context.abortSignal` in long-running tools.
diff --git a/docs/sdk/guides/going-to-production.mdx b/docs/sdk/guides/going-to-production.mdx
new file mode 100644
index 0000000..b820867
--- /dev/null
+++ b/docs/sdk/guides/going-to-production.mdx
@@ -0,0 +1,317 @@
+---
+title: "Going to Production"
+sidebarTitle: "Going to Production"
+description: "Best practices for deploying agents to production: error handling, observability, cost control, and security."
+---
+
+Moving from development to production means handling the things that don't matter during prototyping: errors, costs, observability, and security. This guide covers the patterns that production agent deployments need.
+
+## Error Handling
+
+### Agent-Level Errors
+
+The direct `AgentRuntime` result reports `status`; the host-facing `AgentResult` used by core reports `finishReason`.
+
+```typescript
+const result = await agent.run("Do something complex")
+
+if (result.status === "failed") {
+  // Log the error and alert
+  logger.error("Agent run failed", {
+    iterations: result.iterations,
+    error: result.error,
+  })
+}
+```
+
+### Tool Errors
+
+Tools should return errors as data rather than throwing. This lets the agent see the error and adjust:
+
+```typescript
+const apiTool: AgentTool<{ payload: unknown }, { success: boolean; data?: unknown; error?: string }> = {
+  name: "call_service",
+  // ...
+  execute: async (input) => {
+    try {
+      const result = await service.call(input)
+      return { output: { success: true, data: result } }
+    } catch (err) {
+      return {
+        output: { success: false, error: err.message },
+        isError: true,
+      }
+    }
+  },
+}
+```
+
+### Mistake Limits
+
+Core sessions can track consecutive recoverable mistakes and stop with `finishReason: "mistake_limit"`. Direct runtime runs report failure through `status` and `error`.
+
+### Loop Detection
+
+Loop detection is available through core/session execution settings.
+
+## Observability
+
+### OpenTelemetry Integration
+
+The SDK integrates with OpenTelemetry for traces, metrics, and logs:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "production-app",
+  telemetry: myTelemetryService,
+  logger: myLogger,
+})
+```
+
+Events emitted include:
+- `agent_created` -- agent initialized with config
+- `tool_usage` -- tool called with name, duration, success/failure
+- `model_api_call` -- LLM API call with model, tokens, latency
+- `session_ended` -- session completed with finish reason, total tokens
+
+### Custom Metrics via Plugins
+
+```typescript
+const productionMetrics: AgentPlugin = {
+  name: "production-metrics",
+  manifest: { capabilities: ["hooks"] },
+
+  onRunEnd({ result }) {
+    metrics.histogram("agent.duration_ms", result.durationMs)
+    metrics.counter("agent.tokens.input", result.usage.inputTokens)
+    metrics.counter("agent.tokens.output", result.usage.outputTokens)
+    metrics.counter(`agent.finish.${result.finishReason}`, 1)
+  },
+
+  onToolCall({ call }) {
+    metrics.counter(`agent.tool.${call.name}`, 1)
+  },
+
+  onError({ error, recoverable }) {
+    metrics.counter("agent.errors", 1, {
+      recoverable: String(recoverable),
+      type: error.constructor.name,
+    })
+  },
+}
+```
+
+### Structured Logging
+
+```typescript
+import pino from "pino"
+
+const logger = pino({ level: "info" })
+
+const agent = new Agent({
+  // ...config
+})
+
+agent.subscribe((event) => {
+  if (event.type === "run-finished") {
+    logger.info({
+      event: "agent_complete",
+      status: event.result.status,
+      iterations: event.result.iterations,
+      tokens: event.result.usage,
+    })
+  }
+  if (event.type === "run-failed") {
+    logger.error({
+      event: "agent_error",
+      message: event.error.message,
+    })
+  }
+})
+```
+
+## Cost Control
+
+### Set Token Limits
+
+```typescript
+const agent = new Agent({
+  // ...config
+  maxTokensPerTurn: 4096,
+  maxIterations: 20,
+})
+```
+
+### Track Spending
+
+```typescript
+type ModelPricing = {
+  inputPerMillion: number
+  outputPerMillion: number
+}
+
+function estimateCost(
+  usage: { inputTokens: number; outputTokens: number; totalCost?: number },
+  pricing: ModelPricing,
+) {
+  if (usage.totalCost != null) {
+    return usage.totalCost
+  }
+
+  return (
+    (usage.inputTokens / 1_000_000) * pricing.inputPerMillion +
+    (usage.outputTokens / 1_000_000) * pricing.outputPerMillion
+  )
+}
+
+let sessionCost = 0
+
+const providerId = "anthropic"
+const modelId = "claude-sonnet-4-6"
+// Load current USD-per-million-token pricing from configuration or a pricing service.
+const pricing = loadModelPricing(providerId, modelId)
+
+const agent = new Agent({
+  providerId,
+  modelId,
+  // ...
+})
+
+agent.subscribe((event) => {
+  if (event.type === "usage-updated") {
+    sessionCost = estimateCost(event.usage, pricing)
+
+    if (sessionCost > 1.0) {
+      agent.abort("Cost limit exceeded ($1.00)")
+    }
+  }
+})
+```
+
+### Use Cheaper Models for Simple Tasks
+
+```typescript
+// Quick lookup: use a fast, cheap model
+const lookupAgent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-haiku-4-5",
+  // ...
+})
+
+// Complex work: use a more capable model
+const workAgent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  // ...
+})
+```
+
+## Security
+
+### Sandbox Tool Execution
+
+Never let an agent run arbitrary shell commands on a production server without constraints:
+
+```typescript
+const sandboxedBash: AgentTool<{ command: string }, { error?: string; result?: unknown }> = {
+  name: "run_commands",
+  description: "Execute a shell command in a sandboxed environment.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "Shell command to execute" },
+    },
+    required: ["command"],
+  },
+  execute: async (input) => {
+    const blocked = ["rm -rf", "sudo", "curl | sh", "wget | sh", "> /dev/"]
+    if (blocked.some((b) => input.command.includes(b))) {
+      return { output: { error: "Command blocked by security policy" }, isError: true }
+    }
+
+    // Execute in a container, chroot, or restricted shell
+    return { output: { result: await executeInSandbox(input.command) } }
+  },
+}
+```
+
+### Validate Tool Inputs
+
+Don't trust tool inputs any more than you'd trust user input:
+
+```typescript
+const fileTool = createTool({
+  name: "read_files",
+  // ...
+  execute: async (input) => {
+    const resolved = path.resolve(input.path)
+
+    // Prevent path traversal
+    if (!resolved.startsWith(ALLOWED_DIRECTORY)) {
+      return { error: "Access denied: path outside allowed directory" }
+    }
+
+    return await fs.readFile(resolved, "utf-8")
+  },
+})
+```
+
+### Rotate API Keys
+
+Use environment variables for API keys, not hardcoded values:
+
+```typescript
+// Good
+const agent = new Agent({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  // ...
+})
+
+// Never do this
+const agent = new Agent({
+  apiKey: "sk-ant-api03-...",
+  // ...
+})
+```
+
+## Deployment Patterns
+
+### Stateless Worker
+
+For request/response workflows (API endpoints, webhook handlers):
+
+```typescript
+async function handleRequest(prompt: string): Promise<string> {
+  const agent = new Agent({
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    systemPrompt: "You are a helpful assistant.",
+    tools: [myTool],
+    maxIterations: 10,
+  })
+
+  const result = await agent.run(prompt)
+  // Agent has no explicit shutdown method
+  return result.outputText
+}
+```
+
+### Persistent Service
+
+For long-running services with session management:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-service",
+  backendMode: "hub",
+})
+
+// Sessions persist across restarts
+// Connectors, schedules, and team state all managed by the hub
+
+process.on("SIGTERM", async () => {
+  await cline.dispose("Shutting down")
+  process.exit(0)
+})
+```
diff --git a/docs/sdk/guides/multi-agent-teams.mdx b/docs/sdk/guides/multi-agent-teams.mdx
new file mode 100644
index 0000000..793d90e
--- /dev/null
+++ b/docs/sdk/guides/multi-agent-teams.mdx
@@ -0,0 +1,114 @@
+---
+title: "Multi-Agent Teams"
+sidebarTitle: "Multi-Agent Teams"
+description: "Coordinate multiple agents working together on complex tasks with delegation, shared context, and result merging."
+---
+
+Multi-agent teams let you break complex work across multiple agents that coordinate through a shared task board. One agent acts as the coordinator, delegating subtasks to specialist agents and merging their results.
+
+## Enabling Teams
+
+Teams are a ClineCore feature. Enable them in the session config:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "team-app" })
+
+const session = await cline.start({
+  prompt: "Plan and implement a user authentication module with tests",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    systemPrompt: "You are a coordinator for a multi-agent coding team.",
+    cwd: "/path/to/project",
+    workspaceRoot: "/path/to/project",
+    enableTools: true,
+    enableSpawnAgent: true,
+    enableAgentTeams: true,
+    teamName: "auth-sprint",
+  },
+})
+```
+
+## How Teams Work
+
+When teams are enabled, the coordinator agent gets additional tools:
+
+| Tool | Description |
+|------|-------------|
+| `team_spawn_teammate` | Create a new agent with a specific role and task |
+| `team_delegate_task` | Assign a task to an existing teammate |
+| `team_check_status` | Check the status of delegated tasks |
+| `team_get_result` | Retrieve the result of a completed task |
+
+The coordinator decides how to split work, which agents to create, and how to combine results.
+
+## Team Persistence
+
+Team state persists across sessions:
+
+```
+~/.cline/data/teams/[team-name]/
+  task-board.json      # Current tasks and their status
+  mailbox.json         # Inter-agent messages
+  mission-log.json     # Team activity history
+```
+
+Resume a team's work in a new session:
+
+```bash
+cline --team-name auth-sprint "Continue -- pick up incomplete tasks"
+```
+
+## Via CLI
+
+```bash
+# Start a new team
+cline --team-name auth-sprint "Plan and implement user auth with tests"
+
+# Resume work
+cline --team-name auth-sprint "What's the status? Continue with unfinished tasks."
+
+# Different team for a different workstream
+cline --team-name perf-sprint "Profile the API endpoints and optimize the slowest 3"
+```
+
+## Sub-Agents vs Teams
+
+The SDK offers two levels of multi-agent coordination:
+
+| Feature | Sub-Agents | Teams |
+|---------|-----------|-------|
+| Enable with | `enableSpawnAgent: true` | `enableAgentTeams: true` |
+| Persistence | Within session only | Across sessions |
+| Coordination | Parent-child | Peer-to-peer with task board |
+| Shared state | None | Task board, mailbox, mission log |
+| Best for | One-off delegation | Complex, multi-session projects |
+
+Sub-agents are lighter weight. The parent agent spawns a child, waits for its result, and continues. No persistent state, no task board.
+
+```typescript
+// Sub-agents: simple delegation within a single session
+const session = await cline.start({
+  config: {
+    enableSpawnAgent: true,  // Agent can spawn sub-agents
+    // ...
+  },
+  // ...
+})
+```
+
+Teams are for bigger efforts where work spans multiple sessions and agents need to coordinate asynchronously.
+
+## When to Use Teams
+
+Teams add overhead. Use them when:
+
+- The task naturally decomposes into independent subtasks
+- Different subtasks benefit from different system prompts or specializations
+- Work spans multiple sessions or days
+- You want a persistent record of task delegation and completion
+
+For simpler cases, a single agent with good tools is usually more efficient than a team.
diff --git a/docs/sdk/guides/permission-handling.mdx b/docs/sdk/guides/permission-handling.mdx
new file mode 100644
index 0000000..e19293d
--- /dev/null
+++ b/docs/sdk/guides/permission-handling.mdx
@@ -0,0 +1,161 @@
+---
+title: "Permission Handling"
+sidebarTitle: "Permission Handling"
+description: "Control which tools agents can run automatically and which require explicit approval."
+---
+
+Tool policies control whether tools are enabled and whether they run without approval. Tool names not listed in `toolPolicies` default to enabled and auto-approved, so set policies explicitly for tools that need review.
+
+## Tool Policies
+
+The simplest way to manage permissions is through tool policies. Set them per-tool when creating an agent:
+
+```typescript
+const agent = new Agent({
+  // ...config
+  tools: [readFileTool, writeFileTool, bashTool, searchTool],
+  toolPolicies: {
+    read_files: { autoApprove: true },     // Always run without asking
+    search_codebase: { autoApprove: true },         // Always run without asking
+    write_file: { autoApprove: false },    // Always ask before running
+    run_commands: { autoApprove: false },          // Always ask before running
+  },
+})
+```
+
+### Policy Options
+
+| Policy | Effect |
+|--------|--------|
+| `{ autoApprove: true }` | Tool executes immediately without approval |
+| `{ autoApprove: false }` | Tool waits for approval before executing |
+| `{ enabled: false }` | Tool is completely disabled (model won't see it) |
+| No policy set | Defaults to enabled and auto-approved |
+
+## Auto-Approve Everything
+
+For trusted environments (CI pipelines, sandboxed containers, development scripts):
+
+```typescript
+const agent = new Agent({
+  // ...config
+  tools: allTools,
+  toolPolicies: Object.fromEntries(
+    allTools.map((t) => [t.name, { autoApprove: true }])
+  ),
+})
+```
+
+Or with ClineCore:
+
+```typescript
+const session = await cline.start({
+  config: {
+    enableTools: true,
+  },
+  toolPolicies: {
+    run_commands: { autoApprove: true },
+    editor: { autoApprove: true },
+    read_files: { autoApprove: true },
+    apply_patch: { autoApprove: true },
+    search_codebase: { autoApprove: true },
+    fetch_web_content: { autoApprove: true },
+  },
+  capabilities: {
+    requestToolApproval: async () => ({ approved: true }),
+  },
+  // ...
+})
+```
+
+<Warning>
+Auto-approving all tools means the agent can execute any shell command, modify any file, and make network requests without your review. Only use this in environments where the agent's actions are either sandboxed or fully trusted.
+</Warning>
+
+## Interactive Approval
+
+For applications that need human oversight, implement a custom approval handler:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+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 cline = await ClineCore.create({
+  clientName: "interactive-app",
+  capabilities: {
+    requestToolApproval: async (request) => {
+      console.log(`\nTool: ${request.toolName}`)
+      console.log(`Input: ${JSON.stringify(request.input, null, 2)}`)
+
+      const answer = await ask("Approve? (y/n): ")
+      return { approved: answer.toLowerCase() === "y" }
+    },
+  },
+})
+```
+
+## Tiered Permissions
+
+A practical middle ground: auto-approve read-only operations, require approval for writes:
+
+```typescript
+const READ_TOOLS = new Set(["read_files", "search_codebase", "fetch_web_content"])
+const WRITE_TOOLS = new Set(["run_commands", "editor", "apply_patch"])
+
+const toolPolicies: Record<string, { autoApprove: boolean }> = {}
+
+for (const tool of READ_TOOLS) {
+  toolPolicies[tool] = { autoApprove: true }
+}
+for (const tool of WRITE_TOOLS) {
+  toolPolicies[tool] = { autoApprove: false }
+}
+```
+
+## Conditional Approval Logic
+
+Approve based on what the tool is actually doing, not just which tool it is:
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "smart-approval",
+  capabilities: {
+    requestToolApproval: async (request) => {
+      // Auto-approve non-destructive shell commands
+      if (request.toolName === "run_commands") {
+        const cmd = JSON.stringify(request.input)
+        const safeCommands = ["ls", "cat", "grep", "find", "git status", "git log", "git diff"]
+        if (safeCommands.some((safe) => cmd.startsWith(safe))) {
+          return { approved: true }
+        }
+      }
+
+      // Auto-approve reads to specific directories
+      if (request.toolName === "read_files") {
+        const path = request.input.path as string
+        if (path.startsWith("/src/") || path.startsWith("/tests/")) {
+          return { approved: true }
+        }
+      }
+
+      // Everything else requires manual approval
+      console.log(`Approval needed: ${request.toolName}`)
+      console.log(`Input: ${JSON.stringify(request.input)}`)
+      return { approved: false }
+    },
+  },
+})
+```
+
+## What Happens When a Tool is Rejected
+
+When approval is denied, the agent receives a rejection message and can adjust its approach. It might:
+- Ask the user for clarification
+- Try a different tool to accomplish the same goal
+- Modify its approach and try again with different parameters
+- Give up on that subtask and move on
+
+The agent does not get stuck in a loop. The rejection counts as a response, and the agent proceeds with its next iteration.
diff --git a/docs/sdk/guides/scheduled-agents.mdx b/docs/sdk/guides/scheduled-agents.mdx
new file mode 100644
index 0000000..3f14108
--- /dev/null
+++ b/docs/sdk/guides/scheduled-agents.mdx
@@ -0,0 +1,143 @@
+---
+title: "Scheduled Agents"
+sidebarTitle: "Scheduled Agents"
+description: "Run agents on cron schedules for recurring automations like daily summaries, code reviews, and maintenance tasks."
+---
+
+The SDK supports running agents on cron schedules. Scheduled agents persist across process restarts and run independently of any client application.
+
+## How Scheduling Works
+
+1. You define a schedule (cron expression + prompt + config)
+2. The SDK stores the schedule and manages execution
+3. At each trigger time a new session is created and the agent is run
+4. Results are stored and can be routed to connectors (Slack, email, etc.)
+
+Scheduled agents rely on the [hub-spoke architecture](/sdk/architecture/hub-spoke) that is part of `ClineCore`. The hub runs as a background process on your machine. It starts automatically when needed and persists schedules across restarts.
+
+## Creating Schedules Programmatically with Cline SDK
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({
+  clientName: "scheduler",
+  automation: true,
+})
+
+await cline.automation.start()
+
+// Use cline.automation to reconcile specs, ingest events, and list runs.
+```
+
+## Schedule Wizard with Cline CLI
+
+An easy way to schedule task is to use Cline CLI for scheduling task, if you've already installed via `npm i -g cline`
+
+Run `cline schedule` to open an interactive menu for creating and managing schedules, browsing execution history, and viewing performance statistics.
+
+## Creating Schedules with Flags
+
+```bash
+# Daily at 9 AM on weekdays
+cline schedule create "PR summary" \
+  --cron "0 9 * * MON-FRI" \
+  --prompt "List all open PRs, their review status, and any that have been open more than 3 days" \
+  --workspace /path/to/repo \
+  --model anthropic/claude-sonnet-4-6
+
+# Every 6 hours
+cline schedule create "Health check" \
+  --cron "0 */6 * * *" \
+  --prompt "Run the test suite and report any failures" \
+  --workspace /path/to/project
+
+# Monday mornings
+cline schedule create "Weekly digest" \
+  --cron "0 8 * * MON" \
+  --prompt "Summarize last week's commits, PRs merged, and issues closed"
+```
+
+## Managing Schedules
+
+```bash
+# List all schedules
+cline schedule list
+
+# Trigger a schedule immediately (without waiting for cron)
+cline schedule trigger <schedule-id>
+
+# Pause a schedule
+cline schedule pause <schedule-id>
+
+# Resume a paused schedule
+cline schedule resume <schedule-id>
+
+# Delete a schedule
+cline schedule delete <schedule-id>
+
+# View execution history
+cline schedule executions <schedule-id>
+```
+
+## Cron Expression Reference
+
+| Expression | Schedule |
+|-----------|----------|
+| `0 9 * * MON-FRI` | 9 AM, Monday through Friday |
+| `0 */6 * * *` | Every 6 hours |
+| `0 8 * * MON` | 8 AM every Monday |
+| `30 17 * * *` | 5:30 PM every day |
+| `0 0 1 * *` | Midnight on the 1st of each month |
+| `*/30 * * * *` | Every 30 minutes |
+
+## Use Cases
+
+### Daily Standup Summary
+
+```bash
+cline schedule create "Standup prep" \
+  --cron "0 8 * * MON-FRI" \
+  --prompt "Summarize: (1) PRs merged yesterday, (2) PRs currently in review, (3) open issues assigned to team members. Format as a brief standup update." \
+  --workspace /path/to/repo
+```
+
+### Automated Dependency Updates
+
+```bash
+cline schedule create "Dependency check" \
+  --cron "0 10 * * MON" \
+  --prompt "Check for outdated npm dependencies. For any with security vulnerabilities, create a branch with the update and open a PR." \
+  --workspace /path/to/project
+```
+
+### Codebase Health Report
+
+```bash
+cline schedule create "Code health" \
+  --cron "0 6 * * MON" \
+  --prompt "Analyze the codebase for: (1) files with no test coverage, (2) TODO/FIXME comments older than 30 days, (3) functions longer than 100 lines. Produce a health report." \
+  --workspace /path/to/project
+```
+
+## Concurrency and Resource Limits
+
+The scheduler enforces limits to prevent resource exhaustion:
+
+- Schedules have configurable concurrency limits
+- If a previous execution is still running when the next trigger fires, the new execution is queued or skipped (configurable)
+- The hub monitors resource usage and can pause schedules if the system is under load
+
+## Routing Results
+
+Combine scheduled agents with [connectors](/cli/connectors) in CLI to route results to messaging platforms:
+
+```bash
+# Start a Telegram connector
+cline connect telegram -k $BOT_TOKEN
+
+# Schedule an agent whose output gets sent to Telegram
+cline schedule create "Morning briefing" \
+  --cron "0 8 * * *" \
+  --prompt "Summarize overnight activity in the repo"
+```
diff --git a/docs/sdk/guides/writing-plugins.mdx b/docs/sdk/guides/writing-plugins.mdx
new file mode 100644
index 0000000..19bf42c
--- /dev/null
+++ b/docs/sdk/guides/writing-plugins.mdx
@@ -0,0 +1,314 @@
+---
+title: "Writing Plugins"
+sidebarTitle: "Writing Plugins"
+description: "Build plugins that add tools, observe execution, and modify agent behavior."
+---
+
+Plugins are the primary way to package reusable agent capabilities. This guide walks through building a production-quality plugin from scratch.
+
+## What You'll Build
+
+A GitHub integration plugin that:
+- Registers tools for interacting with GitHub (list issues, create PRs, post comments)
+- Logs all tool calls for auditing
+- Tracks token usage per session
+
+## Step 1: Define the Plugin Structure
+
+```typescript
+// github-plugin.ts
+import { type AgentPlugin } from "@cline/sdk"
+import { createTool } from "@cline/sdk"
+
+interface GitHubConfig {
+  token: string
+  owner: string
+  repo: string
+}
+
+export function createGitHubPlugin(config: GitHubConfig): AgentPlugin {
+  let totalTokens = 0
+
+  return {
+    name: "github-integration",
+    manifest: {
+      capabilities: ["tools", "hooks"],
+    },
+
+    setup(api, ctx) {
+      // Register tools in the setup phase
+      api.registerTool(createListIssuesTool(config))
+      api.registerTool(createCreateIssueTool(config))
+      api.registerTool(createPostCommentTool(config))
+    },
+
+    hooks: {
+      beforeRun() {
+        console.log(`[github] Run started`)
+      },
+
+      beforeTool(context) {
+        console.log(`[github] Tool: ${context.toolCall.name}(${JSON.stringify(context.input).slice(0, 100)})`)
+      },
+
+      afterRun(context) {
+        const usage = context.result.usage
+        totalTokens += (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
+        console.log(`[github] Run complete. Session tokens so far: ${totalTokens}`)
+      },
+    },
+  }
+}
+```
+
+## Step 2: Create the Tools
+
+```typescript
+function createListIssuesTool(config: GitHubConfig) {
+  return createTool({
+    name: "list_github_issues",
+    description: `List open issues in ${config.owner}/${config.repo}. Returns issue numbers, titles, labels, and assignees.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        state: {
+          type: "string",
+          enum: ["open", "closed", "all"],
+          description: "Issue state filter. Default: open.",
+        },
+        labels: {
+          type: "string",
+          description: "Comma-separated label names to filter by (e.g., 'bug,priority:high').",
+        },
+        limit: {
+          type: "number",
+          description: "Maximum issues to return. Default: 10, max: 100.",
+        },
+      },
+    },
+    execute: async (input) => {
+      const params = new URLSearchParams({
+        state: input.state ?? "open",
+        per_page: String(Math.min(input.limit ?? 10, 100)),
+      })
+      if (input.labels) params.set("labels", input.labels)
+
+      const response = await fetch(
+        `https://api.github.com/repos/${config.owner}/${config.repo}/issues?${params}`,
+        { headers: { Authorization: `token ${config.token}` } }
+      )
+
+      const issues = await response.json()
+      return {
+        issues: issues.map((i: Record<string, unknown>) => ({
+          number: i.number,
+          title: i.title,
+          state: i.state,
+          labels: (i.labels as Array<{ name: string }>).map((l) => l.name),
+          assignee: (i.assignee as { login: string } | null)?.login,
+          createdAt: i.created_at,
+        })),
+        total: issues.length,
+      }
+    },
+  })
+}
+
+function createCreateIssueTool(config: GitHubConfig) {
+  return createTool({
+    name: "create_github_issue",
+    description: `Create a new issue in ${config.owner}/${config.repo}.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Issue title" },
+        body: { type: "string", description: "Issue body (Markdown supported)" },
+        labels: {
+          type: "array",
+          items: { type: "string" },
+          description: "Labels to apply",
+        },
+      },
+      required: ["title"],
+    },
+    execute: async (input) => {
+      const response = await fetch(
+        `https://api.github.com/repos/${config.owner}/${config.repo}/issues`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `token ${config.token}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            title: input.title,
+            body: input.body,
+            labels: input.labels,
+          }),
+        }
+      )
+
+      const issue = await response.json()
+      return { number: issue.number, url: issue.html_url }
+    },
+  })
+}
+
+function createPostCommentTool(config: GitHubConfig) {
+  return createTool({
+    name: "post_github_comment",
+    description: `Post a comment on an issue or PR in ${config.owner}/${config.repo}.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        issueNumber: { type: "number", description: "Issue or PR number" },
+        body: { type: "string", description: "Comment body (Markdown supported)" },
+      },
+      required: ["issueNumber", "body"],
+    },
+    execute: async (input) => {
+      const response = await fetch(
+        `https://api.github.com/repos/${config.owner}/${config.repo}/issues/${input.issueNumber}/comments`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `token ${config.token}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ body: input.body }),
+        }
+      )
+
+      const comment = await response.json()
+      return { id: comment.id, url: comment.html_url }
+    },
+  })
+}
+```
+
+## Step 3: Use the Plugin
+
+```typescript
+import { Agent } from "@cline/sdk"
+import { createGitHubPlugin } from "./github-plugin"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  systemPrompt: "You are a project manager assistant with access to GitHub.",
+  plugins: [
+    createGitHubPlugin({
+      token: process.env.GITHUB_TOKEN,
+      owner: "my-org",
+      repo: "my-project",
+    }),
+  ],
+})
+
+await agent.run("List all open bugs and create a summary issue with the count")
+```
+
+## Distributing as a File Plugin
+
+To load this plugin from a file in ClineCore, pass its path in `pluginPaths`:
+
+```typescript
+// /absolute/path/to/github.ts
+import { type AgentPlugin, createTool } from "@cline/sdk"
+
+const plugin: AgentPlugin = {
+  name: "github",
+  manifest: { capabilities: ["tools"] },
+  setup(api, ctx) {
+    api.registerTool(
+      createTool({
+        name: "list_github_issues",
+        // ... tool definition
+      })
+    )
+  },
+}
+
+export default plugin
+```
+
+Then include it in session config:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+await cline.start({
+  config: {
+    systemPrompt: "Use the GitHub plugin",
+    // ...model/runtime config
+    pluginPaths: ["/absolute/path/to/github.ts"],
+  },
+})
+```
+
+## Distributing via CLI Install
+
+Single-file plugins can be installed directly from a file URL:
+
+```bash
+cline plugin install https://github.com/your-org/your-repo/blob/main/plugins/github-plugin.ts
+```
+
+Single-file plugins can only import Node builtins and `@cline/*`. As soon as you need an npm dependency (`zod`, an HTTP client, etc.) you must ship as a package: a directory with a `package.json` that declares a `cline` field for entry points and your runtime `dependencies`. Dependencies under the `@cline/` scope are provided by the host runtime -- the installer strips these and runs `npm install` for the rest, so declare any `@cline/*` package you import as an optional peer dependency:
+
+```json
+{
+  "cline": {
+    "plugins": [{ "paths": ["./github-plugin.ts"], "capabilities": ["tools", "hooks"] }]
+  },
+  "dependencies": {
+    "@octokit/rest": "^21.0.0"
+  },
+  "peerDependencies": {
+    "@cline/sdk": "*"
+  },
+  "peerDependenciesMeta": {
+    "@cline/sdk": {
+      "optional": true
+    }
+  }
+}
+```
+
+Users can also install package plugins from git, npm, or a local path:
+
+```bash
+cline plugin install https://github.com/your-org/cline-github-plugin.git
+```
+
+## Bundling Skills
+
+Package plugins can include skills by adding a top-level `skills/` directory next to `package.json`:
+
+```txt
+cline-github-plugin/
+  package.json
+  github-plugin.ts
+  skills/
+    triage/
+      SKILL.md
+```
+
+Each bundled skill follows the same directory format as any other [Cline skill](/customization/skills). When the plugin is installed or loaded through `pluginPaths`, Cline discovers those skills automatically.
+
+See [Plugins](/customization/plugins) for the full manifest format, directory layout, and the [typescript-lsp-plugin](https://github.com/cline/typescript-lsp-plugin) for a complete working example.
+
+## Plugin Design Guidelines
+
+1. Use factory functions (like `createGitHubPlugin`) when the plugin needs configuration. Export the plugin object directly when it doesn't.
+
+2. Keep `setup()` synchronous and fast. It runs before the first LLM call, so any async initialization delays the agent.
+
+3. Register all tools in `setup()`, not in lifecycle hooks. Tools must be available before the first iteration.
+
+4. Use lifecycle hooks for observation (logging, metrics, auditing), not for modifying agent behavior. If you need to modify behavior, consider using the `beforeRun` or `beforeModel` hooks to adjust the system prompt or context.
+
+5. Handle errors gracefully in hooks. A thrown error in `beforeTool` will count as a tool failure. If your hook is purely observational, catch errors internally.
diff --git a/docs/sdk/model-providers.mdx b/docs/sdk/model-providers.mdx
new file mode 100644
index 0000000..a8baf82
--- /dev/null
+++ b/docs/sdk/model-providers.mdx
@@ -0,0 +1,109 @@
+---
+title: "Model Providers"
+sidebarTitle: "Model Providers"
+description: "Configure provider credentials, model IDs, and the LLM gateway."
+---
+
+The `@cline/llms` package provides provider registries, model catalogs, handlers, and a gateway. `@cline/agents` and `@cline/core` use this layer internally.
+
+## Configure a Provider
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  // ...
+})
+```
+
+Provider config can include `apiKey`, `baseUrl`, `headers`, and provider-specific settings through core/provider config types.
+
+Common environment variables:
+
+| Provider | Environment variable |
+|----------|----------------------|
+| Anthropic | `ANTHROPIC_API_KEY` |
+| OpenAI | `OPENAI_API_KEY` |
+| Google | `GOOGLE_API_KEY` or `GOOGLE_APPLICATION_CREDENTIALS` |
+| AWS Bedrock | `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN` |
+| Mistral | `MISTRAL_API_KEY` |
+
+## OpenAI-Compatible Providers
+
+Use `openai-compatible` for providers that expose an OpenAI-compatible API:
+
+```typescript
+const agent = new Agent({
+  providerId: "openai-compatible",
+  modelId: "your-model-name",
+  apiKey: process.env.PROVIDER_API_KEY,
+  baseUrl: "https://your-provider.com/v1",
+})
+```
+
+## AWS Bedrock
+
+Bedrock uses AWS credentials from the standard environment/SDK chain and provider-specific config:
+
+```typescript
+const agent = new Agent({
+  providerId: "bedrock",
+  modelId: "anthropic.claude-sonnet-4-6",
+  providerConfig: {
+    awsRegion: "us-east-1",
+  },
+})
+```
+
+## Gateway API
+
+Use `DefaultGateway` or `createGateway` when you need direct provider/model access:
+
+```typescript
+import { DefaultGateway } from "@cline/llms"
+
+const gateway = new DefaultGateway()
+
+const providers = gateway.listProviders()
+const model = gateway.createAgentModel({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+})
+```
+
+The package also exports registry helpers such as `getAllProviders`, `getProviderIds`, `getModelsForProvider`, `registerProvider`, and `registerModel`.
+
+See [Gateway reference](/sdk/reference/gateway) for exact APIs.
+
+## Model Metadata
+
+Models expose metadata for selection and cost calculations:
+
+```typescript
+interface ModelInfo {
+  id: string
+  name?: string
+  contextWindow?: number
+  maxTokens?: number
+  pricing?: {
+    input?: number
+    output?: number
+    cacheCreation?: number
+    cacheRead?: number
+  }
+  capabilities?: Record<string, unknown>
+}
+```
+
+## Cost Tracking
+
+Agent results and usage events include token usage:
+
+```typescript
+const result = await agent.run("Analyze this codebase")
+
+console.log(result.usage.inputTokens)
+console.log(result.usage.outputTokens)
+console.log(result.usage.totalCost)
+```
diff --git a/docs/sdk/overview.mdx b/docs/sdk/overview.mdx
new file mode 100644
index 0000000..ca28c81
--- /dev/null
+++ b/docs/sdk/overview.mdx
@@ -0,0 +1,85 @@
+---
+title: "Cline SDK"
+sidebarTitle: "Overview"
+description: "TypeScript packages for embedding Cline's agent runtime in your own applications."
+---
+
+The Cline SDK is an open source framework for building agentic applications, and is the same harness used in the Cline IDE extensions and CLI. It uses a plugin architecture that makes it easy to customize and comes with all the features you expect from agents like checkpoints, web fetch, MCPs, cron jobs, subagents, and more.
+
+Use the Cline SDK to run agents from CI/CD pipelines, create automations for end-to-end workflows, or embed agents directly inside your products.
+
+## Install
+
+```bash
+npm install @cline/sdk
+```
+
+`@cline/sdk` exports all SDK packages: `@cline/core` for the full agent harness, `@cline/agents` for the stateless agent loop, `@cline/llms` for control over the model gateway, and `@cline/shared` for common utilities.
+
+Requires Node.js 22 or later.
+
+## SDK Skill
+
+If you use a coding agent (Claude Code, Codex, Cline, etc.), install the [Cline SDK skill](https://github.com/cline/sdk-skill) to give your agent context on the SDK's APIs and best practices to help you build with the Cline SDK.
+
+```bash
+npx skills add cline/sdk-skill
+```
+
+Prompt it to scaffold agents, create custom tools, wire up plugins, configure providers, and more.
+
+## Your First Agent
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  maxIterations: 1,
+})
+
+agent.subscribe((event) => {
+  if (event.type === "assistant-text-delta") {
+    process.stdout.write(event.text ?? "")
+  }
+})
+
+const result = await agent.run("Explain what an SDK is in two sentences.")
+```
+
+<Note>
+  Here is a complete [quickstart example](https://github.com/cline/cline/tree/main/apps/examples/quickstart). Clone it and run `bun dev` to try it.
+</Note>
+
+## Packages
+
+| Package | Purpose |
+|---------|---------|
+| `@cline/sdk` | Public SDK surface (re-exports `@cline/core`) |
+| `@cline/core` | Node runtime for sessions, built-in tools, persistence, hub support, automation |
+| `@cline/agents` | Browser-compatible stateless agent execution loop |
+| `@cline/llms` | Provider gateway and model catalogs |
+| `@cline/shared` | Types, schemas, tool helpers, hooks, storage helpers |
+
+
+
+See [Packages](/sdk/architecture/overview) for package boundaries and exports.
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Examples" icon="rocket" href="/sdk/examples">
+    Browse complete, runnable SDK examples.
+  </Card>
+  <Card title="Plugins" icon="diagram-project" href="/sdk/plugins">
+    Extend Cline's functionality.
+  </Card>
+  <Card title="Tools" icon="wrench" href="/sdk/tools">
+    Add actions the model can call.
+  </Card>
+  <Card title="Building an Agent" icon="code" href="/sdk/guides/building-an-agent">
+    Build a complete SDK agent from a tutorial.
+  </Card>
+</CardGroup>
diff --git a/docs/sdk/plugin-examples.mdx b/docs/sdk/plugin-examples.mdx
new file mode 100644
index 0000000..3780be0
--- /dev/null
+++ b/docs/sdk/plugin-examples.mdx
@@ -0,0 +1,92 @@
+---
+title: "Plugin Examples"
+sidebarTitle: "Plugin Examples"
+description: "Explore installable plugin examples from the Cline SDK repository."
+---
+
+The [SDK repository](https://github.com/cline/cline/tree/main/sdk) includes installable plugin examples under [`examples/plugins/`](https://github.com/cline/cline/tree/main/sdk/examples/plugins). Use them as starting points for tools, lifecycle hooks, message rewriting, policy enforcement, background jobs, and multi-agent workflows.
+
+## Examples
+
+| Example | What it shows |
+|---------|---------------|
+| [`weather-metrics.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts) | Tool registration plus lifecycle metrics hooks. Best starting point. |
+| [`mac-notify.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/mac-notify.ts) | macOS Notification Center alert from an `afterRun` hook. |
+| [`custom-compaction.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/custom-compaction.ts) | Provider-message compaction with `registerMessageBuilder`. |
+| [`background-terminal.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/background-terminal.ts) | Detached shell jobs with persisted logs and optional session steering. |
+| [`automation-events.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/automation-events.ts) | Plugin-emitted automation events. |
+| [`gitignore-read-files-guard.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/gitignore-read-files-guard.ts) | Runtime hook policy that blocks file access outside workspace `.gitignore` boundaries. |
+| [`web-search.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/web-search.ts) | `web_search` tool backed by an Exa API key. |
+| [`typescript-lsp/`](https://github.com/cline/cline/tree/main/sdk/examples/plugins/typescript-lsp) | `goto_definition` tool powered by the TypeScript Language Service. |
+| [`agents-squad/`](https://github.com/cline/cline/tree/main/sdk/examples/plugins/agents-squad) | Multi-agent team with subagents that have their own models and personalities. |
+
+## Try a File Plugin with the CLI
+
+The CLI auto-discovers plugins from `.cline/plugins` in the workspace, `~/.cline/plugins`, and the system plugins folder.
+
+```sh
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts --cwd .
+cline -i "What's the weather like in Tokyo and Paris?"
+```
+
+Swap `weather-metrics.ts` for any other single-file plugin example.
+
+## Block Ignored File Access
+
+Use `gitignore-read-files-guard.ts` to block tools from reading or editing files ignored by workspace `.gitignore` files:
+
+```sh
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/gitignore-read-files-guard.ts --cwd .
+cline -i "Read the ignored .env file"
+```
+
+The guard uses the `beforeTool` runtime hook. When a `read_files`, `editor`, or `apply_patch` call targets an ignored workspace file, the hook returns `{ skip: true }`, so the tool records a policy error and does not access the file.
+
+## Install a Directory Plugin
+
+For a plugin that lives in a directory with its own `package.json`, use `cline plugin install`:
+
+```sh
+cline plugin install ./examples/plugins/agents-squad
+```
+
+See [Installing Plugins](/sdk/plugin-install) for more install options.
+
+## Add Web Search
+
+The `web-search.ts` plugin registers a `web_search` tool backed by Exa. Use `web_search` to discover relevant URLs, then use `fetch_web_content` when the agent needs to inspect a specific page.
+
+```sh
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/web-search.ts --cwd .
+
+export EXA_API_KEY=...
+export OPENROUTER_API_KEY=...
+
+cline auth --provider openrouter --apikey "$OPENROUTER_API_KEY" --modelid anthropic/claude-sonnet-4.6
+cline -P openrouter -m anthropic/claude-sonnet-4.6 "Search the web for recent Bun release notes, then fetch the most relevant page"
+```
+
+`EXA_API_KEY` authenticates the search backend. The CLI still needs a normal model provider key or saved provider auth for inference.
+
+## Custom Message Compaction
+
+Use `registerMessageBuilder` when a plugin needs to rewrite the provider-bound message list before the model call.
+
+| Example | Extension point | Best for |
+|---------|-----------------|----------|
+| [`custom-compaction.ts`](https://github.com/cline/cline/blob/main/sdk/examples/plugins/custom-compaction.ts) | `api.registerMessageBuilder()` | Reusable, plugin-owned compaction policies. |
+| [`custom-compaction-hook.example.ts`](https://github.com/cline/cline/blob/main/sdk/examples/hooks/custom-compaction-hook.example.ts) | `hooks.beforeModel` | Runtime hook logic that needs runtime hook context or direct request mutation. |
+
+Prefer the message-builder version for normal compaction. It runs in the core message pipeline before the built-in safety builder, multiple builders run in registration order, and the final pass enforces provider-safe truncation.
+
+## Background Terminal Plugin
+
+`background-terminal.ts` registers three tools for long-running shell jobs:
+
+| Tool | Purpose |
+|------|---------|
+| `start_background_command` | Starts a detached shell command, returns a job ID immediately, and captures stdout/stderr under Cline's data directory. |
+| `get_background_command` | Reads job status plus recent stdout/stderr tails. |
+| `delete_background_command` | Deletes saved job metadata and optionally deletes captured logs. |
+
+When `notifyParent` is true, the plugin emits a `steer_message` after the command exits, pushing a completion summary back into the active session so the agent can react to long-running commands without blocking the original tool call.
diff --git a/docs/sdk/plugin-install.mdx b/docs/sdk/plugin-install.mdx
new file mode 100644
index 0000000..79666c8
--- /dev/null
+++ b/docs/sdk/plugin-install.mdx
@@ -0,0 +1,173 @@
+---
+title: "Installing Plugins"
+sidebarTitle: "Installing Plugins"
+description: "Install plugins from file URLs, npm, git, or local sources using the CLI or programmatically."
+---
+
+The Cline CLI provides a `plugin install` command to install plugins from various sources. You can also load plugins programmatically via session config.
+
+## CLI Installation
+
+Use the `cline plugin install` command to install plugins from file URLs, npm, git repositories, or local paths.
+
+```sh
+cline plugin install <source> [options]
+```
+
+The shorthand `cline plugin i` works as well.
+
+### Install from a File URL
+
+```sh
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts
+cline plugin install https://raw.githubusercontent.com/cline/cline/main/sdk/examples/plugins/weather-metrics.ts
+```
+
+Installs a single `.ts` or `.js` plugin file from an HTTPS URL. GitHub `blob` URLs are normalized to raw file downloads automatically.
+
+### Install from npm
+
+```sh
+cline plugin install --npm @scope/plugin-name
+```
+
+Installs the package from the npm registry into the Cline plugin directory.
+
+### Install from Git
+
+```sh
+cline plugin install --git https://github.com/owner/repo.git
+cline plugin install --git github.com/owner/repo
+```
+
+Clones the repository (shallow, with blobless filter for speed) and installs its dependencies. The `.git` directory is excluded from the final install.
+
+### Install from Local Source
+
+```sh
+cline plugin install ./path/to/plugin.ts     # Single file
+cline plugin install /absolute/path/to/dir   # Directory with package.json
+```
+
+Supports both files and directories. Local installs copy the source, filter out `.git` and `node_modules`, and run `npm install` to resolve dependencies.
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `--npm` | Treat the source as an npm package name |
+| `--git` | Treat the source as a git repository URL |
+| `--force` | Overwrite an existing plugin at the same path |
+| `--json` | Output results as JSON (useful for scripting) |
+| `--cwd` | Install to `<path>/.cline/plugins` and resolve relative local paths from `<path>` |
+
+### Examples
+
+```sh
+# Install a local plugin directory
+cline plugin install ./my-custom-plugin
+
+# Install a single plugin file from GitHub
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts
+
+# Install an npm package as a plugin
+cline plugin install --npm @cline/plugin-sql
+
+# Install from a GitHub repo
+cline plugin install --git https://github.com/my-org/my-plugin.git
+
+# Force reinstall an existing plugin
+cline plugin install --force --npm @scope/plugin-name
+
+# Use shorthand
+cline plugin i --git github.com/owner/repo
+```
+
+### Listing Installed Plugins
+
+Installed plugins appear in the `plugins` section of your CLI config:
+
+```sh
+cline config
+```
+
+### Find All Your Plugins from your file system
+
+Project-scoped plugins live in the `.cline/plugins/` folder at your workspace root. The CLI auto-discovers plugins from this folder when you run Cline in that project.
+
+```text
+your-project/
+├── .cline/
+│   └── plugins/
+│       ├── my-plugin.ts
+│       └── another-plugin/
+└── ...
+```
+
+To add a single-file plugin to a project, install it with `--cwd`:
+
+```sh
+cline plugin install https://github.com/owner/repo/blob/main/plugins/my-plugin.ts --cwd .
+```
+
+Global plugins are discovered from `~/.cline/plugins/`, and Cline may also discover plugins from the system Plugins folder. Use `--cwd .` when you want plugins to stay with a specific project.
+
+## Programmatic Installation
+
+### Using `pluginPaths` (ClineCore)
+
+In SDK code, load plugins from file paths using the `pluginPaths` session config option:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+await cline.start({
+  config: {
+    systemPrompt: "Analyze this project",
+    // ...model/runtime config
+    pluginPaths: ["/absolute/path/to/plugin.ts"],
+  },
+})
+```
+
+Plugin files must export an `AgentPlugin` as the default export. `pluginPaths` also accepts a package directory -- the SDK reads `package.json` and follows the `cline.plugins` entries, so you can `npm install` once inside a package and iterate without re-running `cline plugin install` on every edit.
+
+### Using `plugins` (Agent Runtime)
+
+When using the `Agent` or `AgentRuntime` directly, pass plugin instances in the `plugins` array:
+
+```typescript
+import { Agent } from "@cline/sdk"
+import { myPlugin } from "./my-plugin"
+
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  plugins: [myPlugin],
+})
+```
+
+### Using `extensions` (ClineCore)
+
+With `ClineCore`, use the `extensions` config array instead:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+await cline.start({
+  config: {
+    systemPrompt: "Analyze customer records",
+    extensions: [myPlugin],
+  },
+})
+```
+
+## Next Steps
+
+- **Learn about [Plugins](/sdk/plugins)** — Understand what plugins are and their benefits.
+- **Follow the [Writing Plugins](/sdk/guides/writing-plugins) guide** — Build and distribute your own plugin.
+- Explore [Plugin Examples](/sdk/plugin-examples) to install ready-to-run plugin examples from the SDK repository.
diff --git a/docs/sdk/plugins.mdx b/docs/sdk/plugins.mdx
new file mode 100644
index 0000000..c47cd9f
--- /dev/null
+++ b/docs/sdk/plugins.mdx
@@ -0,0 +1,160 @@
+---
+title: "Plugins Overview"
+sidebarTitle: "Plugins"
+description: "Learn what plugins are, their benefits, and how they extend agent behavior."
+---
+
+Plugins are packages of reusable agent capabilities. They let you bundle tools, lifecycle hooks, commands, and configuration into a single module that can be shared across projects or published for others to use.
+
+## Benefits of Plugins
+
+| Benefit | Description |
+|---------|-------------|
+| **Modularity** | Encapsulate related tools and hooks in a single unit. No more scattered logic. |
+| **Reusability** | Share plugins across agents, projects, or teams. Publish to npm or distribute via git. |
+| **Packaging** | Bundle tools, hooks, commands, message builders, and providers together. |
+| **Observability** | Hook into every stage of the agent lifecycle — run start/end, model calls, tool calls, errors. |
+| **Composability** | Combine multiple plugins in a single agent. Each plugin handles its own domain. |
+
+## Extension Glossary
+
+| Extension point | What it does |
+|-----------------|--------------|
+| **Tool** | Lets the model call an action (query a DB, call an API, etc.) |
+| **Command** | Register slash commands to allow actions to be manually triggered |
+| **Hook** | Runs lifecycle logic or policy checks at specific stages |
+| **Rules** | Prompts that steer the agent and will be included in every session |
+| **Events** | Register external events that will trigger agent actions |
+| **Plugin** | Packages tools, hooks, commands, rules, and automation events together |
+
+| If you need to... | Use a... |
+|-------------------|----------|
+| Allow the model to query a database, call an API, run a domain action | **Tool** |
+| Register a user triggered action (slash command) | **Command** |
+| Log runs, collect metrics, enforce policy | **Hook** handler |
+| Block dangerous tool calls | **Hook** or approval policy |
+| Provide consistent guidance to the model via prompts | **Rule** |
+| Trigger agent action on an external event (new PR, Slack message, etc) | **Event** |
+| Bundle several tools into a reusable module | **Plugin** |
+
+## What is a Plugin?
+
+A plugin is an `AgentPlugin` — an object that implements the SDK's extension interface. It can register tools, hook into agent lifecycle events, and provide configuration defaults.
+
+```typescript
+import { type AgentPlugin } from "@cline/sdk"
+
+const myPlugin: AgentPlugin = {
+  name: "my-plugin",
+  manifest: {
+    capabilities: ["tools", "hooks"],
+  },
+  setup(api, ctx) {
+    // Register tools, commands, providers via api.registerTool(), etc.
+  },
+  hooks: {
+    beforeTool(context) {
+      // Observe or audit tool calls before they execute
+    },
+    afterRun(context) {
+      // Log metrics, cleanup, notify after a run completes
+    },
+  },
+}
+```
+
+Hooks are defined inside the `hooks` object, not directly on the extension. The available lifecycle hooks are `beforeRun`, `afterRun`, `beforeModel`, `afterModel`, `beforeTool`, `afterTool`, and `onEvent`.
+
+
+## Next Steps
+
+Register with `ClineCore`:
+
+```typescript
+await cline.start({
+  prompt: "Analyze customer records",
+  config: {
+    // ...model/runtime config
+    extensions: [databasePlugin],
+  },
+})
+```
+
+## File-Based Plugins
+
+`ClineCore` supports plugin module paths via `pluginPaths` in session config:
+
+```typescript
+await cline.start({
+  prompt: "Analyze this project",
+  config: {
+    // ...model/runtime config
+    pluginPaths: ["/absolute/path/to/plugin.ts"],
+  },
+})
+```
+
+Plugin files export an `AgentPlugin`.
+
+## Installing Plugins via CLI
+
+Plugins can also be installed from file URLs, npm, git, or local paths using `cline plugin install`. See [Plugins](/customization/plugins) for install commands, the manifest format, and directory layout.
+
+## Hook Stages
+
+Hook stages include:
+
+```txt
+input
+runtime_event
+session_start
+run_start
+iteration_start
+turn_start
+before_agent_start
+tool_call_before
+tool_call_after
+turn_end
+stop_error
+iteration_end
+run_end
+session_shutdown
+error
+```
+
+Common stages:
+
+| Stage | Use for |
+|-------|---------|
+| `before_agent_start` | Inject context or modify prompt/messages |
+| `run_start` | Logging, timers, rate limits |
+| `tool_call_before` | Audit or block tool calls |
+| `tool_call_after` | Log results, trigger side effects |
+| `run_end` | Metrics, notifications, cleanup |
+| `error` | Error reporting |
+
+## Hook Policies
+
+Hook policies control execution behavior:
+
+| Field | Meaning |
+|-------|---------|
+| `mode` | `"blocking"` or `"async"` |
+| `timeoutMs` | Hook timeout |
+| `retries` | Retry count |
+| `retryDelayMs` | Delay between retries |
+| `failureMode` | `"fail_open"` or `"fail_closed"` |
+| `maxConcurrency` | Concurrent hook executions |
+| `queueLimit` | Queue size before dropping |
+
+Use `fail_closed` for policy-enforcement hooks where bypassing the hook is unsafe.
+
+## Build a Plugin
+
+For a step-by-step plugin tutorial, see [Writing Plugins](/sdk/guides/writing-plugins).
+
+## SDK Examples
+
+The [SDK repository](https://github.com/cline/cline/tree/main/sdk) includes ready-to-run plugin examples under [`examples/plugins/`](https://github.com/cline/cline/tree/main/sdk/examples/plugins), including tool registration, lifecycle metrics, notifications, custom compaction, policy guards, web search, background jobs, TypeScript LSP tools, and multi-agent teams.
+
+See [Plugin Examples](/sdk/plugin-examples) for the full list and usage commands.
diff --git a/docs/sdk/reference/agent.mdx b/docs/sdk/reference/agent.mdx
new file mode 100644
index 0000000..d872b7c
--- /dev/null
+++ b/docs/sdk/reference/agent.mdx
@@ -0,0 +1,111 @@
+---
+title: "Agent"
+sidebarTitle: "Agent"
+description: "API reference for Agent / AgentRuntime from @cline/agents."
+---
+
+`Agent` is an alias for `AgentRuntime` from `@cline/agents`.
+
+```typescript
+import { Agent, AgentRuntime, createAgent, createAgentRuntime } from "@cline/sdk"
+```
+
+## Constructor
+
+```typescript
+new Agent(config: AgentRuntimeConfig)
+```
+
+`AgentRuntimeConfig` accepts either:
+
+- a prebuilt `model: AgentModel`, or
+- `providerId`, `modelId`, and optional provider credentials (`apiKey`, `baseUrl`, `headers`).
+
+Common fields:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `providerId` | `string` | Yes, unless `model` supplied | Provider ID |
+| `modelId` | `string` | Yes, unless `model` supplied | Model ID |
+| `apiKey` | `string` | No | Provider API key |
+| `baseUrl` | `string` | No | Custom provider base URL |
+| `systemPrompt` | `string` | No | System instructions |
+| `tools` | `AgentTool[]` | No | Tools available to the runtime |
+| `initialMessages` | `AgentMessage[]` | No | Preloaded conversation |
+| `toolPolicies` | `Record<string, ToolPolicy>` | No | Per-tool enablement/approval |
+| `hooks` | `AgentRuntimeHooks` | No | Runtime lifecycle hooks |
+
+## Methods
+
+### `run(input)`
+
+```typescript
+const result = await agent.run("Analyze this codebase")
+```
+
+Starts a run with input.
+
+### `continue(input?)`
+
+```typescript
+const result = await agent.continue("Now inspect the auth module")
+```
+
+Continues with optional new input.
+
+### `abort(reason?)`
+
+```typescript
+agent.abort("User cancelled")
+```
+
+Aborts the active run.
+
+### `subscribe(listener)`
+
+```typescript
+const unsubscribe = agent.subscribe((event) => {
+  console.log(event.type)
+})
+```
+
+Subscribes to `AgentRuntimeEvent` events.
+
+### `restore(messages)`
+
+```typescript
+agent.restore(savedMessages)
+```
+
+Replaces conversation history and resets runtime state while preserving tools, hooks, model, agent identity, and subscribers.
+
+### `snapshot()`
+
+```typescript
+const state = agent.snapshot()
+```
+
+Returns an `AgentRuntimeStateSnapshot`.
+
+## AgentRunResult
+
+```typescript
+interface AgentRunResult {
+  agentId: string
+  agentRole?: string
+  runId: string
+  status: "completed" | "aborted" | "failed"
+  iterations: number
+  outputText: string
+  messages: readonly AgentMessage[]
+  usage: AgentUsage
+  error?: Error
+}
+```
+
+## Factories
+
+```typescript
+const agent = createAgent(config)
+const runtime = createAgentRuntime(config)
+```
diff --git a/docs/sdk/reference/cline-core.mdx b/docs/sdk/reference/cline-core.mdx
new file mode 100644
index 0000000..79da826
--- /dev/null
+++ b/docs/sdk/reference/cline-core.mdx
@@ -0,0 +1,108 @@
+---
+title: "ClineCore"
+sidebarTitle: "ClineCore"
+description: "API reference for ClineCore from @cline/core."
+---
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+```
+
+## `ClineCore.create(options)`
+
+```typescript
+const cline = await ClineCore.create({
+  clientName: "my-app",
+  backendMode: "auto",
+})
+```
+
+Common options:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `clientName` | `string` | Human-readable SDK client name |
+| `distinctId` | `string` | Stable telemetry/user identifier |
+| `backendMode` | `"auto" \| "local" \| "hub" \| "remote"` | Runtime backend selection |
+| `hub` | `HubOptions` | Local hub connection options |
+| `remote` | `RemoteOptions` | Remote hub options |
+| `capabilities` | `RuntimeCapabilities` | Client-owned tool executors and approval callbacks |
+| `toolPolicies` | `Record<string, ToolPolicy>` | Default tool approval policies |
+| `automation` | `boolean \| ClineCoreAutomationOptions` | Enable automation APIs |
+| `fetch` | `typeof fetch` | Custom fetch for local provider calls |
+
+## `start(input)`
+
+```typescript
+const session = await cline.start({
+  prompt: "Summarize this repo",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    systemPrompt: "You are a helpful coding assistant.",
+    cwd: process.cwd(),
+    workspaceRoot: process.cwd(),
+    enableTools: true,
+    enableSpawnAgent: false,
+    enableAgentTeams: false,
+  },
+})
+```
+
+### ClineCoreStartInput
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `prompt` | `string` | No | Initial prompt |
+| `config` | `CoreSessionConfig` | Yes | Session model/runtime config |
+| `source` | `SessionSource` | No | Session source label |
+| `interactive` | `boolean` | No | Whether session expects interaction |
+| `sessionMetadata` | `Record<string, unknown>` | No | Metadata persisted with session |
+| `initialMessages` | `Message[]` | No | Preloaded messages |
+| `toolPolicies` | `Record<string, ToolPolicy>` | No | Per-session tool policies |
+| `capabilities` | `RuntimeCapabilities` | No | Per-session tool executors and approval callbacks |
+
+### StartSessionResult
+
+```typescript
+interface StartSessionResult {
+  sessionId: string
+  manifest: SessionManifest
+  manifestPath: string
+  messagesPath: string
+  result?: AgentResult
+}
+```
+
+## `send(input)`
+
+```typescript
+const result = await cline.send({
+  sessionId,
+  prompt: "Continue with tests",
+})
+```
+
+Returns `AgentResult | undefined`.
+
+## Session APIs
+
+| Method | Description |
+|--------|-------------|
+| `subscribe(listener, options?)` | Subscribe to `CoreSessionEvent` events |
+| `list(limit?, options?)` | List session history records |
+| `listHistory(options?)` | List session history records |
+| `get(sessionId)` | Get session metadata |
+| `readMessages(sessionId)` | Read persisted messages |
+| `getAccumulatedUsage(sessionId)` | Read accumulated token/cost usage |
+| `update(sessionId, updates)` | Update prompt/title/metadata |
+| `abort(sessionId, reason?)` | Abort active work |
+| `stop(sessionId)` | Stop session |
+| `delete(sessionId)` | Delete session |
+| `restore(input)` | Restore from checkpoint |
+| `dispose(reason?)` | Dispose runtime resources |
+
+## Automation API
+
+When `automation` is enabled, use `cline.automation` to start/stop automation services, reconcile specs, ingest events, and list events/specs/runs.
diff --git a/docs/sdk/reference/events.mdx b/docs/sdk/reference/events.mdx
new file mode 100644
index 0000000..ac57855
--- /dev/null
+++ b/docs/sdk/reference/events.mdx
@@ -0,0 +1,75 @@
+---
+title: "Events"
+sidebarTitle: "Events"
+description: "Reference for SDK event surfaces."
+---
+
+The SDK exposes multiple event surfaces.
+
+## AgentRuntimeEvent
+
+Direct `AgentRuntime` usage emits low-level runtime events through `agent.subscribe(listener)`.
+
+```typescript
+const unsubscribe = agent.subscribe((event) => {
+  console.log(event.type)
+})
+```
+
+Common runtime events include model events, tool execution events, run lifecycle events, and failure events. Runtime results use `AgentRunResult.status` rather than `finishReason`.
+
+## AgentEvent
+
+Core/host-facing agent events are emitted through `AgentConfig.onEvent` and core adapters.
+
+| Event | Description |
+|-------|-------------|
+| `content_start` | Text/reasoning/tool content begins |
+| `content_update` | Tool progress update |
+| `content_end` | Text/reasoning/tool content completes |
+| `iteration_start` | Loop iteration begins |
+| `iteration_end` | Loop iteration completes |
+| `usage` | Token/cost usage update |
+| `notice` | Runtime status/recovery notice |
+| `done` | Agent completed/aborted/failed |
+| `error` | Error occurred |
+
+## Done Event
+
+```typescript
+interface AgentDoneEvent {
+  type: "done"
+  reason: "completed" | "max_iterations" | "aborted" | "mistake_limit" | "error"
+  text: string
+  iterations: number
+  usage?: LegacyAgentUsage
+}
+```
+
+## Usage Event
+
+```typescript
+interface AgentUsageEvent {
+  type: "usage"
+  inputTokens: number
+  outputTokens: number
+  cacheReadTokens?: number
+  cacheWriteTokens?: number
+  cost?: number
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalCacheReadTokens?: number
+  totalCacheWriteTokens?: number
+  totalCost?: number
+}
+```
+
+## CoreSessionEvent
+
+`ClineCore.subscribe(listener, options?)` emits session-level events from the runtime host.
+
+```typescript
+const unsubscribe = cline.subscribe((event) => {
+  console.log(event.type, event.sessionId)
+}, { sessionId })
+```
diff --git a/docs/sdk/reference/gateway.mdx b/docs/sdk/reference/gateway.mdx
new file mode 100644
index 0000000..aeb235e
--- /dev/null
+++ b/docs/sdk/reference/gateway.mdx
@@ -0,0 +1,106 @@
+---
+title: "Gateway"
+sidebarTitle: "Gateway"
+description: "API reference for the LLM provider gateway in @cline/llms."
+---
+
+`DefaultGateway` creates provider-backed `AgentModel` instances and exposes provider/model catalog helpers.
+
+```typescript
+import { DefaultGateway, createGateway } from "@cline/llms"
+```
+
+## Constructor
+
+```typescript
+const gateway = new DefaultGateway({
+  providerConfigs: [
+    { providerId: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY },
+  ],
+})
+```
+
+Or:
+
+```typescript
+const gateway = createGateway({ providerConfigs: [...] })
+```
+
+## Methods
+
+### `registerProvider(registration)`
+
+```typescript
+gateway.registerProvider(registration)
+```
+
+Registers a `GatewayProviderRegistration`.
+
+### `configureProvider(config)`
+
+```typescript
+gateway.configureProvider({
+  providerId: "anthropic",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+})
+```
+
+Configures credentials/defaults for a provider.
+
+### `listProviders()`
+
+```typescript
+const providers = gateway.listProviders()
+```
+
+Returns registered provider manifests.
+
+### `listModels(providerId?)`
+
+```typescript
+const allModels = gateway.listModels()
+const anthropicModels = gateway.listModels("anthropic")
+```
+
+Returns model metadata.
+
+### `createAgentModel(selection, options?)`
+
+```typescript
+const model = gateway.createAgentModel({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+})
+```
+
+Returns an `AgentModel` that can be passed to `AgentRuntime`.
+
+### `stream(request)`
+
+```typescript
+const stream = await gateway.stream({
+  providerId: "anthropic",
+  modelId: "claude-sonnet-4-6",
+  messages,
+  tools: [],
+})
+```
+
+Returns `AsyncIterable<AgentModelEvent>`.
+
+## Registry Helpers
+
+`@cline/llms` also exports:
+
+- `getAllProviders`
+- `getProviderIds`
+- `getProvider`
+- `getModelsForProvider`
+- `registerProvider`
+- `registerModel`
+- `createHandler`
+- `createHandlerAsync`
+
+## Built-In Provider Families
+
+The runtime includes built-in registrations for provider families including Anthropic, OpenAI, Gemini, Vertex, Bedrock, Mistral, Claude Code, OpenAI Codex, OpenCode, Dify, and OpenAI-compatible providers.
diff --git a/docs/sdk/reference/tools-api.mdx b/docs/sdk/reference/tools-api.mdx
new file mode 100644
index 0000000..3646e7d
--- /dev/null
+++ b/docs/sdk/reference/tools-api.mdx
@@ -0,0 +1,86 @@
+---
+title: "Tools API"
+sidebarTitle: "Tools API"
+description: "API reference for creating and configuring tools."
+---
+
+## `createTool(config)`
+
+```typescript
+import { createTool } from "@cline/sdk"
+```
+
+Creates a typed tool. Also re-exported from `@cline/agents` and `@cline/core`.
+
+```typescript
+const tool = createTool({
+  name: "get_current_time",
+  description: "Return the current time as ISO string.",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (_input, context) => {
+    return { now: new Date().toISOString() }
+  },
+})
+```
+
+`inputSchema` can be either JSON Schema or a Zod schema.
+
+## AgentTool
+
+```typescript
+interface AgentTool<TInput = unknown, TOutput = unknown> {
+  name: string
+  description: string
+  inputSchema: Record<string, unknown>
+  execute: (input: TInput, context: AgentToolContext, onChange?: (update: unknown) => void) => Promise<TOutput>
+  timeoutMs?: number
+  retryable?: boolean
+  maxRetries?: number
+}
+```
+
+Defaults from `createTool`:
+
+| Field | Default |
+|-------|---------|
+| `timeoutMs` | `30000` |
+| `retryable` | `true` |
+| `maxRetries` | `3` |
+
+## AgentToolContext
+
+```typescript
+interface AgentToolContext {
+  agentId: string
+  conversationId: string
+  iteration: number
+  abortSignal?: AbortSignal
+  metadata?: Record<string, unknown>
+}
+```
+
+## ToolPolicy
+
+```typescript
+interface ToolPolicy {
+  enabled?: boolean
+  autoApprove?: boolean
+}
+```
+
+Tool names not listed in a policy map default to enabled and auto-approved.
+
+## ToolCallRecord
+
+```typescript
+interface ToolCallRecord {
+  id: string
+  name: string
+  input: unknown
+  output: unknown
+  error?: string
+  durationMs: number
+  startedAt: Date
+  endedAt: Date
+}
+```
diff --git a/docs/sdk/reference/types.mdx b/docs/sdk/reference/types.mdx
new file mode 100644
index 0000000..9fd9cd5
--- /dev/null
+++ b/docs/sdk/reference/types.mdx
@@ -0,0 +1,89 @@
+---
+title: "Types"
+sidebarTitle: "Types"
+description: "Common SDK type surfaces."
+---
+
+Most common types are exported from `@cline/shared`; runtime entry-point packages re-export selected helpers.
+
+## AgentRuntime Types
+
+```typescript
+import type {
+  AgentMessage,
+  AgentMessagePart,
+  AgentRunResult,
+  AgentRuntimeEvent,
+  AgentRuntimeStateSnapshot,
+  AgentUsage,
+} from "@cline/sdk"
+```
+
+`AgentRunResult` is returned by direct `AgentRuntime` / `Agent` runs:
+
+```typescript
+interface AgentRunResult {
+  agentId: string
+  agentRole?: string
+  runId: string
+  status: "completed" | "aborted" | "failed"
+  iterations: number
+  outputText: string
+  messages: readonly AgentMessage[]
+  usage: AgentUsage
+  error?: Error
+}
+```
+
+## Host-Facing Agent Types
+
+```typescript
+import type {
+  AgentConfig,
+  AgentEvent,
+  AgentResult,
+  AgentPlugin,
+  AgentTool,
+  AgentToolContext,
+  ToolPolicy,
+} from "@cline/sdk"
+```
+
+`AgentResult` is the host/core-facing result shape:
+
+```typescript
+interface AgentResult {
+  text: string
+  usage: LegacyAgentUsage
+  messages: MessageWithMetadata[]
+  toolCalls: ToolCallRecord[]
+  iterations: number
+  finishReason: "completed" | "max_iterations" | "aborted" | "mistake_limit" | "error"
+  model: { id: string; provider: string; info?: ModelInfo }
+  startedAt: Date
+  endedAt: Date
+  durationMs: number
+}
+```
+
+## ClineCore Types
+
+```typescript
+import type {
+  ClineCoreOptions,
+  ClineCoreStartInput,
+  CoreSessionConfig,
+  SessionRecord,
+} from "@cline/sdk"
+```
+
+## Tool Types
+
+```typescript
+interface ToolPolicy {
+  enabled?: boolean
+  autoApprove?: boolean
+}
+```
+
+See [Tools API](/sdk/reference/tools-api) for the full tool surface.
diff --git a/docs/sdk/tools.mdx b/docs/sdk/tools.mdx
new file mode 100644
index 0000000..cb94e91
--- /dev/null
+++ b/docs/sdk/tools.mdx
@@ -0,0 +1,141 @@
+---
+title: "Tools"
+sidebarTitle: "Tools"
+description: "Tools let agents read, write, search, call APIs, and run domain-specific actions."
+---
+
+Tools are functions the model can call during execution. Tools consist of a name, description, and schema which the SDK sends to the model. Then the model can direct the SDK to execute tool functions and send results back into the conversation.
+
+## Built-In Tools
+
+`ClineCore` can enable the built-in tool suite:
+
+| Tool | Description |
+|------|-------------|
+| `read_files` | Read one or more files |
+| `search_codebase` | Search the workspace |
+| `run_commands` | Execute shell commands |
+| `fetch_web_content` | Fetch web content |
+| `apply_patch` | Apply patch/diff edits |
+| `editor` | Edit files |
+| `skills` | Invoke configured skills |
+| `ask_question` | Ask the user for input |
+| `submit_and_exit` | Submit a final answer and stop |
+
+<Note>
+  If you need more control you can use the `Agents` package directly. This does not include built-in tools. You pass in only the tools you want when constructing the agent.
+</Note>
+
+## Custom Tools with createTool
+
+One of the most powerful features of the SDK is the ability to create and register custom tools. This allows you to add and share capabilities that are context efficient and behave deterministically because they are implemented in code rather than prompts.
+
+### Quick Example
+
+Use `createTool` with a zod schema for type-safe tools:
+
+```typescript
+import { createTool } from "@cline/sdk"
+import { z } from "zod"
+
+const searchDatabase = createTool({
+  name: "search_database",
+  description: "Search the application database. Returns matching records as JSON.",
+  inputSchema: z.object({
+    query: z.string().describe("Search query"),
+    limit: z.number().optional().describe("Maximum results to return"),
+  }),
+  async execute(input) {
+    const results = await db.search(input.query, input.limit ?? 10)
+    return { results, count: results.length }
+  },
+})
+```
+
+`createTool` also accepts raw JSON Schema if you prefer:
+
+```typescript
+const searchDatabase = createTool({
+  name: "search_database",
+  description: "Search the application database.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Search query" },
+      limit: { type: "number", description: "Maximum results to return" },
+    },
+    required: ["query"],
+  },
+  async execute(input) {
+    return await db.search(input.query, input.limit ?? 10)
+  },
+})
+```
+
+For complete examples of tools in action, see the [cli-agent](https://github.com/cline/cline/tree/main/apps/examples/cli-agent) (shell tool) and [code-review-bot](https://github.com/cline/cline/tree/main/apps/examples/code-review-bot) (multiple tools with completion lifecycle).
+
+For a full tutorial, see [Creating Custom Tools](/sdk/guides/creating-custom-tools). For exact types, see [Tools API](/sdk/reference/tools-api).
+
+## Registering Tools
+
+With `ClineCore`, custom tools are passed as `extraTools` in session config:
+
+```typescript
+await cline.start({
+  prompt: "Analyze customer records",
+  config: {
+    // ...
+    extraTools: [searchDatabase],
+  },
+})
+```
+
+With `Agent`, you pass all tools into the constructor:
+
+```typescript
+const agent = new Agent({
+  tools: [searchDatabase, myOtherTool],
+  // ...
+})
+```
+
+Tools are more easily shared via plugins/extensions:
+
+```typescript
+const plugin: AgentPlugin = {
+  name: "database-tools",
+  manifest: { capabilities: ["tools"] },
+  setup(api) {
+    api.registerTool(searchDatabase)
+  },
+}
+```
+See [Plugins](/sdk/plugins) for more info.
+
+## Tool Policies
+
+You can control how tools are used through Tool Policies. These control whether a tool is visible and whether it requires approval.
+
+```typescript
+const agent = new Agent({
+  tools: [readTool, writeTool, deleteTool],
+  toolPolicies: {
+    read_data: { autoApprove: true },
+    write_data: { autoApprove: false },
+    delete_data: { enabled: false },
+  },
+  // ...
+})
+```
+
+| Policy | Effect |
+|--------|--------|
+| `{ autoApprove: true }` | Run without asking |
+| `{ autoApprove: false }` | Ask before running |
+| `{ enabled: false }` | Hide/disable the tool |
+
+Tool names not listed in `toolPolicies` default to enabled and auto-approved.
+
+## MCP Tools
+
+Tools work along side MCP. `ClineCore` can load MCP settings through its runtime/config extension path. MCP tools are registered alongside built-in and custom tools when MCP support is enabled for the session.
diff --git a/docs/styles.css b/docs/styles.css
new file mode 100644
index 0000000..97fe786
--- /dev/null
+++ b/docs/styles.css
@@ -0,0 +1,93 @@
+/* Custom styles for Cline documentation */
+
+/* Import Geist Sans font from Google Fonts */
+@import url("https://fonts.googleapis.com/css2?family=Geist+Sans:wght@300;400;500;600;700&display=swap");
+
+/* Import Geist Mono font from Google Fonts */
+@import url("https://fonts.googleapis.com/css2?family=Geist+Mono:wght@300;400;500;600;700&display=swap");
+
+/* Apply Geist Sans to body text, but not headings or code */
+body,
+p,
+li,
+td,
+th,
+span:not(code *),
+div:not(code *):not(pre *) {
+	font-family:
+		"Geist Sans", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif !important;
+}
+
+/* Ensure code blocks use Geist Mono */
+code,
+pre,
+.code,
+pre code,
+code *,
+pre * {
+	font-family: "Geist Mono", "Monaco", "Courier New", monospace !important;
+}
+
+/* Make h1 titles lighter in font weight */
+h1 {
+	font-weight: 600 !important;
+}
+
+/* Keep headings and images at full opacity */
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+img {
+	opacity: 1 !important;
+	font-family:
+		"Geist Sans", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif !important;
+}
+
+/* Also apply to any h1 elements within content areas */
+.content h1,
+.markdown h1,
+article h1,
+main h1 {
+	font-weight: 500 !important;
+}
+
+/* JetBrains logo visibility fix for dark mode */
+/* Add a subtle background and border to ensure visibility in both light and dark modes */
+img[alt="JetBrains logo"] {
+	background-color: rgba(255, 255, 255, 0.9);
+	border: 1px solid rgba(0, 0, 0, 0.1);
+	border-radius: 8px;
+	padding: 12px;
+	transition: all 0.3s ease;
+}
+
+/* Dark mode specific styling */
+[data-theme="dark"] img[alt="JetBrains logo"],
+.dark img[alt="JetBrains logo"] {
+	background-color: rgba(255, 255, 255, 0.95);
+	border: 1px solid rgba(0, 0, 0, 0.2);
+	box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* Media query for system dark mode preference */
+@media (prefers-color-scheme: dark) {
+	img[alt="JetBrains logo"] {
+		background-color: rgba(255, 255, 255, 0.95);
+		border: 1px solid rgba(0, 0, 0, 0.2);
+		box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+	}
+}
+
+/* Hover effect for better interactivity */
+img[alt="JetBrains logo"]:hover {
+	transform: scale(1.02);
+	box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+/* Reduce list margin-top */
+.steps {
+	margin-top: 5px !important;
+}
diff --git a/docs/tools-reference/all-cline-tools.mdx b/docs/tools-reference/all-cline-tools.mdx
new file mode 100644
index 0000000..4e53581
--- /dev/null
+++ b/docs/tools-reference/all-cline-tools.mdx
@@ -0,0 +1,77 @@
+---
+title: "Tools"
+sidebarTitle: "Tools"
+description: "Reference for Cline's built-in tool system, aligned with SDK tool architecture."
+---
+
+Cline tools are executable functions the model can call while working. The model decides which tool to call, Cline runs it, then returns results back to the model.
+
+## Built-In Tools (ClineCore)
+
+When running through `ClineCore`, these built-ins are available:
+
+| Tool | Description |
+|------|-------------|
+| `bash` | Execute shell commands |
+| `editor` | View and edit files |
+| `read_files` | Batch read multiple files |
+| `apply_patch` | Apply unified diffs to files |
+| `search` | Ripgrep-powered codebase search |
+| `fetch_web` | HTTP requests with HTML-to-markdown conversion |
+| `ask_question` | Ask the user for input |
+
+<Note>
+`Agent` from `@cline/agents` does not include built-ins by default. You provide tools explicitly.
+</Note>
+
+## Tool Categories
+
+- **Codebase operations**: `editor`, `read_files`, `apply_patch`, `search`
+- **Execution**: `bash`
+- **External retrieval**: `fetch_web`
+- **Human-in-the-loop controls**: `ask_question`
+
+## Approval and Policy Controls
+
+Cline can run tools with approval or auto-approval, depending on settings/policies. Typical patterns:
+
+- Require approval for risky tools (for example `bash`, write/edit operations)
+- Auto-approve low-risk tools (for example read/search operations)
+- Disable specific tools entirely when needed
+
+For policy examples, see [SDK Tools](/sdk/tools) and [Permission Handling](/sdk/guides/permission-handling).
+
+## MCP Tools
+
+Cline can also call tools discovered from MCP servers configured in `.cline/mcp.json`.
+
+MCP tools are loaded alongside built-ins, so Cline can use both local tools and external integrations in one task.
+
+See [MCP Overview](/mcp/mcp-overview) and [SDK Tools → MCP Tools](/sdk/tools#mcp-tools).
+
+## Custom Tools
+
+<Warning>
+  This feature currently only applies to Cline SDK, CLI, and Kanban. This feature is not applicable on VSCode and JetBrains Extension for now.
+</Warning>
+
+Beyond built-ins and MCP, you can create custom tools and add them through plugins.
+
+- Define tool behavior and input schema in plugin code
+- Register tools during plugin setup
+- Expose those tools to agents alongside built-ins
+
+See:
+- [SDK Plugins](/sdk/plugins)
+- [Writing Plugins (examples)](/sdk/guides/writing-plugins)
+- [SDK Tools: Creating Custom Tools](/sdk/tools#creating-custom-tools)
+
+## Legacy Tool Names vs Current Runtime Tools
+
+Some older docs/examples reference XML-style names like `read_file`, `replace_in_file`, or `execute_command`. Current SDK/ClineCore runtime uses the built-in tool names listed above (`read_files`, `apply_patch`, `bash`, etc.).
+
+## Related
+
+- [SDK Tools](/sdk/tools)
+- [Tools API Reference](/sdk/reference/tools-api)
+- [MCP Overview](/mcp/mcp-overview)
diff --git a/docs/troubleshooting/networking-and-proxies.mdx b/docs/troubleshooting/networking-and-proxies.mdx
new file mode 100644
index 0000000..1b4f453
--- /dev/null
+++ b/docs/troubleshooting/networking-and-proxies.mdx
@@ -0,0 +1,229 @@
+---
+title: "Networking and Proxies"
+sidebarTitle: "Networking & Proxies"
+description: "Configure Cline to work behind firewalls and proxies"
+---
+
+If you're working behind a corporate proxy or firewall, you'll need to configure
+proxy settings for Cline to connect to AI providers. The configuration varies
+depending on which version of Cline you're using.
+
+## VSCode Extension
+
+The VSCode extension automatically uses VSCode's built-in proxy settings. See
+[Network Connections in Visual Studio Code, Proxy server support](https://code.visualstudio.com/docs/setup/network#_proxy-server-support)
+for instructions on how to set up proxies in VSCode. No additional configuration
+is needed for Cline itself.
+
+## CLI
+
+The Cline CLI uses standard HTTP proxy environment variables. Configure these before running `cline` commands.
+
+### Basic Configuration
+
+**Windows (Command Prompt)**
+```cmd
+set https_proxy=http://proxy.company.com:8080
+set http_proxy=http://proxy.company.com:8080
+cline start
+```
+
+**Windows (PowerShell)**
+```powershell
+$env:https_proxy="http://proxy.company.com:8080"
+$env:http_proxy="http://proxy.company.com:8080"
+cline start
+```
+
+**macOS/Linux**
+```bash
+export https_proxy=http://proxy.company.com:8080
+export http_proxy=http://proxy.company.com:8080
+cline start
+```
+
+### Proxy with Authentication
+
+If your proxy requires authentication, include credentials in the URL:
+
+```bash
+export https_proxy=http://username:password@proxy.company.com:8080
+export http_proxy=http://username:password@proxy.company.com:8080
+```
+
+<Warning>
+Storing credentials in environment variables can be a security risk.
+</Warning>
+
+### Bypass Proxy for Localhost
+
+To prevent localhost traffic from going through the proxy, set the `no_proxy` environment variable:
+
+**Windows**
+```cmd
+set no_proxy=localhost,127.0.0.1,.local
+```
+
+**macOS/Linux**
+```bash
+export no_proxy=localhost,127.0.0.1,.local
+```
+
+### Custom Certificate Authority
+
+If your proxy uses a custom CA certificate:
+
+**Windows**
+```cmd
+set NODE_EXTRA_CA_CERTS=C:\path\to\ca-certificate.crt
+cline start
+```
+
+**macOS/Linux**
+```bash
+export NODE_EXTRA_CA_CERTS=/path/to/ca-certificate.pem
+cline start
+```
+
+### Permanent Configuration
+
+To avoid setting these variables every time, add them to your shell profile or system environment variables.
+
+**macOS/Linux** (add to `~/.bashrc`, `~/.zshrc`, or `~/.profile`):
+```bash
+# Proxy configuration
+export https_proxy=http://proxy.company.com:8080
+export http_proxy=http://proxy.company.com:8080
+export no_proxy=localhost,127.0.0.1,.local
+export NODE_EXTRA_CA_CERTS=/path/to/ca-certificate.pem
+```
+
+**Windows** (System Environment Variables):
+1. Search for "Environment Variables" in Windows Settings
+2. Add the variables under "User variables" or "System variables"
+3. Restart your terminal or IDE
+
+### Known Limitations
+
+Cline CLI only supports HTTP proxies. It does not support SOCKS proxies,
+proxy autoconfiguration (PAC) scripts, or HTTP proxies which require
+authentication beyond a basic username and password.
+
+## JetBrains IDEs
+
+The JetBrains plugin uses the IDE's HTTP proxy settings.
+
+### Configure JetBrains Proxy
+
+1. Open Settings/Preferences:
+   - **Windows/Linux**: File > Settings
+   - **macOS**: IntelliJ IDEA > Preferences
+   - Or press `Ctrl+Alt+S` (Windows/Linux) or `Cmd+,` (macOS)
+
+2. Navigate to:
+   ```
+   Appearance & Behavior > System Settings > HTTP Proxy
+   ```
+
+3. Select "Manual proxy configuration"
+
+4. Configure your proxy:
+   - **Host name**: `proxy.company.com`
+   - **Port number**: `8080`
+   - **No proxy for**: `localhost,127.0.0.1`
+   - Check "Proxy authentication" if required
+   - Enter your username and password
+
+5. Click "Check connection" to verify the settings
+
+6. Click "OK" to apply
+
+7. Restart the IDE
+
+### Test Connection
+
+After configuring the proxy, test that Cline can connect to your AI provider:
+
+1. Open the Cline panel
+2. Try sending a simple message
+3. If connection fails, check the IDE's Event Log for error messages
+
+### Custom Certificate Authority
+
+If your proxy uses a custom CA:
+
+1. Add the certificate to your system's trust store, or
+2. Import it into the JetBrains IDE:
+   - Settings > Tools > Server Certificates
+   - Click "+" to add your certificate
+
+### Known Limitations
+
+Cline in JetBrains only supports HTTP proxies. It does not support SOCKS
+proxies, proxy autoconfiguration (PAC) scripts, or HTTP proxies which require
+authentication beyond a basic username and password.
+
+Cline does not pick up changed proxy settings dynamically. After changing proxy
+settings, restart the IDE for Cline to use the new settings.
+
+## Troubleshooting
+
+### Connection Timeouts
+
+If you're experiencing connection timeouts:
+
+1. Verify your proxy address and port are correct
+2. Check if the proxy requires authentication
+3. Ensure the AI provider's API endpoints aren't blocked by your firewall
+
+### SSL/TLS Certificate Errors
+
+If you see certificate-related errors:
+
+1. Check that `NODE_EXTRA_CA_CERTS` points to the correct certificate file
+2. Ensure the certificate file is in PEM format
+3. Use curl to verify the certificate works, for example, `curl -x proxy.corp.example:8080 --cacert /path/to/ca-cert.pem -o - -vv https://api.cline.bot/`
+4. Consider disabling `http.proxyStrictSSL` in VSCode (not recommended for production)
+
+### Testing Proxy Configuration
+
+If you encounter problems with Cline networking, first verify your proxy
+configuration works using curl:
+
+```bash
+# Linux/macOS
+export https_proxy=http://proxy.company.com:8080
+curl -vv https://api.anthropic.com
+
+# Windows PowerShell
+$env:https_proxy="http://proxy.company.com:8080"
+curl.exe -vv https://api.anthropic.com
+```
+
+Use `--cacert $NODE_EXTRA_CA_CERTS` to specify a certificate if necessary.
+
+Next, check ~/.cline/cline-core-service.log (CLI, JetBrains) for log messages
+confirming your proxy configuration and any network-related errors.
+
+## Common Proxy Patterns
+
+### Authenticated HTTPS Proxy
+
+```bash
+export https_proxy=http://username:password@proxy.company.com:8080
+export NODE_EXTRA_CA_CERTS=/path/to/ca-cert.pem
+```
+
+### Proxy with No Authentication
+
+```bash
+export https_proxy=http://proxy.company.com:8080
+export http_proxy=http://proxy.company.com:8080
+```
+
+### Proxy with Bypass Rules
+
+```bash
+export https_proxy=http://proxy.company.com:8080
+export no_proxy=localhost,127.0.0.1,.company.local,192.168.0.0/16
+```
diff --git a/docs/usage/cli-overview.mdx b/docs/usage/cli-overview.mdx
new file mode 100644
index 0000000..f0feafd
--- /dev/null
+++ b/docs/usage/cli-overview.mdx
@@ -0,0 +1,163 @@
+---
+title: "CLI Overview"
+sidebarTitle: "CLI Overview"
+description: "Use Cline CLI for interactive terminal sessions and automated headless workflows."
+---
+
+## Prerequisites
+
+- Cline CLI installed (install via `npm i -g cline`)
+- Provider authenticated (`cline auth`) — use the Cline Provider, ClinePass, or your own provider key ([Authorization Guide](/getting-started/authorizing-with-cline#cli-setup))
+
+## Quick Start
+
+```bash
+# Interactive session
+cline
+
+# Run one task immediately
+cline "refactor this module to use async/await"
+
+# Structured output for scripts
+cline --json "list TODO comments"
+```
+
+## Headless mode
+
+Use headless mode for scripts/automation and processable output.
+
+Headless is triggered when using flags like `--json`, when stdin is piped, or when output is redirected.
+
+#### When headless activates
+
+| Invocation | Reason |
+|---|---|
+| `cline --json "task"` | JSON output mode |
+| `cat file \| cline "task"` | stdin is piped |
+| `cline "task" > output.txt` | stdout is redirected |
+
+```bash
+# CI/script style execution
+git diff | cline "review these changes"
+
+# JSON for parsing
+cline --json "summarize this changelog" | jq -r '.text'
+```
+
+See: [Headless Mode](#headless-mode)
+
+### Autonomous execution
+
+For fully unattended runs, use auto-approval:
+
+```bash
+cline --auto-approve true "run tests and fix failures"
+```
+
+Mode selection also works in headless runs:
+
+```bash
+# plan-first
+cline -p "design migration plan"
+
+# act immediately (default)
+cline "apply migration"
+```
+
+<Warning>
+Autonomous execution can modify files and run commands without further prompts. Use a clean branch and review results.
+</Warning>
+
+## High-Value Commands
+
+```bash
+cline --help
+cline <command> --help
+```
+
+| Command | Purpose |
+|---|---|
+| `cline` | Start interactive mode or run a prompt |
+| `cline auth` | Authenticate and set provider/model |
+| `cline config` | Open the interactive config view |
+| `cline mcp` | Manage MCP servers |
+| `cline doctor` | Diagnose/fix configuration issues |
+| `cline history` | Show and manage task history |
+| `cline schedule` | Manage scheduled tasks |
+| `cline hub` | Manage local hub daemon |
+| `cline kanban` | Launch Kanban app |
+
+## Most-Used Global Flags
+
+Source of truth: [CLI Reference](/cli/cli-reference)
+
+| Flag | Purpose |
+|---|---|
+| `-p, --plan` | Start in Plan mode |
+| `--auto-approve <boolean>` | Global tool auto-approval (`true`/`false`, default `true`) |
+| `-m, --model <model>` | Override model for this run |
+| `-P, --provider <id>` | Override provider for this run |
+| `-c, --cwd <path>` | Set working directory |
+| `--config <dir>` | Use config directory |
+| `--data-dir <dir>` | Use isolated local state |
+| `--json` | Output newline-delimited JSON messages |
+| `--thinking <level>` | Set reasoning effort: `none\|low\|medium\|high\|xhigh` (default `medium`) |
+| `-t, --timeout <seconds>` | Set task timeout |
+
+## Automation Patterns
+
+### Pipe context in
+
+```bash
+cat README.md | cline "summarize key setup steps"
+git diff | cline "review for potential regressions"
+```
+
+### Chain tasks
+
+```bash
+git diff | cline "explain these changes" | cline "write a commit message"
+```
+
+### Restrict command execution
+
+```bash
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *"], "deny": ["rm -rf *", "sudo *"]}'
+```
+
+### Include images in tasks
+
+```bash
+cline -i "fix the layout issue shown in @./screenshot.png"
+
+# or reference inline
+cline "fix the UI shown in @./design-mockup.png"
+```
+
+### Set execution timeout
+
+```bash
+cline --timeout 600 "run full test suite"
+```
+
+## JSON Output Schema
+
+When using `--json`, each line is a JSON message object.
+
+```json
+{"type":"say","text":"I'll create the file now.","ts":1760501486669,"say":"text"}
+```
+
+| Field | Type | Description |
+|---|---|---|
+| `type` | `"ask"` or `"say"` | Message category |
+| `text` | `string` | Message content |
+| `ts` | `number` | Unix timestamp in milliseconds |
+| `say` | `string` | Subtype when `type` is `"say"` |
+| `ask` | `string` | Subtype when `type` is `"ask"` |
+| `reasoning` | `string` | Optional model reasoning |
+| `partial` | `boolean` | Streaming flag |
+
+## Next Steps
+
+- [CLI Reference](/cli/cli-reference)
\ No newline at end of file
diff --git a/docs/usage/ide.mdx b/docs/usage/ide.mdx
new file mode 100644
index 0000000..9d840bc
--- /dev/null
+++ b/docs/usage/ide.mdx
@@ -0,0 +1,262 @@
+---
+title: "IDE"
+sidebarTitle: "IDE"
+description: "Use Cline in your IDE to build a working todo app and learn the core workflow."
+---
+
+## Prerequisites
+
+Before starting, make sure you have:
+
+- Cline installed in your editor ([Install Guide](/getting-started/installing-cline))
+- An AI model connected ([Model Setup](/getting-started/authorizing-with-cline))
+
+If you haven't done these yet, complete them first and come back here.
+
+## Step 1: Open a Project Folder
+
+Cline needs a workspace, which is a folder on your computer where it can create and edit files. You'll open an empty folder so Cline has a clean place to build your todo app.
+
+<Tabs>
+  <Tab title="VS Code / Cursor / Windsurf">
+    1. Go to **File → Open Folder** in the top menu bar
+    2. Create a new folder on your computer (for example, name it `todo-app` on your Desktop)
+    3. Select that folder and click **Open**
+
+    Your editor should now show the folder name in the top of the sidebar on the left. The file explorer (left panel) will be empty since the folder is new.
+  </Tab>
+  <Tab title="JetBrains">
+    1. Go to **File → Open** in the top menu bar
+    2. Create a new folder on your computer (for example, name it `todo-app` on your Desktop)
+    3. Select that folder and click **OK**
+
+    Your editor should now show the folder name in the Project panel on the left. It will be empty since the folder is new.
+  </Tab>
+</Tabs>
+
+<Warning>
+If you skip this step and don't have a folder open, Cline won't know where to create files. Always open a folder before starting a task.
+</Warning>
+
+## Step 2: Open the Cline Panel
+
+The Cline panel is a chat interface where you communicate with Cline. You need to open it before you can give Cline any instructions.
+
+<Tabs>
+  <Tab title="VS Code / Cursor / Windsurf">
+    Look at the **Activity Bar**, the vertical strip of icons on the far left (or far right) of your editor. Find the **Cline icon** (it looks like a small robot) and click it.
+
+    A panel will open showing the Cline chat interface. You'll see:
+    - A **text input box** at the bottom where you type messages
+    - A **chat area** above it where Cline's responses will appear
+    - A **settings gear icon** in the top-right corner of the panel
+
+    <Tip>
+    **Can't find the Cline icon?** Open the Command Palette with `Cmd+Shift+P` (Mac) or `Ctrl+Shift+P` (Windows/Linux), type **"Cline: Open In New Tab"**, and press Enter. This opens Cline in a full editor tab, which also gives it more screen space.
+    </Tip>
+  </Tab>
+  <Tab title="JetBrains">
+    Go to **View → Tool Windows → Cline** in the top menu bar. The Cline panel will open on the right side of your editor.
+
+    You'll see:
+    - A **text input box** at the bottom where you type messages
+    - A **chat area** above it where Cline's responses will appear
+    - A **settings gear icon** in the top-right corner of the panel
+  </Tab>
+</Tabs>
+
+## Step 3: Give Cline a Task
+
+Now you'll tell Cline what to build. You communicate with Cline by typing messages in the text input box, just like a chat app.
+
+1. **Click on the text input box** at the bottom of the Cline panel
+2. **Paste (or type) the following prompt** into the text input box:
+
+```text
+Build a todo app in a single HTML file. Include:
+- Input field to add new tasks
+- List that displays all tasks
+- Checkbox to mark tasks complete (with strikethrough styling)
+- Button to delete individual tasks
+- Clean, modern design with CSS
+- All JavaScript inline in the same file
+```
+
+3. **Press Enter** on your keyboard (or click the **Send** button) to send the message
+
+Cline will now read your message and start working on a response. You'll see text appearing in the chat area as Cline thinks through your request.
+
+## Step 4: Understand Plan Mode vs Act Mode
+
+When Cline receives your task, it may start in one of two modes. Look at the **bottom of the Cline panel**. You'll see a toggle button that says either **"Plan"** or **"Act"**.
+
+### If Cline is in Plan Mode
+
+In Plan mode, Cline **only talks**. It analyzes your request and discusses the approach, but it does **not** create or modify any files. You'll see Cline describe what it plans to build, but nothing will change in your project folder yet.
+
+This is useful for complex tasks where you want to discuss the approach first. You can:
+- Ask Cline questions about its plan
+- Suggest changes to the approach
+- Clarify your requirements
+
+**When you're ready for Cline to start writing code**, click the toggle button at the bottom of the panel to switch from **"Plan"** to **"Act"**. Cline will then begin proposing actual file changes.
+
+### If Cline is in Act Mode
+
+In Act mode, Cline will start creating files and writing code right away (but it still asks for your approval before making any changes, see the next step).
+
+<Note>
+For this tutorial, you want to be in **Act mode** so Cline creates the todo app. If you see "Plan" at the bottom, click it to switch to "Act". Learn more about when to use each mode in the [Plan and Act guide](/core-workflows/plan-and-act).
+</Note>
+
+## Step 5: Approve the Changes
+
+Cline **never** modifies your files without your permission. Before creating or editing any file, Cline will show you exactly what it wants to do and wait for you to approve.
+
+Here's what you'll see in the chat:
+
+1. **Cline proposes a file change.** You'll see a section in the chat showing the file path (e.g., `index.html`) and the code Cline wants to write. New lines of code are highlighted in **green**.
+
+2. **Approve or Reject buttons appear.** Directly below the proposed change, you'll see two buttons:
+   - **Approve** (checkmark): Click this to let Cline create or edit the file. The file will be written to your project folder.
+   - **Reject** (X): Click this to stop Cline and provide different instructions instead.
+
+3. **Click Approve** to let Cline create the `index.html` file.
+
+After you approve, Cline writes the file to your project folder. You should see `index.html` appear in your editor's file explorer (the left panel).
+
+<Note>
+Every file creation, file edit, and terminal command requires your explicit approval. You are always in control of what changes in your project. Once you're comfortable with Cline, you can enable [auto-approve](/features/auto-approve) to skip confirmations for specific actions.
+</Note>
+
+## Step 6: View Any Created App
+
+With the previous prompt, Cline has created the `index.html` file in your project folder. Now let's open it in a web browser to see the app.
+
+<Tabs>
+  <Tab title="macOS">
+    **Option A: Use the terminal**
+
+    If Cline ran a terminal command to open the file, it may have already opened. Otherwise, you can open a terminal in your editor (`` Ctrl+` `` or **Terminal → New Terminal** from the menu) and type:
+    ```bash
+    open index.html
+    ```
+
+    **Option B: Use Finder**
+
+    Right-click `index.html` in your editor's file explorer (left panel) and select **"Reveal in Finder"**. Then double-click the file in Finder to open it in your default browser.
+  </Tab>
+  <Tab title="Windows">
+    **Option A: Use the terminal**
+
+    Open a terminal in your editor (`` Ctrl+` `` or **Terminal → New Terminal** from the menu) and type:
+    ```bash
+    start index.html
+    ```
+
+    **Option B: Use File Explorer**
+
+    Right-click `index.html` in your editor's file explorer (left panel) and select **"Reveal in File Explorer"**. Then double-click the file to open it in your default browser.
+  </Tab>
+  <Tab title="Linux">
+    **Option A: Use the terminal**
+
+    Open a terminal in your editor (`` Ctrl+` `` or **Terminal → New Terminal** from the menu) and type:
+    ```bash
+    xdg-open index.html
+    ```
+
+    **Option B: Use your file manager**
+
+    Right-click `index.html` in your editor's file explorer (left panel) and select **"Open Containing Folder"**. Then double-click the file to open it in your default browser.
+  </Tab>
+</Tabs>
+
+**Option C: Live Server (any OS)**
+
+If you have the Live Server extension installed in VS Code, right-click `index.html` in the file explorer and select **"Open with Live Server"**. This opens the app in your browser and automatically refreshes when files change.
+
+Try out your new todo app: add a few tasks, check them off, and delete them. The app runs entirely in your browser with no server or backend needed.
+
+## Step 7: Iterate on Your Project
+
+One of Cline's most powerful features is that it remembers your entire conversation. You can ask for changes and Cline will modify the existing code rather than starting over.
+
+**In the same Cline chat** (don't start a new conversation), click the text input box at the bottom and type a follow-up request. Here are some ideas to try:
+
+**Add persistence:**
+```text
+Add local storage so tasks persist when I refresh the page
+```
+
+**Change the design:**
+```text
+Switch to a dark theme with purple accent colors
+```
+
+**Add a feature:**
+```text
+Add a filter to show all, active, or completed tasks
+```
+
+When you send a follow-up message, Cline will:
+1. Read your current `index.html` file to understand the existing code
+2. Propose specific changes (shown as a diff with green for added lines and red for removed lines)
+3. Wait for your approval before modifying the file
+
+Click **Approve** to apply the changes, then refresh your browser to see the updated app.
+
+## Step 8: Undo Mistakes with Checkpoints
+
+Cline automatically saves a **checkpoint** after each change it makes. If something breaks or you don't like a modification, you can go back to any previous state.
+
+### How to find checkpoints
+
+Scroll through your conversation in the Cline panel. Next to each step where Cline made a change, you'll see two small buttons:
+
+- **Compare**: Click this to see exactly what files changed at that step (a before/after diff)
+- **Restore**: Click this to roll back your project to how it was at that point
+
+### How to restore
+
+When you click **Restore**, you'll see three options:
+
+| Option | What it does | When to use it |
+|--------|--------------|----------------|
+| **Restore Task and Workspace** | Resets both your files and conversation to that point | You want to completely go back and start over from that step |
+| **Restore Task Only** | Keeps your current files but reverts the conversation context | Rarely needed |
+| **Restore Workspace Only** | Resets files to that point but keeps the full conversation | You want to try a different approach but keep the conversation history |
+
+**Recommended for beginners:** Use **"Restore Workspace Only"** when you want to undo a change but keep chatting with Cline about what to do differently.
+
+<Tip>
+Checkpoints are separate from Git. They won't affect your commits, branches, or any version control you have set up.
+</Tip>
+
+Learn more in the [Checkpoints guide](/core-workflows/checkpoints).
+
+## What You Learned
+
+You just completed the core Cline workflow:
+
+1. **Opened a project folder** so Cline has a workspace
+2. **Opened the Cline panel** and typed a task in the chat input
+3. **Understood Plan vs Act mode** and how to switch between them
+4. **Approved file changes** before Cline wrote anything to disk
+5. **Iterated** by sending follow-up messages in the same conversation
+6. **Used checkpoints** to undo mistakes and try different approaches
+
+These same patterns work for any project, from simple scripts to full applications. The more context you give Cline about what you want, the better the results.
+
+## Next Steps
+
+- [Core Workflows](/core-workflows/task-management): Learn the patterns you'll use daily with Cline
+- [Working with Files](/core-workflows/working-with-files): Use `@` mentions to reference files, folders, and URLs in your prompts
+- [Cline Provider](/getting-started/cline-provider): Fastest setup with built-in authentication and unified billing
+- [Cline Rules](/customization/cline-rules): Customize how Cline behaves in your projects
+
+## Need Help?
+
+- **Start a fresh conversation**: Type `/new` in the chat input to begin a new task
+- **Report issues**: Use `/reportbug` to help us improve
+- **Get support**: Join our [Discord community](https://discord.gg/cline)
diff --git a/docs/usage/kanban.mdx b/docs/usage/kanban.mdx
new file mode 100644
index 0000000..cefff86
--- /dev/null
+++ b/docs/usage/kanban.mdx
@@ -0,0 +1,50 @@
+---
+title: "Kanban"
+sidebarTitle: "Overview"
+description: "Use Cline Kanban to run multiple coding agents in parallel with isolated git worktrees."
+---
+
+<Warning>
+Kanban is a **research preview**. Some features described here use experimental capabilities. Expect changes.
+</Warning>
+
+## Prerequisites
+
+- Node.js 18+
+- A git repository (run from repo root)
+- Kanban launcher available (`npx kanban`)
+
+## Quick Start
+
+```bash
+cd /path/to/your/repo
+npx kanban
+```
+
+This starts a local server and opens the board in your browser.
+
+## Core Workflow
+
+1. **Create tasks** on the board (manually or from sidebar chat).
+2. **Start tasks** with play — each card gets an isolated git worktree + terminal.
+3. **Monitor progress** from card status and latest agent output.
+4. **Review diffs** in card detail view and leave inline comments.
+5. **Ship changes** via Commit or Open PR.
+6. **Clean up** by moving cards to trash (worktrees are removed).
+
+## Key Capabilities
+
+- **Parallel execution:** each task runs in a separate worktree to avoid conflicts.
+- **Task linking:** dependency chains can auto-start next tasks.
+- **Inline review loop:** comment directly on diff lines to steer agent work.
+- **Auto-commit / Auto-PR:** optional automation from settings.
+- **Sidebar chat orchestration:** ask an agent to break work into cards and start flows.
+
+## Agent Compatibility
+
+Kanban is designed for CLI-style coding agents and currently works with Cline CLI, Claude Code, Codex, OpenCode, and related runtimes available in settings.
+
+## Next Steps
+
+- [Kanban Core Workflow](/kanban/core-workflow)
+- [Kanban Remote Access](/kanban/remote-access)
\ No newline at end of file
diff --git a/docs/usage/tui.mdx b/docs/usage/tui.mdx
new file mode 100644
index 0000000..817752f
--- /dev/null
+++ b/docs/usage/tui.mdx
@@ -0,0 +1,51 @@
+---
+title: "TUI"
+sidebarTitle: "TUI"
+description: "Use Cline's terminal UI (TUI) for interactive coding workflows in your terminal."
+---
+
+## What is the TUI?
+
+The TUI is Cline's interactive terminal interface. It is designed for conversational, in-terminal work: ask questions, review plans, approve actions, and iterate quickly.
+
+## Prerequisites
+
+Install the CLI:
+
+```bash
+npm install -g cline
+```
+
+## Launch the TUI
+
+```bash
+# default interactive launch
+cline
+
+# explicit TUI mode
+cline -i
+```
+
+## Core TUI Actions
+
+- `Tab` to toggle Plan/Act
+- `Shift+Tab` to toggle auto-approve all
+- `Ctrl+C` to abort a running turn; press again to exit
+- `Ctrl+D` to exit when the prompt is empty and idle
+- `Ctrl+L` to clear the chat view or current conversation
+- `/settings`, `/model`, `/account`, `/mcp`, `/compact`, `/undo`, `/clear`, `/history`, `/help`, `/quit`
+- `@file` mentions for workspace context
+
+The status area shows the active model, context usage, cost, workspace/branch, git diff stats, Plan/Act state, and whether auto-approve all is enabled.
+
+## When to Use TUI vs Headless
+
+- Use **TUI** when you want collaboration and approvals.
+- Use **headless** (`--json`, piped stdin/stdout, CI scripts) for automation.
+
+See: [CLI Headless Mode](/usage/cli-overview#headless-mode)
+
+## Next Steps
+
+- [CLI Overview](/usage/cli-overview)
+- [CLI Reference](/cli/cli-reference)
\ No newline at end of file
diff --git a/evals/.gitignore b/evals/.gitignore
new file mode 100644
index 0000000..0d4a823
--- /dev/null
+++ b/evals/.gitignore
@@ -0,0 +1,29 @@
+repositories
+temp-files
+results
+
+# Tool precision - results and databases
+benchmarks/tool-precision/replace-in-file/results/
+benchmarks/tool-precision/replace-in-file/*.db
+benchmarks/tool-precision/replace-in-file/*.db-wal
+benchmarks/tool-precision/replace-in-file/*.db-shm
+
+# Tool precision - private test cases (from real sessions)
+# Public/synthetic cases (example-*.json) ARE committed
+benchmarks/tool-precision/replace-in-file/cases/private-*.json
+benchmarks/tool-precision/replace-in-file/cases/session-*.json
+
+# Legacy paths (kept for backwards compatibility)
+diff-edits/cases/
+diff-edits/results/
+diff_editing/test_cases/
+diff_editing/test_outputs/
+diff-edits/cases.zip
+
+# Environment variables
+.env
+
+# Python bytecode cache
+*__pycache__/
+
+.cache
diff --git a/evals/ARCHITECTURE.md b/evals/ARCHITECTURE.md
new file mode 100644
index 0000000..53981fa
--- /dev/null
+++ b/evals/ARCHITECTURE.md
@@ -0,0 +1,263 @@
+# Cline Evals Architecture
+
+> Note: Smoke tests (Layer 2) are partially disabled while the eval framework is repointed at the new SDK CLI. The scenarios under `evals/smoke-tests/` are preserved and `npm run eval:smoke:run` still works against whatever `cline` is on `$PATH` (install with `npm i -g cline`). The old build-and-link helpers and the auto-running `cline-evals-regression.yml` workflow are off until someone wires the build step at the new SDK CLI.
+
+## Overview
+
+The evals system provides multi-layered testing for Cline's AI capabilities.
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           TESTING PYRAMID                                   │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│                              ┌─────────┐                                    │
+│                             /   E2E    \         Layer 3: Full Agent        │
+│                            /  cline-   \         - Real coding tasks        │
+│                           /   bench     \        - Harbor execution         │
+│                          /_______________\       - Nightly runs             │
+│                                                                             │
+│                        ┌───────────────────┐                                │
+│                       /    Smoke Tests     \     Layer 2: Provider          │
+│                      /   run-smoke-tests    \    - 5 curated scenarios      │
+│                     /    (cline provider)    \   - 3 models via Vercel      │
+│                    /_________________________\   - pass@k metrics           │
+│                                                                             │
+│              ┌─────────────────────────────────┐                            │
+│             /        Contract Tests            \  Layer 1: Unit             │
+│            /   thinking-traces.test.ts          \ - No LLM calls            │
+│           /    tool-parsing.test.ts              \ - Fast, deterministic    │
+│          /______________________________________ \ - API format validation  │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+## Directory Structure
+
+```
+evals/
+├── ARCHITECTURE.md          # This file
+├── README.md                # Quick start guide
+│
+├── analysis/                # Shared metrics & reporting
+│   └── src/
+│       ├── metrics.ts       # pass@k, pass^k, flakiness calculations
+│       └── cli.ts           # Analysis CLI
+│
+├── smoke-tests/             # Layer 2: Provider smoke tests
+│   ├── run-smoke-tests.ts   # Main runner
+│   ├── README.md            # Usage docs
+│   ├── scenarios/           # Test definitions
+│   │   ├── 01-create-file/
+│   │   │   ├── config.json  # Prompt, expected files/content
+│   │   │   ├── template/    # Initial files (if any)
+│   │   │   └── workspace/   # Working dir (cleaned each run)
+│   │   ├── 02-edit-file/
+│   │   ├── 03-read-summarize/
+│   │   ├── 04-multi-file/
+│   │   └── 05-typescript-function/
+│   └── results/             # Generated outputs
+│       ├── latest -> 2026-01-27T.../  # Symlink to most recent
+│       └── 2026-01-27T19-50-54-391Z/
+│           ├── report.json  # Full results
+│           ├── summary.md   # CI-friendly markdown
+│           └── 01-create-file/
+│               └── claude-sonnet/
+│                   ├── trial-1.log           # CLI stdout/stderr
+│                   └── workspace-trial-1/    # Kept for failures only
+│
+├── e2e/                     # Layer 3: Full agent E2E
+│   ├── run-cline-bench.ts   # Harbor runner
+│   └── README.md
+│
+└── cline-bench/             # Git submodule with real coding tasks
+    └── tasks/               # SWE-bench style problems
+```
+
+## Smoke Test Workflow
+
+```
+┌──────────────────────────────────────────────────────────────────────────────┐
+│                         SMOKE TEST EXECUTION FLOW                            │
+└──────────────────────────────────────────────────────────────────────────────┘
+
+ npm run eval:smoke:run
+        │
+        ▼
+┌───────────────────┐
+│ Load scenarios    │  Read config.json from each scenarios/* dir
+│ from disk         │
+└────────┬──────────┘
+         │
+         ▼
+┌───────────────────┐
+│ Create results    │  evals/smoke-tests/results/2026-01-27T.../
+│ directory         │
+└────────┬──────────┘
+         │
+         ▼
+┌───────────────────────────────────────────────────────────────┐
+│                    FOR EACH SCENARIO                          │
+│  ┌─────────────────────────────────────────────────────────┐  │
+│  │                  FOR EACH MODEL                         │  │
+│  │  ┌───────────────────────────────────────────────────┐  │  │
+│  │  │           RUN 3 TRIALS SEQUENTIALLY               │  │  │
+│  │  │                                                   │  │  │
+│  │  │  Trial 1 ──► Trial 2 ──► Trial 3 ──► Results      │  │  │
+│  │  │  (Sequential - Cline instance handles one at a time)  │  │
+│  │  │                                                   │  │  │
+│  │  │  Each trial:                                      │  │  │
+│  │  │  1. Create workspace-trial-N/                     │  │  │
+│  │  │  2. Copy template files (if any)                  │  │  │
+│  │  │  3. Run: cline -y -o "prompt"                     │  │  │
+│  │  │  4. Verify expected files exist                   │  │  │
+│  │  │  5. Verify expected content                       │  │  │
+│  │  │  6. Save trial-N.log                              │  │  │
+│  │  │  7. If failed, copy workspace to results/         │  │  │
+│  │  └───────────────────────────────────────────────────┘  │  │
+│  │                         │                               │  │
+│  │                         ▼                               │  │
+│  │  ┌───────────────────────────────────────────────────┐  │  │
+│  │  │ Calculate metrics: pass@1, pass@3, pass^3, flaky  │  │  │
+│  │  └───────────────────────────────────────────────────┘  │  │
+│  └─────────────────────────────────────────────────────────┘  │
+└───────────────────────────────────────────────────────────────┘
+         │
+         ▼
+┌───────────────────┐
+│ Generate outputs  │
+│ - report.json     │
+│ - summary.md      │
+│ - latest symlink  │
+└───────────────────┘
+```
+
+## Models Tested
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    CLINE PROVIDER ROUTING                       │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│   ┌─────────────┐                                               │
+│   │ Smoke Test  │                                               │
+│   │   Runner    │                                               │
+│   └──────┬──────┘                                               │
+│          │                                                      │
+│          │  cline -y -o "prompt" --model <model>                │
+│          │                                                      │
+│          ▼                                                      │
+│   ┌─────────────┐                                               │
+│   │   Cline     │                                               │
+│   │  Provider   │ ◄─── Uses your Cline auth (cline auth)        │
+│   └──────┬──────┘                                               │
+│          │                                                      │
+│          │ Routes to backend                                    │
+│          ▼                                                      │
+│   ┌─────────────────────────────────────────────────────────┐   │
+│   │                   Default Models                        │   │
+│   ├─────────────────────────────────────────────────────────┤   │
+│   │  claude-sonnet-4-20250514                               │   │
+│   │  gpt-4o                                                 │   │
+│   │  gemini-2.5-pro-preview-06-05                           │   │
+│   └─────────────────────────────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Metrics Explained
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        METRICS                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  pass@k   "What's the probability of getting at least one      │
+│            success if I run k trials?"                          │
+│                                                                 │
+│            Example: 2/3 trials pass → pass@3 ≈ 96%              │
+│            (Very likely to pass if you run 3 times)             │
+│                                                                 │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  pass^k   "What's the probability of ALL k trials succeeding?" │
+│                                                                 │
+│            Example: 2/3 trials pass → pass^3 ≈ 30%              │
+│            (Only 30% chance all 3 would pass)                   │
+│                                                                 │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  Status   PASS  = All trials passed                             │
+│           FLAKY = Some passed, some failed                      │
+│           FAIL  = All trials failed                             │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Quick Commands
+
+```bash
+# Run all smoke tests (all models, 3 trials each)
+npm run eval:smoke:run
+
+# Run single model (use exact model ID for reproducibility)
+npm run eval:smoke:run -- --model claude-sonnet-4-20250514
+
+# Run single scenario
+npm run eval:smoke:run -- --scenario 01-create-file
+
+# Quick check (1 trial)
+npm run eval:smoke:run -- --trials 1
+
+# View latest results
+cat evals/smoke-tests/results/latest/summary.md
+
+# Debug a failure
+cat evals/smoke-tests/results/latest/<scenario>/<model>/trial-1.log
+ls evals/smoke-tests/results/latest/<scenario>/<model>/workspace-trial-1/
+```
+
+## CI Integration
+
+Smoke test CI is temporarily disabled. `.github/workflows/cline-evals-regression.yml` was removed until the build step is repointed at the new SDK CLI.
+
+### Viewing CI Results
+
+1. **Job Summary**: Each run posts results to the Actions tab
+2. **Artifacts**: Full results downloadable as `smoke-test-results-<run_id>`
+
+### Running CI-like Tests Locally
+
+```bash
+# Use an installed or locally linked cline binary
+npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1
+```
+
+### Re-enabling CI
+
+The old workflow built the legacy CLI from `cli/`. Re-enable it only after replacing that build step with the SDK CLI under `apps/cli`.
+
+## Contract Tests (Layer 1)
+
+> **Note**: The old `evals/benchmarks/tool-precision/` tests have been removed. Their functionality is now covered by contract tests in `src/core/**/__tests__/` and the 52 system prompt snapshot tests that run with `npm run test:unit`.
+
+Located in `src/core/api/transform/__tests__/`:
+
+```
+thinking-traces.test.ts
+├── convertToOpenAiMessages preserves reasoning_details
+├── convertToAnthropicMessage preserves thinking blocks
+└── sanitizeGeminiMessages handles provider-specific cleaning
+
+tool-parsing.test.ts
+├── Anthropic tool_use → OpenAI tool_calls conversion
+├── Tool call ID truncation (>40 chars)
+├── OpenAI Responses API ID transformation
+└── Tool result matching
+```
+
+Run with:
+```bash
+npm run test:unit -- --grep "Thinking Trace"  # 9 tests
+npm run test:unit -- --grep "Tool Call"       # 11 tests
+```
diff --git a/evals/README.md b/evals/README.md
new file mode 100644
index 0000000..4827c61
--- /dev/null
+++ b/evals/README.md
@@ -0,0 +1,152 @@
+# Cline Evaluation Framework
+
+A layered testing system for measuring Cline's performance at different levels.
+
+> Note: Smoke tests (Layer 2) are partially disabled while the eval framework is repointed at the new SDK CLI. The scenarios under `evals/smoke-tests/` are preserved and `npm run eval:smoke:run` still works against whatever `cline` is on `$PATH` (install with `npm i -g cline`). The old build-and-link helpers and the auto-running `cline-evals-regression.yml` workflow are off until someone wires the build step at the new SDK CLI.
+
+## Directory Structure
+
+```
+evals/
+├── smoke-tests/           # Quick provider validation (minutes)
+│   ├── run-smoke-tests.ts
+│   └── scenarios/         # 5 curated test scenarios
+│
+├── e2e/                   # Full E2E with cline-bench (hours)
+│   └── run-cline-bench.ts
+│
+├── cline-bench/           # Real-world tasks (git submodule)
+│   └── tasks/             # 12 production bug fixes
+│
+├── analysis/              # Metrics and reporting framework
+│   ├── src/
+│   │   ├── metrics.ts     # pass@k, pass^k calculations
+│   │   ├── classifier.ts  # Failure pattern matching
+│   │   └── reporters/     # Markdown, JSON output
+│   └── patterns/
+│       └── cline-failures.yaml
+│
+└── baselines/             # Performance baselines for regression detection
+```
+
+## Test Layers
+
+### Layer 1: Contract Tests (Unit)
+
+Location: `src/core/api/transform/__tests__/`
+
+Tests API transform logic without LLM calls:
+- Thinking trace preservation
+- Tool call parsing (XML, native formats)
+- Provider format conversions
+
+```bash
+npm run test:unit -- --grep "Thinking\|Tool Call"
+```
+
+### Layer 2: Smoke Tests (Minutes)
+
+Location: `evals/smoke-tests/`
+
+Quick validation across providers with real LLM calls:
+- 5 curated scenarios
+- 3 trials per test for pass@k metrics
+- Runs the `cline` CLI with `--config`, `-y`, `-t`, and `-m`
+
+```bash
+# Set API key (Cline provider)
+export CLINE_API_KEY=sk-...
+
+# Run smoke tests
+npm run eval:smoke:run
+
+# Run specific scenario
+npm run eval:smoke:run -- --scenario 01-create-file
+
+# Run with specific model (overrides per-scenario models)
+npm run eval:smoke:run -- --model anthropic/claude-sonnet-4.5
+```
+
+### Layer 3: E2E Tests (Hours)
+
+Location: `evals/e2e/` + `evals/cline-bench/`
+
+Full agent tests on production-grade tasks:
+- 12 real-world coding problems
+- Docker/Daytona execution via Harbor
+- Nightly CI runs
+
+```bash
+# Prerequisites: Python 3.13, Harbor, Docker
+npm run eval:e2e
+
+# Specific task
+npm run eval:e2e -- --tasks discord
+
+# Different provider
+npm run eval:e2e -- --provider openai --model gpt-4o
+```
+
+## Metrics
+
+The framework calculates:
+
+| Metric | Formula | Interpretation |
+|--------|---------|----------------|
+| **pass@k** | P(≥1 of k passes) | Solution finding capability |
+| **pass^k** | P(all k pass) | Reliability |
+| **Flakiness** | Entropy of pass rate | Consistency |
+
+With 3 trials:
+- All pass → `pass` (reliable)
+- All fail → `fail` (broken)
+- Mixed → `flaky` (needs investigation)
+
+## CI Integration
+
+- Current PR gate: contract tests only
+- Smoke test CI: temporarily disabled while the workflow is repointed at the SDK CLI
+- Nightly: E2E tests with cline-bench are not yet implemented, see TODO
+
+## Quick Start
+
+```bash
+# Run all fast tests
+npm run test:unit
+npm run eval:smoke:run
+
+# Run E2E (requires setup)
+cd evals/cline-bench
+# Follow README.md for Harbor setup
+npm run eval:e2e
+```
+
+## Adding Tests
+
+### Smoke Test Scenario
+
+1. Create `evals/smoke-tests/scenarios/<name>/config.json`
+2. Add optional `template/` directory with starting files
+3. Run to verify: `npm run eval:smoke:run -- --scenario <name>`
+
+### Contract Test
+
+1. Add to `src/core/api/transform/__tests__/`
+2. Run: `npm run test:unit -- --grep "YourTest"`
+
+### E2E Task
+
+Contribute to [cline/cline-bench](https://github.com/cline/cline-bench)
+
+## Resources
+
+- [cline-bench tasks](evals/cline-bench/README.md)
+- [Smoke test scenarios](evals/smoke-tests/README.md)
+
+## TODO
+
+- [ ] **Nightly E2E CI**: Add scheduled workflow for cline-bench tests
+  - Requires: Docker runner, Harbor setup, ~1-2 hour timeout
+  - Should run on schedule (e.g., nightly) not per-PR
+  - Separate secrets for E2E environment
+- [ ] **Native tool calling smoke tests**: Add CLI support for `native_tool_call_enabled` setting to test Claude 4 with native tools
diff --git a/evals/analysis/package-lock.json b/evals/analysis/package-lock.json
new file mode 100644
index 0000000..4da7794
--- /dev/null
+++ b/evals/analysis/package-lock.json
@@ -0,0 +1 @@
+{"name":"@cline/analysis","version":"1.0.0","lockfileVersion":3,"requires":true,"packages":{"":{"name":"@cline/analysis","version":"1.0.0","dependencies":{"chalk":"^5.0.0","commander":"^12.0.0","js-yaml":"^4.1.0"},"devDependencies":{"@types/js-yaml":"^4.0.0","@types/node":"^20.0.0","tsx":"^4.0.0","typescript":"^5.0.0","vitest":"^1.0.0"}},"node_modules/@esbuild/aix-ppc64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz","integrity":"sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==","cpu":["ppc64"],"dev":true,"license":"MIT","optional":true,"os":["aix"],"engines":{"node":">=18"}},"node_modules/@esbuild/android-arm":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz","integrity":"sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["android"],"engines":{"node":">=18"}},"node_modules/@esbuild/android-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz","integrity":"sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["android"],"engines":{"node":">=18"}},"node_modules/@esbuild/android-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz","integrity":"sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["android"],"engines":{"node":">=18"}},"node_modules/@esbuild/darwin-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz","integrity":"sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["darwin"],"engines":{"node":">=18"}},"node_modules/@esbuild/darwin-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz","integrity":"sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["darwin"],"engines":{"node":">=18"}},"node_modules/@esbuild/freebsd-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz","integrity":"sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["freebsd"],"engines":{"node":">=18"}},"node_modules/@esbuild/freebsd-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz","integrity":"sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["freebsd"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-arm":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz","integrity":"sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz","integrity":"sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-ia32":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz","integrity":"sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==","cpu":["ia32"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-loong64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz","integrity":"sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==","cpu":["loong64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-mips64el":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz","integrity":"sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==","cpu":["mips64el"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-ppc64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz","integrity":"sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==","cpu":["ppc64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-riscv64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz","integrity":"sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==","cpu":["riscv64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-s390x":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz","integrity":"sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==","cpu":["s390x"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/linux-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz","integrity":"sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=18"}},"node_modules/@esbuild/netbsd-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz","integrity":"sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["netbsd"],"engines":{"node":">=18"}},"node_modules/@esbuild/netbsd-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz","integrity":"sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["netbsd"],"engines":{"node":">=18"}},"node_modules/@esbuild/openbsd-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz","integrity":"sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["openbsd"],"engines":{"node":">=18"}},"node_modules/@esbuild/openbsd-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz","integrity":"sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["openbsd"],"engines":{"node":">=18"}},"node_modules/@esbuild/openharmony-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz","integrity":"sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["openharmony"],"engines":{"node":">=18"}},"node_modules/@esbuild/sunos-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz","integrity":"sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["sunos"],"engines":{"node":">=18"}},"node_modules/@esbuild/win32-arm64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz","integrity":"sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["win32"],"engines":{"node":">=18"}},"node_modules/@esbuild/win32-ia32":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz","integrity":"sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==","cpu":["ia32"],"dev":true,"license":"MIT","optional":true,"os":["win32"],"engines":{"node":">=18"}},"node_modules/@esbuild/win32-x64":{"version":"0.27.2","resolved":"https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz","integrity":"sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["win32"],"engines":{"node":">=18"}},"node_modules/@jest/schemas":{"version":"29.6.3","resolved":"https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz","integrity":"sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==","dev":true,"license":"MIT","dependencies":{"@sinclair/typebox":"^0.27.8"},"engines":{"node":"^14.15.0 || ^16.10.0 || >=18.0.0"}},"node_modules/@jridgewell/sourcemap-codec":{"version":"1.5.5","resolved":"https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz","integrity":"sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==","dev":true,"license":"MIT"},"node_modules/@rollup/rollup-android-arm-eabi":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.56.0.tgz","integrity":"sha512-LNKIPA5k8PF1+jAFomGe3qN3bbIgJe/IlpDBwuVjrDKrJhVWywgnJvflMt/zkbVNLFtF1+94SljYQS6e99klnw==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["android"]},"node_modules/@rollup/rollup-android-arm64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.56.0.tgz","integrity":"sha512-lfbVUbelYqXlYiU/HApNMJzT1E87UPGvzveGg2h0ktUNlOCxKlWuJ9jtfvs1sKHdwU4fzY7Pl8sAl49/XaEk6Q==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["android"]},"node_modules/@rollup/rollup-darwin-arm64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.56.0.tgz","integrity":"sha512-EgxD1ocWfhoD6xSOeEEwyE7tDvwTgZc8Bss7wCWe+uc7wO8G34HHCUH+Q6cHqJubxIAnQzAsyUsClt0yFLu06w==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["darwin"]},"node_modules/@rollup/rollup-darwin-x64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.56.0.tgz","integrity":"sha512-1vXe1vcMOssb/hOF8iv52A7feWW2xnu+c8BV4t1F//m9QVLTfNVpEdja5ia762j/UEJe2Z1jAmEqZAK42tVW3g==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["darwin"]},"node_modules/@rollup/rollup-freebsd-arm64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.56.0.tgz","integrity":"sha512-bof7fbIlvqsyv/DtaXSck4VYQ9lPtoWNFCB/JY4snlFuJREXfZnm+Ej6yaCHfQvofJDXLDMTVxWscVSuQvVWUQ==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["freebsd"]},"node_modules/@rollup/rollup-freebsd-x64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.56.0.tgz","integrity":"sha512-KNa6lYHloW+7lTEkYGa37fpvPq+NKG/EHKM8+G/g9WDU7ls4sMqbVRV78J6LdNuVaeeK5WB9/9VAFbKxcbXKYg==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["freebsd"]},"node_modules/@rollup/rollup-linux-arm-gnueabihf":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.56.0.tgz","integrity":"sha512-E8jKK87uOvLrrLN28jnAAAChNq5LeCd2mGgZF+fGF5D507WlG/Noct3lP/QzQ6MrqJ5BCKNwI9ipADB6jyiq2A==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-arm-musleabihf":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.56.0.tgz","integrity":"sha512-jQosa5FMYF5Z6prEpTCCmzCXz6eKr/tCBssSmQGEeozA9tkRUty/5Vx06ibaOP9RCrW1Pvb8yp3gvZhHwTDsJw==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-arm64-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.56.0.tgz","integrity":"sha512-uQVoKkrC1KGEV6udrdVahASIsaF8h7iLG0U0W+Xn14ucFwi6uS539PsAr24IEF9/FoDtzMeeJXJIBo5RkbNWvQ==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-arm64-musl":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.56.0.tgz","integrity":"sha512-vLZ1yJKLxhQLFKTs42RwTwa6zkGln+bnXc8ueFGMYmBTLfNu58sl5/eXyxRa2RarTkJbXl8TKPgfS6V5ijNqEA==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-loong64-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.56.0.tgz","integrity":"sha512-FWfHOCub564kSE3xJQLLIC/hbKqHSVxy8vY75/YHHzWvbJL7aYJkdgwD/xGfUlL5UV2SB7otapLrcCj2xnF1dg==","cpu":["loong64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-loong64-musl":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.56.0.tgz","integrity":"sha512-z1EkujxIh7nbrKL1lmIpqFTc/sr0u8Uk0zK/qIEFldbt6EDKWFk/pxFq3gYj4Bjn3aa9eEhYRlL3H8ZbPT1xvA==","cpu":["loong64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-ppc64-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.56.0.tgz","integrity":"sha512-iNFTluqgdoQC7AIE8Q34R3AuPrJGJirj5wMUErxj22deOcY7XwZRaqYmB6ZKFHoVGqRcRd0mqO+845jAibKCkw==","cpu":["ppc64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-ppc64-musl":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.56.0.tgz","integrity":"sha512-MtMeFVlD2LIKjp2sE2xM2slq3Zxf9zwVuw0jemsxvh1QOpHSsSzfNOTH9uYW9i1MXFxUSMmLpeVeUzoNOKBaWg==","cpu":["ppc64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-riscv64-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.56.0.tgz","integrity":"sha512-in+v6wiHdzzVhYKXIk5U74dEZHdKN9KH0Q4ANHOTvyXPG41bajYRsy7a8TPKbYPl34hU7PP7hMVHRvv/5aCSew==","cpu":["riscv64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-riscv64-musl":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.56.0.tgz","integrity":"sha512-yni2raKHB8m9NQpI9fPVwN754mn6dHQSbDTwxdr9SE0ks38DTjLMMBjrwvB5+mXrX+C0npX0CVeCUcvvvD8CNQ==","cpu":["riscv64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-s390x-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.56.0.tgz","integrity":"sha512-zhLLJx9nQPu7wezbxt2ut+CI4YlXi68ndEve16tPc/iwoylWS9B3FxpLS2PkmfYgDQtosah07Mj9E0khc3Y+vQ==","cpu":["s390x"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-x64-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.56.0.tgz","integrity":"sha512-MVC6UDp16ZSH7x4rtuJPAEoE1RwS8N4oK9DLHy3FTEdFoUTCFVzMfJl/BVJ330C+hx8FfprA5Wqx4FhZXkj2Kw==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-linux-x64-musl":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.56.0.tgz","integrity":"sha512-ZhGH1eA4Qv0lxaV00azCIS1ChedK0V32952Md3FtnxSqZTBTd6tgil4nZT5cU8B+SIw3PFYkvyR4FKo2oyZIHA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["linux"]},"node_modules/@rollup/rollup-openbsd-x64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.56.0.tgz","integrity":"sha512-O16XcmyDeFI9879pEcmtWvD/2nyxR9mF7Gs44lf1vGGx8Vg2DRNx11aVXBEqOQhWb92WN4z7fW/q4+2NYzCbBA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["openbsd"]},"node_modules/@rollup/rollup-openharmony-arm64":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.56.0.tgz","integrity":"sha512-LhN/Reh+7F3RCgQIRbgw8ZMwUwyqJM+8pXNT6IIJAqm2IdKkzpCh/V9EdgOMBKuebIrzswqy4ATlrDgiOwbRcQ==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["openharmony"]},"node_modules/@rollup/rollup-win32-arm64-msvc":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.56.0.tgz","integrity":"sha512-kbFsOObXp3LBULg1d3JIUQMa9Kv4UitDmpS+k0tinPBz3watcUiV2/LUDMMucA6pZO3WGE27P7DsfaN54l9ing==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["win32"]},"node_modules/@rollup/rollup-win32-ia32-msvc":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.56.0.tgz","integrity":"sha512-vSSgny54D6P4vf2izbtFm/TcWYedw7f8eBrOiGGecyHyQB9q4Kqentjaj8hToe+995nob/Wv48pDqL5a62EWtg==","cpu":["ia32"],"dev":true,"license":"MIT","optional":true,"os":["win32"]},"node_modules/@rollup/rollup-win32-x64-gnu":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.56.0.tgz","integrity":"sha512-FeCnkPCTHQJFbiGG49KjV5YGW/8b9rrXAM2Mz2kiIoktq2qsJxRD5giEMEOD2lPdgs72upzefaUvS+nc8E3UzQ==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["win32"]},"node_modules/@rollup/rollup-win32-x64-msvc":{"version":"4.56.0","resolved":"https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.56.0.tgz","integrity":"sha512-H8AE9Ur/t0+1VXujj90w0HrSOuv0Nq9r1vSZF2t5km20NTfosQsGGUXDaKdQZzwuLts7IyL1fYT4hM95TI9c4g==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["win32"]},"node_modules/@sinclair/typebox":{"version":"0.27.8","resolved":"https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz","integrity":"sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==","dev":true,"license":"MIT"},"node_modules/@types/estree":{"version":"1.0.8","resolved":"https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz","integrity":"sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==","dev":true,"license":"MIT"},"node_modules/@types/js-yaml":{"version":"4.0.9","resolved":"https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.9.tgz","integrity":"sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==","dev":true,"license":"MIT"},"node_modules/@types/node":{"version":"20.19.30","resolved":"https://registry.npmjs.org/@types/node/-/node-20.19.30.tgz","integrity":"sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==","dev":true,"license":"MIT","dependencies":{"undici-types":"~6.21.0"}},"node_modules/@vitest/expect":{"version":"1.6.1","resolved":"https://registry.npmjs.org/@vitest/expect/-/expect-1.6.1.tgz","integrity":"sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog==","dev":true,"license":"MIT","dependencies":{"@vitest/spy":"1.6.1","@vitest/utils":"1.6.1","chai":"^4.3.10"},"funding":{"url":"https://opencollective.com/vitest"}},"node_modules/@vitest/runner":{"version":"1.6.1","resolved":"https://registry.npmjs.org/@vitest/runner/-/runner-1.6.1.tgz","integrity":"sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA==","dev":true,"license":"MIT","dependencies":{"@vitest/utils":"1.6.1","p-limit":"^5.0.0","pathe":"^1.1.1"},"funding":{"url":"https://opencollective.com/vitest"}},"node_modules/@vitest/snapshot":{"version":"1.6.1","resolved":"https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.6.1.tgz","integrity":"sha512-WvidQuWAzU2p95u8GAKlRMqMyN1yOJkGHnx3M1PL9Raf7AQ1kwLKg04ADlCa3+OXUZE7BceOhVZiuWAbzCKcUQ==","dev":true,"license":"MIT","dependencies":{"magic-string":"^0.30.5","pathe":"^1.1.1","pretty-format":"^29.7.0"},"funding":{"url":"https://opencollective.com/vitest"}},"node_modules/@vitest/spy":{"version":"1.6.1","resolved":"https://registry.npmjs.org/@vitest/spy/-/spy-1.6.1.tgz","integrity":"sha512-MGcMmpGkZebsMZhbQKkAf9CX5zGvjkBTqf8Zx3ApYWXr3wG+QvEu2eXWfnIIWYSJExIp4V9FCKDEeygzkYrXMw==","dev":true,"license":"MIT","dependencies":{"tinyspy":"^2.2.0"},"funding":{"url":"https://opencollective.com/vitest"}},"node_modules/@vitest/utils":{"version":"1.6.1","resolved":"https://registry.npmjs.org/@vitest/utils/-/utils-1.6.1.tgz","integrity":"sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==","dev":true,"license":"MIT","dependencies":{"diff-sequences":"^29.6.3","estree-walker":"^3.0.3","loupe":"^2.3.7","pretty-format":"^29.7.0"},"funding":{"url":"https://opencollective.com/vitest"}},"node_modules/acorn":{"version":"8.15.0","resolved":"https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz","integrity":"sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==","dev":true,"license":"MIT","bin":{"acorn":"bin/acorn"},"engines":{"node":">=0.4.0"}},"node_modules/acorn-walk":{"version":"8.3.4","resolved":"https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz","integrity":"sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==","dev":true,"license":"MIT","dependencies":{"acorn":"^8.11.0"},"engines":{"node":">=0.4.0"}},"node_modules/ansi-styles":{"version":"5.2.0","resolved":"https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz","integrity":"sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==","dev":true,"license":"MIT","engines":{"node":">=10"},"funding":{"url":"https://github.com/chalk/ansi-styles?sponsor=1"}},"node_modules/argparse":{"version":"2.0.1","resolved":"https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz","integrity":"sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==","license":"Python-2.0"},"node_modules/assertion-error":{"version":"1.1.0","resolved":"https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz","integrity":"sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==","dev":true,"license":"MIT","engines":{"node":"*"}},"node_modules/cac":{"version":"6.7.14","resolved":"https://registry.npmjs.org/cac/-/cac-6.7.14.tgz","integrity":"sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==","dev":true,"license":"MIT","engines":{"node":">=8"}},"node_modules/chai":{"version":"4.5.0","resolved":"https://registry.npmjs.org/chai/-/chai-4.5.0.tgz","integrity":"sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==","dev":true,"license":"MIT","dependencies":{"assertion-error":"^1.1.0","check-error":"^1.0.3","deep-eql":"^4.1.3","get-func-name":"^2.0.2","loupe":"^2.3.6","pathval":"^1.1.1","type-detect":"^4.1.0"},"engines":{"node":">=4"}},"node_modules/chalk":{"version":"5.6.2","resolved":"https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz","integrity":"sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==","license":"MIT","engines":{"node":"^12.17.0 || ^14.13 || >=16.0.0"},"funding":{"url":"https://github.com/chalk/chalk?sponsor=1"}},"node_modules/check-error":{"version":"1.0.3","resolved":"https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz","integrity":"sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==","dev":true,"license":"MIT","dependencies":{"get-func-name":"^2.0.2"},"engines":{"node":"*"}},"node_modules/commander":{"version":"12.1.0","resolved":"https://registry.npmjs.org/commander/-/commander-12.1.0.tgz","integrity":"sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==","license":"MIT","engines":{"node":">=18"}},"node_modules/confbox":{"version":"0.1.8","resolved":"https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz","integrity":"sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==","dev":true,"license":"MIT"},"node_modules/cross-spawn":{"version":"7.0.6","resolved":"https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz","integrity":"sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==","dev":true,"license":"MIT","dependencies":{"path-key":"^3.1.0","shebang-command":"^2.0.0","which":"^2.0.1"},"engines":{"node":">= 8"}},"node_modules/debug":{"version":"4.4.3","resolved":"https://registry.npmjs.org/debug/-/debug-4.4.3.tgz","integrity":"sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==","dev":true,"license":"MIT","dependencies":{"ms":"^2.1.3"},"engines":{"node":">=6.0"},"peerDependenciesMeta":{"supports-color":{"optional":true}}},"node_modules/deep-eql":{"version":"4.1.4","resolved":"https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.4.tgz","integrity":"sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==","dev":true,"license":"MIT","dependencies":{"type-detect":"^4.0.0"},"engines":{"node":">=6"}},"node_modules/diff-sequences":{"version":"29.6.3","resolved":"https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz","integrity":"sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==","dev":true,"license":"MIT","engines":{"node":"^14.15.0 || ^16.10.0 || >=18.0.0"}},"node_modules/esbuild":{"version":"0.27.2","resolved":"https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz","integrity":"sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==","dev":true,"hasInstallScript":true,"license":"MIT","bin":{"esbuild":"bin/esbuild"},"engines":{"node":">=18"},"optionalDependencies":{"@esbuild/aix-ppc64":"0.27.2","@esbuild/android-arm":"0.27.2","@esbuild/android-arm64":"0.27.2","@esbuild/android-x64":"0.27.2","@esbuild/darwin-arm64":"0.27.2","@esbuild/darwin-x64":"0.27.2","@esbuild/freebsd-arm64":"0.27.2","@esbuild/freebsd-x64":"0.27.2","@esbuild/linux-arm":"0.27.2","@esbuild/linux-arm64":"0.27.2","@esbuild/linux-ia32":"0.27.2","@esbuild/linux-loong64":"0.27.2","@esbuild/linux-mips64el":"0.27.2","@esbuild/linux-ppc64":"0.27.2","@esbuild/linux-riscv64":"0.27.2","@esbuild/linux-s390x":"0.27.2","@esbuild/linux-x64":"0.27.2","@esbuild/netbsd-arm64":"0.27.2","@esbuild/netbsd-x64":"0.27.2","@esbuild/openbsd-arm64":"0.27.2","@esbuild/openbsd-x64":"0.27.2","@esbuild/openharmony-arm64":"0.27.2","@esbuild/sunos-x64":"0.27.2","@esbuild/win32-arm64":"0.27.2","@esbuild/win32-ia32":"0.27.2","@esbuild/win32-x64":"0.27.2"}},"node_modules/estree-walker":{"version":"3.0.3","resolved":"https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz","integrity":"sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==","dev":true,"license":"MIT","dependencies":{"@types/estree":"^1.0.0"}},"node_modules/execa":{"version":"8.0.1","resolved":"https://registry.npmjs.org/execa/-/execa-8.0.1.tgz","integrity":"sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==","dev":true,"license":"MIT","dependencies":{"cross-spawn":"^7.0.3","get-stream":"^8.0.1","human-signals":"^5.0.0","is-stream":"^3.0.0","merge-stream":"^2.0.0","npm-run-path":"^5.1.0","onetime":"^6.0.0","signal-exit":"^4.1.0","strip-final-newline":"^3.0.0"},"engines":{"node":">=16.17"},"funding":{"url":"https://github.com/sindresorhus/execa?sponsor=1"}},"node_modules/fsevents":{"version":"2.3.3","resolved":"https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz","integrity":"sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==","dev":true,"hasInstallScript":true,"license":"MIT","optional":true,"os":["darwin"],"engines":{"node":"^8.16.0 || ^10.6.0 || >=11.0.0"}},"node_modules/get-func-name":{"version":"2.0.2","resolved":"https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz","integrity":"sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==","dev":true,"license":"MIT","engines":{"node":"*"}},"node_modules/get-stream":{"version":"8.0.1","resolved":"https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz","integrity":"sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==","dev":true,"license":"MIT","engines":{"node":">=16"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/get-tsconfig":{"version":"4.13.0","resolved":"https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz","integrity":"sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==","dev":true,"license":"MIT","dependencies":{"resolve-pkg-maps":"^1.0.0"},"funding":{"url":"https://github.com/privatenumber/get-tsconfig?sponsor=1"}},"node_modules/human-signals":{"version":"5.0.0","resolved":"https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz","integrity":"sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==","dev":true,"license":"Apache-2.0","engines":{"node":">=16.17.0"}},"node_modules/is-stream":{"version":"3.0.0","resolved":"https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz","integrity":"sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==","dev":true,"license":"MIT","engines":{"node":"^12.20.0 || ^14.13.1 || >=16.0.0"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/isexe":{"version":"2.0.0","resolved":"https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz","integrity":"sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==","dev":true,"license":"ISC"},"node_modules/js-tokens":{"version":"9.0.1","resolved":"https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz","integrity":"sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==","dev":true,"license":"MIT"},"node_modules/js-yaml":{"version":"4.1.1","resolved":"https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz","integrity":"sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==","license":"MIT","dependencies":{"argparse":"^2.0.1"},"bin":{"js-yaml":"bin/js-yaml.js"}},"node_modules/local-pkg":{"version":"0.5.1","resolved":"https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.1.tgz","integrity":"sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==","dev":true,"license":"MIT","dependencies":{"mlly":"^1.7.3","pkg-types":"^1.2.1"},"engines":{"node":">=14"},"funding":{"url":"https://github.com/sponsors/antfu"}},"node_modules/loupe":{"version":"2.3.7","resolved":"https://registry.npmjs.org/loupe/-/loupe-2.3.7.tgz","integrity":"sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==","dev":true,"license":"MIT","dependencies":{"get-func-name":"^2.0.1"}},"node_modules/magic-string":{"version":"0.30.21","resolved":"https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz","integrity":"sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==","dev":true,"license":"MIT","dependencies":{"@jridgewell/sourcemap-codec":"^1.5.5"}},"node_modules/merge-stream":{"version":"2.0.0","resolved":"https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz","integrity":"sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==","dev":true,"license":"MIT"},"node_modules/mimic-fn":{"version":"4.0.0","resolved":"https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz","integrity":"sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==","dev":true,"license":"MIT","engines":{"node":">=12"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/mlly":{"version":"1.8.0","resolved":"https://registry.npmjs.org/mlly/-/mlly-1.8.0.tgz","integrity":"sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==","dev":true,"license":"MIT","dependencies":{"acorn":"^8.15.0","pathe":"^2.0.3","pkg-types":"^1.3.1","ufo":"^1.6.1"}},"node_modules/mlly/node_modules/pathe":{"version":"2.0.3","resolved":"https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz","integrity":"sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==","dev":true,"license":"MIT"},"node_modules/ms":{"version":"2.1.3","resolved":"https://registry.npmjs.org/ms/-/ms-2.1.3.tgz","integrity":"sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==","dev":true,"license":"MIT"},"node_modules/nanoid":{"version":"3.3.11","resolved":"https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz","integrity":"sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==","dev":true,"funding":[{"type":"github","url":"https://github.com/sponsors/ai"}],"license":"MIT","bin":{"nanoid":"bin/nanoid.cjs"},"engines":{"node":"^10 || ^12 || ^13.7 || ^14 || >=15.0.1"}},"node_modules/npm-run-path":{"version":"5.3.0","resolved":"https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz","integrity":"sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==","dev":true,"license":"MIT","dependencies":{"path-key":"^4.0.0"},"engines":{"node":"^12.20.0 || ^14.13.1 || >=16.0.0"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/npm-run-path/node_modules/path-key":{"version":"4.0.0","resolved":"https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz","integrity":"sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==","dev":true,"license":"MIT","engines":{"node":">=12"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/onetime":{"version":"6.0.0","resolved":"https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz","integrity":"sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==","dev":true,"license":"MIT","dependencies":{"mimic-fn":"^4.0.0"},"engines":{"node":">=12"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/p-limit":{"version":"5.0.0","resolved":"https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz","integrity":"sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==","dev":true,"license":"MIT","dependencies":{"yocto-queue":"^1.0.0"},"engines":{"node":">=18"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/path-key":{"version":"3.1.1","resolved":"https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz","integrity":"sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==","dev":true,"license":"MIT","engines":{"node":">=8"}},"node_modules/pathe":{"version":"1.1.2","resolved":"https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz","integrity":"sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==","dev":true,"license":"MIT"},"node_modules/pathval":{"version":"1.1.1","resolved":"https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz","integrity":"sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==","dev":true,"license":"MIT","engines":{"node":"*"}},"node_modules/picocolors":{"version":"1.1.1","resolved":"https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz","integrity":"sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==","dev":true,"license":"ISC"},"node_modules/pkg-types":{"version":"1.3.1","resolved":"https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz","integrity":"sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==","dev":true,"license":"MIT","dependencies":{"confbox":"^0.1.8","mlly":"^1.7.4","pathe":"^2.0.1"}},"node_modules/pkg-types/node_modules/pathe":{"version":"2.0.3","resolved":"https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz","integrity":"sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==","dev":true,"license":"MIT"},"node_modules/postcss":{"version":"8.5.6","resolved":"https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz","integrity":"sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==","dev":true,"funding":[{"type":"opencollective","url":"https://opencollective.com/postcss/"},{"type":"tidelift","url":"https://tidelift.com/funding/github/npm/postcss"},{"type":"github","url":"https://github.com/sponsors/ai"}],"license":"MIT","dependencies":{"nanoid":"^3.3.11","picocolors":"^1.1.1","source-map-js":"^1.2.1"},"engines":{"node":"^10 || ^12 || >=14"}},"node_modules/pretty-format":{"version":"29.7.0","resolved":"https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz","integrity":"sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==","dev":true,"license":"MIT","dependencies":{"@jest/schemas":"^29.6.3","ansi-styles":"^5.0.0","react-is":"^18.0.0"},"engines":{"node":"^14.15.0 || ^16.10.0 || >=18.0.0"}},"node_modules/react-is":{"version":"18.3.1","resolved":"https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz","integrity":"sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==","dev":true,"license":"MIT"},"node_modules/resolve-pkg-maps":{"version":"1.0.0","resolved":"https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz","integrity":"sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==","dev":true,"license":"MIT","funding":{"url":"https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"}},"node_modules/rollup":{"version":"4.56.0","resolved":"https://registry.npmjs.org/rollup/-/rollup-4.56.0.tgz","integrity":"sha512-9FwVqlgUHzbXtDg9RCMgodF3Ua4Na6Gau+Sdt9vyCN4RhHfVKX2DCHy3BjMLTDd47ITDhYAnTwGulWTblJSDLg==","dev":true,"license":"MIT","dependencies":{"@types/estree":"1.0.8"},"bin":{"rollup":"dist/bin/rollup"},"engines":{"node":">=18.0.0","npm":">=8.0.0"},"optionalDependencies":{"@rollup/rollup-android-arm-eabi":"4.56.0","@rollup/rollup-android-arm64":"4.56.0","@rollup/rollup-darwin-arm64":"4.56.0","@rollup/rollup-darwin-x64":"4.56.0","@rollup/rollup-freebsd-arm64":"4.56.0","@rollup/rollup-freebsd-x64":"4.56.0","@rollup/rollup-linux-arm-gnueabihf":"4.56.0","@rollup/rollup-linux-arm-musleabihf":"4.56.0","@rollup/rollup-linux-arm64-gnu":"4.56.0","@rollup/rollup-linux-arm64-musl":"4.56.0","@rollup/rollup-linux-loong64-gnu":"4.56.0","@rollup/rollup-linux-loong64-musl":"4.56.0","@rollup/rollup-linux-ppc64-gnu":"4.56.0","@rollup/rollup-linux-ppc64-musl":"4.56.0","@rollup/rollup-linux-riscv64-gnu":"4.56.0","@rollup/rollup-linux-riscv64-musl":"4.56.0","@rollup/rollup-linux-s390x-gnu":"4.56.0","@rollup/rollup-linux-x64-gnu":"4.56.0","@rollup/rollup-linux-x64-musl":"4.56.0","@rollup/rollup-openbsd-x64":"4.56.0","@rollup/rollup-openharmony-arm64":"4.56.0","@rollup/rollup-win32-arm64-msvc":"4.56.0","@rollup/rollup-win32-ia32-msvc":"4.56.0","@rollup/rollup-win32-x64-gnu":"4.56.0","@rollup/rollup-win32-x64-msvc":"4.56.0","fsevents":"~2.3.2"}},"node_modules/shebang-command":{"version":"2.0.0","resolved":"https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz","integrity":"sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==","dev":true,"license":"MIT","dependencies":{"shebang-regex":"^3.0.0"},"engines":{"node":">=8"}},"node_modules/shebang-regex":{"version":"3.0.0","resolved":"https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz","integrity":"sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==","dev":true,"license":"MIT","engines":{"node":">=8"}},"node_modules/siginfo":{"version":"2.0.0","resolved":"https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz","integrity":"sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==","dev":true,"license":"ISC"},"node_modules/signal-exit":{"version":"4.1.0","resolved":"https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz","integrity":"sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==","dev":true,"license":"ISC","engines":{"node":">=14"},"funding":{"url":"https://github.com/sponsors/isaacs"}},"node_modules/source-map-js":{"version":"1.2.1","resolved":"https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz","integrity":"sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==","dev":true,"license":"BSD-3-Clause","engines":{"node":">=0.10.0"}},"node_modules/stackback":{"version":"0.0.2","resolved":"https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz","integrity":"sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==","dev":true,"license":"MIT"},"node_modules/std-env":{"version":"3.10.0","resolved":"https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz","integrity":"sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==","dev":true,"license":"MIT"},"node_modules/strip-final-newline":{"version":"3.0.0","resolved":"https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz","integrity":"sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==","dev":true,"license":"MIT","engines":{"node":">=12"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}},"node_modules/strip-literal":{"version":"2.1.1","resolved":"https://registry.npmjs.org/strip-literal/-/strip-literal-2.1.1.tgz","integrity":"sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==","dev":true,"license":"MIT","dependencies":{"js-tokens":"^9.0.1"},"funding":{"url":"https://github.com/sponsors/antfu"}},"node_modules/tinybench":{"version":"2.9.0","resolved":"https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz","integrity":"sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==","dev":true,"license":"MIT"},"node_modules/tinypool":{"version":"0.8.4","resolved":"https://registry.npmjs.org/tinypool/-/tinypool-0.8.4.tgz","integrity":"sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==","dev":true,"license":"MIT","engines":{"node":">=14.0.0"}},"node_modules/tinyspy":{"version":"2.2.1","resolved":"https://registry.npmjs.org/tinyspy/-/tinyspy-2.2.1.tgz","integrity":"sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==","dev":true,"license":"MIT","engines":{"node":">=14.0.0"}},"node_modules/tsx":{"version":"4.21.0","resolved":"https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz","integrity":"sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==","dev":true,"license":"MIT","dependencies":{"esbuild":"~0.27.0","get-tsconfig":"^4.7.5"},"bin":{"tsx":"dist/cli.mjs"},"engines":{"node":">=18.0.0"},"optionalDependencies":{"fsevents":"~2.3.3"}},"node_modules/type-detect":{"version":"4.1.0","resolved":"https://registry.npmjs.org/type-detect/-/type-detect-4.1.0.tgz","integrity":"sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==","dev":true,"license":"MIT","engines":{"node":">=4"}},"node_modules/typescript":{"version":"5.9.3","resolved":"https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz","integrity":"sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==","dev":true,"license":"Apache-2.0","bin":{"tsc":"bin/tsc","tsserver":"bin/tsserver"},"engines":{"node":">=14.17"}},"node_modules/ufo":{"version":"1.6.3","resolved":"https://registry.npmjs.org/ufo/-/ufo-1.6.3.tgz","integrity":"sha512-yDJTmhydvl5lJzBmy/hyOAA0d+aqCBuwl818haVdYCRrWV84o7YyeVm4QlVHStqNrrJSTb6jKuFAVqAFsr+K3Q==","dev":true,"license":"MIT"},"node_modules/undici-types":{"version":"6.21.0","resolved":"https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz","integrity":"sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==","dev":true,"license":"MIT"},"node_modules/vite":{"version":"5.4.21","resolved":"https://registry.npmjs.org/vite/-/vite-5.4.21.tgz","integrity":"sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==","dev":true,"license":"MIT","dependencies":{"esbuild":"^0.21.3","postcss":"^8.4.43","rollup":"^4.20.0"},"bin":{"vite":"bin/vite.js"},"engines":{"node":"^18.0.0 || >=20.0.0"},"funding":{"url":"https://github.com/vitejs/vite?sponsor=1"},"optionalDependencies":{"fsevents":"~2.3.3"},"peerDependencies":{"@types/node":"^18.0.0 || >=20.0.0","less":"*","lightningcss":"^1.21.0","sass":"*","sass-embedded":"*","stylus":"*","sugarss":"*","terser":"^5.4.0"},"peerDependenciesMeta":{"@types/node":{"optional":true},"less":{"optional":true},"lightningcss":{"optional":true},"sass":{"optional":true},"sass-embedded":{"optional":true},"stylus":{"optional":true},"sugarss":{"optional":true},"terser":{"optional":true}}},"node_modules/vite-node":{"version":"1.6.1","resolved":"https://registry.npmjs.org/vite-node/-/vite-node-1.6.1.tgz","integrity":"sha512-YAXkfvGtuTzwWbDSACdJSg4A4DZiAqckWe90Zapc/sEX3XvHcw1NdurM/6od8J207tSDqNbSsgdCacBgvJKFuA==","dev":true,"license":"MIT","dependencies":{"cac":"^6.7.14","debug":"^4.3.4","pathe":"^1.1.1","picocolors":"^1.0.0","vite":"^5.0.0"},"bin":{"vite-node":"vite-node.mjs"},"engines":{"node":"^18.0.0 || >=20.0.0"},"funding":{"url":"https://opencollective.com/vitest"}},"node_modules/vite/node_modules/@esbuild/aix-ppc64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz","integrity":"sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==","cpu":["ppc64"],"dev":true,"license":"MIT","optional":true,"os":["aix"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/android-arm":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz","integrity":"sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["android"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/android-arm64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz","integrity":"sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["android"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/android-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz","integrity":"sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["android"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/darwin-arm64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz","integrity":"sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["darwin"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/darwin-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz","integrity":"sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["darwin"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/freebsd-arm64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz","integrity":"sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["freebsd"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/freebsd-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz","integrity":"sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["freebsd"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-arm":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz","integrity":"sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==","cpu":["arm"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-arm64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz","integrity":"sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-ia32":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz","integrity":"sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==","cpu":["ia32"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-loong64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz","integrity":"sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==","cpu":["loong64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-mips64el":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz","integrity":"sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==","cpu":["mips64el"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-ppc64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz","integrity":"sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==","cpu":["ppc64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-riscv64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz","integrity":"sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==","cpu":["riscv64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-s390x":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz","integrity":"sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==","cpu":["s390x"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/linux-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz","integrity":"sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["linux"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/netbsd-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz","integrity":"sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["netbsd"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/openbsd-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz","integrity":"sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["openbsd"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/sunos-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz","integrity":"sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["sunos"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/win32-arm64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz","integrity":"sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==","cpu":["arm64"],"dev":true,"license":"MIT","optional":true,"os":["win32"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/win32-ia32":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz","integrity":"sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==","cpu":["ia32"],"dev":true,"license":"MIT","optional":true,"os":["win32"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/@esbuild/win32-x64":{"version":"0.21.5","resolved":"https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz","integrity":"sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==","cpu":["x64"],"dev":true,"license":"MIT","optional":true,"os":["win32"],"engines":{"node":">=12"}},"node_modules/vite/node_modules/esbuild":{"version":"0.21.5","resolved":"https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz","integrity":"sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==","dev":true,"hasInstallScript":true,"license":"MIT","bin":{"esbuild":"bin/esbuild"},"engines":{"node":">=12"},"optionalDependencies":{"@esbuild/aix-ppc64":"0.21.5","@esbuild/android-arm":"0.21.5","@esbuild/android-arm64":"0.21.5","@esbuild/android-x64":"0.21.5","@esbuild/darwin-arm64":"0.21.5","@esbuild/darwin-x64":"0.21.5","@esbuild/freebsd-arm64":"0.21.5","@esbuild/freebsd-x64":"0.21.5","@esbuild/linux-arm":"0.21.5","@esbuild/linux-arm64":"0.21.5","@esbuild/linux-ia32":"0.21.5","@esbuild/linux-loong64":"0.21.5","@esbuild/linux-mips64el":"0.21.5","@esbuild/linux-ppc64":"0.21.5","@esbuild/linux-riscv64":"0.21.5","@esbuild/linux-s390x":"0.21.5","@esbuild/linux-x64":"0.21.5","@esbuild/netbsd-x64":"0.21.5","@esbuild/openbsd-x64":"0.21.5","@esbuild/sunos-x64":"0.21.5","@esbuild/win32-arm64":"0.21.5","@esbuild/win32-ia32":"0.21.5","@esbuild/win32-x64":"0.21.5"}},"node_modules/vitest":{"version":"1.6.1","resolved":"https://registry.npmjs.org/vitest/-/vitest-1.6.1.tgz","integrity":"sha512-Ljb1cnSJSivGN0LqXd/zmDbWEM0RNNg2t1QW/XUhYl/qPqyu7CsqeWtqQXHVaJsecLPuDoak2oJcZN2QoRIOag==","dev":true,"license":"MIT","dependencies":{"@vitest/expect":"1.6.1","@vitest/runner":"1.6.1","@vitest/snapshot":"1.6.1","@vitest/spy":"1.6.1","@vitest/utils":"1.6.1","acorn-walk":"^8.3.2","chai":"^4.3.10","debug":"^4.3.4","execa":"^8.0.1","local-pkg":"^0.5.0","magic-string":"^0.30.5","pathe":"^1.1.1","picocolors":"^1.0.0","std-env":"^3.5.0","strip-literal":"^2.0.0","tinybench":"^2.5.1","tinypool":"^0.8.3","vite":"^5.0.0","vite-node":"1.6.1","why-is-node-running":"^2.2.2"},"bin":{"vitest":"vitest.mjs"},"engines":{"node":"^18.0.0 || >=20.0.0"},"funding":{"url":"https://opencollective.com/vitest"},"peerDependencies":{"@edge-runtime/vm":"*","@types/node":"^18.0.0 || >=20.0.0","@vitest/browser":"1.6.1","@vitest/ui":"1.6.1","happy-dom":"*","jsdom":"*"},"peerDependenciesMeta":{"@edge-runtime/vm":{"optional":true},"@types/node":{"optional":true},"@vitest/browser":{"optional":true},"@vitest/ui":{"optional":true},"happy-dom":{"optional":true},"jsdom":{"optional":true}}},"node_modules/which":{"version":"2.0.2","resolved":"https://registry.npmjs.org/which/-/which-2.0.2.tgz","integrity":"sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==","dev":true,"license":"ISC","dependencies":{"isexe":"^2.0.0"},"bin":{"node-which":"bin/node-which"},"engines":{"node":">= 8"}},"node_modules/why-is-node-running":{"version":"2.3.0","resolved":"https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz","integrity":"sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==","dev":true,"license":"MIT","dependencies":{"siginfo":"^2.0.0","stackback":"0.0.2"},"bin":{"why-is-node-running":"cli.js"},"engines":{"node":">=8"}},"node_modules/yocto-queue":{"version":"1.2.2","resolved":"https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.2.tgz","integrity":"sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==","dev":true,"license":"MIT","engines":{"node":">=12.20"},"funding":{"url":"https://github.com/sponsors/sindresorhus"}}}}
\ No newline at end of file
diff --git a/evals/analysis/package.json b/evals/analysis/package.json
new file mode 100644
index 0000000..9a5e37a
--- /dev/null
+++ b/evals/analysis/package.json
@@ -0,0 +1,34 @@
+{
+	"name": "@cline/analysis",
+	"version": "1.0.0",
+	"description": "Analysis framework for Cline evaluations with failure classification and metrics",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"start": "tsx src/cli.ts",
+		"build": "tsc",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:ui": "vitest --ui"
+	},
+	"keywords": [
+		"cline",
+		"evaluation",
+		"benchmarking",
+		"ai-testing",
+		"metrics"
+	],
+	"dependencies": {
+		"commander": "^12.0.0",
+		"js-yaml": "^4.1.0",
+		"chalk": "^5.0.0"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"@types/js-yaml": "^4.0.0",
+		"tsx": "^4.0.0",
+		"typescript": "^5.0.0",
+		"vitest": "^1.0.0"
+	}
+}
diff --git a/evals/analysis/patterns/cline-failures.yaml b/evals/analysis/patterns/cline-failures.yaml
new file mode 100644
index 0000000..3e94381
--- /dev/null
+++ b/evals/analysis/patterns/cline-failures.yaml
@@ -0,0 +1,57 @@
+# Cline-specific failure patterns for classification
+# Version 1.0
+
+version: "1.0"
+
+patterns:
+  # Provider-specific bugs (Cline integration issues)
+  - name: "gemini_signature"
+    pattern: "missing.?signature|thoughtSignature"
+    category: "provider_bug"
+    issue: "https://github.com/cline/cline/issues/7974"
+    description: "Gemini 3 Pro requires thoughtSignature for native tool calls"
+
+  - name: "claude_tool_format"
+    pattern: "write_to_file.*missing.*content|content.*parameter.*required"
+    category: "provider_bug"
+    issue: "https://github.com/cline/cline/issues/7998"
+    description: "Claude tool parameter extraction failure"
+
+  # Transient failures (retriable)
+  - name: "rate_limit"
+    pattern: "429|rate.?limit|too.?many.?requests|quota.?exceeded"
+    category: "transient"
+    description: "API rate limiting"
+
+  - name: "network_timeout"
+    pattern: "ECONNREFUSED|ETIMEDOUT|ENOTFOUND|timed.?out"
+    category: "transient"
+    description: "Network connectivity issues"
+
+  - name: "model_overloaded"
+    pattern: "503|service.?unavailable|overloaded"
+    category: "transient"
+    description: "Provider service unavailable"
+
+  # Infrastructure/harness failures
+  - name: "harness_error"
+    pattern: "verifier.*failed|test.*harness.*error|missing.*test.*file"
+    category: "harness"
+    description: "Test harness or verification script failure"
+
+  - name: "environment_failure"
+    pattern: "docker.*failed|container.*exit|OCI.*runtime|pod.*error"
+    category: "environment"
+    description: "Docker/Daytona environment setup failure"
+
+  # Policy/safety failures
+  - name: "safety_refusal"
+    pattern: "content.*policy|safety.*filter|inappropriate.*request"
+    category: "policy"
+    description: "Model refused due to safety/content policy"
+
+  # Auth issues (non-retriable)
+  - name: "auth_error"
+    pattern: "401|unauthorized|invalid.?api.?key"
+    category: "auth"
+    description: "Invalid API credentials"
diff --git a/evals/analysis/src/__tests__/classifier.test.ts b/evals/analysis/src/__tests__/classifier.test.ts
new file mode 100644
index 0000000..5962ffe
--- /dev/null
+++ b/evals/analysis/src/__tests__/classifier.test.ts
@@ -0,0 +1,198 @@
+import { describe, expect, it } from "vitest"
+import { FailureClassifier } from "../classifier"
+
+describe("FailureClassifier", () => {
+	const classifier = new FailureClassifier()
+
+	describe("Provider Bug Detection", () => {
+		it("detects Gemini signature issue", () => {
+			const logs = `
+				Error: Function call is missing a thought_signature in functionCall parts.
+				This is required for tools to work correctly with Gemini 3 Pro...
+			`
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("gemini_signature")
+			expect(failures[0].category).toBe("provider_bug")
+			expect(failures[0].issue_url).toBe("https://github.com/cline/cline/issues/7974")
+		})
+
+		it("detects Claude tool format issue", () => {
+			const logs = `Cline tried to use write_to_file without value for required parameter 'content'`
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("claude_tool_format")
+			expect(failures[0].category).toBe("provider_bug")
+			expect(failures[0].issue_url).toBe("https://github.com/cline/cline/issues/7998")
+		})
+	})
+
+	describe("Transient Failure Detection", () => {
+		it("detects rate limiting", () => {
+			const logs = "Error: 429 Too Many Requests - Rate limit exceeded"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("rate_limit")
+			expect(failures[0].category).toBe("transient")
+		})
+
+		it("detects network timeout", () => {
+			const logs = "Error: ETIMEDOUT - Connection timed out"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("network_timeout")
+			expect(failures[0].category).toBe("transient")
+		})
+
+		it("detects service unavailable", () => {
+			const logs = "503 Service Unavailable - Model is currently overloaded"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("model_overloaded")
+			expect(failures[0].category).toBe("transient")
+		})
+	})
+
+	describe("Infrastructure Failure Detection", () => {
+		it("detects harness errors", () => {
+			const logs = "verifier script failed with exit code 1"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("harness_error")
+			expect(failures[0].category).toBe("harness")
+		})
+
+		it("detects environment failures", () => {
+			const logs = "Error: docker container exit code 137"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("environment_failure")
+			expect(failures[0].category).toBe("environment")
+		})
+	})
+
+	describe("Policy and Auth Failures", () => {
+		it("detects safety refusals", () => {
+			const logs = "Request blocked: Content policy violation"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("safety_refusal")
+			expect(failures[0].category).toBe("policy")
+		})
+
+		it("detects auth errors", () => {
+			const logs = "401 Unauthorized: Invalid API key"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("auth_error")
+			expect(failures[0].category).toBe("auth")
+		})
+	})
+
+	describe("Excerpt Extraction", () => {
+		it("extracts context around the matched pattern", () => {
+			const logs = `
+				This is some context before the error.
+				Error: 429 Too Many Requests - Rate limit exceeded
+				This is some context after the error.
+			`
+			const failures = classifier.classify(logs)
+
+			expect(failures[0].excerpt).toContain("Rate limit exceeded")
+			expect(failures[0].excerpt.length).toBeLessThan(500)
+		})
+	})
+
+	describe("Helper Methods", () => {
+		it("hasProviderBug returns true for provider bugs", () => {
+			const logs = "Error: missing thoughtSignature in function call"
+			expect(classifier.hasProviderBug(logs)).toBe(true)
+		})
+
+		it("hasProviderBug returns false for non-provider bugs", () => {
+			const logs = "Error: 429 Too Many Requests"
+			expect(classifier.hasProviderBug(logs)).toBe(false)
+		})
+
+		it("hasTransientFailure returns true for transient errors", () => {
+			const logs = "Error: ETIMEDOUT"
+			expect(classifier.hasTransientFailure(logs)).toBe(true)
+		})
+
+		it("hasTransientFailure returns false for non-transient errors", () => {
+			const logs = "Error: missing thoughtSignature"
+			expect(classifier.hasTransientFailure(logs)).toBe(false)
+		})
+
+		it("getPatternsByCategory returns correct patterns", () => {
+			const providerBugs = classifier.getPatternsByCategory("provider_bug")
+			expect(providerBugs).toContain("gemini_signature")
+			expect(providerBugs).toContain("claude_tool_format")
+
+			const transient = classifier.getPatternsByCategory("transient")
+			expect(transient).toContain("rate_limit")
+			expect(transient).toContain("network_timeout")
+			expect(transient).toContain("model_overloaded")
+		})
+	})
+
+	describe("Multiple Pattern Matching", () => {
+		it("detects multiple failures in same log", () => {
+			const logs = `
+				Error: 429 Too Many Requests
+				Later: Error: ETIMEDOUT
+			`
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBe(2)
+			expect(failures.map((f) => f.name)).toContain("rate_limit")
+			expect(failures.map((f) => f.name)).toContain("network_timeout")
+		})
+	})
+
+	describe("Case Insensitivity", () => {
+		it("matches patterns case-insensitively", () => {
+			const logs = "error: RATE LIMIT exceeded"
+			const failures = classifier.classify(logs)
+
+			expect(failures.length).toBeGreaterThan(0)
+			expect(failures[0].name).toBe("rate_limit")
+		})
+	})
+
+	describe("No Match", () => {
+		it("returns empty array when no patterns match", () => {
+			const logs = "Everything completed successfully"
+			const failures = classifier.classify(logs)
+
+			expect(failures).toEqual([])
+		})
+	})
+
+	describe("YAML Safety (JSON_SCHEMA)", () => {
+		it("rejects patterns file with custom YAML tags", () => {
+			// Write a temp YAML file with a !!js/function tag
+			const fs = require("fs")
+			const path = require("path")
+			const os = require("os")
+			const tmpFile = path.join(os.tmpdir(), "unsafe-patterns.yaml")
+			fs.writeFileSync(
+				tmpFile,
+				`version: "1.0"\npatterns:\n  - name: !!js/function 'function(){ return "pwned" }'\n`,
+			)
+
+			expect(() => new FailureClassifier(tmpFile)).toThrow()
+
+			fs.unlinkSync(tmpFile)
+		})
+	})
+})
diff --git a/evals/analysis/src/__tests__/metrics.test.ts b/evals/analysis/src/__tests__/metrics.test.ts
new file mode 100644
index 0000000..5360836
--- /dev/null
+++ b/evals/analysis/src/__tests__/metrics.test.ts
@@ -0,0 +1,249 @@
+import { describe, expect, it } from "vitest"
+import { MetricsCalculator } from "../metrics"
+
+describe("MetricsCalculator", () => {
+	const calc = new MetricsCalculator()
+
+	describe("pass@k (solution finding)", () => {
+		it("calculates 100% when at least k trials pass", () => {
+			expect(calc.passAtK([true, true, true], 1)).toBe(1.0)
+			expect(calc.passAtK([true, true, false], 1)).toBe(1.0)
+			expect(calc.passAtK([true, true, true], 3)).toBe(1.0)
+		})
+
+		it("calculates 0% when fewer than k trials pass", () => {
+			expect(calc.passAtK([false, false, false], 1)).toBe(0.0)
+		})
+
+		it("calculates correct probability for mixed results", () => {
+			// With n=3, c=2, k=2: 1 - C(1,2)/C(3,2) = 1 - 0/3 = 1.0
+			expect(calc.passAtK([true, true, false], 2)).toBe(1.0)
+
+			// With n=3, c=1, k=2: 1 - C(2,2)/C(3,2) = 1 - 1/3 = 2/3
+			expect(calc.passAtK([true, false, false], 2)).toBeCloseTo(0.6667, 4)
+		})
+
+		it("throws error when k > n", () => {
+			expect(() => calc.passAtK([true, false], 3)).toThrow()
+		})
+
+		it("handles k=1 correctly (most common case)", () => {
+			expect(calc.passAtK([true, false, false], 1)).toBe(1.0)
+			expect(calc.passAtK([false, false, false], 1)).toBe(0.0)
+		})
+
+		it("handles all-pass scenarios", () => {
+			expect(calc.passAtK([true, true, true, true, true], 3)).toBe(1.0)
+			expect(calc.passAtK([true, true, true, true, true], 5)).toBe(1.0)
+		})
+
+		it("handles all-fail scenarios", () => {
+			expect(calc.passAtK([false, false, false], 1)).toBe(0.0)
+			expect(calc.passAtK([false, false, false], 3)).toBe(0.0)
+		})
+	})
+
+	describe("pass^k (reliability)", () => {
+		it("calculates 100% when all k trials must and do pass", () => {
+			expect(calc.passCaretK([true, true, true], 3)).toBe(1.0)
+			expect(calc.passCaretK([true, true, true, true], 3)).toBeCloseTo(1.0, 4)
+		})
+
+		it("calculates 0% when fewer than k trials pass", () => {
+			expect(calc.passCaretK([true, true, false], 3)).toBe(0.0)
+			expect(calc.passCaretK([true, false, false], 2)).toBe(0.0)
+			expect(calc.passCaretK([false, false, false], 1)).toBe(0.0)
+		})
+
+		it("calculates correct probability for sufficient passes", () => {
+			// With n=4, c=3, k=2: C(3,2)/C(4,2) = 3/6 = 0.5
+			expect(calc.passCaretK([true, true, true, false], 2)).toBeCloseTo(0.5, 4)
+
+			// With n=5, c=3, k=2: C(3,2)/C(5,2) = 3/10 = 0.3
+			expect(calc.passCaretK([true, true, true, false, false], 2)).toBeCloseTo(0.3, 4)
+		})
+
+		it("throws error when k > n", () => {
+			expect(() => calc.passCaretK([true, false], 3)).toThrow()
+		})
+
+		it("diverges from pass@k as trials increase", () => {
+			const trials = [true, true, false, false, false]
+
+			// pass@k increases (eventually finds solution)
+			const passAt1 = calc.passAtK(trials, 1)
+			const passAt3 = calc.passAtK(trials, 3)
+			expect(passAt3).toBeGreaterThanOrEqual(passAt1)
+
+			// pass^k decreases (reliability drops)
+			const passCaret1 = calc.passCaretK(trials, 1)
+			const passCaret3 = calc.passCaretK(trials, 3)
+			expect(passCaret3).toBeLessThanOrEqual(passCaret1)
+		})
+	})
+
+	describe("flakinessScore (variance)", () => {
+		it("returns 0 for all-pass scenarios", () => {
+			expect(calc.flakinessScore([true, true, true])).toBe(0)
+		})
+
+		it("returns 0 for all-fail scenarios", () => {
+			expect(calc.flakinessScore([false, false, false])).toBe(0)
+		})
+
+		it("returns 1 for maximum variance (50% pass rate)", () => {
+			expect(calc.flakinessScore([true, false])).toBe(1)
+			expect(calc.flakinessScore([true, true, false, false])).toBe(1)
+		})
+
+		it("returns values between 0 and 1 for partial variance", () => {
+			const score1 = calc.flakinessScore([true, true, true, false])
+			expect(score1).toBeGreaterThan(0)
+			expect(score1).toBeLessThan(1)
+
+			const score2 = calc.flakinessScore([true, false, false, false])
+			expect(score2).toBeGreaterThan(0)
+			expect(score2).toBeLessThan(1)
+		})
+
+		it("symmetric around 50% pass rate", () => {
+			const score25 = calc.flakinessScore([true, false, false, false])
+			const score75 = calc.flakinessScore([true, true, true, false])
+			expect(score25).toBeCloseTo(score75, 4)
+		})
+
+		it("higher variance for rates closer to 50%", () => {
+			const score25 = calc.flakinessScore([true, false, false, false])
+			const score50 = calc.flakinessScore([true, true, false, false])
+			expect(score50).toBeGreaterThan(score25)
+		})
+	})
+
+	describe("binomial coefficient", () => {
+		it("calculates C(n, 0) = 1", () => {
+			expect(calc["binomial"](5, 0)).toBe(1)
+		})
+
+		it("calculates C(n, n) = 1", () => {
+			expect(calc["binomial"](5, 5)).toBe(1)
+		})
+
+		it("calculates C(n, 1) = n", () => {
+			expect(calc["binomial"](5, 1)).toBe(5)
+		})
+
+		it("calculates C(n, k) correctly", () => {
+			expect(calc["binomial"](5, 2)).toBe(10)
+			expect(calc["binomial"](6, 3)).toBe(20)
+			expect(calc["binomial"](10, 3)).toBe(120)
+		})
+
+		it("returns 0 when k > n", () => {
+			expect(calc["binomial"](3, 5)).toBe(0)
+		})
+
+		it("optimizes by using smaller k", () => {
+			// C(10, 8) = C(10, 2) = 45
+			expect(calc["binomial"](10, 8)).toBe(45)
+			expect(calc["binomial"](10, 2)).toBe(45)
+		})
+	})
+
+	describe("calculateTaskMetrics", () => {
+		it("calculates all metrics for 3 trials", () => {
+			const metrics = calc.calculateTaskMetrics([true, true, false])
+
+			expect(metrics.passAt1).toBe(1.0)
+			expect(metrics.passAt3).toBeGreaterThan(0)
+			expect(metrics.passCaret3).toBe(0.0)
+			expect(metrics.flakinessScore).toBeGreaterThan(0)
+		})
+
+		it("calculates all metrics for perfect pass", () => {
+			const metrics = calc.calculateTaskMetrics([true, true, true])
+
+			expect(metrics.passAt1).toBe(1.0)
+			expect(metrics.passAt3).toBe(1.0)
+			expect(metrics.passCaret3).toBe(1.0)
+			expect(metrics.flakinessScore).toBe(0)
+		})
+
+		it("calculates all metrics for perfect fail", () => {
+			const metrics = calc.calculateTaskMetrics([false, false, false])
+
+			expect(metrics.passAt1).toBe(0.0)
+			expect(metrics.passAt3).toBe(0.0)
+			expect(metrics.passCaret3).toBe(0.0)
+			expect(metrics.flakinessScore).toBe(0)
+		})
+
+		it("throws error for empty trials", () => {
+			expect(() => calc.calculateTaskMetrics([])).toThrow()
+		})
+
+		it("handles fewer than 3 trials gracefully", () => {
+			const metrics = calc.calculateTaskMetrics([true, false])
+
+			expect(metrics.passAt1).toBe(1.0)
+			expect(metrics.passAt3).toBe(0) // Not enough trials
+			expect(metrics.passCaret3).toBe(0)
+			expect(metrics.flakinessScore).toBe(1)
+		})
+	})
+
+	describe("getTaskStatus", () => {
+		it("returns 'pass' when all trials pass", () => {
+			expect(calc.getTaskStatus([true, true, true])).toBe("pass")
+		})
+
+		it("returns 'fail' when all trials fail", () => {
+			expect(calc.getTaskStatus([false, false, false])).toBe("fail")
+		})
+
+		it("returns 'flaky' when some trials pass and some fail", () => {
+			expect(calc.getTaskStatus([true, false, false])).toBe("flaky")
+			expect(calc.getTaskStatus([true, true, false])).toBe("flaky")
+		})
+
+		it("handles single trial", () => {
+			expect(calc.getTaskStatus([true])).toBe("pass")
+			expect(calc.getTaskStatus([false])).toBe("fail")
+		})
+	})
+
+	describe("Real-world scenarios", () => {
+		it("handles typical cline-bench results", () => {
+			// Scenario: Task passed 2/3 times
+			const trials = [true, true, false]
+			const metrics = calc.calculateTaskMetrics(trials)
+
+			expect(metrics.passAt1).toBe(1.0) // Found solution
+			expect(metrics.passAt3).toBeGreaterThan(0.5) // Likely to solve
+			expect(metrics.passCaret3).toBe(0) // Not reliable
+			expect(metrics.flakinessScore).toBeGreaterThan(0) // Has variance
+			expect(calc.getTaskStatus(trials)).toBe("flaky")
+		})
+
+		it("handles consistent success", () => {
+			const trials = [true, true, true]
+			const metrics = calc.calculateTaskMetrics(trials)
+
+			expect(metrics.passAt1).toBe(1.0)
+			expect(metrics.passAt3).toBe(1.0)
+			expect(metrics.passCaret3).toBe(1.0)
+			expect(metrics.flakinessScore).toBe(0)
+			expect(calc.getTaskStatus(trials)).toBe("pass")
+		})
+
+		it("handles consistent failure", () => {
+			const trials = [false, false, false]
+			const metrics = calc.calculateTaskMetrics(trials)
+
+			expect(metrics.passAt1).toBe(0)
+			expect(metrics.passAt3).toBe(0)
+			expect(metrics.passCaret3).toBe(0)
+			expect(metrics.flakinessScore).toBe(0)
+			expect(calc.getTaskStatus(trials)).toBe("fail")
+		})
+	})
+})
diff --git a/evals/analysis/src/classifier.ts b/evals/analysis/src/classifier.ts
new file mode 100644
index 0000000..d7ed137
--- /dev/null
+++ b/evals/analysis/src/classifier.ts
@@ -0,0 +1,124 @@
+/**
+ * Failure classification system for Cline evaluations
+ *
+ * Classifies failures by matching log patterns against known issues:
+ * - Provider bugs (Gemini #7974, Claude #7998)
+ * - Transient failures (rate limits, timeouts)
+ * - Infrastructure issues (harness, environment)
+ * - Policy/safety refusals
+ * - Auth errors
+ */
+
+import * as fs from "fs"
+import * as yaml from "js-yaml"
+import * as path from "path"
+import type { FailureCategory, FailureInfo } from "./schemas"
+
+export interface FailurePattern {
+	name: string
+	pattern: string // Regex pattern as string
+	category: FailureCategory
+	issue?: string // GitHub issue URL
+	description: string
+}
+
+export interface FailurePatternsConfig {
+	version: string
+	patterns: FailurePattern[]
+}
+
+export class FailureClassifier {
+	private patterns: Array<FailurePattern & { regex: RegExp }>
+
+	constructor(patternsPath?: string) {
+		const defaultPath = path.join(__dirname, "../patterns/cline-failures.yaml")
+		const configPath = patternsPath || defaultPath
+
+		const config = this.loadPatternsFromYaml(configPath)
+		this.patterns = config.patterns.map((p) => ({
+			...p,
+			regex: new RegExp(p.pattern, "i"), // Case-insensitive matching
+		}))
+	}
+
+	private loadPatternsFromYaml(filePath: string): FailurePatternsConfig {
+		const content = fs.readFileSync(filePath, "utf-8")
+		const config = yaml.load(content, { schema: yaml.JSON_SCHEMA }) as FailurePatternsConfig
+
+		if (!config.version || !config.patterns) {
+			throw new Error("Invalid patterns YAML: missing version or patterns")
+		}
+
+		return config
+	}
+
+	/**
+	 * Classify failures in log text
+	 * @param logs Full log text (e.g., cline.txt content)
+	 * @returns Array of matched failure categories with excerpts
+	 */
+	classify(logs: string): FailureInfo[] {
+		const failures: FailureInfo[] = []
+
+		for (const pattern of this.patterns) {
+			const match = pattern.regex.exec(logs)
+			if (match) {
+				failures.push({
+					name: pattern.name,
+					category: pattern.category,
+					excerpt: this.extractExcerpt(logs, match.index, match[0].length),
+					issue_url: pattern.issue,
+				})
+			}
+		}
+
+		return failures
+	}
+
+	/**
+	 * Extract a context snippet around the matched pattern
+	 * @param logs Full log text
+	 * @param matchIndex Index where pattern matched
+	 * @param matchLength Length of the matched text
+	 * @returns Context snippet (up to 200 chars before/after match)
+	 */
+	private extractExcerpt(logs: string, matchIndex: number, matchLength: number): string {
+		const contextSize = 200
+		const start = Math.max(0, matchIndex - contextSize)
+		const end = Math.min(logs.length, matchIndex + matchLength + contextSize)
+
+		let excerpt = logs.slice(start, end)
+
+		// Trim to complete lines for readability
+		excerpt = excerpt.replace(/^\s*\S*\s*/, "") // Remove partial first line
+		excerpt = excerpt.replace(/\s*\S*\s*$/, "") // Remove partial last line
+
+		// Truncate if still too long
+		if (excerpt.length > 400) {
+			excerpt = excerpt.slice(0, 400) + "..."
+		}
+
+		return excerpt.trim()
+	}
+
+	/**
+	 * Check if logs contain any known provider bug patterns
+	 */
+	hasProviderBug(logs: string): boolean {
+		return this.classify(logs).some((f) => f.category === "provider_bug")
+	}
+
+	/**
+	 * Check if logs contain transient failure patterns (retriable)
+	 */
+	hasTransientFailure(logs: string): boolean {
+		return this.classify(logs).some((f) => f.category === "transient")
+	}
+
+	/**
+	 * Get all pattern names for a specific category
+	 */
+	getPatternsByCategory(category: FailureCategory): string[] {
+		return this.patterns.filter((p) => p.category === category).map((p) => p.name)
+	}
+}
diff --git a/evals/analysis/src/cli.ts b/evals/analysis/src/cli.ts
new file mode 100644
index 0000000..0770463
--- /dev/null
+++ b/evals/analysis/src/cli.ts
@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+/**
+ * Cline Analysis Framework CLI
+ *
+ * Commands:
+ * - analyze: Parse Harbor job output and generate reports
+ * - compare: Compare baseline vs current results for regression detection
+ */
+
+import chalk from "chalk"
+import { Command } from "commander"
+import * as fs from "fs"
+import { HarborParser } from "./parsers"
+import { JsonReporter, MarkdownReporter } from "./reporters"
+import type { AnalysisOutputV1, ComparisonResult } from "./schemas"
+
+const program = new Command()
+
+program.name("cline-analysis").description("Analysis framework for Cline evaluations").version("1.0.0")
+
+// Analyze command
+program
+	.command("analyze <job-dir>")
+	.description("Parse Harbor job output and generate analysis report")
+	.option("-f, --format <format>", "Output format: markdown, json, or minimal", "markdown")
+	.option("-o, --output <file>", "Write report to file (default: stdout)")
+	.option("--no-color", "Disable colored output")
+	.action(async (jobDir: string, options: any) => {
+		try {
+			// Validate job directory
+			if (!fs.existsSync(jobDir)) {
+				console.error(chalk.red(`Error: Job directory not found: ${jobDir}`))
+				process.exit(1)
+			}
+
+			console.error(chalk.blue(`Analyzing Harbor job: ${jobDir}`))
+
+			// Parse Harbor output
+			const parser = new HarborParser()
+			const analysis = parser.parseJob(jobDir)
+
+			// Generate report
+			let report: string
+
+			if (options.format === "json") {
+				const jsonReporter = new JsonReporter()
+				report = jsonReporter.generate(analysis, true)
+			} else if (options.format === "minimal") {
+				const jsonReporter = new JsonReporter()
+				report = jsonReporter.generateMinimal(analysis)
+			} else {
+				const markdownReporter = new MarkdownReporter()
+				report = markdownReporter.generate(analysis, options.color)
+			}
+
+			// Output report
+			if (options.output) {
+				fs.writeFileSync(options.output, report)
+				console.error(chalk.green(`✓ Report written to: ${options.output}`))
+
+				// Also write full JSON for future reference
+				if (options.format === "markdown") {
+					const jsonPath = options.output.replace(/\.md$/, ".json")
+					const jsonReporter = new JsonReporter()
+					fs.writeFileSync(jsonPath, jsonReporter.generate(analysis, true))
+					console.error(chalk.gray(`  (Full JSON saved to: ${jsonPath})`))
+				}
+			} else {
+				console.log(report)
+			}
+
+			// Summary on stderr
+			const markdownReporter = new MarkdownReporter()
+			const summary = markdownReporter.generateCompactSummary(analysis)
+			console.error("\n" + chalk.bold("Summary:"))
+			console.error(summary)
+		} catch (error) {
+			console.error(chalk.red("Error during analysis:"))
+			console.error(error)
+			process.exit(1)
+		}
+	})
+
+// Compare command
+program
+	.command("compare <baseline> <current>")
+	.description("Compare baseline and current analysis results")
+	.option("-t, --threshold <number>", "Regression threshold (percentage points)", "10")
+	.option("--no-color", "Disable colored output")
+	.action(async (baselinePath: string, currentPath: string, options: any) => {
+		try {
+			// Load both analysis outputs
+			if (!fs.existsSync(baselinePath)) {
+				console.error(chalk.red(`Error: Baseline file not found: ${baselinePath}`))
+				process.exit(1)
+			}
+
+			if (!fs.existsSync(currentPath)) {
+				console.error(chalk.red(`Error: Current file not found: ${currentPath}`))
+				process.exit(1)
+			}
+
+			const baseline: AnalysisOutputV1 = JSON.parse(fs.readFileSync(baselinePath, "utf-8"))
+			const current: AnalysisOutputV1 = JSON.parse(fs.readFileSync(currentPath, "utf-8"))
+
+			const threshold = parseFloat(options.threshold)
+
+			// Compare results
+			const comparison = compareAnalyses(baseline, current, threshold)
+
+			// Display comparison
+			displayComparison(comparison, options.color)
+
+			// Exit with error if regression detected
+			if (comparison.regression_detected) {
+				console.error(chalk.red("\n✗ Regression detected! See details above."))
+				process.exit(1)
+			} else {
+				console.error(chalk.green("\n✓ No significant regression detected."))
+				process.exit(0)
+			}
+		} catch (error) {
+			console.error(chalk.red("Error during comparison:"))
+			console.error(error)
+			process.exit(1)
+		}
+	})
+
+program.parse()
+
+/**
+ * Compare two analysis outputs for regression detection
+ */
+function compareAnalyses(baseline: AnalysisOutputV1, current: AnalysisOutputV1, threshold: number): ComparisonResult {
+	const delta = {
+		pass_at_1: (current.summary.pass_at_1 - baseline.summary.pass_at_1) * 100,
+		pass_at_3: (current.summary.pass_at_3 - baseline.summary.pass_at_3) * 100,
+		pass_caret_3: (current.summary.pass_caret_3 - baseline.summary.pass_caret_3) * 100,
+		cost_usd: current.summary.total_cost_usd - baseline.summary.total_cost_usd,
+		duration_sec: current.summary.total_duration_sec - baseline.summary.total_duration_sec,
+	}
+
+	// Detect regression (drop in pass rates exceeding threshold)
+	const regression_detected = delta.pass_at_1 < -threshold || delta.pass_at_3 < -threshold
+
+	// Find tasks that regressed or improved
+	const tasks_regressed: string[] = []
+	const tasks_improved: string[] = []
+
+	const baselineTaskMap = new Map(baseline.tasks.map((t) => [t.task_id, t]))
+
+	for (const currentTask of current.tasks) {
+		const baselineTask = baselineTaskMap.get(currentTask.task_id)
+		if (!baselineTask) {
+			continue
+		}
+
+		const taskDelta = (currentTask.metrics.pass_at_3 - baselineTask.metrics.pass_at_3) * 100
+
+		if (taskDelta < -threshold) {
+			tasks_regressed.push(currentTask.task_name)
+		} else if (taskDelta > threshold) {
+			tasks_improved.push(currentTask.task_name)
+		}
+	}
+
+	return {
+		baseline: baseline.summary,
+		current: current.summary,
+		delta,
+		regression_detected,
+		tasks_regressed,
+		tasks_improved,
+	}
+}
+
+/**
+ * Display comparison results with color coding
+ */
+function displayComparison(comparison: ComparisonResult, useColor: boolean): void {
+	const separator = "━".repeat(79)
+
+	console.log(useColor ? chalk.bold(separator) : separator)
+	console.log(useColor ? chalk.bold.cyan("Baseline vs Current Comparison") : "Baseline vs Current Comparison")
+	console.log(useColor ? chalk.bold(separator) : separator)
+	console.log("")
+
+	// Pass rate changes
+	console.log(useColor ? chalk.bold("Pass Rate Changes:") : "Pass Rate Changes:")
+	console.log(`  pass@1: ${formatDelta(comparison.delta.pass_at_1, useColor)} percentage points`)
+	console.log(`  pass@3: ${formatDelta(comparison.delta.pass_at_3, useColor)} percentage points`)
+	console.log(`  pass^3: ${formatDelta(comparison.delta.pass_caret_3, useColor)} percentage points`)
+	console.log("")
+
+	// Cost and duration changes
+	console.log(useColor ? chalk.bold("Resource Changes:") : "Resource Changes:")
+	console.log(`  Cost: ${formatDelta(comparison.delta.cost_usd, useColor, true)} USD`)
+	console.log(`  Duration: ${formatDelta(comparison.delta.duration_sec, useColor)} seconds`)
+	console.log("")
+
+	// Tasks regressed
+	if (comparison.tasks_regressed.length > 0) {
+		console.log(useColor ? chalk.bold.red("Tasks Regressed:") : "Tasks Regressed:")
+		for (const task of comparison.tasks_regressed) {
+			console.log(`  • ${task}`)
+		}
+		console.log("")
+	}
+
+	// Tasks improved
+	if (comparison.tasks_improved.length > 0) {
+		console.log(useColor ? chalk.bold.green("Tasks Improved:") : "Tasks Improved:")
+		for (const task of comparison.tasks_improved) {
+			console.log(`  • ${task}`)
+		}
+		console.log("")
+	}
+}
+
+/**
+ * Format delta value with color coding
+ */
+function formatDelta(value: number, useColor: boolean, invertSign = false): string {
+	const sign = invertSign ? -Math.sign(value) : Math.sign(value)
+	const absValue = Math.abs(value).toFixed(2)
+	const signStr = sign > 0 ? "+" : sign < 0 ? "-" : " "
+
+	if (!useColor) {
+		return `${signStr}${absValue}`
+	}
+
+	if (sign > 0) {
+		return chalk.green(`${signStr}${absValue}`)
+	}
+	if (sign < 0) {
+		return chalk.red(`${signStr}${absValue}`)
+	}
+	return chalk.gray(`${signStr}${absValue}`)
+}
diff --git a/evals/analysis/src/metrics.ts b/evals/analysis/src/metrics.ts
new file mode 100644
index 0000000..8f214a5
--- /dev/null
+++ b/evals/analysis/src/metrics.ts
@@ -0,0 +1,186 @@
+/**
+ * Metrics calculation for nondeterministic AI testing
+ *
+ * Implements:
+ * - pass@k: P(at least 1 of k trials passes) - solution finding capability
+ * - pass^k: P(all k trials pass) - reliability measure
+ * - Flakiness score: Entropy-based variance measurement
+ *
+ * References:
+ * - HumanEval paper: https://arxiv.org/abs/2107.03374
+ * - pass@k methodology: https://github.com/openai/human-eval
+ */
+
+export class MetricsCalculator {
+	/**
+	 * Calculate pass@k: Probability that at least 1 of k trials succeeds
+	 *
+	 * Formula: 1 - C(n-c, k) / C(n, k)
+	 * where n = total trials, c = number of passes, k = sample size
+	 *
+	 * Interpretation: "Can this model solve the problem?"
+	 *
+	 * @param trials Array of boolean trial results (true = pass, false = fail)
+	 * @param k Number of trials to sample
+	 * @returns Probability [0, 1]
+	 */
+	passAtK(trials: boolean[], k: number): number {
+		const n = trials.length
+		const c = trials.filter(Boolean).length
+
+		if (n < k) {
+			throw new Error(`Cannot calculate pass@${k} with only ${n} trials`)
+		}
+
+		// If we have at least k passes, probability is 100%
+		if (c >= k) {
+			return 1.0
+		}
+
+		// Calculate: 1 - C(n-c, k) / C(n, k)
+		const numerator = this.binomial(n - c, k)
+		const denominator = this.binomial(n, k)
+
+		return 1 - numerator / denominator
+	}
+
+	/**
+	 * Calculate pass^k: Probability that ALL k trials succeed
+	 *
+	 * Formula: C(c, k) / C(n, k)
+	 * where n = total trials, c = number of passes, k = sample size
+	 *
+	 * Interpretation: "Can I rely on this model?" (reliability metric)
+	 *
+	 * @param trials Array of boolean trial results
+	 * @param k Number of trials that must all pass
+	 * @returns Probability [0, 1]
+	 */
+	passCaretK(trials: boolean[], k: number): number {
+		const n = trials.length
+		const c = trials.filter(Boolean).length
+
+		if (n < k) {
+			throw new Error(`Cannot calculate pass^${k} with only ${n} trials`)
+		}
+
+		// If we have fewer than k passes, probability is 0%
+		if (c < k) {
+			return 0.0
+		}
+
+		// Calculate: C(c, k) / C(n, k)
+		const numerator = this.binomial(c, k)
+		const denominator = this.binomial(n, k)
+
+		return numerator / denominator
+	}
+
+	/**
+	 * Calculate flakiness score: Entropy-based measure of variance
+	 *
+	 * Formula: -p*log2(p) - (1-p)*log2(1-p)
+	 * where p = pass rate
+	 *
+	 * Returns:
+	 * - 0.0: No variance (all pass or all fail)
+	 * - 1.0: Maximum variance (50% pass rate)
+	 *
+	 * Interpretation: How unpredictable/inconsistent is this task?
+	 *
+	 * @param trials Array of boolean trial results
+	 * @returns Flakiness score [0, 1]
+	 */
+	flakinessScore(trials: boolean[]): number {
+		const passRate = trials.filter(Boolean).length / trials.length
+
+		// No variance if all pass or all fail
+		if (passRate === 0 || passRate === 1) {
+			return 0
+		}
+
+		// Binary entropy
+		const entropy = -passRate * Math.log2(passRate) - (1 - passRate) * Math.log2(1 - passRate)
+
+		return entropy // Already in [0, 1] range
+	}
+
+	/**
+	 * Binomial coefficient C(n, k) = n! / (k! * (n-k)!)
+	 *
+	 * Uses iterative calculation to avoid factorial overflow
+	 *
+	 * @param n Total items
+	 * @param k Items to choose
+	 * @returns Number of ways to choose k items from n
+	 */
+	private binomial(n: number, k: number): number {
+		if (k > n) {
+			return 0
+		}
+		if (k === 0 || k === n) {
+			return 1
+		}
+
+		// Optimize by using smaller k
+		if (k > n - k) {
+			k = n - k
+		}
+
+		let result = 1
+		for (let i = 1; i <= k; i++) {
+			result *= n - i + 1
+			result /= i
+		}
+
+		return result
+	}
+
+	/**
+	 * Calculate all metrics for a task's trials
+	 *
+	 * @param trials Array of boolean trial results
+	 * @returns Object with pass@1, pass@3, pass^3, and flakiness scores
+	 */
+	calculateTaskMetrics(trials: boolean[]): {
+		passAt1: number
+		passAt3: number
+		passCaret3: number
+		flakinessScore: number
+	} {
+		if (trials.length === 0) {
+			throw new Error("Cannot calculate metrics with no trials")
+		}
+
+		// Calculate pass@k and pass^k for available trials
+		const passAt1 = trials.length >= 1 ? this.passAtK(trials, 1) : 0
+		const passAt3 = trials.length >= 3 ? this.passAtK(trials, 3) : 0
+		const passCaret3 = trials.length >= 3 ? this.passCaretK(trials, 3) : 0
+
+		return {
+			passAt1,
+			passAt3,
+			passCaret3,
+			flakinessScore: this.flakinessScore(trials),
+		}
+	}
+
+	/**
+	 * Determine task status based on trial results
+	 *
+	 * @param trials Array of boolean trial results
+	 * @returns "pass" | "fail" | "flaky"
+	 */
+	getTaskStatus(trials: boolean[]): "pass" | "fail" | "flaky" {
+		const passCount = trials.filter(Boolean).length
+		const totalCount = trials.length
+
+		if (passCount === totalCount) {
+			return "pass"
+		}
+		if (passCount === 0) {
+			return "fail"
+		}
+		return "flaky"
+	}
+}
diff --git a/evals/analysis/src/parsers/harbor.ts b/evals/analysis/src/parsers/harbor.ts
new file mode 100644
index 0000000..5c0b26e
--- /dev/null
+++ b/evals/analysis/src/parsers/harbor.ts
@@ -0,0 +1,301 @@
+/**
+ * Parser for Harbor framework job output
+ *
+ * Parses jobs/ directory structure created by Harbor to extract:
+ * - Trial results (pass/fail, duration, cost, tokens)
+ * - Task groupings and metrics
+ * - Failure classifications
+ */
+
+import * as fs from "fs"
+import * as path from "path"
+import { FailureClassifier } from "../classifier"
+import { MetricsCalculator } from "../metrics"
+import type {
+	AnalysisMetadata,
+	AnalysisOutputV1,
+	AnalysisSummary,
+	FailureAnalysis,
+	TaskResultV1,
+	TrialResultV1,
+} from "../schemas"
+
+export interface HarborParserOptions {
+	patternsPath?: string
+}
+
+export class HarborParser {
+	private classifier: FailureClassifier
+	private metrics: MetricsCalculator
+
+	constructor(options: HarborParserOptions = {}) {
+		this.classifier = new FailureClassifier(options.patternsPath)
+		this.metrics = new MetricsCalculator()
+	}
+
+	/**
+	 * Parse a complete Harbor job directory
+	 *
+	 * @param jobDir Path to job directory (e.g., jobs/2025-01-25__10-30-00/)
+	 * @returns Structured analysis output with schema version 1.0
+	 */
+	parseJob(jobDir: string): AnalysisOutputV1 {
+		const configPath = path.join(jobDir, "config.json")
+		const resultPath = path.join(jobDir, "result.json")
+
+		if (!fs.existsSync(configPath) || !fs.existsSync(resultPath)) {
+			throw new Error(`Invalid Harbor job directory: ${jobDir}`)
+		}
+
+		const config = JSON.parse(fs.readFileSync(configPath, "utf-8"))
+		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"))
+
+		// Find all trial directories
+		const trialDirs = this.findTrialDirectories(jobDir)
+		const trials = trialDirs.map((dir) => this.parseTrialDirectory(dir))
+
+		// Group trials by task ID
+		const taskResults = this.groupTrialsByTask(trials)
+
+		// Calculate aggregate metrics
+		const summary = this.calculateSummary(taskResults)
+
+		// Analyze failures
+		const failures = this.analyzeFailures(taskResults)
+
+		const metadata: AnalysisMetadata = {
+			generated_at: new Date().toISOString(),
+			analysis_version: "1.0.0", // TODO: Get from package.json
+			job_id: path.basename(jobDir),
+			model: config.model,
+			agent: config.agent || "cline-cli",
+			environment: config.environment || "docker",
+		}
+
+		return {
+			schema_version: "1.0",
+			metadata,
+			summary,
+			tasks: taskResults,
+			failures,
+		}
+	}
+
+	/**
+	 * Find all trial directories in a job
+	 */
+	private findTrialDirectories(jobDir: string): string[] {
+		const entries = fs.readdirSync(jobDir, { withFileTypes: true })
+
+		return entries
+			.filter((entry) => entry.isDirectory())
+			.filter((entry) => {
+				// Trial dirs have format: 01k7a12s...disco__fhSEuhr
+				const configExists = fs.existsSync(path.join(jobDir, entry.name, "config.json"))
+				return configExists
+			})
+			.map((entry) => path.join(jobDir, entry.name))
+	}
+
+	/**
+	 * Parse a single trial directory
+	 */
+	private parseTrialDirectory(trialDir: string): ParsedTrial {
+		const configPath = path.join(trialDir, "config.json")
+		const resultPath = path.join(trialDir, "result.json")
+		const rewardPath = path.join(trialDir, "verifier", "reward.txt")
+		const logsPath = path.join(trialDir, "agent", "cline.txt")
+		const testOutputPath = path.join(trialDir, "verifier", "test-stdout.txt")
+
+		const config = JSON.parse(fs.readFileSync(configPath, "utf-8"))
+		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"))
+		const reward = fs.readFileSync(rewardPath, "utf-8").trim()
+		const logs = fs.existsSync(logsPath) ? fs.readFileSync(logsPath, "utf-8") : ""
+		const testOutput = fs.existsSync(testOutputPath) ? fs.readFileSync(testOutputPath, "utf-8") : ""
+
+		const passed = reward === "1"
+		const failures = passed ? [] : this.classifier.classify(logs)
+
+		return {
+			taskId: config.task_id,
+			trialHash: path.basename(trialDir).split("__")[1] || "",
+			passed,
+			duration: result.duration_sec || 0,
+			cost: result.cost_usd || 0,
+			tokensIn: result.tokens_in,
+			tokensOut: result.tokens_out,
+			logs,
+			testOutput,
+			failures,
+		}
+	}
+
+	/**
+	 * Group trials by task ID and calculate metrics
+	 */
+	private groupTrialsByTask(trials: ParsedTrial[]): TaskResultV1[] {
+		const taskMap = new Map<string, ParsedTrial[]>()
+
+		// Group trials by task ID
+		for (const trial of trials) {
+			const existing = taskMap.get(trial.taskId) || []
+			existing.push(trial)
+			taskMap.set(trial.taskId, existing)
+		}
+
+		// Convert to TaskResultV1 format
+		const taskResults: TaskResultV1[] = []
+
+		for (const [taskId, taskTrials] of taskMap.entries()) {
+			const trialResults: TrialResultV1[] = taskTrials.map((trial, index) => ({
+				trial_index: index,
+				trial_hash: trial.trialHash,
+				passed: trial.passed,
+				duration_sec: trial.duration,
+				cost_usd: trial.cost,
+				tokens_in: trial.tokensIn,
+				tokens_out: trial.tokensOut,
+				failures: trial.failures,
+			}))
+
+			const passResults = taskTrials.map((t) => t.passed)
+			const metrics = this.metrics.calculateTaskMetrics(passResults)
+			const status = this.metrics.getTaskStatus(passResults)
+
+			const totalCost = taskTrials.reduce((sum, t) => sum + t.cost, 0)
+			const avgDuration = taskTrials.reduce((sum, t) => sum + t.duration, 0) / taskTrials.length
+
+			// Extract readable task name from ID
+			const taskName = this.extractTaskName(taskId)
+
+			taskResults.push({
+				task_id: taskId,
+				task_name: taskName,
+				trials: trialResults,
+				metrics,
+				status,
+				total_cost_usd: totalCost,
+				avg_duration_sec: avgDuration,
+			})
+		}
+
+		return taskResults.sort((a, b) => a.task_name.localeCompare(b.task_name))
+	}
+
+	/**
+	 * Extract human-readable task name from task ID
+	 * Example: 01k7a12sd1nk15j08e6x0x7v9e-discord-trivia-approval-keyerror → discord-trivia
+	 */
+	private extractTaskName(taskId: string): string {
+		const parts = taskId.split("-")
+		if (parts.length > 1) {
+			// Remove the ID prefix and get first 2-3 meaningful words
+			const words = parts.slice(1, 4)
+			return words.join("-")
+		}
+		return taskId
+	}
+
+	/**
+	 * Calculate aggregate summary metrics
+	 */
+	private calculateSummary(taskResults: TaskResultV1[]): AnalysisSummary {
+		const totalTasks = taskResults.length
+		const totalTrials = taskResults.reduce((sum, task) => sum + task.trials.length, 0)
+
+		// Calculate overall pass@k metrics
+		const allTrials = taskResults.flatMap((task) => task.trials.map((t) => t.passed))
+		let passAt1 = 0
+		let passAt3 = 0
+		let passCaret3 = 0
+
+		if (allTrials.length >= 1) {
+			passAt1 = this.metrics.passAtK(allTrials, 1)
+		}
+		if (allTrials.length >= 3) {
+			passAt3 = this.metrics.passAtK(allTrials, 3)
+			passCaret3 = this.metrics.passCaretK(allTrials, 3)
+		}
+
+		const totalCost = taskResults.reduce((sum, task) => sum + task.total_cost_usd, 0)
+		const totalDuration = taskResults.reduce((sum, task) => sum + task.avg_duration_sec * task.trials.length, 0)
+
+		const flakyTaskCount = taskResults.filter((task) => task.status === "flaky").length
+
+		return {
+			total_tasks: totalTasks,
+			total_trials: totalTrials,
+			pass_at_1: passAt1,
+			pass_at_3: passAt3,
+			pass_caret_3: passCaret3,
+			total_cost_usd: totalCost,
+			total_duration_sec: totalDuration,
+			flaky_task_count: flakyTaskCount,
+		}
+	}
+
+	/**
+	 * Analyze failure patterns across all tasks
+	 */
+	private analyzeFailures(taskResults: TaskResultV1[]): FailureAnalysis {
+		const categoryCount = new Map<string, number>()
+		const patternCount = new Map<string, { count: number; issue_url?: string; examples: any[] }>()
+
+		for (const task of taskResults) {
+			for (const trial of task.trials) {
+				if (!trial.passed) {
+					for (const failure of trial.failures) {
+						// Count by category
+						categoryCount.set(failure.category, (categoryCount.get(failure.category) || 0) + 1)
+
+						// Count by pattern
+						const existing = patternCount.get(failure.name) || {
+							count: 0,
+							issue_url: failure.issue_url,
+							examples: [],
+						}
+						existing.count++
+
+						// Add example if not too many
+						if (existing.examples.length < 3) {
+							existing.examples.push({
+								task_id: task.task_id,
+								trial_index: trial.trial_index,
+								excerpt: failure.excerpt,
+							})
+						}
+
+						patternCount.set(failure.name, existing)
+					}
+				}
+			}
+		}
+
+		const byCategory: Record<string, number> = {}
+		for (const [category, count] of categoryCount.entries()) {
+			byCategory[category] = count
+		}
+
+		const byPattern = Array.from(patternCount.entries()).map(([name, data]) => ({
+			name,
+			count: data.count,
+			issue_url: data.issue_url,
+			examples: data.examples,
+		}))
+
+		return { by_category: byCategory as any, by_pattern: byPattern }
+	}
+}
+
+interface ParsedTrial {
+	taskId: string
+	trialHash: string
+	passed: boolean
+	duration: number
+	cost: number
+	tokensIn?: number
+	tokensOut?: number
+	logs: string
+	testOutput: string
+	failures: any[]
+}
diff --git a/evals/analysis/src/parsers/index.ts b/evals/analysis/src/parsers/index.ts
new file mode 100644
index 0000000..233e037
--- /dev/null
+++ b/evals/analysis/src/parsers/index.ts
@@ -0,0 +1,8 @@
+/**
+ * Parser exports for Cline Analysis Framework
+ *
+ * Parsers for different benchmark types:
+ * - Harbor: Real-world tasks via cline-bench
+ */
+
+export * from "./harbor"
diff --git a/evals/analysis/src/reporters/index.ts b/evals/analysis/src/reporters/index.ts
new file mode 100644
index 0000000..0e69812
--- /dev/null
+++ b/evals/analysis/src/reporters/index.ts
@@ -0,0 +1,10 @@
+/**
+ * Reporter exports for Cline Analysis Framework
+ *
+ * Available reporters:
+ * - JsonReporter: Structured JSON output with schema validation
+ * - MarkdownReporter: Human-readable terminal reports
+ */
+
+export * from "./json"
+export * from "./markdown"
diff --git a/evals/analysis/src/reporters/json.ts b/evals/analysis/src/reporters/json.ts
new file mode 100644
index 0000000..8d5b709
--- /dev/null
+++ b/evals/analysis/src/reporters/json.ts
@@ -0,0 +1,96 @@
+/**
+ * JSON reporter for Cline analysis results
+ *
+ * Outputs structured JSON with schema versioning for:
+ * - CI integration (baseline diffing, regression detection)
+ * - Programmatic analysis
+ * - Data archival
+ */
+
+import type { AnalysisOutputV1 } from "../schemas"
+
+export class JsonReporter {
+	/**
+	 * Generate JSON report from analysis output
+	 *
+	 * @param output Analysis output (already structured)
+	 * @param pretty Whether to pretty-print the JSON
+	 * @returns JSON string
+	 */
+	generate(output: AnalysisOutputV1, pretty = true): string {
+		return JSON.stringify(output, null, pretty ? 2 : undefined)
+	}
+
+	/**
+	 * Validate that output conforms to AnalysisOutputV1 schema
+	 *
+	 * @param output Analysis output to validate
+	 * @throws Error if schema validation fails
+	 */
+	validate(output: any): asserts output is AnalysisOutputV1 {
+		if (output.schema_version !== "1.0") {
+			throw new Error(`Unsupported schema version: ${output.schema_version}`)
+		}
+
+		// Basic structure validation
+		const required = ["metadata", "summary", "tasks", "failures"]
+		for (const field of required) {
+			if (!(field in output)) {
+				throw new Error(`Missing required field: ${field}`)
+			}
+		}
+
+		// Validate metadata
+		if (!output.metadata.generated_at || !output.metadata.job_id || !output.metadata.model) {
+			throw new Error("Invalid metadata: missing required fields")
+		}
+
+		// Validate summary
+		if (typeof output.summary.total_tasks !== "number") {
+			throw new Error("Invalid summary: total_tasks must be a number")
+		}
+
+		// Validate tasks array
+		if (!Array.isArray(output.tasks)) {
+			throw new Error("Invalid tasks: must be an array")
+		}
+	}
+
+	/**
+	 * Generate a minimal JSON report (without full logs and excerpts)
+	 *
+	 * Useful for CI artifacts where space is limited
+	 *
+	 * @param output Analysis output
+	 * @returns Minified JSON string
+	 */
+	generateMinimal(output: AnalysisOutputV1): string {
+		const minimal = {
+			schema_version: output.schema_version,
+			metadata: {
+				job_id: output.metadata.job_id,
+				model: output.metadata.model,
+				generated_at: output.metadata.generated_at,
+			},
+			summary: output.summary,
+			tasks: output.tasks.map((task) => ({
+				task_id: task.task_id,
+				task_name: task.task_name,
+				status: task.status,
+				metrics: task.metrics,
+				total_cost_usd: task.total_cost_usd,
+				avg_duration_sec: task.avg_duration_sec,
+			})),
+			failures: {
+				by_category: output.failures.by_category,
+				by_pattern: output.failures.by_pattern.map((p) => ({
+					name: p.name,
+					count: p.count,
+					issue_url: p.issue_url,
+				})),
+			},
+		}
+
+		return JSON.stringify(minimal, null, 2)
+	}
+}
diff --git a/evals/analysis/src/reporters/markdown.ts b/evals/analysis/src/reporters/markdown.ts
new file mode 100644
index 0000000..1619cc4
--- /dev/null
+++ b/evals/analysis/src/reporters/markdown.ts
@@ -0,0 +1,236 @@
+/**
+ * Markdown reporter for Cline analysis results
+ *
+ * Generates human-readable reports with:
+ * - Summary metrics (pass@k, cost, duration)
+ * - Task-by-task results
+ * - Failure analysis with issue links
+ * - Terminal-friendly formatting
+ */
+
+import chalk from "chalk"
+import type { AnalysisOutputV1, TaskResultV1 } from "../schemas"
+
+export class MarkdownReporter {
+	/**
+	 * Generate markdown report from analysis output
+	 *
+	 * @param output Analysis output
+	 * @param useColor Whether to use terminal colors
+	 * @returns Markdown-formatted report string
+	 */
+	generate(output: AnalysisOutputV1, useColor = true): string {
+		const sections: string[] = []
+
+		sections.push(this.generateHeader(output, useColor))
+		sections.push(this.generateSummary(output, useColor))
+		sections.push(this.generateTaskResults(output, useColor))
+		sections.push(this.generateFailureAnalysis(output, useColor))
+		sections.push(this.generateCostPerformance(output, useColor))
+
+		return sections.join("\n\n")
+	}
+
+	private generateHeader(output: AnalysisOutputV1, useColor: boolean): string {
+		const separator = "━".repeat(79)
+		const title = "Cline Bench Analysis Report"
+
+		const lines = [
+			useColor ? chalk.bold(separator) : separator,
+			useColor ? chalk.bold.cyan(title) : title,
+			useColor ? chalk.bold(separator) : separator,
+			"",
+			`Job: ${output.metadata.job_id}`,
+			`Model: ${output.metadata.model}`,
+			`Tasks: ${output.summary.total_tasks} | Trials per task: ${Math.round(output.summary.total_trials / output.summary.total_tasks)}`,
+		]
+
+		return lines.join("\n")
+	}
+
+	private generateSummary(output: AnalysisOutputV1, useColor: boolean): string {
+		const { summary } = output
+		const separator = "━".repeat(79)
+
+		const passAt1Pct = (summary.pass_at_1 * 100).toFixed(1)
+		const passAt3Pct = (summary.pass_at_3 * 100).toFixed(1)
+		const passCaret3Pct = (summary.pass_caret_3 * 100).toFixed(1)
+
+		const lines = [
+			useColor ? chalk.bold(separator) : separator,
+			useColor ? chalk.bold("Results Summary") : "Results Summary",
+			useColor ? chalk.bold(separator) : separator,
+			"",
+			"Overall Metrics:",
+			`  pass@1: ${passAt1Pct}%  (solution finding)`,
+			`  pass@3: ${passAt3Pct}%  (with 3 attempts)`,
+			`  pass^3: ${passCaret3Pct}%  (reliability - all 3 pass)`,
+			"",
+		]
+
+		if (summary.flaky_task_count > 0) {
+			lines.push(
+				useColor
+					? chalk.yellow(`Flakiness: ${summary.flaky_task_count} tasks showed variance across trials`)
+					: `Flakiness: ${summary.flaky_task_count} tasks showed variance across trials`,
+			)
+		} else {
+			lines.push("Flakiness: No variance detected (all tasks consistent)")
+		}
+
+		return lines.join("\n")
+	}
+
+	private generateTaskResults(output: AnalysisOutputV1, useColor: boolean): string {
+		const separator = "━".repeat(79)
+
+		const lines = [
+			useColor ? chalk.bold(separator) : separator,
+			useColor ? chalk.bold("Task Results") : "Task Results",
+			useColor ? chalk.bold(separator) : separator,
+			"",
+		]
+
+		for (const task of output.tasks) {
+			const statusIcon = this.getStatusIcon(task, useColor)
+			const passAt1Pct = (task.metrics.pass_at_1 * 100).toFixed(0)
+			const passCaret3Pct = (task.metrics.pass_caret_3 * 100).toFixed(0)
+			const trialPattern = this.getTrialPattern(task, useColor)
+			const flakyWarning =
+				task.status === "flaky" && useColor ? chalk.yellow(" ⚠️  FLAKY") : task.status === "flaky" ? " ⚠️  FLAKY" : ""
+
+			const taskLine = `${statusIcon} ${task.task_name.padEnd(30)} | pass@1: ${passAt1Pct.padStart(3)}% | pass^3: ${passCaret3Pct.padStart(3)}% | ${trialPattern}${flakyWarning}`
+			lines.push(taskLine)
+		}
+
+		return lines.join("\n")
+	}
+
+	private getStatusIcon(task: TaskResultV1, useColor: boolean): string {
+		if (task.status === "pass") {
+			return useColor ? chalk.green("✓") : "✓"
+		}
+		if (task.status === "fail") {
+			return useColor ? chalk.red("✗") : "✗"
+		}
+		return useColor ? chalk.yellow("◐") : "◐"
+	}
+
+	private getTrialPattern(task: TaskResultV1, useColor: boolean): string {
+		const pattern = task.trials
+			.map((t) => {
+				if (t.passed) {
+					return useColor ? chalk.green("P") : "P"
+				}
+				return useColor ? chalk.red("F") : "F"
+			})
+			.join("")
+
+		return `[${pattern}]`
+	}
+
+	private generateFailureAnalysis(output: AnalysisOutputV1, useColor: boolean): string {
+		const separator = "━".repeat(79)
+
+		const lines = [
+			useColor ? chalk.bold(separator) : separator,
+			useColor ? chalk.bold("Failure Analysis") : "Failure Analysis",
+			useColor ? chalk.bold(separator) : separator,
+			"",
+		]
+
+		// Known issues (provider bugs)
+		const providerBugs = output.failures.by_pattern.filter((p) => p.issue_url)
+
+		if (providerBugs.length > 0) {
+			lines.push("Known Issues Detected:")
+			for (const bug of providerBugs) {
+				const line = `  • ${bug.name} (${bug.count} occurrence${bug.count > 1 ? "s" : ""}) - ${bug.issue_url}`
+				lines.push(useColor ? chalk.yellow(line) : line)
+
+				// Show first example
+				if (bug.examples.length > 0) {
+					const example = bug.examples[0]
+					lines.push(`    Task: ${example.task_id}, Trial ${example.trial_index}`)
+				}
+			}
+			lines.push("")
+		}
+
+		// Transient failures
+		const transient = Object.entries(output.failures.by_category).filter(([cat]) =>
+			["transient", "harness", "environment"].includes(cat),
+		)
+
+		if (transient.length > 0) {
+			lines.push("Infrastructure/Transient Failures:")
+			for (const [category, count] of transient) {
+				lines.push(`  • ${category}: ${count} occurrence${count > 1 ? "s" : ""}`)
+			}
+			lines.push("")
+		}
+
+		// Task failures (model couldn't solve)
+		const taskFailures = output.tasks.filter((t) => t.status === "fail")
+		if (taskFailures.length > 0) {
+			lines.push("Task Failures (Model couldn't solve):")
+			for (const task of taskFailures) {
+				const allFailed = task.trials.every((t) => !t.passed)
+				if (allFailed) {
+					lines.push(`  • ${task.task_name}: All ${task.trials.length} trials failed verification tests`)
+				}
+			}
+		}
+
+		return lines.join("\n")
+	}
+
+	private generateCostPerformance(output: AnalysisOutputV1, useColor: boolean): string {
+		const separator = "━".repeat(79)
+
+		const avgCostPerTask = output.summary.total_cost_usd / output.summary.total_tasks
+		const avgDurationPerTask = output.summary.total_duration_sec / output.summary.total_tasks
+
+		const formattedDuration = this.formatDuration(output.summary.total_duration_sec)
+		const avgFormattedDuration = this.formatDuration(avgDurationPerTask)
+
+		const lines = [
+			useColor ? chalk.bold(separator) : separator,
+			useColor ? chalk.bold("Cost & Performance") : "Cost & Performance",
+			useColor ? chalk.bold(separator) : separator,
+			"",
+			`Total Cost: $${output.summary.total_cost_usd.toFixed(2)}`,
+			`Avg per task: $${avgCostPerTask.toFixed(2)}`,
+			`Total Duration: ${formattedDuration}`,
+			`Avg per task: ${avgFormattedDuration}`,
+			"",
+			`Full report saved to: ${output.metadata.job_id}/analysis_report.md`,
+		]
+
+		return lines.join("\n")
+	}
+
+	private formatDuration(seconds: number): string {
+		if (seconds < 60) {
+			return `${seconds.toFixed(0)}s`
+		}
+		const minutes = Math.floor(seconds / 60)
+		const secs = Math.floor(seconds % 60)
+		return `${minutes}m ${secs}s`
+	}
+
+	/**
+	 * Generate a compact summary (for CI output)
+	 */
+	generateCompactSummary(output: AnalysisOutputV1): string {
+		const passAt1 = (output.summary.pass_at_1 * 100).toFixed(1)
+		const passAt3 = (output.summary.pass_at_3 * 100).toFixed(1)
+		const cost = output.summary.total_cost_usd.toFixed(2)
+
+		return [
+			`✓ pass@1: ${passAt1}% | pass@3: ${passAt3}%`,
+			`  Cost: $${cost} | Tasks: ${output.summary.total_tasks}`,
+			`  Flaky: ${output.summary.flaky_task_count}`,
+		].join("\n")
+	}
+}
diff --git a/evals/analysis/src/schemas/analysis-output.ts b/evals/analysis/src/schemas/analysis-output.ts
new file mode 100644
index 0000000..da25f45
--- /dev/null
+++ b/evals/analysis/src/schemas/analysis-output.ts
@@ -0,0 +1,146 @@
+/**
+ * Type definitions for Cline Analysis Framework output
+ * These schemas define the structured JSON output from our analysis tools
+ */
+
+/**
+ * Versioned analysis output schema (V1)
+ * Breaking changes should increment the version number
+ */
+export interface AnalysisOutputV1 {
+	schema_version: "1.0"
+	metadata: AnalysisMetadata
+	summary: AnalysisSummary
+	tasks: TaskResultV1[]
+	failures: FailureAnalysis
+}
+
+export interface AnalysisMetadata {
+	generated_at: string // ISO 8601 timestamp
+	analysis_version: string // Package version (from package.json)
+	job_id: string // Job directory name (e.g., "2025-01-25__10-30-00")
+	model: string // Model used for the run
+	agent: string // Agent name (e.g., "cline-cli")
+	environment: string // "docker" | "daytona"
+}
+
+export interface AnalysisSummary {
+	total_tasks: number
+	total_trials: number
+	pass_at_1: number // Probability at least 1 of k=1 succeeds
+	pass_at_3: number // Probability at least 1 of k=3 succeeds
+	pass_caret_3: number // Probability ALL k=3 succeed (reliability)
+	total_cost_usd: number
+	total_duration_sec: number
+	flaky_task_count: number // Tasks with variance across trials
+}
+
+export interface TaskResultV1 {
+	task_id: string
+	task_name: string
+	trials: TrialResultV1[]
+	metrics: TaskMetrics
+	status: "pass" | "fail" | "flaky"
+	total_cost_usd: number
+	avg_duration_sec: number
+}
+
+export interface TrialResultV1 {
+	trial_index: number // 0-indexed trial number
+	trial_hash: string // Hash from trial directory name
+	passed: boolean
+	duration_sec: number
+	cost_usd: number
+	tokens_in?: number
+	tokens_out?: number
+	failures: FailureInfo[] // Classified failure patterns
+}
+
+export interface TaskMetrics {
+	pass_at_1: number // P(at least 1 of 1 succeeds)
+	pass_at_3: number // P(at least 1 of 3 succeeds)
+	pass_caret_3: number // P(all 3 succeed) - reliability metric
+	flakiness_score: number // Entropy-based variance measure (0-1)
+}
+
+export interface FailureInfo {
+	name: string // Pattern name (e.g., "gemini_signature")
+	category: FailureCategory
+	excerpt: string // Log excerpt showing the failure
+	issue_url?: string // GitHub issue link if applicable
+}
+
+export type FailureCategory =
+	| "provider_bug" // Cline integration bugs (Gemini #7974, Claude #7998)
+	| "transient" // Rate limits, network timeouts, service unavailable
+	| "harness" // Test harness or verification script failure
+	| "environment" // Docker/Daytona setup failure
+	| "policy" // Model safety/content policy refusal
+	| "auth" // Invalid API credentials
+	| "task_failure" // Model couldn't solve the task
+
+export interface FailureAnalysis {
+	by_category: Record<FailureCategory, number>
+	by_pattern: FailurePatternSummary[]
+}
+
+export interface FailurePatternSummary {
+	name: string
+	count: number
+	issue_url?: string
+	examples: FailureExample[]
+}
+
+export interface FailureExample {
+	task_id: string
+	trial_index: number
+	excerpt: string
+}
+
+/**
+ * Tool Precision Test Result (for replace_in_file benchmarks)
+ */
+export interface ToolPrecisionResult {
+	schema_version: "1.0"
+	benchmark: "tool-precision/replace-in-file"
+	total_cases: number
+	passed: number
+	failed: number
+	pass_rate: number
+	avg_latency_ms: number
+	known_failures: string[]
+	timestamp: string
+}
+
+/**
+ * Coding Exercises Result (for small task benchmarks)
+ */
+export interface CodingExercisesResult {
+	schema_version: "1.0"
+	benchmark: "coding-exercises"
+	total_exercises: number
+	passed: number
+	failed: number
+	pass_at_1: number
+	avg_duration_sec: number
+	known_failures: string[]
+	timestamp: string
+}
+
+/**
+ * Comparison result between two analysis outputs
+ */
+export interface ComparisonResult {
+	baseline: AnalysisSummary
+	current: AnalysisSummary
+	delta: {
+		pass_at_1: number // Percentage point change
+		pass_at_3: number
+		pass_caret_3: number
+		cost_usd: number
+		duration_sec: number
+	}
+	regression_detected: boolean
+	tasks_regressed: string[] // Task IDs that got worse
+	tasks_improved: string[] // Task IDs that got better
+}
diff --git a/evals/analysis/src/schemas/harbor-output.ts b/evals/analysis/src/schemas/harbor-output.ts
new file mode 100644
index 0000000..afdbbe9
--- /dev/null
+++ b/evals/analysis/src/schemas/harbor-output.ts
@@ -0,0 +1,111 @@
+/**
+ * Type definitions for Harbor framework output structure
+ * These schemas document Harbor's jobs/ directory format (read-only, we validate against this)
+ *
+ * Harbor is the execution framework used by cline-bench.
+ * See: https://harborframework.com
+ */
+
+export interface HarborTrialConfig {
+	task_id: string
+	model: string
+	agent: string
+	environment?: string
+	retries?: number
+}
+
+export interface HarborTrialResult {
+	reward: 0 | 1 // Binary pass/fail from verifier
+	duration_sec: number
+	cost_usd: number
+	tokens_in?: number
+	tokens_out?: number
+	timestamp?: string
+}
+
+export interface HarborTrialFiles {
+	agent: {
+		"cline.txt": string // Full conversation log
+		"setup/stdout.txt": string
+		"setup/stderr.txt": string
+		"setup/return-code.txt": string
+		[key: string]: string // command-N/ directories with stdout, stderr, return-code.txt
+	}
+	verifier: {
+		"reward.txt": "0" | "1"
+		"test-stdout.txt": string
+		"test-stderr.txt": string
+	}
+}
+
+/**
+ * Structure of a single trial directory
+ * Example: jobs/2025-01-25__10-30-00/01k7a12s...disco__fhSEuhr/
+ */
+export interface HarborTrialDirectory {
+	"config.json": HarborTrialConfig
+	"result.json": HarborTrialResult
+	agent: HarborTrialFiles["agent"]
+	verifier: HarborTrialFiles["verifier"]
+}
+
+/**
+ * Structure of a job's config.json
+ */
+export interface HarborJobConfig {
+	model: string
+	agent: string
+	tasks: string[] // Task IDs
+	trials_per_task: number
+	environment: string // "docker" | "daytona"
+	created_at?: string
+}
+
+/**
+ * Structure of a job's result.json (aggregate)
+ */
+export interface HarborJobResult {
+	total_tasks: number
+	passed_tasks: number
+	failed_tasks: number
+	total_cost_usd: number
+	total_duration_sec: number
+	started_at?: string
+	completed_at?: string
+}
+
+/**
+ * Complete job directory structure
+ * Example: jobs/2025-01-25__10-30-00/
+ */
+export interface HarborJobDirectory {
+	"config.json": HarborJobConfig
+	"result.json": HarborJobResult
+	trials: Record<string, HarborTrialDirectory> // trial-hash -> trial data
+}
+
+/**
+ * Parsed trial result from Harbor output
+ */
+export interface ParsedHarborTrial {
+	taskId: string
+	trialHash: string
+	passed: boolean
+	duration: number
+	cost: number
+	tokensIn?: number
+	tokensOut?: number
+	logs: string // Full cline.txt content
+	testOutput: string // Test verification output
+	errors: string[] // Setup or command errors
+}
+
+/**
+ * Utility type for extracting trial directory paths
+ */
+export interface HarborTrialPath {
+	jobDir: string
+	trialDir: string
+	taskId: string
+	trialHash: string
+}
diff --git a/evals/analysis/src/schemas/index.ts b/evals/analysis/src/schemas/index.ts
new file mode 100644
index 0000000..1b62e6b
--- /dev/null
+++ b/evals/analysis/src/schemas/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Schema exports for Cline Analysis Framework
+ *
+ * This module provides TypeScript type definitions for:
+ * - Harbor framework output (read-only validation)
+ * - Analysis framework output (our structured results)
+ * - Comparison results (baseline vs current)
+ */
+
+export * from "./analysis-output"
+export * from "./harbor-output"
diff --git a/evals/analysis/tsconfig.json b/evals/analysis/tsconfig.json
new file mode 100644
index 0000000..293143a
--- /dev/null
+++ b/evals/analysis/tsconfig.json
@@ -0,0 +1,32 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": [
+			"ES2022"
+		],
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"types": [
+			"node",
+			"vitest/globals"
+		]
+	},
+	"include": [
+		"src/**/*"
+	],
+	"exclude": [
+		"node_modules",
+		"dist",
+		"src/**/*.test.ts"
+	]
+}
diff --git a/evals/benchmarks/tool-precision/DEPRECATED.md b/evals/benchmarks/tool-precision/DEPRECATED.md
new file mode 100644
index 0000000..fbe2f50
--- /dev/null
+++ b/evals/benchmarks/tool-precision/DEPRECATED.md
@@ -0,0 +1,17 @@
+# DEPRECATED
+
+This framework is kept for backward compatibility but is scheduled for removal.
+
+## Why It's Deprecated
+
+1. **Narrow scope**: Tests diff schema compliance, not general model capability
+2. **Better alternatives**: `cline-bench` provides real-world task evaluation
+3. **Maintenance burden**: Requires manual test case generation from conversations
+
+## If You're Using This
+
+Contact @ara or @robin before this gets removed. We can help migrate your use case to the smoke tests or cline-bench framework.
+
+## Removal Timeline
+
+Target: Q2 2026 (or when cline-bench is fully operational for model comparison)
diff --git a/evals/e2e/README.md b/evals/e2e/README.md
new file mode 100644
index 0000000..68a8c7c
--- /dev/null
+++ b/evals/e2e/README.md
@@ -0,0 +1,128 @@
+# E2E Agent Tests
+
+Full end-to-end tests using real-world tasks from cline-bench.
+
+## Overview
+
+These tests run Cline against production-grade coding problems derived from actual user sessions. Each task:
+- Starts with a broken codebase in Docker
+- Gives Cline the task description
+- Verifies the fix with pytest
+
+## Prerequisites
+
+1. **Python 3.13 with uv**
+   ```bash
+   # macOS
+   brew install python@3.13
+   pip install uv
+   ```
+
+2. **Harbor** (benchmark execution framework)
+   ```bash
+   uv tool install harbor
+   ```
+
+3. **Docker** (for local execution)
+   ```bash
+   # Verify Docker is running
+   docker info
+   ```
+
+4. **API Keys**
+   ```bash
+   export ANTHROPIC_API_KEY=sk-ant-...
+   # or
+   export API_KEY=sk-ant-...  # Generic fallback
+   ```
+
+## Running Locally
+
+```bash
+# Run all tasks with default settings (Anthropic, Docker)
+npx tsx evals/e2e/run-cline-bench.ts
+
+# Run specific task
+npx tsx evals/e2e/run-cline-bench.ts --tasks discord
+
+# Use different provider/model
+npx tsx evals/e2e/run-cline-bench.ts --provider openai --model gpt-4o
+
+# Run on Daytona cloud (faster, parallel)
+export DAYTONA_API_KEY=dtn_...
+npx tsx evals/e2e/run-cline-bench.ts --env daytona
+
+# Output to JSON
+npx tsx evals/e2e/run-cline-bench.ts --output results.json
+```
+
+## CLI Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--env` | `docker` | Execution environment: `docker` or `daytona` |
+| `--provider` | `anthropic` | Provider: `anthropic`, `openai`, `openrouter`, `gemini` |
+| `--model` | `claude-sonnet-4-20250514` | Model ID |
+| `--tasks` | `all` | Task filter pattern |
+| `--trials` | `1` | Number of trials per task |
+| `--output` | - | Write JSON results to file |
+
+## Tasks
+
+Current tasks from cline-bench (12 total):
+
+1. **every-plugin-api-migration** - Migrate API calls in plugin
+2. **police-sync-segfault** - Fix segmentation fault
+3. **intercept-axios-error-handling** - Fix Axios error handling
+4. **telegram-plugin-refactor** - Refactor Telegram plugin
+5. **discord-trivia-approval-keyerror** - Fix KeyError in Discord bot
+6. **terraform-azurerm-deployment-stacks** - Terraform provider fix
+7. **orpc-client-migration** - Client migration task
+8. **v-edit-workspace-tests** - Fix workspace tests
+9. **healthchain-prefetch-removal** - Remove prefetch logic
+10. **aenet-pytorch-pbc-neighborlist** - PyTorch PBC fix
+11. **suave-http-data-bleeding** - Fix HTTP data bleeding
+12. **filmarchiver** - Film archiver fixes
+
+## CI Integration
+
+These tests run nightly (not on every PR) due to:
+- Long execution time (20-30 min per task)
+- API costs (~$1-5 per run depending on model)
+- Docker/Daytona infrastructure requirements
+
+See `.github/workflows/nightly-evals.yml` for CI configuration.
+
+## Results
+
+Results are written to `evals/cline-bench/jobs/` directory by Harbor:
+
+```
+jobs/
+└── 2025-01-25__10-00-00/
+    ├── result.json              # Aggregate results
+    └── <task-id>__<hash>/
+        ├── result.json          # Trial result
+        ├── agent/cline.txt      # Conversation log
+        └── verifier/reward.txt  # 1 (pass) or 0 (fail)
+```
+
+## Troubleshooting
+
+### "Harbor not found"
+
+```bash
+source .venv/bin/activate  # If using venv
+uv tool install harbor
+```
+
+### "Docker not available"
+
+```bash
+# Start Docker daemon
+docker info  # Should show Docker info
+```
+
+### Task timeouts
+
+Some tasks (Qt WASM, Android) can take 20-30 minutes. If running locally, ensure Docker has sufficient resources (8GB+ RAM).
diff --git a/evals/e2e/run-cline-bench.ts b/evals/e2e/run-cline-bench.ts
new file mode 100644
index 0000000..445084a
--- /dev/null
+++ b/evals/e2e/run-cline-bench.ts
@@ -0,0 +1,334 @@
+#!/usr/bin/env npx tsx
+/**
+ * cline-bench Runner
+ *
+ * Runs real-world tasks from cline-bench using Harbor framework.
+ * Designed for nightly CI execution.
+ *
+ * Prerequisites:
+ *   - Python 3.13 with uv
+ *   - Harbor installed (`uv tool install harbor`)
+ *   - Docker (for local) or DAYTONA_API_KEY (for cloud)
+ *
+ * Usage:
+ *   npx tsx evals/e2e/run-cline-bench.ts [options]
+ *
+ * Options:
+ *   --env <docker|daytona>  Execution environment (default: docker)
+ *   --provider <name>       Provider to use (default: anthropic)
+ *   --model <id>            Model ID (default: claude-sonnet-4-20250514)
+ *   --tasks <pattern>       Task filter pattern (default: all)
+ *   --trials <n>            Number of trials per task (default: 1)
+ *   --output <file>         Write results to JSON file
+ */
+
+import { execSync, spawnSync } from "child_process"
+import * as fs from "fs"
+import * as path from "path"
+
+interface RunOptions {
+	env: "docker" | "daytona"
+	provider: string
+	model: string
+	tasks: string
+	trials: number
+	outputFile?: string
+}
+
+// Provider configurations for Harbor model format
+const PROVIDER_MODEL_PREFIX: Record<string, string> = {
+	anthropic: "anthropic",
+	openrouter: "openrouter",
+	openai: "openai-native",
+	gemini: "gemini", // Needs different handling
+}
+
+const PROVIDER_API_KEY_ENV: Record<string, string> = {
+	anthropic: "ANTHROPIC_API_KEY",
+	openrouter: "OPENROUTER_API_KEY",
+	openai: "OPENAI_API_KEY",
+	gemini: "GEMINI_API_KEY",
+}
+
+function checkPrerequisites(): { ok: boolean; error?: string } {
+	// Check Python
+	try {
+		const pythonVersion = execSync("python3 --version", { encoding: "utf-8" })
+		if (!pythonVersion.includes("3.13")) {
+			console.warn(`Warning: Python 3.13 recommended, found: ${pythonVersion.trim()}`)
+		}
+	} catch {
+		return { ok: false, error: "Python 3 not found" }
+	}
+
+	// Check Harbor
+	try {
+		execSync("which harbor", { encoding: "utf-8" })
+	} catch {
+		return { ok: false, error: "Harbor not found. Install with: uv tool install harbor" }
+	}
+
+	// Check Docker (for local env)
+	try {
+		execSync("docker info > /dev/null 2>&1")
+	} catch {
+		console.warn("Warning: Docker not available. Use --env daytona for cloud execution.")
+	}
+
+	return { ok: true }
+}
+
+function getTaskList(clineBenchDir: string, filter?: string): string[] {
+	const tasksDir = path.join(clineBenchDir, "tasks")
+	if (!fs.existsSync(tasksDir)) {
+		throw new Error(`Tasks directory not found: ${tasksDir}`)
+	}
+
+	let tasks = fs
+		.readdirSync(tasksDir, { withFileTypes: true })
+		.filter((d) => d.isDirectory())
+		.map((d) => d.name)
+
+	if (filter && filter !== "all") {
+		tasks = tasks.filter((t) => t.includes(filter))
+	}
+
+	return tasks
+}
+
+interface TaskResult {
+	taskId: string
+	passed: boolean
+	duration_sec: number
+	error?: string
+}
+
+function runHarborTask(clineBenchDir: string, taskId: string, options: RunOptions): TaskResult {
+	const startTime = Date.now()
+
+	// Build Harbor model string
+	const modelPrefix = PROVIDER_MODEL_PREFIX[options.provider] || options.provider
+	const harborModel = `${modelPrefix}:${options.model}`
+
+	// Set up environment
+	const apiKeyEnv = PROVIDER_API_KEY_ENV[options.provider]
+	const apiKey = process.env[apiKeyEnv] || process.env.API_KEY
+
+	if (!apiKey) {
+		return {
+			taskId,
+			passed: false,
+			duration_sec: 0,
+			error: `Missing API key: ${apiKeyEnv} or API_KEY`,
+		}
+	}
+
+	const harborEnv = {
+		...process.env,
+		API_KEY: apiKey,
+	}
+
+	// Build Harbor command
+	const harborArgs = ["run", "-p", `tasks/${taskId}`, "-a", "cline-cli", "-m", harborModel, "--env", options.env]
+
+	console.log(`  Running: harbor ${harborArgs.join(" ")}`)
+
+	try {
+		const result = spawnSync("harbor", harborArgs, {
+			cwd: clineBenchDir,
+			env: harborEnv,
+			stdio: ["inherit", "pipe", "pipe"],
+			timeout: 30 * 60 * 1000, // 30 minutes
+		})
+
+		const duration_sec = (Date.now() - startTime) / 1000
+
+		if (result.status !== 0) {
+			return {
+				taskId,
+				passed: false,
+				duration_sec,
+				error: result.stderr?.toString() || `Exit code: ${result.status}`,
+			}
+		}
+
+		// Check if task passed by looking at the latest job results
+		// Harbor writes results to jobs/ directory
+		const jobsDir = path.join(clineBenchDir, "jobs")
+		if (fs.existsSync(jobsDir)) {
+			const latestJob = fs
+				.readdirSync(jobsDir)
+				.filter((d) => d.startsWith("2"))
+				.sort()
+				.pop()
+
+			if (latestJob) {
+				const jobDir = path.join(jobsDir, latestJob)
+				const trialDirs = fs.readdirSync(jobDir).filter((d) => d.includes(taskId.substring(0, 10)))
+
+				for (const trialDir of trialDirs) {
+					const rewardFile = path.join(jobDir, trialDir, "verifier", "reward.txt")
+					if (fs.existsSync(rewardFile)) {
+						const reward = fs.readFileSync(rewardFile, "utf-8").trim()
+						return {
+							taskId,
+							passed: reward === "1",
+							duration_sec,
+						}
+					}
+				}
+			}
+		}
+
+		// Couldn't determine result from files
+		return {
+			taskId,
+			passed: false,
+			duration_sec,
+			error: "Could not determine task result",
+		}
+	} catch (error: any) {
+		return {
+			taskId,
+			passed: false,
+			duration_sec: (Date.now() - startTime) / 1000,
+			error: error.message || String(error),
+		}
+	}
+}
+
+interface BenchmarkReport {
+	timestamp: string
+	provider: string
+	model: string
+	environment: string
+	trialsPerTask: number
+	results: TaskResult[]
+	summary: {
+		total: number
+		passed: number
+		failed: number
+		passRate: number
+	}
+}
+
+async function main() {
+	const args = process.argv.slice(2)
+
+	// Parse arguments
+	const options: RunOptions = {
+		env: "docker",
+		provider: "anthropic",
+		model: "claude-sonnet-4-20250514",
+		tasks: "all",
+		trials: 1,
+	}
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--env" && args[i + 1]) {
+			options.env = args[++i] as "docker" | "daytona"
+		} else if (args[i] === "--provider" && args[i + 1]) {
+			options.provider = args[++i]
+		} else if (args[i] === "--model" && args[i + 1]) {
+			options.model = args[++i]
+		} else if (args[i] === "--tasks" && args[i + 1]) {
+			options.tasks = args[++i]
+		} else if (args[i] === "--trials" && args[i + 1]) {
+			options.trials = parseInt(args[++i], 10)
+		} else if (args[i] === "--output" && args[i + 1]) {
+			options.outputFile = args[++i]
+		}
+	}
+
+	// Check prerequisites
+	const prereq = checkPrerequisites()
+	if (!prereq.ok) {
+		console.error(`Prerequisite check failed: ${prereq.error}`)
+		process.exit(1)
+	}
+
+	// Find cline-bench directory
+	const clineBenchDir = path.join(__dirname, "..", "cline-bench")
+	if (!fs.existsSync(clineBenchDir)) {
+		console.error(`cline-bench not found at: ${clineBenchDir}`)
+		console.error("Ensure the submodule is initialized: git submodule update --init")
+		process.exit(1)
+	}
+
+	// Get task list
+	const tasks = getTaskList(clineBenchDir, options.tasks)
+	if (tasks.length === 0) {
+		console.error("No tasks found matching filter:", options.tasks)
+		process.exit(1)
+	}
+
+	console.log(`cline-bench E2E Runner`)
+	console.log(`======================`)
+	console.log(`Provider: ${options.provider}`)
+	console.log(`Model: ${options.model}`)
+	console.log(`Environment: ${options.env}`)
+	console.log(`Tasks: ${tasks.length}`)
+	console.log(`Trials per task: ${options.trials}`)
+	console.log("")
+
+	const results: TaskResult[] = []
+
+	// Run tasks
+	for (const taskId of tasks) {
+		console.log(`\n[${taskId}]`)
+
+		for (let trial = 0; trial < options.trials; trial++) {
+			if (options.trials > 1) {
+				console.log(`  Trial ${trial + 1}/${options.trials}`)
+			}
+
+			const result = runHarborTask(clineBenchDir, taskId, options)
+			results.push(result)
+
+			console.log(`  Result: ${result.passed ? "✓ PASS" : `✗ FAIL: ${result.error || "unknown"}`}`)
+			console.log(`  Duration: ${result.duration_sec.toFixed(1)}s`)
+		}
+	}
+
+	// Generate report
+	const passed = results.filter((r) => r.passed).length
+	const report: BenchmarkReport = {
+		timestamp: new Date().toISOString(),
+		provider: options.provider,
+		model: options.model,
+		environment: options.env,
+		trialsPerTask: options.trials,
+		results,
+		summary: {
+			total: results.length,
+			passed,
+			failed: results.length - passed,
+			passRate: results.length > 0 ? passed / results.length : 0,
+		},
+	}
+
+	// Output
+	if (options.outputFile) {
+		fs.writeFileSync(options.outputFile, JSON.stringify(report, null, 2))
+		console.log(`\nResults written to: ${options.outputFile}`)
+	}
+
+	// Summary
+	console.log("\n" + "=".repeat(60))
+	console.log("SUMMARY")
+	console.log("=".repeat(60))
+	console.log(`Total: ${report.summary.total}`)
+	console.log(`Passed: ${report.summary.passed}`)
+	console.log(`Failed: ${report.summary.failed}`)
+	console.log(`Pass Rate: ${(report.summary.passRate * 100).toFixed(1)}%`)
+
+	// Exit with error if any failures
+	if (report.summary.failed > 0) {
+		process.exit(1)
+	}
+}
+
+main().catch((err) => {
+	console.error(err)
+	process.exit(1)
+})
diff --git a/evals/package-lock.json b/evals/package-lock.json
new file mode 100644
index 0000000..09ad789
--- /dev/null
+++ b/evals/package-lock.json
@@ -0,0 +1,1142 @@
+{
+	"name": "cline-evals",
+	"version": "2.0.0",
+	"lockfileVersion": 2,
+	"requires": true,
+	"packages": {
+		"": {
+			"name": "cline-evals",
+			"version": "2.0.0",
+			"license": "MIT",
+			"dependencies": {
+				"better-sqlite3": "^12.4.1",
+				"chalk": "5.6.2",
+				"commander": "^9.4.1",
+				"dotenv": "^16.5.0",
+				"tiktoken": "^1.0.21"
+			},
+			"devDependencies": {
+				"@types/better-sqlite3": "^7.6.3",
+				"@types/node": "^18.11.18",
+				"ts-node": "^10.9.1",
+				"typescript": "^4.9.4"
+			}
+		},
+		"node_modules/@cspotcode/source-map-support": {
+			"version": "0.8.1",
+			"resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
+			"integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+			"dev": true,
+			"dependencies": {
+				"@jridgewell/trace-mapping": "0.3.9"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/@jridgewell/resolve-uri": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+			"integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+			"dev": true,
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/@jridgewell/sourcemap-codec": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+			"integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+			"dev": true
+		},
+		"node_modules/@jridgewell/trace-mapping": {
+			"version": "0.3.9",
+			"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
+			"integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
+			"dev": true,
+			"dependencies": {
+				"@jridgewell/resolve-uri": "^3.0.3",
+				"@jridgewell/sourcemap-codec": "^1.4.10"
+			}
+		},
+		"node_modules/@tsconfig/node10": {
+			"version": "1.0.11",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz",
+			"integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==",
+			"dev": true
+		},
+		"node_modules/@tsconfig/node12": {
+			"version": "1.0.11",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
+			"integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
+			"dev": true
+		},
+		"node_modules/@tsconfig/node14": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
+			"integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
+			"dev": true
+		},
+		"node_modules/@tsconfig/node16": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
+			"integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
+			"dev": true
+		},
+		"node_modules/@types/better-sqlite3": {
+			"version": "7.6.13",
+			"resolved": "https://registry.npmjs.org/@types/better-sqlite3/-/better-sqlite3-7.6.13.tgz",
+			"integrity": "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA==",
+			"dev": true,
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@types/node": {
+			"version": "18.19.112",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.112.tgz",
+			"integrity": "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog==",
+			"dev": true,
+			"dependencies": {
+				"undici-types": "~5.26.4"
+			}
+		},
+		"node_modules/acorn": {
+			"version": "8.15.0",
+			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+			"integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+			"dev": true,
+			"bin": {
+				"acorn": "bin/acorn"
+			},
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/acorn-walk": {
+			"version": "8.3.4",
+			"resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
+			"integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
+			"dev": true,
+			"dependencies": {
+				"acorn": "^8.11.0"
+			},
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/arg": {
+			"version": "4.1.3",
+			"resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
+			"integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
+			"dev": true
+		},
+		"node_modules/base64-js": {
+			"version": "1.5.1",
+			"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+			"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			]
+		},
+		"node_modules/better-sqlite3": {
+			"version": "12.4.1",
+			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
+			"integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
+			"hasInstallScript": true,
+			"license": "MIT",
+			"dependencies": {
+				"bindings": "^1.5.0",
+				"prebuild-install": "^7.1.1"
+			},
+			"engines": {
+				"node": "20.x || 22.x || 23.x || 24.x"
+			}
+		},
+		"node_modules/bindings": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+			"integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+			"dependencies": {
+				"file-uri-to-path": "1.0.0"
+			}
+		},
+		"node_modules/bl": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
+			"integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
+			"dependencies": {
+				"buffer": "^5.5.0",
+				"inherits": "^2.0.4",
+				"readable-stream": "^3.4.0"
+			}
+		},
+		"node_modules/buffer": {
+			"version": "5.7.1",
+			"resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+			"integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"dependencies": {
+				"base64-js": "^1.3.1",
+				"ieee754": "^1.1.13"
+			}
+		},
+		"node_modules/chalk": {
+			"version": "5.6.2",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+			"integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.17.0 || ^14.13 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/chalk?sponsor=1"
+			}
+		},
+		"node_modules/chownr": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
+			"integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==",
+			"license": "ISC"
+		},
+		"node_modules/commander": {
+			"version": "9.5.0",
+			"resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+			"integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+			"engines": {
+				"node": "^12.20.0 || >=14"
+			}
+		},
+		"node_modules/create-require": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
+			"integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
+			"dev": true
+		},
+		"node_modules/decompress-response": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+			"integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+			"dependencies": {
+				"mimic-response": "^3.1.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/deep-extend": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+			"integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+			"engines": {
+				"node": ">=4.0.0"
+			}
+		},
+		"node_modules/detect-libc": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+			"integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/diff": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
+			"integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
+			"dev": true,
+			"engines": {
+				"node": ">=0.3.1"
+			}
+		},
+		"node_modules/dotenv": {
+			"version": "16.5.0",
+			"resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.5.0.tgz",
+			"integrity": "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://dotenvx.com"
+			}
+		},
+		"node_modules/end-of-stream": {
+			"version": "1.4.5",
+			"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+			"integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+			"dependencies": {
+				"once": "^1.4.0"
+			}
+		},
+		"node_modules/expand-template": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
+			"integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/file-uri-to-path": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+			"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="
+		},
+		"node_modules/fs-constants": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
+			"integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
+			"license": "MIT"
+		},
+		"node_modules/github-from-package": {
+			"version": "0.0.0",
+			"resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
+			"integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="
+		},
+		"node_modules/ieee754": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+			"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			]
+		},
+		"node_modules/inherits": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+			"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+		},
+		"node_modules/ini": {
+			"version": "1.3.8",
+			"resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+			"integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
+		},
+		"node_modules/make-error": {
+			"version": "1.3.6",
+			"resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
+			"integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+			"dev": true
+		},
+		"node_modules/mimic-response": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+			"integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/minimist": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+			"integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/mkdirp-classic": {
+			"version": "0.5.3",
+			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
+			"integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="
+		},
+		"node_modules/napi-build-utils": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz",
+			"integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA=="
+		},
+		"node_modules/node-abi": {
+			"version": "3.75.0",
+			"resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.75.0.tgz",
+			"integrity": "sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/once": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+			"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+			"dependencies": {
+				"wrappy": "1"
+			}
+		},
+		"node_modules/prebuild-install": {
+			"version": "7.1.3",
+			"resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
+			"integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==",
+			"dependencies": {
+				"detect-libc": "^2.0.0",
+				"expand-template": "^2.0.3",
+				"github-from-package": "0.0.0",
+				"minimist": "^1.2.3",
+				"mkdirp-classic": "^0.5.3",
+				"napi-build-utils": "^2.0.0",
+				"node-abi": "^3.3.0",
+				"pump": "^3.0.0",
+				"rc": "^1.2.7",
+				"simple-get": "^4.0.0",
+				"tar-fs": "^2.0.0",
+				"tunnel-agent": "^0.6.0"
+			},
+			"bin": {
+				"prebuild-install": "bin.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/prebuild-install/node_modules/tar-fs": {
+			"version": "2.1.4",
+			"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+			"integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
+			"license": "MIT",
+			"dependencies": {
+				"chownr": "^1.1.1",
+				"mkdirp-classic": "^0.5.2",
+				"pump": "^3.0.0",
+				"tar-stream": "^2.1.4"
+			}
+		},
+		"node_modules/prebuild-install/node_modules/tar-stream": {
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
+			"integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
+			"license": "MIT",
+			"dependencies": {
+				"bl": "^4.0.3",
+				"end-of-stream": "^1.4.1",
+				"fs-constants": "^1.0.0",
+				"inherits": "^2.0.3",
+				"readable-stream": "^3.1.1"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/pump": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+			"integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+			"dependencies": {
+				"end-of-stream": "^1.1.0",
+				"once": "^1.3.1"
+			}
+		},
+		"node_modules/rc": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+			"integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+			"dependencies": {
+				"deep-extend": "^0.6.0",
+				"ini": "~1.3.0",
+				"minimist": "^1.2.0",
+				"strip-json-comments": "~2.0.1"
+			},
+			"bin": {
+				"rc": "cli.js"
+			}
+		},
+		"node_modules/readable-stream": {
+			"version": "3.6.2",
+			"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+			"integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+			"dependencies": {
+				"inherits": "^2.0.3",
+				"string_decoder": "^1.1.1",
+				"util-deprecate": "^1.0.1"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/safe-buffer": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+			"integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			]
+		},
+		"node_modules/semver": {
+			"version": "7.7.2",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+			"integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+			"bin": {
+				"semver": "bin/semver.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/simple-concat": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+			"integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			]
+		},
+		"node_modules/simple-get": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz",
+			"integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"dependencies": {
+				"decompress-response": "^6.0.0",
+				"once": "^1.3.1",
+				"simple-concat": "^1.0.0"
+			}
+		},
+		"node_modules/string_decoder": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+			"integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+			"dependencies": {
+				"safe-buffer": "~5.2.0"
+			}
+		},
+		"node_modules/strip-json-comments": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+			"integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/tiktoken": {
+			"version": "1.0.21",
+			"resolved": "https://registry.npmjs.org/tiktoken/-/tiktoken-1.0.21.tgz",
+			"integrity": "sha512-/kqtlepLMptX0OgbYD9aMYbM7EFrMZCL7EoHM8Psmg2FuhXoo/bH64KqOiZGGwa6oS9TPdSEDKBnV2LuB8+5vQ=="
+		},
+		"node_modules/ts-node": {
+			"version": "10.9.2",
+			"resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
+			"integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+			"dev": true,
+			"dependencies": {
+				"@cspotcode/source-map-support": "^0.8.0",
+				"@tsconfig/node10": "^1.0.7",
+				"@tsconfig/node12": "^1.0.7",
+				"@tsconfig/node14": "^1.0.0",
+				"@tsconfig/node16": "^1.0.2",
+				"acorn": "^8.4.1",
+				"acorn-walk": "^8.1.1",
+				"arg": "^4.1.0",
+				"create-require": "^1.1.0",
+				"diff": "^4.0.1",
+				"make-error": "^1.1.1",
+				"v8-compile-cache-lib": "^3.0.1",
+				"yn": "3.1.1"
+			},
+			"bin": {
+				"ts-node": "dist/bin.js",
+				"ts-node-cwd": "dist/bin-cwd.js",
+				"ts-node-esm": "dist/bin-esm.js",
+				"ts-node-script": "dist/bin-script.js",
+				"ts-node-transpile-only": "dist/bin-transpile.js",
+				"ts-script": "dist/bin-script-deprecated.js"
+			},
+			"peerDependencies": {
+				"@swc/core": ">=1.2.50",
+				"@swc/wasm": ">=1.2.50",
+				"@types/node": "*",
+				"typescript": ">=2.7"
+			},
+			"peerDependenciesMeta": {
+				"@swc/core": {
+					"optional": true
+				},
+				"@swc/wasm": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/tunnel-agent": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+			"integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==",
+			"dependencies": {
+				"safe-buffer": "^5.0.1"
+			},
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/typescript": {
+			"version": "4.9.5",
+			"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
+			"integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
+			"dev": true,
+			"bin": {
+				"tsc": "bin/tsc",
+				"tsserver": "bin/tsserver"
+			},
+			"engines": {
+				"node": ">=4.2.0"
+			}
+		},
+		"node_modules/undici-types": {
+			"version": "5.26.5",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+			"integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+			"dev": true
+		},
+		"node_modules/util-deprecate": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+			"integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
+		},
+		"node_modules/v8-compile-cache-lib": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
+			"integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
+			"dev": true
+		},
+		"node_modules/wrappy": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+			"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+		},
+		"node_modules/yn": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
+			"integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
+			"dev": true,
+			"engines": {
+				"node": ">=6"
+			}
+		}
+	},
+	"dependencies": {
+		"@cspotcode/source-map-support": {
+			"version": "0.8.1",
+			"resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
+			"integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+			"dev": true,
+			"requires": {
+				"@jridgewell/trace-mapping": "0.3.9"
+			}
+		},
+		"@jridgewell/resolve-uri": {
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+			"integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+			"dev": true
+		},
+		"@jridgewell/sourcemap-codec": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+			"integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+			"dev": true
+		},
+		"@jridgewell/trace-mapping": {
+			"version": "0.3.9",
+			"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
+			"integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
+			"dev": true,
+			"requires": {
+				"@jridgewell/resolve-uri": "^3.0.3",
+				"@jridgewell/sourcemap-codec": "^1.4.10"
+			}
+		},
+		"@tsconfig/node10": {
+			"version": "1.0.11",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz",
+			"integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==",
+			"dev": true
+		},
+		"@tsconfig/node12": {
+			"version": "1.0.11",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
+			"integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
+			"dev": true
+		},
+		"@tsconfig/node14": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
+			"integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
+			"dev": true
+		},
+		"@tsconfig/node16": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
+			"integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
+			"dev": true
+		},
+		"@types/better-sqlite3": {
+			"version": "7.6.13",
+			"resolved": "https://registry.npmjs.org/@types/better-sqlite3/-/better-sqlite3-7.6.13.tgz",
+			"integrity": "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA==",
+			"dev": true,
+			"requires": {
+				"@types/node": "*"
+			}
+		},
+		"@types/node": {
+			"version": "18.19.112",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.112.tgz",
+			"integrity": "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog==",
+			"dev": true,
+			"requires": {
+				"undici-types": "~5.26.4"
+			}
+		},
+		"acorn": {
+			"version": "8.15.0",
+			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+			"integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+			"dev": true
+		},
+		"acorn-walk": {
+			"version": "8.3.4",
+			"resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
+			"integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
+			"dev": true,
+			"requires": {
+				"acorn": "^8.11.0"
+			}
+		},
+		"arg": {
+			"version": "4.1.3",
+			"resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
+			"integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
+			"dev": true
+		},
+		"base64-js": {
+			"version": "1.5.1",
+			"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+			"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="
+		},
+		"better-sqlite3": {
+			"version": "12.4.1",
+			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
+			"integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
+			"requires": {
+				"bindings": "^1.5.0",
+				"prebuild-install": "^7.1.1"
+			}
+		},
+		"bindings": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+			"integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+			"requires": {
+				"file-uri-to-path": "1.0.0"
+			}
+		},
+		"bl": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
+			"integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
+			"requires": {
+				"buffer": "^5.5.0",
+				"inherits": "^2.0.4",
+				"readable-stream": "^3.4.0"
+			}
+		},
+		"buffer": {
+			"version": "5.7.1",
+			"resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+			"integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+			"requires": {
+				"base64-js": "^1.3.1",
+				"ieee754": "^1.1.13"
+			}
+		},
+		"chalk": {
+			"version": "5.6.2",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+			"integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="
+		},
+		"chownr": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
+			"integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="
+		},
+		"commander": {
+			"version": "9.5.0",
+			"resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+			"integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ=="
+		},
+		"create-require": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
+			"integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
+			"dev": true
+		},
+		"decompress-response": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+			"integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+			"requires": {
+				"mimic-response": "^3.1.0"
+			}
+		},
+		"deep-extend": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+			"integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA=="
+		},
+		"detect-libc": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+			"integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="
+		},
+		"diff": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
+			"integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
+			"dev": true
+		},
+		"dotenv": {
+			"version": "16.5.0",
+			"resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.5.0.tgz",
+			"integrity": "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg=="
+		},
+		"end-of-stream": {
+			"version": "1.4.5",
+			"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+			"integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+			"requires": {
+				"once": "^1.4.0"
+			}
+		},
+		"expand-template": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
+			"integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="
+		},
+		"file-uri-to-path": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+			"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="
+		},
+		"fs-constants": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
+			"integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="
+		},
+		"github-from-package": {
+			"version": "0.0.0",
+			"resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
+			"integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="
+		},
+		"ieee754": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+			"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="
+		},
+		"inherits": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+			"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+		},
+		"ini": {
+			"version": "1.3.8",
+			"resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+			"integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
+		},
+		"make-error": {
+			"version": "1.3.6",
+			"resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
+			"integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+			"dev": true
+		},
+		"mimic-response": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+			"integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="
+		},
+		"minimist": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+			"integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="
+		},
+		"mkdirp-classic": {
+			"version": "0.5.3",
+			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
+			"integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="
+		},
+		"napi-build-utils": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz",
+			"integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA=="
+		},
+		"node-abi": {
+			"version": "3.75.0",
+			"resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.75.0.tgz",
+			"integrity": "sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==",
+			"requires": {
+				"semver": "^7.3.5"
+			}
+		},
+		"once": {
+			"version": "1.4.0",
+			"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+			"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+			"requires": {
+				"wrappy": "1"
+			}
+		},
+		"prebuild-install": {
+			"version": "7.1.3",
+			"resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
+			"integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==",
+			"requires": {
+				"detect-libc": "^2.0.0",
+				"expand-template": "^2.0.3",
+				"github-from-package": "0.0.0",
+				"minimist": "^1.2.3",
+				"mkdirp-classic": "^0.5.3",
+				"napi-build-utils": "^2.0.0",
+				"node-abi": "^3.3.0",
+				"pump": "^3.0.0",
+				"rc": "^1.2.7",
+				"simple-get": "^4.0.0",
+				"tar-fs": "^2.0.0",
+				"tunnel-agent": "^0.6.0"
+			},
+			"dependencies": {
+				"tar-fs": {
+					"version": "2.1.4",
+					"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+					"integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
+					"requires": {
+						"chownr": "^1.1.1",
+						"mkdirp-classic": "^0.5.2",
+						"pump": "^3.0.0",
+						"tar-stream": "^2.1.4"
+					}
+				},
+				"tar-stream": {
+					"version": "2.2.0",
+					"resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
+					"integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
+					"requires": {
+						"bl": "^4.0.3",
+						"end-of-stream": "^1.4.1",
+						"fs-constants": "^1.0.0",
+						"inherits": "^2.0.3",
+						"readable-stream": "^3.1.1"
+					}
+				}
+			}
+		},
+		"pump": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+			"integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+			"requires": {
+				"end-of-stream": "^1.1.0",
+				"once": "^1.3.1"
+			}
+		},
+		"rc": {
+			"version": "1.2.8",
+			"resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+			"integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+			"requires": {
+				"deep-extend": "^0.6.0",
+				"ini": "~1.3.0",
+				"minimist": "^1.2.0",
+				"strip-json-comments": "~2.0.1"
+			}
+		},
+		"readable-stream": {
+			"version": "3.6.2",
+			"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+			"integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+			"requires": {
+				"inherits": "^2.0.3",
+				"string_decoder": "^1.1.1",
+				"util-deprecate": "^1.0.1"
+			}
+		},
+		"safe-buffer": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+			"integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
+		},
+		"semver": {
+			"version": "7.7.2",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+			"integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="
+		},
+		"simple-concat": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+			"integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q=="
+		},
+		"simple-get": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz",
+			"integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==",
+			"requires": {
+				"decompress-response": "^6.0.0",
+				"once": "^1.3.1",
+				"simple-concat": "^1.0.0"
+			}
+		},
+		"string_decoder": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+			"integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+			"requires": {
+				"safe-buffer": "~5.2.0"
+			}
+		},
+		"strip-json-comments": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+			"integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ=="
+		},
+		"tiktoken": {
+			"version": "1.0.21",
+			"resolved": "https://registry.npmjs.org/tiktoken/-/tiktoken-1.0.21.tgz",
+			"integrity": "sha512-/kqtlepLMptX0OgbYD9aMYbM7EFrMZCL7EoHM8Psmg2FuhXoo/bH64KqOiZGGwa6oS9TPdSEDKBnV2LuB8+5vQ=="
+		},
+		"ts-node": {
+			"version": "10.9.2",
+			"resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
+			"integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+			"dev": true,
+			"requires": {
+				"@cspotcode/source-map-support": "^0.8.0",
+				"@tsconfig/node10": "^1.0.7",
+				"@tsconfig/node12": "^1.0.7",
+				"@tsconfig/node14": "^1.0.0",
+				"@tsconfig/node16": "^1.0.2",
+				"acorn": "^8.4.1",
+				"acorn-walk": "^8.1.1",
+				"arg": "^4.1.0",
+				"create-require": "^1.1.0",
+				"diff": "^4.0.1",
+				"make-error": "^1.1.1",
+				"v8-compile-cache-lib": "^3.0.1",
+				"yn": "3.1.1"
+			}
+		},
+		"tunnel-agent": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+			"integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==",
+			"requires": {
+				"safe-buffer": "^5.0.1"
+			}
+		},
+		"typescript": {
+			"version": "4.9.5",
+			"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
+			"integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
+			"dev": true
+		},
+		"undici-types": {
+			"version": "5.26.5",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+			"integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+			"dev": true
+		},
+		"util-deprecate": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+			"integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
+		},
+		"v8-compile-cache-lib": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
+			"integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
+			"dev": true
+		},
+		"wrappy": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+			"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+		},
+		"yn": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
+			"integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
+			"dev": true
+		}
+	},
+	"overrides": {
+		"tar-fs": ">=2.1.4"
+	}
+}
diff --git a/evals/package.json b/evals/package.json
new file mode 100644
index 0000000..b1a387a
--- /dev/null
+++ b/evals/package.json
@@ -0,0 +1,22 @@
+{
+	"name": "cline-evals",
+	"version": "2.0.0",
+	"description": "Evaluation framework for Cline: smoke tests, analysis, and benchmarks",
+	"scripts": {
+		"analysis": "cd analysis && npm start --"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"better-sqlite3": "^12.4.1",
+		"chalk": "5.6.2",
+		"commander": "^9.4.1",
+		"dotenv": "^16.5.0",
+		"tiktoken": "^1.0.21"
+	},
+	"devDependencies": {
+		"@types/better-sqlite3": "^7.6.3",
+		"@types/node": "^18.11.18",
+		"ts-node": "^10.9.1",
+		"typescript": "^4.9.4"
+	}
+}
\ No newline at end of file
diff --git a/evals/smoke-tests/README.md b/evals/smoke-tests/README.md
new file mode 100644
index 0000000..cb0bdd9
--- /dev/null
+++ b/evals/smoke-tests/README.md
@@ -0,0 +1,122 @@
+# Smoke Tests
+
+Curated smoke tests that verify Cline works correctly with LLM providers.
+
+## Purpose
+
+These tests catch regressions in:
+- Tool execution (read, write, edit files)
+- Provider response parsing
+- Tool chaining (multiple operations)
+- Basic code generation
+
+## Quick Start
+
+```bash
+# One-time auth setup
+cline auth
+
+# Run tests (3 trials by default)
+npm run eval:smoke:run
+```
+
+## Commands
+
+| Command | What it does |
+|---------|--------------|
+| `npm run eval:smoke:run` | Run tests (uses installed CLI) |
+
+## Options
+
+```bash
+# Run specific scenario
+npm run eval:smoke:run -- --scenario 01-create-file
+
+# Run with fewer trials (faster)
+npm run eval:smoke:run -- --trials 1
+
+# Run with specific model (overrides any per-scenario models)
+npm run eval:smoke:run -- --model claude-sonnet-4-5-20250929
+```
+
+## Authentication
+
+### Interactive (recommended for local dev)
+
+```bash
+cline auth
+```
+
+### With API key (for automation)
+
+```bash
+cline auth -p cline -k "$CLINE_API_KEY" -m anthropic/claude-sonnet-4.5
+```
+
+## Scenarios
+
+| ID | Name | What it tests |
+|----|------|---------------|
+| 01-create-file | Create a simple file | `write_to_file` |
+| 02-edit-file | Edit existing file | `replace_in_file` |
+| 03-read-summarize | Read and summarize | `read_file` |
+| 04-multi-file | Create multiple files | Multiple tool calls |
+| 05-typescript-function | Generate TypeScript | Code generation |
+| 06-apply-patch | Edit file (GPT-5) | `apply_patch` tool, native tool calling |
+| 07-edit-gemini | Edit file (Gemini) | Gemini model variant |
+
+### Per-Scenario Models
+
+Scenarios can specify their own model(s) via the `models` field in `config.json`. This is useful for testing model-specific code paths like `apply_patch` (GPT-5 only).
+
+If you pass `--model`, it overrides any per-scenario `models` list.
+
+Examples:
+```bash
+# Run apply_patch scenario with its default model (GPT-5)
+npm run eval:smoke:run -- --scenario 06-apply-patch
+
+# Force that scenario to use a specific model
+npm run eval:smoke:run -- --scenario 06-apply-patch --model openai/gpt-4o
+```
+
+## Metrics
+
+- **pass@k**: Probability at least 1 of k trials succeeds
+- **pass^k**: Probability ALL k trials succeed (reliability)
+
+Shows `pass@1` when trials < 3, `pass@3` otherwise.
+
+## Adding New Scenarios
+
+1. Create directory: `scenarios/<name>/`
+2. Add `config.json`:
+   ```json
+   {
+     "name": "Human-readable name",
+     "description": "What this tests",
+     "prompt": "The task prompt for Cline",
+     "expectedFiles": ["file1.txt"],
+     "expectedContent": [
+       { "file": "file1.txt", "contains": "expected text" }
+     ],
+     "timeout": 60
+   }
+   ```
+3. (Optional) Add `template/` directory with starting files
+
+## CI Integration
+
+Smoke test CI is temporarily disabled while the build step is repointed at the SDK CLI. The remaining root script runs the scenarios against whichever `cline` binary is already on `$PATH`.
+
+### Required Secrets
+
+- `CLINE_API_KEY` - Cline API key, needed when CI is re-enabled
+
+### Viewing Results
+
+- Local summaries are written under `evals/smoke-tests/results/latest/`
+
+## TODO
+
+- [ ] Native tool calling tests: Add CLI support for `native_tool_call_enabled` setting, then create a scenario that tests Claude 4 with native tool calling enabled (currently only GPT-5 models automatically use native tools via the Responses API)
diff --git a/evals/smoke-tests/run-smoke-tests.ts b/evals/smoke-tests/run-smoke-tests.ts
new file mode 100644
index 0000000..62250ea
--- /dev/null
+++ b/evals/smoke-tests/run-smoke-tests.ts
@@ -0,0 +1,749 @@
+#!/usr/bin/env npx tsx
+/**
+ * Smoke Test Runner for Cline
+ *
+ * Runs curated smoke tests against configured providers to verify:
+ * - Basic tool execution works
+ * - Provider responses are correctly parsed
+ * - Thinking traces are preserved
+ *
+ * Usage:
+ *   npx tsx evals/smoke-tests/run-smoke-tests.ts [options]
+ *
+ * Options:
+ *   --trials <n>       Number of trials per test (default: 3)
+ *   --scenario <name>  Run a specific scenario (default: all)
+ *   --model <id>       Override model for all scenarios
+ *   --output <file>    Write JSON results to file
+ */
+
+import { execSync, spawn } from "child_process"
+import * as fs from "fs"
+import * as path from "path"
+import * as dotenv from "dotenv"
+import { MetricsCalculator } from "../analysis/src/metrics"
+
+// Default provider and model for smoke tests
+// These ensure deterministic behavior regardless of local config
+const DEFAULT_PROVIDER = "cline"
+const DEFAULT_MODEL = "anthropic/claude-sonnet-4.5"
+
+// Models to test - can be overridden with --model flag
+const MODELS: string[] = [DEFAULT_MODEL]
+
+// Check if cline CLI is available
+function checkClineCli(): boolean {
+	try {
+		execSync("which cline", { encoding: "utf-8", timeout: 5000 })
+		return true
+	} catch {
+		return false
+	}
+}
+
+// Use user's existing Cline config (already has auth configured)
+// For CI, this would be set up by the auth step before tests run
+const CLINE_CONFIG_DIR = path.join(process.env.HOME || "", ".cline")
+const configuredAuthCache = new Set<string>()
+
+function configureAuth(options: { provider: string; apiKey: string; modelId: string; baseUrl?: string }): {
+	ok: boolean
+	error?: string
+} {
+	// Ensure config directory exists
+	fs.mkdirSync(CLINE_CONFIG_DIR, { recursive: true })
+
+	try {
+		// Run quick auth setup (non-interactive when all flags provided)
+		const args = [`cline auth --config "${CLINE_CONFIG_DIR}"`, `-p "${options.provider}"`, `-k "${options.apiKey}"`, `-m "${options.modelId}"`]
+		if (options.baseUrl) {
+			args.push(`-b "${options.baseUrl}"`)
+		}
+
+		execSync(args.join(" "), {
+			encoding: "utf-8",
+			timeout: 10000,
+			stdio: "pipe",
+		})
+		return { ok: true }
+	} catch (err: any) {
+		return {
+			ok: false,
+			error: err.message || "Auth command failed",
+		}
+	}
+}
+
+function loadEnvFiles(): void {
+	const repoRoot = path.resolve(__dirname, "..", "..")
+	const envFiles = [path.join(repoRoot, ".env"), path.join(repoRoot, ".env.local")]
+	for (const envPath of envFiles) {
+		if (fs.existsSync(envPath)) {
+			dotenv.config({ path: envPath, override: false })
+		}
+	}
+}
+
+interface ScenarioAuthConfig {
+	apiKeyEnv?: string
+	baseUrlEnv?: string
+	modelId?: string
+}
+
+// Smoke test scenario definition
+interface SmokeScenario {
+	id: string
+	name: string
+	description: string
+	prompt: string
+	workdir: string // Relative to scenario directory
+	expectedFiles?: string[] // Files that should exist after
+	expectedContent?: { file: string; contains: string }[] // Content checks
+	timeout: number // Seconds
+	models?: string[] // Optional: override default models for this scenario
+	provider?: string // Provider override (defaults to DEFAULT_PROVIDER)
+	requiredEnv?: string[] // Env vars required for this scenario to run
+	auth?: ScenarioAuthConfig // Optional auth overrides for provider-specific scenarios
+}
+
+// Load scenarios from disk
+function loadScenarios(scenariosDir: string): SmokeScenario[] {
+	const scenarios: SmokeScenario[] = []
+
+	for (const entry of fs.readdirSync(scenariosDir, { withFileTypes: true })) {
+		if (entry.isDirectory()) {
+			const configPath = path.join(scenariosDir, entry.name, "config.json")
+			if (fs.existsSync(configPath)) {
+				const config = JSON.parse(fs.readFileSync(configPath, "utf-8"))
+				scenarios.push({
+					...config,
+					id: entry.name,
+					workdir: path.join(scenariosDir, entry.name, "workspace"),
+				})
+			}
+		}
+	}
+
+	return scenarios
+}
+
+function getMissingEnvVars(requiredEnv: string[] | undefined): string[] {
+	if (!requiredEnv || requiredEnv.length === 0) {
+		return []
+	}
+	return requiredEnv.filter((key) => !process.env[key])
+}
+
+function getScenarioProvider(scenario: SmokeScenario): string {
+	return scenario.provider || DEFAULT_PROVIDER
+}
+
+function ensureScenarioAuth(scenario: SmokeScenario, modelId: string): { ok: boolean; error?: string } {
+	const provider = getScenarioProvider(scenario)
+	const authModelId = scenario.auth?.modelId || modelId
+	const apiKeyEnv = scenario.auth?.apiKeyEnv || (provider === DEFAULT_PROVIDER ? "CLINE_API_KEY" : undefined)
+	const apiKey = apiKeyEnv ? process.env[apiKeyEnv] : undefined
+	const baseUrl = scenario.auth?.baseUrlEnv ? process.env[scenario.auth.baseUrlEnv] : undefined
+	const authCacheKey = `${provider}|${authModelId}|${baseUrl || ""}|${apiKeyEnv || ""}`
+
+	if (apiKey) {
+		if (configuredAuthCache.has(authCacheKey)) {
+			return { ok: true }
+		}
+		const result = configureAuth({ provider, apiKey, modelId: authModelId, baseUrl })
+		if (result.ok) {
+			configuredAuthCache.add(authCacheKey)
+		}
+		return result
+	}
+
+	// For default provider, local developers can rely on existing ~/.cline auth.
+	if (provider === DEFAULT_PROVIDER) {
+		return { ok: true }
+	}
+
+	if (!apiKeyEnv) {
+		return {
+			ok: false,
+			error: `Provider '${provider}' requires auth.apiKeyEnv in scenario config or preconfigured credentials`,
+		}
+	}
+
+	return {
+		ok: false,
+		error: `Missing required auth env var '${apiKeyEnv}' for provider '${provider}'`,
+	}
+}
+
+// Run a single trial
+interface TrialResult {
+	passed: boolean
+	error?: string
+	durationMs: number
+	stdout: string
+	stderr: string
+}
+
+async function runTrial(scenario: SmokeScenario, modelId: string, trialWorkdir: string): Promise<TrialResult> {
+	const startTime = Date.now()
+
+	// Ensure workspace exists and is clean
+	if (fs.existsSync(trialWorkdir)) {
+		fs.rmSync(trialWorkdir, { recursive: true })
+	}
+	fs.mkdirSync(trialWorkdir, { recursive: true })
+
+	// Copy any template files from scenario
+	const templateDir = path.join(path.dirname(scenario.workdir), "template")
+	if (fs.existsSync(templateDir)) {
+		fs.cpSync(templateDir, trialWorkdir, { recursive: true })
+	}
+
+	// Build CLI command with explicit model setting for determinism
+	// Provider is configured via `cline auth` before running tests
+	const args = [
+		"--config",
+		CLINE_CONFIG_DIR, // Use shared config directory for auth
+		"-y", // YOLO mode - auto-approve all actions, exits after completion
+		"-t",
+		String(scenario.timeout), // CLI timeout (matches our timeout)
+		"-m",
+		modelId, // Model to use (overrides configured default)
+		scenario.prompt,
+	]
+
+	try {
+		// Run cline CLI
+		const result = await runClineWithTimeout(args, trialWorkdir, scenario.timeout * 1000)
+
+		if (!result.success) {
+			return {
+				passed: false,
+				error: result.error || "CLI execution failed",
+				durationMs: Date.now() - startTime,
+				stdout: result.stdout,
+				stderr: result.stderr,
+			}
+		}
+
+		// Verify expected files
+		if (scenario.expectedFiles) {
+			for (const file of scenario.expectedFiles) {
+				const filePath = path.join(trialWorkdir, file)
+				if (!fs.existsSync(filePath)) {
+					return {
+						passed: false,
+						error: `Expected file not found: ${file}`,
+						durationMs: Date.now() - startTime,
+						stdout: result.stdout,
+						stderr: result.stderr,
+					}
+				}
+			}
+		}
+
+		// Verify expected content
+		if (scenario.expectedContent) {
+			for (const check of scenario.expectedContent) {
+				const filePath = path.join(trialWorkdir, check.file)
+				if (!fs.existsSync(filePath)) {
+					return {
+						passed: false,
+						error: `File not found for content check: ${check.file}`,
+						durationMs: Date.now() - startTime,
+						stdout: result.stdout,
+						stderr: result.stderr,
+					}
+				}
+				const content = fs.readFileSync(filePath, "utf-8")
+				if (!content.includes(check.contains)) {
+					return {
+						passed: false,
+						error: `Expected content not found in ${check.file}: "${check.contains}"`,
+						durationMs: Date.now() - startTime,
+						stdout: result.stdout,
+						stderr: result.stderr,
+					}
+				}
+			}
+		}
+
+		return {
+			passed: true,
+			durationMs: Date.now() - startTime,
+			stdout: result.stdout,
+			stderr: result.stderr,
+		}
+	} catch (error: any) {
+		return {
+			passed: false,
+			error: error.message || String(error),
+			durationMs: Date.now() - startTime,
+			stdout: "",
+			stderr: "",
+		}
+	}
+}
+
+// Run cline CLI with timeout
+interface ClineResult {
+	success: boolean
+	error?: string
+	stdout: string
+	stderr: string
+}
+
+function runClineWithTimeout(args: string[], cwd: string, timeoutMs: number): Promise<ClineResult> {
+	return new Promise((resolve) => {
+		let stdout = ""
+		let stderr = ""
+
+		const proc = spawn("cline", args, {
+			cwd,
+			env: { ...process.env },
+			stdio: ["ignore", "pipe", "pipe"], // stdin: ignore, stdout/stderr: pipe
+		})
+
+		const timeout = setTimeout(() => {
+			proc.kill("SIGKILL")
+			resolve({
+				success: false,
+				error: "Timeout exceeded",
+				stdout,
+				stderr,
+			})
+		}, timeoutMs)
+
+		proc.stdout?.on("data", (data) => {
+			stdout += data.toString()
+		})
+
+		proc.stderr?.on("data", (data) => {
+			stderr += data.toString()
+		})
+
+		proc.on("error", (err) => {
+			clearTimeout(timeout)
+			resolve({
+				success: false,
+				error: err.message,
+				stdout,
+				stderr,
+			})
+		})
+
+		proc.on("close", (code) => {
+			clearTimeout(timeout)
+			let error: string | undefined
+			if (code !== 0) {
+				// Include last line of stderr for context
+				const lastStderr = stderr.trim().split("\n").slice(-3).join(" | ")
+				error = `Exit code: ${code}${lastStderr ? ` - ${lastStderr}` : ""}`
+			}
+			resolve({
+				success: code === 0,
+				error,
+				stdout,
+				stderr,
+			})
+		})
+	})
+}
+
+// Result types
+interface ScenarioResult {
+	scenarioId: string
+	scenarioName: string
+	model: string
+	modelId: string
+	trials: TrialResult[]
+	metrics: {
+		passAt1: number
+		passAt3: number
+		passCaret3: number
+		flakinessScore: number
+	}
+	status: "pass" | "fail" | "flaky"
+}
+
+interface SmokeTestReport {
+	timestamp: string
+	provider: string
+	models: string[]
+	scenarios: string[]
+	trialsPerTest: number
+	results: ScenarioResult[]
+	summary: {
+		total: number
+		passed: number
+		failed: number
+		flaky: number
+		passAt1Overall: number
+		passAt3Overall: number
+	}
+}
+
+// Main execution
+async function main() {
+	loadEnvFiles()
+
+	const args = process.argv.slice(2)
+
+	// Parse arguments
+	let selectedModel: string | undefined
+	let trials = 3
+	let selectedScenario: string | undefined
+	let outputFile: string | undefined
+	let parallel = false
+	let parallelLimit = 4
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--model" && args[i + 1]) {
+			selectedModel = args[++i]
+		} else if (args[i] === "--trials" && args[i + 1]) {
+			trials = parseInt(args[++i], 10)
+		} else if (args[i] === "--scenario" && args[i + 1]) {
+			selectedScenario = args[++i]
+		} else if (args[i] === "--output" && args[i + 1]) {
+			outputFile = args[++i]
+		} else if (args[i] === "--parallel") {
+			parallel = true
+			if (args[i + 1] && !args[i + 1].startsWith("--")) {
+				parallelLimit = parseInt(args[++i], 10)
+			}
+		}
+	}
+
+	// Check cline CLI is available
+	if (!checkClineCli()) {
+		console.error("ERROR: cline CLI not found in PATH")
+		console.error("")
+		console.error("For local development:")
+		console.error("  Install cline from npm or link the SDK CLI from apps/cli")
+		console.error("")
+		console.error("For CI:")
+		console.error("  Ensure a cline binary is available on PATH")
+		process.exit(1)
+	}
+
+	// Load scenarios
+	const scenariosDir = path.join(__dirname, "scenarios")
+	let scenarios = loadScenarios(scenariosDir)
+
+	if (scenarios.length === 0) {
+		console.error("No scenarios found in", scenariosDir)
+		process.exit(1)
+	}
+
+	if (selectedScenario) {
+		scenarios = scenarios.filter((s) => s.id === selectedScenario)
+		if (scenarios.length === 0) {
+			console.error(`Scenario not found: ${selectedScenario}`)
+			process.exit(1)
+		}
+	}
+
+	const skippedByEnv: Array<{ id: string; missingEnv: string[] }> = []
+	if (selectedScenario) {
+		const missingEnv = getMissingEnvVars(scenarios[0].requiredEnv)
+		if (missingEnv.length > 0) {
+			console.error(`Scenario '${selectedScenario}' missing required env: ${missingEnv.join(", ")}`)
+			process.exit(1)
+		}
+	} else {
+		scenarios = scenarios.filter((scenario) => {
+			const missingEnv = getMissingEnvVars(scenario.requiredEnv)
+			if (missingEnv.length > 0) {
+				skippedByEnv.push({ id: scenario.id, missingEnv })
+				return false
+			}
+			return true
+		})
+	}
+
+	// Filter models
+	let models = MODELS
+	if (selectedModel) {
+		models = [selectedModel]
+	}
+
+	if (scenarios.length === 0) {
+		console.error("No runnable scenarios after env filtering")
+		if (skippedByEnv.length > 0) {
+			for (const skipped of skippedByEnv) {
+				console.error(`  - ${skipped.id}: missing ${skipped.missingEnv.join(", ")}`)
+			}
+		}
+		process.exit(1)
+	}
+
+	// Create results directory with timestamp
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+	const resultsBaseDir = path.join(__dirname, "results")
+	const resultsDir = path.join(resultsBaseDir, timestamp)
+	fs.mkdirSync(resultsDir, { recursive: true })
+
+	// Models are now always explicit
+	const resolvedModels = models
+	const providersInRun = [...new Set(scenarios.map((scenario) => getScenarioProvider(scenario)))]
+
+	console.log(`Running ${scenarios.length} scenarios × ${models.length} models × ${trials} trials`)
+	console.log(`Providers: ${providersInRun.join(", ")}`)
+	console.log(`Models: ${resolvedModels.join(", ")}`)
+	console.log(`Scenarios: ${scenarios.map((s) => s.id).join(", ")}`)
+	if (skippedByEnv.length > 0) {
+		console.log(
+			`Skipped by env: ${skippedByEnv.map((skipped) => `${skipped.id} (missing: ${skipped.missingEnv.join(", ")})`).join("; ")}`,
+		)
+	}
+	console.log(`Results: ${resultsDir}`)
+	console.log(`Parallel: ${parallel ? `yes (limit: ${parallelLimit})` : "no"}`)
+	console.log("")
+
+	const metricsCalc = new MetricsCalculator()
+	const results: ScenarioResult[] = []
+
+	// Build list of all scenario+model combinations
+	interface TestJob {
+		scenario: SmokeScenario
+		modelId: string
+	}
+	const jobs: TestJob[] = []
+	for (const scenario of scenarios) {
+		const scenarioModels = selectedModel ? [selectedModel] : scenario.models || models
+		for (const modelId of scenarioModels) {
+			jobs.push({ scenario, modelId })
+		}
+	}
+
+	// Run a single job
+	async function runJob(job: TestJob): Promise<ScenarioResult> {
+		const { scenario, modelId } = job
+		const logDir = path.join(resultsDir, scenario.id, modelId)
+		fs.mkdirSync(logDir, { recursive: true })
+
+		const authResult = ensureScenarioAuth(scenario, modelId)
+		if (!authResult.ok) {
+			const trialResults = Array.from({ length: trials }, () => ({
+				passed: false,
+				error: authResult.error || "Scenario authentication failed",
+				durationMs: 0,
+				stdout: "",
+				stderr: "",
+			}))
+			return {
+				scenarioId: scenario.id,
+				scenarioName: scenario.name,
+				model: modelId,
+				modelId,
+				trials: trialResults,
+				metrics: metricsCalc.calculateTaskMetrics(trialResults.map((t) => t.passed)),
+				status: metricsCalc.getTaskStatus(trialResults.map((t) => t.passed)),
+			}
+		}
+
+		const trialResults: TrialResult[] = []
+		const trialWorkdirs: string[] = []
+
+		for (let t = 0; t < trials; t++) {
+			const trialWorkdir = path.join(logDir, `workspace-trial-${t + 1}`)
+			trialWorkdirs.push(trialWorkdir)
+			const result = await runTrial(scenario, modelId, trialWorkdir)
+			trialResults.push(result)
+		}
+
+		trialResults.forEach((result, t) => {
+			const trialNum = t + 1
+			const logContent =
+				`# Trial ${trialNum}\n` +
+				`Status: ${result.passed ? "PASS" : "FAIL"}\n` +
+				`Duration: ${result.durationMs}ms\n` +
+				(result.error ? `Error: ${result.error}\n` : "") +
+				`\n## STDOUT\n${result.stdout || "(empty)"}\n` +
+				`\n## STDERR\n${result.stderr || "(empty)"}\n`
+			fs.writeFileSync(path.join(logDir, `trial-${trialNum}.log`), logContent)
+		})
+
+		const trialBools = trialResults.map((t) => t.passed)
+		const metrics = metricsCalc.calculateTaskMetrics(trialBools)
+		const status = metricsCalc.getTaskStatus(trialBools)
+
+		return {
+			scenarioId: scenario.id,
+			scenarioName: scenario.name,
+			model: modelId,
+			modelId: modelId,
+			trials: trialResults,
+			metrics,
+			status,
+		}
+	}
+
+	if (parallel) {
+		// Run jobs in parallel with concurrency limit
+		console.log(`Running ${jobs.length} jobs in parallel...`)
+		const executing: Promise<void>[] = []
+
+		for (const job of jobs) {
+			const p = runJob(job).then((result) => {
+				results.push(result)
+				const passMetric = trials >= 3 ? result.metrics.passAt3 : result.metrics.passAt1
+				const icon = result.status === "pass" ? "✓" : result.status === "flaky" ? "~" : "✗"
+				console.log(
+					`  ${icon} [${result.scenarioId}] ${result.model}: ${result.status.toUpperCase()} (${(passMetric * 100).toFixed(0)}%)`,
+				)
+			})
+			executing.push(p as unknown as Promise<void>)
+
+			if (executing.length >= parallelLimit) {
+				await Promise.race(executing)
+				// Remove settled promises
+				for (let i = executing.length - 1; i >= 0; i--) {
+					const settled = await Promise.race([executing[i].then(() => true).catch(() => true), Promise.resolve(false)])
+					if (settled) executing.splice(i, 1)
+				}
+			}
+		}
+		await Promise.all(executing)
+	} else {
+		// Sequential execution
+		for (const job of jobs) {
+			console.log(`\n[${job.scenario.id}] ${job.scenario.name} (${job.modelId})`)
+			const result = await runJob(job)
+			result.trials.forEach((trial, index) => {
+				console.log(`  Trial ${index + 1}/${trials}... ${trial.passed ? "✓ PASS" : `✗ FAIL: ${trial.error}`}`)
+			})
+			results.push(result)
+
+			// Display pass@k where k = actual trials (pass@3 is meaningless with fewer trials)
+			const passMetric = trials >= 3 ? result.metrics.passAt3 : result.metrics.passAt1
+			const passLabel = trials >= 3 ? "pass@3" : "pass@1"
+			console.log(`  Result: ${result.status.toUpperCase()} | ${passLabel}: ${(passMetric * 100).toFixed(0)}%`)
+		}
+	}
+
+	// Generate report
+	const report: SmokeTestReport = {
+		timestamp: new Date().toISOString(),
+		provider: providersInRun.join(","),
+		models: resolvedModels,
+		scenarios: scenarios.map((s) => s.id),
+		trialsPerTest: trials,
+		results,
+		summary: {
+			total: results.length,
+			passed: results.filter((r) => r.status === "pass").length,
+			failed: results.filter((r) => r.status === "fail").length,
+			flaky: results.filter((r) => r.status === "flaky").length,
+			passAt1Overall: results.length > 0 ? results.reduce((sum, r) => sum + r.metrics.passAt1, 0) / results.length : 0,
+			passAt3Overall: results.length > 0 ? results.reduce((sum, r) => sum + r.metrics.passAt3, 0) / results.length : 0,
+		},
+	}
+
+	// Save report.json
+	fs.writeFileSync(path.join(resultsDir, "report.json"), JSON.stringify(report, null, 2))
+
+	// Generate summary.md for CI job summary
+	const summaryMd = generateSummaryMarkdown(report)
+	fs.writeFileSync(path.join(resultsDir, "summary.md"), summaryMd)
+
+	// Create/update 'latest' symlink
+	const latestLink = path.join(resultsBaseDir, "latest")
+	try {
+		if (fs.existsSync(latestLink)) {
+			fs.unlinkSync(latestLink)
+		}
+		fs.symlinkSync(timestamp, latestLink)
+	} catch {
+		// Symlinks may fail on some systems, ignore
+	}
+
+	// Also write to custom output file if specified
+	if (outputFile) {
+		fs.writeFileSync(outputFile, JSON.stringify(report, null, 2))
+		console.log(`\nResults also written to: ${outputFile}`)
+	}
+
+	// Summary
+	console.log("\n" + "=".repeat(60))
+	console.log("SUMMARY")
+	console.log("=".repeat(60))
+	console.log(`Total: ${report.summary.total}`)
+	console.log(`Passed: ${report.summary.passed}`)
+	console.log(`Failed: ${report.summary.failed}`)
+	console.log(`Flaky: ${report.summary.flaky}`)
+	const passLabel = report.trialsPerTest >= 3 ? "pass@3" : "pass@1"
+	const passOverall = report.trialsPerTest >= 3 ? report.summary.passAt3Overall : report.summary.passAt1Overall
+	console.log(`Overall ${passLabel}: ${(passOverall * 100).toFixed(1)}%`)
+	console.log(`\nFull results: ${resultsDir}`)
+	console.log(`Latest link: ${latestLink}`)
+
+	// Exit with error if any failures
+	if (report.summary.failed > 0) {
+		process.exit(1)
+	}
+}
+
+// Generate markdown summary for CI
+function generateSummaryMarkdown(report: SmokeTestReport): string {
+	const lines: string[] = []
+	lines.push("## Smoke Test Results")
+	lines.push("")
+	lines.push(`**Date:** ${report.timestamp}`)
+
+	// Show unique model IDs from results
+	const modelIds = [...new Set(report.results.map((r) => r.modelId))]
+	lines.push(`**Models:** ${modelIds.join(", ")}`)
+	lines.push(`**Trials per test:** ${report.trialsPerTest}`)
+	lines.push("")
+	lines.push("### Summary")
+	lines.push("")
+	lines.push(`| Metric | Value |`)
+	lines.push(`|--------|-------|`)
+	lines.push(`| Total | ${report.summary.total} |`)
+	lines.push(`| Passed | ${report.summary.passed} |`)
+	lines.push(`| Failed | ${report.summary.failed} |`)
+	lines.push(`| Flaky | ${report.summary.flaky} |`)
+	const mdPassLabel = report.trialsPerTest >= 3 ? "pass@3" : "pass@1"
+	const mdPassOverall = report.trialsPerTest >= 3 ? report.summary.passAt3Overall : report.summary.passAt1Overall
+	lines.push(`| Overall ${mdPassLabel} | ${(mdPassOverall * 100).toFixed(1)}% |`)
+	lines.push("")
+
+	// Results table
+	lines.push("### Results by Scenario")
+	lines.push("")
+	lines.push(`| Scenario | Model | Status | ${mdPassLabel} |`)
+	lines.push("|----------|-------|--------|--------|")
+	for (const r of report.results) {
+		const statusEmoji = r.status === "pass" ? "✅" : r.status === "flaky" ? "⚠️" : "❌"
+		const rPassMetric = report.trialsPerTest >= 3 ? r.metrics.passAt3 : r.metrics.passAt1
+		lines.push(
+			`| ${r.scenarioId} | ${r.modelId} | ${statusEmoji} ${r.status.toUpperCase()} | ${(rPassMetric * 100).toFixed(0)}% |`,
+		)
+	}
+	lines.push("")
+
+	// Failed/flaky details
+	const problemResults = report.results.filter((r) => r.status !== "pass")
+	if (problemResults.length > 0) {
+		lines.push("### Failed/Flaky Details")
+		lines.push("")
+		for (const r of problemResults) {
+			lines.push(`#### ${r.scenarioId} (${r.modelId})`)
+			lines.push("")
+			r.trials.forEach((t, i) => {
+				if (!t.passed) {
+					lines.push(`- Trial ${i + 1}: ${t.error}`)
+				}
+			})
+			lines.push("")
+		}
+	}
+
+	return lines.join("\n")
+}
+
+main().catch((err) => {
+	console.error(err)
+	process.exit(1)
+})
diff --git a/evals/smoke-tests/scenarios/01-create-file/config.json b/evals/smoke-tests/scenarios/01-create-file/config.json
new file mode 100644
index 0000000..ebfe695
--- /dev/null
+++ b/evals/smoke-tests/scenarios/01-create-file/config.json
@@ -0,0 +1,15 @@
+{
+	"name": "Create a simple file",
+	"description": "Tests basic file creation with write_to_file tool",
+	"prompt": "Create a file called hello.txt that contains the text 'Hello, World!'",
+	"expectedFiles": [
+		"hello.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "hello.txt",
+			"contains": "Hello"
+		}
+	],
+	"timeout": 120
+}
diff --git a/evals/smoke-tests/scenarios/02-edit-file/config.json b/evals/smoke-tests/scenarios/02-edit-file/config.json
new file mode 100644
index 0000000..dc7f3e3
--- /dev/null
+++ b/evals/smoke-tests/scenarios/02-edit-file/config.json
@@ -0,0 +1,15 @@
+{
+	"name": "Edit an existing file",
+	"description": "Tests file editing with replace_in_file tool",
+	"prompt": "Edit the file greeting.txt and change 'Hello' to 'Goodbye'",
+	"expectedFiles": [
+		"greeting.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "greeting.txt",
+			"contains": "Goodbye"
+		}
+	],
+	"timeout": 120
+}
diff --git a/evals/smoke-tests/scenarios/02-edit-file/template/greeting.txt b/evals/smoke-tests/scenarios/02-edit-file/template/greeting.txt
new file mode 100644
index 0000000..ec6194d
--- /dev/null
+++ b/evals/smoke-tests/scenarios/02-edit-file/template/greeting.txt
@@ -0,0 +1 @@
+Hello World, this is a greeting file.
diff --git a/evals/smoke-tests/scenarios/03-read-summarize/config.json b/evals/smoke-tests/scenarios/03-read-summarize/config.json
new file mode 100644
index 0000000..c449620
--- /dev/null
+++ b/evals/smoke-tests/scenarios/03-read-summarize/config.json
@@ -0,0 +1,15 @@
+{
+	"name": "Read and create summary",
+	"description": "Tests read_file tool and response generation",
+	"prompt": "Read the file data.txt and create a summary.txt file that contains a one-sentence summary of what the data file contains",
+	"expectedFiles": [
+		"summary.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "summary.txt",
+			"contains": "user"
+		}
+	],
+	"timeout": 180
+}
diff --git a/evals/smoke-tests/scenarios/03-read-summarize/template/data.txt b/evals/smoke-tests/scenarios/03-read-summarize/template/data.txt
new file mode 100644
index 0000000..63e2d0a
--- /dev/null
+++ b/evals/smoke-tests/scenarios/03-read-summarize/template/data.txt
@@ -0,0 +1,11 @@
+User Analytics Report
+=====================
+Total users: 1,523
+Active users (last 30 days): 892
+New signups this month: 147
+Churn rate: 3.2%
+
+Top features by usage:
+1. Dashboard (89%)
+2. Reports (67%)
+3. Settings (45%)
diff --git a/evals/smoke-tests/scenarios/03-read-summarize/workspace/.gitkeep b/evals/smoke-tests/scenarios/03-read-summarize/workspace/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/evals/smoke-tests/scenarios/04-multi-file/config.json b/evals/smoke-tests/scenarios/04-multi-file/config.json
new file mode 100644
index 0000000..f350f6a
--- /dev/null
+++ b/evals/smoke-tests/scenarios/04-multi-file/config.json
@@ -0,0 +1,20 @@
+{
+	"name": "Create multiple files",
+	"description": "Tests tool chaining with multiple file operations",
+	"prompt": "Create a simple project with two files: index.html with a basic HTML structure, and style.css with a simple body style that sets the font family to Arial",
+	"expectedFiles": [
+		"index.html",
+		"style.css"
+	],
+	"expectedContent": [
+		{
+			"file": "index.html",
+			"contains": "html"
+		},
+		{
+			"file": "style.css",
+			"contains": "Arial"
+		}
+	],
+	"timeout": 180
+}
diff --git a/evals/smoke-tests/scenarios/04-multi-file/workspace/.gitkeep b/evals/smoke-tests/scenarios/04-multi-file/workspace/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/evals/smoke-tests/scenarios/05-typescript-function/config.json b/evals/smoke-tests/scenarios/05-typescript-function/config.json
new file mode 100644
index 0000000..16bfec0
--- /dev/null
+++ b/evals/smoke-tests/scenarios/05-typescript-function/config.json
@@ -0,0 +1,19 @@
+{
+	"name": "Write TypeScript function",
+	"description": "Tests code generation with correct syntax",
+	"prompt": "Create a file called utils.ts that exports a function called 'capitalize' that takes a string and returns it with the first letter capitalized",
+	"expectedFiles": [
+		"utils.ts"
+	],
+	"expectedContent": [
+		{
+			"file": "utils.ts",
+			"contains": "export"
+		},
+		{
+			"file": "utils.ts",
+			"contains": "capitalize"
+		}
+	],
+	"timeout": 180
+}
diff --git a/evals/smoke-tests/scenarios/05-typescript-function/workspace/.gitkeep b/evals/smoke-tests/scenarios/05-typescript-function/workspace/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/evals/smoke-tests/scenarios/06-apply-patch/config.json b/evals/smoke-tests/scenarios/06-apply-patch/config.json
new file mode 100644
index 0000000..d9af06f
--- /dev/null
+++ b/evals/smoke-tests/scenarios/06-apply-patch/config.json
@@ -0,0 +1,18 @@
+{
+	"name": "Edit file with apply_patch (GPT-5)",
+	"description": "Tests file editing with apply_patch tool (GPT-5 specific)",
+	"prompt": "Edit the file config.txt and change the 'debug' setting from 'false' to 'true'",
+	"models": [
+		"openai/gpt-5"
+	],
+	"expectedFiles": [
+		"config.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "config.txt",
+			"contains": "debug = true"
+		}
+	],
+	"timeout": 180
+}
diff --git a/evals/smoke-tests/scenarios/06-apply-patch/template/config.txt b/evals/smoke-tests/scenarios/06-apply-patch/template/config.txt
new file mode 100644
index 0000000..25166cf
--- /dev/null
+++ b/evals/smoke-tests/scenarios/06-apply-patch/template/config.txt
@@ -0,0 +1,11 @@
+# Application Configuration
+name = MyApp
+version = 1.0.0
+
+# Debug settings
+debug = false
+log_level = info
+
+# Server settings
+host = localhost
+port = 8080
diff --git a/evals/smoke-tests/scenarios/07-edit-gemini/config.json b/evals/smoke-tests/scenarios/07-edit-gemini/config.json
new file mode 100644
index 0000000..b8690db
--- /dev/null
+++ b/evals/smoke-tests/scenarios/07-edit-gemini/config.json
@@ -0,0 +1,18 @@
+{
+	"name": "Edit file (Gemini)",
+	"description": "Tests file editing with Gemini model variant",
+	"prompt": "Edit the file greeting.txt and change 'Hello' to 'Goodbye'",
+	"models": [
+		"google/gemini-2.5-flash"
+	],
+	"expectedFiles": [
+		"greeting.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "greeting.txt",
+			"contains": "Goodbye"
+		}
+	],
+	"timeout": 120
+}
diff --git a/evals/smoke-tests/scenarios/07-edit-gemini/template/greeting.txt b/evals/smoke-tests/scenarios/07-edit-gemini/template/greeting.txt
new file mode 100644
index 0000000..ec6194d
--- /dev/null
+++ b/evals/smoke-tests/scenarios/07-edit-gemini/template/greeting.txt
@@ -0,0 +1 @@
+Hello World, this is a greeting file.
diff --git a/evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/config.json b/evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/config.json
new file mode 100644
index 0000000..0fdb36c
--- /dev/null
+++ b/evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/config.json
@@ -0,0 +1,28 @@
+{
+	"name": "Edit file with gpt-oss via OpenAI-compatible",
+	"description": "Reproduces openai-compatible gpt-oss file editing reliability when native tool calling is enabled",
+	"prompt": "Edit the file config.txt and change the line 'debug = false' to 'debug = true'. Prefer direct file-edit tools instead of shell command workarounds.",
+	"provider": "openai",
+	"models": [
+		"gpt-oss-120b"
+	],
+	"requiredEnv": [
+		"OPENAI_COMPAT_API_KEY",
+		"OPENAI_COMPAT_BASE_URL"
+	],
+	"auth": {
+		"apiKeyEnv": "OPENAI_COMPAT_API_KEY",
+		"baseUrlEnv": "OPENAI_COMPAT_BASE_URL",
+		"modelId": "gpt-oss-120b"
+	},
+	"expectedFiles": [
+		"config.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "config.txt",
+			"contains": "debug = true"
+		}
+	],
+	"timeout": 180
+}
diff --git a/evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/template/config.txt b/evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/template/config.txt
new file mode 100644
index 0000000..25166cf
--- /dev/null
+++ b/evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/template/config.txt
@@ -0,0 +1,11 @@
+# Application Configuration
+name = MyApp
+version = 1.0.0
+
+# Debug settings
+debug = false
+log_level = info
+
+# Server settings
+host = localhost
+port = 8080
diff --git a/evals/tsconfig.json b/evals/tsconfig.json
new file mode 100644
index 0000000..561e9b0
--- /dev/null
+++ b/evals/tsconfig.json
@@ -0,0 +1,6 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"baseUrl": ".."
+	}
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..5687bf7
--- /dev/null
+++ b/package.json
@@ -0,0 +1,86 @@
+{
+    "name": "@cline/packages",
+    "private": true,
+    "workspaces": [
+        "sdk/packages/*",
+        "apps/*",
+        "apps/vscode/webview-ui",
+        "apps/vscode/testing-platform",
+        "apps/cline-hub/src/webview",
+        "apps/examples/*",
+        "apps/examples/vscode/src/webview",
+        "sdk/examples",
+        "sdk/examples/plugins/*"
+    ],
+    "scripts": {
+        "prepare": "husky",
+        "build": "bun run clean && bun install && bun run build:sdk && bun -F @cline/cli build",
+        "build:sdk": "bun --production -F './sdk/packages/*' build",
+        "build:apps": "bun -F './apps/**' --production build",
+        "build:models": "bun -F @cline/llms generate:models && bun format --write",
+        "dev": "bun --conditions=development run build:sdk && bun run cli && bun run cli hub stop",
+        "cli": "bun --conditions=development --cwd apps/cli dev",
+        "code": "bun --conditions=development -F @cline/code dev",
+        "clean": "bun run sdk/scripts/clean.ts",
+        "types": "bun --parallel -F '*' typecheck",
+        "test": "bun --parallel -F './sdk/packages/**' -F @cline/cli -F @cline/cline-hub test",
+        "test:unit": "bash -lc 'set -euo pipefail; bun -F @cline/agents test & p1=$!; bun -F @cline/llms test & p2=$!; bun -F @cline/core test:unit & p3=$!; bun -F @cline/cli test:unit & p4=$!; bun -F @cline/cline-hub test & p5=$!; wait $p1; wait $p2; wait $p3; wait $p4; wait $p5'",
+        "test:e2e": "bun -F @cline/core test:e2e && bun -F @cline/cli test:e2e",
+        "test:e2e:interactive": "bun -F @cline/cli test:e2e:interactive",
+        "verify:routines": "zsh -lc 'cd sdk/packages/core && bunx vitest run src/cron/schedule-service.test.ts --config vitest.config.ts'",
+        "verify:workos-device-auth": "bun sdk/scripts/verify-workos-device-auth.ts",
+        "biome": "bunx --bun @biomejs/biome",
+        "format": "bun biome format sdk/ apps/cli/ apps/cline-hub/ apps/examples/",
+        "lint": "bun biome lint sdk/ apps/cli/ apps/cline-hub/ apps/examples/",
+        "fix": "bun biome check --write --unsafe --diagnostic-level=error sdk/ apps/cli/ apps/cline-hub/ apps/examples/",
+        "check": "bun biome check --diagnostic-level=error sdk/ apps/cli/ apps/cline-hub/ apps/examples/ && bun run build:sdk && bun run -F @cline/cli build && bun -F @cline/cline-hub build:webview && bun --parallel -F './sdk/packages/**' -F @cline/cli -F @cline/cline-hub typecheck && bun sdk/scripts/check-publish.ts",
+        "version": "bun run types && bun sdk/scripts/version.ts",
+        "release": "bun sdk/scripts/release.ts"
+    },
+    "lint-staged": {
+        "sdk/**": [
+            "sh -c 'bun run types'",
+            "bun biome check --no-errors-on-unmatched --files-ignore-unknown=true"
+        ],
+        "apps/{cli,cline-hub,examples}/**": [
+            "sh -c 'bun run types'",
+            "bun biome check --no-errors-on-unmatched --files-ignore-unknown=true"
+        ]
+    },
+    "module": "index.ts",
+    "type": "module",
+    "engines": {
+        "bun": "1.3.13",
+        "node": ">=22"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.4.5",
+        "@types/bun": "^1.3.13",
+        "@types/node": "^25.3.5",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.3.2",
+        "vitest": "^4.0.18"
+    },
+    "peerDependencies": {
+        "nanoid": "^5.1.7",
+        "typescript": "^5.9.3"
+    },
+    "overrides": {
+        "tar-fs": ">=3.1.1",
+        "tar": "^7.5.2",
+        "js-yaml": "^4.1.1",
+        "serialize-javascript": ">=7.0.3",
+        "protobufjs": "7.5.8",
+        "diff": "8.0.4",
+        "@sap-cloud-sdk/connectivity": "4.6.0",
+        "@sap-cloud-sdk/http-client": "4.6.0",
+        "@sap-cloud-sdk/openapi": "4.6.0",
+        "@sap-cloud-sdk/resilience": "4.6.0",
+        "@sap-cloud-sdk/util": "4.6.0"
+    },
+    "trustedDependencies": [
+        "better-sqlite3",
+        "grpc-tools"
+    ],
+    "packageManager": "bun@1.3.13"
+}
diff --git a/sdk/.cline/rules/worktree_dependency_hygiene.md b/sdk/.cline/rules/worktree_dependency_hygiene.md
new file mode 100644
index 0000000..2a2f6a2
--- /dev/null
+++ b/sdk/.cline/rules/worktree_dependency_hygiene.md
@@ -0,0 +1,15 @@
+### Worktree Dependency Hygiene
+ 
+When working in a git worktree, verify dependency links before running CLI repros,
+tests, hooks, or commits. `node_modules` symlinks can accidentally point at
+another checkout, causing mixed-source type errors or runtime behavior.
+ 
+Quick check:
+ 
+```sh
+realpath node_modules packages/core/node_modules packages/core/node_modules/@cline/llms
+```
+ 
+All paths should stay under the current worktree. If any path points to another
+checkout, remove the bad `node_modules` symlinks and run `bun install` from the
+worktree root before trusting test or hook results.
diff --git a/sdk/.cline/skills/plugin.md b/sdk/.cline/skills/plugin.md
new file mode 100644
index 0000000..fdb86e6
--- /dev/null
+++ b/sdk/.cline/skills/plugin.md
@@ -0,0 +1,892 @@
+---
+name: cline-plugin
+description: Self-contained guide to designing, building, packaging, and distributing a plugin for any Cline-based agent (CLI, VS Code, Kanban, JetBrains, custom SDK hosts). Covers both single-file plugins and full plugin packages.
+---
+
+# Authoring a Cline Agent Plugin
+
+A **Cline plugin** is a TypeScript module that extends any agent built on the Cline Core SDK. The same plugin runs in the Cline CLI, the VS Code and JetBrains extensions, the Kanban host, and any custom app built on `@cline/core` — write it once, every host gets the new behavior.
+
+A plugin can:
+
+- **Register tools** the model can call (the most common use).
+- **Hook into the agent loop** before/after runs, model calls, and tool calls.
+- **Rewrite provider messages** before they hit the model (custom compaction, redaction, context shaping).
+- **Register slash commands**, **prompt rules**, **providers**, and **automation event types**.
+
+A plugin ships in one of two shapes:
+
+1. **Single-file plugin** — one `.ts` file that exports a default plugin object. Drop it in a discovery folder and it's loaded.
+2. **Plugin package** — a directory with `package.json`, npm dependencies, and (optionally) bundled assets like markdown templates. Installable via `cline plugin install`.
+
+Both shapes use the same plugin API. The package form just adds dependency management and asset bundling.
+
+This guide is self-contained. By the end of it, you'll be able to build either kind from scratch.
+
+---
+
+## 1. The mental model
+
+When the host starts a session, it builds a registry of plugins and runs four phases:
+
+1. **resolve** — collect the plugin objects.
+2. **validate** — check each plugin's `manifest`. Capabilities must be non-empty; declared hook stages must have matching handlers; if `hooks` is present, `"hooks"` must be in `capabilities`.
+3. **setup** — call each plugin's `setup(api, ctx)` once. This is where you `registerTool`, `registerCommand`, etc.
+4. **activate** — registry is frozen, the agent loop starts, and your hooks/tools are live.
+
+Two invariants the registry enforces:
+
+- **Every contribution requires a matching capability.** Calling `api.registerRule(...)` without `"rules"` in `manifest.capabilities` throws.
+- **Capabilities and handlers must agree.** Declaring `"hooks"` without a `hooks` object, or vice versa, fails validation.
+
+After validation, registration is one-shot — there's no dynamic register/unregister during the session.
+
+---
+
+## 2. The smallest working plugin
+
+```ts
+import type { AgentPlugin } from "@cline/core";
+import { createTool } from "@cline/core";
+
+const plugin: AgentPlugin = {
+  name: "hello-plugin",                     // required, unique within a session
+  manifest: {
+    capabilities: ["tools"],                // declares what setup() will register
+  },
+  setup(api, ctx) {
+    api.registerTool(
+      createTool({
+        name: "say_hello",
+        description: "Greet a person by name.",
+        inputSchema: {
+          type: "object",
+          properties: { name: { type: "string" } },
+          required: ["name"],
+        },
+        async execute({ name }: { name: string }) {
+          return { greeting: `Hello, ${name}!` };
+        },
+      }),
+    );
+  },
+};
+
+export default plugin;
+```
+
+That's a complete plugin. The agent will see `say_hello` as a callable tool.
+
+---
+
+## 3. The manifest
+
+```ts
+manifest: {
+  capabilities: ["tools", "hooks"],   // required — non-empty array
+  paths?: string[],                   // optional — multi-entry packages
+  providerIds?: string[],             // optional — provider plugins
+  modelIds?: string[],                // optional — model plugins
+}
+```
+
+| Field          | When to use                                                                                             |
+| -------------- | ------------------------------------------------------------------------------------------------------- |
+| `capabilities` | Always. Lists what the plugin contributes; gates the corresponding `api.register*` methods.             |
+| `paths`        | Only inside a `package.json` `cline.plugins` entry — when one package exposes multiple plugin entry points. |
+| `providerIds`  | When `capabilities` includes `"providers"` — declares which provider IDs you register.                  |
+| `modelIds`     | When you contribute models tied to specific IDs.                                                        |
+
+### The complete capability list
+
+| Capability         | What it unlocks in `api`                                              |
+| ------------------ | --------------------------------------------------------------------- |
+| `tools`            | `api.registerTool()`                                                  |
+| `commands`         | `api.registerCommand()` (slash commands in chat surfaces)             |
+| `rules`            | `api.registerRule()` (string injected into the system prompt)         |
+| `messageBuilders`  | `api.registerMessageBuilder()` (rewrites provider-bound messages)     |
+| `providers`        | `api.registerProvider()` (e.g. a custom model provider)               |
+| `automationEvents` | `api.registerAutomationEventType()` and `ctx.automation?.ingestEvent()` |
+| `hooks`            | The runtime `hooks` object on the plugin (lifecycle callbacks)        |
+
+You declare any combination — most real plugins need 1–3 capabilities.
+
+---
+
+## 4. `setup(api, ctx)` — the registration phase
+
+`setup()` runs **once per session** before the agent loop starts. Everything you register here is frozen for the lifetime of the session.
+
+### 4.1 The `api` object
+
+Each `register*` method requires the matching capability in your manifest:
+
+```ts
+api.registerTool(tool);                              // requires "tools"
+api.registerCommand({ name, description, handler }); // requires "commands"
+api.registerRule({ id, content, source });           // requires "rules"
+api.registerMessageBuilder({ name, build });         // requires "messageBuilders"
+api.registerProvider({ name, description });         // requires "providers"
+api.registerAutomationEventType({ eventType, source, /* ... */ }); // requires "automationEvents"
+```
+
+### 4.2 The `ctx` object — host-provided session context
+
+The second argument carries everything the host knows about the current session. **All fields are optional**, so feature-detect before using them — the same plugin must work in hosts that supply less context (unit tests, sandboxed plugin processes).
+
+```ts
+ctx.session?.sessionId       // string — stable core session id
+ctx.client?.name             // host: "cline-cli", "cline-vscode", etc.
+ctx.user                     // authenticated user/org info, when available
+ctx.workspaceInfo            // { rootPath, hint, latestGitBranchName,
+                             //   latestGitCommitHash, associatedRemoteUrls }
+ctx.automation?.ingestEvent  // emit normalized automation events
+ctx.logger?.log              // structured logger scoped to this plugin
+ctx.telemetry                // ITelemetryService — only present in-process
+```
+
+**Two big rules about `ctx.workspaceInfo`:**
+
+1. **Always prefer `ctx.workspaceInfo?.rootPath` over `process.cwd()`.** The CLI may have been launched with `--cwd` without calling `chdir`, and VS Code workspaces don't share a single CWD. `workspaceInfo` is sourced from the session config and is always correct.
+2. **Don't use `import.meta.url` tricks to find "the workspace".** That gives you the plugin's own location, not the user's project.
+
+### 4.3 Persisting state across hooks
+
+`setup()` runs first; hooks fire later. The simplest way to share state is module-level variables in your plugin file:
+
+```ts
+let sessionWorkspaceRoot: string | undefined;
+let sessionBranch: string | undefined;
+
+const plugin: AgentPlugin = {
+  name: "metrics",
+  manifest: { capabilities: ["hooks"] },
+  setup(api, ctx) {
+    sessionWorkspaceRoot = ctx.workspaceInfo?.rootPath;
+    sessionBranch = ctx.workspaceInfo?.latestGitBranchName;
+  },
+  hooks: {
+    beforeTool({ toolCall, input }) {
+      if (sessionBranch === "main" && toolCall.toolName === "run_commands") {
+        // Inspect input, optionally block.
+      }
+      return undefined;
+    },
+  },
+};
+```
+
+A single Node process may host multiple sessions concurrently. If your plugin will run in a multi-session host, key your state by `ctx.session?.sessionId` instead of using module-level singletons:
+
+```ts
+const stateBySession = new Map<string, MyState>();
+setup(api, ctx) {
+  const id = ctx.session?.sessionId;
+  if (id) stateBySession.set(id, /* ... */);
+}
+```
+
+---
+
+## 5. Tools — `api.registerTool`
+
+Tools are how plugins give the agent new capabilities. Use the `createTool()` helper from `@cline/core`:
+
+```ts
+import { createTool } from "@cline/core";
+
+api.registerTool(
+  createTool({
+    name: "get_weather",                // visible to the model
+    description: "Get current weather for a city.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        city: { type: "string", description: "The city name" },
+      },
+      required: ["city"],
+    },
+    async execute(input, context) {
+      const { city } = input as { city: string };
+      // context.sessionId, context.conversationId, context.cwd are available
+      return { city, temperature: "72°F", condition: "sunny" };
+    },
+  }),
+);
+```
+
+Guidelines for good tools:
+
+- **Names are snake_case verbs** — `goto_definition`, `start_background_command`.
+- **Descriptions are written for the model**, not for humans. Include when to use the tool, what inputs mean, and what the output looks like.
+- **Inputs are JSON Schema.** Mark `required` fields explicitly. Constrain enums where possible.
+- **Return JSON-serializable values** — strings, numbers, plain objects, arrays. The host serializes results before passing them back to the model.
+- **Throw on invalid input or hard failure.** The runtime turns thrown errors into tool error results the model can recover from.
+- **Keep tools focused.** A `start / get / delete` triplet of small tools beats one mega-tool with a `mode` enum.
+
+---
+
+## 6. Runtime hooks — `hooks: { ... }`
+
+Runtime hooks are typed in-process callbacks on the same hook layer the runtime uses internally. They run inside the agent loop with full type information — no IPC, no JSON marshaling.
+
+Declare `"hooks"` in `manifest.capabilities`, then add a `hooks` property:
+
+```ts
+const plugin: AgentPlugin = {
+  name: "metrics",
+  manifest: { capabilities: ["hooks"] },
+  hooks: {
+    beforeRun(ctx) { /* ... */ },
+    beforeTool({ toolCall, input }) { /* ... */ },
+    afterTool({ toolCall, result }) { /* ... */ },
+    afterRun({ result }) { /* ... */ },
+    onEvent(event) { /* ... */ },
+  },
+};
+```
+
+### 6.1 The seven hooks
+
+| Hook          | Fires                                                      | Can stop the loop? | Common uses                                            |
+| ------------- | ---------------------------------------------------------- | ------------------ | ------------------------------------------------------ |
+| `beforeRun`   | Before the runtime loop starts (one user turn)             | Yes                | Greet, log, attach session metadata                    |
+| `afterRun`    | After the runtime loop finishes (success, abort, or fail)  | No                 | Notifications, metrics, persistent logs                |
+| `beforeModel` | Before each model request                                  | Yes (mutate req)   | Inject context, last-mile prompt edits                 |
+| `afterModel`  | After each model response, before tool execution           | Yes                | Block based on model output                            |
+| `beforeTool`  | Before each tool execution                                 | Yes (`{ stop }`)   | Audit, redact, block dangerous tools                   |
+| `afterTool`   | After each tool execution                                  | Can replace result | Post-process, redact secrets in tool output            |
+| `onEvent`     | On every `AgentRuntimeEvent` emitted by the runtime        | No                 | Streaming UIs, telemetry pipes                         |
+
+### 6.2 Stopping the loop from a hook
+
+Several hooks return an optional control object. The most common pattern is `beforeTool` blocking a destructive tool call:
+
+```ts
+beforeTool({ toolCall, input }) {
+  if (toolCall.toolName === "run_commands") {
+    const { commands } = input as { commands?: string[] };
+    if (sessionBranch === "main" && commands?.some(c => c.startsWith("git push"))) {
+      return { stop: true, reason: "Blocked git push on protected branch" };
+    }
+  }
+  return undefined;  // explicit "continue"
+}
+```
+
+Returning `undefined` (or omitting `return`) lets execution continue normally.
+
+### 6.3 `afterRun` semantics
+
+`afterRun` fires for **every** terminal status — `completed`, `aborted`, `failed`. If you only want to act on success:
+
+```ts
+afterRun({ result }) {
+  if (result.status !== "completed") return;
+  // notify, log success metrics, etc.
+}
+```
+
+### 6.4 Plugin hooks vs file hooks
+
+The runtime supports two hook systems:
+
+- **File hooks** — external scripts in `.cline/hooks/` invoked with serialized JSON. Right for user/workspace-specific scripts that don't ship with code.
+- **Plugin runtime hooks** — typed in-process callbacks. Right when the behavior belongs to a reusable extension and needs typed access to the runtime.
+
+Core adapts file hooks onto the runtime hook layer, so you don't need both. If you're shipping a plugin, write it as runtime hooks.
+
+---
+
+## 7. Message builders — `api.registerMessageBuilder`
+
+Message builders rewrite the **provider-bound message list** before the model call. They run after runtime messages are converted into SDK message blocks but **before** core's built-in safety builder, which always has the final say on provider-safe truncation.
+
+Use them for:
+
+- Custom compaction policies (replace middle history with a summary).
+- Redacting PII or secrets before they reach the provider.
+- Reshaping context for a specific model's strengths.
+
+```ts
+api.registerMessageBuilder({
+  name: "summarize-middle-history",
+  build(messages) {
+    if (estimateTokens(messages) < THRESHOLD) return messages;
+    return [...prefix, summary, ...recent];
+  },
+});
+```
+
+Multiple builders run in registration order; the output of one is the input of the next.
+
+**When to use `beforeModel` instead.** Reach for the `beforeModel` hook only if you need the runtime snapshot or want to mutate the request object itself. Pure message rewrites belong in a builder.
+
+---
+
+## 8. Automation events — `api.registerAutomationEventType` + `ctx.automation`
+
+Plugins can declare normalized event types and emit them into Cline automation. Hosts that don't have automation enabled simply ignore both — your plugin should feature-detect `ctx.automation`.
+
+```ts
+manifest: { capabilities: ["automationEvents"] },
+
+setup(api, ctx) {
+  api.registerAutomationEventType({
+    eventType: "github.pull_request.opened",
+    source: "github",
+    description: "A new GitHub PR was opened",
+    attributesSchema: { /* JSON Schema for envelope.attributes */ },
+  });
+
+  if (!ctx.automation) return;  // host has no automation
+  ctx.automation.ingestEvent({
+    eventId: "pr-1234",
+    eventType: "github.pull_request.opened",
+    source: "github",
+    subject: "owner/repo#1234",
+    occurredAt: new Date().toISOString(),
+    attributes: { /* ... */ },
+  });
+}
+```
+
+---
+
+## 9. Loading a plugin
+
+There are three ways a plugin gets into a session:
+
+### 9.1 Auto-discovery (CLI)
+
+The CLI scans these directories on startup:
+
+- `<workspace>/.cline/plugins/` — project-scoped plugins (committed or gitignored).
+- `~/.cline/plugins/` — user-scoped plugins.
+- The system "Plugins" folder — host-managed installs.
+
+Drop a `.ts` or `.js` file in, run `cline`, done:
+
+```bash
+mkdir -p .cline/plugins
+cp my-plugin.ts .cline/plugins/
+cline -i "do the thing my plugin enables"
+```
+
+### 9.2 Explicit `extensions: [...]` in SDK config
+
+When you build your own host with `ClineCore`, pass the plugin object directly:
+
+```ts
+import plugin from "./my-plugin";
+import { ClineCore } from "@cline/core";
+
+const host = await ClineCore.create({ backendMode: "local" });
+await host.start({
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+    cwd: process.cwd(),
+    enableTools: true,
+    systemPrompt: "You are a helpful assistant.",
+    extensions: [plugin],
+    // Required for ctx.workspaceInfo to be populated:
+    extensionContext: {
+      workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+    },
+  },
+  prompt: "...",
+  interactive: false,
+});
+```
+
+### 9.3 `pluginPaths: [...]` for directory-based plugins
+
+When the plugin is a directory with `package.json`, point `pluginPaths` at the directory. The loader reads `package.json` and finds entry points from the `cline.plugins` field:
+
+```ts
+config: {
+  // ...
+  pluginPaths: ["./path/to/my-plugin-package"],
+}
+```
+
+Or install one with the CLI:
+
+```bash
+cline plugin install ./path/to/my-plugin-package
+cline plugin install @scope/my-cline-plugin       # from npm
+cline plugin install --git github.com/owner/repo  # from git
+```
+
+---
+
+## 10. Single-file plugin — full template
+
+This is the full shape for a single-file plugin. Save as `my-plugin.ts`, drop in `.cline/plugins/`.
+
+```ts
+/**
+ * My Cline Plugin
+ *
+ * What it does: <one paragraph, written for users>.
+ *
+ * CLI usage:
+ *   mkdir -p .cline/plugins
+ *   cp my-plugin.ts .cline/plugins/
+ *   cline -i "trigger something the plugin enables"
+ *
+ * Direct demo:
+ *   ANTHROPIC_API_KEY=sk-... bun run my-plugin.ts
+ */
+
+import { type AgentPlugin, ClineCore, createTool } from "@cline/core";
+
+let sessionRoot: string | undefined;
+
+const plugin: AgentPlugin = {
+  name: "my-plugin",
+  manifest: {
+    capabilities: ["tools", "hooks"],
+  },
+
+  setup(api, ctx) {
+    sessionRoot = ctx.workspaceInfo?.rootPath;
+
+    api.registerTool(
+      createTool({
+        name: "do_thing",
+        description: "Do the thing this plugin exists for.",
+        inputSchema: {
+          type: "object",
+          properties: { target: { type: "string" } },
+          required: ["target"],
+        },
+        async execute(input) {
+          const { target } = input as { target: string };
+          return { ok: true, target, root: sessionRoot };
+        },
+      }),
+    );
+  },
+
+  hooks: {
+    beforeRun() {
+      console.log("[my-plugin] run started");
+    },
+    afterRun({ result }) {
+      if (result.status !== "completed") return;
+      console.log(`[my-plugin] done in ${result.iterations} iteration(s)`);
+    },
+  },
+};
+
+// Optional: a runnable demo so users can `bun run` this file directly.
+async function runDemo(): Promise<void> {
+  const host = await ClineCore.create({ backendMode: "local" });
+  try {
+    const result = await host.start({
+      config: {
+        providerId: "anthropic",
+        modelId: "claude-sonnet-4-6",
+        apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+        cwd: process.cwd(),
+        enableTools: true,
+        systemPrompt: "You are a helpful assistant. Use tools when needed.",
+        extensions: [plugin],
+        extensionContext: {
+          workspace: { rootPath: process.cwd(), cwd: process.cwd() },
+        },
+      },
+      prompt: "Use do_thing on the target 'world'.",
+      interactive: false,
+    });
+    console.log(result.result?.text ?? "");
+  } finally {
+    await host.dispose();
+  }
+}
+
+if (import.meta.main) {
+  await runDemo();
+}
+
+export { plugin, runDemo };
+export default plugin;
+```
+
+That's the entire shape. Copy it, rename the tool, swap in your logic.
+
+---
+
+## 11. Plugin package — full walkthrough
+
+A **plugin package** is a directory with a `package.json`. Use it when you need any of:
+
+- npm dependencies (`zod`, `yaml`, `typescript`, etc.)
+- multiple plugin entry points from one package
+- bundled assets (markdown templates, agent definitions, schemas, fixtures)
+- a way to ship and version the plugin via npm or git
+
+The package is still just a normal npm package — what makes it a plugin is the `cline.plugins` field in `package.json`.
+
+### 11.1 Layout
+
+A typical package looks like:
+
+```
+my-cline-plugin/
+├── package.json
+├── tsconfig.json          (optional — for local typechecking)
+├── index.ts               (the plugin entry point)
+├── README.md              (user-facing docs)
+└── assets/                (optional — bundled content)
+    ├── templates/
+    │   └── greeting.md
+    └── schemas/
+        └── input.json
+```
+
+For larger plugins, you can also organize by feature:
+
+```
+my-cline-plugin/
+├── package.json
+├── index.ts
+├── tools/
+│   ├── do-thing.ts
+│   └── read-thing.ts
+├── hooks/
+│   └── audit.ts
+├── lib/
+│   └── helpers.ts
+└── assets/
+    └── ...
+```
+
+### 11.2 `package.json` — the discovery contract
+
+```json
+{
+  "name": "my-cline-plugin",
+  "version": "0.1.0",
+  "private": true,
+  "description": "What this plugin does, in one sentence.",
+  "type": "module",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf node_modules dist"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "cline": {
+    "plugins": [
+      {
+        "paths": ["./index.ts"],
+        "capabilities": ["tools", "hooks"]
+      }
+    ]
+  },
+  "peerDependencies": {
+    "@cline/core": "*"
+  },
+  "peerDependenciesMeta": {
+    "@cline/core": { "optional": true }
+  },
+  "dependencies": {
+    "zod": "^4.1.5"
+  }
+}
+```
+
+Field-by-field:
+
+- **`type: "module"`** — required. Cline plugins are ES modules.
+- **`exports`** — points npm consumers at the entry. For TypeScript-source plugins loaded by Cline at runtime, you can export `./index.ts` directly; the loader handles TS.
+- **`cline.plugins`** — the discovery contract. An array of entries, each with:
+  - `paths` — entry files relative to the package root. For multiple plugin objects from one package, list all entries.
+  - `capabilities` — pre-declared capabilities, validated by the loader before importing the entry.
+- **`peerDependencies` for `@cline/core`** — the host already provides `@cline/core`. Marking it a peer dep avoids version drift; marking it optional lets users typecheck the plugin in isolation without forcing a `@cline/core` install.
+- **`dependencies`** — your own deps (parsers, schema libraries, SDKs you wrap).
+
+### 11.3 `tsconfig.json` (optional)
+
+For local typechecking only:
+
+```json
+{
+  "extends": "../../tsconfig.json",
+  "include": ["index.ts"]
+}
+```
+
+If your plugin lives outside a monorepo, a minimal standalone `tsconfig.json` works too:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["index.ts"]
+}
+```
+
+### 11.4 `index.ts` — package entry
+
+The same plugin shape as the single-file version, just inside a package:
+
+```ts
+import { type AgentPlugin, createTool } from "@cline/core";
+import { z } from "zod";
+
+const InputSchema = z.object({
+  target: z.string().min(1),
+});
+
+const plugin: AgentPlugin = {
+  name: "my-cline-plugin",
+  manifest: {
+    capabilities: ["tools"],
+  },
+  setup(api, ctx) {
+    api.registerTool(
+      createTool({
+        name: "do_thing",
+        description: "Do the thing.",
+        inputSchema: {
+          type: "object",
+          properties: { target: { type: "string" } },
+          required: ["target"],
+        },
+        async execute(input) {
+          const { target } = InputSchema.parse(input);
+          return { ok: true, target };
+        },
+      }),
+    );
+  },
+};
+
+export default plugin;
+```
+
+### 11.5 Bundling assets
+
+Anything next to `index.ts` ships with the package. Resolve asset paths with `import.meta.url`, **not** `process.cwd()`:
+
+```ts
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(MODULE_DIR, "assets", "templates");
+
+function loadTemplate(name: string): string | undefined {
+  const path = join(TEMPLATES_DIR, `${name}.md`);
+  return existsSync(path) ? readFileSync(path, "utf8") : undefined;
+}
+```
+
+This is the only place `import.meta.url` is appropriate in a plugin — locating files **inside the plugin package**. For workspace paths, always use `ctx.workspaceInfo?.rootPath`.
+
+### 11.6 The override pattern (bundled / global / project)
+
+A package can ship default assets and let users override them with their own. The convention used across Cline plugins is a three-tier lookup, last write wins by `name`:
+
+1. **bundled** — files inside the plugin package (defaults shipped with the plugin).
+2. **global** — files under `~/.cline/data/settings/<kind>/` (user overrides).
+3. **project** — files under `<workspace>/.cline/<kind>/` (project overrides).
+
+Example: a plugin that supports user-defined "presets" via markdown files with YAML frontmatter:
+
+```ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import YAML from "yaml";
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_DIR = join(MODULE_DIR, "presets");
+
+function resolveDataDir(): string {
+  return process.env.CLINE_DATA_DIR ??
+    join(process.env.HOME ?? "~", ".cline", "data");
+}
+
+function readPresets(workspaceRoot: string) {
+  const sources = [
+    { dir: BUNDLED_DIR, source: "bundled" as const },
+    { dir: join(resolveDataDir(), "settings", "presets"), source: "global" as const },
+    { dir: join(workspaceRoot, ".cline", "presets"), source: "project" as const },
+  ];
+  const presets = new Map<string, { name: string; body: string; source: string }>();
+  for (const { dir, source } of sources) {
+    if (!existsSync(dir)) continue;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = readFileSync(join(dir, entry.name), "utf8");
+      const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+      const data = match ? YAML.parse(match[1] ?? "") ?? {} : {};
+      const body = (match ? match[2] : raw).trim();
+      const name = data?.name ?? entry.name.replace(/\.md$/, "");
+      // Project overrides global overrides bundled — last write wins.
+      presets.set(name, { name, body, source });
+    }
+  }
+  return [...presets.values()];
+}
+```
+
+This pattern lets users:
+
+- Use the plugin out of the box (bundled defaults).
+- Customize globally for all projects (drop a file in `~/.cline/data/settings/<kind>/`).
+- Override per-project (drop a file in `<workspace>/.cline/<kind>/`).
+
+### 11.7 Multiple plugin entries in one package
+
+If your package exposes more than one plugin, list each in `cline.plugins`:
+
+```json
+"cline": {
+  "plugins": [
+    { "paths": ["./tools-plugin.ts"], "capabilities": ["tools"] },
+    { "paths": ["./hooks-plugin.ts"], "capabilities": ["hooks"] }
+  ]
+}
+```
+
+Each entry file should `export default` its own plugin object.
+
+### 11.8 Installing the package
+
+Once the package is on disk, on npm, or in a git repo, users install it with:
+
+```bash
+cline plugin install ./my-cline-plugin              # local path
+cline plugin install @scope/my-cline-plugin          # npm
+cline plugin install --git github.com/owner/repo     # git
+```
+
+The CLI installs into `<workspace>/.cline/plugins/.installs/` (or `~/.cline/plugins/.installs/`) and auto-discovers it on the next session.
+
+For SDK consumers, point `pluginPaths` at the package directory directly (see §9.3).
+
+---
+
+## 12. Testing your plugin
+
+### 12.1 Unit tests
+
+The plugin object is plain data. You can drive `setup()` against a minimal context and exercise tools directly:
+
+```ts
+import plugin from "../my-plugin";
+
+const tools: unknown[] = [];
+const api = {
+  registerTool: (t: unknown) => tools.push(t),
+  registerCommand: () => {},
+  registerRule: () => {},
+  registerMessageBuilder: () => {},
+  registerProvider: () => {},
+  registerAutomationEventType: () => {},
+};
+await plugin.setup?.(api as never, {
+  workspaceInfo: { rootPath: "/tmp/fake-workspace" },
+});
+
+// Now `tools` contains the registered tools — call tool.execute(input, ctx).
+```
+
+For higher fidelity, build a real registry (`new ContributionRegistry({ extensions: [plugin] })`) and call `initialize()` — that exercises validation too.
+
+### 12.2 End-to-end with a `runDemo()`
+
+Add a `runDemo()` in your plugin file (see §10) that boots a real `ClineCore` session against `ANTHROPIC_API_KEY`:
+
+```bash
+ANTHROPIC_API_KEY=sk-... bun run my-plugin.ts
+```
+
+This is the fastest way to verify the plugin works end-to-end.
+
+### 12.3 CLI smoke test
+
+```bash
+mkdir -p .cline/plugins
+cp my-plugin.ts .cline/plugins/
+cline -i "trigger something that exercises the plugin"
+```
+
+For packages:
+
+```bash
+cline plugin install ./my-cline-plugin
+cline -i "..."
+```
+
+If the plugin fails validation or setup, the CLI prints a clear error and continues without it.
+
+---
+
+## 13. Common gotchas
+
+- **"capabilities must be a non-empty array"** — you forgot `manifest.capabilities`, or it's `[]`.
+- **"registerRule requires the 'rules' capability"** — capability/handler drift. Add `"rules"` to capabilities, or stop calling `registerRule`.
+- **Tool not visible to the model** — check `enableTools: true` on the session config, and that you're declaring `"tools"` in capabilities.
+- **`ctx.workspaceInfo` is undefined in SDK tests** — the host didn't pass `extensionContext.workspace`. In SDK code, set it explicitly (see §9.2).
+- **State leaking across sessions** — module-level variables are shared across sessions in the same process. Key by `ctx.session?.sessionId` if your host runs multiple sessions concurrently.
+- **`afterRun` firing on aborts** — guard with `if (result.status !== "completed") return;`.
+- **Heavy work in `setup()`** — `setup()` blocks session start. Defer expensive work into the first tool call or `beforeRun`.
+- **Importing host internals** — only import from `@cline/core`. Reaching into host-specific packages (e.g. CLI internals) will break in non-CLI hosts.
+- **Sandboxed plugins and `telemetry`** — telemetry is process-local. Feature-detect `ctx.telemetry` and expect it to be undefined in sandboxed plugin processes.
+- **Resolving bundled assets** — use `import.meta.url` + `fileURLToPath` to find files inside your package; never `process.cwd()`. For workspace paths, do the opposite: use `ctx.workspaceInfo?.rootPath`, never `import.meta.url`.
+- **Plugin name collisions** — `name` must be unique within a session. If two plugins share a name, validation fails. Namespace by package (`my-org-redactor`, not `redactor`).
+
+---
+
+## 14. Decision guide — which extension point?
+
+| You want to…                                                | Use                                              |
+| ----------------------------------------------------------- | ------------------------------------------------ |
+| Give the model a new capability                             | `registerTool`                                   |
+| Add a slash command in chat surfaces                        | `registerCommand`                                |
+| Inject text into the system prompt                          | `registerRule`                                   |
+| Rewrite messages before they hit the provider               | `registerMessageBuilder`                         |
+| Add a custom model provider                                 | `registerProvider`                               |
+| Emit normalized cron/webhook events                         | `registerAutomationEventType` + `ctx.automation` |
+| Observe or steer the agent loop                             | `hooks.*`                                        |
+| Block a dangerous tool call                                 | `hooks.beforeTool` returning `{ stop: true }`    |
+| Notify on completion                                        | `hooks.afterRun` (gate on `status === "completed"`) |
+| Tweak each model request                                    | `hooks.beforeModel`                              |
+| Stream events to a UI                                       | `hooks.onEvent`                                  |
+| Ship reusable templates with the plugin                     | Bundle assets next to `index.ts`, resolve via `import.meta.url` |
+| Let users override defaults globally or per-project         | Three-tier lookup: bundled / global / project    |
+
+---
+
+## 15. Quick checklist before you ship
+
+- [ ] `manifest.capabilities` is a non-empty array.
+- [ ] Every `api.register*` call has a matching capability declared.
+- [ ] If `hooks` is present, `"hooks"` is in `capabilities`.
+- [ ] `ctx.workspaceInfo?.rootPath` is used for workspace paths (not `process.cwd()`).
+- [ ] Optional `ctx` fields are feature-detected.
+- [ ] Tool names are snake_case verbs; descriptions are written for the model.
+- [ ] Tool inputs have JSON Schema with `required` set.
+- [ ] `afterRun` handlers gate on `result.status === "completed"` if they only want successes.
+- [ ] State that must not leak between concurrent sessions is keyed by `ctx.session?.sessionId`.
+- [ ] (Package) `package.json` has `type: "module"`, `cline.plugins`, and `@cline/core` as an optional peer dep.
+- [ ] (Package) Bundled assets resolved via `import.meta.url`, not `process.cwd()`.
+- [ ] Smoke test: drop the plugin into `.cline/plugins/` (or `cline plugin install`), run `cline -i "..."`, watch it work.
+
+When in doubt, write a tiny tool, get it to fire end-to-end, then grow it.
diff --git a/sdk/.gitignore b/sdk/.gitignore
new file mode 100644
index 0000000..31290f5
--- /dev/null
+++ b/sdk/.gitignore
@@ -0,0 +1,69 @@
+out
+dist
+dist-standalone
+node_modules
+tmp
+.vscode-test/
+*.vsix
+
+.DS_Store
+.idea
+.husky/_/
+
+pnpm-lock.yaml
+
+.clineignore
+.venv
+.actrc
+CLAUDE.local.md
+
+# Ignore coverage directories and files
+coverage
+coverage-unit
+.nyc_output
+# But don't ignore the coverage scripts in .github/scripts/
+!.github/scripts/coverage/
+
+*evals.env
+.env
+.secrets
+.github/act/.secrets
+
+.worktrees
+
+## Generated files ##
+apps/vscode/src/generated/
+apps/vscode/src/shared/proto/
+apps/vscode/webview-ui/src/services/grpc-client.ts
+*.tsbuildinfo
+
+# E2E Tests
+test-results
+
+/.github/act
+/pkg
+.secrets
+
+*.tsbuildinfo
+
+# Smoke test results (generated)
+evals/smoke-tests/results/
+
+.tui-test
+secrets.json
+tui-traces
+tests/**/cache
+
+# Backup created by scripts/marketplace-readme.mjs while publishing.
+# Should never be committed: only exists if a publish aborts mid-swap.
+.README.github.bak
+
+
+# SDK Session files / User data
+.cline/data
+.cline/tmp
+*.db
+*.db-shm
+*.db-wal
+.cline/**/managed.json
+.cline/**/bundle.json
diff --git a/sdk/AGENTS.md b/sdk/AGENTS.md
new file mode 100644
index 0000000..95e2f8e
--- /dev/null
+++ b/sdk/AGENTS.md
@@ -0,0 +1,109 @@
+---
+description: Development reference for the Cline SDK workspace.
+globs: "*.ts,*.tsx,*.js,*.jsx,*.json,*.md"
+alwaysApply: true
+---
+
+# Cline SDK — Development Reference
+
+Quick-reference for active development. For onboarding, workspace setup, publishing, and detailed workflow see [CONTRIBUTING.md](./CONTRIBUTING.md). For architecture and runtime flows see [ARCHITECTURE.md](./ARCHITECTURE.md). For API details see [DOC.md](./DOC.md).
+
+## Repository Scope
+
+This file applies to the SDK workspace rooted at this directory (`sdk/`). In this repo, "root" means the SDK workspace root unless explicitly stated otherwise. Ignore the legacy repository root for SDK development except for Git operations or repo-wide searches that are explicitly needed.
+
+Run SDK commands from `sdk/`, not from the legacy repository root. Do not run direct root-level commands such as `bun test sdk/...`; they bypass the SDK workspace setup and can fail to resolve `workspace:*` packages correctly.
+
+## Package Boundaries
+
+### Published SDK Packages
+
+- `@cline/shared`: shared contracts, schemas, path helpers, hook engine, extension registry, low-level utilities
+- `@cline/llms`: provider settings/config, model catalogs, provider manifests, gateway contracts, handler creation
+- `@cline/agents`: stateless agent loop, tool orchestration, hook/extension runtime, event streaming
+- `@cline/core`: stateful orchestration, session lifecycle, storage, config watching, plugin loading, default tools, telemetry. Exposes `@cline/core/hub` for discovery, the detached daemon entry, WebSocket clients, and session/UI client adapters, plus `@cline/core/hub/daemon-entry` for launching the shared daemon
+
+### Dependency Direction
+
+```mermaid
+flowchart TD
+  shared["@cline/shared"] --> llms["@cline/llms"] & agents["@cline/agents"] & core["@cline/core"]
+  llms --> agents & core
+  agents --> core
+  core --> apps["CLI / VS Code / Code App"]
+```
+
+Rules:
+- `shared` stays low-level and reusable
+- `agents` stays stateless — no session/storage/config concerns
+- `core` owns stateful orchestration, including the shared-hub daemon, server, and client adapters under `src/hub/`
+
+## Change Routing
+
+Route changes to the package that owns the concern:
+
+- model/provider schemas or handler behavior: `@cline/llms`
+- stateless loop, tool orchestration, streaming, hook/extension runtime: `@cline/agents`
+- session lifecycle, storage, config watching, default tools, plugin loading, telemetry, hub runtime services, hub discovery, hub daemon spawn, and session-oriented client helpers (`HubSessionClient`, `HubUIClient`, `connectToHub`): `@cline/core` (hub pieces live under `src/hub/`)
+- remote-config schemas, managed instruction materialization, blob upload metadata, and OpenTelemetry config normalization: `@cline/shared/src/remote-config`
+- host-specific UX or shell behavior: app package
+
+## Verifying Changes
+
+Before testing in a fresh worktree, install SDK dependencies from the SDK workspace root:
+
+```sh
+cd sdk
+bun install --frozen-lockfile
+```
+
+SDK package exports resolve sibling packages through compiled `dist/` files. If `dist/` is missing, build the SDK packages before running package tests:
+
+```sh
+bun run build:sdk
+```
+
+SDK-root commands for cross-package confidence:
+
+```sh
+bun run types       # typecheck all packages
+bun run test        # run all tests
+bun run check       # lint + build + typecheck + check-publish
+```
+
+For focused verification, prefer workspace package scripts from the SDK root:
+
+```sh
+bun -F @cline/shared test
+bun -F @cline/llms test
+bun -F @cline/agents test
+bun -F @cline/core test:unit
+bun -F @cline/cli test:unit
+```
+
+If a focused test command fails with a missing `@cline/*` export or missing `dist/` file, build the relevant dependency package or run `bun run build:sdk`, then rerun the same test command. Treat that as a workspace setup issue, not as evidence of a source-code bug.
+
+If you touch hub/bootstrap/session flows, please update `ARCHITECTURE.md`.
+
+## Practical Guidance
+
+### Keep Boundaries Clean
+
+- Don't move stateful logic down into `agents`
+- For `@cline/llms` provider/model routing rules, follow [packages/llms/AGENTS.md](./packages/llms/AGENTS.md).
+- Don't put app-specific behavior into `core` unless it is truly shared host behavior
+- Keep remote-config primitives generic in `shared`; host-facing session integration belongs in `core`
+
+### Refactor Standard
+
+- Prefer direct architectural cleanup over compatibility shims
+- Move code to the layer that owns the concern and update all call sites
+- If a helper just projects watcher state, keep it with the config layer instead of creating thin runtime wrappers
+
+## Documentation Responsibilities
+
+- `README.md`: visitor-facing overview. Update when the repo story or package inventory changes.
+- `CONTRIBUTING.md`: onboarding, workflow, publishing. Update when contributor setup or release process changes.
+- `AGENTS.md` (this file): development reference. Update when package boundaries, dependency rules, or change routing changes.
+- `ARCHITECTURE.md`: design, boundaries, runtime flows. Update when system design or architectural constraints change.
+- `DOC.md`: API and behavior reference. Update when exported surfaces, lifecycle semantics, or runtime behavior changes.
diff --git a/sdk/ARCHITECTURE.md b/sdk/ARCHITECTURE.md
new file mode 100644
index 0000000..65ab495
--- /dev/null
+++ b/sdk/ARCHITECTURE.md
@@ -0,0 +1,530 @@
+# Cline SDK Architecture
+
+This document is the architecture source of truth for the Cline SDK repository. It describes how the system is organized, how components interact, and the design principles that guide development decisions.
+
+**Who should read this?**
+- SDK contributors working across multiple packages
+- Developers building integrations or host applications using `@cline/core`
+- Plugin authors understanding the runtime and extension systems
+
+**What this covers:**
+- Package boundaries and responsibilities
+- Dependency direction and layering rules
+- Runtime flows (local, hub-backed, remote-config managed)
+- Design seams (repeated patterns instead of one-off integrations)
+- Architectural constraints and why they exist
+
+**What this is NOT:**
+- An onboarding guide for new contributors (see README.md and CONTRIBUTING.md)
+- A detailed API reference (see package READMEs and inline JSDoc)
+- A user guide (see the main documentation)
+
+## Layered Model
+
+The workspace is organized as a layered runtime stack.
+
+```mermaid
+flowchart LR
+  shared["@cline/shared"]
+  llms["@cline/llms"]
+  agents["@cline/agents"]
+  core["@cline/core"]
+  apps["Host Apps"]
+
+  llms --> shared
+  agents --> llms
+  agents --> shared
+  core --> agents
+  core --> llms
+  core --> shared
+  apps --> core
+```
+
+## Package Responsibilities
+
+### `@cline/shared`
+
+Owns reusable low-level contracts and infrastructure:
+
+- shared types and schemas
+- path resolution
+- hook contracts/engine
+- extension registry contracts
+- prompt and parsing helpers
+- storage path helpers
+- remote-config schemas, managed instruction materialization, telemetry normalization, and blob upload primitives
+
+Design rule:
+
+- `shared` should not depend on higher-level runtime packages.
+
+### `@cline/llms`
+
+Owns model/provider runtime concerns:
+
+- provider settings/config resolution
+- model catalogs and manifests
+- shared gateway-style provider contracts
+- handler creation via an internal gateway registry
+- AI SDK-backed provider execution code
+
+Design rule:
+
+- provider-specific behavior should be isolated here, not spread across `core` or apps.
+
+### `@cline/agents`
+
+Owns the stateless runtime loop:
+
+- agent iteration loop
+- tool orchestration
+- runtime event emission
+- hook/extension execution
+- turn preparation before provider calls
+- in-memory team/runtime primitives
+
+Design rule:
+
+- `agents` should not own persistent storage or host lifecycle concerns.
+
+### `@cline/core`
+
+Owns stateful orchestration:
+
+- runtime composition
+- session lifecycle
+- storage and persistence
+- config watching/loading and watcher projections
+- settings listing and mutation orchestration
+- default host tool assembly
+- plugin discovery/loading
+- default context compaction policy
+- telemetry integration
+- hub server and scheduled-runtime services under `src/hub/`
+- hub discovery, the detached hub daemon, and the `@cline/core/hub/daemon-entry` subpath
+- host-side hub client adapters (`NodeHubClient`, `HubSessionClient`, `HubUIClient`, `connectToHub`) exported from `@cline/core/hub`
+
+Design rules:
+
+- `core` is the app-facing orchestration layer over `agents`.
+- hub-related modules live under `packages/core/src/hub/`, grouped by service:
+  - `client/` contains host-facing hub clients and browser connection helpers
+  - `daemon/` contains detached daemon startup, entrypoint, and local runtime handler wiring
+  - `discovery/` contains endpoint defaults, discovery records, and workspace owner resolution
+  - `server/` contains WebSocket server startup, native/browser socket adapters, server transport, server helpers, and `handlers/` for hub command dispatch
+- settings mutations belong in core services and hub commands, not in host-specific file writes. Hosts should call the core settings facade or the `settings.*` hub command family and react to `settings.changed`.
+
+## Runtime Flows
+
+### Local In-Process Runtime
+
+1. Host constructs a `RuntimeHost` through `@cline/core`.
+2. `@cline/core` selects `LocalRuntimeHost` through `packages/core/src/runtime/host.ts`.
+3. Hosts normalize broad local config into `RuntimeSessionConfig` plus `localRuntime` overrides before calling `RuntimeHost.start(...)`.
+4. `@cline/core` prepares a local bootstrap artifact from `localRuntime`, then builds the runtime from it.
+5. `@cline/core` creates an `Agent` from `@cline/agents`.
+6. `@cline/agents` runs the loop using `@cline/llms` handlers.
+7. `@cline/core` persists state, artifacts, and metadata.
+
+Completion telemetry is anchored to the assistant's explicit completion
+declaration, not session shutdown. After each agent turn, the local
+runtime inspects `AgentResult.toolCalls` and emits `task.completed` the
+moment a successful `submit_and_exit` (the SDK analog of original
+Cline's `attempt_completion`) is observed. `shutdownSession(...)`
+retains a fallback emission for completed sessions that finished
+without an explicit completion-tool observation, so non-interactive
+runs not using the yolo preset still produce a `task.completed` signal.
+Each session emits at most one `task.completed`. See `DOC.md` for the
+event payload and `source` field.
+
+### Hub-Backed Runtime
+
+1. Host constructs a `RuntimeHost` through `@cline/core`.
+2. `@cline/core` selects `HubRuntimeHost` or `RemoteRuntimeHost` through `packages/core/src/runtime/host.ts`.
+3. When no compatible local hub is already discovered, `@cline/core` can spawn a detached hub daemon and reconnect through discovery.
+4. Hosts attach and detach from shared sessions without stopping the authority runtime, so another client can keep streaming or resume the same session later.
+5. The hub-hosted runtime executes the agent loop using `@cline/agents` and `@cline/llms`.
+6. `@cline/core` hub services broker sessions, events, approvals, schedules, and client-owned runtime capabilities such as session-local tool executors.
+7. Hub event forwarding preserves structured streaming lifecycle boundaries: text/reasoning deltas, final text/reasoning completion, tool start/finish, and agent done events are translated across the hub transport so host UIs can reliably close loading/streaming state.
+8. Hub client adapters exported from `@cline/core/hub` (`NodeHubClient`, `HubSessionClient`, `HubUIClient`, `connectToHub`) translate command/reply and event streams into host-facing APIs.
+9. Hub `session.get` records include both canonical root-session usage and explicit aggregate usage from the hub-owned `RuntimeHost`, so attached clients can intentionally render either root-only or root-plus-teammate costs without replaying event streams.
+
+Detached daemon startup retries transient `ETXTBSY` spawn failures before
+polling discovery. This covers package-manager updates that replace the CLI
+binary immediately before a command restarts the shared hub.
+
+Local hub discovery also carries the authentication contract for the shared
+daemon. On startup, the hub server generates a cryptographically random
+per-process auth token, stores it in the owner discovery record, and writes that
+record with owner-only file permissions. Local clients resolve the token from
+the discovery file at connection time rather than embedding it in endpoint URLs.
+The server validates the token with a constant-time comparison before accepting
+`/hub` WebSocket upgrades or `/shutdown` requests; WebSocket clients send it via
+the `Sec-WebSocket-Protocol` header and shutdown requests use an
+`Authorization: Bearer` header. Unauthenticated local processes can still probe
+public health/build metadata, but they cannot attach to sessions, issue
+commands, or stop the daemon.
+
+Local hub rediscovery is limited to managed shared-daemon endpoints obtained
+through discovery or `ensure*HubServer(...)` startup paths. Explicit endpoints,
+including loopback URLs such as `ws://127.0.0.1:<port>/hub`, are sticky exact
+targets: reconnects may retry the same socket URL, but command recovery and
+startup-deadlock recovery must not replace them with the workspace-discovered
+hub. This keeps custom local hubs and remote hubs from silently drifting to a
+different process.
+
+### Interactive CLI Startup
+
+1. `apps/cli` owns OpenTUI startup and must render the first frame without waiting for detached hub startup.
+2. Interactive sessions use `backendMode: "auto"` so an already-compatible hub can be reused immediately, while a missing hub is only prewarmed in the background and the TUI falls back to a local runtime for responsiveness.
+3. Hub-required flows such as `cline hub`, schedules, connectors, and `--zen` may still call the explicit ensure path because those commands require a live hub before proceeding.
+4. Resume hydration is deferred until after `renderOpenTui()` so loading previous messages cannot block initial TUI paint.
+5. Any future CLI/TUI startup work should follow the same rule: daemon startup, discovery polling, provider catalog refreshes, file indexing, and resume reads must be background or user-action gated unless a command explicitly requires their result before output.
+
+### Remote-Config Managed Runtime
+
+1. A host or core wrapper fetches a normalized `RemoteConfigBundle`.
+2. `@cline/shared/remote-config` caches the bundle when configured.
+3. Shared remote-config materializes managed rules/workflows/skills under workspace-local `.cline/<plugin>/`.
+4. Shared remote-config derives generic OpenTelemetry config and session blob upload metadata from the bundle.
+5. `@cline/core` exposes the app-facing integration wrapper that applies extensions, telemetry, and session metadata to `StartSessionInput`.
+6. `@cline/core` consumes the prepared local overrides during local bootstrap.
+
+This keeps reusable remote-config behavior in `shared` while the session-specific bridge remains in `core`.
+
+## Design Seams
+
+The codebase relies on a few repeated seams instead of one-off integration paths.
+
+### 1. Config Watchers
+
+Core uses file-based discovery and watchers for:
+
+- rules
+- workflows
+- skills
+- agents
+- hooks
+- plugins
+
+Design implication:
+
+- new instruction sources should usually materialize into files and reuse watcher-based loading instead of inventing parallel in-memory execution paths.
+- in `packages/core`, config-facing discovery, parsing, watching, and slash-command projection live under `src/extensions/config`
+
+### 2. Runtime Builder Inputs
+
+`DefaultRuntimeBuilder` composes a runtime from generic inputs:
+
+- tools
+- hooks
+- extensions
+- user instruction watcher
+- telemetry
+
+Design implication:
+
+- higher-level integrations should prefer feeding those seams rather than patching agent internals directly.
+- the local runtime bootstrap lives in `packages/core/src/services/local-runtime-bootstrap.ts` and feeds the builder rather than bypassing it
+
+### 3. Runtime Host Boundary
+
+Core exposes one shared execution boundary: `RuntimeHost`.
+
+Concrete implementations:
+
+- `LocalRuntimeHost` for in-process execution
+- `HubRuntimeHost` for shared local hub execution
+- `RemoteRuntimeHost` for explicit remote hub endpoints
+
+Design implication:
+
+- host selection happens in `packages/core/src/runtime/host.ts`
+- `ClineCore` delegates uniformly to `RuntimeHost` and does not branch on local vs hub behavior
+- transport-specific translation belongs inside concrete hosts, not in top-level orchestration
+- `RuntimeHost` inputs stay transport-safe, while `ClineCore.start(...)` is the app-facing facade that normalizes broad local config before delegation
+- `RuntimeSessionConfig` is transport-neutral across local, shared hub, and remote hub modes; host-local bootstrap concerns stay under `localRuntime`
+- client-local runtime behaviors that must survive hub mode, such as `defaultToolExecutors`, are attached at session start and proxied through hub capability requests instead of changing host selection
+- pending prompt list/update/delete are exposed through the grouped
+  `ClineCore.pendingPrompts` service. Usage summary lookup and active-session
+  model switching are also service-style capabilities exposed through
+  `ClineCore` when the concrete transport implements them. These service APIs
+  are intentionally outside the minimal `RuntimeHost` primitive vocabulary.
+- The usage service's `getAccumulatedUsage(sessionId)` method returns a summary
+  with two explicit buckets: `usage` for the root/lead agent and
+  `aggregateUsage` for root plus teammates/subagents. Local execution tracks
+  root usage and teammate usage as separate buckets, then derives aggregate
+  totals from those buckets while telemetry remains scoped to the primary
+  lead/root agent.
+
+### 4. Settings Mutation Boundary
+
+Core owns settings snapshots and mutations through `packages/core/src/settings`.
+The hub exposes the same path through `settings.list` and `settings.toggle`.
+
+Design implication:
+
+- hosts should not mutate skill, tool, MCP, provider, or other settings files directly
+- domain-specific persistence helpers, such as skill markdown frontmatter writes, stay internal to the owning settings provider/service
+- successful hub-backed mutations return an updated settings snapshot and publish `settings.changed` with the changed settings types
+- CLI settings surfaces may keep local snapshot rendering for startup responsiveness, but mutation flow must refresh the relevant watcher before reloading UI data
+
+### 5. Session Startup Bootstrap
+
+`ClineCore.create(...)` exposes a generic `prepare(input)` hook.
+
+Design implication:
+
+- higher-level packages can prepare workspace-scoped runtime state before a session starts
+- core stays unaware of enterprise-specific contracts
+- cleanup stays at the host boundary rather than inside the agent loop
+
+### 6. Logging
+
+Cross-package logging uses a small injected interface exported from `@cline/shared`:
+
+- **`BasicLogger`** — required `debug` and `log`; optional `error`. Hosts map these to their backend (Pino, VS Code `OutputChannel`, etc.). Many runtime options take `logger?: BasicLogger`; when omitted, components skip logging or use `noopBasicLogger` where a full object is required.
+- **`BasicLogMetadata`** — optional structured fields (`sessionId`, `runId`, `providerId`, `toolName`, `durationMs`, …) plus `severity` on `log` when a single method must represent both informational and warning-style messages (for example the CLI Pino bridge maps `severity: "warn"` to Pino `warn`).
+
+Naming clarity:
+
+- **`CliLoggerAdapter` (CLI)** — a **host bundle**: holds the raw `pino` logger (for file paths, rotation, and CLI-only concerns) and exposes `.core: BasicLogger` for anything that consumes the SDK contract. It is not an `ITelemetryAdapter`.
+- **`TelemetryLoggerSink` (`@cline/core`)** — an **`ITelemetryAdapter`** that mirrors telemetry events and metrics into a `BasicLogger`. It is a telemetry sink, not a host logging implementation.
+
+The agent and other call sites route former `info` / `warn` semantics through `log` (warnings include `severity: "warn"` in metadata). Errors prefer `error` when implemented; otherwise `log` with `severity: "error"` is used as a fallback.
+
+Design implication:
+
+- logging is injectable and transport-agnostic, allowing host environments (CLI, VS Code, browser) to wire their own backends
+- do not hardcode logging calls; accept a `logger?: BasicLogger` parameter instead
+
+### 7. Storage Adapters
+
+Stateful persistence should be isolated behind adapter/service layers.
+
+Design implication:
+
+- file-backed, SQLite-backed, RPC-backed, and enterprise-specific persistence should share service logic where possible and isolate backend differences in adapters.
+
+### 8. Extension and Hook System
+
+Extensibility is split deliberately:
+
+- extensions register runtime contributions
+- hooks intercept lifecycle stages
+
+Design implication:
+
+- additive runtime behavior should usually enter through these extension points instead of bespoke special-case host code.
+
+### 9. Context Compaction
+
+Context compaction is owned by `core`.
+
+- `@cline/agents` owns the generic turn-preparation seam:
+  - run normal lifecycle hooks
+  - allow hosts to project message history or system prompt before the provider call
+  - keep its canonical runtime transcript append-only when a projection is returned
+- `@cline/core` owns compaction policy:
+  - inject a prepare-turn pipeline for root sessions
+  - choose between built-in strategies through a registry map
+  - persist the latest compacted working context as a session compaction artifact
+  - keep compaction logic out of the low-level agent message builder
+
+Design implications:
+
+- compaction is a context-pipeline concern owned by `core`
+- canonical session history lives in the session messages artifact at full fidelity; compaction state lives separately in `${sessionId}.compaction.json`
+- resume loads the canonical transcript for history/debugging and, when present, reuses the latest compaction state only after validating a hash of the canonical prefix covered by that state; valid state is projected by appending canonical messages written after the compaction boundary
+- sessions that were already persisted with compacted messages before this model are best-effort only because the omitted original transcript is not recoverable from the compacted artifact
+- `agents` stays focused on the stateless loop and provider/tool orchestration
+- delegated/subagent flows should inherit compaction behavior through core session config, not through a separate agent-level compaction hook surface
+
+### 10. Extension Layering Inside Core
+
+`packages/core/src/extensions` is split by concern:
+
+- `extensions/config`: config loaders, parsers, watchers, and watcher projections such as runtime slash-command expansion
+- `extensions/plugin`: runtime plugin discovery, loading, and sandboxing
+- `extensions/context`: core-owned context/message pipeline concerns such as compaction
+
+Design implications:
+
+- avoid mixing config discovery code into runtime/plugin code
+- avoid creating thin runtime wrapper files when a helper is fundamentally projecting watcher state
+
+## Architectural Constraints
+
+### Keep `agents` Stateless
+
+Do not move these concerns into `@cline/agents`:
+
+- session persistence
+- provider settings storage
+- RPC lifecycle
+- host-specific approvals
+- remote-config policy caching
+
+### Keep `core` Generic
+
+Do not make `@cline/core` organization- or provider-specific.
+
+If a capability is truly generic and app-facing, add a generic core seam. Reusable remote-config parsing, materialization, and upload primitives belong in `@cline/shared/remote-config`.
+
+### Use One-Way Optional Layers
+
+Optional higher-level integrations may depend on lower layers.
+Lower layers should not depend on optional feature packages.
+
+For remote config, that means shared owns the reusable bundle/materialization/blob primitives and core owns only the session-oriented wrapper exported to apps.
+
+## File-Based And Event-Driven Automation (`ClineCore` / `CronService`)
+
+`@cline/core` ships a file-based automation subsystem under
+`packages/core/src/cron/`. It lets operators author recurring and one-off
+tasks as Markdown files under global `~/.cline/cron/` by default, and
+event-driven tasks as `events/*.event.md` specs. All trigger kinds run
+through the same durable queue and runtime handlers. `ClineCore` exposes the
+SDK-facing `cline.automation.*` entry points; `CronService` is the internal
+orchestrator used by core and hub layers.
+
+### Layers
+
+1. **Spec parser** (`cron/specs/cron-spec-parser.ts`): parses YAML frontmatter + body
+   into a `CronSpec` discriminated union (`one_off | schedule | event`).
+   Types live in `@cline/shared` under `src/cron/cron-spec-types.ts`
+   so other packages can consume them without the YAML parser. Schedule
+   expressions and timezones are validated before a spec can become
+   runnable.
+2. **Store** (`cron/store/sqlite-cron-store.ts`): owns `cron.db` at
+   `resolveCronDbPath()` (default `.cline/data/db/cron.db`). Schema is
+   bootstrapped from `cron/store/cron-schema.ts` — sessions and cron live in separate
+   DBs so their lifecycles stay decoupled.
+3. **Reconciler** (`cron/specs/cron-reconciler.ts`): scans the configured cron specs
+   directory (global `~/.cline/cron/` by default, or workspace-scoped when
+   configured), parses each file independently, and upserts spec state.
+   Invalid specs are recorded
+   with `parse_status='invalid'` so state is durable rather than silently
+   dropped. Files that disappear between scans get `removed=1` and their
+   queued runs are cancelled.
+4. **Watcher** (`cron/specs/cron-watcher.ts`): `node:fs watch({ recursive: true })`
+   with a ~250ms per-path debounce. Watcher events always trigger a
+   re-reconcile — the reconciler is always the source of truth, not the
+   watcher stream.
+5. **Materializer** (`cron/runner/cron-materializer.ts`): turns file-triggered specs into
+   queued `cron_runs`. One-off: at most one run record per `(spec_id,
+   revision)`, including failed runs so specs do not retry accidentally.
+   Schedule: "one overdue catch-up on startup then advance" using
+   timezone-aware `getNextCronTime`.
+6. **Event ingress** (`cron/events/cron-event-ingress.ts`): accepts already-normalized
+   `AutomationEventEnvelope` values, persists them into `cron_event_log`,
+   matches enabled event specs by `event_type` plus declarative filters,
+   applies dedupe/debounce/cooldown policy, and enqueues `cron_runs` with
+   `trigger_kind='event'`. It never executes agents directly. Plugins can
+   declare `automationEvents` and submit normalized events through
+   `ctx.automation.ingestEvent(...)`; sandboxed plugins forward those events
+   through the core plugin event bridge.
+7. **Runner** (`cron/runner/cron-runner.ts`): polls `cron.db`, atomically claims
+   queued runs, executes them via the existing `HubScheduleRuntimeHandlers`
+   (`startSession` → `sendSession` → `stopSession` / `abortSession`),
+   renews the run claim while execution is active, writes a markdown report
+   per run, and transactionally updates status. File specs can constrain
+   tool availability, config extension loading (`rules`, `skills`,
+   `plugins`), session source, and a notes directory that is injected into
+   the system prompt. Event runs include the normalized trigger event context
+   in the prompt.
+8. **Reports** (`cron/reports/cron-report-writer.ts`): writes
+   `.cline/cron/reports/<run-id>.md` with run frontmatter plus
+   `## Summary`, `## Usage`, `## Tool Calls`, and, for event runs,
+   `## Trigger Event` sections.
+9. **Service** (`cron/service/cron-service.ts`): orchestrates all of the above.
+   `ClineCore.create({ automation })` owns the SDK-facing lifecycle and exposes
+   `cline.automation.*` methods. Hub-side callers can submit normalized events
+   through the `cron.event.ingest` command.
+
+The detached hub daemon passes its workspace root as `cronOptions`, so
+normal CLI/hub startup watches `${workspaceRoot}/.cline/cron/` without a
+custom host needing to opt in.
+
+Programmatic hub schedules are stored as `cron_specs` with source
+`hub-schedule` and execute through the same `cron_runs`
+claim/requeue/report flow as file-backed one-off, recurring, and
+event-driven specs. The hub schedule command surface remains a thin adapter;
+there is no separate schedules table, schedule store, or schedule runner.
+
+## Navigating the Codebase
+
+### Starting Points by Task
+
+**I want to understand the agent loop and tool execution:**
+- Start: `packages/agents/src/agent.ts` — the stateless runtime loop
+- Then: `packages/agents/src/agent-step.ts` — individual iteration steps
+- Extensions: `packages/core/src/extensions/plugin/` — plugin discovery and sandboxing
+
+**I want to understand session persistence and state:**
+- Start: `packages/core/src/runtime/host/local-runtime-host.ts` — local session lifecycle
+- Then: `packages/core/src/runtime/orchestration/` — session orchestration
+- Settings: `packages/core/src/settings/` — settings mutation and state
+
+**I want to understand the hub system:**
+- Start: `packages/core/src/hub/server/` — WebSocket server and hub command handlers
+- Clients: `packages/core/src/hub/client/` — host-side hub clients
+- Transport: `packages/core/src/hub/runtime-host/` — hub-backed runtime hosts
+
+**I want to add a new tool:**
+- Tools registry: `packages/core/src/extensions/tools/` — built-in tool definitions
+- Tool execution: `packages/agents/src/tool-use.ts` — how tools are called
+- Plugin tools: `packages/core/src/extensions/plugin/` — plugin-registered tools
+
+**I want to understand settings and configuration:**
+- Watcher system: `packages/core/src/extensions/config/` — file watching and loading
+- Provider config: `packages/core/src/runtime/config/` — provider settings resolution
+- Settings services: `packages/core/src/settings/` — settings state and mutation
+
+**I want to add a new runtime feature (hook/extension):**
+- Hook contracts: `packages/shared/src/hooks/` — hook types and engine
+- Plugin system: `packages/core/src/extensions/plugin/` — plugin discovery and execution
+- Runtime builder: `packages/core/src/services/local-runtime-bootstrap.ts` — how runtime is composed
+
+### File Naming Conventions
+
+- `*.ts` — TypeScript source
+- `*.test.ts` — unit tests (Vitest)
+- `*.e2e.test.ts` — end-to-end tests requiring full integration
+- `*.ts` in examples — runnable example files (plugins, hooks)
+- `*.md` files in `apps/examples/` — documentation and markdown-based specs (cron, events)
+
+### Key Type Locations
+
+- **`ClineCore`** — `packages/core/src/index.ts` — the main SDK orchestrator
+- **`Agent`** — `packages/agents/src/agent.ts` — the agent loop
+- **`RuntimeHost`** — `packages/core/src/runtime/host/runtime-host.ts` — execution abstraction
+- **`AgentPlugin`** — `packages/shared/src/plugin/` — plugin contract
+- **`CronSpec`** — `packages/shared/src/cron/cron-spec-types.ts` — automation specs
+
+## Publishability Constraint
+
+This repo has both publishable SDK packages and internal workspace packages.
+
+Architectural consequence:
+
+- internal packages must not accidentally become part of the publishable SDK surface
+- release automation should only target the intended published packages
+- internal code may compose with published packages, but published packages should not take hard dependencies on internal-only workspace layers unless you explicitly intend to publish that integration
+
+### Published Packages
+
+The following packages are published to npm:
+
+- `@cline/shared` — shared types, contracts, and low-level utilities
+- `@cline/llms` — provider integrations and model manifests
+- `@cline/agents` — the agent loop and tool orchestration
+- `@cline/core` — the main SDK with session management, hub, and configuration
+
+### Internal Apps
+
+The following workspace apps are internal and not published as SDK packages:
+
+- `apps/cli` — CLI implementation
+- `apps/webview` — VS Code webview
+- `apps/examples` — example plugins and integrations
diff --git a/sdk/CHANGELOG.md b/sdk/CHANGELOG.md
new file mode 100644
index 0000000..09ca496
--- /dev/null
+++ b/sdk/CHANGELOG.md
@@ -0,0 +1,162 @@
+# Cline SDK Changelog
+
+## 0.0.59
+
+- You can now select Cline free models on the ClinePass provider
+- The SDK now recognizes ClinePass rate-limit responses and surfaces them as a typed `ClinePassLimitError` (with `isClinePassLimitMessage` / `extractClinePassLimitMessage` helpers)
+- Removed references to the retired ClinePass GLM 5.1 model
+- Fixed OpenAI Codex model metadata under the GPT Subscription provider
+- The detached hub daemon process now emits telemetry
+- SDK/CLI telemetry identity attributes now include `user_id`
+- Cline provider requests now send versioned Cline client-identity headers
+- Fixed context compaction so canonical session history is preserved
+- `str_replace` edits now report accurate diffs
+- Fixed a performance issue where listing sessions could hang the extension host
+
+## 0.0.58
+
+- `read_files` now tolerates malformed input from weaker models: line-range entries (`start_line`/`end_line`) sent as separate array items are coalesced back onto the preceding file path instead of being rejected
+
+## 0.0.57
+
+- Models in the live catalog that don't report a context window now default to a 128K input-token limit (up from 4,096), so under-specified models get a usable context budget
+- The default max input-token budget used for context compaction is now 128K
+- Added a shared prompt-format helper in `@cline/shared` and simplified runtime host support
+
+## 0.0.56
+
+- Tool calls from weaker models that use slightly-off argument shapes (e.g. a bare string where an array is expected) or malformed/truncated JSON are now coerced or repaired and executed, instead of being rejected before the tools can handle them
+- Fixed plan/act mode notices being stripped from outbound prompts
+- Added support for surfacing plan/act mode switches to the model
+
+## 0.0.55
+
+- Add Tencent TokenHub as a provider
+- Add a compaction strategy setting so you can choose how context compaction works
+- Fix first-prompt truncation on high-output models (e.g. MiniMax M3), where a shallow session could auto-compact immediately and reduce the initial task to just the input wrapper
+- Use a curated default when migrating legacy provider settings
+- Advertise run commands as shell strings
+- Refresh the bundled model catalog with the latest provider models
+
+## 0.0.54
+
+- Improve basic compaction token budgeting so context compaction is more accurate
+- Preserve error detail and fetch error cause information so failures surface clearer messages
+- Preserve failed run error messages instead of dropping them
+- Derive model info in the provider/model runtime path for more reliable provider/model handling
+- Add ClinePass subscription support to the account service
+
+## 0.0.53
+
+- Show when request cost is covered by the user's Cline subscription
+- List ClinePass features in the not-subscribed message
+- Added shared marketplace uninstall support
+- Shared marketplace install logic through core
+- Surfaced plugin-bundled skills
+- Capped MCP tool names at 64 characters for OpenAI-compatible providers
+- Updated coupon code
+
+## 0.0.52
+
+- Added checkpoints support to the agent runtime
+- Added SAP AI Core provider support: stabilized provider setup, bundled provider auth, forwarded provider options to the gateway, aligned provider config, kept model filtering in clients, and added OCA legacy reasoning-effort handling
+- Routed LiteLLM model fetches through the SDK and stopped unrelated models from being injected into the LiteLLM model list
+- Preserved OpenRouter reasoning-disable semantics and included the session id for OpenRouter prompt caching
+- Updated the ClinePass model list live, restored ClinePass models in onboarding, fixed ClinePass error mapping, and scoped the ClinePass URL to the CLI
+- Threaded proxy/CA-aware fetch into the SDK inference path
+- Persisted Bedrock settings to providers.json
+- Repaired exposed provider auth routing and restored provider-request capture wiring lost in the SDK migration
+- Added a connector configure path and moved the shared connector catalog into the shared package
+- Normalized JSON-like tool inputs by schema and avoided a nullable editor `old_text` schema
+- Batched outdated-read rewrites in `MessageBuilder` to preserve provider prefix caches
+- Prevented an "ERROR: EMPTY CONTENT" message from appearing when an error occurs
+- Added non-interactive command guidance to the agent
+- Published SDK sourcemaps
+- Refreshed the generated model catalog
+
+## 0.0.51
+
+- Fixed Z.ai model metadata not resolving correctly when using Z.ai models through the Cline provider; aliases now map to the right model metadata and user overrides are preserved
+
+## 0.0.50
+
+- Truncate every tool result by default (including MCP and custom tool output), with tightened `MessageBuilder` limits and tunable `CLINE_MESSAGE_BUILDER_*` env overrides, to keep provider requests within budget
+- Cap assistant text in provider messages and count `tool_use` input toward the request budget; protect binary carrier blocks (not just images) from truncation
+- Resolve tool names from `tool_result` when the paired `tool_use` is gone
+- Add ClinePass provider support (built-in provider, error handling, format compatibility)
+- Apply auto-approve toggles immediately in the agent runtime
+- Harden parallel tool-call guidance in the system prompt and tool definitions
+- Refresh the generated model catalog
+
+## 0.0.49
+
+- Reverted ClinePass recommended-models support, removing the `clinePass` field from the recommended models data
+
+## 0.0.48
+
+- Added ClinePass support and ClinePass models
+- Added MCP server support to plugins
+- Updated the recommended/fixed model list
+- Encouraged parallel tool calls for faster task execution
+- Capped tool output ingestion for bash commands and file reads to keep large output within context limits
+- Added a bounded media budget for provider requests, plus generic provider-request capture
+- Allowed ranged reads on large files
+- Fixed apply_patch to fail when a hunk is skipped instead of silently dropping it
+- Fixed run_commands to return captured stdout on failure and to coalesce split heredocs
+- Fixed search tools to treat zero results as a successful result
+- Fixed search output cap and bash executor follow-up issues
+- Fixed disabled-reasoning handling for StepFun flash
+- Fixed the Hugging Face URL
+- Fixed Cline OAuth token formatting in provider config
+
+## 0.0.47
+
+- Added support for overriding the API base URL
+- Enforced a production singleton Cline Hub so only one hub daemon runs, and a stale hub is respawned after an upgrade
+- Allowed plugin chat commands to submit prompts to the agent
+- Fixed truncation of structured tool operation result strings so oversized tool output stays within limits
+- Stopped echoing the full command text in run_commands tool results
+
+## 0.0.46
+
+- Added support for configured agents as subagent tools
+- Centralized OAuth management into the SDK
+- Added Vertex GCP settings configuration
+- Fixed the Azure Foundry API version for the CLI
+- Fixed an error caused by disabled reasoning on Fable 5
+
+## 0.0.45
+
+- Added support for the Claude Fable 5 model
+- Fixed MiniMax M3 thinking controls so they route correctly across gateways
+
+## 0.0.44
+
+- Added support for Vertex AI Application Default Credentials (ADC) with tool use
+- Added a global auto-update setting for CLI startup updates
+- Fixed empty message content replay for Bedrock
+- Cleaned up the OpenAI Codex model list
+
+## 0.0.43
+
+- Added the Cline Hub web app for managing and monitoring agent sessions
+- Added plugin uninstall support
+- Added skills bundled with plugins, including grouping plugin skills in settings and rule contributions from sandboxed plugins
+- Added support for global AGENTS rules
+- Added Slack socket mode support and bound Discord sessions to individual message authors
+- Synced the Fireworks AI model registry and updated the model catalog to current platform offerings
+- Routed custom registered handlers through the agent runtime
+- Added a CLINE_PLUGIN_IMPORT_TIMEOUT_MS environment override for plugin import timeouts
+- Allowed a baseUrl field for Anthropic vendor-type providers
+- Fixed SAP AI Core to use the AI SDK community provider
+- Fixed the hub daemon to stay alive on runtime abort
+- Fixed read-files tool input validation to use a union schema
+- Fixed discovery of symlinked SDK skill directories
+- Improved Cline provider migration
+- Fixed OTEL variable bundling
+- Added telemetry for run_commands timeouts
+
+## 0.0.42
+
+- Supports Bedrock bearer API keys, direct IAM credentials, AWS profiles, and the default AWS SDK credential chain
+- Routes Z.AI GLM thinking through provider metadata while preserving generic thinking suppression for non-GLM Z.AI custom models
diff --git a/sdk/CONTRIBUTING.md b/sdk/CONTRIBUTING.md
new file mode 100644
index 0000000..710584e
--- /dev/null
+++ b/sdk/CONTRIBUTING.md
@@ -0,0 +1,196 @@
+# Contributing to the Cline SDK
+
+This document covers onboarding, development workflow, and publishing. For package boundaries and change routing during development, see [AGENTS.md](./AGENTS.md). For architecture and runtime flows, see [ARCHITECTURE.md](./ARCHITECTURE.md).
+
+This repo is a WIP framework for building and orchestrating AI agents. Full refactors are acceptable when they improve the architecture and all call sites are updated.
+
+## Workspace Overview
+
+### Published SDK Packages
+
+| Package | Owns |
+|---------|------|
+| `@cline/shared` | Contracts, schemas, path helpers, hook engine, extension registry |
+| `@cline/llms` | Provider settings, model catalogs, manifests, handler creation |
+| `@cline/agents` | Stateless agent loop, tool orchestration, hook/extension runtime |
+| `@cline/core` | Stateful orchestration, session lifecycle, storage, config, telemetry, hub runtime services, hub discovery, detached daemon, and hub client adapters (`@cline/core/hub`, `@cline/core/hub/daemon-entry`) |
+
+### Apps
+
+- `apps/cli`: CLI host and local hub management
+- `apps/examples/desktop-app`: Tauri + Next.js desktop app example
+- `apps/examples/vscode`: VS Code extension example
+- `apps/examples/menubar`: hub notification menubar example
+- `examples`: plugin, hook, and cron automation examples (customizations upon Cline SDK)
+
+## Development Workflow
+
+### Essential Commands
+
+| Command | Purpose |
+|---------|---------|
+| `bun install` | Install dependencies |
+| `bun run build` | Build SDK and CLI |
+| `bun run build:sdk` | Build SDK packages only |
+| `bun run dev` | Build in development mode |
+| `bun run cli` | Run CLI interactively |
+| `bun run test` | Run the Vitest suite |
+| `bun run types` | Typecheck all packages |
+| `bun run lint` / `format` / `fix` | Code quality and formatting |
+
+Package-scoped commands:
+
+```sh
+bun -F @cline/core build|test|typecheck
+bun -F @cline/agents build|test|typecheck
+```
+
+### Rebuilding
+
+Changes to published SDK packages require `bun run build:sdk`. Direct CLI runs pick up rebuilt packages immediately. Use `dev:*` scripts for automatic rebuilding during development.
+
+The CLI build (`bun -F @cline/cli build`) bundles packages from their compiled `dist/`, not their TypeScript source. If you edit a package and then build the CLI without rebuilding the package first, the CLI binary will silently include the old package code. Always run `bun run build:sdk` (or the relevant `bun -F @cline/<pkg> build`) before building the CLI when testing changes end-to-end.
+
+Hub-backed hosts use shared workspace discovery and owned daemon startup logic. If you touch hub bootstrap, preserve the startup lock and owner-scoped discovery behavior so multiple builds can coexist safely.
+
+### Debug Builds
+
+- Set `CLINE_BUILD_ENV=development` for debug builds. Spawned Node/Bun subprocesses get an inspector endpoint plus `--enable-source-maps`.
+- By default, child-process inspector ports are ephemeral (`--inspect=127.0.0.1:0`) to avoid collisions across parallel dev runs.
+- Set `CLINE_DEBUG_HOST` and `CLINE_DEBUG_PORT_BASE` to opt into deterministic role-based ports. With `CLINE_DEBUG_PORT_BASE=9230`, the roles map to hub `9230`, hook worker `9231`, plugin sandbox `9232`, connector child `9233`, fallback sandbox `9234`.
+- Fallback chain: `CLINE_BUILD_ENV` → `NODE_ENV` → Bun `--conditions=development`.
+- To debug the CLI process itself: `cd apps/cli && CLINE_BUILD_ENV=development bun --conditions=development --inspect-brk=6499 ./src/index.ts "hey"`.
+- The workspace includes a VS Code launch config (`Launch CLI Debugger`) that uses `"type": "bun"` (requires `oven.bun-vscode`).
+
+### Testing
+
+Root commands for cross-package confidence:
+
+```sh
+bun run test        # all tests
+bun run types       # typecheck all packages
+bun run check       # lint + build + typecheck + check-publish
+```
+
+If you touch hub/bootstrap/session flows, prefer both unit coverage and an end-to-end sanity check.
+
+## Publishing
+
+### SDK Release
+
+The `bun release sdk` script automates the SDK publish flow: versioning, lockfile regeneration, verification, and publishing.
+
+```sh
+bun release sdk              # auto-increment patch version
+bun release sdk 0.1.0        # explicit version
+bun release sdk --tag next   # publish with a custom npm dist-tag
+bun release sdk --dry-run    # preview without side effects
+```
+
+Additional SDK flags: `--skip-tests`, `--skip-git-tags`.
+
+The script checks out `main` (and pulls latest) before starting. If the working tree is dirty it aborts.
+
+The SDK flow runs: tests → version bump → lockfile regeneration → tarball verification → publish (shared → llms → agents → core) → optional `sdk-v{VERSION}` tag creation.
+
+### CLI Release
+
+The CLI is published through npm. Start releases from `apps/cli` with the `publish-cli` skill. The skill should guide the release prep, then offer the GitHub Actions publish path and the local publish path.
+
+Under the hood, every release starts the same way: prepare one release commit, then choose how to publish it.
+
+Prepare the release commit from the code you want to release:
+
+1. Draft user-facing release notes from the commits since the last `cli-vX.Y.Z` tag.
+2. Choose the release version.
+3. Update `apps/cli/package.json`.
+4. Add the approved notes to `apps/cli/CHANGELOG.md`.
+5. Run the requested checks.
+6. Commit the version and changelog changes.
+
+Then publish that release commit with one of these paths.
+
+Path A: publish from GitHub Actions.
+
+Use this for normal releases. Merge the release commit to `main`, create and push the matching release tag, then run:
+
+```sh
+git tag -a cli-vX.Y.Z -m "CLI vX.Y.Z"
+git push origin refs/tags/cli-vX.Y.Z
+gh workflow run cli-publish.yml -f publish_target=main -f git_tag=cli-vX.Y.Z -f confirm_publish=publish
+```
+
+The workflow checks out the provided `cli-vX.Y.Z` tag, verifies it matches `apps/cli/package.json`, builds the platform packages, publishes to npm with the `latest` dist-tag, creates the GitHub release, and posts to Slack.
+
+Path B: publish locally.
+
+Use this when publishing from an authenticated local machine. Start from a clean checkout at the release commit:
+
+```sh
+gh auth status
+npm whoami
+git tag -a cli-vX.Y.Z -m "CLI vX.Y.Z"
+git push origin refs/tags/cli-vX.Y.Z
+bun release cli
+gh release create cli-vX.Y.Z --verify-tag --title "CLI vX.Y.Z" --notes "Paste the approved release notes here."
+```
+
+The local helper verifies the working tree is clean, verifies `cli-vX.Y.Z` points at `HEAD` locally and on `origin`, runs tests, builds platform packages, and publishes to npm.
+
+Nightly release:
+
+```sh
+gh workflow run cli-publish.yml -f publish_target=nightly
+```
+
+Nightly also runs on a schedule. It publishes `X.Y.Z-nightly.TIMESTAMP` to npm with the `nightly` dist-tag and skips if there were no commits in the last 24 hours unless forced.
+
+### Manual SDK Publish
+
+If you need fine-grained control over individual steps:
+
+1. `bun run test`
+2. `bun version <version>` — updates all workspace package versions, regenerates models, formats, and builds.
+3. `rm bun.lock && bun install --lockfile-only` — regenerate the lockfile so `bun pm pack` resolves `workspace:*` to the new versions.
+4. `bun scripts/check-publish.ts` — pack tarballs, verify dependency alignment, test isolated install and module resolution.
+5. `npm login` — ensure you're authenticated with the npm registry.
+6. Publish in dependency order:
+   ```sh
+   cd packages/shared && bun publish && cd ../llms && bun publish && cd ../agents && bun publish && cd ../core && bun publish && cd ../../
+   ```
+7. For tagged production releases, create and push a git tag: `git tag -a sdk-v{VERSION} -m "SDK v{VERSION}" && git push origin sdk-v{VERSION}`.
+
+### Workspace Dependency Rules
+
+- Source manifests use `workspace:*` so `bun install` and local builds resolve correctly.
+- Published runtime workspace packages stay in `dependencies`. Bundled internals go in `devDependencies` so they don't leak into packed manifests.
+- `bun publish` resolves `workspace:*` to concrete versions when packing.
+
+### Verifying a Single Package
+
+Inspect the exact manifest that will be published:
+
+```sh
+cd ./packages/core
+tmpdir=$(mktemp -d)
+bun pm pack --destination "$tmpdir" >/dev/null
+tar -xOf "$tmpdir"/*.tgz package/package.json | jq '.version, .dependencies'
+```
+
+Check installed versions in a consuming project:
+
+```sh
+bun pm ls @cline/core @cline/agents @cline/llms
+```
+
+### CI
+
+The CI publish workflow (`.github/workflows/sdk-publish.yml`) follows the same order: build → version → check-publish → publish (shared → llms → agents → core). It supports `nightly` and `latest` channels and is triggered by manual dispatch or a daily cron.
+
+### Root Automation Scope
+
+Root scripts are intentionally narrower than the full workspace:
+
+- Root SDK build/test/version/publish flows target the publishable SDK packages only.
+- Internal packages can still be built/tested directly, but should not be swept into release automation by accident.
+- If you add a new internal package, keep it out of root publish/version/build sweeps unless you explicitly intend to publish it.
diff --git a/sdk/README.md b/sdk/README.md
new file mode 100644
index 0000000..d486c8f
--- /dev/null
+++ b/sdk/README.md
@@ -0,0 +1,273 @@
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/a05da977-2cb7-498a-88ca-20f24c9562e1" width="100%" />
+</p>
+
+<div align="center">
+<table>
+<tbody>
+<td align="center">
+<a href="https://discord.gg/cline" target="_blank"><strong>Discord</strong></a>
+</td>
+<td align="center">
+<a href="https://www.reddit.com/r/cline/" target="_blank"><strong>r/cline</strong></a>
+</td>
+<td align="center">
+<a href="https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop" target="_blank"><strong>Feature Requests</strong></a>
+</td>
+</tbody>
+</table>
+</div>
+
+The Cline SDK is a TypeScript framework for building AI agents that can edit files, run shell commands, browse the web, call APIs, and use any custom tool you give them. It's the same engine that powers [Cline](https://github.com/cline/cline), packaged as a library you can embed in your own applications.
+
+```typescript
+import { Agent } from "@cline/sdk"
+
+const agent = new Agent({
+  providerId: "cline",
+  modelId: "openai/gpt-5.5",
+  systemPrompt: "You are a helpful coding assistant.",
+  tools: [],
+})
+
+const result = await agent.run("Create a REST API with Express and TypeScript")
+console.log(result.text)
+```
+
+That's it. The agent streams its response, calls tools if you give it any, and returns when the task is done.
+
+## Install
+
+```bash
+npm install @cline/sdk
+```
+
+## SDK Skill
+
+If you use a coding agent (Claude Code, Codex, Cline, etc.), install the [Cline SDK skill](https://github.com/cline/sdk-skill) to give your agent context on the SDK's APIs and best practices to help you build with the Cline SDK.
+
+```bash
+npx skills add cline/sdk-skill
+```
+
+Prompt it to scaffold agents, create custom tools, wire up plugins, configure providers, and more.
+
+## What You Can Build
+
+Coding agents, Slack bots, scheduled automations, code review pipelines, multi-agent teams, IDE integrations -- anything that benefits from an LLM that can take actions, not just generate text.
+
+```typescript
+// Slack bot: each thread gets its own agent with conversation memory
+const agents = new Map<string, Agent>()
+
+async function handleMessage(threadId: string, message: string) {
+  let agent = agents.get(threadId)
+  if (!agent) {
+    agent = new Agent({
+      providerId: "gemini",
+      modelId: "gemini-3.1-pro-preview",
+      systemPrompt: "You are a concise Slack assistant.",
+      tools: [],
+    })
+    agents.set(threadId, agent)
+  }
+
+  const result = agent.hasRun
+    ? await agent.continue(message)
+    : await agent.run(message)
+
+  return result.text
+}
+```
+
+Explore full working examples in [`examples/`](examples) and app examples in [`apps/examples/`](apps/examples):
+
+| Example | Description |
+|---------|-------------|
+| [Plugins](examples/plugins) | Custom tools with workspace-aware context, lifecycle hooks, and branch-level safety policies |
+| [Subagent Orchestration](examples/plugins/agents-squad) | Spawn and manage background agents with presets, skills, and cross-agent handoffs |
+| [Hooks](examples/hooks) | File-based and runtime hooks for logging, review gates, context injection, and lifecycle automation |
+| [Cron Automations](examples/cron) | Recurring and event-driven automation specs for scheduled quality checks and PR workflows |
+| [Desktop App](apps/examples/desktop-app) | Tauri desktop shell with a Bun sidecar backend and Next.js UI |
+| [VS Code Extension App](apps/examples/vscode) | VS Code extension example that runs Cline sessions over the RPC runtime |
+
+## Custom Tools
+
+Tools are how agents interact with the world. Define a tool with a name, a description the model reads, a JSON Schema for inputs, and a function that does the work:
+
+```typescript
+import { createTool } from "@cline/sdk"
+
+const deploy = createTool({
+  name: "deploy",
+  description: "Deploy the app to staging or production.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      environment: { type: "string", enum: ["staging", "production"] },
+    },
+    required: ["environment"],
+  },
+  execute: async (input) => {
+    const result = await runDeployment(input.environment)
+    return { url: result.url, status: "success" }
+  },
+})
+
+const agent = new Agent({
+  providerId: "moonshot",
+  modelId: "kimi-k2.5",
+  systemPrompt: "You are a deployment assistant.",
+  tools: [deploy],
+})
+```
+
+The agent decides when to call the tool based on the description. It sees the result and incorporates it into its response.
+
+## Streaming Events
+
+Every event during execution is observable in real time:
+
+```typescript
+const agent = new Agent({
+  providerId: "anthropic",
+  modelId: "claude-opus-4-7",
+  systemPrompt: "You are a helpful assistant.",
+  tools: [myTool],
+  onEvent: (event) => {
+    switch (event.type) {
+      case "content_update":
+        if (event.contentType === "text") process.stdout.write(event.text)
+        break
+      case "content_start":
+        if (event.contentType === "tool") console.log(`\n[${event.toolName}]`)
+        break
+      case "usage":
+        console.log(`\ntokens: ${event.inputTokens} in, ${event.outputTokens} out`)
+        break
+    }
+  },
+})
+```
+
+## Plugins
+
+Package reusable capabilities as extensions. An extension can register tools, observe lifecycle events, and modify agent behavior:
+
+```typescript
+const metrics: AgentPlugin = {
+  name: "metrics",
+  manifest: { capabilities: ["tools", "hooks"] },
+
+  setup(api) {
+    api.registerTool(myCustomTool)
+  },
+
+  hooks: {
+    beforeRun() {
+      console.time("agent")
+    },
+
+    beforeTool({ toolCall }) {
+      console.log(`tool: ${toolCall.toolName}`)
+    },
+
+    afterRun({ result }) {
+      console.timeEnd("agent")
+      console.log(`${result.iterations} iterations, ${result.usage.outputTokens} tokens`)
+    },
+  },
+}
+```
+
+## ClineCore: Full Runtime
+
+When you need session persistence, built-in tools, config discovery, and multi-process support, use `ClineCore`:
+
+```typescript
+import { ClineCore } from "@cline/sdk"
+
+const cline = await ClineCore.create({ clientName: "my-app" })
+
+const session = await cline.start({
+  prompt: "Set up CI with GitHub Actions",
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY,
+    cwd: "/path/to/project",
+    enableTools: true,
+  },
+})
+
+console.log(session.result?.text)
+```
+
+`ClineCore` gives the agent built-in tools (`bash`, `editor`, `read_files`, `apply_patch`, `search`, `fetch_web`), persists sessions to SQLite, discovers config from `.cline/` directories, and optionally connects to an RPC sidecar for scheduled agents and cross-process session management.
+
+## Packages
+
+The SDK is a layered stack. Use as much or as little as you need:
+
+| Package | What it does |
+|---------|-------------|
+| `@cline/sdk` | Everything you need -- install this one |
+| `@cline/core` | Sessions, persistence, built-in tools, config discovery, RPC |
+| `@cline/agents` | Stateless agent loop with tool execution and streaming |
+| `@cline/llms` | LLM provider gateway (Anthropic, OpenAI, Google, Bedrock, Mistral, and more) |
+| `@cline/shared` | Types, tool creation helpers, hook engine |
+
+`@cline/sdk` is an alias for `@cline/core` that re-exports from all packages, so a single install gives you the full API. The individual packages are available if you want a minimal dependency footprint.
+
+## CLI
+
+The Cline CLI gives you terminal access to the full SDK:
+
+```bash
+# Interactive agent
+cline
+
+# Single prompt
+cline "Refactor the auth module to use JWT"
+
+# Schedule an agent to run daily
+cline schedule create "PR summary" --cron "0 9 * * MON-FRI" --prompt "Summarize open PRs"
+
+# Connect a Telegram bot created with @BotFather
+cline connect telegram -k "$TELEGRAM_BOT_TOKEN"
+# Then send /help or /start to the bot in Telegram
+```
+
+For Telegram-specific connector behavior, see [`apps/cli/src/connectors/adapters/telegram.md`](./apps/cli/src/connectors/adapters/telegram.md).
+
+## Providers
+
+Works with every major LLM provider out of the box:
+
+| Provider | Models |
+|----------|--------|
+| Anthropic | Claude Opus 4.7, Sonnet 4.6, Haiku 4.5 |
+| OpenAI | GPT-5.5, GPT-5.3 Codex |
+| Google | Gemini 3.1 Pro Preview, Gemini 3 Flash Preview |
+| AWS Bedrock | Claude, Llama |
+| Mistral | Mistral Large, Codestral |
+| Any OpenAI-compatible | vLLM, Together, Fireworks, Groq, etc. |
+
+## Documentation
+
+Full documentation at [docs.cline.bot/sdk](https://docs.cline.bot/sdk/overview):
+
+- [Quickstart](https://docs.cline.bot/sdk/quickstart) -- zero to running agent in 5 minutes
+- [Core Concepts](https://docs.cline.bot/sdk/agents) -- agents, sessions, tools, events, extensions, hooks
+- [Guides](https://docs.cline.bot/sdk/guides/building-an-agent) -- end-to-end tutorials for common patterns
+- [Architecture](https://docs.cline.bot/sdk/architecture/overview) -- how the SDK is structured and why
+- [API Reference](https://docs.cline.bot/sdk/reference/cline-core) -- every method, type, and config option
+
+
+## Contributing
+
+To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.md) to learn the basics. You can also join our [Discord](https://discord.gg/cline) to chat with other contributors in the `#contributors` channel. If you're looking for full-time work, check out our open positions on our [careers page](https://cline.bot/join-us)!
+
+## License
+
+[Apache 2.0 © 2026 Cline Bot Inc.](./LICENSE)
diff --git a/sdk/biome.json b/sdk/biome.json
new file mode 100644
index 0000000..55f5cb2
--- /dev/null
+++ b/sdk/biome.json
@@ -0,0 +1,140 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.5/schema.json",
+	"root": false,
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"ignoreUnknown": true
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"suspicious": {
+				"noConfusingVoidType": "info",
+				"noExplicitAny": "info",
+				"noAssignInExpressions": "info",
+				"noArrayIndexKey": "info",
+				"noUnknownAtRules": {
+					"level": "info",
+					"options": {
+						"ignore": [
+							"tailwind",
+							"layer",
+							"apply",
+							"responsive",
+							"screen",
+							"variants"
+						]
+					}
+				}
+			},
+			"style": {
+				"noNonNullAssertion": "info",
+				"noRestrictedImports": {
+					"level": "error",
+					"options": {
+						"patterns": [
+							{
+								"group": [
+									"@cline/llms/*",
+									"@cline/agents/*",
+									"@cline/core/*",
+									"@cline/shared/*",
+									"**/llms/src/**",
+									"**/agents/src/**",
+									"**/core/src/**",
+									"**/shared/src/**",
+									"**/rpc/src/**",
+									"**/scheduler/src/**",
+									"!@cline/llms/node",
+									"!@cline/llms/browser",
+									"!@cline/llms/runtime",
+									"!@cline/llms/runtime/*",
+									"!@cline/llms/models",
+									"!@cline/llms/models/*",
+									"!@cline/llms/providers",
+									"!@cline/llms/providers/*",
+									"!@cline/agents/node",
+									"!@cline/agents/browser",
+									"!@cline/core/hub",
+									"!@cline/core/telemetry",
+									"!@cline/core/rpc",
+									"!@cline/shared/browser",
+									"!@cline/shared/types",
+									"!@cline/shared/storage",
+									"!@cline/shared/db"
+								],
+								"message": "Use package entrypoints for cross-package imports. Do not import from another package's internal files."
+							}
+						]
+					}
+				}
+			}
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"css": {
+		"parser": {
+			"tailwindDirectives": true
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	},
+	"json": {
+		"formatter": {
+			"enabled": true
+		}
+	},
+	"overrides": [
+		{
+			"includes": ["docs/**"],
+			"linter": {
+				"rules": {
+					"a11y": {
+						"noStaticElementInteractions": "off",
+						"useKeyWithClickEvents": "off",
+						"noSvgWithoutTitle": "off",
+						"useFocusableInteractive": "off",
+						"useSemanticElements": "off",
+						"useAriaPropsForRole": "off"
+					},
+					"security": {
+						"noDangerouslySetInnerHtml": "off"
+					},
+					"suspicious": {
+						"noDocumentCookie": "off"
+					}
+				}
+			}
+		},
+		{
+			"includes": ["../apps/cli/src/tui/**"],
+			"linter": {
+				"rules": {
+					"a11y": {
+						"noStaticElementInteractions": "off",
+						"useKeyWithClickEvents": "off"
+					}
+				}
+			}
+		}
+	]
+}
diff --git a/sdk/examples/README.md b/sdk/examples/README.md
new file mode 100644
index 0000000..b0bf9d8
--- /dev/null
+++ b/sdk/examples/README.md
@@ -0,0 +1,196 @@
+# Cline SDK Examples
+
+Learn how to build with the Cline SDK through practical, runnable examples.
+
+## 📁 Plugin, Hook, and Automation Examples
+
+Plugins extend the CLI and SDK with custom capabilities. Install local files, GitHub file URLs, package directories, git repos, and npm packages with `cline plugin install`:
+
+### [`./plugins/`](./plugins/)
+
+**Plugin module examples** showing how to extend the CLI and SDK with custom capabilities:
+
+- Register custom tools
+- Hook into agent lifecycle events
+- Export a reusable plugin module for `.cline/plugins`
+
+Examples include:
+- `weather-metrics.ts` - Weather query tool
+- `mac-notify.ts` - macOS Notification Center alerts
+- `custom-compaction.ts` - Custom context compaction
+- `automation-events.ts` - Plugin event emission
+- `background-terminal.ts` - Background shell jobs with setup and job logging
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts
+cline -i "What's the weather like in Tokyo and Paris?"
+```
+
+Plugin setup receives a host logger through the second `setup` argument. Use
+`ctx.logger` for setup-time diagnostics and logs emitted during tool calls:
+
+```ts
+setup(api, ctx) {
+  ctx.logger?.log("my-plugin setup", {
+    sessionId: ctx.session?.sessionId,
+    workspaceRoot: ctx.workspaceInfo?.rootPath,
+  });
+
+  try {
+    // Register tools or perform plugin setup work.
+  } catch (error) {
+    if (ctx.logger?.error) {
+      ctx.logger.error("my-plugin setup failed", { error });
+    } else {
+      ctx.logger?.log("my-plugin setup failed", { error, severity: "error" });
+    }
+    throw error;
+  }
+}
+```
+
+`ctx.logger` is session-scoped. For detached work that can outlive the session,
+such as background processes, persist status to plugin-owned storage or report
+completion through the host event channel instead of calling the captured logger
+from long-lived callbacks.
+
+### [`./plugins/typescript-lsp/`](./plugins/typescript-lsp)
+
+TypeScript LSP plugin that gives the agent a `goto_definition` tool powered by the TypeScript Language Service API. Resolves through imports, re-exports, and type aliases -- much more precise than text search.
+
+- Register a tool via `createTool()` and `AgentExtension`
+- Use the TypeScript Language Service to resolve symbol definitions
+- Cache the language service for efficient repeated lookups
+- Zero extra dependencies -- resolves `typescript` from the target project
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/typescript-lsp/index.ts
+cline -i "Find where createTool is defined"
+```
+
+### [`./plugins/agents-squad/`](./plugins/agents-squad)
+
+**Portable subagent plugin** that adds background agent orchestration tools to the CLI and SDK:
+
+- Export a reusable plugin module for `.cline/plugins`
+- Start background subagents from the main session
+- Load bundled or custom agent presets and skills
+- Log setup, subagent starts, and follow-ups through `ctx.logger`
+
+Includes pre-configured agents:
+- **Anvil** - Build and compile
+- **Inquisitor** - Investigation and discovery
+- **Oracle** - Planning and architecture
+- **Phantom** - Stealth and optimization
+
+Skills available:
+- API design, code review, debugging, documentation, migration, refactoring, test generation
+
+```bash
+cline plugin install ./examples/plugins/agents-squad
+cline -i "Use subagents to inspect this repository and report back."
+```
+
+Once loaded, the agent can call tools like `start_subagent`, `message_subagent`, `get_subagent`, `list_agent_presets`, `list_skills`, and the handoff tools.
+
+## 📁 Cron & hooks Examples
+
+### [`./cron/`](./cron)
+
+**Example file-based and event-driven automation specs** for global `~/.cline/cron/`:
+
+Recurring jobs for continuous quality:
+- **changelog-generator** — Auto-generate CHANGELOG from commits
+- **dependency-check** — Weekly security and update audits
+- **test-coverage-report** — Daily coverage metrics
+- **performance-baseline** — Build time and bundle size tracking
+- **type-check-strict** — TypeScript type safety audits
+- **code-style-audit** — Linting and formatting checks
+- **dead-code-finder** — Identify unused code
+- **documentation-check** — API documentation coverage
+- **weekly-metrics-summary** — Fun team metrics report 🎉
+
+Event-driven jobs for PR workflows:
+- **pr-changelog-check** — Verify CHANGELOG is updated in PRs
+- **pr-test-coverage** — Analyze coverage impact of changes
+
+```bash
+mkdir -p ~/.cline/cron
+cp examples/cron/changelog-generator.cron.md ~/.cline/cron/
+mkdir -p ~/.cline/cron/events
+cp examples/cron/events/pr-changelog-check.event.md ~/.cline/cron/events/
+```
+
+See [cron/README.md](./cron/README.md) for full descriptions and usage patterns.
+
+### [`./hooks/`](./hooks)
+
+**Lifecycle hooks** written in bash, Python, or TypeScript that intercept agent actions at key points:
+
+- Log all tool calls (PreToolUse) and results (PostToolUse)
+- Block destructive operations
+- Require review for critical files
+- Inject contextual information
+- Track lifecycle events (TaskStart, TaskComplete, SessionShutdown)
+
+Hooks live in `.cline/hooks/` and are named after the event they handle (PreToolUse, PostToolUse, TaskStart, etc.):
+
+```bash
+mkdir -p ~/.cline/hooks
+
+# Bash hook
+cp examples/hooks/PreToolUse.sh ~/.cline/hooks/
+chmod +x ~/.cline/hooks/PreToolUse.sh
+
+# Or Python
+cp examples/hooks/PreToolUse.py ~/.cline/hooks/PreToolUse.py
+chmod +x ~/.cline/hooks/PreToolUse.py
+
+# Or TypeScript (runs via bun)
+cp examples/hooks/PreToolUse.ts ~/.cline/hooks/PreToolUse.ts
+chmod +x ~/.cline/hooks/PreToolUse.ts
+
+cline -i "do something"  # Hooks will execute automatically
+```
+
+## 🚀 Quick Start
+
+To use the SDK in your own Node app (outside this monorepo), start with:
+
+```bash
+npm add @cline/core
+```
+
+Add `@cline/agents` or `@cline/llms` only if you intentionally want lower-level control. For RPC client helpers, prefer importing from `@cline/core` when you want the app-facing SDK surface.
+
+Current SDK layering:
+
+- `@cline/core` owns config discovery/watchers, runtime plugin loading, and the context pipeline
+- context compaction is core-owned and runs through turn preparation before model calls
+- most app integrations should stay on the `@cline/core` surface unless they intentionally need lower-level agent or model control
+
+## 📚 Learning Path
+
+**Building plugins?**
+- Start with [`./plugins/`](./plugins/) for basic tool and event patterns
+- Explore [`./plugins/typescript-lsp/`](./plugins/typescript-lsp) for integration with language services
+- See [`./plugins/agents-squad/`](./plugins/agents-squad) for advanced agent orchestration
+
+**Building integrations?**
+- Review [`./cron/`](./cron) for automation and event-driven workflows
+- Explore [`desktop-app/`](../../apps/examples/desktop-app), [`vscode/`](../../apps/examples/vscode), and [`menubar/`](../../apps/examples/menubar) for app integration patterns
+
+**Controlling agent behavior?**
+- Explore [`./hooks/`](./hooks) to intercept and modify tool execution, log actions, or enforce policies
+
+## 📖 Documentation
+
+- [Cline SDK README](../packages/README.md)
+- [Architecture Guide](../ARCHITECTURE.md)
+- [Individual Package Docs](../packages/)
+
+## 🛠️ Requirements
+
+- **Node.js 22+** - For package compatibility
+- **API Key** - Set `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, or provider-specific key (for SDK examples)
+- **Bun** - Optional, install from [bun.sh](https://bun.sh) for running examples
diff --git a/sdk/examples/cron/README.md b/sdk/examples/cron/README.md
new file mode 100644
index 0000000..5f8bb4a
--- /dev/null
+++ b/sdk/examples/cron/README.md
@@ -0,0 +1,419 @@
+# Cline Automation Examples
+
+This directory contains example automation specs for file-based and event-driven automation in Cline. Use these as templates to set up your own recurring or event-driven tasks.
+
+## 🚀 Quick Start: Pick Your Automation
+
+| Goal | Spec | Schedule | Mode |
+|------|------|----------|------|
+| 🔄 Review code | `daily-code-review` | Mon-Fri 9 AM | act |
+| 📝 Update CHANGELOG | `changelog-generator` | Friday 6 PM | act |
+| 🔒 Check security | `dependency-check` | Monday 10 AM | act |
+| ✅ Verify tests | `test-coverage-report` | Daily 10 PM | act |
+| ⚡ Track performance | `performance-baseline` | Daily 2 AM | act |
+| 🏷️ Check types | `type-check-strict` | Daily 6 AM | plan |
+| 🎨 Audit style | `code-style-audit` | Wednesday 3 AM | act |
+| 🗑️ Find dead code | `dead-code-finder` | Sunday 4 AM | plan |
+| 📚 Check docs | `documentation-check` | Thursday 5 AM | plan |
+| 🎉 Weekly wins | `weekly-metrics-summary` | Friday 5 PM | act |
+| 👀 Review PRs | `pr-review` | On PR opened | act |
+| 📋 Check PR changelog | `pr-changelog-check` | On PR opened | act |
+| 📊 PR coverage | `pr-test-coverage` | On PR updated | act |
+
+## 📋 Overview
+
+Cline automation supports two types of specs:
+
+1. **Recurring specs** (`.cron.md`) — Run on a schedule
+2. **Event-driven specs** (`.event.md`) — Run when an event occurs
+
+Both can be enabled in `.cline/cron/` to be picked up by the hub or SDK.
+
+## 🔄 Recurring Specs
+
+### [`daily-code-review.cron.md`](./daily-code-review.cron.md)
+
+A production-ready example that runs a code review automation on weekday mornings.
+
+**Key fields:**
+- `schedule: "0 9 * * MON-FRI"` — 9 AM on weekdays (cron format)
+- `tools: run_commands,read_files` — Restrict tools to specific actions
+- `mode: act` — Execute commands (vs. `plan` or `yolo`)
+- `timeoutSeconds: 1800` — 30-minute timeout
+- `modelSelection` — Override model/provider for this run
+- `notesDirectory` — Durable automation notes for multi-run state
+
+**Usage:**
+```bash
+mkdir -p ~/.cline/cron
+cp examples/cron/daily-code-review.cron.md ~/.cline/cron/
+# Edit the spec: set workspaceRoot, model, etc.
+# Spec is reconciled on startup; next run enqueued automatically
+```
+
+**One-off specs:**
+For one-time tasks, save as `.cline/cron/<name>.md` (no `.cron` infix) and omit the `schedule` field.
+
+### Additional Recurring Spec Examples
+
+#### [`changelog-generator.cron.md`](./changelog-generator.cron.md)
+
+**Auto-generate changelog from recent commits**
+
+Runs every Friday at 6 PM. Reviews commits in a directory (e.g., `apps/cli/`) and generates a changelog entry summarizing new features, bug fixes, and breaking changes. Updates `CHANGELOG.md` without bumping the version.
+
+**Best for:** Projects with frequent releases and manual changelog maintenance overhead.
+
+#### [`dependency-check.cron.md`](./dependency-check.cron.md)
+
+**Weekly dependency health check**
+
+Runs every Monday at 10 AM. Checks for outdated packages, security vulnerabilities, unused dependencies, and major version upgrades. Generates a prioritized report for action.
+
+**Best for:** Teams that want proactive dependency maintenance without daily alerts.
+
+#### [`test-coverage-report.cron.md`](./test-coverage-report.cron.md)
+
+**Daily test coverage metrics**
+
+Runs every day at 10 PM. Runs the full test suite, generates coverage reports, and identifies files needing more tests. Creates a markdown summary with visual indicators.
+
+**Best for:** Maintaining code quality standards and tracking coverage trends over time.
+
+#### [`performance-baseline.cron.md`](./performance-baseline.cron.md)
+
+**Track performance metrics overnight**
+
+Runs daily at 2 AM. Measures build time, bundle size, and cold start performance. Detects regressions and alerts if metrics exceed thresholds.
+
+**Best for:** CLI tools, libraries, or services where performance is critical.
+
+#### [`type-check-strict.cron.md`](./type-check-strict.cron.md)
+
+**Strict TypeScript type checking**
+
+Runs every morning at 6 AM in `plan` mode. Reports all type errors with strict compiler options and categorizes them by issue type.
+
+**Best for:** Gradually improving type safety without blocking development.
+
+#### [`code-style-audit.cron.md`](./code-style-audit.cron.md)
+
+**Code style and linting audit**
+
+Runs every Wednesday at 3 AM. Runs ESLint and Prettier, identifies unused code, detects anti-patterns, and provides a summary of violations.
+
+**Best for:** Maintaining code consistency across a team.
+
+#### [`dead-code-finder.cron.md`](./dead-code-finder.cron.md)
+
+**Find and report dead code**
+
+Runs every Sunday at 4 AM in `plan` mode. Identifies unused exports, unreachable code, and deprecated patterns. Prioritizes safe removals vs. ones requiring review.
+
+**Best for:** Regular codebase cleanup and reducing technical debt.
+
+#### [`documentation-check.cron.md`](./documentation-check.cron.md)
+
+**Documentation coverage audit**
+
+Runs every Thursday at 5 AM in `plan` mode. Analyzes documentation completeness, identifies missing JSDoc comments, checks for outdated docs, and evaluates overall documentation structure.
+
+**Best for:** Improving code maintainability and onboarding of new team members.
+
+#### [`weekly-metrics-summary.cron.md`](./weekly-metrics-summary.cron.md)
+
+**Fun weekly metrics summary for the team** 🎉
+
+Runs every Friday at 5 PM. Collects a week's worth of data: commits, test coverage, performance, PR activity, and contributor stats. Generates a celebratory markdown report with emojis, top contributors, metrics trends, and fun facts.
+
+**Best for:** Team morale, tracking velocity, and celebrating wins. Great for Friday morning stand-ups or team channels.
+
+## 🎯 Event-Driven Specs
+
+Event-driven specs live in `.cline/cron/events/` and trigger when normalized events are ingested.
+
+### [`events/pr-review.event.md`](./events/pr-review.event.md)
+
+Runs a pull request review whenever a new PR opens on the `main` branch.
+
+**Key fields:**
+- `event: github.pull_request.opened` — Trigger on this event type
+- `filters` — Narrow scope: match repository, branch, labels, etc.
+- `debounceSeconds: 30` — Wait 30s for more events before triggering
+- `dedupeWindowSeconds: 600` — Ignore duplicate events within 10 minutes
+- `cooldownSeconds: 120` — Wait 2 minutes after a run before next trigger
+- `maxParallel: 2` — Run at most 2 in parallel
+
+**Usage:**
+```bash
+mkdir -p ~/.cline/cron/events
+cp examples/cron/events/pr-review.event.md ~/.cline/cron/events/
+# Configure your repository, branch, and workspace
+# Wire up GitHub App or webhook to ingest events
+```
+
+**Ingesting events:**
+Events are ingested via:
+- GitHub App or webhook receiver
+- Plugin-emitted events (see `plugins/automation-events.ts`)
+- Connector adapters
+- `cline.automation.ingestEvent()` in the SDK
+
+### [`events/local-manual-test.event.md`](./events/local-manual-test.event.md)
+
+Local test spec for verifying event-driven automation without external services.
+
+**Key fields:**
+- `event: local.manual_test` — Local event type (no external dependency)
+- `filters: { topic: cron-feature-2 }` — Match on event payload fields
+- `debounceSeconds: 0` — Trigger immediately
+- `maxIterations: 5` — Quick timeout for testing
+
+**Usage:**
+```bash
+mkdir -p ~/.cline/cron/events
+cp examples/cron/events/local-manual-test.event.md ~/.cline/cron/events/
+
+# Start the hub with automation enabled
+# In another shell, ingest a test event
+node -e "
+  const { HubWebSocketClient } = require('@cline/core');
+  const client = new HubWebSocketClient('ws://localhost:8000');
+  client.send('cron.event.ingest', {
+    eventType: 'local.manual_test',
+    envelope: { subject: 'test', topic: 'cron-feature-2', message: 'hello' }
+  });
+"
+```
+
+### [`events/local-plugin-event.event.md`](./events/local-plugin-event.event.md)
+
+Test spec for plugin-emitted events. Pairs with `plugins/automation-events.ts`.
+
+### Additional Event-Driven Examples
+
+#### [`events/pr-changelog-check.event.md`](./events/pr-changelog-check.event.md)
+
+**Verify CHANGELOG updates in PRs**
+
+Triggers when a PR opens on `main`. If the PR modifies source code but doesn't update CHANGELOG, posts a comment suggesting what should be added. If CHANGELOG is updated, verifies the format.
+
+**Best for:** Maintaining an up-to-date changelog without manual reminders. Reduces reviewer burden.
+
+#### [`events/pr-test-coverage.event.md`](./events/pr-test-coverage.event.md)
+
+**Analyze test coverage impact of PRs**
+
+Triggers when a PR is opened or updated. Runs test coverage against the PR branch, compares to main, and posts a comment showing:
+- Which new code is covered vs. uncovered
+- Coverage impact percentage
+- Files with decreased coverage
+- Recommendations for additional tests
+
+**Best for:** Maintaining test coverage standards while being helpful rather than blocking. Guides authors toward better test practices.
+
+**Key fields:**
+- `event: local.plugin_event` — Custom event emitted by the plugin
+- `filters: { topic: plugin-demo }` — Match on plugin event attributes
+- Minimal throttling for responsive testing
+
+**Usage:**
+```bash
+mkdir -p ~/.cline/cron/events
+cp examples/cron/events/local-plugin-event.event.md ~/.cline/cron/events/
+
+# Load the plugin that emits these events
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/automation-events.ts
+
+# Run CLI with automation enabled; the plugin emits events
+cline --enable-automation -i "Test automation events"
+```
+
+## 🚀 Getting Started
+
+### 1. Set up the spec directory
+
+```bash
+mkdir -p ~/.cline/cron/events
+```
+
+### 2. Copy a template
+
+- **For scheduled tasks:** Copy `daily-code-review.cron.md`
+- **For GitHub events:** Copy `pr-review.event.md`
+- **For local testing:** Copy `local-manual-test.event.md`
+- **For plugin events:** Copy `local-plugin-event.event.md`
+
+### 3. Customize the spec
+
+Edit your copied spec:
+- Set `workspaceRoot` to your project path
+- Set `modelSelection` if using a non-default model
+- Update `filters` to match your repos/branches
+- Adjust timeout, iterations, and tool restrictions
+- Refine the prompt (the YAML body)
+
+### 4. Enable automation
+
+**In the hub:**
+```bash
+new HubWebSocketServer({
+  cronOptions: { workspaceRoot: "/absolute/workspace" }
+});
+```
+
+**In the SDK:**
+```ts
+const cline = await ClineCore.create({
+  automation: true,  // Enable automation
+  // ... other options
+});
+```
+
+**In the CLI:**
+```bash
+cline --enable-automation
+```
+
+### 5. Monitor runs
+
+Completed and failed runs are reported to `.cline/cron/reports/<run-id>.md` with:
+- YAML frontmatter (run ID, status, timing, token usage)
+- Summary of work performed
+- Tool calls and results
+- For events: trigger event context
+
+## 📖 Field Reference
+
+### Common fields
+
+| Field | Type | Required | Notes |
+|-------|------|----------|-------|
+| `id` | string | yes | Unique identifier (alphanumeric, hyphens) |
+| `title` | string | yes | Human-readable title |
+| `workspaceRoot` | string | yes | Absolute path to the project |
+| `mode` | string | no | `yolo` (default), `act`, or `plan` |
+| `tools` | string/array | no | Comma-separated tool names; empty disables work tools |
+| `systemPrompt` | string | no | Custom system prompt |
+| `modelSelection` | object | no | `{ providerId, modelId }` |
+| `maxIterations` | number | no | Iteration limit |
+| `timeoutSeconds` | number | no | Run timeout |
+| `extensions` | array | no | `rules`, `skills`, `plugins` |
+| `tags` | array | no | Arbitrary tags for grouping |
+| `metadata` | object | no | Custom metadata |
+
+### Recurring-only fields (`.cron.md`)
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `schedule` | string | **Required**. Cron expression (5 fields: minute, hour, day, month, day-of-week) |
+| `timezone` | string | Optional. IANA timezone (e.g., `America/New_York`). Defaults to system timezone. |
+
+### Event-only fields (`.event.md`)
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `event` | string | **Required**. Event type (e.g., `github.pull_request.opened`, `local.manual_test`) |
+| `filters` | object | Optional. Match event fields (supports dot paths) |
+| `debounceSeconds` | number | Optional. Coalesce events within N seconds (default 0) |
+| `dedupeWindowSeconds` | number | Optional. Skip duplicates within N seconds (default 0) |
+| `cooldownSeconds` | number | Optional. Wait N seconds after a run (default 0) |
+| `maxParallel` | number | Optional. Max concurrent runs (default unbounded) |
+
+## 📚 Tools Reference
+
+Available tool names:
+- `read_files` — Read file contents
+- `search_codebase` — Search across the project
+- `run_commands` — Execute shell commands
+- `fetch_web_content` — Fetch URLs
+- `apply_patch` — Apply code patches
+- `editor` — Edit files
+- `skills` — Call custom skills
+- `ask_question` — Query the user
+- `submit_and_exit` — Complete the run
+
+## 💡 Practical Automation Workflows
+
+### Complete Development Automation Suite
+
+Combine multiple specs for comprehensive automation:
+
+```
+Monday 10 AM    → dependency-check.cron.md       (Check dependencies)
+Tuesday 3 AM    → code-style-audit.cron.md       (Lint and format)
+Wednesday 5 AM  → documentation-check.cron.md    (Doc coverage)
+Thursday 4 AM   → dead-code-finder.cron.md       (Find cleanup opportunities)
+Friday 6 PM     → changelog-generator.cron.md    (Auto-generate changelog)
+Daily 2 AM      → performance-baseline.cron.md   (Track metrics)
+Daily 10 PM     → test-coverage-report.cron.md   (Coverage trends)
+Daily 6 AM      → type-check-strict.cron.md      (Type safety)
+
+On every PR:
+  → pr-changelog-check.event.md     (Verify CHANGELOG)
+  → pr-test-coverage.event.md       (Coverage impact)
+```
+
+This provides continuous quality monitoring without developers having to remember to run checks manually.
+
+### Team Workflows by Role
+
+**For Team Leads:**
+- `dependency-check.cron.md` — Weekly security review
+- `dead-code-finder.cron.md` — Quarterly cleanup planning
+- `performance-baseline.cron.md` — Monitor system health
+
+**For QA Engineers:**
+- `test-coverage-report.cron.md` — Track trends
+- `pr-test-coverage.event.md` — PR-level feedback
+
+**For Backend Teams:**
+- `performance-baseline.cron.md` — Build time, API response time
+- `type-check-strict.cron.md` — Type safety
+
+**For Frontend Teams:**
+- `performance-baseline.cron.md` — Bundle size, cold start
+- `code-style-audit.cron.md` — Consistent styling
+
+## 🔍 Examples in Action
+
+### Schedule a daily security audit
+
+```md
+---
+id: daily-security-audit
+title: Daily Security Audit
+workspaceRoot: /path/to/repo
+schedule: "0 2 * * *"  # 2 AM daily
+tools: read_files,search_codebase
+mode: act
+timeoutSeconds: 3600
+extensions:
+  - skills
+---
+Search for hardcoded secrets, outdated dependencies, and insecure patterns.
+Report findings to the team.
+```
+
+### Review all new PRs on main
+
+```md
+---
+id: pr-security-review
+title: Security Review for PRs
+workspaceRoot: /path/to/repo
+event: github.pull_request.opened
+filters:
+  pullRequest:
+    baseBranch: main
+cooldownSeconds: 300
+maxParallel: 3
+---
+Summarize the changes, check for security risks, and recommend approval or changes.
+```
+
+## 🔗 See Also
+
+- [Architecture automation overview](../../ARCHITECTURE.md#automation) — Runtime architecture and flow details
+- [`plugins/automation-events.ts`](../plugins/automation-events.ts) — Plugin event emission
+- [Cline SDK Examples](../) — Other integration examples
diff --git a/sdk/examples/cron/changelog-generator.cron.md b/sdk/examples/cron/changelog-generator.cron.md
new file mode 100644
index 0000000..8b75b04
--- /dev/null
+++ b/sdk/examples/cron/changelog-generator.cron.md
@@ -0,0 +1,37 @@
+---
+id: changelog-generator
+title: Auto-Generate Changelog from Commits
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 18 * * FRI"
+tools: run_commands,read_files,editor
+mode: act
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 20
+tags:
+  - automation
+  - changelog
+  - documentation
+metadata:
+  owner: development
+  targetFile: apps/cli/CHANGELOG.md
+  trackDirectory: apps/cli
+---
+Review recent commits in the `apps/cli` directory since the last CHANGELOG entry.
+Generate a summary of significant changes (new features, bug fixes, breaking changes).
+Update `apps/cli/CHANGELOG.md` with a new version entry at the top following this format:
+
+## [VERSION] (YYYY-MM-DD)
+
+- Feature: [description]
+- Fix: [description]
+- Breaking: [description]
+
+Do NOT bump the version number in package.json.
+Do NOT override existing entries.
+Focus on user-facing changes, not internal refactors.
+
+Follow the existing changelog style and format from previous entries.
diff --git a/sdk/examples/cron/code-style-audit.cron.md b/sdk/examples/cron/code-style-audit.cron.md
new file mode 100644
index 0000000..e7567ef
--- /dev/null
+++ b/sdk/examples/cron/code-style-audit.cron.md
@@ -0,0 +1,47 @@
+---
+id: code-style-audit
+title: Code Style and Linting Audit
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 3 * * WED"
+tools: run_commands,read_files
+mode: act
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 20
+tags:
+  - automation
+  - quality
+  - style
+metadata:
+  owner: development
+  reportFormat: markdown
+---
+Run comprehensive code style and linting checks:
+
+1. Run ESLint: `npm run lint` or `eslint .`
+2. Run Prettier check: `prettier --check .` or equivalent
+3. Check for common issues:
+   - Unused variables or imports
+   - Dead code
+   - TODO/FIXME comments left in main branch
+   - Console.log statements in production code
+   - Magic numbers without explanation
+
+Generate a report showing:
+- Linting violations by rule (top 10)
+- Files with most violations
+- Formatting inconsistencies
+- Pattern analysis (e.g., common TODO reasons, unused import patterns)
+
+Provide statistics:
+- Total violations found
+- Fixable vs non-fixable violations
+- Trend compared to previous week (if data exists)
+
+Recommendations:
+- Quick wins: violations that can be auto-fixed
+- Standards improvements: patterns to establish
+- Review-needed: complex issues requiring human judgment
diff --git a/sdk/examples/cron/daily-code-review.cron.md b/sdk/examples/cron/daily-code-review.cron.md
new file mode 100644
index 0000000..8de0fbc
--- /dev/null
+++ b/sdk/examples/cron/daily-code-review.cron.md
@@ -0,0 +1,28 @@
+---
+id: daily-code-review
+title: Daily Code Review
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 9 * * MON-FRI"
+tools: run_commands,read_files
+mode: act
+enabled: true
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+systemPrompt: You are a precise automation agent that reports only actionable review findings.
+maxIterations: 20
+tags:
+  - automation
+  - review
+metadata:
+  owner: platform
+notesDirectory: /absolute/path/to/notes
+extensions:
+  - rules
+  - skills
+  - plugins
+source: user
+---
+Review the open pull requests, identify the highest-risk changes, run the
+relevant checks if needed, and write a concise summary of findings.
diff --git a/sdk/examples/cron/dead-code-finder.cron.md b/sdk/examples/cron/dead-code-finder.cron.md
new file mode 100644
index 0000000..6d049c4
--- /dev/null
+++ b/sdk/examples/cron/dead-code-finder.cron.md
@@ -0,0 +1,58 @@
+---
+id: dead-code-finder
+title: Find and Report Dead Code
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 4 * * SUN"
+tools: run_commands,read_files,search_codebase
+mode: plan
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 2400
+maxIterations: 30
+tags:
+  - automation
+  - quality
+  - refactoring
+metadata:
+  owner: development
+  reportType: analysis
+---
+Scan the codebase for dead code and unused exports:
+
+1. Identify unused exports:
+   - Functions not called within the module or by external modules
+   - Classes with no instantiations
+   - Constants/variables not referenced
+   - Type definitions not used
+
+2. Detect unreachable code patterns:
+   - Statements after return/throw
+   - Unreachable branches in conditionals
+   - Dead try-catch blocks
+   - Unused catch parameters
+
+3. Analyze file-level patterns:
+   - Modules that are never imported
+   - Test files without corresponding implementation
+   - Example/demo code in main codebase
+   - Deprecated or marked-for-removal code
+
+Generate a comprehensive report with:
+- Dead code segments (with file locations and line numbers)
+- Confidence level for each finding (high/medium/low)
+- Safe-to-remove vs requires-review items
+- Estimated code reduction if cleanup is done
+
+Safe removals candidates:
+- Variables only assigned, never read
+- Functions declared but never called
+- Exported items with no external references
+
+Requires review:
+- Code that might be called dynamically
+- Public APIs (check if external consumers exist)
+- Backwards-compatibility concerns
+
+Use plan mode to suggest removals without applying them.
diff --git a/sdk/examples/cron/dependency-check.cron.md b/sdk/examples/cron/dependency-check.cron.md
new file mode 100644
index 0000000..88814fa
--- /dev/null
+++ b/sdk/examples/cron/dependency-check.cron.md
@@ -0,0 +1,35 @@
+---
+id: dependency-check
+title: Weekly Dependency Health Check
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 10 * * MON"
+tools: run_commands,read_files
+mode: act
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 15
+tags:
+  - automation
+  - security
+  - dependencies
+metadata:
+  owner: platform
+---
+Run a comprehensive dependency health check:
+
+1. Check for outdated packages: `npm outdated` (or yarn/pnpm equivalent)
+2. Check for security vulnerabilities: `npm audit` 
+3. List packages with available major version upgrades
+4. Identify unused dependencies (if possible)
+5. Check for dependency conflicts or duplicate packages
+
+Provide a summary report covering:
+- Critical security vulnerabilities (if any)
+- Count of outdated packages by severity (minor, patch, major)
+- Recommended immediate actions
+- Packages safe to update to latest versions
+
+Focus on actionable insights. Ignore known false positives and dev-only dependencies.
diff --git a/sdk/examples/cron/documentation-check.cron.md b/sdk/examples/cron/documentation-check.cron.md
new file mode 100644
index 0000000..c10a133
--- /dev/null
+++ b/sdk/examples/cron/documentation-check.cron.md
@@ -0,0 +1,66 @@
+---
+id: documentation-check
+title: Documentation Coverage Audit
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 5 * * THU"
+tools: run_commands,read_files,search_codebase
+mode: plan
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 25
+tags:
+  - automation
+  - documentation
+  - quality
+metadata:
+  owner: documentation
+  checkAreas:
+    - publicAPIs
+    - complexFunctions
+    - typeDefinitions
+    - modules
+---
+Audit documentation coverage across the codebase:
+
+1. Check public API documentation:
+   - Functions exported from public modules
+   - Classes and interfaces
+   - Type definitions and generics
+   - Decorators and annotations
+
+2. Identify missing documentation:
+   - Public functions without JSDoc comments
+   - Complex functions without explanation
+   - Public types without descriptions
+   - Exported modules without README or header comments
+
+3. Evaluate existing documentation quality:
+   - JSDoc comments without @param or @return tags
+   - Comments that are outdated or misleading
+   - Code samples in docs that may be broken
+   - Links in documentation that point to removed code
+
+4. Analyze documentation structure:
+   - Main README quality and completeness
+   - Architecture documentation
+   - Contributing guide existence
+   - API reference documentation
+   - Changelog maintenance
+
+Generate report with sections:
+- Documentation coverage percentage by module
+- Top 10 undocumented public APIs
+- Types with missing descriptions
+- Files with complex logic needing explanation
+- Outdated documentation instances
+
+Recommendations:
+- High-priority items (public APIs without docs)
+- Documentation style improvements
+- Template suggestions for JSDoc
+- Links that need updating
+
+Use plan mode to suggest improvements without applying changes.
diff --git a/sdk/examples/cron/events/local-manual-test.event.md b/sdk/examples/cron/events/local-manual-test.event.md
new file mode 100644
index 0000000..882743b
--- /dev/null
+++ b/sdk/examples/cron/events/local-manual-test.event.md
@@ -0,0 +1,28 @@
+---
+id: local-manual-test
+title: Local Manual Event Test
+workspaceRoot: /absolute/path/to/repo
+cwd: /absolute/path/to/repo
+event: local.manual_test
+filters:
+  topic: cron-feature-2
+debounceSeconds: 0
+dedupeWindowSeconds: 60
+cooldownSeconds: 0
+maxParallel: 1
+mode: act
+enabled: true
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 300
+maxIterations: 5
+tags:
+  - automation
+  - local-test
+metadata:
+  owner: platform
+  source: local-smoke-test
+---
+Use the normalized trigger event context to confirm event-driven automation is
+working locally. Summarize the event id, subject, topic, and payload message.
diff --git a/sdk/examples/cron/events/local-plugin-event.event.md b/sdk/examples/cron/events/local-plugin-event.event.md
new file mode 100644
index 0000000..ec10e41
--- /dev/null
+++ b/sdk/examples/cron/events/local-plugin-event.event.md
@@ -0,0 +1,20 @@
+---
+id: local-plugin-event
+title: Local Plugin Event
+workspaceRoot: /absolute/path/to/repo
+cwd: /absolute/path/to/repo
+event: local.plugin_event
+filters:
+  topic: plugin-demo
+dedupeWindowSeconds: 5
+cooldownSeconds: 5
+maxParallel: 1
+tags:
+  - local
+  - plugin
+  - automation
+metadata:
+  source: examples/plugins/automation-events.ts
+---
+Summarize the local plugin event and report the event subject, topic, and
+message payload.
diff --git a/sdk/examples/cron/events/pr-changelog-check.event.md b/sdk/examples/cron/events/pr-changelog-check.event.md
new file mode 100644
index 0000000..19a3077
--- /dev/null
+++ b/sdk/examples/cron/events/pr-changelog-check.event.md
@@ -0,0 +1,42 @@
+---
+id: pr-changelog-check
+title: Check for Changelog Updates in PRs
+workspaceRoot: /absolute/path/to/repo
+event: github.pull_request.opened
+filters:
+  repository: your-org/your-repo
+  pullRequest:
+    baseBranch: main
+debounceSeconds: 10
+cooldownSeconds: 60
+maxParallel: 3
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+tags:
+  - automation
+  - github
+  - documentation
+metadata:
+  owner: development
+---
+Automatically check if a PR that modifies code also updates the CHANGELOG:
+
+1. Detect if the PR modifies source files (src/, lib/, etc.)
+2. Check if the PR also includes changes to CHANGELOG.md or relevant changelogs
+3. If significant code changes but no changelog update:
+   - Extract a summary of the changes
+   - Suggest what should be added to CHANGELOG
+   - Request the author to add an entry
+
+4. If CHANGELOG is updated:
+   - Verify the format matches the project style
+   - Check that entry is concise and user-facing
+   - Ensure version number is appropriate
+
+Provide feedback as a comment on the PR:
+- ✅ CHANGELOG properly updated
+- ⚠️  No CHANGELOG changes detected - please add an entry
+- 🤔 CHANGELOG entry format seems off - consider [example]
+
+This helps maintain an up-to-date CHANGELOG without manual reminders.
diff --git a/sdk/examples/cron/events/pr-review.event.md b/sdk/examples/cron/events/pr-review.event.md
new file mode 100644
index 0000000..12f9238
--- /dev/null
+++ b/sdk/examples/cron/events/pr-review.event.md
@@ -0,0 +1,32 @@
+---
+id: pr-review
+title: Review New Pull Requests
+workspaceRoot: /absolute/path/to/repo
+cwd: /absolute/path/to/repo
+event: github.pull_request.opened
+filters:
+  repository: acme/api
+  pullRequest:
+    baseBranch: main
+debounceSeconds: 30
+dedupeWindowSeconds: 600
+cooldownSeconds: 120
+maxParallel: 2
+mode: act
+enabled: true
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 20
+tags:
+  - automation
+  - github
+  - review
+metadata:
+  owner: platform
+  source: normalized-event-ingress
+---
+Review the opened pull request from the trigger event context. Summarize the
+highest-risk changes, call out missing tests or migration risks, and recommend
+the next action for the author.
diff --git a/sdk/examples/cron/events/pr-test-coverage.event.md b/sdk/examples/cron/events/pr-test-coverage.event.md
new file mode 100644
index 0000000..2505663
--- /dev/null
+++ b/sdk/examples/cron/events/pr-test-coverage.event.md
@@ -0,0 +1,55 @@
+---
+id: pr-test-coverage
+title: Analyze Test Coverage Impact of PR
+workspaceRoot: /absolute/path/to/repo
+event: github.pull_request.synchronize
+filters:
+  repository: your-org/your-repo
+  pullRequest:
+    baseBranch: main
+debounceSeconds: 30
+cooldownSeconds: 120
+maxParallel: 2
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+tags:
+  - automation
+  - github
+  - testing
+metadata:
+  owner: qa
+  checkMetrics:
+    - lineCoverage
+    - branchCoverage
+    - newFilesCoverage
+---
+Analyze test coverage impact when a PR is updated:
+
+1. Checkout the PR branch
+2. Run test coverage: `npm run test:coverage`
+3. Compare coverage to main branch:
+   - Lines added with coverage
+   - Lines added without coverage
+   - Files with decreased coverage
+   - New files with low coverage
+
+4. Generate a coverage impact report showing:
+   - Coverage change percentage
+   - Files with added uncovered code
+   - Critical gaps in new functionality
+   - Suggestions for missing tests
+
+5. Post results as PR comment with:
+   - Overall coverage impact (↑ or ↓)
+   - File-by-file breakdown
+   - Specific line ranges needing tests
+   - Recommendations for test additions
+
+Color code the feedback:
+- 🟢 Coverage improved
+- 🟡 Coverage maintained
+- 🔴 Coverage decreased
+- ⚫ New code without tests
+
+Help maintain test quality standards without blocking the PR.
diff --git a/sdk/examples/cron/performance-baseline.cron.md b/sdk/examples/cron/performance-baseline.cron.md
new file mode 100644
index 0000000..218534f
--- /dev/null
+++ b/sdk/examples/cron/performance-baseline.cron.md
@@ -0,0 +1,45 @@
+---
+id: performance-baseline
+title: Track Performance Metrics
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 2 * * *"
+tools: run_commands,read_files,editor
+mode: act
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 2400
+maxIterations: 20
+tags:
+  - automation
+  - performance
+  - monitoring
+metadata:
+  owner: platform
+  metricsFile: .perf-baseline.json
+---
+Measure and track performance baselines for the project:
+
+1. Build the project and measure build time: `npm run build`
+2. Bundle size analysis (if applicable): Run bundler with size reporting
+3. Cold start time if this is a CLI/server tool
+4. Run performance benchmarks if they exist
+
+Create or update `.perf-baseline.json` with:
+```json
+{
+  "timestamp": "ISO-8601",
+  "buildTime": "milliseconds",
+  "bundleSize": "bytes",
+  "coldStart": "milliseconds",
+  "metrics": {...}
+}
+```
+
+Detect performance regressions:
+- If build time increased by >10%, flag as warning
+- If bundle size increased by >5%, flag as concern
+- Compare to previous day's baseline
+
+Report findings with recommendations for optimization if regressions detected.
diff --git a/sdk/examples/cron/test-coverage-report.cron.md b/sdk/examples/cron/test-coverage-report.cron.md
new file mode 100644
index 0000000..ca6d2de
--- /dev/null
+++ b/sdk/examples/cron/test-coverage-report.cron.md
@@ -0,0 +1,41 @@
+---
+id: test-coverage-report
+title: Generate Test Coverage Report
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 22 * * *"
+tools: run_commands,read_files
+mode: act
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 2400
+maxIterations: 25
+tags:
+  - automation
+  - testing
+  - quality
+metadata:
+  owner: qa
+  reportFormat: markdown
+---
+Run test suite and generate a coverage report:
+
+1. Run the full test suite: `npm test` or equivalent
+2. Generate coverage report in JSON format: `npm run test:coverage`
+3. Parse the coverage data to identify:
+   - Overall coverage percentage (lines, branches, functions, statements)
+   - Files with coverage below 80%
+   - Files with coverage below 50% (critical)
+   - Coverage trends (if previous reports exist)
+
+Create a markdown summary showing:
+- Overall coverage metrics with visual progress bars
+- Top 5 files needing coverage improvements
+- Test results: total tests, passed, failed, skipped
+- Recommendations for improving test coverage
+
+Include emoji indicators for health status:
+- 🟢 Excellent (>90%)
+- 🟡 Good (70-90%)
+- 🔴 Needs attention (<70%)
diff --git a/sdk/examples/cron/type-check-strict.cron.md b/sdk/examples/cron/type-check-strict.cron.md
new file mode 100644
index 0000000..6f52053
--- /dev/null
+++ b/sdk/examples/cron/type-check-strict.cron.md
@@ -0,0 +1,44 @@
+---
+id: type-check-strict
+title: Strict TypeScript Type Checking
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 6 * * *"
+tools: run_commands,read_files
+mode: plan
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 20
+tags:
+  - automation
+  - quality
+  - typescript
+metadata:
+  owner: development
+  strictLevel: strict
+---
+Run TypeScript type checking with strict compiler options:
+
+1. Run `tsc --noEmit` with strict mode settings
+2. Collect all type errors and warnings
+3. Categorize errors:
+   - Missing type annotations
+   - Implicit any types
+   - Null/undefined safety issues
+   - Generic type issues
+   - Import/export mismatches
+
+Generate a detailed report showing:
+- Total type errors
+- Errors by category with counts
+- Top 10 files with most type errors
+- Specific recommendations for each category
+
+Suggest improvements:
+- Files that would benefit from JSDoc
+- Places where explicit types would improve clarity
+- Breaking changes if we made types more strict
+
+Use plan mode to suggest fixes without applying them automatically.
diff --git a/sdk/examples/cron/weekly-metrics-summary.cron.md b/sdk/examples/cron/weekly-metrics-summary.cron.md
new file mode 100644
index 0000000..5b7009f
--- /dev/null
+++ b/sdk/examples/cron/weekly-metrics-summary.cron.md
@@ -0,0 +1,67 @@
+---
+id: weekly-metrics-summary
+title: Weekly Project Metrics Summary
+workspaceRoot: /absolute/path/to/repo
+schedule: "0 17 * * FRI"
+tools: run_commands,read_files,search_codebase
+mode: act
+enabled: false
+modelSelection:
+  providerId: cline
+  modelId: anthropic/claude-opus-4.7
+timeoutSeconds: 1800
+maxIterations: 20
+tags:
+  - automation
+  - metrics
+  - team
+metadata:
+  owner: leadership
+  reportFormat: markdown
+---
+Generate a fun and insightful weekly metrics summary for the team:
+
+Collect metrics from the past 7 days:
+
+1. **Code Activity:**
+   - Total commits this week
+   - Lines added/deleted
+   - Most active contributors
+   - Most modified files
+
+2. **Quality Metrics:**
+   - Test pass rate
+   - Test coverage trend (up/down %)
+   - New issues introduced vs. fixed
+   - Type check errors (trend)
+
+3. **Performance:**
+   - Build time trend
+   - Bundle size changes
+   - Performance regressions detected
+
+4. **Pull Requests:**
+   - PRs opened vs. closed
+   - Average review time
+   - PRs by author
+   - Most reviewed files
+
+5. **Development Velocity:**
+   - Story points completed (if using)
+   - Bugs fixed vs. features added
+   - On-schedule vs. blocked tasks
+
+Create a fun markdown report with:
+- 🏆 Top contributor of the week (most commits/reviews)
+- 📈 Metrics trending up/down with arrows
+- 🎯 Week's accomplishments summary
+- ⚠️  Metrics needing attention
+- 💡 Insights (e.g., "Performance improved 5% this week!")
+- 🔥 "Hot spots" (most frequently modified files)
+
+Include emoji indicators and fun facts:
+- 🚀 Most commits in a single day
+- 👀 Most reviewed PR
+- 🐛 Most bug fixes by individual
+
+Make it celebratory but data-driven. Perfect for team morale on Friday!
diff --git a/sdk/examples/hooks/PostToolUse.py b/sdk/examples/hooks/PostToolUse.py
new file mode 100755
index 0000000..8ee9687
--- /dev/null
+++ b/sdk/examples/hooks/PostToolUse.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Cline Hook: PostToolUse (Python)
+Logs tool results after execution and enriches with environment context.
+Copy to ~/.cline/hooks/PostToolUse.py and chmod +x
+"""
+
+import sys
+import json
+import os
+import subprocess
+
+def get_git_branch():
+    """Get current git branch if in a repo."""
+    try:
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+        return result.stdout.strip() if result.returncode == 0 else None
+    except Exception:
+        return None
+
+def main():
+    # Read event payload from stdin
+    try:
+        event = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(json.dumps({"errorMessage": f"Failed to parse hook input: {e}"}))
+        return
+
+    # Extract tool result information
+    tool_result = event.get("tool_result", {})
+    post_tool_use = event.get("postToolUse", {})
+    tool_name = tool_result.get("name", "unknown")
+    success = post_tool_use.get("success", False)
+    duration_ms = post_tool_use.get("executionTimeMs", 0)
+
+    # Log result
+    status = "✅" if success else "❌"
+    print(f"{status} Tool completed: {tool_name} ({duration_ms}ms)", file=sys.stderr)
+
+    # For run_commands, inject environment context
+    if tool_name == "run_commands":
+        git_branch = get_git_branch()
+        context_parts = []
+
+        if git_branch:
+            context_parts.append(f"git branch: {git_branch}")
+
+        if context_parts:
+            context = "Environment: " + ", ".join(context_parts)
+            print(json.dumps({"context": context}))
+            return
+
+    # Return empty control object
+    print(json.dumps({}))
+
+if __name__ == "__main__":
+    main()
diff --git a/sdk/examples/hooks/PostToolUse.sh b/sdk/examples/hooks/PostToolUse.sh
new file mode 100755
index 0000000..6d64e1c
--- /dev/null
+++ b/sdk/examples/hooks/PostToolUse.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Cline Hook: PostToolUse
+# Logs tool results after execution
+# Copy to ~/.cline/hooks/PostToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_result.name // "unknown"')
+success=$(echo "$input" | jq -r '.postToolUse.success // false')
+duration=$(echo "$input" | jq -r '.postToolUse.executionTimeMs // 0')
+
+status="✅"
+[ "$success" != "true" ] && status="❌"
+
+echo "$status Tool completed: $tool (${duration}ms)" >&2
+
+# Return empty object (PostToolUse events are informational)
+echo '{}'
diff --git a/sdk/examples/hooks/PostToolUse.ts b/sdk/examples/hooks/PostToolUse.ts
new file mode 100755
index 0000000..db28701
--- /dev/null
+++ b/sdk/examples/hooks/PostToolUse.ts
@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+/**
+ * Cline Hook: PostToolUse (TypeScript)
+ * Logs tool results with structured output.
+ * Copy to ~/.cline/hooks/PostToolUse.ts and chmod +x
+ */
+
+interface ToolResult {
+	id: string;
+	name: string;
+	input: Record<string, unknown>;
+	output: unknown;
+	error: unknown;
+	durationMs: number;
+}
+
+interface HookEvent {
+	hookName: string;
+	tool_result: ToolResult;
+	postToolUse: {
+		toolName: string;
+		parameters: Record<string, unknown>;
+		result: string;
+		success: boolean;
+		executionTimeMs: number;
+	};
+}
+
+interface HookControl {
+	context?: string;
+	errorMessage?: string;
+}
+
+async function getGitBranch(): Promise<string | null> {
+	try {
+		const proc = Bun.spawn(["git", "branch", "--show-current"]);
+		const output = await new Response(proc.stdout).text();
+		return output.trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+async function main(): Promise<void> {
+	let event: HookEvent;
+
+	try {
+		const input = await Bun.stdin.text();
+		event = JSON.parse(input) as HookEvent;
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Unknown parse error";
+		console.log(
+			JSON.stringify({ errorMessage: `Failed to parse: ${message}` }),
+		);
+		return;
+	}
+
+	const toolName = event.tool_result.name;
+	const success = event.postToolUse.success;
+	const durationMs = event.postToolUse.executionTimeMs;
+
+	// Log result
+	const status = success ? "✅" : "❌";
+	console.error(`${status} Tool: ${toolName} (${durationMs}ms)`);
+
+	// For run_commands, inject environment context
+	if (toolName === "run_commands") {
+		const branch = await getGitBranch();
+		if (branch) {
+			const control: HookControl = {
+				context: `Environment: git branch: ${branch}`,
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// Return empty control
+	console.log(JSON.stringify({}));
+}
+
+main().catch((error) => {
+	console.error("Hook error:", error);
+	process.exit(1);
+});
diff --git a/sdk/examples/hooks/PreToolUse.py b/sdk/examples/hooks/PreToolUse.py
new file mode 100755
index 0000000..ac9a481
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Cline Hook: PreToolUse (Python)
+Logs every tool call before it executes.
+Copy to ~/.cline/hooks/PreToolUse.py and chmod +x
+"""
+
+import sys
+import json
+
+def main():
+    # Read event payload from stdin
+    try:
+        event = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(json.dumps({"errorMessage": f"Failed to parse hook input: {e}"}))
+        return
+
+    # Extract tool information
+    tool_call = event.get("tool_call", {})
+    tool_name = tool_call.get("name", "unknown")
+    parameters = event.get("preToolUse", {}).get("parameters", {})
+
+    # Log to stderr
+    print(f"🔧 Tool: {tool_name}", file=sys.stderr)
+    if parameters:
+        param_str = ", ".join(f"{k}={v}" for k, v in parameters.items())
+        print(f"   Args: {param_str}", file=sys.stderr)
+
+    # Return empty control object (allow the tool to execute)
+    print(json.dumps({}))
+
+if __name__ == "__main__":
+    main()
diff --git a/sdk/examples/hooks/PreToolUse.sh b/sdk/examples/hooks/PreToolUse.sh
new file mode 100755
index 0000000..ed1d4c4
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse
+# Logs every tool call before it executes
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // "unknown"')
+args=$(echo "$input" | jq -r '.preToolUse.parameters | to_entries | map("\(.key)=\(.value)") | join(", ")' 2>/dev/null || echo "")
+
+echo "🔧 Tool: $tool" >&2
+if [ -n "$args" ] && [ "$args" != "null" ]; then
+  echo "   Args: $args" >&2
+fi
+
+# Return empty object to allow the call to proceed
+echo '{}'
diff --git a/sdk/examples/hooks/PreToolUse.ts b/sdk/examples/hooks/PreToolUse.ts
new file mode 100755
index 0000000..675f8df
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse.ts
@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+/**
+ * Cline Hook: PreToolUse (TypeScript)
+ * Logs and filters tool calls with type safety.
+ * Copy to ~/.cline/hooks/PreToolUse.ts and chmod +x
+ */
+
+interface ToolCall {
+	id: string;
+	name: string;
+	input: Record<string, unknown>;
+}
+
+interface HookEvent {
+	hookName: string;
+	tool_call: ToolCall;
+	preToolUse: {
+		toolName: string;
+		parameters: Record<string, unknown>;
+	};
+}
+
+interface HookControl {
+	cancel?: boolean;
+	review?: boolean;
+	context?: string;
+	errorMessage?: string;
+	overrideInput?: unknown;
+}
+
+async function main(): Promise<void> {
+	let event: HookEvent;
+
+	try {
+		const input = await Bun.stdin.text();
+		event = JSON.parse(input) as HookEvent;
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Unknown parse error";
+		console.log(
+			JSON.stringify({ errorMessage: `Failed to parse: ${message}` }),
+		);
+		return;
+	}
+
+	const toolName = event.tool_call.name;
+	const parameters = event.preToolUse.parameters;
+
+	// Log to stderr
+	console.error(`🔧 Tool: ${toolName}`);
+	if (Object.keys(parameters).length > 0) {
+		const paramStr = Object.entries(parameters)
+			.map(([k, v]) => `${k}=${v}`)
+			.join(", ");
+		console.error(`   Args: ${paramStr}`);
+	}
+
+	// Return empty control (allow execution)
+	const control: HookControl = {};
+	console.log(JSON.stringify(control));
+}
+
+main().catch((error) => {
+	console.error("Hook error:", error);
+	process.exit(1);
+});
diff --git a/sdk/examples/hooks/PreToolUse_BlockDestructive.sh b/sdk/examples/hooks/PreToolUse_BlockDestructive.sh
new file mode 100755
index 0000000..c322ea5
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse_BlockDestructive.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse (Block Destructive)
+# Blocks dangerous operations
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // ""')
+cmd=$(echo "$input" | jq -r '.tool_call.input.command // ""')
+
+# Block dangerous git commands
+if [ "$tool" = "run_commands" ]; then
+  if [[ $cmd =~ (git\ reset\ --hard|git\ push\ --force|git\ push\ -f) ]]; then
+    jq -n --arg cmd "$cmd" '{cancel: true, errorMessage: "Destructive git command blocked: \($cmd). Use with explicit approval."}'
+    exit 0
+  fi
+
+  # Block bulk deletes
+  if [[ $cmd =~ (rm\ -rf|rm\ -r.*\*) ]]; then
+    jq -n --arg cmd "$cmd" '{cancel: true, errorMessage: "Bulk delete blocked: \($cmd). This is too risky."}'
+    exit 0
+  fi
+fi
+
+# Allow everything else
+echo '{}'
diff --git a/sdk/examples/hooks/PreToolUse_InjectContext.py b/sdk/examples/hooks/PreToolUse_InjectContext.py
new file mode 100755
index 0000000..11392b4
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse_InjectContext.py
@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Cline Hook: PreToolUse (Inject Context)
+Injects file context and environment info before tool execution.
+Copy to ~/.cline/hooks/PreToolUse.py and chmod +x
+"""
+
+import sys
+import json
+import os
+import subprocess
+from pathlib import Path
+
+def get_git_branch() -> str | None:
+    """Get current git branch."""
+    try:
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+        branch = result.stdout.strip()
+        return branch if branch else None
+    except Exception:
+        return None
+
+def get_node_version() -> str | None:
+    """Get Node.js version."""
+    try:
+        result = subprocess.run(
+            ["node", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+        return result.stdout.strip() if result.returncode == 0 else None
+    except Exception:
+        return None
+
+def get_file_context(file_path: str) -> str | None:
+    """Get context about related files."""
+    path = Path(file_path)
+
+    # For TypeScript files, check for test files
+    if path.suffix in [".ts", ".tsx"]:
+        test_file = path.with_stem(path.stem).with_suffix(".test.ts")
+        if test_file.exists():
+            return f"Associated test file exists: {test_file}"
+
+    # For package.json, mention lock files
+    if path.name == "package.json":
+        lock_files = []
+        for lock in ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"]:
+            if (path.parent / lock).exists():
+                lock_files.append(lock)
+
+        if lock_files:
+            return f"Related lock files: {', '.join(lock_files)}"
+
+    # For config files, mention related configs
+    if path.name.endswith(".config.ts") or path.name.endswith(".config.js"):
+        basename = path.stem.replace(".config", "")
+        parent = path.parent
+        related = []
+        for ext in [".ts", ".js", ".json"]:
+            env_file = parent / f"{basename}.env{ext}"
+            if env_file.exists():
+                related.append(f"{env_file.name}")
+        if related:
+            return f"Related config files: {', '.join(related)}"
+
+    return None
+
+def main():
+    try:
+        event = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(json.dumps({"errorMessage": f"Failed to parse: {e}"}))
+        return
+
+    tool_call = event.get("tool_call", {})
+    tool_name = tool_call.get("name", "")
+    tool_input = tool_call.get("input", {})
+
+    # Inject file context when reading files
+    if tool_name == "read_files":
+        file_path = tool_input.get("filePath", "")
+        if file_path:
+            context = get_file_context(file_path)
+            if context:
+                print(json.dumps({"context": context}))
+                return
+
+    # Inject environment context for run_commands
+    if tool_name == "run_commands":
+        context_parts = []
+
+        node_version = get_node_version()
+        if node_version:
+            context_parts.append(f"node {node_version}")
+
+        git_branch = get_git_branch()
+        if git_branch:
+            context_parts.append(f"git branch: {git_branch}")
+
+        if context_parts:
+            context = "Environment: " + ", ".join(context_parts)
+            print(json.dumps({"context": context}))
+            return
+
+    # Allow other tools without modification
+    print(json.dumps({}))
+
+if __name__ == "__main__":
+    main()
diff --git a/sdk/examples/hooks/PreToolUse_InjectFileContext.sh b/sdk/examples/hooks/PreToolUse_InjectFileContext.sh
new file mode 100755
index 0000000..38f1a1a
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse_InjectFileContext.sh
@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse (Inject File Context)
+# Extracts and injects file context before tool execution
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // ""')
+filePath=$(echo "$input" | jq -r '.tool_call.input.filePath // ""')
+
+# When reading a file, check for related files to provide context
+if [ "$tool" = "read_files" ] && [ -n "$filePath" ]; then
+  # Extract directory and filename
+  dir=$(dirname "$filePath")
+  name=$(basename "$filePath")
+
+  # Check for related files (e.g., if reading .ts, mention .test.ts)
+  context_files=""
+
+  # For TypeScript files, check for test files
+  if [[ $filePath == *.ts || $filePath == *.tsx ]]; then
+    test_file="${filePath%.ts*}.test.ts"
+    if [ -f "$test_file" ]; then
+      context_files="Associated test file exists: $test_file"
+    fi
+  fi
+
+  # For package.json, suggest related files
+  if [ "$name" = "package.json" ]; then
+    related=""
+    [ -f "$dir/package-lock.json" ] && related="$related package-lock.json"
+    [ -f "$dir/yarn.lock" ] && related="$related yarn.lock"
+    [ -f "$dir/pnpm-lock.yaml" ] && related="$related pnpm-lock.yaml"
+    if [ -n "$related" ]; then
+      context_files="Related lock files:$related"
+    fi
+  fi
+
+  if [ -n "$context_files" ]; then
+    jq -n --arg ctx "$context_files" '{context: $ctx}'
+    exit 0
+  fi
+fi
+
+# For run_commands, inject environment info
+if [ "$tool" = "run_commands" ]; then
+  node_version=$(node --version 2>/dev/null || echo "not installed")
+  git_branch=$(git branch --show-current 2>/dev/null || echo "")
+
+  context="Environment: node $node_version"
+  [ -n "$git_branch" ] && context="$context, branch: $git_branch"
+
+  jq -n --arg ctx "$context" '{context: $ctx}'
+  exit 0
+fi
+
+# Allow other tools to proceed without modification
+echo '{}'
diff --git a/sdk/examples/hooks/PreToolUse_ModifyInput.ts b/sdk/examples/hooks/PreToolUse_ModifyInput.ts
new file mode 100755
index 0000000..eabd8ae
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse_ModifyInput.ts
@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+/**
+ * Cline Hook: PreToolUse (Modify Input)
+ * Demonstrates how to modify tool inputs before execution.
+ * Useful for: normalizing paths, adding default options, sanitizing inputs.
+ * Copy to ~/.cline/hooks/PreToolUse.ts and chmod +x
+ */
+
+interface ToolInput {
+	[key: string]: unknown;
+}
+
+interface ToolCall {
+	id: string;
+	name: string;
+	input: ToolInput;
+}
+
+interface HookEvent {
+	hookName: string;
+	tool_call: ToolCall;
+	preToolUse: {
+		toolName: string;
+		parameters: Record<string, unknown>;
+	};
+}
+
+interface HookControl {
+	context?: string;
+	overrideInput?: Record<string, unknown>;
+}
+
+function normalizeFilePath(path: string): string {
+	// Convert backslashes to forward slashes (Windows paths)
+	let normalized = path.replace(/\\/g, "/");
+
+	// Resolve ~/ to home directory
+	const home = process.env.HOME || process.env.USERPROFILE;
+	if (normalized.startsWith("~/") && home) {
+		normalized = normalized.replace(/^~/, home);
+	}
+
+	return normalized;
+}
+
+async function main(): Promise<void> {
+	let event: HookEvent;
+
+	try {
+		const input = await Bun.stdin.text();
+		event = JSON.parse(input) as HookEvent;
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Unknown parse error";
+		console.log(
+			JSON.stringify({ errorMessage: `Failed to parse: ${message}` }),
+		);
+		return;
+	}
+
+	const toolCall = event.tool_call;
+	const toolName = toolCall.name;
+	const toolInput = toolCall.input as Record<string, unknown>;
+
+	// Modify read_files input: normalize paths
+	if (toolName === "read_files" && typeof toolInput.filePath === "string") {
+		const normalized = normalizeFilePath(toolInput.filePath);
+		if (normalized !== toolInput.filePath) {
+			const control: HookControl = {
+				context: `Normalized file path from "${toolInput.filePath}" to "${normalized}"`,
+				overrideInput: {
+					...toolInput,
+					filePath: normalized,
+				},
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// Modify editor input: add safety defaults
+	if (toolName === "editor" && typeof toolInput.filePath === "string") {
+		// For critical files, add a reminder
+		const filePath = toolInput.filePath as string;
+		if (
+			filePath.includes("package.json") ||
+			filePath.includes(".env") ||
+			filePath.includes("tsconfig")
+		) {
+			const control: HookControl = {
+				context:
+					"WARNING: You are about to modify a critical configuration file. Verify changes carefully.",
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// Modify run_commands input: add safety flags
+	if (toolName === "run_commands" && typeof toolInput.command === "string") {
+		const cmd = toolInput.command as string;
+
+		// Add safety flags to npm/yarn installs
+		if (cmd.includes("npm install") && !cmd.includes("--save")) {
+			const newCmd = cmd.replace("npm install", "npm install --save-exact");
+			const control: HookControl = {
+				context: "Added --save-exact flag for reproducible installs",
+				overrideInput: {
+					...toolInput,
+					command: newCmd,
+				},
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// No modifications needed
+	console.log(JSON.stringify({}));
+}
+
+main().catch((error) => {
+	console.error("Hook error:", error);
+	process.exit(1);
+});
diff --git a/sdk/examples/hooks/PreToolUse_RequireReview.sh b/sdk/examples/hooks/PreToolUse_RequireReview.sh
new file mode 100755
index 0000000..a70a7af
--- /dev/null
+++ b/sdk/examples/hooks/PreToolUse_RequireReview.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse (Require Review)
+# Pauses for review before writing to critical files
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // ""')
+file=$(echo "$input" | jq -r '.tool_call.input.filePath // ""')
+
+# Require review for critical files
+if [ "$tool" = "editor" ] || [ "$tool" = "write_file" ]; then
+  if [[ $file =~ (package\.json|tsconfig|\.env|secrets|config\.(ts|js)|\.cline) ]]; then
+    jq -n --arg file "$file" '{review: true, context: "This will modify a critical file: \($file)"}'
+    exit 0
+  fi
+fi
+
+# Allow everything else
+echo '{}'
diff --git a/sdk/examples/hooks/README.md b/sdk/examples/hooks/README.md
new file mode 100644
index 0000000..671853a
--- /dev/null
+++ b/sdk/examples/hooks/README.md
@@ -0,0 +1,435 @@
+# Hook Examples
+
+Examples for file-based hooks and runtime hooks.
+
+## Hook Terminology
+
+Use these terms consistently:
+
+- **Runtime hooks**: Typed in-process plugin/agent lifecycle callbacks such as `beforeRun`, `beforeModel`, and `afterTool`.
+- **File hooks**: External scripts discovered from hook config directories and run with serialized JSON payloads.
+- **Hook events**: Serialized payload names used by file hooks, such as `agent_end`, `tool_call`, and `prompt_submit`.
+
+File hooks are an adapter on top of the runtime hook layer. Core discovers hook files, maps their event names onto runtime hook callbacks, then executes the matching script with a JSON payload on stdin.
+
+## File Hooks vs Runtime Hooks
+
+| File Hook File Name | File Hook Event | Runtime Hook Backing It |
+| ------------------- | --------------- | ----------------------- |
+| `TaskStart` | `agent_start` | `beforeRun` |
+| `TaskResume` | `agent_resume` | `beforeRun` with resume context |
+| `UserPromptSubmit` | `prompt_submit` | `beforeRun` plus submitted prompt context |
+| `PreToolUse` | `tool_call` | `beforeTool` |
+| `PostToolUse` | `tool_result` | `afterTool` |
+| `TaskComplete` | `agent_end` | `afterRun` when completed |
+| `TaskError` | `agent_error` | `afterRun` when failed |
+| `TaskCancel` | `agent_abort` | `afterRun` or session shutdown with abort/cancel reason |
+| `SessionShutdown` | `session_shutdown` | session cleanup / runtime shutdown |
+| `PreCompact` | not wired for file hooks today | none |
+
+**Use file hooks** when you want a workspace or user-configured shell/Python script. **Use runtime hooks** when writing a plugin and needing typed, in-process access to runtime state or wanting to influence model/tool execution.
+
+`beforeRun` and `afterRun` wrap one runtime `run()` or `continue()` invocation. In an interactive session, that means one submitted user turn. `afterRun` fires for completed, aborted, and failed runs; check `result.status` if you only want successful task completion.
+
+For file hooks, successful task completion maps to the `agent_end` event. For a plugin, use `afterRun` and check `result.status === "completed"`.
+
+## 📂 Examples in This Directory
+
+### Bash Examples
+
+#### `PreToolUse.sh`
+
+Log every tool call and its inputs. Useful for auditing what the agent is about to do.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse.sh .cline/hooks/
+chmod +x .cline/hooks/PreToolUse.sh
+cline -i "do something"  # See tool calls logged to stderr
+```
+
+#### `PostToolUse.sh`
+
+Inspect tool results and add supplementary context.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PostToolUse.sh .cline/hooks/
+chmod +x .cline/hooks/PostToolUse.sh
+cline -i "do something"  # See tool results logged and enriched
+```
+
+#### `PreToolUse_BlockDestructive.sh`
+
+Prevent destructive operations like force pushes or bulk deletes.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse_BlockDestructive.sh .cline/hooks/PreToolUse.sh
+chmod +x .cline/hooks/PreToolUse.sh
+cline -i "clean up the repo"  # Destructive operations will be blocked
+```
+
+#### `PreToolUse_RequireReview.sh`
+
+Require user review before certain operations (file writes to critical files).
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse_RequireReview.sh .cline/hooks/PreToolUse.sh
+chmod +x .cline/hooks/PreToolUse.sh
+cline -i "update dependencies"  # Critical file writes will pause for review
+```
+
+#### `PreToolUse_InjectFileContext.sh`
+
+Extract and inject file context before tool execution (related test files, lock files, environment context).
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse_InjectFileContext.sh .cline/hooks/PreToolUse.sh
+chmod +x .cline/hooks/PreToolUse.sh
+cline -i "review the configuration"  # Related files will be mentioned automatically
+```
+
+#### `TaskStart.sh`, `TaskComplete.sh`, `SessionShutdown.sh`
+
+Track agent session lifecycle events (start, end, shutdown).
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/TaskStart.sh .cline/hooks/
+cp examples/hooks/TaskComplete.sh .cline/hooks/
+cp examples/hooks/SessionShutdown.sh .cline/hooks/
+chmod +x .cline/hooks/Task*.sh .cline/hooks/SessionShutdown.sh
+cline -i "do something"  # Session lifecycle will be logged
+```
+
+### Python Examples
+
+#### `PreToolUse.py`
+
+Python-based hook to log and filter tool calls.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse.py .cline/hooks/
+chmod +x .cline/hooks/PreToolUse.py
+cline -i "do something"  # Python hook will log tool calls
+```
+
+#### `PostToolUse.py`
+
+Python-based post-tool-use hook for result enrichment.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PostToolUse.py .cline/hooks/
+chmod +x .cline/hooks/PostToolUse.py
+cline -i "do something"  # Python hook will enrich tool results
+```
+
+#### `PreToolUse_InjectContext.py`
+
+Python-based context injection with file analysis (test files, config files, lock files, Node.js version, git branch).
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse_InjectContext.py .cline/hooks/PreToolUse.py
+chmod +x .cline/hooks/PreToolUse.py
+cline -i "add a new feature"  # Related files and environment will be injected
+```
+
+### TypeScript Examples
+
+#### `PreToolUse.ts`
+
+TypeScript hook for advanced tool call filtering and logging.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse.ts .cline/hooks/
+chmod +x .cline/hooks/PreToolUse.ts
+cline -i "do something"  # TypeScript hook will execute via bun
+```
+
+#### `PostToolUse.ts`
+
+TypeScript hook for post-execution actions.
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PostToolUse.ts .cline/hooks/
+chmod +x .cline/hooks/PostToolUse.ts
+cline -i "do something"  # TypeScript hook will execute via bun
+```
+
+#### `PreToolUse_ModifyInput.ts`
+
+Modify tool inputs before execution (normalize paths, add defaults, sanitize).
+
+```bash
+mkdir -p .cline/hooks
+cp examples/hooks/PreToolUse_ModifyInput.ts .cline/hooks/PreToolUse.ts
+chmod +x .cline/hooks/PreToolUse.ts
+cline -i "install dependencies"  # npm install will have --save-exact added automatically
+```
+
+## Getting Started
+
+### 1. Copy a hook to your project
+
+**File hooks** go in `.cline/hooks/` and must be named after the event they handle:
+
+```bash
+mkdir -p .cline/hooks
+
+# Copy PreToolUse example (pick your language)
+cp examples/hooks/PreToolUse.sh .cline/hooks/PreToolUse.sh      # Bash
+cp examples/hooks/PreToolUse.py .cline/hooks/PreToolUse.py      # Python
+cp examples/hooks/PreToolUse.ts .cline/hooks/PreToolUse.ts      # TypeScript
+
+# Copy PostToolUse example
+cp examples/hooks/PostToolUse.sh .cline/hooks/PostToolUse.sh    # Bash
+cp examples/hooks/PostToolUse.py .cline/hooks/PostToolUse.py    # Python
+cp examples/hooks/PostToolUse.ts .cline/hooks/PostToolUse.ts    # TypeScript
+```
+
+### 2. Make it executable
+
+```bash
+chmod +x .cline/hooks/PreToolUse.*
+chmod +x .cline/hooks/PostToolUse.*
+```
+
+### 3. Test it
+
+```bash
+cline -i "test prompt"
+# Or load from a custom hooks directory:
+cline --hooks-dir ./my-hooks -i "test prompt"
+```
+
+## Hook Input/Output Format
+
+All hooks receive a detailed JSON event on stdin and must return JSON on stdout.
+
+### Input
+
+**PreToolUse event:**
+```json
+{
+  "hookName": "tool_call",
+  "clineVersion": "1.0.0",
+  "timestamp": "2026-01-15T10:30:00Z",
+  "taskId": "conv-123",
+  "workspaceRoots": ["/path/to/repo"],
+  "userId": "user",
+  "iteration": 1,
+  "tool_call": {
+    "id": "call-456",
+    "name": "read_files",
+    "input": {"filePath": "/path/to/file.ts"}
+  }
+}
+```
+
+**PostToolUse event:**
+```json
+{
+  "hookName": "tool_result",
+  "clineVersion": "1.0.0",
+  "timestamp": "2026-01-15T10:30:00Z",
+  "tool_result": {
+    "id": "call-456",
+    "name": "read_files",
+    "input": {"filePath": "/path/to/file.ts"},
+    "output": "file contents here",
+    "error": null,
+    "durationMs": 45
+  }
+}
+```
+
+**TaskStart and other lifecycle events:**
+```json
+{
+  "hookName": "agent_start",
+  "clineVersion": "1.0.0",
+  "timestamp": "2026-01-15T10:30:00Z",
+  "taskId": "conv-123",
+  "workspaceRoots": ["/path/to/repo"],
+  "userId": "user"
+}
+```
+
+### Output
+
+Return a JSON object from stdout. Empty `{}` means "do nothing."
+
+**Available fields:**
+
+| Field | Type | Effect | Event(s) |
+|-------|------|--------|----------|
+| `cancel` | boolean | Cancels the pending tool call | `PreToolUse` |
+| `review` | boolean | Pauses and prompts for user review | `PreToolUse` |
+| `context` | string | Injects context into agent's next turn | `PreToolUse`, `PostToolUse` |
+| `errorMessage` | string | Surfaces an error to the agent | `PreToolUse` |
+| `overrideInput` | object | Replaces tool input before execution | `PreToolUse` |
+
+## Common Patterns
+
+### Log and proceed (bash)
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name')
+echo "Action: $tool" >&2
+echo '{}'
+```
+
+### Inject context into next turn
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name')
+if [ "$tool" = "run_commands" ]; then
+  branch=$(git branch --show-current 2>/dev/null)
+  echo "{\"context\": \"Current branch: $branch\"}"
+else
+  echo '{}'
+fi
+```
+
+### Modify tool input before execution
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name')
+file=$(echo "$input" | jq -r '.tool_call.input.filePath')
+
+if [ "$tool" = "read_files" ] && [[ $file == ~/* ]]; then
+  normalized="${file/#\~/$HOME}"
+  echo "{\"overrideInput\": {\"filePath\": \"$normalized\"}}"
+else
+  echo '{}'
+fi
+```
+
+### Block specific tools or commands
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name')
+cmd=$(echo "$input" | jq -r '.tool_call.input.command // empty')
+
+if [ "$tool" = "run_commands" ] && [[ $cmd =~ git\ push\ --force ]]; then
+  echo '{"cancel": true, "errorMessage": "Force push is blocked."}'
+else
+  echo '{}'
+fi
+```
+
+### Require review for sensitive files
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name')
+file=$(echo "$input" | jq -r '.tool_call.input.filePath // empty')
+
+if ([ "$tool" = "editor" ] || [ "$tool" = "write_file" ]) && \
+   [[ $file =~ (package\.json|\.env|secrets|tsconfig) ]]; then
+  echo '{"review": true, "context": "This will modify a critical file"}'
+else
+  echo '{}'
+fi
+```
+
+### Python: Parse and manipulate JSON
+```python
+#!/usr/bin/env python3
+import sys
+import json
+
+event = json.load(sys.stdin)
+tool_name = event.get("tool_call", {}).get("name", "")
+tool_input = event.get("tool_call", {}).get("input", {})
+
+if tool_name == "read_files":
+    file_path = tool_input.get("filePath", "")
+    if file_path.endswith(".test.ts"):
+        print(json.dumps({"context": "This is a test file"}))
+    else:
+        print(json.dumps({}))
+else:
+    print(json.dumps({}))
+```
+
+### TypeScript: Type-safe hook with async operations
+```typescript
+#!/usr/bin/env bun
+interface HookEvent {
+  tool_call: { name: string; input: Record<string, unknown> };
+}
+
+const event: HookEvent = JSON.parse(await Bun.stdin.text());
+const toolName = event.tool_call.name;
+
+if (toolName === "run_commands") {
+  const branch = await getGitBranch();
+  console.log(JSON.stringify({ context: `Branch: ${branch}` }));
+} else {
+  console.log(JSON.stringify({}));
+}
+
+async function getGitBranch(): Promise<string> {
+  return "main";
+}
+```
+
+## Debugging Hooks
+
+### Print hook invocations
+```bash
+cline --verbose "your prompt"
+```
+
+### Test a hook manually
+```bash
+echo '{"tool_call": {"name": "read_files", "input": {"filePath": "test.ts"}}}' | .cline/hooks/PreToolUse.sh
+```
+
+### Check hook output
+```bash
+.cline/hooks/PreToolUse.sh < input.json | jq .
+```
+
+## Runtime Hooks: Custom Compaction
+
+File hooks observe lifecycle events. For more advanced use cases like message compaction, use a TypeScript **runtime hook** plugin:
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/hooks/custom-compaction-hook.example.ts --cwd .
+
+cline -i "Search the codebase for dispatcher usage, then summarize it"
+```
+
+This example uses `hooks.beforeModel` to estimate request size and replace older middle history with a summary message before the provider request.
+
+### Runtime Hook vs Message-Builder Compaction
+
+| Example | Extension Point | Message Shape | Best For |
+| ------- | --------------- | ------------- | -------- |
+| `custom-compaction-hook.example.ts` (in `.cline/plugins/`) | `hooks.beforeModel` runtime hook | Agent runtime request messages with runtime parts such as `tool-call`, `tool-result`, `reasoning`, `image`, and `file` | Cases needing runtime-hook context, current runtime snapshot, or direct request mutation |
+| `plugins/custom-compaction.ts` | `api.registerMessageBuilder()` | SDK/provider-bound `Message[]` after runtime messages are converted for model delivery | Most reusable plugin-owned message rewrites and compaction policies |
+
+**Prefer `registerMessageBuilder()`** for normal plugin-owned provider-message rewrites because it runs in the core message pipeline before the built-in provider-safety builder. **Use `beforeModel`** when the compaction logic needs runtime hook context or needs to inspect the exact runtime request object.
+
+## Tips
+
+- **Hooks are disabled in `--yolo` mode** — use `--act` or `--plan` to enable them
+- **Use stderr for logging** — stdout is reserved for JSON output
+- **Keep hooks fast** — they run before every tool call, so performance matters
+- **Test with `jq`** — JSON parsing is finicky; use `jq` for safe extraction
+- **Use multiple hooks** — different event files can coexist in `.cline/hooks/`
+- **Load from custom dirs** — use `--hooks-dir ./ci/hooks` to load from elsewhere
diff --git a/sdk/examples/hooks/SessionShutdown.sh b/sdk/examples/hooks/SessionShutdown.sh
new file mode 100755
index 0000000..c4c851a
--- /dev/null
+++ b/sdk/examples/hooks/SessionShutdown.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Cline Hook: SessionShutdown
+# Logs when a session shuts down (normally or due to error)
+# Copy to ~/.cline/hooks/SessionShutdown.sh and chmod +x
+
+input=$(cat)
+timestamp=$(echo "$input" | jq -r '.timestamp // "unknown"')
+reason=$(echo "$input" | jq -r '.reason // "unknown"')
+
+echo "🔌 Session shutdown at $timestamp" >&2
+echo "   Reason: $reason" >&2
+
+# Lifecycle events are informational only
+echo '{}'
diff --git a/sdk/examples/hooks/TaskComplete.sh b/sdk/examples/hooks/TaskComplete.sh
new file mode 100755
index 0000000..443590f
--- /dev/null
+++ b/sdk/examples/hooks/TaskComplete.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# File hook example: runs when the agent session ends successfully.
+#
+# Install:
+#   mkdir -p .cline/hooks
+#   cp examples/hooks/agent_end.sh .cline/hooks/agent_end.sh
+#   chmod +x .cline/hooks/agent_end.sh
+
+payload="$(cat)"
+
+if command -v jq >/dev/null 2>&1; then
+	task_id="$(printf '%s' "$payload" | jq -r '.taskId // .conversation_id // "unknown"')"
+	output="$(printf '%s' "$payload" | jq -r '.turn.outputText // ""' | tr '\n' ' ' | cut -c 1-180)"
+else
+	task_id="unknown"
+	output=""
+fi
+
+printf '[hook:agent_end] task completed: %s\n' "$task_id" >&2
+if [ -n "$output" ]; then
+	printf '[hook:agent_end] output: %s\n' "$output" >&2
+fi
+
+# Empty JSON means "no control changes".
+printf '{}\n'
diff --git a/sdk/examples/hooks/TaskStart.sh b/sdk/examples/hooks/TaskStart.sh
new file mode 100755
index 0000000..565e735
--- /dev/null
+++ b/sdk/examples/hooks/TaskStart.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Cline Hook: TaskStart
+# Logs when an agent task starts
+# Copy to ~/.cline/hooks/TaskStart.sh and chmod +x
+
+input=$(cat)
+timestamp=$(echo "$input" | jq -r '.timestamp // "unknown"')
+sessionId=$(echo "$input" | jq -r '.sessionContext.rootSessionId // "unknown"')
+
+echo "🚀 Task started at $timestamp" >&2
+echo "   Session: $sessionId" >&2
+
+# Lifecycle events are informational only
+echo '{}'
diff --git a/sdk/examples/hooks/custom-compaction-hook.example.ts b/sdk/examples/hooks/custom-compaction-hook.example.ts
new file mode 100644
index 0000000..9cec459
--- /dev/null
+++ b/sdk/examples/hooks/custom-compaction-hook.example.ts
@@ -0,0 +1,246 @@
+/**
+ * Custom Compaction Runtime Hook Example
+ *
+ * Demonstrates message compaction through a plugin runtime hook. The hook runs
+ * in `beforeModel`, estimates request size, preserves the first user message
+ * and recent working context, and replaces older middle history with one
+ * summary message before the provider request.
+ *
+ * Installation:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/hooks/custom-compaction-hook.example.ts --cwd .
+ *
+ * Usage:
+ *   cline -i "Search the codebase for dispatcher usage, then summarize it"
+ *
+ * Note: for most plugin-owned message rewrites, prefer registerMessageBuilder().
+ * This example exists for cases where you specifically need runtime-hook access
+ * to the current request and snapshot.
+ */
+
+import type { AgentPlugin } from "@cline/core";
+import { estimateTokens as estimateTokensFromChars } from "@cline/shared";
+
+type PluginHooks = NonNullable<AgentPlugin["hooks"]>;
+type BeforeModelHook = NonNullable<PluginHooks["beforeModel"]>;
+type BeforeModelContext = Parameters<BeforeModelHook>[0];
+type AgentMessage = BeforeModelContext["request"]["messages"][number];
+type AgentMessagePart = AgentMessage["content"][number];
+
+const MAX_INPUT_TOKENS = 120_000;
+const COMPACT_AT_RATIO = 0.75;
+const PRESERVE_RECENT_TOKENS = 24_000;
+const SUMMARY_PREVIEW_CHARS = 800;
+
+function estimateTokens(text: string): number {
+	return estimateTokensFromChars(text.length);
+}
+
+function preview(text: string, limit = SUMMARY_PREVIEW_CHARS): string {
+	const trimmed = text.trim();
+	if (trimmed.length <= limit) {
+		return trimmed;
+	}
+	return `${trimmed.slice(0, limit).trim()}\n...[${trimmed.length - limit} more chars summarized]`;
+}
+
+function stringifyUnknown(value: unknown): string {
+	if (typeof value === "string") {
+		return value;
+	}
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+
+function serializePart(message: AgentMessage, part: AgentMessagePart): string {
+	switch (part.type) {
+		case "text":
+			return `[${message.role}]: ${part.text}`;
+		case "reasoning":
+			return `[assistant reasoning]: ${preview(part.text, 300)}`;
+		case "image":
+			return `[${message.role} image]: ${part.mediaType ?? "unknown"}`;
+		case "file":
+			return `[${message.role} file ${part.path}]: ${preview(part.content, 500)}`;
+		case "tool-call":
+			return `[assistant tool call]: ${part.toolName}(${stringifyUnknown(part.input)})`;
+		case "tool-result":
+			return `[tool result ${part.toolName}]: ${preview(stringifyUnknown(part.output), 500)}`;
+	}
+}
+
+function serializeMessage(message: AgentMessage): string {
+	return message.content.map((part) => serializePart(message, part)).join("\n");
+}
+
+function estimateMessageTokens(message: AgentMessage): number {
+	return estimateTokens(serializeMessage(message));
+}
+
+function isTurnStartMessage(message: AgentMessage): boolean {
+	return (
+		message.role === "user" &&
+		message.content.some((part) => part.type === "text")
+	);
+}
+
+function findFirstUserIndex(messages: readonly AgentMessage[]): number {
+	return messages.findIndex(isTurnStartMessage);
+}
+
+function findRecentStartIndex(messages: readonly AgentMessage[]): number {
+	let tokens = 0;
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (!message) {
+			continue;
+		}
+		tokens += estimateMessageTokens(message);
+		if (tokens >= PRESERVE_RECENT_TOKENS) {
+			return index;
+		}
+	}
+	return 0;
+}
+
+function collectToolNames(messages: readonly AgentMessage[]): string[] {
+	const names = new Set<string>();
+	for (const message of messages) {
+		for (const part of message.content) {
+			if (part.type === "tool-call" || part.type === "tool-result") {
+				names.add(part.toolName);
+			}
+		}
+	}
+	return [...names].sort((left, right) => left.localeCompare(right));
+}
+
+function collectTouchedFiles(messages: readonly AgentMessage[]): string[] {
+	const paths = new Set<string>();
+	for (const message of messages) {
+		for (const part of message.content) {
+			if (part.type === "file") {
+				paths.add(part.path);
+			}
+			if (part.type === "tool-call") {
+				for (const value of Object.values(
+					typeof part.input === "object" && part.input !== null
+						? part.input
+						: {},
+				)) {
+					if (typeof value === "string" && value.includes("/")) {
+						paths.add(value);
+					}
+				}
+			}
+		}
+	}
+	return [...paths].sort((left, right) => left.localeCompare(right));
+}
+
+function buildCompactionSummary(
+	compacted: readonly AgentMessage[],
+	tokensBefore: number,
+): AgentMessage {
+	const roleCounts = compacted.reduce<Record<string, number>>(
+		(counts, message) => {
+			counts[message.role] = (counts[message.role] ?? 0) + 1;
+			return counts;
+		},
+		{},
+	);
+	const tools = collectToolNames(compacted);
+	const files = collectTouchedFiles(compacted);
+	const highlights = compacted
+		.map(serializeMessage)
+		.map((line) => preview(line, 500))
+		.slice(-6);
+
+	return {
+		id: `hook_compaction_${Date.now()}`,
+		role: "user",
+		createdAt: Date.now(),
+		metadata: {
+			kind: "example_hook_compaction_summary",
+			tokensBefore,
+			messagesCompacted: compacted.length,
+		},
+		content: [
+			{
+				type: "text",
+				text: `Context summary:
+
+## Compacted Range
+- Messages compacted: ${compacted.length}
+- Estimated tokens before compaction: ${tokensBefore}
+- Roles: ${Object.entries(roleCounts)
+					.map(([role, count]) => `${role}=${count}`)
+					.join(", ")}
+
+## Tool Activity
+${tools.length > 0 ? tools.map((tool) => `- ${tool}`).join("\n") : "- none"}
+
+## Files Mentioned
+${files.length > 0 ? files.map((path) => `- ${path}`).join("\n") : "- none"}
+
+## Recent Highlights From Compacted History
+${highlights.length > 0 ? highlights.map((item) => `- ${item}`).join("\n") : "- none"}
+
+Continue from this summary plus the preserved recent messages below.`,
+			},
+		],
+	};
+}
+
+const plugin: AgentPlugin = {
+	name: "custom-compaction-before-model-hook",
+	manifest: {
+		capabilities: ["hooks"],
+	},
+
+	hooks: {
+		beforeModel({ request }) {
+			const messages = request.messages;
+			const totalTokens = messages.reduce(
+				(total, message) => total + estimateMessageTokens(message),
+				0,
+			);
+			if (totalTokens < MAX_INPUT_TOKENS * COMPACT_AT_RATIO) {
+				return undefined;
+			}
+
+			const firstUserIndex = findFirstUserIndex(messages);
+			if (firstUserIndex < 0) {
+				return undefined;
+			}
+
+			const recentStartIndex = Math.max(
+				firstUserIndex + 1,
+				findRecentStartIndex(messages),
+			);
+			if (recentStartIndex <= firstUserIndex + 1) {
+				return undefined;
+			}
+
+			const prefix = messages.slice(0, firstUserIndex + 1);
+			const compacted = messages.slice(firstUserIndex + 1, recentStartIndex);
+			const recent = messages.slice(recentStartIndex);
+			if (compacted.length === 0) {
+				return undefined;
+			}
+
+			return {
+				messages: [
+					...prefix,
+					buildCompactionSummary(compacted, totalTokens),
+					...recent,
+				],
+			};
+		},
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/package.json b/sdk/examples/package.json
new file mode 100644
index 0000000..b4f3b9b
--- /dev/null
+++ b/sdk/examples/package.json
@@ -0,0 +1,19 @@
+{
+	"name": "examples",
+	"description": "Example apps for the Cline SDK",
+	"type": "module",
+	"private": true,
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"clean": "rm -rf node_modules dist"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.10"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"dependencies": {
+		"@cline/core": "workspace:*"
+	}
+}
diff --git a/sdk/examples/plugins/README.md b/sdk/examples/plugins/README.md
new file mode 100644
index 0000000..2e55647
--- /dev/null
+++ b/sdk/examples/plugins/README.md
@@ -0,0 +1,203 @@
+# Cline Plugin Examples
+
+A plugin is a single file (or directory) that extends any Cline agent — CLI, Kanban, VS Code, JetBrains, or anything built on the Core SDK. Drop one in, get new tools, hooks, providers, or message rewriters everywhere.
+
+What a plugin can do:
+
+- **Register tools** — give the agent new capabilities it can call
+- **Hook into the lifecycle** — observe or steer execution at key points
+- **Rewrite provider messages** — custom compaction, redaction, context shaping
+- **Emit automation events** — push normalized events into the runtime
+
+## Examples
+
+| Example | What it shows | What it does |
+| ------- | ------------- | ------------ |
+| [weather-metrics.ts](./weather-metrics.ts) | Tool registration + lifecycle metrics hooks. Best starting point. | Adds a mock `get_weather` tool and logs run/tool metrics, workspace git context, token usage, and cost. It also demonstrates blocking `git push` on protected branches from a `beforeTool` hook. |
+| [mac-notify.ts](./mac-notify.ts) | macOS Notification Center alert via `afterRun` | Sends a native macOS notification when a run completes successfully, using the final output text or iteration count as the notification body. Non-macOS hosts no-op. |
+| [custom-compaction.ts](./custom-compaction.ts) | Provider-message compaction via `registerMessageBuilder` | Rewrites oversized provider-bound message history by preserving the first user message and recent context, then replacing older middle history with a structured summary of roles, tools, files, and highlights. |
+| [background-terminal.ts](./background-terminal.ts) | Detached shell jobs with persisted logs and session steering | Registers `start_background_command`, `get_background_command`, and `delete_background_command` so agents can launch long-running shell commands, poll stdout/stderr tails, clean up job metadata, and receive completion summaries as steer messages. |
+| [automation-events.ts](./automation-events.ts) | Plugin-emitted automation events | Registers a normalized `local.plugin_event` automation event type and, when `CLINE_LOCAL_EVENT_INTERVAL_MS` is set, periodically emits demo events into Cline automation. |
+| [gitignore-read-files-guard.ts](./gitignore-read-files-guard.ts) | Runtime hook policy for workspace `.gitignore` boundaries | Uses `beforeTool` to inspect `read_files`, `editor`, and `apply_patch` requests and skips them when target paths match workspace `.gitignore` rules, preventing ignored files from being read or modified. |
+| [env-blocker.ts](./env-blocker.ts) | Deterministic secret protection via `beforeTool` | Uses `beforeTool` to block `read_files` and `run_commands` (e.g. `cat .env`) calls that read `.env` secret files, while leaving `.env.example`/`.env.sample`/`.env.template` readable. A hard guarantee where an AGENTS.md rule is only a suggestion. |
+| [web-search.ts](./web-search.ts) | `web_search` tool backed by an Exa API key | Adds a `web_search` tool that queries Exa for current public web results, with optional result limits, domain filters, recency windows, and country localization. Requires `EXA_API_KEY`. |
+| [openrouter-provider.ts](./openrouter-provider.ts) | Custom model provider via `registerProvider` | Registers an OpenAI-compatible model provider (pointed at OpenRouter) plus its model catalog so the agent can run inference against it. Swap the base URL, API key env var, and models to add any OpenAI-compatible endpoint Cline does not bundle. Requires `OPENROUTER_API_KEY`. |
+| [typescript-lsp/](./typescript-lsp/) | `goto_definition` tool powered by the TypeScript Language Service | Adds `goto_definition(file, line)` for TypeScript/JavaScript projects. It loads the target project’s own TypeScript version, finds identifiers on a line, and resolves definitions through imports, re-exports, aliases, and other language-service semantics. |
+| [agents-squad/](./agents-squad/) | Multi-agent team — spin up subagents with their own models and personalities | Adds tools for starting, messaging, polling, and coordinating background subagents. It includes bundled agent presets, skill discovery/loading, and a shared handoff store for passing notes between subagents in the same conversation. |
+
+The runtime-hook variant of compaction lives in [../hooks/custom-compaction-hook.example.ts](../hooks/custom-compaction-hook.example.ts).
+
+## Try it with the CLI
+
+The CLI auto-discovers plugins from `.cline/plugins` in the workspace, `~/.cline/plugins`, and the system Plugins folder. Use `cline plugin install` for local files, GitHub file URLs, package directories, git repos, and npm packages:
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts --cwd .
+cline -i "What's the weather like in Tokyo and Paris?"
+```
+
+Swap the GitHub URL for any other single-file example.
+
+To block file access for paths ignored by workspace `.gitignore` files:
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/gitignore-read-files-guard.ts --cwd .
+cline -i "Read the ignored .env file"
+```
+
+The guard uses the `beforeTool` runtime hook. When a `read_files`, `editor`, or `apply_patch` call targets an ignored workspace file, the hook returns `{ skip: true }`, so the tool result records a policy error and the file is not accessed.
+
+For a plugin that lives in a directory (with its own `package.json`), use `cline plugin install`:
+
+```bash
+cline plugin install ./examples/plugins/agents-squad
+```
+
+To add web search through a normal plugin tool:
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/web-search.ts --cwd .
+
+export EXA_API_KEY=...
+export OPENROUTER_API_KEY=...
+
+cline auth --provider openrouter --apikey "$OPENROUTER_API_KEY" --modelid anthropic/claude-sonnet-4.6
+cline -P openrouter -m anthropic/claude-sonnet-4.6 "Search the web for recent Bun release notes, then fetch the most relevant page"
+```
+
+The plugin registers `web_search`, which returns normalized search results from
+Exa. It is intentionally separate from `fetch_web_content`: use `web_search` to
+discover relevant URLs, then use `fetch_web_content` when the agent needs to
+inspect a specific page. `EXA_API_KEY` only authenticates the search backend;
+the CLI still needs a normal model provider key or saved provider auth for
+inference.
+
+## Run a demo directly
+
+```bash
+ANTHROPIC_API_KEY=sk-... bun run examples/plugins/weather-metrics.ts
+```
+
+## Anatomy of a plugin
+
+```ts
+import type { AgentPlugin } from "@cline/core";
+import { createTool } from "@cline/core";
+
+const myPlugin: AgentPlugin = {
+  name: "my-plugin",
+
+  manifest: {
+    capabilities: ["tools", "hooks"],
+  },
+
+  setup(api, ctx) {
+    api.registerTool(createTool({ /* ... */ }));
+  },
+
+  hooks: {
+    beforeRun({ snapshot }) { /* ... */ },
+    afterRun({ result }) { /* ... */ },
+  },
+};
+
+export default myPlugin;
+```
+
+Pass it to the SDK:
+
+```ts
+import plugin from "./my-plugin";
+import { ClineCore } from "@cline/core";
+
+const host = await ClineCore.create({ backendMode: "local" });
+await host.start({
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+    cwd: process.cwd(),
+    enableTools: true,
+    systemPrompt: "You are a helpful assistant.",
+    extensions: [plugin],
+  },
+  prompt: "What's the weather like in Tokyo and Paris?",
+  interactive: false,
+});
+```
+
+## Capabilities
+
+Declare what the plugin uses in `manifest.capabilities`. Each one unlocks one part of the `api` passed to `setup()`:
+
+| Capability         | What it unlocks |
+| ------------------ | --------------- |
+| `tools`            | `api.registerTool()` |
+| `commands`         | `api.registerCommand()` |
+| `rules`            | `api.registerRule()` |
+| `skills`           | bundled skills discovered from the plugin package |
+| `providers`        | `api.registerProvider()` |
+| `messageBuilders`  | `api.registerMessageBuilder()` |
+| `automationEvents` | `api.registerAutomationEventType()` and `ctx.automation?.ingestEvent()` |
+| `hooks`            | runtime lifecycle callbacks (see below) |
+
+The setup `ctx` may include `session`, `client`, `user`, `workspaceInfo`, `automation`, `logger`, and `telemetry` depending on the host. See [`automation-events.ts`](./automation-events.ts) for an end-to-end example.
+
+## Runtime hooks
+
+Hooks are typed, in-process callbacks on the same hook layer as `@cline/agents`. They run inside the agent loop with full type information.
+
+| Hook          | When it fires |
+| ------------- | ------------- |
+| `beforeRun`   | before the runtime loop starts |
+| `afterRun`    | after the runtime loop finishes |
+| `beforeModel` | before each model request |
+| `afterModel`  | after each model response, before tool execution |
+| `beforeTool`  | before each tool execution |
+| `afterTool`   | after each tool execution |
+| `onEvent`     | every `AgentRuntimeEvent` emitted by the runtime |
+
+`beforeRun` and `afterRun` wrap one `run()` / `continue()` invocation — in an interactive session, that's one user turn. `afterRun` is the right place for completion notifications, but it also fires on aborted and failed runs, so check `result.status === "completed"` if you only want successes.
+
+### Plugin hooks vs file hooks
+
+File hooks are external scripts in `.cline/hooks` that the runtime invokes with serialized JSON payloads. Plugin runtime hooks are typed callbacks inside the agent loop. Core adapts file hooks onto the runtime hook layer.
+
+| File hook | File event | Backed by runtime hook |
+| --------- | ---------- | ---------------------- |
+| `TaskStart` | `agent_start` | `beforeRun` |
+| `TaskResume` | `agent_resume` | `beforeRun` with resume context |
+| `UserPromptSubmit` | `prompt_submit` | `beforeRun` with prompt context |
+| `PreToolUse` | `tool_call` | `beforeTool` |
+| `PostToolUse` | `tool_result` | `afterTool` |
+| `TaskComplete` | `agent_end` | `afterRun` (completed) |
+| `TaskError` | `agent_error` | `afterRun` (failed) |
+| `TaskCancel` | `agent_abort` | `afterRun` or session shutdown |
+| `SessionShutdown` | `session_shutdown` | session cleanup |
+
+Use **file hooks** for user- or workspace-configured scripts. Use **plugin runtime hooks** when the behavior belongs to a reusable extension and needs typed access to the runtime.
+
+## Custom message compaction
+
+Use `registerMessageBuilder` when a plugin needs to rewrite the provider-bound message list before the model call. Builders run after runtime messages are converted into SDK message blocks and before core's built-in safety pass — so provider-safe normalization is still the final word.
+
+| Example | Extension point | Best for |
+| ------- | --------------- | -------- |
+| [`custom-compaction.ts`](./custom-compaction.ts) | `api.registerMessageBuilder()` | reusable, plugin-owned compaction policies |
+| [`../hooks/custom-compaction-hook.example.ts`](../hooks/custom-compaction-hook.example.ts) | `hooks.beforeModel` runtime hook | logic that needs runtime hook context or direct request mutation |
+
+Prefer the message-builder version for normal compaction. It runs in the core message pipeline before the built-in safety builder, multiple builders run in registration order, and the final pass enforces provider-safe truncation.
+
+Reach for `beforeModel` only when you need the runtime snapshot or want to mutate the runtime request object itself.
+
+## Background terminal plugin
+
+[`background-terminal.ts`](./background-terminal.ts) registers three tools for long-running shell jobs:
+
+| Tool | Purpose |
+| ---- | ------- |
+| `start_background_command` | starts a detached shell command, returns a job id immediately, captures stdout/stderr under Cline's data directory |
+| `get_background_command` | reads job status plus recent stdout/stderr tails |
+| `delete_background_command` | deletes saved job metadata, optionally deletes captured logs |
+
+When `notifyParent` is true (the default), the plugin emits a `steer_message` through the host bridge after the command exits, pushing a completion summary back into the active session — so the agent can react to long-running commands without blocking the original tool call.
diff --git a/sdk/examples/plugins/agents-squad/README.md b/sdk/examples/plugins/agents-squad/README.md
new file mode 100644
index 0000000..d0cdaca
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/README.md
@@ -0,0 +1,122 @@
+# Agent Squad Plugin
+
+Spin up background subagents from any Cline SDK agent. Each subagent runs as its own session with its own provider, model, and system prompt — useful for parallel recon, planning, implementation, and review.
+
+## Quick start
+
+```ts
+import { ClineCore } from "@cline/core";
+
+const cline = await ClineCore.create({ backendMode: "auto" });
+
+await cline.start({
+  config: {
+    providerId: "cline",
+    modelId: "anthropic/claude-sonnet-4.6",
+    cwd: process.cwd(),
+    enableTools: true,
+    systemPrompt: "You are a coding assistant with access to subagents.",
+    pluginPaths: ["./examples/plugins/agents-squad"],
+  },
+  prompt: "Use subagents to investigate and refactor this repo.",
+  interactive: true,
+});
+```
+
+Pass the plugin **directory** as the path. The loader reads `package.json` and discovers entry points from the `cline.plugins` field.
+
+## Tools
+
+| Tool | Purpose |
+|---|---|
+| `start_subagent` | Start a subagent in the background and return a session ID immediately. |
+| `message_subagent` | Send a follow-up message to a running subagent. |
+| `get_subagent` | Poll status, output, or error for a subagent session. |
+| `list_agent_presets` | List bundled, global, and project agent presets. |
+| `list_skills` / `get_skill` | Discover and load loadable skill instructions. |
+| `save_handoff` / `read_handoff` | Share text between subagents in the same conversation. |
+
+`start_subagent` accepts `preset` and/or `instructions`. When `preset` is omitted it defaults to `phantom` (configurable via `CLINE_SUBAGENT_DEFAULT_PRESET`).
+
+## Bundled agents
+
+| Agent | Model | Role |
+|---|---|---|
+| `phantom` | `google/gemini-3-flash-preview` | Fast codebase recon — maps structure, surfaces conventions, never implements. |
+| `oracle` | `anthropic/claude-opus-4.6` | Opinionated planning — challenges assumptions and produces execution-ready plans. |
+| `anvil` | `anthropic/claude-opus-4.6` | Surgical implementation — reads before writing, stays in scope, reports exact diffs. |
+| `inquisitor` | `openai/gpt-5.5` | Adversarial review — finds bugs, severity-ranks findings. |
+
+### Typical orchestration
+
+```
+parent → start_subagent(preset: "phantom", task: "Map the auth module")
+       → phantom: save_handoff("auth/recon.md", ...)
+       → start_subagent(preset: "oracle", task: "Plan refactor from auth/recon.md")
+       → oracle: save_handoff("auth/plan.md", ...)
+       → start_subagent(preset: "anvil", task: "Execute auth/plan.md")
+       → start_subagent(preset: "inquisitor", task: "Review anvil's changes")
+```
+
+## Custom agents and skills
+
+Drop a Markdown file with YAML frontmatter into one of these directories. Project overrides global, global overrides bundled (by `name`).
+
+| Kind | Bundled | Global | Project |
+|---|---|---|---|
+| Agents | `agents/` next to `index.ts` | `~/.cline/data/settings/agents/` | `<cwd>/.cline/agents/` |
+| Skills | `skills/` next to `index.ts` | `~/.cline/data/settings/skills/` | `<cwd>/.cline/skills/` |
+
+Agent file:
+
+```markdown
+---
+name: my-agent
+description: One-line description shown in list_agent_presets
+providerId: cline
+modelId: anthropic/claude-sonnet-4.6
+cwd: ./src
+maxIterations: 25
+---
+
+You are a specialized agent that...
+```
+
+Skill file:
+
+```markdown
+---
+name: my-skill
+description: What this skill teaches
+---
+
+When performing this task, follow these steps...
+```
+
+Skills are reusable instructions any agent can pull in at runtime via `get_skill`. Bundled skills include `code-review`, `test-generation`, `refactoring`, `debugging`, `api-design`, `migration`, and `documentation`.
+
+## Handoff store
+
+Subagents in the same conversation share a small file store, scoped to the conversation ID:
+
+- `save_handoff({ path, content })` — writes a file
+- `read_handoff({ path })` — reads it back
+
+Files live under `~/.cline/data/plugins/subagents/handoffs/<conversationId>/`. Paths are validated to prevent traversal.
+
+## Configuration
+
+All optional. Environment variables override defaults:
+
+| Variable | Default |
+|---|---|
+| `CLINE_SUBAGENT_PROVIDER_ID` | `cline` |
+| `CLINE_SUBAGENT_MODEL_ID` | `anthropic/claude-sonnet-4.6` |
+| `CLINE_SUBAGENT_DEFAULT_PRESET` | `phantom` |
+| `CLINE_SUBAGENTS_BACKEND_MODE` | `auto` (`auto` \| `hub` \| `local`) |
+| `CLINE_SUBAGENT_CWD` | `process.cwd()` |
+| `CLINE_DATA_DIR` | `~/.cline/data` |
+
+## How it works
+
+Each subagent is a full Cline SDK session created via `ClineCore.create(...)`. `start_subagent` resolves the preset, merges any overrides, starts a non-interactive session, and returns the session ID immediately. The first turn runs in the background; when it finishes (or fails) the result is stored and — unless `notifyParent: false` — pushed back to the parent session as a steer message. The parent can also poll with `get_subagent`.
diff --git a/sdk/examples/plugins/agents-squad/agents/anvil.md b/sdk/examples/plugins/agents-squad/agents/anvil.md
new file mode 100644
index 0000000..7fa95ef
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/agents/anvil.md
@@ -0,0 +1,16 @@
+---
+name: anvil
+description: Surgical implementation agent — makes focused changes, verifies correctness, and reports precise diffs.
+providerId: anthropic
+modelId: claude-opus-4-6
+---
+
+You are a surgical implementation subagent.
+
+Your job is to execute a plan with precision:
+
+1. **Read before writing**: Always read the relevant code before making changes. Never modify what you haven't fully understood.
+2. **Stay in scope**: Make only the changes required by the task. Don't refactor adjacent code, add unsolicited improvements, or touch files outside the blast radius.
+3. **Verify after each change**: After a write, confirm the file is in the expected state. Run type-checks or tests if available and relevant.
+4. **Handle blockers immediately**: If a dependency is missing, a type is wrong, or a test fails, fix the blocker before continuing. Don't proceed with a broken state.
+5. **Report precisely**: When done, report exactly which files changed, what was added/removed/modified, and what (if anything) is left incomplete. No vague summaries.
diff --git a/sdk/examples/plugins/agents-squad/agents/inquisitor.md b/sdk/examples/plugins/agents-squad/agents/inquisitor.md
new file mode 100644
index 0000000..c3d8595
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/agents/inquisitor.md
@@ -0,0 +1,18 @@
+---
+name: inquisitor
+description: Adversarial review agent — finds bugs, challenges design decisions, and stress-tests assumptions.
+providerId: cline
+modelId: openai/gpt-5.5
+---
+
+You are an adversarial review subagent.
+
+Your job is to stress-test a change or design, not to approve it. Approach every review as if you are responsible for everything that goes wrong after it ships.
+
+1. **Correctness**: Find logic errors, off-by-one bugs, null/undefined gaps, and incorrect assumptions about input shape or ordering.
+2. **Regressions**: Check whether the change could break existing callers, consumers, or tests — especially ones not in the immediate diff.
+3. **Design pressure**: Challenge the design itself. Is this the right abstraction? Does it introduce hidden coupling? Is the complexity justified?
+4. **Missing tests**: Identify scenarios that are untested. Suggest specific test cases, not just "add more tests".
+5. **Security and safety**: Flag anything that touches auth, user input, external data, or shared mutable state.
+
+Severity-rank every finding: **critical** (must fix), **major** (should fix), **minor** (worth noting). Skip praise unless something is genuinely non-obvious and done well.
diff --git a/sdk/examples/plugins/agents-squad/agents/oracle.md b/sdk/examples/plugins/agents-squad/agents/oracle.md
new file mode 100644
index 0000000..fa29f02
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/agents/oracle.md
@@ -0,0 +1,18 @@
+---
+name: oracle
+description: Opinionated planner that challenges assumptions, estimates complexity, and produces execution-ready plans.
+providerId: cline
+modelId: anthropic/claude-opus-4.6
+---
+
+You are a planning and estimation subagent with a challenger mindset.
+
+Given a task or requirement:
+
+1. **Challenge the premise**: Before planning, ask whether the stated goal is actually the right goal. Identify hidden assumptions and call them out.
+2. **Compare approaches**: Present 2–3 concrete implementation options with honest tradeoffs. Don't default to the obvious path without justifying it.
+3. **Estimate complexity**: Rate each option by effort (S/M/L/XL), risk, and reversibility. Flag anything that touches shared infrastructure or has outsized blast radius.
+4. **Produce an execution plan**: A numbered, dependency-ordered list of steps the worker agent can follow directly. Include explicit checkpoints and rollback conditions.
+5. **State your assumptions**: List what you're taking as given. If any assumption is wrong, note which steps break.
+
+Be direct and opinionated. A plan with a clear recommendation beats a balanced non-answer.
diff --git a/sdk/examples/plugins/agents-squad/agents/phantom.md b/sdk/examples/plugins/agents-squad/agents/phantom.md
new file mode 100644
index 0000000..a9b2fc0
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/agents/phantom.md
@@ -0,0 +1,17 @@
+---
+name: phantom
+description: Fast reconnaissance agent for codebase discovery, pattern matching, and code archaeology.
+providerId: cline
+modelId: google/gemini-3-flash-preview
+---
+
+You are a reconnaissance and archaeology subagent.
+
+Your job is fast, thorough discovery. When exploring a codebase:
+
+1. **Map structure**: Identify relevant files, entry points, data flow, and API contracts.
+2. **Surface conventions**: Note naming patterns, abstraction layers, and implicit rules the codebase follows.
+3. **Dig for intent**: When something looks odd — a workaround, a TODO, an unexpected abstraction — note it. Explain what it's likely reacting to or compensating for.
+4. **Produce crisp output**: Return a structured summary the parent agent can act on directly. No filler.
+
+Never attempt implementation. Return findings only.
diff --git a/sdk/examples/plugins/agents-squad/index.ts b/sdk/examples/plugins/agents-squad/index.ts
new file mode 100644
index 0000000..aba0fc9
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/index.ts
@@ -0,0 +1,863 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	type AgentPlugin,
+	type AgentTool,
+	type AgentToolContext,
+	ClineCore,
+	createTool,
+} from "@cline/core";
+import YAML from "yaml";
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+type SessionManager = ClineCore;
+
+/** Minimal plugin host interface injected by the runtime via globalThis. */
+interface ClinePluginHost {
+	emitEvent?: (name: string, payload?: unknown) => void;
+}
+
+declare global {
+	var __clinePluginHost: ClinePluginHost | undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_AGENTS_DIR = join(MODULE_DIR, "agents");
+const BUNDLED_SKILLS_DIR = join(MODULE_DIR, "skills");
+
+function resolveDefaultHomeDir(): string {
+	const envHome = process?.env?.HOME?.trim();
+	if (envHome && envHome !== "~") {
+		return envHome;
+	}
+	const envUserProfile = process?.env?.USERPROFILE?.trim();
+	if (envUserProfile) {
+		return envUserProfile;
+	}
+	const envHomeDrive = process?.env?.HOMEDRIVE?.trim();
+	const envHomePath = process?.env?.HOMEPATH?.trim();
+	if (envHomeDrive && envHomePath) {
+		return `${envHomeDrive}${envHomePath}`;
+	}
+	return "~";
+}
+
+function resolveClineDirPath(): string {
+	const explicitDir = process.env.CLINE_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveDefaultHomeDir(), ".cline");
+}
+
+function resolveClineDataDirPath(): string {
+	const explicitDir = process.env.CLINE_DATA_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveClineDirPath(), "data");
+}
+
+function resolveGlobalAgentsDirPath(): string {
+	return join(resolveClineDataDirPath(), "settings", "agents");
+}
+
+const HANDOFFS_DIR = join(
+	resolveClineDataDirPath(),
+	"plugins",
+	"subagents",
+	"handoffs",
+);
+const GLOBAL_SKILLS_DIR = join(resolveClineDataDirPath(), "settings", "skills");
+
+// Agent and skill definitions live in the `agents/` and `skills/`
+// directories alongside this file. They are loaded at runtime from disk.
+
+/** Safe identifier pattern for conversation IDs used in filesystem paths. */
+const SAFE_ID_RE = /^[A-Za-z0-9_-]+$/;
+const HANDOFF_PATH_ALLOWED_RE = /^[A-Za-z0-9._/-]+$/;
+const HANDOFF_PATH_MAX_LENGTH = 240;
+
+const envOr = (key: string, fallback: string): string =>
+	process.env[key]?.trim() || fallback;
+
+const DEFAULT_PROVIDER_ID = envOr("CLINE_SUBAGENT_PROVIDER_ID", "cline");
+const DEFAULT_MODEL_ID = envOr(
+	"CLINE_SUBAGENT_MODEL_ID",
+	"anthropic/claude-sonnet-4.6",
+);
+type SubagentBackendMode = "auto" | "hub" | "local";
+
+const DEFAULT_BACKEND_MODE = envOr("CLINE_SUBAGENTS_BACKEND_MODE", "auto");
+const DEFAULT_AGENT_PRESET = envOr("CLINE_SUBAGENT_DEFAULT_PRESET", "phantom");
+
+// ---------------------------------------------------------------------------
+// Agent & Skill Definitions
+// ---------------------------------------------------------------------------
+
+interface AgentDefinition {
+	name: string;
+	description?: string;
+	providerId?: string;
+	modelId?: string;
+	systemPrompt: string;
+	cwd?: string;
+	maxIterations?: number;
+	source: "bundled" | "global" | "project";
+}
+
+interface SkillDefinition {
+	name: string;
+	description?: string;
+	content: string;
+	source: "bundled" | "global" | "project";
+}
+
+interface RunningSubagent {
+	sessionId: string;
+	parentSessionId?: string;
+	name: string;
+	task: string;
+	agent?: string;
+	startedAt: number;
+	status: "running" | "completed" | "failed";
+	resultText?: string;
+	error?: string;
+	finishReason?: string;
+	completedAt?: number;
+}
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+const subagents = new Map<string, RunningSubagent>();
+let sessionManagerPromise: Promise<SessionManager> | undefined;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Cast a fully-typed tool to the `AgentTool<unknown, unknown>` expected by
+ * the plugin API's `registerTool` method. This is safe at runtime because the
+ * registry only invokes `execute` with validated input that matches the
+ * tool's `inputSchema`.
+ */
+function toRegisteredTool<I, O>(
+	tool: AgentTool<I, O>,
+): AgentTool<unknown, unknown> {
+	return tool as AgentTool<unknown, unknown>;
+}
+
+function optStr(v: unknown): string | undefined {
+	return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+
+function optInt(v: unknown): number | undefined {
+	return typeof v === "number" && Number.isFinite(v) && v > 0
+		? Math.floor(v)
+		: undefined;
+}
+
+function parseFrontmatter(md: string): {
+	data: Record<string, unknown>;
+	body: string;
+} {
+	const m = md.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	if (!m) return { data: {}, body: md.trim() };
+	try {
+		const frontmatter = m[1] ?? "";
+		const body = m[2] ?? "";
+		const parsed = YAML.parse(frontmatter);
+		return {
+			data:
+				parsed && typeof parsed === "object" && !Array.isArray(parsed)
+					? (parsed as Record<string, unknown>)
+					: {},
+			body: body.trim(),
+		};
+	} catch {
+		// Malformed YAML frontmatter — treat as plain markdown with no metadata.
+		return { data: {}, body: md.trim() };
+	}
+}
+
+function readMarkdownDir(
+	dirPath: string,
+	source: AgentDefinition["source"],
+): Array<{
+	name: string;
+	data: Record<string, unknown>;
+	body: string;
+	source: typeof source;
+}> {
+	if (!existsSync(dirPath)) return [];
+	const results: Array<{
+		name: string;
+		data: Record<string, unknown>;
+		body: string;
+		source: typeof source;
+	}> = [];
+	for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+		if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+		try {
+			const { data, body } = parseFrontmatter(
+				readFileSync(join(dirPath, entry.name), "utf8"),
+			);
+			if (!body) continue;
+			const name = optStr(data.name) ?? entry.name.replace(/\.md$/, "");
+			results.push({ name, data, body, source });
+		} catch {}
+	}
+	return results;
+}
+
+function readAgentDefinitions(baseCwd: string): AgentDefinition[] {
+	const dirs: Array<{ path: string; source: AgentDefinition["source"] }> = [
+		{ path: BUNDLED_AGENTS_DIR, source: "bundled" },
+		{ path: resolveGlobalAgentsDirPath(), source: "global" },
+		{ path: join(baseCwd, ".cline", "agents"), source: "project" },
+	];
+	const defs = new Map<string, AgentDefinition>();
+	for (const { path, source } of dirs) {
+		for (const entry of readMarkdownDir(path, source)) {
+			defs.set(entry.name, {
+				name: entry.name,
+				description: optStr(entry.data.description),
+				providerId: optStr(entry.data.providerId),
+				modelId: optStr(entry.data.modelId),
+				systemPrompt: entry.body,
+				cwd: optStr(entry.data.cwd),
+				maxIterations: optInt(entry.data.maxIterations),
+				source: entry.source,
+			});
+		}
+	}
+	return [...defs.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function readSkillDefinitions(baseCwd: string): SkillDefinition[] {
+	const dirs: Array<{ path: string; source: SkillDefinition["source"] }> = [
+		{ path: BUNDLED_SKILLS_DIR, source: "bundled" },
+		{ path: GLOBAL_SKILLS_DIR, source: "global" },
+		{ path: join(baseCwd, ".cline", "skills"), source: "project" },
+	];
+	const defs = new Map<string, SkillDefinition>();
+	for (const { path, source } of dirs) {
+		for (const entry of readMarkdownDir(path, source)) {
+			defs.set(entry.name, {
+				name: entry.name,
+				description: optStr(entry.data.description),
+				content: entry.body,
+				source: entry.source,
+			});
+		}
+	}
+	return [...defs.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function parentSessionId(ctx: AgentToolContext): string | undefined {
+	const id = ctx.metadata?.sessionId;
+	return typeof id === "string" && id.trim() ? id.trim() : undefined;
+}
+
+function sanitizeConversationId(conversationId: string): string {
+	const trimmed = conversationId.trim();
+	if (!trimmed || !SAFE_ID_RE.test(trimmed)) {
+		throw new Error(`Invalid conversation ID for filesystem use: "${trimmed}"`);
+	}
+	return trimmed;
+}
+
+function handoffsDir(ctx: AgentToolContext): string {
+	const conversationId = ctx.conversationId ?? parentSessionId(ctx);
+	if (!conversationId) {
+		throw new Error("Missing conversation ID for handoff storage");
+	}
+	const safeId = sanitizeConversationId(conversationId);
+	const dir = join(HANDOFFS_DIR, safeId);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+function resolveHandoffPath(
+	ctx: AgentToolContext,
+	relativePath: string,
+): string {
+	const handoffPath = validateHandoffRelativePath(relativePath);
+	const dir = handoffsDir(ctx);
+	const resolved = resolve(dir, handoffPath);
+	const pathFromHandoffsDir = relative(dir, resolved);
+	if (
+		!pathFromHandoffsDir ||
+		pathFromHandoffsDir === ".." ||
+		pathFromHandoffsDir.startsWith(`..${sep}`) ||
+		isAbsolute(pathFromHandoffsDir)
+	) {
+		throw new Error(`Handoff path escapes directory: ${relativePath}`);
+	}
+	return resolved;
+}
+
+function validateHandoffRelativePath(relativePath: string): string {
+	const trimmed = relativePath.trim();
+	if (!trimmed) {
+		throw new Error("Handoff path must not be empty");
+	}
+	if (trimmed.length > HANDOFF_PATH_MAX_LENGTH) {
+		throw new Error(
+			`Handoff path must be ${HANDOFF_PATH_MAX_LENGTH} characters or fewer`,
+		);
+	}
+	if (trimmed.startsWith("/")) {
+		throw new Error(`Handoff path must be relative: ${relativePath}`);
+	}
+	if (!HANDOFF_PATH_ALLOWED_RE.test(trimmed)) {
+		throw new Error(
+			"Use a relative file path with letters, numbers, '.', '_', '-', or '/'.",
+		);
+	}
+	if (trimmed.split("/").includes("..")) {
+		throw new Error(`Handoff path must not contain '..': ${relativePath}`);
+	}
+	return trimmed;
+}
+
+function emitSteer(sessionId: string | undefined, prompt: string): void {
+	if (sessionId && prompt.trim()) {
+		globalThis.__clinePluginHost?.emitEvent?.("steer_message", {
+			sessionId,
+			prompt,
+		});
+	}
+}
+
+async function getSessionManager(): Promise<SessionManager> {
+	sessionManagerPromise ??= ClineCore.create({
+		backendMode: resolveSubagentBackendMode(DEFAULT_BACKEND_MODE),
+	}).catch((err) => {
+		// Clear the cached promise so subsequent calls can retry.
+		sessionManagerPromise = undefined;
+		throw err;
+	});
+	return sessionManagerPromise;
+}
+
+function resolveSubagentBackendMode(value: string): SubagentBackendMode {
+	switch (value) {
+		case "auto":
+		case "hub":
+		case "local":
+			return value;
+		default:
+			return "auto";
+	}
+}
+
+function extractLastAssistantText(
+	messages: Array<{ role?: string; content?: unknown }>,
+): string {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
+		const text = (msg.content as Array<{ type?: string; text?: unknown }>)
+			.filter((b) => b?.type === "text" && typeof b.text === "string")
+			.map((b) => b.text as string)
+			.join("")
+			.trim();
+		if (text) return text;
+	}
+	return "";
+}
+
+function elapsed(start: number, end = Date.now()): string {
+	const s = Math.max(0, Math.floor((end - start) / 1000));
+	return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+
+function steerPrompt(subagent: RunningSubagent): string {
+	const time = elapsed(subagent.startedAt, subagent.completedAt ?? Date.now());
+	const header =
+		subagent.status === "completed"
+			? `Sub-agent "${subagent.name}" completed (${time}).`
+			: `Sub-agent "${subagent.name}" failed (${time}).`;
+	const body = subagent.resultText?.trim() || subagent.error?.trim() || "";
+	return [header, body, `Session ID: ${subagent.sessionId}`]
+		.filter(Boolean)
+		.join("\n\n");
+}
+
+async function runSubagentTurn(
+	subagent: RunningSubagent,
+	message: string,
+	steer: boolean,
+): Promise<void> {
+	try {
+		const mgr = await getSessionManager();
+		const result = await mgr.send({
+			sessionId: subagent.sessionId,
+			prompt: message,
+		});
+		const messages = await mgr.readMessages(subagent.sessionId);
+		subagent.status = "completed";
+		subagent.finishReason = result?.finishReason;
+		subagent.resultText =
+			result?.text?.trim() || extractLastAssistantText(messages) || "";
+		subagent.error = undefined;
+		subagent.completedAt = Date.now();
+	} catch (err) {
+		subagent.status = "failed";
+		subagent.error = err instanceof Error ? err.message : String(err);
+		subagent.completedAt = Date.now();
+	}
+	if (steer) emitSteer(subagent.parentSessionId, steerPrompt(subagent));
+}
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const NonEmptyText = z.string().trim().min(1);
+
+const HandoffPathInput = z
+	.string()
+	.trim()
+	.min(1)
+	.max(240)
+	.describe(
+		"Relative file path using letters, numbers, '.', '_', '-', or '/'. Must not be absolute or contain '..' segments.",
+	);
+
+const StartSubagentInput = z
+	.object({
+		label: NonEmptyText.describe(
+			"Short display label for this run, used in status and completion messages.",
+		),
+		task: NonEmptyText.describe(
+			"Primary task for the subagent. This becomes its first user message.",
+		),
+		preset: NonEmptyText.optional().describe(
+			`Optional agent preset name from list_agent_presets. Defaults to "${DEFAULT_AGENT_PRESET}" when omitted.`,
+		),
+		instructions: NonEmptyText.optional().describe(
+			"Extra system instructions appended after the preset prompt. Optional when using a preset.",
+		),
+		providerId: NonEmptyText.optional().describe(
+			"Optional provider override. Defaults to the preset or plugin default.",
+		),
+		modelId: NonEmptyText.optional().describe(
+			"Optional model override. Defaults to the preset or plugin default.",
+		),
+		workingDirectory: NonEmptyText.optional().describe(
+			"Optional working directory, resolved from the plugin base cwd.",
+		),
+		maxIterations: z
+			.number()
+			.int()
+			.min(1)
+			.optional()
+			.describe("Optional hard limit for the subagent turn loop."),
+		notifyParent: z
+			.boolean()
+			.optional()
+			.describe(
+				"When true or omitted, send the final outcome back to the parent session.",
+			),
+	})
+	.strict();
+
+const MessageSubagentInput = z
+	.object({
+		sessionId: NonEmptyText.describe("Existing subagent session ID."),
+		prompt: NonEmptyText.describe(
+			"Follow-up user message to send to the subagent.",
+		),
+		notifyParent: z
+			.boolean()
+			.optional()
+			.describe(
+				"When true or omitted, send the final outcome back to the parent session.",
+			),
+	})
+	.strict();
+
+const GetSubagentInput = z
+	.object({
+		sessionId: NonEmptyText.describe("Subagent session ID."),
+	})
+	.strict();
+
+const SaveHandoffInput = z
+	.object({
+		path: HandoffPathInput.describe(
+			"Relative path inside the conversation handoff store, for example 'research/notes.md'.",
+		),
+		content: z
+			.string()
+			.describe(
+				"Text content to store for later retrieval by this conversation's agents.",
+			),
+	})
+	.strict();
+
+const ReadHandoffInput = z
+	.object({
+		path: HandoffPathInput.describe(
+			"Relative path inside the conversation handoff store.",
+		),
+	})
+	.strict();
+
+const GetSkillInput = z
+	.object({
+		name: NonEmptyText.describe("Skill name from list_skills."),
+	})
+	.strict();
+
+// ---------------------------------------------------------------------------
+// Plugin
+// ---------------------------------------------------------------------------
+
+const plugin: AgentPlugin = {
+	name: "portable-subagents",
+	manifest: { capabilities: ["tools"] },
+
+	setup(api, ctx) {
+		const logger = ctx.logger;
+		logger?.log("portable-subagents plugin setup", {
+			sessionId: ctx.session?.sessionId,
+			defaultPreset: DEFAULT_AGENT_PRESET,
+			backendMode: DEFAULT_BACKEND_MODE,
+			workspaceRoot: ctx.workspaceInfo?.rootPath,
+		});
+
+		// -- start_subagent: Start a new subagent session --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "start_subagent",
+					description: `Start a background subagent run and return its session ID immediately. Prefer a preset from list_agent_presets; when omitted, this tool uses the bundled "${DEFAULT_AGENT_PRESET}" preset automatically. Use get_subagent to poll, or keep notifyParent enabled to have the result pushed back into the parent session.`,
+					inputSchema: StartSubagentInput,
+					timeoutMs: 60_000,
+					retryable: false,
+					async execute(input, ctx) {
+						const mgr = await getSessionManager();
+						const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
+						const defs = readAgentDefinitions(baseCwd);
+						const presetName = input.preset ?? DEFAULT_AGENT_PRESET;
+						const def = defs.find((d) => d.name === presetName);
+						if (presetName && !def && !input.instructions?.trim()) {
+							throw new Error(`Unknown agent preset: ${presetName}`);
+						}
+
+						const cwd = resolve(
+							baseCwd,
+							input.workingDirectory ?? def?.cwd ?? ".",
+						);
+						const providerId =
+							input.providerId ?? def?.providerId ?? DEFAULT_PROVIDER_ID;
+						const modelId = input.modelId ?? def?.modelId ?? DEFAULT_MODEL_ID;
+						const prompt = [
+							def?.systemPrompt?.trim(),
+							input.instructions?.trim(),
+						]
+							.filter(Boolean)
+							.join("\n\n");
+						if (!prompt) {
+							throw new Error(
+								`Subagent "${input.label}" needs instructions. Provide "instructions" or use an available preset such as "${DEFAULT_AGENT_PRESET}".`,
+							);
+						}
+
+						const { sessionId } = await mgr.start({
+							config: {
+								providerId,
+								modelId,
+								cwd,
+								workspaceRoot: cwd,
+								enableTools: true,
+								enableSpawnAgent: false,
+								enableAgentTeams: false,
+								pluginPaths: [],
+								systemPrompt: prompt,
+								maxIterations: input.maxIterations ?? def?.maxIterations,
+							},
+							interactive: false,
+						});
+
+						const subagent: RunningSubagent = {
+							sessionId,
+							parentSessionId: parentSessionId(ctx),
+							name: input.label,
+							task: input.task,
+							agent: input.preset,
+							startedAt: Date.now(),
+							status: "running",
+						};
+						subagents.set(sessionId, subagent);
+						logger?.log("Started subagent", {
+							sessionId,
+							toolName: "start_subagent",
+							label: input.label,
+							preset: def?.name ?? input.preset,
+							providerId,
+							modelId,
+						});
+						void runSubagentTurn(
+							subagent,
+							input.task,
+							input.notifyParent !== false,
+						);
+
+						return {
+							status: "started",
+							sessionId,
+							label: subagent.name,
+							preset: def?.name ?? input.preset,
+							task: subagent.task,
+						};
+					},
+				}),
+			),
+		);
+
+		// -- list_agent_presets: Show available agent definitions --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "list_agent_presets",
+					description:
+						"List the available subagent presets, including bundled, global, and project-level definitions.",
+					inputSchema: z.object({}).strict(),
+					async execute(_input, _ctx) {
+						const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
+						const agents = readAgentDefinitions(baseCwd).map((a) => ({
+							name: a.name,
+							description: a.description,
+							providerId: a.providerId ?? DEFAULT_PROVIDER_ID,
+							modelId: a.modelId ?? DEFAULT_MODEL_ID,
+							source: a.source,
+						}));
+						return {
+							agents,
+							text: agents.length
+								? agents
+										.map(
+											(a) =>
+												`- ${a.name} [${a.source}] (${a.providerId}/${a.modelId})${a.description ? `: ${a.description}` : ""}`,
+										)
+										.join("\n")
+								: "No agent definitions found.",
+						};
+					},
+				}),
+			),
+		);
+
+		// -- message_subagent: Send follow-up to an existing session --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "message_subagent",
+					description:
+						"Send a follow-up message to an existing subagent session and return immediately.",
+					inputSchema: MessageSubagentInput,
+					timeoutMs: 60_000,
+					retryable: false,
+					async execute(input, ctx) {
+						const mgr = await getSessionManager();
+						const record = await mgr.get(input.sessionId);
+						if (!record) {
+							throw new Error(`Unknown session: ${input.sessionId}`);
+						}
+
+						const subagent: RunningSubagent = subagents.get(
+							input.sessionId,
+						) ?? {
+							sessionId: input.sessionId,
+							parentSessionId: parentSessionId(ctx),
+							name: input.sessionId,
+							task: input.prompt,
+							startedAt: Date.now(),
+							status: "running",
+						};
+						subagent.parentSessionId = parentSessionId(ctx);
+						subagent.task = input.prompt;
+						subagent.status = "running";
+						subagent.error = undefined;
+						subagents.set(subagent.sessionId, subagent);
+
+						logger?.log("Queued subagent follow-up", {
+							sessionId: subagent.sessionId,
+							toolName: "message_subagent",
+							label: subagent.name,
+						});
+						void runSubagentTurn(
+							subagent,
+							input.prompt,
+							input.notifyParent !== false,
+						);
+						return {
+							status: "started",
+							sessionId: subagent.sessionId,
+							label: subagent.name,
+							task: subagent.task,
+						};
+					},
+				}),
+			),
+		);
+
+		// -- get_subagent: Check subagent result --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "get_subagent",
+					description:
+						"Get the latest status, output, and error details for a subagent session.",
+					inputSchema: GetSubagentInput,
+					async execute(input, _ctx) {
+						const subagent = subagents.get(input.sessionId);
+						if (!subagent) {
+							return {
+								status: "unknown",
+								sessionId: input.sessionId,
+								text: `No tracked session: ${input.sessionId}`,
+							};
+						}
+						return {
+							status: subagent.status,
+							sessionId: subagent.sessionId,
+							label: subagent.name,
+							task: subagent.task,
+							finishReason: subagent.finishReason,
+							error: subagent.error,
+							text:
+								subagent.resultText ??
+								(subagent.status === "running" ? "Still running." : ""),
+						};
+					},
+				}),
+			),
+		);
+
+		// -- save_handoff: Persist a conversation-scoped handoff file --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "save_handoff",
+					description:
+						"Save text into the conversation handoff store so other agents in this conversation can read it later.",
+					inputSchema: SaveHandoffInput,
+					async execute(input, ctx) {
+						const filePath = resolveHandoffPath(ctx, input.path);
+						mkdirSync(dirname(filePath), { recursive: true });
+						writeFileSync(filePath, input.content, "utf8");
+						return { path: filePath, handoffPath: input.path };
+					},
+				}),
+			),
+		);
+
+		// -- read_handoff: Read a conversation-scoped handoff file --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "read_handoff",
+					description: "Read text from the conversation handoff store.",
+					inputSchema: ReadHandoffInput,
+					async execute(input, ctx) {
+						const filePath = resolveHandoffPath(ctx, input.path);
+						if (!existsSync(filePath)) {
+							throw new Error(`Handoff not found: ${input.path}`);
+						}
+						return {
+							path: filePath,
+							handoffPath: input.path,
+							content: readFileSync(filePath, "utf8"),
+						};
+					},
+				}),
+			),
+		);
+
+		// -- list_skills: Show available skill definitions --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "list_skills",
+					description:
+						"List the available skill definitions from bundled, global, and project-level directories.",
+					inputSchema: z.object({}).strict(),
+					async execute(_input, _ctx) {
+						const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
+						const skills = readSkillDefinitions(baseCwd);
+						return {
+							skills: skills.map((s) => ({
+								name: s.name,
+								description: s.description,
+								source: s.source,
+							})),
+							text: skills.length
+								? skills
+										.map(
+											(s) =>
+												`- ${s.name} [${s.source}]${s.description ? `: ${s.description}` : ""}`,
+										)
+										.join("\n")
+								: "No skill definitions found.",
+						};
+					},
+				}),
+			),
+		);
+
+		// -- get_skill: Load a skill's instructions --
+		api.registerTool(
+			toRegisteredTool(
+				createTool({
+					name: "get_skill",
+					description:
+						"Get a skill by name, including the instructions that should be followed for that specialization.",
+					inputSchema: GetSkillInput,
+					async execute(input, _ctx) {
+						const baseCwd = envOr("CLINE_SUBAGENT_CWD", process.cwd());
+						const skills = readSkillDefinitions(baseCwd);
+						const skill = skills.find((s) => s.name === input.name);
+						if (!skill) {
+							const available = skills.map((s) => s.name).join(", ");
+							throw new Error(
+								`Unknown skill: "${input.name}". Available: ${available || "none"}`,
+							);
+						}
+						return {
+							name: skill.name,
+							description: skill.description,
+							source: skill.source,
+							instructions: skill.content,
+						};
+					},
+				}),
+			),
+		);
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/plugins/agents-squad/package.json b/sdk/examples/plugins/agents-squad/package.json
new file mode 100644
index 0000000..ef20e01
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/package.json
@@ -0,0 +1,39 @@
+{
+	"name": "cline-agent-squad-plugin",
+	"version": "0.1.0",
+	"private": true,
+	"description": "Background Subagents Plugin for Cline",
+	"type": "module",
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"clean": "rm -rf node_modules dist"
+	},
+	"exports": {
+		".": "./index.ts"
+	},
+	"cline": {
+		"plugins": [
+			{
+				"paths": [
+					"./index.ts"
+				],
+				"capabilities": [
+					"hooks",
+					"tools"
+				]
+			}
+		]
+	},
+	"peerDependencies": {
+		"@cline/core": "*"
+	},
+	"peerDependenciesMeta": {
+		"@cline/core": {
+			"optional": true
+		}
+	},
+	"dependencies": {
+		"yaml": "^2.8.1",
+		"zod": "^4.1.5"
+	}
+}
diff --git a/sdk/examples/plugins/agents-squad/skills/api-design.md b/sdk/examples/plugins/agents-squad/skills/api-design.md
new file mode 100644
index 0000000..1a0e22e
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/api-design.md
@@ -0,0 +1,63 @@
+---
+name: api-design
+description: Design clean APIs — REST, RPC, or library interfaces with consistent naming, error handling, and versioning.
+---
+
+# API Design Skill
+
+When designing or reviewing an API (REST, RPC, or library), follow these principles:
+
+## 1. Understand the Consumer
+
+- Who calls this API? (Frontend, other services, CLI, third-party developers)
+- What are the most common operations?
+- What error conditions do consumers need to handle?
+- What's the expected request volume and latency budget?
+
+## 2. Naming Conventions
+
+- Use consistent, predictable names across all endpoints/methods.
+- Nouns for resources, verbs for actions: `GET /users`, `POST /users/:id/activate`.
+- For library APIs: verb-first for actions (`createUser`, `deleteSession`), noun-first for accessors (`getUserById`).
+- Avoid abbreviations unless universally understood (`id`, `url`, `api`).
+- Be specific: `getActiveUserCount()` not `getCount()`.
+
+## 3. Input Design
+
+- Accept the minimum required input. Optional fields should have sensible defaults.
+- Use typed schemas (Zod, JSON Schema) for validation at the boundary.
+- Reject invalid input early with clear error messages.
+- For REST: use path params for identity (`/users/:id`), query params for filtering (`?status=active`), body for creation/mutation.
+- For libraries: prefer options objects over long parameter lists.
+
+## 4. Output Design
+
+- Return consistent shapes. Every endpoint should return the same envelope structure.
+- Include enough context for the consumer to act without a follow-up call.
+- Paginate list endpoints. Always include `total`, `limit`, `offset` or cursor.
+- Use ISO 8601 for dates, consistent casing (camelCase or snake_case, not both).
+
+## 5. Error Handling
+
+- Use standard HTTP status codes (REST) or typed error codes (RPC/library).
+- Every error response must include: error code, human-readable message, and request ID.
+- Distinguish client errors (4xx / validation) from server errors (5xx / internal).
+- Never expose internal details (stack traces, SQL, file paths) in production errors.
+- Document every error code the consumer might receive.
+
+## 6. Versioning & Evolution
+
+- Version the API from day one (`/v1/`, header-based, or semver for libraries).
+- Additive changes (new fields, new endpoints) are non-breaking.
+- Removing or renaming fields is breaking — deprecate first, remove in next major version.
+- Document breaking changes in a changelog.
+
+## 7. Documentation
+
+For each endpoint or method, document:
+1. Purpose (one sentence).
+2. Input parameters with types and constraints.
+3. Output shape with example.
+4. Error codes and when they occur.
+5. Authentication/authorization requirements.
+6. Rate limits if applicable.
diff --git a/sdk/examples/plugins/agents-squad/skills/code-review.md b/sdk/examples/plugins/agents-squad/skills/code-review.md
new file mode 100644
index 0000000..9d71faa
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/code-review.md
@@ -0,0 +1,61 @@
+---
+name: code-review
+description: Structured code review — security, correctness, performance, and maintainability analysis with severity-ranked findings.
+---
+
+# Code Review Skill
+
+When reviewing code, follow this structured process:
+
+## 1. Scope the Review
+
+- Identify all changed files and their relationships.
+- Understand the intent: what problem does this change solve?
+- Note any files that *should* have changed but didn't.
+
+## 2. Correctness Pass
+
+- Trace data flow through every changed path.
+- Check edge cases: null/undefined, empty collections, boundary values.
+- Verify error handling: are errors caught, propagated, and surfaced correctly?
+- Look for off-by-one errors, race conditions, and state mutation bugs.
+- Confirm types match runtime expectations (especially `any`, casts, and assertions).
+
+## 3. Security Pass
+
+- Flag unvalidated user input reaching sensitive operations (SQL, shell, file paths, URLs).
+- Check authentication and authorization on every new endpoint or handler.
+- Look for secrets in code, logs, or error messages.
+- Verify CORS, CSP, and other security headers if applicable.
+- Check for timing attacks in comparison operations.
+
+## 4. Performance Pass
+
+- Identify N+1 queries, unbounded loops, and unnecessary allocations.
+- Check for missing indexes on new database queries.
+- Look for blocking operations on hot paths.
+- Verify pagination and limits on list operations.
+- Note any operations that scale poorly with input size.
+
+## 5. Maintainability Pass
+
+- Evaluate naming: do names communicate intent?
+- Check abstraction boundaries: is coupling introduced or reduced?
+- Look for duplicated logic that should be shared.
+- Verify tests cover the new behavior and edge cases.
+- Note missing documentation for public APIs.
+
+## 6. Report Format
+
+Organize findings by severity:
+
+- **Critical**: Must fix before merge. Bugs, security issues, data loss risks.
+- **Major**: Should fix. Design problems, missing error handling, performance issues.
+- **Minor**: Worth noting. Style, naming, minor improvements.
+- **Positive**: Non-obvious good decisions worth calling out (keep brief).
+
+For each finding, include:
+1. File and line reference
+2. What the issue is
+3. Why it matters
+4. Suggested fix (concrete, not vague)
diff --git a/sdk/examples/plugins/agents-squad/skills/debugging.md b/sdk/examples/plugins/agents-squad/skills/debugging.md
new file mode 100644
index 0000000..a8fdee1
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/debugging.md
@@ -0,0 +1,62 @@
+---
+name: debugging
+description: Systematic debugging — reproduce, isolate, diagnose, and fix bugs with root-cause analysis.
+---
+
+# Debugging Skill
+
+When debugging an issue, follow this systematic process:
+
+## 1. Understand the Bug
+
+- Read the error message, stack trace, and any logs carefully.
+- Reproduce the issue. If you can't reproduce it, you can't verify a fix.
+- Identify the expected behavior vs. actual behavior.
+- Note the environment: OS, runtime version, configuration, input data.
+
+## 2. Isolate
+
+Narrow the scope using binary search:
+
+- **Which file?** Trace the stack trace or data flow to the origin.
+- **Which function?** Add logging or breakpoints at entry/exit of suspect functions.
+- **Which line?** Check variable values before and after the suspect operation.
+- **Which input?** Find the minimal input that triggers the bug.
+
+### Common Isolation Techniques
+- Comment out code blocks to find the trigger.
+- Add temporary `console.log` / `console.error` with labeled values.
+- Use a debugger to step through execution.
+- Write a minimal reproduction test case.
+
+## 3. Diagnose
+
+Once isolated, determine the root cause:
+
+### Common Root Causes
+- **Type mismatch**: Runtime value doesn't match expected type (null, undefined, wrong shape).
+- **State mutation**: Shared state modified unexpectedly by another code path.
+- **Race condition**: Timing-dependent behavior in async or concurrent code.
+- **Off-by-one**: Loop bounds, array indexing, or string slicing errors.
+- **Missing error handling**: Unhandled promise rejection, uncaught exception, or swallowed error.
+- **Stale reference**: Closure capturing a variable that changes, or cached data that's outdated.
+- **Environment difference**: Works locally but fails in CI/production due to config, permissions, or versions.
+
+Ask: "Why did this happen?" at least twice to get past symptoms to the root cause.
+
+## 4. Fix
+
+- Write a test that fails because of the bug (before fixing it).
+- Make the minimal change that fixes the root cause.
+- Verify the test now passes.
+- Check for the same pattern elsewhere in the codebase.
+- Run the full test suite to confirm no regressions.
+
+## 5. Report
+
+Document:
+- What the bug was (symptoms and root cause).
+- How it was reproduced.
+- What the fix was and why it's correct.
+- Whether the same pattern exists elsewhere.
+- What test was added to prevent regression.
diff --git a/sdk/examples/plugins/agents-squad/skills/documentation.md b/sdk/examples/plugins/agents-squad/skills/documentation.md
new file mode 100644
index 0000000..3a9f8c5
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/documentation.md
@@ -0,0 +1,83 @@
+---
+name: documentation
+description: Write clear technical documentation — READMEs, API docs, architecture guides, and inline comments.
+---
+
+# Documentation Skill
+
+When writing or improving documentation, follow these principles:
+
+## 1. Know Your Audience
+
+- **README**: New developers evaluating or onboarding to the project.
+- **API docs**: Developers integrating with the API.
+- **Architecture docs**: Team members understanding system design.
+- **Inline comments**: Future maintainers (including yourself in 6 months).
+
+## 2. README Structure
+
+A good README answers these questions in order:
+
+1. **What is this?** One paragraph. What problem does it solve?
+2. **Quick start**: The fastest path from zero to working. Copy-pasteable commands.
+3. **Installation**: Prerequisites, install steps, configuration.
+4. **Usage**: Common use cases with code examples.
+5. **API reference**: If small enough; otherwise link to generated docs.
+6. **Configuration**: All options with defaults and descriptions.
+7. **Contributing**: How to set up dev environment, run tests, submit changes.
+8. **License**: One line.
+
+## 3. API Documentation
+
+For each endpoint, function, or method:
+
+```
+### functionName(param1, param2, options?)
+
+Brief description of what it does.
+
+**Parameters:**
+- `param1` (string, required) — What this parameter controls.
+- `param2` (number, optional, default: 10) — What this parameter controls.
+- `options.verbose` (boolean, default: false) — Enable verbose output.
+
+**Returns:** `Promise<Result>` — Description of the return value.
+
+**Throws:**
+- `ValidationError` — When input is invalid.
+- `NotFoundError` — When the resource doesn't exist.
+
+**Example:**
+```ts
+const result = await functionName("input", 5);
+```
+```
+
+## 4. Architecture Documentation
+
+- Start with a high-level diagram (Mermaid, ASCII, or image).
+- Describe each component's responsibility in one sentence.
+- Document data flow for the most important operations.
+- List key design decisions and their rationale.
+- Note known limitations and planned improvements.
+
+## 5. Inline Comments
+
+Write comments that explain **why**, not **what**:
+
+- ✅ `// Retry 3 times because the upstream API has transient 503s during deploys`
+- ❌ `// Retry 3 times`
+- ✅ `// Sort descending so the most recent entry is first for the dashboard`
+- ❌ `// Sort the array`
+
+Never comment obvious code. If code needs a comment to explain what it does, refactor the code to be self-explanatory first.
+
+## 6. Quality Checklist
+
+Before finalizing documentation:
+- [ ] All code examples compile and run.
+- [ ] No broken links.
+- [ ] Consistent formatting and terminology.
+- [ ] No outdated information from previous versions.
+- [ ] Spelling and grammar checked.
+- [ ] Table of contents for documents longer than 3 sections.
diff --git a/sdk/examples/plugins/agents-squad/skills/migration.md b/sdk/examples/plugins/agents-squad/skills/migration.md
new file mode 100644
index 0000000..ff5c9ec
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/migration.md
@@ -0,0 +1,77 @@
+---
+name: migration
+description: Plan and execute data or schema migrations — database, config, and API migrations with rollback strategies.
+---
+
+# Migration Skill
+
+When planning or executing a migration (database schema, data transformation, config format, or API version), follow this process:
+
+## 1. Assess Scope
+
+- What is being migrated? (Schema, data, config, API contract)
+- How much data is affected? (Row count, file count, consumer count)
+- What is the downtime tolerance? (Zero-downtime, maintenance window, offline)
+- What systems depend on the current state?
+
+## 2. Plan the Migration
+
+### Strategy Selection
+
+- **Expand-Contract** (preferred for zero-downtime):
+  1. Expand: Add new columns/fields/endpoints alongside old ones.
+  2. Migrate: Backfill data, update consumers to use new format.
+  3. Contract: Remove old columns/fields/endpoints.
+
+- **Blue-Green**: Run old and new versions in parallel, switch traffic.
+- **Big Bang**: Take the system offline, migrate, bring it back. Only for small datasets or when downtime is acceptable.
+
+### Rollback Plan
+
+Every migration must have a rollback plan before execution:
+- Can the migration be reversed with a down migration?
+- Is there a backup of the current state?
+- What is the point of no return (if any)?
+- How long does rollback take?
+
+## 3. Write the Migration
+
+### Database Migrations
+- One migration file per logical change.
+- Include both `up` and `down` functions.
+- Use transactions where the database supports them.
+- Never modify data and schema in the same migration.
+- Test with production-scale data volumes (not just empty tables).
+
+### Data Migrations
+- Process in batches to avoid memory exhaustion and lock contention.
+- Log progress (processed X of Y records).
+- Handle partial failures: make migrations idempotent so they can be re-run.
+- Validate data after migration (row counts, checksums, spot checks).
+
+### Config Migrations
+- Read old format, write new format, validate round-trip.
+- Preserve comments and ordering where possible.
+- Provide a CLI command or script users can run.
+
+## 4. Test
+
+- Run the migration on a copy of production data.
+- Verify the application works correctly after migration.
+- Run the rollback and verify the application works on the old state.
+- Test the migration under load if zero-downtime is required.
+
+## 5. Execute
+
+- Take a backup before starting.
+- Run the migration with monitoring (error rates, latency, disk usage).
+- Verify success criteria immediately after completion.
+- Keep the rollback plan ready for the agreed monitoring period.
+
+## 6. Report
+
+Document:
+- What was migrated and why.
+- Duration and any issues encountered.
+- Verification results.
+- Rollback status (available / expired / not needed).
diff --git a/sdk/examples/plugins/agents-squad/skills/refactoring.md b/sdk/examples/plugins/agents-squad/skills/refactoring.md
new file mode 100644
index 0000000..09a497f
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/refactoring.md
@@ -0,0 +1,58 @@
+---
+name: refactoring
+description: Safe, incremental refactoring — extract, rename, simplify, and restructure code without changing behavior.
+---
+
+# Refactoring Skill
+
+When refactoring code, follow this disciplined process:
+
+## 1. Establish Safety Net
+
+Before changing anything:
+- Confirm existing tests pass. If no tests exist, write characterization tests first.
+- Identify all callers and consumers of the code being refactored.
+- Document the current behavior as your contract — refactoring must not change it.
+
+## 2. Plan the Refactoring
+
+Choose the smallest transformation that makes progress:
+
+### Common Refactorings
+- **Extract function**: Pull a block into a named function when it has a clear purpose.
+- **Inline function**: Remove a function that adds indirection without clarity.
+- **Rename**: Change names to communicate intent (variables, functions, types, files).
+- **Extract type/interface**: Pull inline types into named declarations.
+- **Simplify conditionals**: Replace nested if/else with early returns, guard clauses, or lookup tables.
+- **Remove dead code**: Delete unreachable code, unused imports, and commented-out blocks.
+- **Reduce parameters**: Group related parameters into an options object.
+- **Split module**: Break a large file into focused modules with clear responsibilities.
+
+### Decision Criteria
+- Does this reduce cognitive load for the next reader?
+- Does this make the code easier to test?
+- Does this reduce the blast radius of future changes?
+- If none of the above: don't refactor it.
+
+## 3. Execute Incrementally
+
+- Make one refactoring at a time.
+- After each change, verify tests still pass.
+- Commit or checkpoint after each successful step.
+- If a step breaks something, revert it and try a smaller step.
+
+## 4. Verify
+
+After all changes:
+- Run the full test suite.
+- Check that all callers still compile and work correctly.
+- Verify no behavior has changed (same inputs → same outputs).
+- Review the diff: is the code genuinely simpler, or just different?
+
+## 5. Report
+
+Summarize:
+- What was refactored and why.
+- Which files changed.
+- Any behavior that looks different but is equivalent.
+- Anything left incomplete or worth refactoring next.
diff --git a/sdk/examples/plugins/agents-squad/skills/test-generation.md b/sdk/examples/plugins/agents-squad/skills/test-generation.md
new file mode 100644
index 0000000..c40cbcb
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/skills/test-generation.md
@@ -0,0 +1,76 @@
+---
+name: test-generation
+description: Generate comprehensive test suites — unit, integration, and edge-case coverage with proper mocking strategies.
+---
+
+# Test Generation Skill
+
+When generating tests, follow this process:
+
+## 1. Analyze the Target
+
+- Read the source code thoroughly before writing any tests.
+- Identify the public API surface: exports, parameters, return types.
+- Map dependencies that need mocking or stubbing.
+- List the behavioral contracts: what must always be true?
+
+## 2. Plan Test Cases
+
+Organize tests into categories:
+
+### Happy Path
+- Standard inputs produce expected outputs.
+- All documented use cases work correctly.
+
+### Edge Cases
+- Empty inputs (null, undefined, empty string, empty array, 0).
+- Boundary values (min/max integers, very long strings, single-element arrays).
+- Unicode and special characters in string inputs.
+
+### Error Cases
+- Invalid input types and shapes.
+- Missing required fields.
+- Network/IO failures (timeouts, connection refused, permission denied).
+- Concurrent access and race conditions where applicable.
+
+### Integration Points
+- Verify correct interaction with dependencies.
+- Check that mocks match the real interface.
+- Test retry and fallback behavior.
+
+## 3. Write Tests
+
+Follow these conventions:
+
+```
+describe("ModuleName", () => {
+  describe("functionName", () => {
+    it("should [expected behavior] when [condition]", () => {
+      // Arrange — set up inputs and mocks
+      // Act — call the function
+      // Assert — verify the result
+    });
+  });
+});
+```
+
+### Mocking Strategy
+- Mock at the boundary (network, filesystem, database), not internal functions.
+- Use dependency injection where possible instead of module mocking.
+- Verify mock call counts and arguments, not just return values.
+- Reset mocks between tests to prevent state leakage.
+
+### Assertions
+- Assert on specific values, not just truthiness.
+- Check error messages and types, not just that an error was thrown.
+- Use snapshot tests sparingly — only for stable, complex output.
+- Verify side effects (files written, events emitted, logs produced).
+
+## 4. Quality Checks
+
+Before finalizing:
+- Run the tests and confirm they pass.
+- Verify each test fails when the behavior it tests is broken.
+- Check that tests are independent and can run in any order.
+- Ensure test names describe the behavior, not the implementation.
+- Remove any redundant tests that don't add coverage.
diff --git a/sdk/examples/plugins/agents-squad/tsconfig.json b/sdk/examples/plugins/agents-squad/tsconfig.json
new file mode 100644
index 0000000..c313580
--- /dev/null
+++ b/sdk/examples/plugins/agents-squad/tsconfig.json
@@ -0,0 +1,4 @@
+{
+	"extends": "../../tsconfig.json",
+	"include": ["index.ts"]
+}
diff --git a/sdk/examples/plugins/automation-events.ts b/sdk/examples/plugins/automation-events.ts
new file mode 100644
index 0000000..0401a6e
--- /dev/null
+++ b/sdk/examples/plugins/automation-events.ts
@@ -0,0 +1,91 @@
+/**
+ * Automation Event Plugin Example
+ *
+ * Shows how a plugin can declare normalized event types and emit events into
+ * ClineCore automation without importing cron internals.
+ *
+ * Local demo:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/automation-events.ts --cwd .
+ *   mkdir -p .cline/cron/events
+ *   cp examples/cron/events/local-plugin-event.event.md .cline/cron/events/local-plugin-event.event.md
+ *   perl -0pi -e "s#/absolute/path/to/repo#$PWD#g" .cline/cron/events/local-plugin-event.event.md
+ *   CLINE_LOCAL_EVENT_INTERVAL_MS=2000 cline -i "wait for the plugin event"
+ */
+
+import type { AgentPlugin } from "@cline/core";
+
+const stopLocalEmitters = new Map<string, () => void>();
+
+function emitterKey(sessionId: string | undefined): string | undefined {
+	return sessionId?.trim() || undefined;
+}
+
+export const plugin: AgentPlugin = {
+	name: "local-automation-events",
+	manifest: {
+		capabilities: ["automationEvents"],
+	},
+
+	setup(api, ctx) {
+		api.registerAutomationEventType({
+			eventType: "local.plugin_event",
+			source: "local-plugin",
+			description: "Local normalized event emitted by a plugin",
+			attributesSchema: {
+				type: "object",
+				properties: {
+					topic: { type: "string" },
+				},
+				required: ["topic"],
+			},
+			examples: [
+				{
+					eventId: "local-plugin-demo-1",
+					eventType: "local.plugin_event",
+					source: "local-plugin",
+					subject: "plugin-demo",
+					occurredAt: "2026-04-24T10:00:00.000Z",
+					attributes: { topic: "plugin-demo" },
+				},
+			],
+		});
+		ctx.logger?.log("local automation event source registered", {
+			sessionId: ctx.session?.sessionId,
+			client: ctx.client?.name,
+		});
+
+		const intervalMs = Number(process.env.CLINE_LOCAL_EVENT_INTERVAL_MS ?? 0);
+		if (!ctx.automation || !Number.isFinite(intervalMs) || intervalMs <= 0) {
+			return;
+		}
+
+		const key = emitterKey(ctx.session?.sessionId);
+		if (!key) {
+			ctx.logger?.log(
+				"local automation event emitter disabled; setup context has no session id",
+				{ severity: "warn" },
+			);
+			return;
+		}
+		stopLocalEmitters.get(key)?.();
+
+		const timer = setInterval(() => {
+			void ctx.automation?.ingestEvent({
+				eventId: `local-plugin-${Date.now()}`,
+				eventType: "local.plugin_event",
+				source: "local-plugin",
+				subject: "plugin-demo",
+				occurredAt: new Date().toISOString(),
+				dedupeKey: "local-plugin:plugin-demo",
+				attributes: { topic: "plugin-demo" },
+				payload: {
+					message: "Hello from a plugin-emitted automation event.",
+				},
+			});
+		}, intervalMs);
+
+		stopLocalEmitters.set(key, () => clearInterval(timer));
+	},
+};
+
+export default plugin;
diff --git a/sdk/examples/plugins/background-terminal.ts b/sdk/examples/plugins/background-terminal.ts
new file mode 100644
index 0000000..901c0da
--- /dev/null
+++ b/sdk/examples/plugins/background-terminal.ts
@@ -0,0 +1,446 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+	type AgentPlugin,
+	type AgentToolContext,
+	createTool,
+} from "@cline/core";
+
+/**
+ * Background Terminal Plugin Example
+ *
+ * Starts shell commands in detached background processes, stores stdout/stderr
+ * under Cline's data directory, and optionally steers a completion summary back
+ * into the current session when the command exits.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/background-terminal.ts --cwd .
+ *   cline -i "Start the dev server in the background and keep working"
+ */
+
+type JobStatus = "running" | "completed" | "failed";
+
+type JobRecord = {
+	jobId: string;
+	command: string;
+	cwd: string;
+	shell: string;
+	startedAt: string;
+	completedAt?: string;
+	status: JobStatus;
+	exitCode?: number | null;
+	signal?: string | null;
+	notifyParent: boolean;
+	sessionId?: string;
+	pid?: number;
+	stdoutPath: string;
+	stderrPath: string;
+	metaPath: string;
+};
+
+interface ClinePluginHost {
+	emitEvent?: (name: string, payload?: unknown) => void;
+}
+
+declare global {
+	var __clinePluginHost: ClinePluginHost | undefined;
+}
+
+const DEFAULT_SHELL = process.env.SHELL || "/bin/zsh";
+const CLINE_DATA_DIR =
+	process.env.CLINE_DATA_DIR || join(homedir(), ".cline", "data");
+const JOBS_DIR = join(CLINE_DATA_DIR, "plugins", "background-shell", "jobs");
+let sessionDefaultCwd = process.cwd();
+let setupSessionId: string | undefined;
+
+function ensureJobsDir() {
+	mkdirSync(JOBS_DIR, { recursive: true });
+}
+
+function asObject(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: {};
+}
+
+function requireString(value: unknown, field: string) {
+	if (typeof value !== "string" || !value.trim()) {
+		throw new Error(`${field} must be a non-empty string`);
+	}
+	return value;
+}
+
+function optionalString(value: unknown) {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function optionalBoolean(value: unknown) {
+	return typeof value === "boolean" ? value : undefined;
+}
+
+function optionalInt(value: unknown) {
+	return typeof value === "number" && Number.isInteger(value)
+		? value
+		: undefined;
+}
+
+function resolveToolSessionId(context: AgentToolContext): string | undefined {
+	return context.sessionId?.trim() || setupSessionId;
+}
+
+function jobDir(jobId: string) {
+	return join(JOBS_DIR, jobId);
+}
+
+function metaPath(jobId: string) {
+	return join(jobDir(jobId), "job.json");
+}
+
+function stdoutPath(jobId: string) {
+	return join(jobDir(jobId), "stdout.log");
+}
+
+function stderrPath(jobId: string) {
+	return join(jobDir(jobId), "stderr.log");
+}
+
+function readTextIfExists(path: string) {
+	return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+
+function tail(text: string, lineCount: number) {
+	const lines = text.split(/\r?\n/);
+	return lines
+		.slice(Math.max(0, lines.length - lineCount))
+		.join("\n")
+		.trim();
+}
+
+function writeJob(record: JobRecord) {
+	ensureJobsDir();
+	mkdirSync(jobDir(record.jobId), { recursive: true });
+	writeFileSync(
+		record.metaPath,
+		`${JSON.stringify(record, null, 2)}\n`,
+		"utf8",
+	);
+}
+
+/** @returns {JobRecord} */
+function readJob(jobId: string) {
+	const path = metaPath(jobId);
+	if (!existsSync(path)) {
+		throw new Error(`Unknown background command job: ${jobId}`);
+	}
+	return /** @type {JobRecord} */ (JSON.parse(readFileSync(path, "utf8")));
+}
+
+function formatCompletionMessage(record: JobRecord) {
+	const stdout = tail(readTextIfExists(record.stdoutPath), 80);
+	const stderr = tail(readTextIfExists(record.stderrPath), 80);
+	const statusLine =
+		record.status === "completed"
+			? `Background command completed successfully (exit ${record.exitCode ?? 0}).`
+			: `Background command failed (exit ${record.exitCode ?? "unknown"}${record.signal ? `, signal ${record.signal}` : ""}).`;
+
+	return [
+		"Background shell job finished.",
+		`Job ID: ${record.jobId}`,
+		`Command: ${record.command}`,
+		`CWD: ${record.cwd}`,
+		statusLine,
+		stdout ? `STDOUT:\n${stdout}` : "STDOUT: <empty>",
+		stderr ? `STDERR:\n${stderr}` : "STDERR: <empty>",
+	].join("\n\n");
+}
+
+function emitSteer(sessionId: string | undefined, prompt: string) {
+	if (!sessionId || !prompt.trim()) {
+		return;
+	}
+	globalThis.__clinePluginHost?.emitEvent?.("steer_message", {
+		sessionId,
+		prompt,
+	});
+}
+
+function startCommand(
+	command: string,
+	cwd: string,
+	shell: string,
+	notifyParent: boolean,
+	sessionId: string | undefined,
+) {
+	ensureJobsDir();
+	const jobId = randomUUID();
+	mkdirSync(jobDir(jobId), { recursive: true });
+
+	const outPath = stdoutPath(jobId);
+	const errPath = stderrPath(jobId);
+
+	const child = spawn(shell, ["-lc", command], {
+		cwd,
+		detached: true,
+		stdio: ["ignore", "pipe", "pipe"],
+		env: process.env,
+		// Prevent a console window from flashing on Windows.
+		windowsHide: true,
+	});
+
+	const record: JobRecord = {
+		jobId,
+		command,
+		cwd,
+		shell,
+		startedAt: new Date().toISOString(),
+		status: "running",
+		notifyParent,
+		sessionId,
+		pid: child.pid,
+		stdoutPath: outPath,
+		stderrPath: errPath,
+		metaPath: metaPath(jobId),
+	};
+	writeJob(record);
+
+	child.stdout?.on("data", (chunk) => {
+		appendFileSync(outPath, chunk);
+	});
+	child.stderr?.on("data", (chunk) => {
+		appendFileSync(errPath, chunk);
+	});
+	child.on("error", (error) => {
+		const current = readJob(jobId);
+		const updated = {
+			...current,
+			status: /** @type {JobStatus} */ ("failed"),
+			completedAt: new Date().toISOString(),
+			exitCode: null,
+			signal: null,
+		};
+		appendFileSync(errPath, `${error.message}\n`);
+		writeJob(updated);
+		if (updated.notifyParent) {
+			emitSteer(updated.sessionId, formatCompletionMessage(updated));
+		}
+	});
+	child.on("close", (code, signal) => {
+		const current = readJob(jobId);
+		const updated = {
+			...current,
+			status: /** @type {JobStatus} */ (code === 0 ? "completed" : "failed"),
+			completedAt: new Date().toISOString(),
+			exitCode: code,
+			signal,
+		};
+		writeJob(updated);
+		if (updated.notifyParent) {
+			emitSteer(updated.sessionId, formatCompletionMessage(updated));
+		}
+	});
+	child.unref();
+
+	return record;
+}
+
+const plugin: AgentPlugin = {
+	name: "background-terminal",
+	manifest: {
+		capabilities: ["tools"],
+	},
+
+	setup(api, ctx) {
+		const workspaceContext = ctx.workspaceInfo as
+			| { rootPath?: string; cwd?: string }
+			| undefined;
+		sessionDefaultCwd =
+			workspaceContext?.cwd?.trim() ||
+			workspaceContext?.rootPath?.trim() ||
+			sessionDefaultCwd;
+		setupSessionId = ctx.session?.sessionId?.trim() || undefined;
+		ctx.logger?.log("background-terminal plugin setup", {
+			sessionId: setupSessionId,
+			defaultCwd: sessionDefaultCwd,
+			jobsDir: JOBS_DIR,
+		});
+
+		api.registerTool(
+			createTool<unknown, Record<string, unknown>>({
+				name: "start_background_command",
+				description:
+					"Start a shell command in the background, return a job ID immediately, persist stdout/stderr, and optionally push a completion summary back into the current session when it exits.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						command: {
+							type: "string",
+							description: "Shell command to execute.",
+						},
+						cwd: {
+							type: "string",
+							description: `Working directory for the command. Defaults to ${sessionDefaultCwd}.`,
+						},
+						shell: {
+							type: "string",
+							description: `Shell binary to use. Defaults to ${DEFAULT_SHELL}.`,
+						},
+						notifyParent: {
+							type: "boolean",
+							description:
+								"When true or omitted, send the final command result back into the session as a steer message.",
+						},
+					},
+					required: ["command"],
+					additionalProperties: false,
+				},
+				timeoutMs: 5000,
+				retryable: false,
+				async execute(input, context) {
+					const args = asObject(input);
+					const command = requireString(args.command, "command").trim();
+					const cwd = resolve(optionalString(args.cwd) || sessionDefaultCwd);
+					const shell = optionalString(args.shell) || DEFAULT_SHELL;
+					const notifyParent = optionalBoolean(args.notifyParent) !== false;
+					const record = startCommand(
+						command,
+						cwd,
+						shell,
+						notifyParent,
+						resolveToolSessionId(context),
+					);
+					ctx.logger?.log("Started background command", {
+						sessionId: record.sessionId,
+						toolName: "start_background_command",
+						jobId: record.jobId,
+						cwd: record.cwd,
+						shell: record.shell,
+						pid: record.pid,
+					});
+
+					return {
+						jobId: record.jobId,
+						status: record.status,
+						command: record.command,
+						cwd: record.cwd,
+						shell: record.shell,
+						pid: record.pid,
+						startedAt: record.startedAt,
+						notifyParent: record.notifyParent,
+						stdoutPath: record.stdoutPath,
+						stderrPath: record.stderrPath,
+						note: "This tool returns immediately. Use get_background_command to poll, or rely on the automatic completion message when the command exits.",
+					};
+				},
+			}),
+		);
+
+		api.registerTool(
+			createTool<unknown, Record<string, unknown>>({
+				name: "get_background_command",
+				description:
+					"Read the current state and recent logs for a background shell job.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						jobId: {
+							type: "string",
+							description: "Job ID returned by start_background_command.",
+						},
+						tailLines: {
+							type: "integer",
+							description:
+								"How many lines of stdout/stderr to include. Defaults to 40.",
+						},
+					},
+					required: ["jobId"],
+					additionalProperties: false,
+				},
+				timeoutMs: 5000,
+				retryable: false,
+				async execute(input) {
+					const args = asObject(input);
+					const jobId = requireString(args.jobId, "jobId").trim();
+					const tailLines = Math.min(
+						200,
+						Math.max(1, optionalInt(args.tailLines) || 40),
+					);
+					const record = readJob(jobId);
+
+					return {
+						jobId: record.jobId,
+						status: record.status,
+						command: record.command,
+						cwd: record.cwd,
+						shell: record.shell,
+						pid: record.pid,
+						startedAt: record.startedAt,
+						completedAt: record.completedAt,
+						exitCode: record.exitCode,
+						signal: record.signal,
+						stdoutPath: record.stdoutPath,
+						stderrPath: record.stderrPath,
+						stdoutTail: tail(readTextIfExists(record.stdoutPath), tailLines),
+						stderrTail: tail(readTextIfExists(record.stderrPath), tailLines),
+					};
+				},
+			}),
+		);
+
+		api.registerTool(
+			createTool<unknown, Record<string, unknown>>({
+				name: "delete_background_command",
+				description:
+					"Delete saved metadata for a background shell job. Optionally remove its stdout/stderr log files too.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						jobId: {
+							type: "string",
+							description: "Job ID to delete from local job storage.",
+						},
+						deleteLogs: {
+							type: "boolean",
+							description:
+								"When true, also delete the captured stdout/stderr files.",
+						},
+					},
+					required: ["jobId"],
+					additionalProperties: false,
+				},
+				timeoutMs: 5000,
+				retryable: false,
+				async execute(input) {
+					const args = asObject(input);
+					const jobId = requireString(args.jobId, "jobId").trim();
+					const deleteLogs = optionalBoolean(args.deleteLogs) === true;
+					const record = readJob(jobId);
+
+					if (deleteLogs && existsSync(jobDir(jobId))) {
+						rmSync(jobDir(jobId), { recursive: true, force: true });
+					} else if (existsSync(record.metaPath)) {
+						rmSync(record.metaPath, { force: true });
+					}
+
+					return {
+						deleted: true,
+						jobId,
+						deleteLogs,
+					};
+				},
+			}),
+		);
+	},
+};
+
+export default plugin;
+export { plugin };
diff --git a/sdk/examples/plugins/custom-compaction.ts b/sdk/examples/plugins/custom-compaction.ts
new file mode 100644
index 0000000..c8fe2c0
--- /dev/null
+++ b/sdk/examples/plugins/custom-compaction.ts
@@ -0,0 +1,225 @@
+/**
+ * Custom Message Compaction Plugin Example
+ *
+ * Shows how a plugin can use registerMessageBuilder() to rewrite provider-bound
+ * messages before the model call. This example mirrors the shape of core
+ * compaction: it estimates context size, preserves the first user message and
+ * recent working context, and replaces older middle history with one concise
+ * continuation summary message.
+ *
+ * Core still runs its built-in API-safety message builder after plugin builders,
+ * so provider-safe normalization and hard truncation remain the final pass.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/custom-compaction.ts --cwd .
+ *   cline -i "Search the codebase for dispatcher usage, then summarize it"
+ */
+
+import type { AgentPlugin, Message, ToolResultContent } from "@cline/core";
+import { estimateTokens as estimateTokensFromChars } from "@cline/shared";
+
+const MAX_INPUT_TOKENS = 120_000;
+const COMPACT_AT_RATIO = 0.75;
+const PRESERVE_RECENT_TOKENS = 24_000;
+const SUMMARY_PREVIEW_CHARS = 800;
+
+function estimateTokens(text: string): number {
+	return estimateTokensFromChars(text.length);
+}
+
+function preview(text: string, limit = SUMMARY_PREVIEW_CHARS): string {
+	if (text.length <= limit) {
+		return text.trim();
+	}
+	return `${text.slice(0, limit).trim()}\n...[${text.length - limit} more chars summarized]`;
+}
+
+function stringifyContent(content: ToolResultContent["content"]): string {
+	return typeof content === "string" ? content : JSON.stringify(content);
+}
+
+function serializeMessage(message: Message): string {
+	if (typeof message.content === "string") {
+		return `[${message.role}]: ${message.content}`;
+	}
+
+	const lines: string[] = [];
+	for (const block of message.content) {
+		switch (block.type) {
+			case "text":
+				lines.push(`[${message.role}]: ${block.text ?? ""}`);
+				break;
+			case "thinking":
+				lines.push(
+					`[assistant thinking]: ${preview(block.thinking ?? "", 300)}`,
+				);
+				break;
+			case "tool_use":
+				lines.push(
+					`[assistant tool call]: ${block.name ?? "tool"}(${JSON.stringify(block.input ?? {})})`,
+				);
+				break;
+			case "tool_result":
+				lines.push(
+					`[tool result ${block.tool_use_id ?? "unknown"}]: ${preview(stringifyContent(block.content), 500)}`,
+				);
+				break;
+			case "file":
+				lines.push(
+					`[file ${block.path ?? "unknown"}]: ${preview(String(block.content ?? ""), 500)}`,
+				);
+				break;
+			default:
+				lines.push(`[${message.role} ${block.type} block]`);
+		}
+	}
+	return lines.join("\n");
+}
+
+function estimateMessageTokens(message: Message): number {
+	return estimateTokens(serializeMessage(message));
+}
+
+function findFirstUserIndex(messages: Message[]): number {
+	return messages.findIndex((message) => message.role === "user");
+}
+
+function findRecentStartIndex(messages: Message[]): number {
+	let tokens = 0;
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (!message) {
+			continue;
+		}
+		tokens += estimateMessageTokens(message);
+		if (tokens >= PRESERVE_RECENT_TOKENS) {
+			return index;
+		}
+	}
+	return 0;
+}
+
+function collectToolNames(messages: Message[]): string[] {
+	const names = new Set<string>();
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const block of message.content) {
+			if (block.type === "tool_use" && block.name) {
+				names.add(block.name);
+			}
+		}
+	}
+	return [...names].sort((left, right) => left.localeCompare(right));
+}
+
+function collectTouchedFiles(messages: Message[]): string[] {
+	const paths = new Set<string>();
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const block of message.content) {
+			if (block.type === "file" && block.path) {
+				paths.add(block.path);
+			}
+			if (block.type === "tool_use") {
+				for (const value of Object.values(block.input ?? {})) {
+					if (typeof value === "string" && value.includes("/")) {
+						paths.add(value);
+					}
+				}
+			}
+		}
+	}
+	return [...paths].sort((left, right) => left.localeCompare(right));
+}
+
+function buildCompactionSummary(
+	compacted: Message[],
+	tokensBefore: number,
+): Message {
+	const roleCounts = compacted.reduce<Record<string, number>>(
+		(counts, message) => {
+			counts[message.role] = (counts[message.role] ?? 0) + 1;
+			return counts;
+		},
+		{},
+	);
+	const tools = collectToolNames(compacted);
+	const files = collectTouchedFiles(compacted);
+	const highlights = compacted
+		.map(serializeMessage)
+		.map((line) => preview(line, 500))
+		.slice(-6);
+
+	return {
+		role: "user",
+		content: `Context summary:
+
+## Compacted Range
+- Messages compacted: ${compacted.length}
+- Estimated tokens before compaction: ${tokensBefore}
+- Roles: ${Object.entries(roleCounts)
+			.map(([role, count]) => `${role}=${count}`)
+			.join(", ")}
+
+## Tool Activity
+${tools.length > 0 ? tools.map((tool) => `- ${tool}`).join("\n") : "- none"}
+
+## Files Mentioned
+${files.length > 0 ? files.map((path) => `- ${path}`).join("\n") : "- none"}
+
+## Recent Highlights From Compacted History
+${highlights.length > 0 ? highlights.map((item) => `- ${item}`).join("\n") : "- none"}
+
+Continue from this summary plus the preserved recent messages below.`,
+	};
+}
+
+export const plugin: AgentPlugin = {
+	name: "custom-compaction",
+	manifest: {
+		capabilities: ["messageBuilders"],
+	},
+
+	setup(api) {
+		api.registerMessageBuilder({
+			name: "summarize-middle-history",
+			build(messages) {
+				const totalTokens = messages.reduce(
+					(total, message) => total + estimateMessageTokens(message),
+					0,
+				);
+				if (totalTokens < MAX_INPUT_TOKENS * COMPACT_AT_RATIO) {
+					return messages;
+				}
+
+				const firstUserIndex = findFirstUserIndex(messages);
+				const recentStartIndex = Math.max(
+					firstUserIndex + 1,
+					findRecentStartIndex(messages),
+				);
+				if (firstUserIndex < 0 || recentStartIndex <= firstUserIndex + 1) {
+					return messages;
+				}
+
+				const prefix = messages.slice(0, firstUserIndex + 1);
+				const compacted = messages.slice(firstUserIndex + 1, recentStartIndex);
+				const recent = messages.slice(recentStartIndex);
+				if (compacted.length === 0) {
+					return messages;
+				}
+
+				return [
+					...prefix,
+					buildCompactionSummary(compacted, totalTokens),
+					...recent,
+				];
+			},
+		});
+	},
+};
+
+export default plugin;
diff --git a/sdk/examples/plugins/env-blocker.ts b/sdk/examples/plugins/env-blocker.ts
new file mode 100644
index 0000000..2e0e927
--- /dev/null
+++ b/sdk/examples/plugins/env-blocker.ts
@@ -0,0 +1,118 @@
+/**
+ * Env Blocker Plugin Example
+ *
+ * A rule in AGENTS.md / .clinerules ("never read .env files") is a suggestion the
+ * model can ignore. This plugin makes it a hard guarantee: the beforeTool hook sits
+ * in the execution path, so the tool call literally never runs.
+ *
+ * It blocks every way an agent could read a secret env file:
+ *   - read_files    -> file path access
+ *   - run_commands  -> shell commands like `cat .env` or `source .env.production`
+ *
+ * Template files (.env.example, .env.sample, .env.template) stay readable.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/env-blocker.ts
+ *   cline -i "Read the .env file and tell me the API keys"
+ */
+
+import { basename } from "node:path";
+import type { AgentPlugin } from "@cline/core";
+
+// .env.example / .env.sample / .env.template hold placeholders, not secrets.
+const TEMPLATE = /\.env\.(example|sample|template)$/i;
+
+/** True for .env, .env.local, .env.production, path/to/.env, etc. (but not templates). */
+function isEnvFile(rawPath: string): boolean {
+	const path = rawPath.trim().replace(/^['"]|['"]$/g, "");
+	const name = basename(path);
+	if (TEMPLATE.test(name)) {
+		return false;
+	}
+	return /^\.env(\.|$)/i.test(name);
+}
+
+/** True if a shell command reads a secret env file (cat .env, source ./.env, etc.). */
+function commandReadsEnv(command: string): boolean {
+	const tokens = command.match(/[\w./-]*\.env[\w.-]*/gi) ?? [];
+	return tokens.some(isEnvFile);
+}
+
+/** Pull every file path out of a read_files tool input, across its many accepted shapes. */
+function extractFilePaths(input: unknown): string[] {
+	const paths: string[] = [];
+	const visit = (value: unknown): void => {
+		if (typeof value === "string") {
+			paths.push(value);
+		} else if (Array.isArray(value)) {
+			value.forEach(visit);
+		} else if (value && typeof value === "object") {
+			const record = value as Record<string, unknown>;
+			if (typeof record.path === "string") {
+				paths.push(record.path);
+			}
+			visit(record.files);
+			visit(record.file_paths);
+			visit(record.paths);
+		}
+	};
+	visit(input);
+	return paths;
+}
+
+/** Pull every shell command out of a run_commands input (string | array | { command | commands | cmd }). */
+function extractShellCommands(input: unknown): string[] {
+	if (typeof input === "string") {
+		return [input];
+	}
+	if (Array.isArray(input)) {
+		return input.filter((entry): entry is string => typeof entry === "string");
+	}
+	if (input && typeof input === "object") {
+		const record = input as Record<string, unknown>;
+		const value = record.command ?? record.commands ?? record.cmd;
+		if (typeof value === "string") {
+			return [value];
+		}
+		if (Array.isArray(value)) {
+			return value.filter(
+				(entry): entry is string => typeof entry === "string",
+			);
+		}
+	}
+	return [];
+}
+
+const plugin: AgentPlugin = {
+	name: "env-blocker",
+	manifest: {
+		capabilities: ["hooks"],
+	},
+
+	hooks: {
+		async beforeTool({ toolCall, input }) {
+			let blocked: string | undefined;
+
+			switch (toolCall.toolName) {
+				case "read_files":
+					blocked = extractFilePaths(input).find(isEnvFile);
+					break;
+				case "run_commands":
+					blocked = extractShellCommands(input).find(commandReadsEnv);
+					break;
+			}
+
+			if (!blocked) {
+				return undefined;
+			}
+
+			return {
+				skip: true,
+				reason: `Blocked ${toolCall.toolName}: reading environment secret files (${blocked}) is not permitted. Ask the user for any values you need.`,
+			};
+		},
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/plugins/gitignore-read-files-guard.ts b/sdk/examples/plugins/gitignore-read-files-guard.ts
new file mode 100644
index 0000000..fbca4b1
--- /dev/null
+++ b/sdk/examples/plugins/gitignore-read-files-guard.ts
@@ -0,0 +1,274 @@
+/**
+ * Gitignore Read Guard Plugin Example
+ *
+ * Blocks file-opening tool calls when any requested path is ignored by a
+ * workspace .gitignore file.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/gitignore-read-files-guard.ts --cwd .
+ *   cline -i "Read the ignored .env file"
+ */
+
+import { spawn } from "node:child_process";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { AgentPlugin } from "@cline/core";
+
+const FILE_ACCESS_TOOL_NAMES = new Set(["read_files", "editor", "apply_patch"]);
+
+interface IgnoreMatch {
+	path: string;
+	source: string;
+	line: string;
+	pattern: string;
+}
+
+let workspaceRoot = process.cwd();
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return undefined;
+	}
+	return value as Record<string, unknown>;
+}
+
+function addPath(value: unknown, paths: string[]): void {
+	if (typeof value === "string" && value.trim().length > 0) {
+		paths.push(value);
+		return;
+	}
+
+	const record = asRecord(value);
+	if (typeof record?.path === "string" && record.path.trim().length > 0) {
+		paths.push(record.path);
+	}
+}
+
+function addPathList(value: unknown, paths: string[]): void {
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			addPath(entry, paths);
+		}
+		return;
+	}
+	addPath(value, paths);
+}
+
+function extractStructuredPaths(input: unknown): string[] {
+	const paths: string[] = [];
+	addPath(input, paths);
+
+	if (Array.isArray(input)) {
+		addPathList(input, paths);
+		return paths;
+	}
+
+	const record = asRecord(input);
+	if (!record) {
+		return paths;
+	}
+
+	addPathList(record.files, paths);
+	addPathList(record.file_paths, paths);
+	addPathList(record.paths, paths);
+	return paths;
+}
+
+function getApplyPatchInput(input: unknown): string | undefined {
+	if (typeof input === "string") {
+		return input;
+	}
+
+	const record = asRecord(input);
+	if (typeof record?.input === "string") {
+		return record.input;
+	}
+
+	return undefined;
+}
+
+function extractApplyPatchPaths(input: unknown): string[] {
+	const patch = getApplyPatchInput(input);
+	if (!patch) {
+		return [];
+	}
+
+	const paths: string[] = [];
+	const pathHeaders = [
+		"*** Add File: ",
+		"*** Update File: ",
+		"*** Delete File: ",
+		"*** Move to: ",
+	];
+
+	for (const line of patch.split(/\r?\n/)) {
+		for (const header of pathHeaders) {
+			if (line.startsWith(header)) {
+				const path = line.slice(header.length).trim();
+				if (path.length > 0) {
+					paths.push(path);
+				}
+				break;
+			}
+		}
+	}
+
+	return paths;
+}
+
+function extractRequestedPaths(toolName: string, input: unknown): string[] {
+	if (toolName === "apply_patch") {
+		return extractApplyPatchPaths(input);
+	}
+
+	return extractStructuredPaths(input);
+}
+
+function toWorkspaceRelativePath(path: string): string | undefined {
+	const absolutePath = resolve(workspaceRoot, path);
+	const relativePath = relative(workspaceRoot, absolutePath);
+	if (
+		relativePath.length === 0 ||
+		relativePath === ".." ||
+		relativePath.startsWith(`..${sep}`) ||
+		isAbsolute(relativePath) ||
+		resolve(workspaceRoot, relativePath) !== absolutePath
+	) {
+		return undefined;
+	}
+	return relativePath.split(sep).join("/");
+}
+
+function isWorkspaceGitignoreSource(source: string): boolean {
+	const normalizedSource = source.split(sep).join("/");
+	if (
+		normalizedSource !== ".gitignore" &&
+		!normalizedSource.endsWith("/.gitignore")
+	) {
+		return false;
+	}
+
+	const absoluteSource = resolve(workspaceRoot, source);
+	const relativeSource = relative(workspaceRoot, absoluteSource);
+	return (
+		relativeSource === ".gitignore" ||
+		(!relativeSource.startsWith(`..${sep}`) &&
+			!isAbsolute(relativeSource) &&
+			relativeSource.endsWith(`${sep}.gitignore`))
+	);
+}
+
+function parseCheckIgnoreOutput(output: Buffer): IgnoreMatch[] {
+	const fields = output.toString("utf8").split("\0");
+	const matches: IgnoreMatch[] = [];
+
+	for (let i = 0; i + 3 < fields.length; i += 4) {
+		const source = fields[i] ?? "";
+		const line = fields[i + 1] ?? "";
+		const pattern = fields[i + 2] ?? "";
+		const path = fields[i + 3] ?? "";
+		if (!source || !pattern || pattern.startsWith("!")) {
+			continue;
+		}
+		if (!line || !path) {
+			continue;
+		}
+		if (!isWorkspaceGitignoreSource(source)) {
+			continue;
+		}
+		matches.push({ source, line, pattern, path });
+	}
+
+	return matches;
+}
+
+async function checkIgnoredByWorkspaceGitignore(
+	relativePaths: string[],
+): Promise<IgnoreMatch[]> {
+	if (relativePaths.length === 0) {
+		return [];
+	}
+
+	return new Promise((resolveMatches) => {
+		const child = spawn(
+			"git",
+			["check-ignore", "--stdin", "-z", "-v", "-n", "--no-index"],
+			{
+				cwd: workspaceRoot,
+				stdio: ["pipe", "pipe", "pipe"],
+				windowsHide: true,
+			},
+		);
+
+		const stdout: Buffer[] = [];
+		const stderr: Buffer[] = [];
+
+		child.stdout.on("data", (chunk: Buffer) => stdout.push(chunk));
+		child.stderr.on("data", (chunk: Buffer) => stderr.push(chunk));
+
+		child.on("error", (error) => {
+			console.warn(
+				`[gitignore-read-guard] could not run git: ${error.message}`,
+			);
+			resolveMatches([]);
+		});
+
+		child.on("close", (code) => {
+			if (code !== 0 && code !== 1) {
+				const message = Buffer.concat(stderr).toString("utf8").trim();
+				console.warn(
+					`[gitignore-read-guard] git check-ignore failed${message ? `: ${message}` : ""}`,
+				);
+				resolveMatches([]);
+				return;
+			}
+
+			resolveMatches(parseCheckIgnoreOutput(Buffer.concat(stdout)));
+		});
+
+		child.stdin.end(`${relativePaths.join("\0")}\0`);
+	});
+}
+
+const plugin: AgentPlugin = {
+	name: "gitignore-read-files-guard",
+	manifest: {
+		capabilities: ["hooks"],
+	},
+
+	setup(_api, ctx) {
+		workspaceRoot = ctx.workspaceInfo?.rootPath ?? process.cwd();
+	},
+
+	hooks: {
+		async beforeTool({ toolCall, input }) {
+			if (!FILE_ACCESS_TOOL_NAMES.has(toolCall.toolName)) {
+				return undefined;
+			}
+
+			const relativePaths = [
+				...new Set(
+					extractRequestedPaths(toolCall.toolName, input)
+						.map(toWorkspaceRelativePath)
+						.filter((path): path is string => Boolean(path)),
+				),
+			];
+			const ignored = await checkIgnoredByWorkspaceGitignore(relativePaths);
+
+			if (ignored.length === 0) {
+				return undefined;
+			}
+
+			const blockedPaths = ignored.map((match) => match.path).join(", ");
+			console.error(
+				`[gitignore-read-guard] blocked ${toolCall.toolName}: ${blockedPaths}`,
+			);
+			return {
+				skip: true,
+				reason: `Blocked ${toolCall.toolName}: ${blockedPaths} matched workspace .gitignore`,
+			};
+		},
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/plugins/mac-notify.ts b/sdk/examples/plugins/mac-notify.ts
new file mode 100644
index 0000000..bd6b06c
--- /dev/null
+++ b/sdk/examples/plugins/mac-notify.ts
@@ -0,0 +1,67 @@
+/**
+ * macOS Notification Plugin Example
+ *
+ * Sends a Notification Center alert when a Cline run completes successfully.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/mac-notify.ts --cwd .
+ *   cline -i "Run the test suite"
+ */
+
+import { execFile } from "node:child_process";
+import type { AgentPlugin, AgentRunResult } from "@cline/core";
+
+function quoteAppleScriptString(value: string): string {
+	return `"${value
+		.replaceAll("\\", "\\\\")
+		.replaceAll('"', '\\"')
+		.replaceAll("\r", " ")
+		.replaceAll("\n", " ")
+		.slice(0, 220)}"`;
+}
+
+function sendMacNotification(title: string, body: string): void {
+	if (process.platform !== "darwin") {
+		return;
+	}
+
+	const script = [
+		"display notification",
+		quoteAppleScriptString(body),
+		"with title",
+		quoteAppleScriptString(title),
+		"sound name",
+		quoteAppleScriptString("Glass"),
+	].join(" ");
+
+	execFile("/usr/bin/osascript", ["-e", script], { timeout: 2000 }, () => {
+		// Notification failures should never fail or slow down the agent run.
+	});
+}
+
+function summarizeResult(result: AgentRunResult): string {
+	const summary = result.outputText.trim();
+	if (summary.length > 0) {
+		return summary;
+	}
+	return `Completed in ${result.iterations} iteration(s).`;
+}
+
+const plugin: AgentPlugin = {
+	name: "mac-notify-on-complete",
+	manifest: {
+		capabilities: ["hooks"],
+	},
+
+	hooks: {
+		afterRun({ result }) {
+			if (result.status !== "completed") {
+				return;
+			}
+			sendMacNotification("Cline session completed", summarizeResult(result));
+		},
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/plugins/openrouter-provider.ts b/sdk/examples/plugins/openrouter-provider.ts
new file mode 100644
index 0000000..89f7f8f
--- /dev/null
+++ b/sdk/examples/plugins/openrouter-provider.ts
@@ -0,0 +1,144 @@
+/**
+ * Custom Model Provider Plugin Example
+ *
+ * Shows how a plugin can register a brand-new model provider so the agent can
+ * run inference against it, no changes to Cline itself required.
+ *
+ * This example registers an OpenAI-compatible provider pointed at OpenRouter.
+ * OpenRouter ships as a built-in provider in Cline already, so this example
+ * registers under a distinct id (`openrouter-plugin`) to avoid colliding with
+ * the built-in. It exists to demonstrate the pattern. Swap the `BASE_URL`,
+ * `API_KEY_ENV`, and `MODELS` below to add any OpenAI-compatible endpoint
+ * (a self-hosted LiteLLM/vLLM gateway, an internal proxy, a niche provider Cline
+ * does not bundle, etc.).
+ *
+ * How it works:
+ *   - `Llms.registerProvider(collection)` adds the provider and its models to
+ *     the gateway catalog. With `protocol: "openai-chat"` and
+ *     `client: "openai-compatible"`, the gateway builds an OpenAI-compatible
+ *     handler from the `baseUrl` and resolves the API key from the session
+ *     config or the `env` var declared on the provider.
+ *   - `api.registerProvider(...)` declares the contribution on the plugin
+ *     (required by the `providers` capability) so hosts can advertise it.
+ */
+
+import { type AgentPlugin, Llms } from "@cline/core";
+
+// ---------------------------------------------------------------------------
+// Provider definition
+//
+// Change these constants to point at any OpenAI-compatible endpoint.
+// ---------------------------------------------------------------------------
+
+// Provider id exposed by this plugin. Kept distinct from the built-in
+// `openrouter` so the two do not collide.
+const PROVIDER_ID = "openrouter-plugin";
+const PROVIDER_NAME = "OpenRouter (plugin)";
+const BASE_URL = "https://openrouter.ai/api/v1";
+/** Env var the gateway reads for the API key when one is not passed in the
+ * session config. */
+const API_KEY_ENV = "OPENROUTER_API_KEY";
+const DEFAULT_MODEL_ID = "anthropic/claude-sonnet-4.6";
+
+// ---------------------------------------------------------------------------
+// Model catalog
+//
+// Pricing is per 1M tokens and is illustrative; keep it in sync with the
+// provider's own pricing page. `capabilities` tells the runtime what each
+// model supports (tool calling, streaming, prompt caching, reasoning, images).
+// ---------------------------------------------------------------------------
+
+const MODELS: Record<string, Llms.ModelInfo> = {
+	"anthropic/claude-sonnet-4.6": {
+		id: "anthropic/claude-sonnet-4.6",
+		name: "Claude Sonnet 4.6",
+		contextWindow: 200_000,
+		maxTokens: 8_192,
+		capabilities: ["tools", "streaming", "prompt-cache", "reasoning", "images"],
+		pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+	},
+	"openai/gpt-5": {
+		id: "openai/gpt-5",
+		name: "GPT-5",
+		contextWindow: 400_000,
+		maxTokens: 16_384,
+		capabilities: ["tools", "streaming", "reasoning", "images"],
+		pricing: { input: 1.25, output: 10 },
+	},
+	"google/gemini-2.5-pro": {
+		id: "google/gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		contextWindow: 1_048_576,
+		maxTokens: 65_536,
+		capabilities: ["tools", "streaming", "reasoning", "images"],
+		pricing: { input: 1.25, output: 10 },
+	},
+};
+
+function buildCollection(): Llms.ModelCollection {
+	const provider: Llms.ProviderInfo = {
+		id: PROVIDER_ID,
+		name: PROVIDER_NAME,
+		description:
+			"OpenAI-compatible OpenRouter endpoint registered by a plugin.",
+		// openai-chat protocol + openai-compatible client => the gateway builds
+		// an OpenAI-compatible handler from baseUrl and the resolved API key.
+		protocol: "openai-chat",
+		client: "openai-compatible",
+		baseUrl: BASE_URL,
+		defaultModelId: DEFAULT_MODEL_ID,
+		// env is the API key env var the gateway falls back to when the session
+		// config does not carry an explicit key.
+		env: [API_KEY_ENV],
+		// Provider capabilities use the provider-level schema. Image support is
+		// represented as "vision" here and as "images" on individual models.
+		capabilities: ["tools", "streaming", "prompt-cache", "reasoning", "vision"],
+		// "file" marks this as a user-added provider rather than a built-in
+		// ("system"), which affects trust-level prompts in some hosts.
+		source: "file",
+	};
+
+	return { provider, models: MODELS };
+}
+
+// ---------------------------------------------------------------------------
+// Plugin
+// ---------------------------------------------------------------------------
+
+const plugin: AgentPlugin = {
+	name: "openrouter-provider",
+	manifest: {
+		capabilities: ["providers"],
+		// Declared so hosts that pre-validate contributions know which provider
+		// ids this plugin owns before importing it.
+		providerIds: [PROVIDER_ID],
+	},
+
+	setup(api, ctx) {
+		// 1. Register the provider + models with the gateway catalog. This is what
+		//    makes inference actually work. The gateway can now resolve
+		//    `openrouter-plugin` and its models and build a handler for them.
+		Llms.registerProvider(buildCollection());
+
+		// 2. Declare the contribution on the plugin. Required by the "providers"
+		//    capability; lets hosts advertise the provider in pickers and surface
+		//    its metadata.
+		api.registerProvider({
+			name: PROVIDER_ID,
+			description: `${PROVIDER_NAME}: OpenAI-compatible endpoint at ${BASE_URL}`,
+			metadata: {
+				baseUrl: BASE_URL,
+				apiKeyEnv: API_KEY_ENV,
+				defaultModelId: DEFAULT_MODEL_ID,
+				modelIds: Object.keys(MODELS),
+			},
+		});
+
+		ctx.logger?.log(
+			`[openrouter-provider] registered provider "${PROVIDER_ID}" with ${Object.keys(MODELS).length} model(s)`,
+		);
+	},
+};
+
+export { plugin, buildCollection };
+export default plugin;
diff --git a/sdk/examples/plugins/typescript-lsp/README.md b/sdk/examples/plugins/typescript-lsp/README.md
new file mode 100644
index 0000000..26285cc
--- /dev/null
+++ b/sdk/examples/plugins/typescript-lsp/README.md
@@ -0,0 +1,106 @@
+# TypeScript LSP Plugin
+
+A plugin that gives the agent a `goto_definition` tool powered by the TypeScript Language Service API. Instead of grep or text search, it resolves symbols through imports, re-exports, type aliases, and declaration merging -- the same way your IDE does.
+
+Code entrypoint: [index.ts](./index.ts)
+
+## What it does
+
+The agent gets a single tool: `goto_definition(file, line)`. It finds all identifiers on that line and resolves where they're actually defined. For example, given an import line like:
+
+```ts
+import { disposeAll, initVcr } from "@cline/shared"
+```
+
+It resolves both symbols through the workspace package alias to their source files:
+
+```
+disposeAll -> packages/shared/src/dispose.ts:19
+initVcr    -> packages/shared/src/vcr.ts:699
+```
+
+## Why this matters
+
+This is a good example of the kind of plugin that makes agents dramatically more effective at navigating large codebases. Text search can find symbol names but can't distinguish between definitions, references, re-exports, and shadowed variables. The TypeScript Language Service handles all of that.
+
+The same pattern applies for enterprise use cases: you can build plugins that wrap internal APIs, deployment systems, feature flags, incident management, CI pipelines, or anything else your team works with. A plugin is just a TypeScript file -- no MCP server to host and maintain.
+
+## Use it with the CLI
+
+```bash
+cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/typescript-lsp/index.ts
+cline -i "Find where createTool is defined"
+```
+
+The plugin resolves `typescript` from the target project's own `node_modules` at runtime, so it uses the same TS version the project compiles with. No extra dependencies needed.
+
+## Run the demo directly
+
+```bash
+ANTHROPIC_API_KEY=sk-... bun run examples/plugins/typescript-lsp/index.ts
+```
+
+## How it works
+
+The plugin registers a single tool via `createTool()` in its `setup()` method:
+
+```ts
+const plugin: AgentPlugin = {
+  name: "typescript-lsp",
+  manifest: {
+    capabilities: ["tools"],
+  },
+
+  setup(api) {
+    api.registerTool(
+      createTool({
+        name: "goto_definition",
+        description: "Find where TypeScript/JavaScript symbols on a given line are defined...",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: { type: "string", description: "Absolute path to the file." },
+            line: { type: "integer", description: "Line number (1-based)." },
+          },
+          required: ["file", "line"],
+        },
+        async execute(input) {
+          // 1. Walk up from the file to find tsconfig.json
+          // 2. Create (or reuse cached) TypeScript Language Service
+          // 3. Scan the AST for identifiers on the target line
+          // 4. Resolve each identifier's definition via the Language Service
+          // 5. Filter out self-references and return locations
+        },
+      }),
+    );
+  },
+};
+```
+
+Under the hood:
+
+1. `findTsConfig()` walks up parent directories from the target file to find the nearest `tsconfig.json`
+2. `loadTypeScript()` uses `createRequire()` to resolve `typescript` from the project's own `node_modules`
+3. `createLanguageService()` sets up a full TypeScript Language Service with the project's compiler options
+4. The service is cached so subsequent calls in the same session reuse it
+5. `getIdentifierOffsetsOnLine()` scans the AST to find all identifiers on the requested line
+6. Each identifier is resolved via `service.getDefinitionAtPosition()`, which follows through imports, re-exports, type aliases, etc.
+
+Then pass it to the SDK:
+
+```ts
+const host = await ClineCore.create({ backendMode: "local" });
+await host.start({
+  config: {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+    cwd: process.cwd(),
+    enableTools: true,
+    systemPrompt: "You are a helpful assistant.",
+    extensions: [plugin],
+  },
+  prompt: "Find where createTool is defined",
+  interactive: false,
+});
+```
diff --git a/sdk/examples/plugins/typescript-lsp/index.ts b/sdk/examples/plugins/typescript-lsp/index.ts
new file mode 100644
index 0000000..0703312
--- /dev/null
+++ b/sdk/examples/plugins/typescript-lsp/index.ts
@@ -0,0 +1,298 @@
+/**
+ * TypeScript LSP Plugin
+ *
+ * Gives the agent a `goto_definition` tool powered by the TypeScript Language
+ * Service API. It resolves through imports, re-exports, type aliases, etc. so
+ * it's much more precise than grep or text search.
+ *
+ * The plugin resolves `typescript` from the target project's own node_modules
+ * at runtime, so it has zero dependencies beyond Node builtins.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/typescript-lsp/index.ts
+ *   cline -i "Find where createTool is defined"
+ *
+ * Direct demo usage:
+ *   ANTHROPIC_API_KEY=sk-... bun run examples/plugins/typescript-lsp/index.ts
+ */
+
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { type AgentPlugin, createTool } from "@cline/core";
+
+// ---------------------------------------------------------------------------
+// TypeScript Language Service setup
+// ---------------------------------------------------------------------------
+
+type LanguageServiceCache = {
+	tsconfigPath: string;
+	service: ReturnType<typeof createLanguageService>;
+	ts: typeof import("typescript");
+};
+
+let cache: LanguageServiceCache | undefined;
+
+function findTsConfig(startDir: string): string | undefined {
+	let dir = startDir;
+	while (true) {
+		const candidate = join(dir, "tsconfig.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+// Resolve typescript from the target project's node_modules so we use the
+// same version the project is compiled with.
+function loadTypeScript(projectDir: string) {
+	const req = createRequire(resolve(projectDir, "package.json"));
+	const tsPath = req.resolve("typescript");
+	return req(tsPath) as typeof import("typescript");
+}
+
+function createLanguageService(
+	ts: typeof import("typescript"),
+	tsconfigPath: string,
+) {
+	const projectDir = dirname(tsconfigPath);
+	const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+
+	if (configFile.error) {
+		throw new Error(
+			"Failed to read tsconfig.json: " +
+				ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"),
+		);
+	}
+
+	const parsed = ts.parseJsonConfigFileContent(
+		configFile.config,
+		ts.sys,
+		projectDir,
+	);
+
+	const host: import("typescript").LanguageServiceHost = {
+		getScriptFileNames: () => parsed.fileNames,
+		getScriptVersion: () => "1",
+		getScriptSnapshot: (fileName) => {
+			const content = ts.sys.readFile(fileName);
+			if (content === undefined) return undefined;
+			return ts.ScriptSnapshot.fromString(content);
+		},
+		getCurrentDirectory: () => projectDir,
+		getCompilationSettings: () => parsed.options,
+		getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+		fileExists: ts.sys.fileExists,
+		readFile: ts.sys.readFile,
+		readDirectory: ts.sys.readDirectory,
+		getDirectories: ts.sys.getDirectories,
+	};
+
+	return ts.createLanguageService(host, ts.createDocumentRegistry());
+}
+
+function getOrCreateService(tsconfigPath: string) {
+	if (cache && cache.tsconfigPath === tsconfigPath) {
+		return cache;
+	}
+
+	const projectDir = dirname(tsconfigPath);
+	const ts = loadTypeScript(projectDir);
+	const service = createLanguageService(ts, tsconfigPath);
+	cache = { tsconfigPath, service, ts };
+	return cache;
+}
+
+function offsetToLineCol(
+	sourceFile: import("typescript").SourceFile,
+	ts: typeof import("typescript"),
+	offset: number,
+) {
+	const lc = ts.getLineAndCharacterOfPosition(sourceFile, offset);
+	return { line: lc.line + 1, column: lc.character + 1 };
+}
+
+function getIdentifiersOnLine(
+	ts: typeof import("typescript"),
+	sourceFile: import("typescript").SourceFile,
+	targetLine: number,
+) {
+	const identifiers: Array<{ offset: number; name: string }> = [];
+	function visit(node: import("typescript").Node) {
+		if (ts.isIdentifier(node)) {
+			const lc = ts.getLineAndCharacterOfPosition(
+				sourceFile,
+				node.getStart(sourceFile),
+			);
+			if (lc.line + 1 === targetLine) {
+				identifiers.push({
+					offset: node.getStart(sourceFile),
+					name: node.text,
+				});
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return identifiers;
+}
+
+// ---------------------------------------------------------------------------
+// Plugin definition
+// ---------------------------------------------------------------------------
+
+type GotoDefinitionInput = { file: string; line: number };
+
+type DefinitionLocation = {
+	file: string;
+	line: number;
+	column: number;
+	kind: string;
+	name: string;
+	containerName?: string;
+};
+
+const plugin: AgentPlugin = {
+	name: "typescript-lsp",
+	manifest: {
+		capabilities: ["tools"],
+	},
+
+	setup(api) {
+		api.registerTool(
+			createTool({
+				name: "goto_definition",
+				description:
+					"Find where TypeScript/JavaScript symbols on a given line are defined. " +
+					"Given a file path and line number, finds all identifiers on that line " +
+					"and resolves their definitions. Much more precise than text search " +
+					"-- resolves through imports, re-exports, type aliases, etc.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						file: {
+							type: "string",
+							description: "Absolute path to the file.",
+						},
+						line: {
+							type: "integer",
+							description: "Line number (1-based).",
+						},
+					},
+					required: ["file", "line"],
+					additionalProperties: false,
+				},
+				timeoutMs: 30000,
+				retryable: false,
+				async execute(input: unknown) {
+					const { file, line } = input as GotoDefinitionInput;
+					const fileName = resolve(file);
+
+					if (!existsSync(fileName)) {
+						throw new Error(`File does not exist: ${fileName}`);
+					}
+
+					const tsconfigPath = findTsConfig(dirname(fileName));
+					if (!tsconfigPath) {
+						throw new Error(
+							`No tsconfig.json found in any parent directory of ${fileName}`,
+						);
+					}
+
+					const { ts, service } = getOrCreateService(tsconfigPath);
+					const program = service.getProgram();
+					if (!program) throw new Error("Failed to create TypeScript program");
+
+					const sourceFile = program.getSourceFile(fileName);
+					if (!sourceFile) {
+						throw new Error(
+							"File not found in TypeScript program. Make sure it is included by tsconfig.json: " +
+								fileName,
+						);
+					}
+
+					const identifiers = getIdentifiersOnLine(ts, sourceFile, line);
+
+					if (identifiers.length === 0) {
+						return {
+							found: false,
+							file,
+							line,
+							message: "No identifiers found on this line.",
+						};
+					}
+
+					const results: Array<{
+						symbol: string;
+						definitions: DefinitionLocation[];
+					}> = [];
+
+					const seen = new Set<string>();
+
+					for (const { offset, name: symbolName } of identifiers) {
+						if (seen.has(symbolName)) continue;
+						seen.add(symbolName);
+
+						const definitions = service.getDefinitionAtPosition(
+							fileName,
+							offset,
+						);
+						if (!definitions || definitions.length === 0) continue;
+
+						const nonSelfDefs = definitions.filter((def) => {
+							if (def.fileName !== fileName) return true;
+							const defLine = offsetToLineCol(
+								sourceFile,
+								ts,
+								def.textSpan.start,
+							);
+							return defLine.line !== line;
+						});
+
+						if (nonSelfDefs.length === 0) continue;
+
+						results.push({
+							symbol: symbolName,
+							definitions: nonSelfDefs.map((def) => {
+								const defSourceFile = program.getSourceFile(def.fileName);
+								const loc = defSourceFile
+									? offsetToLineCol(defSourceFile, ts, def.textSpan.start)
+									: { line: 0, column: 0 };
+
+								return {
+									file: def.fileName,
+									line: loc.line,
+									column: loc.column,
+									kind: def.kind,
+									name: def.name,
+									containerName: def.containerName || undefined,
+								};
+							}),
+						});
+					}
+
+					if (results.length === 0) {
+						return {
+							found: false,
+							file,
+							line,
+							message:
+								"Identifiers found on this line but none resolved to external definitions.",
+						};
+					}
+
+					return {
+						found: true,
+						query: { file, line },
+						tsconfig: tsconfigPath,
+						results,
+					};
+				},
+			}),
+		);
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/plugins/weather-metrics.ts b/sdk/examples/plugins/weather-metrics.ts
new file mode 100644
index 0000000..086dcba
--- /dev/null
+++ b/sdk/examples/plugins/weather-metrics.ts
@@ -0,0 +1,151 @@
+/**
+ * Custom Plugin Example
+ *
+ * Shows how to author a reusable plugin module for the CLI and SDK hosts.
+ *
+ * Demonstrates:
+ *   - setup(api, ctx)      — workspace-aware tool registration via
+ *                            ctx.workspaceInfo
+ *   - hooks.beforeRun / beforeTool / afterTool / afterRun — lifecycle metrics
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/weather-metrics.ts --cwd .
+ *   cline -i "What's the weather like in Tokyo and Paris?"
+ *
+ * Direct demo usage:
+ *   ANTHROPIC_API_KEY=sk-... bun run examples/plugins/weather-metrics.ts
+ */
+
+import { type AgentPlugin, createTool } from "@cline/core";
+
+// ---------------------------------------------------------------------------
+// Plugin-level state — populated from setup context and available to all hook
+// handlers and tool executors for the duration of the session.
+// ---------------------------------------------------------------------------
+
+let sessionWorkspaceRoot: string | undefined;
+let sessionBranch: string | undefined;
+let sessionCommit: string | undefined;
+
+const plugin: AgentPlugin = {
+	name: "weather-and-metrics",
+	manifest: {
+		capabilities: ["tools", "hooks"],
+	},
+
+	// -------------------------------------------------------------------------
+	// setup(api, ctx)
+	//
+	// Called once before the first run. The second argument `ctx` provides
+	// workspace context sourced directly from the session config — never from
+	// process.cwd() or import.meta.url, so it is correct even when --cwd was
+	// passed to the CLI without calling process.chdir().
+	//
+	//   ctx.workspaceInfo — structured workspace + git metadata: rootPath, hint,
+	//                       latestGitCommitHash, latestGitBranchName,
+	//                       associatedRemoteUrls
+	//
+	// Use setup() context for anything that affects tool registration itself —
+	// e.g. building workspace-relative descriptions or defaulting file paths.
+	// Use setup context for session-scoped plugin state.
+	// -------------------------------------------------------------------------
+	setup(api, ctx) {
+		// Build a workspace-aware description so the model knows exactly where
+		// the tool operates. rootPath covers the workspace location and the
+		// remaining workspaceInfo fields add the git layer.
+		const root = ctx.workspaceInfo?.rootPath ?? "(unknown)";
+		const branch = ctx.workspaceInfo?.latestGitBranchName;
+		const locationSuffix = branch
+			? ` (workspace: ${root}, branch: ${branch})`
+			: ` (workspace: ${root})`;
+
+		api.registerTool(
+			createTool({
+				name: "get_weather",
+				description: `Get the current weather for a city${locationSuffix}`,
+				inputSchema: {
+					type: "object",
+					properties: {
+						city: { type: "string", description: "The city name" },
+					},
+					required: ["city"],
+				},
+				execute: async (input: unknown) => {
+					const { city } = input as { city: string };
+					return {
+						city,
+						temperature: "72°F",
+						condition: "sunny",
+						humidity: "45%",
+					};
+				},
+			}),
+		);
+		sessionWorkspaceRoot = ctx.workspaceInfo?.rootPath;
+		sessionBranch = ctx.workspaceInfo?.latestGitBranchName;
+		sessionCommit = ctx.workspaceInfo?.latestGitCommitHash?.slice(0, 7);
+		const remotes = ctx.workspaceInfo?.associatedRemoteUrls ?? [];
+
+		console.log(`\n[metrics] session started`);
+		if (sessionWorkspaceRoot) {
+			console.log(`[metrics] workspace : ${sessionWorkspaceRoot}`);
+		}
+		if (sessionBranch) {
+			console.log(
+				`[metrics] branch   : ${sessionBranch}${sessionCommit ? ` @ ${sessionCommit}` : ""}`,
+			);
+		}
+		if (remotes.length > 0) {
+			console.log(`[metrics] remotes  : ${remotes.join(", ")}`);
+		}
+	},
+
+	// -------------------------------------------------------------------------
+	// Lifecycle metrics hooks
+	// -------------------------------------------------------------------------
+	hooks: {
+		beforeRun() {
+			console.log("\n[metrics] run started");
+			return undefined;
+		},
+
+		beforeTool({ toolCall, input }) {
+			console.log(`[metrics] -> ${toolCall.toolName}`, input);
+
+			if (toolCall.toolName === "run_commands") {
+				const { commands } = input as { commands?: string[] };
+				const isProtected =
+					sessionBranch === "main" || sessionBranch === "master";
+				const hasPush = commands?.some((c) =>
+					c.trimStart().startsWith("git push"),
+				);
+				if (isProtected && hasPush) {
+					console.error(
+						`[metrics] blocked: git push on protected branch "${sessionBranch}"`,
+					);
+					return { stop: true, reason: "Blocked git push on protected branch" };
+				}
+			}
+			return undefined;
+		},
+
+		afterTool({ toolCall }) {
+			console.log(`[metrics] <- ${toolCall.toolName}`);
+			return undefined;
+		},
+
+		afterRun({ result }) {
+			const { status, iterations, usage } = result;
+			const loc = sessionWorkspaceRoot ? ` in ${sessionWorkspaceRoot}` : "";
+			console.log(
+				`[metrics] run done${loc} — ${iterations} iteration(s), status: ${status}`,
+			);
+			console.log(
+				`[metrics] tokens — in: ${usage.inputTokens}, out: ${usage.outputTokens}, cost: ${usage.totalCost?.toFixed(6)}`,
+			);
+		},
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/plugins/web-search.ts b/sdk/examples/plugins/web-search.ts
new file mode 100644
index 0000000..960ed16
--- /dev/null
+++ b/sdk/examples/plugins/web-search.ts
@@ -0,0 +1,324 @@
+/**
+ * Web Search Plugin Example
+ *
+ * Registers a `web_search` tool backed by Exa.
+ *
+ * CLI usage:
+ *   cline plugin install https://github.com/cline/cline/blob/main/sdk/examples/plugins/web-search.ts --cwd .
+ *   EXA_API_KEY=... cline "Search the web for recent TypeScript 6 updates"
+ *
+ * Provider key:
+ *   EXA_API_KEY              Enables Exa search. A separate model provider key
+ *                            is still required for CLI inference.
+ */
+
+import { type AgentPlugin, createTool } from "@cline/core";
+
+export interface WebSearchInput {
+	query: string;
+	limit?: number;
+	domains?: string[];
+	recencyDays?: number;
+	country?: string;
+}
+
+export interface WebSearchResult {
+	title: string;
+	url: string;
+	snippet?: string;
+	publishedAt?: string;
+	author?: string;
+	score?: number;
+	source: "exa";
+}
+
+export interface WebSearchOutput {
+	provider: "exa";
+	query: string;
+	results: WebSearchResult[];
+	requestId?: string;
+}
+
+interface ExaSearchResult {
+	title?: string;
+	url?: string;
+	publishedDate?: string;
+	author?: string;
+	score?: number;
+	text?: string;
+	highlights?: string[];
+	summary?: string;
+}
+
+interface ExaSearchResponse {
+	requestId?: string;
+	results?: ExaSearchResult[];
+	error?: string;
+}
+
+const DEFAULT_RESULT_LIMIT = 5;
+const MAX_RESULT_LIMIT = 10;
+const EXA_SEARCH_ENDPOINT = "https://api.exa.ai/search";
+
+function env(name: string): string | undefined {
+	const value = process.env[name]?.trim();
+	return value ? value : undefined;
+}
+
+function clampResultLimit(limit: number | undefined): number {
+	if (typeof limit !== "number" || !Number.isFinite(limit)) {
+		return DEFAULT_RESULT_LIMIT;
+	}
+	const integer = Math.trunc(limit);
+	return Math.min(Math.max(integer, 1), MAX_RESULT_LIMIT);
+}
+
+function normalizeDomains(domains: string[] | undefined): string[] | undefined {
+	const normalized = domains
+		?.map((domain) => domain.trim().replace(/^https?:\/\//, ""))
+		.map((domain) => domain.replace(/\/.*$/, ""))
+		.filter(Boolean);
+	return normalized && normalized.length > 0
+		? [...new Set(normalized)]
+		: undefined;
+}
+
+function isoDateDaysAgo(days: number | undefined): string | undefined {
+	if (typeof days !== "number" || !Number.isFinite(days) || days <= 0) {
+		return undefined;
+	}
+	const date = new Date();
+	date.setUTCDate(date.getUTCDate() - Math.trunc(days));
+	return date.toISOString();
+}
+
+function truncateSnippet(text: string | undefined): string | undefined {
+	if (!text) {
+		return undefined;
+	}
+	const normalized = text.replace(/\s+/g, " ").trim();
+	if (!normalized) {
+		return undefined;
+	}
+	return normalized.length > 800
+		? `${normalized.slice(0, 797).trimEnd()}...`
+		: normalized;
+}
+
+function extractErrorMessage(body: unknown): string | undefined {
+	if (!body || typeof body !== "object") {
+		return undefined;
+	}
+	const record = body as Record<string, unknown>;
+	for (const key of ["error", "message", "detail"] as const) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim()) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function hasResultUrl(
+	result: ExaSearchResult,
+): result is ExaSearchResult & { url: string } {
+	return typeof result.url === "string" && result.url.trim().length > 0;
+}
+
+function parseWebSearchInput(input: unknown): WebSearchInput {
+	if (!input || typeof input !== "object") {
+		throw new Error("web_search input must be an object");
+	}
+	const record = input as Record<string, unknown>;
+	const query = asString(record.query);
+	if (!query) {
+		throw new Error("query is required");
+	}
+
+	const domains = Array.isArray(record.domains)
+		? record.domains.flatMap((domain) => {
+				const value = asString(domain);
+				return value ? [value] : [];
+			})
+		: undefined;
+
+	return {
+		query,
+		limit: asNumber(record.limit),
+		domains,
+		recencyDays: asNumber(record.recencyDays),
+		country: asString(record.country),
+	};
+}
+
+async function readJsonResponse<T>(response: Response): Promise<T> {
+	const text = await response.text();
+	let body: unknown = {};
+	try {
+		body = text ? (JSON.parse(text) as unknown) : {};
+	} catch {
+		if (!response.ok) {
+			throw new Error(
+				`HTTP ${response.status}: ${text || response.statusText}`,
+			);
+		}
+		throw new Error("Search provider returned invalid JSON");
+	}
+
+	if (!response.ok) {
+		const message = extractErrorMessage(body) ?? (text || response.statusText);
+		throw new Error(`HTTP ${response.status}: ${message}`);
+	}
+
+	return body as T;
+}
+
+function resolveExaApiKey(): string {
+	const exaApiKey = env("EXA_API_KEY");
+	if (!exaApiKey) {
+		throw new Error("Set EXA_API_KEY to use web_search");
+	}
+	return exaApiKey;
+}
+
+async function searchExa(
+	input: WebSearchInput,
+	apiKey: string,
+	limit: number,
+	domains: string[] | undefined,
+): Promise<WebSearchOutput> {
+	const body: Record<string, unknown> = {
+		query: input.query,
+		numResults: limit,
+		contents: {
+			highlights: true,
+		},
+	};
+	if (domains) {
+		body.includeDomains = domains;
+	}
+	const startPublishedDate = isoDateDaysAgo(input.recencyDays);
+	if (startPublishedDate) {
+		body.startPublishedDate = startPublishedDate;
+	}
+	if (input.country) {
+		body.userLocation = input.country.toLowerCase();
+	}
+
+	const response = await fetch(EXA_SEARCH_ENDPOINT, {
+		method: "POST",
+		headers: {
+			"x-api-key": apiKey,
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify(body),
+	});
+	const json = await readJsonResponse<ExaSearchResponse>(response);
+
+	if (json.error) {
+		throw new Error(json.error);
+	}
+
+	return {
+		provider: "exa",
+		query: input.query,
+		requestId: json.requestId,
+		results: (json.results ?? [])
+			.filter(hasResultUrl)
+			.slice(0, limit)
+			.map((result) => ({
+				title: result.title || result.url || "Untitled",
+				url: result.url,
+				snippet: truncateSnippet(
+					result.highlights?.join("\n") ?? result.summary ?? result.text,
+				),
+				publishedAt: result.publishedDate,
+				author: result.author,
+				score: result.score,
+				source: "exa",
+			})),
+	};
+}
+
+export async function searchWeb(
+	input: WebSearchInput,
+): Promise<WebSearchOutput> {
+	if (!input.query || !input.query.trim()) {
+		throw new Error("query is required");
+	}
+
+	const limit = clampResultLimit(input.limit);
+	const domains = normalizeDomains(input.domains);
+	const apiKey = resolveExaApiKey();
+
+	return searchExa(input, apiKey, limit, domains);
+}
+
+const plugin: AgentPlugin = {
+	name: "web-search",
+	manifest: {
+		capabilities: ["tools"],
+	},
+
+	setup(api) {
+		api.registerTool(
+			createTool({
+				name: "web_search",
+				description:
+					"Search the web for current public information using Exa. " +
+					"Use this to discover relevant URLs, news, docs, and recent facts; use fetch_web_content afterward when a page needs deeper inspection. " +
+					"Requires EXA_API_KEY in the plugin host environment.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						query: {
+							type: "string",
+							description:
+								"Search query. Use precise terms and include dates when recency matters.",
+						},
+						limit: {
+							type: "number",
+							description: `Number of results to return, from 1 to ${MAX_RESULT_LIMIT}. Defaults to ${DEFAULT_RESULT_LIMIT}.`,
+						},
+						domains: {
+							type: "array",
+							items: { type: "string" },
+							description:
+								"Optional domains to restrict results to, such as github.com or docs.exa.ai.",
+						},
+						recencyDays: {
+							type: "number",
+							description:
+								"Optional freshness window in days. Maps to Exa startPublishedDate.",
+						},
+						country: {
+							type: "string",
+							description:
+								"Optional lowercase two-letter country code for localized results, such as us.",
+						},
+					},
+					required: ["query"],
+					additionalProperties: false,
+				},
+				timeoutMs: 30_000,
+				retryable: true,
+				maxRetries: 1,
+				execute: async (input: unknown) =>
+					searchWeb(parseWebSearchInput(input)),
+			}),
+		);
+	},
+};
+
+export { plugin };
+export default plugin;
diff --git a/sdk/examples/tsconfig.json b/sdk/examples/tsconfig.json
new file mode 100644
index 0000000..3ce2f43
--- /dev/null
+++ b/sdk/examples/tsconfig.json
@@ -0,0 +1,58 @@
+{
+	"extends": "../../apps/tsconfig.apps.json",
+	"compilerOptions": {
+		// Environment setup & latest features
+		"lib": ["ESNext"],
+		"types": ["bun"],
+		"target": "ESNext",
+		"module": "Preserve",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+		"allowJs": true,
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": false,
+		"noImplicitOverride": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false,
+		"paths": {
+			"@cline/agents": ["../packages/agents/src/index.ts"],
+			"@cline/agents/*": [
+				"../packages/agents/src/*",
+				"../packages/agents/src/*/index.ts"
+			],
+			"@cline/cline-hub": ["./cline-hub/src/server.ts"],
+			"@cline/core": ["../packages/core/src/index.ts"],
+			"@cline/core/hub/daemon-entry": [
+				"../packages/core/src/hub/daemon/entry.ts"
+			],
+			"@cline/core/*": [
+				"../packages/core/src/*",
+				"../packages/core/src/*/index.ts"
+			],
+			"@cline/core/telemetry": [
+				"../packages/core/src/services/telemetry/index.ts"
+			],
+			"@cline/llms": ["../packages/llms/src/index.ts"],
+			"@cline/shared": ["../packages/shared/src/index.ts"],
+			"@cline/shared/storage": ["../packages/shared/src/storage/index.ts"],
+			"@cline/shared/db": ["../packages/shared/src/db/index.ts"],
+			"@cline/shared/*": [
+				"../packages/shared/src/*",
+				"../packages/shared/src/*/index.ts"
+			]
+		}
+	}
+}
diff --git a/sdk/packages/README.md b/sdk/packages/README.md
new file mode 100644
index 0000000..021ab00
--- /dev/null
+++ b/sdk/packages/README.md
@@ -0,0 +1,44 @@
+# Packages Overview
+
+This directory is the single documentation source for package-level responsibilities.
+
+- High-level package roles: this file (`packages/README.md`)
+- Package interaction and runtime flows: [`ARCHITECTURE.md`](./ARCHITECTURE.md)
+
+## Package Responsibilities
+
+| Package | Primary responsibility | Typical consumers | Internal deps |
+| --- | --- | --- | --- |
+| `@cline/shared` | Cross-package shared primitives (path resolution, session common types, indexing helpers) | `@cline/agents`, `@cline/core`, apps | None |
+| `@cline/llms` | Model catalog + provider settings schema + handler creation SDK | `@cline/agents`, `@cline/core`, apps | None |
+| `@cline/agents` | Stateless agent runtime loop (tools, hooks, extensions, teams, streaming) | `@cline/core`, apps | `@cline/llms`, `@cline/shared` |
+| `@cline/core` | Stateful runtime orchestration (runtime composition, session lifecycle/storage, local and hub runtime services, hub discovery and client helpers) | CLI/Desktop apps | `@cline/agents`, `@cline/llms`, `@cline/shared` |
+
+## How Packages Work Together
+
+1. `@cline/llms` defines model/provider capabilities and builds concrete handlers.
+2. `@cline/agents` runs the agent loop on top of those handlers and tool execution primitives.
+3. `@cline/core` composes runtime behavior with persistent sessions/storage and local or hub-backed runtime services.
+4. `@cline/core` hub services orchestrate scheduled runtime execution, execution history, and schedule command handling.
+5. `@cline/core/hub` exposes discovery, the detached hub daemon, and session-oriented client APIs (`HubSessionClient`, `HubUIClient`) when hosts need a shared daemon.
+6. `@cline/shared` provides the shared contracts and path/session primitives used across the stack.
+
+## Practical Boundary Rules
+
+- Put provider/model schema, cataloging, and handler wiring in `@cline/llms`.
+- Put loop/tool/hook/team execution behavior in `@cline/agents`.
+- Put persistence, session lifecycle, and runtime assembly in `@cline/core`.
+- Put scheduled execution and schedule persistence in `@cline/core` hub services.
+- Put hub discovery, attach flows, and session-oriented client adapters in `@cline/core/hub`.
+- Put cross-package utility types and path/session constants in `@cline/shared`.
+- Put remote-config schemas, materialization, telemetry normalization, and blob upload primitives in `@cline/shared/remote-config`.
+
+## Runtime Entry Points
+
+- Node-oriented imports exist where packages expose a distinct Node alias.
+- `@cline/core` itself is now the Node/runtime-oriented entry point for host/session services.
+- Browser entry points still exist in packages that intentionally publish a browser surface, but `@cline/core` no longer does.
+
+## Notes for Doc Consolidation
+
+Nested package `README.md` and `ARCHITECTURE.md` files can be reduced or removed after references are updated to point here.
diff --git a/sdk/packages/agents/README.md b/sdk/packages/agents/README.md
new file mode 100644
index 0000000..aa7fff7
--- /dev/null
+++ b/sdk/packages/agents/README.md
@@ -0,0 +1,310 @@
+# [experimental] @cline/agents
+
+`@cline/agents` is the runtime-agnostic agent loop package in the Cline SDK.
+It gives you the core primitives for building tool-using LLM agents without
+bringing in session storage, hub transport, or host-specific default tools.
+
+## What You Get
+
+- `Agent` / `AgentRuntime` — the same class under two names — for running and
+  continuing tool-using agent conversations
+- `createAgent` / `createAgentRuntime` — factory-function equivalents
+- `AgentRuntimeHooks` for lifecycle interception (`beforeRun`, `afterRun`,
+  `beforeModel`, `afterModel`, `beforeTool`, `afterTool`, `onEvent`)
+- Event streaming via `agent.subscribe(listener)` and the `hooks.onEvent`
+  callback
+- Plugin setup callbacks for contributing tools and hooks at boot
+
+## What This Package Does Not Include
+
+`@cline/agents` does not ship a full application runtime by itself.
+
+- Default host tools like filesystem access, shell execution, or web fetching live in `@cline/core`
+- Session persistence and stateful orchestration live in `@cline/core`
+- Shared hub runtime/session transport lives in `@cline/core` (see `@cline/core/hub`)
+- Sub-agent and team coordination primitives live in `@cline/core`
+
+That split keeps this package usable in Node, browser, and custom host
+environments where you want to supply your own tools and runtime policy.
+
+## Installation
+
+```bash
+npm install @cline/agents @cline/shared @cline/llms
+```
+
+## Quick Start
+
+```ts
+import { Agent } from "@cline/agents";
+import type { AgentTool } from "@cline/shared";
+
+const getWeather: AgentTool<{ city: string }, { forecast: string }> = {
+	name: "get_weather",
+	description: "Return the current weather for a city.",
+	inputSchema: {
+		type: "object",
+		properties: { city: { type: "string" } },
+		required: ["city"],
+	},
+	async execute({ city }) {
+		return { forecast: `sunny in ${city}` };
+	},
+};
+
+const agent = new Agent({
+	providerId: "anthropic",
+	modelId: "claude-sonnet-4-6",
+	apiKey: process.env.ANTHROPIC_API_KEY,
+	systemPrompt: "You are a concise assistant.",
+	tools: [getWeather],
+});
+
+const result = await agent.run("What's the weather in San Francisco?");
+console.log(result.outputText);
+```
+
+## Two Ways to Configure
+
+`Agent` / `AgentRuntime` accepts two config shapes:
+
+**Provider form** — friendly entrypoint. The runtime builds an `AgentModel` for
+you via `@cline/llms`:
+
+```ts
+new Agent({
+	providerId: "openai",
+	modelId: "gpt-5",
+	apiKey: process.env.OPENAI_API_KEY,
+	// baseUrl, headers also supported
+	tools: [/* ... */],
+});
+```
+
+**Model form** — advanced. Supply a pre-built `AgentModel` directly. Useful
+when the host already owns gateway construction (this is what `@cline/core`
+uses internally):
+
+```ts
+import { createGateway } from "@cline/llms";
+
+const gateway = createGateway({ providerConfigs: [/* ... */] });
+const model = gateway.createAgentModel({ providerId, modelId });
+
+new Agent({
+	model,
+	tools: [/* ... */],
+});
+```
+
+## Core Concepts
+
+### Tools
+
+Tools conform to the `AgentTool<TInput, TOutput>` interface from
+`@cline/shared`. Each tool has a JSON Schema `inputSchema` and an
+`execute(input, context)` function that returns the tool output directly:
+
+```ts
+import type { AgentTool } from "@cline/shared";
+
+const summarize: AgentTool<{ text: string }, { summary: string }> = {
+	name: "summarize_text",
+	description: "Summarize text into a short preview.",
+	inputSchema: {
+		type: "object",
+		properties: { text: { type: "string" } },
+		required: ["text"],
+	},
+	async execute({ text }, context) {
+		// context.signal — aborts when the run is cancelled
+		// context.emitUpdate(...) — stream progress as `tool-updated` events
+		return { summary: text.slice(0, 120) };
+	},
+};
+```
+
+The runtime wraps successful tool outputs in an internal tool-result message.
+Throw from `execute(...)` to report a tool failure, or use an `afterTool` hook
+to transform the internal `AgentToolResult` envelope.
+
+### Events
+
+Subscribe to the `AgentRuntimeEvent` stream in one of two ways:
+
+```ts
+// 1. Attach a listener after construction. Returns an unsubscribe function.
+const unsubscribe = agent.subscribe((event) => {
+	if (event.type === "assistant-text-delta") {
+		process.stdout.write(event.text);
+	}
+});
+
+// 2. Register an `onEvent` hook at construction time.
+new Agent({
+	providerId,
+	modelId,
+	apiKey,
+	hooks: {
+		onEvent(event) {
+			// fires for every runtime event
+		},
+	},
+});
+```
+
+`AgentRuntimeEvent` covers run/turn boundaries, assistant text and reasoning
+deltas, tool lifecycle, usage updates, and run completion/failure. See
+`AgentRuntimeEvent` in `@cline/shared` for the full union.
+
+### Conversation Control
+
+- `agent.run(input)` — start a run. `input` may be a string, an `AgentMessage`,
+  or an array of messages. Also accepts `undefined` to continue without adding
+  a new user turn.
+- `agent.continue(input?)` — convenience alias for `run(input?)`.
+- `agent.abort(reason?)` — cancel the active run. `.run()` resolves with
+  `status: "aborted"`.
+- `agent.snapshot()` — immutable view of the current
+  `AgentRuntimeStateSnapshot` (messages, usage, iteration, status, etc.).
+- `agent.restore(messages)` — replace the conversation with a persisted
+  message array. Resets run/turn state but preserves subscribers, tools,
+  hooks, plugins, and the model.
+- `initialMessages` in the constructor seeds the conversation on boot.
+
+### Hooks
+
+Pass a `hooks` bag (`AgentRuntimeHooks`) to observe or influence the loop.
+All hooks may be async; any that return `{ stop: true, reason }` will halt the
+run with an `aborted` status.
+
+```ts
+new Agent({
+	providerId,
+	modelId,
+	apiKey,
+	tools: [/* ... */],
+	hooks: {
+		beforeModel({ request }) {
+			// mutate messages/tools/options before the model call
+			return { options: { temperature: 0.2 } };
+		},
+		beforeTool({ tool, input }) {
+			// block a tool call based on policy
+			if (tool.name === "get_weather" && !(input as { city?: string }).city) {
+				return { skip: true, reason: "city required" };
+			}
+			return undefined;
+		},
+		afterRun({ result }) {
+			console.log("done", result.usage);
+		},
+	},
+});
+```
+
+For richer, host-side hook orchestration (15-stage `HookEngine`,
+subprocess-backed hooks, MCP extensions), use `@cline/core`.
+
+### Preparing Requests with `prepareTurn`
+
+`prepareTurn` runs before messages are sent to the provider. It can rewrite the
+messages or system prompt for the next request:
+
+```text
+saved transcript
+        |
+        | turn preparation
+        v
+prepareTurn
+        |
+        v
+prepared provider request
+```
+
+Returned messages affect only the provider request for the current model call.
+They do not replace saved history and are not returned from
+`AgentRunResult.messages`.
+
+```text
+prepareTurn returns prepared messages
+        |
+        +--> provider request: yes
+        +--> saved transcript: no
+        +--> AgentRunResult.messages: no
+```
+
+This is intentionally different from changing saved history. Hosts that need
+durable redaction, normalization, or policy filtering must apply that change
+before a message enters the transcript.
+
+### Plugins
+
+Plugins can contribute tools and hooks at setup time:
+
+```ts
+import type { AgentRuntimePlugin } from "@cline/shared";
+
+const loggingPlugin: AgentRuntimePlugin = {
+	name: "logging",
+	setup({ agentId }) {
+		return {
+			hooks: {
+				afterTool({ tool, result }) {
+					console.log(agentId, tool.name, result.isError);
+					return undefined; // hook may return an AgentAfterToolResult
+				},
+			},
+		};
+	},
+};
+
+new Agent({
+	providerId,
+	modelId,
+	apiKey,
+	plugins: [loggingPlugin],
+});
+```
+
+### Teams and Spawn
+
+For multi-agent workflows, use `@cline/core`:
+
+```ts
+import {
+	createSpawnAgentTool,
+	AgentTeamsRuntime,
+	createAgentTeamsTools,
+	bootstrapAgentTeams,
+} from "@cline/core";
+```
+
+These helpers provide coordination primitives for delegated runs,
+mailboxes, task management, and outcome convergence.
+
+## Entry Point
+
+- `@cline/agents` — the single package entrypoint. The `package.json`
+  `exports` map automatically serves a browser-safe bundle when bundlers
+  resolve the `browser` condition.
+
+## Related Packages
+
+- `@cline/shared`: shared types (`AgentTool`, `AgentMessage`,
+  `AgentRuntimeEvent`, `AgentRuntimeHooks`, etc.)
+- `@cline/llms`: provider settings, model catalogs, and gateway/handler
+  creation
+- `@cline/core`: stateful runtime assembly, storage, default tools,
+  subprocess hooks, hub transport, and MCP integration
+
+## More Examples
+
+- Repo examples:
+  [examples/plugins](https://github.com/cline/sdk/tree/main/examples/plugins),
+  [examples/hooks](https://github.com/cline/sdk/tree/main/examples/hooks),
+  [examples/cron](https://github.com/cline/sdk/tree/main/examples/cron)
+- Workspace overview: [README.md](https://github.com/cline/sdk/blob/main/README.md)
+- API and architecture references:
+  [DOC.md](https://github.com/cline/sdk/blob/main/DOC.md),
+  [ARCHITECTURE.md](https://github.com/cline/sdk/blob/main/ARCHITECTURE.md)
diff --git a/sdk/packages/agents/bun.mts b/sdk/packages/agents/bun.mts
new file mode 100644
index 0000000..93e1d47
--- /dev/null
+++ b/sdk/packages/agents/bun.mts
@@ -0,0 +1,31 @@
+/// <reference types="@types/bun" />
+export {};
+
+// Externalize third-party runtime deps plus the provider/runtime layer that
+// the Agent facade loads dynamically. `@cline/shared` stays bundled.
+const external = ["@cline/llms", "nanoid"];
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+// minify: true keeps identifier mangling active even when sourcemaps are enabled.
+const minify = Bun.env.CLINE_SOURCEMAPS !== "1";
+
+const builds: Parameters<typeof Bun.build>[0][] = [
+	{
+		entrypoints: ["./src/index.ts"],
+		outdir: "./dist",
+		target: "node",
+		minify,
+		sourcemap,
+		packages: "bundle",
+		external,
+	},
+];
+
+for (const config of builds) {
+	const result = await Bun.build(config);
+
+	if (result.logs.length > 0) {
+		for (const log of result.logs) {
+			console.warn(log);
+		}
+	}
+}
diff --git a/sdk/packages/agents/package.json b/sdk/packages/agents/package.json
new file mode 100644
index 0000000..dd0190a
--- /dev/null
+++ b/sdk/packages/agents/package.json
@@ -0,0 +1,45 @@
+{
+	"name": "@cline/agents",
+	"version": "0.0.59",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline",
+		"directory": "sdk/packages/agents"
+	},
+	"main": "dist/index.js",
+	"dependencies": {
+		"@cline/llms": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"nanoid": "^5.1.7"
+	},
+	"exports": {
+		".": {
+			"browser": "./dist/index.js",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"description": "Browser-safe agent runtime for the next-generation Cline SDK",
+	"files": [
+		"dist"
+	],
+	"keywords": [
+		"llm",
+		"agents",
+		"ai",
+		"tool-calling"
+	],
+	"license": "Apache-2.0",
+	"scripts": {
+		"build": "bun run bun.mts && bun tsc -p tsconfig.build.json",
+		"dev": "bun build ./src/index.ts --outdir ./dist --target node --format esm --watch",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts"
+}
diff --git a/sdk/packages/agents/src/agent-runtime.provider-form.test.ts b/sdk/packages/agents/src/agent-runtime.provider-form.test.ts
new file mode 100644
index 0000000..f56e5b5
--- /dev/null
+++ b/sdk/packages/agents/src/agent-runtime.provider-form.test.ts
@@ -0,0 +1,289 @@
+import type {
+	AgentMessage,
+	AgentModel,
+	AgentModelEvent,
+	AgentModelRequest,
+	AgentRuntimeEvent,
+} from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AgentRuntime, AgentRuntimeAbortError } from "./agent-runtime";
+import { Agent, createAgent } from "./index";
+
+const { createAgentModel, createGateway } = vi.hoisted(() => {
+	const createAgentModel = vi.fn();
+	const createGateway = vi.fn(() => ({
+		createAgentModel,
+	}));
+	return { createAgentModel, createGateway };
+});
+
+vi.mock("@cline/llms", () => ({
+	createGateway,
+}));
+
+class ScriptedModel implements AgentModel {
+	constructor(
+		private readonly steps: Array<
+			(
+				request: AgentModelRequest,
+			) => Iterable<AgentModelEvent> | AsyncIterable<AgentModelEvent>
+		>,
+	) {}
+
+	async stream(
+		request: AgentModelRequest,
+	): Promise<AsyncIterable<AgentModelEvent>> {
+		const step = this.steps.shift();
+		if (!step) {
+			throw new Error("No scripted model step available");
+		}
+		return toAsyncIterable(step(request));
+	}
+}
+
+async function* toAsyncIterable(
+	events: Iterable<AgentModelEvent> | AsyncIterable<AgentModelEvent>,
+): AsyncIterable<AgentModelEvent> {
+	for await (const event of events) {
+		yield event;
+	}
+}
+
+describe("AgentRuntime (provider-form config + Agent alias)", () => {
+	beforeEach(() => {
+		createGateway.mockClear();
+		createAgentModel.mockReset();
+	});
+
+	it("constructs the runtime via the llms gateway in ESM-safe code", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+			apiKey: "test-key",
+		});
+
+		expect(agent).toBeInstanceOf(Agent);
+		expect(createGateway).toHaveBeenCalledWith({
+			providerConfigs: [
+				{
+					providerId: "openai",
+					apiKey: "test-key",
+					baseUrl: undefined,
+					headers: undefined,
+					options: undefined,
+				},
+			],
+		});
+		expect(createAgentModel).toHaveBeenCalledWith({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+	});
+
+	it("passes provider options through to the llms gateway", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		new Agent({
+			providerId: "openai-compatible",
+			modelId: "gpt-4.1",
+			apiKey: "test-key",
+			baseUrl: "https://example.openai.azure.com/openai/deployments/gpt-4.1",
+			options: { apiVersion: "2025-01-01-preview" },
+		});
+
+		expect(createGateway).toHaveBeenCalledWith({
+			providerConfigs: [
+				{
+					providerId: "openai-compatible",
+					apiKey: "test-key",
+					baseUrl:
+						"https://example.openai.azure.com/openai/deployments/gpt-4.1",
+					headers: undefined,
+					options: { apiVersion: "2025-01-01-preview" },
+				},
+			],
+		});
+	});
+
+	it("forwards abort() to the active AgentRuntime", async () => {
+		let abortReason: unknown;
+		const model = new ScriptedModel([
+			async function* (request) {
+				yield { type: "text-delta", text: "partial" };
+				await new Promise<void>((resolve) => {
+					request.signal?.addEventListener(
+						"abort",
+						() => {
+							abortReason = request.signal?.reason;
+							resolve();
+						},
+						{ once: true },
+					);
+				});
+				yield { type: "finish", reason: "aborted" };
+			},
+		]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+
+		const runPromise = agent.run("cancel me");
+		for (let i = 0; i < 20; i += 1) {
+			if (agent.snapshot().status === "running") {
+				break;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		}
+		agent.abort("user cancelled");
+
+		await expect(runPromise).resolves.toMatchObject({
+			status: "aborted",
+		});
+		expect(abortReason).toBeInstanceOf(AgentRuntimeAbortError);
+		if (!(abortReason instanceof AgentRuntimeAbortError)) {
+			throw new Error("expected agent runtime abort reason");
+		}
+		expect(abortReason.message).toBe("user cancelled");
+		expect(abortReason.reason).toBe("user cancelled");
+	});
+
+	it("createAgent() and new Agent() both return an AgentRuntime instance", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = createAgent({
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+		});
+
+		// After the facade/runtime merge (Option B), `Agent` is an alias for
+		// `AgentRuntime`. Both constructors return the same class — verified
+		// here so future refactors don't silently reintroduce a split.
+		expect(agent).toBeInstanceOf(Agent);
+		expect(agent).toBeInstanceOf(AgentRuntime);
+		expect(Agent).toBe(AgentRuntime);
+	});
+
+	it("restores conversation state by rebuilding the runtime", () => {
+		const model = new ScriptedModel([]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+		const messages: AgentMessage[] = [
+			{
+				id: "msg_1",
+				role: "user",
+				content: [{ type: "text", text: "hello" }],
+				createdAt: 1,
+			},
+		];
+
+		agent.restore(messages);
+
+		expect(agent.snapshot().messages).toEqual(messages);
+		expect(agent.snapshot().status).toBe("idle");
+	});
+
+	it("rebinds existing subscribers when restore() replaces the runtime", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "hello" },
+				{ type: "finish", reason: "stop" },
+			],
+			() => [
+				{ type: "text-delta", text: "again" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "openai",
+			modelId: "gpt-5",
+		});
+		const received: AgentRuntimeEvent["type"][] = [];
+		const unsubscribe = agent.subscribe((event) => {
+			received.push(event.type);
+		});
+
+		agent.restore([
+			{
+				id: "msg_1",
+				role: "user",
+				content: [{ type: "text", text: "restored" }],
+				createdAt: 1,
+			},
+		]);
+		await agent.run("hello");
+
+		expect(received).toContain("run-started");
+		expect(received).toContain("run-finished");
+
+		const countAfterRun = received.length;
+		unsubscribe();
+		await agent.run("again");
+		expect(received).toHaveLength(countAfterRun);
+	});
+
+	it("derives messageModelInfo from providerId/modelId so assistant messages carry model tags", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "hi" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+		});
+
+		const result = await agent.run("hello");
+
+		const assistant = result.messages.find((m) => m.role === "assistant");
+		expect(assistant?.modelInfo).toEqual({
+			id: "claude-sonnet-4-6",
+			provider: "anthropic",
+		});
+	});
+
+	it("prefers an explicit messageModelInfo over the derived provider/model", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "hi" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		createAgentModel.mockReturnValue(model);
+
+		const agent = new Agent({
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			messageModelInfo: {
+				id: "explicit-model",
+				provider: "explicit-provider",
+				family: "explicit-family",
+			},
+		});
+
+		const result = await agent.run("hello");
+
+		const assistant = result.messages.find((m) => m.role === "assistant");
+		expect(assistant?.modelInfo).toEqual({
+			id: "explicit-model",
+			provider: "explicit-provider",
+			family: "explicit-family",
+		});
+	});
+});
diff --git a/sdk/packages/agents/src/agent-runtime.test.ts b/sdk/packages/agents/src/agent-runtime.test.ts
new file mode 100644
index 0000000..dcaabfe
--- /dev/null
+++ b/sdk/packages/agents/src/agent-runtime.test.ts
@@ -0,0 +1,1811 @@
+import type {
+	AgentMessage,
+	AgentModel,
+	AgentModelEvent,
+	AgentModelRequest,
+	AgentRuntimePlugin,
+	AgentTool,
+	ITelemetryService,
+} from "@cline/shared";
+import { AGENT_UNEXPECTED_REASONING_TOKENS_EVENT } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import { AgentRuntime } from "./index";
+
+class ScriptedModel implements AgentModel {
+	public readonly requests: AgentModelRequest[] = [];
+
+	constructor(
+		private readonly steps: Array<
+			(
+				request: AgentModelRequest,
+			) => Iterable<AgentModelEvent> | AsyncIterable<AgentModelEvent>
+		>,
+	) {}
+
+	async stream(
+		request: AgentModelRequest,
+	): Promise<AsyncIterable<AgentModelEvent>> {
+		this.requests.push(request);
+		const step = this.steps.shift();
+		if (!step) {
+			throw new Error("No scripted model step available");
+		}
+		return toAsyncIterable(step(request));
+	}
+}
+
+async function* toAsyncIterable(
+	events: Iterable<AgentModelEvent> | AsyncIterable<AgentModelEvent>,
+): AsyncIterable<AgentModelEvent> {
+	for await (const event of events) {
+		yield event;
+	}
+}
+
+const createEchoTool = (): AgentTool<{ text: string }, { echoed: string }> => ({
+	name: "echo",
+	description: "Echo input text",
+	inputSchema: { type: "object" },
+	async execute(input) {
+		return { echoed: input.text };
+	},
+});
+
+describe("AgentRuntime", () => {
+	it("completes a simple turn without tools", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "hello" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({ model });
+
+		const result = await runtime.run("Hi");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("hello");
+		expect(result.messages).toHaveLength(2);
+		expect(model.requests).toHaveLength(1);
+	});
+
+	it("does not persist an empty assistant message when the model stream fails", async () => {
+		const model = new ScriptedModel([
+			() => [{ type: "finish", reason: "error", error: "upstream failed" }],
+		]);
+		const addedMessages: AgentMessage[] = [];
+		const runtime = new AgentRuntime({ model });
+		runtime.subscribe((event) => {
+			if (event.type === "message-added") {
+				addedMessages.push(event.message);
+			}
+		});
+
+		const result = await runtime.run("Hi");
+
+		expect(result.status).toBe("failed");
+		expect(result.error?.message).toBe("upstream failed");
+		expect(result.messages).toHaveLength(1);
+		expect(result.messages[0]?.role).toBe("user");
+		expect(addedMessages.map((message) => message.role)).toEqual(["user"]);
+	});
+
+	it("does not complete or persist history when the model returns no content", async () => {
+		const model = new ScriptedModel([
+			() => [{ type: "finish", reason: "stop" }],
+		]);
+		const runtime = new AgentRuntime({ model });
+
+		const result = await runtime.run("Hi");
+
+		expect(result.status).toBe("failed");
+		expect(result.error?.message).toBe("Model returned empty response");
+		expect(result.messages).toHaveLength(1);
+		expect(result.messages[0]?.role).toBe("user");
+	});
+
+	it("executes a tool call and continues the loop", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({ model, tools: [createEchoTool()] });
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(
+			result.messages.filter((message) => message.role === "tool"),
+		).toHaveLength(1);
+		expect(result.outputText).toBe("done");
+	});
+
+	it("injects a pending user message after tool results and before the next model request", async () => {
+		const consumePendingUserMessage = vi.fn(() => "steer now");
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const assistantMessage = request.messages.at(-3);
+				const toolMessage = request.messages.at(-2);
+				const steerMessage = request.messages.at(-1);
+				expect(assistantMessage?.role).toBe("assistant");
+				expect(
+					assistantMessage?.content.some((part) => part.type === "tool-call"),
+				).toBe(true);
+				expect(toolMessage?.role).toBe("tool");
+				expect(toolMessage?.content).toEqual([
+					expect.objectContaining({
+						type: "tool-result",
+						toolCallId: "call_1",
+					}),
+				]);
+				expect(steerMessage).toMatchObject({
+					role: "user",
+					content: [{ type: "text", text: "steer now" }],
+				});
+				return [
+					{ type: "text-delta", text: "steered done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const addedMessages: AgentMessage[] = [];
+		const runtime = new AgentRuntime({
+			model,
+			tools: [createEchoTool()],
+			consumePendingUserMessage,
+		});
+		runtime.subscribe((event) => {
+			if (event.type === "message-added") {
+				addedMessages.push(event.message);
+			}
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(consumePendingUserMessage).toHaveBeenCalledTimes(1);
+		expect(model.requests).toHaveLength(2);
+		expect(result.status).toBe("completed");
+		expect(result.messages.map((message) => message.role)).toEqual([
+			"user",
+			"assistant",
+			"tool",
+			"user",
+			"assistant",
+		]);
+		expect(
+			addedMessages.some(
+				(message) =>
+					message.role === "user" &&
+					message.content.some(
+						(part) => part.type === "text" && part.text === "steer now",
+					),
+			),
+		).toBe(true);
+	});
+
+	it("injects pending user messages before prepareTurn projects the provider request", async () => {
+		const consumePendingUserMessage = vi.fn(() => "steer before prepare");
+		const prepareTurn = vi.fn(
+			(context: { messages: readonly AgentMessage[] }) => ({
+				messages: context.messages.slice(),
+			}),
+		);
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				expect(request.messages.at(-1)).toMatchObject({
+					role: "user",
+					content: [{ type: "text", text: "steer before prepare" }],
+				});
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [createEchoTool()],
+			prepareTurn,
+			consumePendingUserMessage,
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(prepareTurn).toHaveBeenCalledTimes(2);
+		expect(consumePendingUserMessage).toHaveBeenCalledTimes(1);
+		expect(result.messages.map((message) => message.role)).toEqual([
+			"user",
+			"assistant",
+			"tool",
+			"user",
+			"assistant",
+		]);
+		const secondPrepareMessages = prepareTurn.mock.calls[1]?.[0].messages;
+		expect(secondPrepareMessages.at(-1)).toMatchObject({
+			role: "user",
+			content: [{ type: "text", text: "steer before prepare" }],
+		});
+	});
+
+	it("lets prepareTurn project tool results after pending user input is added", async () => {
+		const consumePendingUserMessage = vi.fn(() => "latest steering");
+		const hugeToolOutput = "x".repeat(100_000);
+		const prepareTurn = vi.fn(
+			(context: { messages: readonly AgentMessage[] }) => {
+				const latest = context.messages.at(-1);
+				if (
+					latest?.role === "user" &&
+					latest.content.some(
+						(part) => part.type === "text" && part.text === "latest steering",
+					)
+				) {
+					return {
+						messages: context.messages.filter(
+							(message) => message.role !== "tool",
+						),
+					};
+				}
+				return { messages: context.messages.slice() };
+			},
+		);
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_large",
+					toolName: "large",
+					inputText: "{}",
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				expect(JSON.stringify(request.messages)).not.toContain(hugeToolOutput);
+				expect(request.messages.at(-1)).toMatchObject({
+					role: "user",
+					content: [{ type: "text", text: "latest steering" }],
+				});
+				return [
+					{ type: "text-delta", text: "compacted" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "large",
+					description: "Large output",
+					inputSchema: { type: "object" },
+					execute: async () => hugeToolOutput,
+				},
+			],
+			prepareTurn,
+			consumePendingUserMessage,
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("compacted");
+		expect(prepareTurn).toHaveBeenCalledTimes(2);
+		const secondPrepareMessages = prepareTurn.mock.calls[1]?.[0].messages;
+		expect(JSON.stringify(secondPrepareMessages)).toContain(hugeToolOutput);
+		expect(secondPrepareMessages.at(-1)).toMatchObject({
+			role: "user",
+			content: [{ type: "text", text: "latest steering" }],
+		});
+	});
+
+	it("continues when completionGuard rejects a no-tool response", async () => {
+		const submitTool: AgentTool<{ summary: string }, string> = {
+			name: "submit",
+			description: "Submit final answer",
+			inputSchema: { type: "object" },
+			lifecycle: { completesRun: true },
+			async execute(input) {
+				return `submitted: ${input.summary}`;
+			},
+		};
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "I am done" },
+				{ type: "finish", reason: "stop" },
+			],
+			(request) => {
+				const reminder = request.messages.at(-1);
+				expect(reminder?.role).toBe("user");
+				expect(
+					reminder?.content.some(
+						(part) => part.type === "text" && part.text.includes("submit"),
+					),
+				).toBe(true);
+				return [
+					{
+						type: "tool-call-delta",
+						toolCallId: "call_submit",
+						toolName: "submit",
+						inputText: '{"summary":"done"}',
+					},
+					{ type: "finish", reason: "tool-calls" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [submitTool],
+			completionPolicy: {
+				completionGuard: () =>
+					"[SYSTEM] This run is not complete until you call submit.",
+			},
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.iterations).toBe(2);
+		expect(result.outputText).toBe("submitted: done");
+		expect(model.requests).toHaveLength(2);
+	});
+
+	it("announces and enforces required completion tools from tool lifecycle metadata", async () => {
+		const submitTool: AgentTool<{ summary: string }, string> = {
+			name: "custom_finish",
+			description: "Submit final answer",
+			inputSchema: { type: "object" },
+			lifecycle: { completesRun: true },
+			async execute(input) {
+				return `submitted: ${input.summary}`;
+			},
+		};
+		const model = new ScriptedModel([
+			(request) => {
+				const reminder = request.messages.at(-1);
+				expect(reminder?.role).toBe("user");
+				expect(
+					reminder?.content.some(
+						(part) =>
+							part.type === "text" && part.text.includes("custom_finish"),
+					),
+				).toBe(true);
+				return [
+					{ type: "text-delta", text: "I am done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+			(request) => {
+				const reminder = request.messages.at(-1);
+				expect(reminder?.role).toBe("user");
+				expect(
+					reminder?.content.some(
+						(part) =>
+							part.type === "text" && part.text.includes("custom_finish"),
+					),
+				).toBe(true);
+				return [
+					{
+						type: "tool-call-delta",
+						toolCallId: "call_submit",
+						toolName: "custom_finish",
+						inputText: '{"summary":"done"}',
+					},
+					{ type: "finish", reason: "tool-calls" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [submitTool],
+			completionPolicy: { requireCompletionTool: true },
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.iterations).toBe(2);
+		expect(result.outputText).toBe("submitted: done");
+		expect(model.requests).toHaveLength(2);
+	});
+
+	it("finishes immediately after a successful terminal tool call", async () => {
+		const submitTool: AgentTool<{ summary: string }, string> = {
+			name: "submit",
+			description: "Submit final answer",
+			inputSchema: { type: "object" },
+			lifecycle: { completesRun: true },
+			async execute(input) {
+				return input.summary;
+			},
+		};
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_submit",
+					toolName: "submit",
+					inputText: '{"summary":"finished"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [submitTool],
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.iterations).toBe(1);
+		expect(result.outputText).toBe("finished");
+		expect(model.requests).toHaveLength(1);
+	});
+
+	it("preserves structured multimodal tool results for the next model request", async () => {
+		const structuredOutput = [
+			{ type: "text", text: "Successfully read image" },
+			{ type: "image", data: "QkFTRTY0REFUQQ==", mediaType: "image/jpeg" },
+		];
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_img",
+					toolName: "read_file",
+					inputText: '{"path":"/tmp/image.jpg"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				expect(toolMessage.content[0]).toMatchObject({
+					type: "tool-result",
+					toolCallId: "call_img",
+					toolName: "read_file",
+					output: structuredOutput,
+				});
+				return [
+					{ type: "text-delta", text: "saw image" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "read_file",
+					description: "Read file",
+					inputSchema: { type: "object" },
+					execute: async () => structuredOutput,
+				},
+			],
+		});
+
+		const result = await runtime.run("Inspect image");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("saw image");
+	});
+
+	it("preserves plain tool outputs that contain an output property", async () => {
+		const plainOutput = {
+			output: "nested value",
+			status: "ok",
+			count: 2,
+		};
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_plain",
+					toolName: "plain_output",
+					inputText: "{}",
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				expect(toolMessage.content[0]).toMatchObject({
+					type: "tool-result",
+					toolCallId: "call_plain",
+					toolName: "plain_output",
+					output: plainOutput,
+				});
+				return [
+					{ type: "text-delta", text: "preserved" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "plain_output",
+					description: "Return a plain object with an output key",
+					inputSchema: { type: "object" },
+					execute: async () => plainOutput,
+				},
+			],
+		});
+
+		const result = await runtime.run("Run tool");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("preserved");
+	});
+
+	it("requests approval when a tool policy disables auto-approval", async () => {
+		const executeTool = vi.fn(async () => ({ echoed: "hi" }));
+		const requestToolApproval = vi.fn(async () => ({
+			approved: false,
+			reason: "denied by test",
+		}));
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_approval",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				expect(toolMessage.content[0]).toMatchObject({
+					type: "tool-result",
+					isError: true,
+					output: { error: "denied by test" },
+				});
+				return [
+					{ type: "text-delta", text: "approval handled" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			sessionId: "session_test",
+			agentId: "agent_test",
+			conversationId: "conversation_test",
+			model,
+			tools: [
+				{
+					name: "echo",
+					description: "Echo input text",
+					inputSchema: { type: "object" },
+					execute: executeTool,
+				},
+			],
+			toolPolicies: { "*": { autoApprove: false } },
+			requestToolApproval,
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("approval handled");
+		expect(executeTool).not.toHaveBeenCalled();
+		expect(requestToolApproval).toHaveBeenCalledWith({
+			sessionId: "session_test",
+			agentId: "agent_test",
+			conversationId: "conversation_test",
+			iteration: 1,
+			toolCallId: "call_approval",
+			toolName: "echo",
+			input: { text: "hi" },
+			policy: { autoApprove: false },
+		});
+	});
+
+	it("applies beforeTool approval policy overrides before executing tools", async () => {
+		const executeTool = vi.fn(async () => ({ echoed: "hi" }));
+		const requestToolApproval = vi.fn(async () => ({
+			approved: false,
+			reason: "live policy denied",
+		}));
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_live_policy",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				expect(toolMessage.content[0]).toMatchObject({
+					type: "tool-result",
+					isError: true,
+					output: { error: "live policy denied" },
+				});
+				return [
+					{ type: "text-delta", text: "live policy handled" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			sessionId: "session_test",
+			agentId: "agent_test",
+			conversationId: "conversation_test",
+			model,
+			tools: [
+				{
+					name: "echo",
+					description: "Echo input text",
+					inputSchema: { type: "object" },
+					execute: executeTool,
+				},
+			],
+			toolPolicies: { "*": { autoApprove: true } },
+			hooks: {
+				beforeTool: () => ({ policy: { autoApprove: false } }),
+			},
+			requestToolApproval,
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("live policy handled");
+		expect(executeTool).not.toHaveBeenCalled();
+		expect(requestToolApproval).toHaveBeenCalledWith({
+			sessionId: "session_test",
+			agentId: "agent_test",
+			conversationId: "conversation_test",
+			iteration: 1,
+			toolCallId: "call_live_policy",
+			toolName: "echo",
+			input: { text: "hi" },
+			policy: { autoApprove: false },
+		});
+	});
+
+	it("stores tool calls but skips execution when metadata disables external execution", async () => {
+		const executeTool = vi.fn(async () => ({ echoed: "hi" }));
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+					metadata: {
+						toolSource: {
+							providerId: "openai-codex",
+							modelId: "gpt-5-codex",
+							executionMode: "provider",
+						},
+					},
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "echo",
+					description: "Echo input text",
+					inputSchema: { type: "object" },
+					execute: executeTool,
+				},
+			],
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("done");
+		expect(executeTool).not.toHaveBeenCalled();
+		const toolMessages = result.messages.filter(
+			(message) => message.role === "tool",
+		);
+		expect(toolMessages).toHaveLength(1);
+		expect(toolMessages[0]?.content).toEqual([
+			expect.objectContaining({
+				type: "tool-result",
+				toolCallId: "call_1",
+				toolName: "echo",
+				isError: true,
+				output: {
+					error: "Tool execution is disabled for provider openai-codex",
+				},
+			}),
+		]);
+	});
+
+	it("shows provider-disabled message even when tool is not registered locally", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "shell",
+					inputText: '{"command":"echo hi"}',
+					metadata: {
+						toolSource: {
+							providerId: "openai-codex",
+							executionMode: "provider",
+						},
+					},
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [], // shell tool is not registered
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("done");
+		const toolMessages = result.messages.filter(
+			(message) => message.role === "tool",
+		);
+		expect(toolMessages).toHaveLength(1);
+		expect(toolMessages[0]?.content).toEqual([
+			expect.objectContaining({
+				type: "tool-result",
+				toolCallId: "call_1",
+				toolName: "shell",
+				isError: true,
+				output: {
+					error: "Tool execution is disabled for provider openai-codex",
+				},
+			}),
+		]);
+	});
+
+	it("normalizes JSON-encoded string fields when the tool schema expects arrays", async () => {
+		const executeTool = vi.fn(async (input: { commands: string[] }) => ({
+			joined: input.commands.join(" && "),
+		}));
+		const beforeTool = vi.fn();
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_commands",
+					toolName: "commands",
+					inputText: JSON.stringify({
+						commands: JSON.stringify(["git status", "bun test"]),
+					}),
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				expect(toolMessage.content[0]).toMatchObject({
+					type: "tool-result",
+					toolName: "commands",
+					output: { joined: "git status && bun test" },
+				});
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "commands",
+					description: "Run commands",
+					inputSchema: {
+						type: "object",
+						properties: {
+							commands: {
+								type: "array",
+								items: { type: "string" },
+							},
+						},
+					},
+					execute: executeTool,
+				},
+			],
+			hooks: {
+				beforeTool,
+			},
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(executeTool).toHaveBeenCalledWith(
+			{ commands: ["git status", "bun test"] },
+			expect.anything(),
+		);
+		expect(beforeTool).toHaveBeenCalledWith(
+			expect.objectContaining({
+				input: { commands: ["git status", "bun test"] },
+				toolCall: expect.objectContaining({
+					input: { commands: ["git status", "bun test"] },
+				}),
+			}),
+		);
+	});
+
+	it("preserves JSON-looking strings when the tool schema expects strings", async () => {
+		const executeTool = vi.fn(async (input: { text: string }) => ({
+			echoed: input.text,
+		}));
+		const jsonText = JSON.stringify({ keep: "as text" });
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_text",
+					toolName: "echo_json",
+					inputText: JSON.stringify({ text: jsonText }),
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			() => [
+				{ type: "text-delta", text: "done" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "echo_json",
+					description: "Echo JSON-looking text",
+					inputSchema: {
+						type: "object",
+						properties: {
+							text: { type: "string" },
+						},
+					},
+					execute: executeTool,
+				},
+			],
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(executeTool).toHaveBeenCalledWith(
+			{ text: jsonText },
+			expect.anything(),
+		);
+	});
+
+	it("treats an unset maxIterations as unlimited", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"first"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_2",
+					toolName: "echo",
+					inputText: '{"text":"second"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			() => [
+				{ type: "text-delta", text: "done" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({ model, tools: [createEchoTool()] });
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.iterations).toBe(3);
+		expect(result.outputText).toBe("done");
+	});
+
+	it("supports plugin-contributed tools and hooks", async () => {
+		const beforeRun = vi.fn();
+		const plugin: AgentRuntimePlugin = {
+			name: "plugin-tool",
+			setup: () => ({
+				hooks: {
+					beforeRun,
+				},
+				tools: [
+					{
+						name: "plugin_tool",
+						description: "Provided by a plugin",
+						inputSchema: { type: "object" },
+						execute: async () => ({ ok: true }),
+					},
+				],
+			}),
+		};
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_plugin",
+					toolName: "plugin_tool",
+					inputText: "{}",
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			() => [
+				{ type: "text-delta", text: "plugin complete" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+
+		const runtime = new AgentRuntime({
+			model,
+			conversationId: "conversation_plugin",
+			plugins: [plugin],
+		});
+		const result = await runtime.run("Run plugin");
+
+		expect(beforeRun).toHaveBeenCalledOnce();
+		expect(beforeRun).toHaveBeenCalledWith({
+			snapshot: expect.objectContaining({
+				conversationId: "conversation_plugin",
+			}),
+		});
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("plugin complete");
+	});
+
+	it("unwinds cleanly when beforeRun stops the run", async () => {
+		const events: string[] = [];
+		let stopNextRun = true;
+		const runtime = new AgentRuntime({
+			model: new ScriptedModel([
+				() => [
+					{ type: "text-delta", text: "second run" },
+					{ type: "finish", reason: "stop" },
+				],
+			]),
+			hooks: {
+				beforeRun: async () => {
+					if (!stopNextRun) {
+						return undefined;
+					}
+					stopNextRun = false;
+					return { stop: true, reason: "blocked" };
+				},
+			},
+		});
+		runtime.subscribe((event) => {
+			events.push(event.type);
+		});
+
+		const first = await runtime.run("first");
+		const second = await runtime.run("second");
+
+		expect(first.status).toBe("aborted");
+		expect(first.error).toBeUndefined();
+		expect(events[0]).toBe("run-finished");
+		expect(events).toContain("run-started");
+		expect(events.at(-1)).toBe("run-finished");
+		expect(second.status).toBe("completed");
+		expect(second.outputText).toBe("second run");
+		expect(runtime.snapshot().status).toBe("completed");
+	});
+
+	it("annotates assistant messages with per-turn metrics and model info", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "usage",
+					usage: {
+						inputTokens: 12,
+						outputTokens: 7,
+						cacheReadTokens: 3,
+						cacheWriteTokens: 2,
+						reasoningTokenCount: 5,
+						totalCost: 0.42,
+					},
+				},
+				{ type: "text-delta", text: "hello" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			messageModelInfo: {
+				id: "anthropic/claude-sonnet-4.6",
+				provider: "openrouter",
+				family: "claude-sonnet",
+			},
+		});
+
+		const result = await runtime.run("Hi");
+		const assistant = result.messages.at(-1);
+
+		expect(assistant?.role).toBe("assistant");
+		expect(assistant?.modelInfo).toEqual({
+			id: "anthropic/claude-sonnet-4.6",
+			provider: "openrouter",
+			family: "claude-sonnet",
+		});
+		expect(assistant?.metrics).toEqual({
+			inputTokens: 12,
+			outputTokens: 7,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+			reasoningTokenCount: 5,
+			cost: 0.42,
+		});
+	});
+
+	it("captures telemetry when disabled reasoning still reports reasoning tokens", async () => {
+		const telemetry = {
+			capture: vi.fn(),
+			captureRequired: vi.fn(),
+			setDistinctId: vi.fn(),
+			setMetadata: vi.fn(),
+			updateMetadata: vi.fn(),
+			setCommonProperties: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: vi.fn(async () => undefined),
+			dispose: vi.fn(async () => undefined),
+		} as unknown as ITelemetryService;
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "usage",
+					usage: {
+						inputTokens: 12,
+						outputTokens: 7,
+						reasoningTokenCount: 5,
+					},
+				},
+				{ type: "text-delta", text: "hello" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			modelOptions: { thinking: false },
+			messageModelInfo: {
+				id: "z-ai/glm-4.7",
+				provider: "openrouter",
+			},
+			telemetry,
+		});
+
+		await runtime.run("Hi");
+
+		expect(telemetry.capture).toHaveBeenCalledWith(
+			expect.objectContaining({
+				event: AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+				properties: expect.objectContaining({
+					providerId: "openrouter",
+					modelId: "z-ai/glm-4.7",
+					requestedThinking: false,
+					reasoningTokenCount: 5,
+					iteration: 1,
+				}),
+			}),
+		);
+	});
+
+	it("stops a run from beforeModel hooks and returns an aborted result", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "should not happen" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			hooks: {
+				beforeModel: () => ({ stop: true, reason: "approval required" }),
+			},
+		});
+
+		const result = await runtime.run("Stop early");
+
+		expect(result.status).toBe("aborted");
+		expect(result.error).toBeUndefined();
+		expect(result.outputText).toBe("");
+		expect(model.requests).toHaveLength(0);
+	});
+
+	it("projects the provider request without overwriting canonical messages", async () => {
+		const projectedMessage: AgentMessage = {
+			id: "msg_projected",
+			role: "user",
+			content: [{ type: "text", text: "projected context" }],
+			createdAt: 1,
+		};
+		const notices: string[] = [];
+		const prepareTurn = vi.fn((context) => {
+			expect(context.messages).toHaveLength(1);
+			expect(context.messages[0]?.content).toEqual([
+				{ type: "text", text: "large context" },
+			]);
+			context.emitStatusNotice?.("auto-compacting", {
+				reason: "auto_compaction",
+			});
+			return {
+				messages: [projectedMessage],
+				systemPrompt: "projected system",
+			};
+		});
+		const beforeModel = vi.fn(({ request }) => {
+			expect(request.systemPrompt).toBe("projected system");
+			expect(request.messages).toEqual([projectedMessage]);
+			return undefined;
+		});
+		const model = new ScriptedModel([
+			(request) => {
+				expect(request.systemPrompt).toBe("projected system");
+				expect(request.messages).toEqual([projectedMessage]);
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			systemPrompt: "original system",
+			prepareTurn,
+			hooks: { beforeModel },
+		});
+		runtime.subscribe((event) => {
+			if (event.type === "status-notice") {
+				notices.push(event.message);
+			}
+		});
+
+		const result = await runtime.run("large context");
+
+		expect(prepareTurn).toHaveBeenCalledTimes(1);
+		expect(beforeModel).toHaveBeenCalledTimes(1);
+		expect(notices).toEqual(["auto-compacting"]);
+		expect(model.requests[0]?.messages).toEqual([projectedMessage]);
+		expect(result.messages[0]).toMatchObject({
+			role: "user",
+			content: [{ type: "text", text: "large context" }],
+		});
+		expect(result.messages).toHaveLength(2);
+		expect(result.messages).not.toContainEqual(projectedMessage);
+		expect(model.requests).toHaveLength(1);
+	});
+
+	it("merges beforeModel options metadata into the model request", async () => {
+		const model = new ScriptedModel([
+			(request) => {
+				expect(request.options?.metadata).toMatchObject({
+					sessionId: "session-1",
+					runId: "run-1",
+					iteration: 1,
+				});
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			modelOptions: { metadata: { existing: true } },
+			hooks: {
+				beforeModel: () => ({
+					options: {
+						metadata: {
+							sessionId: "session-1",
+							runId: "run-1",
+							iteration: 1,
+						},
+					},
+				}),
+			},
+		});
+
+		await runtime.run("capture metadata");
+
+		expect(model.requests).toHaveLength(1);
+		expect(model.requests[0]?.options?.metadata).toMatchObject({
+			existing: true,
+			sessionId: "session-1",
+			runId: "run-1",
+			iteration: 1,
+		});
+	});
+
+	it("stamps runtime identity metadata onto model requests", async () => {
+		const model = new ScriptedModel([
+			(request) => {
+				const metadata = request.options?.metadata as
+					| Record<string, unknown>
+					| undefined;
+				expect(metadata).toMatchObject({
+					sessionId: "session-runtime",
+					agentId: "agent-runtime",
+					conversationId: "conversation-runtime",
+					iteration: 1,
+				});
+				expect(typeof metadata?.runId).toBe("string");
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			sessionId: "session-runtime",
+			agentId: "agent-runtime",
+			conversationId: "conversation-runtime",
+			model,
+		});
+
+		await runtime.run("capture metadata");
+
+		expect(model.requests).toHaveLength(1);
+	});
+
+	it("does not synthesize session or conversation ids in model request metadata", async () => {
+		const model = new ScriptedModel([
+			(request) => {
+				const metadata = request.options?.metadata as
+					| Record<string, unknown>
+					| undefined;
+				expect(metadata).not.toHaveProperty("sessionId");
+				expect(metadata).not.toHaveProperty("conversationId");
+				expect(metadata).toMatchObject({
+					agentId: "agent-runtime",
+					iteration: 1,
+				});
+				expect(typeof metadata?.runId).toBe("string");
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			agentId: "agent-runtime",
+			model,
+		});
+
+		await runtime.run("capture metadata");
+
+		expect(model.requests).toHaveLength(1);
+	});
+
+	it("preserves the existing system prompt when prepareTurn returns only messages", async () => {
+		const projectedMessage: AgentMessage = {
+			id: "msg_projected",
+			role: "user",
+			content: [{ type: "text", text: "projected context" }],
+			createdAt: 1,
+		};
+		const model = new ScriptedModel([
+			(request) => {
+				expect(request.systemPrompt).toBe("original system");
+				expect(request.messages).toEqual([projectedMessage]);
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			systemPrompt: "original system",
+			prepareTurn: () => ({ messages: [projectedMessage] }),
+		});
+
+		await runtime.run("large context");
+
+		expect(model.requests).toHaveLength(1);
+	});
+
+	it("can block a tool through beforeTool hooks", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "blocked",
+					toolName: "echo",
+					inputText: '{"text":"x"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolResult = request.messages.at(-1)?.content[0];
+				expect(toolResult).toMatchObject({
+					type: "tool-result",
+					isError: true,
+				});
+				return [
+					{ type: "text-delta", text: "recovered" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			tools: [createEchoTool()],
+			hooks: {
+				beforeTool: () => ({ skip: true, reason: "policy denied" }),
+			},
+		});
+
+		const result = await runtime.run("Block it");
+
+		expect(result.status).toBe("completed");
+		const toolMessage = result.messages.find(
+			(message) => message.role === "tool",
+		);
+		expect(toolMessage?.content[0]).toMatchObject({
+			type: "tool-result",
+			isError: true,
+		});
+	});
+
+	it("treats invalid tool-call JSON as a tool error instead of failing the run", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "bad_json",
+					toolName: "echo",
+					inputText: '{"text":"bad\\x"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolResult = request.messages.at(-1)?.content[0];
+				expect(toolResult).toMatchObject({
+					type: "tool-result",
+					toolName: "echo",
+					isError: true,
+					output: {
+						error: expect.stringContaining(
+							"Tool call echo emitted invalid JSON arguments",
+						),
+					},
+				});
+				return [
+					{ type: "text-delta", text: "recovered" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({ model, tools: [createEchoTool()] });
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("recovered");
+	});
+
+	it("recovers when a model stream reports an invalid tool input error after a tool call", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "bad_json",
+					toolName: "echo",
+					inputText: '{"text": find /tmp | head -20}',
+				},
+				{
+					type: "finish",
+					reason: "error",
+					error: "Invalid input for tool echo",
+				},
+			],
+			(request) => {
+				const toolMessage = request.messages.at(-1) as AgentMessage;
+				expect(toolMessage.role).toBe("tool");
+				expect(toolMessage.content[0]).toMatchObject({
+					type: "tool-result",
+					toolName: "echo",
+					isError: true,
+					output: {
+						error: expect.stringContaining(
+							"Tool call echo emitted invalid JSON arguments",
+						),
+					},
+				});
+				return [
+					{ type: "text-delta", text: "recovered" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({ model, tools: [createEchoTool()] });
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("recovered");
+		expect(
+			result.messages.filter((message) => message.role === "tool"),
+		).toHaveLength(1);
+	});
+
+	it("merges metadata from repeated tool-call deltas", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_with_metadata",
+					toolName: "echo",
+					inputText: '{"text":"hi"}',
+					metadata: {
+						thoughtSignature: "sig_123",
+					},
+				},
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_with_metadata",
+					toolName: "echo",
+					metadata: {
+						inputParseError: "adapter rejected tool input",
+					},
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const assistantMessage = request.messages.find(
+					(message) => message.role === "assistant",
+				);
+				const toolCall = assistantMessage?.content.find(
+					(part) => part.type === "tool-call",
+				);
+				expect(toolCall).toMatchObject({
+					type: "tool-call",
+					metadata: {
+						thoughtSignature: "sig_123",
+						inputParseError: "adapter rejected tool input",
+					},
+				});
+				const toolResult = request.messages.at(-1)?.content[0];
+				expect(toolResult).toMatchObject({
+					type: "tool-result",
+					isError: true,
+					output: {
+						error: "adapter rejected tool input",
+					},
+				});
+				return [
+					{ type: "text-delta", text: "recovered" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const executeTool = vi.fn(async () => ({ echoed: "hi" }));
+		const runtime = new AgentRuntime({
+			model,
+			tools: [
+				{
+					name: "echo",
+					description: "Echo input text",
+					inputSchema: { type: "object" },
+					execute: executeTool,
+				},
+			],
+		});
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("recovered");
+		expect(executeTool).not.toHaveBeenCalled();
+	});
+
+	it("accepts corrected full argument snapshots for the same streamed tool call", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"oops"}',
+				},
+				{
+					type: "tool-call-delta",
+					toolCallId: "call_1",
+					toolName: "echo",
+					inputText: '{"text":"fixed"}',
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			(request) => {
+				const toolResult = request.messages.at(-1)?.content[0];
+				expect(toolResult).toMatchObject({
+					type: "tool-result",
+					toolName: "echo",
+					output: { echoed: "fixed" },
+				});
+				return [
+					{ type: "text-delta", text: "done" },
+					{ type: "finish", reason: "stop" },
+				];
+			},
+		]);
+		const runtime = new AgentRuntime({ model, tools: [createEchoTool()] });
+
+		const result = await runtime.run("Start");
+
+		expect(result.status).toBe("completed");
+		expect(result.outputText).toBe("done");
+	});
+
+	it("executes tools in parallel but preserves assistant order in appended messages", async () => {
+		const executionOrder: string[] = [];
+		const finishOrder: string[] = [];
+		const slow: AgentTool = {
+			name: "slow",
+			description: "slow tool",
+			inputSchema: { type: "object" },
+			async execute() {
+				executionOrder.push("slow-start");
+				await new Promise((resolve) => setTimeout(resolve, 25));
+				finishOrder.push("slow-finish");
+				return { name: "slow" };
+			},
+		};
+		const fast: AgentTool = {
+			name: "fast",
+			description: "fast tool",
+			inputSchema: { type: "object" },
+			async execute() {
+				executionOrder.push("fast-start");
+				finishOrder.push("fast-finish");
+				return { name: "fast" };
+			},
+		};
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "slow_call",
+					toolName: "slow",
+					inputText: "{}",
+				},
+				{
+					type: "tool-call-delta",
+					toolCallId: "fast_call",
+					toolName: "fast",
+					inputText: "{}",
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			() => [
+				{ type: "text-delta", text: "done" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+
+		const runtime = new AgentRuntime({
+			model,
+			tools: [slow, fast],
+			toolExecution: "parallel",
+		});
+
+		const result = await runtime.run("Parallel");
+
+		expect(executionOrder).toEqual(["slow-start", "fast-start"]);
+		expect(finishOrder).toEqual(["fast-finish", "slow-finish"]);
+		const toolMessages = result.messages.filter(
+			(message) => message.role === "tool",
+		);
+		expect(toolMessages[0]?.content[0]).toMatchObject({ toolName: "slow" });
+		expect(toolMessages[1]?.content[0]).toMatchObject({ toolName: "fast" });
+	});
+
+	it("captures events, logger calls, telemetry, and failed tool runs", async () => {
+		const telemetry = {
+			capture: vi.fn(),
+			captureRequired: vi.fn(),
+			setDistinctId: vi.fn(),
+			setMetadata: vi.fn(),
+			updateMetadata: vi.fn(),
+			setCommonProperties: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: vi.fn(async () => undefined),
+			dispose: vi.fn(async () => undefined),
+		} as unknown as ITelemetryService;
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const events: string[] = [];
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "tool-call-delta",
+					toolCallId: "boom_call",
+					toolName: "boom",
+					inputText: "{}",
+				},
+				{ type: "finish", reason: "tool-calls" },
+			],
+			() => [{ type: "finish", reason: "error", error: "model failed" }],
+		]);
+		const runtime = new AgentRuntime({
+			model,
+			logger,
+			telemetry,
+			tools: [
+				{
+					name: "boom",
+					description: "throws",
+					inputSchema: { type: "object" },
+					async execute() {
+						throw new Error("tool exploded");
+					},
+				},
+			],
+		});
+		runtime.subscribe((event) => {
+			events.push(event.type);
+		});
+
+		const result = await runtime.run("Fail");
+
+		expect(result.status).toBe("failed");
+		expect(events).toContain("run-failed");
+		expect(logger.error).toHaveBeenCalled();
+		expect(telemetry.capture).toHaveBeenCalled();
+	});
+
+	it("propagates agent identity including role through snapshots and plugin setup", async () => {
+		const setup = vi.fn(() => undefined);
+		const plugin: AgentRuntimePlugin = {
+			name: "identity",
+			setup,
+		};
+		const model = new ScriptedModel([
+			() => [
+				{ type: "text-delta", text: "ok" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({
+			agentId: "lead-1",
+			agentRole: "lead",
+			model,
+			plugins: [plugin],
+		});
+
+		const snapshots: Array<{ agentId: string; agentRole?: string }> = [];
+		runtime.subscribe((event) => {
+			snapshots.push({
+				agentId: event.snapshot.agentId,
+				agentRole: event.snapshot.agentRole,
+			});
+		});
+
+		const result = await runtime.run("Identity");
+
+		expect(setup).toHaveBeenCalledWith({
+			agentId: "lead-1",
+			agentRole: "lead",
+			systemPrompt: undefined,
+		});
+		expect(result.agentId).toBe("lead-1");
+		expect(result.agentRole).toBe("lead");
+		expect(snapshots.every((snapshot) => snapshot.agentId === "lead-1")).toBe(
+			true,
+		);
+		expect(snapshots.every((snapshot) => snapshot.agentRole === "lead")).toBe(
+			true,
+		);
+	});
+
+	it("resets usage between consecutive run/continue calls", async () => {
+		const model = new ScriptedModel([
+			() => [
+				{
+					type: "usage",
+					usage: { inputTokens: 100, outputTokens: 20, totalCost: 0.5 },
+				},
+				{ type: "text-delta", text: "first" },
+				{ type: "finish", reason: "stop" },
+			],
+			() => [
+				{
+					type: "usage",
+					usage: { inputTokens: 200, outputTokens: 40, totalCost: 1.0 },
+				},
+				{ type: "text-delta", text: "second" },
+				{ type: "finish", reason: "stop" },
+			],
+		]);
+		const runtime = new AgentRuntime({ model });
+
+		const first = await runtime.run("Turn 1");
+		expect(first.usage).toMatchObject({
+			inputTokens: 100,
+			outputTokens: 20,
+			totalCost: 0.5,
+		});
+
+		const second = await runtime.continue("Turn 2");
+		expect(second.usage).toMatchObject({
+			inputTokens: 200,
+			outputTokens: 40,
+			totalCost: 1.0,
+		});
+	});
+});
diff --git a/sdk/packages/agents/src/agent-runtime.ts b/sdk/packages/agents/src/agent-runtime.ts
new file mode 100644
index 0000000..2edf491
--- /dev/null
+++ b/sdk/packages/agents/src/agent-runtime.ts
@@ -0,0 +1,1650 @@
+import { createGateway, type GatewayProviderSettings } from "@cline/llms";
+import type {
+	AgentAfterToolResult,
+	AgentBeforeModelResult,
+	AgentBeforeToolResult,
+	AgentMessage,
+	AgentMessagePart,
+	AgentModel,
+	AgentModelFinishReason,
+	AgentModelRequest,
+	AgentRunResult,
+	AgentRuntimeEvent,
+	AgentRuntimeHooks,
+	AgentRuntimeStateSnapshot,
+	AgentStopControl,
+	AgentTool,
+	AgentToolCallPart,
+	AgentToolDefinition,
+	AgentToolResult,
+	AgentUsage,
+	AgentRuntimeConfig as BaseAgentRuntimeConfig,
+	TelemetryProperties,
+	ToolApprovalResult,
+	ToolPolicy,
+} from "@cline/shared";
+import {
+	captureAgentUnexpectedReasoningTokens,
+	captureSdkError,
+	estimateTokens,
+	mergeModelOptions,
+	normalizeJsonLikeStringsForSchema,
+	omitUndefinedValues,
+	trimNonEmpty,
+} from "@cline/shared";
+import { nanoid } from "nanoid";
+
+// Local `createUID` helper. The clinee source imports this from
+// `@cline/shared` (see `packages/shared/dist/identifier.ts`), but
+// sdk-re's shared package does not expose it yet. Inlining here keeps
+// PLAN.md Step 1 scoped to `packages/agents/src/` and matches the
+// exact clinee implementation (`${prefix}_${nanoid(length)}`).
+function createUID(prefix: string, length = 8): string {
+	return `${prefix}_${nanoid(length)}`;
+}
+
+export type AgentRunInput = string | AgentMessage | readonly AgentMessage[];
+export type AgentEventListener = (event: AgentRuntimeEvent) => void;
+
+/**
+ * Advanced form: caller supplies a pre-built `AgentModel`. Used by
+ * `@cline/core`, which constructs models itself to share gateway/telemetry
+ * wiring with the rest of the session runtime.
+ */
+export interface AgentRuntimeConfigWithModel extends BaseAgentRuntimeConfig {
+	model: AgentModel;
+}
+
+/**
+ * Friendly form: caller supplies provider/model IDs and credentials, and the
+ * runtime builds an `AgentModel` internally via `@cline/llms`. This is the
+ * entry point most standalone users want.
+ */
+export interface AgentRuntimeConfigWithProvider
+	extends Omit<BaseAgentRuntimeConfig, "model"> {
+	/** Provider ID (e.g., "anthropic", "openai") */
+	providerId: string;
+	/** Model ID to use */
+	modelId: string;
+	/** API key for the provider */
+	apiKey?: string;
+	/** Custom base URL for the API */
+	baseUrl?: string;
+	/** Additional headers for API requests */
+	headers?: Record<string, string>;
+	/** Provider-specific gateway options */
+	options?: GatewayProviderSettings["options"];
+}
+
+/**
+ * Config accepted by `new AgentRuntime(...)` / `createAgentRuntime(...)` /
+ * `new Agent(...)` / `createAgent(...)`. Either supply a pre-built `model`
+ * (advanced) or `providerId` + `modelId` (+ credentials) and the runtime will
+ * construct the model itself via `@cline/llms`.
+ */
+export type AgentRuntimeConfig =
+	| AgentRuntimeConfigWithModel
+	| AgentRuntimeConfigWithProvider;
+
+function hasPrebuiltModel(
+	config: AgentRuntimeConfig,
+): config is AgentRuntimeConfigWithModel {
+	return (config as AgentRuntimeConfigWithModel).model !== undefined;
+}
+
+function resolveRuntimeConfig(
+	config: AgentRuntimeConfig,
+): BaseAgentRuntimeConfig {
+	if (hasPrebuiltModel(config)) {
+		return config;
+	}
+	const { providerId, modelId, apiKey, baseUrl, headers, options, ...rest } =
+		config;
+	const gateway = createGateway({
+		providerConfigs: [{ providerId, apiKey, baseUrl, headers, options }],
+		telemetry: rest.telemetry,
+	});
+	const model = gateway.createAgentModel({ providerId, modelId });
+	// The prebuilt-model path preserves a caller-provided messageModelInfo;
+	// mirror that here so the provider/model constructor also tags assistant
+	// messages with modelInfo. An explicit caller-provided value still wins.
+	const messageModelInfo = rest.messageModelInfo ?? {
+		id: modelId,
+		provider: providerId,
+	};
+	return { ...rest, model, messageModelInfo };
+}
+
+function resolveToolPolicy(
+	toolName: string,
+	policies: BaseAgentRuntimeConfig["toolPolicies"],
+): ToolPolicy {
+	return {
+		...(policies?.["*"] ?? {}),
+		...(policies?.[toolName] ?? {}),
+	};
+}
+
+interface PendingToolAssembly {
+	toolCallId: string;
+	toolName?: string;
+	inputText: string;
+	inputValue?: unknown;
+	metadata?: unknown;
+	parseError?: string;
+}
+
+interface InvalidToolCall {
+	toolCallId: string;
+	toolName?: string;
+	input: Record<string, unknown>;
+	reason: "missing_name" | "missing_arguments" | "invalid_arguments";
+}
+
+function safeJsonSize(value: unknown): number {
+	try {
+		return JSON.stringify(value).length;
+	} catch {
+		return String(value).length;
+	}
+}
+
+function getOutputSize(output: unknown): number {
+	if (typeof output === "string") {
+		return output.length;
+	}
+	return safeJsonSize(output);
+}
+
+function summarizeModelRequest(
+	request: AgentModelRequest,
+): Record<string, unknown> {
+	let textChars = request.systemPrompt?.length ?? 0;
+	let toolResultCount = 0;
+	let toolResultChars = 0;
+	let maxToolResultChars = 0;
+	for (const message of request.messages) {
+		for (const part of message.content) {
+			switch (part.type) {
+				case "text":
+					textChars += part.text.length;
+					break;
+				case "reasoning":
+					textChars += part.text.length;
+					break;
+				case "file":
+					textChars += part.content.length;
+					break;
+				case "tool-call":
+					textChars += safeJsonSize(part.input);
+					break;
+				case "tool-result": {
+					const outputChars = getOutputSize(part.output);
+					toolResultCount += 1;
+					toolResultChars += outputChars;
+					maxToolResultChars = Math.max(maxToolResultChars, outputChars);
+					textChars += outputChars;
+					break;
+				}
+			}
+		}
+	}
+
+	return {
+		messageCount: request.messages.length,
+		toolSchemaCount: request.tools.length,
+		systemPromptChars: request.systemPrompt?.length ?? 0,
+		requestJsonChars: safeJsonSize({
+			systemPrompt: request.systemPrompt,
+			messages: request.messages,
+			tools: request.tools,
+			options: request.options,
+		}),
+		visibleTextChars: textChars,
+		estimatedTextTokens: estimateTokens(textChars),
+		toolResultCount,
+		toolResultChars,
+		maxToolResultChars,
+	};
+}
+
+interface PreparedToolExecution {
+	toolCall: AgentToolCallPart;
+	tool?: AgentTool;
+	input: unknown;
+	skipReason?: string;
+}
+
+interface HookBag {
+	beforeRun: NonNullable<AgentRuntimeHooks["beforeRun"]>[];
+	afterRun: NonNullable<AgentRuntimeHooks["afterRun"]>[];
+	beforeModel: NonNullable<AgentRuntimeHooks["beforeModel"]>[];
+	afterModel: NonNullable<AgentRuntimeHooks["afterModel"]>[];
+	beforeTool: NonNullable<AgentRuntimeHooks["beforeTool"]>[];
+	afterTool: NonNullable<AgentRuntimeHooks["afterTool"]>[];
+	onEvent: NonNullable<AgentRuntimeHooks["onEvent"]>[];
+}
+
+class ControlledStopError extends Error {
+	readonly reason?: string;
+
+	constructor(reason?: string) {
+		super(reason ?? "Run stopped by runtime control");
+		this.name = "ControlledStopError";
+		this.reason = reason;
+	}
+}
+
+export class AgentRuntimeAbortError extends Error {
+	readonly reason?: unknown;
+
+	constructor(reason?: unknown) {
+		const message =
+			typeof reason === "string"
+				? reason
+				: reason instanceof Error
+					? reason.message
+					: reason === undefined
+						? "Run aborted"
+						: String(reason);
+		super(message);
+		this.name = "AgentRuntimeAbortError";
+		this.reason = reason;
+	}
+}
+
+const DEFAULT_USAGE: AgentUsage = {
+	inputTokens: 0,
+	outputTokens: 0,
+	cacheReadTokens: 0,
+	cacheWriteTokens: 0,
+};
+
+function createMessage(
+	role: AgentMessage["role"],
+	content: AgentMessagePart[],
+	metadata?: Record<string, unknown>,
+): AgentMessage {
+	return {
+		id: createUID("msg"),
+		role,
+		content,
+		createdAt: Date.now(),
+		metadata,
+	};
+}
+
+function cloneUsage(usage: AgentUsage): AgentUsage {
+	return { ...usage };
+}
+
+function cloneMessages(messages: readonly AgentMessage[]): AgentMessage[] {
+	return messages.map((message) => ({
+		...message,
+		content: message.content.map((part: AgentMessagePart) => ({ ...part })),
+		metadata: message.metadata ? { ...message.metadata } : undefined,
+		modelInfo: message.modelInfo ? { ...message.modelInfo } : undefined,
+		metrics: message.metrics ? { ...message.metrics } : undefined,
+	}));
+}
+
+function usageDelta(
+	start: AgentUsage,
+	end: AgentUsage,
+): NonNullable<AgentMessage["metrics"]> | undefined {
+	const inputTokens = Math.max(
+		0,
+		(end.inputTokens ?? 0) - (start.inputTokens ?? 0),
+	);
+	const outputTokens = Math.max(
+		0,
+		(end.outputTokens ?? 0) - (start.outputTokens ?? 0),
+	);
+	const cacheReadTokens = Math.max(
+		0,
+		(end.cacheReadTokens ?? 0) - (start.cacheReadTokens ?? 0),
+	);
+	const cacheWriteTokens = Math.max(
+		0,
+		(end.cacheWriteTokens ?? 0) - (start.cacheWriteTokens ?? 0),
+	);
+	const reasoningTokenCount = Math.max(
+		0,
+		(end.reasoningTokenCount ?? 0) - (start.reasoningTokenCount ?? 0),
+	);
+	const startCost = start.totalCost ?? 0;
+	const endCost = end.totalCost ?? 0;
+	const cost = Math.max(0, endCost - startCost);
+	if (
+		inputTokens === 0 &&
+		outputTokens === 0 &&
+		cacheReadTokens === 0 &&
+		cacheWriteTokens === 0 &&
+		reasoningTokenCount === 0 &&
+		cost === 0
+	) {
+		return undefined;
+	}
+	return {
+		inputTokens: inputTokens > 0 ? inputTokens : 0,
+		outputTokens: outputTokens > 0 ? outputTokens : 0,
+		cacheReadTokens: cacheReadTokens > 0 ? cacheReadTokens : 0,
+		cacheWriteTokens: cacheWriteTokens > 0 ? cacheWriteTokens : 0,
+		...(reasoningTokenCount > 0 ? { reasoningTokenCount } : {}),
+		...(cost > 0 ? { cost } : {}),
+	};
+}
+
+function reasoningWasRequestedOff(request: AgentModelRequest): boolean {
+	return request.options?.thinking === false;
+}
+
+function textFromMessage(message: AgentMessage | undefined): string {
+	if (!message) {
+		return "";
+	}
+	return message.content
+		.filter(
+			(
+				part: AgentMessagePart,
+			): part is Extract<AgentMessagePart, { type: "text" }> =>
+				part.type === "text",
+		)
+		.map((part: Extract<AgentMessagePart, { type: "text" }>) => part.text)
+		.join("");
+}
+
+function textFromToolMessage(message: AgentMessage | undefined): string {
+	const result = message?.content.find(
+		(part): part is Extract<AgentMessagePart, { type: "tool-result" }> =>
+			part.type === "tool-result",
+	);
+	if (!result || result.isError) {
+		return "";
+	}
+	if (typeof result.output === "string") {
+		return result.output;
+	}
+	try {
+		return JSON.stringify(result.output);
+	} catch {
+		return String(result.output);
+	}
+}
+
+function normalizeInput(input: AgentRunInput): AgentMessage[] {
+	if (typeof input === "string") {
+		return [createMessage("user", [{ type: "text", text: input }])];
+	}
+	if (Array.isArray(input)) {
+		return cloneMessages(input);
+	}
+	return cloneMessages([input as AgentMessage]);
+}
+
+export class AgentRuntime {
+	private config: Required<Pick<BaseAgentRuntimeConfig, "toolExecution">> &
+		BaseAgentRuntimeConfig;
+	private readonly listeners = new Set<AgentEventListener>();
+	// biome-ignore lint/suspicious/noExplicitAny: tool input/output types vary per tool
+	private readonly tools = new Map<string, AgentTool<any, any>>();
+	private hooks: HookBag = {
+		beforeRun: [],
+		afterRun: [],
+		beforeModel: [],
+		afterModel: [],
+		beforeTool: [],
+		afterTool: [],
+		onEvent: [],
+	};
+	private readonly state = {
+		agentId: "",
+		agentRole: undefined as string | undefined,
+		parentAgentId: undefined as string | null | undefined,
+		runId: undefined as string | undefined,
+		status: "idle" as AgentRuntimeStateSnapshot["status"],
+		iteration: 0,
+		messages: [] as AgentMessage[],
+		pendingToolCalls: [] as string[],
+		usage: cloneUsage(DEFAULT_USAGE),
+		lastError: undefined as string | undefined,
+	};
+	private initialization?: Promise<void>;
+	private abortController?: AbortController;
+
+	constructor(config: AgentRuntimeConfig) {
+		const resolved = resolveRuntimeConfig(config);
+		this.config = {
+			...resolved,
+			toolExecution: resolved.toolExecution ?? "sequential",
+		};
+		this.state.agentId = resolved.agentId ?? createUID("agent");
+		this.state.agentRole = resolved.agentRole;
+		this.state.parentAgentId = resolved.parentAgentId;
+		this.state.messages = cloneMessages(resolved.initialMessages ?? []);
+	}
+
+	async run(input: AgentRunInput): Promise<AgentRunResult> {
+		return this.execute(input);
+	}
+
+	async continue(input?: AgentRunInput): Promise<AgentRunResult> {
+		return this.execute(input);
+	}
+
+	abort(reason?: unknown): void {
+		if (!this.abortController) {
+			return;
+		}
+		const abortError =
+			reason instanceof AgentRuntimeAbortError
+				? reason
+				: new AgentRuntimeAbortError(reason);
+		this.state.lastError = abortError.message;
+		this.abortController.abort(abortError);
+	}
+
+	subscribe(listener: AgentEventListener): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	/**
+	 * Replace the conversation with a fresh set of messages, discarding any
+	 * in-flight run and usage state while preserving the underlying model,
+	 * tools, hooks, plugins, and active event subscribers.
+	 *
+	 * Useful for standalone callers that persist conversations externally and
+	 * want to re-seed the runtime from storage without recreating subscribers.
+	 */
+	restore(messages: readonly AgentMessage[]): void {
+		this.abort("Agent state restored");
+		// Reset state that is not carried across restores. Keep `listeners`,
+		// tools, hooks, plugins, model, and agent identity so external event
+		// subscribers continue to receive events after restore().
+		this.state.runId = undefined;
+		this.state.status = "idle";
+		this.state.iteration = 0;
+		this.state.pendingToolCalls = [];
+		this.state.usage = cloneUsage(DEFAULT_USAGE);
+		this.state.lastError = undefined;
+		this.state.messages = cloneMessages(messages);
+		this.config = {
+			...this.config,
+			initialMessages: cloneMessages(messages),
+		};
+	}
+
+	snapshot(): AgentRuntimeStateSnapshot {
+		return {
+			agentId: this.state.agentId,
+			agentRole: this.state.agentRole,
+			parentAgentId: this.state.parentAgentId,
+			conversationId: this.config.conversationId?.trim() || undefined,
+			runId: this.state.runId,
+			status: this.state.status,
+			iteration: this.state.iteration,
+			messages: cloneMessages(this.state.messages),
+			pendingToolCalls: [...this.state.pendingToolCalls],
+			usage: cloneUsage(this.state.usage),
+			lastError: this.state.lastError,
+		};
+	}
+
+	private async ensureInitialized(): Promise<void> {
+		this.initialization ??= this.initialize();
+		await this.initialization;
+	}
+
+	private async initialize(): Promise<void> {
+		this.registerHooks(this.config.hooks);
+		for (const tool of this.config.tools ?? []) {
+			this.tools.set(tool.name, tool);
+		}
+		for (const plugin of this.config.plugins ?? []) {
+			const setup = await plugin.setup?.({
+				agentId: this.state.agentId,
+				agentRole: this.state.agentRole,
+				systemPrompt: this.config.systemPrompt,
+			});
+			for (const tool of setup?.tools ?? []) {
+				this.tools.set(tool.name, tool);
+			}
+			this.registerHooks(setup?.hooks);
+		}
+	}
+
+	private registerHooks(hooks: Partial<AgentRuntimeHooks> | undefined): void {
+		if (!hooks) {
+			return;
+		}
+		if (hooks.beforeRun) this.hooks.beforeRun.push(hooks.beforeRun);
+		if (hooks.afterRun) this.hooks.afterRun.push(hooks.afterRun);
+		if (hooks.beforeModel) this.hooks.beforeModel.push(hooks.beforeModel);
+		if (hooks.afterModel) this.hooks.afterModel.push(hooks.afterModel);
+		if (hooks.beforeTool) this.hooks.beforeTool.push(hooks.beforeTool);
+		if (hooks.afterTool) this.hooks.afterTool.push(hooks.afterTool);
+		if (hooks.onEvent) this.hooks.onEvent.push(hooks.onEvent);
+	}
+
+	private getRequiredCompletionToolNames(): string[] {
+		if (this.config.completionPolicy?.requireCompletionTool !== true) {
+			return [];
+		}
+		return [...this.tools.values()]
+			.filter((tool) => tool.lifecycle?.completesRun === true)
+			.map((tool) => tool.name)
+			.sort();
+	}
+
+	private getCompletionToolReminderMessage(): string | undefined {
+		const terminalToolNames = this.getRequiredCompletionToolNames();
+		if (terminalToolNames.length === 0) {
+			return undefined;
+		}
+		return `[SYSTEM] This run is not complete until you call one of these terminal completion tools: ${terminalToolNames.join(
+			", ",
+		)}. Continue working if requirements are not met. If the task is complete, call the appropriate terminal completion tool now.`;
+	}
+
+	private getCompletionReminderMessages(): string[] {
+		return [
+			this.getCompletionToolReminderMessage(),
+			this.config.completionPolicy?.completionGuard?.(),
+		].filter((message): message is string => Boolean(message));
+	}
+
+	private async addUserReminderMessage(text: string): Promise<AgentMessage> {
+		const reminderMessage = createMessage("user", [{ type: "text", text }]);
+		this.state.messages.push(reminderMessage);
+		await this.emit({
+			type: "message-added",
+			snapshot: this.snapshot(),
+			message: reminderMessage,
+		});
+		return reminderMessage;
+	}
+
+	private async execute(input?: AgentRunInput): Promise<AgentRunResult> {
+		await this.ensureInitialized();
+		if (this.state.status === "running") {
+			throw new Error("Agent runtime is already running");
+		}
+
+		this.abortController = new AbortController();
+		this.state.runId = createUID("run");
+		this.state.status = "running";
+		this.state.iteration = 0;
+		this.state.pendingToolCalls = [];
+		this.state.lastError = undefined;
+		this.state.usage = cloneUsage(DEFAULT_USAGE);
+
+		try {
+			await this.callBeforeRunHooks();
+			await this.emit({ type: "run-started", snapshot: this.snapshot() });
+
+			for (const message of input ? normalizeInput(input) : []) {
+				this.state.messages.push(message);
+				await this.emit({
+					type: "message-added",
+					snapshot: this.snapshot(),
+					message,
+				});
+			}
+
+			const completionToolReminder = this.getCompletionToolReminderMessage();
+			if (completionToolReminder) {
+				await this.addUserReminderMessage(completionToolReminder);
+			}
+
+			let finalAssistantMessage: AgentMessage | undefined;
+
+			while (
+				this.config.maxIterations === undefined ||
+				this.state.iteration < this.config.maxIterations
+			) {
+				this.throwIfAborted();
+
+				this.state.iteration += 1;
+				await this.emit({
+					type: "turn-started",
+					snapshot: this.snapshot(),
+					iteration: this.state.iteration,
+				});
+
+				const { message, finishReason } = await this.generateAssistantMessage();
+				if (finishReason === "aborted") {
+					throw this.normalizeAbortError();
+				}
+				if (message.content.length === 0) {
+					throw new Error(
+						finishReason === "error"
+							? (this.state.lastError ?? "Model stream failed")
+							: "Model returned empty response",
+					);
+				}
+				const toolCalls = message.content.filter(
+					(part: AgentMessagePart): part is AgentToolCallPart =>
+						part.type === "tool-call",
+				);
+
+				finalAssistantMessage = message;
+				this.state.messages.push(message);
+				await this.emit({
+					type: "message-added",
+					snapshot: this.snapshot(),
+					message,
+				});
+				await this.emit({
+					type: "assistant-message",
+					snapshot: this.snapshot(),
+					iteration: this.state.iteration,
+					message,
+					finishReason,
+				});
+
+				if (finishReason === "error" && toolCalls.length === 0) {
+					throw new Error(this.state.lastError ?? "Model stream failed");
+				}
+				this.state.pendingToolCalls = toolCalls.map((part) => part.toolCallId);
+
+				if (toolCalls.length === 0) {
+					await this.emit({
+						type: "turn-finished",
+						snapshot: this.snapshot(),
+						iteration: this.state.iteration,
+						toolCallCount: 0,
+					});
+					const completionReminderMessages =
+						this.getCompletionReminderMessages();
+					if (completionReminderMessages.length > 0) {
+						for (const reminderMessage of completionReminderMessages) {
+							await this.addUserReminderMessage(reminderMessage);
+						}
+						continue;
+					}
+					const result = this.finishRun("completed", finalAssistantMessage);
+					await this.callAfterRunHooks(result);
+					await this.emit({
+						type: "run-finished",
+						snapshot: this.snapshot(),
+						result,
+					});
+					return result;
+				}
+
+				const toolMessages = await this.executeToolCalls(toolCalls);
+				this.state.pendingToolCalls = [];
+				for (const toolMessage of toolMessages) {
+					this.state.messages.push(toolMessage);
+					await this.emit({
+						type: "message-added",
+						snapshot: this.snapshot(),
+						message: toolMessage,
+					});
+				}
+				await this.emit({
+					type: "turn-finished",
+					snapshot: this.snapshot(),
+					iteration: this.state.iteration,
+					toolCallCount: toolCalls.length,
+				});
+				const terminalToolMessage = this.findCompletingToolMessage(
+					toolCalls,
+					toolMessages,
+				);
+				if (terminalToolMessage) {
+					const result = this.finishRun(
+						"completed",
+						finalAssistantMessage,
+						textFromToolMessage(terminalToolMessage) || undefined,
+					);
+					await this.callAfterRunHooks(result);
+					await this.emit({
+						type: "run-finished",
+						snapshot: this.snapshot(),
+						result,
+					});
+					return result;
+				}
+			}
+
+			throw new Error(
+				`Agent runtime exceeded maxIterations (${this.config.maxIterations})`,
+			);
+		} catch (error) {
+			const normalized =
+				error instanceof Error ? error : new Error(String(error));
+			const isControlledStop = normalized instanceof ControlledStopError;
+			const status =
+				this.abortController.signal.aborted || isControlledStop
+					? "aborted"
+					: "failed";
+			this.state.status = status;
+			this.state.lastError = normalized.message;
+			const result: AgentRunResult = {
+				agentId: this.state.agentId,
+				agentRole: this.state.agentRole,
+				runId: this.state.runId ?? createUID("run"),
+				status,
+				iterations: this.state.iteration,
+				outputText: textFromMessage(this.findLastAssistantMessage()),
+				messages: cloneMessages(this.state.messages),
+				usage: cloneUsage(this.state.usage),
+				error: status === "failed" ? normalized : undefined,
+			};
+			await this.callAfterRunHooks(result);
+			if (status === "failed") {
+				await this.emit({
+					type: "run-failed",
+					snapshot: this.snapshot(),
+					error: normalized,
+				});
+			} else {
+				await this.emit({
+					type: "run-finished",
+					snapshot: this.snapshot(),
+					result,
+				});
+			}
+			return result;
+		} finally {
+			this.abortController = undefined;
+		}
+	}
+
+	private async callBeforeRunHooks(): Promise<void> {
+		for (const hook of this.hooks.beforeRun) {
+			const control = (await hook({
+				snapshot: this.snapshot(),
+			})) as AgentStopControl | undefined;
+			this.applyStopControl(control);
+		}
+	}
+
+	private async callAfterRunHooks(result: AgentRunResult): Promise<void> {
+		for (const hook of this.hooks.afterRun) {
+			await hook({ snapshot: this.snapshot(), result });
+		}
+	}
+
+	private async generateAssistantMessage(): Promise<{
+		message: AgentMessage;
+		finishReason: AgentModelFinishReason;
+	}> {
+		const usageBeforeModel = cloneUsage(this.state.usage);
+		const modelRequestMetadata = omitUndefinedValues({
+			sessionId: trimNonEmpty(this.config.sessionId),
+			agentId: this.state.agentId,
+			conversationId: trimNonEmpty(this.config.conversationId),
+			runId: this.state.runId,
+			iteration: this.state.iteration,
+		});
+		let request: AgentModelRequest = {
+			systemPrompt: this.config.systemPrompt,
+			messages: cloneMessages(this.state.messages),
+			tools: [...this.tools.values()].map<AgentToolDefinition>((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema,
+			})),
+			signal: this.abortController?.signal,
+			options: mergeModelOptions(this.config.modelOptions, {
+				metadata: modelRequestMetadata,
+			}),
+		};
+
+		if (this.state.iteration > 1) {
+			const pendingUserMessage = await this.consumePendingUserMessage();
+			if (pendingUserMessage) {
+				request = {
+					...request,
+					messages: [
+						...request.messages,
+						...cloneMessages([pendingUserMessage]),
+					],
+				};
+			}
+		}
+
+		request = await this.prepareTurnForModelRequest(request);
+
+		for (const hook of this.hooks.beforeModel) {
+			const result = (await hook({
+				snapshot: this.snapshot(),
+				request,
+			})) as AgentBeforeModelResult | undefined;
+			this.applyStopControl(result);
+			if (result?.messages) {
+				request = { ...request, messages: cloneMessages(result.messages) };
+			}
+			if (result?.tools) {
+				request = { ...request, tools: [...result.tools] };
+			}
+			if (result?.options) {
+				request = {
+					...request,
+					options: mergeModelOptions(request.options, result.options),
+				};
+			}
+		}
+
+		this.config.logger?.debug("Agent model request diagnostics", {
+			iteration: this.state.iteration,
+			providerId:
+				"providerId" in this.config &&
+				typeof this.config.providerId === "string"
+					? this.config.providerId
+					: undefined,
+			modelId:
+				"modelId" in this.config && typeof this.config.modelId === "string"
+					? this.config.modelId
+					: undefined,
+			...summarizeModelRequest(request),
+		});
+
+		const stream = await this.config.model.stream(request);
+		const content: AgentMessagePart[] = [];
+		const toolAssemblies = new Map<string, PendingToolAssembly>();
+		const invalidToolCalls: InvalidToolCall[] = [];
+		const sequence: Array<
+			{ type: "tool"; key: string } | { type: "part"; part: AgentMessagePart }
+		> = [];
+		let nextToolIndex = 0;
+		let finishReason: AgentModelFinishReason = "stop";
+		let accumulatedText = "";
+		let accumulatedReasoning = "";
+
+		for await (const event of stream) {
+			this.throwIfAborted();
+			switch (event.type) {
+				case "text-delta": {
+					accumulatedText += event.text;
+					const last = sequence.at(-1);
+					if (last?.type === "part" && last.part.type === "text") {
+						last.part.text += event.text;
+					} else {
+						sequence.push({
+							type: "part",
+							part: { type: "text", text: event.text },
+						});
+					}
+					await this.emit({
+						type: "assistant-text-delta",
+						snapshot: this.snapshot(),
+						iteration: this.state.iteration,
+						text: event.text,
+						accumulatedText,
+					});
+					break;
+				}
+				case "reasoning-delta": {
+					accumulatedReasoning += event.text;
+					const last = sequence.at(-1);
+					if (last?.type === "part" && last.part.type === "reasoning") {
+						last.part.text += event.text;
+						last.part.redacted = event.redacted ?? last.part.redacted;
+						last.part.metadata = event.metadata ?? last.part.metadata;
+					} else {
+						sequence.push({
+							type: "part",
+							part: {
+								type: "reasoning",
+								text: event.text,
+								redacted: event.redacted,
+								metadata: event.metadata,
+							},
+						});
+					}
+					await this.emit({
+						type: "assistant-reasoning-delta",
+						snapshot: this.snapshot(),
+						iteration: this.state.iteration,
+						text: event.text,
+						accumulatedText: accumulatedReasoning,
+						redacted: event.redacted,
+						metadata: event.metadata,
+					});
+					break;
+				}
+				case "tool-call-delta": {
+					const key =
+						event.toolCallId ?? `tool_${event.index ?? nextToolIndex}`;
+					if (event.index == null && event.toolCallId == null) {
+						nextToolIndex += 1;
+					}
+					let assembly = toolAssemblies.get(key);
+					if (!assembly) {
+						assembly = {
+							toolCallId: event.toolCallId ?? createUID("tool"),
+							inputText: "",
+						};
+						toolAssemblies.set(key, assembly);
+						sequence.push({ type: "tool", key });
+					}
+					if (event.toolCallId) {
+						assembly.toolCallId = event.toolCallId;
+					}
+					if (event.toolName) {
+						assembly.toolName = event.toolName;
+					}
+					if (event.input !== undefined) {
+						assembly.inputValue = event.input;
+					}
+					if (event.metadata !== undefined) {
+						assembly.metadata = mergeToolMetadata(
+							assembly.metadata,
+							event.metadata,
+						);
+					}
+					if (event.inputText) {
+						assembly.inputText = mergeToolInputText(
+							assembly.inputText,
+							event.inputText,
+						);
+					}
+					break;
+				}
+				case "usage": {
+					await this.updateUsage(event.usage);
+					break;
+				}
+				case "finish": {
+					finishReason = event.reason;
+					if (event.error) {
+						this.state.lastError = event.error;
+					}
+					break;
+				}
+			}
+		}
+
+		for (const item of sequence) {
+			if (item.type === "part") {
+				content.push(item.part);
+				continue;
+			}
+			const assembly = toolAssemblies.get(item.key);
+			if (!assembly?.toolName) {
+				invalidToolCalls.push({
+					toolCallId: assembly?.toolCallId ?? item.key,
+					input: buildInvalidToolInput(assembly?.inputText ?? ""),
+					reason: "missing_name",
+				});
+				continue;
+			}
+			const parsed = parseToolInput(assembly);
+			if (parsed.reason) {
+				invalidToolCalls.push({
+					toolCallId: assembly.toolCallId,
+					toolName: assembly.toolName,
+					input: parsed.invalidInput,
+					reason: parsed.reason,
+				});
+			}
+			content.push({
+				type: "tool-call",
+				toolCallId: assembly.toolCallId,
+				toolName: assembly.toolName,
+				input: parsed.input,
+				metadata: parsed.parseError
+					? mergeToolMetadata(assembly.metadata, {
+							inputParseError: parsed.parseError,
+							rawInputText: assembly.inputText,
+						})
+					: assembly.metadata,
+			});
+		}
+
+		const message = createMessage(
+			"assistant",
+			content,
+			invalidToolCalls.length > 0 ? { invalidToolCalls } : undefined,
+		);
+		const metrics = usageDelta(usageBeforeModel, this.state.usage);
+		if (metrics) {
+			message.metrics = metrics;
+			this.captureUnexpectedReasoningTokens(request, metrics);
+		}
+		if (this.config.messageModelInfo) {
+			message.modelInfo = { ...this.config.messageModelInfo };
+		}
+		for (const hook of this.hooks.afterModel) {
+			const control = (await hook({
+				snapshot: this.snapshot(),
+				assistantMessage: message,
+				finishReason,
+			})) as AgentStopControl | undefined;
+			this.applyStopControl(control);
+		}
+
+		return { message, finishReason };
+	}
+
+	private captureUnexpectedReasoningTokens(
+		request: AgentModelRequest,
+		metrics: NonNullable<AgentMessage["metrics"]>,
+	): void {
+		if (
+			!reasoningWasRequestedOff(request) ||
+			(metrics.reasoningTokenCount ?? 0) <= 0
+		) {
+			return;
+		}
+		const reasoningTokenCount = metrics.reasoningTokenCount;
+		if (reasoningTokenCount === undefined) {
+			return;
+		}
+
+		captureAgentUnexpectedReasoningTokens(this.config.telemetry, {
+			sessionId: this.config.sessionId,
+			agentId: this.state.agentId,
+			runId: this.state.runId,
+			iteration: this.state.iteration,
+			providerId: this.config.messageModelInfo?.provider,
+			modelId: this.config.messageModelInfo?.id,
+			requestedThinking: false,
+			reasoningTokenCount,
+		});
+	}
+
+	private async prepareTurnForModelRequest(
+		request: AgentModelRequest,
+	): Promise<AgentModelRequest> {
+		if (!this.config.prepareTurn) {
+			return request;
+		}
+
+		const result = await this.config.prepareTurn({
+			agentId: this.state.agentId,
+			conversationId: this.config.conversationId,
+			parentAgentId: this.state.parentAgentId ?? null,
+			iteration: this.state.iteration,
+			messages: request.messages,
+			systemPrompt: request.systemPrompt,
+			tools: request.tools,
+			model: {
+				id: this.config.messageModelInfo?.id,
+				provider: this.config.messageModelInfo?.provider,
+			},
+			signal: request.signal,
+			emitStatusNotice: (message, metadata) => {
+				void this.emit({
+					type: "status-notice",
+					snapshot: this.snapshot(),
+					message,
+					metadata,
+				});
+			},
+		});
+		if (!result) {
+			return request;
+		}
+
+		let next = request;
+		if (result.messages) {
+			const preparedMessages = cloneMessages(result.messages);
+			next = { ...next, messages: cloneMessages(preparedMessages) };
+		}
+		if (result.systemPrompt !== undefined) {
+			next = { ...next, systemPrompt: result.systemPrompt };
+		}
+		return next;
+	}
+
+	private async consumePendingUserMessage(): Promise<AgentMessage | undefined> {
+		const consumePendingUserMessage = this.config.consumePendingUserMessage;
+		if (!consumePendingUserMessage) {
+			return undefined;
+		}
+		const pending = (await consumePendingUserMessage())?.trim();
+		if (!pending) {
+			return undefined;
+		}
+		const message = createMessage("user", [{ type: "text", text: pending }]);
+		this.state.messages.push(message);
+		await this.emit({
+			type: "message-added",
+			snapshot: this.snapshot(),
+			message,
+		});
+		return message;
+	}
+
+	private async updateUsage(usage: Partial<AgentUsage>): Promise<void> {
+		this.state.usage = {
+			inputTokens: this.state.usage.inputTokens + (usage.inputTokens ?? 0),
+			outputTokens: this.state.usage.outputTokens + (usage.outputTokens ?? 0),
+			cacheReadTokens:
+				this.state.usage.cacheReadTokens + (usage.cacheReadTokens ?? 0),
+			cacheWriteTokens:
+				this.state.usage.cacheWriteTokens + (usage.cacheWriteTokens ?? 0),
+			reasoningTokenCount:
+				(this.state.usage.reasoningTokenCount ?? 0) +
+				(usage.reasoningTokenCount ?? 0),
+			totalCost: (this.state.usage.totalCost ?? 0) + (usage.totalCost ?? 0),
+		};
+		await this.emit({
+			type: "usage-updated",
+			snapshot: this.snapshot(),
+			usage: cloneUsage(this.state.usage),
+		});
+	}
+
+	private async executeToolCalls(
+		toolCalls: AgentToolCallPart[],
+	): Promise<AgentMessage[]> {
+		const prepared: PreparedToolExecution[] = [];
+		for (const toolCall of toolCalls) {
+			prepared.push(await this.prepareToolExecution(toolCall));
+		}
+
+		if (this.config.toolExecution === "parallel") {
+			return Promise.all(
+				prepared.map((execution) => this.executePreparedTool(execution)),
+			);
+		}
+
+		const results: AgentMessage[] = [];
+		for (const execution of prepared) {
+			results.push(await this.executePreparedTool(execution));
+		}
+		return results;
+	}
+
+	private findCompletingToolMessage(
+		toolCalls: AgentToolCallPart[],
+		toolMessages: AgentMessage[],
+	): AgentMessage | undefined {
+		for (let index = 0; index < toolCalls.length; index += 1) {
+			const toolCall = toolCalls[index];
+			if (this.tools.get(toolCall.toolName)?.lifecycle?.completesRun !== true) {
+				continue;
+			}
+			const toolMessage = toolMessages[index];
+			const result = toolMessage?.content.find(
+				(part): part is Extract<AgentMessagePart, { type: "tool-result" }> =>
+					part.type === "tool-result" &&
+					part.toolCallId === toolCall.toolCallId,
+			);
+			if (result && !result.isError) {
+				return toolMessage;
+			}
+		}
+		return undefined;
+	}
+
+	private async prepareToolExecution(
+		toolCall: AgentToolCallPart,
+	): Promise<PreparedToolExecution> {
+		const tool = this.tools.get(toolCall.toolName);
+		let input = toolCall.input;
+		let skipReason: string | undefined;
+		const metadata =
+			toolCall.metadata &&
+			typeof toolCall.metadata === "object" &&
+			!Array.isArray(toolCall.metadata)
+				? (toolCall.metadata as Record<string, unknown>)
+				: undefined;
+
+		if (typeof metadata?.inputParseError === "string") {
+			skipReason = metadata.inputParseError;
+		}
+
+		const toolSource =
+			metadata?.toolSource &&
+			typeof metadata.toolSource === "object" &&
+			!Array.isArray(metadata.toolSource)
+				? (metadata.toolSource as Record<string, unknown>)
+				: undefined;
+		if (toolSource?.executionMode === "provider") {
+			const providerId =
+				typeof toolSource.providerId === "string"
+					? toolSource.providerId
+					: "provider";
+			skipReason = `Tool execution is disabled for provider ${providerId}`;
+		}
+
+		if (tool && !skipReason) {
+			input = normalizeJsonLikeStringsForSchema(input, tool.inputSchema);
+		}
+
+		let policyOverride: ToolPolicy | undefined;
+		if (tool && !skipReason) {
+			for (const hook of this.hooks.beforeTool) {
+				const result = (await hook({
+					snapshot: this.snapshot(),
+					tool,
+					toolCall: { ...toolCall, input },
+					input,
+				})) as AgentBeforeToolResult | undefined;
+				if (result?.input !== undefined) {
+					input = result.input;
+				}
+				if (result?.policy) {
+					policyOverride = {
+						...policyOverride,
+						...result.policy,
+					};
+				}
+				this.applyStopControl(result);
+				if (result?.skip) {
+					skipReason =
+						result.reason ?? `Tool ${tool.name} was blocked by a runtime hook`;
+					break;
+				}
+			}
+		}
+
+		if (tool && !skipReason) {
+			const policy = {
+				...resolveToolPolicy(toolCall.toolName, this.config.toolPolicies),
+				...policyOverride,
+			};
+			if (policy.enabled === false) {
+				skipReason = `Tool "${toolCall.toolName}" is disabled by policy`;
+			} else if (policy.autoApprove === false) {
+				const approval = await this.requestToolApproval(
+					toolCall,
+					input,
+					policy,
+				);
+				if (!approval.approved) {
+					skipReason =
+						approval.reason ?? `Tool "${toolCall.toolName}" was not approved`;
+				}
+			}
+		}
+
+		return {
+			toolCall: { ...toolCall, input },
+			tool,
+			input,
+			skipReason,
+		};
+	}
+
+	private async requestToolApproval(
+		toolCall: AgentToolCallPart,
+		input: unknown,
+		policy: ToolPolicy,
+	): Promise<ToolApprovalResult> {
+		const requestApproval = this.config.requestToolApproval;
+		if (!requestApproval) {
+			return {
+				approved: false,
+				reason: `Tool "${toolCall.toolName}" requires approval but no approval callback is configured`,
+			};
+		}
+		try {
+			return await requestApproval({
+				sessionId:
+					this.config.sessionId?.trim() ||
+					this.config.conversationId?.trim() ||
+					this.state.runId ||
+					this.state.agentId,
+				agentId: this.state.agentId,
+				conversationId:
+					this.config.conversationId?.trim() ||
+					this.state.runId ||
+					this.state.agentId,
+				iteration: this.state.iteration,
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				input,
+				policy,
+			});
+		} catch (error) {
+			return {
+				approved: false,
+				reason: `Tool "${toolCall.toolName}" approval request failed: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			};
+		}
+	}
+
+	private async executePreparedTool(
+		prepared: PreparedToolExecution,
+	): Promise<AgentMessage> {
+		const startedAt = new Date();
+		await this.emit({
+			type: "tool-started",
+			snapshot: this.snapshot(),
+			iteration: this.state.iteration,
+			toolCall: prepared.toolCall,
+		});
+
+		let result: AgentToolResult;
+		if (prepared.skipReason) {
+			result = {
+				output: { error: prepared.skipReason },
+				isError: true,
+			};
+		} else if (!prepared.tool) {
+			result = {
+				output: { error: `Unknown tool: ${prepared.toolCall.toolName}` },
+				isError: true,
+			};
+		} else {
+			try {
+				const output = await prepared.tool.execute(prepared.input, {
+					sessionId: this.config.sessionId,
+					agentId: this.state.agentId,
+					conversationId: this.config.conversationId,
+					runId: this.state.runId ?? createUID("run"),
+					iteration: this.state.iteration,
+					toolCallId: prepared.toolCall.toolCallId,
+					signal: this.abortController?.signal,
+					metadata: this.config.toolContextMetadata,
+					snapshot: this.snapshot(),
+					emitUpdate: (update: unknown) => {
+						void this.emit({
+							type: "tool-updated",
+							snapshot: this.snapshot(),
+							iteration: this.state.iteration,
+							toolCall: prepared.toolCall,
+							update,
+						});
+					},
+				});
+				result = { output };
+			} catch (error) {
+				result = {
+					output: {
+						error: error instanceof Error ? error.message : String(error),
+					},
+					isError: true,
+				};
+			}
+		}
+
+		const endedAt = new Date();
+		const durationMs = Math.max(0, endedAt.getTime() - startedAt.getTime());
+
+		if (prepared.tool) {
+			for (const hook of this.hooks.afterTool) {
+				const after = (await hook({
+					snapshot: this.snapshot(),
+					tool: prepared.tool,
+					toolCall: prepared.toolCall,
+					input: prepared.input,
+					result,
+					startedAt,
+					endedAt,
+					durationMs,
+				})) as AgentAfterToolResult | undefined;
+				this.applyStopControl(after);
+				if (after?.result) {
+					result = after.result;
+				}
+			}
+		}
+
+		const message = createMessage("tool", [
+			{
+				type: "tool-result",
+				toolCallId: prepared.toolCall.toolCallId,
+				toolName: prepared.toolCall.toolName,
+				output: result.output,
+				isError: result.isError,
+			},
+		]);
+
+		await this.emit({
+			type: "tool-finished",
+			snapshot: this.snapshot(),
+			iteration: this.state.iteration,
+			toolCall: prepared.toolCall,
+			message,
+		});
+
+		return message;
+	}
+
+	private finishRun(
+		status: AgentRunResult["status"],
+		assistantMessage?: AgentMessage,
+		outputText?: string,
+	): AgentRunResult {
+		this.state.status = status;
+		return {
+			agentId: this.state.agentId,
+			agentRole: this.state.agentRole,
+			runId: this.state.runId ?? createUID("run"),
+			status,
+			iterations: this.state.iteration,
+			outputText:
+				outputText ??
+				textFromMessage(assistantMessage ?? this.findLastAssistantMessage()),
+			messages: cloneMessages(this.state.messages),
+			usage: cloneUsage(this.state.usage),
+		};
+	}
+
+	private findLastAssistantMessage(): AgentMessage | undefined {
+		return [...this.state.messages]
+			.reverse()
+			.find((message) => message.role === "assistant");
+	}
+
+	private throwIfAborted(): void {
+		if (this.abortController?.signal.aborted) {
+			throw this.normalizeAbortError();
+		}
+	}
+
+	private normalizeAbortError(): Error {
+		const reason = this.abortController?.signal.reason;
+		if (reason instanceof Error) {
+			return reason;
+		}
+		if (typeof reason === "string") {
+			return new Error(reason);
+		}
+		return new Error(this.state.lastError ?? "Run aborted");
+	}
+
+	private async emit(event: AgentRuntimeEvent): Promise<void> {
+		const metadata = buildEventMetadata(event);
+		switch (event.type) {
+			case "run-started":
+				// Verbatim clinee calls `logger?.info?.(...)`. sdk-re's
+				// `BasicLogger` does not declare `info` (it uses `log`), so
+				// we narrow to an optional-info shape at the call site to
+				// preserve the clinee runtime contract without mutating
+				// shared's `BasicLogger` interface.
+				(
+					this.config.logger as
+						| {
+								info?: (msg: string, md?: unknown) => void;
+						  }
+						| undefined
+				)?.info?.("Agent run started", metadata);
+				break;
+			case "tool-finished":
+				(
+					this.config.logger as
+						| {
+								info?: (msg: string, md?: unknown) => void;
+						  }
+						| undefined
+				)?.info?.("Agent tool finished", metadata);
+				break;
+			case "run-failed":
+				this.config.logger?.error?.("Agent run failed", {
+					...metadata,
+					error: event.error,
+				});
+				captureSdkError(this.config.telemetry, {
+					component: "agents",
+					operation: "agent.run",
+					error: event.error,
+					severity: "error",
+					handled: false,
+					context: metadata as TelemetryProperties,
+				});
+				break;
+			default:
+				this.config.logger?.debug?.("Agent event", metadata);
+				break;
+		}
+		this.config.telemetry?.capture({
+			event: `agent.${event.type}`,
+			properties: metadata as TelemetryProperties,
+		});
+		for (const listener of this.listeners) {
+			listener(event);
+		}
+		for (const hook of this.hooks.onEvent) {
+			await hook(event);
+		}
+	}
+
+	private applyStopControl(
+		control: AgentStopControl | undefined | undefined,
+	): void {
+		if (!control?.stop) {
+			return;
+		}
+		if (control.reason) {
+			this.state.lastError = control.reason;
+		}
+		throw new ControlledStopError(control.reason);
+	}
+}
+
+function buildEventMetadata(event: AgentRuntimeEvent): Record<string, unknown> {
+	return {
+		agentId: event.snapshot.agentId,
+		agentRole: event.snapshot.agentRole,
+		runId: event.snapshot.runId,
+		status: event.snapshot.status,
+		iteration: event.snapshot.iteration,
+		eventType: event.type,
+	};
+}
+
+function mergeToolMetadata(current: unknown, patch: unknown): unknown {
+	if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+		return patch;
+	}
+	if (!current || typeof current !== "object" || Array.isArray(current)) {
+		return patch;
+	}
+	return {
+		...(current as Record<string, unknown>),
+		...patch,
+	};
+}
+
+function parseToolInput(assembly: PendingToolAssembly): {
+	input: unknown;
+	parseError?: string;
+	invalidInput: Record<string, unknown>;
+	reason?: InvalidToolCall["reason"];
+} {
+	if (assembly.inputValue !== undefined) {
+		return {
+			input: assembly.inputValue,
+			invalidInput: buildInvalidToolInput(JSON.stringify(assembly.inputValue)),
+		};
+	}
+	if (!assembly.inputText.trim()) {
+		return {
+			input: {},
+			invalidInput: {},
+		};
+	}
+	const parsed = parseToolArguments(assembly.inputText);
+	if (parsed.ok) {
+		return {
+			input: parsed.value,
+			invalidInput: buildInvalidToolInput(assembly.inputText),
+		};
+	}
+	return {
+		input: {},
+		invalidInput: buildInvalidToolInput(assembly.inputText, parsed.error),
+		parseError: `Tool call ${assembly.toolName ?? assembly.toolCallId} emitted invalid JSON arguments: ${parsed.error}`,
+		reason: "invalid_arguments",
+	};
+}
+
+function buildInvalidToolInput(
+	value: string,
+	parseError?: string,
+): Record<string, unknown> {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return {};
+	}
+	return parseError
+		? { rawInputText: value, parseError }
+		: { rawInputText: value };
+}
+
+function parseToolArguments(
+	value: string,
+): { ok: true; value: unknown } | { ok: false; error: string } {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return {
+			ok: false,
+			error: "Tool call arguments were empty.",
+		};
+	}
+
+	try {
+		return { ok: true, value: JSON.parse(trimmed) };
+	} catch {
+		// Fall through to a normalized error below.
+	}
+
+	if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) {
+		return {
+			ok: false,
+			error: "Tool call arguments must be encoded as a JSON object or array.",
+		};
+	}
+
+	return {
+		ok: false,
+		error:
+			"Tool call arguments could not be parsed as JSON. Ensure the outer tool payload is valid JSON and escape embedded quotes/newlines inside string fields.",
+	};
+}
+
+function mergeToolInputText(current: string, incoming: string): string {
+	if (!current) {
+		return incoming;
+	}
+	const trimmed = incoming.trimStart();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		return incoming;
+	}
+	return current + incoming;
+}
+
+export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
+	return new AgentRuntime(config);
+}
+
+/**
+ * `Agent` is the user-friendly name for `AgentRuntime`. They are the same
+ * class; this alias exists so standalone callers can write:
+ *
+ *     const agent = new Agent({ providerId, modelId, apiKey });
+ *     await agent.run("hello");
+ *
+ * while `@cline/core` (which owns model construction) continues to use
+ * the `AgentRuntime` name with `{ model, ... }` configs.
+ */
+export const Agent = AgentRuntime;
+export type Agent = AgentRuntime;
+
+export function createAgent(config: AgentRuntimeConfig): AgentRuntime {
+	return new AgentRuntime(config);
+}
diff --git a/sdk/packages/agents/src/index.ts b/sdk/packages/agents/src/index.ts
new file mode 100644
index 0000000..b78788e
--- /dev/null
+++ b/sdk/packages/agents/src/index.ts
@@ -0,0 +1,57 @@
+/**
+ * @cline/agents
+ *
+ * Browser-safe agent runtime for the next-generation Cline SDK.
+ *
+ * Exports:
+ *   - `AgentRuntime` / `Agent` — the agentic loop class (two names for the
+ *     same class). Use `Agent` when supplying provider/model IDs, or
+ *     `AgentRuntime` when supplying a pre-built `AgentModel`.
+ *   - `createAgentRuntime` / `createAgent` — factory-function equivalents.
+ *   - `AgentRuntimeConfig` and its two variants (`AgentRuntimeConfigWithModel`,
+ *     `AgentRuntimeConfigWithProvider`) — the discriminated config union.
+ *   - `AgentRunInput` / `AgentEventListener` — convenience type aliases.
+ *   - `createTool` — re-exported from `@cline/shared` for authoring tools.
+ *
+ * Shared types (`AgentMessage`, `AgentRunResult`, etc.) should be imported
+ * directly from `@cline/shared`.
+ */
+
+export type {
+	AgentAfterToolResult,
+	AgentBeforeModelResult,
+	AgentBeforeToolResult,
+	AgentMessage,
+	AgentMessagePart,
+	AgentModel,
+	AgentModelFinishReason,
+	AgentModelRequest,
+	AgentRunResult,
+	AgentRuntimeConfig as BaseAgentRuntimeConfig,
+	AgentRuntimeEvent,
+	AgentRuntimeHooks,
+	AgentRuntimeStateSnapshot,
+	AgentStopControl,
+	AgentTool,
+	AgentToolCallPart,
+	AgentToolDefinition,
+	AgentToolResult,
+	AgentUsage,
+	ToolApprovalResult,
+	ToolPolicy,
+} from "@cline/shared";
+export { createTool } from "@cline/shared";
+export type {
+	AgentEventListener,
+	AgentRunInput,
+	AgentRuntimeConfig,
+	AgentRuntimeConfigWithModel,
+	AgentRuntimeConfigWithProvider,
+} from "./agent-runtime";
+export {
+	Agent,
+	AgentRuntime,
+	AgentRuntimeAbortError,
+	createAgent,
+	createAgentRuntime,
+} from "./agent-runtime";
diff --git a/sdk/packages/agents/tsconfig.build.json b/sdk/packages/agents/tsconfig.build.json
new file mode 100644
index 0000000..c701abf
--- /dev/null
+++ b/sdk/packages/agents/tsconfig.build.json
@@ -0,0 +1,13 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": false,
+		"emitDeclarationOnly": true,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"incremental": false
+	},
+	"include": ["src/index.ts"]
+}
diff --git a/sdk/packages/agents/tsconfig.dev.json b/sdk/packages/agents/tsconfig.dev.json
new file mode 100644
index 0000000..57f2147
--- /dev/null
+++ b/sdk/packages/agents/tsconfig.dev.json
@@ -0,0 +1,13 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"baseUrl": ".",
+		"rootDir": "..",
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"paths": {
+			"@cline/shared": ["../shared/src/index.ts"],
+			"@cline/shared/*": ["../shared/src/*", "../shared/src/*/index.ts"]
+		}
+	}
+}
diff --git a/sdk/packages/agents/tsconfig.json b/sdk/packages/agents/tsconfig.json
new file mode 100644
index 0000000..ff64f9c
--- /dev/null
+++ b/sdk/packages/agents/tsconfig.json
@@ -0,0 +1,9 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]
+}
diff --git a/sdk/packages/agents/vitest.config.ts b/sdk/packages/agents/vitest.config.ts
new file mode 100644
index 0000000..086b910
--- /dev/null
+++ b/sdk/packages/agents/vitest.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts"],
+		exclude: ["src/example.test.ts"],
+		passWithNoTests: true,
+	},
+});
diff --git a/sdk/packages/core/README.md b/sdk/packages/core/README.md
new file mode 100644
index 0000000..c3a4362
--- /dev/null
+++ b/sdk/packages/core/README.md
@@ -0,0 +1,110 @@
+# [experimental] @cline/core
+
+`@cline/core` is the stateful orchestration layer of the Cline SDK. It
+connects the agent runtime, provider settings, storage, default tools, and
+session lifecycle into a host-ready runtime.
+
+## What You Get
+
+- session lifecycle and orchestration primitives
+- provider settings and account services
+- default runtime tools and MCP integration
+- storage-backed session and team state helpers
+- host-facing Node helpers through `@cline/core`
+
+## Installation
+
+```bash
+npm install @cline/core
+```
+
+## Entry Points
+
+- `@cline/core`: core contracts, shared utilities, and Node/server helpers for building hosts and runtimes
+
+## Typical Usage
+
+Most host apps should start with `@cline/core`.
+
+```ts
+import { ClineCore } from "@cline/core";
+
+const cline = await ClineCore.create({});
+
+const result = await cline.start({
+	config: {
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+		cwd: process.cwd(),
+		mode: "act",
+		enableTools: true,
+		enableSpawnAgent: false,
+		enableAgentTeams: false,
+		systemPrompt: "You are a concise assistant.",
+	},
+	prompt: "Summarize this project.",
+	interactive: false,
+});
+
+console.log(result.result?.text);
+await cline.dispose();
+```
+
+## Session Bootstrap
+
+`ClineCore.create(...)` also accepts `prepare(input)`.
+
+Use it when a host needs to prepare workspace-scoped runtime state before each
+session starts, then apply watcher/extensions/telemetry inputs through
+explicit `localRuntime` bootstrap fields without widening the shared host
+contract.
+
+## Main APIs
+
+### Runtime and Sessions
+
+Use `@cline/core` for host-facing runtime assembly:
+
+- `ClineCore.create(...)`
+- `createRuntimeHost(...)`
+- `LocalRuntimeHost`
+- `HubRuntimeHost` and `RemoteRuntimeHost`
+- `DefaultRuntimeBuilder`
+
+`ClineCore` is the app-facing session API. The lower-level `RuntimeHost`
+boundary uses runtime-primitive names such as `startSession` and `runTurn` so
+transport adapters stay distinct from product methods like `start` and `send`.
+Service-style operations such as pending prompt edits, accumulated usage lookup,
+and active-session model switching are exposed through `ClineCore` when the
+selected transport supports them rather than being part of the minimal host
+primitive vocabulary.
+
+### Default Tools
+
+`@cline/core` owns the built-in host tools and executors:
+
+- `createBuiltinTools(...)`
+- `createDefaultTools(...)`
+- `createDefaultExecutors(...)`
+
+### Storage and Settings
+
+The package also exports storage and settings helpers such as:
+
+- `ProviderSettingsManager`
+- `CoreSettingsService` and `createCoreSettingsService`
+- MCP settings helpers such as `setMcpServerDisabled`
+- `SqliteTeamStore`
+- SQLite-backed local session stores and artifacts through `@cline/core`
+
+## Related Packages
+
+- `@cline/agents`: stateless agent loop and tool primitives
+- `@cline/llms`: provider/model configuration and handlers
+
+## More Examples
+
+- Repo examples: [examples](https://github.com/cline/sdk/tree/main/examples), [apps/examples](https://github.com/cline/sdk/tree/main/apps/examples)
+- Workspace overview: [README.md](https://github.com/cline/cline/blob/main/README.md)
+- API and architecture references: [DOC.md](https://github.com/cline/cline/blob/main/DOC.md), [ARCHITECTURE.md](https://github.com/cline/cline/blob/main/ARCHITECTURE.md)
diff --git a/sdk/packages/core/bun.mts b/sdk/packages/core/bun.mts
new file mode 100644
index 0000000..0a43240
--- /dev/null
+++ b/sdk/packages/core/bun.mts
@@ -0,0 +1,82 @@
+/// <reference types="@types/bun" />
+export {};
+
+type PackageManifest = {
+	dependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+};
+
+const packageJson = (await Bun.file(
+	new URL("./package.json", import.meta.url),
+).json()) as PackageManifest;
+
+// Keep declared runtime packages external so they are not duplicated inside each
+// bundled entrypoint and installed again from package.json.
+const external = Object.keys({
+	...(packageJson.dependencies ?? {}),
+	...(packageJson.peerDependencies ?? {}),
+});
+
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+// minify: true keeps identifier mangling active even when sourcemaps are enabled.
+const minify = Bun.env.CLINE_SOURCEMAPS !== "1";
+
+const buildConfig = {
+	target: "node",
+	format: "esm",
+	minify,
+	packages: "bundle",
+	sourcemap,
+	external,
+} as const;
+
+const builds: Parameters<typeof Bun.build>[0][] = [
+	// Build main exports separately to avoid Bun bundler output path conflicts
+	{
+		entrypoints: ["./src/index.ts"],
+		outdir: "./dist",
+		...buildConfig,
+	},
+	{
+		entrypoints: ["./src/hub/index.ts"],
+		outdir: "./dist/hub",
+		...buildConfig,
+	},
+	{
+		entrypoints: ["./src/hub/daemon/entry.ts"],
+		outdir: "./dist/hub/daemon",
+		...buildConfig,
+	},
+	{
+		entrypoints: ["./src/services/telemetry/index.ts"],
+		outdir: "./dist/services/telemetry",
+		...buildConfig,
+	},
+	{
+		entrypoints: ["./src/services/feature-flags/posthog.ts"],
+		outdir: "./dist/services/feature-flags",
+		...buildConfig,
+	},
+	// The plugin sandbox bootstrap runs in an isolated child process via
+	// SubprocessSandbox and must be emitted as a separate executable entrypoint.
+	{
+		entrypoints: ["./src/extensions/plugin/plugin-sandbox-bootstrap.ts"],
+		outdir: "./dist/extensions",
+		...buildConfig,
+	},
+];
+
+for (const config of builds) {
+	const result = await Bun.build(config as Parameters<typeof Bun.build>[0]);
+
+	if (!result.success) {
+		console.error("Build failed for entrypoints:", config.entrypoints);
+		process.exit(1);
+	}
+
+	if (result.logs.length > 0) {
+		for (const log of result.logs) {
+			console.warn(log);
+		}
+	}
+}
diff --git a/sdk/packages/core/docs/messages-contract-v1.md b/sdk/packages/core/docs/messages-contract-v1.md
new file mode 100644
index 0000000..6a08d79
--- /dev/null
+++ b/sdk/packages/core/docs/messages-contract-v1.md
@@ -0,0 +1,148 @@
+# messages.json contract — v1
+
+This document describes the persisted session messages artifact written by
+`@cline/core` at:
+
+```
+~/.cline/data/sessions/<sessionId>/<sessionId>.messages.json
+```
+
+It is the canonical replay/export artifact. Downstream consumers (for example,
+ATIF converters) should be able to reconstruct a full session trajectory from
+this file alone. `hooks.jsonl` in the same directory is observability/debug
+telemetry and is not required for replay or export.
+
+The schema is versioned by the top-level `version` field. This document
+describes **version `1`**.
+
+## File-level shape
+
+```jsonc
+{
+  "version": 1,
+  "updated_at": "2026-04-22T17:42:10.123Z",
+  "agent": "lead" | "subagent" | "teammate",
+  "sessionId": "<session-id>",
+  "taskType": "...",              // optional; present for subagent/team runs
+  "messages": [ /* see below */ ],
+  "system_prompt": "..."          // optional
+}
+```
+
+Producer: [`buildMessagesFilePayload`](../src/services/session-data.ts).
+
+## Message shape
+
+Each entry in `messages[]` is a normalized stored message:
+
+```jsonc
+{
+  "id": "<stable-nanoid>",             // always present; generated if missing
+  "role": "user" | "assistant",
+  "content": [ /* content blocks, see below */ ],
+  "ts": 1745343730123,                 // epoch ms; present on assistant turn messages
+  "modelInfo": {                       // assistant only; see assistant guarantees
+    "id": "claude-sonnet-4-6",
+    "provider": "anthropic",
+    "family": "claude-sonnet-4"        // optional
+  },
+  "metrics": {                         // terminal assistant message of a turn; see below
+    "inputTokens": 21,
+    "outputTokens": 8,
+    "cacheReadTokens": 3,
+    "cacheWriteTokens": 1,
+    "cost": 0.13
+  }
+}
+```
+
+Notes:
+
+- `role` is `"user"` or `"assistant"`. There is no distinct `"tool"` role at
+  rest — tool results are embedded as `tool_result` blocks on a `user` message
+  (Anthropic-native shape).
+- `content` is always an array. No string-form content.
+
+## Content block shape (Anthropic-native)
+
+The persisted content uses the provider-native block shape, not the gateway
+kebab-case shape. Valid block `type` values:
+
+| `type`        | Fields                                                | Role      |
+|---------------|-------------------------------------------------------|-----------|
+| `text`        | `text: string`                                        | any       |
+| `thinking`    | `thinking: string` (reasoning text)                   | assistant |
+| `tool_use`    | `id: string`, `name: string`, `input: unknown`        | assistant |
+| `tool_result` | `tool_use_id: string`, `content: unknown`, `is_error?: boolean` | user |
+
+Correlation: a `tool_result.tool_use_id` matches a prior
+`tool_use.id` on an assistant message. IDs are stable within the session.
+
+Error signal on tool results: `is_error` is the single canonical field.
+When set by the provider path it is normalized to boolean (`false` by default).
+
+## Assistant turn guarantees
+
+For each **completed** assistant turn (one the model actually produced output
+for), the terminal assistant message of that turn carries:
+
+- `modelInfo.id` (required)
+- `modelInfo.provider` (required)
+- `metrics.inputTokens` (required)
+- `metrics.outputTokens` (required)
+- `metrics.cacheReadTokens` (required; `0` allowed)
+- `metrics.cacheWriteTokens` (required; `0` allowed)
+- `metrics.cost` (required; `0` allowed)
+
+If an assistant turn emits multiple assistant messages in the same run, only
+the **last** assistant message of that turn carries `metrics`. Earlier
+assistant messages in the same turn still carry `modelInfo`.
+
+Enforced by
+[`withLatestAssistantTurnMetadata`](../src/services/session-data.ts) and
+covered by the LocalRuntimeHost e2e contract test in
+[`../src/runtime/host/local-runtime-host.e2e.test.ts`](../src/runtime/host/local-runtime-host.e2e.test.ts).
+
+## Failure and retry semantics
+
+1. **Turn succeeds.** Terminal assistant message has full `modelInfo` +
+   `metrics` as above.
+
+2. **Turn fails before any assistant output exists.** No assistant message is
+   appended. The persisted file remains a valid snapshot with no fabricated
+   usage/model metadata. Consumers must not assume every completed session
+   ends in an assistant message.
+
+3. **Transient failure followed by successful retry** (for example, auth
+   refresh + retry). Prior assistant messages retain their `modelInfo` and
+   `metrics`; the retry's terminal assistant message carries the new turn's
+   `metrics`. Prior metrics are not overwritten or dropped.
+
+4. **Multiple assistant messages in one turn.** The last assistant message of
+   that turn carries the turn's `metrics`. Earlier assistant messages in the
+   same turn carry `modelInfo` but no `metrics`.
+
+These behaviors are identical across CLI, desktop sidecar, and subagent /
+team-task session paths.
+
+## Versioning
+
+The top-level `version` field is a number. Today it is `1`. Any
+backwards-incompatible change to the shape above will increment this value.
+Additive fields (new optional top-level keys, new optional message fields)
+may appear without a version bump, so consumers should tolerate unknown
+keys.
+
+## Example
+
+A golden example for v1 lives at
+[`../fixtures/messages/success.messages.json`](../fixtures/messages/success.messages.json):
+single turn with reasoning + tool call + tool result + final text. It is
+provided as a copy-paste reference for downstream translators.
+
+The authoritative guarantees come from the real writer path and the
+end-to-end tests in
+[`../src/runtime/host/local-runtime-host.e2e.test.ts`](../src/runtime/host/local-runtime-host.e2e.test.ts)
+and [`../src/runtime/host/local-runtime-host.test.ts`](../src/runtime/host/local-runtime-host.test.ts); if
+the example ever drifts from what the writer emits, those tests are the
+source of truth.
diff --git a/sdk/packages/core/fixtures/messages/success.messages.json b/sdk/packages/core/fixtures/messages/success.messages.json
new file mode 100644
index 0000000..f53a552
--- /dev/null
+++ b/sdk/packages/core/fixtures/messages/success.messages.json
@@ -0,0 +1,72 @@
+{
+	"version": 1,
+	"updated_at": "2026-04-22T17:42:10.123Z",
+	"agent": "lead",
+	"sessionId": "fixture-success-01",
+	"messages": [
+		{
+			"id": "msg_user_1",
+			"role": "user",
+			"content": [
+				{ "type": "text", "text": "Inspect the README and summarize it." }
+			]
+		},
+		{
+			"id": "msg_assistant_1",
+			"role": "assistant",
+			"ts": 1745343730123,
+			"modelInfo": {
+				"id": "claude-sonnet-4-6",
+				"provider": "anthropic",
+				"family": "claude-sonnet-4"
+			},
+			"content": [
+				{
+					"type": "thinking",
+					"thinking": "I should read the README first before summarizing."
+				},
+				{
+					"type": "tool_use",
+					"id": "tool-call-1",
+					"name": "read_files",
+					"input": { "path": "/tmp/project/README.md" }
+				}
+			]
+		},
+		{
+			"id": "msg_user_2",
+			"role": "user",
+			"content": [
+				{
+					"type": "tool_result",
+					"tool_use_id": "tool-call-1",
+					"content": "# Project\n\nA small test fixture.",
+					"is_error": false
+				}
+			]
+		},
+		{
+			"id": "msg_assistant_2",
+			"role": "assistant",
+			"ts": 1745343731456,
+			"modelInfo": {
+				"id": "claude-sonnet-4-6",
+				"provider": "anthropic",
+				"family": "claude-sonnet-4"
+			},
+			"metrics": {
+				"inputTokens": 21,
+				"outputTokens": 8,
+				"cacheReadTokens": 3,
+				"cacheWriteTokens": 1,
+				"cost": 0.13
+			},
+			"content": [
+				{
+					"type": "text",
+					"text": "The README describes a small test fixture project."
+				}
+			]
+		}
+	]
+}
diff --git a/sdk/packages/core/package.json b/sdk/packages/core/package.json
new file mode 100644
index 0000000..ae67fcf
--- /dev/null
+++ b/sdk/packages/core/package.json
@@ -0,0 +1,93 @@
+{
+	"name": "@cline/core",
+	"description": "Cline Core SDK for Node Runtime",
+	"version": "0.0.59",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline",
+		"directory": "sdk/packages/core"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"main": "./dist/index.js",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./hub": {
+			"types": "./dist/hub/index.d.ts",
+			"import": "./dist/hub/index.js"
+		},
+		"./hub/daemon-entry": {
+			"types": "./dist/hub/daemon/entry.d.ts",
+			"import": "./dist/hub/daemon/entry.js"
+		},
+		"./telemetry": {
+			"types": "./dist/services/telemetry/index.d.ts",
+			"import": "./dist/services/telemetry/index.js"
+		},
+		"./services/feature-flags/posthog": {
+			"types": "./dist/services/feature-flags/posthog.d.ts",
+			"import": "./dist/services/feature-flags/posthog.js"
+		}
+	},
+	"scripts": {
+		"build": "bun run ./bun.mts && bun tsc -p tsconfig.build.json",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit && bun run typecheck:smoke",
+		"typecheck:smoke": "bun tsc -p tsconfig.smoke.json --noEmit",
+		"test": "bun run test:unit && bun run test:e2e",
+		"test:live": "vitest run --config vitest.config.ts src/extensions/context/compaction.live.test.ts",
+		"test:unit": "vitest run --config vitest.config.ts",
+		"test:e2e": "vitest run --config vitest.e2e.config.ts",
+		"verify:routines": "zsh -lc 'bunx vitest run src/cron/schedule-service.test.ts --config vitest.config.ts'",
+		"test:watch": "vitest --config vitest.config.ts"
+	},
+	"dependencies": {
+		"@cline/agents": "workspace:*",
+		"@cline/shared": "workspace:*",
+		"@cline/llms": "workspace:*",
+		"@modelcontextprotocol/sdk": "^1.29.0",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.214.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+		"@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+		"@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+		"@opentelemetry/resources": "^2.6.1",
+		"@opentelemetry/sdk-logs": "^0.214.0",
+		"@opentelemetry/sdk-metrics": "^2.6.1",
+		"@opentelemetry/sdk-trace-base": "^2.6.1",
+		"@opentelemetry/sdk-trace-node": "^2.6.1",
+		"@opentelemetry/semantic-conventions": "^1.40.0",
+		"jiti": "^2.7.0",
+		"node-machine-id": "^1.1.12",
+		"nanoid": "^5.1.7",
+		"simple-git": "3.36.0",
+		"ws": "^8.20.0",
+		"yaml": "^2.8.2",
+		"zod": "^4.3.6"
+	},
+	"peerDependencies": {
+		"posthog-node": "^5.8.0"
+	},
+	"peerDependenciesMeta": {
+		"posthog-node": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@types/ws": "^8.18.1",
+		"posthog-node": "^5.8.0"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.d.ts.map"
+	]
+}
diff --git a/sdk/packages/core/scripts/telemetry-smoke-host.ts b/sdk/packages/core/scripts/telemetry-smoke-host.ts
new file mode 100644
index 0000000..64074ed
--- /dev/null
+++ b/sdk/packages/core/scripts/telemetry-smoke-host.ts
@@ -0,0 +1,204 @@
+/**
+ * Host-level telemetry smoke test for ENG-1902.
+ *
+ * Exercises the CLI memoized activation helper and the VS Code shared
+ * telemetry factory using the configured OTEL telemetry pipeline + a
+ * BasicLogger sink. With OTEL_TELEMETRY_ENABLED unset the OpenTelemetry
+ * provider stays disabled, so we observe events through the
+ * `TelemetryLoggerSink` log lines (`telemetry.event`). Activation and
+ * workspace lifecycle events are routed through normal `capture` so they
+ * respect the user's telemetry opt-out setting.
+ */
+
+import {
+	createClineTelemetryServiceConfig,
+	type ITelemetryService,
+} from "@cline/shared";
+import {
+	captureExtensionActivated,
+	identifyAccount,
+} from "../src/services/telemetry/core-events";
+import { createConfiguredTelemetryService } from "../src/services/telemetry/OpenTelemetryProvider";
+
+interface CapturedLog {
+	channel: "log" | "debug" | "error";
+	message: string;
+	metadata?: Record<string, unknown>;
+}
+
+class CapturingLogger {
+	readonly entries: CapturedLog[] = [];
+	log(message: string, metadata?: Record<string, unknown>): void {
+		this.entries.push({ channel: "log", message, metadata });
+	}
+	debug(message: string, metadata?: Record<string, unknown>): void {
+		this.entries.push({ channel: "debug", message, metadata });
+	}
+	error(message: string, metadata?: Record<string, unknown>): void {
+		this.entries.push({ channel: "error", message, metadata });
+	}
+}
+
+function header(t: string) {
+	console.log(`\n=== ${t} ===`);
+}
+
+function dumpActivationEvents(
+	logger: CapturingLogger,
+	eventName: string,
+): number {
+	let count = 0;
+	for (const e of logger.entries) {
+		if (e.message !== "telemetry.event") {
+			continue;
+		}
+		const md = (e.metadata ?? {}) as {
+			event?: string;
+			properties?: Record<string, unknown>;
+		};
+		if (md.event !== eventName) {
+			continue;
+		}
+		count++;
+		console.log(`[event] ${md.event} ${JSON.stringify(md.properties ?? {})}`);
+	}
+	return count;
+}
+
+/**
+ * Mirror of the per-process memoized CLI activation helper from
+ * `apps/cli/src/utils/telemetry.ts` (`captureCliExtensionActivated`).
+ *
+ * Cross-importing from `apps/cli/...` here would pull the full
+ * `@cline/core` barrel which transitively requires `@cline/llms`, so
+ * we replicate the exact memoization pattern locally and call the same
+ * underlying core helper.
+ */
+interface AccountContext {
+	id?: string;
+	email?: string;
+	provider?: string;
+	organizationId?: string;
+	organizationName?: string;
+	memberId?: string;
+}
+
+function makeMemoizedCliActivator(telemetry: ITelemetryService) {
+	let captured = false;
+	return (account?: AccountContext) => {
+		if (captured) {
+			return;
+		}
+		captured = true;
+		// Mirror the real apps/cli helper: identify the active account/org
+		// (mapped onto telemetry common properties via `identifyAccount`)
+		// strictly before emitting `user.extension_activated`, so the
+		// activation event itself carries `organization_id` and friends.
+		if (account) {
+			identifyAccount(telemetry, account);
+		}
+		captureExtensionActivated(telemetry);
+	};
+}
+
+async function smokeCli() {
+	header(
+		"CLI: memoized captureCliExtensionActivated equivalent (only first call should emit)",
+	);
+	const logger = new CapturingLogger();
+	const cfg = createClineTelemetryServiceConfig({
+		metadata: {
+			extension_version: "0.0.0-smoke",
+			cline_type: "cli",
+			platform: "smoke-cli",
+			platform_version: process.version,
+			os_type: process.platform,
+			os_version: "smoke",
+		},
+	});
+	const { telemetry, provider } = createConfiguredTelemetryService({
+		...cfg,
+		logger,
+	});
+	const captureCliActivation = makeMemoizedCliActivator(telemetry);
+	captureCliActivation();
+	captureCliActivation(); // memoized: must NOT emit a second event.
+	const captured = dumpActivationEvents(logger, "user.extension_activated");
+	console.log(
+		`captured ${captured} user.extension_activated event(s); expected exactly 1.`,
+	);
+	await Promise.allSettled([telemetry.dispose(), provider?.dispose()]);
+}
+
+async function smokeCliAuthenticated() {
+	header(
+		"CLI: authenticated captureCliExtensionActivated should carry organization_id",
+	);
+	const logger = new CapturingLogger();
+	const cfg = createClineTelemetryServiceConfig({
+		metadata: {
+			extension_version: "0.0.0-smoke",
+			cline_type: "cli",
+			platform: "smoke-cli",
+			platform_version: process.version,
+			os_type: process.platform,
+			os_version: "smoke",
+		},
+	});
+	const { telemetry, provider } = createConfiguredTelemetryService({
+		...cfg,
+		logger,
+	});
+	const captureCliActivation = makeMemoizedCliActivator(telemetry);
+	captureCliActivation({
+		id: "user-smoke",
+		email: "user@example.com",
+		provider: "cline",
+		organizationId: "org-smoke",
+		organizationName: "Smoke Org",
+		memberId: "member-smoke",
+	});
+	const captured = dumpActivationEvents(logger, "user.extension_activated");
+	console.log(
+		`captured ${captured} user.extension_activated event(s); expected exactly 1, with organization_id="org-smoke".`,
+	);
+	await Promise.allSettled([telemetry.dispose(), provider?.dispose()]);
+}
+
+async function smokeVscode() {
+	header("VS Code: createVscodeTelemetry-equivalent shared service");
+	const logger = new CapturingLogger();
+	const cfg = createClineTelemetryServiceConfig({
+		metadata: {
+			extension_version: "0.0.0-smoke",
+			cline_type: "VSCode Extension",
+			platform: "Visual Studio Code",
+			platform_version: "1.113.0",
+			os_type: process.platform,
+			os_version: "smoke",
+		},
+	});
+	const { telemetry, provider } = createConfiguredTelemetryService({
+		...cfg,
+		logger,
+	});
+	// Single shared activation event for the VS Code host
+	captureExtensionActivated(telemetry);
+	const captured = dumpActivationEvents(logger, "user.extension_activated");
+	console.log(
+		`captured ${captured} user.extension_activated event(s); expected exactly 1.`,
+	);
+	await Promise.allSettled([telemetry.dispose(), provider?.dispose()]);
+}
+
+async function main() {
+	await smokeCli();
+	await smokeCliAuthenticated();
+	await smokeVscode();
+	header("Done");
+}
+
+main().catch((err) => {
+	console.error("host smoke test failed:", err);
+	process.exitCode = 1;
+});
diff --git a/sdk/packages/core/scripts/telemetry-smoke.ts b/sdk/packages/core/scripts/telemetry-smoke.ts
new file mode 100644
index 0000000..8667167
--- /dev/null
+++ b/sdk/packages/core/scripts/telemetry-smoke.ts
@@ -0,0 +1,431 @@
+/**
+ * Telemetry smoke test for ENG-1902.
+ *
+ * Runs each activation/workspace funnel event through the SDK telemetry
+ * helpers using a minimal capturing telemetry service. Prints the captured
+ * event names and event-specific payloads so a human can verify no raw
+ * paths leak and that the legacy snake_case schema is preserved. Activation
+ * and workspace events are routed through normal `capture` so they respect
+ * the user's telemetry opt-out setting.
+ *
+ * Usage:
+ *   bunx --bun tsx packages/core/scripts/telemetry-smoke.ts
+ *   # or
+ *   bun packages/core/scripts/telemetry-smoke.ts
+ */
+import type { ITelemetryService, TelemetryProperties } from "@cline/shared";
+import {
+	captureConversationTurnEvent,
+	captureExtensionActivated,
+	captureTaskCompleted,
+	captureTaskCreated,
+	captureTaskRestarted,
+	captureWorkspaceInitError,
+	captureWorkspaceInitialized,
+	captureWorkspacePathResolved,
+} from "../src/services/telemetry/core-events";
+import {
+	emitWorkspaceLifecycleTelemetry,
+	resetWorkspaceTelemetryForTests,
+} from "../src/services/workspace/workspace-telemetry";
+
+type RecordedEvent = {
+	name: string;
+	properties?: Record<string, unknown>;
+	required: boolean;
+};
+
+/**
+ * Minimal capturing stub used by the smoke harness. Intentionally **not**
+ * declared `implements ITelemetryService` because this file is a CLI smoke
+ * harness — its purpose is to record `capture()` / `captureRequired()`
+ * payloads for human inspection, not to track every method that lands on
+ * the production telemetry interface (e.g. `setMetadata`,
+ * `setCommonProperties`, the `recordCounter` overload). Casting the
+ * instance via `unknown as ITelemetryService` at the call site lets the
+ * harness stay tiny while still typechecking under
+ * `tsconfig.smoke.json`.
+ */
+class CapturingTelemetry {
+	readonly events: RecordedEvent[] = [];
+
+	capture(event: { event: string; properties?: TelemetryProperties }): void {
+		this.events.push({
+			name: event.event,
+			properties: event.properties as Record<string, unknown> | undefined,
+			required: false,
+		});
+	}
+
+	captureRequired(event: string, properties?: TelemetryProperties): void {
+		this.events.push({
+			name: event,
+			properties: properties as Record<string, unknown> | undefined,
+			required: true,
+		});
+	}
+
+	setDistinctId(_id?: string): void {}
+	updateCommonProperties(_props: TelemetryProperties): void {}
+	identify(_distinctId: string, _properties?: TelemetryProperties): void {}
+	isEnabled(): boolean {
+		return true;
+	}
+	async dispose(): Promise<void> {}
+	async flush(): Promise<void> {}
+	recordCounter(): void {}
+	recordHistogram(): void {}
+	recordGauge(): void {}
+}
+
+/**
+ * Cast helper so call sites can pass the harness stub to functions that
+ * accept the real `ITelemetryService` without each call duplicating the
+ * `unknown` cast. See {@link CapturingTelemetry} for why we don't track
+ * the production interface directly.
+ */
+function asITelemetryService(stub: CapturingTelemetry): ITelemetryService {
+	return stub as unknown as ITelemetryService;
+}
+
+function header(title: string) {
+	console.log(`\n=== ${title} ===`);
+}
+
+function rawPathLeakCheck(events: RecordedEvent[], rawPath: string) {
+	for (const evt of events) {
+		const dump = JSON.stringify(evt.properties ?? {});
+		if (dump.includes(rawPath)) {
+			console.log(`!! event ${evt.name} leaks raw path; properties=${dump}`);
+			process.exitCode = 2;
+			return;
+		}
+	}
+	console.log(
+		`✓ no raw workspace path "${rawPath}" leaked into ${events.length} captured event(s).`,
+	);
+}
+
+function dumpEvents(events: RecordedEvent[]) {
+	for (const evt of events) {
+		// Activation/workspace events are now routed through normal `capture`
+		// so the [required] tag is only kept for visibility on any unexpected
+		// captureRequired() usage during the smoke run.
+		const tag = evt.required ? "[required]" : "[event]   ";
+		console.log(`${tag} ${evt.name} ${JSON.stringify(evt.properties ?? {})}`);
+	}
+}
+
+/**
+ * Assertion helper for smoke checks. Logs the comparison and, when the
+ * assertion fails, sets `process.exitCode = 1` so CI can catch regressions
+ * if the smoke harness is wired into a check step. Without this the script
+ * would happily exit 0 on a count mismatch and silently mask broken
+ * telemetry plumbing.
+ */
+function assertSmoke(
+	label: string,
+	actual: number | string | boolean,
+	expected: number | string | boolean,
+): void {
+	const ok = actual === expected;
+	const marker = ok ? "✓" : "!!";
+	console.log(`${marker} ${label}: actual=${actual} expected=${expected}`);
+	if (!ok) {
+		process.exitCode = 1;
+	}
+}
+
+async function main() {
+	resetWorkspaceTelemetryForTests();
+
+	header("user.extension_activated (CLI/VS Code activation parity)");
+	{
+		const t = new CapturingTelemetry();
+		captureExtensionActivated(asITelemetryService(t));
+		dumpEvents(t.events);
+	}
+
+	header("workspace.initialized + workspace.init_error (lifecycle emitter)");
+	{
+		const t = new CapturingTelemetry();
+		const healthyRoot = "/tmp/healthy-repo";
+		const brokenRoot = "/tmp/broken-repo";
+		const tSvc = asITelemetryService(t);
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: tSvc,
+			rootPath: healthyRoot,
+			rootCount: 1,
+			vcsType: "git",
+			durationMs: 92.7155,
+			featureFlagEnabled: true,
+		});
+		// duplicate call to verify per-process de-dup
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: tSvc,
+			rootPath: healthyRoot,
+			rootCount: 1,
+			vcsType: "git",
+			durationMs: 12.345,
+		});
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: tSvc,
+			rootPath: brokenRoot,
+			rootCount: 0,
+			vcsType: "none",
+			initError: {
+				errorType: "WorkspaceSetupError",
+				message: "permission denied while probing git repository",
+			},
+		});
+		dumpEvents(t.events);
+		rawPathLeakCheck(t.events, healthyRoot);
+		rawPathLeakCheck(t.events, brokenRoot);
+		const initialized = t.events.filter(
+			(e) => e.name === "workspace.initialized",
+		);
+		const initError = t.events.filter((e) => e.name === "workspace.init_error");
+		console.log(
+			`emitted ${initialized.length} workspace.initialized and ${initError.length} workspace.init_error events; expected 2 + 1.`,
+		);
+		assertSmoke(
+			"workspace.initialized count (after de-dup gate)",
+			initialized.length,
+			2,
+		);
+		assertSmoke("workspace.init_error count", initError.length, 1);
+	}
+
+	header("explicit captureWorkspaceInitialized payload sample");
+	{
+		const t = new CapturingTelemetry();
+		captureWorkspaceInitialized(asITelemetryService(t), {
+			root_count: 2,
+			vcs_types: ["git", "hg"],
+			init_duration_ms: 134.5,
+			feature_flag_enabled: true,
+			is_remote_workspace: false,
+		});
+		dumpEvents(t.events);
+	}
+
+	header("explicit captureWorkspaceInitError payload sample");
+	{
+		const t = new CapturingTelemetry();
+		captureWorkspaceInitError(
+			asITelemetryService(t),
+			Object.assign(new Error("simulated init failure"), {
+				name: "WorkspaceSetupError",
+			}),
+			{ fallback_to_single_root: true, workspace_count: 0 },
+		);
+		dumpEvents(t.events);
+	}
+
+	header("explicit captureWorkspacePathResolved payload sample");
+	{
+		const t = new CapturingTelemetry();
+		captureWorkspacePathResolved(asITelemetryService(t), {
+			ulid: "ulid-smoke-explicit",
+			context: "search_codebase",
+			resolution_type: "hint_provided",
+			hint_type: "workspace_name",
+			resolution_success: true,
+			target_workspace_index: 1,
+			is_multi_root_enabled: true,
+		});
+		dumpEvents(t.events);
+	}
+
+	header("task.created (canonical task-start event for new sessions)");
+	{
+		const t = new CapturingTelemetry();
+		captureTaskCreated(asITelemetryService(t), {
+			ulid: "ulid-smoke-task-1",
+			apiProvider: "anthropic",
+		});
+		dumpEvents(t.events);
+		const created = t.events.filter((e) => e.name === "task.created");
+		console.log(
+			`emitted ${created.length} task.created event(s); expected exactly 1.`,
+		);
+		assertSmoke("task.created count", created.length, 1);
+	}
+
+	header("task.restarted (sibling event when an existing task is resumed)");
+	{
+		const t = new CapturingTelemetry();
+		captureTaskRestarted(asITelemetryService(t), {
+			ulid: "ulid-smoke-task-1",
+			apiProvider: "anthropic",
+		});
+		dumpEvents(t.events);
+		const restarted = t.events.filter((e) => e.name === "task.restarted");
+		console.log(
+			`emitted ${restarted.length} task.restarted event(s); expected exactly 1.`,
+		);
+		assertSmoke("task.restarted count", restarted.length, 1);
+	}
+
+	header("task.conversation_turn (user + assistant turns)");
+	{
+		const t = new CapturingTelemetry();
+		const tSvc = asITelemetryService(t);
+		captureConversationTurnEvent(tSvc, {
+			ulid: "ulid-smoke-task-1",
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			source: "user",
+			mode: "act",
+		});
+		captureConversationTurnEvent(tSvc, {
+			ulid: "ulid-smoke-task-1",
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			source: "assistant",
+			mode: "act",
+		});
+		dumpEvents(t.events);
+		const turns = t.events.filter((e) => e.name === "task.conversation_turn");
+		const userTurns = turns.filter((e) => e.properties?.source === "user");
+		const assistantTurns = turns.filter(
+			(e) => e.properties?.source === "assistant",
+		);
+		const allHaveTimestamp = turns.every(
+			(e) => typeof e.properties?.timestamp === "string",
+		);
+		console.log(
+			`emitted ${turns.length} task.conversation_turn event(s); expected 2 (1 user + 1 assistant).`,
+		);
+		console.log(
+			`  user=${userTurns.length} assistant=${assistantTurns.length} all_have_timestamp=${allHaveTimestamp}`,
+		);
+		assertSmoke("task.conversation_turn count", turns.length, 2);
+		assertSmoke("task.conversation_turn user count", userTurns.length, 1);
+		assertSmoke(
+			"task.conversation_turn assistant count",
+			assistantTurns.length,
+			1,
+		);
+		assertSmoke(
+			"task.conversation_turn timestamps populated",
+			allHaveTimestamp,
+			true,
+		);
+	}
+
+	header(
+		"task.completed source=submit_and_exit (assistant declared completion)",
+	);
+	{
+		const t = new CapturingTelemetry();
+		captureTaskCompleted(asITelemetryService(t), {
+			ulid: "ulid-smoke-task-1",
+			provider: "anthropic",
+			modelId: "claude-sonnet-4-5",
+			mode: "act",
+			durationMs: 12_345,
+			source: "submit_and_exit",
+		});
+		dumpEvents(t.events);
+		const completed = t.events.filter((e) => e.name === "task.completed");
+		const submitSourced = completed.filter(
+			(e) => e.properties?.source === "submit_and_exit",
+		);
+		console.log(
+			`emitted ${completed.length} task.completed event(s); expected 1 with source="submit_and_exit" (got ${submitSourced.length}).`,
+		);
+		assertSmoke("task.completed (submit_and_exit) count", completed.length, 1);
+		assertSmoke(
+			"task.completed source=submit_and_exit count",
+			submitSourced.length,
+			1,
+		);
+	}
+
+	header(
+		"task.completed source=shutdown (non-interactive fallback when submit_and_exit was not observed)",
+	);
+	{
+		const t = new CapturingTelemetry();
+		captureTaskCompleted(asITelemetryService(t), {
+			ulid: "ulid-smoke-task-2",
+			provider: "anthropic",
+			modelId: "claude-sonnet-4-5",
+			mode: "act",
+			durationMs: 9_876,
+			source: "shutdown",
+		});
+		dumpEvents(t.events);
+		const completed = t.events.filter((e) => e.name === "task.completed");
+		const shutdownSourced = completed.filter(
+			(e) => e.properties?.source === "shutdown",
+		);
+		console.log(
+			`emitted ${completed.length} task.completed event(s); expected 1 with source="shutdown" (got ${shutdownSourced.length}).`,
+		);
+		assertSmoke("task.completed (shutdown) count", completed.length, 1);
+		assertSmoke(
+			"task.completed source=shutdown count",
+			shutdownSourced.length,
+			1,
+		);
+	}
+
+	header(
+		"task lifecycle in order: created → conversation_turn × 2 → completed (single capturing telemetry)",
+	);
+	{
+		const t = new CapturingTelemetry();
+		const tSvc = asITelemetryService(t);
+		const ulid = "ulid-smoke-task-lifecycle";
+		captureTaskCreated(tSvc, {
+			ulid,
+			apiProvider: "anthropic",
+		});
+		captureConversationTurnEvent(tSvc, {
+			ulid,
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			source: "user",
+			mode: "act",
+		});
+		captureConversationTurnEvent(tSvc, {
+			ulid,
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			source: "assistant",
+			mode: "act",
+		});
+		captureTaskCompleted(tSvc, {
+			ulid,
+			provider: "anthropic",
+			modelId: "claude-sonnet-4-5",
+			mode: "act",
+			durationMs: 4_242,
+			source: "submit_and_exit",
+		});
+		dumpEvents(t.events);
+		const order = t.events.map((e) => e.name);
+		const expectedOrder = [
+			"task.created",
+			"task.conversation_turn",
+			"task.conversation_turn",
+			"task.completed",
+		];
+		const orderOk =
+			order.length === expectedOrder.length &&
+			order.every((name, idx) => name === expectedOrder[idx]);
+		console.log(
+			`event order: [${order.join(", ")}]; expected [${expectedOrder.join(", ")}]; ok=${orderOk}.`,
+		);
+		assertSmoke("task lifecycle event order", orderOk, true);
+	}
+
+	header("Done");
+}
+
+main().catch((err) => {
+	console.error("smoke test failed:", err);
+	process.exitCode = 1;
+});
diff --git a/sdk/packages/core/src/ClineCore.test.ts b/sdk/packages/core/src/ClineCore.test.ts
new file mode 100644
index 0000000..3002e78
--- /dev/null
+++ b/sdk/packages/core/src/ClineCore.test.ts
@@ -0,0 +1,767 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ClineCoreStartInput } from "./cline-core/types";
+import type {
+	StartSessionInput,
+	StartSessionResult,
+} from "./runtime/host/runtime-host";
+
+const { createRuntimeHostMock } = vi.hoisted(() => ({
+	createRuntimeHostMock: vi.fn(),
+}));
+
+vi.mock("./runtime/host/host", () => ({
+	createRuntimeHost: createRuntimeHostMock,
+}));
+
+import type { AgentResult } from "@cline/shared";
+import { ClineCore } from "./ClineCore";
+import { NoOpFeatureFlagsProvider } from "./services/feature-flags";
+
+function createStartInput(): ClineCoreStartInput {
+	return {
+		config: {
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			apiKey: "test",
+			cwd: "/tmp/workspace",
+			workspaceRoot: "/tmp/workspace",
+			systemPrompt: "You are concise.",
+			mode: "act",
+			enableTools: true,
+			enableSpawnAgent: false,
+			enableAgentTeams: false,
+		},
+		prompt: "hello",
+		interactive: false,
+	};
+}
+
+function createStartResult(sessionId: string): StartSessionResult {
+	return {
+		sessionId,
+		manifest: {} as StartSessionResult["manifest"],
+		manifestPath: `/tmp/${sessionId}.json`,
+		messagesPath: `/tmp/${sessionId}.messages.json`,
+	};
+}
+
+function createAgentResult(text: string): AgentResult {
+	const now = new Date("2026-04-24T10:00:00.000Z");
+	return {
+		text,
+		usage: {
+			inputTokens: 1,
+			outputTokens: 1,
+		},
+		messages: [],
+		toolCalls: [],
+		iterations: 1,
+		finishReason: "completed",
+		model: {
+			id: "test-model",
+			provider: "test-provider",
+		},
+		startedAt: now,
+		endedAt: now,
+		durationMs: 1,
+	};
+}
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", ["-C", cwd, ...args], {
+		encoding: "utf8",
+	}).trim();
+}
+
+describe("ClineCore", () => {
+	beforeEach(() => {
+		createRuntimeHostMock.mockReset();
+	});
+
+	it("compares a checkpoint to the current workspace through the public SDK API", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "cline-core-compare-"));
+		let core: ClineCore | undefined;
+		try {
+			git(dir, ["init", "-b", "main"]);
+			git(dir, ["config", "user.email", "test@example.com"]);
+			git(dir, ["config", "user.name", "Test User"]);
+			writeFileSync(join(dir, "tracked.txt"), "before\n", "utf8");
+			git(dir, ["add", "."]);
+			git(dir, ["commit", "-m", "initial"]);
+			const checkpointRef = git(dir, ["rev-parse", "HEAD"]);
+			writeFileSync(join(dir, "tracked.txt"), "after\n", "utf8");
+
+			const host = {
+				runtimeAddress: undefined,
+				startSession: vi.fn(),
+				runTurn: vi.fn(),
+				restoreSession: vi.fn(),
+				getAccumulatedUsage: vi.fn(),
+				abort: vi.fn(),
+				stopSession: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn(async () => ({
+					sessionId: "session-1",
+					cwd: dir,
+					workspaceRoot: dir,
+					metadata: {
+						checkpoint: {
+							history: [
+								{
+									ref: checkpointRef,
+									runCount: 1,
+									createdAt: 1,
+									kind: "commit",
+								},
+							],
+						},
+					},
+				})),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				readSessionMessages: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				subscribe: vi.fn(() => () => {}),
+				updateSessionModel: vi.fn(),
+			};
+			createRuntimeHostMock.mockResolvedValue(host);
+
+			core = await ClineCore.create();
+			const result = await core.compareCheckpoint({
+				sessionId: "session-1",
+				checkpointRunCount: 1,
+			});
+
+			expect(host.getSession).toHaveBeenCalledWith("session-1");
+			expect(result.checkpoint.ref).toBe(checkpointRef);
+			expect(result.diffs).toEqual([
+				{
+					filePath: join(dir, "tracked.txt"),
+					leftContent: "before\n",
+					rightContent: "after\n",
+				},
+			]);
+		} finally {
+			await core?.dispose();
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("applies start-session bootstraps before delegating to the host", async () => {
+		const listeners: Array<
+			(event: { type: string; payload: { sessionId: string } }) => void
+		> = [];
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async (input: StartSessionInput) => {
+				expect(input.config.systemPrompt).toBe("Bootstrapped prompt");
+				expect(input.localRuntime?.extensions).toEqual([
+					expect.objectContaining({ name: "enterprise" }),
+				]);
+				return createStartResult("session-1");
+			}),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn((listener) => {
+				listeners.push(listener);
+				return () => {};
+			}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const dispose = vi.fn(async () => {});
+		const applyToStartSessionInput = vi.fn(
+			async (input: ClineCoreStartInput) => ({
+				...input,
+				config: {
+					...input.config,
+					systemPrompt: "Bootstrapped prompt",
+					extensions: [
+						{
+							name: "enterprise",
+							manifest: { capabilities: [] },
+							setup: vi.fn(),
+						},
+					],
+				},
+			}),
+		);
+
+		const core = await ClineCore.create({
+			prepare: async () => ({
+				applyToStartSessionInput,
+				dispose,
+			}),
+		});
+
+		await core.start(createStartInput());
+
+		expect(applyToStartSessionInput).toHaveBeenCalledTimes(1);
+		expect(host.startSession).toHaveBeenCalledTimes(1);
+		expect(dispose).toHaveBeenCalledTimes(1);
+		expect(listeners).toHaveLength(1);
+	});
+
+	it("disposes active session bootstraps when the session ends", async () => {
+		let listener:
+			| ((event: { type: string; payload: { sessionId: string } }) => void)
+			| undefined;
+		const host = {
+			runtimeAddress: "127.0.0.1:5317",
+			startSession: vi.fn(async () => createStartResult("session-2")),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => ({ sessionId: "session-2" })),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn((nextListener) => {
+				listener = nextListener;
+				return () => {};
+			}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const dispose = vi.fn(async () => {});
+		const core = await ClineCore.create({
+			prepare: async () => ({
+				applyToStartSessionInput: (input) => input,
+				dispose,
+			}),
+		});
+		expect(core.runtimeAddress).toBe("127.0.0.1:5317");
+
+		await core.start(createStartInput());
+		expect(dispose).not.toHaveBeenCalled();
+
+		listener?.({ type: "ended", payload: { sessionId: "session-2" } });
+		await Promise.resolve();
+
+		expect(dispose).toHaveBeenCalledTimes(1);
+	});
+
+	it("emits session.started telemetry when a new session is started", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async () => createStartResult("session-telemetry")),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const telemetry = {
+			capture: vi.fn(),
+			captureRequired: vi.fn(),
+			setDistinctId: vi.fn(),
+			setMetadata: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: vi.fn(() => true),
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const core = await ClineCore.create({
+			backendMode: "local",
+			clientName: "unit-test-client",
+			telemetry: telemetry as never,
+		});
+		await core.start(createStartInput());
+
+		expect(telemetry.capture).toHaveBeenCalledWith(
+			expect.objectContaining({
+				event: "session.started",
+				properties: expect.objectContaining({
+					sessionId: "session-telemetry",
+					source: "core",
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-6",
+					enableTools: true,
+					enableSpawnAgent: false,
+					enableAgentTeams: false,
+					clientName: "unit-test-client",
+				}),
+			}),
+		);
+	});
+
+	it("merges instance and per-start runtime capabilities", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async (_input: StartSessionInput) =>
+				createStartResult("session-capabilities"),
+			),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+		const askQuestion = vi.fn(async () => "yes");
+		const submit = vi.fn(async () => "submitted");
+		const requestToolApproval = vi.fn(async () => ({ approved: true }));
+
+		const core = await ClineCore.create({
+			capabilities: {
+				toolExecutors: { askQuestion },
+				requestToolApproval,
+			},
+		});
+
+		await core.start({
+			...createStartInput(),
+			capabilities: {
+				toolExecutors: { submit },
+			},
+		});
+
+		const startInput = vi.mocked(host.startSession).mock.calls.at(-1)?.[0] as
+			| StartSessionInput
+			| undefined;
+		expect(startInput).toBeDefined();
+		if (!startInput) throw new Error("Expected host.startSession to be called");
+		expect(startInput.capabilities?.toolExecutors).toMatchObject({
+			askQuestion,
+			submit,
+		});
+		expect(startInput.capabilities?.requestToolApproval).toBe(
+			requestToolApproval,
+		);
+	});
+
+	it("normalizes config extension context into local runtime before delegating to the host", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async (_input: StartSessionInput) =>
+				createStartResult("session-extension-context"),
+			),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const onTeamRestored = vi.fn();
+		const clientContext = {
+			name: "VSCode Extension",
+			version: "3.27.0",
+			platform: "Visual Studio Code",
+			platformVersion: "1.102.3",
+			isMultiRoot: true,
+		};
+		const core = await ClineCore.create();
+
+		await core.start({
+			...createStartInput(),
+			config: {
+				...createStartInput().config,
+				extensionContext: {
+					client: clientContext,
+				},
+			},
+			localRuntime: {
+				onTeamRestored,
+			},
+		});
+
+		const startInput = vi.mocked(host.startSession).mock.calls.at(-1)?.[0] as
+			| StartSessionInput
+			| undefined;
+		expect(startInput).toBeDefined();
+		if (!startInput) throw new Error("Expected host.startSession to be called");
+		expect(startInput.config).not.toHaveProperty("extensionContext");
+		expect(startInput.localRuntime?.extensionContext?.client).toEqual(
+			clientContext,
+		);
+		expect(startInput.localRuntime?.onTeamRestored).toBe(onTeamRestored);
+	});
+
+	it("prefers the per-session telemetry service over the ClineCore one", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async () => createStartResult("session-override")),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const coreTelemetry = {
+			capture: vi.fn(),
+			setDistinctId: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: vi.fn(() => true),
+		};
+		const sessionTelemetry = {
+			capture: vi.fn(),
+			setDistinctId: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: vi.fn(() => true),
+		};
+
+		const core = await ClineCore.create({
+			backendMode: "local",
+			telemetry: coreTelemetry as never,
+		});
+		const input = createStartInput();
+		input.config.telemetry = sessionTelemetry as never;
+		await core.start(input);
+
+		expect(sessionTelemetry.capture).toHaveBeenCalledWith(
+			expect.objectContaining({ event: "session.started" }),
+		);
+		expect(coreTelemetry.capture).not.toHaveBeenCalled();
+	});
+
+	it("uses a no-op feature flags provider by default", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const core = await ClineCore.create();
+
+		expect(core.featureFlags.getProvider()).toBeInstanceOf(
+			NoOpFeatureFlagsProvider,
+		);
+		await core.dispose();
+		expect(host.dispose).toHaveBeenCalledTimes(1);
+	});
+
+	it("hydrates list rows through the core API", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(async () => [
+				{
+					sessionId: "session-3",
+					source: "cli",
+					pid: 1,
+					startedAt: "2026-04-21T02:17:46.169Z",
+					status: "completed",
+					interactive: false,
+					provider: "",
+					model: "",
+					cwd: "/tmp/workspace",
+					workspaceRoot: "/tmp/workspace",
+					enableTools: true,
+					enableSpawn: false,
+					enableTeams: false,
+					prompt: "hello",
+					metadata: {},
+					updatedAt: "2026-04-21T02:17:46.169Z",
+				},
+			]),
+			deleteSession: vi.fn(),
+			updateSession: vi.fn(),
+			readSessionMessages: vi.fn(async () => [
+				{
+					role: "user",
+					content: [{ type: "text", text: "hello" }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "hi" }],
+					modelInfo: {
+						provider: "cline",
+						id: "anthropic/claude-sonnet-4.6",
+					},
+					metrics: {
+						cost: 0.02,
+					},
+				},
+			]),
+			dispatchHookEvent: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const core = await ClineCore.create();
+		const [row] = await core.list(10);
+
+		expect(host.listSessions).toHaveBeenCalledWith(20);
+		expect(host.readSessionMessages).toHaveBeenCalledWith("session-3");
+		expect(row).toMatchObject({
+			sessionId: "session-3",
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			metadata: {
+				title: "hello",
+				totalCost: 0.02,
+			},
+		});
+	});
+
+	it("can list sessions without hydrating message history", async () => {
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(),
+			runTurn: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(),
+			listSessions: vi.fn(async () => [
+				{
+					sessionId: "session-lightweight",
+					source: "core",
+					pid: 1,
+					startedAt: "2026-04-21T02:17:46.169Z",
+					status: "completed",
+					interactive: false,
+					provider: "cline",
+					model: "anthropic/claude-sonnet-4.6",
+					cwd: "/tmp/workspace",
+					workspaceRoot: "/tmp/workspace",
+					enableTools: true,
+					enableSpawn: false,
+					enableTeams: false,
+					isSubagent: false,
+					metadata: { title: "stored title" },
+					updatedAt: "2026-04-21T02:17:46.169Z",
+				},
+			]),
+			deleteSession: vi.fn(),
+			updateSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			dispatchHookEvent: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const core = await ClineCore.create();
+		const [row] = await core.list(10, { hydrate: false });
+
+		// Hydration and default root-session filtering are consumed by
+		// ClineCore/listSessionHistory; the host list contract only receives the
+		// numeric scan limit.
+		expect(host.listSessions.mock.calls).toEqual([[20]]);
+		expect(host.readSessionMessages).not.toHaveBeenCalled();
+		expect(row).toMatchObject({
+			sessionId: "session-lightweight",
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			metadata: { title: "stored title" },
+		});
+	});
+
+	it("exposes event automation through ClineCore instead of CronService", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-core-automation-"));
+		const cronDir = join(root, ".cline", "cron");
+		const reportsDir = join(cronDir, "reports");
+		const dbPath = join(root, ".cline", "data", "db", "cron.db");
+		mkdirSync(join(cronDir, "events"), { recursive: true });
+		writeFileSync(
+			join(cronDir, "events", "local.event.md"),
+			`---
+id: local-test
+title: Local Test
+workspaceRoot: ${root}
+event: local.manual_test
+filters:
+  topic: cron-feature-2
+---
+Summarize the local event.
+`,
+			"utf8",
+		);
+
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async () => createStartResult("automation-session")),
+			runTurn: vi.fn(async () => createAgentResult("automation complete")),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(async () => undefined),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			updateSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			dispatchHookEvent: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		try {
+			const core = await ClineCore.create({
+				automation: {
+					cronDir,
+					reportsDir,
+					dbPath,
+					autoStart: false,
+					pollIntervalMs: 10_000,
+				},
+			});
+			await core.automation.reconcileNow();
+			const result = core.automation.ingestEvent({
+				eventId: "evt_local_1",
+				eventType: "local.manual_test",
+				source: "local",
+				subject: "manual smoke test",
+				occurredAt: "2026-04-24T10:00:00.000Z",
+				attributes: { topic: "cron-feature-2" },
+			});
+
+			expect(result.matchedSpecIds).toHaveLength(1);
+			expect(result.queuedRuns).toHaveLength(1);
+
+			await core.automation.start();
+			await core.automation.stop();
+			await core.dispose();
+
+			expect(host.startSession).toHaveBeenCalledTimes(1);
+			expect(host.runTurn).toHaveBeenCalledWith(
+				expect.objectContaining({
+					sessionId: "automation-session",
+					prompt: expect.stringContaining("Trigger event:"),
+				}),
+			);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("delegates restore to the runtime host", async () => {
+		const restoreResult = {
+			sessionId: "restored-session",
+			startResult: createStartResult("restored-session"),
+			messages: [
+				{ role: "user" as const, content: "first" },
+				{ role: "assistant" as const, content: "first response" },
+				{ role: "user" as const, content: "second" },
+			],
+			checkpoint: {
+				ref: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+				createdAt: 2,
+				runCount: 2,
+				kind: "commit" as const,
+			},
+		};
+		const host = {
+			runtimeAddress: undefined,
+			startSession: vi.fn(async () => createStartResult("restored-session")),
+			runTurn: vi.fn(),
+			restoreSession: vi.fn(async () => restoreResult),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(),
+			listSessions: vi.fn(),
+			deleteSession: vi.fn(),
+			updateSession: vi.fn(),
+			readSessionMessages: vi.fn(),
+			dispatchHookEvent: vi.fn(),
+			subscribe: vi.fn(() => () => {}),
+			updateSessionModel: vi.fn(),
+		};
+		createRuntimeHostMock.mockResolvedValue(host);
+
+		const core = await ClineCore.create();
+		const result = await core.restore({
+			sessionId: "source-session",
+			checkpointRunCount: 2,
+			restore: {
+				messages: true,
+				workspace: false,
+				omitCheckpointMessageFromSession: true,
+			},
+			start: createStartInput(),
+		});
+
+		expect(host.restoreSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				sessionId: "source-session",
+				checkpointRunCount: 2,
+				restore: {
+					messages: true,
+					workspace: false,
+					omitCheckpointMessageFromSession: true,
+				},
+				start: expect.objectContaining({
+					config: expect.objectContaining({
+						providerId: "anthropic",
+						modelId: "claude-sonnet-4-6",
+					}),
+				}),
+			}),
+		);
+		expect(result.messages).toEqual(restoreResult.messages);
+		expect(result.sessionId).toBe("restored-session");
+	});
+});
diff --git a/sdk/packages/core/src/ClineCore.ts b/sdk/packages/core/src/ClineCore.ts
new file mode 100644
index 0000000..4557721
--- /dev/null
+++ b/sdk/packages/core/src/ClineCore.ts
@@ -0,0 +1,633 @@
+import type { BasicLogger, ITelemetryService } from "@cline/shared";
+import {
+	ClineCoreAutomationController,
+	createClineCoreAutomationExtensionContext,
+	createClineCoreAutomationRuntimeHandlers,
+	normalizeAutomationCronScope,
+	normalizeAutomationOptions,
+} from "./cline-core/automation";
+import {
+	createClineCorePendingPromptsApi,
+	createClineCoreSettingsApi,
+	type RuntimeHostServiceExtensions,
+} from "./cline-core/runtime-services";
+import {
+	normalizeClineCoreStartInput,
+	toClineCoreStartInput,
+} from "./cline-core/start-input";
+import { emitSessionStartedTelemetry } from "./cline-core/telemetry";
+import type {
+	ClineCoreAutomationApi,
+	ClineCoreAutomationOptions,
+	ClineCoreListHistoryOptions,
+	ClineCoreOptions,
+	ClineCoreSettingsApi,
+	ClineCoreStartInput,
+	CompareCheckpointInput,
+	CompareCheckpointResult,
+	RestoreInput,
+	RestoreResult,
+	StartSessionBootstrap,
+} from "./cline-core/types";
+
+import { CronService } from "./cron/service/cron-service";
+import type { RuntimeCapabilities } from "./runtime/capabilities";
+import { normalizeRuntimeCapabilities } from "./runtime/capabilities";
+import { listSessionHistory } from "./runtime/host/history";
+import { createRuntimeHost } from "./runtime/host/host";
+import type {
+	PendingPromptsServiceApi,
+	RuntimeHost,
+	RuntimeHostSubscribeOptions,
+	SessionConnectionRuntimeService,
+	SessionModelRuntimeService,
+	SessionUsageRuntimeService,
+	StartSessionInput,
+	StartSessionResult,
+} from "./runtime/host/runtime-host";
+import {
+	FeatureFlagsService,
+	NoOpFeatureFlagsProvider,
+} from "./services/feature-flags";
+import { resolveCoreDistinctId } from "./services/telemetry/distinct-id";
+import { compareCheckpointToWorkspace } from "./session/checkpoint-diff";
+import type { CoreSessionEvent } from "./types/events";
+import type { SessionHistoryRecord } from "./types/sessions";
+
+export type {
+	ClineAutomationEventIngressResult,
+	ClineAutomationEventLog,
+	ClineAutomationEventSuppression,
+	ClineAutomationListEventsOptions,
+	ClineAutomationListRunsOptions,
+	ClineAutomationListSpecsOptions,
+	ClineAutomationRun,
+	ClineAutomationRunStatus,
+	ClineAutomationSpec,
+	ClineCoreAutomationApi,
+	ClineCoreAutomationOptions,
+	ClineCoreListHistoryOptions,
+	ClineCoreOptions,
+	ClineCoreSettingsApi,
+	ClineCoreStartInput,
+	CompareCheckpointInput,
+	CompareCheckpointResult,
+	HubOptions,
+	RemoteOptions,
+	RestoreInput,
+	RestoreOptions,
+	RestoreResult,
+	RuntimeHostMode,
+	StartSessionBootstrap,
+} from "./cline-core/types";
+
+/**
+ * The primary entry point for the Cline Core SDK.
+ *
+ * @example
+ * ```ts
+ * import { ClineCore } from "@cline/core";
+ *
+ * const cline = await ClineCore.create({ clientName: "my-app" });
+ * const session = await cline.start({ ... });
+ * ```
+ */
+export class ClineCore {
+	readonly clientName: string | undefined;
+	readonly runtimeAddress: string | undefined;
+	readonly automation: ClineCoreAutomationApi;
+	readonly settings: ClineCoreSettingsApi;
+	readonly featureFlags: FeatureFlagsService;
+	readonly pendingPrompts: PendingPromptsServiceApi;
+	private readonly host: RuntimeHost;
+	private readonly prepare: ClineCoreOptions["prepare"] | undefined;
+	private readonly capabilities: RuntimeCapabilities | undefined;
+	private readonly logger: BasicLogger | undefined;
+	private readonly telemetry: ITelemetryService | undefined;
+	private readonly distinctId: string | undefined;
+	private readonly automationService: CronService | undefined;
+	private readonly activeSessionBootstraps = new Map<
+		string,
+		StartSessionBootstrap
+	>();
+	private readonly unsubscribeBootstrapCleanup: () => void;
+
+	private constructor(
+		host: RuntimeHost,
+		clientName: string | undefined,
+		runtimeAddress: string | undefined,
+		prepare: ClineCoreOptions["prepare"],
+		capabilities: RuntimeCapabilities | undefined,
+		logger: BasicLogger | undefined,
+		telemetry: ITelemetryService | undefined,
+		distinctId: string | undefined,
+		featureFlags: FeatureFlagsService,
+		automationOptions:
+			| (ClineCoreAutomationOptions & { logger?: BasicLogger })
+			| undefined,
+	) {
+		this.clientName = clientName;
+		this.runtimeAddress = runtimeAddress;
+		this.host = host;
+		this.prepare = prepare;
+		this.capabilities = capabilities;
+		this.logger = logger;
+		this.telemetry = telemetry;
+		this.distinctId = distinctId;
+		this.featureFlags = featureFlags;
+		this.settings = createClineCoreSettingsApi(host);
+		this.pendingPrompts = createClineCorePendingPromptsApi(host);
+		this.automation = new ClineCoreAutomationController(() => {
+			if (!this.automationService) {
+				throw new Error(
+					"ClineCore automation is not enabled. Pass `automation: true` or automation options to ClineCore.create().",
+				);
+			}
+			return this.automationService;
+		});
+		this.automationService = automationOptions
+			? new CronService({
+					workspaceRoot: automationOptions.workspaceRoot ?? process.cwd(),
+					specs: {
+						cronSpecsDir:
+							automationOptions.cronSpecsDir ?? automationOptions.cronDir,
+						scope: normalizeAutomationCronScope(automationOptions.cronScope),
+						workspaceRoot: automationOptions.workspaceRoot,
+					},
+					runtimeHandlers: createClineCoreAutomationRuntimeHandlers({
+						host,
+						getExtensionContext: () =>
+							createClineCoreAutomationExtensionContext({
+								automationService: this.automationService,
+								automation: this.automation,
+								clientName: this.clientName,
+								distinctId: this.distinctId,
+								logger: this.logger,
+								telemetry: this.telemetry,
+							}),
+					}),
+					dbPath: automationOptions.dbPath,
+					logger: automationOptions.logger,
+					pollIntervalMs: automationOptions.pollIntervalMs,
+					claimLeaseSeconds: automationOptions.claimLeaseSeconds,
+					globalMaxConcurrency: automationOptions.globalMaxConcurrency,
+					watcherDebounceMs: automationOptions.watcherDebounceMs,
+				})
+			: undefined;
+		this.unsubscribeBootstrapCleanup = this.host.subscribe((event) => {
+			if (event.type !== "ended") {
+				return;
+			}
+			void this.disposeSessionBootstrap(event.payload.sessionId);
+		});
+	}
+
+	/**
+	 * Creates a new ClineCore instance.
+	 *
+	 * This is the primary factory method for initializing the SDK. It sets up the runtime
+	 * host (local, hub, or remote) based on the provided options and prepares the SDK for
+	 * starting sessions.
+	 *
+	 * @param options Configuration options for the SDK instance
+	 * @returns A promise that resolves to a new ClineCore instance
+	 *
+	 * @example
+	 * ```ts
+	 * const cline = await ClineCore.create({
+	 *   clientName: "my-app",
+	 *   backendMode: "local",
+	 * });
+	 * ```
+	 */
+	static async create(options: ClineCoreOptions = {}): Promise<ClineCore> {
+		const distinctId = resolveCoreDistinctId(options.distinctId);
+		const capabilities = normalizeRuntimeCapabilities(options.capabilities);
+		const normalizedOptions = { ...options, capabilities, distinctId };
+		const host = await createRuntimeHost(normalizedOptions);
+		const automationOptions = normalizeAutomationOptions(options.automation);
+		const featureFlags =
+			options.featureFlags ||
+			new FeatureFlagsService({
+				provider: new NoOpFeatureFlagsProvider(),
+				telemetry: options.telemetry,
+				logger: options.logger,
+				context: {
+					distinctId,
+					clientName: options.clientName,
+				},
+			});
+		const core = new ClineCore(
+			host,
+			options.clientName,
+			host.runtimeAddress,
+			options.prepare,
+			capabilities,
+			options.logger,
+			options.telemetry,
+			distinctId,
+			featureFlags,
+			automationOptions
+				? { ...automationOptions, logger: options.logger }
+				: undefined,
+		);
+		if (automationOptions && automationOptions.autoStart !== false) {
+			await core.automation.start();
+		}
+		return core;
+	}
+
+	private async disposeSessionBootstrap(sessionId: string): Promise<void> {
+		const bootstrap = this.activeSessionBootstraps.get(sessionId);
+		if (!bootstrap) {
+			return;
+		}
+		this.activeSessionBootstraps.delete(sessionId);
+		await Promise.resolve(bootstrap.dispose?.());
+	}
+
+	/**
+	 * Starts a new Cline session with the provided configuration.
+	 *
+	 * This method initializes and begins a new agent session. It handles session setup,
+	 * runs any preparation hooks, and returns session metadata along with event streams.
+	 * The session continues to run until explicitly stopped or aborted.
+	 *
+	 * @param input The session configuration and startup parameters
+	 * @returns A promise that resolves to session metadata and event stream
+	 *
+	 * @example
+	 * ```ts
+	 * const result = await cline.start({
+	 *   config: {
+	 *     providerId: "anthropic",
+	 *     modelId: "claude-opus-4-1",
+	 *   },
+	 * });
+	 *
+	 * // Subscribe to session events
+	 * result.subscribe((event) => {
+	 *   console.log("Session event:", event);
+	 * });
+	 * ```
+	 */
+	start(input: StartSessionInput): Promise<StartSessionResult>;
+	/**
+	 * Starts a new Cline session with extended core-specific configuration.
+	 * This overload allows specifying local runtime options and config overrides.
+	 */
+	start(input: ClineCoreStartInput): Promise<StartSessionResult>;
+	async start(
+		input: StartSessionInput | ClineCoreStartInput,
+	): Promise<StartSessionResult> {
+		const clineCoreInput = toClineCoreStartInput(input);
+		const bootstrap = await this.prepare?.(clineCoreInput);
+		try {
+			const preparedInput = bootstrap
+				? await bootstrap.applyToStartSessionInput(clineCoreInput)
+				: clineCoreInput;
+			const result = await this.host.startSession(
+				normalizeClineCoreStartInput(preparedInput, {
+					defaultCapabilities: this.capabilities,
+					withExtensionContext: (context) =>
+						createClineCoreAutomationExtensionContext({
+							automationService: this.automationService,
+							automation: this.automation,
+							context,
+							clientName: this.clientName,
+							distinctId: this.distinctId,
+							logger: this.logger,
+							telemetry: this.telemetry,
+						}),
+				}),
+			);
+			if (bootstrap) {
+				const activeSession = await this.host.getSession(result.sessionId);
+				if (activeSession) {
+					this.activeSessionBootstraps.set(result.sessionId, bootstrap);
+				} else {
+					await Promise.resolve(bootstrap.dispose?.());
+				}
+			}
+			emitSessionStartedTelemetry({
+				input: preparedInput,
+				sessionId: result.sessionId,
+				telemetry: this.telemetry,
+				clientName: this.clientName,
+				runtimeAddress: this.runtimeAddress,
+			});
+			return result;
+		} catch (error) {
+			await Promise.resolve(bootstrap?.dispose?.());
+			throw error;
+		}
+	}
+	/**
+	 * Sends a message or command to an active session.
+	 *
+	 * This method communicates with a running session, allowing you to send user messages,
+	 * tool responses, or other session input while the session is in progress.
+	 *
+	 * @example
+	 * ```ts
+	 * await cline.send(sessionId, {
+	 *   type: "user_message",
+	 *   text: "Please implement the login feature",
+	 * });
+	 * ```
+	 */
+	send: RuntimeHost["runTurn"] = (...args) => this.host.runTurn(...args);
+	/**
+	 * Retrieves accumulated token and cost usage for a session.
+	 *
+	 * Returns metrics about the session's resource consumption, including tokens used
+	 * across different API providers and associated costs. The `usage` field is
+	 * root/lead-agent usage; `aggregateUsage` includes teammates and subagents.
+	 *
+	 * @example
+	 * ```ts
+	 * const usageSummary = await cline.getAccumulatedUsage(sessionId);
+	 * console.log(`Total cost: $${usageSummary?.aggregateUsage?.totalCost}`);
+	 * ```
+	 */
+	getAccumulatedUsage: SessionUsageRuntimeService["getAccumulatedUsage"] = (
+		...args
+	) => {
+		const service = this.host as RuntimeHostServiceExtensions;
+		return service.getAccumulatedUsage?.(...args) ?? Promise.resolve(undefined);
+	};
+	/**
+	 * Aborts an in-flight tool execution without stopping the session.
+	 *
+	 * Interrupts the current tool operation (e.g., file read, shell command) while keeping
+	 * the session alive. The session can continue processing after the abort. Use this for
+	 * cancelling long-running operations.
+	 *
+	 * @example
+	 * ```ts
+	 * // Stop the current operation but keep the session running
+	 * await cline.abort(sessionId);
+	 * ```
+	 */
+	abort: RuntimeHost["abort"] = (...args) => this.host.abort(...args);
+	/**
+	 * Stops an active session gracefully.
+	 *
+	 * Terminates the session and cleans up associated resources. Unlike abort, this
+	 * completely ends the session. The session cannot be resumed after stopping.
+	 *
+	 * @example
+	 * ```ts
+	 * // Cleanly shutdown the session
+	 * await cline.stop(sessionId);
+	 * ```
+	 */
+	stop: RuntimeHost["stopSession"] = async (sessionId) => {
+		await this.host.stopSession(sessionId);
+		await this.disposeSessionBootstrap(sessionId);
+	};
+	/**
+	 * Disposes the ClineCore instance and all associated resources.
+	 *
+	 * Shuts down the runtime host, closes connections, and cleans up all active sessions
+	 * and bootstraps. Call this when you're done using the SDK instance, typically at
+	 * application shutdown. After calling dispose, the instance cannot be reused.
+	 *
+	 * @example
+	 * ```ts
+	 * // Clean up when done
+	 * await cline.dispose();
+	 * ```
+	 */
+	dispose: RuntimeHost["dispose"] = async (...args) => {
+		try {
+			await this.automationService?.dispose();
+			await this.host.dispose(...args);
+		} finally {
+			this.unsubscribeBootstrapCleanup();
+			const sessionIds = [...this.activeSessionBootstraps.keys()];
+			await Promise.allSettled(
+				sessionIds.map((sessionId) => this.disposeSessionBootstrap(sessionId)),
+			);
+		}
+	};
+	/**
+	 * Retrieves information about a specific session by ID.
+	 *
+	 * Fetches the current metadata and state of a session, including configuration,
+	 * status, and other session details.
+	 *
+	 * @example
+	 * ```ts
+	 * const session = await cline.get(sessionId);
+	 * console.log("Session status:", session?.status);
+	 * ```
+	 */
+	get: RuntimeHost["getSession"] = (...args) => this.host.getSession(...args);
+	/**
+	 * Lists recent sessions through the shared history-listing path.
+	 */
+	listHistory = async (
+		options: ClineCoreListHistoryOptions = {},
+	): Promise<SessionHistoryRecord[]> =>
+		await listSessionHistory(this.host, options);
+	/**
+	 * Lists recent sessions with inferred history display metadata.
+	 *
+	 * Retrieves a paginated list of recent sessions, optionally limited by the
+	 * provided count.
+	 *
+	 * @param limit Maximum number of sessions to return (defaults to 200)
+	 * @returns A promise resolving to an array of session history records
+	 *
+	 * @example
+	 * ```ts
+	 * const sessions = await cline.list(50);
+	 * sessions.forEach((session) => {
+	 *   console.log(`Session ${session.sessionId}: ${session.metadata?.title}`);
+	 * });
+	 * ```
+	 */
+	list = async (
+		limit = 200,
+		options: Omit<ClineCoreListHistoryOptions, "limit"> = {},
+	): Promise<SessionHistoryRecord[]> =>
+		await this.listHistory({ ...options, limit });
+	/**
+	 * Permanently deletes a session and all its associated data.
+	 *
+	 * Removes the session from storage and cleans up any related resources. This is
+	 * a destructive operation that cannot be undone.
+	 *
+	 * @param sessionId The ID of the session to delete
+	 * @returns A promise that resolves to true if the session was deleted, false if not found
+	 *
+	 * @example
+	 * ```ts
+	 * const deleted = await cline.delete(sessionId);
+	 * if (deleted) {
+	 *   console.log("Session deleted successfully");
+	 * }
+	 * ```
+	 */
+	delete: RuntimeHost["deleteSession"] = async (sessionId) => {
+		const deleted = await this.host.deleteSession(sessionId);
+		if (deleted) {
+			await this.disposeSessionBootstrap(sessionId);
+		}
+		return deleted;
+	};
+	/**
+	 * Updates an existing session's metadata.
+	 *
+	 * Modifies session properties like title or other mutable metadata while preserving
+	 * message history and other session data.
+	 *
+	 * @example
+	 * ```ts
+	 * await cline.update(sessionId, {
+	 *   title: "Updated session title",
+	 * });
+	 * ```
+	 */
+	update: RuntimeHost["updateSession"] = (...args) =>
+		this.host.updateSession(...args);
+	/**
+	 * Stores the compacted working-context state for an existing session.
+	 */
+	updateSessionCompactionState: RuntimeHost["updateSessionCompactionState"] = (
+		...args
+	) => this.host.updateSessionCompactionState(...args);
+	/**
+	 * Reads the compacted working-context sidecar for a session, if one exists.
+	 */
+	readSessionCompactionState: RuntimeHost["readSessionCompactionState"] = (
+		...args
+	) => this.host.readSessionCompactionState(...args);
+	/**
+	 * Reads message history for a session.
+	 *
+	 * Retrieves the full message transcript for a specific session, including all
+	 * user messages, agent responses, and tool interactions.
+	 *
+	 * @example
+	 * ```ts
+	 * const messages = await cline.readMessages(sessionId);
+	 * messages.forEach((msg) => {
+	 *   console.log(`${msg.role}: ${msg.content}`);
+	 * });
+	 * ```
+	 */
+	readMessages: RuntimeHost["readSessionMessages"] = (...args) =>
+		this.host.readSessionMessages(...args);
+
+	async restore(input: RestoreInput): Promise<RestoreResult> {
+		const normalizedStart = input.start
+			? normalizeClineCoreStartInput(input.start, {
+					defaultCapabilities: this.capabilities,
+					withExtensionContext: (context) =>
+						createClineCoreAutomationExtensionContext({
+							automationService: this.automationService,
+							automation: this.automation,
+							context,
+							clientName: this.clientName,
+							distinctId: this.distinctId,
+							logger: this.logger,
+							telemetry: this.telemetry,
+						}),
+				})
+			: undefined;
+		return this.host.restoreSession({
+			sessionId: input.sessionId,
+			checkpointRunCount: input.checkpointRunCount,
+			cwd: input.cwd,
+			restore: input.restore,
+			start: normalizedStart,
+		});
+	}
+
+	async compareCheckpoint(
+		input: CompareCheckpointInput,
+	): Promise<CompareCheckpointResult> {
+		const sessionId = input.sessionId.trim();
+		if (!sessionId) {
+			throw new Error("sessionId is required");
+		}
+		const session = await this.host.getSession(sessionId);
+		if (!session) {
+			throw new Error(`Session ${sessionId} not found`);
+		}
+		return compareCheckpointToWorkspace({
+			session,
+			checkpointRunCount: input.checkpointRunCount,
+			cwd: input.cwd,
+		});
+	}
+
+	/**
+	 * Handles hook events from the runtime environment.
+	 *
+	 * Processes system or environment events (e.g., workspace changes, external signals)
+	 * that may affect the current session. This is typically called by the host environment
+	 * rather than directly by consumer code.
+	 *
+	 * @internal
+	 */
+	ingestHookEvent: RuntimeHost["dispatchHookEvent"] = (...args) =>
+		this.host.dispatchHookEvent(...args);
+	/**
+	 * Subscribes to session events.
+	 *
+	 * Registers a listener for all session events (messages, state changes, errors, etc.).
+	 * Returns an unsubscribe function to stop listening.
+	 *
+	 * @param listener Callback function invoked for each event
+	 * @param options Optional configuration for the subscription
+	 * @returns An unsubscribe function
+	 *
+	 * @example
+	 * ```ts
+	 * const unsubscribe = cline.subscribe((event) => {
+	 *   if (event.type === "message") {
+	 *     console.log("New message:", event.payload.message);
+	 *   }
+	 * });
+	 *
+	 * // Later, stop listening
+	 * unsubscribe();
+	 * ```
+	 */
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		return this.host.subscribe(listener, options);
+	}
+	/**
+	 * Updates the AI model used by an active session.
+	 *
+	 * Switches the session to use a different AI model while maintaining the session state
+	 * and message history. This allows you to continue a conversation with a different model.
+	 *
+	 * @example
+	 * ```ts
+	 * // Switch to a different model mid-session
+	 * await cline.updateSessionModel(sessionId, "claude-opus-4-1");
+	 * ```
+	 */
+	updateSessionModel: SessionModelRuntimeService["updateSessionModel"] = (
+		...args
+	) => {
+		const service = this.host as RuntimeHostServiceExtensions;
+		return service.updateSessionModel?.(...args) ?? Promise.resolve();
+	};
+	/**
+	 * Updates provider/model/reasoning connection options for subsequent turns in
+	 * an active session.
+	 */
+	updateSessionConnection: SessionConnectionRuntimeService["updateSessionConnection"] =
+		(...args) => {
+			const service = this.host as RuntimeHostServiceExtensions;
+			return service.updateSessionConnection?.(...args) ?? Promise.resolve();
+		};
+}
diff --git a/sdk/packages/core/src/account/cline-account-service.test.ts b/sdk/packages/core/src/account/cline-account-service.test.ts
new file mode 100644
index 0000000..c8c4706
--- /dev/null
+++ b/sdk/packages/core/src/account/cline-account-service.test.ts
@@ -0,0 +1,284 @@
+import { describe, expect, it, vi } from "vitest";
+import { ClineAccountService } from "./cline-account-service";
+
+describe("ClineAccountService", () => {
+	it("fetches current user balance and sends auth header", async () => {
+		const fetchImpl = vi.fn(async (input: unknown, init?: RequestInit) => {
+			expect(String(input)).toBe(
+				"https://api.cline.bot/api/v1/users/user-1/balance",
+			);
+			expect(init?.headers).toMatchObject({
+				Authorization: "Bearer workos:token-123",
+			});
+			return new Response(
+				JSON.stringify({
+					success: true,
+					data: { balance: 5, userId: "user-1" },
+				}),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			getCurrentUserId: () => "user-1",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const balance = await service.fetchBalance();
+		expect(balance).toEqual({ balance: 5, userId: "user-1" });
+	});
+
+	it("resolves organization member id from /users/me when not provided", async () => {
+		const fetchImpl = vi
+			.fn()
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						success: true,
+						data: {
+							id: "u-1",
+							email: "u@example.com",
+							displayName: "User",
+							photoUrl: "",
+							createdAt: "2025-01-01T00:00:00Z",
+							updatedAt: "2025-01-01T00:00:00Z",
+							organizations: [
+								{
+									active: true,
+									memberId: "member-9",
+									name: "Org",
+									organizationId: "org-1",
+									roles: ["member"],
+								},
+							],
+						},
+					}),
+					{ status: 200 },
+				),
+			)
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({ success: true, data: { items: [{ id: "tx-1" }] } }),
+					{ status: 200 },
+				),
+			);
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const transactions = await service.fetchOrganizationUsageTransactions({
+			organizationId: "org-1",
+		});
+
+		expect(fetchImpl).toHaveBeenCalledTimes(2);
+		expect(String(fetchImpl.mock.calls[1][0])).toBe(
+			"https://api.cline.bot/api/v1/organizations/org-1/members/member-9/usages",
+		);
+		expect(transactions).toEqual([{ id: "tx-1" }]);
+	});
+
+	it("fetches remote config with organizations list", async () => {
+		const remoteConfigPayload = {
+			organizationId: "org-1",
+			value: '{"model":"claude-4"}',
+			enabled: true,
+			organizations: [
+				{ organizationId: "org-1", name: "Acme Corp" },
+				{ organizationId: "org-2", name: "Beta Inc" },
+			],
+		};
+
+		const fetchImpl = vi.fn(async (input: unknown) => {
+			expect(String(input)).toBe(
+				"https://api.cline.bot/api/v1/users/me/remote-config",
+			);
+			return new Response(
+				JSON.stringify({ success: true, data: remoteConfigPayload }),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const config = await service.fetchRemoteConfig();
+		expect(config).toEqual(remoteConfigPayload);
+		expect(config?.organizations).toHaveLength(2);
+		expect(config?.organizations?.[0]).toEqual({
+			organizationId: "org-1",
+			name: "Acme Corp",
+		});
+	});
+
+	it("fetches available individual subscription plans with auth header", async () => {
+		const plansPayload = [
+			{
+				id: "plan-1",
+				displayName: "ClinePass Monthly",
+				interval: "Monthly",
+				features: { included: ["Major open-weights models"] },
+			},
+		];
+		const fetchImpl = vi.fn(async (input: unknown, init?: RequestInit) => {
+			expect(String(input)).toBe(
+				"https://api.cline.bot/api/v1/plans?type=individual",
+			);
+			expect(init?.headers).toMatchObject({
+				Authorization: "Bearer workos:token-123",
+			});
+			return new Response(
+				JSON.stringify({ success: true, data: plansPayload }),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const plans = await service.fetchAvailableSubscriptionPlans({
+			type: "individual",
+		});
+
+		expect(plans).toEqual(plansPayload);
+	});
+
+	it("fetches the current user's subscription plan", async () => {
+		const planPayload = {
+			plan: {
+				id: "plan-1",
+				displayName: "ClinePass Monthly",
+				interval: "Monthly",
+			},
+			planHistoryId: "history-1",
+			subscriptionId: "sub-1",
+			userId: "user-1",
+		};
+		const fetchImpl = vi.fn(async (input: unknown, init?: RequestInit) => {
+			expect(String(input)).toBe("https://api.cline.bot/api/v1/users/me/plan");
+			expect(init?.headers).toMatchObject({
+				Authorization: "Bearer workos:token-123",
+			});
+			return new Response(
+				JSON.stringify({ success: true, data: planPayload }),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const plan = await service.fetchCurrentUserPlan();
+		expect(plan).toEqual(planPayload);
+	});
+
+	it("fetches remote config with fallback org selected", async () => {
+		const remoteConfigPayload = {
+			organizationId: "org-fallback",
+			value: '{"model":"claude-4"}',
+			enabled: true,
+			organizations: [{ organizationId: "org-fallback", name: "Fallback Org" }],
+		};
+
+		const fetchImpl = vi.fn(async () => {
+			return new Response(
+				JSON.stringify({ success: true, data: remoteConfigPayload }),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const config = await service.fetchRemoteConfig();
+		expect(config?.organizationId).toBe("org-fallback");
+		expect(config?.organizations).toHaveLength(1);
+		expect(config?.organizations?.[0]).toEqual({
+			organizationId: "org-fallback",
+			name: "Fallback Org",
+		});
+	});
+
+	it("returns null when no org has remote config (data: null)", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response(JSON.stringify({ success: true, data: null }), {
+				status: 200,
+				headers: { "Content-Type": "application/json" },
+			});
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const config = await service.fetchRemoteConfig();
+		expect(config).toBeNull();
+	});
+
+	it("surfaces plain text request failures without JSON parse errors", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response("Authentication failed", { status: 401 });
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		await expect(service.fetchMe()).rejects.toThrow(
+			"Cline account request failed with status 401: Authentication failed",
+		);
+	});
+
+	it("surfaces invalid success payloads without JSON parse internals", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response("Account service unavailable", { status: 200 });
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		await expect(service.fetchMe()).rejects.toThrow(
+			"Cline account response was not valid JSON",
+		);
+	});
+
+	it("switchAccount sends null org id for personal account", async () => {
+		const fetchImpl = vi.fn(async (_input: unknown, init?: RequestInit) => {
+			expect(init?.method).toBe("PUT");
+			expect(init?.body).toBe(JSON.stringify({ organizationId: null }));
+			return new Response(null, { status: 204 });
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		await service.switchAccount(undefined);
+		expect(fetchImpl).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/sdk/packages/core/src/account/cline-account-service.ts b/sdk/packages/core/src/account/cline-account-service.ts
new file mode 100644
index 0000000..8df8997
--- /dev/null
+++ b/sdk/packages/core/src/account/cline-account-service.ts
@@ -0,0 +1,354 @@
+import type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+	ClineOrganization,
+	ClineSubscriptionPlan,
+	FeaturebaseTokenResponse,
+	UserCurrentPlan,
+	UserRemoteConfigResponse,
+} from "./types";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+interface ClineApiEnvelope<T> {
+	success?: boolean;
+	error?: string;
+	data?: T;
+}
+
+function getClineApiEnvelopeError(parsed: unknown): string | undefined {
+	if (typeof parsed !== "object" || parsed === null || !("error" in parsed)) {
+		return undefined;
+	}
+	const error = parsed.error;
+	return typeof error === "string" && error.trim() ? error : undefined;
+}
+
+function formatClineAccountRequestFailure(
+	status: number,
+	bodyText: string,
+	parsed: unknown,
+): string {
+	const envelopeError = getClineApiEnvelopeError(parsed);
+	if (envelopeError) {
+		return envelopeError;
+	}
+
+	const body = bodyText.trim();
+	if (body) {
+		const preview = body.length > 200 ? `${body.slice(0, 200)}...` : body;
+		return `Cline account request failed with status ${status}: ${preview}`;
+	}
+
+	return `Cline account request failed with status ${status}`;
+}
+
+export interface ClineAccountServiceOptions {
+	apiBaseUrl: string;
+	getAuthToken: () => Promise<string | undefined | null>;
+	getCurrentUserId?: () =>
+		| Promise<string | undefined | null>
+		| string
+		| undefined
+		| null;
+	getOrganizationMemberId?: (
+		organizationId: string,
+	) => Promise<string | undefined | null> | string | undefined | null;
+	getHeaders?: () =>
+		| Promise<Record<string, string> | undefined>
+		| Record<string, string>
+		| undefined;
+	requestTimeoutMs?: number;
+	fetchImpl?: typeof fetch;
+}
+
+export class ClineAccountService {
+	private readonly apiBaseUrl: string;
+	private readonly getAuthTokenFn: ClineAccountServiceOptions["getAuthToken"];
+	private readonly getCurrentUserIdFn: ClineAccountServiceOptions["getCurrentUserId"];
+	private readonly getOrganizationMemberIdFn: ClineAccountServiceOptions["getOrganizationMemberId"];
+	private readonly getHeadersFn: ClineAccountServiceOptions["getHeaders"];
+	private readonly requestTimeoutMs: number;
+	private readonly fetchImpl: typeof fetch;
+
+	constructor(options: ClineAccountServiceOptions) {
+		const apiBaseUrl = options.apiBaseUrl.trim();
+		if (!apiBaseUrl) {
+			throw new Error("apiBaseUrl is required");
+		}
+
+		this.apiBaseUrl = apiBaseUrl;
+		this.getAuthTokenFn = options.getAuthToken;
+		this.getCurrentUserIdFn = options.getCurrentUserId;
+		this.getOrganizationMemberIdFn = options.getOrganizationMemberId;
+		this.getHeadersFn = options.getHeaders;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+
+	public async fetchMe(): Promise<ClineAccountUser> {
+		return this.request<ClineAccountUser>("/api/v1/users/me");
+	}
+
+	public async fetchRemoteConfig(): Promise<UserRemoteConfigResponse | null> {
+		return this.request<UserRemoteConfigResponse | null>(
+			"/api/v1/users/me/remote-config",
+		);
+	}
+
+	public async fetchFeaturebaseToken(): Promise<
+		FeaturebaseTokenResponse | undefined
+	> {
+		try {
+			return await this.request<FeaturebaseTokenResponse>(
+				"/api/v1/users/me/featurebase-token",
+			);
+		} catch {
+			return undefined;
+		}
+	}
+
+	public async fetchBalance(userId?: string): Promise<ClineAccountBalance> {
+		const resolvedUserId = await this.resolveUserId(userId);
+		return this.request<ClineAccountBalance>(
+			`/api/v1/users/${encodeURIComponent(resolvedUserId)}/balance`,
+		);
+	}
+
+	public async fetchUsageTransactions(
+		userId?: string,
+	): Promise<ClineAccountUsageTransaction[]> {
+		const resolvedUserId = await this.resolveUserId(userId);
+		const response = await this.request<{
+			items: ClineAccountUsageTransaction[];
+		}>(`/api/v1/users/${encodeURIComponent(resolvedUserId)}/usages`);
+		return response.items ?? [];
+	}
+
+	public async fetchPaymentTransactions(
+		userId?: string,
+	): Promise<ClineAccountPaymentTransaction[]> {
+		const resolvedUserId = await this.resolveUserId(userId);
+		const response = await this.request<{
+			paymentTransactions: ClineAccountPaymentTransaction[];
+		}>(`/api/v1/users/${encodeURIComponent(resolvedUserId)}/payments`);
+		return response.paymentTransactions ?? [];
+	}
+
+	public async fetchUserOrganizations(): Promise<ClineAccountOrganization[]> {
+		const me = await this.fetchMe();
+		return me.organizations ?? [];
+	}
+
+	public async fetchAvailableSubscriptionPlans(input?: {
+		type?: "individual" | "teams";
+	}): Promise<ClineSubscriptionPlan[]> {
+		const path = new URL("/api/v1/plans", this.apiBaseUrl);
+		if (input?.type) {
+			path.searchParams.set("type", input.type);
+		}
+		return this.request<ClineSubscriptionPlan[]>(
+			`${path.pathname}${path.search}`,
+		);
+	}
+
+	public async fetchCurrentUserPlan(): Promise<UserCurrentPlan | undefined> {
+		return this.request<UserCurrentPlan | undefined>("/api/v1/users/me/plan");
+	}
+
+	public async fetchOrganization(
+		organizationId: string,
+	): Promise<ClineOrganization> {
+		const orgId = organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineOrganization>(
+			`/api/v1/organizations/${encodeURIComponent(orgId)}`,
+		);
+	}
+
+	public async fetchOrganizationBalance(
+		organizationId: string,
+	): Promise<ClineAccountOrganizationBalance> {
+		const orgId = organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineAccountOrganizationBalance>(
+			`/api/v1/organizations/${encodeURIComponent(orgId)}/balance`,
+		);
+	}
+
+	public async fetchOrganizationUsageTransactions(input: {
+		organizationId: string;
+		memberId?: string;
+	}): Promise<ClineAccountOrganizationUsageTransaction[]> {
+		const organizationId = input.organizationId.trim();
+		if (!organizationId) {
+			throw new Error("organizationId is required");
+		}
+
+		const memberId = await this.resolveOrganizationMemberId(
+			organizationId,
+			input.memberId,
+		);
+		const response = await this.request<{
+			items: ClineAccountOrganizationUsageTransaction[];
+		}>(
+			`/api/v1/organizations/${encodeURIComponent(organizationId)}/members/${encodeURIComponent(memberId)}/usages`,
+		);
+		return response.items ?? [];
+	}
+
+	public async switchAccount(organizationId?: string | null): Promise<void> {
+		await this.request<void>("/api/v1/users/active-account", {
+			method: "PUT",
+			body: {
+				organizationId: organizationId?.trim() || null,
+			},
+			expectNoContent: true,
+		});
+	}
+
+	private async resolveUserId(userId?: string): Promise<string> {
+		const explicit = userId?.trim();
+		if (explicit) {
+			return explicit;
+		}
+
+		const fromProvider = this.getCurrentUserIdFn
+			? await this.getCurrentUserIdFn()
+			: undefined;
+		const provided = fromProvider?.trim();
+		if (provided) {
+			return provided;
+		}
+
+		const me = await this.fetchMe();
+		if (!me.id?.trim()) {
+			throw new Error("Unable to resolve current user id");
+		}
+		return me.id;
+	}
+
+	private async resolveOrganizationMemberId(
+		organizationId: string,
+		memberId?: string,
+	): Promise<string> {
+		const explicit = memberId?.trim();
+		if (explicit) {
+			return explicit;
+		}
+
+		const fromProvider = this.getOrganizationMemberIdFn
+			? await this.getOrganizationMemberIdFn(organizationId)
+			: undefined;
+		const provided = fromProvider?.trim();
+		if (provided) {
+			return provided;
+		}
+
+		const organizations = await this.fetchUserOrganizations();
+		const resolved = organizations.find(
+			(org) => org.organizationId === organizationId,
+		)?.memberId;
+		if (!resolved?.trim()) {
+			throw new Error(
+				`Unable to resolve memberId for organization ${organizationId}`,
+			);
+		}
+		return resolved;
+	}
+
+	private async request<T>(
+		endpoint: string,
+		input?: {
+			method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+			body?: unknown;
+			expectNoContent?: boolean;
+		},
+	): Promise<T> {
+		const token = (await this.getAuthTokenFn())?.trim();
+		if (!token) {
+			throw new Error("No Cline account auth token found");
+		}
+
+		const extraHeaders = this.getHeadersFn ? await this.getHeadersFn() : {};
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+
+		try {
+			const response = await this.fetchImpl(
+				new URL(endpoint, this.apiBaseUrl),
+				{
+					method: input?.method ?? "GET",
+					headers: {
+						Authorization: `Bearer ${token}`,
+						"Content-Type": "application/json",
+						...(extraHeaders ?? {}),
+					},
+					body:
+						input?.body !== undefined ? JSON.stringify(input.body) : undefined,
+					signal: controller.signal,
+				},
+			);
+
+			if (response.status === 204 || input?.expectNoContent) {
+				if (!response.ok) {
+					throw new Error(
+						`Cline account request failed with status ${response.status}`,
+					);
+				}
+				return undefined as T;
+			}
+
+			const text = await response.text();
+			let parsed: unknown;
+			if (text.trim()) {
+				try {
+					parsed = JSON.parse(text);
+				} catch {
+					if (!response.ok) {
+						throw new Error(
+							formatClineAccountRequestFailure(
+								response.status,
+								text,
+								undefined,
+							),
+						);
+					}
+					throw new Error("Cline account response was not valid JSON");
+				}
+			}
+
+			if (!response.ok) {
+				throw new Error(
+					formatClineAccountRequestFailure(response.status, text, parsed),
+				);
+			}
+
+			if (typeof parsed === "object" && parsed !== null) {
+				const envelope = parsed as ClineApiEnvelope<T>;
+				if (typeof envelope.success === "boolean") {
+					if (!envelope.success) {
+						throw new Error(envelope.error || "Cline account request failed");
+					}
+					return envelope.data as T;
+				}
+			}
+
+			if (parsed === undefined || parsed === null) {
+				throw new Error("Cline account response payload was empty");
+			}
+			return parsed as T;
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+}
diff --git a/sdk/packages/core/src/account/featurebase-token.test.ts b/sdk/packages/core/src/account/featurebase-token.test.ts
new file mode 100644
index 0000000..0dbbd3a
--- /dev/null
+++ b/sdk/packages/core/src/account/featurebase-token.test.ts
@@ -0,0 +1,175 @@
+import { describe, expect, it, vi } from "vitest";
+import { ClineAccountService } from "./cline-account-service";
+import {
+	type ClineAccountOperations,
+	executeClineAccountAction,
+	RpcClineAccountService,
+} from "./rpc";
+
+describe("ClineAccountService.fetchFeaturebaseToken", () => {
+	it("returns featurebaseJwt on success", async () => {
+		const fetchImpl = vi.fn(async (input: unknown, init?: RequestInit) => {
+			expect(String(input)).toBe(
+				"https://api.cline.bot/api/v1/users/me/featurebase-token",
+			);
+			expect(init?.headers).toMatchObject({
+				Authorization: "Bearer workos:token-123",
+			});
+			return new Response(
+				JSON.stringify({
+					success: true,
+					data: { featurebaseJwt: "eyJhbGciOiJIUzI1NiJ9.test.sig" },
+				}),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const result = await service.fetchFeaturebaseToken();
+		expect(result).toEqual({
+			featurebaseJwt: "eyJhbGciOiJIUzI1NiJ9.test.sig",
+		});
+		expect(fetchImpl).toHaveBeenCalledTimes(1);
+	});
+
+	it("returns undefined on network/request error", async () => {
+		const fetchImpl = vi.fn(async () => {
+			throw new Error("Network error");
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const result = await service.fetchFeaturebaseToken();
+		expect(result).toBeUndefined();
+	});
+
+	it("returns undefined when auth token is missing", async () => {
+		const fetchImpl = vi.fn();
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => undefined,
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const result = await service.fetchFeaturebaseToken();
+		expect(result).toBeUndefined();
+		expect(fetchImpl).not.toHaveBeenCalled();
+	});
+
+	it("returns undefined on HTTP error response", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response(JSON.stringify({ error: "Unauthorized" }), {
+				status: 401,
+				headers: { "Content-Type": "application/json" },
+			});
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const result = await service.fetchFeaturebaseToken();
+		expect(result).toBeUndefined();
+	});
+});
+
+describe("executeClineAccountAction - fetchFeaturebaseToken", () => {
+	it("dispatches fetchFeaturebaseToken", async () => {
+		const service: ClineAccountOperations = {
+			fetchMe: vi.fn(async () => ({
+				id: "u1",
+				email: "user1@example.com",
+				displayName: "User 1",
+				photoUrl: "",
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:00:00Z",
+				organizations: [],
+			})),
+			fetchBalance: vi.fn(async () => ({ balance: 1, userId: "u1" })),
+			fetchUsageTransactions: vi.fn(async () => []),
+			fetchPaymentTransactions: vi.fn(async () => []),
+			fetchUserOrganizations: vi.fn(async () => []),
+			fetchOrganizationBalance: vi.fn(async () => ({
+				balance: 1,
+				organizationId: "org-1",
+			})),
+			fetchOrganizationUsageTransactions: vi.fn(async () => []),
+			switchAccount: vi.fn(async () => {}),
+			fetchFeaturebaseToken: vi.fn(async () => ({
+				featurebaseJwt: "mock-jwt-token",
+			})),
+		};
+
+		const result = await executeClineAccountAction(
+			{ action: "clineAccount", operation: "fetchFeaturebaseToken" },
+			service,
+		);
+		expect(service.fetchFeaturebaseToken).toHaveBeenCalledTimes(1);
+		expect(result).toEqual({ featurebaseJwt: "mock-jwt-token" });
+	});
+
+	it("returns undefined when fetchFeaturebaseToken is not implemented", async () => {
+		const service: ClineAccountOperations = {
+			fetchMe: vi.fn(async () => ({
+				id: "u1",
+				email: "user1@example.com",
+				displayName: "User 1",
+				photoUrl: "",
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:00:00Z",
+				organizations: [],
+			})),
+			fetchBalance: vi.fn(async () => ({ balance: 1, userId: "u1" })),
+			fetchUsageTransactions: vi.fn(async () => []),
+			fetchPaymentTransactions: vi.fn(async () => []),
+			fetchUserOrganizations: vi.fn(async () => []),
+			fetchOrganizationBalance: vi.fn(async () => ({
+				balance: 1,
+				organizationId: "org-1",
+			})),
+			fetchOrganizationUsageTransactions: vi.fn(async () => []),
+			switchAccount: vi.fn(async () => {}),
+		};
+
+		const result = await executeClineAccountAction(
+			{ action: "clineAccount", operation: "fetchFeaturebaseToken" },
+			service,
+		);
+		expect(result).toBeUndefined();
+	});
+});
+
+describe("RpcClineAccountService.fetchFeaturebaseToken", () => {
+	it("sends provider action payload and parses response", async () => {
+		const runProviderAction = vi.fn(async (request: unknown) => {
+			const parsed = request as {
+				action: string;
+				operation: string;
+			};
+			expect(parsed).toEqual({
+				action: "clineAccount",
+				operation: "fetchFeaturebaseToken",
+			});
+			return {
+				result: { featurebaseJwt: "rpc-jwt-token" },
+			};
+		});
+		const service = new RpcClineAccountService({ runProviderAction });
+
+		const result = await service.fetchFeaturebaseToken();
+		expect(runProviderAction).toHaveBeenCalledTimes(1);
+		expect(result).toEqual({ featurebaseJwt: "rpc-jwt-token" });
+	});
+});
diff --git a/sdk/packages/core/src/account/index.ts b/sdk/packages/core/src/account/index.ts
new file mode 100644
index 0000000..edb067e
--- /dev/null
+++ b/sdk/packages/core/src/account/index.ts
@@ -0,0 +1,26 @@
+export {
+	ClineAccountService,
+	type ClineAccountServiceOptions,
+} from "./cline-account-service";
+export {
+	type ClineAccountOperations,
+	executeClineAccountAction,
+	isClineAccountActionRequest,
+	type ProviderActionExecutor,
+	RpcClineAccountService,
+} from "./rpc";
+export type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+	ClineOrganization,
+	ClineSubscriptionPlan,
+	FeaturebaseTokenResponse,
+	UserCurrentPlan,
+	UserRemoteConfigOrganization,
+	UserRemoteConfigResponse,
+} from "./types";
diff --git a/sdk/packages/core/src/account/rpc.test.ts b/sdk/packages/core/src/account/rpc.test.ts
new file mode 100644
index 0000000..610376d
--- /dev/null
+++ b/sdk/packages/core/src/account/rpc.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	type ClineAccountOperations,
+	executeClineAccountAction,
+	RpcClineAccountService,
+} from "./rpc";
+
+describe("executeClineAccountAction", () => {
+	it("dispatches fetchMe", async () => {
+		const service: ClineAccountOperations = {
+			fetchMe: vi.fn(async () => ({
+				id: "u1",
+				email: "user1@example.com",
+				displayName: "User 1",
+				photoUrl: "",
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:00:00Z",
+				organizations: [],
+			})),
+			fetchBalance: vi.fn(async () => ({ balance: 1, userId: "u1" })),
+			fetchUsageTransactions: vi.fn(async () => []),
+			fetchPaymentTransactions: vi.fn(async () => []),
+			fetchUserOrganizations: vi.fn(async () => []),
+			fetchOrganizationBalance: vi.fn(async () => ({
+				balance: 1,
+				organizationId: "org-1",
+			})),
+			fetchOrganizationUsageTransactions: vi.fn(async () => []),
+			switchAccount: vi.fn(async () => {}),
+			fetchFeaturebaseToken: vi.fn(async () => undefined),
+		};
+
+		const result = await executeClineAccountAction(
+			{ action: "clineAccount", operation: "fetchMe" },
+			service,
+		);
+		expect(service.fetchMe).toHaveBeenCalledTimes(1);
+		expect(result).toMatchObject({ id: "u1" });
+	});
+});
+
+describe("RpcClineAccountService", () => {
+	it("sends provider action payload and parses response", async () => {
+		const runProviderAction = vi.fn(async (request: unknown) => {
+			const parsed = request as {
+				action: string;
+				operation: string;
+			};
+			expect(parsed).toEqual({
+				action: "clineAccount",
+				operation: "fetchMe",
+			});
+			return {
+				result: { id: "u2", email: "u2@example.com" },
+			};
+		});
+		const service = new RpcClineAccountService({ runProviderAction });
+
+		const me = await service.fetchMe();
+		expect(runProviderAction).toHaveBeenCalledTimes(1);
+		expect(me).toEqual({ id: "u2", email: "u2@example.com" });
+	});
+});
diff --git a/sdk/packages/core/src/account/rpc.ts b/sdk/packages/core/src/account/rpc.ts
new file mode 100644
index 0000000..caed109
--- /dev/null
+++ b/sdk/packages/core/src/account/rpc.ts
@@ -0,0 +1,185 @@
+import type {
+	ClineAccountActionRequest,
+	ProviderActionRequest,
+} from "@cline/shared";
+import type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+	FeaturebaseTokenResponse,
+} from "./types";
+
+export interface ClineAccountOperations {
+	fetchMe(): Promise<ClineAccountUser>;
+	fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+	fetchUsageTransactions(
+		userId?: string,
+	): Promise<ClineAccountUsageTransaction[]>;
+	fetchPaymentTransactions(
+		userId?: string,
+	): Promise<ClineAccountPaymentTransaction[]>;
+	fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+	fetchOrganizationBalance(
+		organizationId: string,
+	): Promise<ClineAccountOrganizationBalance>;
+	fetchOrganizationUsageTransactions(input: {
+		organizationId: string;
+		memberId?: string;
+	}): Promise<ClineAccountOrganizationUsageTransaction[]>;
+	switchAccount(organizationId?: string | null): Promise<void>;
+	fetchFeaturebaseToken?(): Promise<FeaturebaseTokenResponse | undefined>;
+}
+
+export function isClineAccountActionRequest(
+	request: ProviderActionRequest,
+): request is ClineAccountActionRequest {
+	return request.action === "clineAccount";
+}
+
+export async function executeClineAccountAction(
+	request: ClineAccountActionRequest,
+	service: ClineAccountOperations,
+): Promise<unknown> {
+	switch (request.operation) {
+		case "fetchMe":
+			return service.fetchMe();
+		case "fetchBalance":
+			return service.fetchBalance(request.userId);
+		case "fetchUsageTransactions":
+			return service.fetchUsageTransactions(request.userId);
+		case "fetchPaymentTransactions":
+			return service.fetchPaymentTransactions(request.userId);
+		case "fetchUserOrganizations":
+			return service.fetchUserOrganizations();
+		case "fetchOrganizationBalance":
+			return service.fetchOrganizationBalance(request.organizationId);
+		case "fetchOrganizationUsageTransactions":
+			return service.fetchOrganizationUsageTransactions({
+				organizationId: request.organizationId,
+				memberId: request.memberId,
+			});
+		case "switchAccount":
+			await service.switchAccount(request.organizationId);
+			return { updated: true };
+		case "fetchFeaturebaseToken":
+			return service.fetchFeaturebaseToken?.();
+		default: {
+			const exhaustive: never = request;
+			throw new Error(
+				`Unsupported Cline account operation: ${String(exhaustive)}`,
+			);
+		}
+	}
+}
+
+export interface ProviderActionExecutor {
+	runProviderAction(request: ProviderActionRequest): Promise<{
+		result: unknown;
+	}>;
+}
+
+export class RpcClineAccountService implements ClineAccountOperations {
+	private readonly executor: ProviderActionExecutor;
+
+	constructor(executor: ProviderActionExecutor) {
+		this.executor = executor;
+	}
+
+	public async fetchMe(): Promise<ClineAccountUser> {
+		return this.request<ClineAccountUser>({
+			action: "clineAccount",
+			operation: "fetchMe",
+		});
+	}
+
+	public async fetchBalance(userId?: string): Promise<ClineAccountBalance> {
+		return this.request<ClineAccountBalance>({
+			action: "clineAccount",
+			operation: "fetchBalance",
+			...(userId?.trim() ? { userId: userId.trim() } : {}),
+		});
+	}
+
+	public async fetchUsageTransactions(
+		userId?: string,
+	): Promise<ClineAccountUsageTransaction[]> {
+		return this.request<ClineAccountUsageTransaction[]>({
+			action: "clineAccount",
+			operation: "fetchUsageTransactions",
+			...(userId?.trim() ? { userId: userId.trim() } : {}),
+		});
+	}
+
+	public async fetchPaymentTransactions(
+		userId?: string,
+	): Promise<ClineAccountPaymentTransaction[]> {
+		return this.request<ClineAccountPaymentTransaction[]>({
+			action: "clineAccount",
+			operation: "fetchPaymentTransactions",
+			...(userId?.trim() ? { userId: userId.trim() } : {}),
+		});
+	}
+
+	public async fetchUserOrganizations(): Promise<ClineAccountOrganization[]> {
+		return this.request<ClineAccountOrganization[]>({
+			action: "clineAccount",
+			operation: "fetchUserOrganizations",
+		});
+	}
+
+	public async fetchOrganizationBalance(
+		organizationId: string,
+	): Promise<ClineAccountOrganizationBalance> {
+		const orgId = organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineAccountOrganizationBalance>({
+			action: "clineAccount",
+			operation: "fetchOrganizationBalance",
+			organizationId: orgId,
+		});
+	}
+
+	public async fetchOrganizationUsageTransactions(input: {
+		organizationId: string;
+		memberId?: string;
+	}): Promise<ClineAccountOrganizationUsageTransaction[]> {
+		const orgId = input.organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineAccountOrganizationUsageTransaction[]>({
+			action: "clineAccount",
+			operation: "fetchOrganizationUsageTransactions",
+			organizationId: orgId,
+			...(input.memberId?.trim() ? { memberId: input.memberId.trim() } : {}),
+		});
+	}
+
+	public async switchAccount(organizationId?: string | null): Promise<void> {
+		await this.request<{ updated: boolean }>({
+			action: "clineAccount",
+			operation: "switchAccount",
+			organizationId: organizationId?.trim() || null,
+		});
+	}
+
+	public async fetchFeaturebaseToken(): Promise<
+		FeaturebaseTokenResponse | undefined
+	> {
+		return this.request<FeaturebaseTokenResponse | undefined>({
+			action: "clineAccount",
+			operation: "fetchFeaturebaseToken",
+		});
+	}
+
+	private async request<T>(request: ClineAccountActionRequest): Promise<T> {
+		const response = await this.executor.runProviderAction(request);
+		return response.result as T;
+	}
+}
diff --git a/sdk/packages/core/src/account/types.ts b/sdk/packages/core/src/account/types.ts
new file mode 100644
index 0000000..bed0212
--- /dev/null
+++ b/sdk/packages/core/src/account/types.ts
@@ -0,0 +1,134 @@
+export interface ClineAccountOrganization {
+	active: boolean;
+	memberId: string;
+	name: string;
+	organizationId: string;
+	roles: Array<"admin" | "member" | "owner">;
+}
+
+export interface ClineAccountUser {
+	id: string;
+	email: string;
+	displayName: string;
+	photoUrl: string;
+	createdAt: string;
+	updatedAt: string;
+	organizations: ClineAccountOrganization[];
+}
+
+export interface UserRemoteConfigOrganization {
+	organizationId: string;
+	name: string;
+}
+
+export interface UserRemoteConfigResponse {
+	organizationId: string;
+	value: string;
+	enabled: boolean;
+	organizations?: UserRemoteConfigOrganization[];
+}
+
+export interface ClineAccountBalance {
+	balance: number;
+	userId: string;
+}
+
+export interface ClineAccountUsageTransaction {
+	aiInferenceProviderName: string;
+	aiModelName: string;
+	aiModelTypeName: string;
+	completionTokens: number;
+	costUsd: number;
+	createdAt: string;
+	creditsUsed: number;
+	generationId: string;
+	id: string;
+	metadata: {
+		additionalProp1: string;
+		additionalProp2: string;
+		additionalProp3: string;
+	};
+	operation?: string;
+	organizationId: string;
+	promptTokens: number;
+	totalTokens: number;
+	userId: string;
+}
+
+export interface ClineAccountPaymentTransaction {
+	paidAt: string;
+	creatorId: string;
+	amountCents: number;
+	credits: number;
+}
+
+export interface ClineOrganization {
+	createdAt: string;
+	defaultRemoteConfig?: string;
+	deletedAt?: string;
+	externalOrganizationId?: string;
+	id: string;
+	memberCount?: number;
+	name: string;
+	remoteConfigEnabled: boolean;
+	updatedAt: string;
+}
+
+export interface ClineAccountOrganizationBalance {
+	balance: number;
+	organizationId: string;
+}
+
+export interface FeaturebaseTokenResponse {
+	featurebaseJwt: string;
+}
+
+export interface ClineSubscriptionPlan {
+	displayName?: string;
+	features?: {
+		included?: string[];
+		[key: string]: unknown;
+	};
+	id?: string;
+	interval?: string;
+	name?: string;
+	pricePerSeatCents?: number;
+	type?: string;
+	[key: string]: unknown;
+}
+
+export interface UserCurrentPlan {
+	cancelAt?: string;
+	canceledAt?: string;
+	currentPeriodEnd?: string;
+	currentPeriodStart?: string;
+	plan?: ClineSubscriptionPlan | null;
+	planHistoryId?: string;
+	subscriptionId?: string;
+	userId?: string;
+	[key: string]: unknown;
+}
+
+export interface ClineAccountOrganizationUsageTransaction {
+	aiInferenceProviderName: string;
+	aiModelName: string;
+	aiModelTypeName: string;
+	completionTokens: number;
+	costUsd: number;
+	createdAt: string;
+	creditsUsed: number;
+	generationId: string;
+	id: string;
+	memberDisplayName: string;
+	memberEmail: string;
+	metadata: {
+		additionalProp1: string;
+		additionalProp2: string;
+		additionalProp3: string;
+	};
+	operation?: string;
+	organizationId: string;
+	promptTokens: number;
+	totalTokens: number;
+	userId: string;
+}
diff --git a/sdk/packages/core/src/auth/bounded-ttl-cache.test.ts b/sdk/packages/core/src/auth/bounded-ttl-cache.test.ts
new file mode 100644
index 0000000..c7e3a3b
--- /dev/null
+++ b/sdk/packages/core/src/auth/bounded-ttl-cache.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { BoundedTtlCache } from "./bounded-ttl-cache";
+
+describe("BoundedTtlCache", () => {
+	it("returns undefined after TTL", () => {
+		const cache = new BoundedTtlCache(1_000, 10);
+		cache.set("a", "one", 0);
+		expect(cache.get("a", 500)).toBe("one");
+		expect(cache.get("a", 1_500)).toBeUndefined();
+	});
+
+	it("evicts oldest entries when over max size", () => {
+		const cache = new BoundedTtlCache(60_000, 2);
+		cache.set("a", "1", 0);
+		cache.set("b", "2", 0);
+		cache.set("c", "3", 0);
+		expect(cache.get("a", 0)).toBeUndefined();
+		expect(cache.get("b", 0)).toBe("2");
+		expect(cache.get("c", 0)).toBe("3");
+	});
+
+	it("refreshes recency on get so hot keys survive eviction", () => {
+		const cache = new BoundedTtlCache(60_000, 2);
+		cache.set("a", "1", 0);
+		cache.set("b", "2", 0);
+		expect(cache.get("a", 0)).toBe("1");
+		cache.set("c", "3", 0);
+		expect(cache.get("a", 0)).toBe("1");
+		expect(cache.get("b", 0)).toBeUndefined();
+	});
+
+	it("supports per-entry TTL override", () => {
+		const cache = new BoundedTtlCache(60_000, 2);
+		cache.set("short", "v", 0, 1_000);
+		expect(cache.get("short", 500)).toBe("v");
+		expect(cache.get("short", 1_500)).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/auth/bounded-ttl-cache.ts b/sdk/packages/core/src/auth/bounded-ttl-cache.ts
new file mode 100644
index 0000000..ebf41ac
--- /dev/null
+++ b/sdk/packages/core/src/auth/bounded-ttl-cache.ts
@@ -0,0 +1,53 @@
+/**
+ * Small process-local string cache with TTL expiry and a hard entry cap.
+ * Used where unbounded Maps would grow without bound in long-running processes.
+ */
+export class BoundedTtlCache {
+	private readonly entries = new Map<
+		string,
+		{ value: string; expiresAt: number }
+	>();
+
+	constructor(
+		private readonly ttlMs: number,
+		private readonly maxEntries: number,
+	) {}
+
+	get(key: string, now = Date.now()): string | undefined {
+		this.pruneExpired(now);
+		const hit = this.entries.get(key);
+		if (!hit) {
+			return undefined;
+		}
+		// Bump recency for FIFO eviction under cap.
+		this.entries.delete(key);
+		this.entries.set(key, hit);
+		return hit.value;
+	}
+
+	set(
+		key: string,
+		value: string,
+		now = Date.now(),
+		ttlMsOverride = this.ttlMs,
+	): void {
+		this.pruneExpired(now);
+		this.entries.delete(key);
+		while (this.entries.size >= this.maxEntries) {
+			const first = this.entries.keys().next().value as string | undefined;
+			if (first === undefined) {
+				break;
+			}
+			this.entries.delete(first);
+		}
+		this.entries.set(key, { value, expiresAt: now + ttlMsOverride });
+	}
+
+	private pruneExpired(now: number): void {
+		for (const [k, v] of this.entries) {
+			if (v.expiresAt <= now) {
+				this.entries.delete(k);
+			}
+		}
+	}
+}
diff --git a/sdk/packages/core/src/auth/client.test.ts b/sdk/packages/core/src/auth/client.test.ts
new file mode 100644
index 0000000..fd22c2a
--- /dev/null
+++ b/sdk/packages/core/src/auth/client.test.ts
@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from "vitest";
+import { createOAuthClientCallbacks } from "./client";
+
+describe("auth/client createOAuthClientCallbacks", () => {
+	it("emits instructions and URL and forwards prompts", async () => {
+		const onOutput = vi.fn();
+		const onPrompt = vi.fn().mockResolvedValue("value");
+		const callbacks = createOAuthClientCallbacks({ onOutput, onPrompt });
+
+		callbacks.onAuth({
+			url: "https://example.com/auth",
+			instructions: "Open your browser",
+		});
+		const answer = await callbacks.onPrompt({ message: "Enter code" });
+
+		expect(answer).toBe("value");
+		expect(onPrompt).toHaveBeenCalledWith({ message: "Enter code" });
+		expect(onOutput).toHaveBeenNthCalledWith(1, "Open your browser");
+		expect(onOutput).toHaveBeenNthCalledWith(2, "https://example.com/auth");
+	});
+
+	it("tries opening URL and reports opener errors", async () => {
+		const openUrl = vi.fn().mockRejectedValue(new Error("failed"));
+		const onOpenUrlError = vi.fn();
+		const callbacks = createOAuthClientCallbacks({
+			onPrompt: vi.fn().mockResolvedValue(""),
+			openUrl,
+			onOpenUrlError,
+		});
+
+		callbacks.onAuth({ url: "https://example.com/auth" });
+		await Promise.resolve();
+
+		expect(openUrl).toHaveBeenCalledWith("https://example.com/auth");
+		expect(onOpenUrlError).toHaveBeenCalledTimes(1);
+		expect(onOpenUrlError.mock.calls[0]?.[0]).toMatchObject({
+			url: "https://example.com/auth",
+		});
+	});
+
+	it("reports synchronous opener errors without aborting auth output", () => {
+		const openUrl = vi.fn(() => {
+			throw new Error("missing opener");
+		});
+		const onOpenUrlError = vi.fn();
+		const onOutput = vi.fn();
+		const callbacks = createOAuthClientCallbacks({
+			onPrompt: vi.fn().mockResolvedValue(""),
+			onOutput,
+			openUrl,
+			onOpenUrlError,
+		});
+
+		expect(() =>
+			callbacks.onAuth({ url: "https://example.com/auth" }),
+		).not.toThrow();
+		expect(openUrl).toHaveBeenCalledWith("https://example.com/auth");
+		expect(onOpenUrlError).toHaveBeenCalledTimes(1);
+		expect(onOpenUrlError.mock.calls[0]?.[0]).toMatchObject({
+			url: "https://example.com/auth",
+		});
+		expect(onOutput).toHaveBeenLastCalledWith("https://example.com/auth");
+	});
+
+	it("forwards onServerListening to the returned callbacks", () => {
+		const onServerListening = vi.fn();
+		const callbacks = createOAuthClientCallbacks({
+			onPrompt: vi.fn().mockResolvedValue(""),
+			onServerListening,
+		});
+
+		expect(callbacks.onServerListening).toBe(onServerListening);
+	});
+
+	it("forwards onServerClose to the returned callbacks", () => {
+		const onServerClose = vi.fn();
+		const callbacks = createOAuthClientCallbacks({
+			onPrompt: vi.fn().mockResolvedValue(""),
+			onServerClose,
+		});
+
+		expect(callbacks.onServerClose).toBe(onServerClose);
+	});
+
+	it("leaves onServerListening and onServerClose undefined when not provided", () => {
+		const callbacks = createOAuthClientCallbacks({
+			onPrompt: vi.fn().mockResolvedValue(""),
+		});
+
+		expect(callbacks.onServerListening).toBeUndefined();
+		expect(callbacks.onServerClose).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/auth/client.ts b/sdk/packages/core/src/auth/client.ts
new file mode 100644
index 0000000..105a159
--- /dev/null
+++ b/sdk/packages/core/src/auth/client.ts
@@ -0,0 +1,50 @@
+import type { OAuthServerCloseInfo, OAuthServerListeningInfo } from "./server";
+import type { OAuthLoginCallbacks, OAuthPrompt } from "./types";
+
+export interface OAuthClientCallbacksOptions {
+	onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+	onOutput?: (message: string) => void;
+	openUrl?: (url: string) => void | Promise<void>;
+	onOpenUrlError?: (context: { url: string; error: unknown }) => void;
+	/**
+	 * Called when the local OAuth redirect server successfully binds to a port
+	 * and is ready to receive the browser callback.
+	 *
+	 * Forwarded directly from `OAuthLoginCallbacks.onServerListening`.
+	 * Use this to show a "waiting for OAuth callback on :::1 port N" status
+	 * message or, in remote-development environments (e.g. JetBrains Gateway),
+	 * to set up a port-forward from the remote machine to the local one.
+	 */
+	onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+	/**
+	 * Called when the local OAuth redirect server closes.
+	 *
+	 * Forwarded directly from `OAuthLoginCallbacks.onServerClose`.
+	 * Use this to tear down port-forwards and clear any status UI set up in
+	 * `onServerListening`.
+	 */
+	onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+
+export function createOAuthClientCallbacks(
+	options: OAuthClientCallbacksOptions,
+): OAuthLoginCallbacks {
+	return {
+		onAuth: ({ url, instructions }) => {
+			options.onOutput?.(instructions ?? "Complete sign-in in your browser.");
+			if (options.openUrl) {
+				try {
+					void Promise.resolve(options.openUrl(url)).catch((error) => {
+						options.onOpenUrlError?.({ url, error });
+					});
+				} catch (error) {
+					options.onOpenUrlError?.({ url, error });
+				}
+			}
+			options.onOutput?.(url);
+		},
+		onPrompt: options.onPrompt,
+		onServerListening: options.onServerListening,
+		onServerClose: options.onServerClose,
+	};
+}
diff --git a/sdk/packages/core/src/auth/cline.test.ts b/sdk/packages/core/src/auth/cline.test.ts
new file mode 100644
index 0000000..689dc9d
--- /dev/null
+++ b/sdk/packages/core/src/auth/cline.test.ts
@@ -0,0 +1,216 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ClineOAuthCredentials } from "./cline";
+import { getValidClineCredentials, loginClineOAuth } from "./cline";
+
+const PROVIDER_OPTIONS = {
+	apiBaseUrl: "https://auth.example.com",
+};
+const ORIGINAL_FETCH = globalThis.fetch;
+
+function createCredentials(
+	overrides: Partial<ClineOAuthCredentials> = {},
+): ClineOAuthCredentials {
+	return {
+		access: "access-old",
+		refresh: "refresh-old",
+		expires: 0,
+		accountId: "acct-1",
+		email: "user@example.com",
+		metadata: { provider: "google" },
+		...overrides,
+	};
+}
+
+describe("auth/cline getValidClineCredentials", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+		globalThis.fetch = ORIGINAL_FETCH;
+	});
+
+	it("returns existing credentials when not expired", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(10_000);
+		const current = createCredentials({ expires: 400_000 });
+		const fetchMock = vi.fn();
+		globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS);
+		expect(result).toBe(current);
+		expect(fetchMock).not.toHaveBeenCalled();
+		nowSpy.mockRestore();
+	});
+
+	it("refreshes expired credentials", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const current = createCredentials({ expires: 101_000 });
+		const fetchMock = vi.fn(
+			async () =>
+				new Response(
+					JSON.stringify({
+						success: true,
+						data: {
+							accessToken: "access-new",
+							refreshToken: "refresh-new",
+							tokenType: "Bearer",
+							expiresAt: "2030-01-01T00:00:00.000Z",
+							userInfo: {
+								subject: "sub-1",
+								email: "new@example.com",
+								name: "New User",
+								clineUserId: "acct-2",
+								accounts: [],
+							},
+						},
+					}),
+					{ status: 200, headers: { "Content-Type": "application/json" } },
+				),
+		);
+		globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS);
+		expect(result).toMatchObject({
+			access: "access-new",
+			refresh: "refresh-new",
+			accountId: "acct-2",
+			email: "new@example.com",
+		});
+		nowSpy.mockRestore();
+	});
+
+	it("returns null when refresh fails with invalid_grant", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const current = createCredentials({ expires: 101_000 });
+		globalThis.fetch = vi.fn(
+			async () =>
+				new Response(
+					JSON.stringify({
+						error: "invalid_grant",
+						error_description: "refresh expired",
+					}),
+					{
+						status: 401,
+						headers: { "Content-Type": "application/json" },
+					},
+				),
+		) as unknown as typeof fetch;
+
+		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS);
+		expect(result).toBeNull();
+		nowSpy.mockRestore();
+	});
+
+	it("keeps current credentials on transient refresh error while token remains valid", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const current = createCredentials({ expires: 150_000 });
+		globalThis.fetch = vi.fn(
+			async () =>
+				new Response(
+					JSON.stringify({
+						error: "server_error",
+						error_description: "temporary issue",
+					}),
+					{
+						status: 500,
+						headers: { "Content-Type": "application/json" },
+					},
+				),
+		) as unknown as typeof fetch;
+
+		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS, {
+			refreshBufferMs: 60_000,
+			retryableTokenGraceMs: 30_000,
+		});
+		expect(result).toBe(current);
+		nowSpy.mockRestore();
+	});
+});
+
+describe("auth/cline loginClineOAuth", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+		globalThis.fetch = ORIGINAL_FETCH;
+	});
+
+	it("completes WorkOS device auth and registers tokens", async () => {
+		const fetchMock = vi
+			.fn()
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						device_code: "dev-code-1",
+						user_code: "ABCD-EFGH",
+						verification_uri: "https://example.com/device",
+						verification_uri_complete:
+							"https://example.com/device?user_code=ABCD-EFGH",
+						expires_in: 300,
+						interval: 1,
+					}),
+					{ status: 200, headers: { "Content-Type": "application/json" } },
+				),
+			)
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						access_token: "workos-access",
+						refresh_token: "workos-refresh",
+						token_type: "Bearer",
+						expires_in: 3600,
+					}),
+					{ status: 200, headers: { "Content-Type": "application/json" } },
+				),
+			)
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						success: true,
+						data: {
+							accessToken: "cline-access",
+							refreshToken: "cline-refresh",
+							tokenType: "Bearer",
+							expiresAt: "2030-01-01T00:00:00.000Z",
+							userInfo: {
+								subject: "sub-1",
+								email: "user@example.com",
+								name: "User",
+								clineUserId: "acct-1",
+								accounts: ["acct-1"],
+							},
+						},
+					}),
+					{ status: 200, headers: { "Content-Type": "application/json" } },
+				),
+			);
+		globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+		const onAuth = vi.fn();
+		const credentials = await loginClineOAuth({
+			apiBaseUrl: "https://api.cline.bot",
+			useWorkOSDeviceAuth: true,
+			callbacks: {
+				onAuth,
+				onPrompt: async () => "",
+			},
+		});
+
+		expect(onAuth).toHaveBeenCalledTimes(1);
+		expect(onAuth.mock.calls[0]?.[0]).toMatchObject({
+			url: "https://example.com/device?user_code=ABCD-EFGH",
+		});
+		expect(credentials).toMatchObject({
+			access: "cline-access",
+			refresh: "cline-refresh",
+			accountId: "acct-1",
+			email: "user@example.com",
+		});
+		expect(fetchMock).toHaveBeenCalledTimes(3);
+		const registerCallBody = JSON.parse(
+			String(fetchMock.mock.calls[2]?.[1]?.body ?? "{}"),
+		);
+		const deviceAuthBody = String(fetchMock.mock.calls[0]?.[1]?.body ?? "");
+		const deviceAuthParams = new URLSearchParams(deviceAuthBody);
+		expect(deviceAuthParams.get("client_id")).toMatch(/client_.*/);
+		expect(registerCallBody).toMatchObject({
+			accessToken: "workos-access",
+			refreshToken: "workos-refresh",
+		});
+	});
+});
diff --git a/sdk/packages/core/src/auth/cline.ts b/sdk/packages/core/src/auth/cline.ts
new file mode 100644
index 0000000..574f70c
--- /dev/null
+++ b/sdk/packages/core/src/auth/cline.ts
@@ -0,0 +1,712 @@
+import {
+	getClineEnvironmentConfig,
+	type ITelemetryService,
+} from "@cline/shared";
+import {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	identifyAccount,
+} from "../services/telemetry/core-events";
+import { startLocalOAuthServer } from "./server";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
+import { hashSecret, sdkDebug } from "../logging/early-logger";
+import {
+	isCredentialLikelyExpired,
+	parseAuthorizationInput,
+	parseOAuthError,
+	resolveAuthorizationCodeInput,
+	resolveUrl,
+} from "./utils";
+
+const DEFAULT_AUTH_ENDPOINTS = {
+	authorize: "/api/v1/auth/authorize",
+	token: "/api/v1/auth/token",
+	register: "/api/v1/auth/register",
+	refresh: "/api/v1/auth/refresh",
+} as const;
+
+const DEFAULT_WORKOS_ENDPOINTS = {
+	deviceAuthorization: "/user_management/authorize/device",
+	authenticate: "/user_management/authenticate",
+} as const;
+
+const DEFAULT_WORKOS_API_BASE_URL = "https://api.workos.com";
+const DEFAULT_CALLBACK_PATH = "/auth";
+const DEFAULT_CALLBACK_PORTS = Array.from(
+	{ length: 11 },
+	(_, index) => 48801 + index,
+);
+const DEFAULT_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+const DEFAULT_RETRYABLE_TOKEN_GRACE_MS = 30 * 1000;
+const DEFAULT_HTTP_TIMEOUT_MS = 30 * 1000;
+const DEFAULT_DEVICE_AUTH_EXPIRES_IN_SECONDS = 300;
+const DEFAULT_DEVICE_AUTH_INTERVAL_SECONDS = 5;
+
+export type ClineTokenResolution = {
+	forceRefresh?: boolean;
+	refreshBufferMs?: number;
+	retryableTokenGraceMs?: number;
+};
+
+interface ClineAuthApiUser {
+	subject: string | null;
+	email: string;
+	name: string;
+	clineUserId: string | null;
+	accounts: string[] | null;
+}
+
+interface ClineAuthResponseData {
+	accessToken: string;
+	refreshToken?: string;
+	tokenType: string;
+	expiresAt: string;
+	userInfo: ClineAuthApiUser;
+}
+
+type ClineTokenResponse = {
+	success: boolean;
+	data: ClineAuthResponseData;
+};
+
+type HeaderMap = Record<string, string>;
+type HeaderInput = HeaderMap | (() => Promise<HeaderMap> | HeaderMap);
+
+export interface ClineOAuthProviderOptions {
+	apiBaseUrl: string;
+	headers?: HeaderInput;
+	requestTimeoutMs?: number;
+	telemetry?: ITelemetryService;
+	useWorkOSDeviceAuth?: boolean;
+	callbackPath?: string;
+	callbackPorts?: number[];
+	/**
+	 * Optional identity provider name for token exchange.
+	 */
+	provider?: string;
+}
+
+export interface ClineOAuthCredentials extends OAuthCredentials {
+	metadata?: {
+		provider?: string;
+		tokenType?: string;
+		userInfo?: ClineAuthApiUser;
+		[key: string]: unknown;
+	};
+}
+
+class ClineOAuthTokenError extends Error {
+	public readonly status?: number;
+	public readonly errorCode?: string;
+
+	constructor(message: string, opts?: { status?: number; errorCode?: string }) {
+		super(message);
+		this.name = "ClineOAuthTokenError";
+		this.status = opts?.status;
+		this.errorCode = opts?.errorCode;
+	}
+
+	public isLikelyInvalidGrant(): boolean {
+		if (
+			this.errorCode &&
+			/invalid_grant|invalid_token|unauthorized/i.test(this.errorCode)
+		) {
+			return true;
+		}
+		if (this.status === 400 || this.status === 401 || this.status === 403) {
+			return /invalid|expired|revoked|unauthorized/i.test(this.message);
+		}
+		return false;
+	}
+}
+
+function toEpochMs(isoDateTime: string): number {
+	const epoch = Date.parse(isoDateTime);
+	if (Number.isNaN(epoch)) {
+		throw new Error(`Invalid expiresAt value: ${isoDateTime}`);
+	}
+	return epoch;
+}
+
+function toClineCredentials(
+	responseData: ClineAuthResponseData,
+	provider: string | undefined,
+	fallback: Partial<ClineOAuthCredentials> = {},
+): ClineOAuthCredentials {
+	const accountId = responseData.userInfo.clineUserId ?? fallback.accountId;
+	const refreshToken = responseData.refreshToken ?? fallback.refresh;
+
+	if (!refreshToken) {
+		throw new Error("Token response did not include a refresh token");
+	}
+
+	return {
+		access: responseData.accessToken,
+		refresh: refreshToken,
+		expires: toEpochMs(responseData.expiresAt),
+		accountId: accountId ?? undefined,
+		email: responseData.userInfo.email || fallback.email,
+		metadata: {
+			provider,
+			tokenType: responseData.tokenType,
+			userInfo: responseData.userInfo,
+		},
+	};
+}
+
+async function resolveHeaders(input?: HeaderInput): Promise<HeaderMap> {
+	if (!input) {
+		return {};
+	}
+	return typeof input === "function" ? await input() : input;
+}
+
+function toSeconds(value: unknown, fallback: number): number {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+		return fallback;
+	}
+	return Math.floor(value);
+}
+
+async function sleep(ms: number): Promise<void> {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+type WorkOSDeviceAuthorizationResponse = {
+	device_code?: string;
+	user_code?: string;
+	verification_uri?: string;
+	verification_uri_complete?: string;
+	expires_in?: number;
+	interval?: number;
+	error?: string;
+	error_description?: string;
+};
+
+type WorkOSTokenResponse = {
+	access_token?: string;
+	refresh_token?: string;
+	token_type?: string;
+	expires_in?: number;
+	error?: string;
+	error_description?: string;
+};
+
+type WorkOSTokenSuccess = {
+	accessToken: string;
+	refreshToken: string;
+	tokenType: string;
+};
+
+function requireClineTokenResponse(
+	payload: ClineTokenResponse,
+	message: string,
+): ClineAuthResponseData {
+	if (!payload.success || !payload.data?.accessToken) {
+		throw new Error(message);
+	}
+	return payload.data;
+}
+
+async function requestWorkOSDeviceAuthorization(
+	clientId: string,
+	options?: { requestTimeoutMs?: number },
+): Promise<{
+	deviceCode: string;
+	userCode: string;
+	verificationUri: string;
+	verificationUriComplete?: string;
+	expiresInSeconds: number;
+	pollIntervalSeconds: number;
+}> {
+	const response = await fetch(
+		resolveUrl(
+			DEFAULT_WORKOS_API_BASE_URL,
+			DEFAULT_WORKOS_ENDPOINTS.deviceAuthorization,
+		),
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+			},
+			body: new URLSearchParams({ client_id: clientId }),
+			signal: AbortSignal.timeout(
+				options?.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
+			),
+		},
+	);
+
+	const json = (await response
+		.json()
+		.catch(() => ({}))) as WorkOSDeviceAuthorizationResponse;
+	if (!response.ok) {
+		throw new ClineOAuthTokenError(
+			`Device authorization failed: ${response.status}${json.error_description ? ` - ${json.error_description}` : ""}`,
+			{ status: response.status, errorCode: json.error },
+		);
+	}
+	if (!json.device_code || !json.user_code || !json.verification_uri) {
+		throw new Error("Invalid WorkOS device authorization response");
+	}
+
+	return {
+		deviceCode: json.device_code,
+		userCode: json.user_code,
+		verificationUri: json.verification_uri,
+		verificationUriComplete: json.verification_uri_complete,
+		expiresInSeconds: toSeconds(
+			json.expires_in,
+			DEFAULT_DEVICE_AUTH_EXPIRES_IN_SECONDS,
+		),
+		pollIntervalSeconds: toSeconds(
+			json.interval,
+			DEFAULT_DEVICE_AUTH_INTERVAL_SECONDS,
+		),
+	};
+}
+
+async function pollWorkOSTokens(options: {
+	clientId: string;
+	deviceCode: string;
+	expiresInSeconds: number;
+	initialPollIntervalSeconds: number;
+	requestTimeoutMs: number;
+	workosApiBaseUrl: string;
+	onProgress?: OAuthLoginCallbacks["onProgress"];
+}): Promise<WorkOSTokenSuccess> {
+	const deadline = Date.now() + options.expiresInSeconds * 1000;
+	let intervalSeconds = Math.max(1, options.initialPollIntervalSeconds);
+
+	while (Date.now() <= deadline) {
+		const response = await fetch(
+			resolveUrl(
+				options.workosApiBaseUrl,
+				DEFAULT_WORKOS_ENDPOINTS.authenticate,
+			),
+			{
+				method: "POST",
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+				},
+				body: new URLSearchParams({
+					grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+					device_code: options.deviceCode,
+					client_id: options.clientId,
+				}),
+				signal: AbortSignal.timeout(options.requestTimeoutMs),
+			},
+		);
+		const payload = (await response
+			.json()
+			.catch(() => ({}))) as WorkOSTokenResponse;
+		if (response.ok) {
+			if (!payload.access_token || !payload.refresh_token) {
+				throw new Error("Invalid WorkOS token response");
+			}
+			return {
+				accessToken: payload.access_token,
+				refreshToken: payload.refresh_token,
+				tokenType: payload.token_type ?? "Bearer",
+			};
+		}
+
+		switch (payload.error) {
+			case "authorization_pending": {
+				await sleep(intervalSeconds * 1000);
+				break;
+			}
+			case "slow_down": {
+				intervalSeconds += 1;
+				await sleep(intervalSeconds * 1000);
+				break;
+			}
+			case "access_denied":
+			case "expired_token":
+			case "invalid_grant": {
+				throw new ClineOAuthTokenError(
+					payload.error_description || "WorkOS authorization failed",
+					{
+						status: response.status,
+						errorCode: payload.error,
+					},
+				);
+			}
+			default: {
+				throw new ClineOAuthTokenError(
+					`WorkOS token polling failed: ${response.status}${payload.error_description ? ` - ${payload.error_description}` : ""}`,
+					{
+						status: response.status,
+						errorCode: payload.error,
+					},
+				);
+			}
+		}
+
+		options.onProgress?.("Waiting for browser authentication confirmation...");
+	}
+
+	throw new Error("WorkOS device authorization timed out");
+}
+
+async function registerWorkOSTokens(
+	workosTokens: WorkOSTokenSuccess,
+	options: ClineOAuthProviderOptions,
+	provider?: string,
+): Promise<ClineOAuthCredentials> {
+	const body = {
+		accessToken: workosTokens.accessToken,
+		refreshToken: workosTokens.refreshToken,
+	};
+
+	const response = await fetch(
+		resolveUrl(options.apiBaseUrl, DEFAULT_AUTH_ENDPOINTS.register),
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...(await resolveHeaders(options.headers)),
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(
+				options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
+			),
+		},
+	);
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		const details = parseOAuthError(text);
+		throw new ClineOAuthTokenError(
+			`Token registration failed: ${response.status}${details.message ? ` - ${details.message}` : ""}`,
+			{ status: response.status, errorCode: details.code },
+		);
+	}
+
+	const json = (await response.json()) as ClineTokenResponse;
+	return toClineCredentials(
+		requireClineTokenResponse(json, "Invalid token exchange response"),
+		provider ?? options.provider,
+	);
+}
+
+async function exchangeAuthorizationCode(
+	code: string,
+	callbackUrl: string,
+	options: ClineOAuthProviderOptions,
+	provider?: string,
+): Promise<ClineOAuthCredentials> {
+	const body = {
+		grant_type: "authorization_code",
+		code,
+		client_type: "extension",
+		redirect_uri: callbackUrl,
+		provider: provider ?? options.provider,
+	};
+
+	const response = await fetch(
+		resolveUrl(options.apiBaseUrl, DEFAULT_AUTH_ENDPOINTS.token),
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...(await resolveHeaders(options.headers)),
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(
+				options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
+			),
+		},
+	);
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		const details = parseOAuthError(text);
+		throw new ClineOAuthTokenError(
+			`Token exchange failed: ${response.status}${details.message ? ` - ${details.message}` : ""}`,
+			{ status: response.status, errorCode: details.code },
+		);
+	}
+
+	const json = (await response.json()) as ClineTokenResponse;
+	return toClineCredentials(
+		requireClineTokenResponse(json, "Invalid token exchange response"),
+		provider ?? options.provider,
+	);
+}
+
+export async function loginClineOAuth(
+	options: ClineOAuthProviderOptions & {
+		callbacks: OAuthLoginCallbacks;
+	},
+): Promise<ClineOAuthCredentials> {
+	captureAuthStarted(options.telemetry, options.provider ?? "cline");
+	const useWorkOSDeviceAuth = options.useWorkOSDeviceAuth ?? true;
+	const callbackPorts = options.callbackPorts?.length
+		? options.callbackPorts
+		: DEFAULT_CALLBACK_PORTS;
+	const callbackPath = options.callbackPath ?? DEFAULT_CALLBACK_PATH;
+	const localServer = useWorkOSDeviceAuth
+		? null
+		: await startLocalOAuthServer({
+				ports: callbackPorts,
+				callbackPath,
+				onListening: options.callbacks.onServerListening,
+				onClose: options.callbacks.onServerClose,
+			});
+	const callbackUrl =
+		localServer?.callbackUrl ||
+		`http://127.0.0.1:${callbackPorts[0] ?? DEFAULT_CALLBACK_PORTS[0]}${callbackPath}`;
+
+	try {
+		let credentials: ClineOAuthCredentials;
+		if (useWorkOSDeviceAuth) {
+			const clientId = getClineEnvironmentConfig().workOsClientId;
+			const deviceAuthorization = await requestWorkOSDeviceAuthorization(
+				clientId,
+				options,
+			);
+			options.callbacks.onAuth({
+				url:
+					deviceAuthorization.verificationUriComplete ??
+					deviceAuthorization.verificationUri,
+				instructions: `Enter this code in your browser: ${deviceAuthorization.userCode}`,
+			});
+
+			const workosTokens = await pollWorkOSTokens({
+				clientId,
+				deviceCode: deviceAuthorization.deviceCode,
+				expiresInSeconds: deviceAuthorization.expiresInSeconds,
+				initialPollIntervalSeconds: deviceAuthorization.pollIntervalSeconds,
+				requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
+				workosApiBaseUrl: DEFAULT_WORKOS_API_BASE_URL,
+				onProgress: options.callbacks.onProgress,
+			});
+
+			credentials = await registerWorkOSTokens(
+				workosTokens,
+				options,
+				options.provider,
+			);
+		} else {
+			const authUrl = new URL(
+				resolveUrl(options.apiBaseUrl, DEFAULT_AUTH_ENDPOINTS.authorize),
+			);
+			authUrl.searchParams.set("client_type", "extension");
+			authUrl.searchParams.set("callback_url", callbackUrl);
+			authUrl.searchParams.set("redirect_uri", callbackUrl);
+			options.callbacks.onAuth({
+				url: authUrl.toString(),
+				instructions: "Continue the authentication process in your browser.",
+			});
+
+			let code: string | undefined;
+			let provider = options.provider;
+			const authResult = await resolveAuthorizationCodeInput({
+				waitForCallback: localServer?.waitForCallback ?? (async () => null),
+				cancelWait: localServer?.cancelWait ?? (() => {}),
+				onManualCodeInput: options.callbacks.onManualCodeInput,
+				parseOptions: { includeProvider: true },
+			});
+			if (authResult.error) {
+				throw new Error(`OAuth error: ${authResult.error}`);
+			}
+			code = authResult.code;
+			provider = authResult.provider ?? provider;
+			if (!code) {
+				const input = await options.callbacks.onPrompt({
+					message: "Paste the authorization code (or full redirect URL):",
+				});
+				const parsed = parseAuthorizationInput(input, {
+					includeProvider: true,
+				});
+				code = parsed.code;
+				provider = parsed.provider ?? provider;
+			}
+			if (!code) {
+				throw new Error("Missing authorization code");
+			}
+			credentials = await exchangeAuthorizationCode(
+				code,
+				callbackUrl,
+				options,
+				provider,
+			);
+		}
+
+		captureAuthSucceeded(options.telemetry, options.provider ?? "cline");
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: options.provider ?? "cline",
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			options.provider ?? "cline",
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
+	} finally {
+		localServer?.close();
+	}
+}
+
+export async function startClineDeviceAuth(options?: {
+	requestTimeoutMs?: number;
+}): Promise<{
+	deviceCode: string;
+	userCode: string;
+	verificationUri: string;
+	verificationUriComplete?: string;
+	expiresInSeconds: number;
+	pollIntervalSeconds: number;
+}> {
+	return await requestWorkOSDeviceAuthorization(
+		getClineEnvironmentConfig().workOsClientId,
+		options,
+	);
+}
+
+export async function completeClineDeviceAuth(options: {
+	deviceCode: string;
+	expiresInSeconds: number;
+	pollIntervalSeconds: number;
+	apiBaseUrl: string;
+	provider?: string;
+	headers?: HeaderInput;
+	requestTimeoutMs?: number;
+	telemetry?: ITelemetryService;
+}): Promise<ClineOAuthCredentials> {
+	const providerName = options.provider ?? "cline";
+	captureAuthStarted(options.telemetry, providerName);
+	try {
+		const workosTokens = await pollWorkOSTokens({
+			clientId: getClineEnvironmentConfig().workOsClientId,
+			deviceCode: options.deviceCode,
+			expiresInSeconds: options.expiresInSeconds,
+			initialPollIntervalSeconds: options.pollIntervalSeconds,
+			requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
+			workosApiBaseUrl: DEFAULT_WORKOS_API_BASE_URL,
+		});
+		const credentials = await registerWorkOSTokens(
+			workosTokens,
+			{
+				apiBaseUrl: options.apiBaseUrl,
+				headers: options.headers,
+				requestTimeoutMs: options.requestTimeoutMs,
+				provider: options.provider,
+			},
+			options.provider,
+		);
+		captureAuthSucceeded(options.telemetry, providerName);
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: providerName,
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			providerName,
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
+	}
+}
+
+export async function refreshClineToken(
+	current: ClineOAuthCredentials,
+	options: ClineOAuthProviderOptions,
+): Promise<ClineOAuthCredentials> {
+	const refreshUrl = resolveUrl(options.apiBaseUrl, DEFAULT_AUTH_ENDPOINTS.refresh);
+	sdkDebug(`cline.refresh.request url=${refreshUrl} refreshTokenHash=${hashSecret(current.refresh)}`);
+	const response = await fetch(
+		refreshUrl,
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...(await resolveHeaders(options.headers)),
+			},
+			body: JSON.stringify({
+				refreshToken: current.refresh,
+				grantType: "refresh_token",
+			}),
+			signal: AbortSignal.timeout(
+				options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
+			),
+		},
+	);
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		const details = parseOAuthError(text);
+		sdkDebug(`cline.refresh.error status=${response.status} errorCode=${details.code ?? "none"} message=${details.message ?? "none"}`);
+		throw new ClineOAuthTokenError(
+			`Token refresh failed: ${response.status}${details.message ? ` - ${details.message}` : ""}`,
+			{ status: response.status, errorCode: details.code },
+		);
+	}
+
+	const json = (await response.json()) as ClineTokenResponse;
+	const provider =
+		(current.metadata?.provider as string | undefined) ?? options.provider;
+	const result = toClineCredentials(
+		requireClineTokenResponse(json, "Invalid token refresh response"),
+		provider,
+		current,
+	);
+	sdkDebug(`cline.refresh.success newAccessTokenHash=${hashSecret(result.access)} newRefreshTokenHash=${hashSecret(result.refresh)} expires=${result.expires}`);
+	return result;
+}
+
+export async function getValidClineCredentials(
+	currentCredentials: ClineOAuthCredentials | null,
+	providerOptions: ClineOAuthProviderOptions,
+	options?: ClineTokenResolution,
+): Promise<ClineOAuthCredentials | null> {
+	if (!currentCredentials) {
+		sdkDebug("cline.getCredentials outcome=no_current_credentials");
+		return null;
+	}
+
+	const refreshBufferMs = options?.refreshBufferMs ?? DEFAULT_REFRESH_BUFFER_MS;
+	const retryableTokenGraceMs =
+		options?.retryableTokenGraceMs ?? DEFAULT_RETRYABLE_TOKEN_GRACE_MS;
+	const forceRefresh = options?.forceRefresh === true;
+
+	if (
+		!forceRefresh &&
+		!isCredentialLikelyExpired(currentCredentials, refreshBufferMs)
+	) {
+		sdkDebug(`cline.getCredentials outcome=still_valid forceRefresh=${forceRefresh}`);
+		return currentCredentials;
+	}
+
+	sdkDebug(`cline.getCredentials outcome=needs_refresh forceRefresh=${forceRefresh} accessTokenHash=${hashSecret(currentCredentials.access)}`);
+
+	try {
+		return await refreshClineToken(currentCredentials, providerOptions);
+	} catch (error) {
+		if (error instanceof ClineOAuthTokenError && error.isLikelyInvalidGrant()) {
+			sdkDebug(`cline.getCredentials outcome=invalid_grant status=${error.status} errorCode=${error.errorCode ?? "none"}`);
+			captureAuthLoggedOut(
+				providerOptions.telemetry,
+				providerOptions.provider ?? "cline",
+				"invalid_grant",
+			);
+			return null;
+		}
+		if (currentCredentials.expires - Date.now() > retryableTokenGraceMs) {
+			// Keep current token on transient refresh failures while still valid.
+			sdkDebug(`cline.getCredentials outcome=transient_failure_kept_current error=${error instanceof Error ? error.message : String(error)}`);
+			return currentCredentials;
+		}
+		sdkDebug(`cline.getCredentials outcome=transient_failure_expired error=${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
diff --git a/sdk/packages/core/src/auth/codex.test.ts b/sdk/packages/core/src/auth/codex.test.ts
new file mode 100644
index 0000000..bae94de
--- /dev/null
+++ b/sdk/packages/core/src/auth/codex.test.ts
@@ -0,0 +1,156 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	getValidOpenAICodexCredentials,
+	refreshOpenAICodexToken,
+} from "./codex";
+import type { OAuthCredentials } from "./types";
+
+function toBase64Url(value: string): string {
+	return Buffer.from(value, "utf8").toString("base64url");
+}
+
+function createJwt(payload: Record<string, unknown>): string {
+	return `${toBase64Url(JSON.stringify({ alg: "none", typ: "JWT" }))}.${toBase64Url(JSON.stringify(payload))}.sig`;
+}
+
+function createCredentials(
+	overrides: Partial<OAuthCredentials> = {},
+): OAuthCredentials {
+	return {
+		access: "access-old",
+		refresh: "refresh-old",
+		expires: 0,
+		accountId: "acct-old",
+		email: "old@example.com",
+		metadata: { provider: "openai-codex" },
+		...overrides,
+	};
+}
+
+describe("auth/codex token lifecycle", () => {
+	afterEach(() => {
+		vi.unstubAllGlobals();
+		vi.restoreAllMocks();
+	});
+
+	it("returns current credentials when not expired", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(10_000);
+		const current = createCredentials({ expires: 400_000 });
+		const fetchMock = vi.fn();
+		vi.stubGlobal("fetch", fetchMock);
+
+		const result = await getValidOpenAICodexCredentials(current);
+		expect(result).toBe(current);
+		expect(fetchMock).not.toHaveBeenCalled();
+		nowSpy.mockRestore();
+	});
+
+	it("refreshes expired credentials and preserves provider metadata", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const idToken = createJwt({
+			"https://api.openai.com/auth": { chatgpt_account_id: "acct-new" },
+			email: "new@example.com",
+		});
+		const accessToken = createJwt({
+			"https://api.openai.com/auth": { chatgpt_account_id: "acct-new" },
+		});
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(
+				async () =>
+					new Response(
+						JSON.stringify({
+							access_token: accessToken,
+							refresh_token: "refresh-new",
+							expires_in: 3600,
+							email: "new@example.com",
+							id_token: idToken,
+						}),
+						{ status: 200, headers: { "Content-Type": "application/json" } },
+					),
+			),
+		);
+
+		const current = createCredentials({ expires: 110_000 });
+		const result = await getValidOpenAICodexCredentials(current);
+		expect(result).toMatchObject({
+			access: accessToken,
+			refresh: "refresh-new",
+			accountId: "acct-new",
+			email: "new@example.com",
+			metadata: { provider: "openai-codex" },
+		});
+		nowSpy.mockRestore();
+	});
+
+	it("returns null on invalid_grant refresh errors", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "invalid_grant",
+							error_description: "token revoked",
+						}),
+						{
+							status: 400,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			),
+		);
+
+		const result = await getValidOpenAICodexCredentials(
+			createCredentials({ expires: 120_000 }),
+		);
+		expect(result).toBeNull();
+		nowSpy.mockRestore();
+	});
+
+	it("keeps current credentials on non-invalid transient refresh failures when still valid", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "server_error",
+							error_description: "try again",
+						}),
+						{
+							status: 500,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			),
+		);
+
+		const current = createCredentials({ expires: 150_000 });
+		const result = await getValidOpenAICodexCredentials(current, {
+			refreshBufferMs: 60_000,
+			retryableTokenGraceMs: 30_000,
+		});
+		expect(result).toBe(current);
+		nowSpy.mockRestore();
+	});
+
+	it("refreshOpenAICodexToken throws when response is structurally invalid", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(
+				async () =>
+					new Response(JSON.stringify({ access_token: "only-access" }), {
+						status: 200,
+						headers: { "Content-Type": "application/json" },
+					}),
+			),
+		);
+
+		await expect(refreshOpenAICodexToken("refresh")).rejects.toThrow(
+			"Failed to refresh OpenAI Codex token",
+		);
+	});
+});
diff --git a/sdk/packages/core/src/auth/codex.ts b/sdk/packages/core/src/auth/codex.ts
new file mode 100644
index 0000000..8ce6233
--- /dev/null
+++ b/sdk/packages/core/src/auth/codex.ts
@@ -0,0 +1,439 @@
+/**
+ * OpenAI Codex (ChatGPT OAuth) flow
+ *
+ * NOTE: This module uses Node.js crypto and http for the OAuth callback.
+ * It is only intended for CLI use, not browser environments.
+ */
+
+import type { ITelemetryService } from "@cline/shared";
+import { nanoid } from "nanoid";
+import {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	identifyAccount,
+} from "../services/telemetry/core-events";
+import { startLocalOAuthServer } from "./server";
+import type { OAuthCredentials, OAuthPrompt } from "./types";
+import {
+	decodeJwtPayload,
+	getProofKey,
+	isCredentialLikelyExpired,
+	parseAuthorizationInput,
+	parseOAuthError,
+	resolveAuthorizationCodeInput,
+} from "./utils";
+
+export const OPENAI_CODEX_OAUTH_CONFIG = {
+	authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
+	tokenEndpoint: "https://auth.openai.com/oauth/token",
+	clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+	redirectUri: "http://localhost:1455/auth/callback",
+	scopes: "openid profile email offline_access",
+	callbackPort: 1455,
+	jwtClaimPath: "https://api.openai.com/auth",
+	refreshBufferMs: 5 * 60 * 1000,
+	retryableTokenGraceMs: 30 * 1000,
+	httpTimeoutMs: 30 * 1000,
+} as const;
+
+type CodexTokenSuccess = {
+	type: "success";
+	access: string;
+	refresh: string;
+	expires: number;
+	email?: string;
+	idToken?: string;
+};
+type CodexTokenFailure = { type: "failed" };
+type CodexTokenResult = CodexTokenSuccess | CodexTokenFailure;
+export type RefreshTokenResolution = {
+	forceRefresh?: boolean;
+	refreshBufferMs?: number;
+	retryableTokenGraceMs?: number;
+};
+
+type JwtPayload = {
+	[OPENAI_CODEX_OAUTH_CONFIG.jwtClaimPath]?: {
+		chatgpt_account_id?: string;
+	};
+	[key: string]: unknown;
+};
+
+class OpenAICodexOAuthTokenError extends Error {
+	public readonly status?: number;
+	public readonly errorCode?: string;
+
+	constructor(message: string, opts?: { status?: number; errorCode?: string }) {
+		super(message);
+		this.name = "OpenAICodexOAuthTokenError";
+		this.status = opts?.status;
+		this.errorCode = opts?.errorCode;
+	}
+
+	public isLikelyInvalidGrant(): boolean {
+		if (this.errorCode && /invalid_grant/i.test(this.errorCode)) {
+			return true;
+		}
+		if (this.status === 400 || this.status === 401 || this.status === 403) {
+			return /invalid_grant|revoked|expired|invalid refresh/i.test(
+				this.message,
+			);
+		}
+		return false;
+	}
+}
+
+async function exchangeAuthorizationCode(
+	code: string,
+	verifier: string,
+	redirectUri: string = OPENAI_CODEX_OAUTH_CONFIG.redirectUri,
+): Promise<CodexTokenResult> {
+	const response = await fetch(OPENAI_CODEX_OAUTH_CONFIG.tokenEndpoint, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "authorization_code",
+			client_id: OPENAI_CODEX_OAUTH_CONFIG.clientId,
+			code,
+			code_verifier: verifier,
+			redirect_uri: redirectUri,
+		}),
+		signal: AbortSignal.timeout(OPENAI_CODEX_OAUTH_CONFIG.httpTimeoutMs),
+	});
+
+	if (!response.ok) {
+		return { type: "failed" };
+	}
+
+	const json = (await response.json()) as {
+		access_token?: string;
+		refresh_token?: string;
+		expires_in?: number;
+		email?: string;
+		id_token?: string;
+	};
+
+	if (
+		!json.access_token ||
+		!json.refresh_token ||
+		typeof json.expires_in !== "number"
+	) {
+		return { type: "failed" };
+	}
+
+	return {
+		type: "success",
+		access: json.access_token,
+		refresh: json.refresh_token,
+		expires: Date.now() + json.expires_in * 1000,
+		email: json.email,
+		idToken: json.id_token,
+	};
+}
+
+async function refreshAccessToken(
+	refreshToken: string,
+): Promise<CodexTokenResult> {
+	try {
+		const response = await fetch(OPENAI_CODEX_OAUTH_CONFIG.tokenEndpoint, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "refresh_token",
+				refresh_token: refreshToken,
+				client_id: OPENAI_CODEX_OAUTH_CONFIG.clientId,
+			}),
+			signal: AbortSignal.timeout(OPENAI_CODEX_OAUTH_CONFIG.httpTimeoutMs),
+		});
+
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			const details = parseOAuthError(text);
+			throw new OpenAICodexOAuthTokenError(
+				`Token refresh failed: ${response.status}${details.message ? ` - ${details.message}` : ""}`,
+				{ status: response.status, errorCode: details.code },
+			);
+		}
+
+		const json = (await response.json()) as {
+			access_token?: string;
+			refresh_token?: string;
+			expires_in?: number;
+			email?: string;
+			id_token?: string;
+		};
+
+		if (
+			!json.access_token ||
+			!json.refresh_token ||
+			typeof json.expires_in !== "number"
+		) {
+			return { type: "failed" };
+		}
+
+		return {
+			type: "success",
+			access: json.access_token,
+			refresh: json.refresh_token,
+			expires: Date.now() + json.expires_in * 1000,
+			email: json.email,
+			idToken: json.id_token,
+		};
+	} catch (error) {
+		if (error instanceof OpenAICodexOAuthTokenError) {
+			throw error;
+		}
+		return { type: "failed" };
+	}
+}
+
+async function createAuthorizationFlow(
+	originator = "pi",
+): Promise<{ verifier: string; state: string; url: string }> {
+	const { verifier, challenge } = await getProofKey();
+	const state = nanoid(32);
+
+	const url = new URL(OPENAI_CODEX_OAUTH_CONFIG.authorizationEndpoint);
+	url.searchParams.set("response_type", "code");
+	url.searchParams.set("client_id", OPENAI_CODEX_OAUTH_CONFIG.clientId);
+	url.searchParams.set("redirect_uri", OPENAI_CODEX_OAUTH_CONFIG.redirectUri);
+	url.searchParams.set("scope", OPENAI_CODEX_OAUTH_CONFIG.scopes);
+	url.searchParams.set("code_challenge", challenge);
+	url.searchParams.set("code_challenge_method", "S256");
+	url.searchParams.set("state", state);
+	url.searchParams.set("id_token_add_organizations", "true");
+	url.searchParams.set("codex_cli_simplified_flow", "true");
+	url.searchParams.set("originator", originator);
+
+	return { verifier, state, url: url.toString() };
+}
+
+function resolveCallbackServerConfig(): {
+	host: string;
+	port: number;
+	callbackPath: string;
+	redirectUri: string;
+} {
+	try {
+		const redirect = new URL(OPENAI_CODEX_OAUTH_CONFIG.redirectUri);
+		const parsedPort =
+			redirect.port.length > 0
+				? Number.parseInt(redirect.port, 10)
+				: OPENAI_CODEX_OAUTH_CONFIG.callbackPort;
+		return {
+			host: redirect.hostname || "localhost",
+			port: Number.isFinite(parsedPort)
+				? parsedPort
+				: OPENAI_CODEX_OAUTH_CONFIG.callbackPort,
+			callbackPath: redirect.pathname || "/auth/callback",
+			redirectUri: redirect.toString(),
+		};
+	} catch {
+		return {
+			host: "localhost",
+			port: OPENAI_CODEX_OAUTH_CONFIG.callbackPort,
+			callbackPath: "/auth/callback",
+			redirectUri: OPENAI_CODEX_OAUTH_CONFIG.redirectUri,
+		};
+	}
+}
+
+function getAccountId(accessToken: string, idToken?: string): string | null {
+	const payload = (
+		idToken ? decodeJwtPayload(idToken) : decodeJwtPayload(accessToken)
+	) as JwtPayload | null;
+	const fallback = (
+		payload ? payload : decodeJwtPayload(accessToken)
+	) as JwtPayload | null;
+	const auth = fallback?.[OPENAI_CODEX_OAUTH_CONFIG.jwtClaimPath];
+	const accountId = auth?.chatgpt_account_id;
+	if (typeof accountId === "string" && accountId.length > 0) {
+		return accountId;
+	}
+
+	const organizations = fallback?.organizations;
+	if (Array.isArray(organizations) && organizations.length > 0) {
+		const first = organizations[0] as { id?: unknown } | undefined;
+		if (typeof first?.id === "string" && first.id.length > 0) {
+			return first.id;
+		}
+	}
+
+	const rootAccountId = fallback?.chatgpt_account_id;
+	if (typeof rootAccountId === "string" && rootAccountId.length > 0) {
+		return rootAccountId;
+	}
+
+	return null;
+}
+
+function toCodexCredentials(
+	result: CodexTokenSuccess,
+	fallback?: OAuthCredentials,
+): OAuthCredentials {
+	const accountId =
+		getAccountId(result.access, result.idToken) ?? fallback?.accountId;
+	if (!accountId) {
+		throw new Error("Failed to extract accountId from token");
+	}
+
+	return {
+		access: result.access,
+		refresh: result.refresh || fallback?.refresh || "",
+		expires: result.expires,
+		accountId,
+		email: result.email ?? fallback?.email,
+		metadata: {
+			...(fallback?.metadata ?? {}),
+			provider: "openai-codex",
+		},
+	};
+}
+
+export async function loginOpenAICodex(options: {
+	onAuth: (info: { url: string; instructions?: string }) => void;
+	onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+	onProgress?: (message: string) => void;
+	onManualCodeInput?: () => Promise<string>;
+	originator?: string;
+	telemetry?: ITelemetryService;
+}): Promise<OAuthCredentials> {
+	captureAuthStarted(options.telemetry, "openai-codex");
+	const callbackConfig = resolveCallbackServerConfig();
+	const { verifier, state, url } = await createAuthorizationFlow(
+		options.originator,
+	);
+	const server = await startLocalOAuthServer({
+		host: callbackConfig.host,
+		ports: [callbackConfig.port],
+		callbackPath: callbackConfig.callbackPath,
+		expectedState: state,
+	});
+
+	options.onAuth({
+		url,
+		instructions: "Continue the authentication process in your browser.",
+	});
+
+	let code: string | undefined;
+	try {
+		const authResult = await resolveAuthorizationCodeInput({
+			waitForCallback: server.waitForCallback,
+			cancelWait: server.cancelWait,
+			onManualCodeInput: options.onManualCodeInput,
+			parseOptions: { allowHashCodeState: true },
+		});
+		if (authResult.state && authResult.state !== state) {
+			throw new Error("State mismatch");
+		}
+		code = authResult.code;
+
+		// Fallback to onPrompt if still no code
+		if (!code) {
+			const input = await options.onPrompt({
+				message: "Paste the authorization code (or full redirect URL):",
+			});
+			const parsed = parseAuthorizationInput(input, {
+				allowHashCodeState: true,
+			});
+			if (parsed.state && parsed.state !== state) {
+				throw new Error("State mismatch");
+			}
+			code = parsed.code;
+		}
+
+		if (!code) {
+			throw new Error("Missing authorization code");
+		}
+
+		const tokenResult = await exchangeAuthorizationCode(
+			code,
+			verifier,
+			callbackConfig.redirectUri,
+		);
+		if (tokenResult.type !== "success") {
+			throw new Error("Token exchange failed");
+		}
+
+		const credentials = toCodexCredentials(tokenResult);
+		captureAuthSucceeded(options.telemetry, "openai-codex");
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: "openai-codex",
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			"openai-codex",
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
+	} finally {
+		server.close();
+	}
+}
+
+export async function refreshOpenAICodexToken(
+	refreshToken: string,
+	fallback?: OAuthCredentials,
+): Promise<OAuthCredentials> {
+	const result = await refreshAccessToken(refreshToken);
+	if (result.type !== "success") {
+		throw new Error("Failed to refresh OpenAI Codex token");
+	}
+
+	const normalized = toCodexCredentials(result, fallback);
+	if (!normalized.refresh) {
+		throw new Error(
+			"Failed to refresh OpenAI Codex token: missing refresh token",
+		);
+	}
+	return normalized;
+}
+
+export async function getValidOpenAICodexCredentials(
+	currentCredentials: OAuthCredentials | null,
+	options?: RefreshTokenResolution & { telemetry?: ITelemetryService },
+): Promise<OAuthCredentials | null> {
+	if (!currentCredentials) {
+		return null;
+	}
+
+	const refreshBufferMs =
+		options?.refreshBufferMs ?? OPENAI_CODEX_OAUTH_CONFIG.refreshBufferMs;
+	const retryableTokenGraceMs =
+		options?.retryableTokenGraceMs ??
+		OPENAI_CODEX_OAUTH_CONFIG.retryableTokenGraceMs;
+	const forceRefresh = options?.forceRefresh === true;
+
+	if (
+		!forceRefresh &&
+		!isCredentialLikelyExpired(currentCredentials, refreshBufferMs)
+	) {
+		return currentCredentials;
+	}
+
+	try {
+		const refreshed = await refreshOpenAICodexToken(
+			currentCredentials.refresh,
+			currentCredentials,
+		);
+		return refreshed;
+	} catch (error) {
+		if (
+			error instanceof OpenAICodexOAuthTokenError &&
+			error.isLikelyInvalidGrant()
+		) {
+			captureAuthLoggedOut(options?.telemetry, "openai-codex", "invalid_grant");
+			return null;
+		}
+		if (currentCredentials.expires - Date.now() > retryableTokenGraceMs) {
+			return currentCredentials;
+		}
+		return null;
+	}
+}
diff --git a/sdk/packages/core/src/auth/oca.test.ts b/sdk/packages/core/src/auth/oca.test.ts
new file mode 100644
index 0000000..6f886ac
--- /dev/null
+++ b/sdk/packages/core/src/auth/oca.test.ts
@@ -0,0 +1,340 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getValidOcaCredentials } from "./oca";
+import type { OAuthCredentials } from "./types";
+
+function toBase64Url(value: string): string {
+	return Buffer.from(value, "utf8").toString("base64url");
+}
+
+function createJwt(payload: Record<string, unknown>): string {
+	return `${toBase64Url(JSON.stringify({ alg: "none", typ: "JWT" }))}.${toBase64Url(JSON.stringify(payload))}.sig`;
+}
+
+function createCredentials(
+	overrides: Partial<OAuthCredentials> = {},
+): OAuthCredentials {
+	return {
+		access: "access-old",
+		refresh: "refresh-old",
+		expires: 0,
+		accountId: "acct-old",
+		email: "old@example.com",
+		metadata: { provider: "oca", mode: "internal" },
+		...overrides,
+	};
+}
+
+describe("auth/oca getValidOcaCredentials", () => {
+	afterEach(() => {
+		vi.unstubAllGlobals();
+		vi.restoreAllMocks();
+	});
+
+	it("returns current credentials when token is still fresh", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(10_000);
+		const current = createCredentials({ expires: 400_000 });
+		const fetchMock = vi.fn();
+		vi.stubGlobal("fetch", fetchMock);
+
+		const result = await getValidOcaCredentials(current);
+		expect(result).toBe(current);
+		expect(fetchMock).not.toHaveBeenCalled();
+		nowSpy.mockRestore();
+	});
+
+	it("refreshes an expired token after discovery", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const idToken = createJwt({
+			sub: "acct-new",
+			email: "new@example.com",
+			exp: 2_000_000_000,
+		});
+
+		const fetchMock = vi
+			.fn()
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							token_endpoint: "https://idcs.example.com/oauth2/v1/token",
+						}),
+						{
+							status: 200,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			)
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							access_token: createJwt({
+								sub: "acct-new",
+								email: "new@example.com",
+								exp: 2_000_000_000,
+							}),
+							refresh_token: "refresh-new",
+							id_token: idToken,
+						}),
+						{ status: 200, headers: { "Content-Type": "application/json" } },
+					),
+			);
+
+		vi.stubGlobal("fetch", fetchMock);
+
+		const result = await getValidOcaCredentials(
+			createCredentials({ expires: 101_000 }),
+			undefined,
+			{
+				config: {
+					internal: {
+						clientId: "client-1",
+						idcsUrl: "https://idcs.example.com",
+						scopes: "openid offline_access",
+						baseUrl: "https://oca.example.com",
+					},
+				},
+			},
+		);
+
+		expect(result).toMatchObject({
+			access: expect.any(String),
+			refresh: "refresh-new",
+			accountId: "acct-new",
+			email: "new@example.com",
+			metadata: {
+				provider: "oca",
+				mode: "internal",
+			},
+		});
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+		nowSpy.mockRestore();
+	});
+
+	it("returns null when refresh fails with invalid_grant", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const fetchMock = vi
+			.fn()
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							token_endpoint: "https://idcs.invalid/oauth2/v1/token",
+						}),
+						{
+							status: 200,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			)
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "invalid_grant",
+							error_description: "expired refresh token",
+						}),
+						{
+							status: 400,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			);
+		vi.stubGlobal("fetch", fetchMock);
+
+		const result = await getValidOcaCredentials(
+			createCredentials({ expires: 101_000 }),
+			undefined,
+			{
+				config: {
+					internal: {
+						clientId: "client-2",
+						idcsUrl: "https://idcs.invalid",
+						scopes: "openid offline_access",
+						baseUrl: "https://oca.example.com",
+					},
+				},
+			},
+		);
+		expect(result).toBeNull();
+		nowSpy.mockRestore();
+	});
+
+	it("keeps current credentials on transient refresh failures when access token is still usable", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const fetchMock = vi
+			.fn()
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							token_endpoint: "https://idcs.retry/oauth2/v1/token",
+						}),
+						{
+							status: 200,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			)
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "server_error",
+							error_description: "temporary issue",
+						}),
+						{
+							status: 500,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			);
+		vi.stubGlobal("fetch", fetchMock);
+
+		const current = createCredentials({ expires: 150_000 });
+		const result = await getValidOcaCredentials(
+			current,
+			{
+				refreshBufferMs: 60_000,
+				retryableTokenGraceMs: 30_000,
+			},
+			{
+				config: {
+					internal: {
+						clientId: "client-3",
+						idcsUrl: "https://idcs.retry",
+						scopes: "openid offline_access",
+						baseUrl: "https://oca.example.com",
+					},
+				},
+			},
+		);
+		expect(result).toBe(current);
+		nowSpy.mockRestore();
+	});
+
+	it("re-discovers token endpoint shortly after discovery fallback errors", async () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
+		const fetchMock = vi
+			.fn()
+			// first refresh: discovery fails and fallback endpoint is used
+			.mockImplementationOnce(async () => new Response(null, { status: 503 }))
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "server_error",
+							error_description: "temporary issue",
+						}),
+						{
+							status: 500,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			)
+			// second refresh within fallback TTL: discovery should still be cached
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "server_error",
+							error_description: "temporary issue",
+						}),
+						{
+							status: 500,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			)
+			// third refresh after fallback TTL: discovery should be retried
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							token_endpoint: "https://idcs.fallback/oauth2/v2/token",
+						}),
+						{
+							status: 200,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			)
+			.mockImplementationOnce(
+				async () =>
+					new Response(
+						JSON.stringify({
+							error: "server_error",
+							error_description: "temporary issue",
+						}),
+						{
+							status: 500,
+							headers: { "Content-Type": "application/json" },
+						},
+					),
+			);
+		vi.stubGlobal("fetch", fetchMock);
+
+		const current = createCredentials({ expires: 10_000_000 });
+		const providerOptions = {
+			config: {
+				internal: {
+					clientId: "client-fallback-ttl",
+					idcsUrl: "https://idcs.fallback",
+					scopes: "openid offline_access",
+					baseUrl: "https://oca.example.com",
+				},
+			},
+		};
+
+		const first = await getValidOcaCredentials(
+			current,
+			{ forceRefresh: true },
+			providerOptions,
+		);
+		expect(first).toBe(current);
+
+		nowSpy.mockReturnValue(200_000);
+		const second = await getValidOcaCredentials(
+			current,
+			{ forceRefresh: true },
+			providerOptions,
+		);
+		expect(second).toBe(current);
+
+		nowSpy.mockReturnValue(500_001);
+		const third = await getValidOcaCredentials(
+			current,
+			{ forceRefresh: true },
+			providerOptions,
+		);
+		expect(third).toBe(current);
+
+		expect(fetchMock).toHaveBeenCalledTimes(5);
+		expect(fetchMock).toHaveBeenNthCalledWith(
+			1,
+			"https://idcs.fallback/.well-known/openid-configuration",
+			expect.objectContaining({ method: "GET" }),
+		);
+		expect(fetchMock).toHaveBeenNthCalledWith(
+			2,
+			"https://idcs.fallback/oauth2/v1/token",
+			expect.objectContaining({ method: "POST" }),
+		);
+		expect(fetchMock).toHaveBeenNthCalledWith(
+			3,
+			"https://idcs.fallback/oauth2/v1/token",
+			expect.objectContaining({ method: "POST" }),
+		);
+		expect(fetchMock).toHaveBeenNthCalledWith(
+			4,
+			"https://idcs.fallback/.well-known/openid-configuration",
+			expect.objectContaining({ method: "GET" }),
+		);
+		expect(fetchMock).toHaveBeenNthCalledWith(
+			5,
+			"https://idcs.fallback/oauth2/v2/token",
+			expect.objectContaining({ method: "POST" }),
+		);
+		nowSpy.mockRestore();
+	});
+});
diff --git a/sdk/packages/core/src/auth/oca.ts b/sdk/packages/core/src/auth/oca.ts
new file mode 100644
index 0000000..209b04a
--- /dev/null
+++ b/sdk/packages/core/src/auth/oca.ts
@@ -0,0 +1,525 @@
+import type { ITelemetryService } from "@cline/shared";
+import { nanoid } from "nanoid";
+import {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	identifyAccount,
+} from "../services/telemetry/core-events";
+import { BoundedTtlCache } from "./bounded-ttl-cache";
+import { startLocalOAuthServer } from "./server";
+import type {
+	OAuthCredentials,
+	OAuthLoginCallbacks,
+	OcaMode,
+	OcaOAuthConfig,
+	OcaOAuthProviderOptions,
+	OcaTokenResolution,
+} from "./types";
+import {
+	decodeJwtPayload,
+	getProofKey,
+	isCredentialLikelyExpired,
+	normalizeBaseUrl,
+	resolveAuthorizationCodeInput,
+} from "./utils";
+
+export const DEFAULT_INTERNAL_IDCS_CLIENT_ID =
+	"a8331954c0cf48ba99b5dd223a14c6ea";
+export const DEFAULT_INTERNAL_IDCS_URL =
+	"https://idcs-9dc693e80d9b469480d7afe00e743931.identity.oraclecloud.com";
+export const DEFAULT_INTERNAL_IDCS_SCOPES = "openid offline_access";
+export const DEFAULT_INTERNAL_OCA_BASE_URL =
+	"https://code-internal.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+
+export const DEFAULT_EXTERNAL_IDCS_CLIENT_ID =
+	"c1aba3deed5740659981a752714eba33";
+export const DEFAULT_EXTERNAL_IDCS_URL =
+	"https://login-ext.identity.oraclecloud.com";
+export const DEFAULT_EXTERNAL_IDCS_SCOPES = "openid offline_access";
+export const DEFAULT_EXTERNAL_OCA_BASE_URL =
+	"https://code.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+
+export const OCI_HEADER_OPC_REQUEST_ID = "opc-request-id";
+
+const DEFAULT_CALLBACK_PATH = "/auth/oca";
+const DEFAULT_CALLBACK_PORTS = Array.from(
+	{ length: 11 },
+	(_, index) => 48801 + index,
+);
+const DEFAULT_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+const DEFAULT_RETRYABLE_TOKEN_GRACE_MS = 30 * 1000;
+const DEFAULT_HTTP_TIMEOUT_MS = 30 * 1000;
+const PKCE_STATE_TTL_MS = 10 * 60 * 1000;
+
+type OcaTokenResponse = {
+	access_token?: string;
+	refresh_token?: string;
+	expires_in?: number;
+	id_token?: string;
+	error?: string;
+	error_description?: string;
+};
+
+type OcaDiscoveryDocument = {
+	token_endpoint?: string;
+};
+
+type OcaAuthFlowState = {
+	verifier: string;
+	nonce: string;
+	mode: OcaMode;
+	redirectUri: string;
+	createdAt: number;
+};
+
+class OcaOAuthTokenError extends Error {
+	public readonly status?: number;
+	public readonly errorCode?: string;
+
+	constructor(message: string, opts?: { status?: number; errorCode?: string }) {
+		super(message);
+		this.name = "OcaOAuthTokenError";
+		this.status = opts?.status;
+		this.errorCode = opts?.errorCode;
+	}
+
+	public isLikelyInvalidGrant(): boolean {
+		if (
+			this.errorCode &&
+			/invalid_grant|invalid_token|unauthorized/i.test(this.errorCode)
+		) {
+			return true;
+		}
+		return this.status === 400 || this.status === 401 || this.status === 403;
+	}
+}
+
+const OCA_CONFIG_DEFAULTS: OcaOAuthConfig = {
+	internal: {
+		clientId: DEFAULT_INTERNAL_IDCS_CLIENT_ID,
+		idcsUrl: DEFAULT_INTERNAL_IDCS_URL,
+		scopes: DEFAULT_INTERNAL_IDCS_SCOPES,
+		baseUrl: DEFAULT_INTERNAL_OCA_BASE_URL,
+	},
+	external: {
+		clientId: DEFAULT_EXTERNAL_IDCS_CLIENT_ID,
+		idcsUrl: DEFAULT_EXTERNAL_IDCS_URL,
+		scopes: DEFAULT_EXTERNAL_IDCS_SCOPES,
+		baseUrl: DEFAULT_EXTERNAL_OCA_BASE_URL,
+	},
+};
+
+const OCA_FLOW_STATE = new Map<string, OcaAuthFlowState>();
+/** OpenID discovery documents change rarely; bound memory in long-lived processes. */
+const DISCOVERY_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const DISCOVERY_ERROR_FALLBACK_TTL_MS = 5 * 60 * 1000;
+const DISCOVERY_CACHE_MAX_ENTRIES = 32;
+const discoveryEndpointCache = new BoundedTtlCache(
+	DISCOVERY_CACHE_TTL_MS,
+	DISCOVERY_CACHE_MAX_ENTRIES,
+);
+
+function resolveMode(mode?: OcaMode | (() => OcaMode)): OcaMode {
+	if (typeof mode === "function") {
+		return mode();
+	}
+	return mode ?? "internal";
+}
+
+function resolveConfig(config?: Partial<OcaOAuthConfig>): OcaOAuthConfig {
+	return {
+		internal: {
+			clientId:
+				config?.internal?.clientId ?? OCA_CONFIG_DEFAULTS.internal.clientId,
+			idcsUrl:
+				config?.internal?.idcsUrl ?? OCA_CONFIG_DEFAULTS.internal.idcsUrl,
+			scopes: config?.internal?.scopes ?? OCA_CONFIG_DEFAULTS.internal.scopes,
+			baseUrl:
+				config?.internal?.baseUrl ?? OCA_CONFIG_DEFAULTS.internal.baseUrl,
+		},
+		external: {
+			clientId:
+				config?.external?.clientId ?? OCA_CONFIG_DEFAULTS.external.clientId,
+			idcsUrl:
+				config?.external?.idcsUrl ?? OCA_CONFIG_DEFAULTS.external.idcsUrl,
+			scopes: config?.external?.scopes ?? OCA_CONFIG_DEFAULTS.external.scopes,
+			baseUrl:
+				config?.external?.baseUrl ?? OCA_CONFIG_DEFAULTS.external.baseUrl,
+		},
+	};
+}
+
+function cleanupFlowState(now = Date.now()): void {
+	const cutoff = now - PKCE_STATE_TTL_MS;
+	for (const [state, value] of OCA_FLOW_STATE.entries()) {
+		if (value.createdAt < cutoff) {
+			OCA_FLOW_STATE.delete(state);
+		}
+	}
+}
+
+function resolveExpiryEpochMs(
+	response: OcaTokenResponse,
+	accessToken?: string,
+	idToken?: string,
+): number {
+	if (typeof response.expires_in === "number" && response.expires_in > 0) {
+		return Date.now() + response.expires_in * 1000;
+	}
+	const accessPayload = decodeJwtPayload(accessToken);
+	const accessExp = accessPayload?.exp;
+	if (typeof accessExp === "number" && accessExp > 0) {
+		return accessExp * 1000;
+	}
+	const idPayload = decodeJwtPayload(idToken);
+	const idExp = idPayload?.exp;
+	if (typeof idExp === "number" && idExp > 0) {
+		return idExp * 1000;
+	}
+	return Date.now() + 60 * 60 * 1000;
+}
+
+function toOcaCredentials(
+	response: OcaTokenResponse,
+	mode: OcaMode,
+	fallback?: OAuthCredentials,
+): OAuthCredentials {
+	const accessToken = response.access_token;
+	if (!accessToken) {
+		throw new Error("Token response did not include an access token");
+	}
+	const refreshToken = response.refresh_token ?? fallback?.refresh;
+	if (!refreshToken) {
+		throw new Error("Token response did not include a refresh token");
+	}
+
+	const idPayload = decodeJwtPayload(response.id_token);
+	const accessPayload = decodeJwtPayload(accessToken);
+	const sub =
+		(idPayload?.sub as string | undefined) ??
+		(accessPayload?.sub as string | undefined);
+	const email =
+		(idPayload?.email as string | undefined) ??
+		(accessPayload?.email as string | undefined);
+
+	return {
+		access: accessToken,
+		refresh: refreshToken,
+		expires: resolveExpiryEpochMs(response, accessToken, response.id_token),
+		accountId: sub ?? fallback?.accountId,
+		email: email ?? fallback?.email,
+		metadata: {
+			...(fallback?.metadata ?? {}),
+			provider: "oca",
+			mode,
+			subject: sub,
+			idToken: response.id_token,
+		},
+	};
+}
+
+async function discoverTokenEndpoint(
+	idcsUrl: string,
+	requestTimeoutMs: number,
+): Promise<string> {
+	const normalizedIdcsUrl = normalizeBaseUrl(idcsUrl);
+	const cached = discoveryEndpointCache.get(normalizedIdcsUrl);
+	if (cached) {
+		return cached;
+	}
+
+	const discoveryUrl = `${normalizedIdcsUrl}/.well-known/openid-configuration`;
+	const response = await fetch(discoveryUrl, {
+		method: "GET",
+		signal: AbortSignal.timeout(requestTimeoutMs),
+	});
+
+	if (!response.ok) {
+		const fallback = `${normalizedIdcsUrl}/oauth2/v1/token`;
+		discoveryEndpointCache.set(
+			normalizedIdcsUrl,
+			fallback,
+			Date.now(),
+			DISCOVERY_ERROR_FALLBACK_TTL_MS,
+		);
+		return fallback;
+	}
+
+	const discovery = (await response.json()) as OcaDiscoveryDocument;
+	const endpoint =
+		discovery.token_endpoint || `${normalizedIdcsUrl}/oauth2/v1/token`;
+	discoveryEndpointCache.set(normalizedIdcsUrl, endpoint);
+	return endpoint;
+}
+
+function parseOAuthErrorPayload(payload: OcaTokenResponse): {
+	code?: string;
+	message?: string;
+} {
+	return {
+		code: payload.error,
+		message: payload.error_description,
+	};
+}
+
+async function exchangeAuthorizationCode(input: {
+	code: string;
+	state: string;
+	mode: OcaMode;
+	config: OcaOAuthConfig;
+	requestTimeoutMs: number;
+}): Promise<OAuthCredentials> {
+	const flowState = OCA_FLOW_STATE.get(input.state);
+	if (!flowState) {
+		throw new Error("No PKCE verifier found for this state");
+	}
+	OCA_FLOW_STATE.delete(input.state);
+
+	const envConfig =
+		input.mode === "external" ? input.config.external : input.config.internal;
+	const tokenEndpoint = await discoverTokenEndpoint(
+		envConfig.idcsUrl,
+		input.requestTimeoutMs,
+	);
+
+	const body = new URLSearchParams({
+		grant_type: "authorization_code",
+		code: input.code,
+		redirect_uri: flowState.redirectUri,
+		client_id: envConfig.clientId,
+		code_verifier: flowState.verifier,
+	});
+
+	const response = await fetch(tokenEndpoint, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body,
+		signal: AbortSignal.timeout(input.requestTimeoutMs),
+	});
+
+	const tokenPayload = (await response.json()) as OcaTokenResponse;
+	if (!response.ok) {
+		const details = parseOAuthErrorPayload(tokenPayload);
+		throw new OcaOAuthTokenError(
+			`Token exchange failed: ${response.status}${details.message ? ` - ${details.message}` : ""}`,
+			{ status: response.status, errorCode: details.code },
+		);
+	}
+
+	const idPayload = decodeJwtPayload(tokenPayload.id_token);
+	if (!tokenPayload.id_token || !idPayload) {
+		throw new Error("No ID token received from OCA");
+	}
+	if (idPayload.nonce !== flowState.nonce) {
+		throw new Error("OIDC nonce verification failed");
+	}
+
+	return toOcaCredentials(tokenPayload, input.mode);
+}
+
+function buildAuthorizationUrl(input: {
+	callbackUrl: string;
+	mode: OcaMode;
+	state: string;
+	nonce: string;
+	challenge: string;
+	config: OcaOAuthConfig;
+}): string {
+	const envConfig =
+		input.mode === "external" ? input.config.external : input.config.internal;
+	const authorizeUrl = new URL(
+		`${normalizeBaseUrl(envConfig.idcsUrl)}/oauth2/v1/authorize`,
+	);
+	authorizeUrl.searchParams.set("client_id", envConfig.clientId);
+	authorizeUrl.searchParams.set("response_type", "code");
+	authorizeUrl.searchParams.set("scope", envConfig.scopes);
+	authorizeUrl.searchParams.set("code_challenge", input.challenge);
+	authorizeUrl.searchParams.set("code_challenge_method", "S256");
+	authorizeUrl.searchParams.set("redirect_uri", input.callbackUrl);
+	authorizeUrl.searchParams.set("state", input.state);
+	authorizeUrl.searchParams.set("nonce", input.nonce);
+	return authorizeUrl.toString();
+}
+
+export async function loginOcaOAuth(
+	options: OcaOAuthProviderOptions & {
+		callbacks: OAuthLoginCallbacks;
+		telemetry?: ITelemetryService;
+	},
+): Promise<OAuthCredentials> {
+	captureAuthStarted(options.telemetry, "oca");
+	const config = resolveConfig(options.config);
+	const mode = resolveMode(options.mode);
+	const callbackPorts = options.callbackPorts?.length
+		? options.callbackPorts
+		: DEFAULT_CALLBACK_PORTS;
+	const callbackPath = options.callbackPath ?? DEFAULT_CALLBACK_PATH;
+	const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+
+	const localServer = await startLocalOAuthServer({
+		ports: callbackPorts,
+		callbackPath,
+		onListening: options.callbacks.onServerListening,
+		onClose: options.callbacks.onServerClose,
+	});
+	const callbackUrl = localServer.callbackUrl;
+	if (!callbackUrl) {
+		throw new Error("Unable to bind local OAuth callback server");
+	}
+
+	const state = nanoid(16);
+	const nonce = nanoid(16);
+	const { verifier, challenge } = await getProofKey();
+	cleanupFlowState();
+	OCA_FLOW_STATE.set(state, {
+		verifier,
+		nonce,
+		mode,
+		redirectUri: callbackUrl,
+		createdAt: Date.now(),
+	});
+
+	const authUrl = buildAuthorizationUrl({
+		callbackUrl,
+		mode,
+		state,
+		nonce,
+		challenge,
+		config,
+	});
+	options.callbacks.onAuth({
+		url: authUrl,
+		instructions: "Continue the authentication process in your browser.",
+	});
+
+	try {
+		const authResult = await resolveAuthorizationCodeInput({
+			waitForCallback: localServer.waitForCallback,
+			cancelWait: localServer.cancelWait,
+			onManualCodeInput: options.callbacks.onManualCodeInput,
+		});
+		const code = authResult.code;
+		const returnedState = authResult.state;
+		if (authResult.error) {
+			throw new Error(`OAuth error: ${authResult.error}`);
+		}
+
+		if (!code) {
+			if (!options.callbacks.onManualCodeInput) {
+				throw new Error("Timed out waiting for OCA callback");
+			}
+			throw new Error("Missing authorization code");
+		}
+		if (!returnedState || returnedState !== state) {
+			throw new Error("State mismatch");
+		}
+
+		const credentials = await exchangeAuthorizationCode({
+			code,
+			state: returnedState,
+			mode,
+			config,
+			requestTimeoutMs,
+		});
+		captureAuthSucceeded(options.telemetry, "oca");
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: "oca",
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			"oca",
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
+	} finally {
+		localServer.close();
+	}
+}
+
+export async function refreshOcaToken(
+	credentials: OAuthCredentials,
+	options: OcaOAuthProviderOptions = {},
+): Promise<OAuthCredentials> {
+	const config = resolveConfig(options.config);
+	const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+	const metadataMode = credentials.metadata?.mode;
+	const mode: OcaMode =
+		metadataMode === "internal" || metadataMode === "external"
+			? metadataMode
+			: resolveMode(options.mode);
+	const envConfig = mode === "external" ? config.external : config.internal;
+	const tokenEndpoint = await discoverTokenEndpoint(
+		envConfig.idcsUrl,
+		requestTimeoutMs,
+	);
+
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		refresh_token: credentials.refresh,
+		client_id: envConfig.clientId,
+	});
+
+	const response = await fetch(tokenEndpoint, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body,
+		signal: AbortSignal.timeout(requestTimeoutMs),
+	});
+
+	const tokenPayload = (await response.json()) as OcaTokenResponse;
+	if (!response.ok) {
+		const details = parseOAuthErrorPayload(tokenPayload);
+		throw new OcaOAuthTokenError(
+			`Token refresh failed: ${response.status}${details.message ? ` - ${details.message}` : ""}`,
+			{ status: response.status, errorCode: details.code },
+		);
+	}
+
+	return toOcaCredentials(tokenPayload, mode, credentials);
+}
+
+export async function getValidOcaCredentials(
+	currentCredentials: OAuthCredentials | null,
+	options?: OcaTokenResolution & { telemetry?: ITelemetryService },
+	providerOptions?: OcaOAuthProviderOptions & { telemetry?: ITelemetryService },
+): Promise<OAuthCredentials | null> {
+	if (!currentCredentials) {
+		return null;
+	}
+
+	const refreshBufferMs =
+		options?.refreshBufferMs ??
+		providerOptions?.refreshBufferMs ??
+		DEFAULT_REFRESH_BUFFER_MS;
+	const retryableTokenGraceMs =
+		options?.retryableTokenGraceMs ??
+		providerOptions?.retryableTokenGraceMs ??
+		DEFAULT_RETRYABLE_TOKEN_GRACE_MS;
+	const forceRefresh = options?.forceRefresh === true;
+
+	if (
+		!forceRefresh &&
+		!isCredentialLikelyExpired(currentCredentials, refreshBufferMs)
+	) {
+		return currentCredentials;
+	}
+
+	try {
+		return await refreshOcaToken(currentCredentials, providerOptions);
+	} catch (error) {
+		if (error instanceof OcaOAuthTokenError && error.isLikelyInvalidGrant()) {
+			captureAuthLoggedOut(providerOptions?.telemetry, "oca", "invalid_grant");
+			return null;
+		}
+		if (currentCredentials.expires - Date.now() > retryableTokenGraceMs) {
+			return currentCredentials;
+		}
+		return null;
+	}
+}
diff --git a/sdk/packages/core/src/auth/provider-auth-registry.test.ts b/sdk/packages/core/src/auth/provider-auth-registry.test.ts
new file mode 100644
index 0000000..5eb1df4
--- /dev/null
+++ b/sdk/packages/core/src/auth/provider-auth-registry.test.ts
@@ -0,0 +1,171 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	formatProviderOAuthApiKey,
+	getPersistedProviderApiKey,
+	getProviderAuthHandler,
+	getProviderAuthStorageId,
+	isOAuthProvider,
+	loginAndSaveProviderOAuthCredentials,
+	resolveProviderApiKeyFromSettings,
+} from "./provider-auth-registry";
+
+const { loginClineOAuth } = vi.hoisted(() => ({
+	loginClineOAuth: vi.fn(),
+}));
+
+vi.mock("./cline", () => ({
+	getValidClineCredentials: vi.fn(),
+	loginClineOAuth,
+}));
+
+vi.mock("./oca", () => ({
+	getValidOcaCredentials: vi.fn(),
+	loginOcaOAuth: vi.fn(),
+}));
+
+vi.mock("./codex", () => ({
+	getValidOpenAICodexCredentials: vi.fn(),
+	loginOpenAICodex: vi.fn(),
+}));
+
+describe("provider auth registry", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("returns handlers for managed OAuth providers only", () => {
+		expect(getProviderAuthHandler("cline")?.providerId).toBe("cline");
+		expect(getProviderAuthHandler("cline-pass")?.providerId).toBe("cline-pass");
+		expect(getProviderAuthHandler("oca")?.providerId).toBe("oca");
+		expect(getProviderAuthHandler("openai-codex")?.providerId).toBe(
+			"openai-codex",
+		);
+		expect(getProviderAuthHandler("openai-codex-cli")).toBeUndefined();
+		expect(isOAuthProvider("openai-codex-cli")).toBe(false);
+	});
+
+	it("returns storage provider IDs from handlers", () => {
+		expect(getProviderAuthStorageId("cline")).toBe("cline");
+		expect(getProviderAuthStorageId("cline-pass")).toBe("cline");
+		expect(getProviderAuthStorageId("oca")).toBe("oca");
+		expect(getProviderAuthStorageId("openai-codex")).toBe("openai-codex");
+		expect(getProviderAuthStorageId("openai-codex-cli")).toBeUndefined();
+	});
+
+	it("formats Cline WorkOS tokens without double-prefixing", () => {
+		expect(formatProviderOAuthApiKey("cline", { access: "abc" })).toBe(
+			"workos:abc",
+		);
+		expect(formatProviderOAuthApiKey("cline-pass", { access: "abc" })).toBe(
+			"workos:abc",
+		);
+		expect(formatProviderOAuthApiKey("cline", { access: "workos:abc" })).toBe(
+			"workos:abc",
+		);
+		expect(
+			getPersistedProviderApiKey("cline-pass", {
+				provider: "cline",
+				auth: { accessToken: "abc" },
+			}),
+		).toBe("workos:abc");
+	});
+
+	it("login/save for ClinePass stores credentials under Cline storage", async () => {
+		loginClineOAuth.mockResolvedValueOnce({
+			access: "new-access",
+			refresh: "new-refresh",
+			expires: 4_000_000_000_000,
+			accountId: "acct-new",
+		});
+		const getProviderSettings = vi.fn().mockReturnValue({
+			provider: "cline",
+			apiKey: "manual-key",
+		});
+		const saveProviderSettings = vi.fn();
+		const manager = {
+			getProviderSettings,
+			saveProviderSettings,
+		} as never;
+
+		const saved = await loginAndSaveProviderOAuthCredentials(
+			manager,
+			"cline-pass",
+			{
+				callbacks: {
+					onAuth: vi.fn(),
+					onPrompt: vi.fn(async () => ""),
+				},
+			},
+		);
+
+		expect(getProviderSettings).toHaveBeenCalledWith("cline");
+		expect(saved).toMatchObject({
+			provider: "cline",
+			apiKey: "manual-key",
+			auth: {
+				accessToken: "workos:new-access",
+				refreshToken: "new-refresh",
+				accountId: "acct-new",
+				expiresAt: 4_000_000_000_000,
+			},
+		});
+		expect(saveProviderSettings).toHaveBeenCalledWith(
+			expect.objectContaining({ provider: "cline" }),
+			{ tokenSource: "oauth" },
+		);
+	});
+
+	it("ClinePass resolves API keys from Cline storage", () => {
+		const getProviderSettings = vi.fn().mockReturnValue({
+			provider: "cline",
+			auth: { accessToken: "abc" },
+		});
+		const manager = { getProviderSettings } as never;
+
+		expect(resolveProviderApiKeyFromSettings(manager, "cline-pass")).toBe(
+			"workos:abc",
+		);
+		expect(getProviderSettings).toHaveBeenCalledWith("cline");
+	});
+
+	it("login/save stores credentials under handler storageProviderId", async () => {
+		loginClineOAuth.mockResolvedValueOnce({
+			access: "new-access",
+			refresh: "new-refresh",
+			expires: 4_000_000_000_000,
+			accountId: "acct-new",
+		});
+		const getProviderSettings = vi.fn().mockReturnValue({
+			provider: "cline",
+			apiKey: "manual-key",
+		});
+		const saveProviderSettings = vi.fn();
+		const manager = {
+			getProviderSettings,
+			saveProviderSettings,
+		} as never;
+
+		const saved = await loginAndSaveProviderOAuthCredentials(manager, "cline", {
+			callbacks: {
+				onAuth: vi.fn(),
+				onPrompt: vi.fn(async () => ""),
+			},
+		});
+
+		expect(getProviderSettings).toHaveBeenCalledWith("cline");
+		expect(saved).toMatchObject({
+			provider: "cline",
+			apiKey: "manual-key",
+			auth: {
+				accessToken: "workos:new-access",
+				refreshToken: "new-refresh",
+				accountId: "acct-new",
+				expiresAt: 4_000_000_000_000,
+			},
+		});
+		expect(saveProviderSettings).toHaveBeenCalledWith(
+			expect.objectContaining({ provider: "cline" }),
+			{ tokenSource: "oauth" },
+		);
+	});
+});
diff --git a/sdk/packages/core/src/auth/provider-auth-registry.ts b/sdk/packages/core/src/auth/provider-auth-registry.ts
new file mode 100644
index 0000000..c32d27f
--- /dev/null
+++ b/sdk/packages/core/src/auth/provider-auth-registry.ts
@@ -0,0 +1,380 @@
+import {
+	getClineEnvironmentConfig,
+	type ITelemetryService,
+} from "@cline/shared";
+import type { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import type { ProviderSettings } from "../types/provider-settings";
+import {
+	type ClineOAuthCredentials,
+	getValidClineCredentials,
+	loginClineOAuth,
+} from "./cline";
+import { getValidOpenAICodexCredentials, loginOpenAICodex } from "./codex";
+import { getValidOcaCredentials, loginOcaOAuth } from "./oca";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
+import { decodeJwtPayload } from "./utils";
+
+const WORKOS_TOKEN_PREFIX = "workos:";
+
+export type ProviderOAuthCredentials = OAuthCredentials;
+
+export interface ProviderAuthLoginInput {
+	settings?: ProviderSettings;
+	callbacks: OAuthLoginCallbacks;
+	telemetry?: ITelemetryService;
+}
+
+export interface ProviderAuthRefreshInput {
+	settings: ProviderSettings;
+	credentials: ProviderOAuthCredentials;
+	forceRefresh?: boolean;
+	telemetry?: ITelemetryService;
+}
+
+export interface ProviderAuthSaveCredentialsInput {
+	manager: ProviderSettingsManager;
+	settings?: ProviderSettings;
+	credentials: ProviderOAuthCredentials;
+	setLastUsed?: boolean;
+	save?: boolean;
+}
+
+export interface ProviderAuthHandler {
+	providerId: string;
+	storageProviderId: string;
+	getApiKey(settings: ProviderSettings | undefined): string | undefined;
+	login(input: ProviderAuthLoginInput): Promise<ProviderOAuthCredentials>;
+	refresh(
+		input: ProviderAuthRefreshInput,
+	): Promise<ProviderOAuthCredentials | null>;
+	saveCredentials(input: ProviderAuthSaveCredentialsInput): ProviderSettings;
+	isConfigured(settings: ProviderSettings | undefined): boolean;
+	normalizeStoredAccessToken?(accessToken: string): string;
+}
+
+function formatClineApiKey(accessToken: string): string {
+	const token = accessToken.trim();
+	return token.toLowerCase().startsWith(WORKOS_TOKEN_PREFIX)
+		? token
+		: `${WORKOS_TOKEN_PREFIX}${token}`;
+}
+
+function stripClineApiKeyPrefix(accessToken: string): string {
+	const token = accessToken.trim();
+	return token.toLowerCase().startsWith(WORKOS_TOKEN_PREFIX)
+		? token.slice(WORKOS_TOKEN_PREFIX.length)
+		: token;
+}
+
+function readExpiryFromToken(accessToken: string): number | null {
+	const payload = decodeJwtPayload(accessToken);
+	const exp = payload?.exp;
+	if (typeof exp === "number" && exp > 0) {
+		return exp * 1000;
+	}
+	return null;
+}
+
+function deriveCredentialExpiry(
+	settings: ProviderSettings,
+	normalizedAccessToken: string,
+): number {
+	const explicitExpiry = settings.auth?.expiresAt;
+	if (
+		typeof explicitExpiry === "number" &&
+		Number.isFinite(explicitExpiry) &&
+		explicitExpiry > 0
+	) {
+		return explicitExpiry;
+	}
+
+	const jwtExpiry = readExpiryFromToken(normalizedAccessToken);
+	if (jwtExpiry) {
+		return jwtExpiry;
+	}
+
+	// Unknown expiry should trigger refresh on next resolution.
+	return Date.now() - 1;
+}
+
+function createCredentialsFromSettings(
+	settings: ProviderSettings,
+	options?: { normalizeAccessToken?: (accessToken: string) => string },
+): ProviderOAuthCredentials | null {
+	const rawAccess = settings.auth?.accessToken?.trim();
+	const refreshToken = settings.auth?.refreshToken?.trim();
+	if (!rawAccess || !refreshToken) {
+		return null;
+	}
+	const access = options?.normalizeAccessToken?.(rawAccess) ?? rawAccess;
+	if (!access) {
+		return null;
+	}
+
+	return {
+		access,
+		refresh: refreshToken,
+		expires: deriveCredentialExpiry(settings, access),
+		accountId: settings.auth?.accountId,
+	};
+}
+
+function saveOAuthCredentials(input: {
+	manager: ProviderSettingsManager;
+	storageProviderId: string;
+	settings?: ProviderSettings;
+	credentials: ProviderOAuthCredentials;
+	formatAccessToken?: (accessToken: string) => string;
+	setLastUsed?: boolean;
+	save?: boolean;
+}): ProviderSettings {
+	const accessToken =
+		input.formatAccessToken?.(input.credentials.access) ??
+		input.credentials.access;
+	const auth = {
+		...(input.settings?.auth ?? {}),
+		accessToken,
+		refreshToken: input.credentials.refresh,
+		accountId: input.credentials.accountId,
+		expiresAt: input.credentials.expires,
+	};
+
+	const merged: ProviderSettings = {
+		...(input.settings ?? {
+			provider: input.storageProviderId as ProviderSettings["provider"],
+		}),
+		provider: input.storageProviderId as ProviderSettings["provider"],
+		auth,
+	};
+	if (input.save !== false) {
+		input.manager.saveProviderSettings(merged, {
+			...(input.setLastUsed === undefined
+				? {}
+				: { setLastUsed: input.setLastUsed }),
+			tokenSource: "oauth",
+		});
+	}
+	return merged;
+}
+
+function createOAuthHandler(input: {
+	providerId: string;
+	storageProviderId?: string;
+	formatAccessToken?: (accessToken: string) => string;
+	normalizeStoredAccessToken?: (accessToken: string) => string;
+	login: (input: ProviderAuthLoginInput) => Promise<ProviderOAuthCredentials>;
+	refresh: (
+		input: ProviderAuthRefreshInput,
+	) => Promise<ProviderOAuthCredentials | null>;
+}): ProviderAuthHandler {
+	const storageProviderId = input.storageProviderId ?? input.providerId;
+	return {
+		providerId: input.providerId,
+		storageProviderId,
+		getApiKey(settings) {
+			const accessToken = settings?.auth?.accessToken?.trim();
+			if (accessToken) {
+				return input.formatAccessToken?.(accessToken) ?? accessToken;
+			}
+
+			return (
+				settings?.apiKey?.trim() || settings?.auth?.apiKey?.trim() || undefined
+			);
+		},
+		login: input.login,
+		refresh: input.refresh,
+		saveCredentials(saveInput) {
+			return saveOAuthCredentials({
+				...saveInput,
+				storageProviderId,
+				formatAccessToken: input.formatAccessToken,
+			});
+		},
+		isConfigured(settings) {
+			return !!settings?.auth?.accessToken;
+		},
+		normalizeStoredAccessToken: input.normalizeStoredAccessToken,
+	};
+}
+
+function createClineAuthHandler(input: {
+	providerId: string;
+	storageProviderId?: string;
+}): ProviderAuthHandler {
+	return createOAuthHandler({
+		providerId: input.providerId,
+		storageProviderId: input.storageProviderId,
+		formatAccessToken: formatClineApiKey,
+		normalizeStoredAccessToken: stripClineApiKeyPrefix,
+		login: ({ settings, callbacks, telemetry }) =>
+			loginClineOAuth({
+				apiBaseUrl:
+					settings?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl,
+				useWorkOSDeviceAuth: true,
+				callbacks,
+				telemetry,
+			}),
+		refresh: ({ settings, credentials, forceRefresh, telemetry }) =>
+			getValidClineCredentials(
+				credentials as ClineOAuthCredentials,
+				{
+					apiBaseUrl:
+						settings.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl,
+					telemetry,
+				},
+				{ forceRefresh },
+			),
+	});
+}
+
+const providerAuthHandlers = [
+	createClineAuthHandler({ providerId: "cline" }),
+	createClineAuthHandler({
+		providerId: "cline-pass",
+		storageProviderId: "cline",
+	}),
+	createOAuthHandler({
+		providerId: "oca",
+		login: ({ settings, callbacks, telemetry }) =>
+			loginOcaOAuth({ mode: settings?.oca?.mode, callbacks, telemetry }),
+		refresh: ({ settings, credentials, forceRefresh, telemetry }) =>
+			getValidOcaCredentials(
+				credentials,
+				{ forceRefresh, telemetry },
+				{ mode: settings.oca?.mode, telemetry },
+			),
+	}),
+	createOAuthHandler({
+		providerId: "openai-codex",
+		login: ({ callbacks, telemetry }) =>
+			loginOpenAICodex({
+				onAuth: callbacks.onAuth,
+				onPrompt: callbacks.onPrompt,
+				onProgress: callbacks.onProgress,
+				onManualCodeInput: callbacks.onManualCodeInput,
+				telemetry,
+			}),
+		refresh: ({ credentials, forceRefresh, telemetry }) =>
+			getValidOpenAICodexCredentials(credentials, { forceRefresh, telemetry }),
+	}),
+] as const satisfies readonly ProviderAuthHandler[];
+
+const providerAuthHandlerById = new Map<string, ProviderAuthHandler>(
+	providerAuthHandlers.map((handler) => [handler.providerId, handler]),
+);
+
+export function getProviderAuthHandler(
+	providerId: string,
+): ProviderAuthHandler | undefined {
+	return providerAuthHandlerById.get(providerId.trim().toLowerCase());
+}
+
+export function isOAuthProvider(providerId: string): boolean {
+	return getProviderAuthHandler(providerId) !== undefined;
+}
+
+export function getProviderAuthStorageId(
+	providerId: string,
+): string | undefined {
+	return getProviderAuthHandler(providerId)?.storageProviderId;
+}
+
+export function resolveProviderApiKeyFromSettings(
+	manager: ProviderSettingsManager,
+	providerId: string,
+): string | undefined {
+	const handler = getProviderAuthHandler(providerId);
+	const storageProviderId = handler?.storageProviderId ?? providerId;
+	const settings = manager.getProviderSettings(storageProviderId);
+	return (
+		handler?.getApiKey(settings) ??
+		getPersistedProviderApiKey(providerId, settings)
+	);
+}
+
+export async function loginAndSaveProviderOAuthCredentials(
+	manager: ProviderSettingsManager,
+	providerId: string,
+	input: {
+		callbacks: OAuthLoginCallbacks;
+		telemetry?: ITelemetryService;
+	},
+): Promise<ProviderSettings> {
+	const handler = getProviderAuthHandler(providerId);
+	if (!handler) {
+		throw new Error(`Provider "${providerId}" does not support OAuth login`);
+	}
+	const existing = manager.getProviderSettings(handler.storageProviderId);
+	const credentials = await handler.login({
+		settings: existing,
+		callbacks: input.callbacks,
+		telemetry: input.telemetry,
+	});
+	return handler.saveCredentials({ manager, settings: existing, credentials });
+}
+
+export function getProviderOAuthCredentialsFromSettings(
+	providerId: string,
+	settings: ProviderSettings,
+): ProviderOAuthCredentials | null {
+	const handler = getProviderAuthHandler(providerId);
+	if (!handler) return null;
+	return createCredentialsFromSettings(settings, {
+		normalizeAccessToken: handler.normalizeStoredAccessToken,
+	});
+}
+
+export function saveProviderOAuthCredentials(input: {
+	manager: ProviderSettingsManager;
+	providerId: string;
+	settings?: ProviderSettings;
+	credentials: ProviderOAuthCredentials;
+	setLastUsed?: boolean;
+	save?: boolean;
+}): ProviderSettings {
+	const handler = getProviderAuthHandler(input.providerId);
+	if (!handler) {
+		throw new Error(
+			`Provider "${input.providerId}" does not support OAuth credentials`,
+		);
+	}
+	return handler.saveCredentials({
+		manager: input.manager,
+		settings: input.settings,
+		credentials: input.credentials,
+		setLastUsed: input.setLastUsed,
+		save: input.save,
+	});
+}
+
+export function getPersistedProviderApiKey(
+	providerId: string,
+	settings?: ProviderSettings,
+): string | undefined {
+	const handler = getProviderAuthHandler(providerId);
+	if (handler) {
+		return handler.getApiKey(settings);
+	}
+
+	return (
+		settings?.auth?.accessToken?.trim() ||
+		settings?.apiKey?.trim() ||
+		settings?.auth?.apiKey?.trim() ||
+		undefined
+	);
+}
+
+export function formatProviderOAuthApiKey(
+	providerId: string,
+	credentials: Pick<ProviderOAuthCredentials, "access">,
+): string {
+	const handler = getProviderAuthHandler(providerId);
+	if (!handler) return credentials.access;
+
+	return (
+		handler.getApiKey({
+			provider: handler.storageProviderId,
+			auth: { accessToken: credentials.access },
+		}) ?? credentials.access
+	);
+}
diff --git a/sdk/packages/core/src/auth/server.test.ts b/sdk/packages/core/src/auth/server.test.ts
new file mode 100644
index 0000000..25f588f
--- /dev/null
+++ b/sdk/packages/core/src/auth/server.test.ts
@@ -0,0 +1,395 @@
+import http from "node:http";
+import net from "node:net";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { startLocalOAuthServer } from "./server";
+
+const socketBindingSupported = await (async () => {
+	try {
+		const srv = net.createServer();
+		await new Promise<void>((resolve, reject) => {
+			srv.listen(0, "127.0.0.1", () => resolve());
+			srv.once("error", reject);
+		});
+		await new Promise<void>((resolve, reject) =>
+			srv.close((err) => (err ? reject(err) : resolve())),
+		);
+		return true;
+	} catch {
+		return false;
+	}
+})();
+const socketIt = socketBindingSupported ? it : it.skip;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Bind to port 0 to let the OS pick a free port, then release it. */
+function getFreePort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const srv = net.createServer();
+		srv.listen(0, "127.0.0.1", () => {
+			const addr = srv.address() as net.AddressInfo;
+			srv.close(() => resolve(addr.port));
+		});
+		srv.on("error", reject);
+	});
+}
+
+/** Occupy a port so the OAuth server cannot bind to it. */
+function occupyPort(port: number): Promise<http.Server> {
+	return new Promise((resolve, reject) => {
+		const srv = http.createServer();
+		srv.listen(port, "127.0.0.1", () => resolve(srv));
+		srv.on("error", reject);
+	});
+}
+
+/** Close an http.Server, resolving when the socket is gone. */
+function closeServer(srv: http.Server): Promise<void> {
+	return new Promise((resolve, reject) =>
+		srv.close((err) => (err ? reject(err) : resolve())),
+	);
+}
+
+/** Make a GET request and return status + body. */
+function get(url: string): Promise<{ status: number; body: string }> {
+	return new Promise((resolve, reject) => {
+		http
+			.get(url, (res) => {
+				let body = "";
+				res.on("data", (chunk: Buffer) => {
+					body += chunk.toString();
+				});
+				res.on("end", () => resolve({ status: res.statusCode ?? 0, body }));
+			})
+			.on("error", reject);
+	});
+}
+
+/** Flush microtasks + a short macro-task delay for fire-and-forget promises. */
+function flushAsync(): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, 20));
+}
+
+// ---------------------------------------------------------------------------
+// onListening
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — onListening", () => {
+	socketIt(
+		"is called with host, port, and callbackUrl when the server binds",
+		async () => {
+			const port = await getFreePort();
+			const onListening = vi.fn();
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/callback",
+				onListening,
+			});
+
+			expect(onListening).toHaveBeenCalledOnce();
+			expect(onListening).toHaveBeenCalledWith({
+				host: "127.0.0.1",
+				port,
+				callbackUrl: `http://127.0.0.1:${port}/callback`,
+			});
+
+			server.close();
+		},
+	);
+
+	socketIt("is not called when no port can be bound", async () => {
+		const port = await getFreePort();
+		const blocker = await occupyPort(port);
+		const onListening = vi.fn();
+
+		await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onListening,
+		});
+
+		expect(onListening).not.toHaveBeenCalled();
+
+		await closeServer(blocker);
+	});
+
+	socketIt(
+		"fires for the first available port and skips occupied ones",
+		async () => {
+			const [port1, port2] = await Promise.all([getFreePort(), getFreePort()]);
+			const blocker = await occupyPort(port1);
+			const onListening = vi.fn();
+
+			const server = await startLocalOAuthServer({
+				ports: [port1, port2],
+				callbackPath: "/cb",
+				onListening,
+			});
+
+			expect(onListening).toHaveBeenCalledOnce();
+			expect(onListening).toHaveBeenCalledWith(
+				expect.objectContaining({ port: port2 }),
+			);
+
+			server.close();
+			await closeServer(blocker);
+		},
+	);
+
+	socketIt("swallows errors thrown by the onListening callback", async () => {
+		const port = await getFreePort();
+		const onListening = vi
+			.fn()
+			.mockReturnValue(Promise.reject(new Error("listening boom")));
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onListening,
+		});
+
+		await flushAsync();
+		expect(onListening).toHaveBeenCalledOnce();
+
+		server.close();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// onClose
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — onClose", () => {
+	socketIt("is called with host and port when close() is invoked", async () => {
+		const port = await getFreePort();
+		const onClose = vi.fn();
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		server.close();
+
+		expect(onClose).toHaveBeenCalledOnce();
+		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
+	});
+
+	socketIt(
+		"is called with host and port when cancelWait() is invoked",
+		async () => {
+			const port = await getFreePort();
+			const onClose = vi.fn();
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/callback",
+				onClose,
+			});
+
+			server.cancelWait();
+
+			expect(onClose).toHaveBeenCalledOnce();
+			expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
+		},
+	);
+
+	socketIt("is called after a successful OAuth callback request", async () => {
+		const port = await getFreePort();
+		const onClose = vi.fn();
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		const waitPromise = server.waitForCallback();
+		const { status } = await get(
+			`http://127.0.0.1:${port}/callback?code=tok123`,
+		);
+		expect(status).toBe(200);
+
+		await waitPromise;
+
+		expect(onClose).toHaveBeenCalledOnce();
+		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
+	});
+
+	socketIt("is not called when no port was bound", async () => {
+		const port = await getFreePort();
+		const blocker = await occupyPort(port);
+		const onClose = vi.fn();
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		server.close();
+		expect(onClose).not.toHaveBeenCalled();
+
+		await closeServer(blocker);
+	});
+
+	socketIt("swallows errors thrown by the onClose callback", async () => {
+		const port = await getFreePort();
+		const onClose = vi
+			.fn()
+			.mockReturnValue(Promise.reject(new Error("teardown failed")));
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		server.close();
+		await flushAsync();
+
+		expect(onClose).toHaveBeenCalledOnce();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Sequential flows on a fixed port (keep-alive socket teardown)
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — sequential flows on a fixed port", () => {
+	// A browser / global-fetch connection pool keeps a keep-alive socket to the
+	// callback port alive across requests. If close() left those sockets open, a
+	// later request to a re-bound port could be delivered over the pooled socket
+	// to the first (already-settled) server, and that flow's waitForCallback()
+	// would never resolve. close() must therefore drop lingering connections.
+	socketIt(
+		"does not serve requests over a pooled keep-alive socket after close()",
+		async () => {
+			const port = await getFreePort();
+
+			// A keep-alive agent models the browser / global-fetch connection pool,
+			// which keeps a socket to the fixed callback port alive across requests.
+			const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
+			const getOverAgent = (path: string) =>
+				new Promise<{ status: number } | { error: string }>((resolve) => {
+					const req = http.get(
+						{ host: "127.0.0.1", port, path, agent },
+						(res) => {
+							res.on("data", () => {});
+							res.on("end", () => resolve({ status: res.statusCode ?? 0 }));
+						},
+					);
+					req.on("error", (e) =>
+						resolve({ error: (e as NodeJS.ErrnoException).code ?? e.message }),
+					);
+				});
+
+			// First flow: deny. The 400 response leaves a pooled keep-alive socket
+			// attached to THIS server.
+			const first = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/callback",
+			});
+			const firstWait = first.waitForCallback();
+			expect(await getOverAgent("/callback?error=access_denied")).toMatchObject(
+				{ status: 400 },
+			);
+			expect((await firstWait)?.error).toBe("access_denied");
+			first.close();
+
+			// A second request over the same agent must not be served by the closed
+			// first server. close() destroys the pooled socket, so the reused
+			// connection errors rather than reaching the (already-settled) server —
+			// which is what would otherwise swallow a subsequent flow's callback.
+			const reused = await getOverAgent("/callback?code=abc123&state=xyz");
+			expect(reused).not.toHaveProperty("status");
+			expect(reused).toHaveProperty("error");
+
+			// And a brand-new server can bind the same port and serve normally.
+			const second = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/callback",
+			});
+			const secondWait = second.waitForCallback();
+			expect(
+				await get(`http://127.0.0.1:${port}/callback?code=abc123&state=xyz`),
+			).toMatchObject({ status: 200 });
+			const secondPayload = await Promise.race([
+				secondWait,
+				new Promise<never>((_, rej) =>
+					setTimeout(() => rej(new Error("flow 2 callback hung")), 3000),
+				),
+			]);
+			expect(secondPayload?.code).toBe("abc123");
+
+			second.close();
+			agent.destroy();
+		},
+	);
+});
+
+// ---------------------------------------------------------------------------
+// onListening + onClose ordering
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — onListening + onClose together", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	socketIt(
+		"fires onListening on bind then onClose after a successful callback",
+		async () => {
+			const port = await getFreePort();
+			const order: string[] = [];
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/cb",
+				onListening: vi.fn(() => {
+					order.push("listening");
+				}),
+				onClose: vi.fn(() => {
+					order.push("close");
+				}),
+			});
+
+			expect(order).toEqual(["listening"]);
+
+			const waitPromise = server.waitForCallback();
+			await get(`http://127.0.0.1:${port}/cb?code=mycode`);
+			const payload = await waitPromise;
+
+			expect(payload?.code).toBe("mycode");
+			expect(order).toEqual(["listening", "close"]);
+		},
+	);
+
+	socketIt(
+		"fires onListening on bind then onClose after cancelWait()",
+		async () => {
+			const port = await getFreePort();
+			const order: string[] = [];
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/cb",
+				onListening: vi.fn(() => {
+					order.push("listening");
+				}),
+				onClose: vi.fn(() => {
+					order.push("close");
+				}),
+			});
+
+			expect(order).toEqual(["listening"]);
+
+			server.cancelWait();
+			expect(order).toEqual(["listening", "close"]);
+		},
+	);
+});
diff --git a/sdk/packages/core/src/auth/server.ts b/sdk/packages/core/src/auth/server.ts
new file mode 100644
index 0000000..c00a8bf
--- /dev/null
+++ b/sdk/packages/core/src/auth/server.ts
@@ -0,0 +1,274 @@
+export interface OAuthCallbackPayload {
+	url: URL;
+	code?: string;
+	state?: string;
+	provider?: string;
+	error?: string;
+}
+
+type Deferred<T> = {
+	promise: Promise<T>;
+	resolve: (value: T) => void;
+};
+
+function createDeferred<T>(): Deferred<T> {
+	let resolve!: (value: T) => void;
+	const promise = new Promise<T>((res) => {
+		resolve = res;
+	});
+	return { promise, resolve };
+}
+
+export interface OAuthServerListeningInfo {
+	host: string;
+	port: number;
+	callbackUrl: string;
+}
+
+export interface OAuthServerCloseInfo {
+	host: string;
+	port: number;
+}
+
+export interface LocalOAuthServerOptions {
+	host?: string;
+	ports: number[];
+	callbackPath: string;
+	timeoutMs?: number;
+	expectedState?: string;
+	successHtml?: string;
+	/**
+	 * Called when the local redirect server successfully binds to a port and is
+	 * ready to receive the OAuth callback. Hosts can use this to display a
+	 * "waiting for callback" status indicator or — in remote-development
+	 * environments like JetBrains Gateway — to forward the port from the remote
+	 * machine to the local machine where the user's browser is running.
+	 *
+	 * May be async; `startLocalOAuthServer` will **await** this callback before
+	 * returning so that any setup it performs (e.g. port-forwarding) is
+	 * guaranteed to complete before the caller opens the auth URL. Errors
+	 * thrown by this callback are swallowed — they do not prevent the OAuth
+	 * flow from proceeding.
+	 */
+	onListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+	/**
+	 * Called when the local redirect server closes, either because the OAuth
+	 * callback was received, the flow was cancelled, or the timeout elapsed.
+	 * Hosts should use this to tear down any port-forward set up in
+	 * `onListening` and clear any "waiting for callback" status UI.
+	 *
+	 * May be async; fired after the underlying server socket is closed.
+	 */
+	onClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+
+export interface LocalOAuthServer {
+	callbackUrl: string;
+	waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+	cancelWait: () => void;
+	close: () => void;
+}
+
+export async function startLocalOAuthServer(
+	options: LocalOAuthServerOptions,
+): Promise<LocalOAuthServer> {
+	const http = await import("node:http");
+
+	const host = options.host ?? "127.0.0.1";
+	const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
+	const successHtml = options.successHtml ?? HTML_CONTENT;
+
+	const deferred = createDeferred<OAuthCallbackPayload | null>();
+	let settled = false;
+	let timeout: ReturnType<typeof setTimeout> | null = null;
+	let activeServer: import("node:http").Server | null = null;
+	let boundPort: number | null = null;
+
+	const settle = (value: OAuthCallbackPayload | null) => {
+		if (settled) return;
+		settled = true;
+		deferred.resolve(value);
+	};
+
+	const close = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+		const closingPort = boundPort;
+		boundPort = null;
+		if (activeServer) {
+			activeServer.close();
+			// `Server.close()` only stops accepting new connections; existing
+			// keep-alive sockets keep working. A browser / global-fetch connection
+			// pool keeps such a socket to the (fixed) callback port alive, and a
+			// later request to that port can be delivered over the pooled socket to
+			// this server even after it has settled — so a subsequent OAuth flow
+			// reusing the port would have its callback delivered here and never
+			// resolve. Drop lingering connections so no pooled socket outlives this
+			// server.
+			activeServer.closeAllConnections?.();
+			activeServer = null;
+		}
+		if (closingPort !== null && options.onClose) {
+			void Promise.resolve(options.onClose({ host, port: closingPort })).catch(
+				() => {},
+			);
+		}
+	};
+
+	const waitForCallback = async () => {
+		timeout = setTimeout(() => {
+			close();
+			settle(null);
+		}, timeoutMs);
+		return deferred.promise;
+	};
+
+	for (const port of options.ports) {
+		const server = http.createServer((req, res) => {
+			try {
+				const requestUrl = new URL(req.url || "", `http://${host}:${port}`);
+				if (requestUrl.pathname !== options.callbackPath) {
+					res.statusCode = 404;
+					res.end("Not found");
+					return;
+				}
+
+				const payload: OAuthCallbackPayload = {
+					url: requestUrl,
+					code: requestUrl.searchParams.get("code") ?? undefined,
+					state: requestUrl.searchParams.get("state") ?? undefined,
+					provider: requestUrl.searchParams.get("provider") ?? undefined,
+					error: requestUrl.searchParams.get("error") ?? undefined,
+				};
+
+				if (payload.error) {
+					res.statusCode = 400;
+					res.end(`Authentication failed: ${payload.error}`);
+					close();
+					settle(payload);
+					return;
+				}
+
+				if (!payload.code) {
+					res.statusCode = 400;
+					res.end("Missing authorization code");
+					return;
+				}
+
+				if (options.expectedState && payload.state !== options.expectedState) {
+					res.statusCode = 400;
+					res.end("State mismatch");
+					return;
+				}
+
+				res.statusCode = 200;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(successHtml);
+				close();
+				settle(payload);
+			} catch {
+				res.statusCode = 500;
+				res.end("Internal error");
+			}
+		});
+
+		const bindResult = await new Promise<{
+			bound: boolean;
+			error?: NodeJS.ErrnoException;
+		}>((resolve) => {
+			const onError = (error: NodeJS.ErrnoException) => {
+				server.off("error", onError);
+				resolve({ bound: false, error });
+			};
+
+			server.once("error", onError);
+			server.listen(port, host, () => {
+				server.off("error", onError);
+				activeServer = server;
+				resolve({ bound: true });
+			});
+		});
+
+		if (bindResult.error) {
+			if (bindResult.error.code === "EADDRINUSE") {
+				continue;
+			}
+			close();
+			throw bindResult.error;
+		}
+
+		if (bindResult.bound) {
+			boundPort = port;
+			const callbackUrl = `http://${host}:${port}${options.callbackPath}`;
+			if (options.onListening) {
+				await Promise.resolve(
+					options.onListening({ host, port, callbackUrl }),
+				).catch(() => {});
+			}
+			return {
+				callbackUrl,
+				waitForCallback,
+				cancelWait: () => {
+					close();
+					settle(null);
+				},
+				close: () => {
+					close();
+					settle(null);
+				},
+			};
+		}
+	}
+
+	return {
+		callbackUrl: "",
+		waitForCallback: async () => null,
+		cancelWait: () => {},
+		close: () => {},
+	};
+}
+
+const HTML_CONTENT = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Authentication Successful</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    color: #fff;
+  }
+  .container { text-align: center; padding: 48px; max-width: 420px; }
+  .icon {
+    width: 72px; height: 72px; margin: 0 auto 24px;
+    background: linear-gradient(135deg, #10a37f 0%, #1a7f64 100%);
+    border-radius: 50%;
+    display: flex; align-items: center; justify-content: center;
+  }
+  .icon svg { width: 36px; height: 36px; stroke: #fff; stroke-width: 3; fill: none; }
+  h1 { font-size: 24px; font-weight: 600; margin-bottom: 12px; }
+  p { font-size: 15px; color: rgba(255,255,255,0.7); line-height: 1.5; }
+  .closing { margin-top: 32px; font-size: 13px; color: rgba(255,255,255,0.5); }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="icon">
+    <svg viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg>
+  </div>
+  <h1>Authentication Successful</h1>
+  <p>You're now signed in. You can close this window.</p>
+  <p class="closing">This window will close automatically...</p>
+</div>
+<script>setTimeout(() => window.close(), 3000);</script>
+</body>
+</html>`;
diff --git a/sdk/packages/core/src/auth/types.ts b/sdk/packages/core/src/auth/types.ts
new file mode 100644
index 0000000..44492ca
--- /dev/null
+++ b/sdk/packages/core/src/auth/types.ts
@@ -0,0 +1,110 @@
+import type { ITelemetryService } from "@cline/shared";
+import type { OAuthServerCloseInfo, OAuthServerListeningInfo } from "./server";
+
+export interface OAuthPrompt {
+	message: string;
+	defaultValue?: string;
+}
+
+export interface OAuthCredentials {
+	access: string;
+	refresh: string;
+	/**
+	 * Expiration timestamp in milliseconds since epoch.
+	 */
+	expires: number;
+	/**
+	 * Optional provider-specific account identifier.
+	 */
+	accountId?: string;
+	/**
+	 * Optional email for display/telemetry.
+	 */
+	email?: string;
+	/**
+	 * Provider-specific metadata (user info, provider hint, etc).
+	 */
+	metadata?: Record<string, unknown>;
+}
+
+export interface OAuthLoginCallbacks {
+	onAuth: (info: { url: string; instructions?: string }) => void;
+	onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+	onProgress?: (message: string) => void;
+	onManualCodeInput?: () => Promise<string>;
+	/**
+	 * Called when the local OAuth redirect server successfully binds to a port
+	 * and is ready to receive the browser callback. The `info` object contains
+	 * the host, the bound port number, and the full `callbackUrl`.
+	 *
+	 * Use this to:
+	 * - Show a "waiting for OAuth callback on port N" status indicator in your UI.
+	 * - Forward the port in remote-development environments (e.g. JetBrains
+	 *   Gateway) from the remote machine to the machine running the browser.
+	 *
+	 * Paired with `onServerClose` for teardown.
+	 *
+	 * Only fired when the provider uses a local callback server
+	 * (`OAuthProviderInterface.usesCallbackServer === true`).
+	 */
+	onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+	/**
+	 * Called when the local OAuth redirect server closes — either because the
+	 * callback was received, the flow was cancelled, or the timeout elapsed.
+	 *
+	 * Use this to:
+	 * - Clear any "waiting for callback" status UI shown in `onServerListening`.
+	 * - Tear down port-forwards set up in `onServerListening`.
+	 *
+	 * Only fired when the provider uses a local callback server
+	 * (`OAuthProviderInterface.usesCallbackServer === true`).
+	 */
+	onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+
+export interface OAuthProviderInterface {
+	id: string;
+	name: string;
+	usesCallbackServer: boolean;
+	login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
+	refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+	getApiKey(credentials: OAuthCredentials): string;
+}
+
+export type OcaMode = "internal" | "external";
+
+export interface OcaOAuthEnvironmentConfig {
+	clientId: string;
+	idcsUrl: string;
+	scopes: string;
+	baseUrl: string;
+}
+
+export interface OcaOAuthConfig {
+	internal: OcaOAuthEnvironmentConfig;
+	external: OcaOAuthEnvironmentConfig;
+}
+
+export interface OcaClientMetadata {
+	client?: string;
+	clientVersion?: string;
+	clientIde?: string;
+	clientIdeVersion?: string;
+}
+
+export interface OcaOAuthProviderOptions {
+	config?: Partial<OcaOAuthConfig>;
+	mode?: OcaMode | (() => OcaMode);
+	callbackPath?: string;
+	callbackPorts?: number[];
+	requestTimeoutMs?: number;
+	refreshBufferMs?: number;
+	retryableTokenGraceMs?: number;
+	telemetry?: ITelemetryService;
+}
+
+export interface OcaTokenResolution {
+	forceRefresh?: boolean;
+	refreshBufferMs?: number;
+	retryableTokenGraceMs?: number;
+}
diff --git a/sdk/packages/core/src/auth/utils.test.ts b/sdk/packages/core/src/auth/utils.test.ts
new file mode 100644
index 0000000..4d9cdd3
--- /dev/null
+++ b/sdk/packages/core/src/auth/utils.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	decodeJwtPayload,
+	isCredentialLikelyExpired,
+	parseAuthorizationInput,
+	parseOAuthError,
+	resolveAuthorizationCodeInput,
+	resolveUrl,
+} from "./utils";
+
+function toBase64Url(value: string): string {
+	return Buffer.from(value, "utf8").toString("base64url");
+}
+
+function createJwt(payload: Record<string, unknown>): string {
+	return `${toBase64Url(JSON.stringify({ alg: "none", typ: "JWT" }))}.${toBase64Url(JSON.stringify(payload))}.sig`;
+}
+
+describe("auth/utils", () => {
+	it("parses auth input from full URL with provider", () => {
+		const parsed = parseAuthorizationInput(
+			"http://localhost/callback?code=test-code&state=s1&provider=google",
+			{
+				includeProvider: true,
+			},
+		);
+		expect(parsed).toEqual({
+			code: "test-code",
+			state: "s1",
+			provider: "google",
+		});
+	});
+
+	it("parses auth input from hash format when enabled", () => {
+		const parsed = parseAuthorizationInput("abc123#state1", {
+			allowHashCodeState: true,
+		});
+		expect(parsed).toEqual({ code: "abc123", state: "state1" });
+	});
+
+	it("builds resolved URLs from base + path", () => {
+		expect(resolveUrl("https://example.com/", "/token")).toBe(
+			"https://example.com/token",
+		);
+	});
+
+	it("decodes JWT payload", () => {
+		const token = createJwt({ sub: "account-1", exp: 123 });
+		expect(decodeJwtPayload(token)).toMatchObject({
+			sub: "account-1",
+			exp: 123,
+		});
+		expect(decodeJwtPayload("invalid")).toBeNull();
+	});
+
+	it("parses OAuth error payloads from string and object forms", () => {
+		expect(
+			parseOAuthError(
+				JSON.stringify({
+					error: "invalid_grant",
+					error_description: "expired",
+				}),
+			),
+		).toEqual({
+			code: "invalid_grant",
+			message: "expired",
+		});
+		expect(
+			parseOAuthError(
+				JSON.stringify({ error: { type: "unauthorized", message: "denied" } }),
+			),
+		).toEqual({
+			code: "unauthorized",
+			message: "denied",
+		});
+	});
+
+	it("resolves code from callback result", async () => {
+		const result = await resolveAuthorizationCodeInput({
+			waitForCallback: async () => ({
+				url: new URL("http://localhost"),
+				code: "from-callback",
+				state: "s1",
+			}),
+			cancelWait: () => {},
+		});
+		expect(result).toEqual({
+			code: "from-callback",
+			state: "s1",
+			provider: undefined,
+			error: undefined,
+		});
+	});
+
+	it("resolves code from manual input when callback does not provide one", async () => {
+		const cancelWait = vi.fn();
+		const result = await resolveAuthorizationCodeInput({
+			waitForCallback: async () => null,
+			cancelWait,
+			onManualCodeInput: async () => "code=manual&state=manual-state",
+		});
+		expect(cancelWait).toHaveBeenCalled();
+		expect(result).toEqual({
+			code: "manual",
+			state: "manual-state",
+			provider: undefined,
+		});
+	});
+
+	it("throws when manual input rejects", async () => {
+		await expect(
+			resolveAuthorizationCodeInput({
+				waitForCallback: async () => null,
+				cancelWait: () => {},
+				onManualCodeInput: async () => {
+					throw new Error("cancelled");
+				},
+			}),
+		).rejects.toThrow("cancelled");
+	});
+
+	it("checks token expiry with configurable buffer", () => {
+		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(1_000);
+		expect(isCredentialLikelyExpired({ expires: 1_500 }, 600)).toBe(true);
+		expect(isCredentialLikelyExpired({ expires: 3_000 }, 600)).toBe(false);
+		nowSpy.mockRestore();
+	});
+});
diff --git a/sdk/packages/core/src/auth/utils.ts b/sdk/packages/core/src/auth/utils.ts
new file mode 100644
index 0000000..872194f
--- /dev/null
+++ b/sdk/packages/core/src/auth/utils.ts
@@ -0,0 +1,247 @@
+import type { OAuthCallbackPayload } from "./server";
+import type { OAuthCredentials } from "./types";
+
+function base64UrlEncode(input: Uint8Array): string {
+	let binary = "";
+	for (let i = 0; i < input.length; i += 1) {
+		binary += String.fromCharCode(input[i] ?? 0);
+	}
+	return btoa(binary)
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=+$/g, "");
+}
+
+async function sha256(value: string): Promise<Uint8Array> {
+	const encoder = new TextEncoder();
+	const data = encoder.encode(value);
+	const digest = await crypto.subtle.digest("SHA-256", data);
+	return new Uint8Array(digest);
+}
+
+function createVerifier(byteLength = 32): string {
+	const randomBytes = new Uint8Array(byteLength);
+	crypto.getRandomValues(randomBytes);
+	return base64UrlEncode(randomBytes);
+}
+
+export async function getProofKey(): Promise<{
+	verifier: string;
+	challenge: string;
+}> {
+	const verifier = createVerifier();
+	const challenge = base64UrlEncode(await sha256(verifier));
+	return { verifier, challenge };
+}
+
+export function normalizeBaseUrl(value: string): string {
+	return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+
+export function resolveUrl(baseUrl: string, path: string): string {
+	return new URL(path, `${normalizeBaseUrl(baseUrl)}/`).toString();
+}
+
+export type ParsedAuthorizationInput = {
+	code?: string;
+	state?: string;
+	provider?: string;
+};
+
+export type ParseAuthorizationInputOptions = {
+	includeProvider?: boolean;
+	allowHashCodeState?: boolean;
+};
+
+export function parseAuthorizationInput(
+	input: string,
+	options: ParseAuthorizationInputOptions = {},
+): ParsedAuthorizationInput {
+	const value = input.trim();
+	if (!value) {
+		return {};
+	}
+
+	try {
+		const url = new URL(value);
+		return {
+			code: url.searchParams.get("code") ?? undefined,
+			state: url.searchParams.get("state") ?? undefined,
+			provider: options.includeProvider
+				? (url.searchParams.get("provider") ?? undefined)
+				: undefined,
+		};
+	} catch {
+		// not a URL
+	}
+
+	if (options.allowHashCodeState && value.includes("#")) {
+		const [code, state] = value.split("#", 2);
+		return {
+			code: code || undefined,
+			state: state || undefined,
+		};
+	}
+
+	if (value.includes("code=")) {
+		const params = new URLSearchParams(value);
+		return {
+			code: params.get("code") ?? undefined,
+			state: params.get("state") ?? undefined,
+			provider: options.includeProvider
+				? (params.get("provider") ?? undefined)
+				: undefined,
+		};
+	}
+
+	return { code: value };
+}
+
+function decodeBase64(value: string): string | null {
+	if (typeof atob === "function") {
+		try {
+			return atob(value);
+		} catch {
+			return null;
+		}
+	}
+
+	if (typeof Buffer !== "undefined") {
+		try {
+			return Buffer.from(value, "base64").toString("utf8");
+		} catch {
+			return null;
+		}
+	}
+
+	return null;
+}
+
+export function decodeJwtPayload(
+	token?: string,
+): Record<string, unknown> | null {
+	if (!token) {
+		return null;
+	}
+
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) {
+			return null;
+		}
+
+		const payload = parts[1];
+		if (!payload) {
+			return null;
+		}
+
+		const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+		const padded = normalized.padEnd(
+			normalized.length + ((4 - (normalized.length % 4)) % 4),
+			"=",
+		);
+		const decoded = decodeBase64(padded);
+		if (!decoded) {
+			return null;
+		}
+		return JSON.parse(decoded) as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+}
+
+export function parseOAuthError(text: string): {
+	code?: string;
+	message?: string;
+} {
+	try {
+		const json = JSON.parse(text) as Record<string, unknown>;
+		const error = json.error;
+		const code =
+			typeof error === "string"
+				? error
+				: error &&
+						typeof error === "object" &&
+						typeof (error as Record<string, unknown>).type === "string"
+					? ((error as Record<string, unknown>).type as string)
+					: undefined;
+		const message =
+			typeof json.error_description === "string"
+				? json.error_description
+				: typeof json.message === "string"
+					? json.message
+					: error &&
+							typeof error === "object" &&
+							typeof (error as Record<string, unknown>).message === "string"
+						? ((error as Record<string, unknown>).message as string)
+						: undefined;
+		return { code, message };
+	} catch {
+		return {};
+	}
+}
+
+export function isCredentialLikelyExpired(
+	credentials: Pick<OAuthCredentials, "expires">,
+	refreshBufferMs: number,
+): boolean {
+	return Date.now() >= credentials.expires - refreshBufferMs;
+}
+
+export async function resolveAuthorizationCodeInput(input: {
+	waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+	cancelWait: () => void;
+	onManualCodeInput?: () => Promise<string>;
+	parseOptions?: ParseAuthorizationInputOptions;
+}): Promise<ParsedAuthorizationInput & { error?: string }> {
+	if (!input.onManualCodeInput) {
+		const callbackResult = await input.waitForCallback();
+		return {
+			code: callbackResult?.code,
+			state: callbackResult?.state,
+			provider: callbackResult?.provider,
+			error: callbackResult?.error,
+		};
+	}
+
+	let manualInput: string | undefined;
+	let manualError: Error | undefined;
+	const manualPromise = input
+		.onManualCodeInput()
+		.then((value) => {
+			manualInput = value;
+			input.cancelWait();
+		})
+		.catch((error: unknown) => {
+			manualError = error instanceof Error ? error : new Error(String(error));
+			input.cancelWait();
+		});
+
+	const callbackResult = await input.waitForCallback();
+	if (manualError) {
+		throw manualError;
+	}
+
+	if (callbackResult?.code || callbackResult?.error) {
+		return {
+			code: callbackResult.code,
+			state: callbackResult.state,
+			provider: callbackResult.provider,
+			error: callbackResult.error,
+		};
+	}
+
+	if (manualInput) {
+		return parseAuthorizationInput(manualInput, input.parseOptions);
+	}
+
+	await manualPromise;
+	if (manualError) {
+		throw manualError;
+	}
+	if (manualInput) {
+		return parseAuthorizationInput(manualInput, input.parseOptions);
+	}
+
+	return {};
+}
diff --git a/sdk/packages/core/src/cline-core/automation.ts b/sdk/packages/core/src/cline-core/automation.ts
new file mode 100644
index 0000000..5ef823b
--- /dev/null
+++ b/sdk/packages/core/src/cline-core/automation.ts
@@ -0,0 +1,250 @@
+import type {
+	AgentExtensionAutomationContext,
+	AgentResult,
+	AutomationEventEnvelope,
+	BasicLogger,
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+	ChatTurnResult,
+	ExtensionContext,
+	ITelemetryService,
+} from "@cline/shared";
+import type { CronEventIngressResult } from "../cron/events/cron-event-ingress";
+import type { CronService } from "../cron/service/cron-service";
+import type { HubScheduleRuntimeHandlers } from "../cron/service/schedule-service";
+import type { RuntimeHost } from "../runtime/host/runtime-host";
+import { normalizeProviderId } from "../services/llms/provider-settings";
+import { SessionSource } from "../types/common";
+import type {
+	ClineAutomationEventIngressResult,
+	ClineAutomationEventLog,
+	ClineAutomationListEventsOptions,
+	ClineAutomationListRunsOptions,
+	ClineAutomationListSpecsOptions,
+	ClineAutomationRun,
+	ClineAutomationSpec,
+	ClineCoreAutomationApi,
+	ClineCoreAutomationOptions,
+} from "./types";
+
+export function normalizeAutomationOptions(
+	options: ClineCoreAutomationOptions | boolean | undefined,
+): ClineCoreAutomationOptions | undefined {
+	if (options === true) return {};
+	if (!options) return undefined;
+	return options;
+}
+
+export function normalizeAutomationCronScope(
+	scope: ClineCoreAutomationOptions["cronScope"],
+): "global" | "workspace" | undefined {
+	if (scope === "user") return "global";
+	return scope;
+}
+
+export class ClineCoreAutomationController implements ClineCoreAutomationApi {
+	constructor(private readonly getService: () => CronService) {}
+
+	async start(): Promise<void> {
+		await this.getService().start();
+	}
+
+	async stop(): Promise<void> {
+		await this.getService().stop();
+	}
+
+	async reconcileNow(): Promise<void> {
+		await this.getService().reconcileNow();
+	}
+
+	ingestEvent(
+		event: AutomationEventEnvelope,
+	): ClineAutomationEventIngressResult {
+		const result: CronEventIngressResult = this.getService().ingestEvent(event);
+		return {
+			event: result.event,
+			duplicate: result.duplicate,
+			matchedSpecIds: result.matchedSpecs.map((spec) => spec.specId),
+			queuedRuns: result.queuedRuns,
+			suppressions: result.suppressions,
+		};
+	}
+
+	listEvents(
+		options?: ClineAutomationListEventsOptions,
+	): ClineAutomationEventLog[] {
+		return this.getService().listEventLogs(options);
+	}
+
+	getEvent(eventId: string): ClineAutomationEventLog | undefined {
+		return this.getService().getEventLog(eventId);
+	}
+
+	listSpecs(options?: ClineAutomationListSpecsOptions): ClineAutomationSpec[] {
+		return this.getService().listSpecs(options);
+	}
+
+	listRuns(options?: ClineAutomationListRunsOptions): ClineAutomationRun[] {
+		return this.getService().listRuns(options);
+	}
+}
+
+export interface ClineCoreAutomationRuntimeHandlersInput {
+	host: RuntimeHost;
+	getExtensionContext(): ExtensionContext | undefined;
+}
+
+export function createClineCoreAutomationRuntimeHandlers(
+	input: ClineCoreAutomationRuntimeHandlersInput,
+): HubScheduleRuntimeHandlers {
+	const { host } = input;
+	return {
+		async startSession(request) {
+			const cwd = (request.cwd?.trim() || request.workspaceRoot).trim();
+			const started = await host.startSession({
+				source: request.source?.trim() || SessionSource.CLI,
+				interactive: false,
+				config: {
+					providerId: normalizeProviderId(request.provider),
+					modelId: request.model,
+					apiKey: request.apiKey?.trim() || undefined,
+					cwd,
+					workspaceRoot: request.workspaceRoot,
+					systemPrompt: request.systemPrompt ?? "",
+					mode: resolveMode(request),
+					maxIterations: request.maxIterations,
+					enableTools: request.enableTools !== false,
+					enableSpawnAgent: request.enableSpawn !== false,
+					enableAgentTeams: request.enableTeams !== false,
+					disableMcpSettingsTools: request.disableMcpSettingsTools,
+					missionLogIntervalSteps: request.missionStepInterval,
+					missionLogIntervalMs: request.missionTimeIntervalMs,
+				},
+				toolPolicies: request.toolPolicies ?? {
+					"*": {
+						autoApprove: request.autoApproveTools !== false,
+					},
+				},
+				localRuntime: {
+					extensionContext: input.getExtensionContext(),
+					configExtensions: request.configExtensions,
+				},
+			});
+			return {
+				sessionId: started.sessionId,
+				startResult: {
+					sessionId: started.sessionId,
+					manifestPath: started.manifestPath,
+					messagesPath: started.messagesPath,
+				},
+			};
+		},
+		async sendSession(sessionId, request) {
+			const result = await host.runTurn({
+				sessionId,
+				prompt: request.prompt,
+				userImages: request.attachments?.userImages,
+				userFiles: request.attachments?.userFiles?.map((file) => file.content),
+				delivery: request.delivery,
+			});
+			if (!result) {
+				throw new Error("ClineCore automation runtime returned no result");
+			}
+			return { result: toChatTurnResult(result) };
+		},
+		async abortSession(sessionId) {
+			await host.abort(sessionId, new Error("ClineCore automation abort"));
+			return { applied: true };
+		},
+		async stopSession(sessionId) {
+			await host.stopSession(sessionId);
+			return { applied: true };
+		},
+	};
+}
+
+export interface ClineCoreAutomationExtensionContextInput {
+	automationService?: CronService;
+	automation: ClineCoreAutomationApi;
+	context?: ExtensionContext;
+	clientName?: string;
+	distinctId?: string;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}
+
+export function createClineCoreAutomationExtensionContext(
+	input: ClineCoreAutomationExtensionContextInput,
+): ExtensionContext | undefined {
+	const automation = createAutomationPluginContext(
+		input.automationService,
+		input.automation,
+	);
+	const client =
+		input.context?.client ??
+		(input.clientName ? { name: input.clientName } : undefined);
+	const user =
+		input.context?.user ??
+		(input.distinctId ? { distinctId: input.distinctId } : undefined);
+	const logger = input.context?.logger ?? input.logger;
+	const telemetry = input.context?.telemetry ?? input.telemetry;
+	if (!automation && !client && !user && !logger && !telemetry) {
+		return input.context;
+	}
+	return {
+		...(input.context ?? {}),
+		...(client ? { client } : {}),
+		...(user ? { user } : {}),
+		...(logger ? { logger } : {}),
+		...(telemetry ? { telemetry } : {}),
+		...(automation ? { automation } : {}),
+	};
+}
+
+function createAutomationPluginContext(
+	automationService: CronService | undefined,
+	automation: ClineCoreAutomationApi,
+): AgentExtensionAutomationContext | undefined {
+	if (!automationService) {
+		return undefined;
+	}
+	return {
+		ingestEvent: (event: AutomationEventEnvelope) => {
+			automation.ingestEvent(event);
+		},
+	};
+}
+
+function toChatTurnResult(result: AgentResult): ChatTurnResult {
+	return {
+		text: result.text,
+		usage: {
+			inputTokens: result.usage.inputTokens,
+			outputTokens: result.usage.outputTokens,
+			cacheReadTokens: result.usage.cacheReadTokens,
+			cacheWriteTokens: result.usage.cacheWriteTokens,
+			totalCost: result.usage.totalCost,
+		},
+		inputTokens: result.usage.inputTokens,
+		outputTokens: result.usage.outputTokens,
+		iterations: result.iterations,
+		finishReason: result.finishReason,
+		toolCalls: result.toolCalls.map((call) => ({
+			name: call.name,
+			input: call.input,
+			output: call.output,
+			error: call.error,
+			durationMs: call.durationMs,
+		})),
+	};
+}
+
+function resolveMode(
+	request: ChatStartSessionRequest | ChatRunTurnRequest["config"],
+): "act" | "plan" | "yolo" {
+	return request.mode === "plan"
+		? "plan"
+		: request.mode === "yolo"
+			? "yolo"
+			: "act";
+}
diff --git a/sdk/packages/core/src/cline-core/runtime-services.ts b/sdk/packages/core/src/cline-core/runtime-services.ts
new file mode 100644
index 0000000..7bd348b
--- /dev/null
+++ b/sdk/packages/core/src/cline-core/runtime-services.ts
@@ -0,0 +1,77 @@
+import type {
+	PendingPromptsRuntimeService,
+	PendingPromptsServiceApi,
+	RuntimeHost,
+	SessionConnectionRuntimeService,
+	SessionModelRuntimeService,
+	SessionUsageRuntimeService,
+} from "../runtime/host/runtime-host";
+import {
+	type ClineCoreSettingsApi,
+	type CoreSettingsListInput,
+	type CoreSettingsMutationResult,
+	type CoreSettingsSnapshot,
+	type CoreSettingsToggleInput,
+	createCoreSettingsService,
+} from "../settings";
+
+type RuntimeHostWithSettings = RuntimeHost & {
+	listSettings?: (
+		input?: CoreSettingsListInput,
+	) => Promise<CoreSettingsSnapshot>;
+	toggleSetting?: (
+		input: CoreSettingsToggleInput,
+	) => Promise<CoreSettingsMutationResult>;
+};
+
+export type RuntimeHostServiceExtensions = RuntimeHost &
+	Partial<
+		PendingPromptsRuntimeService &
+			SessionUsageRuntimeService &
+			SessionConnectionRuntimeService &
+			SessionModelRuntimeService
+	>;
+
+export function createClineCoreSettingsApi(
+	host: RuntimeHost,
+): ClineCoreSettingsApi {
+	return {
+		async list(input) {
+			const settingsHost = host as RuntimeHostWithSettings;
+			if (settingsHost.listSettings) {
+				return await settingsHost.listSettings(input);
+			}
+			return await createCoreSettingsService().list(input);
+		},
+		async toggle(input) {
+			const settingsHost = host as RuntimeHostWithSettings;
+			if (settingsHost.toggleSetting) {
+				return await settingsHost.toggleSetting(input);
+			}
+			return await createCoreSettingsService().toggle(input);
+		},
+	};
+}
+
+export function createClineCorePendingPromptsApi(
+	host: RuntimeHost,
+): PendingPromptsServiceApi {
+	function getService(): PendingPromptsServiceApi {
+		const service = (host as RuntimeHostServiceExtensions).pendingPrompts;
+		if (!service) {
+			throw new Error("Pending prompt service is not available.");
+		}
+		return service;
+	}
+	return {
+		list(input) {
+			return getService().list(input);
+		},
+		update(input) {
+			return getService().update(input);
+		},
+		delete(input) {
+			return getService().delete(input);
+		},
+	};
+}
diff --git a/sdk/packages/core/src/cline-core/start-input.ts b/sdk/packages/core/src/cline-core/start-input.ts
new file mode 100644
index 0000000..4631bb2
--- /dev/null
+++ b/sdk/packages/core/src/cline-core/start-input.ts
@@ -0,0 +1,91 @@
+import type { ExtensionContext } from "@cline/shared";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import { normalizeRuntimeCapabilities } from "../runtime/capabilities";
+import type {
+	LocalRuntimeStartOptions,
+	StartSessionInput,
+} from "../runtime/host/runtime-host";
+import { splitCoreSessionConfig } from "../runtime/host/runtime-host";
+import type { CoreSessionConfig } from "../types/config";
+import type { ClineCoreStartInput } from "./types";
+
+export function toClineCoreStartInput(
+	input: StartSessionInput | ClineCoreStartInput,
+): ClineCoreStartInput {
+	const config = input.config as CoreSessionConfig;
+	return "providerId" in config
+		? {
+				...input,
+				config: {
+					...config,
+					...coreConfigFromLocalRuntime(input.localRuntime),
+				},
+				localRuntime: input.localRuntime,
+			}
+		: (input as ClineCoreStartInput);
+}
+
+export interface NormalizeClineCoreStartInputOptions {
+	defaultCapabilities?: RuntimeCapabilities;
+	withExtensionContext?: (
+		context?: ExtensionContext,
+	) => ExtensionContext | undefined;
+}
+
+export function normalizeClineCoreStartInput(
+	input: ClineCoreStartInput,
+	options: NormalizeClineCoreStartInputOptions = {},
+): StartSessionInput {
+	const split = splitCoreSessionConfig(input.config);
+	const capabilities = normalizeRuntimeCapabilities(
+		options.defaultCapabilities,
+		input.capabilities,
+	);
+	let localRuntime = mergeLocalRuntimeStartOptions(
+		split.localRuntime,
+		input.localRuntime,
+	);
+	const extensionContext = options.withExtensionContext?.(
+		localRuntime?.extensionContext,
+	);
+	if (extensionContext) {
+		localRuntime = {
+			...(localRuntime ?? {}),
+			extensionContext,
+		};
+	}
+	return {
+		...input,
+		...split,
+		...(localRuntime ? { localRuntime } : {}),
+		...(capabilities ? { capabilities } : {}),
+	};
+}
+
+function coreConfigFromLocalRuntime(
+	localRuntime: LocalRuntimeStartOptions | undefined,
+): Partial<CoreSessionConfig> {
+	if (!localRuntime) {
+		return {};
+	}
+	const {
+		modelCatalogDefaults: _modelCatalogDefaults,
+		userInstructionService: _userInstructionService,
+		configExtensions: _configExtensions,
+		onTeamRestored: _onTeamRestored,
+		...localConfig
+	} = localRuntime;
+	return localConfig;
+}
+
+function mergeLocalRuntimeStartOptions(
+	...sources: Array<LocalRuntimeStartOptions | undefined>
+): LocalRuntimeStartOptions | undefined {
+	const merged: LocalRuntimeStartOptions = {};
+	for (const source of sources) {
+		if (source) {
+			Object.assign(merged, source);
+		}
+	}
+	return Object.keys(merged).length > 0 ? merged : undefined;
+}
diff --git a/sdk/packages/core/src/cline-core/telemetry.ts b/sdk/packages/core/src/cline-core/telemetry.ts
new file mode 100644
index 0000000..bc35013
--- /dev/null
+++ b/sdk/packages/core/src/cline-core/telemetry.ts
@@ -0,0 +1,39 @@
+import type { ITelemetryService } from "@cline/shared";
+import { CORE_TELEMETRY_EVENTS } from "../services/telemetry/core-events";
+import { SessionSource } from "../types/common";
+import type { ClineCoreStartInput } from "./types";
+
+export interface EmitSessionStartedTelemetryInput {
+	input: ClineCoreStartInput;
+	sessionId: string;
+	telemetry?: ITelemetryService;
+	clientName?: string;
+	runtimeAddress?: string;
+}
+
+export function emitSessionStartedTelemetry(
+	input: EmitSessionStartedTelemetryInput,
+): void {
+	// Per-session telemetry override (passed via `CoreSessionConfig.telemetry`)
+	// takes precedence over the instance-wide telemetry service configured on
+	// `ClineCore.create`. Either way we fire a single `session.started` event
+	// here so the signal is emitted for every backend.
+	const telemetry = input.input.config.telemetry ?? input.telemetry;
+	if (!telemetry) {
+		return;
+	}
+	telemetry.capture({
+		event: CORE_TELEMETRY_EVENTS.SESSION.STARTED,
+		properties: {
+			sessionId: input.sessionId,
+			source: input.input.source ?? SessionSource.CORE,
+			providerId: input.input.config.providerId,
+			modelId: input.input.config.modelId,
+			enableTools: input.input.config.enableTools,
+			enableSpawnAgent: input.input.config.enableSpawnAgent,
+			enableAgentTeams: input.input.config.enableAgentTeams,
+			clientName: input.clientName,
+			runtimeAddress: input.runtimeAddress,
+		},
+	});
+}
diff --git a/sdk/packages/core/src/cline-core/types.ts b/sdk/packages/core/src/cline-core/types.ts
new file mode 100644
index 0000000..a0e0d3d
--- /dev/null
+++ b/sdk/packages/core/src/cline-core/types.ts
@@ -0,0 +1,289 @@
+import type { Message } from "@cline/llms";
+import type {
+	AgentConfig,
+	AutomationEventEnvelope,
+	BasicLogger,
+	ITelemetryService,
+} from "@cline/shared";
+import type { CronEventSuppression } from "../cron/events/cron-event-ingress";
+import type {
+	CronEventLogRecord,
+	CronRunRecord,
+	CronSpecRecord,
+} from "../cron/store/sqlite-cron-store";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { CheckpointWorkspaceCompareResult } from "../session/checkpoint-diff";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { SessionHistoryListOptions } from "../runtime/host/history";
+import type { SessionBackend } from "../runtime/host/host";
+import type {
+	LocalRuntimeStartOptions,
+	RuntimeHostMode,
+	StartSessionInput,
+	StartSessionResult,
+} from "../runtime/host/runtime-host";
+import type { FeatureFlagsService } from "../services/feature-flags";
+import type { CoreSessionConfig } from "../types/config";
+import type { SessionMessagesArtifactUploader } from "../types/session";
+
+export type { RuntimeHostMode } from "../runtime/host/runtime-host";
+export type { ClineCoreSettingsApi } from "../settings";
+
+export interface HubOptions {
+	endpoint?: string;
+	authToken?: string;
+	strategy?: "prefer-hub" | "require-hub";
+	clientType?: string;
+	displayName?: string;
+	workspaceRoot?: string;
+	cwd?: string;
+}
+
+export interface RemoteOptions {
+	endpoint: string;
+	authToken?: string;
+	clientType?: string;
+	displayName?: string;
+	workspaceRoot?: string;
+	cwd?: string;
+}
+
+export interface ClineCoreAutomationOptions {
+	/** @deprecated Use `cronSpecsDir`. */
+	cronDir?: string;
+	cronSpecsDir?: string;
+	/** @deprecated Reports are written under the resolved cron specs directory. */
+	reportsDir?: string;
+	cronScope?: "global" | "user" | "workspace";
+	workspaceRoot?: string;
+	dbPath?: string;
+	pollIntervalMs?: number;
+	claimLeaseSeconds?: number;
+	globalMaxConcurrency?: number;
+	watcherDebounceMs?: number;
+	autoStart?: boolean;
+}
+
+export type ClineAutomationSpec = CronSpecRecord;
+export type ClineAutomationRun = CronRunRecord;
+export type ClineAutomationEventLog = CronEventLogRecord;
+export type ClineAutomationEventSuppression = CronEventSuppression;
+export type ClineAutomationRunStatus =
+	| "queued"
+	| "running"
+	| "done"
+	| "failed"
+	| "cancelled";
+
+export interface ClineAutomationListSpecsOptions {
+	triggerKind?: "one_off" | "schedule" | "event";
+	enabled?: boolean;
+	parseStatus?: "valid" | "invalid";
+	includeRemoved?: boolean;
+	limit?: number;
+}
+
+export interface ClineAutomationListRunsOptions {
+	specId?: string;
+	status?: ClineAutomationRunStatus | ClineAutomationRunStatus[];
+	limit?: number;
+}
+
+export interface ClineAutomationListEventsOptions {
+	eventType?: string;
+	source?: string;
+	processingStatus?:
+		| "received"
+		| "unmatched"
+		| "queued"
+		| "suppressed"
+		| "failed";
+	limit?: number;
+}
+
+export interface ClineAutomationEventIngressResult {
+	event: ClineAutomationEventLog;
+	duplicate: boolean;
+	matchedSpecIds: string[];
+	queuedRuns: ClineAutomationRun[];
+	suppressions: ClineAutomationEventSuppression[];
+}
+
+export interface ClineCoreAutomationApi {
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	reconcileNow(): Promise<void>;
+	ingestEvent(
+		event: AutomationEventEnvelope,
+	): ClineAutomationEventIngressResult;
+	listEvents(
+		options?: ClineAutomationListEventsOptions,
+	): ClineAutomationEventLog[];
+	getEvent(eventId: string): ClineAutomationEventLog | undefined;
+	listSpecs(options?: ClineAutomationListSpecsOptions): ClineAutomationSpec[];
+	listRuns(options?: ClineAutomationListRunsOptions): ClineAutomationRun[];
+}
+
+export type ClineCoreListHistoryOptions = SessionHistoryListOptions;
+
+export interface ClineCoreStartInput
+	extends Omit<StartSessionInput, "config" | "localRuntime"> {
+	config: CoreSessionConfig;
+	localRuntime?: LocalRuntimeStartOptions;
+}
+
+export interface RestoreOptions {
+	/**
+	 * Restore the message history by starting a new session fork trimmed to
+	 * `checkpointRunCount`. Defaults to true.
+	 */
+	messages?: boolean;
+	/**
+	 * Restore the workspace files from the checkpoint's git snapshot.
+	 * Defaults to true.
+	 */
+	workspace?: boolean;
+	/**
+	 * Start the forked session with messages before the checkpoint user message
+	 * while still returning messages through that user message. This is for
+	 * clients that put the checkpoint message back into a compose box so it can
+	 * be edited and submitted again without duplicating it in session history.
+	 */
+	omitCheckpointMessageFromSession?: boolean;
+}
+
+export interface RestoreInput {
+	sessionId: string;
+	checkpointRunCount: number;
+	start?: ClineCoreStartInput;
+	cwd?: string;
+	restore?: RestoreOptions;
+}
+
+export interface RestoreResult {
+	sessionId?: string;
+	startResult?: StartSessionResult;
+	messages?: Message[];
+	checkpoint: CheckpointEntry;
+}
+
+export interface CompareCheckpointInput {
+	sessionId: string;
+	checkpointRunCount: number;
+	cwd?: string;
+}
+
+export type CompareCheckpointResult = CheckpointWorkspaceCompareResult;
+
+export interface ClineCoreOptions {
+	/**
+	 * A human-readable name for this SDK client (e.g. `"my-app"`, `"acme-bot"`).
+	 * Used to identify the consumer in telemetry and logs.
+	 */
+	clientName?: string;
+	/**
+	 * A stable identifier for this machine or user, used for telemetry attribution.
+	 * Defaults to the system machine ID, falling back to a generated `cl-<nanoid>` persisted
+	 * at `~/.cline/data/machine-id`.
+	 */
+	distinctId?: string;
+	/**
+	 * Controls how the runtime host is selected:
+	 * - `"auto"` (default) — prefers a compatible local hub when one is available and falls
+	 *   back to local in-process execution when not.
+	 * - `"hub"` — requires a compatible websocket hub runtime; throws if one is not reachable.
+	 * - `"remote"` — requires an explicit remote websocket hub endpoint.
+	 * - `"local"` — always uses local in-process execution and local SQLite/file storage.
+	 */
+	backendMode?: RuntimeHostMode;
+	/**
+	 * Hub runtime connection options. Used when `backendMode` is `"hub"` or when `"auto"`
+	 * should prefer a shared local hub if available.
+	 */
+	hub?: HubOptions;
+	/**
+	 * Remote hub connection options. Only relevant when `backendMode` is `"remote"`.
+	 */
+	remote?: RemoteOptions;
+	/**
+	 * Client-owned runtime capabilities. Core adapts these handlers to the
+	 * selected runtime backend so apps implement interactive behavior once.
+	 */
+	capabilities?: RuntimeCapabilities;
+	/**
+	 * Telemetry service instance to use for capturing events and usage.
+	 * If omitted, telemetry is a no-op.
+	 */
+	telemetry?: ITelemetryService;
+	/**
+	 * Feature flags service for this ClineCore instance.
+	 * If omitted, Core uses a no-op provider with default flag values.
+	 */
+	featureFlags?: FeatureFlagsService;
+	/**
+	 * Optional structured logger for core-side operational diagnostics such as
+	 * runtime-host selection and fallback decisions.
+	 */
+	logger?: BasicLogger;
+	/**
+	 * Per-tool approval policies that control whether a tool runs automatically,
+	 * requires user confirmation, or is blocked entirely.
+	 */
+	toolPolicies?: AgentConfig["toolPolicies"];
+	/**
+	 * Optional hook invoked after `messages.json` is persisted to disk.
+	 * Consumers can use this to mirror session transcripts into remote storage.
+	 */
+	messagesArtifactUploader?: SessionMessagesArtifactUploader;
+	/**
+	 * Enables file-based and event-driven automation through this ClineCore
+	 * instance. When configured, callers use `cline.automation.*` instead of
+	 * constructing cron services directly.
+	 */
+	automation?: boolean | ClineCoreAutomationOptions;
+	/**
+	 * Custom `fetch` implementation forwarded to the AI gateway providers used
+	 * by local sessions. When supplied, it is threaded into each
+	 * `ProviderConfig.fetch` built during session bootstrap, which in turn
+	 * populates `GatewayProviderSettings.fetch` (and the top-level
+	 * `GatewayConfig.fetch` fallback) so hosts can inject custom HTTP behavior
+	 * such as proxies, retries, tracing, or test doubles.
+	 *
+	 * Per-session or per-provider overrides still win: an explicit
+	 * `config.fetch` on `CoreSessionConfig` or a stored provider-level `fetch`
+	 * takes precedence over this default.
+	 *
+	 * Applies only to sessions executed in this process (local and fallback-
+	 * to-local auto mode). For hub and remote runtimes the HTTP call happens
+	 * inside the process that owns the gateway, so configure `fetch` there:
+	 *   - `startHubServer({ fetch })` / `ensureHubServer({ fetch })` from
+	 *     `@cline/hub`
+	 *   - `createLocalHubScheduleRuntimeHandlers({ fetch })` from
+	 *     `@cline/core/hub` for the scheduler
+	 */
+	fetch?: typeof fetch;
+	/**
+	 * An already-constructed session backend to use instead of resolving one automatically.
+	 * Intended for testing or embedding a custom persistence layer.
+	 * @internal
+	 */
+	sessionService?: SessionBackend;
+	/**
+	 * Optional hook invoked before each session starts.
+	 * Use this to prepare workspace-scoped runtime state and then return an
+	 * adapter that mutates the shared session input before core starts the run.
+	 */
+	prepare?: (
+		input: ClineCoreStartInput,
+	) =>
+		| Promise<StartSessionBootstrap | undefined>
+		| StartSessionBootstrap
+		| undefined;
+}
+
+export interface StartSessionBootstrap {
+	applyToStartSessionInput(
+		input: ClineCoreStartInput,
+	): Promise<ClineCoreStartInput> | ClineCoreStartInput;
+	dispose?(): Promise<void> | void;
+}
diff --git a/sdk/packages/core/src/cron/events/cron-event-ingress.test.ts b/sdk/packages/core/src/cron/events/cron-event-ingress.test.ts
new file mode 100644
index 0000000..40e9189
--- /dev/null
+++ b/sdk/packages/core/src/cron/events/cron-event-ingress.test.ts
@@ -0,0 +1,255 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CronEventSpec } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import {
+	automationEventMatchesFilters,
+	CronEventIngress,
+} from "./cron-event-ingress";
+
+describe("automationEventMatchesFilters", () => {
+	it("matches attributes by default and supports dot paths", () => {
+		expect(
+			automationEventMatchesFilters(
+				{
+					eventId: "evt_1",
+					eventType: "github.pull_request.opened",
+					source: "github",
+					occurredAt: "2026-04-23T10:00:00.000Z",
+					attributes: {
+						repository: "acme/api",
+						pullRequest: { baseBranch: "main" },
+					},
+				},
+				{
+					repository: "acme/api",
+					"pullRequest.baseBranch": "main",
+				},
+			),
+		).toBe(true);
+	});
+});
+
+describe("CronEventIngress", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+	let nowMs: number;
+	let ingress: CronEventIngress;
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "cline-event-ingress-"));
+		store = new SqliteCronStore({ dbPath: join(dir, "cron.db") });
+		nowMs = Date.parse("2026-04-23T10:00:00.000Z");
+		ingress = new CronEventIngress({ store, now: () => nowMs });
+	});
+
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	function seedEventSpec(overrides: Partial<CronEventSpec> = {}) {
+		const spec: CronEventSpec = {
+			triggerKind: "event",
+			id: "pr-review",
+			title: "PR Review",
+			prompt: "Review the PR",
+			workspaceRoot: "/ws",
+			enabled: true,
+			event: "github.pull_request.opened",
+			filters: { repository: "acme/api" },
+			...overrides,
+		};
+		return store.upsertSpec({
+			externalId: spec.id ?? "pr-review",
+			sourcePath: `events/${spec.id ?? "pr-review"}.event.md`,
+			triggerKind: "event",
+			sourceHash: JSON.stringify(spec),
+			parseStatus: "valid",
+			spec,
+		}).record;
+	}
+
+	it("persists a normalized event and queues matching event runs", () => {
+		const spec = seedEventSpec({
+			filters: {
+				repository: "acme/api",
+				"pullRequest.baseBranch": "main",
+			},
+		});
+
+		const result = ingress.ingestEvent({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T09:59:59.000Z",
+			attributes: {
+				repository: "acme/api",
+				pullRequest: { baseBranch: "main" },
+			},
+			payload: { action: "opened" },
+		});
+
+		expect(result.duplicate).toBe(false);
+		expect(result.matchedSpecs).toHaveLength(1);
+		expect(result.queuedRuns).toHaveLength(1);
+		expect(result.queuedRuns[0]?.specId).toBe(spec.specId);
+		expect(result.queuedRuns[0]?.triggerKind).toBe("event");
+		expect(result.queuedRuns[0]?.triggerEventId).toBe("evt_1");
+		expect(result.event.processingStatus).toBe("queued");
+		expect(result.event.dedupeKey).toBe(
+			"github.pull_request.opened:github:acme/api#12",
+		);
+	});
+
+	it("records unmatched events without queuing", () => {
+		seedEventSpec({ filters: { repository: "acme/api" } });
+
+		const result = ingress.ingestEvent({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/web#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			attributes: { repository: "acme/web" },
+		});
+
+		expect(result.matchedSpecs).toHaveLength(0);
+		expect(result.queuedRuns).toHaveLength(0);
+		expect(result.event.processingStatus).toBe("unmatched");
+		expect(store.listRuns()).toHaveLength(0);
+	});
+
+	it("queues one run per concurrently matching event spec", () => {
+		const first = seedEventSpec({ id: "pr-review-a" });
+		const second = seedEventSpec({
+			id: "pr-review-b",
+			filters: { repository: "acme/api", label: "security" },
+		});
+
+		const result = ingress.ingestEvent({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			attributes: { repository: "acme/api", label: "security" },
+		});
+
+		expect(result.matchedSpecs.map((spec) => spec.specId).sort()).toEqual(
+			[first.specId, second.specId].sort(),
+		);
+		expect(result.queuedRuns).toHaveLength(2);
+		expect(store.listRuns()).toHaveLength(2);
+	});
+
+	it("treats duplicate event ids as replay and does not requeue", () => {
+		seedEventSpec();
+		const event = {
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			attributes: { repository: "acme/api" },
+		};
+
+		expect(ingress.ingestEvent(event).queuedRuns).toHaveLength(1);
+		const duplicate = ingress.ingestEvent(event);
+
+		expect(duplicate.duplicate).toBe(true);
+		expect(duplicate.queuedRuns).toHaveLength(0);
+		expect(store.listRuns()).toHaveLength(1);
+	});
+
+	it("suppresses events inside a dedupe window", () => {
+		seedEventSpec({ dedupeWindowSeconds: 600 });
+		ingress.ingestEvent({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			dedupeKey: "pr:12",
+			attributes: { repository: "acme/api" },
+		});
+		nowMs = Date.parse("2026-04-23T10:01:00.000Z");
+
+		const suppressed = ingress.ingestEvent({
+			eventId: "evt_2",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:01:00.000Z",
+			dedupeKey: "pr:12",
+			attributes: { repository: "acme/api" },
+		});
+
+		expect(suppressed.queuedRuns).toHaveLength(0);
+		expect(suppressed.event.processingStatus).toBe("suppressed");
+		expect(suppressed.suppressions[0]?.reason).toBe("dedupe_window");
+		expect(store.listRuns()).toHaveLength(1);
+	});
+
+	it("extends a pending debounced run instead of creating another run", () => {
+		seedEventSpec({ debounceSeconds: 30 });
+		const first = ingress.ingestEvent({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			dedupeKey: "pr:12",
+			attributes: { repository: "acme/api" },
+		});
+		nowMs = Date.parse("2026-04-23T10:00:10.000Z");
+
+		const second = ingress.ingestEvent({
+			eventId: "evt_2",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:10.000Z",
+			dedupeKey: "pr:12",
+			attributes: { repository: "acme/api" },
+		});
+
+		expect(second.queuedRuns).toHaveLength(1);
+		expect(second.queuedRuns[0]?.runId).toBe(first.queuedRuns[0]?.runId);
+		expect(second.queuedRuns[0]?.triggerEventId).toBe("evt_2");
+		expect(second.queuedRuns[0]?.scheduledFor).toBe("2026-04-23T10:00:40.000Z");
+		expect(store.listRuns()).toHaveLength(1);
+	});
+
+	it("suppresses events during cooldown regardless of dedupe key", () => {
+		seedEventSpec({ cooldownSeconds: 300 });
+		ingress.ingestEvent({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			dedupeKey: "pr:12",
+			attributes: { repository: "acme/api" },
+		});
+		nowMs = Date.parse("2026-04-23T10:02:00.000Z");
+
+		const suppressed = ingress.ingestEvent({
+			eventId: "evt_2",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#13",
+			occurredAt: "2026-04-23T10:02:00.000Z",
+			dedupeKey: "pr:13",
+			attributes: { repository: "acme/api" },
+		});
+
+		expect(suppressed.queuedRuns).toHaveLength(0);
+		expect(suppressed.event.processingStatus).toBe("suppressed");
+		expect(suppressed.suppressions[0]?.reason).toBe("cooldown");
+		expect(store.listRuns()).toHaveLength(1);
+	});
+});
diff --git a/sdk/packages/core/src/cron/events/cron-event-ingress.ts b/sdk/packages/core/src/cron/events/cron-event-ingress.ts
new file mode 100644
index 0000000..4b28bd5
--- /dev/null
+++ b/sdk/packages/core/src/cron/events/cron-event-ingress.ts
@@ -0,0 +1,357 @@
+import type { AutomationEventEnvelope, BasicLogger } from "@cline/shared";
+import type {
+	CronEventLogRecord,
+	CronRunRecord,
+	CronSpecRecord,
+	SqliteCronStore,
+} from "../store/sqlite-cron-store";
+
+/**
+ * Durable ingress for normalized automation events.
+ *
+ * This layer persists the incoming event before matching, then materializes
+ * queued `cron_runs` for matching event specs. It deliberately does not
+ * execute agents; the normal runner claim loop owns execution.
+ */
+
+export interface CronEventIngressOptions {
+	store: SqliteCronStore;
+	now?: () => number;
+	logger?: BasicLogger;
+}
+
+export type CronEventSuppressionReason =
+	| "duplicate_event"
+	| "filter_mismatch"
+	| "dedupe_window"
+	| "cooldown";
+
+export interface CronEventSuppression {
+	specId?: string;
+	externalId?: string;
+	reason: CronEventSuppressionReason;
+	dedupeKey?: string;
+}
+
+export interface CronEventIngressResult {
+	event: CronEventLogRecord;
+	duplicate: boolean;
+	matchedSpecs: CronSpecRecord[];
+	queuedRuns: CronRunRecord[];
+	suppressions: CronEventSuppression[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function trimOrUndefined(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function normalizeIso(value: string | undefined, fallback: string): string {
+	const candidate = value?.trim();
+	if (!candidate) return fallback;
+	const ms = Date.parse(candidate);
+	if (!Number.isFinite(ms)) return fallback;
+	return new Date(ms).toISOString();
+}
+
+function addSeconds(iso: string, seconds: number): string {
+	return new Date(
+		new Date(iso).getTime() + Math.max(0, Math.floor(seconds)) * 1000,
+	).toISOString();
+}
+
+function subtractSeconds(iso: string, seconds: number): string {
+	return new Date(
+		new Date(iso).getTime() - Math.max(0, Math.floor(seconds)) * 1000,
+	).toISOString();
+}
+
+function maxIso(a: string | undefined, b: string): string {
+	if (!a) return b;
+	return new Date(a).getTime() >= new Date(b).getTime() ? a : b;
+}
+
+function normalizeEvent(
+	event: AutomationEventEnvelope,
+	receivedAt: string,
+): AutomationEventEnvelope {
+	const eventId = event.eventId.trim();
+	const eventType = event.eventType.trim();
+	const source = event.source.trim();
+	const subject = trimOrUndefined(event.subject);
+	const dedupeKey =
+		trimOrUndefined(event.dedupeKey) ??
+		`${eventType}:${source}:${subject ?? eventId}`;
+	return {
+		eventId,
+		eventType,
+		source,
+		subject,
+		occurredAt: normalizeIso(event.occurredAt, receivedAt),
+		workspaceRoot: trimOrUndefined(event.workspaceRoot),
+		payload: isRecord(event.payload) ? event.payload : undefined,
+		attributes: isRecord(event.attributes) ? event.attributes : undefined,
+		dedupeKey,
+	};
+}
+
+function getPath(value: unknown, path: string): unknown {
+	if (!path) return undefined;
+	const parts = path.split(".");
+	let current: unknown = value;
+	for (const part of parts) {
+		if (!isRecord(current)) return undefined;
+		current = current[part];
+	}
+	return current;
+}
+
+function resolveFilterValue(
+	event: AutomationEventEnvelope,
+	filterKey: string,
+): unknown {
+	if (event.attributes && Object.hasOwn(event.attributes, filterKey)) {
+		return event.attributes[filterKey];
+	}
+	if (event.payload && Object.hasOwn(event.payload, filterKey)) {
+		return event.payload[filterKey];
+	}
+	const candidate = {
+		eventId: event.eventId,
+		eventType: event.eventType,
+		source: event.source,
+		subject: event.subject,
+		occurredAt: event.occurredAt,
+		workspaceRoot: event.workspaceRoot,
+		dedupeKey: event.dedupeKey,
+		attributes: event.attributes,
+		payload: event.payload,
+	};
+	const direct = getPath(candidate, filterKey);
+	if (direct !== undefined) return direct;
+	if (event.attributes) {
+		const fromAttributes = getPath(event.attributes, filterKey);
+		if (fromAttributes !== undefined) return fromAttributes;
+	}
+	if (event.payload) {
+		return getPath(event.payload, filterKey);
+	}
+	return undefined;
+}
+
+function matchesExpected(actual: unknown, expected: unknown): boolean {
+	if (Array.isArray(expected)) {
+		return expected.some((item) => matchesExpected(actual, item));
+	}
+	if (Array.isArray(actual)) {
+		return actual.some((item) => matchesExpected(item, expected));
+	}
+	if (isRecord(expected)) {
+		if (!isRecord(actual)) return false;
+		return Object.entries(expected).every(([key, value]) =>
+			matchesExpected(actual[key], value),
+		);
+	}
+	return Object.is(actual, expected);
+}
+
+export function automationEventMatchesFilters(
+	event: AutomationEventEnvelope,
+	filters: Record<string, unknown> | undefined,
+): boolean {
+	if (!filters || Object.keys(filters).length === 0) return true;
+	return Object.entries(filters).every(([key, expected]) =>
+		matchesExpected(resolveFilterValue(event, key), expected),
+	);
+}
+
+export class CronEventIngress {
+	private readonly store: SqliteCronStore;
+	private readonly nowFn: () => number;
+	private readonly logger?: BasicLogger;
+
+	constructor(options: CronEventIngressOptions) {
+		this.store = options.store;
+		this.nowFn = options.now ?? (() => Date.now());
+		this.logger = options.logger;
+	}
+
+	public ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult {
+		const receivedAt = new Date(this.nowFn()).toISOString();
+		const normalized = normalizeEvent(event, receivedAt);
+		const inserted = this.store.insertEventLog(normalized, {
+			receivedAtIso: receivedAt,
+		});
+		if (!inserted.created) {
+			this.logger?.debug("cron.event.duplicate", {
+				eventId: inserted.record.eventId,
+				eventType: inserted.record.eventType,
+				source: inserted.record.source,
+			});
+			return {
+				event: inserted.record,
+				duplicate: true,
+				matchedSpecs: [],
+				queuedRuns: [],
+				suppressions: [
+					{
+						reason: "duplicate_event",
+						dedupeKey: inserted.record.dedupeKey,
+					},
+				],
+			};
+		}
+
+		try {
+			const allCandidateSpecs = this.store.listEventSpecsForType(
+				normalized.eventType,
+			);
+			const suppressions: CronEventSuppression[] = [];
+			const matchedSpecs: CronSpecRecord[] = [];
+			const queuedRuns: CronRunRecord[] = [];
+
+			for (const spec of allCandidateSpecs) {
+				if (!automationEventMatchesFilters(normalized, spec.filters)) {
+					suppressions.push({
+						specId: spec.specId,
+						externalId: spec.externalId,
+						reason: "filter_mismatch",
+						dedupeKey: normalized.dedupeKey,
+					});
+					continue;
+				}
+				matchedSpecs.push(spec);
+				const run = this.materializeForSpec(
+					spec,
+					normalized,
+					inserted.record.receivedAt,
+				);
+				if (run.run) {
+					queuedRuns.push(run.run);
+				} else {
+					suppressions.push({
+						specId: spec.specId,
+						externalId: spec.externalId,
+						reason: run.reason,
+						dedupeKey: normalized.dedupeKey,
+					});
+				}
+			}
+
+			const status =
+				matchedSpecs.length === 0
+					? "unmatched"
+					: queuedRuns.length > 0
+						? "queued"
+						: "suppressed";
+			this.store.updateEventLogProcessing(inserted.record.eventId, {
+				status,
+				matchedSpecCount: matchedSpecs.length,
+				queuedRunCount: queuedRuns.length,
+				suppressedCount: suppressions.filter(
+					(s) => s.reason !== "filter_mismatch",
+				).length,
+			});
+			const updated = this.store.getEventLog(inserted.record.eventId);
+			this.logger?.debug("cron.event.processed", {
+				eventId: inserted.record.eventId,
+				eventType: inserted.record.eventType,
+				status,
+				matchedSpecCount: matchedSpecs.length,
+				queuedRunCount: queuedRuns.length,
+			});
+			return {
+				event: updated ?? inserted.record,
+				duplicate: false,
+				matchedSpecs,
+				queuedRuns,
+				suppressions,
+			};
+		} catch (err) {
+			this.store.updateEventLogProcessing(inserted.record.eventId, {
+				status: "failed",
+				error: err instanceof Error ? err.message : String(err),
+			});
+			if (this.logger?.error) {
+				this.logger.error("cron.event.failed", {
+					eventId: inserted.record.eventId,
+					eventType: inserted.record.eventType,
+					error: err,
+				});
+			}
+			throw err;
+		}
+	}
+
+	private materializeForSpec(
+		spec: CronSpecRecord,
+		event: AutomationEventEnvelope,
+		receivedAt: string,
+	): {
+		run?: CronRunRecord;
+		reason: Exclude<
+			CronEventSuppressionReason,
+			"duplicate_event" | "filter_mismatch"
+		>;
+	} {
+		const dedupeKey = event.dedupeKey ?? event.eventId;
+		const debounceSeconds = spec.debounceSeconds ?? 0;
+		if (debounceSeconds > 0) {
+			const existing = this.store.findQueuedEventRunForDedupe({
+				specId: spec.specId,
+				dedupeKey,
+			});
+			if (existing) {
+				const scheduledFor = maxIso(
+					existing.scheduledFor,
+					addSeconds(receivedAt, debounceSeconds),
+				);
+				const updated = this.store.updateQueuedEventRunForDebounce({
+					runId: existing.runId,
+					triggerEventId: event.eventId,
+					scheduledFor,
+				});
+				if (updated) return { run: updated, reason: "dedupe_window" };
+			}
+		}
+
+		const dedupeWindowSeconds = spec.dedupeWindowSeconds ?? 0;
+		if (
+			dedupeWindowSeconds > 0 &&
+			this.store.hasRecentEventRunForDedupe({
+				specId: spec.specId,
+				dedupeKey,
+				sinceIso: subtractSeconds(receivedAt, dedupeWindowSeconds),
+			})
+		) {
+			return { reason: "dedupe_window" };
+		}
+
+		const cooldownSeconds = spec.cooldownSeconds ?? 0;
+		if (
+			cooldownSeconds > 0 &&
+			this.store.hasRecentEventRunForSpec({
+				specId: spec.specId,
+				sinceIso: subtractSeconds(receivedAt, cooldownSeconds),
+			})
+		) {
+			return { reason: "cooldown" };
+		}
+
+		const run = this.store.enqueueRun({
+			specId: spec.specId,
+			specRevision: spec.revision,
+			triggerKind: "event",
+			triggerEventId: event.eventId,
+			scheduledFor:
+				debounceSeconds > 0
+					? addSeconds(receivedAt, debounceSeconds)
+					: receivedAt,
+		});
+		return { run, reason: "dedupe_window" };
+	}
+}
diff --git a/sdk/packages/core/src/cron/events/index.ts b/sdk/packages/core/src/cron/events/index.ts
new file mode 100644
index 0000000..586750e
--- /dev/null
+++ b/sdk/packages/core/src/cron/events/index.ts
@@ -0,0 +1 @@
+export * from "./cron-event-ingress";
diff --git a/sdk/packages/core/src/cron/index.ts b/sdk/packages/core/src/cron/index.ts
new file mode 100644
index 0000000..226951e
--- /dev/null
+++ b/sdk/packages/core/src/cron/index.ts
@@ -0,0 +1,7 @@
+export * from "./events";
+export * from "./reports";
+export * from "./runner";
+export * from "./schedule";
+export * from "./service";
+export * from "./specs";
+export * from "./store";
diff --git a/sdk/packages/core/src/cron/reports/cron-report-writer.ts b/sdk/packages/core/src/cron/reports/cron-report-writer.ts
new file mode 100644
index 0000000..31ffb68
--- /dev/null
+++ b/sdk/packages/core/src/cron/reports/cron-report-writer.ts
@@ -0,0 +1,153 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+	type ResolveCronSpecsDirOptions,
+	resolveCronReportsDir,
+} from "@cline/shared/storage";
+import type {
+	CronEventLogRecord,
+	CronRunRecord,
+	CronSpecRecord,
+} from "../store/sqlite-cron-store";
+
+/**
+ * Writes a markdown report for a completed or failed cron run.
+ * Reports live under `<cron-specs-dir>/reports/<run-id>.md`.
+ * By default that is `~/.cline/cron/reports/<run-id>.md`.
+ * and are derived artifacts — the database is still the operational source
+ * of truth.
+ */
+
+export interface CronRunReportData {
+	finalText?: string;
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	};
+	toolCalls?: Array<{ name: string; error?: string; durationMs?: number }>;
+	durationMs?: number;
+	error?: string;
+	triggerEvent?: CronEventLogRecord;
+}
+
+export interface WriteReportOptions {
+	/**
+	 * Cron spec source/report location. Defaults to global `~/.cline/cron`.
+	 * Pass `{ scope: "workspace", workspaceRoot }` to write reports beside a
+	 * future workspace-scoped cron specs directory.
+	 */
+	specs?: ResolveCronSpecsDirOptions;
+	workspaceRoot: string;
+	run: CronRunRecord;
+	spec: CronSpecRecord;
+	data: CronRunReportData;
+}
+
+function escapeYamlString(value: string): string {
+	// Minimal escaping: wrap in quotes only when needed.
+	if (/[:#\n]/.test(value) || value.includes('"')) {
+		return JSON.stringify(value);
+	}
+	return value;
+}
+
+function yamlEntry(key: string, value: string | undefined): string | undefined {
+	if (value === undefined || value === null) return undefined;
+	return `${key}: ${escapeYamlString(value)}`;
+}
+
+function buildFrontmatter(
+	run: CronRunRecord,
+	spec: CronSpecRecord,
+	triggerEvent?: CronEventLogRecord,
+): string {
+	const entries: string[] = [
+		`runId: ${escapeYamlString(run.runId)}`,
+		`specId: ${escapeYamlString(spec.specId)}`,
+		`externalId: ${escapeYamlString(spec.externalId)}`,
+		`title: ${escapeYamlString(spec.title)}`,
+		`triggerKind: ${escapeYamlString(run.triggerKind)}`,
+		`status: ${escapeYamlString(run.status)}`,
+		`sourcePath: ${escapeYamlString(spec.sourcePath)}`,
+	];
+	const optional = [
+		yamlEntry("sessionId", run.sessionId),
+		yamlEntry("startedAt", run.startedAt),
+		yamlEntry("completedAt", run.completedAt),
+		yamlEntry("triggerEventId", run.triggerEventId),
+		yamlEntry("triggerEventType", triggerEvent?.eventType),
+		yamlEntry("triggerEventSource", triggerEvent?.source),
+		yamlEntry("triggerEventSubject", triggerEvent?.subject),
+	];
+	for (const entry of optional) if (entry) entries.push(entry);
+	return `---\n${entries.join("\n")}\n---\n`;
+}
+
+function buildBody(data: CronRunReportData): string {
+	const sections: string[] = [];
+	if (data.triggerEvent) {
+		const event = data.triggerEvent;
+		const lines = [
+			`- eventId: ${event.eventId}`,
+			`- eventType: ${event.eventType}`,
+			`- source: ${event.source}`,
+			event.subject ? `- subject: ${event.subject}` : "",
+			`- occurredAt: ${event.occurredAt}`,
+			event.dedupeKey ? `- dedupeKey: ${event.dedupeKey}` : "",
+			event.attributes
+				? `- attributes: ${JSON.stringify(event.attributes)}`
+				: "",
+		].filter((line) => line.length > 0);
+		sections.push(`## Trigger Event\n\n${lines.join("\n")}\n`);
+	}
+	if (data.error) {
+		sections.push(`## Error\n\n${data.error}\n`);
+	}
+	if (data.finalText && data.finalText.trim().length > 0) {
+		sections.push(`## Summary\n\n${data.finalText.trim()}\n`);
+	}
+	if (data.usage) {
+		const u = data.usage;
+		const lines = [
+			u.inputTokens !== undefined ? `- inputTokens: ${u.inputTokens}` : "",
+			u.outputTokens !== undefined ? `- outputTokens: ${u.outputTokens}` : "",
+			u.cacheReadTokens !== undefined
+				? `- cacheReadTokens: ${u.cacheReadTokens}`
+				: "",
+			u.cacheWriteTokens !== undefined
+				? `- cacheWriteTokens: ${u.cacheWriteTokens}`
+				: "",
+			u.totalCost !== undefined ? `- totalCostUsd: ${u.totalCost}` : "",
+			data.durationMs !== undefined ? `- durationMs: ${data.durationMs}` : "",
+		].filter((line) => line.length > 0);
+		if (lines.length > 0) {
+			sections.push(`## Usage\n\n${lines.join("\n")}\n`);
+		}
+	}
+	if (data.toolCalls && data.toolCalls.length > 0) {
+		const bullets = data.toolCalls.map((call) => {
+			const parts = [`- ${call.name}`];
+			if (call.durationMs !== undefined) parts.push(`(${call.durationMs}ms)`);
+			if (call.error) parts.push(`error: ${call.error}`);
+			return parts.join(" ");
+		});
+		sections.push(`## Tool Calls\n\n${bullets.join("\n")}\n`);
+	}
+	return sections.join("\n");
+}
+
+export function writeCronRunReport(options: WriteReportOptions): string {
+	const dir = resolveCronReportsDir(options.specs);
+	mkdirSync(dir, { recursive: true });
+	const path = join(dir, `${options.run.runId}.md`);
+	const content = `${buildFrontmatter(
+		options.run,
+		options.spec,
+		options.data.triggerEvent,
+	)}\n${buildBody(options.data)}`;
+	writeFileSync(path, content, "utf8");
+	return path;
+}
diff --git a/sdk/packages/core/src/cron/reports/index.ts b/sdk/packages/core/src/cron/reports/index.ts
new file mode 100644
index 0000000..c11a5f9
--- /dev/null
+++ b/sdk/packages/core/src/cron/reports/index.ts
@@ -0,0 +1 @@
+export * from "./cron-report-writer";
diff --git a/sdk/packages/core/src/cron/runner/cron-materializer.test.ts b/sdk/packages/core/src/cron/runner/cron-materializer.test.ts
new file mode 100644
index 0000000..469faf9
--- /dev/null
+++ b/sdk/packages/core/src/cron/runner/cron-materializer.test.ts
@@ -0,0 +1,152 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import { CronMaterializer } from "./cron-materializer";
+
+describe("CronMaterializer", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "cline-materializer-"));
+		store = new SqliteCronStore({ dbPath: join(dir, "cron.db") });
+	});
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	function seedOneOff() {
+		return store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "p",
+				workspaceRoot: "/ws",
+				enabled: true,
+			},
+		}).record;
+	}
+
+	function requireValue<T>(value: T | undefined): T {
+		expect(value).toBeDefined();
+		if (value === undefined) {
+			throw new Error("Expected value to be defined");
+		}
+		return value;
+	}
+
+	it("queues exactly one run per one-off spec revision", () => {
+		seedOneOff();
+		const m = new CronMaterializer({ store });
+		expect(m.materializeAll().oneOffQueued).toBe(1);
+		expect(m.materializeAll().oneOffQueued).toBe(0);
+	});
+
+	it("queues a new run when the revision bumps", () => {
+		const spec = seedOneOff();
+		const m = new CronMaterializer({ store });
+		m.materializeAll();
+		store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h2",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "new prompt",
+				workspaceRoot: "/ws",
+				enabled: true,
+			},
+		});
+		const updated = requireValue(store.getSpec(spec.specId));
+		expect(updated.revision).toBe(2);
+		expect(m.materializeAll().oneOffQueued).toBe(1);
+		const runs = store.listRuns({ specId: spec.specId });
+		expect(runs.length).toBe(2);
+	});
+
+	it("does not requeue a failed one-off run for the same revision", () => {
+		const spec = seedOneOff();
+		const m = new CronMaterializer({ store });
+		expect(m.materializeAll().oneOffQueued).toBe(1);
+		const run = requireValue(store.listRuns({ specId: spec.specId })[0]);
+		store.completeRun(run.runId, { status: "failed", error: "boom" });
+
+		expect(m.materializeAll().oneOffQueued).toBe(0);
+		const runs = store.listRuns({ specId: spec.specId });
+		expect(runs).toHaveLength(1);
+		expect(runs[0]?.status).toBe("failed");
+	});
+
+	it("catches up one overdue schedule run and advances next_run_at", () => {
+		const past = new Date(Date.now() - 60_000).toISOString();
+		const upserted = store.upsertSpec({
+			externalId: "nightly",
+			sourcePath: "nightly.cron.md",
+			triggerKind: "schedule",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "schedule",
+				id: "nightly",
+				title: "Nightly",
+				prompt: "p",
+				workspaceRoot: "/ws",
+				enabled: true,
+				schedule: "* * * * *",
+			},
+		});
+		// Force an overdue next_run_at.
+		store.updateSpecNextRunAt(upserted.record.specId, past);
+
+		const m = new CronMaterializer({ store });
+		expect(m.materializeAll().scheduleQueued).toBe(1);
+		expect(m.materializeAll().scheduleQueued).toBe(0);
+		const after = requireValue(store.getSpec(upserted.record.specId));
+		const nextRunAt = requireValue(after.nextRunAt);
+		expect(new Date(nextRunAt).getTime()).toBeGreaterThan(Date.now());
+	});
+
+	it("does not duplicate a due schedule run when called twice with a stale spec snapshot", () => {
+		const nowMs = Date.parse("2026-04-23T10:00:00.000Z");
+		const dueAt = new Date(nowMs - 60_000).toISOString();
+		const upserted = store.upsertSpec({
+			externalId: "nightly",
+			sourcePath: "nightly.cron.md",
+			triggerKind: "schedule",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "schedule",
+				id: "nightly",
+				title: "Nightly",
+				prompt: "p",
+				workspaceRoot: "/ws",
+				enabled: true,
+				schedule: "* * * * *",
+			},
+		});
+		store.updateSpecNextRunAt(upserted.record.specId, dueAt);
+		const staleSpec = requireValue(store.getSpec(upserted.record.specId));
+		const m = new CronMaterializer({ store, now: () => nowMs });
+
+		expect(m.materializeSchedule(staleSpec)).toBe(true);
+		expect(m.materializeSchedule(staleSpec)).toBe(false);
+
+		const runs = store.listRuns({ specId: upserted.record.specId });
+		expect(runs).toHaveLength(1);
+		expect(runs[0]?.scheduledFor).toBe(dueAt);
+	});
+});
diff --git a/sdk/packages/core/src/cron/runner/cron-materializer.ts b/sdk/packages/core/src/cron/runner/cron-materializer.ts
new file mode 100644
index 0000000..ed3d967
--- /dev/null
+++ b/sdk/packages/core/src/cron/runner/cron-materializer.ts
@@ -0,0 +1,100 @@
+import type {
+	CronSpecRecord,
+	SqliteCronStore,
+} from "../store/sqlite-cron-store";
+
+/**
+ * Queue materialization rules shared between the reconciler, watcher, and
+ * periodic runner tick. Execution stays trigger-agnostic once a row is
+ * queued; this module is the only place that decides when to create a row.
+ */
+
+export interface CronMaterializerOptions {
+	store: SqliteCronStore;
+	now?: () => number;
+}
+
+export interface MaterializeSummary {
+	oneOffQueued: number;
+	scheduleQueued: number;
+}
+
+export class CronMaterializer {
+	private readonly store: SqliteCronStore;
+	private readonly nowFn: () => number;
+
+	constructor(options: CronMaterializerOptions) {
+		this.store = options.store;
+		this.nowFn = options.now ?? (() => Date.now());
+	}
+
+	/**
+	 * Run materialization for every valid/enabled spec. Typically called at
+	 * startup (after reconciliation) and on each runner tick.
+	 */
+	public materializeAll(): MaterializeSummary {
+		const summary: MaterializeSummary = {
+			oneOffQueued: 0,
+			scheduleQueued: 0,
+		};
+
+		const oneOffs = this.store.listSpecs({
+			triggerKind: "one_off",
+			enabled: true,
+			parseStatus: "valid",
+		});
+		for (const spec of oneOffs) {
+			if (this.materializeOneOff(spec)) summary.oneOffQueued += 1;
+		}
+
+		const schedules = this.store.listSpecs({
+			triggerKind: "schedule",
+			enabled: true,
+			parseStatus: "valid",
+		});
+		for (const spec of schedules) {
+			try {
+				if (this.materializeSchedule(spec)) summary.scheduleQueued += 1;
+			} catch {
+				// Keep one stale/invalid persisted schedule from blocking other specs.
+			}
+		}
+
+		return summary;
+	}
+
+	/**
+	 * Ensure a single one-off spec has exactly one run record for its current
+	 * revision unless an explicit rerun path creates a different trigger kind.
+	 * Returns true if a new queued run was created.
+	 */
+	public materializeOneOff(spec: CronSpecRecord): boolean {
+		if (spec.triggerKind !== "one_off") return false;
+		if (!spec.enabled || spec.removed) return false;
+		if (this.store.hasOneOffRunForRevision(spec.specId, spec.revision)) {
+			return false;
+		}
+		this.store.enqueueRun({
+			specId: spec.specId,
+			specRevision: spec.revision,
+			triggerKind: "one_off",
+			scheduledFor: new Date(this.nowFn()).toISOString(),
+		});
+		return true;
+	}
+
+	/**
+	 * Materialize schedule runs. Implements the "one overdue catch-up on
+	 * startup, then advance" policy described in PLAN.md.
+	 */
+	public materializeSchedule(spec: CronSpecRecord): boolean {
+		if (spec.triggerKind !== "schedule") return false;
+		if (!spec.enabled || spec.removed) return false;
+		if (!spec.scheduleExpr) return false;
+
+		return this.store.materializeDueScheduleRun({
+			specId: spec.specId,
+			nowMs: this.nowFn(),
+		}).queued;
+	}
+}
diff --git a/sdk/packages/core/src/cron/runner/cron-runner.test.ts b/sdk/packages/core/src/cron/runner/cron-runner.test.ts
new file mode 100644
index 0000000..7ae56b7
--- /dev/null
+++ b/sdk/packages/core/src/cron/runner/cron-runner.test.ts
@@ -0,0 +1,342 @@
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import { CronMaterializer } from "./cron-materializer";
+import { CronRunner } from "./cron-runner";
+
+function fakeHandlers(): {
+	handlers: HubScheduleRuntimeHandlers;
+	calls: { start: number; send: number; stop: number; prompts: string[] };
+} {
+	const calls = { start: 0, send: 0, stop: 0, prompts: [] as string[] };
+	const handlers: HubScheduleRuntimeHandlers = {
+		async startSession(_req) {
+			calls.start += 1;
+			return { sessionId: `sess_${calls.start}` };
+		},
+		async sendSession(_sessionId, req) {
+			calls.send += 1;
+			calls.prompts.push(req.prompt);
+			return {
+				result: {
+					text: "done text",
+					usage: { inputTokens: 5, outputTokens: 7, totalCost: 0.001 },
+					toolCalls: [{ name: "read_file", durationMs: 1 }],
+				},
+			};
+		},
+		async abortSession(_sessionId) {
+			return { applied: true };
+		},
+		async stopSession(_sessionId) {
+			calls.stop += 1;
+			return { applied: true };
+		},
+	};
+	return { handlers, calls };
+}
+
+function requireValue<T>(value: T | undefined): T {
+	expect(value).toBeDefined();
+	if (value === undefined) {
+		throw new Error("Expected value to be defined");
+	}
+	return value;
+}
+
+describe("CronRunner", () => {
+	let dir: string;
+	let workspaceRoot: string;
+	let cronDir: string;
+	let store: SqliteCronStore;
+	let materializer: CronMaterializer;
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "cline-runner-"));
+		workspaceRoot = join(dir, "ws");
+		cronDir = join(dir, "cron-specs");
+		mkdirSync(workspaceRoot, { recursive: true });
+		store = new SqliteCronStore({ dbPath: join(dir, "cron.db") });
+		materializer = new CronMaterializer({ store });
+	});
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("executes a queued one-off run end-to-end and writes a report", async () => {
+		const { handlers, calls } = fakeHandlers();
+		const upserted = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "Do it",
+				workspaceRoot,
+				enabled: true,
+				modelSelection: { providerId: "p", modelId: "m" },
+			},
+		});
+		const runner = new CronRunner({
+			store,
+			materializer,
+			runtimeHandlers: handlers,
+			workspaceRoot,
+			specs: { cronSpecsDir: cronDir },
+			pollIntervalMs: 10_000,
+		});
+		await runner.tick();
+		await runner.dispose();
+
+		expect(calls.start).toBe(1);
+		expect(calls.send).toBe(1);
+		expect(calls.stop).toBe(1);
+
+		const run = requireValue(
+			store.listRuns({ specId: upserted.record.specId })[0],
+		);
+		expect(run.status).toBe("done");
+		const reportPath = requireValue(run.reportPath);
+		expect(existsSync(reportPath)).toBe(true);
+	});
+
+	it("marks runs failed when the runtime throws", async () => {
+		const handlers: HubScheduleRuntimeHandlers = {
+			async startSession() {
+				throw new Error("no runtime");
+			},
+			async sendSession() {
+				throw new Error("unreachable");
+			},
+			async abortSession() {
+				return { applied: true };
+			},
+			async stopSession() {
+				return { applied: true };
+			},
+		};
+		const upserted = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "Do it",
+				workspaceRoot,
+				enabled: true,
+			},
+		});
+		const runner = new CronRunner({
+			store,
+			materializer,
+			runtimeHandlers: handlers,
+			workspaceRoot,
+			specs: { cronSpecsDir: cronDir },
+		});
+		await runner.tick();
+		await runner.dispose();
+
+		const run = requireValue(
+			store.listRuns({ specId: upserted.record.specId })[0],
+		);
+		expect(run.status).toBe("failed");
+		expect(run.error).toMatch(/no runtime/);
+	});
+
+	it("executes queued event runs with trigger context and report provenance", async () => {
+		const { handlers, calls } = fakeHandlers();
+		const upserted = store.upsertSpec({
+			externalId: "pr-review",
+			sourcePath: "events/pr-review.event.md",
+			triggerKind: "event",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "event",
+				id: "pr-review",
+				title: "PR Review",
+				prompt: "Review the opened pull request",
+				workspaceRoot,
+				enabled: true,
+				event: "github.pull_request.opened",
+				filters: { repository: "acme/api" },
+			},
+		});
+		store.insertEventLog({
+			eventId: "evt_1",
+			eventType: "github.pull_request.opened",
+			source: "github",
+			subject: "acme/api#12",
+			occurredAt: "2026-04-23T10:00:00.000Z",
+			dedupeKey: "pr:12",
+			attributes: { repository: "acme/api" },
+		});
+		store.enqueueRun({
+			specId: upserted.record.specId,
+			specRevision: upserted.record.revision,
+			triggerKind: "event",
+			triggerEventId: "evt_1",
+		});
+
+		const runner = new CronRunner({
+			store,
+			materializer,
+			runtimeHandlers: handlers,
+			workspaceRoot,
+			specs: { cronSpecsDir: cronDir },
+		});
+		await runner.tick();
+		await runner.dispose();
+
+		expect(calls.send).toBe(1);
+		expect(calls.prompts[0]).toContain("Trigger event:");
+		expect(calls.prompts[0]).toContain("github.pull_request.opened");
+		const run = requireValue(
+			store.listRuns({ specId: upserted.record.specId })[0],
+		);
+		expect(run.status).toBe("done");
+		const reportPath = requireValue(run.reportPath);
+		const report = readFileSync(reportPath, "utf8");
+		expect(report).toContain("triggerEventType: github.pull_request.opened");
+		expect(report).toContain("## Trigger Event");
+	});
+
+	it("requeues runs that lose the limiter race instead of failing them", async () => {
+		const { handlers } = fakeHandlers();
+		const upserted = store.upsertSpec({
+			externalId: "nightly",
+			sourcePath: "nightly.cron.md",
+			triggerKind: "schedule",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "schedule",
+				id: "nightly",
+				title: "Nightly",
+				prompt: "Do it",
+				workspaceRoot,
+				enabled: true,
+				schedule: "0 2 * * *",
+			},
+		});
+		store.enqueueRun({
+			specId: upserted.record.specId,
+			specRevision: upserted.record.revision,
+			triggerKind: "schedule",
+		});
+		const blocked = store.enqueueRun({
+			specId: upserted.record.specId,
+			specRevision: upserted.record.revision,
+			triggerKind: "schedule",
+		});
+		const runner = new CronRunner({
+			store,
+			materializer,
+			runtimeHandlers: handlers,
+			workspaceRoot,
+			specs: { cronSpecsDir: cronDir },
+			globalMaxConcurrency: 1,
+		});
+		await runner.tick();
+		await runner.dispose();
+
+		const requeued = store.getRun(blocked.runId);
+		expect(requeued?.status).toBe("queued");
+		expect(requeued?.attemptCount).toBe(1);
+		expect(requeued?.error).toBe("concurrency limit reached");
+	});
+
+	it("requeues active runs on stop and allows them to be reclaimed", async () => {
+		let aborted = 0;
+		const handlers: HubScheduleRuntimeHandlers = {
+			async startSession() {
+				return { sessionId: "unused" };
+			},
+			async sendSession() {
+				return { result: { text: "unused" } };
+			},
+			async abortSession() {
+				aborted += 1;
+				return { applied: true };
+			},
+			async stopSession() {
+				return { applied: true };
+			},
+		};
+		const upserted = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "Do it",
+				workspaceRoot,
+				enabled: true,
+			},
+		});
+		const runner = new CronRunner({
+			store,
+			materializer,
+			runtimeHandlers: handlers,
+			workspaceRoot,
+			specs: { cronSpecsDir: cronDir },
+		});
+		const run = store.enqueueRun({
+			specId: upserted.record.specId,
+			specRevision: upserted.record.revision,
+			triggerKind: "one_off",
+		});
+		const [claim] = store.claimDueRuns({
+			nowIso: new Date().toISOString(),
+			leaseMs: 30_000,
+		});
+		const claimedRun = requireValue(claim);
+		expect(claimedRun.run.runId).toBe(run.runId);
+		(runner as unknown as { started: boolean }).started = true;
+		(
+			runner as unknown as {
+				activeRuns: Map<string, { claimToken: string; sessionId?: string }>;
+			}
+		).activeRuns.set(run.runId, {
+			claimToken: claimedRun.claimToken,
+			sessionId: "sess_stop",
+		});
+		await runner.stop();
+		await runner.dispose();
+
+		expect(aborted).toBe(1);
+		const requeued = requireValue(store.getRun(run.runId));
+		expect(requeued.status).toBe("queued");
+		expect(requeued.claimToken).toBeUndefined();
+		expect(requeued.completedAt).toBeUndefined();
+
+		const reclaimed = store.claimDueRuns({
+			nowIso: new Date().toISOString(),
+			leaseMs: 30_000,
+		});
+		expect(reclaimed).toHaveLength(1);
+		expect(reclaimed[0]?.run.runId).toBe(run.runId);
+	});
+});
diff --git a/sdk/packages/core/src/cron/runner/cron-runner.ts b/sdk/packages/core/src/cron/runner/cron-runner.ts
new file mode 100644
index 0000000..ea2b0bc
--- /dev/null
+++ b/sdk/packages/core/src/cron/runner/cron-runner.ts
@@ -0,0 +1,547 @@
+import { basename } from "node:path";
+import type {
+	BasicLogger,
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+} from "@cline/shared";
+import { buildClineSystemPrompt } from "@cline/shared";
+import { nowIso } from "@cline/shared/db";
+import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
+import { DefaultToolNames } from "../../extensions/tools/constants";
+import { mergeRulesForSystemPrompt } from "../../runtime/safety/rules";
+import { buildWorkspaceMetadata } from "../../services/workspace/workspace-manifest";
+import { writeCronRunReport } from "../reports/cron-report-writer";
+import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
+import type {
+	ClaimedCronRun,
+	CronEventLogRecord,
+	CronRunRecord,
+	CronSpecRecord,
+	SqliteCronStore,
+} from "../store/sqlite-cron-store";
+import type { CronMaterializer } from "./cron-materializer";
+import { ResourceLimiter } from "./resource-limiter";
+
+/**
+ * Trigger-agnostic runner for queued cron runs.
+ *
+ * Polls cron.db every N seconds, atomically claims queued runs, executes
+ * them through the existing runtime handlers (also used by the hub schedule
+ * command adapter), persists status transitions transactionally,
+ * and writes a markdown report per completion/failure.
+ */
+
+const DEFAULT_POLL_INTERVAL_MS = 15_000;
+const DEFAULT_CLAIM_LEASE_SECONDS = 90;
+const DEFAULT_CRON_EXTENSIONS = ["rules", "skills", "plugins"] as const;
+
+interface HubTurnResult {
+	text: string;
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	};
+	toolCalls?: Array<{
+		name: string;
+		error?: string;
+		durationMs?: number;
+	}>;
+}
+
+function cronExtensionEnabled(
+	spec: CronSpecRecord,
+	extension: (typeof DEFAULT_CRON_EXTENSIONS)[number],
+): boolean {
+	return new Set(spec.extensions ?? DEFAULT_CRON_EXTENSIONS).has(extension);
+}
+
+function buildToolPolicies(
+	spec: CronSpecRecord,
+	mode: "act" | "plan" | "yolo",
+): ChatStartSessionRequest["toolPolicies"] | undefined {
+	if (spec.tools === undefined) {
+		return { "*": { autoApprove: true } };
+	}
+	const policies: NonNullable<ChatStartSessionRequest["toolPolicies"]> = {
+		"*": { enabled: false, autoApprove: true },
+	};
+	for (const tool of spec.tools) {
+		policies[tool] = { enabled: true, autoApprove: true };
+	}
+	if (mode === "yolo") {
+		policies[DefaultToolNames.SUBMIT_AND_EXIT] = {
+			enabled: true,
+			autoApprove: true,
+		};
+	}
+	return policies;
+}
+
+function buildNotesSystemPromptSection(
+	notesDirectory: string | undefined,
+): string | undefined {
+	const trimmed = notesDirectory?.trim();
+	if (!trimmed) return undefined;
+	return [
+		"# Notes Directory",
+		`Use ${trimmed} for durable notes related to this automation.`,
+		"Before starting, inspect relevant existing notes there when useful. During or after the run, write concise notes there when they would help future runs continue with context.",
+	].join("\n");
+}
+
+class TimeoutError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "TimeoutError";
+	}
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+): Promise<T> {
+	if (timeoutMs <= 0) return promise;
+	let handle: ReturnType<typeof setTimeout> | undefined;
+	const timeoutPromise = new Promise<never>((_, reject) => {
+		handle = setTimeout(() => {
+			reject(new TimeoutError("cron run timed out"));
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (handle) clearTimeout(handle);
+	}
+}
+
+export interface CronRunnerOptions {
+	store: SqliteCronStore;
+	materializer: CronMaterializer;
+	runtimeHandlers: HubScheduleRuntimeHandlers;
+	eventPublisher?: (
+		eventType: string,
+		payload: Record<string, unknown>,
+	) => void;
+	/** Default runtime workspace for the hub/daemon process. */
+	workspaceRoot: string;
+	/** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+	specs?: ResolveCronSpecsDirOptions;
+	logger?: BasicLogger;
+	pollIntervalMs?: number;
+	claimLeaseSeconds?: number;
+	globalMaxConcurrency?: number;
+}
+
+export class CronRunner {
+	private readonly store: SqliteCronStore;
+	private readonly materializer: CronMaterializer;
+	private readonly options: CronRunnerOptions;
+	private readonly limiter: ResourceLimiter;
+	private readonly claimLeaseMs: number;
+	private timer: ReturnType<typeof setInterval> | undefined;
+	private started = false;
+	private ticking = false;
+	private disposed = false;
+	private stopping = false;
+	private readonly activeRuns = new Map<
+		string,
+		{ claimToken: string; sessionId?: string }
+	>();
+
+	constructor(options: CronRunnerOptions) {
+		this.store = options.store;
+		this.materializer = options.materializer;
+		this.options = options;
+		this.limiter = new ResourceLimiter(options.globalMaxConcurrency ?? 10);
+		this.claimLeaseMs = Math.max(
+			5_000,
+			(options.claimLeaseSeconds ?? DEFAULT_CLAIM_LEASE_SECONDS) * 1000,
+		);
+	}
+
+	public async start(): Promise<void> {
+		if (this.disposed) throw new Error("CronRunner disposed");
+		if (this.started) return;
+		this.stopping = false;
+		this.started = true;
+		const interval = Math.max(
+			2_000,
+			this.options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+		);
+		await this.tick();
+		this.timer = setInterval(() => void this.tick(), interval);
+	}
+
+	public async stop(): Promise<void> {
+		const wasStarted = this.started;
+		this.started = false;
+		this.stopping = true;
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = undefined;
+		}
+		if (!wasStarted) return;
+		const active = [...this.activeRuns.entries()];
+		await Promise.all(
+			active.map(async ([runId, run]) => {
+				if (run.sessionId) {
+					try {
+						await this.options.runtimeHandlers.abortSession(run.sessionId);
+					} catch {
+						// best effort
+					}
+				}
+				try {
+					this.store.requeueRun({
+						runId,
+						claimToken: run.claimToken,
+						error: "runner stopped before completion",
+					});
+				} catch {
+					// best effort
+				}
+			}),
+		);
+	}
+
+	public async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.stop();
+	}
+
+	public async tick(): Promise<void> {
+		if (this.ticking) return;
+		this.ticking = true;
+		try {
+			this.materializer.materializeAll();
+			const claims = this.store.claimDueRuns({
+				nowIso: nowIso(),
+				leaseMs: this.claimLeaseMs,
+			});
+			await Promise.allSettled(claims.map((claim) => this.executeClaim(claim)));
+		} catch (err) {
+			const log = this.options.logger;
+			if (log) {
+				if (log.error) log.error("cron.runner.tick.failed", { error: err });
+				else log.log("cron.runner.tick.failed", { error: err });
+			}
+		} finally {
+			this.ticking = false;
+		}
+	}
+
+	public getActiveRuns(): Array<
+		CronRunRecord & { claimToken: string; sessionId?: string }
+	> {
+		return [...this.activeRuns.entries()].flatMap(([runId, active]) => {
+			const run = this.store.getRun(runId);
+			return run ? [{ ...run, ...active }] : [];
+		});
+	}
+
+	private async executeClaim(claim: ClaimedCronRun): Promise<void> {
+		const run = claim.run;
+		const spec = this.store.getSpec(run.specId);
+		if (!spec) {
+			this.store.completeRun(run.runId, {
+				status: "failed",
+				error: "spec not found",
+				claimToken: claim.claimToken,
+			});
+			return;
+		}
+		if (!spec.enabled || spec.removed) {
+			this.store.completeRun(run.runId, {
+				status: "cancelled",
+				error: "spec disabled or removed",
+				claimToken: claim.claimToken,
+			});
+			return;
+		}
+
+		const maxParallel =
+			spec.maxParallel && spec.maxParallel > 0 ? spec.maxParallel : 1;
+		const acquired = this.limiter.acquire(spec.specId, run.runId, maxParallel);
+		if (!acquired) {
+			this.store.requeueRun({
+				runId: run.runId,
+				claimToken: claim.claimToken,
+				error: "concurrency limit reached",
+			});
+			return;
+		}
+		if (this.stopping) {
+			this.limiter.release(spec.specId, run.runId);
+			this.store.requeueRun({
+				runId: run.runId,
+				claimToken: claim.claimToken,
+				error: "runner stopped before execution",
+			});
+			return;
+		}
+
+		this.activeRuns.set(run.runId, { claimToken: claim.claimToken });
+		const triggerEvent = run.triggerEventId
+			? this.store.getEventLog(run.triggerEventId)
+			: undefined;
+		let sessionId: string | undefined;
+		let releaseLeaseHeartbeat: (() => void) | undefined;
+		const startMs = Date.now();
+		let executionDeadlineMs: number | undefined;
+		if (spec.timeoutSeconds && spec.timeoutSeconds > 0) {
+			executionDeadlineMs = startMs + spec.timeoutSeconds * 1000;
+		}
+
+		try {
+			releaseLeaseHeartbeat = this.startClaimLeaseHeartbeat(claim);
+			const startRequest = await this.buildStartRequest(spec);
+			const startResp =
+				await this.options.runtimeHandlers.startSession(startRequest);
+			sessionId = startResp.sessionId.trim();
+			if (!sessionId) throw new Error("runtime returned empty sessionId");
+			this.activeRuns.set(run.runId, {
+				claimToken: claim.claimToken,
+				sessionId,
+			});
+			this.store.attachSessionIdToRun(run.runId, sessionId);
+
+			const turnRequest: ChatRunTurnRequest = {
+				config: startRequest,
+				prompt: this.buildPrompt(spec, triggerEvent),
+			};
+			const sendPromise = this.options.runtimeHandlers.sendSession(
+				sessionId,
+				turnRequest,
+			);
+			const timeoutMs = executionDeadlineMs
+				? Math.max(1, executionDeadlineMs - Date.now())
+				: 0;
+			const sendResult = await withTimeout(sendPromise, timeoutMs);
+			const result = sendResult.result as HubTurnResult;
+
+			const endMs = Date.now();
+			const reportPath = writeCronRunReport({
+				specs: this.options.specs,
+				workspaceRoot: this.options.workspaceRoot,
+				run: { ...run, sessionId, status: "done" },
+				spec,
+				data: {
+					finalText: result.text,
+					usage: result.usage,
+					toolCalls: result.toolCalls,
+					durationMs: endMs - startMs,
+					triggerEvent,
+				},
+			});
+			this.store.completeRun(run.runId, {
+				status: "done",
+				sessionId,
+				reportPath,
+				claimToken: claim.claimToken,
+			});
+			this.publishScheduleExecutionEvent(
+				"schedule.execution.completed",
+				spec,
+				run.runId,
+			);
+			this.store.updateSpecLastRunAt(spec.specId, nowIso());
+		} catch (err) {
+			const isTimeout = err instanceof TimeoutError;
+			if (sessionId && isTimeout) {
+				try {
+					await this.options.runtimeHandlers.abortSession(sessionId);
+				} catch {
+					// best effort
+				}
+			}
+			const message = err instanceof Error ? err.message : String(err);
+			const endMs = Date.now();
+			const reportPath = writeCronRunReport({
+				specs: this.options.specs,
+				workspaceRoot: this.options.workspaceRoot,
+				run: { ...run, sessionId, status: "failed" },
+				spec,
+				data: { error: message, durationMs: endMs - startMs, triggerEvent },
+			});
+			this.store.completeRun(run.runId, {
+				status: "failed",
+				sessionId,
+				reportPath,
+				error: message,
+				claimToken: claim.claimToken,
+			});
+			this.publishScheduleExecutionEvent(
+				"schedule.execution.failed",
+				spec,
+				run.runId,
+			);
+		} finally {
+			releaseLeaseHeartbeat?.();
+			if (sessionId) {
+				try {
+					await this.options.runtimeHandlers.stopSession(sessionId);
+				} catch {
+					// best effort
+				}
+			}
+			this.activeRuns.delete(run.runId);
+			this.limiter.release(spec.specId, run.runId);
+		}
+	}
+
+	private publishScheduleExecutionEvent(
+		eventType: "schedule.execution.completed" | "schedule.execution.failed",
+		spec: CronSpecRecord,
+		runId: string,
+	): void {
+		if (spec.source !== "hub-schedule" || !this.options.eventPublisher) {
+			return;
+		}
+		const run = this.store.getRun(runId);
+		if (!run) {
+			return;
+		}
+		const status =
+			run.status === "done"
+				? "success"
+				: run.status === "cancelled"
+					? "aborted"
+					: run.status === "running"
+						? "running"
+						: run.status === "queued"
+							? "pending"
+							: "failed";
+		this.options.eventPublisher(eventType, {
+			scheduleId: spec.externalId,
+			executionId: run.runId,
+			sessionId: run.sessionId,
+			triggeredAt: new Date(run.scheduledFor ?? run.createdAt).getTime(),
+			startedAt: run.startedAt ? new Date(run.startedAt).getTime() : undefined,
+			endedAt: run.completedAt
+				? new Date(run.completedAt).getTime()
+				: undefined,
+			status,
+			errorMessage: run.error,
+		});
+	}
+
+	private buildPrompt(
+		spec: CronSpecRecord,
+		triggerEvent: CronEventLogRecord | undefined,
+	): string {
+		const prompt = spec.prompt ?? "";
+		if (!triggerEvent) return prompt;
+		const eventContext = {
+			eventId: triggerEvent.eventId,
+			eventType: triggerEvent.eventType,
+			source: triggerEvent.source,
+			subject: triggerEvent.subject,
+			occurredAt: triggerEvent.occurredAt,
+			workspaceRoot: triggerEvent.workspaceRoot,
+			dedupeKey: triggerEvent.dedupeKey,
+			attributes: triggerEvent.attributes,
+			payload: triggerEvent.payload,
+		};
+		return `${prompt}\n\nTrigger event:\n${JSON.stringify(eventContext, null, 2)}`;
+	}
+
+	private startClaimLeaseHeartbeat(claim: ClaimedCronRun): () => void {
+		const heartbeatMs = Math.max(1_000, Math.floor(this.claimLeaseMs / 2));
+		const interval = setInterval(() => {
+			const leaseUntilAt = new Date(
+				Date.now() + this.claimLeaseMs,
+			).toISOString();
+			const renewed = this.store.renewClaim(
+				claim.run.runId,
+				claim.claimToken,
+				leaseUntilAt,
+			);
+			if (!renewed) {
+				clearInterval(interval);
+			}
+		}, heartbeatMs);
+		return () => clearInterval(interval);
+	}
+
+	private async buildSystemPrompt(
+		spec: CronSpecRecord,
+		workspaceRoot: string,
+		mode: "act" | "plan" | "yolo",
+		provider: string,
+	): Promise<string> {
+		const notes = buildNotesSystemPromptSection(spec.notesDirectory);
+		const additional = mergeRulesForSystemPrompt(undefined, notes);
+		const metadata = await buildWorkspaceMetadata(workspaceRoot);
+		const base = buildClineSystemPrompt({
+			ide: "Cline Cron",
+			workspaceRoot,
+			workspaceName: basename(workspaceRoot),
+			metadata,
+			rules: spec.systemPrompt ? undefined : additional,
+			mode,
+			providerId: provider,
+			overridePrompt: spec.systemPrompt,
+			platform:
+				(typeof process !== "undefined" && process?.platform) || "unknown",
+		});
+		return spec.systemPrompt
+			? (mergeRulesForSystemPrompt(base, additional) ?? base)
+			: base;
+	}
+
+	private async buildStartRequest(
+		spec: CronSpecRecord,
+	): Promise<ChatStartSessionRequest> {
+		const workspaceRoot = (spec.workspaceRoot ?? "").trim();
+		const provider = (spec.providerId ?? "").trim();
+		const model = (spec.modelId ?? "").trim();
+		const runtimeOptions =
+			spec.metadata?.__hubRuntimeOptions &&
+			typeof spec.metadata.__hubRuntimeOptions === "object" &&
+			!Array.isArray(spec.metadata.__hubRuntimeOptions)
+				? (spec.metadata.__hubRuntimeOptions as {
+						enableTools?: boolean;
+						enableSpawn?: boolean;
+						enableTeams?: boolean;
+						autoApproveTools?: boolean;
+					})
+				: undefined;
+		const cwd =
+			typeof spec.metadata?.__hubScheduleCwd === "string" &&
+			spec.metadata.__hubScheduleCwd.trim()
+				? spec.metadata.__hubScheduleCwd.trim()
+				: workspaceRoot;
+		if (!workspaceRoot) {
+			throw new Error("cron spec requires workspaceRoot");
+		}
+		const mode =
+			spec.mode === "plan" ? "plan" : spec.mode === "act" ? "act" : "yolo";
+		return {
+			workspaceRoot,
+			cwd,
+			provider,
+			model,
+			mode,
+			source: spec.source?.trim() || "user",
+			systemPrompt: await this.buildSystemPrompt(
+				spec,
+				workspaceRoot,
+				mode,
+				provider,
+			),
+			maxIterations: spec.maxIterations,
+			enableTools: runtimeOptions?.enableTools ?? true,
+			enableSpawn: runtimeOptions?.enableSpawn ?? true,
+			enableTeams: runtimeOptions?.enableTeams ?? true,
+			autoApproveTools: runtimeOptions?.autoApproveTools ?? true,
+			toolPolicies: buildToolPolicies(spec, mode),
+			configExtensions: DEFAULT_CRON_EXTENSIONS.filter((extension) =>
+				cronExtensionEnabled(spec, extension),
+			),
+		};
+	}
+}
diff --git a/sdk/packages/core/src/cron/runner/index.ts b/sdk/packages/core/src/cron/runner/index.ts
new file mode 100644
index 0000000..e7c2958
--- /dev/null
+++ b/sdk/packages/core/src/cron/runner/index.ts
@@ -0,0 +1,3 @@
+export * from "./cron-materializer";
+export * from "./cron-runner";
+export * from "./resource-limiter";
diff --git a/sdk/packages/core/src/cron/runner/resource-limiter.ts b/sdk/packages/core/src/cron/runner/resource-limiter.ts
new file mode 100644
index 0000000..9cb71b6
--- /dev/null
+++ b/sdk/packages/core/src/cron/runner/resource-limiter.ts
@@ -0,0 +1,46 @@
+export class ResourceLimiter {
+	private readonly globalMaxConcurrency: number;
+	private readonly activeExecutions = new Map<string, Set<string>>();
+
+	constructor(globalMaxConcurrency: number) {
+		this.globalMaxConcurrency = Math.max(1, Math.floor(globalMaxConcurrency));
+	}
+
+	public acquire(
+		scheduleId: string,
+		executionId: string,
+		maxParallel: number,
+	): boolean {
+		if (this.getGlobalActiveCount() >= this.globalMaxConcurrency) {
+			return false;
+		}
+		const perScheduleLimit = Math.max(1, Math.floor(maxParallel));
+		const scheduleExecutions =
+			this.activeExecutions.get(scheduleId) ?? new Set<string>();
+		if (scheduleExecutions.size >= perScheduleLimit) {
+			return false;
+		}
+		scheduleExecutions.add(executionId);
+		this.activeExecutions.set(scheduleId, scheduleExecutions);
+		return true;
+	}
+
+	public release(scheduleId: string, executionId: string): void {
+		const executions = this.activeExecutions.get(scheduleId);
+		if (!executions) {
+			return;
+		}
+		executions.delete(executionId);
+		if (executions.size === 0) {
+			this.activeExecutions.delete(scheduleId);
+		}
+	}
+
+	public getGlobalActiveCount(): number {
+		let total = 0;
+		for (const executions of this.activeExecutions.values()) {
+			total += executions.size;
+		}
+		return total;
+	}
+}
diff --git a/sdk/packages/core/src/cron/schedule/index.ts b/sdk/packages/core/src/cron/schedule/index.ts
new file mode 100644
index 0000000..e36fefc
--- /dev/null
+++ b/sdk/packages/core/src/cron/schedule/index.ts
@@ -0,0 +1 @@
+export * from "./scheduler";
diff --git a/sdk/packages/core/src/cron/schedule/scheduler.test.ts b/sdk/packages/core/src/cron/schedule/scheduler.test.ts
new file mode 100644
index 0000000..634598c
--- /dev/null
+++ b/sdk/packages/core/src/cron/schedule/scheduler.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { getNextCronTime } from "./scheduler";
+
+describe("hub scheduler cron helpers", () => {
+	it("computes the next matching cron timestamp", () => {
+		const after = new Date(2026, 3, 21, 10, 3, 12).getTime();
+		const next = getNextCronTime("*/15 * * * *", after);
+		expect(next).toBe(new Date(2026, 3, 21, 10, 15, 0).getTime());
+	});
+
+	it("computes the next matching cron timestamp in an explicit timezone", () => {
+		const after = Date.parse("2026-04-21T15:30:00.000Z");
+		const next = getNextCronTime("0 9 * * *", after, "America/New_York");
+		expect(next).toBe(Date.parse("2026-04-22T13:00:00.000Z"));
+	});
+});
diff --git a/sdk/packages/core/src/cron/schedule/scheduler.ts b/sdk/packages/core/src/cron/schedule/scheduler.ts
new file mode 100644
index 0000000..a8c11e6
--- /dev/null
+++ b/sdk/packages/core/src/cron/schedule/scheduler.ts
@@ -0,0 +1,373 @@
+function parseCronField(
+	token: string,
+	min: number,
+	max: number,
+	names?: readonly string[],
+): number[] {
+	const results = new Set<number>();
+
+	function resolveValue(raw: string): number {
+		const lower = raw.toLowerCase();
+		if (names) {
+			const index = names.indexOf(lower);
+			if (index !== -1) {
+				return index + min;
+			}
+		}
+		const value = Number(raw);
+		if (!Number.isInteger(value) || value < min || value > max) {
+			throw new Error(`Invalid cron value "${raw}" for range [${min}-${max}]`);
+		}
+		return value;
+	}
+
+	for (const part of token.split(",")) {
+		if (part === "*") {
+			for (let value = min; value <= max; value += 1) {
+				results.add(value);
+			}
+			continue;
+		}
+
+		const stepSeparator = part.indexOf("/");
+		if (stepSeparator !== -1) {
+			const rangePart = part.slice(0, stepSeparator);
+			const step = Number(part.slice(stepSeparator + 1));
+			if (!Number.isInteger(step) || step < 1) {
+				throw new Error(`Invalid step "${part.slice(stepSeparator + 1)}"`);
+			}
+			let from = min;
+			let to = max;
+			if (rangePart !== "*") {
+				const dashIndex = rangePart.indexOf("-");
+				if (dashIndex !== -1) {
+					from = resolveValue(rangePart.slice(0, dashIndex));
+					to = resolveValue(rangePart.slice(dashIndex + 1));
+				} else {
+					from = resolveValue(rangePart);
+				}
+			}
+			if (from > to) {
+				throw new Error(`Invalid cron range "${rangePart}"`);
+			}
+			for (let value = from; value <= to; value += step) {
+				results.add(value);
+			}
+			continue;
+		}
+
+		const dashIndex = part.indexOf("-");
+		if (dashIndex !== -1) {
+			const from = resolveValue(part.slice(0, dashIndex));
+			const to = resolveValue(part.slice(dashIndex + 1));
+			if (from > to) {
+				throw new Error(`Invalid cron range "${part}"`);
+			}
+			for (let value = from; value <= to; value += 1) {
+				results.add(value);
+			}
+			continue;
+		}
+
+		results.add(resolveValue(part));
+	}
+
+	return [...results].sort((left, right) => left - right);
+}
+
+const MONTH_NAMES = [
+	"jan",
+	"feb",
+	"mar",
+	"apr",
+	"may",
+	"jun",
+	"jul",
+	"aug",
+	"sep",
+	"oct",
+	"nov",
+	"dec",
+] as const;
+
+const DOW_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] as const;
+
+export interface ParsedCron {
+	minutes: number[];
+	hours: number[];
+	daysOfMonth: number[];
+	months: number[];
+	daysOfWeek: number[];
+}
+
+interface CronDateParts {
+	month: number;
+	dayOfMonth: number;
+	dayOfWeek: number;
+	hour: number;
+	minute: number;
+}
+
+function getRequiredField(
+	fields: readonly string[],
+	index: number,
+	pattern: string,
+): string {
+	const value = fields[index];
+	if (typeof value !== "string") {
+		throw new Error(
+			`Invalid cron pattern "${pattern}": missing field ${index + 1}`,
+		);
+	}
+	return value;
+}
+
+function getFirstCronValue(values: readonly number[], label: string): number {
+	const value = values[0];
+	if (typeof value !== "number") {
+		throw new Error(`Invalid cron pattern: no values parsed for ${label}`);
+	}
+	return value;
+}
+
+export function parseCron(pattern: string): ParsedCron {
+	const fields = pattern.trim().split(/\s+/);
+	if (fields.length !== 5) {
+		throw new Error(
+			`Invalid cron pattern "${pattern}": expected 5 fields, got ${fields.length}`,
+		);
+	}
+	return {
+		minutes: parseCronField(getRequiredField(fields, 0, pattern), 0, 59),
+		hours: parseCronField(getRequiredField(fields, 1, pattern), 0, 23),
+		daysOfMonth: parseCronField(getRequiredField(fields, 2, pattern), 1, 31),
+		months: parseCronField(
+			getRequiredField(fields, 3, pattern),
+			1,
+			12,
+			MONTH_NAMES,
+		),
+		daysOfWeek: parseCronField(
+			getRequiredField(fields, 4, pattern),
+			0,
+			6,
+			DOW_NAMES,
+		),
+	};
+}
+
+export function validateCronPattern(pattern: string): void {
+	parseCron(pattern);
+}
+
+export function validateCronSchedule(
+	pattern: string,
+	timezone?: string,
+	after: number = Date.now(),
+): void {
+	getNextCronTime(pattern, after, timezone);
+}
+
+const TIMEZONE_FORMATTERS = new Map<string, Intl.DateTimeFormat>();
+const DOW_BY_SHORT_NAME = new Map(
+	DOW_NAMES.map((name, index) => [name, index] as const),
+);
+
+function normalizeTimezone(timezone: string | undefined): string | undefined {
+	const trimmed = timezone?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function getTimezoneFormatter(timezone: string): Intl.DateTimeFormat {
+	const existing = TIMEZONE_FORMATTERS.get(timezone);
+	if (existing) return existing;
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		calendar: "gregory",
+		numberingSystem: "latn",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		weekday: "short",
+		hour: "2-digit",
+		minute: "2-digit",
+		hourCycle: "h23",
+	});
+	TIMEZONE_FORMATTERS.set(timezone, formatter);
+	return formatter;
+}
+
+export function validateTimezone(timezone: string | undefined): void {
+	const normalized = normalizeTimezone(timezone);
+	if (!normalized) return;
+	getTimezoneFormatter(normalized).format(new Date());
+}
+
+function getZonedCronDateParts(
+	timestampMs: number,
+	timezone: string,
+): CronDateParts {
+	const parts = getTimezoneFormatter(timezone).formatToParts(
+		new Date(timestampMs),
+	);
+	const byType = new Map(parts.map((part) => [part.type, part.value]));
+	const weekdayRaw = byType.get("weekday")?.toLowerCase().slice(0, 3) ?? "";
+	const dayOfWeek = DOW_BY_SHORT_NAME.get(
+		weekdayRaw as (typeof DOW_NAMES)[number],
+	);
+	if (dayOfWeek === undefined) {
+		throw new Error(`Unable to resolve weekday for timezone "${timezone}"`);
+	}
+	return {
+		month: Number(byType.get("month")),
+		dayOfMonth: Number(byType.get("day")),
+		dayOfWeek,
+		hour: Number(byType.get("hour")),
+		minute: Number(byType.get("minute")),
+	};
+}
+
+function getLocalCronDateParts(timestampMs: number): CronDateParts {
+	const date = new Date(timestampMs);
+	return {
+		month: date.getMonth() + 1,
+		dayOfMonth: date.getDate(),
+		dayOfWeek: date.getDay(),
+		hour: date.getHours(),
+		minute: date.getMinutes(),
+	};
+}
+
+function cronMatchesParts(cron: ParsedCron, parts: CronDateParts): boolean {
+	return (
+		cron.months.includes(parts.month) &&
+		cron.daysOfMonth.includes(parts.dayOfMonth) &&
+		cron.daysOfWeek.includes(parts.dayOfWeek) &&
+		cron.hours.includes(parts.hour) &&
+		cron.minutes.includes(parts.minute)
+	);
+}
+
+function getNextCronTimeByMinuteScan(
+	pattern: string,
+	after: number,
+	timezone: string,
+): number {
+	const cron = parseCron(pattern);
+	const next = new Date(after);
+	next.setSeconds(0, 0);
+	let nextMs = next.getTime() + 60_000;
+
+	const limit = new Date(after);
+	limit.setFullYear(limit.getFullYear() + 4);
+	const limitMs = limit.getTime();
+
+	while (nextMs <= limitMs) {
+		if (cronMatchesParts(cron, getZonedCronDateParts(nextMs, timezone))) {
+			return nextMs;
+		}
+		nextMs += 60_000;
+	}
+
+	throw new Error(
+		`No cron occurrence found within 4 years for pattern "${pattern}" in timezone "${timezone}"`,
+	);
+}
+
+export function getNextCronTime(
+	pattern: string,
+	after: number,
+	timezone?: string,
+): number {
+	const normalizedTimezone = normalizeTimezone(timezone);
+	if (normalizedTimezone) {
+		validateTimezone(normalizedTimezone);
+		return getNextCronTimeByMinuteScan(pattern, after, normalizedTimezone);
+	}
+
+	const cron = parseCron(pattern);
+	let next = new Date(after);
+	next.setSeconds(0, 0);
+	next = new Date(next.getTime() + 60_000);
+
+	const limit = new Date(after);
+	limit.setFullYear(limit.getFullYear() + 4);
+
+	while (next <= limit) {
+		const { month, dayOfMonth, dayOfWeek, hour, minute } =
+			getLocalCronDateParts(next.getTime());
+
+		if (!cron.months.includes(month)) {
+			const targetMonth =
+				cron.months.find((value) => value > month) ??
+				getFirstCronValue(cron.months, "months");
+			const yearDelta = targetMonth <= month ? 1 : 0;
+			next = new Date(
+				next.getFullYear() + yearDelta,
+				targetMonth - 1,
+				1,
+				0,
+				0,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		if (
+			!cron.daysOfMonth.includes(dayOfMonth) ||
+			!cron.daysOfWeek.includes(dayOfWeek)
+		) {
+			next = new Date(
+				next.getFullYear(),
+				next.getMonth(),
+				dayOfMonth + 1,
+				0,
+				0,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		if (!cron.hours.includes(hour)) {
+			const targetHour =
+				cron.hours.find((value) => value > hour) ??
+				getFirstCronValue(cron.hours, "hours");
+			const dayDelta = targetHour <= hour ? 1 : 0;
+			next = new Date(
+				next.getFullYear(),
+				next.getMonth(),
+				next.getDate() + dayDelta,
+				targetHour,
+				0,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		if (!cron.minutes.includes(minute)) {
+			const targetMinute =
+				cron.minutes.find((value) => value > minute) ??
+				getFirstCronValue(cron.minutes, "minutes");
+			const hourDelta = targetMinute <= minute ? 1 : 0;
+			next = new Date(
+				next.getFullYear(),
+				next.getMonth(),
+				next.getDate(),
+				next.getHours() + hourDelta,
+				targetMinute,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		return next.getTime();
+	}
+
+	throw new Error(
+		`No cron occurrence found within 4 years for pattern "${pattern}"`,
+	);
+}
diff --git a/sdk/packages/core/src/cron/service/cron-service.ts b/sdk/packages/core/src/cron/service/cron-service.ts
new file mode 100644
index 0000000..08dbba1
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/cron-service.ts
@@ -0,0 +1,163 @@
+import type { AutomationEventEnvelope, BasicLogger } from "@cline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
+import {
+	CronEventIngress,
+	type CronEventIngressResult,
+} from "../events/cron-event-ingress";
+import { CronMaterializer } from "../runner/cron-materializer";
+import { CronRunner } from "../runner/cron-runner";
+import { CronReconciler } from "../specs/cron-reconciler";
+import { CronWatcher } from "../specs/cron-watcher";
+import type {
+	CronRunRecord,
+	CronSpecRecord,
+	ListEventLogsOptions,
+	ListRunsOptions,
+	ListSpecsOptions,
+} from "../store/sqlite-cron-store";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import type { HubScheduleRuntimeHandlers } from "./schedule-service";
+
+/**
+ * Top-level orchestrator for file-based cron automation.
+ *
+ * Wires together:
+ *   - `SqliteCronStore` (cron.db)
+ *   - `CronReconciler` (disk -> DB)
+ *   - `CronWatcher` (cron specs directory filesystem events)
+ *   - `CronMaterializer` (queue materialization)
+ *   - `CronRunner` (claim + execute + report)
+ *
+ * This service is the forward path: the legacy `HubScheduleService`
+ * continues to serve programmatic schedules, while `CronService` handles
+ * everything sourced from the configured file-based cron directory.
+ */
+
+export interface CronServiceOptions {
+	/** Default runtime workspace for the hub/daemon process. */
+	workspaceRoot: string;
+	/** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+	specs?: ResolveCronSpecsDirOptions;
+	runtimeHandlers: HubScheduleRuntimeHandlers;
+	dbPath?: string;
+	logger?: BasicLogger;
+	pollIntervalMs?: number;
+	claimLeaseSeconds?: number;
+	globalMaxConcurrency?: number;
+	watcherDebounceMs?: number;
+}
+
+export class CronService {
+	private readonly store: SqliteCronStore;
+	private readonly reconciler: CronReconciler;
+	private readonly watcher: CronWatcher;
+	private readonly eventIngress: CronEventIngress;
+	private readonly materializer: CronMaterializer;
+	private readonly runner: CronRunner;
+	private started = false;
+	private disposed = false;
+
+	constructor(options: CronServiceOptions) {
+		this.store = new SqliteCronStore({ dbPath: options.dbPath });
+		const specs = options.specs;
+		this.reconciler = new CronReconciler({
+			store: this.store,
+			specs,
+		});
+		this.materializer = new CronMaterializer({ store: this.store });
+		this.eventIngress = new CronEventIngress({
+			store: this.store,
+			logger: options.logger,
+		});
+		this.runner = new CronRunner({
+			store: this.store,
+			materializer: this.materializer,
+			runtimeHandlers: options.runtimeHandlers,
+			workspaceRoot: options.workspaceRoot,
+			specs,
+			logger: options.logger,
+			pollIntervalMs: options.pollIntervalMs,
+			claimLeaseSeconds: options.claimLeaseSeconds,
+			globalMaxConcurrency: options.globalMaxConcurrency,
+		});
+		this.watcher = new CronWatcher({
+			reconciler: this.reconciler,
+			debounceMs: options.watcherDebounceMs,
+			onReconciled: () => {
+				this.materializer.materializeAll();
+			},
+			onError: (err) => {
+				const log = options.logger;
+				if (log) {
+					if (log.error) log.error("cron.watcher.failed", { error: err });
+					else log.log("cron.watcher.failed", { error: err });
+				}
+			},
+		});
+	}
+
+	public async start(): Promise<void> {
+		if (this.disposed) throw new Error("CronService disposed");
+		if (this.started) return;
+		this.started = true;
+		await this.reconciler.reconcileAll();
+		this.materializer.materializeAll();
+		this.watcher.start();
+		await this.runner.start();
+	}
+
+	public async stop(): Promise<void> {
+		this.watcher.stop();
+		await this.runner.stop();
+		this.started = false;
+	}
+
+	public async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.watcher.dispose();
+		await this.runner.dispose();
+		this.store.close();
+	}
+
+	public listSpecs(options?: ListSpecsOptions): CronSpecRecord[] {
+		return this.store.listSpecs(options);
+	}
+
+	public getSpec(specId: string): CronSpecRecord | undefined {
+		return this.store.getSpec(specId);
+	}
+
+	public listRuns(options?: ListRunsOptions): CronRunRecord[] {
+		return this.store.listRuns(options);
+	}
+
+	public getRun(runId: string): CronRunRecord | undefined {
+		return this.store.getRun(runId);
+	}
+
+	public listActiveRuns(): CronRunRecord[] {
+		return this.store.listRuns({ status: "running", limit: 200 });
+	}
+
+	public listUpcomingRuns(limit = 20): CronRunRecord[] {
+		return this.store.listRuns({ status: "queued", limit });
+	}
+
+	public async reconcileNow(): Promise<void> {
+		await this.reconciler.reconcileAll();
+		this.materializer.materializeAll();
+	}
+
+	public ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult {
+		return this.eventIngress.ingestEvent(event);
+	}
+
+	public listEventLogs(options?: ListEventLogsOptions) {
+		return this.store.listEventLogs(options);
+	}
+
+	public getEventLog(eventId: string) {
+		return this.store.getEventLog(eventId);
+	}
+}
diff --git a/sdk/packages/core/src/cron/service/index.ts b/sdk/packages/core/src/cron/service/index.ts
new file mode 100644
index 0000000..df0a0f1
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/index.ts
@@ -0,0 +1,3 @@
+export * from "./cron-service";
+export * from "./schedule-command-service";
+export * from "./schedule-service";
diff --git a/sdk/packages/core/src/cron/service/schedule-command-service.ts b/sdk/packages/core/src/cron/service/schedule-command-service.ts
new file mode 100644
index 0000000..2e02350
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/schedule-command-service.ts
@@ -0,0 +1,198 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+} from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import type { HubScheduleService } from "./schedule-service";
+
+function okReply(
+	envelope: HubCommandEnvelope,
+	payload?: Record<string, unknown>,
+): HubReplyEnvelope {
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId,
+		ok: true,
+		payload,
+	};
+}
+
+function errorReply(
+	envelope: HubCommandEnvelope,
+	code: string,
+	message: string,
+): HubReplyEnvelope {
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId ?? createSessionId("hubreq_"),
+		ok: false,
+		error: { code, message },
+	};
+}
+
+export class HubScheduleCommandService {
+	constructor(private readonly schedules: HubScheduleService) {}
+
+	public async handleCommand(
+		envelope: HubCommandEnvelope,
+	): Promise<HubReplyEnvelope> {
+		try {
+			switch (envelope.command) {
+				case "schedule.create":
+					return okReply(envelope, {
+						schedule: this.schedules.createSchedule(
+							this.toCreateInput(envelope.payload ?? {}),
+						),
+					});
+				case "schedule.list":
+					return okReply(envelope, {
+						schedules: this.schedules.listSchedules({
+							enabled:
+								typeof envelope.payload?.enabled === "boolean"
+									? envelope.payload.enabled
+									: undefined,
+							limit:
+								typeof envelope.payload?.limit === "number"
+									? envelope.payload.limit
+									: undefined,
+							tags: Array.isArray(envelope.payload?.tags)
+								? (envelope.payload?.tags as string[])
+								: undefined,
+						}),
+					});
+				case "schedule.get":
+					return okReply(envelope, {
+						schedule: this.schedules.getSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.update":
+					return okReply(envelope, {
+						schedule: this.schedules.updateSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+							this.toUpdateInput(envelope.payload ?? {}),
+						),
+					});
+				case "schedule.delete":
+					return okReply(envelope, {
+						deleted: this.schedules.deleteSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.enable":
+					return okReply(envelope, {
+						schedule: this.schedules.resumeSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.disable":
+					return okReply(envelope, {
+						schedule: this.schedules.pauseSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.trigger":
+					return okReply(envelope, {
+						execution:
+							envelope.payload?.wait === false
+								? this.schedules.triggerScheduleNowDetached(
+										String(envelope.payload?.scheduleId ?? ""),
+									)
+								: await this.schedules.triggerScheduleNow(
+										String(envelope.payload?.scheduleId ?? ""),
+									),
+					});
+				case "schedule.list_executions":
+					return okReply(envelope, {
+						executions: this.schedules.listScheduleExecutions({
+							scheduleId:
+								typeof envelope.payload?.scheduleId === "string"
+									? envelope.payload.scheduleId
+									: undefined,
+							status:
+								typeof envelope.payload?.status === "string"
+									? (envelope.payload.status as never)
+									: undefined,
+							limit:
+								typeof envelope.payload?.limit === "number"
+									? envelope.payload.limit
+									: undefined,
+						}),
+					});
+				case "schedule.stats":
+					return okReply(envelope, {
+						stats: this.schedules.getScheduleStats(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.active":
+					return okReply(envelope, {
+						executions: this.schedules.getActiveExecutions(),
+					});
+				case "schedule.upcoming":
+					return okReply(envelope, {
+						runs: this.schedules.getUpcomingRuns(
+							typeof envelope.payload?.limit === "number"
+								? envelope.payload.limit
+								: undefined,
+						),
+					});
+				default:
+					return errorReply(
+						envelope,
+						"unsupported_command",
+						`Unsupported hub schedule command: ${envelope.command}`,
+					);
+			}
+		} catch (error) {
+			return errorReply(
+				envelope,
+				"schedule_command_failed",
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	}
+
+	private toCreateInput(
+		payload: Record<string, unknown>,
+	): HubScheduleCreateInput {
+		const modelSelection =
+			payload.modelSelection &&
+			typeof payload.modelSelection === "object" &&
+			!Array.isArray(payload.modelSelection)
+				? (payload.modelSelection as HubScheduleCreateInput["modelSelection"])
+				: payload.provider && payload.model
+					? {
+							providerId: String(payload.provider),
+							modelId: String(payload.model),
+						}
+					: undefined;
+		return {
+			...(payload as unknown as HubScheduleCreateInput),
+			modelSelection,
+		};
+	}
+
+	private toUpdateInput(
+		payload: Record<string, unknown>,
+	): HubScheduleUpdateInput {
+		const modelSelection =
+			payload.modelSelection &&
+			typeof payload.modelSelection === "object" &&
+			!Array.isArray(payload.modelSelection)
+				? (payload.modelSelection as HubScheduleUpdateInput["modelSelection"])
+				: payload.provider || payload.model
+					? {
+							providerId:
+								typeof payload.provider === "string" ? payload.provider : "",
+							modelId: typeof payload.model === "string" ? payload.model : "",
+						}
+					: undefined;
+		return {
+			...(payload as unknown as HubScheduleUpdateInput),
+			modelSelection,
+		};
+	}
+}
diff --git a/sdk/packages/core/src/cron/service/schedule-service.test.ts b/sdk/packages/core/src/cron/service/schedule-service.test.ts
new file mode 100644
index 0000000..14cc949
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/schedule-service.test.ts
@@ -0,0 +1,213 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { HubScheduleCommandService } from "./schedule-command-service";
+import { HubScheduleService } from "./schedule-service";
+
+const require = createRequire(import.meta.url);
+const sqliteAvailable = (() => {
+	try {
+		require("node:sqlite");
+		return true;
+	} catch {
+		return false;
+	}
+})();
+
+async function createTempDbPath(): Promise<string> {
+	const directory = await mkdtemp(join(tmpdir(), "sdk-hub-schedule-"));
+	return join(directory, "cron.db");
+}
+
+const cleanupPaths: string[] = [];
+
+afterEach(async () => {
+	await Promise.all(
+		cleanupPaths.splice(0).map(async (dbPath) => {
+			await rm(dirname(dbPath), { recursive: true, force: true });
+		}),
+	);
+});
+
+describe("HubScheduleService", () => {
+	const sqliteIt = sqliteAvailable ? it : it.skip;
+
+	sqliteIt("creates, triggers, and reports schedule history", async () => {
+		const dbPath = await createTempDbPath();
+		cleanupPaths.push(dbPath);
+		const publishedEvents: Array<{
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const service = new HubScheduleService({
+			dbPath,
+			runtimeHandlers: {
+				startSession: vi.fn(async () => ({ sessionId: "session-1" })),
+				sendSession: vi.fn(async () => ({
+					result: {
+						text: "done",
+						iterations: 3,
+						inputTokens: 10,
+						outputTokens: 20,
+						usage: { totalCost: 1.25 },
+					},
+				})),
+				abortSession: vi.fn(async () => ({ applied: true })),
+				stopSession: vi.fn(async () => ({ applied: true })),
+			},
+			eventPublisher: (eventType, payload) => {
+				publishedEvents.push({ eventType, payload });
+			},
+		});
+		try {
+			const created = service.createSchedule({
+				name: "Routine",
+				cronPattern: "0 * * * *",
+				prompt: "Run the routine",
+				workspaceRoot: "/workspace",
+				cwd: "/workspace",
+				modelSelection: {
+					providerId: "openai",
+					modelId: "gpt-5.3-codex",
+				},
+				maxParallel: 1,
+				timeoutSeconds: 30,
+				metadata: { delivery: { threadId: "thread-1" } },
+			});
+
+			const execution = await service.triggerScheduleNow(created.scheduleId);
+			expect(execution?.status).toBe("success");
+			expect(execution?.sessionId).toBe("session-1");
+			expect(publishedEvents).toEqual([
+				{
+					eventType: "schedule.execution.completed",
+					payload: expect.objectContaining({
+						scheduleId: created.scheduleId,
+						executionId: execution?.executionId,
+						sessionId: "session-1",
+						status: "success",
+					}),
+				},
+			]);
+
+			const schedule = service.getSchedule(created.scheduleId);
+			expect(schedule?.metadata).toEqual({
+				delivery: { threadId: "thread-1" },
+			});
+			expect(
+				service.listScheduleExecutions({ scheduleId: created.scheduleId }),
+			).toHaveLength(1);
+			expect(service.getScheduleStats(created.scheduleId).totalRuns).toBe(1);
+			expect(service.getUpcomingRuns(10)).toHaveLength(1);
+		} finally {
+			await service.dispose();
+		}
+	});
+
+	sqliteIt("publishes failed schedule execution events", async () => {
+		const dbPath = await createTempDbPath();
+		cleanupPaths.push(dbPath);
+		const publishedEvents: Array<{
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const service = new HubScheduleService({
+			dbPath,
+			runtimeHandlers: {
+				startSession: vi.fn(async () => ({ sessionId: "session-failed" })),
+				sendSession: vi.fn(async () => {
+					throw new Error("runtime failed");
+				}),
+				abortSession: vi.fn(async () => ({ applied: true })),
+				stopSession: vi.fn(async () => ({ applied: true })),
+			},
+			eventPublisher: (eventType, payload) => {
+				publishedEvents.push({ eventType, payload });
+			},
+		});
+		try {
+			const created = service.createSchedule({
+				name: "Failure routine",
+				cronPattern: "0 * * * *",
+				prompt: "Run and fail",
+				workspaceRoot: "/workspace",
+				modelSelection: {
+					providerId: "openai",
+					modelId: "gpt-5.3-codex",
+				},
+			});
+
+			const execution = await service.triggerScheduleNow(created.scheduleId);
+			expect(execution?.status).toBe("failed");
+			expect(publishedEvents).toEqual([
+				{
+					eventType: "schedule.execution.failed",
+					payload: expect.objectContaining({
+						scheduleId: created.scheduleId,
+						executionId: execution?.executionId,
+						sessionId: "session-failed",
+						status: "failed",
+						errorMessage: "runtime failed",
+					}),
+				},
+			]);
+		} finally {
+			await service.dispose();
+		}
+	});
+
+	sqliteIt(
+		"handles schedule commands through the hub command adapter",
+		async () => {
+			const dbPath = await createTempDbPath();
+			cleanupPaths.push(dbPath);
+			const service = new HubScheduleService({
+				dbPath,
+				runtimeHandlers: {
+					startSession: vi.fn(async () => ({ sessionId: "session-2" })),
+					sendSession: vi.fn(async () => ({ result: { text: "done" } })),
+					abortSession: vi.fn(async () => ({ applied: true })),
+					stopSession: vi.fn(async () => ({ applied: true })),
+				},
+			});
+			try {
+				const commands = new HubScheduleCommandService(service);
+
+				const createdReply = await commands.handleCommand({
+					version: "v1",
+					command: "schedule.create",
+					payload: {
+						name: "Command routine",
+						cronPattern: "15 * * * *",
+						prompt: "Run from command",
+						workspaceRoot: "/workspace",
+						modelSelection: {
+							providerId: "openai",
+							modelId: "gpt-5.3-codex",
+						},
+					},
+				});
+				expect(createdReply.ok).toBe(true);
+				const created = createdReply.payload?.schedule as {
+					scheduleId: string;
+				};
+
+				const listReply = await commands.handleCommand({
+					version: "v1",
+					command: "schedule.list",
+					payload: { limit: 10 },
+				});
+				expect(listReply.ok).toBe(true);
+				expect(
+					(listReply.payload?.schedules as Array<{ scheduleId: string }>).some(
+						(item) => item.scheduleId === created.scheduleId,
+					),
+				).toBe(true);
+			} finally {
+				await service.dispose();
+			}
+		},
+	);
+});
diff --git a/sdk/packages/core/src/cron/service/schedule-service.ts b/sdk/packages/core/src/cron/service/schedule-service.ts
new file mode 100644
index 0000000..30f5762
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/schedule-service.ts
@@ -0,0 +1,416 @@
+import type {
+	BasicLogger,
+	ChatRunTurnRequest,
+	ChatStartSessionArtifacts,
+	ChatStartSessionRequest,
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+	ScheduleExecutionRecord,
+	ScheduleExecutionStatus,
+	ScheduleRecord,
+} from "@cline/shared";
+import { CronMaterializer } from "../runner/cron-materializer";
+import { CronRunner } from "../runner/cron-runner";
+import { validateCronPattern } from "../schedule/scheduler";
+import {
+	type CronRunRecord,
+	type CronSpecRecord,
+	type ListRunsOptions,
+	type ListSpecsOptions,
+	SqliteCronStore,
+} from "../store/sqlite-cron-store";
+
+type HubScheduleTurnResult = {
+	text: string;
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	};
+	inputTokens?: number;
+	outputTokens?: number;
+	iterations?: number;
+	finishReason?: string;
+	messages?: unknown[];
+	toolCalls?: Array<{
+		name: string;
+		input?: unknown;
+		output?: unknown;
+		error?: string;
+		durationMs?: number;
+	}>;
+};
+
+export interface HubScheduleRuntimeHandlers {
+	startSession(request: ChatStartSessionRequest): Promise<{
+		sessionId: string;
+		startResult?: ChatStartSessionArtifacts;
+	}>;
+	sendSession(
+		sessionId: string,
+		request: ChatRunTurnRequest,
+	): Promise<{
+		result: HubScheduleTurnResult;
+	}>;
+	abortSession(sessionId: string): Promise<{ applied: boolean }>;
+	stopSession(sessionId: string): Promise<{ applied: boolean }>;
+}
+
+export interface ActiveScheduledExecution {
+	executionId: string;
+	scheduleId: string;
+	sessionId: string;
+	startedAt: string;
+	timeoutAt?: string;
+}
+
+export interface HubScheduleServiceOptions {
+	runtimeHandlers: HubScheduleRuntimeHandlers;
+	eventPublisher?: (
+		eventType: string,
+		payload: Record<string, unknown>,
+	) => void;
+	logger?: BasicLogger;
+	dbPath?: string;
+	pollIntervalMs?: number;
+	globalMaxConcurrency?: number;
+	claimLeaseSeconds?: number;
+}
+
+export interface ListSchedulesOptions {
+	enabled?: boolean;
+	limit?: number;
+	tags?: string[];
+}
+
+export interface ListScheduleExecutionsOptions {
+	scheduleId?: string;
+	status?: ScheduleExecutionStatus;
+	limit?: number;
+}
+
+export interface ScheduleExecutionStats {
+	totalRuns: number;
+	successRate: number;
+	avgDurationSeconds: number;
+	lastFailure?: ScheduleExecutionRecord;
+}
+
+function toMillis(value: string | undefined): number | undefined {
+	return value ? new Date(value).getTime() : undefined;
+}
+
+function scheduleMetadata(
+	spec: CronSpecRecord,
+): Record<string, unknown> | undefined {
+	const metadata = spec.metadata ? { ...spec.metadata } : undefined;
+	if (metadata) {
+		delete metadata.__hubScheduleCreatedBy;
+		delete metadata.__hubScheduleCwd;
+		delete metadata.__hubRuntimeOptions;
+	}
+	return metadata;
+}
+
+function specToSchedule(spec: CronSpecRecord): ScheduleRecord {
+	const metadata = spec.metadata;
+	return {
+		scheduleId: spec.externalId,
+		name: spec.title,
+		cronPattern: spec.scheduleExpr ?? "",
+		prompt: spec.prompt ?? "",
+		workspaceRoot: spec.workspaceRoot ?? "",
+		cwd:
+			typeof metadata?.__hubScheduleCwd === "string"
+				? metadata.__hubScheduleCwd
+				: undefined,
+		modelSelection:
+			spec.providerId || spec.modelId
+				? {
+						providerId: spec.providerId ?? "",
+						modelId: spec.modelId ?? "",
+					}
+				: undefined,
+		enabled: spec.enabled && !spec.removed && spec.parseStatus === "valid",
+		mode: spec.mode === "plan" ? "plan" : spec.mode === "yolo" ? "yolo" : "act",
+		systemPrompt: spec.systemPrompt,
+		maxIterations: spec.maxIterations,
+		timeoutSeconds: spec.timeoutSeconds,
+		maxParallel: spec.maxParallel ?? 1,
+		createdAt: new Date(spec.createdAt).getTime(),
+		updatedAt: new Date(spec.updatedAt).getTime(),
+		nextRunAt: toMillis(spec.nextRunAt),
+		lastRunAt: toMillis(spec.lastRunAt),
+		createdBy:
+			typeof metadata?.__hubScheduleCreatedBy === "string"
+				? metadata.__hubScheduleCreatedBy
+				: undefined,
+		tags: spec.tags,
+		runtimeOptions:
+			metadata?.__hubRuntimeOptions &&
+			typeof metadata.__hubRuntimeOptions === "object" &&
+			!Array.isArray(metadata.__hubRuntimeOptions)
+				? (metadata.__hubRuntimeOptions as ScheduleRecord["runtimeOptions"])
+				: undefined,
+		metadata: scheduleMetadata(spec) as ScheduleRecord["metadata"],
+	};
+}
+
+function runStatusToScheduleStatus(
+	status: CronRunRecord["status"],
+): ScheduleExecutionStatus {
+	switch (status) {
+		case "done":
+			return "success";
+		case "cancelled":
+			return "aborted";
+		case "running":
+			return "running";
+		case "queued":
+			return "pending";
+		default:
+			return "failed";
+	}
+}
+
+function runToExecution(
+	run: CronRunRecord,
+	scheduleId: string,
+): ScheduleExecutionRecord {
+	return {
+		executionId: run.runId,
+		scheduleId,
+		sessionId: run.sessionId,
+		triggeredAt: new Date(run.scheduledFor ?? run.createdAt).getTime(),
+		startedAt: toMillis(run.startedAt),
+		endedAt: toMillis(run.completedAt),
+		status: runStatusToScheduleStatus(run.status),
+		errorMessage: run.error,
+	};
+}
+
+export class HubScheduleService {
+	private readonly store: SqliteCronStore;
+	private readonly materializer: CronMaterializer;
+	private readonly runner: CronRunner;
+	private started = false;
+	private disposed = false;
+
+	constructor(options: HubScheduleServiceOptions) {
+		this.store = new SqliteCronStore({
+			dbPath: options.dbPath,
+		});
+		this.materializer = new CronMaterializer({ store: this.store });
+		this.runner = new CronRunner({
+			store: this.store,
+			materializer: this.materializer,
+			runtimeHandlers: options.runtimeHandlers,
+			eventPublisher: options.eventPublisher,
+			workspaceRoot: "",
+			logger: options.logger,
+			pollIntervalMs: options.pollIntervalMs,
+			claimLeaseSeconds: options.claimLeaseSeconds,
+			globalMaxConcurrency: options.globalMaxConcurrency,
+		});
+	}
+
+	public async start(): Promise<void> {
+		if (this.disposed) throw new Error("HubScheduleService has been disposed");
+		if (this.started) return;
+		this.started = true;
+		await this.runner.start();
+	}
+
+	public async stop(): Promise<void> {
+		await this.runner.stop();
+		this.started = false;
+	}
+
+	public async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.runner.dispose();
+		this.store.close();
+	}
+
+	public createSchedule(input: HubScheduleCreateInput): ScheduleRecord {
+		validateCronPattern(input.cronPattern);
+		if (!input.workspaceRoot?.trim()) {
+			throw new Error("workspaceRoot is required for schedules");
+		}
+		return specToSchedule(this.store.createHubSchedule(input));
+	}
+
+	public getSchedule(scheduleId: string): ScheduleRecord | undefined {
+		const spec = this.store.getHubSchedule(scheduleId);
+		return spec ? specToSchedule(spec) : undefined;
+	}
+
+	public listSchedules(options: ListSchedulesOptions = {}): ScheduleRecord[] {
+		return this.store
+			.listHubSchedules(options)
+			.map((spec) => specToSchedule(spec));
+	}
+
+	public updateSchedule(
+		scheduleId: string,
+		updates: HubScheduleUpdateInput,
+	): ScheduleRecord | undefined {
+		if (updates.cronPattern !== undefined) {
+			validateCronPattern(updates.cronPattern);
+		}
+		const current = this.store.getHubSchedule(scheduleId);
+		if (!current) return undefined;
+		const nextWorkspaceRoot =
+			updates.workspaceRoot !== undefined
+				? updates.workspaceRoot.trim()
+				: current.workspaceRoot;
+		const nextEnabled = updates.enabled ?? current.enabled;
+		if (nextEnabled && !nextWorkspaceRoot) {
+			throw new Error("workspaceRoot is required for enabled schedules");
+		}
+		const updated = this.store.updateHubSchedule(scheduleId, {
+			...updates,
+			scheduleId,
+		});
+		return updated ? specToSchedule(updated) : undefined;
+	}
+
+	public deleteSchedule(scheduleId: string): boolean {
+		return this.store.deleteHubSchedule(scheduleId);
+	}
+
+	public pauseSchedule(scheduleId: string): ScheduleRecord | undefined {
+		return this.updateSchedule(scheduleId, { scheduleId, enabled: false });
+	}
+
+	public resumeSchedule(scheduleId: string): ScheduleRecord | undefined {
+		return this.updateSchedule(scheduleId, { scheduleId, enabled: true });
+	}
+
+	public async triggerScheduleNow(
+		scheduleId: string,
+	): Promise<ScheduleExecutionRecord | undefined> {
+		const run = this.store.enqueueHubScheduleRun(scheduleId, "manual");
+		if (!run) return undefined;
+		await this.runner.tick();
+		const completed = this.store.getRun(run.runId) ?? run;
+		return runToExecution(completed, scheduleId);
+	}
+
+	public triggerScheduleNowDetached(
+		scheduleId: string,
+	): ScheduleExecutionRecord | undefined {
+		const run = this.store.enqueueHubScheduleRun(scheduleId, "manual");
+		if (!run) return undefined;
+		void this.runner.tick().catch(() => undefined);
+		return runToExecution(run, scheduleId);
+	}
+
+	public listScheduleExecutions(
+		options: ListScheduleExecutionsOptions,
+	): ScheduleExecutionRecord[] {
+		const spec = options.scheduleId
+			? this.store.getHubSchedule(options.scheduleId)
+			: undefined;
+		const runOptions: ListRunsOptions = {
+			specId: spec?.specId,
+			limit: options.limit,
+		};
+		const runs = this.store.listRuns(runOptions);
+		return runs
+			.map((run) => {
+				const runSpec = spec ?? this.store.getSpec(run.specId);
+				if (!runSpec || runSpec.source !== "hub-schedule") return undefined;
+				return runToExecution(run, runSpec.externalId);
+			})
+			.filter((record): record is ScheduleExecutionRecord => {
+				if (!record) return false;
+				return !options.status || record.status === options.status;
+			});
+	}
+
+	public getScheduleStats(scheduleId: string): ScheduleExecutionStats {
+		const all = this.listScheduleExecutions({ scheduleId, limit: 10_000 });
+		if (all.length === 0) {
+			return { totalRuns: 0, successRate: 0, avgDurationSeconds: 0 };
+		}
+		let success = 0;
+		let withDuration = 0;
+		let durationMsTotal = 0;
+		let lastFailure: ScheduleExecutionRecord | undefined;
+		for (const execution of all) {
+			if (execution.status === "success" || execution.status === "completed") {
+				success += 1;
+			}
+			if (
+				!lastFailure &&
+				execution.status !== "success" &&
+				execution.status !== "completed"
+			) {
+				lastFailure = execution;
+			}
+			if (execution.startedAt && execution.endedAt) {
+				durationMsTotal += execution.endedAt - execution.startedAt;
+				withDuration += 1;
+			}
+		}
+		return {
+			totalRuns: all.length,
+			successRate: success / all.length,
+			avgDurationSeconds:
+				withDuration > 0 ? durationMsTotal / withDuration / 1000 : 0,
+			lastFailure,
+		};
+	}
+
+	public getActiveExecutions(): ActiveScheduledExecution[] {
+		return this.runner.getActiveRuns().flatMap((run) => {
+			const spec = this.store.getSpec(run.specId);
+			if (!spec || spec.source !== "hub-schedule" || !run.sessionId) return [];
+			return [
+				{
+					executionId: run.runId,
+					scheduleId: spec.externalId,
+					sessionId: run.sessionId,
+					startedAt: run.startedAt ?? new Date().toISOString(),
+					timeoutAt:
+						spec.timeoutSeconds && run.startedAt
+							? new Date(
+									new Date(run.startedAt).getTime() +
+										spec.timeoutSeconds * 1000,
+								).toISOString()
+							: undefined,
+				},
+			];
+		});
+	}
+
+	public getUpcomingRuns(limit = 20): Array<{
+		scheduleId: string;
+		name: string;
+		nextRunAt: string;
+	}> {
+		const options: ListSpecsOptions = {
+			triggerKind: "schedule",
+			enabled: true,
+			limit,
+		};
+		return this.store
+			.listSpecs(options)
+			.flatMap((spec) =>
+				spec.source === "hub-schedule" && spec.nextRunAt
+					? [{ spec, nextRunAt: spec.nextRunAt }]
+					: [],
+			)
+			.sort((a, b) => String(a.nextRunAt).localeCompare(String(b.nextRunAt)))
+			.slice(0, limit)
+			.map(({ spec, nextRunAt }) => ({
+				scheduleId: spec.externalId,
+				name: spec.title,
+				nextRunAt,
+			}));
+	}
+}
diff --git a/sdk/packages/core/src/cron/specs/cron-reconciler.test.ts b/sdk/packages/core/src/cron/specs/cron-reconciler.test.ts
new file mode 100644
index 0000000..a8c3492
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/cron-reconciler.test.ts
@@ -0,0 +1,138 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import { CronReconciler } from "./cron-reconciler";
+
+describe("CronReconciler", () => {
+	let root: string;
+	let cronDir: string;
+	let dbPath: string;
+	let store: SqliteCronStore;
+	let reconciler: CronReconciler;
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "cline-reconciler-"));
+		cronDir = join(root, "cron-specs");
+		mkdirSync(cronDir, { recursive: true });
+		dbPath = join(root, "cron.db");
+		store = new SqliteCronStore({ dbPath });
+		reconciler = new CronReconciler({
+			store,
+			specs: { cronSpecsDir: cronDir },
+		});
+	});
+
+	afterEach(() => {
+		store.close();
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	function writeSpec(rel: string, content: string) {
+		const full = join(cronDir, rel);
+		mkdirSync(join(full, ".."), { recursive: true });
+		writeFileSync(full, content, "utf8");
+	}
+
+	function requireValue<T>(value: T | undefined): T {
+		expect(value).toBeDefined();
+		if (value === undefined) {
+			throw new Error("Expected value to be defined");
+		}
+		return value;
+	}
+
+	it("imports valid one-off and schedule specs on startup", async () => {
+		writeSpec(
+			"cleanup.md",
+			`---\nid: cleanup\nworkspaceRoot: /ws\n---\nRemove stale files`,
+		);
+		writeSpec(
+			"nightly.cron.md",
+			`---\nid: nightly\nworkspaceRoot: /ws\nschedule: "0 2 * * *"\n---\nNightly`,
+		);
+
+		const summary = await reconciler.reconcileAll();
+		expect(summary.scanned).toBe(2);
+		expect(summary.upserted).toBe(2);
+		expect(summary.invalidParses).toBe(0);
+
+		const specs = store.listSpecs();
+		expect(specs.length).toBe(2);
+		const schedule = specs.find((s) => s.triggerKind === "schedule");
+		expect(schedule?.scheduleExpr).toBe("0 2 * * *");
+		expect(schedule?.nextRunAt).toBeDefined();
+	});
+
+	it("records invalid specs without failing the whole scan", async () => {
+		writeSpec("bad.md", `---\nid: [unclosed\n---\nbody`);
+		writeSpec(
+			"good.md",
+			`---\nid: good\nworkspaceRoot: /ws\n---\nDo good work`,
+		);
+
+		const summary = await reconciler.reconcileAll();
+		expect(summary.upserted).toBe(2);
+		expect(summary.invalidParses).toBe(1);
+
+		const invalid = store
+			.listSpecs({ parseStatus: "invalid" })
+			.find((s) => s.sourcePath === "bad.md");
+		expect(invalid).toBeDefined();
+		expect(invalid?.parseError).toBeTruthy();
+		expect(invalid?.enabled).toBe(false);
+
+		const valid = store
+			.listSpecs({ parseStatus: "valid" })
+			.find((s) => s.sourcePath === "good.md");
+		expect(valid?.enabled).toBe(true);
+	});
+
+	it("marks specs as removed when source files disappear", async () => {
+		writeSpec("cleanup.md", `---\nid: cleanup\nworkspaceRoot: /ws\n---\nBody`);
+		await reconciler.reconcileAll();
+		rmSync(join(cronDir, "cleanup.md"));
+
+		const summary = await reconciler.reconcileAll();
+		expect(summary.removed).toBe(1);
+
+		const remaining = store.listSpecs({ includeRemoved: false });
+		expect(remaining.length).toBe(0);
+		const all = store.listSpecs({ includeRemoved: true });
+		expect(all[0]?.removed).toBe(true);
+	});
+
+	it("cancels queued runs when spec is removed", async () => {
+		writeSpec("cleanup.md", `---\nid: cleanup\nworkspaceRoot: /ws\n---\nBody`);
+		await reconciler.reconcileAll();
+		const spec = requireValue(store.listSpecs()[0]);
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: spec.revision,
+			triggerKind: "one_off",
+		});
+
+		rmSync(join(cronDir, "cleanup.md"));
+		await reconciler.reconcileAll();
+
+		const run = requireValue(store.listRuns({ specId: spec.specId })[0]);
+		expect(run.status).toBe("cancelled");
+	});
+
+	it("preserves overdue schedule next_run_at on startup refresh", async () => {
+		writeSpec(
+			"nightly.cron.md",
+			`---\nid: nightly\nworkspaceRoot: /ws\nschedule: "* * * * *"\n---\nNightly`,
+		);
+		await reconciler.reconcileAll();
+		const spec = requireValue(store.listSpecs({ triggerKind: "schedule" })[0]);
+		const overdue = new Date(Date.now() - 60_000).toISOString();
+		store.updateSpecNextRunAt(spec.specId, overdue);
+
+		reconciler.refreshScheduleNextRunAt();
+
+		const refreshed = requireValue(store.getSpec(spec.specId));
+		expect(refreshed.nextRunAt).toBe(overdue);
+	});
+});
diff --git a/sdk/packages/core/src/cron/specs/cron-reconciler.ts b/sdk/packages/core/src/cron/specs/cron-reconciler.ts
new file mode 100644
index 0000000..3cf811a
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/cron-reconciler.ts
@@ -0,0 +1,241 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { relative } from "node:path";
+import type { CronSpecParseResult } from "@cline/shared";
+import {
+	type ResolveCronSpecsDirOptions,
+	resolveCronSpecsDir,
+} from "@cline/shared/storage";
+import { getNextCronTime } from "../schedule/scheduler";
+import type {
+	CronSpecRecord,
+	SqliteCronStore,
+	UpsertSpecResult,
+} from "../store/sqlite-cron-store";
+import { type ParseCronSpecInput, parseCronSpecFile } from "./cron-spec-parser";
+
+/**
+ * Scan the configured cron specs directory on disk, parse every file, and
+ * upsert spec state into the cron DB. This is the startup source of truth:
+ * watcher events are triggers to re-run reconciliation for one file, not a
+ * replacement.
+ */
+
+export interface CronReconcilerOptions {
+	store: SqliteCronStore;
+	/**
+	 * Cron spec source location. Defaults to global `~/.cline/cron`.
+	 * Pass `{ scope: "workspace", workspaceRoot }` later to enable
+	 * workspace-level cron sources without changing reconciler internals.
+	 */
+	specs?: ResolveCronSpecsDirOptions;
+	/** @deprecated Use `specs: { scope: "workspace", workspaceRoot }`. */
+	workspaceRoot?: string;
+}
+
+export interface ReconcileChange {
+	relativePath: string;
+	result: UpsertSpecResult;
+	parse: CronSpecParseResult;
+}
+
+export interface ReconcileSummary {
+	scanned: number;
+	upserted: number;
+	invalidParses: number;
+	removed: number;
+	changes: ReconcileChange[];
+}
+
+function toPosixRelative(fromDir: string, absolutePath: string): string {
+	return relative(fromDir, absolutePath).replace(/\\/g, "/");
+}
+
+function walk(dir: string): string[] {
+	if (!existsSync(dir)) return [];
+	const result: string[] = [];
+	const stack: string[] = [dir];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current) continue;
+		let entries: import("node:fs").Dirent[];
+		try {
+			entries = readdirSync(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const full = `${current}/${entry.name}`;
+			if (entry.isDirectory()) {
+				// Skip the generated reports subdirectory — not spec sources.
+				if (entry.name === "reports") continue;
+				stack.push(full);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			if (!entry.name.endsWith(".md")) continue;
+			result.push(full);
+		}
+	}
+	return result;
+}
+
+export class CronReconciler {
+	private readonly store: SqliteCronStore;
+	private readonly cronDir: string;
+
+	constructor(options: CronReconcilerOptions) {
+		this.store = options.store;
+		this.cronDir = resolveCronSpecsDir(
+			options.specs ??
+				(options.workspaceRoot
+					? { scope: "workspace", workspaceRoot: options.workspaceRoot }
+					: undefined),
+		);
+	}
+
+	public getCronDir(): string {
+		return this.cronDir;
+	}
+
+	/**
+	 * Reconcile every file under the cron specs directory into the DB and mark specs
+	 * whose source files no longer exist as `removed=1`.
+	 */
+	public async reconcileAll(): Promise<ReconcileSummary> {
+		const summary: ReconcileSummary = {
+			scanned: 0,
+			upserted: 0,
+			invalidParses: 0,
+			removed: 0,
+			changes: [],
+		};
+
+		const files = walk(this.cronDir);
+		const seenPaths = new Set<string>();
+
+		for (const abs of files) {
+			const rel = toPosixRelative(this.cronDir, abs);
+			seenPaths.add(rel);
+			summary.scanned += 1;
+			const change = await this.reconcileFile(rel, abs);
+			if (change) {
+				summary.changes.push(change);
+				summary.upserted += 1;
+				if (change.parse.error) summary.invalidParses += 1;
+			}
+		}
+
+		const existing = this.store.listSpecs({
+			includeRemoved: false,
+			limit: 10_000,
+		});
+		for (const spec of existing) {
+			if (!seenPaths.has(spec.sourcePath)) {
+				this.handleFileDeleted(spec);
+				summary.removed += 1;
+			}
+		}
+
+		this.refreshScheduleNextRunAt();
+
+		return summary;
+	}
+
+	/**
+	 * Reconcile a single file (absolute path). `relativePath` is expected to
+	 * be POSIX-relative to the cron specs directory. Returns the reconciliation change
+	 * or undefined if the file could not be read.
+	 */
+	public async reconcileFile(
+		relativePath: string,
+		absolutePath: string,
+	): Promise<ReconcileChange | undefined> {
+		const existing = this.store.getSpecBySourcePath(relativePath);
+		let raw: string;
+		let mtimeMs: number | undefined;
+		try {
+			raw = readFileSync(absolutePath, "utf8");
+			mtimeMs = statSync(absolutePath).mtimeMs;
+		} catch {
+			return undefined;
+		}
+		const input: ParseCronSpecInput = { relativePath, raw };
+		const parse = parseCronSpecFile(input);
+		const result = this.store.upsertSpec({
+			externalId: parse.externalId,
+			sourcePath: relativePath,
+			triggerKind: parse.triggerKind,
+			sourceMtimeMs: mtimeMs,
+			sourceHash: parse.contentHash,
+			parseStatus: parse.error ? "invalid" : "valid",
+			parseError: parse.error,
+			spec: parse.spec,
+		});
+
+		// For valid schedule specs, compute next_run_at if missing or reset
+		// when schedule_expr changed.
+		if (
+			!parse.error &&
+			parse.triggerKind === "schedule" &&
+			result.record.enabled
+		) {
+			this.applyScheduleNextRunAt(result.record, {
+				forceReset:
+					!existing ||
+					existing.removed ||
+					!existing.enabled ||
+					existing.scheduleExpr !== result.record.scheduleExpr ||
+					existing.timezone !== result.record.timezone,
+			});
+		}
+
+		return { relativePath, result, parse };
+	}
+
+	/**
+	 * Handle a file that disappeared from disk between reconciliations.
+	 * Marks the spec as removed and cancels any queued runs for it.
+	 */
+	public handleFileDeleted(spec: CronSpecRecord): void {
+		this.store.markSpecRemoved(spec.specId);
+		this.store.cancelQueuedRunsForSpec(spec.specId);
+	}
+
+	/**
+	 * Refresh next_run_at for every enabled schedule spec.
+	 * Used at startup to handle the "one overdue catch-up on startup then
+	 * advance to next slot" policy.
+	 */
+	public refreshScheduleNextRunAt(): void {
+		const schedules = this.store.listSpecs({
+			triggerKind: "schedule",
+			enabled: true,
+			parseStatus: "valid",
+		});
+		for (const spec of schedules) {
+			this.applyScheduleNextRunAt(spec, { forceReset: false });
+		}
+	}
+
+	private applyScheduleNextRunAt(
+		spec: CronSpecRecord,
+		options: { forceReset: boolean },
+	): void {
+		if (!spec.scheduleExpr) return;
+		if (!options.forceReset && spec.nextRunAt) return;
+		try {
+			const now = Date.now();
+			const base = spec.lastRunAt
+				? Math.max(now, new Date(spec.lastRunAt).getTime())
+				: now;
+			const nextMs = getNextCronTime(spec.scheduleExpr, base, spec.timezone);
+			const nextIso = new Date(nextMs).toISOString();
+			if (spec.nextRunAt !== nextIso) {
+				this.store.updateSpecNextRunAt(spec.specId, nextIso);
+			}
+		} catch {
+			// Invalid cron pattern — leave next_run_at as is; the upsert's
+			// parse_status already reflects the spec correctness.
+		}
+	}
+}
diff --git a/sdk/packages/core/src/cron/specs/cron-spec-parser.test.ts b/sdk/packages/core/src/cron/specs/cron-spec-parser.test.ts
new file mode 100644
index 0000000..652779b
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/cron-spec-parser.test.ts
@@ -0,0 +1,198 @@
+import { describe, expect, it } from "vitest";
+import {
+	computeContentHash,
+	inferTriggerKindFromPath,
+	parseCronSpecFile,
+	splitFrontmatter,
+} from "./cron-spec-parser";
+
+describe("inferTriggerKindFromPath", () => {
+	it("classifies *.cron.md as schedule", () => {
+		expect(inferTriggerKindFromPath("nightly.cron.md")).toBe("schedule");
+	});
+	it("classifies events/*.event.md as event", () => {
+		expect(inferTriggerKindFromPath("events/pr.event.md")).toBe("event");
+	});
+	it("classifies other *.md as one_off", () => {
+		expect(inferTriggerKindFromPath("repo-cleanup.md")).toBe("one_off");
+	});
+	it("does not classify *.event.md outside events/ as event", () => {
+		expect(inferTriggerKindFromPath("weird.event.md")).toBe("one_off");
+	});
+});
+
+describe("splitFrontmatter", () => {
+	it("returns undefined when no frontmatter", () => {
+		const result = splitFrontmatter("hello");
+		expect(result.frontmatter).toBeUndefined();
+		expect(result.body).toBe("hello");
+	});
+	it("splits frontmatter and body", () => {
+		const { frontmatter, body } = splitFrontmatter(
+			`---\nid: x\n---\nBody here`,
+		);
+		expect(frontmatter).toContain("id: x");
+		expect(body).toBe("Body here");
+	});
+});
+
+describe("computeContentHash", () => {
+	it("is stable under key order", () => {
+		expect(computeContentHash({ b: 1, a: 2 }, "body")).toBe(
+			computeContentHash({ a: 2, b: 1 }, "body"),
+		);
+	});
+
+	describe("parseCronSpecFile: one-off", () => {
+		it("parses with body prompt", () => {
+			const raw = `---\nid: cleanup\ntitle: Clean\nworkspaceRoot: /ws\nmode: act\n---\nRemove stale files.`;
+			const r = parseCronSpecFile({ relativePath: "cleanup.md", raw });
+			expect(r.error).toBeUndefined();
+			expect(r.externalId).toBe("cleanup");
+			expect(r.triggerKind).toBe("one_off");
+			expect(r.spec?.title).toBe("Clean");
+			expect(r.spec?.prompt).toBe("Remove stale files.");
+		});
+
+		it("defaults to yolo and parses cron runtime fields", () => {
+			const raw = `---\nid: cleanup\nworkspaceRoot: /ws\ntools: run_commands,read_files\nnotesDirectory: /notes\nextensions:\n  - rules\n  - skills\nsource: automation\n---\nBody`;
+			const r = parseCronSpecFile({ relativePath: "cleanup.md", raw });
+			expect(r.error).toBeUndefined();
+			expect(r.spec?.mode).toBe("yolo");
+			expect(r.spec?.tools).toEqual(["run_commands", "read_files"]);
+			expect(r.spec?.notesDirectory).toBe("/notes");
+			expect(r.spec?.extensions).toEqual(["rules", "skills"]);
+			expect(r.spec?.source).toBe("automation");
+		});
+
+		it("preserves explicit empty tools and extensions lists", () => {
+			const raw = `---\nid: cleanup\nworkspaceRoot: /ws\ntools: []\nextensions: []\n---\nBody`;
+			const r = parseCronSpecFile({ relativePath: "cleanup.md", raw });
+			expect(r.error).toBeUndefined();
+			expect(r.spec?.tools).toEqual([]);
+			expect(r.spec?.extensions).toEqual([]);
+		});
+
+		it("falls back to filename stem title", () => {
+			const raw = `---\nworkspaceRoot: /ws\n---\ndo work`;
+			const r = parseCronSpecFile({
+				relativePath: "nested/fix-thing.md",
+				raw,
+			});
+			expect(r.error).toBeUndefined();
+			expect(r.externalId).toBe("nested/fix-thing.md");
+			expect(r.spec?.title).toBe("fix-thing");
+		});
+
+		it("fails without workspaceRoot", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.md",
+				raw: `---\nid: x\n---\nbody`,
+			});
+			expect(r.error).toMatch(/workspaceRoot/);
+		});
+
+		it("fails when prompt and body both empty", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.md",
+				raw: `---\nworkspaceRoot: /ws\n---\n`,
+			});
+			expect(r.error).toMatch(/prompt is required/);
+		});
+
+		it("rejects schedule fields on one-off", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.md",
+				raw: `---\nworkspaceRoot: /ws\nschedule: "* * * * *"\n---\nbody`,
+			});
+			expect(r.error).toMatch(/schedule/);
+		});
+
+		it("rejects event fields on one-off", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.md",
+				raw: `---\nworkspaceRoot: /ws\nevent: github.pr\n---\nbody`,
+			});
+			expect(r.error).toMatch(/event/);
+		});
+
+		it("rejects removed cwd field", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.md",
+				raw: `---\nworkspaceRoot: /ws\ncwd: /ws/subdir\n---\nbody`,
+			});
+			expect(r.error).toMatch(/cwd/);
+		});
+
+		it("rejects invalid mode values", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.md",
+				raw: `---\nworkspaceRoot: /ws\nmode: autopilot\n---\nbody`,
+			});
+			expect(r.error).toMatch(/mode/);
+		});
+	});
+
+	describe("parseCronSpecFile: schedule", () => {
+		it("parses a valid *.cron.md", () => {
+			const raw = `---\nid: nightly\nworkspaceRoot: /ws\nschedule: "0 2 * * *"\ntimezone: UTC\n---\nDo work.`;
+			const r = parseCronSpecFile({ relativePath: "nightly.cron.md", raw });
+			expect(r.error).toBeUndefined();
+			expect(r.spec?.triggerKind).toBe("schedule");
+			if (r.spec?.triggerKind === "schedule") {
+				expect(r.spec.schedule).toBe("0 2 * * *");
+				expect(r.spec.timezone).toBe("UTC");
+			}
+		});
+		it("fails on *.cron.md without schedule", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.cron.md",
+				raw: `---\nworkspaceRoot: /ws\n---\nbody`,
+			});
+			expect(r.error).toMatch(/schedule/);
+		});
+
+		it("fails on invalid cron pattern", () => {
+			const r = parseCronSpecFile({
+				relativePath: "x.cron.md",
+				raw: `---\nworkspaceRoot: /ws\nschedule: "bad cron"\n---\nbody`,
+			});
+			expect(r.error).toMatch(/Invalid cron pattern/);
+		});
+	});
+
+	describe("parseCronSpecFile: event", () => {
+		it("parses events/*.event.md", () => {
+			const raw = `---\nid: pr\nworkspaceRoot: /ws\nevent: gh.pr.opened\nfilters:\n  repo: acme\ndebounceSeconds: 30\nmaxParallel: 2\n---\nReview PR.`;
+			const r = parseCronSpecFile({
+				relativePath: "events/pr.event.md",
+				raw,
+			});
+			expect(r.error).toBeUndefined();
+			expect(r.triggerKind).toBe("event");
+			if (r.spec?.triggerKind === "event") {
+				expect(r.spec.event).toBe("gh.pr.opened");
+				expect(r.spec.filters?.repo).toBe("acme");
+				expect(r.spec.maxParallel).toBe(2);
+			}
+		});
+		it("fails on event spec without event", () => {
+			const r = parseCronSpecFile({
+				relativePath: "events/x.event.md",
+				raw: `---\nworkspaceRoot: /ws\n---\nbody`,
+			});
+			expect(r.error).toMatch(/event/);
+		});
+	});
+
+	describe("parseCronSpecFile: invalid frontmatter", () => {
+		it("records parse error without throwing", () => {
+			const r = parseCronSpecFile({
+				relativePath: "bad.md",
+				raw: `---\nid: [unclosed\n---\nbody`,
+			});
+			expect(r.error).toBeDefined();
+			expect(r.spec).toBeUndefined();
+		});
+	});
+});
diff --git a/sdk/packages/core/src/cron/specs/cron-spec-parser.ts b/sdk/packages/core/src/cron/specs/cron-spec-parser.ts
new file mode 100644
index 0000000..4872591
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/cron-spec-parser.ts
@@ -0,0 +1,489 @@
+import { createHash } from "node:crypto";
+import type {
+	CronEventSpec,
+	CronOneOffSpec,
+	CronScheduleSpec,
+	CronSpec,
+	CronSpecExtensionKind,
+	CronSpecMode,
+	CronSpecParseResult,
+	CronTriggerKind,
+} from "@cline/shared";
+import YAML from "yaml";
+import { ALL_DEFAULT_TOOL_NAMES } from "../../extensions/tools/constants";
+import { validateCronSchedule } from "../schedule/scheduler";
+
+/**
+ * Markdown frontmatter parser for `.cline/cron/*.md` automation specs.
+ *
+ * Lives in @cline/core because it depends on `yaml`. The spec types
+ * themselves live in @cline/shared so other packages can consume them
+ * without pulling in a YAML parser.
+ *
+ * The parser never throws for a single bad file — it produces a
+ * `CronSpecParseResult` with an `error` message so the reconciler can record
+ * `parse_status='invalid'` durably instead of dropping state.
+ */
+
+export function inferTriggerKindFromPath(
+	relativePath: string,
+): CronTriggerKind {
+	const normalized = relativePath.replace(/\\/g, "/");
+	if (normalized.startsWith("events/") && normalized.endsWith(".event.md")) {
+		return "event";
+	}
+	if (normalized.endsWith(".cron.md")) {
+		return "schedule";
+	}
+	return "one_off";
+}
+
+export function splitFrontmatter(raw: string): {
+	frontmatter: string | undefined;
+	body: string;
+} {
+	const text = raw.replace(/\r\n/g, "\n");
+	if (!text.startsWith("---\n")) {
+		return { frontmatter: undefined, body: raw };
+	}
+	const afterOpen = text.slice(4);
+	const closeIdx = afterOpen.indexOf("\n---");
+	if (closeIdx === -1) {
+		return { frontmatter: undefined, body: raw };
+	}
+	const frontmatter = afterOpen.slice(0, closeIdx);
+	let rest = afterOpen.slice(closeIdx + 4);
+	if (rest.startsWith("\n")) rest = rest.slice(1);
+	return { frontmatter, body: rest };
+}
+
+function trimOrUndefined(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function normalizeTags(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const tags = value
+		.map((item) => (typeof item === "string" ? item.trim() : ""))
+		.filter((item) => item.length > 0);
+	return tags.length > 0 ? tags : undefined;
+}
+
+function normalizeRecord(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return value as Record<string, unknown>;
+}
+
+function normalizeModelSelection(
+	value: unknown,
+): { providerId?: string; modelId?: string } | undefined {
+	const obj = normalizeRecord(value);
+	if (!obj) return undefined;
+	const providerId = trimOrUndefined(obj.providerId);
+	const modelId = trimOrUndefined(obj.modelId);
+	if (providerId === undefined && modelId === undefined) return undefined;
+	return { providerId, modelId };
+}
+
+function normalizeMode(value: unknown): CronSpecMode | undefined {
+	if (typeof value !== "string") return undefined;
+	const lower = value.trim().toLowerCase();
+	if (lower === "act" || lower === "plan" || lower === "yolo") return lower;
+	return undefined;
+}
+
+function normalizeStringList(
+	value: unknown,
+	options: { preserveEmptyArray?: boolean } = {},
+): string[] | undefined {
+	const raw = Array.isArray(value)
+		? value
+		: typeof value === "string"
+			? value.split(",")
+			: undefined;
+	if (!raw) return undefined;
+	const normalized = [
+		...new Set(
+			raw
+				.map((item) => (typeof item === "string" ? item.trim() : ""))
+				.filter((item) => item.length > 0),
+		),
+	];
+	if (Array.isArray(value) && options.preserveEmptyArray) {
+		return normalized;
+	}
+	return normalized.length > 0 ? normalized : undefined;
+}
+
+const DEFAULT_TOOL_NAME_SET = new Set<string>(ALL_DEFAULT_TOOL_NAMES);
+
+function normalizeToolList(value: unknown): string[] | undefined {
+	const tools = normalizeStringList(value, { preserveEmptyArray: true });
+	if (!tools) return undefined;
+	const invalid = tools.filter((tool) => !DEFAULT_TOOL_NAME_SET.has(tool));
+	if (invalid.length > 0) {
+		throw new Error(`unknown tool(s): ${invalid.join(", ")}`);
+	}
+	return tools;
+}
+
+const CRON_EXTENSION_KINDS = new Set<CronSpecExtensionKind>([
+	"rules",
+	"skills",
+	"plugins",
+]);
+
+function normalizeExtensions(
+	value: unknown,
+): CronSpecExtensionKind[] | undefined {
+	const extensions = normalizeStringList(value, { preserveEmptyArray: true });
+	if (!extensions) return undefined;
+	const invalid = extensions.filter(
+		(extension) =>
+			!CRON_EXTENSION_KINDS.has(extension as CronSpecExtensionKind),
+	);
+	if (invalid.length > 0) {
+		throw new Error(`unknown extension(s): ${invalid.join(", ")}`);
+	}
+	return extensions as CronSpecExtensionKind[];
+}
+
+function asPositiveInt(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+		return undefined;
+	}
+	return Math.floor(value);
+}
+
+function asNonNegativeInt(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+		return undefined;
+	}
+	return Math.floor(value);
+}
+
+function stableStringify(value: unknown): string {
+	if (value === null || typeof value !== "object") {
+		return JSON.stringify(value ?? null);
+	}
+	if (Array.isArray(value)) {
+		return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	}
+	const entries = Object.entries(value as Record<string, unknown>).filter(
+		([, v]) => v !== undefined,
+	);
+	entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+	return `{${entries
+		.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)
+		.join(",")}}`;
+}
+
+export function computeContentHash(
+	frontmatterJson: unknown,
+	body: string,
+): string {
+	const hash = createHash("sha256");
+	hash.update(stableStringify(frontmatterJson));
+	hash.update("\n");
+	hash.update(body);
+	return hash.digest("hex");
+}
+
+function filenameStem(relativePath: string): string {
+	const base = relativePath.split("/").pop() ?? relativePath;
+	return base
+		.replace(/\.event\.md$/, "")
+		.replace(/\.cron\.md$/, "")
+		.replace(/\.md$/, "");
+}
+
+const SCHEDULE_ONLY_FIELDS = ["schedule", "timezone"] as const;
+const EVENT_ONLY_FIELDS = [
+	"event",
+	"filters",
+	"debounceSeconds",
+	"dedupeWindowSeconds",
+	"cooldownSeconds",
+	"maxParallel",
+] as const;
+const REMOVED_FIELDS = ["cwd"] as const;
+
+export interface ParseCronSpecInput {
+	relativePath: string;
+	raw: string;
+}
+
+function invalid(
+	relativePath: string,
+	triggerKind: CronTriggerKind,
+	body: string,
+	frontmatter: Record<string, unknown>,
+	error: string,
+): CronSpecParseResult {
+	return {
+		externalId: relativePath,
+		relativePath,
+		triggerKind,
+		body,
+		contentHash: computeContentHash(frontmatter, body),
+		error,
+	};
+}
+
+function invalidWithHash(
+	externalId: string,
+	relativePath: string,
+	triggerKind: CronTriggerKind,
+	body: string,
+	contentHash: string,
+	error: string,
+): CronSpecParseResult {
+	return {
+		externalId,
+		relativePath,
+		triggerKind,
+		body,
+		contentHash,
+		error,
+	};
+}
+
+/**
+ * Parse a single cron spec file. Never throws; always returns a result.
+ */
+export function parseCronSpecFile(
+	input: ParseCronSpecInput,
+): CronSpecParseResult {
+	const relativePath = input.relativePath.replace(/\\/g, "/");
+	const triggerKind = inferTriggerKindFromPath(relativePath);
+	const { frontmatter, body } = splitFrontmatter(input.raw);
+
+	let frontmatterData: Record<string, unknown> = {};
+	if (frontmatter !== undefined && frontmatter.trim().length > 0) {
+		try {
+			const parsed = YAML.parse(frontmatter) as unknown;
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				frontmatterData = parsed as Record<string, unknown>;
+			} else if (parsed !== null && parsed !== undefined) {
+				return invalid(
+					relativePath,
+					triggerKind,
+					body,
+					{},
+					"frontmatter must be a YAML mapping",
+				);
+			}
+		} catch (err) {
+			return invalid(
+				relativePath,
+				triggerKind,
+				body,
+				{},
+				err instanceof Error
+					? `failed to parse frontmatter: ${err.message}`
+					: "failed to parse frontmatter",
+			);
+		}
+	}
+
+	const contentHash = computeContentHash(frontmatterData, body);
+	const externalIdRaw = trimOrUndefined(frontmatterData.id);
+	const externalId = externalIdRaw ?? relativePath;
+
+	if (triggerKind !== "schedule") {
+		for (const key of SCHEDULE_ONLY_FIELDS) {
+			if (frontmatterData[key] !== undefined) {
+				return invalidWithHash(
+					externalId,
+					relativePath,
+					triggerKind,
+					body,
+					contentHash,
+					`field "${key}" is only allowed on *.cron.md specs`,
+				);
+			}
+		}
+	}
+	for (const key of REMOVED_FIELDS) {
+		if (frontmatterData[key] !== undefined) {
+			return invalidWithHash(
+				externalId,
+				relativePath,
+				triggerKind,
+				body,
+				contentHash,
+				`field "${key}" is no longer supported; cron specs use workspaceRoot as cwd`,
+			);
+		}
+	}
+	if (triggerKind !== "event") {
+		for (const key of EVENT_ONLY_FIELDS) {
+			if (frontmatterData[key] !== undefined) {
+				return invalidWithHash(
+					externalId,
+					relativePath,
+					triggerKind,
+					body,
+					contentHash,
+					`field "${key}" is only allowed on .event.md specs`,
+				);
+			}
+		}
+	}
+
+	const frontmatterPrompt = trimOrUndefined(frontmatterData.prompt);
+	const bodyTrimmed = body.trim();
+	const prompt =
+		frontmatterPrompt ?? (bodyTrimmed.length > 0 ? bodyTrimmed : undefined);
+	if (!prompt) {
+		return invalidWithHash(
+			externalId,
+			relativePath,
+			triggerKind,
+			body,
+			contentHash,
+			"prompt is required (frontmatter `prompt` or markdown body)",
+		);
+	}
+
+	const workspaceRoot = trimOrUndefined(frontmatterData.workspaceRoot);
+	if (!workspaceRoot) {
+		return invalidWithHash(
+			externalId,
+			relativePath,
+			triggerKind,
+			body,
+			contentHash,
+			"workspaceRoot is required",
+		);
+	}
+
+	let tools: string[] | undefined;
+	let extensions: CronSpecExtensionKind[] | undefined;
+	try {
+		tools = normalizeToolList(frontmatterData.tools);
+		extensions = normalizeExtensions(frontmatterData.extensions);
+	} catch (err) {
+		return invalidWithHash(
+			externalId,
+			relativePath,
+			triggerKind,
+			body,
+			contentHash,
+			err instanceof Error ? err.message : String(err),
+		);
+	}
+
+	const mode = normalizeMode(frontmatterData.mode);
+	if (frontmatterData.mode !== undefined && mode === undefined) {
+		return invalidWithHash(
+			externalId,
+			relativePath,
+			triggerKind,
+			body,
+			contentHash,
+			"mode must be one of: act, plan, yolo",
+		);
+	}
+
+	const common = {
+		id: externalIdRaw,
+		title:
+			trimOrUndefined(frontmatterData.title) ??
+			externalIdRaw ??
+			filenameStem(relativePath),
+		prompt,
+		workspaceRoot,
+		mode: mode ?? "yolo",
+		systemPrompt: trimOrUndefined(frontmatterData.systemPrompt),
+		modelSelection: normalizeModelSelection(frontmatterData.modelSelection),
+		maxIterations: asPositiveInt(frontmatterData.maxIterations),
+		timeoutSeconds: asPositiveInt(frontmatterData.timeoutSeconds),
+		tools,
+		notesDirectory: trimOrUndefined(frontmatterData.notesDirectory),
+		extensions,
+		source: trimOrUndefined(frontmatterData.source) ?? "user",
+		tags: normalizeTags(frontmatterData.tags),
+		enabled:
+			typeof frontmatterData.enabled === "boolean"
+				? frontmatterData.enabled
+				: true,
+		metadata: normalizeRecord(frontmatterData.metadata),
+	};
+
+	let spec: CronSpec;
+	if (triggerKind === "schedule") {
+		const schedule = trimOrUndefined(frontmatterData.schedule);
+		if (!schedule) {
+			return invalidWithHash(
+				externalId,
+				relativePath,
+				triggerKind,
+				body,
+				contentHash,
+				"schedule is required for *.cron.md specs",
+			);
+		}
+		const timezone = trimOrUndefined(frontmatterData.timezone);
+		try {
+			validateCronSchedule(schedule, timezone);
+		} catch (err) {
+			return invalidWithHash(
+				externalId,
+				relativePath,
+				triggerKind,
+				body,
+				contentHash,
+				err instanceof Error ? err.message : String(err),
+			);
+		}
+		const s: CronScheduleSpec = {
+			...common,
+			triggerKind: "schedule",
+			schedule,
+			timezone,
+		};
+		spec = s;
+	} else if (triggerKind === "event") {
+		const event = trimOrUndefined(frontmatterData.event);
+		if (!event) {
+			return invalidWithHash(
+				externalId,
+				relativePath,
+				triggerKind,
+				body,
+				contentHash,
+				"event is required for .event.md specs",
+			);
+		}
+		const e: CronEventSpec = {
+			...common,
+			triggerKind: "event",
+			event,
+			filters: normalizeRecord(frontmatterData.filters),
+			debounceSeconds: asNonNegativeInt(frontmatterData.debounceSeconds),
+			dedupeWindowSeconds: asNonNegativeInt(
+				frontmatterData.dedupeWindowSeconds,
+			),
+			cooldownSeconds: asNonNegativeInt(frontmatterData.cooldownSeconds),
+			maxParallel: asPositiveInt(frontmatterData.maxParallel),
+		};
+		spec = e;
+	} else {
+		const o: CronOneOffSpec = { ...common, triggerKind: "one_off" };
+		spec = o;
+	}
+
+	return {
+		externalId,
+		relativePath,
+		triggerKind,
+		body,
+		contentHash,
+		spec,
+	};
+}
diff --git a/sdk/packages/core/src/cron/specs/cron-watcher.test.ts b/sdk/packages/core/src/cron/specs/cron-watcher.test.ts
new file mode 100644
index 0000000..14afe05
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/cron-watcher.test.ts
@@ -0,0 +1,87 @@
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { CronMaterializer } from "../runner/cron-materializer";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import { CronReconciler } from "./cron-reconciler";
+import { CronWatcher } from "./cron-watcher";
+
+describe("CronWatcher", () => {
+	let root: string;
+	let cronDir: string;
+	let store: SqliteCronStore;
+	let reconciler: CronReconciler;
+	let materializer: CronMaterializer;
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "cline-watcher-"));
+		cronDir = join(root, "cron-specs");
+		mkdirSync(cronDir, { recursive: true });
+		store = new SqliteCronStore({ dbPath: join(root, "cron.db") });
+		reconciler = new CronReconciler({
+			store,
+			specs: { cronSpecsDir: cronDir },
+		});
+		materializer = new CronMaterializer({ store });
+	});
+
+	afterEach(() => {
+		store.close();
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	function requireValue<T>(value: T | undefined): T {
+		expect(value).toBeDefined();
+		if (value === undefined) {
+			throw new Error("Expected value to be defined");
+		}
+		return value;
+	}
+
+	it("materializes after a watched file reconcile", async () => {
+		const specPath = join(cronDir, "cleanup.md");
+		writeFileSync(
+			specPath,
+			`---\nid: cleanup\nworkspaceRoot: /ws\n---\nRemove stale files`,
+			"utf8",
+		);
+		let materialized = 0;
+		const watcher = new CronWatcher({
+			reconciler,
+			onReconciled: () => {
+				materialized += materializer.materializeAll().oneOffQueued;
+			},
+		});
+
+		await (
+			watcher as unknown as { reconcileNow(path: string): Promise<void> }
+		).reconcileNow("cleanup.md");
+
+		expect(materialized).toBe(1);
+		const spec = requireValue(store.listSpecs()[0]);
+		const runs = store.listRuns({ specId: spec.specId });
+		expect(runs).toHaveLength(1);
+		expect(runs[0]?.status).toBe("queued");
+	});
+
+	it("creates the cron directory before starting the watcher", () => {
+		const missingCronDir = join(root, "missing-cron-specs");
+		const watcherReconciler = new CronReconciler({
+			store,
+			specs: { cronSpecsDir: missingCronDir },
+		});
+		const watcher = new CronWatcher({ reconciler: watcherReconciler });
+
+		watcher.start();
+		watcher.stop();
+
+		expect(existsSync(missingCronDir)).toBe(true);
+	});
+});
diff --git a/sdk/packages/core/src/cron/specs/cron-watcher.ts b/sdk/packages/core/src/cron/specs/cron-watcher.ts
new file mode 100644
index 0000000..3f72536
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/cron-watcher.ts
@@ -0,0 +1,102 @@
+import type { FSWatcher } from "node:fs";
+import { existsSync, mkdirSync, watch } from "node:fs";
+import { relative, resolve } from "node:path";
+import type { CronReconciler } from "./cron-reconciler";
+
+/**
+ * Filesystem watcher for the configured cron specs directory.
+ *
+ * Uses `node:fs` `watch` with `{ recursive: true }`. Emits a re-reconcile
+ * request for each change, debounced per path, so rapid save bursts from
+ * editors don't cause redundant DB churn.
+ */
+
+const DEFAULT_DEBOUNCE_MS = 250;
+
+export interface CronWatcherOptions {
+	reconciler: CronReconciler;
+	debounceMs?: number;
+	onError?: (error: unknown) => void;
+	onReconciled?: () => void | Promise<void>;
+}
+
+export class CronWatcher {
+	private readonly reconciler: CronReconciler;
+	private readonly debounceMs: number;
+	private readonly onError: (error: unknown) => void;
+	private readonly onReconciled: () => void | Promise<void>;
+	private watcher?: FSWatcher;
+	private readonly pending = new Map<string, ReturnType<typeof setTimeout>>();
+	private disposed = false;
+
+	constructor(options: CronWatcherOptions) {
+		this.reconciler = options.reconciler;
+		this.debounceMs = Math.max(0, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+		this.onError = options.onError ?? (() => {});
+		this.onReconciled = options.onReconciled ?? (() => {});
+	}
+
+	public start(): void {
+		if (this.disposed) throw new Error("CronWatcher disposed");
+		if (this.watcher) return;
+		const dir = this.reconciler.getCronDir();
+		try {
+			mkdirSync(dir, { recursive: true });
+			this.watcher = watch(dir, { recursive: true }, (_eventType, filename) => {
+				if (!filename) return;
+				const rel = String(filename).replace(/\\/g, "/");
+				if (!rel.endsWith(".md")) return;
+				if (rel.startsWith("reports/")) return;
+				this.scheduleReconcile(rel);
+			});
+			this.watcher.on("error", this.onError);
+		} catch (err) {
+			this.onError(err);
+		}
+	}
+
+	public stop(): void {
+		for (const timer of this.pending.values()) clearTimeout(timer);
+		this.pending.clear();
+		this.watcher?.close();
+		this.watcher = undefined;
+	}
+
+	public dispose(): void {
+		this.disposed = true;
+		this.stop();
+	}
+
+	private scheduleReconcile(relativePath: string): void {
+		const existing = this.pending.get(relativePath);
+		if (existing) clearTimeout(existing);
+		const timer = setTimeout(() => {
+			this.pending.delete(relativePath);
+			void this.reconcileNow(relativePath);
+		}, this.debounceMs);
+		this.pending.set(relativePath, timer);
+	}
+
+	private async reconcileNow(relativePath: string): Promise<void> {
+		try {
+			const abs = resolve(this.reconciler.getCronDir(), relativePath);
+			if (!existsSync(abs)) {
+				// File was deleted — force a full reconcile to catch the
+				// missing source and mark the spec removed.
+				await this.reconciler.reconcileAll();
+				await this.onReconciled();
+				return;
+			}
+			// Normalize relative path through the reconciler dir to defend
+			// against a watcher emitting an unexpected format.
+			const normalizedRel = relative(this.reconciler.getCronDir(), abs).replace(
+				/\\/g,
+				"/",
+			);
+			await this.reconciler.reconcileFile(normalizedRel, abs);
+			await this.onReconciled();
+		} catch (err) {
+			this.onError(err);
+		}
+	}
+}
diff --git a/sdk/packages/core/src/cron/specs/index.ts b/sdk/packages/core/src/cron/specs/index.ts
new file mode 100644
index 0000000..389605f
--- /dev/null
+++ b/sdk/packages/core/src/cron/specs/index.ts
@@ -0,0 +1,3 @@
+export * from "./cron-reconciler";
+export * from "./cron-spec-parser";
+export * from "./cron-watcher";
diff --git a/sdk/packages/core/src/cron/store/cron-schema.ts b/sdk/packages/core/src/cron/store/cron-schema.ts
new file mode 100644
index 0000000..c34fd79
--- /dev/null
+++ b/sdk/packages/core/src/cron/store/cron-schema.ts
@@ -0,0 +1,127 @@
+import type { SqliteDb } from "@cline/shared/db";
+
+/**
+ * Bootstrap the dedicated cron.db schema. Unlike @cline/shared's
+ * `ensureSessionSchema`, this schema is fully owned by @cline/core
+ * because cron lifecycle (specs, runs, reports) is a core concern and
+ * should not be coupled to session storage.
+ */
+
+const CRON_SCHEMA_STATEMENTS: readonly string[] = [
+	`CREATE TABLE IF NOT EXISTS cron_specs (
+		spec_id TEXT PRIMARY KEY,
+		external_id TEXT NOT NULL,
+		source_path TEXT NOT NULL UNIQUE,
+		trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('one_off', 'schedule', 'event')),
+		source_mtime_ms INTEGER,
+		source_hash TEXT,
+		parse_status TEXT NOT NULL CHECK (parse_status IN ('valid', 'invalid')),
+		parse_error TEXT,
+		enabled INTEGER NOT NULL DEFAULT 1,
+		removed INTEGER NOT NULL DEFAULT 0,
+		title TEXT NOT NULL,
+		prompt TEXT,
+		workspace_root TEXT,
+		schedule_expr TEXT,
+		timezone TEXT,
+		event_type TEXT,
+		filters_json TEXT,
+		debounce_seconds INTEGER,
+		dedupe_window_seconds INTEGER,
+		cooldown_seconds INTEGER,
+		mode TEXT,
+		system_prompt TEXT,
+		provider_id TEXT,
+		model_id TEXT,
+		max_iterations INTEGER,
+		timeout_seconds INTEGER,
+		max_parallel INTEGER,
+		tools_json TEXT,
+		notes_directory TEXT,
+		extensions_json TEXT,
+		source TEXT,
+		tags_json TEXT,
+		metadata_json TEXT,
+		revision INTEGER NOT NULL DEFAULT 1,
+		last_materialized_run_id TEXT,
+		last_run_at TEXT,
+		next_run_at TEXT,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);`,
+	`CREATE TABLE IF NOT EXISTS cron_runs (
+		run_id TEXT PRIMARY KEY,
+		spec_id TEXT NOT NULL REFERENCES cron_specs(spec_id) ON DELETE CASCADE,
+		spec_revision INTEGER NOT NULL,
+		trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('one_off', 'schedule', 'event', 'manual', 'retry')),
+		status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'done', 'failed', 'cancelled')),
+		claim_token TEXT,
+		claim_started_at TEXT,
+		claim_until_at TEXT,
+		scheduled_for TEXT,
+		trigger_event_id TEXT,
+		started_at TEXT,
+		completed_at TEXT,
+		session_id TEXT,
+		report_path TEXT,
+		error TEXT,
+		attempt_count INTEGER NOT NULL DEFAULT 0,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);`,
+	`CREATE TABLE IF NOT EXISTS cron_event_log (
+		event_id TEXT PRIMARY KEY,
+		event_type TEXT NOT NULL,
+		source TEXT NOT NULL,
+		subject TEXT,
+		occurred_at TEXT NOT NULL,
+		received_at TEXT NOT NULL,
+		workspace_root TEXT,
+		dedupe_key TEXT,
+		payload_json TEXT,
+		attributes_json TEXT,
+		processing_status TEXT NOT NULL DEFAULT 'received'
+			CHECK (processing_status IN ('received', 'unmatched', 'queued', 'suppressed', 'failed')),
+		matched_spec_count INTEGER NOT NULL DEFAULT 0,
+		queued_run_count INTEGER NOT NULL DEFAULT 0,
+		suppressed_count INTEGER NOT NULL DEFAULT 0,
+		error TEXT,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);`,
+	`DROP INDEX IF EXISTS cron_runs_one_off_active_idx;`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS cron_runs_one_off_active_idx
+		ON cron_runs(spec_id, spec_revision)
+		WHERE trigger_kind = 'one_off';`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_claimable_idx
+		ON cron_runs(status, scheduled_for, claim_until_at);`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_spec_idx
+		ON cron_runs(spec_id, created_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_trigger_event_idx
+		ON cron_runs(trigger_event_id);`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_event_spec_status_idx
+		ON cron_runs(spec_id, trigger_kind, status, scheduled_for);`,
+	`CREATE INDEX IF NOT EXISTS cron_event_log_type_idx
+		ON cron_event_log(event_type, received_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_event_log_received_idx
+		ON cron_event_log(received_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_event_log_dedupe_idx
+		ON cron_event_log(event_type, source, dedupe_key, received_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_next_run_idx
+		ON cron_specs(trigger_kind, enabled, next_run_at);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_event_match_idx
+		ON cron_specs(trigger_kind, event_type, enabled);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_parse_status_idx
+		ON cron_specs(parse_status, updated_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_source_path_idx
+		ON cron_specs(source_path);`,
+];
+
+export function ensureCronSchema(db: SqliteDb): void {
+	db.exec("PRAGMA journal_mode = WAL;");
+	db.exec("PRAGMA busy_timeout = 5000;");
+	db.exec("PRAGMA foreign_keys = ON;");
+	for (const stmt of CRON_SCHEMA_STATEMENTS) {
+		db.exec(stmt);
+	}
+}
diff --git a/sdk/packages/core/src/cron/store/index.ts b/sdk/packages/core/src/cron/store/index.ts
new file mode 100644
index 0000000..da7594c
--- /dev/null
+++ b/sdk/packages/core/src/cron/store/index.ts
@@ -0,0 +1,2 @@
+export * from "./cron-schema";
+export * from "./sqlite-cron-store";
diff --git a/sdk/packages/core/src/cron/store/sqlite-cron-store.test.ts b/sdk/packages/core/src/cron/store/sqlite-cron-store.test.ts
new file mode 100644
index 0000000..69402ee
--- /dev/null
+++ b/sdk/packages/core/src/cron/store/sqlite-cron-store.test.ts
@@ -0,0 +1,354 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CronOneOffSpec, CronScheduleSpec } from "@cline/shared";
+import { loadSqliteDb } from "@cline/shared/db";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SqliteCronStore } from "./sqlite-cron-store";
+
+function tempDbPath(): { dir: string; path: string } {
+	const dir = mkdtempSync(join(tmpdir(), "cline-cron-store-"));
+	return { dir, path: join(dir, "cron.db") };
+}
+
+describe("SqliteCronStore", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		const tmp = tempDbPath();
+		dir = tmp.dir;
+		store = new SqliteCronStore({ dbPath: tmp.path });
+	});
+
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	const baseOneOff = (): CronOneOffSpec => ({
+		triggerKind: "one_off",
+		id: "cleanup",
+		title: "Clean",
+		prompt: "Remove stale files",
+		workspaceRoot: "/ws",
+		enabled: true,
+	});
+
+	it("creates a new spec row for a new source path", () => {
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		expect(result.created).toBe(true);
+		expect(result.revisionChanged).toBe(true);
+		expect(result.record.revision).toBe(1);
+		expect(result.record.enabled).toBe(true);
+		expect(result.record.parseStatus).toBe("valid");
+		expect(result.record.prompt).toBe("Remove stale files");
+	});
+
+	it("persists cron runtime controls", () => {
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: {
+				...baseOneOff(),
+				tools: ["run_commands", "read_files"],
+				notesDirectory: "/notes",
+				extensions: ["rules", "skills"],
+				source: "automation",
+			},
+		});
+		expect(result.record.tools).toEqual(["run_commands", "read_files"]);
+		expect(result.record.notesDirectory).toBe("/notes");
+		expect(result.record.extensions).toEqual(["rules", "skills"]);
+		expect(result.record.source).toBe("automation");
+	});
+
+	it("does not bump revision on cosmetic-only re-upsert with same hash", () => {
+		store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		expect(result.created).toBe(false);
+		expect(result.revisionChanged).toBe(false);
+		expect(result.record.revision).toBe(1);
+	});
+
+	it("bumps revision when the prompt changes", () => {
+		store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash2",
+			parseStatus: "valid",
+			spec: { ...baseOneOff(), prompt: "New prompt" },
+		});
+		expect(result.revisionChanged).toBe(true);
+		expect(result.record.revision).toBe(2);
+	});
+
+	it("records invalid parse status without a spec", () => {
+		const result = store.upsertSpec({
+			externalId: "bad.md",
+			sourcePath: "bad.md",
+			triggerKind: "one_off",
+			sourceHash: "bad",
+			parseStatus: "invalid",
+			parseError: "boom",
+		});
+		expect(result.record.parseStatus).toBe("invalid");
+		expect(result.record.enabled).toBe(false);
+		expect(result.record.parseError).toBe("boom");
+	});
+});
+
+describe("SqliteCronStore: schema migrations", () => {
+	it("recreates the one-off run uniqueness index when its predicate changes", () => {
+		const tmp = tempDbPath();
+		const initialStore = new SqliteCronStore({ dbPath: tmp.path });
+		initialStore.close();
+
+		const db = loadSqliteDb(tmp.path);
+		try {
+			db.exec("DROP INDEX IF EXISTS cron_runs_one_off_active_idx;");
+			db.exec(`CREATE UNIQUE INDEX cron_runs_one_off_active_idx
+				ON cron_runs(spec_id, spec_revision)
+				WHERE trigger_kind = 'one_off' AND status IN ('queued', 'running');`);
+			const before = db
+				.prepare(
+					"SELECT sql FROM sqlite_master WHERE type = 'index' AND name = 'cron_runs_one_off_active_idx'",
+				)
+				.get();
+			expect(String(before?.sql)).toContain("status IN");
+		} finally {
+			db.close?.();
+		}
+
+		const migratedStore = new SqliteCronStore({ dbPath: tmp.path });
+		migratedStore.close();
+
+		const migratedDb = loadSqliteDb(tmp.path);
+		try {
+			const after = migratedDb
+				.prepare(
+					"SELECT sql FROM sqlite_master WHERE type = 'index' AND name = 'cron_runs_one_off_active_idx'",
+				)
+				.get();
+			const indexSql = String(after?.sql);
+			expect(indexSql).toContain("WHERE trigger_kind = 'one_off'");
+			expect(indexSql).not.toContain("status IN");
+		} finally {
+			migratedDb.close?.();
+			rmSync(tmp.dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("SqliteCronStore: runs", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		const tmp = tempDbPath();
+		dir = tmp.dir;
+		store = new SqliteCronStore({ dbPath: tmp.path });
+	});
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	function seedOneOff() {
+		return store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "p",
+				workspaceRoot: "/ws",
+				enabled: true,
+			},
+		}).record;
+	}
+
+	it("enqueues a queued one-off run and detects duplicates", () => {
+		const spec = seedOneOff();
+		expect(store.hasOneOffRunForRevision(spec.specId, 1)).toBe(false);
+		const run = store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+			scheduledFor: new Date().toISOString(),
+		});
+		expect(run.status).toBe("queued");
+		expect(run.triggerKind).toBe("one_off");
+		expect(store.hasOneOffRunForRevision(spec.specId, 1)).toBe(true);
+	});
+
+	it("treats failed one-off runs as satisfying the revision", () => {
+		const spec = seedOneOff();
+		const run = store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		store.completeRun(run.runId, { status: "failed", error: "boom" });
+		expect(store.hasOneOffRunForRevision(spec.specId, 1)).toBe(true);
+	});
+
+	it("claims due queued runs and completes them", () => {
+		const spec = seedOneOff();
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+			scheduledFor: new Date().toISOString(),
+		});
+		const claims = store.claimDueRuns({
+			nowIso: new Date().toISOString(),
+			leaseMs: 30_000,
+		});
+		expect(claims.length).toBe(1);
+		expect(claims[0]?.run.status).toBe("running");
+		const ok = store.completeRun(claims[0]?.run.runId, {
+			status: "done",
+			reportPath: "/tmp/report.md",
+		});
+		expect(ok).toBe(true);
+		const run = store.getRun(claims[0]?.run.runId);
+		expect(run?.status).toBe("done");
+		expect(run?.reportPath).toBe("/tmp/report.md");
+	});
+
+	it("reclaims expired running leases", () => {
+		const spec = seedOneOff();
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		const firstClaims = store.claimDueRuns({
+			nowIso: "2026-04-23T10:00:00.000Z",
+			leaseMs: 1_000,
+		});
+		expect(firstClaims).toHaveLength(1);
+		const reclaimed = store.claimDueRuns({
+			nowIso: "2026-04-23T10:00:02.000Z",
+			leaseMs: 1_000,
+		});
+		expect(reclaimed).toHaveLength(1);
+		expect(reclaimed[0]?.run.runId).toBe(firstClaims[0]?.run.runId);
+		expect(reclaimed[0]?.claimToken).not.toBe(firstClaims[0]?.claimToken);
+		expect(reclaimed[0]?.run.attemptCount).toBe(2);
+	});
+
+	it("cancels queued runs when the spec is removed", () => {
+		const spec = seedOneOff();
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		expect(store.cancelQueuedRunsForSpec(spec.specId)).toBe(1);
+		const runs = store.listRuns({ specId: spec.specId });
+		expect(runs[0]?.status).toBe("cancelled");
+	});
+
+	it("requeues a claimed run when ownership matches", () => {
+		const spec = seedOneOff();
+		const queued = store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		const [claim] = store.claimDueRuns({
+			nowIso: "2026-04-23T10:00:00.000Z",
+			leaseMs: 10_000,
+		});
+		expect(claim?.run.runId).toBe(queued.runId);
+		expect(
+			store.requeueRun({
+				runId: claim?.run.runId,
+				claimToken: claim?.claimToken,
+				error: "retry later",
+			}),
+		).toBe(true);
+		const run = store.getRun(queued.runId);
+		expect(run?.status).toBe("queued");
+		expect(run?.claimToken).toBeUndefined();
+		expect(run?.startedAt).toBeUndefined();
+		expect(run?.error).toBe("retry later");
+	});
+});
+
+describe("SqliteCronStore: schedule spec fields", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		const tmp = tempDbPath();
+		dir = tmp.dir;
+		store = new SqliteCronStore({ dbPath: tmp.path });
+	});
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("persists schedule_expr and timezone", () => {
+		const spec: CronScheduleSpec = {
+			triggerKind: "schedule",
+			id: "nightly",
+			title: "Nightly",
+			prompt: "p",
+			workspaceRoot: "/ws",
+			enabled: true,
+			schedule: "0 2 * * *",
+			timezone: "UTC",
+		};
+		const result = store.upsertSpec({
+			externalId: "nightly",
+			sourcePath: "nightly.cron.md",
+			triggerKind: "schedule",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec,
+		});
+		expect(result.record.scheduleExpr).toBe("0 2 * * *");
+		expect(result.record.timezone).toBe("UTC");
+	});
+});
diff --git a/sdk/packages/core/src/cron/store/sqlite-cron-store.ts b/sdk/packages/core/src/cron/store/sqlite-cron-store.ts
new file mode 100644
index 0000000..390d7ef
--- /dev/null
+++ b/sdk/packages/core/src/cron/store/sqlite-cron-store.ts
@@ -0,0 +1,1552 @@
+import { randomUUID } from "node:crypto";
+import type {
+	AutomationEventEnvelope,
+	CronSpec,
+	CronSpecExtensionKind,
+	CronTriggerKind,
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+} from "@cline/shared";
+import {
+	asOptionalString,
+	asString,
+	loadSqliteDb,
+	nowIso,
+	type SqliteDb,
+} from "@cline/shared/db";
+import { resolveCronDbPath } from "@cline/shared/storage";
+import { getNextCronTime } from "../schedule/scheduler";
+import { ensureCronSchema } from "./cron-schema";
+
+/**
+ * Generalized cron/automation store backed by `cron.db`. Sessions stay in
+ * their own database (see @cline/shared `ensureSessionSchema`). cron_runs
+ * here absorb one-off, recurring, and event-driven work under one queue.
+ */
+
+export type CronRunStatus =
+	| "queued"
+	| "running"
+	| "done"
+	| "failed"
+	| "cancelled";
+
+export type CronRunTriggerKind =
+	| "one_off"
+	| "schedule"
+	| "event"
+	| "manual"
+	| "retry";
+
+export type CronParseStatus = "valid" | "invalid";
+
+export type CronEventProcessingStatus =
+	| "received"
+	| "unmatched"
+	| "queued"
+	| "suppressed"
+	| "failed";
+
+export interface CronSpecRecord {
+	specId: string;
+	externalId: string;
+	sourcePath: string;
+	triggerKind: CronTriggerKind;
+	sourceMtimeMs?: number;
+	sourceHash?: string;
+	parseStatus: CronParseStatus;
+	parseError?: string;
+	enabled: boolean;
+	removed: boolean;
+	title: string;
+	prompt?: string;
+	workspaceRoot?: string;
+	scheduleExpr?: string;
+	timezone?: string;
+	eventType?: string;
+	filters?: Record<string, unknown>;
+	debounceSeconds?: number;
+	dedupeWindowSeconds?: number;
+	cooldownSeconds?: number;
+	mode?: string;
+	systemPrompt?: string;
+	providerId?: string;
+	modelId?: string;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	maxParallel?: number;
+	tools?: string[];
+	notesDirectory?: string;
+	extensions?: CronSpecExtensionKind[];
+	source?: string;
+	tags?: string[];
+	metadata?: Record<string, unknown>;
+	revision: number;
+	lastMaterializedRunId?: string;
+	lastRunAt?: string;
+	nextRunAt?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface CronRunRecord {
+	runId: string;
+	specId: string;
+	specRevision: number;
+	triggerKind: CronRunTriggerKind;
+	status: CronRunStatus;
+	claimToken?: string;
+	claimStartedAt?: string;
+	claimUntilAt?: string;
+	scheduledFor?: string;
+	triggerEventId?: string;
+	startedAt?: string;
+	completedAt?: string;
+	sessionId?: string;
+	reportPath?: string;
+	error?: string;
+	attemptCount: number;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface CronEventLogRecord {
+	eventId: string;
+	eventType: string;
+	source: string;
+	subject?: string;
+	occurredAt: string;
+	receivedAt: string;
+	workspaceRoot?: string;
+	dedupeKey?: string;
+	payload?: Record<string, unknown>;
+	attributes?: Record<string, unknown>;
+	processingStatus: CronEventProcessingStatus;
+	matchedSpecCount: number;
+	queuedRunCount: number;
+	suppressedCount: number;
+	error?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface UpsertSpecInput {
+	externalId: string;
+	sourcePath: string;
+	triggerKind: CronTriggerKind;
+	sourceMtimeMs?: number;
+	sourceHash: string;
+	parseStatus: CronParseStatus;
+	parseError?: string;
+	spec?: CronSpec;
+}
+
+export interface UpsertSpecResult {
+	record: CronSpecRecord;
+	created: boolean;
+	revisionChanged: boolean;
+}
+
+export interface SqliteCronStoreOptions {
+	dbPath?: string;
+}
+
+function parseJsonRecord(
+	value: string | undefined,
+): Record<string, unknown> | undefined {
+	if (!value) return undefined;
+	try {
+		const parsed = JSON.parse(value) as unknown;
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as Record<string, unknown>;
+		}
+	} catch {
+		// ignore
+	}
+	return undefined;
+}
+
+function parseJsonArray(
+	value: string | undefined,
+	options: { preserveEmpty?: boolean } = {},
+): string[] | undefined {
+	if (!value) return undefined;
+	try {
+		const parsed = JSON.parse(value) as unknown;
+		if (!Array.isArray(parsed)) return undefined;
+		const tags = parsed
+			.map((item) => (typeof item === "string" ? item.trim() : ""))
+			.filter((item) => item.length > 0);
+		if (options.preserveEmpty) {
+			return tags;
+		}
+		return tags.length > 0 ? tags : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function toInt(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "bigint") return Number(value);
+	return undefined;
+}
+
+function specToRecord(row: Record<string, unknown>): CronSpecRecord {
+	return {
+		specId: asString(row.spec_id),
+		externalId: asString(row.external_id),
+		sourcePath: asString(row.source_path),
+		triggerKind: asString(row.trigger_kind) as CronTriggerKind,
+		sourceMtimeMs: toInt(row.source_mtime_ms),
+		sourceHash: asOptionalString(row.source_hash),
+		parseStatus: asString(row.parse_status) === "invalid" ? "invalid" : "valid",
+		parseError: asOptionalString(row.parse_error),
+		enabled: Number(row.enabled ?? 0) === 1,
+		removed: Number(row.removed ?? 0) === 1,
+		title: asString(row.title),
+		prompt: asOptionalString(row.prompt),
+		workspaceRoot: asOptionalString(row.workspace_root),
+		scheduleExpr: asOptionalString(row.schedule_expr),
+		timezone: asOptionalString(row.timezone),
+		eventType: asOptionalString(row.event_type),
+		filters: parseJsonRecord(asOptionalString(row.filters_json)),
+		debounceSeconds: toInt(row.debounce_seconds),
+		dedupeWindowSeconds: toInt(row.dedupe_window_seconds),
+		cooldownSeconds: toInt(row.cooldown_seconds),
+		mode: asOptionalString(row.mode),
+		systemPrompt: asOptionalString(row.system_prompt),
+		providerId: asOptionalString(row.provider_id),
+		modelId: asOptionalString(row.model_id),
+		maxIterations: toInt(row.max_iterations),
+		timeoutSeconds: toInt(row.timeout_seconds),
+		maxParallel: toInt(row.max_parallel),
+		tools: parseJsonArray(asOptionalString(row.tools_json), {
+			preserveEmpty: true,
+		}),
+		notesDirectory: asOptionalString(row.notes_directory),
+		extensions: parseJsonArray(asOptionalString(row.extensions_json), {
+			preserveEmpty: true,
+		}) as CronSpecExtensionKind[] | undefined,
+		source: asOptionalString(row.source),
+		tags: parseJsonArray(asOptionalString(row.tags_json)),
+		metadata: parseJsonRecord(asOptionalString(row.metadata_json)),
+		revision: Number(row.revision ?? 1),
+		lastMaterializedRunId: asOptionalString(row.last_materialized_run_id),
+		lastRunAt: asOptionalString(row.last_run_at),
+		nextRunAt: asOptionalString(row.next_run_at),
+		createdAt: asString(row.created_at),
+		updatedAt: asString(row.updated_at),
+	};
+}
+
+function runToRecord(row: Record<string, unknown>): CronRunRecord {
+	return {
+		runId: asString(row.run_id),
+		specId: asString(row.spec_id),
+		specRevision: Number(row.spec_revision ?? 1),
+		triggerKind: asString(row.trigger_kind) as CronRunTriggerKind,
+		status: asString(row.status) as CronRunStatus,
+		claimToken: asOptionalString(row.claim_token),
+		claimStartedAt: asOptionalString(row.claim_started_at),
+		claimUntilAt: asOptionalString(row.claim_until_at),
+		scheduledFor: asOptionalString(row.scheduled_for),
+		triggerEventId: asOptionalString(row.trigger_event_id),
+		startedAt: asOptionalString(row.started_at),
+		completedAt: asOptionalString(row.completed_at),
+		sessionId: asOptionalString(row.session_id),
+		reportPath: asOptionalString(row.report_path),
+		error: asOptionalString(row.error),
+		attemptCount: Number(row.attempt_count ?? 0),
+		createdAt: asString(row.created_at),
+		updatedAt: asString(row.updated_at),
+	};
+}
+
+function eventLogToRecord(row: Record<string, unknown>): CronEventLogRecord {
+	return {
+		eventId: asString(row.event_id),
+		eventType: asString(row.event_type),
+		source: asString(row.source),
+		subject: asOptionalString(row.subject),
+		occurredAt: asString(row.occurred_at),
+		receivedAt: asString(row.received_at),
+		workspaceRoot: asOptionalString(row.workspace_root),
+		dedupeKey: asOptionalString(row.dedupe_key),
+		payload: parseJsonRecord(asOptionalString(row.payload_json)),
+		attributes: parseJsonRecord(asOptionalString(row.attributes_json)),
+		processingStatus: asString(
+			row.processing_status,
+		) as CronEventProcessingStatus,
+		matchedSpecCount: Number(row.matched_spec_count ?? 0),
+		queuedRunCount: Number(row.queued_run_count ?? 0),
+		suppressedCount: Number(row.suppressed_count ?? 0),
+		error: asOptionalString(row.error),
+		createdAt: asString(row.created_at),
+		updatedAt: asString(row.updated_at),
+	};
+}
+
+function jsonOrNull(value: Record<string, unknown> | undefined): string | null {
+	return value ? JSON.stringify(value) : null;
+}
+
+const MEANINGFUL_FIELD_KEYS = [
+	"prompt",
+	"workspaceRoot",
+	"mode",
+	"systemPrompt",
+	"providerId",
+	"modelId",
+	"maxIterations",
+	"timeoutSeconds",
+	"maxParallel",
+	"tools",
+	"notesDirectory",
+	"extensions",
+	"source",
+	"scheduleExpr",
+	"timezone",
+	"eventType",
+	"filters",
+	"debounceSeconds",
+	"dedupeWindowSeconds",
+	"cooldownSeconds",
+] as const;
+
+function normalizeForCompare(value: unknown): unknown {
+	if (value === undefined) return null;
+	if (value && typeof value === "object") {
+		return JSON.stringify(value);
+	}
+	return value;
+}
+
+function hasMeaningfulChange(
+	prev: CronSpecRecord,
+	nextValues: Record<string, unknown>,
+	prevEnabled: boolean,
+	nextEnabled: boolean,
+): boolean {
+	for (const key of MEANINGFUL_FIELD_KEYS) {
+		const prevVal = (prev as unknown as Record<string, unknown>)[key];
+		const nextVal = nextValues[key];
+		if (normalizeForCompare(prevVal) !== normalizeForCompare(nextVal)) {
+			return true;
+		}
+	}
+	if (prevEnabled === false && nextEnabled === true) return true;
+	return false;
+}
+
+function filenameStemFromPath(sourcePath: string): string {
+	const base = sourcePath.split("/").pop() ?? sourcePath;
+	return base
+		.replace(/\.event\.md$/, "")
+		.replace(/\.cron\.md$/, "")
+		.replace(/\.md$/, "");
+}
+
+function hubScheduleSourcePath(scheduleId: string): string {
+	return `hub/schedules/${scheduleId}.cron.md`;
+}
+
+function hubScheduleMetadata(
+	input: HubScheduleCreateInput,
+): Record<string, unknown> | undefined {
+	const metadata = {
+		...(input.metadata ?? {}),
+		...(input.createdBy ? { __hubScheduleCreatedBy: input.createdBy } : {}),
+		...(input.cwd ? { __hubScheduleCwd: input.cwd } : {}),
+		...(input.runtimeOptions
+			? { __hubRuntimeOptions: input.runtimeOptions }
+			: {}),
+	};
+	return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+function hubScheduleInputToCronSpec(input: HubScheduleCreateInput): CronSpec {
+	return {
+		triggerKind: "schedule",
+		title: input.name.trim(),
+		prompt: input.prompt,
+		workspaceRoot: input.workspaceRoot.trim(),
+		schedule: input.cronPattern.trim(),
+		mode: input.mode ?? "act",
+		systemPrompt: input.systemPrompt,
+		modelSelection: input.modelSelection
+			? JSON.parse(JSON.stringify(input.modelSelection))
+			: undefined,
+		maxIterations:
+			typeof input.maxIterations === "number"
+				? Math.floor(input.maxIterations)
+				: undefined,
+		timeoutSeconds:
+			typeof input.timeoutSeconds === "number"
+				? Math.floor(input.timeoutSeconds)
+				: undefined,
+		maxParallel:
+			typeof input.maxParallel === "number"
+				? Math.max(1, Math.floor(input.maxParallel))
+				: 1,
+		source: "hub-schedule",
+		tags: input.tags?.filter((tag) => tag.trim().length > 0),
+		enabled: input.enabled !== false,
+		metadata: hubScheduleMetadata(input),
+	} as CronSpec;
+}
+
+function hubScheduleHash(input: HubScheduleCreateInput): string {
+	return JSON.stringify(hubScheduleInputToCronSpec(input));
+}
+
+function cronSpecRecordToHubScheduleInput(
+	current: CronSpecRecord,
+	updates: HubScheduleUpdateInput,
+): HubScheduleCreateInput {
+	const metadata = current.metadata ? { ...current.metadata } : {};
+	const createdBy =
+		updates.createdBy === null
+			? undefined
+			: updates.createdBy !== undefined
+				? updates.createdBy
+				: typeof metadata.__hubScheduleCreatedBy === "string"
+					? metadata.__hubScheduleCreatedBy
+					: undefined;
+	const cwd =
+		updates.cwd !== undefined
+			? updates.cwd
+			: typeof metadata.__hubScheduleCwd === "string"
+				? metadata.__hubScheduleCwd
+				: undefined;
+	const runtimeOptions =
+		updates.runtimeOptions !== undefined
+			? updates.runtimeOptions
+			: metadata.__hubRuntimeOptions &&
+					typeof metadata.__hubRuntimeOptions === "object" &&
+					!Array.isArray(metadata.__hubRuntimeOptions)
+				? (metadata.__hubRuntimeOptions as HubScheduleCreateInput["runtimeOptions"])
+				: undefined;
+	delete metadata.__hubScheduleCreatedBy;
+	delete metadata.__hubScheduleCwd;
+	delete metadata.__hubRuntimeOptions;
+	return {
+		name: updates.name ?? current.title,
+		cronPattern: updates.cronPattern ?? current.scheduleExpr ?? "",
+		prompt: updates.prompt ?? current.prompt ?? "",
+		workspaceRoot: updates.workspaceRoot ?? current.workspaceRoot ?? "",
+		cwd,
+		modelSelection:
+			updates.modelSelection !== undefined
+				? updates.modelSelection
+				: current.providerId || current.modelId
+					? {
+							providerId: current.providerId ?? "",
+							modelId: current.modelId ?? "",
+						}
+					: undefined,
+		enabled: updates.enabled ?? current.enabled,
+		mode:
+			updates.mode ??
+			(current.mode === "plan"
+				? "plan"
+				: current.mode === "yolo"
+					? "yolo"
+					: "act"),
+		systemPrompt:
+			updates.systemPrompt === null
+				? undefined
+				: updates.systemPrompt !== undefined
+					? updates.systemPrompt
+					: current.systemPrompt,
+		maxIterations:
+			updates.maxIterations === null
+				? undefined
+				: updates.maxIterations !== undefined
+					? updates.maxIterations
+					: current.maxIterations,
+		timeoutSeconds:
+			updates.timeoutSeconds === null
+				? undefined
+				: updates.timeoutSeconds !== undefined
+					? updates.timeoutSeconds
+					: current.timeoutSeconds,
+		maxParallel: updates.maxParallel ?? current.maxParallel ?? 1,
+		createdBy,
+		tags: updates.tags ?? current.tags,
+		runtimeOptions,
+		metadata:
+			updates.metadata !== undefined
+				? updates.metadata
+				: Object.keys(metadata).length > 0
+					? (metadata as HubScheduleCreateInput["metadata"])
+					: undefined,
+	};
+}
+
+export interface ListSpecsOptions {
+	triggerKind?: CronTriggerKind;
+	enabled?: boolean;
+	parseStatus?: CronParseStatus;
+	includeRemoved?: boolean;
+	limit?: number;
+}
+
+export interface ListRunsOptions {
+	specId?: string;
+	status?: CronRunStatus | CronRunStatus[];
+	limit?: number;
+}
+
+export interface ClaimRunOptions {
+	nowIso: string;
+	leaseMs: number;
+	limit?: number;
+}
+
+export interface ClaimedCronRun {
+	run: CronRunRecord;
+	claimToken: string;
+	claimUntilAt: string;
+}
+
+interface ClaimBoundUpdate {
+	runId: string;
+	claimToken: string;
+}
+
+export interface MaterializeScheduleRunResult {
+	queued: boolean;
+	run?: CronRunRecord;
+	nextRunAt?: string;
+}
+
+export interface EnqueueRunInput {
+	specId: string;
+	specRevision: number;
+	triggerKind: CronRunTriggerKind;
+	scheduledFor?: string;
+	triggerEventId?: string;
+}
+
+export interface InsertEventLogResult {
+	record: CronEventLogRecord;
+	created: boolean;
+}
+
+export interface ListEventLogsOptions {
+	eventType?: string;
+	source?: string;
+	processingStatus?: CronEventProcessingStatus;
+	limit?: number;
+}
+
+export class SqliteCronStore {
+	private readonly db: SqliteDb;
+
+	constructor(options: SqliteCronStoreOptions = {}) {
+		const path = options.dbPath ?? resolveCronDbPath();
+		this.db = loadSqliteDb(path);
+		ensureCronSchema(this.db);
+	}
+
+	public close(): void {
+		this.db.close?.();
+	}
+
+	public getSpecBySourcePath(sourcePath: string): CronSpecRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM cron_specs WHERE source_path = ?")
+			.get(sourcePath);
+		return row ? specToRecord(row) : undefined;
+	}
+
+	public getSpec(specId: string): CronSpecRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM cron_specs WHERE spec_id = ?")
+			.get(specId);
+		return row ? specToRecord(row) : undefined;
+	}
+
+	public getSpecByExternalId(externalId: string): CronSpecRecord | undefined {
+		const row = this.db
+			.prepare(
+				"SELECT * FROM cron_specs WHERE external_id = ? ORDER BY created_at ASC LIMIT 1",
+			)
+			.get(externalId);
+		return row ? specToRecord(row) : undefined;
+	}
+
+	public listSpecs(options: ListSpecsOptions = {}): CronSpecRecord[] {
+		const where: string[] = [];
+		const params: unknown[] = [];
+		if (options.triggerKind) {
+			where.push("trigger_kind = ?");
+			params.push(options.triggerKind);
+		}
+		if (typeof options.enabled === "boolean") {
+			where.push("enabled = ?");
+			params.push(options.enabled ? 1 : 0);
+		}
+		if (options.parseStatus) {
+			where.push("parse_status = ?");
+			params.push(options.parseStatus);
+		}
+		if (!options.includeRemoved) {
+			where.push("removed = 0");
+		}
+		const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+		const limit = Math.max(1, Math.floor(options.limit ?? 500));
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM cron_specs ${whereClause} ORDER BY created_at DESC LIMIT ?`,
+			)
+			.all(...params, limit);
+		return rows.map((row) => specToRecord(row));
+	}
+
+	public createHubSchedule(input: HubScheduleCreateInput): CronSpecRecord {
+		const scheduleId = `sched_${randomUUID()}`;
+		const result = this.upsertSpec({
+			externalId: scheduleId,
+			sourcePath: hubScheduleSourcePath(scheduleId),
+			triggerKind: "schedule",
+			sourceHash: hubScheduleHash(input),
+			parseStatus: "valid",
+			spec: hubScheduleInputToCronSpec(input),
+		});
+		this.initializeScheduleNextRun(result.record.specId);
+		const record = this.getSpec(result.record.specId);
+		if (!record) throw new Error("failed to create hub schedule");
+		return record;
+	}
+
+	public getHubSchedule(scheduleId: string): CronSpecRecord | undefined {
+		const row = this.db
+			.prepare(
+				`SELECT * FROM cron_specs
+					WHERE external_id = ? AND source = 'hub-schedule' AND removed = 0
+					ORDER BY created_at ASC LIMIT 1`,
+			)
+			.get(scheduleId);
+		return row ? specToRecord(row) : undefined;
+	}
+
+	public listHubSchedules(
+		options: { enabled?: boolean; limit?: number; tags?: string[] } = {},
+	): CronSpecRecord[] {
+		const where = [
+			"source = 'hub-schedule'",
+			"trigger_kind = 'schedule'",
+			"removed = 0",
+		];
+		const params: unknown[] = [];
+		if (typeof options.enabled === "boolean") {
+			where.push("enabled = ?");
+			params.push(options.enabled ? 1 : 0);
+		}
+		if (options.tags && options.tags.length > 0) {
+			for (const tag of options.tags) {
+				where.push("tags_json LIKE ?");
+				params.push(`%"${tag.trim()}"%`);
+			}
+		}
+		const limit = Math.max(1, Math.floor(options.limit ?? 200));
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM cron_specs
+					WHERE ${where.join(" AND ")}
+					ORDER BY created_at DESC LIMIT ?`,
+			)
+			.all(...params, limit);
+		return rows.map((row) => specToRecord(row));
+	}
+
+	public updateHubSchedule(
+		scheduleId: string,
+		updates: HubScheduleUpdateInput,
+	): CronSpecRecord | undefined {
+		const current = this.getHubSchedule(scheduleId);
+		if (!current) return undefined;
+		const input = cronSpecRecordToHubScheduleInput(current, updates);
+		const result = this.upsertSpec({
+			externalId: scheduleId,
+			sourcePath: current.sourcePath,
+			triggerKind: "schedule",
+			sourceHash: hubScheduleHash(input),
+			parseStatus: "valid",
+			spec: hubScheduleInputToCronSpec(input),
+		});
+		if (updates.cronPattern !== undefined || updates.enabled !== undefined) {
+			this.initializeScheduleNextRun(result.record.specId);
+		}
+		return this.getSpec(result.record.specId);
+	}
+
+	public deleteHubSchedule(scheduleId: string): boolean {
+		const spec = this.getHubSchedule(scheduleId);
+		if (!spec) return false;
+		this.markSpecRemoved(spec.specId);
+		this.cancelQueuedRunsForSpec(spec.specId);
+		return true;
+	}
+
+	public enqueueHubScheduleRun(
+		scheduleId: string,
+		triggerKind: "manual" | "retry" = "manual",
+	): CronRunRecord | undefined {
+		const spec = this.getHubSchedule(scheduleId);
+		if (
+			!spec ||
+			!spec.enabled ||
+			spec.removed ||
+			spec.parseStatus !== "valid"
+		) {
+			return undefined;
+		}
+		return this.enqueueRun({
+			specId: spec.specId,
+			specRevision: spec.revision,
+			triggerKind,
+			scheduledFor: nowIso(),
+		});
+	}
+
+	public listEventSpecsForType(eventType: string): CronSpecRecord[] {
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM cron_specs
+					WHERE trigger_kind = 'event'
+						AND event_type = ?
+						AND enabled = 1
+						AND removed = 0
+						AND parse_status = 'valid'
+					ORDER BY created_at ASC`,
+			)
+			.all(eventType);
+		return rows.map((row) => specToRecord(row));
+	}
+
+	public upsertSpec(input: UpsertSpecInput): UpsertSpecResult {
+		const now = nowIso();
+		const existing = this.getSpecBySourcePath(input.sourcePath);
+
+		const spec = input.spec;
+		const nextValues: Record<string, unknown> = {
+			title:
+				spec?.title ??
+				existing?.title ??
+				filenameStemFromPath(input.sourcePath),
+			prompt: spec?.prompt,
+			workspaceRoot: spec?.workspaceRoot,
+			scheduleExpr:
+				spec?.triggerKind === "schedule" ? spec.schedule : undefined,
+			timezone: spec?.triggerKind === "schedule" ? spec.timezone : undefined,
+			eventType: spec?.triggerKind === "event" ? spec.event : undefined,
+			filters: spec?.triggerKind === "event" ? spec.filters : undefined,
+			debounceSeconds:
+				spec?.triggerKind === "event" ? spec.debounceSeconds : undefined,
+			dedupeWindowSeconds:
+				spec?.triggerKind === "event" ? spec.dedupeWindowSeconds : undefined,
+			cooldownSeconds:
+				spec?.triggerKind === "event" ? spec.cooldownSeconds : undefined,
+			mode: spec?.mode,
+			systemPrompt: spec?.systemPrompt,
+			providerId: spec?.modelSelection?.providerId,
+			modelId: spec?.modelSelection?.modelId,
+			maxIterations: spec?.maxIterations,
+			timeoutSeconds: spec?.timeoutSeconds,
+			maxParallel:
+				spec && "maxParallel" in spec
+					? (spec.maxParallel as number | undefined)
+					: undefined,
+			tools: spec?.tools,
+			notesDirectory: spec?.notesDirectory,
+			extensions: spec?.extensions,
+			source: spec?.source,
+		};
+
+		const enabled = input.parseStatus === "valid" && (spec?.enabled ?? true);
+
+		if (!existing) {
+			const specId = `cspec_${randomUUID()}`;
+			this.insertSpecRow(specId, input, nextValues, enabled, now);
+			const record = this.getSpec(specId);
+			if (!record) throw new Error("failed to insert cron_spec row");
+			return { record, created: true, revisionChanged: true };
+		}
+
+		const hashChanged = existing.sourceHash !== input.sourceHash;
+		const revisionChanged =
+			hashChanged &&
+			hasMeaningfulChange(existing, nextValues, existing.enabled, enabled);
+		const revision = revisionChanged
+			? existing.revision + 1
+			: existing.revision;
+		this.updateSpecRow(
+			existing.specId,
+			input,
+			nextValues,
+			enabled,
+			revision,
+			now,
+		);
+		const record = this.getSpec(existing.specId);
+		if (!record) throw new Error("failed to reload cron_spec after update");
+		return { record, created: false, revisionChanged };
+	}
+
+	private insertSpecRow(
+		specId: string,
+		input: UpsertSpecInput,
+		v: Record<string, unknown>,
+		enabled: boolean,
+		now: string,
+	): void {
+		const spec = input.spec;
+		this.db
+			.prepare(
+				`INSERT INTO cron_specs (
+						spec_id, external_id, source_path, trigger_kind,
+						source_mtime_ms, source_hash, parse_status, parse_error,
+						enabled, removed, title, prompt, workspace_root,
+						schedule_expr, timezone, event_type, filters_json,
+						debounce_seconds, dedupe_window_seconds, cooldown_seconds,
+						mode, system_prompt, provider_id, model_id,
+						max_iterations, timeout_seconds, max_parallel,
+						tools_json, notes_directory, extensions_json, source,
+						tags_json, metadata_json, revision,
+						created_at, updated_at
+					) VALUES (${Array.from({ length: 36 }, () => "?").join(",")})`,
+			)
+			.run(
+				specId,
+				input.externalId,
+				input.sourcePath,
+				input.triggerKind,
+				input.sourceMtimeMs ?? null,
+				input.sourceHash,
+				input.parseStatus,
+				input.parseError ?? null,
+				enabled ? 1 : 0,
+				0,
+				(v.title as string) ?? "",
+				(v.prompt as string | undefined) ?? null,
+				(v.workspaceRoot as string | undefined) ?? null,
+				(v.scheduleExpr as string | undefined) ?? null,
+				(v.timezone as string | undefined) ?? null,
+				(v.eventType as string | undefined) ?? null,
+				v.filters ? JSON.stringify(v.filters) : null,
+				(v.debounceSeconds as number | undefined) ?? null,
+				(v.dedupeWindowSeconds as number | undefined) ?? null,
+				(v.cooldownSeconds as number | undefined) ?? null,
+				(v.mode as string | undefined) ?? null,
+				(v.systemPrompt as string | undefined) ?? null,
+				(v.providerId as string | undefined) ?? null,
+				(v.modelId as string | undefined) ?? null,
+				(v.maxIterations as number | undefined) ?? null,
+				(v.timeoutSeconds as number | undefined) ?? null,
+				(v.maxParallel as number | undefined) ?? null,
+				v.tools ? JSON.stringify(v.tools) : null,
+				(v.notesDirectory as string | undefined) ?? null,
+				v.extensions ? JSON.stringify(v.extensions) : null,
+				(v.source as string | undefined) ?? null,
+				spec?.tags ? JSON.stringify(spec.tags) : null,
+				spec?.metadata ? JSON.stringify(spec.metadata) : null,
+				1,
+				now,
+				now,
+			);
+	}
+
+	private updateSpecRow(
+		specId: string,
+		input: UpsertSpecInput,
+		v: Record<string, unknown>,
+		enabled: boolean,
+		revision: number,
+		now: string,
+	): void {
+		const spec = input.spec;
+		this.db
+			.prepare(
+				`UPDATE cron_specs SET
+						external_id = ?, trigger_kind = ?,
+						source_mtime_ms = ?, source_hash = ?, parse_status = ?, parse_error = ?,
+						enabled = ?, removed = 0, title = ?, prompt = ?,
+						workspace_root = ?, schedule_expr = ?, timezone = ?,
+						event_type = ?, filters_json = ?,
+						debounce_seconds = ?, dedupe_window_seconds = ?, cooldown_seconds = ?,
+						mode = ?, system_prompt = ?, provider_id = ?, model_id = ?,
+						max_iterations = ?, timeout_seconds = ?, max_parallel = ?,
+						tools_json = ?, notes_directory = ?, extensions_json = ?, source = ?,
+						tags_json = ?, metadata_json = ?,
+						revision = ?, updated_at = ?
+				WHERE spec_id = ?`,
+			)
+			.run(
+				input.externalId,
+				input.triggerKind,
+				input.sourceMtimeMs ?? null,
+				input.sourceHash,
+				input.parseStatus,
+				input.parseError ?? null,
+				enabled ? 1 : 0,
+				(v.title as string) ?? "",
+				(v.prompt as string | undefined) ?? null,
+				(v.workspaceRoot as string | undefined) ?? null,
+				(v.scheduleExpr as string | undefined) ?? null,
+				(v.timezone as string | undefined) ?? null,
+				(v.eventType as string | undefined) ?? null,
+				v.filters ? JSON.stringify(v.filters) : null,
+				(v.debounceSeconds as number | undefined) ?? null,
+				(v.dedupeWindowSeconds as number | undefined) ?? null,
+				(v.cooldownSeconds as number | undefined) ?? null,
+				(v.mode as string | undefined) ?? null,
+				(v.systemPrompt as string | undefined) ?? null,
+				(v.providerId as string | undefined) ?? null,
+				(v.modelId as string | undefined) ?? null,
+				(v.maxIterations as number | undefined) ?? null,
+				(v.timeoutSeconds as number | undefined) ?? null,
+				(v.maxParallel as number | undefined) ?? null,
+				v.tools ? JSON.stringify(v.tools) : null,
+				(v.notesDirectory as string | undefined) ?? null,
+				v.extensions ? JSON.stringify(v.extensions) : null,
+				(v.source as string | undefined) ?? null,
+				spec?.tags ? JSON.stringify(spec.tags) : null,
+				spec?.metadata ? JSON.stringify(spec.metadata) : null,
+				revision,
+				now,
+				specId,
+			);
+	}
+
+	public markSpecRemoved(specId: string): void {
+		this.db
+			.prepare(
+				`UPDATE cron_specs SET removed = 1, enabled = 0, updated_at = ? WHERE spec_id = ?`,
+			)
+			.run(nowIso(), specId);
+	}
+
+	public updateSpecNextRunAt(
+		specId: string,
+		nextRunAt: string | undefined,
+	): void {
+		this.db
+			.prepare(
+				`UPDATE cron_specs SET next_run_at = ?, updated_at = ? WHERE spec_id = ?`,
+			)
+			.run(nextRunAt ?? null, nowIso(), specId);
+	}
+
+	public updateSpecLastRunAt(specId: string, lastRunAt: string): void {
+		this.db
+			.prepare(
+				`UPDATE cron_specs SET last_run_at = ?, updated_at = ? WHERE spec_id = ?`,
+			)
+			.run(lastRunAt, nowIso(), specId);
+	}
+
+	public updateLastMaterializedRunId(specId: string, runId: string): void {
+		this.db
+			.prepare(
+				`UPDATE cron_specs SET last_materialized_run_id = ?, updated_at = ? WHERE spec_id = ?`,
+			)
+			.run(runId, nowIso(), specId);
+	}
+
+	private initializeScheduleNextRun(specId: string): void {
+		const spec = this.getSpec(specId);
+		if (
+			!spec ||
+			spec.triggerKind !== "schedule" ||
+			!spec.enabled ||
+			!spec.scheduleExpr
+		) {
+			this.updateSpecNextRunAt(specId, undefined);
+			return;
+		}
+		const nextRunAt = new Date(
+			getNextCronTime(spec.scheduleExpr, Date.now(), spec.timezone),
+		).toISOString();
+		this.updateSpecNextRunAt(specId, nextRunAt);
+	}
+
+	public materializeDueScheduleRun(options: {
+		specId: string;
+		nowMs: number;
+	}): MaterializeScheduleRunResult {
+		const nowMs = options.nowMs;
+		const now = new Date(nowMs).toISOString();
+		this.db.exec("BEGIN IMMEDIATE;");
+		try {
+			const row = this.db
+				.prepare("SELECT * FROM cron_specs WHERE spec_id = ?")
+				.get(options.specId);
+			if (!row) {
+				this.db.exec("COMMIT;");
+				return { queued: false };
+			}
+			const spec = specToRecord(row);
+			if (
+				spec.triggerKind !== "schedule" ||
+				!spec.enabled ||
+				spec.removed ||
+				spec.parseStatus !== "valid" ||
+				!spec.scheduleExpr
+			) {
+				this.db.exec("COMMIT;");
+				return { queued: false };
+			}
+
+			const dueAt = spec.nextRunAt;
+			if (!dueAt) {
+				const initializedNext = new Date(
+					getNextCronTime(spec.scheduleExpr, nowMs, spec.timezone),
+				).toISOString();
+				this.db
+					.prepare(
+						`UPDATE cron_specs SET next_run_at = ?, updated_at = ? WHERE spec_id = ?`,
+					)
+					.run(initializedNext, now, spec.specId);
+				this.db.exec("COMMIT;");
+				return { queued: false, nextRunAt: initializedNext };
+			}
+
+			if (new Date(dueAt).getTime() > nowMs) {
+				this.db.exec("COMMIT;");
+				return { queued: false, nextRunAt: dueAt };
+			}
+
+			const runId = `crun_${randomUUID()}`;
+			let nextRunAt: string | undefined;
+			try {
+				nextRunAt = new Date(
+					getNextCronTime(spec.scheduleExpr, nowMs, spec.timezone),
+				).toISOString();
+			} catch {
+				nextRunAt = undefined;
+			}
+
+			this.db
+				.prepare(
+					`INSERT INTO cron_runs (
+						run_id, spec_id, spec_revision, trigger_kind, status,
+						scheduled_for, trigger_event_id, attempt_count,
+						created_at, updated_at
+					) VALUES (?,?,?,?,?, ?,?,?, ?,?)`,
+				)
+				.run(
+					runId,
+					spec.specId,
+					spec.revision,
+					"schedule",
+					"queued",
+					dueAt,
+					null,
+					0,
+					now,
+					now,
+				);
+			this.db
+				.prepare(
+					`UPDATE cron_specs SET
+						last_materialized_run_id = ?,
+						last_run_at = ?,
+						next_run_at = ?,
+						updated_at = ?
+					WHERE spec_id = ?`,
+				)
+				.run(runId, now, nextRunAt ?? null, now, spec.specId);
+			this.db.exec("COMMIT;");
+			return {
+				queued: true,
+				run: this.getRun(runId),
+				nextRunAt,
+			};
+		} catch (err) {
+			this.db.exec("ROLLBACK;");
+			throw err;
+		}
+	}
+
+	public getRun(runId: string): CronRunRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM cron_runs WHERE run_id = ?")
+			.get(runId);
+		return row ? runToRecord(row) : undefined;
+	}
+
+	public insertEventLog(
+		event: AutomationEventEnvelope,
+		options: { receivedAtIso?: string } = {},
+	): InsertEventLogResult {
+		const now = nowIso();
+		const receivedAt = options.receivedAtIso ?? now;
+		const eventId = event.eventId.trim();
+		if (!eventId) {
+			throw new Error("automation event requires eventId");
+		}
+		const eventType = event.eventType.trim();
+		if (!eventType) {
+			throw new Error("automation event requires eventType");
+		}
+		const source = event.source.trim();
+		if (!source) {
+			throw new Error("automation event requires source");
+		}
+		const occurredAt = event.occurredAt.trim() || receivedAt;
+		const changes =
+			this.db
+				.prepare(
+					`INSERT OR IGNORE INTO cron_event_log (
+						event_id, event_type, source, subject,
+						occurred_at, received_at, workspace_root, dedupe_key,
+						payload_json, attributes_json, processing_status,
+						matched_spec_count, queued_run_count, suppressed_count,
+						error, created_at, updated_at
+					) VALUES (?,?,?,?, ?,?,?,?, ?,?,?, ?,?,?, ?,?,?)`,
+				)
+				.run(
+					eventId,
+					eventType,
+					source,
+					event.subject?.trim() || null,
+					occurredAt,
+					receivedAt,
+					event.workspaceRoot?.trim() || null,
+					event.dedupeKey?.trim() || null,
+					jsonOrNull(event.payload),
+					jsonOrNull(event.attributes),
+					"received",
+					0,
+					0,
+					0,
+					null,
+					now,
+					now,
+				).changes ?? 0;
+		const record = this.getEventLog(eventId);
+		if (!record) throw new Error("failed to insert cron_event_log row");
+		return { record, created: changes === 1 };
+	}
+
+	public getEventLog(eventId: string): CronEventLogRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM cron_event_log WHERE event_id = ?")
+			.get(eventId);
+		return row ? eventLogToRecord(row) : undefined;
+	}
+
+	public listEventLogs(
+		options: ListEventLogsOptions = {},
+	): CronEventLogRecord[] {
+		const where: string[] = [];
+		const params: unknown[] = [];
+		if (options.eventType) {
+			where.push("event_type = ?");
+			params.push(options.eventType);
+		}
+		if (options.source) {
+			where.push("source = ?");
+			params.push(options.source);
+		}
+		if (options.processingStatus) {
+			where.push("processing_status = ?");
+			params.push(options.processingStatus);
+		}
+		const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+		const limit = Math.max(1, Math.floor(options.limit ?? 200));
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM cron_event_log ${whereClause}
+					ORDER BY received_at DESC, created_at DESC
+					LIMIT ?`,
+			)
+			.all(...params, limit);
+		return rows.map((row) => eventLogToRecord(row));
+	}
+
+	public updateEventLogProcessing(
+		eventId: string,
+		update: {
+			status: CronEventProcessingStatus;
+			matchedSpecCount?: number;
+			queuedRunCount?: number;
+			suppressedCount?: number;
+			error?: string;
+		},
+	): boolean {
+		const changes =
+			this.db
+				.prepare(
+					`UPDATE cron_event_log SET
+						processing_status = ?,
+						matched_spec_count = COALESCE(?, matched_spec_count),
+						queued_run_count = COALESCE(?, queued_run_count),
+						suppressed_count = COALESCE(?, suppressed_count),
+						error = ?,
+						updated_at = ?
+					WHERE event_id = ?`,
+				)
+				.run(
+					update.status,
+					update.matchedSpecCount ?? null,
+					update.queuedRunCount ?? null,
+					update.suppressedCount ?? null,
+					update.error ?? null,
+					nowIso(),
+					eventId,
+				).changes ?? 0;
+		return changes === 1;
+	}
+
+	public listRuns(options: ListRunsOptions = {}): CronRunRecord[] {
+		const where: string[] = [];
+		const params: unknown[] = [];
+		if (options.specId) {
+			where.push("spec_id = ?");
+			params.push(options.specId);
+		}
+		if (options.status) {
+			const statuses = Array.isArray(options.status)
+				? options.status
+				: [options.status];
+			if (statuses.length > 0) {
+				const placeholders = statuses.map(() => "?").join(",");
+				where.push(`status IN (${placeholders})`);
+				for (const s of statuses) params.push(s);
+			}
+		}
+		const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+		const limit = Math.max(1, Math.floor(options.limit ?? 200));
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM cron_runs ${whereClause} ORDER BY created_at DESC LIMIT ?`,
+			)
+			.all(...params, limit);
+		return rows.map((row) => runToRecord(row));
+	}
+
+	public hasRecentEventRunForDedupe(options: {
+		specId: string;
+		dedupeKey: string;
+		sinceIso: string;
+	}): boolean {
+		const row = this.db
+			.prepare(
+				`SELECT r.run_id FROM cron_runs r
+					INNER JOIN cron_event_log e ON e.event_id = r.trigger_event_id
+					WHERE r.spec_id = ?
+						AND r.trigger_kind = 'event'
+						AND e.dedupe_key = ?
+						AND e.received_at >= ?
+					LIMIT 1`,
+			)
+			.get(options.specId, options.dedupeKey, options.sinceIso);
+		return !!row;
+	}
+
+	public hasRecentEventRunForSpec(options: {
+		specId: string;
+		sinceIso: string;
+	}): boolean {
+		const row = this.db
+			.prepare(
+				`SELECT r.run_id FROM cron_runs r
+					INNER JOIN cron_event_log e ON e.event_id = r.trigger_event_id
+					WHERE r.spec_id = ?
+						AND r.trigger_kind = 'event'
+						AND e.received_at >= ?
+					LIMIT 1`,
+			)
+			.get(options.specId, options.sinceIso);
+		return !!row;
+	}
+
+	public findQueuedEventRunForDedupe(options: {
+		specId: string;
+		dedupeKey: string;
+	}): CronRunRecord | undefined {
+		const row = this.db
+			.prepare(
+				`SELECT r.* FROM cron_runs r
+					INNER JOIN cron_event_log e ON e.event_id = r.trigger_event_id
+					WHERE r.spec_id = ?
+						AND r.trigger_kind = 'event'
+						AND r.status = 'queued'
+						AND e.dedupe_key = ?
+					ORDER BY COALESCE(r.scheduled_for, r.created_at) DESC
+					LIMIT 1`,
+			)
+			.get(options.specId, options.dedupeKey);
+		return row ? runToRecord(row) : undefined;
+	}
+
+	public updateQueuedEventRunForDebounce(options: {
+		runId: string;
+		triggerEventId: string;
+		scheduledFor: string;
+	}): CronRunRecord | undefined {
+		const updatedAt = nowIso();
+		const changes =
+			this.db
+				.prepare(
+					`UPDATE cron_runs SET
+						trigger_event_id = ?,
+						scheduled_for = ?,
+						updated_at = ?
+					WHERE run_id = ?
+						AND trigger_kind = 'event'
+						AND status = 'queued'`,
+				)
+				.run(
+					options.triggerEventId,
+					options.scheduledFor,
+					updatedAt,
+					options.runId,
+				).changes ?? 0;
+		if (changes !== 1) return undefined;
+		return this.getRun(options.runId);
+	}
+
+	public hasOneOffRunForRevision(specId: string, revision: number): boolean {
+		const row = this.db
+			.prepare(
+				`SELECT run_id FROM cron_runs
+					WHERE spec_id = ? AND spec_revision = ?
+						AND trigger_kind = 'one_off'
+					LIMIT 1`,
+			)
+			.get(specId, revision);
+		return !!row;
+	}
+
+	public enqueueRun(input: EnqueueRunInput): CronRunRecord {
+		const runId = `crun_${randomUUID()}`;
+		const now = nowIso();
+		this.db
+			.prepare(
+				`INSERT INTO cron_runs (
+					run_id, spec_id, spec_revision, trigger_kind, status,
+					scheduled_for, trigger_event_id, attempt_count,
+					created_at, updated_at
+				) VALUES (?,?,?,?,?, ?,?,?, ?,?)`,
+			)
+			.run(
+				runId,
+				input.specId,
+				input.specRevision,
+				input.triggerKind,
+				"queued",
+				input.scheduledFor ?? null,
+				input.triggerEventId ?? null,
+				0,
+				now,
+				now,
+			);
+		this.updateLastMaterializedRunId(input.specId, runId);
+		const run = this.getRun(runId);
+		if (!run) throw new Error("failed to insert cron_run row");
+		return run;
+	}
+
+	public cancelQueuedRunsForSpec(specId: string): number {
+		const changes =
+			this.db
+				.prepare(
+					`UPDATE cron_runs SET status = 'cancelled', updated_at = ?
+						WHERE spec_id = ? AND status = 'queued'`,
+				)
+				.run(nowIso(), specId).changes ?? 0;
+		return changes;
+	}
+
+	public claimDueRuns(options: ClaimRunOptions): ClaimedCronRun[] {
+		const referenceIso = options.nowIso;
+		const boundedLease = Math.max(1_000, Math.floor(options.leaseMs));
+		const leaseUntilIso = new Date(
+			new Date(referenceIso).getTime() + boundedLease,
+		).toISOString();
+		const limit = Math.max(1, Math.floor(options.limit ?? 25));
+		const claimed: ClaimedCronRun[] = [];
+		this.db.exec("BEGIN IMMEDIATE;");
+		try {
+			const rows = this.db
+				.prepare(
+					`SELECT * FROM cron_runs
+						WHERE (
+								status = 'queued'
+								OR (
+									status = 'running'
+									AND claim_until_at IS NOT NULL
+									AND claim_until_at <= ?
+									AND completed_at IS NULL
+								)
+							)
+							AND (scheduled_for IS NULL OR scheduled_for <= ?)
+						ORDER BY COALESCE(scheduled_for, created_at) ASC
+						LIMIT ?`,
+				)
+				.all(referenceIso, referenceIso, limit);
+			for (const row of rows) {
+				const runId = asString(row.run_id);
+				if (!runId) continue;
+				const claimToken = `cclaim_${randomUUID()}`;
+				const changes =
+					this.db
+						.prepare(
+							`UPDATE cron_runs SET
+								status = 'running',
+								claim_token = ?,
+								claim_started_at = ?,
+								claim_until_at = ?,
+								started_at = ?,
+								completed_at = NULL,
+								session_id = NULL,
+								report_path = NULL,
+								error = NULL,
+								attempt_count = attempt_count + 1,
+								updated_at = ?
+							WHERE run_id = ?
+								AND (
+									status = 'queued'
+									OR (
+										status = 'running'
+										AND claim_until_at IS NOT NULL
+										AND claim_until_at <= ?
+										AND completed_at IS NULL
+									)
+								)`,
+						)
+						.run(
+							claimToken,
+							referenceIso,
+							leaseUntilIso,
+							referenceIso,
+							referenceIso,
+							runId,
+							referenceIso,
+						).changes ?? 0;
+				if (changes !== 1) continue;
+				const run = this.getRun(runId);
+				if (!run) continue;
+				claimed.push({ run, claimToken, claimUntilAt: leaseUntilIso });
+			}
+			this.db.exec("COMMIT;");
+		} catch (err) {
+			this.db.exec("ROLLBACK;");
+			throw err;
+		}
+		return claimed;
+	}
+
+	public renewClaim(
+		runId: string,
+		claimToken: string,
+		leaseUntilAt: string,
+	): boolean {
+		const changes =
+			this.db
+				.prepare(
+					`UPDATE cron_runs SET claim_until_at = ?, updated_at = ?
+						WHERE run_id = ? AND claim_token = ?`,
+				)
+				.run(leaseUntilAt, nowIso(), runId, claimToken).changes ?? 0;
+		return changes === 1;
+	}
+
+	public completeRun(
+		runId: string,
+		update: {
+			status: "done" | "failed" | "cancelled";
+			sessionId?: string;
+			reportPath?: string;
+			error?: string;
+			completedAtIso?: string;
+			claimToken?: string;
+		},
+	): boolean {
+		const completedAt = update.completedAtIso ?? nowIso();
+		const whereClause = update.claimToken
+			? "WHERE run_id = ? AND claim_token = ?"
+			: "WHERE run_id = ?";
+		const changes =
+			this.db
+				.prepare(
+					`UPDATE cron_runs SET
+						status = ?,
+						session_id = COALESCE(?, session_id),
+						report_path = COALESCE(?, report_path),
+						error = ?,
+						completed_at = ?,
+						claim_started_at = NULL,
+						claim_token = NULL,
+						claim_until_at = NULL,
+						updated_at = ?
+					${whereClause}`,
+				)
+				.run(
+					update.status,
+					update.sessionId ?? null,
+					update.reportPath ?? null,
+					update.error ?? null,
+					completedAt,
+					completedAt,
+					runId,
+					...(update.claimToken ? [update.claimToken] : []),
+				).changes ?? 0;
+		return changes > 0;
+	}
+
+	public requeueRun(
+		update: ClaimBoundUpdate & {
+			error?: string;
+			scheduledFor?: string;
+		},
+	): boolean {
+		const updatedAt = nowIso();
+		const changes =
+			this.db
+				.prepare(
+					`UPDATE cron_runs SET
+						status = 'queued',
+						claim_started_at = NULL,
+						claim_token = NULL,
+						claim_until_at = NULL,
+						started_at = NULL,
+						completed_at = NULL,
+						session_id = NULL,
+						report_path = NULL,
+						error = ?,
+						scheduled_for = COALESCE(?, scheduled_for),
+						updated_at = ?
+					WHERE run_id = ? AND claim_token = ?`,
+				)
+				.run(
+					update.error ?? null,
+					update.scheduledFor ?? null,
+					updatedAt,
+					update.runId,
+					update.claimToken,
+				).changes ?? 0;
+		return changes > 0;
+	}
+
+	public attachSessionIdToRun(runId: string, sessionId: string): void {
+		this.db
+			.prepare(
+				`UPDATE cron_runs SET session_id = ?, updated_at = ? WHERE run_id = ?`,
+			)
+			.run(sessionId, nowIso(), runId);
+	}
+
+	public attachReportPathToRun(runId: string, reportPath: string): void {
+		this.db
+			.prepare(
+				`UPDATE cron_runs SET report_path = ?, updated_at = ? WHERE run_id = ?`,
+			)
+			.run(reportPath, nowIso(), runId);
+	}
+}
diff --git a/sdk/packages/core/src/extensions/config/index.ts b/sdk/packages/core/src/extensions/config/index.ts
new file mode 100644
index 0000000..543a091
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/index.ts
@@ -0,0 +1,46 @@
+export type {
+	AvailableRuntimeCommand,
+	RuntimeCommandKind,
+} from "./runtime-commands";
+// Skill frontmatter mutation is intentionally not exported from this barrel.
+export type {
+	UnifiedConfigDefinition,
+	UnifiedConfigFileCandidate,
+	UnifiedConfigFileContext,
+	UnifiedConfigRecord,
+	UnifiedConfigWatcherEvent,
+	UnifiedConfigWatcherOptions,
+} from "./unified-config-file-watcher";
+export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
+export type {
+	CreateInstructionWatcherOptions,
+	CreateRulesConfigDefinitionOptions,
+	CreateSkillsConfigDefinitionOptions,
+	CreateWorkflowsConfigDefinitionOptions,
+	ParseMarkdownFrontmatterResult,
+	RuleConfig,
+	SkillConfig,
+	UserInstructionConfig,
+	UserInstructionConfigType,
+	WorkflowConfig,
+} from "./user-instruction-config-loader";
+export {
+	createRulesConfigDefinition,
+	createSkillsConfigDefinition,
+	createWorkflowsConfigDefinition,
+	parseRuleConfigFromMarkdown,
+	parseSkillConfigFromMarkdown,
+	parseWorkflowConfigFromMarkdown,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveRulesConfigSearchPaths,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "./user-instruction-config-loader";
+export type {
+	CreateUserInstructionConfigServiceOptions,
+	UserInstructionConfigRecord,
+	UserInstructionConfigService,
+} from "./user-instruction-service";
+export { createUserInstructionConfigService } from "./user-instruction-service";
diff --git a/sdk/packages/core/src/extensions/config/runtime-commands.test.ts b/sdk/packages/core/src/extensions/config/runtime-commands.test.ts
new file mode 100644
index 0000000..83a6fa1
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/runtime-commands.test.ts
@@ -0,0 +1,185 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./runtime-commands";
+import { toggleSkillFrontmatter } from "./skill-frontmatter-toggle";
+import { createUserInstructionConfigWatcher } from "./user-instruction-config-loader";
+
+describe("runtime command registry", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("lists workflow and skill commands together", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "debug");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(skillDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use the debugging skill.");
+		await writeFile(
+			join(workflowsDir, "release.md"),
+			`---
+name: release
+---
+Run the release workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.refreshAll();
+			expect(listAvailableRuntimeCommandsFromWatcher(watcher)).toEqual([
+				{
+					id: "debug",
+					name: "debug",
+					description: "Use the debugging skill.",
+					instructions: "Use the debugging skill.",
+					kind: "skill",
+				},
+				{
+					id: "release",
+					name: "release",
+					description: undefined,
+					instructions: "Run the release workflow.",
+					kind: "workflow",
+				},
+			]);
+		} finally {
+			watcher.stop();
+		}
+	});
+
+	it("expands slash commands with workflow precedence and ignores disabled entries", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "ship");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(skillDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use the ship skill.");
+		await writeFile(
+			join(workflowsDir, "ship.md"),
+			`---
+name: ship
+---
+Run the ship workflow.`,
+		);
+		await writeFile(
+			join(workflowsDir, "disabled.md"),
+			`---
+name: disabled
+disabled: true
+---
+Do not run this workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.refreshAll();
+			expect(resolveRuntimeSlashCommandFromWatcher("/ship", watcher)).toBe(
+				"Run the ship workflow.",
+			);
+			expect(resolveRuntimeSlashCommandFromWatcher("/ship now", watcher)).toBe(
+				"Run the ship workflow. now",
+			);
+			expect(resolveRuntimeSlashCommandFromWatcher("/disabled", watcher)).toBe(
+				"/disabled",
+			);
+			expect(resolveRuntimeSlashCommandFromWatcher("/missing", watcher)).toBe(
+				"/missing",
+			);
+			expect(
+				resolveRuntimeSlashCommandFromWatcher("please run /ship", watcher),
+			).toBe("please run /ship");
+		} finally {
+			watcher.stop();
+		}
+	});
+
+	it("leaves workflow display description blank when no description is set", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(
+			join(workflowsDir, "review.md"),
+			`# Review Current Branch
+
+Review the current branch and summarize findings.
+`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.refreshAll();
+			expect(listAvailableRuntimeCommandsFromWatcher(watcher)).toEqual([
+				{
+					id: "review",
+					name: "review",
+					description: undefined,
+					instructions:
+						"# Review Current Branch\n\nReview the current branch and summarize findings.",
+					kind: "workflow",
+				},
+			]);
+		} finally {
+			watcher.stop();
+		}
+	});
+
+	it("reflects skill frontmatter toggles after watcher refresh", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "review");
+		await mkdir(skillDir, { recursive: true });
+		const skillPath = join(skillDir, "SKILL.md");
+		await writeFile(skillPath, "Use the review skill.");
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [] },
+		});
+
+		try {
+			await watcher.refreshAll();
+			expect(resolveRuntimeSlashCommandFromWatcher("/review", watcher)).toBe(
+				"Use the review skill.",
+			);
+
+			await toggleSkillFrontmatter({ filePath: skillPath, enabled: false });
+			await watcher.refreshType("skill");
+
+			expect(resolveRuntimeSlashCommandFromWatcher("/review", watcher)).toBe(
+				"/review",
+			);
+		} finally {
+			watcher.stop();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/config/runtime-commands.ts b/sdk/packages/core/src/extensions/config/runtime-commands.ts
new file mode 100644
index 0000000..8ed8538
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/runtime-commands.ts
@@ -0,0 +1,92 @@
+import { truncateSplit } from "@cline/shared";
+import type {
+	SkillConfig,
+	UserInstructionConfigWatcher,
+	WorkflowConfig,
+} from "./user-instruction-config-loader";
+
+export type RuntimeCommandKind = "skill" | "workflow";
+
+export type AvailableRuntimeCommand = {
+	id: string;
+	name: string;
+	instructions: string;
+	description?: string;
+	kind: RuntimeCommandKind;
+};
+
+type CommandRecord = {
+	item: SkillConfig | WorkflowConfig;
+};
+
+function resolveCommandDescription(
+	item: SkillConfig | WorkflowConfig,
+	kind: RuntimeCommandKind,
+): string | undefined {
+	if (item.description?.trim()) {
+		return truncateSplit(item.description, ".");
+	}
+	if (kind === "workflow") {
+		return undefined;
+	}
+	return truncateSplit(item.instructions, ".");
+}
+
+function isCommandEnabled(command: SkillConfig | WorkflowConfig): boolean {
+	return command.disabled !== true;
+}
+
+function listCommandsForKind(
+	watcher: UserInstructionConfigWatcher,
+	kind: RuntimeCommandKind,
+): AvailableRuntimeCommand[] {
+	return [...watcher.getSnapshot(kind).entries()]
+		.map(([id, record]) => ({ id, record: record as CommandRecord }))
+		.filter(({ record }) => isCommandEnabled(record.item))
+		.map(({ id, record }) => ({
+			id,
+			name: record.item.name,
+			instructions: record.item.instructions,
+			description: resolveCommandDescription(record.item, kind),
+			kind,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function listAvailableRuntimeCommandsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): AvailableRuntimeCommand[] {
+	const byName = new Map<string, AvailableRuntimeCommand>();
+	for (const command of [
+		...listCommandsForKind(watcher, "workflow"),
+		...listCommandsForKind(watcher, "skill"),
+	]) {
+		if (!byName.has(command.name)) {
+			byName.set(command.name, command);
+		}
+	}
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function resolveRuntimeSlashCommandFromWatcher(
+	input: string,
+	watcher: UserInstructionConfigWatcher,
+): string {
+	if (!input.startsWith("/") || input.length < 2) {
+		return input;
+	}
+	const match = input.match(/^\/(\S+)/);
+	if (!match) {
+		return input;
+	}
+	const name = match[1];
+	if (!name) {
+		return input;
+	}
+	const commandLength = name.length + 1;
+	const remainder = input.slice(commandLength);
+	const matched = listAvailableRuntimeCommandsFromWatcher(watcher).find(
+		(command) => command.name === name,
+	);
+	return matched ? `${matched.instructions}${remainder}` : input;
+}
diff --git a/sdk/packages/core/src/extensions/config/skill-frontmatter-toggle.test.ts b/sdk/packages/core/src/extensions/config/skill-frontmatter-toggle.test.ts
new file mode 100644
index 0000000..02818ec
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/skill-frontmatter-toggle.test.ts
@@ -0,0 +1,109 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	toggleSkillFrontmatter,
+	updateSkillMarkdownEnabledState,
+} from "./skill-frontmatter-toggle";
+import { parseSkillConfigFromMarkdown } from "./user-instruction-config-loader";
+
+describe("skill frontmatter toggle", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("disables an enabled skill with existing frontmatter", () => {
+		const content = `---
+name: code-review
+description: Review code carefully
+---
+First line.
+
+Second line.`;
+
+		const updated = updateSkillMarkdownEnabledState(content, false);
+		const parsed = parseSkillConfigFromMarkdown(updated, "fallback");
+
+		expect(parsed.disabled).toBe(true);
+		expect(parsed.frontmatter.name).toBe("code-review");
+		expect(parsed.frontmatter.description).toBe("Review code carefully");
+		expect(updated.endsWith("First line.\n\nSecond line.")).toBe(true);
+	});
+
+	it("enables a disabled skill", () => {
+		const content = `---
+name: code-review
+disabled: true
+---
+Use the review checklist.`;
+
+		const updated = updateSkillMarkdownEnabledState(content, true);
+		const parsed = parseSkillConfigFromMarkdown(updated, "fallback");
+
+		expect(parsed.disabled).toBeUndefined();
+		expect(parsed.frontmatter).not.toHaveProperty("disabled");
+		expect(updated.endsWith("Use the review checklist.")).toBe(true);
+	});
+
+	it("enables a legacy enabled false skill", () => {
+		const content = `---
+name: legacy-skill
+enabled: false
+---
+Use legacy instructions.`;
+
+		const updated = updateSkillMarkdownEnabledState(content, true);
+		const parsed = parseSkillConfigFromMarkdown(updated, "fallback");
+
+		expect(parsed.disabled).toBeUndefined();
+		expect(parsed.frontmatter).not.toHaveProperty("enabled");
+		expect(updated.endsWith("Use legacy instructions.")).toBe(true);
+	});
+
+	it("prepends frontmatter when disabling a skill without frontmatter", () => {
+		const content = "Follow the incident response runbook.";
+
+		const updated = updateSkillMarkdownEnabledState(content, false);
+		const parsed = parseSkillConfigFromMarkdown(updated, "incident-response");
+
+		expect(parsed.disabled).toBe(true);
+		expect(parsed.instructions).toBe(content);
+		expect(updated).toBe(`---
+disabled: true
+---
+${content}`);
+	});
+
+	it("leaves a skill without frontmatter unchanged when enabling", () => {
+		const content = "Follow the incident response runbook.";
+
+		expect(updateSkillMarkdownEnabledState(content, true)).toBe(content);
+	});
+
+	it("writes toggled content and returns the resulting state", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-skill-toggle-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "SKILL.md");
+		await writeFile(
+			filePath,
+			`---
+name: file-skill
+---
+Use file-backed instructions.`,
+		);
+
+		const result = await toggleSkillFrontmatter({ filePath, enabled: false });
+		const written = await readFile(filePath, "utf8");
+		const parsed = parseSkillConfigFromMarkdown(written, "fallback");
+
+		expect(result).toEqual({ filePath, enabled: false, disabled: true });
+		expect(parsed.disabled).toBe(true);
+		expect(written.endsWith("Use file-backed instructions.")).toBe(true);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/config/skill-frontmatter-toggle.ts b/sdk/packages/core/src/extensions/config/skill-frontmatter-toggle.ts
new file mode 100644
index 0000000..9dff660
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/skill-frontmatter-toggle.ts
@@ -0,0 +1,83 @@
+import { readFile, writeFile } from "node:fs/promises";
+import YAML from "yaml";
+
+export interface ToggleSkillFrontmatterOptions {
+	filePath: string;
+	enabled: boolean;
+}
+
+export interface ToggleSkillFrontmatterResult {
+	filePath: string;
+	enabled: boolean;
+	disabled: boolean;
+}
+
+interface MarkdownFrontmatterParts {
+	data: Record<string, unknown>;
+	body: string;
+	hadFrontmatter: boolean;
+}
+
+function parseMarkdownFrontmatter(content: string): MarkdownFrontmatterParts {
+	const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+	const match = content.match(frontmatterRegex);
+	if (!match) {
+		return { data: {}, body: content, hadFrontmatter: false };
+	}
+
+	const [, yamlContent, body] = match;
+	const parsed = YAML.parse(yamlContent);
+	const data =
+		parsed && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: {};
+	return { data, body, hadFrontmatter: true };
+}
+
+function serializeMarkdownFrontmatter(
+	data: Record<string, unknown>,
+	body: string,
+): string {
+	const yaml = YAML.stringify(data).trimEnd();
+	return `---\n${yaml}\n---\n${body}`;
+}
+
+export function updateSkillMarkdownEnabledState(
+	content: string,
+	enabled: boolean,
+): string {
+	const { data, body, hadFrontmatter } = parseMarkdownFrontmatter(content);
+
+	if (!hadFrontmatter && enabled) {
+		return content;
+	}
+
+	if (enabled) {
+		delete data.disabled;
+		if (data.enabled === false) {
+			delete data.enabled;
+		}
+		if (Object.keys(data).length === 0) {
+			return body;
+		}
+		return serializeMarkdownFrontmatter(data, body);
+	}
+
+	data.disabled = true;
+	return serializeMarkdownFrontmatter(data, body);
+}
+
+export async function toggleSkillFrontmatter({
+	filePath,
+	enabled,
+}: ToggleSkillFrontmatterOptions): Promise<ToggleSkillFrontmatterResult> {
+	const content = await readFile(filePath, "utf8");
+	const updated = updateSkillMarkdownEnabledState(content, enabled);
+	await writeFile(filePath, updated);
+
+	return {
+		filePath,
+		enabled,
+		disabled: !enabled,
+	};
+}
diff --git a/sdk/packages/core/src/extensions/config/unified-config-file-watcher.test.ts b/sdk/packages/core/src/extensions/config/unified-config-file-watcher.test.ts
new file mode 100644
index 0000000..3b044b0
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/unified-config-file-watcher.test.ts
@@ -0,0 +1,193 @@
+import { mkdir, mkdtemp, rm, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	UnifiedConfigFileWatcher,
+	type UnifiedConfigWatcherEvent,
+} from "./unified-config-file-watcher";
+
+const WAIT_TIMEOUT_MS = 8_000;
+const WAIT_INTERVAL_MS = 25;
+
+interface TestProfileConfig {
+	name: string;
+	body: string;
+}
+
+function parseTestProfileConfig(content: string): TestProfileConfig {
+	const match = content.match(/^name:\s*(.+)\n\n([\s\S]*)$/);
+	if (!match) {
+		throw new Error("Invalid test profile config.");
+	}
+	return {
+		name: match[1].trim(),
+		body: match[2].trim(),
+	};
+}
+
+async function waitForEvent<TType extends string, TItem>(
+	events: Array<UnifiedConfigWatcherEvent<TType, TItem>>,
+	predicate: (event: UnifiedConfigWatcherEvent<TType, TItem>) => boolean,
+	timeoutMs = WAIT_TIMEOUT_MS,
+): Promise<UnifiedConfigWatcherEvent<TType, TItem>> {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < timeoutMs) {
+		const match = events.find(predicate);
+		if (match) {
+			return match;
+		}
+		await new Promise((resolve) => setTimeout(resolve, WAIT_INTERVAL_MS));
+	}
+	throw new Error("Timed out waiting for watcher event.");
+}
+
+describe("UnifiedConfigFileWatcher", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("emits upsert and remove events with config type", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-unified-config-watcher-"),
+		);
+		tempRoots.push(tempRoot);
+		const profilesDir = join(tempRoot, "profiles");
+		await mkdir(profilesDir, { recursive: true });
+		const profileFilePath = join(profilesDir, "reviewer.profile");
+		await writeFile(
+			profileFilePath,
+			"name: Reviewer\n\nReview code carefully.",
+		);
+
+		const watcher = new UnifiedConfigFileWatcher([
+			{
+				type: "profile" as const,
+				directories: [profilesDir],
+				includeFile: (fileName) => fileName.endsWith(".profile"),
+				parseFile: (context) => parseTestProfileConfig(context.content),
+				resolveId: (config) => config.name.toLowerCase(),
+			},
+		]);
+
+		const events: Array<
+			UnifiedConfigWatcherEvent<
+				"profile",
+				ReturnType<typeof parseTestProfileConfig>
+			>
+		> = [];
+		const unsubscribe = watcher.subscribe((event) => events.push(event));
+
+		try {
+			await watcher.refreshAll();
+			await waitForEvent(
+				events,
+				(event) => event.kind === "upsert" && event.record.id === "reviewer",
+			);
+
+			events.length = 0;
+			await writeFile(
+				profileFilePath,
+				"name: Reviewer\n\nReview code with strictness.",
+			);
+			await watcher.refreshType("profile");
+			await waitForEvent(
+				events,
+				(event) => event.kind === "upsert" && event.record.type === "profile",
+			);
+
+			events.length = 0;
+			await unlink(profileFilePath);
+			await watcher.refreshType("profile");
+			await waitForEvent(
+				events,
+				(event) => event.kind === "remove" && event.type === "profile",
+			);
+		} finally {
+			unsubscribe();
+		}
+	}, 15_000);
+
+	it("supports one watcher instance for multiple config types", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-unified-config-watcher-"),
+		);
+		tempRoots.push(tempRoot);
+		const profilesDir = join(tempRoot, "profiles");
+		const skillsDir = join(tempRoot, "skills");
+		await mkdir(profilesDir, { recursive: true });
+		await mkdir(skillsDir, { recursive: true });
+
+		await writeFile(
+			join(profilesDir, "researcher.profile"),
+			"name: Researcher\n\nInvestigate related code paths.",
+		);
+		await writeFile(
+			join(skillsDir, "SKILL.md"),
+			`---
+name: incident-response
+description: Handle incidents
+---
+Escalation playbook`,
+		);
+
+		const watcher = new UnifiedConfigFileWatcher<
+			"profile" | "skill",
+			TestProfileConfig | { path: string }
+		>([
+			{
+				type: "profile" as const,
+				directories: [profilesDir],
+				includeFile: (fileName) => fileName.endsWith(".profile"),
+				parseFile: (context) =>
+					parseTestProfileConfig(context.content) as
+						| TestProfileConfig
+						| { path: string },
+				resolveId: (config) =>
+					"name" in config ? config.name.toLowerCase() : "invalid-profile",
+			},
+			{
+				type: "skill" as const,
+				directories: [skillsDir],
+				includeFile: (fileName) => fileName === "SKILL.md",
+				parseFile: (context) => ({ path: context.filePath }),
+				resolveId: (_parsed, context) => basename(context.directoryPath),
+			},
+		]);
+
+		const events: Array<
+			UnifiedConfigWatcherEvent<
+				"profile" | "skill",
+				TestProfileConfig | { path: string }
+			>
+		> = [];
+		const unsubscribe = watcher.subscribe((event) => events.push(event));
+
+		try {
+			await watcher.refreshAll();
+			await waitForEvent(
+				events,
+				(event) =>
+					event.kind === "upsert" &&
+					(event.record.type === "profile" || event.record.type === "skill"),
+			);
+			expect(
+				events.some(
+					(event) => event.kind === "upsert" && event.record.type === "profile",
+				),
+			).toBe(true);
+			expect(
+				events.some(
+					(event) => event.kind === "upsert" && event.record.type === "skill",
+				),
+			).toBe(true);
+		} finally {
+			unsubscribe();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/config/unified-config-file-watcher.ts b/sdk/packages/core/src/extensions/config/unified-config-file-watcher.ts
new file mode 100644
index 0000000..176d4f2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/unified-config-file-watcher.ts
@@ -0,0 +1,496 @@
+import { createHash } from "node:crypto";
+import { type FSWatcher, watch } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export interface UnifiedConfigFileContext<TType extends string = string> {
+	type: TType;
+	directoryPath: string;
+	fileName: string;
+	filePath: string;
+	content: string;
+}
+
+export interface UnifiedConfigFileCandidate {
+	directoryPath: string;
+	fileName: string;
+	filePath: string;
+}
+
+export interface UnifiedConfigDefinition<
+	TType extends string = string,
+	TItem = unknown,
+> {
+	type: TType;
+	directories: ReadonlyArray<string>;
+	discoverFiles?: (
+		directoryPath: string,
+	) => Promise<ReadonlyArray<UnifiedConfigFileCandidate>>;
+	includeFile?: (fileName: string, filePath: string) => boolean;
+	parseFile: (context: UnifiedConfigFileContext<TType>) => TItem;
+	resolveId: (item: TItem, context: UnifiedConfigFileContext<TType>) => string;
+}
+
+export interface UnifiedConfigWatcherOptions {
+	debounceMs?: number;
+	emitParseErrors?: boolean;
+}
+
+export interface UnifiedConfigRecord<
+	TType extends string = string,
+	TItem = unknown,
+> {
+	type: TType;
+	id: string;
+	item: TItem;
+	filePath: string;
+}
+
+export type UnifiedConfigWatcherEvent<
+	TType extends string = string,
+	TItem = unknown,
+> =
+	| {
+			kind: "upsert";
+			record: UnifiedConfigRecord<TType, TItem>;
+	  }
+	| {
+			kind: "remove";
+			type: TType;
+			id: string;
+			filePath: string;
+	  }
+	| {
+			kind: "error";
+			type: TType;
+			error: unknown;
+			filePath?: string;
+	  };
+
+interface InternalRecord<TType extends string, TItem>
+	extends UnifiedConfigRecord<TType, TItem> {
+	fingerprint: string;
+}
+
+function toFingerprint(content: string): string {
+	return createHash("sha1").update(content).digest("hex");
+}
+
+function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
+	return Boolean(error && typeof error === "object" && "code" in error);
+}
+
+function isMissingDirectoryError(error: unknown): boolean {
+	return isErrnoException(error) && error.code === "ENOENT";
+}
+
+function isInaccessibleDirectoryError(error: unknown): boolean {
+	return (
+		isErrnoException(error) &&
+		(error.code === "EACCES" || error.code === "EPERM")
+	);
+}
+
+export class UnifiedConfigFileWatcher<
+	TType extends string = string,
+	TItem = unknown,
+> {
+	private readonly definitions: ReadonlyArray<
+		UnifiedConfigDefinition<TType, TItem>
+	>;
+	private readonly debounceMs: number;
+	private readonly emitParseErrors: boolean;
+	private readonly listeners = new Set<
+		(event: UnifiedConfigWatcherEvent<TType, TItem>) => void
+	>();
+	private readonly recordsByType = new Map<
+		TType,
+		Map<string, InternalRecord<TType, TItem>>
+	>();
+	private readonly watchersByDirectory = new Map<string, FSWatcher>();
+	private readonly baseTypesByDirectory = new Map<string, Set<TType>>();
+	private watchedTypesByDirectory = new Map<string, Set<TType>>();
+	private readonly discoveredDirectoriesByType = new Map<TType, Set<string>>();
+	private readonly definitionsByType = new Map<
+		TType,
+		UnifiedConfigDefinition<TType, TItem>
+	>();
+	private readonly pendingTypes = new Set<TType>();
+	private flushTimer: NodeJS.Timeout | undefined;
+	private refreshQueue: Promise<void> = Promise.resolve();
+	private started = false;
+
+	constructor(
+		definitions: ReadonlyArray<UnifiedConfigDefinition<TType, TItem>>,
+		options?: UnifiedConfigWatcherOptions,
+	) {
+		if (definitions.length === 0) {
+			throw new Error(
+				"UnifiedConfigFileWatcher requires at least one definition.",
+			);
+		}
+
+		this.definitions = definitions;
+		this.debounceMs = options?.debounceMs ?? 75;
+		this.emitParseErrors = options?.emitParseErrors ?? false;
+
+		for (const definition of definitions) {
+			if (this.definitionsByType.has(definition.type)) {
+				throw new Error(
+					`Duplicate unified config definition type '${definition.type}'.`,
+				);
+			}
+			this.definitionsByType.set(definition.type, definition);
+			this.recordsByType.set(definition.type, new Map());
+			this.discoveredDirectoriesByType.set(definition.type, new Set());
+			for (const directoryPath of definition.directories) {
+				const existing = this.baseTypesByDirectory.get(directoryPath);
+				if (existing) {
+					existing.add(definition.type);
+				} else {
+					this.baseTypesByDirectory.set(
+						directoryPath,
+						new Set([definition.type]),
+					);
+				}
+			}
+		}
+	}
+
+	subscribe(
+		listener: (event: UnifiedConfigWatcherEvent<TType, TItem>) => void,
+	): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	async start(): Promise<void> {
+		if (this.started) {
+			return;
+		}
+		this.started = true;
+		await this.refreshAll();
+		this.startDirectoryWatchers();
+	}
+
+	stop(): void {
+		this.started = false;
+		if (this.flushTimer) {
+			clearTimeout(this.flushTimer);
+			this.flushTimer = undefined;
+		}
+		this.pendingTypes.clear();
+		for (const watcher of this.watchersByDirectory.values()) {
+			watcher.close();
+		}
+		this.watchersByDirectory.clear();
+		this.watchedTypesByDirectory = new Map();
+	}
+
+	async refreshAll(): Promise<void> {
+		await this.enqueueRefresh(async () => {
+			for (const definition of this.definitions) {
+				await this.refreshTypeInternal(definition);
+			}
+		});
+	}
+
+	async refreshType(type: TType): Promise<void> {
+		const definition = this.definitionsByType.get(type);
+		if (!definition) {
+			throw new Error(`Unknown unified config type '${type}'.`);
+		}
+		await this.enqueueRefresh(async () => {
+			await this.refreshTypeInternal(definition);
+		});
+	}
+
+	getSnapshot(type: TType): Map<string, UnifiedConfigRecord<TType, TItem>> {
+		const records = this.recordsByType.get(type);
+		return new Map(
+			[...(records?.entries() ?? [])].map(([id, record]) => [
+				id,
+				{ ...record },
+			]),
+		);
+	}
+
+	getAllSnapshots(): Map<
+		TType,
+		Map<string, UnifiedConfigRecord<TType, TItem>>
+	> {
+		const snapshot = new Map<
+			TType,
+			Map<string, UnifiedConfigRecord<TType, TItem>>
+		>();
+		for (const [type, records] of this.recordsByType.entries()) {
+			snapshot.set(
+				type,
+				new Map(
+					[...records.entries()].map(([id, record]) => [id, { ...record }]),
+				),
+			);
+		}
+		return snapshot;
+	}
+
+	private emit(event: UnifiedConfigWatcherEvent<TType, TItem>): void {
+		for (const listener of this.listeners) {
+			listener(event);
+		}
+	}
+
+	private enqueueRefresh(action: () => Promise<void>): Promise<void> {
+		this.refreshQueue = this.refreshQueue.then(action, action);
+		return this.refreshQueue;
+	}
+
+	private startDirectoryWatchers(): void {
+		this.syncDirectoryWatchers();
+	}
+
+	private syncDirectoryWatchers(): void {
+		const desiredTypesByDirectory = this.buildDesiredTypesByDirectory();
+
+		for (const [directoryPath, watcher] of this.watchersByDirectory.entries()) {
+			if (desiredTypesByDirectory.has(directoryPath)) {
+				continue;
+			}
+			watcher.close();
+			this.watchersByDirectory.delete(directoryPath);
+		}
+
+		this.watchedTypesByDirectory = desiredTypesByDirectory;
+
+		for (const directoryPath of desiredTypesByDirectory.keys()) {
+			if (this.watchersByDirectory.has(directoryPath)) {
+				continue;
+			}
+
+			try {
+				const watcher = watch(directoryPath, () => {
+					const types = this.watchedTypesByDirectory.get(directoryPath);
+					if (!types) {
+						return;
+					}
+					for (const type of types) {
+						this.pendingTypes.add(type);
+					}
+					this.scheduleFlush();
+				});
+				this.watchersByDirectory.set(directoryPath, watcher);
+				watcher.on("error", (error) => {
+					const types = this.watchedTypesByDirectory.get(directoryPath);
+					if (!types) {
+						return;
+					}
+					for (const type of types) {
+						this.emit({
+							kind: "error",
+							type,
+							error,
+							filePath: directoryPath,
+						});
+					}
+				});
+			} catch (error) {
+				if (
+					!isMissingDirectoryError(error) &&
+					!isInaccessibleDirectoryError(error)
+				) {
+					const types = desiredTypesByDirectory.get(directoryPath);
+					if (!types) {
+						continue;
+					}
+					for (const type of types) {
+						this.emit({
+							kind: "error",
+							type,
+							error,
+							filePath: directoryPath,
+						});
+					}
+				}
+			}
+		}
+	}
+
+	private scheduleFlush(): void {
+		if (this.flushTimer) {
+			clearTimeout(this.flushTimer);
+		}
+		this.flushTimer = setTimeout(() => {
+			this.flushTimer = undefined;
+			const types = [...this.pendingTypes];
+			this.pendingTypes.clear();
+			void this.enqueueRefresh(async () => {
+				for (const type of types) {
+					const definition = this.definitionsByType.get(type);
+					if (!definition) {
+						continue;
+					}
+					await this.refreshTypeInternal(definition);
+				}
+			});
+		}, this.debounceMs);
+	}
+
+	private async refreshTypeInternal(
+		definition: UnifiedConfigDefinition<TType, TItem>,
+	): Promise<void> {
+		const { records: nextRecords, discoveredDirectories } =
+			await this.loadDefinition(definition);
+		const previousRecords =
+			this.recordsByType.get(definition.type) ??
+			new Map<string, InternalRecord<TType, TItem>>();
+
+		for (const [id, previousRecord] of previousRecords.entries()) {
+			if (nextRecords.has(id)) {
+				continue;
+			}
+			this.emit({
+				kind: "remove",
+				type: definition.type,
+				id,
+				filePath: previousRecord.filePath,
+			});
+		}
+
+		for (const [id, nextRecord] of nextRecords.entries()) {
+			const previousRecord = previousRecords.get(id);
+			if (
+				previousRecord &&
+				previousRecord.filePath === nextRecord.filePath &&
+				previousRecord.fingerprint === nextRecord.fingerprint
+			) {
+				continue;
+			}
+			this.emit({
+				kind: "upsert",
+				record: {
+					type: nextRecord.type,
+					id,
+					item: nextRecord.item,
+					filePath: nextRecord.filePath,
+				},
+			});
+		}
+
+		this.recordsByType.set(definition.type, nextRecords);
+		this.discoveredDirectoriesByType.set(
+			definition.type,
+			discoveredDirectories,
+		);
+		if (this.started) {
+			this.syncDirectoryWatchers();
+		}
+	}
+
+	private async loadDefinition(
+		definition: UnifiedConfigDefinition<TType, TItem>,
+	): Promise<{
+		records: Map<string, InternalRecord<TType, TItem>>;
+		discoveredDirectories: Set<string>;
+	}> {
+		const records = new Map<string, InternalRecord<TType, TItem>>();
+		const discoveredDirectories = new Set<string>();
+
+		for (const directoryPath of definition.directories) {
+			discoveredDirectories.add(directoryPath);
+			const fileCandidates = definition.discoverFiles
+				? await definition.discoverFiles(directoryPath)
+				: await this.readDirectoryFileCandidates(directoryPath);
+
+			for (const candidate of fileCandidates) {
+				const fileName = candidate.fileName;
+				const filePath = candidate.filePath;
+				discoveredDirectories.add(candidate.directoryPath);
+				if (
+					definition.includeFile &&
+					!definition.includeFile(fileName, filePath)
+				) {
+					continue;
+				}
+				try {
+					const content = await readFile(filePath, "utf8");
+					const context: UnifiedConfigFileContext<TType> = {
+						type: definition.type,
+						directoryPath: candidate.directoryPath,
+						fileName,
+						filePath,
+						content,
+					};
+					const parsed = definition.parseFile(context);
+					const id = definition.resolveId(parsed, context).trim();
+					if (!id) {
+						continue;
+					}
+					records.set(id, {
+						type: definition.type,
+						id,
+						item: parsed,
+						filePath,
+						fingerprint: toFingerprint(content),
+					});
+				} catch (error) {
+					if (this.emitParseErrors) {
+						this.emit({
+							kind: "error",
+							type: definition.type,
+							error,
+							filePath,
+						});
+					}
+				}
+			}
+		}
+		return { records, discoveredDirectories };
+	}
+
+	private buildDesiredTypesByDirectory(): Map<string, Set<TType>> {
+		const desired = new Map<string, Set<TType>>();
+		for (const [directoryPath, types] of this.baseTypesByDirectory.entries()) {
+			desired.set(directoryPath, new Set(types));
+		}
+		for (const [
+			type,
+			directories,
+		] of this.discoveredDirectoriesByType.entries()) {
+			for (const directoryPath of directories) {
+				const existing = desired.get(directoryPath);
+				if (existing) {
+					existing.add(type);
+				} else {
+					desired.set(directoryPath, new Set([type]));
+				}
+			}
+		}
+		return desired;
+	}
+
+	private async readDirectoryFileCandidates(
+		directoryPath: string,
+	): Promise<UnifiedConfigFileCandidate[]> {
+		try {
+			const entries = await readdir(directoryPath, { withFileTypes: true });
+			return entries
+				.filter((entry) => entry.isFile())
+				.map((entry) => ({
+					directoryPath,
+					fileName: entry.name,
+					filePath: join(directoryPath, entry.name),
+				}))
+				.sort((a, b) => a.fileName.localeCompare(b.fileName));
+		} catch (error) {
+			if (
+				isMissingDirectoryError(error) ||
+				isInaccessibleDirectoryError(error)
+			) {
+				return [];
+			}
+			throw error;
+		}
+	}
+}
diff --git a/sdk/packages/core/src/extensions/config/user-instruction-config-loader.test.ts b/sdk/packages/core/src/extensions/config/user-instruction-config-loader.test.ts
new file mode 100644
index 0000000..a39f217
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/user-instruction-config-loader.test.ts
@@ -0,0 +1,424 @@
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	resolveGlobalAgentsRulesPath,
+	setHomeDir,
+} from "@cline/shared/storage";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	createRulesConfigDefinition,
+	createSkillsConfigDefinition,
+	createUserInstructionConfigWatcher,
+	createWorkflowsConfigDefinition,
+	parseRuleConfigFromMarkdown,
+	parseSkillConfigFromMarkdown,
+	parseWorkflowConfigFromMarkdown,
+	resolveRulesConfigSearchPaths,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	type UserInstructionConfigWatcherEvent,
+} from "./user-instruction-config-loader";
+
+const WAIT_TIMEOUT_MS = 4_000;
+const WAIT_INTERVAL_MS = 25;
+
+async function waitForEvent(
+	events: Array<UserInstructionConfigWatcherEvent>,
+	predicate: (event: UserInstructionConfigWatcherEvent) => boolean,
+	timeoutMs = WAIT_TIMEOUT_MS,
+): Promise<UserInstructionConfigWatcherEvent> {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < timeoutMs) {
+		const match = events.find(predicate);
+		if (match) {
+			return match;
+		}
+		await new Promise((resolve) => setTimeout(resolve, WAIT_INTERVAL_MS));
+	}
+	throw new Error("Timed out waiting for watcher event.");
+}
+
+describe("user instruction config loader", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("resolves legacy-compatible default search paths", () => {
+		const workspacePath = "/repo/demo";
+		expect(resolveSkillsConfigSearchPaths(workspacePath)).toEqual(
+			expect.arrayContaining([
+				join(workspacePath, ".clinerules", "skills"),
+				join(workspacePath, ".cline", "skills"),
+				join(workspacePath, ".agents", "skills"),
+			]),
+		);
+		expect(resolveRulesConfigSearchPaths(workspacePath)).toEqual(
+			expect.arrayContaining([
+				join(workspacePath, "AGENTS.md"),
+				join(workspacePath, ".clinerules"),
+				join(workspacePath, ".cline", "rules"),
+			]),
+		);
+		expect(
+			resolveRulesConfigSearchPaths(workspacePath).some((path) =>
+				path.endsWith(join(".agents", "AGENTS.md")),
+			),
+		).toBe(true);
+		const paths = resolveWorkflowsConfigSearchPaths(workspacePath);
+		expect(paths).toContain(join(workspacePath, ".clinerules", "workflows"));
+		expect(paths).toContain(join(workspacePath, ".cline", "workflows"));
+		expect(
+			paths.some(
+				(p) =>
+					p.includes("Documents") &&
+					p.includes("Cline") &&
+					p.includes("Workflows"),
+			),
+		).toBe(true);
+		expect(paths).not.toContain(
+			join(process.env.HOME ?? "~", ".cline", "data", "workflows"),
+		);
+	});
+
+	it("discovers managed plugin instruction roots from workspace .cline manifests", () => {
+		const workspacePath = "/repo/demo";
+		expect(
+			createSkillsConfigDefinition({ workspacePath }).directories,
+		).toContain(join(workspacePath, ".cline"));
+		expect(
+			createRulesConfigDefinition({ workspacePath }).directories,
+		).toContain(join(workspacePath, ".cline"));
+		expect(
+			createWorkflowsConfigDefinition({ workspacePath }).directories,
+		).toContain(join(workspacePath, ".cline"));
+	});
+
+	it("parses markdown frontmatter for skill, rule, and workflow configs", () => {
+		const skill = parseSkillConfigFromMarkdown(
+			`---
+name: debugging
+description: Use structured debugging
+disabled: true
+---
+Follow the debugging checklist.`,
+			"fallback",
+		);
+		expect(skill.name).toBe("debugging");
+		expect(skill.description).toBe("Use structured debugging");
+		expect(skill.disabled).toBe(true);
+		expect(skill.instructions).toBe("Follow the debugging checklist.");
+
+		const rule = parseRuleConfigFromMarkdown(
+			`---
+name: rule-a
+disabled: true
+---
+Always run tests before merge.`,
+			"rule-a",
+		);
+		expect(rule.name).toBe("rule-a");
+		expect(rule.disabled).toBe(true);
+
+		const workflow = parseWorkflowConfigFromMarkdown(
+			`---
+name: release
+disabled: true
+---
+Document rollout and rollback steps.`,
+			"release",
+		);
+		expect(workflow.name).toBe("release");
+		expect(workflow.disabled).toBe(true);
+	});
+
+	it("emits typed events for skills, rules, and workflows in one watcher", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-user-instructions-loader-"),
+		);
+		tempRoots.push(tempRoot);
+		const skillsDir = join(tempRoot, "skills");
+		const rulesDir = join(tempRoot, "rules");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(join(skillsDir, "incident-response"), { recursive: true });
+		await mkdir(rulesDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+
+		await writeFile(
+			join(skillsDir, "incident-response", "SKILL.md"),
+			`---
+name: incident-response
+description: Handle incidents fast
+---
+Escalation runbook`,
+		);
+		await writeFile(
+			join(rulesDir, "default.md"),
+			"Keep changes minimal and tested.",
+		);
+		await writeFile(
+			join(workflowsDir, "release.md"),
+			"Ship with release checklist.",
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [skillsDir] },
+			rules: { directories: [rulesDir] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		const events: Array<UserInstructionConfigWatcherEvent> = [];
+		const unsubscribe = watcher.subscribe((event) => events.push(event));
+
+		try {
+			await watcher.refreshAll();
+			await waitForEvent(
+				events,
+				(event) => event.kind === "upsert" && event.record.type === "skill",
+			);
+			await waitForEvent(
+				events,
+				(event) => event.kind === "upsert" && event.record.type === "rule",
+			);
+			await waitForEvent(
+				events,
+				(event) => event.kind === "upsert" && event.record.type === "workflow",
+			);
+		} finally {
+			unsubscribe();
+		}
+	});
+
+	it("loads global and workspace AGENTS.md rules without clobbering either source", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-user-instructions-agents-"),
+		);
+		tempRoots.push(tempRoot);
+
+		const originalHomeDir = process.env.HOME?.trim() || homedir();
+		setHomeDir(join(tempRoot, "home"));
+		const globalAgentsPath = resolveGlobalAgentsRulesPath();
+		const fallbackAgentsDir = join(tempRoot, "other", ".agents");
+		const workspaceRoot = join(tempRoot, "workspace");
+		await mkdir(join(tempRoot, "home", ".agents"), { recursive: true });
+		await mkdir(fallbackAgentsDir, { recursive: true });
+		await mkdir(workspaceRoot, { recursive: true });
+		const fallbackAgentsPath = join(fallbackAgentsDir, "AGENTS.md");
+		const workspaceAgentsPath = join(workspaceRoot, "AGENTS.md");
+		await writeFile(globalAgentsPath, "Use global AGENTS rules.");
+		await writeFile(fallbackAgentsPath, "Use fallback AGENTS rules.");
+		await writeFile(workspaceAgentsPath, "Use workspace AGENTS rules.");
+
+		const watcher = createUserInstructionConfigWatcher({
+			rules: {
+				directories: [
+					globalAgentsPath,
+					workspaceAgentsPath,
+					fallbackAgentsPath,
+				],
+				workspacePath: workspaceRoot,
+			},
+		});
+
+		try {
+			await watcher.refreshAll();
+			const rules = watcher.getSnapshot("rule");
+
+			expect(rules.get("global agents.md")?.item.instructions).toBe(
+				"Use global AGENTS rules.",
+			);
+			expect(rules.get("workspace agents.md")?.item.instructions).toBe(
+				"Use workspace AGENTS rules.",
+			);
+			expect(rules.get("agents")?.item.instructions).toBe(
+				"Use fallback AGENTS rules.",
+			);
+		} finally {
+			setHomeDir(originalHomeDir);
+		}
+	});
+
+	it.skipIf(process.platform === "win32")(
+		"discovers skill directories through symlinks",
+		async () => {
+			const tempRoot = await mkdtemp(
+				join(tmpdir(), "core-user-instructions-symlink-skill-"),
+			);
+			tempRoots.push(tempRoot);
+			const skillsDir = join(tempRoot, ".cline", "skills");
+			const externalSkillsDir = join(tempRoot, "external-skills");
+			const targetSkillDir = join(externalSkillsDir, "data-agent-skill");
+			const linkedSkillDir = join(skillsDir, "data-agent-skill");
+			await mkdir(targetSkillDir, { recursive: true });
+			await mkdir(skillsDir, { recursive: true });
+			await writeFile(
+				join(targetSkillDir, "SKILL.md"),
+				`---
+name: data-agent-skill
+description: Analyze data
+---
+Use the data agent skill.`,
+			);
+			await symlink(targetSkillDir, linkedSkillDir, "dir");
+
+			const watcher = createUserInstructionConfigWatcher({
+				skills: { directories: [skillsDir] },
+			});
+
+			await watcher.refreshAll();
+
+			expect(
+				watcher.getSnapshot("skill").get("data-agent-skill"),
+			).toMatchObject({
+				item: {
+					name: "data-agent-skill",
+					description: "Analyze data",
+				},
+			});
+		},
+	);
+
+	it.skipIf(process.platform === "win32")(
+		"ignores circular symlinks while discovering skill directories",
+		async () => {
+			const tempRoot = await mkdtemp(
+				join(tmpdir(), "core-user-instructions-circular-symlink-skill-"),
+			);
+			tempRoots.push(tempRoot);
+			const skillsDir = join(tempRoot, ".cline", "skills");
+			const skillDir = join(skillsDir, "commit");
+			const circularLink = join(skillsDir, "loop");
+			await mkdir(skillDir, { recursive: true });
+			await writeFile(
+				join(skillDir, "SKILL.md"),
+				`---
+name: commit
+---
+Use conventional commits.`,
+			);
+			await symlink(circularLink, circularLink, "dir");
+
+			const watcher = createUserInstructionConfigWatcher({
+				skills: { directories: [skillsDir] },
+			});
+
+			await watcher.refreshAll();
+
+			expect(watcher.getSnapshot("skill").get("commit")).toMatchObject({
+				item: {
+					name: "commit",
+					instructions: "Use conventional commits.",
+				},
+			});
+		},
+	);
+
+	it("loads enterprise-style managed rules, workflows, and skills through the default workspace watcher", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-user-instructions-managed-"),
+		);
+		tempRoots.push(tempRoot);
+
+		const pluginRoot = join(tempRoot, ".cline", "enterprise");
+		await mkdir(join(pluginRoot, "workflows"), { recursive: true });
+		await mkdir(join(pluginRoot, "skills", "security-review"), {
+			recursive: true,
+		});
+		await writeFile(
+			join(pluginRoot, "managed.json"),
+			JSON.stringify({ source: "enterprise", version: "1", files: [] }),
+		);
+		await writeFile(
+			join(pluginRoot, "rules.md"),
+			`---
+name: enterprise-policy
+---
+Follow enterprise policy.`,
+		);
+		await writeFile(
+			join(pluginRoot, "workflows", "triage.md"),
+			`---
+name: triage
+---
+Follow the triage workflow.`,
+		);
+		await writeFile(
+			join(pluginRoot, "skills", "security-review", "SKILL.md"),
+			`---
+name: security-review
+---
+Use the security review checklist.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { workspacePath: tempRoot },
+			rules: { workspacePath: tempRoot },
+			workflows: { workspacePath: tempRoot },
+		});
+
+		await watcher.refreshAll();
+		const rules = watcher.getSnapshot("rule");
+		const workflows = watcher.getSnapshot("workflow");
+		const skills = watcher.getSnapshot("skill");
+
+		expect(
+			[...rules.values()].some((rule) =>
+				rule.item.instructions.includes("enterprise policy"),
+			),
+		).toBe(true);
+		expect(
+			[...workflows.values()].some((workflow) =>
+				workflow.item.instructions.includes("triage workflow"),
+			),
+		).toBe(true);
+		expect(
+			[...skills.values()].some((skill) =>
+				skill.item.instructions.includes("security review checklist"),
+			),
+		).toBe(true);
+	});
+
+	it("lets workspace .cline workflows override legacy .clinerules workflows with the same name", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-user-instructions-workflow-precedence-"),
+		);
+		tempRoots.push(tempRoot);
+
+		await mkdir(join(tempRoot, ".clinerules", "workflows"), {
+			recursive: true,
+		});
+		await mkdir(join(tempRoot, ".cline", "workflows"), { recursive: true });
+		await writeFile(
+			join(tempRoot, ".clinerules", "workflows", "release.md"),
+			`---
+name: release
+---
+Legacy release workflow.`,
+		);
+		await writeFile(
+			join(tempRoot, ".cline", "workflows", "release.md"),
+			`---
+name: release
+---
+New release workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			workflows: { workspacePath: tempRoot },
+		});
+
+		await watcher.refreshAll();
+		const workflows = watcher.getSnapshot("workflow");
+		const release = workflows.get("release");
+
+		expect(release?.item.instructions).toBe("New release workflow.");
+		expect(release?.filePath).toBe(
+			join(tempRoot, ".cline", "workflows", "release.md"),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/config/user-instruction-config-loader.ts b/sdk/packages/core/src/extensions/config/user-instruction-config-loader.ts
new file mode 100644
index 0000000..96258e8
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/user-instruction-config-loader.ts
@@ -0,0 +1,628 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import {
+	AGENTS_RULES_FILE_NAME,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveGlobalAgentsRulesPath,
+	resolveRulesConfigSearchPaths as resolveRulesConfigSearchPathsFromShared,
+	resolveSkillsConfigSearchPaths as resolveSkillsConfigSearchPathsFromShared,
+	resolveWorkflowsConfigSearchPaths as resolveWorkflowsConfigSearchPathsFromShared,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "@cline/shared/storage";
+import YAML from "yaml";
+import { resolveAgentPluginSkillDirectories } from "../plugin/plugin-config-loader";
+import {
+	type UnifiedConfigDefinition,
+	type UnifiedConfigFileCandidate,
+	type UnifiedConfigFileContext,
+	UnifiedConfigFileWatcher,
+	type UnifiedConfigWatcherEvent,
+} from "./unified-config-file-watcher";
+
+const SKILL_FILE_NAME = "SKILL.md";
+const MANAGED_PLUGIN_MANIFEST_FILE_NAME = "managed.json";
+
+const MARKDOWN_EXTENSIONS = new Set([".md", ".markdown", ".txt"]);
+
+export {
+	RULES_CONFIG_DIRECTORY_NAME,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+};
+
+export interface ParseMarkdownFrontmatterResult {
+	data: Record<string, unknown>;
+	body: string;
+	hadFrontmatter: boolean;
+	parseError?: string;
+}
+
+export interface SkillConfig {
+	name: string;
+	description?: string;
+	disabled?: boolean;
+	instructions: string;
+	frontmatter: Record<string, unknown>;
+}
+
+export interface RuleConfig {
+	name: string;
+	disabled?: boolean;
+	instructions: string;
+	frontmatter: Record<string, unknown>;
+}
+
+export interface WorkflowConfig {
+	name: string;
+	disabled?: boolean;
+	description?: string;
+	instructions: string;
+	frontmatter: Record<string, unknown>;
+}
+
+export type UserInstructionConfigType = "skill" | "rule" | "workflow";
+
+export type UserInstructionConfig = SkillConfig | RuleConfig | WorkflowConfig;
+
+export type UserInstructionConfigWatcher = UnifiedConfigFileWatcher<
+	UserInstructionConfigType,
+	UserInstructionConfig
+>;
+
+export type UserInstructionConfigWatcherEvent = UnifiedConfigWatcherEvent<
+	UserInstructionConfigType,
+	UserInstructionConfig
+>;
+
+export interface CreateInstructionWatcherOptions {
+	debounceMs?: number;
+	emitParseErrors?: boolean;
+}
+
+export interface CreateSkillsConfigDefinitionOptions {
+	directories?: ReadonlyArray<string>;
+	workspacePath?: string;
+	includePluginSkills?: boolean;
+	pluginSkillDirectories?: ReadonlyArray<string>;
+	pluginPaths?: ReadonlyArray<string>;
+	cwd?: string;
+}
+
+export interface CreateRulesConfigDefinitionOptions {
+	directories?: ReadonlyArray<string>;
+	workspacePath?: string;
+}
+
+export interface CreateWorkflowsConfigDefinitionOptions {
+	directories?: ReadonlyArray<string>;
+	workspacePath?: string;
+}
+
+function normalizeName(name: string): string {
+	return name.trim().toLowerCase();
+}
+
+function isIgnorableDirectoryError(error: unknown): boolean {
+	const nodeError = error as NodeJS.ErrnoException;
+	return (
+		nodeError?.code === "ENOENT" ||
+		nodeError?.code === "EACCES" ||
+		nodeError?.code === "EPERM" ||
+		nodeError?.code === "ELOOP"
+	);
+}
+
+function isMarkdownFile(fileName: string): boolean {
+	return MARKDOWN_EXTENSIONS.has(extname(fileName).toLowerCase());
+}
+
+function dedupeDirectoryPaths(directories: ReadonlyArray<string>): string[] {
+	const deduped: string[] = [];
+	const seen = new Set<string>();
+	for (const directory of directories) {
+		const normalized = resolve(directory);
+		if (seen.has(normalized)) {
+			continue;
+		}
+		seen.add(normalized);
+		deduped.push(directory);
+	}
+	return deduped;
+}
+
+function resolveSkillDirectories(
+	options?: CreateSkillsConfigDefinitionOptions,
+): string[] {
+	const directories = [
+		...(options?.directories ??
+			resolveSkillsConfigSearchPaths(options?.workspacePath)),
+	];
+	if (options?.pluginSkillDirectories) {
+		directories.push(...options.pluginSkillDirectories);
+	} else if (options?.includePluginSkills) {
+		directories.push(
+			...resolveAgentPluginSkillDirectories({
+				pluginPaths: options.pluginPaths,
+				workspacePath: options.workspacePath,
+				cwd: options.cwd ?? options.workspacePath,
+			}),
+		);
+	}
+	return dedupeDirectoryPaths(directories);
+}
+
+async function discoverManagedPluginRoots(
+	clineDirectoryPath: string,
+): Promise<string[]> {
+	try {
+		const entries = await readdir(clineDirectoryPath, { withFileTypes: true });
+		const pluginRoots: string[] = [];
+		for (const entry of entries) {
+			if (!entry.isDirectory()) {
+				continue;
+			}
+			const pluginRoot = join(clineDirectoryPath, entry.name);
+			const manifestPath = join(pluginRoot, MANAGED_PLUGIN_MANIFEST_FILE_NAME);
+			try {
+				const content = await readFile(manifestPath, "utf8");
+				const parsed = JSON.parse(content) as unknown;
+				if (parsed && typeof parsed === "object") {
+					pluginRoots.push(pluginRoot);
+				}
+			} catch (error) {
+				if (isIgnorableDirectoryError(error)) {
+					continue;
+				}
+				const nodeError = error as NodeJS.ErrnoException;
+				if (nodeError?.name === "SyntaxError") {
+					continue;
+				}
+				throw error;
+			}
+		}
+		return pluginRoots.sort((a, b) => a.localeCompare(b));
+	} catch (error) {
+		if (isIgnorableDirectoryError(error)) {
+			return [];
+		}
+		throw error;
+	}
+}
+
+function parseMarkdownFrontmatter(
+	content: string,
+): ParseMarkdownFrontmatterResult {
+	const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+	const match = content.match(frontmatterRegex);
+	if (!match) {
+		return { data: {}, body: content, hadFrontmatter: false };
+	}
+
+	const [, yamlContent, body] = match;
+	try {
+		const parsed = YAML.parse(yamlContent);
+		const data =
+			parsed && typeof parsed === "object" && !Array.isArray(parsed)
+				? (parsed as Record<string, unknown>)
+				: {};
+		return { data, body, hadFrontmatter: true };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			data: {},
+			body: content,
+			hadFrontmatter: true,
+			parseError: message,
+		};
+	}
+}
+
+function parseStringField(
+	value: unknown,
+	fieldName: string,
+	isRequired: boolean,
+): string | undefined {
+	if (value === undefined || value === null) {
+		if (isRequired) {
+			throw new Error(`Missing required frontmatter field '${fieldName}'.`);
+		}
+		return undefined;
+	}
+	if (typeof value !== "string") {
+		throw new Error(`Frontmatter field '${fieldName}' must be a string.`);
+	}
+	const normalized = value.trim();
+	if (!normalized && isRequired) {
+		throw new Error(`Frontmatter field '${fieldName}' cannot be empty.`);
+	}
+	return normalized || undefined;
+}
+
+function parseBooleanField(
+	value: unknown,
+	fieldName: string,
+): boolean | undefined {
+	if (value === undefined || value === null) {
+		return undefined;
+	}
+	if (typeof value !== "boolean") {
+		throw new Error(`Frontmatter field '${fieldName}' must be a boolean.`);
+	}
+	return value;
+}
+
+function resolveRuleFallbackName(
+	context: UnifiedConfigFileContext<"rule">,
+	workspacePath?: string,
+): string {
+	const fileName = basename(context.filePath);
+	if (fileName.toLowerCase() !== AGENTS_RULES_FILE_NAME.toLowerCase()) {
+		return basename(context.filePath, extname(context.filePath));
+	}
+
+	if (
+		workspacePath &&
+		resolve(context.filePath) === resolve(workspacePath, AGENTS_RULES_FILE_NAME)
+	) {
+		return "Workspace AGENTS.md";
+	}
+
+	if (resolve(context.filePath) === resolve(resolveGlobalAgentsRulesPath())) {
+		return "Global AGENTS.md";
+	}
+
+	return basename(context.filePath, extname(context.filePath));
+}
+
+export function parseSkillConfigFromMarkdown(
+	content: string,
+	fallbackName: string,
+): SkillConfig {
+	const { data, body, parseError } = parseMarkdownFrontmatter(content);
+	if (parseError) {
+		throw new Error(`Failed to parse YAML frontmatter: ${parseError}`);
+	}
+	const instructions = body.trim();
+	if (!instructions) {
+		throw new Error("Missing instructions body in skill file.");
+	}
+	const parsedName = parseStringField(data.name, "name", false);
+	const name = parsedName ?? fallbackName.trim();
+	if (!name) {
+		throw new Error("Missing skill name.");
+	}
+
+	return {
+		name,
+		description: parseStringField(data.description, "description", false),
+		disabled:
+			parseBooleanField(data.disabled, "disabled") ??
+			(parseBooleanField(data.enabled, "enabled") === false ? true : undefined),
+		instructions,
+		frontmatter: data,
+	};
+}
+
+export function parseRuleConfigFromMarkdown(
+	content: string,
+	fallbackName: string,
+): RuleConfig {
+	const { data, body, parseError } = parseMarkdownFrontmatter(content);
+	if (parseError) {
+		throw new Error(`Failed to parse YAML frontmatter: ${parseError}`);
+	}
+	const instructions = body.trim();
+	if (!instructions) {
+		throw new Error("Missing instructions body in rule file.");
+	}
+	const name =
+		parseStringField(data.name, "name", false) ?? fallbackName.trim();
+	if (!name) {
+		throw new Error("Missing rule name.");
+	}
+	return {
+		name,
+		disabled:
+			parseBooleanField(data.disabled, "disabled") ??
+			(parseBooleanField(data.enabled, "enabled") === false ? true : undefined),
+		instructions,
+		frontmatter: data,
+	};
+}
+
+export function parseWorkflowConfigFromMarkdown(
+	content: string,
+	fallbackName: string,
+): WorkflowConfig {
+	const { data, body, parseError } = parseMarkdownFrontmatter(content);
+	if (parseError) {
+		throw new Error(`Failed to parse YAML frontmatter: ${parseError}`);
+	}
+	const instructions = body.trim();
+	if (!instructions) {
+		throw new Error("Missing instructions body in workflow file.");
+	}
+	const name =
+		parseStringField(data.name, "name", false) ?? fallbackName.trim();
+	if (!name) {
+		throw new Error("Missing workflow name.");
+	}
+	return {
+		name,
+		disabled:
+			parseBooleanField(data.disabled, "disabled") ??
+			(parseBooleanField(data.enabled, "enabled") === false ? true : undefined),
+		instructions,
+		frontmatter: data,
+	};
+}
+
+export function resolveSkillsConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveSkillsConfigSearchPathsFromShared(workspacePath);
+}
+
+export function resolveRulesConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveRulesConfigSearchPathsFromShared(workspacePath);
+}
+
+export function resolveWorkflowsConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveWorkflowsConfigSearchPathsFromShared(workspacePath);
+}
+
+async function discoverSkillFiles(
+	directoryPath: string,
+): Promise<ReadonlyArray<UnifiedConfigFileCandidate>> {
+	if (basename(directoryPath) === ".cline") {
+		const pluginRoots = await discoverManagedPluginRoots(directoryPath);
+		const nestedCandidates = await Promise.all(
+			pluginRoots.map((pluginRoot) =>
+				discoverSkillFiles(join(pluginRoot, SKILLS_CONFIG_DIRECTORY_NAME)),
+			),
+		);
+		return nestedCandidates.flat();
+	}
+
+	try {
+		const entries = await readdir(directoryPath, { withFileTypes: true });
+		const candidates: UnifiedConfigFileCandidate[] = [];
+		for (const entry of entries) {
+			if (entry.isFile() && entry.name === SKILL_FILE_NAME) {
+				candidates.push({
+					directoryPath,
+					fileName: entry.name,
+					filePath: join(directoryPath, entry.name),
+				});
+				continue;
+			}
+			const entryPath = join(directoryPath, entry.name);
+			const isDirectory =
+				entry.isDirectory() ||
+				(entry.isSymbolicLink() &&
+					(await stat(entryPath)
+						.then((entryStat) => entryStat.isDirectory())
+						.catch((error) => {
+							if (isIgnorableDirectoryError(error)) {
+								return false;
+							}
+							throw error;
+						})));
+			if (isDirectory) {
+				candidates.push({
+					directoryPath: entryPath,
+					fileName: SKILL_FILE_NAME,
+					filePath: join(entryPath, SKILL_FILE_NAME),
+				});
+			}
+		}
+		return candidates;
+	} catch (error) {
+		if (isIgnorableDirectoryError(error)) {
+			return [];
+		}
+		throw error;
+	}
+}
+
+async function discoverRulesLikeFiles(
+	directoryPath: string,
+): Promise<ReadonlyArray<UnifiedConfigFileCandidate>> {
+	if (basename(directoryPath) === ".cline") {
+		const pluginRoots = await discoverManagedPluginRoots(directoryPath);
+		const nestedCandidates = await Promise.all(
+			pluginRoots.map((pluginRoot) =>
+				discoverRulesLikeFiles(join(pluginRoot, "rules.md")),
+			),
+		);
+		return nestedCandidates.flat();
+	}
+
+	try {
+		const entryStat = await stat(directoryPath);
+		if (entryStat.isFile()) {
+			return [
+				{
+					directoryPath: dirname(directoryPath),
+					fileName: basename(directoryPath),
+					filePath: directoryPath,
+				},
+			];
+		}
+	} catch (error) {
+		if (!isIgnorableDirectoryError(error)) {
+			throw error;
+		}
+	}
+
+	try {
+		const entries = await readdir(directoryPath, { withFileTypes: true });
+		const candidates = entries
+			.filter((entry) => entry.isFile() && isMarkdownFile(entry.name))
+			.map((entry) => ({
+				directoryPath,
+				fileName: entry.name,
+				filePath: join(directoryPath, entry.name),
+			}));
+
+		// Special case: if this is a workspace root directory, also check for AGENTS.md
+		const agentsPath = join(directoryPath, "AGENTS.md");
+		try {
+			const agentsStat = await stat(agentsPath);
+			if (agentsStat.isFile()) {
+				// Check if AGENTS.md is not already in the candidates
+				const alreadyIncluded = candidates.some(
+					(c) => c.fileName === "AGENTS.md",
+				);
+				if (!alreadyIncluded) {
+					candidates.push({
+						directoryPath,
+						fileName: "AGENTS.md",
+						filePath: agentsPath,
+					});
+				}
+			}
+		} catch {
+			// AGENTS.md doesn't exist or is not accessible, which is fine
+		}
+
+		return candidates;
+	} catch (error) {
+		if (isIgnorableDirectoryError(error)) {
+			return [];
+		}
+		throw error;
+	}
+}
+
+async function discoverManagedWorkflowFiles(
+	directoryPath: string,
+): Promise<ReadonlyArray<UnifiedConfigFileCandidate>> {
+	if (basename(directoryPath) === ".cline") {
+		const pluginRoots = await discoverManagedPluginRoots(directoryPath);
+		const nestedCandidates = await Promise.all(
+			pluginRoots.map((pluginRoot) =>
+				discoverRulesLikeFiles(
+					join(pluginRoot, WORKFLOWS_CONFIG_DIRECTORY_NAME),
+				),
+			),
+		);
+		return nestedCandidates.flat();
+	}
+	return discoverRulesLikeFiles(directoryPath);
+}
+
+export function createSkillsConfigDefinition(
+	options?: CreateSkillsConfigDefinitionOptions,
+): UnifiedConfigDefinition<"skill", SkillConfig> {
+	const directories = resolveSkillDirectories(options);
+	const managedRoot = options?.workspacePath
+		? join(options.workspacePath, ".cline")
+		: undefined;
+
+	return {
+		type: "skill",
+		directories: managedRoot
+			? dedupeDirectoryPaths([...directories, managedRoot])
+			: directories,
+		discoverFiles: discoverSkillFiles,
+		includeFile: (fileName) => fileName === SKILL_FILE_NAME,
+		parseFile: (context) =>
+			parseSkillConfigFromMarkdown(
+				context.content,
+				basename(context.directoryPath),
+			),
+		resolveId: (skill) => normalizeName(skill.name),
+	};
+}
+
+export function createRulesConfigDefinition(
+	options?: CreateRulesConfigDefinitionOptions,
+): UnifiedConfigDefinition<"rule", RuleConfig> {
+	const directories =
+		options?.directories ??
+		resolveRulesConfigSearchPaths(options?.workspacePath);
+	const managedRoot = options?.workspacePath
+		? join(options.workspacePath, ".cline")
+		: undefined;
+
+	return {
+		type: "rule",
+		directories: managedRoot ? [...directories, managedRoot] : directories,
+		discoverFiles: discoverRulesLikeFiles,
+		includeFile: (fileName, filePath) =>
+			fileName === ".clinerules" ||
+			isMarkdownFile(fileName) ||
+			isMarkdownFile(filePath),
+		parseFile: (context) =>
+			parseRuleConfigFromMarkdown(
+				context.content,
+				resolveRuleFallbackName(context, options?.workspacePath),
+			),
+		resolveId: (rule) => normalizeName(rule.name),
+	};
+}
+
+export function createWorkflowsConfigDefinition(
+	options?: CreateWorkflowsConfigDefinitionOptions,
+): UnifiedConfigDefinition<"workflow", WorkflowConfig> {
+	const directories =
+		options?.directories ??
+		resolveWorkflowsConfigSearchPaths(options?.workspacePath);
+	const managedRoot = options?.workspacePath
+		? join(options.workspacePath, ".cline")
+		: undefined;
+
+	return {
+		type: "workflow",
+		directories: managedRoot ? [...directories, managedRoot] : directories,
+		discoverFiles: discoverManagedWorkflowFiles,
+		includeFile: (fileName) => isMarkdownFile(fileName),
+		parseFile: (context) =>
+			parseWorkflowConfigFromMarkdown(
+				context.content,
+				basename(context.filePath, extname(context.filePath)),
+			),
+		resolveId: (workflow) => normalizeName(workflow.name),
+	};
+}
+
+export interface CreateUserInstructionConfigWatcherOptions
+	extends CreateInstructionWatcherOptions {
+	skills?: CreateSkillsConfigDefinitionOptions;
+	rules?: CreateRulesConfigDefinitionOptions;
+	workflows?: CreateWorkflowsConfigDefinitionOptions;
+}
+
+export function createUserInstructionConfigWatcher(
+	options?: CreateUserInstructionConfigWatcherOptions,
+): UserInstructionConfigWatcher {
+	const definitions: ReadonlyArray<
+		UnifiedConfigDefinition<UserInstructionConfigType, UserInstructionConfig>
+	> = [
+		createSkillsConfigDefinition(options?.skills) as UnifiedConfigDefinition<
+			UserInstructionConfigType,
+			UserInstructionConfig
+		>,
+		createRulesConfigDefinition(options?.rules) as UnifiedConfigDefinition<
+			UserInstructionConfigType,
+			UserInstructionConfig
+		>,
+		createWorkflowsConfigDefinition(
+			options?.workflows,
+		) as UnifiedConfigDefinition<
+			UserInstructionConfigType,
+			UserInstructionConfig
+		>,
+	];
+
+	return new UnifiedConfigFileWatcher(definitions, {
+		debounceMs: options?.debounceMs,
+		emitParseErrors: options?.emitParseErrors,
+	});
+}
diff --git a/sdk/packages/core/src/extensions/config/user-instruction-plugin.ts b/sdk/packages/core/src/extensions/config/user-instruction-plugin.ts
new file mode 100644
index 0000000..e867a42
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/user-instruction-plugin.ts
@@ -0,0 +1,277 @@
+import type { AgentExtension, AgentTool } from "@cline/shared";
+import { loadRulesForSystemPromptFromWatcher } from "../../runtime/safety/rules";
+import {
+	createSkillsTool,
+	type SkillsExecutor,
+	type SkillsExecutorWithMetadata,
+} from "../tools";
+import { listAvailableRuntimeCommandsFromWatcher } from "./runtime-commands";
+import type {
+	SkillConfig,
+	UserInstructionConfigWatcher,
+} from "./user-instruction-config-loader";
+
+type SkillsExecutorMetadataItem = {
+	id: string;
+	name: string;
+	description?: string;
+	disabled: boolean;
+};
+
+type ConfiguredSkill = SkillsExecutorMetadataItem & {
+	skill: SkillConfig;
+};
+
+export interface CreateUserInstructionPluginOptions {
+	watcher: UserInstructionConfigWatcher;
+	watcherReady?: Promise<void>;
+	includeRules?: boolean;
+	includeSkills?: boolean;
+	includeWorkflows?: boolean;
+	registerSkillsTool?: boolean;
+	allowedSkillNames?: ReadonlyArray<string>;
+}
+
+function normalizeSkillToken(token: string): string {
+	return token.trim().replace(/^\/+/, "").toLowerCase();
+}
+
+function toAllowedSkillSet(
+	allowedSkillNames?: ReadonlyArray<string>,
+): Set<string> | undefined {
+	if (!allowedSkillNames || allowedSkillNames.length === 0) {
+		return undefined;
+	}
+	const normalized = allowedSkillNames
+		.map(normalizeSkillToken)
+		.filter((token) => token.length > 0);
+	return normalized.length > 0 ? new Set(normalized) : undefined;
+}
+
+function isSkillAllowed(
+	skillId: string,
+	skillName: string,
+	allowedSkills?: Set<string>,
+): boolean {
+	if (!allowedSkills) {
+		return true;
+	}
+	const normalizedId = normalizeSkillToken(skillId);
+	const normalizedName = normalizeSkillToken(skillName);
+	const bareId = normalizedId.includes(":")
+		? (normalizedId.split(":").at(-1) ?? normalizedId)
+		: normalizedId;
+	const bareName = normalizedName.includes(":")
+		? (normalizedName.split(":").at(-1) ?? normalizedName)
+		: normalizedName;
+	return (
+		allowedSkills.has(normalizedId) ||
+		allowedSkills.has(normalizedName) ||
+		allowedSkills.has(bareId) ||
+		allowedSkills.has(bareName)
+	);
+}
+
+export function getConfiguredSkillsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+	allowedSkillNames?: ReadonlyArray<string>,
+): ConfiguredSkill[] {
+	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
+	const snapshot = watcher.getSnapshot("skill");
+	return [...snapshot.entries()]
+		.map(([id, record]) => {
+			const skill = record.item as SkillConfig;
+			return {
+				id,
+				name: skill.name.trim(),
+				description: skill.description?.trim(),
+				disabled: skill.disabled === true,
+				skill,
+			};
+		})
+		.filter((skill) => isSkillAllowed(skill.id, skill.name, allowedSkills));
+}
+
+function listAvailableSkillNames(
+	watcher: UserInstructionConfigWatcher,
+	allowedSkillNames?: ReadonlyArray<string>,
+): string[] {
+	return getConfiguredSkillsFromWatcher(watcher, allowedSkillNames)
+		.filter((skill) => !skill.disabled)
+		.map((skill) => skill.name.trim())
+		.filter((name) => name.length > 0)
+		.sort((a, b) => a.localeCompare(b));
+}
+
+function resolveSkillRecord(
+	watcher: UserInstructionConfigWatcher,
+	requestedSkill: string,
+	allowedSkillNames?: ReadonlyArray<string>,
+): { id: string; skill: SkillConfig } | { error: string } {
+	const normalized = normalizeSkillToken(requestedSkill);
+	if (!normalized) {
+		return { error: "Missing skill name." };
+	}
+
+	const configuredSkills = getConfiguredSkillsFromWatcher(
+		watcher,
+		allowedSkillNames,
+	);
+	const exact = configuredSkills.find((entry) => entry.id === normalized);
+	if (exact) {
+		const { skill } = exact;
+		if (skill.disabled === true) {
+			return {
+				error: `Skill "${skill.name}" is configured but disabled.`,
+			};
+		}
+		return { id: exact.id, skill };
+	}
+
+	const bareName = normalized.includes(":")
+		? (normalized.split(":").at(-1) ?? normalized)
+		: normalized;
+	const suffixMatches = configuredSkills.filter(({ id }) => {
+		if (id === bareName) {
+			return true;
+		}
+		return id.endsWith(`:${bareName}`);
+	});
+	const enabledSuffixMatches = suffixMatches.filter(
+		({ skill }) => skill.disabled !== true,
+	);
+
+	if (enabledSuffixMatches.length === 1) {
+		const { id, skill } = enabledSuffixMatches[0];
+		return { id, skill };
+	}
+	if (enabledSuffixMatches.length > 1) {
+		return {
+			error: `Skill "${requestedSkill}" is ambiguous. Use one of: ${enabledSuffixMatches.map(({ id }) => id).join(", ")}`,
+		};
+	}
+	if (suffixMatches.length === 1) {
+		const { skill } = suffixMatches[0];
+		return {
+			error: `Skill "${skill.name}" is configured but disabled.`,
+		};
+	}
+	if (suffixMatches.length > 1) {
+		return {
+			error: `Skill "${requestedSkill}" is ambiguous, and all matches are disabled: ${suffixMatches.map(({ id }) => id).join(", ")}`,
+		};
+	}
+
+	const available = listAvailableSkillNames(watcher, allowedSkillNames);
+	return {
+		error:
+			available.length > 0
+				? `Skill "${requestedSkill}" not found. Available skills: ${available.join(", ")}`
+				: "No skills are currently available.",
+	};
+}
+
+export function createUserInstructionSkillsExecutor(
+	watcher: UserInstructionConfigWatcher,
+	watcherReady: Promise<void> = Promise.resolve(),
+	allowedSkillNames?: ReadonlyArray<string>,
+): SkillsExecutorWithMetadata {
+	const runningSkills = new Set<string>();
+	const executor: SkillsExecutorWithMetadata = (async (skillName, args) => {
+		await watcherReady;
+		const resolved = resolveSkillRecord(watcher, skillName, allowedSkillNames);
+		if ("error" in resolved) {
+			return resolved.error;
+		}
+
+		const { id, skill } = resolved;
+		if (runningSkills.has(id)) {
+			return `Skill "${skill.name}" is already running.`;
+		}
+
+		runningSkills.add(id);
+		try {
+			const trimmedArgs = args?.trim();
+			const argsTag = trimmedArgs
+				? `\n<command-args>${trimmedArgs}</command-args>`
+				: "";
+			const description = skill.description?.trim()
+				? `Description: ${skill.description.trim()}\n\n`
+				: "";
+
+			return `<command-name>${skill.name}</command-name>${argsTag}\n<command-instructions>\n${description}${skill.instructions}\n</command-instructions>`;
+		} finally {
+			runningSkills.delete(id);
+		}
+	}) as SkillsExecutor;
+
+	Object.defineProperty(executor, "configuredSkills", {
+		get: () =>
+			getConfiguredSkillsFromWatcher(watcher, allowedSkillNames).map(
+				({ skill: _skill, ...metadata }) => metadata,
+			),
+		enumerable: true,
+		configurable: false,
+	});
+	return executor;
+}
+
+export function createUserInstructionPlugin(
+	options: CreateUserInstructionPluginOptions,
+): AgentExtension {
+	const watcherReady = options.watcherReady ?? Promise.resolve();
+	const capabilities = [
+		options.includeRules ? "rules" : undefined,
+		options.registerSkillsTool ? "tools" : undefined,
+		options.includeSkills || options.includeWorkflows ? "commands" : undefined,
+	].filter((value): value is "rules" | "tools" | "commands" => Boolean(value));
+
+	return {
+		name: "cline-user-instructions",
+		manifest: {
+			capabilities,
+		},
+		async setup(api) {
+			await watcherReady;
+
+			if (options.includeRules) {
+				api.registerRule({
+					id: "cline-user-instructions:rules",
+					source: "user-instruction-watcher",
+					content: () => loadRulesForSystemPromptFromWatcher(options.watcher),
+				});
+			}
+
+			if (options.registerSkillsTool) {
+				api.registerTool(
+					createSkillsTool(
+						createUserInstructionSkillsExecutor(
+							options.watcher,
+							watcherReady,
+							options.allowedSkillNames,
+						),
+					) as AgentTool,
+				);
+			}
+
+			for (const command of listAvailableRuntimeCommandsFromWatcher(
+				options.watcher,
+			).filter(
+				(command) =>
+					(command.kind === "skill" && options.includeSkills) ||
+					(command.kind === "workflow" && options.includeWorkflows),
+			)) {
+				api.registerCommand({
+					name: command.name,
+					description: command.description,
+					handler: (input) => {
+						const trimmed = input.trim();
+						return trimmed
+							? `${command.instructions}\n\n${trimmed}`
+							: command.instructions;
+					},
+				});
+			}
+		},
+	};
+}
diff --git a/sdk/packages/core/src/extensions/config/user-instruction-service.ts b/sdk/packages/core/src/extensions/config/user-instruction-service.ts
new file mode 100644
index 0000000..2593524
--- /dev/null
+++ b/sdk/packages/core/src/extensions/config/user-instruction-service.ts
@@ -0,0 +1,143 @@
+import type { AgentExtension } from "@cline/shared";
+import type { SkillsExecutorWithMetadata } from "../tools";
+import {
+	type AvailableRuntimeCommand,
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./runtime-commands";
+import {
+	type CreateUserInstructionConfigWatcherOptions,
+	createUserInstructionConfigWatcher,
+	type UserInstructionConfig,
+	type UserInstructionConfigType,
+	type UserInstructionConfigWatcher,
+} from "./user-instruction-config-loader";
+import {
+	type CreateUserInstructionPluginOptions,
+	createUserInstructionPlugin,
+	createUserInstructionSkillsExecutor,
+	getConfiguredSkillsFromWatcher,
+} from "./user-instruction-plugin";
+
+export interface UserInstructionConfigRecord<
+	TConfig extends UserInstructionConfig = UserInstructionConfig,
+> {
+	type: UserInstructionConfigType;
+	id: string;
+	filePath: string;
+	item: TConfig;
+}
+
+export interface CreateUserInstructionConfigServiceOptions
+	extends CreateUserInstructionConfigWatcherOptions {}
+
+export interface UserInstructionConfigService {
+	start(): Promise<void>;
+	stop(): void;
+	refreshType(type: UserInstructionConfigType): Promise<void>;
+	listRecords<TConfig extends UserInstructionConfig = UserInstructionConfig>(
+		type: UserInstructionConfigType,
+	): UserInstructionConfigRecord<TConfig>[];
+	listRuntimeCommands(): AvailableRuntimeCommand[];
+	resolveRuntimeSlashCommand(input: string): string;
+	hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean;
+	createSkillsExecutor?(
+		allowedSkillNames?: ReadonlyArray<string>,
+	): SkillsExecutorWithMetadata;
+	createExtension(
+		options: Omit<
+			CreateUserInstructionPluginOptions,
+			"watcher" | "watcherReady"
+		>,
+	): AgentExtension;
+}
+
+class DefaultUserInstructionConfigService
+	implements UserInstructionConfigService
+{
+	private readonly watcher: UserInstructionConfigWatcher;
+	private ready: Promise<void> | undefined;
+	private stopped = false;
+
+	constructor(options?: CreateUserInstructionConfigServiceOptions) {
+		this.watcher = createUserInstructionConfigWatcher(options);
+	}
+
+	start(): Promise<void> {
+		if (!this.ready) {
+			this.stopped = false;
+			this.ready = this.watcher.start();
+		}
+		return this.ready;
+	}
+
+	stop(): void {
+		if (this.stopped) {
+			return;
+		}
+		this.stopped = true;
+		this.watcher.stop();
+		this.ready = undefined;
+	}
+
+	async refreshType(type: UserInstructionConfigType): Promise<void> {
+		await this.start();
+		await this.watcher.refreshType(type);
+	}
+
+	listRecords<TConfig extends UserInstructionConfig = UserInstructionConfig>(
+		type: UserInstructionConfigType,
+	): UserInstructionConfigRecord<TConfig>[] {
+		return [...this.watcher.getSnapshot(type).entries()].map(
+			([id, record]) => ({
+				type,
+				id,
+				filePath: record.filePath,
+				item: record.item as TConfig,
+			}),
+		);
+	}
+
+	listRuntimeCommands(): AvailableRuntimeCommand[] {
+		return listAvailableRuntimeCommandsFromWatcher(this.watcher);
+	}
+
+	resolveRuntimeSlashCommand(input: string): string {
+		return resolveRuntimeSlashCommandFromWatcher(input, this.watcher);
+	}
+
+	hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean {
+		return getConfiguredSkillsFromWatcher(this.watcher, allowedSkillNames).some(
+			(skill) => !skill.disabled,
+		);
+	}
+
+	createSkillsExecutor(
+		allowedSkillNames?: ReadonlyArray<string>,
+	): SkillsExecutorWithMetadata {
+		return createUserInstructionSkillsExecutor(
+			this.watcher,
+			(this.ready ?? Promise.resolve()).catch(() => {}),
+			allowedSkillNames,
+		);
+	}
+
+	createExtension(
+		options: Omit<
+			CreateUserInstructionPluginOptions,
+			"watcher" | "watcherReady"
+		>,
+	): AgentExtension {
+		return createUserInstructionPlugin({
+			...options,
+			watcher: this.watcher,
+			watcherReady: (this.ready ?? Promise.resolve()).catch(() => {}),
+		});
+	}
+}
+
+export function createUserInstructionConfigService(
+	options?: CreateUserInstructionConfigServiceOptions,
+): UserInstructionConfigService {
+	return new DefaultUserInstructionConfigService(options);
+}
diff --git a/sdk/packages/core/src/extensions/context/agentic-compaction.ts b/sdk/packages/core/src/extensions/context/agentic-compaction.ts
new file mode 100644
index 0000000..5cee89c
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/agentic-compaction.ts
@@ -0,0 +1,285 @@
+import { createHandlerAsync } from "@cline/llms";
+import type { BasicLogger } from "@cline/shared";
+import type {
+	CoreCompactionContext,
+	CoreCompactionResult,
+	CoreCompactionSummarizerConfig,
+} from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+import {
+	buildBudgetProjection,
+	type BudgetProjectionResult,
+} from "./budget-projection";
+import {
+	buildSummaryMessage,
+	buildSummaryRequest,
+	type EstimateMessageTokens,
+	ensureFilesSection,
+	estimateTokens,
+	extractFileOps,
+	findCutIndex,
+	findLatestSummaryIndex,
+	getCompactionSummaryMetadata,
+	resolveSummarizerConfig,
+	serializeConversation,
+} from "./compaction-shared";
+
+const MIN_AGENTIC_SUMMARY_INPUT_TOKENS = 1_024;
+
+function resolveProviderMaxInputTokens(
+	providerConfig: ProviderConfig,
+): number | undefined {
+	const explicit = providerConfig.maxInputTokens;
+	if (typeof explicit === "number" && Number.isFinite(explicit)) {
+		return explicit;
+	}
+	const modelInfoLimit =
+		providerConfig.modelInfo?.maxInputTokens ??
+		providerConfig.modelInfo?.contextWindow;
+	if (typeof modelInfoLimit === "number" && Number.isFinite(modelInfoLimit)) {
+		return modelInfoLimit;
+	}
+	const knownModelInfo = providerConfig.knownModels?.[providerConfig.modelId];
+	const knownModelLimit =
+		knownModelInfo?.maxInputTokens ?? knownModelInfo?.contextWindow;
+	if (typeof knownModelLimit === "number" && Number.isFinite(knownModelLimit)) {
+		return knownModelLimit;
+	}
+	return undefined;
+}
+
+export function buildAgenticSummaryInputBudget(options: {
+	messages: CoreCompactionContext["messages"];
+	targetTokens: number;
+	estimateMessageTokens: EstimateMessageTokens;
+}): BudgetProjectionResult {
+	return buildBudgetProjection({
+		messages: options.messages,
+		targetTokens: Math.max(1, options.targetTokens),
+		policyIntent: "agentic_summary",
+		estimateMessageTokens: options.estimateMessageTokens,
+	});
+}
+
+async function generateSummary(options: {
+	providerConfig: ProviderConfig;
+	request: string;
+	logger?: BasicLogger;
+}): Promise<string> {
+	const handler = await createHandlerAsync(options.providerConfig);
+	let text = "";
+	for await (const chunk of handler.createMessage(
+		"Summarize the provided coding session into a concise continuation note with detailed next steps.",
+		[{ role: "user", content: options.request }],
+	)) {
+		if (chunk.type === "text") {
+			text += chunk.text;
+			continue;
+		}
+		if (chunk.type === "done" && !chunk.success && chunk.error) {
+			throw new Error(chunk.error);
+		}
+	}
+	options.logger?.debug("Generated compaction summary", {
+		outputChars: text.length,
+		modelId: options.providerConfig.modelId,
+		providerId: options.providerConfig.providerId,
+	});
+	return text.trim();
+}
+
+function safeJsonSize(value: unknown): number {
+	try {
+		return JSON.stringify(value).length;
+	} catch {
+		return String(value).length;
+	}
+}
+
+export async function runAgenticCompaction(options: {
+	context: CoreCompactionContext;
+	providerConfig: ProviderConfig;
+	summarizer?: CoreCompactionSummarizerConfig;
+	preserveRecentTokens: number;
+	estimateMessageTokens: EstimateMessageTokens;
+	logger?: BasicLogger;
+}): Promise<CoreCompactionResult | undefined> {
+	const messages = options.context.messages;
+	if (messages.length < 2) {
+		return undefined;
+	}
+
+	const cutIndex = findCutIndex(
+		messages,
+		options.preserveRecentTokens,
+		options.estimateMessageTokens,
+	);
+	if (cutIndex <= 0 || cutIndex >= messages.length) {
+		return undefined;
+	}
+
+	const messagesToSummarize = messages.slice(0, cutIndex);
+	const latestSummaryIndex = findLatestSummaryIndex(messagesToSummarize);
+	const previousSummary =
+		latestSummaryIndex >= 0
+			? getCompactionSummaryMetadata(messagesToSummarize[latestSummaryIndex])
+					?.summary
+			: undefined;
+	const newMessagesToFold =
+		latestSummaryIndex >= 0
+			? messagesToSummarize.slice(latestSummaryIndex + 1)
+			: messagesToSummarize;
+	if (newMessagesToFold.length === 0) {
+		return undefined;
+	}
+
+	const preProjectionFileOps = extractFileOps(messagesToSummarize);
+	const summarizerProviderConfig = resolveSummarizerConfig({
+		activeProviderConfig: options.providerConfig,
+		summarizer: options.summarizer,
+	});
+	const resolvedSummarizerInputLimit = resolveProviderMaxInputTokens(
+		summarizerProviderConfig,
+	);
+	const canUseActiveContextLimit = options.summarizer === undefined;
+	const activeCompactionInputLimit = Math.max(
+		options.context.maxInputTokens,
+		options.context.triggerTokens,
+		MIN_AGENTIC_SUMMARY_INPUT_TOKENS,
+	);
+	if (
+		resolvedSummarizerInputLimit === undefined &&
+		!canUseActiveContextLimit
+	) {
+		options.logger?.log(
+			"Agentic compaction summarizer has no known input limit; using conservative summary budget",
+			{
+				severity: "warn",
+				summarizerProviderId: summarizerProviderConfig.providerId,
+				summarizerModelId: summarizerProviderConfig.modelId,
+				fallbackInputLimit: MIN_AGENTIC_SUMMARY_INPUT_TOKENS,
+			},
+		);
+	}
+	const summarizerInputLimit =
+		resolvedSummarizerInputLimit ??
+		(canUseActiveContextLimit
+			? activeCompactionInputLimit
+			: MIN_AGENTIC_SUMMARY_INPUT_TOKENS);
+	const summaryRequestOverheadTokens = estimateTokens(
+		buildSummaryRequest({
+			previousSummary,
+			conversationText: "",
+			fileOps: preProjectionFileOps,
+		}).length,
+	);
+	const availableSummaryInputTokens =
+		summarizerInputLimit - summaryRequestOverheadTokens;
+	if (availableSummaryInputTokens <= 0) {
+		options.logger?.debug("Skipped agentic compaction: summarizer budget exhausted", {
+			summarizerProviderId: summarizerProviderConfig.providerId,
+			summarizerModelId: summarizerProviderConfig.modelId,
+			summarizerInputLimit,
+			summaryRequestOverheadTokens,
+		});
+		return undefined;
+	}
+	const summaryInputBudget = buildAgenticSummaryInputBudget({
+		messages: newMessagesToFold,
+		targetTokens: availableSummaryInputTokens,
+		estimateMessageTokens: options.estimateMessageTokens,
+	});
+	if (summaryInputBudget.status === "failed") {
+		options.logger?.log(
+			"Skipped agentic compaction: summary input budget failed",
+			{
+				severity: "warn",
+				budgetWarnings: summaryInputBudget.warnings.map(
+					(warning) => warning.code,
+				),
+				summaryInputEstimatedTokens: summaryInputBudget.estimatedTokens,
+				targetTokens: availableSummaryInputTokens,
+				summarizerProviderId: summarizerProviderConfig.providerId,
+				summarizerModelId: summarizerProviderConfig.modelId,
+			},
+		);
+		return undefined;
+	}
+	const fileOps = extractFileOps(summaryInputBudget.messages);
+	const conversationText = serializeConversation(summaryInputBudget.messages);
+	const summaryRequest = buildSummaryRequest({
+		previousSummary,
+		conversationText,
+		fileOps,
+	});
+	options.logger?.debug("Agentic compaction summarizer diagnostics", {
+		messagesToSummarize: messagesToSummarize.length,
+		newMessagesToFold: newMessagesToFold.length,
+		preservedMessages: messages.length - cutIndex,
+		previousSummaryChars: previousSummary?.length ?? 0,
+		conversationTextChars: conversationText.length,
+		summaryRequestChars: summaryRequest.length,
+		summaryRequestEstimatedTokens: estimateTokens(summaryRequest.length),
+		newMessagesJsonChars: safeJsonSize(newMessagesToFold),
+		summaryInputEstimatedTokens: summaryInputBudget.estimatedTokens,
+		summaryInputActions: summaryInputBudget.actions.length,
+		summaryInputWarnings: summaryInputBudget.warnings.map(
+			(warning) => warning.code,
+		),
+		summaryRequestOverheadTokens,
+		summarizerProviderId: summarizerProviderConfig.providerId,
+		summarizerModelId: summarizerProviderConfig.modelId,
+		summarizerInputLimit,
+		maxInputTokens: options.context.maxInputTokens,
+		triggerTokens: options.context.triggerTokens,
+	});
+	const rawSummary = await generateSummary({
+		providerConfig: summarizerProviderConfig,
+		request: summaryRequest,
+		logger: options.logger,
+	});
+	if (!rawSummary.trim()) {
+		return undefined;
+	}
+
+	const summary = ensureFilesSection(rawSummary, fileOps);
+	const tokensBefore = messages.reduce(
+		(total, message) => total + options.estimateMessageTokens(message),
+		0,
+	);
+	const resultMessages = [
+		buildSummaryMessage({
+			summary,
+			fileOps,
+			tokensBefore,
+		}),
+		...messages.slice(cutIndex),
+	];
+	const tokensAfter = resultMessages.reduce(
+		(total, message) => total + options.estimateMessageTokens(message),
+		0,
+	);
+	options.logger?.debug("Performed agentic compaction", {
+		messagesBefore: messages.length,
+		messagesAfter: resultMessages.length,
+		messagesSummarized: cutIndex,
+		messagesPreserved: messages.length - cutIndex,
+		tokensBefore,
+		tokensAfter,
+		maxInputTokens: options.context.maxInputTokens,
+	});
+	const budgetActionCount = summaryInputBudget.actions.filter(
+		(action) =>
+			action.reason === "over_budget" ||
+			action.reason === "tool_pair_boundary",
+	).length;
+	return {
+		messages: resultMessages,
+		budget: {
+			policyIntent: "agentic_summary",
+			actionCount: budgetActionCount,
+			warningCount: summaryInputBudget.warnings.length,
+			liveTailHandling: summaryInputBudget.liveTailHandling,
+		},
+	};
+}
diff --git a/sdk/packages/core/src/extensions/context/basic-compaction.ts b/sdk/packages/core/src/extensions/context/basic-compaction.ts
new file mode 100644
index 0000000..49b6a98
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/basic-compaction.ts
@@ -0,0 +1,503 @@
+import {
+	type BasicLogger,
+	CHARS_PER_TOKEN,
+	type MessageWithMetadata,
+} from "@cline/shared";
+import type {
+	CoreCompactionContext,
+	CoreCompactionResult,
+} from "../../types/config";
+import { buildBudgetProjection } from "./budget-projection";
+import {
+	DEFAULT_TARGET_RATIO,
+	type EstimateMessageTokens,
+	findFirstUserMessageIndex,
+	findLastAssistantIndex,
+	findLastTurnStartIndex,
+	isCompactionSummaryMessage,
+	isTurnStartMessage,
+	MIN_TRUNCATED_MESSAGE_TOKENS,
+	truncateToolResultContentForCompaction,
+} from "./compaction-shared";
+
+interface BasicCompactionCandidate {
+	index: number;
+	message: MessageWithMetadata;
+	estimatedTokens: number;
+	toolPairIds: string[];
+	isFirstUser: boolean;
+	isLastUser: boolean;
+	isLastAssistant: boolean;
+}
+
+interface BasicCompactionCandidateSet {
+	candidates: BasicCompactionCandidate[];
+	totalTokens: number;
+}
+
+function sanitizeMessageForBasic(
+	message: MessageWithMetadata,
+): MessageWithMetadata | undefined {
+	if (isCompactionSummaryMessage(message)) {
+		return undefined;
+	}
+	if (typeof message.content === "string") {
+		const text = message.content.trim();
+		return text ? { ...message, content: text } : undefined;
+	}
+
+	// Preserve multimodal structure: trim text blocks, keep non-text blocks intact.
+	const kept = message.content.filter(
+		(block) => block.type !== "text" || block.text.trim(),
+	);
+	if (kept.length === 0) {
+		return undefined;
+	}
+	return {
+		...message,
+		content: kept.map((block) =>
+			block.type === "text"
+				? { ...block, text: block.text.trim() }
+				: block.type === "tool_result"
+					? {
+							...block,
+							content: truncateToolResultContentForCompaction(block.content),
+						}
+					: block,
+		),
+	};
+}
+
+function getTotalTokens(
+	messages: MessageWithMetadata[],
+	estimateMessageTokens: EstimateMessageTokens,
+): number {
+	return messages.reduce(
+		(total, message) => total + estimateMessageTokens(message),
+		0,
+	);
+}
+
+function truncateMessageText(text: string, limit: number): string {
+	if (text.length <= limit) {
+		return text;
+	}
+	const suffix = "\n...";
+	const sliceLength = Math.max(1, limit - suffix.length);
+	return `${text.slice(0, sliceLength)}${suffix}`;
+}
+
+function truncateMessageToTokens(
+	message: MessageWithMetadata,
+	maxTokens: number,
+): MessageWithMetadata {
+	const safeMaxTokens = Number.isFinite(maxTokens) ? Math.max(1, maxTokens) : 1;
+	const targetChars = Math.max(16, safeMaxTokens * CHARS_PER_TOKEN);
+
+	if (typeof message.content === "string") {
+		const truncated = truncateMessageText(message.content, targetChars).trim();
+		return { ...message, content: truncated || "..." };
+	}
+
+	// Preserve content block array structure while truncating text blocks.
+	let remaining = targetChars;
+	const truncatedBlocks = message.content.map((block) => {
+		if (block.type !== "text" || remaining <= 0) {
+			return block;
+		}
+		const truncated = truncateMessageText(block.text, remaining).trim();
+		remaining -= truncated.length;
+		return { ...block, text: truncated || "..." };
+	});
+	return { ...message, content: truncatedBlocks };
+}
+
+function buildBasicCandidates(
+	messages: MessageWithMetadata[],
+	estimateMessageTokens: EstimateMessageTokens,
+): BasicCompactionCandidateSet {
+	const firstUserIndex = findFirstUserMessageIndex(messages);
+	const lastUserIndex = findLastTurnStartIndex(messages);
+	const lastAssistantIndex = findLastAssistantIndex(messages);
+	const candidates: BasicCompactionCandidate[] = [];
+	let totalTokens = 0;
+	for (let index = 0; index < messages.length; index += 1) {
+		const sanitized = sanitizeMessageForBasic(messages[index]);
+		if (!sanitized) {
+			continue;
+		}
+		const estimatedTokens = estimateMessageTokens(sanitized);
+		totalTokens += estimatedTokens;
+		candidates.push({
+			index,
+			message: sanitized,
+			estimatedTokens,
+			toolPairIds: collectToolPairIds(sanitized),
+			isFirstUser: index === firstUserIndex,
+			isLastUser: index === lastUserIndex,
+			isLastAssistant: index === lastAssistantIndex,
+		});
+	}
+	return { candidates, totalTokens };
+}
+
+function updateCandidate(
+	candidates: BasicCompactionCandidate[],
+	index: number,
+	message: MessageWithMetadata,
+	estimateMessageTokens: EstimateMessageTokens,
+): number {
+	const candidate = candidates[index];
+	const previousTokens = candidate.estimatedTokens;
+	candidate.message = message;
+	candidate.estimatedTokens = estimateMessageTokens(message);
+	candidate.toolPairIds = collectToolPairIds(message);
+	return candidate.estimatedTokens - previousTokens;
+}
+
+function collectToolPairIds(message: MessageWithMetadata): string[] {
+	if (!Array.isArray(message.content)) {
+		return [];
+	}
+	const ids: string[] = [];
+	for (const block of message.content) {
+		if (block.type === "tool_use") {
+			ids.push(block.id);
+		} else if (block.type === "tool_result") {
+			ids.push(block.tool_use_id);
+		}
+	}
+	return ids;
+}
+
+function buildToolPairCandidateIndex(
+	candidates: BasicCompactionCandidate[],
+): Map<string, Set<BasicCompactionCandidate>> {
+	const indexByToolUseId = new Map<string, Set<BasicCompactionCandidate>>();
+	for (const candidate of candidates) {
+		for (const id of candidate.toolPairIds) {
+			const existing = indexByToolUseId.get(id);
+			if (existing) {
+				existing.add(candidate);
+			} else {
+				indexByToolUseId.set(id, new Set([candidate]));
+			}
+		}
+	}
+	return indexByToolUseId;
+}
+
+function collectAtomicRemovalCandidates(
+	activeCandidates: Set<BasicCompactionCandidate>,
+	pairIndex: Map<string, Set<BasicCompactionCandidate>>,
+	startCandidate: BasicCompactionCandidate,
+): Set<BasicCompactionCandidate> {
+	const removalCandidates = new Set<BasicCompactionCandidate>();
+	const queue = [startCandidate];
+	let queueIndex = 0;
+
+	while (queueIndex < queue.length) {
+		const candidate = queue[queueIndex];
+		queueIndex += 1;
+		if (
+			candidate === undefined ||
+			!activeCandidates.has(candidate) ||
+			removalCandidates.has(candidate)
+		) {
+			continue;
+		}
+		removalCandidates.add(candidate);
+		for (const id of candidate.toolPairIds) {
+			for (const linkedCandidate of pairIndex.get(id) ?? []) {
+				if (!removalCandidates.has(linkedCandidate)) {
+					queue.push(linkedCandidate);
+				}
+			}
+		}
+	}
+
+	return removalCandidates;
+}
+
+function removeCandidateSetInPlace(
+	candidates: BasicCompactionCandidate[],
+	removalCandidates: Set<BasicCompactionCandidate>,
+): void {
+	let writeIndex = 0;
+	for (const candidate of candidates) {
+		if (removalCandidates.has(candidate)) {
+			continue;
+		}
+		candidates[writeIndex] = candidate;
+		writeIndex += 1;
+	}
+	candidates.length = writeIndex;
+}
+
+function removeCandidatesByPredicate(
+	candidates: BasicCompactionCandidate[],
+	predicate: (candidate: BasicCompactionCandidate) => boolean,
+	targetTokens: number,
+	totalTokens: number,
+): number {
+	const activeCandidates = new Set(candidates);
+	const pairIndex = buildToolPairCandidateIndex(candidates);
+	for (
+		let index = 0;
+		index < candidates.length && totalTokens > targetTokens;
+	) {
+		if (!predicate(candidates[index])) {
+			index += 1;
+			continue;
+		}
+		const removalCandidates = collectAtomicRemovalCandidates(
+			activeCandidates,
+			pairIndex,
+			candidates[index],
+		);
+		if (removalCandidates.size === 0) {
+			index += 1;
+			continue;
+		}
+		let removedTokens = 0;
+		for (const candidate of removalCandidates) {
+			removedTokens += candidate.estimatedTokens;
+			activeCandidates.delete(candidate);
+		}
+		totalTokens -= removedTokens;
+		removeCandidateSetInPlace(candidates, removalCandidates);
+	}
+	return totalTokens;
+}
+
+function trimCandidatesToBudget(
+	candidates: BasicCompactionCandidate[],
+	targetTokens: number,
+	totalTokens: number,
+	triggerTokens: number,
+	estimateMessageTokens: EstimateMessageTokens,
+): number {
+	if (totalTokens <= targetTokens) {
+		return totalTokens;
+	}
+
+	for (
+		let index = candidates.length - 1;
+		index >= 0 && totalTokens > targetTokens;
+		index -= 1
+	) {
+		const candidate = candidates[index];
+		if (candidate.isFirstUser) {
+			continue;
+		}
+		const desiredTokens = Math.max(
+			MIN_TRUNCATED_MESSAGE_TOKENS,
+			candidate.estimatedTokens - (totalTokens - targetTokens),
+		);
+		if (desiredTokens >= candidate.estimatedTokens) {
+			continue;
+		}
+		totalTokens += updateCandidate(
+			candidates,
+			index,
+			truncateMessageToTokens(candidate.message, desiredTokens),
+			estimateMessageTokens,
+		);
+	}
+
+	if (totalTokens <= targetTokens) {
+		return totalTokens;
+	}
+
+	const firstUserIndex = candidates.findIndex(
+		(candidate) => candidate.isFirstUser,
+	);
+	if (firstUserIndex >= 0) {
+		const firstUser = candidates[firstUserIndex];
+		if (firstUser.estimatedTokens <= triggerTokens) {
+			return totalTokens;
+		}
+		while (totalTokens > targetTokens) {
+			const candidate = candidates[firstUserIndex];
+			const desiredTokens = Math.max(
+				1,
+				candidate.estimatedTokens - (totalTokens - targetTokens),
+			);
+			if (desiredTokens >= candidate.estimatedTokens) {
+				break;
+			}
+			const previousTokens = candidate.estimatedTokens;
+			totalTokens += updateCandidate(
+				candidates,
+				firstUserIndex,
+				truncateMessageToTokens(candidate.message, desiredTokens),
+				estimateMessageTokens,
+			);
+			if (candidate.estimatedTokens >= previousTokens) {
+				break;
+			}
+		}
+	}
+	return totalTokens;
+}
+
+function haveMessagesChanged(
+	original: MessageWithMetadata[],
+	next: MessageWithMetadata[],
+): boolean {
+	return JSON.stringify(original) !== JSON.stringify(next);
+}
+
+function splitLatestTurn(messages: MessageWithMetadata[]): {
+	compactable: MessageWithMetadata[];
+	protectedTail: MessageWithMetadata[];
+} {
+	const lastTurnStartIndex = findLastTurnStartIndex(messages);
+	if (
+		lastTurnStartIndex < 0 ||
+		(lastTurnStartIndex === 0 && !isTurnStartMessage(messages[0]))
+	) {
+		return { compactable: messages, protectedTail: [] };
+	}
+	return {
+		compactable: messages.slice(0, lastTurnStartIndex),
+		protectedTail: messages.slice(lastTurnStartIndex),
+	};
+}
+
+export function runBasicCompaction(options: {
+	context: CoreCompactionContext;
+	estimateMessageTokens: EstimateMessageTokens;
+	logger?: BasicLogger;
+}): CoreCompactionResult | undefined {
+	const totalTargetTokens = Math.max(
+		1,
+		Math.min(
+			options.context.targetTokens ??
+				Math.floor(options.context.triggerTokens * DEFAULT_TARGET_RATIO),
+			options.context.maxInputTokens,
+		),
+	);
+	const { compactable, protectedTail } = splitLatestTurn(
+		options.context.messages,
+	);
+	if (compactable.length === 0) {
+		return undefined;
+	}
+	const protectedTailTokens = getTotalTokens(
+		protectedTail,
+		options.estimateMessageTokens,
+	);
+	const targetTokens = Math.max(1, totalTargetTokens - protectedTailTokens);
+	const candidateSet = buildBasicCandidates(
+		compactable,
+		options.estimateMessageTokens,
+	);
+	const { candidates } = candidateSet;
+	if (candidates.length === 0) {
+		return undefined;
+	}
+	const beforeCompactableTokens = candidateSet.totalTokens;
+	let totalTokens = beforeCompactableTokens;
+
+	totalTokens = removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "assistant" && !candidate.isLastAssistant,
+		targetTokens,
+		totalTokens,
+	);
+	totalTokens = removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "user" &&
+			!candidate.isFirstUser &&
+			!candidate.isLastUser,
+		targetTokens,
+		totalTokens,
+	);
+	totalTokens = removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "assistant" && candidate.isLastAssistant,
+		targetTokens,
+		totalTokens,
+	);
+	totalTokens = removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "user" &&
+			candidate.isLastUser &&
+			!candidate.isFirstUser,
+		targetTokens,
+		totalTokens,
+	);
+
+	totalTokens = trimCandidatesToBudget(
+		candidates,
+		targetTokens,
+		totalTokens,
+		options.context.triggerTokens,
+		options.estimateMessageTokens,
+	);
+
+	const nextMessages = [
+		...candidates.map((candidate) => candidate.message),
+		...protectedTail,
+	];
+	const budgeted = buildBudgetProjection({
+		messages: nextMessages,
+		targetTokens: totalTargetTokens,
+		policyIntent: "basic_compaction_projection",
+		estimateMessageTokens: options.estimateMessageTokens,
+	});
+	// This final projection owns the hard output budget. Unlike the earlier
+	// basic candidate passes, it can drop completed tool pairs after the latest
+	// typed prompt while preserving coherent tool closures.
+	if (budgeted.status === "failed") {
+		options.logger?.debug("Basic compaction returned best-effort projection", {
+			budgetWarnings: budgeted.warnings.map((warning) => warning.code),
+			projectedTokens: budgeted.estimatedTokens,
+			targetTokens: totalTargetTokens,
+			maxInputTokens: options.context.maxInputTokens,
+		});
+	}
+	const resultMessages = budgeted.messages;
+
+	if (!haveMessagesChanged(options.context.messages, resultMessages)) {
+		return undefined;
+	}
+
+	const beforeTokens = beforeCompactableTokens + protectedTailTokens;
+	const afterTokens = getTotalTokens(
+		resultMessages,
+		options.estimateMessageTokens,
+	);
+	const budgetActionCount = budgeted.actions.filter(
+		(action) =>
+			action.reason === "over_budget" ||
+			action.reason === "tool_pair_boundary",
+	).length;
+	options.logger?.debug("Performed basic compaction", {
+		messagesBefore: options.context.messages.length,
+		messagesAfter: resultMessages.length,
+		messagesRemoved: options.context.messages.length - resultMessages.length,
+		tokensBefore: beforeTokens,
+		tokensAfter: afterTokens,
+		budgetStatus: budgeted.status,
+		budgetActions: budgetActionCount,
+		budgetWarnings: budgeted.warnings.map((warning) => warning.code),
+		targetTokens: totalTargetTokens,
+		maxInputTokens: options.context.maxInputTokens,
+	});
+
+	return {
+		messages: resultMessages,
+		budget: {
+			policyIntent: "basic_compaction_projection",
+			actionCount: budgetActionCount,
+			warningCount: budgeted.warnings.length,
+			liveTailHandling: budgeted.liveTailHandling,
+		},
+	};
+}
diff --git a/sdk/packages/core/src/extensions/context/budget-projection/index.ts b/sdk/packages/core/src/extensions/context/budget-projection/index.ts
new file mode 100644
index 0000000..fc6e3a1
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/budget-projection/index.ts
@@ -0,0 +1,17 @@
+export {
+	buildBudgetProjection,
+	findLatestTypedUserMessageIndex,
+} from "./project";
+export type {
+	BlockBudgetClass,
+	BudgetAction,
+	BudgetActionKind,
+	BudgetActionReason,
+	BudgetPath,
+	BudgetPolicyIntent,
+	BudgetProjectionOptions,
+	BudgetProjectionResult,
+	BudgetProjectionWarning,
+	ContentBlockBudgetClassification,
+	LiveTailHandling,
+} from "./types";
diff --git a/sdk/packages/core/src/extensions/context/budget-projection/project.test.ts b/sdk/packages/core/src/extensions/context/budget-projection/project.test.ts
new file mode 100644
index 0000000..0d22500
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/budget-projection/project.test.ts
@@ -0,0 +1,476 @@
+import type { MessageWithMetadata } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	buildBudgetProjection,
+	findLatestTypedUserMessageIndex,
+} from "./project";
+
+const estimateChars = (message: MessageWithMetadata) =>
+	JSON.stringify(message).length;
+
+describe("buildBudgetProjection", () => {
+	it("fails explicitly for impossible budgets", () => {
+		const result = buildBudgetProjection({
+			messages: [{ role: "user", content: "keep me" }],
+			targetTokens: 0,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		expect(result.status).toBe("failed");
+		expect(result.messages).toHaveLength(1);
+		expect(result.warnings[0]?.code).toBe("budget_impossible");
+	});
+
+	it("drops unsafe image and redacted thinking blocks instead of truncating them", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "old context" },
+						{
+							type: "redacted_thinking",
+							data: "x".repeat(500),
+						},
+					],
+				},
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "image",
+							data: "y".repeat(500),
+							mediaType: "image/png",
+						},
+					],
+				},
+				{ role: "user", content: "latest task" },
+			],
+			targetTokens: 150,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).not.toContain("redacted_thinking");
+		expect(serialized).not.toContain("image/png");
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "dropped_block",
+					reason: "unsafe_to_truncate",
+				}),
+			]),
+		);
+		expect(result.liveTailHandling).toBe("included_degraded");
+	});
+
+	it("keeps unsafe blocks when input is already under budget", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "look at this" },
+						{
+							type: "image",
+							data: "small-image",
+							mediaType: "image/png",
+						},
+					],
+				},
+			],
+			targetTokens: 1_000,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		expect(result.status).toBe("ok");
+		expect(result.actions).toEqual([]);
+		expect(result.liveTailHandling).toBe("included_verbatim");
+		expect(JSON.stringify(result.messages)).toContain("small-image");
+	});
+
+	it("preserves unsafe blocks in the latest typed user message", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "old task " + "x".repeat(500) },
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "what is in this image?" },
+						{
+							type: "image",
+							data: "live-image",
+							mediaType: "image/png",
+						},
+					],
+				},
+			],
+			targetTokens: 120,
+			policyIntent: "basic_compaction_projection",
+			estimateMessageTokens: estimateChars,
+		});
+
+		expect(JSON.stringify(result.messages)).toContain("live-image");
+		expect(result.actions).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ kind: "dropped_block" }),
+			]),
+		);
+	});
+
+	it("protects latest typed user after thinking-only messages are pruned", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "old task" },
+				{
+					role: "assistant",
+					content: [{ type: "thinking", thinking: "discard me" }],
+				},
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "what is in this image?" },
+						{
+							type: "image",
+							data: "live-image",
+							mediaType: "image/png",
+						},
+					],
+				},
+			],
+			targetTokens: 1_000,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).toContain("live-image");
+		expect(serialized).not.toContain("discard me");
+	});
+
+	it("keeps tool-use and tool-result pairs coherent when dropping history", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "original task" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool_1",
+							name: "read_files",
+							input: { file_paths: ["/tmp/a.ts"] },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool_1",
+							name: "read_files",
+							content: "x".repeat(1000),
+						},
+					],
+				},
+				{ role: "user", content: "latest task" },
+			],
+			targetTokens: 140,
+			policyIntent: "basic_compaction_projection",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).not.toContain("tool_1");
+		expect(serialized).toContain("latest task");
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ reason: "tool_pair_boundary" }),
+			]),
+		);
+	});
+
+	it("records budget action paths against original message indexes", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{
+					role: "assistant",
+					content: [{ type: "image", data: "x", mediaType: "image/png" }],
+				},
+				{ role: "user", content: "old task " + "x".repeat(500) },
+				{ role: "assistant", content: "old answer " + "y".repeat(500) },
+				{ role: "user", content: "latest task" },
+			],
+			targetTokens: 80,
+			policyIntent: "basic_compaction_projection",
+			estimateMessageTokens: estimateChars,
+		});
+
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "preserved",
+					path: expect.objectContaining({ messageIndex: 1 }),
+				}),
+				expect.objectContaining({
+					kind: "dropped_message",
+					path: expect.objectContaining({ messageIndex: 2 }),
+				}),
+			]),
+		);
+	});
+
+	it("detects the latest typed user message when tool results follow it", () => {
+		const messages: MessageWithMetadata[] = [
+			{ role: "user", content: "old task" },
+			{ role: "user", content: "latest typed prompt" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "tool_use", id: "tool_1", name: "read", input: {} },
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "read",
+						content: "result",
+					},
+				],
+			},
+		];
+
+		expect(findLatestTypedUserMessageIndex(messages)).toBe(1);
+	});
+
+	it("preserves the latest typed prompt under pressure", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "old task " + "x".repeat(500) },
+				{ role: "user", content: "latest typed prompt" },
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool_1",
+							name: "read",
+							content: "result " + "y".repeat(500),
+						},
+					],
+				},
+			],
+			targetTokens: 120,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		expect(JSON.stringify(result.messages)).toContain("latest typed prompt");
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ reason: "protected_live_tail" }),
+			]),
+		);
+	});
+
+	it("drops completed tool pairs after the latest typed prompt", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "old task " + "x".repeat(500) },
+				{ role: "user", content: "latest typed prompt" },
+				{
+					role: "assistant",
+					content: [
+						{ type: "tool_use", id: "tool_after", name: "read", input: {} },
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool_after",
+							name: "read",
+							content: "huge result " + "y".repeat(2_000),
+						},
+					],
+				},
+			],
+			targetTokens: 140,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).toContain("latest typed prompt");
+		expect(serialized).not.toContain("tool_after");
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "dropped_message",
+					reason: "tool_pair_boundary",
+					path: expect.objectContaining({ messageIndex: 2 }),
+				}),
+				expect.objectContaining({
+					kind: "dropped_message",
+					reason: "tool_pair_boundary",
+					path: expect.objectContaining({ messageIndex: 3 }),
+				}),
+			]),
+		);
+	});
+
+	it("preserves unresolved tool use after the latest typed prompt", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "old task " + "x".repeat(500) },
+				{ role: "user", content: "latest typed prompt" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool_live",
+							name: "run_command",
+							input: { command: "sleep 1" },
+						},
+					],
+				},
+			],
+			targetTokens: 80,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).toContain("latest typed prompt");
+		expect(serialized).toContain("tool_live");
+		expect(result.status).toBe("failed");
+		expect(result.warnings[0]?.code).toBe(
+			"budget_unachievable_with_protections",
+		);
+	});
+
+	it("does not preserve later text or file blocks after tool-result budget is exhausted", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "latest typed prompt" },
+				{
+					role: "assistant",
+					content: [
+						{ type: "tool_use", id: "tool_live", name: "read", input: {} },
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool_live",
+							name: "read",
+							content: [
+								{ type: "text", text: "a".repeat(200) },
+								{ type: "file", path: "/tmp/huge.txt", content: "b".repeat(1_000) },
+							],
+						},
+					],
+				},
+			],
+			targetTokens: 260,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).toContain("latest typed prompt");
+		expect(serialized).not.toContain("b".repeat(100));
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "truncated_text",
+					reason: "over_budget",
+				}),
+			]),
+		);
+	});
+
+	it("drops thinking blocks instead of mutating provider-native reasoning", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{ role: "user", content: "latest typed prompt" },
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "a".repeat(1_000) },
+						{ type: "thinking", thinking: "b".repeat(1_000) },
+					],
+				},
+			],
+			targetTokens: 900,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const assistant = result.messages.find(
+			(message) => message.role === "assistant",
+		);
+		expect(JSON.stringify(assistant)).not.toContain("b".repeat(100));
+		expect(JSON.stringify(assistant)).not.toContain("\"thinking\"");
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "dropped_block",
+					reason: "unsafe_to_truncate",
+				}),
+			]),
+		);
+	});
+
+	it("drops nested unsafe tool-result blocks outside the protected tail", () => {
+		const result = buildBudgetProjection({
+			messages: [
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool_old",
+							name: "read",
+							content: [
+								{ type: "text", text: "old output" },
+								{
+									type: "image",
+									data: "old-image-data",
+									mediaType: "image/png",
+								},
+							],
+						},
+					],
+				},
+				{ role: "user", content: "latest typed prompt" },
+			],
+			targetTokens: 1_000,
+			policyIntent: "agentic_summary",
+			estimateMessageTokens: estimateChars,
+		});
+
+		const serialized = JSON.stringify(result.messages);
+		expect(serialized).toContain("old output");
+		expect(serialized).not.toContain("old-image-data");
+		expect(result.actions).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "dropped_block",
+					reason: "unsafe_to_truncate",
+				}),
+			]),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/context/budget-projection/project.ts b/sdk/packages/core/src/extensions/context/budget-projection/project.ts
new file mode 100644
index 0000000..82cecf0
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/budget-projection/project.ts
@@ -0,0 +1,670 @@
+import type {
+	ContentBlock,
+	MessageWithMetadata,
+	ToolResultContent,
+} from "@cline/shared";
+import type {
+	BudgetAction,
+	BudgetMutationAction,
+	BudgetProjectionOptions,
+	BudgetProjectionResult,
+	BudgetProjectionWarning,
+	BudgetPolicyIntent,
+} from "./types";
+
+type EstimateMessageTokens = (message: MessageWithMetadata) => number;
+
+interface ProjectionPolicy {
+	protectLatestTypedUser: boolean;
+	protectLiveTailFromDrop: boolean;
+	dropUnsafeOutsideLiveTail: boolean;
+	dropThinkingBlocks: boolean;
+}
+
+function resolveProjectionPolicy(
+	intent: BudgetPolicyIntent,
+): ProjectionPolicy {
+	switch (intent) {
+		case "agentic_summary":
+		case "basic_compaction_projection":
+			return {
+				protectLatestTypedUser: true,
+				protectLiveTailFromDrop: true,
+				dropUnsafeOutsideLiveTail: true,
+				dropThinkingBlocks: true,
+			};
+		case "normal_provider_request":
+			return {
+				protectLatestTypedUser: true,
+				protectLiveTailFromDrop: true,
+				dropUnsafeOutsideLiveTail: false,
+				dropThinkingBlocks: false,
+			};
+	}
+}
+
+function cloneMessages(messages: MessageWithMetadata[]): MessageWithMetadata[] {
+	return messages.map((message) => ({
+		...message,
+		content: Array.isArray(message.content)
+			? message.content.map((block) => ({ ...block }) as ContentBlock)
+			: message.content,
+		...(message.metadata ? { metadata: { ...message.metadata } } : {}),
+	}));
+}
+
+function safeJsonSize(value: unknown): number {
+	try {
+		return JSON.stringify(value).length;
+	} catch {
+		return String(value).length;
+	}
+}
+
+function totalTokens(
+	messages: MessageWithMetadata[],
+	estimateMessageTokens: EstimateMessageTokens,
+): number {
+	return messages.reduce(
+		(total, message) => total + estimateMessageTokens(message),
+		0,
+	);
+}
+
+function isToolResultOnlyUserMessage(message: MessageWithMetadata): boolean {
+	return (
+		message.role === "user" &&
+		Array.isArray(message.content) &&
+		message.content.length > 0 &&
+		message.content.every((block) => block.type === "tool_result")
+	);
+}
+
+export function findLatestTypedUserMessageIndex(
+	messages: MessageWithMetadata[],
+): number {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message.role === "user" && !isToolResultOnlyUserMessage(message)) {
+			return index;
+		}
+	}
+	return -1;
+}
+
+function findFirstTypedUserMessageIndex(
+	messages: MessageWithMetadata[],
+): number {
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index];
+		if (message.role === "user" && !isToolResultOnlyUserMessage(message)) {
+			return index;
+		}
+	}
+	return -1;
+}
+
+function collectToolIds(message: MessageWithMetadata): Set<string> {
+	const ids = new Set<string>();
+	if (!Array.isArray(message.content)) {
+		return ids;
+	}
+	for (const block of message.content) {
+		if (block.type === "tool_use") {
+			ids.add(block.id);
+		} else if (block.type === "tool_result") {
+			ids.add(block.tool_use_id);
+		}
+	}
+	return ids;
+}
+
+function buildToolPairIndex(
+	messages: MessageWithMetadata[],
+): Map<string, Set<number>> {
+	const index = new Map<string, Set<number>>();
+	for (let messageIndex = 0; messageIndex < messages.length; messageIndex += 1) {
+		for (const id of collectToolIds(messages[messageIndex])) {
+			const existing = index.get(id);
+			if (existing) {
+				existing.add(messageIndex);
+			} else {
+				index.set(id, new Set([messageIndex]));
+			}
+		}
+	}
+	return index;
+}
+
+function findProtectedTailStartIndex(messages: MessageWithMetadata[]): number {
+	const resolvedToolUseIds = new Set<string>();
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const block of message.content) {
+			if (block.type === "tool_result") {
+				resolvedToolUseIds.add(block.tool_use_id);
+			}
+		}
+	}
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		if (
+			message.content.some(
+				(block) =>
+					block.type === "tool_use" && !resolvedToolUseIds.has(block.id),
+			)
+		) {
+			return index;
+		}
+	}
+	return messages.length;
+}
+
+function collectMessageClosure(
+	messages: MessageWithMetadata[],
+	startIndex: number,
+): Set<number> {
+	const pairIndex = buildToolPairIndex(messages);
+	const removal = new Set<number>();
+	const queue = [startIndex];
+	while (queue.length > 0) {
+		const index = queue.shift();
+		if (index === undefined || removal.has(index)) {
+			continue;
+		}
+		removal.add(index);
+		for (const id of collectToolIds(messages[index])) {
+			for (const linked of pairIndex.get(id) ?? []) {
+				if (!removal.has(linked)) {
+					queue.push(linked);
+				}
+			}
+		}
+	}
+	return removal;
+}
+
+function isUnsafeBlock(block: ContentBlock): boolean {
+	return block.type === "image" || block.type === "redacted_thinking";
+}
+
+function isNestedUnsafeToolResultBlock(
+	block: Extract<ToolResultContent["content"], unknown[]>[number],
+): boolean {
+	return block.type === "image";
+}
+
+function shouldDropWholeBlock(
+	block: ContentBlock,
+	policy: ProjectionPolicy,
+	isProtected: boolean,
+): boolean {
+	if (policy.dropThinkingBlocks && block.type === "thinking") {
+		return true;
+	}
+	return policy.dropUnsafeOutsideLiveTail && !isProtected && isUnsafeBlock(block);
+}
+
+function pruneEmptyMessages(
+	messages: MessageWithMetadata[],
+	originalIndexes: number[],
+	actions: BudgetAction[],
+	reason: BudgetMutationAction["reason"] = "over_budget",
+): { messages: MessageWithMetadata[]; originalIndexes: number[] } {
+	const next: MessageWithMetadata[] = [];
+	const nextOriginalIndexes: number[] = [];
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index];
+		if (Array.isArray(message.content) && message.content.length === 0) {
+				actions.push({
+					kind: "dropped_message",
+					path: { messageIndex: originalIndexes[index] },
+					reason,
+					originalSize: safeJsonSize(message),
+					finalSize: 0,
+				});
+			continue;
+		}
+		next.push(message);
+		nextOriginalIndexes.push(originalIndexes[index]);
+	}
+	return { messages: next, originalIndexes: nextOriginalIndexes };
+}
+
+function dropUnsafeBlocks(
+	messages: MessageWithMetadata[],
+	originalIndexes: number[],
+	actions: BudgetAction[],
+	latestTypedUserIndex: number,
+	protectedTailStartIndex: number,
+	policy: ProjectionPolicy,
+): MessageWithMetadata[] {
+	return messages.map((message, messageIndex) => {
+		if (!Array.isArray(message.content)) {
+			return message;
+		}
+		let changed = false;
+		const protectedBlock =
+			messageIndex === latestTypedUserIndex ||
+			messageIndex >= protectedTailStartIndex;
+		const content = message.content.flatMap((block, blockIndex) => {
+			if (shouldDropWholeBlock(block, policy, protectedBlock)) {
+				changed = true;
+				actions.push({
+					kind: "dropped_block",
+					path: { messageIndex: originalIndexes[messageIndex], blockIndex },
+					reason: "unsafe_to_truncate",
+					originalSize: safeJsonSize(block),
+					finalSize: 0,
+				});
+				return [];
+			}
+			if (block.type === "tool_result" && Array.isArray(block.content)) {
+				const nestedContent = block.content.filter((nestedBlock) => {
+					if (
+						policy.dropUnsafeOutsideLiveTail &&
+						!protectedBlock &&
+						isNestedUnsafeToolResultBlock(nestedBlock)
+					) {
+						return false;
+					}
+					return true;
+				});
+				if (nestedContent.length !== block.content.length) {
+					changed = true;
+					const nextBlock = { ...block, content: nestedContent };
+					actions.push({
+						kind: "dropped_block",
+						path: { messageIndex: originalIndexes[messageIndex], blockIndex },
+						reason: "unsafe_to_truncate",
+						originalSize: safeJsonSize(block),
+						finalSize: safeJsonSize(nextBlock),
+					});
+					return [nextBlock];
+				}
+			}
+			return [block];
+		});
+		return changed ? { ...message, content } : message;
+	});
+}
+
+function dropThinkingBlocks(
+	messages: MessageWithMetadata[],
+	originalIndexes: number[],
+	actions: BudgetAction[],
+): MessageWithMetadata[] {
+	return messages.map((message, messageIndex) => {
+		if (!Array.isArray(message.content)) {
+			return message;
+		}
+		let changed = false;
+		const content = message.content.filter((block, blockIndex) => {
+			if (block.type !== "thinking") {
+				return true;
+			}
+			changed = true;
+			actions.push({
+				kind: "dropped_block",
+				path: { messageIndex: originalIndexes[messageIndex], blockIndex },
+				reason: "unsafe_to_truncate",
+				originalSize: safeJsonSize(block),
+				finalSize: 0,
+			});
+			return false;
+		});
+		return changed ? { ...message, content } : message;
+	});
+}
+
+
+function truncateText(text: string, maxChars: number): string {
+	if (maxChars <= 0) {
+		return "";
+	}
+	if (text.length <= maxChars) {
+		return text;
+	}
+	if (maxChars <= 16) {
+		return text.slice(0, Math.max(1, maxChars));
+	}
+	const estimateMarker = `\n...[truncated ${text.length - maxChars} chars]`;
+	const keep = Math.max(1, maxChars - estimateMarker.length);
+	const marker = `\n...[truncated ${text.length - keep} chars]`;
+	return `${text.slice(0, keep)}${marker}`;
+}
+
+function truncateToolResultContent(
+	content: ToolResultContent["content"],
+	maxChars: number,
+): ToolResultContent["content"] {
+	if (typeof content === "string") {
+		return truncateText(content, maxChars);
+	}
+	let remaining = maxChars;
+	return content.map((block) => {
+		if (remaining <= 0) {
+			if (block.type === "text") {
+				return { ...block, text: "" };
+			}
+			if (block.type === "file") {
+				return { ...block, content: "" };
+			}
+			return block;
+		}
+		if (block.type === "text") {
+			const text = truncateText(block.text, remaining);
+			remaining -= text.length;
+			return { ...block, text };
+		}
+		if (block.type === "file") {
+			const content = truncateText(block.content, remaining);
+			remaining -= content.length;
+			return { ...block, content };
+		}
+		return block;
+	});
+}
+
+function toolResultTextLength(content: ToolResultContent["content"]): number {
+	if (typeof content === "string") {
+		return content.length;
+	}
+	return content.reduce((total, block) => {
+		if (block.type === "text") {
+			return total + block.text.length;
+		}
+		if (block.type === "file") {
+			return total + block.content.length;
+		}
+		return total;
+	}, 0);
+}
+
+function truncateMessageText(
+	message: MessageWithMetadata,
+	maxChars: number,
+): MessageWithMetadata {
+	if (typeof message.content === "string") {
+		return { ...message, content: truncateText(message.content, maxChars) };
+	}
+	let remaining = maxChars;
+	return {
+		...message,
+		content: message.content.map((block) => {
+			if (remaining <= 0) {
+				if (block.type === "text") {
+					return { ...block, text: "" };
+				}
+				if (block.type === "file") {
+					return { ...block, content: "" };
+				}
+				if (block.type === "tool_result") {
+					return {
+						...block,
+						content: truncateToolResultContent(block.content, 0),
+					};
+				}
+				return block;
+			}
+			if (block.type === "text") {
+				const text = truncateText(block.text, remaining);
+				remaining -= text.length;
+				return { ...block, text };
+			}
+			if (block.type === "file") {
+				const content = truncateText(block.content, remaining);
+				remaining -= content.length;
+				return { ...block, content };
+			}
+			if (block.type === "tool_result") {
+				const content = truncateToolResultContent(block.content, remaining);
+				remaining -= toolResultTextLength(content);
+				return { ...block, content };
+			}
+			return block;
+		}),
+	};
+}
+
+function hasTruncatableText(message: MessageWithMetadata): boolean {
+	if (typeof message.content === "string") {
+		return message.content.length > 0;
+	}
+	return message.content.some(
+		(block) =>
+			block.type === "text" ||
+			block.type === "file" ||
+			block.type === "tool_result",
+	);
+}
+
+function removeMessagesAt(
+	messages: MessageWithMetadata[],
+	originalIndexes: number[],
+	removal: Set<number>,
+): { messages: MessageWithMetadata[]; originalIndexes: number[] } {
+	return {
+		messages: messages.filter((_, index) => !removal.has(index)),
+		originalIndexes: originalIndexes.filter((_, index) => !removal.has(index)),
+	};
+}
+
+function closureTouchesProtectedTail(
+	closure: Set<number>,
+	protectedStartIndex: number,
+): boolean {
+	if (protectedStartIndex < 0) {
+		return false;
+	}
+	for (const removalIndex of closure) {
+		if (removalIndex >= protectedStartIndex) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function closureTouchesPinnedMessage(
+	closure: Set<number>,
+	pinnedIndex: number,
+): boolean {
+	return pinnedIndex >= 0 && closure.has(pinnedIndex);
+}
+
+export function buildBudgetProjection(
+	options: BudgetProjectionOptions,
+): BudgetProjectionResult {
+	const actions: BudgetAction[] = [];
+	const warnings: BudgetProjectionWarning[] = [];
+	const policy = resolveProjectionPolicy(options.policyIntent);
+	if (options.targetTokens <= 0) {
+		return {
+			status: "failed",
+			messages: cloneMessages(options.messages),
+			actions,
+			liveTailHandling: "preserved_out_of_band",
+			estimatedTokens: totalTokens(
+				options.messages,
+				options.estimateMessageTokens,
+			),
+			warnings: [
+				{
+					code: "budget_impossible",
+					message: "Target budget must be greater than zero.",
+				},
+			],
+		};
+	}
+
+	let messages = cloneMessages(options.messages);
+	let originalIndexes = messages.map((_, index) => index);
+	if (policy.dropThinkingBlocks) {
+		const prunedThinking = pruneEmptyMessages(
+			dropThinkingBlocks(messages, originalIndexes, actions),
+			originalIndexes,
+			actions,
+			"unsafe_to_truncate",
+		);
+		messages = prunedThinking.messages;
+		originalIndexes = prunedThinking.originalIndexes;
+	}
+	const latestTypedUserIndex = policy.protectLatestTypedUser
+		? findLatestTypedUserMessageIndex(messages)
+		: -1;
+	const protectedTailStartIndex = policy.protectLiveTailFromDrop
+		? findProtectedTailStartIndex(messages)
+		: messages.length;
+	if (policy.dropUnsafeOutsideLiveTail) {
+		const prunedUnsafe = pruneEmptyMessages(
+			dropUnsafeBlocks(
+				messages,
+				originalIndexes,
+				actions,
+				latestTypedUserIndex,
+				protectedTailStartIndex,
+				policy,
+			),
+			originalIndexes,
+			actions,
+		);
+		messages = prunedUnsafe.messages;
+		originalIndexes = prunedUnsafe.originalIndexes;
+	}
+	let estimatedTokens = totalTokens(messages, options.estimateMessageTokens);
+	if (estimatedTokens <= options.targetTokens) {
+		return {
+			status: "ok",
+			messages,
+			actions,
+			liveTailHandling:
+				actions.length > 0 ? "included_degraded" : "included_verbatim",
+			estimatedTokens,
+			warnings,
+		};
+	}
+
+	for (
+		let index = messages.length - 1;
+		index >= 0 && estimatedTokens > options.targetTokens;
+		index -= 1
+	) {
+		const latestTypedUserIndex = findLatestTypedUserMessageIndex(messages);
+		if (index === latestTypedUserIndex) {
+			continue;
+		}
+		if (
+			policy.protectLiveTailFromDrop &&
+			index >= findProtectedTailStartIndex(messages)
+		) {
+			continue;
+		}
+		if (!hasTruncatableText(messages[index])) {
+			continue;
+		}
+		const originalSize = safeJsonSize(messages[index]);
+		const charsPerToken = Math.max(
+			1,
+			originalSize /
+				Math.max(1, options.estimateMessageTokens(messages[index])),
+		);
+		const targetChars = Math.max(
+			16,
+			Math.floor(
+				(options.targetTokens * charsPerToken) /
+					Math.max(1, messages.length),
+			),
+		);
+		messages[index] = truncateMessageText(messages[index], targetChars);
+		actions.push({
+			kind: "truncated_text",
+			path: { messageIndex: originalIndexes[index] },
+			reason: "over_budget",
+			originalSize,
+			finalSize: safeJsonSize(messages[index]),
+		});
+		estimatedTokens = totalTokens(messages, options.estimateMessageTokens);
+	}
+
+	for (
+		let index = 0;
+		index < messages.length && estimatedTokens > options.targetTokens;
+	) {
+		const firstTypedUserIndex = findFirstTypedUserMessageIndex(messages);
+		const latestTypedUserIndex = findLatestTypedUserMessageIndex(messages);
+		const protectedStartIndex = policy.protectLiveTailFromDrop
+			? findProtectedTailStartIndex(messages)
+			: messages.length;
+		if (index === firstTypedUserIndex || index === latestTypedUserIndex) {
+			actions.push({
+				kind: "preserved",
+				path: { messageIndex: originalIndexes[index] },
+				reason: "protected_live_tail",
+				originalSize: safeJsonSize(messages[index]),
+				finalSize: safeJsonSize(messages[index]),
+			});
+			index += 1;
+			continue;
+		}
+		const closure = collectMessageClosure(messages, index);
+		if (closureTouchesPinnedMessage(closure, firstTypedUserIndex)) {
+			index += 1;
+			continue;
+		}
+		if (closureTouchesPinnedMessage(closure, latestTypedUserIndex)) {
+			index += 1;
+			continue;
+		}
+		if (closureTouchesProtectedTail(closure, protectedStartIndex)) {
+			index += 1;
+			continue;
+		}
+		for (const removalIndex of closure) {
+			actions.push({
+				kind: "dropped_message",
+				path: { messageIndex: originalIndexes[removalIndex] },
+				reason:
+					closure.size > 1 || collectToolIds(messages[removalIndex]).size > 0
+						? "tool_pair_boundary"
+						: "over_budget",
+				originalSize: safeJsonSize(messages[removalIndex]),
+				finalSize: 0,
+			});
+		}
+		const removed = removeMessagesAt(messages, originalIndexes, closure);
+		messages = removed.messages;
+		originalIndexes = removed.originalIndexes;
+		estimatedTokens = totalTokens(messages, options.estimateMessageTokens);
+	}
+
+	if (estimatedTokens > options.targetTokens) {
+		warnings.push({
+			code: "budget_unachievable_with_protections",
+			message:
+				"Projection could not reach budget without violating protected content.",
+		});
+		return {
+			status: "failed",
+			messages,
+			actions,
+			liveTailHandling: "included_degraded",
+			estimatedTokens,
+			warnings,
+		};
+	}
+
+	return {
+		status: "ok",
+		messages,
+		actions,
+		liveTailHandling:
+			actions.length > 0 ? "included_degraded" : "included_verbatim",
+		estimatedTokens,
+		warnings,
+	};
+}
diff --git a/sdk/packages/core/src/extensions/context/budget-projection/types.ts b/sdk/packages/core/src/extensions/context/budget-projection/types.ts
new file mode 100644
index 0000000..da6e351
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/budget-projection/types.ts
@@ -0,0 +1,103 @@
+import type { ContentBlock, MessageWithMetadata } from "@cline/shared";
+
+export type BudgetPolicyIntent =
+	| "agentic_summary"
+	| "basic_compaction_projection"
+	| "normal_provider_request";
+
+export type BudgetActionKind =
+	| "truncated_text"
+	| "dropped_block"
+	| "dropped_message"
+	| "preserved";
+
+export type BudgetActionReason =
+	| "over_budget"
+	| "unsafe_to_truncate"
+	| "tool_pair_boundary"
+	| "protected_live_tail";
+
+export type LiveTailHandling =
+	| "included_verbatim"
+	| "included_degraded"
+	| "summarized_as_context"
+	| "omitted_with_warning"
+	| "preserved_out_of_band";
+
+export type BlockBudgetClass =
+	| "text"
+	| "thinking"
+	| "tool_use"
+	| "tool_result"
+	| "unsafe_binary"
+	| "unsafe_encrypted"
+	| "opaque";
+
+export interface BudgetPath {
+	messageIndex: number;
+	blockIndex?: number;
+}
+
+interface BaseBudgetAction {
+	path: BudgetPath;
+	originalSize: number;
+	finalSize: number;
+}
+
+export type BudgetMutationAction =
+	| (BaseBudgetAction & {
+			kind: "truncated_text";
+			reason: Extract<BudgetActionReason, "over_budget">;
+	  })
+	| (BaseBudgetAction & {
+			kind: "dropped_block";
+			path: Required<BudgetPath>;
+			reason: Exclude<BudgetActionReason, "protected_live_tail">;
+	  })
+	| (BaseBudgetAction & {
+			kind: "dropped_message";
+			reason: Exclude<BudgetActionReason, "protected_live_tail">;
+	  });
+
+export interface BudgetPreservedAction extends BaseBudgetAction {
+	kind: "preserved";
+	reason: Extract<
+		BudgetActionReason,
+		"protected_live_tail" | "tool_pair_boundary"
+	>;
+}
+
+export type BudgetAction = BudgetMutationAction | BudgetPreservedAction;
+
+export type BudgetProjectionWarningCode =
+	| "budget_impossible"
+	| "budget_unachievable_with_protections";
+
+export interface BudgetProjectionWarning {
+	code: BudgetProjectionWarningCode;
+	message: string;
+	path?: BudgetPath;
+}
+
+export interface BudgetProjectionOptions {
+	messages: MessageWithMetadata[];
+	targetTokens: number;
+	policyIntent: BudgetPolicyIntent;
+	estimateMessageTokens: (message: MessageWithMetadata) => number;
+}
+
+export interface BudgetProjectionResult {
+	status: "ok" | "failed";
+	messages: MessageWithMetadata[];
+	actions: BudgetAction[];
+	liveTailHandling: LiveTailHandling;
+	estimatedTokens: number;
+	warnings: BudgetProjectionWarning[];
+}
+
+export interface ContentBlockBudgetClassification {
+	block: ContentBlock;
+	budgetClass: BlockBudgetClass;
+	canStringTruncate: boolean;
+	canDropWholeBlock: boolean;
+}
diff --git a/sdk/packages/core/src/extensions/context/compaction-shared.ts b/sdk/packages/core/src/extensions/context/compaction-shared.ts
new file mode 100644
index 0000000..6db5e71
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/compaction-shared.ts
@@ -0,0 +1,517 @@
+import type { ToolResultContent } from "@cline/llms";
+import {
+	CHARS_PER_TOKEN,
+	estimateTokens,
+	type MessageWithMetadata,
+} from "@cline/shared";
+
+export { CHARS_PER_TOKEN, estimateTokens };
+
+import type {
+	CoreCompactionContext,
+	CoreCompactionSummarizerConfig,
+} from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+
+export const DEFAULT_MAX_INPUT_TOKENS = 128_000;
+export const DEFAULT_THRESHOLD_RATIO = 0.9;
+export const DEFAULT_TARGET_RATIO = 0.7;
+export const DEFAULT_RESERVE_TOKENS = 16_384;
+export const DEFAULT_PRESERVE_RECENT_TOKENS = 20_000;
+export const DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS = 1_024;
+export const TOOL_RESULT_CHAR_LIMIT = 2_000;
+export const FILE_CONTENT_CHAR_LIMIT = 2_000;
+export const MIN_TRUNCATED_MESSAGE_TOKENS = 8;
+
+export interface FileOperationSummary {
+	readFiles: string[];
+	modifiedFiles: string[];
+}
+
+export interface CompactionSummaryMetadata {
+	kind: "compaction_summary";
+	summary: string;
+	details: FileOperationSummary;
+	tokensBefore: number;
+	generatedAt: number;
+}
+
+export type EstimateMessageTokens = (message: MessageWithMetadata) => number;
+
+export function truncateText(text: string, limit: number): string {
+	if (text.length <= limit) {
+		return text;
+	}
+	return `${text.slice(0, limit)}\n...[truncated ${text.length - limit} chars]`;
+}
+
+export function flattenToolResultContent(
+	content: ToolResultContent["content"],
+): string {
+	const truncated = truncateToolResultContentForCompaction(content);
+	if (typeof truncated === "string") {
+		return truncated;
+	}
+	return truncated
+		.map((block) => {
+			switch (block.type) {
+				case "text":
+					return block.text;
+				case "file":
+					return `<file path="${block.path}">\n${block.content}\n</file>`;
+				case "image":
+					return `[image:${block.mediaType}]`;
+				default:
+					return "";
+			}
+		})
+		.join("\n");
+}
+
+export function truncateToolResultContentForCompaction(
+	content: ToolResultContent["content"],
+): ToolResultContent["content"] {
+	if (typeof content === "string") {
+		return truncateText(content, TOOL_RESULT_CHAR_LIMIT);
+	}
+	return content.map((block) => {
+		switch (block.type) {
+			case "text":
+				return {
+					...block,
+					text: truncateText(block.text, TOOL_RESULT_CHAR_LIMIT),
+				};
+			case "file":
+				return {
+					...block,
+					content: truncateText(block.content, FILE_CONTENT_CHAR_LIMIT),
+				};
+			case "image":
+				return block;
+			default:
+				return block;
+		}
+	});
+}
+
+export function formatToolInput(input: Record<string, unknown>): string {
+	return Object.entries(input)
+		.map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+		.join(", ");
+}
+
+export function serializeMessage(message: MessageWithMetadata): string {
+	if (typeof message.content === "string") {
+		return `[${message.role === "user" ? "User" : "Bot"}]: ${message.content}`;
+	}
+	const lines: string[] = [];
+	for (const block of message.content) {
+		switch (block.type) {
+			case "text":
+				lines.push(
+					`[${message.role === "user" ? "User" : "Bot"}]: ${block.text}`,
+				);
+				break;
+			case "thinking":
+				lines.push(`[Bot thinking]: ${truncateText(block.thinking, 2_000)}`);
+				break;
+			case "redacted_thinking":
+				lines.push("[Bot thinking]: [redacted]");
+				break;
+			case "tool_use":
+				lines.push(
+					`[Bot tool calls]: ${block.name}(${formatToolInput(block.input)})`,
+				);
+				break;
+			case "tool_result":
+				lines.push(`[Tool result]: ${flattenToolResultContent(block.content)}`);
+				break;
+			case "file":
+				lines.push(
+					`[${message.role === "user" ? "User" : "Bot"} file ${block.path}]: ${truncateText(block.content, FILE_CONTENT_CHAR_LIMIT)}`,
+				);
+				break;
+			case "image":
+				lines.push(
+					`[${message.role === "user" ? "User" : "Bot"} image]: ${block.mediaType}`,
+				);
+				break;
+		}
+	}
+	return lines.join("\n");
+}
+
+export function serializeConversation(messages: MessageWithMetadata[]): string {
+	return messages.map(serializeMessage).join("\n\n").trim();
+}
+
+export function createTokenEstimator(): EstimateMessageTokens {
+	const cache = new WeakMap<object, number>();
+	return (message) => {
+		const ref = message as unknown as object;
+		const cached = cache.get(ref);
+		if (typeof cached === "number") {
+			return cached;
+		}
+		let serialized: string;
+		try {
+			serialized = JSON.stringify(message);
+		} catch {
+			serialized = serializeMessage(message);
+		}
+		const value = estimateTokens(serialized.length);
+		cache.set(ref, value);
+		return value;
+	};
+}
+
+export function isCompactionSummaryMessage(
+	message: MessageWithMetadata,
+): boolean {
+	return (
+		(message.metadata as { kind?: string } | undefined)?.kind ===
+		"compaction_summary"
+	);
+}
+
+export function getCompactionSummaryMetadata(
+	message: MessageWithMetadata,
+): CompactionSummaryMetadata | undefined {
+	if (!isCompactionSummaryMessage(message)) {
+		return undefined;
+	}
+	const metadata = message.metadata as Record<string, unknown> | undefined;
+	if (!metadata) {
+		return undefined;
+	}
+	const details = metadata.details as Record<string, unknown> | undefined;
+	return {
+		kind: "compaction_summary",
+		summary: String(metadata.summary ?? ""),
+		details: {
+			readFiles: Array.isArray(details?.readFiles)
+				? details.readFiles
+						.filter((value): value is string => typeof value === "string")
+						.map((value) => value.trim())
+						.filter((value) => value.length > 0)
+				: [],
+			modifiedFiles: Array.isArray(details?.modifiedFiles)
+				? details.modifiedFiles
+						.filter((value): value is string => typeof value === "string")
+						.map((value) => value.trim())
+						.filter((value) => value.length > 0)
+				: [],
+		},
+		tokensBefore: Number(metadata.tokensBefore ?? 0),
+		generatedAt: Number(metadata.generatedAt ?? 0),
+	};
+}
+
+export function isToolResultOnlyUserMessage(
+	message: MessageWithMetadata,
+): boolean {
+	if (message.role !== "user" || !Array.isArray(message.content)) {
+		return false;
+	}
+	return (
+		message.content.length > 0 &&
+		message.content.every((block) => block.type === "tool_result")
+	);
+}
+
+export function isTurnStartMessage(message: MessageWithMetadata): boolean {
+	return (
+		message.role === "user" &&
+		!isToolResultOnlyUserMessage(message) &&
+		!isCompactionSummaryMessage(message)
+	);
+}
+
+export function findFirstUserMessageIndex(
+	messages: MessageWithMetadata[],
+): number {
+	for (let index = 0; index < messages.length; index += 1) {
+		if (isTurnStartMessage(messages[index])) {
+			return index;
+		}
+	}
+	return -1;
+}
+
+export function findLastTurnStartIndex(
+	messages: MessageWithMetadata[],
+): number {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		if (isTurnStartMessage(messages[index])) {
+			return index;
+		}
+	}
+	return 0;
+}
+
+export function findLastAssistantIndex(
+	messages: MessageWithMetadata[],
+): number {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		if (messages[index].role === "assistant") {
+			return index;
+		}
+	}
+	return -1;
+}
+
+export function findLatestSummaryIndex(
+	messages: MessageWithMetadata[],
+): number {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		if (isCompactionSummaryMessage(messages[index])) {
+			return index;
+		}
+	}
+	return -1;
+}
+
+export function findCutIndex(
+	messages: MessageWithMetadata[],
+	preserveRecentTokens: number,
+	estimateMessageTokens: EstimateMessageTokens,
+): number {
+	const lastTurnStartIndex = findLastTurnStartIndex(messages);
+	if (lastTurnStartIndex <= 0) {
+		return 0;
+	}
+
+	let total = 0;
+	let candidate = messages.length;
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		total += estimateMessageTokens(messages[index]);
+		candidate = index;
+		if (total >= preserveRecentTokens) {
+			break;
+		}
+	}
+
+	if (candidate <= 0) {
+		return 0;
+	}
+
+	// Snap to a turn-start boundary so the cut never splits a
+	// tool_use/tool_result pair (or any other intra-turn block).
+	// Everything before the cut gets summarized; everything from
+	// the cut forward is preserved. Both halves of any pair must
+	// land on the same side or the provider will see an orphaned
+	// tool_result (or tool_use) and reject the request.
+	let cut = Math.min(candidate, lastTurnStartIndex);
+	while (cut > 0 && !isTurnStartMessage(messages[cut])) {
+		cut -= 1;
+	}
+	return cut;
+}
+
+export function collectPaths(value: unknown): string[] {
+	if (typeof value === "string" && value.trim().length > 0) {
+		return [value];
+	}
+	if (Array.isArray(value)) {
+		return value.flatMap((item) => collectPaths(item));
+	}
+	if (value && typeof value === "object") {
+		const record = value as Record<string, unknown>;
+		const paths: string[] = [];
+		for (const key of [
+			"path",
+			"file_path",
+			"target_file",
+			"new_file_path",
+			"old_file_path",
+		]) {
+			paths.push(...collectPaths(record[key]));
+		}
+		if (Array.isArray(record.files)) {
+			for (const item of record.files) {
+				if (item && typeof item === "object") {
+					paths.push(...collectPaths((item as Record<string, unknown>).path));
+				}
+			}
+		}
+		if (Array.isArray(record.file_paths)) {
+			paths.push(...collectPaths(record.file_paths));
+		}
+		return paths;
+	}
+	return [];
+}
+
+export function mergeUnique(base: string[], next: Iterable<string>): string[] {
+	const seen = new Set(base);
+	for (const value of next) {
+		const trimmed = value.trim();
+		if (!trimmed) {
+			continue;
+		}
+		seen.add(trimmed);
+	}
+	return [...seen].sort((a, b) => a.localeCompare(b));
+}
+
+export function extractFileOps(
+	messages: MessageWithMetadata[],
+): FileOperationSummary {
+	let readFiles: string[] = [];
+	let modifiedFiles: string[] = [];
+	for (const message of messages) {
+		const summaryMetadata = getCompactionSummaryMetadata(message);
+		if (summaryMetadata) {
+			readFiles = mergeUnique(readFiles, summaryMetadata.details.readFiles);
+			modifiedFiles = mergeUnique(
+				modifiedFiles,
+				summaryMetadata.details.modifiedFiles,
+			);
+			continue;
+		}
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const block of message.content) {
+			if (block.type === "file") {
+				readFiles = mergeUnique(readFiles, [block.path]);
+				continue;
+			}
+			if (block.type !== "tool_use") {
+				continue;
+			}
+			const paths = collectPaths(block.input);
+			if (block.name === "read_files") {
+				readFiles = mergeUnique(readFiles, paths);
+				continue;
+			}
+			if (block.name === "editor" || block.name === "apply_patch") {
+				modifiedFiles = mergeUnique(modifiedFiles, paths);
+			}
+		}
+	}
+	return { readFiles, modifiedFiles };
+}
+
+export function renderFilesSection(fileOps: FileOperationSummary): string {
+	const readLines =
+		fileOps.readFiles.length > 0
+			? fileOps.readFiles.map((path) => `- ${path}`).join("\n")
+			: "- none";
+	const modifiedLines =
+		fileOps.modifiedFiles.length > 0
+			? fileOps.modifiedFiles.map((path) => `- ${path}`).join("\n")
+			: "- none";
+	return `## Files\nRead:\n${readLines}\nModified:\n${modifiedLines}`;
+}
+
+export function ensureFilesSection(
+	summary: string,
+	fileOps: FileOperationSummary,
+): string {
+	if (/^## Files$/im.test(summary)) {
+		return summary.trim();
+	}
+	return `${summary.trim()}\n\n${renderFilesSection(fileOps)}`.trim();
+}
+
+export function buildSummaryRequest(options: {
+	previousSummary?: string;
+	conversationText: string;
+	fileOps: FileOperationSummary;
+}): string {
+	const parts: string[] = [
+		`Summarize this session for continuation. Be concise and factual.
+
+## Goal
+One sentence: what is being built or fixed.
+
+## State
+- Done: completed steps
+- In Progress: current work
+- Blocked: blockers or open questions
+
+## Highlights
+Key technical choices or notable findings (omit if none).
+
+## Next
+Immediate next steps.
+
+## Files
+Read: ${options.fileOps.readFiles.join(", ") || "none"}
+Edited: ${options.fileOps.modifiedFiles.join(", ") || "none"}`,
+	];
+
+	if (options.previousSummary?.trim()) {
+		parts.push(`Previous summary:\n${options.previousSummary.trim()}`);
+	}
+
+	parts.push(`Conversation:\n${options.conversationText || "(empty)"}`);
+
+	return parts.join("\n\n");
+}
+
+export function resolveSummarizerConfig(options: {
+	activeProviderConfig: ProviderConfig;
+	summarizer?: CoreCompactionSummarizerConfig;
+}): ProviderConfig {
+	const summarizer = options.summarizer;
+	const withSummarizerDefaults = (config: ProviderConfig): ProviderConfig => {
+		if (config.providerId === "openai-codex") {
+			const { maxOutputTokens: _maxOutputTokens, ...rest } = config;
+			return {
+				...rest,
+				thinking: false,
+			};
+		}
+		return {
+			...config,
+			maxOutputTokens:
+				config.maxOutputTokens ?? DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
+			thinking: false,
+		};
+	};
+	if (!summarizer) {
+		return withSummarizerDefaults(options.activeProviderConfig);
+	}
+	const baseProviderConfig =
+		summarizer.providerConfig?.providerId === summarizer.providerId
+			? summarizer.providerConfig
+			: undefined;
+	return withSummarizerDefaults({
+		...(baseProviderConfig ?? {}),
+		providerId: summarizer.providerId,
+		modelId: summarizer.modelId,
+		apiKey: summarizer.apiKey ?? baseProviderConfig?.apiKey,
+		baseUrl: summarizer.baseUrl ?? baseProviderConfig?.baseUrl,
+		headers: summarizer.headers ?? baseProviderConfig?.headers,
+		modelInfo: summarizer.modelInfo ?? baseProviderConfig?.modelInfo,
+		knownModels: summarizer.knownModels ?? baseProviderConfig?.knownModels,
+		maxOutputTokens:
+			summarizer.maxOutputTokens ?? DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
+	});
+}
+
+export function buildSummaryMessage(options: {
+	summary: string;
+	fileOps: FileOperationSummary;
+	tokensBefore: number;
+}): MessageWithMetadata {
+	return {
+		role: "user",
+		content: `Context summary:\n\n${options.summary}`,
+		metadata: {
+			kind: "compaction_summary",
+			summary: options.summary,
+			details: options.fileOps,
+			tokensBefore: options.tokensBefore,
+			generatedAt: Date.now(),
+		} satisfies CompactionSummaryMetadata,
+	};
+}
+
+export function getMaxInputTokens(
+	context: Pick<CoreCompactionContext, "maxInputTokens">,
+): number {
+	return context.maxInputTokens;
+}
diff --git a/sdk/packages/core/src/extensions/context/compaction.live.test.ts b/sdk/packages/core/src/extensions/context/compaction.live.test.ts
new file mode 100644
index 0000000..8e50d0b
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/compaction.live.test.ts
@@ -0,0 +1,346 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import type { ProviderConfig } from "@cline/llms";
+import { resolveProviderSettingsPath } from "@cline/shared/storage";
+import { describe, expect, it } from "vitest";
+import { createContextCompactionPrepareTurn } from "./compaction";
+
+interface StoredProviderSettingsLike {
+	providers?: Record<
+		string,
+		{
+			settings?: {
+				auth?: {
+					accessToken?: string;
+					accountId?: string;
+				};
+				apiKey?: string;
+			};
+		}
+	>;
+}
+
+interface LiveProviderEntryLike {
+	settings?: unknown;
+}
+
+interface ProviderTarget {
+	label: string;
+	config: ProviderConfig;
+}
+
+const LIVE_TEST_ENABLED = process.env.CORE_LIVE_COMPACTION_TESTS === "1";
+const PROVIDERS_FILE_ENV =
+	process.env.CORE_LIVE_COMPACTION_PROVIDERS_PATH ??
+	process.env.LLMS_LIVE_PROVIDERS_PATH;
+const PROVIDER_TIMEOUT_MS = Number(
+	process.env.CORE_LIVE_COMPACTION_TIMEOUT_MS ??
+		process.env.LLMS_LIVE_PROVIDER_TIMEOUT_MS ??
+		"120000",
+);
+const HUGE_TOOL_OUTPUT_CHARS = Number(
+	process.env.CORE_LIVE_COMPACTION_TOOL_OUTPUT_CHARS ?? "1100000",
+);
+
+function requireProvidersFilePath(): string {
+	if (!PROVIDERS_FILE_ENV) {
+		throw new Error(
+			"Set CORE_LIVE_COMPACTION_PROVIDERS_PATH or LLMS_LIVE_PROVIDERS_PATH before running live compaction tests.",
+		);
+	}
+	return path.resolve(PROVIDERS_FILE_ENV);
+}
+
+function readObject(input: unknown): Record<string, unknown> {
+	return input && typeof input === "object" && !Array.isArray(input)
+		? (input as Record<string, unknown>)
+		: {};
+}
+
+function readEnvValue(envName: unknown, label: string): string | undefined {
+	if (typeof envName !== "string" || envName.trim().length === 0) {
+		return undefined;
+	}
+	const value = process.env[envName]?.trim();
+	if (!value) {
+		throw new Error(
+			`${label} references unset or empty environment variable ${envName}`,
+		);
+	}
+	return value;
+}
+
+function readStringHeaders(input: unknown): Record<string, string> {
+	return Object.fromEntries(
+		Object.entries(readObject(input)).filter(
+			([, value]) => typeof value === "string",
+		),
+	) as Record<string, string>;
+}
+
+function readSavedOpenAICodexSettings():
+	| { accessToken?: string; accountId?: string }
+	| undefined {
+	const filePath = resolveProviderSettingsPath();
+	if (!existsSync(filePath)) {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(
+			readFileSync(filePath, "utf8"),
+		) as StoredProviderSettingsLike;
+		const settings = parsed.providers?.["openai-codex"]?.settings;
+		return {
+			accessToken:
+				settings?.auth?.accessToken?.trim() || settings?.apiKey?.trim(),
+			accountId: settings?.auth?.accountId?.trim(),
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+	const payload = token.split(".")[1];
+	if (!payload) {
+		return undefined;
+	}
+	try {
+		const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+		const padded = base64.padEnd(
+			base64.length + ((4 - (base64.length % 4)) % 4),
+			"=",
+		);
+		return JSON.parse(Buffer.from(padded, "base64").toString("utf8")) as Record<
+			string,
+			unknown
+		>;
+	} catch {
+		return undefined;
+	}
+}
+
+function deriveOpenAICodexAccountId(
+	accessToken: string | undefined,
+): string | undefined {
+	if (!accessToken) {
+		return undefined;
+	}
+	const payload = decodeJwtPayload(accessToken);
+	const auth = readObject(payload?.["https://api.openai.com/auth"]);
+	const authAccountId = auth.chatgpt_account_id;
+	if (typeof authAccountId === "string" && authAccountId.length > 0) {
+		return authAccountId;
+	}
+	return undefined;
+}
+
+function toLiveProviderConfig(settingsInput: unknown): ProviderConfig {
+	const settings = readObject(settingsInput);
+	const provider = settings.provider;
+	if (typeof provider !== "string" || provider.trim().length === 0) {
+		throw new Error("live provider entry must include a provider string");
+	}
+
+	const savedCodex =
+		provider === "openai-codex" ? readSavedOpenAICodexSettings() : undefined;
+	const apiKey =
+		typeof settings.apiKey === "string"
+			? settings.apiKey
+			: (readEnvValue(settings.apiKeyEnv, "apiKeyEnv") ??
+				savedCodex?.accessToken);
+	const headers = readStringHeaders(settings.headers);
+	const codexAccountId =
+		savedCodex?.accountId || deriveOpenAICodexAccountId(apiKey);
+	if (
+		provider === "openai-codex" &&
+		codexAccountId &&
+		!headers["ChatGPT-Account-Id"]
+	) {
+		headers["ChatGPT-Account-Id"] = codexAccountId;
+	}
+
+	return {
+		providerId: provider,
+		modelId: typeof settings.model === "string" ? settings.model : "default",
+		...(apiKey ? { apiKey } : {}),
+		...(typeof settings.baseUrl === "string"
+			? { baseUrl: settings.baseUrl }
+			: {}),
+		...(Object.keys(headers).length > 0 ? { headers } : {}),
+	};
+}
+
+function toTarget(label: string, settingsInput: unknown): ProviderTarget {
+	const config = toLiveProviderConfig(settingsInput);
+	return {
+		label: `${label} (${config.providerId})`,
+		config,
+	};
+}
+
+function loadProviderTargets(filePath: string): ProviderTarget[] {
+	const parsed = JSON.parse(readFileSync(filePath, "utf8")) as unknown;
+
+	if (Array.isArray(parsed)) {
+		return parsed.map((entry, index) => {
+			if (entry && typeof entry === "object" && "settings" in entry) {
+				return toTarget(
+					`index:${index}`,
+					(entry as LiveProviderEntryLike).settings,
+				);
+			}
+			return toTarget(`index:${index}`, entry);
+		});
+	}
+
+	const stored = parsed as StoredProviderSettingsLike;
+	return Object.entries(stored.providers ?? {}).map(
+		([entryKey, entryValue]) => {
+			const maybeEntry = entryValue as LiveProviderEntryLike;
+			return toTarget(entryKey, maybeEntry.settings ?? entryValue);
+		},
+	);
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	label: string,
+): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	const timeoutPromise = new Promise<T>((_, reject) => {
+		timeout = setTimeout(() => {
+			reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+		}, timeoutMs);
+	});
+
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+async function runOversizedToolResultCompaction(
+	target: ProviderTarget,
+): Promise<void> {
+	const omittedTail = "LIVE_COMPACTION_TOOL_RESULT_TAIL_MUST_NOT_SURVIVE";
+	const hugeToolOutput = "x".repeat(HUGE_TOOL_OUTPUT_CHARS) + omittedTail;
+	const messages = [
+		{
+			role: "user" as const,
+			content: "Inspect the generated report and keep only what matters.",
+		},
+		{
+			role: "assistant" as const,
+			content: [
+				{
+					type: "tool_use" as const,
+					id: "tool-live-report",
+					name: "custom_reporter",
+					input: { path: "/tmp/oversized-report.txt" },
+				},
+			],
+		},
+		{
+			role: "user" as const,
+			content: [
+				{
+					type: "tool_result" as const,
+					tool_use_id: "tool-live-report",
+					name: "tool",
+					content: [{ type: "text" as const, text: hugeToolOutput }],
+				},
+			],
+		},
+		{
+			role: "assistant" as const,
+			content: "I reviewed the report and will continue from the useful bits.",
+		},
+		{
+			role: "user" as const,
+			content: "Continue from the compacted context.",
+		},
+	];
+	const prepareTurn = createContextCompactionPrepareTurn(
+		{
+			providerId: target.config.providerId,
+			modelId: target.config.modelId,
+			providerConfig: target.config,
+			compaction: {
+				enabled: true,
+				strategy: "agentic",
+				preserveRecentTokens: 1,
+				maxInputTokens: 16_000,
+			},
+		},
+		{ mode: "manual", manualTargetRatio: 0.1 },
+	);
+	if (!prepareTurn) {
+		throw new Error("expected compaction prepareTurn to be configured");
+	}
+
+	const result = await prepareTurn({
+		agentId: "agent-live",
+		conversationId: "conv-live",
+		parentAgentId: null,
+		iteration: 1,
+		abortSignal: new AbortController().signal,
+		emitStatusNotice: undefined,
+		systemPrompt: "You are a concise coding assistant.",
+		tools: [],
+		messages,
+		apiMessages: messages,
+		model: {
+			id: target.config.modelId,
+			provider: target.config.providerId,
+			info: { id: target.config.modelId, maxInputTokens: 16_000 },
+		},
+	});
+
+	expect(result?.messages.length).toBeGreaterThan(0);
+	expect(JSON.stringify(result?.messages)).not.toContain(omittedTail);
+	expect(result?.messages[0]).toMatchObject({
+		role: "user",
+		metadata: expect.objectContaining({ kind: "compaction_summary" }),
+	});
+}
+
+describe("live agentic compaction", () => {
+	const runLive = LIVE_TEST_ENABLED ? it : it.skip;
+
+	runLive(
+		"summarizes oversized arbitrary tool results with a real provider",
+		async () => {
+			const targets = loadProviderTargets(requireProvidersFilePath());
+			if (!targets.length) {
+				throw new Error("No providers found for live compaction test.");
+			}
+
+			const failures: string[] = [];
+			for (const target of targets) {
+				try {
+					await withTimeout(
+						runOversizedToolResultCompaction(target),
+						PROVIDER_TIMEOUT_MS,
+						target.label,
+					);
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					failures.push(`${target.label}: ${message}`);
+				}
+			}
+
+			if (failures.length > 0) {
+				throw new Error(
+					`Live compaction providers failed (${failures.length}):\n${failures.join("\n")}`,
+				);
+			}
+		},
+		300_000,
+	);
+});
diff --git a/sdk/packages/core/src/extensions/context/compaction.test.ts b/sdk/packages/core/src/extensions/context/compaction.test.ts
new file mode 100644
index 0000000..4359d05
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/compaction.test.ts
@@ -0,0 +1,2560 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { MessageWithMetadata } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createSessionCompactionState } from "../../session/models/session-compaction";
+import type { CoreCompactionContext } from "../../types/config";
+import { buildAgenticSummaryInputBudget } from "./agentic-compaction";
+import { runBasicCompaction } from "./basic-compaction";
+import {
+	createCompactionStateAwarePrepareTurn,
+	createContextCompactionPrepareTurn,
+} from "./compaction";
+import {
+	createTokenEstimator,
+	estimateTokens,
+	resolveSummarizerConfig,
+	serializeMessage,
+	TOOL_RESULT_CHAR_LIMIT,
+} from "./compaction-shared";
+
+type FakeChunk = Record<string, unknown>;
+
+const createHandlerMock = vi.fn();
+
+vi.mock("@cline/llms", () => ({
+	createHandlerAsync: (config: unknown) => createHandlerMock(config),
+}));
+
+async function* streamChunks(chunks: FakeChunk[]): AsyncGenerator<FakeChunk> {
+	for (const chunk of chunks) {
+		yield chunk;
+	}
+}
+
+const estimateJsonTokens = (message: LlmsProviders.Message): number =>
+	JSON.stringify(message).length;
+
+function totalJsonTokens(messages: LlmsProviders.Message[]): number {
+	return messages.reduce(
+		(total, message) => total + estimateJsonTokens(message),
+		0,
+	);
+}
+
+describe("createTokenEstimator", () => {
+	it("does not treat cumulative request metrics as per-message token counts", () => {
+		const estimateMessageTokens = createTokenEstimator();
+		const message: MessageWithMetadata = {
+			role: "assistant",
+			content: "short",
+			metrics: {
+				inputTokens: 100,
+				cacheReadTokens: 80,
+				outputTokens: 7,
+			},
+		};
+
+		expect(estimateMessageTokens(message)).toBe(
+			Math.ceil(JSON.stringify(message).length / 3),
+		);
+	});
+
+	it("falls back to serialized character estimation when metrics are incomplete", () => {
+		const estimateMessageTokens = createTokenEstimator();
+		const message: MessageWithMetadata = {
+			role: "assistant",
+			content: "short",
+			metrics: {
+				inputTokens: 12,
+			},
+		};
+
+		expect(estimateMessageTokens(message)).toBe(
+			Math.ceil(JSON.stringify(message).length / 3),
+		);
+	});
+});
+
+function runForcedBasicCompaction(
+	messages: LlmsProviders.Message[],
+	targetTokens: number,
+): LlmsProviders.Message[] {
+	const result = runBasicCompaction({
+		context: {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			messages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: targetTokens },
+			},
+			maxInputTokens: targetTokens,
+			triggerTokens: targetTokens,
+			thresholdRatio: 1,
+			utilizationRatio: 2,
+		},
+		estimateMessageTokens: estimateJsonTokens,
+	});
+	return result?.messages ?? messages;
+}
+
+function assistantToolUseMessage(
+	id: string,
+	extraContent: LlmsProviders.ContentBlock[] = [],
+): LlmsProviders.Message {
+	return {
+		role: "assistant",
+		content: [
+			...extraContent,
+			{
+				type: "tool_use",
+				id,
+				name: "read_files",
+				input: { file_paths: [`/tmp/${id}.ts`] },
+			},
+		],
+	};
+}
+
+function assistantMultiToolUseMessage(ids: string[]): LlmsProviders.Message {
+	return {
+		role: "assistant",
+		content: ids.map((id) => ({
+			type: "tool_use",
+			id,
+			name: "read_files",
+			input: { file_paths: [`/tmp/${id}.ts`] },
+		})),
+	};
+}
+
+function toolResultMessage(
+	id: string,
+	content = "tool result",
+): LlmsProviders.Message {
+	return {
+		role: "user",
+		content: [
+			{
+				type: "tool_result",
+				tool_use_id: id,
+				name: "read_files",
+				content,
+			},
+		],
+	};
+}
+
+function collectToolPairPresence(messages: LlmsProviders.Message[]): Map<
+	string,
+	{
+		hasResult: boolean;
+		hasUse: boolean;
+	}
+> {
+	const presence = new Map<string, { hasResult: boolean; hasUse: boolean }>();
+	const ensure = (id: string) => {
+		const existing = presence.get(id);
+		if (existing) {
+			return existing;
+		}
+		const next = { hasResult: false, hasUse: false };
+		presence.set(id, next);
+		return next;
+	};
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const block of message.content) {
+			if (block.type === "tool_use") {
+				ensure(block.id).hasUse = true;
+			} else if (block.type === "tool_result") {
+				ensure(block.tool_use_id).hasResult = true;
+			}
+		}
+	}
+	return presence;
+}
+
+function expectNoOrphanedToolPairs(messages: LlmsProviders.Message[]): void {
+	for (const [id, presence] of collectToolPairPresence(messages)) {
+		expect(presence, `tool pair ${id}`).toEqual({
+			hasResult: presence.hasUse,
+			hasUse: presence.hasResult,
+		});
+	}
+}
+
+describe("createContextCompactionPrepareTurn", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("truncates text-block tool results when serializing compaction input", () => {
+		const longToolOutput = "x".repeat(TOOL_RESULT_CHAR_LIMIT + 100);
+
+		const serializedStringResult = serializeMessage({
+			role: "user",
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: "tool-1",
+					name: "tool",
+					content: longToolOutput,
+				},
+			],
+		});
+		const serializedTextBlockResult = serializeMessage({
+			role: "user",
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: "tool-1",
+					name: "tool",
+					content: [{ type: "text", text: longToolOutput }],
+				},
+			],
+		});
+
+		expect(serializedTextBlockResult).toBe(serializedStringResult);
+		expect(serializedTextBlockResult).toContain(`...[truncated 100 chars]`);
+		expect(serializedTextBlockResult.length).toBeLessThan(
+			longToolOutput.length,
+		);
+	});
+
+	it("truncates retained arbitrary tool results during basic compaction", () => {
+		const omittedTail = "TAIL_SHOULD_NOT_SURVIVE_BASIC_COMPACTION";
+		const longToolOutput =
+			"x".repeat(TOOL_RESULT_CHAR_LIMIT + 5_000) + omittedTail;
+		const result = runBasicCompaction({
+			context: {
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				parentAgentId: null,
+				iteration: 1,
+				messages: [
+					{
+						role: "assistant",
+						content: [
+							{
+								type: "tool_use",
+								id: "tool-custom",
+								name: "custom_reporter",
+								input: {},
+							},
+						],
+					},
+					{
+						role: "user",
+						content: [
+							{
+								type: "tool_result",
+								tool_use_id: "tool-custom",
+								name: "tool",
+								content: [{ type: "text", text: longToolOutput }],
+							},
+						],
+					},
+				],
+				model: {
+					id: "mock-model",
+					provider: "anthropic",
+					info: { id: "mock-model", maxInputTokens: 100_000 },
+				},
+				maxInputTokens: 100_000,
+				triggerTokens: 100_000,
+				thresholdRatio: 1,
+				utilizationRatio: 0.1,
+			},
+			estimateMessageTokens: createTokenEstimator(),
+		});
+
+		expect(result?.messages).toHaveLength(2);
+		const toolResultMessage = result?.messages[1];
+		expect(Array.isArray(toolResultMessage?.content)).toBe(true);
+		const block = Array.isArray(toolResultMessage?.content)
+			? toolResultMessage.content[0]
+			: undefined;
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result" || typeof block.content === "string") {
+			throw new Error("expected structured tool result");
+		}
+		expect(block.content[0]).toEqual(
+			expect.objectContaining({
+				type: "text",
+				text: expect.stringContaining("...[truncated"),
+			}),
+		);
+		expect(JSON.stringify(result?.messages)).not.toContain(omittedTail);
+	});
+
+	it("protects a fresh tool result from basic compaction", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Read the file" },
+			assistantToolUseMessage("tool-a"),
+			toolResultMessage("tool-a", "a".repeat(1_000)),
+		];
+		const targetTokens =
+			totalJsonTokens(messages) - estimateJsonTokens(messages[2]) + 10;
+
+		const compacted = runForcedBasicCompaction(messages, targetTokens);
+
+		expectNoOrphanedToolPairs(compacted);
+		expect(collectToolPairPresence(compacted).get("tool-a")).toEqual({
+			hasResult: true,
+			hasUse: true,
+		});
+	});
+
+	it("removes older tool pairs atomically while preserving a newer pair", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Read the files" },
+			assistantToolUseMessage("tool-a"),
+			toolResultMessage("tool-a", "a".repeat(1_000)),
+			{ role: "user", content: "Read the latest file" },
+			assistantToolUseMessage("tool-b"),
+			toolResultMessage("tool-b", "latest result"),
+		];
+		const targetTokens =
+			totalJsonTokens(messages) -
+			estimateJsonTokens(messages[1]) -
+			estimateJsonTokens(messages[2]) +
+			10;
+
+		const compacted = runForcedBasicCompaction(messages, targetTokens);
+		const pairs = collectToolPairPresence(compacted);
+
+		expectNoOrphanedToolPairs(compacted);
+		expect(pairs.get("tool-a")).toBeUndefined();
+		expect(JSON.stringify(compacted)).toContain("Read the latest file");
+	});
+
+	it("may drop the latest completed tool pair under aggressive basic compaction", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Read the files" },
+			assistantToolUseMessage("tool-a"),
+			toolResultMessage("tool-a", "a".repeat(1_000)),
+			{ role: "user", content: "Read the latest file" },
+			assistantToolUseMessage("tool-b"),
+			toolResultMessage("tool-b", "b".repeat(1_000)),
+		];
+
+		const compacted = runForcedBasicCompaction(messages, 1);
+		const pairs = collectToolPairPresence(compacted);
+
+		expectNoOrphanedToolPairs(compacted);
+		expect(pairs.get("tool-a")).toBeUndefined();
+		expect(pairs.get("tool-b")).toBeUndefined();
+		expect(JSON.stringify(compacted)).toContain("Read the latest file");
+	});
+
+	it("treats multi-tool assistant turns as one atomic group in basic compaction", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Read both old files" },
+			assistantMultiToolUseMessage(["tool-a", "tool-b"]),
+			toolResultMessage("tool-a", "a".repeat(1_000)),
+			toolResultMessage("tool-b", "b".repeat(1_000)),
+			{ role: "user", content: "Now continue" },
+		];
+		const targetTokens =
+			totalJsonTokens(messages) - estimateJsonTokens(messages[2]) + 10;
+
+		const compacted = runForcedBasicCompaction(messages, targetTokens);
+
+		expectNoOrphanedToolPairs(compacted);
+		expect(collectToolPairPresence(compacted).size).toBe(0);
+	});
+
+	it("removes matching tool results when basic compaction removes an assistant tool use", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Read and continue" },
+			assistantToolUseMessage("tool-a", [
+				{ type: "text", text: "large assistant context ".repeat(100) },
+			]),
+			toolResultMessage("tool-a", "short result"),
+			{ role: "user", content: "Latest user turn" },
+			{ role: "assistant", content: "latest assistant response" },
+		];
+		const targetTokens =
+			totalJsonTokens(messages) - estimateJsonTokens(messages[1]) + 10;
+
+		const compacted = runForcedBasicCompaction(messages, targetTokens);
+
+		expectNoOrphanedToolPairs(compacted);
+		expect(collectToolPairPresence(compacted).get("tool-a")).toBeUndefined();
+	});
+
+	it("preserves the latest typed user prompt without requiring completed tool work", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Old request" },
+			{ role: "assistant", content: "Old answer that can be compacted" },
+			{ role: "user", content: "Read the latest file" },
+			assistantToolUseMessage("tool-a"),
+			toolResultMessage("tool-a", "latest result"),
+		];
+
+		const compacted = runForcedBasicCompaction(messages, 1);
+
+		expect(compacted).toEqual([
+			{ role: "user", content: "Old request" },
+			{ role: "user", content: "Read the latest file" },
+		]);
+		expectNoOrphanedToolPairs(compacted);
+	});
+
+	it("budgets the complete basic compaction output including the latest turn", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "original task" },
+			{ role: "assistant", content: "old assistant " + "x".repeat(10_000) },
+			{ role: "user", content: "latest typed prompt" },
+			assistantToolUseMessage("tool-live"),
+			toolResultMessage("tool-live", "live result " + "y".repeat(10_000)),
+		];
+
+		const compacted = runForcedBasicCompaction(messages, 700);
+
+		expect(totalJsonTokens(compacted)).toBeLessThanOrEqual(700);
+		expect(JSON.stringify(compacted)).toContain("latest typed prompt");
+		expectNoOrphanedToolPairs(compacted);
+	});
+
+	it("does not compact a single typed user message", () => {
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Only current request" },
+		];
+
+		const compacted = runForcedBasicCompaction(messages, 1);
+
+		expect(compacted).toBe(messages);
+	});
+
+	it("does not truncate a shallow first task prompt below the trigger for high-output models", async () => {
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openrouter",
+			modelId: "minimax/minimax-m3",
+			providerConfig: {
+				providerId: "openrouter",
+				modelId: "minimax/minimax-m3",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic",
+				maxInputTokens: 1_000,
+				thresholdRatio: 0.9,
+			},
+			logger: undefined,
+		});
+		const task =
+			'<user_input mode="act">Create /app/filter.py that removes JavaScript from HTML files. ' +
+			"Keep this task prompt intact. ".repeat(25) +
+			"</user_input>";
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: task },
+			{ role: "assistant", content: "old assistant context ".repeat(500) },
+			{ role: "user", content: "Continue" },
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "minimax/minimax-m3",
+				provider: "openrouter",
+				info: {
+					id: "minimax/minimax-m3",
+					maxInputTokens: 1_000,
+					maxTokens: 950,
+				},
+			},
+		});
+
+		expect(result?.messages?.[0]?.content).toBe(task);
+		expect(JSON.stringify(result?.messages)).toContain("Create /app/filter.py");
+		expect(JSON.stringify(result?.messages)).not.toContain("<user_input\n...");
+	});
+
+	it("can truncate an oversized first task prompt when it exceeds the trigger", () => {
+		const oversizedPrompt = "<user_input>".repeat(500);
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: oversizedPrompt },
+			{ role: "assistant", content: "old assistant context ".repeat(500) },
+			{ role: "user", content: "current turn" },
+		];
+
+		const compacted = runBasicCompaction({
+			context: {
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				parentAgentId: null,
+				iteration: 1,
+				messages,
+				model: {
+					id: "mock-model",
+					provider: "openrouter",
+					info: { id: "mock-model", maxInputTokens: 1_000 },
+				},
+				maxInputTokens: 1_000,
+				triggerTokens: 900,
+				targetTokens: 100,
+				thresholdRatio: 0.9,
+				utilizationRatio: 2,
+			},
+			estimateMessageTokens: estimateJsonTokens,
+		});
+
+		expect(compacted?.messages[0]?.content).not.toBe(oversizedPrompt);
+		expect(String(compacted?.messages[0]?.content)).toContain("\n...");
+	});
+
+	it("does not add unsupported max output tokens to Codex OAuth summarizer requests", () => {
+		const codexConfig = resolveSummarizerConfig({
+			activeProviderConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.4",
+				maxOutputTokens: 16_000,
+			},
+		});
+		const anthropicConfig = resolveSummarizerConfig({
+			activeProviderConfig: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet",
+			},
+		});
+
+		expect(codexConfig).not.toHaveProperty("maxOutputTokens");
+		expect(codexConfig.thinking).toBe(false);
+		expect(anthropicConfig.maxOutputTokens).toBe(1_024);
+	});
+
+	it("preserves summarizer modelInfo without a nested providerConfig", () => {
+		const resolved = resolveSummarizerConfig({
+			activeProviderConfig: {
+				providerId: "anthropic",
+				modelId: "primary-model",
+				modelInfo: { id: "primary-model", maxInputTokens: 100_000 },
+			} as LlmsProviders.ProviderConfig,
+			summarizer: {
+				providerId: "openai",
+				modelId: "small-summary",
+				modelInfo: { id: "small-summary", maxInputTokens: 600 },
+			},
+		});
+
+		expect(resolved.modelInfo?.maxInputTokens).toBe(600);
+	});
+
+	it("summarizes older messages and keeps recent messages", async () => {
+		const emitStatusNotice = vi.fn();
+		createHandlerMock.mockReturnValue({
+			createMessage: vi.fn(() =>
+				streamChunks([
+					{
+						type: "text",
+						id: "summary-1",
+						text: "## Goal\nShip the feature\n\n## Next\n- Finish it",
+					},
+					{ type: "done", id: "summary-1", success: true },
+				]),
+			),
+		});
+
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "agentic",
+				preserveRecentTokens: 1,
+				reserveTokens: 5,
+			},
+			logger: undefined,
+		});
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			emitStatusNotice,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Old turn to compact" },
+				{ role: "assistant", content: "Old answer" },
+				{ role: "user", content: "Implement the change" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool-1",
+							name: "read_files",
+							input: { file_paths: ["/tmp/example.ts"] },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							name: "tool",
+							content: "file contents",
+						},
+					],
+				},
+				{ role: "assistant", content: "Recent assistant state" },
+			],
+			apiMessages: [
+				{ role: "user", content: "Old turn to compact" },
+				{ role: "assistant", content: "Old answer" },
+				{ role: "user", content: "Implement the change" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool-1",
+							name: "read_files",
+							input: { file_paths: ["/tmp/example.ts"] },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							name: "tool",
+							content: "file contents",
+						},
+					],
+				},
+				{ role: "assistant", content: "Recent assistant state" },
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 10 },
+			},
+		});
+
+		expect(createHandlerMock).toHaveBeenCalledTimes(1);
+		expect(emitStatusNotice).toHaveBeenCalledWith(
+			"auto-compacting",
+			expect.objectContaining({
+				kind: "auto_compaction",
+				reason: "auto_compaction",
+				iteration: 1,
+			}),
+		);
+		expect(result?.messages).toHaveLength(5);
+		expect(result?.messages[0]).toMatchObject({
+			role: "user",
+			metadata: expect.objectContaining({
+				kind: "compaction_summary",
+				details: {
+					readFiles: [],
+					modifiedFiles: [],
+				},
+			}),
+		});
+		expect(typeof result?.messages[0]?.content).toBe("string");
+		const summaryContent = result?.messages[0]?.content as string;
+		expect(summaryContent).toContain("Context summary:");
+		expect(summaryContent).toContain("## Files");
+		expect(result?.messages[1]).toEqual({
+			role: "user",
+			content: "Implement the change",
+		});
+		expect(result?.messages[4]).toEqual({
+			role: "assistant",
+			content: "Recent assistant state",
+		});
+	});
+
+	it("sends truncated text-block tool results to the agentic summarizer", async () => {
+		const createMessage = vi.fn(() =>
+			streamChunks([
+				{
+					type: "text",
+					id: "summary-tool-output",
+					text: "## Goal\nSummarized tool output\n\n## Next\nContinue",
+				},
+				{ type: "done", id: "summary-tool-output", success: true },
+			]),
+		);
+		createHandlerMock.mockReturnValue({ createMessage });
+		const omittedTail = "TAIL_SHOULD_NOT_REACH_SUMMARIZER";
+		const longToolOutput =
+			"x".repeat(TOOL_RESULT_CHAR_LIMIT + 10_000) + omittedTail;
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "agentic",
+				preserveRecentTokens: 1,
+				reserveTokens: 5,
+			},
+			logger: undefined,
+		});
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Run a large command" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool-large",
+							name: "execute_command",
+							input: { command: "print-large-output" },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-large",
+							name: "tool",
+							content: [{ type: "text", text: longToolOutput }],
+						},
+					],
+				},
+				{ role: "assistant", content: "Observed large output" },
+				{ role: "user", content: "Latest request" },
+				{ role: "assistant", content: "Latest answer" },
+			],
+			apiMessages: [
+				{ role: "user", content: "Run a large command" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool-large",
+							name: "execute_command",
+							input: { command: "print-large-output" },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-large",
+							name: "tool",
+							content: [{ type: "text", text: longToolOutput }],
+						},
+					],
+				},
+				{ role: "assistant", content: "Observed large output" },
+				{ role: "user", content: "Latest request" },
+				{ role: "assistant", content: "Latest answer" },
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 10 },
+			},
+		});
+
+		expect(createMessage).toHaveBeenCalledTimes(1);
+		const createMessageCalls = createMessage.mock.calls as unknown as [
+			string,
+			Array<{ role: string; content: string }>,
+		][];
+		const summarizerMessages = createMessageCalls[0]?.[1];
+		const summarizerPrompt = summarizerMessages?.[0]?.content ?? "";
+		expect(summarizerPrompt).toContain("[Tool result]");
+		expect(summarizerPrompt).toContain("...[truncated ");
+		expect(summarizerPrompt).not.toContain(omittedTail);
+		expect(summarizerPrompt.length).toBeLessThan(longToolOutput.length);
+	});
+
+	it("budgets agentic summary input before serialization", () => {
+		const result = buildAgenticSummaryInputBudget({
+			messages: [
+				{ role: "user", content: "Run a large command" },
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "tool-large",
+							name: "execute_command",
+							input: { command: "print-large-output" },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-large",
+							name: "execute_command",
+							content: "x".repeat(50_000),
+						},
+					],
+				},
+				{ role: "user", content: "Latest typed prompt" },
+			],
+			targetTokens: 400,
+			estimateMessageTokens: estimateJsonTokens,
+		});
+
+		expect(result.estimatedTokens).toBeLessThanOrEqual(400);
+		expect(JSON.stringify(result.messages)).toContain("Latest typed prompt");
+		expect(result.actions.length).toBeGreaterThan(0);
+	});
+
+	it("never lands the agentic cut in the middle of a tool pair", async () => {
+		// Repro for the "No tool call found for function call output" provider
+		// error: findCutIndex used to walk back by token budget and could land
+		// between an assistant tool_use and its matching user tool_result,
+		// leaving the tool_result in the preserved tail while the tool_use was
+		// folded into the summary.
+		createHandlerMock.mockReturnValue({
+			createMessage: vi.fn(() =>
+				streamChunks([
+					{
+						type: "text",
+						id: "summary-pair",
+						text: "## Goal\nDescribed earlier work\n\n## Next\nContinue",
+					},
+					{ type: "done", id: "summary-pair", success: true },
+				]),
+			),
+		});
+
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "agentic",
+				// A tiny preserve budget so findCutIndex's natural candidate
+				// would land at the most recent message (the tool_result),
+				// splitting the pair before the snap-to-turn-start fix.
+				preserveRecentTokens: 1,
+				reserveTokens: 5,
+			},
+			logger: undefined,
+		});
+
+		const heavyToolOutput = "x".repeat(1_500);
+		const sharedMessages = [
+			{ role: "user" as const, content: "Old turn to summarize" },
+			{ role: "assistant" as const, content: "Old reply" },
+			{ role: "user" as const, content: "Read the file" },
+			{
+				role: "assistant" as const,
+				content: [
+					{
+						type: "tool_use" as const,
+						id: "tool-pair",
+						name: "read_files",
+						input: { file_paths: ["/tmp/x.ts"] },
+					},
+				],
+			},
+			{
+				role: "user" as const,
+				content: [
+					{
+						type: "tool_result" as const,
+						tool_use_id: "tool-pair",
+						name: "tool",
+						content: heavyToolOutput,
+					},
+				],
+			},
+			{ role: "user" as const, content: "Now do the next thing" },
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: sharedMessages,
+			apiMessages: sharedMessages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 10 },
+			},
+		});
+
+		expect(result?.messages).toBeDefined();
+		const messages = result?.messages ?? [];
+		const toolUseIds = new Set<string>();
+		const toolResultIds = new Set<string>();
+		for (const msg of messages) {
+			if (!Array.isArray(msg.content)) continue;
+			for (const block of msg.content) {
+				if (block.type === "tool_use") toolUseIds.add(block.id);
+				if (block.type === "tool_result") toolResultIds.add(block.tool_use_id);
+			}
+		}
+		// Either both halves of the pair are in the preserved tail, or both
+		// are folded into the summary. Never one without the other.
+		for (const id of toolUseIds) {
+			expect(toolResultIds.has(id)).toBe(true);
+		}
+		for (const id of toolResultIds) {
+			expect(toolUseIds.has(id)).toBe(true);
+		}
+	});
+
+	it("uses the configured summarizer model for compaction", async () => {
+		createHandlerMock.mockReturnValue({
+			createMessage: vi.fn(() =>
+				streamChunks([
+					{ type: "text", id: "summary-3", text: "## Goal\nSummarized" },
+					{ type: "done", id: "summary-3", success: true },
+				]),
+			),
+		});
+
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "primary-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "primary-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "agentic",
+				preserveRecentTokens: 1,
+				reserveTokens: 5,
+				summarizer: {
+					providerId: "openai",
+					modelId: "gpt-summary",
+					maxOutputTokens: 512,
+				},
+			},
+			logger: undefined,
+		});
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Old turn" },
+				{ role: "assistant", content: "Old answer" },
+				{ role: "user", content: "Latest turn" },
+				{ role: "assistant", content: "Latest answer" },
+			],
+			apiMessages: [
+				{ role: "user", content: "Old turn" },
+				{ role: "assistant", content: "Old answer" },
+				{ role: "user", content: "Latest turn" },
+				{ role: "assistant", content: "Latest answer" },
+			],
+			model: {
+				id: "primary-model",
+				provider: "anthropic",
+				info: { id: "primary-model", maxInputTokens: 10 },
+			},
+		});
+
+		expect(createHandlerMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "openai",
+				modelId: "gpt-summary",
+				maxOutputTokens: 512,
+				thinking: false,
+			}),
+		);
+	});
+
+	it("budgets agentic summary input against the configured summarizer context window", async () => {
+		let summaryRequest = "";
+		createHandlerMock.mockReturnValue({
+			createMessage: vi.fn((_system: string, messages: LlmsProviders.Message[]) => {
+				summaryRequest = String(messages[0]?.content ?? "");
+				return streamChunks([
+					{ type: "text", id: "summary-small", text: "## Goal\nSummarized" },
+					{ type: "done", id: "summary-small", success: true },
+				]);
+			}),
+		});
+
+		const summarizerLimit = 600;
+		const oversizedAssistant = "assistant details ".repeat(5_000);
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "primary-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "primary-model",
+				modelInfo: { id: "primary-model", maxInputTokens: 10_000 },
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "agentic",
+				preserveRecentTokens: 1,
+				reserveTokens: 5,
+				summarizer: {
+					providerId: "openai",
+					modelId: "small-summary",
+					modelInfo: {
+						id: "small-summary",
+						maxInputTokens: summarizerLimit,
+					},
+				},
+			},
+			logger: undefined,
+		});
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Old request" },
+				{ role: "assistant", content: oversizedAssistant },
+				{ role: "user", content: "Latest turn" },
+				{ role: "assistant", content: "Latest answer" },
+			],
+			apiMessages: [
+				{ role: "user", content: "Old request" },
+				{ role: "assistant", content: oversizedAssistant },
+				{ role: "user", content: "Latest turn" },
+				{ role: "assistant", content: "Latest answer" },
+			],
+			model: {
+				id: "primary-model",
+				provider: "anthropic",
+				info: { id: "primary-model", maxInputTokens: 10_000 },
+			},
+		});
+
+		expect(createHandlerMock).toHaveBeenCalledTimes(1);
+		expect(estimateTokens(summaryRequest.length)).toBeLessThanOrEqual(
+			summarizerLimit,
+		);
+		expect(summaryRequest).not.toContain(oversizedAssistant);
+	});
+
+	it("uses basic compaction without calling the summarizer", async () => {
+		const emitStatusNotice = vi.fn();
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic",
+				reserveTokens: 5,
+			},
+			logger: undefined,
+		});
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			emitStatusNotice,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Initial request that should survive" },
+				{
+					role: "assistant",
+					content: [
+						{ type: "thinking", thinking: "internal reasoning" },
+						{ type: "text", text: "Older assistant explanation" },
+						{
+							type: "tool_use",
+							id: "tool-1",
+							name: "read_files",
+							input: { file_paths: ["/tmp/example.ts"] },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							name: "tool",
+							content: "tool output that should be removed",
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "Most recent user turn" },
+						{
+							type: "image",
+							data: "abc",
+							mediaType: "image/png",
+						},
+					],
+				},
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "Most recent assistant reply" },
+						{
+							type: "file",
+							path: "/tmp/out.ts",
+							content: "export const value = 1;",
+						},
+					],
+				},
+			],
+			apiMessages: [
+				{ role: "user", content: "Initial request that should survive" },
+				{
+					role: "assistant",
+					content: [
+						{ type: "thinking", thinking: "internal reasoning" },
+						{ type: "text", text: "Older assistant explanation" },
+						{
+							type: "tool_use",
+							id: "tool-1",
+							name: "read_files",
+							input: { file_paths: ["/tmp/example.ts"] },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							name: "tool",
+							content: "tool output that should be removed",
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "Most recent user turn" },
+						{
+							type: "image",
+							data: "abc",
+							mediaType: "image/png",
+						},
+					],
+				},
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "Most recent assistant reply" },
+						{
+							type: "file",
+							path: "/tmp/out.ts",
+							content: "export const value = 1;",
+						},
+					],
+				},
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 10 },
+			},
+		});
+
+		expect(createHandlerMock).not.toHaveBeenCalled();
+		expect(emitStatusNotice).toHaveBeenCalledWith(
+			"auto-compacting",
+			expect.objectContaining({
+				kind: "auto_compaction",
+				reason: "auto_compaction",
+			}),
+		);
+		expect(result?.messages).toBeDefined();
+		expect(result?.messages.length).toBeGreaterThan(0);
+		// Compacted messages should not contain tool_result content that was pruned.
+		for (const message of result?.messages ?? []) {
+			if (typeof message.content === "string") {
+				expect(message.content).not.toContain(
+					"tool output that should be removed",
+				);
+			} else {
+				for (const block of message.content) {
+					if (block.type === "text") {
+						expect(block.text).not.toContain(
+							"tool output that should be removed",
+						);
+					}
+				}
+			}
+		}
+	});
+
+	it("uses the default reserve when no trigger is configured", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [{ role: "user" as const, content: "Compacted by reserve" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, compact },
+			logger: undefined,
+		});
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "x".repeat(340) },
+				{ role: "assistant", content: "y".repeat(340) },
+			],
+			apiMessages: [
+				{ role: "user", content: "x".repeat(340) },
+				{ role: "assistant", content: "y".repeat(340) },
+			],
+			model: {
+				id: "mock-model",
+				provider: "openai-codex",
+				info: { id: "mock-model", maxInputTokens: 200 },
+			},
+		});
+
+		expect(createHandlerMock).not.toHaveBeenCalled();
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.triggerTokens).toBe(0);
+		expect(result?.messages).toEqual([
+			{ role: "user", content: "Compacted by reserve" },
+		]);
+	});
+
+	it("caps the default trigger at 90 percent of the context window", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [{ role: "user" as const, content: "Compacted by ratio" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "gpt-5.4-mini",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.4-mini",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, compact },
+			logger: undefined,
+		});
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "x".repeat(365_000) },
+				{ role: "assistant", content: "y".repeat(365_000) },
+			],
+			apiMessages: [
+				{ role: "user", content: "x".repeat(365_000) },
+				{ role: "assistant", content: "y".repeat(365_000) },
+			],
+			model: {
+				id: "gpt-5.4-mini",
+				provider: "openai-codex",
+				info: { id: "gpt-5.4-mini", maxInputTokens: 200_000 },
+			},
+		});
+
+		expect(createHandlerMock).not.toHaveBeenCalled();
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.triggerTokens).toBe(180_000);
+		expect(context?.thresholdRatio).toBe(0.9);
+		expect(result?.messages).toEqual([
+			{ role: "user", content: "Compacted by ratio" },
+		]);
+	});
+
+	it("does not subtract model max output tokens from an explicit input budget", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [
+				{ role: "user" as const, content: "Compacted by input budget" },
+			],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "gpt-5.4-mini",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.4-mini",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, maxInputTokens: 200_000, compact },
+			logger: undefined,
+		});
+		const messages: MessageWithMetadata[] = [
+			{
+				role: "user",
+				content: "large prompt ".repeat(20_000),
+			},
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "gpt-5.4-mini",
+				provider: "openai-codex",
+				info: {
+					id: "gpt-5.4-mini",
+					maxInputTokens: 200_000,
+					maxTokens: 128_000,
+				},
+			},
+		});
+
+		expect(compact).not.toHaveBeenCalled();
+		expect(result).toBeUndefined();
+	});
+
+	it("targets basic compaction at half the input budget for long conversations", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [
+				{ role: "user" as const, content: "Compacted by target budget" },
+			],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "gpt-5.5",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.5",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, strategy: "basic", compact },
+			logger: undefined,
+		});
+		const messages: MessageWithMetadata[] = [
+			{ role: "user", content: "turn 1" },
+			{ role: "assistant", content: "answer 1" },
+			{ role: "user", content: "turn 2" },
+			{ role: "assistant", content: "answer 2" },
+			{ role: "user", content: "turn 3" },
+			{ role: "assistant", content: "answer 3" },
+			{ role: "user", content: "turn 4" },
+			{ role: "assistant", content: "answer 4" },
+			{ role: "user", content: "turn 5" },
+			{ role: "assistant", content: "answer 5" },
+			{ role: "user", content: "large prompt ".repeat(70_000) },
+		];
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "gpt-5.5",
+				provider: "openai-codex",
+				info: {
+					id: "gpt-5.5",
+					maxInputTokens: 272_000,
+					maxTokens: 128_000,
+				},
+			},
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.triggerTokens).toBe(244_800);
+		expect(context?.targetTokens).toBe(136_000);
+	});
+
+	it("keeps the long-conversation target below low custom trigger thresholds", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [
+				{ role: "user" as const, content: "Compacted by low threshold" },
+			],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic",
+				thresholdRatio: 0.4,
+				compact,
+			},
+			logger: undefined,
+		});
+		const messages: MessageWithMetadata[] = [
+			{ role: "user", content: "turn 1" },
+			{ role: "assistant", content: "answer 1" },
+			{ role: "user", content: "turn 2" },
+			{ role: "assistant", content: "answer 2" },
+			{ role: "user", content: "turn 3" },
+			{ role: "assistant", content: "answer 3" },
+			{ role: "user", content: "turn 4" },
+			{ role: "assistant", content: "answer 4" },
+			{ role: "user", content: "turn 5" },
+			{ role: "assistant", content: "answer 5" },
+			{ role: "user", content: "large prompt ".repeat(20) },
+		];
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: {
+					id: "mock-model",
+					maxInputTokens: 100,
+					maxTokens: 20,
+				},
+			},
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.triggerTokens).toBe(40);
+		expect(context?.targetTokens).toBe(39);
+	});
+
+	it("derives input budget by reserving model max output tokens from context window", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [
+				{ role: "user" as const, content: "Compacted by derived input budget" },
+			],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "gpt-5.5",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.5",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, compact },
+			logger: undefined,
+		});
+		const messages: MessageWithMetadata[] = [
+			{
+				role: "user",
+				content: "large prompt ".repeat(60_000),
+			},
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "gpt-5.5",
+				provider: "openai-codex",
+				info: {
+					id: "gpt-5.5",
+					contextWindow: 400_000,
+					maxTokens: 128_000,
+				},
+			},
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.maxInputTokens).toBe(272_000);
+		expect(context?.triggerTokens).toBe(244_800);
+		expect(context?.thresholdRatio).toBe(0.9);
+		expect(result?.messages).toEqual([
+			{ role: "user", content: "Compacted by derived input budget" },
+		]);
+	});
+
+	it("uses the lower split input budget when it is below context-derived input budget", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [
+				{ role: "user" as const, content: "Compacted by split input" },
+			],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "gpt-5.5",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.5",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, compact },
+			logger: undefined,
+		});
+		const messages: MessageWithMetadata[] = [
+			{
+				role: "user",
+				content: "large prompt ".repeat(60_000),
+			},
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "gpt-5.5",
+				provider: "openai-codex",
+				info: {
+					id: "gpt-5.5",
+					contextWindow: 400_000,
+					maxInputTokens: 200_000,
+					maxTokens: 128_000,
+				},
+			},
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.maxInputTokens).toBe(200_000);
+		expect(context?.triggerTokens).toBe(180_000);
+		expect(context?.thresholdRatio).toBe(0.9);
+		expect(result?.messages).toEqual([
+			{ role: "user", content: "Compacted by split input" },
+		]);
+	});
+
+	it("falls back to the default trigger when model max output cannot derive a lower input budget", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [{ role: "user" as const, content: "Compacted by fallback" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "large-output-model",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "large-output-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, maxInputTokens: 200_000, compact },
+			logger: undefined,
+		});
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [{ role: "user", content: "small prompt" }],
+			apiMessages: [{ role: "user", content: "small prompt" }],
+			model: {
+				id: "large-output-model",
+				provider: "openai-codex",
+				info: {
+					id: "large-output-model",
+					maxInputTokens: 200_000,
+					contextWindow: 200_000,
+					maxTokens: 200_000,
+				},
+			},
+		});
+
+		expect(compact).not.toHaveBeenCalled();
+		expect(result).toBeUndefined();
+	});
+
+	it("does not collapse context-only input budget when output is nearly the full context", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [{ role: "user" as const, content: "Compacted by fallback" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openrouter",
+			modelId: "minimax/minimax-m3",
+			providerConfig: {
+				providerId: "openrouter",
+				modelId: "minimax/minimax-m3",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, strategy: "basic", compact },
+			logger: undefined,
+		});
+		const messages: MessageWithMetadata[] = [
+			{
+				role: "user",
+				content: "regex prompt ".repeat(2_000),
+			},
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "minimax/minimax-m3",
+				provider: "openrouter",
+				info: {
+					id: "minimax/minimax-m3",
+					contextWindow: 524_288,
+					maxTokens: 512_000,
+				},
+			},
+		});
+
+		expect(compact).not.toHaveBeenCalled();
+		expect(result).toBeUndefined();
+	});
+
+	it("triggers compaction from provider-sized tool result payloads", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [
+				{ role: "user" as const, content: "Compacted provider payload" },
+			],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "gpt-5.4-mini",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "gpt-5.4-mini",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, compact },
+			logger: undefined,
+		});
+		const largeToolResult = "x".repeat(800_000);
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Read a large file" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool-large",
+						name: "read_files",
+						input: { file_paths: ["/tmp/large.txt"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool-large",
+						name: "tool",
+						content: [{ type: "text", text: largeToolResult }],
+					},
+				],
+			},
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "gpt-5.4-mini",
+				provider: "openai-codex",
+				info: { id: "gpt-5.4-mini", maxInputTokens: 272_000 },
+			},
+		});
+
+		expect(createHandlerMock).not.toHaveBeenCalled();
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.triggerTokens).toBe(244_800);
+		expect(context?.utilizationRatio).toBeGreaterThan(0.9);
+		expect(result?.messages).toEqual([
+			{ role: "user", content: "Compacted provider payload" },
+		]);
+	});
+
+	it("honors an explicit threshold ratio when reserveTokens is not configured", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [{ role: "user" as const, content: "Compacted explicitly" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, thresholdRatio: 0.95, compact },
+			logger: undefined,
+		});
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Short request" },
+				{ role: "assistant", content: "Short reply" },
+			],
+			apiMessages: [
+				{ role: "user", content: "Short request" },
+				{ role: "assistant", content: "Short reply" },
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(createHandlerMock).not.toHaveBeenCalled();
+		expect(compact).not.toHaveBeenCalled();
+		expect(result).toBeUndefined();
+	});
+
+	it("manual mode forces compaction below the auto threshold", async () => {
+		const compact = vi.fn((_context: CoreCompactionContext) => ({
+			messages: [{ role: "user" as const, content: "Compacted manually" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn(
+			{
+				providerId: "anthropic",
+				modelId: "mock-model",
+				providerConfig: {
+					providerId: "anthropic",
+					modelId: "mock-model",
+				} as LlmsProviders.ProviderConfig,
+				compaction: {
+					enabled: true,
+					thresholdRatio: 0.95,
+					compact,
+				},
+				logger: undefined,
+			},
+			{ mode: "manual" },
+		);
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Short request" },
+				{ role: "assistant", content: "Short reply" },
+			],
+			apiMessages: [
+				{ role: "user", content: "Short request" },
+				{ role: "assistant", content: "Short reply" },
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		const context = compact.mock.calls[0]?.[0];
+		expect(context?.maxInputTokens).toBe(100);
+		expect(context?.triggerTokens).toBeLessThan(95);
+		expect(result?.messages).toEqual([
+			{ role: "user", content: "Compacted manually" },
+		]);
+	});
+
+	it("manual mode lowers the agentic preserve budget below the default floor", async () => {
+		createHandlerMock.mockReturnValue({
+			createMessage: vi.fn(() =>
+				streamChunks([
+					{
+						type: "text",
+						id: "summary-manual",
+						text: "## Goal\nManual compact\n\n## Next\nContinue",
+					},
+					{ type: "done", id: "summary-manual", success: true },
+				]),
+			),
+		});
+		const repeatedText = "manual compact content ".repeat(100);
+		const prepareTurn = createContextCompactionPrepareTurn(
+			{
+				providerId: "anthropic",
+				modelId: "mock-model",
+				providerConfig: {
+					providerId: "anthropic",
+					modelId: "mock-model",
+				} as LlmsProviders.ProviderConfig,
+				compaction: {
+					enabled: true,
+					strategy: "agentic",
+				},
+				logger: undefined,
+			},
+			{ mode: "manual" },
+		);
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: `Old request ${repeatedText}` },
+				{ role: "assistant", content: `Old reply ${repeatedText}` },
+				{ role: "user", content: `Latest request ${repeatedText}` },
+				{ role: "assistant", content: `Latest reply ${repeatedText}` },
+			],
+			apiMessages: [
+				{ role: "user", content: `Old request ${repeatedText}` },
+				{ role: "assistant", content: `Old reply ${repeatedText}` },
+				{ role: "user", content: `Latest request ${repeatedText}` },
+				{ role: "assistant", content: `Latest reply ${repeatedText}` },
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 10_000 },
+			},
+		});
+
+		expect(createHandlerMock).toHaveBeenCalledTimes(1);
+		expect(result?.messages[0]).toMatchObject({
+			role: "user",
+			metadata: expect.objectContaining({
+				kind: "compaction_summary",
+			}),
+		});
+		expect(result?.messages.length).toBeLessThan(4);
+	});
+
+	it("drops old user image blocks during basic compaction sanitization", () => {
+		const messages: LlmsProviders.Message[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "  Older user turn  " },
+					{ type: "image", data: "abc", mediaType: "image/png" },
+				],
+			},
+			{ role: "assistant", content: "Older assistant response" },
+			{ role: "user", content: "Latest user turn" },
+		];
+
+		const result = runBasicCompaction({
+			context: {
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				parentAgentId: null,
+				iteration: 1,
+				messages,
+				model: {
+					id: "mock-model",
+					provider: "anthropic",
+					info: { id: "mock-model", maxInputTokens: 100 },
+				},
+				maxInputTokens: 100,
+				triggerTokens: 100,
+				thresholdRatio: 1,
+				utilizationRatio: 0.1,
+			},
+			estimateMessageTokens: createTokenEstimator(),
+		});
+
+		expect(result?.messages).toBeDefined();
+		expect(result?.messages[0]?.content).toEqual([
+			{ type: "text", text: "Older user turn" },
+		]);
+		expect(result?.messages.at(-1)).toEqual({
+			role: "user",
+			content: "Latest user turn",
+		});
+	});
+
+	it("does not compact when only pre-truncation messages exceed the threshold", async () => {
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				thresholdRatio: 0.8,
+			},
+			logger: undefined,
+		});
+		expect(prepareTurn).toBeDefined();
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: [
+				{ role: "user", content: "Initial request" },
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							name: "tool",
+							content: "x".repeat(1000),
+						},
+					],
+				},
+			],
+			apiMessages: [
+				{ role: "user", content: "Initial request" },
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "tool-1",
+							name: "tool",
+							content: "x".repeat(100),
+						},
+					],
+				},
+			],
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(createHandlerMock).not.toHaveBeenCalled();
+		expect(result).toBeUndefined();
+	});
+
+	// ------------------------------------------------------------------
+	// Telemetry coverage — task.compaction_executed / task.compaction_skipped
+	// ------------------------------------------------------------------
+
+	it("emits task.compaction_executed telemetry after a successful basic compaction", async () => {
+		const captureCalls: Array<{
+			event: string;
+			properties?: Record<string, unknown>;
+		}> = [];
+		const telemetry = {
+			capture: (call: {
+				event: string;
+				properties?: Record<string, unknown>;
+			}) => captureCalls.push(call),
+			captureRequired: () => {},
+			setDistinctId: () => {},
+			updateCommonProperties: () => {},
+			identify: () => {},
+		} as unknown as Parameters<
+			typeof createContextCompactionPrepareTurn
+		>[0]["telemetry"];
+
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic",
+				reserveTokens: 1,
+			},
+			telemetry,
+			sessionId: "ulid-test-1",
+		});
+
+		const filler = "x".repeat(200);
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Original task" },
+			{ role: "assistant", content: `Old answer ${filler}` },
+			{ role: "user", content: `Older user followup ${filler}` },
+			{ role: "assistant", content: `Older assistant ${filler}` },
+			{ role: "user", content: "Latest user question" },
+		];
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(result?.messages).toBeDefined();
+		const executed = captureCalls.find(
+			(call) => call.event === "task.compaction_executed",
+		);
+		expect(executed).toBeDefined();
+		const props = executed?.properties as Record<string, unknown>;
+		expect(props.strategy).toBe("basic");
+		expect(props.mode).toBe("auto");
+		expect(props.ulid).toBe("ulid-test-1");
+		expect(props.provider).toBe("anthropic");
+		expect(props.modelId).toBe("mock-model");
+		expect(props.agentId).toBe("agent-1");
+		expect(props.conversationId).toBe("conv-1");
+		expect(typeof props.durationMs).toBe("number");
+		expect(typeof props.tokensBefore).toBe("number");
+		expect(typeof props.tokensAfter).toBe("number");
+		expect(props.messagesBefore).toBe(messages.length);
+		expect(typeof props.messagesAfter).toBe("number");
+		expect(props.tokensSaved).toBe(
+			(props.tokensBefore as number) - (props.tokensAfter as number),
+		);
+	});
+
+	it("marks strategy as 'custom' when a user-supplied compact callback is used", async () => {
+		const captureCalls: Array<{
+			event: string;
+			properties?: Record<string, unknown>;
+		}> = [];
+		const telemetry = {
+			capture: (call: {
+				event: string;
+				properties?: Record<string, unknown>;
+			}) => captureCalls.push(call),
+			captureRequired: () => {},
+			setDistinctId: () => {},
+			updateCommonProperties: () => {},
+			identify: () => {},
+		} as unknown as Parameters<
+			typeof createContextCompactionPrepareTurn
+		>[0]["telemetry"];
+
+		const customCompact = vi.fn(async () => ({
+			messages: [
+				{ role: "user", content: "trimmed" },
+			] as LlmsProviders.Message[],
+		}));
+
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic", // ignored when `compact` is provided
+				reserveTokens: 1,
+				compact: customCompact,
+			},
+			telemetry,
+		});
+
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Original task" },
+			{ role: "assistant", content: "x".repeat(500) },
+			{ role: "user", content: "Latest" },
+		];
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 2,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(customCompact).toHaveBeenCalledTimes(1);
+		const executed = captureCalls.find(
+			(call) => call.event === "task.compaction_executed",
+		);
+		expect(executed).toBeDefined();
+		expect((executed?.properties as Record<string, unknown>).strategy).toBe(
+			"custom",
+		);
+	});
+
+	it("accounts executed compaction telemetry against compaction messages", async () => {
+		const captureCalls: Array<{
+			event: string;
+			properties?: Record<string, unknown>;
+		}> = [];
+		const telemetry = {
+			capture: (call: {
+				event: string;
+				properties?: Record<string, unknown>;
+			}) => captureCalls.push(call),
+			captureRequired: () => {},
+			setDistinctId: () => {},
+			updateCommonProperties: () => {},
+			identify: () => {},
+		} as unknown as Parameters<
+			typeof createContextCompactionPrepareTurn
+		>[0]["telemetry"];
+
+		const compact = vi.fn(async () => ({
+			messages: [{ role: "user" as const, content: "trimmed" }],
+		}));
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic",
+				reserveTokens: 1,
+				compact,
+			},
+			telemetry,
+		});
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Original task" },
+			{ role: "assistant", content: "short answer" },
+			{ role: "user", content: "Latest" },
+		];
+		const apiMessages: LlmsProviders.Message[] = [
+			...messages,
+			{ role: "assistant", content: "provider-only payload ".repeat(1_000) },
+		];
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 3,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "",
+			tools: [],
+			messages,
+			apiMessages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(compact).toHaveBeenCalledTimes(1);
+		const executed = captureCalls.find(
+			(call) => call.event === "task.compaction_executed",
+		);
+		const props = executed?.properties as Record<string, unknown>;
+		expect(props.tokensBefore as number).toBeLessThan(
+			props.triggerTokens as number,
+		);
+		expect(props.tokensSaved).toBe(
+			(props.tokensBefore as number) - (props.tokensAfter as number),
+		);
+		expect(props.tokensSaved as number).toBeGreaterThanOrEqual(0);
+	});
+
+	it("emits task.compaction_skipped when the strategy returns undefined", async () => {
+		const captureCalls: Array<{
+			event: string;
+			properties?: Record<string, unknown>;
+		}> = [];
+		const telemetry = {
+			capture: (call: {
+				event: string;
+				properties?: Record<string, unknown>;
+			}) => captureCalls.push(call),
+			captureRequired: () => {},
+			setDistinctId: () => {},
+			updateCommonProperties: () => {},
+			identify: () => {},
+		} as unknown as Parameters<
+			typeof createContextCompactionPrepareTurn
+		>[0]["telemetry"];
+
+		// Force the trigger to fire (small budget vs large transcript) but
+		// supply a `compact` callback that intentionally returns undefined
+		// so the wrapper records a skip.
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "anthropic",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: {
+				enabled: true,
+				strategy: "basic",
+				reserveTokens: 1,
+				compact: async () => undefined,
+			},
+			telemetry,
+			sessionId: "ulid-test-skip",
+		});
+
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Original task" },
+			{ role: "assistant", content: "x".repeat(500) },
+			{ role: "user", content: "Latest" },
+		];
+		const apiMessages: LlmsProviders.Message[] = [
+			{ role: "user", content: "api-shaped ".repeat(500) },
+		];
+		const estimateMessageTokens = createTokenEstimator();
+		const sessionInputTokens = messages.reduce(
+			(total, message) => total + estimateMessageTokens(message),
+			0,
+		);
+		const apiInputTokens = apiMessages.reduce(
+			(total, message) => total + estimateMessageTokens(message),
+			0,
+		);
+		expect(apiInputTokens).not.toBe(sessionInputTokens);
+
+		const result = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 3,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "",
+			tools: [],
+			messages,
+			apiMessages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100 },
+			},
+		});
+
+		expect(result).toBeUndefined();
+		const skipped = captureCalls.find(
+			(call) => call.event === "task.compaction_skipped",
+		);
+		expect(skipped).toBeDefined();
+		const props = skipped?.properties as Record<string, unknown>;
+		expect(props.strategy).toBe("custom");
+		expect(props.mode).toBe("auto");
+		expect(props.reason).toBe("no_result");
+		expect(props.ulid).toBe("ulid-test-skip");
+		expect(props.tokensBefore).toBe(sessionInputTokens);
+		expect(typeof props.durationMs).toBe("number");
+		expect(
+			captureCalls.find((call) => call.event === "task.compaction_executed"),
+		).toBeUndefined();
+	});
+
+	it("tags telemetry mode as 'manual' when prepareTurn is run with mode: manual", async () => {
+		const captureCalls: Array<{
+			event: string;
+			properties?: Record<string, unknown>;
+		}> = [];
+		const telemetry = {
+			capture: (call: {
+				event: string;
+				properties?: Record<string, unknown>;
+			}) => captureCalls.push(call),
+			captureRequired: () => {},
+			setDistinctId: () => {},
+			updateCommonProperties: () => {},
+			identify: () => {},
+		} as unknown as Parameters<
+			typeof createContextCompactionPrepareTurn
+		>[0]["telemetry"];
+
+		const prepareTurn = createContextCompactionPrepareTurn(
+			{
+				providerId: "anthropic",
+				modelId: "mock-model",
+				providerConfig: {
+					providerId: "anthropic",
+					modelId: "mock-model",
+				} as LlmsProviders.ProviderConfig,
+				compaction: {
+					enabled: true,
+					strategy: "basic",
+					reserveTokens: 1,
+				},
+				telemetry,
+			},
+			{ mode: "manual" },
+		);
+
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "Original task" },
+			{ role: "assistant", content: "x".repeat(500) },
+			{ role: "user", content: "Older followup" },
+			{ role: "assistant", content: "x".repeat(500) },
+			{ role: "user", content: "Latest" },
+		];
+
+		await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 4,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100_000 },
+			},
+		});
+
+		const compactionEvent = captureCalls.find(
+			(call) =>
+				call.event === "task.compaction_executed" ||
+				call.event === "task.compaction_skipped",
+		);
+		expect(compactionEvent).toBeDefined();
+		expect((compactionEvent?.properties as Record<string, unknown>).mode).toBe(
+			"manual",
+		);
+	});
+
+	it("does not immediately re-trigger basic compaction on the next turn after accounting for the protected tail", async () => {
+		const prepareTurn = createContextCompactionPrepareTurn({
+			providerId: "openai-codex",
+			modelId: "mock-model",
+			providerConfig: {
+				providerId: "openai-codex",
+				modelId: "mock-model",
+			} as LlmsProviders.ProviderConfig,
+			compaction: { enabled: true, strategy: "basic", thresholdRatio: 0.5 },
+			logger: undefined,
+		});
+		const estimateMessageTokens = createTokenEstimator();
+		const model = {
+			id: "mock-model",
+			provider: "openai-codex",
+			info: { id: "mock-model", maxInputTokens: 300 },
+		};
+		const messages: LlmsProviders.Message[] = [
+			{ role: "user", content: "old user context ".repeat(80) },
+			{ role: "assistant", content: "old assistant context ".repeat(80) },
+			{ role: "user", content: "current request" },
+		];
+		const triggerTokens = 150;
+		const firstResult = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages,
+			apiMessages: messages,
+			model,
+		});
+
+		expect(firstResult?.messages).toBeDefined();
+		const firstAfterTokens = firstResult?.messages.reduce(
+			(total, message) => total + estimateMessageTokens(message),
+			0,
+		);
+		expect(firstAfterTokens).toBeLessThanOrEqual(triggerTokens);
+
+		const nextTurnMessages: LlmsProviders.Message[] = [
+			...(firstResult?.messages ?? []),
+			{ role: "assistant", content: "short answer" },
+			{ role: "user", content: "next request" },
+		];
+		const secondResult = await prepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 2,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "You are helpful.",
+			tools: [],
+			messages: nextTurnMessages,
+			apiMessages: nextTurnMessages,
+			model,
+		});
+
+		expect(secondResult).toBeUndefined();
+	});
+
+	it("keeps stale sidecar state when replacement compaction returns no result", async () => {
+		const originalMessages: LlmsProviders.Message[] = [
+			{ role: "user", content: "original" },
+		];
+		const existingState = createSessionCompactionState({
+			sourceMessages: originalMessages,
+			compactedMessages: [{ role: "user", content: "summary" }],
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const compact = vi.fn().mockResolvedValue(undefined);
+		const saveState = vi.fn();
+		const prepareTurn = createCompactionStateAwarePrepareTurn({
+			compact,
+			getState: () => existingState,
+			saveState,
+		});
+		const currentMessages: LlmsProviders.Message[] = [
+			{ role: "user", content: "edited original" },
+			{ role: "assistant", content: "tail" },
+		];
+
+		const result = await prepareTurn({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			abortSignal: new AbortController().signal,
+			systemPrompt: "",
+			tools: [],
+			messages: currentMessages,
+			apiMessages: currentMessages,
+			model: {
+				id: "mock-model",
+				provider: "anthropic",
+				info: { id: "mock-model", maxInputTokens: 100_000 },
+			},
+		});
+
+		expect(result).toBeUndefined();
+		expect(compact).toHaveBeenCalledWith(
+			expect.objectContaining({ messages: currentMessages }),
+		);
+		expect(saveState).not.toHaveBeenCalled();
+	});
+});
diff --git a/sdk/packages/core/src/extensions/context/compaction.ts b/sdk/packages/core/src/extensions/context/compaction.ts
new file mode 100644
index 0000000..14a492e
--- /dev/null
+++ b/sdk/packages/core/src/extensions/context/compaction.ts
@@ -0,0 +1,609 @@
+import {
+	captureCompactionBudgetEmergency,
+	captureCompactionExecuted,
+	captureCompactionSkipped,
+	type TelemetryCompactionStrategy,
+} from "../../services/telemetry/core-events";
+import {
+	createSessionCompactionState,
+	projectSessionCompactionState,
+	type SessionCompactionState,
+} from "../../session/models/session-compaction";
+import type {
+	CoreCompactionConfig,
+	CoreCompactionContext,
+	CoreCompactionResult,
+	CoreCompactionStrategy,
+	CoreSessionConfig,
+} from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+import { runAgenticCompaction } from "./agentic-compaction";
+import { runBasicCompaction } from "./basic-compaction";
+import {
+	createTokenEstimator,
+	DEFAULT_MAX_INPUT_TOKENS,
+	DEFAULT_PRESERVE_RECENT_TOKENS,
+	DEFAULT_RESERVE_TOKENS,
+	DEFAULT_TARGET_RATIO,
+	DEFAULT_THRESHOLD_RATIO,
+} from "./compaction-shared";
+
+export interface ContextPipelinePrepareTurnInput {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	messages: CoreCompactionContext["messages"];
+	apiMessages: CoreCompactionContext["messages"];
+	abortSignal: AbortSignal;
+	systemPrompt: string;
+	tools: unknown[];
+	model: CoreCompactionContext["model"];
+	emitStatusNotice?: (
+		message: string,
+		metadata?: Record<string, unknown>,
+	) => void;
+}
+
+export interface ContextPipelinePrepareTurnResult {
+	messages: CoreCompactionContext["messages"];
+	systemPrompt?: string;
+}
+
+export type ContextPipelinePrepareTurn = (
+	context: ContextPipelinePrepareTurnInput,
+) => Promise<ContextPipelinePrepareTurnResult | undefined>;
+
+type EstimateMessageTokens = ReturnType<typeof createTokenEstimator>;
+
+type BuiltinCompactionStrategyOptions = {
+	context: CoreCompactionContext;
+	providerConfig: ProviderConfig;
+	compaction: CoreCompactionConfig | undefined;
+	mode: ContextCompactionMode;
+	estimateMessageTokens: EstimateMessageTokens;
+	logger: Pick<CoreSessionConfig, "logger">["logger"];
+};
+
+type BuiltinCompactionStrategyRunner = (
+	options: BuiltinCompactionStrategyOptions,
+) =>
+	| Promise<CoreCompactionResult | undefined>
+	| CoreCompactionResult
+	| undefined;
+
+export type ContextCompactionMode = "auto" | "manual";
+
+export interface ContextCompactionPrepareTurnOptions {
+	mode?: ContextCompactionMode;
+	manualTargetRatio?: number;
+}
+
+const MIN_CONTEXT_DERIVED_INPUT_RATIO = 0.5;
+const LONG_CONVERSATION_TARGET_RATIO = 0.5;
+
+function safeJsonSize(value: unknown): number {
+	try {
+		return JSON.stringify(value).length;
+	} catch {
+		return String(value).length;
+	}
+}
+
+function isPositiveFiniteNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function resolveMaxInputTokens(input: {
+	configMaxInputTokens?: number;
+	modelMaxInputTokens?: number;
+	contextWindow?: number;
+	modelMaxTokens?: number;
+}): number {
+	const candidates: number[] = [];
+	if (isPositiveFiniteNumber(input.configMaxInputTokens)) {
+		candidates.push(input.configMaxInputTokens);
+	}
+	if (isPositiveFiniteNumber(input.modelMaxInputTokens)) {
+		candidates.push(input.modelMaxInputTokens);
+	}
+	if (isPositiveFiniteNumber(input.contextWindow)) {
+		candidates.push(input.contextWindow);
+		const derivedInputTokens = isPositiveFiniteNumber(input.modelMaxTokens)
+			? input.contextWindow - input.modelMaxTokens
+			: undefined;
+		if (
+			isPositiveFiniteNumber(derivedInputTokens) &&
+			derivedInputTokens >=
+				input.contextWindow * MIN_CONTEXT_DERIVED_INPUT_RATIO
+		) {
+			candidates.push(derivedInputTokens);
+		}
+	}
+	return candidates.length > 0
+		? Math.min(...candidates)
+		: DEFAULT_MAX_INPUT_TOKENS;
+}
+
+function summarizeToolResults(messages: CoreCompactionContext["messages"]): {
+	toolResultCount: number;
+	toolResultSerializedChars: number;
+	maxToolResultSerializedChars: number;
+} {
+	let toolResultCount = 0;
+	let toolResultSerializedChars = 0;
+	let maxToolResultSerializedChars = 0;
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const block of message.content) {
+			if (block.type !== "tool_result") {
+				continue;
+			}
+			const size = safeJsonSize(block.content);
+			toolResultCount += 1;
+			toolResultSerializedChars += size;
+			maxToolResultSerializedChars = Math.max(
+				maxToolResultSerializedChars,
+				size,
+			);
+		}
+	}
+	return {
+		toolResultCount,
+		toolResultSerializedChars,
+		maxToolResultSerializedChars,
+	};
+}
+
+const BUILTIN_COMPACTION_STRATEGIES = {
+	basic: ({ context, estimateMessageTokens, logger }) =>
+		runBasicCompaction({
+			context,
+			estimateMessageTokens,
+			logger,
+		}),
+	agentic: ({
+		context,
+		providerConfig,
+		compaction,
+		mode,
+		estimateMessageTokens,
+		logger,
+	}) =>
+		runAgenticCompaction({
+			context,
+			providerConfig,
+			summarizer: compaction?.summarizer,
+			preserveRecentTokens:
+				mode === "manual"
+					? Math.min(
+							compaction?.preserveRecentTokens ??
+								DEFAULT_PRESERVE_RECENT_TOKENS,
+							context.triggerTokens,
+						)
+					: (compaction?.preserveRecentTokens ??
+						DEFAULT_PRESERVE_RECENT_TOKENS),
+			estimateMessageTokens,
+			logger,
+		}),
+} satisfies Record<CoreCompactionStrategy, BuiltinCompactionStrategyRunner>;
+
+function resolveTriggerState(input: {
+	inputTokens: number;
+	maxInputTokens: number;
+	config: CoreCompactionConfig;
+}): { shouldCompact: boolean; triggerTokens: number; thresholdRatio: number } {
+	if (typeof input.config.reserveTokens === "number") {
+		const reserveTokens = Math.max(0, input.config.reserveTokens);
+		const triggerTokens = Math.max(0, input.maxInputTokens - reserveTokens);
+		return {
+			shouldCompact: input.inputTokens > triggerTokens,
+			triggerTokens,
+			thresholdRatio:
+				input.maxInputTokens > 0 ? triggerTokens / input.maxInputTokens : 0,
+		};
+	}
+
+	if (typeof input.config.thresholdRatio === "number") {
+		const thresholdRatio = input.config.thresholdRatio;
+		const triggerTokens = input.maxInputTokens * thresholdRatio;
+		return {
+			shouldCompact: input.inputTokens > triggerTokens,
+			triggerTokens,
+			thresholdRatio,
+		};
+	}
+
+	const triggerTokens = Math.max(
+		0,
+		Math.min(
+			input.maxInputTokens - DEFAULT_RESERVE_TOKENS,
+			input.maxInputTokens * DEFAULT_THRESHOLD_RATIO,
+		),
+	);
+	return {
+		shouldCompact: input.inputTokens > triggerTokens,
+		triggerTokens,
+		thresholdRatio:
+			input.maxInputTokens > 0 ? triggerTokens / input.maxInputTokens : 0,
+	};
+}
+
+function resolveManualTargetState(input: {
+	inputTokens: number;
+	maxInputTokens: number;
+	autoTriggerTokens: number;
+	manualTargetRatio: number | undefined;
+}): { triggerTokens: number; thresholdRatio: number } {
+	const ratio =
+		typeof input.manualTargetRatio === "number" &&
+		Number.isFinite(input.manualTargetRatio)
+			? input.manualTargetRatio
+			: 0.5;
+	const targetRatio = Math.min(0.95, Math.max(0.05, ratio));
+	// Keep manual compaction at least as aggressive as the configured auto
+	// threshold; very low thresholdRatio values intentionally dominate here.
+	const targetTokens = Math.max(
+		1,
+		Math.floor(
+			Math.min(input.autoTriggerTokens, input.inputTokens * targetRatio),
+		),
+	);
+	return {
+		triggerTokens: targetTokens,
+		thresholdRatio:
+			input.maxInputTokens > 0 ? targetTokens / input.maxInputTokens : 0,
+	};
+}
+
+function resolveBasicTargetTokens(input: {
+	maxInputTokens: number;
+	modelMaxTokens?: number;
+	triggerTokens: number;
+	messagePairCount: number;
+}): number {
+	const targetTokens =
+		input.messagePairCount >= 5 &&
+		typeof input.modelMaxTokens === "number" &&
+		Number.isFinite(input.modelMaxTokens) &&
+		input.modelMaxTokens < input.maxInputTokens
+			? Math.floor(input.maxInputTokens * LONG_CONVERSATION_TARGET_RATIO)
+			: Math.floor(input.triggerTokens * DEFAULT_TARGET_RATIO);
+	const triggerCeiling = Math.max(1, input.triggerTokens - 1);
+	return Math.max(
+		1,
+		Math.min(targetTokens, input.maxInputTokens, triggerCeiling),
+	);
+}
+
+function countUserAssistantPairs(
+	messages: CoreCompactionContext["messages"],
+): number {
+	let pairs = 0;
+	let hasPendingUser = false;
+	for (const message of messages) {
+		if (message.role === "user") {
+			hasPendingUser = true;
+		} else if (message.role === "assistant" && hasPendingUser) {
+			pairs += 1;
+			hasPendingUser = false;
+		}
+	}
+	return pairs;
+}
+
+/**
+ * Build the `prepareTurn` callback used by the agent runtime to compact the
+ * transcript before each model request.
+ *
+ * Telemetry: emits `task.compaction_executed` on a successful compaction and
+ * `task.compaction_skipped` when the configured strategy returns `undefined`.
+ * Telemetry is keyed by `config.sessionId` (falling back to the per-turn
+ * `conversationId`) and tagged with `provider` / `modelId`.
+ *
+ * Known gap: compactions performed via plugin `registerMessageBuilder()` or
+ * via the `beforeModel` runtime hook bypass this wrapper entirely, so they
+ * do not emit compaction telemetry. If we want coverage there too, the
+ * plugin/hook pipelines must be instrumented separately.
+ */
+export function createContextCompactionPrepareTurn(
+	config: Pick<
+		CoreSessionConfig,
+		| "providerConfig"
+		| "providerId"
+		| "modelId"
+		| "compaction"
+		| "logger"
+		| "telemetry"
+		| "sessionId"
+	>,
+	options: ContextCompactionPrepareTurnOptions = {},
+):
+	| ((
+			context: ContextPipelinePrepareTurnInput,
+	  ) => Promise<ContextPipelinePrepareTurnResult | undefined>)
+	| undefined {
+	const userCompaction = config.compaction;
+	if (userCompaction?.enabled !== true) {
+		return undefined;
+	}
+
+	const providerConfig =
+		config.providerConfig ??
+		({
+			providerId: config.providerId,
+			modelId: config.modelId,
+		} as ProviderConfig);
+	const estimateMessageTokens = createTokenEstimator();
+	const strategy = userCompaction?.strategy ?? "basic";
+	const runBuiltinStrategy = BUILTIN_COMPACTION_STRATEGIES[strategy];
+	const mode = options.mode ?? "auto";
+	const telemetryStrategy: TelemetryCompactionStrategy = userCompaction?.compact
+		? "custom"
+		: strategy;
+
+	return async (context) => {
+		const inputTokens = context.apiMessages.reduce(
+			(total: number, message) => total + estimateMessageTokens(message),
+			0,
+		);
+		const maxInputTokens = resolveMaxInputTokens({
+			configMaxInputTokens: userCompaction?.maxInputTokens,
+			modelMaxInputTokens: context.model.info?.maxInputTokens,
+			contextWindow: context.model.info?.contextWindow,
+			modelMaxTokens: context.model.info?.maxTokens,
+		});
+
+		const triggerState = resolveTriggerState({
+			inputTokens,
+			maxInputTokens,
+			config: {
+				maxInputTokens: userCompaction?.maxInputTokens,
+				reserveTokens: userCompaction?.reserveTokens,
+				thresholdRatio: userCompaction?.thresholdRatio,
+			},
+		});
+		config.logger?.debug("Context compaction diagnostics", {
+			mode,
+			strategy,
+			iteration: context.iteration,
+			providerId: config.providerId,
+			modelId: config.modelId,
+			inputTokens,
+			maxInputTokens,
+			triggerTokens: triggerState.triggerTokens,
+			thresholdRatio: triggerState.thresholdRatio,
+			shouldCompact: triggerState.shouldCompact,
+			messageCount: context.messages.length,
+			apiMessageCount: context.apiMessages.length,
+			apiMessagesJsonChars: safeJsonSize(context.apiMessages),
+			...summarizeToolResults(context.apiMessages),
+		});
+		if (mode === "auto" && !triggerState.shouldCompact) {
+			return undefined;
+		}
+		const targetState =
+			mode === "manual"
+				? resolveManualTargetState({
+						inputTokens,
+						maxInputTokens,
+						autoTriggerTokens: triggerState.triggerTokens,
+						manualTargetRatio: options.manualTargetRatio,
+					})
+				: triggerState;
+		const targetTokens =
+			mode === "auto"
+				? resolveBasicTargetTokens({
+						maxInputTokens,
+						modelMaxTokens: context.model.info?.maxTokens,
+						triggerTokens: targetState.triggerTokens,
+						messagePairCount: countUserAssistantPairs(context.messages),
+					})
+				: undefined;
+
+		const compactionContext = {
+			agentId: context.agentId,
+			conversationId: context.conversationId,
+			parentAgentId: context.parentAgentId,
+			iteration: context.iteration,
+			messages: context.messages,
+			model: context.model,
+			maxInputTokens,
+			triggerTokens: targetState.triggerTokens,
+			targetTokens,
+			thresholdRatio: targetState.thresholdRatio,
+			utilizationRatio: maxInputTokens > 0 ? inputTokens / maxInputTokens : 0,
+		};
+
+		const statusReason =
+			mode === "manual" ? "manual_compaction" : "auto_compaction";
+		context.emitStatusNotice?.(
+			mode === "manual" ? "compacting" : "auto-compacting",
+			{
+				kind: statusReason,
+				reason: statusReason,
+				iteration: context.iteration,
+				triggerTokens: targetState.triggerTokens,
+				maxInputTokens,
+			},
+		);
+
+		const beforeMessageCount = context.messages.length;
+		const compactionInputTokens = context.messages.reduce(
+			(total: number, message) => total + estimateMessageTokens(message),
+			0,
+		);
+		const startedAt = Date.now();
+
+		const result = userCompaction?.compact
+			? await userCompaction.compact(compactionContext)
+			: await runBuiltinStrategy({
+					context: compactionContext,
+					providerConfig: {
+						...providerConfig,
+						abortSignal: context.abortSignal,
+					},
+					compaction: userCompaction,
+					mode,
+					estimateMessageTokens,
+					logger: config.logger,
+				});
+
+		const durationMs = Date.now() - startedAt;
+		// Telemetry identity: surface the agent/conversation passed into the
+		// prepareTurn so multi-agent runs can attribute compactions correctly.
+		// `sessionId` is the host-owned session id (ulid). We fall back to the
+		// conversation id when no sessionId is supplied (e.g. ad-hoc callers).
+		const telemetryUlid = config.sessionId ?? context.conversationId;
+		const telemetryIdentity = {
+			agentId: context.agentId,
+			conversationId: context.conversationId,
+			parentAgentId: context.parentAgentId ?? undefined,
+		};
+
+		if (result?.messages) {
+			const afterTokens = result.messages.reduce(
+				(total: number, message) => total + estimateMessageTokens(message),
+				0,
+			);
+			config.logger?.log("Context compaction completed", {
+				severity: "info",
+				strategy: strategy,
+				maxInputTokens,
+				inputTokens: compactionInputTokens,
+				apiInputTokens: inputTokens,
+				afterTokens,
+				tokensSaved: compactionInputTokens - afterTokens,
+				utilizationBefore: `${((compactionInputTokens / maxInputTokens) * 100).toFixed(1)}%`,
+				utilizationAfter: `${((afterTokens / maxInputTokens) * 100).toFixed(1)}%`,
+				thresholdTrigger: `${(targetState.thresholdRatio * 100).toFixed(1)}%`,
+				messagesBefore: beforeMessageCount,
+				messagesAfter: result.messages.length,
+				messagesRemoved: beforeMessageCount - result.messages.length,
+			} as Record<string, unknown>);
+			captureCompactionExecuted(config.telemetry, {
+				ulid: telemetryUlid,
+				strategy: telemetryStrategy,
+				mode,
+				messagesBefore: beforeMessageCount,
+				messagesAfter: result.messages.length,
+				messagesRemoved: beforeMessageCount - result.messages.length,
+				tokensBefore: compactionInputTokens,
+				tokensAfter: afterTokens,
+				tokensSaved: compactionInputTokens - afterTokens,
+				triggerTokens: targetState.triggerTokens,
+				maxInputTokens,
+				thresholdRatio: targetState.thresholdRatio,
+				durationMs,
+				// Matches the field name used by other TASK telemetry helpers
+				// (e.g. captureTaskCompleted, captureToolUsage).
+				provider: config.providerId,
+				modelId: config.modelId,
+				...telemetryIdentity,
+			});
+			if (
+				result.budget &&
+				(result.budget.actionCount > 0 || result.budget.warningCount > 0)
+			) {
+				captureCompactionBudgetEmergency(config.telemetry, {
+					ulid: telemetryUlid,
+					strategy: telemetryStrategy,
+					mode,
+					policyIntent: result.budget.policyIntent,
+					actionCount: result.budget.actionCount,
+					warningCount: result.budget.warningCount,
+					liveTailHandling: result.budget.liveTailHandling,
+					provider: config.providerId,
+					modelId: config.modelId,
+					...telemetryIdentity,
+				});
+				context.emitStatusNotice?.("compaction-budget-adjusted", {
+					kind: "compaction_budget_emergency",
+					reason: "compaction_budget_emergency",
+					iteration: context.iteration,
+					policyIntent: result.budget.policyIntent,
+					actionCount: result.budget.actionCount,
+					warningCount: result.budget.warningCount,
+				});
+			}
+		} else {
+			captureCompactionSkipped(config.telemetry, {
+				ulid: telemetryUlid,
+				strategy: telemetryStrategy,
+				mode,
+				reason: "no_result",
+				tokensBefore: compactionInputTokens,
+				triggerTokens: targetState.triggerTokens,
+				maxInputTokens,
+				thresholdRatio: targetState.thresholdRatio,
+				durationMs,
+				provider: config.providerId,
+				modelId: config.modelId,
+				...telemetryIdentity,
+			});
+		}
+
+		return result;
+	};
+}
+
+export function createCompactionStateAwarePrepareTurn(input: {
+	compact?: ContextPipelinePrepareTurn;
+	getState?: () => SessionCompactionState | undefined;
+	saveState?: (state: SessionCompactionState) => void | Promise<void>;
+}): ContextPipelinePrepareTurn {
+	return async (context) => {
+		const existingState = input.getState?.();
+		const projectedMessages = existingState
+			? projectSessionCompactionState(existingState, context.messages)
+			: undefined;
+		if (existingState && projectedMessages) {
+			// Re-compaction intentionally starts from the compacted projection plus
+			// canonical tail. This keeps automatic turns bounded without rebuilding a
+			// full-transcript summary every turn; manual `/compact` is the path for a
+			// fresh summary from canonical history.
+			const result = input.compact
+				? await input.compact({
+						...context,
+						messages: projectedMessages,
+						apiMessages: projectedMessages,
+					})
+				: undefined;
+			if (result?.messages) {
+				const systemPrompt = result.systemPrompt ?? existingState.system_prompt;
+				const nextState = createSessionCompactionState({
+					sourceMessages: context.messages,
+					compactedMessages: result.messages,
+					conversationId: context.conversationId,
+					systemPrompt,
+				});
+				await input.saveState?.(nextState);
+				return {
+					...result,
+					...(systemPrompt !== undefined ? { systemPrompt } : {}),
+				};
+			}
+			return {
+				messages: projectedMessages,
+				...(result?.systemPrompt !== undefined
+					? { systemPrompt: result.systemPrompt }
+					: existingState.system_prompt !== undefined
+						? { systemPrompt: existingState.system_prompt }
+						: {}),
+			};
+		}
+		const result = input.compact ? await input.compact(context) : undefined;
+		if (result?.messages) {
+			const nextState = createSessionCompactionState({
+				sourceMessages: context.messages,
+				compactedMessages: result.messages,
+				conversationId: context.conversationId,
+				systemPrompt: result.systemPrompt,
+			});
+			await input.saveState?.(nextState);
+		}
+		return result;
+	};
+}
diff --git a/sdk/packages/core/src/extensions/index.ts b/sdk/packages/core/src/extensions/index.ts
new file mode 100644
index 0000000..ac5cc6d
--- /dev/null
+++ b/sdk/packages/core/src/extensions/index.ts
@@ -0,0 +1,19 @@
+export type { ResolveAgentPluginPathsOptions } from "./plugin/plugin-config-loader";
+export {
+	discoverPluginModulePaths,
+	resolveAgentPluginPaths,
+	resolveAndLoadAgentPlugins,
+	resolvePluginConfigSearchPaths,
+	resolvePluginSkillDirectoriesFromPaths,
+} from "./plugin/plugin-config-loader";
+export type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+	PluginLoadDiagnostics,
+} from "./plugin/plugin-load-report";
+export type { LoadAgentPluginFromPathOptions } from "./plugin/plugin-loader";
+export {
+	loadAgentPluginFromPath,
+	loadAgentPluginsFromPaths,
+	loadAgentPluginsFromPathsWithDiagnostics,
+} from "./plugin/plugin-loader";
diff --git a/sdk/packages/core/src/extensions/mcp/client.ts b/sdk/packages/core/src/extensions/mcp/client.ts
new file mode 100644
index 0000000..c1bb9f2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/client.ts
@@ -0,0 +1,579 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import {
+	createMcpOAuthProviderContext,
+	createMcpSdkTransport,
+	type McpOAuthProviderContext,
+} from "./oauth";
+import type {
+	McpServerClient,
+	McpServerClientFactory,
+	McpServerRegistration,
+	McpToolCallResult,
+	McpToolDescriptor,
+} from "./types";
+
+type JsonRpcRequest = {
+	jsonrpc: "2.0";
+	id: number;
+	method: string;
+	params?: Record<string, unknown>;
+};
+
+type JsonRpcMessage = {
+	jsonrpc?: "2.0";
+	id?: number;
+	method?: string;
+	result?: unknown;
+	error?: {
+		code?: number;
+		message?: string;
+		data?: unknown;
+	};
+};
+
+type StdioProtocolMode = "newline" | "framed";
+
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const MCP_REQUEST_TIMEOUT_MS = 5_000;
+const MCP_CONNECT_TIMEOUT_MS = 1_500;
+const DEFAULT_HTTP_MCP_REDIRECT_URL =
+	"http://127.0.0.1:1456/mcp/oauth/callback";
+
+function toErrorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function encodeFramedMessage(message: Record<string, unknown>): Buffer {
+	const body = Buffer.from(JSON.stringify(message), "utf8");
+	const header = Buffer.from(
+		`Content-Length: ${body.byteLength}\r\n\r\n`,
+		"utf8",
+	);
+	return Buffer.concat([header, body]);
+}
+
+function encodeNewlineMessage(message: Record<string, unknown>): Buffer {
+	return Buffer.from(`${JSON.stringify(message)}\n`, "utf8");
+}
+
+class FramedMessageParser {
+	private buffer = "";
+	private readonly decoder = new StringDecoder("utf8");
+
+	push(chunk: Buffer): string[] {
+		this.buffer += this.decoder.write(chunk);
+		const messages: string[] = [];
+
+		while (true) {
+			const separatorIndex = this.buffer.indexOf("\r\n\r\n");
+			if (separatorIndex < 0) {
+				break;
+			}
+
+			const headerText = this.buffer.slice(0, separatorIndex);
+			const contentLengthMatch = headerText.match(
+				/(?:^|\r\n)Content-Length:\s*(\d+)(?:\r\n|$)/i,
+			);
+			if (!contentLengthMatch) {
+				throw new Error(
+					"Invalid MCP stdio frame: missing Content-Length header.",
+				);
+			}
+
+			const contentLength = Number.parseInt(contentLengthMatch[1], 10);
+			const bodyStart = separatorIndex + 4;
+			const bodyEnd = bodyStart + contentLength;
+			if (this.buffer.length < bodyEnd) {
+				break;
+			}
+
+			messages.push(this.buffer.slice(bodyStart, bodyEnd));
+			this.buffer = this.buffer.slice(bodyEnd);
+		}
+
+		return messages;
+	}
+}
+
+class NewlineMessageParser {
+	private buffer = "";
+	private readonly decoder = new StringDecoder("utf8");
+
+	push(chunk: Buffer): string[] {
+		this.buffer += this.decoder.write(chunk);
+		const messages: string[] = [];
+
+		while (true) {
+			const newlineIndex = this.buffer.indexOf("\n");
+			if (newlineIndex < 0) {
+				break;
+			}
+			const line = this.buffer.slice(0, newlineIndex).trim();
+			this.buffer = this.buffer.slice(newlineIndex + 1);
+			if (line.length > 0) {
+				messages.push(line);
+			}
+		}
+
+		return messages;
+	}
+}
+
+class StdioMcpClient implements McpServerClient {
+	private readonly registration: McpServerRegistration;
+	private process?: ChildProcessWithoutNullStreams;
+	private nextRequestId = 1;
+	private readonly pending = new Map<
+		number,
+		{
+			resolve: (value: unknown) => void;
+			reject: (error: Error) => void;
+			timeout: ReturnType<typeof setTimeout>;
+		}
+	>();
+	private framedParser = new FramedMessageParser();
+	private newlineParser = new NewlineMessageParser();
+	private stderrBuffer = "";
+	private connected = false;
+	private protocolMode: StdioProtocolMode = "newline";
+
+	constructor(registration: McpServerRegistration) {
+		this.registration = registration;
+	}
+
+	async connect(): Promise<void> {
+		if (this.connected) {
+			return;
+		}
+		if (this.registration.transport.type !== "stdio") {
+			throw new Error(
+				`Unsupported MCP transport for "${this.registration.name}": ${this.registration.transport.type}`,
+			);
+		}
+
+		const attempts: StdioProtocolMode[] = ["newline", "framed"];
+		let lastError: Error | undefined;
+
+		for (const protocolMode of attempts) {
+			await this.disconnect().catch(() => {});
+			this.spawnProcess(protocolMode);
+			try {
+				await this.request(
+					"initialize",
+					{
+						protocolVersion: MCP_PROTOCOL_VERSION,
+						capabilities: {},
+						clientInfo: {
+							name: "@cline/core",
+							version: "0.0.0",
+						},
+					},
+					MCP_CONNECT_TIMEOUT_MS,
+				);
+				this.notify("notifications/initialized");
+				this.connected = true;
+				this.protocolMode = protocolMode;
+				return;
+			} catch (error) {
+				lastError = error instanceof Error ? error : new Error(String(error));
+			}
+		}
+
+		throw (
+			lastError ??
+			new Error(`Failed to connect to MCP server "${this.registration.name}".`)
+		);
+	}
+
+	async disconnect(): Promise<void> {
+		const child = this.process;
+		this.connected = false;
+		this.process = undefined;
+		this.failAllPending(
+			new Error(`Disconnected from MCP server "${this.registration.name}".`),
+		);
+		if (!child) {
+			return;
+		}
+		child.kill();
+	}
+
+	async listTools(): Promise<readonly McpToolDescriptor[]> {
+		const result = (await this.request("tools/list")) as {
+			tools?: Array<{
+				name?: string;
+				description?: string;
+				inputSchema?: Record<string, unknown>;
+			}>;
+		};
+		return (result.tools ?? [])
+			.filter(
+				(
+					tool,
+				): tool is {
+					name: string;
+					description?: string;
+					inputSchema: Record<string, unknown>;
+				} =>
+					typeof tool?.name === "string" &&
+					typeof tool.inputSchema === "object" &&
+					tool.inputSchema !== null,
+			)
+			.map((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema,
+			}));
+	}
+
+	async callTool(request: {
+		name: string;
+		arguments?: Record<string, unknown>;
+	}): Promise<McpToolCallResult> {
+		return this.request("tools/call", {
+			name: request.name,
+			arguments: request.arguments ?? {},
+		});
+	}
+
+	private spawnProcess(protocolMode: StdioProtocolMode): void {
+		const transport = this.registration.transport;
+		if (transport.type !== "stdio") {
+			throw new Error(
+				`Unsupported MCP transport for "${this.registration.name}": ${transport.type}`,
+			);
+		}
+
+		this.framedParser = new FramedMessageParser();
+		this.newlineParser = new NewlineMessageParser();
+		this.stderrBuffer = "";
+		this.protocolMode = protocolMode;
+
+		const platformOptions =
+			process.platform === "win32"
+				? {
+						windowsHide: true,
+						shell: true,
+					}
+				: {};
+		const child = spawn(transport.command, transport.args ?? [], {
+			cwd: transport.cwd,
+			env: {
+				...process.env,
+				...(transport.env ?? {}),
+			},
+			stdio: ["pipe", "pipe", "pipe"],
+			...platformOptions,
+		});
+
+		this.process = child;
+		child.stdout.on("data", (chunk: Buffer) => this.handleStdout(chunk));
+		child.stderr.on("data", (chunk: Buffer) => {
+			if (this.process !== child) {
+				return;
+			}
+			this.stderrBuffer += chunk.toString("utf8");
+			if (this.stderrBuffer.length > 16_384) {
+				this.stderrBuffer = this.stderrBuffer.slice(-16_384);
+			}
+		});
+		child.once("error", (error) => {
+			if (this.process !== child) {
+				return;
+			}
+			this.failAllPending(
+				new Error(`MCP process error: ${toErrorMessage(error)}`),
+			);
+		});
+		child.once("exit", (code, signal) => {
+			if (this.process !== child) {
+				return;
+			}
+			this.connected = false;
+			this.process = undefined;
+			const suffix = this.stderrBuffer.trim()
+				? ` stderr: ${this.stderrBuffer.trim()}`
+				: "";
+			this.failAllPending(
+				new Error(
+					`MCP process exited for "${this.registration.name}" (code=${code ?? "null"}, signal=${signal ?? "null"}).${suffix}`,
+				),
+			);
+		});
+	}
+
+	private handleStdout(chunk: Buffer): void {
+		try {
+			const messages =
+				this.protocolMode === "framed"
+					? this.framedParser.push(chunk)
+					: this.newlineParser.push(chunk);
+
+			for (const messageText of messages) {
+				const message = JSON.parse(messageText) as JsonRpcMessage;
+				if (typeof message.id !== "number") {
+					continue;
+				}
+				const pending = this.pending.get(message.id);
+				if (!pending) {
+					continue;
+				}
+				this.pending.delete(message.id);
+				clearTimeout(pending.timeout);
+				if (message.error) {
+					const errorMessage =
+						message.error.message ||
+						`MCP request failed with code ${message.error.code ?? "unknown"}`;
+					pending.reject(new Error(errorMessage));
+					continue;
+				}
+				pending.resolve(message.result);
+			}
+		} catch (error) {
+			this.handleProtocolFailure(error);
+		}
+	}
+
+	private handleProtocolFailure(error: unknown): void {
+		const child = this.process;
+		if (!child) {
+			return;
+		}
+
+		this.connected = false;
+		this.process = undefined;
+		const stderrSuffix = this.stderrBuffer.trim()
+			? ` stderr: ${this.stderrBuffer.trim()}`
+			: "";
+		this.failAllPending(
+			new Error(
+				`Invalid MCP response from "${this.registration.name}": ${toErrorMessage(error)}.${stderrSuffix}`,
+			),
+		);
+		child.kill();
+	}
+
+	private async request(
+		method: string,
+		params?: Record<string, unknown>,
+		timeoutMs = MCP_REQUEST_TIMEOUT_MS,
+	): Promise<unknown> {
+		const child = this.process;
+		if (!child?.stdin.writable) {
+			throw new Error(
+				`MCP server "${this.registration.name}" is not connected.`,
+			);
+		}
+
+		const id = this.nextRequestId++;
+		const payload: JsonRpcRequest = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			...(params ? { params } : {}),
+		};
+
+		const resultPromise = new Promise<unknown>((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(id);
+				reject(
+					new Error(
+						`MCP request timed out for "${this.registration.name}" (${method}).`,
+					),
+				);
+			}, timeoutMs);
+			this.pending.set(id, { resolve, reject, timeout });
+		});
+
+		try {
+			child.stdin.write(
+				this.protocolMode === "framed"
+					? encodeFramedMessage(payload)
+					: encodeNewlineMessage(payload),
+			);
+		} catch (error) {
+			const pending = this.pending.get(id);
+			if (pending) {
+				clearTimeout(pending.timeout);
+				this.pending.delete(id);
+			}
+			throw error;
+		}
+
+		return resultPromise;
+	}
+
+	private notify(method: string, params?: Record<string, unknown>): void {
+		const child = this.process;
+		if (!child?.stdin.writable) {
+			return;
+		}
+		const payload = {
+			jsonrpc: "2.0" as const,
+			method,
+			...(params ? { params } : {}),
+		};
+		child.stdin.write(
+			this.protocolMode === "framed"
+				? encodeFramedMessage(payload)
+				: encodeNewlineMessage(payload),
+		);
+	}
+
+	private failAllPending(error: Error): void {
+		for (const [id, pending] of this.pending) {
+			clearTimeout(pending.timeout);
+			this.pending.delete(id);
+			pending.reject(error);
+		}
+	}
+}
+
+export interface DefaultMcpServerClientFactoryOptions {
+	settingsPath?: string;
+	clientName?: string;
+	clientVersion?: string;
+	fetch?: FetchLike;
+}
+
+class SdkUrlMcpClient implements McpServerClient {
+	private client?: Client;
+	private authContext?: McpOAuthProviderContext;
+
+	constructor(
+		private readonly registration: McpServerRegistration,
+		private readonly options: DefaultMcpServerClientFactoryOptions,
+	) {}
+
+	async connect(): Promise<void> {
+		if (this.client) {
+			return;
+		}
+		if (this.registration.transport.type === "stdio") {
+			throw new Error(
+				`Unsupported MCP transport for "${this.registration.name}": ${this.registration.transport.type}`,
+			);
+		}
+
+		const authContext = createMcpOAuthProviderContext({
+			settingsPath: this.options.settingsPath,
+			serverName: this.registration.name,
+			redirectUrl:
+				this.registration.oauth?.redirectUrl ?? DEFAULT_HTTP_MCP_REDIRECT_URL,
+		});
+		this.authContext = authContext;
+		try {
+			const client = new Client({
+				name: this.options.clientName?.trim() || "@cline/core",
+				version: this.options.clientVersion?.trim() || "0.0.0",
+			});
+			const transport = createMcpSdkTransport({
+				registration: this.registration,
+				oauthProvider: authContext.provider,
+				fetch: this.options.fetch,
+			});
+			await client.connect(transport);
+			await authContext.clearError();
+			this.client = client;
+		} catch (error) {
+			const message =
+				error instanceof UnauthorizedError
+					? this.formatUnauthorizedMessage(
+							authContext.getLastAuthorizationUrl(),
+						)
+					: toErrorMessage(error);
+			await authContext.markError(message);
+			throw new Error(message);
+		}
+	}
+
+	async disconnect(): Promise<void> {
+		const activeClient = this.client;
+		this.client = undefined;
+		await activeClient?.close();
+	}
+
+	async listTools(): Promise<readonly McpToolDescriptor[]> {
+		const client = await this.ensureConnectedClient();
+		try {
+			const result = await client.listTools();
+			return result.tools.map((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				inputSchema:
+					tool.inputSchema &&
+					typeof tool.inputSchema === "object" &&
+					!Array.isArray(tool.inputSchema)
+						? tool.inputSchema
+						: {},
+			}));
+		} catch (error) {
+			return await this.handleOperationError(error);
+		}
+	}
+
+	async callTool(request: {
+		name: string;
+		arguments?: Record<string, unknown>;
+	}): Promise<McpToolCallResult> {
+		const client = await this.ensureConnectedClient();
+		try {
+			return await client.callTool({
+				name: request.name,
+				arguments: request.arguments ?? {},
+			});
+		} catch (error) {
+			return await this.handleOperationError(error);
+		}
+	}
+
+	private async ensureConnectedClient(): Promise<Client> {
+		if (!this.client) {
+			await this.connect();
+		}
+		if (!this.client) {
+			throw new Error(
+				`MCP server "${this.registration.name}" is not connected.`,
+			);
+		}
+		return this.client;
+	}
+
+	private formatUnauthorizedMessage(authUrl: string | undefined): string {
+		const base = `MCP server "${this.registration.name}" requires OAuth authorization.`;
+		if (!authUrl) {
+			return `${base} Run authorizeMcpServerOAuth for this server.`;
+		}
+		return `${base} Run authorizeMcpServerOAuth for this server and complete this URL: ${authUrl}`;
+	}
+
+	private async handleOperationError(error: unknown): Promise<never> {
+		const authContext =
+			this.authContext ??
+			createMcpOAuthProviderContext({
+				settingsPath: this.options.settingsPath,
+				serverName: this.registration.name,
+				redirectUrl:
+					this.registration.oauth?.redirectUrl ?? DEFAULT_HTTP_MCP_REDIRECT_URL,
+			});
+		const message =
+			error instanceof UnauthorizedError
+				? this.formatUnauthorizedMessage(authContext.getLastAuthorizationUrl())
+				: toErrorMessage(error);
+		await authContext.markError(message);
+		throw new Error(message);
+	}
+}
+
+export function createDefaultMcpServerClientFactory(
+	options: DefaultMcpServerClientFactoryOptions = {},
+): McpServerClientFactory {
+	return (registration) =>
+		registration.transport.type === "stdio"
+			? new StdioMcpClient(registration)
+			: new SdkUrlMcpClient(registration, options);
+}
diff --git a/sdk/packages/core/src/extensions/mcp/config-loader.test.ts b/sdk/packages/core/src/extensions/mcp/config-loader.test.ts
new file mode 100644
index 0000000..38e2ec0
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/config-loader.test.ts
@@ -0,0 +1,729 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	renameSync,
+	rmdirSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	hasMcpSettingsFile,
+	listMcpServerOAuthStatuses,
+	loadMcpSettingsFile,
+	registerMcpServersFromSettingsFile,
+	resolveMcpServerRegistrations,
+	setMcpServerDisabled,
+	updateMcpServerOAuthState,
+	updateMcpSettingsFile,
+	updateMcpSettingsFileSync,
+	McpSettingsMutatorPurityError,
+} from "./config-loader";
+
+describe("mcp config loader", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((directory) =>
+				rm(directory, { recursive: true, force: true }),
+			),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("loads and validates mcp server registrations from JSON", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "stdio",
+								command: "npx",
+								args: ["-y", "@modelcontextprotocol/server-filesystem"],
+							},
+						},
+						search: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.example.com",
+							},
+							disabled: true,
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		expect(hasMcpSettingsFile({ filePath })).toBe(true);
+		expect(
+			loadMcpSettingsFile({ filePath }).mcpServers.docs.transport.type,
+		).toBe("stdio");
+
+		const registrations = resolveMcpServerRegistrations({ filePath });
+		expect(registrations).toEqual([
+			{
+				name: "docs",
+				transport: {
+					type: "stdio",
+					command: "npx",
+					args: ["-y", "@modelcontextprotocol/server-filesystem"],
+				},
+				disabled: undefined,
+				metadata: undefined,
+				oauth: undefined,
+			},
+			{
+				name: "search",
+				transport: {
+					type: "streamableHttp",
+					url: "https://mcp.example.com",
+				},
+				disabled: true,
+				metadata: undefined,
+				oauth: undefined,
+			},
+		]);
+	});
+
+	it("registers loaded servers with an mcp manager", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "stdio",
+								command: "node",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const registered: Array<{ name: string }> = [];
+		const manager = {
+			registerServer: async (registration: { name: string }) => {
+				registered.push(registration);
+			},
+		};
+
+		await registerMcpServersFromSettingsFile(manager, { filePath });
+		expect(registered).toEqual([
+			{
+				name: "docs",
+				transport: {
+					type: "stdio",
+					command: "node",
+				},
+				disabled: undefined,
+				metadata: undefined,
+				oauth: undefined,
+			},
+		]);
+	});
+
+	it("throws a clear error for invalid config", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						broken: {
+							transport: {
+								type: "stdio",
+								command: "",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		expect(() => resolveMcpServerRegistrations({ filePath })).toThrow(
+			"Invalid MCP settings",
+		);
+	});
+
+	it("accepts legacy flat stdio format", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						docs: {
+							command: "node",
+							args: ["server.js"],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const registrations = resolveMcpServerRegistrations({ filePath });
+		expect(registrations).toEqual([
+			{
+				name: "docs",
+				transport: {
+					type: "stdio",
+					command: "node",
+					args: ["server.js"],
+				},
+				disabled: undefined,
+				metadata: undefined,
+				oauth: undefined,
+			},
+		]);
+	});
+
+	it("accepts legacy flat url format and preserves explicit transportType", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						legacySse: {
+							url: "https://sse.example.com",
+						},
+						legacyHttp: {
+							url: "https://http.example.com",
+							transportType: "http",
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const registrations = resolveMcpServerRegistrations({ filePath });
+		expect(registrations).toEqual([
+			{
+				name: "legacySse",
+				transport: {
+					type: "sse",
+					url: "https://sse.example.com",
+				},
+				disabled: undefined,
+				metadata: undefined,
+				oauth: undefined,
+			},
+			{
+				name: "legacyHttp",
+				transport: {
+					type: "streamableHttp",
+					url: "https://http.example.com",
+				},
+				disabled: undefined,
+				metadata: undefined,
+				oauth: undefined,
+			},
+		]);
+	});
+
+	it("updates disabled state while preserving legacy server shape and top-level settings", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					otherSetting: true,
+					mcpServers: {
+						docs: {
+							command: "node",
+							args: ["server.js"],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		setMcpServerDisabled({ filePath, name: "docs", disabled: true });
+		const disabled = JSON.parse(await readFile(filePath, "utf8")) as {
+			otherSetting?: boolean;
+			mcpServers?: Record<
+				string,
+				{ command?: string; args?: string[]; disabled?: boolean }
+			>;
+		};
+		expect(disabled.otherSetting).toBe(true);
+		expect(disabled.mcpServers?.docs).toEqual({
+			command: "node",
+			args: ["server.js"],
+			disabled: true,
+		});
+
+		setMcpServerDisabled({ filePath, name: "docs", disabled: false });
+		const enabled = JSON.parse(await readFile(filePath, "utf8")) as {
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+		expect(enabled.mcpServers?.docs?.disabled).toBeUndefined();
+	});
+
+	it("loads and updates sdk-managed oauth state in server entries", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						linear: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.linear.app/mcp",
+							},
+							oauth: {
+								tokens: {
+									access_token: "old-token",
+									token_type: "Bearer",
+								},
+								lastAuthenticatedAt: 123,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const registrations = resolveMcpServerRegistrations({ filePath });
+		expect(registrations[0]?.oauth?.tokens?.access_token).toBe("old-token");
+		expect(listMcpServerOAuthStatuses({ filePath })).toEqual([
+			{
+				serverName: "linear",
+				oauthSupported: true,
+				oauthConfigured: true,
+				lastError: undefined,
+				lastAuthenticatedAt: 123,
+			},
+		]);
+
+		updateMcpServerOAuthState(
+			"linear",
+			(current) => ({
+				...current,
+				tokens: {
+					access_token: "new-token",
+					token_type: "Bearer",
+				},
+				lastError: undefined,
+			}),
+			{ filePath },
+		);
+
+		const written = JSON.parse(await readFile(filePath, "utf8")) as {
+			mcpServers: {
+				linear: {
+					oauth?: {
+						tokens?: Record<string, unknown>;
+						lastAuthenticatedAt?: number;
+					};
+				};
+			};
+		};
+		expect(written.mcpServers.linear.oauth?.tokens?.access_token).toBe(
+			"new-token",
+		);
+		expect(written.mcpServers.linear.oauth?.lastAuthenticatedAt).toBe(123);
+	});
+
+	it("rejects inherited server names when updating oauth state", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const objectPrototype = Object.prototype as { oauth?: unknown };
+		const originalOauth = objectPrototype.oauth;
+		try {
+			expect(() =>
+				updateMcpServerOAuthState(
+					"__proto__",
+					() => ({
+						tokens: {
+							access_token: "bad-token",
+						},
+					}),
+					{ filePath },
+				),
+			).toThrow("Unknown MCP server: __proto__");
+			expect(objectPrototype.oauth).toBe(originalOauth);
+		} finally {
+			if (originalOauth === undefined) {
+				delete objectPrototype.oauth;
+			} else {
+				objectPrototype.oauth = originalOauth;
+			}
+		}
+	});
+
+	it("serializes concurrent oauth updates so neither write is lost", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						linear: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://linear.example.com",
+							},
+						},
+						github: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://github.example.com",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		updateMcpServerOAuthState(
+			"linear",
+			() => ({ tokens: { access_token: "linear-token" } }),
+			{
+				filePath,
+			},
+		);
+		updateMcpServerOAuthState(
+			"github",
+			() => ({ tokens: { access_token: "github-token" } }),
+			{
+				filePath,
+			},
+		);
+
+		const written = JSON.parse(await readFile(filePath, "utf8"));
+		expect(written.mcpServers.linear.oauth?.tokens?.access_token).toBe(
+			"linear-token",
+		);
+		expect(written.mcpServers.github.oauth?.tokens?.access_token).toBe(
+			"github-token",
+		);
+		// Lockfile is released after each critical section.
+		expect(existsSync(`${filePath}.lock`)).toBe(false);
+	});
+
+	it("reclaims a stale lock directory older than the hang timeout", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify({ mcpServers: {} }, null, 2),
+			"utf8",
+		);
+
+		// Simulate a crashed writer that left a lock directory behind, backdated well
+		// past the 10s stale threshold.
+		const lockPath = `${filePath}.lock`;
+		mkdirSync(lockPath);
+		writeFileSync(join(lockPath, "owner.dead"), "dead-owner");
+		const stale = new Date(Date.now() - 60_000);
+		const { utimesSync } = await import("node:fs");
+		utimesSync(lockPath, stale, stale);
+
+		let ran = false;
+		updateMcpSettingsFileSync(filePath, () => {
+			ran = true;
+		});
+
+		expect(ran).toBe(true);
+		// The stale lock was reclaimed and our own lock released afterward.
+		expect(existsSync(lockPath)).toBe(false);
+		expect(statSync(filePath).isFile()).toBe(true);
+	});
+
+	it("does not delete another owner's replacement lock directory on release", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify({ mcpServers: {} }, null, 2),
+			"utf8",
+		);
+
+		const lockPath = `${filePath}.lock`;
+		updateMcpSettingsFileSync(filePath, () => {
+			// Simulate another process reclaiming our lock directory before our
+			// finally release runs. Release must remove only our owner marker and then
+			// rmdir the directory; a populated replacement must survive.
+			const [owner] = readdirSync(lockPath);
+			unlinkSync(join(lockPath, owner));
+			rmdirSync(lockPath);
+			const replacement = `${lockPath}.replacement`;
+			mkdirSync(replacement);
+			writeFileSync(
+				join(replacement, "owner.replacement"),
+				"replacement-owner",
+				{ flag: "wx" },
+			);
+			renameSync(replacement, lockPath);
+		});
+
+		expect(readdirSync(lockPath)).toEqual(["owner.replacement"]);
+	});
+
+	it("rejects impure settings mutators whose output changes across calls", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-config-loader-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify({ mcpServers: {} }, null, 2),
+			"utf8",
+		);
+
+		let count = 0;
+		expect(() =>
+			updateMcpSettingsFileSync(filePath, (settings) => {
+				count += 1;
+				settings.mcpServers = { generated: { counter: count } };
+			}),
+		).toThrow(McpSettingsMutatorPurityError);
+	});
+});
+
+describe("updateMcpSettingsFile (async acquisition)", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((directory) =>
+				rm(directory, { recursive: true, force: true }),
+			),
+		);
+		tempRoots.length = 0;
+	});
+
+	async function makeSettingsFile(): Promise<string> {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-mcp-config-loader-async-"),
+		);
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify({ mcpServers: {} }, null, 2),
+			"utf8",
+		);
+		return filePath;
+	}
+
+	it("runs the mutator and releases the lock on the uncontended path", async () => {
+		const filePath = await makeSettingsFile();
+		let mutatorRan = false;
+
+		const result = await updateMcpSettingsFile(filePath, (settings) => {
+			mutatorRan = true;
+			settings.mcpServers = {
+				alpha: { transport: { type: "stdio", command: "node" } },
+			};
+			return "ok";
+		});
+
+		// The mutator (a synchronous, pure function) ran, the write landed, and the
+		// lock directory is gone — i.e. the lock is never left held after resolution.
+		// (That the lock is never held *across* an await is covered by the contended
+		// test below, which asserts serialization without any Atomics.wait.)
+		expect(mutatorRan).toBe(true);
+		expect(result).toBe("ok");
+		expect(existsSync(`${filePath}.lock`)).toBe(false);
+		const written = JSON.parse(await readFile(filePath, "utf8"));
+		expect(written.mcpServers.alpha.transport.command).toBe("node");
+	});
+
+	it("serializes contended async updates without losing a write and never blocks the event loop", async () => {
+		const filePath = await makeSettingsFile();
+		const waitSpy = vi.spyOn(Atomics, "wait");
+		try {
+			// Pre-place a held lock owned by a fictional live process so the first
+			// real update has to wait (and therefore exercise the await-delay path).
+			const lockDir = `${filePath}.lock`;
+			mkdirSync(lockDir);
+			writeFileSync(join(lockDir, "owner.holder"), "holder");
+
+			const linear = updateMcpSettingsFile(
+				filePath,
+				(settings) => {
+					const servers = settings.mcpServers as Record<
+						string,
+						Record<string, unknown>
+					>;
+					servers.linear.oauth = { tokens: { access_token: "linear-token" } };
+				},
+				{ timeoutMs: 5_000 },
+			).catch(() => undefined);
+			const github = updateMcpSettingsFile(
+				filePath,
+				(settings) => {
+					const servers = settings.mcpServers as Record<
+						string,
+						Record<string, unknown>
+					>;
+					servers.github.oauth = { tokens: { access_token: "github-token" } };
+				},
+				{ timeoutMs: 5_000 },
+			).catch(() => undefined);
+
+			// Seed the two servers while the contender(s) are parked on the lock,
+			// then release the held lock so the waiters can proceed.
+			await writeFile(
+				filePath,
+				JSON.stringify(
+					{
+						mcpServers: {
+							linear: {
+								transport: {
+									type: "streamableHttp",
+									url: "https://linear.example.com",
+								},
+							},
+							github: {
+								transport: {
+									type: "streamableHttp",
+									url: "https://github.example.com",
+								},
+							},
+						},
+					},
+					null,
+					2,
+				),
+				"utf8",
+			);
+			unlinkSync(join(lockDir, "owner.holder"));
+			rmdirSync(lockDir);
+
+			await Promise.all([linear, github]);
+
+			const written = JSON.parse(await readFile(filePath, "utf8"));
+			expect(written.mcpServers.linear.oauth?.tokens?.access_token).toBe(
+				"linear-token",
+			);
+			expect(written.mcpServers.github.oauth?.tokens?.access_token).toBe(
+				"github-token",
+			);
+			// Lock released after each critical section.
+			expect(existsSync(lockDir)).toBe(false);
+			// The whole point of the async path: it must never freeze the loop.
+			expect(waitSpy).not.toHaveBeenCalled();
+		} finally {
+			waitSpy.mockRestore();
+		}
+	});
+
+	it("creates a missing settings file inside the lock", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-mcp-config-loader-async-"),
+		);
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+
+		await updateMcpSettingsFile(filePath, (settings) => {
+			const servers = settings.mcpServers as Record<string, unknown>;
+			servers.docs = { transport: { type: "stdio", command: "node" } };
+		});
+
+		const written = JSON.parse(await readFile(filePath, "utf8"));
+		expect(Object.keys(written.mcpServers)).toEqual(["docs"]);
+	});
+
+	it("reclaims a stale lock directory on the async path", async () => {
+		const filePath = await makeSettingsFile();
+		const lockDir = `${filePath}.lock`;
+		mkdirSync(lockDir);
+		writeFileSync(join(lockDir, "owner.dead"), "dead-owner");
+		const stale = new Date(Date.now() - 60_000);
+		const { utimesSync } = await import("node:fs");
+		utimesSync(lockDir, stale, stale);
+
+		let ran = false;
+		await updateMcpSettingsFile(filePath, () => {
+			ran = true;
+		});
+
+		expect(ran).toBe(true);
+		expect(existsSync(lockDir)).toBe(false);
+	});
+
+	it("fails fast on a reentrant settings update instead of deadlocking the loop", async () => {
+		const filePath = await makeSettingsFile();
+
+		await expect(
+			updateMcpSettingsFile(filePath, () => {
+				// A nested write on the same file would deadlock against the lock we
+				// already hold; the shared reentrancy guard must reject it instead.
+				updateMcpSettingsFileSync(filePath, () => {});
+			}),
+		).rejects.toThrow(/Reentrant MCP settings update/);
+
+		// Guard ran inside the mutator, but the outer lock is still cleaned up.
+		expect(existsSync(`${filePath}.lock`)).toBe(false);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/mcp/config-loader.ts b/sdk/packages/core/src/extensions/mcp/config-loader.ts
new file mode 100644
index 0000000..898402a
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/config-loader.ts
@@ -0,0 +1,828 @@
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	rmdirSync,
+	rmSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import type { BasicLogger } from "@cline/shared";
+import { resolveMcpSettingsPath } from "@cline/shared/storage";
+import { z } from "zod";
+import type {
+	McpManager,
+	McpServerOAuthState,
+	McpServerOAuthStatus,
+	McpServerRegistration,
+} from "./types";
+
+const stringRecordSchema = z.record(z.string(), z.string());
+const metadataSchema = z.record(z.string(), z.unknown());
+const oauthStateSchema = z
+	.object({
+		clientInformation: z.record(z.string(), z.unknown()).optional(),
+		tokens: z.record(z.string(), z.unknown()).optional(),
+		codeVerifier: z.string().optional(),
+		discoveryState: z.record(z.string(), z.unknown()).optional(),
+		redirectUrl: z.string().url().optional(),
+		lastError: z.string().optional(),
+		lastAuthenticatedAt: z.number().int().positive().optional(),
+	})
+	.strip();
+
+const stdioTransportSchema = z.object({
+	type: z.literal("stdio"),
+	command: z.string().min(1),
+	args: z.array(z.string()).optional(),
+	cwd: z.string().min(1).optional(),
+	env: stringRecordSchema.optional(),
+});
+
+const sseTransportSchema = z.object({
+	type: z.literal("sse"),
+	url: z.string().url(),
+	headers: stringRecordSchema.optional(),
+});
+
+const streamableHttpTransportSchema = z.object({
+	type: z.literal("streamableHttp"),
+	url: z.string().url(),
+	headers: stringRecordSchema.optional(),
+});
+
+const mcpTransportSchema = z.discriminatedUnion("type", [
+	stdioTransportSchema,
+	sseTransportSchema,
+	streamableHttpTransportSchema,
+]);
+
+const nestedRegistrationBodySchema = z.object({
+	transport: mcpTransportSchema,
+	disabled: z.boolean().optional(),
+	metadata: metadataSchema.optional(),
+	oauth: oauthStateSchema.optional(),
+});
+
+const legacyTransportTypeSchema = z
+	.enum(["stdio", "sse", "http", "streamableHttp"])
+	.optional();
+
+const legacyRegistrationBaseSchema = z.object({
+	type: z.enum(["stdio", "sse", "streamableHttp"]).optional(),
+	transportType: legacyTransportTypeSchema,
+	disabled: z.boolean().optional(),
+	metadata: metadataSchema.optional(),
+	oauth: oauthStateSchema.optional(),
+});
+
+function mapLegacyTransportType(
+	transportType: z.infer<typeof legacyTransportTypeSchema>,
+): "stdio" | "sse" | "streamableHttp" | undefined {
+	if (!transportType) {
+		return undefined;
+	}
+	if (transportType === "http") {
+		return "streamableHttp";
+	}
+	return transportType;
+}
+
+const legacyStdioRegistrationSchema = legacyRegistrationBaseSchema
+	.extend({
+		command: z.string().min(1),
+		args: z.array(z.string()).optional(),
+		cwd: z.string().min(1).optional(),
+		env: stringRecordSchema.optional(),
+	})
+	.superRefine((value, ctx) => {
+		const resolvedType =
+			value.type ?? mapLegacyTransportType(value.transportType);
+		if (resolvedType && resolvedType !== "stdio") {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: 'Expected type "stdio" for command-based MCP server',
+				path: ["type"],
+			});
+		}
+	})
+	.transform((value) => ({
+		transport: {
+			type: "stdio" as const,
+			command: value.command,
+			args: value.args,
+			cwd: value.cwd,
+			env: value.env,
+		},
+		disabled: value.disabled,
+		metadata: value.metadata,
+		oauth: value.oauth,
+	}));
+
+const legacyUrlRegistrationSchema = legacyRegistrationBaseSchema
+	.extend({
+		url: z.string().url(),
+		headers: stringRecordSchema.optional(),
+	})
+	.superRefine((value, ctx) => {
+		const resolvedType =
+			value.type ?? mapLegacyTransportType(value.transportType) ?? "sse";
+		if (resolvedType !== "sse" && resolvedType !== "streamableHttp") {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message:
+					'Expected type "sse" or "streamableHttp" for URL-based MCP server',
+				path: ["type"],
+			});
+		}
+	})
+	.transform((value) => {
+		const resolvedType =
+			value.type ?? mapLegacyTransportType(value.transportType) ?? "sse";
+		if (resolvedType === "streamableHttp") {
+			return {
+				transport: {
+					type: "streamableHttp" as const,
+					url: value.url,
+					headers: value.headers,
+				},
+				disabled: value.disabled,
+				metadata: value.metadata,
+				oauth: value.oauth,
+			};
+		}
+		return {
+			transport: {
+				type: "sse" as const,
+				url: value.url,
+				headers: value.headers,
+			},
+			disabled: value.disabled,
+			metadata: value.metadata,
+			oauth: value.oauth,
+		};
+	});
+
+const mcpRegistrationBodySchema = z.union([
+	nestedRegistrationBodySchema,
+	legacyStdioRegistrationSchema,
+	legacyUrlRegistrationSchema,
+]);
+
+const mcpSettingsSchema = z
+	.object({
+		mcpServers: z.record(z.string(), mcpRegistrationBodySchema),
+	})
+	.passthrough();
+
+export interface McpSettingsFile {
+	mcpServers: Record<string, Omit<McpServerRegistration, "name">>;
+}
+
+export interface LoadMcpSettingsOptions {
+	filePath?: string;
+}
+
+export interface RegisterMcpServersFromSettingsOptions {
+	filePath?: string;
+}
+
+export interface SetMcpServerDisabledOptions {
+	filePath?: string;
+	name: string;
+	disabled: boolean;
+}
+
+export interface McpSettingsLockOptions {
+	/** Maximum time to wait for the lock before failing. Defaults to 10 seconds. */
+	timeoutMs?: number;
+	/** Optional host logger; stale-lock takeover is logged as severity=warn. */
+	logger?: BasicLogger;
+}
+
+export type McpSettingsMutator<T> = (settings: Record<string, unknown>) => T;
+
+export class McpSettingsUpdateSkippedError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "McpSettingsUpdateSkippedError";
+	}
+}
+
+export class McpSettingsLockTimeoutError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "McpSettingsLockTimeoutError";
+	}
+}
+
+export class McpSettingsMutatorPurityError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "McpSettingsMutatorPurityError";
+	}
+}
+
+export function resolveDefaultMcpSettingsPath(): string {
+	return resolveMcpSettingsPath();
+}
+
+/**
+ * Atomically write the MCP settings file using a temp file + rename.
+ *
+ * Multiple processes (CLI, VSCode extension windows, JetBrains) read and write
+ * this file concurrently. A plain writeFileSync can be observed half-written by
+ * a concurrent reader, surfacing as a JSON parse error or, for a client that
+ * treats an unreadable file as "no servers", silently dropping MCP state.
+ * Rename within the same directory is atomic on POSIX and on NTFS, so a reader
+ * always observes either the old or the new complete file.
+ */
+function atomicWriteSettingsFile(filePath: string, contents: string): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random()
+		.toString(36)
+		.slice(2)}`;
+	try {
+		writeFileSync(tempPath, contents, { encoding: "utf8", flag: "wx" });
+		renameSync(tempPath, filePath);
+	} catch (error) {
+		try {
+			unlinkSync(tempPath);
+		} catch {
+			// Best-effort cleanup of the temp file.
+		}
+		throw error;
+	}
+}
+
+/**
+ * How long (ms) a lock directory may exist before it is considered stale and
+ * forcibly reclaimed. A real critical section here is a handful of synchronous
+ * file ops (sub-millisecond), so this is orders of magnitude larger than any
+ * legitimate hold. A lock older than this can only mean the owner crashed or
+ * was killed mid-update, so taking it over prevents a permanent deadlock.
+ */
+const SETTINGS_LOCK_STALE_MS = 10_000;
+
+/** Poll interval (ms) while waiting for another process to release the lock. */
+const SETTINGS_LOCK_POLL_MS = 25;
+
+const syncSleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+
+/**
+ * Lock directories this process currently holds. The on-disk lock is not
+ * reentrant, so a settings update whose file is already locked by this process
+ * throws rather than waiting. Both acquisition paths register here.
+ */
+const activeLocks = new Set<string>();
+
+function sleepSync(ms: number): void {
+	Atomics.wait(syncSleepBuffer, 0, 0, ms);
+}
+
+function settingsLockDir(filePath: string): string {
+	return `${filePath}.lock`;
+}
+
+function makeLockToken(): string {
+	return `${process.pid}.${Date.now()}.${randomUUID()}`;
+}
+
+interface AcquiredSettingsLock {
+	lockDir: string;
+	ownerFile: string;
+}
+
+/**
+ * Cross-process lock implemented as a populated directory. Acquisition creates a
+ * staging directory, writes a unique owner marker inside it, then renames the
+ * populated directory into place. That means the visible lock directory is never
+ * empty. Release only deletes our marker and then rmdir's the directory; if
+ * another owner replaced the lock, our marker is absent or the directory is
+ * non-empty, so we do not remove their lock. Stale takeover renames the whole
+ * lock directory aside before deleting it. This uses standard mkdir/rename/rmdir
+ * operations and avoids inode- or handle-based deletion, so it works with
+ * Node's portable fs APIs on Windows and POSIX.
+ */
+function tryAcquireSettingsLock(
+	lockDir: string,
+	token: string,
+): AcquiredSettingsLock | undefined {
+	mkdirSync(dirname(lockDir), { recursive: true });
+	const stagingDir = `${lockDir}.tmp.${token}`;
+	rmSync(stagingDir, { recursive: true, force: true });
+	mkdirSync(stagingDir, { recursive: true });
+	writeFileSync(join(stagingDir, `owner.${token}`), token, {
+		encoding: "utf8",
+		flag: "wx",
+	});
+	try {
+		renameSync(stagingDir, lockDir);
+		return { lockDir, ownerFile: join(lockDir, `owner.${token}`) };
+	} catch (error) {
+		rmSync(stagingDir, { recursive: true, force: true });
+		if (existsSync(lockDir)) {
+			return undefined;
+		}
+		throw error;
+	}
+}
+
+function reclaimStaleLock(
+	lockDir: string,
+	options: McpSettingsLockOptions,
+): void {
+	let ageMs: number;
+	try {
+		ageMs = Date.now() - statSync(lockDir).mtimeMs;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return;
+		}
+		throw error;
+	}
+	if (ageMs < SETTINGS_LOCK_STALE_MS) {
+		return;
+	}
+	options.logger?.log(
+		`[mcp-settings] Stale lock directory at ${lockDir} (age ${ageMs}ms); reclaiming.`,
+		{
+			severity: "warn",
+		},
+	);
+	const staleDir = `${lockDir}.stale.${makeLockToken()}`;
+	try {
+		renameSync(lockDir, staleDir);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return;
+		}
+		throw error;
+	}
+	rmSync(staleDir, { recursive: true, force: true });
+}
+
+function releaseSettingsLock(lock: AcquiredSettingsLock): void {
+	try {
+		unlinkSync(lock.ownerFile);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			throw error;
+		}
+	}
+	try {
+		rmdirSync(lock.lockDir);
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+			throw error;
+		}
+	}
+}
+
+function beginAcquire(filePath: string): { lockDir: string; token: string } {
+	const lockDir = settingsLockDir(filePath);
+	if (activeLocks.has(lockDir)) {
+		throw new Error(
+			`Reentrant MCP settings update for ${filePath}. Keep mutators pure: compute values up front and do not call back into the settings API.`,
+		);
+	}
+	return { lockDir, token: makeLockToken() };
+}
+
+function acquireSettingsLockSync(
+	filePath: string,
+	options: McpSettingsLockOptions,
+): AcquiredSettingsLock {
+	const { lockDir, token } = beginAcquire(filePath);
+	const timeoutMs = options.timeoutMs ?? SETTINGS_LOCK_STALE_MS;
+	const startedAt = Date.now();
+	while (true) {
+		const lock = tryAcquireSettingsLock(lockDir, token);
+		if (lock) {
+			activeLocks.add(lockDir);
+			return lock;
+		}
+		if (Date.now() - startedAt > timeoutMs) {
+			throw new McpSettingsLockTimeoutError(
+				`Timed out waiting for MCP settings lock at ${lockDir} after ${timeoutMs}ms.`,
+			);
+		}
+		reclaimStaleLock(lockDir, options);
+		sleepSync(SETTINGS_LOCK_POLL_MS);
+	}
+}
+
+/**
+ * Acquire the settings lock, yielding the event loop (`await delay`) between
+ * attempts. Reclaims a stale lock left by a crashed holder and throws
+ * McpSettingsLockTimeoutError once `timeoutMs` elapses.
+ */
+async function acquireSettingsLockAsync(
+	filePath: string,
+	options: McpSettingsLockOptions,
+): Promise<AcquiredSettingsLock> {
+	const { lockDir, token } = beginAcquire(filePath);
+	const timeoutMs = options.timeoutMs ?? SETTINGS_LOCK_STALE_MS;
+	const startedAt = Date.now();
+	while (true) {
+		const lock = tryAcquireSettingsLock(lockDir, token);
+		if (lock) {
+			activeLocks.add(lockDir);
+			return lock;
+		}
+		if (Date.now() - startedAt > timeoutMs) {
+			throw new McpSettingsLockTimeoutError(
+				`Timed out waiting for MCP settings lock at ${lockDir} after ${timeoutMs}ms.`,
+			);
+		}
+		reclaimStaleLock(lockDir, options);
+		await delay(SETTINGS_LOCK_POLL_MS);
+	}
+}
+
+/**
+ * Run the read-modify-write while the lock is held. The body is synchronous and
+ * never yields, so a concurrent waiter cannot interleave between the read and
+ * the write, and the lock is released the moment the mutation completes.
+ */
+function runLockedSettingsMutation<T>(
+	lock: AcquiredSettingsLock,
+	filePath: string,
+	mutator: McpSettingsMutator<T>,
+): T {
+	try {
+		const settings = loadRawSettingsObject(filePath);
+		const result = runPureSettingsMutator(settings, mutator);
+		atomicWriteSettingsFile(filePath, `${JSON.stringify(settings, null, 2)}\n`);
+		return result;
+	} finally {
+		activeLocks.delete(lock.lockDir);
+		releaseSettingsLock(lock);
+	}
+}
+
+/**
+ * Locked MCP settings read-modify-write that blocks the event loop (via
+ * `Atomics.wait`) while acquiring the lock.
+ *
+ * Prefer {@link updateMcpSettingsFile}: async acquisition keeps the event loop
+ * free and behaves identically otherwise.
+ *
+ * TODO: Delete once all callers migrate to {@link updateMcpSettingsFile}.
+ *
+ * The mutator is synchronous and may be called more than once with the same
+ * input to verify it is pure/deterministic. Compute any I/O, logging, network,
+ * timestamp, or random values before calling and close over them. Return a value
+ * only for a successful update; throw McpSettingsUpdateSkippedError to skip.
+ */
+export function updateMcpSettingsFileSync<T>(
+	filePath: string,
+	mutator: McpSettingsMutator<T>,
+	options: McpSettingsLockOptions = {},
+): T {
+	const lock = acquireSettingsLockSync(filePath, options);
+	return runLockedSettingsMutation(lock, filePath, mutator);
+}
+
+/**
+ * Locked MCP settings read-modify-write that yields the event loop while
+ * acquiring the lock, so concurrent work on the same loop keeps running.
+ *
+ * The mutator is synchronous and may be called more than once with the same
+ * input to verify it is pure/deterministic. Compute any I/O, logging, network,
+ * timestamp, or random values before calling and close over them. The lock is
+ * held only across the synchronous mutation, never across an `await`. Return a
+ * value only for a successful update; throw McpSettingsUpdateSkippedError to skip.
+ */
+export async function updateMcpSettingsFile<T>(
+	filePath: string,
+	mutator: McpSettingsMutator<T>,
+	options: McpSettingsLockOptions = {},
+): Promise<T> {
+	const lock = await acquireSettingsLockAsync(filePath, options);
+	return runLockedSettingsMutation(lock, filePath, mutator);
+}
+
+/**
+ * Read the settings object for a locked read-modify-write. A missing file
+ * bootstraps to `{ mcpServers: {} }`, so the first write to a fresh path creates
+ * the file inside the lock instead of throwing. The subsequent atomic write
+ * persists it.
+ */
+function loadRawSettingsObject(filePath: string): Record<string, unknown> {
+	const settings = readJsonObjectOrEmpty(filePath);
+	if (
+		!settings.mcpServers ||
+		typeof settings.mcpServers !== "object" ||
+		Array.isArray(settings.mcpServers)
+	) {
+		settings.mcpServers = {};
+	}
+	return settings;
+}
+
+function runPureSettingsMutator<T>(
+	settings: Record<string, unknown>,
+	mutator: McpSettingsMutator<T>,
+): T {
+	const before = JSON.stringify(settings);
+	const shadow = JSON.parse(before) as Record<string, unknown>;
+	const shadowResult = mutator(shadow);
+	const shadowAfter = JSON.stringify(shadow);
+	const result = mutator(settings);
+	const after = JSON.stringify(settings);
+	if (after !== shadowAfter) {
+		throw new McpSettingsMutatorPurityError(
+			"MCP settings mutator must be deterministic and free of side effects; repeated calls produced different settings.",
+		);
+	}
+	if (JSON.stringify(result) !== JSON.stringify(shadowResult)) {
+		throw new McpSettingsMutatorPurityError(
+			"MCP settings mutator must be deterministic and free of side effects; repeated calls produced different return values.",
+		);
+	}
+	return result;
+}
+
+function readJsonObject(filePath: string): Record<string, unknown> {
+	const raw = readFileSync(filePath, "utf8");
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		const details = error instanceof Error ? error.message : String(error);
+		throw new Error(
+			`Failed to parse MCP settings JSON at "${filePath}": ${details}`,
+		);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new Error(`Invalid MCP settings at "${filePath}": expected object.`);
+	}
+	return parsed as Record<string, unknown>;
+}
+
+/**
+ * Like {@link readJsonObject}, but treats a missing file as an empty object so a
+ * locked write can create it. A present-but-malformed file still throws.
+ */
+function readJsonObjectOrEmpty(filePath: string): Record<string, unknown> {
+	try {
+		return readJsonObject(filePath);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return {};
+		}
+		throw error;
+	}
+}
+
+function getOwnServerRecord(
+	servers: Record<string, unknown>,
+	name: string,
+): Record<string, unknown> | undefined {
+	if (!Object.hasOwn(servers, name)) {
+		return undefined;
+	}
+	const value = servers[name];
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return value as Record<string, unknown>;
+}
+
+function setOwnServerRecord(
+	servers: Record<string, unknown>,
+	name: string,
+	value: Record<string, unknown>,
+): void {
+	Object.defineProperty(servers, name, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true,
+	});
+}
+
+export function loadMcpSettingsFile(
+	options: LoadMcpSettingsOptions = {},
+): McpSettingsFile {
+	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
+	const raw = readFileSync(filePath, "utf8");
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		const details = error instanceof Error ? error.message : String(error);
+		throw new Error(
+			`Failed to parse MCP settings JSON at "${filePath}": ${details}`,
+		);
+	}
+	const result = mcpSettingsSchema.safeParse(parsed);
+	if (!result.success) {
+		const details = result.error.issues
+			.map((issue) => {
+				const path = issue.path.join(".");
+				return path ? `${path}: ${issue.message}` : issue.message;
+			})
+			.join("; ");
+		throw new Error(`Invalid MCP settings at "${filePath}": ${details}`);
+	}
+	return result.data;
+}
+
+export function normalizeMcpServerOAuthState(
+	value: McpServerOAuthState | undefined,
+): McpServerOAuthState | undefined {
+	if (!value) {
+		return undefined;
+	}
+	const normalized: McpServerOAuthState = {
+		...(value.clientInformation
+			? { clientInformation: value.clientInformation }
+			: {}),
+		...(value.tokens ? { tokens: value.tokens } : {}),
+		...(value.codeVerifier ? { codeVerifier: value.codeVerifier } : {}),
+		...(value.discoveryState ? { discoveryState: value.discoveryState } : {}),
+		...(value.redirectUrl ? { redirectUrl: value.redirectUrl } : {}),
+		...(value.lastError ? { lastError: value.lastError } : {}),
+		...(value.lastAuthenticatedAt
+			? { lastAuthenticatedAt: value.lastAuthenticatedAt }
+			: {}),
+	};
+	return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function validateOauthState(value: unknown): McpServerOAuthState | undefined {
+	if (value === undefined) {
+		return undefined;
+	}
+	const result = oauthStateSchema.safeParse(value);
+	if (!result.success) {
+		return undefined;
+	}
+	return normalizeMcpServerOAuthState(result.data);
+}
+
+export function hasMcpSettingsFile(
+	options: LoadMcpSettingsOptions = {},
+): boolean {
+	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
+	return existsSync(filePath);
+}
+
+export function resolveMcpServerRegistrations(
+	options: LoadMcpSettingsOptions = {},
+): McpServerRegistration[] {
+	const config = loadMcpSettingsFile(options);
+	return Object.entries(config.mcpServers).map(([name, value]) => ({
+		name,
+		transport: value.transport,
+		disabled: value.disabled,
+		metadata: value.metadata,
+		oauth: value.oauth,
+	}));
+}
+
+export function setMcpServerDisabled(
+	options: SetMcpServerDisabledOptions,
+): void {
+	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
+	const name = options.name.trim();
+	if (!name) {
+		throw new Error("MCP server settings toggle requires a server name.");
+	}
+	updateMcpSettingsFileSync(filePath, (settings) => {
+		const serversValue = settings.mcpServers;
+		if (
+			!serversValue ||
+			typeof serversValue !== "object" ||
+			Array.isArray(serversValue)
+		) {
+			throw new Error(
+				`Invalid MCP settings at "${filePath}": mcpServers must be an object.`,
+			);
+		}
+		const servers = { ...(serversValue as Record<string, unknown>) };
+		const current = getOwnServerRecord(servers, name);
+		if (!current) {
+			throw new Error(`Unknown MCP server: ${name}`);
+		}
+		const next = { ...current };
+		if (options.disabled) {
+			next.disabled = true;
+		} else {
+			delete next.disabled;
+		}
+		setOwnServerRecord(servers, name, next);
+		settings.mcpServers = servers;
+	});
+}
+
+export function getMcpServerOAuthState(
+	serverName: string,
+	options: LoadMcpSettingsOptions = {},
+): McpServerOAuthState | undefined {
+	const config = loadMcpSettingsFile(options);
+	if (!Object.hasOwn(config.mcpServers, serverName)) {
+		return undefined;
+	}
+	return normalizeMcpServerOAuthState(config.mcpServers[serverName]?.oauth);
+}
+
+function buildOAuthStateMutator(
+	serverName: string,
+	updater: (current: McpServerOAuthState) => McpServerOAuthState,
+): McpSettingsMutator<McpServerOAuthState> {
+	return (settings) => {
+		const servers = settings.mcpServers as Record<string, unknown>;
+		const server = getOwnServerRecord(servers, serverName);
+		if (!server) {
+			throw new Error(`Unknown MCP server: ${serverName}`);
+		}
+
+		const current = validateOauthState(server.oauth) ?? {};
+		const updated = normalizeMcpServerOAuthState(updater(current));
+		if (updated) {
+			server.oauth = updated;
+		} else {
+			delete server.oauth;
+		}
+		return updated ?? {};
+	};
+}
+
+/**
+ * Scoped read-modify-write of one server's `oauth` block that blocks the event
+ * loop while acquiring the lock.
+ *
+ * Prefer {@link updateMcpServerOAuthStateAsync}.
+ *
+ * TODO: Delete once all callers migrate to {@link updateMcpServerOAuthStateAsync}.
+ */
+export function updateMcpServerOAuthState(
+	serverName: string,
+	updater: (current: McpServerOAuthState) => McpServerOAuthState,
+	options: LoadMcpSettingsOptions = {},
+): McpServerOAuthState {
+	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
+	return updateMcpSettingsFileSync(
+		filePath,
+		buildOAuthStateMutator(serverName, updater),
+	);
+}
+
+/**
+ * Scoped read-modify-write of one server's `oauth` block that yields the event
+ * loop while acquiring the lock. The updater is synchronous and pure; it
+ * receives the server's current OAuth state and returns the next state.
+ */
+export async function updateMcpServerOAuthStateAsync(
+	serverName: string,
+	updater: (current: McpServerOAuthState) => McpServerOAuthState,
+	options: LoadMcpSettingsOptions = {},
+): Promise<McpServerOAuthState> {
+	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
+	return updateMcpSettingsFile(
+		filePath,
+		buildOAuthStateMutator(serverName, updater),
+	);
+}
+
+export function listMcpServerOAuthStatuses(
+	options: LoadMcpSettingsOptions = {},
+): McpServerOAuthStatus[] {
+	const registrations = resolveMcpServerRegistrations(options);
+	return registrations
+		.map((registration) => {
+			const oauthSupported = registration.transport.type !== "stdio";
+			const accessToken = registration.oauth?.tokens?.access_token;
+			return {
+				serverName: registration.name,
+				oauthSupported,
+				oauthConfigured:
+					oauthSupported &&
+					typeof accessToken === "string" &&
+					accessToken.trim().length > 0,
+				lastError: registration.oauth?.lastError,
+				lastAuthenticatedAt: registration.oauth?.lastAuthenticatedAt,
+			};
+		})
+		.sort((left, right) => left.serverName.localeCompare(right.serverName));
+}
+
+export async function registerMcpServersFromSettingsFile(
+	manager: Pick<McpManager, "registerServer">,
+	options: RegisterMcpServersFromSettingsOptions = {},
+): Promise<McpServerRegistration[]> {
+	const registrations = resolveMcpServerRegistrations(options);
+	for (const registration of registrations) {
+		await manager.registerServer(registration);
+	}
+	return registrations;
+}
diff --git a/sdk/packages/core/src/extensions/mcp/index.ts b/sdk/packages/core/src/extensions/mcp/index.ts
new file mode 100644
index 0000000..82c2638
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/index.ts
@@ -0,0 +1,70 @@
+export type { DefaultMcpServerClientFactoryOptions } from "./client";
+export { createDefaultMcpServerClientFactory } from "./client";
+export type {
+	LoadMcpSettingsOptions,
+	McpSettingsLockOptions,
+	McpSettingsMutator,
+	McpSettingsFile,
+	RegisterMcpServersFromSettingsOptions,
+	SetMcpServerDisabledOptions,
+} from "./config-loader";
+export {
+	getMcpServerOAuthState,
+	hasMcpSettingsFile,
+	listMcpServerOAuthStatuses,
+	loadMcpSettingsFile,
+	registerMcpServersFromSettingsFile,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+	setMcpServerDisabled,
+	updateMcpServerOAuthState,
+	updateMcpServerOAuthStateAsync,
+	updateMcpSettingsFile,
+	updateMcpSettingsFileSync,
+	McpSettingsLockTimeoutError,
+	McpSettingsMutatorPurityError,
+	McpSettingsUpdateSkippedError,
+} from "./config-loader";
+export { InMemoryMcpManager } from "./manager";
+export type {
+	AuthorizeMcpServerOAuthOptions,
+	AuthorizeMcpServerOAuthResult,
+	CreateMcpOAuthProviderContextOptions,
+	McpOAuthProviderContext,
+} from "./oauth";
+export { authorizeMcpServerOAuth } from "./oauth";
+export type { PluginMcpServerResolution } from "./plugin-server-registration";
+export {
+	normalizePluginMcpServerRegistration,
+	resolvePluginMcpServerRegistrations,
+} from "./plugin-server-registration";
+export type {
+	CreateDisabledMcpToolPoliciesOptions,
+	CreateDisabledMcpToolPolicyOptions,
+} from "./policies";
+export {
+	createDisabledMcpToolPolicies,
+	createDisabledMcpToolPolicy,
+} from "./policies";
+export { createMcpTools } from "./tools";
+export type {
+	CreateMcpToolsOptions,
+	McpConnectionStatus,
+	McpManager,
+	McpManagerOptions,
+	McpServerClient,
+	McpServerClientFactory,
+	McpServerOAuthState,
+	McpServerOAuthStatus,
+	McpServerRegistration,
+	McpServerSnapshot,
+	McpServerTransportConfig,
+	McpSseTransportConfig,
+	McpStdioTransportConfig,
+	McpStreamableHttpTransportConfig,
+	McpToolCallRequest,
+	McpToolCallResult,
+	McpToolDescriptor,
+	McpToolNameTransform,
+	McpToolProvider,
+} from "./types";
diff --git a/sdk/packages/core/src/extensions/mcp/manager.test.ts b/sdk/packages/core/src/extensions/mcp/manager.test.ts
new file mode 100644
index 0000000..1a1fc07
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/manager.test.ts
@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from "vitest";
+import { InMemoryMcpManager } from "./manager";
+import type { McpServerClient, McpToolDescriptor } from "./types";
+
+function createClient(overrides?: Partial<McpServerClient>): McpServerClient {
+	return {
+		connect: vi.fn(async () => {}),
+		disconnect: vi.fn(async () => {}),
+		listTools: vi.fn(async () => []),
+		callTool: vi.fn(async () => ({ ok: true })),
+		...overrides,
+	};
+}
+
+describe("InMemoryMcpManager", () => {
+	it("registers servers, connects on demand, and calls tools", async () => {
+		const toolDescriptors: readonly McpToolDescriptor[] = [
+			{
+				name: "search",
+				inputSchema: {
+					type: "object",
+					properties: { q: { type: "string" } },
+					required: ["q"],
+				},
+			},
+		];
+		const client = createClient({
+			listTools: vi.fn(async () => toolDescriptors),
+		});
+		const manager = new InMemoryMcpManager({
+			clientFactory: vi.fn(async () => client),
+		});
+
+		await manager.registerServer({
+			name: "docs",
+			transport: {
+				type: "streamableHttp",
+				url: "https://mcp.example.test",
+			},
+		});
+
+		const tools = await manager.listTools("docs");
+		expect(tools).toHaveLength(1);
+
+		await manager.callTool({
+			serverName: "docs",
+			toolName: "search",
+			arguments: { q: "oauth flow" },
+		});
+
+		expect(client.connect).toHaveBeenCalledTimes(1);
+		expect(client.callTool).toHaveBeenCalledWith({
+			name: "search",
+			arguments: { q: "oauth flow" },
+			context: undefined,
+		});
+	});
+
+	it("uses tool list cache to avoid repeated listTools round trips", async () => {
+		const toolDescriptors: readonly McpToolDescriptor[] = [
+			{
+				name: "echo",
+				inputSchema: { type: "object", properties: {} },
+			},
+		];
+		const client = createClient({
+			listTools: vi.fn(async () => toolDescriptors),
+		});
+		const manager = new InMemoryMcpManager({
+			clientFactory: async () => client,
+			toolsCacheTtlMs: 60_000,
+		});
+
+		await manager.registerServer({
+			name: "cache-test",
+			transport: {
+				type: "stdio",
+				command: "node",
+				args: ["./mcp.js"],
+			},
+		});
+
+		await manager.listTools("cache-test");
+		await manager.listTools("cache-test");
+		expect(client.listTools).toHaveBeenCalledTimes(1);
+	});
+
+	it("prevents tool calls on disabled servers", async () => {
+		const manager = new InMemoryMcpManager({
+			clientFactory: async () => createClient(),
+		});
+		await manager.registerServer({
+			name: "disabled",
+			transport: { type: "sse", url: "https://example.test/sse" },
+			disabled: true,
+		});
+
+		await expect(
+			manager.callTool({
+				serverName: "disabled",
+				toolName: "anything",
+			}),
+		).rejects.toThrow(/disabled/i);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/mcp/manager.ts b/sdk/packages/core/src/extensions/mcp/manager.ts
new file mode 100644
index 0000000..a75c469
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/manager.ts
@@ -0,0 +1,260 @@
+import type {
+	McpConnectionStatus,
+	McpManager,
+	McpManagerOptions,
+	McpServerClient,
+	McpServerRegistration,
+	McpServerSnapshot,
+	McpToolCallRequest,
+	McpToolCallResult,
+	McpToolDescriptor,
+} from "./types";
+
+const DEFAULT_TOOLS_CACHE_TTL_MS = 5000;
+
+type ManagedServerState = {
+	registration: McpServerRegistration;
+	client?: McpServerClient;
+	status: McpConnectionStatus;
+	lastError?: string;
+	updatedAt: number;
+	toolCache?: readonly McpToolDescriptor[];
+	toolCacheUpdatedAt?: number;
+};
+
+function nowMs(): number {
+	return Date.now();
+}
+
+function cloneTools(
+	tools: readonly McpToolDescriptor[],
+): readonly McpToolDescriptor[] {
+	return tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+	}));
+}
+
+export class InMemoryMcpManager implements McpManager {
+	private readonly toolsCacheTtlMs: number;
+	private readonly clientFactory: McpManagerOptions["clientFactory"];
+	private readonly servers = new Map<string, ManagedServerState>();
+	private readonly operationLocks = new Map<string, Promise<void>>();
+
+	constructor(options: McpManagerOptions) {
+		this.clientFactory = options.clientFactory;
+		this.toolsCacheTtlMs =
+			options.toolsCacheTtlMs ?? DEFAULT_TOOLS_CACHE_TTL_MS;
+	}
+
+	async registerServer(registration: McpServerRegistration): Promise<void> {
+		await this.runExclusive(registration.name, async () => {
+			const existing = this.servers.get(registration.name);
+			if (!existing) {
+				this.servers.set(registration.name, {
+					registration: { ...registration },
+					status: "disconnected",
+					updatedAt: nowMs(),
+				});
+				return;
+			}
+
+			const didTransportChange =
+				JSON.stringify(existing.registration.transport) !==
+				JSON.stringify(registration.transport);
+			existing.registration = { ...registration };
+			existing.updatedAt = nowMs();
+
+			if (didTransportChange) {
+				await this.disconnectState(existing);
+				existing.client = undefined;
+				existing.toolCache = undefined;
+				existing.toolCacheUpdatedAt = undefined;
+			}
+		});
+	}
+
+	async unregisterServer(serverName: string): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			await this.disconnectState(state);
+			this.servers.delete(serverName);
+		});
+	}
+
+	async connectServer(serverName: string): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			await this.connectState(state);
+		});
+	}
+
+	async disconnectServer(serverName: string): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			await this.disconnectState(state);
+		});
+	}
+
+	async setServerDisabled(
+		serverName: string,
+		disabled: boolean,
+	): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			state.registration = {
+				...state.registration,
+				disabled,
+			};
+			state.updatedAt = nowMs();
+			if (disabled) {
+				await this.disconnectState(state);
+			}
+		});
+	}
+
+	listServers(): readonly McpServerSnapshot[] {
+		return [...this.servers.values()]
+			.map((state) => ({
+				name: state.registration.name,
+				status: state.status,
+				disabled: state.registration.disabled === true,
+				lastError: state.lastError,
+				toolCount: state.toolCache?.length ?? 0,
+				updatedAt: state.updatedAt,
+				metadata: state.registration.metadata,
+			}))
+			.sort((a, b) => a.name.localeCompare(b.name));
+	}
+
+	async listTools(serverName: string): Promise<readonly McpToolDescriptor[]> {
+		const state = this.requireServer(serverName);
+		const fetchedAt = state.toolCacheUpdatedAt ?? 0;
+		if (state.toolCache && nowMs() - fetchedAt <= this.toolsCacheTtlMs) {
+			return state.toolCache;
+		}
+		return this.refreshTools(serverName);
+	}
+
+	async refreshTools(
+		serverName: string,
+	): Promise<readonly McpToolDescriptor[]> {
+		return this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			const client = await this.ensureConnectedClient(state);
+			const tools = await client.listTools();
+			const cloned = cloneTools(tools);
+			state.toolCache = cloned;
+			state.toolCacheUpdatedAt = nowMs();
+			state.updatedAt = nowMs();
+			return cloned;
+		});
+	}
+
+	async callTool(request: McpToolCallRequest): Promise<McpToolCallResult> {
+		return this.runExclusive(request.serverName, async () => {
+			const state = this.requireServer(request.serverName);
+			const client = await this.ensureConnectedClient(state);
+			state.updatedAt = nowMs();
+			return client.callTool({
+				name: request.toolName,
+				arguments: request.arguments,
+				context: request.context,
+			});
+		});
+	}
+
+	async dispose(): Promise<void> {
+		const names = [...this.servers.keys()];
+		for (const name of names) {
+			await this.unregisterServer(name);
+		}
+	}
+
+	private async ensureConnectedClient(
+		state: ManagedServerState,
+	): Promise<McpServerClient> {
+		await this.connectState(state);
+		if (!state.client) {
+			throw new Error(
+				`MCP server "${state.registration.name}" does not have an initialized client.`,
+			);
+		}
+		return state.client;
+	}
+
+	private async connectState(state: ManagedServerState): Promise<void> {
+		if (state.registration.disabled) {
+			throw new Error(
+				`MCP server "${state.registration.name}" is disabled and cannot be connected.`,
+			);
+		}
+		if (state.status === "connected" && state.client) {
+			return;
+		}
+		state.status = "connecting";
+		state.updatedAt = nowMs();
+		try {
+			const client =
+				state.client ?? (await this.clientFactory(state.registration));
+			await client.connect();
+			state.client = client;
+			state.status = "connected";
+			state.lastError = undefined;
+			state.updatedAt = nowMs();
+		} catch (error) {
+			state.status = "disconnected";
+			state.lastError = error instanceof Error ? error.message : String(error);
+			state.updatedAt = nowMs();
+			throw error;
+		}
+	}
+
+	private async disconnectState(state: ManagedServerState): Promise<void> {
+		if (!state.client) {
+			state.status = "disconnected";
+			state.updatedAt = nowMs();
+			return;
+		}
+
+		try {
+			await state.client.disconnect();
+		} finally {
+			state.status = "disconnected";
+			state.updatedAt = nowMs();
+		}
+	}
+
+	private requireServer(serverName: string): ManagedServerState {
+		const state = this.servers.get(serverName);
+		if (!state) {
+			throw new Error(`Unknown MCP server: ${serverName}`);
+		}
+		return state;
+	}
+
+	private async runExclusive<T>(
+		serverName: string,
+		operation: () => Promise<T>,
+	): Promise<T> {
+		const previous = this.operationLocks.get(serverName) ?? Promise.resolve();
+		let releaseCurrent: (() => void) | undefined;
+		const current = new Promise<void>((resolve) => {
+			releaseCurrent = resolve;
+		});
+		const queued = previous.catch(() => undefined).then(() => current);
+		this.operationLocks.set(serverName, queued);
+
+		await previous.catch(() => undefined);
+		try {
+			return await operation();
+		} finally {
+			releaseCurrent?.();
+			const lock = this.operationLocks.get(serverName);
+			if (lock === queued) {
+				this.operationLocks.delete(serverName);
+			}
+		}
+	}
+}
diff --git a/sdk/packages/core/src/extensions/mcp/name-transform.test.ts b/sdk/packages/core/src/extensions/mcp/name-transform.test.ts
new file mode 100644
index 0000000..4cad3ef
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/name-transform.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { defaultMcpToolNameTransform } from "./name-transform";
+
+const MAX_LENGTH = 64;
+const VALID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+describe("defaultMcpToolNameTransform", () => {
+	it("passes through short, valid names unchanged", () => {
+		expect(
+			defaultMcpToolNameTransform({ serverName: "mock", toolName: "echo" }),
+		).toBe("mock__echo");
+	});
+
+	it("sanitizes invalid characters", () => {
+		const result = defaultMcpToolNameTransform({
+			serverName: "my.server",
+			toolName: "tool/name",
+		});
+		expect(result).toMatch(VALID_PATTERN);
+		expect(result).not.toContain(".");
+		expect(result).not.toContain("/");
+	});
+
+	it("truncates valid names longer than 64 characters", () => {
+		const toolName = "a".repeat(100);
+		const result = defaultMcpToolNameTransform({
+			serverName: "server",
+			toolName,
+		});
+		expect(result.length).toBeLessThanOrEqual(MAX_LENGTH);
+		expect(result).toMatch(VALID_PATTERN);
+	});
+
+	it("keeps names that are exactly at the limit unchanged", () => {
+		const toolName = "a".repeat(MAX_LENGTH - "server__".length);
+		const rawName = `server__${toolName}`;
+		expect(rawName.length).toBe(MAX_LENGTH);
+		expect(
+			defaultMcpToolNameTransform({ serverName: "server", toolName }),
+		).toBe(rawName);
+	});
+
+	it("produces distinct names for distinct long inputs via the hash suffix", () => {
+		const a = defaultMcpToolNameTransform({
+			serverName: "server",
+			toolName: `${"x".repeat(80)}_a`,
+		});
+		const b = defaultMcpToolNameTransform({
+			serverName: "server",
+			toolName: `${"x".repeat(80)}_b`,
+		});
+		expect(a).not.toBe(b);
+		expect(a.length).toBeLessThanOrEqual(MAX_LENGTH);
+		expect(b.length).toBeLessThanOrEqual(MAX_LENGTH);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/mcp/name-transform.ts b/sdk/packages/core/src/extensions/mcp/name-transform.ts
new file mode 100644
index 0000000..a64f3d0
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/name-transform.ts
@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import type { McpToolNameTransform } from "./types";
+
+// 64 is OpenAI's function-name limit; Anthropic allows 128. Cap at the lower
+// bound so OpenAI-compatible providers don't reject long MCP tool names.
+const MAX_MCP_TOOL_NAME_LENGTH = 64;
+const INVALID_MCP_TOOL_NAME_CHARACTERS = /[^a-zA-Z0-9_-]+/g;
+const HASH_LENGTH = 8;
+const HASH_SEPARATOR_LENGTH = 1;
+const FALLBACK_BASE_NAME = "mcp_tool";
+
+function buildMcpToolNameHash(value: string): string {
+	return createHash("sha1").update(value).digest("hex").slice(0, HASH_LENGTH);
+}
+
+function sanitizeMcpToolNameCandidate(value: string): string {
+	return value.replace(INVALID_MCP_TOOL_NAME_CHARACTERS, "_");
+}
+
+export const defaultMcpToolNameTransform: McpToolNameTransform = ({
+	serverName,
+	toolName,
+}): string => {
+	const rawName = `${serverName}__${toolName}`;
+	const sanitizedName = sanitizeMcpToolNameCandidate(rawName);
+	if (sanitizedName === rawName && rawName.length <= MAX_MCP_TOOL_NAME_LENGTH) {
+		return rawName;
+	}
+
+	const hash = buildMcpToolNameHash(rawName);
+	const maxBaseLength =
+		MAX_MCP_TOOL_NAME_LENGTH - HASH_SEPARATOR_LENGTH - HASH_LENGTH;
+	const baseName = sanitizedName.slice(0, maxBaseLength) || FALLBACK_BASE_NAME;
+	return `${baseName}_${hash}`;
+};
diff --git a/sdk/packages/core/src/extensions/mcp/oauth.test.ts b/sdk/packages/core/src/extensions/mcp/oauth.test.ts
new file mode 100644
index 0000000..3a72d3e
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/oauth.test.ts
@@ -0,0 +1,79 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createMcpOAuthProviderContext } from "./oauth";
+
+describe("mcp oauth", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((directory) =>
+				rm(directory, { recursive: true, force: true }),
+			),
+		);
+		tempRoots.length = 0;
+	});
+
+	async function createSettingsFile(): Promise<string> {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-mcp-oauth-"));
+		tempRoots.push(tempRoot);
+		const filePath = join(tempRoot, "cline_mcp_settings.json");
+		await writeFile(
+			filePath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						linear: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://mcp.linear.app/mcp",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		return filePath;
+	}
+
+	it("tracks the most recent generated OAuth state", async () => {
+		const settingsPath = await createSettingsFile();
+		const context = createMcpOAuthProviderContext({
+			settingsPath,
+			serverName: "linear",
+			redirectUrl: "http://127.0.0.1:1456/mcp/oauth/callback",
+		});
+
+		expect(context.getLastOAuthState()).toBeUndefined();
+
+		const createState = context.provider.state;
+		if (!createState) {
+			throw new Error("Expected OAuth provider to expose state generator.");
+		}
+
+		const firstState = createState();
+		expect(context.getLastOAuthState()).toBe(firstState);
+
+		const secondState = createState();
+		expect(secondState).not.toBe(firstState);
+		expect(context.getLastOAuthState()).toBe(secondState);
+	});
+
+	it("does not write redirect state when creating a provider context", async () => {
+		const settingsPath = await createSettingsFile();
+		const before = await readFile(settingsPath, "utf8");
+
+		createMcpOAuthProviderContext({
+			settingsPath,
+			serverName: "linear",
+			redirectUrl: "http://127.0.0.1:1456/mcp/oauth/callback",
+		});
+
+		await expect(readFile(settingsPath, "utf8")).resolves.toBe(before);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/mcp/oauth.ts b/sdk/packages/core/src/extensions/mcp/oauth.ts
new file mode 100644
index 0000000..e41adac
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/oauth.ts
@@ -0,0 +1,402 @@
+import { randomUUID } from "node:crypto";
+import type {
+	OAuthClientProvider,
+	OAuthDiscoveryState,
+} from "@modelcontextprotocol/sdk/client/auth.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type {
+	OAuthClientInformationMixed,
+	OAuthClientMetadata,
+	OAuthTokens,
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import {
+	type OAuthServerCloseInfo,
+	type OAuthServerListeningInfo,
+	startLocalOAuthServer,
+} from "../../auth/server";
+import {
+	getMcpServerOAuthState,
+	normalizeMcpServerOAuthState,
+	updateMcpServerOAuthState,
+} from "./config-loader";
+import type { McpServerOAuthState, McpServerRegistration } from "./types";
+
+const DEFAULT_MCP_OAUTH_CALLBACK_PATH = "/mcp/oauth/callback";
+const DEFAULT_MCP_OAUTH_CALLBACK_PORTS = [1456, 1457, 1458];
+const DEFAULT_MCP_OAUTH_TIMEOUT_MS = 5 * 60 * 1000;
+
+export type McpSdkAuthCapableTransport =
+	| SSEClientTransport
+	| StreamableHTTPClientTransport;
+
+export interface CreateMcpOAuthProviderContextOptions {
+	settingsPath?: string;
+	serverName: string;
+	redirectUrl: string;
+	onAuthorizationUrl?: (url: string) => void | Promise<void>;
+}
+
+export interface McpOAuthProviderContext {
+	provider: OAuthClientProvider;
+	getLastAuthorizationUrl(): string | undefined;
+	getLastOAuthState(): string | undefined;
+	resetInteractiveState(): Promise<void>;
+	markError(errorMessage: string): Promise<void>;
+	clearError(): Promise<void>;
+}
+
+export interface AuthorizeMcpServerOAuthOptions {
+	serverName: string;
+	filePath?: string;
+	clientName?: string;
+	clientVersion?: string;
+	fetch?: FetchLike;
+	openUrl?: (url: string) => void | Promise<void>;
+	callbackHost?: string;
+	callbackPorts?: number[];
+	callbackPath?: string;
+	timeoutMs?: number;
+	successHtml?: string;
+	onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+	onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+
+export interface AuthorizeMcpServerOAuthResult {
+	serverName: string;
+	authorized: true;
+	message: string;
+}
+
+function toErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const message = error.message.trim();
+		if (message.length > 0) {
+			return message;
+		}
+	}
+	return String(error);
+}
+
+function createOAuthClientMetadata(redirectUrl: string): OAuthClientMetadata {
+	return {
+		client_name: "Cline",
+		redirect_uris: [redirectUrl],
+		grant_types: ["authorization_code", "refresh_token"],
+		response_types: ["code"],
+		token_endpoint_auth_method: "none",
+	};
+}
+
+export function createMcpOAuthProviderContext(
+	options: CreateMcpOAuthProviderContextOptions,
+): McpOAuthProviderContext {
+	let state: McpServerOAuthState = {};
+	try {
+		state =
+			getMcpServerOAuthState(options.serverName, {
+				filePath: options.settingsPath,
+			}) ?? {};
+	} catch {
+		state = {};
+	}
+	let lastAuthorizationUrl: string | undefined;
+	let lastOAuthState: string | undefined;
+
+	const patch = async (
+		updater: (current: McpServerOAuthState) => McpServerOAuthState,
+	): Promise<void> => {
+		const nextState = normalizeMcpServerOAuthState(updater(state)) ?? {};
+		try {
+			state = updateMcpServerOAuthState(options.serverName, () => nextState, {
+				filePath: options.settingsPath,
+			});
+		} catch {
+			state = nextState;
+		}
+	};
+
+	const provider: OAuthClientProvider = {
+		get redirectUrl() {
+			return state.redirectUrl ?? options.redirectUrl;
+		},
+		get clientMetadata() {
+			return createOAuthClientMetadata(
+				state.redirectUrl ?? options.redirectUrl,
+			);
+		},
+		state: () => {
+			lastOAuthState = randomUUID();
+			return lastOAuthState;
+		},
+		clientInformation: () =>
+			state.clientInformation as OAuthClientInformationMixed | undefined,
+		saveClientInformation: async (clientInformation) => {
+			await patch((current) => ({
+				...current,
+				clientInformation: clientInformation as Record<string, unknown>,
+				redirectUrl: options.redirectUrl,
+				lastError: undefined,
+			}));
+		},
+		tokens: () => state.tokens as OAuthTokens | undefined,
+		saveTokens: async (tokens) => {
+			const lastAuthenticatedAt = Date.now();
+			await patch((current) => ({
+				...current,
+				tokens: tokens as Record<string, unknown>,
+				redirectUrl: options.redirectUrl,
+				lastError: undefined,
+				lastAuthenticatedAt,
+			}));
+		},
+		redirectToAuthorization: async (authorizationUrl) => {
+			lastAuthorizationUrl = authorizationUrl.toString();
+			await options.onAuthorizationUrl?.(lastAuthorizationUrl);
+		},
+		saveCodeVerifier: async (codeVerifier) => {
+			await patch((current) => ({
+				...current,
+				codeVerifier,
+				redirectUrl: options.redirectUrl,
+			}));
+		},
+		codeVerifier: () => {
+			if (!state.codeVerifier) {
+				throw new Error(
+					`Missing OAuth code verifier for MCP server "${options.serverName}".`,
+				);
+			}
+			return state.codeVerifier;
+		},
+		invalidateCredentials: async (scope) => {
+			await patch((current) => {
+				if (scope === "all") {
+					return {
+						lastError: current.lastError,
+						redirectUrl: current.redirectUrl,
+					};
+				}
+				return {
+					...current,
+					...(scope === "client" ? { clientInformation: undefined } : {}),
+					...(scope === "tokens"
+						? { tokens: undefined, lastAuthenticatedAt: undefined }
+						: {}),
+					...(scope === "verifier" ? { codeVerifier: undefined } : {}),
+					...(scope === "discovery" ? { discoveryState: undefined } : {}),
+				};
+			});
+		},
+		saveDiscoveryState: async (discoveryState) => {
+			await patch((current) => ({
+				...current,
+				discoveryState: discoveryState as unknown as Record<string, unknown>,
+			}));
+		},
+		discoveryState: () =>
+			state.discoveryState as OAuthDiscoveryState | undefined,
+	};
+
+	return {
+		provider,
+		getLastAuthorizationUrl: () => lastAuthorizationUrl,
+		getLastOAuthState: () => lastOAuthState,
+		resetInteractiveState: async () => {
+			await patch((current) => ({
+				...current,
+				clientInformation: undefined,
+				codeVerifier: undefined,
+				discoveryState: undefined,
+				lastError: undefined,
+				redirectUrl: options.redirectUrl,
+			}));
+		},
+		markError: async (errorMessage) => {
+			await patch((current) => ({
+				...current,
+				lastError: errorMessage,
+			}));
+		},
+		clearError: async () => {
+			await patch((current) => ({
+				...current,
+				lastError: undefined,
+			}));
+		},
+	};
+}
+
+export function createMcpSdkTransport(input: {
+	registration: McpServerRegistration;
+	oauthProvider?: OAuthClientProvider;
+	fetch?: FetchLike;
+}): McpSdkAuthCapableTransport {
+	const transport = input.registration.transport;
+	if (transport.type === "stdio") {
+		throw new Error(
+			`MCP server "${input.registration.name}" uses stdio transport and does not support OAuth browser flow.`,
+		);
+	}
+
+	const requestInit = transport.headers
+		? {
+				headers: transport.headers,
+			}
+		: undefined;
+	if (transport.type === "sse") {
+		return new SSEClientTransport(new URL(transport.url), {
+			authProvider: input.oauthProvider,
+			requestInit,
+			fetch: input.fetch,
+		});
+	}
+
+	return new StreamableHTTPClientTransport(new URL(transport.url), {
+		authProvider: input.oauthProvider,
+		requestInit,
+		fetch: input.fetch,
+	});
+}
+
+function buildClient(input: {
+	clientName?: string;
+	clientVersion?: string;
+}): Client {
+	return new Client({
+		name: input.clientName?.trim() || "@cline/core",
+		version: input.clientVersion?.trim() || "0.0.0",
+	});
+}
+
+export async function authorizeMcpServerOAuth(
+	options: AuthorizeMcpServerOAuthOptions,
+): Promise<AuthorizeMcpServerOAuthResult> {
+	const serverName = options.serverName.trim();
+	if (!serverName) {
+		throw new Error("MCP server name cannot be empty.");
+	}
+
+	const { resolveMcpServerRegistrations } = await import("./config-loader");
+	const registration = resolveMcpServerRegistrations({
+		filePath: options.filePath,
+	}).find((entry) => entry.name === serverName);
+	if (!registration) {
+		throw new Error(`MCP server "${serverName}" is not configured.`);
+	}
+	if (registration.disabled) {
+		throw new Error(
+			`MCP server "${serverName}" is disabled. Enable it before running OAuth.`,
+		);
+	}
+	if (registration.transport.type === "stdio") {
+		throw new Error(
+			`MCP server "${serverName}" uses stdio transport and does not support OAuth browser flow.`,
+		);
+	}
+
+	const callbackServer = await startLocalOAuthServer({
+		host: options.callbackHost,
+		ports: options.callbackPorts?.length
+			? options.callbackPorts
+			: DEFAULT_MCP_OAUTH_CALLBACK_PORTS,
+		callbackPath: options.callbackPath ?? DEFAULT_MCP_OAUTH_CALLBACK_PATH,
+		timeoutMs: options.timeoutMs ?? DEFAULT_MCP_OAUTH_TIMEOUT_MS,
+		successHtml: options.successHtml,
+		onListening: options.onServerListening,
+		onClose: options.onServerClose,
+	});
+	if (!callbackServer.callbackUrl) {
+		throw new Error("Unable to bind local MCP OAuth callback server.");
+	}
+
+	const oauthContext = createMcpOAuthProviderContext({
+		settingsPath: options.filePath,
+		serverName,
+		redirectUrl: callbackServer.callbackUrl,
+		onAuthorizationUrl: async (url) => {
+			await options.openUrl?.(url);
+		},
+	});
+	await oauthContext.resetInteractiveState();
+
+	const client = buildClient(options);
+	let retryClient: Client | undefined;
+	try {
+		const transport = createMcpSdkTransport({
+			registration,
+			oauthProvider: oauthContext.provider,
+			fetch: options.fetch,
+		});
+		try {
+			await client.connect(transport);
+			await client.listTools();
+			await oauthContext.clearError();
+			return {
+				serverName,
+				authorized: true,
+				message: `MCP server "${serverName}" is already authorized.`,
+			};
+		} catch (error) {
+			if (!(error instanceof UnauthorizedError)) {
+				throw error;
+			}
+			const authUrl = oauthContext.getLastAuthorizationUrl();
+			if (!authUrl) {
+				throw new Error(
+					`MCP server "${serverName}" did not provide an authorization URL.`,
+				);
+			}
+			const callback = await callbackServer.waitForCallback();
+			if (!callback) {
+				throw new Error(
+					"Timed out waiting for MCP OAuth authorization callback.",
+				);
+			}
+			if (callback.error) {
+				throw new Error(`OAuth authorization failed: ${callback.error}`);
+			}
+			if (!callback.code) {
+				throw new Error(
+					"OAuth callback did not include an authorization code.",
+				);
+			}
+			const expectedState = oauthContext.getLastOAuthState();
+			if (!expectedState) {
+				throw new Error(
+					`MCP server "${serverName}" did not start an OAuth stateful authorization flow.`,
+				);
+			}
+			if (callback.state !== expectedState) {
+				throw new Error("OAuth authorization failed: state mismatch.");
+			}
+
+			await transport.finishAuth(callback.code);
+			retryClient = buildClient(options);
+			const retryTransport = createMcpSdkTransport({
+				registration,
+				oauthProvider: oauthContext.provider,
+				fetch: options.fetch,
+			});
+			await retryClient.connect(retryTransport);
+			await retryClient.listTools();
+			await oauthContext.clearError();
+			return {
+				serverName,
+				authorized: true,
+				message: `MCP server "${serverName}" OAuth authorization completed.`,
+			};
+		}
+	} catch (error) {
+		const message = toErrorMessage(error);
+		await oauthContext.markError(message);
+		throw new Error(message);
+	} finally {
+		await client.close().catch(() => undefined);
+		await retryClient?.close().catch(() => undefined);
+		callbackServer.close();
+	}
+}
diff --git a/sdk/packages/core/src/extensions/mcp/plugin-server-registration.test.ts b/sdk/packages/core/src/extensions/mcp/plugin-server-registration.test.ts
new file mode 100644
index 0000000..eaee727
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/plugin-server-registration.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import { normalizePluginMcpServerRegistration } from "./plugin-server-registration";
+
+describe("plugin MCP server registration", () => {
+	it("normalizes streamable HTTP plugin MCP servers", () => {
+		const result = normalizePluginMcpServerRegistration({
+			name: "remote",
+			transport: {
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+				headers: {
+					Authorization: "Bearer token",
+				},
+			},
+		});
+
+		expect(result.loadError).toBeUndefined();
+		expect(result.registration).toEqual({
+			name: "remote",
+			transport: {
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+				headers: {
+					Authorization: "Bearer token",
+				},
+			},
+		});
+	});
+
+	it("normalizes SSE plugin MCP servers", () => {
+		const result = normalizePluginMcpServerRegistration({
+			name: "remote-sse",
+			transport: {
+				type: "sse",
+				url: "https://example.com/sse",
+			},
+		});
+
+		expect(result.loadError).toBeUndefined();
+		expect(result.registration).toEqual({
+			name: "remote-sse",
+			transport: {
+				type: "sse",
+				url: "https://example.com/sse",
+			},
+		});
+	});
+
+	it("keeps top-level env scoped to stdio transports", () => {
+		const result = normalizePluginMcpServerRegistration({
+			name: "remote",
+			transport: {
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+			},
+			env: {
+				TOKEN: {
+					fromEnv: "TOKEN",
+					required: true,
+				},
+			},
+		});
+
+		expect(result.registration).toBeUndefined();
+		expect(result.loadError).toContain(
+			"top-level env is only supported for stdio MCP transports",
+		);
+	});
+
+	it("reports missing stdio command before missing required env", () => {
+		const result = normalizePluginMcpServerRegistration({
+			name: "local",
+			transport: {
+				type: "stdio",
+				command: "",
+			},
+			env: {
+				MISSING_TOKEN: {
+					fromEnv: "CLINE_TEST_MISSING_PLUGIN_MCP_TOKEN",
+					required: true,
+				},
+			},
+		});
+
+		expect(result.registration).toBeUndefined();
+		expect(result.loadError).toBe("stdio MCP transport requires command");
+	});
+
+	it("normalizes whitespace-only server names to empty-name errors", () => {
+		const result = normalizePluginMcpServerRegistration({
+			name: "   ",
+			transport: {
+				type: "stdio",
+				command: "node",
+			},
+		});
+
+		expect(result.registration).toBeUndefined();
+		expect(result).toEqual({
+			name: "",
+			loadError: "empty MCP server name",
+		});
+	});
+});
diff --git a/sdk/packages/core/src/extensions/mcp/plugin-server-registration.ts b/sdk/packages/core/src/extensions/mcp/plugin-server-registration.ts
new file mode 100644
index 0000000..6e49ac5
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/plugin-server-registration.ts
@@ -0,0 +1,260 @@
+import type {
+	AgentExtensionMcpEnvValue,
+	AgentExtensionMcpServer,
+} from "@cline/shared";
+import type { McpServerRegistration } from "./types";
+
+export interface PluginMcpServerResolution<TOwner> {
+	owner: TOwner;
+	name: string;
+	registration?: McpServerRegistration;
+	loadError?: string;
+}
+
+type ResolvedPluginMcpEnv =
+	| {
+			ok: true;
+			env?: Record<string, string>;
+	  }
+	| {
+			ok: false;
+			reason: string;
+	  };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+	return (
+		isRecord(value) &&
+		Object.values(value).every((entry) => typeof entry === "string")
+	);
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return (
+		Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	);
+}
+
+function isPluginMcpEnvValue(
+	value: unknown,
+): value is AgentExtensionMcpEnvValue {
+	if (!isRecord(value)) {
+		return false;
+	}
+	return (
+		(value.fromEnv === undefined || typeof value.fromEnv === "string") &&
+		(value.value === undefined || typeof value.value === "string") &&
+		(value.required === undefined || typeof value.required === "boolean")
+	);
+}
+
+function resolvePluginMcpEnv(
+	server: AgentExtensionMcpServer,
+): ResolvedPluginMcpEnv {
+	const entries = server.env ? Object.entries(server.env) : [];
+	if (entries.length === 0) {
+		return { ok: true };
+	}
+
+	const env: Record<string, string> = {};
+	for (const [targetName, value] of entries) {
+		if (typeof value === "string") {
+			env[targetName] = value;
+			continue;
+		}
+
+		const sourceName = value.fromEnv?.trim() || targetName;
+		const sourceValue = process.env[sourceName];
+		if (typeof sourceValue === "string" && sourceValue.length > 0) {
+			env[targetName] = sourceValue;
+			continue;
+		}
+		if (typeof value.value === "string") {
+			env[targetName] = value.value;
+			continue;
+		}
+		if (value.required === true) {
+			return {
+				ok: false,
+				reason: `required environment variable "${sourceName}" is not set`,
+			};
+		}
+	}
+
+	return { ok: true, env: Object.keys(env).length > 0 ? env : undefined };
+}
+
+export function normalizePluginMcpServerRegistration(
+	server: AgentExtensionMcpServer,
+): {
+	name: string;
+	registration?: McpServerRegistration;
+	loadError?: string;
+} {
+	if (!isRecord(server)) {
+		return { name: "", loadError: "invalid MCP server registration" };
+	}
+	const name = typeof server.name === "string" ? server.name.trim() : "";
+	if (!name) {
+		return {
+			name,
+			loadError: "empty MCP server name",
+		};
+	}
+
+	const envValue = server.env;
+	const env = envValue === undefined ? undefined : envValue;
+	if (env !== undefined) {
+		if (!isRecord(env)) {
+			return { name, loadError: "invalid env" };
+		}
+		for (const [key, value] of Object.entries(env)) {
+			if (typeof value !== "string" && !isPluginMcpEnvValue(value)) {
+				return { name, loadError: `invalid env "${key}"` };
+			}
+		}
+	}
+
+	const transport = server.transport;
+	if (!isRecord(transport)) {
+		return { name, loadError: "invalid MCP transport" };
+	}
+	const type = transport.type;
+	if (type !== "stdio" && type !== "sse" && type !== "streamableHttp") {
+		return { name, loadError: "invalid MCP transport type" };
+	}
+	if (type !== "stdio" && env !== undefined) {
+		return {
+			name,
+			loadError: "top-level env is only supported for stdio MCP transports",
+		};
+	}
+
+	const metadata = isRecord(server.metadata) ? server.metadata : undefined;
+	if (type === "stdio") {
+		const command = transport.command;
+		if (typeof command !== "string" || !command.trim()) {
+			return { name, loadError: "stdio MCP transport requires command" };
+		}
+		const args = transport.args;
+		if (args !== undefined && !isStringArray(args)) {
+			return { name, loadError: "stdio MCP transport args must be strings" };
+		}
+		const cwd = transport.cwd;
+		if (cwd !== undefined && typeof cwd !== "string") {
+			return { name, loadError: "stdio MCP transport cwd must be a string" };
+		}
+		const transportEnv = transport.env;
+		if (transportEnv !== undefined && !isStringRecord(transportEnv)) {
+			return { name, loadError: "stdio MCP transport env must be strings" };
+		}
+
+		const resolvedEnv = resolvePluginMcpEnv({
+			name,
+			transport: {
+				type: "stdio",
+				command,
+				args,
+				cwd,
+				env: transportEnv,
+			},
+			env,
+			metadata,
+		});
+		if (!resolvedEnv.ok) {
+			return { name, loadError: resolvedEnv.reason };
+		}
+
+		const resolvedTransportEnv =
+			transportEnv || resolvedEnv.env
+				? {
+						...(transportEnv ?? {}),
+						...(resolvedEnv.env ?? {}),
+					}
+				: undefined;
+		return {
+			name,
+			registration: {
+				name,
+				transport: {
+					type: "stdio",
+					command,
+					args,
+					cwd,
+					env: resolvedTransportEnv,
+				},
+				metadata,
+			},
+		};
+	}
+
+	if (typeof transport.url !== "string" || !transport.url.trim()) {
+		return { name, loadError: `${type} MCP transport requires url` };
+	}
+	const headers = transport.headers;
+	if (headers !== undefined && !isStringRecord(headers)) {
+		return { name, loadError: `${type} MCP transport headers must be strings` };
+	}
+
+	return {
+		name,
+		registration: {
+			name,
+			transport:
+				type === "sse"
+					? {
+							type: "sse",
+							url: transport.url,
+							headers,
+						}
+					: {
+							type: "streamableHttp",
+							url: transport.url,
+							headers,
+						},
+			metadata,
+		},
+	};
+}
+
+export function resolvePluginMcpServerRegistrations<TOwner>(
+	servers: readonly {
+		server: AgentExtensionMcpServer;
+		owner: TOwner;
+		ownerLabel?: string;
+	}[],
+): PluginMcpServerResolution<TOwner>[] {
+	const firstOwnerByName = new Map<string, string | undefined>();
+	return servers.map(({ server, owner, ownerLabel }) => {
+		const normalized = normalizePluginMcpServerRegistration(server);
+		if (!normalized.registration) {
+			return {
+				owner,
+				name: normalized.name,
+				loadError: normalized.loadError ?? "invalid MCP server registration",
+			};
+		}
+
+		const firstOwner = firstOwnerByName.get(normalized.registration.name);
+		if (firstOwnerByName.has(normalized.registration.name)) {
+			const ownerText = firstOwner
+				? ` already registered by ${firstOwner}`
+				: "";
+			return {
+				owner,
+				name: normalized.registration.name,
+				loadError: `duplicate MCP server name "${normalized.registration.name}"${ownerText}`,
+			};
+		}
+
+		firstOwnerByName.set(normalized.registration.name, ownerLabel);
+		return {
+			owner,
+			name: normalized.registration.name,
+			registration: normalized.registration,
+		};
+	});
+}
diff --git a/sdk/packages/core/src/extensions/mcp/policies.ts b/sdk/packages/core/src/extensions/mcp/policies.ts
new file mode 100644
index 0000000..5064913
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/policies.ts
@@ -0,0 +1,47 @@
+import type { ToolPolicy } from "@cline/shared";
+import { defaultMcpToolNameTransform } from "./name-transform";
+import type { McpToolNameTransform } from "./types";
+
+export interface CreateDisabledMcpToolPolicyOptions {
+	serverName: string;
+	toolName: string;
+	nameTransform?: McpToolNameTransform;
+}
+
+export interface CreateDisabledMcpToolPoliciesOptions {
+	serverName: string;
+	toolNames: readonly string[];
+	nameTransform?: McpToolNameTransform;
+}
+
+export function createDisabledMcpToolPolicy(
+	options: CreateDisabledMcpToolPolicyOptions,
+): Record<string, ToolPolicy> {
+	const nameTransform = options.nameTransform ?? defaultMcpToolNameTransform;
+	const name = nameTransform({
+		serverName: options.serverName,
+		toolName: options.toolName,
+	});
+	return {
+		[name]: {
+			enabled: false,
+		},
+	};
+}
+
+export function createDisabledMcpToolPolicies(
+	options: CreateDisabledMcpToolPoliciesOptions,
+): Record<string, ToolPolicy> {
+	const policies: Record<string, ToolPolicy> = {};
+	for (const toolName of options.toolNames) {
+		Object.assign(
+			policies,
+			createDisabledMcpToolPolicy({
+				serverName: options.serverName,
+				toolName,
+				nameTransform: options.nameTransform,
+			}),
+		);
+	}
+	return policies;
+}
diff --git a/sdk/packages/core/src/extensions/mcp/tools.ts b/sdk/packages/core/src/extensions/mcp/tools.ts
new file mode 100644
index 0000000..8a39e48
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/tools.ts
@@ -0,0 +1,47 @@
+import { type AgentTool, createTool } from "@cline/shared";
+import { defaultMcpToolNameTransform } from "./name-transform";
+import type { CreateMcpToolsOptions, McpToolDescriptor } from "./types";
+
+function defaultMcpDescription(
+	serverName: string,
+	tool: McpToolDescriptor,
+): string {
+	const base = tool.description?.trim();
+	if (base) {
+		return base;
+	}
+	return `Execute MCP tool "${tool.name}" from server "${serverName}".`;
+}
+
+export async function createMcpTools(
+	options: CreateMcpToolsOptions,
+): Promise<AgentTool[]> {
+	const descriptors = await options.provider.listTools(options.serverName);
+	const nameTransform = options.nameTransform ?? defaultMcpToolNameTransform;
+
+	return descriptors.map((descriptor) => {
+		const agentToolName = nameTransform({
+			serverName: options.serverName,
+			toolName: descriptor.name,
+		});
+
+		return createTool({
+			name: agentToolName,
+			description: defaultMcpDescription(options.serverName, descriptor),
+			inputSchema: descriptor.inputSchema,
+			timeoutMs: options.timeoutMs,
+			retryable: options.retryable,
+			maxRetries: options.maxRetries,
+			execute: async (input: unknown, context) =>
+				options.provider.callTool({
+					serverName: options.serverName,
+					toolName: descriptor.name,
+					arguments:
+						input && typeof input === "object" && !Array.isArray(input)
+							? (input as Record<string, unknown>)
+							: undefined,
+					context,
+				}),
+		});
+	});
+}
diff --git a/sdk/packages/core/src/extensions/mcp/types.ts b/sdk/packages/core/src/extensions/mcp/types.ts
new file mode 100644
index 0000000..e99a747
--- /dev/null
+++ b/sdk/packages/core/src/extensions/mcp/types.ts
@@ -0,0 +1,135 @@
+import type { AgentToolContext } from "@cline/shared";
+
+export interface McpToolDescriptor {
+	name: string;
+	description?: string;
+	inputSchema: Record<string, unknown>;
+}
+
+export interface McpToolCallRequest {
+	serverName: string;
+	toolName: string;
+	arguments?: Record<string, unknown>;
+	context?: AgentToolContext;
+}
+
+export type McpToolCallResult = unknown;
+
+export interface McpToolProvider {
+	listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+	callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+}
+
+export type McpToolNameTransform = (input: {
+	serverName: string;
+	toolName: string;
+}) => string;
+
+export interface CreateMcpToolsOptions {
+	serverName: string;
+	provider: McpToolProvider;
+	nameTransform?: McpToolNameTransform;
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}
+
+export type McpConnectionStatus = "disconnected" | "connecting" | "connected";
+
+export interface McpStdioTransportConfig {
+	type: "stdio";
+	command: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+}
+
+export interface McpSseTransportConfig {
+	type: "sse";
+	url: string;
+	headers?: Record<string, string>;
+}
+
+export interface McpStreamableHttpTransportConfig {
+	type: "streamableHttp";
+	url: string;
+	headers?: Record<string, string>;
+}
+
+export type McpServerTransportConfig =
+	| McpStdioTransportConfig
+	| McpSseTransportConfig
+	| McpStreamableHttpTransportConfig;
+
+export interface McpServerOAuthState {
+	clientInformation?: Record<string, unknown>;
+	tokens?: Record<string, unknown>;
+	codeVerifier?: string;
+	discoveryState?: Record<string, unknown>;
+	redirectUrl?: string;
+	lastError?: string;
+	lastAuthenticatedAt?: number;
+}
+
+export interface McpServerRegistration {
+	name: string;
+	transport: McpServerTransportConfig;
+	disabled?: boolean;
+	metadata?: Record<string, unknown>;
+	oauth?: McpServerOAuthState;
+}
+
+export interface McpServerSnapshot {
+	name: string;
+	status: McpConnectionStatus;
+	disabled: boolean;
+	lastError?: string;
+	toolCount: number;
+	updatedAt: number;
+	metadata?: Record<string, unknown>;
+}
+
+export interface McpServerClient {
+	connect(): Promise<void>;
+	disconnect(): Promise<void>;
+	listTools(): Promise<readonly McpToolDescriptor[]>;
+	callTool(request: {
+		name: string;
+		arguments?: Record<string, unknown>;
+		context?: AgentToolContext;
+	}): Promise<McpToolCallResult>;
+}
+
+export type McpServerClientFactory = (
+	registration: McpServerRegistration,
+) => Promise<McpServerClient> | McpServerClient;
+
+export interface McpServerOAuthStatus {
+	serverName: string;
+	oauthSupported: boolean;
+	oauthConfigured: boolean;
+	lastError?: string;
+	lastAuthenticatedAt?: number;
+}
+
+export interface McpManagerOptions {
+	clientFactory: McpServerClientFactory;
+	/**
+	 * Cache TTL for tools/list responses.
+	 * A short cache avoids repeated list requests while keeping server metadata fresh.
+	 * @default 5000
+	 */
+	toolsCacheTtlMs?: number;
+}
+
+export interface McpManager extends McpToolProvider {
+	registerServer(registration: McpServerRegistration): Promise<void>;
+	unregisterServer(serverName: string): Promise<void>;
+	connectServer(serverName: string): Promise<void>;
+	disconnectServer(serverName: string): Promise<void>;
+	setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+	listServers(): readonly McpServerSnapshot[];
+	refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+	callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+	dispose(): Promise<void>;
+}
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-config-loader.test.ts b/sdk/packages/core/src/extensions/plugin/plugin-config-loader.test.ts
new file mode 100644
index 0000000..d8504b2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-config-loader.test.ts
@@ -0,0 +1,480 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setHomeDir } from "@cline/shared/storage";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	discoverPluginModulePaths,
+	resolveAgentPluginPaths,
+	resolveAgentPluginSkillDirectories,
+	resolveAndLoadAgentPlugins,
+	resolvePluginConfigSearchPaths,
+	resolvePluginSkillDirectoriesFromPaths,
+} from "./plugin-config-loader";
+
+describe("plugin-config-loader", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
+	};
+
+	afterEach(() => {
+		process.env.HOME = envSnapshot.HOME;
+		process.env.CLINE_GLOBAL_SETTINGS_PATH =
+			envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
+		setHomeDir(envSnapshot.HOME ?? "~");
+	});
+
+	it("discovers plugin modules recursively", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			const nested = join(root, "nested");
+			await mkdir(nested, { recursive: true });
+			await writeFile(join(root, "a.js"), "export default {}", "utf8");
+			await writeFile(join(nested, "b.ts"), "export default {}", "utf8");
+			await writeFile(
+				join(root, ".a.js.cline-plugin.js"),
+				"export default {}",
+				"utf8",
+			);
+			await writeFile(join(root, "ignore.txt"), "noop", "utf8");
+
+			const discovered = discoverPluginModulePaths(root);
+			expect(discovered).toEqual([join(root, "a.js"), join(nested, "b.ts")]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves plugin paths from explicit files/directories", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const pluginsDir = join(root, "plugins");
+			await mkdir(pluginsDir, { recursive: true });
+			const filePath = join(root, "direct.js");
+			const dirPluginPath = join(pluginsDir, "dir-plugin.js");
+			await writeFile(filePath, "export default {}", "utf8");
+			await writeFile(dirPluginPath, "export default {}", "utf8");
+
+			const resolved = resolveAgentPluginPaths({
+				pluginPaths: ["./direct.js", "./plugins"],
+				workspacePath: join(root, "workspace"),
+				cwd: root,
+			});
+
+			expect(resolved).toEqual([filePath, dirPluginPath]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("prefers package manifest plugin entries for configured directories", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const pluginDir = join(root, "plugin-package");
+			const srcDir = join(pluginDir, "src");
+			await mkdir(srcDir, { recursive: true });
+			const declaredEntry = join(srcDir, "index.ts");
+			const ignoredEntry = join(pluginDir, "ignored.js");
+			await writeFile(
+				join(pluginDir, "package.json"),
+				JSON.stringify({
+					name: "plugin-package",
+					private: true,
+					cline: {
+						plugins: [
+							{
+								paths: ["./src/index.ts"],
+								capabilities: ["tools"],
+							},
+						],
+					},
+				}),
+				"utf8",
+			);
+			await writeFile(declaredEntry, "export default {}", "utf8");
+			await writeFile(ignoredEntry, "export default {}", "utf8");
+
+			const resolved = resolveAgentPluginPaths({
+				pluginPaths: ["./plugin-package"],
+				cwd: root,
+				workspacePath: join(root, "workspace"),
+			});
+
+			expect(resolved).toContain(declaredEntry);
+			expect(resolved).not.toContain(ignoredEntry);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves bundled skill directories from configured plugin packages", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const pluginDir = join(root, "plugin-package");
+			const srcDir = join(pluginDir, "src");
+			const skillDir = join(pluginDir, "skills", "review");
+			await mkdir(srcDir, { recursive: true });
+			await mkdir(skillDir, { recursive: true });
+			await writeFile(
+				join(pluginDir, "package.json"),
+				JSON.stringify({
+					name: "plugin-package",
+					private: true,
+					cline: {
+						plugins: [
+							{
+								paths: ["./src/index.ts"],
+								capabilities: ["tools"],
+							},
+						],
+					},
+				}),
+				"utf8",
+			);
+			await writeFile(join(srcDir, "index.ts"), "export default {}", "utf8");
+			await writeFile(
+				join(skillDir, "SKILL.md"),
+				"---\nname: review\n---\nReview skill.",
+				"utf8",
+			);
+
+			const resolved = resolveAgentPluginSkillDirectories({
+				pluginPaths: ["./plugin-package"],
+				cwd: root,
+				workspacePath: join(root, "workspace"),
+			});
+
+			expect(resolved).toEqual([join(pluginDir, "skills")]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("skips missing configured plugin paths while resolving bundled skill directories", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const pluginDir = join(root, "plugin-package");
+			const srcDir = join(pluginDir, "src");
+			const skillDir = join(pluginDir, "skills", "review");
+			await mkdir(srcDir, { recursive: true });
+			await mkdir(skillDir, { recursive: true });
+			await writeFile(
+				join(pluginDir, "package.json"),
+				JSON.stringify({
+					name: "plugin-package",
+					private: true,
+					cline: {
+						plugins: [
+							{
+								paths: ["./src/index.ts"],
+								capabilities: ["tools"],
+							},
+						],
+					},
+				}),
+				"utf8",
+			);
+			await writeFile(join(srcDir, "index.ts"), "export default {}", "utf8");
+			await writeFile(
+				join(skillDir, "SKILL.md"),
+				"---\nname: review\n---\nReview skill.",
+				"utf8",
+			);
+
+			const resolved = resolveAgentPluginSkillDirectories({
+				pluginPaths: ["./missing-plugin", "./plugin-package"],
+				cwd: root,
+				workspacePath: join(root, "workspace"),
+			});
+
+			expect(resolved).toEqual([join(pluginDir, "skills")]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves bundled skill directories from active plugin paths", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			const pluginDir = join(root, "plugin-package");
+			const srcDir = join(pluginDir, "src");
+			const skillDir = join(pluginDir, "skills", "review");
+			await mkdir(srcDir, { recursive: true });
+			await mkdir(skillDir, { recursive: true });
+			await writeFile(
+				join(pluginDir, "package.json"),
+				JSON.stringify({
+					name: "plugin-package",
+					private: true,
+					cline: {
+						plugins: [{ paths: ["./src/index.ts"] }],
+					},
+				}),
+				"utf8",
+			);
+			const pluginPath = join(srcDir, "index.ts");
+			await writeFile(pluginPath, "export default {}", "utf8");
+			await writeFile(
+				join(skillDir, "SKILL.md"),
+				"---\nname: review\n---\nReview skill.",
+				"utf8",
+			);
+
+			expect(resolvePluginSkillDirectoriesFromPaths([pluginPath])).toEqual([
+				join(pluginDir, "skills"),
+			]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not resolve ancestor skills from unrelated package roots", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			const pluginSrcDir = join(root, "packages", "myplugin", "src");
+			const rootSkillDir = join(root, "skills", "private-root-skill");
+			await mkdir(pluginSrcDir, { recursive: true });
+			await mkdir(rootSkillDir, { recursive: true });
+			await writeFile(
+				join(root, "package.json"),
+				JSON.stringify({
+					name: "monorepo-root",
+					private: true,
+				}),
+				"utf8",
+			);
+			const pluginPath = join(pluginSrcDir, "index.ts");
+			await writeFile(pluginPath, "export default {}", "utf8");
+			await writeFile(
+				join(rootSkillDir, "SKILL.md"),
+				"---\nname: private-root-skill\n---\nPrivate root skill.",
+				"utf8",
+			);
+
+			expect(resolvePluginSkillDirectoriesFromPaths([pluginPath])).toEqual([]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves bundled skill directories from installed plugin wrappers", async () => {
+		const home = await mkdtemp(
+			join(tmpdir(), "core-plugin-config-loader-home-"),
+		);
+		const workspace = await mkdtemp(
+			join(tmpdir(), "core-plugin-config-loader-workspace-"),
+		);
+		try {
+			process.env.HOME = home;
+			setHomeDir(home);
+			const installRoot = join(
+				workspace,
+				".cline",
+				"plugins",
+				"_installed",
+				"local",
+				"demo",
+			);
+			const packageRoot = join(installRoot, "package");
+			const skillDir = join(packageRoot, "skills", "review");
+			await mkdir(skillDir, { recursive: true });
+			await writeFile(
+				join(installRoot, "package.json"),
+				JSON.stringify({
+					name: "cline-installed-plugin-demo",
+					private: true,
+					cline: {
+						plugins: [{ paths: ["./package/index.ts"] }],
+					},
+				}),
+				"utf8",
+			);
+			await writeFile(
+				join(packageRoot, "index.ts"),
+				"export default {}",
+				"utf8",
+			);
+			await writeFile(
+				join(skillDir, "SKILL.md"),
+				"---\nname: review\n---\nReview skill.",
+				"utf8",
+			);
+
+			const resolved = resolveAgentPluginSkillDirectories({
+				workspacePath: workspace,
+				cwd: workspace,
+			});
+
+			expect(resolved).toEqual([join(packageRoot, "skills")]);
+		} finally {
+			await rm(home, { recursive: true, force: true });
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("includes shared search-path plugins", async () => {
+		const home = await mkdtemp(
+			join(tmpdir(), "core-plugin-config-loader-home-"),
+		);
+		const workspace = await mkdtemp(
+			join(tmpdir(), "core-plugin-config-loader-workspace-"),
+		);
+		try {
+			process.env.HOME = home;
+			setHomeDir(home);
+			const workspacePlugins = join(workspace, ".cline", "plugins");
+			const userPlugins = join(home, ".cline", "plugins");
+			const documentsPlugins = join(home, "Documents", "Cline", "Plugins");
+			await mkdir(workspacePlugins, { recursive: true });
+			await mkdir(userPlugins, { recursive: true });
+			await mkdir(documentsPlugins, { recursive: true });
+			const workspacePlugin = join(workspacePlugins, "workspace.js");
+			const userPlugin = join(userPlugins, "user.js");
+			const documentsPlugin = join(documentsPlugins, "documents.js");
+			await writeFile(workspacePlugin, "export default {}", "utf8");
+			await writeFile(userPlugin, "export default {}", "utf8");
+			await writeFile(documentsPlugin, "export default {}", "utf8");
+
+			const searchPaths = resolvePluginConfigSearchPaths(workspace);
+			expect(searchPaths).toHaveLength(3);
+			expect(searchPaths).toContain(workspacePlugins);
+			expect(searchPaths).toContain(userPlugins);
+			expect(searchPaths).toContain(documentsPlugins);
+
+			const resolved = resolveAgentPluginPaths({ workspacePath: workspace });
+			expect(resolved).toContain(workspacePlugin);
+			expect(resolved).toContain(userPlugin);
+			expect(resolved).toContain(documentsPlugin);
+		} finally {
+			await rm(home, { recursive: true, force: true });
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("omits plugins disabled in global settings", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const enabledPlugin = join(root, "enabled.js");
+			const disabledPlugin = join(root, "disabled.js");
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+			await writeFile(enabledPlugin, "export default {}", "utf8");
+			await writeFile(disabledPlugin, "export default {}", "utf8");
+			await writeFile(
+				settingsPath,
+				JSON.stringify({ disabledPlugins: [disabledPlugin] }, null, 2),
+				"utf8",
+			);
+
+			const resolved = resolveAgentPluginPaths({
+				pluginPaths: [enabledPlugin, disabledPlugin],
+				cwd: root,
+			});
+
+			expect(resolved).toEqual([enabledPlugin]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("loads valid plugins while reporting failures and duplicate overrides", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const first = join(root, "duplicate-one.js");
+			const second = join(root, "duplicate-two.js");
+			const invalid = join(root, "invalid.js");
+			await writeFile(
+				first,
+				"export default { name: 'duplicate-plugin', manifest: { capabilities: ['tools'] } };",
+				"utf8",
+			);
+			await writeFile(
+				second,
+				"export default { name: 'duplicate-plugin', manifest: { capabilities: ['commands'] } };",
+				"utf8",
+			);
+			await writeFile(invalid, "export default { name: 'broken' };", "utf8");
+
+			const loaded = await resolveAndLoadAgentPlugins({
+				mode: "in_process",
+				pluginPaths: [first, invalid, second],
+				cwd: root,
+			});
+
+			// Filter to only our test plugins to ignore any discovered system plugins
+			const testPlugins = loaded.extensions.filter(
+				(plugin) => plugin.name === "duplicate-plugin",
+			);
+			expect(testPlugins).toHaveLength(1);
+			expect(testPlugins[0]?.manifest.capabilities).toEqual(["commands"]);
+			expect(loaded.pluginPaths).toEqual([second]);
+			expect(loaded.failures).toHaveLength(1);
+			expect(loaded.warnings).toHaveLength(1);
+			expect(loaded.warnings[0]?.overriddenPluginPath).toBe(first);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("reports only provider and model compatible active plugin paths", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
+		try {
+			process.env.HOME = root;
+			setHomeDir(root);
+			const compatible = join(root, "compatible.js");
+			const incompatible = join(root, "incompatible.js");
+			await writeFile(
+				compatible,
+				`export default {
+	name: 'compatible-plugin',
+	manifest: {
+		capabilities: ['tools'],
+		providerIds: ['cline'],
+		modelIds: ['anthropic/claude-haiku-4.5']
+	}
+};`,
+				"utf8",
+			);
+			await writeFile(
+				incompatible,
+				`export default {
+	name: 'incompatible-plugin',
+	manifest: {
+		capabilities: ['tools'],
+		providerIds: ['openai'],
+		modelIds: ['gpt-5.4']
+	}
+};`,
+				"utf8",
+			);
+
+			const loaded = await resolveAndLoadAgentPlugins({
+				mode: "in_process",
+				pluginPaths: [compatible, incompatible],
+				cwd: root,
+				providerId: "cline",
+				modelId: "anthropic/claude-haiku-4.5",
+			});
+
+			expect(loaded.extensions.map((plugin) => plugin.name)).toEqual([
+				"compatible-plugin",
+			]);
+			expect(loaded.pluginPaths).toEqual([compatible]);
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-config-loader.ts b/sdk/packages/core/src/extensions/plugin/plugin-config-loader.ts
new file mode 100644
index 0000000..447cd8a
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-config-loader.ts
@@ -0,0 +1,313 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import type {
+	AgentConfig,
+	PluginSetupContext,
+	WorkspaceInfo,
+} from "@cline/shared";
+import {
+	discoverPluginModulePaths as discoverPluginModulePathsFromShared,
+	resolveConfiguredPluginModulePaths,
+	resolvePluginConfigSearchPaths as resolvePluginConfigSearchPathsFromShared,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+} from "@cline/shared/storage";
+import { filterDisabledPluginPaths } from "../../services/global-settings";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import { loadAgentPluginsFromPathsWithDiagnostics } from "./plugin-loader";
+import { loadSandboxedPlugins } from "./plugin-sandbox";
+import type { PluginTargeting } from "./plugin-targeting";
+
+type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
+
+const PACKAGE_JSON_FILE_NAME = "package.json";
+const INSTALLED_PACKAGE_DIRECTORY_NAME = "package";
+
+export function resolvePluginConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolvePluginConfigSearchPathsFromShared(workspacePath);
+}
+
+export function discoverPluginModulePaths(directoryPath: string): string[] {
+	return discoverPluginModulePathsFromShared(directoryPath);
+}
+
+export interface ResolveAgentPluginPathsOptions {
+	pluginPaths?: ReadonlyArray<string>;
+	workspacePath?: string;
+	cwd?: string;
+}
+
+function isDirectory(path: string): boolean {
+	try {
+		return existsSync(path) && statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function dedupePaths(paths: Iterable<string>): string[] {
+	const deduped: string[] = [];
+	const seen = new Set<string>();
+	for (const path of paths) {
+		const normalizedPath = resolve(path);
+		if (seen.has(normalizedPath)) {
+			continue;
+		}
+		seen.add(normalizedPath);
+		deduped.push(normalizedPath);
+	}
+	return deduped;
+}
+
+function mergePluginPaths(paths: Iterable<string>): string[] {
+	const deduped = dedupePaths(paths);
+	return filterDisabledPluginPaths(deduped);
+}
+
+function resolveDiscoveredPluginPaths(
+	workspacePath: string | undefined,
+): string[] {
+	return resolvePluginConfigSearchPaths(workspacePath)
+		.flatMap((directoryPath) => discoverPluginModulePaths(directoryPath))
+		.filter((path) => existsSync(path));
+}
+
+function resolveConfiguredPluginModulePathsBestEffort(
+	pluginPaths: ReadonlyArray<string>,
+	cwd: string,
+): string[] {
+	const resolvedPaths: string[] = [];
+	for (const pluginPath of pluginPaths) {
+		try {
+			resolvedPaths.push(
+				...resolveConfiguredPluginModulePaths([pluginPath], cwd),
+			);
+		} catch {}
+	}
+	return resolvedPaths;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function readDeclaredPluginEntryPaths(packageRoot: string): string[] {
+	try {
+		const parsed = JSON.parse(
+			readFileSync(join(packageRoot, PACKAGE_JSON_FILE_NAME), "utf8"),
+		) as unknown;
+		if (!isRecord(parsed) || !isRecord(parsed.cline)) {
+			return [];
+		}
+		const entries = parsed.cline.plugins;
+		if (!Array.isArray(entries)) {
+			return [];
+		}
+		const paths: string[] = [];
+		for (const entry of entries) {
+			if (typeof entry === "string") {
+				paths.push(entry);
+				continue;
+			}
+			if (!isRecord(entry) || !Array.isArray(entry.paths)) {
+				continue;
+			}
+			for (const path of entry.paths) {
+				if (typeof path === "string") {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	} catch {
+		return [];
+	}
+}
+
+function packageDeclaresPluginEntry(
+	packageRoot: string,
+	entryPath: string,
+): boolean {
+	const normalizedEntryPath = resolve(entryPath);
+	return readDeclaredPluginEntryPaths(packageRoot).some(
+		(declaredPath) =>
+			resolve(packageRoot, declaredPath) === normalizedEntryPath,
+	);
+}
+
+function isInstalledPackageDirectory(path: string, entryPath: string): boolean {
+	return (
+		basename(path) === INSTALLED_PACKAGE_DIRECTORY_NAME &&
+		existsSync(join(dirname(path), PACKAGE_JSON_FILE_NAME)) &&
+		packageDeclaresPluginEntry(dirname(path), entryPath)
+	);
+}
+
+function collectPluginSkillRootCandidates(entryPath: string): string[] {
+	const normalizedEntryPath = resolve(entryPath);
+	const candidates: string[] = [];
+	let current = dirname(normalizedEntryPath);
+
+	while (true) {
+		if (isInstalledPackageDirectory(current, normalizedEntryPath)) {
+			candidates.push(current);
+			break;
+		}
+		if (existsSync(join(current, PACKAGE_JSON_FILE_NAME))) {
+			// Do not keep walking after the first package boundary. A monorepo
+			// plugin entry can live under packages/foo/src/index.ts with no local
+			// package.json; climbing to the workspace root would expose unrelated
+			// root skills/. Only package manifests that declare this entry own skills.
+			if (packageDeclaresPluginEntry(current, normalizedEntryPath)) {
+				candidates.push(current);
+			}
+			break;
+		}
+
+		const parent = dirname(current);
+		if (parent === current) {
+			break;
+		}
+		current = parent;
+	}
+
+	return dedupePaths(candidates);
+}
+
+export function resolveAgentPluginPaths(
+	options: ResolveAgentPluginPathsOptions = {},
+): string[] {
+	const cwd = options.cwd ?? process.cwd();
+	const discoveredFromSearchPaths = resolveDiscoveredPluginPaths(
+		options.workspacePath,
+	);
+	const configuredPaths = resolveConfiguredPluginModulePaths(
+		options.pluginPaths ?? [],
+		cwd,
+	);
+
+	return mergePluginPaths([...configuredPaths, ...discoveredFromSearchPaths]);
+}
+
+function resolveAgentPluginPathsBestEffort(
+	options: ResolveAgentPluginPathsOptions = {},
+): string[] {
+	const cwd = options.cwd ?? process.cwd();
+	const discoveredFromSearchPaths = resolveDiscoveredPluginPaths(
+		options.workspacePath,
+	);
+	const configuredPaths = resolveConfiguredPluginModulePathsBestEffort(
+		options.pluginPaths ?? [],
+		cwd,
+	);
+
+	return mergePluginPaths([...configuredPaths, ...discoveredFromSearchPaths]);
+}
+
+export function resolvePluginSkillDirectoriesFromPaths(
+	pluginPaths: ReadonlyArray<string>,
+): string[] {
+	const directories: string[] = [];
+	for (const pluginPath of pluginPaths) {
+		for (const root of collectPluginSkillRootCandidates(pluginPath)) {
+			const skillDirectory = join(root, SKILLS_CONFIG_DIRECTORY_NAME);
+			if (isDirectory(skillDirectory)) {
+				directories.push(skillDirectory);
+			}
+		}
+	}
+	return dedupePaths(directories);
+}
+
+export function resolveAgentPluginSkillDirectories(
+	options: ResolveAgentPluginPathsOptions = {},
+): string[] {
+	return resolvePluginSkillDirectoriesFromPaths(
+		resolveAgentPluginPathsBestEffort(options),
+	);
+}
+
+export interface ResolveAndLoadAgentPluginsOptions
+	extends ResolveAgentPluginPathsOptions,
+		PluginTargeting {
+	mode?: "sandbox" | "in_process";
+	exportName?: string;
+	importTimeoutMs?: number;
+	hookTimeoutMs?: number;
+	contributionTimeoutMs?: number;
+	onEvent?: (event: { name: string; payload?: unknown }) => void;
+	/**
+	 * Structured workspace and git metadata. Forwarded to sandboxed plugins
+	 * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
+	 * in the extension context.
+	 */
+	workspaceInfo?: WorkspaceInfo;
+	session?: PluginSetupContext["session"];
+	client?: PluginSetupContext["client"];
+	user?: PluginSetupContext["user"];
+	automation?: PluginSetupContext["automation"];
+	logger?: PluginSetupContext["logger"];
+	telemetry?: PluginSetupContext["telemetry"];
+}
+
+export async function resolveAndLoadAgentPlugins(
+	options: ResolveAndLoadAgentPluginsOptions = {},
+): Promise<
+	{
+		extensions: AgentPlugin[];
+		pluginPaths: string[];
+		shutdown?: () => Promise<void>;
+	} & PluginLoadDiagnostics
+> {
+	const paths = resolveAgentPluginPaths(options);
+	if (paths.length === 0) {
+		return { extensions: [], failures: [], warnings: [], pluginPaths: [] };
+	}
+
+	if (options.mode === "in_process") {
+		const report = await loadAgentPluginsFromPathsWithDiagnostics(paths, {
+			cwd: options.cwd,
+			exportName: options.exportName,
+			providerId: options.providerId,
+			modelId: options.modelId,
+			session: options.session,
+			client: options.client,
+			user: options.user,
+			workspaceInfo: options.workspaceInfo,
+			automation: options.automation,
+			logger: options.logger,
+			telemetry: options.telemetry,
+		});
+		return {
+			extensions: report.plugins,
+			failures: report.failures,
+			pluginPaths: report.pluginPaths,
+			warnings: report.warnings,
+		};
+	}
+
+	const sandboxed = await loadSandboxedPlugins({
+		pluginPaths: paths,
+		exportName: options.exportName,
+		importTimeoutMs: options.importTimeoutMs,
+		hookTimeoutMs: options.hookTimeoutMs,
+		contributionTimeoutMs: options.contributionTimeoutMs,
+		onEvent: options.onEvent,
+		providerId: options.providerId,
+		modelId: options.modelId,
+		cwd: options.cwd,
+		session: options.session,
+		client: options.client,
+		user: options.user,
+		workspaceInfo: options.workspaceInfo,
+		logger: options.logger,
+	});
+	return {
+		extensions: sandboxed.extensions ?? [],
+		shutdown: sandboxed.shutdown,
+		failures: sandboxed.failures,
+		pluginPaths: sandboxed.pluginPaths,
+		warnings: sandboxed.warnings,
+	};
+}
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-load-report.ts b/sdk/packages/core/src/extensions/plugin/plugin-load-report.ts
new file mode 100644
index 0000000..5e54f9b
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-load-report.ts
@@ -0,0 +1,20 @@
+export interface PluginInitializationFailure {
+	pluginPath: string;
+	pluginName?: string;
+	phase: "load" | "setup";
+	message: string;
+	stack?: string;
+}
+
+export interface PluginInitializationWarning {
+	type: "duplicate_plugin_override";
+	pluginPath: string;
+	pluginName: string;
+	overriddenPluginPath: string;
+	message: string;
+}
+
+export interface PluginLoadDiagnostics {
+	failures: PluginInitializationFailure[];
+	warnings: PluginInitializationWarning[];
+}
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-loader.test.ts b/sdk/packages/core/src/extensions/plugin/plugin-loader.test.ts
new file mode 100644
index 0000000..921bd39
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-loader.test.ts
@@ -0,0 +1,473 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+	loadAgentPluginFromPath,
+	loadAgentPluginsFromPaths,
+	loadAgentPluginsFromPathsWithDiagnostics,
+} from "./plugin-loader";
+
+describe("plugin-loader", () => {
+	let dir = "";
+	let copyDir = "";
+
+	beforeAll(async () => {
+		dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
+		copyDir = await mkdtemp(join(tmpdir(), "core-plugin-loader-copy-"));
+
+		await writeFile(
+			join(dir, "plugin-default.mjs"),
+			[
+				"export default {",
+				"  name: 'from-default',",
+				"  manifest: { capabilities: ['hooks'] },",
+				"  hooks: { beforeRun: () => undefined }",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-top-level-await.mjs"),
+			[
+				"const name = await Promise.resolve('plugin-top-level-await');",
+				"export default {",
+				"  name,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-named.mjs"),
+			[
+				"export const plugin = {",
+				"  name: 'from-named',",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-a.mjs"),
+			"export default { name: 'plugin-a', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-b.mjs"),
+			"export default { name: 'plugin-b', manifest: { capabilities: ['commands'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-ts.ts"),
+			[
+				"const name: string = 'plugin-ts';",
+				"export default {",
+				"  name,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const depDir = join(dir, "node_modules", "plugin-local-dep");
+		await mkdir(depDir, { recursive: true });
+		await writeFile(
+			join(depDir, "package.json"),
+			JSON.stringify({
+				name: "plugin-local-dep",
+				type: "module",
+				exports: "./index.js",
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(depDir, "index.js"),
+			"export const depName = 'plugin-local-dep';\n",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-with-dep.ts"),
+			[
+				"import { depName } from 'plugin-local-dep';",
+				"export default {",
+				"  name: depName,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const sdkDir = join(dir, "node_modules", "@cline", "shared");
+		await mkdir(sdkDir, { recursive: true });
+		await writeFile(
+			join(sdkDir, "package.json"),
+			JSON.stringify({
+				name: "@cline/shared",
+				type: "module",
+				exports: "./index.js",
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(sdkDir, "index.js"),
+			"export const sdkMarker = 'plugin-installed-sdk';\n",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-with-sdk-dep.ts"),
+			[
+				"import { sdkMarker } from '@cline/shared';",
+				"export default {",
+				"  name: sdkMarker,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(copyDir, "portable-subagents.ts"),
+			[
+				"import { safeJsonStringify } from '@cline/shared';",
+				"import { resolveClineDataDir } from '@cline/shared/storage';",
+				"import YAML from 'yaml';",
+				"export default {",
+				"  name: typeof safeJsonStringify === 'function' ? YAML.stringify({ ok: !!resolveClineDataDir() }) : 'invalid',",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const packagedCopyDir = join(copyDir, "packaged-plugin");
+		await mkdir(packagedCopyDir, { recursive: true });
+		await writeFile(
+			join(packagedCopyDir, "package.json"),
+			JSON.stringify({
+				name: "packaged-plugin",
+				type: "module",
+				cline: {
+					plugins: ["index.ts"],
+				},
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(packagedCopyDir, "index.ts"),
+			[
+				"import YAML from 'yaml';",
+				"export default {",
+				"  name: YAML.stringify({ ok: true }),",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const packagedSdkSubpathDir = join(copyDir, "packaged-sdk-subpath");
+		await mkdir(packagedSdkSubpathDir, { recursive: true });
+		await writeFile(
+			join(packagedSdkSubpathDir, "package.json"),
+			JSON.stringify({
+				name: "packaged-sdk-subpath",
+				type: "module",
+				cline: {
+					plugins: ["index.ts"],
+				},
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(packagedSdkSubpathDir, "index.ts"),
+			[
+				"import { createConfiguredTelemetryHandle } from '@cline/core/telemetry';",
+				"export default {",
+				"  name: typeof createConfiguredTelemetryHandle === 'function' ? 'sdk-subpath-ok' : 'invalid',",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const packagedTypeOnlyDir = join(copyDir, "packaged-type-only-imports");
+		await mkdir(packagedTypeOnlyDir, { recursive: true });
+		await writeFile(
+			join(packagedTypeOnlyDir, "package.json"),
+			JSON.stringify({
+				name: "packaged-type-only-imports",
+				type: "module",
+				cline: {
+					plugins: ["index.ts"],
+				},
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(packagedTypeOnlyDir, "index.ts"),
+			[
+				"import type { MissingStaticType } from 'missing-static-type';",
+				"type MissingImportType = import('missing-import-type').Foo;",
+				"type MissingTypeQuery = typeof import('missing-type-query');",
+				"type TypeBag = { value: MissingStaticType; imported: MissingImportType; query: MissingTypeQuery };",
+				"function acceptsTypeOnly(input: import('missing-param-type').Foo): TypeBag | undefined {",
+				"  void input;",
+				"  return undefined;",
+				"}",
+				"const value = {} as import('missing-assertion-type').Foo;",
+				"void value;",
+				"void acceptsTypeOnly;",
+				"export default {",
+				"  name: 'type-only-imports-ok',",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "invalid-plugin.mjs"),
+			"export default { name: 'invalid-plugin' };",
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "duplicate-one.mjs"),
+			"export default { name: 'duplicate-plugin', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "duplicate-two.mjs"),
+			"export default { name: 'duplicate-plugin', manifest: { capabilities: ['commands'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "targeted-plugin.mjs"),
+			[
+				"export default {",
+				"  name: 'targeted-plugin',",
+				"  manifest: { capabilities: ['tools'], providerIds: ['openai'], modelIds: ['gpt-5.4'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+	});
+
+	afterAll(async () => {
+		if (dir) {
+			await rm(dir, { recursive: true, force: true });
+		}
+		if (copyDir) {
+			await rm(copyDir, { recursive: true, force: true });
+		}
+	});
+
+	it("loads default-exported plugin from path", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(dir, "plugin-default.mjs"),
+		);
+		expect(plugin.name).toBe("from-default");
+		expect(plugin.manifest.capabilities).toContain("hooks");
+	});
+
+	it("loads ESM plugin with top-level await from path", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(dir, "plugin-top-level-await.mjs"),
+		);
+		expect(plugin.name).toBe("plugin-top-level-await");
+	});
+
+	it("loads named plugin export from path", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(dir, "plugin-named.mjs"),
+			{
+				exportName: "plugin",
+			},
+		);
+		expect(plugin.name).toBe("from-named");
+	});
+
+	it("loads multiple plugins from file paths", async () => {
+		const plugins = await loadAgentPluginsFromPaths([
+			join(dir, "plugin-a.mjs"),
+			join(dir, "plugin-b.mjs"),
+		]);
+		expect(plugins.map((plugin) => plugin.name)).toEqual([
+			"plugin-a",
+			"plugin-b",
+		]);
+	});
+
+	it("loads TypeScript plugins from file paths", async () => {
+		const plugin = await loadAgentPluginFromPath(join(dir, "plugin-ts.ts"));
+		expect(plugin.name).toBe("plugin-ts");
+	});
+
+	it("resolves plugin-local dependencies from the plugin path", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(dir, "plugin-with-dep.ts"),
+			{ cwd: dir },
+		);
+		expect(plugin.name).toBe("plugin-local-dep");
+	});
+
+	it("prefers plugin-installed SDK packages over workspace aliases", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(dir, "plugin-with-sdk-dep.ts"),
+			{ cwd: dir },
+		);
+		expect(plugin.name).toBe("plugin-installed-sdk");
+	});
+
+	it("allows standalone file plugins to use host runtime dependencies", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(copyDir, "portable-subagents.ts"),
+			{
+				cwd: copyDir,
+				useCache: true,
+			},
+		);
+		expect(plugin.name).toMatch(/ok: true/i);
+	});
+
+	it("resolves standalone plugin dependencies from the npm wrapper path", async () => {
+		const previousWrapperPath = process.env.CLINE_WRAPPER_PATH;
+		const wrapperRoot = join(dir, "wrapper-root");
+		const wrapperBinDir = join(wrapperRoot, "bin");
+		const depDir = join(wrapperRoot, "node_modules", "wrapper-host-dep");
+		const pluginPath = join(dir, "plugin-with-wrapper-dep.ts");
+		await mkdir(wrapperBinDir, { recursive: true });
+		await mkdir(depDir, { recursive: true });
+		await writeFile(join(wrapperBinDir, "cline"), "#!/usr/bin/env node\n");
+		await writeFile(
+			join(depDir, "package.json"),
+			JSON.stringify({
+				name: "wrapper-host-dep",
+				type: "module",
+				exports: "./index.js",
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(depDir, "index.js"),
+			"export const depName = 'wrapper-host-dep';\n",
+			"utf8",
+		);
+		await writeFile(
+			pluginPath,
+			[
+				"import { depName } from 'wrapper-host-dep';",
+				"export default {",
+				"  name: depName,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		try {
+			process.env.CLINE_WRAPPER_PATH = join(wrapperBinDir, "cline");
+			const plugin = await loadAgentPluginFromPath(pluginPath);
+			expect(plugin.name).toBe("wrapper-host-dep");
+		} finally {
+			if (previousWrapperPath === undefined) {
+				delete process.env.CLINE_WRAPPER_PATH;
+			} else {
+				process.env.CLINE_WRAPPER_PATH = previousWrapperPath;
+			}
+		}
+	});
+
+	it("requires package-based plugins to provide their own non-SDK dependencies", async () => {
+		await expect(
+			loadAgentPluginFromPath(join(copyDir, "packaged-plugin", "index.ts"), {
+				cwd: join(copyDir, "packaged-plugin"),
+				useCache: true,
+			}),
+		).rejects.toThrow(/Cannot find (package|module) 'yaml'/i);
+	});
+
+	it("allows package-based plugins to use host SDK subpath exports", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(copyDir, "packaged-sdk-subpath", "index.ts"),
+			{
+				cwd: join(copyDir, "packaged-sdk-subpath"),
+				useCache: true,
+			},
+		);
+		expect(plugin.name).toBe("sdk-subpath-ok");
+	});
+
+	it("allows package-based TypeScript plugins to reference type-only packages", async () => {
+		const plugin = await loadAgentPluginFromPath(
+			join(copyDir, "packaged-type-only-imports", "index.ts"),
+			{
+				cwd: join(copyDir, "packaged-type-only-imports"),
+				useCache: true,
+			},
+		);
+		expect(plugin.name).toBe("type-only-imports-ok");
+	});
+
+	it("rejects invalid plugin export missing manifest", async () => {
+		await expect(
+			loadAgentPluginFromPath(join(dir, "invalid-plugin.mjs")),
+		).rejects.toThrow(/missing required "manifest"/i);
+	});
+
+	it("continues loading valid plugins when one plugin fails", async () => {
+		const report = await loadAgentPluginsFromPathsWithDiagnostics([
+			join(dir, "plugin-a.mjs"),
+			join(dir, "invalid-plugin.mjs"),
+			join(dir, "plugin-b.mjs"),
+		]);
+
+		expect(report.plugins.map((plugin) => plugin.name)).toEqual([
+			"plugin-a",
+			"plugin-b",
+		]);
+		expect(report.failures).toHaveLength(1);
+		expect(report.failures[0]?.pluginPath).toBe(
+			join(dir, "invalid-plugin.mjs"),
+		);
+		expect(report.warnings).toEqual([]);
+	});
+
+	it("keeps the later duplicate plugin and reports the override", async () => {
+		const report = await loadAgentPluginsFromPathsWithDiagnostics([
+			join(dir, "duplicate-one.mjs"),
+			join(dir, "duplicate-two.mjs"),
+		]);
+
+		expect(report.plugins).toHaveLength(1);
+		expect(report.plugins[0]?.name).toBe("duplicate-plugin");
+		expect(report.plugins[0]?.manifest.capabilities).toEqual(["commands"]);
+		expect(report.warnings).toHaveLength(1);
+		expect(report.warnings[0]?.overriddenPluginPath).toBe(
+			join(dir, "duplicate-one.mjs"),
+		);
+	});
+
+	it("filters plugins by manifest providerIds and modelIds", async () => {
+		const report = await loadAgentPluginsFromPathsWithDiagnostics(
+			[join(dir, "plugin-a.mjs"), join(dir, "targeted-plugin.mjs")],
+			{
+				providerId: "openai",
+				modelId: "gpt-5.4",
+			},
+		);
+		expect(report.plugins.map((plugin) => plugin.name)).toEqual([
+			"plugin-a",
+			"targeted-plugin",
+		]);
+
+		const filtered = await loadAgentPluginsFromPathsWithDiagnostics(
+			[join(dir, "plugin-a.mjs"), join(dir, "targeted-plugin.mjs")],
+			{
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4.5",
+			},
+		);
+		expect(filtered.plugins.map((plugin) => plugin.name)).toEqual(["plugin-a"]);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-loader.ts b/sdk/packages/core/src/extensions/plugin/plugin-loader.ts
new file mode 100644
index 0000000..9b2a261
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-loader.ts
@@ -0,0 +1,214 @@
+import { resolve } from "node:path";
+import type { AgentExtension, PluginSetupContext } from "@cline/shared";
+import { normalizePluginManifest } from "@cline/shared";
+import type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+} from "./plugin-load-report";
+import { importPluginModule } from "./plugin-module-import";
+import {
+	matchesPluginManifestTargeting,
+	type PluginTargeting,
+} from "./plugin-targeting";
+
+type PluginLike = {
+	name: string;
+	manifest: {
+		capabilities: string[];
+		providerIds?: string[];
+		modelIds?: string[];
+	};
+};
+
+export interface LoadAgentPluginFromPathOptions {
+	exportName?: string;
+	cwd?: string;
+	useCache?: boolean;
+	session?: PluginSetupContext["session"];
+	client?: PluginSetupContext["client"];
+	user?: PluginSetupContext["user"];
+	workspaceInfo?: PluginSetupContext["workspaceInfo"];
+	automation?: PluginSetupContext["automation"];
+	logger?: PluginSetupContext["logger"];
+	telemetry?: PluginSetupContext["telemetry"];
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function hasValidStringArray(value: unknown): value is string[] {
+	return (
+		Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	);
+}
+
+function validatePluginManifest(
+	plugin: PluginLike,
+	absolutePath: string,
+): void {
+	if (!isObject(plugin.manifest)) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: missing required "manifest"`,
+		);
+	}
+	if (!hasValidStringArray(plugin.manifest.capabilities)) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.capabilities must be a string array`,
+		);
+	}
+	if (plugin.manifest.capabilities.length === 0) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.capabilities cannot be empty`,
+		);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "providerIds") &&
+		!hasValidStringArray(plugin.manifest.providerIds)
+	) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.providerIds must be a string array when provided`,
+		);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "modelIds") &&
+		!hasValidStringArray(plugin.manifest.modelIds)
+	) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.modelIds must be a string array when provided`,
+		);
+	}
+}
+
+function validatePluginExport(
+	plugin: unknown,
+	absolutePath: string,
+): asserts plugin is PluginLike {
+	if (!isObject(plugin)) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: expected object export`,
+		);
+	}
+	if (typeof plugin.name !== "string" || plugin.name.length === 0) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: expected non-empty "name"`,
+		);
+	}
+	if (!Object.hasOwn(plugin, "manifest")) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: missing required "manifest"`,
+		);
+	}
+	validatePluginManifest(plugin as PluginLike, absolutePath);
+}
+
+export async function loadAgentPluginFromPath(
+	pluginPath: string,
+	options: LoadAgentPluginFromPathOptions = {},
+): Promise<AgentExtension> {
+	const absolutePath = resolve(options.cwd ?? process.cwd(), pluginPath);
+	const moduleExports = await importPluginModule(absolutePath, {
+		useCache: options.useCache,
+	});
+	const exportName = options.exportName ?? "plugin";
+	const plugin = (moduleExports.default ??
+		moduleExports[exportName]) as unknown;
+
+	validatePluginExport(plugin, absolutePath);
+	const pluginTyped = plugin as AgentExtension;
+	const originalSetup = pluginTyped.setup;
+
+	// Wrap setup to inject workspace context
+	const setupWithContext: AgentExtension["setup"] = originalSetup
+		? (api, _ctx) => {
+				const session = {
+					...options.session,
+					..._ctx.session,
+				};
+				const ctx = {
+					..._ctx,
+					session: Object.keys(session).length > 0 ? session : undefined,
+					client: options.client ?? _ctx.client,
+					user: options.user ?? _ctx.user,
+					workspaceInfo: options.workspaceInfo ?? _ctx.workspaceInfo,
+					automation: options.automation ?? _ctx.automation,
+					logger: options.logger ?? _ctx.logger,
+					telemetry: options.telemetry ?? _ctx.telemetry,
+				};
+				return originalSetup(api, ctx);
+			}
+		: undefined;
+
+	return {
+		...pluginTyped,
+		manifest: normalizePluginManifest(pluginTyped.manifest),
+		setup: setupWithContext,
+	};
+}
+
+export async function loadAgentPluginsFromPaths(
+	pluginPaths: string[],
+	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
+): Promise<AgentExtension[]> {
+	const report = await loadAgentPluginsFromPathsWithDiagnostics(
+		pluginPaths,
+		options,
+	);
+	return report.plugins;
+}
+
+export async function loadAgentPluginsFromPathsWithDiagnostics(
+	pluginPaths: string[],
+	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
+): Promise<{
+	plugins: AgentExtension[];
+	pluginPaths: string[];
+	failures: PluginInitializationFailure[];
+	warnings: PluginInitializationWarning[];
+}> {
+	const failures: PluginInitializationFailure[] = [];
+	const warnings: PluginInitializationWarning[] = [];
+	const loadedByName = new Map<
+		string,
+		{ plugin: AgentExtension; pluginPath: string; order: number }
+	>();
+	let order = 0;
+
+	for (const pluginPath of pluginPaths) {
+		try {
+			const plugin = await loadAgentPluginFromPath(pluginPath, options);
+			if (!matchesPluginManifestTargeting(plugin.manifest, options)) {
+				continue;
+			}
+			const existing = loadedByName.get(plugin.name);
+			if (existing) {
+				warnings.push({
+					type: "duplicate_plugin_override",
+					pluginName: plugin.name,
+					pluginPath,
+					overriddenPluginPath: existing.pluginPath,
+					message: `Plugin "${plugin.name}" from ${pluginPath} overrides ${existing.pluginPath}`,
+				});
+			}
+			loadedByName.set(plugin.name, { plugin, pluginPath, order: order++ });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			failures.push({
+				pluginPath,
+				phase: "load",
+				message,
+				stack: error instanceof Error ? error.stack : undefined,
+			});
+		}
+	}
+
+	const loadedEntries = [...loadedByName.values()].sort(
+		(left, right) => left.order - right.order,
+	);
+	return {
+		plugins: loadedEntries.map((entry) => entry.plugin),
+		pluginPaths: loadedEntries.map((entry) => entry.pluginPath),
+		failures,
+		warnings,
+	};
+}
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-module-import.ts b/sdk/packages/core/src/extensions/plugin/plugin-module-import.ts
new file mode 100644
index 0000000..34d3c01
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-module-import.ts
@@ -0,0 +1,682 @@
+import { existsSync, readFileSync } from "node:fs";
+import { builtinModules, createRequire } from "node:module";
+import { dirname, extname, isAbsolute, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PLUGIN_FILE_EXTENSIONS } from "@cline/shared";
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const HOST_REQUIRE = createRequire(import.meta.url);
+// `plugin-module-import.ts` lives at `packages/core/src/extensions/plugin`, so
+// walking up five levels lands at the repo root.
+const WORKSPACE_ROOT = resolve(MODULE_DIR, "..", "..", "..", "..", "..");
+const WORKSPACE_ALIASES = collectWorkspaceAliases(WORKSPACE_ROOT);
+const HOST_PROVIDED_SDK_SPECIFIERS = [
+	"@cline/sdk",
+	"@cline/agents",
+	"@cline/core",
+	"@cline/core/hub",
+	"@cline/core/hub/daemon-entry",
+	"@cline/core/telemetry",
+	"@cline/llms",
+	"@cline/llms/browser",
+	"@cline/shared",
+	"@cline/shared/automation",
+	"@cline/shared/browser",
+	"@cline/shared/storage",
+	"@cline/shared/db",
+	"@cline/shared/types",
+];
+const BUILTIN_MODULES = new Set(
+	builtinModules.flatMap((id) => [id, id.replace(/^node:/, "")]),
+);
+const SUPPORTED_PLUGIN_EXTENSIONS = new Set(PLUGIN_FILE_EXTENSIONS);
+const WORKSPACE_EXPORT_CONDITIONS = [
+	"development",
+	"node",
+	"import",
+	"require",
+	"default",
+];
+
+export interface ImportPluginModuleOptions {
+	useCache?: boolean;
+}
+
+function collectWorkspaceAliases(root: string): Record<string, string> {
+	const aliases: Record<string, string> = {};
+	const candidates: Record<string, string> = {
+		"@cline/sdk": resolve(root, "packages/sdk/src/index.ts"),
+		"@cline/agents": resolve(root, "packages/agents/src/index.ts"),
+		"@cline/core": resolve(root, "packages/core/src/index.ts"),
+		"@cline/llms": resolve(root, "packages/llms/src/index.ts"),
+		"@cline/shared": resolve(root, "packages/shared/src/index.ts"),
+		"@cline/shared/storage": resolve(
+			root,
+			"packages/shared/src/storage/index.ts",
+		),
+		"@cline/shared/db": resolve(root, "packages/shared/src/db/index.ts"),
+	};
+	for (const [key, value] of Object.entries(candidates)) {
+		if (existsSync(value)) {
+			aliases[key] = value;
+		}
+	}
+	for (const packageName of ["agents", "core", "llms", "shared"]) {
+		const packageRoot = resolve(root, "packages", packageName);
+		const packageJsonPath = resolve(packageRoot, "package.json");
+		if (!existsSync(packageJsonPath)) {
+			continue;
+		}
+		try {
+			const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+				name?: unknown;
+				exports?: unknown;
+			};
+			if (typeof pkg.name !== "string" || !pkg.exports) {
+				continue;
+			}
+			if (typeof pkg.exports === "string") {
+				const target = resolve(packageRoot, pkg.exports);
+				if (existsSync(target)) {
+					aliases[pkg.name] = target;
+				}
+				continue;
+			}
+			if (typeof pkg.exports !== "object") {
+				continue;
+			}
+			for (const [exportPath, exportValue] of Object.entries(pkg.exports)) {
+				const sourcePath = resolveWorkspaceExportSourcePath(
+					packageRoot,
+					exportValue,
+				);
+				if (!sourcePath) {
+					continue;
+				}
+				const specifier =
+					exportPath === "."
+						? pkg.name
+						: `${pkg.name}/${exportPath.replace(/^\.\//, "")}`;
+				aliases[specifier] = sourcePath;
+			}
+		} catch {
+			// Workspace aliases are a development convenience; ignore malformed
+			// package manifests and let normal resolution report any real failure.
+		}
+	}
+	return aliases;
+}
+
+function resolveWorkspaceExportSourcePath(
+	packageRoot: string,
+	exportValue: unknown,
+): string | null {
+	const exportPath = selectWorkspaceExportPath(exportValue);
+	if (!exportPath) {
+		return null;
+	}
+	const candidates = inferWorkspaceSourceCandidates(packageRoot, exportPath);
+	for (const candidate of candidates) {
+		if (existsSync(candidate)) {
+			return candidate;
+		}
+	}
+	return null;
+}
+
+function selectWorkspaceExportPath(
+	exportValue: unknown,
+	seen = new Set<unknown>(),
+): string | null {
+	if (typeof exportValue === "string") {
+		return exportValue;
+	}
+	if (!exportValue || typeof exportValue !== "object") {
+		return null;
+	}
+	if (seen.has(exportValue)) {
+		return null;
+	}
+	seen.add(exportValue);
+	const exports = exportValue as Record<string, unknown>;
+	for (const condition of WORKSPACE_EXPORT_CONDITIONS) {
+		const resolved = selectWorkspaceExportPath(exports[condition], seen);
+		if (resolved) {
+			return resolved;
+		}
+	}
+	return null;
+}
+
+function inferWorkspaceSourceCandidates(
+	packageRoot: string,
+	exportPath: string,
+): string[] {
+	const normalizedPath = exportPath.replace(/^\.\//, "");
+	const candidates = [resolve(packageRoot, exportPath)];
+	if (normalizedPath.startsWith("dist/")) {
+		const sourceBasePath = normalizedPath
+			.replace(/^dist\//, "src/")
+			.replace(/\.(mjs|cjs|js)$/, "");
+		return [
+			resolve(packageRoot, `${sourceBasePath}.ts`),
+			resolve(packageRoot, `${sourceBasePath}.tsx`),
+			resolve(packageRoot, `${sourceBasePath}.mts`),
+			resolve(packageRoot, `${sourceBasePath}.cts`),
+			...candidates,
+		];
+	}
+	return candidates;
+}
+
+function sortAliasesBySpecificity(
+	aliases: Record<string, string>,
+): Record<string, string> {
+	return Object.fromEntries(
+		Object.entries(aliases).sort(
+			([left], [right]) => right.length - left.length,
+		),
+	);
+}
+
+function isBareSpecifier(specifier: string): boolean {
+	return !(
+		specifier.startsWith(".") ||
+		specifier.startsWith("/") ||
+		specifier.startsWith("file:") ||
+		specifier.startsWith("data:") ||
+		specifier.startsWith("http:") ||
+		specifier.startsWith("https:")
+	);
+}
+
+function getPackageName(specifier: string): string {
+	if (specifier.startsWith("@")) {
+		const [scope, name] = specifier.split("/", 3);
+		return name ? `${scope}/${name}` : specifier;
+	}
+	return specifier.split("/", 1)[0] ?? specifier;
+}
+
+function getPackageExportPath(specifier: string): string {
+	const packageName = getPackageName(specifier);
+	if (specifier === packageName) {
+		return ".";
+	}
+	return `.${specifier.slice(packageName.length)}`;
+}
+
+function isClineSdkSpecifier(specifier: string): boolean {
+	return getPackageName(specifier).startsWith("@cline/");
+}
+
+function hasInstalledDependency(
+	pluginFilePath: string,
+	specifier: string,
+): boolean {
+	const packageName = getPackageName(specifier);
+	let current = dirname(pluginFilePath);
+	while (true) {
+		const packageDir = resolve(current, "node_modules", packageName);
+		if (
+			existsSync(packageDir) ||
+			existsSync(resolve(packageDir, "package.json"))
+		) {
+			return true;
+		}
+		const parent = resolve(current, "..");
+		if (parent === current) {
+			return false;
+		}
+		current = parent;
+	}
+}
+
+function resolvesFromHostRuntime(specifier: string): boolean {
+	return resolveFromHostRuntime(specifier) !== null;
+}
+
+function resolveFromHostRuntime(specifier: string): string | null {
+	try {
+		return HOST_REQUIRE.resolve(specifier);
+	} catch {
+		// Continue with package export resolution for ESM-only package exports.
+	}
+	return resolveHostPackageExport(specifier);
+}
+
+function resolveHostPackageExport(specifier: string): string | null {
+	const packageName = getPackageName(specifier);
+	const packageRoot = findHostPackageRoot(packageName);
+	if (!packageRoot) {
+		return null;
+	}
+	const packageJsonPath = resolve(packageRoot, "package.json");
+	try {
+		const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+			exports?: unknown;
+			main?: unknown;
+		};
+		const exportPath = getPackageExportPath(specifier);
+		const exportValue =
+			exportPath === "." && typeof pkg.exports === "string"
+				? pkg.exports
+				: pkg.exports &&
+						typeof pkg.exports === "object" &&
+						Object.hasOwn(pkg.exports, exportPath)
+					? (pkg.exports as Record<string, unknown>)[exportPath]
+					: undefined;
+		const resolvedExportPath =
+			selectWorkspaceExportPath(exportValue) ??
+			(exportPath === "." && typeof pkg.main === "string" ? pkg.main : null);
+		if (!resolvedExportPath) {
+			return null;
+		}
+		const exportTarget = resolve(packageRoot, resolvedExportPath);
+		const candidates = [
+			exportTarget,
+			...inferWorkspaceSourceCandidates(packageRoot, resolvedExportPath).filter(
+				(candidate) => candidate !== exportTarget,
+			),
+		];
+		for (const candidate of candidates) {
+			if (existsSync(candidate)) {
+				return candidate;
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+function getHostPackageSearchRoots(): string[] {
+	const roots = [MODULE_DIR];
+	const wrapperPath = process.env.CLINE_WRAPPER_PATH?.trim();
+	if (wrapperPath) {
+		roots.push(dirname(dirname(wrapperPath)));
+	}
+	const execPath = process.execPath?.trim();
+	if (execPath) {
+		roots.push(dirname(execPath));
+	}
+	return [...new Set(roots.map((root) => resolve(root)))];
+}
+
+function findHostPackageRootFrom(
+	startDir: string,
+	packageName: string,
+): string | null {
+	let current = startDir;
+	while (true) {
+		const packageJsonPath = resolve(current, "package.json");
+		if (existsSync(packageJsonPath)) {
+			try {
+				const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+					name?: unknown;
+				};
+				if (pkg.name === packageName) {
+					return current;
+				}
+			} catch {
+				// Keep walking; malformed manifests are not useful for resolution.
+			}
+		}
+		const dependencyPackageJsonPath = resolve(
+			current,
+			"node_modules",
+			packageName,
+			"package.json",
+		);
+		if (existsSync(dependencyPackageJsonPath)) {
+			return dirname(dependencyPackageJsonPath);
+		}
+		const parent = resolve(current, "..");
+		if (parent === current) {
+			return null;
+		}
+		current = parent;
+	}
+}
+
+function findHostPackageRoot(packageName: string): string | null {
+	for (const root of getHostPackageSearchRoots()) {
+		const packageRoot = findHostPackageRootFrom(root, packageName);
+		if (packageRoot) {
+			return packageRoot;
+		}
+	}
+	return null;
+}
+
+function isPackageBasedPlugin(pluginFilePath: string): boolean {
+	// Walk up from the plugin file looking for a package.json with a `cline`
+	// manifest. Stop at the first package.json we encounter; if it doesn't
+	// declare `cline` we've left the plugin boundary (e.g. hit the workspace
+	// root).  Also cap the traversal so we never wander far from the plugin
+	// search root (.cline/plugins).
+	const MAX_DEPTH = 4;
+	let current = dirname(pluginFilePath);
+	for (let depth = 0; depth < MAX_DEPTH; depth++) {
+		const packageJsonPath = resolve(current, "package.json");
+		if (existsSync(packageJsonPath)) {
+			try {
+				const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+				return pkg != null && typeof pkg === "object" && "cline" in pkg;
+			} catch {
+				return false;
+			}
+		}
+		const parent = resolve(current, "..");
+		if (parent === current) {
+			return false;
+		}
+		current = parent;
+	}
+	return false;
+}
+
+function resolveRelativeImportPath(
+	fromPath: string,
+	specifier: string,
+): string | null {
+	const resolvedBase = specifier.startsWith("file:")
+		? fileURLToPath(specifier)
+		: isAbsolute(specifier)
+			? specifier
+			: resolve(dirname(fromPath), specifier);
+	if (
+		existsSync(resolvedBase) &&
+		SUPPORTED_PLUGIN_EXTENSIONS.has(extname(resolvedBase))
+	) {
+		return resolvedBase;
+	}
+	for (const extension of SUPPORTED_PLUGIN_EXTENSIONS) {
+		const withExtension = `${resolvedBase}${extension}`;
+		if (existsSync(withExtension)) {
+			return withExtension;
+		}
+	}
+	for (const extension of SUPPORTED_PLUGIN_EXTENSIONS) {
+		const indexPath = resolve(resolvedBase, `index${extension}`);
+		if (existsSync(indexPath)) {
+			return indexPath;
+		}
+	}
+	return null;
+}
+
+function collectStaticModuleSpecifiers(source: string): string[] {
+	const specifiers = new Set<string>();
+	const patterns = [
+		/\bimport\s+(?:type\s+)?[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,
+		/\bexport\s+[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,
+		/\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+		/\brequire\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+	];
+	for (const pattern of patterns) {
+		for (const match of source.matchAll(pattern)) {
+			const specifier = match[1];
+			if (specifier) {
+				specifiers.add(specifier);
+			}
+		}
+	}
+	return [...specifiers];
+}
+
+function shouldPreflightBareDependencies(pluginPath: string): boolean {
+	// TypeScript source can contain type-only import syntax that is not runtime
+	// dependency evidence. Let jiti and Node report real runtime load failures.
+	return extname(pluginPath) !== ".ts";
+}
+
+function assertPluginDependenciesInstalled(
+	pluginPath: string,
+	preferHostRuntimeDependencies: boolean,
+	seen = new Set<string>(),
+): void {
+	if (seen.has(pluginPath) || !existsSync(pluginPath)) {
+		return;
+	}
+	seen.add(pluginPath);
+
+	if (!SUPPORTED_PLUGIN_EXTENSIONS.has(extname(pluginPath))) {
+		return;
+	}
+
+	const source = readFileSync(pluginPath, "utf8");
+	const preflightBareDependencies = shouldPreflightBareDependencies(pluginPath);
+	for (const specifier of collectStaticModuleSpecifiers(source)) {
+		if (specifier.startsWith("node:") || BUILTIN_MODULES.has(specifier)) {
+			continue;
+		}
+		if (isBareSpecifier(specifier)) {
+			if (!preflightBareDependencies) {
+				continue;
+			}
+			if (
+				Object.hasOwn(WORKSPACE_ALIASES, specifier) ||
+				Object.hasOwn(WORKSPACE_ALIASES, getPackageName(specifier)) ||
+				hasInstalledDependency(pluginPath, specifier) ||
+				(isClineSdkSpecifier(specifier) &&
+					resolvesFromHostRuntime(specifier)) ||
+				(preferHostRuntimeDependencies && resolvesFromHostRuntime(specifier))
+			) {
+				continue;
+			}
+			throw new Error(`Cannot find module '${getPackageName(specifier)}'`);
+		}
+		const resolvedPath = resolveRelativeImportPath(pluginPath, specifier);
+		if (resolvedPath) {
+			assertPluginDependenciesInstalled(
+				resolvedPath,
+				preferHostRuntimeDependencies,
+				seen,
+			);
+		}
+	}
+}
+
+function collectPluginStaticModuleSpecifiers(
+	pluginPath: string,
+	seen = new Set<string>(),
+	specifiers = new Set<string>(),
+): Set<string> {
+	if (seen.has(pluginPath) || !existsSync(pluginPath)) {
+		return specifiers;
+	}
+	seen.add(pluginPath);
+
+	if (!SUPPORTED_PLUGIN_EXTENSIONS.has(extname(pluginPath))) {
+		return specifiers;
+	}
+
+	const source = readFileSync(pluginPath, "utf8");
+	for (const specifier of collectStaticModuleSpecifiers(source)) {
+		specifiers.add(specifier);
+		if (isBareSpecifier(specifier)) {
+			continue;
+		}
+		const resolvedPath = resolveRelativeImportPath(pluginPath, specifier);
+		if (resolvedPath) {
+			collectPluginStaticModuleSpecifiers(resolvedPath, seen, specifiers);
+		}
+	}
+	return specifiers;
+}
+
+function collectPluginImportAliases(
+	pluginPath: string,
+	preferHostRuntimeDependencies: boolean,
+): Record<string, string> {
+	const pluginRequire = createRequire(pluginPath);
+	const aliases: Record<string, string> = {};
+	const staticSpecifiers = collectPluginStaticModuleSpecifiers(pluginPath);
+	const hostRuntimeSpecifiers = new Set(HOST_PROVIDED_SDK_SPECIFIERS);
+	for (const [specifier, sourcePath] of Object.entries(WORKSPACE_ALIASES)) {
+		try {
+			pluginRequire.resolve(specifier);
+			continue;
+		} catch {
+			// Use the workspace source only when the plugin package does not provide
+			// its own installed SDK dependency.
+		}
+		aliases[specifier] = sourcePath;
+	}
+	for (const specifier of staticSpecifiers) {
+		if (
+			isBareSpecifier(specifier) &&
+			(isClineSdkSpecifier(specifier) || preferHostRuntimeDependencies)
+		) {
+			hostRuntimeSpecifiers.add(specifier);
+		}
+	}
+	for (const specifier of hostRuntimeSpecifiers) {
+		if (
+			Object.hasOwn(aliases, specifier) ||
+			hasInstalledDependency(pluginPath, specifier)
+		) {
+			continue;
+		}
+		const resolved = resolveFromHostRuntime(specifier);
+		if (resolved) {
+			aliases[specifier] = resolved;
+		}
+	}
+	if (!preferHostRuntimeDependencies) {
+		return aliases;
+	}
+	for (const specifier of staticSpecifiers) {
+		if (
+			!isBareSpecifier(specifier) ||
+			Object.hasOwn(aliases, specifier) ||
+			hasInstalledDependency(pluginPath, specifier) ||
+			specifier.startsWith("node:") ||
+			BUILTIN_MODULES.has(specifier)
+		) {
+			continue;
+		}
+		const resolved = resolveFromHostRuntime(specifier);
+		if (resolved) {
+			aliases[specifier] = resolved;
+		}
+	}
+	return aliases;
+}
+
+function shouldTransformAliasTarget(target: string): boolean {
+	const extension = extname(target);
+	return (
+		extension === ".ts" ||
+		extension === ".tsx" ||
+		extension === ".mts" ||
+		extension === ".cts"
+	);
+}
+
+type JitiTransform = (opts: {
+	source: string;
+	filename?: string;
+	ts?: boolean;
+	async?: boolean;
+	jsx?: unknown;
+	[key: string]: unknown;
+}) => { code: string; error?: unknown };
+
+let cachedJitiTransform: JitiTransform | null | undefined;
+
+function loadJitiBabelTransform(): JitiTransform | null {
+	if (cachedJitiTransform !== undefined) {
+		return cachedJitiTransform;
+	}
+	// jiti's default lazyTransform path is
+	//   createRequire(import.meta.url)("../dist/babel.cjs")
+	// which fails in a `bun build --compile` binary: `import.meta.url` is
+	// `bunfs:/root/chunk-XXXX.js`, so the relative resolve has nothing to
+	// walk through. The wrapper install layout still has the real file at
+	// <wrapper>/node_modules/jiti/dist/babel.cjs, so locate it on disk via
+	// our host-package resolver and createRequire from an actual on-disk
+	// path. Returning null falls back to jiti's own loader (works in dev).
+	const jitiRoot = findHostPackageRoot("jiti");
+	if (!jitiRoot) {
+		cachedJitiTransform = null;
+		return null;
+	}
+	const babelPath = resolve(jitiRoot, "dist", "babel.cjs");
+	if (!existsSync(babelPath)) {
+		cachedJitiTransform = null;
+		return null;
+	}
+	try {
+		const requireFromBabel = createRequire(babelPath);
+		const transform = requireFromBabel(babelPath) as unknown;
+		cachedJitiTransform =
+			typeof transform === "function" ? (transform as JitiTransform) : null;
+	} catch {
+		cachedJitiTransform = null;
+	}
+	return cachedJitiTransform;
+}
+
+export async function importPluginModule(
+	pluginPath: string,
+	options: ImportPluginModuleOptions = {},
+): Promise<Record<string, unknown>> {
+	const preferHostRuntimeDependencies = !isPackageBasedPlugin(pluginPath);
+	assertPluginDependenciesInstalled(pluginPath, preferHostRuntimeDependencies);
+	const aliases = collectPluginImportAliases(
+		pluginPath,
+		preferHostRuntimeDependencies,
+	);
+	const sortedAliases = sortAliasesBySpecificity(aliases);
+	const jitiModule = (await import("jiti")) as unknown;
+	const createJiti =
+		typeof jitiModule === "function"
+			? jitiModule
+			: typeof (jitiModule as { default?: unknown }).default === "function"
+				? (jitiModule as { default: typeof import("jiti").default }).default
+				: undefined;
+	if (!createJiti) {
+		throw new Error("Unable to load jiti");
+	}
+	const transformModules = Object.entries(sortedAliases)
+		.filter(([, target]) => shouldTransformAliasTarget(target))
+		.map(([specifier]) => specifier);
+	// jiti's lazyTransform uses `createRequire(import.meta.url)("../dist/babel.cjs")`
+	// to load its babel transformer on demand. In a `bun build --compile`
+	// binary that fails because `import.meta.url` points inside the bunfs
+	// bundle; the wrapper install still has the file on real disk though, so
+	// we locate it via our host-package resolver and inject the transform.
+	//
+	// jiti threads its top-level `interopDefault` into babel via the transform
+	// call's options (babel uses `noInterop: !interopDefault`). We want babel
+	// to emit the CJS interop wrapper so `import YAML from "yaml"` works for
+	// CJS deps, but we do not want jiti's runtime to wrap returned modules
+	// in a default-synthesizing Proxy (that proxy makes `moduleExports.default`
+	// truthy even for namespace-only modules, which breaks named-export
+	// plugins). Pin `interopDefault: true` going into babel by overriding it
+	// in the transform call, while keeping `interopDefault: false` on the jiti
+	// instance so the loader sees raw exports.
+	const baseBabelTransform = loadJitiBabelTransform();
+	const babelTransform: JitiTransform | undefined = baseBabelTransform
+		? (opts) => baseBabelTransform({ ...opts, interopDefault: true })
+		: undefined;
+	const jiti = createJiti(pluginPath, {
+		alias: sortedAliases,
+		cache: options.useCache,
+		requireCache: options.useCache,
+		esmResolve: true,
+		interopDefault: false,
+		nativeModules: [...BUILTIN_MODULES],
+		transformModules,
+		// On Bun (the packaged binary), tryNative defaults to true, which makes
+		// jiti hand the plugin path straight to Bun's `import()`. Bun then owns
+		// every nested import in the plugin, sees `import "@cline/core"` with no
+		// node_modules adjacent to the drop-in plugin. Forcing tryNative off keeps
+		// jiti in charge so bare specifiers can be rewritten through aliases first.
+		tryNative: false,
+		...(babelTransform ? { transform: babelTransform } : {}),
+	});
+	return (await jiti.import(pluginPath, {})) as Record<string, unknown>;
+}
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-sandbox-bootstrap.ts b/sdk/packages/core/src/extensions/plugin/plugin-sandbox-bootstrap.ts
new file mode 100644
index 0000000..6031c32
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-sandbox-bootstrap.ts
@@ -0,0 +1,799 @@
+/**
+ * Bootstrap script for the plugin sandbox subprocess.
+ *
+ * This file runs inside an isolated Node.js child process spawned by
+ * {@link SubprocessSandbox}. It receives RPC calls over IPC and dynamically
+ * imports plugin modules, wiring up their contributions (tools, commands,
+ * message builders, providers) and lifecycle hooks.
+ *
+ * Because it executes in a separate process it must stay bundle-safe and only
+ * depend on local helpers that can be inlined into the sandbox build.
+ */
+
+import {
+	type AgentExtensionMcpServer,
+	type AutomationEventEnvelope,
+	normalizePluginManifest,
+	type PluginManifest,
+} from "@cline/shared";
+import { importPluginModule } from "./plugin-module-import";
+import {
+	matchesPluginManifestTargeting,
+	type PluginTargeting,
+} from "./plugin-targeting";
+
+// ---------------------------------------------------------------------------
+// Types (intentionally minimal – mirrors only what the RPC protocol needs)
+// ---------------------------------------------------------------------------
+
+interface PluginTool {
+	name: string;
+	description?: string;
+	inputSchema?: unknown;
+	timeoutMs?: number;
+	retryable?: boolean;
+	execute: (input: unknown, context: unknown) => Promise<unknown>;
+}
+
+interface PluginCommand {
+	name: string;
+	description?: string;
+	handler?: (
+		input: string,
+	) => Promise<PluginCommandResult> | PluginCommandResult;
+}
+
+// Keep this local mirror in sync with AgentExtensionCommandResult from @cline/shared.
+// The sandbox bootstrap runs in an isolated process and avoids host package imports.
+type PluginCommandResult =
+	| string
+	| {
+			reply?: string;
+			submitPrompt?: string;
+	  };
+
+interface PluginRule {
+	id: string;
+	content: string | (() => string | Promise<string>);
+	source?: string;
+}
+
+interface PluginMessageBuilder {
+	name: string;
+	build: (message: unknown[]) => unknown[]; // Message[]
+}
+
+interface PluginProvider {
+	name: string;
+	description?: string;
+	metadata?: Record<string, unknown>;
+}
+
+interface PluginAutomationEventType {
+	eventType: string;
+	source: string;
+	description?: string;
+	attributesSchema?: Record<string, unknown>;
+	payloadSchema?: Record<string, unknown>;
+	examples?: AutomationEventEnvelope[];
+	metadata?: Record<string, unknown>;
+}
+
+interface PluginApi {
+	registerTool(tool: PluginTool): void;
+	registerCommand(command: PluginCommand): void;
+	registerRule(rule: PluginRule): void;
+	registerMessageBuilder(builder: PluginMessageBuilder): void;
+	registerProvider(provider: PluginProvider): void;
+	registerAutomationEventType(eventType: PluginAutomationEventType): void;
+	registerMcpServer(server: AgentExtensionMcpServer): void;
+}
+
+interface PluginSetupCtx {
+	session?: unknown;
+	client?: unknown;
+	user?: unknown;
+	workspaceInfo?: unknown;
+	automation?: {
+		ingestEvent(event: AutomationEventEnvelope): void | Promise<void>;
+	};
+	logger?: {
+		debug(message: string, metadata?: Record<string, unknown>): void;
+		log(message: string, metadata?: Record<string, unknown>): void;
+		error(message: string, metadata?: Record<string, unknown>): void;
+	};
+}
+
+interface PluginModule {
+	name: string;
+	manifest: PluginManifest;
+	setup?: (api: PluginApi, ctx: PluginSetupCtx) => void | Promise<void>;
+	hooks?: Record<string, (ctx: unknown) => unknown | Promise<unknown>>;
+}
+
+interface ContributionDescriptor {
+	id: string;
+	name: string;
+	description?: string;
+	inputSchema?: unknown;
+	timeoutMs?: number;
+	retryable?: boolean;
+	value?: string;
+	defaultValue?: boolean | string | number;
+	metadata?: Record<string, unknown>;
+}
+
+interface RuleContributionDescriptor {
+	id: string;
+	ruleId: string;
+	content?: string;
+	source?: string;
+	hasContentHandler?: boolean;
+}
+
+interface AutomationEventTypeDescriptor {
+	id: string;
+	eventType: string;
+	source: string;
+	description?: string;
+	attributesSchema?: Record<string, unknown>;
+	payloadSchema?: Record<string, unknown>;
+	examples?: AutomationEventEnvelope[];
+	metadata?: Record<string, unknown>;
+}
+
+interface PluginDescriptor {
+	pluginId: string;
+	pluginPath: string;
+	name: string;
+	manifest: PluginManifest;
+	hooks?: string[];
+	contributions: {
+		tools: ContributionDescriptor[];
+		commands: ContributionDescriptor[];
+		rules: RuleContributionDescriptor[];
+		messageBuilders: ContributionDescriptor[];
+		providers: ContributionDescriptor[];
+		automationEventTypes: AutomationEventTypeDescriptor[];
+		mcpServers: AgentExtensionMcpServer[];
+		shortcuts?: ContributionDescriptor[];
+		flags?: ContributionDescriptor[];
+	};
+}
+
+interface PluginInitializationFailure {
+	pluginPath: string;
+	pluginName?: string;
+	phase: "load" | "setup";
+	message: string;
+	stack?: string;
+}
+
+interface PluginInitializationWarning {
+	type: "duplicate_plugin_override";
+	pluginPath: string;
+	pluginName: string;
+	overriddenPluginPath: string;
+	message: string;
+}
+
+interface InitializeResult {
+	plugins: PluginDescriptor[];
+	failures: PluginInitializationFailure[];
+	warnings: PluginInitializationWarning[];
+}
+
+interface PluginState {
+	plugin: PluginModule;
+	handlers: {
+		tools: Map<string, PluginTool["execute"]>;
+		commands: Map<string, NonNullable<PluginCommand["handler"]>>;
+		rules: Map<string, () => string | Promise<string>>;
+		messageBuilders: Map<string, PluginMessageBuilder["build"]>;
+	};
+}
+
+type LoadedPluginResult =
+	| {
+			type: "loaded";
+			descriptor: PluginDescriptor;
+			state: PluginState;
+	  }
+	| {
+			type: "skipped";
+	  }
+	| {
+			type: "failure";
+			failure: PluginInitializationFailure;
+	  };
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function hasValidStringArray(value: unknown): value is string[] {
+	return (
+		Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	);
+}
+
+function assertValidPluginModule(
+	plugin: unknown,
+	pluginPath: string,
+): asserts plugin is PluginModule {
+	if (!isObject(plugin)) {
+		throw new Error(`Invalid plugin module: ${pluginPath}`);
+	}
+	if (typeof plugin.name !== "string" || !plugin.name) {
+		throw new Error(`Invalid plugin name: ${pluginPath}`);
+	}
+	if (!isObject(plugin.manifest)) {
+		throw new Error(`Invalid plugin manifest: ${pluginPath}`);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "providerIds") &&
+		!hasValidStringArray(plugin.manifest.providerIds)
+	) {
+		throw new Error(`Invalid plugin manifest.providerIds: ${pluginPath}`);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "modelIds") &&
+		!hasValidStringArray(plugin.manifest.modelIds)
+	) {
+		throw new Error(`Invalid plugin manifest.modelIds: ${pluginPath}`);
+	}
+}
+
+function assertValidPluginSetupCtx(
+	ctx: unknown,
+): asserts ctx is PluginSetupCtx {
+	if (!isObject(ctx)) {
+		throw new Error("Plugin setup context must be an object");
+	}
+	if (ctx.session !== undefined && !isObject(ctx.session)) {
+		throw new Error("Plugin setup context session must be an object");
+	}
+	if (ctx.client !== undefined && !isObject(ctx.client)) {
+		throw new Error("Plugin setup context client must be an object");
+	}
+	if (ctx.user !== undefined && !isObject(ctx.user)) {
+		throw new Error("Plugin setup context user must be an object");
+	}
+	if (ctx.workspaceInfo !== undefined && !isObject(ctx.workspaceInfo)) {
+		throw new Error("Plugin setup context workspaceInfo must be an object");
+	}
+	if (ctx.automation !== undefined && !isObject(ctx.automation)) {
+		throw new Error("Plugin setup context automation must be an object");
+	}
+	if (
+		ctx.automation !== undefined &&
+		typeof ctx.automation.ingestEvent !== "function"
+	) {
+		throw new Error(
+			"Plugin setup context automation.ingestEvent must be a function",
+		);
+	}
+	if (ctx.logger !== undefined && !isObject(ctx.logger)) {
+		throw new Error("Plugin setup context logger must be an object");
+	}
+}
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+let pluginCounter = 0;
+const pluginState = new Map<string, PluginState>();
+const contributionCounters = new Map<string, number>();
+
+// ---------------------------------------------------------------------------
+// IPC helpers
+// ---------------------------------------------------------------------------
+
+function toErrorPayload(error: unknown): { message: string; stack?: string } {
+	const message = error instanceof Error ? error.message : String(error);
+	const stack = error instanceof Error ? error.stack : undefined;
+	return { message, stack };
+}
+
+function sendResponse(
+	id: string,
+	ok: boolean,
+	result: unknown,
+	error?: { message: string; stack?: string },
+): void {
+	if (!process.send) return;
+	process.send({ type: "response", id, ok, result, error });
+}
+
+function emitEvent(name: string, payload?: unknown): void {
+	if (!process.send) return;
+	process.send({ type: "event", name, payload });
+}
+
+// Expose event emitter to plugins.
+(globalThis as Record<string, unknown>).__clinePluginHost = { emitEvent };
+
+/**
+ * Session workspace env — populated by `initialize()` and available to any
+ * plugin code that executes before the setup hook, or cannot use hook context.
+ * Prefer using PluginSetupCtx from the setup function when possible.
+ */
+(globalThis as Record<string, unknown>).__clineSessionEnv = {
+	cwd: undefined as string | undefined,
+	workspaceInfo: undefined as unknown,
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function sanitizeObject(value: unknown): Record<string, unknown> {
+	if (!value || typeof value !== "object") return {};
+	return value as Record<string, unknown>;
+}
+
+function sanitizeLogMetadata(
+	value: unknown,
+): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object") {
+		return undefined;
+	}
+	const metadata = { ...(value as Record<string, unknown>) };
+	if (metadata.error instanceof Error) {
+		metadata.error = {
+			name: metadata.error.name,
+			message: metadata.error.message,
+			stack: metadata.error.stack,
+		};
+	}
+	return metadata;
+}
+
+function createPluginLogger(
+	pluginName: string,
+): NonNullable<PluginSetupCtx["logger"]> {
+	const emitLog = (
+		level: "debug" | "log" | "error",
+		message: string,
+		metadata?: Record<string, unknown>,
+	) => {
+		emitEvent("plugin_log", {
+			level,
+			pluginName,
+			message,
+			metadata: sanitizeLogMetadata(metadata),
+		});
+	};
+	return {
+		debug: (message, metadata) => emitLog("debug", message, metadata),
+		log: (message, metadata) => emitLog("log", message, metadata),
+		error: (message, metadata) => emitLog("error", message, metadata),
+	};
+}
+
+function makeId(pluginId: string, prefix: string): string {
+	const key = `${pluginId}:${prefix}`;
+	const next = (contributionCounters.get(key) ?? 0) + 1;
+	contributionCounters.set(key, next);
+	return `${pluginId}_${prefix}_${next}`;
+}
+
+function normalizeAutomationEventType(
+	eventType: PluginAutomationEventType,
+): PluginAutomationEventType {
+	const normalizedEventType =
+		typeof eventType.eventType === "string" ? eventType.eventType.trim() : "";
+	const source =
+		typeof eventType.source === "string" ? eventType.source.trim() : "";
+	if (!normalizedEventType) {
+		throw new Error("Automation event type contribution requires eventType");
+	}
+	if (!source) {
+		throw new Error("Automation event type contribution requires source");
+	}
+	return {
+		...eventType,
+		eventType: normalizedEventType,
+		source,
+		examples: eventType.examples ? [...eventType.examples] : undefined,
+		metadata: eventType.metadata
+			? sanitizeObject(eventType.metadata)
+			: undefined,
+	};
+}
+
+function getPlugin(pluginId: string): PluginState {
+	const state = pluginState.get(pluginId);
+	if (!state) {
+		throw new Error(`Unknown sandbox plugin id: ${pluginId}`);
+	}
+	return state;
+}
+
+async function loadPluginDescriptor(args: {
+	pluginPath: string;
+	pluginId: string;
+	exportName: string;
+	targeting: PluginTargeting;
+	setupCtxBase: Pick<
+		PluginSetupCtx,
+		"session" | "client" | "user" | "workspaceInfo"
+	>;
+	loggerEnabled?: boolean;
+}): Promise<LoadedPluginResult> {
+	let plugin: PluginModule | undefined;
+	try {
+		const moduleExports = await importPluginModule(args.pluginPath);
+		plugin = (moduleExports.default ??
+			moduleExports[args.exportName]) as unknown as PluginModule;
+		assertValidPluginModule(plugin, args.pluginPath);
+		plugin.manifest = normalizePluginManifest(plugin.manifest);
+		if (!matchesPluginManifestTargeting(plugin.manifest, args.targeting)) {
+			return { type: "skipped" };
+		}
+
+		const contributions: PluginDescriptor["contributions"] = {
+			tools: [],
+			commands: [],
+			rules: [],
+			messageBuilders: [],
+			providers: [],
+			automationEventTypes: [],
+			mcpServers: [],
+			shortcuts: [],
+			flags: [],
+		};
+		const handlers: PluginState["handlers"] = {
+			tools: new Map(),
+			commands: new Map(),
+			rules: new Map(),
+			messageBuilders: new Map(),
+		};
+
+		const api: PluginApi = {
+			registerTool: (tool) => {
+				const id = makeId(args.pluginId, "tool");
+				handlers.tools.set(id, tool.execute);
+				contributions.tools.push({
+					id,
+					name: tool.name,
+					description: tool.description,
+					inputSchema: tool.inputSchema,
+					timeoutMs: tool.timeoutMs,
+					retryable: tool.retryable,
+				});
+			},
+			registerCommand: (command) => {
+				const id = makeId(args.pluginId, "command");
+				if (typeof command.handler === "function") {
+					handlers.commands.set(id, command.handler);
+				}
+				contributions.commands.push({
+					id,
+					name: command.name,
+					description: command.description,
+				});
+			},
+			registerRule: (rule) => {
+				const id = makeId(args.pluginId, "rule");
+				if (typeof rule.content === "function") {
+					handlers.rules.set(id, rule.content);
+					contributions.rules.push({
+						id,
+						ruleId: rule.id,
+						source: rule.source,
+						hasContentHandler: true,
+					});
+					return;
+				}
+				contributions.rules.push({
+					id,
+					ruleId: rule.id,
+					content: rule.content,
+					source: rule.source,
+				});
+			},
+			registerMessageBuilder: (builder) => {
+				const id = makeId(args.pluginId, "builder");
+				handlers.messageBuilders.set(id, builder.build);
+				contributions.messageBuilders.push({ id, name: builder.name });
+			},
+			registerProvider: (provider) => {
+				contributions.providers.push({
+					id: makeId(args.pluginId, "provider"),
+					name: provider.name,
+					description: provider.description,
+					metadata: sanitizeObject(provider.metadata),
+				});
+			},
+			registerAutomationEventType: (eventType) => {
+				contributions.automationEventTypes.push({
+					id: makeId(args.pluginId, "automation_event"),
+					...normalizeAutomationEventType(eventType),
+				});
+			},
+			registerMcpServer: (server) => {
+				contributions.mcpServers.push(server);
+			},
+		};
+
+		if (typeof plugin.setup === "function") {
+			try {
+				const setupCtx = {
+					...args.setupCtxBase,
+					...(args.loggerEnabled
+						? { logger: createPluginLogger(plugin.name) }
+						: {}),
+					...(plugin.manifest.capabilities.includes("automationEvents")
+						? {
+								automation: {
+									ingestEvent: (event: AutomationEventEnvelope) => {
+										emitEvent("automation_event", event);
+									},
+								},
+							}
+						: {}),
+				};
+				assertValidPluginSetupCtx(setupCtx);
+				await plugin.setup(api, setupCtx);
+			} catch (error) {
+				return {
+					type: "failure",
+					failure: {
+						pluginPath: args.pluginPath,
+						pluginName: plugin.name,
+						phase: "setup",
+						message: error instanceof Error ? error.message : String(error),
+						stack: error instanceof Error ? error.stack : undefined,
+					},
+				};
+			}
+		}
+
+		return {
+			type: "loaded",
+			state: { plugin, handlers },
+			descriptor: {
+				pluginId: args.pluginId,
+				pluginPath: args.pluginPath,
+				name: plugin.name,
+				manifest: plugin.manifest,
+				hooks: plugin.hooks
+					? Object.entries(plugin.hooks)
+							.filter(([, hook]) => typeof hook === "function")
+							.map(([name]) => name)
+					: undefined,
+				contributions,
+			},
+		};
+	} catch (error) {
+		return {
+			type: "failure",
+			failure: {
+				pluginPath: args.pluginPath,
+				pluginName: plugin?.name,
+				phase: "load",
+				message: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+			},
+		};
+	}
+}
+
+// ---------------------------------------------------------------------------
+// RPC methods
+// ---------------------------------------------------------------------------
+
+async function initialize(args: {
+	pluginPaths?: string[];
+	exportName?: string;
+	providerId?: string;
+	modelId?: string;
+	cwd?: string;
+	session?: unknown;
+	client?: unknown;
+	user?: unknown;
+	workspaceInfo?: unknown;
+	loggerEnabled?: boolean;
+}): Promise<InitializeResult> {
+	pluginState.clear();
+	pluginCounter = 0;
+	contributionCounters.clear();
+
+	// Apply the session's working directory so that process.cwd() and relative
+	// path resolution inside plugins reflect the correct workspace, not the
+	// host process's cwd (which may differ when --cwd was used without calling
+	// process.chdir() on the host side).
+	if (args.cwd) {
+		try {
+			process.chdir(args.cwd);
+		} catch {
+			// Ignore — best-effort; path may not exist in unusual environments.
+		}
+	}
+
+	// Keep the global escape-hatch in sync with the active session.
+	const sessionEnv = (globalThis as Record<string, unknown>)
+		.__clineSessionEnv as Record<string, unknown>;
+	if (sessionEnv) {
+		sessionEnv.cwd = args.cwd;
+		sessionEnv.workspaceInfo = args.workspaceInfo;
+	}
+
+	const descriptors: PluginDescriptor[] = [];
+	const failures: PluginInitializationFailure[] = [];
+	const warnings: PluginInitializationWarning[] = [];
+	const exportName = args.exportName || "plugin";
+	const pluginIndexByName = new Map<string, number>();
+	const targeting: PluginTargeting = {
+		providerId: args.providerId,
+		modelId: args.modelId,
+	};
+	const setupCtxBase = {
+		session: args.session,
+		client: args.client,
+		user: args.user,
+		workspaceInfo: args.workspaceInfo,
+	};
+
+	const loadResults = await Promise.all(
+		(args.pluginPaths || []).map((pluginPath) => {
+			const pluginId = `plugin_${++pluginCounter}`;
+			return loadPluginDescriptor({
+				pluginPath,
+				pluginId,
+				exportName,
+				targeting,
+				setupCtxBase,
+				loggerEnabled: args.loggerEnabled,
+			});
+		}),
+	);
+
+	for (const result of loadResults) {
+		if (result.type === "skipped") {
+			continue;
+		}
+		if (result.type === "failure") {
+			failures.push(result.failure);
+			continue;
+		}
+
+		const { descriptor, state } = result;
+		const previousIndex = pluginIndexByName.get(descriptor.name);
+		if (previousIndex !== undefined) {
+			const previous = descriptors[previousIndex];
+			if (!previous) {
+				pluginIndexByName.delete(descriptor.name);
+			} else {
+				warnings.push({
+					type: "duplicate_plugin_override",
+					pluginName: descriptor.name,
+					pluginPath: descriptor.pluginPath,
+					overriddenPluginPath: previous.pluginPath,
+					message: `Plugin "${descriptor.name}" from ${descriptor.pluginPath} overrides ${previous.pluginPath}`,
+				});
+				pluginState.delete(previous.pluginId);
+				descriptors.splice(previousIndex, 1);
+				pluginIndexByName.clear();
+				for (const [index, descriptor] of descriptors.entries()) {
+					pluginIndexByName.set(descriptor.name, index);
+				}
+			}
+		}
+
+		pluginState.set(descriptor.pluginId, state);
+		pluginIndexByName.set(descriptor.name, descriptors.length);
+		descriptors.push(descriptor);
+	}
+
+	return { plugins: descriptors, failures, warnings };
+}
+
+async function invokeHook(args: {
+	pluginId: string;
+	hookName: string;
+	payload: unknown;
+}): Promise<unknown> {
+	const state = getPlugin(args.pluginId);
+	const handler = state.plugin.hooks?.[args.hookName];
+	if (typeof handler !== "function") {
+		return undefined;
+	}
+	return await (handler as (payload: unknown) => Promise<unknown>)(
+		args.payload,
+	);
+}
+
+async function executeTool(args: {
+	pluginId: string;
+	contributionId: string;
+	input: unknown;
+	context: unknown;
+}): Promise<unknown> {
+	const state = getPlugin(args.pluginId);
+	const handler = state.handlers.tools.get(args.contributionId);
+	if (typeof handler !== "function") {
+		throw new Error("Unknown sandbox tool contribution");
+	}
+	return await handler(args.input, args.context);
+}
+
+async function executeCommand(args: {
+	pluginId: string;
+	contributionId: string;
+	input: string;
+}): Promise<PluginCommandResult> {
+	const state = getPlugin(args.pluginId);
+	const handler = state.handlers.commands.get(args.contributionId);
+	if (typeof handler !== "function") {
+		return "";
+	}
+	return await handler(args.input);
+}
+
+async function buildMessages(args: {
+	pluginId: string;
+	contributionId: string;
+	messages: unknown[];
+}): Promise<unknown[]> {
+	const state = getPlugin(args.pluginId);
+	const handler = state.handlers.messageBuilders.get(args.contributionId);
+	if (typeof handler !== "function") {
+		return [];
+	}
+	return await handler(args.messages);
+}
+
+async function resolveRuleContent(args: {
+	pluginId: string;
+	contributionId: string;
+}): Promise<string> {
+	const state = getPlugin(args.pluginId);
+	const handler = state.handlers.rules.get(args.contributionId);
+	if (typeof handler !== "function") {
+		return "";
+	}
+	return await handler();
+}
+
+// ---------------------------------------------------------------------------
+// Message dispatch
+// ---------------------------------------------------------------------------
+
+const methods: Record<string, (args: never) => Promise<unknown>> = {
+	initialize,
+	invokeHook,
+	executeTool,
+	executeCommand,
+	buildMessages,
+	resolveRuleContent,
+};
+
+process.on(
+	"message",
+	async (message: {
+		type: string;
+		id: string;
+		method: string;
+		args?: unknown;
+	}) => {
+		if (!message || message.type !== "call") {
+			return;
+		}
+		const method = methods[message.method];
+		if (!method) {
+			sendResponse(message.id, false, undefined, {
+				message: `Unknown method: ${String(message.method)}`,
+			});
+			return;
+		}
+		try {
+			const result = await method((message.args || {}) as never);
+			sendResponse(message.id, true, result);
+		} catch (error) {
+			sendResponse(message.id, false, undefined, toErrorPayload(error));
+		}
+	},
+);
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-sandbox.test.ts b/sdk/packages/core/src/extensions/plugin/plugin-sandbox.test.ts
new file mode 100644
index 0000000..5ab7415
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-sandbox.test.ts
@@ -0,0 +1,811 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type {
+	AgentConfig,
+	AgentExtensionMessageBuilder,
+	AgentExtensionRule,
+	AgentTool,
+	AgentToolContext,
+	Message,
+} from "@cline/shared";
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	vi,
+} from "vitest";
+import { loadSandboxedPlugins } from "./plugin-sandbox";
+
+function createApiCapture() {
+	const tools: AgentTool[] = [];
+	const rules: AgentExtensionRule[] = [];
+	const messageBuilders: AgentExtensionMessageBuilder<Message[]>[] = [];
+	const automationEventTypes: unknown[] = [];
+	const api = {
+		registerTool: (tool: AgentTool) => tools.push(tool),
+		registerCommand: () => {},
+		registerMessageBuilder: (
+			builder: AgentExtensionMessageBuilder<Message[]>,
+		) => messageBuilders.push(builder),
+		registerRule: (rule: AgentExtensionRule) => rules.push(rule),
+		registerProvider: () => {},
+		registerAutomationEventType: (eventType: unknown) =>
+			automationEventTypes.push(eventType),
+		registerMcpServer: () => {},
+	};
+	return { tools, rules, messageBuilders, automationEventTypes, api };
+}
+
+function makeSnapshot() {
+	return {
+		agentId: "agent-1",
+		status: "running" as const,
+		iteration: 1,
+		messages: [],
+		pendingToolCalls: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+		},
+	};
+}
+
+describe("plugin-sandbox", () => {
+	let dir = "";
+	let sharedSandbox:
+		| Awaited<ReturnType<typeof loadSandboxedPlugins>>
+		| undefined;
+	let sharedExtensions = new Map<
+		string,
+		NonNullable<AgentConfig["extensions"]>[number]
+	>();
+	const forwardedEvents: Array<{ name: string; payload?: unknown }> = [];
+
+	// Allow generous time for jiti transpilation of multiple TS plugins in CI.
+	beforeAll(async () => {
+		dir = await mkdtemp(join(tmpdir(), "core-plugin-sandbox-"));
+
+		await writeFile(
+			join(dir, "plugin.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-test',",
+				"  manifest: { capabilities: ['hooks','tools'] },",
+				"  setup(api) {",
+				"    api.registerTool({",
+				"      name: 'sandbox_echo',",
+				"      description: 'echo',",
+				"      inputSchema: { type: 'object', properties: { value: { type: 'string' } }, required: ['value'] },",
+				"      execute: async (input) => ({ echoed: input.value }),",
+				"    });",
+				"  },",
+				"  hooks: { beforeRun() { return { reason: 'sandbox-before-run' }; } },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-events.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-events',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup(api) {",
+				"    api.registerTool({",
+				"      name: 'emit_event',",
+				"      description: 'emit host event',",
+				"      inputSchema: { type: 'object', properties: { value: { type: 'string' } }, required: ['value'] },",
+				"      execute: async (input) => {",
+				"        globalThis.__clinePluginHost?.emitEvent?.('test_event', { value: input.value });",
+				"        return { ok: true };",
+				"      },",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-run-end.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-run-end',",
+				"  manifest: { capabilities: ['hooks'] },",
+				"  hooks: { afterRun(ctx) {",
+				"    globalThis.__clinePluginHost?.emitEvent?.('run_end_hook', {",
+				"      finishReason: ctx.result?.status,",
+				"      iterations: ctx.result?.iterations,",
+				"    });",
+				"  } },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-message-builder.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-message-builder',",
+				"  manifest: { capabilities: ['messageBuilders'] },",
+				"  setup(api) {",
+				"    api.registerMessageBuilder({",
+				"      name: 'append-system-context',",
+				"      build: async (messages) => messages.concat([{ role: 'user', content: [{ type: 'text', text: 'from sandbox builder' }] }]),",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-rules.mjs"),
+			[
+				"let resolveCount = 0;",
+				"export default {",
+				"  name: 'sandbox-rules',",
+				"  manifest: { capabilities: ['rules'] },",
+				"  setup(api) {",
+				"    api.registerRule({",
+				"      id: 'sandbox-rules:static',",
+				"      source: 'sandbox-rules',",
+				"      content: 'Static sandbox rule',",
+				"    });",
+				"    api.registerRule({",
+				"      id: 'sandbox-rules:lazy',",
+				"      source: 'sandbox-rules',",
+				"      content: async () => {",
+				"        resolveCount += 1;",
+				"        return 'Lazy sandbox rule ' + resolveCount;",
+				"      },",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-automation-events.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-automation-events',",
+				"  manifest: { capabilities: ['automationEvents','tools'] },",
+				"  setup(api, ctx) {",
+				"    api.registerAutomationEventType({",
+				"      eventType: 'local.plugin_event',",
+				"      source: 'local-plugin',",
+				"      description: 'Local event emitted by a sandbox plugin',",
+				"      attributesSchema: { type: 'object', properties: { topic: { type: 'string' } } },",
+				"    });",
+				"    api.registerTool({",
+				"      name: 'emit_automation_event',",
+				"      description: 'emit automation event',",
+				"      inputSchema: { type: 'object', properties: { topic: { type: 'string' } }, required: ['topic'] },",
+				"      execute: async (input) => {",
+				"        await ctx.automation?.ingestEvent?.({",
+				"          eventId: 'plugin-' + input.topic,",
+				"          eventType: 'local.plugin_event',",
+				"          source: 'local-plugin',",
+				"          subject: input.topic,",
+				"          occurredAt: '2026-04-24T10:00:00.000Z',",
+				"          attributes: { topic: input.topic },",
+				"        });",
+				"        return { ok: true };",
+				"      },",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-ts.ts"),
+			[
+				"const TOOL_NAME: string = 'sandbox_ts_echo';",
+				"export default {",
+				"  name: 'sandbox-ts',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup(api) {",
+				"    api.registerTool({",
+				"      name: TOOL_NAME,",
+				"      description: 'echo',",
+				"      inputSchema: { type: 'object', properties: { value: { type: 'string' } }, required: ['value'] },",
+				"      execute: async (input) => ({ echoed: input.value }),",
+				"    });",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const localDepDir = join(dir, "node_modules", "sandbox-local-dep");
+		await mkdir(localDepDir, { recursive: true });
+		await writeFile(
+			join(localDepDir, "package.json"),
+			JSON.stringify({
+				name: "sandbox-local-dep",
+				type: "module",
+				exports: "./index.js",
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(localDepDir, "index.js"),
+			"export const depName = 'sandbox-local-dep';\n",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-dep.ts"),
+			[
+				"import { depName } from 'sandbox-local-dep';",
+				"export default {",
+				"  name: depName,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		const sdkDepDir = join(dir, "node_modules", "@cline", "shared");
+		await mkdir(sdkDepDir, { recursive: true });
+		await writeFile(
+			join(sdkDepDir, "package.json"),
+			JSON.stringify({
+				name: "@cline/shared",
+				type: "module",
+				exports: "./index.js",
+			}),
+			"utf8",
+		);
+		await writeFile(
+			join(sdkDepDir, "index.js"),
+			"export const sdkMarker = 'sandbox-plugin-installed-sdk';\n",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-sdk.ts"),
+			[
+				"import { sdkMarker } from '@cline/shared';",
+				"export default {",
+				"  name: sdkMarker,",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-host-dep.ts"),
+			[
+				"import { resolveClineDataDir } from '@cline/shared/storage';",
+				"import YAML from 'yaml';",
+				"export default {",
+				"  name: YAML.stringify({ host: !!resolveClineDataDir() }).trim(),",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-create-tool.ts"),
+			[
+				"import { createTool } from '@cline/agents';",
+				"export default {",
+				"  name: 'sandbox-create-tool',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup(api) {",
+				"    api.registerTool(createTool({",
+				"      name: 'created_tool',",
+				"      description: 'created via agents export',",
+				"      inputSchema: { type: 'object', properties: { value: { type: 'string' } }, required: ['value'] },",
+				"      execute: async (input) => ({ echoed: input.value }),",
+				"    }));",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-broken-setup.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-broken-setup',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  async setup() {",
+				"    throw new Error('broken setup');",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-duplicate-a.mjs"),
+			"export default { name: 'sandbox-duplicate', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-duplicate-b.mjs"),
+			"export default { name: 'sandbox-duplicate', manifest: { capabilities: ['commands'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-targeted.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-targeted',",
+				"  manifest: { capabilities: ['tools'], providerIds: ['openai'], modelIds: ['gpt-5.4'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		sharedSandbox = await loadSandboxedPlugins({
+			pluginPaths: [
+				join(dir, "plugin.mjs"),
+				join(dir, "plugin-events.mjs"),
+				join(dir, "plugin-run-end.mjs"),
+				join(dir, "plugin-automation-events.mjs"),
+				join(dir, "plugin-message-builder.mjs"),
+				join(dir, "plugin-rules.mjs"),
+				join(dir, "plugin-ts.ts"),
+				join(dir, "plugin-dep.ts"),
+				join(dir, "plugin-sdk.ts"),
+				join(dir, "plugin-host-dep.ts"),
+				join(dir, "plugin-create-tool.ts"),
+			],
+			// CI environments are significantly slower for jiti transpilation;
+			// the default 4 000 ms is too tight for 7 plugins.
+			importTimeoutMs: 30_000,
+			onEvent: (event) => {
+				forwardedEvents.push(event);
+			},
+		});
+		sharedExtensions = new Map(
+			(sharedSandbox.extensions ?? []).map((extension) => [
+				extension.name,
+				extension,
+			]),
+		);
+	}, 60_000);
+
+	beforeEach(() => {
+		forwardedEvents.length = 0;
+	});
+
+	afterAll(async () => {
+		await sharedSandbox?.shutdown();
+		if (dir) {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("runs plugin hooks and tool contributions in sandbox process", async () => {
+		expect(sharedSandbox?.extensions).toBeDefined();
+		const extension = sharedExtensions.get("sandbox-test");
+		expect(extension?.name).toBe("sandbox-test");
+		const control = await extension?.hooks?.beforeRun?.({
+			snapshot: makeSnapshot(),
+		});
+		expect(control?.reason).toBe("sandbox-before-run");
+
+		const { tools, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+		expect(tools.map((tool) => tool.name)).toContain("sandbox_echo");
+		const echoTool = tools.find((tool) => tool.name === "sandbox_echo");
+		expect(echoTool).toBeDefined();
+		const result = await echoTool?.execute({ value: "ok" }, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		} as AgentToolContext);
+		expect(result).toEqual({ echoed: "ok" });
+	});
+
+	it("enforces hook timeout and cancels sandbox process", async () => {
+		const timeoutDir = await mkdtemp(
+			join(tmpdir(), "core-plugin-sandbox-timeout-"),
+		);
+		try {
+			const pluginPath = join(timeoutDir, "plugin-timeout.mjs");
+			await writeFile(
+				pluginPath,
+				[
+					"export default {",
+					"  name: 'sandbox-timeout',",
+					"  manifest: { capabilities: ['hooks'] },",
+					"  hooks: { beforeRun() { return new Promise(() => {}); } },",
+					"};",
+				].join("\n"),
+				"utf8",
+			);
+
+			const sandboxed = await loadSandboxedPlugins({
+				pluginPaths: [pluginPath],
+				hookTimeoutMs: 50,
+			});
+			const extension = sandboxed.extensions?.[0];
+			await expect(
+				extension?.hooks?.beforeRun?.({ snapshot: makeSnapshot() }),
+			).rejects.toThrow(/timed out/i);
+			await sandboxed.shutdown();
+		} finally {
+			await rm(timeoutDir, { recursive: true, force: true });
+		}
+	});
+
+	it("respects CLINE_PLUGIN_IMPORT_TIMEOUT_MS env var when options.importTimeoutMs is unset", async () => {
+		const envDir = await mkdtemp(
+			join(tmpdir(), "core-plugin-sandbox-import-env-"),
+		);
+		try {
+			const pluginPath = join(envDir, "plugin-import-hang.mjs");
+			// Top-level await that never resolves — module import never
+			// completes, so the initialize call must hit the timeout.
+			await writeFile(
+				pluginPath,
+				[
+					"await new Promise(() => {});",
+					"export default {",
+					"  name: 'sandbox-import-hang',",
+					"  manifest: { capabilities: ['tools'] },",
+					"};",
+				].join("\n"),
+				"utf8",
+			);
+
+			// Set env override well below the 4000 ms hardcoded default.
+			// If the env var isn't read, this test would block for ~4 s and
+			// the per-test timeout (3000 ms below) would fail it.
+			vi.stubEnv("CLINE_PLUGIN_IMPORT_TIMEOUT_MS", "150");
+			await expect(
+				loadSandboxedPlugins({ pluginPaths: [pluginPath] }),
+			).rejects.toThrow(/timed out/i);
+		} finally {
+			vi.unstubAllEnvs();
+			await rm(envDir, { recursive: true, force: true });
+		}
+	}, 3000);
+
+	it("forwards sandbox plugin events to the host", async () => {
+		const extension = sharedExtensions.get("sandbox-events");
+		const { tools, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+		const tool = tools.find((entry) => entry.name === "emit_event");
+		await tool?.execute({ value: "hello" }, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		} as AgentToolContext);
+		expect(forwardedEvents).toEqual([
+			{
+				name: "test_event",
+				payload: { value: "hello" },
+			},
+		]);
+	});
+
+	it("resolves sandbox bootstrap from the npm wrapper platform package", async () => {
+		const previousWrapperPath = process.env.CLINE_WRAPPER_PATH;
+		const wrapperRoot = await mkdtemp(
+			join(tmpdir(), "core-plugin-sandbox-wrapper-"),
+		);
+		const platform =
+			process.platform === "win32" ? "windows" : process.platform;
+		const packageRoot = join(
+			wrapperRoot,
+			"node_modules",
+			"@cline",
+			`cli-${platform}-${process.arch}`,
+		);
+		const wrapperBinDir = join(wrapperRoot, "bin");
+		const bootstrapPath = join(
+			packageRoot,
+			"extensions",
+			"plugin-sandbox-bootstrap.js",
+		);
+		const wrapperPath = join(wrapperBinDir, "cline");
+		const events: Array<{ name: string; payload?: unknown }> = [];
+
+		try {
+			await mkdir(join(packageRoot, "extensions"), { recursive: true });
+			await mkdir(wrapperBinDir, { recursive: true });
+			await writeFile(wrapperPath, "#!/usr/bin/env node\n", "utf8");
+			await writeFile(
+				join(packageRoot, "package.json"),
+				JSON.stringify({
+					name: `@cline/cli-${platform}-${process.arch}`,
+					version: "0.0.0-test",
+					type: "module",
+				}),
+				"utf8",
+			);
+			await writeFile(
+				bootstrapPath,
+				[
+					"process.on('message', (message) => {",
+					"  if (!message || message.type !== 'call') return;",
+					"  if (message.method !== 'initialize') throw new Error('Unexpected method: ' + message.method);",
+					"  process.send?.({ type: 'event', name: 'wrapper_bootstrap_selected', payload: { ok: true } });",
+					"  process.send?.({",
+					"    type: 'response',",
+					"    id: message.id,",
+					"    ok: true,",
+					"    result: {",
+					"      plugins: [{",
+					"        pluginId: 'plugin_1',",
+					"        pluginPath: 'wrapper-bootstrap',",
+					"        name: 'wrapper-bootstrap',",
+					"        manifest: { capabilities: ['tools'] },",
+					"        contributions: { tools: [], commands: [], messageBuilders: [], providers: [], automationEventTypes: [] },",
+					"      }],",
+					"      failures: [],",
+					"      warnings: [],",
+					"    },",
+					"  });",
+					"});",
+				].join("\n"),
+				"utf8",
+			);
+
+			process.env.CLINE_WRAPPER_PATH = wrapperPath;
+			vi.resetModules();
+			const { loadSandboxedPlugins: loadSandboxedPluginsFromWrapper } =
+				await import("./plugin-sandbox");
+			const sandboxed = await loadSandboxedPluginsFromWrapper({
+				pluginPaths: [join(wrapperRoot, "unused-plugin.mjs")],
+				onEvent: (event) => events.push(event),
+			});
+
+			try {
+				expect(
+					sandboxed.extensions?.map((extension) => extension.name),
+				).toEqual(["wrapper-bootstrap"]);
+				expect(events).toContainEqual({
+					name: "wrapper_bootstrap_selected",
+					payload: { ok: true },
+				});
+			} finally {
+				await sandboxed.shutdown();
+			}
+		} finally {
+			if (previousWrapperPath === undefined) {
+				delete process.env.CLINE_WRAPPER_PATH;
+			} else {
+				process.env.CLINE_WRAPPER_PATH = previousWrapperPath;
+			}
+			vi.resetModules();
+			await rm(wrapperRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("registers automation event types and forwards sandbox automation events", async () => {
+		const extension = sharedExtensions.get("sandbox-automation-events");
+		const { tools, automationEventTypes, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+		expect(automationEventTypes).toEqual([
+			expect.objectContaining({
+				eventType: "local.plugin_event",
+				source: "local-plugin",
+			}),
+		]);
+
+		const tool = tools.find((entry) => entry.name === "emit_automation_event");
+		await tool?.execute({ topic: "cron-feature-2" }, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		} as AgentToolContext);
+		expect(forwardedEvents).toEqual([
+			{
+				name: "automation_event",
+				payload: expect.objectContaining({
+					eventId: "plugin-cron-feature-2",
+					eventType: "local.plugin_event",
+					source: "local-plugin",
+				}),
+			},
+		]);
+	});
+
+	it("runs run_end hooks in sandbox process", async () => {
+		const extension = sharedExtensions.get("sandbox-run-end");
+		expect(typeof extension?.hooks?.afterRun).toBe("function");
+		await extension?.hooks?.afterRun?.({
+			snapshot: makeSnapshot(),
+			result: {
+				agentId: "agent-1",
+				runId: "run-1",
+				status: "completed",
+				iterations: 2,
+				outputText: "done",
+				messages: [],
+				usage: {
+					inputTokens: 1,
+					outputTokens: 2,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+				},
+			},
+		});
+		expect(forwardedEvents).toEqual([
+			{
+				name: "run_end_hook",
+				payload: { finishReason: "completed", iterations: 2 },
+			},
+		]);
+	});
+
+	it("runs message builders in the sandbox process", async () => {
+		const extension = sharedExtensions.get("sandbox-message-builder");
+		const { messageBuilders, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+		expect(messageBuilders).toHaveLength(1);
+		const result = await messageBuilders[0]?.build([
+			{ role: "user", content: [{ type: "text", text: "original" }] },
+		]);
+		expect(result).toEqual([
+			{ role: "user", content: [{ type: "text", text: "original" }] },
+			{
+				role: "user",
+				content: [{ type: "text", text: "from sandbox builder" }],
+			},
+		]);
+	});
+
+	it("registers prompt rules from sandbox plugins", async () => {
+		const extension = sharedExtensions.get("sandbox-rules");
+		const { rules, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+
+		expect(rules).toHaveLength(2);
+		expect(rules[0]).toEqual({
+			id: "sandbox-rules:static",
+			source: "sandbox-rules",
+			content: "Static sandbox rule",
+		});
+		expect(rules[1]?.id).toBe("sandbox-rules:lazy");
+		expect(rules[1]?.source).toBe("sandbox-rules");
+		expect(typeof rules[1]?.content).toBe("function");
+		if (typeof rules[1]?.content !== "function") {
+			throw new Error("Expected lazy sandbox rule content handler");
+		}
+		const content = await rules[1].content();
+		expect(content).toBe("Lazy sandbox rule 1");
+	});
+
+	it("loads TypeScript plugins in the sandbox process", async () => {
+		const extension = sharedExtensions.get("sandbox-ts");
+		expect(extension?.name).toBe("sandbox-ts");
+		const { tools, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+		const tool = tools.find((entry) => entry.name === "sandbox_ts_echo");
+		expect(tool).toBeDefined();
+		const result = await tool?.execute({ value: "ok" }, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		} as AgentToolContext);
+		expect(result).toEqual({ echoed: "ok" });
+	});
+
+	it("continues loading remaining sandbox plugins when one setup fails", async () => {
+		const sandboxed = await loadSandboxedPlugins({
+			pluginPaths: [
+				join(dir, "plugin.mjs"),
+				join(dir, "plugin-broken-setup.mjs"),
+				join(dir, "plugin-events.mjs"),
+			],
+		});
+
+		try {
+			expect(sandboxed.extensions?.map((extension) => extension.name)).toEqual([
+				"sandbox-test",
+				"sandbox-events",
+			]);
+			expect(sandboxed.failures).toHaveLength(1);
+			expect(sandboxed.failures[0]?.pluginName).toBe("sandbox-broken-setup");
+			expect(sandboxed.failures[0]?.phase).toBe("setup");
+		} finally {
+			await sandboxed.shutdown();
+		}
+	});
+
+	it("keeps the later duplicate sandbox plugin and reports the override", async () => {
+		const sandboxed = await loadSandboxedPlugins({
+			pluginPaths: [
+				join(dir, "plugin-duplicate-a.mjs"),
+				join(dir, "plugin-duplicate-b.mjs"),
+			],
+		});
+
+		try {
+			expect(sandboxed.extensions).toHaveLength(1);
+			expect(sandboxed.extensions?.[0]?.name).toBe("sandbox-duplicate");
+			expect(sandboxed.extensions?.[0]?.manifest.capabilities).toEqual([
+				"commands",
+			]);
+			expect(sandboxed.warnings).toHaveLength(1);
+			expect(sandboxed.warnings[0]?.overriddenPluginPath).toBe(
+				join(dir, "plugin-duplicate-a.mjs"),
+			);
+		} finally {
+			await sandboxed.shutdown();
+		}
+	});
+
+	it("resolves plugin-local dependencies in the sandbox process", async () => {
+		expect(sharedExtensions.get("sandbox-local-dep")?.name).toBe(
+			"sandbox-local-dep",
+		);
+	});
+
+	it("prefers plugin-installed SDK packages in the sandbox process", async () => {
+		expect(sharedExtensions.get("sandbox-plugin-installed-sdk")?.name).toBe(
+			"sandbox-plugin-installed-sdk",
+		);
+	});
+
+	it("allows standalone file plugins to use host runtime dependencies in the sandbox", async () => {
+		expect(sharedExtensions.get("host: true")?.name).toBe("host: true");
+	});
+
+	it("supports createTool through the agents package export in the sandbox", async () => {
+		const extension = sharedExtensions.get("sandbox-create-tool");
+		const { tools, api } = createApiCapture();
+		await extension?.setup?.(api, {});
+		const tool = tools.find((entry) => entry.name === "created_tool");
+		expect(tool).toBeDefined();
+		const result = await tool?.execute({ value: "ok" }, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		} as AgentToolContext);
+		expect(result).toEqual({ echoed: "ok" });
+	});
+
+	it("loads sandbox plugins matching manifest providerIds and modelIds", async () => {
+		const matched = await loadSandboxedPlugins({
+			pluginPaths: [join(dir, "plugin-targeted.mjs")],
+			providerId: "openai",
+			modelId: "gpt-5.4",
+			importTimeoutMs: 30_000,
+		});
+
+		try {
+			expect(matched.extensions?.map((extension) => extension.name)).toEqual([
+				"sandbox-targeted",
+			]);
+		} finally {
+			await matched.shutdown();
+		}
+	}, 15_000);
+
+	it("filters sandbox plugins with non-matching manifest providerIds and modelIds", async () => {
+		const filtered = await loadSandboxedPlugins({
+			pluginPaths: [join(dir, "plugin-targeted.mjs")],
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4.5",
+			importTimeoutMs: 30_000,
+		});
+
+		try {
+			expect(filtered.extensions).toEqual([]);
+		} finally {
+			await filtered.shutdown();
+		}
+	}, 15_000);
+});
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-sandbox.ts b/sdk/packages/core/src/extensions/plugin/plugin-sandbox.ts
new file mode 100644
index 0000000..83eddc2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-sandbox.ts
@@ -0,0 +1,648 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type {
+	AgentConfig,
+	AgentExtensionAutomationEventType,
+	AgentExtensionCommandResult,
+	AgentExtensionMcpServer,
+	AgentExtensionRule,
+	AgentRuntimeHooks,
+	AgentTool,
+	Message,
+	PluginSetupContext,
+	WorkspaceInfo,
+} from "@cline/shared";
+import { SubprocessSandbox } from "../../runtime/tools/subprocess-sandbox";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+
+export type SandboxedPluginSetupContext = Pick<
+	PluginSetupContext,
+	"session" | "client" | "user" | "workspaceInfo" | "logger"
+>;
+
+export interface PluginSandboxOptions extends PluginTargeting {
+	pluginPaths: string[];
+	exportName?: string;
+	/**
+	 * Max wall time for plugin module imports. Defaults to 4000 ms; falls back
+	 * to the `CLINE_PLUGIN_IMPORT_TIMEOUT_MS` env var when this option is not
+	 * set, allowing slower hosts (Windows cold-start, CI without warm caches)
+	 * to raise the ceiling without touching code.
+	 */
+	importTimeoutMs?: number;
+	hookTimeoutMs?: number;
+	contributionTimeoutMs?: number;
+	onEvent?: (event: { name: string; payload?: unknown }) => void;
+	/**
+	 * The session's working directory. Forwarded to the sandbox subprocess so
+	 * that `process.cwd()` returns the correct path inside the sandbox even
+	 * when `--cwd` was passed without calling `process.chdir()` on the host.
+	 */
+	cwd?: string;
+	/**
+	 * Structured workspace and git metadata (branch, commit, remotes) generated
+	 * at session startup. Forwarded to plugins via PluginSetupCtx.workspaceInfo
+	 * so they can inspect git state without running their own commands.
+	 */
+	workspaceInfo?: WorkspaceInfo;
+	session?: SandboxedPluginSetupContext["session"];
+	client?: SandboxedPluginSetupContext["client"];
+	user?: SandboxedPluginSetupContext["user"];
+	/** Enables a logger bridge that forwards sandbox log calls to the host. */
+	logger?: SandboxedPluginSetupContext["logger"];
+}
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+type SandboxedAgentExtension = AgentExtension & {
+	/** Internal metadata used by settings surfaces that need source paths. */
+	__clinePluginPath?: string;
+};
+
+type SandboxedContributionDescriptor = {
+	id: string;
+	name: string;
+	description?: string;
+	inputSchema?: unknown;
+	timeoutMs?: number;
+	retryable?: boolean;
+	metadata?: Record<string, unknown>;
+};
+
+type SandboxedRuleDescriptor = Omit<AgentExtensionRule, "id" | "content"> & {
+	id: string;
+	ruleId: string;
+	content?: string;
+	hasContentHandler?: boolean;
+};
+
+type SandboxedAutomationEventTypeDescriptor =
+	AgentExtensionAutomationEventType & {
+		id: string;
+	};
+
+type SandboxedPluginDescriptor = {
+	pluginId: string;
+	pluginPath: string;
+	name: string;
+	manifest: AgentExtension["manifest"];
+	hooks?: Array<keyof AgentRuntimeHooks>;
+	contributions: {
+		tools: SandboxedContributionDescriptor[];
+		commands: SandboxedContributionDescriptor[];
+		rules: SandboxedRuleDescriptor[];
+		messageBuilders: SandboxedContributionDescriptor[];
+		providers: SandboxedContributionDescriptor[];
+		automationEventTypes: SandboxedAutomationEventTypeDescriptor[];
+		mcpServers: AgentExtensionMcpServer[];
+		shortcuts?: SandboxedContributionDescriptor[];
+		flags?: SandboxedContributionDescriptor[];
+	};
+};
+
+type SandboxedInitializeResult = {
+	plugins: SandboxedPluginDescriptor[];
+} & PluginLoadDiagnostics;
+
+function normalizeDescriptor(
+	descriptor: SandboxedPluginDescriptor,
+): SandboxedPluginDescriptor {
+	return {
+		...descriptor,
+		contributions: {
+			tools: descriptor.contributions?.tools ?? [],
+			commands: descriptor.contributions?.commands ?? [],
+			rules: descriptor.contributions?.rules ?? [],
+			messageBuilders: descriptor.contributions?.messageBuilders ?? [],
+			providers: descriptor.contributions?.providers ?? [],
+			automationEventTypes:
+				descriptor.contributions?.automationEventTypes ?? [],
+			mcpServers: descriptor.contributions?.mcpServers ?? [],
+			shortcuts: descriptor.contributions?.shortcuts ?? [],
+			flags: descriptor.contributions?.flags ?? [],
+		},
+	};
+}
+
+function isUnknownPluginIdError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("Unknown sandbox plugin id:");
+}
+
+function getPlatformPackageName(): string {
+	const platform = process.platform === "win32" ? "windows" : process.platform;
+	return `@cline/cli-${platform}-${process.arch}`;
+}
+
+function resolveBootstrapFromWrapper(): string | undefined {
+	const wrapperPath = process.env.CLINE_WRAPPER_PATH?.trim();
+	if (!wrapperPath) {
+		return undefined;
+	}
+	try {
+		const requireFromWrapper = createRequire(wrapperPath);
+		const packageJsonPath = requireFromWrapper.resolve(
+			`${getPlatformPackageName()}/package.json`,
+		);
+		const candidate = join(
+			dirname(packageJsonPath),
+			"extensions",
+			"plugin-sandbox-bootstrap.js",
+		);
+		return existsSync(candidate) ? candidate : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveBootstrapFromExecutable(): string | undefined {
+	const execPath = process.execPath?.trim();
+	if (!execPath) {
+		return undefined;
+	}
+	const candidate = join(
+		dirname(dirname(execPath)),
+		"extensions",
+		"plugin-sandbox-bootstrap.js",
+	);
+	return existsSync(candidate) ? candidate : undefined;
+}
+
+/**
+ * Resolve the bootstrap for the sandbox subprocess.
+ *
+ * In production (bundled), the compiled `.js` file lives next to this module
+ * and can be passed directly as a file to spawn. In development/test
+ * (unbundled, where only the `.ts` source exists), we load the TypeScript
+ * bootstrap through jiti from an inline script.
+ */
+function resolveBootstrap(): { file: string } | { script: string } {
+	const dir = dirname(fileURLToPath(import.meta.url));
+	const requireFromHere = createRequire(import.meta.url);
+	// In dev, the bootstrap sits next to this file in src/extensions/.
+	// In production, the main bundle is at dist/ and the bootstrap is emitted
+	// under dist/extensions/. Keep the older dist/agents/ fallback for
+	// compatibility with previously built layouts.
+	const candidates = [
+		join(dir, "plugin-sandbox-bootstrap.js"),
+		join(dir, "extensions", "plugin-sandbox-bootstrap.js"),
+		join(dir, "agents", "plugin-sandbox-bootstrap.js"),
+		resolveBootstrapFromWrapper(),
+		resolveBootstrapFromExecutable(),
+	];
+	for (const candidate of candidates.filter(
+		(candidate): candidate is string => typeof candidate === "string",
+	)) {
+		if (existsSync(candidate)) return { file: candidate };
+	}
+	const tsPath = join(dir, "plugin-sandbox-bootstrap.ts");
+	let jitiSpecifier = "jiti";
+	try {
+		jitiSpecifier = requireFromHere.resolve("jiti");
+	} catch {
+		// Fall back to bare specifier and let runtime resolution handle it.
+	}
+	return {
+		script: [
+			`const createJiti = require(${JSON.stringify(jitiSpecifier)});`,
+			`const jiti = createJiti(${JSON.stringify(tsPath)}, { cache: false, requireCache: false, esmResolve: true, interopDefault: false });`,
+			`Promise.resolve(jiti.import(${JSON.stringify(tsPath)}, {})).catch((error) => {`,
+			"  console.error(error);",
+			"  process.exitCode = 1;",
+			"});",
+		].join("\n"),
+	};
+}
+
+const BOOTSTRAP = resolveBootstrap();
+
+function withTimeoutFallback(
+	timeoutMs: number | undefined,
+	fallback: number,
+	envVarName?: string,
+): number {
+	if (typeof timeoutMs === "number" && timeoutMs > 0) {
+		return timeoutMs;
+	}
+	if (envVarName) {
+		const raw = process.env[envVarName];
+		if (raw) {
+			// Number() is stricter than parseInt: it rejects values with
+			// trailing non-numeric characters (e.g. "4000ms" -> NaN) so a
+			// malformed env value falls back to the default instead of
+			// silently consuming its numeric prefix.
+			const parsed = Number(raw);
+			if (Number.isInteger(parsed) && parsed > 0) {
+				return parsed;
+			}
+		}
+	}
+	return fallback;
+}
+
+export async function loadSandboxedPlugins(
+	options: PluginSandboxOptions,
+): Promise<
+	{
+		extensions: AgentConfig["extensions"];
+		pluginPaths: string[];
+		shutdown: () => Promise<void>;
+	} & PluginLoadDiagnostics
+> {
+	const sandbox = new SubprocessSandbox({
+		name: "plugin-sandbox",
+		...("file" in BOOTSTRAP
+			? { bootstrapFile: BOOTSTRAP.file }
+			: { bootstrapScript: BOOTSTRAP.script }),
+		onEvent: options.onEvent,
+	});
+	const importTimeoutMs = withTimeoutFallback(
+		options.importTimeoutMs,
+		4000,
+		"CLINE_PLUGIN_IMPORT_TIMEOUT_MS",
+	);
+	const hookTimeoutMs = withTimeoutFallback(options.hookTimeoutMs, 3000);
+	const contributionTimeoutMs = withTimeoutFallback(
+		options.contributionTimeoutMs,
+		60_000,
+	);
+	const initArgs = {
+		pluginPaths: options.pluginPaths,
+		exportName: options.exportName,
+		providerId: options.providerId,
+		modelId: options.modelId,
+		cwd: options.cwd,
+		session: options.session,
+		client: options.client,
+		user: options.user,
+		workspaceInfo: options.workspaceInfo,
+		loggerEnabled: Boolean(options.logger),
+	};
+
+	// Guard against concurrent re-initialization when multiple tools/hooks
+	// fail simultaneously with "Unknown sandbox plugin id:".
+	let reinitPromise: Promise<void> | undefined;
+	const reinitialize = (): Promise<void> => {
+		reinitPromise ??= sandbox
+			.call<void>("initialize", initArgs, { timeoutMs: importTimeoutMs })
+			.finally(() => {
+				reinitPromise = undefined;
+			});
+		return reinitPromise;
+	};
+
+	let initialized: SandboxedInitializeResult;
+	try {
+		initialized = await sandbox.call<SandboxedInitializeResult>(
+			"initialize",
+			initArgs,
+			{ timeoutMs: importTimeoutMs },
+		);
+	} catch (error) {
+		await sandbox.shutdown().catch(() => {
+			// Best-effort cleanup when sandbox initialization fails.
+		});
+		throw error;
+	}
+	const descriptors = initialized.plugins.map(normalizeDescriptor);
+
+	const extensions: NonNullable<AgentConfig["extensions"]> = descriptors.map(
+		(descriptor) => {
+			const extension: SandboxedAgentExtension = {
+				name: descriptor.name,
+				__clinePluginPath: descriptor.pluginPath,
+				manifest: descriptor.manifest,
+				setup: (api: AgentExtensionApi) => {
+					registerTools(
+						api,
+						sandbox,
+						descriptor,
+						contributionTimeoutMs,
+						reinitialize,
+					);
+					registerCommands(
+						api,
+						sandbox,
+						descriptor,
+						contributionTimeoutMs,
+						reinitialize,
+					);
+					registerRules(
+						api,
+						sandbox,
+						descriptor,
+						contributionTimeoutMs,
+						reinitialize,
+					);
+					registerMessageBuilders(
+						api,
+						sandbox,
+						descriptor,
+						contributionTimeoutMs,
+						reinitialize,
+					);
+					registerSimpleContributions(api, descriptor);
+				},
+			};
+
+			extension.hooks = createSandboxRuntimeHooks(
+				sandbox,
+				descriptor,
+				hookTimeoutMs,
+				reinitialize,
+			);
+
+			return extension;
+		},
+	);
+
+	return {
+		extensions,
+		failures: initialized.failures,
+		pluginPaths: descriptors.map((descriptor) => descriptor.pluginPath),
+		shutdown: async () => {
+			await sandbox.shutdown();
+		},
+		warnings: initialized.warnings,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Contribution registration helpers
+// ---------------------------------------------------------------------------
+
+function registerTools(
+	api: AgentExtensionApi,
+	sandbox: SubprocessSandbox,
+	descriptor: SandboxedPluginDescriptor,
+	timeoutMs: number,
+	reinitialize: () => Promise<void>,
+): void {
+	for (const td of descriptor.contributions?.tools ?? []) {
+		const tool: AgentTool = {
+			name: td.name,
+			description: td.description ?? "",
+			inputSchema: (td.inputSchema ?? {
+				type: "object",
+				properties: {},
+			}) as AgentTool["inputSchema"],
+			timeoutMs: td.timeoutMs,
+			retryable: td.retryable,
+			execute: async (input: unknown, context: unknown) => {
+				try {
+					return await sandbox.call(
+						"executeTool",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: td.id,
+							input,
+							context,
+						},
+						{ timeoutMs },
+					);
+				} catch (error) {
+					if (!isUnknownPluginIdError(error)) {
+						throw error;
+					}
+					await reinitialize();
+					return await sandbox.call(
+						"executeTool",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: td.id,
+							input,
+							context,
+						},
+						{ timeoutMs },
+					);
+				}
+			},
+		};
+		api.registerTool(tool);
+	}
+}
+
+function registerCommands(
+	api: AgentExtensionApi,
+	sandbox: SubprocessSandbox,
+	descriptor: SandboxedPluginDescriptor,
+	timeoutMs: number,
+	reinitialize: () => Promise<void>,
+): void {
+	for (const cd of descriptor.contributions?.commands ?? []) {
+		api.registerCommand({
+			name: cd.name,
+			description: cd.description,
+			handler: async (input: string) => {
+				try {
+					return await sandbox.call<AgentExtensionCommandResult>(
+						"executeCommand",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: cd.id,
+							input,
+						},
+						{ timeoutMs },
+					);
+				} catch (error) {
+					if (!isUnknownPluginIdError(error)) {
+						throw error;
+					}
+					await reinitialize();
+					return await sandbox.call<AgentExtensionCommandResult>(
+						"executeCommand",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: cd.id,
+							input,
+						},
+						{ timeoutMs },
+					);
+				}
+			},
+		});
+	}
+}
+
+function registerRules(
+	api: AgentExtensionApi,
+	sandbox: SubprocessSandbox,
+	descriptor: SandboxedPluginDescriptor,
+	timeoutMs: number,
+	reinitialize: () => Promise<void>,
+): void {
+	for (const rule of descriptor.contributions?.rules ?? []) {
+		api.registerRule({
+			id: rule.ruleId,
+			source: rule.source,
+			content:
+				rule.hasContentHandler === true
+					? async () => {
+							try {
+								return await sandbox.call<string>(
+									"resolveRuleContent",
+									{
+										pluginId: descriptor.pluginId,
+										contributionId: rule.id,
+									},
+									{ timeoutMs },
+								);
+							} catch (error) {
+								if (!isUnknownPluginIdError(error)) {
+									throw error;
+								}
+								await reinitialize();
+								return await sandbox.call<string>(
+									"resolveRuleContent",
+									{
+										pluginId: descriptor.pluginId,
+										contributionId: rule.id,
+									},
+									{ timeoutMs },
+								);
+							}
+						}
+					: (rule.content ?? ""),
+		});
+	}
+}
+
+function registerSimpleContributions(
+	api: AgentExtensionApi,
+	descriptor: SandboxedPluginDescriptor,
+): void {
+	for (const pd of descriptor.contributions?.providers ?? []) {
+		api.registerProvider({
+			name: pd.name,
+			description: pd.description,
+			metadata: pd.metadata,
+		});
+	}
+
+	for (const eventType of descriptor.contributions?.automationEventTypes ??
+		[]) {
+		api.registerAutomationEventType({
+			eventType: eventType.eventType,
+			source: eventType.source,
+			description: eventType.description,
+			attributesSchema: eventType.attributesSchema,
+			payloadSchema: eventType.payloadSchema,
+			examples: eventType.examples,
+			metadata: eventType.metadata,
+		});
+	}
+
+	for (const mcpServer of descriptor.contributions?.mcpServers ?? []) {
+		api.registerMcpServer(mcpServer);
+	}
+}
+
+function registerMessageBuilders(
+	api: AgentExtensionApi,
+	sandbox: SubprocessSandbox,
+	descriptor: SandboxedPluginDescriptor,
+	timeoutMs: number,
+	reinitialize: () => Promise<void>,
+): void {
+	for (const bd of descriptor.contributions?.messageBuilders ?? []) {
+		api.registerMessageBuilder({
+			name: bd.name,
+			async build(messages) {
+				try {
+					const result = await sandbox.call<unknown[]>(
+						"buildMessages",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: bd.id,
+							messages,
+						},
+						{ timeoutMs },
+					);
+					return isMessageArray(result) ? result : messages;
+				} catch (error) {
+					if (!isUnknownPluginIdError(error)) {
+						throw error;
+					}
+					await reinitialize();
+					const result = await sandbox.call<unknown[]>(
+						"buildMessages",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: bd.id,
+							messages,
+						},
+						{ timeoutMs },
+					);
+					return isMessageArray(result) ? result : messages;
+				}
+			},
+		});
+	}
+}
+
+function isMessageArray(value: unknown): value is Message[] {
+	return (
+		Array.isArray(value) &&
+		value.every(
+			(entry) =>
+				typeof entry === "object" &&
+				entry !== null &&
+				"role" in entry &&
+				"content" in entry,
+		)
+	);
+}
+
+function makeHookHandler(
+	sandbox: SubprocessSandbox,
+	pluginId: string,
+	hookName: string,
+	timeoutMs: number,
+	reinitialize: () => Promise<void>,
+): (payload: unknown) => Promise<unknown> {
+	return async (payload: unknown) => {
+		try {
+			return await sandbox.call(
+				"invokeHook",
+				{ pluginId, hookName, payload },
+				{ timeoutMs },
+			);
+		} catch (error) {
+			if (!isUnknownPluginIdError(error)) {
+				throw error;
+			}
+			await reinitialize();
+			return await sandbox.call(
+				"invokeHook",
+				{ pluginId, hookName, payload },
+				{ timeoutMs },
+			);
+		}
+	};
+}
+
+function createSandboxRuntimeHooks(
+	sandbox: SubprocessSandbox,
+	descriptor: SandboxedPluginDescriptor,
+	hookTimeoutMs: number,
+	reinitialize: () => Promise<void>,
+): Partial<AgentRuntimeHooks> | undefined {
+	const hooks: Partial<
+		Record<keyof AgentRuntimeHooks, (payload: unknown) => Promise<unknown>>
+	> = {};
+	for (const hookName of descriptor.hooks ?? []) {
+		hooks[hookName] = makeHookHandler(
+			sandbox,
+			descriptor.pluginId,
+			hookName,
+			hookTimeoutMs,
+			reinitialize,
+		);
+	}
+	return Object.keys(hooks).length > 0
+		? (hooks as Partial<AgentRuntimeHooks>)
+		: undefined;
+}
diff --git a/sdk/packages/core/src/extensions/plugin/plugin-targeting.ts b/sdk/packages/core/src/extensions/plugin/plugin-targeting.ts
new file mode 100644
index 0000000..b8fbee6
--- /dev/null
+++ b/sdk/packages/core/src/extensions/plugin/plugin-targeting.ts
@@ -0,0 +1,32 @@
+import type { PluginManifest } from "@cline/shared";
+
+export interface PluginTargeting {
+	providerId?: string;
+	modelId?: string;
+}
+
+export function matchesPluginManifestTargeting(
+	manifest: PluginManifest | undefined,
+	targeting: PluginTargeting | undefined,
+): boolean {
+	if (!manifest) {
+		return true;
+	}
+
+	if (manifest.providerIds?.length) {
+		if (
+			!targeting?.providerId ||
+			!manifest.providerIds.includes(targeting.providerId)
+		) {
+			return false;
+		}
+	}
+
+	if (manifest.modelIds?.length) {
+		if (!targeting?.modelId || !manifest.modelIds.includes(targeting.modelId)) {
+			return false;
+		}
+	}
+
+	return true;
+}
diff --git a/sdk/packages/core/src/extensions/tools/constants.ts b/sdk/packages/core/src/extensions/tools/constants.ts
new file mode 100644
index 0000000..e92680d
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/constants.ts
@@ -0,0 +1,37 @@
+/**
+ * Constants for Default Tools
+ *
+ * Tool name constants and utility arrays.
+ */
+
+import type { DefaultToolName } from "./types";
+
+/**
+ * Constants for default tool names
+ */
+export const DefaultToolNames = {
+	READ_FILES: "read_files",
+	SEARCH_CODEBASE: "search_codebase",
+	RUN_COMMANDS: "run_commands",
+	FETCH_WEB_CONTENT: "fetch_web_content",
+	APPLY_PATCH: "apply_patch",
+	EDITOR: "editor",
+	SKILLS: "skills",
+	ASK: "ask_question",
+	SUBMIT_AND_EXIT: "submit_and_exit",
+} as const;
+
+/**
+ * Array of all default tool names
+ */
+export const ALL_DEFAULT_TOOL_NAMES: DefaultToolName[] = [
+	DefaultToolNames.READ_FILES,
+	DefaultToolNames.SEARCH_CODEBASE,
+	DefaultToolNames.RUN_COMMANDS,
+	DefaultToolNames.FETCH_WEB_CONTENT,
+	DefaultToolNames.APPLY_PATCH,
+	DefaultToolNames.EDITOR,
+	DefaultToolNames.SKILLS,
+	DefaultToolNames.ASK,
+	DefaultToolNames.SUBMIT_AND_EXIT,
+];
diff --git a/sdk/packages/core/src/extensions/tools/definitions.test.ts b/sdk/packages/core/src/extensions/tools/definitions.test.ts
new file mode 100644
index 0000000..e296bee
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/definitions.test.ts
@@ -0,0 +1,1929 @@
+import type { ITelemetryService } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import {
+	CLINE_INTERNAL_TELEMETRY_METADATA_KEY,
+	getToolContextTelemetry,
+} from "../../services/telemetry/tool-context";
+import {
+	createDefaultTools,
+	createReadFilesTool,
+	createSearchTool,
+	createShellTool,
+	createSkillsTool,
+} from "./definitions";
+import { CommandExitError } from "./executors/bash";
+import { RUN_COMMAND_QUERY_PREVIEW_LIMIT, TimeoutError } from "./helpers";
+import { INPUT_ARG_CHAR_LIMIT } from "./schemas";
+import type { SkillsExecutorWithMetadata } from "./types";
+
+function hasSchemaKey(value: unknown, key: string): boolean {
+	if (Array.isArray(value)) {
+		return value.some((item) => hasSchemaKey(item, key));
+	}
+	if (value && typeof value === "object") {
+		return Object.entries(value).some(
+			([entryKey, entryValue]) =>
+				entryKey === key || hasSchemaKey(entryValue, key),
+		);
+	}
+	return false;
+}
+
+function createMockSkillsExecutor(
+	fn: (...args: unknown[]) => Promise<string> = async () => "ok",
+	configuredSkills?: SkillsExecutorWithMetadata["configuredSkills"],
+): SkillsExecutorWithMetadata {
+	const executor = fn as SkillsExecutorWithMetadata;
+	executor.configuredSkills = configuredSkills;
+	return executor;
+}
+
+describe("default skills tool", () => {
+	it("is included only when enabled with a skills executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableSkills: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"skills",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				skills: createMockSkillsExecutor(),
+			},
+			enableSkills: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain("skills");
+	});
+
+	it("includes configured skill names in description", () => {
+		const executor = createMockSkillsExecutor(
+			async () => "ok",
+			[
+				{ id: "commit", name: "commit", disabled: false },
+				{
+					id: "review-pr",
+					name: "review-pr",
+					description: "Review a PR",
+					disabled: false,
+				},
+				{ id: "disabled-skill", name: "disabled-skill", disabled: true },
+			],
+		);
+		const tool = createSkillsTool(executor);
+		expect(tool.description).toContain("Available skills: commit, review-pr.");
+		expect(tool.description).not.toContain("disabled-skill");
+	});
+
+	it("omits skill list from description when no skills are configured", () => {
+		const executor = createMockSkillsExecutor(async () => "ok");
+		const tool = createSkillsTool(executor);
+		expect(tool.description).not.toContain("Available skills");
+	});
+
+	it("validates and executes skill invocation input", async () => {
+		const execute = vi.fn(async () => "loaded");
+		const tools = createDefaultTools({
+			executors: {
+				skills: createMockSkillsExecutor(execute),
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: true,
+		});
+		const skillsTool = tools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool to be defined.");
+		}
+
+		const result = await skillsTool.execute(
+			{ skill: "commit", args: "-m 'fix'" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toBe("loaded");
+		expect(execute).toHaveBeenCalledWith(
+			"commit",
+			"-m 'fix'",
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("default ask_question tool", () => {
+	it("is enabled by default when executor is provided", () => {
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: async () => "ok",
+			},
+		});
+		expect(tools.map((tool) => tool.name)).toContain("ask_question");
+	});
+
+	it("is excluded when explicitly disabled", () => {
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: async () => "ok",
+			},
+			enableAskQuestion: false,
+		});
+		expect(tools.map((tool) => tool.name)).not.toContain("ask_question");
+	});
+
+	it("is included only when enabled with an askQuestion executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableAskQuestion: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"ask_question",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				askQuestion: async () => "ok",
+			},
+			enableAskQuestion: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain(
+			"ask_question",
+		);
+	});
+
+	it("validates and executes ask_question input", async () => {
+		const execute = vi.fn(async () => "asked");
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: false,
+			enableAskQuestion: true,
+		});
+		const askTool = tools.find((tool) => tool.name === "ask_question");
+		expect(askTool).toBeDefined();
+		if (!askTool) {
+			throw new Error("Expected ask_question tool to be defined.");
+		}
+
+		const result = await askTool.execute(
+			{
+				question: "Which approach should I take?",
+				options: ["Option 1", "Option 2"],
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toBe("asked");
+		expect(execute).toHaveBeenCalledWith(
+			"Which approach should I take?",
+			["Option 1", "Option 2"],
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("waits for ask_question answers without timing out", async () => {
+		vi.useFakeTimers();
+		try {
+			let resolveAnswer: (answer: string) => void = () => {};
+			const execute = vi.fn(
+				() =>
+					new Promise<string>((resolve) => {
+						resolveAnswer = resolve;
+					}),
+			);
+			const tools = createDefaultTools({
+				executors: {
+					askQuestion: execute,
+				},
+				enableReadFiles: false,
+				enableSearch: false,
+				enableBash: false,
+				enableWebFetch: false,
+				enableEditor: false,
+				enableSkills: false,
+				enableAskQuestion: true,
+			});
+			const askTool = tools.find((tool) => tool.name === "ask_question");
+			expect(askTool).toBeDefined();
+			if (!askTool) {
+				throw new Error("Expected ask_question tool to be defined.");
+			}
+
+			const pending = Promise.resolve(
+				askTool.execute(
+					{
+						question: "Which approach should I take?",
+						options: ["Option 1", "Option 2"],
+					},
+					{
+						agentId: "agent-1",
+						conversationId: "conv-1",
+						iteration: 1,
+					},
+				),
+			);
+			let settled: unknown;
+			pending.then(
+				(value) => {
+					settled = value;
+				},
+				(error) => {
+					settled = error instanceof Error ? error : new Error(String(error));
+				},
+			);
+
+			await vi.advanceTimersByTimeAsync(60_000);
+			await Promise.resolve();
+
+			expect(settled).toBeUndefined();
+			resolveAnswer("Option 2");
+			await expect(pending).resolves.toBe("Option 2");
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
+
+describe("default submit_and_exit tool", () => {
+	it("is excluded by default even when executor is provided", () => {
+		const tools = createDefaultTools({
+			executors: {
+				submit: async () => "ok",
+			},
+		});
+		expect(tools.map((tool) => tool.name)).not.toContain("submit_and_exit");
+	});
+
+	it("is included only when enabled with a submit executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableSubmitAndExit: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"submit_and_exit",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				submit: async () => "ok",
+			},
+			enableSubmitAndExit: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain(
+			"submit_and_exit",
+		);
+	});
+
+	it("excludes ask_question when submit_and_exit is included", () => {
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: async () => "answer",
+				submit: async () => "submitted",
+			},
+			enableAskQuestion: true,
+			enableSubmitAndExit: true,
+		});
+
+		const toolNames = tools.map((tool) => tool.name);
+		expect(toolNames).toContain("submit_and_exit");
+		expect(toolNames).not.toContain("ask_question");
+	});
+
+	it("validates and executes submit_and_exit input", async () => {
+		const execute = vi.fn(async () => "submitted");
+		const tools = createDefaultTools({
+			executors: {
+				submit: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableSubmitAndExit: true,
+		});
+		const submitTool = tools.find((tool) => tool.name === "submit_and_exit");
+		expect(submitTool).toBeDefined();
+		expect(submitTool?.lifecycle).toEqual({ completesRun: true });
+		if (!submitTool) {
+			throw new Error("Expected submit_and_exit tool to be defined.");
+		}
+
+		const result = await submitTool.execute(
+			{
+				summary: "Done and verified with the requested checks.",
+				verified: true,
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toBe("submitted");
+		expect(execute).toHaveBeenCalledWith(
+			"Done and verified with the requested checks.",
+			true,
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("default search_codebase tool", () => {
+	it("treats a valid search with zero matches as success", async () => {
+		const noResults =
+			"No results found for pattern: missingSymbol\nSearched 3 files.";
+		const execute = vi.fn(async () => noResults);
+		const tool = createSearchTool(execute);
+
+		const result = await tool.execute(
+			{ queries: ["missingSymbol"] },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "missingSymbol",
+				result: noResults,
+				success: true,
+			},
+		]);
+	});
+
+	it("treats executor errors as failures", async () => {
+		const execute = vi.fn(async () => {
+			throw new Error("bad regex");
+		});
+		const tool = createSearchTool(execute);
+
+		const result = await tool.execute(
+			{ queries: ["("] },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "(",
+				result: "",
+				error: "Search failed: bad regex",
+				success: false,
+			},
+		]);
+	});
+});
+
+describe("default apply_patch tool", () => {
+	it("is included only when enabled with an applyPatch executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableApplyPatch: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"apply_patch",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				applyPatch: async () => "ok",
+			},
+			enableApplyPatch: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain("apply_patch");
+	});
+
+	it("validates and executes apply_patch input", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				applyPatch: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: true,
+		});
+
+		const applyPatchTool = tools.find((tool) => tool.name === "apply_patch");
+		expect(applyPatchTool).toBeDefined();
+		if (!applyPatchTool) {
+			throw new Error("Expected apply_patch tool to be defined.");
+		}
+
+		const result = await applyPatchTool.execute(
+			{ input: "*** Begin Patch\n*** End Patch" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "apply_patch",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			{ input: "*** Begin Patch\n*** End Patch" },
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("default run_commands tool", () => {
+	function createTelemetryStub(): ITelemetryService {
+		return {
+			capture: vi.fn(),
+			captureRequired: vi.fn(),
+			setDistinctId: vi.fn(),
+			setMetadata: vi.fn(),
+			updateMetadata: vi.fn(),
+			setCommonProperties: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: vi.fn(() => true),
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: vi.fn(async () => {}),
+			dispose: vi.fn(async () => {}),
+		};
+	}
+
+	function capturedTimeoutEvents(telemetry: ITelemetryService) {
+		return (telemetry.capture as ReturnType<typeof vi.fn>).mock.calls
+			.map((call) => call[0])
+			.filter((event) => event.event === "sdk.tool_timeout");
+	}
+
+	it("reads telemetry from the internal metadata key", () => {
+		const telemetry = createTelemetryStub();
+
+		expect(
+			getToolContextTelemetry({
+				telemetry: "user-defined-label",
+				[CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry,
+			}),
+		).toBe(telemetry);
+	});
+
+	it("accepts object input with commands as a single string", async () => {
+		const execute = vi.fn(async (command: string | { command: string }) =>
+			typeof command === "string" ? `ran:${command}` : `ran:${command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute({ commands: "ls" } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		});
+
+		expect(result).toEqual([
+			{
+				query: "ls",
+				result: "ran:ls",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenCalledTimes(1);
+		expect(execute).toHaveBeenCalledWith(
+			"ls",
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("accepts common single-command aliases", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		await tool.execute({ command: "pwd" } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		});
+		await tool.execute({ cmd: "git status --short" } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 2,
+		});
+
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			"pwd",
+			process.cwd(),
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			"git status --short",
+			process.cwd(),
+			expect.objectContaining({ iteration: 2 }),
+		);
+	});
+
+	it("accepts structured commands and preserves argv", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string; args?: string[] }) =>
+				typeof command === "string"
+					? `ran:${command}`
+					: `ran:${command.command}:${(command.args ?? []).join(",")}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{
+				commands: {
+					command: "node",
+					args: ["-e", "console.log('ok')"],
+				},
+			} as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "node -e console.log('ok')",
+				result: "ran:node:-e,console.log('ok')",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenCalledWith(
+			{
+				command: "node",
+				args: ["-e", "console.log('ok')"],
+			},
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("accepts mixed structured and string command arrays", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string; args?: string[] }) =>
+				typeof command === "string"
+					? `ran:${command}`
+					: `ran:${command.command}:${(command.args ?? []).join(",")}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{
+				commands: ["pwd", { command: "node", args: ["--version"] }],
+			} as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{ query: "pwd", result: "ran:pwd", success: true },
+			{
+				query: "node --version",
+				result: "ran:node:--version",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			"pwd",
+			process.cwd(),
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			{ command: "node", args: ["--version"] },
+			process.cwd(),
+			expect.objectContaining({ iteration: 1 }),
+		);
+	});
+
+	it("rejects invalid text-object command entries", async () => {
+		const execute = vi.fn(async () => "ran");
+		const tool = createShellTool(execute);
+
+		await expect(
+			tool.execute({ commands: [{ $text: "pwd" }] } as never, {
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		).rejects.toThrow("Invalid input");
+		expect(execute).not.toHaveBeenCalled();
+	});
+
+	it("preserves args on direct structured command objects", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string; args?: string[] }) =>
+				typeof command === "string"
+					? `ran:${command}`
+					: `ran:${command.command}:${(command.args ?? []).join(",")}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{ command: "git", args: ["status", "--short"] } as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "git status --short",
+				result: "ran:git:status,--short",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenCalledWith(
+			{ command: "git", args: ["status", "--short"] },
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("keeps short command echoes unchanged in tool results", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{ commands: ["git status --short"] },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "git status --short",
+				result: "ran:git status --short",
+				success: true,
+			},
+		]);
+	});
+
+	it("returns captured output for non-zero command exits", async () => {
+		const execute = vi.fn(async () => {
+			throw new CommandExitError(
+				1,
+				"[Command exited with code 1]\nfailed assertion details",
+			);
+		});
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{ commands: ["bun test"] },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "bun test",
+				result: "[Command exited with code 1]\nfailed assertion details",
+				error: "Command exited with code 1",
+				success: false,
+			},
+		]);
+	});
+
+	it("coalesces split heredoc command arrays before execution", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{
+				commands: [
+					"cd /app && python3 << 'PYEOF'",
+					"import csv",
+					"print('ok')",
+					"PYEOF",
+				],
+			},
+			{
+				sessionId: "session-split-heredoc",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		const expectedCommand =
+			"cd /app && python3 << 'PYEOF'\nimport csv\nprint('ok')\nPYEOF";
+		expect(execute).toHaveBeenCalledTimes(1);
+		expect(execute).toHaveBeenCalledWith(
+			expectedCommand,
+			process.cwd(),
+			expect.objectContaining({ sessionId: "session-split-heredoc" }),
+		);
+		expect(result).toEqual([
+			expect.objectContaining({
+				query: expect.stringContaining("cd /app && python3"),
+				result: `ran:${expectedCommand}`,
+				success: true,
+			}),
+		]);
+	});
+
+	it("coalesces split heredocs while preserving surrounding command order", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{
+				commands: [
+					"pwd",
+					"python3 << 'PYEOF'",
+					"print('ok')",
+					"PYEOF",
+					"ls /app",
+				],
+			},
+			{
+				sessionId: "session-surrounding-heredoc",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		const expectedCommand = "python3 << 'PYEOF'\nprint('ok')\nPYEOF";
+		expect(execute).toHaveBeenCalledTimes(3);
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			"pwd",
+			process.cwd(),
+			expect.objectContaining({ sessionId: "session-surrounding-heredoc" }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			expectedCommand,
+			process.cwd(),
+			expect.objectContaining({ sessionId: "session-surrounding-heredoc" }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			3,
+			"ls /app",
+			process.cwd(),
+			expect.objectContaining({ sessionId: "session-surrounding-heredoc" }),
+		);
+		expect(result).toEqual([
+			expect.objectContaining({ query: "pwd", result: "ran:pwd" }),
+			expect.objectContaining({
+				query: expectedCommand,
+				result: `ran:${expectedCommand}`,
+			}),
+			expect.objectContaining({ query: "ls /app", result: "ran:ls /app" }),
+		]);
+	});
+
+	it("coalesces split tab-stripping heredocs", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{
+				commands: ["cat <<- EOF", "\tindented body", "EOF"],
+			},
+			{
+				sessionId: "session-tab-stripping-heredoc",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		const expectedCommand = "cat <<- EOF\n\tindented body\nEOF";
+		expect(execute).toHaveBeenCalledTimes(1);
+		expect(execute).toHaveBeenCalledWith(
+			expectedCommand,
+			process.cwd(),
+			expect.objectContaining({
+				sessionId: "session-tab-stripping-heredoc",
+			}),
+		);
+		expect(result).toEqual([
+			expect.objectContaining({
+				query: expectedCommand,
+				result: `ran:${expectedCommand}`,
+			}),
+		]);
+	});
+
+	it("does not coalesce independent command arrays", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{ commands: ["pwd", "ls /app"] },
+			{
+				sessionId: "session-independent-commands",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(execute).toHaveBeenCalledTimes(2);
+		expect(result).toEqual([
+			expect.objectContaining({ query: "pwd", result: "ran:pwd" }),
+			expect.objectContaining({ query: "ls /app", result: "ran:ls /app" }),
+		]);
+	});
+
+	it("coalesces consecutive split heredoc command arrays independently", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{
+				commands: [
+					"cat << 'FOO'",
+					"foo body",
+					"FOO",
+					"cat << 'BAR'",
+					"bar body",
+					"BAR",
+				],
+			},
+			{
+				sessionId: "session-consecutive-heredocs",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		const expectedFirstCommand = "cat << 'FOO'\nfoo body\nFOO";
+		const expectedSecondCommand = "cat << 'BAR'\nbar body\nBAR";
+		expect(execute).toHaveBeenCalledTimes(2);
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			expectedFirstCommand,
+			process.cwd(),
+			expect.objectContaining({ sessionId: "session-consecutive-heredocs" }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			expectedSecondCommand,
+			process.cwd(),
+			expect.objectContaining({ sessionId: "session-consecutive-heredocs" }),
+		);
+		expect(result).toEqual([
+			expect.objectContaining({
+				query: "cat << 'FOO'\nfoo body\nFOO",
+				result: `ran:${expectedFirstCommand}`,
+			}),
+			expect.objectContaining({
+				query: "cat << 'BAR'\nbar body\nBAR",
+				result: `ran:${expectedSecondCommand}`,
+			}),
+		]);
+	});
+
+	it("does not treat here-strings as split heredocs", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{ commands: ['wc -c <<< "hello"', "hello"] },
+			{
+				sessionId: "session-here-string",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(execute).toHaveBeenCalledTimes(2);
+		expect(result).toEqual([
+			expect.objectContaining({
+				query: 'wc -c <<< "hello"',
+				result: 'ran:wc -c <<< "hello"',
+			}),
+			expect.objectContaining({
+				query: "hello",
+				result: "ran:hello",
+			}),
+		]);
+	});
+
+	it("does not coalesce unterminated heredoc command arrays", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command : command.command}`,
+		);
+		const tool = createShellTool(execute);
+
+		const result = await tool.execute(
+			{ commands: ["python3 << 'PYEOF'", "print('ok')"] },
+			{
+				sessionId: "session-unterminated-heredoc",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(execute).toHaveBeenCalledTimes(2);
+		expect(result).toEqual([
+			expect.objectContaining({
+				query: "python3 << 'PYEOF'",
+				result: "ran:python3 << 'PYEOF'",
+			}),
+			expect.objectContaining({
+				query: "print('ok')",
+				result: "ran:print('ok')",
+			}),
+		]);
+	});
+
+	it("truncates long command echoes in tool results without affecting execution", async () => {
+		const execute = vi.fn(
+			async (command: string | { command: string }) =>
+				`ran:${typeof command === "string" ? command.length : command.command.length}`,
+		);
+		const tool = createShellTool(execute);
+		const largeSource = "x".repeat(14000);
+		const command = `cat > /app/eval.scm << 'EOF'\n${largeSource}\nEOF`;
+
+		const result = (await tool.execute(
+			{ commands: [command] },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		)) as Array<{ query: string; result: string; success: boolean }>;
+
+		// The executor still receives the full command
+		expect(execute).toHaveBeenCalledWith(
+			command,
+			process.cwd(),
+			expect.anything(),
+		);
+		expect(result[0].success).toBe(true);
+		expect(result[0].result).toBe(`ran:${command.length}`);
+		// The provider-facing echo is bounded and self-describing
+		expect(result[0].query.length).toBeLessThan(
+			RUN_COMMAND_QUERY_PREVIEW_LIMIT + 100,
+		);
+		expect(result[0].query).toContain("cat > /app/eval.scm << 'EOF'");
+		expect(result[0].query).toContain("command truncated");
+		expect(result[0].query).toContain("full command is in the tool call input");
+	});
+
+	it("truncates long command echoes on the error path too", async () => {
+		const execute = vi.fn(async () => {
+			throw new Error("boom");
+		});
+		const tool = createShellTool(execute);
+		const command = `cat > /app/big.txt << 'EOF'\n${"y".repeat(10000)}\nEOF`;
+
+		const result = (await tool.execute(
+			{ commands: [command] },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		)) as Array<{ query: string; success: boolean; error?: string }>;
+
+		expect(result[0].success).toBe(false);
+		expect(result[0].error).toContain("boom");
+		expect(result[0].query.length).toBeLessThan(
+			RUN_COMMAND_QUERY_PREVIEW_LIMIT + 100,
+		);
+		expect(result[0].query).toContain("command truncated");
+	});
+
+	it("truncates long command echoes for the structured windows shell tool", async () => {
+		const execute = vi.fn(async () => "ok");
+		const tool = createShellTool(execute);
+		const command = `powershell -Command "${"z".repeat(9000)}"`;
+
+		const result = (await tool.execute({ commands: [command] } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		})) as Array<{ query: string; success: boolean }>;
+
+		expect(result[0].success).toBe(true);
+		expect(result[0].query.length).toBeLessThan(
+			RUN_COMMAND_QUERY_PREVIEW_LIMIT + 100,
+		);
+		expect(result[0].query).toContain("command truncated");
+	});
+
+	it("emits timeout telemetry without leaking raw command data", async () => {
+		// Never resolves, so the configured timeout deterministically wins the
+		// race regardless of host load (a tight real-timer margin flaked under
+		// heavy parallel CI runs).
+		const execute = vi.fn((): Promise<string> => new Promise<string>(() => {}));
+		const tool = createShellTool(execute, { bashTimeoutMs: 5 });
+		const telemetry = createTelemetryStub();
+
+		const result = await tool.execute(
+			{
+				commands: [
+					{
+						command: process.execPath,
+						args: ["-e", "console.log('secret-token')"],
+					},
+					"pwd",
+				],
+			} as never,
+			{
+				sessionId: "session-1",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				runId: "run-1",
+				iteration: 1,
+				toolCallId: "tool-call-1",
+				metadata: {
+					[CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry,
+					mode: "act",
+					source: "sdk-test",
+				},
+			},
+		);
+
+		expect(result).toEqual([
+			expect.objectContaining({ success: false }),
+			expect.objectContaining({ success: false }),
+		]);
+		const timeoutCalls = capturedTimeoutEvents(telemetry);
+		expect(timeoutCalls).toHaveLength(2);
+		for (const call of timeoutCalls) {
+			expect(call.properties).toMatchObject({
+				tool_name: "run_commands",
+				effective_timeout_ms: 5,
+				timeout_source: "configured_setting",
+				command_count: 2,
+				ulid: "session-1",
+				mode: "act",
+				source: "sdk-test",
+				session_id: "session-1",
+				agent_id: "agent-1",
+				conversation_id: "conv-1",
+				run_id: "run-1",
+				iteration: 1,
+				tool_call_id: "tool-call-1",
+			});
+			expect(typeof call.properties.duration_ms).toBe("number");
+			const payload = JSON.stringify(call.properties);
+			expect(payload).not.toContain("secret-token");
+			expect(payload).not.toContain("pwd");
+			expect(payload).not.toContain("stdout");
+			expect(payload).not.toContain("stderr");
+			expect(payload).not.toContain("env");
+			expect(call.properties).not.toHaveProperty("command");
+			expect(call.properties).not.toHaveProperty("commands");
+		}
+	});
+
+	it("emits timeout telemetry for executor TimeoutError only", async () => {
+		const telemetry = createTelemetryStub();
+		const executorTimeout = vi.fn(async () => {
+			throw new TimeoutError("Command timed out after 5000ms", 5000);
+		});
+		const plainFailure = vi.fn(async () => {
+			throw new Error("Command timed out after 5000ms");
+		});
+
+		await createShellTool(executorTimeout, {
+			bashTimeoutMs: 5000,
+		}).execute({ commands: ["echo timeout"] } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+			metadata: { [CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry },
+		});
+		await createShellTool(plainFailure, { bashTimeoutMs: 5000 }).execute(
+			{ commands: ["echo not-timeout"] } as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 2,
+				metadata: { [CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry },
+			},
+		);
+
+		const timeoutCalls = capturedTimeoutEvents(telemetry);
+		expect(timeoutCalls).toHaveLength(1);
+		expect(timeoutCalls[0]?.properties).toMatchObject({
+			effective_timeout_ms: 5000,
+			timeout_source: "configured_setting",
+			command_count: 1,
+		});
+	});
+
+	it("emits timeout telemetry on the default bash tool path", async () => {
+		const telemetry = createTelemetryStub();
+		// Never resolves, so the configured timeout deterministically wins the
+		// race regardless of host load (a tight real-timer margin flaked under
+		// heavy parallel CI runs).
+		const execute = vi.fn((): Promise<string> => new Promise<string>(() => {}));
+		const tool = createShellTool(execute, { bashTimeoutMs: 5 });
+
+		const result = await tool.execute(
+			{ commands: ["echo secret-token", "pwd"] },
+			{
+				sessionId: "session-1",
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				runId: "run-1",
+				iteration: 1,
+				toolCallId: "tool-call-1",
+				metadata: {
+					[CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry,
+					mode: "act",
+					source: "sdk-test",
+				},
+			},
+		);
+
+		expect(result).toEqual([
+			expect.objectContaining({ success: false }),
+			expect.objectContaining({ success: false }),
+		]);
+		const timeoutCalls = capturedTimeoutEvents(telemetry);
+		expect(timeoutCalls).toHaveLength(2);
+		for (const call of timeoutCalls) {
+			expect(call.properties).toMatchObject({
+				tool_name: "run_commands",
+				effective_timeout_ms: 5,
+				timeout_source: "configured_setting",
+				command_count: 2,
+				ulid: "session-1",
+				mode: "act",
+				source: "sdk-test",
+				session_id: "session-1",
+				agent_id: "agent-1",
+				conversation_id: "conv-1",
+				run_id: "run-1",
+				iteration: 1,
+				tool_call_id: "tool-call-1",
+			});
+			expect(typeof call.properties.duration_ms).toBe("number");
+			const payload = JSON.stringify(call.properties);
+			expect(payload).not.toContain("secret-token");
+			expect(payload).not.toContain("pwd");
+			expect(call.properties).not.toHaveProperty("command");
+			expect(call.properties).not.toHaveProperty("commands");
+		}
+	});
+
+	it("does not emit timeout telemetry for normal command success", async () => {
+		const execute = vi.fn(async () => "ok");
+		const tool = createShellTool(execute, { bashTimeoutMs: 50 });
+		const telemetry = createTelemetryStub();
+
+		await tool.execute({ commands: ["echo hi"] } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+			metadata: { [CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry },
+		});
+
+		expect(capturedTimeoutEvents(telemetry)).toEqual([]);
+	});
+});
+
+describe("default read_files tool", () => {
+	it("validates ranged file requests and passes them to the executor", async () => {
+		const execute = vi.fn(async () => "selected lines");
+		const tool = createReadFilesTool(execute);
+
+		const result = await tool.execute(
+			{
+				files: [
+					{
+						path: "/tmp/example.ts",
+						start_line: 3,
+						end_line: 5,
+					},
+				],
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "/tmp/example.ts:3-5",
+				result: "selected lines",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenCalledWith(
+			{
+				path: "/tmp/example.ts",
+				start_line: 3,
+				end_line: 5,
+			},
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("accepts string union inputs reading full file content", async () => {
+		const execute = vi.fn(async () => "full file");
+		const tool = createReadFilesTool(execute);
+
+		await tool.execute("/tmp/example.ts" as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		});
+
+		expect(execute).toHaveBeenCalledWith(
+			{ path: "/tmp/example.ts" },
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("accepts paths aliases for model-generated read requests", async () => {
+		const execute = vi.fn(
+			async (request: { path: string }) => `content:${request.path}`,
+		);
+		const tool = createReadFilesTool(execute);
+
+		await tool.execute(
+			{
+				paths: ["/tmp/a.ts", { path: "/tmp/b.ts", start_line: 2 }],
+			} as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		await tool.execute({ paths: "/tmp/c.ts" } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 2,
+		});
+
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			{ path: "/tmp/a.ts" },
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			{ path: "/tmp/b.ts", start_line: 2 },
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			3,
+			{ path: "/tmp/c.ts" },
+			expect.objectContaining({ iteration: 2 }),
+		);
+	});
+
+	it("accepts files aliases with string paths from model-generated read requests", async () => {
+		const execute = vi.fn(
+			async (request: { path: string }) => `content:${request.path}`,
+		);
+		const tool = createReadFilesTool(execute);
+
+		await tool.execute(
+			{ files: ["/tmp/a.ts", { path: "/tmp/b.ts", end_line: 4 }] } as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		await tool.execute({ files: "/tmp/c.ts" } as never, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 2,
+		});
+
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			{ path: "/tmp/a.ts" },
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			{ path: "/tmp/b.ts", end_line: 4 },
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			3,
+			{ path: "/tmp/c.ts" },
+			expect.objectContaining({ iteration: 2 }),
+		);
+	});
+
+	it("folds orphan range entries into the preceding file entry", async () => {
+		const execute = vi.fn(
+			async (request: { path: string }) => `content:${request.path}`,
+		);
+		const tool = createReadFilesTool(execute);
+
+		await tool.execute(
+			{
+				files: [
+					{ path: "/tmp/example.ips" },
+					{ start_line: 45, end_line: 100 },
+				],
+			} as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		await tool.execute(
+			{ paths: ["/tmp/a.ts", { end_line: 4 }, "/tmp/b.ts"] } as never,
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 2,
+			},
+		);
+
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			{ path: "/tmp/example.ips", start_line: 45, end_line: 100 },
+			expect.objectContaining({ iteration: 1 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			{ path: "/tmp/a.ts", end_line: 4 },
+			expect.objectContaining({ iteration: 2 }),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			3,
+			{ path: "/tmp/b.ts" },
+			expect.objectContaining({ iteration: 2 }),
+		);
+	});
+
+	it("rejects orphan range entries that cannot be attached to a file entry", async () => {
+		const execute = vi.fn(async () => "should not run");
+		const tool = createReadFilesTool(execute);
+
+		// Leading orphan range: no preceding file entry to fold into.
+		await expect(
+			tool.execute(
+				{
+					files: [{ start_line: 1, end_line: 2 }, { path: "/tmp/a.ts" }],
+				} as never,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow();
+
+		// Preceding entry already has its own range: keep the conflict visible.
+		await expect(
+			tool.execute(
+				{
+					files: [
+						{ path: "/tmp/a.ts", start_line: 1 },
+						{ start_line: 4, end_line: 8 },
+					],
+				} as never,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 2,
+				},
+			),
+		).rejects.toThrow();
+
+		expect(execute).not.toHaveBeenCalled();
+	});
+
+	it("rejects invalid union inputs before calling the executor", async () => {
+		const execute = vi.fn(async () => "should not run");
+		const tool = createReadFilesTool(execute);
+
+		await expect(
+			tool.execute({ paths: ["/tmp/a.ts", 42] } as never, {
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		).rejects.toThrow();
+
+		expect(execute).not.toHaveBeenCalled();
+	});
+
+	it("treats null line bounds as full-file boundaries", async () => {
+		const execute = vi.fn(async () => "full file");
+		const tool = createReadFilesTool(execute);
+
+		const result = await tool.execute(
+			{
+				files: [
+					{
+						path: "/tmp/example.ts",
+						start_line: null,
+						end_line: null,
+					},
+				],
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "/tmp/example.ts",
+				result: "full file",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenCalledWith(
+			{
+				path: "/tmp/example.ts",
+				start_line: null,
+				end_line: null,
+			},
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("returns per-file errors for reversed ranges while executing valid batch entries", async () => {
+		const execute = vi.fn(async (request: { path: string }) => {
+			return `content for ${request.path}`;
+		});
+		const tool = createReadFilesTool(execute);
+
+		const result = await tool.execute(
+			{
+				files: [
+					{
+						path: "/tmp/valid-a.ts",
+						start_line: 1,
+						end_line: 2,
+					},
+					{
+						path: "/tmp/reversed.ts",
+						start_line: 5,
+						end_line: 3,
+					},
+					{
+						path: "/tmp/valid-b.ts",
+					},
+				],
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual([
+			{
+				query: "/tmp/valid-a.ts:1-2",
+				result: "content for /tmp/valid-a.ts",
+				success: true,
+			},
+			{
+				query: "/tmp/reversed.ts:5-3",
+				result: "",
+				error:
+					"Invalid file range: start_line must be less than or equal to end_line (received start_line: 5, end_line: 3)",
+				success: false,
+			},
+			{
+				query: "/tmp/valid-b.ts",
+				result: "content for /tmp/valid-b.ts",
+				success: true,
+			},
+		]);
+		expect(execute).toHaveBeenCalledTimes(2);
+		expect(execute).toHaveBeenNthCalledWith(
+			1,
+			{
+				path: "/tmp/valid-a.ts",
+				start_line: 1,
+				end_line: 2,
+			},
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+		expect(execute).toHaveBeenNthCalledWith(
+			2,
+			{
+				path: "/tmp/valid-b.ts",
+			},
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("zod schema conversion", () => {
+	it("advertises run_commands as string-only command arrays", () => {
+		const tool = createShellTool(async () => "ok");
+		const inputSchema = tool.inputSchema as Record<string, unknown>;
+		const serialized = JSON.stringify(inputSchema);
+
+		expect(serialized).not.toContain('"anyOf"');
+		expect(serialized).not.toContain("Prefer structured");
+		expect(hasSchemaKey(inputSchema, "command")).toBe(false);
+
+		const properties = inputSchema.properties as Record<string, unknown>;
+		const commands = properties.commands as {
+			items?: { type?: string };
+		};
+		expect(commands.items?.type).toBe("string");
+	});
+
+	it("preserves read_files required properties in generated JSON schema", () => {
+		const tool = createReadFilesTool(async () => "ok");
+		const inputSchema = tool.inputSchema as Record<string, unknown>;
+		const properties = inputSchema.properties as Record<string, unknown>;
+		expect(inputSchema.type).toBe("object");
+		expect(properties.files).toMatchObject({
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					path: {
+						type: "string",
+						description:
+							"The absolute file path of a text file to read content from",
+					},
+					start_line: {
+						anyOf: [{ type: "integer" }, { type: "null" }],
+						description:
+							"Optional one-based starting line number to read from; use null or omit for the start of the file",
+					},
+					end_line: {
+						anyOf: [{ type: "integer" }, { type: "null" }],
+						description:
+							"Optional one-based ending line number to read through; use null or omit to read to the end of the file or the read cap, whichever comes first",
+					},
+				},
+				required: ["path"],
+			},
+			description:
+				"Array of file read requests; each element is one file and must include path. Omit start_line/end_line or set them to null to read from the start; provide integers on the same object as the path to return only that inclusive one-based line range — never emit a range as its own array element. Reads are capped, so page through long files with start_line/end_line. Prefer this tool over running terminal command to get file content for better performance and reliability.",
+		});
+		expect(inputSchema.required).toEqual(["files"]);
+	});
+
+	it("exposes skills args as optional nullable in tool schemas", () => {
+		const tools = createDefaultTools({
+			executors: {
+				skills: createMockSkillsExecutor(),
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableApplyPatch: false,
+			enableAskQuestion: false,
+			enableSkills: true,
+		});
+		const skills = tools.find((tool) => tool.name === "skills");
+		expect(skills).toBeDefined();
+		if (!skills) {
+			throw new Error("Expected skills tool.");
+		}
+		const schema = skills.inputSchema as {
+			required?: string[];
+			properties?: Record<string, unknown>;
+		};
+		expect(schema.required).toEqual(["skill"]);
+		expect(schema.properties).toHaveProperty("args");
+	});
+});
+
+describe("default editor tool", () => {
+	it("accepts replacement edits without insert fields", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		const result = await editorTool.execute(
+			{
+				path: "/tmp/example.ts",
+				old_text: "before",
+				new_text: "after",
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "edit:/tmp/example.ts",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			expect.objectContaining({
+				path: "/tmp/example.ts",
+				old_text: "before",
+				new_text: "after",
+			}),
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+
+	it("allows edit without old_text so missing files can be created", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		const result = await editorTool.execute(
+			{
+				path: "/tmp/example.ts",
+				new_text: "created",
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "edit:/tmp/example.ts",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			expect.objectContaining({
+				path: "/tmp/example.ts",
+				new_text: "created",
+			}),
+			process.cwd(),
+			expect.anything(),
+		);
+	});
+
+	it("treats insert_line as an insert operation", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		const result = await editorTool.execute(
+			{
+				path: "/tmp/example.ts",
+				new_text: "after",
+				insert_line: 3,
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "insert:/tmp/example.ts",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			expect.objectContaining({
+				path: "/tmp/example.ts",
+				new_text: "after",
+				insert_line: 3,
+			}),
+			process.cwd(),
+			expect.anything(),
+		);
+	});
+
+	it("returns a recoverable tool error when text exceeds the soft character limit", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		const oversizedText = "x".repeat(INPUT_ARG_CHAR_LIMIT + 1);
+		const result = await editorTool.execute(
+			{
+				path: "/tmp/example.ts",
+				new_text: oversizedText,
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "edit:/tmp/example.ts",
+			result: "",
+			error: expect.stringContaining("new_text was"),
+			success: false,
+		});
+		if (typeof result !== "object" || result == null || !("error" in result)) {
+			throw new Error("Expected editor tool result to include an error.");
+		}
+		expect(result.error).toContain(
+			`recommended limit of ${INPUT_ARG_CHAR_LIMIT}`,
+		);
+		expect(execute).not.toHaveBeenCalled();
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/definitions.ts b/sdk/packages/core/src/extensions/tools/definitions.ts
new file mode 100644
index 0000000..cd85c3a
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/definitions.ts
@@ -0,0 +1,876 @@
+/**
+ * Default AgentTool Definitions
+ *
+ * Factory functions for creating the default tools.
+ */
+
+import {
+	type AgentTool,
+	type AgentToolContext,
+	createTool,
+	validateWithZod,
+	zodToJsonSchema,
+} from "@cline/shared";
+import { captureRunCommandsTimeout } from "../../services/telemetry/core-events";
+import { getToolContextTelemetry } from "../../services/telemetry/tool-context";
+import { CommandExitError } from "./executors/bash";
+import {
+	MAX_COMMAND_OUTPUT_CHARS,
+	MAX_READ_LINES,
+	MAX_READ_OUTPUT_CHARS,
+	MAX_SEARCH_OUTPUT_CHARS,
+} from "./executors/output-limits";
+import {
+	coalesceOrphanReadRanges,
+	formatError,
+	formatReadFileQuery,
+	formatRunCommandQueryPreview,
+	getEditorSizeError,
+	getReadFileRangeError,
+	normalizeRunCommandsInput,
+	TimeoutError,
+	withTimeout,
+} from "./helpers";
+import {
+	type ApplyPatchInput,
+	ApplyPatchInputSchema,
+	ApplyPatchInputUnionSchema,
+	type AskQuestionInput,
+	AskQuestionInputSchema,
+	type EditFileInput,
+	EditFileInputSchema,
+	type FetchWebContentInput,
+	FetchWebContentInputSchema,
+	type ReadFileRequest,
+	type ReadFilesInput,
+	ReadFilesInputSchema,
+	ReadFilesInputUnionSchema,
+	RunCommandsInputSchema,
+	type SearchCodebaseInput,
+	SearchCodebaseInputSchema,
+	SearchCodebaseUnionInputSchema,
+	type SkillsInput,
+	SkillsInputSchema,
+	type StructuredCommandInput,
+	type SubmitInput,
+	SubmitInputSchema,
+} from "./schemas";
+import type {
+	ApplyPatchExecutor,
+	AskQuestionExecutor,
+	CreateDefaultToolsOptions,
+	DefaultToolsConfig,
+	EditorExecutor,
+	FileReadExecutor,
+	SearchExecutor,
+	ShellExecutor,
+	SkillsExecutorWithMetadata,
+	ToolOperationResult,
+	VerifySubmitExecutor,
+	WebFetchExecutor,
+} from "./types";
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+function getStringMetadata(
+	context: AgentToolContext,
+	key: string,
+): string | undefined {
+	const value = context.metadata?.[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+function captureRunCommandsTimeoutFromContext(
+	context: AgentToolContext,
+	properties: {
+		effectiveTimeoutMs: number;
+		timeoutSource: "default_setting" | "configured_setting";
+		commandCount: number;
+		durationMs: number;
+	},
+): void {
+	captureRunCommandsTimeout(getToolContextTelemetry(context.metadata), {
+		tool_name: "run_commands",
+		effective_timeout_ms: properties.effectiveTimeoutMs,
+		timeout_source: properties.timeoutSource,
+		command_count: properties.commandCount,
+		duration_ms: properties.durationMs,
+		ulid: context.sessionId,
+		mode: getStringMetadata(context, "mode"),
+		source: getStringMetadata(context, "source"),
+		session_id: context.sessionId,
+		agent_id: context.agentId,
+		conversation_id: context.conversationId,
+		run_id: context.runId,
+		iteration: context.iteration,
+		tool_call_id: context.toolCallId,
+	});
+}
+
+function getHeredocDelimiter(command: string): string | undefined {
+	const match = command.match(
+		/(?<![<])<<-?\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_./-]+))/,
+	);
+	return match?.[1] ?? match?.[2] ?? match?.[3];
+}
+
+function coalesceSplitHeredocCommands(commands: string[]): string[] {
+	const coalesced: string[] = [];
+	for (let index = 0; index < commands.length; index += 1) {
+		const command = commands[index];
+		const delimiter = getHeredocDelimiter(command);
+		if (!delimiter) {
+			coalesced.push(command);
+			continue;
+		}
+
+		const endIndex = commands.findIndex(
+			(nextCommand, nextIndex) =>
+				nextIndex > index && nextCommand.trim() === delimiter,
+		);
+		if (endIndex === -1) {
+			coalesced.push(command);
+			continue;
+		}
+
+		const parts = [command];
+		while (index < endIndex) {
+			index += 1;
+			const nextCommand = commands[index];
+			parts.push(nextCommand);
+		}
+		coalesced.push(parts.join("\n"));
+	}
+	return coalesced;
+}
+
+function coalesceAdjacentStringHeredocs(
+	commands: Array<string | StructuredCommandInput>,
+): Array<string | StructuredCommandInput> {
+	const coalesced: Array<string | StructuredCommandInput> = [];
+	let stringRun: string[] = [];
+
+	const flushStringRun = () => {
+		if (stringRun.length > 0) {
+			coalesced.push(...coalesceSplitHeredocCommands(stringRun));
+			stringRun = [];
+		}
+	};
+
+	for (const command of commands) {
+		if (typeof command === "string") {
+			stringRun.push(command);
+			continue;
+		}
+
+		flushStringRun();
+		coalesced.push(command);
+	}
+
+	flushStringRun();
+	return coalesced;
+}
+
+async function executeShellCommands(
+	commands: Array<string | StructuredCommandInput>,
+	options: {
+		executor: ShellExecutor;
+		cwd: string;
+		context: AgentToolContext;
+		timeoutMs: number;
+		timeoutSource: "default_setting" | "configured_setting";
+	},
+): Promise<ToolOperationResult[]> {
+	const { executor, cwd, context, timeoutMs, timeoutSource } = options;
+
+	return Promise.all(
+		commands.map(async (command): Promise<ToolOperationResult> => {
+			const startedAt = Date.now();
+			const query = formatRunCommandQueryPreview(command);
+			try {
+				const output = await withTimeout(
+					executor(command, cwd, context),
+					timeoutMs,
+					`Command timed out after ${timeoutMs}ms`,
+				);
+				return {
+					query,
+					result: output,
+					success: true,
+				};
+			} catch (error) {
+				if (error instanceof TimeoutError) {
+					captureRunCommandsTimeoutFromContext(context, {
+						effectiveTimeoutMs: error.timeoutMs,
+						timeoutSource,
+						commandCount: commands.length,
+						durationMs: Date.now() - startedAt,
+					});
+				}
+				if (error instanceof CommandExitError) {
+					return {
+						query,
+						result: error.output,
+						error: error.message,
+						success: false,
+					};
+				}
+				const msg = formatError(error);
+				return {
+					query,
+					result: "",
+					error: `Command failed: ${msg}`,
+					success: false,
+				};
+			}
+		}),
+	);
+}
+
+// =============================================================================
+// AgentTool Factory Functions
+// =============================================================================
+
+/**
+ * Create the read_files tool
+ *
+ * Reads the content of one or more files from the filesystem.
+ */
+export function createReadFilesTool(
+	executor: FileReadExecutor,
+	config: Pick<DefaultToolsConfig, "fileReadTimeoutMs"> = {},
+): AgentTool<ReadFilesInput, ToolOperationResult[]> {
+	const timeoutMs = config.fileReadTimeoutMs ?? 10000;
+
+	return createTool<ReadFilesInput, ToolOperationResult[]>({
+		name: "read_files",
+		description:
+			"Read the content of text or image files at the provided absolute paths, or return only an inclusive one-based line range when start_line/end_line are provided on the same file entry as its path. " +
+			"When you already know multiple files you need, read them together in one call, and call this tool in the same response as other independent tool calls. " +
+			`Each read returns at most ${MAX_READ_LINES} lines / ~${Math.round(MAX_READ_OUTPUT_CHARS / 1024)}k characters; longer files report their total line count, page through them with start_line/end_line on that file's entry. ` +
+			"Binary files that are not image and large files are not supported. " +
+			"Returns file contents or error messages for each path. ",
+		inputSchema: zodToJsonSchema(ReadFilesInputSchema),
+		timeoutMs: timeoutMs * 2, // Account for multiple files
+		retryable: true,
+		maxRetries: 1,
+		execute: async (input, context) => {
+			const validate = validateWithZod(
+				ReadFilesInputUnionSchema,
+				coalesceOrphanReadRanges(input),
+			);
+			let requests: ReadFileRequest[];
+			if (typeof validate === "string") {
+				requests = [{ path: validate }];
+			} else if (Array.isArray(validate)) {
+				requests = validate.map((value) =>
+					typeof value === "string" ? { path: value } : value,
+				);
+			} else if ("files" in validate) {
+				const files = Array.isArray(validate.files)
+					? validate.files
+					: [validate.files];
+				requests = files.map((file) =>
+					typeof file === "string" ? { path: file } : file,
+				);
+			} else if ("file_paths" in validate) {
+				const filePaths = Array.isArray(validate.file_paths)
+					? validate.file_paths
+					: [validate.file_paths];
+				requests = filePaths.map((path) => ({ path }));
+			} else if ("paths" in validate) {
+				const paths = Array.isArray(validate.paths)
+					? validate.paths
+					: [validate.paths];
+				requests = paths.map((path) =>
+					typeof path === "string" ? { path } : path,
+				);
+			} else {
+				requests = [validate];
+			}
+
+			return Promise.all(
+				requests.map(async (request): Promise<ToolOperationResult> => {
+					const rangeError = getReadFileRangeError(request);
+					if (rangeError) {
+						return {
+							query: formatReadFileQuery(request),
+							result: "",
+							error: `Invalid file range: ${rangeError}`,
+							success: false,
+						};
+					}
+
+					try {
+						const content = await withTimeout(
+							executor(request, context),
+							timeoutMs,
+							`File read timed out after ${timeoutMs}ms`,
+						);
+						return {
+							query: formatReadFileQuery(request),
+							result: content,
+							success: true,
+						};
+					} catch (error) {
+						const msg = formatError(error);
+						return {
+							query: formatReadFileQuery(request),
+							result: "",
+							error: `Error reading file: ${msg}`,
+							success: false,
+						};
+					}
+				}),
+			);
+		},
+	});
+}
+
+/**
+ * Create the search_codebase tool
+ *
+ * Performs regex pattern searches across the codebase.
+ */
+export function createSearchTool(
+	executor: SearchExecutor,
+	config: Pick<DefaultToolsConfig, "cwd" | "searchTimeoutMs"> = {},
+): AgentTool<SearchCodebaseInput, ToolOperationResult[]> {
+	const timeoutMs = config.searchTimeoutMs ?? 30000;
+	const cwd = config.cwd ?? process.cwd();
+
+	return createTool<SearchCodebaseInput, ToolOperationResult[]>({
+		name: "search_codebase",
+		description:
+			"Perform regex pattern searches across the codebase. " +
+			"Supports multiple parallel searches. When several search patterns could be useful and do not depend on each other, run them together in one call, and call this tool in the same response as other independent tool calls. " +
+			"Use for finding code patterns, function definitions, class names, imports, etc. " +
+			`Output beyond ~${Math.round(MAX_SEARCH_OUTPUT_CHARS / 1000)}k characters per query is middle-truncated; narrow patterns beat broad ones.`,
+		inputSchema: zodToJsonSchema(SearchCodebaseInputSchema),
+		timeoutMs: timeoutMs * 2,
+		retryable: true,
+		maxRetries: 1,
+		execute: async (input, context) => {
+			// Validate input with Zod schema
+			const validate = validateWithZod(SearchCodebaseUnionInputSchema, input);
+			const queries = Array.isArray(validate)
+				? validate
+				: typeof validate === "object"
+					? Array.isArray(validate.queries)
+						? validate.queries
+						: [validate.queries]
+					: [validate];
+
+			return Promise.all(
+				queries.map(async (query): Promise<ToolOperationResult> => {
+					try {
+						const results = await withTimeout(
+							executor(query, cwd, context),
+							timeoutMs,
+							`Search timed out after ${timeoutMs}ms`,
+						);
+						return {
+							query,
+							result: results,
+							success: true,
+						};
+					} catch (error) {
+						const msg = formatError(error);
+						return {
+							query,
+							result: "",
+							error: `Search failed: ${msg}`,
+							success: false,
+						};
+					}
+				}),
+			);
+		},
+	});
+}
+
+const RUN_COMMANDS_SHARED_INSTRUCTIONS =
+	"Use for listing files, checking git status, running builds, executing tests, etc. " +
+	"Commands must be non-interactive. Commands that require follow-up input like pagers should be skipped or used with supported flags/env (e.g. git --no-pager, --non-interactive) to bypass the interaction steps. ";
+
+/**
+ * Create the run_commands shell tool for the current platform.
+ *
+ * This preserves the SDK's platform-specific prompting/schema choices while
+ * exposing a single generic shell-tool factory for host integrations.
+ */
+export function createShellTool(
+	executor: ShellExecutor,
+	config: Pick<DefaultToolsConfig, "cwd" | "bashTimeoutMs"> = {},
+): AgentTool<unknown, ToolOperationResult[]> {
+	const timeoutMs = config.bashTimeoutMs ?? 30000;
+	const timeoutSource =
+		config.bashTimeoutMs === undefined
+			? "default_setting"
+			: "configured_setting";
+	const cwd = config.cwd ?? process.cwd();
+	const isWindows = process.platform === "win32";
+
+	return createTool<unknown, ToolOperationResult[]>({
+		name: "run_commands",
+		description: isWindows
+			? "Run non-interactive shell commands from the root of the workspace in Windows environment. " +
+				RUN_COMMANDS_SHARED_INSTRUCTIONS +
+				`Output beyond ~${Math.round(MAX_COMMAND_OUTPUT_CHARS / 1000)}k characters is middle-truncated (start and end preserved); filter output when you need specific sections. ` +
+				"Commands run through PowerShell; quote paths and arguments for PowerShell and use ';' to sequence commands. Include multiple commands in the same call when they are independent and safe to run concurrently. When independent reads, searches, or edits are also needed, call those tools in the same response."
+			: "Run non-interactive shell commands from the root of the workspace. " +
+				RUN_COMMANDS_SHARED_INSTRUCTIONS +
+				"Commands should be properly shell-escaped and targeted to avoid error or timeout. Include multiple commands in the same call when they are independent complete shell commands and safe to run concurrently; multiline scripts and heredocs must be a single command string. When independent reads, searches, or edits are also needed, call those tools in the same response. " +
+				`Output beyond ~${Math.round(MAX_COMMAND_OUTPUT_CHARS / 1000)}k characters is middle-truncated (start and end preserved); pipe through grep/head/tail when you need specific sections of large output. ` +
+				"For long-running commands, run them in background and redirect output to a tmp file that you can read from later.",
+		inputSchema: zodToJsonSchema(RunCommandsInputSchema),
+		timeoutMs: timeoutMs * 2,
+		retryable: false,
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const commands = coalesceAdjacentStringHeredocs(
+				normalizeRunCommandsInput(input),
+			);
+
+			return executeShellCommands(commands, {
+				executor,
+				cwd,
+				context,
+				timeoutMs,
+				timeoutSource,
+			});
+		},
+	});
+}
+
+/**
+ * Create the fetch_web_content tool
+ *
+ * Fetches content from URLs and analyzes them using provided prompts.
+ */
+export function createWebFetchTool(
+	executor: WebFetchExecutor,
+	config: Pick<DefaultToolsConfig, "webFetchTimeoutMs"> = {},
+): AgentTool<FetchWebContentInput, ToolOperationResult[]> {
+	const timeoutMs = config.webFetchTimeoutMs ?? 30000;
+
+	return createTool<FetchWebContentInput, ToolOperationResult[]>({
+		name: "fetch_web_content",
+		description:
+			"Fetch content from URLs and analyze them using the provided prompts. " +
+			"Use for retrieving documentation, API references, or any web content. " +
+			"Each request includes a URL and a prompt describing what information to extract. Fetch independent URLs together in one call, and call this tool in the same response as other independent tool calls.",
+		inputSchema: zodToJsonSchema(FetchWebContentInputSchema),
+		timeoutMs: timeoutMs * 2,
+		retryable: true,
+		maxRetries: 2,
+		execute: async (input, context) => {
+			// Validate input with Zod schema
+			const validatedInput = validateWithZod(FetchWebContentInputSchema, input);
+
+			return Promise.all(
+				validatedInput.requests.map(
+					async (request): Promise<ToolOperationResult> => {
+						try {
+							const content = await withTimeout(
+								executor(request.url, request.prompt, context),
+								timeoutMs,
+								`Web fetch timed out after ${timeoutMs}ms`,
+							);
+							return {
+								query: request.url,
+								result: content,
+								success: true,
+							};
+						} catch (error) {
+							const msg = formatError(error);
+							return {
+								query: request.url,
+								result: "",
+								error: `Error fetching web content: ${msg}`,
+								success: false,
+							};
+						}
+					},
+				),
+			);
+		},
+	});
+}
+
+const APPLY_PATCH_TOOL_DESC = `Use \`apply_patch\` to edit files with the canonical freeform patch grammar. Pass the patch text directly as the \`input\` string. Prefer the exact format below:
+
+*** Begin Patch
+*** Update File: path/to/file.ts
+@@ optional section marker
+ [context before]
+-[old line]
++[new line]
+ [context after]
+*** End Patch
+
+Supported actions:
+- \`*** Add File: <path>\`
+- \`*** Update File: <path>\`
+- \`*** Delete File: <path>\`
+- optional \`*** Move to: <new path>\` immediately after an Update File header
+
+Rules:
+- In an Add File section, every file-content line must start with \`+\`.
+- In an Update section, use context lines plus \`-\` and \`+\` lines to describe the change.
+- Use \`@@\` markers when extra context is needed to disambiguate repeated code blocks.
+- Do not use line numbers; this format is context-based.
+- Prefer sending the patch body directly. Legacy shell wrappers such as \`%%bash\` and \`apply_patch <<"EOF"\` are accepted for compatibility but are not preferred.
+
+Example:
+
+*** Begin Patch
+*** Update File: src/page.tsx
+@@
+   return (
+     <div>
+       <button onClick={() => console.log("clicked")}>Click me</button>
++      <button onClick={() => console.log("cancel clicked")}>Cancel</button>
+     </div>
+   );
+ }
+*** End Patch`;
+
+/**
+ * Create the apply_patch tool
+ *
+ * Applies the canonical apply_patch format to one or more files.
+ */
+export function createApplyPatchTool(
+	executor: ApplyPatchExecutor,
+	config: Pick<DefaultToolsConfig, "cwd" | "applyPatchTimeoutMs"> = {},
+): AgentTool<ApplyPatchInput, ToolOperationResult> {
+	const timeoutMs = config.applyPatchTimeoutMs ?? 30000;
+	const cwd = config.cwd ?? process.cwd();
+
+	return createTool<ApplyPatchInput, ToolOperationResult>({
+		name: "apply_patch",
+		description: APPLY_PATCH_TOOL_DESC,
+		inputSchema: zodToJsonSchema(ApplyPatchInputSchema),
+		timeoutMs,
+		retryable: false,
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const validate = validateWithZod(ApplyPatchInputUnionSchema, input);
+			const patchInput =
+				typeof validate === "string" ? validate : validate.input;
+
+			try {
+				const result = await withTimeout(
+					executor({ input: patchInput }, cwd, context),
+					timeoutMs,
+					`apply_patch timed out after ${timeoutMs}ms`,
+				);
+
+				return {
+					query: "apply_patch",
+					result,
+					success: true,
+				};
+			} catch (error) {
+				const msg = formatError(error);
+				return {
+					query: "apply_patch",
+					result: "",
+					error: `apply_patch failed: ${msg}`,
+					success: false,
+				};
+			}
+		},
+	});
+}
+
+/**
+ * Create the editor tool
+ *
+ * Supports controlled filesystem edits with create, replace, and insert commands.
+ */
+export function createEditorTool(
+	executor: EditorExecutor,
+	config: Pick<DefaultToolsConfig, "cwd" | "editorTimeoutMs"> = {},
+): AgentTool<EditFileInput, ToolOperationResult> {
+	const timeoutMs = config.editorTimeoutMs ?? 30000;
+	const cwd = config.cwd ?? process.cwd();
+
+	return createTool<EditFileInput, ToolOperationResult>({
+		name: "editor",
+		description:
+			"An editor for controlled filesystem edits on the text file at the provided path. " +
+			"Provide `insert_line` to insert `new_text` at a specific line number. " +
+			"Otherwise, the tool replaces `old_text` with `new_text`, or creates the file with `new_text` if file does not exist. " +
+			"Use this tool for making small, precise edits to existing files or creating new files over shell commands. If several edits to different files or non-overlapping regions are already known, emit multiple editor tool calls in the same response instead of serializing them across turns.",
+
+		inputSchema: zodToJsonSchema(EditFileInputSchema),
+		timeoutMs,
+		retryable: false, // Editing operations are stateful and should not auto-retry
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const validatedInput = validateWithZod(EditFileInputSchema, input);
+			const operation = validatedInput.insert_line == null ? "edit" : "insert";
+			const sizeError = getEditorSizeError(validatedInput);
+
+			if (sizeError) {
+				return {
+					query: `${operation}:${validatedInput.path}`,
+					result: "",
+					error: sizeError,
+					success: false,
+				};
+			}
+
+			try {
+				const result = await withTimeout(
+					executor(validatedInput, cwd, context),
+					timeoutMs,
+					`Editor operation timed out after ${timeoutMs}ms`,
+				);
+
+				return {
+					query: `${operation}:${validatedInput.path}`,
+					result,
+					success: true,
+				};
+			} catch (error) {
+				const msg = formatError(error);
+				return {
+					query: `${operation}:${validatedInput.path}`,
+					result: "",
+					error: `Editor operation failed: ${msg}`,
+					success: false,
+				};
+			}
+		},
+	});
+}
+
+/**
+ * Create the skills tool
+ *
+ * Invokes a configured skill by name and optional arguments.
+ */
+export function createSkillsTool(
+	executor: SkillsExecutorWithMetadata,
+	config: Pick<DefaultToolsConfig, "skillsTimeoutMs"> = {},
+): AgentTool<SkillsInput, string> {
+	const timeoutMs = config.skillsTimeoutMs ?? 15000;
+
+	const baseDescription =
+		"Execute a skill within the main conversation. " +
+		"When users ask you to perform tasks, check if any available skills match. " +
+		"When users reference a slash command, invoke it with this tool. " +
+		'Input: `skill` (required) and optional `args`. Example: `skill: "pdf"`, `skill: "commit", args: "-m \\"Fix bug\\""`, `skill: "review-pr", args: "123"`, `skill: "ms-office-suite:pdf"`. ' +
+		"When a skill matches the user's request, invoking this tool is a blocking requirement before any other response. " +
+		"Never mention a skill without invoking this tool.";
+
+	const tool = createTool<SkillsInput, string>({
+		name: "skills",
+		description: baseDescription,
+		inputSchema: zodToJsonSchema(SkillsInputSchema),
+		timeoutMs,
+		retryable: false,
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const validatedInput = validateWithZod(SkillsInputSchema, input);
+			return withTimeout(
+				executor(
+					validatedInput.skill,
+					validatedInput.args || undefined,
+					context,
+				),
+				timeoutMs,
+				`Skills operation timed out after ${timeoutMs}ms`,
+			);
+		},
+	});
+
+	Object.defineProperty(tool, "description", {
+		get() {
+			const skills = executor.configuredSkills
+				?.filter((s) => !s.disabled)
+				.map((s) => s.name);
+			if (skills && skills.length > 0) {
+				return `${baseDescription} Available skills: ${skills.join(", ")}.`;
+			}
+			return baseDescription;
+		},
+		enumerable: true,
+		configurable: true,
+	});
+
+	return tool;
+}
+
+/**
+ * Create the ask_question tool
+ *
+ * Asks the user a single clarifying question with 2-5 selectable options.
+ */
+export function createAskQuestionTool(
+	executor: AskQuestionExecutor,
+): AgentTool<AskQuestionInput, string> {
+	return {
+		name: "ask_question",
+		description:
+			"Ask user a question for clarifying or gathering information needed to complete the task. " +
+			"For example, ask the user clarifying questions about a key implementation decision. " +
+			"You should only ask one question. " +
+			"Provide an array of 2-5 options for the user to choose from. " +
+			"Never include an option to toggle to Act mode.",
+		inputSchema: zodToJsonSchema(AskQuestionInputSchema),
+		retryable: false,
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const validatedInput = validateWithZod(AskQuestionInputSchema, input);
+			return executor(validatedInput.question, validatedInput.options, context);
+		},
+	};
+}
+
+export function createSubmitAndExitTool(
+	executor: VerifySubmitExecutor,
+	config: Pick<DefaultToolsConfig, "submitTimeoutMs"> = {},
+): AgentTool<SubmitInput, string> {
+	const timeoutMs = config.submitTimeoutMs ?? 15000;
+
+	return createTool<SubmitInput, string>({
+		name: "submit_and_exit",
+		description:
+			"Submit the final answer and exit the conversation. " +
+			"For example, submit a summary of the investigation and confirm the issue is resolved. " +
+			"You should only submit once all necessary steps are completed. " +
+			"Make sure to verify your output matches the expected format, data types, and file locations specified. " +
+			"Provide a summary of the investigation and confirm the issue is resolved.",
+		inputSchema: zodToJsonSchema(SubmitInputSchema),
+		lifecycle: {
+			completesRun: true,
+		},
+		timeoutMs,
+		retryable: false,
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const validatedInput = validateWithZod(SubmitInputSchema, input);
+			return withTimeout(
+				executor(validatedInput.summary, validatedInput.verified, context),
+				timeoutMs,
+				`submit_and_exit timed out after ${timeoutMs}ms`,
+			);
+		},
+	});
+}
+
+// =============================================================================
+// Default Tools Factory
+// =============================================================================
+
+/**
+ * Create a set of default tools for an agent
+ *
+ * This function creates the default tools based on the provided configuration
+ * and executors. Only tools that are enabled AND have an executor provided
+ * will be included in the returned array.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, createDefaultTools } from "@cline/core"
+ * import * as fs from "fs/promises"
+ * import { exec } from "child_process"
+ *
+ * const tools = createDefaultTools({
+ *   executors: {
+ *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
+ *     bash: async (cmd, cwd) => {
+ *       return new Promise((resolve, reject) => {
+ *         exec(cmd, { cwd }, (err, stdout, stderr) => {
+ *           if (err) reject(new Error(stderr || err.message))
+ *           else resolve(stdout)
+ *         })
+ *       })
+ *     },
+ *   },
+ *   enableReadFiles: true,
+ *   enableBash: true,
+ *   enableSearch: false, // Disabled
+ *   enableWebFetch: false, // Disabled
+ *   cwd: "/path/to/project",
+ * })
+ *
+ * const agent = new Agent({
+ *   // ... provider config
+ *   tools,
+ * })
+ * ```
+ */
+export function createDefaultTools(
+	options: CreateDefaultToolsOptions,
+): AgentTool[] {
+	const {
+		executors,
+		enableReadFiles = true,
+		enableSearch = true,
+		enableBash = true,
+		enableWebFetch = true,
+		enableApplyPatch = false,
+		enableEditor = true,
+		enableSkills = true,
+		enableAskQuestion = true,
+		enableSubmitAndExit = false,
+		...config
+	} = options;
+
+	const tools: AgentTool<never, unknown>[] = [];
+
+	// Add read_files tool if enabled and executor provided
+	if (enableReadFiles && executors.readFile) {
+		tools.push(createReadFilesTool(executors.readFile, config));
+	}
+
+	// Add search_codebase tool if enabled and executor provided
+	if (enableSearch && executors.search) {
+		tools.push(createSearchTool(executors.search, config));
+	}
+
+	// Add run_commands tool if enabled and executor provided
+	if (enableBash && executors.bash) {
+		tools.push(createShellTool(executors.bash, config));
+	}
+
+	// Add fetch_web_content tool if enabled and executor provided
+	if (enableWebFetch && executors.webFetch) {
+		tools.push(createWebFetchTool(executors.webFetch, config));
+	}
+
+	// Add editor tool if enabled and executor provided,
+	// else check if apply_patch tool is enabled and executor provided
+	// NOTE: Do not enable two similar tools at the same time.
+	if (enableEditor && executors.editor) {
+		tools.push(createEditorTool(executors.editor, config));
+	} else if (enableApplyPatch && executors.applyPatch) {
+		tools.push(createApplyPatchTool(executors.applyPatch, config));
+	}
+
+	// Add skills tool if enabled and executor provided
+	if (enableSkills && executors.skills) {
+		tools.push(createSkillsTool(executors.skills, config));
+	}
+
+	const submitExecutor = enableSubmitAndExit ? executors.submit : undefined;
+
+	// Add ask_question tool if enabled and executor provided
+	if (enableAskQuestion && executors.askQuestion && !submitExecutor) {
+		tools.push(createAskQuestionTool(executors.askQuestion));
+	}
+
+	// Add submit_and_exit tool if enabled and executor provided
+	if (submitExecutor) {
+		tools.push(createSubmitAndExitTool(submitExecutor, config));
+	}
+
+	return tools as unknown as AgentTool[];
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/apply-patch-parser.ts b/sdk/packages/core/src/extensions/tools/executors/apply-patch-parser.ts
new file mode 100644
index 0000000..e81ac4d
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/apply-patch-parser.ts
@@ -0,0 +1,520 @@
+/**
+ * Apply Patch parser and patch model types.
+ *
+ * This parser supports the Cline apply_patch format used by the legacy runtime.
+ */
+
+export const PATCH_MARKERS = {
+	BEGIN: "*** Begin Patch",
+	END: "*** End Patch",
+	ADD: "*** Add File: ",
+	UPDATE: "*** Update File: ",
+	DELETE: "*** Delete File: ",
+	MOVE: "*** Move to: ",
+	SECTION: "@@",
+	END_FILE: "*** End of File",
+} as const;
+
+export const BASH_WRAPPERS = ["%%bash", "apply_patch", "EOF", "```"] as const;
+
+export enum PatchActionType {
+	ADD = "add",
+	DELETE = "delete",
+	UPDATE = "update",
+}
+
+export interface PatchChunk {
+	origIndex: number;
+	delLines: string[];
+	insLines: string[];
+}
+
+export interface PatchAction {
+	type: PatchActionType;
+	newFile?: string;
+	chunks: PatchChunk[];
+	movePath?: string;
+}
+
+export interface PatchWarning {
+	path: string;
+	chunkIndex?: number;
+	message: string;
+	context?: string;
+}
+
+export interface Patch {
+	actions: Record<string, PatchAction>;
+	warnings?: PatchWarning[];
+}
+
+export class DiffError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "DiffError";
+	}
+}
+
+function canonicalize(input: string): string {
+	const punctuationMap: Record<string, string> = {
+		"\u2010": "-",
+		"\u2011": "-",
+		"\u2012": "-",
+		"\u2013": "-",
+		"\u2014": "-",
+		"\u2212": "-",
+		"\u201C": '"',
+		"\u201D": '"',
+		"\u201E": '"',
+		"\u00AB": '"',
+		"\u00BB": '"',
+		"\u2018": "'",
+		"\u2019": "'",
+		"\u201B": "'",
+		"\u00A0": " ",
+		"\u202F": " ",
+	};
+	return input
+		.normalize("NFC")
+		.replace(/./gu, (char) => punctuationMap[char] ?? char)
+		.replace(/\\`/g, "`")
+		.replace(/\\'/g, "'")
+		.replace(/\\"/g, '"');
+}
+
+export class PatchParser {
+	private patch: Patch = { actions: {}, warnings: [] };
+	private index = 0;
+	private fuzz = 0;
+	private currentPath?: string;
+
+	constructor(
+		private readonly lines: string[],
+		private readonly currentFiles: Record<string, string>,
+	) {}
+
+	parse(): { patch: Patch; fuzz: number } {
+		this.skipBeginSentinel();
+
+		while (this.hasMoreLines() && !this.isEndMarker()) {
+			this.parseNextAction();
+		}
+
+		if (this.patch.warnings?.length === 0) {
+			delete this.patch.warnings;
+		}
+
+		return { patch: this.patch, fuzz: this.fuzz };
+	}
+
+	private addWarning(warning: PatchWarning): void {
+		if (!this.patch.warnings) {
+			this.patch.warnings = [];
+		}
+		this.patch.warnings.push(warning);
+	}
+
+	private skipBeginSentinel(): void {
+		if (this.lines[this.index]?.startsWith(PATCH_MARKERS.BEGIN)) {
+			this.index++;
+		}
+	}
+
+	private hasMoreLines(): boolean {
+		return this.index < this.lines.length;
+	}
+
+	private isEndMarker(): boolean {
+		return this.lines[this.index]?.startsWith(PATCH_MARKERS.END) ?? false;
+	}
+
+	private parseNextAction(): void {
+		const line = this.lines[this.index];
+		if (line?.startsWith(PATCH_MARKERS.UPDATE)) {
+			this.parseUpdate(line.substring(PATCH_MARKERS.UPDATE.length).trim());
+			return;
+		}
+		if (line?.startsWith(PATCH_MARKERS.DELETE)) {
+			this.parseDelete(line.substring(PATCH_MARKERS.DELETE.length).trim());
+			return;
+		}
+		if (line?.startsWith(PATCH_MARKERS.ADD)) {
+			this.parseAdd(line.substring(PATCH_MARKERS.ADD.length).trim());
+			return;
+		}
+		throw new DiffError(`Unknown line while parsing: ${line}`);
+	}
+
+	private checkDuplicate(path: string, operation: string): void {
+		if (path in this.patch.actions) {
+			throw new DiffError(`Duplicate ${operation} for file: ${path}`);
+		}
+	}
+
+	private parseUpdate(path: string): void {
+		this.checkDuplicate(path, "update");
+		this.currentPath = path;
+
+		this.index++;
+		const movePath = this.lines[this.index]?.startsWith(PATCH_MARKERS.MOVE)
+			? (this.lines[this.index++] ?? "")
+					.substring(PATCH_MARKERS.MOVE.length)
+					.trim()
+			: undefined;
+
+		if (!(path in this.currentFiles)) {
+			throw new DiffError(`Update File Error: Missing File: ${path}`);
+		}
+
+		const text = this.currentFiles[path] ?? "";
+		const action = this.parseUpdateFile(text, path);
+		action.movePath = movePath;
+		this.patch.actions[path] = action;
+		this.currentPath = undefined;
+	}
+
+	private parseUpdateFile(text: string, path: string): PatchAction {
+		const action: PatchAction = { type: PatchActionType.UPDATE, chunks: [] };
+		const fileLines = text.split("\n");
+		let index = 0;
+
+		const stopMarkers = [
+			PATCH_MARKERS.END,
+			PATCH_MARKERS.UPDATE,
+			PATCH_MARKERS.DELETE,
+			PATCH_MARKERS.ADD,
+			PATCH_MARKERS.END_FILE,
+		];
+
+		while (
+			!stopMarkers.some((marker) =>
+				this.lines[this.index]?.startsWith(marker.trim()),
+			)
+		) {
+			const currentLine = this.lines[this.index];
+			const defStr = currentLine?.startsWith("@@ ")
+				? currentLine.substring(3)
+				: undefined;
+			const sectionStr = currentLine === "@@" ? currentLine : undefined;
+
+			if (defStr !== undefined || sectionStr !== undefined) {
+				this.index++;
+			} else if (index !== 0) {
+				throw new DiffError(`Invalid Line:\n${this.lines[this.index]}`);
+			}
+
+			if (defStr?.trim()) {
+				const canonDefStr = canonicalize(defStr.trim());
+				for (let i = index; i < fileLines.length; i++) {
+					const fileLine = fileLines[i];
+					if (
+						fileLine &&
+						(canonicalize(fileLine) === canonDefStr ||
+							canonicalize(fileLine.trim()) === canonDefStr)
+					) {
+						index = i + 1;
+						if (
+							canonicalize(fileLine.trim()) === canonDefStr &&
+							canonicalize(fileLine) !== canonDefStr
+						) {
+							this.fuzz++;
+						}
+						break;
+					}
+				}
+			}
+
+			const [nextChunkContext, chunks, endPatchIndex, eof] = peek(
+				this.lines,
+				this.index,
+			);
+			const [newIndex, fuzz, similarity] = findContext(
+				fileLines,
+				nextChunkContext,
+				index,
+				eof,
+			);
+
+			if (newIndex === -1) {
+				const contextText = nextChunkContext.join("\n");
+				this.addWarning({
+					path: this.currentPath || path,
+					chunkIndex: action.chunks.length,
+					message: `Could not find matching context (similarity: ${similarity.toFixed(2)}). Chunk skipped.`,
+					context:
+						contextText.length > 200
+							? `${contextText.substring(0, 200)}...`
+							: contextText,
+				});
+				this.index = endPatchIndex;
+			} else {
+				this.fuzz += fuzz;
+				for (const chunk of chunks) {
+					chunk.origIndex += newIndex;
+					action.chunks.push(chunk);
+				}
+				index = newIndex + nextChunkContext.length;
+				this.index = endPatchIndex;
+			}
+		}
+
+		return action;
+	}
+
+	private parseDelete(path: string): void {
+		this.checkDuplicate(path, "delete");
+		if (!(path in this.currentFiles)) {
+			throw new DiffError(`Delete File Error: Missing File: ${path}`);
+		}
+		this.patch.actions[path] = { type: PatchActionType.DELETE, chunks: [] };
+		this.index++;
+	}
+
+	private parseAdd(path: string): void {
+		this.checkDuplicate(path, "add");
+		if (path in this.currentFiles) {
+			throw new DiffError(`Add File Error: File already exists: ${path}`);
+		}
+
+		this.index++;
+		const lines: string[] = [];
+		const stopMarkers = [
+			PATCH_MARKERS.END,
+			PATCH_MARKERS.UPDATE,
+			PATCH_MARKERS.DELETE,
+			PATCH_MARKERS.ADD,
+		];
+
+		while (
+			this.hasMoreLines() &&
+			!stopMarkers.some((marker) =>
+				this.lines[this.index]?.startsWith(marker.trim()),
+			)
+		) {
+			const line = this.lines[this.index++];
+			if (line === undefined) {
+				break;
+			}
+			if (!line.startsWith("+")) {
+				throw new DiffError(`Invalid Add File line (missing '+'): ${line}`);
+			}
+			lines.push(line.substring(1));
+		}
+
+		this.patch.actions[path] = {
+			type: PatchActionType.ADD,
+			newFile: lines.join("\n"),
+			chunks: [],
+		};
+	}
+}
+
+function calculateSimilarity(str1: string, str2: string): number {
+	const longer = str1.length > str2.length ? str1 : str2;
+	const shorter = str1.length > str2.length ? str2 : str1;
+	if (longer.length === 0) {
+		return 1;
+	}
+	const editDistance = levenshteinDistance(shorter, longer);
+	return (longer.length - editDistance) / longer.length;
+}
+
+function levenshteinDistance(str1: string, str2: string): number {
+	const rows = str2.length + 1;
+	const cols = str1.length + 1;
+	const matrix = new Array<number>(rows * cols).fill(0);
+	const at = (r: number, c: number): number => matrix[r * cols + c] ?? 0;
+	const set = (r: number, c: number, value: number): void => {
+		matrix[r * cols + c] = value;
+	};
+
+	for (let i = 0; i <= str2.length; i++) set(i, 0, i);
+	for (let j = 0; j <= str1.length; j++) set(0, j, j);
+
+	for (let i = 1; i <= str2.length; i++) {
+		for (let j = 1; j <= str1.length; j++) {
+			if (str2[i - 1] === str1[j - 1]) {
+				set(i, j, at(i - 1, j - 1));
+			} else {
+				set(i, j, 1 + Math.min(at(i - 1, j - 1), at(i, j - 1), at(i - 1, j)));
+			}
+		}
+	}
+
+	return at(str2.length, str1.length);
+}
+
+function findContext(
+	lines: string[],
+	context: string[],
+	start: number,
+	eof: boolean,
+): [number, number, number] {
+	if (context.length === 0) {
+		return [start, 0, 1];
+	}
+
+	let bestSimilarity = 0;
+	const findCore = (startIdx: number): [number, number, number] => {
+		const canonicalContext = canonicalize(context.join("\n"));
+
+		for (let i = startIdx; i < lines.length; i++) {
+			const segment = canonicalize(
+				lines.slice(i, i + context.length).join("\n"),
+			);
+			if (segment === canonicalContext) {
+				return [i, 0, 1];
+			}
+			const similarity = calculateSimilarity(segment, canonicalContext);
+			if (similarity > bestSimilarity) {
+				bestSimilarity = similarity;
+			}
+		}
+
+		for (let i = startIdx; i < lines.length; i++) {
+			const segment = canonicalize(
+				lines
+					.slice(i, i + context.length)
+					.map((line) => line.trimEnd())
+					.join("\n"),
+			);
+			const canonicalTrimmed = canonicalize(
+				context.map((line) => line.trimEnd()).join("\n"),
+			);
+			if (segment === canonicalTrimmed) {
+				return [i, 1, 1];
+			}
+		}
+
+		for (let i = startIdx; i < lines.length; i++) {
+			const segment = canonicalize(
+				lines
+					.slice(i, i + context.length)
+					.map((line) => line.trim())
+					.join("\n"),
+			);
+			const canonicalTrimmed = canonicalize(
+				context.map((line) => line.trim()).join("\n"),
+			);
+			if (segment === canonicalTrimmed) {
+				return [i, 100, 1];
+			}
+		}
+
+		const similarityThreshold = 0.66;
+		for (let i = startIdx; i < lines.length; i++) {
+			const segment = canonicalize(
+				lines.slice(i, i + context.length).join("\n"),
+			);
+			const similarity = calculateSimilarity(segment, canonicalContext);
+			if (similarity >= similarityThreshold) {
+				return [i, 1000, similarity];
+			}
+			if (similarity > bestSimilarity) {
+				bestSimilarity = similarity;
+			}
+		}
+
+		return [-1, 0, bestSimilarity];
+	};
+
+	if (eof) {
+		let [newIndex, fuzz, similarity] = findCore(lines.length - context.length);
+		if (newIndex !== -1) {
+			return [newIndex, fuzz, similarity];
+		}
+		[newIndex, fuzz, similarity] = findCore(start);
+		return [newIndex, fuzz + 10000, similarity];
+	}
+
+	return findCore(start);
+}
+
+type PeekResult = [string[], PatchChunk[], number, boolean];
+
+function peek(lines: string[], initialIndex: number): PeekResult {
+	let index = initialIndex;
+	const old: string[] = [];
+	let delLines: string[] = [];
+	let insLines: string[] = [];
+	const chunks: PatchChunk[] = [];
+	let mode: "keep" | "add" | "delete" = "keep";
+
+	const stopMarkers = [
+		"@@",
+		PATCH_MARKERS.END,
+		PATCH_MARKERS.UPDATE,
+		PATCH_MARKERS.DELETE,
+		PATCH_MARKERS.ADD,
+		PATCH_MARKERS.END_FILE,
+	];
+
+	while (index < lines.length) {
+		const sourceLine = lines[index];
+		if (
+			!sourceLine ||
+			stopMarkers.some((marker) => sourceLine.startsWith(marker.trim()))
+		) {
+			break;
+		}
+		if (sourceLine === "***") {
+			break;
+		}
+		if (sourceLine.startsWith("***")) {
+			throw new DiffError(`Invalid line: ${sourceLine}`);
+		}
+
+		index++;
+		const previousMode: "keep" | "add" | "delete" = mode;
+		let line = sourceLine;
+
+		if (line[0] === "+") {
+			mode = "add";
+		} else if (line[0] === "-") {
+			mode = "delete";
+		} else if (line[0] === " ") {
+			mode = "keep";
+		} else {
+			mode = "keep";
+			line = ` ${line}`;
+		}
+
+		line = line.slice(1);
+
+		if (mode === "keep" && previousMode !== mode) {
+			if (insLines.length || delLines.length) {
+				chunks.push({
+					origIndex: old.length - delLines.length,
+					delLines,
+					insLines,
+				});
+			}
+			delLines = [];
+			insLines = [];
+		}
+
+		if (mode === "delete") {
+			delLines.push(line);
+			old.push(line);
+		} else if (mode === "add") {
+			insLines.push(line);
+		} else {
+			old.push(line);
+		}
+	}
+
+	if (insLines.length || delLines.length) {
+		chunks.push({
+			origIndex: old.length - delLines.length,
+			delLines,
+			insLines,
+		});
+	}
+
+	if (index < lines.length && lines[index] === PATCH_MARKERS.END_FILE) {
+		index++;
+		return [old, chunks, index, true];
+	}
+
+	return [old, chunks, index, false];
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/apply-patch.test.ts b/sdk/packages/core/src/extensions/tools/executors/apply-patch.test.ts
new file mode 100644
index 0000000..3e39b9f
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/apply-patch.test.ts
@@ -0,0 +1,173 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createApplyPatchExecutor } from "./apply-patch";
+
+describe("createApplyPatchExecutor", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "apply-patch-"));
+	});
+
+	afterEach(async () => {
+		await fs.rm(tempDir, { recursive: true, force: true });
+	});
+
+	it("applies the documented freeform patch format without shell wrappers", async () => {
+		const filePath = path.join(tempDir, "page.tsx");
+		await fs.writeFile(
+			filePath,
+			[
+				"export default function Page() {",
+				"\treturn (",
+				"\t\t<div>",
+				'\t\t\t<button onClick={() => console.log("clicked")}>Click me</button>',
+				"\t\t</div>",
+				"\t);",
+				"}",
+			].join("\n"),
+			"utf-8",
+		);
+
+		const execute = createApplyPatchExecutor();
+		const result = await execute(
+			{
+				input: [
+					"*** Update File: page.tsx",
+					"@@",
+					" export default function Page() {",
+					" \treturn (",
+					" \t\t<div>",
+					' \t\t\t<button onClick={() => console.log("clicked")}>Click me</button>',
+					'+\t\t\t<button onClick={() => console.log("cancel clicked")}>Cancel</button>',
+					" \t\t</div>",
+					" \t);",
+					" }",
+				].join("\n"),
+			},
+			tempDir,
+			{} as never,
+		);
+
+		await expect(fs.readFile(filePath, "utf-8")).resolves.toContain(
+			'console.log("cancel clicked")',
+		);
+		expect(result).toContain("Successfully applied patch");
+		expect(result).toContain("page.tsx");
+	});
+
+	it("accepts the legacy shell wrapper around the patch", async () => {
+		const filePath = path.join(tempDir, "note.txt");
+		const execute = createApplyPatchExecutor();
+
+		await execute(
+			{
+				input: [
+					"%%bash",
+					'apply_patch <<"EOF"',
+					"*** Begin Patch",
+					"*** Add File: note.txt",
+					"+hello",
+					"*** End Patch",
+					"EOF",
+				].join("\n"),
+			},
+			tempDir,
+			{} as never,
+		);
+
+		await expect(fs.readFile(filePath, "utf-8")).resolves.toBe("hello");
+	});
+
+	it("does not strip valid patch lines that begin with wrapper tokens after the patch prefix", async () => {
+		const filePath = path.join(tempDir, "note.txt");
+		await fs.writeFile(
+			filePath,
+			["alpha", "EOF literal", "``` fence", "omega"].join("\n"),
+			"utf-8",
+		);
+
+		const execute = createApplyPatchExecutor();
+		await execute(
+			{
+				input: [
+					"*** Update File: note.txt",
+					"@@",
+					" alpha",
+					" EOF literal",
+					" ``` fence",
+					"+tail",
+					" omega",
+				].join("\n"),
+			},
+			tempDir,
+			{} as never,
+		);
+
+		await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
+			["alpha", "EOF literal", "``` fence", "tail", "omega"].join("\n"),
+		);
+	});
+
+	it("accepts an end sentinel with trailing whitespace", async () => {
+		const filePath = path.join(tempDir, "note.txt");
+		const execute = createApplyPatchExecutor();
+
+		await execute(
+			{
+				input: [
+					"*** Begin Patch",
+					"*** Add File: note.txt",
+					"+hello",
+					"*** End Patch ",
+				].join("\n"),
+			},
+			tempDir,
+			{} as never,
+		);
+
+		await expect(fs.readFile(filePath, "utf-8")).resolves.toBe("hello");
+	});
+
+	it("rejects incomplete patch sentinels", async () => {
+		const execute = createApplyPatchExecutor();
+
+		await expect(
+			execute(
+				{
+					input: "*** Begin Patch\n*** Add File: note.txt\n+hello",
+				},
+				tempDir,
+				{} as never,
+			),
+		).rejects.toThrow("Invalid patch text - incomplete sentinels");
+	});
+
+	it("rejects a patch when a hunk context does not match", async () => {
+		const filePath = path.join(tempDir, "note.txt");
+		const original = ["alpha", "beta", "gamma"].join("\n");
+		await fs.writeFile(filePath, original, "utf-8");
+		const execute = createApplyPatchExecutor();
+
+		await expect(
+			execute(
+				{
+					input: [
+						"*** Update File: note.txt",
+						"@@",
+						" unrelated heading",
+						" missing middle",
+						"+replacement",
+						" absent footer",
+					].join("\n"),
+				},
+				tempDir,
+				{} as never,
+			),
+		).rejects.toThrow(/note\.txt: hunk 1: Could not find matching context/);
+
+		await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(original);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/executors/apply-patch.ts b/sdk/packages/core/src/extensions/tools/executors/apply-patch.ts
new file mode 100644
index 0000000..365429c
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/apply-patch.ts
@@ -0,0 +1,367 @@
+/**
+ * Apply Patch Executor
+ *
+ * Built-in implementation for the documented GPT-5 apply_patch grammar.
+ * It accepts the freeform patch body directly and tolerates the legacy shell
+ * wrapper form used by older prompts.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AgentToolContext } from "@cline/shared";
+import type { ApplyPatchInput } from "../schemas";
+import type { ApplyPatchExecutor } from "../types";
+import {
+	BASH_WRAPPERS,
+	DiffError,
+	PATCH_MARKERS,
+	PatchActionType,
+	type PatchChunk,
+	PatchParser,
+	type PatchWarning,
+} from "./apply-patch-parser";
+
+interface FileChange {
+	type: PatchActionType;
+	oldContent?: string;
+	newContent?: string;
+	movePath?: string;
+}
+
+interface NormalizedPatchInput {
+	lines: string[];
+}
+
+/**
+ * Options for the apply_patch executor
+ */
+export interface ApplyPatchExecutorOptions {
+	/**
+	 * File encoding used for read/write operations
+	 * @default "utf-8"
+	 */
+	encoding?: BufferEncoding;
+
+	/**
+	 * Restrict relative-path file operations to paths inside cwd.
+	 * Absolute paths are always accepted as-is.
+	 * @default true
+	 */
+	restrictToCwd?: boolean;
+}
+
+function resolveFilePath(
+	cwd: string,
+	inputPath: string,
+	restrictToCwd: boolean,
+): string {
+	const isAbsoluteInput = path.isAbsolute(inputPath);
+	const resolved = isAbsoluteInput
+		? path.normalize(inputPath)
+		: path.resolve(cwd, inputPath);
+	if (!restrictToCwd || isAbsoluteInput) {
+		return resolved;
+	}
+
+	const rel = path.relative(cwd, resolved);
+	if (rel.startsWith("..") || path.isAbsolute(rel)) {
+		throw new DiffError(`Path must stay within cwd: ${inputPath}`);
+	}
+	return resolved;
+}
+
+function normalizeLineEndings(input: string): string[] {
+	return input.split("\n").map((line) => line.replace(/\r$/, ""));
+}
+
+function isWrapperLine(line: string): boolean {
+	if (line.trim() === "") {
+		return false;
+	}
+	return BASH_WRAPPERS.some((wrapper) => line.startsWith(wrapper));
+}
+
+function trimWrapperLines(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
+
+	while (start < end && isWrapperLine(lines[start] ?? "")) {
+		start++;
+	}
+
+	while (end > start && isWrapperLine(lines[end - 1] ?? "")) {
+		end--;
+	}
+
+	return lines.slice(start, end);
+}
+
+function normalizePatchInput(input: string): NormalizedPatchInput {
+	const rawLines = normalizeLineEndings(input);
+	const beginIndex = rawLines.findIndex((line) =>
+		line.startsWith(PATCH_MARKERS.BEGIN),
+	);
+	let endIndex = -1;
+	for (let i = rawLines.length - 1; i >= 0; i--) {
+		if (rawLines[i]?.startsWith(PATCH_MARKERS.END)) {
+			endIndex = i;
+			break;
+		}
+	}
+
+	if (beginIndex !== -1 || endIndex !== -1) {
+		if (beginIndex === -1 || endIndex === -1 || endIndex < beginIndex) {
+			throw new DiffError(
+				"Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.",
+			);
+		}
+		const lines = rawLines.slice(beginIndex, endIndex + 1);
+		return {
+			lines,
+		};
+	}
+
+	const stripped = trimWrapperLines(rawLines);
+	while (stripped.length > 0 && stripped[0] === "") {
+		stripped.shift();
+	}
+	while (stripped.length > 0 && stripped[stripped.length - 1] === "") {
+		stripped.pop();
+	}
+
+	const lines = [PATCH_MARKERS.BEGIN, ...stripped, PATCH_MARKERS.END];
+	return {
+		lines,
+	};
+}
+
+function extractFilesForOperations(
+	lines: readonly string[],
+	markers: readonly string[],
+): string[] {
+	const files = new Set<string>();
+
+	for (const line of lines) {
+		for (const marker of markers) {
+			if (line.startsWith(marker)) {
+				files.add(line.substring(marker.length).trim());
+				break;
+			}
+		}
+	}
+
+	return [...files];
+}
+
+function applyChunks(
+	content: string,
+	chunks: PatchChunk[],
+	filePath: string,
+): string {
+	if (chunks.length === 0) {
+		return content;
+	}
+
+	const lines = content.split("\n");
+	const result: string[] = [];
+	let currentIndex = 0;
+
+	for (const chunk of chunks) {
+		if (chunk.origIndex > lines.length) {
+			throw new DiffError(
+				`${filePath}: chunk.origIndex ${chunk.origIndex} > lines.length ${lines.length}`,
+			);
+		}
+		if (currentIndex > chunk.origIndex) {
+			throw new DiffError(
+				`${filePath}: currentIndex ${currentIndex} > chunk.origIndex ${chunk.origIndex}`,
+			);
+		}
+		result.push(...lines.slice(currentIndex, chunk.origIndex));
+		result.push(...chunk.insLines);
+		currentIndex = chunk.origIndex + chunk.delLines.length;
+	}
+
+	result.push(...lines.slice(currentIndex));
+	return result.join("\n");
+}
+
+async function loadFiles(
+	lines: readonly string[],
+	cwd: string,
+	encoding: BufferEncoding,
+	restrictToCwd: boolean,
+): Promise<Record<string, string>> {
+	const filesToLoad = extractFilesForOperations(lines, [
+		PATCH_MARKERS.UPDATE,
+		PATCH_MARKERS.DELETE,
+	]);
+	const files: Record<string, string> = {};
+
+	for (const filePath of filesToLoad) {
+		const absolutePath = resolveFilePath(cwd, filePath, restrictToCwd);
+		let fileContent: string;
+		try {
+			fileContent = await fs.readFile(absolutePath, encoding);
+		} catch {
+			throw new DiffError(`File not found: ${filePath}`);
+		}
+		files[filePath] = fileContent.replace(/\r\n/g, "\n");
+	}
+
+	return files;
+}
+
+function patchToChanges(
+	patch: ReturnType<PatchParser["parse"]>["patch"],
+	originalFiles: Record<string, string>,
+): Record<string, FileChange> {
+	const changes: Record<string, FileChange> = {};
+
+	for (const [filePath, action] of Object.entries(patch.actions)) {
+		switch (action.type) {
+			case PatchActionType.DELETE:
+				changes[filePath] = {
+					type: PatchActionType.DELETE,
+					oldContent: originalFiles[filePath],
+				};
+				break;
+			case PatchActionType.ADD:
+				if (action.newFile === undefined) {
+					throw new DiffError("ADD action without file content");
+				}
+				changes[filePath] = {
+					type: PatchActionType.ADD,
+					newContent: action.newFile,
+				};
+				break;
+			case PatchActionType.UPDATE:
+				changes[filePath] = {
+					type: PatchActionType.UPDATE,
+					oldContent: originalFiles[filePath],
+					newContent: applyChunks(
+						originalFiles[filePath] ?? "",
+						action.chunks,
+						filePath,
+					),
+					movePath: action.movePath,
+				};
+				break;
+		}
+	}
+
+	return changes;
+}
+
+function formatSkippedHunkFailure(warnings: readonly PatchWarning[]): string {
+	const lines = [
+		`Patch could not be applied because ${warnings.length} hunk${warnings.length === 1 ? "" : "s"} did not match the current file content.`,
+	];
+
+	for (const warning of warnings) {
+		const hunkNumber =
+			warning.chunkIndex === undefined
+				? "unknown"
+				: String(warning.chunkIndex + 1);
+		lines.push(`${warning.path}: hunk ${hunkNumber}: ${warning.message}`);
+		if (warning.context) {
+			lines.push(`Context:\n${warning.context}`);
+		}
+	}
+
+	return lines.join("\n");
+}
+
+async function applyChanges(
+	changes: Record<string, FileChange>,
+	cwd: string,
+	encoding: BufferEncoding,
+	restrictToCwd: boolean,
+): Promise<string[]> {
+	const touched: string[] = [];
+
+	for (const [filePath, change] of Object.entries(changes)) {
+		const sourceAbsPath = resolveFilePath(cwd, filePath, restrictToCwd);
+		switch (change.type) {
+			case PatchActionType.DELETE:
+				await fs.rm(sourceAbsPath, { force: true });
+				touched.push(`${filePath}: [deleted]`);
+				break;
+			case PatchActionType.ADD:
+				if (change.newContent === undefined) {
+					throw new DiffError(`Cannot create ${filePath} with no content`);
+				}
+				await fs.mkdir(path.dirname(sourceAbsPath), { recursive: true });
+				await fs.writeFile(sourceAbsPath, change.newContent, { encoding });
+				touched.push(filePath);
+				break;
+			case PatchActionType.UPDATE: {
+				if (change.newContent === undefined) {
+					throw new DiffError(
+						`UPDATE change for ${filePath} has no new content`,
+					);
+				}
+
+				if (change.movePath) {
+					const moveAbsPath = resolveFilePath(
+						cwd,
+						change.movePath,
+						restrictToCwd,
+					);
+					await fs.mkdir(path.dirname(moveAbsPath), { recursive: true });
+					await fs.writeFile(moveAbsPath, change.newContent, { encoding });
+					await fs.rm(sourceAbsPath, { force: true });
+					touched.push(`${filePath} -> ${change.movePath}`);
+				} else {
+					await fs.writeFile(sourceAbsPath, change.newContent, { encoding });
+					touched.push(filePath);
+				}
+				break;
+			}
+		}
+	}
+
+	return touched;
+}
+
+/**
+ * Create an apply_patch executor using Node.js fs module.
+ */
+export function createApplyPatchExecutor(
+	options: ApplyPatchExecutorOptions = {},
+): ApplyPatchExecutor {
+	const { encoding = "utf-8", restrictToCwd = true } = options;
+
+	return async (
+		input: ApplyPatchInput,
+		cwd: string,
+		_context: AgentToolContext,
+	): Promise<string> => {
+		const normalizedInput = normalizePatchInput(input.input);
+		const currentFiles = await loadFiles(
+			normalizedInput.lines,
+			cwd,
+			encoding,
+			restrictToCwd,
+		);
+		const parser = new PatchParser(normalizedInput.lines, currentFiles);
+		const { patch, fuzz } = parser.parse();
+		if (patch.warnings && patch.warnings.length > 0) {
+			throw new DiffError(formatSkippedHunkFailure(patch.warnings));
+		}
+
+		const changes = patchToChanges(patch, currentFiles);
+		const touched = await applyChanges(changes, cwd, encoding, restrictToCwd);
+
+		const responseLines = [
+			"Successfully applied patch to the following files:",
+		];
+		for (const file of touched) {
+			responseLines.push(file);
+		}
+		if (fuzz > 0) {
+			responseLines.push(`Note: Patch applied with fuzz factor ${fuzz}`);
+		}
+		return responseLines.join("\n");
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/bash.test.ts b/sdk/packages/core/src/extensions/tools/executors/bash.test.ts
new file mode 100644
index 0000000..bcbbed2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/bash.test.ts
@@ -0,0 +1,276 @@
+import type { AgentToolContext } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { CommandExitError, createShellExecutor } from "./bash";
+
+const ctx: AgentToolContext = {
+	agentId: "agent-1",
+	conversationId: "conv-1",
+	iteration: 1,
+};
+
+describe("createShellExecutor", () => {
+	it("runs a simple command and returns stdout", async () => {
+		const shell = createShellExecutor();
+		const output = await shell("echo hello", process.cwd(), ctx);
+		expect(output.trim()).toBe("hello");
+	});
+
+	it("rejects on non-zero exit code", async () => {
+		const shell = createShellExecutor();
+		await expect(shell("exit 1", process.cwd(), ctx)).rejects.toThrow();
+	});
+
+	it("includes stdout and exit code on non-zero exit", async () => {
+		const shell = createShellExecutor();
+		let error: unknown;
+		try {
+			await shell(
+				{
+					command: process.execPath,
+					args: [
+						"-e",
+						"process.stdout.write('failure details'); process.exit(1)",
+					],
+				},
+				process.cwd(),
+				ctx,
+			);
+		} catch (caught) {
+			error = caught;
+		}
+
+		if (!(error instanceof CommandExitError)) {
+			throw new Error("Expected CommandExitError");
+		}
+		expect(error.exitCode).toBe(1);
+		expect(error.output).toContain("[Command exited with code 1]");
+		expect(error.output).toContain("failure details");
+	});
+
+	it("excludes stderr on non-zero exit when combineOutput is false", async () => {
+		const shell = createShellExecutor({ combineOutput: false });
+		let error: unknown;
+		try {
+			await shell(
+				{
+					command: process.execPath,
+					args: [
+						"-e",
+						"process.stdout.write('visible'); process.stderr.write('hidden'); process.exit(1)",
+					],
+				},
+				process.cwd(),
+				ctx,
+			);
+		} catch (caught) {
+			error = caught;
+		}
+
+		if (!(error instanceof CommandExitError)) {
+			throw new Error("Expected CommandExitError");
+		}
+		expect(error.output).toContain("visible");
+		expect(error.output).not.toContain("[stderr]");
+		expect(error.output).not.toContain("hidden");
+	});
+
+	it("includes stderr in combined output on success", async () => {
+		const shell = createShellExecutor({ combineOutput: true });
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: [
+					"-e",
+					"process.stdout.write('ok'); process.stderr.write('warn')",
+				],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toContain("ok");
+		expect(output).toContain("[stderr]");
+		expect(output).toContain("warn");
+	});
+
+	it("excludes stderr when combineOutput is false", async () => {
+		const shell = createShellExecutor({ combineOutput: false });
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: [
+					"-e",
+					"process.stdout.write('ok'); process.stderr.write('warn')",
+				],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output.trim()).toBe("ok");
+	});
+
+	it("rejects on timeout", async () => {
+		const shell = createShellExecutor({ timeoutMs: 50 });
+		await expect(shell("sleep 10", process.cwd(), ctx)).rejects.toThrow(
+			"timed out",
+		);
+	});
+
+	it("middle-truncates output exceeding maxOutputBytes, keeping head and tail", async () => {
+		const shell = createShellExecutor({ maxOutputBytes: 20 });
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: ["-e", "process.stdout.write('HEAD' + 'x'.repeat(100) + 'TAIL')"],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toContain("HEAD");
+		expect(output).toContain("TAIL");
+		expect(output).toContain("[... output truncated: 108 chars total");
+		expect(output.length).toBeLessThan(300);
+	});
+
+	it("keeps default-capped output bounded with the notice in the preserved head/tail", async () => {
+		// Provider-request building (session/services/message-builder.ts)
+		// may middle-cut long tool-result strings again with its own
+		// backstop. The executor keeps its truncation notice in the head and
+		// tail halves, so the recovery guidance survives any such cut.
+		const shell = createShellExecutor();
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: ["-e", "process.stdout.write('x'.repeat(60_000))"],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output.length).toBeLessThanOrEqual(50_000);
+		expect(output).toContain("output truncated: 60000 chars total");
+	});
+
+	it("does not truncate output within maxOutputBytes", async () => {
+		const shell = createShellExecutor({ maxOutputBytes: 1000 });
+		const payload = "b".repeat(500);
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: ["-e", `process.stdout.write('${payload}')`],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toBe(payload);
+	});
+
+	it("marks truncation in the captured output when a failing command floods stderr", async () => {
+		const shell = createShellExecutor({ maxOutputBytes: 20 });
+		let error: unknown;
+		try {
+			await shell(
+				{
+					command: process.execPath,
+					args: [
+						"-e",
+						"process.stderr.write('ERR' + 'x'.repeat(100) + 'TAIL'); process.exit(1)",
+					],
+				},
+				process.cwd(),
+				ctx,
+			);
+		} catch (caught) {
+			error = caught;
+		}
+
+		if (!(error instanceof CommandExitError)) {
+			throw new Error("Expected CommandExitError");
+		}
+		expect(error.output).toContain("output truncated");
+	});
+
+	it("keeps the tail of streamed output written in many chunks", async () => {
+		const shell = createShellExecutor({ maxOutputBytes: 40 });
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: [
+					"-e",
+					"for (let i = 0; i < 50; i++) process.stdout.write('line' + i + '\\n'); process.stdout.write('FINAL')",
+				],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toContain("line0");
+		expect(output).toContain("FINAL");
+		expect(output).toContain("output truncated");
+	});
+
+	it("rejects when abort signal fires", async () => {
+		const ac = new AbortController();
+		const abortCtx: AgentToolContext = { ...ctx, signal: ac.signal };
+		const shell = createShellExecutor();
+
+		setTimeout(() => ac.abort(), 50);
+		await expect(shell("sleep 10", process.cwd(), abortCtx)).rejects.toThrow(
+			"aborted",
+		);
+	});
+
+	it("flushes a trailing incomplete multibyte sequence instead of dropping it", async () => {
+		const shell = createShellExecutor();
+		// Output ends with the first byte of a two-byte UTF-8 sequence; the
+		// decoder must flush it at end-of-stream (as U+FFFD) rather than
+		// silently dropping buffered bytes.
+		const output = await shell(
+			{
+				command: process.execPath,
+				args: ["-e", "process.stdout.write(Buffer.from([0x61, 0x62, 0xc3]))"],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toHaveLength(3);
+		expect(output.startsWith("ab")).toBe(true);
+	});
+
+	it("honors maxOutputChars and the deprecated maxOutputBytes alias", async () => {
+		const emit = {
+			command: process.execPath,
+			args: ["-e", "process.stdout.write('x'.repeat(500))"],
+		};
+		const renamed = await createShellExecutor({ maxOutputChars: 100 })(
+			emit,
+			process.cwd(),
+			ctx,
+		);
+		const alias = await createShellExecutor({ maxOutputBytes: 100 })(
+			emit,
+			process.cwd(),
+			ctx,
+		);
+		expect(renamed).toContain("output truncated: 500 chars total");
+		expect(alias).toContain("output truncated: 500 chars total");
+	});
+});
+
+describe.runIf(process.platform === "win32")("createWindowsExecutor", () => {
+	it("runs structured commands without shell parsing", async () => {
+		const executor = createShellExecutor();
+		const output = await executor(
+			{
+				command: process.execPath,
+				args: ["-e", "process.stdout.write(process.argv[1])", "argv-ok"],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toBe("argv-ok");
+	});
+
+	it("runs string commands through the shell", async () => {
+		const executor = createShellExecutor();
+		const output = await executor("echo shell-ok", process.cwd(), ctx);
+		expect(output.trim()).toBe("shell-ok");
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/executors/bash.ts b/sdk/packages/core/src/extensions/tools/executors/bash.ts
new file mode 100644
index 0000000..d7b9457
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/bash.ts
@@ -0,0 +1,308 @@
+/**
+ * Bash Executor
+ *
+ * Built-in implementation for running shell commands using Node.js spawn.
+ */
+
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import {
+	type AgentToolContext,
+	getDefaultShell,
+	getShellArgs,
+} from "@cline/shared";
+import { TimeoutError } from "../helpers";
+import type { ShellExecutor } from "../types";
+import {
+	MAX_COMMAND_OUTPUT_CHARS,
+	truncateCommandOutput,
+} from "./output-limits";
+
+export class CommandExitError extends Error {
+	constructor(
+		readonly exitCode: number,
+		readonly output: string,
+	) {
+		super(`Command exited with code ${exitCode}`);
+		this.name = "CommandExitError";
+	}
+}
+
+/**
+ * Options for the shell executor
+ */
+export interface ShellExecutorOptions {
+	/**
+	 * Shell to use for execution
+	 * @default "/bin/bash" on Unix, "powershell" on Windows
+	 */
+	shell?: string;
+
+	/**
+	 * Timeout for command execution in milliseconds
+	 * @default 30000 (30 seconds)
+	 */
+	timeoutMs?: number;
+
+	/**
+	 * Maximum output kept, in characters. Output beyond this is
+	 * middle-truncated: the head and tail are preserved and the middle is
+	 * elided, since build and test failures usually live at the end of the
+	 * output.
+	 * @default 48_000 — see MAX_COMMAND_OUTPUT_CHARS in output-limits.ts
+	 */
+	maxOutputChars?: number;
+
+	/**
+	 * @deprecated Misnamed — the limit was always enforced in characters,
+	 * not bytes. Use {@link maxOutputChars}; this alias is honored when
+	 * maxOutputChars is not set.
+	 */
+	maxOutputBytes?: number;
+
+	/**
+	 * Environment variables to add/override
+	 */
+	env?: Record<string, string>;
+
+	/**
+	 * Whether to combine stdout and stderr
+	 * @default true
+	 */
+	combineOutput?: boolean;
+}
+
+interface SpawnConfig {
+	executable: string;
+	args: string[];
+	cwd: string;
+	env: Record<string, string>;
+}
+
+/**
+ * Collects stream output with bounded memory: the first half of the budget
+ * is kept verbatim, the rest rolls so the latest output always survives.
+ */
+function createRollingCollector(maxChars: number) {
+	const headLimit = Math.ceil(maxChars / 2);
+	const tailLimit = Math.max(1, maxChars - headLimit);
+	// StringDecoder keeps multibyte UTF-8 sequences split across stream
+	// chunks intact instead of corrupting them at chunk boundaries.
+	const decoder = new StringDecoder("utf8");
+	let head = "";
+	let tail = "";
+	let totalChars = 0;
+
+	const appendText = (text: string): void => {
+		if (!text) return;
+		totalChars += text.length;
+		const headRoom = headLimit - head.length;
+		if (headRoom > 0) {
+			head += text.slice(0, headRoom);
+			tail = (tail + text.slice(headRoom)).slice(-tailLimit);
+			return;
+		}
+		tail = (tail + text).slice(-tailLimit);
+	};
+
+	return {
+		append(data: Buffer): void {
+			appendText(decoder.write(data));
+		},
+		snapshot() {
+			// Flush bytes the decoder buffered for an incomplete multibyte
+			// sequence at end-of-stream; otherwise the final characters of
+			// non-ASCII output are silently dropped.
+			appendText(decoder.end());
+			return {
+				text: head + tail,
+				totalChars,
+				dropped: totalChars > head.length + tail.length,
+			};
+		},
+	};
+}
+
+function spawnAndCollect(
+	config: SpawnConfig,
+	context: AgentToolContext,
+	timeoutMs: number,
+	maxOutputChars: number,
+	combineOutput: boolean,
+): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const isWindows = process.platform === "win32";
+
+		const child = spawn(config.executable, config.args, {
+			cwd: config.cwd,
+			env: { ...process.env, ...config.env },
+			stdio: ["pipe", "pipe", "pipe"],
+			detached: !isWindows,
+			// Prevent a console window from flashing on Windows when the
+			// parent process has no console (or a different console).
+			// No-op on non-Windows platforms.
+			windowsHide: true,
+		});
+		const childPid = child.pid;
+
+		const stdout = createRollingCollector(maxOutputChars);
+		const stderr = createRollingCollector(maxOutputChars);
+		let killed = false;
+		let settled = false;
+
+		const settle = (fn: () => void) => {
+			if (settled) return;
+			settled = true;
+			fn();
+		};
+
+		const killProcessTree = () => {
+			if (!childPid) return;
+			if (isWindows) {
+				const killer = spawn(
+					"taskkill",
+					["/pid", String(childPid), "/T", "/F"],
+					{ stdio: "ignore", shell: true, windowsHide: true },
+				);
+				killer.unref();
+				return;
+			}
+			try {
+				process.kill(-childPid, "SIGKILL");
+			} catch {
+				child.kill("SIGKILL");
+			}
+		};
+
+		const killAndReject = (error: Error) => {
+			killed = true;
+			killProcessTree();
+			settle(() => reject(error));
+		};
+
+		const timeout = setTimeout(
+			() =>
+				killAndReject(
+					new TimeoutError(`Command timed out after ${timeoutMs}ms`, timeoutMs),
+				),
+			timeoutMs,
+		);
+
+		const abortHandler = () => killAndReject(new Error("Command was aborted"));
+
+		if (context.signal) {
+			context.signal.addEventListener("abort", abortHandler);
+		}
+
+		const cleanup = () => {
+			clearTimeout(timeout);
+			context.signal?.removeEventListener("abort", abortHandler);
+		};
+
+		child.stdout?.on("data", (data: Buffer) => {
+			stdout.append(data);
+		});
+
+		child.stderr?.on("data", (data: Buffer) => {
+			stderr.append(data);
+		});
+
+		child.on("close", (code) => {
+			cleanup();
+			if (killed) return;
+
+			const out = stdout.snapshot();
+			const err = stderr.snapshot();
+
+			if (code !== 0) {
+				const exitCode = code ?? 1;
+				let failureOutput = combineOutput
+					? out.text + (err.text ? `\n[stderr]\n${err.text}` : "")
+					: out.text;
+				const dropped = out.dropped || (combineOutput && err.dropped);
+				const totalChars = combineOutput
+					? out.totalChars + err.totalChars
+					: out.totalChars;
+				if (dropped || failureOutput.length > maxOutputChars) {
+					failureOutput = truncateCommandOutput(failureOutput, {
+						maxChars: maxOutputChars,
+						totalChars,
+					});
+				}
+				const result =
+					failureOutput.length > 0
+						? `[Command exited with code ${exitCode}]\n${failureOutput}`
+						: `[Command exited with code ${exitCode}]`;
+				settle(() => reject(new CommandExitError(exitCode, result)));
+			} else {
+				let output = combineOutput
+					? out.text + (err.text ? `\n[stderr]\n${err.text}` : "")
+					: out.text;
+				const dropped = out.dropped || (combineOutput && err.dropped);
+				if (dropped || output.length > maxOutputChars) {
+					const totalChars = combineOutput
+						? out.totalChars + err.totalChars
+						: out.totalChars;
+					output = truncateCommandOutput(output, {
+						maxChars: maxOutputChars,
+						totalChars,
+					});
+				}
+				settle(() => resolve(output));
+			}
+		});
+
+		child.on("error", (error) => {
+			cleanup();
+			settle(() =>
+				reject(new Error(`Failed to execute command: ${error.message}`)),
+			);
+		});
+	});
+}
+
+/**
+ * Create a shell executor using Node.js spawn
+ *
+ * @example
+ * ```typescript
+ * const shell = createShellExecutor({
+ *   timeoutMs: 60000, // 1 minute timeout
+ *   shell: "/bin/zsh",
+ * })
+ *
+ * const output = await shell("ls -la", "/path/to/project", context)
+ * ```
+ */
+export function createShellExecutor(
+	options: ShellExecutorOptions = {},
+): ShellExecutor {
+	const {
+		shell = getDefaultShell(process.platform),
+		timeoutMs = 30000,
+		env = {},
+		combineOutput = true,
+	} = options;
+	const maxOutputChars =
+		options.maxOutputChars ??
+		options.maxOutputBytes ??
+		MAX_COMMAND_OUTPUT_CHARS;
+
+	return (command, cwd, context) => {
+		const isStructured = typeof command !== "string";
+		return spawnAndCollect(
+			{
+				executable: isStructured ? command.command : shell,
+				args: isStructured
+					? (command.args ?? [])
+					: getShellArgs(shell, command),
+				cwd,
+				env,
+			},
+			context,
+			timeoutMs,
+			maxOutputChars,
+			combineOutput,
+		);
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/editor.test.ts b/sdk/packages/core/src/extensions/tools/executors/editor.test.ts
new file mode 100644
index 0000000..cf861ae
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/editor.test.ts
@@ -0,0 +1,222 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createEditorExecutor } from "./editor";
+
+const context = {
+	agentId: "agent-1",
+	conversationId: "conv-1",
+	iteration: 1,
+};
+
+async function withTempFile(
+	content: string,
+	run: (filePath: string, dir: string) => Promise<void>,
+): Promise<void> {
+	const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
+	const filePath = path.join(dir, "example.txt");
+	await fs.writeFile(filePath, content, "utf-8");
+	try {
+		await run(filePath, dir);
+	} finally {
+		await fs.rm(dir, { recursive: true, force: true });
+	}
+}
+
+describe("createEditorExecutor", () => {
+	it("creates a missing file when edit is used", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
+		const filePath = path.join(dir, "example.txt");
+
+		try {
+			const editor = createEditorExecutor();
+			const result = await editor(
+				{
+					path: filePath,
+					new_text: "created with edit",
+				},
+				dir,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			);
+
+			expect(result).toBe(`File created successfully at: ${filePath}`);
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
+				"created with edit",
+			);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("inserts before a one-based line and appends at the EOF boundary", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
+		const filePath = path.join(dir, "example.txt");
+		await fs.writeFile(filePath, "one\ntwo", "utf-8");
+
+		try {
+			const editor = createEditorExecutor();
+			await editor(
+				{
+					path: filePath,
+					new_text: "inserted",
+					insert_line: 2,
+				},
+				dir,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			);
+
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
+				"one\ninserted\ntwo",
+			);
+
+			await editor(
+				{
+					path: filePath,
+					new_text: "tail",
+					insert_line: 4,
+				},
+				dir,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			);
+
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
+				"one\ninserted\ntwo\ntail",
+			);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("emits a minimal diff for an in-place single-line edit", async () => {
+		await withTempFile("a\nb\nc", async (filePath, dir) => {
+			const editor = createEditorExecutor();
+			const result = await editor(
+				{ path: filePath, old_text: "b", new_text: "B" },
+				dir,
+				context,
+			);
+
+			expect(result).toBe(
+				`Edited ${filePath}\n\`\`\`diff\n-2: b\n+2: B\n\`\`\``,
+			);
+		});
+	});
+
+	it("only emits the changed region when the edit changes the line count", async () => {
+		await withTempFile("a\nb\nc\nd\ne\nf", async (filePath, dir) => {
+			const editor = createEditorExecutor();
+			const result = await editor(
+				{ path: filePath, old_text: "b\nc\nd", new_text: "B" },
+				dir,
+				context,
+			);
+
+			// The trailing unchanged lines (e, f) must not be mispaired into
+			// the diff even though their positions shifted.
+			expect(result).toBe(
+				`Edited ${filePath}\n\`\`\`diff\n-2: b\n-3: c\n-4: d\n+2: B\n\`\`\``,
+			);
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe("a\nB\ne\nf");
+		});
+	});
+
+	it("emits only additions for a pure insertion via str_replace", async () => {
+		await withTempFile("a\nb\nc", async (filePath, dir) => {
+			const editor = createEditorExecutor();
+			const result = await editor(
+				{ path: filePath, old_text: "a\nb", new_text: "a\nnew\nb" },
+				dir,
+				context,
+			);
+
+			expect(result).toBe(`Edited ${filePath}\n\`\`\`diff\n+2: new\n\`\`\``);
+		});
+	});
+
+	it("truncates long diffs at maxDiffLines while keeping both sides visible", async () => {
+		const oldLines = Array.from({ length: 10 }, (_, i) => `old-${i}`);
+		await withTempFile(oldLines.join("\n"), async (filePath, dir) => {
+			const editor = createEditorExecutor({ maxDiffLines: 3 });
+			const result = await editor(
+				{
+					path: filePath,
+					old_text: oldLines.join("\n"),
+					new_text: "replaced",
+				},
+				dir,
+				context,
+			);
+
+			expect(result).toBe(
+				`Edited ${filePath}\n\`\`\`diff\n-1: old-0\n-2: old-1\n+1: replaced\n... diff truncated (8 more removed, 0 more added lines) ...\n\`\`\``,
+			);
+		});
+	});
+
+	it("does not drop additions when removals alone exhaust maxDiffLines", async () => {
+		const oldLines = Array.from({ length: 6 }, (_, i) => `old-${i}`);
+		const newLines = Array.from({ length: 4 }, (_, i) => `new-${i}`);
+		await withTempFile(oldLines.join("\n"), async (filePath, dir) => {
+			const editor = createEditorExecutor({ maxDiffLines: 6 });
+			const result = await editor(
+				{
+					path: filePath,
+					old_text: oldLines.join("\n"),
+					new_text: newLines.join("\n"),
+				},
+				dir,
+				context,
+			);
+
+			// Budget splits 3/3 instead of removals consuming all 6 lines and
+			// reporting +0 additions.
+			expect(result).toBe(
+				`Edited ${filePath}\n\`\`\`diff\n-1: old-0\n-2: old-1\n-3: old-2\n+1: new-0\n+2: new-1\n+3: new-2\n... diff truncated (3 more removed, 1 more added lines) ...\n\`\`\``,
+			);
+		});
+	});
+
+	it("rejects insert_line 0 with the valid one-based boundary range", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
+		const filePath = path.join(dir, "example.txt");
+		await fs.writeFile(filePath, "one\ntwo", "utf-8");
+
+		try {
+			const editor = createEditorExecutor();
+
+			await expect(
+				editor(
+					{
+						path: filePath,
+						new_text: "invalid",
+						insert_line: 0,
+					},
+					dir,
+					{
+						agentId: "agent-1",
+						conversationId: "conv-1",
+						iteration: 1,
+					},
+				),
+			).rejects.toThrow(
+				"Invalid insert_line: 0. insert_line must be a positive one-based boundary line in the range 1-3. Use 3 to append at EOF.",
+			);
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe("one\ntwo");
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/executors/editor.ts b/sdk/packages/core/src/extensions/tools/executors/editor.ts
new file mode 100644
index 0000000..1694e4c
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/editor.ts
@@ -0,0 +1,245 @@
+/**
+ * Editor Executor
+ *
+ * Built-in implementation for filesystem editing operations.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AgentToolContext } from "@cline/shared";
+import type { EditFileInput } from "../schemas";
+import type { EditorExecutor } from "../types";
+
+/**
+ * Options for the editor executor
+ */
+export interface EditorExecutorOptions {
+	/**
+	 * File encoding used for read/write operations
+	 * @default "utf-8"
+	 */
+	encoding?: BufferEncoding;
+
+	/**
+	 * Restrict relative-path file operations to paths inside cwd.
+	 * Absolute paths are always accepted as-is.
+	 * @default true
+	 */
+	restrictToCwd?: boolean;
+
+	/**
+	 * Maximum number of diff lines in str_replace output
+	 * @default 200
+	 */
+	maxDiffLines?: number;
+}
+
+function resolveFilePath(
+	cwd: string,
+	inputPath: string,
+	restrictToCwd: boolean,
+): string {
+	const isAbsoluteInput = path.isAbsolute(inputPath);
+	const resolved = isAbsoluteInput
+		? path.normalize(inputPath)
+		: path.resolve(cwd, inputPath);
+	if (!restrictToCwd) {
+		return resolved;
+	}
+
+	// Absolute paths are accepted directly; cwd restriction applies to relative inputs.
+	if (isAbsoluteInput) {
+		return resolved;
+	}
+
+	const rel = path.relative(cwd, resolved);
+	if (rel.startsWith("..") || path.isAbsolute(rel)) {
+		throw new Error(`Path must stay within cwd: ${inputPath}`);
+	}
+	return resolved;
+}
+
+function countOccurrences(content: string, needle: string): number {
+	if (needle.length === 0) return 0;
+	return content.split(needle).length - 1;
+}
+
+function createLineDiff(
+	oldContent: string,
+	newContent: string,
+	maxLines: number,
+): string {
+	const oldLines = oldContent.split("\n");
+	const newLines = newContent.split("\n");
+
+	// Trim the common prefix and suffix so only the changed region is emitted;
+	// a naive positional compare would mispair every line after an edit that
+	// changes the line count.
+	let start = 0;
+	while (
+		start < oldLines.length &&
+		start < newLines.length &&
+		oldLines[start] === newLines[start]
+	) {
+		start++;
+	}
+	let oldEnd = oldLines.length;
+	let newEnd = newLines.length;
+	while (
+		oldEnd > start &&
+		newEnd > start &&
+		oldLines[oldEnd - 1] === newLines[newEnd - 1]
+	) {
+		oldEnd--;
+		newEnd--;
+	}
+
+	// Split the line budget between removals and additions so neither side is
+	// silently dropped when the other alone would exhaust maxLines.
+	const removedCount = oldEnd - start;
+	const addedCount = newEnd - start;
+	let removedBudget = removedCount;
+	let addedBudget = addedCount;
+	if (removedCount + addedCount > maxLines) {
+		removedBudget = Math.min(
+			removedCount,
+			Math.max(Math.ceil(maxLines / 2), maxLines - addedCount),
+		);
+		addedBudget = Math.min(addedCount, maxLines - removedBudget);
+	}
+
+	const out: string[] = ["```diff"];
+	for (let i = start; i < start + removedBudget; i++) {
+		out.push(`-${i + 1}: ${oldLines[i]}`);
+	}
+	for (let i = start; i < start + addedBudget; i++) {
+		out.push(`+${i + 1}: ${newLines[i]}`);
+	}
+
+	const omittedRemoved = removedCount - removedBudget;
+	const omittedAdded = addedCount - addedBudget;
+	if (omittedRemoved > 0 || omittedAdded > 0) {
+		out.push(
+			`... diff truncated (${omittedRemoved} more removed, ${omittedAdded} more added lines) ...`,
+		);
+	}
+
+	out.push("```");
+	return out.join("\n");
+}
+
+async function createFile(
+	filePath: string,
+	fileText: string,
+	encoding: BufferEncoding,
+): Promise<string> {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, fileText, { encoding });
+	return `File created successfully at: ${filePath}`;
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function replaceInFile(
+	filePath: string,
+	oldStr: string,
+	newStr: string | null | undefined,
+	encoding: BufferEncoding,
+	maxDiffLines: number,
+): Promise<string> {
+	const content = await fs.readFile(filePath, encoding);
+	const occurrences = countOccurrences(content, oldStr);
+
+	if (occurrences === 0) {
+		throw new Error(`No replacement performed: text not found in ${filePath}.`);
+	}
+
+	if (occurrences > 1) {
+		throw new Error(
+			`No replacement performed: multiple occurrences of text found in ${filePath}.`,
+		);
+	}
+
+	const updated = content.replace(oldStr, newStr ?? "");
+	await fs.writeFile(filePath, updated, { encoding });
+
+	const diff = createLineDiff(content, updated, maxDiffLines);
+	return `Edited ${filePath}\n${diff}`;
+}
+
+async function insertInFile(
+	filePath: string,
+	insertLineOneBased: number,
+	newStr: string,
+	encoding: BufferEncoding,
+): Promise<string> {
+	const content = await fs.readFile(filePath, encoding);
+	const lines = content.split("\n");
+	const maxBoundaryLine = lines.length + 1;
+
+	if (insertLineOneBased < 1 || insertLineOneBased > maxBoundaryLine) {
+		throw new Error(
+			`Invalid insert_line: ${insertLineOneBased}. insert_line must be a positive one-based boundary line in the range 1-${maxBoundaryLine}. Use ${maxBoundaryLine} to append at EOF.`,
+		);
+	}
+
+	const insertLine = insertLineOneBased - 1;
+	lines.splice(insertLine, 0, ...newStr.split("\n"));
+	await fs.writeFile(filePath, lines.join("\n"), { encoding });
+
+	return `Inserted content at line ${insertLineOneBased} in ${filePath}.`;
+}
+
+/**
+ * Create an editor executor using Node.js fs module
+ */
+export function createEditorExecutor(
+	options: EditorExecutorOptions = {},
+): EditorExecutor {
+	const {
+		encoding = "utf-8",
+		restrictToCwd = true,
+		maxDiffLines = 200,
+	} = options;
+
+	return async (
+		input: EditFileInput,
+		cwd: string,
+		_context: AgentToolContext,
+	): Promise<string> => {
+		const filePath = resolveFilePath(cwd, input.path, restrictToCwd);
+
+		if (input.insert_line != null) {
+			return insertInFile(
+				filePath,
+				input.insert_line, // One-based index
+				input.new_text,
+				encoding,
+			);
+		}
+
+		if (!(await fileExists(filePath))) {
+			return createFile(filePath, input.new_text, encoding);
+		}
+		if (input.old_text == null) {
+			throw new Error(
+				"Parameter `old_text` is required when editing an existing file without `insert_line`",
+			);
+		}
+
+		return replaceInFile(
+			filePath,
+			input.old_text,
+			input.new_text,
+			encoding,
+			maxDiffLines,
+		);
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/file-read.test.ts b/sdk/packages/core/src/extensions/tools/executors/file-read.test.ts
new file mode 100644
index 0000000..846ae42
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/file-read.test.ts
@@ -0,0 +1,322 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createFileReadExecutor } from "./file-read";
+
+describe("createFileReadExecutor", () => {
+	it("reads a file from an absolute path", async () => {
+		const result = await readTempFile("hello absolute path");
+		expect(result).toBe("1 | hello absolute path");
+	});
+
+	it("returns only the requested inclusive line range", async () => {
+		const result = await readTempFile("alpha\nbeta\ngamma\ndelta", {
+			start_line: 2,
+			end_line: 3,
+		});
+		expect(result).toBe("2 | beta\n3 | gamma");
+	});
+
+	async function readTempFile(
+		content: string,
+		range?: { start_line?: number; end_line?: number },
+	): Promise<string> {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		try {
+			const filePath = path.join(dir, "example.txt");
+			await fs.writeFile(filePath, content, "utf-8");
+			const readFile = createFileReadExecutor();
+			return (await readFile(
+				{ path: filePath, ...range },
+				{ agentId: "agent-1", conversationId: "conv-1", iteration: 1 },
+			)) as string;
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	}
+
+	const numberedLines = (count: number) =>
+		Array.from({ length: count }, (_, i) => `line ${i + 1}`).join("\n");
+
+	it("windows whole-file reads to the line cap and reports how to paginate", async () => {
+		const result = await readTempFile(numberedLines(2500));
+
+		expect(result).toContain("1 | line 1");
+		expect(result).toContain("2000 | line 2000");
+		expect(result).not.toContain("line 2001");
+		expect(result).toContain(
+			"[Showing lines 1-2000 of 2500. Use start_line/end_line to read other sections.]",
+		);
+	});
+
+	it("bounds line counting for unranged reads after the capture window", async () => {
+		const result = await readTempFile(numberedLines(60_000));
+
+		expect(result).toContain("1 | line 1");
+		expect(result).toContain("2000 | line 2000");
+		expect(result).not.toContain("line 2001");
+		expect(result).toContain(
+			"[Showing lines 1-2000 of 50000+ lines. Use start_line/end_line to read other sections.]",
+		);
+	});
+
+	it("honors explicit ranges beyond the default window start", async () => {
+		const result = await readTempFile(numberedLines(2500), {
+			start_line: 2400,
+			end_line: 2402,
+		});
+
+		expect(result).toBe("2400 | line 2400\n2401 | line 2401\n2402 | line 2402");
+	});
+
+	it("reports the requested finite end line when a range exceeds the line cap", async () => {
+		const result = await readTempFile(numberedLines(3000), {
+			start_line: 1,
+			end_line: 3000,
+		});
+
+		expect(result).toContain("1 | line 1");
+		expect(result).toContain("2000 | line 2000");
+		expect(result).not.toContain("line 2001");
+		expect(result).toContain(
+			"[Showing lines 1-2000 of 3000. Use start_line/end_line to read other sections.]",
+		);
+	});
+
+	it("reads a requested range from a text file larger than the size gate", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		const filePath = path.join(dir, "large.txt");
+		await fs.writeFile(filePath, numberedLines(100), "utf-8");
+
+		try {
+			const readFile = createFileReadExecutor({ maxFileSizeBytes: 10 });
+			const result = (await readFile(
+				{ path: filePath, start_line: 50, end_line: 52 },
+				{ agentId: "agent-1", conversationId: "conv-1", iteration: 1 },
+			)) as string;
+
+			expect(result).toBe("50 | line 50\n51 | line 51\n52 | line 52");
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("returns a window for an unranged text file larger than the size gate", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		const filePath = path.join(dir, "large.txt");
+		await fs.writeFile(filePath, numberedLines(2500), "utf-8");
+
+		try {
+			const readFile = createFileReadExecutor({ maxFileSizeBytes: 10 });
+			const result = (await readFile(
+				{ path: filePath },
+				{ agentId: "agent-1", conversationId: "conv-1", iteration: 1 },
+			)) as string;
+
+			expect(result).toContain("1 | line 1");
+			expect(result).toContain("2000 | line 2000");
+			expect(result).toContain(
+				"[Showing lines 1-2000 of 2500. Use start_line/end_line to read other sections.]",
+			);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("truncates very long lines", async () => {
+		const result = await readTempFile(`short\n${"y".repeat(5000)}\nend`);
+
+		expect(result).toContain("short");
+		expect(result).toContain("[line truncated]");
+		expect(result).toContain("end");
+		expect(result.length).toBeLessThan(2500);
+	});
+
+	it("rejects very large text files instead of streaming them", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		const filePath = path.join(dir, "huge.txt");
+		await fs.writeFile(filePath, "hello", "utf-8");
+		await fs.truncate(filePath, 100_000_001);
+
+		try {
+			const readFile = createFileReadExecutor();
+
+			await expect(
+				readFile(
+					{ path: filePath, start_line: 1, end_line: 1 },
+					{ agentId: "agent-1", conversationId: "conv-1", iteration: 1 },
+				),
+			).rejects.toThrow("Text file too large to stream safely");
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects when the abort signal fires before reading", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		const filePath = path.join(dir, "example.txt");
+		await fs.writeFile(filePath, "hello", "utf-8");
+
+		try {
+			const controller = new AbortController();
+			controller.abort(new Error("stop reading"));
+			const readFile = createFileReadExecutor();
+
+			await expect(
+				readFile(
+					{ path: filePath },
+					{
+						agentId: "agent-1",
+						conversationId: "conv-1",
+						iteration: 1,
+						signal: controller.signal,
+					},
+				),
+			).rejects.toThrow("stop reading");
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("caps the returned window by characters for dense files", async () => {
+		// 1500 lines of 100 chars each is ~150k chars, well over the ~50k cap
+		// while staying under the 2000-line cap.
+		const result = await readTempFile(
+			Array.from({ length: 1500 }, () => "z".repeat(100)).join("\n"),
+		);
+
+		// Bounded by the read window cap; the pagination notice sits at the
+		// end of the kept window, inside the tail that any downstream
+		// provider-request middle-cut preserves.
+		expect(result.length).toBeLessThanOrEqual(50_000);
+		expect(result).toContain("of 1500. Use start_line/end_line");
+	});
+
+	it("keeps dense output capped when total line-number width grows after capture", async () => {
+		const result = await readTempFile(
+			Array.from({ length: 10_000 }, () => "z".repeat(100)).join("\n"),
+		);
+
+		expect(result.length).toBeLessThanOrEqual(50_000);
+		expect(result).toContain("of 10000. Use start_line/end_line");
+	});
+
+	it("returns image blocks for image files when the model supports images", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		const filePath = path.join(dir, "example.png");
+		const pngBytes = Buffer.from(
+			"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+			"base64",
+		);
+		await fs.writeFile(filePath, pngBytes);
+
+		try {
+			const readFile = createFileReadExecutor();
+			const result = await readFile(
+				{ path: filePath },
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+					metadata: {
+						modelSupportsImages: true,
+					},
+				},
+			);
+			expect(result).toEqual([
+				{
+					type: "text",
+					text: "Successfully read image",
+				},
+				{
+					type: "image",
+					data: pngBytes.toString("base64"),
+					mediaType: "image/png",
+				},
+			]);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("returns image blocks for gif files when the model supports images", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
+		const filePath = path.join(dir, "example.gif");
+		const gifBytes = Buffer.from(
+			"R0lGODdhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=",
+			"base64",
+		);
+		await fs.writeFile(filePath, gifBytes);
+
+		try {
+			const readFile = createFileReadExecutor();
+			const result = await readFile(
+				{ path: filePath },
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+					metadata: {
+						modelSupportsImages: true,
+					},
+				},
+			);
+			expect(result).toEqual([
+				{
+					type: "text",
+					text: "Successfully read image",
+				},
+				{
+					type: "image",
+					data: gifBytes.toString("base64"),
+					mediaType: "image/gif",
+				},
+			]);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves macOS screenshot paths with narrow no-break space (U+202F) before PM", async () => {
+		// Repro for the agent-tool side of the U+202F bug: a Cline session
+		// (e.g. 1778635423953_jac9b) sent a screenshot path with a regular
+		// space, but the on-disk filename contains U+202F. Without the
+		// Unicode-aware resolver, fs.stat returns ENOENT and the tool fails.
+		const dir = await fs.mkdtemp(
+			path.join(os.tmpdir(), "agents-file-read-nnbsp-"),
+		);
+		const onDisk = "Screenshot 2026-05-12 at 4.42.48\u202FPM.png";
+		// A 1x1 PNG so the file is valid image bytes -- the tool branches
+		// on the .png extension and returns image content blocks.
+		const pngBytes = Buffer.from(
+			"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+			"base64",
+		);
+		await fs.writeFile(path.join(dir, onDisk), pngBytes);
+
+		try {
+			const readFile = createFileReadExecutor();
+			const result = await readFile(
+				// Request with a regular space instead of U+202F.
+				{ path: path.join(dir, "Screenshot 2026-05-12 at 4.42.48 PM.png") },
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+					metadata: { modelSupportsImages: true },
+				},
+			);
+			expect(result).toEqual([
+				{ type: "text", text: "Successfully read image" },
+				{
+					type: "image",
+					data: pngBytes.toString("base64"),
+					mediaType: "image/png",
+				},
+			]);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/executors/file-read.ts b/sdk/packages/core/src/extensions/tools/executors/file-read.ts
new file mode 100644
index 0000000..60097bc
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/file-read.ts
@@ -0,0 +1,269 @@
+/**
+ * File Read Executor
+ *
+ * Built-in implementation for reading files using Node.js fs module.
+ */
+
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { createInterface } from "node:readline";
+import type { AgentToolContext } from "@cline/shared";
+import { resolveExistingFilePath } from "@cline/shared/storage";
+import type { ReadFileRequest } from "../schemas";
+import type { FileReadExecutor } from "../types";
+import {
+	MAX_LINE_CHARS,
+	MAX_READ_LINES,
+	MAX_READ_OUTPUT_CHARS,
+} from "./output-limits";
+
+const IMAGE_MEDIA_TYPES = new Map<string, string>([
+	[".gif", "image/gif"],
+	[".png", "image/png"],
+	[".jpg", "image/jpeg"],
+	[".jpeg", "image/jpeg"],
+	[".webp", "image/webp"],
+]);
+
+/**
+ * Options for the file read executor
+ */
+export interface FileReadExecutorOptions {
+	/**
+	 * Maximum file size to read in bytes
+	 * @default 10_000_000 (10MB)
+	 */
+	maxFileSizeBytes?: number;
+
+	/**
+	 * File encoding
+	 * @default "utf-8"
+	 */
+	encoding?: BufferEncoding;
+
+	/**
+	 * Whether to include line numbers in output
+	 * @default false
+	 */
+	includeLineNumbers?: boolean;
+}
+
+const DEFAULT_FILE_READ_OPTIONS: Required<FileReadExecutorOptions> = {
+	maxFileSizeBytes: 10_000_000, // 10MB default limit
+	encoding: "utf-8", // Default to UTF-8 encoding
+	includeLineNumbers: true, // Include line numbers by default
+};
+
+const MAX_TEXT_STREAM_BYTES = 100_000_000;
+const MAX_UNRANGED_LINE_SCAN = 50_000;
+
+interface CapturedLine {
+	lineNumber: number;
+	text: string;
+}
+
+function getAbortError(signal: AbortSignal): Error {
+	const { reason } = signal;
+	if (reason instanceof Error) {
+		return reason;
+	}
+	if (reason !== undefined) {
+		return new Error(String(reason));
+	}
+	return new Error("File read was aborted");
+}
+
+async function readTextWindow(
+	filePath: string,
+	encoding: BufferEncoding,
+	includeLineNumbers: boolean,
+	startLine: number | null | undefined,
+	endLine: number | null | undefined,
+	signal?: AbortSignal,
+): Promise<string> {
+	if (signal?.aborted) {
+		throw getAbortError(signal);
+	}
+
+	const requestedStartLine = Math.max(startLine ?? 1, 1);
+	const requestedEndLine = endLine ?? Number.POSITIVE_INFINITY;
+	const hasFiniteEndLine = Number.isFinite(requestedEndLine);
+	const maxScannedLine = hasFiniteEndLine
+		? requestedEndLine
+		: requestedStartLine + MAX_UNRANGED_LINE_SCAN - 1;
+	const captured: CapturedLine[] = [];
+	let chars = 0;
+	let totalLines = 0;
+	let capped = false;
+	let approximateTotalLines = false;
+	const maxCapturedLineNumber = Number.isFinite(requestedEndLine)
+		? Math.min(requestedEndLine, requestedStartLine + MAX_READ_LINES - 1)
+		: requestedStartLine + MAX_READ_LINES - 1;
+	const lineNumberPrefixChars = includeLineNumbers
+		? String(maxCapturedLineNumber).length + 3
+		: 0;
+
+	const stream = createReadStream(filePath, { encoding });
+	const reader = createInterface({
+		input: stream,
+		crlfDelay: Number.POSITIVE_INFINITY,
+	});
+	const abortHandler = signal
+		? () => stream.destroy(getAbortError(signal))
+		: undefined;
+
+	if (signal && abortHandler) {
+		signal.addEventListener("abort", abortHandler, { once: true });
+	}
+
+	try {
+		for await (const rawLine of reader) {
+			totalLines += 1;
+			if (totalLines > requestedEndLine) {
+				totalLines = requestedEndLine;
+				break;
+			}
+			if (!hasFiniteEndLine && capped && totalLines >= maxScannedLine) {
+				approximateTotalLines = true;
+				break;
+			}
+			if (totalLines < requestedStartLine || capped) {
+				continue;
+			}
+			if (captured.length >= MAX_READ_LINES) {
+				capped = true;
+				continue;
+			}
+
+			let line = rawLine;
+			if (line.length > MAX_LINE_CHARS) {
+				line = `${line.slice(0, MAX_LINE_CHARS)} [line truncated]`;
+			}
+
+			const nextChars = chars + line.length + lineNumberPrefixChars + 1;
+			if (nextChars > MAX_READ_OUTPUT_CHARS && captured.length > 0) {
+				capped = true;
+				continue;
+			}
+
+			captured.push({ lineNumber: totalLines, text: line });
+			chars = nextChars;
+		}
+	} finally {
+		if (signal && abortHandler) {
+			signal.removeEventListener("abort", abortHandler);
+		}
+		reader.close();
+		stream.destroy();
+	}
+
+	const maxLineNumWidth = String(
+		captured[captured.length - 1]?.lineNumber ?? totalLines,
+	).length;
+	const body = captured
+		.map(({ lineNumber, text }) =>
+			includeLineNumbers
+				? `${String(lineNumber).padStart(maxLineNumWidth, " ")} | ${text}`
+				: text,
+		)
+		.join("\n");
+	const lastCapturedLine = captured[captured.length - 1]?.lineNumber;
+	if (lastCapturedLine === undefined) {
+		return body;
+	}
+
+	const effectiveEndLine = Math.min(requestedEndLine, totalLines);
+	if (lastCapturedLine >= effectiveEndLine) {
+		return body;
+	}
+	const totalLineText = approximateTotalLines
+		? `${totalLines}+ lines`
+		: effectiveEndLine;
+
+	return (
+		`${body}\n\n` +
+		`[Showing lines ${requestedStartLine}-${lastCapturedLine} of ${totalLineText}. ` +
+		"Use start_line/end_line to read other sections.]"
+	);
+}
+
+/**
+ * Create a file read executor using Node.js fs module
+ *
+ * @example
+ * ```typescript
+ * const readFile = createFileReadExecutor({
+ *   maxFileSizeBytes: 5_000_000, // 5MB limit
+ *   includeLineNumbers: true,
+ * })
+ *
+ * const content = await readFile({ path: "/path/to/file.ts" }, context)
+ * ```
+ */
+export function createFileReadExecutor(
+	options: FileReadExecutorOptions = {},
+): FileReadExecutor {
+	const { maxFileSizeBytes, encoding, includeLineNumbers } = {
+		...DEFAULT_FILE_READ_OPTIONS,
+		...options,
+	};
+
+	return async (request: ReadFileRequest, context: AgentToolContext) => {
+		const { path: filePath, start_line, end_line } = request;
+		const initialPath = path.isAbsolute(filePath)
+			? path.normalize(filePath)
+			: path.resolve(process.cwd(), filePath);
+		// Tolerate Unicode-whitespace mismatches (e.g. macOS Sonoma+
+		// screenshot paths where the on-disk filename contains U+202F but
+		// the caller's string has a regular space).
+		const resolvedPath = resolveExistingFilePath(initialPath) ?? initialPath;
+		const extension = path.extname(resolvedPath).toLowerCase();
+		const imageMediaType = IMAGE_MEDIA_TYPES.get(extension);
+
+		// Check if file exists
+		const stat = await fs.stat(resolvedPath);
+
+		if (!stat.isFile()) {
+			throw new Error(`Path is not a file: ${resolvedPath}`);
+		}
+
+		if (imageMediaType) {
+			if (stat.size > maxFileSizeBytes) {
+				throw new Error(
+					`Image file too large: ${stat.size} bytes (max: ${maxFileSizeBytes} bytes).`,
+				);
+			}
+			if (context.metadata?.modelSupportsImages !== true) {
+				throw new Error("Current model does not support image input");
+			}
+			const data = await fs.readFile(resolvedPath);
+			return [
+				{
+					type: "text",
+					text: "Successfully read image",
+				},
+				{
+					type: "image",
+					data: data.toString("base64"),
+					mediaType: imageMediaType,
+				},
+			];
+		}
+
+		if (stat.size > MAX_TEXT_STREAM_BYTES) {
+			throw new Error(
+				`Text file too large to stream safely: ${stat.size} bytes (max: ${MAX_TEXT_STREAM_BYTES} bytes). Use a targeted command such as sed, grep, head, or tail to inspect specific sections.`,
+			);
+		}
+
+		return readTextWindow(
+			resolvedPath,
+			encoding,
+			includeLineNumbers,
+			start_line,
+			end_line,
+			context.signal,
+		);
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/index.ts b/sdk/packages/core/src/extensions/tools/executors/index.ts
new file mode 100644
index 0000000..7e0f54a
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/index.ts
@@ -0,0 +1,98 @@
+/**
+ * Built-in Executor Implementations
+ *
+ * This module provides ready-to-use implementations of the tool executors
+ * using Node.js built-in modules. These can be used directly or as references
+ * for custom implementations.
+ */
+
+import type { ToolExecutors } from "../types";
+import {
+	type ApplyPatchExecutorOptions,
+	createApplyPatchExecutor,
+} from "./apply-patch";
+import { type ShellExecutorOptions, createShellExecutor } from "./bash";
+import { createEditorExecutor, type EditorExecutorOptions } from "./editor";
+import {
+	createFileReadExecutor,
+	type FileReadExecutorOptions,
+} from "./file-read";
+import { createSearchExecutor, type SearchExecutorOptions } from "./search";
+import {
+	createWebFetchExecutor,
+	type WebFetchExecutorOptions,
+} from "./web-fetch";
+
+// Re-export individual executors and their options types
+export {
+	type ApplyPatchExecutorOptions,
+	createApplyPatchExecutor,
+} from "./apply-patch";
+export {
+	type ShellExecutorOptions,
+	createShellExecutor,
+} from "./bash";
+export { createEditorExecutor, type EditorExecutorOptions } from "./editor";
+export {
+	createFileReadExecutor,
+	type FileReadExecutorOptions,
+} from "./file-read";
+export { createSearchExecutor, type SearchExecutorOptions } from "./search";
+export {
+	createWebFetchExecutor,
+	type WebFetchExecutorOptions,
+} from "./web-fetch";
+
+/**
+ * Options for creating default executors
+ */
+export interface DefaultExecutorsOptions {
+	fileRead?: FileReadExecutorOptions;
+	search?: SearchExecutorOptions;
+	bash?: ShellExecutorOptions;
+	webFetch?: WebFetchExecutorOptions;
+	applyPatch?: ApplyPatchExecutorOptions;
+	editor?: EditorExecutorOptions;
+}
+
+/**
+ * Create the default shell executor for the current platform.
+ *
+ * This is factored out from {@link createDefaultExecutors} so host integrations
+ * can reuse the SDK's cross-platform shell selection while supplying their own
+ * tool wrapper.
+ */
+export function createDefaultShellExecutor(options: ShellExecutorOptions = {}) {
+	return createShellExecutor(options);
+}
+
+/**
+ * Create all default executors with optional configuration
+ *
+ * @example
+ * ```typescript
+ * import { createDefaultTools, createDefaultExecutors } from "@cline/core"
+ *
+ * const executors = createDefaultExecutors({
+ *   bash: { timeoutMs: 60000 },
+ *   search: { maxResults: 50 },
+ * })
+ *
+ * const tools = createDefaultTools({
+ *   executors,
+ *   cwd: "/path/to/project",
+ * })
+ * ```
+ */
+export function createDefaultExecutors(
+	options: DefaultExecutorsOptions = {},
+): ToolExecutors {
+	return {
+		readFile: createFileReadExecutor(options.fileRead),
+		search: createSearchExecutor(options.search),
+		bash: createDefaultShellExecutor(options.bash),
+		webFetch: createWebFetchExecutor(options.webFetch),
+		applyPatch: createApplyPatchExecutor(options.applyPatch),
+		editor: createEditorExecutor(options.editor),
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/output-limits.ts b/sdk/packages/core/src/extensions/tools/executors/output-limits.ts
new file mode 100644
index 0000000..2168661
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/output-limits.ts
@@ -0,0 +1,50 @@
+/**
+ * Shared caps for how much tool output may enter the conversation. Every
+ * character returned by an executor is re-sent to the model on each
+ * subsequent request, so oversized outputs cost quadratically over the
+ * remaining run. Limits are measured in characters (UTF-16 code units),
+ * which tracks token cost more closely than bytes and is what JS strings
+ * measure exactly. Executors enforce these caps; tool descriptions
+ * reference them so the model pages or narrows instead of retrying.
+ *
+ * Truncation notices always live in the preserved head/tail of an entry,
+ * never in the elided middle. Provider-request building may re-truncate
+ * long strings with its own (possibly tighter) middle-cut backstop
+ * (session/services/message-builder.ts); keeping the notices at the edges
+ * means the recovery guidance survives that cut too.
+ */
+
+/** Max characters of command output kept; beyond this the middle is elided. */
+export const MAX_COMMAND_OUTPUT_CHARS = 48_000;
+
+export function truncateCommandOutput(
+	text: string,
+	options: { maxChars?: number; totalChars?: number } = {},
+): string {
+	const maxChars = options.maxChars ?? MAX_COMMAND_OUTPUT_CHARS;
+	const totalChars = options.totalChars ?? text.length;
+	if (text.length <= maxChars && totalChars <= maxChars) {
+		return text;
+	}
+
+	const headLimit = Math.ceil(maxChars / 2);
+	const tailLimit = Math.max(1, maxChars - headLimit);
+	return (
+		`${text.slice(0, headLimit)}\n` +
+		`[... output truncated: ${totalChars} chars total. ` +
+		"Refine the command (grep, head, tail) to view the elided middle ...]\n" +
+		text.slice(-tailLimit)
+	);
+}
+
+/** Max lines returned per file read when the range is larger or absent. */
+export const MAX_READ_LINES = 2_000;
+
+/** Max characters kept per line in file reads (defangs minified files). */
+export const MAX_LINE_CHARS = 2_000;
+
+/** Max characters returned per file read window. */
+export const MAX_READ_OUTPUT_CHARS = 48_000;
+
+/** Max characters returned per search query; beyond this the middle is elided. */
+export const MAX_SEARCH_OUTPUT_CHARS = 48_000;
diff --git a/sdk/packages/core/src/extensions/tools/executors/search.test.ts b/sdk/packages/core/src/extensions/tools/executors/search.test.ts
new file mode 100644
index 0000000..1643f57
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/search.test.ts
@@ -0,0 +1,39 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { AgentToolContext } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { MAX_SEARCH_OUTPUT_CHARS } from "./output-limits";
+import { createSearchExecutor } from "./search";
+
+const ctx: AgentToolContext = {
+	agentId: "agent-1",
+	conversationId: "conv-1",
+	iteration: 1,
+};
+
+describe("createSearchExecutor", () => {
+	it("middle-truncates oversized search output with recovery guidance", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-search-"));
+		const filePath = path.join(dir, "large.ts");
+		await fs.writeFile(
+			filePath,
+			`needle ${"x".repeat(MAX_SEARCH_OUTPUT_CHARS * 2)} TAIL`,
+			"utf-8",
+		);
+
+		try {
+			const search = createSearchExecutor({ contextLines: 0 });
+			const result = await search("(?=needle)", dir, ctx);
+
+			expect(result.length).toBeGreaterThan(MAX_SEARCH_OUTPUT_CHARS);
+			expect(result.length).toBeLessThanOrEqual(50_000);
+			expect(result).toContain("Found 1 result for pattern");
+			expect(result).toContain("search output truncated");
+			expect(result).toContain("Narrow the pattern or scope");
+			expect(result).toContain("TAIL");
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/executors/search.ts b/sdk/packages/core/src/extensions/tools/executors/search.ts
new file mode 100644
index 0000000..ad854da
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/search.ts
@@ -0,0 +1,497 @@
+/**
+ * Search Executor
+ *
+ * Built-in implementation for searching the codebase using ripgrep (if available) or regex.
+ */
+
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AgentToolContext } from "@cline/shared";
+import { getFileIndex } from "../../../services/workspace";
+import type { SearchExecutor } from "../types";
+import { MAX_SEARCH_OUTPUT_CHARS } from "./output-limits";
+
+/**
+ * Options for the search executor
+ */
+export interface SearchExecutorOptions {
+	/**
+	 * File extensions to include in search (without dot)
+	 * @default common code extensions
+	 */
+	includeExtensions?: string[];
+
+	/**
+	 * Directories to exclude from search
+	 * @default ["node_modules", ".git", "dist", "build", ".next", "coverage"]
+	 */
+	excludeDirs?: string[];
+
+	/**
+	 * Maximum number of results to return
+	 * @default 100
+	 */
+	maxResults?: number;
+
+	/**
+	 * Number of context lines before and after match
+	 * @default 2
+	 */
+	contextLines?: number;
+
+	/**
+	 * Maximum depth to traverse
+	 * @default 20
+	 */
+	maxDepth?: number;
+}
+
+const DEFAULT_INCLUDE_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"json",
+	"md",
+	"mdx",
+	"txt",
+	"yaml",
+	"yml",
+	"toml",
+	"py",
+	"rb",
+	"go",
+	"rs",
+	"java",
+	"kt",
+	"swift",
+	"c",
+	"cpp",
+	"h",
+	"hpp",
+	"css",
+	"scss",
+	"less",
+	"html",
+	"vue",
+	"svelte",
+	"sql",
+	"sh",
+	"bash",
+	"zsh",
+	"fish",
+	"ps1",
+	"env",
+	"gitignore",
+	"dockerignore",
+	"editorconfig",
+];
+
+const DEFAULT_EXCLUDE_DIRS = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	"coverage",
+	"__pycache__",
+	".venv",
+	"venv",
+	".cache",
+	".turbo",
+	".output",
+	"out",
+	"target",
+	"bin",
+	"obj",
+];
+
+/**
+ * Search result for a single file match
+ */
+interface SearchMatch {
+	file: string;
+	line: number;
+	column: number;
+	match: string;
+	context: string[];
+}
+
+let rgAvailable: boolean | null = null;
+
+function checkRipgrepAvailable(): Promise<boolean> {
+	if (rgAvailable !== null) {
+		return Promise.resolve(rgAvailable);
+	}
+
+	return new Promise((resolve) => {
+		const child = spawn("rg", ["--version"], {
+			stdio: ["ignore", "pipe", "pipe"],
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		});
+
+		child.on("close", (code) => {
+			rgAvailable = code === 0;
+			resolve(rgAvailable);
+		});
+
+		child.on("error", () => {
+			rgAvailable = false;
+			resolve(false);
+		});
+
+		setTimeout(() => {
+			if (!child.killed) {
+				child.kill("SIGTERM");
+			}
+			if (rgAvailable === null) {
+				rgAvailable = false;
+				resolve(false);
+			}
+		}, 1000);
+	});
+}
+
+function searchWithRipgrep(
+	query: string,
+	cwd: string,
+	maxResults: number,
+	contextLines: number,
+	timeoutMs: number = 5000,
+	abortSignal?: AbortSignal,
+): Promise<SearchMatch[] | null> {
+	return new Promise((resolve) => {
+		const child = spawn(
+			"rg",
+			["--json", `--context=${contextLines}`, "--max-count=1", "-i", query],
+			{
+				cwd,
+				stdio: ["ignore", "pipe", "pipe"],
+				// Prevent a console window from flashing on Windows.
+				windowsHide: true,
+			},
+		);
+
+		let stdout = "";
+		let resolved = false;
+
+		const cleanup = () => {
+			if (!child.killed) {
+				child.kill("SIGTERM");
+			}
+		};
+
+		const timeout = setTimeout(() => {
+			if (!resolved) {
+				resolved = true;
+				cleanup();
+				resolve(null);
+			}
+		}, timeoutMs);
+
+		const finalize = (result: SearchMatch[] | null) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeout);
+				cleanup();
+				resolve(result);
+			}
+		};
+
+		if (abortSignal?.aborted) {
+			cleanup();
+			resolve(null);
+			return;
+		}
+
+		abortSignal?.addEventListener("abort", () => {
+			finalize(null);
+		});
+
+		child.stdout.on("data", (chunk: Buffer | string) => {
+			stdout += chunk.toString();
+		});
+
+		child.stderr.on("data", () => {
+			// Ignore stderr
+		});
+
+		child.on("close", (code: number | null) => {
+			if (code === 0 || code === 1) {
+				try {
+					const matches: SearchMatch[] = [];
+					const lines = stdout.split("\n").filter((line) => line.trim());
+
+					for (const line of lines) {
+						if (matches.length >= maxResults) break;
+
+						const json = JSON.parse(line);
+						if (json.type === "match") {
+							const matchData = json.data;
+							const contextLines: string[] = [];
+
+							if (json.data.submatches && json.data.submatches.length > 0) {
+								const submatch = json.data.submatches[0];
+								matches.push({
+									file: matchData.path.text,
+									line: matchData.line_number,
+									column: (submatch?.start ?? 0) + 1,
+									match: submatch?.match?.text ?? "",
+									context: contextLines,
+								});
+							}
+						} else if (json.type === "context" && matches.length > 0) {
+							const lastMatch = matches[matches.length - 1];
+							const prefix =
+								json.data.line_number === lastMatch.line ? ">" : " ";
+							lastMatch.context.push(
+								`${prefix} ${json.data.line_number}: ${json.data.lines?.text ?? json.data.line?.text ?? ""}`,
+							);
+						}
+					}
+
+					finalize(matches.length > 0 ? matches : null);
+				} catch {
+					finalize(null);
+				}
+				return;
+			}
+
+			finalize(null);
+		});
+
+		child.on("error", () => {
+			finalize(null);
+		});
+	});
+}
+
+function shouldIncludeFile(
+	relativePath: string,
+	excludeDirs: Set<string>,
+	includeExtensions: Set<string>,
+	maxDepth: number,
+): boolean {
+	const segments = relativePath.split("/");
+	const fileName = segments[segments.length - 1] ?? "";
+	const directoryDepth = segments.length - 1;
+
+	if (directoryDepth > maxDepth) {
+		return false;
+	}
+
+	for (let i = 0; i < segments.length - 1; i++) {
+		if (excludeDirs.has(segments[i] ?? "")) {
+			return false;
+		}
+	}
+
+	const ext = path.posix.extname(fileName).slice(1).toLowerCase();
+	return includeExtensions.has(ext) || (!ext && !fileName.startsWith("."));
+}
+
+/**
+ * Create a search executor using regex pattern matching
+ *
+ * @example
+ * ```typescript
+ * const search = createSearchExecutor({
+ *   maxResults: 50,
+ *   contextLines: 3,
+ * })
+ *
+ * const results = await search("function\\s+handleClick", "/path/to/project", context)
+ * ```
+ */
+export function createSearchExecutor(
+	options: SearchExecutorOptions = {},
+): SearchExecutor {
+	const {
+		includeExtensions = DEFAULT_INCLUDE_EXTENSIONS,
+		excludeDirs = DEFAULT_EXCLUDE_DIRS,
+		maxResults = 100,
+		contextLines = 2,
+		maxDepth = 20,
+	} = options;
+	const excludeDirsSet = new Set(excludeDirs);
+	const includeExtensionsSet = new Set(
+		includeExtensions.map((extension) => extension.toLowerCase()),
+	);
+
+	return async (
+		query: string,
+		cwd: string,
+		context: AgentToolContext,
+	): Promise<string> => {
+		// Check for abort before starting
+		if (context.signal?.aborted) {
+			throw new Error("Search operation aborted");
+		}
+
+		// Try ripgrep first if available
+		const isRgAvailable = await checkRipgrepAvailable();
+		let rgMatches: SearchMatch[] | null = null;
+		if (isRgAvailable) {
+			rgMatches = await searchWithRipgrep(
+				query,
+				cwd,
+				maxResults,
+				contextLines,
+				5000,
+				context.signal,
+			);
+		}
+
+		if (rgMatches) {
+			const resultLines: string[] = [
+				`Found ${rgMatches.length} result${rgMatches.length === 1 ? "" : "s"} for pattern: ${query}`,
+				"",
+			];
+
+			for (const match of rgMatches) {
+				resultLines.push(`${match.file}:${match.line}:${match.column}`);
+				resultLines.push(...match.context);
+				resultLines.push("");
+			}
+
+			if (rgMatches.length >= maxResults) {
+				resultLines.push(
+					`(Showing first ${maxResults} results. Refine your search for more specific results.)`,
+				);
+			}
+
+			return capSearchOutput(resultLines.join("\n"));
+		}
+
+		// Fallback to manual regex search
+		let regex: RegExp;
+		try {
+			regex = new RegExp(query, "gim");
+		} catch (error) {
+			throw new Error(
+				`Invalid regex pattern: ${query}. ${error instanceof Error ? error.message : ""}`,
+			);
+		}
+
+		const matches: SearchMatch[] = [];
+		let totalFilesSearched = 0;
+
+		const fileList = await getFileIndex(cwd);
+
+		// Search files from the fast index.
+		for (const relativePath of fileList) {
+			// Check for abort signal
+			if (context.signal?.aborted) {
+				throw new Error("Search operation aborted");
+			}
+
+			if (
+				!shouldIncludeFile(
+					relativePath,
+					excludeDirsSet,
+					includeExtensionsSet,
+					maxDepth,
+				)
+			) {
+				continue;
+			}
+
+			if (matches.length >= maxResults) break;
+
+			totalFilesSearched++;
+			const filePath = path.join(cwd, relativePath);
+
+			try {
+				const content = await fs.readFile(filePath, "utf-8");
+				const lines = content.split("\n");
+
+				for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+					const line = lines[lineIdx];
+					regex.lastIndex = 0; // Reset regex state
+
+					let match = regex.exec(line);
+					while (match !== null) {
+						if (matches.length >= maxResults) break;
+
+						// Get context lines
+						const contextStart = Math.max(0, lineIdx - contextLines);
+						const contextEnd = Math.min(
+							lines.length - 1,
+							lineIdx + contextLines,
+						);
+						const contextLinesArr: string[] = [];
+
+						for (let i = contextStart; i <= contextEnd; i++) {
+							const prefix = i === lineIdx ? ">" : " ";
+							contextLinesArr.push(`${prefix} ${i + 1}: ${lines[i]}`);
+						}
+
+						matches.push({
+							file: relativePath,
+							line: lineIdx + 1,
+							column: match.index + 1,
+							match: match[0],
+							context: contextLinesArr,
+						});
+
+						// Prevent infinite loop on zero-length matches
+						if (match.index === regex.lastIndex) {
+							regex.lastIndex++;
+						}
+						match = regex.exec(line);
+					}
+				}
+			} catch {}
+		}
+
+		// Format results
+		if (matches.length === 0) {
+			return `No results found for pattern: ${query}\nSearched ${totalFilesSearched} files.`;
+		}
+
+		const resultLines: string[] = [
+			`Found ${matches.length} result${matches.length === 1 ? "" : "s"} for pattern: ${query}`,
+			`Searched ${totalFilesSearched} files.`,
+			"",
+		];
+
+		for (const match of matches) {
+			resultLines.push(`${match.file}:${match.line}:${match.column}`);
+			resultLines.push(...match.context);
+			resultLines.push("");
+		}
+
+		if (matches.length >= maxResults) {
+			resultLines.push(
+				`(Showing first ${maxResults} results. Refine your search for more specific results.)`,
+			);
+		}
+
+		return capSearchOutput(resultLines.join("\n"));
+	};
+}
+
+/**
+ * Middle-truncate oversized search output. Matches with long context lines
+ * can blow past the per-query cap even within the maxResults bound; the
+ * head (earliest matches plus the result count) and tail (the refine hint)
+ * are preserved and the middle is elided with a notice teaching the model
+ * to narrow the pattern instead of retrying.
+ */
+function capSearchOutput(text: string): string {
+	if (text.length <= MAX_SEARCH_OUTPUT_CHARS) {
+		return text;
+	}
+	const headLimit = Math.ceil(MAX_SEARCH_OUTPUT_CHARS / 2);
+	const tailLimit = Math.max(1, MAX_SEARCH_OUTPUT_CHARS - headLimit);
+	return (
+		`${text.slice(0, headLimit)}\n` +
+		`[... search output truncated: ${text.length} chars total. ` +
+		"Narrow the pattern or scope to view the elided matches ...]\n" +
+		text.slice(-tailLimit)
+	);
+}
diff --git a/sdk/packages/core/src/extensions/tools/executors/web-fetch.ts b/sdk/packages/core/src/extensions/tools/executors/web-fetch.ts
new file mode 100644
index 0000000..e21e9c2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/executors/web-fetch.ts
@@ -0,0 +1,259 @@
+/**
+ * Web Fetch Executor
+ *
+ * Built-in implementation for fetching web content using native fetch.
+ */
+
+import type { AgentToolContext } from "@cline/shared";
+import type { WebFetchExecutor } from "../types";
+
+/**
+ * Options for the web fetch executor
+ */
+export interface WebFetchExecutorOptions {
+	/**
+	 * Timeout for fetch requests in milliseconds
+	 * @default 30000 (30 seconds)
+	 */
+	timeoutMs?: number;
+
+	/**
+	 * Maximum response size in bytes
+	 * @default 5_000_000 (5MB)
+	 */
+	maxResponseBytes?: number;
+
+	/**
+	 * User agent string
+	 * @default "Mozilla/5.0 (compatible; AgentBot/1.0)"
+	 */
+	userAgent?: string;
+
+	/**
+	 * Additional headers
+	 */
+	headers?: Record<string, string>;
+
+	/**
+	 * Whether to follow redirects
+	 * @default true
+	 */
+	followRedirects?: boolean;
+
+	/**
+	 * Maximum number of redirects to follow
+	 * @default 5
+	 */
+	maxRedirects?: number;
+}
+
+/**
+ * Extract text content from HTML
+ * Simple implementation - strips tags and normalizes whitespace
+ */
+function htmlToText(html: string): string {
+	return (
+		html
+			// Remove script and style elements
+			.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+			.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+			// Remove HTML comments
+			.replace(/<!--[\s\S]*?-->/g, "")
+			// Replace block elements with newlines
+			.replace(/<(p|div|br|hr|h[1-6]|li|tr)[^>]*>/gi, "\n")
+			// Remove all remaining tags
+			.replace(/<[^>]+>/g, " ")
+			// Decode HTML entities
+			.replace(/&nbsp;/g, " ")
+			.replace(/&amp;/g, "&")
+			.replace(/&lt;/g, "<")
+			.replace(/&gt;/g, ">")
+			.replace(/&quot;/g, '"')
+			.replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n, 10)))
+			// Normalize whitespace
+			.replace(/\s+/g, " ")
+			.replace(/\n\s+/g, "\n")
+			.replace(/\n{3,}/g, "\n\n")
+			.trim()
+	);
+}
+
+/**
+ * Create a web fetch executor using native fetch
+ *
+ * @example
+ * ```typescript
+ * const webFetch = createWebFetchExecutor({
+ *   timeoutMs: 15000,
+ *   maxResponseBytes: 2_000_000,
+ * })
+ *
+ * const content = await webFetch(
+ *   "https://docs.example.com/api",
+ *   "Extract the authentication section",
+ *   context
+ * )
+ * ```
+ */
+export function createWebFetchExecutor(
+	options: WebFetchExecutorOptions = {},
+): WebFetchExecutor {
+	const {
+		timeoutMs = 30000,
+		maxResponseBytes = 5_000_000,
+		userAgent = "Mozilla/5.0 (compatible; AgentBot/1.0)",
+		headers = {},
+		followRedirects = true,
+		// maxRedirects is available in options but native fetch handles it automatically
+	} = options;
+
+	return async (
+		url: string,
+		prompt: string,
+		context: AgentToolContext,
+	): Promise<string> => {
+		// Validate URL
+		let parsedUrl: URL;
+		try {
+			parsedUrl = new URL(url);
+		} catch {
+			throw new Error(`Invalid URL: ${url}`);
+		}
+
+		// Only allow http and https
+		if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+			throw new Error(
+				`Invalid protocol: ${parsedUrl.protocol}. Only http and https are supported.`,
+			);
+		}
+
+		// Create abort controller for timeout
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		let contextAbortHandler: (() => void) | undefined;
+
+		// Combine with context abort signal
+		if (context.signal) {
+			contextAbortHandler = () => controller.abort();
+			context.signal.addEventListener("abort", contextAbortHandler);
+		}
+
+		try {
+			const response = await fetch(url, {
+				method: "GET",
+				headers: {
+					"User-Agent": userAgent,
+					Accept:
+						"text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7",
+					"Accept-Language": "en-US,en;q=0.9",
+					...headers,
+				},
+				redirect: followRedirects ? "follow" : "manual",
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeout);
+
+			// Check for redirect limit (if we're checking manually)
+			if (!followRedirects && response.status >= 300 && response.status < 400) {
+				const location = response.headers.get("location");
+				return `Redirect to: ${location}`;
+			}
+
+			// Check response status
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			}
+
+			// Get content type
+			const contentType = response.headers.get("content-type") || "";
+
+			// Read response body with size limit
+			const reader = response.body?.getReader();
+			if (!reader) {
+				throw new Error("Failed to read response body");
+			}
+
+			const chunks: Uint8Array[] = [];
+			let totalSize = 0;
+
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				totalSize += value.length;
+				if (totalSize > maxResponseBytes) {
+					reader.cancel();
+					throw new Error(
+						`Response too large: exceeded ${maxResponseBytes} bytes`,
+					);
+				}
+
+				chunks.push(value);
+			}
+
+			// Combine chunks
+			const buffer = new Uint8Array(totalSize);
+			let offset = 0;
+			for (const chunk of chunks) {
+				buffer.set(chunk, offset);
+				offset += chunk.length;
+			}
+
+			// Decode as text
+			const text = new TextDecoder("utf-8").decode(buffer);
+
+			// Process content based on type
+			let content: string;
+			if (
+				contentType.includes("text/html") ||
+				contentType.includes("application/xhtml")
+			) {
+				content = htmlToText(text);
+			} else if (contentType.includes("application/json")) {
+				try {
+					const json = JSON.parse(text);
+					content = JSON.stringify(json, null, 2);
+				} catch {
+					content = text;
+				}
+			} else {
+				content = text;
+			}
+
+			// Format output with metadata
+			const outputLines = [
+				`URL: ${url}`,
+				`Content-Type: ${contentType}`,
+				`Size: ${totalSize} bytes`,
+				``,
+				`--- Content ---`,
+				content.slice(0, 50000), // Limit content size for output
+			];
+
+			if (content.length > 50000) {
+				outputLines.push(
+					`\n[Content truncated: showing first 50000 of ${content.length} characters]`,
+				);
+			}
+
+			outputLines.push(``, `--- Analysis Request ---`, `Prompt: ${prompt}`);
+
+			return outputLines.join("\n");
+		} catch (error) {
+			clearTimeout(timeout);
+
+			if (error instanceof Error) {
+				if (error.name === "AbortError") {
+					throw new Error(`Request timed out after ${timeoutMs}ms`);
+				}
+				throw error;
+			}
+			throw new Error(`Fetch failed: ${String(error)}`);
+		} finally {
+			if (context.signal && contextAbortHandler) {
+				context.signal.removeEventListener("abort", contextAbortHandler);
+			}
+		}
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/helpers.ts b/sdk/packages/core/src/extensions/tools/helpers.ts
new file mode 100644
index 0000000..a9a3373
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/helpers.ts
@@ -0,0 +1,207 @@
+import { validateWithZod } from "@cline/shared";
+import {
+	type EditFileInput,
+	INPUT_ARG_CHAR_LIMIT,
+	type ReadFileRequest,
+	RunCommandsInputUnionSchema,
+	type StructuredCommandInput,
+} from "./schemas";
+
+/**
+ * Format an error into a string message
+ */
+export function formatError(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+export function getEditorSizeError(input: EditFileInput): string | null {
+	if (
+		typeof input.old_text === "string" &&
+		input.old_text.length > INPUT_ARG_CHAR_LIMIT
+	) {
+		return `Editor input too large: old_text was ${input.old_text.length} characters, exceeding the recommended limit of ${INPUT_ARG_CHAR_LIMIT}. Split the edit into smaller tool calls so later tool calls are less likely to be truncated or time out.`;
+	}
+
+	if (input.new_text.length > INPUT_ARG_CHAR_LIMIT) {
+		return `Editor input too large: new_text was ${input.new_text.length} characters, exceeding the recommended limit of ${INPUT_ARG_CHAR_LIMIT}. Split the edit into smaller tool calls so later tool calls are less likely to be truncated or time out.`;
+	}
+
+	return null;
+}
+
+/**
+ * Create a timeout-wrapped promise
+ */
+export class TimeoutError extends Error {
+	readonly timeoutMs: number;
+
+	constructor(message: string, timeoutMs: number) {
+		super(message);
+		this.name = "TimeoutError";
+		this.timeoutMs = timeoutMs;
+	}
+}
+
+export function withTimeout<T>(
+	promise: Promise<T>,
+	ms: number,
+	message: string,
+): Promise<T> {
+	return Promise.race([
+		promise,
+		new Promise<never>((_, reject) => {
+			setTimeout(() => reject(new TimeoutError(message, ms)), ms);
+		}),
+	]);
+}
+
+export function formatReadFileQuery(request: ReadFileRequest): string {
+	const { path, start_line, end_line } = request;
+	if (start_line == null && end_line == null) {
+		return path;
+	}
+	const start = start_line ?? 1;
+	const end = end_line ?? "EOF";
+	return `${path}:${start}-${end}`;
+}
+
+export function getReadFileRangeError(request: ReadFileRequest): string | null {
+	const { start_line, end_line } = request;
+	if (start_line == null || end_line == null || start_line <= end_line) {
+		return null;
+	}
+
+	return `start_line must be less than or equal to end_line (received start_line: ${start_line}, end_line: ${end_line})`;
+}
+
+const READ_RANGE_KEYS = new Set(["start_line", "end_line"]);
+
+function isOrphanReadRangeEntry(
+	value: unknown,
+): value is Record<string, unknown> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		return false;
+	}
+	const keys = Object.keys(value);
+	return keys.length > 0 && keys.every((key) => READ_RANGE_KEYS.has(key));
+}
+
+function coalesceOrphanReadRangeEntries(entries: unknown[]): unknown[] {
+	const coalesced: unknown[] = [];
+	for (const entry of entries) {
+		if (isOrphanReadRangeEntry(entry)) {
+			const previous = coalesced[coalesced.length - 1];
+			if (typeof previous === "string") {
+				coalesced[coalesced.length - 1] = { path: previous, ...entry };
+				continue;
+			}
+			if (
+				previous !== null &&
+				typeof previous === "object" &&
+				!Array.isArray(previous) &&
+				"path" in previous &&
+				Object.keys(entry).every((key) => !(key in previous))
+			) {
+				coalesced[coalesced.length - 1] = { ...previous, ...entry };
+				continue;
+			}
+		}
+		coalesced.push(entry);
+	}
+	return coalesced;
+}
+
+/**
+ * Some models emit a file's line range as a separate array element instead of
+ * placing start_line/end_line on the same object as its path. Fold such
+ * orphan range entries into the preceding file entry before validation.
+ */
+export function coalesceOrphanReadRanges(input: unknown): unknown {
+	if (Array.isArray(input)) {
+		return coalesceOrphanReadRangeEntries(input);
+	}
+	if (input !== null && typeof input === "object") {
+		for (const key of ["files", "paths"] as const) {
+			const value = (input as Record<string, unknown>)[key];
+			if (Array.isArray(value)) {
+				return { ...input, [key]: coalesceOrphanReadRangeEntries(value) };
+			}
+		}
+	}
+	return input;
+}
+
+export function normalizeRunCommandsInput(
+	input: unknown,
+): Array<string | StructuredCommandInput> {
+	const validate = validateWithZod(RunCommandsInputUnionSchema, input);
+
+	if (typeof validate === "string") {
+		return [validate];
+	}
+
+	if (Array.isArray(validate)) {
+		return validate;
+	}
+
+	if ("commands" in validate) {
+		return Array.isArray(validate.commands)
+			? validate.commands
+			: [validate.commands];
+	}
+
+	if ("command" in validate) {
+		return "args" in validate ? [validate] : [validate.command];
+	}
+
+	if ("cmd" in validate) {
+		return [validate.cmd];
+	}
+
+	return [validate];
+}
+
+export function formatRunCommandQuery(
+	command: string | StructuredCommandInput,
+): string {
+	if (typeof command === "string") {
+		return command;
+	}
+
+	const args = command.args ?? [];
+	if (args.length === 0) {
+		return command.command;
+	}
+
+	const renderedArgs = args.map((arg) =>
+		/[\s"]/u.test(arg) ? JSON.stringify(arg) : arg,
+	);
+	return `${command.command} ${renderedArgs.join(" ")}`;
+}
+
+/**
+ * Max characters of the executed command echoed back in the tool result's
+ * `query` field. The full command already exists in the assistant tool-call
+ * input, so repeating it in the result only duplicates tokens in the
+ * provider request (expensive for large heredoc/file-generation commands).
+ */
+export const RUN_COMMAND_QUERY_PREVIEW_LIMIT = 200;
+
+/**
+ * Bound the command echo placed in a provider-facing tool result.
+ * Short commands pass through unchanged; long commands keep a short
+ * prefix plus a truncation note so the result is still identifiable.
+ */
+export function formatRunCommandQueryPreview(
+	command: string | StructuredCommandInput,
+): string {
+	const rendered = formatRunCommandQuery(command);
+	if (rendered.length <= RUN_COMMAND_QUERY_PREVIEW_LIMIT) {
+		return rendered;
+	}
+	const truncatedChars = rendered.length - RUN_COMMAND_QUERY_PREVIEW_LIMIT;
+	return `${rendered.slice(0, RUN_COMMAND_QUERY_PREVIEW_LIMIT)} ... [command truncated: ${truncatedChars} more chars; full command is in the tool call input]`;
+}
diff --git a/sdk/packages/core/src/extensions/tools/index.ts b/sdk/packages/core/src/extensions/tools/index.ts
new file mode 100644
index 0000000..0b4c546
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/index.ts
@@ -0,0 +1,189 @@
+/**
+ * Default Tools
+ *
+ * This module provides a set of configurable default tools for agents.
+ */
+
+// Zod Utilities
+export { validateWithZod, zodToJsonSchema } from "@cline/shared";
+// Constants
+export { ALL_DEFAULT_TOOL_NAMES, DefaultToolNames } from "./constants";
+// AgentTool Definitions
+export {
+	createApplyPatchTool,
+	createAskQuestionTool,
+	createDefaultTools,
+	createEditorTool,
+	createReadFilesTool,
+	createSearchTool,
+	createShellTool,
+	createSkillsTool,
+	createSubmitAndExitTool,
+	createWebFetchTool,
+} from "./definitions";
+// Built-in Executors
+export {
+	type ApplyPatchExecutorOptions,
+	createApplyPatchExecutor,
+	createDefaultExecutors,
+	createDefaultShellExecutor,
+	createEditorExecutor,
+	createFileReadExecutor,
+	createSearchExecutor,
+	createShellExecutor,
+	createWebFetchExecutor,
+	type DefaultExecutorsOptions,
+	type EditorExecutorOptions,
+	type FileReadExecutorOptions,
+	type SearchExecutorOptions,
+	type ShellExecutorOptions,
+	type WebFetchExecutorOptions,
+} from "./executors/index";
+export {
+	MAX_COMMAND_OUTPUT_CHARS,
+	truncateCommandOutput,
+} from "./executors/output-limits";
+export {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+	type ToolRoutingRule,
+} from "./model-tool-routing";
+// Presets
+export {
+	createDefaultToolsWithPreset,
+	createToolPoliciesWithPreset,
+	resolveToolPresetName,
+	type ToolPolicyPresetName,
+	type ToolPresetName,
+	ToolPresets,
+} from "./presets";
+export {
+	type BuiltinToolAvailabilityContext,
+	getCoreAcpToolNames,
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	resolveCoreSelectedToolIds,
+	type ToolCatalogEntry,
+} from "./runtime";
+// Schemas
+export {
+	type ApplyPatchInput,
+	ApplyPatchInputSchema,
+	type AskQuestionInput,
+	AskQuestionInputSchema,
+	type EditFileInput,
+	EditFileInputSchema,
+	type FetchWebContentInput,
+	FetchWebContentInputSchema,
+	type ReadFileRequest,
+	ReadFileRequestSchema,
+	type ReadFilesInput,
+	ReadFilesInputSchema,
+	type RunCommandsInput,
+	RunCommandsInputSchema,
+	type SearchCodebaseInput,
+	SearchCodebaseInputSchema,
+	type SkillsInput,
+	SkillsInputSchema,
+	type StructuredCommandInput,
+	StructuredCommandInputSchema,
+	type SubmitInput,
+	SubmitInputSchema,
+	type WebFetchRequest,
+	WebFetchRequestSchema,
+} from "./schemas";
+export { TEAM_TOOL_NAMES } from "./team/team-tools";
+// Types
+export type {
+	ApplyPatchExecutor,
+	AskQuestionExecutor,
+	CreateDefaultToolsOptions,
+	DefaultToolName,
+	DefaultToolsConfig,
+	EditorExecutor,
+	FileReadExecutor,
+	SearchExecutor,
+	ShellExecutor,
+	SkillsExecutor,
+	SkillsExecutorSkillMetadata,
+	SkillsExecutorWithMetadata,
+	ToolExecutors,
+	ToolOperationResult,
+	VerifySubmitExecutor,
+	WebFetchExecutor,
+} from "./types";
+
+// =============================================================================
+// Convenience: Create Tools with Built-in Executors
+// =============================================================================
+
+import type { AgentTool } from "@cline/shared";
+import { createDefaultTools } from "./definitions";
+import {
+	createDefaultExecutors,
+	type DefaultExecutorsOptions,
+} from "./executors/index";
+import type { CreateDefaultToolsOptions, ToolExecutors } from "./types";
+
+/**
+ * Options for creating default tools with built-in executors
+ */
+export interface CreateBuiltinToolsOptions
+	extends Omit<CreateDefaultToolsOptions, "executors"> {
+	/**
+	 * Configuration for the built-in executors
+	 */
+	executorOptions?: DefaultExecutorsOptions;
+	/**
+	 * Optional executor overrides/additions for tools without built-ins
+	 */
+	executors?: Partial<ToolExecutors>;
+}
+
+/**
+ * Create default tools with built-in Node.js executors
+ *
+ * This is a convenience function that creates the default tools with
+ * working implementations using Node.js built-in modules.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, createBuiltinTools } from "@cline/core"
+ *
+ * const tools = createBuiltinTools({
+ *   cwd: "/path/to/project",
+ *   enableBash: true,
+ *   enableWebFetch: false, // Disable web fetching
+ *   executorOptions: {
+ *     bash: { timeoutMs: 60000 },
+ *   },
+ * })
+ *
+ * const agent = new Agent({
+ *   providerId: "anthropic",
+ *   modelId: "claude-sonnet-4-20250514",
+ *   systemPrompt: "You are a coding assistant.",
+ *   tools,
+ * })
+ * ```
+ */
+export function createBuiltinTools(
+	options: CreateBuiltinToolsOptions = {},
+): AgentTool[] {
+	const {
+		executorOptions = {},
+		executors: executorOverrides,
+		...toolsConfig
+	} = options;
+
+	const executors = {
+		...createDefaultExecutors(executorOptions),
+		...(executorOverrides ?? {}),
+	};
+
+	return createDefaultTools({
+		...toolsConfig,
+		executors,
+	});
+}
diff --git a/sdk/packages/core/src/extensions/tools/model-tool-routing.test.ts b/sdk/packages/core/src/extensions/tools/model-tool-routing.test.ts
new file mode 100644
index 0000000..a9549e6
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/model-tool-routing.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+} from "./model-tool-routing";
+
+describe("model tool routing", () => {
+	it("applies default codex/gpt routing in act mode", () => {
+		const config = resolveToolRoutingConfig(
+			"openai",
+			"openai/gpt-5.4",
+			"act",
+			DEFAULT_MODEL_TOOL_ROUTING_RULES,
+		);
+
+		expect(config.enableApplyPatch).toBe(true);
+		expect(config.enableEditor).toBe(false);
+	});
+
+	it("does not apply default codex/gpt routing in plan mode", () => {
+		const config = resolveToolRoutingConfig(
+			"openai",
+			"openai/gpt-5.4",
+			"plan",
+			DEFAULT_MODEL_TOOL_ROUTING_RULES,
+		);
+
+		expect(config).toEqual({});
+	});
+
+	it("applies matching custom rules in order", () => {
+		const config = resolveToolRoutingConfig(
+			"anthropic",
+			"claude-sonnet-4-6",
+			"act",
+			[
+				{
+					name: "claude-editor-off",
+					mode: "act",
+					modelIdIncludes: ["claude"],
+					disableTools: ["editor"],
+				},
+				{
+					name: "claude-apply-patch-on",
+					mode: "act",
+					modelIdIncludes: ["claude"],
+					enableTools: ["apply_patch"],
+				},
+			],
+		);
+
+		expect(config.enableEditor).toBe(false);
+		expect(config.enableApplyPatch).toBe(true);
+	});
+
+	it("returns empty config when no rules match", () => {
+		const config = resolveToolRoutingConfig(
+			"anthropic",
+			"claude-sonnet-4-6",
+			"act",
+			[
+				{
+					mode: "act",
+					modelIdIncludes: ["gpt"],
+					enableTools: ["apply_patch"],
+				},
+			],
+		);
+
+		expect(config).toEqual({});
+	});
+
+	it("can match provider-only rules", () => {
+		const config = resolveToolRoutingConfig("openai", "o4-mini", "act", [
+			{
+				mode: "act",
+				providerIdIncludes: ["openai"],
+				enableTools: ["apply_patch"],
+				disableTools: ["editor"],
+			},
+		]);
+
+		expect(config.enableApplyPatch).toBe(true);
+		expect(config.enableEditor).toBe(false);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/model-tool-routing.ts b/sdk/packages/core/src/extensions/tools/model-tool-routing.ts
new file mode 100644
index 0000000..cc20375
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/model-tool-routing.ts
@@ -0,0 +1,134 @@
+import type { CoreAgentMode } from "../../types/config";
+import type { DefaultToolName, DefaultToolsConfig } from "./types";
+
+export interface ToolRoutingRule {
+	/**
+	 * Optional rule label for debugging and logs.
+	 */
+	name?: string;
+	/**
+	 * Which mode the rule applies to.
+	 * @default "any"
+	 */
+	mode?: CoreAgentMode | "any";
+	/**
+	 * Case-insensitive substrings that must match the model ID.
+	 * When omitted/empty, the rule is not constrained by model ID.
+	 */
+	modelIdIncludes?: string[];
+	/**
+	 * Case-insensitive substrings that must match the provider ID.
+	 * When omitted/empty, the rule is not constrained by provider ID.
+	 */
+	providerIdIncludes?: string[];
+	/**
+	 * Enable these tools when the rule matches.
+	 */
+	enableTools?: DefaultToolName[];
+	/**
+	 * Disable these tools when the rule matches.
+	 */
+	disableTools?: DefaultToolName[];
+}
+
+const TOOL_NAME_TO_FLAG: Record<
+	DefaultToolName,
+	keyof Pick<
+		DefaultToolsConfig,
+		| "enableReadFiles"
+		| "enableSearch"
+		| "enableBash"
+		| "enableWebFetch"
+		| "enableApplyPatch"
+		| "enableEditor"
+		| "enableSkills"
+		| "enableAskQuestion"
+		| "enableSubmitAndExit"
+	>
+> = {
+	read_files: "enableReadFiles",
+	search_codebase: "enableSearch",
+	run_commands: "enableBash",
+	fetch_web_content: "enableWebFetch",
+	apply_patch: "enableApplyPatch",
+	editor: "enableEditor",
+	skills: "enableSkills",
+	ask_question: "enableAskQuestion",
+	submit_and_exit: "enableSubmitAndExit",
+};
+
+export const DEFAULT_MODEL_TOOL_ROUTING_RULES: ToolRoutingRule[] = [
+	{
+		name: "openai-native-use-apply-patch",
+		mode: "act",
+		providerIdIncludes: ["openai-native"],
+		enableTools: ["apply_patch"],
+		disableTools: ["editor"],
+	},
+	{
+		name: "codex-and-gpt-use-apply-patch",
+		mode: "act",
+		modelIdIncludes: ["codex", "gpt"],
+		enableTools: ["apply_patch"],
+		disableTools: ["editor"],
+	},
+];
+
+function matchesModelId(
+	modelId: string,
+	includes: string[] | undefined,
+): boolean {
+	if (!includes || includes.length === 0) {
+		return true;
+	}
+	const normalizedModelId = modelId.toLowerCase();
+	return includes.some((value) =>
+		normalizedModelId.includes(value.toLowerCase()),
+	);
+}
+
+function matchesRule(
+	rule: ToolRoutingRule,
+	providerId: string,
+	modelId: string,
+	mode: CoreAgentMode,
+): boolean {
+	if (rule.mode && rule.mode !== "any" && rule.mode !== mode) {
+		return false;
+	}
+	return (
+		matchesModelId(providerId, rule.providerIdIncludes) &&
+		matchesModelId(modelId, rule.modelIdIncludes)
+	);
+}
+
+export function resolveToolRoutingConfig(
+	providerId: string,
+	modelId: string,
+	mode: CoreAgentMode,
+	rules: ToolRoutingRule[] | undefined,
+): Partial<DefaultToolsConfig> {
+	if (!rules || rules.length === 0) {
+		return {};
+	}
+
+	const toggles = new Map<DefaultToolName, boolean>();
+
+	for (const rule of rules) {
+		if (!matchesRule(rule, providerId, modelId, mode)) {
+			continue;
+		}
+		for (const toolName of rule.disableTools ?? []) {
+			toggles.set(toolName, false);
+		}
+		for (const toolName of rule.enableTools ?? []) {
+			toggles.set(toolName, true);
+		}
+	}
+
+	const config: Partial<DefaultToolsConfig> = {};
+	for (const [toolName, enabled] of toggles.entries()) {
+		config[TOOL_NAME_TO_FLAG[toolName]] = enabled;
+	}
+	return config;
+}
diff --git a/sdk/packages/core/src/extensions/tools/presets.test.ts b/sdk/packages/core/src/extensions/tools/presets.test.ts
new file mode 100644
index 0000000..fdd1cf2
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/presets.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import {
+	createDefaultToolsWithPreset,
+	createToolPoliciesWithPreset,
+	ToolPresets,
+} from "./presets";
+
+describe("default tool presets", () => {
+	it("explicitly configures ask_question across presets", () => {
+		expect(ToolPresets.search.enableAskQuestion).toBe(false);
+		expect(ToolPresets.act.enableAskQuestion).toBe(true);
+		expect(ToolPresets.plan.enableAskQuestion).toBe(true);
+		expect(ToolPresets.minimal.enableAskQuestion).toBe(false);
+		expect(ToolPresets.yolo.enableAskQuestion).toBe(false);
+	});
+
+	it("disables spawn and team tools by default in yolo mode", () => {
+		expect(ToolPresets.act.enableSpawnAgent).toBe(true);
+		expect(ToolPresets.act.enableAgentTeams).toBe(true);
+		expect(ToolPresets.yolo.enableSpawnAgent).toBe(false);
+		expect(ToolPresets.yolo.enableAgentTeams).toBe(false);
+		expect(ToolPresets.yolo.enableSubmitAndExit).toBe(true);
+	});
+
+	it("disables search and web fetch in yolo mode", () => {
+		expect(ToolPresets.yolo.enableSearch).toBe(false);
+		expect(ToolPresets.yolo.enableWebFetch).toBe(false);
+	});
+
+	it("yolo preset excludes ask_question even when its executor exists", () => {
+		const tools = createDefaultToolsWithPreset("yolo", {
+			executors: {
+				readFile: async () => "ok",
+				search: async () => "ok",
+				bash: async () => "ok",
+				webFetch: async () => "ok",
+				applyPatch: async () => "ok",
+				editor: async () => "ok",
+				skills: async () => "ok",
+				askQuestion: async () => "ok",
+			},
+		});
+
+		expect(tools.map((tool) => tool.name)).toEqual([
+			"read_files",
+			"run_commands",
+			"editor",
+		]);
+	});
+});
+
+describe("tool policy presets", () => {
+	it("returns empty policies for default", () => {
+		expect(createToolPoliciesWithPreset("default")).toEqual({});
+	});
+
+	it("yolo preset enables and auto-approves all tools", () => {
+		const policies = createToolPoliciesWithPreset("yolo");
+		expect(policies["*"]).toEqual({
+			enabled: true,
+			autoApprove: true,
+		});
+		expect(policies.ask_question).toEqual({
+			enabled: true,
+			autoApprove: true,
+		});
+		expect(policies.skills).toEqual({
+			enabled: true,
+			autoApprove: true,
+		});
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/presets.ts b/sdk/packages/core/src/extensions/tools/presets.ts
new file mode 100644
index 0000000..685c9f3
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/presets.ts
@@ -0,0 +1,190 @@
+/**
+ * AgentTool Presets
+ *
+ * Pre-configured tool combinations for common use cases.
+ */
+
+import type { AgentMode, AgentTool, ToolPolicy } from "@cline/shared";
+import { ALL_DEFAULT_TOOL_NAMES } from "./constants";
+import { createDefaultTools } from "./definitions";
+import type { CreateDefaultToolsOptions, DefaultToolsConfig } from "./types";
+
+export interface ToolPresetConfig extends DefaultToolsConfig {
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+}
+
+/**
+ * Preset configurations for common use cases
+ */
+export const ToolPresets = {
+	/**
+	 * Act mode (full development tools)
+	 * Good for coding assistants and task automation
+	 */
+	act: {
+		enableReadFiles: true,
+		enableSearch: true,
+		enableBash: true,
+		enableWebFetch: true,
+		enableApplyPatch: false,
+		enableEditor: true,
+		enableSkills: true,
+		enableAskQuestion: true,
+		enableSubmitAndExit: false,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+	},
+
+	/**
+	 * Plan mode (read-only, no shell access)
+	 * Good for analysis and documentation agents
+	 */
+	plan: {
+		enableReadFiles: true,
+		enableSearch: true,
+		enableBash: true,
+		enableWebFetch: true,
+		enableApplyPatch: false,
+		enableEditor: false,
+		enableSkills: true,
+		enableAskQuestion: true,
+		enableSubmitAndExit: false,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+	},
+
+	/**
+	 * Search-focused tools (read_files + search_codebase)
+	 * Good for code exploration and analysis agents
+	 */
+	search: {
+		enableReadFiles: true,
+		enableSearch: true,
+		enableBash: false,
+		enableWebFetch: false,
+		enableApplyPatch: false,
+		enableEditor: false,
+		enableSkills: false,
+		enableAskQuestion: false,
+		enableSubmitAndExit: false,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+	},
+
+	/**
+	 * Minimal tools for focused tasks
+	 */
+	minimal: {
+		enableReadFiles: false,
+		enableSearch: false,
+		enableBash: true,
+		enableWebFetch: false,
+		enableApplyPatch: false,
+		enableEditor: false,
+		enableSkills: false,
+		enableAskQuestion: false,
+		enableSubmitAndExit: false,
+		enableSpawnAgent: true,
+		enableAgentTeams: false,
+	},
+
+	/**
+	 * YOLO mode (automation-focused tools + no approval required)
+	 * Good for trusted local automation workflows.
+	 */
+	yolo: {
+		enableReadFiles: true,
+		enableSearch: false,
+		enableBash: true,
+		enableWebFetch: false,
+		enableApplyPatch: false,
+		enableEditor: true,
+		enableSkills: false,
+		enableAskQuestion: false,
+		enableSubmitAndExit: true,
+		enableSpawnAgent: false,
+		enableAgentTeams: false,
+	},
+} as const satisfies Record<string, ToolPresetConfig>;
+
+/**
+ * Type for preset names
+ */
+export type ToolPresetName = keyof typeof ToolPresets;
+
+export function resolveToolPresetName(options: {
+	mode?: AgentMode;
+}): ToolPresetName {
+	if (options.mode === "plan") {
+		return "plan";
+	}
+	if (options.mode === "yolo") {
+		return "yolo";
+	}
+	return "act";
+}
+
+/**
+ * AgentTool policy preset names
+ */
+export type ToolPolicyPresetName = "default" | "yolo";
+
+/**
+ * Build tool policies for a preset.
+ * `yolo` guarantees tool policies are enabled and auto-approved.
+ */
+export function createToolPoliciesWithPreset(
+	presetName: ToolPolicyPresetName,
+): Record<string, ToolPolicy> {
+	if (presetName !== "yolo") {
+		return {};
+	}
+
+	const yoloPolicy: ToolPolicy = {
+		enabled: true,
+		autoApprove: true,
+	};
+
+	const policies: Record<string, ToolPolicy> = {
+		"*": yoloPolicy,
+	};
+
+	for (const toolName of ALL_DEFAULT_TOOL_NAMES) {
+		policies[toolName] = yoloPolicy;
+	}
+
+	return policies;
+}
+
+/**
+ * Create default tools using a preset configuration
+ *
+ * @example
+ * ```typescript
+ * const tools = createDefaultToolsWithPreset("plan", {
+ *   executors: {
+ *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
+ *     search: async (query, cwd) => searchFiles(query, cwd),
+ *     webFetch: async (url, prompt) => fetchAndAnalyze(url, prompt),
+ *   },
+ *   cwd: "/path/to/project",
+ * })
+ * ```
+ */
+export function createDefaultToolsWithPreset(
+	presetName: ToolPresetName,
+	options: Omit<CreateDefaultToolsOptions, keyof DefaultToolsConfig> &
+		Partial<DefaultToolsConfig>,
+): AgentTool[] {
+	const preset = ToolPresets[presetName];
+	const {
+		enableSpawnAgent: _enableSpawnAgent,
+		enableAgentTeams: _enableAgentTeams,
+		...toolConfig
+	} = preset;
+	return createDefaultTools({
+		...toolConfig,
+		...options,
+	});
+}
diff --git a/sdk/packages/core/src/extensions/tools/runtime.test.ts b/sdk/packages/core/src/extensions/tools/runtime.test.ts
new file mode 100644
index 0000000..8dccde4
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/runtime.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import {
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	resolveCoreSelectedToolIds,
+} from "./runtime";
+
+describe("builtin tool catalog", () => {
+	it("includes spawn and teams entries", () => {
+		const catalog = getCoreBuiltinToolCatalog({ mode: "act" });
+		expect(catalog.some((entry) => entry.id === "spawn_agent")).toBe(true);
+		expect(catalog.some((entry) => entry.id === "teams")).toBe(true);
+	});
+
+	it("marks teams enabled by default in act mode", () => {
+		const catalog = getCoreBuiltinToolCatalog({ mode: "act" });
+		expect(catalog.find((entry) => entry.id === "teams")?.defaultEnabled).toBe(
+			true,
+		);
+		expect(
+			catalog.find((entry) => entry.id === "spawn_agent")?.defaultEnabled,
+		).toBe(true);
+	});
+
+	it("marks teams and spawn disabled by default in yolo mode", () => {
+		const catalog = getCoreBuiltinToolCatalog({ mode: "yolo" });
+		expect(catalog.find((entry) => entry.id === "teams")?.defaultEnabled).toBe(
+			false,
+		);
+		expect(
+			catalog.find((entry) => entry.id === "spawn_agent")?.defaultEnabled,
+		).toBe(false);
+	});
+
+	it("expands grouped headless tool names for selected entries", () => {
+		const names = getCoreHeadlessToolNames(new Set(["teams", "read_files"]), {
+			mode: "act",
+		});
+		expect(names).toContain("read_files");
+		expect(names).toContain("team_status");
+		expect(names).toContain("team_run_task");
+	});
+
+	it("uses a single editor catalog entry and maps to apply_patch when routed", () => {
+		const actCatalog = getCoreBuiltinToolCatalog({ mode: "act" });
+		expect(actCatalog.some((entry) => entry.id === "apply_patch")).toBe(false);
+		expect(
+			actCatalog.find((entry) => entry.id === "editor")?.headlessToolNames,
+		).toEqual(["editor"]);
+
+		const gptCatalog = getCoreBuiltinToolCatalog({
+			mode: "act",
+			modelId: "openai/gpt-5.4",
+			providerId: "openai",
+		});
+		expect(
+			gptCatalog.find((entry) => entry.id === "editor")?.headlessToolNames,
+		).toEqual(["apply_patch"]);
+		expect(gptCatalog.some((entry) => entry.id === "submit_and_exit")).toBe(
+			false,
+		);
+	});
+
+	it("resolves default selected ids from the catalog", () => {
+		const selected = resolveCoreSelectedToolIds({
+			enabled: true,
+			availabilityContext: { mode: "act" },
+		});
+		expect(selected.has("teams")).toBe(true);
+		expect(selected.has("spawn_agent")).toBe(true);
+		expect(getCoreDefaultEnabledToolIds({ mode: "act" })).toContain("teams");
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/runtime.ts b/sdk/packages/core/src/extensions/tools/runtime.ts
new file mode 100644
index 0000000..2f3a8d7
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/runtime.ts
@@ -0,0 +1,261 @@
+import type { CoreAgentMode } from "../../types/config";
+import {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+} from "./model-tool-routing";
+import { resolveToolPresetName, ToolPresets } from "./presets";
+import { createSpawnAgentTool } from "./team/spawn-agent-tool";
+import { TEAM_TOOL_NAMES } from "./team/team-tools";
+import type { DefaultToolsConfig } from "./types";
+
+export interface ToolCatalogEntry {
+	id: string;
+	description: string;
+	defaultEnabled: boolean;
+	headlessToolNames: string[];
+}
+
+export interface BuiltinToolAvailabilityContext {
+	mode?: CoreAgentMode;
+	providerId?: string;
+	modelId?: string;
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+	disabledToolIds?: ReadonlySet<string>;
+}
+
+type RuntimeToolCatalogEntry = Omit<ToolCatalogEntry, "defaultEnabled">;
+
+const BASE_TOOL_CATALOG: readonly RuntimeToolCatalogEntry[] = [
+	{
+		id: "read_files",
+		description:
+			"Read the content of text or image files at the provided absolute paths, or return only an inclusive one-based line range when start_line/end_line are provided. Long files are windowed; page with start_line/end_line.",
+		headlessToolNames: ["read_files"],
+	},
+	{
+		id: "search_codebase",
+		description:
+			"Perform regex pattern searches across the codebase for code patterns, definitions, imports, and other text matches.",
+		headlessToolNames: ["search_codebase"],
+	},
+	{
+		id: "run_commands",
+		description:
+			"Run shell commands from the root of the workspace for listing files, checking git status, builds, tests, and similar tasks.",
+		headlessToolNames: ["run_commands"],
+	},
+	{
+		id: "editor",
+		description:
+			"Make controlled filesystem edits on text files with create, replace, and insert operations.",
+		headlessToolNames: ["editor"],
+	},
+	{
+		id: "fetch_web_content",
+		description:
+			"Fetch URL content and analyze it with a prompt describing what to extract.",
+		headlessToolNames: ["fetch_web_content"],
+	},
+	{
+		id: "skills",
+		description:
+			"Execute a configured skill within the main conversation when a matching skill exists for the task.",
+		headlessToolNames: ["skills"],
+	},
+	{
+		id: "ask_question",
+		description:
+			"Ask the user a single clarifying question with 2-5 selectable options.",
+		headlessToolNames: ["ask_question"],
+	},
+	{
+		id: "spawn_agent",
+		description: createSpawnAgentTool({ configProvider: {} as never })
+			.description,
+		headlessToolNames: ["spawn_agent"],
+	},
+	{
+		id: "teams",
+		description:
+			"Enable team collaboration tools for teammate management, task coordination, mailbox messaging, mission logs, and outcomes.",
+		headlessToolNames: [...TEAM_TOOL_NAMES],
+	},
+] as const;
+
+const TOOL_NAME_TO_FLAG: Partial<
+	Record<
+		string,
+		keyof Pick<
+			DefaultToolsConfig,
+			| "enableReadFiles"
+			| "enableSearch"
+			| "enableBash"
+			| "enableWebFetch"
+			| "enableApplyPatch"
+			| "enableEditor"
+			| "enableSkills"
+			| "enableAskQuestion"
+			| "enableSubmitAndExit"
+		>
+	>
+> = {
+	read_files: "enableReadFiles",
+	search_codebase: "enableSearch",
+	run_commands: "enableBash",
+	fetch_web_content: "enableWebFetch",
+	apply_patch: "enableApplyPatch",
+	editor: "enableEditor",
+	skills: "enableSkills",
+	ask_question: "enableAskQuestion",
+};
+
+function resolveContextMode(
+	mode?: BuiltinToolAvailabilityContext["mode"],
+): CoreAgentMode {
+	return mode === "plan" || mode === "yolo" ? mode : "act";
+}
+
+type ResolvedToolFlags = Pick<
+	DefaultToolsConfig,
+	| "enableReadFiles"
+	| "enableSearch"
+	| "enableBash"
+	| "enableWebFetch"
+	| "enableApplyPatch"
+	| "enableEditor"
+	| "enableSkills"
+	| "enableAskQuestion"
+	| "enableSubmitAndExit"
+> & {
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+};
+
+function resolvePresetFlags(context: BuiltinToolAvailabilityContext): {
+	mode: CoreAgentMode;
+	flags: ResolvedToolFlags;
+} {
+	const mode = resolveContextMode(context.mode);
+	const preset = ToolPresets[resolveToolPresetName({ mode })];
+	const routed = resolveToolRoutingConfig(
+		context.providerId ?? "",
+		context.modelId ?? "",
+		mode,
+		DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	);
+	return {
+		mode,
+		flags: {
+			...preset,
+			...routed,
+			...(typeof context.enableSpawnAgent === "boolean"
+				? { enableSpawnAgent: context.enableSpawnAgent }
+				: {}),
+			...(typeof context.enableAgentTeams === "boolean"
+				? { enableAgentTeams: context.enableAgentTeams }
+				: {}),
+		},
+	};
+}
+
+function isEntryEnabledByDefault(
+	entryId: string,
+	context: BuiltinToolAvailabilityContext,
+): boolean {
+	if (context.disabledToolIds?.has(entryId)) {
+		return false;
+	}
+
+	const { flags } = resolvePresetFlags(context);
+	if (entryId === "spawn_agent") {
+		return flags.enableSpawnAgent === true;
+	}
+	if (entryId === "teams") {
+		return flags.enableAgentTeams === true;
+	}
+	if (entryId === "editor") {
+		return flags.enableEditor === true || flags.enableApplyPatch === true;
+	}
+
+	const flag = TOOL_NAME_TO_FLAG[entryId];
+	return flag ? flags[flag] === true : false;
+}
+
+function buildCatalogEntry(
+	entry: RuntimeToolCatalogEntry,
+	context: BuiltinToolAvailabilityContext,
+): ToolCatalogEntry {
+	if (entry.id === "editor") {
+		const { flags } = resolvePresetFlags(context);
+		const usesApplyPatch =
+			flags.enableApplyPatch === true && flags.enableEditor !== true;
+		return {
+			...entry,
+			defaultEnabled: isEntryEnabledByDefault(entry.id, context),
+			headlessToolNames: [usesApplyPatch ? "apply_patch" : "editor"],
+		};
+	}
+
+	return {
+		...entry,
+		defaultEnabled: isEntryEnabledByDefault(entry.id, context),
+	};
+}
+
+export function getCoreBuiltinToolCatalog(
+	context: BuiltinToolAvailabilityContext = {},
+): ToolCatalogEntry[] {
+	return BASE_TOOL_CATALOG.map((entry) => buildCatalogEntry(entry, context));
+}
+
+export function getCoreDefaultEnabledToolIds(
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreBuiltinToolCatalog(context)
+		.filter((entry) => entry.defaultEnabled)
+		.map((entry) => entry.id);
+}
+
+export function resolveCoreSelectedToolIds(input: {
+	enabled: boolean;
+	allowlist?: string[];
+	availabilityContext?: BuiltinToolAvailabilityContext;
+}): Set<string> {
+	if (!input.enabled) {
+		return new Set();
+	}
+
+	const catalog = getCoreBuiltinToolCatalog(input.availabilityContext);
+	const known = new Set(catalog.map((entry) => entry.id));
+	if (!input.allowlist || input.allowlist.length === 0) {
+		return new Set(
+			catalog.filter((entry) => entry.defaultEnabled).map((entry) => entry.id),
+		);
+	}
+
+	for (const id of input.allowlist) {
+		if (!known.has(id)) {
+			throw new Error(
+				`Unknown tool "${id}". Available tools: ${catalog.map((entry) => entry.id).join(", ")}`,
+			);
+		}
+	}
+	return new Set(input.allowlist);
+}
+
+export function getCoreHeadlessToolNames(
+	selectedToolIds: ReadonlySet<string>,
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreBuiltinToolCatalog(context)
+		.filter((entry) => selectedToolIds.has(entry.id))
+		.flatMap((entry) => entry.headlessToolNames);
+}
+
+export function getCoreAcpToolNames(
+	selectedToolIds: ReadonlySet<string>,
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreHeadlessToolNames(selectedToolIds, context);
+}
diff --git a/sdk/packages/core/src/extensions/tools/schemas.ts b/sdk/packages/core/src/extensions/tools/schemas.ts
new file mode 100644
index 0000000..85fb062
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/schemas.ts
@@ -0,0 +1,324 @@
+/**
+ * Zod Schemas for Default Tool Inputs
+ *
+ * These schemas define the input structure for each default tool
+ * and are used for both validation and JSON Schema generation.
+ */
+
+import { z } from "zod";
+
+export const INPUT_ARG_CHAR_LIMIT = 6000;
+
+/**
+ * Schema for read tool input
+ */
+const AbsolutePath = z
+	.string()
+	.describe("The absolute file path of a text file to read content from");
+
+export const ReadFileLineRangeSchema = z
+	.object({
+		start_line: z
+			.number()
+			.int()
+			.positive()
+			.nullable()
+			.optional()
+			.describe(
+				"Optional one-based starting line number to read from; use null or omit for the start of the file",
+			),
+		end_line: z
+			.number()
+			.int()
+			.positive()
+			.nullable()
+			.optional()
+			.describe(
+				"Optional one-based ending line number to read through; use null or omit to read to the end of the file or the read cap, whichever comes first",
+			),
+	})
+	.describe("Optional inclusive one-based file line range");
+
+export const ReadFileRequestSchema = z
+	.object({
+		path: AbsolutePath,
+		start_line: ReadFileLineRangeSchema.shape.start_line,
+		end_line: ReadFileLineRangeSchema.shape.end_line,
+	})
+	.describe(
+		"A file read request with optional inclusive one-based line bounds. Always include path; start_line/end_line must be on the same object as the path they apply to, never in a separate array element",
+	);
+
+/**
+ * Schema for read_files tool input
+ */
+export const ReadFilesInputSchema = z.object({
+	files: z
+		.array(ReadFileRequestSchema)
+		.describe(
+			"Array of file read requests; each element is one file and must include path. Omit start_line/end_line or set them to null to read from the start; provide integers on the same object as the path to return only that inclusive one-based line range — never emit a range as its own array element. Reads are capped, so page through long files with start_line/end_line. Prefer this tool over running terminal command to get file content for better performance and reliability.",
+		),
+});
+
+/**
+ * Union schema for read_files tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export const ReadFilesInputUnionSchema = z.union([
+	ReadFilesInputSchema,
+	ReadFileRequestSchema,
+	z.array(ReadFileRequestSchema),
+	z.array(z.string()),
+	z.string(),
+	z.object({ files: z.array(z.union([AbsolutePath, ReadFileRequestSchema])) }),
+	z.object({ files: ReadFileRequestSchema }),
+	z.object({ files: AbsolutePath }),
+	z.object({ file_paths: z.array(AbsolutePath) }),
+	z.object({ file_paths: z.string() }),
+	z.object({ paths: z.array(z.union([AbsolutePath, ReadFileRequestSchema])) }),
+	z.object({ paths: ReadFileRequestSchema }),
+	z.object({ paths: z.string() }),
+]);
+
+/**
+ * Schema for search_codebase tool input
+ */
+export const SearchCodebaseInputSchema = z.object({
+	queries: z
+		.array(z.string())
+		.describe("Array of regex search queries to execute"),
+});
+
+/**
+ * Union schema for search_codebase tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export const SearchCodebaseUnionInputSchema = z.union([
+	SearchCodebaseInputSchema,
+	z.array(z.string()),
+	z.string(),
+	z.object({ queries: z.string() }),
+]);
+
+const CommandInputSchema = z
+	.string()
+	.describe(
+		`The non-interactive shell command to execute - MUST keep input short and concise (within ${INPUT_ARG_CHAR_LIMIT * 2} characters) to avoid timeouts.`,
+	);
+
+export const StructuredCommandInputSchema = z.object({
+	command: z
+		.string()
+		.min(1)
+		.describe("The executable to run directly without shell parsing."),
+	args: z
+		.array(z.string())
+		.optional()
+		.describe("Optional argv list passed directly to the executable."),
+});
+
+export const StructuredCommandEntrySchema = z.union([
+	CommandInputSchema,
+	StructuredCommandInputSchema,
+]);
+
+export const RunCommandsInputSchema = z.object({
+	commands: z
+		.array(CommandInputSchema)
+		.describe("Array of complete shell command strings to execute."),
+});
+
+const StructuredCommandsInputSchema = z.object({
+	commands: z.array(StructuredCommandEntrySchema),
+});
+
+/**
+ * Union schema for run_commands tool input. More flexible.
+ */
+export const RunCommandsInputUnionSchema = z.union([
+	RunCommandsInputSchema,
+	StructuredCommandsInputSchema,
+	z.object({ commands: StructuredCommandEntrySchema }),
+	z.array(StructuredCommandInputSchema),
+	StructuredCommandInputSchema,
+	z.object({ command: CommandInputSchema }),
+	z.object({ cmd: CommandInputSchema }),
+	z.array(z.string()),
+	z.string(),
+]);
+
+/**
+ * Schema for a single web fetch request
+ */
+export const WebFetchRequestSchema = z.object({
+	url: z.string().describe("The URL to fetch"),
+	prompt: z.string().min(2).describe("Analysis prompt for the fetched content"),
+});
+
+/**
+ * Schema for fetch_web_content tool input
+ */
+export const FetchWebContentInputSchema = z.object({
+	requests: z
+		.array(WebFetchRequestSchema)
+		.describe("Array of the URLs for the web fetch requests"),
+});
+
+/**
+ * Schema for editor tool input
+ */
+export const EditFileInputSchema = z
+	.object({
+		path: z
+			.string()
+			.min(1)
+			.describe("The absolute file path for the action to be performed on"),
+		old_text: z
+			.string()
+			.nullable()
+			.optional()
+			.describe(
+				`Exact text to replace (must match exactly once). Omit this when creating a missing file or inserting via insert_line. Keep this at or below ${INPUT_ARG_CHAR_LIMIT} characters when possible; larger payloads should be split across multiple tool calls to avoid timeouts.`,
+			),
+		new_text: z
+			.string()
+			.describe(
+				`The new content to write when creating a missing file, the replacement text for edits, or the inserted text when insert_line is provided. Keep this at or below ${INPUT_ARG_CHAR_LIMIT} characters when possible; for large edits, use multiple calls with small chunks of old_text and new_text to iteratively edit the file.`,
+			),
+		insert_line: z
+			.number()
+			.int()
+			.nullable()
+			.optional()
+			.describe(
+				"Optional positive one-based boundary line. When provided, the tool inserts new_text before that line instead of performing a replacement edit; use line_count + 1 to append at EOF.",
+			),
+	})
+	.describe(
+		"Edit a text file by replacing old_text with new_text, create the file with new_text if it does not exist, or insert new_text at insert_line when insert_line is provided. Prefer using this tool for file edits over shell commands. IMPORTANT: large edits can time out, so use small chunks and multiple calls when possible.",
+	);
+
+/**
+ * Schema for apply_patch tool input
+ */
+export const ApplyPatchInputSchema = z
+	.object({
+		input: z
+			.string()
+			.min(1)
+			.describe(
+				"The freeform apply_patch payload in the canonical patch grammar (e.g *** Begin Patch, *** Update File:, @@, and *** End Patch).",
+			),
+	})
+	.describe(
+		"Modify or create a text file by applying patches using the canonical apply_patch diff grammar. Prefer sending the patch body directly rather than wrapping it in shell syntax. IMPORTANT: large patches can time out, so use small chunks and multiple calls when possible.",
+	);
+export const ApplyPatchInputUnionSchema = z.union([
+	ApplyPatchInputSchema,
+	z.string(),
+]);
+
+/**
+ * Schema for skills tool input
+ */
+export const SkillsInputSchema = z.object({
+	skill: z.string().min(1).describe("Name of the skill to execute."),
+	args: z
+		.string()
+		.nullable()
+		.optional()
+		.describe("Arguments for the skill; use null when omitted"),
+});
+
+/**
+ * Schema for ask_followup_question tool input
+ */
+export const AskQuestionInputSchema = z.object({
+	question: z
+		.string()
+		.min(1)
+		.describe(
+			'The single question to ask the user. E.g. "How can I help you?"',
+		),
+	options: z
+		.array(z.string().min(1))
+		.min(2)
+		.max(5)
+		.describe(
+			"Array of 2-5 user-selectable answer options for the single question",
+		),
+});
+
+export const SubmitInputSchema = z.object({
+	summary: z
+		.string()
+		.min(10)
+		.describe(
+			"Summarization of the investigation, steps taken, and resolution status to submit at the end of the session. Before submitting, read the problem again along with any provided test's assertions carefully and confirm your fix produces the expected output.",
+		),
+	verified: z
+		.boolean()
+		.describe(
+			`Have you verified that the issue is resolved to the best of your knowledge, including updating and creating all the requested files and items? 'True' if you have completed the investigation and taken all necessary steps to resolve the issue.\n'False' if you have done all you can but cannot resolve the issue or if you are stuck and cannot proceed further. =\nIMPORTANT: You must run the specific failing test(s) mentioned in the issue or test patch and include the test output in your reasoning. If the test still fails after your fix, you must revise. Do NOT submit with 'true' unless the test output shows the test passing.`,
+		),
+});
+
+// =============================================================================
+// Type Definitions (derived from Zod schemas)
+// =============================================================================
+
+/**
+ * Input for a single file read request
+ */
+export type ReadFileRequest = z.infer<typeof ReadFileRequestSchema>;
+
+/**
+ * Input for the read_files tool
+ */
+export type ReadFilesInput = z.infer<typeof ReadFilesInputSchema>;
+
+/**
+ * Input for the search_codebase tool
+ */
+export type SearchCodebaseInput = z.infer<typeof SearchCodebaseInputSchema>;
+
+/**
+ * Input for the run_commands tool
+ */
+export type RunCommandsInput = z.infer<typeof RunCommandsInputSchema>;
+export type StructuredCommandInput = z.infer<
+	typeof StructuredCommandInputSchema
+>;
+
+/**
+ * Web fetch request parameters
+ */
+export type WebFetchRequest = z.infer<typeof WebFetchRequestSchema>;
+
+/**
+ * Input for the fetch_web_content tool
+ */
+export type FetchWebContentInput = z.infer<typeof FetchWebContentInputSchema>;
+
+/**
+ * Input for the editor tool
+ */
+export type EditFileInput = z.infer<typeof EditFileInputSchema>;
+
+/**
+ * Input for the apply_patch tool
+ */
+export type ApplyPatchInput = z.infer<typeof ApplyPatchInputSchema>;
+
+/**
+ * Input for the skills tool
+ */
+export type SkillsInput = z.infer<typeof SkillsInputSchema>;
+
+/**
+ * Input for the ask_followup_question tool
+ */
+export type AskQuestionInput = z.infer<typeof AskQuestionInputSchema>;
+
+/**
+ * Input for the submit and exit tool
+ */
+export type SubmitInput = z.infer<typeof SubmitInputSchema>;
diff --git a/sdk/packages/core/src/extensions/tools/team/configured-agent-config.test.ts b/sdk/packages/core/src/extensions/tools/team/configured-agent-config.test.ts
new file mode 100644
index 0000000..84f05d4
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/configured-agent-config.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { parseConfiguredAgentConfig } from "./configured-agent-config";
+
+describe("configured agent config parser", () => {
+	it("parses YAML frontmatter and system prompt body", () => {
+		const config = parseConfiguredAgentConfig(`---
+name: code-reviewer
+description: Reviews code
+tools: execute_command, read_file
+skills:
+  - review-pr
+modelId: anthropic/claude-sonnet-4.6
+---
+You are a code reviewer.`);
+
+		expect(config).toMatchObject({
+			name: "code-reviewer",
+			description: "Reviews code",
+			tools: ["execute_command", "read_file"],
+			skills: ["review-pr"],
+			modelId: "anthropic/claude-sonnet-4.6",
+			systemPrompt: "You are a code reviewer.",
+		});
+	});
+
+	it("does not treat delimiter lines in the body as frontmatter delimiters", () => {
+		const config = parseConfiguredAgentConfig(`---
+name: code-reviewer
+description: Reviews code
+tools: read_file
+---
+Prompt body
+---
+More prompt`);
+
+		expect(config.systemPrompt).toBe("Prompt body\n---\nMore prompt");
+	});
+
+	it.each([
+		["empty", ""],
+		["comment-only", "# comment"],
+		["scalar", "code-reviewer"],
+	])("rejects %s frontmatter candidates without hanging", (_name, yaml) => {
+		expect(() =>
+			parseConfiguredAgentConfig(`---
+${yaml}
+---
+You are a code reviewer.`),
+		).toThrow("Missing closing YAML frontmatter delimiter");
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/team/configured-agent-config.ts b/sdk/packages/core/src/extensions/tools/team/configured-agent-config.ts
new file mode 100644
index 0000000..50f38d9
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/configured-agent-config.ts
@@ -0,0 +1,198 @@
+import { type Dirent, existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { resolveAgentConfigSearchPaths } from "@cline/shared/storage";
+import YAML from "yaml";
+import { z } from "zod";
+
+const ConfiguredAgentFrontmatterSchema = z.object({
+	name: z.string().trim().min(1),
+	description: z.string().trim().min(1),
+	tools: z.union([z.string(), z.array(z.string())]).optional(),
+	skills: z.union([z.string(), z.array(z.string())]).optional(),
+	providerId: z.string().trim().min(1).optional(),
+	modelId: z.string().trim().min(1).optional(),
+	maxIterations: z.number().int().positive().optional(),
+});
+
+export interface ConfiguredAgentConfig {
+	name: string;
+	description: string;
+	tools?: string[];
+	skills?: string[];
+	providerId?: string;
+	modelId?: string;
+	maxIterations?: number;
+	systemPrompt: string;
+	path?: string;
+}
+
+export interface ConfiguredAgentReadError {
+	path: string;
+	error: Error;
+}
+
+export interface ConfiguredAgentLoadResult {
+	configs: ConfiguredAgentConfig[];
+	errors: ConfiguredAgentReadError[];
+}
+
+function splitFrontmatter(content: string): {
+	frontmatter: string;
+	body: string;
+} {
+	const firstLineMatch = content.match(/^(---)[^\S\r\n]*(?:\r?\n|$)/);
+	if (!firstLineMatch) {
+		throw new Error("Missing YAML frontmatter block in agent config file.");
+	}
+
+	const frontmatterStart = firstLineMatch[0].length;
+	const delimiterPattern = /^---[^\S\r\n]*(?:\r?\n|$)/gm;
+	delimiterPattern.lastIndex = frontmatterStart;
+	let lastValid:
+		| {
+				frontmatter: string;
+				body: string;
+		  }
+		| undefined;
+	const candidates = Array.from(content.matchAll(delimiterPattern)).filter(
+		(candidate) => candidate.index >= frontmatterStart,
+	);
+	for (const candidate of candidates) {
+		const delimiterStart = candidate.index;
+		const frontmatter = content.slice(frontmatterStart, delimiterStart);
+		try {
+			const parsedYaml = YAML.parse(frontmatter);
+			if (
+				!parsedYaml ||
+				typeof parsedYaml !== "object" ||
+				Array.isArray(parsedYaml)
+			) {
+				continue;
+			}
+			ConfiguredAgentFrontmatterSchema.parse(parsedYaml);
+			const body = content.slice(delimiterStart + candidate[0].length);
+			lastValid = { frontmatter, body };
+		} catch {
+			// Keep scanning: this delimiter may be literal content inside YAML.
+		}
+	}
+
+	if (lastValid) {
+		return lastValid;
+	}
+
+	throw new Error(
+		"Missing closing YAML frontmatter delimiter in agent config file.",
+	);
+}
+
+function parseStringList(
+	value: string | string[] | undefined,
+): string[] | undefined {
+	if (value === undefined) {
+		return undefined;
+	}
+	const raw = Array.isArray(value) ? value : value.split(",");
+	return Array.from(
+		new Set(
+			raw.map((entry) => entry.trim()).filter((entry) => entry.length > 0),
+		),
+	);
+}
+
+function normalizeAgentName(name: string): string {
+	return name.trim().toLowerCase();
+}
+
+function isYamlFile(fileName: string): boolean {
+	const extension = extname(fileName).toLowerCase();
+	return extension === ".yml" || extension === ".yaml";
+}
+
+export function parseConfiguredAgentConfig(
+	content: string,
+	options: { path?: string } = {},
+): ConfiguredAgentConfig {
+	const { frontmatter, body } = splitFrontmatter(content);
+	const parsedYaml = YAML.parse(frontmatter);
+	if (
+		!parsedYaml ||
+		typeof parsedYaml !== "object" ||
+		Array.isArray(parsedYaml)
+	) {
+		throw new Error("Agent config frontmatter must be a YAML mapping.");
+	}
+
+	const parsed = ConfiguredAgentFrontmatterSchema.parse(parsedYaml);
+	const systemPrompt = body.trim();
+	if (!systemPrompt) {
+		throw new Error("Missing system prompt body in agent config file.");
+	}
+
+	return {
+		name: parsed.name,
+		description: parsed.description,
+		tools: parseStringList(parsed.tools),
+		skills: parseStringList(parsed.skills),
+		providerId: parsed.providerId,
+		modelId: parsed.modelId,
+		maxIterations: parsed.maxIterations,
+		systemPrompt,
+		path: options.path,
+	};
+}
+
+export function loadConfiguredAgentConfigs(input: {
+	workspaceRoot?: string;
+	searchPaths?: string[];
+}): ConfiguredAgentLoadResult {
+	const searchPaths =
+		input.searchPaths ?? resolveAgentConfigSearchPaths(input.workspaceRoot);
+	const configsByName = new Map<string, ConfiguredAgentConfig>();
+	const errors: ConfiguredAgentReadError[] = [];
+
+	for (const directory of searchPaths.filter(Boolean)) {
+		if (!existsSync(directory)) {
+			continue;
+		}
+
+		let entries: Dirent[];
+		try {
+			entries = readdirSync(directory, { withFileTypes: true });
+		} catch (error) {
+			errors.push({
+				path: directory,
+				error: error instanceof Error ? error : new Error(String(error)),
+			});
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (!entry.isFile() || !isYamlFile(entry.name)) {
+				continue;
+			}
+
+			const filePath = join(directory, entry.name);
+			try {
+				const raw = readFileSync(filePath, "utf8");
+				const config = parseConfiguredAgentConfig(raw, { path: filePath });
+				const normalizedName = normalizeAgentName(config.name);
+				if (!configsByName.has(normalizedName)) {
+					configsByName.set(normalizedName, config);
+				}
+			} catch (error) {
+				errors.push({
+					path: filePath,
+					error: error instanceof Error ? error : new Error(String(error)),
+				});
+			}
+		}
+	}
+
+	const configs = Array.from(configsByName.values()).sort((a, b) =>
+		(a.path ? basename(a.path) : a.name).localeCompare(
+			b.path ? basename(b.path) : b.name,
+		),
+	);
+	return { configs, errors };
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/configured-agent-tool.test.ts b/sdk/packages/core/src/extensions/tools/team/configured-agent-tool.test.ts
new file mode 100644
index 0000000..6f5bcb1
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/configured-agent-tool.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildConfiguredAgentToolName,
+	createConfiguredAgentTools,
+} from "./configured-agent-tool";
+
+describe("configured agent tools", () => {
+	it("builds stable subagent tool names", () => {
+		expect(buildConfiguredAgentToolName("Code Reviewer")).toBe(
+			"subagent_code_reviewer",
+		);
+		expect(buildConfiguredAgentToolName("___")).toBe("subagent_agent");
+	});
+
+	it("matches spawn_agent timeout and retry policy", () => {
+		const [tool] = createConfiguredAgentTools({
+			configProvider: {
+				getRuntimeConfig: () => ({
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-6",
+					apiKey: "key",
+				}),
+				getConnectionConfig: () => ({
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-6",
+					apiKey: "key",
+				}),
+				updateConnectionDefaults: () => {},
+			},
+			agents: [
+				{
+					name: "code-reviewer",
+					description: "Reviews code",
+					systemPrompt: "You are a code reviewer.",
+				},
+			],
+		});
+
+		expect(tool?.name).toBe("subagent_code_reviewer");
+		expect(tool?.timeoutMs).toBe(300000);
+		expect(tool?.retryable).toBe(false);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/team/configured-agent-tool.ts b/sdk/packages/core/src/extensions/tools/team/configured-agent-tool.ts
new file mode 100644
index 0000000..9699b23
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/configured-agent-tool.ts
@@ -0,0 +1,253 @@
+import {
+	type AgentEvent,
+	type AgentResult,
+	type AgentTool,
+	type AgentToolContext,
+	createTool,
+	type HookErrorMode,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+	type ToolPolicy,
+	zodToJsonSchema,
+} from "@cline/shared";
+import { z } from "zod";
+import type { ConfiguredAgentConfig } from "./configured-agent-config";
+import {
+	createDelegatedAgent,
+	createDelegatedAgentConfigProvider,
+	type DelegatedAgentConfigProvider,
+	type DelegatedAgentRuntimeConfig,
+} from "./delegated-agent";
+import type {
+	SpawnAgentOutput,
+	SubAgentEndContext,
+	SubAgentStartContext,
+} from "./spawn-agent-tool";
+
+const CONFIGURED_AGENT_TOOL_NAME_PREFIX = "subagent_";
+const CONFIGURED_AGENT_TOOL_NAME_MAX_LENGTH = 64;
+
+const ConfiguredAgentInputSchema = z.object({
+	prompt: z.string().trim().min(1).describe("Task for the subagent to perform"),
+});
+
+export type ConfiguredAgentInput = z.infer<typeof ConfiguredAgentInputSchema>;
+
+export interface ConfiguredAgentToolDescriptor {
+	toolName: string;
+	config: ConfiguredAgentConfig;
+}
+
+export interface ConfiguredAgentToolConfig {
+	configProvider: DelegatedAgentConfigProvider;
+	agents: ConfiguredAgentConfig[];
+	createSubAgentTools?: (
+		agent: ConfiguredAgentConfig,
+		input: ConfiguredAgentInput,
+		context: AgentToolContext,
+	) => AgentTool[] | Promise<AgentTool[]>;
+	onSubAgentEvent?: (event: AgentEvent) => void;
+	hookErrorMode?: HookErrorMode;
+	toolPolicies?: Record<string, ToolPolicy>;
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+	onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+	onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+}
+
+function sanitizeAgentName(name: string): string {
+	let result = "";
+	let lastWasUnderscore = true;
+
+	for (const char of name.trim().toLowerCase()) {
+		const code = char.charCodeAt(0);
+		const isAllowed =
+			(code >= 97 && code <= 122) || (code >= 48 && code <= 57) || char === "_";
+
+		if (!isAllowed || char === "_") {
+			if (!lastWasUnderscore) {
+				result += "_";
+				lastWasUnderscore = true;
+			}
+			continue;
+		}
+
+		result += char;
+		lastWasUnderscore = false;
+	}
+
+	return lastWasUnderscore ? result.slice(0, -1) : result;
+}
+
+function hashString(value: string): string {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i++) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+
+export function buildConfiguredAgentToolName(agentName: string): string {
+	const sanitized = sanitizeAgentName(agentName) || "agent";
+	const hashSuffix = hashString(agentName).slice(0, 6);
+	const base = `${CONFIGURED_AGENT_TOOL_NAME_PREFIX}${sanitized}`;
+
+	if (base.length <= CONFIGURED_AGENT_TOOL_NAME_MAX_LENGTH) {
+		return base;
+	}
+
+	const maxBodyLength =
+		CONFIGURED_AGENT_TOOL_NAME_MAX_LENGTH -
+		CONFIGURED_AGENT_TOOL_NAME_PREFIX.length -
+		hashSuffix.length -
+		1;
+	const body = sanitized.slice(0, Math.max(1, maxBodyLength));
+	return `${CONFIGURED_AGENT_TOOL_NAME_PREFIX}${body}_${hashSuffix}`.slice(
+		0,
+		CONFIGURED_AGENT_TOOL_NAME_MAX_LENGTH,
+	);
+}
+
+export function buildConfiguredAgentToolDescriptors(
+	agents: readonly ConfiguredAgentConfig[],
+): ConfiguredAgentToolDescriptor[] {
+	const usedToolNames = new Set<string>();
+	const descriptors: ConfiguredAgentToolDescriptor[] = [];
+
+	for (const config of [...agents].sort((a, b) =>
+		a.name.localeCompare(b.name),
+	)) {
+		const baseName = buildConfiguredAgentToolName(config.name);
+		let candidate = baseName;
+		let suffix = 2;
+		while (usedToolNames.has(candidate)) {
+			const suffixText = `_${suffix++}`;
+			const maxBaseLength = Math.max(
+				1,
+				CONFIGURED_AGENT_TOOL_NAME_MAX_LENGTH - suffixText.length,
+			);
+			candidate = `${baseName.slice(0, maxBaseLength)}${suffixText}`;
+		}
+		usedToolNames.add(candidate);
+		descriptors.push({ toolName: candidate, config });
+	}
+
+	return descriptors;
+}
+
+function buildAgentRuntimeConfig(
+	base: DelegatedAgentRuntimeConfig,
+	agent: ConfiguredAgentConfig,
+): DelegatedAgentRuntimeConfig {
+	return {
+		...base,
+		providerId: agent.providerId ?? base.providerId,
+		modelId: agent.modelId ?? base.modelId,
+		maxIterations: agent.maxIterations ?? base.maxIterations,
+	};
+}
+
+export function createConfiguredAgentTools(
+	options: ConfiguredAgentToolConfig,
+): AgentTool[] {
+	return buildConfiguredAgentToolDescriptors(options.agents).map(
+		({ toolName, config }) => {
+			const tool = createTool<ConfiguredAgentInput, SpawnAgentOutput>({
+				name: toolName,
+				description: `Use the "${config.name}" subagent: ${config.description}`,
+				inputSchema: zodToJsonSchema(ConfiguredAgentInputSchema),
+				execute: async (input, context) => {
+					const baseRuntimeConfig = options.configProvider.getRuntimeConfig();
+					const configProvider = createDelegatedAgentConfigProvider(
+						buildAgentRuntimeConfig(baseRuntimeConfig, config),
+					);
+					const tools = options.createSubAgentTools
+						? await options.createSubAgentTools(config, input, context)
+						: [];
+					const subAgent = createDelegatedAgent({
+						kind: "subagent",
+						prompt: config.systemPrompt,
+						configProvider,
+						tools,
+						maxIterations: config.maxIterations,
+						parentAgentId: context.agentId,
+						abortSignal: context.signal,
+						onEvent: options.onSubAgentEvent,
+						hookErrorMode: options.hookErrorMode,
+						toolPolicies: options.toolPolicies,
+						requestToolApproval: options.requestToolApproval,
+					});
+					const subAgentId = subAgent.getAgentId();
+					const conversationId = subAgent.getConversationId();
+					const parentAgentId = context.agentId;
+					const spawnInput = {
+						systemPrompt: config.systemPrompt,
+						task: input.prompt,
+					};
+
+					if (options.onSubAgentStart) {
+						try {
+							await options.onSubAgentStart({
+								subAgentId,
+								conversationId,
+								parentAgentId,
+								input: spawnInput,
+							});
+						} catch {
+							// Best-effort observer callback.
+						}
+					}
+
+					try {
+						const result: AgentResult = await subAgent.run(input.prompt);
+						const output: SpawnAgentOutput = {
+							text: result.text,
+							iterations: result.iterations,
+							finishReason: result.finishReason,
+							usage: {
+								inputTokens: result.usage.inputTokens,
+								outputTokens: result.usage.outputTokens,
+							},
+						};
+						if (options.onSubAgentEnd) {
+							try {
+								await options.onSubAgentEnd({
+									subAgentId,
+									conversationId,
+									parentAgentId,
+									input: spawnInput,
+									result: output,
+									agentResult: result,
+								});
+							} catch {
+								// Best-effort observer callback.
+							}
+						}
+						return output;
+					} catch (error) {
+						if (options.onSubAgentEnd) {
+							try {
+								await options.onSubAgentEnd({
+									subAgentId,
+									conversationId,
+									parentAgentId,
+									input: spawnInput,
+									error:
+										error instanceof Error ? error : new Error(String(error)),
+								});
+							} catch {
+								// Best-effort observer callback.
+							}
+						}
+						throw error;
+					}
+				},
+				timeoutMs: 300000,
+				retryable: false,
+			});
+			return tool as unknown as AgentTool;
+		},
+	);
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/delegated-agent.ts b/sdk/packages/core/src/extensions/tools/team/delegated-agent.ts
new file mode 100644
index 0000000..4b9352d
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/delegated-agent.ts
@@ -0,0 +1,142 @@
+import type {
+	AgentConfig,
+	AgentEvent,
+	AgentHooks,
+	AgentTool,
+	BasicLogger,
+	HookErrorMode,
+	ITelemetryService,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@cline/shared";
+import { SessionRuntime } from "../../../runtime/orchestration/session-runtime-orchestrator";
+import {
+	buildSubAgentSystemPrompt,
+	buildTeammateSystemPrompt,
+} from "./subagent-prompts";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+
+export type DelegatedAgentConnectionConfig = Pick<
+	AgentConfig,
+	| "providerId"
+	| "modelId"
+	| "apiKey"
+	| "baseUrl"
+	| "headers"
+	| "providerConfig"
+	| "knownModels"
+	| "thinking"
+	| "reasoningEffort"
+	| "thinkingBudgetTokens"
+	| "maxTokensPerTurn"
+>;
+
+export interface DelegatedAgentRuntimeConfig
+	extends DelegatedAgentConnectionConfig {
+	cwd?: string;
+	providerId: string;
+	clinePlatform?: string;
+	clineIdeName?: string;
+	maxIterations?: number;
+	hooks?: AgentHooks;
+	extensions?: AgentExtension[];
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+	workspaceMetadata?: string;
+}
+
+export interface DelegatedAgentConfigProvider {
+	getRuntimeConfig(): DelegatedAgentRuntimeConfig;
+	getConnectionConfig(): DelegatedAgentConnectionConfig;
+	updateConnectionDefaults(
+		overrides: Partial<DelegatedAgentConnectionConfig>,
+	): void;
+}
+
+export type DelegatedAgentKind = "subagent" | "teammate";
+
+export interface BuildDelegatedAgentConfigOptions {
+	kind: DelegatedAgentKind;
+	prompt: string;
+	tools: AgentTool[];
+	configProvider: DelegatedAgentConfigProvider;
+	parentAgentId?: string;
+	maxIterations?: number;
+	abortSignal?: AbortSignal;
+	onEvent?: (event: AgentEvent) => void;
+	hookErrorMode?: HookErrorMode;
+	toolPolicies?: AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+	role?: string;
+	cwd?: string;
+}
+
+export function createDelegatedAgentConfigProvider(
+	initialConfig: DelegatedAgentRuntimeConfig,
+): DelegatedAgentConfigProvider {
+	let runtimeConfig: DelegatedAgentRuntimeConfig = { ...initialConfig };
+
+	return {
+		getRuntimeConfig: () => runtimeConfig,
+		getConnectionConfig: () => ({
+			providerId: runtimeConfig.providerId,
+			modelId: runtimeConfig.modelId,
+			apiKey: runtimeConfig.apiKey,
+			baseUrl: runtimeConfig.baseUrl,
+			headers: runtimeConfig.headers,
+			providerConfig: runtimeConfig.providerConfig,
+			knownModels: runtimeConfig.knownModels,
+			thinking: runtimeConfig.thinking,
+			reasoningEffort: runtimeConfig.reasoningEffort,
+			thinkingBudgetTokens: runtimeConfig.thinkingBudgetTokens,
+			maxTokensPerTurn: runtimeConfig.maxTokensPerTurn,
+		}),
+		updateConnectionDefaults: (overrides) => {
+			runtimeConfig = {
+				...runtimeConfig,
+				...overrides,
+			};
+		},
+	};
+}
+
+export function buildDelegatedAgentConfig(
+	options: BuildDelegatedAgentConfigOptions,
+): AgentConfig & { role?: string } {
+	const runtimeConfig = options.configProvider.getRuntimeConfig();
+	const systemPrompt =
+		options.kind === "teammate"
+			? buildTeammateSystemPrompt(options.prompt, runtimeConfig)
+			: buildSubAgentSystemPrompt(options.prompt, runtimeConfig);
+
+	return {
+		...options.configProvider.getConnectionConfig(),
+		systemPrompt,
+		tools: options.tools,
+		maxIterations: options.maxIterations ?? runtimeConfig.maxIterations,
+		parentAgentId: options.parentAgentId,
+		abortSignal: options.abortSignal,
+		onEvent: options.onEvent,
+		hooks: runtimeConfig.hooks,
+		extensions: runtimeConfig.extensions,
+		hookErrorMode: options.hookErrorMode,
+		toolPolicies: options.toolPolicies,
+		requestToolApproval: options.requestToolApproval,
+		logger: runtimeConfig.logger,
+		role: options.role,
+	};
+}
+
+export function createDelegatedAgent(
+	options: BuildDelegatedAgentConfigOptions,
+): SessionRuntime {
+	const config = buildDelegatedAgentConfig(options);
+	const session = new SessionRuntime(config);
+	if (config.onEvent) {
+		session.subscribeEvents(config.onEvent);
+	}
+	return session;
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/index.ts b/sdk/packages/core/src/extensions/tools/team/index.ts
new file mode 100644
index 0000000..b8b7b9a
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/index.ts
@@ -0,0 +1,24 @@
+export {
+	type ConfiguredAgentConfig,
+	type ConfiguredAgentLoadResult,
+	type ConfiguredAgentReadError,
+	loadConfiguredAgentConfigs,
+	parseConfiguredAgentConfig,
+} from "./configured-agent-config";
+export {
+	buildConfiguredAgentToolDescriptors,
+	buildConfiguredAgentToolName,
+	type ConfiguredAgentInput,
+	type ConfiguredAgentToolConfig,
+	type ConfiguredAgentToolDescriptor,
+	createConfiguredAgentTools,
+} from "./configured-agent-tool";
+export {
+	buildTeamProgressSummary,
+	toTeamProgressLifecycleEvent,
+} from "./projections";
+export * from "./runtime";
+export type {
+	SubAgentEndContext,
+	SubAgentStartContext,
+} from "./spawn-agent-tool";
diff --git a/sdk/packages/core/src/extensions/tools/team/multi-agent.lifecycle.test.ts b/sdk/packages/core/src/extensions/tools/team/multi-agent.lifecycle.test.ts
new file mode 100644
index 0000000..40c29a0
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/multi-agent.lifecycle.test.ts
@@ -0,0 +1,649 @@
+import type { AgentConfig, AgentEvent } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import {
+	AgentTeamsRuntime,
+	type TeamEvent,
+	TeamMessageType,
+} from "./multi-agent";
+
+const { createSessionRuntimeMock } = vi.hoisted(() => {
+	// The mock must work with `new SessionRuntime(...)` which the
+	// production code uses. Arrow functions cannot be called with `new`,
+	// so we declare the default impl as a regular function expression.
+	// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+	const createSessionRuntimeMock = vi.fn(function (_config?: unknown) {
+		return {
+			abort: vi.fn(),
+			run: vi.fn(),
+			continue: vi.fn(),
+			canStartRun: vi.fn(() => true),
+			getAgentId: vi.fn(() => "teammate-1"),
+			getConversationId: vi.fn(() => "conv-1"),
+			getMessages: vi.fn(() => []),
+			subscribeEvents: vi.fn(() => () => {}),
+		};
+	});
+
+	return { createSessionRuntimeMock };
+});
+
+type SessionRuntimeCtorConfig = AgentConfig & {
+	consumePendingUserMessage?: () => string | undefined;
+	onEvent?: (event: AgentEvent) => void;
+};
+
+vi.mock("../../../runtime/orchestration/session-runtime-orchestrator", () => {
+	return {
+		SessionRuntime: createSessionRuntimeMock,
+	};
+});
+
+describe("AgentTeamsRuntime teammate lifecycle events", () => {
+	it("spawns teammates with a 10 minute API timeout", () => {
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(),
+				run: vi.fn(),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+		});
+
+		runtime.spawnTeammate({
+			agentId: "python-poet",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Write concise Python-focused haiku",
+				tools: [],
+			},
+		});
+
+		expect(createSessionRuntimeMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiTimeoutMs: 10 * 60 * 1000,
+			}),
+		);
+	});
+
+	it("does not emit task_start when teammate is already busy", async () => {
+		const events: TeamEvent[] = [];
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(),
+				run: vi.fn(),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => false),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+			onTeamEvent: (event) => events.push(event),
+		});
+
+		runtime.spawnTeammate({
+			agentId: "python-poet",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Write concise Python-focused haiku",
+				maxIterations: 7,
+				tools: [],
+			},
+		});
+
+		await expect(
+			runtime.routeToTeammate("python-poet", "write something"),
+		).rejects.toThrow(
+			"Cannot start a new run while another run is already in progress",
+		);
+		expect(
+			events.some((event) => event.type === TeamMessageType.TaskStart),
+		).toBe(false);
+	});
+
+	it("emits teammate_spawned with lifecycle payload", () => {
+		const events: TeamEvent[] = [];
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(),
+				run: vi.fn(),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+			onTeamEvent: (event) => events.push(event),
+		});
+
+		runtime.spawnTeammate({
+			agentId: "python-poet",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Write concise Python-focused haiku",
+				maxIterations: 7,
+				tools: [],
+			},
+		});
+
+		expect(events).toContainEqual({
+			type: TeamMessageType.TeammateSpawned,
+			agentId: "python-poet",
+			role: undefined,
+			teammate: {
+				rolePrompt: "Write concise Python-focused haiku",
+				modelId: "claude-sonnet-4-5-20250929",
+				maxIterations: 7,
+				runtimeAgentId: "teammate-1",
+				conversationId: "conv-1",
+				parentAgentId: null,
+			},
+		});
+	});
+
+	it("swallows abort-like shutdown errors from teammates", () => {
+		const events: TeamEvent[] = [];
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(() => {
+					throw new DOMException("This operation was aborted", "AbortError");
+				}),
+				run: vi.fn(),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+			onTeamEvent: (event) => events.push(event),
+		});
+
+		runtime.spawnTeammate({
+			agentId: "python-poet",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Write concise Python-focused haiku",
+				tools: [],
+			},
+		});
+
+		expect(() =>
+			runtime.shutdownTeammate("python-poet", "manual_restart"),
+		).not.toThrow();
+		expect(runtime.getSnapshot().members).toContainEqual(
+			expect.objectContaining({
+				agentId: "python-poet",
+				status: "stopped",
+			}),
+		);
+		expect(events).toContainEqual({
+			type: TeamMessageType.TeammateShutdown,
+			agentId: "python-poet",
+			reason: "manual_restart",
+		});
+	});
+
+	it("marks an active queued run as cancelled when teammate shutdown aborts it", async () => {
+		const events: TeamEvent[] = [];
+		let rejectRun: ((error: Error) => void) | undefined;
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(() => {
+					rejectRun?.(
+						new DOMException("This operation was aborted", "AbortError"),
+					);
+				}),
+				run: vi.fn(
+					() =>
+						new Promise((_, reject) => {
+							rejectRun = reject;
+						}),
+				),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+			onTeamEvent: (event) => events.push(event),
+		});
+
+		runtime.spawnTeammate({
+			agentId: "python-poet",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Write concise Python-focused haiku",
+				tools: [],
+			},
+		});
+
+		const run = runtime.startTeammateRun("python-poet", "write something");
+		runtime.shutdownTeammate("python-poet", "manual_restart");
+
+		const settledRun = await runtime.awaitRun(run.id, 1);
+		expect(settledRun.status).toBe("cancelled");
+		expect(events).toContainEqual({
+			type: TeamMessageType.RunCancelled,
+			run: expect.objectContaining({
+				id: run.id,
+				agentId: "python-poet",
+				status: "cancelled",
+			}),
+			reason: "This operation was aborted",
+		});
+	});
+
+	it("prepends unread mailbox notification to teammate message", async () => {
+		let routedMessage: string | undefined;
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(),
+				run: vi.fn(async (message) => {
+					routedMessage = message;
+					return {
+						text: "Task completed",
+						iterations: 1,
+						finishReason: "end_turn",
+						durationMs: 100,
+						usage: {
+							inputTokens: 10,
+							outputTokens: 20,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0,
+							totalCost: 0,
+						},
+						messages: [],
+					};
+				}),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+		});
+
+		runtime.spawnTeammate({
+			agentId: "alice",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Helper teammate",
+				tools: [],
+			},
+		});
+
+		// Send message from lead to alice
+		runtime.sendMessage(
+			"lead",
+			"alice",
+			"Status check",
+			"How is your work going?",
+		);
+
+		// Route task to alice
+		await runtime.routeToTeammate("alice", "Complete your task");
+
+		// Verify the routed message includes mailbox notification
+		expect(routedMessage).toBeDefined();
+		expect(routedMessage).toContain("[MAILBOX]");
+		expect(routedMessage).toContain("You have 1 unread message(s)");
+		expect(routedMessage).toContain(
+			"Message from lead | subject: Status check",
+		);
+		expect(routedMessage).toContain("How is your work going?");
+		expect(routedMessage).toContain("Complete your task");
+
+		// Verify message is marked as read
+		const unreadAfter = runtime.listMailbox("alice", { unreadOnly: true });
+		expect(unreadAfter).toHaveLength(0);
+	});
+
+	it("does not prepend notification when no unread mail", async () => {
+		let routedMessage: string | undefined;
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function () {
+			return {
+				abort: vi.fn(),
+				run: vi.fn(async (message) => {
+					routedMessage = message;
+					return {
+						text: "Task completed",
+						iterations: 1,
+						finishReason: "end_turn",
+						durationMs: 100,
+						usage: {
+							inputTokens: 10,
+							outputTokens: 20,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0,
+							totalCost: 0,
+						},
+						messages: [],
+					};
+				}),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+		});
+
+		runtime.spawnTeammate({
+			agentId: "bob",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Helper teammate",
+				tools: [],
+			},
+		});
+
+		// Route task to bob with no prior messages
+		await runtime.routeToTeammate("bob", "Complete your task");
+
+		// Verify the routed message does not contain mailbox notification
+		expect(routedMessage).toBeDefined();
+		expect(routedMessage).toBe("Complete your task");
+		expect(routedMessage).not.toContain("[MAILBOX]");
+	});
+
+	it("queues steer message notification when recipient is running", () => {
+		let consumePendingMessage: (() => string | undefined) | undefined;
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function (config) {
+			consumePendingMessage = (config as SessionRuntimeCtorConfig)
+				.consumePendingUserMessage;
+			return {
+				abort: vi.fn(),
+				run: vi.fn(),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+		});
+
+		runtime.spawnTeammate({
+			agentId: "charlie",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Helper teammate",
+				tools: [],
+			},
+		});
+
+		// Simulate teammate is running by incrementing runningCount
+		const runtimeMembers = (
+			runtime as unknown as { members: Map<string, { runningCount: number }> }
+		).members;
+		const member = runtimeMembers.get("charlie");
+		if (member) {
+			member.runningCount = 1;
+		}
+
+		// Send message from lead while charlie is running
+		runtime.sendMessage("lead", "charlie", "urgent update", "Fix the bug now!");
+
+		// Verify steer message is queued
+		expect(consumePendingMessage).toBeDefined();
+		const steerMsg = consumePendingMessage?.();
+		expect(steerMsg).toBeDefined();
+		expect(steerMsg).toContain("[MAILBOX]");
+		expect(steerMsg).toContain("lead");
+		expect(steerMsg).toContain("urgent update");
+		expect(steerMsg).toContain("team_read_mailbox");
+
+		// Verify consuming again returns undefined
+		expect(consumePendingMessage?.()).toBeUndefined();
+	});
+
+	it("does not queue steer message when recipient is idle", () => {
+		let consumePendingMessage: (() => string | undefined) | undefined;
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function (config) {
+			consumePendingMessage = (config as SessionRuntimeCtorConfig)
+				.consumePendingUserMessage;
+			return {
+				abort: vi.fn(),
+				run: vi.fn(),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+		});
+
+		runtime.spawnTeammate({
+			agentId: "diana",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Helper teammate",
+				tools: [],
+			},
+		});
+
+		// Send message from lead while diana is idle (runningCount = 0)
+		runtime.sendMessage("lead", "diana", "hello", "Hi there");
+
+		// Verify no steer message is queued
+		expect(consumePendingMessage?.()).toBeUndefined();
+
+		// Message should still be in mailbox for next route
+		const mailbox = runtime.listMailbox("diana", { unreadOnly: true });
+		expect(mailbox).toHaveLength(1);
+		expect(mailbox[0].subject).toBe("hello");
+	});
+
+	it("includes tool and run error details in run_progress activity", async () => {
+		const events: TeamEvent[] = [];
+		let wrappedOnEvent: ((event: AgentEvent) => void) | undefined;
+		// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+		createSessionRuntimeMock.mockImplementationOnce(function (config) {
+			wrappedOnEvent = (config as SessionRuntimeCtorConfig).onEvent;
+			return {
+				abort: vi.fn(),
+				run: vi.fn(async () => {
+					wrappedOnEvent?.({
+						type: "content_end",
+						contentType: "tool",
+						toolName: "team_mission_log",
+						error: "RPC backend returned 500 while appending mission log",
+					});
+					wrappedOnEvent?.({
+						type: "error",
+						error: new Error("API request timed out after 120000ms"),
+						recoverable: false,
+						iteration: 11,
+					});
+					throw new Error("API request timed out after 120000ms");
+				}),
+				continue: vi.fn(),
+				canStartRun: vi.fn(() => true),
+				getAgentId: vi.fn(() => "teammate-1"),
+				getConversationId: vi.fn(() => "conv-1"),
+				getMessages: vi.fn(() => []),
+				subscribeEvents: vi.fn(() => () => {}),
+			};
+		});
+		const runtime = new AgentTeamsRuntime({
+			teamName: "test-team",
+			onTeamEvent: (event) => events.push(event),
+		});
+
+		runtime.spawnTeammate({
+			agentId: "providers-investigator",
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5-20250929",
+				systemPrompt: "Investigate providers thoroughly",
+				tools: [],
+			},
+		});
+
+		const run = runtime.startTeammateRun(
+			"providers-investigator",
+			"Investigate providers",
+		);
+		const settled = await runtime.awaitRun(run.id);
+
+		expect(settled.status).toBe("failed");
+		expect(events).toContainEqual(
+			expect.objectContaining({
+				type: TeamMessageType.RunProgress,
+				message:
+					"tool_team_mission_log_error: RPC backend returned 500 while appending mission log",
+			}),
+		);
+		expect(events).toContainEqual(
+			expect.objectContaining({
+				type: TeamMessageType.RunProgress,
+				message: "run_error: API request timed out after 120000ms",
+			}),
+		);
+	});
+
+	it("honors pending retry backoff when recovering queued runs", async () => {
+		vi.useFakeTimers();
+		try {
+			const runMock = vi.fn(async (_message: string) => ({
+				text: "Recovered task completed",
+				iterations: 1,
+				finishReason: "end_turn",
+				durationMs: 100,
+				usage: {
+					inputTokens: 10,
+					outputTokens: 20,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+				messages: [],
+			}));
+			// biome-ignore lint/complexity/useArrowFunction: `new SessionRuntime(...)` requires a non-arrow callable.
+			createSessionRuntimeMock.mockImplementation(function () {
+				return {
+					abort: vi.fn(),
+					run: runMock,
+					continue: vi.fn(),
+					canStartRun: vi.fn(() => true),
+					getAgentId: vi.fn(() => "teammate-1"),
+					getConversationId: vi.fn(() => "conv-1"),
+					getMessages: vi.fn(() => []),
+					subscribeEvents: vi.fn(() => () => {}),
+				};
+			});
+
+			const originalRuntime = new AgentTeamsRuntime({ teamName: "test-team" });
+			originalRuntime.spawnTeammate({
+				agentId: "alice",
+				config: {
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-5-20250929",
+					systemPrompt: "Helper teammate",
+					tools: [],
+				},
+			});
+			const run = originalRuntime.startTeammateRun("alice", "Complete work", {
+				maxRetries: 1,
+			});
+			const retryAt = new Date(Date.now() + 5000);
+			const originalRuns = (
+				originalRuntime as unknown as {
+					runs: Map<string, { status: string; nextAttemptAt?: Date }>;
+				}
+			).runs;
+			const originalRun = originalRuns.get(run.id);
+			if (!originalRun) {
+				throw new Error("Expected test run to exist");
+			}
+			originalRun.status = "queued";
+			originalRun.nextAttemptAt = retryAt;
+			const persistedState = originalRuntime.exportState();
+			runMock.mockClear();
+
+			const recoveredRuntime = new AgentTeamsRuntime({ teamName: "test-team" });
+			recoveredRuntime.hydrateState(persistedState);
+			recoveredRuntime.spawnTeammate({
+				agentId: "alice",
+				config: {
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-5-20250929",
+					systemPrompt: "Helper teammate",
+					tools: [],
+				},
+			});
+
+			const recovered = recoveredRuntime.recoverActiveRuns("runtime_recovered");
+			expect(recovered).toHaveLength(1);
+			expect(recovered[0].nextAttemptAt).toEqual(retryAt);
+			expect(runMock).not.toHaveBeenCalled();
+
+			await vi.advanceTimersByTimeAsync(4999);
+			expect(runMock).not.toHaveBeenCalled();
+
+			await vi.advanceTimersByTimeAsync(1);
+			expect(runMock).toHaveBeenCalledTimes(1);
+			expect(runMock.mock.calls[0][0]).toContain(
+				"This is an automatic recovery of interrupted team run",
+			);
+			expect(runMock.mock.calls[0][0]).toContain("Complete work");
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/team/multi-agent.ts b/sdk/packages/core/src/extensions/tools/team/multi-agent.ts
new file mode 100644
index 0000000..790ea72
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/multi-agent.ts
@@ -0,0 +1,1845 @@
+/**
+ * Multi-Agent Coordination
+ *
+ * Utilities for orchestrating multiple agents working together.
+ */
+
+import {
+	type AgentConfig,
+	type AgentEvent,
+	type AgentResult,
+	type AppendMissionLogInput,
+	type AttachTeamOutcomeFragmentInput,
+	type CreateTeamOutcomeInput,
+	type CreateTeamTaskInput,
+	type MissionLogEntry,
+	type ReviewTeamOutcomeFragmentInput,
+	type RouteToTeammateOptions,
+	sanitizeFileName,
+	type TeamMailboxMessage,
+	type TeamMemberSnapshot,
+	TeamMessageType,
+	type TeammateLifecycleSpec,
+	type TeamOutcome,
+	type TeamOutcomeFragment,
+	type TeamOutcomeStatus,
+	type TeamRunRecord,
+	type TeamRunStatus,
+	type TeamRuntimeSnapshot,
+	type TeamRuntimeState,
+	type TeamTask,
+	type TeamTaskListItem,
+	type TeamTaskStatus,
+} from "@cline/shared";
+import { nanoid } from "nanoid";
+import { SessionRuntime } from "../../../runtime/orchestration/session-runtime-orchestrator";
+
+// Re-export shared types for backward compatibility
+export {
+	type AppendMissionLogInput,
+	type AttachTeamOutcomeFragmentInput,
+	type CreateTeamOutcomeInput,
+	type CreateTeamTaskInput,
+	type MissionLogEntry,
+	type MissionLogKind,
+	type ReviewTeamOutcomeFragmentInput,
+	type RouteToTeammateOptions,
+	type TeamMailboxMessage,
+	type TeamMemberSnapshot,
+	TeamMessageType,
+	type TeammateLifecycleSpec,
+	type TeamOutcome,
+	type TeamOutcomeFragment,
+	type TeamOutcomeFragmentStatus,
+	type TeamOutcomeStatus,
+	type TeamRunRecord,
+	type TeamRunStatus,
+	type TeamRuntimeSnapshot,
+	type TeamRuntimeState,
+	type TeamTask,
+	type TeamTaskListItem,
+	type TeamTaskStatus,
+} from "@cline/shared";
+
+// =============================================================================
+// Types that depend on @cline/agents (cannot live in shared)
+// =============================================================================
+
+export interface TeamMemberConfig extends AgentConfig {
+	role?: string;
+}
+
+export interface AgentTask {
+	agentId: string;
+	message: string;
+	metadata?: Record<string, unknown>;
+}
+
+export interface TaskResult {
+	agentId: string;
+	result: AgentResult;
+	error?: Error;
+	metadata?: Record<string, unknown>;
+}
+
+export type TeamEvent =
+	| { type: TeamMessageType.TaskStart; agentId: string; message: string }
+	| {
+			type: TeamMessageType.TaskEnd;
+			agentId: string;
+			result?: AgentResult;
+			error?: Error;
+			messages?: AgentResult["messages"];
+	  }
+	| { type: TeamMessageType.AgentEvent; agentId: string; event: AgentEvent }
+	| {
+			type: TeamMessageType.TeammateSpawned;
+			agentId: string;
+			role?: string;
+			teammate: TeammateLifecycleSpec;
+	  }
+	| { type: TeamMessageType.TeammateShutdown; agentId: string; reason?: string }
+	| { type: TeamMessageType.TeamTaskUpdated; task: TeamTask }
+	| { type: TeamMessageType.TeamMessage; message: TeamMailboxMessage }
+	| { type: TeamMessageType.TeamMissionLog; entry: MissionLogEntry }
+	| { type: TeamMessageType.RunQueued; run: TeamRunRecord }
+	| { type: TeamMessageType.RunStarted; run: TeamRunRecord }
+	| { type: TeamMessageType.RunProgress; run: TeamRunRecord; message: string }
+	| { type: TeamMessageType.RunCompleted; run: TeamRunRecord }
+	| { type: TeamMessageType.RunFailed; run: TeamRunRecord }
+	| { type: TeamMessageType.RunCancelled; run: TeamRunRecord; reason?: string }
+	| {
+			type: TeamMessageType.RunInterrupted;
+			run: TeamRunRecord;
+			reason?: string;
+	  }
+	| { type: TeamMessageType.OutcomeCreated; outcome: TeamOutcome }
+	| {
+			type: TeamMessageType.OutcomeFragmentAttached;
+			fragment: TeamOutcomeFragment;
+	  }
+	| {
+			type: TeamMessageType.OutcomeFragmentReviewed;
+			fragment: TeamOutcomeFragment;
+	  }
+	| { type: TeamMessageType.OutcomeFinalized; outcome: TeamOutcome };
+
+export interface AgentTeamsRuntimeOptions {
+	teamName: string;
+	leadAgentId?: string;
+	missionLogIntervalSteps?: number;
+	missionLogIntervalMs?: number;
+	maxConcurrentRuns?: number;
+	onTeamEvent?: (event: TeamEvent) => void;
+}
+
+export interface SpawnTeammateOptions {
+	agentId: string;
+	config: TeamMemberConfig;
+}
+
+function isAbortLikeError(error: unknown): boolean {
+	if (
+		typeof DOMException !== "undefined" &&
+		error instanceof DOMException &&
+		error.name === "AbortError"
+	) {
+		return true;
+	}
+	if (!(error instanceof Error)) {
+		return false;
+	}
+	return (
+		error.name === "AbortError" ||
+		error.message.toLowerCase().includes("aborted")
+	);
+}
+
+function isIntentionalShutdownAbort(
+	member: TeamMemberState | undefined,
+	error: unknown,
+): boolean {
+	return member?.status === "stopped" && isAbortLikeError(error);
+}
+
+// =============================================================================
+// AgentTeam
+// =============================================================================
+
+const TEAMMATE_API_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const RECOVERED_QUEUED_ACTIVITY = "recovered_queued";
+
+function buildRecoveredRunMessage(run: TeamRunRecord): string {
+	return `This is an automatic recovery of interrupted team run ${run.id}. The previous process stopped before completion. Continue the task safely, inspect the current workspace state before making changes, and avoid duplicating completed work.\n\n${run.message}`;
+}
+
+export class AgentTeam {
+	private agents: Map<string, SessionRuntime> = new Map();
+	private configs: Map<string, TeamMemberConfig> = new Map();
+	private onTeamEvent?: (event: TeamEvent) => void;
+
+	constructor(
+		configs?: Record<string, TeamMemberConfig>,
+		onTeamEvent?: (event: TeamEvent) => void,
+	) {
+		this.onTeamEvent = onTeamEvent;
+
+		if (configs) {
+			for (const [id, config] of Object.entries(configs)) {
+				this.addAgent(id, config);
+			}
+		}
+	}
+
+	addAgent(id: string, config: TeamMemberConfig): void {
+		if (this.agents.has(id)) {
+			throw new Error(`Agent with id "${id}" already exists in the team`);
+		}
+
+		const wrappedConfig: AgentConfig = {
+			...config,
+			onEvent: (event: AgentEvent) => {
+				config.onEvent?.(event);
+				this.emitEvent({
+					type: TeamMessageType.AgentEvent,
+					agentId: id,
+					event,
+				});
+			},
+		};
+
+		const agent = new SessionRuntime(wrappedConfig);
+		if (wrappedConfig.onEvent) {
+			agent.subscribeEvents(wrappedConfig.onEvent);
+		}
+		this.agents.set(id, agent);
+		this.configs.set(id, config);
+	}
+
+	removeAgent(id: string): boolean {
+		this.configs.delete(id);
+		return this.agents.delete(id);
+	}
+
+	getAgent(id: string): SessionRuntime | undefined {
+		return this.agents.get(id);
+	}
+
+	getAgentIds(): string[] {
+		return Array.from(this.agents.keys());
+	}
+
+	get size(): number {
+		return this.agents.size;
+	}
+
+	async routeTo(agentId: string, message: string): Promise<AgentResult> {
+		const agent = this.agents.get(agentId);
+		if (!agent) {
+			throw new Error(`Agent "${agentId}" not found in team`);
+		}
+
+		this.emitEvent({ type: TeamMessageType.TaskStart, agentId, message });
+
+		try {
+			const result = await agent.run(message);
+			this.emitEvent({ type: TeamMessageType.TaskEnd, agentId, result });
+			return result;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.emitEvent({
+				type: TeamMessageType.TaskEnd,
+				agentId,
+				error: err,
+				messages: agent.getMessages(),
+			});
+			throw error;
+		}
+	}
+
+	async continueTo(agentId: string, message: string): Promise<AgentResult> {
+		const agent = this.agents.get(agentId);
+		if (!agent) {
+			throw new Error(`Agent "${agentId}" not found in team`);
+		}
+
+		this.emitEvent({ type: TeamMessageType.TaskStart, agentId, message });
+
+		try {
+			const result = await agent.continue(message);
+			this.emitEvent({ type: TeamMessageType.TaskEnd, agentId, result });
+			return result;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.emitEvent({
+				type: TeamMessageType.TaskEnd,
+				agentId,
+				error: err,
+				messages: agent.getMessages(),
+			});
+			throw error;
+		}
+	}
+
+	async runParallel(tasks: AgentTask[]): Promise<TaskResult[]> {
+		const executions = tasks.map(async (task): Promise<TaskResult> => {
+			const agent = this.agents.get(task.agentId);
+			if (!agent) {
+				return {
+					agentId: task.agentId,
+					result: undefined as unknown as AgentResult,
+					error: new Error(`Agent "${task.agentId}" not found in team`),
+					metadata: task.metadata,
+				};
+			}
+
+			this.emitEvent({
+				type: TeamMessageType.TaskStart,
+				agentId: task.agentId,
+				message: task.message,
+			});
+
+			try {
+				const result = await agent.run(task.message);
+				this.emitEvent({
+					type: TeamMessageType.TaskEnd,
+					agentId: task.agentId,
+					result,
+				});
+				return {
+					agentId: task.agentId,
+					result,
+					metadata: task.metadata,
+				};
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				this.emitEvent({
+					type: TeamMessageType.TaskEnd,
+					agentId: task.agentId,
+					error: err,
+					messages: agent.getMessages(),
+				});
+				return {
+					agentId: task.agentId,
+					result: undefined as unknown as AgentResult,
+					error: err,
+					metadata: task.metadata,
+				};
+			}
+		});
+
+		return Promise.all(executions);
+	}
+
+	async runSequential(tasks: AgentTask[]): Promise<TaskResult[]> {
+		const results: TaskResult[] = [];
+
+		for (const task of tasks) {
+			const agent = this.agents.get(task.agentId);
+			if (!agent) {
+				results.push({
+					agentId: task.agentId,
+					result: undefined as unknown as AgentResult,
+					error: new Error(`Agent "${task.agentId}" not found in team`),
+					metadata: task.metadata,
+				});
+				continue;
+			}
+
+			this.emitEvent({
+				type: TeamMessageType.TaskStart,
+				agentId: task.agentId,
+				message: task.message,
+			});
+
+			try {
+				const result = await agent.run(task.message);
+				this.emitEvent({
+					type: TeamMessageType.TaskEnd,
+					agentId: task.agentId,
+					result,
+				});
+				results.push({
+					agentId: task.agentId,
+					result,
+					metadata: task.metadata,
+				});
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				this.emitEvent({
+					type: TeamMessageType.TaskEnd,
+					agentId: task.agentId,
+					error: err,
+					messages: agent.getMessages(),
+				});
+				results.push({
+					agentId: task.agentId,
+					result: undefined as unknown as AgentResult,
+					error: err,
+					metadata: task.metadata,
+				});
+			}
+		}
+
+		return results;
+	}
+
+	async runPipeline(
+		pipeline: string[],
+		initialMessage: string,
+		messageTransformer?: (
+			prevResult: AgentResult,
+			nextAgentId: string,
+		) => string,
+	): Promise<TaskResult[]> {
+		const results: TaskResult[] = [];
+		let currentMessage = initialMessage;
+
+		for (const agentId of pipeline) {
+			const agent = this.agents.get(agentId);
+			if (!agent) {
+				results.push({
+					agentId,
+					result: undefined as unknown as AgentResult,
+					error: new Error(`Agent "${agentId}" not found in team`),
+				});
+				break;
+			}
+
+			this.emitEvent({
+				type: TeamMessageType.TaskStart,
+				agentId,
+				message: currentMessage,
+			});
+
+			try {
+				const result = await agent.run(currentMessage);
+				this.emitEvent({ type: TeamMessageType.TaskEnd, agentId, result });
+				results.push({ agentId, result });
+
+				const nextIndex = pipeline.indexOf(agentId) + 1;
+				if (nextIndex < pipeline.length) {
+					const nextAgentId = pipeline[nextIndex];
+					currentMessage = messageTransformer
+						? messageTransformer(result, nextAgentId)
+						: `Previous agent output:\n${result.text}\n\nPlease continue from here.`;
+				}
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				this.emitEvent({
+					type: TeamMessageType.TaskEnd,
+					agentId,
+					error: err,
+					messages: agent.getMessages(),
+				});
+				results.push({
+					agentId,
+					result: undefined as unknown as AgentResult,
+					error: err,
+				});
+				break;
+			}
+		}
+
+		return results;
+	}
+
+	abortAll(): void {
+		for (const agent of this.agents.values()) {
+			agent.abort(new Error("Agent team abortAll requested"));
+		}
+	}
+
+	clear(): void {
+		this.abortAll();
+		this.agents.clear();
+		this.configs.clear();
+	}
+
+	private emitEvent(event: TeamEvent): void {
+		try {
+			this.onTeamEvent?.(event);
+		} catch {
+			// Ignore callback errors
+		}
+	}
+}
+
+// =============================================================================
+// Factory Functions
+// =============================================================================
+
+export function createAgentTeam(
+	configs: Record<string, TeamMemberConfig>,
+	onTeamEvent?: (event: TeamEvent) => void,
+): AgentTeam {
+	return new AgentTeam(configs, onTeamEvent);
+}
+
+export function createWorkerReviewerTeam(configs: {
+	worker: TeamMemberConfig;
+	reviewer: TeamMemberConfig;
+}): AgentTeam & {
+	doAndReview: (
+		message: string,
+	) => Promise<{ workerResult: AgentResult; reviewResult: AgentResult }>;
+} {
+	const team = createAgentTeam({
+		worker: configs.worker,
+		reviewer: configs.reviewer,
+	});
+
+	const enhanced = team as AgentTeam & {
+		doAndReview: (
+			message: string,
+		) => Promise<{ workerResult: AgentResult; reviewResult: AgentResult }>;
+	};
+
+	enhanced.doAndReview = async (message: string) => {
+		const workerResult = await team.routeTo("worker", message);
+		const reviewResult = await team.routeTo(
+			"reviewer",
+			`Please review this work:\n\n${workerResult.text}`,
+		);
+		return { workerResult, reviewResult };
+	};
+
+	return enhanced;
+}
+
+// =============================================================================
+// Agent Teams Runtime (lead + teammate collaboration)
+// =============================================================================
+
+interface TeamMemberState extends TeamMemberSnapshot {
+	agent?: SessionRuntime;
+	runningCount: number;
+	lastMissionStep: number;
+	lastMissionAt: number;
+	pendingSteerMessage?: string;
+}
+
+export class AgentTeamsRuntime {
+	private readonly teamId: string;
+	private readonly teamName: string;
+	private readonly onTeamEvent?: (event: TeamEvent) => void;
+	private readonly members: Map<string, TeamMemberState> = new Map();
+	private readonly tasks: Map<string, TeamTask> = new Map();
+	private readonly missionLog: MissionLogEntry[] = [];
+	private readonly mailbox: TeamMailboxMessage[] = [];
+	private missionStepCounter = 0;
+	private taskCounter = 0;
+	private messageCounter = 0;
+	private missionCounter = 0;
+	private runCounter = 0;
+	private outcomeCounter = 0;
+	private outcomeFragmentCounter = 0;
+	private readonly runs: Map<string, TeamRunRecord & { result?: AgentResult }> =
+		new Map();
+	private readonly runQueue: string[] = [];
+	private queuedRunDispatchTimer: ReturnType<typeof setTimeout> | undefined;
+	private readonly outcomes: Map<string, TeamOutcome> = new Map();
+	private readonly outcomeFragments: Map<string, TeamOutcomeFragment> =
+		new Map();
+	private readonly missionLogIntervalSteps: number;
+	private readonly missionLogIntervalMs: number;
+	private readonly maxConcurrentRuns: number;
+
+	constructor(options: AgentTeamsRuntimeOptions) {
+		this.teamName = options.teamName;
+		this.teamId = `t_${sanitizeFileName(nanoid(10))}`;
+		this.onTeamEvent = options.onTeamEvent;
+		this.missionLogIntervalSteps = Math.max(
+			1,
+			options.missionLogIntervalSteps ?? 3,
+		);
+		this.missionLogIntervalMs = Math.max(
+			1000,
+			options.missionLogIntervalMs ?? 120000,
+		);
+		this.maxConcurrentRuns = Math.max(1, options.maxConcurrentRuns ?? 2);
+		const leadAgentId = options.leadAgentId ?? "lead";
+		this.members.set(leadAgentId, {
+			agentId: leadAgentId,
+			role: "lead",
+			status: "idle",
+			runningCount: 0,
+			lastMissionStep: 0,
+			lastMissionAt: Date.now(),
+		});
+	}
+
+	getTeamId(): string {
+		return this.teamId;
+	}
+
+	getTeamName(): string {
+		return this.teamName;
+	}
+
+	getMemberRole(agentId: string): "lead" | "teammate" | undefined {
+		return this.members.get(agentId)?.role;
+	}
+
+	getMemberIds(): string[] {
+		return Array.from(this.members.keys());
+	}
+
+	getTeammateIds(): string[] {
+		return Array.from(this.members.values())
+			.filter((member) => member.role === "teammate")
+			.map((member) => member.agentId);
+	}
+
+	getTask(taskId: string): TeamTask | undefined {
+		return this.tasks.get(taskId);
+	}
+
+	listTasks(): TeamTask[] {
+		return Array.from(this.tasks.values());
+	}
+
+	listTaskItems(options?: {
+		status?: TeamTaskStatus;
+		assignee?: string;
+	}): TeamTaskListItem[] {
+		return Array.from(this.tasks.values())
+			.map((task) => {
+				const blockedBy = this.getUnresolvedDependencies(task);
+				return {
+					...task,
+					blockedBy,
+					isReady:
+						task.status === "pending" &&
+						!task.assignee &&
+						blockedBy.length === 0,
+				};
+			})
+			.filter((task) => {
+				if (options?.status && task.status !== options.status) {
+					return false;
+				}
+				if (options?.assignee && task.assignee !== options.assignee) {
+					return false;
+				}
+				return true;
+			});
+	}
+
+	listMissionLog(limit?: number): MissionLogEntry[] {
+		if (!limit || limit <= 0) {
+			return [...this.missionLog];
+		}
+		return this.missionLog.slice(Math.max(0, this.missionLog.length - limit));
+	}
+
+	listMailbox(
+		agentId: string,
+		options?: { unreadOnly?: boolean; markRead?: boolean; limit?: number },
+	): TeamMailboxMessage[] {
+		const unreadOnly = options?.unreadOnly ?? true;
+		const markRead = options?.markRead ?? true;
+		const limit = options?.limit;
+		const messages = this.mailbox.filter(
+			(message) =>
+				message.toAgentId === agentId && (!unreadOnly || !message.readAt),
+		);
+		const selected =
+			typeof limit === "number" && limit > 0
+				? messages.slice(Math.max(0, messages.length - limit))
+				: messages;
+		if (markRead) {
+			const now = new Date();
+			for (const message of selected) {
+				if (!message.readAt) {
+					message.readAt = now;
+				}
+			}
+		}
+		return selected.map((message) => ({ ...message }));
+	}
+
+	getSnapshot(): TeamRuntimeSnapshot {
+		const taskCounts: Record<TeamTaskStatus, number> = {
+			pending: 0,
+			in_progress: 0,
+			blocked: 0,
+			completed: 0,
+		};
+		for (const task of this.tasks.values()) {
+			taskCounts[task.status]++;
+		}
+		const outcomeCounts: Record<TeamOutcomeStatus, number> = {
+			draft: 0,
+			in_review: 0,
+			finalized: 0,
+		};
+		for (const outcome of this.outcomes.values()) {
+			outcomeCounts[outcome.status]++;
+		}
+		return {
+			teamId: this.teamId,
+			teamName: this.teamName,
+			members: Array.from(this.members.values()).map((member) => ({
+				agentId: member.agentId,
+				role: member.role,
+				description: member.description,
+				status: member.status,
+			})),
+			taskCounts,
+			unreadMessages: this.mailbox.filter((message) => !message.readAt).length,
+			missionLogEntries: this.missionLog.length,
+			activeRuns: Array.from(this.runs.values()).filter(
+				(run) => run.status === "running",
+			).length,
+			queuedRuns: Array.from(this.runs.values()).filter(
+				(run) => run.status === "queued",
+			).length,
+			outcomeCounts,
+		};
+	}
+
+	exportState(): TeamRuntimeState {
+		return {
+			teamId: this.teamId,
+			teamName: this.teamName,
+			members: Array.from(this.members.values()).map((member) => ({
+				agentId: member.agentId,
+				role: member.role,
+				description: member.description,
+				status: member.status,
+			})),
+			tasks: Array.from(this.tasks.values()).map((task) => ({ ...task })),
+			mailbox: this.mailbox.map((message) => ({ ...message })),
+			missionLog: this.missionLog.map((entry) => ({ ...entry })),
+			runs: Array.from(this.runs.values()).map((run) => ({ ...run })),
+			outcomes: Array.from(this.outcomes.values()).map((outcome) => ({
+				...outcome,
+			})),
+			outcomeFragments: Array.from(this.outcomeFragments.values()).map(
+				(fragment) => ({ ...fragment }),
+			),
+		};
+	}
+
+	hydrateState(state: TeamRuntimeState): void {
+		this.clearQueuedRunDispatchTimer();
+		this.tasks.clear();
+		for (const task of state.tasks) {
+			this.tasks.set(task.id, { ...task });
+		}
+
+		this.mailbox.length = 0;
+		this.mailbox.push(...state.mailbox.map((message) => ({ ...message })));
+
+		this.missionLog.length = 0;
+		this.missionLog.push(...state.missionLog.map((entry) => ({ ...entry })));
+
+		this.runs.clear();
+		for (const run of state.runs ?? []) {
+			this.runs.set(run.id, { ...run } as TeamRunRecord & {
+				result?: AgentResult;
+			});
+		}
+		this.runQueue.length = 0;
+		this.runQueue.push(
+			...Array.from(this.runs.values())
+				.filter((run) => run.status === "queued")
+				.map((run) => run.id),
+		);
+
+		this.outcomes.clear();
+		for (const outcome of state.outcomes ?? []) {
+			this.outcomes.set(outcome.id, { ...outcome });
+		}
+
+		this.outcomeFragments.clear();
+		for (const fragment of state.outcomeFragments ?? []) {
+			this.outcomeFragments.set(fragment.id, { ...fragment });
+		}
+
+		const leadMembers = Array.from(this.members.values()).filter(
+			(member) => member.role === "lead",
+		);
+		this.members.clear();
+		for (const lead of leadMembers) {
+			this.members.set(lead.agentId, {
+				...lead,
+				status: "idle",
+				runningCount: 0,
+				lastMissionStep: this.missionStepCounter,
+				lastMissionAt: Date.now(),
+			});
+		}
+		for (const member of state.members) {
+			if (member.role !== "teammate") {
+				continue;
+			}
+			this.members.set(member.agentId, {
+				agentId: member.agentId,
+				role: "teammate",
+				description: member.description,
+				status: "stopped",
+				agent: undefined,
+				runningCount: 0,
+				lastMissionStep: this.missionStepCounter,
+				lastMissionAt: Date.now(),
+			});
+		}
+
+		this.taskCounter = Math.max(
+			this.taskCounter,
+			maxCounter(
+				state.tasks.map((task) => task.id),
+				"task_",
+			),
+		);
+		this.messageCounter = Math.max(
+			this.messageCounter,
+			maxCounter(
+				state.mailbox.map((message) => message.id),
+				"msg_",
+			),
+		);
+		this.missionCounter = Math.max(
+			this.missionCounter,
+			maxCounter(
+				state.missionLog.map((entry) => entry.id),
+				"log_",
+			),
+		);
+		this.runCounter = Math.max(
+			this.runCounter,
+			maxCounter(
+				(state.runs ?? []).map((run) => run.id),
+				"run_",
+			),
+		);
+		this.outcomeCounter = Math.max(
+			this.outcomeCounter,
+			maxCounter(
+				(state.outcomes ?? []).map((outcome) => outcome.id),
+				"out_",
+			),
+		);
+		this.outcomeFragmentCounter = Math.max(
+			this.outcomeFragmentCounter,
+			maxCounter(
+				(state.outcomeFragments ?? []).map((fragment) => fragment.id),
+				"frag_",
+			),
+		);
+	}
+
+	isTeammateActive(agentId: string): boolean {
+		const member = this.members.get(agentId);
+		return !!member && member.role === "teammate" && !!member.agent;
+	}
+
+	spawnTeammate({ agentId, config }: SpawnTeammateOptions): TeamMemberSnapshot {
+		const existing = this.members.get(agentId);
+		if (existing && existing.role !== "teammate") {
+			throw new Error(
+				`Team member "${agentId}" already exists and is not a teammate`,
+			);
+		}
+		if (existing && existing.runningCount > 0) {
+			throw new Error(
+				`Teammate "${agentId}" is currently running and cannot be respawned`,
+			);
+		}
+
+		const wrappedConfig: TeamMemberConfig = {
+			...config,
+			apiTimeoutMs: TEAMMATE_API_TIMEOUT_MS,
+			consumePendingUserMessage: () => {
+				const member = this.members.get(agentId);
+				if (!member || !member.pendingSteerMessage) {
+					return undefined;
+				}
+				const message = member.pendingSteerMessage;
+				member.pendingSteerMessage = undefined;
+				return message;
+			},
+			onEvent: (event: AgentEvent) => {
+				config.onEvent?.(event);
+				this.emitEvent({ type: TeamMessageType.AgentEvent, agentId, event });
+				this.trackMeaningfulEvent(agentId, event);
+			},
+		};
+
+		const agent = new SessionRuntime(wrappedConfig);
+		if (wrappedConfig.onEvent) {
+			agent.subscribeEvents(wrappedConfig.onEvent);
+		}
+		const teammate: TeamMemberState = {
+			agentId,
+			role: "teammate",
+			description: config.role,
+			status: "idle",
+			agent,
+			runningCount: 0,
+			lastMissionStep: 0,
+			lastMissionAt: Date.now(),
+		};
+		this.members.set(agentId, teammate);
+		this.emitEvent({
+			type: TeamMessageType.TeammateSpawned,
+			agentId,
+			role: config.role,
+			teammate: {
+				rolePrompt: config.systemPrompt,
+				modelId: config.modelId,
+				maxIterations: config.maxIterations,
+				runtimeAgentId: agent.getAgentId(),
+				conversationId: agent.getConversationId(),
+				parentAgentId: null,
+			},
+		});
+		return {
+			agentId: teammate.agentId,
+			role: teammate.role,
+			description: teammate.description,
+			status: teammate.status,
+		};
+	}
+
+	shutdownTeammate(agentId: string, reason?: string): void {
+		const member = this.members.get(agentId);
+		if (!member || member.role !== "teammate") {
+			throw new Error(`Teammate "${agentId}" was not found`);
+		}
+		try {
+			member.agent?.abort();
+		} catch (error) {
+			if (!isAbortLikeError(error)) {
+				throw error;
+			}
+		}
+		member.status = "stopped";
+		this.emitEvent({ type: TeamMessageType.TeammateShutdown, agentId, reason });
+	}
+
+	updateTeammateConnections(
+		overrides: Partial<Pick<AgentConfig, "apiKey" | "baseUrl" | "headers">>,
+	): void {
+		for (const member of this.members.values()) {
+			if (member.role !== "teammate" || !member.agent) {
+				continue;
+			}
+			member.agent.updateConnection(overrides);
+		}
+	}
+
+	createTask(input: CreateTeamTaskInput): TeamTask {
+		const taskId = `task_${String(++this.taskCounter).padStart(4, "0")}`;
+		const now = new Date();
+		const task: TeamTask = {
+			id: taskId,
+			title: input.title,
+			description: input.description,
+			status: input.assignee ? "in_progress" : "pending",
+			createdAt: now,
+			updatedAt: now,
+			createdBy: input.createdBy,
+			assignee: input.assignee,
+			dependsOn: input.dependsOn ?? [],
+		};
+		this.tasks.set(taskId, task);
+		this.emitEvent({
+			type: TeamMessageType.TeamTaskUpdated,
+			task: { ...task },
+		});
+		return { ...task };
+	}
+
+	claimTask(taskId: string, agentId: string): TeamTask {
+		const task = this.requireTask(taskId);
+		this.assertDependenciesResolved(task);
+		task.status = "in_progress";
+		task.assignee = agentId;
+		task.updatedAt = new Date();
+		this.emitEvent({
+			type: TeamMessageType.TeamTaskUpdated,
+			task: { ...task },
+		});
+		this.appendMissionLog({
+			agentId,
+			taskId,
+			kind: "progress",
+			summary: `Claimed task "${task.title}"`,
+		});
+		return { ...task };
+	}
+
+	blockTask(taskId: string, agentId: string, reason: string): TeamTask {
+		const task = this.requireTask(taskId);
+		task.status = "blocked";
+		task.updatedAt = new Date();
+		task.summary = reason;
+		this.emitEvent({
+			type: TeamMessageType.TeamTaskUpdated,
+			task: { ...task },
+		});
+		this.appendMissionLog({
+			agentId,
+			taskId,
+			kind: "blocked",
+			summary: reason,
+		});
+		return { ...task };
+	}
+
+	completeTask(taskId: string, agentId: string, summary: string): TeamTask {
+		const task = this.requireTask(taskId);
+		task.status = "completed";
+		task.updatedAt = new Date();
+		task.summary = summary;
+		if (!task.assignee) {
+			task.assignee = agentId;
+		}
+		this.emitEvent({
+			type: TeamMessageType.TeamTaskUpdated,
+			task: { ...task },
+		});
+		this.appendMissionLog({
+			agentId,
+			taskId,
+			kind: "done",
+			summary,
+		});
+		return { ...task };
+	}
+
+	async routeToTeammate(
+		agentId: string,
+		message: string,
+		options?: RouteToTeammateOptions,
+	): Promise<AgentResult> {
+		const member = this.members.get(agentId);
+		if (!member || member.role !== "teammate" || !member.agent) {
+			throw new Error(`Teammate "${agentId}" was not found`);
+		}
+		if (!member.agent.canStartRun()) {
+			throw new Error(
+				`Cannot start a new run while another run is already in progress`,
+			);
+		}
+
+		member.runningCount++;
+		member.status = "running";
+		this.emitEvent({ type: TeamMessageType.TaskStart, agentId, message });
+
+		try {
+			const unreadMail = this.listMailbox(agentId, {
+				unreadOnly: true,
+				markRead: true,
+			});
+			const enrichedMessage =
+				unreadMail.length > 0
+					? `${this.buildMailboxNotification(unreadMail)}\n\n${message}`
+					: message;
+			const result = options?.continueConversation
+				? await member.agent.continue(enrichedMessage)
+				: await member.agent.run(enrichedMessage);
+			this.emitEvent({ type: TeamMessageType.TaskEnd, agentId, result });
+			this.recordProgressStep(
+				agentId,
+				`Completed a delegated run (${result.iterations} iterations)`,
+				options?.taskId,
+				true,
+			);
+			return result;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.emitEvent({
+				type: TeamMessageType.TaskEnd,
+				agentId,
+				error: err,
+				messages: member.agent.getMessages(),
+			});
+			if (!isIntentionalShutdownAbort(member, err)) {
+				this.appendMissionLog({
+					agentId,
+					taskId: options?.taskId,
+					kind: "error",
+					summary: err.message,
+				});
+			}
+			throw err;
+		} finally {
+			member.runningCount--;
+			if (
+				member.runningCount <= 0 &&
+				this.members.get(agentId)?.status !== "stopped"
+			) {
+				member.status = "idle";
+			}
+		}
+	}
+
+	startTeammateRun(
+		agentId: string,
+		message: string,
+		options?: RouteToTeammateOptions & {
+			priority?: number;
+			maxRetries?: number;
+			leaseOwner?: string;
+		},
+	): TeamRunRecord {
+		const runId = `run_${String(++this.runCounter).padStart(5, "0")}`;
+		const record: TeamRunRecord & { result?: AgentResult } = {
+			id: runId,
+			agentId,
+			taskId: options?.taskId,
+			status: "queued",
+			message,
+			priority: options?.priority ?? 0,
+			retryCount: 0,
+			maxRetries: Math.max(0, options?.maxRetries ?? 0),
+			continueConversation: options?.continueConversation,
+			startedAt: new Date(0),
+			leaseOwner: options?.leaseOwner,
+			heartbeatAt: undefined,
+			lastProgressAt: new Date(),
+			lastProgressMessage: "queued",
+			currentActivity: "queued",
+		};
+		this.runs.set(runId, record);
+		this.runQueue.push(runId);
+		this.emitEvent({ type: TeamMessageType.RunQueued, run: { ...record } });
+		this.dispatchQueuedRuns();
+		return { ...record };
+	}
+
+	private dispatchQueuedRuns(): void {
+		this.clearQueuedRunDispatchTimer();
+		let nextDelayedAttemptAt: Date | undefined;
+		while (
+			this.countActiveRuns() < this.maxConcurrentRuns &&
+			this.runQueue.length > 0
+		) {
+			const nextRun = this.selectNextDispatchableQueuedRun();
+			nextDelayedAttemptAt = nextRun.nextDelayedAttemptAt;
+			const nextRunIndex = nextRun.index;
+			if (nextRunIndex < 0) {
+				this.scheduleQueuedRunDispatch(nextDelayedAttemptAt);
+				return;
+			}
+			const [runId] = this.runQueue.splice(nextRunIndex, 1);
+			const run = runId ? this.runs.get(runId) : undefined;
+			if (!run || run.status !== "queued") {
+				continue;
+			}
+			void this.executeQueuedRun(run);
+		}
+		this.scheduleQueuedRunDispatch(nextDelayedAttemptAt);
+	}
+
+	private selectNextDispatchableQueuedRun(): {
+		index: number;
+		nextDelayedAttemptAt?: Date;
+	} {
+		let selectedIndex = -1;
+		let bestPriority = Number.NEGATIVE_INFINITY;
+		let nextDelayedAttemptAt: Date | undefined;
+		const now = Date.now();
+		for (let index = 0; index < this.runQueue.length; index++) {
+			const run = this.runs.get(this.runQueue[index]);
+			if (!run || run.status !== "queued") {
+				continue;
+			}
+			if (run.nextAttemptAt && run.nextAttemptAt.getTime() > now) {
+				if (!nextDelayedAttemptAt || run.nextAttemptAt < nextDelayedAttemptAt) {
+					nextDelayedAttemptAt = run.nextAttemptAt;
+				}
+				continue;
+			}
+			if (run.priority > bestPriority) {
+				bestPriority = run.priority;
+				selectedIndex = index;
+			}
+		}
+		return { index: selectedIndex, nextDelayedAttemptAt };
+	}
+
+	private scheduleQueuedRunDispatch(nextAttemptAt: Date | undefined): void {
+		if (!nextAttemptAt) {
+			return;
+		}
+		const delayMs = Math.max(0, nextAttemptAt.getTime() - Date.now());
+		this.queuedRunDispatchTimer = setTimeout(() => {
+			this.queuedRunDispatchTimer = undefined;
+			this.dispatchQueuedRuns();
+		}, delayMs);
+	}
+
+	private clearQueuedRunDispatchTimer(): void {
+		if (!this.queuedRunDispatchTimer) {
+			return;
+		}
+		clearTimeout(this.queuedRunDispatchTimer);
+		this.queuedRunDispatchTimer = undefined;
+	}
+
+	private countActiveRuns(): number {
+		let count = 0;
+		for (const run of this.runs.values()) {
+			if (run.status === "running") {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	private async executeQueuedRun(
+		run: TeamRunRecord & { result?: AgentResult },
+	): Promise<void> {
+		const recoveredRun = run.currentActivity === RECOVERED_QUEUED_ACTIVITY;
+		run.nextAttemptAt = undefined;
+		run.status = "running";
+		run.startedAt = new Date();
+		run.heartbeatAt = new Date();
+		run.currentActivity = "run_started";
+		this.emitEvent({ type: TeamMessageType.RunStarted, run: { ...run } });
+
+		const heartbeatTimer = setInterval(() => {
+			if (run.status !== "running") {
+				return;
+			}
+			this.recordRunProgress(run, "heartbeat");
+		}, 2000);
+
+		try {
+			const runMessage = recoveredRun
+				? buildRecoveredRunMessage(run)
+				: run.message;
+			const result = await this.routeToTeammate(run.agentId, runMessage, {
+				taskId: run.taskId,
+				continueConversation: run.continueConversation,
+			});
+			run.status = "completed";
+			run.result = result;
+			run.endedAt = new Date();
+			run.currentActivity = "completed";
+			this.emitEvent({ type: TeamMessageType.RunCompleted, run: { ...run } });
+		} catch (error) {
+			const message =
+				error instanceof Error
+					? error.message
+					: String(error ?? "Unknown error");
+			run.error = message;
+			run.endedAt = new Date();
+			const member = this.members.get(run.agentId);
+			if (isIntentionalShutdownAbort(member, error)) {
+				run.status = "cancelled";
+				run.currentActivity = "cancelled";
+				this.emitEvent({
+					type: TeamMessageType.RunCancelled,
+					run: { ...run },
+					reason: message,
+				});
+			} else if (run.retryCount < run.maxRetries) {
+				run.retryCount++;
+				run.status = "queued";
+				run.nextAttemptAt = new Date(
+					Date.now() + Math.min(30000, 1000 * 2 ** run.retryCount),
+				);
+				this.runQueue.push(run.id);
+				this.recordRunProgress(run, `retry_scheduled_${run.retryCount}`);
+			} else {
+				run.status = "failed";
+				run.currentActivity = "failed";
+				this.emitEvent({ type: TeamMessageType.RunFailed, run: { ...run } });
+			}
+		} finally {
+			clearInterval(heartbeatTimer);
+			this.dispatchQueuedRuns();
+		}
+	}
+
+	listRuns(options?: {
+		status?: TeamRunStatus | null;
+		agentId?: string | null;
+		includeCompleted?: boolean | null;
+	}): TeamRunRecord[] {
+		const includeCompleted = options?.includeCompleted ?? true;
+		return Array.from(this.runs.values())
+			.filter((run) => {
+				if (!includeCompleted && !["running", "queued"].includes(run.status)) {
+					return false;
+				}
+				if (options?.status && run.status !== options.status) {
+					return false;
+				}
+				if (options?.agentId && run.agentId !== options.agentId) {
+					return false;
+				}
+				return true;
+			})
+			.map((run) => ({ ...run }));
+	}
+
+	getRun(runId: string): TeamRunRecord | undefined {
+		const run = this.runs.get(runId);
+		return run ? { ...run } : undefined;
+	}
+
+	async awaitRun(runId: string, pollIntervalMs = 250): Promise<TeamRunRecord> {
+		const run = this.runs.get(runId);
+		if (!run) {
+			throw new Error(`Run "${runId}" was not found`);
+		}
+		while (run.status === "queued" || run.status === "running") {
+			await sleep(pollIntervalMs);
+		}
+		return { ...run };
+	}
+
+	async awaitAllRuns(pollIntervalMs = 250): Promise<TeamRunRecord[]> {
+		while (
+			Array.from(this.runs.values()).some((run) =>
+				["queued", "running"].includes(run.status),
+			)
+		) {
+			await sleep(pollIntervalMs);
+		}
+		return this.listRuns();
+	}
+
+	cancelRun(runId: string, reason?: string): TeamRunRecord {
+		const run = this.runs.get(runId);
+		if (!run) {
+			throw new Error(`Run "${runId}" was not found`);
+		}
+		if (run.status === "completed" || run.status === "failed") {
+			return { ...run };
+		}
+		run.status = "cancelled";
+		run.error = reason;
+		run.endedAt = new Date();
+		run.currentActivity = "cancelled";
+		const queueIndex = this.runQueue.indexOf(runId);
+		if (queueIndex >= 0) {
+			this.runQueue.splice(queueIndex, 1);
+		}
+		this.emitEvent({
+			type: TeamMessageType.RunCancelled,
+			run: { ...run },
+			reason,
+		});
+		return { ...run };
+	}
+
+	recoverActiveRuns(reason = "runtime_recovered"): TeamRunRecord[] {
+		const recovered: TeamRunRecord[] = [];
+		for (const run of this.runs.values()) {
+			if (!["queued", "running"].includes(run.status)) {
+				continue;
+			}
+
+			const member = this.members.get(run.agentId);
+			if (!member || member.role !== "teammate" || !member.agent) {
+				run.status = "interrupted";
+				run.error = "teammate_unavailable_after_recovery";
+				run.endedAt = new Date();
+				run.currentActivity = "interrupted";
+				this.emitEvent({
+					type: TeamMessageType.RunInterrupted,
+					run: { ...run },
+					reason: run.error,
+				});
+				continue;
+			}
+
+			const now = new Date();
+			run.status = "queued";
+			run.error = undefined;
+			run.endedAt = undefined;
+			run.heartbeatAt = now;
+			run.lastProgressAt = now;
+			run.lastProgressMessage = reason;
+			run.currentActivity = RECOVERED_QUEUED_ACTIVITY;
+			if (!this.runQueue.includes(run.id)) {
+				this.runQueue.push(run.id);
+			}
+			recovered.push({ ...run });
+			this.emitEvent({ type: TeamMessageType.RunQueued, run: { ...run } });
+		}
+		this.dispatchQueuedRuns();
+		return recovered;
+	}
+
+	markStaleRunsInterrupted(reason = "runtime_recovered"): TeamRunRecord[] {
+		const interrupted: TeamRunRecord[] = [];
+		for (const run of this.runs.values()) {
+			if (!["queued", "running"].includes(run.status)) {
+				continue;
+			}
+			run.status = "interrupted";
+			run.error = reason;
+			run.endedAt = new Date();
+			run.currentActivity = "interrupted";
+			interrupted.push({ ...run });
+			this.emitEvent({
+				type: TeamMessageType.RunInterrupted,
+				run: { ...run },
+				reason,
+			});
+		}
+		this.runQueue.length = 0;
+		this.clearQueuedRunDispatchTimer();
+		return interrupted;
+	}
+
+	sendMessage(
+		fromAgentId: string,
+		toAgentId: string,
+		subject: string,
+		body: string,
+		taskId?: string,
+	): TeamMailboxMessage {
+		if (!this.members.has(fromAgentId)) {
+			throw new Error(`Unknown sender "${fromAgentId}"`);
+		}
+		const recipient = this.members.get(toAgentId);
+		if (!recipient) {
+			throw new Error(`Unknown recipient "${toAgentId}"`);
+		}
+		const message: TeamMailboxMessage = {
+			id: `msg_${String(++this.messageCounter).padStart(5, "0")}`,
+			teamId: this.teamId,
+			fromAgentId,
+			toAgentId,
+			subject,
+			body,
+			taskId,
+			sentAt: new Date(),
+		};
+		this.mailbox.push(message);
+		this.emitEvent({
+			type: TeamMessageType.TeamMessage,
+			message: { ...message },
+		});
+		if (
+			recipient.role === "teammate" &&
+			recipient.runningCount > 0 &&
+			recipient.agent
+		) {
+			recipient.pendingSteerMessage = `[MAILBOX] You got a message from ${fromAgentId}. Subject: "${subject}". Use the team_read_mailbox tool to read it at your convenience.`;
+		}
+		return { ...message };
+	}
+
+	broadcast(
+		fromAgentId: string,
+		subject: string,
+		body: string,
+		options?: { taskId?: string },
+	): TeamMailboxMessage[] {
+		const messages: TeamMailboxMessage[] = [];
+		for (const member of this.members.values()) {
+			if (member.agentId === fromAgentId) {
+				continue;
+			}
+			if (member.role === "lead") {
+				continue;
+			}
+			messages.push(
+				this.sendMessage(
+					fromAgentId,
+					member.agentId,
+					subject,
+					body,
+					options?.taskId,
+				),
+			);
+		}
+		return messages;
+	}
+
+	appendMissionLog(input: AppendMissionLogInput): MissionLogEntry {
+		if (!this.members.has(input.agentId)) {
+			throw new Error(`Unknown team member "${input.agentId}"`);
+		}
+		const entry: MissionLogEntry = {
+			id: `log_${String(++this.missionCounter).padStart(6, "0")}`,
+			ts: new Date(),
+			teamId: this.teamId,
+			agentId: input.agentId,
+			taskId: input.taskId,
+			kind: input.kind,
+			summary: input.summary,
+			evidence: input.evidence,
+			nextAction: input.nextAction,
+		};
+		this.missionLog.push(entry);
+		const member = this.members.get(input.agentId);
+		if (member) {
+			member.lastMissionAt = Date.now();
+			member.lastMissionStep = this.missionStepCounter;
+		}
+		this.emitEvent({
+			type: TeamMessageType.TeamMissionLog,
+			entry: { ...entry },
+		});
+		return { ...entry };
+	}
+
+	createOutcome(input: CreateTeamOutcomeInput): TeamOutcome {
+		const outcome: TeamOutcome = {
+			id: `out_${String(++this.outcomeCounter).padStart(4, "0")}`,
+			teamId: this.teamId,
+			title: input.title,
+			status: "draft",
+			requiredSections: [...new Set(input.requiredSections)],
+			createdBy: input.createdBy,
+			createdAt: new Date(),
+		};
+		this.outcomes.set(outcome.id, outcome);
+		this.emitEvent({
+			type: TeamMessageType.OutcomeCreated,
+			outcome: { ...outcome },
+		});
+		return { ...outcome };
+	}
+
+	listOutcomes(): TeamOutcome[] {
+		return Array.from(this.outcomes.values()).map((outcome) => ({
+			...outcome,
+		}));
+	}
+
+	attachOutcomeFragment(
+		input: AttachTeamOutcomeFragmentInput,
+	): TeamOutcomeFragment {
+		const outcome = this.outcomes.get(input.outcomeId);
+		if (!outcome) {
+			throw new Error(`Outcome "${input.outcomeId}" was not found`);
+		}
+		if (!outcome.requiredSections.includes(input.section)) {
+			throw new Error(
+				`Section "${input.section}" is not part of outcome "${input.outcomeId}"`,
+			);
+		}
+		const fragment: TeamOutcomeFragment = {
+			id: `frag_${String(++this.outcomeFragmentCounter).padStart(5, "0")}`,
+			teamId: this.teamId,
+			outcomeId: input.outcomeId,
+			section: input.section,
+			sourceAgentId: input.sourceAgentId,
+			sourceRunId: input.sourceRunId,
+			content: input.content,
+			status: "draft",
+			createdAt: new Date(),
+		};
+		this.outcomeFragments.set(fragment.id, fragment);
+		if (outcome.status === "draft") {
+			outcome.status = "in_review";
+		}
+		this.emitEvent({
+			type: TeamMessageType.OutcomeFragmentAttached,
+			fragment: { ...fragment },
+		});
+		return { ...fragment };
+	}
+
+	reviewOutcomeFragment(
+		input: ReviewTeamOutcomeFragmentInput,
+	): TeamOutcomeFragment {
+		const fragment = this.outcomeFragments.get(input.fragmentId);
+		if (!fragment) {
+			throw new Error(`Fragment "${input.fragmentId}" was not found`);
+		}
+		fragment.status = input.approved ? "reviewed" : "rejected";
+		fragment.reviewedBy = input.reviewedBy;
+		fragment.reviewedAt = new Date();
+		this.emitEvent({
+			type: TeamMessageType.OutcomeFragmentReviewed,
+			fragment: { ...fragment },
+		});
+		return { ...fragment };
+	}
+
+	listOutcomeFragments(outcomeId: string): TeamOutcomeFragment[] {
+		return Array.from(this.outcomeFragments.values())
+			.filter((fragment) => fragment.outcomeId === outcomeId)
+			.map((fragment) => ({ ...fragment }));
+	}
+
+	finalizeOutcome(outcomeId: string): TeamOutcome {
+		const outcome = this.outcomes.get(outcomeId);
+		if (!outcome) {
+			throw new Error(`Outcome "${outcomeId}" was not found`);
+		}
+		const fragments = this.listOutcomeFragments(outcomeId);
+		for (const section of outcome.requiredSections) {
+			const approvedForSection = fragments.some(
+				(fragment) =>
+					fragment.section === section && fragment.status === "reviewed",
+			);
+			if (!approvedForSection) {
+				throw new Error(
+					`Outcome "${outcomeId}" cannot be finalized. Section "${section}" is missing a reviewed fragment.`,
+				);
+			}
+		}
+		outcome.status = "finalized";
+		outcome.finalizedAt = new Date();
+		this.emitEvent({
+			type: TeamMessageType.OutcomeFinalized,
+			outcome: { ...outcome },
+		});
+		return { ...outcome };
+	}
+
+	cleanup(): void {
+		for (const member of this.members.values()) {
+			if (member.role === "teammate" && member.runningCount > 0) {
+				throw new Error(
+					`Cannot cleanup team while teammate "${member.agentId}" is still running`,
+				);
+			}
+		}
+		if (
+			Array.from(this.runs.values()).some((run) =>
+				["queued", "running"].includes(run.status),
+			)
+		) {
+			throw new Error(
+				"Cannot cleanup team while async teammate runs are still active",
+			);
+		}
+
+		for (const member of this.members.values()) {
+			if (member.role === "teammate") {
+				try {
+					member.agent?.abort();
+				} catch (error) {
+					if (!isAbortLikeError(error)) {
+						throw error;
+					}
+				}
+			}
+		}
+
+		this.tasks.clear();
+		this.mailbox.length = 0;
+		this.missionLog.length = 0;
+		this.runs.clear();
+		this.runQueue.length = 0;
+		this.clearQueuedRunDispatchTimer();
+		this.outcomes.clear();
+		this.outcomeFragments.clear();
+
+		for (const [memberId, member] of this.members.entries()) {
+			if (member.role === "teammate") {
+				this.members.delete(memberId);
+			}
+		}
+	}
+
+	private requireTask(taskId: string): TeamTask {
+		const task = this.tasks.get(taskId);
+		if (!task) {
+			throw new Error(`Task "${taskId}" was not found`);
+		}
+		return task;
+	}
+
+	private assertDependenciesResolved(task: TeamTask): void {
+		const blockedBy = this.getUnresolvedDependencies(task);
+		if (blockedBy.length > 0) {
+			throw new Error(`Task "${task.id}" is blocked by "${blockedBy[0]}"`);
+		}
+	}
+
+	private getUnresolvedDependencies(task: TeamTask): string[] {
+		return task.dependsOn.filter((dependencyId) => {
+			const dependency = this.tasks.get(dependencyId);
+			return !dependency || dependency.status !== "completed";
+		});
+	}
+
+	private trackMeaningfulEvent(agentId: string, event: AgentEvent): void {
+		this.recordRunActivityFromAgentEvent(agentId, event);
+
+		if (event.type === "iteration_end" && event.hadToolCalls) {
+			this.recordProgressStep(
+				agentId,
+				`Completed iteration ${event.iteration} with ${event.toolCallCount} tool call(s)`,
+			);
+			return;
+		}
+
+		if (
+			event.type === "content_end" &&
+			event.contentType === "tool" &&
+			!event.error
+		) {
+			this.recordProgressStep(
+				agentId,
+				`Finished tool "${event.toolName ?? "unknown"}"`,
+			);
+			return;
+		}
+
+		if (event.type === "done") {
+			this.appendMissionLog({
+				agentId,
+				kind: "done",
+				summary: `Completed a delegated run (${event.iterations} iterations)`,
+			});
+			return;
+		}
+
+		if (event.type === "error") {
+			this.appendMissionLog({
+				agentId,
+				kind: "error",
+				summary: event.error.message,
+			});
+		}
+	}
+
+	private recordRunActivityFromAgentEvent(
+		agentId: string,
+		event: AgentEvent,
+	): void {
+		let activity: string | undefined;
+		switch (event.type) {
+			case "iteration_start":
+				activity = `iteration_${event.iteration}_started`;
+				break;
+			case "content_start":
+				if (event.contentType === "tool") {
+					activity = `running_tool_${event.toolName ?? "unknown"}`;
+				}
+				break;
+			case "content_end":
+				if (event.contentType === "tool") {
+					activity = event.error
+						? this.formatProgressErrorActivity(
+								`tool_${event.toolName ?? "unknown"}_error`,
+								event.error,
+							)
+						: `finished_tool_${event.toolName ?? "unknown"}`;
+				}
+				break;
+			case "done":
+				activity = "finalizing_response";
+				break;
+			case "error":
+				activity = this.formatProgressErrorActivity(
+					"run_error",
+					event.error.message,
+				);
+				break;
+			default:
+				break;
+		}
+		if (!activity) {
+			return;
+		}
+		for (const run of this.runs.values()) {
+			if (run.agentId !== agentId || run.status !== "running") {
+				continue;
+			}
+			this.recordRunProgress(run, activity);
+		}
+	}
+
+	private recordRunProgress(run: TeamRunRecord, message: string): void {
+		const now = new Date();
+		run.heartbeatAt = now;
+		run.lastProgressAt = now;
+		run.lastProgressMessage = message;
+		run.currentActivity = message;
+		this.emitEvent({
+			type: TeamMessageType.RunProgress,
+			run: { ...run },
+			message,
+		});
+	}
+
+	private formatProgressErrorActivity(prefix: string, detail: string): string {
+		const summary = detail.replace(/\s+/g, " ").trim();
+		if (summary.length === 0) {
+			return prefix;
+		}
+		const suffix =
+			summary.length > 240 ? `${summary.slice(0, 237).trimEnd()}...` : summary;
+		return `${prefix}: ${suffix}`;
+	}
+
+	private recordProgressStep(
+		agentId: string,
+		summary: string,
+		taskId?: string,
+		force = false,
+	): void {
+		this.missionStepCounter++;
+		const member = this.members.get(agentId);
+		if (!member) {
+			return;
+		}
+		const stepsSinceLast = this.missionStepCounter - member.lastMissionStep;
+		const elapsedMs = Date.now() - member.lastMissionAt;
+		if (
+			!force &&
+			stepsSinceLast < this.missionLogIntervalSteps &&
+			elapsedMs < this.missionLogIntervalMs
+		) {
+			return;
+		}
+		this.appendMissionLog({
+			agentId,
+			taskId,
+			kind: "progress",
+			summary,
+		});
+	}
+
+	private buildMailboxNotification(messages: TeamMailboxMessage[]): string {
+		if (messages.length === 0) {
+			return "";
+		}
+		const lines: string[] = [
+			`[MAILBOX] You have ${messages.length} unread message(s):`,
+		];
+		for (const msg of messages) {
+			lines.push(
+				`--- Message from ${msg.fromAgentId} | subject: ${msg.subject} ---`,
+			);
+			lines.push(msg.body);
+		}
+		lines.push("---");
+		return lines.join("\n");
+	}
+
+	private emitEvent(event: TeamEvent): void {
+		try {
+			this.onTeamEvent?.(event);
+		} catch {
+			// Ignore callback errors to avoid disrupting execution.
+		}
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function maxCounter(ids: string[], prefix: string): number {
+	let max = 0;
+	for (const id of ids) {
+		if (!id.startsWith(prefix)) {
+			continue;
+		}
+		const value = Number.parseInt(id.slice(prefix.length), 10);
+		if (Number.isFinite(value)) {
+			max = Math.max(max, value);
+		}
+	}
+	return max;
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/projections.ts b/sdk/packages/core/src/extensions/tools/team/projections.ts
new file mode 100644
index 0000000..1c0ed62
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/projections.ts
@@ -0,0 +1,283 @@
+import type {
+	TeamOutcome,
+	TeamOutcomeFragment,
+	TeamProgressLifecycleEvent,
+	TeamProgressSummary,
+	TeamRuntimeState,
+} from "@cline/shared";
+import type { TeamEvent } from "./multi-agent";
+
+function toIsoNow(): string {
+	return new Date().toISOString();
+}
+
+function pct(numerator: number, denominator: number): number {
+	if (denominator <= 0) {
+		return 0;
+	}
+	return Math.round((numerator / denominator) * 100);
+}
+
+function collectMissingRequiredSections(
+	outcomes: TeamOutcome[],
+	fragments: TeamOutcomeFragment[],
+): string[] {
+	const approvedSections = new Set<string>();
+	for (const fragment of fragments) {
+		if (fragment.status === "reviewed") {
+			approvedSections.add(`${fragment.outcomeId}:${fragment.section}`);
+		}
+	}
+	const missing = new Set<string>();
+	for (const outcome of outcomes) {
+		if (outcome.status === "finalized") {
+			continue;
+		}
+		for (const section of outcome.requiredSections) {
+			if (!approvedSections.has(`${outcome.id}:${section}`)) {
+				missing.add(`${outcome.id}:${section}`);
+			}
+		}
+	}
+	return [...missing].sort((a, b) => a.localeCompare(b));
+}
+
+export function buildTeamProgressSummary(
+	teamName: string,
+	state: TeamRuntimeState,
+): TeamProgressSummary {
+	const membersByStatus: Record<"idle" | "running" | "stopped", number> = {
+		idle: 0,
+		running: 0,
+		stopped: 0,
+	};
+	const tasksByStatus: Record<
+		"pending" | "in_progress" | "blocked" | "completed",
+		number
+	> = {
+		pending: 0,
+		in_progress: 0,
+		blocked: 0,
+		completed: 0,
+	};
+	const runsByStatus: Record<
+		"queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted",
+		number
+	> = {
+		queued: 0,
+		running: 0,
+		completed: 0,
+		failed: 0,
+		cancelled: 0,
+		interrupted: 0,
+	};
+	const outcomesByStatus: Record<"draft" | "in_review" | "finalized", number> =
+		{
+			draft: 0,
+			in_review: 0,
+			finalized: 0,
+		};
+	const fragmentsByStatus: Record<"draft" | "reviewed" | "rejected", number> = {
+		draft: 0,
+		reviewed: 0,
+		rejected: 0,
+	};
+
+	let leadCount = 0;
+	let teammateCount = 0;
+	for (const member of state.members) {
+		membersByStatus[member.status] += 1;
+		if (member.role === "lead") {
+			leadCount += 1;
+		} else {
+			teammateCount += 1;
+		}
+	}
+
+	const blockedTaskIds: string[] = [];
+	const readyTaskIds: string[] = [];
+	const completedTaskCount = state.tasks.filter(
+		(task) => task.status === "completed",
+	).length;
+	const taskById = new Map(state.tasks.map((task) => [task.id, task] as const));
+	for (const task of state.tasks) {
+		tasksByStatus[task.status] += 1;
+		if (task.status === "blocked") {
+			blockedTaskIds.push(task.id);
+			continue;
+		}
+		if (task.status !== "pending") {
+			continue;
+		}
+		const depsSatisfied = task.dependsOn.every((depId) => {
+			const dependency = taskById.get(depId);
+			return dependency?.status === "completed";
+		});
+		if (depsSatisfied) {
+			readyTaskIds.push(task.id);
+		}
+	}
+
+	const activeRunIds: string[] = [];
+	let latestRunId: string | undefined;
+	let latestRunTs = 0;
+	for (const run of state.runs) {
+		runsByStatus[run.status] += 1;
+		if (run.status === "queued" || run.status === "running") {
+			activeRunIds.push(run.id);
+		}
+		const startedAtTs = run.startedAt.getTime();
+		if (startedAtTs >= latestRunTs) {
+			latestRunTs = startedAtTs;
+			latestRunId = run.id;
+		}
+	}
+
+	for (const outcome of state.outcomes) {
+		outcomesByStatus[outcome.status] += 1;
+	}
+	for (const fragment of state.outcomeFragments) {
+		fragmentsByStatus[fragment.status] += 1;
+	}
+
+	return {
+		teamName,
+		updatedAt: toIsoNow(),
+		members: {
+			total: state.members.length,
+			byStatus: membersByStatus,
+			leadCount,
+			teammateCount,
+		},
+		tasks: {
+			total: state.tasks.length,
+			byStatus: tasksByStatus,
+			blockedTaskIds,
+			readyTaskIds,
+			completionPct: pct(completedTaskCount, state.tasks.length),
+		},
+		runs: {
+			total: state.runs.length,
+			byStatus: runsByStatus,
+			activeRunIds,
+			latestRunId,
+		},
+		outcomes: {
+			total: state.outcomes.length,
+			byStatus: outcomesByStatus,
+			finalizedPct: pct(outcomesByStatus.finalized, state.outcomes.length),
+			missingRequiredSections: collectMissingRequiredSections(
+				state.outcomes,
+				state.outcomeFragments,
+			),
+		},
+		fragments: {
+			total: state.outcomeFragments.length,
+			byStatus: fragmentsByStatus,
+		},
+	};
+}
+
+export function toTeamProgressLifecycleEvent(input: {
+	teamName: string;
+	sessionId: string;
+	event: TeamEvent;
+}): TeamProgressLifecycleEvent {
+	const { event } = input;
+	switch (event.type) {
+		case "team_task_updated":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				taskId: event.task.id,
+				agentId: event.task.assignee ?? event.task.createdBy,
+			};
+		case "run_queued":
+		case "run_started":
+		case "run_completed":
+		case "run_failed":
+		case "run_cancelled":
+		case "run_interrupted":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				runId: event.run.id,
+				taskId: event.run.taskId,
+				agentId: event.run.agentId,
+				message: event.run.error,
+			};
+		case "run_progress":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				runId: event.run.id,
+				taskId: event.run.taskId,
+				agentId: event.run.agentId,
+				message: event.message,
+			};
+		case "outcome_created":
+		case "outcome_finalized":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				outcomeId: event.outcome.id,
+			};
+		case "outcome_fragment_attached":
+		case "outcome_fragment_reviewed":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				outcomeId: event.fragment.outcomeId,
+				fragmentId: event.fragment.id,
+				agentId: event.fragment.sourceAgentId,
+			};
+		case "team_message":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				taskId: event.message.taskId,
+				agentId: event.message.fromAgentId,
+				message: event.message.subject,
+			};
+		case "team_mission_log":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				taskId: event.entry.taskId,
+				agentId: event.entry.agentId,
+				message: event.entry.summary,
+			};
+		case "teammate_spawned":
+		case "teammate_shutdown":
+		case "task_start":
+		case "task_end":
+		case "agent_event":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				agentId: event.agentId,
+			};
+	}
+	return {
+		teamName: input.teamName,
+		sessionId: input.sessionId,
+		eventType: (event as TeamEvent).type,
+		ts: toIsoNow(),
+	};
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/runtime.ts b/sdk/packages/core/src/extensions/tools/team/runtime.ts
new file mode 100644
index 0000000..edcfcf8
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/runtime.ts
@@ -0,0 +1,54 @@
+export {
+	buildDelegatedAgentConfig,
+	createDelegatedAgent,
+	createDelegatedAgentConfigProvider,
+	type DelegatedAgentConfigProvider,
+	type DelegatedAgentConnectionConfig,
+	type DelegatedAgentKind,
+	type DelegatedAgentRuntimeConfig,
+} from "./delegated-agent";
+
+// =============================================================================
+// Spawn Agent Tool
+// =============================================================================
+
+export {
+	createSpawnAgentTool,
+	type SpawnAgentInput,
+	type SpawnAgentOutput,
+	type SpawnAgentToolConfig,
+	type SubAgentEndContext,
+	type SubAgentStartContext,
+} from "./spawn-agent-tool";
+
+// =============================================================================
+// Multi-Agent
+// =============================================================================
+
+export {
+	type AgentTask,
+	AgentTeam,
+	AgentTeamsRuntime,
+	type AgentTeamsRuntimeOptions,
+	createAgentTeam,
+	createWorkerReviewerTeam,
+	type SpawnTeammateOptions,
+	type TaskResult,
+	type TeamEvent,
+	type TeamMemberConfig,
+} from "./multi-agent";
+
+// =============================================================================
+// Team Tools
+// =============================================================================
+
+export {
+	type BootstrapAgentTeamsOptions,
+	type BootstrapAgentTeamsResult,
+	bootstrapAgentTeams,
+	type CreateAgentTeamsToolsOptions,
+	createAgentTeamsTools,
+	reviveTeamStateDates,
+	sanitizeTeamName,
+	type TeamTeammateRuntimeConfig,
+} from "./team-tools";
diff --git a/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.test.ts b/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.test.ts
new file mode 100644
index 0000000..15887b5
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.test.ts
@@ -0,0 +1,378 @@
+import type { AgentConfig } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createDelegatedAgentConfigProvider } from "./delegated-agent";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+
+const runMock = vi.fn();
+const getAgentIdMock = vi.fn(() => "sub-agent-1");
+const getConversationIdMock = vi.fn(() => "conv-sub-1");
+const agentConstructorSpy = vi.fn();
+
+vi.mock("../../../runtime/orchestration/session-runtime-orchestrator", () => {
+	return {
+		SessionRuntime: class MockSessionRuntime {
+			constructor(config: unknown) {
+				agentConstructorSpy(config);
+			}
+
+			getAgentId(): string {
+				return getAgentIdMock();
+			}
+
+			getConversationId(): string {
+				return getConversationIdMock();
+			}
+
+			subscribeEvents(): () => void {
+				return () => {};
+			}
+
+			async run(input: string): Promise<unknown> {
+				return runMock(input);
+			}
+		},
+	};
+});
+
+describe("createSpawnAgentTool", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("creates a sub-agent, forwards callbacks, and returns normalized output", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "sub-agent result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: { inputTokens: 11, outputTokens: 7 },
+		});
+
+		const onSubAgentStart = vi.fn();
+		const onSubAgentEnd = vi.fn();
+		const createSubAgentTools = vi.fn().mockResolvedValue([]);
+		const extensions = [
+			{
+				name: "sample-ext",
+				manifest: { capabilities: ["hooks"] },
+				hooks: { onEvent: vi.fn() },
+			} as AgentExtension,
+		];
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+				extensions,
+			}),
+			defaultMaxIterations: 4,
+			createSubAgentTools,
+			onSubAgentStart,
+			onSubAgentEnd,
+		});
+
+		const output = await tool.execute(
+			{
+				systemPrompt: "You are focused",
+				task: "Do delegated work",
+			},
+			{
+				agentId: "parent-1",
+				conversationId: "conv-parent",
+				iteration: 3,
+			},
+		);
+
+		expect(createSubAgentTools).toHaveBeenCalledTimes(1);
+		expect(runMock).toHaveBeenCalledWith("Do delegated work");
+		expect(onSubAgentStart).toHaveBeenCalledTimes(1);
+		expect(onSubAgentEnd).toHaveBeenCalledTimes(1);
+		expect(output).toEqual({
+			text: "sub-agent result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: {
+				inputTokens: 11,
+				outputTokens: 7,
+			},
+		});
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				parentAgentId: "parent-1",
+				maxIterations: 4,
+				extensions,
+			}),
+		);
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.not.objectContaining({
+				prepareTurn: expect.anything(),
+			}),
+		);
+	});
+
+	it("passes extension hooks through delegated config", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "sub-agent result",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const extensions = [
+			{
+				name: "before-start-ext",
+				manifest: {
+					capabilities: ["hooks"],
+				},
+				hooks: { beforeModel: vi.fn() },
+			} as AgentExtension,
+		];
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+				extensions,
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "You are focused",
+				task: "Do delegated work",
+			},
+			{
+				agentId: "parent-1",
+				conversationId: "conv-parent",
+				iteration: 3,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				extensions,
+			}),
+		);
+	});
+
+	it("propagates sub-agent errors and still reports onSubAgentEnd", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockRejectedValue(new Error("sub-agent failed"));
+		const onSubAgentEnd = vi.fn();
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+			}),
+			subAgentTools: [],
+			onSubAgentEnd,
+		});
+
+		await expect(
+			tool.execute(
+				{
+					systemPrompt: "System",
+					task: "Fail task",
+				},
+				{
+					agentId: "parent-2",
+					conversationId: "conv-parent",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow("sub-agent failed");
+
+		expect(onSubAgentEnd).toHaveBeenCalledTimes(1);
+		expect(onSubAgentEnd).toHaveBeenCalledWith(
+			expect.objectContaining({
+				parentAgentId: "parent-2",
+				error: expect.any(Error),
+			}),
+		);
+	});
+
+	it("leaves maxIterations unset when neither input nor default is provided", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "sub-agent result",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "System",
+				task: "Do task",
+			},
+			{
+				agentId: "parent-3",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				maxIterations: undefined,
+			}),
+		);
+	});
+
+	it("appends workspace metadata for cline sub-agents when missing", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "ok",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const workspaceMetadata = `# Workspace Configuration
+{
+  "workspaces": {
+    "/repo/demo": {
+      "hint": "demo"
+    }
+  }
+}`;
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				cwd: "/repo/demo",
+				workspaceMetadata,
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "You are a specialist teammate.",
+				task: "Investigate module boundaries",
+			},
+			{
+				agentId: "parent-4",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				systemPrompt: expect.stringContaining(workspaceMetadata),
+			}),
+		);
+	});
+
+	it("does not duplicate workspace metadata for cline sub-agents", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "ok",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const inputSystemPrompt = `You are a specialist teammate.
+
+# Workspace Configuration
+{
+  "workspaces": {
+    "/repo/demo": {
+      "hint": "demo"
+    }
+  }
+}`;
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				cwd: "/repo/demo",
+				workspaceMetadata: "# Workspace Configuration\n{}",
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: inputSystemPrompt,
+				task: "Investigate module boundaries",
+			},
+			{
+				agentId: "parent-5",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				systemPrompt: inputSystemPrompt,
+			}),
+		);
+	});
+
+	it("resolves connection settings lazily at execution time", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "ok",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const configProvider = createDelegatedAgentConfigProvider({
+			providerId: "cline",
+			modelId: "stale-model",
+			apiKey: "oauth-access-old",
+		});
+		const updateConnectionDefaults = vi.spyOn(
+			configProvider,
+			"updateConnectionDefaults",
+		);
+		configProvider.updateConnectionDefaults({
+			apiKey: "oauth-access-new",
+			modelId: "updated-model",
+		});
+
+		const tool = createSpawnAgentTool({
+			configProvider,
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "System",
+				task: "Do task",
+			},
+			{
+				agentId: "parent-6",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(updateConnectionDefaults).toHaveBeenCalledTimes(1);
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "oauth-access-new",
+				modelId: "updated-model",
+			}),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.ts b/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.ts
new file mode 100644
index 0000000..7bdad60
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.ts
@@ -0,0 +1,203 @@
+/**
+ * Reusable spawn_agent tool for delegating tasks to sub-agents.
+ */
+
+import {
+	type AgentConfig,
+	type AgentEvent,
+	type AgentHooks,
+	type AgentResult,
+	type AgentTool,
+	type AgentToolContext,
+	type BasicLogger,
+	createTool,
+	type HookErrorMode,
+	type ITelemetryService,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+	type ToolPolicy,
+	zodToJsonSchema,
+} from "@cline/shared";
+import { z } from "zod";
+import {
+	createDelegatedAgent,
+	type DelegatedAgentConfigProvider,
+} from "./delegated-agent";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentFinishReason = AgentResult["finishReason"];
+
+export const SpawnAgentInputSchema = z.object({
+	systemPrompt: z
+		.string()
+		.describe("System prompt defining the sub-agent's behavior"),
+	task: z.string().describe("Task for the sub-agent to complete"),
+});
+
+export type SpawnAgentInput = z.infer<typeof SpawnAgentInputSchema>;
+
+export interface SpawnAgentOutput {
+	text: string;
+	iterations: number;
+	finishReason: AgentFinishReason;
+	usage: {
+		inputTokens: number;
+		outputTokens: number;
+	};
+}
+
+export interface SubAgentStartContext {
+	subAgentId: string;
+	conversationId: string;
+	parentAgentId: string;
+	input: SpawnAgentInput;
+}
+
+export interface SubAgentEndContext {
+	subAgentId: string;
+	conversationId: string;
+	parentAgentId: string;
+	input: SpawnAgentInput;
+	result?: SpawnAgentOutput;
+	agentResult?: AgentResult;
+	error?: Error;
+}
+
+export interface SpawnAgentToolConfig {
+	configProvider: DelegatedAgentConfigProvider;
+	defaultMaxIterations?: number;
+	subAgentTools?: AgentTool[];
+	createSubAgentTools?: (
+		input: SpawnAgentInput,
+		context: AgentToolContext,
+	) => AgentTool[] | Promise<AgentTool[]>;
+	onSubAgentEvent?: (event: AgentEvent) => void;
+	/**
+	 * Lifecycle hooks forwarded to spawned sub-agent runs.
+	 */
+	hooks?: AgentHooks;
+	/**
+	 * Extension list forwarded to spawned sub-agent runs.
+	 */
+	extensions?: AgentExtension[];
+	/**
+	 * Error handling mode for forwarded lifecycle hooks.
+	 */
+	hookErrorMode?: HookErrorMode;
+	/**
+	 * Called after a sub-agent instance is created and before it starts running.
+	 * Errors are ignored so lifecycle observers cannot break task execution.
+	 */
+	onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+	/**
+	 * Called once a sub-agent run finishes (success or error).
+	 * Errors are ignored so lifecycle observers cannot break task execution.
+	 */
+	onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+	/**
+	 * Optional per-tool policy for spawned sub-agents.
+	 */
+	toolPolicies?: Record<string, ToolPolicy>;
+	/**
+	 * Optional approval callback for spawned sub-agent tool calls.
+	 */
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+	/**
+	 * Optional logger forwarded to spawned sub-agent runs.
+	 */
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}
+
+/**
+ * Create a spawn_agent tool that can run a delegated task with a focused sub-agent.
+ */
+export function createSpawnAgentTool(
+	config: SpawnAgentToolConfig,
+): AgentTool<SpawnAgentInput, SpawnAgentOutput> {
+	return createTool<SpawnAgentInput, SpawnAgentOutput>({
+		name: "spawn_agent",
+		description: `Spawn a sub-agent with a custom system prompt for specialized tasks. Use when delegating work that benefits from focused expertise.`,
+		inputSchema: zodToJsonSchema(SpawnAgentInputSchema),
+		execute: async (input, context) => {
+			const tools = config.createSubAgentTools
+				? await config.createSubAgentTools(input, context)
+				: (config.subAgentTools ?? []);
+
+			const subAgent = createDelegatedAgent({
+				kind: "subagent",
+				prompt: input.systemPrompt,
+				configProvider: config.configProvider,
+				tools,
+				maxIterations: config.defaultMaxIterations,
+				parentAgentId: context.agentId,
+				abortSignal: context.signal,
+				onEvent: config.onSubAgentEvent,
+				hookErrorMode: config.hookErrorMode,
+				toolPolicies: config.toolPolicies,
+				requestToolApproval: config.requestToolApproval,
+			});
+			const subAgentId = subAgent.getAgentId();
+			const conversationId = subAgent.getConversationId();
+			const parentAgentId = context.agentId;
+			if (config.onSubAgentStart) {
+				try {
+					await config.onSubAgentStart({
+						subAgentId,
+						conversationId,
+						parentAgentId,
+						input,
+					});
+				} catch {
+					// Best-effort observer callback.
+				}
+			}
+			try {
+				const result = await subAgent.run(input.task);
+				const output: SpawnAgentOutput = {
+					text: result.text,
+					iterations: result.iterations,
+					finishReason: result.finishReason,
+					usage: {
+						inputTokens: result.usage.inputTokens,
+						outputTokens: result.usage.outputTokens,
+					},
+				};
+				if (config.onSubAgentEnd) {
+					try {
+						await config.onSubAgentEnd({
+							subAgentId,
+							conversationId,
+							parentAgentId,
+							input,
+							result: output,
+							agentResult: result,
+						});
+					} catch {
+						// Best-effort observer callback.
+					}
+				}
+				return output;
+			} catch (error) {
+				if (config.onSubAgentEnd) {
+					try {
+						await config.onSubAgentEnd({
+							subAgentId,
+							conversationId,
+							parentAgentId,
+							input,
+							error: error instanceof Error ? error : new Error(String(error)),
+						});
+					} catch {
+						// Best-effort observer callback.
+					}
+				}
+				throw error;
+			}
+		},
+		timeoutMs: 300000,
+		retryable: false,
+	});
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/subagent-prompts.ts b/sdk/packages/core/src/extensions/tools/team/subagent-prompts.ts
new file mode 100644
index 0000000..684d747
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/subagent-prompts.ts
@@ -0,0 +1,41 @@
+import { buildClineSystemPrompt } from "@cline/shared";
+import type { DelegatedAgentRuntimeConfig } from "./delegated-agent";
+
+export function buildTeammateSystemPrompt(
+	prompt: string,
+	config: DelegatedAgentRuntimeConfig,
+): string {
+	const trimmedPrompt = prompt.trim();
+	if (config.providerId.toLowerCase() !== "cline") {
+		return trimmedPrompt;
+	}
+
+	return buildClineSystemPrompt({
+		ide: config.clineIdeName?.trim() || "Terminal",
+		workspaceRoot: config.cwd?.trim() || "/",
+		providerId: config.providerId,
+		rules: `# Team Teammate Role\n${trimmedPrompt}`,
+		platform: config.clinePlatform,
+		metadata: config.workspaceMetadata,
+	});
+}
+
+export function buildSubAgentSystemPrompt(
+	// The prompt provided when spawning the subagent
+	prompt: string,
+	config: DelegatedAgentRuntimeConfig,
+): string {
+	const trimmedPrompt = prompt.trim();
+	if (config.providerId.toLowerCase() !== "cline") {
+		return trimmedPrompt;
+	}
+
+	return buildClineSystemPrompt({
+		ide: config.clineIdeName || "Terminal",
+		workspaceRoot: config.cwd?.trim() || "/",
+		providerId: config.providerId,
+		overridePrompt: trimmedPrompt,
+		metadata: config.workspaceMetadata,
+		platform: config.clinePlatform,
+	});
+}
diff --git a/sdk/packages/core/src/extensions/tools/team/team-tools.test.ts b/sdk/packages/core/src/extensions/tools/team/team-tools.test.ts
new file mode 100644
index 0000000..91a3f81
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/team-tools.test.ts
@@ -0,0 +1,991 @@
+import { join } from "node:path";
+import { resolveTeamDataDir } from "@cline/shared/storage";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDelegatedAgentConfigProvider } from "./delegated-agent";
+import { AgentTeamsRuntime } from "./multi-agent";
+import { createAgentTeamsTools } from "./team-tools";
+
+type EnvSnapshot = {
+	CLINE_DATA_DIR: string | undefined;
+	CLINE_TEAM_DATA_DIR: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+		CLINE_TEAM_DATA_DIR: process.env.CLINE_TEAM_DATA_DIR,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.CLINE_DATA_DIR = snapshot.CLINE_DATA_DIR;
+	process.env.CLINE_TEAM_DATA_DIR = snapshot.CLINE_TEAM_DATA_DIR;
+}
+
+function makeTeammateConfigProvider(
+	overrides?: Partial<Parameters<typeof createDelegatedAgentConfigProvider>[0]>,
+) {
+	return createDelegatedAgentConfigProvider({
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-5-20250929",
+		...overrides,
+	});
+}
+
+describe("resolveTeamDataDir", () => {
+	let snapshot: EnvSnapshot = captureEnv();
+
+	afterEach(() => {
+		restoreEnv(snapshot);
+	});
+
+	it("uses CLINE_TEAM_DATA_DIR when set", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_TEAM_DATA_DIR = "/tmp/team-dir";
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+		expect(resolveTeamDataDir()).toBe("/tmp/team-dir");
+	});
+
+	it("falls back to CLINE_DATA_DIR/teams", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_TEAM_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+		expect(resolveTeamDataDir()).toBe(join("/tmp/cline-data", "teams"));
+	});
+});
+
+describe("createAgentTeamsTools schema surface", () => {
+	it("exposes a compact task action tool plus strict schemas elsewhere", () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+
+		const spawn = tools.find((tool) => tool.name === "team_spawn_teammate");
+		const teamTask = tools.find((tool) => tool.name === "team_task");
+		const send = tools.find((tool) => tool.name === "team_send_message");
+		const createOutcome = tools.find(
+			(tool) => tool.name === "team_create_outcome",
+		);
+		const teamAwaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		const teamLogUpdate = tools.find(
+			(tool) => tool.name === "team_mission_log",
+		);
+
+		expect(spawn?.inputSchema.type).toBe("object");
+		const teamTaskSchema = teamTask?.inputSchema as
+			| {
+					type?: string;
+					properties?: Record<string, unknown>;
+					required?: unknown[];
+			  }
+			| undefined;
+		expect(teamTaskSchema?.type).toBe("object");
+		expect(teamTaskSchema?.properties).toHaveProperty("action");
+		expect(teamTaskSchema?.required).toEqual(["action"]);
+		expect(send?.inputSchema.type).toBe("object");
+		expect(createOutcome?.inputSchema.type).toBe("object");
+		expect(teamAwaitRuns?.inputSchema.type).toBe("object");
+		const schema = teamLogUpdate?.inputSchema as
+			| { properties: Record<string, unknown>; required: unknown[] }
+			| undefined;
+		expect(schema?.properties.kind).toEqual({
+			type: "string",
+			enum: ["progress", "handoff", "blocked", "decision", "done", "error"],
+		});
+		expect(schema?.required).toEqual(["kind", "summary"]);
+	});
+
+	it("rejects extra fields for strict spawn schema", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const spawn = tools.find((tool) => tool.name === "team_spawn_teammate");
+		expect(spawn).toBeDefined();
+
+		await expect(
+			spawn?.execute(
+				{
+					agentId: "python-poet",
+					rolePrompt: "Write concise Python-focused haiku",
+					action: "spawn",
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow("Unrecognized key");
+	});
+
+	it("can expose only the spawn tool until the first teammate is created", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const onLeadToolsUnlocked = vi.fn();
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+			includeSpawnTool: true,
+			includeManagementTools: false,
+			onLeadToolsUnlocked,
+		});
+
+		expect(tools.map((tool) => tool.name)).toEqual(["team_spawn_teammate"]);
+
+		const spawn = tools[0];
+		await expect(
+			spawn?.execute(
+				{
+					agentId: "writer",
+					rolePrompt: "Write concise summaries",
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toEqual({
+			agentId: "writer",
+			status: "spawned",
+		});
+
+		expect(onLeadToolsUnlocked).toHaveBeenCalledTimes(1);
+		const unlockedTools = onLeadToolsUnlocked.mock.calls[0]?.[0] as
+			| Array<{ name: string }>
+			| undefined;
+		expect(unlockedTools?.some((tool) => tool.name === "team_task")).toBe(true);
+		expect(
+			unlockedTools?.some((tool) => tool.name === "team_spawn_teammate"),
+		).toBe(false);
+	});
+
+	it("rejects non-object payloads for task tools", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const teamTask = tools.find((tool) => tool.name === "team_task");
+		expect(teamTask).toBeDefined();
+
+		await expect(
+			teamTask?.execute(["create", "task"], {
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		).rejects.toThrow("expected object");
+	});
+
+	it("normalizes null placeholders for required fields into missing-field errors", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const teamTask = tools.find((tool) => tool.name === "team_task");
+		expect(teamTask).toBeDefined();
+
+		await expect(
+			teamTask?.execute(
+				{
+					action: "complete",
+					taskId: "task_0001",
+					summary: null,
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow('Field "summary" is required when action=complete');
+	});
+
+	it("accepts null placeholders for optional fields", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const teamTask = tools.find((tool) => tool.name === "team_task");
+		expect(teamTask).toBeDefined();
+		if (!teamTask) {
+			throw new Error("Expected team_task tool to be defined");
+		}
+
+		await expect(
+			teamTask.execute(
+				{
+					action: "create",
+					title: "Investigate llms boundaries",
+					description: "Deep dive models and providers",
+					dependsOn: null,
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toMatchObject({
+			action: "create",
+			status: "pending",
+			taskId: expect.stringMatching(/^task_/),
+		});
+	});
+
+	it("ignores non-create fields for action=create and reports them back", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const teamTask = tools.find((tool) => tool.name === "team_task");
+		expect(teamTask).toBeDefined();
+		if (!teamTask) {
+			throw new Error("Expected team_task tool to be defined");
+		}
+
+		await expect(
+			teamTask.execute(
+				{
+					action: "create",
+					title: "Draft TypeScript haiku",
+					description: "Write a concise haiku",
+					status: "pending",
+					summary: "not used",
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toMatchObject({
+			action: "create",
+			status: "pending",
+			taskId: expect.stringMatching(/^task_/),
+			ignoredFields: ["status", "summary"],
+			note: "Ignored fields for action=create: status, summary",
+		});
+	});
+
+	it("defaults requiredSections for team_create_outcome", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const createOutcome = tools.find(
+			(tool) => tool.name === "team_create_outcome",
+		);
+		expect(createOutcome).toBeDefined();
+
+		await expect(
+			createOutcome?.execute(
+				{
+					title: "LLMS boundary redesign",
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toMatchObject({
+			outcomeId: expect.stringMatching(/^out_/),
+			status: "draft",
+		});
+
+		const outcomes = runtime.listOutcomes();
+		expect(outcomes).toHaveLength(1);
+		expect(outcomes[0]?.requiredSections).toEqual([
+			"current_state",
+			"boundary_analysis",
+			"interface_proposal",
+		]);
+	});
+
+	it("can list outcomes via dedicated list tool", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const createOutcome = tools.find(
+			(tool) => tool.name === "team_create_outcome",
+		);
+		const listOutcomes = tools.find(
+			(tool) => tool.name === "team_list_outcomes",
+		);
+		expect(createOutcome).toBeDefined();
+		expect(listOutcomes).toBeDefined();
+
+		await createOutcome?.execute(
+			{ title: "LLMS redesign" },
+			{
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		await expect(
+			listOutcomes?.execute(
+				{},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					title: expect.any(String),
+					createdAt: expect.any(String),
+				}),
+			]),
+		);
+	});
+
+	it("serializes mailbox timestamps through team_read_mailbox", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		runtime.sendMessage("lead", "lead", "Status", "Please review");
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const readMailbox = tools.find((tool) => tool.name === "team_read_mailbox");
+
+		await expect(
+			readMailbox?.execute(
+				{ unreadOnly: true },
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toEqual([
+			expect.objectContaining({
+				subject: "Status",
+				sentAt: expect.any(String),
+				readAt: expect.any(String),
+			}),
+		]);
+	});
+
+	it("accepts null sourceRunId for team_attach_outcome_fragment", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const createOutcome = tools.find(
+			(tool) => tool.name === "team_create_outcome",
+		);
+		const attachFragment = tools.find(
+			(tool) => tool.name === "team_attach_outcome_fragment",
+		);
+		expect(createOutcome).toBeDefined();
+		expect(attachFragment).toBeDefined();
+		if (!createOutcome || !attachFragment) {
+			throw new Error("Expected outcome tools to be defined");
+		}
+
+		const createdResult = await createOutcome.execute(
+			{ title: "Providers report" },
+			{
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(createdResult).toMatchObject({
+			outcomeId: expect.stringMatching(/^out_/),
+			status: "draft",
+		});
+		const isCreatedOutcome = (
+			value: unknown,
+		): value is { outcomeId: string; status: string } => {
+			if (typeof value !== "object" || value === null) {
+				return false;
+			}
+			const record = value as Record<string, unknown>;
+			return (
+				typeof record.outcomeId === "string" &&
+				typeof record.status === "string"
+			);
+		};
+		if (!isCreatedOutcome(createdResult)) {
+			throw new Error(
+				"Expected createOutcome result to include outcomeId and status",
+			);
+		}
+		const created = createdResult;
+
+		await expect(
+			attachFragment.execute(
+				{
+					outcomeId: created.outcomeId,
+					section: "current_state",
+					sourceRunId: null,
+					content: "Current findings.",
+				},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toMatchObject({
+			fragmentId: expect.stringMatching(/^frag_/),
+			status: "draft",
+		});
+
+		const [fragment] = runtime.listOutcomeFragments(created.outcomeId);
+		expect(fragment?.sourceRunId).toBeUndefined();
+	});
+});
+
+describe("createAgentTeamsTools runtime behavior", () => {
+	it("forwards teammateRuntime headers when spawning teammates", async () => {
+		const spawnTeammate = vi.fn();
+		const runtime = {
+			getMemberRole: vi.fn(() => "lead"),
+			isTeammateActive: vi.fn(() => false),
+			spawnTeammate,
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider({
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				headers: { Authorization: "Bearer token" },
+			}),
+			createBaseTools: () => [],
+			includeManagementTools: false,
+		});
+		const spawnTool = tools.find((tool) => tool.name === "team_spawn_teammate");
+		expect(spawnTool).toBeDefined();
+
+		await spawnTool?.execute(
+			{
+				agentId: "investigator",
+				rolePrompt: "Investigate code boundaries",
+			},
+			{
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(spawnTeammate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					headers: { Authorization: "Bearer token" },
+				}),
+			}),
+		);
+	});
+
+	it("injects workspace metadata into cline teammate system prompt", async () => {
+		const spawnTeammate = vi.fn();
+		const runtime = {
+			getMemberRole: vi.fn(() => "lead"),
+			isTeammateActive: vi.fn(() => false),
+			spawnTeammate,
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider({
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				cwd: "/repo/app",
+			}),
+		});
+		const spawnTool = tools.find((tool) => tool.name === "team_spawn_teammate");
+		expect(spawnTool).toBeDefined();
+
+		await spawnTool?.execute(
+			{
+				agentId: "researcher",
+				rolePrompt: "Investigate runtime boundary regressions.",
+			},
+			{
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(spawnTeammate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					systemPrompt: expect.stringContaining("# Workspace Configuration"),
+				}),
+			}),
+		);
+		expect(spawnTeammate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					systemPrompt: expect.stringContaining('"/repo/app"'),
+				}),
+			}),
+		);
+		expect(spawnTeammate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					systemPrompt: expect.stringContaining('"hint": "app"'),
+				}),
+			}),
+		);
+		expect(spawnTeammate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					systemPrompt: expect.stringContaining(
+						"# Team Teammate Role\nInvestigate runtime boundary regressions.",
+					),
+				}),
+			}),
+		);
+	});
+
+	it("throws from team_await_runs when a requested async delegated run fails", async () => {
+		const runtime = {
+			awaitRun: vi.fn(async () => ({
+				id: "run_0001",
+				status: "failed",
+				error: "Authentication failed",
+			})),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		expect(awaitRuns).toBeDefined();
+
+		await expect(
+			awaitRuns?.execute(
+				{ runId: "run_0001" },
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow('Run "run_0001" failed: Authentication failed');
+	});
+
+	it("throws from team_await_runs when any delegated run is not successful in all-runs mode", async () => {
+		const runtime = {
+			awaitAllRuns: vi.fn(async () => [
+				{ id: "run_ok", status: "completed" },
+				{ id: "run_bad", status: "failed", error: "Auth expired" },
+			]),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		expect(awaitRuns).toBeDefined();
+
+		await expect(
+			awaitRuns?.execute(
+				{},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow(
+			"One or more runs did not complete successfully: run_bad:failed(Auth expired)",
+		);
+	});
+
+	it("returns compact summaries from team_await_runs without full teammate transcripts", async () => {
+		const runtime = {
+			awaitRun: vi.fn(async () => ({
+				id: "run_0001",
+				agentId: "models-investigator",
+				status: "completed",
+				message:
+					"Investigate the models directory and summarize the boundaries",
+				priority: 0,
+				retryCount: 0,
+				maxRetries: 0,
+				startedAt: new Date("2026-03-24T09:00:00.000Z"),
+				endedAt: new Date("2026-03-24T09:01:00.000Z"),
+				lastProgressAt: new Date("2026-03-24T09:00:59.000Z"),
+				lastProgressMessage: "completed",
+				currentActivity: "completed",
+				result: {
+					text: "Models are the public catalog and provider files are provider-specific defaults.",
+					usage: {
+						inputTokens: 1200,
+						outputTokens: 300,
+						cacheReadTokens: 900,
+						cacheWriteTokens: 120,
+						totalCost: 0.12,
+					},
+					messages: [{ role: "user", content: "huge transcript omitted" }],
+					toolCalls: [{ name: "read_file", input: {}, output: "omitted" }],
+					iterations: 3,
+					finishReason: "completed",
+					model: { id: "claude-sonnet-4-5-20250929", provider: "anthropic" },
+					startedAt: new Date("2026-03-24T09:00:00.000Z"),
+					endedAt: new Date("2026-03-24T09:01:00.000Z"),
+					durationMs: 60_000,
+				},
+			})),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+
+		await expect(
+			awaitRuns?.execute(
+				{ runId: "run_0001" },
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toEqual({
+			id: "run_0001",
+			agentId: "models-investigator",
+			status: "completed",
+			messagePreview:
+				"Investigate the models directory and summarize the boundaries",
+			priority: 0,
+			retryCount: 0,
+			maxRetries: 0,
+			startedAt: "2026-03-24T09:00:00.000Z",
+			endedAt: "2026-03-24T09:01:00.000Z",
+			lastProgressAt: "2026-03-24T09:00:59.000Z",
+			lastProgressMessage: "completed",
+			currentActivity: "completed",
+			resultSummary: {
+				textPreview:
+					"Models are the public catalog and provider files are provider-specific defaults.",
+				iterations: 3,
+				finishReason: "completed",
+				durationMs: 60_000,
+				usage: {
+					inputTokens: 1200,
+					outputTokens: 300,
+					cacheReadTokens: 900,
+					cacheWriteTokens: 120,
+					totalCost: 0.12,
+				},
+			},
+		});
+	});
+
+	it("returns compact summaries from team_list_runs", async () => {
+		const runtime = {
+			listRuns: vi.fn(() => [
+				{
+					id: "run_0001",
+					agentId: "providers-investigator",
+					status: "running",
+					message: "Investigate providers directory in detail",
+					priority: 0,
+					retryCount: 0,
+					maxRetries: 0,
+					startedAt: new Date("2026-03-24T09:00:00.000Z"),
+					lastProgressAt: new Date("2026-03-24T09:00:30.000Z"),
+					lastProgressMessage: "reading files",
+					currentActivity: "reading_files",
+				},
+			]),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const listRuns = tools.find((tool) => tool.name === "team_list_runs");
+
+		await expect(
+			listRuns?.execute(
+				{},
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toEqual([
+			{
+				id: "run_0001",
+				agentId: "providers-investigator",
+				status: "running",
+				messagePreview: "Investigate providers directory in detail",
+				priority: 0,
+				retryCount: 0,
+				maxRetries: 0,
+				startedAt: "2026-03-24T09:00:00.000Z",
+				lastProgressAt: "2026-03-24T09:00:30.000Z",
+				lastProgressMessage: "reading files",
+				currentActivity: "reading_files",
+				resultSummary: undefined,
+			},
+		]);
+	});
+
+	it("sets long timeout for team await tool", () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		expect(awaitRuns?.timeoutMs).toBe(60 * 60 * 1000);
+	});
+
+	it("collapses concurrent sync team_run_task calls to the same agent", async () => {
+		let resolveRoute!: (value: { text: string; iterations: number }) => void;
+		const routePromise = new Promise<{ text: string; iterations: number }>(
+			(resolve) => {
+				resolveRoute = resolve;
+			},
+		);
+		const routeToTeammate = vi.fn(() => routePromise);
+		const runtime = {
+			routeToTeammate,
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+		const input = {
+			agentId: "educator",
+			task: "Explain probability",
+			runMode: "sync",
+		};
+
+		// Fire two concurrent sync calls to the same agent
+		const call1 = runTask.execute(input, ctx);
+		const call2 = runTask.execute(input, ctx);
+
+		// Only one routeToTeammate call should be made.
+		expect(routeToTeammate).toHaveBeenCalledTimes(1);
+
+		// Both callers should receive the same result from the shared in-flight run.
+		resolveRoute({ text: "Probability explained", iterations: 3 });
+		const result1 = (await call1) as { text?: string; iterations?: number };
+		const result2 = (await call2) as {
+			text?: string;
+			iterations?: number;
+			status?: string;
+			deduped?: boolean;
+			message?: string;
+		};
+		expect(result1.text).toBe("Probability explained");
+		expect(result1.iterations).toBe(3);
+		expect(result2.text).toBe("Probability explained");
+		expect(result2.iterations).toBe(3);
+		expect(result2.status).toBe("joined");
+		expect(result2.deduped).toBe(true);
+		expect(result2.message).toContain("already dispatched");
+	});
+
+	it("returns explicit dispatch state for async team_run_task calls", async () => {
+		const runtime = {
+			startTeammateRun: vi.fn(() => ({ id: "run_00001" })),
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+		const result = (await runTask.execute(
+			{ agentId: "educator", task: "Explain probability", runMode: "async" },
+			ctx,
+		)) as {
+			runId?: string;
+			status?: string;
+			dispatched?: boolean;
+			message?: string;
+		};
+
+		expect(result.runId).toBe("run_00001");
+		expect(result.status).toBe("queued");
+		expect(result.dispatched).toBe(true);
+		expect(result.message).toContain("queued as run_00001");
+	});
+
+	it("allows concurrent sync team_run_task calls to different agents", async () => {
+		let resolveRoute1!: (value: { text: string; iterations: number }) => void;
+		let resolveRoute2!: (value: { text: string; iterations: number }) => void;
+		const routeToTeammate = vi.fn((agentId: string) => {
+			if (agentId === "educator") {
+				return new Promise<{ text: string; iterations: number }>((resolve) => {
+					resolveRoute1 = resolve;
+				});
+			}
+			return new Promise<{ text: string; iterations: number }>((resolve) => {
+				resolveRoute2 = resolve;
+			});
+		});
+		const runtime = {
+			routeToTeammate,
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+
+		// Fire sync calls to two different agents - both should proceed
+		const call1 = runTask.execute(
+			{ agentId: "educator", task: "Explain probability", runMode: "sync" },
+			ctx,
+		);
+		const call2 = runTask.execute(
+			{ agentId: "assessor", task: "Evaluate answer", runMode: "sync" },
+			ctx,
+		);
+
+		// Both should have called routeToTeammate
+		expect(routeToTeammate).toHaveBeenCalledTimes(2);
+
+		// Resolve both
+		resolveRoute1({ text: "Explained", iterations: 2 });
+		resolveRoute2({ text: "Evaluated", iterations: 1 });
+
+		const result1 = (await call1) as { text?: string };
+		const result2 = (await call2) as { text?: string };
+		expect(result1.text).toBe("Explained");
+		expect(result2.text).toBe("Evaluated");
+	});
+
+	it("lists team tasks through team_task list action", async () => {
+		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const teamTask = tools.find((tool) => tool.name === "team_task");
+		expect(teamTask).toBeDefined();
+
+		const first = (await teamTask?.execute(
+			{
+				action: "create",
+				title: "Ready task",
+				description: "Claim immediately",
+			},
+			{
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		)) as { taskId: string };
+		await teamTask?.execute(
+			{
+				action: "create",
+				title: "Blocked task",
+				description: "Wait on dependency",
+				dependsOn: [first.taskId],
+			},
+			{
+				agentId: "lead",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		await expect(
+			teamTask?.execute(
+				{ action: "list" },
+				{
+					agentId: "lead",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			),
+		).resolves.toEqual({
+			action: "list",
+			tasks: [
+				expect.objectContaining({
+					id: first.taskId,
+					createdAt: expect.any(String),
+					updatedAt: expect.any(String),
+					isReady: true,
+					blockedBy: [],
+				}),
+				expect.objectContaining({
+					title: "Blocked task",
+					isReady: false,
+					blockedBy: [first.taskId],
+				}),
+			],
+		});
+	});
+});
diff --git a/sdk/packages/core/src/extensions/tools/team/team-tools.ts b/sdk/packages/core/src/extensions/tools/team/team-tools.ts
new file mode 100644
index 0000000..0a98771
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/team/team-tools.ts
@@ -0,0 +1,912 @@
+import type { AgentResult } from "@cline/shared";
+import {
+	type AgentTool,
+	createTool,
+	TEAM_AWAIT_TIMEOUT_MS,
+	TEAM_RUN_MESSAGE_PREVIEW_LIMIT,
+	TEAM_RUN_TEXT_PREVIEW_LIMIT,
+	TEAM_TASK_IGNORED_FIELDS_BY_ACTION,
+	type TeamAttachOutcomeFragmentInput,
+	TeamAttachOutcomeFragmentInputSchema,
+	type TeamAwaitRunsInput,
+	TeamAwaitRunsInputSchema,
+	type TeamBroadcastInput,
+	TeamBroadcastInputSchema,
+	TeamBroadcastToolResultSchema,
+	type TeamCancelRunInput,
+	TeamCancelRunInputSchema,
+	TeamCancelRunToolResultSchema,
+	type TeamCleanupInput,
+	TeamCleanupInputSchema,
+	TeamCleanupToolResultSchema,
+	type TeamCreateOutcomeInput,
+	TeamCreateOutcomeInputSchema,
+	type TeamCreateOutcomeToolResult,
+	TeamCreateOutcomeToolResultSchema,
+	type TeamFinalizeOutcomeInput,
+	TeamFinalizeOutcomeInputSchema,
+	TeamFinalizeOutcomeToolResultSchema,
+	type TeamListOutcomesInput,
+	TeamListOutcomesInputSchema,
+	type TeamListRunsInput,
+	TeamListRunsInputSchema,
+	type TeamMailboxMessageToolResult,
+	TeamMailboxMessageToolResultSchema,
+	type TeamMissionLogInput,
+	TeamMissionLogInputSchema,
+	TeamMissionLogToolResultSchema,
+	TeamOutcomeFragmentToolResultSchema,
+	type TeamOutcomeToolResult,
+	TeamOutcomeToolResultSchema,
+	type TeamReadMailboxInput,
+	TeamReadMailboxInputSchema,
+	type TeamReviewOutcomeFragmentInput,
+	TeamReviewOutcomeFragmentInputSchema,
+	type TeamRunRecord,
+	type TeamRunResultSummary,
+	type TeamRunTaskInput,
+	TeamRunTaskInputSchema,
+	type TeamRunTaskToolResult,
+	TeamRunTaskToolResultSchema,
+	type TeamRunToolSummary,
+	TeamRunToolSummarySchema,
+	type TeamRuntimeState,
+	type TeamSendMessageInput,
+	TeamSendMessageInputSchema,
+	TeamSendMessageToolResultSchema,
+	type TeamShutdownTeammateInput,
+	TeamShutdownTeammateInputSchema,
+	TeamSimpleAgentStatusToolResultSchema,
+	type TeamSpawnTeammateInput,
+	TeamSpawnTeammateInputSchema,
+	type TeamStatusInput,
+	TeamStatusInputSchema,
+	type TeamStatusToolResult,
+	TeamStatusToolResultSchema,
+	type TeamTaskInput,
+	TeamTaskInputSchema,
+	type TeamTaskToolResult,
+	TeamTaskToolResultSchema,
+	type TeamTeammateSpec,
+	validateWithZod,
+	zodToJsonSchema,
+} from "@cline/shared";
+import {
+	buildDelegatedAgentConfig,
+	type DelegatedAgentConfigProvider,
+	type DelegatedAgentRuntimeConfig,
+} from "./delegated-agent";
+import type { AgentTeamsRuntime } from "./multi-agent";
+
+function truncateText(value: string, maxLength: number): string {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	if (normalized.length <= maxLength) {
+		return normalized;
+	}
+	return `${normalized.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+function requireInputField<T>(value: T | undefined, field: string): T {
+	if (value === undefined) {
+		throw new Error(`Missing required field: ${field}`);
+	}
+	return value;
+}
+
+function summarizeRunResult(
+	run: TeamRunRecord,
+): TeamRunResultSummary | undefined {
+	const result = run.result as AgentResult | undefined;
+	if (!result) {
+		return undefined;
+	}
+	return {
+		textPreview: truncateText(result.text, TEAM_RUN_TEXT_PREVIEW_LIMIT),
+		iterations: result.iterations,
+		finishReason: result.finishReason,
+		durationMs: result.durationMs,
+		usage: {
+			inputTokens: result.usage.inputTokens,
+			outputTokens: result.usage.outputTokens,
+			cacheReadTokens: result.usage.cacheReadTokens,
+			cacheWriteTokens: result.usage.cacheWriteTokens,
+			totalCost: result.usage.totalCost,
+		},
+	};
+}
+
+function dateToIso(value: Date | undefined): string | undefined {
+	return value?.toISOString();
+}
+
+function summarizeRun(run: TeamRunRecord): TeamRunToolSummary {
+	return {
+		id: run.id,
+		agentId: run.agentId,
+		taskId: run.taskId,
+		status: run.status,
+		messagePreview: truncateText(run.message, TEAM_RUN_MESSAGE_PREVIEW_LIMIT),
+		priority: run.priority,
+		retryCount: run.retryCount,
+		maxRetries: run.maxRetries,
+		nextAttemptAt: dateToIso(run.nextAttemptAt),
+		continueConversation: run.continueConversation,
+		startedAt: run.startedAt.toISOString(),
+		endedAt: dateToIso(run.endedAt),
+		leaseOwner: run.leaseOwner,
+		heartbeatAt: dateToIso(run.heartbeatAt),
+		lastProgressAt: dateToIso(run.lastProgressAt),
+		lastProgressMessage: run.lastProgressMessage,
+		currentActivity: run.currentActivity,
+		error: run.error,
+		resultSummary: summarizeRunResult(run),
+	};
+}
+
+function assertAwaitedRunSucceeded(run: TeamRunRecord): void {
+	if (run.status === "failed") {
+		throw new Error(
+			`Run "${run.id}" failed${run.error ? `: ${run.error}` : ""}`,
+		);
+	}
+	if (run.status === "cancelled") {
+		throw new Error(
+			`Run "${run.id}" was cancelled${run.error ? `: ${run.error}` : ""}`,
+		);
+	}
+	if (run.status === "interrupted") {
+		throw new Error(
+			`Run "${run.id}" was interrupted${run.error ? `: ${run.error}` : ""}`,
+		);
+	}
+}
+
+export type TeamTeammateRuntimeConfig = DelegatedAgentRuntimeConfig;
+
+export interface CreateAgentTeamsToolsOptions {
+	runtime: AgentTeamsRuntime;
+	requesterId: string;
+	teammateConfigProvider: DelegatedAgentConfigProvider;
+	createBaseTools?: () => AgentTool[];
+	allowSpawn?: boolean;
+	includeSpawnTool?: boolean;
+	includeManagementTools?: boolean;
+	onLeadToolsUnlocked?: (tools: AgentTool[]) => void;
+}
+
+export interface BootstrapAgentTeamsOptions {
+	runtime: AgentTeamsRuntime;
+	teammateConfigProvider: DelegatedAgentConfigProvider;
+	createBaseTools?: () => AgentTool[];
+	leadAgentId?: string;
+	restoredTeammates?: TeamTeammateSpec[];
+	restoredFromPersistence?: boolean;
+	includeLeadSpawnTool?: boolean;
+	includeLeadManagementTools?: boolean;
+	onLeadToolsUnlocked?: (tools: AgentTool[]) => void;
+}
+
+export interface BootstrapAgentTeamsResult {
+	tools: AgentTool[];
+	restoredFromPersistence: boolean;
+	restoredTeammates: string[];
+}
+
+export const TEAM_TOOL_NAMES = [
+	"team_spawn_teammate",
+	"team_shutdown_teammate",
+	"team_status",
+	"team_task",
+	"team_run_task",
+	"team_cancel_run",
+	"team_list_runs",
+	"team_await_runs",
+	"team_send_message",
+	"team_broadcast",
+	"team_read_mailbox",
+	"team_mission_log",
+	"team_cleanup",
+	"team_create_outcome",
+	"team_attach_outcome_fragment",
+	"team_review_outcome_fragment",
+	"team_finalize_outcome",
+	"team_list_outcomes",
+] as const;
+
+function spawnTeamTeammate(
+	options: Omit<CreateAgentTeamsToolsOptions, "requesterId" | "allowSpawn"> & {
+		requesterId: string;
+		spec: TeamTeammateSpec;
+	},
+): void {
+	const teammateTools: AgentTool[] = [];
+	if (options.createBaseTools) {
+		teammateTools.push(...options.createBaseTools());
+	}
+	teammateTools.push(
+		...createAgentTeamsTools({
+			runtime: options.runtime,
+			requesterId: options.spec.agentId,
+			teammateConfigProvider: options.teammateConfigProvider,
+			createBaseTools: options.createBaseTools,
+			allowSpawn: false,
+		}),
+	);
+	options.runtime.spawnTeammate({
+		agentId: options.spec.agentId,
+		config: buildDelegatedAgentConfig({
+			kind: "teammate",
+			prompt: options.spec.rolePrompt,
+			role: options.spec.rolePrompt,
+			configProvider: options.teammateConfigProvider,
+			tools: teammateTools,
+			maxIterations: options.spec.maxIterations,
+			cwd: options.teammateConfigProvider.getRuntimeConfig().cwd,
+		}),
+	});
+}
+
+export function bootstrapAgentTeams(
+	options: BootstrapAgentTeamsOptions,
+): BootstrapAgentTeamsResult {
+	const leadAgentId = options.leadAgentId ?? "lead";
+	const restoredFromPersistence = options.restoredFromPersistence === true;
+
+	const tools = createAgentTeamsTools({
+		runtime: options.runtime,
+		requesterId: leadAgentId,
+		teammateConfigProvider: options.teammateConfigProvider,
+		createBaseTools: options.createBaseTools,
+		allowSpawn: true,
+		includeSpawnTool: options.includeLeadSpawnTool,
+		includeManagementTools: options.includeLeadManagementTools,
+		onLeadToolsUnlocked: options.onLeadToolsUnlocked,
+	});
+
+	const restoredTeammates: string[] = [];
+	for (const spec of options.restoredTeammates ?? []) {
+		if (options.runtime.isTeammateActive(spec.agentId)) {
+			continue;
+		}
+		spawnTeamTeammate({
+			runtime: options.runtime,
+			requesterId: leadAgentId,
+			teammateConfigProvider: options.teammateConfigProvider,
+			createBaseTools: options.createBaseTools,
+			spec,
+		});
+		restoredTeammates.push(spec.agentId);
+	}
+
+	return {
+		tools,
+		restoredFromPersistence,
+		restoredTeammates,
+	};
+}
+
+export function createAgentTeamsTools(
+	options: CreateAgentTeamsToolsOptions,
+): AgentTool[] {
+	const allowSpawn = options.allowSpawn ?? true;
+	const includeSpawnTool = options.includeSpawnTool ?? true;
+	const includeManagementTools = options.includeManagementTools ?? true;
+	const tools: AgentTool[] = [];
+
+	if (includeSpawnTool) {
+		tools.push(
+			createTool<TeamSpawnTeammateInput, { agentId: string; status: string }>({
+				name: "team_spawn_teammate",
+				description: "Spawn a teammate with a required agentId and rolePrompt.",
+				inputSchema: zodToJsonSchema(TeamSpawnTeammateInputSchema),
+				execute: async (input) => {
+					const validatedInput = validateWithZod(
+						TeamSpawnTeammateInputSchema,
+						input,
+					);
+					if (options.runtime.getMemberRole(options.requesterId) !== "lead") {
+						throw new Error("Only the lead agent can manage teammates.");
+					}
+					if (!allowSpawn) {
+						throw new Error("Spawning teammates is disabled in this context.");
+					}
+					const spec: TeamTeammateSpec = {
+						agentId: validatedInput.agentId,
+						rolePrompt: validatedInput.rolePrompt,
+					};
+					spawnTeamTeammate({
+						runtime: options.runtime,
+						requesterId: options.requesterId,
+						teammateConfigProvider: options.teammateConfigProvider,
+						createBaseTools: options.createBaseTools,
+						spec,
+					});
+					if (!includeManagementTools) {
+						options.onLeadToolsUnlocked?.(
+							createAgentTeamsTools({
+								...options,
+								includeSpawnTool: false,
+								includeManagementTools: true,
+								onLeadToolsUnlocked: undefined,
+							}),
+						);
+					}
+					return validateWithZod(TeamSimpleAgentStatusToolResultSchema, {
+						agentId: validatedInput.agentId,
+						status: "spawned",
+					});
+				},
+			}) as AgentTool,
+		);
+	}
+
+	if (!includeManagementTools) {
+		return tools;
+	}
+
+	tools.push(
+		createTool<TeamShutdownTeammateInput, { agentId: string; status: string }>({
+			name: "team_shutdown_teammate",
+			description: "Shutdown a teammate by agentId.",
+			inputSchema: zodToJsonSchema(TeamShutdownTeammateInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamShutdownTeammateInputSchema,
+					input,
+				);
+				if (options.runtime.getMemberRole(options.requesterId) !== "lead") {
+					throw new Error("Only the lead agent can manage teammates.");
+				}
+				options.runtime.shutdownTeammate(
+					validatedInput.agentId,
+					validatedInput.reason,
+				);
+				return validateWithZod(TeamSimpleAgentStatusToolResultSchema, {
+					agentId: validatedInput.agentId,
+					status: "stopped",
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamStatusInput, TeamStatusToolResult>({
+			name: "team_status",
+			description:
+				"Return a snapshot of team members, task counts, mailbox, and mission log stats.",
+			inputSchema: zodToJsonSchema(TeamStatusInputSchema),
+			execute: async (input) => {
+				validateWithZod(TeamStatusInputSchema, input);
+				return validateWithZod(
+					TeamStatusToolResultSchema,
+					options.runtime.getSnapshot(),
+				);
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamTaskInput, TeamTaskToolResult>({
+			name: "team_task",
+			description:
+				"Manage shared team tasks with action-specific payloads. " +
+				"create requires title and description, with optional dependsOn and assignee. " +
+				"list accepts optional status, assignee. " +
+				"claim requires taskId. complete requires taskId and summary. block requires taskId and reason. " +
+				"Do not include fields from other actions.",
+			inputSchema: zodToJsonSchema(TeamTaskInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(TeamTaskInputSchema, input);
+				switch (validatedInput.action) {
+					case "create": {
+						const ignoredFieldSet = new Set(
+							TEAM_TASK_IGNORED_FIELDS_BY_ACTION.create ?? [],
+						);
+						const ignoredFields = Object.entries(
+							input as Record<string, unknown>,
+						)
+							.filter(
+								([field, value]) => ignoredFieldSet.has(field) && value != null,
+							)
+							.map(([field]) => field);
+						const task = options.runtime.createTask({
+							title: requireInputField(validatedInput.title, "title"),
+							description: requireInputField(
+								validatedInput.description,
+								"description",
+							),
+							dependsOn: validatedInput.dependsOn,
+							assignee: validatedInput.assignee,
+							createdBy: options.requesterId,
+						});
+						return validateWithZod(TeamTaskToolResultSchema, {
+							action: "create",
+							taskId: task.id,
+							status: task.status,
+							...(ignoredFields.length > 0
+								? {
+										ignoredFields,
+										note: `Ignored fields for action=create: ${ignoredFields.join(", ")}`,
+									}
+								: {}),
+						});
+					}
+					case "list":
+						return validateWithZod(TeamTaskToolResultSchema, {
+							action: "list",
+							tasks: options.runtime.listTaskItems({
+								status: validatedInput.status,
+								assignee: validatedInput.assignee,
+							}),
+						});
+					case "claim": {
+						const task = options.runtime.claimTask(
+							requireInputField(validatedInput.taskId, "taskId"),
+							options.requesterId,
+						);
+						return validateWithZod(TeamTaskToolResultSchema, {
+							action: "claim",
+							taskId: task.id,
+							status: task.status,
+							nextStep:
+								"Task is now in_progress. Execute the work using team_run_task or your own tools, then call team_task with action=complete when done.",
+						});
+					}
+					case "complete": {
+						const task = options.runtime.completeTask(
+							requireInputField(validatedInput.taskId, "taskId"),
+							options.requesterId,
+							requireInputField(validatedInput.summary, "summary"),
+						);
+						return validateWithZod(TeamTaskToolResultSchema, {
+							action: "complete",
+							taskId: task.id,
+							status: task.status,
+						});
+					}
+					case "block": {
+						const task = options.runtime.blockTask(
+							requireInputField(validatedInput.taskId, "taskId"),
+							options.requesterId,
+							requireInputField(validatedInput.reason, "reason"),
+						);
+						return validateWithZod(TeamTaskToolResultSchema, {
+							action: "block",
+							taskId: task.id,
+							status: task.status,
+						});
+					}
+				}
+			},
+		}) as AgentTool,
+	);
+
+	// Track in-flight sync runs per agent for dedup
+	// (Claude sometimes emits duplicate tool_use blocks in a single response;
+	//  duplicate sync calls should await the first dispatched run)
+	const pendingSyncRuns = new Map<string, Promise<TeamRunTaskToolResult>>();
+
+	tools.push(
+		createTool<TeamRunTaskInput, TeamRunTaskToolResult>({
+			name: "team_run_task",
+			description:
+				"Route a delegated task to a teammate. Choose sync (wait) or async (run in background).",
+			inputSchema: zodToJsonSchema(TeamRunTaskInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(TeamRunTaskInputSchema, input);
+				if (validatedInput.runMode === "async") {
+					const run = options.runtime.startTeammateRun(
+						validatedInput.agentId,
+						validatedInput.task,
+						{
+							taskId: validatedInput.taskId || undefined,
+							fromAgentId: options.requesterId,
+							continueConversation:
+								validatedInput.continueConversation || undefined,
+						},
+					);
+					return validateWithZod(TeamRunTaskToolResultSchema, {
+						agentId: validatedInput.agentId,
+						mode: "async",
+						status: "queued",
+						dispatched: true,
+						message: `Task dispatched to ${validatedInput.agentId} and queued as ${run.id}.`,
+						runId: run.id,
+					});
+				}
+
+				// Deduplication guard: collapse a duplicate sync call for the same
+				// agent onto the first in-flight dispatch in this parallel tool-call batch.
+				const pendingRun = pendingSyncRuns.get(validatedInput.agentId);
+				if (pendingRun) {
+					const result = await pendingRun;
+					return validateWithZod(TeamRunTaskToolResultSchema, {
+						...result,
+						status: "joined",
+						deduped: true,
+						message: `Task for ${validatedInput.agentId} was already dispatched in this tool batch; joined the existing in-flight run.`,
+					});
+				}
+				const runPromise = options.runtime
+					.routeToTeammate(validatedInput.agentId, validatedInput.task, {
+						taskId: validatedInput.taskId || undefined,
+						fromAgentId: options.requesterId,
+						continueConversation:
+							validatedInput.continueConversation || undefined,
+					})
+					.then((result) =>
+						validateWithZod(TeamRunTaskToolResultSchema, {
+							agentId: validatedInput.agentId,
+							mode: "sync" as const,
+							status: "running" as const,
+							dispatched: true,
+							message: `Task dispatched to ${validatedInput.agentId} and completed in sync mode.`,
+							text: result.text,
+							iterations: result.iterations,
+						}),
+					)
+					.finally(() => {
+						pendingSyncRuns.delete(validatedInput.agentId);
+					});
+				pendingSyncRuns.set(validatedInput.agentId, runPromise);
+				return await runPromise;
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamCancelRunInput, { runId: string; status: string }>({
+			name: "team_cancel_run",
+			description: "Cancel one async teammate run.",
+			inputSchema: zodToJsonSchema(TeamCancelRunInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(TeamCancelRunInputSchema, input);
+				const run = options.runtime.cancelRun(
+					validatedInput.runId,
+					validatedInput.reason,
+				);
+				return validateWithZod(TeamCancelRunToolResultSchema, {
+					runId: run.id,
+					status: run.status,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamListRunsInput, TeamRunToolSummary[]>({
+			name: "team_list_runs",
+			description:
+				"List teammate runs started with team_run_task in async mode, including live activity/progress fields when available.",
+			inputSchema: zodToJsonSchema(TeamListRunsInputSchema),
+			execute: async (input) =>
+				validateWithZod(
+					TeamRunToolSummarySchema.array(),
+					options.runtime
+						.listRuns(validateWithZod(TeamListRunsInputSchema, input))
+						.map(summarizeRun),
+				),
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamAwaitRunsInput, TeamRunToolSummary | TeamRunToolSummary[]>({
+			name: "team_await_runs",
+			description:
+				"Wait for async teammate runs. Provide runId to wait for one run, or omit it to wait for all active async runs. Uses a long timeout for legitimate teammate work.",
+			inputSchema: zodToJsonSchema(TeamAwaitRunsInputSchema),
+			timeoutMs: TEAM_AWAIT_TIMEOUT_MS,
+			execute: async (input) => {
+				const validatedInput = validateWithZod(TeamAwaitRunsInputSchema, input);
+				if (validatedInput.runId) {
+					const run = await options.runtime.awaitRun(validatedInput.runId);
+					assertAwaitedRunSucceeded(run);
+					return validateWithZod(TeamRunToolSummarySchema, summarizeRun(run));
+				}
+				const runs = await options.runtime.awaitAllRuns();
+				const failedRuns = runs.filter((run) =>
+					["failed", "cancelled", "interrupted"].includes(run.status),
+				);
+				if (failedRuns.length > 0) {
+					const details = failedRuns
+						.map(
+							(run) =>
+								`${run.id}:${run.status}${run.error ? `(${run.error})` : ""}`,
+						)
+						.join(", ");
+					throw new Error(
+						`One or more runs did not complete successfully: ${details}`,
+					);
+				}
+				return validateWithZod(
+					TeamRunToolSummarySchema.array(),
+					runs.map(summarizeRun),
+				);
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamSendMessageInput, { id: string; toAgentId: string }>({
+			name: "team_send_message",
+			description: "Send a mailbox message to a specific teammate.",
+			inputSchema: zodToJsonSchema(TeamSendMessageInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamSendMessageInputSchema,
+					input,
+				);
+				const message = options.runtime.sendMessage(
+					options.requesterId,
+					validatedInput.toAgentId,
+					validatedInput.subject,
+					validatedInput.body,
+					validatedInput.taskId ?? undefined,
+				);
+				return validateWithZod(TeamSendMessageToolResultSchema, {
+					id: message.id,
+					toAgentId: message.toAgentId,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamBroadcastInput, { delivered: number }>({
+			name: "team_broadcast",
+			description: "Broadcast a message to all teammates.",
+			inputSchema: zodToJsonSchema(TeamBroadcastInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(TeamBroadcastInputSchema, input);
+				const messages = options.runtime.broadcast(
+					options.requesterId,
+					validatedInput.subject,
+					validatedInput.body,
+					{
+						taskId: validatedInput.taskId ?? undefined,
+					},
+				);
+				return validateWithZod(TeamBroadcastToolResultSchema, {
+					delivered: messages.length,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamReadMailboxInput, TeamMailboxMessageToolResult[]>({
+			name: "team_read_mailbox",
+			description: "Read the current agent mailbox.",
+			inputSchema: zodToJsonSchema(TeamReadMailboxInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamReadMailboxInputSchema,
+					input,
+				);
+				return validateWithZod(
+					TeamMailboxMessageToolResultSchema.array(),
+					options.runtime.listMailbox(options.requesterId, {
+						unreadOnly: validatedInput.unreadOnly,
+						markRead: true,
+					}),
+				);
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamMissionLogInput, { id: string }>({
+			name: "team_mission_log",
+			description: "Append a mission log update for your team.",
+			inputSchema: zodToJsonSchema(TeamMissionLogInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamMissionLogInputSchema,
+					input,
+				);
+				const entry = options.runtime.appendMissionLog({
+					agentId: options.requesterId,
+					taskId: validatedInput.taskId || undefined,
+					kind: validatedInput.kind,
+					summary: validatedInput.summary,
+					evidence: validatedInput.evidence?.length
+						? validatedInput.evidence
+						: undefined,
+					nextAction: validatedInput.nextAction || undefined,
+				});
+				return validateWithZod(TeamMissionLogToolResultSchema, {
+					id: entry.id,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamCleanupInput, { status: string }>({
+			name: "team_cleanup",
+			description:
+				"Clean up the team runtime. Fails if teammates are still running.",
+			inputSchema: zodToJsonSchema(TeamCleanupInputSchema),
+			execute: async (input) => {
+				validateWithZod(TeamCleanupInputSchema, input);
+				if (options.runtime.getMemberRole(options.requesterId) !== "lead") {
+					throw new Error("Only the lead agent can run cleanup.");
+				}
+				options.runtime.cleanup();
+				return validateWithZod(TeamCleanupToolResultSchema, {
+					status: "cleaned",
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamCreateOutcomeInput, TeamCreateOutcomeToolResult>({
+			name: "team_create_outcome",
+			description: "Create a converged team outcome.",
+			inputSchema: zodToJsonSchema(TeamCreateOutcomeInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamCreateOutcomeInputSchema,
+					input,
+				);
+				const outcome = options.runtime.createOutcome({
+					title: validatedInput.title,
+					requiredSections: validatedInput.requiredSections,
+					createdBy: options.requesterId,
+				});
+				return validateWithZod(TeamCreateOutcomeToolResultSchema, {
+					outcomeId: outcome.id,
+					status: outcome.status,
+					requiredSections: outcome.requiredSections,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<
+			TeamAttachOutcomeFragmentInput,
+			{ fragmentId: string; status: string }
+		>({
+			name: "team_attach_outcome_fragment",
+			description: "Attach a fragment to an outcome section.",
+			inputSchema: zodToJsonSchema(TeamAttachOutcomeFragmentInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamAttachOutcomeFragmentInputSchema,
+					input,
+				);
+				const fragment = options.runtime.attachOutcomeFragment({
+					outcomeId: validatedInput.outcomeId,
+					section: validatedInput.section,
+					sourceAgentId: options.requesterId,
+					sourceRunId: validatedInput.sourceRunId || undefined,
+					content: validatedInput.content,
+				});
+				return validateWithZod(TeamOutcomeFragmentToolResultSchema, {
+					fragmentId: fragment.id,
+					status: fragment.status,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<
+			TeamReviewOutcomeFragmentInput,
+			{ fragmentId: string; status: string }
+		>({
+			name: "team_review_outcome_fragment",
+			description: "Review one outcome fragment.",
+			inputSchema: zodToJsonSchema(TeamReviewOutcomeFragmentInputSchema),
+			execute: async (input) => {
+				const validatedInput = validateWithZod(
+					TeamReviewOutcomeFragmentInputSchema,
+					input,
+				);
+				const fragment = options.runtime.reviewOutcomeFragment({
+					fragmentId: validatedInput.fragmentId,
+					reviewedBy: options.requesterId,
+					approved: validatedInput.approved,
+				});
+				return validateWithZod(TeamOutcomeFragmentToolResultSchema, {
+					fragmentId: fragment.id,
+					status: fragment.status,
+				});
+			},
+		}) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamFinalizeOutcomeInput, { outcomeId: string; status: string }>(
+			{
+				name: "team_finalize_outcome",
+				description: "Finalize one outcome.",
+				inputSchema: zodToJsonSchema(TeamFinalizeOutcomeInputSchema),
+				execute: async (input) => {
+					const validatedInput = validateWithZod(
+						TeamFinalizeOutcomeInputSchema,
+						input,
+					);
+					const outcome = options.runtime.finalizeOutcome(
+						validatedInput.outcomeId,
+					);
+					return validateWithZod(TeamFinalizeOutcomeToolResultSchema, {
+						outcomeId: outcome.id,
+						status: outcome.status,
+					});
+				},
+			},
+		) as AgentTool,
+	);
+
+	tools.push(
+		createTool<TeamListOutcomesInput, TeamOutcomeToolResult[]>({
+			name: "team_list_outcomes",
+			description: "List team outcomes.",
+			inputSchema: zodToJsonSchema(TeamListOutcomesInputSchema),
+			execute: async (input) => {
+				validateWithZod(TeamListOutcomesInputSchema, input);
+				return validateWithZod(
+					TeamOutcomeToolResultSchema.array(),
+					options.runtime.listOutcomes(),
+				);
+			},
+		}) as AgentTool,
+	);
+
+	return tools;
+}
+
+export function reviveTeamStateDates(
+	state: TeamRuntimeState,
+): TeamRuntimeState {
+	return {
+		...state,
+		tasks: state.tasks.map((task) => ({
+			...task,
+			createdAt: new Date(task.createdAt),
+			updatedAt: new Date(task.updatedAt),
+		})),
+		mailbox: state.mailbox.map((message) => ({
+			...message,
+			sentAt: new Date(message.sentAt),
+			readAt: message.readAt ? new Date(message.readAt) : undefined,
+		})),
+		missionLog: state.missionLog.map((entry) => ({
+			...entry,
+			ts: new Date(entry.ts),
+		})),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			startedAt: new Date(run.startedAt),
+			endedAt: run.endedAt ? new Date(run.endedAt) : undefined,
+			nextAttemptAt: run.nextAttemptAt
+				? new Date(run.nextAttemptAt)
+				: undefined,
+			heartbeatAt: run.heartbeatAt ? new Date(run.heartbeatAt) : undefined,
+		})),
+		outcomes: (state.outcomes ?? []).map((outcome) => ({
+			...outcome,
+			createdAt: new Date(outcome.createdAt),
+			finalizedAt: outcome.finalizedAt
+				? new Date(outcome.finalizedAt)
+				: undefined,
+		})),
+		outcomeFragments: (state.outcomeFragments ?? []).map((fragment) => ({
+			...fragment,
+			createdAt: new Date(fragment.createdAt),
+			reviewedAt: fragment.reviewedAt
+				? new Date(fragment.reviewedAt)
+				: undefined,
+		})),
+	};
+}
+
+export function sanitizeTeamName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
diff --git a/sdk/packages/core/src/extensions/tools/types.ts b/sdk/packages/core/src/extensions/tools/types.ts
new file mode 100644
index 0000000..1408e8d
--- /dev/null
+++ b/sdk/packages/core/src/extensions/tools/types.ts
@@ -0,0 +1,358 @@
+/**
+ * Types for Default Tools
+ *
+ * Type definitions for executors, configuration, and results.
+ */
+
+import type {
+	AgentToolContext,
+	ImageContent,
+	TextContent,
+} from "@cline/shared";
+import type {
+	ApplyPatchInput,
+	EditFileInput,
+	ReadFileRequest,
+	StructuredCommandInput,
+} from "./schemas";
+
+// =============================================================================
+// Tool Result Types
+// =============================================================================
+
+/**
+ * Result from a single tool operation
+ */
+export interface ToolOperationResult {
+	/** The query/input that was executed */
+	query: string;
+	/** The result content (if successful) */
+	result: unknown;
+	/** Error message (if failed) */
+	error?: string;
+	/** Whether the operation succeeded */
+	success: boolean;
+	/** Duration in MS */
+	duration?: number;
+}
+
+export type FileReadResultContent = string | Array<TextContent | ImageContent>;
+
+// =============================================================================
+// Executor Interfaces
+// =============================================================================
+
+/**
+ * Executor for reading files
+ *
+ * @param request - File path and optional inclusive line range to read
+ * @param context - Tool execution context
+ * @returns The file content as a string
+ */
+export type FileReadExecutor = (
+	request: ReadFileRequest,
+	context: AgentToolContext,
+) => Promise<FileReadResultContent>;
+
+/**
+ * Executor for searching the codebase
+ *
+ * @param query - Regex pattern to search for
+ * @param cwd - Current working directory for the search
+ * @param context - Tool execution context
+ * @returns Search results as a formatted string
+ */
+export type SearchExecutor = (
+	query: string,
+	cwd: string,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Executor for running shell commands
+ *
+ * @param command - Shell command to execute
+ * @param cwd - Current working directory for execution
+ * @param context - Tool execution context
+ * @returns Command output (stdout)
+ */
+export type ShellExecutor = (
+	command: string | StructuredCommandInput,
+	cwd: string,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Executor for fetching web content
+ *
+ * @param url - URL to fetch
+ * @param prompt - Analysis prompt for the content
+ * @param context - Tool execution context
+ * @returns Analyzed/extracted content
+ */
+export type WebFetchExecutor = (
+	url: string,
+	prompt: string,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Executor for editing files
+ *
+ * @param input - Editor command input
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type EditorExecutor = (
+	input: EditFileInput,
+	cwd: string,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Executor for apply_patch operations
+ *
+ * @param input - apply_patch command payload
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type ApplyPatchExecutor = (
+	input: ApplyPatchInput,
+	cwd: string,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Executor for invoking configured skills
+ *
+ * @param skill - Skill name to invoke
+ * @param args - Optional arguments for the skill
+ * @param context - Tool execution context
+ * @returns Skill loading/invocation result
+ */
+export type SkillsExecutor = (
+	skill: string,
+	args: string | undefined,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Executor for asking a single follow-up question with selectable options
+ *
+ * @param question - Single clarifying question for the user
+ * @param options - 2-5 selectable answer options
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type AskQuestionExecutor = (
+	question: string,
+	options: string[],
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Skill metadata exposed by SkillsExecutor for clients/UI
+ */
+export interface SkillsExecutorSkillMetadata {
+	/** Normalized skill id (usually lowercased name) */
+	id: string;
+	/** Display name for the skill */
+	name: string;
+	/** Optional short description */
+	description?: string;
+	/** True when configured but intentionally disabled */
+	disabled: boolean;
+}
+
+/**
+ * A callable executor that can also expose configured skill metadata.
+ */
+export interface SkillsExecutorWithMetadata {
+	(
+		skill: string,
+		args: string | undefined,
+		context: AgentToolContext,
+	): Promise<string>;
+	configuredSkills?: SkillsExecutorSkillMetadata[];
+}
+
+/**
+ * Executor for verifying a user's response to a question
+ *
+ * @param summary - Summary of the solution ans steps taken
+ * @param verified - Boolean indicating if the solution has been verified
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type VerifySubmitExecutor = (
+	summary: string,
+	verified: boolean,
+	context: AgentToolContext,
+) => Promise<string>;
+
+/**
+ * Collection of all tool executors
+ */
+export interface ToolExecutors {
+	/** File reading implementation */
+	readFile?: FileReadExecutor;
+	/** Codebase search implementation */
+	search?: SearchExecutor;
+	/** Shell command execution implementation */
+	bash?: ShellExecutor;
+	/** Web content fetching implementation */
+	webFetch?: WebFetchExecutor;
+	/** Filesystem editor implementation */
+	editor?: EditorExecutor;
+	/** Apply patch implementation */
+	applyPatch?: ApplyPatchExecutor;
+	/** Skill invocation implementation */
+	skills?: SkillsExecutorWithMetadata;
+	/** Follow-up question implementation */
+	askQuestion?: AskQuestionExecutor;
+	/** Final submission implementation */
+	submit?: VerifySubmitExecutor;
+}
+
+// =============================================================================
+// Tool Configuration
+// =============================================================================
+
+/**
+ * Names of available default tools
+ */
+export type DefaultToolName =
+	| "read_files"
+	| "search_codebase"
+	| "run_commands"
+	| "fetch_web_content"
+	| "apply_patch"
+	| "editor"
+	| "skills"
+	| "ask_question"
+	| "submit_and_exit";
+
+/**
+ * Configuration for enabling/disabling default tools
+ */
+export interface DefaultToolsConfig {
+	/**
+	 * Enable the read_files tool
+	 * @default true
+	 */
+	enableReadFiles?: boolean;
+
+	/**
+	 * Enable the search_codebase tool
+	 * @default true
+	 */
+	enableSearch?: boolean;
+
+	/**
+	 * Enable the run_commands tool
+	 * @default true
+	 */
+	enableBash?: boolean;
+
+	/**
+	 * Enable the fetch_web_content tool
+	 * @default true
+	 */
+	enableWebFetch?: boolean;
+
+	/**
+	 * Enable the apply_patch tool
+	 * @default true
+	 */
+	enableApplyPatch?: boolean;
+
+	/**
+	 * Enable the editor tool
+	 * @default true
+	 */
+	enableEditor?: boolean;
+
+	/**
+	 * Enable the skills tool
+	 * @default true
+	 */
+	enableSkills?: boolean;
+
+	/**
+	 * Enable the ask_followup_question tool
+	 * @default true
+	 */
+	enableAskQuestion?: boolean;
+
+	/**
+	 * Enable the submit_and_exit tool
+	 * @default false
+	 */
+	enableSubmitAndExit?: boolean;
+
+	/**
+	 * Current working directory for tools that need it
+	 */
+	cwd?: string;
+
+	/**
+	 * Timeout for file read operations in milliseconds
+	 * @default 10000
+	 */
+	fileReadTimeoutMs?: number;
+
+	/**
+	 * Timeout for bash command execution in milliseconds
+	 * @default 30000
+	 */
+	bashTimeoutMs?: number;
+
+	/**
+	 * Timeout for web fetch operations in milliseconds
+	 * @default 30000
+	 */
+	webFetchTimeoutMs?: number;
+
+	/**
+	 * Timeout for search operations in milliseconds
+	 * @default 30000
+	 */
+	searchTimeoutMs?: number;
+
+	/**
+	 * Timeout for apply_patch operations in milliseconds
+	 * @default 30000
+	 */
+	applyPatchTimeoutMs?: number;
+
+	/**
+	 * Timeout for editor operations in milliseconds
+	 * @default 30000
+	 */
+	editorTimeoutMs?: number;
+
+	/**
+	 * Timeout for skills operations in milliseconds
+	 * @default 15000
+	 */
+	skillsTimeoutMs?: number;
+
+	/**
+	 * Timeout for submit_and_exit operations in milliseconds
+	 * @default 15000
+	 */
+	submitTimeoutMs?: number;
+}
+
+/**
+ * Options for creating default tools
+ */
+export interface CreateDefaultToolsOptions extends DefaultToolsConfig {
+	/**
+	 * Executor implementations for the tools
+	 * Only tools with provided executors will be available
+	 */
+	executors: ToolExecutors;
+}
diff --git a/sdk/packages/core/src/hooks/checkpoint-hooks.test.ts b/sdk/packages/core/src/hooks/checkpoint-hooks.test.ts
new file mode 100644
index 0000000..746d3b0
--- /dev/null
+++ b/sdk/packages/core/src/hooks/checkpoint-hooks.test.ts
@@ -0,0 +1,276 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { describe, expect, it } from "vitest";
+import {
+	type CheckpointEntry,
+	type CheckpointMetadata,
+	createCheckpointHooks,
+} from "./checkpoint-hooks";
+
+const execFile = promisify(execFileCallback);
+
+async function runGit(cwd: string, ...args: string[]): Promise<string> {
+	const result = await execFile("git", ["-C", cwd, ...args], {
+		windowsHide: true,
+	});
+	return result.stdout.trim();
+}
+
+async function createGitRepo(): Promise<string> {
+	const cwd = await mkdtemp(join(tmpdir(), "core-checkpoint-"));
+	await runGit(cwd, "init");
+	await runGit(cwd, "config", "user.name", "Codex Test");
+	await runGit(cwd, "config", "user.email", "codex@example.com");
+	await writeFile(join(cwd, "note.txt"), "base\n", "utf8");
+	await runGit(cwd, "add", "note.txt");
+	await runGit(cwd, "commit", "-m", "initial");
+	return cwd;
+}
+
+async function runCheckpointHooks(
+	hooks: ReturnType<typeof createCheckpointHooks>,
+	options: { parentAgentId?: string | null } = {},
+): Promise<void> {
+	const snapshot = {
+		agentId: options.parentAgentId ? "agent_child" : "agent_1",
+		parentAgentId: options.parentAgentId,
+		conversationId: options.parentAgentId ? "conv_child" : "conv_1",
+		runId: options.parentAgentId ? "run_child" : "run_1",
+		status: "running" as const,
+		iteration: 1,
+		messages: [],
+		pendingToolCalls: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+		},
+	};
+	await hooks.beforeRun?.({ snapshot: { ...snapshot, iteration: 0 } });
+	await hooks.beforeModel?.({
+		snapshot,
+		request: {
+			messages: [],
+			tools: [],
+		},
+	});
+}
+
+describe("createCheckpointHooks", () => {
+	it("creates one checkpoint at the start of each root run and appends metadata", async () => {
+		const cwd = await createGitRepo();
+		let metadata: Record<string, unknown> | undefined;
+		try {
+			const hooks = createCheckpointHooks({
+				cwd,
+				sessionId: "sess_1",
+				readSessionMetadata: async () => metadata,
+				writeSessionMetadata: async (next) => {
+					metadata = next;
+				},
+			});
+
+			await writeFile(join(cwd, "note.txt"), "run-one\n", "utf8");
+			await runCheckpointHooks(hooks);
+
+			const first = metadata?.checkpoint as CheckpointMetadata;
+			expect(first.history).toHaveLength(1);
+			expect(first.latest.runCount).toBe(1);
+			expect(first.latest.ref).toMatch(/^[0-9a-f]{40}$/);
+
+			await writeFile(join(cwd, "note.txt"), "run-two\n", "utf8");
+			await runCheckpointHooks(hooks);
+
+			const checkpoint = metadata?.checkpoint as CheckpointMetadata;
+			expect(checkpoint.latest.runCount).toBe(2);
+			expect(checkpoint.history).toHaveLength(2);
+			expect(
+				checkpoint.history.map((entry: CheckpointEntry) => entry.runCount),
+			).toEqual([1, 2]);
+			expect(checkpoint.latest.kind).toBe("stash");
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("falls back to a commit checkpoint when the worktree is clean", async () => {
+		const cwd = await createGitRepo();
+		let metadata: Record<string, unknown> | undefined;
+		try {
+			const hooks = createCheckpointHooks({
+				cwd,
+				sessionId: "sess_clean",
+				readSessionMetadata: async () => metadata,
+				writeSessionMetadata: async (next) => {
+					metadata = next;
+				},
+			});
+
+			await runCheckpointHooks(hooks);
+
+			const checkpoint = metadata?.checkpoint as CheckpointMetadata;
+			expect(checkpoint.history).toHaveLength(1);
+			expect(checkpoint.latest.kind).toBe("commit");
+			expect(checkpoint.latest.ref).toMatch(/^[0-9a-f]{40}$/);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("does not append a checkpoint when the snapshot matches the latest checkpoint", async () => {
+		const cwd = await createGitRepo();
+		let metadata: Record<string, unknown> | undefined;
+		try {
+			const hooks = createCheckpointHooks({
+				cwd,
+				sessionId: "sess_no_change",
+				readSessionMetadata: async () => metadata,
+				writeSessionMetadata: async (next) => {
+					metadata = next;
+				},
+			});
+
+			await runCheckpointHooks(hooks);
+
+			const first = metadata?.checkpoint as CheckpointMetadata;
+			expect(first.history).toHaveLength(1);
+			expect(first.latest.kind).toBe("commit");
+
+			await runCheckpointHooks(hooks);
+
+			const checkpoint = metadata?.checkpoint as CheckpointMetadata;
+			expect(checkpoint.history).toHaveLength(1);
+			expect(checkpoint.latest.runCount).toBe(1);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("skips checkpoint creation for subagents", async () => {
+		const cwd = await createGitRepo();
+		let writes = 0;
+		try {
+			const hooks = createCheckpointHooks({
+				cwd,
+				sessionId: "sess_1",
+				readSessionMetadata: async () => undefined,
+				writeSessionMetadata: async () => {
+					writes += 1;
+				},
+			});
+
+			await writeFile(join(cwd, "note.txt"), "subagent-dirty\n", "utf8");
+			await runCheckpointHooks(hooks, { parentAgentId: "agent_root" });
+
+			expect(writes).toBe(0);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("does not advance root checkpoint numbering for subagent runs", async () => {
+		let metadata: Record<string, unknown> | undefined;
+		const hooks = createCheckpointHooks({
+			cwd: "/tmp",
+			sessionId: "sess_subagent_count",
+			createCheckpoint: ({ runCount }) => ({
+				ref: `checkpoint-${runCount}`,
+				createdAt: runCount,
+				runCount,
+				kind: "commit",
+			}),
+			readSessionMetadata: async () => metadata,
+			writeSessionMetadata: async (next) => {
+				metadata = next;
+			},
+		});
+
+		await runCheckpointHooks(hooks, { parentAgentId: "agent_root" });
+		await runCheckpointHooks(hooks);
+
+		const checkpoint = metadata?.checkpoint as CheckpointMetadata;
+		expect(checkpoint.latest.runCount).toBe(1);
+		expect(checkpoint.history.map((entry) => entry.runCount)).toEqual([1]);
+	});
+
+	it("continues checkpoint numbering after seeded messages", async () => {
+		const cwd = await createGitRepo();
+		let metadata: Record<string, unknown> | undefined;
+		try {
+			const hooks = createCheckpointHooks({
+				cwd,
+				sessionId: "sess_seeded",
+				initialRunCount: 2,
+				readSessionMetadata: async () => metadata,
+				writeSessionMetadata: async (next) => {
+					metadata = next;
+				},
+			});
+
+			await writeFile(join(cwd, "note.txt"), "run-three\n", "utf8");
+			await runCheckpointHooks(hooks);
+
+			const checkpoint = metadata?.checkpoint as CheckpointMetadata;
+			expect(checkpoint.latest.runCount).toBe(3);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("replaces an existing checkpoint entry for the same run count", async () => {
+		let metadata: Record<string, unknown> | undefined = {
+			checkpoint: {
+				latest: {
+					ref: "old-three",
+					createdAt: 3,
+					runCount: 3,
+					kind: "commit",
+				},
+				history: [
+					{ ref: "one", createdAt: 1, runCount: 1, kind: "commit" },
+					{ ref: "two", createdAt: 2, runCount: 2, kind: "commit" },
+					{
+						ref: "old-three",
+						createdAt: 3,
+						runCount: 3,
+						kind: "commit",
+					},
+				],
+			},
+		};
+		const hooks = createCheckpointHooks({
+			cwd: "/tmp",
+			sessionId: "sess_replace",
+			initialRunCount: 2,
+			createCheckpoint: ({ runCount }) => ({
+				ref: "new-three",
+				createdAt: 4,
+				runCount,
+				kind: "commit",
+			}),
+			readSessionMetadata: async () => metadata,
+			writeSessionMetadata: async (next) => {
+				metadata = next;
+			},
+		});
+
+		await runCheckpointHooks(hooks);
+
+		const checkpoint = metadata?.checkpoint as CheckpointMetadata;
+		expect(checkpoint.latest).toMatchObject({
+			ref: "new-three",
+			runCount: 3,
+		});
+		expect(checkpoint.history.map((entry) => entry.runCount)).toEqual([
+			1, 2, 3,
+		]);
+		expect(checkpoint.history.at(-1)).toMatchObject({
+			ref: "new-three",
+			runCount: 3,
+		});
+	});
+});
diff --git a/sdk/packages/core/src/hooks/checkpoint-hooks.ts b/sdk/packages/core/src/hooks/checkpoint-hooks.ts
new file mode 100644
index 0000000..391566f
--- /dev/null
+++ b/sdk/packages/core/src/hooks/checkpoint-hooks.ts
@@ -0,0 +1,291 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import type { AgentHooks, BasicLogger } from "@cline/shared";
+
+const execFile = promisify(execFileCallback);
+
+export interface CheckpointEntry {
+	ref: string;
+	createdAt: number;
+	runCount: number;
+	kind?: "stash" | "commit";
+}
+
+export interface CheckpointMetadata {
+	latest: CheckpointEntry;
+	history: CheckpointEntry[];
+}
+
+type CreateCheckpointHooksOptions = {
+	cwd: string;
+	sessionId: string;
+	logger?: BasicLogger;
+	readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+	writeSessionMetadata: (
+		metadata: Record<string, unknown>,
+	) => Promise<void> | void;
+	/**
+	 * Optional custom checkpoint implementation. When provided, the built-in
+	 * git stash/ref logic is skipped entirely and this function is called
+	 * instead. Return `undefined` to skip writing a checkpoint for that run.
+	 */
+	createCheckpoint?: (context: {
+		cwd: string;
+		sessionId: string;
+		runCount: number;
+	}) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+	/**
+	 * Starting value for the internal run counter. Use this when a session
+	 * is created with initial messages (e.g. after a checkpoint restore) so
+	 * that new checkpoint entries get runCount values that don't collide
+	 * with entries carried over from the source session.
+	 */
+	initialRunCount?: number;
+};
+
+function warn(logger: BasicLogger | undefined, message: string): void {
+	logger?.log(message, { severity: "warn" });
+}
+
+function readCheckpointMetadata(
+	metadata: Record<string, unknown> | undefined,
+): CheckpointMetadata | undefined {
+	const candidate = metadata?.checkpoint;
+	if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+		return undefined;
+	}
+	const record = candidate as Partial<CheckpointMetadata>;
+	if (!record.latest || !Array.isArray(record.history)) {
+		return undefined;
+	}
+	const latest = record.latest as Partial<CheckpointEntry>;
+	const history = record.history.filter(
+		(entry): entry is CheckpointEntry =>
+			!!entry &&
+			typeof entry === "object" &&
+			typeof (entry as Partial<CheckpointEntry>).ref === "string" &&
+			typeof (entry as Partial<CheckpointEntry>).createdAt === "number" &&
+			typeof (entry as Partial<CheckpointEntry>).runCount === "number",
+	);
+	if (
+		typeof latest.ref !== "string" ||
+		typeof latest.createdAt !== "number" ||
+		typeof latest.runCount !== "number"
+	) {
+		return undefined;
+	}
+	return {
+		latest: latest as CheckpointEntry,
+		history,
+	};
+}
+
+async function runGit(
+	cwd: string,
+	args: string[],
+): Promise<{ stdout: string; stderr: string }> {
+	const result = await execFile("git", ["-C", cwd, ...args], {
+		windowsHide: true,
+	});
+	return {
+		stdout: result.stdout.trim(),
+		stderr: result.stderr.trim(),
+	};
+}
+
+/**
+ * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that
+ * were created by the checkpoint system to keep stash objects reachable.
+ * Errors are swallowed - if the cwd is not a git repo or the refs don't exist,
+ * the delete is a no-op.
+ */
+export async function deleteCheckpointRefs(
+	cwd: string | null | undefined,
+	sessionId: string,
+): Promise<void> {
+	if (!cwd) return;
+	const prefix = `refs/cline/checkpoints/${sessionId}/`;
+	try {
+		const { stdout } = await runGit(cwd, [
+			"for-each-ref",
+			"--format=%(refname)",
+			prefix,
+		]);
+		const refs = stdout.trim().split("\n").filter(Boolean);
+		await Promise.allSettled(
+			refs.map((ref) => runGit(cwd, ["update-ref", "-d", ref])),
+		);
+	} catch {
+		// Not a git repo or git not available - ignore.
+	}
+}
+
+export async function retainCheckpointRefs(
+	cwd: string | null | undefined,
+	sessionId: string,
+	checkpoints: readonly CheckpointEntry[],
+): Promise<void> {
+	if (!cwd || checkpoints.length === 0) return;
+	await Promise.allSettled(
+		checkpoints.map((entry) =>
+			runGit(cwd, [
+				"update-ref",
+				`refs/cline/checkpoints/${sessionId}/${entry.runCount}`,
+				entry.ref,
+			]),
+		),
+	);
+}
+
+function upsertCheckpointHistory(
+	history: readonly CheckpointEntry[],
+	entry: CheckpointEntry,
+): CheckpointEntry[] {
+	const existingIndex = history.findIndex(
+		(candidate) => candidate.runCount === entry.runCount,
+	);
+	if (existingIndex < 0) {
+		return [...history, entry];
+	}
+	return history.map((candidate, index) =>
+		index === existingIndex ? entry : candidate,
+	);
+}
+
+export function createCheckpointHooks(
+	options: CreateCheckpointHooksOptions,
+): AgentHooks {
+	let runCount = options.initialRunCount ?? 0;
+	let repoSupported: boolean | undefined;
+
+	const ensureGitRepository = async (): Promise<boolean> => {
+		if (repoSupported !== undefined) {
+			return repoSupported;
+		}
+		try {
+			const result = await runGit(options.cwd, [
+				"rev-parse",
+				"--is-inside-work-tree",
+			]);
+			repoSupported = result.stdout === "true";
+		} catch {
+			repoSupported = false;
+		}
+		return repoSupported;
+	};
+
+	const createCheckpoint = async (): Promise<CheckpointEntry | undefined> => {
+		if (options.createCheckpoint) {
+			return await options.createCheckpoint({
+				cwd: options.cwd,
+				sessionId: options.sessionId,
+				runCount,
+			});
+		}
+
+		if (!(await ensureGitRepository())) {
+			return undefined;
+		}
+
+		const createHeadCheckpoint = async (
+			warnPrefix: string,
+		): Promise<CheckpointEntry | undefined> => {
+			try {
+				const result = await runGit(options.cwd, ["rev-parse", "HEAD"]);
+				const ref = result.stdout.trim();
+				if (!ref) {
+					return undefined;
+				}
+				return {
+					ref,
+					createdAt: Date.now(),
+					runCount,
+					kind: "commit",
+				};
+			} catch (error) {
+				warn(
+					options.logger,
+					`${warnPrefix}: ${error instanceof Error ? error.message : String(error)}`,
+				);
+				return undefined;
+			}
+		};
+
+		const message = `cline checkpoint session=${options.sessionId} run=${runCount}`;
+		let ref = "";
+		try {
+			const result = await runGit(options.cwd, ["stash", "create", message]);
+			ref = result.stdout.trim();
+		} catch (error) {
+			warn(
+				options.logger,
+				`Checkpoint snapshot failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return createHeadCheckpoint("Checkpoint HEAD fallback failed");
+		}
+		if (!ref) {
+			return createHeadCheckpoint("Checkpoint HEAD fallback failed");
+		}
+
+		// Store the stash commit under a private ref namespace so it is
+		// invisible to the user's normal `git stash list` workflow.
+		// `refs/stash` is what populates that list; writing to any other
+		// ref path keeps the object reachable (GC-safe) without surfacing
+		// it to the user.  The raw SHA already works with `git stash apply`
+		// on the restore path, so no restore-side changes are needed.
+		const privateRef = `refs/cline/checkpoints/${options.sessionId}/${runCount}`;
+		try {
+			await runGit(options.cwd, ["update-ref", privateRef, ref]);
+		} catch (error) {
+			warn(
+				options.logger,
+				`Checkpoint store failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return undefined;
+		}
+
+		return {
+			ref,
+			createdAt: Date.now(),
+			runCount,
+			kind: "stash",
+		};
+	};
+
+	return {
+		beforeRun: async ({ snapshot }) => {
+			if (snapshot.parentAgentId != null) {
+				return undefined;
+			}
+			runCount += 1;
+			return undefined;
+		},
+		beforeModel: async ({ snapshot }) => {
+			if (
+				snapshot.parentAgentId != null ||
+				snapshot.iteration !== 1 ||
+				runCount < 1
+			) {
+				return undefined;
+			}
+			const entry = await createCheckpoint();
+			if (!entry) {
+				return undefined;
+			}
+			const metadata = await options.readSessionMetadata();
+			const existing = readCheckpointMetadata(metadata);
+			if (existing?.latest.ref === entry.ref) {
+				return undefined;
+			}
+			const history = upsertCheckpointHistory(existing?.history ?? [], entry);
+			await options.writeSessionMetadata({
+				...(metadata ?? {}),
+				checkpoint: {
+					latest: entry,
+					history,
+				} satisfies CheckpointMetadata,
+			});
+			return undefined;
+		},
+	};
+}
diff --git a/sdk/packages/core/src/hooks/hook-extension.ts b/sdk/packages/core/src/hooks/hook-extension.ts
new file mode 100644
index 0000000..c09bff7
--- /dev/null
+++ b/sdk/packages/core/src/hooks/hook-extension.ts
@@ -0,0 +1,15 @@
+import type { AgentExtension, AgentHooks } from "@cline/shared";
+
+export function createAgentHooksExtension(
+	name: string,
+	hooks: AgentHooks | undefined,
+): AgentExtension | undefined {
+	if (!hooks) {
+		return undefined;
+	}
+	return {
+		name,
+		manifest: { capabilities: ["hooks"] },
+		hooks,
+	};
+}
diff --git a/sdk/packages/core/src/hooks/hook-file-config.test.ts b/sdk/packages/core/src/hooks/hook-file-config.test.ts
new file mode 100644
index 0000000..ab80e98
--- /dev/null
+++ b/sdk/packages/core/src/hooks/hook-file-config.test.ts
@@ -0,0 +1,17 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { HookConfigFileName, toHookConfigFileName } from "./hook-file-config";
+
+describe("hook file config", () => {
+	afterEach(() => {
+		delete process.env.CLINE_DATA_DIR;
+	});
+
+	it("recognizes PowerShell hook files", () => {
+		expect(toHookConfigFileName("PreToolUse.ps1")).toBe(
+			HookConfigFileName.PreToolUse,
+		);
+		expect(toHookConfigFileName("TaskError.ps1")).toBe(
+			HookConfigFileName.TaskError,
+		);
+	});
+});
diff --git a/sdk/packages/core/src/hooks/hook-file-config.ts b/sdk/packages/core/src/hooks/hook-file-config.ts
new file mode 100644
index 0000000..0ab3132
--- /dev/null
+++ b/sdk/packages/core/src/hooks/hook-file-config.ts
@@ -0,0 +1,117 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import {
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	resolveHooksConfigSearchPaths as resolveHooksConfigSearchPathsFromShared,
+} from "@cline/shared/storage";
+import type { HookEventName } from "./subprocess";
+
+export { HOOKS_CONFIG_DIRECTORY_NAME };
+
+export function resolveHooksConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveHooksConfigSearchPathsFromShared(workspacePath);
+}
+
+export enum HookConfigFileName {
+	TaskStart = "TaskStart",
+	TaskResume = "TaskResume",
+	TaskCancel = "TaskCancel",
+	TaskComplete = "TaskComplete",
+	TaskError = "TaskError",
+	PreToolUse = "PreToolUse",
+	PostToolUse = "PostToolUse",
+	UserPromptSubmit = "UserPromptSubmit",
+	PreCompact = "PreCompact",
+	SessionShutdown = "SessionShutdown",
+}
+
+export const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<
+	Record<HookConfigFileName, HookEventName | undefined>
+> = {
+	[HookConfigFileName.TaskStart]: "agent_start",
+	[HookConfigFileName.TaskResume]: "agent_resume",
+	[HookConfigFileName.TaskCancel]: "agent_abort",
+	[HookConfigFileName.TaskComplete]: "agent_end",
+	[HookConfigFileName.TaskError]: "agent_error",
+	[HookConfigFileName.PreToolUse]: "tool_call",
+	[HookConfigFileName.PostToolUse]: "tool_result",
+	[HookConfigFileName.UserPromptSubmit]: "prompt_submit",
+	[HookConfigFileName.PreCompact]: undefined,
+	[HookConfigFileName.SessionShutdown]: "session_shutdown",
+};
+
+const HOOK_CONFIG_FILE_LOOKUP = new Map<string, HookConfigFileName>(
+	Object.values(HookConfigFileName).map((name) => [name.toLowerCase(), name]),
+);
+
+const SUPPORTED_HOOK_FILE_EXTENSIONS = new Set([
+	"",
+	".sh",
+	".bash",
+	".zsh",
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts",
+	".py",
+	".ps1",
+]);
+
+export function toHookConfigFileName(
+	fileName: string,
+): HookConfigFileName | undefined {
+	const extension = extname(fileName).toLowerCase();
+	if (!SUPPORTED_HOOK_FILE_EXTENSIONS.has(extension)) {
+		return undefined;
+	}
+	const key = basename(fileName, extension).trim().toLowerCase();
+	return HOOK_CONFIG_FILE_LOOKUP.get(key);
+}
+
+export interface HookConfigFileEntry {
+	fileName: HookConfigFileName;
+	hookEventName?: HookEventName;
+	path: string;
+}
+
+export function listHookConfigFiles(
+	workspacePath?: string,
+): HookConfigFileEntry[] {
+	const entries: HookConfigFileEntry[] = [];
+	const seen = new Set<string>();
+	const directories = resolveHooksConfigSearchPaths(workspacePath).filter(
+		(directory) => existsSync(directory),
+	);
+
+	for (const directory of directories) {
+		try {
+			for (const entry of readdirSync(directory, { withFileTypes: true })) {
+				if (!entry.isFile()) {
+					continue;
+				}
+				const fileName = toHookConfigFileName(entry.name);
+				if (!fileName) {
+					continue;
+				}
+				const path = join(directory, entry.name);
+				if (seen.has(path)) {
+					continue;
+				}
+				seen.add(path);
+				entries.push({
+					fileName,
+					hookEventName: HOOK_CONFIG_FILE_EVENT_MAP[fileName],
+					path,
+				});
+			}
+		} catch {
+			// Best-effort listing across config roots.
+		}
+	}
+
+	return entries.sort((a, b) => a.path.localeCompare(b.path));
+}
diff --git a/sdk/packages/core/src/hooks/hook-file-hooks.test.ts b/sdk/packages/core/src/hooks/hook-file-hooks.test.ts
new file mode 100644
index 0000000..5d70a41
--- /dev/null
+++ b/sdk/packages/core/src/hooks/hook-file-hooks.test.ts
@@ -0,0 +1,593 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	resolveClineDir,
+	resolveDocumentsClineDirectoryPath,
+	setClineDir,
+	setHomeDir,
+} from "@cline/shared/storage";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+	createHookAuditHooks,
+	createHookConfigFileExtension,
+	createHookConfigFileHooks,
+	getWindowsPythonFallbackCommand,
+	mergeAgentHooks,
+} from "./hook-file-hooks";
+
+async function waitForFile(
+	filePath: string,
+	timeoutMs = 1500,
+): Promise<string> {
+	const started = Date.now();
+	for (;;) {
+		try {
+			return await readFile(filePath, "utf8");
+		} catch (error) {
+			const code =
+				error && typeof error === "object" && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ENOENT" || Date.now() - started >= timeoutMs) {
+				throw error;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+	}
+}
+
+async function waitForJsonLines(
+	filePath: string,
+	expectedLines: number,
+	timeoutMs = 1500,
+): Promise<string[]> {
+	const started = Date.now();
+	for (;;) {
+		const content = await waitForFile(
+			filePath,
+			Math.max(1, timeoutMs - (Date.now() - started)),
+		);
+		const lines = content.trim().split("\n").filter(Boolean);
+		if (lines.length >= expectedLines) {
+			return lines;
+		}
+		if (Date.now() - started >= timeoutMs) {
+			return lines;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 25));
+	}
+}
+
+async function createWorkspaceWithHook(
+	fileName: string,
+	body: string,
+): Promise<{ workspace: string; hookPath: string }> {
+	const workspace = await mkdtemp(join(tmpdir(), "hooks-workspace-"));
+	const hooksDir = join(workspace, ".clinerules", "hooks");
+	await mkdir(hooksDir, { recursive: true });
+	const hookPath = join(hooksDir, fileName);
+	await writeFile(hookPath, body, "utf8");
+	return { workspace, hookPath };
+}
+
+function beforeToolContext(input: unknown = { path: "README.md" }) {
+	return {
+		snapshot: {
+			agentId: "agent_1",
+			conversationId: "conv_1",
+			runId: "run_1",
+			status: "running" as const,
+			iteration: 1,
+			messages: [],
+			pendingToolCalls: [],
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+			},
+		},
+		tool: {
+			name: "read_file",
+			description: "",
+			inputSchema: {},
+			execute: async () => "",
+		},
+		toolCall: {
+			type: "tool-call" as const,
+			toolCallId: "call_1",
+			toolName: "read_file",
+			input,
+		},
+		input,
+	};
+}
+
+function afterToolContext(input: unknown = { path: "README.md" }) {
+	const startedAt = new Date("2026-01-01T00:00:00.000Z");
+	const endedAt = new Date("2026-01-01T00:00:00.037Z");
+	const before = beforeToolContext(input);
+	return {
+		...before,
+		result: { output: "ok" },
+		startedAt,
+		endedAt,
+		durationMs: 37,
+	};
+}
+
+describe("createHookConfigFileHooks", () => {
+	const originalHomeDir = dirname(
+		dirname(resolveDocumentsClineDirectoryPath()),
+	);
+	const originalClineDir = resolveClineDir();
+	let isolatedRoot = "";
+
+	beforeAll(async () => {
+		isolatedRoot = await mkdtemp(join(tmpdir(), "hooks-home-"));
+		const isolatedHomeDir = join(isolatedRoot, "home");
+		const isolatedClineDir = join(isolatedRoot, "cline");
+		await mkdir(isolatedHomeDir, { recursive: true });
+		await mkdir(isolatedClineDir, { recursive: true });
+		setHomeDir(isolatedHomeDir);
+		setClineDir(isolatedClineDir);
+	});
+
+	afterAll(async () => {
+		setHomeDir(originalHomeDir);
+		setClineDir(originalClineDir);
+		if (isolatedRoot) {
+			await rm(isolatedRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("ignores example hook files", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse.example",
+			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"should-not-run"}\'\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks).toBeUndefined();
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	});
+
+	it("executes extensionless legacy hook files via bash fallback", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse",
+			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"legacy-ok"}\'\nexit 0\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.beforeTool).toBeTypeOf("function");
+			const control = await hooks?.beforeTool?.(beforeToolContext());
+			expect(control).toMatchObject({ stop: true });
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	});
+
+	it("adapts file hooks into an AgentExtension", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse",
+			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"extension-ok"}\'\nexit 0\n',
+		);
+		try {
+			const extension = createHookConfigFileExtension({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(extension?.name).toBe("core.hook_config_files");
+			expect(extension?.manifest).toMatchObject({
+				capabilities: ["hooks"],
+			});
+			const control = await extension?.hooks?.beforeTool?.({
+				snapshot: {
+					agentId: "agent_1",
+					conversationId: "conv_1",
+					status: "running",
+					iteration: 1,
+					messages: [],
+					pendingToolCalls: [],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+					},
+				},
+				tool: {
+					name: "read_file",
+					description: "",
+					inputSchema: {},
+					execute: async () => "",
+				},
+				toolCall: {
+					type: "tool-call",
+					toolCallId: "call_1",
+					toolName: "read_file",
+					input: { path: "README.md" },
+				},
+				input: { path: "README.md" },
+			});
+			expect(control).toMatchObject({ stop: true });
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	});
+
+	it("honors shebang interpreter when present", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse",
+			'#!/usr/bin/env bash\necho \'HOOK_CONTROL\t{"cancel":false,"context":"shebang-ok"}\'\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.beforeTool).toBeTypeOf("function");
+			const control = await hooks?.beforeTool?.(beforeToolContext());
+			expect(control).toBeUndefined();
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	});
+
+	it("parses review control from hook output", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse.js",
+			'console.log(\'HOOK_CONTROL\\t{"review":true,"context":"needs-review"}\')\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.beforeTool).toBeTypeOf("function");
+			const ctx = beforeToolContext({ commands: ["git status"] });
+			ctx.tool.name = "run_commands";
+			ctx.toolCall.toolName = "run_commands";
+			const control = await hooks?.beforeTool?.(ctx);
+			expect(control).toBeUndefined();
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	});
+
+	it("executes python hook files", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse.py",
+			'print(\'HOOK_CONTROL\\t{"cancel": false, "context": "python-ok"}\')\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.beforeTool).toBeTypeOf("function");
+			const control = await hooks?.beforeTool?.(beforeToolContext());
+			expect(control).toBeUndefined();
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	}, 15000);
+
+	it("falls back from py -3 to python when the Windows launcher is missing", () => {
+		expect(
+			getWindowsPythonFallbackCommand(["py", "-3", "hook.py"], "win32", {
+				code: "ENOENT",
+			}),
+		).toEqual(["python", "hook.py"]);
+		expect(
+			getWindowsPythonFallbackCommand(["py", "-3", "-u", "hook.py"], "win32", {
+				code: "ENOENT",
+			}),
+		).toEqual(["python", "-u", "hook.py"]);
+	});
+
+	it("does not rewrite python launch commands when fallback conditions are not met", () => {
+		expect(
+			getWindowsPythonFallbackCommand(["py", "-3", "hook.py"], "linux", {
+				code: "ENOENT",
+			}),
+		).toBeUndefined();
+		expect(
+			getWindowsPythonFallbackCommand(["python", "hook.py"], "win32", {
+				code: "ENOENT",
+			}),
+		).toBeUndefined();
+		expect(
+			getWindowsPythonFallbackCommand(["py", "-3", "hook.py"], "win32", {
+				code: "EACCES",
+			}),
+		).toBeUndefined();
+	});
+
+	it.runIf(process.platform === "win32")(
+		"executes PowerShell hook files on Windows",
+		async () => {
+			const { workspace } = await createWorkspaceWithHook(
+				"PreToolUse.ps1",
+				'Write-Output \'HOOK_CONTROL\t{"cancel": false, "context": "powershell-ok"}\'\n',
+			);
+			try {
+				const hooks = createHookConfigFileHooks({
+					cwd: workspace,
+					workspacePath: workspace,
+				});
+				expect(hooks?.beforeTool).toBeTypeOf("function");
+				const control = await hooks?.beforeTool?.(beforeToolContext());
+				expect(control).toBeUndefined();
+			} finally {
+				await rm(workspace, {
+					recursive: true,
+					force: true,
+					maxRetries: 3,
+					retryDelay: 250,
+				});
+			}
+		},
+	);
+
+	it("maps TaskError hook files to agent_error stop events", async () => {
+		const outputPath = join(tmpdir(), `hooks-task-error-${Date.now()}.json`);
+		const { workspace } = await createWorkspaceWithHook(
+			"TaskError.js",
+			`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').writeFileSync(${JSON.stringify(outputPath)}, data);});\n`,
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			await hooks?.afterRun?.({
+				snapshot: beforeToolContext().snapshot,
+				result: {
+					agentId: "agent_1",
+					runId: "conv_1",
+					status: "failed",
+					iterations: 3,
+					outputText: "",
+					messages: [],
+					usage: beforeToolContext().snapshot.usage,
+					error: new Error("401 unauthorized"),
+				},
+			});
+			const payload = JSON.parse(await waitForFile(outputPath)) as {
+				hookName: string;
+				error?: { message?: string };
+				taskId?: string;
+			};
+			expect(payload.hookName).toBe("agent_error");
+			expect(payload.error?.message).toBe("401 unauthorized");
+			expect(payload.taskId).toBe("conv_1");
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+		}
+	});
+
+	it("writes audit tool timing and completed turn payloads", async () => {
+		const outputPath = join(tmpdir(), `hooks-audit-${Date.now()}.jsonl`);
+		const originalLogPath = process.env.CLINE_HOOKS_LOG_PATH;
+		process.env.CLINE_HOOKS_LOG_PATH = outputPath;
+		try {
+			const hooks = createHookAuditHooks({
+				workspacePath: "/workspace",
+			});
+			await hooks.afterTool?.(afterToolContext());
+			await hooks.afterRun?.({
+				snapshot: beforeToolContext().snapshot,
+				result: {
+					agentId: "agent_1",
+					runId: "run_1",
+					status: "completed",
+					iterations: 1,
+					outputText: "done",
+					messages: [],
+					usage: beforeToolContext().snapshot.usage,
+				},
+			});
+
+			const payloads = (await readFile(outputPath, "utf8"))
+				.trim()
+				.split("\n")
+				.map((line) => JSON.parse(line));
+			const toolResult = payloads.find(
+				(payload) => payload.hookName === "tool_result",
+			);
+			const agentEnd = payloads.find(
+				(payload) => payload.hookName === "agent_end",
+			);
+			expect(toolResult.tool_result).toMatchObject({
+				durationMs: 37,
+				startedAt: "2026-01-01T00:00:00.000Z",
+				endedAt: "2026-01-01T00:00:00.037Z",
+			});
+			expect(toolResult.postToolUse.executionTimeMs).toBe(37);
+			expect(agentEnd.turn).toEqual({
+				outputText: "done",
+				status: "completed",
+			});
+		} finally {
+			if (originalLogPath === undefined) {
+				delete process.env.CLINE_HOOKS_LOG_PATH;
+			} else {
+				process.env.CLINE_HOOKS_LOG_PATH = originalLogPath;
+			}
+			await rm(outputPath, { force: true });
+		}
+	});
+
+	it("merges before-model controls across hook layers", async () => {
+		const hooks = mergeAgentHooks([
+			{
+				beforeModel: async () => ({
+					options: { systemPrompt: "system-a" },
+				}),
+			},
+			{
+				beforeModel: async () => ({
+					options: { extra: "ctx-a" },
+				}),
+			},
+		]);
+
+		const control = await hooks?.beforeModel?.({
+			snapshot: beforeToolContext().snapshot,
+			request: {
+				messages: [],
+				tools: [],
+			},
+		});
+
+		expect(control).toMatchObject({
+			options: { systemPrompt: "system-a", extra: "ctx-a" },
+		});
+	});
+
+	it("dispatches agent_start and prompt_submit exactly once when both are configured", async () => {
+		const outputPath = join(tmpdir(), `hooks-start-prompt-${Date.now()}.jsonl`);
+		const { workspace } = await createWorkspaceWithHook(
+			"TaskStart.js",
+			`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').appendFileSync(${JSON.stringify(outputPath)}, data.trim()+"\\n");});\n`,
+		);
+		try {
+			await writeFile(
+				join(workspace, ".clinerules", "hooks", "UserPromptSubmit.js"),
+				`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').appendFileSync(${JSON.stringify(outputPath)}, data.trim()+"\\n");});\n`,
+				"utf8",
+			);
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			const snapshot = beforeToolContext().snapshot;
+			await hooks?.beforeRun?.({ snapshot: { ...snapshot, iteration: 0 } });
+			await hooks?.onEvent?.({
+				type: "message-added",
+				snapshot,
+				message: {
+					id: "msg_1",
+					role: "user",
+					content: [{ type: "text", text: "real prompt" }],
+					createdAt: 0,
+				},
+			});
+
+			const payloads = (await waitForJsonLines(outputPath, 2)).map(
+				(line) =>
+					JSON.parse(line) as {
+						hookName: string;
+						userPromptSubmit?: { prompt?: string };
+					},
+			);
+			expect(payloads.map((payload) => payload.hookName).sort()).toEqual([
+				"agent_start",
+				"prompt_submit",
+			]);
+			expect(
+				payloads.find((payload) => payload.hookName === "prompt_submit")
+					?.userPromptSubmit?.prompt,
+			).toBe("real prompt");
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+			await rm(outputPath, { force: true });
+		}
+	});
+
+	it("returns hooks and dispatches abort shutdown when only SessionShutdown is configured", async () => {
+		const outputPath = join(
+			tmpdir(),
+			`hooks-session-shutdown-${Date.now()}.json`,
+		);
+		const { workspace } = await createWorkspaceWithHook(
+			"SessionShutdown.js",
+			`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').writeFileSync(${JSON.stringify(outputPath)}, data);});\n`,
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.afterRun).toBeTypeOf("function");
+			await hooks?.afterRun?.({
+				snapshot: beforeToolContext().snapshot,
+				result: {
+					agentId: "agent_1",
+					runId: "run_1",
+					status: "aborted",
+					iterations: 1,
+					outputText: "",
+					messages: [],
+					usage: beforeToolContext().snapshot.usage,
+					error: new Error("user cancel"),
+				},
+			});
+
+			const payload = JSON.parse(await waitForFile(outputPath)) as {
+				hookName: string;
+				reason?: string;
+			};
+			expect(payload.hookName).toBe("session_shutdown");
+			expect(payload.reason).toBe("user cancel");
+		} finally {
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
+			await rm(outputPath, { force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/hooks/hook-file-hooks.ts b/sdk/packages/core/src/hooks/hook-file-hooks.ts
new file mode 100644
index 0000000..be2d9fb
--- /dev/null
+++ b/sdk/packages/core/src/hooks/hook-file-hooks.ts
@@ -0,0 +1,1143 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type {
+	AgentAfterToolContext,
+	AgentBeforeToolContext,
+	AgentExtension,
+	AgentHooks,
+	AgentRunLifecycleContext,
+	AgentRuntimeEvent,
+} from "@cline/shared";
+import {
+	augmentNodeCommandForDebug,
+	type BasicLogger,
+	type HookControl,
+	type HookSessionContext,
+	type WorkspaceInfo,
+	withResolvedClineBuildEnv,
+} from "@cline/shared";
+import { ensureHookLogDir } from "@cline/shared/storage";
+import { createAgentHooksExtension } from "./hook-extension";
+import { listHookConfigFiles } from "./hook-file-config";
+import type { HookEventName, HookEventPayload } from "./subprocess";
+
+type HookContextBase = {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+};
+
+type HookCommandControl = Omit<HookControl, "appendMessages"> & {
+	systemPrompt?: string;
+	appendMessages?: unknown[];
+};
+
+type HookCommandRunStartContext = HookContextBase & {
+	userMessage: string;
+};
+type HookCommandToolCallStartContext = HookContextBase & {
+	iteration: number;
+	call: { id: string; name: string; input: unknown };
+};
+type HookCommandToolCallEndContext = HookContextBase & {
+	iteration: number;
+	record: {
+		id: string;
+		name: string;
+		input: unknown;
+		output: unknown;
+		error?: string;
+		durationMs: number;
+		startedAt: Date;
+		endedAt: Date;
+	};
+};
+type HookCommandTurnEndContext = HookContextBase & {
+	iteration: number;
+	turn: unknown;
+};
+type HookCommandStopErrorContext = HookContextBase & {
+	iteration: number;
+	error: Error;
+};
+type HookCommandSessionShutdownContext = HookContextBase & {
+	reason?: string;
+};
+
+type HookRuntimeOptions = {
+	cwd: string;
+	workspacePath: string;
+	rootSessionId?: string;
+	logger?: BasicLogger;
+	toolCallTimeoutMs?: number;
+	/** Structured git + path metadata forwarded into every hook payload. */
+	workspaceInfo?: WorkspaceInfo;
+};
+
+function mapParams(input: unknown): Record<string, string> {
+	if (!input || typeof input !== "object") {
+		return {};
+	}
+	const output: Record<string, string> = {};
+	for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+		output[key] = typeof value === "string" ? value : JSON.stringify(value);
+	}
+	return output;
+}
+
+function logHookError(
+	logger: BasicLogger | undefined,
+	message: string,
+	error?: unknown,
+): void {
+	const detail = error instanceof Error ? `: ${error.message}` : "";
+	const text = `${message}${detail}`;
+	if (logger) {
+		try {
+			logger.log(text, {
+				severity: "warn",
+				...(error !== undefined ? { error } : {}),
+			});
+		} catch {
+			// Logging failures must not break hook execution.
+		}
+		return;
+	}
+	console.warn(text);
+}
+
+function mergeHookControls(
+	current: HookCommandControl | undefined,
+	next: HookCommandControl | undefined,
+): HookCommandControl | undefined {
+	if (!next) {
+		return current;
+	}
+	if (!current) {
+		return { ...next };
+	}
+	const contexts = [current.context, next.context]
+		.filter(
+			(value): value is string => typeof value === "string" && value.length > 0,
+		)
+		.join("\n");
+	const appendMessages = [
+		...(current.appendMessages ?? []),
+		...(next.appendMessages ?? []),
+	];
+	return {
+		cancel: current.cancel === true || next.cancel === true ? true : undefined,
+		review: current.review === true || next.review === true ? true : undefined,
+		context: contexts || undefined,
+		overrideInput:
+			next.overrideInput !== undefined
+				? next.overrideInput
+				: current.overrideInput,
+		systemPrompt:
+			next.systemPrompt !== undefined
+				? next.systemPrompt
+				: current.systemPrompt,
+		appendMessages: appendMessages.length > 0 ? appendMessages : undefined,
+	};
+}
+
+function parseHookControl(value: unknown): HookCommandControl | undefined {
+	if (!value || typeof value !== "object") {
+		return undefined;
+	}
+	const record = value as Record<string, unknown>;
+	const context =
+		typeof record.context === "string"
+			? record.context
+			: typeof record.contextModification === "string"
+				? record.contextModification
+				: typeof record.errorMessage === "string"
+					? record.errorMessage
+					: undefined;
+	return {
+		cancel: typeof record.cancel === "boolean" ? record.cancel : undefined,
+		review: typeof record.review === "boolean" ? record.review : undefined,
+		context,
+		overrideInput: Object.hasOwn(record, "overrideInput")
+			? record.overrideInput
+			: undefined,
+	};
+}
+
+function isAbortReason(reason?: string): boolean {
+	const value = String(reason ?? "").toLowerCase();
+	return (
+		value.includes("cancel") ||
+		value.includes("abort") ||
+		value.includes("interrupt")
+	);
+}
+
+function createPayloadBase(
+	ctx: HookContextBase,
+	options: HookRuntimeOptions,
+): Omit<HookEventPayload, "hookName"> {
+	const userId =
+		process.env.CLINE_USER_ID?.trim() || process.env.USER?.trim() || "unknown";
+	const sessionContext: HookSessionContext = {
+		rootSessionId: options.rootSessionId || ctx.conversationId,
+	};
+	return {
+		clineVersion: process.env.CLINE_VERSION?.trim() || "",
+		timestamp: new Date().toISOString(),
+		taskId: ctx.conversationId,
+		sessionContext,
+		workspaceRoots: options.workspacePath ? [options.workspacePath] : [],
+		workspaceInfo: options.workspaceInfo,
+		userId,
+		agent_id: ctx.agentId,
+		parent_agent_id: ctx.parentAgentId,
+	} as Omit<HookEventPayload, "hookName">;
+}
+
+type HookCommandMap = Partial<Record<HookEventName, string[][]>>;
+
+interface HookCommandResult {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+	parsedJson?: unknown;
+	parseError?: string;
+	timedOut?: boolean;
+}
+
+function parseHookStdout(stdout: string): {
+	parsedJson?: unknown;
+	parseError?: string;
+} {
+	const trimmed = stdout.trim();
+	if (!trimmed) {
+		return {};
+	}
+	const lines = trimmed
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const prefixed = lines
+		.filter((line) => line.startsWith("HOOK_CONTROL\t"))
+		.map((line) => line.slice("HOOK_CONTROL\t".length));
+	const candidate =
+		prefixed.length > 0 ? prefixed[prefixed.length - 1] : trimmed;
+	try {
+		return { parsedJson: JSON.parse(candidate) };
+	} catch (error) {
+		return {
+			parseError:
+				error instanceof Error
+					? error.message
+					: "Failed to parse hook stdout JSON",
+		};
+	}
+}
+
+async function writeToChildStdin(
+	child: ReturnType<typeof spawn>,
+	body: string,
+): Promise<void> {
+	const stdin = child.stdin;
+	if (!stdin) {
+		throw new Error("hook command failed to create stdin");
+	}
+
+	await new Promise<void>((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			stdin.off("error", onError);
+			stdin.off("finish", onFinish);
+			child.off("close", onChildClose);
+		};
+		const finish = (error?: Error | null) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			cleanup();
+			if (error) {
+				const code = (error as Error & { code?: string }).code;
+				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+					resolve();
+					return;
+				}
+				reject(error);
+				return;
+			}
+			resolve();
+		};
+		const onError = (error: Error) => finish(error);
+		const onFinish = () => finish();
+		const onChildClose = () => finish();
+		stdin.on("error", onError);
+		stdin.once("finish", onFinish);
+		child.once("close", onChildClose);
+		try {
+			stdin.end(body);
+		} catch (error) {
+			finish(error as Error);
+		}
+	});
+}
+
+async function runHookCommand(
+	payload: HookEventPayload,
+	options: {
+		command: string[];
+		cwd: string;
+		env?: NodeJS.ProcessEnv;
+		detached: boolean;
+		timeoutMs?: number;
+	},
+): Promise<HookCommandResult | undefined> {
+	if (options.command.length === 0) {
+		throw new Error("runHookCommand requires non-empty command");
+	}
+	try {
+		return await runHookCommandOnce(payload, options);
+	} catch (error) {
+		const fallbackCommand = getWindowsPythonFallbackCommand(
+			options.command,
+			process.platform,
+			error,
+		);
+		if (!fallbackCommand) {
+			throw error;
+		}
+		return await runHookCommandOnce(payload, {
+			...options,
+			command: fallbackCommand,
+		});
+	}
+}
+
+async function runHookCommandOnce(
+	payload: HookEventPayload,
+	options: {
+		command: string[];
+		cwd: string;
+		env?: NodeJS.ProcessEnv;
+		detached: boolean;
+		timeoutMs?: number;
+	},
+): Promise<HookCommandResult | undefined> {
+	const command = augmentNodeCommandForDebug(options.command, {
+		env: options.env,
+		debugRole: "hook",
+	});
+	const child = spawn(command[0], command.slice(1), {
+		cwd: options.cwd,
+		env: withResolvedClineBuildEnv(options.env),
+		stdio: options.detached
+			? ["pipe", "ignore", "ignore"]
+			: ["pipe", "pipe", "pipe"],
+		detached: options.detached,
+		// Prevent a console window from flashing on Windows (especially when
+		// detached, which would otherwise allocate a new console).
+		windowsHide: true,
+	});
+	const spawned = new Promise<void>((resolve) => {
+		child.once("spawn", () => resolve());
+	});
+	const childError = new Promise<never>((_, reject) => {
+		child.once("error", (error) => reject(error));
+	});
+
+	const body = JSON.stringify(payload);
+	await Promise.race([spawned, childError]);
+	await writeToChildStdin(child, body);
+
+	if (options.detached) {
+		child.unref();
+		return;
+	}
+
+	if (!child.stdout || !child.stderr) {
+		throw new Error("hook command failed to create stdout/stderr");
+	}
+	let stdout = "";
+	let stderr = "";
+	let timedOut = false;
+	let timeoutId: NodeJS.Timeout | undefined;
+	child.stdout.on("data", (chunk: Buffer | string) => {
+		stdout += chunk.toString();
+	});
+	child.stderr.on("data", (chunk: Buffer | string) => {
+		stderr += chunk.toString();
+	});
+
+	const result = new Promise<HookCommandResult>((resolve) => {
+		if ((options.timeoutMs ?? 0) > 0) {
+			timeoutId = setTimeout(() => {
+				timedOut = true;
+				child.kill("SIGKILL");
+			}, options.timeoutMs);
+		}
+		child.once("close", (exitCode) => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+			const { parsedJson, parseError } = parseHookStdout(stdout);
+			resolve({
+				exitCode,
+				stdout,
+				stderr,
+				parsedJson,
+				parseError,
+				timedOut,
+			});
+		});
+	});
+	return await Promise.race([result, childError]);
+}
+
+function parseShebangCommand(path: string): string[] | undefined {
+	try {
+		const content = readFileSync(path, "utf8");
+		const firstLine = content.split(/\r?\n/, 1)[0]?.trim();
+		if (!firstLine?.startsWith("#!")) {
+			return undefined;
+		}
+		const shebang = firstLine.slice(2).trim();
+		if (!shebang) {
+			return undefined;
+		}
+		const tokens = shebang.split(/\s+/).filter(Boolean);
+		return tokens.length > 0 ? tokens : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isMissingCommandError(error: unknown): boolean {
+	return !!(
+		error &&
+		typeof error === "object" &&
+		"code" in error &&
+		(error as { code?: unknown }).code === "ENOENT"
+	);
+}
+
+export function getWindowsPythonFallbackCommand(
+	command: string[],
+	platform = process.platform,
+	error?: unknown,
+): string[] | undefined {
+	if (platform !== "win32" || !isMissingCommandError(error)) {
+		return undefined;
+	}
+	if (command[0] !== "py" || command[1] !== "-3") {
+		return undefined;
+	}
+	return ["python", ...command.slice(2)];
+}
+
+function normalizeHookInterpreter(tokens: string[]): string[] | undefined {
+	if (tokens.length === 0) {
+		return undefined;
+	}
+	const [rawCommand, ...rest] = tokens;
+	const normalizedCommand = rawCommand.replace(/\\/g, "/").toLowerCase();
+	const commandName = normalizedCommand.split("/").at(-1) ?? normalizedCommand;
+
+	if (commandName === "env") {
+		return normalizeHookInterpreter(rest);
+	}
+
+	if (commandName === "bash" || commandName === "sh" || commandName === "zsh") {
+		return [commandName, ...rest];
+	}
+
+	if (commandName === "python3" || commandName === "python") {
+		return process.platform === "win32"
+			? ["py", "-3", ...rest]
+			: [commandName, ...rest];
+	}
+
+	return tokens;
+}
+
+function inferHookCommand(path: string): string[] {
+	const shebang = parseShebangCommand(path);
+	if (shebang && shebang.length > 0) {
+		return [...(normalizeHookInterpreter(shebang) ?? shebang), path];
+	}
+	const lowered = path.toLowerCase();
+	if (
+		lowered.endsWith(".sh") ||
+		lowered.endsWith(".bash") ||
+		lowered.endsWith(".zsh")
+	) {
+		return ["bash", path];
+	}
+	if (
+		lowered.endsWith(".js") ||
+		lowered.endsWith(".mjs") ||
+		lowered.endsWith(".cjs")
+	) {
+		return augmentNodeCommandForDebug(["node", path], {
+			debugRole: "hook",
+		});
+	}
+	if (
+		lowered.endsWith(".ts") ||
+		lowered.endsWith(".mts") ||
+		lowered.endsWith(".cts")
+	) {
+		return ["bun", "run", path];
+	}
+	if (lowered.endsWith(".py")) {
+		return process.platform === "win32"
+			? ["py", "-3", path]
+			: ["python3", path];
+	}
+	if (lowered.endsWith(".ps1")) {
+		return [
+			process.platform === "win32" ? "powershell" : "pwsh",
+			"-File",
+			path,
+		];
+	}
+	// Default to bash for legacy hook files with no extension/shebang.
+	return ["bash", path];
+}
+
+function createHookCommandMap(workspacePath: string): HookCommandMap {
+	const map: HookCommandMap = {};
+	for (const file of listHookConfigFiles(workspacePath)) {
+		if (!file.hookEventName) {
+			continue;
+		}
+		const hookEventName = file.hookEventName;
+		const existing = map[hookEventName] ?? [];
+		existing.push(inferHookCommand(file.path));
+		map[hookEventName] = existing;
+	}
+	return map;
+}
+
+async function runBlockingHookCommands(options: {
+	commands: string[][];
+	payload: HookEventPayload;
+	cwd: string;
+	logger?: BasicLogger;
+	timeoutMs?: number;
+}): Promise<HookCommandControl | undefined> {
+	let merged: HookCommandControl | undefined;
+	for (const command of options.commands) {
+		const commandLabel = command.join(" ");
+		try {
+			const result = await runHookCommand(options.payload, {
+				command,
+				cwd: options.cwd,
+				env: withResolvedClineBuildEnv(process.env),
+				detached: false,
+				timeoutMs: options.timeoutMs,
+			});
+			if (result?.timedOut) {
+				logHookError(options.logger, `hook command timed out: ${commandLabel}`);
+				continue;
+			}
+			if (result?.parseError) {
+				logHookError(
+					options.logger,
+					`hook command returned invalid JSON control output: ${commandLabel} (${result.parseError})`,
+				);
+				continue;
+			}
+			merged = mergeHookControls(merged, parseHookControl(result?.parsedJson));
+		} catch (error) {
+			logHookError(
+				options.logger,
+				`hook command failed: ${commandLabel}`,
+				error,
+			);
+		}
+	}
+	return merged;
+}
+
+function runAsyncHookCommands(options: {
+	commands: string[][];
+	payload: HookEventPayload;
+	cwd: string;
+	logger?: BasicLogger;
+}): void {
+	for (const command of options.commands) {
+		const commandLabel = command.join(" ");
+		void runHookCommand(options.payload, {
+			command,
+			cwd: options.cwd,
+			env: withResolvedClineBuildEnv(process.env),
+			detached: true,
+		}).catch((error) => {
+			logHookError(
+				options.logger,
+				`hook command failed: ${commandLabel}`,
+				error,
+			);
+		});
+	}
+}
+
+function baseContextFromSnapshot(
+	snapshot: AgentRunLifecycleContext["snapshot"],
+): HookContextBase {
+	return {
+		agentId: snapshot.agentId,
+		conversationId:
+			snapshot.conversationId ?? snapshot.runId ?? snapshot.agentId,
+		parentAgentId: snapshot.parentAgentId ?? null,
+	};
+}
+
+function runStartContext(
+	ctx: AgentRunLifecycleContext,
+	userMessage: string,
+): HookCommandRunStartContext {
+	return {
+		...baseContextFromSnapshot(ctx.snapshot),
+		userMessage,
+	};
+}
+
+function toolCallStartContext(
+	ctx: AgentBeforeToolContext,
+): HookCommandToolCallStartContext {
+	return {
+		...baseContextFromSnapshot(ctx.snapshot),
+		iteration: ctx.snapshot.iteration,
+		call: {
+			id: ctx.toolCall.toolCallId,
+			name: ctx.toolCall.toolName,
+			input: ctx.input,
+		},
+	};
+}
+
+function toolCallEndContext(
+	ctx: AgentAfterToolContext,
+): HookCommandToolCallEndContext {
+	return {
+		...baseContextFromSnapshot(ctx.snapshot),
+		iteration: ctx.snapshot.iteration,
+		record: {
+			id: ctx.toolCall.toolCallId,
+			name: ctx.toolCall.toolName,
+			input: ctx.input,
+			output: ctx.result.output,
+			error: ctx.result.isError ? String(ctx.result.output) : undefined,
+			durationMs: ctx.durationMs,
+			startedAt: ctx.startedAt,
+			endedAt: ctx.endedAt,
+		},
+	};
+}
+
+function textFromMessageContent(
+	content: readonly { type: string; text?: string }[],
+): string {
+	return content
+		.filter((part) => part.type === "text" && typeof part.text === "string")
+		.map((part) => part.text)
+		.join("");
+}
+
+function beforeToolResultFromControl(
+	control: HookCommandControl | undefined,
+): { stop?: boolean; reason?: string; input?: unknown } | undefined {
+	if (!control) {
+		return undefined;
+	}
+	const result: { stop?: boolean; reason?: string; input?: unknown } = {};
+	if (control.cancel === true) {
+		result.stop = true;
+	}
+	if (control.overrideInput !== undefined) {
+		result.input = control.overrideInput;
+	}
+	return Object.keys(result).length > 0 ? result : undefined;
+}
+
+export function createHookAuditHooks(options: {
+	rootSessionId?: string;
+	workspacePath: string;
+	workspaceInfo?: WorkspaceInfo;
+}): AgentHooks {
+	const runtimeOptions: HookRuntimeOptions = {
+		cwd: options.workspacePath,
+		workspacePath: options.workspacePath,
+		rootSessionId: options.rootSessionId,
+		workspaceInfo: options.workspaceInfo,
+	};
+
+	const append = (payload: HookEventPayload): void => {
+		const line = `${JSON.stringify({
+			ts: new Date().toISOString(),
+			...payload,
+		})}\n`;
+		const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+		const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+		ensureHookLogDir(logPath);
+		appendFileSync(logPath, line, "utf8");
+	};
+
+	return {
+		beforeRun: async (ctx: AgentRunLifecycleContext) => {
+			const commandCtx = runStartContext(ctx, "");
+			append({
+				...createPayloadBase(commandCtx, runtimeOptions),
+				hookName: "agent_start",
+				taskStart: { taskMetadata: {} },
+			});
+			return undefined;
+		},
+		beforeTool: async (ctx: AgentBeforeToolContext) => {
+			const commandCtx = toolCallStartContext(ctx);
+			append({
+				...createPayloadBase(commandCtx, runtimeOptions),
+				hookName: "tool_call",
+				iteration: commandCtx.iteration,
+				tool_call: {
+					id: commandCtx.call.id,
+					name: commandCtx.call.name,
+					input: commandCtx.call.input,
+				},
+				preToolUse: {
+					toolName: commandCtx.call.name,
+					parameters: mapParams(commandCtx.call.input),
+				},
+			});
+			return undefined;
+		},
+		afterTool: async (ctx: AgentAfterToolContext) => {
+			const commandCtx = toolCallEndContext(ctx);
+			append({
+				...createPayloadBase(commandCtx, runtimeOptions),
+				hookName: "tool_result",
+				iteration: commandCtx.iteration,
+				tool_result: commandCtx.record,
+				postToolUse: {
+					toolName: commandCtx.record.name,
+					parameters: mapParams(commandCtx.record.input),
+					result:
+						typeof commandCtx.record.output === "string"
+							? commandCtx.record.output
+							: JSON.stringify(commandCtx.record.output),
+					success: !commandCtx.record.error,
+					executionTimeMs: commandCtx.record.durationMs,
+				},
+			});
+			return undefined;
+		},
+		afterRun: async ({ snapshot, result }) => {
+			const base = baseContextFromSnapshot(snapshot);
+			if (result.status === "completed") {
+				append({
+					...createPayloadBase(base, runtimeOptions),
+					hookName: "agent_end",
+					iteration: result.iterations,
+					turn: { outputText: result.outputText, status: result.status },
+					taskComplete: { taskMetadata: {} },
+				});
+				return;
+			}
+			if (result.status === "aborted" || isAbortReason(result.error?.message)) {
+				append({
+					...createPayloadBase(base, runtimeOptions),
+					hookName: "agent_abort",
+					reason: result.error?.message,
+					taskCancel: { taskMetadata: {} },
+				});
+				return;
+			}
+			if (result.error) {
+				append({
+					...createPayloadBase(base, runtimeOptions),
+					hookName: "agent_error",
+					iteration: result.iterations,
+					error: {
+						name: result.error.name,
+						message: result.error.message,
+						stack: result.error.stack,
+					},
+				});
+			}
+		},
+		onEvent: async (event: AgentRuntimeEvent) => {
+			if (event.type !== "message-added" || event.message.role !== "user") {
+				return;
+			}
+			const commandCtx = runStartContext(
+				{ snapshot: event.snapshot },
+				textFromMessageContent(event.message.content),
+			);
+			append({
+				...createPayloadBase(commandCtx, runtimeOptions),
+				hookName: "prompt_submit",
+				userPromptSubmit: {
+					prompt: commandCtx.userMessage,
+					attachments: [],
+				},
+			});
+		},
+	};
+}
+
+export function createHookConfigFileHooks(
+	options: HookRuntimeOptions,
+): AgentHooks | undefined {
+	const commandMap = createHookCommandMap(options.workspacePath);
+	const hasAnyHooks = Object.values(commandMap).some(
+		(commands) => commands.length > 0,
+	);
+	if (!hasAnyHooks) {
+		return undefined;
+	}
+
+	const runAgentStart = async (
+		ctx: HookContextBase,
+		hookName: "agent_start" | "agent_resume",
+	): Promise<void> => {
+		const commandPaths = commandMap[hookName] ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload:
+				hookName === "agent_resume"
+					? {
+							...createPayloadBase(ctx, options),
+							hookName,
+							taskResume: {
+								taskMetadata: {},
+								previousState: {},
+							},
+						}
+					: {
+							...createPayloadBase(ctx, options),
+							hookName,
+							taskStart: { taskMetadata: {} },
+						},
+		});
+	};
+
+	const runPromptSubmit = async (
+		ctx: HookCommandRunStartContext,
+	): Promise<void> => {
+		const promptSubmit = commandMap.prompt_submit ?? [];
+		if (promptSubmit.length > 0) {
+			runAsyncHookCommands({
+				commands: promptSubmit,
+				cwd: options.cwd,
+				logger: options.logger,
+				payload: {
+					...createPayloadBase(ctx, options),
+					hookName: "prompt_submit",
+					userPromptSubmit: {
+						prompt: ctx.userMessage,
+						attachments: [],
+					},
+				},
+			});
+		}
+	};
+
+	const runToolCallStart = async (
+		ctx: HookCommandToolCallStartContext,
+	): Promise<HookCommandControl | undefined> => {
+		const commandPaths = commandMap.tool_call ?? [];
+		if (commandPaths.length === 0) {
+			return undefined;
+		}
+		return runBlockingHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			timeoutMs: options.toolCallTimeoutMs ?? 120000,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "tool_call",
+				iteration: ctx.iteration,
+				tool_call: {
+					id: ctx.call.id,
+					name: ctx.call.name,
+					input: ctx.call.input,
+				},
+				preToolUse: {
+					toolName: ctx.call.name,
+					parameters: mapParams(ctx.call.input),
+				},
+			},
+		});
+	};
+
+	const runToolCallEnd = async (
+		ctx: HookCommandToolCallEndContext,
+	): Promise<void> => {
+		const commandPaths = commandMap.tool_result ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "tool_result",
+				iteration: ctx.iteration,
+				tool_result: ctx.record,
+				postToolUse: {
+					toolName: ctx.record.name,
+					parameters: mapParams(ctx.record.input),
+					result:
+						typeof ctx.record.output === "string"
+							? ctx.record.output
+							: JSON.stringify(ctx.record.output),
+					success: !ctx.record.error,
+					executionTimeMs: ctx.record.durationMs,
+				},
+			},
+		});
+	};
+
+	const runTurnEnd = async (ctx: HookCommandTurnEndContext): Promise<void> => {
+		const commandPaths = commandMap.agent_end ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "agent_end",
+				iteration: ctx.iteration,
+				turn: ctx.turn,
+				taskComplete: { taskMetadata: {} },
+			},
+		});
+	};
+
+	const runStopError = async (
+		ctx: HookCommandStopErrorContext,
+	): Promise<void> => {
+		const commandPaths = commandMap.agent_error ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			},
+		});
+	};
+
+	const runSessionShutdown = async (
+		ctx: HookCommandSessionShutdownContext,
+	): Promise<void> => {
+		if (isAbortReason(ctx.reason)) {
+			const abortCommands = commandMap.agent_abort ?? [];
+			if (abortCommands.length > 0) {
+				runAsyncHookCommands({
+					commands: abortCommands,
+					cwd: options.cwd,
+					logger: options.logger,
+					payload: {
+						...createPayloadBase(ctx, options),
+						hookName: "agent_abort",
+						reason: ctx.reason,
+						taskCancel: { taskMetadata: {} },
+					},
+				});
+			}
+		}
+		const shutdownCommands = commandMap.session_shutdown ?? [];
+		if (shutdownCommands.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: shutdownCommands,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "session_shutdown",
+				reason: ctx.reason,
+			},
+		});
+	};
+
+	const hooks: AgentHooks = {};
+	if (
+		(commandMap.agent_start?.length ?? 0) > 0 ||
+		(commandMap.agent_resume?.length ?? 0) > 0 ||
+		(commandMap.prompt_submit?.length ?? 0) > 0
+	) {
+		if (
+			(commandMap.agent_start?.length ?? 0) > 0 ||
+			(commandMap.agent_resume?.length ?? 0) > 0
+		) {
+			hooks.beforeRun = async (ctx: AgentRunLifecycleContext) => {
+				const hookName =
+					process.env.CLINE_HOOK_AGENT_RESUME === "1"
+						? "agent_resume"
+						: "agent_start";
+				await runAgentStart(baseContextFromSnapshot(ctx.snapshot), hookName);
+				return undefined;
+			};
+		}
+		if ((commandMap.prompt_submit?.length ?? 0) > 0) {
+			hooks.onEvent = async (event: AgentRuntimeEvent) => {
+				if (event.type !== "message-added" || event.message.role !== "user") {
+					return;
+				}
+				await runPromptSubmit(
+					runStartContext(
+						{ snapshot: event.snapshot },
+						textFromMessageContent(event.message.content),
+					),
+				);
+			};
+		}
+	}
+	if ((commandMap.tool_call?.length ?? 0) > 0) {
+		hooks.beforeTool = async (ctx: AgentBeforeToolContext) => {
+			const control = await runToolCallStart(toolCallStartContext(ctx));
+			return beforeToolResultFromControl(control);
+		};
+	}
+	if ((commandMap.tool_result?.length ?? 0) > 0) {
+		hooks.afterTool = async (ctx: AgentAfterToolContext) => {
+			await runToolCallEnd(toolCallEndContext(ctx));
+			return undefined;
+		};
+	}
+	if ((commandMap.agent_end?.length ?? 0) > 0) {
+		hooks.afterRun = async ({ snapshot, result }) => {
+			if (result.status !== "completed") {
+				return;
+			}
+			await runTurnEnd({
+				...baseContextFromSnapshot(snapshot),
+				iteration: result.iterations,
+				turn: {
+					outputText: result.outputText,
+					status: result.status,
+				},
+			});
+		};
+	}
+	if (
+		(commandMap.agent_error?.length ?? 0) > 0 ||
+		(commandMap.agent_abort?.length ?? 0) > 0 ||
+		(commandMap.session_shutdown?.length ?? 0) > 0
+	) {
+		const previousAfterRun = hooks.afterRun;
+		hooks.afterRun = async (ctx) => {
+			await previousAfterRun?.(ctx);
+			const { snapshot, result } = ctx;
+			if (result.status === "aborted" || isAbortReason(result.error?.message)) {
+				await runSessionShutdown({
+					...baseContextFromSnapshot(snapshot),
+					reason: result.error?.message,
+				});
+				return;
+			}
+			if (result.error) {
+				await runStopError({
+					...baseContextFromSnapshot(snapshot),
+					iteration: result.iterations,
+					error: result.error,
+				});
+			}
+		};
+	}
+	return hooks;
+}
+
+export function createHookConfigFileExtension(
+	options: HookRuntimeOptions,
+): AgentExtension | undefined {
+	return createAgentHooksExtension(
+		"core.hook_config_files",
+		createHookConfigFileHooks(options),
+	);
+}
+
+function mergeHookFunction<K extends keyof AgentHooks>(
+	layers: AgentHooks[],
+	key: K,
+): AgentHooks[K] | undefined {
+	const handlers = layers
+		.map((layer) => layer[key])
+		.filter((handler) => typeof handler === "function");
+	if (handlers.length === 0) {
+		return undefined;
+	}
+	return (async (ctx: unknown) => {
+		let merged: Record<string, unknown> | undefined;
+		for (const handler of handlers) {
+			const next = await (handler as (arg: unknown) => unknown)(ctx);
+			if (!next || typeof next !== "object") {
+				continue;
+			}
+			const record = next as Record<string, unknown>;
+			merged = {
+				...(merged ?? {}),
+				...record,
+				stop:
+					merged?.stop === true || record.stop === true ? true : record.stop,
+				options:
+					merged?.options || record.options
+						? {
+								...((merged?.options as Record<string, unknown> | undefined) ??
+									{}),
+								...((record.options as Record<string, unknown> | undefined) ??
+									{}),
+							}
+						: undefined,
+			};
+		}
+		return merged;
+	}) as AgentHooks[K];
+}
+
+export function mergeAgentHooks(
+	layers: Array<AgentHooks | undefined>,
+): AgentHooks | undefined {
+	const activeLayers = layers.filter(
+		(layer): layer is AgentHooks => layer !== undefined,
+	);
+	if (activeLayers.length === 0) {
+		return undefined;
+	}
+
+	return {
+		beforeRun: mergeHookFunction(activeLayers, "beforeRun"),
+		afterRun: mergeHookFunction(activeLayers, "afterRun"),
+		beforeModel: mergeHookFunction(activeLayers, "beforeModel"),
+		afterModel: mergeHookFunction(activeLayers, "afterModel"),
+		beforeTool: mergeHookFunction(activeLayers, "beforeTool"),
+		afterTool: mergeHookFunction(activeLayers, "afterTool"),
+		onEvent: mergeHookFunction(activeLayers, "onEvent"),
+	};
+}
diff --git a/sdk/packages/core/src/hooks/index.ts b/sdk/packages/core/src/hooks/index.ts
new file mode 100644
index 0000000..af5dc88
--- /dev/null
+++ b/sdk/packages/core/src/hooks/index.ts
@@ -0,0 +1,34 @@
+export { createAgentHooksExtension } from "./hook-extension";
+export {
+	HOOK_CONFIG_FILE_EVENT_MAP,
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	type HookConfigFileEntry,
+	HookConfigFileName,
+	listHookConfigFiles,
+	resolveHooksConfigSearchPaths,
+	toHookConfigFileName,
+} from "./hook-file-config";
+export {
+	createHookAuditHooks,
+	createHookConfigFileExtension,
+	createHookConfigFileHooks,
+	mergeAgentHooks,
+} from "./hook-file-hooks";
+export {
+	createSubprocessHooks,
+	type HookEventName,
+	HookEventNameSchema,
+	type HookEventPayload,
+	HookEventPayloadSchema,
+	parseHookEventPayload,
+	type RunHookOptions,
+	type RunHookResult,
+	runHook,
+	type SubprocessHookControl,
+	type SubprocessHooksOptions,
+} from "./subprocess";
+export {
+	type RunSubprocessEventOptions,
+	type RunSubprocessEventResult,
+	runSubprocessEvent,
+} from "./subprocess-runner";
diff --git a/sdk/packages/core/src/hooks/subprocess-runner.ts b/sdk/packages/core/src/hooks/subprocess-runner.ts
new file mode 100644
index 0000000..ff9f625
--- /dev/null
+++ b/sdk/packages/core/src/hooks/subprocess-runner.ts
@@ -0,0 +1,199 @@
+import { spawn } from "node:child_process";
+import {
+	augmentNodeCommandForDebug,
+	withResolvedClineBuildEnv,
+} from "@cline/shared";
+
+export interface RunSubprocessEventOptions {
+	command: string[];
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	detached?: boolean;
+	timeoutMs?: number;
+	onSpawn?: (event: {
+		command: string[];
+		pid?: number;
+		detached: boolean;
+	}) => void;
+}
+
+export interface RunSubprocessEventResult {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+	parsedJson?: unknown;
+	parseError?: string;
+	timedOut?: boolean;
+}
+
+function parseStdout(stdout: string): {
+	parsedJson?: unknown;
+	parseError?: string;
+} {
+	const trimmed = stdout.trim();
+	if (!trimmed) {
+		return {};
+	}
+
+	const lines = trimmed
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const prefixed = lines
+		.filter((line) => line.startsWith("HOOK_CONTROL\t"))
+		.map((line) => line.slice("HOOK_CONTROL\t".length));
+
+	const candidate =
+		prefixed.length > 0 ? prefixed[prefixed.length - 1] : trimmed;
+	try {
+		return { parsedJson: JSON.parse(candidate) };
+	} catch (error) {
+		return {
+			parseError:
+				error instanceof Error
+					? error.message
+					: "Failed to parse subprocess stdout JSON",
+		};
+	}
+}
+
+function formatSpawnError(error: unknown, command: string[]): Error {
+	const err = error instanceof Error ? error : new Error(String(error));
+	const withCode = err as Error & { code?: string };
+	const commandLabel = command.join(" ");
+	if (withCode.code === "EACCES") {
+		return new Error(
+			`Failed to execute hook command "${commandLabel}" (EACCES). Configure hooks with an explicit interpreter/command array (for example: ["bash", "/path/to/script"]) or make the script executable with a valid shebang.`,
+		);
+	}
+	return new Error(
+		`Failed to execute hook command "${commandLabel}": ${err.message}`,
+	);
+}
+
+async function writeToChildStdin(
+	child: ReturnType<typeof spawn>,
+	payload: string,
+): Promise<void> {
+	const stdin = child.stdin;
+	if (!stdin) {
+		throw new Error("runSubprocessEvent failed to create stdin pipe");
+	}
+
+	await new Promise<void>((resolve, reject) => {
+		const onError = (error: Error) => {
+			stdin.off("error", onError);
+			const code = (error as Error & { code?: string }).code;
+			if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+				resolve();
+				return;
+			}
+			reject(error);
+		};
+		stdin.once("error", onError);
+		stdin.end(payload, (error?: Error | null) => {
+			stdin.off("error", onError);
+			if (error) {
+				const code = (error as Error & { code?: string }).code;
+				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+					resolve();
+					return;
+				}
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+
+export async function runSubprocessEvent(
+	payload: unknown,
+	options: RunSubprocessEventOptions,
+): Promise<RunSubprocessEventResult | undefined> {
+	const command = augmentNodeCommandForDebug(options.command, {
+		env: options.env,
+		debugRole: "hook",
+	});
+	if (!Array.isArray(command) || command.length === 0) {
+		throw new Error("runSubprocessEvent requires a non-empty command");
+	}
+
+	const detached = !!options.detached;
+	const child = spawn(command[0], command.slice(1), {
+		cwd: options.cwd,
+		env: withResolvedClineBuildEnv(options.env),
+		stdio: detached ? ["pipe", "ignore", "ignore"] : ["pipe", "pipe", "pipe"],
+		detached,
+		// Prevent a console window from flashing on Windows (especially when
+		// detached, which would otherwise allocate a new console).
+		windowsHide: true,
+	});
+	const spawned = new Promise<void>((resolve) => {
+		child.once("spawn", () => {
+			try {
+				options.onSpawn?.({
+					command,
+					pid: child.pid ?? undefined,
+					detached,
+				});
+			} catch {
+				// Logging callbacks must not break subprocess execution.
+			}
+			resolve();
+		});
+	});
+	const childError = new Promise<never>((_, reject) => {
+		child.once("error", (error) => {
+			reject(formatSpawnError(error, command));
+		});
+	});
+
+	await writeToChildStdin(child, JSON.stringify(payload));
+
+	if (detached) {
+		await Promise.race([spawned, childError]);
+		child.unref();
+		return;
+	}
+
+	if (!child.stdout || !child.stderr) {
+		throw new Error("runSubprocessEvent failed to create stdout/stderr pipes");
+	}
+
+	let stdout = "";
+	let stderr = "";
+	let timedOut = false;
+	let timeoutId: NodeJS.Timeout | undefined;
+
+	child.stdout.on("data", (chunk: Buffer | string) => {
+		stdout += chunk.toString();
+	});
+	child.stderr.on("data", (chunk: Buffer | string) => {
+		stderr += chunk.toString();
+	});
+
+	const result = new Promise<RunSubprocessEventResult>((resolve) => {
+		if ((options.timeoutMs ?? 0) > 0) {
+			timeoutId = setTimeout(() => {
+				timedOut = true;
+				child.kill("SIGKILL");
+			}, options.timeoutMs);
+		}
+		child.once("close", (exitCode) => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+			const { parsedJson, parseError } = parseStdout(stdout);
+			resolve({
+				exitCode,
+				stdout,
+				stderr,
+				parsedJson,
+				parseError,
+				timedOut,
+			});
+		});
+	});
+	return await Promise.race([result, childError]);
+}
diff --git a/sdk/packages/core/src/hooks/subprocess.ts b/sdk/packages/core/src/hooks/subprocess.ts
new file mode 100644
index 0000000..2a38239
--- /dev/null
+++ b/sdk/packages/core/src/hooks/subprocess.ts
@@ -0,0 +1,543 @@
+import {
+	type AgentAbortHookPayload,
+	type AgentAfterToolContext,
+	type AgentBeforeToolContext,
+	type AgentEndHookPayload,
+	type AgentErrorHookPayload,
+	type AgentHooks,
+	type AgentResumeHookPayload,
+	type AgentRunLifecycleContext,
+	type AgentRuntimeEvent,
+	type AgentStartHookPayload,
+	type HookControl,
+	type HookEventName,
+	HookEventNameSchema,
+	type HookEventPayload,
+	type HookEventPayloadBase,
+	HookEventPayloadSchema,
+	type HookSessionContextProvider,
+	type PostToolUseData,
+	type PreCompactData,
+	type PreCompactHookPayload,
+	type PreToolUseData,
+	type PromptSubmitHookPayload,
+	parseHookEventPayload,
+	resolveHookSessionContext,
+	type SessionShutdownHookPayload,
+	type TaskCancelData,
+	type TaskCompleteData,
+	type TaskResumeData,
+	type TaskStartData,
+	type ToolCallHookPayload,
+	type ToolResultHookPayload,
+	type UserPromptSubmitData,
+	type WorkspaceInfo,
+} from "@cline/shared";
+import { z } from "zod";
+import {
+	type RunSubprocessEventResult,
+	runSubprocessEvent,
+} from "./subprocess-runner";
+
+type AgentHookControl = Omit<HookControl, "appendMessages"> & {
+	appendMessages?: unknown[];
+};
+
+export interface HookOutput {
+	contextModification: string;
+	cancel: boolean;
+	review?: boolean;
+	errorMessage: string;
+}
+
+export const HookOutputSchema = z
+	.object({
+		contextModification: z.string().optional(),
+		cancel: z.boolean().optional(),
+		review: z.boolean().optional(),
+		errorMessage: z.string().optional(),
+		context: z.string().optional(),
+		overrideInput: z.unknown().optional(),
+	})
+	.passthrough();
+
+export { HookEventNameSchema, HookEventPayloadSchema, parseHookEventPayload };
+export type {
+	AgentAbortHookPayload,
+	AgentEndHookPayload,
+	AgentErrorHookPayload,
+	AgentResumeHookPayload,
+	AgentStartHookPayload,
+	HookEventName,
+	HookEventPayload,
+	HookEventPayloadBase,
+	PostToolUseData,
+	PreCompactData,
+	PreCompactHookPayload,
+	PreToolUseData,
+	PromptSubmitHookPayload,
+	SessionShutdownHookPayload,
+	TaskCancelData,
+	TaskCompleteData,
+	TaskResumeData,
+	TaskStartData,
+	ToolCallHookPayload,
+	ToolResultHookPayload,
+	UserPromptSubmitData,
+};
+
+export interface RunHookOptions {
+	command?: string[];
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	detached?: boolean;
+	timeoutMs?: number;
+	onSpawn?: (event: {
+		command: string[];
+		pid?: number;
+		detached: boolean;
+	}) => void;
+}
+
+export type RunHookResult = RunSubprocessEventResult;
+
+const DEFAULT_HOOK_COMMAND = ["agent", "hook"];
+
+export async function runHook(
+	payload: HookEventPayload,
+	options: RunHookOptions = {},
+): Promise<RunHookResult | undefined> {
+	const command = options.command ?? DEFAULT_HOOK_COMMAND;
+	return await runSubprocessEvent(payload, {
+		command,
+		cwd: options.cwd,
+		env: options.env,
+		detached: options.detached,
+		timeoutMs: options.timeoutMs,
+		onSpawn: options.onSpawn,
+	});
+}
+
+export interface SubprocessHooksOptions {
+	command?: string[];
+	cwd?: string;
+	/**
+	 * Structured workspace and git metadata forwarded into every hook payload
+	 * as `workspaceInfo`. Obtained from `generateWorkspaceInfo` at session
+	 * startup and passed here so hook scripts can inspect branch, commit, and
+	 * remote without running their own `git` commands.
+	 */
+	workspaceInfo?: WorkspaceInfo;
+	env?: NodeJS.ProcessEnv;
+	timeoutMs?: number;
+	onDispatchError?: (error: Error, payload: HookEventPayload) => void;
+	onDispatch?: (event: {
+		payload: HookEventPayload;
+		result?: RunHookResult;
+		detached: boolean;
+	}) => void;
+	onSpawn?: (event: {
+		command: string[];
+		pid?: number;
+		detached: boolean;
+	}) => void;
+	sessionContext?: HookSessionContextProvider;
+}
+
+export interface SubprocessHookControl {
+	hooks: AgentHooks;
+	shutdown: (ctx: {
+		agentId: string;
+		conversationId: string;
+		parentAgentId: string | null;
+		reason?: string;
+	}) => Promise<void>;
+}
+
+function toError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function toHookControl(value: unknown): AgentHookControl | undefined {
+	if (!value || typeof value !== "object") {
+		return undefined;
+	}
+	const parsed = HookOutputSchema.safeParse(value);
+	if (!parsed.success) {
+		return undefined;
+	}
+	const maybe = parsed.data;
+	const hasControlKey =
+		"cancel" in maybe ||
+		"review" in maybe ||
+		"context" in maybe ||
+		"contextModification" in maybe ||
+		"overrideInput" in maybe ||
+		"errorMessage" in maybe;
+	if (!hasControlKey) {
+		return undefined;
+	}
+	const contextFromHook =
+		typeof maybe.context === "string"
+			? maybe.context
+			: typeof maybe.contextModification === "string"
+				? maybe.contextModification
+				: typeof maybe.errorMessage === "string" &&
+						maybe.errorMessage.length > 0
+					? maybe.errorMessage
+					: undefined;
+	return {
+		cancel: typeof maybe.cancel === "boolean" ? maybe.cancel : undefined,
+		review: typeof maybe.review === "boolean" ? maybe.review : undefined,
+		context: contextFromHook,
+		overrideInput: Object.hasOwn(maybe, "overrideInput")
+			? maybe.overrideInput
+			: undefined,
+	};
+}
+
+function mapParams(input: unknown): Record<string, string> {
+	if (!input || typeof input !== "object") {
+		return {};
+	}
+	const output: Record<string, string> = {};
+	for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+		if (typeof value === "string") {
+			output[key] = value;
+		} else {
+			output[key] = JSON.stringify(value);
+		}
+	}
+	return output;
+}
+
+function basePayload(
+	hookName: HookEventName,
+	ctx: {
+		agentId: string;
+		conversationId: string;
+		parentAgentId: string | null;
+	},
+	options: SubprocessHooksOptions,
+): HookEventPayloadBase {
+	const env = options.env ?? process.env;
+	const userId = env.CLINE_USER_ID?.trim() || env.USER?.trim() || "unknown";
+	const workspaceRoot = options.cwd || process.cwd();
+	return {
+		clineVersion: env.CLINE_VERSION?.trim() || "",
+		hookName,
+		timestamp: new Date().toISOString(),
+		taskId: ctx.conversationId,
+		sessionContext: resolveHookSessionContext(options.sessionContext, {
+			hookName,
+			conversationId: ctx.conversationId,
+			agentId: ctx.agentId,
+			parentAgentId: ctx.parentAgentId,
+		}),
+		workspaceRoots: workspaceRoot ? [workspaceRoot] : [],
+		workspaceInfo: options.workspaceInfo,
+		userId,
+		agent_id: ctx.agentId,
+		parent_agent_id: ctx.parentAgentId,
+	};
+}
+
+function serializeHookError(error: Error): AgentErrorHookPayload["error"] {
+	return {
+		name: error.name,
+		message: error.message,
+		stack: error.stack,
+	};
+}
+
+function isAbortReason(reason?: string): boolean {
+	const value = String(reason ?? "").toLowerCase();
+	return (
+		value.includes("cancel") ||
+		value.includes("abort") ||
+		value.includes("interrupt")
+	);
+}
+
+function runtimeBase(ctx: AgentRunLifecycleContext): {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+} {
+	return {
+		agentId: ctx.snapshot.agentId,
+		conversationId:
+			ctx.snapshot.conversationId ?? ctx.snapshot.runId ?? ctx.snapshot.agentId,
+		parentAgentId: ctx.snapshot.parentAgentId ?? null,
+	};
+}
+
+function textFromRuntimeMessage(
+	content: readonly { type: string; text?: string }[],
+): string {
+	return content
+		.filter((part) => part.type === "text" && typeof part.text === "string")
+		.map((part) => part.text)
+		.join("");
+}
+
+function runtimeToolRecord(
+	ctx: AgentAfterToolContext,
+): ToolResultHookPayload["tool_result"] {
+	return {
+		id: ctx.toolCall.toolCallId,
+		name: ctx.toolCall.toolName,
+		input: ctx.input,
+		output: ctx.result.output,
+		error: ctx.result.isError ? String(ctx.result.output) : undefined,
+		durationMs: ctx.durationMs,
+		startedAt: ctx.startedAt,
+		endedAt: ctx.endedAt,
+	};
+}
+
+function beforeToolResultFromControl(
+	control: AgentHookControl | undefined,
+): { stop?: boolean; input?: unknown } | undefined {
+	if (!control) return undefined;
+	const result: { stop?: boolean; input?: unknown } = {};
+	if (control.cancel === true) result.stop = true;
+	if (control.overrideInput !== undefined) result.input = control.overrideInput;
+	return Object.keys(result).length > 0 ? result : undefined;
+}
+
+async function dispatchDetached(
+	payload: HookEventPayload,
+	options: SubprocessHooksOptions,
+): Promise<void> {
+	try {
+		const result = await runHook(payload, {
+			command: options.command,
+			cwd: options.cwd,
+			env: options.env,
+			detached: true,
+			onSpawn: options.onSpawn,
+		});
+		options.onDispatch?.({ payload, result, detached: true });
+	} catch (error) {
+		options.onDispatchError?.(toError(error), payload);
+	}
+}
+
+export function createSubprocessHooks(
+	options: SubprocessHooksOptions = {},
+): SubprocessHookControl {
+	const beforeRun = async (
+		ctx: AgentRunLifecycleContext,
+	): Promise<undefined> => {
+		const base = runtimeBase(ctx);
+		const isResume =
+			(options.env ?? process.env).CLINE_HOOK_AGENT_RESUME === "1";
+		if (isResume) {
+			const resumePayload: AgentResumeHookPayload = {
+				...basePayload("agent_resume", base, options),
+				hookName: "agent_resume",
+				taskResume: {
+					taskMetadata: {},
+					previousState: {},
+				},
+			};
+			await dispatchDetached(resumePayload, options);
+		} else {
+			const startPayload: AgentStartHookPayload = {
+				...basePayload("agent_start", base, options),
+				hookName: "agent_start",
+				taskStart: { taskMetadata: {} },
+			};
+			await dispatchDetached(startPayload, options);
+		}
+		return undefined;
+	};
+
+	const onEvent = async (event: AgentRuntimeEvent): Promise<void> => {
+		if (event.type !== "message-added" || event.message.role !== "user") {
+			return;
+		}
+		const base = {
+			agentId: event.snapshot.agentId,
+			conversationId:
+				event.snapshot.conversationId ??
+				event.snapshot.runId ??
+				event.snapshot.agentId,
+			parentAgentId: event.snapshot.parentAgentId ?? null,
+		};
+		const promptPayload: PromptSubmitHookPayload = {
+			...basePayload("prompt_submit", base, options),
+			hookName: "prompt_submit",
+			userPromptSubmit: {
+				prompt: textFromRuntimeMessage(event.message.content),
+				attachments: [],
+			},
+		};
+		await dispatchDetached(promptPayload, options);
+	};
+
+	const beforeTool = async (
+		ctx: AgentBeforeToolContext,
+	): Promise<{ stop?: boolean; input?: unknown } | undefined> => {
+		const base = {
+			agentId: ctx.snapshot.agentId,
+			conversationId:
+				ctx.snapshot.conversationId ??
+				ctx.snapshot.runId ??
+				ctx.snapshot.agentId,
+			parentAgentId: ctx.snapshot.parentAgentId ?? null,
+		};
+		const payload: ToolCallHookPayload = {
+			...basePayload("tool_call", base, options),
+			hookName: "tool_call",
+			iteration: ctx.snapshot.iteration,
+			tool_call: {
+				id: ctx.toolCall.toolCallId,
+				name: ctx.toolCall.toolName,
+				input: ctx.input,
+			},
+			preToolUse: {
+				toolName: ctx.toolCall.toolName,
+				parameters: mapParams(ctx.input),
+			},
+		};
+
+		try {
+			const result = await runHook(payload, {
+				command: options.command,
+				cwd: options.cwd,
+				env: options.env,
+				detached: false,
+				timeoutMs: options.timeoutMs,
+				onSpawn: options.onSpawn,
+			});
+			options.onDispatch?.({ payload, result, detached: false });
+			if (result?.timedOut) {
+				throw new Error("tool_call hook command timed out");
+			}
+			if (result?.parseError) {
+				throw new Error(
+					`tool_call hook produced invalid control JSON: ${result.parseError}`,
+				);
+			}
+			return beforeToolResultFromControl(toHookControl(result?.parsedJson));
+		} catch (error) {
+			options.onDispatchError?.(toError(error), payload);
+			return;
+		}
+	};
+
+	const afterTool = async (ctx: AgentAfterToolContext): Promise<undefined> => {
+		const record = runtimeToolRecord(ctx);
+		const base = {
+			agentId: ctx.snapshot.agentId,
+			conversationId:
+				ctx.snapshot.conversationId ??
+				ctx.snapshot.runId ??
+				ctx.snapshot.agentId,
+			parentAgentId: ctx.snapshot.parentAgentId ?? null,
+		};
+		const payload: ToolResultHookPayload = {
+			...basePayload("tool_result", base, options),
+			hookName: "tool_result",
+			iteration: ctx.snapshot.iteration,
+			tool_result: record,
+			postToolUse: {
+				toolName: record.name,
+				parameters: mapParams(record.input),
+				result:
+					typeof record.output === "string"
+						? record.output
+						: JSON.stringify(record.output),
+				success: !record.error,
+				executionTimeMs: record.durationMs,
+			},
+		};
+		await dispatchDetached(payload, options);
+		return undefined;
+	};
+
+	const afterRun: NonNullable<AgentHooks["afterRun"]> = async ({
+		snapshot,
+		result,
+	}) => {
+		const base = {
+			agentId: snapshot.agentId,
+			conversationId:
+				snapshot.conversationId ?? snapshot.runId ?? snapshot.agentId,
+			parentAgentId: snapshot.parentAgentId ?? null,
+		};
+		if (result.status === "completed") {
+			const payload: AgentEndHookPayload = {
+				...basePayload("agent_end", base, options),
+				hookName: "agent_end",
+				iteration: result.iterations,
+				turn: { outputText: result.outputText, status: result.status },
+				taskComplete: { taskMetadata: {} },
+			};
+			await dispatchDetached(payload, options);
+			return;
+		}
+		const hookName: HookEventName =
+			result.status === "aborted" || isAbortReason(result.error?.message)
+				? "agent_abort"
+				: "agent_error";
+		const payload: AgentErrorHookPayload | AgentAbortHookPayload =
+			hookName === "agent_error"
+				? {
+						...basePayload(hookName, base, options),
+						hookName,
+						iteration: result.iterations,
+						error: serializeHookError(
+							result.error ?? new Error("Agent run failed"),
+						),
+						taskCancel: { taskMetadata: {} },
+					}
+				: {
+						...basePayload(hookName, base, options),
+						hookName,
+						reason: result.error?.message,
+						taskCancel: { taskMetadata: {} },
+					};
+		await dispatchDetached(payload, options);
+	};
+
+	const shutdown = async ({
+		agentId,
+		conversationId,
+		parentAgentId,
+		reason,
+	}: {
+		agentId: string;
+		conversationId: string;
+		parentAgentId: string | null;
+		reason?: string;
+	}): Promise<void> => {
+		const payload: SessionShutdownHookPayload = {
+			...basePayload(
+				"session_shutdown",
+				{
+					agentId,
+					conversationId,
+					parentAgentId,
+				},
+				options,
+			),
+			hookName: "session_shutdown",
+			reason,
+		};
+		await dispatchDetached(payload, options);
+	};
+
+	return {
+		hooks: {
+			beforeRun,
+			beforeTool,
+			afterTool,
+			afterRun,
+			onEvent,
+		},
+		shutdown,
+	};
+}
diff --git a/sdk/packages/core/src/hub/client/connect.test.ts b/sdk/packages/core/src/hub/client/connect.test.ts
new file mode 100644
index 0000000..178cebb
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/connect.test.ts
@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { resolveHubUrl } from "./connect";
+
+const envSnapshot = {
+	CLINE_HUB_DISCOVERY_PATH: process.env.CLINE_HUB_DISCOVERY_PATH,
+	CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+	CLINE_BUILD_ENV: process.env.CLINE_BUILD_ENV,
+};
+
+beforeEach(() => {
+	// Pin to production so default port assertions are deterministic regardless
+	// of the ambient build env (e.g. when vitest sets CLINE_BUILD_ENV=development).
+	process.env.CLINE_BUILD_ENV = "production";
+});
+
+afterEach(() => {
+	process.env.CLINE_HUB_DISCOVERY_PATH = envSnapshot.CLINE_HUB_DISCOVERY_PATH;
+	process.env.CLINE_DATA_DIR = envSnapshot.CLINE_DATA_DIR;
+	if (envSnapshot.CLINE_BUILD_ENV === undefined) {
+		delete process.env.CLINE_BUILD_ENV;
+	} else {
+		process.env.CLINE_BUILD_ENV = envSnapshot.CLINE_BUILD_ENV;
+	}
+	vi.useRealTimers();
+	vi.restoreAllMocks();
+});
+
+describe("resolveHubUrl", () => {
+	it("prefers discovered hub URL when no explicit endpoint is provided", async () => {
+		const discoveryPath = "/tmp/test-hub-discovery.json";
+		process.env.CLINE_HUB_DISCOVERY_PATH = discoveryPath;
+		vi.spyOn(
+			await import("../discovery"),
+			"readHubDiscovery",
+		).mockResolvedValue({
+			hubId: "hub-test",
+			protocolVersion: "v1",
+			authToken: "test-token",
+			host: "127.0.0.1",
+			port: 25463,
+			url: "ws://127.0.0.1:25463/hub",
+			startedAt: new Date(0).toISOString(),
+			updatedAt: new Date(0).toISOString(),
+		});
+
+		await expect(resolveHubUrl()).resolves.toBe("ws://127.0.0.1:25463/hub");
+	});
+
+	it("uses the shared discovery owner in development builds", async () => {
+		delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-connect-test-data";
+		process.env.CLINE_BUILD_ENV = "development";
+		const readHubDiscovery = vi
+			.spyOn(await import("../discovery"), "readHubDiscovery")
+			.mockResolvedValue({
+				hubId: "hub-test",
+				protocolVersion: "v1",
+				authToken: "test-token",
+				host: "127.0.0.1",
+				port: 25466,
+				url: "ws://127.0.0.1:25466/hub",
+				startedAt: new Date(0).toISOString(),
+				updatedAt: new Date(0).toISOString(),
+			});
+
+		await expect(resolveHubUrl()).resolves.toBe("ws://127.0.0.1:25466/hub");
+
+		const discoveryPath = readHubDiscovery.mock.calls[0]?.[0].replaceAll(
+			"\\",
+			"/",
+		);
+		expect(discoveryPath).toContain("/locks/hub/owners/");
+		expect(discoveryPath).not.toBe(
+			"/tmp/cline-connect-test-data/locks/hub/production.json",
+		);
+	});
+
+	it("falls back to the default endpoint when no discovery file exists", async () => {
+		process.env.CLINE_HUB_DISCOVERY_PATH = "/tmp/missing-hub-discovery.json";
+		vi.spyOn(
+			await import("../discovery"),
+			"readHubDiscovery",
+		).mockResolvedValue(undefined);
+
+		await expect(resolveHubUrl()).resolves.toBe("ws://127.0.0.1:25463/hub");
+	});
+
+	it("uses an explicit endpoint without consulting discovery", async () => {
+		const readHubDiscovery = vi.spyOn(
+			await import("../discovery"),
+			"readHubDiscovery",
+		);
+
+		await expect(
+			resolveHubUrl({
+				host: "0.0.0.0",
+				port: 9321,
+				pathname: "/custom",
+			}),
+		).resolves.toBe("ws://0.0.0.0:9321/custom");
+		expect(readHubDiscovery).not.toHaveBeenCalled();
+	});
+});
diff --git a/sdk/packages/core/src/hub/client/connect.ts b/sdk/packages/core/src/hub/client/connect.ts
new file mode 100644
index 0000000..1aa8cd3
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/connect.ts
@@ -0,0 +1,197 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	HubTransportFrame,
+} from "@cline/shared";
+import { resolveClineBuildEnv } from "@cline/shared";
+import { createHubServerUrl, readHubDiscovery } from "../discovery";
+import {
+	type HubEndpointOverrides,
+	resolveHubEndpointOptions,
+} from "../discovery/defaults";
+import {
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+} from "../discovery/workspace";
+
+export interface HubConnection {
+	send(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	close(): void;
+}
+
+export interface HubCommandRequest
+	extends Omit<HubCommandEnvelope, "version" | "clientId"> {
+	version?: HubCommandEnvelope["version"];
+	clientId?: string;
+}
+
+function normalizeHubConnectionError(error: unknown, url: string): Error {
+	if (error instanceof Error) {
+		return error;
+	}
+	if (
+		error &&
+		typeof error === "object" &&
+		"message" in error &&
+		typeof (error as { message?: unknown }).message === "string" &&
+		(error as { message: string }).message.trim()
+	) {
+		return new Error((error as { message: string }).message.trim());
+	}
+	const eventType =
+		error &&
+		typeof error === "object" &&
+		"type" in error &&
+		typeof (error as { type?: unknown }).type === "string"
+			? (error as { type: string }).type.trim()
+			: "";
+	return new Error(
+		eventType
+			? `Failed to connect to hub at ${url} (${eventType} event before socket open).`
+			: `Failed to connect to hub at ${url}.`,
+	);
+}
+
+const HUB_AUTH_PROTOCOL_PREFIX = "cline-hub-auth.";
+
+function hasExplicitEndpoint(overrides: HubEndpointOverrides): boolean {
+	return (
+		overrides.host !== undefined ||
+		overrides.port !== undefined ||
+		overrides.pathname !== undefined
+	);
+}
+
+function sameHubEndpoint(left: string, right: string): boolean {
+	const leftUrl = new URL(left);
+	const rightUrl = new URL(right);
+	leftUrl.search = "";
+	leftUrl.hash = "";
+	rightUrl.search = "";
+	rightUrl.hash = "";
+	return leftUrl.toString() === rightUrl.toString();
+}
+
+function resolveDefaultHubOwnerContext() {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+async function resolveHubUrlAuthToken(url: URL): Promise<string | undefined> {
+	const queryToken = url.searchParams.get("authToken")?.trim();
+	url.searchParams.delete("authToken");
+	if (queryToken) {
+		return queryToken;
+	}
+	const owner = resolveDefaultHubOwnerContext();
+	const discovery = await readHubDiscovery(owner.discoveryPath);
+	if (discovery?.url && sameHubEndpoint(url.toString(), discovery.url)) {
+		return discovery.authToken;
+	}
+	return undefined;
+}
+
+export async function resolveHubUrl(
+	overrides: HubEndpointOverrides = {},
+): Promise<string> {
+	const endpoint = resolveHubEndpointOptions(overrides);
+	if (!hasExplicitEndpoint(overrides)) {
+		const owner = resolveDefaultHubOwnerContext();
+		const discovery = await readHubDiscovery(owner.discoveryPath);
+		if (discovery?.url) {
+			return discovery.url;
+		}
+	}
+	return createHubServerUrl(endpoint.host, endpoint.port, endpoint.pathname);
+}
+
+export async function connectToHub(url: string): Promise<HubConnection> {
+	return await new Promise((resolve, reject) => {
+		void (async () => {
+			const parsed = new URL(url);
+			const authToken = await resolveHubUrlAuthToken(parsed);
+			parsed.hash = "";
+			const ws = new WebSocket(
+				parsed.toString(),
+				authToken ? [`${HUB_AUTH_PROTOCOL_PREFIX}${authToken}`] : undefined,
+			);
+			const pending = new Map<
+				string,
+				{
+					resolve: (reply: HubReplyEnvelope) => void;
+					reject: (error: unknown) => void;
+				}
+			>();
+			let counter = 0;
+
+			ws.addEventListener("open", () => {
+				resolve({
+					send(envelope) {
+						const requestId = envelope.requestId ?? `hub-client-${++counter}`;
+						return new Promise<HubReplyEnvelope>((res, rej) => {
+							pending.set(requestId, { resolve: res, reject: rej });
+							const frame: HubTransportFrame = {
+								kind: "command",
+								envelope: { ...envelope, requestId },
+							};
+							ws.send(JSON.stringify(frame));
+						});
+					},
+					close() {
+						ws.close();
+					},
+				});
+			});
+
+			ws.addEventListener("message", (event) => {
+				const frame = JSON.parse(String(event.data)) as HubTransportFrame;
+				if (frame.kind === "reply" && frame.envelope.requestId) {
+					const entry = pending.get(frame.envelope.requestId);
+					if (entry) {
+						pending.delete(frame.envelope.requestId);
+						entry.resolve(frame.envelope);
+					}
+				}
+			});
+
+			ws.addEventListener("close", () => {
+				for (const entry of pending.values()) {
+					entry.reject(new Error("Hub connection closed"));
+				}
+				pending.clear();
+			});
+
+			ws.addEventListener("error", (error) => {
+				reject(normalizeHubConnectionError(error, url));
+			});
+		})().catch(reject);
+	});
+}
+
+export async function probeHubConnection(url: string): Promise<boolean> {
+	try {
+		const connection = await connectToHub(url);
+		connection.close();
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function sendHubCommand(
+	overrides: HubEndpointOverrides,
+	envelope: HubCommandRequest,
+): Promise<HubReplyEnvelope> {
+	const url = await resolveHubUrl(overrides);
+	const connection = await connectToHub(url);
+	try {
+		return await connection.send({
+			version: envelope.version ?? "v1",
+			clientId: envelope.clientId ?? "hub-client",
+			...envelope,
+		});
+	} finally {
+		connection.close();
+	}
+}
diff --git a/sdk/packages/core/src/hub/client/index.test.ts b/sdk/packages/core/src/hub/client/index.test.ts
new file mode 100644
index 0000000..bf08686
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/index.test.ts
@@ -0,0 +1,1140 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	HubTransportError,
+	isHubReconnectableTransportError,
+	NodeHubClient,
+} from "../client";
+
+type SocketListener = (...args: unknown[]) => void;
+type MessageListener = (event: { data: string }) => void;
+type GenericListener = (...args: unknown[]) => void;
+
+class MockWebSocket {
+	static readonly CONNECTING = 0;
+	static readonly OPEN = 1;
+	static readonly CLOSING = 2;
+	static readonly CLOSED = 3;
+	static instances: MockWebSocket[] = [];
+
+	readyState = MockWebSocket.CONNECTING;
+	readonly sentFrames: unknown[] = [];
+	private readonly listeners = new Map<string, SocketListener[]>();
+
+	constructor(public readonly url: string) {
+		MockWebSocket.instances.push(this);
+		queueMicrotask(() => {
+			this.readyState = MockWebSocket.OPEN;
+			this.emit("open");
+		});
+	}
+
+	static reset(): void {
+		MockWebSocket.instances = [];
+	}
+
+	send(data: string): void {
+		const frame = JSON.parse(data) as {
+			kind?: string;
+			envelope?: { requestId?: string };
+		};
+		this.sentFrames.push(frame);
+		if (frame.kind === "command" && frame.envelope?.requestId) {
+			queueMicrotask(() => {
+				this.emit("message", {
+					data: JSON.stringify({
+						kind: "reply",
+						envelope: {
+							version: "v1",
+							command: "client.register",
+							requestId: frame.envelope?.requestId,
+							ok: true,
+							clientId: "hub",
+							payload: {},
+						},
+					}),
+				});
+			});
+		}
+	}
+
+	close(): void {
+		this.readyState = MockWebSocket.CLOSED;
+		queueMicrotask(() => {
+			this.emit("close", { code: 1000, reason: "" });
+		});
+	}
+
+	addEventListener(type: string, listener: SocketListener): void {
+		const listeners = this.listeners.get(type) ?? [];
+		listeners.push(listener);
+		this.listeners.set(type, listeners);
+	}
+
+	emit(type: string, ...args: unknown[]): void {
+		for (const listener of this.listeners.get(type) ?? []) {
+			listener(...args);
+		}
+	}
+}
+
+class FakeWebSocket {
+	static instances: FakeWebSocket[] = [];
+
+	public readyState = 0;
+	private readonly listeners = new Map<string, Set<GenericListener>>();
+
+	constructor(_url: string) {
+		FakeWebSocket.instances.push(this);
+	}
+
+	addEventListener(type: string, listener: GenericListener): void {
+		const current = this.listeners.get(type) ?? new Set<GenericListener>();
+		current.add(listener);
+		this.listeners.set(type, current);
+	}
+
+	send(data: string): void {
+		const frame = JSON.parse(data) as {
+			kind?: string;
+			envelope?: { requestId?: string; command?: string };
+		};
+		if (
+			frame.kind === "command" &&
+			frame.envelope?.command === "client.register" &&
+			frame.envelope.requestId
+		) {
+			queueMicrotask(() => {
+				this.emit("message", {
+					data: JSON.stringify({
+						kind: "reply",
+						envelope: {
+							version: "v1",
+							requestId: frame.envelope?.requestId,
+							ok: true,
+							payload: {},
+						},
+					}),
+				});
+			});
+		}
+	}
+
+	close(): void {
+		this.readyState = 3;
+		this.emit("close", { code: 1000, reason: "" });
+	}
+
+	open(): void {
+		this.readyState = 1;
+		this.emit("open");
+	}
+
+	fail(payload?: unknown): void {
+		this.emit("error", payload);
+	}
+
+	private emit(type: string, payload?: unknown): void {
+		for (const listener of this.listeners.get(type) ?? []) {
+			if (type === "message") {
+				(listener as MessageListener)(payload as { data: string });
+				continue;
+			}
+			listener(payload);
+		}
+	}
+}
+
+describe("NodeHubClient", () => {
+	describe("subscription re-registration", () => {
+		afterEach(() => {
+			MockWebSocket.reset();
+			vi.unstubAllGlobals();
+		});
+
+		it("re-subscribes global listeners without sending the wildcard sentinel", async () => {
+			vi.stubGlobal("WebSocket", MockWebSocket);
+
+			const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+			await client.connect();
+			client.subscribe(() => {});
+
+			const firstSocket = MockWebSocket.instances[0];
+			expect(firstSocket.sentFrames).toContainEqual({
+				kind: "stream.subscribe",
+				clientId: client.getClientId(),
+			});
+
+			firstSocket.emit("close", { code: 1006, reason: "" });
+
+			await client.connect();
+
+			const secondSocket = MockWebSocket.instances[1];
+			expect(secondSocket.sentFrames).toContainEqual({
+				kind: "stream.subscribe",
+				clientId: client.getClientId(),
+			});
+			expect(secondSocket.sentFrames).not.toContainEqual({
+				kind: "stream.subscribe",
+				clientId: client.getClientId(),
+				sessionId: "*",
+			});
+		});
+
+		it("reconnects and re-subscribes active listeners after an idle close", async () => {
+			vi.useFakeTimers();
+			vi.stubGlobal("WebSocket", MockWebSocket);
+
+			try {
+				const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+				await client.connect();
+				client.subscribe(() => {});
+
+				const firstSocket = MockWebSocket.instances[0];
+				firstSocket.emit("close", { code: 1006, reason: "Connection ended" });
+
+				await vi.advanceTimersByTimeAsync(251);
+				await Promise.resolve();
+				await Promise.resolve();
+
+				const secondSocket = MockWebSocket.instances[1];
+				expect(secondSocket).toBeDefined();
+				expect(secondSocket.sentFrames).toContainEqual({
+					kind: "stream.subscribe",
+					clientId: client.getClientId(),
+				});
+
+				await client.dispose();
+			} finally {
+				vi.useRealTimers();
+			}
+		});
+
+		it("unregisters before closing when disposed", async () => {
+			vi.stubGlobal("WebSocket", MockWebSocket);
+
+			const client = new NodeHubClient({
+				url: "ws://127.0.0.1:25463/hub",
+				clientType: "code-sidecar",
+			});
+			await client.connect();
+			const socket = MockWebSocket.instances[0];
+
+			await client.dispose();
+
+			expect(socket.sentFrames).toContainEqual(
+				expect.objectContaining({
+					kind: "command",
+					envelope: expect.objectContaining({
+						command: "client.unregister",
+						clientId: client.getClientId(),
+					}),
+				}),
+			);
+			expect(socket.readyState).toBe(MockWebSocket.CLOSED);
+		});
+
+		it("ignores stale close events from retired sockets", async () => {
+			vi.stubGlobal("WebSocket", MockWebSocket);
+
+			const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+			await client.connect();
+			client.close();
+
+			await expect(client.connect()).resolves.toBeUndefined();
+
+			expect(MockWebSocket.instances).toHaveLength(2);
+			expect(MockWebSocket.instances[1]?.sentFrames).toContainEqual(
+				expect.objectContaining({
+					kind: "command",
+					envelope: expect.objectContaining({
+						command: "client.register",
+						clientId: client.getClientId(),
+					}),
+				}),
+			);
+
+			await client.dispose();
+		});
+	});
+
+	describe("timeouts", () => {
+		const originalWebSocket = globalThis.WebSocket;
+
+		beforeEach(() => {
+			vi.useFakeTimers();
+			FakeWebSocket.instances = [];
+			(
+				globalThis as unknown as { WebSocket?: typeof FakeWebSocket }
+			).WebSocket = FakeWebSocket;
+		});
+
+		afterEach(() => {
+			vi.useRealTimers();
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+		});
+
+		it("times out when the hub connection never opens", async () => {
+			const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+			const connectPromise = client.connect();
+			const expectation = expect(connectPromise).rejects.toThrow(
+				"Timed out connecting to hub after 8000ms",
+			);
+
+			await vi.advanceTimersByTimeAsync(8_001);
+			await expectation;
+			await expect(connectPromise).rejects.toMatchObject({
+				name: "HubTransportError",
+				code: "hub_connect_timeout",
+			});
+		});
+
+		it("times out when a hub command never replies", async () => {
+			const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+			const connectPromise = client.connect();
+			const socket = FakeWebSocket.instances[0];
+			if (!socket) {
+				throw new Error("expected fake websocket instance");
+			}
+			socket.open();
+			await connectPromise;
+
+			const commandPromise = client.command("client.list");
+			const expectation = expect(commandPromise).rejects.toThrow(
+				"Hub command client.list timed out after 30000ms",
+			);
+			await vi.advanceTimersByTimeAsync(30_001);
+			await expectation;
+		});
+
+		it("allows commands to opt out of the reply timeout", async () => {
+			const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+			const connectPromise = client.connect();
+			const socket = FakeWebSocket.instances[0];
+			if (!socket) {
+				throw new Error("expected fake websocket instance");
+			}
+			socket.open();
+			await connectPromise;
+
+			const commandPromise = client.command(
+				"client.list",
+				undefined,
+				undefined,
+				{ timeoutMs: null },
+			);
+			await vi.advanceTimersByTimeAsync(30_001);
+
+			let settled = false;
+			void commandPromise.then(
+				() => {
+					settled = true;
+				},
+				() => {
+					settled = true;
+				},
+			);
+			await Promise.resolve();
+
+			expect(settled).toBe(false);
+			const requestId = [
+				...(
+					client as unknown as { pendingReplies: Map<string, unknown> }
+				).pendingReplies.keys(),
+			][0];
+
+			(
+				socket as unknown as { emit: (type: string, payload: unknown) => void }
+			).emit("message", {
+				data: JSON.stringify({
+					kind: "reply",
+					envelope: {
+						version: "v1",
+						requestId,
+						ok: true,
+						payload: { clients: [] },
+					},
+				}),
+			});
+			await expect(commandPromise).resolves.toMatchObject({
+				ok: true,
+				payload: { clients: [] },
+			});
+		});
+	});
+
+	it("normalizes websocket error events during connect", async () => {
+		const originalWebSocket = globalThis.WebSocket;
+		(globalThis as unknown as { WebSocket?: typeof FakeWebSocket }).WebSocket =
+			FakeWebSocket;
+		FakeWebSocket.instances = [];
+
+		const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+		const connectPromise = client.connect();
+		const socket = FakeWebSocket.instances[0];
+		if (!socket) {
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+			throw new Error("expected fake websocket instance");
+		}
+
+		socket.fail({ type: "error" });
+
+		try {
+			await expect(connectPromise).rejects.toThrow(
+				"Failed to connect to hub at ws://127.0.0.1:25463/hub (error event before socket open).",
+			);
+		} finally {
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+		}
+	});
+
+	it("surfaces websocket error messages during connect", async () => {
+		const originalWebSocket = globalThis.WebSocket;
+		(globalThis as unknown as { WebSocket?: typeof FakeWebSocket }).WebSocket =
+			FakeWebSocket;
+		FakeWebSocket.instances = [];
+
+		const client = new NodeHubClient({ url: "ws://127.0.0.1:25463/hub" });
+		const connectPromise = client.connect();
+		const socket = FakeWebSocket.instances[0];
+		if (!socket) {
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+			throw new Error("expected fake websocket instance");
+		}
+
+		socket.fail({ type: "error", message: "socket unavailable" });
+
+		try {
+			await expect(connectPromise).rejects.toThrow("socket unavailable");
+		} finally {
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+		}
+	});
+
+	it("marks transport errors as reconnectable", () => {
+		expect(
+			isHubReconnectableTransportError(
+				new HubTransportError("hub_connection_closed", "closed"),
+			),
+		).toBe(true);
+		expect(isHubReconnectableTransportError(new Error("closed"))).toBe(false);
+	});
+
+	it("rediscovers the local hub and retries commands after transport close", async () => {
+		vi.resetModules();
+		const originalWebSocket = globalThis.WebSocket;
+		const recoveredUrl = "ws://127.0.0.1:25464/hub";
+		const record = {
+			hubId: "hub-test",
+			protocolVersion: "v1",
+			buildId: "test-build",
+			authToken: "token",
+			host: "127.0.0.1",
+			port: 25464,
+			url: recoveredUrl,
+			startedAt: new Date().toISOString(),
+			updatedAt: new Date().toISOString(),
+		};
+
+		class RecoveryWebSocket {
+			readyState = 0;
+			private failedCommand = false;
+			private readonly listeners = new Map<string, Set<GenericListener>>();
+
+			constructor(
+				private readonly url: string,
+				_protocols?: string | string[],
+			) {
+				queueMicrotask(() => {
+					this.readyState = 1;
+					this.emit("open");
+				});
+			}
+
+			addEventListener(type: string, listener: GenericListener): void {
+				const current = this.listeners.get(type) ?? new Set<GenericListener>();
+				current.add(listener);
+				this.listeners.set(type, current);
+			}
+
+			send(data: string): void {
+				const frame = JSON.parse(data) as {
+					kind?: string;
+					envelope?: { requestId?: string; command?: string };
+				};
+				if (frame.kind !== "command" || !frame.envelope?.requestId) {
+					return;
+				}
+				if (frame.envelope.command === "client.register") {
+					queueMicrotask(() => {
+						this.emit("message", {
+							data: JSON.stringify({
+								kind: "reply",
+								envelope: {
+									version: "v1",
+									requestId: frame.envelope?.requestId,
+									ok: true,
+									payload: {},
+								},
+							}),
+						});
+					});
+					return;
+				}
+				if (this.url.includes(":25463/") && !this.failedCommand) {
+					this.failedCommand = true;
+					queueMicrotask(() => {
+						this.readyState = 3;
+						this.emit("close", { code: 1006, reason: "" });
+					});
+					return;
+				}
+				queueMicrotask(() => {
+					this.emit("message", {
+						data: JSON.stringify({
+							kind: "reply",
+							envelope: {
+								version: "v1",
+								requestId: frame.envelope?.requestId,
+								ok: true,
+								payload: { clients: [] },
+							},
+						}),
+					});
+				});
+			}
+
+			close(): void {
+				this.readyState = 3;
+				this.emit("close", { code: 1000, reason: "" });
+			}
+
+			private emit(type: string, payload?: unknown): void {
+				for (const listener of this.listeners.get(type) ?? []) {
+					if (type === "message") {
+						(listener as MessageListener)(payload as { data: string });
+						continue;
+					}
+					listener(payload);
+				}
+			}
+		}
+
+		(
+			globalThis as unknown as { WebSocket?: typeof RecoveryWebSocket }
+		).WebSocket = RecoveryWebSocket;
+		vi.doMock("../daemon", () => ({
+			spawnDetachedHubServerWithRetry: vi.fn(async () => undefined),
+		}));
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery-recovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				resolveHubBuildId: () => "test-build",
+				readHubDiscovery: vi.fn(async () => record),
+				probeHubServer: vi.fn(async (url: string) =>
+					url.includes(":25464/") ? record : undefined,
+				),
+				clearHubDiscovery: vi.fn(async () => undefined),
+			};
+		});
+
+		try {
+			const { NodeHubClient: DynamicClient, rememberRecoverableLocalHubUrl } =
+				await import(".");
+			rememberRecoverableLocalHubUrl("ws://127.0.0.1:25463/hub");
+			const client = new DynamicClient({
+				url: "ws://127.0.0.1:25463/hub",
+				workspaceRoot: "/tmp/project",
+				cwd: "/tmp/project",
+			});
+
+			await expect(client.command("client.list")).resolves.toMatchObject({
+				ok: true,
+				payload: { clients: [] },
+			});
+			expect(client.getUrl()).toBe(recoveredUrl);
+			await client.dispose();
+		} finally {
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+			vi.resetModules();
+		}
+	});
+
+	it("does not rediscover explicit local hub endpoints", async () => {
+		vi.resetModules();
+		const originalWebSocket = globalThis.WebSocket;
+		const originalUrl = "ws://127.0.0.1:25463/hub";
+		const recoveredUrl = "ws://127.0.0.1:25464/hub";
+		const record = {
+			hubId: "hub-test",
+			protocolVersion: "v1",
+			buildId: "test-build",
+			authToken: "token",
+			host: "127.0.0.1",
+			port: 25464,
+			url: recoveredUrl,
+			startedAt: new Date().toISOString(),
+			updatedAt: new Date().toISOString(),
+		};
+
+		class ExplicitEndpointWebSocket {
+			readyState = 0;
+			private readonly listeners = new Map<string, Set<GenericListener>>();
+
+			constructor(
+				private readonly url: string,
+				_protocols?: string | string[],
+			) {
+				queueMicrotask(() => {
+					this.readyState = 1;
+					this.emit("open");
+				});
+			}
+
+			addEventListener(type: string, listener: GenericListener): void {
+				const current = this.listeners.get(type) ?? new Set<GenericListener>();
+				current.add(listener);
+				this.listeners.set(type, current);
+			}
+
+			send(data: string): void {
+				const frame = JSON.parse(data) as {
+					kind?: string;
+					envelope?: { requestId?: string; command?: string };
+				};
+				if (frame.kind !== "command" || !frame.envelope?.requestId) {
+					return;
+				}
+				if (frame.envelope.command === "client.register") {
+					queueMicrotask(() => {
+						this.emit("message", {
+							data: JSON.stringify({
+								kind: "reply",
+								envelope: {
+									version: "v1",
+									requestId: frame.envelope?.requestId,
+									ok: true,
+									payload: {},
+								},
+							}),
+						});
+					});
+					return;
+				}
+				if (this.url === originalUrl) {
+					queueMicrotask(() => {
+						this.readyState = 3;
+						this.emit("close", { code: 1006, reason: "" });
+					});
+					return;
+				}
+				queueMicrotask(() => {
+					this.emit("message", {
+						data: JSON.stringify({
+							kind: "reply",
+							envelope: {
+								version: "v1",
+								requestId: frame.envelope?.requestId,
+								ok: true,
+								payload: { clients: [] },
+							},
+						}),
+					});
+				});
+			}
+
+			close(): void {
+				this.readyState = 3;
+				this.emit("close", { code: 1000, reason: "" });
+			}
+
+			private emit(type: string, payload?: unknown): void {
+				for (const listener of this.listeners.get(type) ?? []) {
+					if (type === "message") {
+						(listener as MessageListener)(payload as { data: string });
+						continue;
+					}
+					listener(payload);
+				}
+			}
+		}
+
+		(
+			globalThis as unknown as { WebSocket?: typeof ExplicitEndpointWebSocket }
+		).WebSocket = ExplicitEndpointWebSocket;
+		vi.doMock("../daemon", () => ({
+			spawnDetachedHubServerWithRetry: vi.fn(async () => undefined),
+		}));
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery-explicit.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				resolveHubBuildId: () => "test-build",
+				readHubDiscovery: vi.fn(async () => record),
+				probeHubServer: vi.fn(async (url: string) =>
+					url.includes(":25464/") ? record : undefined,
+				),
+				clearHubDiscovery: vi.fn(async () => undefined),
+			};
+		});
+
+		try {
+			const { NodeHubClient: DynamicClient } = await import(".");
+			const client = new DynamicClient({
+				url: originalUrl,
+				workspaceRoot: "/tmp/project",
+				cwd: "/tmp/project",
+			});
+
+			await expect(client.command("client.list")).rejects.toMatchObject({
+				name: "HubTransportError",
+				code: "hub_connection_closed",
+			});
+			expect(client.getUrl()).toBe(originalUrl);
+			await client.dispose();
+		} finally {
+			if (originalWebSocket) {
+				globalThis.WebSocket = originalWebSocket;
+			} else {
+				delete (globalThis as unknown as { WebSocket?: unknown }).WebSocket;
+			}
+			vi.resetModules();
+		}
+	});
+});
+
+describe("resolveCompatibleLocalHubUrl", () => {
+	// Reset the module registry *before* each test so the `vi.doMock(...)`
+	// calls below register against a fresh `./client` module graph. Without
+	// this, the static `import { NodeHubClient } from "../client"` at the top
+	// of the file has already cached `./client` (and its real `./discovery`
+	// + `./workspace` bindings) before any test runs, so `vi.doMock` never
+	// takes effect for the dynamic `await import(".")`. That cache
+	// contamination causes the test to hit the real discovery/probe code
+	// path and fail locally whenever a stray hub daemon is listening on
+	// the default port (passes in CI only because no daemon is running).
+	beforeEach(() => {
+		vi.resetModules();
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+		delete process.env.CLINE_HUB_BUILD_ID;
+		vi.resetModules();
+	});
+
+	it("does not clear discovery on transient probe failure", async () => {
+		const clearHubDiscoveryMock = vi.fn();
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				resolveHubBuildId: () => "test-build",
+				readHubDiscovery: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v1",
+					buildId: "test-build",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+				clearHubDiscovery: vi.fn(async (...args: unknown[]) => {
+					clearHubDiscoveryMock(...args);
+				}),
+				probeHubServer: vi.fn(async () => undefined),
+			};
+		});
+
+		const { resolveCompatibleLocalHubUrl } = await import(".");
+
+		await expect(resolveCompatibleLocalHubUrl()).resolves.toBeUndefined();
+		expect(clearHubDiscoveryMock).not.toHaveBeenCalled();
+	});
+
+	it("keeps discovery on build mismatch when protocol is compatible", async () => {
+		const clearHubDiscoveryMock = vi.fn();
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				resolveHubBuildId: () => "current-build",
+				readHubDiscovery: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v1",
+					buildId: "old-build",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+				clearHubDiscovery: vi.fn(async (...args: unknown[]) => {
+					clearHubDiscoveryMock(...args);
+				}),
+				probeHubServer: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v1",
+					buildId: "old-build",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+			};
+		});
+
+		const { resolveCompatibleLocalHubUrl } = await import(".");
+
+		await expect(resolveCompatibleLocalHubUrl()).resolves.toBe(
+			"ws://127.0.0.1:59999/hub",
+		);
+		expect(clearHubDiscoveryMock).not.toHaveBeenCalled();
+	});
+
+	it("keeps discovery when a hub omits build metadata but has compatible protocol", async () => {
+		const clearHubDiscoveryMock = vi.fn();
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				resolveHubBuildId: () => "current-build",
+				readHubDiscovery: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v1",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+				clearHubDiscovery: vi.fn(async (...args: unknown[]) => {
+					clearHubDiscoveryMock(...args);
+				}),
+				probeHubServer: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v1",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+			};
+		});
+
+		const { resolveCompatibleLocalHubUrl } = await import(".");
+
+		await expect(resolveCompatibleLocalHubUrl()).resolves.toBe(
+			"ws://127.0.0.1:59999/hub",
+		);
+		expect(clearHubDiscoveryMock).not.toHaveBeenCalled();
+	});
+
+	it("clears discovery on protocol mismatch", async () => {
+		const clearHubDiscoveryMock = vi.fn();
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				readHubDiscovery: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v0",
+					buildId: "old-build",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+				clearHubDiscovery: vi.fn(async (...args: unknown[]) => {
+					clearHubDiscoveryMock(...args);
+				}),
+				probeHubServer: vi.fn(async () => ({
+					hubId: "hub-test",
+					protocolVersion: "v0",
+					buildId: "old-build",
+					host: "127.0.0.1",
+					port: 59999,
+					url: "ws://127.0.0.1:59999/hub",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				})),
+			};
+		});
+
+		const { resolveCompatibleLocalHubUrl } = await import(".");
+
+		await expect(resolveCompatibleLocalHubUrl()).resolves.toBeUndefined();
+		expect(clearHubDiscoveryMock).toHaveBeenCalledWith(
+			"/tmp/hub-discovery.json",
+		);
+	});
+
+	it("starts missing local hubs through the retrying daemon spawn API", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const spawnDetachedHubServerWithRetryMock = vi.fn(async () => undefined);
+		const record = {
+			hubId: "hub-test",
+			protocolVersion: "v1",
+			buildId: "test-build",
+			authToken: "token",
+			host: "127.0.0.1",
+			port: 25464,
+			url: "ws://127.0.0.1:25464/hub",
+			startedAt: new Date().toISOString(),
+			updatedAt: new Date().toISOString(),
+		};
+		const readHubDiscoveryMock = vi
+			.fn()
+			.mockResolvedValueOnce(undefined)
+			.mockResolvedValueOnce(record);
+		vi.doMock("../daemon", () => ({
+			spawnDetachedHubServerWithRetry: spawnDetachedHubServerWithRetryMock,
+		}));
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				resolveHubBuildId: () => "test-build",
+				readHubDiscovery: readHubDiscoveryMock,
+				probeHubServer: vi.fn(async () => record),
+				clearHubDiscovery: vi.fn(async () => undefined),
+			};
+		});
+
+		const { ensureCompatibleLocalHubUrl } = await import(".");
+
+		await expect(
+			ensureCompatibleLocalHubUrl({
+				workspaceRoot: "/tmp/project",
+				cwd: "/tmp/project",
+			}),
+		).resolves.toBe("ws://127.0.0.1:25464/hub");
+		expect(spawnDetachedHubServerWithRetryMock).toHaveBeenCalledWith(
+			"/tmp/project",
+		);
+		expect(
+			spawnDetachedHubServerWithRetryMock.mock.invocationCallOrder[0],
+		).toBeGreaterThan(readHubDiscoveryMock.mock.invocationCallOrder[0]);
+		expect(
+			spawnDetachedHubServerWithRetryMock.mock.invocationCallOrder[0],
+		).toBeLessThan(readHubDiscoveryMock.mock.invocationCallOrder[1]);
+	});
+
+	it("waits on shared discovery after spawning in development builds", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const originalBuildEnv = process.env.CLINE_BUILD_ENV;
+		process.env.CLINE_BUILD_ENV = "development";
+		const spawnDetachedHubServerWithRetryMock = vi.fn(async () => undefined);
+		const record = {
+			hubId: "hub-test",
+			protocolVersion: "v1",
+			buildId: "test-build",
+			authToken: "token",
+			host: "127.0.0.1",
+			port: 25466,
+			url: "ws://127.0.0.1:25466/hub",
+			startedAt: new Date().toISOString(),
+			updatedAt: new Date().toISOString(),
+		};
+		const readHubDiscoveryMock = vi.fn(async (path: string) =>
+			path === "/tmp/shared-hub-discovery.json" ? record : undefined,
+		);
+		vi.doMock("../daemon", () => ({
+			spawnDetachedHubServerWithRetry: spawnDetachedHubServerWithRetryMock,
+		}));
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "production",
+				discoveryPath: "/tmp/production-hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "shared",
+				discoveryPath: "/tmp/shared-hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				readHubDiscovery: readHubDiscoveryMock,
+				probeHubServer: vi.fn(async () => record),
+				clearHubDiscovery: vi.fn(async () => undefined),
+			};
+		});
+
+		try {
+			const { ensureCompatibleLocalHubUrl } = await import(".");
+
+			await expect(
+				ensureCompatibleLocalHubUrl({
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				}),
+			).resolves.toBe("ws://127.0.0.1:25466/hub");
+			expect(readHubDiscoveryMock).toHaveBeenCalledWith(
+				"/tmp/shared-hub-discovery.json",
+			);
+			expect(readHubDiscoveryMock).not.toHaveBeenCalledWith(
+				"/tmp/production-hub-discovery.json",
+			);
+		} finally {
+			if (originalBuildEnv === undefined) {
+				delete process.env.CLINE_BUILD_ENV;
+			} else {
+				process.env.CLINE_BUILD_ENV = originalBuildEnv;
+			}
+		}
+	});
+
+	it("does not restart explicit local endpoints after startup timeout", async () => {
+		const readHubDiscoveryMock = vi.fn(async () => ({
+			hubId: "hub-test",
+			protocolVersion: "v1",
+			buildId: "test-build",
+			authToken: "token",
+			host: "127.0.0.1",
+			port: 25463,
+			url: "ws://127.0.0.1:25463/hub",
+			startedAt: new Date().toISOString(),
+			updatedAt: new Date().toISOString(),
+		}));
+		vi.doMock("../discovery/workspace", () => ({
+			resolveProductionHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+			resolveSharedHubOwnerContext: () => ({
+				ownerId: "hub-test",
+				discoveryPath: "/tmp/hub-discovery.json",
+			}),
+		}));
+		vi.doMock("../daemon", () => ({
+			spawnDetachedHubServerWithRetry: vi.fn(async () => undefined),
+		}));
+		vi.doMock("../discovery", async () => {
+			const actual =
+				await vi.importActual<typeof import("../discovery")>("../discovery");
+			return {
+				...actual,
+				readHubDiscovery: readHubDiscoveryMock,
+			};
+		});
+
+		const { restartLocalHubIfIdleAfterStartupTimeout } = await import(".");
+
+		await expect(
+			restartLocalHubIfIdleAfterStartupTimeout({
+				url: "ws://127.0.0.1:25463/hub",
+				workspaceRoot: "/tmp/project",
+				cwd: "/tmp/project",
+			}),
+		).resolves.toBeUndefined();
+		expect(readHubDiscoveryMock).not.toHaveBeenCalled();
+	});
+});
diff --git a/sdk/packages/core/src/hub/client/index.ts b/sdk/packages/core/src/hub/client/index.ts
new file mode 100644
index 0000000..7f7942a
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/index.ts
@@ -0,0 +1,1100 @@
+import {
+	createSessionId,
+	type HubClientRegistration,
+	type HubCommandEnvelope,
+	type HubEventEnvelope,
+	type HubReplyEnvelope,
+	type HubTransportFrame,
+	isHubProtocolCompatible,
+	resolveClineBuildEnv,
+	resolveHubCommandTimeoutMs,
+} from "@cline/shared";
+import {
+	SESSION_NOT_FOUND_ERROR_CODE,
+	SessionNotFoundError,
+} from "../../runtime/host/runtime-host";
+import { spawnDetachedHubServerWithRetry } from "../daemon";
+import {
+	clearHubDiscovery,
+	type HubOwnerContext,
+	probeHubServer,
+	readHubDiscovery,
+} from "../discovery";
+import {
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+} from "../discovery/workspace";
+
+type PendingReply = {
+	resolve: (reply: HubReplyEnvelope) => void;
+	reject: (error: unknown) => void;
+};
+
+type SubscriptionEntry = {
+	listener: (event: HubEventEnvelope) => void;
+	sessionId?: string;
+};
+
+function resolveDefaultHubOwnerContext(): HubOwnerContext {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+type WebSocketLike = {
+	readyState: number;
+	send(data: string): void;
+	close(): void;
+	addEventListener(type: string, listener: (...args: unknown[]) => void): void;
+};
+
+type WebSocketCtor = new (
+	url: string,
+	protocols?: string | string[],
+) => WebSocketLike;
+
+function getWebSocketCtor(): WebSocketCtor {
+	const ctor = (globalThis as { WebSocket?: WebSocketCtor }).WebSocket;
+	if (!ctor) {
+		throw new Error(
+			"Global WebSocket is not available in this runtime. Node 22+ is required for hub mode.",
+		);
+	}
+	return ctor;
+}
+
+function decodeSocketData(data: unknown): string {
+	if (typeof data === "string") {
+		return data;
+	}
+	if (data instanceof Uint8Array) {
+		return Buffer.from(data).toString();
+	}
+	if (data instanceof ArrayBuffer) {
+		return Buffer.from(data).toString();
+	}
+	if (Array.isArray(data)) {
+		return Buffer.concat(data.map((chunk) => Buffer.from(chunk))).toString();
+	}
+	if (
+		data &&
+		typeof data === "object" &&
+		"data" in data &&
+		typeof (data as { data?: unknown }).data !== "undefined"
+	) {
+		return decodeSocketData((data as { data?: unknown }).data);
+	}
+	return String(data);
+}
+
+function decodeCloseReason(reason: unknown): string {
+	if (typeof reason === "string") {
+		return reason;
+	}
+	if (reason instanceof Uint8Array) {
+		return Buffer.from(reason).toString("utf8");
+	}
+	if (reason instanceof ArrayBuffer) {
+		return Buffer.from(reason).toString("utf8");
+	}
+	return "";
+}
+
+function createHubCloseError(event: unknown): HubTransportError {
+	const closeEvent = event as { code?: number; reason?: unknown };
+	const reasonText = decodeCloseReason(closeEvent.reason);
+	return new HubTransportError(
+		"hub_connection_closed",
+		closeEvent.code || reasonText
+			? `Hub connection closed (code=${closeEvent.code ?? 0}${reasonText ? `, reason=${reasonText}` : ""})`
+			: DEFAULT_HUB_CLOSED_MESSAGE,
+		{
+			closeCode: closeEvent.code,
+			closeReason: reasonText || undefined,
+		},
+	);
+}
+
+function normalizeWebSocketConnectError(
+	error: unknown,
+	url: URL,
+): HubTransportError {
+	if (error instanceof HubTransportError) {
+		return error;
+	}
+	if (error instanceof Error) {
+		return new HubTransportError("hub_connect_failed", error.message);
+	}
+	if (
+		error &&
+		typeof error === "object" &&
+		"error" in error &&
+		(error as { error?: unknown }).error instanceof Error
+	) {
+		return new HubTransportError(
+			"hub_connect_failed",
+			(error as { error: Error }).error.message,
+		);
+	}
+	const message =
+		error &&
+		typeof error === "object" &&
+		"message" in error &&
+		typeof (error as { message?: unknown }).message === "string"
+			? (error as { message: string }).message.trim()
+			: "";
+	if (message) {
+		return new HubTransportError("hub_connect_failed", message);
+	}
+	const eventType =
+		error &&
+		typeof error === "object" &&
+		"type" in error &&
+		typeof (error as { type?: unknown }).type === "string"
+			? (error as { type: string }).type.trim()
+			: "";
+	return new HubTransportError(
+		"hub_connect_failed",
+		eventType
+			? `Failed to connect to hub at ${url.toString()} (${eventType} event before socket open).`
+			: `Failed to connect to hub at ${url.toString()}.`,
+	);
+}
+
+export interface HubClientOptions {
+	url: string;
+	clientId?: string;
+	clientType?: string;
+	displayName?: string;
+	workspaceRoot?: string;
+	cwd?: string;
+	authToken?: string;
+}
+
+export interface LocalHubResolutionOptions {
+	endpoint?: string;
+	strategy?: "prefer-hub" | "require-hub";
+	workspaceRoot?: string;
+	cwd?: string;
+}
+
+const HUB_STARTUP_TIMEOUT_MS = 8_000;
+const HUB_STARTUP_POLL_MS = 200;
+const GLOBAL_SUBSCRIPTION_KEY = "*";
+const HUB_CONNECT_TIMEOUT_MS = 8_000;
+const HUB_AUTH_PROTOCOL_PREFIX = "cline-hub-auth.";
+const LOCAL_HUB_AUTH_TOKENS = new Map<string, string>();
+const RECOVERABLE_LOCAL_HUB_URLS = new Set<string>();
+const HUB_RECOVERY_SESSION_LIST_TIMEOUT_MS = 3_000;
+const HUB_RECOVERY_RETIRE_TIMEOUT_MS = 3_000;
+const HUB_RECOVERY_RETIRE_POLL_MS = 100;
+const DEFAULT_HUB_CLOSED_MESSAGE = "Hub connection closed";
+const HUB_RECONNECT_INITIAL_DELAY_MS = 250;
+const HUB_RECONNECT_MAX_DELAY_MS = 5_000;
+const HUB_RECONNECT_JITTER_RATIO = 0.5;
+
+export type HubTransportErrorCode =
+	| "hub_connect_timeout"
+	| "hub_connect_failed"
+	| "hub_connection_closed"
+	| "hub_connection_not_open";
+
+export class HubTransportError extends Error {
+	constructor(
+		readonly code: HubTransportErrorCode,
+		message: string,
+		readonly details?: { closeCode?: number; closeReason?: string },
+	) {
+		super(message);
+		this.name = "HubTransportError";
+	}
+}
+
+export function isHubReconnectableTransportError(
+	error: unknown,
+): error is HubTransportError {
+	return error instanceof HubTransportError;
+}
+
+export class HubCommandError extends Error {
+	constructor(
+		readonly command: HubCommandEnvelope["command"],
+		readonly code: string | undefined,
+		message: string,
+	) {
+		super(message);
+		this.name = "HubCommandError";
+	}
+}
+
+export function isHubCommandTimeoutError(
+	error: unknown,
+	command?: HubCommandEnvelope["command"],
+): boolean {
+	return (
+		error instanceof HubCommandError &&
+		error.code === "hub_command_timeout" &&
+		(command === undefined || error.command === command)
+	);
+}
+
+function resolveLocalHubAuthToken(url: URL): string | undefined {
+	const queryToken = url.searchParams.get("authToken")?.trim();
+	url.searchParams.delete("authToken");
+	if (queryToken) {
+		return queryToken;
+	}
+	const key = localHubUrlKey(url.toString());
+	return key ? LOCAL_HUB_AUTH_TOKENS.get(key) : undefined;
+}
+
+function isLocalHubUrl(url: string): boolean {
+	try {
+		const parsed = new URL(url);
+		const hostname = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+		return (
+			hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"
+		);
+	} catch {
+		return false;
+	}
+}
+
+function localHubUrlKey(url: string): string | undefined {
+	if (!isLocalHubUrl(url)) {
+		return undefined;
+	}
+	const parsed = new URL(normalizeHubWebSocketUrl(url));
+	parsed.search = "";
+	parsed.hash = "";
+	return parsed.toString();
+}
+
+function isRecoverableLocalHubUrl(url: string): boolean {
+	const key = localHubUrlKey(url);
+	return !!key && RECOVERABLE_LOCAL_HUB_URLS.has(key);
+}
+
+export function rememberRecoverableLocalHubUrl(
+	url: string,
+	authToken?: string,
+): string {
+	const key = localHubUrlKey(url);
+	if (key) {
+		RECOVERABLE_LOCAL_HUB_URLS.add(key);
+		if (authToken?.trim()) {
+			LOCAL_HUB_AUTH_TOKENS.set(key, authToken);
+		}
+	}
+	return url;
+}
+
+export class NodeHubClient {
+	private socket: WebSocketLike | undefined;
+	private connectPromise: Promise<void> | undefined;
+	private readonly clientId: string;
+	private currentUrl: string;
+	private recoveryPromise: Promise<boolean> | undefined;
+	private readonly pendingReplies = new Map<string, PendingReply>();
+	private readonly listeners = new Set<SubscriptionEntry>();
+	private readonly subscriptionCounts = new Map<string, number>();
+	private reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+	private reconnectAttempt = 0;
+	private closedByClient = false;
+	private lastCloseError = new HubTransportError(
+		"hub_connection_closed",
+		DEFAULT_HUB_CLOSED_MESSAGE,
+	);
+	private sawSocketClose = false;
+	private registered = false;
+
+	constructor(private readonly options: HubClientOptions) {
+		this.clientId =
+			options.clientId ??
+			`core-${Math.random().toString(36).slice(2, 10)}-${Date.now().toString(36)}`;
+		this.currentUrl = options.url;
+	}
+
+	getClientId(): string {
+		return this.clientId;
+	}
+
+	getUrl(): string {
+		return this.currentUrl;
+	}
+
+	async connect(): Promise<void> {
+		if (
+			this.socket &&
+			(this.socket.readyState === 1 || this.socket.readyState === 0)
+		) {
+			return this.connectPromise ?? Promise.resolve();
+		}
+		this.closedByClient = false;
+		this.clearReconnectTimer();
+
+		const url = new URL(this.currentUrl);
+		const authToken =
+			this.options.authToken?.trim() || resolveLocalHubAuthToken(url);
+		url.hash = "";
+
+		const WebSocketImpl = getWebSocketCtor();
+		const socket = new WebSocketImpl(
+			url.toString(),
+			authToken ? [`${HUB_AUTH_PROTOCOL_PREFIX}${authToken}`] : undefined,
+		);
+		this.socket = socket;
+		let suppressCloseMessage = false;
+		this.connectPromise = new Promise<void>((resolve, reject) => {
+			let settled = false;
+			const timeout = setTimeout(() => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				suppressCloseMessage = true;
+				this.lastCloseError = new HubTransportError(
+					"hub_connect_timeout",
+					`Timed out connecting to hub after ${HUB_CONNECT_TIMEOUT_MS}ms`,
+				);
+				this.sawSocketClose = false;
+				this.connectPromise = undefined;
+				this.socket = undefined;
+				try {
+					socket.close();
+				} catch {
+					// best-effort close
+				}
+				reject(this.lastCloseError);
+			}, HUB_CONNECT_TIMEOUT_MS);
+			socket.addEventListener("open", () => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				clearTimeout(timeout);
+				resolve();
+			});
+			socket.addEventListener("error", (error) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				clearTimeout(timeout);
+				this.lastCloseError = normalizeWebSocketConnectError(error, url);
+				this.sawSocketClose = false;
+				this.connectPromise = undefined;
+				this.socket = undefined;
+				reject(this.lastCloseError);
+			});
+			socket.addEventListener("close", (event: unknown) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				clearTimeout(timeout);
+				if (!suppressCloseMessage) {
+					this.lastCloseError = createHubCloseError(event);
+					this.sawSocketClose = true;
+				}
+				this.connectPromise = undefined;
+				this.socket = undefined;
+				reject(this.lastCloseError);
+			});
+		});
+
+		socket.addEventListener("message", (data: unknown) => {
+			this.handleFrame(JSON.parse(decodeSocketData(data)) as HubTransportFrame);
+		});
+		socket.addEventListener("close", (event: unknown) => {
+			if (this.socket !== socket) {
+				return;
+			}
+			if (!suppressCloseMessage) {
+				this.lastCloseError = createHubCloseError(event);
+				this.sawSocketClose = true;
+			}
+			this.registered = false;
+			for (const pending of this.pendingReplies.values()) {
+				pending.reject(this.lastCloseError);
+			}
+			this.pendingReplies.clear();
+			this.connectPromise = undefined;
+			this.socket = undefined;
+			if (!this.closedByClient && this.hasActiveSubscriptions()) {
+				this.scheduleReconnect();
+			}
+		});
+
+		await this.connectPromise;
+		await this.command("client.register", {
+			clientId: this.clientId,
+			clientType: this.options.clientType ?? "core",
+			displayName: this.options.displayName ?? "core",
+			transport: "native",
+			actorKind: "client",
+			workspaceContext: {
+				workspaceRoot: this.options.workspaceRoot,
+				cwd: this.options.cwd,
+			},
+		} satisfies HubClientRegistration);
+		this.registered = true;
+		for (const key of this.subscriptionCounts.keys()) {
+			this.sendSubscriptionFrame(
+				"stream.subscribe",
+				this.subscriptionSessionIdFromKey(key),
+			);
+		}
+		this.reconnectAttempt = 0;
+	}
+
+	subscribe(
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): () => void {
+		const sessionId = options?.sessionId?.trim() || undefined;
+		const entry = { listener, sessionId };
+		this.listeners.add(entry);
+		this.adjustSubscriptionCount(sessionId, 1);
+		return () => {
+			if (!this.listeners.delete(entry)) {
+				return;
+			}
+			this.adjustSubscriptionCount(sessionId, -1);
+		};
+	}
+
+	async command(
+		command: HubCommandEnvelope["command"],
+		payload?: Record<string, unknown>,
+		sessionId?: string,
+		options?: { timeoutMs?: number | null },
+	): Promise<HubReplyEnvelope> {
+		let attempt = 0;
+		const canRecoverTransport =
+			command !== "client.register" && command !== "client.unregister";
+		while (true) {
+			try {
+				return await this.commandOnce(command, payload, sessionId, options);
+			} catch (error) {
+				if (
+					!canRecoverTransport ||
+					attempt >= 1 ||
+					!(await this.recoverLocalHubTransport(error))
+				) {
+					throw error;
+				}
+				attempt += 1;
+			}
+		}
+	}
+
+	private async commandOnce(
+		command: HubCommandEnvelope["command"],
+		payload?: Record<string, unknown>,
+		sessionId?: string,
+		options?: { timeoutMs?: number | null },
+	): Promise<HubReplyEnvelope> {
+		await this.connect();
+		const requestId = createSessionId("hubreq_");
+		const effectiveTimeoutMs = resolveHubCommandTimeoutMs(
+			command,
+			options?.timeoutMs,
+		);
+		const reply = new Promise<HubReplyEnvelope>((resolve, reject) => {
+			const timeout =
+				effectiveTimeoutMs === null
+					? undefined
+					: setTimeout(() => {
+							if (!this.pendingReplies.delete(requestId)) {
+								return;
+							}
+							reject(
+								new HubCommandError(
+									command,
+									"hub_command_timeout",
+									`Hub command ${command} timed out after ${effectiveTimeoutMs}ms (hub=${this.currentUrl}, requestId=${requestId}, clientId=${this.clientId}). Check hub-daemon.log for matching command.start/command.slow entries, or run 'cline doctor fix' to restart the hub.`,
+								),
+							);
+						}, effectiveTimeoutMs);
+			this.pendingReplies.set(requestId, {
+				resolve: (value) => {
+					if (timeout) {
+						clearTimeout(timeout);
+					}
+					resolve(value);
+				},
+				reject: (error) => {
+					if (timeout) {
+						clearTimeout(timeout);
+					}
+					reject(error);
+				},
+			});
+		});
+		try {
+			this.sendFrame({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command,
+					requestId,
+					clientId: this.clientId,
+					sessionId,
+					timeoutMs: effectiveTimeoutMs,
+					payload,
+				},
+			});
+		} catch (error) {
+			this.pendingReplies.delete(requestId);
+			throw error;
+		}
+		const resolved = await reply;
+		if (!resolved.ok) {
+			if (resolved.error?.code === SESSION_NOT_FOUND_ERROR_CODE) {
+				const targetSessionId =
+					sessionId ??
+					(typeof payload?.sessionId === "string"
+						? payload.sessionId
+						: undefined);
+				throw new SessionNotFoundError(targetSessionId, resolved.error.message);
+			}
+			throw new HubCommandError(
+				command,
+				resolved.error?.code,
+				resolved.error?.message ?? `Hub command ${command} failed`,
+			);
+		}
+		return resolved;
+	}
+
+	private async recoverLocalHubTransport(error: unknown): Promise<boolean> {
+		if (
+			!isRecoverableLocalHubUrl(this.currentUrl) ||
+			!isHubReconnectableTransportError(error)
+		) {
+			return false;
+		}
+		if (this.recoveryPromise) {
+			return await this.recoveryPromise;
+		}
+		this.recoveryPromise = (async () => {
+			const recoveredUrl = await ensureCompatibleLocalHubUrl({
+				workspaceRoot: this.options.workspaceRoot,
+				cwd: this.options.cwd,
+			}).catch(() => undefined);
+			if (!recoveredUrl) {
+				return false;
+			}
+			this.currentUrl = recoveredUrl;
+			this.close();
+			return true;
+		})().finally(() => {
+			this.recoveryPromise = undefined;
+		});
+		return await this.recoveryPromise;
+	}
+
+	private hasActiveSubscriptions(): boolean {
+		return this.subscriptionCounts.size > 0;
+	}
+
+	private clearReconnectTimer(): void {
+		if (!this.reconnectTimer) {
+			return;
+		}
+		clearTimeout(this.reconnectTimer);
+		this.reconnectTimer = undefined;
+	}
+
+	private scheduleReconnect(): void {
+		if (
+			this.reconnectTimer ||
+			this.closedByClient ||
+			!this.hasActiveSubscriptions()
+		) {
+			return;
+		}
+		const delayMs = Math.min(
+			HUB_RECONNECT_INITIAL_DELAY_MS * 2 ** this.reconnectAttempt,
+			HUB_RECONNECT_MAX_DELAY_MS,
+		);
+		const jitteredDelayMs = Math.round(
+			delayMs * (1 - HUB_RECONNECT_JITTER_RATIO) +
+				Math.random() * delayMs * HUB_RECONNECT_JITTER_RATIO,
+		);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = undefined;
+			void this.reconnectSubscribedTransport();
+		}, jitteredDelayMs);
+	}
+
+	private async reconnectSubscribedTransport(): Promise<void> {
+		if (this.closedByClient || !this.hasActiveSubscriptions()) {
+			return;
+		}
+		try {
+			await this.connect();
+			this.reconnectAttempt = 0;
+		} catch {
+			if (!isRecoverableLocalHubUrl(this.currentUrl)) {
+				this.reconnectAttempt += 1;
+				this.scheduleReconnect();
+				return;
+			}
+			try {
+				const recoveredUrl = await ensureCompatibleLocalHubUrl({
+					workspaceRoot: this.options.workspaceRoot,
+					cwd: this.options.cwd,
+				});
+				if (recoveredUrl) {
+					this.currentUrl = recoveredUrl;
+					await this.connect();
+					this.reconnectAttempt = 0;
+					return;
+				}
+			} catch {
+				// fall through to retry below
+			}
+			this.reconnectAttempt += 1;
+			this.scheduleReconnect();
+		}
+	}
+
+	close(): void {
+		const socket = this.socket;
+		this.closedByClient = true;
+		this.clearReconnectTimer();
+		this.registered = false;
+		if (!socket) {
+			return;
+		}
+		this.lastCloseError = new HubTransportError(
+			"hub_connection_closed",
+			DEFAULT_HUB_CLOSED_MESSAGE,
+		);
+		this.sawSocketClose = false;
+		for (const pending of this.pendingReplies.values()) {
+			pending.reject(this.lastCloseError);
+		}
+		this.pendingReplies.clear();
+		this.connectPromise = undefined;
+		this.socket = undefined;
+		try {
+			socket.close();
+		} catch {
+			// best-effort close
+		}
+	}
+
+	async dispose(): Promise<void> {
+		const socket = this.socket;
+		if (socket?.readyState === 1 && this.registered) {
+			try {
+				await this.command("client.unregister", undefined, undefined, {
+					timeoutMs: 2_000,
+				});
+			} catch {
+				// Best-effort unregister during shutdown. The websocket adapter also
+				// unregisters clients on close, so failure here should not block teardown.
+			}
+		}
+		this.close();
+	}
+
+	private sendFrame(frame: HubTransportFrame): void {
+		if (!this.socket || this.socket.readyState !== 1) {
+			if (
+				this.lastCloseError.code === "hub_connection_closed" &&
+				!this.sawSocketClose
+			) {
+				throw new HubTransportError(
+					"hub_connection_not_open",
+					"Hub connection is not open.",
+				);
+			}
+			throw this.lastCloseError;
+		}
+		this.socket.send(JSON.stringify(frame));
+	}
+
+	private sendSubscriptionFrame(
+		kind: "stream.subscribe" | "stream.unsubscribe",
+		sessionId?: string,
+	): void {
+		this.sendFrame({
+			kind,
+			clientId: this.clientId,
+			...(sessionId ? { sessionId } : {}),
+		});
+	}
+
+	private adjustSubscriptionCount(
+		sessionId: string | undefined,
+		delta: 1 | -1,
+	): void {
+		const key = this.subscriptionKeyForSessionId(sessionId);
+		const next = (this.subscriptionCounts.get(key) ?? 0) + delta;
+		if (next <= 0) {
+			this.subscriptionCounts.delete(key);
+			if (!this.hasActiveSubscriptions()) {
+				this.clearReconnectTimer();
+			}
+			if (delta < 0 && this.socket?.readyState === 1) {
+				this.sendSubscriptionFrame("stream.unsubscribe", sessionId);
+			}
+			return;
+		}
+		this.subscriptionCounts.set(key, next);
+		if (delta > 0 && next === 1 && this.socket?.readyState === 1) {
+			this.sendSubscriptionFrame("stream.subscribe", sessionId);
+		}
+	}
+
+	private subscriptionKeyForSessionId(sessionId: string | undefined): string {
+		return sessionId ?? GLOBAL_SUBSCRIPTION_KEY;
+	}
+
+	private subscriptionSessionIdFromKey(key: string): string | undefined {
+		return key === GLOBAL_SUBSCRIPTION_KEY ? undefined : key;
+	}
+
+	private handleFrame(frame: HubTransportFrame): void {
+		switch (frame.kind) {
+			case "reply": {
+				const requestId = frame.envelope.requestId;
+				if (!requestId) {
+					return;
+				}
+				const pending = this.pendingReplies.get(requestId);
+				if (!pending) {
+					return;
+				}
+				this.pendingReplies.delete(requestId);
+				pending.resolve(frame.envelope);
+				return;
+			}
+			case "event":
+				for (const entry of this.listeners) {
+					if (
+						entry.sessionId &&
+						entry.sessionId !== frame.envelope.sessionId?.trim()
+					) {
+						continue;
+					}
+					entry.listener(frame.envelope);
+				}
+				return;
+			case "command":
+			case "stream.subscribe":
+			case "stream.unsubscribe":
+				return;
+		}
+	}
+}
+
+export function normalizeHubWebSocketUrl(url: string): string {
+	const parsed = new URL(url);
+	if (parsed.protocol === "http:") {
+		parsed.protocol = "ws:";
+	} else if (parsed.protocol === "https:") {
+		parsed.protocol = "wss:";
+	}
+	return parsed.toString();
+}
+
+export async function verifyHubConnection(
+	url: string,
+	options?: Pick<HubClientOptions, "workspaceRoot" | "cwd" | "authToken">,
+): Promise<boolean> {
+	const client = new NodeHubClient({
+		url,
+		authToken: options?.authToken,
+		clientType: "hub-healthcheck",
+		displayName: "hub healthcheck",
+		workspaceRoot: options?.workspaceRoot,
+		cwd: options?.cwd,
+	});
+	try {
+		await client.connect();
+		return true;
+	} catch {
+		return false;
+	} finally {
+		client.close();
+	}
+}
+
+type HubProbeResult =
+	| {
+			status: "compatible";
+			url: string;
+	  }
+	| {
+			status: "unreachable" | "protocol_mismatch";
+			url: string;
+	  };
+
+async function probeCompatibleHubUrl(
+	url: string,
+	options?: {
+		verifyConnection?: boolean;
+		workspaceRoot?: string;
+		cwd?: string;
+		authToken?: string;
+	},
+): Promise<HubProbeResult> {
+	const normalized = normalizeHubWebSocketUrl(url);
+	const record = await probeHubServer(normalized, {
+		authToken: options?.authToken,
+	});
+	if (!record) {
+		return {
+			status: "unreachable",
+			url: normalized,
+		};
+	}
+	if (!isHubProtocolCompatible(record).compatible) {
+		return {
+			status: "protocol_mismatch",
+			url: normalized,
+		};
+	}
+	if (
+		options?.verifyConnection === true &&
+		!(await verifyHubConnection(normalized, {
+			workspaceRoot: options.workspaceRoot,
+			cwd: options.cwd,
+			authToken: options.authToken,
+		}))
+	) {
+		return {
+			status: "unreachable",
+			url: normalized,
+		};
+	}
+	return {
+		status: "compatible",
+		url: normalized,
+	};
+}
+
+async function waitForCompatibleHubUrl(
+	owner: HubOwnerContext,
+): Promise<string | undefined> {
+	const deadline = Date.now() + HUB_STARTUP_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		const record = await readHubDiscovery(owner.discoveryPath);
+		if (record?.url) {
+			const compatible = await probeCompatibleHubUrl(record.url, {
+				verifyConnection: true,
+				authToken: record.authToken,
+			});
+			if (compatible.status === "compatible") {
+				return rememberRecoverableLocalHubUrl(compatible.url, record.authToken);
+			}
+		}
+		await new Promise((resolve) => setTimeout(resolve, HUB_STARTUP_POLL_MS));
+	}
+	return undefined;
+}
+
+async function waitForHubToRetire(url: string): Promise<boolean> {
+	const deadline = Date.now() + HUB_RECOVERY_RETIRE_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		const healthy = await probeHubServer(url).catch(() => undefined);
+		if (!healthy?.url) {
+			return true;
+		}
+		await new Promise((resolve) =>
+			setTimeout(resolve, HUB_RECOVERY_RETIRE_POLL_MS),
+		);
+	}
+	return false;
+}
+
+function sameNormalizedHubUrl(left: string, right: string): boolean {
+	try {
+		return normalizeHubWebSocketUrl(left) === normalizeHubWebSocketUrl(right);
+	} catch {
+		return false;
+	}
+}
+
+function hasActiveHubSessions(payload: unknown): boolean {
+	const sessions =
+		payload &&
+		typeof payload === "object" &&
+		Array.isArray((payload as { sessions?: unknown }).sessions)
+			? (payload as { sessions: unknown[] }).sessions
+			: [];
+	return sessions.some((session) => {
+		if (!session || typeof session !== "object") {
+			return false;
+		}
+		const record = session as {
+			status?: unknown;
+			participants?: unknown;
+		};
+		if (
+			record.status === "running" ||
+			record.status === "idle" ||
+			record.status === "pending"
+		) {
+			return true;
+		}
+		return Array.isArray(record.participants) && record.participants.length > 0;
+	});
+}
+
+async function localHubHasNoActiveSessions(
+	url: string,
+	authToken?: string,
+	options?: Pick<HubClientOptions, "workspaceRoot" | "cwd">,
+): Promise<boolean> {
+	const client = new NodeHubClient({
+		url,
+		authToken,
+		clientType: "hub-recovery-check",
+		displayName: "hub recovery check",
+		workspaceRoot: options?.workspaceRoot,
+		cwd: options?.cwd,
+	});
+	try {
+		const reply = await client.command(
+			"session.list",
+			{ limit: 500 },
+			undefined,
+			{ timeoutMs: HUB_RECOVERY_SESSION_LIST_TIMEOUT_MS },
+		);
+		return !hasActiveHubSessions(reply.payload);
+	} catch {
+		return false;
+	} finally {
+		await client.dispose().catch(() => undefined);
+	}
+}
+
+export async function resolveCompatibleLocalHubUrl(
+	options: LocalHubResolutionOptions = {},
+): Promise<string | undefined> {
+	if (options.endpoint?.trim()) {
+		const compatible = await probeCompatibleHubUrl(options.endpoint);
+		return compatible.status === "compatible" ? compatible.url : undefined;
+	}
+
+	const owner = resolveDefaultHubOwnerContext();
+	const record = await readHubDiscovery(owner.discoveryPath);
+	if (!record?.url) {
+		return undefined;
+	}
+	const compatible = await probeCompatibleHubUrl(record.url, {
+		authToken: record.authToken,
+	});
+	if (compatible.status === "compatible") {
+		return rememberRecoverableLocalHubUrl(compatible.url, record.authToken);
+	}
+	if (compatible.status === "protocol_mismatch") {
+		await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+	}
+	return undefined;
+}
+
+export async function ensureCompatibleLocalHubUrl(
+	options: LocalHubResolutionOptions = {},
+): Promise<string | undefined> {
+	const resolved = await resolveCompatibleLocalHubUrl(options);
+	if (
+		resolved &&
+		(await verifyHubConnection(resolved, {
+			workspaceRoot: options.workspaceRoot,
+			cwd: options.cwd,
+		}))
+	) {
+		return resolved;
+	}
+	if (options.endpoint?.trim()) {
+		return undefined;
+	}
+	const owner = resolveDefaultHubOwnerContext();
+	await spawnDetachedHubServerWithRetry(options.workspaceRoot ?? process.cwd());
+	return await waitForCompatibleHubUrl(owner);
+}
+
+export async function requestHubShutdown(
+	url: string,
+	authToken?: string,
+): Promise<boolean> {
+	const parsed = new URL(url);
+	const resolvedAuthToken =
+		authToken?.trim() || resolveLocalHubAuthToken(parsed);
+	if (parsed.protocol === "ws:") {
+		parsed.protocol = "http:";
+	} else if (parsed.protocol === "wss:") {
+		parsed.protocol = "https:";
+	}
+	parsed.pathname = "/shutdown";
+	parsed.hash = "";
+	const response = await fetch(parsed, {
+		method: "POST",
+		headers: resolvedAuthToken
+			? { authorization: `Bearer ${resolvedAuthToken}` }
+			: undefined,
+	});
+	return response.ok;
+}
+
+export async function stopLocalHubServerGracefully(
+	owner: HubOwnerContext = resolveDefaultHubOwnerContext(),
+): Promise<boolean> {
+	const discovery = await readHubDiscovery(owner.discoveryPath);
+	if (!discovery?.url) {
+		return false;
+	}
+	try {
+		const stopped = await requestHubShutdown(
+			discovery.url,
+			discovery.authToken,
+		);
+		if (stopped) {
+			return true;
+		}
+	} catch {
+		// Fall through so callers can apply a stronger fallback.
+	}
+	return false;
+}
+
+export async function restartLocalHubIfIdleAfterStartupTimeout(options: {
+	url: string;
+	workspaceRoot?: string;
+	cwd?: string;
+}): Promise<string | undefined> {
+	if (!isRecoverableLocalHubUrl(options.url)) {
+		return undefined;
+	}
+	const owner = resolveDefaultHubOwnerContext();
+	const discovery = await readHubDiscovery(owner.discoveryPath);
+	if (!discovery?.url || !sameNormalizedHubUrl(discovery.url, options.url)) {
+		return undefined;
+	}
+	const hasNoActiveSessions = await localHubHasNoActiveSessions(
+		discovery.url,
+		discovery.authToken,
+		{ workspaceRoot: options.workspaceRoot, cwd: options.cwd },
+	);
+	if (!hasNoActiveSessions) {
+		return undefined;
+	}
+	if (!(await stopLocalHubServerGracefully())) {
+		return undefined;
+	}
+	if (!(await waitForHubToRetire(discovery.url))) {
+		return undefined;
+	}
+	await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+	return await ensureCompatibleLocalHubUrl({
+		workspaceRoot: options.workspaceRoot,
+		cwd: options.cwd,
+	});
+}
diff --git a/sdk/packages/core/src/hub/client/session-client.test.ts b/sdk/packages/core/src/hub/client/session-client.test.ts
new file mode 100644
index 0000000..1efc4da
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/session-client.test.ts
@@ -0,0 +1,310 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { HubSessionClient } from "./session-client";
+
+type SocketListener = (...args: unknown[]) => void;
+
+class MockWebSocket {
+	static instances: MockWebSocket[] = [];
+
+	readyState = 0;
+	private readonly listeners = new Map<string, SocketListener[]>();
+
+	constructor(_url: string) {
+		MockWebSocket.instances.push(this);
+		queueMicrotask(() => {
+			this.readyState = 1;
+			this.emit("open");
+		});
+	}
+
+	static reset(): void {
+		MockWebSocket.instances = [];
+	}
+
+	send(data: string): void {
+		const frame = JSON.parse(data) as {
+			kind?: string;
+			envelope?: { requestId?: string; command?: string };
+		};
+		if (frame.kind !== "command" || !frame.envelope?.requestId) {
+			return;
+		}
+		queueMicrotask(() => {
+			this.emitFrame({
+				kind: "reply",
+				envelope: {
+					version: "v1",
+					requestId: frame.envelope?.requestId,
+					command: frame.envelope?.command,
+					ok: true,
+					payload: {},
+				},
+			});
+		});
+	}
+
+	close(): void {
+		this.readyState = 3;
+		this.emit("close", { code: 1000, reason: "" });
+	}
+
+	addEventListener(type: string, listener: SocketListener): void {
+		const listeners = this.listeners.get(type) ?? [];
+		listeners.push(listener);
+		this.listeners.set(type, listeners);
+	}
+
+	emitFrame(frame: unknown): void {
+		this.emit("message", { data: JSON.stringify(frame) });
+	}
+
+	private emit(type: string, ...args: unknown[]): void {
+		for (const listener of this.listeners.get(type) ?? []) {
+			listener(...args);
+		}
+	}
+}
+
+describe("HubSessionClient", () => {
+	afterEach(() => {
+		MockWebSocket.reset();
+		vi.unstubAllGlobals();
+	});
+
+	it("normalizes run.failed events to include a top-level error", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const client = new HubSessionClient({
+			address: "ws://127.0.0.1:25463/hub",
+			clientId: "client-1",
+		});
+		await client.connect();
+		const socket = MockWebSocket.instances[0];
+		if (!socket) {
+			throw new Error("expected websocket");
+		}
+		const received: Array<{
+			sessionId: string;
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const unsubscribe = client.streamEvents(
+			{ sessionIds: ["session-1"] },
+			{
+				onEvent: (event) => {
+					received.push(event);
+				},
+			},
+		);
+
+		socket.emitFrame({
+			kind: "event",
+			envelope: {
+				version: "v1",
+				eventId: "evt-1",
+				event: "run.failed",
+				timestamp: Date.now(),
+				sessionId: "session-1",
+				payload: {
+					reason: "error",
+					result: {
+						text: "Provider rejected the request",
+						finishReason: "error",
+					},
+				},
+			},
+		});
+
+		expect(received).toEqual([
+			{
+				sessionId: "session-1",
+				eventType: "runtime.chat.failed",
+				payload: {
+					reason: "error",
+					error: "Provider rejected the request",
+					result: {
+						text: "Provider rejected the request",
+						finishReason: "error",
+					},
+				},
+			},
+		]);
+
+		unsubscribe();
+		client.close();
+	});
+
+	it("maps usage.updated events into runtime chat usage events", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const client = new HubSessionClient({
+			address: "ws://127.0.0.1:25463/hub",
+			clientId: "client-1",
+		});
+		await client.connect();
+		const socket = MockWebSocket.instances[0];
+		if (!socket) {
+			throw new Error("expected websocket");
+		}
+		const received: Array<{
+			sessionId: string;
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const unsubscribe = client.streamEvents(
+			{ sessionIds: ["session-1"] },
+			{
+				onEvent: (event) => {
+					received.push(event);
+				},
+			},
+		);
+
+		socket.emitFrame({
+			kind: "event",
+			envelope: {
+				version: "v1",
+				eventId: "evt-usage",
+				event: "usage.updated",
+				timestamp: Date.now(),
+				sessionId: "session-1",
+				payload: {
+					delta: { inputTokens: 7, outputTokens: 5, totalCost: 0.12 },
+					aggregateUsage: { inputTokens: 17, outputTokens: 8, totalCost: 0.23 },
+					agent: { kind: "teammate", teamAgentId: "investigator" },
+				},
+			},
+		});
+
+		expect(received).toEqual([
+			{
+				sessionId: "session-1",
+				eventType: "runtime.chat.usage",
+				payload: {
+					delta: { inputTokens: 7, outputTokens: 5, totalCost: 0.12 },
+					aggregateUsage: { inputTokens: 17, outputTokens: 8, totalCost: 0.23 },
+					agent: { kind: "teammate", teamAgentId: "investigator" },
+				},
+			},
+		]);
+
+		unsubscribe();
+		client.close();
+	});
+
+	it("maps schedule execution events without requiring an envelope session id", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const client = new HubSessionClient({
+			address: "ws://127.0.0.1:25463/hub",
+			clientId: "client-1",
+		});
+		await client.connect();
+		const socket = MockWebSocket.instances[0];
+		if (!socket) {
+			throw new Error("expected websocket");
+		}
+		const received: Array<{
+			sessionId: string;
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const unsubscribe = client.streamEvents(
+			{ clientId: "schedule-listener" },
+			{
+				onEvent: (event) => {
+					received.push(event);
+				},
+			},
+		);
+
+		socket.emitFrame({
+			kind: "event",
+			envelope: {
+				version: "v1",
+				eventId: "evt-schedule",
+				event: "schedule.execution_completed",
+				timestamp: Date.now(),
+				payload: {
+					scheduleId: "sched_1",
+					executionId: "run_1",
+					sessionId: "session-1",
+					status: "success",
+				},
+			},
+		});
+
+		expect(received).toEqual([
+			{
+				sessionId: "session-1",
+				eventType: "schedule.execution.completed",
+				payload: {
+					scheduleId: "sched_1",
+					executionId: "run_1",
+					sessionId: "session-1",
+					status: "success",
+				},
+			},
+		]);
+
+		unsubscribe();
+		client.close();
+	});
+
+	it("maps failed schedule execution events", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const client = new HubSessionClient({
+			address: "ws://127.0.0.1:25463/hub",
+			clientId: "client-1",
+		});
+		await client.connect();
+		const socket = MockWebSocket.instances[0];
+		if (!socket) {
+			throw new Error("expected websocket");
+		}
+		const received: Array<{
+			sessionId: string;
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const unsubscribe = client.streamEvents(
+			{ clientId: "schedule-listener" },
+			{
+				onEvent: (event) => {
+					received.push(event);
+				},
+			},
+		);
+
+		socket.emitFrame({
+			kind: "event",
+			envelope: {
+				version: "v1",
+				eventId: "evt-schedule-failed",
+				event: "schedule.execution_failed",
+				timestamp: Date.now(),
+				payload: {
+					scheduleId: "sched_1",
+					executionId: "run_1",
+					sessionId: "session-1",
+					status: "failed",
+					errorMessage: "runtime failed",
+				},
+			},
+		});
+
+		expect(received).toEqual([
+			{
+				sessionId: "session-1",
+				eventType: "schedule.execution.failed",
+				payload: {
+					scheduleId: "sched_1",
+					executionId: "run_1",
+					sessionId: "session-1",
+					status: "failed",
+					errorMessage: "runtime failed",
+				},
+			},
+		]);
+
+		unsubscribe();
+		client.close();
+	});
+});
diff --git a/sdk/packages/core/src/hub/client/session-client.ts b/sdk/packages/core/src/hub/client/session-client.ts
new file mode 100644
index 0000000..a0c2d46
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/session-client.ts
@@ -0,0 +1,734 @@
+import type * as LlmsProviders from "@cline/llms";
+import type {
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+	ChatStartSessionResponse,
+	ChatTurnResult,
+	HubEventEnvelope,
+	TeamProgressProjectionEvent,
+} from "@cline/shared";
+import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
+import { isSessionNotFoundError } from "../../runtime/host/runtime-host";
+import { NodeHubClient } from "../client";
+
+type ScheduleClientRecord = Record<string, unknown> & {
+	metadata?: Record<string, unknown>;
+};
+
+export interface HubSessionClientOptions {
+	address: string;
+	authToken?: string;
+	clientId?: string;
+	clientType?: string;
+	displayName?: string;
+	workspaceRoot?: string;
+	cwd?: string;
+	metadata?: Record<string, unknown>;
+}
+
+export interface HubSessionRow {
+	sessionId: string;
+	parentSessionId?: string;
+	metadata?: Record<string, unknown>;
+	messagesPath?: string;
+}
+
+export interface HubStreamEvent {
+	sessionId: string;
+	eventType: string;
+	payload: Record<string, unknown>;
+}
+
+export interface HubRestoreRequest {
+	sessionId: string;
+	checkpointRunCount: number;
+	config?: ChatStartSessionRequest;
+	restore?: {
+		messages?: boolean;
+		workspace?: boolean;
+		omitCheckpointMessageFromSession?: boolean;
+	};
+}
+
+export interface HubRestoreResponse {
+	sessionId?: string;
+	startResult?: {
+		sessionId: string;
+		manifestPath: string;
+		messagesPath: string;
+	};
+	messages?: LlmsProviders.Message[];
+	checkpoint: CheckpointEntry;
+}
+
+export interface HubEventStreamHandlers {
+	onEvent?: (event: HubStreamEvent) => void;
+	onError?: (error: Error) => void;
+}
+
+export interface HubTeamProgressHandlers {
+	onProjection?: (event: TeamProgressProjectionEvent) => void;
+	onError?: (error: Error) => void;
+}
+
+function cloneRecord(
+	value: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+	return value ? JSON.parse(JSON.stringify(value)) : {};
+}
+
+function extractSessionRow(
+	payload: Record<string, unknown> | undefined,
+): HubSessionRow | undefined {
+	const session =
+		payload?.session && typeof payload.session === "object"
+			? (payload.session as Record<string, unknown>)
+			: undefined;
+	if (!session) {
+		return undefined;
+	}
+	const metadata =
+		session.metadata && typeof session.metadata === "object"
+			? cloneRecord(session.metadata as Record<string, unknown>)
+			: undefined;
+	return {
+		sessionId: typeof session.sessionId === "string" ? session.sessionId : "",
+		parentSessionId:
+			typeof metadata?.parentSessionId === "string"
+				? metadata.parentSessionId
+				: undefined,
+		messagesPath:
+			typeof metadata?.messagesPath === "string"
+				? metadata.messagesPath
+				: undefined,
+		metadata,
+	};
+}
+
+function hubReplyErrorMessage(
+	reply: { error?: { message?: string } },
+	command: string,
+): string {
+	return reply.error?.message ?? `hub command failed: ${command}`;
+}
+
+function normalizeFailedRunPayload(
+	payload: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+	const cloned = cloneRecord(payload);
+	if (typeof cloned.error === "string" && cloned.error.trim()) {
+		return { ...cloned, error: cloned.error.trim() };
+	}
+	const result =
+		cloned.result && typeof cloned.result === "object"
+			? (cloned.result as Record<string, unknown>)
+			: undefined;
+	if (typeof result?.text === "string" && result.text.trim()) {
+		return { ...cloned, error: result.text.trim() };
+	}
+	const resultError =
+		result?.error && typeof result.error === "object"
+			? (result.error as Record<string, unknown>)
+			: undefined;
+	if (typeof resultError?.message === "string" && resultError.message.trim()) {
+		return { ...cloned, error: resultError.message.trim() };
+	}
+	return cloned;
+}
+
+function payloadSessionId(
+	payload: Record<string, unknown> | undefined,
+): string | undefined {
+	const value = payload?.sessionId;
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function extractCheckpoint(
+	payload: Record<string, unknown> | undefined,
+): CheckpointEntry {
+	const checkpoint = payload?.checkpoint;
+	if (
+		!checkpoint ||
+		typeof checkpoint !== "object" ||
+		Array.isArray(checkpoint)
+	) {
+		throw new Error("hub checkpoint restore returned no checkpoint");
+	}
+	const record = checkpoint as Partial<CheckpointEntry>;
+	if (
+		typeof record.ref !== "string" ||
+		typeof record.createdAt !== "number" ||
+		typeof record.runCount !== "number"
+	) {
+		throw new Error("hub checkpoint restore returned an invalid checkpoint");
+	}
+	return record as CheckpointEntry;
+}
+
+function mapHubEvent(event: HubEventEnvelope): HubStreamEvent | undefined {
+	const payload = cloneRecord(event.payload);
+	if (event.event === "schedule.execution_completed") {
+		return {
+			sessionId: event.sessionId?.trim() || payloadSessionId(payload) || "",
+			eventType: "schedule.execution.completed",
+			payload,
+		};
+	}
+	if (event.event === "schedule.execution_failed") {
+		return {
+			sessionId: event.sessionId?.trim() || payloadSessionId(payload) || "",
+			eventType: "schedule.execution.failed",
+			payload,
+		};
+	}
+
+	const sessionId = event.sessionId?.trim();
+	if (!sessionId) {
+		return undefined;
+	}
+	switch (event.event) {
+		case "iteration.started":
+			return {
+				sessionId,
+				eventType: "runtime.chat.iteration_start",
+				payload,
+			};
+		case "iteration.finished":
+			return {
+				sessionId,
+				eventType: "runtime.chat.iteration_end",
+				payload,
+			};
+		case "assistant.delta":
+			return {
+				sessionId,
+				eventType: "runtime.chat.text_delta",
+				payload,
+			};
+		case "usage.updated":
+			return {
+				sessionId,
+				eventType: "runtime.chat.usage",
+				payload,
+			};
+		case "tool.started":
+			return {
+				sessionId,
+				eventType: "runtime.chat.tool_call_start",
+				payload,
+			};
+		case "tool.finished":
+			return {
+				sessionId,
+				eventType: "runtime.chat.tool_call_end",
+				payload,
+			};
+		case "approval.requested":
+			return {
+				sessionId,
+				eventType: "approval.requested",
+				payload,
+			};
+		case "run.aborted":
+			return {
+				sessionId,
+				eventType: "runtime.chat.aborted",
+				payload,
+			};
+		case "run.failed":
+			return {
+				sessionId,
+				eventType: "runtime.chat.failed",
+				payload: normalizeFailedRunPayload(event.payload),
+			};
+		case "run.completed":
+			return {
+				sessionId,
+				eventType: "runtime.chat.completed",
+				payload,
+			};
+		default:
+			return undefined;
+	}
+}
+
+export class HubSessionClient {
+	private readonly client: NodeHubClient;
+	private metadataApplied = false;
+
+	constructor(private readonly options: HubSessionClientOptions) {
+		this.client = new NodeHubClient({
+			url: options.address,
+			authToken: options.authToken,
+			clientId: options.clientId,
+			clientType: options.clientType ?? "hub-session-client",
+			displayName: options.displayName ?? "hub session client",
+			workspaceRoot: options.workspaceRoot,
+			cwd: options.cwd,
+		});
+	}
+
+	private async ensureMetadataApplied(): Promise<void> {
+		if (this.metadataApplied || !this.options.metadata) {
+			if (!this.options.metadata) {
+				await this.client.connect();
+			}
+			return;
+		}
+		await this.client.connect();
+		await this.client.command("client.update", {
+			metadata: this.options.metadata,
+		});
+		this.metadataApplied = true;
+	}
+
+	async connect(): Promise<void> {
+		await this.ensureMetadataApplied();
+	}
+
+	close(): void {
+		this.client.close();
+	}
+
+	async dispose(): Promise<void> {
+		await this.client.dispose();
+	}
+
+	async startRuntimeSession(
+		request: ChatStartSessionRequest,
+	): Promise<ChatStartSessionResponse> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("session.create", {
+			workspaceRoot: request.workspaceRoot,
+			cwd: request.cwd,
+			sessionConfig: {
+				providerId: request.provider,
+				modelId: request.model,
+				apiKey: request.apiKey,
+				cwd: request.cwd ?? request.workspaceRoot,
+				workspaceRoot: request.workspaceRoot,
+				systemPrompt: request.systemPrompt ?? "",
+				mode: request.mode ?? "act",
+				rules: request.rules,
+				maxIterations: request.maxIterations,
+				timeoutSeconds: request.timeoutSeconds,
+				enableTools: request.enableTools,
+				enableSpawnAgent: request.enableSpawn !== false,
+				enableAgentTeams: request.enableTeams !== false,
+				disableMcpSettingsTools: request.disableMcpSettingsTools,
+				missionLogIntervalSteps: request.missionStepInterval,
+				missionLogIntervalMs: request.missionTimeIntervalMs,
+			},
+			metadata: {
+				source: request.source ?? "cli",
+				provider: request.provider,
+				model: request.model,
+				enableTools: request.enableTools,
+				enableSpawn: request.enableSpawn,
+				enableTeams: request.enableTeams,
+				prompt: undefined,
+				interactive: request.interactive !== false,
+			},
+			runtimeOptions: {
+				mode: request.mode,
+				systemPrompt: request.systemPrompt,
+				maxIterations: request.maxIterations,
+				timeoutSeconds: request.timeoutSeconds,
+				enableTools: request.enableTools,
+				enableSpawn: request.enableSpawn,
+				enableTeams: request.enableTeams,
+				autoApproveTools: request.autoApproveTools,
+				toolExecutors: request.toolExecutors,
+				configExtensions: request.configExtensions,
+			},
+			modelSelection: {
+				provider: request.provider,
+				model: request.model,
+				apiKey: request.apiKey,
+			},
+			toolPolicies: request.toolPolicies,
+		});
+		const row = extractSessionRow(reply.payload);
+		if (!row?.sessionId) {
+			throw new Error("hub session create returned no session id");
+		}
+		return {
+			sessionId: row.sessionId,
+			startResult: {
+				sessionId: row.sessionId,
+				manifestPath: "",
+				messagesPath: row.messagesPath ?? "",
+			},
+		};
+	}
+
+	async sendRuntimeSession(
+		sessionId: string,
+		request: ChatRunTurnRequest,
+		options?: { timeoutMs?: number | null },
+	): Promise<{ result?: ChatTurnResult }> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command(
+			"session.send_input",
+			{
+				prompt: request.prompt,
+				mode: request.config.mode,
+				attachments: request.attachments,
+				delivery: request.delivery,
+				timeoutSeconds: request.config.timeoutSeconds,
+			},
+			sessionId,
+			options,
+		);
+		return {
+			result: reply.payload?.result as ChatTurnResult | undefined,
+		};
+	}
+
+	async stopRuntimeSession(sessionId: string): Promise<{ applied: boolean }> {
+		await this.ensureMetadataApplied();
+		await this.client.command("session.detach", { sessionId }, sessionId);
+		return { applied: true };
+	}
+
+	async abortRuntimeSession(sessionId: string): Promise<{ applied: boolean }> {
+		await this.ensureMetadataApplied();
+		await this.client.command("run.abort", { sessionId }, sessionId);
+		return { applied: true };
+	}
+
+	async updateSession(input: {
+		sessionId: string;
+		metadata?: Record<string, unknown>;
+	}): Promise<{ updated: boolean }> {
+		await this.ensureMetadataApplied();
+		await this.client.command(
+			"session.update",
+			{
+				sessionId: input.sessionId,
+				metadata: input.metadata,
+			},
+			input.sessionId,
+		);
+		return { updated: true };
+	}
+
+	async getSession(sessionId: string): Promise<HubSessionRow | undefined> {
+		await this.ensureMetadataApplied();
+		let reply: Awaited<ReturnType<NodeHubClient["command"]>>;
+		try {
+			reply = await this.client.command("session.get", undefined, sessionId);
+		} catch (error) {
+			if (isSessionNotFoundError(error)) {
+				return undefined;
+			}
+			throw error;
+		}
+		return extractSessionRow(reply.payload);
+	}
+
+	async readMessages(sessionId: string): Promise<LlmsProviders.Message[]> {
+		const target = sessionId.trim();
+		if (!target) {
+			return [];
+		}
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command(
+			"session.messages",
+			{ sessionId: target },
+			target,
+		);
+		if (!reply.ok) {
+			throw new Error(hubReplyErrorMessage(reply, "session.messages"));
+		}
+		const messages = reply.payload?.messages;
+		return Array.isArray(messages) ? (messages as LlmsProviders.Message[]) : [];
+	}
+
+	async restore(input: HubRestoreRequest): Promise<HubRestoreResponse> {
+		const sessionId = input.sessionId.trim();
+		if (!sessionId) {
+			throw new Error("sessionId is required");
+		}
+		const restoreMessages = input.restore?.messages !== false;
+		if (restoreMessages && !input.config) {
+			throw new Error("config is required when restore.messages is true");
+		}
+		await this.ensureMetadataApplied();
+		const request = input.config;
+		const reply = await this.client.command(
+			"session.restore",
+			{
+				sessionId,
+				checkpointRunCount: input.checkpointRunCount,
+				restore: input.restore,
+				...(request
+					? {
+							workspaceRoot: request.workspaceRoot,
+							cwd: request.cwd,
+							sessionConfig: {
+								providerId: request.provider,
+								modelId: request.model,
+								apiKey: request.apiKey,
+								cwd: request.cwd ?? request.workspaceRoot,
+								workspaceRoot: request.workspaceRoot,
+								systemPrompt: request.systemPrompt ?? "",
+								mode: request.mode ?? "act",
+								rules: request.rules,
+								maxIterations: request.maxIterations,
+								enableTools: request.enableTools,
+								enableSpawnAgent: request.enableSpawn !== false,
+								enableAgentTeams: request.enableTeams !== false,
+								disableMcpSettingsTools: request.disableMcpSettingsTools,
+								missionLogIntervalSteps: request.missionStepInterval,
+								missionLogIntervalMs: request.missionTimeIntervalMs,
+							},
+							metadata: {
+								source: request.source ?? "cli",
+								provider: request.provider,
+								model: request.model,
+								enableTools: request.enableTools,
+								enableSpawn: request.enableSpawn,
+								enableTeams: request.enableTeams,
+								prompt: undefined,
+								interactive: request.interactive !== false,
+							},
+							runtimeOptions: {
+								mode: request.mode,
+								systemPrompt: request.systemPrompt,
+								maxIterations: request.maxIterations,
+								enableTools: request.enableTools,
+								enableSpawn: request.enableSpawn,
+								enableTeams: request.enableTeams,
+								autoApproveTools: request.autoApproveTools,
+								configExtensions: request.configExtensions,
+							},
+							modelSelection: {
+								provider: request.provider,
+								model: request.model,
+								apiKey: request.apiKey,
+							},
+							toolPolicies: request.toolPolicies,
+						}
+					: {}),
+			},
+			sessionId,
+		);
+		if (!reply.ok) {
+			throw new Error(hubReplyErrorMessage(reply, "session.restore"));
+		}
+		const row = extractSessionRow(reply.payload);
+		if (restoreMessages && !row?.sessionId) {
+			throw new Error("hub checkpoint restore returned no session id");
+		}
+		const messages = Array.isArray(reply.payload?.messages)
+			? (reply.payload.messages as LlmsProviders.Message[])
+			: undefined;
+		const checkpoint = extractCheckpoint(reply.payload);
+		return {
+			sessionId: row?.sessionId,
+			startResult: row?.sessionId
+				? {
+						sessionId: row.sessionId,
+						manifestPath: "",
+						messagesPath: row.messagesPath ?? "",
+					}
+				: undefined,
+			...(messages ? { messages } : {}),
+			checkpoint,
+		};
+	}
+
+	async listSessions(input?: { limit?: number }): Promise<HubSessionRow[]> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("session.list", {
+			limit: input?.limit ?? 200,
+		});
+		const sessions = Array.isArray(reply.payload?.sessions)
+			? (reply.payload?.sessions as Record<string, unknown>[])
+			: [];
+		return sessions
+			.map((session) => extractSessionRow({ session }))
+			.filter((row): row is HubSessionRow => Boolean(row?.sessionId));
+	}
+
+	async deleteSession(
+		sessionId: string,
+		deleteCheckpointRefs = true,
+	): Promise<boolean> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("session.delete", {
+			sessionId,
+			deleteCheckpointRefs,
+		});
+		return reply.payload?.deleted === true;
+	}
+
+	async respondToolApproval(input: {
+		approvalId: string;
+		approved: boolean;
+		reason?: string;
+		responderClientId?: string;
+	}): Promise<void> {
+		await this.ensureMetadataApplied();
+		await this.client.command("approval.respond", {
+			approvalId: input.approvalId,
+			approved: input.approved,
+			payload: input.reason ? { reason: input.reason } : undefined,
+			responderClientId: input.responderClientId,
+		});
+	}
+
+	streamEvents(
+		input: { clientId?: string; sessionIds?: string[] },
+		handlers: HubEventStreamHandlers,
+	): () => void {
+		const allowed = new Set(
+			(input.sessionIds ?? []).map((id) => id.trim()).filter(Boolean),
+		);
+		const unsubscribe = this.client.subscribe((event: HubEventEnvelope) => {
+			const mapped = mapHubEvent(event);
+			if (!mapped) {
+				return;
+			}
+			if (allowed.size > 0 && !allowed.has(mapped.sessionId)) {
+				return;
+			}
+			handlers.onEvent?.(mapped);
+		});
+		void this.ensureMetadataApplied().catch((error) => {
+			handlers.onError?.(
+				error instanceof Error ? error : new Error(String(error)),
+			);
+		});
+		return unsubscribe;
+	}
+
+	streamTeamProgress(
+		_input: { clientId?: string },
+		handlers: HubTeamProgressHandlers,
+	): () => void {
+		const unsubscribe = this.client.subscribe((event: HubEventEnvelope) => {
+			if (event.event !== "team.progress" || !event.payload) {
+				return;
+			}
+			handlers.onProjection?.(
+				event.payload as unknown as TeamProgressProjectionEvent,
+			);
+		});
+		void this.ensureMetadataApplied().catch((error) => {
+			handlers.onError?.(
+				error instanceof Error ? error : new Error(String(error)),
+			);
+		});
+		return unsubscribe;
+	}
+
+	async createSchedule(
+		input: Record<string, unknown>,
+	): Promise<ScheduleClientRecord | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.create", input);
+		return reply.payload?.schedule as ScheduleClientRecord | undefined;
+	}
+
+	async listSchedules(_input?: {
+		limit?: number;
+	}): Promise<ScheduleClientRecord[]> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.list");
+		return Array.isArray(reply.payload?.schedules)
+			? (reply.payload?.schedules as ScheduleClientRecord[])
+			: [];
+	}
+
+	async getSchedule(
+		scheduleId: string,
+	): Promise<ScheduleClientRecord | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.get", { scheduleId });
+		return reply.payload?.schedule as ScheduleClientRecord | undefined;
+	}
+
+	async updateSchedule(
+		scheduleId: string,
+		input: Record<string, unknown>,
+	): Promise<ScheduleClientRecord | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.update", {
+			scheduleId,
+			...input,
+		});
+		return reply.payload?.schedule as ScheduleClientRecord | undefined;
+	}
+
+	async pauseSchedule(
+		scheduleId: string,
+	): Promise<ScheduleClientRecord | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.disable", { scheduleId });
+		return reply.payload?.schedule as ScheduleClientRecord | undefined;
+	}
+
+	async resumeSchedule(
+		scheduleId: string,
+	): Promise<ScheduleClientRecord | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.enable", { scheduleId });
+		return reply.payload?.schedule as ScheduleClientRecord | undefined;
+	}
+
+	async deleteSchedule(scheduleId: string): Promise<boolean> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.delete", { scheduleId });
+		return reply.payload?.deleted === true;
+	}
+
+	async triggerScheduleNow(
+		scheduleId: string,
+	): Promise<Record<string, unknown> | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.trigger", { scheduleId });
+		return reply.payload?.execution as Record<string, unknown> | undefined;
+	}
+
+	async listScheduleExecutions(
+		scheduleId: string,
+		limit?: number,
+	): Promise<Array<Record<string, unknown>>> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.list_executions", {
+			scheduleId,
+			limit,
+		});
+		return Array.isArray(reply.payload?.executions)
+			? (reply.payload?.executions as Array<Record<string, unknown>>)
+			: [];
+	}
+
+	async getScheduleStats(): Promise<Record<string, unknown> | undefined> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.stats");
+		return reply.payload?.stats as Record<string, unknown> | undefined;
+	}
+
+	async getActiveScheduledExecutions(): Promise<
+		Array<Record<string, unknown>>
+	> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.active");
+		return Array.isArray(reply.payload?.executions)
+			? (reply.payload?.executions as Array<Record<string, unknown>>)
+			: [];
+	}
+
+	async getUpcomingScheduledRuns(
+		limit?: number,
+	): Promise<Array<Record<string, unknown>>> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command("schedule.upcoming", { limit });
+		return Array.isArray(reply.payload?.upcoming)
+			? (reply.payload?.upcoming as Array<Record<string, unknown>>)
+			: [];
+	}
+}
diff --git a/sdk/packages/core/src/hub/client/ui-client.ts b/sdk/packages/core/src/hub/client/ui-client.ts
new file mode 100644
index 0000000..dc607ad
--- /dev/null
+++ b/sdk/packages/core/src/hub/client/ui-client.ts
@@ -0,0 +1,128 @@
+import type {
+	HubClientRecord,
+	HubEventEnvelope,
+	HubUINotifyPayload,
+	HubUIShowWindowPayload,
+	SessionRecord,
+} from "@cline/shared";
+import { NodeHubClient } from "../client";
+
+export interface HubUIClientOptions {
+	address: string;
+	authToken?: string;
+	clientId?: string;
+	clientType?: string;
+	displayName?: string;
+}
+
+/**
+ * A lightweight hub client for UI/notification concerns.
+ * Used by the menu bar app and other UI clients to send/receive
+ * UI events (notifications, show window, client tracking).
+ */
+export class HubUIClient {
+	private readonly client: NodeHubClient;
+
+	constructor(options: HubUIClientOptions) {
+		this.client = new NodeHubClient({
+			url: options.address,
+			authToken: options.authToken,
+			clientId: options.clientId,
+			clientType: options.clientType ?? "hub-ui-client",
+			displayName: options.displayName ?? "hub ui client",
+		});
+	}
+
+	async connect(): Promise<void> {
+		await this.client.connect();
+	}
+
+	close(): void {
+		this.client.close();
+	}
+
+	async dispose(): Promise<void> {
+		await this.client.dispose();
+	}
+
+	getClientId(): string {
+		return this.client.getClientId();
+	}
+
+	/**
+	 * Send a notification request to the hub.
+	 * The hub will broadcast a "ui.notify" event to all subscribers (e.g. the menu bar app).
+	 */
+	async sendNotify(payload: HubUINotifyPayload): Promise<void> {
+		await this.client.command(
+			"ui.notify",
+			payload as unknown as Record<string, unknown>,
+		);
+	}
+
+	/**
+	 * Request the hub to broadcast a "ui.show_window" event to all subscribers.
+	 */
+	async sendShowWindow(payload?: HubUIShowWindowPayload): Promise<void> {
+		await this.client.command(
+			"ui.show_window",
+			(payload ?? {}) as Record<string, unknown>,
+		);
+	}
+
+	async listClients(): Promise<HubClientRecord[]> {
+		const reply = await this.client.command("client.list");
+		return Array.isArray(reply.payload?.clients)
+			? (reply.payload.clients as HubClientRecord[])
+			: [];
+	}
+
+	async listSessions(limit = 200): Promise<SessionRecord[]> {
+		const reply = await this.client.command("session.list", { limit });
+		return Array.isArray(reply.payload?.sessions)
+			? (reply.payload.sessions as SessionRecord[])
+			: [];
+	}
+
+	/**
+	 * Subscribe to UI-relevant hub events.
+	 * Returns an unsubscribe function.
+	 */
+	subscribeUI(handlers: {
+		onNotify?: (payload: HubUINotifyPayload) => void;
+		onShowWindow?: (payload: HubUIShowWindowPayload) => void;
+		onClientRegistered?: (payload: Record<string, unknown>) => void;
+		onClientDisconnected?: (payload: Record<string, unknown>) => void;
+		onSessionCreated?: (payload: Record<string, unknown>) => void;
+		onSessionUpdated?: (payload: Record<string, unknown>) => void;
+		onSessionDetached?: (payload: Record<string, unknown>) => void;
+	}): () => void {
+		return this.client.subscribe((event: HubEventEnvelope) => {
+			switch (event.event) {
+				case "ui.notify":
+					handlers.onNotify?.(event.payload as unknown as HubUINotifyPayload);
+					break;
+				case "ui.show_window":
+					handlers.onShowWindow?.(
+						event.payload as unknown as HubUIShowWindowPayload,
+					);
+					break;
+				case "hub.client.registered":
+					handlers.onClientRegistered?.(event.payload ?? {});
+					break;
+				case "hub.client.disconnected":
+					handlers.onClientDisconnected?.(event.payload ?? {});
+					break;
+				case "session.created":
+					handlers.onSessionCreated?.(event.payload ?? {});
+					break;
+				case "session.updated":
+					handlers.onSessionUpdated?.(event.payload ?? {});
+					break;
+				case "session.detached":
+					handlers.onSessionDetached?.(event.payload ?? {});
+					break;
+			}
+		});
+	}
+}
diff --git a/sdk/packages/core/src/hub/daemon/entry.test.ts b/sdk/packages/core/src/hub/daemon/entry.test.ts
new file mode 100644
index 0000000..0c7ab1f
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/entry.test.ts
@@ -0,0 +1,166 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const {
+	mockCreateLocalHubScheduleRuntimeHandlers,
+	mockInitVcr,
+	mockResolveHubEndpointOptions,
+	mockResolveProductionHubOwnerContext,
+	mockResolveSharedHubOwnerContext,
+	mockStartHubWebSocketServer,
+} = vi.hoisted(() => ({
+	mockCreateLocalHubScheduleRuntimeHandlers: vi.fn(() => ({
+		startSession: vi.fn(),
+		sendSession: vi.fn(),
+		stopSession: vi.fn(),
+		abortSession: vi.fn(),
+	})),
+	mockInitVcr: vi.fn(),
+	mockResolveHubEndpointOptions: vi.fn(
+		(options: { host?: string; port?: number; pathname?: string }) => ({
+			host: options.host ?? "127.0.0.1",
+			port: options.port ?? 25463,
+			pathname: options.pathname ?? "/hub",
+		}),
+	),
+	mockResolveProductionHubOwnerContext: vi.fn(() => ({
+		ownerId: "production",
+		discoveryPath: "/tmp/cline-data/locks/hub/production.json",
+	})),
+	mockResolveSharedHubOwnerContext: vi.fn(() => ({
+		ownerId: "shared",
+		discoveryPath: "/tmp/cline-data/locks/hub/owners/shared.json",
+	})),
+	mockStartHubWebSocketServer: vi.fn(async () => ({
+		close: vi.fn(async () => undefined),
+	})),
+}));
+
+const {
+	mockDaemonTelemetryService,
+	mockDaemonTelemetryDispose,
+	mockCreateHubDaemonTelemetry,
+} = vi.hoisted(() => {
+	const telemetry = { capture: vi.fn() };
+	const dispose = vi.fn(async () => undefined);
+	return {
+		mockDaemonTelemetryService: telemetry,
+		mockDaemonTelemetryDispose: dispose,
+		mockCreateHubDaemonTelemetry: vi.fn(() => ({
+			telemetry,
+			dispose,
+		})),
+	};
+});
+
+vi.mock("@cline/shared", () => ({
+	initVcr: mockInitVcr,
+	resolveClineBuildEnv: () => "production",
+}));
+
+vi.mock("../daemon/runtime-handlers", () => ({
+	createLocalHubScheduleRuntimeHandlers:
+		mockCreateLocalHubScheduleRuntimeHandlers,
+}));
+
+vi.mock("../discovery/defaults", () => ({
+	resolveHubEndpointOptions: mockResolveHubEndpointOptions,
+}));
+
+vi.mock("../discovery/workspace", () => ({
+	resolveProductionHubOwnerContext: mockResolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext: mockResolveSharedHubOwnerContext,
+}));
+
+vi.mock("../server", () => ({
+	startHubWebSocketServer: mockStartHubWebSocketServer,
+}));
+
+vi.mock("./telemetry", () => ({
+	createHubDaemonTelemetry: mockCreateHubDaemonTelemetry,
+}));
+
+const originalArgv = [...process.argv];
+const originalCwd = process.cwd();
+
+describe("hub daemon entry", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		process.argv = [...originalArgv];
+		process.chdir(originalCwd);
+		vi.restoreAllMocks();
+		vi.resetModules();
+		mockCreateLocalHubScheduleRuntimeHandlers.mockClear();
+		mockInitVcr.mockClear();
+		mockResolveHubEndpointOptions.mockClear();
+		mockResolveProductionHubOwnerContext.mockClear();
+		mockResolveSharedHubOwnerContext.mockClear();
+		mockStartHubWebSocketServer.mockClear();
+		mockCreateHubDaemonTelemetry.mockClear();
+		mockDaemonTelemetryDispose.mockClear();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("starts the daemon with cron options for the daemon workspace root", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "cline-hub-entry-test-"));
+		tempDirs.push(cwd);
+		process.argv = [
+			"node",
+			"entry.js",
+			"--cwd",
+			cwd,
+			"--host",
+			"127.0.0.1",
+			"--port",
+			"30000",
+			"--pathname",
+			"/hub",
+		];
+		vi.spyOn(process, "on").mockImplementation(() => process);
+
+		await import("./entry");
+		await vi.waitFor(() => {
+			expect(mockStartHubWebSocketServer).toHaveBeenCalled();
+		});
+
+		expect(mockStartHubWebSocketServer).toHaveBeenCalledWith(
+			expect.objectContaining({
+				host: "127.0.0.1",
+				port: 30000,
+				pathname: "/hub",
+				owner: expect.objectContaining({ ownerId: "production" }),
+				telemetry: mockDaemonTelemetryService,
+				cronOptions: { workspaceRoot: cwd },
+			}),
+		);
+		expect(mockCreateLocalHubScheduleRuntimeHandlers).toHaveBeenCalledOnce();
+		expect(mockCreateLocalHubScheduleRuntimeHandlers).toHaveBeenCalledWith({
+			telemetry: mockDaemonTelemetryService,
+		});
+	});
+
+	it("disposes telemetry and exits when server startup fails", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "cline-hub-entry-test-"));
+		tempDirs.push(cwd);
+		process.argv = ["node", "entry.js", "--cwd", cwd];
+		vi.spyOn(process, "on").mockImplementation(() => process);
+		vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+		const exitSpy = vi
+			.spyOn(process, "exit")
+			.mockImplementation(() => undefined as never);
+		mockStartHubWebSocketServer.mockRejectedValueOnce(
+			new Error("port already in use"),
+		);
+
+		await import("./entry");
+		await vi.waitFor(() => {
+			expect(exitSpy).toHaveBeenCalledWith(1);
+		});
+		expect(mockDaemonTelemetryDispose).toHaveBeenCalled();
+	});
+});
diff --git a/sdk/packages/core/src/hub/daemon/entry.ts b/sdk/packages/core/src/hub/daemon/entry.ts
new file mode 100644
index 0000000..f723718
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/entry.ts
@@ -0,0 +1,155 @@
+import { AgentRuntimeAbortError } from "@cline/agents";
+import { initVcr, resolveClineBuildEnv } from "@cline/shared";
+import { createLocalHubScheduleRuntimeHandlers } from "../daemon/runtime-handlers";
+import { resolveHubEndpointOptions } from "../discovery/defaults";
+import {
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+} from "../discovery/workspace";
+import { startHubWebSocketServer } from "../server";
+import { createHubDaemonTelemetry } from "./telemetry";
+
+initVcr(process.env.CLINE_VCR);
+
+function parseArgs(argv: string[]): {
+	cwd: string;
+	host?: string;
+	port?: number;
+	pathname?: string;
+} {
+	let cwd = process.cwd();
+	let host: string | undefined;
+	let port: number | undefined;
+	let pathname: string | undefined;
+
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		const value = argv[index + 1];
+		if (arg === "--cwd" && value) {
+			cwd = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--host" && value) {
+			host = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--port" && value) {
+			const parsed = Number(value);
+			if (Number.isFinite(parsed)) {
+				port = parsed;
+			}
+			index += 1;
+			continue;
+		}
+		if (arg === "--pathname" && value) {
+			pathname = value;
+			index += 1;
+		}
+	}
+
+	return { cwd, host, port, pathname };
+}
+
+async function main(): Promise<void> {
+	const options = parseArgs(process.argv.slice(2));
+	process.chdir(options.cwd);
+
+	const endpoint = resolveHubEndpointOptions({
+		host: options.host,
+		port: options.port,
+		pathname: options.pathname,
+	});
+
+	const daemonTelemetry = createHubDaemonTelemetry();
+
+	let server: Awaited<ReturnType<typeof startHubWebSocketServer>>;
+	try {
+		server = await startHubWebSocketServer({
+			host: endpoint.host,
+			port: endpoint.port,
+			pathname: endpoint.pathname,
+			owner:
+				resolveClineBuildEnv() === "production"
+					? resolveProductionHubOwnerContext()
+					: resolveSharedHubOwnerContext(),
+			telemetry: daemonTelemetry.telemetry,
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers({
+				telemetry: daemonTelemetry.telemetry,
+			}),
+			cronOptions: { workspaceRoot: options.cwd },
+		});
+	} catch (error) {
+		// Flush before the top-level catch exits so failed daemon starts are
+		// still visible in telemetry instead of dying silently.
+		await daemonTelemetry.dispose().catch(() => undefined);
+		throw error;
+	}
+
+	const shutdown = async (): Promise<void> => {
+		await server.close();
+		await daemonTelemetry.dispose().catch(() => undefined);
+		process.exit(0);
+	};
+
+	let fatalShutdownStarted = false;
+	const shutdownFatal = (label: string, error: unknown): void => {
+		if (fatalShutdownStarted) {
+			return;
+		}
+		fatalShutdownStarted = true;
+		const message =
+			error instanceof Error ? error.stack || error.message : String(error);
+		process.stderr.write(`[hub-daemon] ${label}: ${message}\n`);
+		void server
+			.close()
+			.catch((closeError) => {
+				const closeMessage =
+					closeError instanceof Error
+						? closeError.stack || closeError.message
+						: String(closeError);
+				process.stderr.write(
+					`[hub-daemon] shutdown after ${label} failed: ${closeMessage}\n`,
+				);
+			})
+			.finally(() => {
+				void daemonTelemetry
+					.dispose()
+					.catch(() => undefined)
+					.finally(() => {
+						process.exit(1);
+					});
+			});
+	};
+
+	process.on("SIGINT", () => {
+		void shutdown();
+	});
+	process.on("SIGTERM", () => {
+		void shutdown();
+	});
+	process.on("uncaughtException", (error) => {
+		shutdownFatal("uncaughtException", error);
+	});
+	process.on("unhandledRejection", (reason) => {
+		if (reason instanceof AgentRuntimeAbortError) {
+			process.stderr.write(
+				`[hub-daemon] ignored agent runtime abort rejection: ${reason.message}\n`,
+			);
+			return;
+		}
+		shutdownFatal("unhandledRejection", reason);
+	});
+
+	await new Promise<void>(() => {
+		// keep daemon process alive
+	});
+}
+
+void main().catch((error) => {
+	const message =
+		error instanceof Error ? error.stack || error.message : String(error);
+	process.stderr.write(`[hub-daemon] fatal: ${message}\n`);
+	process.exit(1);
+});
diff --git a/sdk/packages/core/src/hub/daemon/index.test.ts b/sdk/packages/core/src/hub/daemon/index.test.ts
new file mode 100644
index 0000000..94fe4e9
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/index.test.ts
@@ -0,0 +1,581 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+	spawn,
+	closeSync,
+	mkdirSync,
+	openSync,
+	rememberRecoverableLocalHubUrl,
+	verifyHubConnection,
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+	createHubServerUrl,
+	clearHubDiscovery,
+	probeHubServer,
+	requestHubShutdown,
+	readHubDiscovery,
+	resolveClineDataDir,
+	resolveHubBuildId,
+	writeHubDiscovery,
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+} = vi.hoisted(() => ({
+	spawn: vi.fn(() => ({ unref: vi.fn() })),
+	closeSync: vi.fn(),
+	mkdirSync: vi.fn(),
+	openSync: vi.fn(() => 17),
+	rememberRecoverableLocalHubUrl: vi.fn((url: string) => url),
+	verifyHubConnection: vi.fn(),
+	resolveProductionHubOwnerContext: vi.fn(() => ({
+		discoveryPath: "/tmp/hub-discovery.json",
+	})),
+	resolveSharedHubOwnerContext: vi.fn(() => ({
+		discoveryPath: "/tmp/hub-discovery.json",
+	})),
+	createHubServerUrl: vi.fn(
+		(host: string, port: number, pathname: string) =>
+			`ws://${host}:${port}${pathname}`,
+	),
+	clearHubDiscovery: vi.fn(async () => undefined),
+	probeHubServer: vi.fn(),
+	requestHubShutdown: vi.fn(async () => true),
+	readHubDiscovery: vi.fn(),
+	resolveClineDataDir: vi.fn(() => "/tmp/cline-data"),
+	resolveHubBuildId: vi.fn(() => "current-build"),
+	writeHubDiscovery: vi.fn(),
+	CLINE_RUN_AS_HUB_DAEMON_ENV: "CLINE_RUN_AS_HUB_DAEMON",
+}));
+
+const originalRunAsHubDaemon = process.env[CLINE_RUN_AS_HUB_DAEMON_ENV];
+
+vi.mock("node:child_process", () => ({
+	spawn,
+}));
+
+vi.mock("node:fs", () => ({
+	closeSync,
+	mkdirSync,
+	openSync,
+}));
+
+vi.mock("@cline/shared", () => ({
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+	CLINE_HUB_PORT: 25463,
+	CLINE_HUB_DEV_PORT: 25466,
+	isHubProtocolCompatible: (record: { protocolVersion?: string }) => ({
+		compatible: record.protocolVersion === "v1",
+	}),
+	isHubDaemonProcess: (env: NodeJS.ProcessEnv = process.env) =>
+		env[CLINE_RUN_AS_HUB_DAEMON_ENV] === "1",
+	resolveClineBuildEnv: () => "production",
+	withResolvedClineBuildEnv: (env: NodeJS.ProcessEnv) => env,
+}));
+
+vi.mock("../client", () => ({
+	rememberRecoverableLocalHubUrl,
+	requestHubShutdown,
+	verifyHubConnection,
+}));
+
+vi.mock("../discovery/workspace", () => ({
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+}));
+
+vi.mock("../discovery", () => ({
+	clearHubDiscovery,
+	createHubServerUrl,
+	probeHubServer,
+	readHubDiscovery,
+	resolveClineDataDir,
+	resolveHubBuildId,
+	writeHubDiscovery,
+}));
+
+describe("ensureDetachedHubServer", () => {
+	const fetchMock = vi.fn(async () => ({ ok: true }));
+
+	beforeEach(() => {
+		delete process.env[CLINE_RUN_AS_HUB_DAEMON_ENV];
+		spawn.mockReset();
+		spawn.mockImplementation(() => ({ unref: vi.fn() }));
+		closeSync.mockReset();
+		mkdirSync.mockReset();
+		openSync.mockReset();
+		openSync.mockImplementation(() => 17);
+		rememberRecoverableLocalHubUrl.mockReset();
+		rememberRecoverableLocalHubUrl.mockImplementation((url: string) => url);
+		verifyHubConnection.mockReset();
+		clearHubDiscovery.mockReset();
+		clearHubDiscovery.mockResolvedValue(undefined);
+		probeHubServer.mockReset();
+		requestHubShutdown.mockReset();
+		requestHubShutdown.mockResolvedValue(true);
+		readHubDiscovery.mockReset();
+		vi.stubGlobal("fetch", fetchMock);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+		vi.unstubAllGlobals();
+		if (originalRunAsHubDaemon === undefined) {
+			delete process.env[CLINE_RUN_AS_HUB_DAEMON_ENV];
+		} else {
+			process.env[CLINE_RUN_AS_HUB_DAEMON_ENV] = originalRunAsHubDaemon;
+		}
+	});
+
+	it("does not use port 0 for default production startup", async () => {
+		readHubDiscovery.mockResolvedValue(undefined);
+		probeHubServer.mockResolvedValueOnce(undefined).mockResolvedValueOnce({
+			url: "ws://127.0.0.1:25463/hub",
+			protocolVersion: "v1",
+			buildId: "current-build",
+		});
+		verifyHubConnection.mockResolvedValueOnce(true);
+		readHubDiscovery.mockResolvedValueOnce(undefined).mockResolvedValueOnce({
+			url: "ws://127.0.0.1:25463/hub",
+			buildId: "current-build",
+			authToken: "new-token",
+		});
+
+		const { ensureDetachedHubServer } = await import(".");
+		const result = await ensureDetachedHubServer("/workspace");
+		const spawnCalls = (spawn as unknown as { mock: { calls: unknown[][] } })
+			.mock.calls;
+		const spawnArgs = spawnCalls[0]?.[1] as string[] | undefined;
+		const spawnOptions = spawnCalls[0]?.[2] as
+			| { env?: NodeJS.ProcessEnv }
+			| undefined;
+
+		expect(result).toEqual({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "new-token",
+		});
+		expect(spawn).toHaveBeenCalledOnce();
+		expect(spawnArgs).toContain("--port");
+		expect(spawnArgs).toContain("25463");
+		expect(spawnArgs).not.toContain("0");
+		expect(spawnOptions?.env?.[CLINE_RUN_AS_HUB_DAEMON_ENV]).toBe("1");
+	});
+
+	it("retries a transient ETXTBSY spawn failure while starting the detached daemon", async () => {
+		vi.useFakeTimers();
+		try {
+			const textFileBusy = Object.assign(
+				new Error(
+					"ETXTBSY: text file is busy, posix_spawn '/usr/local/bin/cline'",
+				),
+				{ code: "ETXTBSY" },
+			);
+			spawn
+				.mockImplementationOnce(() => {
+					throw textFileBusy;
+				})
+				.mockImplementationOnce(() => ({ unref: vi.fn() }));
+			readHubDiscovery.mockResolvedValueOnce(undefined).mockResolvedValueOnce({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "new-token",
+			});
+			probeHubServer.mockResolvedValueOnce(undefined).mockResolvedValueOnce({
+				url: "ws://127.0.0.1:25463/hub",
+				protocolVersion: "v1",
+				buildId: "current-build",
+			});
+			verifyHubConnection.mockResolvedValueOnce(true);
+
+			const { ensureDetachedHubServer } = await import(".");
+			const pending = ensureDetachedHubServer("/workspace");
+			await vi.runAllTimersAsync();
+			const result = await pending;
+
+			expect(result).toEqual({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "new-token",
+			});
+			expect(spawn).toHaveBeenCalledTimes(2);
+			expect(closeSync).toHaveBeenCalledTimes(2);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("does not spawn another detached daemon from inside the hub daemon process", async () => {
+		process.env[CLINE_RUN_AS_HUB_DAEMON_ENV] = "1";
+
+		const { spawnDetachedHubServer } = await import(".");
+		spawnDetachedHubServer("/workspace");
+
+		expect(spawn).not.toHaveBeenCalled();
+		expect(openSync).not.toHaveBeenCalled();
+	});
+
+	it("does not prewarm another detached daemon from inside the hub daemon process", async () => {
+		process.env[CLINE_RUN_AS_HUB_DAEMON_ENV] = "1";
+
+		const { prewarmDetachedHubServer } = await import(".");
+		prewarmDetachedHubServer("/workspace");
+
+		expect(readHubDiscovery).not.toHaveBeenCalled();
+		expect(spawn).not.toHaveBeenCalled();
+	});
+
+	it("clears stale discovery when prewarm finds an unreachable discovered hub", async () => {
+		readHubDiscovery.mockResolvedValueOnce({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "old-token",
+		});
+		probeHubServer
+			.mockResolvedValueOnce(undefined)
+			.mockResolvedValueOnce(undefined);
+
+		const { prewarmDetachedHubServer } = await import(".");
+		prewarmDetachedHubServer("/workspace");
+		await vi.waitFor(() => {
+			expect(clearHubDiscovery).toHaveBeenCalledWith("/tmp/hub-discovery.json");
+		});
+
+		expect(clearHubDiscovery.mock.invocationCallOrder[0]).toBeGreaterThan(
+			probeHubServer.mock.invocationCallOrder[0],
+		);
+		expect(spawn).toHaveBeenCalledOnce();
+	});
+
+	it("retries a transient ETXTBSY spawn failure while prewarming the detached daemon", async () => {
+		vi.useFakeTimers();
+		try {
+			const textFileBusy = Object.assign(
+				new Error(
+					"ETXTBSY: text file is busy, posix_spawn '/usr/local/bin/cline'",
+				),
+				{ code: "ETXTBSY" },
+			);
+			spawn
+				.mockImplementationOnce(() => {
+					throw textFileBusy;
+				})
+				.mockImplementationOnce(() => ({ unref: vi.fn() }));
+			readHubDiscovery.mockResolvedValueOnce(undefined);
+			probeHubServer.mockResolvedValueOnce(undefined);
+
+			const { prewarmDetachedHubServer } = await import(".");
+			prewarmDetachedHubServer("/workspace");
+			await vi.runAllTimersAsync();
+
+			expect(spawn).toHaveBeenCalledTimes(2);
+			expect(closeSync).toHaveBeenCalledTimes(2);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("prewarms on a fallback port when an empty-token hub cannot be retired", async () => {
+		vi.useFakeTimers();
+		const kill = vi.spyOn(process, "kill").mockImplementation(() => true);
+		try {
+			readHubDiscovery.mockResolvedValueOnce({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "",
+				pid: 12345,
+			});
+			probeHubServer.mockResolvedValue({
+				url: "ws://127.0.0.1:25463/hub",
+				protocolVersion: "v1",
+				buildId: "old-build",
+			});
+
+			const { prewarmDetachedHubServer } = await import(".");
+			prewarmDetachedHubServer("/workspace", { allowPortFallback: true });
+			await vi.runAllTimersAsync();
+
+			const spawnArgs = ((spawn as unknown as { mock: { calls: unknown[][] } })
+				.mock.calls[0]?.[1] ?? []) as string[];
+			expect(requestHubShutdown).toHaveBeenCalledWith(
+				"ws://127.0.0.1:25463/hub",
+				"",
+			);
+			expect(kill).toHaveBeenCalledWith(12345, "SIGTERM");
+			expect(spawn).toHaveBeenCalledOnce();
+			expect(spawnArgs).toContain("--port");
+			expect(spawnArgs).toContain("0");
+		} finally {
+			kill.mockRestore();
+			vi.useRealTimers();
+		}
+	});
+
+	it("reuses a protocol-compatible healthy hub from a different build", async () => {
+		const kill = vi.spyOn(process, "kill").mockImplementation(() => true);
+		try {
+			readHubDiscovery
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "old-token",
+				})
+				.mockResolvedValueOnce(undefined);
+			probeHubServer.mockResolvedValueOnce({
+				url: "ws://127.0.0.1:25463/hub",
+				protocolVersion: "v1",
+				buildId: "old-build",
+				pid: 12345,
+			});
+			verifyHubConnection.mockResolvedValueOnce(true);
+
+			const { ensureDetachedHubServer } = await import(".");
+			const result = await ensureDetachedHubServer("/workspace");
+
+			expect(result).toEqual({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "old-token",
+			});
+			expect(requestHubShutdown).not.toHaveBeenCalled();
+			expect(clearHubDiscovery).not.toHaveBeenCalled();
+			expect(kill).not.toHaveBeenCalled();
+			expect(spawn).not.toHaveBeenCalled();
+			expect(verifyHubConnection).toHaveBeenCalledOnce();
+		} finally {
+			kill.mockRestore();
+		}
+	});
+
+	it("retires an existing hub with an empty discovery auth token before starting a replacement", async () => {
+		const kill = vi.spyOn(process, "kill").mockImplementation(() => true);
+		try {
+			readHubDiscovery
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "",
+					pid: 12345,
+				})
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "new-token",
+				});
+			probeHubServer
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v1",
+					buildId: "current-build",
+				});
+			verifyHubConnection.mockResolvedValueOnce(true);
+
+			const { ensureDetachedHubServer } = await import(".");
+			const result = await ensureDetachedHubServer("/workspace");
+
+			expect(result).toEqual({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "new-token",
+			});
+			expect(requestHubShutdown).toHaveBeenCalledWith(
+				"ws://127.0.0.1:25463/hub",
+				"",
+			);
+			expect(kill).toHaveBeenCalledWith(12345, "SIGTERM");
+			expect(clearHubDiscovery).toHaveBeenCalledWith("/tmp/hub-discovery.json");
+			expect(spawn).toHaveBeenCalledOnce();
+		} finally {
+			kill.mockRestore();
+		}
+	});
+
+	it("throws a targeted error when an incompatible hub cannot be retired", async () => {
+		vi.useFakeTimers();
+		try {
+			readHubDiscovery.mockResolvedValue(undefined);
+			probeHubServer.mockResolvedValue({
+				url: "ws://127.0.0.1:25463/hub",
+				protocolVersion: "v2",
+				buildId: "future-build",
+			});
+
+			const { ensureDetachedHubServer } = await import(".");
+			const pending = expect(
+				ensureDetachedHubServer("/workspace"),
+			).rejects.toThrow(
+				"An incompatible Cline Hub is already running at ws://127.0.0.1:25463/hub and could not be retired automatically.",
+			);
+			await vi.runAllTimersAsync();
+
+			await pending;
+			expect(spawn).not.toHaveBeenCalled();
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("retires a legacy shared production hub before resolving the production hub", async () => {
+		const kill = vi.spyOn(process, "kill").mockImplementation(() => true);
+		try {
+			resolveSharedHubOwnerContext.mockReturnValueOnce({
+				discoveryPath: "/tmp/legacy-hub-discovery.json",
+			});
+			readHubDiscovery
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:39121/hub",
+					authToken: "legacy-token",
+					pid: 222,
+				})
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "new-token",
+				});
+			probeHubServer
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v1",
+					buildId: "current-build",
+				});
+			verifyHubConnection.mockResolvedValueOnce(true);
+
+			const { ensureDetachedHubServer } = await import(".");
+			const result = await ensureDetachedHubServer("/workspace");
+
+			expect(result).toEqual({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "new-token",
+			});
+			expect(requestHubShutdown).toHaveBeenCalledWith(
+				"ws://127.0.0.1:39121/hub",
+				"legacy-token",
+			);
+			expect(kill).toHaveBeenCalledWith(222, "SIGTERM");
+			expect(clearHubDiscovery).toHaveBeenCalledWith(
+				"/tmp/legacy-hub-discovery.json",
+			);
+			expect(spawn).toHaveBeenCalledOnce();
+		} finally {
+			kill.mockRestore();
+		}
+	});
+
+	it("throws when a compatible expected hub has no discovery record", async () => {
+		readHubDiscovery.mockResolvedValue(undefined);
+		probeHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			protocolVersion: "v1",
+			buildId: "current-build",
+		});
+
+		const { ensureDetachedHubServer } = await import(".");
+		await expect(ensureDetachedHubServer("/workspace")).rejects.toThrow(
+			"A compatible Cline Hub is already running at ws://127.0.0.1:25463/hub, but its discovery record is missing or unreadable.",
+		);
+		expect(spawn).not.toHaveBeenCalled();
+	});
+
+	it("uses matching discovery pid and token when retiring an incompatible expected-url hub", async () => {
+		const kill = vi
+			.spyOn(process, "kill")
+			.mockImplementation((_pid, signal) => {
+				if (signal === 0) {
+					throw Object.assign(new Error("missing"), { code: "ESRCH" });
+				}
+				return true;
+			});
+		try {
+			readHubDiscovery
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "old-token",
+					pid: 12345,
+				})
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "new-token",
+				});
+			probeHubServer
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v2",
+					buildId: "future-build",
+				})
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v1",
+					buildId: "current-build",
+				});
+			verifyHubConnection.mockResolvedValueOnce(true);
+
+			const { ensureDetachedHubServer } = await import(".");
+			const result = await ensureDetachedHubServer("/workspace");
+
+			expect(result).toEqual({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "new-token",
+			});
+			expect(requestHubShutdown).toHaveBeenCalledWith(
+				"ws://127.0.0.1:25463/hub",
+				"old-token",
+			);
+			expect(kill).toHaveBeenCalledWith(12345, "SIGTERM");
+		} finally {
+			kill.mockRestore();
+		}
+	});
+
+	it("does not reuse a healthy hub without protocol metadata", async () => {
+		const kill = vi.spyOn(process, "kill").mockImplementation(() => true);
+		try {
+			readHubDiscovery
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					authToken: "old-token",
+				})
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v1",
+					buildId: "current-build",
+					authToken: "new-token",
+				});
+			probeHubServer
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					pid: 12345,
+				})
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					pid: 12345,
+				})
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce(undefined)
+				.mockResolvedValueOnce({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v1",
+					buildId: "current-build",
+				})
+				.mockResolvedValue({
+					url: "ws://127.0.0.1:25463/hub",
+					protocolVersion: "v1",
+					buildId: "current-build",
+				});
+			verifyHubConnection.mockResolvedValueOnce(true);
+
+			const { ensureDetachedHubServer } = await import(".");
+			const result = await ensureDetachedHubServer("/workspace");
+
+			expect(result).toEqual({
+				url: "ws://127.0.0.1:25463/hub",
+				authToken: "new-token",
+			});
+			expect(requestHubShutdown).toHaveBeenCalledWith(
+				"ws://127.0.0.1:25463/hub",
+				"old-token",
+			);
+			expect(clearHubDiscovery).toHaveBeenCalledWith("/tmp/hub-discovery.json");
+			expect(clearHubDiscovery.mock.invocationCallOrder[0]).toBeGreaterThan(
+				probeHubServer.mock.invocationCallOrder[2],
+			);
+			expect(kill).toHaveBeenCalledWith(12345, "SIGTERM");
+			expect(spawn).toHaveBeenCalledOnce();
+			expect(verifyHubConnection).toHaveBeenCalledOnce();
+		} finally {
+			kill.mockRestore();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/hub/daemon/index.ts b/sdk/packages/core/src/hub/daemon/index.ts
new file mode 100644
index 0000000..7b298a0
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/index.ts
@@ -0,0 +1,489 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync, openSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+	isHubDaemonProcess,
+	isHubProtocolCompatible,
+	resolveClineBuildEnv,
+	withResolvedClineBuildEnv,
+} from "@cline/shared";
+import {
+	rememberRecoverableLocalHubUrl,
+	requestHubShutdown,
+	verifyHubConnection,
+} from "../client";
+import {
+	clearHubDiscovery,
+	createHubServerUrl,
+	type HubOwnerContext,
+	type HubServerProbeRecord,
+	probeHubServer,
+	readHubDiscovery,
+	resolveClineDataDir,
+} from "../discovery";
+import {
+	type HubEndpointOverrides,
+	resolveHubEndpointOptions,
+} from "../discovery/defaults";
+import {
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+} from "../discovery/workspace";
+
+const HUB_STARTUP_TIMEOUT_MS = 8_000;
+const HUB_STARTUP_POLL_MS = 200;
+const HUB_RETIRE_TIMEOUT_MS = 3_000;
+const HUB_RETIRE_POLL_MS = 100;
+const HUB_SPAWN_RETRY_DELAYS_MS = [100, 250, 500, 1_000, 2_000];
+const COMPILED_BUN_HUB_DAEMON_ARG = "--cline-hub-daemon";
+
+function endpointArgs(endpoint: HubEndpointOverrides): string[] {
+	return [
+		...(endpoint.host ? ["--host", endpoint.host] : []),
+		...(typeof endpoint.port === "number"
+			? ["--port", String(endpoint.port)]
+			: []),
+		...(endpoint.pathname ? ["--pathname", endpoint.pathname] : []),
+	];
+}
+
+function openDetachedHubLogFile(): { fd: number; logPath: string } | undefined {
+	try {
+		const logPath = join(resolveClineDataDir(), "logs", "hub-daemon.log");
+		mkdirSync(dirname(logPath), { recursive: true });
+		return { fd: openSync(logPath, "a"), logPath };
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveDefaultHubOwnerContext() {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+function isCompatibleHubRecord(record: HubServerProbeRecord): boolean {
+	return isHubProtocolCompatible(record).compatible;
+}
+
+function withMatchingDiscoveryRetirementMetadata(
+	probe: HubServerProbeRecord,
+	discovered: { url?: string; authToken?: string; pid?: number } | undefined,
+	expectedUrl: string,
+): HubServerProbeRecord {
+	if (!discovered || discovered.url !== expectedUrl) {
+		return probe;
+	}
+	return {
+		...probe,
+		authToken: probe.authToken ?? discovered.authToken,
+		pid: probe.pid ?? discovered.pid,
+	};
+}
+
+async function safeProbeHubServer(
+	url: string,
+	authToken?: string,
+): Promise<HubServerProbeRecord | undefined> {
+	try {
+		return await probeHubServer(url, { authToken });
+	} catch {
+		return undefined;
+	}
+}
+
+async function waitForHubToRetire(
+	url: string,
+	timeoutMs: number,
+): Promise<boolean> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const healthy = await safeProbeHubServer(url);
+		if (!healthy?.url) {
+			return true;
+		}
+		await new Promise((resolve) => setTimeout(resolve, HUB_RETIRE_POLL_MS));
+	}
+	return false;
+}
+
+async function retireDiscoveredHub(
+	record: { url: string; authToken?: string; pid?: number },
+	discoveryPath: string,
+): Promise<boolean> {
+	await requestHubShutdown(record.url, record.authToken).catch(() => false);
+	if (record.pid) {
+		try {
+			process.kill(record.pid, "SIGTERM");
+		} catch {
+			// Best-effort cleanup only. A compatible hub may still start on a fallback port.
+		}
+	}
+	const retired = await waitForHubToRetire(record.url, HUB_RETIRE_TIMEOUT_MS);
+	await clearHubDiscovery(discoveryPath).catch(() => undefined);
+	return retired;
+}
+
+async function retireIncompatibleHub(
+	record: HubServerProbeRecord,
+	discoveryPath: string,
+): Promise<boolean> {
+	if (isCompatibleHubRecord(record)) {
+		return true;
+	}
+	return retireDiscoveredHub(record, discoveryPath);
+}
+
+/**
+ * Pre-singleton production builds tracked the local hub under the shared
+ * owner discovery path and spawned daemons on random fallback ports. Those
+ * daemons are invisible to the production owner context, so nothing would
+ * ever reuse or stop them. Retire the recorded legacy hub (its record carries
+ * the auth token and pid needed for a graceful stop) and clear the legacy
+ * record so upgrades do not leave orphaned daemons running stale code.
+ */
+async function retireLegacySharedHub(owner: HubOwnerContext): Promise<void> {
+	if (resolveClineBuildEnv() !== "production") {
+		return;
+	}
+	const legacy = resolveSharedHubOwnerContext();
+	if (legacy.discoveryPath === owner.discoveryPath) {
+		return;
+	}
+	const record = await readHubDiscovery(legacy.discoveryPath);
+	if (record?.url) {
+		await retireDiscoveredHub(record, legacy.discoveryPath);
+	} else {
+		await clearHubDiscovery(legacy.discoveryPath).catch(() => undefined);
+	}
+}
+
+function resolveDaemonEntryPath(): string {
+	const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+	return fileURLToPath(new URL(`./entry.${extension}`, import.meta.url));
+}
+
+function resolveLaunchCommand(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides,
+): {
+	launcher: string;
+	args: string[];
+	cwd: string;
+	env: NodeJS.ProcessEnv;
+} {
+	const daemonEntryPath = resolveDaemonEntryPath();
+	const execPath = process.execPath?.trim();
+	if (!execPath) {
+		throw new Error("unable to resolve runtime executable for hub daemon");
+	}
+	const isBunRuntime = basename(execPath).toLowerCase().includes("bun");
+	const isCompiledBunEmbeddedEntry = daemonEntryPath.startsWith("/$bunfs/");
+	const useDevelopmentConditions =
+		isBunRuntime && daemonEntryPath.toLowerCase().endsWith(".ts");
+	const entryArgs = isCompiledBunEmbeddedEntry
+		? [COMPILED_BUN_HUB_DAEMON_ARG]
+		: [
+				...(useDevelopmentConditions ? ["--conditions=development"] : []),
+				daemonEntryPath,
+			];
+	return {
+		launcher: execPath,
+		args: [...entryArgs, "--cwd", workspaceRoot, ...endpointArgs(endpoint)],
+		cwd: workspaceRoot,
+		env: {
+			...withResolvedClineBuildEnv(process.env),
+			CLINE_NO_INTERACTIVE: "1",
+			[CLINE_RUN_AS_HUB_DAEMON_ENV]: "1",
+		},
+	};
+}
+
+function isTextFileBusyError(error: unknown): boolean {
+	if (!error || typeof error !== "object") {
+		return false;
+	}
+	const code = "code" in error ? error.code : undefined;
+	if (code === "ETXTBSY") {
+		return true;
+	}
+	const message = "message" in error ? error.message : undefined;
+	return typeof message === "string" && message.includes("ETXTBSY");
+}
+
+export function spawnDetachedHubServer(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides = {},
+): void {
+	if (isHubDaemonProcess()) {
+		return;
+	}
+	const command = resolveLaunchCommand(workspaceRoot, endpoint);
+	const logFile = openDetachedHubLogFile();
+	try {
+		const child = spawn(command.launcher, command.args, {
+			detached: true,
+			stdio: logFile ? ["ignore", logFile.fd, logFile.fd] : "ignore",
+			env: command.env,
+			cwd: command.cwd,
+			// Prevent a console window from appearing on Windows; detached
+			// processes otherwise allocate a new visible console.
+			windowsHide: true,
+		});
+		child.unref();
+	} finally {
+		if (logFile) {
+			closeSync(logFile.fd);
+		}
+	}
+}
+
+export async function spawnDetachedHubServerWithRetry(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides = {},
+): Promise<void> {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			spawnDetachedHubServer(workspaceRoot, endpoint);
+			return;
+		} catch (error) {
+			const delay = HUB_SPAWN_RETRY_DELAYS_MS[attempt];
+			if (!isTextFileBusyError(error) || delay === undefined) {
+				throw error;
+			}
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+}
+
+export function prewarmDetachedHubServer(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides & { allowPortFallback?: boolean } = {},
+): void {
+	if (isHubDaemonProcess()) {
+		return;
+	}
+	const owner = resolveDefaultHubOwnerContext();
+	const resolvedEndpoint = resolveHubEndpointOptions(endpoint);
+	const expectedUrl = createHubServerUrl(
+		resolvedEndpoint.host,
+		resolvedEndpoint.port,
+		resolvedEndpoint.pathname,
+	);
+	const shouldUseFallbackPort =
+		endpoint.allowPortFallback === true && resolvedEndpoint.port !== 0;
+	void retireLegacySharedHub(owner)
+		.catch(() => undefined)
+		.then(() => readHubDiscovery(owner.discoveryPath))
+		.then(async (discovered) => {
+			let retiredUnusableDiscovery = false;
+			if (discovered?.url) {
+				if (!discovered.authToken) {
+					retiredUnusableDiscovery = true;
+					const retired = await retireDiscoveredHub(
+						discovered,
+						owner.discoveryPath,
+					);
+					if (!retired && !shouldUseFallbackPort) {
+						return;
+					}
+				} else {
+					const healthy = await safeProbeHubServer(
+						discovered.url,
+						discovered.authToken,
+					);
+					if (
+						healthy?.url &&
+						isCompatibleHubRecord(healthy) &&
+						(await verifyHubConnection(healthy.url, {
+							authToken: discovered.authToken,
+						}))
+					) {
+						return;
+					}
+					if (healthy?.url) {
+						await retireIncompatibleHub(
+							{ ...healthy, authToken: discovered.authToken },
+							owner.discoveryPath,
+						);
+					} else {
+						await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+					}
+				}
+			}
+			const expected = await safeProbeHubServer(expectedUrl);
+			if (expected?.url) {
+				if (isCompatibleHubRecord(expected)) {
+					if (!shouldUseFallbackPort || !retiredUnusableDiscovery) {
+						return;
+					}
+				} else {
+					const retiredExpected = await retireIncompatibleHub(
+						{ ...expected, authToken: undefined },
+						owner.discoveryPath,
+					);
+					if (!retiredExpected && !shouldUseFallbackPort) {
+						return;
+					}
+				}
+			}
+			const spawnEndpoint = shouldUseFallbackPort
+				? { ...resolvedEndpoint, port: 0 }
+				: resolvedEndpoint;
+			await spawnDetachedHubServerWithRetry(workspaceRoot, spawnEndpoint);
+		})
+		.catch(() => {
+			// best-effort prewarm only
+		});
+}
+
+export interface DetachedHubResolution {
+	url: string;
+	authToken: string;
+}
+
+export async function ensureDetachedHubServer(
+	workspaceRoot: string,
+	endpointOverrides: HubEndpointOverrides & {
+		allowPortFallback?: boolean;
+	} = {},
+): Promise<DetachedHubResolution> {
+	const owner = resolveDefaultHubOwnerContext();
+	const hasExplicitEndpoint =
+		endpointOverrides.host !== undefined ||
+		endpointOverrides.port !== undefined ||
+		endpointOverrides.pathname !== undefined ||
+		!!process.env.CLINE_HUB_PORT?.trim();
+	const endpoint = resolveHubEndpointOptions(endpointOverrides);
+	const expectedUrl = createHubServerUrl(
+		endpoint.host,
+		endpoint.port,
+		endpoint.pathname,
+	);
+	const rememberIfManaged = (
+		result: DetachedHubResolution,
+	): DetachedHubResolution => {
+		if (!hasExplicitEndpoint) {
+			rememberRecoverableLocalHubUrl(result.url, result.authToken);
+		}
+		return result;
+	};
+	await retireLegacySharedHub(owner).catch(() => undefined);
+	const discovered = await readHubDiscovery(owner.discoveryPath);
+	let retiredUnusableDiscovery = false;
+	if (discovered?.url) {
+		const discoveredAuthToken = discovered.authToken;
+		if (!discoveredAuthToken) {
+			retiredUnusableDiscovery = true;
+			await retireDiscoveredHub(discovered, owner.discoveryPath);
+		} else {
+			const healthy = await safeProbeHubServer(
+				discovered.url,
+				discoveredAuthToken,
+			);
+			if (
+				healthy?.url &&
+				isCompatibleHubRecord(healthy) &&
+				(await verifyHubConnection(healthy.url, {
+					authToken: discoveredAuthToken,
+				}))
+			) {
+				return rememberIfManaged({
+					url: healthy.url,
+					authToken: discoveredAuthToken,
+				});
+			}
+			if (healthy?.url) {
+				await retireIncompatibleHub(
+					{ ...healthy, authToken: discoveredAuthToken },
+					owner.discoveryPath,
+				);
+			} else {
+				await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+			}
+		}
+	}
+	const expected = await safeProbeHubServer(expectedUrl);
+	if (expected?.url) {
+		const expectedForRetirement = withMatchingDiscoveryRetirementMetadata(
+			expected,
+			discovered,
+			expectedUrl,
+		);
+		if (isCompatibleHubRecord(expected)) {
+			const upgradeHint = retiredUnusableDiscovery
+				? " This can happen immediately after upgrading from a build that wrote an empty hub auth token; run 'cline doctor fix' to stop the old daemon and repair local hub discovery."
+				: "";
+			throw new Error(
+				`A compatible Cline Hub is already running at ${expectedUrl}, but its discovery record is missing or unreadable. Run 'cline doctor fix' to repair local hub discovery.${upgradeHint}`,
+			);
+		}
+		const retiredExpected = await retireIncompatibleHub(
+			expectedForRetirement,
+			owner.discoveryPath,
+		);
+		if (
+			!retiredExpected &&
+			endpointOverrides.allowPortFallback !== true &&
+			endpoint.port !== 0
+		) {
+			throw new Error(
+				`An incompatible Cline Hub is already running at ${expectedUrl} and could not be retired automatically. Run 'cline doctor fix' to stop stale hub daemons before starting a new hub.`,
+			);
+		}
+	}
+	const shouldUseFallbackPort =
+		endpointOverrides.allowPortFallback === true && endpoint.port !== 0;
+	const spawnEndpoint = shouldUseFallbackPort
+		? { ...endpoint, port: 0 }
+		: endpoint;
+	await spawnDetachedHubServerWithRetry(workspaceRoot, spawnEndpoint);
+	const deadline = Date.now() + HUB_STARTUP_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		const nextDiscovery = await readHubDiscovery(owner.discoveryPath);
+		if (nextDiscovery?.url && nextDiscovery.authToken) {
+			const healthy = await safeProbeHubServer(
+				nextDiscovery.url,
+				nextDiscovery.authToken,
+			);
+			if (
+				healthy?.url &&
+				isCompatibleHubRecord(healthy) &&
+				(await verifyHubConnection(healthy.url, {
+					authToken: nextDiscovery.authToken,
+				}))
+			) {
+				return rememberIfManaged({
+					url: healthy.url,
+					authToken: nextDiscovery.authToken,
+				});
+			}
+		}
+		const nextExpected = await safeProbeHubServer(expectedUrl);
+		if (nextExpected?.url && !isCompatibleHubRecord(nextExpected)) {
+			const expectedForRetirement = withMatchingDiscoveryRetirementMetadata(
+				nextExpected,
+				nextDiscovery,
+				expectedUrl,
+			);
+			const retiredExpected = await retireIncompatibleHub(
+				expectedForRetirement,
+				owner.discoveryPath,
+			);
+			if (
+				!retiredExpected &&
+				endpointOverrides.allowPortFallback !== true &&
+				endpoint.port !== 0
+			) {
+				throw new Error(
+					`An incompatible Cline Hub is still running at ${expectedUrl} and could not be retired automatically. Run 'cline doctor fix' to stop stale hub daemons before starting a new hub.`,
+				);
+			}
+		}
+		await new Promise((resolve) => setTimeout(resolve, HUB_STARTUP_POLL_MS));
+	}
+	throw new Error("Timed out waiting for detached hub startup.");
+}
diff --git a/sdk/packages/core/src/hub/daemon/runtime-handlers.ts b/sdk/packages/core/src/hub/daemon/runtime-handlers.ts
new file mode 100644
index 0000000..00e31e8
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/runtime-handlers.ts
@@ -0,0 +1,144 @@
+import { normalizeProviderId } from "@cline/llms";
+import type {
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+	ChatTurnResult,
+	ITelemetryService,
+} from "@cline/shared";
+import type {
+	HubScheduleRuntimeHandlers,
+	HubScheduleServiceOptions,
+} from "../../cron/service/schedule-service";
+import { LocalRuntimeHost } from "../../runtime/host/local-runtime-host";
+import { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import { CoreSessionService } from "../../session/services/session-service";
+import { SessionSource } from "../../types/common";
+
+function toChatTurnResult(result: {
+	text: string;
+	usage: {
+		inputTokens: number;
+		outputTokens: number;
+		totalCost?: number;
+	};
+	iterations: number;
+	finishReason: string;
+	toolCalls: Array<{
+		name: string;
+		input?: unknown;
+		output?: unknown;
+		error?: string;
+		durationMs?: number;
+	}>;
+}): ChatTurnResult {
+	return {
+		text: result.text,
+		usage: result.usage,
+		inputTokens: result.usage.inputTokens,
+		outputTokens: result.usage.outputTokens,
+		iterations: result.iterations,
+		finishReason: result.finishReason,
+		toolCalls: result.toolCalls.map((call) => ({
+			name: call.name,
+			input: call.input,
+			output: call.output,
+			error: call.error,
+			durationMs: call.durationMs,
+		})),
+	};
+}
+
+function resolveMode(
+	request: ChatStartSessionRequest | ChatRunTurnRequest["config"],
+): "act" | "plan" | "yolo" {
+	return request.mode === "plan"
+		? "plan"
+		: request.mode === "yolo"
+			? "yolo"
+			: "act";
+}
+
+export interface CreateLocalHubScheduleRuntimeHandlersOptions
+	extends Pick<HubScheduleServiceOptions, "logger"> {
+	/**
+	 * Custom `fetch` implementation forwarded to the scheduler's internal
+	 * `LocalRuntimeHost`. Used by the AI gateway providers for every
+	 * scheduled session executed inside this hub process.
+	 */
+	fetch?: typeof fetch;
+	telemetry?: ITelemetryService;
+}
+
+export function createLocalHubScheduleRuntimeHandlers(
+	options: CreateLocalHubScheduleRuntimeHandlersOptions = {},
+): HubScheduleRuntimeHandlers {
+	const sessionHost = new LocalRuntimeHost({
+		sessionService: new CoreSessionService(new SqliteSessionStore()),
+		fetch: options.fetch,
+		telemetry: options.telemetry,
+	});
+
+	return {
+		async startSession(request) {
+			const cwd = (request.cwd?.trim() || request.workspaceRoot).trim();
+			const started = await sessionHost.startSession({
+				source: request.source?.trim() || SessionSource.CLI,
+				interactive: false,
+				config: {
+					providerId: normalizeProviderId(request.provider),
+					modelId: request.model,
+					apiKey: request.apiKey?.trim() || undefined,
+					cwd,
+					workspaceRoot: request.workspaceRoot,
+					systemPrompt: request.systemPrompt ?? "",
+					mode: resolveMode(request),
+					maxIterations: request.maxIterations,
+					enableTools: request.enableTools !== false,
+					enableSpawnAgent: request.enableSpawn !== false,
+					enableAgentTeams: request.enableTeams !== false,
+					disableMcpSettingsTools: request.disableMcpSettingsTools,
+					missionLogIntervalSteps: request.missionStepInterval,
+					missionLogIntervalMs: request.missionTimeIntervalMs,
+				},
+				toolPolicies: request.toolPolicies ?? {
+					"*": {
+						autoApprove: request.autoApproveTools !== false,
+					},
+				},
+				localRuntime: {
+					configExtensions: request.configExtensions,
+				},
+			});
+			return {
+				sessionId: started.sessionId,
+				startResult: {
+					sessionId: started.sessionId,
+					manifestPath: started.manifestPath,
+					messagesPath: started.messagesPath,
+				},
+			};
+		},
+		async sendSession(sessionId, request) {
+			const result = await sessionHost.runTurn({
+				sessionId,
+				prompt: request.prompt,
+				userImages: request.attachments?.userImages,
+				userFiles: request.attachments?.userFiles?.map((file) => file.content),
+			});
+			if (!result) {
+				throw new Error("local hub schedule runtime returned no turn result");
+			}
+			return {
+				result: toChatTurnResult(result),
+			};
+		},
+		async abortSession(sessionId) {
+			await sessionHost.abort(sessionId, new Error("hub schedule abort"));
+			return { applied: true };
+		},
+		async stopSession(sessionId) {
+			await sessionHost.stopSession(sessionId);
+			return { applied: true };
+		},
+	};
+}
diff --git a/sdk/packages/core/src/hub/daemon/start-shared-server.test.ts b/sdk/packages/core/src/hub/daemon/start-shared-server.test.ts
new file mode 100644
index 0000000..efbaafd
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/start-shared-server.test.ts
@@ -0,0 +1,135 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { EnsureHubServerOptions } from "./start-shared-server";
+
+const {
+	mockEnsureHubWebSocketServer,
+	mockResolveHubEndpointOptions,
+	mockResolveClineBuildEnv,
+	mockResolveProductionHubOwnerContext,
+	mockResolveSharedHubOwnerContext,
+	mockStartHubWebSocketServer,
+} = vi.hoisted(() => ({
+	mockEnsureHubWebSocketServer: vi.fn(async () => ({
+		url: "ws://127.0.0.1:25463/hub",
+		authToken: "token",
+		action: "started",
+	})),
+	mockResolveHubEndpointOptions: vi.fn(
+		(options: { host?: string; port?: number; pathname?: string }) => ({
+			host: options.host ?? "127.0.0.1",
+			port: options.port ?? 25463,
+			pathname: options.pathname ?? "/hub",
+		}),
+	),
+	mockResolveClineBuildEnv: vi.fn(() => "production"),
+	mockResolveProductionHubOwnerContext: vi.fn(() => ({
+		ownerId: "production",
+		discoveryPath: "/tmp/cline-data/locks/hub/production.json",
+	})),
+	mockResolveSharedHubOwnerContext: vi.fn(() => ({
+		ownerId: "shared",
+		discoveryPath: "/tmp/cline-data/locks/hub/owners/shared.json",
+	})),
+	mockStartHubWebSocketServer: vi.fn(),
+}));
+
+vi.mock("@cline/shared", () => ({
+	resolveClineBuildEnv: mockResolveClineBuildEnv,
+}));
+
+vi.mock("../discovery/defaults", () => ({
+	resolveHubEndpointOptions: mockResolveHubEndpointOptions,
+}));
+
+vi.mock("../discovery/workspace", () => ({
+	resolveProductionHubOwnerContext: mockResolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext: mockResolveSharedHubOwnerContext,
+}));
+
+vi.mock("../server", () => ({
+	ensureHubWebSocketServer: mockEnsureHubWebSocketServer,
+	startHubWebSocketServer: mockStartHubWebSocketServer,
+}));
+
+const originalHubPort = process.env.CLINE_HUB_PORT;
+const runtimeHandlers =
+	{} as unknown as EnsureHubServerOptions["runtimeHandlers"];
+
+describe("ensureHubServer", () => {
+	afterEach(() => {
+		mockEnsureHubWebSocketServer.mockClear();
+		mockResolveHubEndpointOptions.mockClear();
+		mockResolveClineBuildEnv.mockClear();
+		mockResolveClineBuildEnv.mockReturnValue("production");
+		mockResolveProductionHubOwnerContext.mockClear();
+		mockResolveSharedHubOwnerContext.mockClear();
+		mockStartHubWebSocketServer.mockClear();
+		if (originalHubPort === undefined) {
+			delete process.env.CLINE_HUB_PORT;
+		} else {
+			process.env.CLINE_HUB_PORT = originalHubPort;
+		}
+	});
+
+	it("does not allow port fallback by default in production", async () => {
+		delete process.env.CLINE_HUB_PORT;
+		const { ensureHubServer } = await import("./start-shared-server");
+
+		await ensureHubServer({ runtimeHandlers });
+
+		expect(mockEnsureHubWebSocketServer).toHaveBeenCalledWith(
+			expect.objectContaining({
+				port: 25463,
+				allowPortFallback: false,
+				owner: expect.objectContaining({
+					discoveryPath: "/tmp/cline-data/locks/hub/production.json",
+				}),
+			}),
+		);
+	});
+
+	it("allows port fallback by default in development when no port is explicit", async () => {
+		delete process.env.CLINE_HUB_PORT;
+		mockResolveClineBuildEnv.mockReturnValue("development");
+		const { ensureHubServer } = await import("./start-shared-server");
+
+		await ensureHubServer({ runtimeHandlers });
+
+		expect(mockEnsureHubWebSocketServer).toHaveBeenCalledWith(
+			expect.objectContaining({
+				port: 25463,
+				allowPortFallback: true,
+				owner: expect.objectContaining({
+					discoveryPath: "/tmp/cline-data/locks/hub/owners/shared.json",
+				}),
+			}),
+		);
+	});
+
+	it("does not default port fallback when a port option is explicit", async () => {
+		delete process.env.CLINE_HUB_PORT;
+		const { ensureHubServer } = await import("./start-shared-server");
+
+		await ensureHubServer({ port: 30000, runtimeHandlers });
+
+		expect(mockEnsureHubWebSocketServer).toHaveBeenCalledWith(
+			expect.objectContaining({
+				port: 30000,
+				allowPortFallback: false,
+			}),
+		);
+	});
+
+	it("does not default port fallback when CLINE_HUB_PORT is explicit", async () => {
+		process.env.CLINE_HUB_PORT = "30001";
+		const { ensureHubServer } = await import("./start-shared-server");
+
+		await ensureHubServer({ runtimeHandlers });
+
+		expect(mockEnsureHubWebSocketServer).toHaveBeenCalledWith(
+			expect.objectContaining({
+				allowPortFallback: false,
+			}),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/hub/daemon/start-shared-server.ts b/sdk/packages/core/src/hub/daemon/start-shared-server.ts
new file mode 100644
index 0000000..78ae6a3
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/start-shared-server.ts
@@ -0,0 +1,77 @@
+import { resolveClineBuildEnv } from "@cline/shared";
+import { resolveHubEndpointOptions } from "../discovery/defaults";
+import {
+	resolveProductionHubOwnerContext,
+	resolveSharedHubOwnerContext,
+} from "../discovery/workspace";
+import {
+	type EnsuredHubWebSocketServerResult,
+	type EnsureHubWebSocketServerOptions,
+	ensureHubWebSocketServer,
+	type HubWebSocketServer,
+	type HubWebSocketServerOptions,
+	startHubWebSocketServer,
+} from "../server";
+
+export type HubServer = HubWebSocketServer;
+export type EnsureHubServerResult = EnsuredHubWebSocketServerResult;
+
+export interface StartHubServerOptions
+	extends Omit<HubWebSocketServerOptions, "owner"> {}
+
+export interface EnsureHubServerOptions
+	extends Omit<EnsureHubWebSocketServerOptions, "owner"> {}
+
+function resolveDefaultHubOwnerContext() {
+	return resolveClineBuildEnv() === "production"
+		? resolveProductionHubOwnerContext()
+		: resolveSharedHubOwnerContext();
+}
+
+function shouldAllowDefaultPortFallback(hasExplicitPort: boolean): boolean {
+	return resolveClineBuildEnv() !== "production" && !hasExplicitPort;
+}
+
+/**
+ * Start a hub WebSocket server bound to the default owner context for the
+ * current build environment. Callers that need a custom owner should invoke
+ * {@link startHubWebSocketServer} directly.
+ */
+export async function startHubServer(
+	options: StartHubServerOptions,
+): Promise<HubServer> {
+	const endpoint = resolveHubEndpointOptions({
+		host: options.host,
+		port: options.port,
+		pathname: options.pathname,
+	});
+	return await startHubWebSocketServer({
+		...options,
+		...endpoint,
+		owner: resolveDefaultHubOwnerContext(),
+	});
+}
+
+/**
+ * Ensure a hub WebSocket server is running in the default owner context for the
+ * current build environment, reusing a compatible in-process instance when available.
+ */
+export async function ensureHubServer(
+	options: EnsureHubServerOptions,
+): Promise<EnsureHubServerResult> {
+	const hasExplicitPort =
+		options.port !== undefined || !!process.env.CLINE_HUB_PORT?.trim();
+	const endpoint = resolveHubEndpointOptions({
+		host: options.host,
+		port: options.port,
+		pathname: options.pathname,
+	});
+	return await ensureHubWebSocketServer({
+		...options,
+		...endpoint,
+		allowPortFallback:
+			options.allowPortFallback ??
+			shouldAllowDefaultPortFallback(hasExplicitPort),
+		owner: resolveDefaultHubOwnerContext(),
+	});
+}
diff --git a/sdk/packages/core/src/hub/daemon/telemetry.test.ts b/sdk/packages/core/src/hub/daemon/telemetry.test.ts
new file mode 100644
index 0000000..8862754
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/telemetry.test.ts
@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+	mockIdentifyAccount,
+	mockGetProviderSettings,
+	mockFlush,
+	mockDispose,
+	mockTelemetryService,
+	mockCreateConfiguredTelemetryHandle,
+	providerSettingsManagerConstructions,
+} = vi.hoisted(() => {
+	const telemetry = { capture: vi.fn() };
+	const mockFlush = vi.fn(async () => undefined);
+	const mockDispose = vi.fn(async () => undefined);
+	return {
+		mockIdentifyAccount: vi.fn(),
+		mockGetProviderSettings: vi.fn(),
+		mockFlush,
+		mockDispose,
+		mockTelemetryService: telemetry,
+		mockCreateConfiguredTelemetryHandle: vi.fn(() => ({
+			telemetry,
+			flush: mockFlush,
+			dispose: mockDispose,
+		})),
+		providerSettingsManagerConstructions: { count: 0 },
+	};
+});
+
+vi.mock("../../services/telemetry/OpenTelemetryProvider", () => ({
+	createConfiguredTelemetryHandle: mockCreateConfiguredTelemetryHandle,
+}));
+
+vi.mock("../../services/telemetry/core-events", () => ({
+	identifyAccount: mockIdentifyAccount,
+}));
+
+vi.mock("../../services/storage/provider-settings-manager", () => ({
+	ProviderSettingsManager: class {
+		constructor() {
+			providerSettingsManagerConstructions.count += 1;
+		}
+		getProviderSettings = mockGetProviderSettings;
+	},
+}));
+
+import { createHubDaemonTelemetry } from "./telemetry";
+
+describe("createHubDaemonTelemetry", () => {
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+		mockIdentifyAccount.mockClear();
+		mockGetProviderSettings.mockClear();
+		mockFlush.mockClear();
+		mockFlush.mockImplementation(async () => undefined);
+		mockDispose.mockClear();
+		mockCreateConfiguredTelemetryHandle.mockClear();
+		providerSettingsManagerConstructions.count = 0;
+	});
+
+	it("identifies the cached cline account at startup", () => {
+		mockGetProviderSettings.mockReturnValue({
+			auth: { accountId: " usr-123 " },
+		});
+		const daemonTelemetry = createHubDaemonTelemetry();
+		expect(daemonTelemetry.telemetry).toBe(mockTelemetryService);
+		expect(mockCreateConfiguredTelemetryHandle).toHaveBeenCalledWith(
+			expect.objectContaining({
+				metadata: expect.objectContaining({
+					cline_type: "hub",
+					platform: "cline-hub-daemon",
+				}),
+			}),
+		);
+		expect(mockIdentifyAccount).toHaveBeenCalledExactlyOnceWith(
+			mockTelemetryService,
+			{ id: "usr-123", provider: "cline" },
+		);
+	});
+
+	it("stays anonymous when no cached account exists, then identifies once the user logs in", () => {
+		mockGetProviderSettings.mockReturnValue(undefined);
+		createHubDaemonTelemetry();
+		expect(mockIdentifyAccount).not.toHaveBeenCalled();
+
+		mockGetProviderSettings.mockReturnValue({
+			auth: { accountId: "usr-456" },
+		});
+		vi.advanceTimersByTime(5 * 60 * 1000);
+		expect(mockIdentifyAccount).toHaveBeenCalledExactlyOnceWith(
+			mockTelemetryService,
+			{ id: "usr-456", provider: "cline" },
+		);
+	});
+
+	it("does not re-identify an unchanged account and reuses one settings manager", () => {
+		mockGetProviderSettings.mockReturnValue({
+			auth: { accountId: "usr-123" },
+		});
+		createHubDaemonTelemetry();
+		vi.advanceTimersByTime(30 * 60 * 1000);
+		expect(mockIdentifyAccount).toHaveBeenCalledTimes(1);
+		expect(providerSettingsManagerConstructions.count).toBe(1);
+	});
+
+	it("survives provider settings read failures", () => {
+		mockGetProviderSettings.mockImplementation(() => {
+			throw new Error("corrupt settings");
+		});
+		expect(() => createHubDaemonTelemetry()).not.toThrow();
+		expect(mockIdentifyAccount).not.toHaveBeenCalled();
+	});
+
+	it("flushes and disposes the handle and stops the refresh timer on dispose", async () => {
+		mockGetProviderSettings.mockReturnValue(undefined);
+		const daemonTelemetry = createHubDaemonTelemetry();
+		await daemonTelemetry.dispose();
+		expect(mockFlush).toHaveBeenCalledTimes(1);
+		expect(mockDispose).toHaveBeenCalledTimes(1);
+
+		mockGetProviderSettings.mockReturnValue({
+			auth: { accountId: "usr-789" },
+		});
+		vi.advanceTimersByTime(30 * 60 * 1000);
+		expect(mockIdentifyAccount).not.toHaveBeenCalled();
+	});
+
+	it("does not let a hung exporter block dispose past the deadline", async () => {
+		mockGetProviderSettings.mockReturnValue(undefined);
+		mockFlush.mockImplementation(() => new Promise<undefined>(() => undefined));
+		const daemonTelemetry = createHubDaemonTelemetry();
+		const disposed = daemonTelemetry.dispose();
+		await vi.advanceTimersByTimeAsync(5_000);
+		await expect(disposed).resolves.toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/hub/daemon/telemetry.ts b/sdk/packages/core/src/hub/daemon/telemetry.ts
new file mode 100644
index 0000000..0eb335c
--- /dev/null
+++ b/sdk/packages/core/src/hub/daemon/telemetry.ts
@@ -0,0 +1,103 @@
+import { release } from "node:os";
+import {
+	createClineTelemetryServiceConfig,
+	type ITelemetryService,
+} from "@cline/shared";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+import { identifyAccount } from "../../services/telemetry/core-events";
+import { createConfiguredTelemetryHandle } from "../../services/telemetry/OpenTelemetryProvider";
+import { CORE_BUILD_VERSION } from "../../version";
+
+const IDENTITY_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+const DISPOSE_FLUSH_TIMEOUT_MS = 5_000;
+
+export interface HubDaemonTelemetry {
+	readonly telemetry: ITelemetryService;
+	/** Flushes pending batches and disposes the underlying provider. */
+	dispose(): Promise<void>;
+}
+
+/**
+ * Telemetry for the detached hub daemon process.
+ *
+ * The daemon hosts the `LocalRuntimeHost` that emits `task.conversation_turn`
+ * and `task.tokens` for every hub-backed session, so without its own handle
+ * those events are dropped entirely - sessions bill on the backend while
+ * reporting nothing to OTel.
+ *
+ * The daemon is long-lived and frequently starts before the user logs in (or
+ * outlives an account switch), so the cached Cline account id is re-resolved
+ * periodically rather than only once at startup.
+ */
+export function createHubDaemonTelemetry(): HubDaemonTelemetry {
+	const config = createClineTelemetryServiceConfig({
+		metadata: {
+			extension_version: CORE_BUILD_VERSION,
+			// "hub", not "cli": daemon-hosted sessions can be triggered by the
+			// CLI, desktop app, or connectors, so daemon-emitted events must be
+			// distinguishable from the CLI process's own events.
+			cline_type: "hub",
+			platform: "cline-hub-daemon",
+			platform_version: process.version,
+			os_type: process.platform,
+			os_version: release(),
+		},
+	});
+	const handle = createConfiguredTelemetryHandle(config);
+
+	// Constructed once and reused: the constructor runs legacy settings
+	// migration and provider registration side effects, while
+	// getProviderSettings re-reads the file on every call anyway.
+	let settingsManager: ProviderSettingsManager | undefined;
+	const resolveCachedClineAccountId = (): string | undefined => {
+		try {
+			settingsManager ??= new ProviderSettingsManager();
+			return (
+				settingsManager.getProviderSettings("cline")?.auth?.accountId?.trim() ||
+				undefined
+			);
+		} catch {
+			// Telemetry identity must never interfere with daemon operation.
+			return undefined;
+		}
+	};
+
+	let identifiedAccountId: string | undefined;
+	const refreshIdentity = (): void => {
+		const accountId = resolveCachedClineAccountId();
+		if (!accountId || accountId === identifiedAccountId) {
+			return;
+		}
+		identifiedAccountId = accountId;
+		identifyAccount(handle.telemetry, { id: accountId, provider: "cline" });
+	};
+
+	refreshIdentity();
+	const identityTimer = setInterval(
+		refreshIdentity,
+		IDENTITY_REFRESH_INTERVAL_MS,
+	);
+	identityTimer.unref?.();
+
+	return {
+		telemetry: handle.telemetry,
+		dispose: async (): Promise<void> => {
+			clearInterval(identityTimer);
+			// dispose only runs on the daemon's way out; a hung exporter must
+			// never keep a crashed daemon alive (holding the hub port), so
+			// the flush races a hard deadline.
+			let deadline: ReturnType<typeof setTimeout> | undefined;
+			await Promise.race([
+				(async (): Promise<void> => {
+					await handle.flush();
+					await handle.dispose();
+				})(),
+				new Promise<void>((resolve) => {
+					deadline = setTimeout(resolve, DISPOSE_FLUSH_TIMEOUT_MS);
+					deadline.unref?.();
+				}),
+			]);
+			clearTimeout(deadline);
+		},
+	};
+}
diff --git a/sdk/packages/core/src/hub/discovery/defaults.test.ts b/sdk/packages/core/src/hub/discovery/defaults.test.ts
new file mode 100644
index 0000000..6341477
--- /dev/null
+++ b/sdk/packages/core/src/hub/discovery/defaults.test.ts
@@ -0,0 +1,122 @@
+import { CLINE_BUILD_ENV_ENV } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	DEFAULT_HUB_PORT,
+	resolveDefaultHubPort,
+	resolveHubEndpointOptions,
+} from "./defaults";
+
+const DEV_HUB_PORT = 25466;
+
+describe("resolveDefaultHubPort", () => {
+	it("returns the dev hub port when CLINE_BUILD_ENV is development and CLINE_HUB_PORT is unset", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: { [CLINE_BUILD_ENV_ENV]: "development" },
+				execArgv: [],
+			}),
+		).toBe(DEV_HUB_PORT);
+	});
+
+	it("returns the production hub port when CLINE_BUILD_ENV is production and CLINE_HUB_PORT is unset", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: { [CLINE_BUILD_ENV_ENV]: "production" },
+				execArgv: [],
+			}),
+		).toBe(DEFAULT_HUB_PORT);
+	});
+
+	it("returns the production hub port when the build env cannot be determined", () => {
+		expect(resolveDefaultHubPort({ env: {}, execArgv: [] })).toBe(
+			DEFAULT_HUB_PORT,
+		);
+	});
+
+	it("treats --conditions=development as a development build", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {},
+				execArgv: ["--conditions=development"],
+			}),
+		).toBe(DEV_HUB_PORT);
+	});
+
+	it("honors an explicit CLINE_HUB_PORT override in development", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "development",
+					CLINE_HUB_PORT: "31000",
+				},
+				execArgv: [],
+			}),
+		).toBe(31000);
+	});
+
+	it("honors an explicit CLINE_HUB_PORT override in production", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "production",
+					CLINE_HUB_PORT: "31000",
+				},
+				execArgv: [],
+			}),
+		).toBe(31000);
+	});
+
+	it("falls back to the dev default when CLINE_HUB_PORT is invalid in development", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "development",
+					CLINE_HUB_PORT: "not-a-port",
+				},
+				execArgv: [],
+			}),
+		).toBe(DEV_HUB_PORT);
+	});
+
+	it("falls back to the production default when CLINE_HUB_PORT is invalid in production", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "production",
+					CLINE_HUB_PORT: "0",
+				},
+				execArgv: [],
+			}),
+		).toBe(DEFAULT_HUB_PORT);
+	});
+});
+
+describe("resolveHubEndpointOptions", () => {
+	it("composes the dev hub port when overrides are not provided in development", () => {
+		expect(
+			resolveHubEndpointOptions(
+				{},
+				{
+					env: { [CLINE_BUILD_ENV_ENV]: "development" },
+					execArgv: [],
+				},
+			),
+		).toEqual({
+			host: "127.0.0.1",
+			port: DEV_HUB_PORT,
+			pathname: "/hub",
+		});
+	});
+
+	it("respects explicit port overrides regardless of build env", () => {
+		expect(
+			resolveHubEndpointOptions(
+				{ port: 40000 },
+				{
+					env: { [CLINE_BUILD_ENV_ENV]: "development" },
+					execArgv: [],
+				},
+			).port,
+		).toBe(40000);
+	});
+});
diff --git a/sdk/packages/core/src/hub/discovery/defaults.ts b/sdk/packages/core/src/hub/discovery/defaults.ts
new file mode 100644
index 0000000..a3edb56
--- /dev/null
+++ b/sdk/packages/core/src/hub/discovery/defaults.ts
@@ -0,0 +1,70 @@
+import {
+	CLINE_HUB_DEV_PORT,
+	CLINE_HUB_PORT,
+	resolveClineBuildEnv,
+} from "@cline/shared";
+
+const HUB_HOST_ENV = "CLINE_HUB_HOST";
+const HUB_PORT_ENV = "CLINE_HUB_PORT";
+const HUB_PATHNAME_ENV = "CLINE_HUB_PATHNAME";
+
+export const DEFAULT_HUB_HOST = "127.0.0.1";
+export const DEFAULT_HUB_PORT = CLINE_HUB_PORT;
+export const DEFAULT_HUB_PATHNAME = "/hub";
+
+export interface HubEndpointOverrides {
+	host?: string;
+	port?: number;
+	pathname?: string;
+}
+
+export interface ResolveHubDefaultsOptions {
+	env?: NodeJS.ProcessEnv;
+	execArgv?: string[];
+}
+
+function fallbackHubPort(options: ResolveHubDefaultsOptions): number {
+	return resolveClineBuildEnv(options) === "development"
+		? CLINE_HUB_DEV_PORT
+		: DEFAULT_HUB_PORT;
+}
+
+export function resolveDefaultHubHost(
+	options: ResolveHubDefaultsOptions = {},
+): string {
+	const env = options.env ?? process.env;
+	return env[HUB_HOST_ENV]?.trim() || DEFAULT_HUB_HOST;
+}
+
+export function resolveDefaultHubPort(
+	options: ResolveHubDefaultsOptions = {},
+): number {
+	const env = options.env ?? process.env;
+	const raw = env[HUB_PORT_ENV]?.trim();
+	if (!raw) {
+		return fallbackHubPort(options);
+	}
+	const port = Number.parseInt(raw, 10);
+	if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+		return fallbackHubPort(options);
+	}
+	return port;
+}
+
+export function resolveDefaultHubPathname(
+	options: ResolveHubDefaultsOptions = {},
+): string {
+	const env = options.env ?? process.env;
+	return env[HUB_PATHNAME_ENV]?.trim() || DEFAULT_HUB_PATHNAME;
+}
+
+export function resolveHubEndpointOptions(
+	overrides: HubEndpointOverrides = {},
+	options: ResolveHubDefaultsOptions = {},
+): Required<HubEndpointOverrides> {
+	return {
+		host: overrides.host ?? resolveDefaultHubHost(options),
+		port: overrides.port ?? resolveDefaultHubPort(options),
+		pathname: overrides.pathname ?? resolveDefaultHubPathname(options),
+	};
+}
diff --git a/sdk/packages/core/src/hub/discovery/index.test.ts b/sdk/packages/core/src/hub/discovery/index.test.ts
new file mode 100644
index 0000000..656ac6b
--- /dev/null
+++ b/sdk/packages/core/src/hub/discovery/index.test.ts
@@ -0,0 +1,150 @@
+import { chmod, mkdir, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	clearHubDiscovery,
+	probeHubServer,
+	readHubDiscovery,
+	resolveHubOwnerContext,
+	writeHubDiscovery,
+} from ".";
+
+type EnvSnapshot = {
+	CLINE_DATA_DIR: string | undefined;
+	CLINE_HUB_DISCOVERY_PATH: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+		CLINE_HUB_DISCOVERY_PATH: process.env.CLINE_HUB_DISCOVERY_PATH,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.CLINE_DATA_DIR = snapshot.CLINE_DATA_DIR;
+	process.env.CLINE_HUB_DISCOVERY_PATH = snapshot.CLINE_HUB_DISCOVERY_PATH;
+}
+
+describe("hub discovery", () => {
+	let snapshot: EnvSnapshot = captureEnv();
+
+	afterEach(() => {
+		restoreEnv(snapshot);
+	});
+
+	it("stores shared hub discovery under the locks directory by default", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveHubOwnerContext("shared").discoveryPath).toBe(
+			join(
+				"/tmp/cline-data",
+				"locks",
+				"hub",
+				"owners",
+				"hub-a4d26868017c.json",
+			),
+		);
+	});
+
+	it("honors an explicit hub discovery path override", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_HUB_DISCOVERY_PATH = "/tmp/custom-hub-discovery.json";
+
+		expect(resolveHubOwnerContext("shared").discoveryPath).toBe(
+			"/tmp/custom-hub-discovery.json",
+		);
+	});
+
+	it("writes and clears discovery records at the resolved location", async () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		const discoveryPath = resolveHubOwnerContext("shared").discoveryPath;
+		const record = {
+			hubId: "hub_123",
+			protocolVersion: "v1",
+			authToken: "test-token",
+			host: "127.0.0.1",
+			port: 25463,
+			url: "ws://127.0.0.1:25463/hub",
+			startedAt: new Date().toISOString(),
+			updatedAt: new Date().toISOString(),
+		};
+
+		await mkdir(dirname(discoveryPath), { recursive: true });
+		await writeFile(discoveryPath, "{}\n", "utf8");
+		await chmod(discoveryPath, 0o644);
+		await writeHubDiscovery(discoveryPath, record);
+		await expect(readHubDiscovery(discoveryPath)).resolves.toMatchObject(
+			record,
+		);
+		// Windows does not support Unix file permissions; chmod is a no-op there.
+		if (process.platform !== "win32") {
+			expect((await stat(discoveryPath)).mode & 0o777).toBe(0o600);
+		}
+		await clearHubDiscovery(discoveryPath);
+		await expect(readHubDiscovery(discoveryPath)).resolves.toBeUndefined();
+	});
+
+	it("rejects discovery records without an auth token", async () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		const discoveryPath = resolveHubOwnerContext("missing-auth").discoveryPath;
+		await mkdir(dirname(discoveryPath), { recursive: true });
+		await writeFile(
+			discoveryPath,
+			`${JSON.stringify({
+				hubId: "hub_123",
+				protocolVersion: "v1",
+				host: "127.0.0.1",
+				port: 25463,
+				url: "ws://127.0.0.1:25463/hub",
+				startedAt: new Date().toISOString(),
+				updatedAt: new Date().toISOString(),
+			})}\n`,
+			"utf8",
+		);
+
+		await expect(readHubDiscovery(discoveryPath)).resolves.toBeUndefined();
+	});
+
+	it("returns only public health fields for unauthenticated probes", async () => {
+		const fetchMock = async () =>
+			({
+				ok: true,
+				json: async () => ({
+					ok: true,
+					protocolVersion: "v1",
+					minClientProtocolVersion: "v1",
+					maxClientProtocolVersion: "v1",
+					coreVersion: "1.0.0",
+					host: "127.0.0.1",
+					port: 25463,
+					url: "ws://127.0.0.1:25463/hub",
+				}),
+			}) as Response;
+		const originalFetch = globalThis.fetch;
+		globalThis.fetch = fetchMock as typeof fetch;
+		try {
+			const record = await probeHubServer("ws://127.0.0.1:25463/hub");
+
+			expect(record).toMatchObject({
+				protocolVersion: "v1",
+				host: "127.0.0.1",
+				port: 25463,
+				url: "ws://127.0.0.1:25463/hub",
+			});
+			expect(record?.hubId).toBeUndefined();
+			expect(record?.startedAt).toBeUndefined();
+			expect(record?.updatedAt).toBeUndefined();
+		} finally {
+			globalThis.fetch = originalFetch;
+		}
+	});
+});
diff --git a/sdk/packages/core/src/hub/discovery/index.ts b/sdk/packages/core/src/hub/discovery/index.ts
new file mode 100644
index 0000000..e46c7f6
--- /dev/null
+++ b/sdk/packages/core/src/hub/discovery/index.ts
@@ -0,0 +1,347 @@
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { resolveClineDataDir, resolveClineDir } from "@cline/shared/storage";
+import corePackage from "../../../package.json";
+
+const HUB_DISCOVERY_ENV = "CLINE_HUB_DISCOVERY_PATH";
+const HUB_BUILD_ID_ENV = "CLINE_HUB_BUILD_ID";
+const HUB_STARTUP_LOCK_MAX_AGE_MS = 30_000;
+const HUB_STARTUP_LOCK_WAIT_MS = 15_000;
+const HUB_STARTUP_LOCK_POLL_MS = 100;
+
+export interface HubServerDiscoveryRecord {
+	hubId: string;
+	protocolVersion: string;
+	minClientProtocolVersion?: string;
+	maxClientProtocolVersion?: string;
+	capabilities?: readonly string[];
+	coreVersion?: string;
+	buildId?: string;
+	authToken: string;
+	host: string;
+	port: number;
+	url: string;
+	pid?: number;
+	startedAt: string;
+	updatedAt: string;
+}
+
+export type HubServerProbeRecord = {
+	protocolVersion: string;
+	minClientProtocolVersion?: string;
+	maxClientProtocolVersion?: string;
+	capabilities?: readonly string[];
+	coreVersion?: string;
+	buildId?: string;
+	host: string;
+	port: number;
+	url: string;
+	hubId?: string;
+	authToken?: string;
+	pid?: number;
+	startedAt?: string;
+	updatedAt?: string;
+};
+
+export interface HubOwnerContext {
+	ownerId: string;
+	discoveryPath: string;
+}
+
+function sanitizeKey(value: string): string {
+	return value.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+}
+
+function hashValue(value: string): string {
+	return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+
+function isPidAlive(pid: number | undefined): boolean {
+	if (!Number.isInteger(pid) || !pid || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error
+			? String((error as NodeJS.ErrnoException).code) === "EPERM"
+			: false;
+	}
+}
+
+export function createHubAuthToken(): string {
+	return randomBytes(32).toString("hex");
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getStartupLockDir(discoveryPath: string): string {
+	return `${discoveryPath}.lock`;
+}
+
+async function readStartupLockRecord(
+	lockDir: string,
+): Promise<{ pid: number; acquiredAt: string } | undefined> {
+	try {
+		const parsed = JSON.parse(
+			await readFile(join(lockDir, "owner.json"), "utf8"),
+		) as Partial<{ pid: number; acquiredAt: string }>;
+		if (
+			typeof parsed.pid !== "number" ||
+			typeof parsed.acquiredAt !== "string"
+		) {
+			return undefined;
+		}
+		return { pid: parsed.pid, acquiredAt: parsed.acquiredAt };
+	} catch {
+		return undefined;
+	}
+}
+
+async function removeStartupLock(lockDir: string): Promise<void> {
+	await rm(lockDir, { recursive: true, force: true }).catch(() => undefined);
+}
+
+export function resolveHubBuildId(): string {
+	return process.env[HUB_BUILD_ID_ENV]?.trim() || String(corePackage.version);
+}
+
+export function resolveHubOwnerContext(
+	ownerBasis: string = process.argv[1]?.trim() || process.cwd(),
+): HubOwnerContext {
+	const ownerId = `hub-${hashValue(ownerBasis)}`;
+	const discoveryPath =
+		process.env[HUB_DISCOVERY_ENV]?.trim() ||
+		join(
+			resolveClineDataDir(),
+			"locks",
+			"hub",
+			"owners",
+			`${sanitizeKey(ownerId)}.json`,
+		);
+	return { ownerId, discoveryPath };
+}
+
+export function createInMemoryHubOwnerContext(
+	label = `hub-${Date.now().toString(36)}`,
+): HubOwnerContext {
+	return resolveHubOwnerContext(label);
+}
+
+export async function readHubDiscovery(
+	discoveryPath: string,
+): Promise<HubServerDiscoveryRecord | undefined> {
+	try {
+		const parsed = JSON.parse(
+			await readFile(discoveryPath, "utf8"),
+		) as Partial<HubServerDiscoveryRecord>;
+		if (
+			typeof parsed.hubId !== "string" ||
+			typeof parsed.protocolVersion !== "string" ||
+			typeof parsed.authToken !== "string" ||
+			typeof parsed.host !== "string" ||
+			typeof parsed.port !== "number" ||
+			typeof parsed.url !== "string" ||
+			typeof parsed.startedAt !== "string" ||
+			typeof parsed.updatedAt !== "string"
+		) {
+			return undefined;
+		}
+		return {
+			hubId: parsed.hubId,
+			protocolVersion: parsed.protocolVersion,
+			minClientProtocolVersion:
+				typeof parsed.minClientProtocolVersion === "string"
+					? parsed.minClientProtocolVersion
+					: undefined,
+			maxClientProtocolVersion:
+				typeof parsed.maxClientProtocolVersion === "string"
+					? parsed.maxClientProtocolVersion
+					: undefined,
+			capabilities: Array.isArray(parsed.capabilities)
+				? parsed.capabilities.filter(
+						(capability): capability is string =>
+							typeof capability === "string",
+					)
+				: undefined,
+			coreVersion:
+				typeof parsed.coreVersion === "string" ? parsed.coreVersion : undefined,
+			buildId: typeof parsed.buildId === "string" ? parsed.buildId : undefined,
+			authToken: parsed.authToken,
+			host: parsed.host,
+			port: parsed.port,
+			url: parsed.url,
+			pid: typeof parsed.pid === "number" ? parsed.pid : undefined,
+			startedAt: parsed.startedAt,
+			updatedAt: parsed.updatedAt,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+export async function writeHubDiscovery(
+	discoveryPath: string,
+	record: HubServerDiscoveryRecord,
+): Promise<void> {
+	await mkdir(dirname(discoveryPath), { recursive: true });
+	// Remove any existing file first so writeFile creates it fresh with the
+	// correct mode. On Linux, the mode option is ignored for existing files.
+	await rm(discoveryPath, { force: true }).catch(() => undefined);
+	await writeFile(discoveryPath, `${JSON.stringify(record, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 0o600,
+	});
+	await chmod(discoveryPath, 0o600);
+}
+
+export async function clearHubDiscovery(discoveryPath: string): Promise<void> {
+	await rm(discoveryPath, { force: true }).catch(() => undefined);
+}
+
+export async function withHubStartupLock<T>(
+	discoveryPath: string,
+	callback: () => Promise<T>,
+): Promise<T> {
+	const lockDir = getStartupLockDir(discoveryPath);
+	await mkdir(dirname(lockDir), { recursive: true });
+	const deadline = Date.now() + HUB_STARTUP_LOCK_WAIT_MS;
+
+	while (true) {
+		try {
+			await mkdir(lockDir, { recursive: false });
+			await writeFile(
+				join(lockDir, "owner.json"),
+				`${JSON.stringify(
+					{ pid: process.pid, acquiredAt: new Date().toISOString() },
+					null,
+					2,
+				)}\n`,
+				"utf8",
+			);
+			try {
+				return await callback();
+			} finally {
+				await removeStartupLock(lockDir);
+			}
+		} catch (error) {
+			const code =
+				error instanceof Error && "code" in error
+					? String((error as NodeJS.ErrnoException).code)
+					: "";
+			if (code !== "EEXIST") {
+				throw error;
+			}
+			const record = await readStartupLockRecord(lockDir);
+			const lockAge = record
+				? Date.now() - Date.parse(record.acquiredAt)
+				: HUB_STARTUP_LOCK_MAX_AGE_MS + 1;
+			if (
+				!record ||
+				!isPidAlive(record.pid) ||
+				lockAge > HUB_STARTUP_LOCK_MAX_AGE_MS
+			) {
+				await removeStartupLock(lockDir);
+				continue;
+			}
+			if (Date.now() >= deadline) {
+				throw new Error(`Timed out waiting for hub startup lock ${lockDir}`);
+			}
+			await sleep(HUB_STARTUP_LOCK_POLL_MS);
+		}
+	}
+}
+
+export async function probeHubServer(
+	url: string,
+	options?: { authToken?: string },
+): Promise<HubServerProbeRecord | undefined> {
+	try {
+		const response = await fetch(
+			options?.authToken ? toHubStatusUrl(url) : toHubHealthUrl(url),
+			{
+				headers: options?.authToken
+					? { authorization: `Bearer ${options.authToken}` }
+					: undefined,
+			},
+		);
+		if (!response.ok) {
+			return undefined;
+		}
+		const parsed = (await response.json()) as Partial<HubServerProbeRecord>;
+		if (
+			typeof parsed.protocolVersion !== "string" ||
+			typeof parsed.host !== "string" ||
+			typeof parsed.port !== "number" ||
+			typeof parsed.url !== "string"
+		) {
+			return undefined;
+		}
+		return {
+			protocolVersion: parsed.protocolVersion,
+			minClientProtocolVersion:
+				typeof parsed.minClientProtocolVersion === "string"
+					? parsed.minClientProtocolVersion
+					: undefined,
+			maxClientProtocolVersion:
+				typeof parsed.maxClientProtocolVersion === "string"
+					? parsed.maxClientProtocolVersion
+					: undefined,
+			capabilities: Array.isArray(parsed.capabilities)
+				? parsed.capabilities.filter(
+						(capability): capability is string =>
+							typeof capability === "string",
+					)
+				: undefined,
+			coreVersion:
+				typeof parsed.coreVersion === "string" ? parsed.coreVersion : undefined,
+			buildId: typeof parsed.buildId === "string" ? parsed.buildId : undefined,
+			host: parsed.host,
+			port: parsed.port,
+			url: parsed.url,
+			hubId: typeof parsed.hubId === "string" ? parsed.hubId : undefined,
+			authToken:
+				typeof parsed.authToken === "string" ? parsed.authToken : undefined,
+			pid: typeof parsed.pid === "number" ? parsed.pid : undefined,
+			startedAt:
+				typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+			updatedAt:
+				typeof parsed.updatedAt === "string" ? parsed.updatedAt : undefined,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+export function createHubServerUrl(
+	host: string,
+	port: number,
+	pathname = "/hub",
+): string {
+	return new URL(`ws://${host}:${port}${pathname}`).toString();
+}
+
+export function toHubHealthUrl(wsUrl: string): string {
+	const parsed = new URL(wsUrl);
+	parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
+	parsed.pathname = "/health";
+	parsed.search = "";
+	return parsed.toString();
+}
+
+export function toHubStatusUrl(wsUrl: string): string {
+	const parsed = new URL(toHubHealthUrl(wsUrl));
+	parsed.pathname = "/status";
+	return parsed.toString();
+}
+
+export function isDiscoveryFilePresent(pathname: string): boolean {
+	return existsSync(pathname);
+}
+
+export { resolveClineDataDir, resolveClineDir };
diff --git a/sdk/packages/core/src/hub/discovery/workspace.ts b/sdk/packages/core/src/hub/discovery/workspace.ts
new file mode 100644
index 0000000..e0a1628
--- /dev/null
+++ b/sdk/packages/core/src/hub/discovery/workspace.ts
@@ -0,0 +1,35 @@
+import { join } from "node:path";
+import { normalizeWorkspacePath } from "../../services/workspace/workspace-manifest";
+import {
+	type HubOwnerContext,
+	resolveClineDataDir,
+	resolveHubOwnerContext,
+} from ".";
+
+const DEFAULT_SHARED_HUB_OWNER_LABEL = "shared:cline";
+const HUB_DISCOVERY_ENV = "CLINE_HUB_DISCOVERY_PATH";
+const PRODUCTION_HUB_OWNER_ID = "hub-production";
+
+export function resolveWorkspaceHubOwnerContext(
+	workspaceRoot: string,
+): HubOwnerContext {
+	const normalized = normalizeWorkspacePath(workspaceRoot.trim());
+	return resolveHubOwnerContext(
+		`workspace:${normalized || workspaceRoot.trim()}`,
+	);
+}
+
+export function resolveSharedHubOwnerContext(
+	label = DEFAULT_SHARED_HUB_OWNER_LABEL,
+): HubOwnerContext {
+	return resolveHubOwnerContext(label);
+}
+
+export function resolveProductionHubOwnerContext(): HubOwnerContext {
+	return {
+		ownerId: PRODUCTION_HUB_OWNER_ID,
+		discoveryPath:
+			process.env[HUB_DISCOVERY_ENV]?.trim() ||
+			join(resolveClineDataDir(), "locks", "hub", "production.json"),
+	};
+}
diff --git a/sdk/packages/core/src/hub/index.ts b/sdk/packages/core/src/hub/index.ts
new file mode 100644
index 0000000..68e46ca
--- /dev/null
+++ b/sdk/packages/core/src/hub/index.ts
@@ -0,0 +1,37 @@
+export type { ITelemetryService } from "@cline/shared";
+export { HubScheduleCommandService } from "../cron/service/schedule-command-service";
+export { HubScheduleService } from "../cron/service/schedule-service";
+/**
+ * Re-exported so detached hub daemon entry points (e.g. the VS Code
+ * `hub-daemon.ts` companion process) can construct a telemetry service
+ * from a single `@cline/core/hub` import. The hub daemon is the
+ * canonical owner of telemetry forwarding for sessions executed inside
+ * the detached process, so the factory belongs on the hub surface even
+ * though its implementation lives under `services/telemetry`.
+ *
+ * `createConfiguredTelemetryHandle` is the preferred entry point for
+ * hosts: it bundles the telemetry service together with the canonical
+ * `flush`/`dispose` closures so detached daemons, the VS Code extension,
+ * and the CLI can share one implementation instead of each
+ * re-deriving the same lifecycle plumbing.
+ */
+export {
+	type ConfiguredTelemetryHandle,
+	type CreateOpenTelemetryTelemetryServiceOptions,
+	createConfiguredTelemetryHandle,
+	createConfiguredTelemetryService,
+} from "../services/telemetry/OpenTelemetryProvider";
+export * from "./client";
+export * from "./client/connect";
+export * from "./client/session-client";
+export * from "./client/ui-client";
+export * from "./daemon";
+export * from "./daemon/runtime-handlers";
+export * from "./daemon/start-shared-server";
+export * from "./discovery";
+export * from "./discovery/defaults";
+export * from "./discovery/workspace";
+export * from "./server";
+export * from "./server/browser-websocket";
+export * from "./server/command-transport";
+export * from "./server/native-transport";
diff --git a/sdk/packages/core/src/hub/runtime-host/hub-runtime-host.test.ts b/sdk/packages/core/src/hub/runtime-host/hub-runtime-host.test.ts
new file mode 100644
index 0000000..22fb138
--- /dev/null
+++ b/sdk/packages/core/src/hub/runtime-host/hub-runtime-host.test.ts
@@ -0,0 +1,1567 @@
+import type { AgentToolContext, HubEventEnvelope } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { version as corePackageVersion } from "../../../package.json";
+import { createSessionCompactionState } from "../../session/models/session-compaction";
+import { SessionSource } from "../../types/common";
+
+const commandMock = vi.hoisted(() => vi.fn());
+const subscribeMock = vi.hoisted(() => vi.fn());
+const closeMock = vi.hoisted(() => vi.fn());
+const disposeMock = vi.hoisted(() => vi.fn());
+const getClientIdMock = vi.hoisted(() => vi.fn(() => "client-1"));
+const restartLocalHubIfIdleAfterStartupTimeoutMock = vi.hoisted(() => vi.fn());
+
+vi.mock("../client", () => ({
+	NodeHubClient: class {
+		private readonly url: string;
+
+		constructor(options: { url: string }) {
+			this.url = options.url;
+		}
+
+		command = commandMock;
+		subscribe = subscribeMock;
+		close = closeMock;
+		dispose = disposeMock;
+		getClientId = getClientIdMock;
+		getUrl = () => this.url;
+	},
+	isHubCommandTimeoutError: (
+		error: unknown,
+		command?: string,
+	): error is Error & { command?: string; code?: string } =>
+		!!error &&
+		typeof error === "object" &&
+		(error as { code?: unknown }).code === "hub_command_timeout" &&
+		(command === undefined ||
+			(error as { command?: unknown }).command === command),
+	restartLocalHubIfIdleAfterStartupTimeout:
+		restartLocalHubIfIdleAfterStartupTimeoutMock,
+}));
+
+function createConfig() {
+	return {
+		providerId: "cline",
+		modelId: "anthropic/claude-haiku-4.5",
+		cwd: "/tmp/project",
+		workspaceRoot: "/tmp/project",
+		systemPrompt: "system",
+		mode: "act" as const,
+		checkpoint: { enabled: true },
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+	};
+}
+
+function agentDoneEvents(events: unknown[]) {
+	return events.filter(
+		(
+			event,
+		): event is {
+			type: "agent_event";
+			payload: { event: { type: "done"; [key: string]: unknown } };
+		} =>
+			!!event &&
+			typeof event === "object" &&
+			(event as { type?: unknown }).type === "agent_event" &&
+			(event as { payload?: { event?: { type?: unknown } } }).payload?.event
+				?.type === "done",
+	);
+}
+
+describe("HubRuntimeHost", () => {
+	afterEach(() => {
+		commandMock.mockReset();
+		subscribeMock.mockReset();
+		closeMock.mockReset();
+		disposeMock.mockReset();
+		getClientIdMock.mockClear();
+		restartLocalHubIfIdleAfterStartupTimeoutMock.mockReset();
+	});
+
+	it("does not auto-start a run during session creation", async () => {
+		subscribeMock.mockReturnValue(() => {});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		const started = await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			localRuntime: {
+				extensionContext: {
+					client: { name: "cline-cli", version: "3.0.38" },
+				},
+			},
+			prompt: "Hey",
+		});
+
+		expect(started.sessionId).toBe("sess-1");
+		expect(started.result).toBeUndefined();
+		expect(commandMock).toHaveBeenCalledTimes(1);
+		expect(subscribeMock).toHaveBeenCalledWith(expect.any(Function), {
+			sessionId: "sess-1",
+		});
+		expect(commandMock).toHaveBeenCalledWith("session.create", {
+			workspaceRoot: "/tmp/project",
+			cwd: "/tmp/project",
+			sessionConfig: expect.objectContaining({
+				providerId: "cline",
+				modelId: "anthropic/claude-haiku-4.5",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				systemPrompt: "system",
+				mode: "act",
+				checkpoint: { enabled: true },
+				enableTools: true,
+				enableSpawnAgent: true,
+				enableAgentTeams: true,
+				headers: expect.objectContaining({
+					"HTTP-Referer": "https://cline.bot",
+					"X-Title": "Cline",
+					"User-Agent": "Cline/3.0.38",
+					"X-IS-MULTIROOT": "false",
+					"X-CLIENT-TYPE": "cline-cli",
+					"X-CLIENT-VERSION": "3.0.38",
+					"X-PLATFORM": "cli",
+					"X-PLATFORM-VERSION": "3.0.38",
+					"X-CORE-VERSION": corePackageVersion,
+					"X-Task-ID": expect.any(String),
+				}),
+			}),
+			metadata: expect.objectContaining({
+				source: SessionSource.CLI,
+				prompt: "Hey",
+				interactive: false,
+			}),
+			runtimeOptions: {},
+			toolPolicies: undefined,
+			initialMessages: undefined,
+		});
+	});
+
+	it("restarts an idle local hub and retries session.create after startup timeout", async () => {
+		subscribeMock.mockReturnValue(() => {});
+		const timeoutError = Object.assign(new Error("session.create timed out"), {
+			command: "session.create",
+			code: "hub_command_timeout",
+		});
+		commandMock.mockRejectedValueOnce(timeoutError).mockResolvedValueOnce({
+			ok: true,
+			payload: {
+				session: {
+					sessionId: "sess-recovered",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		restartLocalHubIfIdleAfterStartupTimeoutMock.mockResolvedValue(
+			"ws://127.0.0.1:25464/hub",
+		);
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost(
+			{ url: "ws://127.0.0.1:25463/hub" },
+			{ workspaceRoot: "/tmp/project", cwd: "/tmp/project" },
+		);
+
+		const started = await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		expect(started.sessionId).toBe("sess-recovered");
+		expect(commandMock).toHaveBeenCalledTimes(2);
+		expect(restartLocalHubIfIdleAfterStartupTimeoutMock).toHaveBeenCalledWith({
+			url: "ws://127.0.0.1:25463/hub",
+			workspaceRoot: "/tmp/project",
+			cwd: "/tmp/project",
+		});
+		expect(disposeMock).toHaveBeenCalledOnce();
+	});
+
+	it("starts runs only through send", async () => {
+		subscribeMock.mockReturnValue(() => {});
+		const result = {
+			text: "Hey!",
+			usage: {
+				inputTokens: 1,
+				outputTokens: 1,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				totalCost: 0,
+			},
+			messages: [],
+			toolCalls: [],
+			iterations: 1,
+			finishReason: "completed",
+			model: {
+				id: "anthropic/claude-haiku-4.5",
+				provider: "cline",
+				info: {},
+			},
+			startedAt: new Date("2026-04-21T00:00:00.000Z"),
+			endedAt: new Date("2026-04-21T00:00:01.000Z"),
+			durationMs: 1000,
+		};
+		commandMock.mockResolvedValue({ ok: true, payload: { result } });
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		const sent = await host.runTurn({
+			sessionId: "sess-1",
+			prompt: "Hey",
+			mode: "plan",
+			delivery: "queue",
+		});
+
+		expect(subscribeMock).toHaveBeenCalledWith(expect.any(Function), {
+			sessionId: "sess-1",
+		});
+		expect(commandMock).toHaveBeenCalledWith(
+			"run.start",
+			{
+				sessionId: "sess-1",
+				input: "Hey",
+				mode: "plan",
+				attachments: undefined,
+				delivery: "queue",
+			},
+			"sess-1",
+			{ timeoutMs: null },
+		);
+		expect(sent).toEqual(result);
+	});
+
+	it("projects canonical hub snapshots from replies and lifecycle events", async () => {
+		let onEvent: ((event: HubEventEnvelope) => void) | undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		const snapshot = {
+			version: 1,
+			sessionId: "sess-snapshot",
+			source: SessionSource.CLI,
+			status: "running",
+			createdAt: "2026-01-01T00:00:00.000Z",
+			updatedAt: "2026-01-01T00:00:00.000Z",
+			endedAt: null,
+			exitCode: null,
+			interactive: true,
+			workspace: { cwd: "/tmp/project", root: "/tmp/project" },
+			model: {
+				providerId: "cline",
+				modelId: "anthropic/claude-haiku-4.5",
+			},
+			capabilities: {
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: true,
+			},
+			lineage: {
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				isSubagent: false,
+			},
+			prompt: "Hey",
+			messages: [{ role: "user", content: "Hey" }],
+			usage: {
+				inputTokens: 1,
+				outputTokens: 2,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				totalCost: 0.01,
+			},
+		};
+		commandMock.mockResolvedValueOnce({ ok: true, payload: { snapshot } });
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		const events: unknown[] = [];
+		host.subscribe((event) => events.push(event));
+
+		const started = await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+			interactive: true,
+		});
+
+		expect(started.sessionId).toBe("sess-snapshot");
+		expect(started.manifest).toMatchObject({
+			session_id: "sess-snapshot",
+			provider: "cline",
+			model: "anthropic/claude-haiku-4.5",
+			interactive: true,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: "v1",
+			event: "session.updated",
+			sessionId: "sess-snapshot",
+			payload: {
+				snapshot: { ...snapshot, status: "completed", exitCode: 0 },
+			},
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "session_snapshot",
+					payload: expect.objectContaining({
+						sessionId: "sess-snapshot",
+						snapshot: expect.objectContaining({
+							version: 1,
+							sessionId: "sess-snapshot",
+							status: "completed",
+							workspace: { cwd: "/tmp/project", root: "/tmp/project" },
+						}),
+					}),
+				}),
+			]),
+		);
+
+		commandMock.mockResolvedValueOnce({ ok: true, payload: { snapshot } });
+		await expect(host.getSession("sess-snapshot")).resolves.toMatchObject({
+			sessionId: "sess-snapshot",
+			provider: "cline",
+			model: "anthropic/claude-haiku-4.5",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+		});
+	});
+
+	it("bridges hub approval requests through runtime capabilities", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event: string;
+					sessionId: string;
+					payload: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock
+			.mockResolvedValueOnce({
+				payload: {
+					session: {
+						sessionId: "sess-1",
+						status: "running",
+						createdAt: Date.now(),
+						updatedAt: Date.now(),
+						workspaceRoot: "/tmp/project",
+						cwd: "/tmp/project",
+					},
+				},
+			})
+			.mockResolvedValueOnce({ ok: true, payload: {} });
+		const eventOrder: string[] = [];
+		const requestToolApproval = vi.fn(async () => {
+			eventOrder.push("approval-requested");
+			return {
+				approved: true,
+				reason: "ok",
+			};
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({
+			url: "ws://127.0.0.1:25463/hub",
+			capabilities: { requestToolApproval },
+		});
+		host.subscribe((event) => {
+			if (
+				event.type === "agent_event" &&
+				event.payload.event.type === "content_start" &&
+				event.payload.event.contentType === "tool"
+			) {
+				eventOrder.push("tool-started");
+			}
+		});
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+		onEvent?.({
+			version: 1,
+			event: "approval.requested",
+			sessionId: "sess-1",
+			payload: {
+				approvalId: "approval-1",
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 2,
+				toolCallId: "call-1",
+				toolName: "run_commands",
+				inputJson: '{"commands":["echo hi"]}',
+				policy: { autoApprove: false },
+			},
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(eventOrder).toEqual(["tool-started", "approval-requested"]);
+		expect(requestToolApproval).toHaveBeenCalledWith({
+			sessionId: "sess-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 2,
+			toolCallId: "call-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+		expect(commandMock).toHaveBeenLastCalledWith(
+			"approval.respond",
+			{ approvalId: "approval-1", approved: true, reason: "ok" },
+			"sess-1",
+		);
+
+		onEvent?.({
+			version: 1,
+			event: "tool.started",
+			sessionId: "sess-1",
+			payload: {
+				toolCallId: "call-1",
+				toolName: "run_commands",
+				input: { commands: ["echo hi"] },
+			},
+		});
+		expect(eventOrder).toEqual(["tool-started", "approval-requested"]);
+	});
+
+	it("uses one app runtime capability object for hub tool executors and approvals", async () => {
+		let onEvent: ((event: HubEventEnvelope) => void) | undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock
+			.mockResolvedValueOnce({
+				payload: {
+					session: {
+						sessionId: "sess-1",
+						status: "running",
+						createdAt: Date.now(),
+						updatedAt: Date.now(),
+						workspaceRoot: "/tmp/project",
+						cwd: "/tmp/project",
+					},
+				},
+			})
+			.mockResolvedValueOnce({ ok: true, payload: {} })
+			.mockResolvedValueOnce({ ok: true, payload: {} });
+		const askQuestion = vi.fn(
+			async (
+				_question: string,
+				_options: string[],
+				_context: AgentToolContext,
+			) => "Use the SDK",
+		);
+		const requestToolApproval = vi.fn(async () => ({
+			approved: true,
+			reason: "approved by app handler",
+		}));
+		const appCapabilities = {
+			toolExecutors: { askQuestion },
+			requestToolApproval,
+		};
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			capabilities: appCapabilities,
+		});
+		expect(commandMock.mock.calls[0]?.[0]).toBe("session.create");
+		expect(commandMock.mock.calls[0]?.[1]).toMatchObject({
+			runtimeOptions: {
+				clientContributions: [
+					{
+						kind: "toolExecutor",
+						executor: "askQuestion",
+						capabilityName: "tool_executor.askQuestion",
+					},
+				],
+			},
+		});
+
+		onEvent?.({
+			version: "v1",
+			event: "run.completed",
+			sessionId: "sess-1",
+			payload: { reason: "completed" },
+		});
+		onEvent?.({
+			version: "v1",
+			event: "capability.requested",
+			sessionId: "sess-1",
+			payload: {
+				requestId: "capreq-1",
+				targetClientId: "client-1",
+				capabilityName: "tool_executor.askQuestion",
+				payload: {
+					args: ["Which approach?", ["Use the SDK", "Write custom code"]],
+					context: {
+						agentId: "agent-1",
+						conversationId: "conversation-1",
+						iteration: 1,
+					},
+				},
+			},
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(askQuestion).toHaveBeenCalledWith(
+			"Which approach?",
+			["Use the SDK", "Write custom code"],
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 1,
+			}),
+		);
+		expect(commandMock).toHaveBeenLastCalledWith(
+			"capability.respond",
+			{
+				requestId: "capreq-1",
+				ok: true,
+				payload: { result: "Use the SDK" },
+			},
+			"sess-1",
+		);
+
+		onEvent?.({
+			version: "v1",
+			event: "approval.requested",
+			sessionId: "sess-1",
+			payload: {
+				approvalId: "approval-1",
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 2,
+				toolCallId: "call-approval-1",
+				toolName: "run_commands",
+				inputJson: '{"commands":["echo hi"]}',
+				policy: { autoApprove: false },
+			},
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(requestToolApproval).toHaveBeenCalledWith({
+			sessionId: "sess-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 2,
+			toolCallId: "call-approval-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+		expect(commandMock).toHaveBeenLastCalledWith(
+			"approval.respond",
+			{
+				approvalId: "approval-1",
+				approved: true,
+				reason: "approved by app handler",
+			},
+			"sess-1",
+		);
+	});
+
+	it("passes cancellation into long-running hub capability handlers", async () => {
+		let onEvent: ((event: HubEventEnvelope) => void) | undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValueOnce({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		let receivedSignal: AbortSignal | undefined;
+		let resolveExecutor: ((value: string) => void) | undefined;
+		const askQuestion = vi.fn(
+			async (
+				_question: string,
+				_options: string[],
+				context: AgentToolContext,
+			) => {
+				receivedSignal = context.signal;
+				return await new Promise<string>((resolve) => {
+					resolveExecutor = resolve;
+				});
+			},
+		);
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			capabilities: { toolExecutors: { askQuestion } },
+		});
+
+		onEvent?.({
+			version: "v1",
+			event: "capability.requested",
+			sessionId: "sess-1",
+			payload: {
+				requestId: "capreq-1",
+				targetClientId: "client-1",
+				capabilityName: "tool_executor.askQuestion",
+				payload: {
+					args: ["Which approach?", ["Use the SDK"]],
+					context: {
+						agentId: "agent-1",
+						conversationId: "conversation-1",
+						iteration: 1,
+					},
+				},
+			},
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(receivedSignal).toBeDefined();
+		expect(receivedSignal?.aborted).toBe(false);
+		onEvent?.({
+			version: "v1",
+			event: "capability.resolved",
+			sessionId: "sess-1",
+			payload: {
+				requestId: "capreq-1",
+				capabilityName: "tool_executor.askQuestion",
+				targetClientId: "client-1",
+				ok: false,
+				cancelled: true,
+				error: "user cancelled",
+			},
+		});
+
+		expect(receivedSignal?.aborted).toBe(true);
+		resolveExecutor?.("Use the SDK");
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(commandMock).not.toHaveBeenLastCalledWith(
+			"capability.respond",
+			expect.anything(),
+			"sess-1",
+		);
+	});
+
+	it("tears down session stream subscriptions when a session stops", async () => {
+		const unsubscribe = vi.fn();
+		subscribeMock.mockReturnValue(unsubscribe);
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await host.startSession({
+			config: { ...createConfig(), sessionId: "sess-1" },
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		commandMock.mockResolvedValue({ ok: true, payload: {} });
+		await host.stopSession("sess-1");
+
+		expect(unsubscribe).toHaveBeenCalledTimes(1);
+		expect(commandMock).toHaveBeenLastCalledWith(
+			"session.detach",
+			{ sessionId: "sess-1" },
+			"sess-1",
+		);
+	});
+
+	it("maps hub completion events back to agent and lifecycle events without duplicating done", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event:
+						| "assistant.finished"
+						| "reasoning.finished"
+						| "agent.done"
+						| "run.completed";
+					sessionId: string;
+					payload?: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: 1,
+			event: "assistant.finished",
+			sessionId: "sess-1",
+			payload: { text: "hello" },
+		});
+		onEvent?.({
+			version: 1,
+			event: "reasoning.finished",
+			sessionId: "sess-1",
+			payload: { reasoning: "thought" },
+		});
+		onEvent?.({
+			version: 1,
+			event: "agent.done",
+			sessionId: "sess-1",
+			payload: {
+				reason: "completed",
+				text: "hello",
+				iterations: 1,
+				usage: { inputTokens: 2, outputTokens: 3, totalCost: 0.01 },
+			},
+		});
+		onEvent?.({
+			version: 1,
+			event: "run.completed",
+			sessionId: "sess-1",
+			payload: { reason: "completed" },
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: { type: "content_end", contentType: "text", text: "hello" },
+					}),
+				}),
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: {
+							type: "content_end",
+							contentType: "reasoning",
+							reasoning: "thought",
+						},
+					}),
+				}),
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: expect.objectContaining({
+							type: "done",
+							reason: "completed",
+							text: "hello",
+							iterations: 1,
+						}),
+					}),
+				}),
+			]),
+		);
+		expect(agentDoneEvents(events)).toHaveLength(1);
+		expect(agentDoneEvents(events)[0]?.payload.event).toMatchObject({
+			type: "done",
+			reason: "completed",
+			text: "hello",
+			iterations: 1,
+		});
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "ended",
+					payload: expect.objectContaining({
+						sessionId: "sess-1",
+						reason: "completed",
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("maps hub usage updates back to agent usage events with identity", async () => {
+		let onEvent: ((event: HubEventEnvelope) => void) | undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: "v1",
+			event: "usage.updated",
+			sessionId: "sess-1",
+			payload: {
+				delta: {
+					inputTokens: 7,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 1,
+					totalCost: 0.12,
+				},
+				totals: {
+					inputTokens: 17,
+					outputTokens: 8,
+					cacheReadTokens: 3,
+					cacheWriteTokens: 3,
+					totalCost: 0.23,
+				},
+				agent: {
+					kind: "teammate",
+					agentId: "agent-teammate-1",
+					conversationId: "conv-teammate-1",
+					parentAgentId: "lead",
+					teamAgentId: "investigator",
+					teamRole: "teammate",
+				},
+			},
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "agent_event",
+					payload: {
+						sessionId: "sess-1",
+						teamAgentId: "investigator",
+						teamRole: "teammate",
+						event: {
+							type: "usage",
+							agentId: "agent-teammate-1",
+							conversationId: "conv-teammate-1",
+							parentAgentId: "lead",
+							inputTokens: 7,
+							outputTokens: 5,
+							cacheReadTokens: 2,
+							cacheWriteTokens: 1,
+							cost: 0.12,
+							totalInputTokens: 17,
+							totalOutputTokens: 8,
+							totalCacheReadTokens: 3,
+							totalCacheWriteTokens: 3,
+							totalCost: 0.23,
+						},
+					},
+				}),
+			]),
+		);
+	});
+
+	it("synthesizes done from run.completed when no agent.done was observed", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event: "run.completed";
+					sessionId: string;
+					payload?: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: 1,
+			event: "run.completed",
+			sessionId: "sess-1",
+			payload: {
+				reason: "completed",
+				result: {
+					finishReason: "completed",
+					text: "fallback text",
+					iterations: 2,
+				},
+			},
+		});
+
+		expect(agentDoneEvents(events)).toHaveLength(1);
+		expect(agentDoneEvents(events)[0]?.payload.event).toMatchObject({
+			type: "done",
+			reason: "completed",
+			text: "fallback text",
+			iterations: 2,
+		});
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "ended",
+					payload: expect.objectContaining({
+						sessionId: "sess-1",
+						reason: "completed",
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("maps hub iteration lifecycle events back to agent events", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event: "iteration.started" | "iteration.finished";
+					sessionId: string;
+					payload?: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: 1,
+			event: "iteration.started",
+			sessionId: "sess-1",
+			payload: { iteration: 2 },
+		});
+		onEvent?.({
+			version: 1,
+			event: "iteration.finished",
+			sessionId: "sess-1",
+			payload: { iteration: 2, hadToolCalls: true, toolCallCount: 1 },
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: { type: "iteration_start", iteration: 2 },
+					}),
+				}),
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: {
+							type: "iteration_end",
+							iteration: 2,
+							hadToolCalls: true,
+							toolCallCount: 1,
+						},
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("maps hub aborted runs back to aborted agent events", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event: "run.aborted";
+					sessionId: string;
+					payload?: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: 1,
+			event: "run.aborted",
+			sessionId: "sess-1",
+			payload: {
+				snapshot: {
+					version: 1,
+					sessionId: "sess-1",
+					status: "running",
+					interactive: true,
+				},
+			},
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: expect.objectContaining({
+							type: "done",
+							reason: "aborted",
+						}),
+					}),
+				}),
+			]),
+		);
+		expect(events).not.toContainEqual(
+			expect.objectContaining({
+				type: "ended",
+				payload: expect.objectContaining({ sessionId: "sess-1" }),
+			}),
+		);
+	});
+
+	it("emits ended for terminal interactive hub run events", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event: "run.aborted";
+					sessionId: string;
+					payload?: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: 1,
+			event: "run.aborted",
+			sessionId: "sess-1",
+			payload: {
+				snapshot: {
+					version: 1,
+					sessionId: "sess-1",
+					status: "cancelled",
+					interactive: true,
+				},
+			},
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: expect.objectContaining({
+							type: "done",
+							reason: "aborted",
+						}),
+					}),
+				}),
+				expect.objectContaining({
+					type: "ended",
+					payload: expect.objectContaining({
+						sessionId: "sess-1",
+						reason: "aborted",
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("maps failed hub runs back to error agent events", async () => {
+		let onEvent:
+			| ((event: {
+					version: 1;
+					event: "run.failed";
+					sessionId: string;
+					payload?: Record<string, unknown>;
+			  }) => void)
+			| undefined;
+		subscribeMock.mockImplementation((listener) => {
+			onEvent = listener;
+			return () => {};
+		});
+		commandMock.mockResolvedValue({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+		const events: unknown[] = [];
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+		host.subscribe((event) => events.push(event));
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+
+		onEvent?.({
+			version: 1,
+			event: "run.failed",
+			sessionId: "sess-1",
+			payload: {
+				reason: "error",
+				text: "run failed",
+				iterations: 2,
+			},
+		});
+
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "agent_event",
+					payload: expect.objectContaining({
+						event: expect.objectContaining({
+							type: "done",
+							reason: "error",
+							text: "run failed",
+							iterations: 2,
+						}),
+					}),
+				}),
+				expect.objectContaining({
+					type: "ended",
+					payload: expect.objectContaining({
+						sessionId: "sess-1",
+						reason: "error",
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("forwards image attachments when sending a run", async () => {
+		commandMock.mockResolvedValue({ ok: true, payload: { result: undefined } });
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await host.runTurn({
+			sessionId: "sess-1",
+			prompt: "Describe this image",
+			userImages: ["data:image/png;base64,aGVsbG8="],
+		});
+
+		expect(commandMock).toHaveBeenCalledWith(
+			"run.start",
+			{
+				sessionId: "sess-1",
+				input: "Describe this image",
+				attachments: {
+					userImages: ["data:image/png;base64,aGVsbG8="],
+				},
+				delivery: undefined,
+			},
+			"sess-1",
+			{ timeoutMs: null },
+		);
+	});
+
+	it("forwards file attachments when sending a run", async () => {
+		commandMock.mockResolvedValue({ ok: true, payload: { result: undefined } });
+
+		const filePath = "/tmp/project/note.md";
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await host.runTurn({
+			sessionId: "sess-1",
+			prompt: "Use this file",
+			userFiles: [filePath],
+		});
+
+		expect(commandMock).toHaveBeenCalledWith(
+			"run.start",
+			{
+				sessionId: "sess-1",
+				input: "Use this file",
+				attachments: {
+					userFiles: [filePath],
+				},
+				delivery: undefined,
+			},
+			"sess-1",
+			{ timeoutMs: null },
+		);
+	});
+
+	it("serializes error abort reasons for hub abort commands", async () => {
+		commandMock.mockResolvedValue({ ok: true, payload: { applied: true } });
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await host.abort(
+			"sess-1",
+			new Error("Interactive runtime abort requested"),
+		);
+
+		expect(commandMock).toHaveBeenCalledWith(
+			"run.abort",
+			{
+				sessionId: "sess-1",
+				reason: "Interactive runtime abort requested",
+			},
+			"sess-1",
+		);
+	});
+
+	it("reads messages through the hub instead of dereferencing client-local artifact paths", async () => {
+		const messages = [
+			{
+				role: "user",
+				content: [{ type: "text", text: "hello from another client" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "hello" }],
+			},
+		];
+		commandMock.mockResolvedValue({ ok: true, payload: { messages } });
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await expect(host.readSessionMessages(" sess-1 ")).resolves.toEqual(
+			messages,
+		);
+		expect(commandMock).toHaveBeenCalledWith(
+			"session.messages",
+			{ sessionId: "sess-1" },
+			"sess-1",
+		);
+	});
+
+	it("throws when the hub rejects message reads", async () => {
+		const telemetry = { capture: vi.fn() };
+		commandMock.mockResolvedValue({
+			ok: false,
+			error: {
+				code: "session_not_found",
+				message: "Unknown session: sess-missing",
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({
+			url: "ws://127.0.0.1:25463/hub",
+			telemetry: telemetry as never,
+		});
+
+		await expect(host.readSessionMessages("sess-missing")).rejects.toThrow(
+			"Unknown session: sess-missing",
+		);
+		expect(telemetry.capture).toHaveBeenCalledWith({
+			event: "sdk.error",
+			properties: expect.objectContaining({
+				component: "core",
+				operation: "hub.runtime_host.read_session_messages",
+				severity: "warn",
+				handled: true,
+				command: "session.messages",
+				sessionId: "sess-missing",
+				errorCode: "session_not_found",
+				error_message: "Unknown session: sess-missing",
+			}),
+		});
+	});
+
+	it("records rejected compaction state updates as handled errors", async () => {
+		const telemetry = { capture: vi.fn() };
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "sess-1",
+		});
+		commandMock.mockResolvedValue({
+			ok: false,
+			error: {
+				code: "session_wrong_client",
+				message: "Session sess-1 is owned by other-client",
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({
+			url: "ws://127.0.0.1:25463/hub",
+			telemetry: telemetry as never,
+		});
+
+		await expect(
+			host.updateSessionCompactionState(" sess-1 ", state),
+		).resolves.toEqual({ updated: false });
+		expect(telemetry.capture).toHaveBeenCalledWith({
+			event: "sdk.error",
+			properties: expect.objectContaining({
+				component: "core",
+				operation: "hub.runtime_host.update_session_compaction_state",
+				severity: "warn",
+				handled: true,
+				command: "session.compaction.update",
+				sessionId: "sess-1",
+				errorCode: "session_wrong_client",
+				error_message: "Session sess-1 is owned by other-client",
+			}),
+		});
+	});
+
+	it("treats stale compaction state updates as non-error no-ops", async () => {
+		const telemetry = { capture: vi.fn() };
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "sess-1",
+		});
+		commandMock.mockResolvedValue({
+			ok: true,
+			payload: { updated: false },
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({
+			url: "ws://127.0.0.1:25463/hub",
+			telemetry: telemetry as never,
+		});
+
+		await expect(
+			host.updateSessionCompactionState("sess-1", state),
+		).resolves.toEqual({ updated: false });
+		expect(telemetry.capture).not.toHaveBeenCalled();
+	});
+
+	it("throws when the hub rejects settings list", async () => {
+		commandMock.mockResolvedValue({
+			ok: false,
+			error: {
+				code: "settings_list_failed",
+				message: "Invalid settings list payload",
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await expect(host.listSettings({ cwd: "/tmp/project" })).rejects.toThrow(
+			"Invalid settings list payload",
+		);
+		expect(commandMock).toHaveBeenCalledWith("settings.list", {
+			cwd: "/tmp/project",
+		});
+	});
+
+	it("throws when the hub rejects settings toggle", async () => {
+		commandMock.mockResolvedValue({
+			ok: false,
+			error: {
+				code: "settings_toggle_failed",
+				message: "Unknown settings type",
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await expect(
+			host.toggleSetting({ type: "skills", id: "skill-one" }),
+		).rejects.toThrow("Unknown settings type");
+		expect(commandMock).toHaveBeenCalledWith("settings.toggle", {
+			type: "skills",
+			id: "skill-one",
+		});
+	});
+
+	it("detaches active sessions when disposed", async () => {
+		commandMock.mockResolvedValueOnce({
+			payload: {
+				session: {
+					sessionId: "sess-1",
+					status: "running",
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				},
+			},
+		});
+
+		const { HubRuntimeHost } = await import("./hub-runtime-host");
+		const host = new HubRuntimeHost({ url: "ws://127.0.0.1:25463/hub" });
+
+		await host.startSession({
+			config: createConfig(),
+			source: SessionSource.CLI,
+			prompt: "Hey",
+		});
+		await host.dispose();
+
+		expect(commandMock).toHaveBeenLastCalledWith(
+			"session.detach",
+			{ sessionId: "sess-1" },
+			"sess-1",
+		);
+		expect(disposeMock).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/sdk/packages/core/src/hub/runtime-host/hub-runtime-host.ts b/sdk/packages/core/src/hub/runtime-host/hub-runtime-host.ts
new file mode 100644
index 0000000..98f87ac
--- /dev/null
+++ b/sdk/packages/core/src/hub/runtime-host/hub-runtime-host.ts
@@ -0,0 +1,2067 @@
+import type {
+	AgentEvent,
+	AgentFinishReason,
+	AgentResult,
+	AgentToolContext,
+	AgentUsage,
+	HubClientContribution,
+	HubEventEnvelope,
+	SessionRecord as HubSessionRecord,
+	ITelemetryService,
+	JsonValue,
+	ToolApprovalRequest,
+} from "@cline/shared";
+import {
+	captureSdkError,
+	createSessionId,
+	HUB_CHECKPOINT_CAPABILITY,
+	HUB_COMPACTION_CAPABILITY,
+	HUB_CUSTOM_TOOL_CAPABILITY_PREFIX,
+	HUB_HOOK_CAPABILITY_PREFIX,
+	HUB_MISTAKE_LIMIT_CAPABILITY,
+	HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX,
+	HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+	isHubToolExecutorName,
+	mergeClineClientRequestHeaders,
+} from "@cline/shared";
+import { version as corePackageVersion } from "../../../package.json";
+import type { HookEventPayload } from "../../hooks";
+import type { RuntimeCapabilities } from "../../runtime/capabilities";
+import { normalizeRuntimeCapabilities } from "../../runtime/capabilities";
+import type {
+	PendingPromptMutationResult,
+	PendingPromptsServiceApi,
+	RestoreSessionInput,
+	RestoreSessionResult,
+	RuntimeHost,
+	RuntimeHostSubscribeOptions,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	SessionConnectionUpdate,
+	SessionUsageSummary,
+	StartSessionInput,
+	StartSessionResult,
+} from "../../runtime/host/runtime-host";
+import { isSessionNotFoundError } from "../../runtime/host/runtime-host";
+import { RuntimeHostEventBus } from "../../runtime/host/runtime-host-support";
+import {
+	parseSessionCompactionState,
+	type SessionCompactionState,
+} from "../../session/models/session-compaction";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "../../session/models/session-manifest";
+import {
+	type CoreSessionSnapshot,
+	coreSessionSnapshotToRecord,
+} from "../../session/session-snapshot";
+import type {
+	CoreSettingsListInput,
+	CoreSettingsMutationResult,
+	CoreSettingsSnapshot,
+	CoreSettingsToggleInput,
+} from "../../settings";
+import {
+	isNonTerminalSessionStatus,
+	SessionSource,
+	type SessionStatus,
+} from "../../types/common";
+import type {
+	CoreSessionEvent,
+	SessionPendingPrompt,
+} from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import {
+	type HubClientOptions,
+	isHubCommandTimeoutError,
+	NodeHubClient,
+	restartLocalHubIfIdleAfterStartupTimeout,
+} from "../client";
+
+function toJsonRecord(
+	value: Record<string, unknown> | undefined,
+): Record<string, JsonValue | undefined> | undefined {
+	if (!value) {
+		return undefined;
+	}
+	return JSON.parse(JSON.stringify(value)) as Record<
+		string,
+		JsonValue | undefined
+	>;
+}
+
+const HUB_HOOK_NAMES = [
+	"beforeRun",
+	"afterRun",
+	"beforeModel",
+	"afterModel",
+	"beforeTool",
+	"afterTool",
+	"onEvent",
+] as const;
+
+function toJsonSerializable(
+	value: unknown,
+): Record<string, JsonValue | undefined> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return JSON.parse(JSON.stringify(value)) as Record<
+		string,
+		JsonValue | undefined
+	>;
+}
+
+function serializeSettingsInput(
+	input: CoreSettingsListInput | CoreSettingsToggleInput | undefined,
+): Record<string, unknown> | undefined {
+	if (!input) {
+		return undefined;
+	}
+	const { userInstructionService: _userInstructionService, ...serializable } =
+		input;
+	return JSON.parse(JSON.stringify(serializable)) as Record<string, unknown>;
+}
+
+function buildCommandSessionConfig(
+	input: StartSessionInput,
+	sessionId: string,
+): Record<string, unknown> {
+	const sessionConfig: Record<string, unknown> = {
+		...(input.config as Record<string, unknown>),
+		sessionId,
+	};
+	const headers = mergeClineClientRequestHeaders({
+		providerId: input.config.providerId,
+		sessionId,
+		source: input.source,
+		defaultSource: SessionSource.CORE,
+		clientName: input.localRuntime?.extensionContext?.client?.name,
+		clientVersion: input.localRuntime?.extensionContext?.client?.version,
+		clientVersionHeaderFallback: input.config.headers?.["X-CLIENT-VERSION"],
+		platform: input.localRuntime?.extensionContext?.client?.platform,
+		platformVersion:
+			input.localRuntime?.extensionContext?.client?.platformVersion,
+		isMultiRoot: input.localRuntime?.extensionContext?.client?.isMultiRoot,
+		coreVersion: corePackageVersion,
+		headers: [input.config.headers],
+	});
+	if (headers) {
+		sessionConfig.headers = headers;
+	}
+	return sessionConfig;
+}
+
+function parseToolContext(value: unknown): AgentToolContext {
+	const payload =
+		value && typeof value === "object" && !Array.isArray(value)
+			? (value as Record<string, unknown>)
+			: {};
+	return {
+		agentId: typeof payload.agentId === "string" ? payload.agentId : "",
+		conversationId:
+			typeof payload.conversationId === "string" ? payload.conversationId : "",
+		iteration: typeof payload.iteration === "number" ? payload.iteration : 0,
+		metadata:
+			payload.metadata &&
+			typeof payload.metadata === "object" &&
+			!Array.isArray(payload.metadata)
+				? (payload.metadata as Record<string, unknown>)
+				: undefined,
+	};
+}
+
+type ClientContributionHandler = (input: {
+	payload: Record<string, unknown>;
+	abortSignal: AbortSignal;
+	progress: (payload: Record<string, unknown>) => void;
+}) => Promise<Record<string, unknown> | undefined>;
+
+interface ClientContributionRegistration {
+	manifest: HubClientContribution[];
+	handlers: Map<string, ClientContributionHandler>;
+}
+
+function addClientContribution(
+	registration: ClientContributionRegistration,
+	contribution: HubClientContribution,
+	handler: ClientContributionHandler,
+): void {
+	registration.manifest.push(contribution);
+	registration.handlers.set(contribution.capabilityName, handler);
+}
+
+function buildClientContributionRegistration(
+	localRuntime: StartSessionInput["localRuntime"] | undefined,
+	capabilities: RuntimeCapabilities,
+): ClientContributionRegistration {
+	const registration: ClientContributionRegistration = {
+		manifest: [],
+		handlers: new Map(),
+	};
+
+	for (const executor of Object.keys(capabilities.toolExecutors ?? {}).filter(
+		isHubToolExecutorName,
+	)) {
+		const executorFn = capabilities.toolExecutors?.[executor] as
+			| ((...args: unknown[]) => Promise<unknown>)
+			| undefined;
+		if (typeof executorFn !== "function") continue;
+		addClientContribution(
+			registration,
+			{
+				kind: "toolExecutor",
+				executor,
+				capabilityName: `${HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX}${executor}`,
+			},
+			async ({ payload, abortSignal }) => {
+				const args = Array.isArray(payload.args) ? [...payload.args] : [];
+				const context = {
+					...parseToolContext(payload.context),
+					signal: abortSignal,
+				};
+				return { result: await executorFn(...args, context) };
+			},
+		);
+	}
+
+	for (const tool of localRuntime?.extraTools ?? []) {
+		addClientContribution(
+			registration,
+			{
+				kind: "tool",
+				name: tool.name,
+				description: tool.description,
+				inputSchema: toJsonRecord(tool.inputSchema) ?? {},
+				...(tool.lifecycle
+					? {
+							lifecycle: toJsonRecord(
+								tool.lifecycle as Record<string, unknown>,
+							),
+						}
+					: {}),
+				capabilityName: `${HUB_CUSTOM_TOOL_CAPABILITY_PREFIX}${tool.name}`,
+			},
+			async ({ payload, abortSignal, progress }) => {
+				const context = {
+					...parseToolContext(payload.context),
+					signal: abortSignal,
+				};
+				const result = await tool.execute(payload.input, {
+					...context,
+					emitUpdate: (update) => {
+						progress({ update });
+					},
+				});
+				return { result };
+			},
+		);
+	}
+
+	const hooks = localRuntime?.hooks as Record<string, unknown> | undefined;
+	if (hooks) {
+		for (const name of HUB_HOOK_NAMES) {
+			const hook = hooks[name];
+			if (typeof hook !== "function") continue;
+			addClientContribution(
+				registration,
+				{
+					kind: "hook",
+					name,
+					capabilityName: `${HUB_HOOK_CAPABILITY_PREFIX}${name}`,
+				},
+				async ({ payload }) => ({
+					control: await hook(payload.context),
+				}),
+			);
+		}
+	}
+
+	if (localRuntime?.compaction?.compact) {
+		const compact = localRuntime.compaction.compact;
+		addClientContribution(
+			registration,
+			{
+				kind: "compaction",
+				capabilityName: HUB_COMPACTION_CAPABILITY,
+				config: toJsonSerializable(localRuntime.compaction),
+			},
+			async ({ payload }) => ({
+				result: await compact(payload.context as never),
+			}),
+		);
+	}
+
+	if (localRuntime?.checkpoint?.createCheckpoint) {
+		const createCheckpoint = localRuntime.checkpoint.createCheckpoint;
+		addClientContribution(
+			registration,
+			{
+				kind: "checkpoint",
+				capabilityName: HUB_CHECKPOINT_CAPABILITY,
+				config: toJsonSerializable(localRuntime.checkpoint),
+			},
+			async ({ payload }) => ({
+				result: await createCheckpoint(payload.context as never),
+			}),
+		);
+	}
+
+	if (localRuntime?.onConsecutiveMistakeLimitReached) {
+		const decide = localRuntime.onConsecutiveMistakeLimitReached;
+		addClientContribution(
+			registration,
+			{
+				kind: "mistakeLimit",
+				capabilityName: HUB_MISTAKE_LIMIT_CAPABILITY,
+			},
+			async ({ payload }) => ({
+				result: await decide(payload.context as never),
+			}),
+		);
+	}
+
+	if (localRuntime?.userInstructionService) {
+		const service = localRuntime.userInstructionService;
+		addClientContribution(
+			registration,
+			{
+				kind: "userInstructionService",
+				capabilityName: HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+			},
+			async () => {
+				await service.start().catch(() => {});
+				return {
+					snapshot: {
+						records: {
+							skill: service.listRecords("skill"),
+							rule: service.listRecords("rule"),
+							workflow: service.listRecords("workflow"),
+						},
+						runtimeCommands: service.listRuntimeCommands(),
+					},
+				};
+			},
+		);
+	}
+
+	return registration;
+}
+
+function messageFromUnknown(value: unknown): string | undefined {
+	if (typeof value === "string" && value.trim()) {
+		return value.trim();
+	}
+	if (value instanceof Error) {
+		return value.message.trim() || undefined;
+	}
+	if (value && typeof value === "object" && "message" in value) {
+		const message = (value as { message?: unknown }).message;
+		if (typeof message === "string" && message.trim()) {
+			return message.trim();
+		}
+	}
+	return undefined;
+}
+
+function abortReasonMessage(value: unknown): string {
+	return messageFromUnknown(value) ?? "Capability request was cancelled.";
+}
+
+function parseApprovalInput(value: unknown): unknown {
+	if (typeof value !== "string") {
+		return value;
+	}
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+
+function isAgentFinishReason(value: unknown): value is AgentFinishReason {
+	return (
+		value === "completed" ||
+		value === "max_iterations" ||
+		value === "aborted" ||
+		value === "mistake_limit" ||
+		value === "error"
+	);
+}
+
+function parseDoneUsage(value: unknown): AgentUsage | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	const payload = value as Record<string, unknown>;
+	const inputTokens =
+		typeof payload.inputTokens === "number" ? payload.inputTokens : undefined;
+	const outputTokens =
+		typeof payload.outputTokens === "number" ? payload.outputTokens : undefined;
+	if (inputTokens === undefined || outputTokens === undefined) {
+		return undefined;
+	}
+	return {
+		inputTokens,
+		outputTokens,
+		cacheReadTokens:
+			typeof payload.cacheReadTokens === "number" ? payload.cacheReadTokens : 0,
+		cacheWriteTokens:
+			typeof payload.cacheWriteTokens === "number"
+				? payload.cacheWriteTokens
+				: 0,
+		totalCost: typeof payload.totalCost === "number" ? payload.totalCost : 0,
+	};
+}
+
+function accumulatedUsageFromMetrics(
+	value: HubSessionRecord["usage"],
+): SessionAccumulatedUsage | undefined {
+	if (!value) {
+		return undefined;
+	}
+	return {
+		inputTokens: typeof value.inputTokens === "number" ? value.inputTokens : 0,
+		outputTokens:
+			typeof value.outputTokens === "number" ? value.outputTokens : 0,
+		cacheReadTokens:
+			typeof value.cacheReadTokens === "number" ? value.cacheReadTokens : 0,
+		cacheWriteTokens:
+			typeof value.cacheWriteTokens === "number" ? value.cacheWriteTokens : 0,
+		totalCost: typeof value.totalCost === "number" ? value.totalCost : 0,
+	};
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function usageMetric(
+	record: Record<string, unknown> | undefined,
+	key: string,
+): number {
+	return finiteNumber(record?.[key]) ?? 0;
+}
+
+function usageEventFromPayload(payload: Record<string, unknown> | undefined): {
+	event: Extract<AgentEvent, { type: "usage" }>;
+	teamAgentId?: string;
+	teamRole?: "lead" | "teammate";
+} {
+	const delta =
+		payload?.delta && typeof payload.delta === "object"
+			? (payload.delta as Record<string, unknown>)
+			: undefined;
+	const totals =
+		payload?.totals && typeof payload.totals === "object"
+			? (payload.totals as Record<string, unknown>)
+			: undefined;
+	const agent =
+		payload?.agent && typeof payload.agent === "object"
+			? (payload.agent as Record<string, unknown>)
+			: undefined;
+	const teamRole =
+		agent?.teamRole === "teammate" || agent?.teamRole === "lead"
+			? agent.teamRole
+			: undefined;
+	return {
+		event: {
+			type: "usage",
+			agentId: typeof agent?.agentId === "string" ? agent.agentId : undefined,
+			conversationId:
+				typeof agent?.conversationId === "string"
+					? agent.conversationId
+					: undefined,
+			parentAgentId:
+				typeof agent?.parentAgentId === "string"
+					? agent.parentAgentId
+					: undefined,
+			inputTokens: usageMetric(delta, "inputTokens"),
+			outputTokens: usageMetric(delta, "outputTokens"),
+			cacheReadTokens: usageMetric(delta, "cacheReadTokens"),
+			cacheWriteTokens: usageMetric(delta, "cacheWriteTokens"),
+			cost: finiteNumber(delta?.totalCost),
+			totalInputTokens: usageMetric(totals, "inputTokens"),
+			totalOutputTokens: usageMetric(totals, "outputTokens"),
+			totalCacheReadTokens: usageMetric(totals, "cacheReadTokens"),
+			totalCacheWriteTokens: usageMetric(totals, "cacheWriteTokens"),
+			totalCost: finiteNumber(totals?.totalCost),
+		},
+		teamAgentId:
+			typeof agent?.teamAgentId === "string" ? agent.teamAgentId : undefined,
+		teamRole,
+	};
+}
+
+function doneEventFromPayload(
+	payload: Record<string, unknown> | undefined,
+): AgentEvent {
+	const result =
+		payload?.result &&
+		typeof payload.result === "object" &&
+		!Array.isArray(payload.result)
+			? (payload.result as Record<string, unknown>)
+			: undefined;
+	const reasonCandidate = payload?.reason ?? result?.finishReason;
+	const reason = isAgentFinishReason(reasonCandidate)
+		? reasonCandidate
+		: reasonCandidate === "failed"
+			? "error"
+			: "completed";
+	const usage = parseDoneUsage(payload?.usage ?? result?.usage);
+	return {
+		type: "done",
+		reason,
+		text:
+			typeof payload?.text === "string"
+				? payload.text
+				: typeof result?.text === "string"
+					? result.text
+					: "",
+		iterations:
+			typeof payload?.iterations === "number"
+				? payload.iterations
+				: typeof result?.iterations === "number"
+					? result.iterations
+					: 0,
+		usage,
+	};
+}
+
+function hubReplyErrorMessage(
+	reply: { error?: { message?: string } },
+	command: string,
+): string {
+	return reply.error?.message ?? `hub command failed: ${command}`;
+}
+
+export interface HubRuntimeHostOptions {
+	url: string;
+	authToken?: string;
+	clientType?: string;
+	displayName?: string;
+	capabilities?: RuntimeCapabilities;
+	telemetry?: ITelemetryService;
+}
+
+function mapStatus(
+	status: HubSessionRecord["status"] | undefined,
+): SessionStatus {
+	switch (status) {
+		case "idle":
+		case "completed":
+			return "completed";
+		case "failed":
+			return "failed";
+		case "aborted":
+			return "cancelled";
+		default:
+			return "running";
+	}
+}
+
+function toSessionRecord(session: HubSessionRecord): SessionRecord {
+	const metadata =
+		session.metadata && typeof session.metadata === "object"
+			? JSON.parse(JSON.stringify(session.metadata))
+			: undefined;
+	return {
+		sessionId: session.sessionId,
+		parentSessionId:
+			typeof metadata?.parentSessionId === "string"
+				? metadata.parentSessionId
+				: undefined,
+		agentId:
+			session.runtimeSession?.agentId ||
+			(typeof metadata?.agentId === "string" ? metadata.agentId : undefined),
+		parentAgentId:
+			typeof metadata?.parentAgentId === "string"
+				? metadata.parentAgentId
+				: undefined,
+		conversationId:
+			typeof metadata?.conversationId === "string"
+				? metadata.conversationId
+				: undefined,
+		isSubagent:
+			typeof metadata?.isSubagent === "boolean" ? metadata.isSubagent : false,
+		source:
+			typeof metadata?.source === "string"
+				? metadata.source
+				: SessionSource.CORE,
+		pid: typeof metadata?.pid === "number" ? metadata.pid : undefined,
+		startedAt: new Date(session.createdAt).toISOString(),
+		endedAt:
+			mapStatus(session.status) === "running"
+				? undefined
+				: new Date(session.updatedAt).toISOString(),
+		exitCode:
+			mapStatus(session.status) === "completed"
+				? 0
+				: mapStatus(session.status) === "failed"
+					? 1
+					: undefined,
+		status: mapStatus(session.status),
+		interactive: metadata?.interactive === true,
+		provider:
+			typeof metadata?.provider === "string" ? metadata.provider : "hub",
+		model: typeof metadata?.model === "string" ? metadata.model : "hub",
+		cwd: session.cwd?.trim() || session.workspaceRoot,
+		workspaceRoot: session.workspaceRoot,
+		teamName:
+			typeof metadata?.teamName === "string" ? metadata.teamName : undefined,
+		enableTools:
+			session.runtimeOptions?.enableTools ?? metadata?.enableTools === true,
+		enableSpawn:
+			session.runtimeOptions?.enableSpawn ?? metadata?.enableSpawn === true,
+		enableTeams:
+			session.runtimeOptions?.enableTeams ?? metadata?.enableTeams === true,
+		prompt: typeof metadata?.prompt === "string" ? metadata.prompt : undefined,
+		metadata,
+		updatedAt: new Date(session.updatedAt).toISOString(),
+		messagesPath:
+			typeof metadata?.messagesPath === "string"
+				? metadata.messagesPath
+				: undefined,
+		hookPath:
+			typeof metadata?.hookPath === "string" ? metadata.hookPath : undefined,
+	};
+}
+
+function parseCoreSessionSnapshot(
+	value: unknown,
+): CoreSessionSnapshot | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	const snapshot = value as Partial<CoreSessionSnapshot>;
+	return snapshot.version === 1 && typeof snapshot.sessionId === "string"
+		? (JSON.parse(JSON.stringify(snapshot)) as CoreSessionSnapshot)
+		: undefined;
+}
+
+function sessionRecordFromPayload(
+	payload: Record<string, unknown> | undefined,
+): SessionRecord | undefined {
+	const snapshot = parseCoreSessionSnapshot(payload?.snapshot);
+	if (snapshot) {
+		return coreSessionSnapshotToRecord(snapshot);
+	}
+	const session = payload?.session as HubSessionRecord | undefined;
+	return session ? toSessionRecord(session) : undefined;
+}
+
+function buildManifest(
+	sessionId: string,
+	input: StartSessionInput,
+	session: HubSessionRecord | undefined,
+): SessionManifest {
+	const workspaceRoot =
+		session?.workspaceRoot?.trim() ||
+		input.config.workspaceRoot ||
+		input.config.cwd;
+	return SessionManifestSchema.parse({
+		version: 1,
+		session_id: sessionId,
+		source: input.source ?? SessionSource.CORE,
+		pid: process.pid,
+		started_at: new Date(session?.createdAt ?? Date.now()).toISOString(),
+		status: mapStatus(session?.status),
+		interactive: input.interactive === true,
+		provider: input.config.providerId,
+		model: input.config.modelId,
+		cwd: session?.cwd?.trim() || input.config.cwd,
+		workspace_root: workspaceRoot,
+		team_name: input.config.teamName,
+		enable_tools: input.config.enableTools,
+		enable_spawn: input.config.enableSpawnAgent,
+		enable_teams: input.config.enableAgentTeams,
+		prompt: input.prompt?.trim() || undefined,
+		metadata:
+			input.sessionMetadata && Object.keys(input.sessionMetadata).length > 0
+				? input.sessionMetadata
+				: undefined,
+	});
+}
+
+function buildManifestFromSnapshot(
+	snapshot: CoreSessionSnapshot,
+	input: StartSessionInput,
+): SessionManifest {
+	return SessionManifestSchema.parse({
+		version: 1,
+		session_id: snapshot.sessionId,
+		source: snapshot.source,
+		pid: process.pid,
+		started_at: snapshot.createdAt,
+		status: snapshot.status,
+		interactive: snapshot.interactive,
+		provider: snapshot.model.providerId,
+		model: snapshot.model.modelId,
+		cwd: snapshot.workspace.cwd,
+		workspace_root: snapshot.workspace.root,
+		team_name: snapshot.team?.name,
+		enable_tools: snapshot.capabilities.enableTools,
+		enable_spawn: snapshot.capabilities.enableSpawn,
+		enable_teams: snapshot.capabilities.enableTeams,
+		prompt: (snapshot.prompt ?? input.prompt?.trim()) || undefined,
+		metadata: snapshot.metadata,
+		messages_path: snapshot.artifacts?.messagesPath,
+	});
+}
+
+export class HubRuntimeHost implements RuntimeHost {
+	public runtimeAddress: string;
+	public readonly pendingPrompts: PendingPromptsServiceApi;
+	private client: NodeHubClient;
+	private readonly clientOptions: Omit<HubClientOptions, "url">;
+	private readonly clientContext?: { workspaceRoot?: string; cwd?: string };
+	private readonly events = new RuntimeHostEventBus();
+	private readonly sessionCapabilities = new Map<string, RuntimeCapabilities>();
+	private readonly sessionClientContributionHandlers = new Map<
+		string,
+		Map<string, ClientContributionHandler>
+	>();
+	private readonly sessionSubscriptions = new Map<string, () => void>();
+	private readonly pendingApprovalToolCallIds = new Set<string>();
+	private readonly agentDoneEmittedForCurrentRunBySession = new Set<string>();
+	private readonly activeCapabilityAbortControllers = new Map<
+		string,
+		AbortController
+	>();
+	private readonly defaultCapabilities: RuntimeCapabilities;
+	private readonly telemetry?: ITelemetryService;
+
+	constructor(
+		options: HubRuntimeHostOptions,
+		clientContext?: { workspaceRoot?: string; cwd?: string },
+	) {
+		this.clientContext = clientContext;
+		this.clientOptions = {
+			authToken: options.authToken,
+			clientType: options.clientType ?? "core-hub-runtime",
+			displayName: options.displayName ?? "core hub runtime",
+			workspaceRoot: clientContext?.workspaceRoot,
+			cwd: clientContext?.cwd,
+		};
+		this.defaultCapabilities =
+			normalizeRuntimeCapabilities(options.capabilities) ?? {};
+		this.telemetry = options.telemetry;
+		this.runtimeAddress = options.url;
+		this.pendingPrompts = {
+			list: (input) => this.requestPendingPromptsList(input),
+			update: (input) => this.requestPendingPromptUpdate(input),
+			delete: (input) => this.requestPendingPromptDelete(input),
+		};
+		this.client = this.createClient(options.url);
+	}
+
+	private createClient(url: string): NodeHubClient {
+		return new NodeHubClient({ ...this.clientOptions, url });
+	}
+
+	private async replaceClient(url: string): Promise<void> {
+		const previous = this.client;
+		this.client = this.createClient(url);
+		this.runtimeAddress = url;
+		await Promise.resolve(previous.dispose()).catch(() => undefined);
+	}
+
+	private async recoverLocalHubStartupDeadlock(
+		error: unknown,
+	): Promise<boolean> {
+		if (!isHubCommandTimeoutError(error, "session.create")) {
+			return false;
+		}
+		const restartedUrl = await restartLocalHubIfIdleAfterStartupTimeout({
+			url: this.client.getUrl(),
+			workspaceRoot: this.clientContext?.workspaceRoot,
+			cwd: this.clientContext?.cwd,
+		}).catch(() => undefined);
+		if (!restartedUrl) {
+			return false;
+		}
+		await this.replaceClient(restartedUrl);
+		return true;
+	}
+
+	private registerPlannedSession(
+		sessionId: string,
+		capabilities: RuntimeCapabilities,
+		clientContributionHandlers: Map<string, ClientContributionHandler>,
+	): void {
+		this.sessionCapabilities.set(sessionId, capabilities);
+		if (clientContributionHandlers.size > 0) {
+			this.sessionClientContributionHandlers.set(
+				sessionId,
+				clientContributionHandlers,
+			);
+		}
+		// The hub may call back into client contributions while handling
+		// `session.create` (for example user_instructions.snapshot during local
+		// runtime bootstrap). Subscribe before sending the command so those
+		// capability.requested events are observed and answered instead of
+		// deadlocking session.create.
+		this.ensureSessionSubscription(sessionId);
+	}
+
+	private cleanupPlannedSession(sessionId: string): void {
+		this.sessionCapabilities.delete(sessionId);
+		this.sessionClientContributionHandlers.delete(sessionId);
+		this.disposeSessionSubscription(sessionId);
+	}
+
+	async connect(): Promise<void> {
+		await this.client.connect();
+	}
+
+	async startSession(input: StartSessionInput): Promise<StartSessionResult> {
+		const capabilities = this.resolveCapabilities(input);
+		const clientContributions = buildClientContributionRegistration(
+			input.localRuntime,
+			capabilities,
+		);
+		const plannedSessionId =
+			input.config.sessionId?.trim() || createSessionId();
+		const sendCreateCommand = () =>
+			this.client.command("session.create", {
+				workspaceRoot: input.config.workspaceRoot?.trim() || input.config.cwd,
+				cwd: input.config.cwd,
+				sessionConfig: toJsonRecord(
+					buildCommandSessionConfig(input, plannedSessionId),
+				),
+				metadata: {
+					...(input.sessionMetadata ?? {}),
+					source: input.source ?? SessionSource.CORE,
+					provider: input.config.providerId,
+					model: input.config.modelId,
+					enableTools: input.config.enableTools,
+					enableSpawn: input.config.enableSpawnAgent,
+					enableTeams: input.config.enableAgentTeams,
+					teamName: input.config.teamName,
+					prompt: input.prompt,
+					interactive: input.interactive === true,
+				},
+				runtimeOptions: {
+					...(clientContributions.manifest.length > 0
+						? { clientContributions: clientContributions.manifest }
+						: {}),
+					...(input.localRuntime?.configExtensions
+						? { configExtensions: input.localRuntime.configExtensions }
+						: {}),
+				},
+				toolPolicies: toJsonRecord(
+					input.toolPolicies as Record<string, unknown> | undefined,
+				),
+				initialMessages: input.initialMessages,
+				...(input.initialCompactionState
+					? { initialCompactionState: input.initialCompactionState }
+					: {}),
+			});
+		this.registerPlannedSession(
+			plannedSessionId,
+			capabilities,
+			clientContributions.handlers,
+		);
+		let reply: Awaited<ReturnType<NodeHubClient["command"]>>;
+		try {
+			reply = await sendCreateCommand();
+		} catch (error) {
+			this.cleanupPlannedSession(plannedSessionId);
+			if (await this.recoverLocalHubStartupDeadlock(error)) {
+				this.registerPlannedSession(
+					plannedSessionId,
+					capabilities,
+					clientContributions.handlers,
+				);
+				try {
+					reply = await sendCreateCommand();
+				} catch (retryError) {
+					this.cleanupPlannedSession(plannedSessionId);
+					throw retryError;
+				}
+			} else {
+				throw error;
+			}
+		}
+		const snapshot = parseCoreSessionSnapshot(reply.payload?.snapshot);
+		const session = reply.payload?.session as HubSessionRecord | undefined;
+		const sessionId = (snapshot?.sessionId ?? session?.sessionId)?.trim();
+		if (!sessionId) {
+			this.cleanupPlannedSession(plannedSessionId);
+			throw new Error("Hub runtime did not return a session id.");
+		}
+		if (sessionId !== plannedSessionId) {
+			this.cleanupPlannedSession(plannedSessionId);
+			this.registerPlannedSession(
+				sessionId,
+				capabilities,
+				clientContributions.handlers,
+			);
+		}
+
+		return {
+			sessionId,
+			manifest: snapshot
+				? buildManifestFromSnapshot(snapshot, input)
+				: buildManifest(sessionId, input, session),
+			manifestPath: "",
+			messagesPath: "",
+			result: undefined,
+		};
+	}
+
+	async restoreSession(
+		input: RestoreSessionInput,
+	): Promise<RestoreSessionResult> {
+		const sessionId = input.sessionId.trim();
+		if (!sessionId) {
+			throw new Error("sessionId is required");
+		}
+		const restoreMessages = input.restore?.messages !== false;
+		if (restoreMessages && !input.start) {
+			throw new Error("start is required when restore.messages is true");
+		}
+		const startConfig = input.start;
+		const capabilities = startConfig
+			? this.resolveCapabilities(startConfig)
+			: undefined;
+		const clientContributions = startConfig
+			? buildClientContributionRegistration(
+					startConfig.localRuntime,
+					capabilities ?? {},
+				)
+			: {
+					manifest: [],
+					handlers: new Map<string, ClientContributionHandler>(),
+				};
+		let plannedSessionId: string | undefined;
+		let startSessionConfig: Record<string, unknown> | undefined;
+		if (startConfig) {
+			plannedSessionId =
+				startConfig.config.sessionId?.trim() || createSessionId();
+			startSessionConfig = buildCommandSessionConfig(
+				startConfig,
+				plannedSessionId,
+			);
+		}
+		if (plannedSessionId && capabilities) {
+			this.sessionCapabilities.set(plannedSessionId, capabilities);
+		}
+		if (plannedSessionId && clientContributions.handlers.size > 0) {
+			this.sessionClientContributionHandlers.set(
+				plannedSessionId,
+				clientContributions.handlers,
+			);
+			this.ensureSessionSubscription(plannedSessionId);
+		}
+		let reply: Awaited<ReturnType<NodeHubClient["command"]>>;
+		try {
+			reply = await this.client.command(
+				"session.restore",
+				{
+					sessionId,
+					checkpointRunCount: input.checkpointRunCount,
+					restore: input.restore,
+					...(startConfig
+						? {
+								workspaceRoot:
+									startConfig.config.workspaceRoot?.trim() ||
+									startConfig.config.cwd,
+								cwd: startConfig.config.cwd ?? input.cwd,
+								sessionConfig: toJsonRecord(startSessionConfig),
+								metadata: {
+									...(startConfig.sessionMetadata ?? {}),
+									source: startConfig.source ?? SessionSource.CORE,
+									provider: startConfig.config.providerId,
+									model: startConfig.config.modelId,
+									enableTools: startConfig.config.enableTools,
+									enableSpawn: startConfig.config.enableSpawnAgent,
+									enableTeams: startConfig.config.enableAgentTeams,
+									teamName: startConfig.config.teamName,
+									prompt: startConfig.prompt,
+									interactive: startConfig.interactive === true,
+								},
+								runtimeOptions: {
+									...(clientContributions.manifest.length > 0
+										? { clientContributions: clientContributions.manifest }
+										: {}),
+									...(startConfig.localRuntime?.configExtensions
+										? {
+												configExtensions:
+													startConfig.localRuntime.configExtensions,
+											}
+										: {}),
+								},
+								toolPolicies: toJsonRecord(
+									startConfig.toolPolicies as
+										| Record<string, unknown>
+										| undefined,
+								),
+								...(startConfig.initialCompactionState
+									? {
+											initialCompactionState:
+												startConfig.initialCompactionState,
+										}
+									: {}),
+							}
+						: {}),
+				},
+				sessionId,
+			);
+		} catch (error) {
+			if (plannedSessionId) {
+				this.sessionCapabilities.delete(plannedSessionId);
+				this.sessionClientContributionHandlers.delete(plannedSessionId);
+				this.disposeSessionSubscription(plannedSessionId);
+			}
+			throw error;
+		}
+		if (!reply.ok) {
+			const errorMsg =
+				typeof reply.payload?.error === "string"
+					? reply.payload.error
+					: "session.restore failed";
+			if (plannedSessionId) {
+				this.sessionCapabilities.delete(plannedSessionId);
+				this.sessionClientContributionHandlers.delete(plannedSessionId);
+				this.disposeSessionSubscription(plannedSessionId);
+			}
+			throw new Error(errorMsg);
+		}
+		const snapshot = parseCoreSessionSnapshot(reply.payload?.snapshot);
+		const session = reply.payload?.session as HubSessionRecord | undefined;
+		const newSessionId = (snapshot?.sessionId ?? session?.sessionId)?.trim();
+		if (restoreMessages && !newSessionId) {
+			if (plannedSessionId) {
+				this.sessionCapabilities.delete(plannedSessionId);
+				this.sessionClientContributionHandlers.delete(plannedSessionId);
+				this.disposeSessionSubscription(plannedSessionId);
+			}
+			throw new Error("Hub checkpoint restore returned no session id");
+		}
+		if (newSessionId && plannedSessionId && newSessionId !== plannedSessionId) {
+			this.sessionCapabilities.delete(plannedSessionId);
+			this.sessionClientContributionHandlers.delete(plannedSessionId);
+			this.disposeSessionSubscription(plannedSessionId);
+		}
+		if (newSessionId && capabilities) {
+			this.sessionCapabilities.set(newSessionId, capabilities);
+		}
+		if (newSessionId && clientContributions.handlers.size > 0) {
+			this.sessionClientContributionHandlers.set(
+				newSessionId,
+				clientContributions.handlers,
+			);
+		}
+		if (newSessionId) {
+			this.ensureSessionSubscription(newSessionId);
+		}
+		const messages = Array.isArray(reply.payload?.messages)
+			? (reply.payload.messages as import("@cline/llms").Message[])
+			: undefined;
+		const checkpoint = reply.payload?.checkpoint as
+			| RestoreSessionResult["checkpoint"]
+			| undefined;
+		if (!checkpoint) {
+			throw new Error("Hub checkpoint restore returned no checkpoint");
+		}
+		return {
+			sessionId: newSessionId,
+			startResult: newSessionId
+				? {
+						sessionId: newSessionId,
+						manifest: snapshot
+							? buildManifestFromSnapshot(
+									snapshot,
+									startConfig ?? ({} as StartSessionInput),
+								)
+							: buildManifest(
+									newSessionId,
+									startConfig ?? ({} as StartSessionInput),
+									session,
+								),
+						manifestPath: "",
+						messagesPath: "",
+						result: undefined,
+					}
+				: undefined,
+			messages,
+			checkpoint,
+		};
+	}
+
+	async runTurn(input: SendSessionInput): Promise<AgentResult | undefined> {
+		this.ensureSessionSubscription(input.sessionId);
+		const reply = await this.client.command(
+			"run.start",
+			{
+				sessionId: input.sessionId,
+				input: input.prompt,
+				mode: input.mode,
+				attachments:
+					(input.userImages?.length ?? 0) > 0 ||
+					(input.userFiles?.length ?? 0) > 0
+						? {
+								...(input.userImages?.length
+									? { userImages: input.userImages }
+									: {}),
+								...(input.userFiles?.length
+									? {
+											userFiles: input.userFiles,
+										}
+									: {}),
+							}
+						: undefined,
+				delivery: input.delivery,
+				timeoutMs: input.timeoutMs,
+			},
+			input.sessionId,
+			{ timeoutMs: null },
+		);
+		return reply.payload?.result as AgentResult | undefined;
+	}
+
+	private async requestPendingPromptsList(
+		input: Parameters<PendingPromptsServiceApi["list"]>[0],
+	): Promise<SessionPendingPrompt[]> {
+		this.ensureSessionSubscription(input.sessionId);
+		const reply = await this.client.command(
+			"session.pending_prompts",
+			{ sessionId: input.sessionId },
+			input.sessionId,
+		);
+		return Array.isArray(reply.payload?.prompts)
+			? (reply.payload.prompts as SessionPendingPrompt[])
+			: [];
+	}
+
+	private async requestPendingPromptUpdate(
+		input: Parameters<PendingPromptsServiceApi["update"]>[0],
+	): Promise<PendingPromptMutationResult> {
+		this.ensureSessionSubscription(input.sessionId);
+		const reply = await this.client.command(
+			"session.update_pending_prompt",
+			{ ...input },
+			input.sessionId,
+		);
+		return {
+			sessionId: input.sessionId,
+			prompts: Array.isArray(reply.payload?.prompts)
+				? (reply.payload.prompts as SessionPendingPrompt[])
+				: [],
+			prompt: reply.payload?.prompt as SessionPendingPrompt | undefined,
+			updated: reply.payload?.updated === true,
+		};
+	}
+
+	private async requestPendingPromptDelete(
+		input: Parameters<PendingPromptsServiceApi["delete"]>[0],
+	): Promise<PendingPromptMutationResult> {
+		this.ensureSessionSubscription(input.sessionId);
+		const reply = await this.client.command(
+			"session.remove_pending_prompt",
+			{ ...input },
+			input.sessionId,
+		);
+		return {
+			sessionId: input.sessionId,
+			prompts: Array.isArray(reply.payload?.prompts)
+				? (reply.payload.prompts as SessionPendingPrompt[])
+				: [],
+			prompt: reply.payload?.prompt as SessionPendingPrompt | undefined,
+			removed: reply.payload?.removed === true,
+		};
+	}
+
+	async getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionUsageSummary | undefined> {
+		const reply = await this.client.command(
+			"session.get",
+			{ includeSnapshot: true },
+			sessionId,
+		);
+		const snapshot = parseCoreSessionSnapshot(reply.payload?.snapshot);
+		if (snapshot) {
+			const usage = snapshot.usage ? { ...snapshot.usage } : undefined;
+			const aggregateUsage = snapshot.aggregateUsage
+				? { ...snapshot.aggregateUsage }
+				: undefined;
+			return usage || aggregateUsage ? { usage, aggregateUsage } : undefined;
+		}
+		const session = reply.payload?.session as HubSessionRecord | undefined;
+		const usage = accumulatedUsageFromMetrics(session?.usage);
+		const aggregateUsage = accumulatedUsageFromMetrics(session?.aggregateUsage);
+		return usage || aggregateUsage ? { usage, aggregateUsage } : undefined;
+	}
+
+	async abort(sessionId: string, reason?: unknown): Promise<void> {
+		await this.client.command(
+			"run.abort",
+			{ sessionId, reason: messageFromUnknown(reason) },
+			sessionId,
+		);
+	}
+
+	async stopSession(sessionId: string): Promise<void> {
+		this.sessionCapabilities.delete(sessionId);
+		this.disposeSessionSubscription(sessionId);
+		await this.client.command("session.detach", { sessionId }, sessionId);
+	}
+
+	async dispose(): Promise<void> {
+		for (const [sessionId, unsubscribe] of this.sessionSubscriptions) {
+			unsubscribe();
+			try {
+				await this.client.command("session.detach", { sessionId }, sessionId);
+			} catch {
+				// Best-effort detach during shutdown.
+			}
+		}
+		this.sessionSubscriptions.clear();
+		this.sessionCapabilities.clear();
+		this.agentDoneEmittedForCurrentRunBySession.clear();
+		for (const controller of this.activeCapabilityAbortControllers.values()) {
+			controller.abort("Hub runtime host disposed.");
+		}
+		this.activeCapabilityAbortControllers.clear();
+		await this.client.dispose();
+	}
+
+	async getSession(sessionId: string): Promise<SessionRecord | undefined> {
+		let reply: Awaited<ReturnType<NodeHubClient["command"]>>;
+		try {
+			reply = await this.client.command("session.get", undefined, sessionId);
+		} catch (error) {
+			if (isSessionNotFoundError(error)) {
+				return undefined;
+			}
+			throw error;
+		}
+		return sessionRecordFromPayload(reply.payload);
+	}
+
+	async listSessions(limit = 100): Promise<SessionRecord[]> {
+		const reply = await this.client.command("session.list", { limit });
+		const snapshots = Array.isArray(reply.payload?.snapshots)
+			? reply.payload.snapshots.flatMap((value) => {
+					const snapshot = parseCoreSessionSnapshot(value);
+					return snapshot ? [coreSessionSnapshotToRecord(snapshot)] : [];
+				})
+			: [];
+		if (snapshots.length > 0) {
+			return snapshots;
+		}
+		const sessions =
+			(reply.payload?.sessions as HubSessionRecord[] | undefined) ?? [];
+		return sessions.map(toSessionRecord);
+	}
+
+	async listSettings(
+		input?: CoreSettingsListInput,
+	): Promise<CoreSettingsSnapshot> {
+		const reply = await this.client.command(
+			"settings.list",
+			serializeSettingsInput(input),
+		);
+		if (!reply.ok) {
+			throw new Error(hubReplyErrorMessage(reply, "settings.list"));
+		}
+		return reply.payload?.snapshot as CoreSettingsSnapshot;
+	}
+
+	async toggleSetting(
+		input: CoreSettingsToggleInput,
+	): Promise<CoreSettingsMutationResult> {
+		const reply = await this.client.command(
+			"settings.toggle",
+			serializeSettingsInput(input),
+		);
+		if (!reply.ok) {
+			throw new Error(hubReplyErrorMessage(reply, "settings.toggle"));
+		}
+		return {
+			snapshot: reply.payload?.snapshot as CoreSettingsSnapshot,
+			changedTypes: Array.isArray(reply.payload?.changedTypes)
+				? (reply.payload
+						.changedTypes as CoreSettingsMutationResult["changedTypes"])
+				: [],
+		};
+	}
+
+	async deleteSession(sessionId: string): Promise<boolean> {
+		this.sessionCapabilities.delete(sessionId);
+		this.disposeSessionSubscription(sessionId);
+		const reply = await this.client.command("session.delete", {
+			sessionId,
+		});
+		return reply.payload?.deleted === true;
+	}
+
+	async updateSession(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }> {
+		const metadata: Record<string, unknown> = {
+			...(updates.metadata ?? {}),
+		};
+		if (typeof updates.prompt === "string") {
+			metadata.prompt = updates.prompt;
+		}
+		if (typeof updates.title === "string") {
+			metadata.title = updates.title;
+		}
+		const reply = await this.client.command("session.update", {
+			sessionId,
+			metadata,
+		});
+		return { updated: reply.ok };
+	}
+
+	async updateSessionConnection(
+		sessionId: string,
+		updates: SessionConnectionUpdate,
+	): Promise<void> {
+		const target = sessionId.trim();
+		if (!target) {
+			return;
+		}
+		const reply = await this.client.command(
+			"session.update_connection",
+			{
+				sessionId: target,
+				updates,
+			},
+			target,
+		);
+		if (!reply.ok) {
+			throw new Error(hubReplyErrorMessage(reply, "session.update_connection"));
+		}
+	}
+
+	async updateSessionCompactionState(
+		sessionId: string,
+		state: SessionCompactionState,
+	): Promise<{ updated: boolean }> {
+		const target = sessionId.trim();
+		if (!target) return { updated: false };
+		const reply = await this.client.command(
+			"session.compaction.update",
+			{ sessionId: target, state },
+			target,
+		);
+		if (!reply.ok) {
+			captureSdkError(this.telemetry, {
+				component: "core",
+				operation: "hub.runtime_host.update_session_compaction_state",
+				error: new Error(
+					hubReplyErrorMessage(reply, "session.compaction.update"),
+				),
+				severity: "warn",
+				handled: true,
+				context: {
+					command: "session.compaction.update",
+					sessionId: target,
+					errorCode: reply.error?.code,
+				},
+			});
+		}
+		return {
+			updated: reply.ok && reply.payload?.updated === true,
+		};
+	}
+
+	async readSessionCompactionState(
+		sessionId: string,
+	): Promise<SessionCompactionState | undefined> {
+		const target = sessionId.trim();
+		if (!target) return undefined;
+		const reply = await this.client.command(
+			"session.compaction.get",
+			{ sessionId: target },
+			target,
+		);
+		if (!reply.ok) {
+			throw new Error(hubReplyErrorMessage(reply, "session.compaction.get"));
+		}
+		return parseSessionCompactionState(reply.payload?.state);
+	}
+
+	async readSessionMessages(
+		sessionId: string,
+	): Promise<import("@cline/llms").Message[]> {
+		const target = sessionId.trim();
+		if (!target) {
+			return [];
+		}
+		const reply = await this.client.command(
+			"session.messages",
+			{ sessionId: target },
+			target,
+		);
+		if (!reply.ok) {
+			captureSdkError(this.telemetry, {
+				component: "core",
+				operation: "hub.runtime_host.read_session_messages",
+				error: new Error(hubReplyErrorMessage(reply, "session.messages")),
+				severity: reply.error?.code === "session_not_found" ? "warn" : "error",
+				handled: true,
+				context: {
+					command: "session.messages",
+					sessionId: target,
+					errorCode: reply.error?.code,
+					runtimeAddress: this.runtimeAddress,
+				},
+			});
+			throw new Error(hubReplyErrorMessage(reply, "session.messages"));
+		}
+		const messages = reply.payload?.messages;
+		return Array.isArray(messages)
+			? (messages as import("@cline/llms").Message[])
+			: [];
+	}
+
+	async dispatchHookEvent(_payload: HookEventPayload): Promise<void> {
+		await this.client.command("session.hook", { payload: _payload });
+	}
+
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		return this.events.subscribe(listener, options);
+	}
+
+	private ensureSessionSubscription(sessionId: string): void {
+		const target = sessionId.trim();
+		if (!target || this.sessionSubscriptions.has(target)) {
+			return;
+		}
+		const subscription = this.client.subscribe(
+			(event) => {
+				this.handleHubEvent(event);
+			},
+			{ sessionId: target },
+		);
+		this.sessionSubscriptions.set(
+			target,
+			typeof subscription === "function" ? subscription : () => {},
+		);
+	}
+
+	private disposeSessionSubscription(sessionId: string): void {
+		const target = sessionId.trim();
+		if (!target) {
+			return;
+		}
+		this.sessionSubscriptions.get(target)?.();
+		this.sessionSubscriptions.delete(target);
+		this.agentDoneEmittedForCurrentRunBySession.delete(target);
+	}
+
+	private resolveCapabilities(input: StartSessionInput): RuntimeCapabilities {
+		return (
+			normalizeRuntimeCapabilities(
+				this.defaultCapabilities,
+				input.capabilities,
+			) ?? {}
+		);
+	}
+
+	private emitToolCallContentStart(input: {
+		sessionId: string;
+		toolCallId?: string;
+		toolName?: string;
+		toolInput?: unknown;
+	}): void {
+		this.events.emit({
+			type: "agent_event",
+			payload: {
+				sessionId: input.sessionId,
+				event: {
+					type: "content_start",
+					contentType: "tool",
+					toolCallId: input.toolCallId,
+					toolName: input.toolName,
+					input: input.toolInput,
+				},
+			},
+		});
+	}
+
+	private emitAgentDoneIfNeeded(input: {
+		sessionId: string;
+		payload: Record<string, unknown> | undefined;
+	}): void {
+		const alreadyEmitted = this.agentDoneEmittedForCurrentRunBySession.has(
+			input.sessionId,
+		);
+		if (alreadyEmitted) {
+			return;
+		}
+		this.agentDoneEmittedForCurrentRunBySession.add(input.sessionId);
+		this.events.emit({
+			type: "agent_event",
+			payload: {
+				sessionId: input.sessionId,
+				event: doneEventFromPayload(input.payload),
+			},
+		});
+	}
+
+	private handleHubEvent(event: HubEventEnvelope): void {
+		const sessionId = event.sessionId?.trim();
+		if (event.event === "capability.requested") {
+			void this.handleCapabilityRequest(event).catch((error) => {
+				this.captureDetachedHubEventError(
+					"hub.runtime_host.capability_request",
+					error,
+					event,
+				);
+			});
+			return;
+		}
+		if (event.event === "capability.resolved") {
+			this.handleCapabilityResolved(event);
+			return;
+		}
+		if (event.event === "approval.requested") {
+			void this.handleApprovalRequested(event).catch((error) => {
+				this.captureDetachedHubEventError(
+					"hub.runtime_host.approval_request",
+					error,
+					event,
+				);
+			});
+			return;
+		}
+		if (!sessionId) {
+			return;
+		}
+
+		switch (event.event) {
+			case "run.started": {
+				this.agentDoneEmittedForCurrentRunBySession.delete(sessionId);
+				const snapshot = parseCoreSessionSnapshot(event.payload?.snapshot);
+				const session = event.payload?.session as HubSessionRecord | undefined;
+				if (snapshot) {
+					this.events.emit({
+						type: "session_snapshot",
+						payload: { sessionId, snapshot },
+					});
+				}
+				this.events.emit({
+					type: "status",
+					payload: {
+						sessionId,
+						status: session?.status ?? "running",
+					},
+				});
+				return;
+			}
+			case "iteration.started": {
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "iteration_start",
+							iteration:
+								typeof event.payload?.iteration === "number"
+									? event.payload.iteration
+									: 0,
+						},
+					},
+				});
+				return;
+			}
+			case "iteration.finished": {
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "iteration_end",
+							iteration:
+								typeof event.payload?.iteration === "number"
+									? event.payload.iteration
+									: 0,
+							hadToolCalls: event.payload?.hadToolCalls === true,
+							toolCallCount:
+								typeof event.payload?.toolCallCount === "number"
+									? event.payload.toolCallCount
+									: 0,
+						},
+					},
+				});
+				return;
+			}
+			case "assistant.delta": {
+				const text =
+					typeof event.payload?.text === "string" ? event.payload.text : "";
+				if (!text) {
+					return;
+				}
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "content_start",
+							contentType: "text",
+							text,
+						},
+					},
+				});
+				return;
+			}
+			case "assistant.finished": {
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "content_end",
+							contentType: "text",
+							text:
+								typeof event.payload?.text === "string"
+									? event.payload.text
+									: undefined,
+						},
+					},
+				});
+				return;
+			}
+			case "reasoning.delta": {
+				const text =
+					typeof event.payload?.text === "string" ? event.payload.text : "";
+				const redacted = event.payload?.redacted === true;
+				if (!text && !redacted) {
+					return;
+				}
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "content_start",
+							contentType: "reasoning",
+							reasoning: text,
+							redacted,
+						},
+					},
+				});
+				return;
+			}
+			case "reasoning.finished": {
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "content_end",
+							contentType: "reasoning",
+							reasoning:
+								typeof event.payload?.reasoning === "string"
+									? event.payload.reasoning
+									: undefined,
+						},
+					},
+				});
+				return;
+			}
+			case "agent.done": {
+				this.emitAgentDoneIfNeeded({
+					sessionId,
+					payload: event.payload,
+				});
+				return;
+			}
+			case "usage.updated": {
+				const usage = usageEventFromPayload(event.payload);
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: usage.event,
+						teamAgentId: usage.teamAgentId,
+						teamRole: usage.teamRole,
+					},
+				});
+				return;
+			}
+			case "tool.started": {
+				const toolCallId =
+					typeof event.payload?.toolCallId === "string"
+						? event.payload.toolCallId
+						: undefined;
+				if (toolCallId && this.pendingApprovalToolCallIds.delete(toolCallId)) {
+					return;
+				}
+				this.emitToolCallContentStart({
+					sessionId,
+					toolCallId,
+					toolName:
+						typeof event.payload?.toolName === "string"
+							? event.payload.toolName
+							: undefined,
+					toolInput: event.payload?.input,
+				});
+				return;
+			}
+			case "tool.finished": {
+				const toolCallId =
+					typeof event.payload?.toolCallId === "string"
+						? event.payload.toolCallId
+						: undefined;
+				if (toolCallId) {
+					this.pendingApprovalToolCallIds.delete(toolCallId);
+				}
+				this.events.emit({
+					type: "agent_event",
+					payload: {
+						sessionId,
+						event: {
+							type: "content_end",
+							contentType: "tool",
+							toolCallId,
+							toolName:
+								typeof event.payload?.toolName === "string"
+									? event.payload.toolName
+									: undefined,
+							output: event.payload?.output,
+							error:
+								typeof event.payload?.error === "string"
+									? event.payload.error
+									: undefined,
+						},
+					},
+				});
+				return;
+			}
+			case "session.created":
+			case "session.updated":
+			case "session.attached":
+			case "session.detached": {
+				const snapshot = parseCoreSessionSnapshot(event.payload?.snapshot);
+				const session = event.payload?.session as HubSessionRecord | undefined;
+				if (snapshot) {
+					this.events.emit({
+						type: "session_snapshot",
+						payload: { sessionId, snapshot },
+					});
+				}
+				this.events.emit({
+					type: "status",
+					payload: {
+						sessionId,
+						status: session?.status ?? "running",
+					},
+				});
+				return;
+			}
+			case "session.pending_prompts": {
+				this.events.emit({
+					type: "pending_prompts",
+					payload: {
+						sessionId,
+						prompts: Array.isArray(event.payload?.prompts)
+							? (event.payload.prompts as SessionPendingPrompt[])
+							: [],
+					},
+				});
+				return;
+			}
+			case "session.pending_prompt_submitted": {
+				const prompt = event.payload?.prompt as
+					| SessionPendingPrompt
+					| undefined;
+				if (!prompt) {
+					return;
+				}
+				this.events.emit({
+					type: "pending_prompt_submitted",
+					payload: {
+						sessionId,
+						id: prompt.id,
+						prompt: prompt.prompt,
+						delivery: prompt.delivery,
+						attachmentCount: prompt.attachmentCount,
+						userImages: prompt.userImages,
+						userFiles: prompt.userFiles,
+					},
+				});
+				return;
+			}
+			case "run.completed":
+			case "run.failed":
+			case "run.aborted": {
+				const snapshot = parseCoreSessionSnapshot(event.payload?.snapshot);
+				const reason =
+					typeof event.payload?.reason === "string"
+						? event.payload.reason
+						: event.event === "run.aborted"
+							? "aborted"
+							: event.event === "run.failed"
+								? "error"
+								: "completed";
+				this.emitAgentDoneIfNeeded({
+					sessionId,
+					payload: {
+						...event.payload,
+						reason,
+					},
+				});
+				if (
+					snapshot?.interactive === true &&
+					isNonTerminalSessionStatus(snapshot.status)
+				) {
+					return;
+				}
+				this.events.emit({
+					type: "ended",
+					payload: {
+						sessionId,
+						reason,
+						ts: event.timestamp ?? Date.now(),
+					},
+				});
+				return;
+			}
+			default:
+				return;
+		}
+	}
+
+	private captureDetachedHubEventError(
+		operation: string,
+		error: unknown,
+		event: HubEventEnvelope,
+	): void {
+		try {
+			captureSdkError(this.telemetry, {
+				component: "core",
+				operation,
+				error,
+				severity: "warn",
+				handled: true,
+				context: {
+					event: event.event,
+					sessionId: event.sessionId,
+					runtimeAddress: this.runtimeAddress,
+				},
+			});
+		} catch {
+			// Telemetry must not rethrow from detached hub event handlers.
+		}
+	}
+
+	private async handleCapabilityRequest(
+		event: HubEventEnvelope,
+	): Promise<void> {
+		const sessionId = event.sessionId?.trim();
+		if (!sessionId) {
+			return;
+		}
+		const targetClientId =
+			typeof event.payload?.targetClientId === "string"
+				? event.payload.targetClientId
+				: undefined;
+		if (targetClientId && targetClientId !== this.client.getClientId()) {
+			return;
+		}
+		const requestId =
+			typeof event.payload?.requestId === "string"
+				? event.payload.requestId
+				: "";
+		const capabilityName =
+			typeof event.payload?.capabilityName === "string"
+				? event.payload.capabilityName
+				: "";
+		if (!requestId) {
+			return;
+		}
+		const handler = this.sessionClientContributionHandlers
+			.get(sessionId)
+			?.get(capabilityName);
+		if (!handler) {
+			await this.client
+				.command(
+					"capability.respond",
+					{
+						requestId,
+						ok: false,
+						error: `No client contribution handler registered for capability ${capabilityName} in session ${sessionId}.`,
+					},
+					sessionId,
+				)
+				.catch(() => {});
+			return;
+		}
+		const payload =
+			event.payload?.payload &&
+			typeof event.payload.payload === "object" &&
+			!Array.isArray(event.payload.payload)
+				? (event.payload.payload as Record<string, unknown>)
+				: {};
+		const abortController = new AbortController();
+		this.activeCapabilityAbortControllers.set(requestId, abortController);
+		const progress = (progressPayload: Record<string, unknown>): void => {
+			void this.client
+				.command(
+					"capability.progress",
+					{
+						requestId,
+						payload: progressPayload,
+					},
+					sessionId,
+				)
+				.catch((error) => {
+					this.captureDetachedHubEventError(
+						"hub.runtime_host.capability_progress",
+						error,
+						event,
+					);
+				});
+		};
+		try {
+			const responsePayload = await handler({
+				payload,
+				abortSignal: abortController.signal,
+				progress,
+			});
+			if (abortController.signal.aborted) {
+				return;
+			}
+			await this.client.command(
+				"capability.respond",
+				{
+					requestId,
+					ok: true,
+					payload: responsePayload,
+				},
+				sessionId,
+			);
+		} catch (error) {
+			if (abortController.signal.aborted) {
+				return;
+			}
+			await this.client.command(
+				"capability.respond",
+				{
+					requestId,
+					ok: false,
+					error: error instanceof Error ? error.message : String(error),
+				},
+				sessionId,
+			);
+		} finally {
+			this.activeCapabilityAbortControllers.delete(requestId);
+		}
+	}
+
+	private handleCapabilityResolved(event: HubEventEnvelope): void {
+		if (event.payload?.cancelled !== true) {
+			return;
+		}
+		const requestId =
+			typeof event.payload.requestId === "string"
+				? event.payload.requestId.trim()
+				: "";
+		if (!requestId) {
+			return;
+		}
+		const controller = this.activeCapabilityAbortControllers.get(requestId);
+		if (!controller) {
+			return;
+		}
+		controller.abort(abortReasonMessage(event.payload.error));
+	}
+
+	private async handleApprovalRequested(
+		event: HubEventEnvelope,
+	): Promise<void> {
+		const sessionId = event.sessionId?.trim();
+		if (!sessionId) {
+			return;
+		}
+		const requestToolApproval =
+			this.sessionCapabilities.get(sessionId)?.requestToolApproval ??
+			this.defaultCapabilities.requestToolApproval;
+		if (!requestToolApproval) {
+			return;
+		}
+		const approvalId =
+			typeof event.payload?.approvalId === "string"
+				? event.payload.approvalId.trim()
+				: "";
+		const toolCallId =
+			typeof event.payload?.toolCallId === "string"
+				? event.payload.toolCallId
+				: "";
+		const toolName =
+			typeof event.payload?.toolName === "string" ? event.payload.toolName : "";
+		if (!approvalId || !toolCallId || !toolName) {
+			return;
+		}
+		const policy =
+			event.payload?.policy &&
+			typeof event.payload.policy === "object" &&
+			!Array.isArray(event.payload.policy)
+				? (event.payload.policy as ToolApprovalRequest["policy"])
+				: { autoApprove: false };
+		const input = parseApprovalInput(event.payload?.inputJson);
+		this.pendingApprovalToolCallIds.add(toolCallId);
+		this.emitToolCallContentStart({
+			sessionId,
+			toolCallId,
+			toolName,
+			toolInput: input,
+		});
+		const result = await Promise.resolve(
+			requestToolApproval({
+				sessionId,
+				agentId:
+					typeof event.payload?.agentId === "string"
+						? event.payload.agentId
+						: "",
+				conversationId:
+					typeof event.payload?.conversationId === "string"
+						? event.payload.conversationId
+						: sessionId,
+				iteration:
+					typeof event.payload?.iteration === "number"
+						? event.payload.iteration
+						: 0,
+				toolCallId,
+				toolName,
+				input,
+				policy,
+			}),
+		).catch((error) => ({
+			approved: false,
+			reason:
+				error instanceof Error
+					? error.message
+					: `Tool approval request failed: ${String(error)}`,
+		}));
+		await this.client
+			.command(
+				"approval.respond",
+				{
+					approvalId,
+					approved: result.approved,
+					reason: result.reason,
+				},
+				sessionId,
+			)
+			.catch(() => {});
+	}
+}
diff --git a/sdk/packages/core/src/hub/runtime-host/remote-runtime-host.ts b/sdk/packages/core/src/hub/runtime-host/remote-runtime-host.ts
new file mode 100644
index 0000000..25e8e43
--- /dev/null
+++ b/sdk/packages/core/src/hub/runtime-host/remote-runtime-host.ts
@@ -0,0 +1,27 @@
+import { normalizeHubWebSocketUrl } from "../client";
+import { HubRuntimeHost, type HubRuntimeHostOptions } from "./hub-runtime-host";
+
+export interface RemoteRuntimeHostOptions
+	extends Omit<HubRuntimeHostOptions, "url"> {
+	endpoint: string;
+	workspaceRoot?: string;
+	cwd?: string;
+}
+
+export class RemoteRuntimeHost extends HubRuntimeHost {
+	constructor(options: RemoteRuntimeHostOptions) {
+		super(
+			{
+				url: normalizeHubWebSocketUrl(options.endpoint),
+				authToken: options.authToken,
+				clientType: options.clientType ?? "core-remote-runtime",
+				displayName: options.displayName ?? "core remote runtime",
+				capabilities: options.capabilities,
+			},
+			{
+				workspaceRoot: options.workspaceRoot,
+				cwd: options.cwd,
+			},
+		);
+	}
+}
diff --git a/sdk/packages/core/src/hub/server/boundary.test.ts b/sdk/packages/core/src/hub/server/boundary.test.ts
new file mode 100644
index 0000000..512631b
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/boundary.test.ts
@@ -0,0 +1,1521 @@
+import type { AgentToolContext, HubEventEnvelope } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import {
+	SessionNotFoundError,
+	type StartSessionInput,
+	type StartSessionResult,
+} from "../../runtime/host/runtime-host";
+import { createSessionCompactionState } from "../../session/models/session-compaction";
+import { createLocalHubScheduleRuntimeHandlers } from "../daemon/runtime-handlers";
+import { HubServerTransport } from "../server";
+import {
+	handleApprovalRespond,
+	requestToolApproval,
+} from "./handlers/approval-handlers";
+import {
+	ensureSessionParticipant,
+	ensureSessionState,
+	type HubTransportContext,
+} from "./handlers/context";
+import { projectSessionEvent } from "./handlers/session-event-projector";
+
+describe("HubServerTransport boundaries", () => {
+	function createTransport(options: Record<string, unknown> = {}) {
+		const { sessionHost: sessionHostOverride, ...transportOptions } = options;
+		return new HubServerTransport({
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			scheduleOptions: { dbPath: ":memory:" },
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockResolvedValue({
+					sessionId: "session-1",
+					status: "completed",
+					startedAt: new Date(0).toISOString(),
+					updatedAt: new Date(0).toISOString(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				}),
+				getAccumulatedUsage: vi.fn().mockResolvedValue(undefined),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages: vi.fn(),
+				...((sessionHostOverride as Record<string, unknown> | undefined) ?? {}),
+			} as never,
+			...transportOptions,
+		});
+	}
+
+	function getContext(transport: HubServerTransport): HubTransportContext {
+		return (transport as unknown as { ctx: HubTransportContext }).ctx;
+	}
+
+	it("continues publishing when one listener throws", () => {
+		const transport = createTransport();
+		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+		const delivered: string[] = [];
+
+		try {
+			transport.subscribe("bad", () => {
+				throw new Error("listener boom");
+			});
+			transport.subscribe("good", (event) => {
+				delivered.push(event.event);
+			});
+
+			(
+				transport as unknown as {
+					publish: (event: {
+						event: string;
+						timestamp: number;
+						version: "v1";
+						eventId: string;
+					}) => void;
+				}
+			).publish({
+				version: "v1",
+				event: "ui.notify",
+				eventId: "evt_1",
+				timestamp: Date.now(),
+			});
+
+			expect(delivered).toEqual(["ui.notify"]);
+			const logged = String(errorSpy.mock.calls[0]?.[0] ?? "");
+			expect(logged.startsWith("[hub] ")).toBe(true);
+			const payload = JSON.parse(logged.slice("[hub] ".length));
+			expect(payload).toMatchObject({
+				level: "error",
+				component: "hub",
+				message: "listener threw while publishing ui.notify",
+			});
+			expect(payload.error).toContain("listener boom");
+		} finally {
+			errorSpy.mockRestore();
+		}
+	});
+
+	it("denies non-interactive approval requests immediately", async () => {
+		const transport = createTransport();
+		const ctx = getContext(transport);
+		ensureSessionState(ctx, "session-1", "client-1", "creator", {
+			interactive: false,
+		});
+
+		const result = await requestToolApproval(ctx, {
+			sessionId: "session-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 1,
+			toolCallId: "call-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+
+		expect(result).toEqual({
+			approved: false,
+			reason:
+				"Tool approval requires an interactive session, but this session is non-interactive.",
+		});
+	});
+
+	it("serves session messages from the hub-owned session host", async () => {
+		const messages = [
+			{
+				role: "user",
+				content: [{ type: "text", text: "created elsewhere" }],
+			},
+		];
+		const readMessages = vi.fn().mockResolvedValue(messages);
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockResolvedValue({
+					sessionId: "session-1",
+					source: "cli",
+					pid: 123,
+					startedAt: new Date(0).toISOString(),
+					status: "completed",
+					interactive: false,
+					provider: "cline",
+					model: "test-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					enableTools: true,
+					enableSpawn: true,
+					enableTeams: false,
+					updatedAt: new Date(0).toISOString(),
+				}),
+				getAccumulatedUsage: vi.fn().mockResolvedValue(undefined),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages: readMessages,
+			} as never,
+		});
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-1",
+			command: "session.messages",
+			sessionId: "session-1",
+		});
+
+		expect(readMessages).toHaveBeenCalledWith("session-1");
+		expect(reply).toMatchObject({
+			version: "v1",
+			requestId: "req-1",
+			ok: true,
+			payload: { sessionId: "session-1", messages },
+		});
+	});
+
+	it("includes accumulated usage on session.get", async () => {
+		const usage = {
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+			totalCost: 0.11,
+		};
+		const aggregateUsage = {
+			inputTokens: 17,
+			outputTokens: 8,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 3,
+			totalCost: 0.23,
+		};
+		const getAccumulatedUsage = vi
+			.fn()
+			.mockResolvedValue({ usage, aggregateUsage });
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockResolvedValue({
+					sessionId: "session-1",
+					source: "cli",
+					pid: 123,
+					startedAt: new Date(0).toISOString(),
+					status: "completed",
+					interactive: false,
+					provider: "cline",
+					model: "test-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					enableTools: true,
+					enableSpawn: true,
+					enableTeams: true,
+					updatedAt: new Date(0).toISOString(),
+				}),
+				getAccumulatedUsage,
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages: vi.fn(),
+			} as never,
+		});
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-usage",
+			command: "session.get",
+			sessionId: "session-1",
+		});
+
+		expect(getAccumulatedUsage).toHaveBeenCalledWith("session-1");
+		expect(reply).toMatchObject({
+			version: "v1",
+			requestId: "req-usage",
+			ok: true,
+			payload: {
+				session: {
+					sessionId: "session-1",
+					usage,
+					aggregateUsage,
+				},
+			},
+		});
+	});
+
+	it("returns session_not_found when session messages are requested for an unknown session", async () => {
+		const readMessages = vi.fn().mockResolvedValue([]);
+		const telemetry = { capture: vi.fn() };
+		const transport = createTransport({
+			telemetry,
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockResolvedValue(undefined),
+				getAccumulatedUsage: vi.fn().mockResolvedValue(undefined),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages: readMessages,
+			} as never,
+		});
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-1",
+			command: "session.messages",
+			sessionId: "missing-session",
+		});
+
+		expect(readMessages).not.toHaveBeenCalled();
+		expect(reply).toMatchObject({
+			version: "v1",
+			requestId: "req-1",
+			ok: false,
+			error: {
+				code: "session_not_found",
+				message: "Unknown session: missing-session",
+			},
+		});
+		expect(telemetry.capture).toHaveBeenCalledWith({
+			event: "sdk.error",
+			properties: expect.objectContaining({
+				component: "core",
+				operation: "hub.command_reply",
+				severity: "warn",
+				handled: true,
+				command: "session.messages",
+				requestId: "req-1",
+				sessionId: "missing-session",
+				errorCode: "session_not_found",
+				error_message: "Unknown session: missing-session",
+			}),
+		});
+	});
+
+	it("keeps session list and get lightweight unless snapshots are requested", async () => {
+		const readSessionMessages = vi
+			.fn()
+			.mockResolvedValue([{ role: "user", content: "heavy transcript" }]);
+		const session = {
+			sessionId: "session-1",
+			source: "cli",
+			status: "completed",
+			startedAt: new Date(0).toISOString(),
+			updatedAt: new Date(0).toISOString(),
+			workspaceRoot: "/tmp/project",
+			cwd: "/tmp/project",
+			interactive: true,
+			provider: "cline",
+			model: "test-model",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+		};
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockResolvedValue(session),
+				getAccumulatedUsage: vi.fn().mockResolvedValue(undefined),
+				listSessions: vi.fn().mockResolvedValue([session]),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages,
+			} as never,
+		});
+
+		const listReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-list",
+			command: "session.list",
+			payload: { limit: 10 },
+		});
+		const getReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-get",
+			command: "session.get",
+			sessionId: "session-1",
+		});
+
+		expect(listReply.payload?.sessions).toHaveLength(1);
+		expect(listReply.payload).not.toHaveProperty("snapshots");
+		expect(getReply.payload).toHaveProperty("session");
+		expect(getReply.payload).not.toHaveProperty("snapshot");
+		expect(readSessionMessages).not.toHaveBeenCalled();
+
+		const snapshotReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-get-snapshot",
+			command: "session.get",
+			sessionId: "session-1",
+			payload: { includeSnapshot: true },
+		});
+
+		expect(snapshotReply.payload).toHaveProperty("snapshot");
+		expect(readSessionMessages).toHaveBeenCalledWith("session-1");
+	});
+
+	it("keeps interactive approval requests pending until a response arrives", async () => {
+		vi.useFakeTimers();
+		try {
+			const transport = createTransport();
+			const events: HubEventEnvelope[] = [];
+			let approvalId = "";
+			transport.subscribe("test", (event) => {
+				events.push(event);
+				if (
+					event.event === "approval.requested" &&
+					typeof event.payload?.approvalId === "string"
+				) {
+					approvalId = event.payload.approvalId;
+				}
+			});
+			const ctx = getContext(transport);
+			ensureSessionState(ctx, "session-1", "client-1", "creator", {
+				interactive: true,
+			});
+
+			let settled: unknown;
+			const resultPromise = requestToolApproval(ctx, {
+				sessionId: "session-1",
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 1,
+				toolCallId: "call-1",
+				toolName: "run_commands",
+				input: { commands: ["echo hi"] },
+				policy: { autoApprove: false },
+			});
+			resultPromise.then((result) => {
+				settled = result;
+			});
+
+			await vi.advanceTimersByTimeAsync(10_000);
+			await Promise.resolve();
+
+			expect(settled).toBeUndefined();
+			expect(approvalId).toMatch(/^approval_/);
+			const requested = events.find(
+				(event) => event.event === "approval.requested",
+			);
+			expect(requested?.sessionId).toBe("session-1");
+			expect(requested?.payload).toMatchObject({
+				sessionId: "session-1",
+				conversationId: "conversation-1",
+			});
+			const reply = handleApprovalRespond(ctx, {
+				version: "v1",
+				requestId: "req-1",
+				command: "approval.respond",
+				payload: {
+					approvalId,
+					approved: true,
+					reason: "approved by user",
+				},
+			});
+
+			await expect(reply).resolves.toMatchObject({ ok: true });
+			await expect(resultPromise).resolves.toEqual({
+				approved: true,
+				reason: "approved by user",
+			});
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("rejects pending tool approvals when a run is aborted", async () => {
+		const abort = vi.fn().mockResolvedValue(undefined);
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort,
+				dispose: vi.fn(),
+				getSession: vi.fn(),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+			} as never,
+		});
+		const ctx = getContext(transport);
+		const events: HubEventEnvelope[] = [];
+		let approvalId = "";
+		transport.subscribe("test", (event) => {
+			events.push(event);
+			if (
+				event.event === "approval.requested" &&
+				typeof event.payload?.approvalId === "string"
+			) {
+				approvalId = event.payload.approvalId;
+			}
+		});
+		ensureSessionState(ctx, "session-1", "client-1", "creator", {
+			interactive: true,
+		});
+
+		const resultPromise = requestToolApproval(ctx, {
+			sessionId: "session-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 1,
+			toolCallId: "call-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+		await Promise.resolve();
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-abort",
+			command: "run.abort",
+			sessionId: "session-1",
+			payload: { reason: "user cancelled" },
+		});
+
+		expect(reply.ok).toBe(true);
+		expect(abort).toHaveBeenCalledWith("session-1", "user cancelled");
+		expect(ctx.pendingApprovals.has(approvalId)).toBe(false);
+		await expect(resultPromise).resolves.toEqual({
+			approved: false,
+			reason: "user cancelled",
+		});
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					event: "approval.resolved",
+					sessionId: "session-1",
+					payload: expect.objectContaining({
+						approvalId,
+						approved: false,
+						cancelled: true,
+						reason: "user cancelled",
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("publishes capability-backed tools on the hub session stream", async () => {
+		let capturedStartInput: StartSessionInput | undefined;
+		const startSession = vi.fn(
+			async (input: StartSessionInput): Promise<StartSessionResult> => {
+				capturedStartInput = input;
+				const sessionId = input.config.sessionId?.trim() || "missing-session";
+				return {
+					sessionId,
+					manifest: {
+						version: 1,
+						session_id: sessionId,
+						source: "cli",
+						pid: 1,
+						started_at: new Date(0).toISOString(),
+						status: "running",
+						interactive: true,
+						provider: "cline",
+						model: "test-model",
+						cwd: "/tmp/project",
+						workspace_root: "/tmp/project",
+						enable_tools: true,
+						enable_spawn: true,
+						enable_teams: false,
+					},
+					manifestPath: "",
+					messagesPath: "",
+					result: undefined,
+				};
+			},
+		);
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession,
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockImplementation(async (sessionId: string) => ({
+					sessionId,
+					status: "running",
+					startedAt: new Date(0).toISOString(),
+					updatedAt: new Date(0).toISOString(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+				})),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages: vi.fn(),
+			} as never,
+		});
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("client-1", (event) => events.push(event));
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-create",
+			command: "session.create",
+			clientId: "client-1",
+			payload: {
+				workspaceRoot: "/tmp/project",
+				cwd: "/tmp/project",
+				sessionConfig: {
+					providerId: "cline",
+					modelId: "test-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					systemPrompt: "system",
+				},
+				metadata: { source: "cli", interactive: true },
+				runtimeOptions: {
+					clientContributions: [
+						{
+							kind: "toolExecutor",
+							executor: "askQuestion",
+							capabilityName: "tool_executor.askQuestion",
+						},
+					],
+				},
+			},
+		});
+
+		expect(reply.ok).toBe(true);
+		const sessionId = capturedStartInput?.config.sessionId?.trim() || "";
+		expect(sessionId).toMatch(/^[0-9]/);
+		const askQuestion =
+			capturedStartInput?.capabilities?.toolExecutors?.askQuestion;
+		if (!askQuestion) {
+			throw new Error("Expected askQuestion executor to be registered");
+		}
+		const toolContext: AgentToolContext = {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		};
+		const answerPromise = askQuestion(
+			"Which path?",
+			["Use hub", "Use local"],
+			toolContext,
+		);
+		await Promise.resolve();
+
+		const request = events.find(
+			(event) => event.event === "capability.requested",
+		);
+		expect(request?.sessionId).toBe(sessionId);
+		expect(request?.payload?.payload).toMatchObject({
+			context: { conversationId: "conv-1" },
+		});
+		expect(request?.payload?.targetClientId).toBe("client-1");
+		const requestId =
+			typeof request?.payload?.requestId === "string"
+				? request.payload.requestId
+				: "";
+		expect(requestId).toMatch(/^capreq_/);
+
+		await transport.handleCommand({
+			version: "v1",
+			requestId: "req-response",
+			command: "capability.respond",
+			clientId: "client-1",
+			sessionId,
+			payload: {
+				requestId,
+				ok: true,
+				payload: { result: "Use hub" },
+			},
+		});
+
+		await expect(answerPromise).resolves.toBe("Use hub");
+	});
+
+	it("does not transfer capability ownership to attached clients", async () => {
+		let createdSessionId = "";
+		const startSession = vi.fn(async (input: StartSessionInput) => {
+			createdSessionId = input.config.sessionId?.trim() || "missing-session";
+			return {
+				sessionId: createdSessionId,
+				manifest: {
+					version: 1,
+					session_id: createdSessionId,
+					source: "cli",
+					pid: 1,
+					started_at: new Date(0).toISOString(),
+					status: "running",
+					interactive: true,
+					provider: "cline",
+					model: "test-model",
+					cwd: "/tmp/project",
+					workspace_root: "/tmp/project",
+					enable_tools: true,
+					enable_spawn: true,
+					enable_teams: false,
+				},
+				manifestPath: "",
+				messagesPath: "",
+				result: undefined,
+			};
+		});
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession,
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn().mockImplementation(async (sessionId: string) => ({
+					sessionId,
+					status: "running",
+					startedAt: new Date(0).toISOString(),
+					updatedAt: new Date(0).toISOString(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+					metadata: { hubCapabilityOwnerClientId: "owner-client" },
+				})),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+				readSessionMessages: vi.fn(),
+			} as never,
+		});
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("owner-client", (event) => events.push(event));
+
+		await transport.handleCommand({
+			version: "v1",
+			requestId: "req-create",
+			command: "session.create",
+			clientId: "owner-client",
+			payload: {
+				workspaceRoot: "/tmp/project",
+				cwd: "/tmp/project",
+				sessionConfig: {
+					providerId: "cline",
+					modelId: "test-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					systemPrompt: "system",
+				},
+				metadata: { source: "cli", interactive: true },
+				runtimeOptions: {
+					clientContributions: [
+						{
+							kind: "toolExecutor",
+							executor: "askQuestion",
+							capabilityName: "tool_executor.askQuestion",
+						},
+					],
+				},
+			},
+		});
+		await transport.handleCommand({
+			version: "v1",
+			requestId: "req-attach",
+			command: "session.attach",
+			clientId: "viewer-client",
+			sessionId: createdSessionId,
+		});
+
+		const askQuestion =
+			startSession.mock.calls[0]?.[0].capabilities?.toolExecutors?.askQuestion;
+		if (!askQuestion) throw new Error("Expected askQuestion executor");
+		const answerPromise = askQuestion("Which path?", ["Use hub"], {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		});
+		await Promise.resolve();
+
+		const request = events.find(
+			(event) => event.event === "capability.requested",
+		);
+		expect(request?.payload?.targetClientId).toBe("owner-client");
+		const requestId = String(request?.payload?.requestId ?? "");
+		await transport.handleCommand({
+			version: "v1",
+			requestId: "req-response",
+			command: "capability.respond",
+			clientId: "owner-client",
+			sessionId: createdSessionId,
+			payload: { requestId, ok: true, payload: { result: "Use hub" } },
+		});
+
+		await expect(answerPromise).resolves.toBe("Use hub");
+	});
+
+	it("rejects capability responses from non-owner clients", async () => {
+		const transport = createTransport();
+		const ctx = getContext(transport);
+		ctx.pendingCapabilityRequests.set("capreq-1", {
+			sessionId: "session-1",
+			targetClientId: "owner-client",
+			capabilityName: "tool_executor.askQuestion",
+			resolve: vi.fn(),
+		});
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-response",
+			command: "capability.respond",
+			clientId: "viewer-client",
+			sessionId: "session-1",
+			payload: { requestId: "capreq-1", ok: true, payload: { result: "no" } },
+		});
+
+		expect(reply).toMatchObject({
+			ok: false,
+			error: { code: "capability_wrong_client" },
+		});
+		expect(ctx.pendingCapabilityRequests.has("capreq-1")).toBe(true);
+	});
+
+	it("does not let session metadata updates overwrite server-owned compaction owner", async () => {
+		const updateSession = vi.fn().mockResolvedValue({ updated: true });
+		const transport = createTransport({
+			sessionHost: {
+				updateSession,
+			},
+		});
+
+		await transport.handleCommand({
+			version: "v1",
+			requestId: "req-update",
+			command: "session.update",
+			clientId: "attacker-client",
+			sessionId: "session-1",
+			payload: {
+				metadata: {
+					hubCapabilityOwnerClientId: "attacker-client",
+					title: "safe title",
+				},
+			},
+		});
+
+		expect(updateSession).toHaveBeenCalledWith("session-1", {
+			metadata: { title: "safe title" },
+		});
+	});
+
+	it("authorizes compaction sidecar access from server session state, not mutable metadata", async () => {
+		const readSessionCompactionState = vi.fn();
+		const transport = createTransport({
+			sessionHost: {
+				getSession: vi.fn().mockResolvedValue({
+					sessionId: "session-1",
+					status: "completed",
+					startedAt: new Date(0).toISOString(),
+					updatedAt: new Date(0).toISOString(),
+					workspaceRoot: "/tmp/project",
+					cwd: "/tmp/project",
+					metadata: { hubCapabilityOwnerClientId: "attacker-client" },
+				}),
+				readSessionCompactionState,
+			},
+		});
+		const ctx = getContext(transport);
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact",
+			command: "session.compaction.get",
+			clientId: "attacker-client",
+			sessionId: "session-1",
+		});
+
+		expect(reply).toMatchObject({
+			ok: false,
+			error: { code: "session_wrong_client" },
+		});
+		expect(readSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("does not grant compaction sidecar ownership from session attach", async () => {
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "session-1",
+		});
+		const readSessionCompactionState = vi.fn().mockResolvedValue(state);
+		const updateSessionCompactionState = vi
+			.fn()
+			.mockResolvedValue({ updated: true });
+		const transport = createTransport({
+			sessionHost: {
+				readSessionCompactionState,
+				updateSessionCompactionState,
+			},
+		});
+		const ctx = getContext(transport);
+		expect(ctx.sessionState.has("session-1")).toBe(false);
+
+		const attachReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-attach",
+			command: "session.attach",
+			clientId: "viewer-client",
+			sessionId: "session-1",
+		});
+
+		expect(attachReply).toMatchObject({ ok: true });
+		expect(
+			ctx.sessionState.get("session-1")?.createdByClientId,
+		).toBeUndefined();
+		expect(
+			ctx.sessionState.get("session-1")?.participants.has("viewer-client"),
+		).toBe(true);
+
+		const getReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-get",
+			command: "session.compaction.get",
+			clientId: "viewer-client",
+			sessionId: "session-1",
+		});
+		const updateReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-update",
+			command: "session.compaction.update",
+			clientId: "viewer-client",
+			sessionId: "session-1",
+			payload: { state },
+		});
+
+		expect(getReply).toMatchObject({
+			ok: false,
+			error: { code: "session_wrong_client" },
+		});
+		expect(updateReply).toMatchObject({
+			ok: false,
+			error: { code: "session_wrong_client" },
+		});
+		expect(readSessionCompactionState).not.toHaveBeenCalled();
+		expect(updateSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("allows a creator to claim ownerless compaction sidecar ownership", async () => {
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "session-1",
+		});
+		const readSessionCompactionState = vi.fn().mockResolvedValue(state);
+		const transport = createTransport({
+			sessionHost: { readSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		ensureSessionParticipant(ctx, "session-1", "viewer-client", "participant");
+
+		expect(
+			ctx.sessionState.get("session-1")?.createdByClientId,
+		).toBeUndefined();
+
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+
+		expect(ctx.sessionState.get("session-1")?.createdByClientId).toBe(
+			"owner-client",
+		);
+		expect(
+			ctx.sessionState.get("session-1")?.participants.has("viewer-client"),
+		).toBe(true);
+
+		const getReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-get",
+			command: "session.compaction.get",
+			clientId: "owner-client",
+			sessionId: "session-1",
+		});
+
+		expect(getReply).toMatchObject({
+			ok: true,
+			payload: { state },
+		});
+		expect(readSessionCompactionState).toHaveBeenCalledWith("session-1");
+	});
+
+	it("clears compaction sidecar ownership when the owner detaches", async () => {
+		const readSessionCompactionState = vi.fn();
+		const transport = createTransport({
+			sessionHost: { readSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+		ensureSessionParticipant(ctx, "session-1", "viewer-client", "participant");
+
+		const detachReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-detach",
+			command: "session.detach",
+			clientId: "owner-client",
+			sessionId: "session-1",
+		});
+
+		expect(detachReply).toMatchObject({ ok: true });
+		expect(
+			ctx.sessionState.get("session-1")?.participants.has("viewer-client"),
+		).toBe(true);
+		expect(
+			ctx.sessionState.get("session-1")?.createdByClientId,
+		).toBeUndefined();
+
+		const getReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-get",
+			command: "session.compaction.get",
+			clientId: "viewer-client",
+			sessionId: "session-1",
+		});
+
+		expect(getReply).toMatchObject({
+			ok: false,
+			error: { code: "session_wrong_client" },
+		});
+		expect(readSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("clears compaction sidecar ownership when the owner unregisters", async () => {
+		const readSessionCompactionState = vi.fn();
+		const transport = createTransport({
+			sessionHost: { readSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+		ensureSessionParticipant(ctx, "session-1", "viewer-client", "participant");
+
+		const unregisterReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-unregister",
+			command: "client.unregister",
+			clientId: "owner-client",
+		});
+
+		expect(unregisterReply).toMatchObject({ ok: true });
+		expect(
+			ctx.sessionState.get("session-1")?.participants.has("viewer-client"),
+		).toBe(true);
+		expect(
+			ctx.sessionState.get("session-1")?.createdByClientId,
+		).toBeUndefined();
+
+		const getReply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-get",
+			command: "session.compaction.get",
+			clientId: "viewer-client",
+			sessionId: "session-1",
+		});
+
+		expect(getReply).toMatchObject({
+			ok: false,
+			error: { code: "session_wrong_client" },
+		});
+		expect(readSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("returns compaction sidecar state to the server-owned session client", async () => {
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "session-1",
+		});
+		const readSessionCompactionState = vi.fn().mockResolvedValue(state);
+		const transport = createTransport({
+			sessionHost: { readSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-get",
+			command: "session.compaction.get",
+			clientId: "owner-client",
+			sessionId: "session-1",
+		});
+
+		expect(reply).toMatchObject({
+			ok: true,
+			payload: { sessionId: "session-1", state },
+		});
+		expect(readSessionCompactionState).toHaveBeenCalledWith("session-1");
+	});
+
+	it("rejects invalid compaction sidecar updates before calling the session host", async () => {
+		const updateSessionCompactionState = vi.fn();
+		const transport = createTransport({
+			sessionHost: { updateSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-update-invalid",
+			command: "session.compaction.update",
+			clientId: "owner-client",
+			sessionId: "session-1",
+			payload: { state: { version: 1, messages: "bad" } },
+		});
+
+		expect(reply).toMatchObject({
+			ok: false,
+			error: { code: "invalid_compaction_state" },
+		});
+		expect(updateSessionCompactionState).not.toHaveBeenCalled();
+	});
+
+	it("publishes session updates after successful compaction sidecar updates", async () => {
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "session-1",
+		});
+		const updateSessionCompactionState = vi
+			.fn()
+			.mockResolvedValue({ updated: true });
+		const transport = createTransport({
+			sessionHost: { updateSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		const events: HubEventEnvelope[] = [];
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+		transport.subscribe("owner-client", (event) => events.push(event));
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-update",
+			command: "session.compaction.update",
+			clientId: "owner-client",
+			sessionId: "session-1",
+			payload: { state },
+		});
+
+		expect(reply).toMatchObject({
+			ok: true,
+			payload: { updated: true },
+		});
+		expect(updateSessionCompactionState).toHaveBeenCalledWith(
+			"session-1",
+			state,
+		);
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					event: "session.updated",
+					sessionId: "session-1",
+				}),
+			]),
+		);
+	});
+
+	it("does not publish session updates when compaction sidecar update is stale", async () => {
+		const state = createSessionCompactionState({
+			sourceMessages: [{ role: "user", content: "source" }],
+			compactedMessages: [{ role: "user", content: "summary" }],
+			conversationId: "session-1",
+		});
+		const updateSessionCompactionState = vi
+			.fn()
+			.mockResolvedValue({ updated: false });
+		const transport = createTransport({
+			sessionHost: { updateSessionCompactionState },
+		});
+		const ctx = getContext(transport);
+		const events: HubEventEnvelope[] = [];
+		ensureSessionState(ctx, "session-1", "owner-client", "creator");
+		transport.subscribe("owner-client", (event) => events.push(event));
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-compact-stale",
+			command: "session.compaction.update",
+			clientId: "owner-client",
+			sessionId: "session-1",
+			payload: { state },
+		});
+
+		expect(reply).toMatchObject({
+			ok: true,
+			payload: { updated: false },
+		});
+		expect(events).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ event: "session.updated" }),
+			]),
+		);
+	});
+
+	it("cancels pending capability requests when a run is aborted", async () => {
+		const abort = vi.fn().mockResolvedValue(undefined);
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn: vi.fn(),
+				abort,
+				dispose: vi.fn(),
+				getSession: vi.fn(),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+			} as never,
+		});
+		const ctx = getContext(transport);
+		const resolved = vi.fn();
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("owner-client", (event) => events.push(event));
+		ctx.pendingCapabilityRequests.set("capreq-1", {
+			sessionId: "session-1",
+			targetClientId: "owner-client",
+			capabilityName: "tool_executor.askQuestion",
+			resolve: resolved,
+		});
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-abort",
+			command: "run.abort",
+			sessionId: "session-1",
+			payload: { reason: "user cancelled" },
+		});
+
+		expect(reply.ok).toBe(true);
+		expect(resolved).toHaveBeenCalledWith({
+			ok: false,
+			error: "user cancelled",
+		});
+		expect(ctx.pendingCapabilityRequests.has("capreq-1")).toBe(false);
+		expect(events).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					event: "capability.resolved",
+					payload: expect.objectContaining({
+						requestId: "capreq-1",
+						cancelled: true,
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("returns session_not_found when a run starts against a stale active session", async () => {
+		const runTurn = vi
+			.fn()
+			.mockRejectedValue(new SessionNotFoundError("stale-session"));
+		const transport = createTransport({
+			sessionHost: {
+				runTurn,
+				getSession: vi.fn().mockResolvedValue({
+					sessionId: "stale-session",
+					source: "cli",
+					pid: 123,
+					startedAt: new Date(0).toISOString(),
+					status: "running",
+					interactive: true,
+					provider: "cline",
+					model: "test-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					enableTools: true,
+					enableSpawn: true,
+					enableTeams: false,
+					updatedAt: new Date(0).toISOString(),
+				}),
+			},
+		});
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("client-1", (event) => events.push(event));
+
+		const reply = await transport.handleCommand({
+			version: "v1",
+			requestId: "req-stale-run",
+			command: "run.start",
+			clientId: "client-1",
+			sessionId: "stale-session",
+			payload: { prompt: "continue" },
+		});
+
+		expect(runTurn).toHaveBeenCalledWith(
+			expect.objectContaining({ sessionId: "stale-session" }),
+		);
+		expect(reply).toMatchObject({
+			version: "v1",
+			requestId: "req-stale-run",
+			ok: false,
+			error: {
+				code: "session_not_found",
+				message: "session not found: stale-session",
+			},
+		});
+		expect(events.some((event) => event.event === "run.failed")).toBe(false);
+	});
+
+	it("forwards run file attachment paths to the session host", async () => {
+		const runTurn = vi.fn().mockResolvedValue(undefined);
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn,
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn(),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+			} as never,
+		});
+
+		const reply = await (
+			transport as unknown as {
+				handleCommand: (envelope: {
+					version: "v1";
+					requestId: string;
+					command: "run.start";
+					sessionId: string;
+					payload: {
+						sessionId: string;
+						prompt: string;
+						mode?: string;
+						attachments: { userFiles: string[] };
+					};
+				}) => Promise<{ ok: boolean }>;
+			}
+		).handleCommand({
+			version: "v1",
+			requestId: "req-1",
+			command: "run.start",
+			sessionId: "session-1",
+			payload: {
+				sessionId: "session-1",
+				prompt: "Use this file",
+				mode: "plan",
+				attachments: { userFiles: ["/tmp/project/note.md"] },
+			},
+		});
+
+		expect(reply.ok).toBe(true);
+		expect(runTurn).toHaveBeenCalledWith(
+			expect.objectContaining({
+				sessionId: "session-1",
+				prompt: "Use this file",
+				mode: "plan",
+				userFiles: ["/tmp/project/note.md"],
+			}),
+		);
+	});
+
+	it("publishes result error text on failed run events", async () => {
+		const runTurn = vi.fn().mockResolvedValue({
+			text: "Provider rejected the request",
+			finishReason: "error",
+			iterations: 1,
+			usage: { inputTokens: 0, outputTokens: 0 },
+			toolCalls: [],
+			messages: [],
+			model: { id: "model-1", provider: "provider-1" },
+			startedAt: new Date(0),
+			endedAt: new Date(0),
+			durationMs: 0,
+		});
+		const transport = createTransport({
+			sessionHost: {
+				subscribe: vi.fn(),
+				startSession: vi.fn(),
+				stopSession: vi.fn(),
+				runTurn,
+				abort: vi.fn(),
+				dispose: vi.fn(),
+				getSession: vi.fn(),
+				listSessions: vi.fn(),
+				deleteSession: vi.fn(),
+				updateSession: vi.fn(),
+				dispatchHookEvent: vi.fn(),
+			} as never,
+		});
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("test", (event) => {
+			events.push(event);
+		});
+
+		await (
+			transport as unknown as {
+				handleCommand: (envelope: {
+					version: "v1";
+					requestId: string;
+					command: "run.start";
+					sessionId: string;
+					payload: { sessionId: string; prompt: string };
+				}) => Promise<{ ok: boolean }>;
+			}
+		).handleCommand({
+			version: "v1",
+			requestId: "req-1",
+			command: "run.start",
+			sessionId: "session-1",
+			payload: { sessionId: "session-1", prompt: "go" },
+		});
+
+		expect(events).toContainEqual(
+			expect.objectContaining({
+				event: "run.failed",
+				payload: expect.objectContaining({
+					error: "Provider rejected the request",
+				}),
+			}),
+		);
+	});
+
+	it("publishes iteration lifecycle events from agent events", async () => {
+		const transport = createTransport();
+		const published: string[] = [];
+		transport.subscribe("test", (event) => {
+			published.push(event.event);
+		});
+		const ctx = getContext(transport);
+
+		await projectSessionEvent(ctx, {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: { type: "iteration_start", iteration: 3 },
+			},
+		});
+		await projectSessionEvent(ctx, {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				event: {
+					type: "iteration_end",
+					iteration: 3,
+					hadToolCalls: true,
+					toolCallCount: 1,
+				},
+			},
+		});
+
+		expect(published).toEqual(["iteration.started", "iteration.finished"]);
+	});
+
+	it("projects live usage events with aggregate usage and agent identity", async () => {
+		const usage = {
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+			totalCost: 0.11,
+		};
+		const aggregateUsage = {
+			inputTokens: 17,
+			outputTokens: 8,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 3,
+			totalCost: 0.23,
+		};
+		const getAccumulatedUsage = vi
+			.fn()
+			.mockResolvedValue({ usage, aggregateUsage });
+		const transport = createTransport({
+			sessionHost: { getAccumulatedUsage },
+		});
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("test", (event) => {
+			events.push(event);
+		});
+		const ctx = getContext(transport);
+
+		await projectSessionEvent(ctx, {
+			type: "agent_event",
+			payload: {
+				sessionId: "session-1",
+				teamAgentId: "investigator",
+				teamRole: "teammate",
+				event: {
+					type: "usage",
+					agentId: "agent-teammate-1",
+					conversationId: "conv-teammate-1",
+					parentAgentId: "lead",
+					inputTokens: 7,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 1,
+					cost: 0.12,
+					totalInputTokens: 7,
+					totalOutputTokens: 5,
+					totalCacheReadTokens: 2,
+					totalCacheWriteTokens: 1,
+					totalCost: 0.12,
+				},
+			},
+		});
+
+		expect(getAccumulatedUsage).toHaveBeenCalledWith("session-1");
+		expect(events).toHaveLength(1);
+		expect(events[0]).toMatchObject({
+			event: "usage.updated",
+			sessionId: "session-1",
+			payload: {
+				sessionId: "session-1",
+				delta: {
+					inputTokens: 7,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 1,
+					totalCost: 0.12,
+				},
+				totals: {
+					inputTokens: 7,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 1,
+					totalCost: 0.12,
+				},
+				usage,
+				aggregateUsage,
+				agent: {
+					kind: "teammate",
+					agentId: "agent-teammate-1",
+					conversationId: "conv-teammate-1",
+					parentAgentId: "lead",
+					teamAgentId: "investigator",
+					teamRole: "teammate",
+				},
+			},
+		});
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/browser-websocket.test.ts b/sdk/packages/core/src/hub/server/browser-websocket.test.ts
new file mode 100644
index 0000000..4618943
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/browser-websocket.test.ts
@@ -0,0 +1,173 @@
+import type { HubReplyEnvelope } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { BrowserWebSocketHubAdapter } from "./browser-websocket";
+
+function createSocket() {
+	const messageListeners = new Set<(event: { data: string }) => void>();
+	const closeListeners = new Set<() => void>();
+	return {
+		sent: [] as string[],
+		send(data: string) {
+			this.sent.push(data);
+		},
+		addEventListener(
+			type: "message" | "close",
+			listener: ((event: { data: string }) => void) | (() => void),
+		) {
+			if (type === "message") {
+				messageListeners.add(listener as (event: { data: string }) => void);
+				return;
+			}
+			closeListeners.add(listener as () => void);
+		},
+		removeEventListener(
+			type: "message" | "close",
+			listener: ((event: { data: string }) => void) | (() => void),
+		) {
+			if (type === "message") {
+				messageListeners.delete(listener as (event: { data: string }) => void);
+				return;
+			}
+			closeListeners.delete(listener as () => void);
+		},
+		emitMessage(data: string) {
+			for (const listener of messageListeners) {
+				void listener({ data });
+			}
+		},
+		emitClose() {
+			for (const listener of closeListeners) {
+				listener();
+			}
+		},
+	};
+}
+
+describe("BrowserWebSocketHubAdapter", () => {
+	afterEach(() => {
+		vi.useRealTimers();
+		vi.restoreAllMocks();
+	});
+
+	it("ignores malformed websocket frames instead of throwing", async () => {
+		const transport = {
+			command: vi.fn(),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+		try {
+			const adapter = new BrowserWebSocketHubAdapter(transport);
+			adapter.attach(socket);
+
+			await expect(async () => {
+				socket.emitMessage("{bad json");
+				await Promise.resolve();
+			}).not.toThrow();
+
+			expect(transport.command).not.toHaveBeenCalled();
+			expect(socket.sent).toHaveLength(0);
+			expect(errorSpy).toHaveBeenCalledWith(
+				expect.stringContaining(
+					'"message":"rejected malformed websocket frame"',
+				),
+			);
+		} finally {
+			errorSpy.mockRestore();
+		}
+	});
+
+	it("keeps run.start open past the default command timeout", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		let resolveCommand: ((reply: HubReplyEnvelope) => void) | undefined;
+		const transport = {
+			command: vi.fn(
+				() =>
+					new Promise<HubReplyEnvelope>((resolve) => {
+						resolveCommand = resolve;
+					}),
+			),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		const adapter = new BrowserWebSocketHubAdapter(transport);
+		adapter.attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "run.start",
+					requestId: "req-run",
+					clientId: "client-1",
+					sessionId: "session-1",
+					payload: { input: "hello" },
+				},
+			}),
+		);
+
+		await vi.advanceTimersByTimeAsync(30_001);
+		expect(socket.sent).toHaveLength(0);
+
+		resolveCommand?.({
+			version: "v1",
+			requestId: "req-run",
+			ok: true,
+			payload: { result: { finishReason: "completed" } },
+		});
+		await Promise.resolve();
+
+		expect(socket.sent.map((entry) => JSON.parse(entry))).toContainEqual({
+			kind: "reply",
+			envelope: {
+				version: "v1",
+				requestId: "req-run",
+				ok: true,
+				payload: { result: { finishReason: "completed" } },
+			},
+		});
+	});
+
+	it("applies the default command timeout to fast commands", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		const transport = {
+			command: vi.fn(() => new Promise<HubReplyEnvelope>(() => {})),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		const adapter = new BrowserWebSocketHubAdapter(transport);
+		adapter.attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "client.list",
+					requestId: "req-list",
+					clientId: "client-1",
+				},
+			}),
+		);
+
+		await vi.advanceTimersByTimeAsync(30_001);
+
+		expect(socket.sent.map((entry) => JSON.parse(entry))).toContainEqual({
+			kind: "reply",
+			envelope: {
+				version: "v1",
+				requestId: "req-list",
+				ok: false,
+				error: {
+					code: "hub_command_timeout",
+					message:
+						"Hub command client.list did not complete within 30000ms. Check hub-daemon.log for command.start/command.slow logs with requestId req-list.",
+				},
+			},
+		});
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/browser-websocket.ts b/sdk/packages/core/src/hub/server/browser-websocket.ts
new file mode 100644
index 0000000..ab280a5
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/browser-websocket.ts
@@ -0,0 +1,295 @@
+import type {
+	HubClientRegistration,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+	HubTransportFrame,
+	ITelemetryService,
+} from "@cline/shared";
+import {
+	captureSdkError,
+	HUB_COMMAND_SLOW_LOG_MS,
+	resolveHubCommandTimeoutMs,
+	safeJsonParse,
+} from "@cline/shared";
+import type { HubCommandTransport } from "./command-transport";
+import { logHubMessage } from "./hub-server-logging";
+
+type HubCommandFrame = HubTransportFrame & { kind: "command" };
+
+export interface BrowserHubSocketLike {
+	send(data: string): void;
+	addEventListener(
+		type: "message",
+		listener: (event: { data: string }) => void,
+	): void;
+	addEventListener(type: "close", listener: () => void): void;
+	removeEventListener(
+		type: "message",
+		listener: (event: { data: string }) => void,
+	): void;
+	removeEventListener(type: "close", listener: () => void): void;
+}
+
+function commandLogContext(frame: HubCommandFrame) {
+	return {
+		command: frame.envelope.command,
+		requestId: frame.envelope.requestId,
+		clientId: frame.envelope.clientId,
+		sessionId: frame.envelope.sessionId,
+	};
+}
+
+function commandErrorReply(
+	frame: HubCommandFrame,
+	code: string,
+	message: string,
+): HubReplyEnvelope {
+	return {
+		version: frame.envelope.version,
+		requestId: frame.envelope.requestId,
+		ok: false,
+		error: { code, message },
+	};
+}
+
+export class BrowserWebSocketHubAdapter {
+	constructor(
+		private readonly transport: HubCommandTransport,
+		private readonly telemetry?: ITelemetryService,
+	) {}
+
+	attach(socket: BrowserHubSocketLike): () => void {
+		const subscriptions = new Map<string, () => void>();
+		const registeredClientIds = new Set<string>();
+		let closed = false;
+
+		const sendFrame = (frame: HubTransportFrame): void => {
+			try {
+				socket.send(JSON.stringify(frame));
+			} catch (error) {
+				console.error(
+					`[hub] failed to send websocket frame: ${
+						error instanceof Error
+							? error.stack || error.message
+							: String(error)
+					}`,
+				);
+			}
+		};
+
+		const onEvent = (envelope: HubEventEnvelope): void => {
+			sendFrame({ kind: "event", envelope });
+		};
+
+		const onMessage = async (event: { data: string }): Promise<void> => {
+			try {
+				const frame = JSON.parse(event.data) as HubTransportFrame;
+				switch (frame.kind) {
+					case "command": {
+						const startedAt = performance.now();
+						let settled = false;
+						const context = commandLogContext(frame);
+						logHubMessage("info", "command.start", context);
+						const slowTimer = setTimeout(() => {
+							if (settled) return;
+							logHubMessage("warn", "command.slow", {
+								...context,
+								elapsedMs: Math.round(performance.now() - startedAt),
+							});
+						}, HUB_COMMAND_SLOW_LOG_MS);
+						const commandPromise = this.transport.command(frame.envelope);
+						commandPromise.then(
+							(lateReply) => {
+								if (!settled) return;
+								logHubMessage(
+									lateReply.ok ? "warn" : "error",
+									"command.late_end",
+									{
+										...context,
+										elapsedMs: Math.round(performance.now() - startedAt),
+										ok: lateReply.ok,
+										errorCode: lateReply.error?.code,
+										errorMessage: lateReply.error?.message,
+									},
+								);
+							},
+							(error) => {
+								if (!settled) return;
+								logHubMessage("error", "command.late_error", {
+									...context,
+									elapsedMs: Math.round(performance.now() - startedAt),
+									error,
+								});
+							},
+						);
+						let timedOut = false;
+						let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+						let reply: HubReplyEnvelope;
+						const timeoutMs = resolveHubCommandTimeoutMs(
+							frame.envelope.command,
+							frame.envelope.timeoutMs,
+						);
+						try {
+							reply =
+								timeoutMs === null
+									? await commandPromise
+									: await Promise.race([
+											commandPromise,
+											new Promise<HubReplyEnvelope>((resolve) => {
+												timeoutTimer = setTimeout(() => {
+													timedOut = true;
+													captureSdkError(this.telemetry, {
+														component: "core",
+														operation: "hub.command_timeout",
+														error: new Error(
+															`Hub command ${frame.envelope.command} did not complete within ${timeoutMs}ms.`,
+														),
+														severity: "error",
+														handled: true,
+														context: {
+															...context,
+															timeoutMs,
+														},
+													});
+													resolve(
+														commandErrorReply(
+															frame,
+															"hub_command_timeout",
+															`Hub command ${frame.envelope.command} did not complete within ${timeoutMs}ms. Check hub-daemon.log for command.start/command.slow logs with requestId ${frame.envelope.requestId}.`,
+														),
+													);
+												}, timeoutMs);
+											}),
+										]);
+						} catch (error) {
+							clearTimeout(slowTimer);
+							if (timeoutTimer) clearTimeout(timeoutTimer);
+							throw error;
+						}
+						settled = timedOut;
+						clearTimeout(slowTimer);
+						if (timeoutTimer) clearTimeout(timeoutTimer);
+						const durationMs = Math.round(performance.now() - startedAt);
+						if (timedOut) {
+							logHubMessage("error", "command.timeout", {
+								...context,
+								durationMs,
+								timeoutMs,
+							});
+						} else {
+							logHubMessage(reply.ok ? "info" : "warn", "command.end", {
+								...context,
+								durationMs,
+								ok: reply.ok,
+								errorCode: reply.error?.code,
+								errorMessage: reply.error?.message,
+							});
+						}
+						if (frame.envelope.command === "client.register" && reply.ok) {
+							const registration = (frame.envelope.payload ??
+								{}) as unknown as HubClientRegistration;
+							const clientId =
+								registration.clientId?.trim() ||
+								frame.envelope.clientId?.trim();
+							if (clientId) {
+								registeredClientIds.add(clientId);
+							}
+						} else if (
+							frame.envelope.command === "client.unregister" &&
+							reply.ok
+						) {
+							const clientId = frame.envelope.clientId?.trim();
+							if (clientId) {
+								registeredClientIds.delete(clientId);
+							}
+						}
+						sendFrame({
+							kind: "reply",
+							envelope: reply satisfies HubReplyEnvelope,
+						});
+						break;
+					}
+					case "stream.subscribe": {
+						const key = `${frame.clientId}:${frame.sessionId ?? "*"}`;
+						if (subscriptions.has(key)) {
+							break;
+						}
+						const unsubscribe = await this.transport.subscribe(
+							frame.clientId,
+							onEvent,
+							{ sessionId: frame.sessionId },
+						);
+						subscriptions.set(key, unsubscribe);
+						break;
+					}
+					case "stream.unsubscribe": {
+						const key = `${frame.clientId}:${frame.sessionId ?? "*"}`;
+						subscriptions.get(key)?.();
+						subscriptions.delete(key);
+						break;
+					}
+					case "reply":
+					case "event":
+						break;
+				}
+			} catch (error) {
+				const parsed =
+					typeof event.data === "string"
+						? safeJsonParse<HubTransportFrame>(event.data)
+						: undefined;
+				if (!parsed || parsed.kind !== "command") {
+					logHubMessage("error", "rejected malformed websocket frame", {
+						error,
+					});
+					return;
+				}
+				logHubMessage("error", "command.error", {
+					...commandLogContext(parsed),
+					error,
+				});
+				captureSdkError(this.telemetry, {
+					component: "core",
+					operation: "hub.websocket_command",
+					error,
+					severity: "error",
+					handled: true,
+					context: commandLogContext(parsed),
+				});
+				sendFrame({
+					kind: "reply",
+					envelope: commandErrorReply(
+						parsed,
+						"command_failed",
+						error instanceof Error ? error.message : "Unknown hub error",
+					),
+				});
+			}
+		};
+
+		const onClose = (): void => {
+			if (closed) {
+				return;
+			}
+			closed = true;
+			for (const unsubscribe of subscriptions.values()) {
+				unsubscribe();
+			}
+			subscriptions.clear();
+			for (const clientId of registeredClientIds) {
+				void this.transport.command({
+					version: "v1",
+					command: "client.unregister",
+					clientId,
+				});
+			}
+			registeredClientIds.clear();
+			socket.removeEventListener("message", onMessage);
+			socket.removeEventListener("close", onClose);
+		};
+
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		return onClose;
+	}
+}
diff --git a/sdk/packages/core/src/hub/server/command-transport.ts b/sdk/packages/core/src/hub/server/command-transport.ts
new file mode 100644
index 0000000..608766b
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/command-transport.ts
@@ -0,0 +1,14 @@
+import type {
+	HubCommandEnvelope,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+} from "@cline/shared";
+
+export interface HubCommandTransport {
+	command(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): Promise<() => void> | (() => void);
+}
diff --git a/sdk/packages/core/src/hub/server/fetch-wiring.test.ts b/sdk/packages/core/src/hub/server/fetch-wiring.test.ts
new file mode 100644
index 0000000..b512eab
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/fetch-wiring.test.ts
@@ -0,0 +1,102 @@
+import { describe, expect, it, vi } from "vitest";
+
+const localRuntimeHostMock = vi.hoisted(() =>
+	vi.fn().mockImplementation(function (this: unknown, _options: unknown) {
+		const instance = this as Record<string, unknown>;
+		instance.subscribe = vi.fn(() => () => {});
+		instance.dispose = vi.fn(async () => {});
+		instance.start = vi.fn();
+		instance.send = vi.fn();
+		instance.abort = vi.fn();
+		instance.stop = vi.fn();
+		instance.runtimeAddress = undefined;
+	}),
+);
+
+vi.mock("../../runtime/host/local-runtime-host", () => ({
+	LocalRuntimeHost: localRuntimeHostMock,
+}));
+
+describe("hub server fetch wiring", () => {
+	it("forwards HubWebSocketServerOptions.fetch into the internal LocalRuntimeHost", async () => {
+		localRuntimeHostMock.mockClear();
+		const { HubServerTransport } = (await import(".")) as unknown as {
+			HubServerTransport: new (options: unknown) => unknown;
+		};
+
+		const customFetch = (async () => new Response()) as unknown as typeof fetch;
+
+		new HubServerTransport({
+			runtimeHandlers: {
+				startSession: vi.fn(),
+				sendSession: vi.fn(),
+				abortSession: vi.fn(),
+				stopSession: vi.fn(),
+			},
+			fetch: customFetch,
+		});
+
+		expect(localRuntimeHostMock).toHaveBeenCalledTimes(1);
+		const constructorArgs = localRuntimeHostMock.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(constructorArgs.fetch).toBe(customFetch);
+	});
+
+	it("does not construct a default LocalRuntimeHost when sessionHost is supplied", async () => {
+		localRuntimeHostMock.mockClear();
+		const { HubServerTransport } = (await import(".")) as unknown as {
+			HubServerTransport: new (options: unknown) => unknown;
+		};
+
+		const suppliedHost = {
+			subscribe: vi.fn(() => () => {}),
+			dispose: vi.fn(async () => {}),
+			runtimeAddress: undefined,
+		};
+
+		new HubServerTransport({
+			sessionHost: suppliedHost,
+			runtimeHandlers: {
+				startSession: vi.fn(),
+				sendSession: vi.fn(),
+				abortSession: vi.fn(),
+				stopSession: vi.fn(),
+			},
+			fetch: (async () => new Response()) as unknown as typeof fetch,
+		});
+
+		expect(localRuntimeHostMock).not.toHaveBeenCalled();
+	});
+
+	it("forwards createLocalHubScheduleRuntimeHandlers fetch into its internal LocalRuntimeHost", async () => {
+		localRuntimeHostMock.mockClear();
+		const { createLocalHubScheduleRuntimeHandlers } = await import(
+			"../daemon/runtime-handlers"
+		);
+
+		const customFetch = (async () => new Response()) as unknown as typeof fetch;
+		createLocalHubScheduleRuntimeHandlers({ fetch: customFetch });
+
+		expect(localRuntimeHostMock).toHaveBeenCalledTimes(1);
+		const constructorArgs = localRuntimeHostMock.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(constructorArgs.fetch).toBe(customFetch);
+	});
+
+	it("leaves fetch undefined when createLocalHubScheduleRuntimeHandlers is called without one", async () => {
+		localRuntimeHostMock.mockClear();
+		const { createLocalHubScheduleRuntimeHandlers } = await import(
+			"../daemon/runtime-handlers"
+		);
+
+		createLocalHubScheduleRuntimeHandlers();
+
+		expect(localRuntimeHostMock).toHaveBeenCalledTimes(1);
+		const constructorArgs = localRuntimeHostMock.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(constructorArgs.fetch).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts b/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts
new file mode 100644
index 0000000..64ff59c
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts
@@ -0,0 +1,133 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	ToolApprovalRequest,
+} from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import { errorReply, type HubTransportContext, okReply } from "./context";
+
+export async function requestToolApproval(
+	ctx: HubTransportContext,
+	request: ToolApprovalRequest,
+): Promise<{ approved: boolean; reason?: string }> {
+	const approvalId = createSessionId("approval_");
+	const sessionId = request.sessionId;
+	const state = ctx.sessionState.get(sessionId);
+	if (state?.interactive === false) {
+		return {
+			approved: false,
+			reason:
+				"Tool approval requires an interactive session, but this session is non-interactive.",
+		};
+	}
+	return await new Promise((resolve) => {
+		ctx.pendingApprovals.set(approvalId, {
+			sessionId,
+			resolve,
+		});
+		ctx.publish(
+			ctx.buildEvent(
+				"approval.requested",
+				{
+					approvalId,
+					sessionId: request.sessionId,
+					agentId: request.agentId,
+					conversationId: request.conversationId,
+					iteration: request.iteration,
+					toolCallId: request.toolCallId,
+					toolName: request.toolName,
+					inputJson: JSON.stringify(request.input ?? null),
+					policy: request.policy,
+				},
+				sessionId,
+			),
+		);
+	});
+}
+
+export function resolvePendingApproval(
+	ctx: HubTransportContext,
+	approvalId: string,
+	result: { approved: boolean; reason?: string },
+): { sessionId: string } | undefined {
+	const pending = ctx.pendingApprovals.get(approvalId);
+	if (!pending) {
+		return undefined;
+	}
+	ctx.pendingApprovals.delete(approvalId);
+	pending.resolve(result);
+	return { sessionId: pending.sessionId };
+}
+
+export function cancelPendingApprovals(
+	ctx: HubTransportContext,
+	filter: (approval: { approvalId: string; sessionId: string }) => boolean,
+	reason: string,
+): number {
+	let cancelled = 0;
+	for (const [approvalId, pending] of [...ctx.pendingApprovals.entries()]) {
+		if (!filter({ approvalId, sessionId: pending.sessionId })) {
+			continue;
+		}
+		ctx.pendingApprovals.delete(approvalId);
+		pending.resolve({ approved: false, reason });
+		ctx.publish(
+			ctx.buildEvent(
+				"approval.resolved",
+				{ approvalId, approved: false, cancelled: true, reason },
+				pending.sessionId,
+			),
+		);
+		cancelled += 1;
+	}
+	return cancelled;
+}
+
+export async function handleApprovalRespond(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const approvalId =
+		typeof envelope.payload?.approvalId === "string"
+			? envelope.payload.approvalId.trim()
+			: "";
+	const pending = ctx.pendingApprovals.get(approvalId);
+	if (!pending) {
+		return errorReply(
+			envelope,
+			"approval_not_found",
+			`Unknown approval: ${approvalId}`,
+		);
+	}
+	const reason =
+		typeof envelope.payload?.reason === "string"
+			? envelope.payload.reason
+			: envelope.payload?.payload &&
+					typeof envelope.payload.payload === "object" &&
+					!Array.isArray(envelope.payload.payload) &&
+					typeof (envelope.payload.payload as Record<string, unknown>)
+						.reason === "string"
+				? ((envelope.payload.payload as Record<string, unknown>)
+						.reason as string)
+				: undefined;
+	const approved = envelope.payload?.approved === true;
+	const resolved = resolvePendingApproval(ctx, approvalId, {
+		approved,
+		reason,
+	});
+	if (!resolved) {
+		return errorReply(
+			envelope,
+			"approval_not_found",
+			`Unknown approval: ${approvalId}`,
+		);
+	}
+	ctx.publish(
+		ctx.buildEvent(
+			"approval.resolved",
+			{ approvalId, approved, reason },
+			resolved.sessionId,
+		),
+	);
+	return okReply(envelope, { approvalId, approved });
+}
diff --git a/sdk/packages/core/src/hub/server/handlers/capability-handlers.ts b/sdk/packages/core/src/hub/server/handlers/capability-handlers.ts
new file mode 100644
index 0000000..3864873
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/capability-handlers.ts
@@ -0,0 +1,278 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import { logHubMessage } from "../hub-server-logging";
+import { errorReply, type HubTransportContext, okReply } from "./context";
+
+export async function requestCapability(
+	ctx: HubTransportContext,
+	sessionId: string,
+	capabilityName: string,
+	payload: Record<string, unknown>,
+	targetClientId: string,
+	onProgress?: (payload: Record<string, unknown>) => void,
+): Promise<Record<string, unknown> | undefined> {
+	const requestId = createSessionId("capreq_");
+	const startedAt = performance.now();
+	logHubMessage("info", "capability.request.start", {
+		requestId,
+		sessionId,
+		capabilityName,
+		targetClientId,
+	});
+	return await new Promise((resolve, reject) => {
+		ctx.pendingCapabilityRequests.set(requestId, {
+			sessionId,
+			targetClientId,
+			capabilityName,
+			onProgress,
+			resolve: (result) => {
+				logHubMessage(result.ok ? "info" : "warn", "capability.request.end", {
+					requestId,
+					sessionId,
+					capabilityName,
+					targetClientId,
+					ok: result.ok,
+					error: result.error,
+					durationMs: Math.round(performance.now() - startedAt),
+				});
+				if (!result.ok) {
+					reject(
+						new Error(
+							result.error ||
+								`Capability ${capabilityName} was rejected by ${targetClientId}.`,
+						),
+					);
+					return;
+				}
+				resolve(result.payload);
+			},
+		});
+		ctx.publish(
+			ctx.buildEvent(
+				"capability.requested",
+				{
+					requestId,
+					targetClientId,
+					capabilityName,
+					payload,
+				},
+				sessionId,
+			),
+		);
+		logHubMessage("info", "capability.request.published", {
+			requestId,
+			sessionId,
+			capabilityName,
+			targetClientId,
+		});
+	});
+}
+
+export function handleCapabilityProgress(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): HubReplyEnvelope {
+	const requestId =
+		typeof envelope.payload?.requestId === "string"
+			? envelope.payload.requestId.trim()
+			: "";
+	const pending = ctx.pendingCapabilityRequests.get(requestId);
+	if (!pending) {
+		return errorReply(
+			envelope,
+			"capability_not_found",
+			`Unknown capability request: ${requestId}`,
+		);
+	}
+	const responderClientId = envelope.clientId?.trim() || "";
+	if (responderClientId !== pending.targetClientId) {
+		return errorReply(
+			envelope,
+			"capability_wrong_client",
+			`Capability request ${requestId} is owned by ${pending.targetClientId}`,
+		);
+	}
+	if (
+		envelope.sessionId?.trim() &&
+		envelope.sessionId.trim() !== pending.sessionId
+	) {
+		return errorReply(
+			envelope,
+			"capability_wrong_session",
+			`Capability request ${requestId} belongs to session ${pending.sessionId}`,
+		);
+	}
+	const payload =
+		envelope.payload?.payload &&
+		typeof envelope.payload.payload === "object" &&
+		!Array.isArray(envelope.payload.payload)
+			? (envelope.payload.payload as Record<string, unknown>)
+			: {};
+	pending.onProgress?.(payload);
+	return okReply(envelope, { requestId });
+}
+
+export function cancelPendingCapabilityRequests(
+	ctx: HubTransportContext,
+	filter: (request: {
+		requestId: string;
+		sessionId: string;
+		targetClientId: string;
+		capabilityName: string;
+	}) => boolean,
+	reason: string,
+): number {
+	let cancelled = 0;
+	for (const [requestId, pending] of [
+		...ctx.pendingCapabilityRequests.entries(),
+	]) {
+		if (!filter({ requestId, ...pending })) {
+			continue;
+		}
+		ctx.pendingCapabilityRequests.delete(requestId);
+		logHubMessage("warn", "capability.request.cancelled", {
+			requestId,
+			sessionId: pending.sessionId,
+			capabilityName: pending.capabilityName,
+			targetClientId: pending.targetClientId,
+			reason,
+		});
+		pending.resolve({ ok: false, error: reason });
+		ctx.publish(
+			ctx.buildEvent(
+				"capability.resolved",
+				{
+					requestId,
+					capabilityName: pending.capabilityName,
+					targetClientId: pending.targetClientId,
+					ok: false,
+					cancelled: true,
+					error: reason,
+				},
+				pending.sessionId,
+			),
+		);
+		cancelled += 1;
+	}
+	return cancelled;
+}
+
+export async function handleCapabilityRequest(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId =
+		typeof envelope.payload?.sessionId === "string"
+			? envelope.payload.sessionId.trim()
+			: envelope.sessionId?.trim() || "";
+	const capabilityName =
+		typeof envelope.payload?.capabilityName === "string"
+			? envelope.payload.capabilityName.trim()
+			: "";
+	const targetClientId =
+		typeof envelope.payload?.targetClientId === "string"
+			? envelope.payload.targetClientId.trim()
+			: "";
+	if (!sessionId || !capabilityName || !targetClientId) {
+		return errorReply(
+			envelope,
+			"invalid_capability_request",
+			"capability.request requires sessionId, capabilityName, and targetClientId",
+		);
+	}
+	try {
+		const payload =
+			envelope.payload?.payload &&
+			typeof envelope.payload.payload === "object" &&
+			!Array.isArray(envelope.payload.payload)
+				? (envelope.payload.payload as Record<string, unknown>)
+				: {};
+		const response = await ctx.requestCapability(
+			sessionId,
+			capabilityName,
+			payload,
+			targetClientId,
+		);
+		return okReply(envelope, response);
+	} catch (error) {
+		return errorReply(
+			envelope,
+			"capability_request_failed",
+			error instanceof Error ? error.message : String(error),
+		);
+	}
+}
+
+export function handleCapabilityRespond(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): HubReplyEnvelope {
+	const requestId =
+		typeof envelope.payload?.requestId === "string"
+			? envelope.payload.requestId.trim()
+			: "";
+	const pending = ctx.pendingCapabilityRequests.get(requestId);
+	if (!pending) {
+		return errorReply(
+			envelope,
+			"capability_not_found",
+			`Unknown capability request: ${requestId}`,
+		);
+	}
+	const responderClientId = envelope.clientId?.trim() || "";
+	if (responderClientId !== pending.targetClientId) {
+		return errorReply(
+			envelope,
+			"capability_wrong_client",
+			`Capability request ${requestId} is owned by ${pending.targetClientId}`,
+		);
+	}
+	if (
+		envelope.sessionId?.trim() &&
+		envelope.sessionId.trim() !== pending.sessionId
+	) {
+		return errorReply(
+			envelope,
+			"capability_wrong_session",
+			`Capability request ${requestId} belongs to session ${pending.sessionId}`,
+		);
+	}
+	ctx.pendingCapabilityRequests.delete(requestId);
+	const payload =
+		envelope.payload?.payload &&
+		typeof envelope.payload.payload === "object" &&
+		!Array.isArray(envelope.payload.payload)
+			? (envelope.payload.payload as Record<string, unknown>)
+			: undefined;
+	const error =
+		typeof envelope.payload?.error === "string"
+			? envelope.payload.error
+			: undefined;
+	const ok = envelope.payload?.ok === true;
+	logHubMessage(ok ? "info" : "warn", "capability.respond", {
+		requestId,
+		sessionId: pending.sessionId,
+		capabilityName: pending.capabilityName,
+		targetClientId: pending.targetClientId,
+		respondedByClientId: responderClientId,
+		ok,
+		error,
+	});
+	pending.resolve({ ok, payload, error });
+	ctx.publish(
+		ctx.buildEvent(
+			"capability.resolved",
+			{
+				requestId,
+				capabilityName: pending.capabilityName,
+				targetClientId: pending.targetClientId,
+				respondedByClientId: responderClientId,
+				ok,
+				payload,
+				error,
+			},
+			pending.sessionId,
+		),
+	);
+	return okReply(envelope, { requestId, ok });
+}
diff --git a/sdk/packages/core/src/hub/server/handlers/client-handlers.ts b/sdk/packages/core/src/hub/server/handlers/client-handlers.ts
new file mode 100644
index 0000000..1b37258
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/client-handlers.ts
@@ -0,0 +1,86 @@
+import type {
+	HubClientRegistration,
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+} from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import {
+	asPlainRecord,
+	errorReply,
+	type HubTransportContext,
+	okReply,
+} from "./context";
+
+export function handleClientRegister(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): HubReplyEnvelope {
+	const payload = envelope.payload as HubClientRegistration | undefined;
+	const clientId =
+		payload?.clientId?.trim() ||
+		envelope.clientId?.trim() ||
+		createSessionId("client_");
+	ctx.clients.set(clientId, {
+		clientId,
+		clientType: payload?.clientType ?? "unknown",
+		displayName: payload?.displayName,
+		actorKind: payload?.actorKind ?? "client",
+		connectedAt: Date.now(),
+		lastSeenAt: Date.now(),
+		transport: payload?.transport ?? "native",
+		capabilities: payload?.capabilities ?? [],
+		metadata: payload?.metadata,
+		workspaceContext: payload?.workspaceContext,
+	});
+	ctx.publish(
+		ctx.buildEvent("hub.client.registered", {
+			clientId,
+			clientType: payload?.clientType ?? "unknown",
+			displayName: payload?.displayName,
+			connectedAt: Date.now(),
+		}),
+	);
+	return okReply(envelope, { clientId });
+}
+
+export function handleClientUpdate(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): HubReplyEnvelope {
+	const clientId = envelope.clientId?.trim();
+	const client = clientId ? ctx.clients.get(clientId) : undefined;
+	if (!clientId || !client) {
+		return errorReply(
+			envelope,
+			"client_not_found",
+			"Client is not registered with this hub.",
+		);
+	}
+	const metadata = asPlainRecord(envelope.payload?.metadata);
+	client.lastSeenAt = Date.now();
+	if (metadata) {
+		client.metadata = JSON.parse(JSON.stringify(metadata));
+	}
+	return okReply(envelope);
+}
+
+export function handleClientUnregister(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+	onClientRemoved: (clientId: string) => void,
+): HubReplyEnvelope {
+	const clientId = envelope.clientId?.trim();
+	if (clientId) {
+		ctx.clients.delete(clientId);
+		onClientRemoved(clientId);
+		ctx.publish(ctx.buildEvent("hub.client.disconnected", { clientId }));
+	}
+	return okReply(envelope);
+}
+
+export function handleClientList(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): HubReplyEnvelope {
+	return okReply(envelope, { clients: [...ctx.clients.values()] });
+}
diff --git a/sdk/packages/core/src/hub/server/handlers/connector-handlers.test.ts b/sdk/packages/core/src/hub/server/handlers/connector-handlers.test.ts
new file mode 100644
index 0000000..293d96d
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/connector-handlers.test.ts
@@ -0,0 +1,259 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { HubCommandEnvelope } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { __test__, handleConnectorCommand } from "./connector-handlers";
+import type { HubTransportContext } from "./context";
+
+describe("connector hub handlers", () => {
+	const previousDataDir = process.env.CLINE_DATA_DIR;
+	const tempRoots: string[] = [];
+
+	afterEach(() => {
+		process.env.CLINE_DATA_DIR = previousDataDir;
+		for (const root of tempRoots.splice(0)) {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	function useTempDataDir(): string {
+		const root = mkdtempSync(join(tmpdir(), "hub-connectors-"));
+		tempRoots.push(root);
+		process.env.CLINE_DATA_DIR = root;
+		return root;
+	}
+
+	function createHubContext(
+		telemetry = { capture: vi.fn() },
+	): HubTransportContext {
+		return {
+			clients: new Map(),
+			sessionState: new Map(),
+			pendingApprovals: new Map(),
+			pendingCapabilityRequests: new Map(),
+			suppressNextTerminalEventBySession: new Map(),
+			telemetry: telemetry as never,
+			sessionHost: {} as never,
+			publish: vi.fn(),
+			buildEvent: vi.fn() as never,
+			requestCapability: vi.fn() as never,
+		};
+	}
+
+	function connectorCommand(
+		command: HubCommandEnvelope["command"],
+		payload?: Record<string, unknown>,
+	): HubCommandEnvelope {
+		return {
+			version: "v1",
+			requestId: `req-${command}`,
+			command,
+			payload,
+		};
+	}
+
+	function readPersistedConnectorValues(
+		channel: string,
+	): Record<string, string> {
+		const persisted = JSON.parse(
+			readFileSync(__test__.resolveConnectorSettingsPath(), "utf8"),
+		) as {
+			connectors: Record<string, { values: Record<string, string> }>;
+		};
+		return persisted.connectors[channel]?.values ?? {};
+	}
+
+	it("configures a connector through hub settings without starting it", () => {
+		useTempDataDir();
+
+		const response = __test__.configureConnector({
+			channel: "telegram",
+			values: { "-k": "123456:fake-token" },
+			security: { enabled: true, values: { userId: "123456789" } },
+		});
+
+		expect(response.active).toEqual([]);
+		expect(response.configured).toEqual([
+			expect.objectContaining({ id: "telegram", type: "telegram" }),
+		]);
+
+		const persisted = JSON.parse(
+			readFileSync(__test__.resolveConnectorSettingsPath(), "utf8"),
+		) as {
+			connectors: {
+				telegram: {
+					values: Record<string, string>;
+					security: { enabled: boolean; values: Record<string, string> };
+				};
+			};
+		};
+		expect(persisted.connectors.telegram.values["-k"]).toBe(
+			"123456:fake-token",
+		);
+		expect(persisted.connectors.telegram.security).toEqual({
+			enabled: true,
+			values: { userId: "123456789" },
+		});
+	});
+
+	it("validates security fields before persisting connector settings", () => {
+		useTempDataDir();
+
+		expect(() =>
+			__test__.configureConnector({
+				channel: "telegram",
+				values: { "-k": "123456:fake-token" },
+				security: { enabled: true, values: { userId: "not-a-number" } },
+			}),
+		).toThrow("Telegram user ID must contain digits only");
+		expect(__test__.connectorChannelsPayload().configured).toEqual([]);
+	});
+
+	it("deletes a connector config and removes an empty settings file", () => {
+		useTempDataDir();
+
+		__test__.configureConnector({
+			channel: "telegram",
+			values: { "-k": "123456:fake-token" },
+		});
+		__test__.configureConnector({
+			channel: "slack",
+			values: {
+				"--bot-token": "xoxb-token",
+				"--base-url": "",
+				"--app-token": "xapp-token",
+			},
+		});
+
+		const deleteTelegram = __test__.deleteConnectorConfig({
+			channel: "telegram",
+		});
+		expect(deleteTelegram.configured).toEqual([
+			expect.objectContaining({ id: "slack", type: "slack" }),
+		]);
+
+		const persisted = JSON.parse(
+			readFileSync(__test__.resolveConnectorSettingsPath(), "utf8"),
+		) as {
+			connectors: Record<string, unknown>;
+		};
+		expect(persisted.connectors).not.toHaveProperty("telegram");
+		expect(persisted.connectors).toHaveProperty("slack");
+
+		const deleteSlack = __test__.deleteConnectorConfig({ channel: "slack" });
+		expect(deleteSlack.configured).toEqual([]);
+		expect(existsSync(__test__.resolveConnectorSettingsPath())).toBe(false);
+	});
+
+	it("validates only included conditional connector fields", () => {
+		useTempDataDir();
+
+		expect(() =>
+			__test__.configureConnector({
+				channel: "slack",
+				values: {
+					"--bot-token": "xoxb-token",
+					"--base-url": "",
+					"--app-token": "xapp-token",
+				},
+			}),
+		).not.toThrow();
+
+		expect(() =>
+			__test__.configureConnector({
+				channel: "slack",
+				values: {
+					"--bot-token": "xoxb-token",
+					"--base-url": "https://example.com",
+				},
+			}),
+		).toThrow("Signing secret is required");
+	});
+
+	it("persists only active Slack fields for the selected mode", () => {
+		useTempDataDir();
+
+		__test__.configureConnector({
+			channel: "slack",
+			values: {
+				"--bot-token": "xoxb-token",
+				"--base-url": "",
+				"--app-token": "xapp-token",
+				"--signing-secret": "stale-signing-secret",
+			},
+		});
+		expect(readPersistedConnectorValues("slack")).toEqual({
+			"--bot-token": "xoxb-token",
+			"--base-url": "",
+			"--app-token": "xapp-token",
+		});
+
+		__test__.configureConnector({
+			channel: "slack",
+			values: {
+				"--bot-token": "xoxb-token",
+				"--base-url": "https://hooks.example.com",
+				"--signing-secret": "signing-secret",
+				"--app-token": "stale-app-token",
+			},
+		});
+		expect(readPersistedConnectorValues("slack")).toEqual({
+			"--bot-token": "xoxb-token",
+			"--base-url": "https://hooks.example.com",
+			"--signing-secret": "signing-secret",
+		});
+	});
+
+	it("emits telemetry for state-mutating connector command outcomes", async () => {
+		useTempDataDir();
+		const telemetry = { capture: vi.fn() };
+		const ctx = createHubContext(telemetry);
+
+		await handleConnectorCommand(
+			ctx,
+			connectorCommand("connector.configure", {
+				channel: "telegram",
+				values: { "-k": "123456:fake-token" },
+			}),
+		);
+		await handleConnectorCommand(
+			ctx,
+			connectorCommand("connector.delete_config", { channel: "telegram" }),
+		);
+		await handleConnectorCommand(
+			ctx,
+			connectorCommand("connector.configure", {
+				channel: "telegram",
+				values: {},
+			}),
+		);
+		await handleConnectorCommand(ctx, connectorCommand("connector.channels"));
+
+		expect(telemetry.capture).toHaveBeenCalledTimes(3);
+		expect(telemetry.capture).toHaveBeenNthCalledWith(1, {
+			event: "task.tool_used",
+			properties: {
+				ulid: "req-connector.configure",
+				tool: "connector.configure",
+				success: true,
+			},
+		});
+		expect(telemetry.capture).toHaveBeenNthCalledWith(2, {
+			event: "task.tool_used",
+			properties: {
+				ulid: "req-connector.delete_config",
+				tool: "connector.delete_config",
+				success: true,
+			},
+		});
+		expect(telemetry.capture).toHaveBeenNthCalledWith(3, {
+			event: "task.tool_used",
+			properties: {
+				ulid: "req-connector.configure",
+				tool: "connector.configure",
+				success: false,
+			},
+		});
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/handlers/connector-handlers.ts b/sdk/packages/core/src/hub/server/handlers/connector-handlers.ts
new file mode 100644
index 0000000..4fb872b
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/connector-handlers.ts
@@ -0,0 +1,447 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import type {
+	ActiveConnectorRecord,
+	ConfiguredConnectorRecord,
+	ConnectorChannelsResponse,
+	ConnectorFieldDef,
+	ConnectorPlatformDef,
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+} from "@cline/shared";
+import {
+	CONNECTOR_PLATFORMS,
+	connectorChannelsFromPlatforms,
+	listConnectorCatalog,
+	shouldIncludeConnectorField,
+} from "@cline/shared";
+import {
+	resolveConnectorDataDir,
+	resolveConnectorSettingsPath,
+} from "@cline/shared/storage";
+import { captureToolUsage } from "../../../services/telemetry/core-events";
+import { errorReply, type HubTransportContext, okReply } from "./context";
+
+type ConnectorSettingsEntry = {
+	type: string;
+	values: Record<string, string>;
+	security?: {
+		enabled: boolean;
+		values: Record<string, string>;
+	};
+	configuredAt: string;
+	updatedAt: string;
+};
+
+type ConnectorSettingsFile = {
+	version: 1;
+	connectors: Record<string, ConnectorSettingsEntry>;
+};
+
+type ConnectorFieldKey = keyof Omit<
+	ActiveConnectorRecord,
+	"id" | "type" | "pid" | "hubUrl"
+>;
+
+const CONNECTOR_SETTINGS_VERSION = 1;
+
+const connectorFieldExtractors: Record<
+	ConnectorFieldKey,
+	(p: Record<string, unknown>) => string | number | undefined
+> = {
+	startedAt: (p) => (typeof p.startedAt === "string" ? p.startedAt : undefined),
+	port: (p) => (typeof p.port === "number" ? p.port : undefined),
+	baseUrl: (p) => (typeof p.baseUrl === "string" ? p.baseUrl : undefined),
+	connectionMode: (p) =>
+		typeof p.connectionMode === "string" ? p.connectionMode : undefined,
+	userName: (p) => (typeof p.userName === "string" ? p.userName : undefined),
+	botUsername: (p) =>
+		typeof p.botUsername === "string" ? p.botUsername : undefined,
+	applicationId: (p) =>
+		typeof p.applicationId === "string" ? p.applicationId : undefined,
+	phoneNumberId: (p) =>
+		typeof p.phoneNumberId === "string" ? p.phoneNumberId : undefined,
+};
+
+const connectorActiveStateConfigs: Record<
+	string,
+	{ required: ConnectorFieldKey[]; optional: ConnectorFieldKey[] }
+> = {
+	discord: {
+		required: ["userName", "applicationId"],
+		optional: ["startedAt", "port", "baseUrl"],
+	},
+	telegram: { required: ["botUsername"], optional: ["startedAt"] },
+	gchat: { required: ["userName"], optional: ["startedAt", "port", "baseUrl"] },
+	linear: {
+		required: ["userName"],
+		optional: ["startedAt", "port", "baseUrl"],
+	},
+	slack: {
+		required: ["userName"],
+		optional: ["startedAt", "connectionMode", "port", "baseUrl"],
+	},
+	whatsapp: {
+		required: ["userName"],
+		optional: ["startedAt", "phoneNumberId", "port", "baseUrl"],
+	},
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" ? value.trim() : undefined;
+}
+
+function readJsonRecord(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+		return isRecord(parsed) ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function readConnectorSettings(): ConnectorSettingsFile {
+	const parsed = readJsonRecord(resolveConnectorSettingsPath());
+	const connectors = isRecord(parsed?.connectors) ? parsed.connectors : {};
+	const normalized: Record<string, ConnectorSettingsEntry> = {};
+	for (const [id, value] of Object.entries(connectors)) {
+		if (!isRecord(value)) {
+			continue;
+		}
+		const type = asString(value.type);
+		const configuredAt = asString(value.configuredAt);
+		const updatedAt = asString(value.updatedAt);
+		if (!type || !configuredAt || !updatedAt) {
+			continue;
+		}
+		const values = normalizeStringRecord(value.values);
+		const security = isRecord(value.security)
+			? {
+					enabled: value.security.enabled === true,
+					values: normalizeStringRecord(value.security.values),
+				}
+			: undefined;
+		normalized[id] = { type, values, security, configuredAt, updatedAt };
+	}
+	return { version: CONNECTOR_SETTINGS_VERSION, connectors: normalized };
+}
+
+function writeConnectorSettings(settings: ConnectorSettingsFile): void {
+	const path = resolveConnectorSettingsPath();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+
+function normalizeStringRecord(value: unknown): Record<string, string> {
+	if (!isRecord(value)) {
+		return {};
+	}
+	const entries: Record<string, string> = {};
+	for (const [key, raw] of Object.entries(value)) {
+		if (typeof raw === "string") {
+			entries[key] = raw.trim();
+		}
+	}
+	return entries;
+}
+
+function isProcessRunning(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function listConnectorStatePaths(type: string): string[] {
+	const dir = join(resolveConnectorDataDir(), type);
+	if (!existsSync(dir)) {
+		return [];
+	}
+	return readdirSync(dir)
+		.filter((name) => name.endsWith(".json") && !name.endsWith(".threads.json"))
+		.map((name) => join(dir, name));
+}
+
+function connectorRecordId(
+	type: string,
+	fields: Partial<
+		Omit<ActiveConnectorRecord, "id" | "type" | "pid" | "hubUrl">
+	>,
+	pid: number,
+): string {
+	const identity =
+		fields.botUsername ??
+		fields.userName ??
+		fields.applicationId ??
+		fields.phoneNumberId ??
+		String(pid);
+	return `${type}:${identity}`;
+}
+
+function readActiveConnectorRecord(
+	type: string,
+	statePath: string,
+): ActiveConnectorRecord | undefined {
+	const parsed = readJsonRecord(statePath);
+	if (!parsed) {
+		return undefined;
+	}
+	const pid = typeof parsed.pid === "number" ? parsed.pid : undefined;
+	const hubUrl =
+		typeof parsed.hubUrl === "string"
+			? parsed.hubUrl
+			: typeof parsed.rpcAddress === "string"
+				? parsed.rpcAddress
+				: undefined;
+	if (!pid || !hubUrl || !isProcessRunning(pid)) {
+		return undefined;
+	}
+	const config = connectorActiveStateConfigs[type];
+	if (!config) {
+		return undefined;
+	}
+	const fields: Partial<
+		Omit<ActiveConnectorRecord, "id" | "type" | "pid" | "hubUrl">
+	> = {};
+	for (const key of config.required) {
+		const value = connectorFieldExtractors[key](parsed);
+		if (!value || (typeof value === "string" && !value.trim())) {
+			return undefined;
+		}
+		(fields as Record<string, unknown>)[key] = value;
+	}
+	for (const key of config.optional) {
+		const value = connectorFieldExtractors[key](parsed);
+		if (value !== undefined) {
+			(fields as Record<string, unknown>)[key] = value;
+		}
+	}
+	return {
+		id: connectorRecordId(type, fields, pid),
+		type,
+		pid,
+		hubUrl,
+		...fields,
+	} as ActiveConnectorRecord;
+}
+
+function listActiveConnectors(): ActiveConnectorRecord[] {
+	const records: ActiveConnectorRecord[] = [];
+	for (const { name } of listConnectorCatalog()) {
+		for (const statePath of listConnectorStatePaths(name)) {
+			const record = readActiveConnectorRecord(name, statePath);
+			if (record) {
+				records.push(record);
+			}
+		}
+	}
+	return records.sort((left, right) => {
+		if (left.type !== right.type) {
+			return left.type.localeCompare(right.type);
+		}
+		const leftName = left.botUsername ?? left.userName ?? "";
+		const rightName = right.botUsername ?? right.userName ?? "";
+		return leftName.localeCompare(rightName);
+	});
+}
+
+function listConfiguredConnectors(): ConfiguredConnectorRecord[] {
+	const settings = readConnectorSettings();
+	return Object.entries(settings.connectors)
+		.map(([id, entry]) => ({
+			id,
+			type: entry.type,
+			configuredAt: entry.configuredAt,
+			updatedAt: entry.updatedAt,
+		}))
+		.sort((left, right) => left.type.localeCompare(right.type));
+}
+
+function connectorChannelsPayload(): ConnectorChannelsResponse {
+	return {
+		available: connectorChannelsFromPlatforms(),
+		active: listActiveConnectors(),
+		configured: listConfiguredConnectors(),
+	};
+}
+
+function validateRequiredField(
+	field: ConnectorFieldDef,
+	values: Record<string, string>,
+): void {
+	if (field.required && !values[field.flag]?.trim()) {
+		throw new Error(`${field.label} is required`);
+	}
+}
+
+function buildActiveConnectorFieldValues(
+	platform: ConnectorPlatformDef,
+	values: Record<string, string>,
+): Record<string, string> {
+	const fieldValues: Record<string, string> = {};
+	for (const field of platform.fields) {
+		fieldValues[field.flag] = values[field.flag] ?? field.initialValue ?? "";
+	}
+
+	const activeFieldValues: Record<string, string> = {};
+	for (const field of platform.fields) {
+		if (!shouldIncludeConnectorField(field, fieldValues)) {
+			continue;
+		}
+		validateRequiredField(field, fieldValues);
+		activeFieldValues[field.flag] = fieldValues[field.flag];
+	}
+	return activeFieldValues;
+}
+
+function configureConnector(payload: unknown): ConnectorChannelsResponse {
+	if (!isRecord(payload)) {
+		throw new Error("connector.configure payload must be an object.");
+	}
+	const channel = asString(payload.channel);
+	if (!channel) {
+		throw new Error("channel is required");
+	}
+	const platform = CONNECTOR_PLATFORMS.find((entry) => entry.id === channel);
+	if (!platform) {
+		throw new Error(`unknown connector channel: ${channel}`);
+	}
+	const supported = new Set(listConnectorCatalog().map((entry) => entry.name));
+	if (!supported.has(platform.id)) {
+		throw new Error(`connector channel is not available: ${channel}`);
+	}
+
+	const values = normalizeStringRecord(payload.values);
+	const fieldValues = buildActiveConnectorFieldValues(platform, values);
+
+	const securityInput = isRecord(payload.security) ? payload.security : {};
+	const securityEnabled = securityInput.enabled === true;
+	const securityValues = normalizeStringRecord(securityInput.values);
+	if (securityEnabled && platform.security) {
+		for (const field of platform.security.fields) {
+			const value = securityValues[field.key];
+			if (!value) {
+				throw new Error(field.requiredMessage);
+			}
+			const validationError = field.validate?.(value);
+			if (validationError) {
+				throw new Error(validationError);
+			}
+		}
+	}
+
+	const settings = readConnectorSettings();
+	const now = new Date().toISOString();
+	const existing = settings.connectors[channel];
+	settings.connectors[channel] = {
+		type: channel,
+		values: fieldValues,
+		security: securityEnabled
+			? { enabled: true, values: securityValues }
+			: { enabled: false, values: {} },
+		configuredAt: existing?.configuredAt ?? now,
+		updatedAt: now,
+	};
+	writeConnectorSettings(settings);
+	return connectorChannelsPayload();
+}
+
+function deleteConnectorConfig(payload: unknown): ConnectorChannelsResponse {
+	if (!isRecord(payload)) {
+		throw new Error("connector.delete_config payload must be an object.");
+	}
+	const channel = asString(payload.channel);
+	if (!channel) {
+		throw new Error("channel is required");
+	}
+	const settings = readConnectorSettings();
+	delete settings.connectors[channel];
+	if (Object.keys(settings.connectors).length > 0) {
+		writeConnectorSettings(settings);
+	} else {
+		rmSync(resolveConnectorSettingsPath(), { force: true });
+	}
+	return connectorChannelsPayload();
+}
+
+function isStateMutatingConnectorCommand(
+	command: HubCommandEnvelope["command"],
+) {
+	return (
+		command === "connector.configure" || command === "connector.delete_config"
+	);
+}
+
+function captureConnectorCommandUsage(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+	success: boolean,
+): void {
+	if (!isStateMutatingConnectorCommand(envelope.command)) {
+		return;
+	}
+	captureToolUsage(ctx.telemetry, {
+		ulid: envelope.sessionId ?? envelope.requestId ?? "hub",
+		tool: envelope.command,
+		success,
+	});
+}
+
+export async function handleConnectorCommand(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	try {
+		if (envelope.command === "connector.channels") {
+			return okReply(envelope, connectorChannelsPayload());
+		}
+		if (envelope.command === "connector.configure") {
+			const payload = configureConnector(envelope.payload);
+			captureConnectorCommandUsage(ctx, envelope, true);
+			return okReply(envelope, payload);
+		}
+		if (envelope.command === "connector.delete_config") {
+			const payload = deleteConnectorConfig(envelope.payload);
+			captureConnectorCommandUsage(ctx, envelope, true);
+			return okReply(envelope, payload);
+		}
+		return errorReply(
+			envelope,
+			"unsupported_connector_command",
+			`unsupported connector command: ${envelope.command}`,
+		);
+	} catch (error) {
+		captureConnectorCommandUsage(ctx, envelope, false);
+		return errorReply(
+			envelope,
+			"connector_command_failed",
+			error instanceof Error ? error.message : String(error),
+		);
+	}
+}
+
+export const __test__ = {
+	configureConnector,
+	connectorChannelsPayload,
+	deleteConnectorConfig,
+	resolveConnectorSettingsPath,
+};
diff --git a/sdk/packages/core/src/hub/server/handlers/context.ts b/sdk/packages/core/src/hub/server/handlers/context.ts
new file mode 100644
index 0000000..40794aa
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/context.ts
@@ -0,0 +1,257 @@
+import type {
+	HubClientRecord,
+	HubCommandEnvelope,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+	SessionRecord as HubSessionRecord,
+	ITelemetryService,
+	JsonValue,
+	SessionParticipant,
+} from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import type {
+	PendingPromptsRuntimeService,
+	RuntimeHost,
+	SessionConnectionRuntimeService,
+	SessionUsageRuntimeService,
+} from "../../../runtime/host/runtime-host";
+import {
+	type CoreSessionSnapshot,
+	createCoreSessionSnapshot,
+} from "../../../session/session-snapshot";
+import {
+	type HubSessionState,
+	toHubSessionRecord,
+} from "../hub-session-records";
+
+export type PendingApproval = {
+	sessionId: string;
+	resolve: (result: { approved: boolean; reason?: string }) => void;
+};
+
+export type PendingCapabilityRequest = {
+	sessionId: string;
+	targetClientId: string;
+	capabilityName: string;
+	onProgress?: (payload: Record<string, unknown>) => void;
+	resolve: (result: {
+		ok: boolean;
+		payload?: Record<string, unknown>;
+		error?: string;
+	}) => void;
+};
+
+/**
+ * Shared mutable state and helpers passed to every command-handler module.
+ * The transport class owns the maps; handlers get a stable read/write surface.
+ */
+export interface HubTransportContext {
+	readonly clients: Map<string, HubClientRecord>;
+	readonly sessionState: Map<string, HubSessionState>;
+	readonly pendingApprovals: Map<string, PendingApproval>;
+	readonly pendingCapabilityRequests: Map<string, PendingCapabilityRequest>;
+	readonly suppressNextTerminalEventBySession: Map<string, string>;
+	readonly telemetry?: ITelemetryService;
+	readonly sessionHost: RuntimeHost &
+		Partial<
+			PendingPromptsRuntimeService &
+				SessionUsageRuntimeService &
+				SessionConnectionRuntimeService
+		>;
+	publish(event: HubEventEnvelope): void;
+	buildEvent(
+		event: HubEventEnvelope["event"],
+		payload?: Record<string, unknown>,
+		sessionId?: string,
+	): HubEventEnvelope;
+	requestCapability(
+		sessionId: string,
+		capabilityName: string,
+		payload: Record<string, unknown>,
+		targetClientId: string,
+		onProgress?: (payload: Record<string, unknown>) => void,
+	): Promise<Record<string, unknown> | undefined>;
+}
+
+type EnvelopeRef = Pick<HubCommandEnvelope, "version" | "requestId">;
+
+export function okReply(
+	envelope: EnvelopeRef,
+	payload?: HubReplyEnvelope["payload"],
+): HubReplyEnvelope {
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId,
+		ok: true,
+		...(payload !== undefined ? { payload } : {}),
+	};
+}
+
+export function errorReply(
+	envelope: EnvelopeRef,
+	code: string,
+	message: string,
+): HubReplyEnvelope {
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId,
+		ok: false,
+		error: { code, message },
+	};
+}
+
+/** Returns the value when it's a plain object, or undefined otherwise. */
+export function asPlainRecord(
+	value: unknown,
+): Record<string, JsonValue | undefined> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, JsonValue | undefined>)
+		: undefined;
+}
+
+/**
+ * Pulls the session id from the envelope. Handlers accept either
+ * `payload.sessionId` (top-level command argument) or `envelope.sessionId`
+ * (envelope-level addressing). Returns "" when neither is present so handlers
+ * can branch on truthiness.
+ */
+export function extractSessionId(envelope: HubCommandEnvelope): string {
+	if (typeof envelope.payload?.sessionId === "string") {
+		return envelope.payload.sessionId.trim();
+	}
+	return envelope.sessionId?.trim() ?? "";
+}
+
+export function buildHubEvent(
+	event: HubEventEnvelope["event"],
+	payload?: Record<string, unknown>,
+	sessionId?: string,
+): HubEventEnvelope {
+	return {
+		version: "v1",
+		event,
+		eventId: createSessionId("hevt_"),
+		sessionId,
+		timestamp: Date.now(),
+		payload,
+	};
+}
+
+export async function readHubSessionRecord(
+	ctx: HubTransportContext,
+	sessionId: string,
+): Promise<HubSessionRecord | undefined> {
+	const session = await ctx.sessionHost.getSession(sessionId);
+	if (!session) {
+		return undefined;
+	}
+	const usageSummary = await ctx.sessionHost.getAccumulatedUsage?.(sessionId);
+	return toHubSessionRecord(
+		session,
+		ctx.sessionState.get(sessionId),
+		usageSummary?.usage,
+		usageSummary?.aggregateUsage,
+	);
+}
+
+export async function readCoreSessionSnapshot(
+	ctx: HubTransportContext,
+	sessionId: string,
+): Promise<CoreSessionSnapshot | undefined> {
+	const session = await ctx.sessionHost.getSession(sessionId);
+	if (!session) {
+		return undefined;
+	}
+	const [messages, usageSummary] = await Promise.all([
+		typeof ctx.sessionHost.readSessionMessages === "function"
+			? ctx.sessionHost.readSessionMessages(sessionId)
+			: [],
+		ctx.sessionHost.getAccumulatedUsage?.(sessionId),
+	]);
+	return createCoreSessionSnapshot({
+		session,
+		messages,
+		usage: usageSummary?.usage,
+		aggregateUsage: usageSummary?.aggregateUsage,
+	});
+}
+
+export function ensureSessionState(
+	ctx: HubTransportContext,
+	sessionId: string,
+	clientId: string,
+	role: SessionParticipant["role"],
+	options: { interactive?: boolean } = {},
+): HubSessionState {
+	const existing = ctx.sessionState.get(sessionId);
+	if (existing) {
+		if (options.interactive !== undefined) {
+			existing.interactive = options.interactive;
+		}
+		if (role === "creator" && !existing.createdByClientId) {
+			existing.createdByClientId = clientId;
+		}
+		if (!existing.participants.has(clientId)) {
+			existing.participants.set(clientId, {
+				clientId,
+				attachedAt: Date.now(),
+				role,
+			});
+		}
+		return existing;
+	}
+	const state: HubSessionState = {
+		createdByClientId: clientId,
+		interactive: options.interactive ?? true,
+		participants: new Map([
+			[
+				clientId,
+				{
+					clientId,
+					attachedAt: Date.now(),
+					role,
+				},
+			],
+		]),
+	};
+	ctx.sessionState.set(sessionId, state);
+	return state;
+}
+
+export function ensureSessionParticipant(
+	ctx: HubTransportContext,
+	sessionId: string,
+	clientId: string,
+	role: SessionParticipant["role"],
+	options: { interactive?: boolean } = {},
+): HubSessionState {
+	const existing = ctx.sessionState.get(sessionId);
+	if (existing) {
+		if (options.interactive !== undefined) {
+			existing.interactive = options.interactive;
+		}
+		if (!existing.participants.has(clientId)) {
+			existing.participants.set(clientId, {
+				clientId,
+				attachedAt: Date.now(),
+				role,
+			});
+		}
+		return existing;
+	}
+	const state: HubSessionState = {
+		interactive: options.interactive ?? true,
+		participants: new Map([
+			[
+				clientId,
+				{
+					clientId,
+					attachedAt: Date.now(),
+					role,
+				},
+			],
+		]),
+	};
+	ctx.sessionState.set(sessionId, state);
+	return state;
+}
diff --git a/sdk/packages/core/src/hub/server/handlers/run-handlers.test.ts b/sdk/packages/core/src/hub/server/handlers/run-handlers.test.ts
new file mode 100644
index 0000000..968eaf4
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/run-handlers.test.ts
@@ -0,0 +1,186 @@
+import type { HubEventEnvelope } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { RuntimeHost } from "../../../runtime/host/runtime-host";
+import { buildHubEvent, type HubTransportContext } from "./context";
+import { handleRunAbort, handleSessionInput } from "./run-handlers";
+
+function createContext(
+	overrides: Partial<RuntimeHost> = {},
+): HubTransportContext & { events: HubEventEnvelope[] } {
+	const events: HubEventEnvelope[] = [];
+	return {
+		clients: new Map(),
+		sessionState: new Map(),
+		pendingApprovals: new Map(),
+		pendingCapabilityRequests: new Map(),
+		suppressNextTerminalEventBySession: new Map(),
+		sessionHost: {
+			startSession: vi.fn(),
+			runTurn: vi.fn(),
+			restoreSession: vi.fn(),
+			abort: vi.fn().mockResolvedValue(undefined),
+			stopSession: vi.fn(),
+			dispose: vi.fn(),
+			getSession: vi.fn(),
+			listSessions: vi.fn(),
+			...overrides,
+		} as RuntimeHost,
+		publish: (event) => {
+			events.push(event);
+		},
+		buildEvent: buildHubEvent,
+		requestCapability: vi.fn(),
+		events,
+	};
+}
+
+describe("run handlers", () => {
+	afterEach(() => {
+		vi.useRealTimers();
+		vi.restoreAllMocks();
+	});
+
+	it("aborts through the runtime host when a run timeout is configured", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		const abort = vi.fn().mockResolvedValue(undefined);
+		const ctx = createContext({
+			runTurn: vi.fn(() => new Promise<undefined>(() => {})),
+			abort,
+		});
+
+		const promise = handleSessionInput(ctx, {
+			version: "v1",
+			command: "run.start",
+			requestId: "req-timeout",
+			sessionId: "session-1",
+			payload: {
+				sessionId: "session-1",
+				prompt: "go",
+				timeoutMs: 50,
+			},
+		});
+		const expectation = expect(promise).rejects.toThrow(
+			"Hub run run.start timed out after 50ms.",
+		);
+
+		await vi.advanceTimersByTimeAsync(51);
+
+		await expectation;
+		expect(abort).toHaveBeenCalledWith(
+			"session-1",
+			"Hub run run.start timed out after 50ms.",
+		);
+		expect(ctx.events).toContainEqual(
+			expect.objectContaining({
+				event: "run.failed",
+				payload: expect.objectContaining({
+					error: "Hub run run.start timed out after 50ms.",
+				}),
+			}),
+		);
+	});
+
+	it("rejects promptly when timeout abort remains pending", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		let resolveAbort: (() => void) | undefined;
+		const abort = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					resolveAbort = resolve;
+				}),
+		);
+		const ctx = createContext({
+			runTurn: vi.fn(() => new Promise<undefined>(() => {})),
+			abort,
+		});
+
+		let rejection: string | undefined;
+		const promise = handleSessionInput(ctx, {
+			version: "v1",
+			command: "run.start",
+			requestId: "req-timeout-prompt",
+			sessionId: "session-1",
+			payload: {
+				sessionId: "session-1",
+				prompt: "go",
+				timeoutMs: 50,
+			},
+		}).catch((error: unknown) => {
+			rejection = error instanceof Error ? error.message : String(error);
+		});
+
+		await vi.advanceTimersByTimeAsync(51);
+
+		expect(rejection).toBe("Hub run run.start timed out after 50ms.");
+		expect(abort).toHaveBeenCalledWith(
+			"session-1",
+			"Hub run run.start timed out after 50ms.",
+		);
+
+		resolveAbort?.();
+		await promise;
+	});
+
+	it("publishes heartbeat events while a run remains pending", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		let resolveRun: ((result: undefined) => void) | undefined;
+		const ctx = createContext({
+			runTurn: vi.fn(
+				() =>
+					new Promise<undefined>((resolve) => {
+						resolveRun = resolve;
+					}),
+			),
+		});
+
+		const promise = handleSessionInput(ctx, {
+			version: "v1",
+			command: "run.start",
+			requestId: "req-heartbeat",
+			sessionId: "session-1",
+			payload: { sessionId: "session-1", prompt: "go" },
+		});
+
+		await vi.advanceTimersByTimeAsync(30_001);
+
+		expect(ctx.events).toContainEqual(
+			expect.objectContaining({
+				event: "run.heartbeat",
+				sessionId: "session-1",
+				payload: expect.objectContaining({
+					requestId: "req-heartbeat",
+					elapsedMs: expect.any(Number),
+				}),
+			}),
+		);
+
+		resolveRun?.(undefined);
+		await expect(promise).resolves.toMatchObject({ ok: true });
+	});
+
+	it("treats abort as applied when the runtime abort hook rejects", async () => {
+		const abort = vi.fn().mockRejectedValue(new Error("Run aborted"));
+		const ctx = createContext({ abort });
+
+		const reply = await handleRunAbort(ctx, {
+			version: "v1",
+			command: "run.abort",
+			requestId: "req-abort",
+			clientId: "client-1",
+			sessionId: "session-1",
+			payload: {
+				sessionId: "session-1",
+				reason: "user cancelled",
+			},
+		});
+
+		expect(reply).toMatchObject({
+			ok: true,
+			payload: { applied: true },
+		});
+		expect(abort).toHaveBeenCalledWith("session-1", "user cancelled");
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/handlers/run-handlers.ts b/sdk/packages/core/src/hub/server/handlers/run-handlers.ts
new file mode 100644
index 0000000..e22a85f
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/run-handlers.ts
@@ -0,0 +1,337 @@
+import type {
+	AgentMode,
+	AgentResult,
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+} from "@cline/shared";
+import { parseHookEventPayload } from "../../../hooks";
+import {
+	isSessionNotFoundError,
+	SESSION_NOT_FOUND_ERROR_CODE,
+	type SendSessionInput,
+} from "../../../runtime/host/runtime-host";
+import { logHubMessage } from "../hub-server-logging";
+import { cancelPendingApprovals } from "./approval-handlers";
+import { cancelPendingCapabilityRequests } from "./capability-handlers";
+import {
+	errorReply,
+	extractSessionId,
+	type HubTransportContext,
+	okReply,
+	readCoreSessionSnapshot,
+} from "./context";
+
+const HUB_RUN_HEARTBEAT_MS = 30_000;
+
+function terminalRunEventForReason(
+	reason: string,
+): "run.aborted" | "run.completed" | "run.failed" {
+	if (reason === "aborted") return "run.aborted";
+	if (reason === "error" || reason === "failed") return "run.failed";
+	return "run.completed";
+}
+
+function errorMessageForResult(result: AgentResult): string | undefined {
+	if (result.finishReason !== "error") {
+		return undefined;
+	}
+	const text = result.text.trim();
+	return text || undefined;
+}
+
+function sessionNotFoundReply(
+	envelope: HubCommandEnvelope,
+	sessionId: string,
+	error?: unknown,
+): HubReplyEnvelope {
+	const message =
+		error instanceof Error && error.message.trim()
+			? error.message
+			: `Unknown session: ${sessionId}`;
+	return errorReply(envelope, SESSION_NOT_FOUND_ERROR_CODE, message);
+}
+
+function parseTurnMode(mode?: unknown): AgentMode | undefined {
+	// Unknown truthy values flow through and formatModePrompt treats them as act.
+	return mode ? (mode as AgentMode) : undefined;
+}
+
+function parseRunTimeoutMs(
+	payload: Record<string, unknown>,
+): number | undefined {
+	const timeoutMs =
+		typeof payload.timeoutMs === "number"
+			? payload.timeoutMs
+			: typeof payload.timeout_ms === "number"
+				? payload.timeout_ms
+				: undefined;
+	if (timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+		return Math.floor(timeoutMs);
+	}
+	const timeoutSeconds =
+		typeof payload.timeoutSeconds === "number"
+			? payload.timeoutSeconds
+			: typeof payload.timeout_seconds === "number"
+				? payload.timeout_seconds
+				: undefined;
+	if (timeoutSeconds && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0) {
+		return Math.floor(timeoutSeconds * 1000);
+	}
+	return undefined;
+}
+
+async function runTurnWithRuntimeHealth(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+	input: SendSessionInput,
+	timeoutMs: number | undefined,
+): Promise<AgentResult | undefined> {
+	const startedAt = performance.now();
+	let settled = false;
+	const baseContext = {
+		command: envelope.command,
+		requestId: envelope.requestId,
+		clientId: envelope.clientId,
+		sessionId: input.sessionId,
+		timeoutMs,
+	};
+	const heartbeat = setInterval(() => {
+		if (settled) return;
+		const elapsedMs = Math.round(performance.now() - startedAt);
+		logHubMessage("warn", "run.heartbeat", {
+			...baseContext,
+			elapsedMs,
+		});
+		ctx.publish(
+			ctx.buildEvent(
+				"run.heartbeat",
+				{
+					requestId: envelope.requestId,
+					elapsedMs,
+					...(timeoutMs ? { timeoutMs } : {}),
+				},
+				input.sessionId,
+			),
+		);
+	}, HUB_RUN_HEARTBEAT_MS);
+	const runPromise = ctx.sessionHost.runTurn(input);
+	runPromise.then(
+		(result) => {
+			if (!settled) return;
+			logHubMessage("warn", "run.late_end", {
+				...baseContext,
+				elapsedMs: Math.round(performance.now() - startedAt),
+				finishReason: result?.finishReason,
+			});
+		},
+		(error) => {
+			if (!settled) return;
+			logHubMessage("error", "run.late_error", {
+				...baseContext,
+				elapsedMs: Math.round(performance.now() - startedAt),
+				error,
+			});
+		},
+	);
+	let timeout: ReturnType<typeof setTimeout> | undefined;
+	try {
+		if (!timeoutMs) {
+			return await runPromise;
+		}
+		return await Promise.race([
+			runPromise,
+			new Promise<never>((_, reject) => {
+				timeout = setTimeout(() => {
+					const reason = `Hub run ${envelope.command} timed out after ${timeoutMs}ms.`;
+					settled = true;
+					clearInterval(heartbeat);
+					reject(new Error(reason));
+					logHubMessage("error", "run.timeout", {
+						...baseContext,
+						elapsedMs: Math.round(performance.now() - startedAt),
+					});
+					cancelPendingApprovals(
+						ctx,
+						(approval) => approval.sessionId === input.sessionId,
+						reason,
+					);
+					cancelPendingCapabilityRequests(
+						ctx,
+						(request) => request.sessionId === input.sessionId,
+						reason,
+					);
+					void ctx.sessionHost.abort(input.sessionId, reason).catch((error) => {
+						logHubMessage("error", "run.timeout_abort_failed", {
+							...baseContext,
+							error,
+						});
+					});
+				}, timeoutMs);
+			}),
+		]);
+	} finally {
+		settled = true;
+		clearInterval(heartbeat);
+		if (timeout) clearTimeout(timeout);
+	}
+}
+
+export async function handleSessionInput(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const payload =
+		envelope.payload && typeof envelope.payload === "object"
+			? envelope.payload
+			: {};
+	const prompt =
+		typeof payload.prompt === "string"
+			? payload.prompt
+			: typeof payload.input === "string"
+				? payload.input
+				: "";
+	if (!prompt.trim()) {
+		return errorReply(
+			envelope,
+			"invalid_session_input",
+			"session input requires a prompt string",
+		);
+	}
+	ctx.publish(ctx.buildEvent("run.started", undefined, sessionId));
+	const attachments =
+		payload.attachments &&
+		typeof payload.attachments === "object" &&
+		!Array.isArray(payload.attachments)
+			? (payload.attachments as Record<string, unknown>)
+			: undefined;
+	const userFiles = Array.isArray(attachments?.userFiles)
+		? attachments.userFiles.filter((filePath) => typeof filePath === "string")
+		: undefined;
+	const timeoutMs = parseRunTimeoutMs(payload);
+	ctx.suppressNextTerminalEventBySession.set(sessionId, "run.start.reply");
+	let result: AgentResult | undefined;
+	try {
+		result = await runTurnWithRuntimeHealth(
+			ctx,
+			envelope,
+			{
+				sessionId,
+				prompt,
+				mode: parseTurnMode(payload.mode),
+				delivery:
+					payload.delivery === "queue" || payload.delivery === "steer"
+						? payload.delivery
+						: undefined,
+				userImages: Array.isArray(attachments?.userImages)
+					? (attachments.userImages as string[])
+					: undefined,
+				userFiles,
+				timeoutMs,
+			},
+			timeoutMs,
+		);
+	} catch (error) {
+		if (
+			ctx.suppressNextTerminalEventBySession.get(sessionId) ===
+			"run.start.reply"
+		) {
+			ctx.suppressNextTerminalEventBySession.delete(sessionId);
+		}
+		if (isSessionNotFoundError(error)) {
+			return sessionNotFoundReply(envelope, sessionId, error);
+		}
+		ctx.publish(
+			ctx.buildEvent(
+				"run.failed",
+				{
+					reason: "error",
+					error: error instanceof Error ? error.message : String(error),
+				},
+				sessionId,
+			),
+		);
+		throw error;
+	}
+	if (result) {
+		const snapshot = await readCoreSessionSnapshot(ctx, sessionId);
+		const error = errorMessageForResult(result);
+		ctx.publish(
+			ctx.buildEvent(
+				terminalRunEventForReason(result.finishReason),
+				{
+					reason: result.finishReason,
+					...(error ? { error } : {}),
+					result,
+					...(snapshot ? { snapshot } : {}),
+				},
+				sessionId,
+			),
+		);
+		if (
+			ctx.suppressNextTerminalEventBySession.get(sessionId) ===
+			"run.start.reply"
+		) {
+			ctx.suppressNextTerminalEventBySession.delete(sessionId);
+		}
+	} else {
+		ctx.suppressNextTerminalEventBySession.delete(sessionId);
+	}
+	const snapshot = await readCoreSessionSnapshot(ctx, sessionId);
+	return okReply(
+		envelope,
+		result || snapshot
+			? { ...(result ? { result } : {}), ...(snapshot ? { snapshot } : {}) }
+			: undefined,
+	);
+}
+
+export async function handleRunAbort(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const reason =
+		typeof envelope.payload?.reason === "string"
+			? envelope.payload.reason
+			: "Run was aborted before pending approval or capability request was resolved.";
+	cancelPendingApprovals(
+		ctx,
+		(approval) => approval.sessionId === sessionId,
+		reason,
+	);
+	try {
+		await ctx.sessionHost.abort(sessionId, envelope.payload?.reason);
+	} catch (error) {
+		logHubMessage("warn", "run.abort_failed", {
+			command: envelope.command,
+			requestId: envelope.requestId,
+			clientId: envelope.clientId,
+			sessionId,
+			error,
+		});
+	} finally {
+		cancelPendingCapabilityRequests(
+			ctx,
+			(request) => request.sessionId === sessionId,
+			reason,
+		);
+	}
+	return okReply(envelope, { applied: true });
+}
+
+export async function handleSessionHook(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const parsed = parseHookEventPayload(envelope.payload?.payload);
+	if (!parsed) {
+		return errorReply(
+			envelope,
+			"invalid_hook_payload",
+			"session.hook requires a valid hook event payload",
+		);
+	}
+	await ctx.sessionHost.dispatchHookEvent(parsed);
+	return okReply(envelope, { applied: true });
+}
diff --git a/sdk/packages/core/src/hub/server/handlers/session-event-projector.ts b/sdk/packages/core/src/hub/server/handlers/session-event-projector.ts
new file mode 100644
index 0000000..6f41c8d
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/session-event-projector.ts
@@ -0,0 +1,357 @@
+import type { TeamProgressProjectionEvent } from "@cline/shared";
+import type { SessionUsageSummary } from "../../../runtime/host/runtime-host";
+import type {
+	CoreSessionEvent,
+	SessionPendingPrompt,
+} from "../../../types/events";
+import { buildCompletionNotification } from "../hub-notifications";
+import {
+	type HubTransportContext,
+	readCoreSessionSnapshot,
+	readHubSessionRecord,
+} from "./context";
+
+/**
+ * Translates internal `CoreSessionEvent`s emitted by the session host into the
+ * outward-facing `HubEventEnvelope` stream.
+ */
+export async function projectSessionEvent(
+	ctx: HubTransportContext,
+	event: CoreSessionEvent,
+): Promise<void> {
+	switch (event.type) {
+		case "chunk":
+			// Ignore raw agent chunks here. In this runtime they can contain
+			// serialized event envelopes rather than user-facing assistant text.
+			// Structured live content is forwarded via the "agent_event" branch.
+			return;
+		case "agent_event":
+			await projectAgentEvent(ctx, event);
+			return;
+		case "hook":
+			if (event.payload.hookEventName === "tool_call") {
+				ctx.publish(
+					ctx.buildEvent(
+						"tool.started",
+						{ toolName: event.payload.toolName },
+						event.payload.sessionId,
+					),
+				);
+			} else if (event.payload.hookEventName === "tool_result") {
+				ctx.publish(
+					ctx.buildEvent(
+						"tool.finished",
+						{ toolName: event.payload.toolName },
+						event.payload.sessionId,
+					),
+				);
+			}
+			return;
+		case "team_progress": {
+			const projection: TeamProgressProjectionEvent = {
+				type: "team_progress_projection",
+				version: 1,
+				sessionId: event.payload.sessionId,
+				summary: event.payload.summary,
+				lastEvent: event.payload.lifecycle,
+			};
+			ctx.publish(
+				ctx.buildEvent(
+					"team.progress",
+					projection as unknown as Record<string, unknown>,
+					event.payload.sessionId,
+				),
+			);
+			return;
+		}
+		case "pending_prompts":
+			ctx.publish(
+				ctx.buildEvent(
+					"session.pending_prompts",
+					{
+						sessionId: event.payload.sessionId,
+						prompts: event.payload.prompts,
+					},
+					event.payload.sessionId,
+				),
+			);
+			return;
+		case "pending_prompt_submitted": {
+			const prompt: SessionPendingPrompt = {
+				id: event.payload.id,
+				prompt: event.payload.prompt,
+				delivery: event.payload.delivery,
+				attachmentCount: event.payload.attachmentCount,
+				userImages: event.payload.userImages,
+				userFiles: event.payload.userFiles,
+			};
+			ctx.publish(
+				ctx.buildEvent(
+					"session.pending_prompt_submitted",
+					{ sessionId: event.payload.sessionId, prompt },
+					event.payload.sessionId,
+				),
+			);
+			return;
+		}
+		case "session_snapshot":
+			ctx.publish(
+				ctx.buildEvent(
+					"session.updated",
+					{
+						sessionId: event.payload.sessionId,
+						snapshot: event.payload.snapshot,
+					},
+					event.payload.sessionId,
+				),
+			);
+			return;
+		case "status": {
+			const [session, snapshot] = await Promise.all([
+				readHubSessionRecord(ctx, event.payload.sessionId),
+				readCoreSessionSnapshot(ctx, event.payload.sessionId),
+			]);
+			if (session) {
+				ctx.publish(
+					ctx.buildEvent(
+						"session.updated",
+						{ session, ...(snapshot ? { snapshot } : {}) },
+						event.payload.sessionId,
+					),
+				);
+			}
+			return;
+		}
+		case "ended":
+			await projectSessionEnded(ctx, event);
+			return;
+		default:
+			return;
+	}
+}
+
+async function projectAgentEvent(
+	ctx: HubTransportContext,
+	event: Extract<CoreSessionEvent, { type: "agent_event" }>,
+): Promise<void> {
+	const { sessionId, event: agentEvent } = event.payload;
+	if (agentEvent.type === "iteration_start") {
+		ctx.publish(
+			ctx.buildEvent(
+				"iteration.started",
+				{ iteration: agentEvent.iteration },
+				sessionId,
+			),
+		);
+		return;
+	}
+	if (agentEvent.type === "iteration_end") {
+		ctx.publish(
+			ctx.buildEvent(
+				"iteration.finished",
+				{
+					iteration: agentEvent.iteration,
+					hadToolCalls: agentEvent.hadToolCalls,
+					toolCallCount: agentEvent.toolCallCount,
+				},
+				sessionId,
+			),
+		);
+		return;
+	}
+	if (agentEvent.type === "content_start") {
+		if (
+			agentEvent.contentType === "text" &&
+			typeof agentEvent.text === "string" &&
+			agentEvent.text.length > 0
+		) {
+			ctx.publish(
+				ctx.buildEvent("assistant.delta", { text: agentEvent.text }, sessionId),
+			);
+			return;
+		}
+		if (agentEvent.contentType === "reasoning") {
+			if (agentEvent.redacted && !agentEvent.reasoning) {
+				ctx.publish(
+					ctx.buildEvent(
+						"reasoning.delta",
+						{ text: "", redacted: true },
+						sessionId,
+					),
+				);
+				return;
+			}
+			if (
+				typeof agentEvent.reasoning === "string" &&
+				agentEvent.reasoning.length > 0
+			) {
+				ctx.publish(
+					ctx.buildEvent(
+						"reasoning.delta",
+						{
+							text: agentEvent.reasoning,
+							redacted: agentEvent.redacted === true,
+						},
+						sessionId,
+					),
+				);
+			}
+			return;
+		}
+		if (agentEvent.contentType === "tool") {
+			ctx.publish(
+				ctx.buildEvent(
+					"tool.started",
+					{
+						toolCallId: agentEvent.toolCallId,
+						toolName: agentEvent.toolName,
+						input: agentEvent.input,
+					},
+					sessionId,
+				),
+			);
+			return;
+		}
+	}
+	if (agentEvent.type === "content_end") {
+		switch (agentEvent.contentType) {
+			case "text":
+				ctx.publish(
+					ctx.buildEvent(
+						"assistant.finished",
+						{ text: agentEvent.text },
+						sessionId,
+					),
+				);
+				break;
+			case "reasoning":
+				ctx.publish(
+					ctx.buildEvent(
+						"reasoning.finished",
+						{ reasoning: agentEvent.reasoning },
+						sessionId,
+					),
+				);
+				break;
+			case "tool":
+				ctx.publish(
+					ctx.buildEvent(
+						"tool.finished",
+						{
+							toolCallId: agentEvent.toolCallId,
+							toolName: agentEvent.toolName,
+							output: agentEvent.output,
+							error: agentEvent.error,
+						},
+						sessionId,
+					),
+				);
+				break;
+		}
+		return;
+	}
+	if (agentEvent.type === "usage") {
+		let usageSummary: SessionUsageSummary | undefined;
+		try {
+			usageSummary = await ctx.sessionHost.getAccumulatedUsage?.(sessionId);
+		} catch {
+			usageSummary = undefined;
+		}
+		ctx.publish(
+			ctx.buildEvent(
+				"usage.updated",
+				{
+					sessionId,
+					delta: {
+						inputTokens: agentEvent.inputTokens,
+						outputTokens: agentEvent.outputTokens,
+						cacheReadTokens: agentEvent.cacheReadTokens ?? 0,
+						cacheWriteTokens: agentEvent.cacheWriteTokens ?? 0,
+						totalCost: agentEvent.cost ?? 0,
+					},
+					totals: {
+						inputTokens: agentEvent.totalInputTokens,
+						outputTokens: agentEvent.totalOutputTokens,
+						cacheReadTokens: agentEvent.totalCacheReadTokens ?? 0,
+						cacheWriteTokens: agentEvent.totalCacheWriteTokens ?? 0,
+						totalCost: agentEvent.totalCost ?? 0,
+					},
+					usage: usageSummary?.usage,
+					aggregateUsage: usageSummary?.aggregateUsage,
+					agent: {
+						kind:
+							event.payload.teamRole === "teammate"
+								? "teammate"
+								: agentEvent.parentAgentId
+									? "subagent"
+									: "lead",
+						agentId: agentEvent.agentId,
+						conversationId: agentEvent.conversationId,
+						parentAgentId: agentEvent.parentAgentId,
+						teamAgentId: event.payload.teamAgentId,
+						teamRole: event.payload.teamRole,
+					},
+				},
+				sessionId,
+			),
+		);
+		return;
+	}
+	if (agentEvent.type === "done") {
+		ctx.publish(
+			ctx.buildEvent(
+				"agent.done",
+				{
+					reason: agentEvent.reason,
+					text: agentEvent.text,
+					iterations: agentEvent.iterations,
+					usage: agentEvent.usage,
+				},
+				sessionId,
+			),
+		);
+	}
+}
+
+async function projectSessionEnded(
+	ctx: HubTransportContext,
+	event: Extract<CoreSessionEvent, { type: "ended" }>,
+): Promise<void> {
+	// `run.start` publishes the result-bearing terminal event after `send`
+	// returns. The local runtime emits `ended` synchronously during that send, so
+	// this token suppresses the earlier projector event. If session events move
+	// to an async transport, terminal-event correlation must move with them.
+	const suppressToken = ctx.suppressNextTerminalEventBySession.get(
+		event.payload.sessionId,
+	);
+	const suppressDuplicateTerminalEvent =
+		suppressToken === event.payload.reason ||
+		suppressToken === "run.start.reply";
+	if (suppressDuplicateTerminalEvent) {
+		ctx.suppressNextTerminalEventBySession.delete(event.payload.sessionId);
+	}
+	const [session, snapshot] = await Promise.all([
+		readHubSessionRecord(ctx, event.payload.sessionId),
+		readCoreSessionSnapshot(ctx, event.payload.sessionId),
+	]);
+	if (event.payload.reason === "completed") {
+		const notification = await buildCompletionNotification(session);
+		ctx.publish(
+			ctx.buildEvent("ui.notify", notification, event.payload.sessionId),
+		);
+	}
+	if (suppressDuplicateTerminalEvent) {
+		return;
+	}
+	ctx.publish(
+		ctx.buildEvent(
+			event.payload.reason === "aborted"
+				? "run.aborted"
+				: event.payload.reason === "error" || event.payload.reason === "failed"
+					? "run.failed"
+					: "run.completed",
+			{ reason: event.payload.reason, ...(snapshot ? { snapshot } : {}) },
+			event.payload.sessionId,
+		),
+	);
+}
diff --git a/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts b/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts
new file mode 100644
index 0000000..df952ae
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { readSessionConnectionUpdate } from "./session-handlers";
+
+describe("readSessionConnectionUpdate", () => {
+	it("enables thinking when a positive budget is supplied without thinking", () => {
+		expect(readSessionConnectionUpdate({ thinkingBudgetTokens: 2048 })).toEqual(
+			{
+				thinking: true,
+				thinkingBudgetTokens: 2048,
+			},
+		);
+	});
+
+	it("lets explicit thinking disable override reasoning fields", () => {
+		const updates = readSessionConnectionUpdate({
+			thinking: false,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 2048,
+		});
+
+		expect(updates.thinking).toBe(false);
+		expect(Object.hasOwn(updates, "reasoningEffort")).toBe(true);
+		expect(updates.reasoningEffort).toBeUndefined();
+		expect(Object.hasOwn(updates, "thinkingBudgetTokens")).toBe(true);
+		expect(updates.thinkingBudgetTokens).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/handlers/session-handlers.ts b/sdk/packages/core/src/hub/server/handlers/session-handlers.ts
new file mode 100644
index 0000000..0cc9d6b
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/handlers/session-handlers.ts
@@ -0,0 +1,1087 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	JsonValue,
+	ToolApprovalRequest,
+} from "@cline/shared";
+import { createSessionId, parseRuntimeConfigExtensions } from "@cline/shared";
+import { normalizeConnectionUpdate } from "../../../runtime/config/connection-update";
+import type {
+	RuntimeSessionConfig,
+	SessionConnectionUpdate,
+} from "../../../runtime/host/runtime-host";
+import { parseSessionCompactionState } from "../../../session/models/session-compaction";
+import {
+	SessionVersioningError,
+	SessionVersioningService,
+} from "../../../session/session-versioning-service";
+import {
+	createHubClientContributionRuntime,
+	parseHubClientContributions,
+} from "../hub-client-contributions";
+import { logHubMessage } from "../hub-server-logging";
+import { toHubSessionRecord } from "../hub-session-records";
+import { cancelPendingCapabilityRequests } from "./capability-handlers";
+import {
+	asPlainRecord,
+	ensureSessionParticipant,
+	ensureSessionState,
+	errorReply,
+	extractSessionId,
+	type HubTransportContext,
+	okReply,
+	readCoreSessionSnapshot,
+	readHubSessionRecord,
+} from "./context";
+
+const CAPABILITY_OWNER_METADATA_KEY = "hubCapabilityOwnerClientId";
+
+function readConnectionString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim().length > 0
+		? value.trim()
+		: undefined;
+}
+
+function readConnectionReasoningEffort(
+	value: unknown,
+): SessionConnectionUpdate["reasoningEffort"] | undefined {
+	if (
+		value === "low" ||
+		value === "medium" ||
+		value === "high" ||
+		value === "xhigh" ||
+		value === null
+	) {
+		return value;
+	}
+	return undefined;
+}
+
+export function readSessionConnectionUpdate(
+	value: unknown,
+): SessionConnectionUpdate {
+	const record = asPlainRecord(value) ?? {};
+	const updates: SessionConnectionUpdate = {};
+	const providerId = readConnectionString(record.providerId);
+	if (providerId) updates.providerId = providerId;
+	const modelId = readConnectionString(record.modelId);
+	if (modelId) updates.modelId = modelId;
+	const apiKey = readConnectionString(record.apiKey);
+	if (apiKey !== undefined) updates.apiKey = apiKey;
+	const baseUrl = readConnectionString(record.baseUrl);
+	if (baseUrl !== undefined) updates.baseUrl = baseUrl;
+	if (record.headers && typeof record.headers === "object") {
+		updates.headers = record.headers as Record<string, string>;
+	}
+	if (record.providerConfig && typeof record.providerConfig === "object") {
+		updates.providerConfig =
+			record.providerConfig as unknown as SessionConnectionUpdate["providerConfig"];
+	}
+	if (Object.hasOwn(record, "thinking")) {
+		if (typeof record.thinking === "boolean" || record.thinking === null) {
+			updates.thinking = record.thinking;
+		}
+	}
+	if (Object.hasOwn(record, "reasoningEffort")) {
+		const reasoningEffort = readConnectionReasoningEffort(
+			record.reasoningEffort,
+		);
+		if (reasoningEffort !== undefined) {
+			updates.reasoningEffort = reasoningEffort;
+		}
+	}
+	if (Object.hasOwn(record, "thinkingBudgetTokens")) {
+		if (
+			typeof record.thinkingBudgetTokens === "number" &&
+			Number.isFinite(record.thinkingBudgetTokens) &&
+			record.thinkingBudgetTokens > 0
+		) {
+			updates.thinkingBudgetTokens = Math.trunc(record.thinkingBudgetTokens);
+		} else if (record.thinkingBudgetTokens === null) {
+			updates.thinkingBudgetTokens = null;
+		}
+	}
+	return normalizeConnectionUpdate(updates);
+}
+
+function getCapabilityOwnerClientId(
+	ctx: HubTransportContext,
+	sessionId: string,
+): string | undefined {
+	// Sidecar access follows the live hub owner, not persisted metadata clients
+	// can replay or edit.
+	return ctx.sessionState.get(sessionId)?.createdByClientId;
+}
+
+function stripServerOwnedSessionMetadata(
+	metadata: Record<string, JsonValue | undefined> | undefined,
+): Record<string, JsonValue | undefined> | undefined {
+	// Clients may echo old records back through session.update; keep ownership
+	// on the live hub state only.
+	if (!metadata || !(CAPABILITY_OWNER_METADATA_KEY in metadata)) {
+		return metadata;
+	}
+	const sanitized = { ...metadata };
+	delete sanitized[CAPABILITY_OWNER_METADATA_KEY];
+	return sanitized;
+}
+
+function authorizeSessionCompactionAccess(input: {
+	sessionId: string;
+	ctx: HubTransportContext;
+	clientId: string;
+	envelope: HubCommandEnvelope;
+}): HubReplyEnvelope | undefined {
+	const ownerClientId = getCapabilityOwnerClientId(input.ctx, input.sessionId);
+	if (!ownerClientId) {
+		return errorReply(
+			input.envelope,
+			"session_wrong_client",
+			`Session ${input.sessionId} has no owner`,
+		);
+	}
+	if (ownerClientId !== input.clientId) {
+		return errorReply(
+			input.envelope,
+			"session_wrong_client",
+			`Session ${input.sessionId} is owned by ${ownerClientId}`,
+		);
+	}
+	return undefined;
+}
+
+export async function handleSessionCreate(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+	requestToolApproval: (
+		request: ToolApprovalRequest,
+	) => Promise<{ approved: boolean; reason?: string }>,
+): Promise<HubReplyEnvelope> {
+	const startedAt = performance.now();
+	const baseLogContext = {
+		command: envelope.command,
+		requestId: envelope.requestId,
+		clientId: envelope.clientId,
+		sessionId: envelope.sessionId,
+	};
+	logHubMessage("info", "session.create.begin", baseLogContext);
+	const payload =
+		envelope.payload && typeof envelope.payload === "object"
+			? envelope.payload
+			: {};
+	const metadata =
+		payload.metadata && typeof payload.metadata === "object"
+			? JSON.parse(JSON.stringify(payload.metadata))
+			: {};
+	const sessionConfig =
+		payload.sessionConfig && typeof payload.sessionConfig === "object"
+			? (JSON.parse(
+					JSON.stringify(payload.sessionConfig),
+				) as Partial<RuntimeSessionConfig>)
+			: undefined;
+	const runtimeOptions =
+		payload.runtimeOptions && typeof payload.runtimeOptions === "object"
+			? (payload.runtimeOptions as Record<string, unknown>)
+			: {};
+	const initialCompactionState = parseSessionCompactionState(
+		payload.initialCompactionState,
+	);
+	if (typeof sessionConfig?.mode === "string") {
+		metadata.mode = sessionConfig.mode;
+	} else if (typeof runtimeOptions.mode === "string") {
+		metadata.mode = runtimeOptions.mode;
+	}
+	if (typeof sessionConfig?.systemPrompt === "string") {
+		metadata.systemPrompt = sessionConfig.systemPrompt;
+	} else if (typeof runtimeOptions.systemPrompt === "string") {
+		metadata.systemPrompt = runtimeOptions.systemPrompt;
+	}
+	if (sessionConfig?.checkpoint?.enabled === true) {
+		metadata.checkpointEnabled = true;
+	} else if (runtimeOptions.checkpointEnabled === true) {
+		metadata.checkpointEnabled = true;
+	}
+	const modelSelection =
+		payload.modelSelection && typeof payload.modelSelection === "object"
+			? (payload.modelSelection as Record<string, unknown>)
+			: {};
+	const workspaceRoot =
+		typeof payload.workspaceRoot === "string" && payload.workspaceRoot.trim()
+			? payload.workspaceRoot.trim()
+			: typeof payload.cwd === "string" && payload.cwd.trim()
+				? payload.cwd.trim()
+				: "";
+	if (!workspaceRoot) {
+		logHubMessage("warn", "session.create.invalid", {
+			...baseLogContext,
+			reason: "missing_workspace_root",
+		});
+		return errorReply(
+			envelope,
+			"invalid_session_create",
+			"session.create requires workspaceRoot or cwd",
+		);
+	}
+	const clientId = envelope.clientId?.trim() || "hub-client";
+	const clientContributions = parseHubClientContributions(
+		runtimeOptions.clientContributions,
+	);
+	logHubMessage("info", "session.create.contributions_parsed", {
+		...baseLogContext,
+		clientId,
+		workspaceRoot,
+		cwd: typeof payload.cwd === "string" ? payload.cwd : undefined,
+		contributionCount: clientContributions.length,
+	});
+	const requestedSessionId =
+		typeof sessionConfig?.sessionId === "string"
+			? sessionConfig.sessionId.trim()
+			: "";
+	const sessionId = requestedSessionId || createSessionId();
+	const configExtensions = parseRuntimeConfigExtensions(
+		runtimeOptions.configExtensions,
+	);
+	logHubMessage("info", "session.create.runtime_build.begin", {
+		...baseLogContext,
+		sessionId,
+		configExtensionCount: configExtensions?.length ?? 0,
+	});
+	const clientContributionRuntime = createHubClientContributionRuntime({
+		sessionId,
+		targetClientId: clientId,
+		contributions: clientContributions,
+		sessionConfig,
+		requestCapability: ctx.requestCapability,
+	});
+	logHubMessage("info", "session.create.start_session.begin", {
+		...baseLogContext,
+		sessionId,
+		provider:
+			sessionConfig?.providerId ??
+			(typeof modelSelection.provider === "string"
+				? modelSelection.provider
+				: typeof metadata.provider === "string"
+					? metadata.provider
+					: "hub"),
+		model:
+			sessionConfig?.modelId ??
+			(typeof modelSelection.model === "string"
+				? modelSelection.model
+				: typeof metadata.model === "string"
+					? metadata.model
+					: "hub"),
+	});
+	const started = await ctx.sessionHost.startSession({
+		source: typeof metadata.source === "string" ? metadata.source : undefined,
+		interactive: metadata.interactive !== false,
+		sessionMetadata:
+			Object.keys(metadata as Record<string, unknown>).length > 0
+				? (metadata as Record<string, unknown>)
+				: undefined,
+		initialMessages: Array.isArray(payload.initialMessages)
+			? (payload.initialMessages as never[])
+			: undefined,
+		initialCompactionState,
+		localRuntime: {
+			modelCatalogDefaults: {
+				loadLatestOnInit: true,
+				loadPrivateOnAuth: true,
+			},
+			configExtensions,
+			...clientContributionRuntime.localRuntime,
+		},
+		capabilities: {
+			toolExecutors: clientContributionRuntime.toolExecutors,
+			requestToolApproval,
+		},
+		config: {
+			...(sessionConfig ?? {}),
+			sessionId,
+			providerId:
+				sessionConfig?.providerId ??
+				(typeof modelSelection.provider === "string"
+					? modelSelection.provider
+					: typeof metadata.provider === "string"
+						? metadata.provider
+						: "hub"),
+			modelId:
+				sessionConfig?.modelId ??
+				(typeof modelSelection.model === "string"
+					? modelSelection.model
+					: typeof metadata.model === "string"
+						? metadata.model
+						: "hub"),
+			apiKey:
+				sessionConfig?.apiKey ??
+				(typeof modelSelection.apiKey === "string"
+					? modelSelection.apiKey
+					: undefined),
+			cwd:
+				sessionConfig?.cwd ??
+				(typeof payload.cwd === "string" && payload.cwd.trim()
+					? payload.cwd.trim()
+					: workspaceRoot),
+			workspaceRoot: sessionConfig?.workspaceRoot ?? workspaceRoot,
+			systemPrompt:
+				sessionConfig?.systemPrompt ??
+				(typeof runtimeOptions.systemPrompt === "string"
+					? runtimeOptions.systemPrompt
+					: ""),
+			mode:
+				sessionConfig?.mode ??
+				(runtimeOptions.mode === "plan" || runtimeOptions.mode === "yolo"
+					? runtimeOptions.mode
+					: "act"),
+			maxIterations:
+				sessionConfig?.maxIterations ??
+				(typeof runtimeOptions.maxIterations === "number"
+					? runtimeOptions.maxIterations
+					: undefined),
+			enableTools:
+				sessionConfig?.enableTools ?? runtimeOptions.enableTools !== false,
+			enableSpawnAgent:
+				sessionConfig?.enableSpawnAgent ?? runtimeOptions.enableSpawn !== false,
+			enableAgentTeams:
+				sessionConfig?.enableAgentTeams ?? runtimeOptions.enableTeams !== false,
+			checkpoint:
+				sessionConfig?.checkpoint ??
+				(runtimeOptions.checkpointEnabled === true
+					? { enabled: true }
+					: undefined),
+			teamName:
+				sessionConfig?.teamName ??
+				(typeof metadata.teamName === "string" ? metadata.teamName : undefined),
+		},
+		toolPolicies:
+			payload.toolPolicies &&
+			typeof payload.toolPolicies === "object" &&
+			!Array.isArray(payload.toolPolicies)
+				? (JSON.parse(JSON.stringify(payload.toolPolicies)) as Record<
+						string,
+						{ autoApprove?: boolean; enabled?: boolean }
+					>)
+				: runtimeOptions.autoApproveTools === true
+					? { "*": { autoApprove: true } }
+					: undefined,
+	});
+	logHubMessage("info", "session.create.start_session.end", {
+		...baseLogContext,
+		sessionId: started.sessionId,
+		elapsedMs: Math.round(performance.now() - startedAt),
+		hasImmediateResult: !!started.result,
+	});
+	ensureSessionState(ctx, started.sessionId, clientId, "creator", {
+		interactive: metadata.interactive !== false,
+	});
+	logHubMessage("info", "session.create.read_records.begin", {
+		...baseLogContext,
+		sessionId: started.sessionId,
+	});
+	const [session, snapshot] = await Promise.all([
+		readHubSessionRecord(ctx, started.sessionId),
+		readCoreSessionSnapshot(ctx, started.sessionId),
+	]);
+	logHubMessage("info", "session.create.read_records.end", {
+		...baseLogContext,
+		sessionId: started.sessionId,
+		hasSession: !!session,
+		hasSnapshot: !!snapshot,
+		elapsedMs: Math.round(performance.now() - startedAt),
+	});
+	if (session) {
+		ctx.publish(
+			ctx.buildEvent(
+				"session.created",
+				{ session, ...(snapshot ? { snapshot } : {}) },
+				started.sessionId,
+			),
+		);
+	}
+	logHubMessage("info", "session.create.reply", {
+		...baseLogContext,
+		sessionId: started.sessionId,
+		elapsedMs: Math.round(performance.now() - startedAt),
+	});
+	return okReply(envelope, { session, ...(snapshot ? { snapshot } : {}) });
+}
+
+export async function handleSessionRestore(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+	requestToolApproval: (
+		request: ToolApprovalRequest,
+	) => Promise<{ approved: boolean; reason?: string }>,
+): Promise<HubReplyEnvelope> {
+	const payload =
+		envelope.payload && typeof envelope.payload === "object"
+			? envelope.payload
+			: {};
+	const sourceSessionId =
+		typeof payload.sessionId === "string"
+			? payload.sessionId.trim()
+			: envelope.sessionId?.trim() || "";
+	const checkpointRunCount = payload.checkpointRunCount;
+	if (!sourceSessionId) {
+		return errorReply(
+			envelope,
+			"invalid_restore",
+			"session.restore requires a session id",
+		);
+	}
+	const restoreOptions =
+		payload.restore && typeof payload.restore === "object"
+			? (payload.restore as Record<string, unknown>)
+			: {};
+	const restoreMessages = restoreOptions.messages !== false;
+	if (typeof checkpointRunCount !== "number") {
+		return errorReply(
+			envelope,
+			"invalid_restore",
+			"checkpointRunCount must be a positive integer",
+		);
+	}
+
+	try {
+		const sessionConfig =
+			payload.sessionConfig && typeof payload.sessionConfig === "object"
+				? (JSON.parse(
+						JSON.stringify(payload.sessionConfig),
+					) as Partial<RuntimeSessionConfig>)
+				: undefined;
+		if (restoreMessages && !sessionConfig) {
+			return errorReply(
+				envelope,
+				"invalid_restore",
+				"sessionConfig is required when restore.messages is true",
+			);
+		}
+		const runtimeOptions =
+			payload.runtimeOptions && typeof payload.runtimeOptions === "object"
+				? (payload.runtimeOptions as Record<string, unknown>)
+				: {};
+		const initialCompactionState = parseSessionCompactionState(
+			payload.initialCompactionState,
+		);
+		const metadata =
+			payload.metadata && typeof payload.metadata === "object"
+				? JSON.parse(JSON.stringify(payload.metadata))
+				: {};
+		if (typeof sessionConfig?.mode === "string") {
+			metadata.mode = sessionConfig.mode;
+		} else if (typeof runtimeOptions.mode === "string") {
+			metadata.mode = runtimeOptions.mode;
+		}
+		if (typeof sessionConfig?.systemPrompt === "string") {
+			metadata.systemPrompt = sessionConfig.systemPrompt;
+		} else if (typeof runtimeOptions.systemPrompt === "string") {
+			metadata.systemPrompt = runtimeOptions.systemPrompt;
+		}
+		if (sessionConfig?.checkpoint?.enabled === true) {
+			metadata.checkpointEnabled = true;
+		} else if (runtimeOptions.checkpointEnabled === true) {
+			metadata.checkpointEnabled = true;
+		}
+
+		const modelSelection =
+			payload.modelSelection && typeof payload.modelSelection === "object"
+				? (payload.modelSelection as Record<string, unknown>)
+				: {};
+		const clientId = envelope.clientId?.trim() || "hub-client";
+		const clientContributions = parseHubClientContributions(
+			runtimeOptions.clientContributions,
+		);
+		const requestedSessionId =
+			typeof sessionConfig?.sessionId === "string"
+				? sessionConfig.sessionId.trim()
+				: "";
+		const sessionId = requestedSessionId || createSessionId();
+		const configExtensions = parseRuntimeConfigExtensions(
+			runtimeOptions.configExtensions,
+		);
+		const clientContributionRuntime = createHubClientContributionRuntime({
+			sessionId,
+			targetClientId: clientId,
+			contributions: clientContributions,
+			sessionConfig,
+			requestCapability: ctx.requestCapability,
+		});
+		const service = new SessionVersioningService();
+		const result = await service.restoreCheckpoint({
+			sessionId: sourceSessionId,
+			checkpointRunCount,
+			restore: {
+				messages: restoreOptions.messages as boolean | undefined,
+				workspace: restoreOptions.workspace as boolean | undefined,
+				omitCheckpointMessageFromSession:
+					restoreOptions.omitCheckpointMessageFromSession === true,
+			},
+			start: sessionConfig,
+			cwd:
+				(typeof sessionConfig?.cwd === "string" && sessionConfig.cwd.trim()) ||
+				(typeof sessionConfig?.workspaceRoot === "string" &&
+					sessionConfig.workspaceRoot.trim()) ||
+				undefined,
+			getSession: (sessionId) => ctx.sessionHost.getSession(sessionId),
+			readMessages: (sessionId) =>
+				ctx.sessionHost.readSessionMessages(sessionId),
+			buildStartInput: (context) => {
+				if (context.restoredCheckpointMetadata) {
+					metadata.checkpoint = context.restoredCheckpointMetadata;
+				}
+				const workspaceRoot =
+					typeof payload.workspaceRoot === "string" &&
+					payload.workspaceRoot.trim()
+						? payload.workspaceRoot.trim()
+						: typeof payload.cwd === "string" && payload.cwd.trim()
+							? payload.cwd.trim()
+							: context.sourceSession.workspaceRoot ||
+								context.sourceSession.cwd;
+				return {
+					source:
+						typeof metadata.source === "string" ? metadata.source : undefined,
+					interactive: metadata.interactive !== false,
+					sessionMetadata: {
+						...metadata,
+						restoredFromSessionId: sourceSessionId,
+						restoredCheckpointRunCount: checkpointRunCount,
+					},
+					initialMessages: context.initialMessages,
+					initialCompactionState,
+					localRuntime: {
+						modelCatalogDefaults: {
+							loadLatestOnInit: true,
+							loadPrivateOnAuth: true,
+						},
+						configExtensions,
+						...clientContributionRuntime.localRuntime,
+					},
+					capabilities: {
+						toolExecutors: clientContributionRuntime.toolExecutors,
+						requestToolApproval,
+					},
+					config: {
+						...(sessionConfig ?? {}),
+						sessionId,
+						providerId:
+							sessionConfig?.providerId ??
+							(typeof modelSelection.provider === "string"
+								? modelSelection.provider
+								: context.sourceSession.provider),
+						modelId:
+							sessionConfig?.modelId ??
+							(typeof modelSelection.model === "string"
+								? modelSelection.model
+								: context.sourceSession.model),
+						apiKey:
+							sessionConfig?.apiKey ??
+							(typeof modelSelection.apiKey === "string"
+								? modelSelection.apiKey
+								: ""),
+						cwd: sessionConfig?.cwd ?? context.plan.cwd,
+						workspaceRoot: sessionConfig?.workspaceRoot ?? workspaceRoot,
+						systemPrompt:
+							sessionConfig?.systemPrompt ??
+							(typeof runtimeOptions.systemPrompt === "string"
+								? runtimeOptions.systemPrompt
+								: ""),
+						mode:
+							sessionConfig?.mode ??
+							(runtimeOptions.mode === "plan" || runtimeOptions.mode === "yolo"
+								? runtimeOptions.mode
+								: "act"),
+						maxIterations:
+							sessionConfig?.maxIterations ??
+							(typeof runtimeOptions.maxIterations === "number"
+								? runtimeOptions.maxIterations
+								: undefined),
+						enableTools:
+							sessionConfig?.enableTools ??
+							runtimeOptions.enableTools !== false,
+						enableSpawnAgent:
+							sessionConfig?.enableSpawnAgent ??
+							runtimeOptions.enableSpawn !== false,
+						enableAgentTeams:
+							sessionConfig?.enableAgentTeams ??
+							runtimeOptions.enableTeams !== false,
+						checkpoint:
+							sessionConfig?.checkpoint ??
+							(runtimeOptions.checkpointEnabled === true
+								? { enabled: true }
+								: undefined),
+						teamName:
+							sessionConfig?.teamName ??
+							(typeof metadata.teamName === "string"
+								? metadata.teamName
+								: undefined),
+					},
+					toolPolicies:
+						payload.toolPolicies &&
+						typeof payload.toolPolicies === "object" &&
+						!Array.isArray(payload.toolPolicies)
+							? (JSON.parse(JSON.stringify(payload.toolPolicies)) as Record<
+									string,
+									{ autoApprove?: boolean; enabled?: boolean }
+								>)
+							: runtimeOptions.autoApproveTools === true
+								? { "*": { autoApprove: true } }
+								: undefined,
+				};
+			},
+			startSession: (startInput) => ctx.sessionHost.startSession(startInput),
+			getStartedSessionId: (started) => started.sessionId,
+			readRestoredSession: (sessionId) => ctx.sessionHost.getSession(sessionId),
+		});
+		if (!restoreMessages) {
+			return okReply(envelope, { checkpoint: result.checkpoint });
+		}
+		const started = result.startResult;
+		if (!started) {
+			return errorReply(
+				envelope,
+				"restore_failed",
+				"Checkpoint restore did not start a session",
+			);
+		}
+		ensureSessionState(ctx, started.sessionId, clientId, "creator", {
+			interactive: metadata.interactive !== false,
+		});
+		const [session, snapshot] = await Promise.all([
+			readHubSessionRecord(ctx, started.sessionId),
+			readCoreSessionSnapshot(ctx, started.sessionId),
+		]);
+		if (session) {
+			ctx.publish(
+				ctx.buildEvent(
+					"session.created",
+					{ session, ...(snapshot ? { snapshot } : {}) },
+					started.sessionId,
+				),
+			);
+		}
+		return okReply(envelope, {
+			session,
+			...(snapshot ? { snapshot } : {}),
+			messages: result.messages ?? [],
+			checkpoint: result.checkpoint,
+		});
+	} catch (error) {
+		if (error instanceof SessionVersioningError) {
+			return errorReply(
+				envelope,
+				error.code,
+				error.code === "session_not_found"
+					? `Unknown session: ${sourceSessionId}`
+					: error.message,
+			);
+		}
+		return errorReply(
+			envelope,
+			"restore_failed",
+			error instanceof Error ? error.message : String(error),
+		);
+	}
+}
+
+export async function handleSessionAttach(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	if (!sessionId) {
+		return errorReply(
+			envelope,
+			"invalid_session_attach",
+			"session.attach requires a session id",
+		);
+	}
+	const session = await readHubSessionRecord(ctx, sessionId);
+	if (!session) {
+		return errorReply(
+			envelope,
+			"session_not_found",
+			`Unknown session: ${sessionId}`,
+		);
+	}
+	ensureSessionParticipant(
+		ctx,
+		sessionId,
+		envelope.clientId?.trim() || "hub-client",
+		"participant",
+	);
+	const attachedSession = await readHubSessionRecord(ctx, sessionId);
+	ctx.publish(
+		ctx.buildEvent(
+			"session.attached",
+			{ session: attachedSession ?? session },
+			sessionId,
+		),
+	);
+	return okReply(envelope, { session: attachedSession ?? session });
+}
+
+export async function handleSessionDetach(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	if (!sessionId) {
+		return errorReply(
+			envelope,
+			"invalid_session_detach",
+			"session.detach requires a session id",
+		);
+	}
+	const clientId = envelope.clientId?.trim() || "hub-client";
+	const state = ctx.sessionState.get(sessionId);
+	if (state) {
+		state.participants.delete(clientId);
+		if (state.createdByClientId === clientId) {
+			state.createdByClientId = undefined;
+		}
+		if (state.participants.size === 0) {
+			ctx.sessionState.delete(sessionId);
+		}
+	}
+	cancelPendingCapabilityRequests(
+		ctx,
+		(request) =>
+			request.sessionId === sessionId && request.targetClientId === clientId,
+		`Capability owner client ${clientId} detached before request was resolved.`,
+	);
+	const [session, snapshot] = await Promise.all([
+		readHubSessionRecord(ctx, sessionId),
+		readCoreSessionSnapshot(ctx, sessionId),
+	]);
+	ctx.publish(
+		ctx.buildEvent(
+			"session.detached",
+			session
+				? { session, ...(snapshot ? { snapshot } : {}), clientId }
+				: { clientId },
+			sessionId,
+		),
+	);
+	return okReply(envelope);
+}
+
+export async function handleSessionGet(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const includeSnapshot = envelope.payload?.includeSnapshot === true;
+	const [session, snapshot] = await Promise.all([
+		readHubSessionRecord(ctx, sessionId),
+		includeSnapshot
+			? readCoreSessionSnapshot(ctx, sessionId)
+			: Promise.resolve(undefined),
+	]);
+	return session
+		? okReply(envelope, { session, ...(snapshot ? { snapshot } : {}) })
+		: errorReply(
+				envelope,
+				"session_not_found",
+				`Unknown session: ${sessionId}`,
+			);
+}
+
+export async function handleSessionMessages(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	if (!sessionId) {
+		return errorReply(
+			envelope,
+			"invalid_session_id",
+			"session.messages requires a session id",
+		);
+	}
+	const session = await readHubSessionRecord(ctx, sessionId);
+	if (!session) {
+		return errorReply(
+			envelope,
+			"session_not_found",
+			`Unknown session: ${sessionId}`,
+		);
+	}
+	const messages = await ctx.sessionHost.readSessionMessages(sessionId);
+	return okReply(envelope, { sessionId, messages });
+}
+
+export async function handleSessionCompactionGet(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	if (!sessionId) {
+		return errorReply(
+			envelope,
+			"invalid_session_id",
+			"session.compaction.get requires a session id",
+		);
+	}
+	const session = await readHubSessionRecord(ctx, sessionId);
+	if (!session) {
+		return errorReply(
+			envelope,
+			"session_not_found",
+			`Unknown session: ${sessionId}`,
+		);
+	}
+	const clientId = envelope.clientId?.trim() || "hub-client";
+	const unauthorized = authorizeSessionCompactionAccess({
+		sessionId,
+		ctx,
+		clientId,
+		envelope,
+	});
+	if (unauthorized) {
+		return unauthorized;
+	}
+	const state = await ctx.sessionHost.readSessionCompactionState(sessionId);
+	return okReply(envelope, { sessionId, state });
+}
+
+export async function handleSessionList(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const limit =
+		typeof envelope.payload?.limit === "number" ? envelope.payload.limit : 200;
+	const records = await ctx.sessionHost.listSessions(limit);
+	const sessions = records.map((session) =>
+		toHubSessionRecord(session, ctx.sessionState.get(session.sessionId)),
+	);
+	return okReply(envelope, {
+		sessions,
+	});
+}
+
+export async function handleSessionUpdate(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const metadata = stripServerOwnedSessionMetadata(
+		asPlainRecord(envelope.payload?.metadata),
+	);
+	const updated = await ctx.sessionHost.updateSession(sessionId, { metadata });
+	const [session, snapshot] = await Promise.all([
+		readHubSessionRecord(ctx, sessionId),
+		readCoreSessionSnapshot(ctx, sessionId),
+	]);
+	if (session) {
+		ctx.publish(
+			ctx.buildEvent(
+				"session.updated",
+				{ session, ...(snapshot ? { snapshot } : {}) },
+				sessionId,
+			),
+		);
+	}
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId,
+		ok: updated.updated,
+		payload: {
+			updated: updated.updated,
+			session,
+			...(snapshot ? { snapshot } : {}),
+		},
+	};
+}
+
+export async function handleSessionUpdateConnection(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	if (!sessionId) {
+		return errorReply(
+			envelope,
+			"invalid_session_update_connection",
+			"session.update_connection requires a session id",
+		);
+	}
+	const updateSessionConnection = ctx.sessionHost.updateSessionConnection;
+	if (!updateSessionConnection) {
+		return errorReply(
+			envelope,
+			"unsupported_session_update_connection",
+			"runtime host does not support session connection updates",
+		);
+	}
+	const payload = asPlainRecord(envelope.payload);
+	const updates = readSessionConnectionUpdate(payload?.updates);
+	await updateSessionConnection.call(ctx.sessionHost, sessionId, updates);
+	return okReply(envelope, { sessionId, updated: true });
+}
+
+export async function handleSessionCompactionUpdate(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	if (!sessionId) {
+		return errorReply(
+			envelope,
+			"invalid_session_id",
+			"session.compaction.update requires a session id",
+		);
+	}
+	const clientId = envelope.clientId?.trim() || "hub-client";
+	const session = await readHubSessionRecord(ctx, sessionId);
+	if (!session) {
+		return errorReply(
+			envelope,
+			"session_not_found",
+			`Unknown session: ${sessionId}`,
+		);
+	}
+	const unauthorized = authorizeSessionCompactionAccess({
+		sessionId,
+		ctx,
+		clientId,
+		envelope,
+	});
+	if (unauthorized) {
+		return unauthorized;
+	}
+	const payload =
+		envelope.payload && typeof envelope.payload === "object"
+			? envelope.payload
+			: {};
+	const state = parseSessionCompactionState(payload.state);
+	if (!state) {
+		return errorReply(
+			envelope,
+			"invalid_compaction_state",
+			"session.compaction.update requires a valid compaction state",
+		);
+	}
+	const updated = await ctx.sessionHost.updateSessionCompactionState(
+		sessionId,
+		state,
+	);
+	const [updatedSession, snapshot] = updated.updated
+		? await Promise.all([
+				readHubSessionRecord(ctx, sessionId),
+				readCoreSessionSnapshot(ctx, sessionId),
+			])
+		: [session, undefined];
+	if (updated.updated) {
+		ctx.publish(
+			ctx.buildEvent(
+				"session.updated",
+				{
+					session: updatedSession ?? session,
+					...(snapshot ? { snapshot } : {}),
+				},
+				sessionId,
+			),
+		);
+	}
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId,
+		ok: true,
+		payload: {
+			updated: updated.updated,
+			session: updatedSession ?? session,
+			...(snapshot ? { snapshot } : {}),
+		},
+	};
+}
+
+export async function handleSessionDelete(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const deleted = await ctx.sessionHost.deleteSession(sessionId);
+	ctx.sessionState.delete(sessionId);
+	return okReply(envelope, { deleted });
+}
+
+export async function handleSessionPendingPrompts(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const service = ctx.sessionHost.pendingPrompts;
+	if (!service) {
+		return errorReply(
+			envelope,
+			"pending_prompts_unavailable",
+			"Pending prompt service is not available.",
+		);
+	}
+	const prompts = await service.list({ sessionId });
+	return okReply(envelope, { sessionId, prompts });
+}
+
+export async function handleSessionUpdatePendingPrompt(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const promptId =
+		typeof envelope.payload?.promptId === "string"
+			? envelope.payload.promptId.trim()
+			: "";
+	const prompt =
+		typeof envelope.payload?.prompt === "string"
+			? envelope.payload.prompt
+			: undefined;
+	const delivery =
+		envelope.payload?.delivery === "queue" ||
+		envelope.payload?.delivery === "steer"
+			? envelope.payload.delivery
+			: undefined;
+	const service = ctx.sessionHost.pendingPrompts;
+	if (!service) {
+		return errorReply(
+			envelope,
+			"pending_prompts_unavailable",
+			"Pending prompt service is not available.",
+		);
+	}
+	const result = await service.update({
+		sessionId,
+		promptId,
+		prompt,
+		delivery,
+	});
+	return okReply(
+		envelope,
+		result as unknown as Record<string, JsonValue | undefined>,
+	);
+}
+
+export async function handleSessionRemovePendingPrompt(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const sessionId = extractSessionId(envelope);
+	const promptId =
+		typeof envelope.payload?.promptId === "string"
+			? envelope.payload.promptId.trim()
+			: "";
+	const service = ctx.sessionHost.pendingPrompts;
+	if (!service) {
+		return errorReply(
+			envelope,
+			"pending_prompts_unavailable",
+			"Pending prompt service is not available.",
+		);
+	}
+	const result = await service.delete({
+		sessionId,
+		promptId,
+	});
+	return okReply(
+		envelope,
+		result as unknown as Record<string, JsonValue | undefined>,
+	);
+}
diff --git a/sdk/packages/core/src/hub/server/hub-capability-tool-executors.test.ts b/sdk/packages/core/src/hub/server/hub-capability-tool-executors.test.ts
new file mode 100644
index 0000000..caf0112
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-capability-tool-executors.test.ts
@@ -0,0 +1,215 @@
+import { describe, expect, it, vi } from "vitest";
+import { handleCapabilityProgress } from "./handlers/capability-handlers";
+import type { HubTransportContext } from "./handlers/context";
+import {
+	createHubClientContributionRuntime,
+	HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+} from "./hub-client-contributions";
+
+type ClientContributionRequest = Parameters<
+	typeof createHubClientContributionRuntime
+>[0]["requestCapability"];
+
+describe("hub capability custom tools", () => {
+	it("proxies custom tool execution to the owning client", async () => {
+		const request: ClientContributionRequest = vi.fn(
+			async (
+				_sessionId,
+				_capabilityName,
+				_payload,
+				_targetClientId,
+				onProgress,
+			) => {
+				onProgress?.({ update: { stream: "stdout", chunk: "hello\n" } });
+				return { result: "done" };
+			},
+		);
+		const runtime = createHubClientContributionRuntime({
+			sessionId: "session-1",
+			targetClientId: "client-1",
+			contributions: [
+				{
+					kind: "tool",
+					name: "custom_exec",
+					description: "Run a custom command.",
+					inputSchema: { type: "object" },
+					capabilityName: "custom_tool.custom_exec",
+				},
+			],
+			requestCapability: request,
+		});
+		const tools = runtime.localRuntime.extraTools ?? [];
+		const updates: unknown[] = [];
+
+		const result = await tools[0].execute(
+			{ command: "echo hello" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 2,
+				emitUpdate: (update) => updates.push(update),
+			},
+		);
+
+		expect(result).toBe("done");
+		expect(updates).toEqual([{ stream: "stdout", chunk: "hello\n" }]);
+		expect(request).toHaveBeenCalledWith(
+			"session-1",
+			"custom_tool.custom_exec",
+			{
+				toolName: "custom_exec",
+				input: { command: "echo hello" },
+				context: {
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 2,
+					metadata: undefined,
+				},
+			},
+			"client-1",
+			expect.any(Function),
+		);
+	});
+});
+
+describe("handleCapabilityProgress", () => {
+	it("routes progress payloads to the pending capability request", () => {
+		const onProgress = vi.fn();
+		const ctx = {
+			pendingCapabilityRequests: new Map([
+				[
+					"capreq-1",
+					{
+						sessionId: "session-1",
+						targetClientId: "client-1",
+						capabilityName: "custom_tool.custom_exec",
+						onProgress,
+						resolve: vi.fn(),
+					},
+				],
+			]),
+		} as unknown as HubTransportContext;
+
+		const reply = handleCapabilityProgress(ctx, {
+			version: "v1",
+			command: "capability.progress",
+			requestId: "request-1",
+			clientId: "client-1",
+			sessionId: "session-1",
+			payload: {
+				requestId: "capreq-1",
+				payload: { update: { stream: "stdout", chunk: "hello\n" } },
+			},
+		});
+
+		expect(reply.ok).toBe(true);
+		expect(onProgress).toHaveBeenCalledWith({
+			update: { stream: "stdout", chunk: "hello\n" },
+		});
+	});
+});
+
+describe("hub client runtime capabilities", () => {
+	it("proxies lifecycle hooks through capability requests", async () => {
+		const request = vi.fn(async () => ({
+			control: { context: "extra context" },
+		}));
+		const runtime = createHubClientContributionRuntime({
+			sessionId: "session-1",
+			targetClientId: "client-1",
+			contributions: [
+				{
+					kind: "hook",
+					name: "beforeRun",
+					capabilityName: "hook.beforeRun",
+				},
+			],
+			requestCapability: request,
+		});
+		const hooks = runtime.localRuntime.hooks;
+
+		const snapshot = {
+			agentId: "agent-1",
+			runId: "conv-1",
+			status: "running" as const,
+			iteration: 0,
+			messages: [],
+			pendingToolCalls: [],
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+			},
+		};
+		const result = await hooks?.beforeRun?.({
+			snapshot,
+		});
+
+		expect(result).toEqual({ context: "extra context" });
+		expect(request).toHaveBeenCalledWith(
+			"session-1",
+			"hook.beforeRun",
+			{
+				context: {
+					snapshot,
+				},
+			},
+			"client-1",
+		);
+	});
+
+	it("rebuilds user instruction services from a client snapshot", async () => {
+		const request = vi.fn(async () => ({
+			snapshot: {
+				records: {
+					rule: [
+						{
+							type: "rule",
+							id: "rule-1",
+							filePath: "/rules/rule.md",
+							item: {
+								name: "Rule One",
+								instructions: "Always be precise.",
+							},
+						},
+					],
+					skill: [],
+					workflow: [],
+				},
+				runtimeCommands: [
+					{
+						id: "workflow-ship",
+						name: "ship",
+						instructions: "Ship it carefully.",
+						kind: "workflow",
+					},
+				],
+			},
+		}));
+		const runtime = createHubClientContributionRuntime({
+			sessionId: "session-1",
+			targetClientId: "client-1",
+			contributions: [
+				{
+					kind: "userInstructionService",
+					capabilityName: HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+				},
+			],
+			requestCapability: request,
+		});
+		const service = runtime.localRuntime.userInstructionService;
+
+		await service?.start();
+
+		expect(service?.resolveRuntimeSlashCommand("/ship now")).toBe(
+			"Ship it carefully. now",
+		);
+		expect(request).toHaveBeenCalledWith(
+			"session-1",
+			HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+			{},
+			"client-1",
+		);
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/hub-client-contributions.ts b/sdk/packages/core/src/hub/server/hub-client-contributions.ts
new file mode 100644
index 0000000..fe27dbd
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-client-contributions.ts
@@ -0,0 +1,689 @@
+import type {
+	AgentExtension,
+	AgentHooks,
+	AgentTool,
+	AgentToolContext,
+	ConsecutiveMistakeLimitDecision,
+	HubClientCheckpointContribution,
+	HubClientCompactionContribution,
+	HubClientContribution,
+	HubClientHookContribution,
+	HubClientToolContribution,
+	HubClientToolExecutorContribution,
+	JsonValue,
+} from "@cline/shared";
+import {
+	HUB_CHECKPOINT_CAPABILITY,
+	HUB_COMPACTION_CAPABILITY,
+	HUB_CUSTOM_TOOL_CAPABILITY_PREFIX,
+	HUB_HOOK_CAPABILITY_PREFIX,
+	HUB_MISTAKE_LIMIT_CAPABILITY,
+	HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX,
+	HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+	isHubToolExecutorName,
+} from "@cline/shared";
+
+export {
+	HUB_CHECKPOINT_CAPABILITY,
+	HUB_COMPACTION_CAPABILITY,
+	HUB_CUSTOM_TOOL_CAPABILITY_PREFIX,
+	HUB_HOOK_CAPABILITY_PREFIX,
+	HUB_MISTAKE_LIMIT_CAPABILITY,
+	HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX,
+	HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY,
+} from "@cline/shared";
+
+import type {
+	AvailableRuntimeCommand,
+	UserInstructionConfig,
+	UserInstructionConfigRecord,
+	UserInstructionConfigService,
+	UserInstructionConfigType,
+} from "../../extensions/config";
+import type { ToolExecutors } from "../../extensions/tools";
+import {
+	createSkillsTool,
+	type SkillsExecutor,
+	type SkillsExecutorWithMetadata,
+} from "../../extensions/tools";
+import type {
+	LocalRuntimeStartOptions,
+	RuntimeSessionConfig,
+} from "../../runtime/host/runtime-host";
+import { formatRulesForSystemPrompt } from "../../runtime/safety/rules";
+import type { CoreSessionConfig } from "../../types/config";
+
+type RequestCapability = (
+	sessionId: string,
+	capabilityName: string,
+	payload: Record<string, unknown>,
+	targetClientId: string,
+	onProgress?: (payload: Record<string, unknown>) => void,
+) => Promise<Record<string, unknown> | undefined>;
+
+type CompactFunction = NonNullable<
+	NonNullable<CoreSessionConfig["compaction"]>["compact"]
+>;
+type CreateCheckpointFunction = NonNullable<
+	NonNullable<CoreSessionConfig["checkpoint"]>["createCheckpoint"]
+>;
+
+type UserInstructionSnapshot = {
+	records: Record<UserInstructionConfigType, UserInstructionConfigRecord[]>;
+	runtimeCommands: AvailableRuntimeCommand[];
+};
+
+const HOOK_NAMES = [
+	"beforeRun",
+	"afterRun",
+	"beforeModel",
+	"afterModel",
+	"beforeTool",
+	"afterTool",
+	"onEvent",
+] as const satisfies readonly (keyof AgentHooks)[];
+
+type HubAgentHookName = (typeof HOOK_NAMES)[number];
+
+export function listHubAgentHookNames(hooks: AgentHooks | undefined): string[] {
+	if (!hooks) return [];
+	return HOOK_NAMES.filter((name) => typeof hooks[name] === "function");
+}
+
+function cloneRecord(
+	value: unknown,
+): Record<string, JsonValue | undefined> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (JSON.parse(JSON.stringify(value)) as Record<
+				string,
+				JsonValue | undefined
+			>)
+		: undefined;
+}
+
+function parseToolContribution(
+	record: Record<string, unknown>,
+	seenCapabilities: Set<string>,
+): HubClientToolContribution | undefined {
+	const name = typeof record.name === "string" ? record.name.trim() : "";
+	const description =
+		typeof record.description === "string" ? record.description : "";
+	const capabilityName =
+		typeof record.capabilityName === "string"
+			? record.capabilityName.trim()
+			: "";
+	const inputSchema = cloneRecord(record.inputSchema);
+	if (
+		!name ||
+		!description ||
+		!inputSchema ||
+		!capabilityName ||
+		seenCapabilities.has(capabilityName)
+	) {
+		return undefined;
+	}
+	seenCapabilities.add(capabilityName);
+	return {
+		kind: "tool",
+		capabilityName,
+		name,
+		description,
+		inputSchema,
+		...(cloneRecord(record.lifecycle)
+			? { lifecycle: cloneRecord(record.lifecycle) }
+			: {}),
+	};
+}
+
+export function parseHubClientContributions(
+	value: unknown,
+): HubClientContribution[] {
+	if (!Array.isArray(value)) return [];
+	const contributions: HubClientContribution[] = [];
+	const seenCapabilities = new Set<string>();
+	for (const item of value) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+		const record = item as Record<string, unknown>;
+		const kind = record.kind;
+		const capabilityName =
+			typeof record.capabilityName === "string"
+				? record.capabilityName.trim()
+				: "";
+		if (!capabilityName || seenCapabilities.has(capabilityName)) continue;
+
+		if (kind === "tool") {
+			const contribution = parseToolContribution(record, seenCapabilities);
+			if (contribution) contributions.push(contribution);
+			continue;
+		}
+
+		if (kind === "toolExecutor") {
+			const executor = record.executor;
+			if (!isHubToolExecutorName(executor)) continue;
+			seenCapabilities.add(capabilityName);
+			contributions.push({
+				kind: "toolExecutor",
+				capabilityName,
+				executor,
+			});
+			continue;
+		}
+
+		if (kind === "hook") {
+			const name = typeof record.name === "string" ? record.name.trim() : "";
+			if (!name) continue;
+			seenCapabilities.add(capabilityName);
+			contributions.push({ kind: "hook", capabilityName, name });
+			continue;
+		}
+
+		if (kind === "compaction") {
+			seenCapabilities.add(capabilityName);
+			contributions.push({
+				kind: "compaction",
+				capabilityName,
+				...(cloneRecord(record.config)
+					? { config: cloneRecord(record.config) }
+					: {}),
+			});
+			continue;
+		}
+
+		if (kind === "checkpoint") {
+			seenCapabilities.add(capabilityName);
+			contributions.push({
+				kind: "checkpoint",
+				capabilityName,
+				...(cloneRecord(record.config)
+					? { config: cloneRecord(record.config) }
+					: {}),
+			});
+			continue;
+		}
+
+		if (kind === "mistakeLimit") {
+			seenCapabilities.add(capabilityName);
+			contributions.push({ kind: "mistakeLimit", capabilityName });
+			continue;
+		}
+
+		if (kind === "userInstructionService") {
+			seenCapabilities.add(capabilityName);
+			contributions.push({ kind: "userInstructionService", capabilityName });
+		}
+	}
+	return contributions;
+}
+
+function serializeToolContext(
+	context: AgentToolContext,
+): Record<string, unknown> {
+	return {
+		agentId: context.agentId,
+		conversationId: context.conversationId,
+		iteration: context.iteration,
+		metadata: context.metadata,
+	};
+}
+
+function asToolUpdate(payload: Record<string, unknown>): unknown {
+	return Object.hasOwn(payload, "update") ? payload.update : payload;
+}
+
+function normalizeSkillToken(token: string): string {
+	return token.trim().replace(/^\/+/, "").toLowerCase();
+}
+
+function toAllowedSkillSet(
+	allowedSkillNames?: ReadonlyArray<string>,
+): Set<string> | undefined {
+	const normalized = (allowedSkillNames ?? [])
+		.map(normalizeSkillToken)
+		.filter(Boolean);
+	return normalized.length > 0 ? new Set(normalized) : undefined;
+}
+
+function isSkillAllowed(
+	skillId: string,
+	skillName: string,
+	allowedSkills?: Set<string>,
+): boolean {
+	if (!allowedSkills) return true;
+	const normalizedId = normalizeSkillToken(skillId);
+	const normalizedName = normalizeSkillToken(skillName);
+	const bareId = normalizedId.includes(":")
+		? (normalizedId.split(":").at(-1) ?? normalizedId)
+		: normalizedId;
+	const bareName = normalizedName.includes(":")
+		? (normalizedName.split(":").at(-1) ?? normalizedName)
+		: normalizedName;
+	return (
+		allowedSkills.has(normalizedId) ||
+		allowedSkills.has(normalizedName) ||
+		allowedSkills.has(bareId) ||
+		allowedSkills.has(bareName)
+	);
+}
+
+function configuredSkills(
+	snapshot: UserInstructionSnapshot,
+	allowedSkillNames?: ReadonlyArray<string>,
+) {
+	const allowed = toAllowedSkillSet(allowedSkillNames);
+	return snapshot.records.skill
+		.map((record) => ({
+			id: record.id,
+			name: record.item.name,
+			description:
+				"description" in record.item &&
+				typeof record.item.description === "string"
+					? record.item.description
+					: undefined,
+			disabled: record.item.disabled === true,
+			skill: record.item,
+		}))
+		.filter((entry) => isSkillAllowed(entry.id, entry.name, allowed));
+}
+
+function createSnapshotSkillsExecutor(
+	snapshot: UserInstructionSnapshot,
+	allowedSkillNames?: ReadonlyArray<string>,
+): SkillsExecutorWithMetadata {
+	const executor: SkillsExecutorWithMetadata = (async (skillName, args) => {
+		const normalized = normalizeSkillToken(skillName);
+		const matches = configuredSkills(snapshot, allowedSkillNames).filter(
+			(entry) =>
+				entry.id === normalized ||
+				normalizeSkillToken(entry.name) === normalized ||
+				entry.id.endsWith(`:${normalized}`),
+		);
+		const enabled = matches.filter((entry) => !entry.disabled);
+		if (enabled.length !== 1) {
+			return enabled.length > 1
+				? `Skill "${skillName}" is ambiguous. Use one of: ${enabled.map((entry) => entry.id).join(", ")}`
+				: `Skill "${skillName}" not found.`;
+		}
+		const skill = enabled[0].skill as {
+			name: string;
+			description?: string;
+			instructions: string;
+		};
+		const trimmedArgs = args?.trim();
+		const argsTag = trimmedArgs
+			? `\n<command-args>${trimmedArgs}</command-args>`
+			: "";
+		const description = skill.description?.trim()
+			? `Description: ${skill.description.trim()}\n\n`
+			: "";
+		return `<command-name>${skill.name}</command-name>${argsTag}\n<command-instructions>\n${description}${skill.instructions}\n</command-instructions>`;
+	}) as SkillsExecutor;
+
+	Object.defineProperty(executor, "configuredSkills", {
+		get: () =>
+			configuredSkills(snapshot, allowedSkillNames).map(
+				({ skill: _skill, ...metadata }) => metadata,
+			),
+		enumerable: true,
+	});
+	return executor;
+}
+
+function createUserInstructionServiceProxy(
+	sessionId: string,
+	targetClientId: string,
+	contribution: HubClientContribution,
+	requestCapability: RequestCapability,
+): UserInstructionConfigService {
+	let snapshot: UserInstructionSnapshot = {
+		records: { skill: [], rule: [], workflow: [] },
+		runtimeCommands: [],
+	};
+	const loadSnapshot = async (): Promise<void> => {
+		const response = await requestCapability(
+			sessionId,
+			contribution.capabilityName,
+			{},
+			targetClientId,
+		);
+		if (response?.snapshot) {
+			snapshot = response.snapshot as UserInstructionSnapshot;
+		}
+	};
+	return {
+		start: loadSnapshot,
+		stop: () => {},
+		refreshType: async () => {
+			await loadSnapshot();
+		},
+		listRecords: <
+			TConfig extends UserInstructionConfig = UserInstructionConfig,
+		>(
+			type: UserInstructionConfigType,
+		) => [...snapshot.records[type]] as UserInstructionConfigRecord<TConfig>[],
+		listRuntimeCommands: () => [...snapshot.runtimeCommands],
+		resolveRuntimeSlashCommand: (input) => {
+			if (!input.startsWith("/") || input.length < 2) return input;
+			const match = input.match(/^\/(\S+)/);
+			const name = match?.[1];
+			if (!name) return input;
+			const command = snapshot.runtimeCommands.find(
+				(item) => item.name === name,
+			);
+			return command
+				? `${command.instructions}${input.slice(name.length + 1)}`
+				: input;
+		},
+		hasConfiguredSkills: (allowedSkillNames) =>
+			configuredSkills(snapshot, allowedSkillNames).some(
+				(entry) => !entry.disabled,
+			),
+		createSkillsExecutor: (allowedSkillNames) =>
+			createSnapshotSkillsExecutor(snapshot, allowedSkillNames),
+		createExtension: (options): AgentExtension => ({
+			name: "cline-hub-user-instructions",
+			manifest: {
+				capabilities: [
+					options.includeRules ? "rules" : undefined,
+					options.registerSkillsTool ? "tools" : undefined,
+					options.includeSkills || options.includeWorkflows
+						? "commands"
+						: undefined,
+				].filter((value): value is "rules" | "tools" | "commands" =>
+					Boolean(value),
+				),
+			},
+			setup(api) {
+				if (options.includeRules) {
+					api.registerRule({
+						id: "cline-hub-user-instructions:rules",
+						source: "hub-user-instructions",
+						content: () =>
+							formatRulesForSystemPrompt(
+								snapshot.records.rule
+									.map((record) => record.item)
+									.filter((rule) => rule.disabled !== true),
+							),
+					});
+				}
+				if (options.registerSkillsTool) {
+					api.registerTool(
+						createSkillsTool(
+							createSnapshotSkillsExecutor(snapshot, options.allowedSkillNames),
+						) as AgentTool,
+					);
+				}
+				for (const command of snapshot.runtimeCommands.filter(
+					(command) =>
+						(command.kind === "skill" && options.includeSkills) ||
+						(command.kind === "workflow" && options.includeWorkflows),
+				)) {
+					api.registerCommand({
+						name: command.name,
+						description: command.description,
+						handler: (input) => {
+							const trimmed = input.trim();
+							return trimmed
+								? `${command.instructions}\n\n${trimmed}`
+								: command.instructions;
+						},
+					});
+				}
+			},
+		}),
+	};
+}
+
+function createToolExecutorProxy(
+	sessionId: string,
+	targetClientId: string,
+	contributions: HubClientToolExecutorContribution[],
+	requestCapability: RequestCapability,
+): Partial<ToolExecutors> | undefined {
+	const entries = contributions.map((contribution) => [
+		contribution.executor,
+		async (...argsAndContext: unknown[]) => {
+			const context = argsAndContext.at(-1) as AgentToolContext;
+			const args = argsAndContext.slice(0, -1);
+			const response = await requestCapability(
+				sessionId,
+				contribution.capabilityName,
+				{
+					executor: contribution.executor,
+					args,
+					context: serializeToolContext(context),
+				},
+				targetClientId,
+			);
+			return response?.result;
+		},
+	]);
+	return entries.length > 0
+		? (Object.fromEntries(entries) as Partial<ToolExecutors>)
+		: undefined;
+}
+
+function createToolProxies(
+	sessionId: string,
+	targetClientId: string,
+	contributions: HubClientToolContribution[],
+	requestCapability: RequestCapability,
+): AgentTool[] | undefined {
+	if (contributions.length === 0) return undefined;
+	return contributions.map((contribution) => ({
+		name: contribution.name,
+		description: contribution.description,
+		inputSchema: contribution.inputSchema,
+		lifecycle: contribution.lifecycle as AgentTool["lifecycle"],
+		async execute(input, context) {
+			const response = await requestCapability(
+				sessionId,
+				contribution.capabilityName,
+				{
+					toolName: contribution.name,
+					input,
+					context: serializeToolContext(context),
+				},
+				targetClientId,
+				context.emitUpdate
+					? (payload) => {
+							context.emitUpdate?.(asToolUpdate(payload));
+						}
+					: undefined,
+			);
+			return response?.result;
+		},
+	}));
+}
+
+function createHookProxies(
+	sessionId: string,
+	targetClientId: string,
+	contributions: HubClientHookContribution[],
+	requestCapability: RequestCapability,
+): AgentHooks | undefined {
+	const available = new Map(contributions.map((item) => [item.name, item]));
+	const hooks: Partial<Record<HubAgentHookName, (ctx: unknown) => unknown>> =
+		{};
+	for (const name of HOOK_NAMES) {
+		const contribution = available.get(name);
+		if (!contribution) continue;
+		hooks[name] = async (ctx: unknown) => {
+			const response = await requestCapability(
+				sessionId,
+				contribution.capabilityName,
+				{ context: ctx },
+				targetClientId,
+			);
+			return response?.control;
+		};
+	}
+	return Object.keys(hooks).length > 0 ? (hooks as AgentHooks) : undefined;
+}
+
+export function createHubClientContributionRuntime(input: {
+	sessionId: string;
+	targetClientId: string;
+	contributions: readonly HubClientContribution[];
+	sessionConfig?: Partial<RuntimeSessionConfig>;
+	requestCapability: RequestCapability;
+}): {
+	localRuntime: LocalRuntimeStartOptions;
+	toolExecutors?: Partial<ToolExecutors>;
+	hasClientContributions: boolean;
+} {
+	const toolExecutors = input.contributions.filter(
+		(item): item is HubClientToolExecutorContribution =>
+			item.kind === "toolExecutor",
+	);
+	const tools = input.contributions.filter(
+		(item): item is HubClientToolContribution => item.kind === "tool",
+	);
+	const hooks = input.contributions.filter(
+		(item): item is HubClientHookContribution => item.kind === "hook",
+	);
+	const compaction = input.contributions.find(
+		(item): item is HubClientCompactionContribution =>
+			item.kind === "compaction",
+	);
+	const checkpoint = input.contributions.find(
+		(item): item is HubClientCheckpointContribution =>
+			item.kind === "checkpoint",
+	);
+	const mistakeLimit = input.contributions.find(
+		(item): item is HubClientContribution => item.kind === "mistakeLimit",
+	);
+	const userInstructionService = input.contributions.find(
+		(item): item is HubClientContribution =>
+			item.kind === "userInstructionService",
+	);
+
+	return {
+		hasClientContributions: input.contributions.length > 0,
+		toolExecutors: createToolExecutorProxy(
+			input.sessionId,
+			input.targetClientId,
+			toolExecutors,
+			input.requestCapability,
+		),
+		localRuntime: {
+			...(hooks.length > 0
+				? {
+						hooks: createHookProxies(
+							input.sessionId,
+							input.targetClientId,
+							hooks,
+							input.requestCapability,
+						),
+					}
+				: {}),
+			...(tools.length > 0
+				? {
+						extraTools: createToolProxies(
+							input.sessionId,
+							input.targetClientId,
+							tools,
+							input.requestCapability,
+						),
+					}
+				: {}),
+			...(compaction
+				? {
+						compaction: {
+							...(input.sessionConfig?.compaction ?? {}),
+							...(compaction.config as NonNullable<
+								CoreSessionConfig["compaction"]
+							>),
+							compact: async (context) => {
+								const response = await input.requestCapability(
+									input.sessionId,
+									compaction.capabilityName,
+									{ context },
+									input.targetClientId,
+								);
+								return response?.result as Awaited<ReturnType<CompactFunction>>;
+							},
+						},
+					}
+				: {}),
+			...(checkpoint
+				? {
+						checkpoint: {
+							...(input.sessionConfig?.checkpoint ?? {}),
+							...(checkpoint.config as NonNullable<
+								CoreSessionConfig["checkpoint"]
+							>),
+							createCheckpoint: async (context) => {
+								const response = await input.requestCapability(
+									input.sessionId,
+									checkpoint.capabilityName,
+									{ context },
+									input.targetClientId,
+								);
+								return response?.result as Awaited<
+									ReturnType<CreateCheckpointFunction>
+								>;
+							},
+						},
+					}
+				: {}),
+			...(mistakeLimit
+				? {
+						onConsecutiveMistakeLimitReached: async (
+							context: Parameters<
+								NonNullable<
+									CoreSessionConfig["onConsecutiveMistakeLimitReached"]
+								>
+							>[0],
+						): Promise<ConsecutiveMistakeLimitDecision> => {
+							const response = await input.requestCapability(
+								input.sessionId,
+								mistakeLimit.capabilityName,
+								{ context },
+								input.targetClientId,
+							);
+							return response?.result as ConsecutiveMistakeLimitDecision;
+						},
+					}
+				: {}),
+			...(userInstructionService
+				? {
+						userInstructionService: createUserInstructionServiceProxy(
+							input.sessionId,
+							input.targetClientId,
+							userInstructionService,
+							input.requestCapability,
+						),
+					}
+				: {}),
+		},
+	};
+}
+
+export function defaultClientContributionCapabilityName(
+	contribution: Pick<HubClientContribution, "kind"> & Record<string, unknown>,
+): string | undefined {
+	switch (contribution.kind) {
+		case "toolExecutor":
+			return typeof contribution.executor === "string"
+				? `${HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX}${contribution.executor}`
+				: undefined;
+		case "tool":
+			return typeof contribution.name === "string"
+				? `${HUB_CUSTOM_TOOL_CAPABILITY_PREFIX}${contribution.name}`
+				: undefined;
+		case "hook":
+			return typeof contribution.name === "string"
+				? `${HUB_HOOK_CAPABILITY_PREFIX}${contribution.name}`
+				: undefined;
+		case "compaction":
+			return HUB_COMPACTION_CAPABILITY;
+		case "checkpoint":
+			return HUB_CHECKPOINT_CAPABILITY;
+		case "mistakeLimit":
+			return HUB_MISTAKE_LIMIT_CAPABILITY;
+		case "userInstructionService":
+			return HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY;
+		default:
+			return undefined;
+	}
+}
diff --git a/sdk/packages/core/src/hub/server/hub-notifications.ts b/sdk/packages/core/src/hub/server/hub-notifications.ts
new file mode 100644
index 0000000..b8fbaa8
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-notifications.ts
@@ -0,0 +1,94 @@
+import type { SessionRecord as HubSessionRecord } from "@cline/shared";
+import { readPersistedMessagesFile } from "../../runtime/host/runtime-host-support";
+
+function extractAssistantText(content: unknown): string | undefined {
+	if (typeof content === "string") {
+		const trimmed = content.trim();
+		return trimmed || undefined;
+	}
+	if (!Array.isArray(content)) {
+		return undefined;
+	}
+	const text = content
+		.map((part) => {
+			if (
+				part &&
+				typeof part === "object" &&
+				"type" in part &&
+				(part as { type?: unknown }).type === "text" &&
+				"text" in part &&
+				typeof (part as { text?: unknown }).text === "string"
+			) {
+				return (part as { text: string }).text.trim();
+			}
+			return "";
+		})
+		.filter(Boolean)
+		.join("\n")
+		.trim();
+	return text || undefined;
+}
+
+const MAX_NOTIFICATION_BODY_BYTES = 120;
+const NOTIFICATION_BODY_ELLIPSIS = "...";
+
+export function truncateNotificationBody(value: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return "";
+	}
+	if (Buffer.byteLength(trimmed, "utf8") <= MAX_NOTIFICATION_BODY_BYTES) {
+		return trimmed;
+	}
+	const budget =
+		MAX_NOTIFICATION_BODY_BYTES -
+		Buffer.byteLength(NOTIFICATION_BODY_ELLIPSIS, "utf8");
+	if (budget <= 0) {
+		return NOTIFICATION_BODY_ELLIPSIS;
+	}
+	let truncated = "";
+	for (const char of trimmed) {
+		if (Buffer.byteLength(truncated + char, "utf8") > budget) {
+			break;
+		}
+		truncated += char;
+	}
+	return `${truncated}${NOTIFICATION_BODY_ELLIPSIS}`;
+}
+
+export async function buildCompletionNotification(
+	session: HubSessionRecord | undefined,
+): Promise<{
+	title: string;
+	body: string;
+	severity: "info";
+}> {
+	const sessionId = session?.sessionId?.trim() || "unknown";
+	const messagesPath =
+		typeof session?.metadata?.messagesPath === "string"
+			? session.metadata.messagesPath
+			: undefined;
+	const messages = await readPersistedMessagesFile(messagesPath);
+	const latestAssistantText = [...messages]
+		.reverse()
+		.find((message) => message.role === "assistant");
+	const assistantReply = latestAssistantText
+		? extractAssistantText(latestAssistantText.content)
+		: undefined;
+	const workspaceRoot = session?.workspaceRoot?.trim() || "workspace";
+	const fallback =
+		typeof session?.metadata?.prompt === "string"
+			? session.metadata.prompt.trim()
+			: workspaceRoot;
+	return {
+		title: `Task completed (${sessionId})`,
+		body: truncateNotificationBody(
+			assistantReply && assistantReply.length > 0
+				? assistantReply
+				: fallback.length > 0
+					? fallback
+					: workspaceRoot,
+		),
+		severity: "info",
+	};
+}
diff --git a/sdk/packages/core/src/hub/server/hub-schedule-events.ts b/sdk/packages/core/src/hub/server/hub-schedule-events.ts
new file mode 100644
index 0000000..c049819
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-schedule-events.ts
@@ -0,0 +1,20 @@
+import type { HubCommandEnvelope, HubEventEnvelope } from "@cline/shared";
+
+export function eventNameForScheduleCommand(
+	command: HubCommandEnvelope["command"],
+): HubEventEnvelope["event"] | undefined {
+	switch (command) {
+		case "schedule.create":
+			return "schedule.created";
+		case "schedule.update":
+		case "schedule.enable":
+		case "schedule.disable":
+			return "schedule.updated";
+		case "schedule.delete":
+			return "schedule.deleted";
+		case "schedule.trigger":
+			return "schedule.triggered";
+		default:
+			return undefined;
+	}
+}
diff --git a/sdk/packages/core/src/hub/server/hub-server-logging.ts b/sdk/packages/core/src/hub/server/hub-server-logging.ts
new file mode 100644
index 0000000..a0f1213
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-server-logging.ts
@@ -0,0 +1,69 @@
+function serializeLogValue(value: unknown): unknown {
+	if (value instanceof Error) {
+		return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack,
+		};
+	}
+	if (value === undefined) {
+		return undefined;
+	}
+	return value;
+}
+
+type HubLogLevel = "debug" | "info" | "warn" | "error" | "silent";
+
+const LOG_LEVEL_PRIORITY: Record<HubLogLevel, number> = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40,
+	silent: 50,
+};
+
+function resolveHubLogLevel(): HubLogLevel {
+	const configured = process.env.CLINE_HUB_LOG_LEVEL?.trim().toLowerCase();
+	if (
+		configured === "debug" ||
+		configured === "info" ||
+		configured === "warn" ||
+		configured === "error" ||
+		configured === "silent"
+	) {
+		return configured;
+	}
+	return process.env.VITEST ? "error" : "info";
+}
+
+export function logHubMessage(
+	level: "debug" | "info" | "warn" | "error",
+	message: string,
+	context: Record<string, unknown> = {},
+): void {
+	if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[resolveHubLogLevel()]) {
+		return;
+	}
+	const payload = JSON.stringify({
+		ts: new Date().toISOString(),
+		level,
+		component: "hub",
+		message,
+		...Object.fromEntries(
+			Object.entries(context)
+				.map(([key, value]) => [key, serializeLogValue(value)])
+				.filter(([, value]) => value !== undefined),
+		),
+	});
+	if (level === "error" || level === "warn") {
+		console.error(`[hub] ${payload}`);
+		return;
+	}
+	console.log(`[hub] ${payload}`);
+}
+
+export function logHubBoundaryError(message: string, error: unknown): void {
+	const details =
+		error instanceof Error ? error.stack || error.message : String(error);
+	logHubMessage("error", message, { error: details });
+}
diff --git a/sdk/packages/core/src/hub/server/hub-server-options.ts b/sdk/packages/core/src/hub/server/hub-server-options.ts
new file mode 100644
index 0000000..ae5bd1f
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-server-options.ts
@@ -0,0 +1,66 @@
+import type { ITelemetryService } from "@cline/shared";
+import type { CronServiceOptions } from "../../cron/service/cron-service";
+import type {
+	HubScheduleRuntimeHandlers,
+	HubScheduleServiceOptions,
+} from "../../cron/service/schedule-service";
+import type {
+	PendingPromptsRuntimeService,
+	RuntimeHost,
+} from "../../runtime/host/runtime-host";
+import type { CoreSettingsService } from "../../settings";
+import type { HubOwnerContext } from "../discovery";
+
+export interface HubWebSocketServerOptions {
+	host?: string;
+	port?: number;
+	pathname?: string;
+	owner?: HubOwnerContext;
+	sessionHost?: RuntimeHost & Partial<PendingPromptsRuntimeService>;
+	settingsService?: CoreSettingsService;
+	runtimeHandlers: HubScheduleRuntimeHandlers;
+	scheduleOptions?: Omit<HubScheduleServiceOptions, "runtimeHandlers">;
+	/**
+	 * File-based cron automation options. When provided, the hub starts a
+	 * `CronService` that watches global `~/.cline/cron/` by default, reconciles
+	 * specs into `cron.db`, and executes queued runs through `runtimeHandlers`.
+	 * Pass `cronOptions.specs` to use a different source, including future
+	 * workspace-scoped specs.
+	 */
+	cronOptions?: Omit<CronServiceOptions, "runtimeHandlers">;
+	/**
+	 * Custom `fetch` implementation forwarded to the internally-constructed
+	 * `LocalRuntimeHost` that executes incoming `session.create` traffic.
+	 * Used by the AI gateway providers for every session that runs inside
+	 * this hub process.
+	 *
+	 * Ignored when `sessionHost` is supplied — in that case the caller owns
+	 * runtime construction and is responsible for wiring its own fetch.
+	 */
+	fetch?: typeof fetch;
+	/**
+	 * Telemetry forwarded to the internally-constructed `LocalRuntimeHost`.
+	 * Ignored when `sessionHost` is supplied.
+	 */
+	telemetry?: ITelemetryService;
+}
+
+export interface HubWebSocketServer {
+	host: string;
+	port: number;
+	url: string;
+	authToken: string;
+	close(): Promise<void>;
+}
+
+export interface EnsureHubWebSocketServerOptions
+	extends HubWebSocketServerOptions {
+	allowPortFallback?: boolean;
+}
+
+export interface EnsuredHubWebSocketServerResult {
+	server?: HubWebSocketServer;
+	url: string;
+	authToken?: string;
+	action: "reuse" | "started";
+}
diff --git a/sdk/packages/core/src/hub/server/hub-server-transport.ts b/sdk/packages/core/src/hub/server/hub-server-transport.ts
new file mode 100644
index 0000000..548e149
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-server-transport.ts
@@ -0,0 +1,610 @@
+import type {
+	HubClientRecord,
+	HubCommandEnvelope,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+	ToolApprovalRequest,
+} from "@cline/shared";
+import { captureSdkError, createSessionId } from "@cline/shared";
+import { CronService } from "../../cron/service/cron-service";
+import { HubScheduleCommandService } from "../../cron/service/schedule-command-service";
+import { HubScheduleService } from "../../cron/service/schedule-service";
+import { LocalRuntimeHost } from "../../runtime/host/local-runtime-host";
+import type {
+	PendingPromptsRuntimeService,
+	RuntimeHost,
+} from "../../runtime/host/runtime-host";
+import { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import { CoreSessionService } from "../../session/services/session-service";
+import {
+	type CoreSettingsListInput,
+	CoreSettingsService,
+	type CoreSettingsToggleInput,
+	type CoreSettingsType,
+} from "../../settings";
+import type { CoreSessionEvent } from "../../types/events";
+import {
+	handleApprovalRespond,
+	requestToolApproval as requestToolApprovalHandler,
+	resolvePendingApproval,
+} from "./handlers/approval-handlers";
+import {
+	cancelPendingCapabilityRequests,
+	handleCapabilityProgress,
+	handleCapabilityRequest,
+	handleCapabilityRespond,
+	requestCapability as requestCapabilityHandler,
+} from "./handlers/capability-handlers";
+import {
+	handleClientList,
+	handleClientRegister,
+	handleClientUnregister,
+	handleClientUpdate,
+} from "./handlers/client-handlers";
+import { handleConnectorCommand } from "./handlers/connector-handlers";
+import {
+	buildHubEvent,
+	type HubTransportContext,
+	okReply,
+	type PendingApproval,
+	type PendingCapabilityRequest,
+} from "./handlers/context";
+import {
+	handleRunAbort,
+	handleSessionHook,
+	handleSessionInput,
+} from "./handlers/run-handlers";
+import { projectSessionEvent } from "./handlers/session-event-projector";
+import {
+	handleSessionAttach,
+	handleSessionCompactionGet,
+	handleSessionCompactionUpdate,
+	handleSessionCreate,
+	handleSessionDelete,
+	handleSessionDetach,
+	handleSessionGet,
+	handleSessionList,
+	handleSessionMessages,
+	handleSessionPendingPrompts,
+	handleSessionRemovePendingPrompt,
+	handleSessionRestore,
+	handleSessionUpdate,
+	handleSessionUpdateConnection,
+	handleSessionUpdatePendingPrompt,
+} from "./handlers/session-handlers";
+import { eventNameForScheduleCommand } from "./hub-schedule-events";
+import { logHubBoundaryError } from "./hub-server-logging";
+import type { HubWebSocketServerOptions } from "./hub-server-options";
+import type { HubSessionState } from "./hub-session-records";
+import type { NativeHubTransport } from "./native-transport";
+
+const SETTINGS_TYPES = new Set<CoreSettingsType>([
+	"skills",
+	"workflows",
+	"rules",
+	"tools",
+	"mcp",
+]);
+
+function isPayloadObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function requireOptionalString(
+	payload: Record<string, unknown>,
+	key: "cwd" | "workspaceRoot" | "id" | "path" | "name",
+): string | undefined {
+	const value = payload[key];
+	if (value === undefined) {
+		return undefined;
+	}
+	if (typeof value !== "string") {
+		throw new Error(`settings payload '${key}' must be a string.`);
+	}
+	return value;
+}
+
+function requireOptionalBoolean(
+	payload: Record<string, unknown>,
+	key: "enabled",
+): boolean | undefined {
+	const value = payload[key];
+	if (value === undefined) {
+		return undefined;
+	}
+	if (typeof value !== "boolean") {
+		throw new Error(`settings payload '${key}' must be a boolean.`);
+	}
+	return value;
+}
+
+function parseSettingsListInput(payload: unknown): CoreSettingsListInput {
+	if (payload === undefined) {
+		return {};
+	}
+	if (!isPayloadObject(payload)) {
+		throw new Error("settings.list payload must be an object.");
+	}
+	return {
+		cwd: requireOptionalString(payload, "cwd"),
+		workspaceRoot: requireOptionalString(payload, "workspaceRoot"),
+		availabilityContext: isPayloadObject(payload.availabilityContext)
+			? (payload.availabilityContext as CoreSettingsListInput["availabilityContext"])
+			: undefined,
+	};
+}
+
+function parseSettingsToggleInput(payload: unknown): CoreSettingsToggleInput {
+	if (!isPayloadObject(payload)) {
+		throw new Error("settings.toggle payload must be an object.");
+	}
+	const { type } = payload;
+	if (
+		typeof type !== "string" ||
+		!SETTINGS_TYPES.has(type as CoreSettingsType)
+	) {
+		throw new Error(
+			"settings.toggle payload 'type' must be one of: skills, workflows, rules, tools, mcp.",
+		);
+	}
+	return {
+		...parseSettingsListInput(payload),
+		type: type as CoreSettingsType,
+		id: requireOptionalString(payload, "id"),
+		path: requireOptionalString(payload, "path"),
+		name: requireOptionalString(payload, "name"),
+		enabled: requireOptionalBoolean(payload, "enabled"),
+	};
+}
+
+/** @internal Exported for unit testing fetch/runtime wiring. */
+export class HubServerTransport implements NativeHubTransport {
+	private readonly clients = new Map<string, HubClientRecord>();
+	private readonly listeners = new Map<
+		string,
+		Set<{ sessionId?: string; listener: (event: HubEventEnvelope) => void }>
+	>();
+	private readonly sessionState = new Map<string, HubSessionState>();
+	private readonly pendingApprovals = new Map<string, PendingApproval>();
+	private readonly pendingCapabilityRequests = new Map<
+		string,
+		PendingCapabilityRequest
+	>();
+	private readonly suppressNextTerminalEventBySession = new Map<
+		string,
+		string
+	>();
+	private readonly schedules: HubScheduleService;
+	private readonly scheduleCommands: HubScheduleCommandService;
+	private readonly settings: CoreSettingsService;
+	private readonly cronService?: CronService;
+	private readonly sessionHost: RuntimeHost &
+		Partial<PendingPromptsRuntimeService>;
+	private readonly hubId = createSessionId("hub_");
+	private readonly ctx: HubTransportContext;
+
+	constructor(readonly options: HubWebSocketServerOptions) {
+		this.sessionHost =
+			options.sessionHost ??
+			new LocalRuntimeHost({
+				sessionService: new CoreSessionService(new SqliteSessionStore()),
+				fetch: options.fetch,
+				telemetry: options.telemetry,
+			});
+		this.ctx = {
+			clients: this.clients,
+			sessionState: this.sessionState,
+			pendingApprovals: this.pendingApprovals,
+			pendingCapabilityRequests: this.pendingCapabilityRequests,
+			suppressNextTerminalEventBySession:
+				this.suppressNextTerminalEventBySession,
+			telemetry: options.telemetry,
+			sessionHost: this.sessionHost,
+			publish: (event) => this.publish(event),
+			buildEvent: buildHubEvent,
+			requestCapability: (
+				sessionId,
+				capabilityName,
+				payload,
+				targetClientId,
+				onProgress,
+			) =>
+				requestCapabilityHandler(
+					this.ctx,
+					sessionId,
+					capabilityName,
+					payload,
+					targetClientId,
+					onProgress,
+				),
+		};
+		this.schedules = new HubScheduleService({
+			...options.scheduleOptions,
+			runtimeHandlers: options.runtimeHandlers,
+			eventPublisher: (eventType, payload) => {
+				const mapped =
+					eventType === "schedule.execution.completed"
+						? "schedule.execution_completed"
+						: eventType === "schedule.execution.failed"
+							? "schedule.execution_failed"
+							: undefined;
+				if (!mapped) {
+					return;
+				}
+				this.publish(
+					buildHubEvent(
+						mapped,
+						payload && typeof payload === "object"
+							? (payload as Record<string, unknown>)
+							: undefined,
+					),
+				);
+			},
+		});
+		this.scheduleCommands = new HubScheduleCommandService(this.schedules);
+		this.settings = options.settingsService ?? new CoreSettingsService();
+		if (options.cronOptions) {
+			this.cronService = new CronService({
+				runtimeHandlers: options.runtimeHandlers,
+				...options.cronOptions,
+			});
+		}
+		this.sessionHost.subscribe((event: CoreSessionEvent) => {
+			void projectSessionEvent(this.ctx, event).catch((error) => {
+				logHubBoundaryError("session event handling failed", error);
+				captureSdkError(this.options.telemetry, {
+					component: "core",
+					operation: "hub.session_event_project",
+					error,
+					severity: "error",
+					handled: true,
+					context: {
+						eventType: event.type,
+						sessionId: event.payload.sessionId,
+					},
+				});
+			});
+		});
+	}
+
+	getCronService(): CronService | undefined {
+		return this.cronService;
+	}
+
+	getHubId(): string {
+		return this.hubId;
+	}
+
+	async start(): Promise<void> {
+		await this.schedules.start();
+		if (this.cronService) {
+			try {
+				await this.cronService.start();
+			} catch (err) {
+				console.error("[hub] cron service start failed", err);
+			}
+		}
+	}
+
+	async stop(): Promise<void> {
+		for (const approvalId of this.pendingApprovals.keys()) {
+			resolvePendingApproval(this.ctx, approvalId, {
+				approved: false,
+				reason: "Hub shutting down before approval was resolved.",
+			});
+		}
+		cancelPendingCapabilityRequests(
+			this.ctx,
+			() => true,
+			"Hub shutting down before capability request was resolved.",
+		);
+		await this.sessionHost.dispose("hub_server_stop");
+		await this.schedules.dispose();
+		if (this.cronService) {
+			try {
+				await this.cronService.dispose();
+			} catch (err) {
+				console.error("[hub] cron service stop failed", err);
+			}
+		}
+	}
+
+	async handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope> {
+		try {
+			const reply = await this.dispatchCommand(envelope);
+			this.captureFailedReply(envelope, reply);
+			return reply;
+		} catch (error) {
+			captureSdkError(this.options.telemetry, {
+				component: "core",
+				operation: "hub.command",
+				error,
+				severity: "error",
+				handled: false,
+				context: this.commandTelemetryContext(envelope),
+			});
+			throw error;
+		}
+	}
+
+	private async dispatchCommand(
+		envelope: HubCommandEnvelope,
+	): Promise<HubReplyEnvelope> {
+		switch (envelope.command) {
+			case "client.register":
+				return handleClientRegister(this.ctx, envelope);
+			case "client.update":
+				return handleClientUpdate(this.ctx, envelope);
+			case "client.unregister":
+				return handleClientUnregister(this.ctx, envelope, (clientId) => {
+					this.listeners.delete(clientId);
+					this.detachClientFromSessions(clientId);
+				});
+			case "client.list":
+				return handleClientList(this.ctx, envelope);
+			case "session.create":
+				return await handleSessionCreate(
+					this.ctx,
+					envelope,
+					(request: ToolApprovalRequest) =>
+						requestToolApprovalHandler(this.ctx, request),
+				);
+			case "session.restore":
+				return await handleSessionRestore(
+					this.ctx,
+					envelope,
+					(request: ToolApprovalRequest) =>
+						requestToolApprovalHandler(this.ctx, request),
+				);
+			case "session.attach":
+				return await handleSessionAttach(this.ctx, envelope);
+			case "session.detach":
+				return await handleSessionDetach(this.ctx, envelope);
+			case "session.get":
+				return await handleSessionGet(this.ctx, envelope);
+			case "session.messages":
+				return await handleSessionMessages(this.ctx, envelope);
+			case "session.compaction.get":
+				return await handleSessionCompactionGet(this.ctx, envelope);
+			case "session.list":
+				return await handleSessionList(this.ctx, envelope);
+			case "session.update":
+				return await handleSessionUpdate(this.ctx, envelope);
+			case "session.update_connection":
+				return await handleSessionUpdateConnection(this.ctx, envelope);
+			case "session.compaction.update":
+				return await handleSessionCompactionUpdate(this.ctx, envelope);
+			case "session.pending_prompts":
+				return await handleSessionPendingPrompts(this.ctx, envelope);
+			case "session.update_pending_prompt":
+				return await handleSessionUpdatePendingPrompt(this.ctx, envelope);
+			case "session.remove_pending_prompt":
+				return await handleSessionRemovePendingPrompt(this.ctx, envelope);
+			case "session.delete":
+				return await handleSessionDelete(this.ctx, envelope);
+			case "session.hook":
+				return await handleSessionHook(this.ctx, envelope);
+			case "run.start":
+			case "session.send_input":
+				return await handleSessionInput(this.ctx, envelope);
+			case "run.abort":
+				return await handleRunAbort(this.ctx, envelope);
+			case "capability.request":
+				return await handleCapabilityRequest(this.ctx, envelope);
+			case "approval.respond":
+				return await handleApprovalRespond(this.ctx, envelope);
+			case "capability.respond":
+				return handleCapabilityRespond(this.ctx, envelope);
+			case "capability.progress":
+				return handleCapabilityProgress(this.ctx, envelope);
+			case "ui.notify":
+				this.publish(buildHubEvent("ui.notify", envelope.payload ?? {}));
+				return okReply(envelope);
+			case "ui.show_window":
+				this.publish(buildHubEvent("ui.show_window", envelope.payload ?? {}));
+				return okReply(envelope);
+			case "settings.list":
+				return await this.handleSettingsList(envelope);
+			case "settings.toggle":
+				return await this.handleSettingsToggle(envelope);
+			case "connector.channels":
+			case "connector.configure":
+			case "connector.delete_config":
+				return await handleConnectorCommand(this.ctx, envelope);
+			case "settings.get":
+			case "settings.patch":
+				return {
+					version: envelope.version,
+					requestId: envelope.requestId,
+					ok: false,
+					error: {
+						code: "not_implemented",
+						message: `${envelope.command} is not implemented yet.`,
+					},
+				};
+			default: {
+				const reply = await this.scheduleCommands.handleCommand(envelope);
+				if (reply.ok) {
+					const event = eventNameForScheduleCommand(envelope.command);
+					if (event) {
+						this.publish(buildHubEvent(event, reply.payload));
+					}
+				}
+				return reply;
+			}
+		}
+	}
+
+	private captureFailedReply(
+		envelope: HubCommandEnvelope,
+		reply: HubReplyEnvelope,
+	): void {
+		if (
+			reply.ok ||
+			!reply.error ||
+			!shouldCaptureHubReplyError(reply.error.code)
+		) {
+			return;
+		}
+		captureSdkError(this.options.telemetry, {
+			component: "core",
+			operation: "hub.command_reply",
+			error: new Error(reply.error.message),
+			severity: reply.error.code === "session_not_found" ? "warn" : "error",
+			handled: true,
+			context: {
+				...this.commandTelemetryContext(envelope),
+				errorCode: reply.error.code,
+			},
+		});
+	}
+
+	private commandTelemetryContext(envelope: HubCommandEnvelope) {
+		return {
+			command: envelope.command,
+			requestId: envelope.requestId,
+			clientId: envelope.clientId,
+			sessionId:
+				typeof envelope.payload?.sessionId === "string"
+					? envelope.payload.sessionId
+					: envelope.sessionId,
+		};
+	}
+
+	private async handleSettingsList(
+		envelope: HubCommandEnvelope,
+	): Promise<HubReplyEnvelope> {
+		try {
+			const snapshot = await this.settings.list(
+				parseSettingsListInput(envelope.payload),
+			);
+			return {
+				version: envelope.version,
+				requestId: envelope.requestId,
+				ok: true,
+				payload: { snapshot },
+			};
+		} catch (error) {
+			return {
+				version: envelope.version,
+				requestId: envelope.requestId,
+				ok: false,
+				error: {
+					code: "settings_list_failed",
+					message: error instanceof Error ? error.message : String(error),
+				},
+			};
+		}
+	}
+
+	private async handleSettingsToggle(
+		envelope: HubCommandEnvelope,
+	): Promise<HubReplyEnvelope> {
+		try {
+			const result = await this.settings.toggle(
+				parseSettingsToggleInput(envelope.payload),
+			);
+			this.publish(
+				buildHubEvent("settings.changed", {
+					types: result.changedTypes,
+					snapshot: result.snapshot,
+				}),
+			);
+			return {
+				version: envelope.version,
+				requestId: envelope.requestId,
+				ok: true,
+				payload: {
+					snapshot: result.snapshot,
+					changedTypes: result.changedTypes,
+				},
+			};
+		} catch (error) {
+			return {
+				version: envelope.version,
+				requestId: envelope.requestId,
+				ok: false,
+				error: {
+					code: "settings_toggle_failed",
+					message: error instanceof Error ? error.message : String(error),
+				},
+			};
+		}
+	}
+
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): () => void {
+		const current = this.listeners.get(clientId) ?? new Set();
+		const entry = { sessionId: options?.sessionId, listener };
+		current.add(entry);
+		this.listeners.set(clientId, current);
+		return () => {
+			const listeners = this.listeners.get(clientId);
+			if (!listeners) {
+				return;
+			}
+			listeners.delete(entry);
+			if (listeners.size === 0) {
+				this.listeners.delete(clientId);
+			}
+		};
+	}
+
+	private detachClientFromSessions(clientId: string): void {
+		for (const [sessionId, state] of this.sessionState.entries()) {
+			state.participants.delete(clientId);
+			if (state.createdByClientId === clientId) {
+				state.createdByClientId = undefined;
+			}
+			if (state.participants.size === 0) {
+				this.sessionState.delete(sessionId);
+			}
+		}
+		cancelPendingCapabilityRequests(
+			this.ctx,
+			(request) => request.targetClientId === clientId,
+			`Capability owner client ${clientId} disconnected before request was resolved.`,
+		);
+	}
+
+	private publish(event: HubEventEnvelope): void {
+		for (const entries of this.listeners.values()) {
+			for (const entry of entries) {
+				if (entry.sessionId && entry.sessionId !== event.sessionId) {
+					continue;
+				}
+				try {
+					entry.listener(event);
+				} catch (error) {
+					logHubBoundaryError(
+						`listener threw while publishing ${event.event}`,
+						error,
+					);
+					captureSdkError(this.options.telemetry, {
+						component: "core",
+						operation: "hub.publish",
+						error,
+						severity: "warn",
+						handled: true,
+						context: {
+							event: event.event,
+							sessionId: event.sessionId,
+						},
+					});
+				}
+			}
+		}
+	}
+}
+
+function shouldCaptureHubReplyError(code: string): boolean {
+	return (
+		code === "session_not_found" ||
+		code === "session_messages_not_found" ||
+		code === "hub_command_timeout" ||
+		code.endsWith("_failed")
+	);
+}
diff --git a/sdk/packages/core/src/hub/server/hub-session-records.ts b/sdk/packages/core/src/hub/server/hub-session-records.ts
new file mode 100644
index 0000000..3e2f8bb
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-session-records.ts
@@ -0,0 +1,99 @@
+import type {
+	SessionRecord as HubSessionRecord,
+	JsonValue,
+	SessionParticipant,
+} from "@cline/shared";
+import type { SessionAccumulatedUsage } from "../../runtime/host/runtime-host";
+import type { SessionRecord as LocalSessionRecord } from "../../types/sessions";
+
+export type HubSessionState = {
+	createdByClientId?: string;
+	interactive: boolean;
+	participants: Map<string, SessionParticipant>;
+};
+
+function mapLocalStatusToHubStatus(
+	status: LocalSessionRecord["status"],
+): HubSessionRecord["status"] {
+	switch (status) {
+		case "idle":
+			return "idle";
+		case "pending":
+			return "pending";
+		case "completed":
+			return "completed";
+		case "failed":
+			return "failed";
+		case "cancelled":
+			return "aborted";
+		default:
+			return "running";
+	}
+}
+
+function cloneSessionMetadata(
+	session: LocalSessionRecord,
+): Record<string, JsonValue | undefined> | undefined {
+	const metadata =
+		session.metadata && typeof session.metadata === "object"
+			? (JSON.parse(JSON.stringify(session.metadata)) as Record<
+					string,
+					JsonValue | undefined
+				>)
+			: ({} as Record<string, JsonValue | undefined>);
+	if (session.parentSessionId?.trim())
+		metadata.parentSessionId = session.parentSessionId;
+	if (session.parentAgentId?.trim())
+		metadata.parentAgentId = session.parentAgentId;
+	if (session.agentId?.trim()) metadata.agentId = session.agentId;
+	if (session.conversationId?.trim())
+		metadata.conversationId = session.conversationId;
+	if (session.messagesPath?.trim())
+		metadata.messagesPath = session.messagesPath;
+	if (session.prompt?.trim()) metadata.prompt = session.prompt;
+	if (session.provider?.trim()) metadata.provider = session.provider;
+	if (session.model?.trim()) metadata.model = session.model;
+	if (session.source?.trim()) metadata.source = session.source;
+	if (typeof session.pid === "number") metadata.pid = session.pid;
+	return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+export function toHubSessionRecord(
+	session: LocalSessionRecord,
+	state?: HubSessionState,
+	usage?: SessionAccumulatedUsage,
+	aggregateUsage?: SessionAccumulatedUsage,
+): HubSessionRecord {
+	return {
+		sessionId: session.sessionId,
+		workspaceRoot: session.workspaceRoot,
+		cwd: session.cwd,
+		createdAt: Date.parse(session.startedAt),
+		updatedAt: Date.parse(session.updatedAt),
+		createdByClientId: state?.createdByClientId ?? "hub",
+		status: mapLocalStatusToHubStatus(session.status),
+		participants: state ? [...state.participants.values()] : [],
+		metadata: cloneSessionMetadata(session),
+		runtimeOptions: {
+			enableTools: session.enableTools,
+			enableSpawn: session.enableSpawn,
+			enableTeams: session.enableTeams,
+			mode:
+				typeof session.metadata?.mode === "string"
+					? (session.metadata.mode as "act" | "plan" | "yolo")
+					: undefined,
+			systemPrompt:
+				typeof session.metadata?.systemPrompt === "string"
+					? session.metadata.systemPrompt
+					: undefined,
+		},
+		runtimeSession: session.agentId
+			? {
+					agentId: session.agentId,
+					team: session.teamName ? { teamId: session.teamName } : undefined,
+				}
+			: undefined,
+		...(usage ? { usage: { ...usage } } : {}),
+		...(aggregateUsage ? { aggregateUsage: { ...aggregateUsage } } : {}),
+	};
+}
diff --git a/sdk/packages/core/src/hub/server/hub-websocket-server.test.ts b/sdk/packages/core/src/hub/server/hub-websocket-server.test.ts
new file mode 100644
index 0000000..be9345b
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-websocket-server.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import {
+	isLocalHubHostName,
+	isLocalHubOrigin,
+	readBearerToken,
+} from "./hub-websocket-server";
+
+describe("readBearerToken", () => {
+	it("reads a bearer token with case-insensitive scheme", () => {
+		expect(readBearerToken("Bearer token")).toBe("token");
+		expect(readBearerToken("bearer token")).toBe("token");
+	});
+
+	it("reads a bearer token separated by tabs without regex backtracking", () => {
+		expect(readBearerToken(`bearer\t\t${"token"}`)).toBe("token");
+		expect(readBearerToken(`bearer${"\t".repeat(10_000)}token`)).toBe("token");
+	});
+
+	it("rejects missing and malformed bearer tokens", () => {
+		expect(readBearerToken(undefined)).toBeNull();
+		expect(readBearerToken("Bearer")).toBeNull();
+		expect(readBearerToken("BearerToken")).toBeNull();
+		expect(readBearerToken("Basic token")).toBeNull();
+	});
+});
+
+describe("loopback websocket origin auth", () => {
+	it("recognizes loopback Hub hosts and browser origins", () => {
+		expect(isLocalHubHostName("127.0.0.1")).toBe(true);
+		expect(isLocalHubHostName("localhost")).toBe(true);
+		expect(isLocalHubHostName("::1")).toBe(true);
+		expect(isLocalHubOrigin("http://localhost:3000")).toBe(true);
+		expect(isLocalHubOrigin("http://127.0.0.1:3017")).toBe(true);
+	});
+
+	it("rejects non-loopback browser origins", () => {
+		expect(isLocalHubOrigin("https://example.com")).toBe(false);
+		expect(isLocalHubOrigin("http://192.168.1.10:3000")).toBe(false);
+		expect(isLocalHubOrigin(undefined)).toBe(false);
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/hub-websocket-server.ts b/sdk/packages/core/src/hub/server/hub-websocket-server.ts
new file mode 100644
index 0000000..0488b51
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/hub-websocket-server.ts
@@ -0,0 +1,654 @@
+import { timingSafeEqual } from "node:crypto";
+import http from "node:http";
+import net from "node:net";
+import { URL } from "node:url";
+import {
+	CURRENT_HUB_PROTOCOL_VERSION,
+	HUB_CAPABILITIES,
+	isHubProtocolCompatible,
+	MAX_CLIENT_HUB_PROTOCOL_VERSION,
+	MIN_CLIENT_HUB_PROTOCOL_VERSION,
+} from "@cline/shared";
+import { WebSocketServer } from "ws";
+import corePackage from "../../../package.json";
+import { rememberRecoverableLocalHubUrl, verifyHubConnection } from "../client";
+import {
+	clearHubDiscovery,
+	createHubAuthToken,
+	createHubServerUrl,
+	type HubServerDiscoveryRecord,
+	probeHubServer,
+	readHubDiscovery,
+	resolveHubBuildId,
+	resolveHubOwnerContext,
+	withHubStartupLock,
+	writeHubDiscovery,
+} from "../discovery";
+import { resolveDefaultHubPort } from "../discovery/defaults";
+import { BrowserWebSocketHubAdapter } from "./browser-websocket";
+import type {
+	EnsuredHubWebSocketServerResult,
+	EnsureHubWebSocketServerOptions,
+	HubWebSocketServer,
+	HubWebSocketServerOptions,
+} from "./hub-server-options";
+import { HubServerTransport } from "./hub-server-transport";
+import { NativeHubTransportAdapter } from "./native-transport";
+
+export { truncateNotificationBody } from "./hub-notifications";
+export type {
+	EnsuredHubWebSocketServerResult,
+	EnsureHubWebSocketServerOptions,
+	HubWebSocketServer,
+	HubWebSocketServerOptions,
+} from "./hub-server-options";
+export { HubServerTransport } from "./hub-server-transport";
+
+type NodeWebSocketLike = {
+	send(data: string): void;
+	on(event: "message", listener: (data: unknown) => void): void;
+	on(event: "close", listener: () => void): void;
+	on(event: "pong", listener: () => void): void;
+	once(event: "close", listener: () => void): void;
+	ping?(): void;
+	terminate?(): void;
+};
+
+type TrackedNodeWebSocket = NodeWebSocketLike & {
+	isAlive?: boolean;
+};
+
+type NodeUpgradeSocketLike = {
+	destroy(error?: Error): void;
+	write(chunk: string): boolean;
+	end(): void;
+};
+
+function decodeSocketData(data: unknown): string {
+	if (typeof data === "string") {
+		return data;
+	}
+	if (data instanceof Uint8Array) {
+		return Buffer.from(data).toString();
+	}
+	if (data instanceof ArrayBuffer) {
+		return Buffer.from(data).toString();
+	}
+	if (Array.isArray(data)) {
+		return Buffer.concat(data.map((chunk) => Buffer.from(chunk))).toString();
+	}
+	return String(data);
+}
+
+function wrapWsSocket(socket: NodeWebSocketLike) {
+	return {
+		send(data: string): void {
+			socket.send(data);
+		},
+		addEventListener(
+			type: "message" | "close",
+			listener: (...args: never[]) => void,
+		): void {
+			if (type === "message") {
+				socket.on("message", (data: unknown) => {
+					(listener as (event: { data: string }) => void)({
+						data: decodeSocketData(data),
+					});
+				});
+				return;
+			}
+			socket.on("close", listener as () => void);
+		},
+		removeEventListener(): void {},
+	};
+}
+
+function rejectUpgradeSocket(socket: NodeUpgradeSocketLike): void {
+	try {
+		socket.write(
+			"HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+		);
+		socket.end();
+	} catch {
+		socket.destroy();
+	}
+}
+
+function rejectUnauthorizedUpgradeSocket(socket: NodeUpgradeSocketLike): void {
+	try {
+		socket.write(
+			"HTTP/1.1 401 Unauthorized\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+		);
+		socket.end();
+	} catch {
+		socket.destroy();
+	}
+}
+
+function isValidHubAuthToken(
+	candidate: string | null,
+	expected: string,
+): boolean {
+	if (!candidate || !expected) {
+		return false;
+	}
+	const candidateBuffer = Buffer.from(candidate, "utf8");
+	const expectedBuffer = Buffer.from(expected, "utf8");
+	return (
+		candidateBuffer.length === expectedBuffer.length &&
+		timingSafeEqual(candidateBuffer, expectedBuffer)
+	);
+}
+
+function formatHubStartupError(
+	error: unknown,
+	context: {
+		host: string;
+		port: number;
+		pathname: string;
+	},
+): Error {
+	const code =
+		error &&
+		typeof error === "object" &&
+		"code" in error &&
+		typeof (error as { code?: unknown }).code === "string"
+			? (error as { code: string }).code
+			: undefined;
+	const message =
+		error instanceof Error
+			? error.message
+			: typeof error === "string"
+				? error
+				: "Unknown startup error";
+	const details = `Failed to start hub server on ${context.host}:${context.port}${context.pathname}: ${message}`;
+	const wrapped = new Error(code ? `${details} (${code})` : details);
+	if (code) {
+		(error as Error & { code?: string }).code = code;
+		(wrapped as Error & { code?: string }).code = code;
+	}
+	if (error instanceof Error && error.stack) {
+		wrapped.stack = `${wrapped.name}: ${wrapped.message}\nCaused by: ${error.stack}`;
+	}
+	return wrapped;
+}
+
+async function resolveEphemeralPort(host: string): Promise<number> {
+	return await new Promise<number>((resolve, reject) => {
+		const probe = net.createServer();
+		probe.once("error", reject);
+		probe.listen(0, host, () => {
+			const address = probe.address();
+			if (!address || typeof address === "string") {
+				probe.close(() => reject(new Error("Failed to resolve free port")));
+				return;
+			}
+			const port = address.port;
+			probe.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(port);
+			});
+		});
+	});
+}
+
+function isAddressInUseError(error: unknown): boolean {
+	return (
+		error instanceof Error &&
+		"code" in error &&
+		(error as Error & { code?: string }).code === "EADDRINUSE"
+	);
+}
+
+const SHARED_SERVERS = new Map<string, Promise<HubWebSocketServer>>();
+const HUB_AUTH_PROTOCOL_PREFIX = "cline-hub-auth.";
+const HUB_SOCKET_HEARTBEAT_INTERVAL_MS = 30_000;
+
+function parseHeaderValue(value: string | string[] | undefined): string {
+	return Array.isArray(value) ? value.join(",") : (value ?? "");
+}
+
+function isAuthHeaderWhitespace(code: number): boolean {
+	return code === 0x20 || code === 0x09;
+}
+
+export function readBearerToken(
+	value: string | string[] | undefined,
+): string | null {
+	const header = parseHeaderValue(value).trim();
+	const bearerScheme = "bearer";
+	if (
+		header.length <= bearerScheme.length ||
+		header.slice(0, bearerScheme.length).toLowerCase() !== bearerScheme ||
+		!isAuthHeaderWhitespace(header.charCodeAt(bearerScheme.length))
+	) {
+		return null;
+	}
+
+	let tokenStart = bearerScheme.length + 1;
+	while (
+		tokenStart < header.length &&
+		isAuthHeaderWhitespace(header.charCodeAt(tokenStart))
+	) {
+		tokenStart += 1;
+	}
+
+	return header.slice(tokenStart).trim() || null;
+}
+
+function readWebSocketAuthToken(
+	value: string | string[] | undefined,
+): string | null {
+	for (const protocol of parseHeaderValue(value).split(",")) {
+		const trimmed = protocol.trim();
+		if (trimmed.startsWith(HUB_AUTH_PROTOCOL_PREFIX)) {
+			return trimmed.slice(HUB_AUTH_PROTOCOL_PREFIX.length).trim() || null;
+		}
+	}
+	return null;
+}
+
+/** @internal Exported for websocket auth tests. */
+export function isLocalHubHostName(value: string): boolean {
+	const normalized = value.trim().toLowerCase();
+	return (
+		normalized === "localhost" ||
+		normalized === "127.0.0.1" ||
+		normalized === "::1" ||
+		normalized === "[::1]"
+	);
+}
+
+/** @internal Exported for websocket auth tests. */
+export function isLocalHubOrigin(
+	value: string | string[] | undefined,
+): boolean {
+	const raw = parseHeaderValue(value).trim();
+	if (!raw) {
+		return false;
+	}
+	try {
+		return isLocalHubHostName(new URL(raw).hostname);
+	} catch {
+		return false;
+	}
+}
+
+export async function startHubWebSocketServer(
+	options: HubWebSocketServerOptions,
+): Promise<HubWebSocketServer> {
+	const owner = options.owner ?? resolveHubOwnerContext();
+	const host = options.host ?? "127.0.0.1";
+	const pathname = options.pathname ?? "/hub";
+	const configuredPort = options.port ?? resolveDefaultHubPort();
+	const requestedPort =
+		configuredPort === 0 ? await resolveEphemeralPort(host) : configuredPort;
+	let port = requestedPort;
+	let url = createHubServerUrl(host, requestedPort, pathname);
+	const buildId = resolveHubBuildId();
+	const authToken = createHubAuthToken();
+	const transport = new HubServerTransport(options);
+	await transport.start();
+	const adapter = new BrowserWebSocketHubAdapter(
+		new NativeHubTransportAdapter(transport),
+		options.telemetry,
+	);
+	const cleanup = new Set<() => void>();
+	const startedAt = new Date().toISOString();
+	const versionPayload = {
+		protocolVersion: CURRENT_HUB_PROTOCOL_VERSION,
+		minClientProtocolVersion: MIN_CLIENT_HUB_PROTOCOL_VERSION,
+		maxClientProtocolVersion: MAX_CLIENT_HUB_PROTOCOL_VERSION,
+		capabilities: HUB_CAPABILITIES,
+		coreVersion: corePackage.version,
+		buildId,
+		pid: process.pid,
+		startedAt,
+	} as const;
+	const sockets = new Set<TrackedNodeWebSocket>();
+	let heartbeatTimer: ReturnType<typeof setInterval> | undefined;
+	let closePromise: Promise<void> | undefined;
+
+	const closeServer = async (): Promise<void> => {
+		if (closePromise) {
+			return closePromise;
+		}
+		closePromise = (async () => {
+			if (heartbeatTimer) {
+				clearInterval(heartbeatTimer);
+				heartbeatTimer = undefined;
+			}
+			for (const websocket of sockets) {
+				websocket.terminate?.();
+			}
+			sockets.clear();
+			for (const detach of cleanup) {
+				detach();
+			}
+			cleanup.clear();
+			await new Promise<void>((resolve, reject) => {
+				wss.close((error?: Error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve();
+				});
+			});
+			await new Promise<void>((resolve, reject) => {
+				server.close((error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve();
+				});
+			});
+			await transport.stop();
+			const current = await readHubDiscovery(owner.discoveryPath);
+			if (current?.url === url) {
+				await clearHubDiscovery(owner.discoveryPath);
+			}
+		})();
+		return closePromise;
+	};
+
+	const server = http.createServer((req, res) => {
+		if ((req.url ?? "/") === "/health") {
+			const body = JSON.stringify({
+				ok: true,
+				protocolVersion: versionPayload.protocolVersion,
+				minClientProtocolVersion: versionPayload.minClientProtocolVersion,
+				maxClientProtocolVersion: versionPayload.maxClientProtocolVersion,
+				coreVersion: versionPayload.coreVersion,
+				host,
+				port,
+				url,
+			});
+			res.statusCode = 200;
+			res.setHeader("content-type", "application/json");
+			res.end(body);
+			return;
+		}
+		if ((req.url ?? "/") === "/status") {
+			if (
+				!isValidHubAuthToken(
+					readBearerToken(req.headers.authorization),
+					authToken,
+				)
+			) {
+				res.statusCode = 401;
+				res.end("Unauthorized");
+				return;
+			}
+			const body = JSON.stringify({
+				hubId: transport.getHubId(),
+				...versionPayload,
+				authToken,
+				host,
+				port,
+				url,
+				updatedAt: new Date().toISOString(),
+			} satisfies HubServerDiscoveryRecord);
+			res.statusCode = 200;
+			res.setHeader("content-type", "application/json");
+			res.end(body);
+			return;
+		}
+		if ((req.url ?? "/") === "/version") {
+			res.statusCode = 200;
+			res.setHeader("content-type", "application/json");
+			res.end(JSON.stringify(versionPayload));
+			return;
+		}
+		const requestUrl = new URL(req.url ?? "/", `http://${host}:${port}`);
+		if (requestUrl.pathname === "/shutdown" && req.method === "POST") {
+			if (
+				!isValidHubAuthToken(
+					readBearerToken(req.headers.authorization),
+					authToken,
+				)
+			) {
+				res.statusCode = 401;
+				res.end("Unauthorized");
+				return;
+			}
+			res.statusCode = 202;
+			res.setHeader("content-type", "application/json");
+			res.end(JSON.stringify({ ok: true }));
+			queueMicrotask(() => {
+				void closeServer();
+			});
+			return;
+		}
+		res.statusCode = 404;
+		res.end("Not found");
+	});
+	const wss = new WebSocketServer({ noServer: true });
+	heartbeatTimer = setInterval(() => {
+		for (const websocket of sockets) {
+			if (websocket.isAlive === false) {
+				try {
+					websocket.terminate?.();
+				} catch {
+					// The socket is already unhealthy; cleanup below is sufficient.
+				}
+				sockets.delete(websocket);
+				continue;
+			}
+			websocket.isAlive = false;
+			try {
+				websocket.ping?.();
+			} catch {
+				try {
+					websocket.terminate?.();
+				} catch {
+					// best-effort termination
+				}
+				sockets.delete(websocket);
+			}
+		}
+	}, HUB_SOCKET_HEARTBEAT_INTERVAL_MS);
+
+	server.on("upgrade", (request, socket, head) => {
+		const requestUrl = new URL(request.url ?? "/", `http://${host}:${port}`);
+		if (requestUrl.pathname !== pathname) {
+			socket.destroy();
+			return;
+		}
+		const isAuthorized =
+			isValidHubAuthToken(
+				readWebSocketAuthToken(request.headers["sec-websocket-protocol"]),
+				authToken,
+			) ||
+			(isLocalHubHostName(host) && isLocalHubOrigin(request.headers.origin));
+		if (!isAuthorized) {
+			rejectUnauthorizedUpgradeSocket(socket);
+			return;
+		}
+		try {
+			wss.handleUpgrade(
+				request,
+				socket,
+				head,
+				(websocket: NodeWebSocketLike) => {
+					const tracked = websocket as TrackedNodeWebSocket;
+					tracked.isAlive = true;
+					tracked.on("pong", () => {
+						tracked.isAlive = true;
+					});
+					sockets.add(tracked);
+					const detach = adapter.attach(wrapWsSocket(websocket));
+					cleanup.add(detach);
+					websocket.once("close", () => {
+						sockets.delete(tracked);
+						detach();
+						cleanup.delete(detach);
+					});
+				},
+			);
+		} catch {
+			rejectUpgradeSocket(socket);
+		}
+	});
+
+	try {
+		await new Promise<void>((resolve, reject) => {
+			server.once("error", (error) => {
+				reject(
+					formatHubStartupError(error, {
+						host,
+						port: requestedPort,
+						pathname,
+					}),
+				);
+			});
+			server.listen(requestedPort, host, () => {
+				const address = server.address();
+				if (!address || typeof address === "string") {
+					reject(
+						formatHubStartupError(new Error("Failed to resolve hub port"), {
+							host,
+							port: requestedPort,
+							pathname,
+						}),
+					);
+					return;
+				}
+				port = address.port;
+				url = createHubServerUrl(host, port, pathname);
+				resolve();
+			});
+		});
+	} catch (error) {
+		if (heartbeatTimer) {
+			clearInterval(heartbeatTimer);
+			heartbeatTimer = undefined;
+		}
+		await transport.stop().catch(() => undefined);
+		throw error;
+	}
+
+	await writeHubDiscovery(owner.discoveryPath, {
+		hubId: transport.getHubId(),
+		protocolVersion: CURRENT_HUB_PROTOCOL_VERSION,
+		minClientProtocolVersion: MIN_CLIENT_HUB_PROTOCOL_VERSION,
+		maxClientProtocolVersion: MAX_CLIENT_HUB_PROTOCOL_VERSION,
+		capabilities: [...versionPayload.capabilities],
+		coreVersion: corePackage.version,
+		buildId,
+		authToken,
+		host,
+		port,
+		url,
+		pid: process.pid,
+		startedAt,
+		updatedAt: startedAt,
+	});
+
+	return {
+		host,
+		port,
+		url,
+		authToken,
+		close: closeServer,
+	};
+}
+
+export async function ensureHubWebSocketServer(
+	options: EnsureHubWebSocketServerOptions,
+): Promise<EnsuredHubWebSocketServerResult> {
+	const owner = options.owner ?? resolveHubOwnerContext();
+	const hasExplicitEndpoint =
+		options.host !== undefined ||
+		options.port !== undefined ||
+		options.pathname !== undefined ||
+		!!process.env.CLINE_HUB_PORT?.trim();
+	const host = options.host ?? "127.0.0.1";
+	const port = options.port ?? resolveDefaultHubPort();
+	const pathname = options.pathname ?? "/hub";
+	const expectedUrl = createHubServerUrl(host, port, pathname);
+	const sharedKey = owner.discoveryPath;
+	const rememberIfManaged = <T extends EnsuredHubWebSocketServerResult>(
+		result: T,
+	): T => {
+		if (!hasExplicitEndpoint) {
+			rememberRecoverableLocalHubUrl(result.url, result.authToken);
+		}
+		return result;
+	};
+	const existing = SHARED_SERVERS.get(sharedKey);
+	if (existing) {
+		const server = await existing;
+		if (server.url === expectedUrl) {
+			return rememberIfManaged({
+				server,
+				url: server.url,
+				authToken: server.authToken,
+				action: "reuse",
+			});
+		}
+	}
+
+	return await withHubStartupLock(owner.discoveryPath, async () => {
+		const discovered = await readHubDiscovery(owner.discoveryPath);
+		const canReuseDiscovered =
+			discovered?.url &&
+			(discovered.url === expectedUrl || options.allowPortFallback === true);
+		if (canReuseDiscovered) {
+			const healthy = await probeHubServer(discovered.url, {
+				authToken: discovered.authToken,
+			});
+			if (
+				healthy?.url &&
+				isHubProtocolCompatible(healthy).compatible &&
+				(await verifyHubConnection(healthy.url, {
+					authToken: discovered.authToken,
+				}))
+			) {
+				return rememberIfManaged({
+					url: healthy.url,
+					authToken: discovered.authToken,
+					action: "reuse",
+				});
+			}
+		}
+
+		// The discovered hub was not reusable (missing, mismatched, or failed
+		// verification), so its record is stale either way.
+		if (discovered?.url) {
+			await clearHubDiscovery(owner.discoveryPath);
+		}
+
+		const start = async (
+			startOptions: HubWebSocketServerOptions,
+		): Promise<EnsuredHubWebSocketServerResult> => {
+			const serverPromise = startHubWebSocketServer({ ...startOptions, owner });
+			SHARED_SERVERS.set(sharedKey, serverPromise);
+			try {
+				const server = await serverPromise;
+				return rememberIfManaged({
+					server,
+					url: server.url,
+					authToken: server.authToken,
+					action: "started",
+				});
+			} catch (error) {
+				SHARED_SERVERS.delete(sharedKey);
+				throw error;
+			}
+		};
+
+		try {
+			return await start(options);
+		} catch (error) {
+			if (!options.allowPortFallback || !isAddressInUseError(error)) {
+				throw error;
+			}
+			return await start({ ...options, port: 0 });
+		}
+	});
+}
diff --git a/sdk/packages/core/src/hub/server/index.test.ts b/sdk/packages/core/src/hub/server/index.test.ts
new file mode 100644
index 0000000..fefa387
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/index.test.ts
@@ -0,0 +1,358 @@
+import { createServer as createHttpServer } from "node:http";
+import {
+	createConnection,
+	createServer as createNetServer,
+	type Socket,
+} from "node:net";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { WebSocketServer } from "ws";
+import { createLocalHubScheduleRuntimeHandlers } from "../daemon/runtime-handlers";
+import {
+	clearHubDiscovery,
+	createInMemoryHubOwnerContext,
+	readHubDiscovery,
+	toHubHealthUrl,
+	writeHubDiscovery,
+} from "../discovery";
+import {
+	ensureHubWebSocketServer,
+	type HubWebSocketServer,
+	startHubWebSocketServer,
+} from "../server";
+
+async function reservePort(): Promise<number> {
+	return await new Promise((resolve, reject) => {
+		const server = createNetServer();
+		server.once("error", reject);
+		server.listen({ host: "127.0.0.1", port: 0 }, () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close(() => reject(new Error("Failed to reserve test port")));
+				return;
+			}
+			const { port } = address;
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(port);
+			});
+		});
+	});
+}
+
+async function sendRawHttpRequest(
+	port: number,
+	request: string,
+): Promise<string> {
+	return await new Promise((resolve, reject) => {
+		let response = "";
+		const socket = createConnection({ host: "127.0.0.1", port }, () => {
+			socket.write(request);
+		});
+		socket.setEncoding("utf8");
+		socket.on("data", (chunk) => {
+			response += chunk;
+		});
+		socket.on("end", () => {
+			resolve(response);
+		});
+		socket.on("error", (error) => {
+			reject(error);
+		});
+	});
+}
+
+function requireServer(
+	server: HubWebSocketServer | undefined,
+): HubWebSocketServer {
+	expect(server).toBeDefined();
+	if (!server) {
+		throw new Error("Expected hub server to be defined");
+	}
+	return server;
+}
+
+describe("hub server startup", () => {
+	const servers = new Set<HubWebSocketServer>();
+
+	afterEach(async () => {
+		for (const server of servers) {
+			await server.close();
+		}
+		servers.clear();
+	});
+
+	it("starts on the requested port instead of drifting to a random port", async () => {
+		const owner = createInMemoryHubOwnerContext("hub-server-test-fixed-port");
+		const port = await reservePort();
+		await writeHubDiscovery(owner.discoveryPath, {
+			hubId: "stale-hub",
+			protocolVersion: "v1",
+			authToken: "stale-token",
+			host: "127.0.0.1",
+			port: port + 1,
+			url: `ws://127.0.0.1:${port + 1}/hub`,
+			startedAt: new Date(0).toISOString(),
+			updatedAt: new Date(0).toISOString(),
+		});
+
+		const result = await ensureHubWebSocketServer({
+			owner,
+			host: "127.0.0.1",
+			port,
+			pathname: "/hub",
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		expect(result.url).toBe(`ws://127.0.0.1:${port}/hub`);
+		expect(result.action).toBe("started");
+		const server = requireServer(result.server);
+		servers.add(server);
+
+		await expect(readHubDiscovery(owner.discoveryPath)).resolves.toMatchObject({
+			port,
+			url: `ws://127.0.0.1:${port}/hub`,
+		});
+	});
+
+	it("fails when the requested port is already occupied", async () => {
+		const owner = createInMemoryHubOwnerContext("hub-server-test-port-busy");
+		const port = await reservePort();
+		const blocker = createNetServer();
+		await new Promise<void>((resolve, reject) => {
+			blocker.once("error", reject);
+			blocker.listen({ host: "127.0.0.1", port }, () => resolve());
+		});
+
+		try {
+			await expect(
+				startHubWebSocketServer({
+					owner,
+					host: "127.0.0.1",
+					port,
+					pathname: "/hub",
+					runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+				}),
+			).rejects.toMatchObject({ code: "EADDRINUSE" });
+			await expect(
+				readHubDiscovery(owner.discoveryPath),
+			).resolves.toBeUndefined();
+		} finally {
+			await new Promise<void>((resolve, reject) => {
+				blocker.close((error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve();
+				});
+			});
+			await clearHubDiscovery(owner.discoveryPath);
+		}
+	});
+
+	it("falls back to an ephemeral port when fallback is allowed", async () => {
+		const owner = createInMemoryHubOwnerContext(
+			"hub-server-test-port-fallback",
+		);
+		const port = await reservePort();
+		const blockerSockets = new Set<Socket>();
+		const blocker = createHttpServer((_req, res) => {
+			res.statusCode = 404;
+			res.setHeader("connection", "close");
+			res.end("not a hub");
+		});
+		blocker.on("connection", (socket) => {
+			blockerSockets.add(socket);
+			socket.once("close", () => {
+				blockerSockets.delete(socket);
+			});
+		});
+		await new Promise<void>((resolve, reject) => {
+			blocker.once("error", reject);
+			blocker.listen({ host: "127.0.0.1", port }, () => resolve());
+		});
+
+		try {
+			const result = await ensureHubWebSocketServer({
+				owner,
+				host: "127.0.0.1",
+				port,
+				pathname: "/hub",
+				allowPortFallback: true,
+				runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			});
+
+			expect(result.action).toBe("started");
+			const server = requireServer(result.server);
+			expect(server.port).not.toBe(port);
+			servers.add(server);
+		} finally {
+			for (const socket of blockerSockets) {
+				socket.destroy();
+			}
+			await new Promise<void>((resolve, reject) => {
+				blocker.close((error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve();
+				});
+			});
+			await clearHubDiscovery(owner.discoveryPath);
+		}
+	});
+
+	it("shuts down active server through the shutdown endpoint", async () => {
+		const owner = createInMemoryHubOwnerContext("hub-server-test-shutdown");
+		const result = await ensureHubWebSocketServer({
+			owner,
+			host: "127.0.0.1",
+			port: 0,
+			pathname: "/hub",
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		const server = requireServer(result.server);
+		servers.add(server);
+
+		const shutdownUrl = new URL(toHubHealthUrl(result.url));
+		shutdownUrl.pathname = "/shutdown";
+		const discovery = await readHubDiscovery(owner.discoveryPath);
+		if (!discovery) {
+			throw new Error("Expected hub discovery to be written");
+		}
+		expect(discovery.authToken).toMatch(/^[a-f0-9]{64}$/);
+		const authToken = discovery.authToken;
+		const response = await fetch(shutdownUrl, {
+			method: "POST",
+			headers: { authorization: `Bearer ${authToken}` },
+		});
+		expect(response.status).toBe(202);
+
+		for (let index = 0; index < 50; index += 1) {
+			if ((await readHubDiscovery(owner.discoveryPath)) === undefined) {
+				servers.delete(server);
+				return;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+
+		throw new Error("Timed out waiting for hub shutdown");
+	});
+
+	it("rejects shutdown request with 401 when no auth token is provided", async () => {
+		const owner = createInMemoryHubOwnerContext(
+			"hub-server-test-shutdown-unauth",
+		);
+		const result = await ensureHubWebSocketServer({
+			owner,
+			host: "127.0.0.1",
+			port: 0,
+			pathname: "/hub",
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		servers.add(requireServer(result.server));
+
+		const shutdownUrl = new URL(toHubHealthUrl(result.url));
+		shutdownUrl.pathname = "/shutdown";
+
+		// No Authorization header
+		const noTokenResponse = await fetch(shutdownUrl, { method: "POST" });
+		expect(noTokenResponse.status).toBe(401);
+
+		// Wrong token
+		const wrongTokenResponse = await fetch(shutdownUrl, {
+			method: "POST",
+			headers: { authorization: "Bearer wrong-token" },
+		});
+		expect(wrongTokenResponse.status).toBe(401);
+
+		// Server should still be alive
+		const health = await fetch(new URL("/health", toHubHealthUrl(result.url)));
+		expect(health.status).toBe(200);
+	});
+
+	it("rejects WebSocket upgrade with 401 when no auth token is provided", async () => {
+		const owner = createInMemoryHubOwnerContext("hub-server-test-ws-unauth");
+		const result = await ensureHubWebSocketServer({
+			owner,
+			host: "127.0.0.1",
+			port: 0,
+			pathname: "/hub",
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		servers.add(requireServer(result.server));
+
+		const hubUrl = new URL(result.url);
+
+		// WebSocket upgrade with no Sec-WebSocket-Protocol token
+		const response = await sendRawHttpRequest(
+			Number(hubUrl.port),
+			[
+				"GET /hub HTTP/1.1",
+				"Host: 127.0.0.1",
+				"Connection: Upgrade",
+				"Upgrade: websocket",
+				"Sec-WebSocket-Version: 13",
+				"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==",
+				"",
+				"",
+			].join("\r\n"),
+		);
+
+		expect(response).toContain("401 Unauthorized");
+	});
+
+	it("survives websocket upgrade handler failures", async () => {
+		const owner = createInMemoryHubOwnerContext(
+			"hub-server-test-upgrade-guard",
+		);
+		const handleUpgrade = vi
+			.spyOn(WebSocketServer.prototype, "handleUpgrade")
+			.mockImplementation(() => {
+				throw new Error("boom");
+			});
+		try {
+			const result = await ensureHubWebSocketServer({
+				owner,
+				host: "127.0.0.1",
+				port: 0,
+				pathname: "/hub",
+				runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			});
+			servers.add(requireServer(result.server));
+
+			const hubUrl = new URL(result.url);
+			const discovery = await readHubDiscovery(owner.discoveryPath);
+			if (!discovery) {
+				throw new Error("Expected hub discovery to be written");
+			}
+			const authToken = discovery.authToken;
+			const response = await sendRawHttpRequest(
+				Number(hubUrl.port),
+				[
+					"GET /hub HTTP/1.1",
+					"Host: 127.0.0.1",
+					"Connection: Upgrade",
+					"Upgrade: websocket",
+					`Sec-WebSocket-Protocol: cline-hub-auth.${authToken}`,
+					"Sec-WebSocket-Version: 13",
+					"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==",
+					"",
+					"",
+				].join("\r\n"),
+			);
+
+			expect(response).toContain("400 Bad Request");
+
+			const health = await fetch(
+				new URL("/health", `http://127.0.0.1:${hubUrl.port}`),
+			);
+			expect(health.status).toBe(200);
+		} finally {
+			handleUpgrade.mockRestore();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/index.ts b/sdk/packages/core/src/hub/server/index.ts
new file mode 100644
index 0000000..8da3076
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/index.ts
@@ -0,0 +1,4 @@
+export { truncateNotificationBody } from "./hub-notifications";
+export * from "./hub-server-options";
+export * from "./hub-server-transport";
+export * from "./hub-websocket-server";
diff --git a/sdk/packages/core/src/hub/server/native-transport.ts b/sdk/packages/core/src/hub/server/native-transport.ts
new file mode 100644
index 0000000..0bcb288
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/native-transport.ts
@@ -0,0 +1,31 @@
+import type {
+	HubCommandEnvelope,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+} from "@cline/shared";
+import type { HubCommandTransport } from "./command-transport";
+
+export interface NativeHubTransport {
+	handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): () => void;
+}
+
+export class NativeHubTransportAdapter implements HubCommandTransport {
+	constructor(private readonly transport: NativeHubTransport) {}
+
+	command(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope> {
+		return this.transport.handleCommand(envelope);
+	}
+
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): () => void {
+		return this.transport.subscribe(clientId, listener, options);
+	}
+}
diff --git a/sdk/packages/core/src/hub/server/notification.test.ts b/sdk/packages/core/src/hub/server/notification.test.ts
new file mode 100644
index 0000000..368c22e
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/notification.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { truncateNotificationBody } from "../server";
+
+describe("truncateNotificationBody", () => {
+	it("keeps short notification bodies unchanged", () => {
+		expect(truncateNotificationBody("short reply")).toBe("short reply");
+	});
+
+	it("truncates long notification bodies with an ellipsis", () => {
+		const body = "a".repeat(200);
+		const truncated = truncateNotificationBody(body);
+		expect(truncated).toBe(`${"a".repeat(117)}...`);
+	});
+
+	it("applies the same truncation budget to multibyte text", () => {
+		const body = "🙂".repeat(40);
+		const truncated = truncateNotificationBody(body);
+		expect(Buffer.byteLength(truncated, "utf8")).toBeLessThanOrEqual(120);
+		expect(truncated.endsWith("...")).toBe(true);
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/ui-events.test.ts b/sdk/packages/core/src/hub/server/ui-events.test.ts
new file mode 100644
index 0000000..0e349c1
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/ui-events.test.ts
@@ -0,0 +1,232 @@
+import type { HubUINotifyPayload } from "@cline/shared";
+import { afterEach, describe, expect, it } from "vitest";
+import { SessionSource } from "../../types/common";
+import { HubUIClient } from "../client/ui-client";
+import { createLocalHubScheduleRuntimeHandlers } from "../daemon/runtime-handlers";
+import { startHubServer } from "../daemon/start-shared-server";
+
+function waitForEvent<T>(
+	subscribe: (resolve: (payload: T) => void) => () => void,
+): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			unsubscribe();
+			reject(new Error("Timed out waiting for hub UI event"));
+		}, 1_000);
+		const unsubscribe = subscribe((payload) => {
+			clearTimeout(timeout);
+			unsubscribe();
+			resolve(payload);
+		});
+	});
+}
+
+describe("hub UI events", () => {
+	const servers: Array<{ close(): Promise<void> }> = [];
+
+	afterEach(async () => {
+		for (const server of servers.splice(0)) {
+			await server.close().catch(() => {});
+		}
+	});
+
+	it("broadcasts ui.notify event to subscribed clients", async () => {
+		// Start a real hub server
+		const server = await startHubServer({
+			port: 0,
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		servers.push(server);
+
+		// Connect two UI clients - one will send, one will receive
+		const sender = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-sender",
+			displayName: "Test Sender",
+		});
+		const receiver = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-receiver",
+			displayName: "Test Receiver",
+		});
+
+		await sender.connect();
+		await receiver.connect();
+
+		const received = waitForEvent<HubUINotifyPayload>((resolve) =>
+			receiver.subscribeUI({ onNotify: resolve }),
+		);
+
+		// Send a notification via the sender
+		await sender.sendNotify({
+			title: "Test Notification",
+			body: "Hello from hub UI events test",
+			severity: "info",
+		});
+
+		const payload = await received;
+		sender.close();
+		receiver.close();
+
+		expect(payload.title).toBe("Test Notification");
+		expect(payload.body).toBe("Hello from hub UI events test");
+		expect(payload.severity).toBe("info");
+	}, 10_000);
+
+	it("broadcasts ui.show_window event to subscribed clients", async () => {
+		const server = await startHubServer({
+			port: 0,
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		servers.push(server);
+
+		const sender = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-sender",
+		});
+		const receiver = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-receiver",
+		});
+
+		await sender.connect();
+		await receiver.connect();
+
+		const received = waitForEvent<unknown>((resolve) =>
+			receiver.subscribeUI({ onShowWindow: resolve }),
+		);
+
+		await sender.sendShowWindow({ focus: true });
+
+		await expect(received).resolves.toEqual({ focus: true });
+		sender.close();
+		receiver.close();
+	}, 10_000);
+
+	it("receives hub.client.registered events when clients connect", async () => {
+		const server = await startHubServer({
+			port: 0,
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		servers.push(server);
+
+		// First client connects and subscribes to registration events
+		const monitor = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-monitor",
+			displayName: "Test Monitor",
+		});
+		await monitor.connect();
+
+		const registered = waitForEvent<Record<string, unknown>>((resolve) =>
+			monitor.subscribeUI({ onClientRegistered: resolve }),
+		);
+
+		// Second client connects — should trigger registration event
+		const newClient = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-newcomer",
+			displayName: "New Client",
+		});
+		await newClient.connect();
+
+		const payload = await registered;
+		monitor.close();
+		newClient.close();
+
+		expect(typeof payload.clientId).toBe("string");
+	}, 10_000);
+
+	it("lists connected clients and sessions for initial UI hydration", async () => {
+		const sessionRecord = {
+			sessionId: "session-ui-hydration",
+			source: SessionSource.CORE,
+			startedAt: new Date(0).toISOString(),
+			updatedAt: new Date(0).toISOString(),
+			status: "running" as const,
+			interactive: true,
+			provider: "cline",
+			model: "test-model",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: false,
+			enableTeams: false,
+			isSubagent: false,
+		};
+		const server = await startHubServer({
+			port: 0,
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			sessionHost: {
+				subscribe: () => () => {},
+				startSession: async () => {
+					throw new Error("not used in this test");
+				},
+				runTurn: async () => undefined,
+				restoreSession: async () => {
+					throw new Error("not used in this test");
+				},
+				pendingPrompts: {
+					list: async () => [],
+					update: async () => ({
+						sessionId: sessionRecord.sessionId,
+						prompts: [],
+						updated: false,
+					}),
+					delete: async () => ({
+						sessionId: sessionRecord.sessionId,
+						prompts: [],
+						removed: false,
+					}),
+				},
+				getAccumulatedUsage: async () => undefined,
+				abort: async () => {},
+				stopSession: async () => {},
+				dispose: async () => {},
+				getSession: async (sessionId: string) =>
+					sessionId === sessionRecord.sessionId ? sessionRecord : undefined,
+				listSessions: async () => [sessionRecord],
+				deleteSession: async () => false,
+				updateSession: async () => ({ updated: false }),
+				readSessionMessages: async () => [],
+				dispatchHookEvent: async () => {},
+			} as never,
+		});
+		servers.push(server);
+
+		const ui = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-ui",
+			displayName: "Test UI",
+		});
+		const worker = new HubUIClient({
+			address: server.url,
+			authToken: server.authToken,
+			clientType: "test-worker",
+			displayName: "Worker",
+		});
+
+		await ui.connect();
+		await worker.connect();
+
+		const clients = await ui.listClients();
+		const sessions = await ui.listSessions();
+
+		worker.close();
+		ui.close();
+
+		expect(clients.some((client) => client.clientType === "test-worker")).toBe(
+			true,
+		);
+		expect(
+			sessions.some((session) => session.workspaceRoot === "/tmp/project"),
+		).toBe(true);
+	}, 10_000);
+});
diff --git a/sdk/packages/core/src/hub/settings.test.ts b/sdk/packages/core/src/hub/settings.test.ts
new file mode 100644
index 0000000..26bcb7f
--- /dev/null
+++ b/sdk/packages/core/src/hub/settings.test.ts
@@ -0,0 +1,143 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CoreSettingsService } from "../settings";
+import { createLocalHubScheduleRuntimeHandlers } from "./daemon/runtime-handlers";
+import { HubServerTransport } from "./server";
+
+describe("hub settings commands", () => {
+	it("returns an updated snapshot and publishes settings.changed after toggle", async () => {
+		const snapshot = {
+			workflows: [],
+			rules: [],
+			skills: [
+				{
+					id: "skill-one",
+					name: "skill-one",
+					path: "/tmp/SKILL.md",
+					kind: "skill" as const,
+					source: "workspace" as const,
+					enabled: false,
+					toggleable: true,
+				},
+			],
+			tools: [],
+			mcp: [],
+		};
+		const settingsService = {
+			toggle: vi.fn().mockResolvedValue({
+				snapshot,
+				changedTypes: ["skills"],
+			}),
+		} as unknown as CoreSettingsService;
+		const transport = new HubServerTransport({
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			settingsService,
+		});
+		const events: string[] = [];
+		const unsubscribe = transport.subscribe("client-one", (event) => {
+			if (event.event === "settings.changed") {
+				events.push(JSON.stringify(event.payload));
+			}
+		});
+
+		try {
+			const reply = await transport.handleCommand({
+				version: "v1",
+				command: "settings.toggle",
+				requestId: "req-1",
+				clientId: "client-one",
+				payload: {
+					type: "skills",
+					id: "skill-one",
+					enabled: false,
+				},
+			});
+
+			expect(reply).toMatchObject({
+				ok: true,
+				payload: {
+					snapshot,
+					changedTypes: ["skills"],
+				},
+			});
+			expect(settingsService.toggle).toHaveBeenCalledWith({
+				type: "skills",
+				id: "skill-one",
+				enabled: false,
+			});
+			expect(events).toHaveLength(1);
+			expect(JSON.parse(events[0] ?? "{}")).toMatchObject({
+				types: ["skills"],
+				snapshot,
+			});
+		} finally {
+			unsubscribe();
+			await transport.stop();
+		}
+	});
+
+	it("rejects malformed settings.toggle payloads before calling settings", async () => {
+		const settingsService = {
+			toggle: vi.fn(),
+		} as unknown as CoreSettingsService;
+		const transport = new HubServerTransport({
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			settingsService,
+		});
+
+		try {
+			const reply = await transport.handleCommand({
+				version: "v1",
+				command: "settings.toggle",
+				requestId: "req-1",
+				clientId: "client-one",
+				payload: {
+					type: "skillz",
+				},
+			});
+
+			expect(reply).toMatchObject({
+				ok: false,
+				error: {
+					code: "settings_toggle_failed",
+				},
+			});
+			expect(reply.error?.message).toContain("settings.toggle payload 'type'");
+			expect(settingsService.toggle).not.toHaveBeenCalled();
+		} finally {
+			await transport.stop();
+		}
+	});
+
+	it("rejects malformed settings.list payloads before calling settings", async () => {
+		const settingsService = {
+			list: vi.fn(),
+		} as unknown as CoreSettingsService;
+		const transport = new HubServerTransport({
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+			settingsService,
+		});
+
+		try {
+			const reply = await transport.handleCommand({
+				version: "v1",
+				command: "settings.list",
+				requestId: "req-1",
+				clientId: "client-one",
+				payload: {
+					workspaceRoot: false,
+				},
+			});
+
+			expect(reply).toMatchObject({
+				ok: false,
+				error: {
+					code: "settings_list_failed",
+				},
+			});
+			expect(reply.error?.message).toContain("workspaceRoot");
+			expect(settingsService.list).not.toHaveBeenCalled();
+		} finally {
+			await transport.stop();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/index.ts b/sdk/packages/core/src/index.ts
new file mode 100644
index 0000000..6be4a8a
--- /dev/null
+++ b/sdk/packages/core/src/index.ts
@@ -0,0 +1,951 @@
+/**
+ * @cline/core
+ *
+ * Core contracts, shared state utilities, and Node runtime services.
+ */
+
+export * as Llms from "@cline/llms";
+export {
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	extractClinePassLimitMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClineNotSubscribedMessage,
+	getClinePassSubscriptionUrl,
+	isClineNotSubscribedError,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionError,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitError,
+	isClinePassLimitMessage,
+} from "@cline/llms";
+// Shared contracts and path helpers re-exported for app consumers.
+export type {
+	AddProviderActionRequest,
+	AgentConfig,
+	AgentEvent,
+	AgentExtension as AgentPlugin, // Public-facing alias for extensions
+	AgentExtensionCommand,
+	AgentExtensionCommand as AgentPluginCommand,
+	AgentExtensionCommandResult,
+	AgentHooks,
+	AgentMode,
+	AgentResult,
+	AgentRunResult,
+	AgentRunStatus,
+	AgentTool,
+	AgentToolContext,
+	AutomationEventEnvelope,
+	BasicLogger,
+	BasicLogger as Logger,
+	CaptureSdkErrorInput,
+	ChatRunTurnRequest,
+	ChatRuntimeConfig,
+	ChatStartSessionArtifacts,
+	ChatStartSessionRequest,
+	ChatTurnResult,
+	ClineAccountActionRequest,
+	ConnectorHookEvent,
+	ContentBlock,
+	FeatureFlag,
+	FeatureFlagPayload,
+	FeatureFlagsAndPayloads,
+	FeatureFlagsContext,
+	FeatureFlagsSettings,
+	FileContent,
+	GetProviderModelsActionRequest,
+	HookSessionContext,
+	IFeatureFlagsProvider,
+	ImageContent,
+	ITelemetryService,
+	ListProvidersActionRequest,
+	Message,
+	MessageWithMetadata,
+	ProviderActionRequest,
+	ProviderCatalogResponse,
+	ProviderListItem,
+	ProviderModel,
+	ProviderOAuthLoginResponse,
+	RuntimeLoggerConfig,
+	SaveProviderSettingsActionRequest,
+	SdkTelemetryErrorComponent,
+	SdkTelemetryErrorSeverity,
+	SessionLineage,
+	TEAM_LIFECYCLE_EVENT_TYPE,
+	TEAM_PROGRESS_EVENT_TYPE,
+	TeamProgressProjectionEvent,
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+	TextContent,
+	ThinkingContent,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	ToolPolicy,
+	ToolResultContent,
+	ToolUseContent,
+	WorkspaceInfo,
+	WorkspaceInfoSchema,
+	WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "@cline/shared";
+export {
+	buildClineSystemPrompt as getClineDefaultSystemPrompt,
+	buildSdkErrorProperties,
+	ContributionRegistry,
+	captureSdkError,
+	createClineTelemetryServiceConfig,
+	createClineTelemetryServiceMetadata,
+	createContributionRegistry,
+	createTool,
+	emptyWorkspaceManifest,
+	FEATURE_FLAGS,
+	FeatureFlagDefaultValue,
+	formatDisplayUserInput,
+	noopBasicLogger,
+	normalizeSdkError,
+	normalizeUserInput,
+	parseUserCommandEnvelope,
+	registerDisposable,
+	SDK_ERROR_TELEMETRY_EVENT,
+} from "@cline/shared";
+export * from "@cline/shared/storage";
+export {
+	type ClineAccountBalance,
+	type ClineAccountOperations,
+	type ClineAccountOrganization,
+	type ClineAccountOrganizationBalance,
+	type ClineAccountOrganizationUsageTransaction,
+	type ClineAccountPaymentTransaction,
+	ClineAccountService,
+	type ClineAccountServiceOptions,
+	type ClineAccountUsageTransaction,
+	type ClineAccountUser,
+	type ClineOrganization,
+	type ClineSubscriptionPlan,
+	executeClineAccountAction,
+	type FeaturebaseTokenResponse,
+	isClineAccountActionRequest,
+	type ProviderActionExecutor,
+	RpcClineAccountService,
+	type UserCurrentPlan,
+	type UserRemoteConfigOrganization,
+	type UserRemoteConfigResponse,
+} from "./account";
+export {
+	hashSecret,
+	setSdkLogger,
+	sdkDebug,
+} from "./logging/early-logger";
+export {
+	createOAuthClientCallbacks,
+	type OAuthClientCallbacksOptions,
+} from "./auth/client";
+export {
+	completeClineDeviceAuth,
+	getValidClineCredentials,
+	loginClineOAuth,
+	refreshClineToken,
+	startClineDeviceAuth,
+} from "./auth/cline";
+export {
+	getValidOpenAICodexCredentials,
+	loginOpenAICodex,
+	refreshOpenAICodexToken,
+} from "./auth/codex";
+export {
+	getValidOcaCredentials,
+	loginOcaOAuth,
+	refreshOcaToken,
+} from "./auth/oca";
+export {
+	formatProviderOAuthApiKey,
+	getPersistedProviderApiKey,
+	getProviderAuthHandler,
+	getProviderAuthStorageId,
+	getProviderOAuthCredentialsFromSettings,
+	isOAuthProvider,
+	loginAndSaveProviderOAuthCredentials,
+	type ProviderAuthHandler,
+	type ProviderAuthLoginInput,
+	type ProviderAuthRefreshInput,
+	type ProviderAuthSaveCredentialsInput,
+	type ProviderOAuthCredentials,
+	resolveProviderApiKeyFromSettings,
+	saveProviderOAuthCredentials,
+} from "./auth/provider-auth-registry";
+export type {
+	LocalOAuthServer,
+	LocalOAuthServerOptions,
+	OAuthCallbackPayload,
+	OAuthServerCloseInfo,
+	OAuthServerListeningInfo,
+} from "./auth/server";
+export { startLocalOAuthServer } from "./auth/server";
+export type {
+	OAuthCredentials,
+	OAuthLoginCallbacks,
+	OAuthPrompt,
+	OAuthProviderInterface,
+	OcaClientMetadata,
+	OcaMode,
+	OcaOAuthConfig,
+	OcaOAuthEnvironmentConfig,
+	OcaOAuthProviderOptions,
+	OcaTokenResolution,
+} from "./auth/types";
+export { ClineCore } from "./ClineCore";
+export type {
+	ClineAutomationEventIngressResult,
+	ClineAutomationEventLog,
+	ClineAutomationEventSuppression,
+	ClineAutomationListEventsOptions,
+	ClineAutomationListRunsOptions,
+	ClineAutomationListSpecsOptions,
+	ClineAutomationRun,
+	ClineAutomationRunStatus,
+	ClineAutomationSpec,
+	ClineCoreAutomationApi,
+	ClineCoreAutomationOptions,
+	ClineCoreListHistoryOptions,
+	ClineCoreOptions,
+	ClineCoreSettingsApi,
+	ClineCoreStartInput,
+	CompareCheckpointInput,
+	CompareCheckpointResult,
+	HubOptions,
+	RemoteOptions,
+	RestoreInput,
+	RestoreOptions,
+	RestoreResult,
+} from "./cline-core/types";
+export type {
+	LoadAgentPluginFromPathOptions,
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+	PluginLoadDiagnostics,
+	ResolveAgentPluginPathsOptions,
+} from "./extensions";
+export {
+	discoverPluginModulePaths,
+	loadAgentPluginFromPath,
+	loadAgentPluginsFromPaths,
+	loadAgentPluginsFromPathsWithDiagnostics,
+	resolveAgentPluginPaths,
+	resolveAndLoadAgentPlugins,
+	resolvePluginConfigSearchPaths,
+	resolvePluginSkillDirectoriesFromPaths,
+} from "./extensions";
+export type {
+	AvailableRuntimeCommand,
+	CreateInstructionWatcherOptions,
+	CreateRulesConfigDefinitionOptions,
+	CreateSkillsConfigDefinitionOptions,
+	CreateUserInstructionConfigServiceOptions,
+	CreateWorkflowsConfigDefinitionOptions,
+	ParseMarkdownFrontmatterResult,
+	RuleConfig,
+	SkillConfig,
+	UnifiedConfigDefinition,
+	UnifiedConfigFileCandidate,
+	UnifiedConfigFileContext,
+	UnifiedConfigRecord,
+	UnifiedConfigWatcherEvent,
+	UnifiedConfigWatcherOptions,
+	UserInstructionConfig,
+	UserInstructionConfigRecord,
+	UserInstructionConfigService,
+	UserInstructionConfigType,
+	WorkflowConfig,
+} from "./extensions/config";
+export {
+	createRulesConfigDefinition,
+	createSkillsConfigDefinition,
+	createUserInstructionConfigService,
+	createWorkflowsConfigDefinition,
+	parseRuleConfigFromMarkdown,
+	parseSkillConfigFromMarkdown,
+	parseWorkflowConfigFromMarkdown,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveRulesConfigSearchPaths,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	UnifiedConfigFileWatcher,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "./extensions/config";
+export {
+	type AuthorizeMcpServerOAuthOptions,
+	type AuthorizeMcpServerOAuthResult,
+	authorizeMcpServerOAuth,
+	type CreateDisabledMcpToolPoliciesOptions,
+	type CreateDisabledMcpToolPolicyOptions,
+	type CreateMcpToolsOptions,
+	createDefaultMcpServerClientFactory,
+	createDisabledMcpToolPolicies,
+	createDisabledMcpToolPolicy,
+	createMcpTools,
+	type DefaultMcpServerClientFactoryOptions,
+	getMcpServerOAuthState,
+	hasMcpSettingsFile,
+	InMemoryMcpManager,
+	type LoadMcpSettingsOptions,
+	listMcpServerOAuthStatuses,
+	loadMcpSettingsFile,
+	type McpConnectionStatus,
+	type McpManager,
+	type McpManagerOptions,
+	type McpServerClient,
+	type McpServerClientFactory,
+	type McpServerOAuthState,
+	type McpServerOAuthStatus,
+	type McpServerRegistration,
+	type McpServerSnapshot,
+	type McpServerTransportConfig,
+	type McpSettingsFile,
+	type McpSettingsLockOptions,
+	McpSettingsLockTimeoutError,
+	type McpSettingsMutator,
+	McpSettingsMutatorPurityError,
+	McpSettingsUpdateSkippedError,
+	type McpSseTransportConfig,
+	type McpStdioTransportConfig,
+	type McpStreamableHttpTransportConfig,
+	type McpToolCallRequest,
+	type McpToolCallResult,
+	type McpToolDescriptor,
+	type McpToolNameTransform,
+	type McpToolProvider,
+	type RegisterMcpServersFromSettingsOptions,
+	registerMcpServersFromSettingsFile,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+	type SetMcpServerDisabledOptions,
+	setMcpServerDisabled,
+	updateMcpServerOAuthState,
+	updateMcpServerOAuthStateAsync,
+	updateMcpSettingsFile,
+	updateMcpSettingsFileSync,
+} from "./extensions/mcp";
+export {
+	type AgentTask,
+	AgentTeam,
+	AgentTeamsRuntime,
+	type AgentTeamsRuntimeOptions,
+	type BootstrapAgentTeamsOptions,
+	type BootstrapAgentTeamsResult,
+	bootstrapAgentTeams,
+	buildConfiguredAgentToolDescriptors,
+	buildConfiguredAgentToolName,
+	buildDelegatedAgentConfig,
+	buildTeamProgressSummary,
+	type ConfiguredAgentConfig,
+	type ConfiguredAgentInput,
+	type ConfiguredAgentLoadResult,
+	type ConfiguredAgentReadError,
+	type ConfiguredAgentToolConfig,
+	type ConfiguredAgentToolDescriptor,
+	type CreateAgentTeamsToolsOptions,
+	createAgentTeamsTools,
+	createConfiguredAgentTools,
+	createDelegatedAgent,
+	createDelegatedAgentConfigProvider,
+	createSpawnAgentTool,
+	type DelegatedAgentConfigProvider,
+	type DelegatedAgentConnectionConfig,
+	type DelegatedAgentKind,
+	type DelegatedAgentRuntimeConfig,
+	loadConfiguredAgentConfigs,
+	parseConfiguredAgentConfig,
+	reviveTeamStateDates,
+	type SpawnTeammateOptions,
+	type SubAgentEndContext,
+	type SubAgentStartContext,
+	type TaskResult,
+	type TeamEvent,
+	type TeamMemberConfig,
+	type TeamTeammateRuntimeConfig,
+	toTeamProgressLifecycleEvent,
+} from "./extensions/tools/team";
+export {
+	createAgentHooksExtension,
+	createHookAuditHooks,
+	createHookConfigFileExtension,
+	createHookConfigFileHooks,
+	createSubprocessHooks,
+	HOOK_CONFIG_FILE_EVENT_MAP,
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	type HookConfigFileEntry,
+	HookConfigFileName,
+	type HookEventName,
+	HookEventNameSchema,
+	type HookEventPayload,
+	HookEventPayloadSchema,
+	listHookConfigFiles,
+	mergeAgentHooks,
+	parseHookEventPayload,
+	type RunHookOptions,
+	type RunHookResult,
+	type RunSubprocessEventOptions,
+	type RunSubprocessEventResult,
+	resolveHooksConfigSearchPaths,
+	runHook,
+	runSubprocessEvent,
+	type SubprocessHookControl,
+	type SubprocessHooksOptions,
+	toHookConfigFileName,
+} from "./hooks";
+export type {
+	CheckpointEntry,
+	CheckpointMetadata,
+} from "./hooks/checkpoint-hooks";
+export * from "./hub";
+export { HubRuntimeHost } from "./hub/runtime-host/hub-runtime-host";
+export { RemoteRuntimeHost } from "./hub/runtime-host/remote-runtime-host";
+export {
+	buildRemoteConfigSessionBlobUploadMetadata,
+	createRemoteConfigSessionMessagesArtifactUploader,
+	type PreparedRemoteConfigCoreIntegration,
+	type PrepareRemoteConfigCoreIntegrationOptions,
+	prepareRemoteConfigCoreIntegration,
+	REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY,
+	readRemoteConfigSessionBlobUploadMetadata,
+	registerRemoteConfigSessionBlobUpload,
+} from "./remote-config/integration";
+export type { RuntimeCapabilities } from "./runtime/capabilities";
+export { normalizeRuntimeCapabilities } from "./runtime/capabilities";
+export type {
+	ConnectionUpdate,
+	ConnectionUpdateInput,
+} from "./runtime/config/connection-update";
+export { buildConnectionUpdate } from "./runtime/config/connection-update";
+export { listSessionHistoryFromBackend } from "./runtime/host/history";
+export type { SessionBackend } from "./runtime/host/host";
+export {
+	createRuntimeHost,
+	createRuntimeHost as createSessionHost,
+	resolveSessionBackend,
+} from "./runtime/host/host";
+export { LocalRuntimeHost } from "./runtime/host/local-runtime-host";
+export type {
+	PendingPromptMutationResult,
+	PendingPromptsDeleteInput,
+	PendingPromptsListInput,
+	PendingPromptsRuntimeService,
+	PendingPromptsServiceApi,
+	PendingPromptsUpdateInput,
+	RestoreSessionInput,
+	RestoreSessionResult,
+	RuntimeHost,
+	RuntimeHost as SessionHost,
+	RuntimeHostMode,
+	RuntimeHostSubscribeOptions,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	SessionUsageSummary,
+	StartSessionInput,
+	StartSessionResult,
+} from "./runtime/host/runtime-host";
+export {
+	isSessionNotFoundError,
+	SESSION_NOT_FOUND_ERROR_CODE,
+	SessionNotFoundError,
+	splitCoreSessionConfig,
+} from "./runtime/host/runtime-host";
+export {
+	createTeamName,
+	DefaultRuntimeBuilder,
+} from "./runtime/orchestration/runtime-builder";
+export type {
+	BuiltRuntime,
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	SessionRuntime,
+} from "./runtime/orchestration/session-runtime";
+export {
+	formatRulesForSystemPrompt,
+	isRuleEnabled,
+	mergeRulesForSystemPrompt,
+} from "./runtime/safety/rules";
+export {
+	type SandboxCallOptions,
+	SubprocessSandbox,
+	type SubprocessSandboxOptions,
+} from "./runtime/tools/subprocess-sandbox";
+export {
+	type DesktopToolApprovalOptions,
+	requestDesktopToolApproval,
+} from "./runtime/tools/tool-approval";
+export {
+	FeatureFlagsService,
+	type FeatureFlagsServiceOptions,
+	NoOpFeatureFlagsProvider,
+} from "./services/feature-flags";
+export type {
+	GlobalCompactionStrategy,
+	GlobalSettings,
+} from "./services/global-settings";
+export {
+	filterDisabledPluginPaths,
+	filterDisabledTools,
+	filterExtensionToolRegistrations,
+	GlobalSettingsSchema,
+	isAutoUpdateEnabledGlobally,
+	isPluginDisabledGlobally,
+	isTelemetryOptedOutGlobally,
+	isToolDisabledGlobally,
+	readCompactionStrategyGlobally,
+	readGlobalSettings,
+	resolveDisabledPluginPaths,
+	resolveDisabledToolNames,
+	setAutoUpdateEnabledGlobally,
+	setCompactionStrategyGlobally,
+	setDisabledPlugin,
+	setDisabledTools,
+	setTelemetryOptOutGlobally,
+	toggleDisabledTool,
+	writeGlobalSettings,
+} from "./services/global-settings";
+export type {
+	MarketplaceActionResult,
+	MarketplaceEntryInput,
+	MarketplacePrimitiveType,
+	MarketplaceSpawnCommand,
+	MarketplaceSpawnResult,
+	UninstallMarketplaceEntryOptions,
+} from "./services/marketplace";
+export {
+	findInstalledGlobalMarketplaceSkillName,
+	getGlobalMarketplaceSkillPaths,
+	getMarketplaceSkillCandidates,
+	isMarketplaceSkillInstalled,
+	marketplaceEntryKey,
+	resolveMarketplaceMcpServerName,
+	uninstallMarketplaceEntry,
+	uninstallMarketplaceMcpServerFromSettings,
+	uninstallMarketplacePlugin,
+	uninstallMarketplaceSkill,
+} from "./services/marketplace";
+export type {
+	McpInstallOptions,
+	McpInstallResult,
+} from "./services/mcp-install";
+export {
+	buildMcpInstallTransport,
+	installMcpServer,
+	parseMcpInstallArgs,
+} from "./services/mcp-install";
+export type {
+	ParsedPluginSource,
+	PluginInstallOptions,
+	PluginInstallResult,
+	PluginInstallSourceType,
+	PluginMcpOAuthCandidate,
+} from "./services/plugin-install";
+export {
+	collectPluginMcpOAuthCandidates,
+	installPlugin,
+	isOfficialPluginSlug,
+	parsePluginSource,
+} from "./services/plugin-install";
+export type {
+	PluginMcpSettingsMutation,
+	PluginMcpSettingsSyncResult,
+	RemovePluginMcpServersFromSettingsOptions,
+	SyncPluginMcpServersToSettingsOptions,
+} from "./services/plugin-mcp-settings";
+export {
+	disablePluginMcpServersInSettings,
+	removePluginMcpServersFromSettings,
+	syncPluginMcpServersToSettings,
+} from "./services/plugin-mcp-settings";
+export type {
+	ListPluginToolsResult,
+	PluginToolSummary,
+} from "./services/plugin-tools";
+export {
+	listPluginTools,
+	listPluginToolsWithDiagnostics,
+} from "./services/plugin-tools";
+export type {
+	PluginUninstallOptions,
+	PluginUninstallResult,
+} from "./services/plugin-uninstall";
+export { uninstallPlugin } from "./services/plugin-uninstall";
+export {
+	addLocalProvider,
+	type DeleteLocalProviderRequest,
+	deleteLocalProvider,
+	ensureCustomProvidersLoaded,
+	getLocalProviderModels,
+	listLocalProviders,
+	loginAndSaveLocalProviderOAuthCredentials,
+	loginLocalProvider,
+	markLocalProviderEnabled,
+	normalizeOAuthProvider,
+	refreshProviderModelsFromSource,
+	resolveLocalClineAuthToken,
+	saveLocalProviderOAuthCredentials,
+	saveLocalProviderSettings,
+	type UpdateLocalProviderRequest,
+	updateLocalProvider,
+} from "./services/providers/local-provider-service";
+export {
+	getProviderConfigFields,
+	type ProviderConfigFieldKey,
+	type ProviderConfigFieldRequirement,
+	type ProviderConfigFields,
+} from "./services/providers/provider-config-fields";
+export {
+	type MigrateLegacyProviderSettingsOptions,
+	type MigrateLegacyProviderSettingsResult,
+	migrateLegacyProviderSettings,
+} from "./services/storage/provider-settings-legacy-migration";
+export { ProviderSettingsManager } from "./services/storage/provider-settings-manager";
+export { SqliteSessionStore } from "./services/storage/sqlite-session-store";
+export {
+	SqliteTeamStore,
+	type SqliteTeamStoreOptions,
+} from "./services/storage/team-store";
+export { resolveCoreDistinctId } from "./services/telemetry";
+export type {
+	CaptureAgentUnexpectedReasoningTokensInput,
+	CaptureCompactionExecutedProperties,
+	CaptureCompactionSkippedProperties,
+	TelemetryAgentIdentityProperties,
+	TelemetryAgentKind,
+	TelemetryCompactionMode,
+	TelemetryCompactionStrategy,
+	WorkspaceInitErrorProperties,
+	WorkspaceInitializedProperties,
+	WorkspacePathResolvedProperties,
+} from "./services/telemetry/core-events";
+export {
+	CORE_TELEMETRY_EVENTS,
+	captureAgentCreated,
+	captureAgentTeamCreated,
+	captureAgentUnexpectedReasoningTokens,
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	captureCompactionExecuted,
+	captureCompactionSkipped,
+	captureConversationTurnEvent,
+	captureDiffEditFailure,
+	captureExtensionActivated,
+	captureHookDiscovery,
+	captureMentionFailed,
+	captureMentionSearchResults,
+	captureMentionUsed,
+	captureModeSwitch,
+	captureProviderApiError,
+	captureProviderConfigured,
+	captureSkillUsed,
+	captureSubagentExecution,
+	captureTaskCompleted,
+	captureTaskCreated,
+	captureTaskRestarted,
+	captureTokenUsage,
+	captureToolUsage,
+	captureWorkspaceInitError,
+	captureWorkspaceInitialized,
+	captureWorkspacePathResolved,
+	identifyAccount,
+} from "./services/telemetry/core-events";
+export type { ITelemetryAdapter } from "./services/telemetry/ITelemetryAdapter";
+export {
+	type ConfiguredTelemetryHandle,
+	type CreateOpenTelemetryTelemetryServiceOptions,
+	createConfiguredTelemetryHandle,
+	createConfiguredTelemetryService,
+	createOpenTelemetryTelemetryService,
+	OpenTelemetryProvider,
+	type OpenTelemetryProviderOptions,
+} from "./services/telemetry/OpenTelemetryProvider";
+export {
+	TelemetryLoggerSink,
+	type TelemetryLoggerSinkOptions,
+} from "./services/telemetry/TelemetryLoggerSink";
+export {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+	getCurrentContextSize,
+	summarizeUsageFromMessages,
+} from "./services/usage";
+export type {
+	FastFileIndexOptions,
+	MentionEnricherOptions,
+	MentionEnrichmentResult,
+} from "./services/workspace";
+export {
+	enrichPromptWithMentions,
+	getFileIndex,
+	prewarmFileIndex,
+} from "./services/workspace";
+export type {
+	WorkspaceManager,
+	WorkspaceManagerEvent,
+} from "./services/workspace/workspace-manager";
+export { InMemoryWorkspaceManager } from "./services/workspace/workspace-manager";
+export {
+	buildWorkspaceMetadata,
+	generateWorkspaceInfo,
+	generateWorkspaceInfoWithDiagnostics,
+	normalizeWorkspacePath,
+} from "./services/workspace/workspace-manifest";
+export {
+	buildCheckpointWorkspaceDiff,
+	type CheckpointComparePlan,
+	type CheckpointContentDiff,
+	type CheckpointWorkspaceCompareResult,
+	compareCheckpointToWorkspace,
+	createCheckpointComparePlan,
+} from "./session/checkpoint-diff";
+export {
+	findCheckpointForRun,
+	readSessionCheckpointHistory,
+} from "./session/checkpoint-restore";
+export {
+	deriveSubsessionStatus,
+	makeSubSessionId,
+	makeTeamTaskSubSessionId,
+	sanitizeSessionToken,
+} from "./session/models/session-graph";
+export type { SessionManifest } from "./session/models/session-manifest";
+export type { SessionRow } from "./session/models/session-row";
+export type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+} from "./session/services/session-service";
+export { CoreSessionService } from "./session/services/session-service";
+export type {
+	CoreSessionCheckpointSnapshot,
+	CoreSessionSnapshot,
+} from "./session/session-snapshot";
+export { createCoreSessionSnapshot } from "./session/session-snapshot";
+export type {
+	SessionCheckpointRestoreContext,
+	SessionCheckpointRestoreResult,
+	SessionVersioningErrorCode,
+} from "./session/session-versioning-service";
+export {
+	SessionVersioningError,
+	SessionVersioningService,
+} from "./session/session-versioning-service";
+export {
+	FileTeamPersistenceStore,
+	type FileTeamPersistenceStoreOptions,
+} from "./session/stores/team-persistence-store";
+export type {
+	CoreSettingsItem,
+	CoreSettingsItemKind,
+	CoreSettingsItemSource,
+	CoreSettingsListInput,
+	CoreSettingsMutationResult,
+	CoreSettingsSnapshot,
+	CoreSettingsToggleInput,
+	CoreSettingsType,
+} from "./settings";
+export {
+	CoreSettingsService,
+	createCoreSettingsService,
+} from "./settings";
+export type {
+	ChatMessage,
+	ChatSessionConfig,
+	ChatSessionStatus,
+	ChatSummary,
+	ChatViewState,
+} from "./types/chat-schema";
+export {
+	ChatMessageRoleSchema,
+	ChatMessageSchema,
+	ChatSessionConfigSchema,
+	ChatSessionStatusSchema,
+	ChatSummarySchema,
+	ChatViewStateSchema,
+} from "./types/chat-schema";
+export type { SessionMessagesArtifactUploader } from "./types/session";
+export { CORE_BUILD_VERSION } from "./version";
+export async function loadOpenTelemetryAdapter() {
+	return import("./services/telemetry/index.js");
+}
+export { Agent, createAgentRuntime } from "@cline/agents";
+export {
+	createCompactionStateAwarePrepareTurn,
+	createContextCompactionPrepareTurn,
+} from "./extensions/context/compaction";
+export {
+	ALL_DEFAULT_TOOL_NAMES,
+	type AskQuestionExecutor,
+	type BuiltinToolAvailabilityContext,
+	type CreateBuiltinToolsOptions,
+	type CreateDefaultToolsOptions,
+	createBuiltinTools,
+	createDefaultExecutors,
+	createDefaultShellExecutor,
+	createDefaultTools,
+	createDefaultToolsWithPreset,
+	createShellExecutor,
+	createShellTool,
+	createToolPoliciesWithPreset,
+	type DefaultExecutorsOptions,
+	type DefaultToolName,
+	DefaultToolNames,
+	type DefaultToolsConfig,
+	getCoreAcpToolNames,
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	MAX_COMMAND_OUTPUT_CHARS,
+	resolveCoreSelectedToolIds,
+	type ShellExecutor,
+	type ShellExecutorOptions,
+	type StructuredCommandInput,
+	StructuredCommandInputSchema,
+	TEAM_TOOL_NAMES,
+	type ToolCatalogEntry,
+	type ToolExecutors,
+	type ToolPolicyPresetName,
+	type ToolPresetName,
+	ToolPresets,
+	truncateCommandOutput,
+} from "./extensions/tools";
+export {
+	type ClineRecommendedModel,
+	type ClineRecommendedModelsData,
+	FALLBACK_CLINE_RECOMMENDED_MODELS,
+	type FetchClineRecommendedModelsOptions,
+	fetchClineRecommendedModels,
+} from "./services/llms/cline-recommended-models";
+export {
+	clearLiveModelsCatalogCache,
+	clearPrivateModelsCatalogCache,
+	DEFAULT_MODELS_CATALOG_URL,
+	getLiveModelsCatalog,
+	getProviderConfig,
+	OPENAI_COMPATIBLE_PROVIDERS,
+	resolveProviderConfig,
+} from "./services/llms/provider-defaults";
+export type {
+	AuthSettings,
+	AwsSettings,
+	AzureSettings,
+	BuiltInProviderId,
+	GcpSettings,
+	ModelCatalogConfig,
+	ModelCatalogSettings,
+	OcaSettings,
+	ProviderCapability,
+	ProviderClient,
+	ProviderConfig,
+	ProviderDefaultsConfig,
+	ProviderId,
+	ProviderProtocol,
+	ProviderSettings,
+	ReasoningSettings,
+	SapSettings,
+	ToProviderConfigOptions,
+} from "./services/llms/provider-settings";
+export {
+	AuthSettingsSchema,
+	AwsSettingsSchema,
+	AzureSettingsSchema,
+	BUILT_IN_PROVIDER,
+	BUILT_IN_PROVIDER_IDS,
+	createProviderConfig,
+	GcpSettingsSchema,
+	isBuiltInProviderId,
+	ModelCatalogSettingsSchema,
+	normalizeProviderId,
+	OcaSettingsSchema,
+	ProviderClientSchema,
+	ProviderIdSchema,
+	ProviderProtocolSchema,
+	ProviderSettingsSchema,
+	parseSettings,
+	ReasoningSettingsSchema,
+	SapSettingsSchema,
+	safeCreateProviderConfig,
+	safeParseSettings,
+	toProviderConfig,
+} from "./services/llms/provider-settings";
+export {
+	defineLlmsConfig,
+	loadLlmsConfigFromFile,
+} from "./services/llms/runtime-config";
+export {
+	createLlmsSdk,
+	DefaultLlmsSdk,
+} from "./services/llms/runtime-registry";
+export type {
+	BuiltInProviderSummary,
+	CreateHandlerInput,
+	LlmsConfig,
+	LlmsSdk,
+	ProviderConfigDefaults,
+	ProviderSelectionConfig,
+	RegisterBuiltinProviderInput,
+	RegisteredProviderSummary,
+	RegisterModelInput,
+	RegisterProviderInput,
+} from "./services/llms/runtime-types";
+export {
+	TelemetryService,
+	type TelemetryServiceOptions,
+} from "./services/telemetry/TelemetryService";
+export {
+	createSessionCompactionState,
+	parseSessionCompactionState,
+	projectSessionCompactionState,
+	type SessionCompactionState,
+} from "./session/models/session-compaction";
+// Compatibility barrel (legacy imports).
+export type { RuntimeEnvironment } from "./types";
+export type { SessionStatus } from "./types/common";
+export { SESSION_STATUSES, SessionSource } from "./types/common";
+export type {
+	CoreAgentMode,
+	CoreCheckpointConfig,
+	CoreCheckpointContext,
+	CoreCompactionConfig,
+	CoreCompactionContext,
+	CoreCompactionResult,
+	CoreCompactionStrategy,
+	CoreCompactionSummarizerConfig,
+	CoreModelConfig,
+	CoreRuntimeFeatures,
+	CoreSessionConfig,
+} from "./types/config";
+export type {
+	CoreSessionEvent,
+	SessionChunkEvent,
+	SessionEndedEvent,
+	SessionPendingPrompt,
+	SessionPendingPromptSubmittedEvent,
+	SessionPendingPromptsEvent,
+	SessionTeamProgressEvent,
+	SessionToolEvent,
+} from "./types/events";
+export type {
+	ProviderTokenSource,
+	StoredProviderSettings,
+	StoredProviderSettingsEntry,
+} from "./types/provider-settings";
+export {
+	emptyStoredProviderSettings,
+	StoredProviderSettingsEntrySchema,
+	StoredProviderSettingsSchema,
+} from "./types/provider-settings";
+export type {
+	SessionHistoryMetadata,
+	SessionHistoryRecord,
+	SessionRecord,
+	SessionRef,
+} from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";
diff --git a/sdk/packages/core/src/logging/early-logger.ts b/sdk/packages/core/src/logging/early-logger.ts
new file mode 100644
index 0000000..e2ef79b
--- /dev/null
+++ b/sdk/packages/core/src/logging/early-logger.ts
@@ -0,0 +1,60 @@
+/**
+ * Early SDK logger for components that operate before/outside of `ClineCore`
+ * sessions, plus a secret-hashing helper for credential diagnostics.
+ *
+ * `ClineCore.create({ logger })` receives a `BasicLogger` but it is only
+ * threaded to session-scoped components. `ProviderSettingsManager`,
+ * `RuntimeOAuthTokenManager`, and the Cline auth functions in `cline.ts` are
+ * constructed or called before `ClineCore` exists or outside a session.
+ * Hosts call `setSdkLogger()` once at startup and every early component picks
+ * it up without threading loggers through every constructor.
+ *
+ * When no logger is registered, every call is a no-op.
+ *
+ * Secrets are never logged in cleartext; {@link hashSecret} produces an
+ * 8-hex-digit fingerprint that is stable for the same value but irreversible.
+ */
+
+import { createHash } from "node:crypto";
+import type { BasicLogger } from "@cline/shared";
+
+let earlyLogger: BasicLogger | undefined;
+
+/**
+ * Register the logger used by {@link sdkDebug}. Pass `undefined` to disable.
+ */
+export function setSdkLogger(logger: BasicLogger | undefined): void {
+	earlyLogger = logger;
+}
+
+/** @internal Returns the currently registered early logger (for testing). */
+export function getSdkLogger(): BasicLogger | undefined {
+	return earlyLogger;
+}
+
+/**
+ * Short, stable fingerprint of a secret for debug logging (8 hex digits of a
+ * SHA-256 digest). The same input always yields the same hash, making it easy
+ * to eyeball whether a token changed across log entries without leaking it.
+ *
+ * Returns `"unset"` for undefined/null/empty so absence is still visible.
+ */
+export function hashSecret(value: unknown): string {
+	if (typeof value !== "string" || value.length === 0) {
+		return "unset";
+	}
+	return createHash("sha256").update(value).digest("hex").slice(0, 8);
+}
+
+/**
+ * Emit a debug-level SDK diagnostic message (already a formatted string).
+ * Best-effort: swallows errors from the underlying logger so logging never
+ * breaks auth/storage flows.
+ */
+export function sdkDebug(message: string): void {
+	try {
+		earlyLogger?.debug(message);
+	} catch {
+		// Never let logging break the app.
+	}
+}
diff --git a/sdk/packages/core/src/remote-config/integration.ts b/sdk/packages/core/src/remote-config/integration.ts
new file mode 100644
index 0000000..18ac31d
--- /dev/null
+++ b/sdk/packages/core/src/remote-config/integration.ts
@@ -0,0 +1,133 @@
+import {
+	type AgentExtension,
+	buildRemoteConfigSessionBlobUploadMetadata,
+	clearRemoteConfigSessionBlobUpload,
+	createClineTelemetryServiceConfig,
+	createSessionId,
+	createRemoteConfigSessionMessagesArtifactUploader as createSharedRemoteConfigSessionMessagesArtifactUploader,
+	type ITelemetryService,
+	type OpenTelemetryClientConfig,
+	type PreparedRemoteConfigRuntime,
+	type PrepareRemoteConfigRuntimeOptions,
+	prepareRemoteConfigRuntime,
+	REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY,
+	readRemoteConfigSessionBlobUploadMetadata,
+	registerRemoteConfigSessionBlobUpload,
+} from "@cline/shared";
+import type { ClineCoreStartInput } from "../cline-core/types";
+import { createConfiguredTelemetryService } from "../services/telemetry";
+import type { CreateOpenTelemetryTelemetryServiceOptions } from "../services/telemetry/OpenTelemetryProvider";
+import type { SessionMessagesArtifactUploader } from "../types/session";
+
+export interface PrepareRemoteConfigCoreIntegrationOptions
+	extends PrepareRemoteConfigRuntimeOptions {
+	telemetryService?: Omit<
+		CreateOpenTelemetryTelemetryServiceOptions,
+		keyof OpenTelemetryClientConfig
+	>;
+}
+
+export interface PreparedRemoteConfigCoreIntegration {
+	prepared: PreparedRemoteConfigRuntime;
+	extensions: AgentExtension[];
+	telemetry?: ITelemetryService;
+	applyToStartSessionInput(input: ClineCoreStartInput): ClineCoreStartInput;
+	dispose(): Promise<void>;
+}
+
+function createTelemetryService(
+	prepared: PreparedRemoteConfigRuntime,
+	options: PrepareRemoteConfigCoreIntegrationOptions,
+): ITelemetryService | undefined {
+	const telemetryConfig: Partial<OpenTelemetryClientConfig> | undefined =
+		prepared.telemetry || options.telemetryService
+			? {
+					...(options.telemetryService ?? {}),
+					...(prepared.telemetry ?? {}),
+				}
+			: undefined;
+
+	if (!telemetryConfig) {
+		return undefined;
+	}
+
+	return createConfiguredTelemetryService(
+		createClineTelemetryServiceConfig(telemetryConfig),
+	).telemetry;
+}
+
+export function createRemoteConfigSessionMessagesArtifactUploader(): SessionMessagesArtifactUploader {
+	const uploader = createSharedRemoteConfigSessionMessagesArtifactUploader();
+	return {
+		async uploadMessagesFile(input) {
+			await uploader.uploadMessagesFile(input);
+		},
+	};
+}
+
+export async function prepareRemoteConfigCoreIntegration(
+	options: PrepareRemoteConfigCoreIntegrationOptions,
+): Promise<PreparedRemoteConfigCoreIntegration> {
+	const prepared = await prepareRemoteConfigRuntime(options);
+	const telemetry = createTelemetryService(prepared, options);
+	const extensions = [prepared.pluginDefinition];
+	const userDistinctId = prepared.claims?.subject;
+	const blobUploadMetadataTemplate = buildRemoteConfigSessionBlobUploadMetadata(
+		prepared.bundle?.remoteConfig,
+		userDistinctId,
+	);
+	let registeredSessionId: string | undefined;
+
+	return {
+		prepared,
+		extensions,
+		telemetry,
+		applyToStartSessionInput(input: ClineCoreStartInput): ClineCoreStartInput {
+			const existingExtensions = input.config.extensions ?? [];
+			const existingTelemetry = input.config.telemetry;
+			const sessionId = blobUploadMetadataTemplate
+				? input.config.sessionId?.trim() || createSessionId()
+				: input.config.sessionId;
+			if (sessionId && blobUploadMetadataTemplate) {
+				registeredSessionId = sessionId;
+			}
+			const blobUploadMetadata =
+				sessionId && blobUploadMetadataTemplate
+					? registerRemoteConfigSessionBlobUpload(
+							sessionId,
+							prepared.bundle?.remoteConfig,
+							userDistinctId,
+						)
+					: undefined;
+			const sessionMetadata = blobUploadMetadata
+				? {
+						...(input.sessionMetadata ?? {}),
+						[REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY]:
+							blobUploadMetadata,
+					}
+				: input.sessionMetadata;
+			return {
+				...input,
+				...(sessionMetadata ? { sessionMetadata } : {}),
+				config: {
+					...input.config,
+					...(sessionId ? { sessionId } : {}),
+					extensions: [...existingExtensions, ...extensions],
+					telemetry: telemetry ?? existingTelemetry,
+				},
+			};
+		},
+		async dispose(): Promise<void> {
+			if (registeredSessionId) {
+				clearRemoteConfigSessionBlobUpload(registeredSessionId);
+			}
+		},
+	};
+}
+
+export {
+	buildRemoteConfigSessionBlobUploadMetadata,
+	REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY,
+	readRemoteConfigSessionBlobUploadMetadata,
+	registerRemoteConfigSessionBlobUpload,
+};
diff --git a/sdk/packages/core/src/runtime/capabilities/index.ts b/sdk/packages/core/src/runtime/capabilities/index.ts
new file mode 100644
index 0000000..3a4dec9
--- /dev/null
+++ b/sdk/packages/core/src/runtime/capabilities/index.ts
@@ -0,0 +1,2 @@
+export { normalizeRuntimeCapabilities } from "./normalize-runtime-capabilities";
+export type { RuntimeCapabilities } from "./runtime-capabilities";
diff --git a/sdk/packages/core/src/runtime/capabilities/normalize-runtime-capabilities.ts b/sdk/packages/core/src/runtime/capabilities/normalize-runtime-capabilities.ts
new file mode 100644
index 0000000..b8db1da
--- /dev/null
+++ b/sdk/packages/core/src/runtime/capabilities/normalize-runtime-capabilities.ts
@@ -0,0 +1,33 @@
+import type { RuntimeCapabilities } from "./runtime-capabilities";
+
+export function normalizeRuntimeCapabilities(
+	...sources: Array<RuntimeCapabilities | undefined>
+): RuntimeCapabilities | undefined {
+	let toolExecutors: RuntimeCapabilities["toolExecutors"] | undefined;
+	let requestToolApproval:
+		| RuntimeCapabilities["requestToolApproval"]
+		| undefined;
+
+	for (const source of sources) {
+		if (!source) continue;
+		if (source.toolExecutors) {
+			toolExecutors = {
+				...(toolExecutors ?? {}),
+				...source.toolExecutors,
+			};
+		}
+		if (source.requestToolApproval) {
+			requestToolApproval = source.requestToolApproval;
+		}
+	}
+
+	const hasToolExecutors =
+		toolExecutors && Object.keys(toolExecutors).length > 0;
+	if (!hasToolExecutors && !requestToolApproval) {
+		return undefined;
+	}
+	return {
+		...(hasToolExecutors ? { toolExecutors } : {}),
+		...(requestToolApproval ? { requestToolApproval } : {}),
+	};
+}
diff --git a/sdk/packages/core/src/runtime/capabilities/runtime-capabilities.ts b/sdk/packages/core/src/runtime/capabilities/runtime-capabilities.ts
new file mode 100644
index 0000000..8d68721
--- /dev/null
+++ b/sdk/packages/core/src/runtime/capabilities/runtime-capabilities.ts
@@ -0,0 +1,9 @@
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import type { ToolExecutors } from "../../extensions/tools";
+
+export interface RuntimeCapabilities {
+	toolExecutors?: Partial<ToolExecutors>;
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+}
diff --git a/sdk/packages/core/src/runtime/config/agent-message-codec.test.ts b/sdk/packages/core/src/runtime/config/agent-message-codec.test.ts
new file mode 100644
index 0000000..ca19b51
--- /dev/null
+++ b/sdk/packages/core/src/runtime/config/agent-message-codec.test.ts
@@ -0,0 +1,171 @@
+import { EMPTY_CONTENT_TEXT } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	agentMessageToMessageWithMetadata,
+	messageToAgentMessages,
+	messagesToAgentMessages,
+} from "./agent-message-codec";
+
+describe("agent message codec", () => {
+	it("replaces empty persisted messages with an explicit error text part", () => {
+		expect(
+			messageToAgentMessages({
+				id: "empty",
+				role: "assistant",
+				ts: 1,
+				content: [],
+			}),
+		).toEqual([
+			{
+				id: "empty",
+				role: "assistant",
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+				createdAt: 1,
+				metadata: undefined,
+				modelInfo: undefined,
+				metrics: undefined,
+			},
+		]);
+		expect(
+			messageToAgentMessages({
+				id: "blank",
+				role: "user",
+				ts: 1,
+				content: "",
+			}),
+		).toEqual([
+			{
+				id: "blank",
+				role: "user",
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+				createdAt: 1,
+				metadata: undefined,
+				modelInfo: undefined,
+				metrics: undefined,
+			},
+		]);
+		expect(
+			messageToAgentMessages({
+				id: "whitespace",
+				role: "assistant",
+				ts: 1,
+				content: "   \n\t  ",
+			}),
+		).toEqual([
+			{
+				id: "whitespace",
+				role: "assistant",
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+				createdAt: 1,
+				metadata: undefined,
+				modelInfo: undefined,
+				metrics: undefined,
+			},
+		]);
+	});
+
+	it("preserves mixed tool result and user text order", () => {
+		const messages = messageToAgentMessages({
+			id: "msg_mixed",
+			role: "user",
+			ts: 1,
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: "toolu_1",
+					name: "run_commands",
+					content: "tool output",
+				},
+				{
+					type: "text",
+					text: "steer this next",
+				},
+			],
+		});
+
+		expect(messages.map((message) => message.role)).toEqual(["tool", "user"]);
+		expect(messages[0]?.content).toEqual([
+			{
+				type: "tool-result",
+				toolCallId: "toolu_1",
+				toolName: "run_commands",
+				output: "tool output",
+				isError: undefined,
+			},
+		]);
+		expect(messages[1]?.content).toEqual([
+			{
+				type: "text",
+				text: "steer this next",
+			},
+		]);
+	});
+
+	it("keeps user text before later tool results", () => {
+		const messages = messageToAgentMessages({
+			id: "msg_text_first",
+			role: "user",
+			ts: 1,
+			content: [
+				{
+					type: "text",
+					text: "before",
+				},
+				{
+					type: "tool_result",
+					tool_use_id: "toolu_2",
+					name: "read_files",
+					content: "tool output",
+				},
+			],
+		});
+
+		expect(messages.map((message) => message.role)).toEqual(["user", "tool"]);
+		expect(messages[0]?.content).toEqual([{ type: "text", text: "before" }]);
+		expect(messages[1]?.content).toEqual([
+			expect.objectContaining({
+				type: "tool-result",
+				toolCallId: "toolu_2",
+				toolName: "read_files",
+			}),
+		]);
+	});
+
+	it("round-trips Gemini tool call thought signatures", () => {
+		const persisted = agentMessageToMessageWithMetadata({
+			id: "msg_tool_call",
+			role: "assistant",
+			createdAt: 1,
+			content: [
+				{
+					type: "tool-call",
+					toolCallId: "toolu_4",
+					toolName: "editor",
+					input: { path: "/tmp/out.txt" },
+					metadata: {
+						thoughtSignature: "sig_4",
+					},
+				},
+			],
+		});
+
+		expect(persisted.content).toEqual([
+			expect.objectContaining({
+				type: "tool_use",
+				id: "toolu_4",
+				name: "editor",
+				signature: "sig_4",
+			}),
+		]);
+
+		const [restored] = messagesToAgentMessages([persisted]);
+		expect(restored?.content[0]).toMatchObject({
+			type: "tool-call",
+			toolCallId: "toolu_4",
+			toolName: "editor",
+			metadata: {
+				signature: "sig_4",
+			},
+		});
+	});
+});
diff --git a/sdk/packages/core/src/runtime/config/agent-message-codec.ts b/sdk/packages/core/src/runtime/config/agent-message-codec.ts
new file mode 100644
index 0000000..d66d50b
--- /dev/null
+++ b/sdk/packages/core/src/runtime/config/agent-message-codec.ts
@@ -0,0 +1,301 @@
+import type {
+	AgentMessage,
+	AgentMessagePart,
+	AgentTextPart,
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	MessageWithMetadata,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolResultContent,
+	ToolUseContent,
+} from "@cline/shared";
+import { EMPTY_CONTENT_TEXT } from "@cline/shared";
+
+export function messageToAgentMessages(
+	message: MessageWithMetadata,
+): AgentMessage[] {
+	const blocks = normalizeContentBlocks(message.content);
+	const out: AgentMessage[] = [];
+	const baseId = message.id ?? generateMessageId();
+	let nonToolSegmentCount = 0;
+	let nonToolBlocks: Exclude<ContentBlock, ToolResultContent>[] = [];
+
+	const flushNonToolBlocks = () => {
+		if (nonToolBlocks.length === 0) {
+			return;
+		}
+		const id =
+			nonToolSegmentCount === 0
+				? baseId
+				: `${baseId}_part_${nonToolSegmentCount}`;
+		nonToolSegmentCount += 1;
+		out.push({
+			id,
+			role: message.role,
+			content: nonToolBlocks.map(contentBlockToAgentPart),
+			createdAt: message.ts ?? Date.now(),
+			metadata: message.metadata,
+			modelInfo: message.modelInfo,
+			metrics: metricsToAgentMetrics(message.metrics),
+		});
+		nonToolBlocks = [];
+	};
+
+	if (blocks.length === 0) {
+		out.push({
+			id: baseId,
+			role: message.role,
+			content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+			createdAt: message.ts ?? Date.now(),
+			metadata: message.metadata,
+			modelInfo: message.modelInfo,
+			metrics: metricsToAgentMetrics(message.metrics),
+		});
+		return out;
+	}
+
+	for (const block of blocks) {
+		if (block.type !== "tool_result") {
+			nonToolBlocks.push(block);
+			continue;
+		}
+		flushNonToolBlocks();
+		out.push({
+			id: `${baseId}_tool_${block.tool_use_id}`,
+			role: "tool",
+			content: [toolResultContentToAgentPart(block)],
+			createdAt: message.ts ?? Date.now(),
+			metadata: message.metadata,
+		});
+	}
+	flushNonToolBlocks();
+
+	return out;
+}
+
+export function messagesToAgentMessages(
+	messages: readonly MessageWithMetadata[],
+): AgentMessage[] {
+	return messages.flatMap(messageToAgentMessages);
+}
+
+export function agentMessageToMessageWithMetadata(
+	message: AgentMessage,
+): MessageWithMetadata {
+	const content = message.content
+		.map(agentPartToContentBlock)
+		.filter((block): block is ContentBlock => block !== undefined);
+	return {
+		id: message.id,
+		role: message.role === "tool" ? "user" : message.role,
+		content,
+		ts: message.createdAt,
+		metadata: message.metadata,
+		modelInfo: message.modelInfo,
+		metrics: agentMetricsToMetrics(message.metrics),
+	};
+}
+
+export function agentMessagesToMessagesWithMetadata(
+	messages: readonly AgentMessage[],
+): MessageWithMetadata[] {
+	return messages.map(agentMessageToMessageWithMetadata);
+}
+
+export function agentMessagesToMessages(
+	messages: readonly AgentMessage[],
+): Message[] {
+	const out: Message[] = [];
+	for (const message of messages) {
+		const content = message.content
+			.map(agentPartToContentBlock)
+			.filter((block): block is ContentBlock => block !== undefined);
+		const role = message.role === "tool" ? "user" : message.role;
+		const previous = out[out.length - 1];
+		if (
+			role === "user" &&
+			content.length > 0 &&
+			content.every((block) => block.type === "tool_result") &&
+			previous?.role === "user" &&
+			Array.isArray(previous.content) &&
+			previous.content.every((block) => block.type === "tool_result")
+		) {
+			previous.content.push(...content);
+			continue;
+		}
+		out.push({ role, content });
+	}
+	return out;
+}
+
+function normalizeContentBlocks(content: Message["content"]): ContentBlock[] {
+	if (typeof content === "string") {
+		return content.trim().length > 0
+			? [{ type: "text", text: content } as TextContent]
+			: [];
+	}
+	return [...content];
+}
+
+function contentBlockToAgentPart(block: ContentBlock): AgentMessagePart {
+	switch (block.type) {
+		case "text":
+			return { type: "text", text: block.text };
+		case "thinking":
+			return {
+				type: "reasoning",
+				text: block.thinking,
+				metadata: block.signature
+					? { signature: block.signature, details: block.details }
+					: block.details
+						? { details: block.details }
+						: undefined,
+			};
+		case "redacted_thinking":
+			return {
+				type: "reasoning",
+				text: "",
+				redacted: true,
+				metadata: { data: block.data },
+			};
+		case "image":
+			return { type: "image", image: block.data, mediaType: block.mediaType };
+		case "file":
+			return { type: "file", path: block.path, content: block.content };
+		case "tool_use":
+			return {
+				type: "tool-call",
+				toolCallId: block.id,
+				toolName: block.name,
+				input: block.input,
+				metadata: block.signature
+					? {
+							signature: block.signature,
+						}
+					: undefined,
+			};
+		case "tool_result":
+			return toolResultContentToAgentPart(block);
+	}
+}
+
+function toolResultContentToAgentPart(
+	block: ToolResultContent,
+): AgentMessagePart {
+	return {
+		type: "tool-result",
+		toolCallId: block.tool_use_id,
+		toolName: block.name,
+		output: block.content,
+		isError: block.is_error,
+	};
+}
+
+function agentPartToContentBlock(
+	part: AgentMessagePart,
+): ContentBlock | undefined {
+	switch (part.type) {
+		case "text":
+			return { type: "text", text: (part as AgentTextPart).text };
+		case "reasoning": {
+			if (part.redacted === true) {
+				const data =
+					(part.metadata as { data?: string } | undefined)?.data ?? "";
+				return {
+					type: "redacted_thinking",
+					data,
+				} satisfies RedactedThinkingContent;
+			}
+			const metadata = part.metadata as
+				| { signature?: string; details?: unknown[] }
+				| undefined;
+			return {
+				type: "thinking",
+				thinking: part.text,
+				signature: metadata?.signature,
+				details: metadata?.details,
+			} satisfies ThinkingContent;
+		}
+		case "image":
+			return typeof part.image === "string"
+				? ({
+						type: "image",
+						data: part.image,
+						mediaType: part.mediaType ?? "image/png",
+					} satisfies ImageContent)
+				: undefined;
+		case "file":
+			return {
+				type: "file",
+				path: part.path,
+				content: part.content,
+			} satisfies FileContent;
+		case "tool-call": {
+			const metadata = part.metadata as
+				| {
+						signature?: string;
+						thoughtSignature?: string;
+				  }
+				| undefined;
+			return {
+				type: "tool_use",
+				id: part.toolCallId,
+				name: part.toolName,
+				input: (part.input as Record<string, unknown>) ?? {},
+				signature: metadata?.thoughtSignature ?? metadata?.signature,
+			} satisfies ToolUseContent;
+		}
+		case "tool-result": {
+			const output = part.output;
+			const content =
+				typeof output === "string"
+					? output
+					: Array.isArray(output)
+						? (output as ToolResultContent["content"])
+						: JSON.stringify(output);
+			return {
+				type: "tool_result",
+				tool_use_id: part.toolCallId,
+				name: part.toolName,
+				content,
+				is_error: part.isError,
+			} satisfies ToolResultContent;
+		}
+	}
+}
+
+function metricsToAgentMetrics(
+	metrics: MessageWithMetadata["metrics"],
+): AgentMessage["metrics"] {
+	if (!metrics) return undefined;
+	return {
+		inputTokens: metrics.inputTokens ?? 0,
+		outputTokens: metrics.outputTokens ?? 0,
+		cacheReadTokens: metrics.cacheReadTokens ?? 0,
+		cacheWriteTokens: metrics.cacheWriteTokens ?? 0,
+		cost: metrics.cost,
+	};
+}
+
+function agentMetricsToMetrics(
+	metrics: AgentMessage["metrics"],
+): MessageWithMetadata["metrics"] {
+	if (!metrics) return undefined;
+	return {
+		inputTokens: metrics.inputTokens,
+		outputTokens: metrics.outputTokens,
+		cacheReadTokens: metrics.cacheReadTokens,
+		cacheWriteTokens: metrics.cacheWriteTokens,
+		cost: metrics.cost,
+	};
+}
+
+let msgSeq = 0;
+function generateMessageId(): string {
+	msgSeq += 1;
+	return `msg_${Date.now().toString(36)}_${msgSeq.toString(36)}`;
+}
diff --git a/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.test.ts b/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.test.ts
new file mode 100644
index 0000000..b7f4177
--- /dev/null
+++ b/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.test.ts
@@ -0,0 +1,268 @@
+/**
+ * Unit tests for `createAgentRuntimeConfig` and its small pure
+ * helpers (`buildModelOptions`, `buildMessageModelInfo`,
+ * `resolveToolExecution`).
+ *
+ */
+
+import type {
+	AgentConfig,
+	AgentModel,
+	AgentModelEvent,
+	AgentTool,
+	ITelemetryService,
+} from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import {
+	buildMessageModelInfo,
+	buildModelOptions,
+	createAgentRuntimeConfig,
+	resolveToolExecution,
+} from "./agent-runtime-config-builder";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeAgentConfig(overrides: Partial<AgentConfig> = {}): AgentConfig {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-3-5-sonnet",
+		systemPrompt: "You are a helpful assistant.",
+		tools: [],
+		...overrides,
+	};
+}
+
+const nullModel: AgentModel = {
+	async stream() {
+		return (async function* (): AsyncIterable<AgentModelEvent> {
+			yield { type: "finish", reason: "stop" };
+		})();
+	},
+};
+
+// ---------------------------------------------------------------------------
+// buildModelOptions
+// ---------------------------------------------------------------------------
+
+describe("buildModelOptions", () => {
+	it("returns undefined when no reasoning/budget fields are set", () => {
+		expect(buildModelOptions(makeAgentConfig())).toBeUndefined();
+	});
+
+	it("collects all provided fields", () => {
+		const config = makeAgentConfig({
+			thinking: true,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 1024,
+			maxTokensPerTurn: 4096,
+			apiTimeoutMs: 60_000,
+		});
+		expect(buildModelOptions(config)).toEqual({
+			thinking: true,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 1024,
+			maxTokensPerTurn: 4096,
+			apiTimeoutMs: 60_000,
+		});
+	});
+
+	it("omits undefined fields", () => {
+		const config = makeAgentConfig({ thinking: true });
+		expect(buildModelOptions(config)).toEqual({ thinking: true });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// buildMessageModelInfo
+// ---------------------------------------------------------------------------
+
+describe("buildMessageModelInfo", () => {
+	it("builds { id, provider, family } from AgentConfig", () => {
+		const config = makeAgentConfig({
+			providerId: "openai",
+			modelId: "gpt-4o",
+			providerConfig: { family: "gpt-4" },
+		});
+		expect(buildMessageModelInfo(config)).toEqual({
+			id: "gpt-4o",
+			provider: "openai",
+			family: "gpt-4",
+		});
+	});
+
+	it("omits family when not present in providerConfig", () => {
+		const config = makeAgentConfig();
+		expect(buildMessageModelInfo(config)).toEqual({
+			id: "claude-3-5-sonnet",
+			provider: "anthropic",
+			family: undefined,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// resolveToolExecution
+// ---------------------------------------------------------------------------
+
+describe("resolveToolExecution", () => {
+	it("returns undefined when unset", () => {
+		expect(resolveToolExecution(undefined)).toBeUndefined();
+	});
+
+	it("returns 'sequential' for 1", () => {
+		expect(resolveToolExecution(1)).toBe("sequential");
+	});
+
+	it("returns 'parallel' for >= 2", () => {
+		expect(resolveToolExecution(2)).toBe("parallel");
+		expect(resolveToolExecution(8)).toBe("parallel");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// createAgentRuntimeConfig
+// ---------------------------------------------------------------------------
+
+describe("createAgentRuntimeConfig", () => {
+	it("produces a config with the PLAN §3.2.1 field mapping", () => {
+		const agentConfig = makeAgentConfig({
+			systemPrompt: "sp",
+			providerId: "openai",
+			modelId: "gpt-4o",
+			providerConfig: { family: "gpt-4" },
+			thinking: true,
+			reasoningEffort: "high",
+			maxIterations: 7,
+			maxParallelToolCalls: 4,
+			completionPolicy: { requireCompletionTool: true },
+			toolPolicies: { "*": { autoApprove: false } },
+			requestToolApproval: async () => ({ approved: true }),
+			consumePendingUserMessage: () => "steer",
+		});
+		const tools: AgentTool[] = [
+			{
+				name: "echo",
+				description: "e",
+				inputSchema: { type: "object" },
+				execute: async () => "x",
+			},
+		];
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig,
+			sessionId: "session_abc",
+			agentId: "agent_abc",
+			conversationId: "conversation_abc",
+			agentRole: "lead",
+			model: nullModel,
+			tools,
+		});
+		expect(runtimeConfig.sessionId).toBe("session_abc");
+		expect(runtimeConfig.agentId).toBe("agent_abc");
+		expect(runtimeConfig.conversationId).toBe("conversation_abc");
+		expect(runtimeConfig.agentRole).toBe("lead");
+		expect(runtimeConfig.systemPrompt).toBe("sp");
+		expect(runtimeConfig.model).toBe(nullModel);
+		expect(runtimeConfig.messageModelInfo).toEqual({
+			id: "gpt-4o",
+			provider: "openai",
+			family: "gpt-4",
+		});
+		expect(runtimeConfig.modelOptions).toEqual({
+			thinking: true,
+			reasoningEffort: "high",
+		});
+		expect(runtimeConfig.tools).toBe(tools);
+		expect(runtimeConfig.maxIterations).toBe(7);
+		expect(runtimeConfig.toolExecution).toBe("parallel");
+		expect(runtimeConfig.completionPolicy).toEqual({
+			requireCompletionTool: true,
+		});
+		expect(runtimeConfig.toolPolicies).toEqual({
+			"*": { autoApprove: false },
+		});
+		expect(runtimeConfig.requestToolApproval).toBe(
+			agentConfig.requestToolApproval,
+		);
+		expect(runtimeConfig.consumePendingUserMessage).toBe(
+			agentConfig.consumePendingUserMessage,
+		);
+	});
+
+	it("uses the override systemPrompt when provided", () => {
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig({ systemPrompt: "default" }),
+			agentId: "a",
+			model: nullModel,
+			systemPrompt: "override",
+		});
+		expect(runtimeConfig.systemPrompt).toBe("override");
+	});
+
+	it("populates hooks when provided", () => {
+		const beforeRun = vi.fn();
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig(),
+			agentId: "a",
+			model: nullModel,
+			hooks: { beforeRun },
+		});
+		expect(runtimeConfig.hooks?.beforeRun).toBe(beforeRun);
+	});
+
+	it("omits hooks when none are provided", () => {
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig(),
+			agentId: "a",
+			model: nullModel,
+		});
+		expect(runtimeConfig.hooks).toBeUndefined();
+	});
+
+	it("passes through plugins/initialMessages/logger/telemetry", () => {
+		const logger = {
+			log: vi.fn(),
+			debug: vi.fn(),
+			info: vi.fn(),
+			warn: vi.fn(),
+			error: vi.fn(),
+		};
+		const telemetryCapture = vi.fn();
+		const telemetry = {
+			capture: telemetryCapture,
+			captureRequired: vi.fn(),
+			setDistinctId: vi.fn(),
+			setMetadata: vi.fn(),
+			updateMetadata: vi.fn(),
+			setCommonProperties: vi.fn(),
+			updateCommonProperties: vi.fn(),
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: vi.fn(async () => undefined),
+			dispose: vi.fn(async () => undefined),
+		} as unknown as ITelemetryService;
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: makeAgentConfig(),
+			agentId: "a",
+			model: nullModel,
+			logger,
+			telemetry,
+			plugins: [{ name: "p1" }],
+			initialMessages: [
+				{
+					id: "m1",
+					role: "user",
+					content: [{ type: "text", text: "hi" }],
+					createdAt: 1,
+				},
+			],
+		});
+		expect(runtimeConfig.logger).toBe(logger);
+		expect(runtimeConfig.telemetry).toBe(telemetry);
+		expect(runtimeConfig.plugins).toHaveLength(1);
+		expect(runtimeConfig.initialMessages).toHaveLength(1);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.ts b/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.ts
new file mode 100644
index 0000000..0f6d6b7
--- /dev/null
+++ b/sdk/packages/core/src/runtime/config/agent-runtime-config-builder.ts
@@ -0,0 +1,181 @@
+/**
+ * Build an `AgentRuntimeConfig` from an `AgentConfig` plus session-owned
+ * supporting objects (model handler, tools, hooks, plugins, telemetry).
+ *
+ * The function is intentionally **pure**: it does not create handlers or tools
+ * itself; it receives them already resolved from the caller (`SessionRuntime`)
+ * and wires them into an `AgentRuntimeConfig`.
+ *
+ * Fields that do **not** round-trip into `AgentRuntimeConfig`
+ * (e.g. `execution.maxConsecutiveMistakes`, `execution.loopDetection`) are
+ * consumed by `SessionRuntime` / `MistakeTracker` /
+ * `LoopDetectionTracker` — not passed through here.
+ */
+
+import type {
+	AgentConfig,
+	AgentMessage,
+	AgentModel,
+	AgentRuntimeConfig,
+	AgentRuntimeHooks,
+	AgentRuntimePlugin,
+	AgentRuntimePrepareTurnContext,
+	AgentRuntimePrepareTurnResult,
+	AgentTool,
+	BasicLogger,
+	ITelemetryService,
+} from "@cline/shared";
+
+/**
+ * Inputs required to assemble an `AgentRuntimeConfig`. Distinct from
+ * `AgentConfig` because some of these (the model adapter, the hook
+ * bridge's runtime-hooks bag, a resolved plugin list) can only be
+ * produced inside `SessionRuntime`.
+ */
+export interface CreateAgentRuntimeConfigInput {
+	readonly agentConfig: AgentConfig;
+	/**
+	 * Core/hub runtime session identifier used for host lifecycle operations,
+	 * event routing, persistence, and approval delivery.
+	 */
+	readonly sessionId?: string;
+	readonly agentId: string;
+	/**
+	 * Agent conversation/transcript identifier used by tools, hooks, telemetry,
+	 * and model history correlation.
+	 */
+	readonly conversationId?: string;
+	readonly parentAgentId?: string;
+	/** The role label for teammates (`AgentConfig.role` in sub-agent configs). */
+	readonly agentRole?: string;
+	/** Pre-built model adapter (produced by `apiHandlerToAgentModel`). */
+	readonly model: AgentModel;
+	readonly logger?: BasicLogger;
+	readonly telemetry?: ITelemetryService;
+	/** Pre-built tool array (builtins + plugin-contributed + session extras). */
+	readonly tools?: readonly AgentTool<unknown, unknown>[];
+	readonly toolContextMetadata?: Record<string, unknown>;
+	/** Pre-resolved plugin list from the plugin loader. */
+	readonly plugins?: readonly AgentRuntimePlugin[];
+	/** Runtime hooks supplied by the session/runtime builder. */
+	readonly hooks?: Partial<AgentRuntimeHooks>;
+	/** Host-owned context pipeline invoked before runtime model hooks. */
+	readonly prepareTurn?: (
+		context: AgentRuntimePrepareTurnContext,
+	) =>
+		| Promise<AgentRuntimePrepareTurnResult | undefined>
+		| AgentRuntimePrepareTurnResult
+		| undefined;
+	/** Seed messages (usually `session.conversation.getMessages()`). */
+	readonly initialMessages?: readonly AgentMessage[];
+	/**
+	 * Override for `AgentRuntimeConfig.systemPrompt` — useful when
+	 * the caller has composed additional guidance (e.g. via
+	 * `LocalRuntimeHost.composeSystemPrompt`). Defaults to
+	 * `agentConfig.systemPrompt`.
+	 */
+	readonly systemPrompt?: string;
+}
+
+/**
+ * Produce an `AgentRuntimeConfig` from session-owned runtime inputs.
+ */
+export function createAgentRuntimeConfig(
+	input: CreateAgentRuntimeConfigInput,
+): AgentRuntimeConfig {
+	const { agentConfig } = input;
+
+	const modelOptions = buildModelOptions(agentConfig);
+	const messageModelInfo = buildMessageModelInfo(agentConfig);
+	const hooks = input.hooks;
+	const toolExecution = resolveToolExecution(agentConfig.maxParallelToolCalls);
+
+	const config: AgentRuntimeConfig = {
+		sessionId: input.sessionId ?? agentConfig.sessionId,
+		agentId: input.agentId,
+		conversationId: input.conversationId,
+		parentAgentId: input.parentAgentId,
+		agentRole: input.agentRole,
+		systemPrompt: input.systemPrompt ?? agentConfig.systemPrompt,
+		messageModelInfo,
+		model: input.model,
+		modelOptions,
+		tools: input.tools,
+		hooks,
+		prepareTurn: input.prepareTurn,
+		consumePendingUserMessage: agentConfig.consumePendingUserMessage,
+		plugins: input.plugins,
+		logger: input.logger ?? agentConfig.logger,
+		telemetry: input.telemetry ?? agentConfig.telemetry,
+		initialMessages: input.initialMessages,
+		completionPolicy: agentConfig.completionPolicy,
+		maxIterations: agentConfig.maxIterations,
+		toolExecution,
+		toolPolicies: agentConfig.toolPolicies,
+		toolContextMetadata: input.toolContextMetadata,
+		requestToolApproval: agentConfig.requestToolApproval,
+	};
+
+	return config;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/**
+ * Collect the provider-/reasoning-related fields from `AgentConfig`
+ * into `AgentRuntimeConfig.modelOptions`. Kept undefined when every
+ * field is undefined so the runtime does not receive an empty object.
+ */
+export function buildModelOptions(
+	config: AgentConfig,
+): Record<string, unknown> | undefined {
+	const options: Record<string, unknown> = {};
+	if (config.thinking !== undefined) {
+		options.thinking = config.thinking;
+	}
+	if (config.reasoningEffort !== undefined) {
+		options.reasoningEffort = config.reasoningEffort;
+	}
+	if (config.thinkingBudgetTokens !== undefined) {
+		options.thinkingBudgetTokens = config.thinkingBudgetTokens;
+	}
+	if (config.maxTokensPerTurn !== undefined) {
+		options.maxTokensPerTurn = config.maxTokensPerTurn;
+	}
+	if (config.apiTimeoutMs !== undefined) {
+		options.apiTimeoutMs = config.apiTimeoutMs;
+	}
+	return Object.keys(options).length > 0 ? options : undefined;
+}
+
+/**
+ * Compose `messageModelInfo` from the provider-related fields per
+ * §3.2.1: `{ id: modelId, provider: providerId, family:
+ * providerConfig?.family }`.
+ */
+export function buildMessageModelInfo(
+	config: AgentConfig,
+): AgentMessage["modelInfo"] {
+	const family = (config.providerConfig as { family?: string } | undefined)
+		?.family;
+	return {
+		id: config.modelId,
+		provider: config.providerId,
+		family,
+	};
+}
+
+/**
+ * `"parallel"` when `maxParallelToolCalls ≥ 2`, `"sequential"` when
+ * `1`, `undefined` when the caller did not specify.
+ */
+export function resolveToolExecution(
+	maxParallelToolCalls: number | undefined,
+): "sequential" | "parallel" | undefined {
+	if (maxParallelToolCalls === undefined) {
+		return undefined;
+	}
+	return maxParallelToolCalls >= 2 ? "parallel" : "sequential";
+}
diff --git a/sdk/packages/core/src/runtime/config/connection-update.test.ts b/sdk/packages/core/src/runtime/config/connection-update.test.ts
new file mode 100644
index 0000000..cdcfb28
--- /dev/null
+++ b/sdk/packages/core/src/runtime/config/connection-update.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { buildConnectionUpdate } from "./connection-update";
+
+describe("buildConnectionUpdate", () => {
+	const base = {
+		providerId: "openai",
+		modelId: "codex-test",
+		apiKey: "sk-test",
+	};
+
+	it("includes only the connection fields that are defined", () => {
+		expect(buildConnectionUpdate(base)).toEqual(base);
+		expect(
+			buildConnectionUpdate({
+				...base,
+				baseUrl: "https://example.test",
+				headers: { "x-a": "1" },
+			}),
+		).toEqual({
+			...base,
+			baseUrl: "https://example.test",
+			headers: { "x-a": "1" },
+		});
+	});
+
+	it("passes an empty string through so callers can clear a field", () => {
+		expect(buildConnectionUpdate({ ...base, apiKey: "" })).toEqual({
+			...base,
+			apiKey: "",
+		});
+	});
+
+	it("clears reasoning when thinking is explicitly false", () => {
+		expect(
+			buildConnectionUpdate({
+				...base,
+				thinking: false,
+				reasoningEffort: "high",
+				thinkingBudgetTokens: 1024,
+			}),
+		).toEqual({
+			...base,
+			thinking: false,
+			reasoningEffort: null,
+			thinkingBudgetTokens: null,
+		});
+	});
+
+	it("enables reasoning with the selected effort", () => {
+		expect(
+			buildConnectionUpdate({
+				...base,
+				thinking: true,
+				reasoningEffort: "low",
+			}),
+		).toEqual({
+			...base,
+			thinking: true,
+			reasoningEffort: "low",
+			thinkingBudgetTokens: null,
+		});
+	});
+
+	it("clears stale effort and budget when thinking is enabled without them", () => {
+		expect(buildConnectionUpdate({ ...base, thinking: true })).toEqual({
+			...base,
+			thinking: true,
+			reasoningEffort: null,
+			thinkingBudgetTokens: null,
+		});
+	});
+
+	it("keeps a provided budget when thinking is enabled explicitly", () => {
+		expect(
+			buildConnectionUpdate({
+				...base,
+				thinking: true,
+				thinkingBudgetTokens: 1024,
+			}),
+		).toEqual({
+			...base,
+			thinking: true,
+			reasoningEffort: null,
+			thinkingBudgetTokens: 1024,
+		});
+	});
+
+	it("enables thinking when only an effort is provided", () => {
+		expect(
+			buildConnectionUpdate({ ...base, reasoningEffort: "medium" }),
+		).toEqual({ ...base, thinking: true, reasoningEffort: "medium" });
+	});
+
+	it("enables thinking and truncates a fractional budget", () => {
+		expect(
+			buildConnectionUpdate({ ...base, thinkingBudgetTokens: 2048.7 }),
+		).toEqual({ ...base, thinking: true, thinkingBudgetTokens: 2048 });
+	});
+
+	it("leaves reasoning untouched when thinking is unset", () => {
+		expect(buildConnectionUpdate(base)).toEqual(base);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/config/connection-update.ts b/sdk/packages/core/src/runtime/config/connection-update.ts
new file mode 100644
index 0000000..9c192c2
--- /dev/null
+++ b/sdk/packages/core/src/runtime/config/connection-update.ts
@@ -0,0 +1,110 @@
+import type { CoreSessionConfig } from "../../types/config";
+
+export interface ConnectionUpdate {
+	providerId?: string;
+	modelId?: string;
+	apiKey?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	providerConfig?: CoreSessionConfig["providerConfig"];
+	reasoningEffort?: CoreSessionConfig["reasoningEffort"] | null;
+	thinking?: CoreSessionConfig["thinking"] | null;
+	thinkingBudgetTokens?: CoreSessionConfig["thinkingBudgetTokens"] | null;
+}
+
+export interface ConnectionUpdateInput {
+	providerId?: string;
+	modelId?: string;
+	apiKey?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	providerConfig?: CoreSessionConfig["providerConfig"];
+	thinking?: boolean;
+	reasoningEffort?: CoreSessionConfig["reasoningEffort"];
+	thinkingBudgetTokens?: number;
+}
+
+/**
+ * Builds a ConnectionUpdate for switching a live session's provider/model
+ * connection. Shared by clients (CLI, desktop sidecar, …) so the
+ * thinking/reasoning transition rules stay consistent:
+ * - `thinking: false` disables reasoning and clears effort/budget.
+ * - `thinking: true` (or a provided effort/budget) enables reasoning; an
+ *   explicit `thinking: true` resets the reasoning state, so a stale effort or
+ *   token budget from the previous connection is cleared unless a replacement
+ *   accompanies it. A bare effort/budget without a `thinking` flag updates
+ *   only the provided field.
+ * - `thinking: undefined` leaves the session's reasoning state untouched.
+ * Connection fields are included only when defined; an empty string is passed
+ * through (it means "clear"), so callers that want to skip blanks must drop
+ * them before calling.
+ */
+export function buildConnectionUpdate(
+	input: ConnectionUpdateInput,
+): ConnectionUpdate {
+	const update: ConnectionUpdate = {};
+	if (input.providerId !== undefined) update.providerId = input.providerId;
+	if (input.modelId !== undefined) update.modelId = input.modelId;
+	if (input.apiKey !== undefined) update.apiKey = input.apiKey;
+	if (input.baseUrl !== undefined) update.baseUrl = input.baseUrl;
+	if (input.headers !== undefined) update.headers = input.headers;
+	if (input.providerConfig !== undefined) {
+		update.providerConfig = input.providerConfig;
+	}
+	if (input.thinking === false) {
+		update.thinking = false;
+		update.reasoningEffort = null;
+		update.thinkingBudgetTokens = null;
+		return update;
+	}
+	if (input.thinking === true) {
+		update.thinking = true;
+		update.reasoningEffort = input.reasoningEffort ?? null;
+		// Cleared symmetrically with reasoningEffort; a valid budget below
+		// overwrites the null.
+		update.thinkingBudgetTokens = null;
+	} else if (input.reasoningEffort !== undefined) {
+		update.thinking = true;
+		update.reasoningEffort = input.reasoningEffort;
+	}
+	if (
+		typeof input.thinkingBudgetTokens === "number" &&
+		Number.isFinite(input.thinkingBudgetTokens) &&
+		input.thinkingBudgetTokens > 0
+	) {
+		update.thinking = true;
+		update.thinkingBudgetTokens = Math.trunc(input.thinkingBudgetTokens);
+	}
+	return update;
+}
+
+export function normalizeConnectionUpdate(
+	updates: ConnectionUpdate,
+): ConnectionUpdate {
+	const normalized: ConnectionUpdate = { ...updates };
+	const hasThinking = Object.hasOwn(updates, "thinking");
+	const hasThinkingBudgetTokens = Object.hasOwn(
+		updates,
+		"thinkingBudgetTokens",
+	);
+	const disablesThinking =
+		updates.thinking === false || updates.thinking === null;
+
+	if (disablesThinking) {
+		normalized.reasoningEffort = undefined;
+		normalized.thinkingBudgetTokens = undefined;
+		return normalized;
+	}
+
+	if (
+		!hasThinking &&
+		hasThinkingBudgetTokens &&
+		typeof updates.thinkingBudgetTokens === "number" &&
+		Number.isFinite(updates.thinkingBudgetTokens) &&
+		updates.thinkingBudgetTokens > 0
+	) {
+		normalized.thinking = true;
+	}
+
+	return normalized;
+}
diff --git a/sdk/packages/core/src/runtime/host/history.test.ts b/sdk/packages/core/src/runtime/host/history.test.ts
new file mode 100644
index 0000000..bddc38f
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/history.test.ts
@@ -0,0 +1,573 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { SessionRow } from "../../session/models/session-row";
+import type { SessionRecord } from "../../types/sessions";
+import {
+	hydrateSessionHistory,
+	listSessionHistory,
+	listSessionHistoryFromBackend,
+} from "./history";
+
+const originalSessionDataDir = process.env.CLINE_SESSION_DATA_DIR;
+
+let tempSessionDataDir = "";
+
+function createRow(
+	overrides: Partial<SessionRecord> & Pick<SessionRecord, "sessionId">,
+): SessionRecord {
+	return {
+		source: "cli",
+		pid: 1,
+		startedAt: "2026-04-21T02:17:46.169Z",
+		status: "completed",
+		interactive: false,
+		provider: "",
+		model: "",
+		cwd: "/tmp/workspace",
+		workspaceRoot: "/tmp/workspace",
+		enableTools: true,
+		enableSpawn: false,
+		enableTeams: false,
+		isSubagent: false,
+		updatedAt: "2026-04-21T02:17:46.169Z",
+		...overrides,
+	};
+}
+
+function createBackendRow(
+	overrides: Partial<SessionRow> & Pick<SessionRow, "sessionId">,
+): SessionRow {
+	return {
+		source: "cli",
+		pid: 1,
+		startedAt: "2026-04-21T02:17:46.169Z",
+		endedAt: null,
+		exitCode: 0,
+		status: "completed",
+		statusLock: 0,
+		interactive: false,
+		provider: "cline",
+		model: "anthropic/claude-sonnet-4.6",
+		cwd: "/tmp/workspace",
+		workspaceRoot: "/tmp/workspace",
+		teamName: null,
+		enableTools: true,
+		enableSpawn: false,
+		enableTeams: false,
+		parentSessionId: null,
+		parentAgentId: null,
+		agentId: null,
+		conversationId: null,
+		isSubagent: false,
+		prompt: null,
+		metadata: null,
+		hookPath: "",
+		messagesPath: null,
+		updatedAt: "2026-04-21T02:17:46.169Z",
+		...overrides,
+	};
+}
+
+async function writeManifest(
+	sessionId: string,
+	manifest: Record<string, unknown>,
+): Promise<void> {
+	const sessionDir = join(tempSessionDataDir, sessionId);
+	const completeManifest = {
+		version: 1,
+		session_id: sessionId,
+		source: "cli",
+		pid: 1,
+		started_at: "2026-04-20T00:00:00.000Z",
+		status: "completed",
+		interactive: false,
+		provider: "cline",
+		model: "anthropic/claude-sonnet-4.6",
+		cwd: "/tmp/workspace",
+		workspace_root: "/tmp/workspace",
+		enable_tools: true,
+		enable_spawn: false,
+		enable_teams: false,
+		...manifest,
+	};
+	await mkdir(sessionDir, { recursive: true });
+	await writeFile(
+		join(sessionDir, `${sessionId}.json`),
+		`${JSON.stringify(completeManifest, null, 2)}\n`,
+		"utf8",
+	);
+}
+
+async function writeMessagesFile(
+	filename: string,
+	messages: unknown[] = [{ role: "user", content: "hi" }],
+): Promise<string> {
+	if (!tempSessionDataDir) {
+		tempSessionDataDir = await mkdtemp(join(tmpdir(), "cline-core-history-"));
+	}
+	const path = join(tempSessionDataDir, filename);
+	await writeFile(
+		path,
+		`${JSON.stringify({ version: 1, messages }, null, 2)}\n`,
+		"utf8",
+	);
+	return path;
+}
+
+describe("session history", () => {
+	afterEach(async () => {
+		vi.clearAllMocks();
+		if (tempSessionDataDir) {
+			await rm(tempSessionDataDir, { recursive: true, force: true });
+			tempSessionDataDir = "";
+		}
+		if (originalSessionDataDir === undefined) {
+			delete process.env.CLINE_SESSION_DATA_DIR;
+		} else {
+			process.env.CLINE_SESSION_DATA_DIR = originalSessionDataDir;
+		}
+	});
+
+	it("preserves rows that already have history display metadata", async () => {
+		const readSessionMessages = vi.fn();
+		const rows = await hydrateSessionHistory({ readSessionMessages }, [
+			createRow({
+				sessionId: "sess_1",
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				prompt: "hello",
+				metadata: {
+					title: "hello",
+					totalCost: 0.02,
+				},
+			}),
+		]);
+
+		expect(rows).toEqual([
+			expect.objectContaining({
+				sessionId: "sess_1",
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				metadata: expect.objectContaining({
+					title: "hello",
+					totalCost: 0.02,
+				}),
+			}),
+		]);
+		expect(readSessionMessages).not.toHaveBeenCalled();
+	});
+
+	it("hydrates missing provider, model, and cost from stored messages", async () => {
+		const readSessionMessages = vi.fn().mockResolvedValue([
+			{
+				role: "user",
+				content: [{ type: "text", text: "hello" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "hi" }],
+				modelInfo: {
+					provider: "cline",
+					id: "anthropic/claude-sonnet-4.6",
+				},
+				metrics: {
+					cost: 0.02,
+				},
+			},
+		]);
+
+		const [row] = await hydrateSessionHistory({ readSessionMessages }, [
+			createRow({
+				sessionId: "sess_2",
+				prompt: "hello",
+				metadata: {},
+			}),
+		]);
+
+		expect(readSessionMessages).toHaveBeenCalledWith("sess_2");
+		expect(row).toMatchObject({
+			sessionId: "sess_2",
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			metadata: {
+				title: "hello",
+				totalCost: 0.02,
+			},
+		});
+	});
+
+	it("falls back to nested metadata provider/model ids before reading messages", async () => {
+		const readSessionMessages = vi
+			.fn()
+			.mockResolvedValue([{ role: "user" as const, content: "hi" }]);
+
+		const [row] = await hydrateSessionHistory({ readSessionMessages }, [
+			createRow({
+				sessionId: "sess_3",
+				metadata: {
+					title: "hello",
+					provider: { id: "cline" },
+					model: { id: "anthropic/claude-haiku-4.5" },
+				},
+			}),
+		]);
+
+		expect(row.provider).toBe("cline");
+		expect(row.model).toBe("anthropic/claude-haiku-4.5");
+		expect(readSessionMessages).toHaveBeenCalledWith("sess_3");
+	});
+
+	it("preserves host ordering when no manifest fallback rows are merged", async () => {
+		const readSessionMessages = vi
+			.fn()
+			.mockResolvedValue([{ role: "user" as const, content: "hi" }]);
+		const first = createRow({
+			sessionId: "sess_first",
+			startedAt: "2026-04-19T00:00:00.000Z",
+		});
+		const second = createRow({
+			sessionId: "sess_second",
+			startedAt: "2026-04-20T00:00:00.000Z",
+		});
+
+		const rows = await listSessionHistory(
+			{
+				listSessions: vi.fn().mockResolvedValue([first, second]),
+				readSessionMessages,
+			},
+			{ limit: 2 },
+		);
+
+		expect(rows.map((row) => row.sessionId)).toEqual([
+			"sess_first",
+			"sess_second",
+		]);
+	});
+
+	it("passes zero limits through without forcing a row", async () => {
+		const list = vi.fn().mockResolvedValue([
+			createRow({
+				sessionId: "sess_4",
+			}),
+		]);
+		const readSessionMessages = vi.fn();
+
+		const rows = await listSessionHistory(
+			{ listSessions: list, readSessionMessages },
+			{ limit: 0 },
+		);
+
+		expect(list).toHaveBeenCalledWith(0);
+		expect(rows).toEqual([]);
+		expect(readSessionMessages).not.toHaveBeenCalled();
+	});
+
+	it("can list lightweight valid history without hydrating display metadata", async () => {
+		const list = vi.fn().mockResolvedValue([
+			createRow({
+				sessionId: "sess_lightweight",
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				metadata: { title: "stored title" },
+			}),
+		]);
+		const readSessionMessages = vi
+			.fn()
+			.mockResolvedValue([{ role: "user" as const, content: "hi" }]);
+
+		const rows = await listSessionHistory(
+			{ listSessions: list, readSessionMessages },
+			{ limit: 10, hydrate: false },
+		);
+
+		expect(list).toHaveBeenCalledWith(20);
+		expect(readSessionMessages).not.toHaveBeenCalled();
+		expect(rows).toEqual([
+			expect.objectContaining({
+				sessionId: "sess_lightweight",
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				metadata: expect.objectContaining({ title: "stored title" }),
+			}),
+		]);
+	});
+
+	it("projects legacy interactive running sessions with completed assistant turns as idle", async () => {
+		const list = vi.fn().mockResolvedValue([
+			createRow({
+				sessionId: "sess_legacy_idle",
+				status: "running",
+				interactive: true,
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+			}),
+		]);
+		const readSessionMessages = vi.fn().mockResolvedValue([
+			{ role: "user" as const, content: "hi" },
+			{
+				role: "assistant" as const,
+				content: [{ type: "text", text: "hello" }],
+			},
+		]);
+
+		const rows = await listSessionHistory(
+			{ listSessions: list, readSessionMessages },
+			{ limit: 10, hydrate: false },
+		);
+
+		expect(readSessionMessages).toHaveBeenCalledWith("sess_legacy_idle");
+		expect(rows).toEqual([
+			expect.objectContaining({
+				sessionId: "sess_legacy_idle",
+				status: "idle",
+			}),
+		]);
+	});
+
+	it("keeps legacy interactive running sessions running when the last turn is not complete", async () => {
+		const list = vi.fn().mockResolvedValue([
+			createRow({
+				sessionId: "sess_legacy_running",
+				status: "running",
+				interactive: true,
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+			}),
+		]);
+		const readSessionMessages = vi
+			.fn()
+			.mockResolvedValue([{ role: "user" as const, content: "keep going" }]);
+
+		const rows = await listSessionHistory(
+			{ listSessions: list, readSessionMessages },
+			{ limit: 10, hydrate: false },
+		);
+
+		expect(rows).toEqual([
+			expect.objectContaining({
+				sessionId: "sess_legacy_running",
+				status: "running",
+			}),
+		]);
+	});
+
+	it("filters child sessions from history by default", async () => {
+		const rootMessagesPath = await writeMessagesFile("root.messages.json");
+		const listSessions = vi.fn().mockResolvedValue([
+			createBackendRow({
+				sessionId: "root-session__teamtask__java-haiku-agent__abc123",
+				parentSessionId: "root-session",
+				parentAgentId: "lead",
+				agentId: "java-haiku-agent",
+				isSubagent: true,
+			}),
+			createBackendRow({
+				sessionId: "root-session__plain-worker",
+				parentSessionId: "root-session",
+				parentAgentId: "lead",
+				agentId: "plain-worker",
+				isSubagent: true,
+			}),
+			createBackendRow({
+				sessionId: "root-session",
+				messagesPath: rootMessagesPath,
+			}),
+		]);
+
+		const rows = await listSessionHistoryFromBackend(
+			{ listSessions },
+			{ limit: 10, hydrate: false },
+		);
+
+		expect(listSessions).toHaveBeenCalledWith(20);
+		expect(rows.map((row) => row.sessionId)).toEqual(["root-session"]);
+	});
+
+	it("can include child sessions when explicitly requested", async () => {
+		const childMessagesPath = await writeMessagesFile("child.messages.json");
+		const rootMessagesPath = await writeMessagesFile("root.messages.json");
+		const listSessions = vi.fn().mockResolvedValue([
+			createBackendRow({
+				sessionId: "root-session__teamtask__java-haiku-agent__abc123",
+				parentSessionId: "root-session",
+				parentAgentId: "lead",
+				agentId: "java-haiku-agent",
+				isSubagent: true,
+				messagesPath: childMessagesPath,
+			}),
+			createBackendRow({
+				sessionId: "root-session",
+				messagesPath: rootMessagesPath,
+			}),
+		]);
+
+		const rows = await listSessionHistoryFromBackend(
+			{ listSessions },
+			{ limit: 10, hydrate: false, includeSubagents: true },
+		);
+
+		expect(listSessions).toHaveBeenCalledWith(10);
+		expect(rows.map((row) => row.sessionId)).toEqual([
+			"root-session__teamtask__java-haiku-agent__abc123",
+			"root-session",
+		]);
+	});
+
+	it("keeps backend history rows even when messages are empty or unreadable", async () => {
+		const fullMessagesPath = await writeMessagesFile("full.messages.json");
+		const emptyMessagesPath = await writeMessagesFile(
+			"empty.messages.json",
+			[],
+		);
+		const listSessions = vi.fn().mockResolvedValue([
+			createBackendRow({
+				sessionId: "sess_full",
+				messagesPath: fullMessagesPath,
+			}),
+			createBackendRow({
+				sessionId: "sess_empty",
+				messagesPath: emptyMessagesPath,
+			}),
+			createBackendRow({
+				sessionId: "sess_unreadable",
+				messagesPath: "/tmp/missing.messages.json",
+			}),
+		]);
+
+		const rows = await listSessionHistoryFromBackend(
+			{ listSessions },
+			{ limit: 10, hydrate: false },
+		);
+
+		expect(listSessions).toHaveBeenCalledWith(20);
+		expect(rows.map((row) => row.sessionId)).toEqual([
+			"sess_full",
+			"sess_empty",
+			"sess_unreadable",
+		]);
+	});
+
+	it("lists directly from a session backend without a runtime host", async () => {
+		tempSessionDataDir = await mkdtemp(join(tmpdir(), "cline-core-history-"));
+		const messagesPath = join(tempSessionDataDir, "messages.json");
+		await writeFile(
+			messagesPath,
+			JSON.stringify([{ role: "user", content: "hi" }]),
+			"utf8",
+		);
+		const listSessions = vi.fn().mockResolvedValue([
+			createBackendRow({
+				sessionId: "sess_backend_direct",
+				prompt: "backend prompt",
+				metadata: { title: "backend title" },
+				messagesPath,
+			}),
+		]);
+
+		const rows = await listSessionHistoryFromBackend(
+			{ listSessions },
+			{ limit: 5, hydrate: false },
+		);
+
+		expect(listSessions).toHaveBeenCalledWith(20);
+		expect(rows).toEqual([
+			expect.objectContaining({
+				sessionId: "sess_backend_direct",
+				prompt: "backend prompt",
+				metadata: expect.objectContaining({ title: "backend title" }),
+			}),
+		]);
+	});
+
+	it("merges manifest fallback rows when the backend list is short", async () => {
+		tempSessionDataDir = await mkdtemp(join(tmpdir(), "cline-core-history-"));
+		process.env.CLINE_SESSION_DATA_DIR = tempSessionDataDir;
+		const manifestMessagesPath = join(
+			tempSessionDataDir,
+			"manifest.messages.json",
+		);
+		const olderManifestMessagesPath = join(
+			tempSessionDataDir,
+			"older-manifest.messages.json",
+		);
+		await writeFile(
+			manifestMessagesPath,
+			JSON.stringify([{ role: "user", content: "manifest prompt" }]),
+			"utf8",
+		);
+		await writeFile(
+			olderManifestMessagesPath,
+			JSON.stringify([{ role: "user", content: "older manifest prompt" }]),
+			"utf8",
+		);
+		await writeManifest("sess_1800000000000", {
+			session_id: "sess_1800000000000",
+			started_at: "2026-04-20T00:00:00.000Z",
+			source: "cli",
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			cwd: "/tmp/workspace",
+			workspace_root: "/tmp/workspace",
+			prompt: "manifest prompt",
+			messages_path: manifestMessagesPath,
+			metadata: {
+				title: "manifest title",
+				totalCost: 0.03,
+			},
+		});
+		await writeManifest("sess_1700000000000", {
+			session_id: "sess_1700000000000",
+			started_at: "2026-04-19T00:00:00.000Z",
+			source: "cli",
+			provider: "cline",
+			model: "anthropic/claude-haiku-4.5",
+			cwd: "/tmp/workspace",
+			workspace_root: "/tmp/workspace",
+			prompt: "older manifest prompt",
+			messages_path: olderManifestMessagesPath,
+		});
+
+		const readSessionMessages = vi
+			.fn()
+			.mockResolvedValue([{ role: "user" as const, content: "hi" }]);
+		const rows = await listSessionHistory(
+			{
+				listSessions: vi.fn().mockResolvedValue([
+					createRow({
+						sessionId: "sess_backend",
+						startedAt: "2026-04-21T00:00:00.000Z",
+						provider: "cline",
+						model: "anthropic/claude-opus-4.1",
+						metadata: {
+							title: "backend title",
+							totalCost: 0.05,
+						},
+					}),
+				]),
+				readSessionMessages,
+			},
+			{
+				limit: 3,
+				includeManifestFallback: true,
+			},
+		);
+
+		expect(rows.map((row) => row.sessionId)).toEqual([
+			"sess_backend",
+			"sess_1800000000000",
+			"sess_1700000000000",
+		]);
+		expect(rows[1]).toMatchObject({
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			prompt: "manifest prompt",
+			metadata: {
+				title: "manifest title",
+				totalCost: 0.03,
+			},
+		});
+		expect(readSessionMessages).toHaveBeenCalledWith("sess_1700000000000");
+	});
+});
diff --git a/sdk/packages/core/src/runtime/host/history.ts b/sdk/packages/core/src/runtime/host/history.ts
new file mode 100644
index 0000000..8b79c2f
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/history.ts
@@ -0,0 +1,516 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import { formatDisplayUserInput, normalizeUserInput } from "@cline/shared";
+import { resolveSessionDataDir } from "@cline/shared/storage";
+import { toSessionRecord } from "../../services/session-data";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import { SessionManifestSchema } from "../../session/models/session-manifest";
+import type { SessionRow } from "../../session/models/session-row";
+import type {
+	SessionHistoryMetadata,
+	SessionHistoryRecord,
+	SessionRecord,
+} from "../../types/sessions";
+import type { SessionBackend } from "./host";
+import type { RuntimeHost } from "./runtime-host";
+import { readPersistedMessagesFile } from "./runtime-host-support";
+
+export interface SessionHistoryListOptions {
+	limit?: number;
+	includeManifestFallback?: boolean;
+	hydrate?: boolean;
+	includeSubagents?: boolean;
+}
+
+type StoredSessionMessage = LlmsProviders.Message & {
+	metrics?: {
+		cost?: number;
+	};
+	modelInfo?: {
+		id?: string;
+		provider?: string;
+	};
+};
+
+type TextBlock = {
+	type?: string;
+	text?: string;
+};
+
+function asTrimmedString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asKnownString(value: unknown): string | undefined {
+	const trimmed = asTrimmedString(value);
+	if (!trimmed) {
+		return undefined;
+	}
+	return trimmed.toLowerCase() === "unknown" ? undefined : trimmed;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function asHistoryMetadata(value: unknown): SessionHistoryMetadata | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return { ...(value as Record<string, unknown>) };
+}
+
+function normalizeHistoryLimit(limit: number | undefined): number {
+	const value = limit ?? 200;
+	return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 200;
+}
+
+function normalizeHistoryScanLimit(limit: number): number {
+	if (limit === 0) {
+		return 0;
+	}
+	return Math.min(Math.max(limit * 2, 20), 2000);
+}
+
+function isRootSessionRecord(
+	row: Pick<SessionRecord, "isSubagent"> & {
+		parentSessionId?: string;
+	},
+): boolean {
+	return row.isSubagent !== true && !asTrimmedString(row.parentSessionId);
+}
+
+function extractSessionRecencyToken(sessionId: string): number {
+	const matches = sessionId.match(/\d{13,}/g);
+	if (!matches || matches.length === 0) {
+		return 0;
+	}
+	let best = 0;
+	for (const match of matches) {
+		const value = Number.parseInt(match, 10);
+		if (Number.isFinite(value) && value > best) {
+			best = value;
+		}
+	}
+	return best;
+}
+
+export function manifestToSessionRecord(
+	manifest: SessionManifest,
+): SessionRecord {
+	return {
+		sessionId: manifest.session_id,
+		source: manifest.source,
+		pid: manifest.pid,
+		startedAt: manifest.started_at,
+		endedAt: manifest.ended_at ?? null,
+		exitCode: manifest.exit_code ?? null,
+		status: manifest.status,
+		interactive: manifest.interactive,
+		provider: manifest.provider,
+		model: manifest.model,
+		cwd: manifest.cwd,
+		workspaceRoot: manifest.workspace_root,
+		teamName: manifest.team_name,
+		enableTools: manifest.enable_tools,
+		enableSpawn: manifest.enable_spawn,
+		enableTeams: manifest.enable_teams,
+		isSubagent: false,
+		prompt: manifest.prompt,
+		metadata: manifest.metadata,
+		messagesPath: manifest.messages_path,
+		updatedAt: manifest.ended_at ?? manifest.started_at,
+	};
+}
+
+async function listManifestHistoryRows(
+	limit: number,
+): Promise<SessionRecord[]> {
+	const requestedLimit = normalizeHistoryLimit(limit);
+	if (requestedLimit === 0) {
+		return [];
+	}
+	const sessionsDir = resolveSessionDataDir();
+	const entries = await readdir(sessionsDir, { withFileTypes: true }).catch(
+		() => [],
+	);
+	const candidateEntries = entries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => ({
+			entry,
+			recency: extractSessionRecencyToken(entry.name.trim()),
+		}))
+		.sort(
+			(left, right) =>
+				right.recency - left.recency ||
+				right.entry.name.localeCompare(left.entry.name),
+		);
+	const rows = await Promise.all(
+		candidateEntries.map(async ({ entry }) => {
+			const sessionId = entry.name.trim();
+			if (!sessionId) {
+				return undefined;
+			}
+			const manifestPath = join(sessionsDir, sessionId, `${sessionId}.json`);
+			const raw = await readFile(manifestPath, "utf8").catch(() => undefined);
+			if (!raw) {
+				return undefined;
+			}
+			let parsedJson: unknown;
+			try {
+				parsedJson = JSON.parse(raw) as unknown;
+			} catch {
+				return undefined;
+			}
+			const parsedManifest = SessionManifestSchema.safeParse(parsedJson);
+			if (!parsedManifest.success) {
+				return undefined;
+			}
+			return manifestToSessionRecord(parsedManifest.data);
+		}),
+	);
+
+	return rows
+		.filter((row): row is SessionRecord => Boolean(row))
+		.sort((left, right) => right.startedAt.localeCompare(left.startedAt))
+		.slice(0, requestedLimit);
+}
+
+async function listHostSessionRows(
+	host: Pick<RuntimeHost, "listSessions" | "readSessionMessages">,
+	limit: number,
+	options: { includeSubagents: boolean },
+): Promise<SessionRecord[]> {
+	const requestedLimit = normalizeHistoryLimit(limit);
+	if (requestedLimit === 0) {
+		await host.listSessions(0);
+		return [];
+	}
+	const scanLimit = options.includeSubagents
+		? requestedLimit
+		: normalizeHistoryScanLimit(requestedLimit);
+	const rows = await host.listSessions(scanLimit);
+	const filtered = options.includeSubagents
+		? rows
+		: rows.filter(isRootSessionRecord);
+	return filtered.slice(0, requestedLimit);
+}
+
+function extractTextFromContent(
+	content: LlmsProviders.Message["content"],
+): string {
+	if (typeof content === "string") {
+		return content.trim();
+	}
+	const segments: string[] = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") {
+			continue;
+		}
+		const maybeText = block as TextBlock;
+		if (maybeText.type !== "text") {
+			continue;
+		}
+		const text = maybeText.text?.trim();
+		if (text) {
+			segments.push(text);
+		}
+	}
+	return segments.join("\n").trim();
+}
+
+function toSingleLine(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+function truncateText(text: string, limit: number): string {
+	if (text.length <= limit) {
+		return text;
+	}
+	return `${text.slice(0, Math.max(0, limit - 3)).trimEnd()}...`;
+}
+
+function inferTitleFromMessages(
+	messages: LlmsProviders.Message[],
+): string | undefined {
+	for (const role of ["user", "assistant"] as const) {
+		for (const raw of messages) {
+			if (raw.role !== role) {
+				continue;
+			}
+			const text = toSingleLine(extractTextFromContent(raw.content));
+			if (!text) {
+				continue;
+			}
+			const formatted =
+				role === "user" ? toSingleLine(formatDisplayUserInput(text)) : text;
+			const normalized = normalizeUserInput(
+				formatted.split("\n")[0] ?? formatted,
+			);
+			return truncateText(normalized, 50);
+		}
+	}
+	return undefined;
+}
+
+function summarizeCostFromMessages(messages: LlmsProviders.Message[]): number {
+	let total = 0;
+	for (const message of messages as StoredSessionMessage[]) {
+		total += asFiniteNumber(message.metrics?.cost) ?? 0;
+	}
+	return total;
+}
+
+function inferProviderAndModelFromMessages(messages: LlmsProviders.Message[]): {
+	provider?: string;
+	model?: string;
+} {
+	let provider: string | undefined;
+	let model: string | undefined;
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const message = messages[i] as StoredSessionMessage;
+		if (!provider) {
+			provider = asKnownString(message.modelInfo?.provider);
+		}
+		if (!model) {
+			model = asKnownString(message.modelInfo?.id);
+		}
+		if (provider && model) {
+			break;
+		}
+	}
+	return { provider, model };
+}
+
+function getMetadataProvider(
+	metadata?: SessionHistoryMetadata,
+): string | undefined {
+	return (
+		asKnownString(metadata?.provider) ??
+		asKnownString(
+			metadata?.provider &&
+				typeof metadata.provider === "object" &&
+				!Array.isArray(metadata.provider)
+				? (metadata.provider as Record<string, unknown>).id
+				: undefined,
+		)
+	);
+}
+
+function getMetadataModel(
+	metadata?: SessionHistoryMetadata,
+): string | undefined {
+	return (
+		asKnownString(metadata?.model) ??
+		asKnownString(
+			metadata?.model &&
+				typeof metadata.model === "object" &&
+				!Array.isArray(metadata.model)
+				? (metadata.model as Record<string, unknown>).id
+				: undefined,
+		)
+	);
+}
+
+function normalizeHistoryRow(
+	row: SessionRecord,
+	overrides?: {
+		title?: string;
+		provider?: string;
+		model?: string;
+		totalCost?: number;
+	},
+): SessionHistoryRecord {
+	const metadata = asHistoryMetadata(row.metadata);
+	const title =
+		asTrimmedString(overrides?.title) ?? asTrimmedString(metadata?.title);
+	const totalCost =
+		asFiniteNumber(overrides?.totalCost) ?? asFiniteNumber(metadata?.totalCost);
+	const nextMetadata =
+		metadata || title !== undefined || totalCost !== undefined
+			? {
+					...(metadata ?? {}),
+					...(title !== undefined ? { title } : {}),
+					...(totalCost !== undefined ? { totalCost } : {}),
+				}
+			: undefined;
+	return {
+		...row,
+		provider:
+			asKnownString(overrides?.provider) ??
+			asKnownString(row.provider) ??
+			getMetadataProvider(metadata) ??
+			"",
+		model:
+			asKnownString(overrides?.model) ??
+			asKnownString(row.model) ??
+			getMetadataModel(metadata) ??
+			"",
+		metadata: nextMetadata,
+	};
+}
+
+function messageContainsToolCall(message: LlmsProviders.Message): boolean {
+	const content = message.content;
+	if (!Array.isArray(content)) {
+		return false;
+	}
+	return content.some(
+		(part) =>
+			!!part &&
+			typeof part === "object" &&
+			(part as { type?: unknown }).type === "tool-call",
+	);
+}
+
+function shouldProjectLegacyRunningSessionAsIdle(
+	row: SessionRecord,
+	messages: LlmsProviders.Message[],
+): boolean {
+	if (row.status !== "running" || row.interactive !== true) {
+		return false;
+	}
+	const lastMessage = messages.at(-1);
+	return (
+		lastMessage?.role === "assistant" && !messageContainsToolCall(lastMessage)
+	);
+}
+
+async function projectLegacyRunningRowsAsIdle(
+	host: Pick<RuntimeHost, "readSessionMessages">,
+	rows: SessionRecord[],
+): Promise<SessionRecord[]> {
+	return await Promise.all(
+		rows.map(async (row) => {
+			if (row.status !== "running" || row.interactive !== true) {
+				return row;
+			}
+			const messages = await host.readSessionMessages(row.sessionId);
+			return shouldProjectLegacyRunningSessionAsIdle(row, messages)
+				? { ...row, status: "idle" }
+				: row;
+		}),
+	);
+}
+
+export async function hydrateSessionHistory(
+	host: Pick<RuntimeHost, "readSessionMessages">,
+	rows: SessionRecord[],
+): Promise<SessionHistoryRecord[]> {
+	return await Promise.all(
+		rows.map(async (row) => {
+			const initial = normalizeHistoryRow(row);
+			const hasTitle = Boolean(asTrimmedString(initial.metadata?.title));
+			const hasProvider = Boolean(asKnownString(initial.provider));
+			const hasModel = Boolean(asKnownString(initial.model));
+			const knownCost = asFiniteNumber(initial.metadata?.totalCost);
+			const hasCost = knownCost !== undefined && knownCost > 0;
+			if (hasTitle && hasProvider && hasModel && hasCost) {
+				return initial;
+			}
+			const messages = await host.readSessionMessages(row.sessionId);
+			if (messages.length === 0) {
+				return initial;
+			}
+			const inferredProviderModel = inferProviderAndModelFromMessages(messages);
+			const inferredCost = summarizeCostFromMessages(messages);
+			return normalizeHistoryRow(row, {
+				title: hasTitle ? undefined : inferTitleFromMessages(messages),
+				provider: hasProvider ? undefined : inferredProviderModel.provider,
+				model: hasModel ? undefined : inferredProviderModel.model,
+				totalCost: hasCost || inferredCost <= 0 ? undefined : inferredCost,
+			});
+		}),
+	);
+}
+
+export async function listSessionHistory(
+	host: Pick<RuntimeHost, "listSessions" | "readSessionMessages">,
+	options: SessionHistoryListOptions = {},
+): Promise<SessionHistoryRecord[]> {
+	const limit = normalizeHistoryLimit(options.limit);
+	const includeSubagents = options.includeSubagents === true;
+	const backendRows = await listHostSessionRows(host, limit, {
+		includeSubagents,
+	});
+	const manifestRows =
+		options.includeManifestFallback === true && backendRows.length < limit
+			? await listManifestHistoryRows(Math.min(Math.max(limit * 2, 100), 500))
+			: [];
+	const merged = new Map<string, SessionRecord>();
+	for (const row of [...backendRows, ...manifestRows]) {
+		if (merged.has(row.sessionId)) {
+			continue;
+		}
+		merged.set(row.sessionId, row);
+	}
+	const rows =
+		manifestRows.length === 0
+			? backendRows
+			: Array.from(merged.values())
+					.sort((left, right) => right.startedAt.localeCompare(left.startedAt))
+					.slice(0, limit);
+	const projectedRows = await projectLegacyRunningRowsAsIdle(host, rows);
+	if (options.hydrate === false) {
+		return projectedRows.map((row) => normalizeHistoryRow(row));
+	}
+	return await hydrateSessionHistory(host, projectedRows);
+}
+
+async function readManifestMessagesPath(
+	sessionId: string,
+): Promise<string | undefined> {
+	const target = sessionId.trim();
+	if (!target) {
+		return undefined;
+	}
+	const manifestPath = join(resolveSessionDataDir(), target, `${target}.json`);
+	const raw = await readFile(manifestPath, "utf8").catch(() => undefined);
+	if (!raw) {
+		return undefined;
+	}
+	try {
+		const parsed = SessionManifestSchema.safeParse(JSON.parse(raw) as unknown);
+		return parsed.success ? parsed.data.messages_path : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Lists history directly from the persistence backend without constructing a
+ * runtime host. This keeps read-only history commands from initializing runtime
+ * services such as plugins, MCP, or hub transport.
+ */
+export async function listSessionHistoryFromBackend(
+	backend: Pick<SessionBackend, "listSessions">,
+	options: SessionHistoryListOptions = {},
+): Promise<SessionHistoryRecord[]> {
+	const rowsById = new Map<string, SessionRow>();
+	const host = {
+		listSessions: async (limit?: number): Promise<SessionRecord[]> => {
+			const rows = await backend.listSessions(limit);
+			rowsById.clear();
+			for (const row of rows) {
+				rowsById.set(row.sessionId, row);
+			}
+			return rows.map(toSessionRecord);
+		},
+		readSessionMessages: async (
+			sessionId: string,
+		): Promise<LlmsProviders.Message[]> => {
+			const messagesPath =
+				rowsById.get(sessionId)?.messagesPath ??
+				(await readManifestMessagesPath(sessionId));
+			return await readPersistedMessagesFile(messagesPath);
+		},
+	};
+	return await listSessionHistory(host, options);
+}
diff --git a/sdk/packages/core/src/runtime/host/host.test.ts b/sdk/packages/core/src/runtime/host/host.test.ts
new file mode 100644
index 0000000..0daaab0
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/host.test.ts
@@ -0,0 +1,297 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { FileSessionService } from "../../session/services/file-session-service";
+
+const sqliteInitMock = vi.hoisted(() => vi.fn());
+const ensureCompatibleLocalHubUrlMock = vi.hoisted(() => vi.fn());
+const resolveCompatibleLocalHubUrlMock = vi.hoisted(() => vi.fn());
+const hubConnectMock = vi.hoisted(() => vi.fn());
+const prewarmDetachedHubServerMock = vi.hoisted(() => vi.fn());
+
+vi.mock("../../hub/client", async () => {
+	const actual =
+		await vi.importActual<typeof import("../../hub/client")>(
+			"../../hub/client",
+		);
+	return {
+		...actual,
+		NodeHubClient: class {
+			connect = hubConnectMock;
+			command = vi.fn();
+			subscribe = vi.fn(() => () => {});
+			close = vi.fn();
+		},
+		ensureCompatibleLocalHubUrl: ensureCompatibleLocalHubUrlMock,
+		resolveCompatibleLocalHubUrl: resolveCompatibleLocalHubUrlMock,
+	};
+});
+
+vi.mock("../../hub/daemon", async () => {
+	const actual =
+		await vi.importActual<typeof import("../../hub/daemon")>(
+			"../../hub/daemon",
+		);
+	return {
+		...actual,
+		prewarmDetachedHubServer: prewarmDetachedHubServerMock,
+	};
+});
+
+vi.mock("../../services/storage/sqlite-session-store", () => ({
+	SqliteSessionStore: class {
+		init(): void {
+			sqliteInitMock();
+		}
+	},
+}));
+
+describe("runtime host resolution", () => {
+	const logger = {
+		debug: vi.fn(),
+		log: vi.fn(),
+		error: vi.fn(),
+	};
+
+	afterEach(() => {
+		sqliteInitMock.mockReset();
+		ensureCompatibleLocalHubUrlMock.mockReset();
+		resolveCompatibleLocalHubUrlMock.mockReset();
+		hubConnectMock.mockReset();
+		prewarmDetachedHubServerMock.mockReset();
+		logger.debug.mockReset();
+		logger.log.mockReset();
+		logger.error.mockReset();
+		delete process.env.CLINE_SESSION_BACKEND_MODE;
+		delete process.env.CLINE_VCR;
+		vi.resetModules();
+	});
+
+	it("falls back to file session storage when sqlite initialization fails", async () => {
+		sqliteInitMock.mockImplementation(() => {
+			throw new Error("sqlite unavailable");
+		});
+		const { resolveSessionBackend } = await import("./host");
+
+		const backend = await resolveSessionBackend({ backendMode: "local" });
+		expect(backend.constructor.name).toBe("FileSessionService");
+	});
+
+	it("silently falls back to file session storage when node:sqlite is unavailable", async () => {
+		sqliteInitMock.mockImplementation(() => {
+			const error = new Error(
+				"No such built-in module: node:sqlite",
+			) as Error & {
+				code?: string;
+			};
+			error.code = "ERR_UNKNOWN_BUILTIN_MODULE";
+			throw error;
+		});
+		const { resolveSessionBackend } = await import("./host");
+
+		const backend = await resolveSessionBackend({ backendMode: "local" });
+		expect(backend.constructor.name).toBe("FileSessionService");
+	});
+
+	it("honors env-managed local mode inside core backend resolution", async () => {
+		process.env.CLINE_SESSION_BACKEND_MODE = "local";
+		const { resolveSessionBackend } = await import("./host");
+
+		const backend = await resolveSessionBackend({});
+
+		expect(backend).not.toBeInstanceOf(FileSessionService);
+	});
+
+	it("forces local backend when vcr is enabled", async () => {
+		process.env.CLINE_VCR = "1";
+		const { resolveSessionBackend } = await import("./host");
+
+		const backend = await resolveSessionBackend({});
+
+		expect(backend).not.toBeInstanceOf(FileSessionService);
+	});
+
+	it("prefers a compatible local hub when backendMode is auto", async () => {
+		const { createRuntimeHost } = await import("./host");
+		const { HubRuntimeHost } = await import(
+			"../../hub/runtime-host/hub-runtime-host"
+		);
+		resolveCompatibleLocalHubUrlMock.mockResolvedValue(
+			"ws://127.0.0.1:25463/hub",
+		);
+		hubConnectMock.mockResolvedValue(undefined);
+
+		const host = await createRuntimeHost({
+			backendMode: "auto",
+			logger,
+			hub: {
+				strategy: "prefer-hub",
+			},
+		});
+
+		expect(host).toBeInstanceOf(HubRuntimeHost);
+		expect(prewarmDetachedHubServerMock).toHaveBeenCalledWith(process.cwd());
+		expect(resolveCompatibleLocalHubUrlMock).toHaveBeenCalledWith({
+			endpoint: undefined,
+			strategy: "prefer-hub",
+		});
+		expect(ensureCompatibleLocalHubUrlMock).not.toHaveBeenCalled();
+		expect(logger.log).toHaveBeenCalledWith(
+			"Using discovered local hub runtime host",
+			{
+				url: "ws://127.0.0.1:25463/hub",
+			},
+		);
+	});
+
+	it("falls back to local runtime when auto hub discovery fails", async () => {
+		const { createRuntimeHost } = await import("./host");
+		const { LocalRuntimeHost } = await import("./local-runtime-host");
+		resolveCompatibleLocalHubUrlMock.mockResolvedValue(undefined);
+
+		const host = await createRuntimeHost({
+			backendMode: "auto",
+			logger,
+		});
+
+		expect(host).toBeInstanceOf(LocalRuntimeHost);
+		expect(prewarmDetachedHubServerMock).toHaveBeenCalledWith(process.cwd());
+		expect(resolveCompatibleLocalHubUrlMock).toHaveBeenCalledWith({
+			endpoint: undefined,
+			strategy: "prefer-hub",
+		});
+		expect(ensureCompatibleLocalHubUrlMock).not.toHaveBeenCalled();
+		expect(logger.log).toHaveBeenCalledWith(
+			"Falling back to local runtime host",
+			{
+				reason: "compatible_hub_unavailable",
+				severity: "warn",
+			},
+		);
+	});
+
+	it("falls back to local runtime when auto hub connect fails", async () => {
+		const { createRuntimeHost } = await import("./host");
+		const { LocalRuntimeHost } = await import("./local-runtime-host");
+		resolveCompatibleLocalHubUrlMock.mockResolvedValue(
+			"ws://127.0.0.1:25463/hub",
+		);
+		hubConnectMock.mockRejectedValue(new Error("connect failed"));
+
+		const host = await createRuntimeHost({
+			backendMode: "auto",
+			logger,
+		});
+
+		expect(host).toBeInstanceOf(LocalRuntimeHost);
+		expect(prewarmDetachedHubServerMock).toHaveBeenCalledWith(process.cwd());
+		expect(logger.log).toHaveBeenCalledWith(
+			"Falling back to local runtime host",
+			expect.objectContaining({
+				reason: "hub_connect_failed",
+				severity: "warn",
+			}),
+		);
+	});
+
+	it("uses a hub runtime host when backendMode is hub", async () => {
+		const { createRuntimeHost } = await import("./host");
+		const { HubRuntimeHost } = await import(
+			"../../hub/runtime-host/hub-runtime-host"
+		);
+		ensureCompatibleLocalHubUrlMock.mockResolvedValue(
+			"ws://127.0.0.1:25463/hub",
+		);
+
+		const host = await createRuntimeHost({
+			backendMode: "hub",
+		});
+
+		expect(host).toBeInstanceOf(HubRuntimeHost);
+		expect(prewarmDetachedHubServerMock).toHaveBeenCalledWith(process.cwd());
+		expect(ensureCompatibleLocalHubUrlMock).toHaveBeenCalledWith({
+			strategy: "require-hub",
+		});
+	});
+
+	it("uses the configured hub workspace root when prewarming", async () => {
+		const { createRuntimeHost } = await import("./host");
+		resolveCompatibleLocalHubUrlMock.mockResolvedValue(undefined);
+
+		await createRuntimeHost({
+			backendMode: "auto",
+			hub: {
+				workspaceRoot: "/workspace/project",
+			},
+		});
+
+		expect(prewarmDetachedHubServerMock).toHaveBeenCalledWith(
+			"/workspace/project",
+		);
+	});
+
+	it("does not prewarm when using an explicit hub endpoint", async () => {
+		const { createRuntimeHost } = await import("./host");
+		resolveCompatibleLocalHubUrlMock.mockResolvedValue(undefined);
+
+		await createRuntimeHost({
+			backendMode: "auto",
+			hub: {
+				endpoint: "ws://127.0.0.1:25463/hub",
+			},
+		});
+
+		expect(prewarmDetachedHubServerMock).not.toHaveBeenCalled();
+	});
+
+	it("uses a remote runtime host when backendMode is remote", async () => {
+		const { createRuntimeHost } = await import("./host");
+		const { RemoteRuntimeHost } = await import(
+			"../../hub/runtime-host/remote-runtime-host"
+		);
+
+		const host = await createRuntimeHost({
+			backendMode: "remote",
+			remote: {
+				endpoint: "https://remote.example.com/hub",
+			},
+			logger,
+		});
+
+		expect(host).toBeInstanceOf(RemoteRuntimeHost);
+		expect(ensureCompatibleLocalHubUrlMock).not.toHaveBeenCalled();
+		expect(logger.log).toHaveBeenCalledWith("Using remote runtime host", {
+			endpoint: "https://remote.example.com/hub",
+		});
+	});
+
+	it("allows runtime capabilities in remote runtime mode", async () => {
+		const { createRuntimeHost } = await import("./host");
+		const { RemoteRuntimeHost } = await import(
+			"../../hub/runtime-host/remote-runtime-host"
+		);
+		const askQuestion = vi.fn(async () => "yes");
+
+		const host = await createRuntimeHost({
+			backendMode: "remote",
+			remote: {
+				endpoint: "https://remote.example.com/hub",
+			},
+			capabilities: {
+				toolExecutors: { askQuestion },
+			},
+		});
+
+		expect(host).toBeInstanceOf(RemoteRuntimeHost);
+	});
+
+	it("requires a remote endpoint when backendMode is remote", async () => {
+		const { createRuntimeHost } = await import("./host");
+
+		await expect(
+			createRuntimeHost({
+				backendMode: "remote",
+			}),
+		).rejects.toThrow(
+			"Remote runtime mode requires `remote.endpoint` to be configured.",
+		);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/host/host.ts b/sdk/packages/core/src/runtime/host/host.ts
new file mode 100644
index 0000000..63fff2d
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/host.ts
@@ -0,0 +1,248 @@
+import { captureSdkError } from "@cline/shared";
+import type { ClineCoreOptions } from "../../cline-core/types";
+import {
+	ensureCompatibleLocalHubUrl,
+	resolveCompatibleLocalHubUrl,
+} from "../../hub/client";
+import { prewarmDetachedHubServer } from "../../hub/daemon";
+import { HubRuntimeHost } from "../../hub/runtime-host/hub-runtime-host";
+import { RemoteRuntimeHost } from "../../hub/runtime-host/remote-runtime-host";
+import { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import { resolveCoreDistinctId } from "../../services/telemetry/distinct-id";
+import { FileSessionService } from "../../session/services/file-session-service";
+import { CoreSessionService } from "../../session/services/session-service";
+import { LocalRuntimeHost } from "./local-runtime-host";
+import type { RuntimeHost, RuntimeHostMode } from "./runtime-host";
+
+function resolveConfiguredBackendMode(
+	options: ClineCoreOptions,
+): RuntimeHostMode {
+	if (options.backendMode) {
+		return options.backendMode;
+	}
+	if (process.env.CLINE_VCR?.trim()) {
+		return "local";
+	}
+	const raw = process.env.CLINE_SESSION_BACKEND_MODE?.trim().toLowerCase();
+	if (raw === "local" || raw === "hub" || raw === "remote") {
+		return raw;
+	}
+	return "auto";
+}
+
+export type SessionBackend = CoreSessionService | FileSessionService;
+
+let cachedBackend: SessionBackend | undefined;
+let backendInitPromise: Promise<SessionBackend> | undefined;
+
+function prewarmLocalHubIfNeeded(
+	configuredMode: RuntimeHostMode,
+	options: ClineCoreOptions,
+): void {
+	if (configuredMode !== "auto" && configuredMode !== "hub") {
+		return;
+	}
+	if (options.hub?.endpoint?.trim()) {
+		return;
+	}
+	prewarmDetachedHubServer(
+		options.hub?.workspaceRoot?.trim() ||
+			options.hub?.cwd?.trim() ||
+			process.cwd(),
+	);
+}
+
+async function reconcileDeadSessionsIfSupported(
+	backend: SessionBackend,
+): Promise<void> {
+	const service = backend as SessionBackend & {
+		reconcileDeadSessions?: (limit?: number) => Promise<number>;
+	};
+	await service.reconcileDeadSessions?.().catch(() => {});
+}
+
+function createLocalBackend(options: ClineCoreOptions): SessionBackend {
+	try {
+		const store = new SqliteSessionStore();
+		store.init();
+		return new CoreSessionService(store, {
+			messagesArtifactUploader: options.messagesArtifactUploader,
+			logger: options.logger,
+		});
+	} catch (error) {
+		// Fallback to file-based session service if SQLite is unavailable.
+		options.telemetry?.capture({
+			event: "session_backend_fallback",
+			properties: {
+				requestedBackend: "sqlite",
+				fallbackBackend: "file",
+			},
+		});
+		captureSdkError(options.telemetry, {
+			component: "core",
+			operation: "session_backend.sqlite_init",
+			error,
+			severity: "warn",
+			handled: true,
+			context: {
+				requestedBackend: "sqlite",
+				fallbackBackend: "file",
+			},
+		});
+		return new FileSessionService(undefined, {
+			messagesArtifactUploader: options.messagesArtifactUploader,
+			logger: options.logger,
+		});
+	}
+}
+
+function createLocalRuntimeHost(
+	options: ClineCoreOptions,
+	distinctId: string,
+	backend?: SessionBackend,
+): LocalRuntimeHost {
+	return new LocalRuntimeHost({
+		sessionService:
+			backend ?? options.sessionService ?? createLocalBackend(options),
+		capabilities: options.capabilities,
+		telemetry: options.telemetry,
+		toolPolicies: options.toolPolicies,
+		distinctId,
+		fetch: options.fetch,
+	});
+}
+
+export async function resolveSessionBackend(
+	options: ClineCoreOptions,
+): Promise<SessionBackend> {
+	if (cachedBackend) {
+		return cachedBackend;
+	}
+	if (backendInitPromise) {
+		return await backendInitPromise;
+	}
+
+	backendInitPromise = (async () => {
+		cachedBackend = createLocalBackend(options);
+		await reconcileDeadSessionsIfSupported(cachedBackend);
+		return cachedBackend;
+	})().finally(() => {
+		backendInitPromise = undefined;
+	});
+
+	return await backendInitPromise;
+}
+
+export async function createRuntimeHost(
+	options: ClineCoreOptions,
+): Promise<RuntimeHost> {
+	const distinctId = resolveCoreDistinctId(options.distinctId);
+	options.telemetry?.setDistinctId(distinctId);
+	const configuredMode = resolveConfiguredBackendMode(options);
+	prewarmLocalHubIfNeeded(configuredMode, options);
+	if (configuredMode === "remote") {
+		const remoteEndpoint = options.remote?.endpoint?.trim();
+		if (!remoteEndpoint) {
+			throw new Error(
+				"Remote runtime mode requires `remote.endpoint` to be configured.",
+			);
+		}
+		options.logger?.log("Using remote runtime host", {
+			endpoint: remoteEndpoint,
+		});
+		return new RemoteRuntimeHost({
+			endpoint: remoteEndpoint,
+			authToken: options.remote?.authToken,
+			clientType: options.remote?.clientType,
+			displayName: options.remote?.displayName,
+			workspaceRoot: options.remote?.workspaceRoot,
+			cwd: options.remote?.cwd,
+			capabilities: options.capabilities,
+		});
+	}
+	if (configuredMode === "hub") {
+		const explicitEndpoint = options.hub?.endpoint?.trim();
+		const hubUrl =
+			explicitEndpoint ||
+			(await ensureCompatibleLocalHubUrl({
+				strategy: options.hub?.strategy ?? "require-hub",
+				workspaceRoot: options.hub?.workspaceRoot,
+				cwd: options.hub?.cwd,
+			}));
+		if (!hubUrl) {
+			throw new Error("No compatible hub runtime is available.");
+		}
+		options.logger?.log("Using hub runtime host", {
+			url: hubUrl,
+			explicitEndpoint: explicitEndpoint || undefined,
+		});
+		return new HubRuntimeHost(
+			{
+				url: hubUrl,
+				authToken: options.hub?.authToken,
+				clientType: options.hub?.clientType,
+				displayName: options.hub?.displayName,
+				capabilities: options.capabilities,
+				telemetry: options.telemetry,
+			},
+			{
+				workspaceRoot: options.hub?.workspaceRoot,
+				cwd: options.hub?.cwd,
+			},
+		);
+	}
+	if (configuredMode === "auto") {
+		const hubUrl = await resolveCompatibleLocalHubUrl({
+			endpoint: options.hub?.endpoint,
+			strategy: options.hub?.strategy ?? "prefer-hub",
+			workspaceRoot: options.hub?.workspaceRoot,
+			cwd: options.hub?.cwd,
+		});
+		if (hubUrl) {
+			options.logger?.log("Using discovered local hub runtime host", {
+				url: hubUrl,
+			});
+			const host = new HubRuntimeHost(
+				{
+					url: hubUrl,
+					authToken: options.hub?.authToken,
+					clientType: options.hub?.clientType,
+					displayName: options.hub?.displayName,
+					capabilities: options.capabilities,
+					telemetry: options.telemetry,
+				},
+				{
+					workspaceRoot: options.hub?.workspaceRoot,
+					cwd: options.hub?.cwd,
+				},
+			);
+			try {
+				await host.connect();
+				return host;
+			} catch (error) {
+				options.logger?.log("Falling back to local runtime host", {
+					reason: "hub_connect_failed",
+					severity: "warn",
+					error,
+				});
+				captureSdkError(options.telemetry, {
+					component: "core",
+					operation: "runtime_host.hub_connect",
+					error,
+					severity: "warn",
+					handled: true,
+					context: {
+						backendMode: "auto",
+						fallbackBackend: "local",
+					},
+				});
+			}
+		}
+		options.logger?.log("Falling back to local runtime host", {
+			reason: "compatible_hub_unavailable",
+			severity: "warn",
+		});
+		return createLocalRuntimeHost(options, distinctId);
+	}
+	return createLocalRuntimeHost(options, distinctId);
+}
diff --git a/sdk/packages/core/src/runtime/host/local-runtime-host.e2e.test.ts b/sdk/packages/core/src/runtime/host/local-runtime-host.e2e.test.ts
new file mode 100644
index 0000000..9bb8225
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local-runtime-host.e2e.test.ts
@@ -0,0 +1,576 @@
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult } from "@cline/shared";
+import { setClineDir, setHomeDir } from "@cline/shared/storage";
+import { nanoid } from "nanoid";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionRow } from "../../session/models/session-row";
+import type { RootSessionArtifacts } from "../../session/services/session-service";
+import type { SessionSource, SessionStatus } from "../../types/common";
+import { LocalRuntimeHost as RuntimeHostUnderTest } from "./local-runtime-host";
+import { splitCoreSessionConfig } from "./runtime-host";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function createResult(overrides: Partial<AgentResult> = {}): AgentResult {
+	return {
+		text: "ok",
+		iterations: 1,
+		finishReason: "completed",
+		usage: {
+			inputTokens: 1,
+			outputTokens: 2,
+			totalCost: 0,
+		},
+		messages: [],
+		toolCalls: [],
+		durationMs: 1,
+		model: {
+			id: "mock-model",
+			provider: "mock-provider",
+		},
+		startedAt: new Date("2026-01-01T00:00:00.000Z"),
+		endedAt: new Date("2026-01-01T00:00:01.000Z"),
+		...overrides,
+	};
+}
+
+class LocalFileSessionService {
+	private readonly rows = new Map<string, SessionRow>();
+
+	constructor(private readonly sessionsDir: string) {}
+
+	ensureSessionsDir(): string {
+		mkdirSync(this.sessionsDir, { recursive: true });
+		return this.sessionsDir;
+	}
+
+	createRootSessionWithArtifacts(input: {
+		sessionId: string;
+		source: SessionSource;
+		pid: number;
+		interactive: boolean;
+		provider: string;
+		model: string;
+		cwd: string;
+		workspaceRoot: string;
+		teamName?: string;
+		enableTools: boolean;
+		enableSpawn: boolean;
+		enableTeams: boolean;
+		prompt?: string;
+		startedAt?: string;
+	}): RootSessionArtifacts {
+		const startedAt = input.startedAt ?? nowIso();
+		const sessionId = input.sessionId.trim() || `${Date.now()}_${nanoid(5)}`;
+		const sessionPath = join(this.sessionsDir, sessionId);
+		mkdirSync(sessionPath, { recursive: true });
+
+		const manifestPath = join(sessionPath, `${sessionId}.json`);
+		const messagesPath = join(sessionPath, `${sessionId}.messages.json`);
+		const prompt = input.prompt?.trim() || undefined;
+		const manifest: SessionManifest = {
+			version: 1,
+			session_id: sessionId,
+			source: input.source,
+			pid: input.pid,
+			started_at: startedAt,
+			status: "running",
+			interactive: input.interactive,
+			provider: input.provider,
+			model: input.model,
+			cwd: input.cwd,
+			workspace_root: input.workspaceRoot,
+			team_name: input.teamName,
+			enable_tools: input.enableTools,
+			enable_spawn: input.enableSpawn,
+			enable_teams: input.enableTeams,
+			prompt,
+			messages_path: messagesPath,
+		};
+		writeFileSync(
+			manifestPath,
+			`${JSON.stringify(manifest, null, 2)}\n`,
+			"utf8",
+		);
+		writeFileSync(
+			messagesPath,
+			`${JSON.stringify({ version: 1, updated_at: startedAt, messages: [] }, null, 2)}\n`,
+			"utf8",
+		);
+
+		this.rows.set(sessionId, {
+			sessionId,
+			source: input.source,
+			pid: input.pid,
+			startedAt,
+			endedAt: null,
+			exitCode: null,
+			status: "running",
+			statusLock: 0,
+			interactive: input.interactive,
+			provider: input.provider,
+			model: input.model,
+			cwd: input.cwd,
+			workspaceRoot: input.workspaceRoot,
+			teamName: input.teamName ?? null,
+			enableTools: input.enableTools,
+			enableSpawn: input.enableSpawn,
+			enableTeams: input.enableTeams,
+			parentSessionId: null,
+			parentAgentId: null,
+			agentId: null,
+			conversationId: null,
+			isSubagent: false,
+			prompt: prompt ?? null,
+			hookPath: "",
+			messagesPath,
+			updatedAt: startedAt,
+		});
+
+		return {
+			manifestPath,
+			messagesPath,
+			manifest,
+		};
+	}
+
+	persistSessionMessages(
+		sessionId: string,
+		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
+	): void {
+		const row = this.rows.get(sessionId);
+		if (!row?.messagesPath) {
+			throw new Error(`session not found: ${sessionId}`);
+		}
+		const payload: {
+			version: number;
+			updated_at: string;
+			systemPrompt?: string;
+			messages: LlmsProviders.Message[];
+		} = { version: 1, updated_at: nowIso(), messages };
+		if (systemPrompt !== undefined && systemPrompt !== "") {
+			payload.systemPrompt = systemPrompt;
+		}
+		writeFileSync(
+			row.messagesPath,
+			`${JSON.stringify(payload, null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	updateSessionStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): { updated: boolean; endedAt?: string } {
+		const row = this.rows.get(sessionId);
+		if (!row) {
+			return { updated: false };
+		}
+		const endedAt = nowIso();
+		row.status = status;
+		row.endedAt = endedAt;
+		row.exitCode = typeof exitCode === "number" ? exitCode : null;
+		row.updatedAt = endedAt;
+		row.statusLock = row.statusLock + 1;
+		return { updated: true, endedAt };
+	}
+
+	writeSessionManifest(manifestPath: string, manifest: SessionManifest): void {
+		writeFileSync(
+			manifestPath,
+			`${JSON.stringify(manifest, null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	listSessions(limit = 200): SessionRow[] {
+		return Array.from(this.rows.values()).slice(0, limit);
+	}
+
+	deleteSession(sessionId: string): { deleted: boolean } {
+		const row = this.rows.get(sessionId);
+		if (!row) {
+			return { deleted: false };
+		}
+		this.rows.delete(sessionId);
+		unlinkSync(row.messagesPath ?? "");
+		unlinkSync(join(this.sessionsDir, sessionId, `${sessionId}.json`));
+		return { deleted: true };
+	}
+}
+
+describe("LocalRuntimeHost e2e", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+	const tempDirs: string[] = [];
+	let isolatedHomeDir = "";
+
+	beforeEach(() => {
+		isolatedHomeDir = mkdtempSync(join(tmpdir(), "core-session-home-"));
+		process.env.HOME = isolatedHomeDir;
+		process.env.CLINE_DIR = join(isolatedHomeDir, ".cline");
+		setHomeDir(isolatedHomeDir);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		process.env.HOME = envSnapshot.HOME;
+		process.env.CLINE_DIR = envSnapshot.CLINE_DIR;
+		setHomeDir(envSnapshot.HOME ?? "~");
+		setClineDir(envSnapshot.CLINE_DIR ?? join("~", ".cline"));
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+		rmSync(isolatedHomeDir, { recursive: true, force: true });
+	});
+
+	it("runs an interactive lifecycle with real artifact files", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "core-e2e-sessions-"));
+		tempDirs.push(sessionsDir);
+
+		const sessionService = new LocalFileSessionService(sessionsDir);
+		const runtimeShutdown = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: runtimeShutdown,
+			}),
+		};
+
+		let messages: LlmsProviders.Message[] = [];
+		let turn = 0;
+		const run = vi.fn(async (prompt: string) => {
+			turn += 1;
+			messages = [
+				...messages,
+				{
+					role: "user",
+					content: [{ type: "text", text: prompt }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: `reply:${turn}:${prompt}` }],
+				},
+			] as LlmsProviders.Message[];
+			return createResult({
+				text: `reply:${turn}:${prompt}`,
+				messages: [...messages],
+			});
+		});
+		const continueFn = vi.fn(async (prompt: string) => {
+			turn += 1;
+			messages = [
+				...messages,
+				{
+					role: "user",
+					content: [{ type: "text", text: prompt }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: `reply:${turn}:${prompt}` }],
+				},
+			] as LlmsProviders.Message[];
+			return createResult({
+				text: `reply:${turn}:${prompt}`,
+				messages: [...messages],
+			});
+		});
+		const agentShutdown = vi.fn().mockResolvedValue(undefined);
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId: `test-${nanoid(5)}`,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-e2e-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-e2e-1"),
+					restore: vi.fn((baseline: LlmsProviders.Message[]) => {
+						messages = [...baseline];
+					}),
+					updateConnection: vi.fn(),
+					shutdown: agentShutdown,
+					getMessages: vi.fn(() => [...messages]),
+					messages: [],
+				}) as never,
+		});
+
+		const started = await manager.startSession({
+			interactive: true,
+			...splitCoreSessionConfig({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "test-key",
+				cwd: sessionsDir,
+				systemPrompt: "You are a test agent",
+				mode: "act",
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			}),
+		});
+
+		expect(started.sessionId.length).toBeGreaterThan(0);
+		expect(existsSync(started.manifestPath)).toBe(false);
+		expect(existsSync(started.messagesPath)).toBe(false);
+
+		const first = await manager.runTurn({
+			sessionId: started.sessionId,
+			prompt: "first prompt",
+		});
+		const second = await manager.runTurn({
+			sessionId: started.sessionId,
+			prompt: "second prompt",
+		});
+		expect(existsSync(started.manifestPath)).toBe(true);
+		expect(existsSync(started.messagesPath)).toBe(true);
+
+		expect(first?.text).toContain("first prompt");
+		expect(second?.text).toContain("second prompt");
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(continueFn).toHaveBeenCalledTimes(1);
+
+		const persistedMessages = await manager.readSessionMessages(
+			started.sessionId,
+		);
+		expect(persistedMessages.length).toBeGreaterThan(0);
+		expect(JSON.stringify(persistedMessages)).toContain("second prompt");
+
+		const listed = await manager.listSessions(20);
+		expect(
+			listed.some((session) => session.sessionId === started.sessionId),
+		).toBe(true);
+
+		await manager.stopSession(started.sessionId);
+		const stopped = await manager.getSession(started.sessionId);
+		expect(stopped?.status).toBe("completed");
+		expect(stopped?.exitCode).toBe(0);
+		expect(agentShutdown).toHaveBeenCalledTimes(1);
+		expect(runtimeShutdown).toHaveBeenCalledTimes(1);
+		const parsedManifest = JSON.parse(
+			readFileSync(started.manifestPath, "utf8"),
+		) as SessionManifest;
+		expect(parsedManifest.status).toBe("completed");
+
+		const deleted = await manager.deleteSession(started.sessionId);
+		expect(deleted).toBe(true);
+		expect(await manager.getSession(started.sessionId)).toBeUndefined();
+		expect(existsSync(started.manifestPath)).toBe(false);
+		expect(existsSync(started.messagesPath)).toBe(false);
+	});
+
+	it("persists replayable assistant content blocks with turn metadata in messages artifacts", async () => {
+		const sessionsDir = mkdtempSync(
+			join(tmpdir(), "core-e2e-messages-contract-"),
+		);
+		tempDirs.push(sessionsDir);
+
+		const sessionService = new LocalFileSessionService(sessionsDir);
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+
+		const assistantToolUseId = "tool-call-1";
+		const run = vi.fn(async (prompt: string) =>
+			createResult({
+				text: "done",
+				usage: {
+					inputTokens: 21,
+					outputTokens: 8,
+					cacheReadTokens: 3,
+					cacheWriteTokens: 1,
+					totalCost: 0.13,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+					info: {
+						id: "claude-sonnet-4-6",
+						family: "claude-sonnet-4",
+					},
+				},
+				messages: [
+					{
+						role: "user",
+						content: [{ type: "text", text: prompt }],
+					},
+					{
+						role: "assistant",
+						content: [
+							{ type: "thinking", thinking: "Need to inspect files first." },
+							{
+								type: "tool_use",
+								id: assistantToolUseId,
+								name: "read_files",
+								input: { path: "/tmp/project/README.md" },
+							},
+						],
+						// Per-turn metrics stamped by agent.ts at append time (turn 1).
+						metrics: {
+							inputTokens: 15,
+							outputTokens: 6,
+							cacheReadTokens: 2,
+							cacheWriteTokens: 1,
+							cost: 0.07,
+						},
+					},
+					{
+						role: "user",
+						content: [
+							{
+								type: "tool_result",
+								tool_use_id: assistantToolUseId,
+								name: "tool",
+								content: "README content",
+							},
+						],
+					},
+					{
+						role: "assistant",
+						content: [{ type: "text", text: "I found the relevant section." }],
+						// Per-turn metrics stamped by agent.ts at append time (turn 2).
+						metrics: {
+							inputTokens: 21,
+							outputTokens: 8,
+							cacheReadTokens: 3,
+							cacheWriteTokens: 1,
+							cost: 0.13,
+						},
+					},
+				] satisfies LlmsProviders.MessageWithMetadata[] as LlmsProviders.Message[],
+			}),
+		);
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId: `test-${nanoid(5)}`,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-e2e-artifacts"),
+					getConversationId: vi.fn().mockReturnValue("conv-e2e-artifacts"),
+					restore: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					updateConnection: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		const started = await manager.startSession({
+			interactive: false,
+			...splitCoreSessionConfig({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "test-key",
+				cwd: sessionsDir,
+				systemPrompt: "You are a test agent",
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			}),
+		});
+
+		await manager.runTurn({
+			sessionId: started.sessionId,
+			prompt: "Inspect the README",
+		});
+
+		const payload = JSON.parse(readFileSync(started.messagesPath, "utf8")) as {
+			messages?: Array<Record<string, unknown>>;
+		};
+		const persisted = payload.messages ?? [];
+		expect(persisted).toHaveLength(4);
+
+		const firstAssistant = persisted[1] as {
+			role: string;
+			content: Array<{ type: string }>;
+			modelInfo?: { id?: string; provider?: string };
+			metrics?: Record<string, unknown>;
+		};
+		const toolResultUser = persisted[2] as {
+			role: string;
+			content: Array<{ type: string; tool_use_id?: string }>;
+		};
+		const terminalAssistant = persisted[3] as {
+			role: string;
+			content: Array<{ type: string; text?: string }>;
+			modelInfo?: { id?: string; provider?: string };
+			metrics?: {
+				inputTokens?: number;
+				outputTokens?: number;
+				cacheReadTokens?: number;
+				cacheWriteTokens?: number;
+				cost?: number;
+			};
+		};
+
+		expect(firstAssistant.role).toBe("assistant");
+		expect(firstAssistant.content[0]?.type).toBe("thinking");
+		expect(firstAssistant.content[1]?.type).toBe("tool_use");
+		expect(firstAssistant.modelInfo).toMatchObject({
+			id: "claude-sonnet-4-6",
+			provider: "anthropic",
+		});
+		// Per-turn metrics are stamped by agent.ts at append time and
+		// preserved by withLatestAssistantTurnMetadata. Each assistant message
+		// should carry its own turn's usage, not the session total.
+		expect(firstAssistant.metrics).toMatchObject({
+			inputTokens: 15,
+			outputTokens: 6,
+			cacheReadTokens: 2,
+			cacheWriteTokens: 1,
+			cost: 0.07,
+		});
+
+		expect(toolResultUser.role).toBe("user");
+		expect(toolResultUser.content[0]?.type).toBe("tool_result");
+		expect(toolResultUser.content[0]?.tool_use_id).toBe(assistantToolUseId);
+
+		expect(terminalAssistant.role).toBe("assistant");
+		expect(terminalAssistant.content[0]?.type).toBe("text");
+		expect(terminalAssistant.modelInfo).toMatchObject({
+			id: "claude-sonnet-4-6",
+			provider: "anthropic",
+		});
+		expect(terminalAssistant.metrics).toMatchObject({
+			inputTokens: 21,
+			outputTokens: 8,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 1,
+			cost: 0.13,
+		});
+	});
+});
diff --git a/sdk/packages/core/src/runtime/host/local-runtime-host.test.ts b/sdk/packages/core/src/runtime/host/local-runtime-host.test.ts
new file mode 100644
index 0000000..6719593
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local-runtime-host.test.ts
@@ -0,0 +1,5745 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { MessageWithMetadata } from "@cline/llms";
+import type {
+	AgentConfig,
+	AgentEvent,
+	AgentExtensionAutomationContext,
+	AgentResult,
+	AgentRuntimeEvent,
+	BasicLogger,
+} from "@cline/shared";
+import { setClineDir, setHomeDir } from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { TelemetryService } from "../../services/telemetry/TelemetryService";
+import { createSessionCompactionState } from "../../session/models/session-compaction";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import { SessionSource } from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import { LocalRuntimeHost as RuntimeHostUnderTest } from "./local-runtime-host";
+import { type StartSessionInput, splitCoreSessionConfig } from "./runtime-host";
+
+const distinctId = "test-machine-id";
+
+function createResult(overrides: Partial<AgentResult> = {}): AgentResult {
+	return {
+		text: "ok",
+		iterations: 1,
+		finishReason: "completed",
+		usage: {
+			inputTokens: 1,
+			outputTokens: 2,
+			totalCost: 0,
+		},
+		messages: [],
+		toolCalls: [],
+		durationMs: 1,
+		model: {
+			id: "mock-model",
+			provider: "mock-provider",
+		},
+		startedAt: new Date("2026-01-01T00:00:00.000Z"),
+		endedAt: new Date("2026-01-01T00:00:01.000Z"),
+		...overrides,
+	};
+}
+
+function createManifest(sessionId: string): SessionManifest {
+	return {
+		version: 1,
+		session_id: sessionId,
+		source: SessionSource.CLI,
+		pid: process.pid,
+		started_at: "2026-01-01T00:00:00.000Z",
+		status: "running",
+		interactive: false,
+		provider: "mock-provider",
+		model: "mock-model",
+		cwd: "/tmp/project",
+		workspace_root: "/tmp/project",
+		enable_tools: true,
+		enable_spawn: true,
+		enable_teams: true,
+		prompt: "hello",
+		messages_path: "/tmp/messages.json",
+	};
+}
+
+type PluginEventTestHarness = {
+	handlePluginEvent: (
+		rootSessionId: string,
+		event: { name: string; payload?: unknown },
+		fallbackAutomation?: AgentExtensionAutomationContext,
+	) => Promise<void>;
+	getPendingPrompts: (
+		sessionId: string,
+	) => Array<{ prompt: string; delivery: "queue" | "steer" }>;
+};
+
+function createPluginEventHarness(
+	manager: RuntimeHostUnderTest,
+): PluginEventTestHarness {
+	const target = manager as object;
+	return {
+		handlePluginEvent: async (rootSessionId, event, fallbackAutomation) => {
+			const handler = Reflect.get(target, "handlePluginEvent");
+			if (typeof handler !== "function") {
+				throw new Error("handlePluginEvent test hook unavailable");
+			}
+			await Reflect.apply(
+				handler as (
+					rootSessionId: string,
+					event: { name: string; payload?: unknown },
+					fallbackAutomation?: AgentExtensionAutomationContext,
+				) => Promise<void>,
+				target,
+				[rootSessionId, event, fallbackAutomation],
+			);
+		},
+		getPendingPrompts: (sessionId) => {
+			const getter = Reflect.get(target, "getSessionOrThrow");
+			if (typeof getter !== "function") {
+				throw new Error("getSessionOrThrow test hook unavailable");
+			}
+			const session = Reflect.apply(
+				getter as (sessionId: string) => {
+					pendingPrompts: Array<{
+						id: string;
+						prompt: string;
+						delivery: "queue" | "steer";
+						userFiles?: unknown;
+						userImages?: unknown;
+					}>;
+				},
+				target,
+				[sessionId],
+			);
+			return session.pendingPrompts.map(({ prompt, delivery }) => ({
+				prompt,
+				delivery,
+			}));
+		},
+	};
+}
+
+function createConfig(
+	overrides: Partial<CoreSessionConfig> = {},
+): CoreSessionConfig {
+	return {
+		providerId: "mock-provider",
+		modelId: "mock-model",
+		cwd: "/tmp/project",
+		systemPrompt: "You are a test agent",
+		mode: "act",
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
+		...overrides,
+	};
+}
+
+function normalizeStartInput(
+	input: Omit<StartSessionInput, "config" | "localRuntime"> & {
+		config: CoreSessionConfig;
+	},
+): StartSessionInput {
+	const split = splitCoreSessionConfig(input.config);
+	return {
+		...input,
+		...split,
+	};
+}
+
+describe("LocalRuntimeHost", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+	let isolatedHomeDir = "";
+
+	beforeEach(() => {
+		isolatedHomeDir = mkdtempSync(join(tmpdir(), "core-session-home-"));
+		process.env.HOME = isolatedHomeDir;
+		process.env.CLINE_DIR = join(isolatedHomeDir, ".cline");
+		setHomeDir(isolatedHomeDir);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		process.env.HOME = envSnapshot.HOME;
+		process.env.CLINE_DIR = envSnapshot.CLINE_DIR;
+		setHomeDir(envSnapshot.HOME ?? "~");
+		setClineDir(envSnapshot.CLINE_DIR ?? join("~", ".cline"));
+		rmSync(isolatedHomeDir, { recursive: true, force: true });
+	});
+
+	it("emits session lifecycle telemetry when configured", async () => {
+		const sessionId = "sess-telemetry";
+		const manifest = createManifest(sessionId);
+		const adapter = {
+			name: "test",
+			emit: vi.fn(),
+			emitRequired: vi.fn(),
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			isEnabled: vi.fn(() => true),
+			flush: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		};
+		const telemetry = new TelemetryService({
+			adapters: [adapter],
+			distinctId: distinctId,
+		});
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				teamRuntime: {
+					getTeamId: vi.fn().mockReturnValue("team_test-team"),
+					getTeamName: vi.fn().mockReturnValue("test-team"),
+				},
+				teamRestoredFromPersistence: false,
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+			telemetry,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ telemetry, sessionId }),
+				prompt: "hello",
+			}),
+		);
+
+		// `session.started` is emitted from `ClineCore.start` (see
+		// `ClineCore.test.ts`), not from `LocalRuntimeHost`, so that the
+		// signal fires for every backend. We assert that it is NOT emitted
+		// here and only transport-scoped events remain.
+		expect(adapter.emit).not.toHaveBeenCalledWith(
+			"session.started",
+			expect.anything(),
+		);
+		expect(adapter.emit).toHaveBeenCalledWith(
+			"task.agent_created",
+			expect.objectContaining({
+				ulid: sessionId,
+				agentId: "agent-root-1",
+				agentKind: "team_lead",
+				conversationId: "conv-root-1",
+				teamRole: "lead",
+				distinct_id: distinctId,
+			}),
+		);
+		expect(adapter.emit).toHaveBeenCalledWith(
+			"task.agent_team_created",
+			expect.objectContaining({
+				ulid: sessionId,
+				leadAgentId: "agent-root-1",
+				restoredFromPersistence: false,
+				distinct_id: distinctId,
+			}),
+		);
+	});
+
+	it("resolves OAuth credentials before creating the agent", async () => {
+		const sessionId = "sess-oauth-bootstrap";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({ tools: [], shutdown: vi.fn() }),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const createAgent = vi.fn(() => agent as never);
+		const oauthTokenManager = {
+			resolveProviderApiKey: vi.fn().mockResolvedValue({
+				apiKey: "workos:resolved-token",
+				refreshed: false,
+			}),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent,
+			oauthTokenManager: oauthTokenManager as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					providerId: "cline-pass",
+					modelId: "cline-pass/glm-5.2",
+					apiKey: undefined,
+				}),
+				prompt: "hello",
+			}),
+		);
+
+		expect(oauthTokenManager.resolveProviderApiKey).toHaveBeenCalledWith({
+			providerId: "cline-pass",
+		});
+		expect(createAgent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "cline-pass",
+				apiKey: "workos:resolved-token",
+			}),
+		);
+	});
+
+	it("persists provider/model connection updates to the session manifest", async () => {
+		const sessionId = "sess-connection-manifest-update";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({ tools: [], shutdown: vi.fn() }),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			updateConnection: vi.fn(),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const createAgent = vi.fn(() => agent as never);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: true,
+			}),
+		);
+		sessionService.writeSessionManifest.mockClear();
+
+		// A disk-only writer (compaction path, rename) updated the manifest
+		// behind the in-memory copy's back; the connection update must re-read
+		// and preserve it instead of clobbering it with the stale copy.
+		const diskManifest = {
+			...manifest,
+			compaction_path: "/tmp/compaction.json",
+			title: "renamed session",
+		};
+		const readSessionManifest = vi.fn().mockResolvedValue(diskManifest);
+		(sessionService as Record<string, unknown>).readSessionManifest =
+			readSessionManifest;
+
+		await manager.updateSessionConnection(sessionId, {
+			providerId: "openai",
+			modelId: "codex-test",
+		});
+
+		expect(sessionService.writeSessionManifest).toHaveBeenCalledWith(
+			"/tmp/manifest.json",
+			expect.objectContaining({
+				session_id: sessionId,
+				provider: "openai",
+				model: "codex-test",
+				compaction_path: "/tmp/compaction.json",
+				title: "renamed session",
+			}),
+		);
+
+		sessionService.writeSessionManifest.mockClear();
+		await manager.updateSessionConnection(sessionId, { thinking: true });
+		expect(sessionService.writeSessionManifest).not.toHaveBeenCalled();
+	});
+
+	it("persists thinking budget token connection updates", async () => {
+		const sessionId = "sess-thinking-budget-update";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({ tools: [], shutdown: vi.fn() }),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			updateConnection: vi.fn(),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const createAgent = vi.fn(() => agent as never);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					thinking: true,
+					reasoningEffort: "high",
+					thinkingBudgetTokens: 1024,
+				}),
+				prompt: "hello",
+				interactive: true,
+			}),
+		);
+
+		expect(createAgent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				thinking: true,
+				reasoningEffort: "high",
+				thinkingBudgetTokens: 1024,
+			}),
+		);
+
+		await manager.updateSessionConnection(sessionId, {
+			thinkingBudgetTokens: 2048,
+		});
+
+		const getSessionOrThrow = Reflect.get(
+			manager as object,
+			"getSessionOrThrow",
+		) as (sessionId: string) => { config: CoreSessionConfig };
+		const session = Reflect.apply(getSessionOrThrow, manager, [sessionId]) as {
+			config: CoreSessionConfig;
+		};
+		expect(session.config.thinking).toBe(true);
+		expect(session.config.thinkingBudgetTokens).toBe(2048);
+		expect(agent.updateConnection).toHaveBeenLastCalledWith({
+			thinking: true,
+			thinkingBudgetTokens: 2048,
+		});
+
+		await manager.updateSessionConnection(sessionId, {
+			thinking: false,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 4096,
+		});
+
+		expect(session.config.thinking).toBe(false);
+		expect(session.config.reasoningEffort).toBeUndefined();
+		expect(session.config.thinkingBudgetTokens).toBeUndefined();
+		expect(agent.updateConnection).toHaveBeenLastCalledWith({
+			thinking: false,
+			reasoningEffort: undefined,
+			thinkingBudgetTokens: undefined,
+		});
+
+		await manager.updateSessionConnection(sessionId, {
+			thinking: null,
+			reasoningEffort: null,
+			thinkingBudgetTokens: null,
+		});
+
+		expect(session.config.thinking).toBeUndefined();
+		expect(session.config.reasoningEffort).toBeUndefined();
+		expect(session.config.thinkingBudgetTokens).toBeUndefined();
+	});
+
+	it("captures active session lookup misses as handled telemetry", async () => {
+		const adapter = {
+			name: "test",
+			emit: vi.fn(),
+			emitRequired: vi.fn(),
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			isEnabled: vi.fn(() => true),
+			flush: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		};
+		const telemetry = new TelemetryService({ adapters: [adapter] });
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: {} as never,
+			telemetry,
+		});
+
+		await expect(
+			manager.runTurn({ sessionId: "missing-session", prompt: "hi" }),
+		).rejects.toThrow("session not found: missing-session");
+
+		expect(adapter.emit).toHaveBeenCalledWith(
+			"sdk.error",
+			expect.objectContaining({
+				component: "core",
+				operation: "session.active_lookup",
+				severity: "warn",
+				handled: true,
+				sessionId: "missing-session",
+				activeSessionCount: 0,
+				error_message: "session not found: missing-session",
+			}),
+		);
+	});
+
+	it("passes app runtime capabilities into the local execution path", async () => {
+		const sessionId = "sess-local-capabilities";
+		const manifest = createManifest(sessionId);
+		const askQuestion = vi.fn(async () => "Use shared handler");
+		const requestToolApproval = vi.fn(async () => ({ approved: true }));
+		const appCapabilities = {
+			toolExecutors: { askQuestion },
+			requestToolApproval,
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+					manifestPath: "/tmp/manifest.json",
+					messagesPath: "/tmp/messages.json",
+					manifest,
+				}),
+				persistSessionMessages: vi.fn(),
+				updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+				writeSessionManifest: vi.fn(),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			} as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: (config) => {
+				expect(typeof config.requestToolApproval).toBe("function");
+				return agent as never;
+			},
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				capabilities: appCapabilities,
+			}),
+		);
+
+		expect(runtimeBuilder.build).toHaveBeenCalledWith(
+			expect.objectContaining({
+				toolExecutors: expect.objectContaining({ askQuestion }),
+			}),
+		);
+		expect(
+			vi.mocked(runtimeBuilder.build).mock.calls[0]?.[0].toolExecutors
+				?.askQuestion,
+		).toBe(askQuestion);
+		expect(agent.run).toHaveBeenCalledWith(
+			expect.stringContaining("hello"),
+			undefined,
+			undefined,
+		);
+	});
+
+	it("marks interactive sessions pending while awaiting tool approval", async () => {
+		const sessionId = "sess-pending-approval-status";
+		const manifest = createManifest(sessionId);
+		let resolveApproval:
+			| ((result: { approved: boolean; reason?: string }) => void)
+			| undefined;
+		const requestToolApproval = vi.fn(
+			() =>
+				new Promise<{ approved: boolean; reason?: string }>((resolve) => {
+					resolveApproval = resolve;
+				}),
+		);
+		let capturedConfig: AgentConfig | undefined;
+		const updateSessionStatus = vi.fn().mockResolvedValue({ updated: true });
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn(async () => {
+				const approval = await capturedConfig?.requestToolApproval?.({
+					sessionId,
+					agentId: "agent-root-1",
+					conversationId: "conv-root-1",
+					iteration: 1,
+					toolCallId: "call-approval-1",
+					toolName: "edit_file",
+					input: { path: "README.md" },
+					policy: { autoApprove: false },
+				});
+				expect(approval?.approved).toBe(true);
+				return createResult();
+			}),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+					manifestPath: "/tmp/manifest.json",
+					messagesPath: "/tmp/messages.json",
+					manifest,
+				}),
+				persistSessionMessages: vi.fn(),
+				updateSessionStatus,
+				writeSessionManifest: vi.fn(),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			} as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: (config) => {
+				capturedConfig = config;
+				return agent as never;
+			},
+		});
+		const pendingStatus = new Promise<void>((resolve) => {
+			manager.subscribe((event) => {
+				if (
+					event.type === "status" &&
+					event.payload.sessionId === sessionId &&
+					event.payload.status === "pending"
+				) {
+					resolve();
+				}
+			});
+		});
+
+		const started = manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: true,
+				capabilities: { requestToolApproval },
+			}),
+		);
+		await pendingStatus;
+
+		await expect(manager.getSession(sessionId)).resolves.toMatchObject({
+			sessionId,
+			status: "pending",
+		});
+		resolveApproval?.({ approved: true });
+		await started;
+
+		expect(updateSessionStatus).toHaveBeenNthCalledWith(
+			1,
+			sessionId,
+			"pending",
+			null,
+		);
+		expect(updateSessionStatus).toHaveBeenNthCalledWith(
+			2,
+			sessionId,
+			"running",
+			null,
+		);
+		expect(updateSessionStatus).toHaveBeenNthCalledWith(
+			3,
+			sessionId,
+			"idle",
+			null,
+		);
+		await expect(manager.getSession(sessionId)).resolves.toMatchObject({
+			sessionId,
+			status: "idle",
+		});
+	});
+
+	it("ingests automation events emitted by sandbox plugins during setup", async () => {
+		const sessionId = "sess-plugin-automation-setup";
+		const ingestEvent = vi.fn().mockResolvedValue(undefined);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				listSessions: vi.fn().mockResolvedValue([]),
+			} as never,
+		});
+		const harness = createPluginEventHarness(manager);
+
+		await harness.handlePluginEvent(
+			sessionId,
+			{
+				name: "automation_event",
+				payload: {
+					eventId: "evt_setup_1",
+					eventType: "local.plugin_event",
+					source: "local-plugin",
+					occurredAt: "2026-04-24T10:00:00.000Z",
+				},
+			},
+			{ ingestEvent },
+		);
+
+		expect(ingestEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				eventId: "evt_setup_1",
+				eventType: "local.plugin_event",
+			}),
+		);
+	});
+
+	it("ingests automation events emitted by plugins after session registration", async () => {
+		const sessionId = "sess-plugin-automation-registered";
+		const manifest = createManifest(sessionId);
+		const ingestEvent = vi.fn().mockResolvedValue(undefined);
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+					manifestPath: "/tmp/manifest.json",
+					messagesPath: "/tmp/messages.json",
+					manifest,
+				}),
+				persistSessionMessages: vi.fn(),
+				updateSessionStatus: vi.fn().mockResolvedValue({
+					updated: true,
+					endedAt: "2026-01-01T00:00:05.000Z",
+				}),
+				writeSessionManifest: vi.fn(),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			} as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					extensionContext: { automation: { ingestEvent } },
+				}),
+				prompt: undefined,
+				interactive: true,
+			}),
+		);
+
+		const harness = createPluginEventHarness(manager);
+		await harness.handlePluginEvent(sessionId, {
+			name: "automation_event",
+			payload: {
+				eventId: "evt_registered_1",
+				eventType: "local.plugin_event",
+				source: "local-plugin",
+				occurredAt: "2026-04-24T10:00:00.000Z",
+			},
+		});
+
+		expect(ingestEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				eventId: "evt_registered_1",
+				eventType: "local.plugin_event",
+			}),
+		);
+	});
+
+	it("persists custom session sources without coercing them to builtin values", async () => {
+		const sessionId = "sess-kanban";
+		const manifest = {
+			...createManifest(sessionId),
+			source: "kanban",
+		};
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				teamRuntime: undefined,
+				teamRestoredFromPersistence: false,
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		const started = await manager.startSession(
+			normalizeStartInput({
+				source: "kanban",
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+			}),
+		);
+
+		expect(sessionService.createRootSessionWithArtifacts).toHaveBeenCalledWith(
+			expect.objectContaining({
+				sessionId,
+				source: "kanban",
+			}),
+		);
+		expect(started.manifest.source).toBe("kanban");
+	});
+
+	it("persists initial messages for idle resumed sessions", async () => {
+		const sessionId = "sess-fork-copy";
+		const manifest = createManifest(sessionId);
+		const initialMessages: MessageWithMetadata[] = [
+			{ role: "user" as const, content: "build a thing" },
+			{ role: "assistant" as const, content: "done" },
+		];
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				teamRuntime: undefined,
+				teamRestoredFromPersistence: false,
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue(initialMessages),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+				initialMessages,
+			}),
+		);
+
+		expect(agent.run).not.toHaveBeenCalled();
+		expect(sessionService.createRootSessionWithArtifacts).toHaveBeenCalledTimes(
+			1,
+		);
+		expect(sessionService.persistSessionMessages).toHaveBeenCalledWith(
+			sessionId,
+			initialMessages,
+			"You are a test agent",
+		);
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"completed",
+			0,
+		);
+		await expect(manager.getSession(sessionId)).resolves.toMatchObject({
+			sessionId,
+			status: "completed",
+		});
+	});
+
+	it("reads manifest-only session records and messages", async () => {
+		const sessionId = "manifest-only-session";
+		const messagesPath = join(isolatedHomeDir, "messages.json");
+		const messages = [
+			{ role: "user" as const, content: "from manifest" },
+			{ role: "assistant" as const, content: "loaded" },
+		];
+		writeFileSync(
+			messagesPath,
+			`${JSON.stringify({ version: 1, messages })}\n`,
+			"utf8",
+		);
+		const manifest: SessionManifest = {
+			...createManifest(sessionId),
+			messages_path: messagesPath,
+		};
+		const sessionService = {
+			listSessions: vi.fn().mockResolvedValue([]),
+			readSessionManifest: vi.fn().mockReturnValue(manifest),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+		});
+
+		await expect(manager.getSession(sessionId)).resolves.toMatchObject({
+			sessionId,
+			source: manifest.source,
+			messagesPath,
+		});
+		await expect(manager.readSessionMessages(sessionId)).resolves.toEqual(
+			messages,
+		);
+		expect(sessionService.readSessionManifest).toHaveBeenCalledWith(sessionId);
+	});
+
+	it("marks interactive sessions idle after a completed turn", async () => {
+		const sessionId = "sess-interactive-turn-status";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi
+				.fn()
+				.mockImplementation(async (_sessionId: string, status: string) => ({
+					updated: true,
+					...(status === "running" || status === "idle" || status === "pending"
+						? {}
+						: { endedAt: "2026-01-01T00:00:05.000Z" }),
+				})),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtime = { tools: [], shutdown: vi.fn() };
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue(runtime),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: true,
+			}),
+		);
+
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"idle",
+			null,
+		);
+		await expect(manager.getSession(sessionId)).resolves.toMatchObject({
+			sessionId,
+			status: "idle",
+		});
+		expect(agent.shutdown).not.toHaveBeenCalled();
+		expect(runtime.shutdown).not.toHaveBeenCalled();
+	});
+
+	it("disposes idle interactive sessions without changing status", async () => {
+		const sessionId = "sess-interactive-dispose";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtime = { tools: [], shutdown: vi.fn() };
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue(runtime),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+				initialMessages: [{ role: "user", content: "done already" }],
+			}),
+		);
+		sessionService.updateSessionStatus.mockClear();
+
+		await manager.dispose("test_dispose");
+
+		expect(sessionService.updateSessionStatus).not.toHaveBeenCalled();
+		expect(agent.shutdown).toHaveBeenCalledWith("test_dispose");
+		expect(runtime.shutdown).toHaveBeenCalledWith("test_dispose");
+	});
+
+	it("reuses the persisted team name when resuming a session", async () => {
+		const sessionId = "sess-team-resume";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([
+				{
+					sessionId,
+					source: SessionSource.CLI,
+					pid: process.pid,
+					startedAt: "2026-01-01T00:00:00.000Z",
+					endedAt: null,
+					exitCode: null,
+					status: "running",
+					statusLock: 0,
+					interactive: true,
+					provider: "mock-provider",
+					model: "mock-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					teamName: "persisted-team",
+					enableTools: true,
+					enableSpawn: true,
+					enableTeams: true,
+					parentSessionId: null,
+					parentAgentId: null,
+					agentId: null,
+					conversationId: null,
+					isSubagent: false,
+					prompt: null,
+					metadata: null,
+					messagesPath: "/tmp/messages.json",
+					updatedAt: "2026-01-01T00:00:00.000Z",
+				},
+			]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				teamRuntime: {
+					getTeamId: vi.fn().mockReturnValue("team_persisted-team"),
+					getTeamName: vi.fn().mockReturnValue("persisted-team"),
+				},
+				teamRestoredFromPersistence: true,
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId, teamName: undefined }),
+			}),
+		);
+
+		expect(runtimeBuilder.build).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					sessionId,
+					teamName: "persisted-team",
+				}),
+			}),
+		);
+		expect(
+			sessionService.createRootSessionWithArtifacts,
+		).not.toHaveBeenCalled();
+	});
+
+	it("runs a non-interactive prompt and persists messages/status", async () => {
+		const sessionId = "sess-1";
+		const manifest = createManifest(sessionId);
+		const createRootSessionWithArtifacts = vi.fn().mockResolvedValue({
+			manifestPath: "/tmp/manifest.json",
+			messagesPath: "/tmp/messages.json",
+			manifest,
+		});
+		const persistSessionMessages = vi.fn();
+		const updateSessionStatus = vi.fn().mockResolvedValue({
+			updated: true,
+			endedAt: "2026-01-01T00:00:05.000Z",
+		});
+		const writeSessionManifest = vi.fn();
+		const listSessions = vi.fn().mockResolvedValue([]);
+		const deleteSession = vi.fn().mockResolvedValue({ deleted: true });
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts,
+			persistSessionMessages,
+			updateSessionStatus,
+			writeSessionManifest,
+			listSessions,
+			deleteSession,
+		};
+
+		const shutdown = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown,
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+				],
+			}),
+		);
+		const continueFn = vi.fn();
+		const agent = {
+			run,
+			continue: continueFn,
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		const started = await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+
+		expect(started.sessionId).toBe(sessionId);
+		expect(started.result?.finishReason).toBe("completed");
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(continueFn).not.toHaveBeenCalled();
+		expect(persistSessionMessages).toHaveBeenCalledTimes(1);
+		expect(updateSessionStatus).toHaveBeenCalledWith(sessionId, "completed", 0);
+		expect(writeSessionManifest).toHaveBeenCalledTimes(1);
+		expect(shutdown).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not fail the run when assistant-response disk flush fails", async () => {
+		const sessionId = "sess-assistant-flush";
+		const manifest = createManifest(sessionId);
+		const createRootSessionWithArtifacts = vi.fn().mockResolvedValue({
+			manifestPath: "/tmp/manifest-assistant-flush.json",
+			messagesPath: "/tmp/messages-assistant-flush.json",
+			manifest,
+		});
+		const order: string[] = [];
+		const persistError = new Error("disk full");
+		let persistCallCount = 0;
+		const persistSessionMessages = vi.fn().mockImplementation(() => {
+			order.push("persist");
+			persistCallCount += 1;
+			if (persistCallCount === 1) {
+				return Promise.reject(persistError);
+			}
+			return Promise.resolve();
+		});
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts,
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const messages = [
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "hello" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "ready on disk" }],
+			},
+		];
+		const run = vi.fn(
+			async (
+				_prompt: string,
+				_userImages?: string[],
+				_userFiles?: string[],
+			) => {
+				const assistantEvent: AgentRuntimeEvent = {
+					type: "assistant-message",
+					iteration: 1,
+					finishReason: "stop",
+					message: {
+						id: "msg_assistant",
+						role: "assistant",
+						content: [{ type: "text", text: "ready on disk" }],
+						createdAt: Date.now(),
+					},
+					snapshot: {
+						agentId: "agent-root-1",
+						runId: "run-1",
+						status: "running",
+						iteration: 1,
+						messages: [],
+						pendingToolCalls: [],
+						usage: {
+							inputTokens: 0,
+							outputTokens: 0,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0,
+							totalCost: 0,
+						},
+					},
+				};
+				await capturedConfig?.hooks?.onEvent?.(assistantEvent);
+				order.push("run-return");
+				return createResult({ messages });
+			},
+		);
+		let capturedConfig:
+			| {
+					hooks?: {
+						onEvent?: (event: AgentRuntimeEvent) => void | Promise<void>;
+					};
+			  }
+			| undefined;
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: (config) => {
+				capturedConfig = config;
+				return {
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi
+						.fn()
+						.mockReturnValueOnce([])
+						.mockReturnValue(messages),
+					messages: [],
+				} as never;
+			},
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId, logger }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+
+		expect(persistSessionMessages).toHaveBeenCalledTimes(2);
+		expect(persistSessionMessages).toHaveBeenNthCalledWith(
+			1,
+			sessionId,
+			messages,
+			"You are a test agent",
+		);
+		expect(order).toEqual(["persist", "run-return", "persist"]);
+		expect(logger.error).toHaveBeenCalledWith(
+			"Failed to persist session messages after assistant response",
+			{ sessionId, error: persistError },
+		);
+	});
+
+	it("does not fail a completed run when shutdown cleanup throws", async () => {
+		const sessionId = "sess-cleanup-errors";
+		const manifest = createManifest(sessionId);
+		const createRootSessionWithArtifacts = vi.fn().mockResolvedValue({
+			manifestPath: "/tmp/manifest-cleanup-errors.json",
+			messagesPath: "/tmp/messages-cleanup-errors.json",
+			manifest,
+		});
+		const persistSessionMessages = vi.fn();
+		const updateSessionStatus = vi
+			.fn()
+			.mockRejectedValue(new Error("status write failed"));
+		const writeSessionManifest = vi.fn();
+		const listSessions = vi.fn().mockResolvedValue([]);
+		const deleteSession = vi.fn().mockResolvedValue({ deleted: true });
+		const logger: BasicLogger = { debug: vi.fn(), log: vi.fn() };
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts,
+			persistSessionMessages,
+			updateSessionStatus,
+			writeSessionManifest,
+			listSessions,
+			deleteSession,
+		};
+
+		const shutdown = vi
+			.fn()
+			.mockRejectedValue(new Error("runtime shutdown failed"));
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown,
+				logger,
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockRejectedValue(new Error("agent shutdown failed")),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		const started = await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId, logger }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+
+		expect(started.result?.finishReason).toBe("completed");
+		expect(updateSessionStatus).toHaveBeenCalledWith(sessionId, "completed", 0);
+		// `SessionRuntime.shutdown(reason?, timeoutMs?)` forwards the
+		// reason string into the `session_shutdown` hook payload, so
+		// host-level hook-file handlers can route on it (e.g.
+		// `isAbortReason(ctx.reason)` in `hook-file-hooks.ts`).
+		// The transport-level `session.runtime.shutdown(reason)` on
+		// the next line also receives the same reason.
+		expect(agent.shutdown).toHaveBeenCalledWith("session_complete");
+		expect(shutdown).toHaveBeenCalledWith("session_complete");
+		expect(logger.log).toHaveBeenCalledWith(
+			"Session shutdown cleanup failed",
+			expect.objectContaining({
+				sessionId,
+				stage: "update_status",
+				severity: "warn",
+			}),
+		);
+		expect(logger.log).toHaveBeenCalledWith(
+			"Session shutdown cleanup failed",
+			expect.objectContaining({
+				sessionId,
+				stage: "agent_shutdown",
+				severity: "warn",
+			}),
+		);
+		expect(logger.log).toHaveBeenCalledWith(
+			"Session shutdown cleanup failed",
+			expect.objectContaining({
+				sessionId,
+				stage: "runtime_shutdown",
+				severity: "warn",
+			}),
+		);
+	});
+
+	it("preserves manifest metadata updates and persists total cost", async () => {
+		const sessionId = "sess-history-meta";
+		let storedManifest: SessionManifest = {
+			...createManifest(sessionId),
+			metadata: {
+				checkpoint: {
+					latest: {
+						ref: "abc123",
+						createdAt: 1,
+						runCount: 1,
+					},
+					history: [
+						{
+							ref: "abc123",
+							createdAt: 1,
+							runCount: 1,
+						},
+					],
+				},
+			},
+		};
+		const createRootSessionWithArtifacts = vi.fn().mockResolvedValue({
+			manifestPath: "/tmp/manifest-history-meta.json",
+			messagesPath: "/tmp/messages-history-meta.json",
+			manifest: { ...storedManifest },
+		});
+		const persistSessionMessages = vi.fn();
+		const updateSession = vi.fn().mockImplementation(async (input) => {
+			storedManifest = {
+				...storedManifest,
+				metadata: input.metadata,
+			};
+			return { updated: true };
+		});
+		const updateSessionStatus = vi.fn().mockResolvedValue({
+			updated: true,
+			endedAt: "2026-01-01T00:00:05.000Z",
+		});
+		const readSessionManifest = vi
+			.fn()
+			.mockImplementation(() => storedManifest);
+		const writeSessionManifest = vi
+			.fn()
+			.mockImplementation((_path, manifest) => {
+				storedManifest = manifest;
+			});
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts,
+			persistSessionMessages,
+			updateSession,
+			updateSessionStatus,
+			readSessionManifest,
+			writeSessionManifest,
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(
+				createResult({
+					usage: {
+						inputTokens: 3,
+						outputTokens: 4,
+						totalCost: 0.42,
+					},
+					messages: [
+						{ role: "user", content: [{ type: "text", text: "hello" }] },
+					],
+				}),
+			),
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+
+		expect(updateSession).toHaveBeenCalledWith({
+			sessionId,
+			metadata: {
+				checkpoint: {
+					latest: {
+						ref: "abc123",
+						createdAt: 1,
+						runCount: 1,
+					},
+					history: [
+						{
+							ref: "abc123",
+							createdAt: 1,
+							runCount: 1,
+						},
+					],
+				},
+				totalCost: 0.42,
+				aggregatedAgentsCost: 0.42,
+				usage: {
+					inputTokens: 3,
+					outputTokens: 4,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0.42,
+				},
+				aggregateUsage: {
+					inputTokens: 3,
+					outputTokens: 4,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0.42,
+				},
+			},
+		});
+		expect(writeSessionManifest).toHaveBeenCalledWith(
+			"/tmp/manifest-history-meta.json",
+			expect.objectContaining({
+				metadata: {
+					checkpoint: {
+						latest: {
+							ref: "abc123",
+							createdAt: 1,
+							runCount: 1,
+						},
+						history: [
+							{
+								ref: "abc123",
+								createdAt: 1,
+								runCount: 1,
+							},
+						],
+					},
+					totalCost: 0.42,
+					aggregatedAgentsCost: 0.42,
+					usage: {
+						inputTokens: 3,
+						outputTokens: 4,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0.42,
+					},
+					aggregateUsage: {
+						inputTokens: 3,
+						outputTokens: 4,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0.42,
+					},
+				},
+				status: "completed",
+			}),
+		);
+	});
+
+	it("does not install checkpoint hooks when checkpoint.enabled is not set in config", async () => {
+		const sessionId = "sess-checkpoint-default-off";
+		const manifest = createManifest(sessionId);
+		const updateSession = vi.fn().mockResolvedValue({ updated: true });
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-checkpoint-default-off.json",
+				messagesPath: "/tmp/messages-checkpoint-default-off.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSession,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([
+				{
+					sessionId,
+					provider: "mock-provider",
+					model: "mock-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					createdAt: "2026-01-01T00:00:00.000Z",
+					updatedAt: "2026-01-01T00:00:00.000Z",
+					status: "running",
+					metadata: undefined,
+				},
+			]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockImplementation(() => {
+				return {
+					tools: [],
+					shutdown: vi.fn(),
+				};
+			}),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: (config) =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						const snapshot = {
+							agentId: "agent_1",
+							runId: "conv_1",
+							parentAgentId: null,
+							status: "running" as const,
+							iteration: 1,
+							messages: [],
+							pendingToolCalls: [],
+							usage: {
+								inputTokens: 0,
+								outputTokens: 0,
+								cacheReadTokens: 0,
+								cacheWriteTokens: 0,
+							},
+						};
+						await config.hooks?.beforeRun?.({
+							snapshot: { ...snapshot, iteration: 0 },
+						});
+						await config.hooks?.beforeModel?.({
+							snapshot,
+							request: { messages: [], tools: [] },
+						});
+						return createResult();
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+		expect(updateSession).toHaveBeenCalledTimes(1);
+		expect(updateSession).toHaveBeenLastCalledWith({
+			sessionId,
+			metadata: {
+				totalCost: 0,
+				aggregatedAgentsCost: 0,
+				usage: {
+					inputTokens: 1,
+					outputTokens: 2,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+				aggregateUsage: {
+					inputTokens: 1,
+					outputTokens: 2,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+			},
+		});
+	});
+
+	it("installs checkpoint hooks when checkpoint.enabled=true in config", async () => {
+		const sessionId = "sess-checkpoint-config-on";
+		const checkpointRef = "a".repeat(40);
+		const repoCwd = join(isolatedHomeDir, "checkpoint-repo");
+		const createCheckpoint = vi.fn(({ runCount }) => ({
+			ref: checkpointRef,
+			createdAt: 123,
+			runCount,
+			kind: "commit" as const,
+		}));
+		const manifest = createManifest(sessionId);
+		const updateSession = vi.fn().mockResolvedValue({ updated: true });
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-checkpoint-env-on.json",
+				messagesPath: "/tmp/messages-checkpoint-env-on.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSession,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([
+				{
+					sessionId,
+					provider: "mock-provider",
+					model: "mock-model",
+					cwd: repoCwd,
+					workspaceRoot: repoCwd,
+					createdAt: "2026-01-01T00:00:00.000Z",
+					updatedAt: "2026-01-01T00:00:00.000Z",
+					status: "running",
+					metadata: undefined,
+				},
+			]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockImplementation(() => {
+				return {
+					tools: [],
+					shutdown: vi.fn(),
+				};
+			}),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: (config) =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						const snapshot = {
+							agentId: "agent_1",
+							runId: "conv_1",
+							parentAgentId: null,
+							status: "running" as const,
+							iteration: 1,
+							messages: [],
+							pendingToolCalls: [],
+							usage: {
+								inputTokens: 0,
+								outputTokens: 0,
+								cacheReadTokens: 0,
+								cacheWriteTokens: 0,
+							},
+						};
+						await config.hooks?.beforeRun?.({
+							snapshot: { ...snapshot, iteration: 0 },
+						});
+						await config.hooks?.beforeModel?.({
+							snapshot,
+							request: { messages: [], tools: [] },
+						});
+						return createResult();
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: {
+					...createConfig({ sessionId, cwd: repoCwd }),
+					checkpoint: { enabled: true, createCheckpoint },
+				},
+				prompt: "hello",
+				initialMessages: [
+					{ role: "user", content: "first" },
+					{ role: "assistant", content: "first response" },
+					{ role: "user", content: "second" },
+				],
+				interactive: true,
+			}),
+		);
+		await expect(manager.getSession(sessionId)).resolves.toEqual(
+			expect.objectContaining({
+				metadata: expect.objectContaining({
+					checkpoint: expect.objectContaining({
+						latest: expect.objectContaining({
+							ref: checkpointRef,
+							runCount: 3,
+						}),
+					}),
+				}),
+			}),
+		);
+		expect(createCheckpoint).toHaveBeenCalledWith({
+			cwd: repoCwd,
+			sessionId,
+			runCount: 3,
+		});
+		expect(updateSession).toHaveBeenCalledTimes(2);
+		expect(updateSession).toHaveBeenNthCalledWith(1, {
+			sessionId,
+			metadata: expect.objectContaining({
+				checkpoint: expect.objectContaining({
+					latest: expect.objectContaining({
+						ref: checkpointRef,
+						runCount: 3,
+					}),
+				}),
+			}),
+		});
+		expect(updateSession).toHaveBeenNthCalledWith(2, {
+			sessionId,
+			metadata: expect.objectContaining({
+				checkpoint: expect.objectContaining({
+					latest: expect.objectContaining({
+						ref: checkpointRef,
+						runCount: 3,
+					}),
+				}),
+				totalCost: 0,
+			}),
+		});
+	});
+
+	it("persists assistant message metadata for usage and model identity", async () => {
+		const sessionId = "sess-meta";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-meta.json",
+				messagesPath: "/tmp/messages-meta.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const updateConnectionDefaults = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				delegatedAgentConfigProvider: {
+					getRuntimeConfig: vi.fn(),
+					getConnectionConfig: vi.fn(),
+					updateConnectionDefaults,
+				},
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 33,
+					outputTokens: 12,
+					cacheReadTokens: 4,
+					cacheWriteTokens: 1,
+					totalCost: 0.42,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+					info: {
+						id: "claude-sonnet-4-6",
+						family: "claude-sonnet-4",
+					},
+				},
+				endedAt: new Date("2026-01-01T00:00:02.000Z"),
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+					{ role: "assistant", content: [{ type: "text", text: "world" }] },
+				],
+			}),
+		);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-6",
+				}),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+
+		expect(persistSessionMessages).toHaveBeenCalledTimes(1);
+		const persisted = persistSessionMessages.mock.calls[0]?.[1];
+		expect(Array.isArray(persisted)).toBe(true);
+		expect(persisted?.[1]).toMatchObject({
+			role: "assistant",
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+				family: "claude-sonnet-4",
+			},
+			metrics: {
+				inputTokens: 33,
+				outputTokens: 12,
+				cacheReadTokens: 4,
+				cacheWriteTokens: 1,
+				cost: 0.42,
+			},
+			ts: new Date("2026-01-01T00:00:02.000Z").getTime(),
+		});
+	});
+
+	it("queues sandbox steer messages back into the active session", async () => {
+		const sessionId = "sess-steer";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const updateConnectionDefaults = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				delegatedAgentConfigProvider: {
+					getRuntimeConfig: vi.fn(),
+					getConnectionConfig: vi.fn(),
+					updateConnectionDefaults,
+				},
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+				],
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "steered",
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+					{
+						role: "assistant",
+						content: [{ type: "text", text: "steered" }],
+					},
+				],
+			}),
+		);
+		const agent = {
+			run,
+			continue: continueFn,
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi
+				.fn()
+				.mockReturnValue([
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+				]),
+			canStartRun: vi.fn().mockReturnValue(true),
+		};
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: true,
+			}),
+		);
+
+		const harness = createPluginEventHarness(manager);
+		await harness.handlePluginEvent(sessionId, {
+			name: "steer_message",
+			payload: { prompt: "async result" },
+		});
+		await vi.waitFor(() => {
+			expect(continueFn).toHaveBeenCalledTimes(2);
+		});
+		expect(continueFn).toHaveBeenLastCalledWith(
+			'<user_input mode="act">async result</user_input>',
+			undefined,
+			undefined,
+		);
+	});
+
+	it("promotes queued prompts to the front when they become steer", async () => {
+		const sessionId = "sess-steer-priority";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const updateConnectionDefaults = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				delegatedAgentConfigProvider: {
+					getRuntimeConfig: vi.fn(),
+					getConnectionConfig: vi.fn(),
+					updateConnectionDefaults,
+				},
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			canStartRun: vi.fn().mockReturnValue(false),
+		};
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: true,
+			}),
+		);
+
+		const harness = createPluginEventHarness(manager);
+
+		await harness.handlePluginEvent(sessionId, {
+			name: "queue_message",
+			payload: { prompt: "queued first" },
+		});
+		await harness.handlePluginEvent(sessionId, {
+			name: "queue_message",
+			payload: { prompt: "queued second" },
+		});
+		await harness.handlePluginEvent(sessionId, {
+			name: "steer_message",
+			payload: { prompt: "queued first" },
+		});
+
+		expect(harness.getPendingPrompts(sessionId)).toEqual([
+			{ prompt: "queued first", delivery: "steer" },
+			{ prompt: "queued second", delivery: "queue" },
+		]);
+	});
+
+	it("wraps consumed steer prompts as mode-scoped user input", async () => {
+		const sessionId = "sess-steer-format";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const telemetry = new TelemetryService();
+		let agentConfig: AgentConfig | undefined;
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(false),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			telemetry,
+			createAgent: (config) => {
+				agentConfig = config;
+				return agent as never;
+			},
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId, mode: "act" }),
+				interactive: true,
+			}),
+		);
+		await expect(
+			manager.runTurn({
+				sessionId,
+				prompt: "steer this",
+				mode: "plan",
+				delivery: "steer",
+			}),
+		).resolves.toBeUndefined();
+
+		const consumed = await Promise.resolve(
+			agentConfig?.consumePendingUserMessage?.(),
+		);
+		expect(consumed).toBe('<user_input mode="plan">steer this</user_input>');
+		expect(agentConfig?.telemetry).toBe(telemetry);
+	});
+
+	it("clears pending prompts after an interactive abort", async () => {
+		const sessionId = "sess-abort-clears-prompts";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		let activeRun = false;
+		let rejectRun: ((error: Error) => void) | undefined;
+		let markRunStarted: (() => void) | undefined;
+		const runStarted = new Promise<void>((resolve) => {
+			markRunStarted = resolve;
+		});
+		const run = vi
+			.fn()
+			.mockImplementationOnce(
+				() =>
+					new Promise<AgentResult>((_resolve, reject) => {
+						activeRun = true;
+						rejectRun = (error) => {
+							activeRun = false;
+							reject(error);
+						};
+						markRunStarted?.();
+					}),
+			)
+			.mockResolvedValueOnce(createResult({ text: "queued result" }));
+		const agent = {
+			run,
+			continue: vi.fn().mockResolvedValue(createResult()),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			canStartRun: vi.fn(() => !activeRun),
+		};
+		agent.abort.mockImplementation(() => {
+			rejectRun?.(new Error("user cancelled"));
+		});
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+
+		const events: unknown[] = [];
+		manager.subscribe((event) => events.push(event));
+		const firstTurn = manager.runTurn({ sessionId, prompt: "slow" });
+		await runStarted;
+		await manager.runTurn({
+			sessionId,
+			prompt: "queued prompt",
+			delivery: "queue",
+		});
+		await manager.runTurn({
+			sessionId,
+			prompt: "steered prompt",
+			delivery: "steer",
+		});
+		expect(
+			(await manager.pendingPrompts.list({ sessionId })).map((prompt) => ({
+				prompt: prompt.prompt,
+				delivery: prompt.delivery,
+			})),
+		).toEqual([
+			{ prompt: "steered prompt", delivery: "steer" },
+			{ prompt: "queued prompt", delivery: "queue" },
+		]);
+
+		await manager.abort(sessionId, new Error("test abort"));
+		expect(agent.abort).toHaveBeenCalledTimes(1);
+		await expect(firstTurn).resolves.toMatchObject({
+			finishReason: "aborted",
+		});
+		expect(events).toContainEqual(
+			expect.objectContaining({
+				type: "agent_event",
+				payload: expect.objectContaining({
+					event: expect.objectContaining({
+						type: "done",
+						reason: "aborted",
+					}),
+				}),
+			}),
+		);
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(
+			(await manager.pendingPrompts.list({ sessionId })).map((prompt) => ({
+				prompt: prompt.prompt,
+				delivery: prompt.delivery,
+			})),
+		).toEqual([]);
+	});
+
+	it("keeps the same live interactive session usable after aborting before the first response", async () => {
+		const sessionId = "sess-abort-then-next-turn";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtime = { tools: [], shutdown: vi.fn() };
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue(runtime),
+		};
+		let messages: AgentResult["messages"] = [];
+		let activeRun = false;
+		let rejectRun: ((error: Error) => void) | undefined;
+		let markRunStarted: (() => void) | undefined;
+		const runStarted = new Promise<void>((resolve) => {
+			markRunStarted = resolve;
+		});
+		const run = vi.fn(
+			() =>
+				new Promise<AgentResult>((_resolve, reject) => {
+					activeRun = true;
+					messages = [{ role: "user", content: "slow" }];
+					rejectRun = (error) => {
+						activeRun = false;
+						reject(error);
+					};
+					markRunStarted?.();
+				}),
+		);
+		const continueTurn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "continued after abort",
+			}),
+		);
+		const agent = {
+			run,
+			continue: continueTurn,
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn(() => messages),
+			canStartRun: vi.fn(() => !activeRun),
+		};
+		agent.abort.mockImplementation(() => {
+			rejectRun?.(new Error("user cancelled before first response"));
+		});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+		const events: unknown[] = [];
+		manager.subscribe((event) => events.push(event));
+
+		const firstTurn = manager.runTurn({ sessionId, prompt: "slow" });
+		await runStarted;
+		await manager.abort(sessionId, new Error("test abort"));
+		await expect(firstTurn).resolves.toMatchObject({
+			finishReason: "aborted",
+		});
+
+		await expect(
+			manager.runTurn({ sessionId, prompt: "next turn after abort" }),
+		).resolves.toMatchObject({
+			finishReason: "completed",
+			text: "continued after abort",
+		});
+		await expect(manager.getSession(sessionId)).resolves.toMatchObject({
+			sessionId,
+			status: "idle",
+		});
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(continueTurn).toHaveBeenCalledTimes(1);
+		expect(agent.shutdown).not.toHaveBeenCalled();
+		expect(runtime.shutdown).not.toHaveBeenCalled();
+		expect(sessionService.updateSessionStatus).toHaveBeenNthCalledWith(
+			1,
+			sessionId,
+			"idle",
+			null,
+		);
+		expect(sessionService.updateSessionStatus).toHaveBeenNthCalledWith(
+			2,
+			sessionId,
+			"running",
+			null,
+		);
+		expect(sessionService.updateSessionStatus).toHaveBeenNthCalledWith(
+			3,
+			sessionId,
+			"idle",
+			null,
+		);
+		expect(events).not.toContainEqual(
+			expect.objectContaining({
+				type: "ended",
+				payload: expect.objectContaining({ sessionId, reason: "aborted" }),
+			}),
+		);
+	});
+
+	it("preserves per-turn metadata on prior assistant messages across turns", async () => {
+		const sessionId = "sess-meta-multi";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const firstTurnMessages = [
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "hello" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "world" }],
+			},
+		];
+		const secondTurnMessages = [
+			...firstTurnMessages,
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "again" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "still here" }],
+			},
+		];
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 33,
+					outputTokens: 12,
+					cacheReadTokens: 4,
+					cacheWriteTokens: 1,
+					totalCost: 0.42,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+				},
+				endedAt: new Date("2026-01-01T00:00:02.000Z"),
+				messages: firstTurnMessages,
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 10,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 0,
+					totalCost: 0.12,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+				},
+				endedAt: new Date("2026-01-01T00:00:03.000Z"),
+				messages: secondTurnMessages,
+			}),
+		);
+		const agent = {
+			run,
+			continue: continueFn,
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			restore: vi.fn(),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-meta-multi.json",
+				messagesPath: "/tmp/messages-meta-multi.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					providerId: "anthropic",
+					modelId: "claude-sonnet-4-6",
+				}),
+				interactive: true,
+			}),
+		);
+
+		await manager.runTurn({ sessionId, prompt: "hello" });
+		await manager.runTurn({ sessionId, prompt: "again" });
+
+		const persisted = persistSessionMessages.mock.calls[1]?.[1];
+		expect(persisted?.[1]).toMatchObject({
+			role: "assistant",
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+			},
+			metrics: {
+				inputTokens: 33,
+				outputTokens: 12,
+				cacheReadTokens: 4,
+				cacheWriteTokens: 1,
+				cost: 0.42,
+			},
+		});
+		expect(persisted?.[3]).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 10,
+				outputTokens: 5,
+				cacheReadTokens: 2,
+				cacheWriteTokens: 0,
+				cost: 0.12,
+			},
+		});
+	});
+
+	it("persists rendered messages when a turn fails", async () => {
+		const sessionId = "sess-failed-turn";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-failed-turn.json",
+				messagesPath: "/tmp/messages-failed-turn.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const renderedMessages = [
+			{ role: "user", content: [{ type: "text", text: "hello" }] },
+			{ role: "assistant", content: [{ type: "text", text: "partial" }] },
+		];
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockRejectedValue(new Error("boom")),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					restore: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi
+						.fn()
+						.mockReturnValueOnce([])
+						.mockReturnValue(renderedMessages),
+					messages: [],
+				}) as never,
+		});
+
+		await expect(
+			manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ sessionId }),
+					prompt: "hello",
+					interactive: false,
+				}),
+			),
+		).rejects.toThrow("boom");
+
+		expect(persistSessionMessages).toHaveBeenCalledTimes(1);
+		expect(persistSessionMessages).toHaveBeenCalledWith(
+			sessionId,
+			renderedMessages,
+			"You are a test agent",
+		);
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"failed",
+			1,
+		);
+	});
+
+	it("does not synthesize assistant usage metadata when a turn fails before assistant output", async () => {
+		const sessionId = "sess-failed-before-assistant";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-failed-before-assistant.json",
+				messagesPath: "/tmp/messages-failed-before-assistant.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const userOnlyMessages = [
+			{ role: "user", content: [{ type: "text", text: "hello" }] },
+		];
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockRejectedValue(new Error("boom")),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					restore: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi
+						.fn()
+						.mockReturnValueOnce([])
+						.mockReturnValue(userOnlyMessages),
+					subscribeEvents: vi.fn(),
+					getAgentId: vi.fn().mockReturnValue("agent-test"),
+					getConversationId: vi.fn().mockReturnValue("conv-test"),
+					messages: [],
+				}) as never,
+		});
+
+		await expect(
+			manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ sessionId }),
+					prompt: "hello",
+					interactive: false,
+				}),
+			),
+		).rejects.toThrow("boom");
+
+		expect(persistSessionMessages).toHaveBeenCalledTimes(1);
+		expect(persistSessionMessages).toHaveBeenCalledWith(
+			sessionId,
+			userOnlyMessages,
+			"You are a test agent",
+		);
+		const persisted = persistSessionMessages.mock.calls[0]?.[1] as Array<{
+			role?: string;
+			metrics?: unknown;
+			modelInfo?: unknown;
+		}>;
+		expect(persisted).toHaveLength(1);
+		expect(persisted[0]?.role).toBe("user");
+		expect(persisted[0]).not.toHaveProperty("metrics");
+		expect(persisted[0]).not.toHaveProperty("modelInfo");
+	});
+
+	it("uses run for first send then continue for subsequent sends", async () => {
+		const sessionId = "sess-2";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-2.json",
+				messagesPath: "/tmp/messages-2.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			updateSession: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(createResult({ text: "first" }));
+		const continueFn = vi
+			.fn()
+			.mockResolvedValue(createResult({ text: "second" }));
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+		const first = await manager.runTurn({ sessionId, prompt: "first" });
+		const second = await manager.runTurn({
+			sessionId,
+			prompt: "second",
+			mode: "plan",
+		});
+
+		expect(first?.text).toBe("first");
+		expect(second?.text).toBe("second");
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(continueFn).toHaveBeenCalledTimes(1);
+		expect(run).toHaveBeenCalledWith(
+			'<user_input mode="act">first</user_input>',
+			undefined,
+			undefined,
+		);
+		expect(continueFn).toHaveBeenCalledWith(
+			'<user_input mode="plan">second</user_input>',
+			undefined,
+			undefined,
+		);
+		expect(sessionService.persistSessionMessages).toHaveBeenCalledTimes(2);
+	});
+
+	it("keeps an interactive session reusable when abort makes the run reject", async () => {
+		const sessionId = "sess-interactive-abort-reject";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-abort-reject.json",
+				messagesPath: "/tmp/messages-abort-reject.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			updateSession: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		let rejectRun: ((error: Error) => void) | undefined;
+		let markRunStarted: (() => void) | undefined;
+		const runStarted = new Promise<void>((resolve) => {
+			markRunStarted = resolve;
+		});
+		const run = vi
+			.fn()
+			.mockImplementationOnce(
+				() =>
+					new Promise<AgentResult>((_resolve, reject) => {
+						rejectRun = reject;
+						markRunStarted?.();
+					}),
+			)
+			.mockResolvedValueOnce(createResult({ text: "second" }));
+		const agent = {
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(() => {
+				rejectRun?.(new Error("user cancelled"));
+			}),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+		const firstTurn = manager.runTurn({ sessionId, prompt: "slow" });
+		await runStarted;
+		await manager.abort(sessionId, new Error("user cancelled"));
+
+		await expect(firstTurn).resolves.toMatchObject({
+			finishReason: "aborted",
+		});
+		await expect(
+			manager.runTurn({ sessionId, prompt: "again" }),
+		).resolves.toMatchObject({
+			text: "second",
+			finishReason: "completed",
+		});
+		expect(run).toHaveBeenCalledTimes(2);
+		expect(agent.shutdown).not.toHaveBeenCalled();
+	});
+
+	it("tracks accumulated usage per session across turns", async () => {
+		const sessionId = "sess-usage";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-usage.json",
+				messagesPath: "/tmp/messages-usage.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			updateSession: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				text: "first",
+				usage: {
+					inputTokens: 10,
+					outputTokens: 3,
+					cacheReadTokens: 1,
+					cacheWriteTokens: 2,
+					totalCost: 0.11,
+				},
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "second",
+				usage: {
+					inputTokens: 8,
+					outputTokens: 4,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 0,
+					totalCost: 0.09,
+				},
+			}),
+		);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+
+		await manager.runTurn({ sessionId, prompt: "first" });
+		expect((await manager.getAccumulatedUsage(sessionId))?.usage).toEqual({
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+			totalCost: 0.11,
+		});
+
+		await manager.runTurn({ sessionId, prompt: "second" });
+		expect((await manager.getAccumulatedUsage(sessionId))?.usage).toEqual({
+			inputTokens: 18,
+			outputTokens: 7,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+			totalCost: 0.2,
+		});
+	});
+
+	it("resumes saved interactive sessions without rewriting metadata or timestamps and seeds usage", async () => {
+		const sessionId = "sess-resume-readonly";
+		const sessionsDir = join(isolatedHomeDir, "sessions");
+		const sessionDir = join(sessionsDir, sessionId);
+		const messagesPath = join(sessionDir, `${sessionId}.messages.json`);
+		mkdirSync(sessionDir, { recursive: true });
+		writeFileSync(
+			join(sessionDir, "investigator__resume.messages.json"),
+			`${JSON.stringify({
+				version: 1,
+				messages: [
+					{
+						role: "assistant",
+						content: "teammate answer",
+						metrics: {
+							inputTokens: 7,
+							outputTokens: 5,
+							cacheReadTokens: 2,
+							cacheWriteTokens: 1,
+							cost: 0.12,
+						},
+					},
+				],
+			})}\n`,
+			"utf8",
+		);
+		const manifest = {
+			...createManifest(sessionId),
+			status: "completed" as const,
+			ended_at: "2026-01-01T00:03:00.000Z",
+			metadata: {
+				title: "saved title",
+				totalCost: 0.25,
+				aggregatedAgentsCost: 0.37,
+			},
+			messages_path: messagesPath,
+		};
+		const initialMessages: MessageWithMetadata[] = [
+			{ role: "user", content: "first prompt" },
+			{
+				role: "assistant",
+				content: "first answer",
+				metrics: {
+					inputTokens: 11,
+					outputTokens: 7,
+					cacheReadTokens: 3,
+					cacheWriteTokens: 2,
+					cost: 0.25,
+				},
+			},
+		];
+		const createRootSessionWithArtifacts = vi.fn();
+		const persistSessionMessages = vi.fn();
+		const updateSessionStatus = vi.fn().mockResolvedValue({
+			updated: true,
+			endedAt: "2026-01-01T00:04:00.000Z",
+		});
+		const updateSession = vi.fn().mockResolvedValue({ updated: true });
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue(sessionsDir),
+			readSessionManifest: vi.fn().mockReturnValue(manifest),
+			createRootSessionWithArtifacts,
+			persistSessionMessages,
+			updateSessionStatus,
+			updateSession,
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 5,
+					outputTokens: 4,
+					totalCost: 0.1,
+				},
+				messages: [
+					...initialMessages,
+					{ role: "user", content: "second prompt" },
+					{ role: "assistant", content: "second answer" },
+				],
+			}),
+		);
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				registerLeadAgent: vi.fn(),
+				shutdown: vi.fn(),
+			}),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn(),
+					continue: continueFn,
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue(initialMessages),
+					messages: initialMessages,
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+				initialMessages,
+			}),
+		);
+
+		expect(createRootSessionWithArtifacts).not.toHaveBeenCalled();
+		expect(persistSessionMessages).not.toHaveBeenCalled();
+		expect(updateSessionStatus).not.toHaveBeenCalled();
+		expect(updateSession).not.toHaveBeenCalled();
+		expect((await manager.getAccumulatedUsage(sessionId))?.usage).toEqual({
+			inputTokens: 11,
+			outputTokens: 7,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+			totalCost: 0.25,
+		});
+		expect(
+			(await manager.getAccumulatedUsage(sessionId))?.aggregateUsage,
+		).toEqual({
+			inputTokens: 18,
+			outputTokens: 12,
+			cacheReadTokens: 5,
+			cacheWriteTokens: 3,
+			totalCost: 0.37,
+		});
+
+		await manager.runTurn({ sessionId, prompt: "second prompt" });
+
+		expect(createRootSessionWithArtifacts).not.toHaveBeenCalled();
+		expect(updateSessionStatus).toHaveBeenNthCalledWith(
+			1,
+			sessionId,
+			"running",
+			null,
+		);
+		expect(updateSessionStatus).toHaveBeenNthCalledWith(
+			2,
+			sessionId,
+			"idle",
+			null,
+		);
+		expect(updateSessionStatus).toHaveBeenCalledTimes(2);
+		const persistedMetadata = updateSession.mock.calls[0]?.[0]
+			.metadata as Record<string, unknown>;
+		expect(persistedMetadata.title).toBe("saved title");
+		expect(persistedMetadata.totalCost as number).toBeCloseTo(0.35);
+		expect(persistedMetadata.aggregatedAgentsCost as number).toBeCloseTo(0.47);
+		const persistedUsage = persistedMetadata.usage as Record<string, unknown>;
+		const persistedAggregateUsage = persistedMetadata.aggregateUsage as Record<
+			string,
+			unknown
+		>;
+		expect(persistedUsage).toMatchObject({
+			inputTokens: 16,
+			outputTokens: 11,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+		});
+		expect(persistedUsage.totalCost as number).toBeCloseTo(0.35);
+		expect(persistedAggregateUsage).toMatchObject({
+			inputTokens: 23,
+			outputTokens: 16,
+			cacheReadTokens: 5,
+			cacheWriteTokens: 3,
+		});
+		expect(persistedAggregateUsage.totalCost as number).toBeCloseTo(0.47);
+		expect((await manager.getAccumulatedUsage(sessionId))?.usage).toEqual({
+			inputTokens: 16,
+			outputTokens: 11,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+			totalCost: 0.35,
+		});
+		expect(
+			(await manager.getAccumulatedUsage(sessionId))?.aggregateUsage,
+		).toEqual({
+			inputTokens: 23,
+			outputTokens: 16,
+			cacheReadTokens: 5,
+			cacheWriteTokens: 3,
+			totalCost: 0.47,
+		});
+	});
+
+	it("restores full persisted aggregate usage when child message artifacts are missing", async () => {
+		const sessionId = "sess-resume-aggregate-metadata";
+		const sessionsDir = join(isolatedHomeDir, "sessions");
+		const sessionDir = join(sessionsDir, sessionId);
+		const messagesPath = join(sessionDir, `${sessionId}.messages.json`);
+		mkdirSync(sessionDir, { recursive: true });
+		const aggregateUsage = {
+			inputTokens: 18,
+			outputTokens: 12,
+			cacheReadTokens: 5,
+			cacheWriteTokens: 3,
+			totalCost: 0.37,
+		};
+		const manifest = {
+			...createManifest(sessionId),
+			status: "completed" as const,
+			ended_at: "2026-01-01T00:03:00.000Z",
+			metadata: {
+				title: "saved title",
+				totalCost: 0.25,
+				aggregatedAgentsCost: 0.37,
+				aggregateUsage,
+			},
+			messages_path: messagesPath,
+		};
+		const initialMessages: MessageWithMetadata[] = [
+			{ role: "user", content: "first prompt" },
+			{
+				role: "assistant",
+				content: "first answer",
+				metrics: {
+					inputTokens: 11,
+					outputTokens: 7,
+					cacheReadTokens: 3,
+					cacheWriteTokens: 2,
+					cost: 0.25,
+				},
+			},
+		];
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue(sessionsDir),
+			readSessionManifest: vi.fn().mockReturnValue(manifest),
+			createRootSessionWithArtifacts: vi.fn(),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn(),
+			updateSession: vi.fn(),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					registerLeadAgent: vi.fn(),
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: () =>
+				({
+					run: vi.fn(),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue(initialMessages),
+					messages: initialMessages,
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+				initialMessages,
+			}),
+		);
+
+		expect(
+			(await manager.getAccumulatedUsage(sessionId))?.aggregateUsage,
+		).toEqual(aggregateUsage);
+	});
+
+	it("aggregates teammate usage without double-counting lead usage events", async () => {
+		const sessionId = "sess-team-usage";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-usage.json",
+				messagesPath: "/tmp/messages-team-usage.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			updateSession: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+		let onAgentEvent: ((event: AgentEvent) => void) | undefined;
+		const run = vi.fn().mockImplementation(async () => {
+			onAgentEvent?.({
+				type: "usage",
+				inputTokens: 10,
+				outputTokens: 3,
+				cacheReadTokens: 1,
+				cacheWriteTokens: 2,
+				cost: 0.11,
+				totalInputTokens: 10,
+				totalOutputTokens: 3,
+				totalCacheReadTokens: 1,
+				totalCacheWriteTokens: 2,
+				totalCost: 0.11,
+			});
+			onTeamEvent?.({
+				type: "agent_event",
+				agentId: "investigator",
+				event: {
+					type: "usage",
+					agentId: "agent-teammate-1",
+					conversationId: "conv-teammate-1",
+					inputTokens: 7,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 1,
+					cost: 0.12,
+					totalInputTokens: 7,
+					totalOutputTokens: 5,
+					totalCacheReadTokens: 2,
+					totalCacheWriteTokens: 1,
+					totalCost: 0.12,
+				},
+			});
+			return createResult({
+				text: "lead scheduled teammate",
+				usage: {
+					inputTokens: 10,
+					outputTokens: 3,
+					cacheReadTokens: 1,
+					cacheWriteTokens: 2,
+					totalCost: 0.11,
+				},
+			});
+		});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn((listener: (event: AgentEvent) => void) => {
+						onAgentEvent = listener;
+						return () => {};
+					}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+
+		await manager.runTurn({ sessionId, prompt: "run teammate work" });
+
+		const usageSummary = await manager.getAccumulatedUsage(sessionId);
+		const usage = usageSummary?.usage;
+		expect(usage).toMatchObject({
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+		});
+		expect(usage?.totalCost).toBeCloseTo(0.11);
+		const aggregateUsage = usageSummary?.aggregateUsage;
+		expect(aggregateUsage).toMatchObject({
+			inputTokens: 17,
+			outputTokens: 8,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 3,
+		});
+		expect(aggregateUsage?.totalCost).toBeCloseTo(0.23);
+		const persistedMetadata = sessionService.updateSession.mock.calls[0]?.[0]
+			.metadata as Record<string, unknown>;
+		expect(persistedMetadata.totalCost as number).toBeCloseTo(0.11);
+		expect(persistedMetadata.aggregatedAgentsCost as number).toBeCloseTo(0.23);
+		const persistedUsage = persistedMetadata.usage as Record<string, unknown>;
+		const persistedAggregateUsage = persistedMetadata.aggregateUsage as Record<
+			string,
+			unknown
+		>;
+		expect(persistedUsage).toMatchObject({
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+		});
+		expect(persistedUsage.totalCost as number).toBeCloseTo(0.11);
+		expect(persistedAggregateUsage).toMatchObject({
+			inputTokens: 17,
+			outputTokens: 8,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 3,
+		});
+		expect(persistedAggregateUsage.totalCost as number).toBeCloseTo(0.23);
+	});
+
+	it("queues sends with explicit queue or steer delivery and emits snapshots", async () => {
+		const sessionId = "sess-delivery-queue";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-queue.json",
+				messagesPath: "/tmp/messages-queue.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		let canStartRun = false;
+		const run = vi.fn().mockResolvedValue(createResult({ text: "first" }));
+		const continueFn = vi
+			.fn()
+			.mockResolvedValue(createResult({ text: "next" }));
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					canStartRun: vi.fn(() => canStartRun),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+		const events: Array<unknown> = [];
+		manager.subscribe((event) => {
+			events.push(event);
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+
+		await expect(
+			manager.runTurn({ sessionId, prompt: "queued first", delivery: "queue" }),
+		).resolves.toBeUndefined();
+		await expect(
+			manager.runTurn({
+				sessionId,
+				prompt: "queued second",
+				delivery: "steer",
+			}),
+		).resolves.toBeUndefined();
+
+		expect(run).not.toHaveBeenCalled();
+		expect(continueFn).not.toHaveBeenCalled();
+		const promptSnapshots = events
+			.filter((event) => {
+				return (
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompts"
+				);
+			})
+			.map((event) => (event as { payload: { prompts: unknown[] } }).payload);
+		expect(promptSnapshots.at(-1)).toEqual({
+			prompts: [
+				expect.objectContaining({
+					prompt: "queued second",
+					delivery: "steer",
+					attachmentCount: 0,
+				}),
+				expect.objectContaining({
+					prompt: "queued first",
+					delivery: "queue",
+					attachmentCount: 0,
+				}),
+			],
+			sessionId,
+		});
+
+		canStartRun = true;
+		await manager.runTurn({ sessionId, prompt: "run now" });
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(
+			events.some((event) => {
+				return (
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompt_submitted" &&
+					"payload" in event &&
+					(event.payload as { prompt?: string }).prompt === "queued second"
+				);
+			}),
+		).toBe(true);
+	});
+
+	it("emits canonical session snapshots for local lifecycle updates", async () => {
+		const sessionId = "sess-local-snapshot";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-snapshot.json",
+				messagesPath: "/tmp/messages-snapshot.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:01.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			readSessionManifest: vi.fn().mockResolvedValue(manifest),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({ tools: [], shutdown: vi.fn() }),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockResolvedValue(
+						createResult({
+							messages: [
+								{ role: "user", content: "hello" },
+								{ role: "assistant", content: "ok" },
+							],
+							usage: {
+								inputTokens: 3,
+								outputTokens: 4,
+								cacheReadTokens: 1,
+								cacheWriteTokens: 2,
+								totalCost: 0.12,
+							},
+						}),
+					),
+					continue: vi.fn(),
+					canStartRun: vi.fn(() => true),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+		const events: Array<unknown> = [];
+		manager.subscribe((event) => events.push(event));
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+			}),
+		);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const snapshotEvent = events
+			.filter(
+				(event) =>
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "session_snapshot",
+			)
+			.at(-1) as { payload: { snapshot: unknown } } | undefined;
+		expect(snapshotEvent?.payload.snapshot).toMatchObject({
+			version: 1,
+			sessionId,
+			source: SessionSource.CLI,
+			workspace: { cwd: "/tmp/project", root: "/tmp/project" },
+			model: { providerId: "mock-provider", modelId: "mock-model" },
+			capabilities: {
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: true,
+			},
+			lineage: { isSubagent: false },
+		});
+	});
+
+	it("auto-queues sends to a running interactive session", async () => {
+		const sessionId = "sess-auto-queue";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-auto-queue.json",
+				messagesPath: "/tmp/messages-auto-queue.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		let canStartRun = false;
+		const run = vi.fn().mockResolvedValue(createResult({ text: "first" }));
+		const continueFn = vi
+			.fn()
+			.mockResolvedValue(createResult({ text: "next" }));
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					canStartRun: vi.fn(() => canStartRun),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+		const events: Array<unknown> = [];
+		manager.subscribe((event) => {
+			events.push(event);
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+
+		await expect(
+			manager.runTurn({ sessionId, prompt: "queued implicitly" }),
+		).resolves.toBeUndefined();
+
+		expect(run).not.toHaveBeenCalled();
+		expect(continueFn).not.toHaveBeenCalled();
+		const promptSnapshots = events
+			.filter((event) => {
+				return (
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompts"
+				);
+			})
+			.map((event) => (event as { payload: { prompts: unknown[] } }).payload);
+		expect(promptSnapshots.at(-1)).toEqual({
+			prompts: [
+				expect.objectContaining({
+					prompt: "queued implicitly",
+					delivery: "queue",
+					attachmentCount: 0,
+				}),
+			],
+			sessionId,
+		});
+
+		canStartRun = true;
+		await manager.runTurn({ sessionId, prompt: "run now" });
+
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(
+			events.some((event) => {
+				return (
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompt_submitted" &&
+					"payload" in event &&
+					(event.payload as { prompt?: string; delivery?: string }).prompt ===
+						"queued implicitly" &&
+					(event.payload as { delivery?: string }).delivery === "queue"
+				);
+			}),
+		).toBe(true);
+	});
+
+	it("updates and removes pending prompts by id", async () => {
+		const sessionId = "sess-edit-pending-queue";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-edit-queue.json",
+				messagesPath: "/tmp/messages-edit-queue.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockResolvedValue(createResult({ text: "first" })),
+					continue: vi.fn().mockResolvedValue(createResult({ text: "next" })),
+					canStartRun: vi.fn(() => false),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+		const events: Array<unknown> = [];
+		manager.subscribe((event) => {
+			events.push(event);
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: true,
+			}),
+		);
+		await manager.runTurn({
+			sessionId,
+			prompt: "queued first",
+			delivery: "queue",
+		});
+		await manager.runTurn({
+			sessionId,
+			prompt: "queued second",
+			delivery: "queue",
+		});
+
+		const queued = await manager.pendingPrompts.list({ sessionId });
+		expect(queued.map((item) => item.prompt)).toEqual([
+			"queued first",
+			"queued second",
+		]);
+
+		const edited = await manager.pendingPrompts.update({
+			sessionId,
+			promptId: queued[0]?.id,
+			prompt: "edited first",
+		});
+		expect(edited.updated).toBe(true);
+		expect(edited.prompts.map((item) => item.prompt)).toEqual([
+			"edited first",
+			"queued second",
+		]);
+
+		const steered = await manager.pendingPrompts.update({
+			sessionId,
+			promptId: edited.prompts[1]?.id,
+			delivery: "steer",
+		});
+		expect(
+			steered.prompts.map(({ prompt, delivery }) => ({ prompt, delivery })),
+		).toEqual([
+			{ prompt: "queued second", delivery: "steer" },
+			{ prompt: "edited first", delivery: "queue" },
+		]);
+
+		const removed = await manager.pendingPrompts.delete({
+			sessionId,
+			promptId: steered.prompts[0]?.id,
+		});
+		expect(removed.removed).toBe(true);
+		expect(removed.prompt?.prompt).toBe("queued second");
+		expect(removed.prompts.map((item) => item.prompt)).toEqual([
+			"edited first",
+		]);
+		expect(
+			events.some(
+				(event) =>
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompts",
+			),
+		).toBe(true);
+	});
+
+	it("returns undefined accumulated usage for unknown sessions", async () => {
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: false }),
+			} as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: () =>
+				({
+					run: vi.fn(),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		expect(
+			await manager.getAccumulatedUsage("missing-session"),
+		).toBeUndefined();
+	});
+
+	it("marks a failed single-run session as failed when run throws", async () => {
+		const sessionId = "sess-fail";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-fail.json",
+				messagesPath: "/tmp/messages-fail.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeShutdown = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: runtimeShutdown,
+			}),
+		};
+		const run = vi.fn().mockRejectedValue(new Error("run failed"));
+		const agentShutdown = vi.fn().mockResolvedValue(undefined);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: agentShutdown,
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await expect(
+			manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ sessionId }),
+					prompt: "hello",
+					interactive: false,
+				}),
+			),
+		).rejects.toThrow("run failed");
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"failed",
+			1,
+		);
+		expect(agentShutdown).toHaveBeenCalledTimes(1);
+		expect(runtimeShutdown).toHaveBeenCalledTimes(1);
+	});
+
+	it("marks a single-run error result as failed", async () => {
+		const sessionId = "sess-error-result";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-error-result.json",
+				messagesPath: "/tmp/messages-error-result.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				finishReason: "error",
+				text: "",
+			}),
+		);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		const started = await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		);
+
+		expect(started.result?.finishReason).toBe("error");
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"failed",
+			1,
+		);
+	});
+
+	it("does not persist or emit shutdown hooks when no prompt was submitted", async () => {
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn(),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn(),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeShutdown = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: runtimeShutdown,
+			}),
+		};
+		const agentShutdown = vi.fn().mockResolvedValue(undefined);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn(),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: agentShutdown,
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		const started = await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId: "sess-no-prompt" }),
+				interactive: true,
+			}),
+		);
+		await manager.stopSession(started.sessionId);
+
+		expect(
+			sessionService.createRootSessionWithArtifacts,
+		).not.toHaveBeenCalled();
+		expect(sessionService.updateSessionStatus).not.toHaveBeenCalled();
+		expect(agentShutdown).not.toHaveBeenCalled();
+		expect(runtimeShutdown).toHaveBeenCalledTimes(1);
+	});
+
+	it("updates agent connection with refreshed OAuth key before turn", async () => {
+		const sessionId = "sess-oauth";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-oauth.json",
+				messagesPath: "/tmp/messages-oauth.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const updateConnectionDefaults = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				delegatedAgentConfigProvider: {
+					getRuntimeConfig: vi.fn(),
+					getConnectionConfig: vi.fn(),
+					updateConnectionDefaults,
+				},
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(createResult({ text: "ok" }));
+		const updateConnection = vi.fn();
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			oauthTokenManager: {
+				resolveProviderApiKey: vi.fn().mockResolvedValue({
+					apiKey: "oauth-access-new",
+					refreshed: true,
+				}),
+			} as never,
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					restore: vi.fn(),
+					updateConnection,
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					providerId: "openai-codex",
+					apiKey: "oauth-access-old",
+				}),
+				interactive: true,
+			}),
+		);
+		await manager.runTurn({ sessionId, prompt: "hello" });
+
+		expect(updateConnectionDefaults).toHaveBeenCalledWith({
+			apiKey: "oauth-access-new",
+		});
+		expect(updateConnection).toHaveBeenCalledWith({
+			apiKey: "oauth-access-new",
+		});
+		expect(run).toHaveBeenCalledTimes(1);
+	});
+
+	it("hydrates provider-specific config from provider settings", async () => {
+		const sessionId = "sess-provider-config";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-provider-config.json",
+				messagesPath: "/tmp/messages-provider-config.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				model: {
+					id: "claude-sonnet-4@20250514",
+					provider: "vertex",
+				},
+			}),
+		);
+		const createAgent = vi.fn().mockReturnValue({
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: createAgent as never,
+			providerSettingsManager: {
+				getProviderSettings: vi.fn().mockReturnValue({
+					provider: "vertex",
+					gcp: {
+						projectId: "test-project",
+						region: "us-central1",
+					},
+				}),
+			} as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					providerId: "vertex",
+					modelId: "claude-sonnet-4@20250514",
+				}),
+				interactive: true,
+			}),
+		);
+		await manager.runTurn({ sessionId, prompt: "hello" });
+
+		expect(createAgent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerId: "vertex",
+				modelId: "claude-sonnet-4@20250514",
+				providerConfig: expect.objectContaining({
+					providerId: "vertex",
+					modelId: "claude-sonnet-4@20250514",
+					gcp: {
+						projectId: "test-project",
+						region: "us-central1",
+					},
+				}),
+			}),
+		);
+	});
+
+	it("forwards loopDetection config to the agent constructor", async () => {
+		const sessionId = "sess-loop-detection";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-loop.json",
+				messagesPath: "/tmp/messages-loop.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(createResult());
+		const createAgent = vi.fn().mockReturnValue({
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: createAgent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					execution: {
+						loopDetection: { softThreshold: 4, hardThreshold: 8 },
+					},
+				}),
+				interactive: true,
+			}),
+		);
+		await manager.runTurn({ sessionId, prompt: "test" });
+
+		expect(createAgent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				execution: {
+					loopDetection: { softThreshold: 4, hardThreshold: 8 },
+				},
+			}),
+		);
+	});
+
+	it("injects a core-owned compaction prepareTurn callback into the agent constructor", async () => {
+		const sessionId = "sess-compaction";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-compaction.json",
+				messagesPath: "/tmp/messages-compaction.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(createResult());
+		const createAgent = vi.fn().mockReturnValue({
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		});
+		const compact = vi.fn();
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: createAgent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					compaction: {
+						enabled: true,
+						strategy: "basic",
+						compact,
+					},
+				}),
+				interactive: true,
+			}),
+		);
+		await manager.runTurn({ sessionId, prompt: "test" });
+
+		expect(createAgent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				prepareTurn: expect.any(Function),
+			}),
+		);
+	});
+
+	it("binds unowned initial compaction state to the started session", async () => {
+		const sessionId = "sess-compaction-initial";
+		const manifest = createManifest(sessionId);
+		const initialMessages: MessageWithMetadata[] = [
+			{ role: "user", content: "large source" },
+		];
+		const initialCompactionState = createSessionCompactionState({
+			sourceMessages: initialMessages,
+			compactedMessages: [{ role: "user", content: "summary" }],
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-compaction-initial.json",
+				messagesPath: "/tmp/messages-compaction-initial.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			persistSessionCompactionState: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(createResult());
+		const createAgent = vi.fn().mockReturnValue({
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue(sessionId),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue(initialMessages),
+			messages: initialMessages,
+		});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: createAgent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					compaction: {
+						enabled: true,
+						strategy: "basic",
+						compact: vi.fn(),
+					},
+				}),
+				initialMessages,
+				initialCompactionState,
+				interactive: true,
+			}),
+		);
+
+		expect(sessionService.persistSessionCompactionState).toHaveBeenCalledWith(
+			sessionId,
+			expect.objectContaining({
+				conversation_id: sessionId,
+				messages: initialCompactionState.messages,
+			}),
+		);
+	});
+
+	it("does not project compaction state when compaction is disabled", async () => {
+		const sessionId = "sess-compaction-disabled";
+		const manifest = createManifest(sessionId);
+		const initialMessages: MessageWithMetadata[] = [
+			{ role: "user", content: "canonical source" },
+		];
+		const initialCompactionState = createSessionCompactionState({
+			sourceMessages: initialMessages,
+			compactedMessages: [{ role: "user", content: "projected summary" }],
+			conversationId: sessionId,
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-compaction-disabled.json",
+				messagesPath: "/tmp/messages-compaction-disabled.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			persistSessionCompactionState: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(createResult());
+		const createAgent = vi.fn().mockReturnValue({
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(),
+			subscribeEvents: vi.fn().mockReturnValue(() => {}),
+			canStartRun: vi.fn().mockReturnValue(true),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue(sessionId),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue(initialMessages),
+			messages: initialMessages,
+		});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: createAgent as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					compaction: {
+						enabled: false,
+						strategy: "basic",
+					},
+				}),
+				initialMessages,
+				initialCompactionState,
+				interactive: true,
+			}),
+		);
+
+		const prepareTurn = createAgent.mock.calls[0]?.[0]?.prepareTurn;
+		expect(prepareTurn).toBeUndefined();
+		expect(sessionService.persistSessionCompactionState).not.toHaveBeenCalled();
+
+		await expect(
+			manager.updateSessionCompactionState(sessionId, initialCompactionState),
+		).resolves.toEqual({ updated: true });
+		expect(createAgent.mock.calls[0]?.[0]?.prepareTurn).toBeUndefined();
+	});
+
+	it("persists active manual compaction state against the persisted transcript", async () => {
+		const sessionId = "sess-compaction-active-persisted";
+		const tempCwd = mkdtempSync(join(tmpdir(), "compaction-active-"));
+		try {
+			const messagesPath = join(tempCwd, "messages.json");
+			const persistedMessages = [
+				{ role: "user", content: "hi" },
+				{
+					role: "assistant",
+					content: "hello",
+					modelInfo: { maxTokens: 1 },
+				},
+			] as MessageWithMetadata[];
+			const liveMessages = [
+				{ role: "user", content: "hi" },
+				{ role: "assistant", content: "hello" },
+			] as MessageWithMetadata[];
+			writeFileSync(messagesPath, JSON.stringify(persistedMessages), "utf8");
+			const manifest = {
+				...createManifest(sessionId),
+				messages_path: messagesPath,
+			};
+			const incoming = createSessionCompactionState({
+				sourceMessages: persistedMessages,
+				compactedMessages: [{ role: "user", content: "summary" }],
+				conversationId: sessionId,
+				updatedAt: "2026-01-01T00:00:00Z",
+			});
+			const sessionService = {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+					manifestPath: "/tmp/manifest-compaction-active.json",
+					messagesPath,
+					manifest,
+				}),
+				persistSessionMessages: vi.fn(),
+				persistSessionCompactionState: vi.fn(),
+				updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+				writeSessionManifest: vi.fn(),
+				listSessions: vi.fn().mockResolvedValue([
+					{
+						sessionId,
+						provider: "mock-provider",
+						model: "mock-model",
+						cwd: "/tmp/project",
+						workspaceRoot: "/tmp/project",
+						createdAt: "2026-01-01T00:00:00.000Z",
+						updatedAt: "2026-01-01T00:00:00.000Z",
+						status: "completed",
+						messagesPath,
+					},
+				]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			};
+			const createAgent = vi.fn().mockReturnValue({
+				run: vi.fn().mockResolvedValue(createResult()),
+				continue: vi.fn(),
+				abort: vi.fn(),
+				subscribeEvents: vi.fn().mockReturnValue(() => {}),
+				canStartRun: vi.fn().mockReturnValue(true),
+				getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+				getConversationId: vi.fn().mockReturnValue(sessionId),
+				restore: vi.fn(),
+				shutdown: vi.fn().mockResolvedValue(undefined),
+				getMessages: vi.fn().mockReturnValue(liveMessages),
+				messages: liveMessages,
+			});
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: {
+					build: vi.fn().mockReturnValue({
+						tools: [],
+						shutdown: vi.fn(),
+					}),
+				},
+				createAgent: createAgent as never,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({
+						sessionId,
+						compaction: {
+							enabled: true,
+							strategy: "basic",
+							compact: vi.fn().mockResolvedValue(undefined),
+						},
+					}),
+					initialMessages: liveMessages,
+					interactive: true,
+				}),
+			);
+
+			await expect(
+				manager.updateSessionCompactionState(sessionId, incoming),
+			).resolves.toEqual({ updated: true });
+			expect(sessionService.persistSessionCompactionState).toHaveBeenCalledWith(
+				sessionId,
+				incoming,
+			);
+			expect(createAgent.mock.results[0]?.value.restore).toHaveBeenCalledWith(
+				persistedMessages,
+			);
+			const prepareTurn = createAgent.mock.calls[0]?.[0]?.prepareTurn;
+			await expect(
+				prepareTurn?.({
+					agentId: "agent-root-1",
+					conversationId: sessionId,
+					parentAgentId: null,
+					iteration: 1,
+					abortSignal: new AbortController().signal,
+					systemPrompt: "",
+					tools: [],
+					messages: [
+						...persistedMessages,
+						{ role: "user", content: "next" },
+					] as MessageWithMetadata[],
+					apiMessages: [
+						...persistedMessages,
+						{ role: "user", content: "next" },
+					] as MessageWithMetadata[],
+					model: {
+						id: "mock-model",
+						provider: "mock-provider",
+						info: { id: "mock-model", maxInputTokens: 100_000 },
+					},
+				}),
+			).resolves.toEqual({
+				messages: [
+					{ role: "user", content: "summary" },
+					{ role: "user", content: "next" },
+				],
+			});
+		} finally {
+			rmSync(tempCwd, { recursive: true, force: true });
+		}
+	});
+
+	it("orders equal-length compaction updates by parsed timestamp", async () => {
+		const sessionId = "inactive-session";
+		const tempCwd = mkdtempSync(join(tmpdir(), "compaction-stale-"));
+		try {
+			const messagesPath = join(tempCwd, "messages.json");
+			const sourceMessages: MessageWithMetadata[] = [
+				{ role: "user", content: "source" },
+			];
+			writeFileSync(messagesPath, JSON.stringify(sourceMessages), "utf8");
+			const current = createSessionCompactionState({
+				sourceMessages,
+				compactedMessages: [{ role: "user", content: "current" }],
+				conversationId: sessionId,
+				updatedAt: "2026-01-01T00:00:00.500Z",
+			});
+			const incoming = createSessionCompactionState({
+				sourceMessages,
+				compactedMessages: [{ role: "user", content: "incoming" }],
+				conversationId: sessionId,
+				updatedAt: "2026-01-01T00:00:00Z",
+			});
+			const sessionService = {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				listSessions: vi.fn().mockResolvedValue([
+					{
+						sessionId,
+						provider: "mock-provider",
+						model: "mock-model",
+						cwd: "/tmp/project",
+						workspaceRoot: "/tmp/project",
+						createdAt: "2026-01-01T00:00:00.000Z",
+						updatedAt: "2026-01-01T00:00:00.000Z",
+						status: "running",
+						messagesPath,
+					},
+				]),
+				readSessionCompactionState: vi.fn().mockResolvedValue(current),
+				persistSessionCompactionState: vi.fn(),
+			};
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+			});
+
+			await expect(
+				manager.updateSessionCompactionState(sessionId, incoming),
+			).resolves.toEqual({ updated: false });
+			expect(
+				sessionService.persistSessionCompactionState,
+			).not.toHaveBeenCalled();
+		} finally {
+			rmSync(tempCwd, { recursive: true, force: true });
+		}
+	});
+
+	it("formats prompt in core and merges explicit + mention user files", async () => {
+		const tempCwd = mkdtempSync(join(tmpdir(), "core-session-format-"));
+		try {
+			const srcDir = join(tempCwd, "src");
+			const docsDir = join(tempCwd, "docs");
+			mkdirSync(srcDir, { recursive: true });
+			mkdirSync(docsDir, { recursive: true });
+			const mentionPath = join(srcDir, "app.ts");
+			const explicitPath = join(docsDir, "note.md");
+			writeFileSync(mentionPath, "export const v = 1;\n", "utf8");
+			writeFileSync(explicitPath, "note\n", "utf8");
+
+			const sessionId = "sess-format";
+			const manifest = createManifest(sessionId);
+			const sessionService = {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+					manifestPath: "/tmp/manifest-format.json",
+					messagesPath: "/tmp/messages-format.json",
+					manifest,
+				}),
+				persistSessionMessages: vi.fn(),
+				updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+				writeSessionManifest: vi.fn(),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			};
+			const run = vi.fn().mockResolvedValue(createResult({ text: "ok" }));
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: {
+					build: vi.fn().mockReturnValue({
+						tools: [],
+						shutdown: vi.fn(),
+					}),
+				},
+				createAgent: () =>
+					({
+						run,
+						continue: vi.fn(),
+						abort: vi.fn(),
+						subscribeEvents: vi.fn().mockReturnValue(() => {}),
+						canStartRun: vi.fn().mockReturnValue(true),
+						getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+						getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+						shutdown: vi.fn().mockResolvedValue(undefined),
+						getMessages: vi.fn().mockReturnValue([]),
+						messages: [],
+					}) as never,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({
+						sessionId,
+						cwd: join(tempCwd, "docs"),
+						workspaceRoot: tempCwd,
+					}),
+					interactive: true,
+				}),
+			);
+			await manager.runTurn({
+				sessionId,
+				prompt: '<user_input mode="act">explain @src/app.ts</user_input>',
+				userFiles: ["note.md"],
+			});
+
+			expect(run).toHaveBeenCalledWith(
+				'<user_input mode="act">explain @src/app.ts</user_input>',
+				undefined,
+				expect.arrayContaining([mentionPath, explicitPath]),
+			);
+		} finally {
+			rmSync(tempCwd, { recursive: true, force: true });
+		}
+	});
+
+	it("force refreshes and retries once when turn fails with auth error", async () => {
+		const sessionId = "sess-oauth-retry";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-oauth-retry.json",
+				messagesPath: "/tmp/messages-oauth-retry.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const updateConnectionDefaults = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				delegatedAgentConfigProvider: {
+					getRuntimeConfig: vi.fn(),
+					getConnectionConfig: vi.fn(),
+					updateConnectionDefaults,
+				},
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi
+			.fn()
+			.mockRejectedValueOnce(new Error("401 Unauthorized"))
+			.mockResolvedValueOnce(
+				createResult({
+					text: "retried",
+					usage: {
+						inputTokens: 9,
+						outputTokens: 4,
+						cacheReadTokens: 2,
+						cacheWriteTokens: 1,
+						totalCost: 0.11,
+					},
+					model: {
+						id: "claude-sonnet-4-6",
+						provider: "anthropic",
+						info: {
+							id: "claude-sonnet-4-6",
+							family: "claude-sonnet-4",
+						},
+					},
+					messages: [
+						{ role: "user", content: [{ type: "text", text: "hello" }] },
+						{ role: "assistant", content: [{ type: "text", text: "retried" }] },
+					],
+				}),
+			);
+		const restore = vi.fn();
+		const updateConnection = vi.fn();
+		const resolveProviderApiKey = vi
+			.fn()
+			.mockResolvedValueOnce(null)
+			.mockResolvedValueOnce({
+				apiKey: "oauth-access-new",
+				refreshed: true,
+			});
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			oauthTokenManager: {
+				resolveProviderApiKey,
+			} as never,
+			createAgent: () =>
+				({
+					run,
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					restore,
+					updateConnection,
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({
+					sessionId,
+					providerId: "openai-codex",
+					apiKey: "oauth-access-old",
+				}),
+				interactive: true,
+			}),
+		);
+		const result = await manager.runTurn({ sessionId, prompt: "hello" });
+
+		expect(result?.text).toBe("retried");
+		expect(run).toHaveBeenCalledTimes(2);
+		expect(restore).toHaveBeenCalledTimes(1);
+		expect(resolveProviderApiKey).toHaveBeenNthCalledWith(1, {
+			providerId: "openai-codex",
+			forceRefresh: undefined,
+		});
+		expect(resolveProviderApiKey).toHaveBeenNthCalledWith(2, {
+			providerId: "openai-codex",
+			forceRefresh: true,
+		});
+		expect(updateConnection).toHaveBeenCalledWith({
+			apiKey: "oauth-access-new",
+		});
+		expect(updateConnectionDefaults).toHaveBeenCalledWith({
+			apiKey: "oauth-access-new",
+		});
+		expect(sessionService.persistSessionMessages).toHaveBeenCalledTimes(1);
+		const persisted = (
+			sessionService.persistSessionMessages as ReturnType<typeof vi.fn>
+		).mock.calls[0]?.[1] as Array<Record<string, unknown>> | undefined;
+		expect(persisted?.[1]).toMatchObject({
+			role: "assistant",
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+				family: "claude-sonnet-4",
+			},
+			metrics: {
+				inputTokens: 9,
+				outputTokens: 4,
+				cacheReadTokens: 2,
+				cacheWriteTokens: 1,
+				cost: 0.11,
+			},
+		});
+	});
+
+	it("auto-continues when async teammate runs complete after lead turn", async () => {
+		const sessionId = "sess-team-auto-continue";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-auto-continue.json",
+				messagesPath: "/tmp/messages-team-auto-continue.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+
+		const run = vi.fn().mockImplementation(async () => {
+			onTeamEvent?.({
+				type: "run_started",
+				run: {
+					id: "run_0001",
+					agentId: "investigator",
+					status: "running",
+					message: "Investigate",
+					priority: 0,
+					retryCount: 0,
+					maxRetries: 0,
+					startedAt: new Date("2026-01-01T00:00:00.000Z"),
+				},
+			});
+			setTimeout(() => {
+				onTeamEvent?.({
+					type: "run_completed",
+					run: {
+						id: "run_0001",
+						agentId: "investigator",
+						status: "completed",
+						message: "Investigate",
+						priority: 0,
+						retryCount: 0,
+						maxRetries: 0,
+						startedAt: new Date("2026-01-01T00:00:00.000Z"),
+						endedAt: new Date("2026-01-01T00:00:02.000Z"),
+						result: createResult({ iterations: 3 }),
+					},
+				});
+			}, 0);
+			return createResult({
+				text: "lead scheduled teammate",
+				messages: [
+					{ role: "user", content: "run teammate work" },
+					{ role: "assistant", content: "lead scheduled teammate" },
+				],
+			});
+		});
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "lead processed teammate result",
+				messages: [
+					{ role: "user", content: "run teammate work" },
+					{ role: "assistant", content: "lead scheduled teammate" },
+					{
+						role: "user",
+						content:
+							"System-delivered teammate async run updates:\n- investigator completed",
+					},
+					{ role: "assistant", content: "lead processed teammate result" },
+				],
+			}),
+		);
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				interactive: false,
+			}),
+		);
+		const result = await manager.runTurn({
+			sessionId,
+			prompt: "run teammate work",
+		});
+
+		expect(result?.text).toBe("lead processed teammate result");
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(continueFn).toHaveBeenCalledTimes(1);
+		expect(continueFn.mock.calls[0]?.[0]).toContain(
+			"System-delivered teammate async run updates:",
+		);
+		const finalPersistedMessages = (
+			sessionService.persistSessionMessages as ReturnType<typeof vi.fn>
+		).mock.calls.at(-1)?.[1] as Array<Record<string, unknown>> | undefined;
+		expect(finalPersistedMessages?.at(-1)).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 1,
+				outputTokens: 2,
+				cost: 0,
+			},
+			modelInfo: {
+				id: "mock-model",
+				provider: "mock-provider",
+			},
+		});
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"completed",
+			0,
+		);
+	});
+
+	it("persists failed teammate task messages for team-task sub-sessions", async () => {
+		const sessionId = "sess-team-task-failure-messages";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-task-failure-messages.json",
+				messagesPath: "/tmp/messages-team-task-failure-messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			onTeamTaskStart: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskEnd: vi.fn().mockResolvedValue(undefined),
+		};
+
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+
+		const failedMessages = [
+			{ role: "user", content: [{ type: "text", text: "delegated prompt" }] },
+			{ role: "assistant", content: [{ type: "text", text: "partial work" }] },
+		];
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						onTeamEvent?.({
+							type: "task_start",
+							agentId: "providers-investigator",
+							message: "Investigate provider boundaries",
+						});
+						onTeamEvent?.({
+							type: "task_end",
+							agentId: "providers-investigator",
+							error: new Error("401 Unauthorized"),
+							messages: failedMessages,
+						});
+						return createResult({ text: "lead handled failure" });
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "run teammate work",
+				interactive: false,
+			}),
+		);
+
+		expect(sessionService.onTeamTaskStart).toHaveBeenCalledTimes(1);
+		expect(sessionService.onTeamTaskEnd).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"failed",
+			"[error] 401 Unauthorized",
+			undefined,
+			failedMessages,
+		);
+	});
+
+	it("persists teammate progress updates for team-task sub-sessions", async () => {
+		const sessionId = "sess-team-task-progress";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-task-progress.json",
+				messagesPath: "/tmp/messages-team-task-progress.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			onTeamTaskStart: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskEnd: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskProgress: vi.fn().mockResolvedValue(undefined),
+		};
+
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+
+		const manager = new RuntimeHostUnderTest({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						onTeamEvent?.({
+							type: "task_start",
+							agentId: "providers-investigator",
+							message: "Investigate provider boundaries",
+						});
+						onTeamEvent?.({
+							type: "run_progress",
+							run: {
+								id: "run_00002",
+								agentId: "providers-investigator",
+								status: "running",
+								message: "Investigate provider boundaries",
+								priority: 0,
+								retryCount: 0,
+								maxRetries: 0,
+								continueConversation: false,
+								startedAt: new Date("2026-01-01T00:00:00.000Z"),
+								lastProgressAt: new Date("2026-01-01T00:00:01.000Z"),
+								lastProgressMessage: "heartbeat",
+								currentActivity: "heartbeat",
+							},
+							message: "heartbeat",
+						});
+						onTeamEvent?.({
+							type: "agent_event",
+							agentId: "providers-investigator",
+							event: {
+								type: "content_start",
+								contentType: "text",
+								text: "Drafting the provider boundary analysis now.",
+							},
+						});
+						onTeamEvent?.({
+							type: "task_end",
+							agentId: "providers-investigator",
+							result: createResult(),
+						});
+						return createResult({ text: "lead handled progress" });
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					subscribeEvents: vi.fn().mockReturnValue(() => {}),
+					canStartRun: vi.fn().mockReturnValue(true),
+					getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+					getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.startSession(
+			normalizeStartInput({
+				config: createConfig({ sessionId }),
+				prompt: "run teammate work",
+				interactive: false,
+			}),
+		);
+
+		expect(sessionService.onTeamTaskProgress).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"heartbeat",
+			{ kind: "heartbeat" },
+		);
+		expect(sessionService.onTeamTaskProgress).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"Drafting the provider boundary analysis now.",
+			{ kind: "text" },
+		);
+	});
+
+	describe("task.completed telemetry anchoring", () => {
+		function createTaskCompletedAdapter() {
+			return {
+				name: "task-completed-test",
+				emit: vi.fn(),
+				emitRequired: vi.fn(),
+				recordCounter: vi.fn(),
+				recordHistogram: vi.fn(),
+				recordGauge: vi.fn(),
+				isEnabled: vi.fn(() => true),
+				flush: vi.fn().mockResolvedValue(undefined),
+				dispose: vi.fn().mockResolvedValue(undefined),
+			};
+		}
+
+		function createSubmitAndExitToolCall(): NonNullable<
+			AgentResult["toolCalls"]
+		>[number] {
+			return {
+				id: "call-submit-1",
+				name: "submit_and_exit",
+				input: { result: "done" },
+				output: { ok: true },
+				durationMs: 1,
+				startedAt: new Date("2026-01-01T00:00:00.500Z"),
+				endedAt: new Date("2026-01-01T00:00:00.600Z"),
+			};
+		}
+
+		function createMockSessionService(manifest: SessionManifest) {
+			return {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+					manifestPath: "/tmp/manifest.json",
+					messagesPath: "/tmp/messages.json",
+					manifest,
+				}),
+				persistSessionMessages: vi.fn(),
+				updateSessionStatus: vi.fn().mockResolvedValue({
+					updated: true,
+					endedAt: "2026-01-01T00:00:05.000Z",
+				}),
+				writeSessionManifest: vi.fn(),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			};
+		}
+
+		function countTaskCompletedEmissions(
+			adapter: ReturnType<typeof createTaskCompletedAdapter>,
+		): Array<Record<string, unknown>> {
+			return adapter.emit.mock.calls
+				.filter(([event]) => event === "task.completed")
+				.map(([, payload]) => payload as Record<string, unknown>);
+		}
+
+		it("emits task.completed once with source=submit_and_exit when the assistant calls the completion tool in a non-interactive run", async () => {
+			const sessionId = "sess-task-completed-submit-non-interactive";
+			const manifest = createManifest(sessionId);
+			const adapter = createTaskCompletedAdapter();
+			const telemetry = new TelemetryService({
+				adapters: [adapter],
+				distinctId,
+			});
+			const sessionService = createMockSessionService(manifest);
+			const runtimeBuilder = {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			};
+			const agent = {
+				run: vi.fn().mockResolvedValue(
+					createResult({
+						toolCalls: [createSubmitAndExitToolCall()],
+					}),
+				),
+				continue: vi.fn(),
+				getMessages: vi.fn().mockReturnValue([]),
+				getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+				getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+				abort: vi.fn(),
+				subscribeEvents: vi.fn().mockReturnValue(() => {}),
+				canStartRun: vi.fn().mockReturnValue(true),
+				shutdown: vi.fn().mockResolvedValue(undefined),
+			};
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: runtimeBuilder as never,
+				createAgent: () => agent as never,
+				telemetry,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ telemetry, sessionId }),
+					prompt: "do a thing then submit_and_exit",
+					interactive: false,
+				}),
+			);
+
+			const emissions = countTaskCompletedEmissions(adapter);
+			expect(emissions).toHaveLength(1);
+			expect(emissions[0]).toMatchObject({
+				ulid: sessionId,
+				source: "submit_and_exit",
+				provider: "mock-provider",
+				modelId: "mock-model",
+			});
+		});
+
+		it("falls back to source=shutdown when a non-interactive run completes without submit_and_exit", async () => {
+			const sessionId = "sess-task-completed-shutdown-fallback";
+			const manifest = createManifest(sessionId);
+			const adapter = createTaskCompletedAdapter();
+			const telemetry = new TelemetryService({
+				adapters: [adapter],
+				distinctId,
+			});
+			const sessionService = createMockSessionService(manifest);
+			const runtimeBuilder = {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			};
+			const agent = {
+				// No `submit_and_exit` in toolCalls — represents a non-interactive
+				// run that finished cleanly without invoking the completion tool.
+				run: vi.fn().mockResolvedValue(createResult({ toolCalls: [] })),
+				continue: vi.fn(),
+				getMessages: vi.fn().mockReturnValue([]),
+				getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+				getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+				abort: vi.fn(),
+				subscribeEvents: vi.fn().mockReturnValue(() => {}),
+				canStartRun: vi.fn().mockReturnValue(true),
+				shutdown: vi.fn().mockResolvedValue(undefined),
+			};
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: runtimeBuilder as never,
+				createAgent: () => agent as never,
+				telemetry,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ telemetry, sessionId }),
+					prompt: "just finish",
+					interactive: false,
+				}),
+			);
+
+			const emissions = countTaskCompletedEmissions(adapter);
+			expect(emissions).toHaveLength(1);
+			expect(emissions[0]).toMatchObject({
+				ulid: sessionId,
+				source: "shutdown",
+			});
+		});
+
+		it("emits task.completed exactly once when an interactive turn invokes submit_and_exit and is later cancelled", async () => {
+			const sessionId = "sess-task-completed-interactive-then-cancel";
+			const manifest = createManifest(sessionId);
+			const adapter = createTaskCompletedAdapter();
+			const telemetry = new TelemetryService({
+				adapters: [adapter],
+				distinctId,
+			});
+			const sessionService = createMockSessionService(manifest);
+			const runtimeBuilder = {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			};
+			const agent = {
+				run: vi.fn().mockResolvedValue(
+					createResult({
+						toolCalls: [createSubmitAndExitToolCall()],
+					}),
+				),
+				continue: vi.fn(),
+				getMessages: vi.fn().mockReturnValue([]),
+				getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+				getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+				abort: vi.fn(),
+				subscribeEvents: vi.fn().mockReturnValue(() => {}),
+				canStartRun: vi.fn().mockReturnValue(true),
+				shutdown: vi.fn().mockResolvedValue(undefined),
+			};
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: runtimeBuilder as never,
+				createAgent: () => agent as never,
+				telemetry,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ telemetry, sessionId }),
+					prompt: "complete and remain attached",
+					interactive: true,
+				}),
+			);
+
+			// Simulate the user later closing the interactive session via stop.
+			await manager.stopSession(sessionId);
+
+			const emissions = countTaskCompletedEmissions(adapter);
+			expect(emissions).toHaveLength(1);
+			expect(emissions[0]).toMatchObject({
+				ulid: sessionId,
+				source: "submit_and_exit",
+			});
+		});
+
+		it("does not emit a duplicate task.completed when shutdownSession runs after a successful submit_and_exit observation", async () => {
+			const sessionId = "sess-task-completed-no-double-fire";
+			const manifest = createManifest(sessionId);
+			const adapter = createTaskCompletedAdapter();
+			const telemetry = new TelemetryService({
+				adapters: [adapter],
+				distinctId,
+			});
+			const sessionService = createMockSessionService(manifest);
+			const runtimeBuilder = {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			};
+			// Non-interactive: executeAgentTurn → finalizeSingleRun → shutdownSession,
+			// all in the same `startSession(...)` call. We must see exactly one emission.
+			const agent = {
+				run: vi.fn().mockResolvedValue(
+					createResult({
+						toolCalls: [createSubmitAndExitToolCall()],
+					}),
+				),
+				continue: vi.fn(),
+				getMessages: vi.fn().mockReturnValue([]),
+				getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+				getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+				abort: vi.fn(),
+				subscribeEvents: vi.fn().mockReturnValue(() => {}),
+				canStartRun: vi.fn().mockReturnValue(true),
+				shutdown: vi.fn().mockResolvedValue(undefined),
+			};
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: runtimeBuilder as never,
+				createAgent: () => agent as never,
+				telemetry,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ telemetry, sessionId }),
+					prompt: "do then submit_and_exit",
+					interactive: false,
+				}),
+			);
+
+			const emissions = countTaskCompletedEmissions(adapter);
+			expect(emissions).toHaveLength(1);
+			expect(emissions[0]).toMatchObject({ source: "submit_and_exit" });
+		});
+
+		it("ignores failed submit_and_exit tool calls so the shutdown fallback still fires", async () => {
+			const sessionId = "sess-task-completed-failed-submit";
+			const manifest = createManifest(sessionId);
+			const adapter = createTaskCompletedAdapter();
+			const telemetry = new TelemetryService({
+				adapters: [adapter],
+				distinctId,
+			});
+			const sessionService = createMockSessionService(manifest);
+			const runtimeBuilder = {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			};
+			const failedSubmitCall: NonNullable<AgentResult["toolCalls"]>[number] = {
+				...createSubmitAndExitToolCall(),
+				error: "missing required field",
+			};
+			const agent = {
+				run: vi.fn().mockResolvedValue(
+					createResult({
+						toolCalls: [failedSubmitCall],
+					}),
+				),
+				continue: vi.fn(),
+				getMessages: vi.fn().mockReturnValue([]),
+				getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+				getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+				abort: vi.fn(),
+				subscribeEvents: vi.fn().mockReturnValue(() => {}),
+				canStartRun: vi.fn().mockReturnValue(true),
+				shutdown: vi.fn().mockResolvedValue(undefined),
+			};
+			const manager = new RuntimeHostUnderTest({
+				distinctId,
+				sessionService: sessionService as never,
+				runtimeBuilder: runtimeBuilder as never,
+				createAgent: () => agent as never,
+				telemetry,
+			});
+
+			await manager.startSession(
+				normalizeStartInput({
+					config: createConfig({ telemetry, sessionId }),
+					prompt: "attempt submit but fail",
+					interactive: false,
+				}),
+			);
+
+			const emissions = countTaskCompletedEmissions(adapter);
+			expect(emissions).toHaveLength(1);
+			expect(emissions[0]).toMatchObject({ source: "shutdown" });
+		});
+	});
+});
diff --git a/sdk/packages/core/src/runtime/host/local-runtime-host.ts b/sdk/packages/core/src/runtime/host/local-runtime-host.ts
new file mode 100644
index 0000000..ed306c6
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local-runtime-host.ts
@@ -0,0 +1,2217 @@
+import { readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import {
+	type AgentConfig,
+	type AgentEvent,
+	type AgentResult,
+	captureSdkError,
+	createSessionId,
+	type ITelemetryService,
+	isLikelyAuthError,
+	normalizeUserInput,
+} from "@cline/shared";
+import { setHomeDirIfUnset } from "@cline/shared/storage";
+import { isOAuthProvider } from "../../auth/provider-auth-registry";
+import {
+	createCompactionStateAwarePrepareTurn,
+	createContextCompactionPrepareTurn,
+} from "../../extensions/context/compaction";
+import type { ToolExecutors } from "../../extensions/tools";
+import { DefaultToolNames } from "../../extensions/tools";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import { buildTelemetryAgentIdentity } from "../../services/agent-events";
+import { resolveWorkspacePath } from "../../services/config";
+import { prepareLocalRuntimeBootstrap } from "../../services/local-runtime-bootstrap";
+import { nowIso } from "../../services/session-artifacts";
+import {
+	toSessionRecord,
+	withLatestAssistantTurnMetadata,
+} from "../../services/session-data";
+import {
+	emitMentionTelemetry,
+	emitSessionCreationTelemetry,
+} from "../../services/session-telemetry";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+import {
+	captureAgentCreated,
+	captureAgentTeamCreated,
+	captureConversationTurnEvent,
+	captureModeSwitch,
+	captureTaskCompleted,
+} from "../../services/telemetry/core-events";
+import { resolveCoreDistinctId } from "../../services/telemetry/distinct-id";
+import {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+	summarizeUsageFromMessages,
+	sumUsageTotals,
+} from "../../services/usage";
+import { enrichPromptWithMentions } from "../../services/workspace";
+import {
+	projectSessionCompactionState,
+	type SessionCompactionState,
+} from "../../session/models/session-compaction";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "../../session/models/session-manifest";
+import type { SessionRow } from "../../session/models/session-row";
+import type { RootSessionArtifacts } from "../../session/services/session-service";
+import { createCoreSessionSnapshot } from "../../session/session-snapshot";
+import { SessionVersioningService } from "../../session/session-versioning-service";
+import {
+	buildTeamRunContinuationPrompt,
+	formatModePrompt,
+	hasPendingTeamRunWork,
+	notifyTeamRunWaiters,
+	shouldAutoContinueTeamRuns,
+	waitForTeamRunUpdates,
+} from "../../session/team";
+import {
+	isNonTerminalSessionStatus,
+	SessionSource,
+	type SessionStatus,
+} from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import type { CoreSessionEvent } from "../../types/events";
+import type { ActiveSession, PreparedTurnInput } from "../../types/session";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
+import { normalizeRuntimeCapabilities } from "../capabilities";
+import { normalizeConnectionUpdate } from "../config/connection-update";
+import { DefaultRuntimeBuilder } from "../orchestration/runtime-builder";
+import {
+	OAuthReauthRequiredError,
+	type RuntimeOAuthResolution,
+	RuntimeOAuthTokenManager,
+} from "../orchestration/runtime-oauth-token-manager";
+import type { RuntimeBuilder } from "../orchestration/session-runtime";
+import { SessionRuntime } from "../orchestration/session-runtime-orchestrator";
+import { PendingPromptsController } from "../turn-queue/pending-prompt-service";
+import { manifestToSessionRecord } from "./history";
+import { AgentEventBridge } from "./local/agent-event-bridge";
+import {
+	type SessionBackend,
+	toActiveSessionRecord,
+} from "./local/session-record";
+import {
+	invokeBackend,
+	invokeBackendOptional,
+	invokeBackendOptionalValue,
+} from "./local/session-service-invoker";
+import {
+	createSessionSpawnTool,
+	createSessionSubAgentLifecycleCallbacks,
+	type SubAgentStartTracker,
+} from "./local/spawn-tool";
+import { loadUserFileContent } from "./local/user-files";
+import type {
+	PendingPromptsServiceApi,
+	RestoreSessionInput,
+	RestoreSessionResult,
+	RuntimeHost,
+	RuntimeHostSubscribeOptions,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	SessionConnectionUpdate,
+	SessionUsageSummary,
+	StartSessionInput,
+	StartSessionResult,
+} from "./runtime-host";
+import { SessionNotFoundError } from "./runtime-host";
+import {
+	cloneAccumulatedUsage,
+	RuntimeHostEventBus,
+	readPersistedMessagesFile,
+	replaySubagentHookEvent,
+} from "./runtime-host-support";
+
+const MAX_SCAN_LIMIT = 5000;
+
+function asFiniteUsageNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function parseAccumulatedUsage(
+	value: unknown,
+): SessionAccumulatedUsage | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	const record = value as Record<string, unknown>;
+	const inputTokens = asFiniteUsageNumber(record.inputTokens);
+	const outputTokens = asFiniteUsageNumber(record.outputTokens);
+	const cacheReadTokens = asFiniteUsageNumber(record.cacheReadTokens);
+	const cacheWriteTokens = asFiniteUsageNumber(record.cacheWriteTokens);
+	const totalCost = asFiniteUsageNumber(record.totalCost);
+	if (
+		inputTokens === undefined ||
+		outputTokens === undefined ||
+		cacheReadTokens === undefined ||
+		cacheWriteTokens === undefined ||
+		totalCost === undefined
+	) {
+		return undefined;
+	}
+	return {
+		inputTokens,
+		outputTokens,
+		cacheReadTokens,
+		cacheWriteTokens,
+		totalCost,
+	};
+}
+
+function maxAccumulatedUsage(
+	left: SessionAccumulatedUsage,
+	right: SessionAccumulatedUsage,
+): SessionAccumulatedUsage {
+	return {
+		inputTokens: Math.max(left.inputTokens, right.inputTokens),
+		outputTokens: Math.max(left.outputTokens, right.outputTokens),
+		cacheReadTokens: Math.max(left.cacheReadTokens, right.cacheReadTokens),
+		cacheWriteTokens: Math.max(left.cacheWriteTokens, right.cacheWriteTokens),
+		totalCost: Math.max(left.totalCost, right.totalCost),
+	};
+}
+
+function isIncomingCompactionStateStale(
+	incoming: SessionCompactionState,
+	current: SessionCompactionState | undefined,
+): boolean {
+	if (!current) {
+		return false;
+	}
+	if (incoming.source_message_count !== current.source_message_count) {
+		return incoming.source_message_count < current.source_message_count;
+	}
+	return Date.parse(incoming.updated_at) < Date.parse(current.updated_at);
+}
+
+export interface LocalRuntimeHostOptions {
+	distinctId?: string;
+	sessionService: SessionBackend;
+	runtimeBuilder?: RuntimeBuilder;
+	createAgent?: (config: AgentConfig) => SessionRuntime;
+	capabilities?: RuntimeCapabilities;
+	toolPolicies?: AgentConfig["toolPolicies"];
+	providerSettingsManager?: ProviderSettingsManager;
+	oauthTokenManager?: RuntimeOAuthTokenManager;
+	telemetry?: ITelemetryService;
+	/**
+	 * Default custom `fetch` implementation threaded into every
+	 * `ProviderConfig.fetch` built during local session bootstrap. Used by
+	 * the AI gateway providers when issuing HTTP requests.
+	 */
+	fetch?: typeof fetch;
+}
+
+export class LocalRuntimeHost implements RuntimeHost {
+	public readonly runtimeAddress = undefined;
+	public readonly pendingPrompts: PendingPromptsServiceApi;
+	private readonly sessionService: SessionBackend;
+	private readonly runtimeBuilder: RuntimeBuilder;
+	private readonly createAgentInstance: (config: AgentConfig) => SessionRuntime;
+	private readonly toolExecutors?: Partial<ToolExecutors>;
+	private readonly defaultCapabilities?: RuntimeCapabilities;
+	private readonly defaultToolPolicies?: AgentConfig["toolPolicies"];
+	private readonly providerSettingsManager: ProviderSettingsManager;
+	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
+	private readonly defaultTelemetry?: ITelemetryService;
+	private readonly defaultFetch?: typeof fetch;
+	private readonly events = new RuntimeHostEventBus();
+	private readonly sessions = new Map<string, ActiveSession>();
+	// Serializes manifest read-modify-writes per session; see mutateSessionManifest.
+	private readonly manifestMutationQueues = new Map<string, Promise<void>>();
+	private readonly usageBySession = new Map<string, SessionAccumulatedUsage>();
+	private readonly aggregateUsageBySession = new Map<
+		string,
+		SessionAccumulatedUsage
+	>();
+	private readonly subAgentStarts: SubAgentStartTracker = new Map();
+	private readonly pendingPromptsController: PendingPromptsController;
+	private readonly eventBridge: AgentEventBridge;
+	private readonly sessionVersioning = new SessionVersioningService();
+
+	constructor(options: LocalRuntimeHostOptions) {
+		const homeDir = homedir();
+		if (homeDir) setHomeDirIfUnset(homeDir);
+		const distinctId = resolveCoreDistinctId(options.distinctId);
+		this.sessionService = options.sessionService;
+		this.runtimeBuilder = options.runtimeBuilder ?? new DefaultRuntimeBuilder();
+		this.createAgentInstance =
+			options.createAgent ?? ((config) => new SessionRuntime(config));
+		this.defaultCapabilities = normalizeRuntimeCapabilities(
+			options.capabilities,
+		);
+		this.toolExecutors = this.defaultCapabilities?.toolExecutors;
+		this.defaultToolPolicies = options.toolPolicies;
+		this.providerSettingsManager =
+			options.providerSettingsManager ?? new ProviderSettingsManager();
+		this.oauthTokenManager =
+			options.oauthTokenManager ??
+			new RuntimeOAuthTokenManager({
+				providerSettingsManager: this.providerSettingsManager,
+				telemetry: options.telemetry,
+			});
+		this.defaultTelemetry = options.telemetry;
+		this.defaultTelemetry?.setDistinctId(distinctId);
+		this.defaultFetch = options.fetch;
+
+		this.pendingPromptsController = new PendingPromptsController({
+			getSession: (sid) => this.sessions.get(sid),
+			emit: (event) => this.emit(event),
+			send: (input) => this.runTurn(input),
+		});
+		this.pendingPrompts = {
+			list: async (input) =>
+				this.pendingPromptsController.list(input.sessionId),
+			update: async (input) => this.pendingPromptsController.update(input),
+			delete: async (input) => this.pendingPromptsController.delete(input),
+		};
+		this.eventBridge = new AgentEventBridge({
+			getSession: (sid) => this.sessions.get(sid),
+			usageBySession: this.usageBySession,
+			aggregateUsageBySession: this.aggregateUsageBySession,
+			emit: (event) => this.emit(event),
+			persistMessages: (sid, messages, systemPrompt) => {
+				void this.invoke<void>(
+					"persistSessionMessages",
+					sid,
+					messages,
+					systemPrompt,
+				);
+			},
+			enqueuePendingPrompt: (sid, entry) =>
+				this.pendingPromptsController.enqueue(sid, entry),
+			invokeBackendOptional: (method, ...args) =>
+				this.invokeOptional(method, ...args),
+		});
+	}
+
+	private async applyInitialOAuthCredentials(
+		input: StartSessionInput,
+	): Promise<StartSessionInput> {
+		if (input.config.apiKey?.trim()) {
+			return input;
+		}
+
+		const resolved = await this.oauthTokenManager.resolveProviderApiKey({
+			providerId: input.config.providerId,
+		});
+		if (!resolved?.apiKey) {
+			return input;
+		}
+
+		return {
+			...input,
+			config: {
+				...input.config,
+				apiKey: resolved.apiKey,
+			},
+		};
+	}
+
+	// ── Public API ──────────────────────────────────────────────────────
+
+	async startSession(input: StartSessionInput): Promise<StartSessionResult> {
+		const source = input.source ?? SessionSource.CLI;
+		const startedAt = nowIso();
+		const requestedSessionId = input.config.sessionId?.trim() ?? "";
+		const sessionId = requestedSessionId || createSessionId();
+		const startInput: StartSessionInput =
+			await this.applyInitialOAuthCredentials(input);
+		const initialMessages = startInput.initialMessages ?? [];
+		const initialUsage =
+			initialMessages.length > 0
+				? summarizeUsageFromMessages(initialMessages)
+				: createInitialAccumulatedUsage();
+
+		const sessionsDir =
+			((await this.invokeOptionalValue("ensureSessionsDir")) as
+				| string
+				| undefined) ?? "";
+		if (!sessionsDir) {
+			throw new Error(
+				"session service method not available: ensureSessionsDir",
+			);
+		}
+
+		const sessionDir = join(sessionsDir, sessionId);
+		const messagesPath = join(sessionDir, `${sessionId}.messages.json`);
+		const manifestPath = join(sessionDir, `${sessionId}.json`);
+		const workspacePath = resolveWorkspacePath(input.config);
+
+		let manifest = SessionManifestSchema.parse({
+			version: 1,
+			session_id: sessionId,
+			source,
+			pid: process.pid,
+			started_at: startedAt,
+			status: "running",
+			interactive: input.interactive === true,
+			provider: startInput.config.providerId,
+			model: startInput.config.modelId,
+			cwd: startInput.config.cwd,
+			workspace_root: workspacePath,
+			team_name: startInput.config.teamName,
+			enable_tools: startInput.config.enableTools,
+			enable_spawn: startInput.config.enableSpawnAgent,
+			enable_teams: startInput.config.enableAgentTeams,
+			prompt: startInput.prompt?.trim() || undefined,
+			messages_path: messagesPath,
+		});
+		let resumedArtifacts: RootSessionArtifacts | undefined;
+		let resumedCompactionState: SessionCompactionState | undefined;
+		const isReadOnlyResumeStart =
+			requestedSessionId.length > 0 &&
+			initialMessages.length > 0 &&
+			!startInput.prompt?.trim();
+		if (isReadOnlyResumeStart) {
+			const existingManifest = await this.invokeOptionalValue<SessionManifest>(
+				"readSessionManifest",
+				sessionId,
+			);
+			if (existingManifest) {
+				manifest = existingManifest;
+				resumedArtifacts = {
+					manifestPath,
+					messagesPath: existingManifest.messages_path || messagesPath,
+					compactionPath: existingManifest.compaction_path,
+					manifest: existingManifest,
+				};
+				resumedCompactionState =
+					await this.invokeOptionalValue<SessionCompactionState>(
+						"readSessionCompactionState",
+						sessionId,
+					);
+			}
+		}
+		const initialAggregateUsage = await this.seedAggregateUsageFromArtifacts({
+			initialUsage,
+			sessionDir,
+			rootMessagesPath: resumedArtifacts?.messagesPath ?? messagesPath,
+			manifest,
+		});
+		this.usageBySession.set(sessionId, initialUsage);
+		this.aggregateUsageBySession.set(sessionId, initialAggregateUsage);
+
+		const capabilities = normalizeRuntimeCapabilities(
+			this.defaultCapabilities,
+			input.capabilities,
+		);
+		const sessionToolExecutors =
+			capabilities?.toolExecutors ?? this.toolExecutors;
+		const inputLocalConfig = input.localRuntime as
+			| Partial<CoreSessionConfig>
+			| undefined;
+		const pluginEventFallbackLogger =
+			inputLocalConfig?.extensionContext?.logger ?? inputLocalConfig?.logger;
+		const pluginEventFallbackAutomation =
+			inputLocalConfig?.extensionContext?.automation;
+		let bootstrap!: Awaited<ReturnType<typeof prepareLocalRuntimeBootstrap>>;
+		const subAgentDeps = {
+			getSession: (sid: string) => this.sessions.get(sid),
+			subAgentStarts: this.subAgentStarts,
+			onAgentEvent: (
+				rootSessionId: string,
+				config: CoreSessionConfig,
+				event: AgentEvent,
+			) => this.eventBridge.dispatchAgentEvent(rootSessionId, config, event),
+			invokeBackendOptional: (method: string, ...args: unknown[]) =>
+				this.invokeOptional(method, ...args),
+		};
+		bootstrap = await prepareLocalRuntimeBootstrap({
+			input: startInput,
+			localRuntime: input.localRuntime,
+			sessionId,
+			providerSettingsManager: this.providerSettingsManager,
+			defaultTelemetry: this.defaultTelemetry,
+			defaultCapabilities: capabilities,
+			defaultToolPolicies: this.defaultToolPolicies,
+			defaultFetch: this.defaultFetch,
+			onPluginEvent: (event) => {
+				if (event.name === "plugin_log") {
+					this.eventBridge.handlePluginLog(
+						sessionId,
+						event.payload,
+						pluginEventFallbackLogger,
+					);
+					return;
+				}
+				void this.eventBridge.handlePluginEvent(
+					sessionId,
+					event,
+					pluginEventFallbackAutomation,
+				);
+			},
+			onTeamEvent: (event: TeamEvent) => {
+				void this.eventBridge.handleTeamEvent(sessionId, event);
+				bootstrap.config.onTeamEvent?.(event);
+			},
+			createSpawnTool: () =>
+				createSessionSpawnTool(
+					subAgentDeps,
+					bootstrap.config,
+					sessionId,
+					sessionToolExecutors,
+				),
+			createSubAgentLifecycleCallbacks: (config) =>
+				createSessionSubAgentLifecycleCallbacks(
+					subAgentDeps,
+					config,
+					sessionId,
+				),
+			readSessionMetadata: async () =>
+				(await this.getSession(sessionId))?.metadata as
+					| Record<string, unknown>
+					| undefined,
+			writeSessionMetadata: async (metadata) => {
+				await this.persistSessionMetadata(sessionId, () => metadata);
+			},
+		});
+		const runtime = await this.runtimeBuilder.build(
+			bootstrap.runtimeBuilderInput,
+		);
+		const configWithProvider = bootstrap.config;
+		const providerConfig = bootstrap.providerConfig;
+		if (runtime.teamRuntime && !configWithProvider.teamName?.trim()) {
+			configWithProvider.teamName = runtime.teamRuntime.getTeamName();
+		}
+
+		const tools = [...runtime.tools, ...(configWithProvider.extraTools ?? [])];
+		const extensions = runtime.extensions ?? bootstrap.extensions;
+		const explicitInitialCompactionState = startInput.initialCompactionState;
+		let activeSessionRef: ActiveSession | undefined;
+		const compact = createContextCompactionPrepareTurn(configWithProvider);
+		const rawInitialCompactionState =
+			explicitInitialCompactionState ?? resumedCompactionState;
+		const initialCompactionState =
+			compact && rawInitialCompactionState
+				? {
+						...rawInitialCompactionState,
+						conversation_id:
+							rawInitialCompactionState.conversation_id?.trim() || sessionId,
+					}
+				: undefined;
+		const prepareTurn = compact
+			? createCompactionStateAwarePrepareTurn({
+					compact,
+					getState: () => activeSessionRef?.compactionState,
+					saveState: async (state) => {
+						const activeSession = activeSessionRef;
+						if (!activeSession) return;
+						const stateForSession = {
+							...state,
+							conversation_id: activeSession.sessionId,
+						};
+						try {
+							const result = await this.persistActiveSessionCompactionState(
+								activeSession,
+								stateForSession,
+							);
+							if (!result.updated) {
+								configWithProvider.logger?.debug?.(
+									"Skipped stale session compaction state",
+									{
+										sessionId: activeSession.sessionId,
+										sourceMessageCount: stateForSession.source_message_count,
+									},
+								);
+							}
+						} catch (error) {
+							configWithProvider.logger?.error?.(
+								"Failed to persist session compaction state",
+								{ sessionId: activeSession.sessionId, error },
+							);
+							captureSdkError(configWithProvider.telemetry, {
+								component: "core",
+								operation: "session.persist_compaction_state",
+								severity: "warn",
+								handled: true,
+								error,
+								context: {
+									sessionId: activeSession.sessionId,
+									providerId: configWithProvider.providerId,
+									modelId: configWithProvider.modelId,
+								},
+							});
+						}
+					},
+				})
+			: undefined;
+
+		const agentConfig = {
+			sessionId,
+			providerId: providerConfig.providerId,
+			modelId: providerConfig.modelId,
+			apiKey: providerConfig.apiKey,
+			baseUrl: providerConfig.baseUrl,
+			headers: providerConfig.headers,
+			knownModels: providerConfig.knownModels,
+			providerConfig,
+			thinking: configWithProvider.thinking,
+			reasoningEffort:
+				configWithProvider.reasoningEffort ?? providerConfig.reasoningEffort,
+			thinkingBudgetTokens: configWithProvider.thinkingBudgetTokens,
+			maxTokensPerTurn: configWithProvider.maxTokensPerTurn,
+			systemPrompt: configWithProvider.systemPrompt,
+			maxIterations: configWithProvider.maxIterations,
+			execution: configWithProvider.execution,
+			prepareTurn,
+			tools,
+			hooks: bootstrap.hooks,
+			extensions,
+			hookErrorMode: configWithProvider.hookErrorMode,
+			initialMessages: bootstrap.effectiveInput.initialMessages,
+			userFileContentLoader: loadUserFileContent,
+			toolPolicies: bootstrap.toolPolicies,
+			requestToolApproval: bootstrap.requestToolApproval
+				? async (request) => {
+						const requestToolApproval = bootstrap.requestToolApproval;
+						const liveSession = this.sessions.get(sessionId);
+						if (liveSession) {
+							await this.markTurnPending(liveSession);
+						}
+						try {
+							if (!requestToolApproval) {
+								return {
+									approved: false,
+									reason: "Tool approval callback is not configured.",
+								};
+							}
+							return await requestToolApproval(request);
+						} finally {
+							const currentSession = this.sessions.get(sessionId);
+							if (currentSession?.status === "pending") {
+								await this.markTurnRunning(currentSession);
+							}
+						}
+					}
+				: undefined,
+			telemetry: configWithProvider.telemetry,
+			onConsecutiveMistakeLimitReached:
+				configWithProvider.onConsecutiveMistakeLimitReached,
+			completionPolicy: runtime.completionPolicy,
+			consumePendingUserMessage: () => {
+				const entry = this.pendingPromptsController.consumeSteer(sessionId);
+				return entry
+					? formatModePrompt(
+							entry.prompt,
+							entry.mode ?? configWithProvider.mode,
+						)
+					: undefined;
+			},
+			logger: runtime.logger ?? configWithProvider.logger,
+			extensionContext: configWithProvider.extensionContext,
+			onEvent: (event: AgentEvent) =>
+				this.eventBridge.dispatchAgentEvent(
+					sessionId,
+					configWithProvider,
+					event,
+				),
+		} as AgentConfig;
+		agentConfig.hooks = {
+			...agentConfig.hooks,
+			onEvent: async (event) => {
+				await bootstrap.hooks?.onEvent?.(event);
+				if (event.type !== "assistant-message") return;
+				const liveSession = this.sessions.get(sessionId);
+				if (!liveSession) return;
+				const messages = liveSession.agent.getMessages();
+				try {
+					await this.invoke<void>(
+						"persistSessionMessages",
+						sessionId,
+						messages,
+						configWithProvider.systemPrompt,
+					);
+				} catch (error) {
+					configWithProvider.logger?.error?.(
+						"Failed to persist session messages after assistant response",
+						{ sessionId, error },
+					);
+					captureSdkError(configWithProvider.telemetry, {
+						component: "core",
+						operation: "session.persist_messages_after_assistant_response",
+						error,
+						severity: "warn",
+						handled: true,
+						context: {
+							sessionId,
+							providerId: configWithProvider.providerId,
+							modelId: configWithProvider.modelId,
+						},
+					});
+				}
+			},
+		};
+		const agent = this.createAgentInstance(agentConfig);
+		if (agentConfig.onEvent) {
+			agent.subscribeEvents(agentConfig.onEvent);
+		}
+		runtime.registerLeadAgent?.(agent);
+		const rootAgentIdentity = buildTelemetryAgentIdentity({
+			agentId: agent.getAgentId(),
+			conversationId: agent.getConversationId(),
+			teamId: runtime.teamRuntime?.getTeamId(),
+			teamName: runtime.teamRuntime?.getTeamName(),
+			teamRole: runtime.teamRuntime ? "lead" : undefined,
+		});
+		emitSessionCreationTelemetry(
+			configWithProvider,
+			sessionId,
+			requestedSessionId.length > 0,
+			workspacePath,
+			rootAgentIdentity,
+		);
+		if (rootAgentIdentity) {
+			captureAgentCreated(configWithProvider.telemetry, {
+				ulid: sessionId,
+				modelId: configWithProvider.modelId,
+				provider: configWithProvider.providerId,
+				...rootAgentIdentity,
+			});
+		}
+		if (runtime.teamRuntime) {
+			captureAgentTeamCreated(configWithProvider.telemetry, {
+				ulid: sessionId,
+				teamId: runtime.teamRuntime.getTeamId(),
+				teamName: runtime.teamRuntime.getTeamName(),
+				leadAgentId: agent.getAgentId(),
+				restoredFromPersistence: runtime.teamRestoredFromPersistence === true,
+			});
+		}
+
+		const active: ActiveSession = {
+			sessionId,
+			config: configWithProvider,
+			sessionMetadata: startInput.sessionMetadata,
+			...(resumedArtifacts ? { artifacts: resumedArtifacts } : {}),
+			source,
+			startedAt: resumedArtifacts?.manifest.started_at ?? startedAt,
+			updatedAt:
+				resumedArtifacts?.manifest.ended_at ??
+				resumedArtifacts?.manifest.started_at ??
+				startedAt,
+			pendingPrompt: manifest.prompt,
+			runtime,
+			agent,
+			started: false,
+			status: resumedArtifacts?.manifest.status ?? "running",
+			aborting: false,
+			interactive: input.interactive === true,
+			persistedMessages: initialMessages,
+			compactionState: initialCompactionState,
+			activeTeamRunIds: new Set<string>(),
+			pendingTeamRunUpdates: [],
+			teamRunWaiters: [],
+			pendingPrompts: [],
+			drainingPendingPrompts: false,
+			pluginSandboxShutdown: bootstrap.pluginSandboxShutdown,
+			submitAndExitObserved: false,
+			lastInteractiveTurnFinishReason: undefined,
+		};
+		activeSessionRef = active;
+		if (
+			active.compactionState &&
+			!this.isCompactionStateForSession(
+				active.sessionId,
+				active.compactionState,
+				active,
+			)
+		) {
+			active.config.logger?.log?.(
+				"Ignoring session compaction state for a different conversation",
+				{
+					severity: "warn",
+					sessionId: active.sessionId,
+					conversationId: active.compactionState.conversation_id,
+				},
+			);
+			active.compactionState = undefined;
+		}
+		this.sessions.set(sessionId, active);
+		this.emitStatus(sessionId, "running");
+		if (initialMessages.length > 0 && !resumedArtifacts) {
+			await this.ensureSessionPersisted(active);
+			await this.invoke<void>(
+				"persistSessionMessages",
+				active.sessionId,
+				initialMessages,
+				active.config.systemPrompt,
+			);
+			if (active.compactionState) {
+				const result = await this.persistActiveSessionCompactionState(
+					active,
+					active.compactionState,
+				);
+				if (!result.updated) {
+					active.compactionState = undefined;
+				}
+			}
+			if (!startInput.prompt?.trim()) {
+				await this.updateStatus(active, "completed", 0);
+			}
+		}
+
+		let result: AgentResult | undefined;
+		try {
+			if (startInput.prompt?.trim()) {
+				result = await this.executeTurn(active, {
+					prompt: startInput.prompt,
+					userImages: startInput.userImages,
+					userFiles: startInput.userFiles,
+				});
+				if (!active.interactive) {
+					await this.finalizeSingleRun(active, result.finishReason);
+				} else {
+					await this.completeInteractiveTurn(active, result.finishReason);
+				}
+			}
+		} catch (error) {
+			if (active.interactive && active.aborting) {
+				result = await this.completeAbortedInteractiveTurn(active);
+			} else {
+				captureSdkError(active.config.telemetry, {
+					component: "core",
+					operation: "session.start",
+					error,
+					severity: "error",
+					handled: false,
+					context: {
+						sessionId: active.sessionId,
+						providerId: active.config.providerId,
+						modelId: active.config.modelId,
+					},
+				});
+				try {
+					await this.failSession(active);
+				} catch (cleanupError) {
+					// Never let cleanup failures mask the error that actually
+					// killed the turn; that one is what callers must see.
+					active.config.logger?.error?.("Session failure cleanup threw", {
+						sessionId: active.sessionId,
+						error: cleanupError,
+					});
+				}
+				throw error;
+			}
+		}
+
+		return {
+			sessionId,
+			manifest,
+			manifestPath,
+			messagesPath,
+			result,
+		};
+	}
+
+	async restoreSession(
+		input: RestoreSessionInput,
+	): Promise<RestoreSessionResult> {
+		return this.sessionVersioning.restoreCheckpoint({
+			...input,
+			getSession: (sessionId) => this.getSession(sessionId),
+			readMessages: (sessionId) => this.readSessionMessages(sessionId),
+			buildStartInput: (context, startInput) => {
+				const sessionMetadata = context.restoredCheckpointMetadata
+					? {
+							...(startInput.sessionMetadata ?? {}),
+							checkpoint: context.restoredCheckpointMetadata,
+						}
+					: startInput.sessionMetadata;
+				return {
+					...startInput,
+					...(sessionMetadata ? { sessionMetadata } : {}),
+					initialMessages: context.initialMessages,
+				};
+			},
+			startSession: (startInput) => this.startSession(startInput),
+			getStartedSessionId: (startResult) => startResult.sessionId,
+			readRestoredSession: (sessionId) => this.getSession(sessionId),
+		});
+	}
+
+	async runTurn(input: SendSessionInput): Promise<AgentResult | undefined> {
+		const session = this.getSessionOrThrow(input.sessionId);
+		const canStartRun = session.agent.canStartRun();
+		const delivery =
+			input.delivery ??
+			(session.interactive && !canStartRun ? ("queue" as const) : undefined);
+		session.config.telemetry?.capture({
+			event: "session.input_sent",
+			properties: {
+				sessionId: input.sessionId,
+				promptLength: input.prompt.length,
+				userImageCount: input.userImages?.length ?? 0,
+				userFileCount: input.userFiles?.length ?? 0,
+				delivery: delivery ?? "immediate",
+			},
+		});
+		if (delivery === "queue" || delivery === "steer") {
+			this.pendingPromptsController.enqueue(input.sessionId, {
+				prompt: input.prompt,
+				mode: input.mode,
+				delivery,
+				userImages: input.userImages,
+				userFiles: input.userFiles,
+			});
+			return undefined;
+		}
+		try {
+			const result = await this.executeTurn(session, {
+				prompt: input.prompt,
+				mode: input.mode,
+				userImages: input.userImages,
+				userFiles: input.userFiles,
+			});
+			if (!session.interactive) {
+				await this.finalizeSingleRun(session, result.finishReason);
+			} else {
+				await this.completeInteractiveTurn(session, result.finishReason);
+			}
+			if (
+				result.finishReason === "error" ||
+				result.finishReason === "aborted"
+			) {
+				return result;
+			}
+			queueMicrotask(() => {
+				void this.pendingPromptsController.drain(input.sessionId);
+			});
+			return result;
+		} catch (error) {
+			if (session.interactive && session.aborting) {
+				return await this.completeAbortedInteractiveTurn(session);
+			}
+			captureSdkError(session.config.telemetry, {
+				component: "core",
+				operation: "session.submit",
+				error,
+				severity: "error",
+				handled: false,
+				context: {
+					sessionId: session.sessionId,
+					providerId: session.config.providerId,
+					modelId: session.config.modelId,
+				},
+			});
+			await this.failSession(session);
+			throw error;
+		}
+	}
+
+	async getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionUsageSummary | undefined> {
+		const usage = cloneAccumulatedUsage(this.usageBySession.get(sessionId));
+		const aggregateUsage = cloneAccumulatedUsage(
+			this.aggregateUsageBySession.get(sessionId),
+		);
+		return usage || aggregateUsage ? { usage, aggregateUsage } : undefined;
+	}
+
+	async abort(sessionId: string, reason?: unknown): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session) return;
+		session.config.telemetry?.capture({
+			event: "session.aborted",
+			properties: { sessionId },
+		});
+		session.aborting = true;
+		this.pendingPromptsController.clearAborted(session);
+		session.agent.abort(reason);
+	}
+
+	async stopSession(sessionId: string): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session) return;
+		session.config.telemetry?.capture({
+			event: "session.stopped",
+			properties: { sessionId },
+		});
+		if (session.interactive && !isNonTerminalSessionStatus(session.status)) {
+			await this.releaseSessionRuntime(session, "session_stop");
+			return;
+		}
+		if (session.interactive && session.agent.canStartRun()) {
+			await this.shutdownSession(session, {
+				status: this.resolveInteractiveStopStatus(session),
+				exitCode: this.resolveInteractiveStopExitCode(session),
+				shutdownReason: "session_stop",
+				endReason: "stopped",
+			});
+			return;
+		}
+		// Abort the agent first if it's running, so shutdown can proceed
+		session.aborting = true;
+		session.agent.abort(new Error("session_stop"));
+		await this.shutdownSession(session, {
+			status: "cancelled",
+			exitCode: 0,
+			shutdownReason: "session_stop",
+			endReason: "stopped",
+		});
+	}
+
+	async dispose(reason = "session_manager_dispose"): Promise<void> {
+		const sessions = [...this.sessions.values()];
+		if (sessions.length === 0) return;
+		await Promise.allSettled(
+			sessions.map((session) =>
+				session.interactive && !isNonTerminalSessionStatus(session.status)
+					? this.releaseSessionRuntime(session, reason)
+					: session.interactive && session.agent.canStartRun()
+						? this.shutdownSession(session, {
+								status: this.resolveInteractiveStopStatus(session),
+								exitCode: this.resolveInteractiveStopExitCode(session),
+								shutdownReason: reason,
+								endReason: "disposed",
+							})
+						: this.shutdownSession(session, {
+								status: "cancelled",
+								exitCode: 0,
+								shutdownReason: reason,
+								endReason: "disposed",
+							}),
+			),
+		);
+		this.usageBySession.clear();
+		this.aggregateUsageBySession.clear();
+	}
+
+	async getSession(sessionId: string): Promise<SessionRecord | undefined> {
+		const active = this.sessions.get(sessionId);
+		if (active) {
+			return toActiveSessionRecord(active);
+		}
+		const target = sessionId.trim();
+		if (!target) return undefined;
+		const row = await this.getRow(target);
+		if (row) return toSessionRecord(row);
+		const manifest = await this.readManifest(target);
+		return manifest ? manifestToSessionRecord(manifest) : undefined;
+	}
+
+	async listSessions(limit = 200): Promise<SessionRecord[]> {
+		const rows = await this.listRows(limit);
+		const persisted = rows.map(toSessionRecord);
+		const seen = new Set(persisted.map((row) => row.sessionId));
+		for (const active of this.sessions.values()) {
+			if (seen.has(active.sessionId)) {
+				continue;
+			}
+			persisted.unshift(toActiveSessionRecord(active));
+		}
+		return persisted.slice(0, limit);
+	}
+
+	async deleteSession(sessionId: string): Promise<boolean> {
+		if (this.sessions.has(sessionId)) {
+			await this.stopSession(sessionId);
+		}
+		const result = await this.invoke<{ deleted: boolean }>(
+			"deleteSession",
+			sessionId,
+		);
+		if (result.deleted) {
+			this.usageBySession.delete(sessionId);
+			this.aggregateUsageBySession.delete(sessionId);
+		}
+		return result.deleted;
+	}
+
+	async updateSession(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }> {
+		const result = await this.invokeOptionalValue<{ updated?: boolean }>(
+			"updateSession",
+			{
+				sessionId,
+				prompt: updates.prompt,
+				metadata: updates.metadata,
+				title: updates.title,
+			},
+		);
+		return { updated: result?.updated === true };
+	}
+
+	async updateSessionCompactionState(
+		sessionId: string,
+		state: SessionCompactionState,
+	): Promise<{ updated: boolean }> {
+		const target = sessionId.trim();
+		if (!target) return { updated: false };
+		const activeSession = this.sessions.get(target);
+		const sessionRecord = activeSession
+			? undefined
+			: await this.getSession(target);
+		const existing = activeSession ?? sessionRecord;
+		if (!existing) return { updated: false };
+		if (activeSession) {
+			const persistedMessages = await this.readSessionMessages(target);
+			const hasPersistedSource =
+				state.source_message_count > 0 &&
+				persistedMessages.length >= state.source_message_count;
+			const validationMessages = hasPersistedSource
+				? persistedMessages
+				: undefined;
+			if (hasPersistedSource) {
+				if (
+					!(await this.canPersistCompactionState(
+						target,
+						state,
+						activeSession,
+						undefined,
+						persistedMessages,
+					))
+				) {
+					return { updated: false };
+				}
+				activeSession.agent.restore(persistedMessages);
+			}
+			return await this.persistActiveSessionCompactionState(
+				activeSession,
+				state,
+				validationMessages,
+			);
+		}
+		if (
+			!(await this.canPersistCompactionState(
+				target,
+				state,
+				undefined,
+				sessionRecord,
+			))
+		) {
+			return { updated: false };
+		}
+		const current = await this.invokeOptionalValue<SessionCompactionState>(
+			"readSessionCompactionState",
+			target,
+		);
+		if (isIncomingCompactionStateStale(state, current)) {
+			return { updated: false };
+		}
+		await this.invoke<void>("persistSessionCompactionState", target, state);
+		return { updated: true };
+	}
+
+	async readSessionCompactionState(
+		sessionId: string,
+	): Promise<SessionCompactionState | undefined> {
+		const target = sessionId.trim();
+		if (!target) return undefined;
+		const activeSession = this.sessions.get(target);
+		if (activeSession) {
+			for (;;) {
+				const pendingWrite = activeSession.compactionStateWriteQueue;
+				if (!pendingWrite) {
+					return activeSession.compactionState;
+				}
+				await pendingWrite.catch(() => undefined);
+			}
+		}
+		return await this.invokeOptionalValue<SessionCompactionState>(
+			"readSessionCompactionState",
+			target,
+		);
+	}
+
+	private isCompactionStateForSession(
+		sessionId: string,
+		state: SessionCompactionState,
+		activeSession?: ActiveSession,
+		sessionRecord?: SessionRecord,
+	): boolean {
+		const conversationId = state.conversation_id?.trim();
+		if (!conversationId) {
+			return true;
+		}
+		if (conversationId === sessionId) {
+			return true;
+		}
+		const expectedConversationId =
+			activeSession?.agent.getConversationId()?.trim() ||
+			sessionRecord?.conversationId?.trim();
+		return expectedConversationId
+			? conversationId === expectedConversationId
+			: false;
+	}
+
+	private async canPersistCompactionState(
+		sessionId: string,
+		state: SessionCompactionState,
+		activeSession?: ActiveSession,
+		sessionRecord?: SessionRecord,
+		sourceMessages?: readonly LlmsProviders.Message[],
+	): Promise<boolean> {
+		if (!state.conversation_id?.trim()) {
+			return false;
+		}
+		if (
+			!this.isCompactionStateForSession(
+				sessionId,
+				state,
+				activeSession,
+				sessionRecord,
+			)
+		) {
+			return false;
+		}
+		const messagesForProjection =
+			sourceMessages ??
+			activeSession?.agent.getMessages() ??
+			(await this.readSessionMessages(sessionId));
+		return (
+			projectSessionCompactionState(state, messagesForProjection) !== undefined
+		);
+	}
+
+	private async persistActiveSessionCompactionState(
+		session: ActiveSession,
+		state: SessionCompactionState,
+		sourceMessages?: readonly LlmsProviders.Message[],
+	): Promise<{ updated: boolean }> {
+		if (
+			!(await this.canPersistCompactionState(
+				session.sessionId,
+				state,
+				session,
+				undefined,
+				sourceMessages,
+			))
+		) {
+			return { updated: false };
+		}
+		return await this.enqueueCompactionStateWrite(session, async () => {
+			if (isIncomingCompactionStateStale(state, session.compactionState)) {
+				return { updated: false };
+			}
+			await this.invoke<void>(
+				"persistSessionCompactionState",
+				session.sessionId,
+				state,
+			);
+			session.compactionState = state;
+			return { updated: true };
+		});
+	}
+
+	private async enqueueCompactionStateWrite<T>(
+		session: ActiveSession,
+		action: () => Promise<T>,
+	): Promise<T> {
+		const previous = session.compactionStateWriteQueue ?? Promise.resolve();
+		const run = previous.catch(() => undefined).then(action);
+		const tracked = run.then(
+			() => undefined,
+			() => undefined,
+		);
+		session.compactionStateWriteQueue = tracked;
+		try {
+			return await run;
+		} finally {
+			if (session.compactionStateWriteQueue === tracked) {
+				session.compactionStateWriteQueue = undefined;
+			}
+		}
+	}
+
+	async readSessionMessages(
+		sessionId: string,
+	): Promise<LlmsProviders.Message[]> {
+		const target = sessionId.trim();
+		if (!target) return [];
+		const row = await this.getRow(target);
+		if (row?.messagesPath) {
+			return readPersistedMessagesFile(row.messagesPath);
+		}
+		const manifest = await this.readManifest(target);
+		return readPersistedMessagesFile(manifest?.messages_path);
+	}
+
+	async dispatchHookEvent(payload: HookEventPayload): Promise<void> {
+		await replaySubagentHookEvent(payload, {
+			queueSpawnRequest: (event: HookEventPayload) =>
+				this.invokeOptional("queueSpawnRequest", event),
+			upsertSubagentSessionFromHook: (event: HookEventPayload) =>
+				this.invokeOptionalValue<string | undefined>(
+					"upsertSubagentSessionFromHook",
+					event,
+				),
+			appendSubagentHookAudit: (sessionId: string, event: HookEventPayload) =>
+				this.invokeOptional("appendSubagentHookAudit", sessionId, event),
+			applySubagentStatus: (sessionId: string, event: HookEventPayload) =>
+				this.invokeOptional("applySubagentStatus", sessionId, event),
+		});
+	}
+
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		return this.events.subscribe(listener, options);
+	}
+
+	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
+		await this.updateSessionConnection(sessionId, { modelId });
+	}
+
+	async updateSessionConnection(
+		sessionId: string,
+		rawUpdates: SessionConnectionUpdate,
+	): Promise<void> {
+		const updates = normalizeConnectionUpdate(rawUpdates);
+		const session = this.getSessionOrThrow(sessionId);
+		if (updates.providerId !== undefined)
+			session.config.providerId = updates.providerId;
+		if (updates.modelId !== undefined) session.config.modelId = updates.modelId;
+		if (updates.apiKey !== undefined) session.config.apiKey = updates.apiKey;
+		if (updates.baseUrl !== undefined) session.config.baseUrl = updates.baseUrl;
+		if (updates.headers !== undefined) session.config.headers = updates.headers;
+		if (updates.providerConfig !== undefined)
+			session.config.providerConfig = updates.providerConfig;
+		if (Object.hasOwn(updates, "reasoningEffort")) {
+			session.config.reasoningEffort = updates.reasoningEffort ?? undefined;
+		}
+		if (Object.hasOwn(updates, "thinkingBudgetTokens")) {
+			session.config.thinkingBudgetTokens =
+				updates.thinkingBudgetTokens ?? undefined;
+		}
+		if (Object.hasOwn(updates, "thinking")) {
+			session.config.thinking = updates.thinking ?? undefined;
+			if (updates.thinking === false || updates.thinking === null) {
+				session.config.reasoningEffort = undefined;
+				session.config.thinkingBudgetTokens = undefined;
+			}
+		}
+		const delegatedUpdates = {
+			...(updates.providerId !== undefined
+				? { providerId: updates.providerId }
+				: {}),
+			...(updates.modelId !== undefined ? { modelId: updates.modelId } : {}),
+			...(updates.apiKey !== undefined ? { apiKey: updates.apiKey } : {}),
+			...(updates.baseUrl !== undefined ? { baseUrl: updates.baseUrl } : {}),
+			...(updates.headers !== undefined ? { headers: updates.headers } : {}),
+			...(updates.providerConfig !== undefined
+				? { providerConfig: updates.providerConfig }
+				: {}),
+			...(Object.hasOwn(updates, "reasoningEffort")
+				? { reasoningEffort: updates.reasoningEffort ?? undefined }
+				: {}),
+			...(Object.hasOwn(updates, "thinking")
+				? { thinking: updates.thinking ?? undefined }
+				: {}),
+			...(Object.hasOwn(updates, "thinkingBudgetTokens")
+				? { thinkingBudgetTokens: updates.thinkingBudgetTokens ?? undefined }
+				: {}),
+		};
+		if (updates.thinking === false || updates.thinking === null) {
+			delegatedUpdates.reasoningEffort = undefined;
+			delegatedUpdates.thinkingBudgetTokens = undefined;
+		}
+		const teammateUpdates = {
+			...(updates.apiKey !== undefined ? { apiKey: updates.apiKey } : {}),
+			...(updates.baseUrl !== undefined ? { baseUrl: updates.baseUrl } : {}),
+			...(updates.headers !== undefined ? { headers: updates.headers } : {}),
+		};
+		session.runtime.delegatedAgentConfigProvider?.updateConnectionDefaults(
+			delegatedUpdates,
+		);
+		session.agent.updateConnection(updates);
+		session.runtime.teamRuntime?.updateTeammateConnections(teammateUpdates);
+		// Keep the persisted manifest in sync so session history reflects the
+		// connection the session is now using, not the one it started with.
+		if (updates.providerId || updates.modelId) {
+			await this.mutateSessionManifest(session, (manifest) => {
+				if (updates.providerId) manifest.provider = updates.providerId;
+				if (updates.modelId) manifest.model = updates.modelId;
+			});
+		}
+	}
+
+	/**
+	 * Serialized read-modify-write for a live session's manifest. Every
+	 * manifest write for an active session MUST go through this helper: it
+	 * re-reads the disk manifest first so disk-only writers (compaction-path
+	 * updates, title/metadata renames) are never reverted by a stale in-memory
+	 * copy, applies the field-level mutation, syncs the in-memory copy, and
+	 * persists — one mutation at a time per session.
+	 */
+	private async mutateSessionManifest(
+		session: ActiveSession,
+		mutate: (manifest: SessionManifest) => void,
+	): Promise<SessionManifest | undefined> {
+		const artifacts = session.artifacts;
+		if (!artifacts) return undefined;
+		const sessionId = session.sessionId;
+		const tail =
+			this.manifestMutationQueues.get(sessionId) ?? Promise.resolve();
+		const next = tail.then(async () => {
+			const latest =
+				(await this.invokeOptionalValue<SessionManifest>(
+					"readSessionManifest",
+					sessionId,
+				)) ?? artifacts.manifest;
+			mutate(latest);
+			artifacts.manifest = latest;
+			await this.invoke<void>(
+				"writeSessionManifest",
+				artifacts.manifestPath,
+				latest,
+			);
+			return latest;
+		});
+		const queued = next.then(
+			() => undefined,
+			() => undefined,
+		);
+		this.manifestMutationQueues.set(sessionId, queued);
+		try {
+			return await next;
+		} finally {
+			if (this.manifestMutationQueues.get(sessionId) === queued) {
+				this.manifestMutationQueues.delete(sessionId);
+			}
+		}
+	}
+
+	// Retained for unit tests that reach in via Reflect.
+	handlePluginEvent(
+		rootSessionId: string,
+		event: { name: string; payload?: unknown },
+		fallbackAutomation?: NonNullable<
+			CoreSessionConfig["extensionContext"]
+		>["automation"],
+	): Promise<void> {
+		return this.eventBridge.handlePluginEvent(
+			rootSessionId,
+			event,
+			fallbackAutomation,
+		);
+	}
+
+	// ── Turn execution ──────────────────────────────────────────────────
+
+	private async executeTurn(
+		session: ActiveSession,
+		input: {
+			prompt: string;
+			mode?: SendSessionInput["mode"];
+			userImages?: string[];
+			userFiles?: string[];
+		},
+	): Promise<AgentResult> {
+		const preparedInput = await this.prepareTurnInput(session, input);
+		const prompt = preparedInput.prompt.trim();
+		const images = preparedInput?.userImages?.length;
+		const files = preparedInput?.userFiles?.length;
+		if (!prompt && !images && !files) throw new Error("prompt cannot be empty");
+
+		if (!session.artifacts && !session.pendingPrompt) {
+			session.pendingPrompt = prompt;
+		}
+		await this.ensureSessionPersisted(session);
+		await this.syncOAuthCredentials(session);
+		await this.markTurnRunning(session);
+
+		let result = await this.executeAgentTurn(
+			session,
+			prompt,
+			preparedInput.userImages,
+			preparedInput.userFiles,
+		);
+
+		while (shouldAutoContinueTeamRuns(session, result.finishReason)) {
+			const updates = await waitForTeamRunUpdates(session);
+			if (updates.length === 0) break;
+			const continuationPrompt = buildTeamRunContinuationPrompt(
+				session,
+				updates,
+			);
+			result = await this.executeAgentTurn(session, continuationPrompt);
+		}
+
+		return result;
+	}
+
+	private async completeInteractiveTurn(
+		session: ActiveSession,
+		finishReason: AgentResult["finishReason"],
+	): Promise<void> {
+		if (hasPendingTeamRunWork(session)) return;
+		session.lastInteractiveTurnFinishReason = finishReason;
+		await this.markTurnIdle(session);
+		session.aborting = false;
+	}
+
+	private resolveInteractiveStopStatus(session: ActiveSession): SessionStatus {
+		const finishReason = session.lastInteractiveTurnFinishReason;
+		if (!finishReason) return "cancelled";
+
+		switch (finishReason) {
+			case "completed":
+				return "completed";
+			case "error":
+				return "failed";
+			case "aborted":
+			case "max_iterations":
+			case "mistake_limit":
+				return "cancelled";
+		}
+
+		const _exhaustive: never = finishReason;
+		return _exhaustive;
+	}
+
+	private resolveInteractiveStopExitCode(session: ActiveSession): number {
+		return session.lastInteractiveTurnFinishReason === "error" ? 1 : 0;
+	}
+
+	private async completeAbortedInteractiveTurn(
+		session: ActiveSession,
+	): Promise<AgentResult> {
+		const endedAt = new Date();
+		const messages = session.agent.getMessages();
+		const usage = createInitialAccumulatedUsage();
+		session.persistedMessages = messages;
+		session.started = session.started || messages.length > 0;
+		this.eventBridge.dispatchAgentEvent(session.sessionId, session.config, {
+			type: "done",
+			reason: "aborted",
+			text: "",
+			iterations: 0,
+			usage,
+		});
+		await this.completeInteractiveTurn(session, "aborted");
+		return {
+			text: "",
+			usage,
+			messages,
+			toolCalls: [],
+			iterations: 0,
+			finishReason: "aborted",
+			model: {
+				id: session.config.modelId,
+				provider: session.config.providerId,
+			},
+			startedAt: endedAt,
+			endedAt,
+			durationMs: 0,
+		};
+	}
+
+	private async executeAgentTurn(
+		session: ActiveSession,
+		prompt: string,
+		userImages?: string[],
+		userFiles?: string[],
+	): Promise<AgentResult> {
+		const shouldContinue =
+			session.started || session.agent.getMessages().length > 0;
+		const baselineMessages =
+			session.persistedMessages ?? session.agent.getMessages();
+		const usageBaseline =
+			this.usageBySession.get(session.sessionId) ??
+			createInitialAccumulatedUsage();
+		const aggregateUsageBaseline =
+			this.aggregateUsageBySession.get(session.sessionId) ?? usageBaseline;
+		session.turnUsageBaseline = usageBaseline;
+		session.turnAggregateUsageBaseline = aggregateUsageBaseline;
+		session.turnPrimaryUsage = createInitialAccumulatedUsage();
+		session.turnUsageByAgent = new Map<string, SessionAccumulatedUsage>();
+
+		captureModeSwitch(
+			session.config.telemetry,
+			session.sessionId,
+			session.config.mode,
+		);
+		captureConversationTurnEvent(session.config.telemetry, {
+			ulid: session.sessionId,
+			provider: session.config.providerId,
+			model: session.config.modelId,
+			source: "user",
+			mode: session.config.mode,
+			...this.getSessionAgentTelemetryIdentity(session),
+		});
+
+		try {
+			const runFn = shouldContinue
+				? () => session.agent.continue(prompt, userImages, userFiles)
+				: () => session.agent.run(prompt, userImages, userFiles);
+			const result = await this.runWithAuthRetry(
+				session,
+				runFn,
+				baselineMessages,
+			);
+
+			session.started = true;
+			const persistedMessages = withLatestAssistantTurnMetadata(
+				result.messages,
+				result,
+				baselineMessages,
+			);
+			session.persistedMessages = persistedMessages;
+			const teammateTurnUsage = sumUsageTotals(
+				session.turnUsageByAgent?.values() ?? [],
+			);
+			const accumulatedUsage = accumulateUsageTotals(
+				usageBaseline,
+				result.usage,
+			);
+			const aggregateTurnUsage = accumulateUsageTotals(
+				accumulateUsageTotals(createInitialAccumulatedUsage(), result.usage),
+				teammateTurnUsage,
+			);
+			const aggregateUsage = accumulateUsageTotals(
+				aggregateUsageBaseline,
+				aggregateTurnUsage,
+			);
+			this.usageBySession.set(session.sessionId, accumulatedUsage);
+			this.aggregateUsageBySession.set(session.sessionId, aggregateUsage);
+			await this.persistSessionMetadata(session.sessionId, (current) => ({
+				...(current ?? {}),
+				totalCost: accumulatedUsage.totalCost,
+				aggregatedAgentsCost: aggregateUsage.totalCost,
+				usage: accumulatedUsage,
+				aggregateUsage,
+			}));
+			await this.invoke<void>(
+				"persistSessionMessages",
+				session.sessionId,
+				persistedMessages,
+				session.config.systemPrompt,
+			);
+			this.observeTaskCompletionTool(session, result);
+			return result;
+		} catch (error) {
+			captureSdkError(session.config.telemetry, {
+				component: "core",
+				operation: "session.turn",
+				error,
+				severity: "error",
+				handled: false,
+				context: {
+					sessionId: session.sessionId,
+					providerId: session.config.providerId,
+					modelId: session.config.modelId,
+				},
+			});
+			await this.invoke<void>(
+				"persistSessionMessages",
+				session.sessionId,
+				session.agent.getMessages(),
+				session.config.systemPrompt,
+			);
+			throw error;
+		} finally {
+			session.turnUsageBaseline = undefined;
+			session.turnAggregateUsageBaseline = undefined;
+			session.turnPrimaryUsage = undefined;
+			session.turnUsageByAgent = undefined;
+		}
+	}
+
+	/**
+	 * Anchor `task.completed` telemetry to the assistant's explicit
+	 * completion declaration. We emit at most once per session, the moment
+	 * a successful `submit_and_exit` tool call is observed in the run
+	 * result. This is the SDK analog of original Cline's
+	 * `attempt_completion`-driven emission and works for both interactive
+	 * and non-interactive sessions.
+	 *
+	 * `shutdownSession(...)` retains a fallback emission for completed
+	 * sessions that finish without an explicit completion-tool observation
+	 * (e.g., non-interactive runs not using the yolo preset). This helper
+	 * sets `submitAndExitObserved` so the shutdown fallback can suppress a
+	 * duplicate emission for the same logical completion.
+	 */
+	private observeTaskCompletionTool(
+		session: ActiveSession,
+		result: AgentResult,
+	): void {
+		if (session.submitAndExitObserved) return;
+		const completedWithSubmitAndExit = result.toolCalls.some(
+			(call) =>
+				call.name === DefaultToolNames.SUBMIT_AND_EXIT &&
+				call.error === undefined,
+		);
+		if (!completedWithSubmitAndExit) return;
+		session.submitAndExitObserved = true;
+		captureTaskCompleted(session.config.telemetry, {
+			ulid: session.sessionId,
+			provider: session.config.providerId,
+			modelId: session.config.modelId,
+			mode: session.config.mode,
+			durationMs: Date.now() - Date.parse(session.startedAt),
+			source: "submit_and_exit",
+			...this.getSessionAgentTelemetryIdentity(session),
+		});
+	}
+
+	private async prepareTurnInput(
+		session: ActiveSession,
+		input: {
+			prompt: string;
+			mode?: SendSessionInput["mode"];
+			userImages?: string[];
+			userFiles?: string[];
+		},
+	): Promise<PreparedTurnInput> {
+		const mentionBaseDir = resolveWorkspacePath(session.config);
+		const normalizedPrompt = normalizeUserInput(input.prompt).trim();
+		if (!normalizedPrompt) {
+			return {
+				prompt: "",
+				userImages: input.userImages,
+				userFiles: this.resolveAbsoluteFilePaths(
+					session.config.cwd,
+					input.userFiles,
+				),
+			};
+		}
+
+		const enriched = await enrichPromptWithMentions(
+			normalizedPrompt,
+			mentionBaseDir,
+		);
+		emitMentionTelemetry(session.config.telemetry, enriched);
+
+		const prompt = formatModePrompt(
+			enriched.prompt,
+			input.mode ?? session.config.mode,
+		);
+		const explicitUserFiles = this.resolveAbsoluteFilePaths(
+			session.config.cwd,
+			input.userFiles,
+		);
+		const mentionedFiles = this.resolveAbsoluteFilePaths(
+			mentionBaseDir,
+			enriched.matchedFiles,
+		);
+		const mergedUserFiles = Array.from(
+			new Set([...explicitUserFiles, ...mentionedFiles]),
+		);
+
+		return {
+			prompt,
+			userImages: input.userImages,
+			userFiles: mergedUserFiles.length > 0 ? mergedUserFiles : undefined,
+		};
+	}
+
+	// ── Session lifecycle ───────────────────────────────────────────────
+
+	private async ensureSessionPersisted(session: ActiveSession): Promise<void> {
+		if (session.artifacts) return;
+		const workspacePath = resolveWorkspacePath(session.config);
+		session.artifacts = (await this.invoke("createRootSessionWithArtifacts", {
+			sessionId: session.sessionId,
+			source: session.source,
+			pid: process.pid,
+			interactive: session.interactive,
+			provider: session.config.providerId,
+			model: session.config.modelId,
+			cwd: session.config.cwd,
+			workspaceRoot: workspacePath,
+			teamName: session.config.teamName,
+			enableTools: session.config.enableTools,
+			enableSpawn: session.config.enableSpawnAgent,
+			enableTeams: session.config.enableAgentTeams,
+			prompt: session.pendingPrompt,
+			metadata: session.sessionMetadata,
+			startedAt: session.startedAt,
+		})) as RootSessionArtifacts;
+	}
+
+	private async markTurnRunning(session: ActiveSession): Promise<void> {
+		if (session.status === "running") return;
+		await this.updateStatus(session, "running", null);
+	}
+
+	private async markTurnPending(session: ActiveSession): Promise<void> {
+		if (session.status === "pending") return;
+		await this.updateStatus(session, "pending", null);
+	}
+
+	private async markTurnIdle(session: ActiveSession): Promise<void> {
+		if (session.status === "idle") return;
+		await this.updateStatus(session, "idle", null);
+	}
+
+	private async persistSessionMetadata(
+		sessionId: string,
+		resolveMetadata: (
+			current: Record<string, unknown> | undefined,
+		) => Record<string, unknown> | undefined,
+	): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		const currentManifest =
+			(await this.invokeOptionalValue<SessionManifest>(
+				"readSessionManifest",
+				sessionId,
+			)) ?? session?.artifacts?.manifest;
+		const metadata = resolveMetadata(
+			currentManifest?.metadata as Record<string, unknown> | undefined,
+		);
+		if (!session?.artifacts) {
+			return;
+		}
+		const result = await this.invokeOptionalValue<{ updated?: boolean }>(
+			"updateSession",
+			{
+				sessionId,
+				metadata,
+			},
+		);
+		if (result?.updated === false) {
+			return;
+		}
+		session.sessionMetadata = metadata;
+		session.artifacts.manifest.metadata = metadata;
+	}
+
+	private async finalizeSingleRun(
+		session: ActiveSession,
+		finishReason: AgentResult["finishReason"],
+	): Promise<void> {
+		if (hasPendingTeamRunWork(session)) return;
+		const isAborted = finishReason === "aborted" || session.aborting;
+		const isError = finishReason === "error";
+		await this.shutdownSession(session, {
+			status: isAborted ? "cancelled" : isError ? "failed" : "completed",
+			exitCode: isError ? 1 : 0,
+			shutdownReason: isError ? "session_error" : "session_complete",
+			endReason: finishReason,
+		});
+	}
+
+	private async failSession(session: ActiveSession): Promise<void> {
+		await this.shutdownSession(session, {
+			status: "failed",
+			exitCode: 1,
+			shutdownReason: "session_error",
+			endReason: "error",
+		});
+	}
+
+	private async shutdownSession(
+		session: ActiveSession,
+		input: {
+			status: SessionStatus;
+			exitCode: number | null;
+			shutdownReason: string;
+			endReason: string;
+		},
+	): Promise<void> {
+		// Fallback `task.completed` emission for completed sessions that
+		// did not observe an explicit `submit_and_exit` tool call. The
+		// observer in `executeAgentTurn(...)` already emitted the event in
+		// that case, so we suppress here to avoid double-counting.
+		if (input.status === "completed" && !session.submitAndExitObserved) {
+			captureTaskCompleted(session.config.telemetry, {
+				ulid: session.sessionId,
+				provider: session.config.providerId,
+				modelId: session.config.modelId,
+				mode: session.config.mode,
+				durationMs: Date.now() - Date.parse(session.startedAt),
+				source: "shutdown",
+				...this.getSessionAgentTelemetryIdentity(session),
+			});
+		}
+		notifyTeamRunWaiters(session);
+
+		const cleanupErrors: unknown[] = [];
+		const recordCleanupError = (stage: string, error: unknown) => {
+			cleanupErrors.push(error);
+			session.config.logger?.log("Session shutdown cleanup failed", {
+				sessionId: session.sessionId,
+				stage,
+				error,
+				severity: "warn",
+			});
+			captureSdkError(session.config.telemetry, {
+				component: "core",
+				operation: "session.shutdown_cleanup",
+				error,
+				severity: "warn",
+				handled: true,
+				context: {
+					sessionId: session.sessionId,
+					stage,
+					status: input.status,
+					shutdownReason: input.shutdownReason,
+					providerId: session.config.providerId,
+					modelId: session.config.modelId,
+				},
+			});
+		};
+
+		if (session.artifacts) {
+			try {
+				await this.updateStatus(session, input.status, input.exitCode);
+			} catch (error) {
+				recordCleanupError("update_status", error);
+			}
+			try {
+				await session.agent.shutdown(input.shutdownReason);
+			} catch (error) {
+				recordCleanupError("agent_shutdown", error);
+			}
+		}
+		try {
+			await Promise.resolve(session.runtime.shutdown(input.shutdownReason));
+		} catch (error) {
+			recordCleanupError("runtime_shutdown", error);
+		}
+		try {
+			await session.pluginSandboxShutdown?.();
+		} catch (error) {
+			recordCleanupError("plugin_sandbox_shutdown", error);
+		}
+		this.sessions.delete(session.sessionId);
+		this.emit({
+			type: "ended",
+			payload: {
+				sessionId: session.sessionId,
+				reason: input.endReason,
+				ts: Date.now(),
+			},
+		});
+		if (cleanupErrors.length > 0 && input.status === "failed") {
+			throw cleanupErrors[0];
+		}
+	}
+
+	private async releaseSessionRuntime(
+		session: ActiveSession,
+		reason: string,
+	): Promise<void> {
+		const cleanupErrors: unknown[] = [];
+		const recordCleanupError = (stage: string, error: unknown) => {
+			cleanupErrors.push(error);
+			session.config.logger?.log("Session runtime cleanup failed", {
+				sessionId: session.sessionId,
+				stage,
+				error,
+				severity: "warn",
+			});
+			captureSdkError(session.config.telemetry, {
+				component: "core",
+				operation: "session.runtime_cleanup",
+				error,
+				severity: "warn",
+				handled: true,
+				context: {
+					sessionId: session.sessionId,
+					stage,
+					reason,
+					providerId: session.config.providerId,
+					modelId: session.config.modelId,
+				},
+			});
+		};
+
+		try {
+			await session.agent.shutdown(reason);
+		} catch (error) {
+			recordCleanupError("agent_shutdown", error);
+		}
+		try {
+			await Promise.resolve(session.runtime.shutdown(reason));
+		} catch (error) {
+			recordCleanupError("runtime_shutdown", error);
+		}
+		try {
+			await session.pluginSandboxShutdown?.();
+		} catch (error) {
+			recordCleanupError("plugin_sandbox_shutdown", error);
+		}
+		this.sessions.delete(session.sessionId);
+		if (cleanupErrors.length > 0) {
+			throw cleanupErrors[0];
+		}
+	}
+
+	private async updateStatus(
+		session: ActiveSession,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): Promise<void> {
+		if (!session.artifacts) return;
+		const result = await this.invoke<{ updated: boolean; endedAt?: string }>(
+			"updateSessionStatus",
+			session.sessionId,
+			status,
+			exitCode,
+		);
+		if (!result.updated) return;
+		const latestManifest = await this.mutateSessionManifest(
+			session,
+			(manifest) => {
+				manifest.status = status;
+				if (isNonTerminalSessionStatus(status)) {
+					delete manifest.ended_at;
+					manifest.exit_code = null;
+				} else {
+					manifest.ended_at = result.endedAt ?? nowIso();
+					manifest.exit_code = typeof exitCode === "number" ? exitCode : null;
+				}
+			},
+		);
+		if (!latestManifest) return;
+		session.status = status;
+		session.updatedAt = result.endedAt ?? nowIso();
+		session.endedAt = isNonTerminalSessionStatus(status)
+			? null
+			: latestManifest.ended_at;
+		session.exitCode = latestManifest.exit_code;
+		this.emitStatus(session.sessionId, status);
+	}
+
+	// ── OAuth & auth ────────────────────────────────────────────────────
+
+	private async runWithAuthRetry(
+		session: ActiveSession,
+		run: () => Promise<AgentResult>,
+		baselineMessages: LlmsProviders.Message[],
+	): Promise<AgentResult> {
+		try {
+			return await run();
+		} catch (error) {
+			if (
+				!isOAuthProvider(session.config.providerId) ||
+				!isLikelyAuthError(error)
+			) {
+				throw error;
+			}
+			await this.syncOAuthCredentials(session, { forceRefresh: true });
+			session.agent.restore(baselineMessages);
+			return run();
+		}
+	}
+
+	private async syncOAuthCredentials(
+		session: ActiveSession,
+		options?: { forceRefresh?: boolean },
+	): Promise<void> {
+		let resolved: RuntimeOAuthResolution | null = null;
+		try {
+			resolved = await this.oauthTokenManager.resolveProviderApiKey({
+				providerId: session.config.providerId,
+				forceRefresh: options?.forceRefresh,
+			});
+		} catch (error) {
+			if (error instanceof OAuthReauthRequiredError) {
+				throw new Error(`${error.providerId} requires re-authentication.`);
+			}
+			throw error;
+		}
+		if (!resolved?.apiKey || session.config.apiKey === resolved.apiKey) return;
+		session.config.apiKey = resolved.apiKey;
+		session.agent.updateConnection({ apiKey: resolved.apiKey });
+		session.runtime.delegatedAgentConfigProvider?.updateConnectionDefaults({
+			apiKey: resolved.apiKey,
+		});
+		session.runtime.teamRuntime?.updateTeammateConnections({
+			apiKey: resolved.apiKey,
+		});
+	}
+
+	// ── Utility methods ─────────────────────────────────────────────────
+
+	private getSessionOrThrow(sessionId: string): ActiveSession {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			const error = new SessionNotFoundError(sessionId);
+			captureSdkError(this.defaultTelemetry, {
+				component: "core",
+				operation: "session.active_lookup",
+				error,
+				severity: "warn",
+				handled: true,
+				context: {
+					sessionId,
+					activeSessionCount: this.sessions.size,
+				},
+			});
+			throw error;
+		}
+		return session;
+	}
+
+	private resolveAbsoluteFilePaths(cwd: string, paths?: string[]): string[] {
+		if (!paths || paths.length === 0) return [];
+		const resolved = paths
+			.map((p) => p.trim())
+			.filter((p) => p.length > 0)
+			.map((p) => (isAbsolute(p) ? p : resolve(cwd, p)));
+		return Array.from(new Set(resolved));
+	}
+
+	private getSessionAgentTelemetryIdentity(session: ActiveSession) {
+		return buildTelemetryAgentIdentity({
+			agentId: session.agent.getAgentId(),
+			conversationId: session.agent.getConversationId(),
+			teamId: session.runtime.teamRuntime?.getTeamId(),
+			teamName: session.runtime.teamRuntime?.getTeamName(),
+			teamRole: session.runtime.teamRuntime ? "lead" : undefined,
+		});
+	}
+
+	private async seedAggregateUsageFromArtifacts(input: {
+		initialUsage: SessionAccumulatedUsage;
+		sessionDir: string;
+		rootMessagesPath: string;
+		manifest: SessionManifest;
+	}): Promise<SessionAccumulatedUsage> {
+		const teammateUsage = await this.summarizePersistedTeammateUsage(
+			input.sessionDir,
+			input.rootMessagesPath,
+			input.manifest.session_id,
+		);
+		const aggregateUsage = accumulateUsageTotals(
+			input.initialUsage,
+			teammateUsage,
+		);
+		return this.withPersistedAggregateUsageFloor(
+			aggregateUsage,
+			input.manifest,
+		);
+	}
+
+	private async summarizePersistedTeammateUsage(
+		sessionDir: string,
+		rootMessagesPath: string,
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage> {
+		const rootPath = resolve(rootMessagesPath);
+		const defaultRootMessagesFilename = `${sessionId}.messages.json`;
+		let filenames: string[];
+		try {
+			filenames = readdirSync(sessionDir);
+		} catch {
+			return createInitialAccumulatedUsage();
+		}
+
+		let usage = createInitialAccumulatedUsage();
+		for (const filename of filenames) {
+			if (!filename.endsWith(".messages.json")) continue;
+			if (filename === defaultRootMessagesFilename) continue;
+			const messagesPath = resolve(sessionDir, filename);
+			if (messagesPath === rootPath) continue;
+			const messages = await readPersistedMessagesFile(messagesPath);
+			if (messages.length === 0) continue;
+			usage = accumulateUsageTotals(
+				usage,
+				summarizeUsageFromMessages(messages),
+			);
+		}
+		return usage;
+	}
+
+	private withPersistedAggregateUsageFloor(
+		usage: SessionAccumulatedUsage,
+		manifest: SessionManifest,
+	): SessionAccumulatedUsage {
+		const persistedAggregateUsage = parseAccumulatedUsage(
+			manifest.metadata?.aggregateUsage,
+		);
+		if (persistedAggregateUsage) {
+			return maxAccumulatedUsage(usage, persistedAggregateUsage);
+		}
+		const aggregatedAgentsCost = manifest.metadata?.aggregatedAgentsCost;
+		if (
+			typeof aggregatedAgentsCost !== "number" ||
+			!Number.isFinite(aggregatedAgentsCost) ||
+			aggregatedAgentsCost <= usage.totalCost
+		) {
+			return usage;
+		}
+		return { ...usage, totalCost: aggregatedAgentsCost };
+	}
+
+	private emitStatus(sessionId: string, status: string): void {
+		void this.emitSessionSnapshot(sessionId);
+		this.emit({
+			type: "status",
+			payload: { sessionId, status },
+		});
+	}
+
+	private async emitSessionSnapshot(sessionId: string): Promise<void> {
+		const session = await this.getSession(sessionId);
+		if (!session) return;
+		this.emit({
+			type: "session_snapshot",
+			payload: {
+				sessionId,
+				snapshot: createCoreSessionSnapshot({
+					session,
+					messages: await this.readSessionMessages(sessionId),
+					usage: this.usageBySession.get(sessionId),
+					aggregateUsage: this.aggregateUsageBySession.get(sessionId),
+				}),
+			},
+		});
+	}
+
+	private emit(event: CoreSessionEvent): void {
+		this.events.emit(event);
+	}
+
+	private async listRows(limit: number): Promise<SessionRow[]> {
+		return this.invoke<SessionRow[]>(
+			"listSessions",
+			Math.min(Math.max(1, Math.floor(limit)), MAX_SCAN_LIMIT),
+		);
+	}
+
+	private async getRow(sessionId: string): Promise<SessionRow | undefined> {
+		const target = sessionId.trim();
+		if (!target) return undefined;
+		const rows = await this.listRows(MAX_SCAN_LIMIT);
+		return rows.find((row) => row.sessionId === target);
+	}
+
+	private async readManifest(
+		sessionId: string,
+	): Promise<SessionManifest | undefined> {
+		const target = sessionId.trim();
+		if (!target) return undefined;
+		return await this.invokeOptionalValue<SessionManifest>(
+			"readSessionManifest",
+			target,
+		);
+	}
+
+	// ── Session service invocation ──────────────────────────────────────
+
+	private invoke<T>(method: string, ...args: unknown[]): Promise<T> {
+		return invokeBackend<T>(this.sessionService, method, ...args);
+	}
+
+	private invokeOptional(method: string, ...args: unknown[]): Promise<void> {
+		return invokeBackendOptional(this.sessionService, method, ...args);
+	}
+
+	private invokeOptionalValue<T = unknown>(
+		method: string,
+		...args: unknown[]
+	): Promise<T | undefined> {
+		return invokeBackendOptionalValue<T>(this.sessionService, method, ...args);
+	}
+}
diff --git a/sdk/packages/core/src/runtime/host/local/agent-event-bridge.ts b/sdk/packages/core/src/runtime/host/local/agent-event-bridge.ts
new file mode 100644
index 0000000..f373d1e
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local/agent-event-bridge.ts
@@ -0,0 +1,231 @@
+import type {
+	AgentEvent,
+	AutomationEventEnvelope,
+	BasicLogger,
+	BasicLogMetadata,
+} from "@cline/shared";
+import type { TeamEvent } from "../../../extensions/tools/team";
+import {
+	type AgentEventContext,
+	buildTelemetryAgentIdentity,
+	extractAgentEventMetadata,
+	handleAgentEvent,
+} from "../../../services/agent-events";
+import { captureAgentCreated } from "../../../services/telemetry/core-events";
+import {
+	dispatchTeamEventToBackend,
+	emitTeamProgress,
+	trackTeamRunState,
+} from "../../../session/team";
+import type { CoreSessionConfig } from "../../../types/config";
+import type { CoreSessionEvent } from "../../../types/events";
+import type { ActiveSession } from "../../../types/session";
+import type { SessionRuntime } from "../../orchestration/session-runtime-orchestrator";
+import type { SessionAccumulatedUsage } from "../runtime-host";
+
+export interface AgentEventBridgeDeps {
+	getSession(sessionId: string): ActiveSession | undefined;
+	usageBySession: Map<string, SessionAccumulatedUsage>;
+	aggregateUsageBySession: Map<string, SessionAccumulatedUsage>;
+	emit(event: CoreSessionEvent): void;
+	persistMessages: AgentEventContext["persistMessages"];
+	enqueuePendingPrompt(
+		sessionId: string,
+		entry: { prompt: string; delivery: "queue" | "steer" },
+	): void;
+	invokeBackendOptional(method: string, ...args: unknown[]): Promise<void>;
+}
+
+export class AgentEventBridge {
+	constructor(private readonly deps: AgentEventBridgeDeps) {}
+
+	dispatchAgentEvent(
+		sessionId: string,
+		config: CoreSessionConfig,
+		event: AgentEvent,
+	): void {
+		const liveSession = this.deps.getSession(sessionId);
+		const ctx: AgentEventContext = {
+			sessionId,
+			config,
+			liveSession,
+			usageBySession: this.deps.usageBySession,
+			aggregateUsageBySession: this.deps.aggregateUsageBySession,
+			persistMessages: this.deps.persistMessages,
+			emit: this.deps.emit,
+		};
+		const eventMetadata = extractAgentEventMetadata(event);
+		const isRootAgentEvent =
+			!!liveSession &&
+			(!eventMetadata.agentId ||
+				eventMetadata.agentId === readAgentId(liveSession.agent));
+		handleAgentEvent(
+			ctx,
+			event,
+			isRootAgentEvent
+				? {
+						isPrimaryAgentEvent: true,
+						agentId: readAgentId(liveSession.agent),
+						conversationId: liveSession.agent.getConversationId(),
+						...(liveSession?.runtime.teamRuntime
+							? { teamRole: "lead" as const }
+							: {}),
+					}
+				: { isPrimaryAgentEvent: false },
+		);
+	}
+
+	async handleTeamEvent(
+		rootSessionId: string,
+		event: TeamEvent,
+	): Promise<void> {
+		const session = this.deps.getSession(rootSessionId);
+		if (session) {
+			trackTeamRunState(session, event);
+			if (event.type === "agent_event") {
+				const ctx: AgentEventContext = {
+					sessionId: rootSessionId,
+					config: session.config,
+					liveSession: session,
+					usageBySession: this.deps.usageBySession,
+					aggregateUsageBySession: this.deps.aggregateUsageBySession,
+					persistMessages: this.deps.persistMessages,
+					emit: this.deps.emit,
+				};
+				handleAgentEvent(ctx, event.event, {
+					agentId: event.agentId,
+					teamRole: "teammate",
+					teamAgentId: event.agentId,
+					isPrimaryAgentEvent: false,
+				});
+			}
+			if (event.type === "teammate_spawned") {
+				const agentIdentity = buildTelemetryAgentIdentity({
+					agentId: event.teammate.runtimeAgentId ?? event.agentId,
+					conversationId: event.teammate.conversationId,
+					parentAgentId: event.teammate.parentAgentId,
+					createdByAgentId: readAgentId(session.agent),
+					teamId: session.runtime.teamRuntime?.getTeamId(),
+					teamName: session.runtime.teamRuntime?.getTeamName(),
+					teamRole: "teammate",
+					teamAgentId: event.agentId,
+				});
+				if (agentIdentity) {
+					captureAgentCreated(session.config.telemetry, {
+						ulid: rootSessionId,
+						modelId: event.teammate.modelId ?? session.config.modelId,
+						provider: session.config.providerId,
+						...agentIdentity,
+					});
+				}
+			}
+		}
+
+		await dispatchTeamEventToBackend(
+			rootSessionId,
+			event,
+			this.deps.invokeBackendOptional,
+		);
+
+		if (session) {
+			emitTeamProgress(session, rootSessionId, event, this.deps.emit);
+		}
+	}
+
+	async handlePluginEvent(
+		rootSessionId: string,
+		event: { name: string; payload?: unknown },
+		fallbackAutomation?: NonNullable<
+			CoreSessionConfig["extensionContext"]
+		>["automation"],
+	): Promise<void> {
+		if (event.name === "plugin_log") {
+			this.handlePluginLog(rootSessionId, event.payload);
+			return;
+		}
+		if (event.name === "automation_event") {
+			const session = this.deps.getSession(rootSessionId);
+			const automation =
+				session?.config.extensionContext?.automation ?? fallbackAutomation;
+			if (!automation) return;
+			const payload =
+				event.payload && typeof event.payload === "object"
+					? (event.payload as AutomationEventEnvelope)
+					: undefined;
+			if (!payload) return;
+			await automation.ingestEvent(payload);
+			return;
+		}
+		if (
+			event.name !== "steer_message" &&
+			event.name !== "queue_message" &&
+			event.name !== "pending_prompt"
+		) {
+			return;
+		}
+		const payload =
+			event.payload && typeof event.payload === "object"
+				? (event.payload as Record<string, unknown>)
+				: undefined;
+		const targetSessionId =
+			typeof payload?.sessionId === "string" &&
+			payload.sessionId.trim().length > 0
+				? payload.sessionId.trim()
+				: rootSessionId;
+		const prompt =
+			typeof payload?.prompt === "string" ? payload.prompt.trim() : "";
+		if (!prompt) return;
+		const delivery: "queue" | "steer" =
+			event.name === "steer_message"
+				? "steer"
+				: event.name === "queue_message"
+					? "queue"
+					: payload?.delivery === "steer"
+						? "steer"
+						: "queue";
+		this.deps.enqueuePendingPrompt(targetSessionId, { prompt, delivery });
+	}
+
+	handlePluginLog(
+		rootSessionId: string,
+		payload: unknown,
+		fallbackLogger?: BasicLogger,
+	): void {
+		const session = this.deps.getSession(rootSessionId);
+		const logger =
+			fallbackLogger ??
+			session?.config.extensionContext?.logger ??
+			session?.config.logger;
+		if (!logger || !payload || typeof payload !== "object") return;
+		const record = payload as Record<string, unknown>;
+		const message = typeof record.message === "string" ? record.message : "";
+		if (!message) return;
+		const metadata =
+			record.metadata && typeof record.metadata === "object"
+				? ({
+						...(record.metadata as Record<string, unknown>),
+					} as BasicLogMetadata)
+				: {};
+		metadata.sessionId ??= rootSessionId;
+		if (typeof record.pluginName === "string" && record.pluginName) {
+			metadata.pluginName = record.pluginName;
+		}
+		if (record.level === "debug") {
+			logger.debug(message, metadata);
+			return;
+		}
+		if (record.level === "error") {
+			if (logger.error) {
+				logger.error(message, metadata);
+			} else {
+				logger.log(message, { ...metadata, severity: "error" });
+			}
+			return;
+		}
+		logger.log(message, metadata);
+	}
+}
+
+function readAgentId(agent: SessionRuntime): string {
+	return agent.getAgentId();
+}
diff --git a/sdk/packages/core/src/runtime/host/local/session-record.ts b/sdk/packages/core/src/runtime/host/local/session-record.ts
new file mode 100644
index 0000000..d8e2dcf
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local/session-record.ts
@@ -0,0 +1,52 @@
+import { resolveWorkspacePath } from "../../../services/config";
+import type { FileSessionService } from "../../../session/services/file-session-service";
+import type { CoreSessionService } from "../../../session/services/session-service";
+import type { ActiveSession } from "../../../types/session";
+import type { SessionRecord } from "../../../types/sessions";
+
+export type SessionBackend = CoreSessionService | FileSessionService;
+
+export function toActiveSessionRecord(session: ActiveSession): SessionRecord {
+	return {
+		sessionId: session.sessionId,
+		source: session.source,
+		pid: process.pid,
+		startedAt: session.startedAt,
+		endedAt: session.endedAt ?? null,
+		exitCode: session.exitCode ?? null,
+		status: session.status,
+		interactive: session.interactive,
+		provider: session.config.providerId,
+		model: session.config.modelId,
+		cwd: session.config.cwd,
+		workspaceRoot: resolveWorkspacePath(session.config),
+		teamName: session.config.teamName?.trim() || undefined,
+		enableTools: session.config.enableTools,
+		enableSpawn: session.config.enableSpawnAgent,
+		enableTeams: session.config.enableAgentTeams,
+		parentSessionId:
+			typeof session.sessionMetadata?.parentSessionId === "string"
+				? session.sessionMetadata.parentSessionId
+				: undefined,
+		parentAgentId:
+			typeof session.sessionMetadata?.parentAgentId === "string"
+				? session.sessionMetadata.parentAgentId
+				: undefined,
+		agentId:
+			typeof session.sessionMetadata?.agentId === "string"
+				? session.sessionMetadata.agentId
+				: undefined,
+		conversationId:
+			typeof session.sessionMetadata?.conversationId === "string"
+				? session.sessionMetadata.conversationId
+				: undefined,
+		isSubagent:
+			typeof session.sessionMetadata?.isSubagent === "boolean"
+				? session.sessionMetadata.isSubagent
+				: false,
+		prompt: session.pendingPrompt,
+		metadata: session.sessionMetadata,
+		messagesPath: session.artifacts?.messagesPath,
+		updatedAt: session.updatedAt ?? session.endedAt ?? session.startedAt,
+	};
+}
diff --git a/sdk/packages/core/src/runtime/host/local/session-service-invoker.ts b/sdk/packages/core/src/runtime/host/local/session-service-invoker.ts
new file mode 100644
index 0000000..986e485
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local/session-service-invoker.ts
@@ -0,0 +1,40 @@
+import type { SessionBackend } from "./session-record";
+
+type AnyMethod = (...args: unknown[]) => unknown;
+
+function getMethod(backend: SessionBackend, method: string): AnyMethod | null {
+	const callable = (backend as unknown as Record<string, unknown>)[method];
+	return typeof callable === "function" ? (callable as AnyMethod) : null;
+}
+
+export async function invokeBackend<T>(
+	backend: SessionBackend,
+	method: string,
+	...args: unknown[]
+): Promise<T> {
+	const callable = getMethod(backend, method);
+	if (!callable) {
+		throw new Error(`session service method not available: ${method}`);
+	}
+	return Promise.resolve(callable.apply(backend, args)) as Promise<T>;
+}
+
+export async function invokeBackendOptional(
+	backend: SessionBackend,
+	method: string,
+	...args: unknown[]
+): Promise<void> {
+	const callable = getMethod(backend, method);
+	if (!callable) return;
+	await Promise.resolve(callable.apply(backend, args));
+}
+
+export async function invokeBackendOptionalValue<T = unknown>(
+	backend: SessionBackend,
+	method: string,
+	...args: unknown[]
+): Promise<T | undefined> {
+	const callable = getMethod(backend, method);
+	if (!callable) return undefined;
+	return (await Promise.resolve(callable.apply(backend, args))) as T;
+}
diff --git a/sdk/packages/core/src/runtime/host/local/spawn-tool.ts b/sdk/packages/core/src/runtime/host/local/spawn-tool.ts
new file mode 100644
index 0000000..3a4cac4
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local/spawn-tool.ts
@@ -0,0 +1,187 @@
+import type { AgentEvent, AgentTool } from "@cline/shared";
+import {
+	createBuiltinTools,
+	resolveToolPresetName,
+	type ToolExecutors,
+	ToolPresets,
+} from "../../../extensions/tools";
+import type {
+	SubAgentEndContext,
+	SubAgentStartContext,
+} from "../../../extensions/tools/team";
+import { createSpawnAgentTool } from "../../../extensions/tools/team";
+import { buildTelemetryAgentIdentity } from "../../../services/agent-events";
+import { filterDisabledTools } from "../../../services/global-settings";
+import {
+	captureAgentCreated,
+	captureSubagentExecution,
+} from "../../../services/telemetry/core-events";
+import type { CoreSessionConfig } from "../../../types/config";
+import type { ActiveSession } from "../../../types/session";
+
+export type SubAgentStartTracker = Map<
+	string,
+	{ startedAt: number; rootSessionId: string }
+>;
+
+export interface SpawnToolDeps {
+	getSession(sessionId: string): ActiveSession | undefined;
+	subAgentStarts: SubAgentStartTracker;
+	onAgentEvent(
+		rootSessionId: string,
+		config: CoreSessionConfig,
+		event: AgentEvent,
+	): void;
+	invokeBackendOptional(method: string, ...args: unknown[]): Promise<void>;
+}
+
+export interface SessionSubAgentLifecycleCallbacks {
+	onSubAgentEvent: (event: AgentEvent) => void;
+	onSubAgentStart: (context: SubAgentStartContext) => void;
+	onSubAgentEnd: (context: SubAgentEndContext) => void;
+}
+
+export function createSessionSubAgentLifecycleCallbacks(
+	deps: SpawnToolDeps,
+	config: CoreSessionConfig,
+	rootSessionId: string,
+): SessionSubAgentLifecycleCallbacks {
+	return {
+		onSubAgentEvent: (event) => deps.onAgentEvent(rootSessionId, config, event),
+		onSubAgentStart: (context) => {
+			const teamRuntime = deps.getSession(rootSessionId)?.runtime.teamRuntime;
+			deps.subAgentStarts.set(context.subAgentId, {
+				startedAt: Date.now(),
+				rootSessionId,
+			});
+			const agentIdentity = buildTelemetryAgentIdentity({
+				agentId: context.subAgentId,
+				conversationId: context.conversationId,
+				parentAgentId: context.parentAgentId,
+				teamId: teamRuntime?.getTeamId(),
+				teamName: teamRuntime?.getTeamName(),
+				createdByAgentId: context.parentAgentId,
+			});
+			if (agentIdentity) {
+				captureAgentCreated(config.telemetry, {
+					ulid: rootSessionId,
+					modelId: config.modelId,
+					provider: config.providerId,
+					...agentIdentity,
+				});
+			}
+			captureSubagentExecution(config.telemetry, {
+				event: "started",
+				ulid: rootSessionId,
+				durationMs: 0,
+				parentId: context.parentAgentId,
+				agentId: context.subAgentId,
+				...agentIdentity,
+			});
+			void deps.invokeBackendOptional(
+				"handleSubAgentStart",
+				rootSessionId,
+				context,
+			);
+		},
+		onSubAgentEnd: (context) => {
+			const teamRuntime = deps.getSession(rootSessionId)?.runtime.teamRuntime;
+			const started = deps.subAgentStarts.get(context.subAgentId);
+			const durationMs = started ? Date.now() - started.startedAt : 0;
+			const outputLines = context.result?.text
+				? context.result.text.split("\n").length
+				: 0;
+			captureSubagentExecution(config.telemetry, {
+				event: "ended",
+				ulid: rootSessionId,
+				durationMs,
+				outputLines,
+				errorMessage: context.error ? String(context.error) : undefined,
+				agentId: context.subAgentId,
+				parentId: context.parentAgentId,
+				...buildTelemetryAgentIdentity({
+					agentId: context.subAgentId,
+					conversationId: context.conversationId,
+					parentAgentId: context.parentAgentId,
+					teamId: teamRuntime?.getTeamId(),
+					teamName: teamRuntime?.getTeamName(),
+					createdByAgentId: context.parentAgentId,
+				}),
+			});
+			deps.subAgentStarts.delete(context.subAgentId);
+			void deps.invokeBackendOptional(
+				"handleSubAgentEnd",
+				rootSessionId,
+				context,
+			);
+		},
+	};
+}
+
+export function createSessionSpawnTool(
+	deps: SpawnToolDeps,
+	config: CoreSessionConfig,
+	rootSessionId: string,
+	toolExecutors?: Partial<ToolExecutors>,
+): AgentTool {
+	const lifecycle = createSessionSubAgentLifecycleCallbacks(
+		deps,
+		config,
+		rootSessionId,
+	);
+	const createSubAgentTools = () => {
+		const tools: AgentTool[] = config.enableTools
+			? createBuiltinTools({
+					cwd: config.cwd,
+					...ToolPresets[resolveToolPresetName({ mode: config.mode })],
+					executors: toolExecutors,
+				})
+			: [];
+		if (config.enableSpawnAgent) {
+			tools.push(
+				createSessionSpawnTool(deps, config, rootSessionId, toolExecutors),
+			);
+		}
+		return filterDisabledTools(tools);
+	};
+
+	return createSpawnAgentTool({
+		configProvider: {
+			getRuntimeConfig: () =>
+				deps
+					.getSession(rootSessionId)
+					?.runtime.delegatedAgentConfigProvider?.getRuntimeConfig() ?? {
+					providerId: config.providerId,
+					modelId: config.modelId,
+					cwd: config.cwd,
+					apiKey: config.apiKey,
+					baseUrl: config.baseUrl,
+					headers: config.headers,
+					providerConfig: config.providerConfig,
+					knownModels: config.knownModels,
+					thinking: config.thinking,
+					maxIterations: config.maxIterations,
+					hooks: config.hooks,
+					extensions: config.extensions,
+					logger: config.logger,
+					telemetry: config.telemetry,
+				},
+			getConnectionConfig: () =>
+				deps
+					.getSession(rootSessionId)
+					?.runtime.delegatedAgentConfigProvider?.getConnectionConfig() ?? {
+					providerId: config.providerId,
+					modelId: config.modelId,
+					apiKey: config.apiKey,
+					baseUrl: config.baseUrl,
+					headers: config.headers,
+					providerConfig: config.providerConfig,
+					knownModels: config.knownModels,
+					thinking: config.thinking,
+				},
+			updateConnectionDefaults: () => {},
+		},
+		createSubAgentTools,
+		...lifecycle,
+	}) as AgentTool;
+}
diff --git a/sdk/packages/core/src/runtime/host/local/user-files.ts b/sdk/packages/core/src/runtime/host/local/user-files.ts
new file mode 100644
index 0000000..b9671ac
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/local/user-files.ts
@@ -0,0 +1,18 @@
+import { readFile, stat } from "node:fs/promises";
+
+const MAX_USER_FILE_BYTES = 20 * 1_000 * 1_024;
+
+export async function loadUserFileContent(path: string): Promise<string> {
+	const fileStat = await stat(path);
+	if (!fileStat.isFile()) {
+		throw new Error("Path is not a file");
+	}
+	if (fileStat.size > MAX_USER_FILE_BYTES) {
+		throw new Error("File is too large to read into context.");
+	}
+	const content = await readFile(path, "utf8");
+	if (content.includes("\u0000")) {
+		throw new Error("Cannot read binary file into context.");
+	}
+	return content;
+}
diff --git a/sdk/packages/core/src/runtime/host/runtime-host-support.test.ts b/sdk/packages/core/src/runtime/host/runtime-host-support.test.ts
new file mode 100644
index 0000000..6735926
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/runtime-host-support.test.ts
@@ -0,0 +1,61 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { readPersistedMessagesFile } from "./runtime-host-support";
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+	await Promise.allSettled(
+		tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })),
+	);
+});
+
+describe("readPersistedMessagesFile", () => {
+	it("returns persisted messages verbatim, wrappers included", async () => {
+		// The user_input wrapper records which mode each message was sent in
+		// and session restarts re-seed through this read path, so stripping
+		// here would destroy that history a little more on every restart.
+		// Display surfaces format for themselves via formatDisplayUserInput.
+		const dir = await mkdtemp(join(tmpdir(), "runtime-host-support-"));
+		tempDirs.push(dir);
+		const messagesPath = join(dir, "messages.json");
+		await writeFile(
+			messagesPath,
+			JSON.stringify([
+				{
+					role: "user",
+					content: '<user_input mode="act">spawn a team of agents</user_input>',
+				},
+				{
+					role: "assistant",
+					content: "Working on it.",
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "text",
+							text: '<user_input mode="plan"><mode_notice>The user switched from act mode to plan mode before sending this message.</mode_notice>\ninspect repo</user_input>',
+						},
+					],
+				},
+			]),
+			"utf8",
+		);
+
+		const messages = await readPersistedMessagesFile(messagesPath);
+
+		expect(messages[0]?.content).toBe(
+			'<user_input mode="act">spawn a team of agents</user_input>',
+		);
+		expect(messages[1]?.content).toBe("Working on it.");
+		expect(messages[2]?.content).toEqual([
+			{
+				type: "text",
+				text: '<user_input mode="plan"><mode_notice>The user switched from act mode to plan mode before sending this message.</mode_notice>\ninspect repo</user_input>',
+			},
+		]);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/host/runtime-host-support.ts b/sdk/packages/core/src/runtime/host/runtime-host-support.ts
new file mode 100644
index 0000000..66a9022
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/runtime-host-support.ts
@@ -0,0 +1,114 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import type * as LlmsProviders from "@cline/llms";
+import type { HookEventPayload } from "../../hooks";
+import type { CoreSessionEvent } from "../../types/events";
+import type {
+	RuntimeHostSubscribeOptions,
+	SessionAccumulatedUsage,
+} from "./runtime-host";
+
+export class RuntimeHostEventBus {
+	private readonly listeners = new Set<{
+		listener: (event: CoreSessionEvent) => void;
+		sessionId?: string;
+	}>();
+
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void {
+		const entry = {
+			listener,
+			sessionId: options?.sessionId?.trim() || undefined,
+		};
+		this.listeners.add(entry);
+		return () => {
+			this.listeners.delete(entry);
+		};
+	}
+
+	emit(event: CoreSessionEvent): void {
+		const sessionId = event.payload.sessionId?.trim();
+		for (const entry of this.listeners) {
+			if (entry.sessionId && entry.sessionId !== sessionId) {
+				continue;
+			}
+			entry.listener(event);
+		}
+	}
+
+	get size(): number {
+		return this.listeners.size;
+	}
+}
+
+// Returns the persisted messages verbatim. User messages keep their
+// runtime-generated <user_input mode="..."> wrappers and <mode_notice>
+// elements: they are the durable record of which mode each message was sent
+// in, and session restarts re-seed new sessions through this read path, so
+// stripping here would launder that history off disk (and out of the model's
+// context) a little more on every restart. Display surfaces are responsible
+// for their own formatting via formatDisplayUserInput.
+export async function readPersistedMessagesFile(
+	messagesPath?: string | null,
+): Promise<LlmsProviders.Message[]> {
+	const path = messagesPath?.trim();
+	if (!path || !existsSync(path)) return [];
+	try {
+		const raw = (await readFile(path, "utf8")).trim();
+		if (!raw) return [];
+		const parsed = JSON.parse(raw) as unknown;
+		if (Array.isArray(parsed)) {
+			return parsed as LlmsProviders.Message[];
+		}
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			const messages = (parsed as { messages?: unknown }).messages;
+			if (Array.isArray(messages)) {
+				return messages as LlmsProviders.Message[];
+			}
+		}
+		return [];
+	} catch {
+		return [];
+	}
+}
+
+export function cloneAccumulatedUsage(
+	usage: SessionAccumulatedUsage | undefined,
+): SessionAccumulatedUsage | undefined {
+	return usage ? { ...usage } : undefined;
+}
+
+type HookAuditBackend = {
+	queueSpawnRequest(payload: HookEventPayload): Promise<void>;
+	upsertSubagentSessionFromHook(
+		payload: HookEventPayload,
+	): Promise<string | undefined>;
+	appendSubagentHookAudit(
+		sessionId: string,
+		payload: HookEventPayload,
+	): Promise<void>;
+	applySubagentStatus(
+		sessionId: string,
+		payload: HookEventPayload,
+	): Promise<void>;
+};
+
+export async function replaySubagentHookEvent(
+	payload: HookEventPayload,
+	backend: HookAuditBackend,
+): Promise<void> {
+	const shouldTouchSessions =
+		payload.hookName === "tool_call" || !!payload.parent_agent_id;
+	if (!shouldTouchSessions) {
+		return;
+	}
+	await backend.queueSpawnRequest(payload);
+	const subSessionId = await backend.upsertSubagentSessionFromHook(payload);
+	if (!subSessionId) {
+		return;
+	}
+	await backend.appendSubagentHookAudit(subSessionId, payload);
+	await backend.applySubagentStatus(subSessionId, payload);
+}
diff --git a/sdk/packages/core/src/runtime/host/runtime-host.ts b/sdk/packages/core/src/runtime/host/runtime-host.ts
new file mode 100644
index 0000000..c9f43be
--- /dev/null
+++ b/sdk/packages/core/src/runtime/host/runtime-host.ts
@@ -0,0 +1,338 @@
+import type * as LlmsProviders from "@cline/llms";
+import type {
+	AgentMode,
+	AgentResult,
+	RuntimeConfigExtensionKind,
+} from "@cline/shared";
+import type { HookEventPayload } from "../../hooks";
+import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
+import type { ProviderSettings } from "../../services/llms/provider-settings";
+import type { SessionCompactionState } from "../../session/models/session-compaction";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionSource } from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import type {
+	CoreSessionEvent,
+	SessionPendingPrompt,
+} from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
+import type { ConnectionUpdate } from "../config/connection-update";
+
+export const SESSION_NOT_FOUND_ERROR_CODE = "session_not_found";
+
+export class SessionNotFoundError extends Error {
+	readonly code = SESSION_NOT_FOUND_ERROR_CODE;
+
+	constructor(
+		readonly sessionId?: string,
+		message?: string,
+	) {
+		super(
+			message ??
+				(sessionId ? `session not found: ${sessionId}` : "session not found"),
+		);
+		this.name = "SessionNotFoundError";
+	}
+}
+
+export function isSessionNotFoundError(
+	error: unknown,
+): error is SessionNotFoundError {
+	return (
+		error instanceof SessionNotFoundError ||
+		(typeof error === "object" &&
+			error !== null &&
+			"code" in error &&
+			(error as { code?: unknown }).code === SESSION_NOT_FOUND_ERROR_CODE)
+	);
+}
+
+type LocalOnlyCoreSessionConfigKeys =
+	| "hooks"
+	| "logger"
+	| "telemetry"
+	| "extensionContext"
+	| "extraTools"
+	| "extensions"
+	| "onTeamEvent"
+	| "onConsecutiveMistakeLimitReached";
+
+export type RuntimeSessionConfig = Omit<
+	CoreSessionConfig,
+	LocalOnlyCoreSessionConfigKeys | "checkpoint" | "compaction"
+> & {
+	checkpoint?: Omit<
+		NonNullable<CoreSessionConfig["checkpoint"]>,
+		"createCheckpoint"
+	>;
+	compaction?: Omit<NonNullable<CoreSessionConfig["compaction"]>, "compact">;
+};
+
+export type LocalRuntimeBootstrapConfig = Pick<
+	CoreSessionConfig,
+	LocalOnlyCoreSessionConfigKeys
+> & {
+	checkpoint?: Pick<
+		NonNullable<CoreSessionConfig["checkpoint"]>,
+		"createCheckpoint"
+	> &
+		Partial<NonNullable<CoreSessionConfig["checkpoint"]>>;
+	compaction?: Pick<NonNullable<CoreSessionConfig["compaction"]>, "compact"> &
+		Partial<NonNullable<CoreSessionConfig["compaction"]>>;
+};
+
+export interface LocalRuntimeStartOptions {
+	hooks?: LocalRuntimeBootstrapConfig["hooks"];
+	logger?: LocalRuntimeBootstrapConfig["logger"];
+	telemetry?: LocalRuntimeBootstrapConfig["telemetry"];
+	extensionContext?: LocalRuntimeBootstrapConfig["extensionContext"];
+	extraTools?: LocalRuntimeBootstrapConfig["extraTools"];
+	extensions?: LocalRuntimeBootstrapConfig["extensions"];
+	onTeamEvent?: LocalRuntimeBootstrapConfig["onTeamEvent"];
+	onConsecutiveMistakeLimitReached?: LocalRuntimeBootstrapConfig["onConsecutiveMistakeLimitReached"];
+	checkpoint?: LocalRuntimeBootstrapConfig["checkpoint"];
+	compaction?: LocalRuntimeBootstrapConfig["compaction"];
+	modelCatalogDefaults?: Partial<NonNullable<ProviderSettings["modelCatalog"]>>;
+	userInstructionService?: import("../../extensions/config").UserInstructionConfigService;
+	configExtensions?: RuntimeConfigExtensionKind[];
+	onTeamRestored?: () => void;
+}
+
+export interface StartSessionInput {
+	config: RuntimeSessionConfig;
+	source?: SessionSource;
+	prompt?: string;
+	interactive?: boolean;
+	sessionMetadata?: Record<string, unknown>;
+	initialMessages?: LlmsProviders.Message[];
+	initialCompactionState?: SessionCompactionState;
+	userImages?: string[];
+	userFiles?: string[];
+	/**
+	 * Host-local bootstrap options. These are intentionally isolated from the
+	 * transport-neutral runtime session config so all runtime hosts share the
+	 * same execution contract while still allowing host-specific preparation.
+	 */
+	localRuntime?: LocalRuntimeStartOptions;
+	capabilities?: RuntimeCapabilities;
+	toolPolicies?: import("@cline/shared").AgentConfig["toolPolicies"];
+}
+
+export function splitCoreSessionConfig(config: CoreSessionConfig): {
+	config: RuntimeSessionConfig;
+	localRuntime?: LocalRuntimeStartOptions;
+} {
+	const {
+		hooks,
+		logger,
+		telemetry,
+		extensionContext,
+		extraTools,
+		extensions,
+		onTeamEvent,
+		onConsecutiveMistakeLimitReached,
+		checkpoint,
+		compaction,
+		...transportConfig
+	} = config;
+
+	const localConfigOverrides: Partial<LocalRuntimeBootstrapConfig> = {};
+	if (hooks) localConfigOverrides.hooks = hooks;
+	if (logger) localConfigOverrides.logger = logger;
+	if (telemetry) localConfigOverrides.telemetry = telemetry;
+	if (extensionContext)
+		localConfigOverrides.extensionContext = extensionContext;
+	if (extraTools) localConfigOverrides.extraTools = extraTools;
+	if (extensions) localConfigOverrides.extensions = extensions;
+	if (onTeamEvent) localConfigOverrides.onTeamEvent = onTeamEvent;
+	if (onConsecutiveMistakeLimitReached) {
+		localConfigOverrides.onConsecutiveMistakeLimitReached =
+			onConsecutiveMistakeLimitReached;
+	}
+	if (checkpoint?.createCheckpoint) {
+		localConfigOverrides.checkpoint = checkpoint;
+	}
+	if (compaction?.compact) {
+		localConfigOverrides.compaction = compaction;
+	}
+
+	const localRuntime =
+		Object.keys(localConfigOverrides).length > 0
+			? (localConfigOverrides as LocalRuntimeStartOptions)
+			: undefined;
+
+	return {
+		config: {
+			...transportConfig,
+			...(checkpoint ? { checkpoint: { enabled: checkpoint.enabled } } : {}),
+			...(compaction
+				? {
+						compaction: {
+							enabled: compaction.enabled,
+							strategy: compaction.strategy,
+							thresholdRatio: compaction.thresholdRatio,
+							reserveTokens: compaction.reserveTokens,
+							preserveRecentTokens: compaction.preserveRecentTokens,
+							maxInputTokens: compaction.maxInputTokens,
+							summarizer: compaction.summarizer,
+						},
+					}
+				: {}),
+		},
+		...(localRuntime ? { localRuntime } : {}),
+	};
+}
+
+export interface StartSessionResult {
+	sessionId: string;
+	manifest: SessionManifest;
+	manifestPath: string;
+	messagesPath: string;
+	result?: AgentResult;
+}
+
+export interface SendSessionInput {
+	sessionId: string;
+	prompt: string;
+	mode?: AgentMode;
+	userImages?: string[];
+	userFiles?: string[];
+	delivery?: "queue" | "steer";
+	timeoutMs?: number;
+}
+
+export interface SessionAccumulatedUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalCost: number;
+}
+
+export interface SessionUsageSummary {
+	usage?: SessionAccumulatedUsage;
+	aggregateUsage?: SessionAccumulatedUsage;
+}
+
+export interface PendingPromptMutationResult {
+	sessionId: string;
+	prompts: SessionPendingPrompt[];
+	prompt?: SessionPendingPrompt;
+	updated?: boolean;
+	removed?: boolean;
+}
+
+export interface PendingPromptsListInput {
+	sessionId: string;
+}
+
+export interface PendingPromptsUpdateInput {
+	sessionId: string;
+	promptId: string;
+	prompt?: string;
+	mode?: AgentMode;
+	delivery?: "queue" | "steer";
+}
+
+export interface PendingPromptsDeleteInput {
+	sessionId: string;
+	promptId: string;
+}
+
+export interface PendingPromptsServiceApi {
+	list(input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>;
+	update(
+		input: PendingPromptsUpdateInput,
+	): Promise<PendingPromptMutationResult>;
+	delete(
+		input: PendingPromptsDeleteInput,
+	): Promise<PendingPromptMutationResult>;
+}
+
+export interface PendingPromptsRuntimeService {
+	readonly pendingPrompts: PendingPromptsServiceApi;
+}
+
+export interface SessionUsageRuntimeService {
+	getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionUsageSummary | undefined>;
+}
+
+export type SessionConnectionUpdate = ConnectionUpdate;
+
+export interface SessionModelRuntimeService {
+	updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+}
+
+export interface SessionConnectionRuntimeService {
+	updateSessionConnection(
+		sessionId: string,
+		updates: SessionConnectionUpdate,
+	): Promise<void>;
+}
+
+export interface RuntimeHostSubscribeOptions {
+	sessionId?: string;
+}
+
+export interface RestoreSessionInput {
+	sessionId: string;
+	checkpointRunCount: number;
+	cwd?: string;
+	restore?: {
+		messages?: boolean;
+		workspace?: boolean;
+		omitCheckpointMessageFromSession?: boolean;
+	};
+	start?: StartSessionInput;
+}
+
+export interface RestoreSessionResult {
+	sessionId?: string;
+	startResult?: StartSessionResult;
+	messages?: LlmsProviders.Message[];
+	checkpoint: CheckpointEntry;
+}
+
+/**
+ * RuntimeHost is the transport/runtime boundary for core session execution.
+ * Callers must normalize broad local config into `RuntimeSessionConfig`
+ * plus optional named `localRuntime` bootstrap fields before invoking a host.
+ */
+export interface RuntimeHost {
+	readonly runtimeAddress?: string;
+	startSession(input: StartSessionInput): Promise<StartSessionResult>;
+	runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+	restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
+	stopSession(sessionId: string): Promise<void>;
+	dispose(reason?: string): Promise<void>;
+	getSession(sessionId: string): Promise<SessionRecord | undefined>;
+	listSessions(limit?: number): Promise<SessionRecord[]>;
+	deleteSession(sessionId: string): Promise<boolean>;
+	updateSession(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }>;
+	updateSessionCompactionState(
+		sessionId: string,
+		state: SessionCompactionState,
+	): Promise<{ updated: boolean }>;
+	readSessionCompactionState(
+		sessionId: string,
+	): Promise<SessionCompactionState | undefined>;
+	readSessionMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+	dispatchHookEvent(payload: HookEventPayload): Promise<void>;
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void;
+}
+
+export type RuntimeHostMode = "auto" | "local" | "hub" | "remote";
diff --git a/sdk/packages/core/src/runtime/index.ts b/sdk/packages/core/src/runtime/index.ts
new file mode 100644
index 0000000..d31998d
--- /dev/null
+++ b/sdk/packages/core/src/runtime/index.ts
@@ -0,0 +1,24 @@
+export {
+	createTeamName,
+	DefaultRuntimeBuilder,
+} from "./orchestration/runtime-builder";
+export type {
+	BuiltRuntime,
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	SessionRuntime,
+} from "./orchestration/session-runtime";
+export {
+	formatRulesForSystemPrompt,
+	isRuleEnabled,
+	mergeRulesForSystemPrompt,
+} from "./safety/rules";
+export {
+	type SandboxCallOptions,
+	SubprocessSandbox,
+	type SubprocessSandboxOptions,
+} from "./tools/subprocess-sandbox";
+export {
+	type DesktopToolApprovalOptions,
+	requestDesktopToolApproval,
+} from "./tools/tool-approval";
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-builder.configured-agent-execution.test.ts b/sdk/packages/core/src/runtime/orchestration/runtime-builder.configured-agent-execution.test.ts
new file mode 100644
index 0000000..95c62c4
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-builder.configured-agent-execution.test.ts
@@ -0,0 +1,325 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	type AgentConfig,
+	type AgentEvent,
+	type AgentExtension,
+	type AgentTool,
+	createContributionRegistry,
+	type Message,
+} from "@cline/shared";
+import { setHomeDir } from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { UserInstructionConfigService } from "../../extensions/config";
+import type { CoreSessionConfig } from "../../types/config";
+
+const runMock = vi.fn();
+const agentConstructorSpy = vi.fn();
+let eventListeners: Array<(event: AgentEvent) => void> = [];
+
+vi.mock("./session-runtime-orchestrator", () => {
+	return {
+		SessionRuntime: class MockSessionRuntime {
+			constructor(config: unknown) {
+				agentConstructorSpy(config);
+			}
+
+			getAgentId(): string {
+				return "configured-sub-agent";
+			}
+
+			getConversationId(): string {
+				return "configured-sub-conversation";
+			}
+
+			subscribeEvents(listener: (event: AgentEvent) => void): () => void {
+				eventListeners.push(listener);
+				return () => {
+					eventListeners = eventListeners.filter((entry) => entry !== listener);
+				};
+			}
+
+			async run(input: string): Promise<unknown> {
+				for (const listener of eventListeners) {
+					listener({
+						type: "notice",
+						noticeType: "status",
+						message: "configured agent running",
+					});
+				}
+				return runMock(input);
+			}
+		},
+	};
+});
+
+function makeBaseConfig(
+	overrides: Partial<CoreSessionConfig> = {},
+): CoreSessionConfig {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		apiKey: "key",
+		systemPrompt: "test",
+		cwd: process.cwd(),
+		enableTools: true,
+		enableSpawnAgent: true,
+		enableAgentTeams: false,
+		...overrides,
+	};
+}
+
+async function collectExtensionTools(
+	extensions?: AgentExtension[],
+): Promise<AgentTool[]> {
+	const registry = createContributionRegistry<
+		AgentExtension,
+		AgentTool,
+		Message[]
+	>({
+		extensions: extensions ?? [],
+	});
+	await registry.initialize();
+	return registry.getRegisteredTools();
+}
+
+describe("DefaultRuntimeBuilder configured agent execution", () => {
+	const previousHome = process.env.HOME;
+	const tempDirs: string[] = [];
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		eventListeners = [];
+		runMock.mockResolvedValue({
+			text: "configured result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: { inputTokens: 13, outputTokens: 8 },
+		});
+	});
+
+	afterEach(() => {
+		process.env.HOME = previousHome;
+		setHomeDir(previousHome ?? "~");
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("invokes configured agents with host callbacks, scoped tools, skills, overrides, and parent context", async () => {
+		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
+		const tempHome = mkdtempSync(join(tmpdir(), "cline-agent-home-"));
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "cline-agent-root-"));
+		const cwd = join(workspaceRoot, "packages", "app");
+		tempDirs.push(tempHome, workspaceRoot);
+		process.env.HOME = tempHome;
+		setHomeDir(tempHome);
+		mkdirSync(cwd, { recursive: true });
+
+		const agentsDir = join(workspaceRoot, ".cline", "agents");
+		const skillDir = join(workspaceRoot, ".cline", "skills", "commit");
+		mkdirSync(agentsDir, { recursive: true });
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(agentsDir, "reviewer.yml"),
+			`---
+name: reviewer
+description: Reviews code
+tools: Execute_Command, Read_File, Use_Skill
+skills: commit
+providerId: openai
+modelId: gpt-4.1
+maxIterations: 3
+---
+You are a reviewer.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: commit
+description: Commit messages
+---
+Write a concise commit message.`,
+			"utf8",
+		);
+
+		const requestToolApproval = vi.fn(async () => ({ approved: true }));
+		const onSubAgentEvent = vi.fn();
+		const onSubAgentStart = vi.fn();
+		const onSubAgentEnd = vi.fn();
+		const effectiveToolPolicies = {
+			"*": { autoApprove: false },
+			read_files: { enabled: false },
+		};
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd, workspaceRoot }),
+			configExtensions: [],
+			toolPolicies: effectiveToolPolicies,
+			requestToolApproval,
+			onSubAgentEvent,
+			onSubAgentStart,
+			onSubAgentEnd,
+		});
+
+		expect(
+			(await collectExtensionTools(runtime.extensions)).map(
+				(tool) => tool.name,
+			),
+		).not.toContain("skills");
+
+		const reviewer = runtime.tools.find(
+			(tool) => tool.name === "subagent_reviewer",
+		);
+		expect(reviewer).toBeDefined();
+		if (!reviewer) {
+			throw new Error("Expected configured reviewer tool.");
+		}
+
+		const output = await reviewer.execute(
+			{ prompt: "review this change" },
+			{
+				agentId: "parent-agent",
+				conversationId: "parent-conversation",
+				iteration: 1,
+			},
+		);
+
+		expect(output).toEqual({
+			text: "configured result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: { inputTokens: 13, outputTokens: 8 },
+		});
+		expect(runMock).toHaveBeenCalledWith("review this change");
+		expect(onSubAgentStart).toHaveBeenCalledWith(
+			expect.objectContaining({
+				subAgentId: "configured-sub-agent",
+				conversationId: "configured-sub-conversation",
+				parentAgentId: "parent-agent",
+				input: {
+					systemPrompt: "You are a reviewer.",
+					task: "review this change",
+				},
+			}),
+		);
+		expect(onSubAgentEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				type: "notice",
+				message: "configured agent running",
+			}),
+		);
+		expect(onSubAgentEnd).toHaveBeenCalledWith(
+			expect.objectContaining({
+				parentAgentId: "parent-agent",
+				result: output,
+			}),
+		);
+
+		const delegatedConfig = agentConstructorSpy.mock.calls.at(-1)?.[0] as
+			| AgentConfig
+			| undefined;
+		expect(delegatedConfig).toEqual(
+			expect.objectContaining({
+				providerId: "openai",
+				modelId: "gpt-4.1",
+				maxIterations: 3,
+				parentAgentId: "parent-agent",
+				requestToolApproval,
+				toolPolicies: effectiveToolPolicies,
+			}),
+		);
+		expect(delegatedConfig?.tools.map((tool) => tool.name).sort()).toEqual([
+			"run_commands",
+			"skills",
+		]);
+
+		const skillsTool = delegatedConfig?.tools.find(
+			(tool) => tool.name === "skills",
+		);
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected delegated skills tool.");
+		}
+		await expect(
+			skillsTool.execute(
+				{ skill: "commit" },
+				{ agentId: "configured-sub-agent", iteration: 1 },
+			),
+		).resolves.toContain("<command-name>commit</command-name>");
+		await expect(
+			skillsTool.execute(
+				{ skill: "review" },
+				{ agentId: "configured-sub-agent", iteration: 1 },
+			),
+		).resolves.toContain('Skill "review" not found.');
+
+		await runtime.shutdown("test");
+	});
+
+	it("does not require custom user instruction services to implement createSkillsExecutor", async () => {
+		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "cline-agent-compat-"));
+		tempDirs.push(workspaceRoot);
+		const agentsDir = join(workspaceRoot, ".cline", "agents");
+		mkdirSync(agentsDir, { recursive: true });
+		writeFileSync(
+			join(agentsDir, "reviewer.yml"),
+			`---
+name: reviewer
+description: Reviews code
+skills: commit
+---
+You are a reviewer.`,
+			"utf8",
+		);
+
+		const legacyService = {
+			start: vi.fn(async () => {}),
+			stop: vi.fn(),
+			refreshType: vi.fn(async () => {}),
+			listRecords: vi.fn(() => []),
+			listRuntimeCommands: vi.fn(() => []),
+			resolveRuntimeSlashCommand: vi.fn((input: string) => input),
+			hasConfiguredSkills: vi.fn(() => false),
+			createExtension: vi.fn(() => ({
+				name: "legacy-service",
+				manifest: { capabilities: [] },
+			})),
+		} as unknown as UserInstructionConfigService;
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd: workspaceRoot, workspaceRoot }),
+			configExtensions: [],
+			userInstructionService: legacyService,
+		});
+		const reviewer = runtime.tools.find(
+			(tool) => tool.name === "subagent_reviewer",
+		);
+		expect(reviewer).toBeDefined();
+		if (!reviewer) {
+			throw new Error("Expected configured reviewer tool.");
+		}
+
+		await expect(
+			reviewer.execute(
+				{ prompt: "review this change" },
+				{ agentId: "parent-agent", iteration: 1 },
+			),
+		).resolves.toEqual({
+			text: "configured result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: { inputTokens: 13, outputTokens: 8 },
+		});
+		const delegatedConfig = agentConstructorSpy.mock.calls.at(-1)?.[0] as
+			| AgentConfig
+			| undefined;
+		expect(delegatedConfig?.tools.map((tool) => tool.name)).not.toContain(
+			"skills",
+		);
+
+		await runtime.shutdown("test");
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-builder.team-persistence.test.ts b/sdk/packages/core/src/runtime/orchestration/runtime-builder.team-persistence.test.ts
new file mode 100644
index 0000000..1a78884
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-builder.team-persistence.test.ts
@@ -0,0 +1,290 @@
+import { describe, expect, it, vi } from "vitest";
+
+const createBuiltinToolsMock = vi.fn(() => []);
+const bootstrapAgentTeamsMock = vi.fn(() => ({
+	tools: [],
+	restoredFromPersistence: true,
+	restoredTeammates: ["restored-1"],
+}));
+
+let runtimeInstance: MockAgentTeamsRuntime | undefined;
+type MockTeamEvent = Record<string, unknown>;
+type BootstrapCall = {
+	teammateConfigProvider: {
+		getRuntimeConfig(): unknown;
+	};
+};
+
+class MockAgentTeamsRuntime {
+	private readonly onTeamEvent?: (event: MockTeamEvent) => void;
+
+	constructor(options: { onTeamEvent?: (event: MockTeamEvent) => void }) {
+		this.onTeamEvent = options.onTeamEvent;
+		runtimeInstance = this;
+	}
+
+	emit(event: MockTeamEvent): void {
+		this.onTeamEvent?.(event);
+	}
+
+	hydrateState = vi.fn();
+	exportState = vi.fn(() => ({
+		members: [],
+		tasks: [],
+		mailbox: [],
+		missionLog: [],
+		runs: [],
+		outcomes: [],
+		outcomeFragments: [],
+	}));
+	markStaleRunsInterrupted = vi.fn();
+	recoverActiveRuns = vi.fn();
+	getTeammateIds = vi.fn(() => []);
+	shutdownTeammate = vi.fn();
+}
+
+vi.mock("../../extensions/tools/team", () => ({
+	AgentTeamsRuntime: MockAgentTeamsRuntime,
+	bootstrapAgentTeams: bootstrapAgentTeamsMock,
+	createDelegatedAgentConfigProvider: (config: Record<string, unknown>) => {
+		let runtimeConfig = { ...config };
+		return {
+			getRuntimeConfig: () => runtimeConfig,
+			getConnectionConfig: () => ({
+				providerId: runtimeConfig.providerId,
+				modelId: runtimeConfig.modelId,
+				apiKey: runtimeConfig.apiKey,
+				baseUrl: runtimeConfig.baseUrl,
+				headers: runtimeConfig.headers,
+				providerConfig: runtimeConfig.providerConfig,
+				knownModels: runtimeConfig.knownModels,
+				thinking: runtimeConfig.thinking,
+			}),
+			updateConnectionDefaults: (overrides: Record<string, unknown>) => {
+				runtimeConfig = { ...runtimeConfig, ...overrides };
+			},
+		};
+	},
+}));
+
+vi.mock("../../extensions/tools", () => ({
+	ALL_DEFAULT_TOOL_NAMES: [],
+	createBuiltinTools: createBuiltinToolsMock,
+	ToolPresets: {
+		development: {},
+		readonly: {},
+	},
+	resolveToolPresetName: () => "development",
+	resolveToolRoutingConfig: () => [],
+	DEFAULT_MODEL_TOOL_ROUTING_RULES: [],
+}));
+
+let teamStoreInstance: MockTeamStore | undefined;
+class MockTeamStore {
+	constructor() {
+		teamStoreInstance = this;
+	}
+
+	loadRuntime = vi.fn(() => ({
+		state: {
+			teamId: "team_1",
+			teamName: "test",
+			members: [],
+			tasks: [],
+			mailbox: [],
+			missionLog: [],
+			runs: [],
+			outcomes: [],
+			outcomeFragments: [],
+		},
+		teammates: [
+			{
+				agentId: "restored-1",
+				rolePrompt: "Persisted teammate",
+				modelId: "claude-sonnet-4-5-20250929",
+				maxIterations: 4,
+			},
+		],
+		interruptedRunIds: [],
+	}));
+	handleTeamEvent = vi.fn();
+	persistRuntime = vi.fn();
+}
+
+vi.mock("../../services/storage/team-store", () => ({
+	createLocalTeamStore: () => new MockTeamStore(),
+}));
+
+describe("DefaultRuntimeBuilder team persistence boundary", () => {
+	it("persists teammate specs and runtime state from team events", async () => {
+		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
+		const onTeamRestored = vi.fn();
+
+		await new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				headers: {
+					Authorization: "Bearer team-token",
+				},
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: true,
+			},
+			onTeamRestored,
+		});
+
+		expect(bootstrapAgentTeamsMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				restoredFromPersistence: true,
+				restoredTeammates: [expect.objectContaining({ agentId: "restored-1" })],
+				teammateConfigProvider: expect.objectContaining({
+					getRuntimeConfig: expect.any(Function),
+				}),
+			}),
+		);
+		const bootstrapCall = (
+			bootstrapAgentTeamsMock.mock.calls as unknown as Array<[BootstrapCall]>
+		)[0]?.[0];
+		expect(bootstrapCall).toBeDefined();
+		expect(bootstrapCall?.teammateConfigProvider.getRuntimeConfig()).toEqual(
+			expect.objectContaining({
+				headers: {
+					Authorization: "Bearer team-token",
+				},
+			}),
+		);
+		expect(onTeamRestored).toHaveBeenCalledTimes(1);
+		expect(runtimeInstance).toBeDefined();
+		expect(teamStoreInstance).toBeDefined();
+		if (!runtimeInstance || !teamStoreInstance) {
+			throw new Error("Expected mocked runtime and team store instances");
+		}
+
+		expect(runtimeInstance.markStaleRunsInterrupted).not.toHaveBeenCalled();
+		expect(runtimeInstance.recoverActiveRuns).toHaveBeenCalledWith(
+			"runtime_recovered",
+		);
+
+		runtimeInstance.emit({
+			type: "teammate_spawned",
+			agentId: "python-poet",
+			teammate: {
+				rolePrompt: "Write concise Python-focused haiku",
+				modelId: "claude-sonnet-4-5-20250929",
+				maxIterations: 7,
+			},
+		});
+		expect(teamStoreInstance.handleTeamEvent).toHaveBeenCalledWith(
+			expect.any(String),
+			expect.objectContaining({
+				type: "teammate_spawned",
+				agentId: "python-poet",
+			}),
+		);
+		expect(teamStoreInstance.persistRuntime).toHaveBeenCalled();
+
+		runtimeInstance.emit({
+			type: "teammate_shutdown",
+			agentId: "python-poet",
+		});
+		expect(teamStoreInstance.handleTeamEvent).toHaveBeenCalledWith(
+			expect.any(String),
+			expect.objectContaining({
+				type: "teammate_shutdown",
+				agentId: "python-poet",
+			}),
+		);
+		expect(teamStoreInstance.persistRuntime).toHaveBeenLastCalledWith(
+			expect.any(String),
+			expect.any(Object),
+			expect.arrayContaining([
+				expect.objectContaining({ agentId: "python-poet" }),
+			]),
+		);
+
+		runtimeInstance.emit({
+			type: "teammate_shutdown",
+			agentId: "python-poet",
+			reason: "manual_restart",
+		});
+		expect(teamStoreInstance.persistRuntime).toHaveBeenLastCalledWith(
+			expect.any(String),
+			expect.any(Object),
+			expect.not.arrayContaining([
+				expect.objectContaining({ agentId: "python-poet" }),
+			]),
+		);
+
+		runtimeInstance.emit({
+			type: "teammate_spawned",
+			agentId: "java-poet",
+			teammate: {
+				rolePrompt: "Write concise Java-focused haiku",
+			},
+		});
+		runtimeInstance.emit({
+			type: "teammate_shutdown",
+			agentId: "java-poet",
+			reason: "cli_run_shutdown",
+		});
+		expect(teamStoreInstance.persistRuntime).toHaveBeenLastCalledWith(
+			expect.any(String),
+			expect.any(Object),
+			expect.arrayContaining([
+				expect.objectContaining({ agentId: "java-poet" }),
+			]),
+		);
+	});
+
+	it("forwards cline workspace metadata to teammate runtime bootstrap config", async () => {
+		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
+		bootstrapAgentTeamsMock.mockClear();
+
+		await new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				apiKey: "key",
+				systemPrompt: `Base instructions.
+
+# Workspace Configuration
+{
+  "workspaces": {
+    "/repo/demo": {
+      "hint": "demo",
+      "latestGitBranchName": "main"
+    }
+  }
+}`,
+				cwd: "/repo/demo",
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: true,
+			},
+		});
+
+		expect(bootstrapAgentTeamsMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				teammateConfigProvider: expect.objectContaining({
+					getRuntimeConfig: expect.any(Function),
+				}),
+			}),
+		);
+		const clineBootstrapCall = (
+			bootstrapAgentTeamsMock.mock.calls as unknown as Array<[BootstrapCall]>
+		)[0]?.[0];
+		expect(clineBootstrapCall).toBeDefined();
+		expect(
+			clineBootstrapCall?.teammateConfigProvider.getRuntimeConfig(),
+		).toEqual(
+			expect.objectContaining({
+				providerId: "cline",
+				cwd: "/repo/demo",
+			}),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-builder.test.ts b/sdk/packages/core/src/runtime/orchestration/runtime-builder.test.ts
new file mode 100644
index 0000000..796613d
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-builder.test.ts
@@ -0,0 +1,985 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	type AgentExtension,
+	type AgentTool,
+	createContributionRegistry,
+	type Message,
+} from "@cline/shared";
+import { setHomeDir } from "@cline/shared/storage";
+import { afterEach, describe, expect, it } from "vitest";
+import { createUserInstructionConfigService } from "../../extensions/config";
+import { TelemetryService } from "../../services/telemetry/TelemetryService";
+import type { CoreSessionConfig } from "../../types/config";
+import { DefaultRuntimeBuilder } from "./runtime-builder";
+
+function makeSpawnTool(): AgentTool {
+	return {
+		name: "spawn_agent",
+		description: "Spawn a subagent",
+		inputSchema: { type: "object", properties: {}, required: [] },
+		execute: async () => ({ ok: true }),
+	};
+}
+
+function makeBaseConfig(
+	overrides: Partial<CoreSessionConfig> = {},
+): CoreSessionConfig {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		apiKey: "key",
+		systemPrompt: "test",
+		cwd: process.cwd(),
+		enableTools: true,
+		enableSpawnAgent: false,
+		enableAgentTeams: false,
+		...overrides,
+	};
+}
+
+async function collectExtensionTools(
+	extensions?: AgentExtension[],
+): Promise<AgentTool[]> {
+	const registry = createContributionRegistry<
+		AgentExtension,
+		AgentTool,
+		Message[]
+	>({
+		extensions: extensions ?? [],
+	});
+	await registry.initialize();
+	return registry.getRegisteredTools();
+}
+
+describe("DefaultRuntimeBuilder", () => {
+	const previousHome = process.env.HOME;
+	const previousGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		process.env.HOME = previousHome;
+		setHomeDir(previousHome ?? "~");
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = previousGlobalSettingsPath;
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("includes builtin tools when enabled", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig(),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names.length).toBeGreaterThan(0);
+		expect(names).not.toContain("spawn_agent");
+	});
+
+	it("forwards runtime logger for downstream agent creation", async () => {
+		const logger = {
+			debug: () => {},
+			log: () => {},
+		};
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				enableTools: false,
+				logger,
+			}),
+		});
+
+		expect(runtime.logger).toBe(logger);
+	});
+
+	it("loads configured agent files as named subagent tools", async () => {
+		const tempHome = mkdtempSync(join(tmpdir(), "cline-agent-home-"));
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "cline-agent-workspace-"));
+		tempDirs.push(tempHome, workspaceRoot);
+		setHomeDir(tempHome);
+
+		const globalAgentsDir = join(tempHome, ".cline", "agents");
+		mkdirSync(globalAgentsDir, { recursive: true });
+		writeFileSync(
+			join(globalAgentsDir, "code-reviewer.yml"),
+			`---
+name: code-reviewer
+description: Reviews code for quality and best practices
+tools: Execute_Command, Read_File
+modelId: anthropic/claude-sonnet-4.6
+---
+You are a code reviewer.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				cwd: workspaceRoot,
+				workspaceRoot,
+				enableSpawnAgent: true,
+				enableAgentTeams: false,
+			}),
+			createSpawnTool: makeSpawnTool,
+		});
+
+		const configuredAgentTool = runtime.tools.find(
+			(tool) => tool.name === "subagent_code_reviewer",
+		);
+		expect(configuredAgentTool).toBeDefined();
+		expect(configuredAgentTool?.description).toContain(
+			'Use the "code-reviewer" subagent',
+		);
+		expect(runtime.tools.map((tool) => tool.name)).toContain("spawn_agent");
+	});
+
+	it("does not register root skills when only configured agents declare skills", async () => {
+		const tempHome = mkdtempSync(join(tmpdir(), "cline-agent-home-"));
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "cline-agent-workspace-"));
+		const cwd = join(workspaceRoot, "packages", "app");
+		tempDirs.push(tempHome, workspaceRoot);
+		setHomeDir(tempHome);
+		mkdirSync(cwd, { recursive: true });
+
+		const agentsDir = join(workspaceRoot, ".cline", "agents");
+		const skillDir = join(workspaceRoot, ".cline", "skills", "review");
+		mkdirSync(agentsDir, { recursive: true });
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(agentsDir, "code-reviewer.yml"),
+			`---
+name: code-reviewer
+description: Reviews code
+tools: use_skill
+skills: review
+---
+You are a code reviewer.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: review
+---
+Use the review guidance.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				cwd,
+				workspaceRoot,
+				enableSpawnAgent: true,
+			}),
+			configExtensions: [],
+			createSpawnTool: makeSpawnTool,
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).toContain(
+			"subagent_code_reviewer",
+		);
+		expect(runtime.tools.map((tool) => tool.name)).not.toContain("skills");
+		expect(
+			(await collectExtensionTools(runtime.extensions)).map(
+				(tool) => tool.name,
+			),
+		).not.toContain("skills");
+		await runtime.shutdown("test");
+	});
+
+	it("forwards telemetry for downstream runtime consumers", async () => {
+		const telemetry = new TelemetryService();
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				enableTools: false,
+				telemetry,
+			}),
+		});
+
+		expect(runtime.telemetry).toBe(telemetry);
+	});
+
+	it("uses readonly preset in plan mode", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				mode: "plan",
+			}),
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).not.toContain("editor");
+	});
+
+	it("uses yolo preset only when yolo mode is explicit", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				mode: "yolo",
+			}),
+			toolExecutors: {
+				submit: async () => "submitted",
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).not.toContain("ask_question");
+		expect(names).toContain("submit_and_exit");
+		expect(runtime.completionPolicy).toEqual({
+			requireCompletionTool: true,
+		});
+	});
+
+	it("requires completion only when submit_and_exit is available", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				mode: "yolo",
+			}),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).not.toContain("submit_and_exit");
+		expect(runtime.completionPolicy).toBeUndefined();
+	});
+
+	it("keeps ask_question available in non-yolo modes", async () => {
+		for (const mode of ["act", "plan"] as const) {
+			const runtime = await new DefaultRuntimeBuilder().build({
+				config: makeBaseConfig({
+					mode,
+				}),
+				toolExecutors: {
+					submit: async () => "submitted",
+					askQuestion: async () => "question",
+				},
+			});
+
+			const names = runtime.tools.map((tool) => tool.name);
+			expect(names).toContain("ask_question");
+			expect(names).not.toContain("submit_and_exit");
+			expect(runtime.completionPolicy).toBeUndefined();
+		}
+	}, 10_000);
+
+	it("does not infer yolo preset from auto-approval alone", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				mode: "act",
+				toolPolicies: {
+					"*": { autoApprove: true },
+				},
+			}),
+			toolExecutors: {
+				submit: async () => "submitted",
+				askQuestion: async () => "question",
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("ask_question");
+		expect(names).not.toContain("submit_and_exit");
+	});
+
+	it("uses yolo preset runtime defaults for spawn and teams", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: {
+				...makeBaseConfig({
+					enableTools: false,
+					mode: "yolo",
+				}),
+			} as CoreSessionConfig,
+			createSpawnTool: makeSpawnTool,
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).not.toContain("spawn_agent");
+		expect(runtime.completionPolicy).toBeUndefined();
+	});
+
+	it("uses apply_patch instead of editor for codex/gpt model IDs in act mode", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				providerId: "openai",
+				modelId: "openai/gpt-5.4",
+				mode: "act",
+			}),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
+	it("keeps editor for non-codex/non-gpt model IDs in act mode", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				mode: "act",
+			}),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("editor");
+		expect(names).not.toContain("apply_patch");
+	});
+
+	it("applies custom tool routing rules from session config", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				mode: "act",
+				toolRoutingRules: [
+					{
+						mode: "act",
+						providerIdIncludes: ["anthropic"],
+						modelIdIncludes: ["claude"],
+						enableTools: ["apply_patch"],
+						disableTools: ["editor"],
+					},
+				],
+			}),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
+	it("omits builtin tools when disabled", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				enableTools: false,
+			}),
+		});
+
+		expect(runtime.tools).toEqual([]);
+	});
+
+	it("omits tools disabled by policy from the advertised runtime tool list", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				toolPolicies: {
+					run_commands: { enabled: false },
+					read_files: { enabled: false },
+				},
+			}),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).not.toContain("run_commands");
+		expect(names).not.toContain("read_files");
+		expect(names).toContain("search_codebase");
+	});
+
+	it("omits tools disabled by global settings from the advertised runtime tool list", async () => {
+		const tempRoot = mkdtempSync(join(tmpdir(), "runtime-builder-global-"));
+		const settingsPath = join(tempRoot, "global-settings.json");
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+		writeFileSync(
+			settingsPath,
+			JSON.stringify({ disabledTools: ["search_codebase"] }, null, 2),
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig(),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).not.toContain("search_codebase");
+		expect(names).toContain("read_files");
+	});
+
+	it("adds spawn tool when enabled", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				enableTools: false,
+				enableSpawnAgent: true,
+			}),
+			createSpawnTool: makeSpawnTool,
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).toContain("spawn_agent");
+	});
+
+	it("provides a shutdown helper", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				enableTools: false,
+			}),
+		});
+
+		await expect(runtime.shutdown("test")).resolves.toBeUndefined();
+	});
+
+	it("includes MCP tools from configured servers", async () => {
+		const tempRoot = mkdtempSync(join(tmpdir(), "runtime-builder-mcp-"));
+		const serverPath = join(tempRoot, "mock-mcp-server.js");
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		const previousSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+
+		writeFileSync(
+			serverPath,
+			`let buffer = "";
+function write(payload) {
+  process.stdout.write(JSON.stringify(payload) + "\\n");
+}
+function handle(message) {
+  if (message.method === "initialize") {
+    write({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "mock", version: "1.0.0" } } });
+    return;
+  }
+  if (message.method === "tools/list") {
+    write({ jsonrpc: "2.0", id: message.id, result: { tools: [{ name: "echo", description: "Echo tool", inputSchema: { type: "object", properties: { value: { type: "string" } }, required: [] } }] } });
+    return;
+  }
+  if (message.method === "tools/call") {
+    write({ jsonrpc: "2.0", id: message.id, result: { echoed: message.params?.arguments?.value ?? null } });
+  }
+}
+process.stdin.on("data", (chunk) => {
+  buffer += chunk.toString("utf8");
+  while (true) {
+    const separator = buffer.indexOf("\\n");
+    if (separator < 0) break;
+    const line = buffer.slice(0, separator).trim();
+    buffer = buffer.slice(separator + 1);
+    if (!line) continue;
+    const message = JSON.parse(line);
+    if (message.method === "notifications/initialized") continue;
+    handle(message);
+  }
+});`,
+			"utf8",
+		);
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						mock: {
+							command: process.execPath,
+							args: [serverPath],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		try {
+			const runtime = await new DefaultRuntimeBuilder().build({
+				config: makeBaseConfig(),
+			});
+			expect(runtime.tools.map((tool) => tool.name)).toContain("mock__echo");
+			await runtime.shutdown("test");
+		} finally {
+			process.env.CLINE_MCP_SETTINGS_PATH = previousSettingsPath;
+		}
+	});
+
+	it("skips MCP settings tools when disableMcpSettingsTools is true", async () => {
+		const tempRoot = mkdtempSync(
+			join(tmpdir(), "runtime-builder-mcp-disabled-"),
+		);
+		const serverPath = join(tempRoot, "mock-mcp-server.js");
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		const previousSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+
+		writeFileSync(
+			serverPath,
+			`let buffer = "";
+function write(payload) {
+  const body = JSON.stringify(payload);
+  process.stdout.write("Content-Length: " + Buffer.byteLength(body, "utf8") + "\\r\\n\\r\\n" + body);
+}
+function handle(message) {
+  if (message.method === "initialize") {
+    write({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "mock", version: "1.0.0" } } });
+    return;
+  }
+  if (message.method === "tools/list") {
+    write({ jsonrpc: "2.0", id: message.id, result: { tools: [{ name: "echo", description: "Echo tool", inputSchema: { type: "object", properties: { value: { type: "string" } }, required: [] } }] } });
+    return;
+  }
+  if (message.method === "tools/call") {
+    write({ jsonrpc: "2.0", id: message.id, result: { echoed: message.params?.arguments?.value ?? null } });
+  }
+}
+process.stdin.on("data", (chunk) => {
+  buffer += chunk.toString("utf8");
+  while (true) {
+    const separator = buffer.indexOf("\\r\\n\\r\\n");
+    if (separator < 0) break;
+    const header = buffer.slice(0, separator);
+    const match = header.match(/Content-Length:\\s*(\\d+)/i);
+    if (!match) throw new Error("missing content length");
+    const length = Number(match[1]);
+    const start = separator + 4;
+    const end = start + length;
+    if (buffer.length < end) break;
+    const body = buffer.slice(start, end);
+    buffer = buffer.slice(end);
+    const message = JSON.parse(body);
+    if (message.method === "notifications/initialized") continue;
+    handle(message);
+  }
+});`,
+			"utf8",
+		);
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						mock: {
+							command: process.execPath,
+							args: [serverPath],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		try {
+			const runtime = await new DefaultRuntimeBuilder().build({
+				config: makeBaseConfig({
+					disableMcpSettingsTools: true,
+				}),
+			});
+			expect(runtime.tools.map((tool) => tool.name)).not.toContain(
+				"mock__echo",
+			);
+			await runtime.shutdown("test");
+		} finally {
+			process.env.CLINE_MCP_SETTINGS_PATH = previousSettingsPath;
+		}
+	});
+
+	it("skips broken MCP servers without crashing", async () => {
+		const tempRoot = mkdtempSync(join(tmpdir(), "runtime-builder-mcp-bad-"));
+		const serverPath = join(tempRoot, "malformed-mcp-server.js");
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		const previousSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+
+		writeFileSync(
+			serverPath,
+			`process.stdin.once("data", () => {
+  process.stdout.write("Content-Length: 2\\r\\n\\r\\n{]");
+});`,
+			"utf8",
+		);
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						broken: {
+							command: process.execPath,
+							args: [serverPath],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		try {
+			const runtime = await new DefaultRuntimeBuilder().build({
+				config: makeBaseConfig(),
+			});
+			const mcpTools = runtime.tools.filter((t) =>
+				t.name.startsWith("broken__"),
+			);
+			expect(mcpTools).toEqual([]);
+			await runtime.shutdown("test");
+		} finally {
+			process.env.CLINE_MCP_SETTINGS_PATH = previousSettingsPath;
+		}
+	});
+
+	it("skips invalid MCP settings file without crashing", async () => {
+		const tempRoot = mkdtempSync(
+			join(tmpdir(), "runtime-builder-mcp-invalid-"),
+		);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		const previousSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+
+		writeFileSync(settingsPath, "{ not valid json !!!", "utf8");
+
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		try {
+			const runtime = await new DefaultRuntimeBuilder().build({
+				config: makeBaseConfig(),
+			});
+			const mcpTools = runtime.tools.filter((t) => t.name.includes("__"));
+			expect(mcpTools).toEqual([]);
+			await runtime.shutdown("test");
+		} finally {
+			process.env.CLINE_MCP_SETTINGS_PATH = previousSettingsPath;
+		}
+	});
+
+	it("includes skills tool when workspace skills are available", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-"));
+		const skillDir = join(cwd, ".cline", "skills", "commit");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: commit
+description: Create commit message
+---
+Use conventional commits.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+		});
+		const extensionTools = await collectExtensionTools(runtime.extensions);
+
+		expect(runtime.tools.map((tool) => tool.name)).not.toContain("skills");
+		expect(extensionTools.map((tool) => tool.name)).toContain("skills");
+		await runtime.shutdown("test");
+	});
+
+	it("includes skills bundled in discovered plugin packages", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-plugin-skills-"));
+		process.env.HOME = cwd;
+		setHomeDir(cwd);
+		const pluginDir = join(cwd, ".cline", "plugins", "review-plugin");
+		const skillDir = join(pluginDir, "skills", "review");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(pluginDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "review-plugin",
+					private: true,
+					cline: {
+						plugins: [{ paths: ["./index.ts"] }],
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		writeFileSync(join(pluginDir, "index.ts"), "export default {}", "utf8");
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: review
+description: Review code
+---
+Use the review plugin guidance.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+		});
+		const extensionTools = await collectExtensionTools(runtime.extensions);
+		const skillsTool = extensionTools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool.");
+		}
+
+		const result = await skillsTool.execute(
+			{ skill: "review" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(result).toContain("<command-name>review</command-name>");
+		expect(result).toContain("Use the review plugin guidance.");
+
+		await runtime.shutdown("test");
+	});
+
+	it("uses explicit plugin skill directories instead of rediscovering plugins", async () => {
+		const cwd = mkdtempSync(
+			join(tmpdir(), "runtime-builder-active-plugin-skills-"),
+		);
+		process.env.HOME = cwd;
+		setHomeDir(cwd);
+		const pluginDir = join(cwd, ".cline", "plugins", "review-plugin");
+		const skillRoot = join(pluginDir, "skills");
+		const skillDir = join(skillRoot, "review");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(pluginDir, "package.json"),
+			JSON.stringify({
+				name: "review-plugin",
+				private: true,
+				cline: {
+					plugins: [{ paths: ["./index.ts"] }],
+				},
+			}),
+			"utf8",
+		);
+		writeFileSync(join(pluginDir, "index.ts"), "export default {}", "utf8");
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: review
+description: Review code
+---
+Use the review plugin guidance.`,
+			"utf8",
+		);
+
+		const inactiveRuntime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+			pluginSkillDirectories: [],
+		});
+		const inactiveExtensionTools = await collectExtensionTools(
+			inactiveRuntime.extensions,
+		);
+		expect(inactiveExtensionTools.map((tool) => tool.name)).not.toContain(
+			"skills",
+		);
+		await inactiveRuntime.shutdown("test");
+
+		const activeRuntime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+			pluginSkillDirectories: [skillRoot],
+		});
+		const activeExtensionTools = await collectExtensionTools(
+			activeRuntime.extensions,
+		);
+		const skillsTool = activeExtensionTools.find(
+			(tool) => tool.name === "skills",
+		);
+		expect(skillsTool).toBeDefined();
+		await activeRuntime.shutdown("test");
+	});
+
+	it("does not include bundled plugin skills when plugins are disabled", async () => {
+		const cwd = mkdtempSync(
+			join(tmpdir(), "runtime-builder-plugin-skills-disabled-"),
+		);
+		process.env.HOME = cwd;
+		setHomeDir(cwd);
+		const pluginDir = join(cwd, ".cline", "plugins", "review-plugin");
+		const skillDir = join(pluginDir, "skills", "review");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(pluginDir, "package.json"),
+			JSON.stringify({
+				name: "review-plugin",
+				private: true,
+				cline: {
+					plugins: [{ paths: ["./index.ts"] }],
+				},
+			}),
+			"utf8",
+		);
+		writeFileSync(join(pluginDir, "index.ts"), "export default {}", "utf8");
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: review
+---
+Use the review plugin guidance.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+			configExtensions: ["skills"],
+		});
+		const extensionTools = await collectExtensionTools(runtime.extensions);
+
+		expect(extensionTools.map((tool) => tool.name)).not.toContain("skills");
+
+		await runtime.shutdown("test");
+	});
+
+	it("allows tool routing rules to disable skills even when skills exist", async () => {
+		const cwd = mkdtempSync(
+			join(tmpdir(), "runtime-builder-skills-routing-disabled-"),
+		);
+		const skillDir = join(cwd, ".cline", "skills", "commit");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: commit
+description: Create commit message
+---
+Use conventional commits.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				providerId: "openrouter",
+				modelId: "google/gemini-3-flash-preview",
+				cwd,
+				toolRoutingRules: [
+					{
+						mode: "act",
+						providerIdIncludes: ["openrouter"],
+						modelIdIncludes: ["gemini"],
+						disableTools: ["skills"],
+					},
+				],
+			}),
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).not.toContain("skills");
+		expect(
+			(await collectExtensionTools(runtime.extensions)).map(
+				(tool) => tool.name,
+			),
+		).not.toContain("skills");
+		await runtime.shutdown("test");
+	});
+
+	it("marks configured but disabled skills in executor metadata", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-disabled-"));
+		const enabledDir = join(cwd, ".cline", "skills", "commit");
+		const disabledDir = join(cwd, ".cline", "skills", "review");
+		mkdirSync(enabledDir, { recursive: true });
+		mkdirSync(disabledDir, { recursive: true });
+		writeFileSync(
+			join(enabledDir, "SKILL.md"),
+			`---
+name: commit
+---
+Enabled skill.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(disabledDir, "SKILL.md"),
+			`---
+name: review
+disabled: true
+---
+Disabled skill.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+		});
+
+		const extensionTools = await collectExtensionTools(runtime.extensions);
+		const skillsTool = extensionTools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool.");
+		}
+
+		const disabledResult = await skillsTool.execute(
+			{ skill: "review" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(disabledResult).toContain("configured but disabled");
+
+		await runtime.shutdown("test");
+	});
+
+	it("scopes skills tool to session-configured skills", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-scoped-"));
+		const commitDir = join(cwd, ".cline", "skills", "commit");
+		const reviewDir = join(cwd, ".cline", "skills", "review");
+		mkdirSync(commitDir, { recursive: true });
+		mkdirSync(reviewDir, { recursive: true });
+		writeFileSync(
+			join(commitDir, "SKILL.md"),
+			`---
+name: commit
+---
+Commit skill.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(reviewDir, "SKILL.md"),
+			`---
+name: review
+---
+Review skill.`,
+			"utf8",
+		);
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				cwd,
+				skills: ["commit"],
+			}),
+		});
+
+		const extensionTools = await collectExtensionTools(runtime.extensions);
+		const skillsTool = extensionTools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool.");
+		}
+
+		const known = await skillsTool.execute(
+			{ skill: "commit" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(known).toContain("<command-name>commit</command-name>");
+
+		const blocked = await skillsTool.execute(
+			{ skill: "review" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(blocked).toContain('Skill "review" not found.');
+		expect(blocked).toContain("Available skills: commit");
+
+		await runtime.shutdown("test");
+	});
+
+	it("does not register the skills tool when all configured skills are disabled", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-disabled-skills-"));
+		const skillDir = join(cwd, ".cline", "skills", "review");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: review
+disabled: true
+---
+Review skill.`,
+			"utf8",
+		);
+		const userInstructionService = createUserInstructionConfigService({
+			skills: { directories: [join(cwd, ".cline", "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [] },
+		});
+
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({ cwd }),
+			userInstructionService,
+		});
+
+		const extensionTools = await collectExtensionTools(runtime.extensions);
+		expect(extensionTools.map((tool) => tool.name)).not.toContain("skills");
+
+		await runtime.shutdown("test");
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-builder.ts b/sdk/packages/core/src/runtime/orchestration/runtime-builder.ts
new file mode 100644
index 0000000..c3a11e6
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-builder.ts
@@ -0,0 +1,739 @@
+import type {
+	AgentTool,
+	BasicLogger,
+	RuntimeConfigExtensionKind,
+	TeamTeammateSpec,
+} from "@cline/shared";
+import { hasRuntimeConfigExtension } from "@cline/shared";
+import { nanoid } from "nanoid";
+import { createUserInstructionConfigService } from "../../extensions/config";
+import {
+	createDefaultMcpServerClientFactory,
+	createMcpTools,
+	hasMcpSettingsFile,
+	InMemoryMcpManager,
+	registerMcpServersFromSettingsFile,
+	resolveDefaultMcpSettingsPath,
+} from "../../extensions/mcp";
+import {
+	createBuiltinTools,
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolPresetName,
+	resolveToolRoutingConfig,
+	type SkillsExecutorWithMetadata,
+	type ToolExecutors,
+	ToolPresets,
+	type ToolRoutingRule,
+} from "../../extensions/tools";
+import {
+	AgentTeamsRuntime,
+	bootstrapAgentTeams,
+	createDelegatedAgentConfigProvider,
+	type TeamEvent,
+} from "../../extensions/tools/team";
+import type { ConfiguredAgentConfig } from "../../extensions/tools/team/configured-agent-config";
+import { loadConfiguredAgentConfigs } from "../../extensions/tools/team/configured-agent-config";
+import { createConfiguredAgentTools } from "../../extensions/tools/team/configured-agent-tool";
+import {
+	filterDisabledTools,
+	resolveDisabledToolNames,
+} from "../../services/global-settings";
+import { createLocalTeamStore } from "../../services/storage/team-store";
+import type { CoreAgentMode, CoreSessionConfig } from "../../types/config";
+import type {
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	BuiltRuntime as RuntimeEnvironment,
+} from "./session-runtime";
+
+function hasConfigExtension(
+	extensions: ReadonlyArray<RuntimeConfigExtensionKind> | undefined,
+	kind: RuntimeConfigExtensionKind,
+): boolean {
+	return hasRuntimeConfigExtension(extensions, kind);
+}
+
+function isToolEnabledByPolicies(
+	toolName: string,
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): boolean {
+	const globalPolicy = toolPolicies?.["*"] ?? {};
+	const toolPolicy = toolPolicies?.[toolName] ?? {};
+	return (
+		{
+			...globalPolicy,
+			...toolPolicy,
+		}.enabled !== false
+	);
+}
+
+function filterToolsByPolicies(
+	tools: AgentTool[],
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): AgentTool[] {
+	return tools.filter((tool) =>
+		isToolEnabledByPolicies(tool.name, toolPolicies),
+	);
+}
+
+function filterAvailableTools(
+	tools: AgentTool[],
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): AgentTool[] {
+	return filterDisabledTools(filterToolsByPolicies(tools, toolPolicies));
+}
+
+const CONFIGURED_AGENT_TOOL_NAME_ALIASES: Record<string, string> = {
+	apply_diff: "editor",
+	attempt_completion: "submit_and_exit",
+	bash: "run_commands",
+	execute_command: "run_commands",
+	list_code_definition_names: "search_codebase",
+	list_files: "run_commands",
+	read_file: "read_files",
+	replace_in_file: "editor",
+	search_files: "search_codebase",
+	use_skill: "skills",
+	write_to_file: "editor",
+};
+
+function resolveConfiguredAgentToolName(toolName: string): string {
+	const normalized = toolName.trim().toLowerCase();
+	return CONFIGURED_AGENT_TOOL_NAME_ALIASES[normalized] ?? normalized;
+}
+
+function filterToolsForConfiguredAgent(
+	tools: AgentTool[],
+	agent: ConfiguredAgentConfig,
+): AgentTool[] {
+	if (agent.tools === undefined) {
+		return tools;
+	}
+
+	const allowedToolNames = new Set(
+		agent.tools.map(resolveConfiguredAgentToolName),
+	);
+	if (agent.skills !== undefined) {
+		allowedToolNames.add("skills");
+	}
+	return tools.filter((tool) => allowedToolNames.has(tool.name));
+}
+
+export function createTeamName(): string {
+	return `team-${nanoid(5)}`;
+}
+
+function createBuiltinToolsList(
+	cwd: string,
+	providerId: string,
+	mode: CoreAgentMode,
+	modelId: string,
+	toolRoutingRules: ToolRoutingRule[] | undefined,
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+	skillsExecutor?: SkillsExecutorWithMetadata,
+	executorOverrides?: Partial<ToolExecutors>,
+): AgentTool[] {
+	const preset = ToolPresets[resolveToolPresetName({ mode })];
+	const toolRoutingConfig = resolveToolRoutingConfig(
+		providerId,
+		modelId,
+		mode,
+		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	);
+
+	return filterAvailableTools(
+		createBuiltinTools({
+			cwd,
+			...preset,
+			enableSkills: !!skillsExecutor,
+			...toolRoutingConfig,
+			executors: {
+				...(skillsExecutor
+					? {
+							skills: skillsExecutor,
+						}
+					: {}),
+				...(executorOverrides ?? {}),
+			},
+		}),
+		toolPolicies,
+	);
+}
+
+function isSkillsToolEnabledForSession(input: {
+	cwd: string;
+	providerId: string;
+	mode: CoreAgentMode;
+	modelId: string;
+	toolRoutingRules?: ToolRoutingRule[];
+	toolPolicies?: CoreSessionConfig["toolPolicies"];
+	toolExecutors?: Partial<ToolExecutors>;
+}): boolean {
+	return createBuiltinToolsList(
+		input.cwd,
+		input.providerId,
+		input.mode,
+		input.modelId,
+		input.toolRoutingRules,
+		input.toolPolicies,
+		SKILLS_PROBE_EXECUTOR,
+		input.toolExecutors,
+	).some((tool) => tool.name === "skills");
+}
+
+const SKILLS_PROBE_EXECUTOR = (async () => "") as SkillsExecutorWithMetadata;
+
+async function loadConfiguredMcpTools(logger?: BasicLogger): Promise<{
+	tools: AgentTool[];
+	shutdown?: () => Promise<void>;
+}> {
+	const settingsPath = resolveDefaultMcpSettingsPath();
+	if (!hasMcpSettingsFile({ filePath: settingsPath })) {
+		return { tools: [] };
+	}
+
+	const manager = new InMemoryMcpManager({
+		clientFactory: createDefaultMcpServerClientFactory({
+			settingsPath,
+		}),
+	});
+
+	let registrations: Awaited<
+		ReturnType<typeof registerMcpServersFromSettingsFile>
+	>;
+	try {
+		registrations = await registerMcpServersFromSettingsFile(manager, {
+			filePath: settingsPath,
+		});
+	} catch (error) {
+		await manager.dispose().catch(() => {});
+		const message = error instanceof Error ? error.message : String(error);
+		logger?.log(
+			`[mcp] Failed to load MCP settings, skipping MCP tools: ${message}`,
+		);
+		return { tools: [] };
+	}
+
+	const enabled = registrations.filter((r) => r.disabled !== true);
+	const results = await Promise.allSettled(
+		enabled.map((r) =>
+			createMcpTools({ serverName: r.name, provider: manager }),
+		),
+	);
+	const tools: AgentTool[] = [];
+	for (const [i, result] of results.entries()) {
+		if (result.status === "fulfilled") {
+			tools.push(...result.value);
+		} else {
+			const message =
+				result.reason instanceof Error
+					? result.reason.message
+					: String(result.reason);
+			logger?.log(
+				`[mcp] Failed to load tools from MCP server "${enabled[i].name}", skipping: ${message}`,
+			);
+		}
+	}
+
+	return {
+		tools,
+		shutdown: async () => {
+			await manager.dispose();
+		},
+	};
+}
+
+function shutdownTeamRuntime(
+	teamRuntime: AgentTeamsRuntime | undefined,
+	reason: string,
+): void {
+	if (!teamRuntime) {
+		return;
+	}
+	for (const teammateId of teamRuntime.getTeammateIds()) {
+		try {
+			teamRuntime.shutdownTeammate(teammateId, reason);
+		} catch {
+			// Best-effort shutdown for all teammates.
+		}
+	}
+}
+
+function isRuntimeLifecycleShutdownReason(reason: string | undefined): boolean {
+	if (reason === undefined) {
+		return true;
+	}
+	switch (reason) {
+		case "session_stop":
+		case "session_complete":
+		case "session_error":
+		case "session_manager_dispose":
+		case "cli_run_shutdown":
+		case "cli_interactive_shutdown":
+		case "cli_interactive_startup_cancelled":
+		case "provider_change":
+		case "acp_shutdown":
+		case "hub_server_stop":
+		case "vscode_webview_dispose":
+			return true;
+		default:
+			return false;
+	}
+}
+
+function normalizeConfig(
+	config: CoreSessionConfig,
+): Required<
+	Pick<
+		CoreSessionConfig,
+		| "mode"
+		| "enableTools"
+		| "enableSpawnAgent"
+		| "enableAgentTeams"
+		| "disableMcpSettingsTools"
+		| "yolo"
+		| "missionLogIntervalSteps"
+		| "missionLogIntervalMs"
+		| "sessionId"
+	>
+> {
+	const preset = ToolPresets[resolveToolPresetName({ mode: config.mode })];
+	return {
+		sessionId: config.sessionId || "",
+		mode:
+			config.mode === "plan" ? "plan" : config.mode === "yolo" ? "yolo" : "act",
+		enableTools: config.enableTools !== false,
+		enableSpawnAgent:
+			config.enableSpawnAgent ?? preset.enableSpawnAgent ?? true,
+		enableAgentTeams:
+			config.enableAgentTeams ?? preset.enableAgentTeams ?? true,
+		disableMcpSettingsTools: config.disableMcpSettingsTools === true,
+		yolo: config.yolo === true,
+		missionLogIntervalSteps:
+			typeof config.missionLogIntervalSteps === "number" &&
+			Number.isFinite(config.missionLogIntervalSteps)
+				? config.missionLogIntervalSteps
+				: 3,
+		missionLogIntervalMs:
+			typeof config.missionLogIntervalMs === "number" &&
+			Number.isFinite(config.missionLogIntervalMs)
+				? config.missionLogIntervalMs
+				: 120000,
+	};
+}
+
+export class DefaultRuntimeBuilder implements RuntimeBuilder {
+	private readonly teamRuntimeEntries = new Map<
+		string,
+		{
+			runtime?: AgentTeamsRuntime;
+			delegatedAgentConfigProvider: ReturnType<
+				typeof createDelegatedAgentConfigProvider
+			>;
+		}
+	>();
+
+	async build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment> {
+		const {
+			config,
+			hooks,
+			extensions,
+			logger,
+			telemetry,
+			createSpawnTool,
+			onTeamRestored,
+			userInstructionService: sharedUserInstructionService,
+			configExtensions,
+			toolExecutors,
+		} = input;
+		const onTeamEvent = input.onTeamEvent ?? (() => {});
+		const normalized = normalizeConfig(config);
+		const workspaceConfigRoot = config.workspaceRoot ?? config.cwd;
+		const effectiveToolPolicies = input.toolPolicies ?? config.toolPolicies;
+		const globallyDisabledToolNames = resolveDisabledToolNames();
+		const tools: AgentTool[] = [];
+		const effectiveTeamName = config.teamName?.trim() || createTeamName();
+		const teamStoreKey = config.sessionId?.trim() || effectiveTeamName;
+		const configuredAgents = normalized.enableSpawnAgent
+			? loadConfiguredAgentConfigs({
+					workspaceRoot: workspaceConfigRoot,
+				})
+			: { configs: [], errors: [] };
+		const configuredAgentsNeedSkills = configuredAgents.configs.some(
+			(agent) => agent.skills !== undefined,
+		);
+		const rulesEnabled = hasConfigExtension(configExtensions, "rules");
+		const rootSkillsEnabled = hasConfigExtension(configExtensions, "skills");
+		const needsSkillsConfigService =
+			rootSkillsEnabled || configuredAgentsNeedSkills;
+		const workflowsEnabled = hasConfigExtension(configExtensions, "workflows");
+		const pluginsEnabled = hasConfigExtension(configExtensions, "plugins");
+		const userInstructionsEnabled =
+			rulesEnabled || rootSkillsEnabled || workflowsEnabled;
+		let teamToolsRegistered = false;
+		const userInstructionServiceProvided = Boolean(
+			sharedUserInstructionService,
+		);
+		let userInstructionService = sharedUserInstructionService;
+		let mcpShutdown: (() => Promise<void>) | undefined;
+
+		for (const error of configuredAgents.errors) {
+			(logger ?? config.logger)?.log?.(
+				`[agents] Failed to load agent config at ${error.path}: ${error.error.message}`,
+			);
+		}
+
+		if (
+			!userInstructionService &&
+			(userInstructionsEnabled || configuredAgentsNeedSkills)
+		) {
+			userInstructionService = createUserInstructionConfigService({
+				skills: needsSkillsConfigService
+					? {
+							workspacePath: workspaceConfigRoot,
+							includePluginSkills: pluginsEnabled,
+							pluginSkillDirectories: pluginsEnabled
+								? input.pluginSkillDirectories
+								: undefined,
+							pluginPaths: config.pluginPaths,
+							cwd: config.cwd,
+						}
+					: { workspacePath: workspaceConfigRoot },
+				rules: { workspacePath: config.cwd },
+				workflows: { workspacePath: config.cwd },
+			});
+		}
+
+		if (userInstructionService) {
+			await userInstructionService.start().catch(() => {});
+		}
+
+		const registerSkillsTool =
+			normalized.enableTools &&
+			rootSkillsEnabled &&
+			Boolean(userInstructionService) &&
+			userInstructionService?.hasConfiguredSkills(config.skills) === true &&
+			isSkillsToolEnabledForSession({
+				cwd: config.cwd,
+				providerId: config.providerId,
+				mode: normalized.mode,
+				modelId: config.modelId,
+				toolRoutingRules: config.toolRoutingRules,
+				toolPolicies: effectiveToolPolicies,
+				toolExecutors,
+			});
+
+		const userInstructionPlugin =
+			userInstructionService && userInstructionsEnabled
+				? userInstructionService.createExtension({
+						includeRules: rulesEnabled,
+						includeSkills: rootSkillsEnabled,
+						includeWorkflows: workflowsEnabled,
+						registerSkillsTool,
+						allowedSkillNames: config.skills,
+					})
+				: undefined;
+		const runtimeExtensions = userInstructionPlugin
+			? [...(extensions ?? config.extensions ?? []), userInstructionPlugin]
+			: (extensions ?? config.extensions);
+
+		if (normalized.enableTools) {
+			tools.push(
+				...createBuiltinToolsList(
+					config.cwd,
+					config.providerId,
+					normalized.mode,
+					config.modelId,
+					config.toolRoutingRules,
+					effectiveToolPolicies,
+					undefined,
+					toolExecutors,
+				),
+			);
+			if (!normalized.disableMcpSettingsTools) {
+				const mcpRuntime = await loadConfiguredMcpTools(config.logger);
+				tools.push(...mcpRuntime.tools);
+				mcpShutdown = mcpRuntime.shutdown;
+			}
+		}
+
+		let teamRuntime: AgentTeamsRuntime | undefined;
+		const teamStore = normalized.enableAgentTeams
+			? createLocalTeamStore()
+			: undefined;
+		const restoredTeam = teamStore?.loadRuntime(teamStoreKey);
+		const restoredTeamState = restoredTeam?.state;
+		const restoredTeammateSpecs = restoredTeam?.teammates ?? [];
+		const teammateSpecs = new Map(
+			restoredTeammateSpecs.map((spec) => [spec.agentId, spec] as const),
+		);
+		const registryKey = config.sessionId || effectiveTeamName;
+		let leadAgentInstance:
+			| {
+					addTools: (tools: AgentTool[]) => void;
+			  }
+			| undefined;
+		let pendingLeadTeamTools: AgentTool[] = [];
+		let restoredStateHydratedIntoRuntime = false;
+		const delegatedAgentConfigProvider = createDelegatedAgentConfigProvider({
+			providerId: config.providerId,
+			modelId: config.modelId,
+			cwd: config.cwd,
+			apiKey: config.apiKey ?? "",
+			baseUrl: config.baseUrl,
+			headers: config.headers,
+			providerConfig: config.providerConfig,
+			knownModels: config.knownModels,
+			thinking: config.thinking,
+			reasoningEffort: config.reasoningEffort,
+			thinkingBudgetTokens: config.thinkingBudgetTokens,
+			maxTokensPerTurn: config.maxTokensPerTurn,
+			maxIterations: config.maxIterations,
+			hooks,
+			extensions: runtimeExtensions,
+			logger: logger ?? config.logger,
+			telemetry: input.telemetry ?? config.telemetry,
+			workspaceMetadata: config.workspaceMetadata,
+		});
+		if (normalized.enableSpawnAgent) {
+			if (configuredAgents.configs.length > 0) {
+				tools.push(
+					...filterAvailableTools(
+						createConfiguredAgentTools({
+							configProvider: delegatedAgentConfigProvider,
+							agents: configuredAgents.configs,
+							createSubAgentTools: (agent) =>
+								normalized.enableTools
+									? filterToolsForConfiguredAgent(
+											createBuiltinToolsList(
+												config.cwd,
+												agent.providerId ?? config.providerId,
+												normalized.mode,
+												agent.modelId ?? config.modelId,
+												config.toolRoutingRules,
+												effectiveToolPolicies,
+												agent.skills !== undefined &&
+													userInstructionService?.createSkillsExecutor
+													? userInstructionService.createSkillsExecutor(
+															agent.skills,
+														)
+													: undefined,
+												toolExecutors,
+											),
+											agent,
+										)
+									: [],
+							hookErrorMode: config.hookErrorMode,
+							toolPolicies: effectiveToolPolicies,
+							requestToolApproval: input.requestToolApproval,
+							onSubAgentEvent: input.onSubAgentEvent,
+							onSubAgentStart: input.onSubAgentStart,
+							onSubAgentEnd: input.onSubAgentEnd,
+						}),
+						effectiveToolPolicies,
+					),
+				);
+			}
+		}
+		if (!this.teamRuntimeEntries.has(registryKey)) {
+			this.teamRuntimeEntries.set(registryKey, {
+				delegatedAgentConfigProvider,
+			});
+		}
+
+		const ensureTeamRuntime = (): AgentTeamsRuntime | undefined => {
+			if (!normalized.enableAgentTeams) {
+				return undefined;
+			}
+
+			const registryEntry = this.teamRuntimeEntries.get(registryKey) ?? {
+				delegatedAgentConfigProvider,
+			};
+			this.teamRuntimeEntries.set(registryKey, registryEntry);
+			teamRuntime = registryEntry.runtime;
+
+			if (!teamRuntime) {
+				teamRuntime = new AgentTeamsRuntime({
+					teamName: effectiveTeamName,
+					leadAgentId: config.sessionId || "lead",
+					missionLogIntervalSteps: normalized.missionLogIntervalSteps,
+					missionLogIntervalMs: normalized.missionLogIntervalMs,
+					onTeamEvent: (event: TeamEvent) => {
+						onTeamEvent(event);
+						if (teamRuntime && teamStore) {
+							if (
+								event.type === "teammate_spawned" &&
+								event.teammate?.rolePrompt
+							) {
+								const spec: TeamTeammateSpec = {
+									agentId: event.agentId,
+									rolePrompt: event.teammate.rolePrompt,
+									modelId: event.teammate.modelId,
+									maxIterations: event.teammate.maxIterations,
+								};
+								teammateSpecs.set(spec.agentId, spec);
+							}
+							if (
+								event.type === "teammate_shutdown" &&
+								!isRuntimeLifecycleShutdownReason(event.reason)
+							) {
+								teammateSpecs.delete(event.agentId);
+							}
+							teamStore.handleTeamEvent(teamStoreKey, event);
+							teamStore.persistRuntime(
+								teamStoreKey,
+								teamRuntime.exportState(),
+								Array.from(teammateSpecs.values()),
+							);
+						}
+					},
+				});
+				if (restoredTeamState) {
+					teamRuntime.hydrateState(restoredTeamState);
+					restoredStateHydratedIntoRuntime = true;
+				}
+				registryEntry.runtime = teamRuntime;
+			}
+
+			if (!teamToolsRegistered) {
+				if (!teamRuntime) {
+					return undefined;
+				}
+				teamToolsRegistered = true;
+
+				const teamBootstrap = bootstrapAgentTeams({
+					runtime: teamRuntime,
+					leadAgentId: config.sessionId || "lead",
+					restoredFromPersistence: Boolean(restoredTeamState),
+					restoredTeammates: restoredTeammateSpecs,
+					includeLeadSpawnTool: true,
+					includeLeadManagementTools: true,
+					onLeadToolsUnlocked: (teamTools) => {
+						pendingLeadTeamTools = teamTools;
+						leadAgentInstance?.addTools(teamTools);
+					},
+					createBaseTools: normalized.enableTools
+						? () =>
+								createBuiltinToolsList(
+									config.cwd,
+									config.providerId,
+									normalized.mode,
+									config.modelId,
+									config.toolRoutingRules,
+									effectiveToolPolicies,
+									undefined,
+									toolExecutors,
+								)
+						: undefined,
+					teammateConfigProvider: delegatedAgentConfigProvider,
+				});
+
+				if (restoredStateHydratedIntoRuntime) {
+					teamRuntime.recoverActiveRuns("runtime_recovered");
+				}
+
+				if (teamBootstrap.restoredFromPersistence) {
+					onTeamRestored?.();
+				}
+				tools.push(...teamBootstrap.tools);
+			}
+
+			return teamRuntime;
+		};
+
+		if (normalized.enableSpawnAgent && createSpawnTool) {
+			const spawnTool = createSpawnTool();
+			tools.push({
+				...spawnTool,
+				execute: async (spawnInput, context) => {
+					ensureTeamRuntime();
+					return spawnTool.execute(spawnInput, context);
+				},
+			});
+		}
+
+		if (normalized.enableAgentTeams) {
+			ensureTeamRuntime();
+		}
+
+		const finalTools = filterAvailableTools(tools, effectiveToolPolicies);
+		const requiresCompletionTool = finalTools.some(
+			(tool) =>
+				tool.name === "submit_and_exit" &&
+				tool.lifecycle?.completesRun === true,
+		);
+		const teamCompletionGuard = normalized.enableAgentTeams
+			? (): string | undefined => {
+					const rt = this.teamRuntimeEntries.get(registryKey)?.runtime;
+					if (!rt) return undefined;
+					const tasks = rt.listTasks();
+					const hasInProgress = tasks.some(
+						(t) => t.status === "in_progress" || t.status === "pending",
+					);
+					const runs = rt.listRuns({});
+					const hasActiveRuns = runs.some(
+						(r) => r.status === "running" || r.status === "queued",
+					);
+					if (hasInProgress || hasActiveRuns) {
+						const pending = tasks
+							.filter(
+								(t) => t.status === "in_progress" || t.status === "pending",
+							)
+							.map((t) => `${t.id} (${t.status}): ${t.title}`)
+							.join(", ");
+						const activeRunSummary = runs
+							.filter((r) => r.status === "running" || r.status === "queued")
+							.map((r) => `${r.id} (${r.status})`)
+							.join(", ");
+						const parts = [];
+						if (pending) parts.push(`Unfinished tasks: ${pending}`);
+						if (activeRunSummary)
+							parts.push(`Active runs: ${activeRunSummary}`);
+						return `[SYSTEM] You still have team obligations. ${parts.join(". ")}. Use team_run_task to delegate work, or team_task with action=complete to mark tasks done, or team_await_runs to wait for active runs. Do NOT stop until all tasks are completed.`;
+					}
+					return undefined;
+				}
+			: undefined;
+		const completionPolicy = requiresCompletionTool
+			? {
+					requireCompletionTool: true,
+					...(teamCompletionGuard
+						? { completionGuard: teamCompletionGuard }
+						: {}),
+				}
+			: teamCompletionGuard
+				? { completionGuard: teamCompletionGuard }
+				: undefined;
+
+		return {
+			tools: finalTools,
+			logger: logger ?? config.logger,
+			telemetry: telemetry ?? config.telemetry,
+			teamRuntime,
+			teamRestoredFromPersistence: Boolean(restoredTeamState),
+			delegatedAgentConfigProvider:
+				this.teamRuntimeEntries.get(registryKey)
+					?.delegatedAgentConfigProvider ?? delegatedAgentConfigProvider,
+			extensions: runtimeExtensions,
+			completionPolicy,
+			registerLeadAgent: (agent) => {
+				leadAgentInstance = agent;
+				if (pendingLeadTeamTools.length > 0) {
+					agent.addTools(
+						filterDisabledTools(pendingLeadTeamTools, [
+							...globallyDisabledToolNames,
+						]),
+					);
+				}
+			},
+			shutdown: async (reason: string) => {
+				shutdownTeamRuntime(teamRuntime, reason);
+				this.teamRuntimeEntries.delete(registryKey);
+				await mcpShutdown?.();
+				if (!userInstructionServiceProvided) {
+					userInstructionService?.stop();
+				}
+			},
+		};
+	}
+}
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-event-adapter.test.ts b/sdk/packages/core/src/runtime/orchestration/runtime-event-adapter.test.ts
new file mode 100644
index 0000000..858df01
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-event-adapter.test.ts
@@ -0,0 +1,950 @@
+/**
+ * Unit tests for `RuntimeEventAdapter` and `toLegacyAgentEvent`.
+ *
+ * Covers every one of the 13 `AgentRuntimeEvent` variants enumerated
+ * in `@cline/shared/src/agent.ts:390-468`. For each variant the
+ * test asserts the mapping described in PLAN.md §3.3.2 (with the
+ * text/reasoning-delta correction documented at the top of
+ * `runtime-event-adapter.ts`).
+ *
+ * @see PLAN.md §3.3.2 — variant-by-variant OLD → NEW mapping.
+ * @see packages/core/src/runtime/runtime-event-adapter.ts
+ *
+ * Landed with PLAN.md Step 8a.
+ */
+
+import type {
+	AgentMessage,
+	AgentRunResult,
+	AgentRuntimeEvent,
+	AgentRuntimeStateSnapshot,
+	AgentToolCallPart,
+	AgentUsage,
+} from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	RuntimeEventAdapter,
+	toLegacyAgentEvent,
+} from "./runtime-event-adapter";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeSnapshot(
+	overrides: Partial<AgentRuntimeStateSnapshot> = {},
+): AgentRuntimeStateSnapshot {
+	return {
+		agentId: "agent_test",
+		runId: "run_test",
+		status: "running",
+		iteration: 1,
+		messages: [],
+		pendingToolCalls: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0,
+		},
+		...overrides,
+	};
+}
+
+function makeMessage(
+	overrides: Partial<AgentMessage> = {},
+	content: AgentMessage["content"] = [],
+): AgentMessage {
+	return {
+		id: "msg_test",
+		role: "assistant",
+		content,
+		createdAt: 1_000_000,
+		...overrides,
+	};
+}
+
+function makeToolCall(
+	overrides: Partial<AgentToolCallPart> = {},
+): AgentToolCallPart {
+	return {
+		type: "tool-call",
+		toolCallId: "call_1",
+		toolName: "read_file",
+		input: { path: "/tmp/x" },
+		...overrides,
+	};
+}
+
+function makeUsage(overrides: Partial<AgentUsage> = {}): AgentUsage {
+	return {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		totalCost: 0,
+		...overrides,
+	};
+}
+
+function makeResult(overrides: Partial<AgentRunResult> = {}): AgentRunResult {
+	return {
+		agentId: "agent_test",
+		runId: "run_test",
+		status: "completed",
+		iterations: 1,
+		outputText: "done",
+		messages: [],
+		usage: makeUsage(),
+		...overrides,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Suppressed events
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — suppressed events", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("suppresses run-started (§3.3.2 row 1)", () => {
+		expect(
+			adapter.translate({ type: "run-started", snapshot: makeSnapshot() }),
+		).toEqual([]);
+	});
+
+	it("suppresses message-added (§3.3.2 final note)", () => {
+		expect(
+			adapter.translate({
+				type: "message-added",
+				snapshot: makeSnapshot(),
+				message: makeMessage(),
+			}),
+		).toEqual([]);
+	});
+});
+
+describe("RuntimeEventAdapter — status notices", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("preserves bounded compaction reasons", () => {
+		for (const reason of [
+			"auto_compaction",
+			"manual_compaction",
+			"compaction_budget_emergency",
+		] as const) {
+			const out = adapter.translate({
+				type: "status-notice",
+				snapshot: makeSnapshot(),
+				message: "compaction status",
+				metadata: { reason },
+			});
+
+			expect(out).toEqual([
+				{
+					type: "notice",
+					noticeType: "status",
+					displayRole: "status",
+					message: "compaction status",
+					reason,
+					metadata: { reason },
+				},
+			]);
+		}
+	});
+
+	it("does not promote arbitrary status reasons", () => {
+		const out = adapter.translate({
+			type: "status-notice",
+			snapshot: makeSnapshot(),
+			message: "custom",
+			metadata: { reason: "surprise" },
+		});
+
+		expect(out[0]).toMatchObject({
+			type: "notice",
+			noticeType: "status",
+			message: "custom",
+			reason: undefined,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Iteration lifecycle
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — iteration lifecycle", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("maps turn-started → iteration_start { iteration }", () => {
+		const out = adapter.translate({
+			type: "turn-started",
+			snapshot: makeSnapshot({ iteration: 3 }),
+			iteration: 3,
+		});
+		expect(out).toEqual([{ type: "iteration_start", iteration: 3 }]);
+	});
+
+	it("maps turn-finished → iteration_end with hadToolCalls=true when tools fired", () => {
+		const out = adapter.translate({
+			type: "turn-finished",
+			snapshot: makeSnapshot({ iteration: 2 }),
+			iteration: 2,
+			toolCallCount: 4,
+		});
+		expect(out).toEqual([
+			{
+				type: "iteration_end",
+				iteration: 2,
+				hadToolCalls: true,
+				toolCallCount: 4,
+			},
+		]);
+	});
+
+	it("maps turn-finished with zero tool calls → hadToolCalls:false", () => {
+		const out = adapter.translate({
+			type: "turn-finished",
+			snapshot: makeSnapshot({ iteration: 1 }),
+			iteration: 1,
+			toolCallCount: 0,
+		});
+		expect(out).toEqual([
+			{
+				type: "iteration_end",
+				iteration: 1,
+				hadToolCalls: false,
+				toolCallCount: 0,
+			},
+		]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Streaming content deltas
+// ---------------------------------------------------------------------------
+//
+// PLAN §3.3.2 suggested "first delta → content_start, subsequent →
+// content_update". The legacy-emitter shape makes that impossible —
+// AgentContentUpdateEvent.contentType is strictly "tool"
+// (shared/agents/types.ts:87). The adapter preserves the legacy
+// per-delta content_start behavior
+// (turn-processor.ts:82-87,113-118).
+
+describe("RuntimeEventAdapter — streaming content deltas", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("maps every assistant-text-delta → content_start(text)", () => {
+		const first = adapter.translate({
+			type: "assistant-text-delta",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			text: "He",
+			accumulatedText: "He",
+		});
+		const second = adapter.translate({
+			type: "assistant-text-delta",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			text: "llo",
+			accumulatedText: "Hello",
+		});
+		expect(first).toEqual([
+			{
+				type: "content_start",
+				contentType: "text",
+				text: "He",
+				accumulated: "He",
+			},
+		]);
+		expect(second).toEqual([
+			{
+				type: "content_start",
+				contentType: "text",
+				text: "llo",
+				accumulated: "Hello",
+			},
+		]);
+	});
+
+	it("maps assistant-reasoning-delta → content_start(reasoning) with redacted:true", () => {
+		const out = adapter.translate({
+			type: "assistant-reasoning-delta",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			text: "thinking...",
+			accumulatedText: "thinking...",
+			redacted: true,
+		});
+		expect(out).toEqual([
+			{
+				type: "content_start",
+				contentType: "reasoning",
+				reasoning: "thinking...",
+				redacted: true,
+			},
+		]);
+	});
+
+	it("defaults redacted to false when missing", () => {
+		const out = adapter.translate({
+			type: "assistant-reasoning-delta",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			text: "thinking",
+			accumulatedText: "thinking",
+		});
+		expect(out[0]).toMatchObject({
+			type: "content_start",
+			contentType: "reasoning",
+			redacted: false,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Assistant-message → content_end synthesis
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — assistant-message → content_end", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("fires content_end(text) when the message has text parts", () => {
+		const out = adapter.translate({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, [{ type: "text", text: "hi there" }]),
+			finishReason: "stop",
+		});
+		expect(out).toEqual([
+			{ type: "content_end", contentType: "text", text: "hi there" },
+		]);
+	});
+
+	it("fires content_end(reasoning) when the message has reasoning parts", () => {
+		const out = adapter.translate({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, [{ type: "reasoning", text: "let me think" }]),
+			finishReason: "stop",
+		});
+		expect(out).toEqual([
+			{
+				type: "content_end",
+				contentType: "reasoning",
+				reasoning: "let me think",
+			},
+		]);
+	});
+
+	it("fires BOTH content_end events when the message has text AND reasoning", () => {
+		const out = adapter.translate({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, [
+				{ type: "reasoning", text: "pondering" },
+				{ type: "text", text: "answer" },
+			]),
+			finishReason: "stop",
+		});
+		expect(out).toHaveLength(2);
+		expect(out).toContainEqual({
+			type: "content_end",
+			contentType: "text",
+			text: "answer",
+		});
+		expect(out).toContainEqual({
+			type: "content_end",
+			contentType: "reasoning",
+			reasoning: "pondering",
+		});
+	});
+
+	it("fires NO content_end events when the message has no text/reasoning", () => {
+		const out = adapter.translate({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, [
+				{
+					type: "tool-call",
+					toolCallId: "x",
+					toolName: "foo",
+					input: {},
+				},
+			]),
+			finishReason: "tool-calls",
+		});
+		expect(out).toEqual([]);
+	});
+
+	it("concatenates multiple text parts into one content_end.text", () => {
+		const out = adapter.translate({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, [
+				{ type: "text", text: "Hel" },
+				{ type: "text", text: "lo" },
+			]),
+			finishReason: "stop",
+		});
+		expect(out[0]).toEqual({
+			type: "content_end",
+			contentType: "text",
+			text: "Hello",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Tool lifecycle + durationMs bookkeeping
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — tool lifecycle", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("maps tool-started → content_start(tool) with toolName/toolCallId/input", () => {
+		const toolCall = makeToolCall({
+			toolCallId: "call_abc",
+			toolName: "read_file",
+			input: { path: "/tmp/a" },
+		});
+		const out = adapter.translate({
+			type: "tool-started",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			toolCall,
+		});
+		expect(out).toEqual([
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: "read_file",
+				toolCallId: "call_abc",
+				input: { path: "/tmp/a" },
+			},
+		]);
+	});
+
+	it("maps tool-updated → content_update(tool) with update", () => {
+		const toolCall = makeToolCall({ toolCallId: "call_abc" });
+		const out = adapter.translate({
+			type: "tool-updated",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			toolCall,
+			update: { progress: 0.5 },
+		});
+		expect(out).toEqual([
+			{
+				type: "content_update",
+				contentType: "tool",
+				toolName: "read_file",
+				toolCallId: "call_abc",
+				update: { progress: 0.5 },
+			},
+		]);
+	});
+
+	it("maps tool-finished with tracked timing → content_end(tool) with durationMs", () => {
+		vi.useFakeTimers();
+		try {
+			vi.setSystemTime(new Date(1_700_000_000_000));
+			const toolCall = makeToolCall({ toolCallId: "call_42" });
+			adapter.translate({
+				type: "tool-started",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				toolCall,
+			});
+			vi.advanceTimersByTime(250);
+			const out = adapter.translate({
+				type: "tool-finished",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				toolCall,
+				message: {
+					id: "msg_tool",
+					role: "tool",
+					createdAt: 1_700_000_000_250,
+					content: [
+						{
+							type: "tool-result",
+							toolCallId: "call_42",
+							toolName: "read_file",
+							output: "file contents here",
+						},
+					],
+				},
+			});
+			expect(out).toEqual([
+				{
+					type: "content_end",
+					contentType: "tool",
+					toolName: "read_file",
+					toolCallId: "call_42",
+					output: "file contents here",
+					error: undefined,
+					durationMs: 250,
+				},
+			]);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("populates error on tool-finished when the result is marked isError", () => {
+		const toolCall = makeToolCall({ toolCallId: "call_err" });
+		adapter.translate({
+			type: "tool-started",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			toolCall,
+		});
+		const out = adapter.translate({
+			type: "tool-finished",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			toolCall,
+			message: {
+				id: "msg_err",
+				role: "tool",
+				createdAt: 0,
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_err",
+						toolName: "read_file",
+						output: "file not found",
+						isError: true,
+					},
+				],
+			},
+		});
+		expect(out[0]).toMatchObject({
+			type: "content_end",
+			contentType: "tool",
+			error: "file not found",
+		});
+	});
+
+	it("reports durationMs:undefined when tool-started was never seen", () => {
+		const toolCall = makeToolCall({ toolCallId: "call_orphan" });
+		const out = adapter.translate({
+			type: "tool-finished",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			toolCall,
+			message: {
+				id: "m",
+				role: "tool",
+				createdAt: 0,
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_orphan",
+						toolName: "read_file",
+						output: "ok",
+					},
+				],
+			},
+		});
+		expect(out[0]).toMatchObject({ durationMs: undefined });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Usage rolling totals
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — usage rolling totals", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("first usage-updated: delta == accumulated (prior snapshot is zero)", () => {
+		const out = adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({
+				inputTokens: 100,
+				outputTokens: 40,
+				cacheReadTokens: 5,
+				totalCost: 0.01,
+			}),
+		});
+		expect(out[0]).toEqual({
+			type: "usage",
+			inputTokens: 100,
+			outputTokens: 40,
+			cacheReadTokens: 5,
+			cacheWriteTokens: undefined,
+			cost: 0.01,
+			totalInputTokens: 100,
+			totalOutputTokens: 40,
+			totalCacheReadTokens: 5,
+			totalCacheWriteTokens: undefined,
+			totalCost: 0.01,
+		});
+	});
+
+	it("second usage-updated: delta = (next - prior), totals are accumulated", () => {
+		adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({
+				inputTokens: 100,
+				outputTokens: 40,
+				totalCost: 0.01,
+			}),
+		});
+		const out = adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({
+				inputTokens: 150,
+				outputTokens: 60,
+				totalCost: 0.03,
+			}),
+		});
+		expect(out[0]).toMatchObject({
+			inputTokens: 50,
+			outputTokens: 20,
+			totalInputTokens: 150,
+			totalOutputTokens: 60,
+			totalCost: 0.03,
+		});
+		// Floating-point-safe: 0.03 - 0.01 ≠ exactly 0.02 in IEEE-754.
+		expect((out[0] as { cost?: number }).cost).toBeCloseTo(0.02, 10);
+	});
+
+	it("omits cost when the totalCost delta is zero", () => {
+		adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({ inputTokens: 10 }),
+		});
+		const out = adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({ inputTokens: 20 }),
+		});
+		expect(out[0]).toMatchObject({ cost: undefined });
+	});
+
+	it("clamps negative deltas to zero (defensive)", () => {
+		adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({ inputTokens: 100 }),
+		});
+		const out = adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({ inputTokens: 50 }),
+		});
+		expect(out[0]).toMatchObject({ inputTokens: 0 });
+	});
+
+	it("resets rolling totals via reset()", () => {
+		adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({ inputTokens: 100, outputTokens: 50 }),
+		});
+		adapter.reset();
+		const out = adapter.translate({
+			type: "usage-updated",
+			snapshot: makeSnapshot(),
+			usage: makeUsage({ inputTokens: 10, outputTokens: 5 }),
+		});
+		expect(out[0]).toMatchObject({
+			inputTokens: 10,
+			outputTokens: 5,
+			totalInputTokens: 10,
+			totalOutputTokens: 5,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Run lifecycle
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — run lifecycle", () => {
+	let adapter: RuntimeEventAdapter;
+	beforeEach(() => {
+		adapter = new RuntimeEventAdapter();
+	});
+
+	it("maps run-finished { status:completed } → done { reason:completed }", () => {
+		const out = adapter.translate({
+			type: "run-finished",
+			snapshot: makeSnapshot(),
+			result: makeResult({
+				status: "completed",
+				outputText: "done",
+				iterations: 3,
+				usage: makeUsage({
+					inputTokens: 100,
+					outputTokens: 50,
+					totalCost: 0.015,
+				}),
+			}),
+		});
+		expect(out[0]).toEqual({
+			type: "done",
+			reason: "completed",
+			text: "done",
+			iterations: 3,
+			usage: {
+				inputTokens: 100,
+				outputTokens: 50,
+				cacheReadTokens: undefined,
+				cacheWriteTokens: undefined,
+				totalCost: 0.015,
+			},
+		});
+	});
+
+	it("maps run-finished { status:aborted } → done { reason:aborted }", () => {
+		const out = adapter.translate({
+			type: "run-finished",
+			snapshot: makeSnapshot(),
+			result: makeResult({ status: "aborted", outputText: "" }),
+		});
+		expect(out[0]).toMatchObject({ type: "done", reason: "aborted" });
+	});
+
+	it("maps run-finished { status:failed } → done { reason:error }", () => {
+		const out = adapter.translate({
+			type: "run-finished",
+			snapshot: makeSnapshot(),
+			result: makeResult({ status: "failed" }),
+		});
+		expect(out[0]).toMatchObject({ type: "done", reason: "error" });
+	});
+
+	it("maps run-failed → error { recoverable:false, iteration }", () => {
+		const err = new Error("boom");
+		const out = adapter.translate({
+			type: "run-failed",
+			snapshot: makeSnapshot({ iteration: 4 }),
+			error: err,
+		});
+		expect(out[0]).toEqual({
+			type: "error",
+			error: err,
+			recoverable: false,
+			iteration: 4,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Stateless helper
+// ---------------------------------------------------------------------------
+
+describe("toLegacyAgentEvent — stateless helper", () => {
+	it("returns undefined for suppressed events", () => {
+		expect(
+			toLegacyAgentEvent({ type: "run-started", snapshot: makeSnapshot() }),
+		).toBeUndefined();
+		expect(
+			toLegacyAgentEvent({
+				type: "message-added",
+				snapshot: makeSnapshot(),
+				message: makeMessage(),
+			}),
+		).toBeUndefined();
+	});
+
+	it("returns the first legacy event when the mapping yields multiple", () => {
+		const result = toLegacyAgentEvent({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, [
+				{ type: "reasoning", text: "r" },
+				{ type: "text", text: "t" },
+			]),
+			finishReason: "stop",
+		});
+		expect(result?.type).toBe("content_end");
+	});
+
+	it("returns undefined when the mapping yields zero events", () => {
+		const result = toLegacyAgentEvent({
+			type: "assistant-message",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			message: makeMessage({}, []),
+			finishReason: "stop",
+		});
+		expect(result).toBeUndefined();
+	});
+
+	it("maps a single run-finished one-shot correctly", () => {
+		const event = toLegacyAgentEvent({
+			type: "run-finished",
+			snapshot: makeSnapshot(),
+			result: makeResult({
+				status: "completed",
+				outputText: "ok",
+				iterations: 1,
+			}),
+		});
+		expect(event).toMatchObject({
+			type: "done",
+			reason: "completed",
+			text: "ok",
+			iterations: 1,
+		});
+	});
+
+	it("reports durationMs=undefined on tool-finished (one-shot has no timing)", () => {
+		const toolCall = makeToolCall({ toolCallId: "c1" });
+		const event = toLegacyAgentEvent({
+			type: "tool-finished",
+			snapshot: makeSnapshot(),
+			iteration: 1,
+			toolCall,
+			message: {
+				id: "m",
+				role: "tool",
+				createdAt: 0,
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "c1",
+						toolName: "read_file",
+						output: "ok",
+					},
+				],
+			},
+		});
+		expect(event).toMatchObject({ durationMs: undefined });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Exhaustiveness — all 13 AgentRuntimeEvent variants
+// ---------------------------------------------------------------------------
+
+describe("RuntimeEventAdapter — exhaustiveness", () => {
+	it("handles every one of the 13 AgentRuntimeEvent variants without throwing", () => {
+		const adapter = new RuntimeEventAdapter();
+		const variants: AgentRuntimeEvent[] = [
+			{ type: "run-started", snapshot: makeSnapshot() },
+			{
+				type: "message-added",
+				snapshot: makeSnapshot(),
+				message: makeMessage(),
+			},
+			{ type: "turn-started", snapshot: makeSnapshot(), iteration: 1 },
+			{
+				type: "assistant-text-delta",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				text: "a",
+				accumulatedText: "a",
+			},
+			{
+				type: "assistant-reasoning-delta",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				text: "r",
+				accumulatedText: "r",
+			},
+			{
+				type: "assistant-message",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				message: makeMessage({}, [{ type: "text", text: "hi" }]),
+				finishReason: "stop",
+			},
+			{
+				type: "tool-started",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				toolCall: makeToolCall(),
+			},
+			{
+				type: "tool-updated",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				toolCall: makeToolCall(),
+				update: {},
+			},
+			{
+				type: "tool-finished",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				toolCall: makeToolCall(),
+				message: {
+					id: "m",
+					role: "tool",
+					createdAt: 0,
+					content: [
+						{
+							type: "tool-result",
+							toolCallId: "call_1",
+							toolName: "read_file",
+							output: "",
+						},
+					],
+				},
+			},
+			{
+				type: "usage-updated",
+				snapshot: makeSnapshot(),
+				usage: makeUsage(),
+			},
+			{
+				type: "turn-finished",
+				snapshot: makeSnapshot(),
+				iteration: 1,
+				toolCallCount: 0,
+			},
+			{
+				type: "run-finished",
+				snapshot: makeSnapshot(),
+				result: makeResult(),
+			},
+			{
+				type: "run-failed",
+				snapshot: makeSnapshot(),
+				error: new Error("boom"),
+			},
+		];
+		expect(variants).toHaveLength(13);
+		for (const event of variants) {
+			expect(() => adapter.translate(event)).not.toThrow();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-event-adapter.ts b/sdk/packages/core/src/runtime/orchestration/runtime-event-adapter.ts
new file mode 100644
index 0000000..1ca6063
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-event-adapter.ts
@@ -0,0 +1,438 @@
+/**
+ * Adapter from the new `AgentRuntimeEvent` union (13 variants, defined
+ * in `@cline/shared/src/agent.ts`) to the legacy `AgentEvent` union
+ * (9 top-level types, defined in
+ * `@cline/shared/src/agents/types.ts`) consumed by today's
+ * `Agent.subscribeEvents` callback.
+ *
+ * @see PLAN.md §3.1  — new file introduced alongside the core runtime port.
+ * @see PLAN.md §3.3.2 — variant-by-variant OLD → NEW mapping.
+ * @see PLAN.md §3.2.4 — called from `Agent.subscribeEvents` inside the
+ *                       legacy-agent facade.
+ *
+ * --- IMPLEMENTATION NOTE — PLAN §3.3.2 text/reasoning-delta rows ----------
+ *
+ * PLAN.md §3.3.2 describes `assistant-text-delta` as "first delta →
+ * content_start, subsequent → content_update". The **actual** legacy
+ * shape forbids this: `AgentContentUpdateEvent.contentType` is
+ * hard-typed as `"tool"` in
+ * `packages/shared/src/agents/types.ts:87`, and the legacy
+ * turn-processor
+ * (`packages/agents/src/runtime/turn-processor.ts:82-87,113-118`)
+ * emits a `content_start` event for **every** text delta and for
+ * **every** reasoning delta — not just the first. This adapter
+ * preserves that observable behavior (what every legacy consumer
+ * relies on today) over the description in §3.3.2.
+ *
+ *   text deltas      → content_start { contentType:"text", text,
+ *                        accumulated } (per delta)
+ *   reasoning deltas → content_start { contentType:"reasoning",
+ *                        reasoning, redacted } (per delta)
+ *   assistant-message → one content_end { contentType:"text", text }
+ *                        if any text parts; one
+ *                        content_end { contentType:"reasoning", reasoning }
+ *                        if any reasoning parts
+ *                        (turn-processor.ts:157-170).
+ *
+ * --- STATEFUL BOOK-KEEPING ------------------------------------------------
+ *
+ *  1. Rolling usage totals. `usage-updated` carries the already-
+ *     accumulated snapshot (agent-runtime.ts:668-683). Legacy
+ *     `AgentUsageEvent` wants both per-turn delta and accumulated
+ *     totals; the adapter subtracts the previous accumulated value
+ *     from the incoming one to produce the delta.
+ *  2. Tool timing. `tool-finished` does not carry `durationMs`. The
+ *     adapter records `Date.now()` on `tool-started` (keyed by
+ *     `toolCallId`) and computes `durationMs` at `tool-finished`.
+ *     Matches `tool-orchestrator.ts:112-131`.
+ *
+ * Both are scoped to a single adapter instance and cleared by
+ * `reset()`.
+ */
+
+import type {
+	AgentEvent,
+	AgentFinishReason,
+	AgentMessage,
+	AgentReasoningPart,
+	AgentRuntimeEvent,
+	AgentTextPart,
+	AgentToolResultPart,
+	AgentUsage,
+	LegacyAgentUsage,
+} from "@cline/shared";
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+type StatusNoticeReason = Extract<AgentEvent, { type: "notice" }>["reason"];
+
+function resolveStatusNoticeReason(
+	reason: unknown,
+): StatusNoticeReason | undefined {
+	switch (reason) {
+		case "auto_compaction":
+		case "manual_compaction":
+		case "compaction_budget_emergency":
+			return reason;
+		default:
+			return undefined;
+	}
+}
+
+function extractTextPart(message: AgentMessage): string | undefined {
+	const parts = message.content.filter(
+		(part): part is AgentTextPart => part.type === "text",
+	);
+	if (parts.length === 0) {
+		return undefined;
+	}
+	return parts.map((part) => part.text).join("");
+}
+
+function extractReasoningPart(
+	message: AgentMessage,
+): { reasoning: string; redacted: boolean } | undefined {
+	const parts = message.content.filter(
+		(part): part is AgentReasoningPart => part.type === "reasoning",
+	);
+	if (parts.length === 0) {
+		return undefined;
+	}
+	return {
+		reasoning: parts.map((part) => part.text).join(""),
+		redacted: parts.some((part) => part.redacted === true),
+	};
+}
+
+function extractToolResultPart(
+	message: AgentMessage,
+): AgentToolResultPart | undefined {
+	return message.content.find(
+		(part): part is AgentToolResultPart => part.type === "tool-result",
+	);
+}
+
+function textFromMessage(message: AgentMessage | undefined): string {
+	if (!message) {
+		return "";
+	}
+	return extractTextPart(message) ?? "";
+}
+
+function statusToLegacyFinishReason(
+	status: "completed" | "aborted" | "failed",
+): AgentFinishReason {
+	switch (status) {
+		case "completed":
+			return "completed";
+		case "aborted":
+			return "aborted";
+		case "failed":
+			return "error";
+	}
+}
+
+function deriveToolError(
+	result: AgentToolResultPart | undefined,
+): string | undefined {
+	if (!result || result.isError !== true) {
+		return undefined;
+	}
+	if (typeof result.output === "string") {
+		return result.output;
+	}
+	if (result.output instanceof Error) {
+		return result.output.message;
+	}
+	try {
+		return JSON.stringify(result.output);
+	} catch {
+		return String(result.output);
+	}
+}
+
+// =============================================================================
+// Stateful adapter
+// =============================================================================
+
+/**
+ * Per-subscriber adapter instance. Constructed once per
+ * `Agent.subscribeEvents` registration (or per `SessionRuntime`),
+ * used for the lifetime of that subscription, and `reset()` at the
+ * start of every new run.
+ *
+ * `translate(event)` returns zero, one, or two `AgentEvent`s. An
+ * array is needed because a single `assistant-message` may yield both
+ * a text `content_end` and a reasoning `content_end`. Empty array
+ * means the event is intentionally suppressed (§3.3.2 rows
+ * `run-started`, `message-added`).
+ */
+export class RuntimeEventAdapter {
+	private lastUsage: AgentUsage = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		totalCost: 0,
+	};
+
+	private toolStartedAt = new Map<string, number>();
+
+	translate(event: AgentRuntimeEvent): AgentEvent[] {
+		switch (event.type) {
+			case "run-started":
+				return [];
+			case "message-added":
+				return [];
+			case "turn-started":
+				return [{ type: "iteration_start", iteration: event.iteration }];
+			case "turn-finished":
+				return [
+					{
+						type: "iteration_end",
+						iteration: event.iteration,
+						hadToolCalls: event.toolCallCount > 0,
+						toolCallCount: event.toolCallCount,
+					},
+				];
+			case "assistant-text-delta":
+				return [
+					{
+						type: "content_start",
+						contentType: "text",
+						text: event.text,
+						accumulated: event.accumulatedText,
+					},
+				];
+			case "assistant-reasoning-delta":
+				return [
+					{
+						type: "content_start",
+						contentType: "reasoning",
+						reasoning: event.text,
+						redacted: event.redacted === true,
+					},
+				];
+			case "assistant-message":
+				return this.translateAssistantMessage(event.message);
+			case "tool-started":
+				return this.translateToolStarted(event);
+			case "tool-updated":
+				return [
+					{
+						type: "content_update",
+						contentType: "tool",
+						toolName: event.toolCall.toolName,
+						toolCallId: event.toolCall.toolCallId,
+						update: event.update,
+					},
+				];
+			case "tool-finished":
+				return this.translateToolFinished(event);
+			case "usage-updated":
+				return this.translateUsage(event.usage);
+			case "status-notice":
+				return [
+					{
+						type: "notice",
+						noticeType: "status",
+						displayRole: "status",
+						message: event.message,
+						reason: resolveStatusNoticeReason(event.metadata?.reason),
+						metadata: event.metadata,
+					},
+				];
+			case "run-finished":
+				return this.translateRunFinished(event.result);
+			case "run-failed":
+				return [
+					{
+						type: "error",
+						error: event.error,
+						recoverable: false,
+						iteration: event.snapshot.iteration,
+					},
+				];
+			default: {
+				const _exhaustive: never = event;
+				return _exhaustive;
+			}
+		}
+	}
+
+	reset(): void {
+		this.lastUsage = {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0,
+		};
+		this.toolStartedAt.clear();
+	}
+
+	// ------- per-variant translators ------------------------------------
+
+	private translateAssistantMessage(message: AgentMessage): AgentEvent[] {
+		const out: AgentEvent[] = [];
+		const text = extractTextPart(message);
+		if (text !== undefined) {
+			out.push({ type: "content_end", contentType: "text", text });
+		}
+		const reasoning = extractReasoningPart(message);
+		if (reasoning !== undefined) {
+			out.push({
+				type: "content_end",
+				contentType: "reasoning",
+				reasoning: reasoning.reasoning,
+			});
+		}
+		return out;
+	}
+
+	private translateToolStarted(event: {
+		toolCall: { toolCallId: string; toolName: string; input: unknown };
+	}): AgentEvent[] {
+		this.toolStartedAt.set(event.toolCall.toolCallId, Date.now());
+		return [
+			{
+				type: "content_start",
+				contentType: "tool",
+				toolName: event.toolCall.toolName,
+				toolCallId: event.toolCall.toolCallId,
+				input: event.toolCall.input,
+			},
+		];
+	}
+
+	private translateToolFinished(event: {
+		toolCall: { toolCallId: string; toolName: string };
+		message: AgentMessage;
+	}): AgentEvent[] {
+		const startedAt = this.toolStartedAt.get(event.toolCall.toolCallId);
+		const durationMs =
+			startedAt === undefined ? undefined : Date.now() - startedAt;
+		this.toolStartedAt.delete(event.toolCall.toolCallId);
+		const result = extractToolResultPart(event.message);
+		const output = result?.output;
+		const error = deriveToolError(result);
+		return [
+			{
+				type: "content_end",
+				contentType: "tool",
+				toolName: event.toolCall.toolName,
+				toolCallId: event.toolCall.toolCallId,
+				output,
+				error,
+				durationMs,
+			},
+		];
+	}
+
+	private translateUsage(next: AgentUsage): AgentEvent[] {
+		const deltaInput = next.inputTokens - this.lastUsage.inputTokens;
+		const deltaOutput = next.outputTokens - this.lastUsage.outputTokens;
+		const deltaCacheRead =
+			next.cacheReadTokens - this.lastUsage.cacheReadTokens;
+		const deltaCacheWrite =
+			next.cacheWriteTokens - this.lastUsage.cacheWriteTokens;
+		const prevCost = this.lastUsage.totalCost ?? 0;
+		const nextCost = next.totalCost ?? 0;
+		const deltaCost = nextCost - prevCost;
+		this.lastUsage = {
+			inputTokens: next.inputTokens,
+			outputTokens: next.outputTokens,
+			cacheReadTokens: next.cacheReadTokens,
+			cacheWriteTokens: next.cacheWriteTokens,
+			totalCost: next.totalCost,
+		};
+		return [
+			{
+				type: "usage",
+				inputTokens: Math.max(0, deltaInput),
+				outputTokens: Math.max(0, deltaOutput),
+				cacheReadTokens:
+					deltaCacheRead === 0 ? undefined : Math.max(0, deltaCacheRead),
+				cacheWriteTokens:
+					deltaCacheWrite === 0 ? undefined : Math.max(0, deltaCacheWrite),
+				cost: deltaCost === 0 ? undefined : deltaCost,
+				totalInputTokens: next.inputTokens,
+				totalOutputTokens: next.outputTokens,
+				totalCacheReadTokens:
+					next.cacheReadTokens === 0 ? undefined : next.cacheReadTokens,
+				totalCacheWriteTokens:
+					next.cacheWriteTokens === 0 ? undefined : next.cacheWriteTokens,
+				totalCost: next.totalCost,
+			},
+		];
+	}
+
+	private translateRunFinished(result: {
+		status: "completed" | "aborted" | "failed";
+		outputText: string;
+		iterations: number;
+		usage: AgentUsage;
+	}): AgentEvent[] {
+		const usage: LegacyAgentUsage = {
+			inputTokens: result.usage.inputTokens,
+			outputTokens: result.usage.outputTokens,
+			cacheReadTokens:
+				result.usage.cacheReadTokens === 0
+					? undefined
+					: result.usage.cacheReadTokens,
+			cacheWriteTokens:
+				result.usage.cacheWriteTokens === 0
+					? undefined
+					: result.usage.cacheWriteTokens,
+			totalCost: result.usage.totalCost,
+		};
+		return [
+			{
+				type: "done",
+				reason: statusToLegacyFinishReason(result.status),
+				text: result.outputText,
+				iterations: result.iterations,
+				usage,
+			},
+		];
+	}
+}
+
+// =============================================================================
+// Stateless convenience export
+// =============================================================================
+
+/**
+ * Stateless translator. Works correctly for every variant except
+ * those that require bookkeeping:
+ *
+ *  - `usage-updated` — deltas cannot be computed without a prior
+ *    snapshot; this function treats the prior snapshot as zero (so
+ *    delta == accumulated). Adequate for a single event, incorrect
+ *    across multiple.
+ *  - `tool-finished` — `durationMs` is reported as `undefined`
+ *    because the corresponding `tool-started` was never observed by
+ *    this one-shot adapter.
+ *
+ * Production code must use `RuntimeEventAdapter` for multi-event
+ * runs; this function exists for ad-hoc unit tests and one-shot
+ * translations where bookkeeping does not matter.
+ *
+ * Returns `undefined` when the event maps to zero legacy events
+ * (`run-started`, `message-added`, or an `assistant-message` that
+ * carries no text/reasoning parts). When an event produces multiple
+ * legacy events (e.g. `assistant-message` with both text and
+ * reasoning parts), only the first is returned; callers needing the
+ * full array must use `RuntimeEventAdapter.translate()`.
+ */
+export function toLegacyAgentEvent(
+	event: AgentRuntimeEvent,
+): AgentEvent | undefined {
+	const adapter = new RuntimeEventAdapter();
+	const translated = adapter.translate(event);
+	return translated[0];
+}
+
+export { textFromMessage };
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-oauth-token-manager.test.ts b/sdk/packages/core/src/runtime/orchestration/runtime-oauth-token-manager.test.ts
new file mode 100644
index 0000000..88f799a
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-oauth-token-manager.test.ts
@@ -0,0 +1,195 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	OAuthReauthRequiredError,
+	RuntimeOAuthTokenManager,
+} from "./runtime-oauth-token-manager";
+
+const {
+	getValidOpenAICodexCredentials,
+	getValidClineCredentials,
+	getValidOcaCredentials,
+} = vi.hoisted(() => ({
+	getValidOpenAICodexCredentials: vi.fn(),
+	getValidClineCredentials: vi.fn(),
+	getValidOcaCredentials: vi.fn(),
+}));
+
+vi.mock("../../auth/codex", () => ({
+	getValidOpenAICodexCredentials,
+}));
+
+vi.mock("../../auth/cline", () => ({
+	getValidClineCredentials,
+}));
+
+vi.mock("../../auth/oca", () => ({
+	getValidOcaCredentials,
+}));
+
+describe("RuntimeOAuthTokenManager", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("refreshes and persists OpenAI Codex OAuth credentials", async () => {
+		const getProviderSettings = vi.fn().mockReturnValue({
+			provider: "openai-codex",
+			auth: {
+				accessToken: "access-old",
+				refreshToken: "refresh-old",
+				expiresAt: Date.now() - 1_000,
+				accountId: "acct-old",
+			},
+		});
+		const saveProviderSettings = vi.fn();
+
+		getValidOpenAICodexCredentials.mockResolvedValueOnce({
+			access: "access-new",
+			refresh: "refresh-new",
+			expires: 4_000_000_000_000,
+			accountId: "acct-new",
+		});
+
+		const manager = new RuntimeOAuthTokenManager({
+			providerSettingsManager: {
+				getProviderSettings,
+				saveProviderSettings,
+			} as never,
+		});
+
+		const result = await manager.resolveProviderApiKey({
+			providerId: "openai-codex",
+		});
+
+		expect(result).toMatchObject({
+			apiKey: "access-new",
+			accountId: "acct-new",
+			refreshed: true,
+		});
+		expect(saveProviderSettings).toHaveBeenCalledWith(
+			expect.objectContaining({
+				auth: expect.objectContaining({
+					accessToken: "access-new",
+					refreshToken: "refresh-new",
+					accountId: "acct-new",
+					expiresAt: 4_000_000_000_000,
+				}),
+			}),
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+	});
+
+	it("resolves ClinePass OAuth using Cline storage and WorkOS formatting", async () => {
+		const getProviderSettings = vi.fn().mockReturnValue({
+			provider: "cline",
+			baseUrl: "https://api.cline.test",
+			auth: {
+				accessToken: "workos:access-old",
+				refreshToken: "refresh-old",
+				expiresAt: Date.now() - 1_000,
+				accountId: "acct-old",
+			},
+		});
+		const saveProviderSettings = vi.fn();
+
+		getValidClineCredentials.mockResolvedValueOnce({
+			access: "access-new",
+			refresh: "refresh-new",
+			expires: 4_000_000_000_000,
+			accountId: "acct-new",
+		});
+
+		const manager = new RuntimeOAuthTokenManager({
+			providerSettingsManager: {
+				getProviderSettings,
+				saveProviderSettings,
+			} as never,
+		});
+
+		const result = await manager.resolveProviderApiKey({
+			providerId: "cline-pass",
+		});
+
+		expect(getProviderSettings).toHaveBeenCalledWith("cline");
+		expect(getValidClineCredentials).toHaveBeenCalledWith(
+			expect.objectContaining({
+				access: "access-old",
+				refresh: "refresh-old",
+			}),
+			expect.objectContaining({ apiBaseUrl: "https://api.cline.test" }),
+			{ forceRefresh: false },
+		);
+		expect(result).toMatchObject({
+			apiKey: "workos:access-new",
+			accountId: "acct-new",
+			refreshed: true,
+		});
+		expect(saveProviderSettings).toHaveBeenCalledWith(
+			expect.objectContaining({
+				provider: "cline",
+				auth: expect.objectContaining({
+					accessToken: "workos:access-new",
+					refreshToken: "refresh-new",
+					accountId: "acct-new",
+					expiresAt: 4_000_000_000_000,
+				}),
+			}),
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+	});
+
+	it("throws re-auth required when refresh returns null", async () => {
+		getValidOpenAICodexCredentials.mockResolvedValueOnce(null);
+		const manager = new RuntimeOAuthTokenManager({
+			providerSettingsManager: {
+				getProviderSettings: vi.fn().mockReturnValue({
+					provider: "openai-codex",
+					auth: {
+						accessToken: "access-old",
+						refreshToken: "refresh-old",
+						expiresAt: Date.now() - 1_000,
+					},
+				}),
+				saveProviderSettings: vi.fn(),
+			} as never,
+		});
+
+		await expect(
+			manager.resolveProviderApiKey({ providerId: "openai-codex" }),
+		).rejects.toBeInstanceOf(OAuthReauthRequiredError);
+	});
+
+	it("de-duplicates concurrent refresh calls per provider", async () => {
+		const refreshBarrier = Promise.resolve().then(() => ({
+			access: "access-new",
+			refresh: "refresh-new",
+			expires: Date.now() + 60_000,
+		}));
+		getValidOpenAICodexCredentials.mockImplementationOnce(
+			async () => refreshBarrier,
+		);
+
+		const manager = new RuntimeOAuthTokenManager({
+			providerSettingsManager: {
+				getProviderSettings: vi.fn().mockReturnValue({
+					provider: "openai-codex",
+					auth: {
+						accessToken: "access-old",
+						refreshToken: "refresh-old",
+						expiresAt: Date.now() - 1_000,
+					},
+				}),
+				saveProviderSettings: vi.fn(),
+			} as never,
+		});
+
+		const [first, second] = await Promise.all([
+			manager.resolveProviderApiKey({ providerId: "openai-codex" }),
+			manager.resolveProviderApiKey({ providerId: "openai-codex" }),
+		]);
+
+		expect(first?.apiKey).toBe("access-new");
+		expect(second?.apiKey).toBe("access-new");
+		expect(getValidOpenAICodexCredentials).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-oauth-token-manager.ts b/sdk/packages/core/src/runtime/orchestration/runtime-oauth-token-manager.ts
new file mode 100644
index 0000000..09c6aaa
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-oauth-token-manager.ts
@@ -0,0 +1,168 @@
+import type { ITelemetryService } from "@cline/shared";
+import { hashSecret, sdkDebug } from "../../logging/early-logger";
+import {
+	getProviderAuthHandler,
+	getProviderOAuthCredentialsFromSettings,
+	saveProviderOAuthCredentials,
+} from "../../auth/provider-auth-registry";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+import type { ProviderSettings } from "../../types/provider-settings";
+
+type ManagedOAuthProviderId = string;
+
+function authSettingsEqual(
+	a: ProviderSettings["auth"] | undefined,
+	b: ProviderSettings["auth"] | undefined,
+): boolean {
+	const aExpiry = (
+		a as (ProviderSettings["auth"] & { expiresAt?: number }) | undefined
+	)?.expiresAt;
+	const bExpiry = (
+		b as (ProviderSettings["auth"] & { expiresAt?: number }) | undefined
+	)?.expiresAt;
+	return (
+		a?.accessToken === b?.accessToken &&
+		a?.refreshToken === b?.refreshToken &&
+		a?.accountId === b?.accountId &&
+		aExpiry === bExpiry
+	);
+}
+
+export class OAuthReauthRequiredError extends Error {
+	public readonly providerId: ManagedOAuthProviderId;
+
+	constructor(providerId: ManagedOAuthProviderId) {
+		super(
+			`OAuth credentials for provider "${providerId}" are no longer valid. Re-run authentication for this provider.`,
+		);
+		this.name = "OAuthReauthRequiredError";
+		this.providerId = providerId;
+	}
+}
+
+export type RuntimeOAuthResolution = {
+	apiKey: string;
+	accountId?: string;
+	refreshed: boolean;
+};
+
+export class RuntimeOAuthTokenManager {
+	private readonly providerSettingsManager: ProviderSettingsManager;
+	private readonly telemetry?: ITelemetryService;
+	private readonly refreshInFlight = new Map<
+		ManagedOAuthProviderId,
+		Promise<RuntimeOAuthResolution | null>
+	>();
+
+	constructor(options?: {
+		providerSettingsManager?: ProviderSettingsManager;
+		telemetry?: ITelemetryService;
+	}) {
+		this.providerSettingsManager =
+			options?.providerSettingsManager ?? new ProviderSettingsManager();
+		this.telemetry = options?.telemetry;
+	}
+
+	public async resolveProviderApiKey(input: {
+		providerId: string;
+		forceRefresh?: boolean;
+	}): Promise<RuntimeOAuthResolution | null> {
+		const handler = getProviderAuthHandler(input.providerId);
+		if (!handler) {
+			return null;
+		}
+		return this.resolveWithSingleFlight(
+			handler.providerId,
+			handler.storageProviderId,
+			input.forceRefresh,
+		);
+	}
+
+	private async resolveWithSingleFlight(
+		providerId: ManagedOAuthProviderId,
+		storageProviderId: ManagedOAuthProviderId,
+		forceRefresh = false,
+	): Promise<RuntimeOAuthResolution | null> {
+		const currentInFlight = this.refreshInFlight.get(storageProviderId);
+		if (currentInFlight) {
+			return currentInFlight;
+		}
+		const pending = this.resolveProviderApiKeyInternal(
+			providerId,
+			storageProviderId,
+			forceRefresh,
+		)
+			.catch((error) => {
+				throw error;
+			})
+			.finally(() => {
+				this.refreshInFlight.delete(storageProviderId);
+			});
+		this.refreshInFlight.set(storageProviderId, pending);
+		return pending;
+	}
+
+	private async resolveProviderApiKeyInternal(
+		providerId: ManagedOAuthProviderId,
+		storageProviderId: ManagedOAuthProviderId,
+		forceRefresh: boolean,
+	): Promise<RuntimeOAuthResolution | null> {
+		const handler = getProviderAuthHandler(providerId);
+		if (!handler) {
+			return null;
+		}
+		const settings =
+			this.providerSettingsManager.getProviderSettings(storageProviderId);
+		if (!settings) {
+			sdkDebug(`oauth.resolve providerId=${providerId} storageProviderId=${storageProviderId} outcome=no_settings`);
+			return null;
+		}
+
+		const currentCredentials = getProviderOAuthCredentialsFromSettings(
+			providerId,
+			settings,
+		);
+		if (!currentCredentials) {
+			sdkDebug(`oauth.resolve providerId=${providerId} storageProviderId=${storageProviderId} outcome=no_credentials`);
+			return null;
+		}
+
+		sdkDebug(`oauth.resolve.start providerId=${providerId} storageProviderId=${storageProviderId} forceRefresh=${forceRefresh} accessTokenHash=${hashSecret(currentCredentials.access)} refreshTokenHash=${hashSecret(currentCredentials.refresh)}`);
+
+		const nextCredentials = await handler.refresh({
+			settings,
+			credentials: currentCredentials,
+			forceRefresh,
+			telemetry: this.telemetry,
+		});
+		if (!nextCredentials) {
+			sdkDebug(`oauth.resolve providerId=${providerId} outcome=refresh_returned_null`);
+			throw new OAuthReauthRequiredError(providerId);
+		}
+
+		const nextSettings: ProviderSettings = saveProviderOAuthCredentials({
+			manager: this.providerSettingsManager,
+			providerId,
+			settings,
+			credentials: nextCredentials,
+			setLastUsed: false,
+			save: false,
+		});
+		const wasRefreshed = !authSettingsEqual(settings.auth, nextSettings.auth);
+		if (wasRefreshed) {
+			sdkDebug(`oauth.resolve.refreshed providerId=${providerId} newAccessTokenHash=${hashSecret(nextCredentials.access)} newRefreshTokenHash=${hashSecret(nextCredentials.refresh)} savingToDisk=true`);
+			this.providerSettingsManager.saveProviderSettings(nextSettings, {
+				setLastUsed: false,
+				tokenSource: "oauth",
+			});
+		} else {
+			sdkDebug(`oauth.resolve providerId=${providerId} outcome=not_refreshed`);
+		}
+
+		return {
+			apiKey: handler.getApiKey(nextSettings) ?? nextCredentials.access,
+			accountId: nextCredentials.accountId,
+			refreshed: wasRefreshed,
+		};
+	}
+}
diff --git a/sdk/packages/core/src/runtime/orchestration/runtime-parity.test.ts b/sdk/packages/core/src/runtime/orchestration/runtime-parity.test.ts
new file mode 100644
index 0000000..40fab26
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/runtime-parity.test.ts
@@ -0,0 +1,165 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AgentTool } from "@cline/shared";
+import { setClineDir, setHomeDir } from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createBuiltinTools } from "../../extensions/tools";
+import { DefaultRuntimeBuilder } from "./runtime-builder";
+
+type LegacyConfig = {
+	providerId: string;
+	modelId: string;
+	apiKey: string;
+	systemPrompt: string;
+	cwd: string;
+	enableTools: boolean;
+	enableSpawnAgent: boolean;
+	enableAgentTeams: boolean;
+};
+
+function legacyBuiltinTools(cwd: string): AgentTool[] {
+	return createBuiltinTools({
+		cwd,
+		enableReadFiles: true,
+		enableSearch: true,
+		enableBash: true,
+		enableWebFetch: true,
+	});
+}
+
+function legacyBuildRuntimeEnvironment(
+	config: LegacyConfig,
+	createSpawnTool?: () => AgentTool,
+): AgentTool[] {
+	const tools: AgentTool[] = [];
+	if (config.enableTools) {
+		tools.push(...legacyBuiltinTools(config.cwd));
+	}
+	if (config.enableSpawnAgent && createSpawnTool) {
+		const spawnTool = createSpawnTool();
+		tools.push({
+			...spawnTool,
+			execute: async (input, context) => spawnTool.execute(input, context),
+		});
+	}
+	return tools;
+}
+
+function normalizeParityToolNames(toolNames: string[]): string[] {
+	// Skills are discovered from user/workspace config and can appear in tests
+	// depending on the machine state. MCP tools may also be configured outside
+	// the test workspace. They are intentionally excluded from strict legacy
+	// parity checks.
+	return toolNames.filter(
+		(toolName) => toolName !== "skills" && !toolName.includes("__"),
+	);
+}
+
+function makeEmptyWorkspaceCwd(): string {
+	return mkdtempSync(join(tmpdir(), "runtime-parity-"));
+}
+
+function makeSpawnTool(): AgentTool {
+	return {
+		name: "spawn_agent",
+		description: "Spawn a subagent",
+		inputSchema: { type: "object", properties: {}, required: [] },
+		execute: async () => ({ ok: true }),
+	};
+}
+
+describe("runtime tool parity", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+	let isolatedHomeDir = "";
+
+	beforeEach(() => {
+		isolatedHomeDir = mkdtempSync(join(tmpdir(), "runtime-parity-home-"));
+		process.env.HOME = isolatedHomeDir;
+		process.env.CLINE_DIR = join(isolatedHomeDir, ".cline");
+		setHomeDir(isolatedHomeDir);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		process.env.HOME = envSnapshot.HOME;
+		process.env.CLINE_DIR = envSnapshot.CLINE_DIR;
+		setHomeDir(envSnapshot.HOME ?? "~");
+		setClineDir(envSnapshot.CLINE_DIR ?? join("~", ".cline"));
+	});
+
+	it("matches legacy tool list when tools+spawn are enabled", async () => {
+		const config: LegacyConfig = {
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			apiKey: "key",
+			systemPrompt: "test",
+			cwd: makeEmptyWorkspaceCwd(),
+			enableTools: true,
+			enableSpawnAgent: true,
+			enableAgentTeams: false,
+		};
+		const createSpawnTool = makeSpawnTool;
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
+				(tool) => tool.name,
+			),
+		);
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config,
+			createSpawnTool,
+		});
+		const actual = runtime.tools.map((tool) => tool.name);
+
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
+	});
+
+	it("matches legacy tool list when only spawn is enabled", async () => {
+		const config: LegacyConfig = {
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			apiKey: "key",
+			systemPrompt: "test",
+			cwd: makeEmptyWorkspaceCwd(),
+			enableTools: false,
+			enableSpawnAgent: true,
+			enableAgentTeams: false,
+		};
+		const createSpawnTool = makeSpawnTool;
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
+				(tool) => tool.name,
+			),
+		);
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config,
+			createSpawnTool,
+		});
+		const actual = runtime.tools.map((tool) => tool.name);
+
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
+	});
+
+	it("matches legacy tool list when tools+spawn are disabled", async () => {
+		const config: LegacyConfig = {
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			apiKey: "key",
+			systemPrompt: "test",
+			cwd: makeEmptyWorkspaceCwd(),
+			enableTools: false,
+			enableSpawnAgent: false,
+			enableAgentTeams: false,
+		};
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config).map((tool) => tool.name),
+		);
+		const runtime = await new DefaultRuntimeBuilder().build({ config });
+		const actual = runtime.tools.map((tool) => tool.name);
+
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts
new file mode 100644
index 0000000..943fe32
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts
@@ -0,0 +1,2344 @@
+/**
+ * Unit tests for the new `SessionRuntime` orchestrator (PLAN.md
+ * Step 8d).
+ *
+ * Scope:
+ *  - constructor wires every state owner (conversation store, mistake
+ *    tracker, loop detector, hook bridge, event adapter) correctly;
+ *  - `run()` drives the injected `AgentRuntime` and fans adapted
+ *    legacy `AgentEvent`s to subscribers;
+ *  - `abort()` forwards into the active runtime;
+ *  - `subscribeEvents` delivers **legacy** `AgentEvent` shapes;
+ *  - `addTools` / `updateConnection` / `clearHistory` / `restore`
+ *    mutate state;
+ *  - `canStartRun` / `shutdown` guards enforce the lifecycle rules.
+ */
+
+import {
+	type AgentRuntime,
+	type AgentRuntimeConfig,
+	createAgentRuntime,
+} from "@cline/agents";
+import {
+	type AgentConfig,
+	type AgentEvent,
+	type AgentExtension,
+	type AgentExtensionContext,
+	type AgentMessage,
+	type AgentModel,
+	type AgentRunResult,
+	type AgentRuntimeEvent,
+	type AgentTool,
+	type AgentToolContext,
+	EMPTY_CONTENT_TEXT,
+} from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import { CLINE_INTERNAL_TELEMETRY_METADATA_KEY } from "../../services/telemetry/tool-context";
+import { MESSAGE_BUILDER_LIMIT_ENV } from "../../session/services/message-builder";
+import {
+	SessionRuntime,
+	type SessionRuntimeOrchestratorDeps,
+} from "./session-runtime-orchestrator";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeAgentConfig(overrides: Partial<AgentConfig> = {}): AgentConfig {
+	return {
+		providerId: "anthropic",
+		modelId: "claude-3-5-sonnet",
+		apiKey: "test-key",
+		systemPrompt: "You are a helpful assistant.",
+		tools: [],
+		...overrides,
+	};
+}
+
+interface FakeAgentRuntimeScript {
+	/** Events to emit synchronously when `run`/`continue` is called. */
+	readonly events?: readonly AgentRuntimeEvent[];
+	/** Result returned by `run`/`continue`. Defaults to a completed run. */
+	readonly result?: Partial<AgentRunResult>;
+	/** If true, reject with the provided error instead of returning. */
+	readonly throwError?: Error;
+}
+
+/**
+ * Build a lightweight fake `AgentRuntime` that records calls and
+ * deterministically emits the scripted events/result.
+ */
+function makeFakeAgentRuntime(script: FakeAgentRuntimeScript = {}): {
+	runtime: AgentRuntime;
+	calls: { run: unknown[]; continue: unknown[]; abort: unknown[] };
+	listeners: Set<(event: AgentRuntimeEvent) => void>;
+} {
+	const listeners = new Set<(event: AgentRuntimeEvent) => void>();
+	const calls = {
+		run: [] as unknown[],
+		continue: [] as unknown[],
+		abort: [] as unknown[],
+	};
+
+	const baseResult: AgentRunResult = {
+		agentId: "agent_fake",
+		runId: "run_fake",
+		status: "completed",
+		iterations: 1,
+		outputText: "ok",
+		messages: [],
+		usage: {
+			inputTokens: 10,
+			outputTokens: 5,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0,
+		},
+		...script.result,
+	};
+
+	const emit = (): void => {
+		for (const event of script.events ?? []) {
+			for (const listener of listeners) {
+				listener(event);
+			}
+		}
+	};
+
+	const runtime = {
+		async run(input: unknown) {
+			calls.run.push(input);
+			emit();
+			if (script.throwError) {
+				throw script.throwError;
+			}
+			return baseResult;
+		},
+		async continue(input: unknown) {
+			calls.continue.push(input);
+			emit();
+			if (script.throwError) {
+				throw script.throwError;
+			}
+			return baseResult;
+		},
+		abort(reason?: string) {
+			calls.abort.push(reason);
+		},
+		subscribe(listener: (event: AgentRuntimeEvent) => void) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		snapshot() {
+			return {
+				agentId: "agent_fake",
+				runId: "run_fake",
+				status: "running" as const,
+				iteration: 0,
+				messages: [] as readonly AgentMessage[],
+				pendingToolCalls: [] as readonly string[],
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+			};
+		},
+	} as unknown as AgentRuntime;
+
+	return { runtime, calls, listeners };
+}
+
+function makeSnapshot() {
+	return {
+		agentId: "agent_fake",
+		runId: "run_fake",
+		status: "running" as const,
+		iteration: 0,
+		messages: [] as readonly AgentMessage[],
+		pendingToolCalls: [] as readonly string[],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0,
+		},
+	};
+}
+
+function makeAgentMessage(
+	id: string,
+	role: AgentMessage["role"],
+	text: string,
+): AgentMessage {
+	return {
+		id,
+		role,
+		content: [{ type: "text", text }],
+		createdAt: Date.now(),
+	};
+}
+
+/** Convenience to stitch a fake runtime into SessionRuntime deps. */
+function withFakeRuntime(script: FakeAgentRuntimeScript = {}): {
+	deps: SessionRuntimeOrchestratorDeps;
+	calls: ReturnType<typeof makeFakeAgentRuntime>["calls"];
+	listeners: ReturnType<typeof makeFakeAgentRuntime>["listeners"];
+} {
+	const { runtime, calls, listeners } = makeFakeAgentRuntime(script);
+	return {
+		deps: { createAgentRuntimeImpl: () => runtime },
+		calls,
+		listeners,
+	};
+}
+
+function withCapturingFakeRuntime(script: FakeAgentRuntimeScript = {}): {
+	deps: SessionRuntimeOrchestratorDeps;
+	configs: Parameters<
+		NonNullable<SessionRuntimeOrchestratorDeps["createAgentRuntimeImpl"]>
+	>[0][];
+} {
+	const configs: AgentRuntimeConfig[] = [];
+	return {
+		deps: {
+			createAgentRuntimeImpl: (config) => {
+				configs.push(config);
+				return makeFakeAgentRuntime(script).runtime;
+			},
+		},
+		configs,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Construction
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime construction", () => {
+	it("wires agentId, conversationId, and canStartRun", () => {
+		const session = new SessionRuntime(makeAgentConfig());
+		expect(session.getAgentId()).toMatch(/^agent_/);
+		expect(session.getConversationId()).toMatch(/^conv_/);
+		expect(session.canStartRun()).toBe(true);
+		expect(session.getMessages()).toEqual([]);
+	});
+
+	it("seeds initial messages through ConversationStore", () => {
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				initialMessages: [
+					{ role: "user", content: [{ type: "text", text: "hi" }] },
+				],
+			}),
+		);
+		expect(session.getMessages()).toHaveLength(1);
+	});
+
+	it("exposes an empty extension registry snapshot when no extensions are declared", () => {
+		const session = new SessionRuntime(makeAgentConfig());
+		const registry = session.getExtensionRegistry();
+		expect(registry).toEqual({
+			tools: [],
+			commands: [],
+			rules: [],
+			messageBuilder: [],
+			providers: [],
+			automationEventTypes: [],
+			mcpServers: [],
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// getExtensionRegistry — real contribution-registry snapshot
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime.getExtensionRegistry", () => {
+	it("returns tools/commands registered by extension setup() after the first run", async () => {
+		const extTool: AgentTool = {
+			name: "ext-echo",
+			description: "extension tool",
+			inputSchema: {},
+			execute: async () => ({}),
+		};
+		const extCommand = {
+			name: "ext-cmd",
+			description: "extension command",
+			execute: async () => ({}),
+		};
+		const extension = {
+			name: "test-ext",
+			manifest: { capabilities: ["tools", "commands"] },
+			setup: (api: {
+				registerTool: (t: AgentTool) => void;
+				registerCommand: (c: typeof extCommand) => void;
+			}) => {
+				api.registerTool(extTool);
+				api.registerCommand(extCommand);
+			},
+		};
+		const { deps } = withFakeRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				// @ts-expect-error — AgentExtension interface validates at runtime;
+				// this fixture supplies only the fields ContributionRegistry needs.
+				extensions: [extension],
+			}),
+			deps,
+		);
+		// Before run: registry is validated but not initialized yet.
+		expect(session.getExtensionRegistry().tools).toEqual([]);
+
+		await session.run("go");
+
+		const registry = session.getExtensionRegistry();
+		expect(registry.tools).toHaveLength(1);
+		expect(registry.tools[0].name).toBe("ext-echo");
+		expect(registry.commands).toHaveLength(1);
+		expect(registry.commands[0].name).toBe("ext-cmd");
+		expect(registry.automationEventTypes).toEqual([]);
+		expect(registry.mcpServers).toEqual([]);
+	});
+
+	it("keeps plugin-registered MCP servers out of direct runtime tools", async () => {
+		const extension: AgentExtension = {
+			name: "mcp-ext",
+			manifest: { capabilities: ["mcp"] },
+			setup(api) {
+				api.registerMcpServer({
+					name: "plugin-mock",
+					transport: {
+						type: "stdio",
+						command: process.execPath,
+					},
+				});
+			},
+		};
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({ extensions: [extension] }),
+			deps,
+		);
+
+		await session.run("go");
+
+		expect((configs[0]?.tools ?? []).map((tool) => tool.name)).not.toContain(
+			"plugin-mock__echo",
+		);
+		expect(session.getExtensionRegistry().mcpServers).toEqual([
+			expect.objectContaining({
+				name: "plugin-mock",
+				metadata: {
+					source: "plugin",
+					plugin: "mcp-ext",
+				},
+			}),
+		]);
+		await session.shutdown("test");
+	});
+
+	it("composes extension-registered rules into the runtime system prompt", async () => {
+		const extension: AgentExtension = {
+			name: "rules-ext",
+			manifest: { capabilities: ["rules"] },
+			setup: (api) => {
+				api.registerRule({
+					id: "rules-ext:primary",
+					content: "Always preserve architectural boundaries.",
+				});
+			},
+		};
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				systemPrompt: "Base prompt.",
+				extensions: [extension],
+			}),
+			deps,
+		);
+
+		await session.run("go");
+
+		expect(configs[0]?.systemPrompt).toBe(
+			"Base prompt.\n\nAlways preserve architectural boundaries.",
+		);
+	});
+
+	it("passes session, caller, and logger context into extension setup()", async () => {
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as AgentConfig["telemetry"];
+		const ingestEvent = vi.fn();
+		let observed: AgentExtensionContext | undefined;
+		const extension: AgentExtension = {
+			name: "context-ext",
+			manifest: { capabilities: ["tools", "automationEvents"] },
+			setup: (_api, ctx) => {
+				observed = ctx;
+				ctx.logger?.log("plugin setup", {
+					sessionId: ctx.session?.sessionId,
+				});
+			},
+		};
+		const { deps } = withFakeRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				extensions: [extension],
+				extensionContext: {
+					session: { sessionId: "sess_plugin_context" },
+					client: { name: "cline-sdk", version: "1.2.3" },
+					user: { distinctId: "user-1" },
+					workspace: { rootPath: "/tmp/workspace" },
+					automation: { ingestEvent },
+					logger,
+					telemetry,
+				},
+			}),
+			deps,
+		);
+
+		await session.run("go");
+
+		expect(observed?.session?.sessionId).toBe("sess_plugin_context");
+		expect(observed?.client).toEqual({
+			name: "cline-sdk",
+			version: "1.2.3",
+		});
+		expect(observed?.user?.distinctId).toBe("user-1");
+		expect(observed?.workspaceInfo?.rootPath).toBe("/tmp/workspace");
+		expect(observed?.automation?.ingestEvent).toBe(ingestEvent);
+		expect(observed?.telemetry).toBe(telemetry);
+		expect(logger.log).toHaveBeenCalledWith("plugin setup", {
+			sessionId: "sess_plugin_context",
+		});
+	});
+
+	it("passes effective telemetry into AgentRuntime config", async () => {
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as AgentConfig["telemetry"];
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig({ telemetry }), deps);
+
+		await session.run("go");
+
+		expect(configs[0]?.telemetry).toBe(telemetry);
+	});
+
+	it("passes dependency telemetry into AgentRuntime config", async () => {
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as AgentConfig["telemetry"];
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig(), {
+			...deps,
+			telemetry,
+		});
+
+		await session.run("go");
+
+		expect(configs[0]?.telemetry).toBe(telemetry);
+	});
+
+	it("merges extension-registered tools into the AgentRuntime tools for the turn", async () => {
+		const extTool: AgentTool = {
+			name: "ext-tool-a",
+			description: "ext tool a",
+			inputSchema: {},
+			execute: async () => ({}),
+		};
+		const configTool: AgentTool = {
+			name: "config-tool-b",
+			description: "config tool b",
+			inputSchema: {},
+			execute: async () => ({}),
+		};
+		const extension = {
+			name: "tool-ext",
+			manifest: { capabilities: ["tools"] },
+			setup: (api: { registerTool: (t: AgentTool) => void }) => {
+				api.registerTool(extTool);
+			},
+		};
+
+		let observedTools: ReadonlyArray<{ readonly name: string }> = [];
+		const { runtime } = makeFakeAgentRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				tools: [configTool],
+				// @ts-expect-error — minimal fixture, see note above.
+				extensions: [extension],
+			}),
+			{
+				createAgentRuntimeImpl: (config) => {
+					observedTools = (config.tools ?? []) as ReadonlyArray<{
+						readonly name: string;
+					}>;
+					return runtime;
+				},
+			},
+		);
+		await session.run("go");
+		const toolNames = observedTools.map((t) => t.name).sort();
+		expect(toolNames).toEqual(["config-tool-b", "ext-tool-a"]);
+	});
+});
+
+describe("SessionRuntime message preparation", () => {
+	it("runs registered message builders and API-safe normalization before model calls", async () => {
+		const build = vi.fn(async (messages) => [
+			...messages,
+			{
+				role: "user" as const,
+				content: [
+					{
+						type: "text" as const,
+						text: "<user_input>builder-added</user_input>",
+					},
+				],
+			},
+		]);
+		const extension: AgentExtension = {
+			name: "message-builder-ext",
+			manifest: { capabilities: ["messageBuilders"] },
+			setup(api) {
+				api.registerMessageBuilder({
+					name: "append-builder-message",
+					build,
+				});
+			},
+		};
+		const { deps, configs } = makeRecordingRuntimeFactory();
+		const session = new SessionRuntime(
+			makeAgentConfig({ extensions: [extension] }),
+			deps,
+		);
+
+		await session.run("go");
+		const beforeModel = configs[0]?.hooks?.beforeModel;
+		expect(beforeModel).toBeDefined();
+
+		const result = await beforeModel?.({
+			snapshot: makeSnapshot(),
+			request: {
+				systemPrompt: "system",
+				messages: [
+					{
+						id: "m1",
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: "<user_input>original</user_input>",
+							},
+						],
+						createdAt: 1,
+					},
+				],
+				tools: [],
+			},
+		});
+
+		expect(build).toHaveBeenCalledTimes(1);
+		expect(build.mock.calls[0]?.[0]).toEqual([
+			{
+				role: "user",
+				content: [
+					{
+						type: "text",
+						text: "<user_input>original</user_input>",
+					},
+				],
+			},
+		]);
+		const textParts = result?.messages?.flatMap((message) =>
+			message.content.flatMap((part) =>
+				typeof part !== "string" && part.type === "text" ? [part.text] : [],
+			),
+		);
+		expect(textParts).toEqual(["original", "builder-added"]);
+	});
+
+	it("merges beforeModel metadata through final message preparation", async () => {
+		const extension: AgentExtension = {
+			name: "metadata-ext",
+			manifest: { capabilities: ["hooks"] },
+			hooks: {
+				beforeModel: () => ({
+					options: {
+						metadata: {
+							runId: "run-plugin",
+							iteration: 2,
+						},
+					},
+				}),
+			},
+		};
+		const { deps, configs } = makeRecordingRuntimeFactory();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				extensions: [extension],
+				hooks: {
+					beforeModel: () => ({
+						options: {
+							metadata: {
+								sessionId: "session-config",
+								conversationId: "conversation-config",
+							},
+						},
+					}),
+				},
+			}),
+			deps,
+		);
+
+		await (
+			session as unknown as {
+				ensureExtensionsInitialized(): Promise<void>;
+			}
+		).ensureExtensionsInitialized();
+		const hooks = (
+			session as unknown as {
+				createRuntimeHooks(): AgentRuntimeConfig["hooks"];
+			}
+		).createRuntimeHooks();
+		const beforeModel = hooks?.beforeModel;
+		expect(beforeModel).toBeDefined();
+
+		const result = await beforeModel?.({
+			snapshot: makeSnapshot(),
+			request: {
+				systemPrompt: "system",
+				messages: [
+					{
+						id: "m1",
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: "<user_input>original</user_input>",
+							},
+						],
+						createdAt: 1,
+					},
+				],
+				tools: [],
+			},
+		});
+
+		expect(result?.options?.metadata).toMatchObject({
+			sessionId: "session-config",
+			conversationId: "conversation-config",
+			runId: "run-plugin",
+			iteration: 2,
+		});
+		expect(result?.messages?.[0]?.content).toEqual([
+			{ type: "text", text: "original" },
+		]);
+		expect(configs).toHaveLength(0);
+	});
+
+	it("adapts prepareTurn with API-safe messages for runtime compaction", async () => {
+		const prepareTurn = vi.fn(() => ({
+			messages: [
+				{
+					role: "user" as const,
+					content: "compacted transcript",
+				},
+			],
+		}));
+		const { deps, configs } = makeRecordingRuntimeFactory();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				prepareTurn,
+				knownModels: {
+					"claude-3-5-sonnet": {
+						id: "claude-3-5-sonnet",
+						maxInputTokens: 200_000,
+					},
+				},
+			}),
+			deps,
+		);
+
+		await session.run("go");
+		const runtimePrepareTurn = configs[0]?.prepareTurn;
+		expect(runtimePrepareTurn).toBeDefined();
+
+		const result = await runtimePrepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			messages: [
+				{
+					id: "m1",
+					role: "user",
+					content: [
+						{
+							type: "text",
+							text: "<user_input>large context</user_input>",
+						},
+					],
+					createdAt: 1,
+				},
+			],
+			systemPrompt: "system",
+			tools: [],
+			model: {},
+		});
+
+		expect(prepareTurn).toHaveBeenCalledWith(
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				parentAgentId: null,
+				iteration: 1,
+				messages: [
+					expect.objectContaining({
+						id: "m1",
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: "<user_input>large context</user_input>",
+							},
+						],
+						ts: 1,
+					}),
+				],
+				apiMessages: [
+					expect.objectContaining({
+						id: "m1",
+						role: "user",
+						content: [{ type: "text", text: "large context" }],
+						ts: 1,
+					}),
+				],
+				model: {
+					id: "claude-3-5-sonnet",
+					provider: "anthropic",
+					info: {
+						id: "claude-3-5-sonnet",
+						maxInputTokens: 200_000,
+					},
+				},
+			}),
+		);
+		expect(result?.messages).toHaveLength(1);
+		expect(result?.messages?.[0]?.content).toEqual([
+			{ type: "text", text: "compacted transcript" },
+		]);
+		expect(Object.hasOwn(result ?? {}, "systemPrompt")).toBe(false);
+	});
+
+	it("allows prepareTurn to return only a system prompt", async () => {
+		const prepareTurn = vi.fn(() => ({
+			systemPrompt: "rewritten system prompt",
+		}));
+		const { deps, configs } = makeRecordingRuntimeFactory();
+		const session = new SessionRuntime(makeAgentConfig({ prepareTurn }), deps);
+
+		await session.run("go");
+		const runtimePrepareTurn = configs[0]?.prepareTurn;
+		expect(runtimePrepareTurn).toBeDefined();
+
+		const result = await runtimePrepareTurn?.({
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			parentAgentId: null,
+			iteration: 1,
+			messages: [
+				{
+					id: "m1",
+					role: "user",
+					content: [{ type: "text", text: "keep me" }],
+					createdAt: 1,
+				},
+			],
+			systemPrompt: "system",
+			tools: [],
+			model: {},
+		});
+
+		expect(result).toEqual({
+			systemPrompt: "rewritten system prompt",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// run() / continue()
+// ---------------------------------------------------------------------------
+
+it("derives tool image support metadata from resolved provider model catalog", async () => {
+	const { deps, configs } = withCapturingFakeRuntime();
+	const execute = vi.fn(async () => "ok");
+	const telemetry = {
+		capture: vi.fn(),
+		captureRequired: vi.fn(),
+	} as unknown as AgentConfig["telemetry"];
+	const session = new SessionRuntime(
+		makeAgentConfig({
+			providerId: "cline",
+			modelId: "anthropic/claude-sonnet-4.6",
+			telemetry,
+			tools: [
+				{
+					name: "read_file",
+					description: "read a file",
+					inputSchema: {},
+					execute,
+				},
+			],
+		}),
+		deps,
+	);
+
+	await session.run("inspect image");
+
+	expect(configs).toHaveLength(1);
+	const runtimeConfig = configs[0];
+	if (!runtimeConfig) {
+		throw new Error("Expected runtime config");
+	}
+	const tool = runtimeConfig.tools?.[0];
+	expect(tool?.execute).toBeDefined();
+	if (!tool?.execute) {
+		throw new Error("Expected adapted tool execute function");
+	}
+	const toolContext: AgentToolContext = {
+		agentId: "agent-1",
+		runId: "run-1",
+		iteration: 0,
+		toolCallId: "call-1",
+		snapshot: {
+			agentId: "agent-1",
+			status: "running",
+			iteration: 0,
+			messages: [],
+			pendingToolCalls: [],
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+			},
+		},
+		emitUpdate: () => {},
+	};
+	const result = await tool.execute({}, toolContext);
+	expect(result).toBe("ok");
+	expect(execute).toHaveBeenCalledTimes(1);
+	expect(execute.mock.calls[0]).toEqual([expect.anything(), toolContext]);
+	expect(runtimeConfig.toolContextMetadata).toEqual(
+		expect.objectContaining({
+			modelSupportsImages: true,
+			[CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: telemetry,
+		}),
+	);
+	expect(runtimeConfig.toolContextMetadata?.telemetry).toBeUndefined();
+});
+
+describe("SessionRuntime.run", () => {
+	it("invokes the injected AgentRuntime and returns an AgentResult", async () => {
+		const { deps, calls } = withFakeRuntime({
+			result: { outputText: "hello world", iterations: 2 },
+		});
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		const result = await session.run("Say hi");
+		expect(calls.run).toHaveLength(1);
+		expect(result.text).toBe("hello world");
+		expect(result.iterations).toBe(2);
+		expect(result.finishReason).toBe("completed");
+		expect(result.model.provider).toBe("anthropic");
+		expect(result.model.id).toBe("claude-3-5-sonnet");
+		expect(result.startedAt).toBeInstanceOf(Date);
+		expect(result.endedAt).toBeInstanceOf(Date);
+		expect(typeof result.durationMs).toBe("number");
+	});
+
+	it("appends the user turn into the conversation store", async () => {
+		const { deps } = withFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		await session.run("question one");
+		// After run.resetForRun() + append, the conversation should
+		// contain at least the user message we appended.
+		const messages = session.getMessages();
+		const userMessage = messages.find((m) => m.role === "user");
+		expect(userMessage).toBeDefined();
+	});
+
+	it("fans legacy events to subscribers (not new AgentRuntimeEvent shape)", async () => {
+		const { deps } = withFakeRuntime({
+			events: [
+				{
+					type: "turn-started",
+					iteration: 1,
+					snapshot: makeSnapshot(),
+				},
+			],
+		});
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		const received: AgentEvent[] = [];
+		session.subscribeEvents((event) => received.push(event));
+		await session.run("go");
+
+		// Legacy shape: iteration_start, not turn-started.
+		const iterationStart = received.find((e) => e.type === "iteration_start");
+		expect(iterationStart).toBeDefined();
+		expect(
+			received.some((e) => (e as { type: string }).type === "turn-started"),
+		).toBe(false);
+	});
+
+	it("maps run-failed errors into AgentResult via thrown error", async () => {
+		const { deps } = withFakeRuntime({ throwError: new Error("boom") });
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		await expect(session.run("go")).rejects.toThrow("boom");
+	});
+
+	it("rejects re-entrant run while the previous run is still active", async () => {
+		let release: (() => void) | undefined;
+		const gate = new Promise<void>((resolve) => {
+			release = resolve;
+		});
+		const slowRuntime = {
+			async run() {
+				await gate;
+				return {
+					agentId: "agent_fake",
+					runId: "run_fake",
+					status: "completed" as const,
+					iterations: 1,
+					outputText: "",
+					messages: [] as readonly AgentMessage[],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+				};
+			},
+			async continue() {
+				await gate;
+				return {
+					agentId: "agent_fake",
+					runId: "run_fake",
+					status: "completed" as const,
+					iterations: 1,
+					outputText: "",
+					messages: [] as readonly AgentMessage[],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+				};
+			},
+			abort() {},
+			subscribe() {
+				return () => {};
+			},
+			snapshot() {
+				return {
+					agentId: "a",
+					status: "running" as const,
+					iteration: 0,
+					messages: [],
+					pendingToolCalls: [],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+				};
+			},
+		} as unknown as AgentRuntime;
+
+		const session = new SessionRuntime(makeAgentConfig(), {
+			createAgentRuntimeImpl: () => slowRuntime,
+		});
+		const first = session.run("one");
+		await Promise.resolve();
+		expect(session.canStartRun()).toBe(false);
+		await expect(session.continue("two")).rejects.toThrow(/"running"/i);
+		release?.();
+		await first;
+		expect(session.canStartRun()).toBe(true);
+	});
+});
+
+describe("SessionRuntime.continue", () => {
+	it("delegates to AgentRuntime.continue", async () => {
+		const { deps, calls } = withFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		await session.continue("more");
+		expect(calls.continue).toHaveLength(1);
+		expect(calls.run).toHaveLength(0);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// abort
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime.abort", () => {
+	it("forwards the reason into the active AgentRuntime", async () => {
+		let release: (() => void) | undefined;
+		const gate = new Promise<void>((resolve) => {
+			release = resolve;
+		});
+		const abortCalls: unknown[] = [];
+		const runtime = {
+			async run() {
+				await gate;
+				return {
+					agentId: "agent_fake",
+					runId: "run_fake",
+					status: "aborted" as const,
+					iterations: 0,
+					outputText: "",
+					messages: [] as readonly AgentMessage[],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+				};
+			},
+			async continue() {
+				await gate;
+				return {
+					agentId: "agent_fake",
+					runId: "run_fake",
+					status: "aborted" as const,
+					iterations: 0,
+					outputText: "",
+					messages: [] as readonly AgentMessage[],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+				};
+			},
+			abort(reason?: unknown) {
+				abortCalls.push(reason);
+				release?.();
+			},
+			subscribe() {
+				return () => {};
+			},
+			snapshot() {
+				return makeSnapshot();
+			},
+		} as unknown as AgentRuntime;
+
+		const session = new SessionRuntime(makeAgentConfig(), {
+			createAgentRuntimeImpl: () => runtime,
+		});
+		const runPromise = session.run("slow");
+		// Wait for the session to install the active runtime. The
+		// `buildUserTurnContent` dynamic-import + handler/tool setup
+		// yield a handful of microtasks before `runtime.run()` is
+		// awaited. Poll until `abort()` produces a call record.
+		for (let i = 0; i < 50 && abortCalls.length === 0; i++) {
+			session.abort("user cancelled");
+			if (abortCalls.length === 0) {
+				await new Promise((resolve) => setTimeout(resolve, 5));
+			}
+		}
+		const result = await runPromise;
+		expect(abortCalls).toEqual(["user cancelled"]);
+		expect(result.finishReason).toBe("aborted");
+	});
+
+	it("does not swallow the caller-visible rejection when abort rejects the run", async () => {
+		let rejectRun: ((error: Error) => void) | undefined;
+		const runGate = new Promise<AgentRunResult>((_resolve, reject) => {
+			rejectRun = reject;
+		});
+		let markRunStarted: (() => void) | undefined;
+		const runStarted = new Promise<void>((resolve) => {
+			markRunStarted = resolve;
+		});
+		const abortCalls: unknown[] = [];
+		const runtime = {
+			async run() {
+				markRunStarted?.();
+				return await runGate;
+			},
+			async continue() {
+				markRunStarted?.();
+				return await runGate;
+			},
+			abort(reason?: unknown) {
+				abortCalls.push(reason);
+				rejectRun?.(new Error(String(reason ?? "aborted")));
+			},
+			subscribe() {
+				return () => {};
+			},
+			snapshot() {
+				return makeSnapshot();
+			},
+		} as unknown as AgentRuntime;
+
+		const session = new SessionRuntime(makeAgentConfig(), {
+			createAgentRuntimeImpl: () => runtime,
+		});
+		const runPromise = session.run("slow");
+		await runStarted;
+		session.abort("user cancelled");
+
+		await expect(runPromise).rejects.toThrow("user cancelled");
+		expect(abortCalls).toEqual(["user cancelled"]);
+	});
+
+	it("observes an abort rejection before the caller awaits the run", async () => {
+		let rejectRun: ((error: Error) => void) | undefined;
+		const runGate = new Promise<AgentRunResult>((_resolve, reject) => {
+			rejectRun = reject;
+		});
+		let markRunStarted: (() => void) | undefined;
+		const runStarted = new Promise<void>((resolve) => {
+			markRunStarted = resolve;
+		});
+		const abortCalls: unknown[] = [];
+		const runtime = {
+			async run() {
+				markRunStarted?.();
+				return await runGate;
+			},
+			async continue() {
+				markRunStarted?.();
+				return await runGate;
+			},
+			abort(reason?: unknown) {
+				abortCalls.push(reason);
+				rejectRun?.(new Error(String(reason ?? "aborted")));
+			},
+			subscribe() {
+				return () => {};
+			},
+			snapshot() {
+				return makeSnapshot();
+			},
+		} as unknown as AgentRuntime;
+		const unhandledReasons: unknown[] = [];
+		const onUnhandledRejection = (reason: unknown): void => {
+			unhandledReasons.push(reason);
+		};
+
+		process.prependListener("unhandledRejection", onUnhandledRejection);
+		try {
+			const session = new SessionRuntime(makeAgentConfig(), {
+				createAgentRuntimeImpl: () => runtime,
+			});
+			const runPromise = session.run("slow");
+			await runStarted;
+			session.abort("user cancelled");
+			await new Promise((resolve) => setTimeout(resolve, 0));
+
+			expect(unhandledReasons).toEqual([]);
+			await expect(runPromise).rejects.toThrow("user cancelled");
+			expect(abortCalls).toEqual(["user cancelled"]);
+		} finally {
+			process.off("unhandledRejection", onUnhandledRejection);
+		}
+	});
+
+	it("is a no-op when no run is active", () => {
+		const { deps } = withFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		expect(() => session.abort()).not.toThrow();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// state mutators
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime.addTools / updateConnection / clearHistory / restore", () => {
+	const echoTool: AgentTool = {
+		name: "echo",
+		description: "e",
+		inputSchema: {},
+		execute: async () => ({}),
+	};
+
+	it("addTools is a no-op when the list is empty", () => {
+		const session = new SessionRuntime(makeAgentConfig({ tools: [echoTool] }));
+		session.addTools([]);
+		expect(session.canStartRun()).toBe(true);
+	});
+
+	it("addTools merges new tools and skips duplicates by name", () => {
+		const session = new SessionRuntime(makeAgentConfig({ tools: [echoTool] }));
+		session.addTools([echoTool, { ...echoTool, name: "other" }]);
+		expect(session.canStartRun()).toBe(true);
+	});
+
+	it("updateConnection mutates provider/model/api fields for next run", async () => {
+		const { deps, calls } = withFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		session.updateConnection({ modelId: "claude-4", apiKey: "new-key" });
+		const result = await session.run("go");
+		expect(result.model.id).toBe("claude-4");
+		expect(calls.run).toHaveLength(1);
+	});
+
+	it("updateConnection clears stale reasoning fields for next run", async () => {
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				thinking: true,
+				reasoningEffort: "high",
+				thinkingBudgetTokens: 1024,
+			}),
+			deps,
+		);
+		session.updateConnection({
+			thinking: null,
+			reasoningEffort: null,
+			thinkingBudgetTokens: null,
+		});
+		await session.run("go");
+		expect(configs[0]?.modelOptions).toBeUndefined();
+	});
+
+	it("updateConnection lets explicit thinking disable override a simultaneous budget", async () => {
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				thinking: true,
+				reasoningEffort: "high",
+				thinkingBudgetTokens: 1024,
+			}),
+			deps,
+		);
+		session.updateConnection({
+			thinking: false,
+			reasoningEffort: "high",
+			thinkingBudgetTokens: 2048,
+		});
+		await session.run("go");
+		expect(configs[0]?.modelOptions).toEqual({ thinking: false });
+	});
+
+	it("updateConnection enables thinking when a positive budget is supplied", async () => {
+		const { deps, configs } = withCapturingFakeRuntime();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		session.updateConnection({ thinkingBudgetTokens: 2048 });
+		await session.run("go");
+		expect(configs[0]?.modelOptions).toEqual({
+			thinking: true,
+			thinkingBudgetTokens: 2048,
+		});
+	});
+
+	it("clearHistory resets the conversation store", () => {
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				initialMessages: [
+					{ role: "user", content: [{ type: "text", text: "hi" }] },
+				],
+			}),
+		);
+		expect(session.getMessages()).toHaveLength(1);
+		session.clearHistory();
+		expect(session.getMessages()).toEqual([]);
+	});
+
+	it("restore replaces the conversation store with provided messages", () => {
+		const session = new SessionRuntime(makeAgentConfig());
+		session.restore([
+			{ role: "user", content: [{ type: "text", text: "first" }] },
+			{ role: "assistant", content: [{ type: "text", text: "second" }] },
+		]);
+		const messages = session.getMessages();
+		expect(messages).toHaveLength(2);
+		expect(messages[0].role).toBe("user");
+		expect(messages[1].role).toBe("assistant");
+	});
+
+	it("restore clears stale MessageBuilder rewrite state when tool ids are reused", async () => {
+		const previousThresholdEnv =
+			process.env[MESSAGE_BUILDER_LIMIT_ENV.minOutdatedRewriteBytes];
+		process.env[MESSAGE_BUILDER_LIMIT_ENV.minOutdatedRewriteBytes] = "7000";
+		const { deps, configs } = makeRecordingRuntimeFactory();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		if (previousThresholdEnv === undefined) {
+			delete process.env[MESSAGE_BUILDER_LIMIT_ENV.minOutdatedRewriteBytes];
+		} else {
+			process.env[MESSAGE_BUILDER_LIMIT_ENV.minOutdatedRewriteBytes] =
+				previousThresholdEnv;
+		}
+		await session.run("go");
+		const beforeModel = configs[0]?.hooks?.beforeModel;
+		if (!beforeModel) {
+			throw new Error("expected beforeModel hook");
+		}
+
+		const staleRead = "export const x = 1;\n".repeat(7_000);
+		const latestRead = "export const x = 2;\n".repeat(7_000);
+		const beforeRestore = await beforeModel({
+			snapshot: makeSnapshot(),
+			request: {
+				systemPrompt: "system",
+				messages: [
+					{
+						id: "m0",
+						role: "user",
+						content: [{ type: "text", text: "task" }],
+						createdAt: 1,
+					},
+					{
+						id: "m1",
+						role: "assistant",
+						content: [
+							{
+								type: "tool-call",
+								toolCallId: "t1",
+								toolName: "read_files",
+								input: { files: [{ path: "src/a.ts" }] },
+							},
+						],
+						createdAt: 2,
+					},
+					{
+						id: "m2",
+						role: "tool",
+						content: [
+							{
+								type: "tool-result",
+								toolCallId: "t1",
+								toolName: "read_files",
+								output: JSON.stringify([
+									{ path: "src/a.ts", result: staleRead },
+								]),
+							},
+						],
+						createdAt: 3,
+					},
+					{
+						id: "m3",
+						role: "assistant",
+						content: [
+							{
+								type: "tool-call",
+								toolCallId: "t2",
+								toolName: "read_files",
+								input: { files: [{ path: "src/a.ts" }] },
+							},
+						],
+						createdAt: 4,
+					},
+					{
+						id: "m4",
+						role: "tool",
+						content: [
+							{
+								type: "tool-result",
+								toolCallId: "t2",
+								toolName: "read_files",
+								output: JSON.stringify([
+									{ path: "src/a.ts", result: latestRead },
+								]),
+							},
+						],
+						createdAt: 5,
+					},
+				],
+				tools: [],
+			},
+		});
+		expect(JSON.stringify(beforeRestore?.messages?.[2])).toContain("outdated");
+
+		session.restore([]);
+		const afterRestore = await beforeModel({
+			snapshot: makeSnapshot(),
+			request: {
+				systemPrompt: "system",
+				messages: [
+					{
+						id: "r1",
+						role: "assistant",
+						content: [
+							{
+								type: "tool-call",
+								toolCallId: "t1",
+								toolName: "read_files",
+								input: { files: [{ path: "src/a.ts" }] },
+							},
+						],
+						createdAt: 6,
+					},
+					{
+						id: "r2",
+						role: "tool",
+						content: [
+							{
+								type: "tool-result",
+								toolCallId: "t1",
+								toolName: "read_files",
+								output: JSON.stringify([
+									{ path: "src/a.ts", result: staleRead },
+								]),
+							},
+						],
+						createdAt: 7,
+					},
+				],
+				tools: [],
+			},
+		});
+
+		expect(JSON.stringify(afterRestore?.messages)).not.toContain("outdated");
+		expect(JSON.stringify(afterRestore?.messages)).toContain(
+			"export const x = 1;",
+		);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// real AgentRuntime smoke
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime real AgentRuntime smoke", () => {
+	it("does not replay ERROR: EMPTY CONTENT after an empty upstream failure", async () => {
+		const modelRequests: AgentMessage[][] = [];
+		const scriptedModel: AgentModel = {
+			async stream(request) {
+				modelRequests.push(request.messages.map((message) => ({ ...message })));
+				const turn = modelRequests.length;
+
+				return (async function* () {
+					if (turn === 1) {
+						yield {
+							type: "finish" as const,
+							reason: "error" as const,
+							error: "upstream failed",
+						};
+						return;
+					}
+					yield { type: "text-delta" as const, text: "second ok" };
+					yield { type: "finish" as const, reason: "stop" as const };
+				})();
+			},
+		};
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				providerId: "cline",
+				modelId: "openai/gpt-5.5",
+				apiKey: "test-key",
+			}),
+			{
+				createAgentRuntimeImpl: (config) =>
+					createAgentRuntime({ ...config, model: scriptedModel }),
+			},
+		);
+
+		const first = await session.run("first");
+		expect(first.finishReason).toBe("error");
+		expect(first.text).toBe("upstream failed");
+		expect(session.getMessages().map((message) => message.role)).toEqual([
+			"user",
+		]);
+
+		const second = await session.continue("second");
+		expect(second.finishReason).toBe("completed");
+		expect(second.text).toBe("second ok");
+		expect(modelRequests).toHaveLength(2);
+		expect(
+			modelRequests[1]?.some((message) =>
+				message.content.some(
+					(part) =>
+						typeof part !== "string" &&
+						part.type === "text" &&
+						part.text === EMPTY_CONTENT_TEXT,
+				),
+			),
+		).toBe(false);
+		expect(modelRequests[1]?.map((message) => message.role)).toEqual([
+			"user",
+			"user",
+		]);
+	});
+
+	it("uses the error message instead of replaying prior assistant text after a tool-call stream failure", async () => {
+		const scriptedModel: AgentModel = {
+			async stream(request) {
+				const turn = request.messages.filter(
+					(message) => message.role === "assistant",
+				).length;
+
+				return (async function* () {
+					if (turn === 0) {
+						yield {
+							type: "text-delta" as const,
+							text: "I am going to make one more cleanup.",
+						};
+						yield {
+							type: "tool-call-delta" as const,
+							toolCallId: "call_cleanup",
+							toolName: "cleanup",
+							inputText: JSON.stringify({ ok: true }),
+						};
+						yield { type: "finish" as const, reason: "tool-calls" as const };
+						return;
+					}
+					yield {
+						type: "finish" as const,
+						reason: "error" as const,
+						error: "upstream failed after tool result",
+					};
+				})();
+			},
+		};
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				providerId: "cline",
+				modelId: "openai/gpt-5.5",
+				apiKey: "test-key",
+				tools: [
+					{
+						name: "cleanup",
+						description: "cleanup",
+						inputSchema: { type: "object" },
+						execute: async () => ({ ok: true }),
+					},
+				],
+			}),
+			{
+				createAgentRuntimeImpl: (config) =>
+					createAgentRuntime({ ...config, model: scriptedModel }),
+			},
+		);
+
+		const result = await session.run("first");
+
+		expect(result.finishReason).toBe("error");
+		expect(result.text).toBe("upstream failed after tool result");
+		expect(result.text).not.toContain("one more cleanup");
+		expect(session.getMessages().map((message) => message.role)).toEqual([
+			"user",
+			"assistant",
+			"user",
+		]);
+		const lastContent = session.getMessages().at(-1)?.content[0];
+		expect(typeof lastContent === "object" ? lastContent.type : undefined).toBe(
+			"tool_result",
+		);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// shutdown
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime.shutdown", () => {
+	it("completes successfully when no run is active and locks out future runs", async () => {
+		const session = new SessionRuntime(makeAgentConfig());
+		await expect(session.shutdown()).resolves.toBeUndefined();
+		expect(session.canStartRun()).toBe(false);
+	});
+
+	it("is idempotent across repeat calls", async () => {
+		const session = new SessionRuntime(makeAgentConfig());
+		await session.shutdown();
+		await expect(session.shutdown()).resolves.toBeUndefined();
+	});
+
+	it("waits for an aborted in-flight run before shutting down", async () => {
+		let releaseRun: (() => void) | undefined;
+		let markRunEntered: (() => void) | undefined;
+		const runEntered = new Promise<void>((resolve) => {
+			markRunEntered = resolve;
+		});
+		const abortCalls: unknown[] = [];
+		const runtime = {
+			async run() {
+				await new Promise<void>((resolve) => {
+					releaseRun = resolve;
+					markRunEntered?.();
+				});
+				return {
+					agentId: "agent_fake",
+					runId: "run_fake",
+					status: "aborted" as const,
+					iterations: 1,
+					outputText: "",
+					messages: [],
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+						totalCost: 0,
+					},
+				};
+			},
+			async continue() {
+				throw new Error("not used");
+			},
+			abort(reason?: unknown) {
+				abortCalls.push(reason);
+				releaseRun?.();
+			},
+			subscribe() {
+				return () => {};
+			},
+			snapshot() {
+				return makeSnapshot();
+			},
+		} as unknown as AgentRuntime;
+
+		const session = new SessionRuntime(makeAgentConfig(), {
+			createAgentRuntimeImpl: () => runtime,
+		});
+
+		const runPromise = session.run("slow");
+		await runEntered;
+		session.abort("session_stop");
+		expect(abortCalls).toEqual(["session_stop"]);
+		await expect(session.shutdown("session_stop")).resolves.toBeUndefined();
+		await expect(runPromise).resolves.toMatchObject({
+			finishReason: "aborted",
+		});
+		expect(session.canStartRun()).toBe(false);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// subscribeEvents lifecycle
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime.subscribeEvents", () => {
+	it("makes assistant messages visible to getMessages as soon as the runtime emits them", async () => {
+		const userMessage = makeAgentMessage("msg_user", "user", "go");
+		const assistantMessage = makeAgentMessage(
+			"msg_assistant",
+			"assistant",
+			"saved before run end",
+		);
+		const snapshot = {
+			...makeSnapshot(),
+			messages: [userMessage, assistantMessage],
+		};
+		const { deps } = withFakeRuntime({
+			events: [
+				{
+					type: "message-added",
+					snapshot,
+					message: assistantMessage,
+				},
+				{
+					type: "assistant-message",
+					snapshot,
+					iteration: 1,
+					message: assistantMessage,
+					finishReason: "stop",
+				},
+			],
+		});
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+
+		await session.run("go");
+
+		expect(session.getMessages()).toMatchObject([
+			{ role: "user", content: [{ type: "text", text: "go" }] },
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "saved before run end" }],
+			},
+		]);
+	});
+
+	it("appends fallback event messages instead of replacing history when the runtime snapshot is empty", async () => {
+		const assistantMessage = makeAgentMessage(
+			"msg_assistant",
+			"assistant",
+			"new answer",
+		);
+		const { deps } = withFakeRuntime({
+			events: [
+				{
+					type: "assistant-message",
+					snapshot: makeSnapshot(),
+					iteration: 1,
+					message: assistantMessage,
+					finishReason: "stop",
+				},
+			],
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				initialMessages: [
+					{
+						role: "user",
+						content: [{ type: "text", text: "prior question" }],
+					},
+					{
+						role: "assistant",
+						content: [{ type: "text", text: "prior answer" }],
+					},
+				],
+			}),
+			deps,
+		);
+
+		await session.continue("next question");
+
+		expect(session.getMessages()).toMatchObject([
+			{
+				role: "user",
+				content: [{ type: "text", text: "prior question" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "prior answer" }],
+			},
+			{
+				role: "user",
+				content: "next question",
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "new answer" }],
+			},
+		]);
+	});
+
+	it("unsubscribes cleanly", async () => {
+		const { deps } = withFakeRuntime({
+			events: [
+				{
+					type: "turn-finished",
+					iteration: 1,
+					toolCallCount: 0,
+					snapshot: makeSnapshot(),
+				},
+			],
+		});
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		const received: AgentEvent[] = [];
+		const unsubscribe = session.subscribeEvents((event) =>
+			received.push(event),
+		);
+		unsubscribe();
+		await session.run("go");
+		expect(received).toHaveLength(0);
+	});
+
+	it("swallows listener errors without breaking fanout", async () => {
+		const { deps } = withFakeRuntime({
+			events: [
+				{
+					type: "turn-finished",
+					iteration: 1,
+					toolCallCount: 0,
+					snapshot: makeSnapshot(),
+				},
+			],
+		});
+		const session = new SessionRuntime(makeAgentConfig(), {
+			...deps,
+			logger: {
+				debug: vi.fn(),
+				log: vi.fn(),
+				error: vi.fn(),
+			},
+		});
+		const good = vi.fn();
+		session.subscribeEvents(() => {
+			throw new Error("listener boom");
+		});
+		session.subscribeEvents(good);
+		await session.run("go");
+		expect(good).toHaveBeenCalled();
+	});
+});
+
+// ===========================================================================
+// P1 defect regression suites (#1, #2, #3) — added by impl-session-fixer.
+// ===========================================================================
+
+/**
+ * Build a runtime-factory that records the `AgentRuntimeConfig` it
+ * receives on every call and returns an `AgentRunResult` produced by
+ * the caller-supplied `producer`. Used to assert seeding / hook wiring.
+ */
+function makeRecordingRuntimeFactory(
+	producer: (
+		call: number,
+	) => Pick<AgentRunResult, "messages" | "outputText"> | undefined = () =>
+		undefined,
+): {
+	deps: SessionRuntimeOrchestratorDeps;
+	configs: Array<
+		Parameters<
+			NonNullable<SessionRuntimeOrchestratorDeps["createAgentRuntimeImpl"]>
+		>[0]
+	>;
+} {
+	const configs: Array<
+		Parameters<
+			NonNullable<SessionRuntimeOrchestratorDeps["createAgentRuntimeImpl"]>
+		>[0]
+	> = [];
+	const deps: SessionRuntimeOrchestratorDeps = {
+		createAgentRuntimeImpl: (config) => {
+			configs.push(config);
+			const callIndex = configs.length;
+			const produced = producer(callIndex);
+			const baseResult: AgentRunResult = {
+				agentId: "agent_fake",
+				runId: `run_fake_${callIndex}`,
+				status: "completed",
+				iterations: 1,
+				outputText: produced?.outputText ?? "",
+				messages: produced?.messages ?? [],
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0,
+					totalCost: 0,
+				},
+			};
+			return {
+				async run() {
+					return baseResult;
+				},
+				async continue() {
+					return baseResult;
+				},
+				abort() {},
+				subscribe() {
+					return () => {};
+				},
+				snapshot: makeSnapshot,
+			} as unknown as AgentRuntime;
+		},
+	};
+	return { deps, configs };
+}
+
+// ---------------------------------------------------------------------------
+// [#1] initialMessages seeding (P1 defect #1)
+// ---------------------------------------------------------------------------
+
+describe("SessionRuntime.run — initialMessages seeding (P1 #1)", () => {
+	it("seeds prior transcript into every subsequent run's runtime config", async () => {
+		const { deps, configs } = makeRecordingRuntimeFactory((call) => {
+			if (call === 1) {
+				return {
+					outputText: "hi back",
+					messages: [
+						{
+							id: "m1",
+							role: "user",
+							content: [{ type: "text", text: "hello" }],
+							createdAt: 1,
+						},
+						{
+							id: "m2",
+							role: "assistant",
+							content: [{ type: "text", text: "hi back" }],
+							createdAt: 2,
+						},
+					],
+				};
+			}
+			return undefined;
+		});
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		await session.run("hello");
+		await session.continue("again");
+		expect(configs).toHaveLength(2);
+		// Turn 1 seeds: just the current-turn user message.
+		const firstSeed = configs[0].initialMessages ?? [];
+		expect(firstSeed.length).toBe(1);
+		expect(firstSeed[0].role).toBe("user");
+		// Turn 2 seeds: turn-1 user + assistant + turn-2 user.
+		const secondSeed = configs[1].initialMessages ?? [];
+		expect(secondSeed.length).toBeGreaterThanOrEqual(3);
+		expect(secondSeed.some((m) => m.role === "assistant")).toBe(true);
+	});
+
+	it("preserves multi-turn transcript in getMessages() across run + continue", async () => {
+		const { deps } = makeRecordingRuntimeFactory((call) => {
+			if (call === 1) {
+				return {
+					outputText: "one",
+					messages: [
+						{
+							id: "u1",
+							role: "user",
+							content: [{ type: "text", text: "q1" }],
+							createdAt: 1,
+						},
+						{
+							id: "a1",
+							role: "assistant",
+							content: [{ type: "text", text: "one" }],
+							createdAt: 2,
+						},
+					],
+				};
+			}
+			return {
+				outputText: "two",
+				messages: [
+					{
+						id: "u1",
+						role: "user",
+						content: [{ type: "text", text: "q1" }],
+						createdAt: 1,
+					},
+					{
+						id: "a1",
+						role: "assistant",
+						content: [{ type: "text", text: "one" }],
+						createdAt: 2,
+					},
+					{
+						id: "u2",
+						role: "user",
+						content: [{ type: "text", text: "q2" }],
+						createdAt: 3,
+					},
+					{
+						id: "a2",
+						role: "assistant",
+						content: [{ type: "text", text: "two" }],
+						createdAt: 4,
+					},
+				],
+			};
+		});
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		await session.run("q1");
+		await session.continue("q2");
+		const messages = session.getMessages();
+		expect(messages).toHaveLength(4);
+		expect(messages.map((m) => m.role)).toEqual([
+			"user",
+			"assistant",
+			"user",
+			"assistant",
+		]);
+	});
+
+	it("seeds runtime with messages provided via restore()", async () => {
+		const { deps, configs } = makeRecordingRuntimeFactory();
+		const session = new SessionRuntime(makeAgentConfig(), deps);
+		session.restore([
+			{ role: "user", content: [{ type: "text", text: "prior-user" }] },
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "prior-assistant" }],
+			},
+		]);
+		await session.continue("followup");
+		expect(configs).toHaveLength(1);
+		const seed = configs[0].initialMessages ?? [];
+		expect(seed.length).toBeGreaterThanOrEqual(3);
+		expect(seed.some((m) => m.role === "assistant")).toBe(true);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// [#3] MistakeTracker + LoopDetectionTracker wiring (P1 defect #3)
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a manual AgentRuntime stub that exposes listener fan-out so
+ * tests can drive the tracker pipeline by emitting scripted
+ * `AgentRuntimeEvent`s synchronously from `run()`/`continue()`.
+ */
+function makeScriptedRuntime(script: {
+	events: readonly AgentRuntimeEvent[];
+}): {
+	deps: SessionRuntimeOrchestratorDeps;
+	abortCalls: string[];
+} {
+	const abortCalls: string[] = [];
+	const baseResult: AgentRunResult = {
+		agentId: "agent_fake",
+		runId: "run_fake",
+		status: "completed",
+		iterations: 1,
+		outputText: "",
+		messages: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0,
+		},
+	};
+	let listener: ((e: AgentRuntimeEvent) => void) | undefined;
+	const runtime = {
+		async run() {
+			for (const e of script.events) listener?.(e);
+			return baseResult;
+		},
+		async continue() {
+			for (const e of script.events) listener?.(e);
+			return baseResult;
+		},
+		abort(reason?: string) {
+			abortCalls.push(reason ?? "");
+		},
+		subscribe(l: (e: AgentRuntimeEvent) => void) {
+			listener = l;
+			return () => {
+				listener = undefined;
+			};
+		},
+		snapshot: makeSnapshot,
+	} as unknown as AgentRuntime;
+	return {
+		deps: { createAgentRuntimeImpl: () => runtime },
+		abortCalls,
+	};
+}
+
+function failedToolTurnEvents(): AgentRuntimeEvent[] {
+	return [
+		{ type: "turn-started", iteration: 1, snapshot: makeSnapshot() },
+		{
+			type: "tool-started",
+			iteration: 1,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: "tc",
+				toolName: "t",
+				input: { n: 1 },
+			},
+			snapshot: makeSnapshot(),
+		},
+		{
+			type: "tool-finished",
+			iteration: 1,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: "tc",
+				toolName: "t",
+				input: { n: 1 },
+			},
+			message: {
+				id: "m",
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "tc",
+						toolName: "t",
+						output: "fail",
+						isError: true,
+					},
+				],
+				createdAt: 1,
+			},
+			snapshot: makeSnapshot(),
+		},
+		{
+			type: "turn-finished",
+			iteration: 1,
+			toolCallCount: 1,
+			snapshot: makeSnapshot(),
+		},
+	];
+}
+
+function failedStructuredToolTurnEvents(): AgentRuntimeEvent[] {
+	return [
+		{ type: "turn-started", iteration: 1, snapshot: makeSnapshot() },
+		{
+			type: "tool-started",
+			iteration: 1,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: "tc_structured",
+				toolName: "exec",
+				input: { cmd: "pwd" },
+			},
+			snapshot: makeSnapshot(),
+		},
+		{
+			type: "tool-finished",
+			iteration: 1,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: "tc_structured",
+				toolName: "exec",
+				input: { cmd: "pwd" },
+			},
+			message: {
+				id: "m_structured",
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "tc_structured",
+						toolName: "exec",
+						output: {
+							message: "sandbox denied",
+							code: "EPERM",
+						},
+						isError: true,
+					},
+				],
+				createdAt: 1,
+			},
+			snapshot: makeSnapshot(),
+		},
+		{
+			type: "turn-finished",
+			iteration: 1,
+			toolCallCount: 1,
+			snapshot: makeSnapshot(),
+		},
+	];
+}
+
+describe("SessionRuntime.run — tracker wiring (P1 #3)", () => {
+	it("aborts after maxConsecutiveMistakes failed-tool turns", async () => {
+		const { deps, abortCalls } = makeScriptedRuntime({
+			events: failedToolTurnEvents(),
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({ execution: { maxConsecutiveMistakes: 2 } }),
+			deps,
+		);
+		await session.run("one");
+		// First failed turn — counter 1 < 2, no abort yet.
+		expect(abortCalls).toHaveLength(0);
+		await session.continue("two");
+		// Second failed turn — counter reaches 2, tracker calls abort.
+		expect(abortCalls.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it("serializes structured tool errors in mistake details", async () => {
+		const errors: string[] = [];
+		const { deps } = makeScriptedRuntime({
+			events: failedStructuredToolTurnEvents(),
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({ execution: { maxConsecutiveMistakes: 1 } }),
+			{
+				...deps,
+				telemetry: undefined,
+				logger: {
+					log() {},
+					debug() {},
+					error() {},
+				},
+			},
+		);
+		session.subscribeEvents((event) => {
+			if (event.type === "error") {
+				errors.push(event.error.message);
+			}
+		});
+
+		await session.run("run tool");
+
+		expect(errors).toContain(
+			'1 tool call(s) failed: [exec] {"message":"sandbox denied","code":"EPERM"}',
+		);
+	});
+
+	it("resets mistake tracking when run() starts a fresh conversation", async () => {
+		const { deps, abortCalls } = makeScriptedRuntime({
+			events: failedToolTurnEvents(),
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({ execution: { maxConsecutiveMistakes: 2 } }),
+			deps,
+		);
+		await session.run("task one");
+		expect(abortCalls).toHaveLength(0);
+		await session.run("task two");
+		expect(abortCalls).toHaveLength(0);
+	});
+
+	it("aborts on hard-threshold loop detection of identical tool calls", async () => {
+		const identical = (i: number): AgentRuntimeEvent => ({
+			type: "tool-started",
+			iteration: i,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: `tc${i}`,
+				toolName: "same",
+				input: { a: 1 },
+			},
+			snapshot: makeSnapshot(),
+		});
+		const { deps, abortCalls } = makeScriptedRuntime({
+			events: [
+				{ type: "turn-started", iteration: 1, snapshot: makeSnapshot() },
+				identical(1),
+				identical(1),
+				identical(1),
+			],
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				execution: {
+					maxConsecutiveMistakes: 6,
+					loopDetection: { softThreshold: 2, hardThreshold: 3 },
+				},
+			}),
+			deps,
+		);
+		await session.run("loop-me");
+		expect(abortCalls.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it("resets loop detection when run() starts a fresh conversation", async () => {
+		const identical = (i: number): AgentRuntimeEvent => ({
+			type: "tool-started",
+			iteration: i,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: `tc${i}`,
+				toolName: "same",
+				input: { a: 1 },
+			},
+			snapshot: makeSnapshot(),
+		});
+		const { deps, abortCalls } = makeScriptedRuntime({
+			events: [
+				{ type: "turn-started", iteration: 1, snapshot: makeSnapshot() },
+				identical(1),
+				identical(1),
+			],
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({
+				execution: {
+					maxConsecutiveMistakes: 6,
+					loopDetection: { softThreshold: 2, hardThreshold: 3 },
+				},
+			}),
+			deps,
+		);
+		await session.run("task one");
+		expect(abortCalls).toHaveLength(0);
+		await session.run("task two");
+		expect(abortCalls).toHaveLength(0);
+	});
+
+	it("does not trigger loop-detection when execution.loopDetection === false", async () => {
+		const identical = (i: number): AgentRuntimeEvent => ({
+			type: "tool-started",
+			iteration: i,
+			toolCall: {
+				type: "tool-call",
+				toolCallId: `tc${i}`,
+				toolName: "same",
+				input: { a: 1 },
+			},
+			snapshot: makeSnapshot(),
+		});
+		const { deps, abortCalls } = makeScriptedRuntime({
+			events: [
+				{ type: "turn-started", iteration: 1, snapshot: makeSnapshot() },
+				identical(1),
+				identical(1),
+				identical(1),
+				identical(1),
+				identical(1),
+			],
+		});
+		const session = new SessionRuntime(
+			makeAgentConfig({ execution: { loopDetection: false } }),
+			deps,
+		);
+		await session.run("many-identical");
+		expect(abortCalls).toHaveLength(0);
+	});
+
+	it("does not abort on productive turns (successful tool calls)", async () => {
+		const events: AgentRuntimeEvent[] = [
+			{ type: "turn-started", iteration: 1, snapshot: makeSnapshot() },
+			{
+				type: "tool-started",
+				iteration: 1,
+				toolCall: {
+					type: "tool-call",
+					toolCallId: "ok",
+					toolName: "t",
+					input: { n: 1 },
+				},
+				snapshot: makeSnapshot(),
+			},
+			{
+				type: "tool-finished",
+				iteration: 1,
+				toolCall: {
+					type: "tool-call",
+					toolCallId: "ok",
+					toolName: "t",
+					input: { n: 1 },
+				},
+				message: {
+					id: "m",
+					role: "tool",
+					content: [
+						{
+							type: "tool-result",
+							toolCallId: "ok",
+							toolName: "t",
+							output: "ok",
+						},
+					],
+					createdAt: 1,
+				},
+				snapshot: makeSnapshot(),
+			},
+			{
+				type: "turn-finished",
+				iteration: 1,
+				toolCallCount: 1,
+				snapshot: makeSnapshot(),
+			},
+		];
+		const { deps, abortCalls } = makeScriptedRuntime({ events });
+		const session = new SessionRuntime(
+			makeAgentConfig({ execution: { maxConsecutiveMistakes: 2 } }),
+			deps,
+		);
+		await session.run("a");
+		await session.continue("b");
+		await session.continue("c");
+		expect(abortCalls).toHaveLength(0);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts
new file mode 100644
index 0000000..3ba2c5a
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts
@@ -0,0 +1,1378 @@
+/**
+ * Per-session `SessionRuntime` orchestrator.
+ *
+ * Owns all cross-turn state for one logical agent session:
+ *
+ *   - `ConversationStore`      — message transcript + session-started gate
+ *   - `MistakeTracker`         — per-session consecutive-mistake counter
+ *   - `LoopDetectionTracker`   — per-session repeated-tool-call detector
+ *   - `MessageBuilder`         — provider-message assembly cache
+ *   - `AgentRuntimeHooks`      — runtime-native hooks from config/extensions
+ *   - `RuntimeEventAdapter`    — per-run stateful `AgentRuntimeEvent`
+ *                                → legacy `AgentEvent` translator
+ *   - listener registry        — host subscribers see legacy `AgentEvent`s
+ *   - pending tool set, abort  — per-run lifecycle housekeeping
+ *
+ * A fresh `AgentRuntime` is instantiated per run via
+ * `createAgentRuntime(createAgentRuntimeConfig({...}))`. All
+ * session-level state outlives any one `AgentRuntime`, making
+ * OAuth-retry and run replay feasible.
+ */
+
+import type { AgentRuntime } from "@cline/agents";
+import { createAgentRuntime } from "@cline/agents";
+import {
+	type AgentConfig,
+	type AgentEvent,
+	type AgentExtension,
+	type AgentExtensionRegistry,
+	type AgentExtensionRule,
+	type AgentFinishReason,
+	type AgentMessage,
+	type AgentResult,
+	type AgentRunResult,
+	type AgentRuntimeEvent,
+	type AgentRuntimeHooks,
+	type AgentRuntimePrepareTurnContext,
+	type AgentTool,
+	type BasicLogger,
+	type ContributionRegistry,
+	createContributionRegistry,
+	type ITelemetryService,
+	type LegacyAgentUsage,
+	type LoopDetectionConfig,
+	type Message,
+	type MessageWithMetadata,
+	type ModelInfo,
+	mergeModelOptions,
+	type ToolCallRecord,
+} from "@cline/shared";
+import { filterDisabledTools } from "../../services/global-settings";
+import {
+	createAgentModelFromConfig,
+	resolveKnownModelsFromConfig,
+} from "../../services/llms/handler-factory";
+import { CLINE_INTERNAL_TELEMETRY_METADATA_KEY } from "../../services/telemetry/tool-context";
+import {
+	getMessageBuilderOptionsFromEnv,
+	MessageBuilder,
+} from "../../session/services/message-builder";
+import { ConversationStore } from "../../session/stores/conversation-store";
+import {
+	agentMessagesToMessages,
+	agentMessagesToMessagesWithMetadata,
+	messagesToAgentMessages,
+} from "../config/agent-message-codec";
+import { createAgentRuntimeConfig } from "../config/agent-runtime-config-builder";
+import {
+	type ConnectionUpdate,
+	normalizeConnectionUpdate,
+} from "../config/connection-update";
+import { LoopDetectionTracker } from "../safety/loop-detection";
+import { MistakeTracker } from "../safety/mistake-tracker";
+import { RuntimeEventAdapter } from "./runtime-event-adapter";
+
+function formatToolResultError(output: unknown): string {
+	if (typeof output === "string") {
+		return output;
+	}
+	if (output instanceof Error) {
+		return output.message;
+	}
+	try {
+		return JSON.stringify(output);
+	} catch {
+		return String(output);
+	}
+}
+
+async function resolveRuleContent(
+	rule: AgentExtensionRule,
+): Promise<string | undefined> {
+	const content =
+		typeof rule.content === "function" ? await rule.content() : rule.content;
+	const trimmed = content.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function mergeSystemPromptRules(
+	systemPrompt: string,
+	rules: ReadonlyArray<string>,
+): string {
+	const base = systemPrompt.trim();
+	const additional = rules
+		.map((rule) => rule.trim())
+		.filter(Boolean)
+		.join("\n\n");
+	if (base && additional) {
+		return `${base}\n\n${additional}`;
+	}
+	return base || additional;
+}
+
+function isToolEnabledByPolicies(
+	toolName: string,
+	toolPolicies: AgentConfig["toolPolicies"],
+): boolean {
+	const globalPolicy = toolPolicies?.["*"] ?? {};
+	const toolPolicy = toolPolicies?.[toolName] ?? {};
+	return (
+		{
+			...globalPolicy,
+			...toolPolicy,
+		}.enabled !== false
+	);
+}
+
+function filterToolsByPolicies(
+	tools: AgentTool[],
+	toolPolicies: AgentConfig["toolPolicies"],
+): AgentTool[] {
+	return tools.filter((tool) =>
+		isToolEnabledByPolicies(tool.name, toolPolicies),
+	);
+}
+
+function filterAvailableExtensionTools(
+	tools: AgentTool[],
+	toolPolicies: AgentConfig["toolPolicies"],
+): AgentTool[] {
+	return filterDisabledTools(filterToolsByPolicies(tools, toolPolicies));
+}
+
+function mergeRuntimeHooks(
+	layers: Array<Partial<AgentRuntimeHooks> | undefined>,
+): Partial<AgentRuntimeHooks> {
+	const hooks = layers.filter(
+		(layer): layer is Partial<AgentRuntimeHooks> => layer !== undefined,
+	);
+	if (hooks.length === 0) {
+		return {};
+	}
+
+	return {
+		beforeRun: async (ctx) => {
+			for (const hook of hooks) {
+				const result = await hook.beforeRun?.(ctx);
+				if (result?.stop) return result;
+			}
+			return undefined;
+		},
+		afterRun: async (ctx) => {
+			for (const hook of hooks) {
+				await hook.afterRun?.(ctx);
+			}
+		},
+		beforeModel: async (ctx) => {
+			let request = ctx.request;
+			let aggregate:
+				| Awaited<ReturnType<NonNullable<AgentRuntimeHooks["beforeModel"]>>>
+				| undefined;
+			for (const hook of hooks) {
+				const result = await hook.beforeModel?.({ ...ctx, request });
+				if (!result) continue;
+				if (result.stop) return result;
+				aggregate = {
+					...aggregate,
+					...result,
+					options: mergeModelOptions(aggregate?.options, result.options),
+				};
+				request = {
+					...request,
+					...(result.messages ? { messages: result.messages } : {}),
+					...(result.tools ? { tools: result.tools } : {}),
+					...(result.options
+						? { options: mergeModelOptions(request.options, result.options) }
+						: {}),
+				};
+			}
+			return aggregate;
+		},
+		afterModel: async (ctx) => {
+			for (const hook of hooks) {
+				const result = await hook.afterModel?.(ctx);
+				if (result?.stop) return result;
+			}
+			return undefined;
+		},
+		beforeTool: async (ctx) => {
+			let input = ctx.input;
+			let aggregate:
+				| Awaited<ReturnType<NonNullable<AgentRuntimeHooks["beforeTool"]>>>
+				| undefined;
+			for (const hook of hooks) {
+				const result = await hook.beforeTool?.({ ...ctx, input });
+				if (!result) continue;
+				if (result.stop || result.skip) return result;
+				aggregate = { ...aggregate, ...result };
+				if (Object.hasOwn(result, "input")) {
+					input = result.input;
+				}
+			}
+			return aggregate;
+		},
+		afterTool: async (ctx) => {
+			let result = ctx.result;
+			let aggregate:
+				| Awaited<ReturnType<NonNullable<AgentRuntimeHooks["afterTool"]>>>
+				| undefined;
+			for (const hook of hooks) {
+				const next = await hook.afterTool?.({ ...ctx, result });
+				if (!next) continue;
+				if (next.stop) return next;
+				aggregate = { ...aggregate, ...next };
+				if (next.result) {
+					result = next.result;
+				}
+			}
+			return aggregate;
+		},
+		onEvent: async (event) => {
+			for (const hook of hooks) {
+				await hook.onEvent?.(event);
+			}
+		},
+	};
+}
+
+// =============================================================================
+// Public types
+// =============================================================================
+
+/**
+ * Listener invoked for every legacy `AgentEvent` produced by the
+ * session runtime. Use `subscribeEvents(listener)` — it returns an
+ * `unsubscribe` function.
+ */
+export type SessionEventListener = (event: AgentEvent) => void;
+
+/** Subset of host-side deps needed by the session orchestrator. */
+export interface SessionRuntimeOrchestratorDeps {
+	readonly logger?: BasicLogger;
+	readonly telemetry?: ITelemetryService;
+	/**
+	 * Test hook: override the `AgentRuntime` factory. Production
+	 * callers leave this undefined and get the real `createAgentRuntime`.
+	 */
+	readonly createAgentRuntimeImpl?: (
+		config: Parameters<typeof createAgentRuntime>[0],
+	) => AgentRuntime;
+}
+
+/** Connection overrides applied via `updateConnection`. */
+export type ConnectionOverrides = ConnectionUpdate;
+
+// =============================================================================
+// SessionRuntime orchestrator
+// =============================================================================
+
+/**
+ * Per-session orchestrator. Construct once per agent session; call
+ * `run` / `continue` repeatedly. The class matches the subset of
+ * runtime-facing session surface.
+ */
+export class SessionRuntime {
+	private config: AgentConfig;
+	private readonly agentId: string;
+	private readonly parentAgentId?: string;
+	private readonly logger?: BasicLogger;
+	// Reserved for §3.4.4 telemetry parity (not yet consumed — §3.4.4
+	// listed as explicitly deferred until telemetry wiring is added).
+	// Typed as `readonly` to preserve the field slot for future use
+	// without re-touching the constructor.
+	readonly telemetry?: ITelemetryService;
+	private readonly conversation: ConversationStore;
+	private readonly mistakeTracker: MistakeTracker;
+	private readonly loopTracker: LoopDetectionTracker;
+	/**
+	 * True when `execution.loopDetection === false` at construction
+	 * time. Loop inspection is skipped entirely — the tracker still
+	 * exists for API compatibility but is never fed.
+	 */
+	private readonly loopDetectionDisabled: boolean;
+	// Host-owned provider request preparation. This runs immediately
+	// before the model call so every loop iteration sees extension
+	// message builders and API-safe normalization.
+	readonly messageBuilder: MessageBuilder;
+	/**
+	 * Contribution registry that hosts extension-provided tools,
+	 * commands, message builders, and providers. Lazily initialized
+	 * on first run (parity with legacy `Agent.ensureExtensionsInitialized`
+	 * at `packages/agents/src/agent.ts:1122-1147`).
+	 */
+	private readonly contributionRegistry: ContributionRegistry<
+		AgentExtension,
+		AgentTool,
+		Message[]
+	>;
+	private extensionsInitialized = false;
+	private readonly listeners = new Set<SessionEventListener>();
+	private readonly createAgentRuntimeImpl: (
+		config: Parameters<typeof createAgentRuntime>[0],
+	) => AgentRuntime;
+
+	/** Stable run id for the active run. */
+	private activeRunId: string | null = null;
+	/** True while a run is in flight. `canStartRun()` is the negation. */
+	private running = false;
+	/** True once `abort()` has been requested for the active run. */
+	private abortRequested = false;
+	/** Last abort reason requested for the active run. */
+	private abortReason: string | undefined;
+	/** Reference to the current run's `AgentRuntime` so `abort` can forward. */
+	private activeRuntime: AgentRuntime | null = null;
+	/** Promise returned from the current run so shutdown can await its drain. */
+	private activeRunPromise: Promise<AgentResult> | null = null;
+	/** Per-run `Agent → AgentEvent` adapter; `reset()` each run. */
+	private readonly eventAdapter = new RuntimeEventAdapter();
+	/** Session-shutdown gate — rejects late runs. */
+	private shutdownCalled = false;
+	/** Running tally of tool-call records for `AgentResult.toolCalls`. */
+	private currentRunToolCalls: ToolCallRecord[] = [];
+	/** Aggregated usage across the current run. */
+	private currentRunUsage: LegacyAgentUsage = {
+		inputTokens: 0,
+		outputTokens: 0,
+	};
+	/** Tool-start timestamps for `ToolCallRecord.durationMs`. */
+	private toolStartedAt = new Map<string, Date>();
+	/** Tool-call input snapshot for `ToolCallRecord.input`. */
+	private toolInputs = new Map<string, unknown>();
+	/**
+	 * Per-turn tool outcome counters used by the MistakeTracker wiring.
+	 * Reset on every `turn-started` event; consumed on `turn-finished`
+	 * to feed `mistakeTracker.record` when every tool call erred and no
+	 * successful call landed. Matches legacy `agent.ts` tool-failure
+	 * mistake-feed path (§3.4.6 + pre-Step-9 oracle lines 972-997).
+	 */
+	private currentTurnSuccessfulTools = 0;
+	private currentTurnFailedTools = 0;
+	private currentTurnFailureDetails: string[] = [];
+	/**
+	 * Serial queue for `MistakeTracker.record(...)` + loop-detection
+	 * side-effects fired from the sync `handleRuntimeEvent` stream. The
+	 * tracker's `record()` is async but the runtime event stream is
+	 * synchronous, so we chain tracker work onto a promise and await it
+	 * in `executeRun` before returning the `AgentResult`.
+	 */
+	private activeTrackerWork: Promise<void> = Promise.resolve();
+	/** True when tracker logic has issued an abort for the active run. */
+	private trackerAbortInFlight = false;
+
+	constructor(config: AgentConfig, deps: SessionRuntimeOrchestratorDeps = {}) {
+		this.config = config;
+		this.agentId = `agent_${Date.now()}_${Math.random()
+			.toString(36)
+			.slice(2, 8)}`;
+		this.parentAgentId = config.parentAgentId;
+		this.logger = deps.logger ?? config.logger;
+		this.telemetry = deps.telemetry ?? config.telemetry;
+		this.createAgentRuntimeImpl =
+			deps.createAgentRuntimeImpl ?? createAgentRuntime;
+
+		this.conversation = new ConversationStore(config.initialMessages);
+		this.messageBuilder = new MessageBuilder(getMessageBuilderOptionsFromEnv());
+		this.contributionRegistry = createContributionRegistry<
+			AgentExtension,
+			AgentTool,
+			Message[]
+		>({
+			extensions: config.extensions ? [...config.extensions] : [],
+			setupContext: {
+				session: config.extensionContext?.session,
+				client: config.extensionContext?.client,
+				user: config.extensionContext?.user,
+				workspaceInfo: config.extensionContext?.workspace,
+				automation: config.extensionContext?.automation,
+				logger: config.extensionContext?.logger ?? this.logger,
+				telemetry: config.extensionContext?.telemetry ?? this.telemetry,
+			},
+		});
+		// Resolve + validate eagerly so `getExtensionRegistry()` is
+		// callable before the first run (legacy parity with
+		// `Agent` constructor at packages/agents/src/agent.ts:158-159).
+		// `setup()` is deferred to `ensureExtensionsInitialized` on
+		// the first run so async extension setup can't block the
+		// constructor.
+		this.contributionRegistry.resolve();
+		this.contributionRegistry.validate();
+
+		const maxMistakes = config.execution?.maxConsecutiveMistakes ?? 6;
+		this.mistakeTracker = new MistakeTracker({
+			maxConsecutiveMistakes: maxMistakes,
+			onLimitReached: config.onConsecutiveMistakeLimitReached,
+			emit: (event) => this.emitLegacyEvent(event),
+			log: (level, message, metadata) =>
+				leveledLog(this.logger, level, message, metadata),
+			agentId: this.agentId,
+			getConversationId: () => this.conversation.getConversationId(),
+			getActiveRunId: () => this.activeRunId ?? "",
+			appendRecoveryNotice: (message, _reason) => {
+				this.conversation.appendMessage({
+					role: "user",
+					content: [{ type: "text", text: message }],
+				});
+			},
+		});
+		const loopDetectionInput = config.execution?.loopDetection;
+		this.loopDetectionDisabled = loopDetectionInput === false;
+		const loopConfig: Partial<LoopDetectionConfig> | undefined =
+			loopDetectionInput === false || loopDetectionInput === undefined
+				? undefined
+				: loopDetectionInput;
+		this.loopTracker = new LoopDetectionTracker(loopConfig);
+	}
+
+	// -------------------------------------------------------------------
+	// Accessors & state mutators
+	// -------------------------------------------------------------------
+
+	getAgentId(): string {
+		return this.agentId;
+	}
+
+	getConversationId(): string {
+		return this.conversation.getConversationId();
+	}
+
+	getMessages(): MessageWithMetadata[] {
+		return this.conversation.getMessages();
+	}
+
+	/** True when no run is currently active and the session is not shut down. */
+	canStartRun(): boolean {
+		return !this.running && !this.shutdownCalled;
+	}
+
+	/**
+	 * Snapshot of the contribution registry (tools, commands, and other
+	 * extension contributions).
+	 *
+	 * Before the first run, the registry is in the `validate` phase:
+	 * extensions are validated but their `setup()` callbacks have not
+	 * run yet, so the snapshot only reflects eagerly-declared
+	 * contributions. After the first `run()`/`continue()`, the
+	 * registry is initialized (§`ensureExtensionsInitialized`), and
+	 * the snapshot reflects everything extensions registered via
+	 * `api.registerTool` / `registerCommand` / `registerMessageBuilder`
+	 * / `registerProvider` / `registerAutomationEventType`.
+	 */
+	getExtensionRegistry(): AgentExtensionRegistry<AgentTool, Message[]> {
+		return this.contributionRegistry.getRegistrySnapshot();
+	}
+
+	/** Append additional tools to every subsequent turn's runtime config. */
+	addTools(tools: AgentTool[]): void {
+		if (tools.length === 0) {
+			return;
+		}
+		const existing = new Set(this.config.tools.map((tool) => tool.name));
+		const merged = [...this.config.tools];
+		for (const tool of tools) {
+			if (!existing.has(tool.name)) {
+				merged.push(tool);
+				existing.add(tool.name);
+			}
+		}
+		this.config = { ...this.config, tools: merged };
+	}
+
+	/** Mutate provider / reasoning fields for subsequent runs. */
+	updateConnection(overrides: ConnectionOverrides): void {
+		const updates = normalizeConnectionUpdate(overrides);
+		const next: AgentConfig = { ...this.config };
+		if (updates.providerId !== undefined) next.providerId = updates.providerId;
+		if (updates.modelId !== undefined) next.modelId = updates.modelId;
+		if (updates.apiKey !== undefined) next.apiKey = updates.apiKey;
+		if (updates.baseUrl !== undefined) next.baseUrl = updates.baseUrl;
+		if (updates.headers !== undefined) next.headers = updates.headers;
+		if (updates.providerConfig !== undefined)
+			next.providerConfig = updates.providerConfig;
+		if (Object.hasOwn(updates, "reasoningEffort")) {
+			next.reasoningEffort = updates.reasoningEffort ?? undefined;
+		}
+		if (Object.hasOwn(updates, "thinkingBudgetTokens")) {
+			next.thinkingBudgetTokens = updates.thinkingBudgetTokens ?? undefined;
+		}
+		if (Object.hasOwn(updates, "thinking")) {
+			next.thinking = updates.thinking ?? undefined;
+			if (updates.thinking === false || updates.thinking === null) {
+				next.reasoningEffort = undefined;
+				next.thinkingBudgetTokens = undefined;
+			}
+		}
+		this.config = next;
+	}
+
+	clearHistory(): void {
+		this.conversation.clearHistory();
+		this.resetConversationBoundaryTrackers();
+	}
+
+	restore(messages: readonly MessageWithMetadata[]): void {
+		this.conversation.restore(messages);
+		this.resetConversationBoundaryTrackers();
+	}
+
+	private resetConversationBoundaryTrackers(): void {
+		this.messageBuilder.resetConversationState();
+		this.mistakeTracker.reset();
+		this.loopTracker.reset();
+	}
+
+	// -------------------------------------------------------------------
+	// Event subscription (legacy shape)
+	// -------------------------------------------------------------------
+
+	/**
+	 * Subscribe to **legacy** `AgentEvent`s. The session runtime
+	 * translates the new `AgentRuntimeEvent` stream via
+	 * `RuntimeEventAdapter` before fanout, so consumers see the
+	 * pre-swap shape.
+	 */
+	subscribeEvents(listener: SessionEventListener): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	// -------------------------------------------------------------------
+	// Abort / shutdown
+	// -------------------------------------------------------------------
+
+	abort(reason?: unknown): void {
+		const message =
+			typeof reason === "string"
+				? reason
+				: reason instanceof Error
+					? reason.message
+					: reason === undefined
+						? undefined
+						: String(reason);
+		this.abortRequested = true;
+		this.abortReason = message;
+		if (this.activeRunPromise) {
+			/**
+			 * Why this exists in hub mode:
+			 *
+			 * The TUI and the runtime are not always in the same process. In hub
+			 * mode, the visible TUI talks to a shared daemon over websocket. When the
+			 * user sends a prompt, the TUI sends a "start this run" command to the
+			 * daemon. The daemon starts the AgentRuntime and stores the promise for
+			 * that run as `activeRunPromise`.
+			 *
+			 * If the user presses Escape, the TUI sends a separate "cancel the
+			 * current run" command to the daemon. Cancelling a run means aborting the
+			 * AgentRuntime. That is supposed to interrupt the provider stream or any
+			 * other in-flight async work, and the normal way that interruption shows
+			 * up in JavaScript is a rejected promise. That rejection is not a bug by
+			 * itself. It is the expected result of the user saying "stop this
+			 * request."
+			 *
+			 * The important detail is that the rejection is already handled by the
+			 * code path that started the run. The original "start this run" command
+			 * is still awaiting `sessionHost.send(...)`, and that await is what
+			 * should eventually turn the run result or run error into a reply/event
+			 * for the client.
+			 *
+			 * The problem we hit was a timing gap inside the daemon process. The
+			 * separate cancel command can call `activeRuntime.abort(message)` while
+			 * the original start command is still waiting elsewhere. The abort can
+			 * make `activeRunPromise` reject immediately. If the runtime reports that
+			 * rejection before the original start command observes it, Node/Bun can
+			 * briefly classify it as an `unhandledRejection`.
+			 *
+			 * In the hub daemon, `unhandledRejection` is fatal. That is normally the
+			 * right policy because real unhandled errors should not be ignored. But
+			 * for this cancellation path it meant Escape could kill the daemon even
+			 * though the run error was expected and the original start command was
+			 * still responsible for handling it. After the daemon died, the next
+			 * prompt looked like it started loading, then silently stalled because
+			 * the TUI was talking to a dead runtime process.
+			 *
+			 * This `.catch()` is not the real application-level error handling. It is
+			 * only a local safety observer attached before we trigger the abort, so
+			 * the daemon does not mistake an expected cancellation rejection for a
+			 * process crash. We do not replace `activeRunPromise`, await this catch,
+			 * or convert the rejection into success. The original start command, and
+			 * any other caller awaiting `run()` / `continue()`, still receives the
+			 * same result or error it would have received without this observer.
+			 */
+			void this.activeRunPromise.catch(() => {});
+		}
+		this.activeRuntime?.abort(message);
+	}
+
+	/** Shut the session down after any active run drains. */
+	async shutdown(_reason?: string, _timeoutMs?: number): Promise<void> {
+		if (this.running) {
+			if (!this.abortRequested || !this.activeRunPromise) {
+				throw new Error(
+					`SessionRuntime.shutdown called while a run is in progress (agentId=${this.agentId})`,
+				);
+			}
+			await this.activeRunPromise;
+		}
+		if (this.shutdownCalled) {
+			return;
+		}
+		this.shutdownCalled = true;
+	}
+
+	// -------------------------------------------------------------------
+	// Run / continue
+	// -------------------------------------------------------------------
+
+	run(
+		userMessage: string,
+		userImages?: string[],
+		userFiles?: string[],
+	): Promise<AgentResult> {
+		this.conversation.resetForRun();
+		this.resetConversationBoundaryTrackers();
+		return this.executeRun({
+			userMessage,
+			userImages,
+			userFiles,
+			isContinue: false,
+		});
+	}
+
+	continue(
+		userMessage?: string,
+		userImages?: string[],
+		userFiles?: string[],
+	): Promise<AgentResult> {
+		return this.executeRun({
+			userMessage,
+			userImages,
+			userFiles,
+			isContinue: true,
+		});
+	}
+
+	// -------------------------------------------------------------------
+	// Private implementation
+	// -------------------------------------------------------------------
+
+	private async composeSystemPrompt(): Promise<string> {
+		const rules: string[] = [];
+		for (const rule of this.contributionRegistry.getRegisteredRules()) {
+			const content = await resolveRuleContent(rule);
+			if (content) {
+				rules.push(content);
+			}
+		}
+		return mergeSystemPromptRules(this.config.systemPrompt, rules);
+	}
+
+	private executeRun(input: {
+		userMessage?: string;
+		userImages?: string[];
+		userFiles?: string[];
+		isContinue: boolean;
+	}): Promise<AgentResult> {
+		let activePromise!: Promise<AgentResult>;
+		activePromise = this.executeRunInternal(input).finally(() => {
+			if (this.activeRunPromise === activePromise) {
+				this.activeRunPromise = null;
+			}
+		});
+		this.activeRunPromise = activePromise;
+		return activePromise;
+	}
+
+	private async executeRunInternal(input: {
+		userMessage?: string;
+		userImages?: string[];
+		userFiles?: string[];
+		isContinue: boolean;
+	}): Promise<AgentResult> {
+		if (this.shutdownCalled) {
+			throw new Error(
+				`SessionRuntime.run called after shutdown (agentId=${this.agentId})`,
+			);
+		}
+		if (this.running) {
+			throw new Error(
+				`SessionRuntime state is "running"; call canStartRun() first (agentId=${this.agentId})`,
+			);
+		}
+		this.running = true;
+		this.abortRequested = false;
+		this.abortReason = undefined;
+		this.activeRunId = `run_${Date.now()}_${Math.random()
+			.toString(36)
+			.slice(2, 8)}`;
+		// Lazily initialize contribution-registry extensions on the
+		// first run, before runtime construction.
+		await this.ensureExtensionsInitialized();
+		this.eventAdapter.reset();
+		this.currentRunToolCalls = [];
+		this.currentRunUsage = { inputTokens: 0, outputTokens: 0 };
+		this.toolStartedAt.clear();
+		this.toolInputs.clear();
+		this.currentTurnSuccessfulTools = 0;
+		this.currentTurnFailedTools = 0;
+		this.currentTurnFailureDetails = [];
+		this.activeTrackerWork = Promise.resolve();
+		this.trackerAbortInFlight = false;
+
+		const startedAt = new Date();
+		const effectiveUserMessage = input.userMessage;
+
+		// Append the user turn (if any) to the conversation store. This
+		// must happen BEFORE we snapshot `initialMessages` below so the
+		// runtime sees the user message as part of its seed — we then
+		// pass an empty input to `runtime.run()` so the runtime does not
+		// append the message a second time (AgentRuntime.execute treats
+		// a falsy input as "no additional messages", per
+		// packages/agents/src/agent-runtime.ts normalizeInput path).
+		if (effectiveUserMessage !== undefined) {
+			const content = await buildUserTurnContent(
+				effectiveUserMessage,
+				input.userImages,
+				input.userFiles,
+				this.config.userFileContentLoader,
+			);
+			this.conversation.appendMessage({ role: "user", content });
+		}
+
+		// Build the AgentRuntime for this turn.
+		const systemPrompt = await this.composeSystemPrompt();
+		const agentModel = createAgentModelFromConfig(
+			this.config,
+			this.logger,
+			this.telemetry,
+		);
+		// Merge extension-contributed tools with the config-declared
+		// tools for this turn. Extensions register tools via
+		// `api.registerTool` during `setup()` — parity with legacy
+		// `Agent.ensureExtensionsInitialized` at pre-Step-9 `agent.ts:1140-1146`
+		// which merged `this.contributionRegistry.getRegisteredTools()`
+		// into `this.config.tools`. Dedupe by name so a config tool
+		// wins over a same-named extension tool (legacy behaviour:
+		// `validateTools` rejects duplicates; here we prefer the
+		// explicitly-declared config tool).
+		const extensionToolsByName = new Map<string, AgentTool>();
+		for (const tool of this.contributionRegistry.getRegisteredTools()) {
+			extensionToolsByName.set(tool.name, tool);
+		}
+		const extensionTools = filterAvailableExtensionTools(
+			[...extensionToolsByName.values()],
+			this.config.toolPolicies,
+		);
+		const mergedToolsByName = new Map<string, AgentTool>();
+		for (const tool of extensionTools) {
+			mergedToolsByName.set(tool.name, tool);
+		}
+		for (const tool of this.config.tools) {
+			mergedToolsByName.set(tool.name, tool);
+		}
+		const conversationId = this.conversation.getConversationId();
+		const modelInfo = tryGetModelInfo(this.config);
+		const tools = Array.from(mergedToolsByName.values());
+		// Seed initialMessages with the full prior transcript (including
+		// the user message we just appended) so multi-turn history is
+		// preserved across runs. Fixes P1 #1: prior turns were silently
+		// lost because `createAgentRuntimeConfig` received no seed and
+		// `replaceMessages(runResult.messages)` downstream overwrote the
+		// conversation with just the current-turn trail.
+		const initialMessages = messagesToAgentMessages(
+			this.conversation.getMessages(),
+		);
+		const runtimeConfig = createAgentRuntimeConfig({
+			agentConfig: this.config,
+			sessionId: this.config.sessionId,
+			agentId: this.agentId,
+			conversationId,
+			parentAgentId: this.parentAgentId,
+			model: agentModel,
+			logger: this.logger,
+			telemetry: this.telemetry,
+			tools,
+			toolContextMetadata: {
+				modelSupportsImages:
+					modelInfo?.capabilities?.includes("images") ?? true,
+				...this.config.toolContextMetadata,
+				[CLINE_INTERNAL_TELEMETRY_METADATA_KEY]: this.telemetry,
+			},
+			hooks: this.createRuntimeHooks(),
+			prepareTurn: this.createRuntimePrepareTurn(modelInfo, tools),
+			initialMessages,
+			systemPrompt,
+		});
+		const runtime = this.createAgentRuntimeImpl(runtimeConfig);
+		this.activeRuntime = runtime;
+		if (this.abortRequested) {
+			runtime.abort(this.abortReason);
+		}
+
+		// Subscribe to runtime events; fan out legacy events to listeners
+		// and keep private book-keeping for tool-call records / usage.
+		const unsubscribe = runtime.subscribe((event: AgentRuntimeEvent) => {
+			this.handleRuntimeEvent(event);
+		});
+
+		let runResult: AgentRunResult | undefined;
+		let thrownError: Error | undefined;
+		try {
+			// Pass empty input so AgentRuntime does not duplicate the
+			// user message we already seeded via `initialMessages`. The
+			// runtime's `normalizeInput` treats `""`/`undefined` as
+			// "no extra messages".
+			if (input.isContinue) {
+				runResult = await runtime.continue(undefined);
+			} else {
+				runResult = await runtime.run("");
+			}
+		} catch (error) {
+			thrownError = error instanceof Error ? error : new Error(String(error));
+		} finally {
+			unsubscribe();
+			// Drain any in-flight tracker work (mistake/loop side-effects
+			// queued from handleRuntimeEvent) before we clear state so a
+			// late abort can still reach the runtime if needed.
+			try {
+				await this.activeTrackerWork;
+			} catch (error) {
+				this.logger?.error?.(
+					"SessionRuntime tracker work failed during drain",
+					{ agentId: this.agentId, error },
+				);
+			}
+			this.activeRuntime = null;
+			this.running = false;
+			this.abortRequested = false;
+			this.abortReason = undefined;
+		}
+
+		// Persist the runtime's message trail back into the conversation
+		// store so later turns see assistant output. The runtime state
+		// was seeded with the full transcript, so `runResult.messages`
+		// IS the complete new transcript (seed + newly-produced turn).
+		if (runResult && runResult.messages.length > 0) {
+			const replacement = agentMessagesToMessagesWithMetadata(
+				runResult.messages,
+			);
+			this.conversation.replaceMessages(replacement);
+		}
+
+		const endedAt = new Date();
+		try {
+			return this.buildLegacyResult({
+				runResult,
+				thrownError,
+				startedAt,
+				endedAt,
+			});
+		} finally {
+			this.activeRunId = null;
+		}
+	}
+
+	/**
+	 * Initialize the contribution registry once per session. Runs
+	 * extension `setup()` callbacks so they can `registerTool`,
+	 * `registerCommand`, `registerMessageBuilder`, and
+	 * `registerProvider`. Matches legacy `Agent.ensureExtensionsInitialized`
+	 * at pre-Step-9 `agent.ts:1122-1147`:
+	 *
+	 *   - on `hookErrorMode === "throw"`, setup failures propagate;
+	 *   - otherwise setup failures emit a recoverable `error` event
+	 *     via the legacy event channel and leave the registry
+	 *     partially initialized.
+	 *
+	 * Idempotent: subsequent calls are no-ops once the registry has
+	 * been activated.
+	 */
+	private async ensureExtensionsInitialized(): Promise<void> {
+		if (this.extensionsInitialized) {
+			return;
+		}
+		try {
+			await this.contributionRegistry.initialize({
+				tolerateSetupErrors: this.config.hookErrorMode !== "throw",
+			});
+		} catch (error) {
+			if (this.config.hookErrorMode === "throw") {
+				throw error;
+			}
+			this.emitLegacyEvent({
+				type: "error",
+				error: error instanceof Error ? error : new Error(String(error)),
+				recoverable: true,
+				iteration: 0,
+			});
+		}
+		this.extensionsInitialized = true;
+	}
+
+	private createRuntimeHooks(): Partial<AgentRuntimeHooks> {
+		const hooks = mergeRuntimeHooks([
+			this.config.hooks,
+			...this.contributionRegistry
+				.getValidatedExtensions()
+				.map((extension) => extension.hooks),
+		]);
+		return {
+			...hooks,
+			beforeModel: async (ctx) => {
+				const control = await hooks.beforeModel?.(ctx);
+				if (control?.stop) {
+					return control;
+				}
+				const messages = control?.messages ?? ctx.request.messages;
+				const preparedMessages =
+					await this.prepareMessagesForModelRequest(messages);
+				return {
+					...control,
+					messages: preparedMessages,
+				};
+			},
+		};
+	}
+
+	private createRuntimePrepareTurn(
+		modelInfo: ModelInfo | undefined,
+		tools: AgentTool[],
+	):
+		| ((context: AgentRuntimePrepareTurnContext) => Promise<
+				| {
+						messages?: readonly AgentMessage[];
+						systemPrompt?: string;
+				  }
+				| undefined
+		  >)
+		| undefined {
+		const prepareTurn = this.config.prepareTurn;
+		if (!prepareTurn) {
+			return undefined;
+		}
+
+		return async (context) => {
+			const messages = agentMessagesToMessagesWithMetadata(context.messages);
+			const apiMessages = await this.prepareProviderMessagesForApi(messages);
+			const result = await prepareTurn({
+				agentId: context.agentId,
+				conversationId:
+					context.conversationId ?? this.conversation.getConversationId(),
+				parentAgentId: context.parentAgentId ?? null,
+				iteration: context.iteration,
+				messages,
+				apiMessages,
+				abortSignal: context.signal ?? new AbortController().signal,
+				systemPrompt: context.systemPrompt ?? "",
+				tools,
+				model: {
+					id: this.config.modelId,
+					provider: this.config.providerId,
+					info: modelInfo,
+				},
+				emitStatusNotice: context.emitStatusNotice,
+			});
+			if (!result) {
+				return undefined;
+			}
+			return {
+				...(result.messages
+					? { messages: messagesToAgentMessages(result.messages) }
+					: {}),
+				...(result.systemPrompt !== undefined
+					? { systemPrompt: result.systemPrompt }
+					: {}),
+			};
+		};
+	}
+
+	private async prepareMessagesForModelRequest(
+		messages: readonly AgentMessage[],
+	): Promise<AgentMessage[]> {
+		const providerMessages = await this.prepareProviderMessagesForApi(
+			agentMessagesToMessages(messages),
+		);
+		return messagesToAgentMessages(providerMessages);
+	}
+
+	private async prepareProviderMessagesForApi(
+		messages: MessageWithMetadata[],
+	): Promise<MessageWithMetadata[]> {
+		let providerMessages = messages;
+		const messageBuilders =
+			this.contributionRegistry.getRegistrySnapshot().messageBuilder;
+		for (const builder of messageBuilders) {
+			providerMessages = await builder.build(providerMessages);
+		}
+		return this.messageBuilder.buildForApi(providerMessages);
+	}
+
+	private handleRuntimeEvent(event: AgentRuntimeEvent): void {
+		// Track tool-call records before translation so the timing data
+		// is available to observers via `AgentResult.toolCalls`.
+		switch (event.type) {
+			case "message-added":
+			case "assistant-message": {
+				this.syncConversationFromRuntimeMessage(event.snapshot.messages, [
+					event.message,
+				]);
+				break;
+			}
+			case "turn-started": {
+				// Reset per-turn tool-outcome counters used by the
+				// MistakeTracker wiring. Parity with pre-Step-9
+				// agent.ts which accumulates per-iteration success/fail
+				// counts and feeds them into recordMistake at the
+				// turn boundary.
+				this.currentTurnSuccessfulTools = 0;
+				this.currentTurnFailedTools = 0;
+				this.currentTurnFailureDetails = [];
+				break;
+			}
+			case "tool-started": {
+				this.toolStartedAt.set(event.toolCall.toolCallId, new Date());
+				this.toolInputs.set(event.toolCall.toolCallId, event.toolCall.input);
+				// Loop-detection inspection: identical consecutive
+				// tool-call signatures trip the tracker. On "soft"
+				// verdict we append a recovery notice; on "hard"
+				// verdict we feed the mistake tracker with
+				// forceAtLimit:true and abort. Parity with pre-Step-9
+				// agent.ts L917-954.
+				this.inspectLoopForToolCall(
+					event.toolCall.toolName,
+					event.toolCall.input,
+					event.iteration,
+				);
+				break;
+			}
+			case "tool-finished": {
+				const startedAt = this.toolStartedAt.get(event.toolCall.toolCallId);
+				const endedAt = new Date();
+				const input = this.toolInputs.get(event.toolCall.toolCallId);
+				this.toolStartedAt.delete(event.toolCall.toolCallId);
+				this.toolInputs.delete(event.toolCall.toolCallId);
+				const resultPart = event.message.content.find(
+					(part) => part.type === "tool-result",
+				);
+				const isError =
+					resultPart?.type === "tool-result" && resultPart.isError === true;
+				const errorText = isError
+					? formatToolResultError(
+							resultPart?.type === "tool-result"
+								? resultPart.output
+								: undefined,
+						)
+					: undefined;
+				const record: ToolCallRecord = {
+					id: event.toolCall.toolCallId,
+					name: event.toolCall.toolName,
+					input,
+					output:
+						resultPart?.type === "tool-result" ? resultPart.output : undefined,
+					error: errorText,
+					durationMs:
+						startedAt === undefined
+							? 0
+							: endedAt.getTime() - startedAt.getTime(),
+					startedAt: startedAt ?? endedAt,
+					endedAt,
+				};
+				this.currentRunToolCalls.push(record);
+				// Per-turn success/failure bookkeeping for MistakeTracker.
+				if (isError) {
+					this.currentTurnFailedTools += 1;
+					if (errorText) {
+						this.currentTurnFailureDetails.push(
+							`[${event.toolCall.toolName}] ${errorText}`,
+						);
+					}
+				} else {
+					this.currentTurnSuccessfulTools += 1;
+				}
+				break;
+			}
+			case "turn-finished": {
+				// End-of-turn mistake evaluation: legacy parity (pre-Step-9
+				// agent.ts L972-997). When some tool calls failed and the
+				// turn had no successful tool calls, record a mistake;
+				// reset on productive turns.
+				const failed = this.currentTurnFailedTools;
+				const succeeded = this.currentTurnSuccessfulTools;
+				if (failed > 0 && succeeded === 0) {
+					const details = this.currentTurnFailureDetails.join("; ");
+					this.enqueueMistakeRecord({
+						iteration: event.iteration,
+						reason: "tool_execution_failed",
+						details: `${failed} tool call(s) failed${
+							details ? `: ${details}` : ""
+						}`,
+					});
+				} else if (succeeded > 0) {
+					// Productive turn — reset the tracker so transient
+					// failures don't accumulate across unrelated turns.
+					this.mistakeTracker.reset();
+				}
+				break;
+			}
+			case "usage-updated": {
+				this.currentRunUsage = {
+					inputTokens: event.usage.inputTokens,
+					outputTokens: event.usage.outputTokens,
+					cacheReadTokens:
+						event.usage.cacheReadTokens > 0
+							? event.usage.cacheReadTokens
+							: undefined,
+					cacheWriteTokens:
+						event.usage.cacheWriteTokens > 0
+							? event.usage.cacheWriteTokens
+							: undefined,
+					totalCost: event.usage.totalCost,
+				};
+				break;
+			}
+			default:
+				break;
+		}
+		for (const legacy of this.eventAdapter.translate(event)) {
+			this.emitLegacyEvent(legacy);
+		}
+	}
+
+	private syncConversationFromRuntimeMessage(
+		snapshotMessages: readonly AgentMessage[],
+		fallbackMessages: readonly AgentMessage[],
+	): void {
+		if (snapshotMessages.length > 0) {
+			this.conversation.replaceMessages(
+				agentMessagesToMessagesWithMetadata(snapshotMessages),
+			);
+			return;
+		}
+		if (fallbackMessages.length === 0) return;
+		const existingIds = new Set(
+			this.conversation
+				.getMessages()
+				.map((message) => message.id)
+				.filter((id): id is string => typeof id === "string"),
+		);
+		const newMessages = agentMessagesToMessagesWithMetadata(
+			fallbackMessages,
+		).filter((message) => !message.id || !existingIds.has(message.id));
+		if (newMessages.length === 0) return;
+		this.conversation.replaceMessages([
+			...this.conversation.getMessages(),
+			...newMessages,
+		]);
+	}
+
+	private emitLegacyEvent(event: AgentEvent): void {
+		for (const listener of this.listeners) {
+			try {
+				listener(event);
+			} catch (error) {
+				this.logger?.error?.("SessionRuntime event listener threw", {
+					agentId: this.agentId,
+					error,
+				});
+			}
+		}
+	}
+
+	/**
+	 * Feed the `LoopDetectionTracker` with a tool-call and react to
+	 * the returned verdict. Parity with pre-Step-9 agent.ts L917-954:
+	 *
+	 *   - `"soft"`  → append a recovery notice telling the model to
+	 *                 change approach;
+	 *   - `"hard"`  → feed `MistakeTracker.record` with
+	 *                 `forceAtLimit:true`. When the tracker returns
+	 *                 `action: "stop"`, append the stop notice and
+	 *                 abort the active runtime.
+	 */
+	private inspectLoopForToolCall(
+		toolName: string,
+		input: unknown,
+		iteration: number,
+	): void {
+		if (this.trackerAbortInFlight || this.loopDetectionDisabled) {
+			return;
+		}
+		const verdict = this.loopTracker.inspect({ name: toolName, input });
+		if (verdict.kind === "ok") {
+			return;
+		}
+		if (verdict.kind === "soft") {
+			if (verdict.message) {
+				this.conversation.appendMessage({
+					role: "user",
+					content: [{ type: "text", text: verdict.message }],
+				});
+			}
+			return;
+		}
+		// Hard escalation.
+		this.enqueueMistakeRecord({
+			iteration,
+			reason: "tool_execution_failed",
+			forceAtLimit: true,
+			details:
+				verdict.message ??
+				`Detected repeated tool calls to \`${toolName}\`; stopping to avoid a loop.`,
+		});
+	}
+
+	/**
+	 * Enqueue a mistake-record onto the serial tracker work chain. The
+	 * runtime event stream is synchronous but `MistakeTracker.record`
+	 * is async — chaining onto a shared promise preserves ordering
+	 * (legacy parity) and lets `executeRun` await draining before
+	 * returning the `AgentResult`.
+	 *
+	 * When the tracker returns `action: "stop"`, append the stop notice
+	 * to the conversation and abort the active runtime so the run ends
+	 * with `finishReason: "aborted"`.
+	 */
+	private enqueueMistakeRecord(input: {
+		iteration: number;
+		reason: "api_error" | "invalid_tool_call" | "tool_execution_failed";
+		details?: string;
+		forceAtLimit?: boolean;
+	}): void {
+		if (this.trackerAbortInFlight) {
+			return;
+		}
+		this.activeTrackerWork = this.activeTrackerWork.then(async () => {
+			if (this.trackerAbortInFlight) {
+				return;
+			}
+			const outcome = await this.mistakeTracker.record(input);
+			if (outcome.action === "stop") {
+				this.trackerAbortInFlight = true;
+				this.conversation.appendMessage({
+					role: "user",
+					content: [{ type: "text", text: outcome.message }],
+				});
+				this.activeRuntime?.abort(outcome.reason ?? outcome.message);
+			}
+		});
+	}
+
+	private buildLegacyResult(input: {
+		runResult: AgentRunResult | undefined;
+		thrownError: Error | undefined;
+		startedAt: Date;
+		endedAt: Date;
+	}): AgentResult {
+		const { runResult, thrownError, startedAt, endedAt } = input;
+		const durationMs = endedAt.getTime() - startedAt.getTime();
+		const finishReason: AgentFinishReason = thrownError
+			? "error"
+			: deriveFinishReason(runResult);
+		const text =
+			(runResult?.status === "failed" ? runResult.error?.message : undefined) ||
+			runResult?.outputText ||
+			"";
+		const usage: LegacyAgentUsage = runResult
+			? {
+					inputTokens: runResult.usage.inputTokens,
+					outputTokens: runResult.usage.outputTokens,
+					cacheReadTokens:
+						runResult.usage.cacheReadTokens > 0
+							? runResult.usage.cacheReadTokens
+							: undefined,
+					cacheWriteTokens:
+						runResult.usage.cacheWriteTokens > 0
+							? runResult.usage.cacheWriteTokens
+							: undefined,
+					totalCost: runResult.usage.totalCost,
+				}
+			: this.currentRunUsage;
+		const messages = runResult
+			? agentMessagesToMessagesWithMetadata(runResult.messages)
+			: this.conversation.getMessages();
+		const modelInfo = tryGetModelInfo(this.config);
+		if (thrownError) {
+			throw thrownError;
+		}
+		return {
+			text,
+			usage,
+			messages,
+			toolCalls: this.currentRunToolCalls,
+			iterations: runResult?.iterations ?? 0,
+			finishReason,
+			model: {
+				id: this.config.modelId,
+				provider: this.config.providerId,
+				info: modelInfo,
+			},
+			startedAt,
+			endedAt,
+			durationMs,
+		};
+	}
+}
+
+// =============================================================================
+// Module-level helpers
+// =============================================================================
+
+function leveledLog(
+	logger: BasicLogger | undefined,
+	level: "debug" | "info" | "warn" | "error",
+	message: string,
+	metadata?: Record<string, unknown>,
+): void {
+	if (!logger) {
+		return;
+	}
+	if (level === "debug") {
+		logger.debug(message, metadata);
+		return;
+	}
+	if (level === "error" && logger.error) {
+		logger.error(message, metadata);
+		return;
+	}
+	const severity: "info" | "warn" | "error" =
+		level === "warn" ? "warn" : level === "error" ? "error" : "info";
+	logger.log(message, { ...metadata, severity });
+}
+
+function deriveFinishReason(
+	runResult: AgentRunResult | undefined,
+): AgentFinishReason {
+	if (!runResult) {
+		return "error";
+	}
+	switch (runResult.status) {
+		case "completed":
+			return "completed";
+		case "aborted":
+			return "aborted";
+		case "failed":
+			return "error";
+	}
+}
+
+async function buildUserTurnContent(
+	userMessage: string,
+	userImages: string[] | undefined,
+	userFiles: string[] | undefined,
+	loader: AgentConfig["userFileContentLoader"],
+): Promise<Message["content"]> {
+	// Import lazily to avoid a circular-import hazard via runtime barrels.
+	const { buildInitialUserContent } = await import("./user-input-builder");
+	return buildInitialUserContent(userMessage, userImages, userFiles, loader);
+}
+
+function tryGetModelInfo(config: AgentConfig): ModelInfo | undefined {
+	if (config.knownModels?.[config.modelId]) {
+		return config.knownModels[config.modelId];
+	}
+	const resolvedKnownModels = resolveKnownModelsFromConfig(config);
+	if (resolvedKnownModels?.[config.modelId]) {
+		return resolvedKnownModels[config.modelId];
+	}
+	return undefined;
+}
diff --git a/sdk/packages/core/src/runtime/orchestration/session-runtime.ts b/sdk/packages/core/src/runtime/orchestration/session-runtime.ts
new file mode 100644
index 0000000..2074ff7
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/session-runtime.ts
@@ -0,0 +1,85 @@
+import type {
+	AgentConfig,
+	AgentEvent,
+	AgentHooks,
+	AgentResult,
+	AgentTool,
+	BasicLogger,
+	ITelemetryService,
+	RuntimeConfigExtensionKind,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@cline/shared";
+import type { UserInstructionConfigService } from "../../extensions/config";
+import type { ToolExecutors } from "../../extensions/tools";
+import type {
+	AgentTeamsRuntime,
+	DelegatedAgentConfigProvider,
+	SubAgentEndContext,
+	SubAgentStartContext,
+	TeamEvent,
+} from "../../extensions/tools/team";
+import type { WorkspaceManager } from "../../services/workspace/workspace-manager";
+import type { CoreSessionConfig } from "../../types/config";
+
+/**
+ * Internal structural alias for the lead-agent handle that
+ * {@link BuiltRuntime.registerLeadAgent} hands off to
+ * `runtime-builder.ts`. Narrowed to only the `.addTools()` surface the
+ * callback exercises; avoids depending on `@cline/agents`' `Agent`
+ * class during the PLAN.md §3.6 Step 5 type-only migration. When
+ * SessionRuntime is rebuilt in Step 6, this field is expected to be
+ * dropped entirely per §3.5 row #2.
+ */
+type LeadAgentHandle = {
+	addTools(tools: AgentTool[]): unknown;
+};
+
+export interface BuiltRuntime {
+	tools: AgentTool[];
+	hooks?: AgentHooks;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+	teamRuntime?: AgentTeamsRuntime;
+	teamRestoredFromPersistence?: boolean;
+	delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
+	extensions?: AgentConfig["extensions"];
+	completionPolicy?: AgentConfig["completionPolicy"];
+	registerLeadAgent?: (agent: LeadAgentHandle) => void;
+	shutdown: (reason: string) => Promise<void> | void;
+}
+
+export interface RuntimeBuilderInput {
+	config: CoreSessionConfig;
+	hooks?: AgentHooks;
+	extensions?: AgentConfig["extensions"];
+	onTeamEvent?: (event: TeamEvent) => void;
+	onSubAgentEvent?: (event: AgentEvent) => void;
+	onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+	onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+	createSpawnTool?: () => AgentTool;
+	onTeamRestored?: () => void;
+	userInstructionService?: UserInstructionConfigService;
+	pluginSkillDirectories?: ReadonlyArray<string>;
+	configExtensions?: RuntimeConfigExtensionKind[];
+	toolExecutors?: Partial<ToolExecutors>;
+	toolPolicies?: CoreSessionConfig["toolPolicies"];
+	workspaceManager?: WorkspaceManager;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+}
+
+export interface RuntimeBuilder {
+	build(input: RuntimeBuilderInput): Promise<BuiltRuntime> | BuiltRuntime;
+}
+
+export interface SessionRuntime {
+	start(config: CoreSessionConfig): Promise<{ sessionId: string }>;
+	send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
+	stop(sessionId: string): Promise<void>;
+	poll(): Promise<string[]>;
+}
diff --git a/sdk/packages/core/src/runtime/orchestration/user-input-builder.ts b/sdk/packages/core/src/runtime/orchestration/user-input-builder.ts
new file mode 100644
index 0000000..1fd7d43
--- /dev/null
+++ b/sdk/packages/core/src/runtime/orchestration/user-input-builder.ts
@@ -0,0 +1,159 @@
+/**
+ * User-input / first-turn content assembler.
+ *
+ * Opens the first user content array for a turn, loading user file contents via
+ * the injected `userFileContentLoader`.
+ */
+
+import type * as LlmsProviders from "@cline/llms";
+
+export async function buildInitialUserContent(
+	userMessage: string,
+	userImages?: string[],
+	userFiles?: string[],
+	userFileContentLoader?: (path: string) => Promise<string>,
+): Promise<string | LlmsProviders.ContentBlock[]> {
+	const imageBlocks = buildImageBlocks(userImages);
+	const fileTextBlocks = await buildUserFileContentBlock(
+		userFiles,
+		userFileContentLoader,
+	);
+
+	if (imageBlocks.length === 0 && !fileTextBlocks) {
+		return userMessage;
+	}
+
+	const content: LlmsProviders.ContentBlock[] = [
+		{
+			type: "text",
+			text: userMessage,
+		},
+		...imageBlocks,
+	];
+	if (fileTextBlocks) {
+		content.push(...fileTextBlocks);
+	}
+	return content;
+}
+
+/**
+ * Normalize a user message shape into a plain string when possible.
+ *
+ * Accepts either a string or a LlmsProviders.Message; returns the best-effort
+ * concatenated plain-text body. Non-text content is ignored.
+ */
+export function normalizeUserMessage(
+	input: string | LlmsProviders.Message | undefined,
+): string {
+	if (input == null) {
+		return "";
+	}
+	if (typeof input === "string") {
+		return input;
+	}
+	const content = input.content;
+	if (typeof content === "string") {
+		return content;
+	}
+	if (!Array.isArray(content)) {
+		return "";
+	}
+	const textParts: string[] = [];
+	for (const block of content) {
+		if (block && typeof block === "object" && block.type === "text") {
+			const text = (block as { text?: unknown }).text;
+			if (typeof text === "string") {
+				textParts.push(text);
+			}
+		}
+	}
+	return textParts.join("\n");
+}
+
+function buildImageBlocks(userImages?: string[]): LlmsProviders.ImageContent[] {
+	if (!userImages || userImages.length === 0) {
+		return [];
+	}
+
+	const blocks: LlmsProviders.ImageContent[] = [];
+	for (const image of userImages) {
+		const block = parseDataUrlImage(image);
+		if (block) {
+			blocks.push(block);
+		}
+	}
+	return blocks;
+}
+
+function parseDataUrlImage(
+	image: string,
+): LlmsProviders.ImageContent | undefined {
+	const value = image.trim();
+	if (!value) {
+		return undefined;
+	}
+
+	const dataUrlMatch = value.match(/^data:([^;,]+);base64,(.+)$/);
+	if (dataUrlMatch) {
+		const mediaType = dataUrlMatch[1];
+		const data = dataUrlMatch[2];
+		if (!mediaType || !data) {
+			return undefined;
+		}
+		return {
+			type: "image",
+			mediaType,
+			data,
+		};
+	}
+
+	// Fallback: treat as plain base64 payload.
+	return {
+		type: "image",
+		mediaType: "image/png",
+		data: value,
+	};
+}
+
+async function buildUserFileContentBlock(
+	userFiles?: string[],
+	userFileContentLoader?: (path: string) => Promise<string>,
+): Promise<LlmsProviders.FileContent[] | undefined> {
+	if (!userFiles || userFiles.length === 0) {
+		return undefined;
+	}
+
+	const loader =
+		userFileContentLoader ??
+		(async () => {
+			throw new Error(
+				"File loading is not configured in this runtime. Provide userFileContentLoader to enable userFiles support.",
+			);
+		});
+
+	const contents = await Promise.all(
+		userFiles.map(async (filePath) => {
+			const normalizedPath = filePath.replace(/\\/g, "/");
+			try {
+				const content = await loader(filePath);
+				return {
+					type: "file",
+					path: normalizedPath,
+					content,
+				} satisfies LlmsProviders.FileContent;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return {
+					type: "file",
+					path: normalizedPath,
+					content: `Error fetching content: ${message}`,
+				} satisfies LlmsProviders.FileContent;
+			}
+		}),
+	);
+
+	if (contents.length === 0) {
+		return undefined;
+	}
+	return contents;
+}
diff --git a/sdk/packages/core/src/runtime/safety/loop-detection.ts b/sdk/packages/core/src/runtime/safety/loop-detection.ts
new file mode 100644
index 0000000..e349007
--- /dev/null
+++ b/sdk/packages/core/src/runtime/safety/loop-detection.ts
@@ -0,0 +1,162 @@
+/**
+ * Repeated tool-call loop detection.
+ *
+ * @see PLAN.md §3.1 — helpers moved from `packages/agents/src/context/loop-detection.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `LoopDetectionTracker`.
+ *
+ * The pure helpers (`createLoopDetectionState`, `resetLoopDetectionState`,
+ * `toolCallSignature`, `checkRepeatedToolCall`) are ported verbatim. The
+ * `LoopDetectionTracker` class is a thin wrapper that owns a
+ * `LoopDetectionState` and exposes the `inspect()` / `reset()` surface that
+ * `SessionRuntime` installs as a `beforeTool` hook per §3.2.3.
+ */
+
+import type { LoopDetectionConfig } from "@cline/shared";
+
+// =============================================================================
+// Pure helpers (verbatim port)
+// =============================================================================
+
+export interface LoopDetectionState {
+	lastToolName: string;
+	lastToolSignature: string;
+	consecutiveIdenticalCount: number;
+}
+
+export function createLoopDetectionState(): LoopDetectionState {
+	return {
+		lastToolName: "",
+		lastToolSignature: "",
+		consecutiveIdenticalCount: 0,
+	};
+}
+
+export function resetLoopDetectionState(state: LoopDetectionState): void {
+	state.lastToolName = "";
+	state.lastToolSignature = "";
+	state.consecutiveIdenticalCount = 0;
+}
+
+function sortKeys(value: unknown): unknown {
+	if (value == null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(sortKeys);
+	const sorted: Record<string, unknown> = {};
+	for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+		sorted[key] = sortKeys((value as Record<string, unknown>)[key]);
+	}
+	return sorted;
+}
+
+export function toolCallSignature(input: unknown): string {
+	if (input == null) return "null";
+	if (typeof input === "string") return input;
+	if (typeof input !== "object") return String(input);
+	try {
+		return JSON.stringify(sortKeys(input));
+	} catch {
+		return String(input);
+	}
+}
+
+export interface LoopCheckResult {
+	softWarning: boolean;
+	hardEscalation: boolean;
+}
+
+export function checkRepeatedToolCall(
+	state: LoopDetectionState,
+	toolName: string,
+	signature: string,
+	config: LoopDetectionConfig,
+): LoopCheckResult {
+	if (
+		toolName === state.lastToolName &&
+		signature === state.lastToolSignature
+	) {
+		state.consecutiveIdenticalCount++;
+	} else {
+		state.consecutiveIdenticalCount = 1;
+	}
+	state.lastToolName = toolName;
+	state.lastToolSignature = signature;
+
+	return {
+		softWarning: state.consecutiveIdenticalCount === config.softThreshold,
+		hardEscalation: state.consecutiveIdenticalCount >= config.hardThreshold,
+	};
+}
+
+// =============================================================================
+// Class wrapper (new — per PLAN.md §3.2.3)
+// =============================================================================
+
+/**
+ * Verdict returned by {@link LoopDetectionTracker.inspect}.
+ *
+ * - `"ok"`   — no repeated call detected.
+ * - `"soft"` — soft-warning threshold reached; SessionRuntime may surface a
+ *              recovery notice but should not block the call.
+ * - `"hard"` — hard-escalation threshold reached; SessionRuntime should
+ *              stop the run with the provided `message`.
+ */
+export interface LoopDetectionVerdict {
+	kind: "ok" | "soft" | "hard";
+	message?: string;
+}
+
+/** Minimal call shape the tracker needs; matches `AgentToolCallPart` subset. */
+export interface LoopDetectionCall {
+	name: string;
+	input: unknown;
+}
+
+const DEFAULT_CONFIG: LoopDetectionConfig = {
+	softThreshold: 3,
+	hardThreshold: 5,
+};
+
+/**
+ * Per-session repeated-tool-call detector.
+ *
+ * `SessionRuntime` owns the instance and installs a `beforeTool` hook
+ * (see `AgentRuntimeHooks.beforeTool`) that calls `inspect()` to decide
+ * whether to return `{ skip, stop, reason }`.
+ */
+export class LoopDetectionTracker {
+	private readonly config: LoopDetectionConfig;
+	private readonly state: LoopDetectionState = createLoopDetectionState();
+
+	constructor(config?: Partial<LoopDetectionConfig>) {
+		this.config = {
+			softThreshold: config?.softThreshold ?? DEFAULT_CONFIG.softThreshold,
+			hardThreshold: config?.hardThreshold ?? DEFAULT_CONFIG.hardThreshold,
+		};
+	}
+
+	inspect(call: LoopDetectionCall): LoopDetectionVerdict {
+		const signature = toolCallSignature(call.input);
+		const result = checkRepeatedToolCall(
+			this.state,
+			call.name,
+			signature,
+			this.config,
+		);
+		if (result.hardEscalation) {
+			return {
+				kind: "hard",
+				message: `Detected ${this.state.consecutiveIdenticalCount} consecutive identical calls to \`${call.name}\`; stopping to avoid a loop.`,
+			};
+		}
+		if (result.softWarning) {
+			return {
+				kind: "soft",
+				message: `Detected ${this.state.consecutiveIdenticalCount} consecutive identical calls to \`${call.name}\`; consider trying a different approach.`,
+			};
+		}
+		return { kind: "ok" };
+	}
+
+	reset(): void {
+		resetLoopDetectionState(this.state);
+	}
+}
diff --git a/sdk/packages/core/src/runtime/safety/mistake-tracker.ts b/sdk/packages/core/src/runtime/safety/mistake-tracker.ts
new file mode 100644
index 0000000..46df1a5
--- /dev/null
+++ b/sdk/packages/core/src/runtime/safety/mistake-tracker.ts
@@ -0,0 +1,221 @@
+/**
+ * Per-session consecutive-mistake tracker.
+ *
+ * @see PLAN.md §3.1 — wrapped around `recordMistake` moved from
+ *                    `packages/agents/src/api/error-handling.ts` lines 147–311.
+ * @see PLAN.md §3.2.3 — public surface of `MistakeTracker`.
+ *
+ * The pure procedural `recordMistake(input, deps)` becomes `record(input)`
+ * on the class; `consecutiveMistakes` is internal state. Other deps flow
+ * through the constructor instead.
+ *
+ * NOTE: the §3.2.3 constructor shape omits some fields (agentId,
+ * conversationId/runId getters, appendRecoveryNotice). They are retained
+ * here for log + notice parity per PLAN.md §3.4.3/§3.4.5. Step 8
+ * (`impl-runtime-porter`) may refactor once SessionRuntime is wired up.
+ */
+
+import type {
+	AgentEvent,
+	BasicLogMetadata,
+	ConsecutiveMistakeLimitContext,
+	ConsecutiveMistakeLimitDecision,
+} from "@cline/shared";
+
+/**
+ * Legacy-agents-style leveled log function. The sdk-re `BasicLogger`
+ * does not carry a level argument (§shared/logging/logger.ts); callers
+ * are expected to bridge via `metadata.severity` or dispatch to
+ * `debug`/`log`/`error`. `MistakeTracker` accepts a leveled callable
+ * here so Step 8 can plug in whichever bridging shape `SessionRuntime`
+ * ends up using.
+ */
+export type LeveledLog = (
+	level: "debug" | "info" | "warn" | "error",
+	message: string,
+	metadata?: BasicLogMetadata,
+) => void;
+
+export type MistakeReason =
+	| "api_error"
+	| "invalid_tool_call"
+	| "tool_execution_failed";
+
+export interface RecordMistakeInput {
+	iteration: number;
+	reason: MistakeReason;
+	details?: string;
+	/** When true, jump straight to maxConsecutiveMistakes instead of incrementing by 1. */
+	forceAtLimit?: boolean;
+}
+
+export type MistakeOutcome =
+	| { action: "continue"; guidance?: string }
+	| { action: "stop"; message: string; reason?: string };
+
+export interface MistakeTrackerOptions {
+	readonly maxConsecutiveMistakes: number;
+	readonly onLimitReached?: (
+		ctx: ConsecutiveMistakeLimitContext,
+	) =>
+		| Promise<ConsecutiveMistakeLimitDecision>
+		| ConsecutiveMistakeLimitDecision;
+	readonly emit: (event: AgentEvent) => void;
+	readonly log: LeveledLog;
+	readonly agentId: string;
+	readonly getConversationId: () => string;
+	readonly getActiveRunId: () => string;
+	readonly appendRecoveryNotice: (
+		message: string,
+		reason: MistakeReason,
+	) => void;
+}
+
+export class MistakeTracker {
+	private consecutiveMistakes = 0;
+	private readonly options: MistakeTrackerOptions;
+
+	constructor(options: MistakeTrackerOptions) {
+		this.options = options;
+	}
+
+	async record(input: RecordMistakeInput): Promise<MistakeOutcome> {
+		const max = this.options.maxConsecutiveMistakes;
+		const next = input.forceAtLimit && max ? max : this.consecutiveMistakes + 1;
+		this.consecutiveMistakes = next;
+
+		const errorMessage =
+			input.details?.trim() || `consecutive mistake (${input.reason})`;
+		this.options.emit({
+			type: "error",
+			error: new Error(errorMessage),
+			recoverable: true,
+			iteration: input.iteration,
+		});
+		this.options.log("warn", "Recorded consecutive mistake", {
+			agentId: this.options.agentId,
+			conversationId: this.options.getConversationId(),
+			runId: this.options.getActiveRunId(),
+			iteration: input.iteration,
+			reason: input.reason,
+			details: input.details,
+			consecutiveMistakes: next,
+			maxConsecutiveMistakes: this.options.maxConsecutiveMistakes,
+		});
+
+		if (!max || next < max) {
+			return { action: "continue" };
+		}
+
+		const decision = await resolveConsecutiveMistakeDecision(
+			{
+				iteration: input.iteration,
+				consecutiveMistakes: next,
+				maxConsecutiveMistakes: max,
+				reason: input.reason,
+				details: input.details,
+			},
+			this.options.onLimitReached,
+		);
+
+		if (decision.action === "continue") {
+			const guidance = decision.guidance?.trim();
+			if (guidance) {
+				this.options.appendRecoveryNotice(guidance, input.reason);
+			}
+			this.consecutiveMistakes = 0;
+			return { action: "continue", guidance };
+		}
+
+		return {
+			action: "stop",
+			reason: decision.reason?.trim() || undefined,
+			message: buildMistakeLimitStopMessage({
+				iteration: input.iteration,
+				consecutiveMistakes: next,
+				maxConsecutiveMistakes: max,
+				reason: input.reason,
+				details: input.details,
+				stopReason: decision.reason,
+			}),
+		};
+	}
+
+	reset(): void {
+		this.consecutiveMistakes = 0;
+	}
+
+	get value(): number {
+		return this.consecutiveMistakes;
+	}
+}
+
+// =============================================================================
+// Mistake Limit Stop Message (pure helper — ported verbatim)
+// =============================================================================
+
+export function buildMistakeLimitStopMessage(input: {
+	iteration: number;
+	consecutiveMistakes: number;
+	maxConsecutiveMistakes: number;
+	reason:
+		| "api_error"
+		| "invalid_tool_call"
+		| "completion_without_submit"
+		| "tool_execution_failed";
+	details?: string;
+	stopReason?: string;
+}): string {
+	const parts = [
+		`Stopped after ${input.consecutiveMistakes}/${input.maxConsecutiveMistakes} consecutive mistakes (${input.reason}) at iteration ${input.iteration}.`,
+	];
+	const details = input.details?.trim();
+	if (details) {
+		parts.push(`Error: ${details}`);
+	}
+	const stopReason = input.stopReason?.trim();
+	if (stopReason) {
+		parts.push(`Decision: ${stopReason}`);
+	}
+	parts.push(
+		"Session state was preserved. Send a new prompt to resume from the latest state.",
+	);
+	return parts.join(" ");
+}
+
+// =============================================================================
+// Consecutive Mistake Decision Resolution (pure helper — ported verbatim)
+// =============================================================================
+
+async function resolveConsecutiveMistakeDecision(
+	input: ConsecutiveMistakeLimitContext,
+	callback?: (
+		context: ConsecutiveMistakeLimitContext,
+	) =>
+		| Promise<ConsecutiveMistakeLimitDecision>
+		| ConsecutiveMistakeLimitDecision,
+): Promise<ConsecutiveMistakeLimitDecision> {
+	if (!callback) {
+		return {
+			action: "stop",
+			reason: `maximum consecutive mistakes reached (${input.maxConsecutiveMistakes})`,
+		};
+	}
+	try {
+		return await callback(input);
+	} catch (error) {
+		return {
+			action: "stop",
+			reason:
+				error instanceof Error
+					? error.message
+					: `maximum consecutive mistakes reached (${input.maxConsecutiveMistakes})`,
+		};
+	}
+}
+
+// TODO(PLAN.md Step 8): The `emit` channel currently accepts legacy `AgentEvent`
+// so the "recoverable error" event shape is preserved verbatim. When
+// `SessionRuntime` wires this up in Step 8, consider whether this should
+// emit an `AgentRuntimeEvent` (per the §3.2.3 signature proposal) and let
+// the bridge translate, or keep the direct legacy channel for notice parity.
diff --git a/sdk/packages/core/src/runtime/safety/rules.test.ts b/sdk/packages/core/src/runtime/safety/rules.test.ts
new file mode 100644
index 0000000..592e3cd
--- /dev/null
+++ b/sdk/packages/core/src/runtime/safety/rules.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { mergeRulesForSystemPrompt } from "./rules";
+
+describe("mergeRulesForSystemPrompt", () => {
+	it("returns additional rules when watcher rules are absent", () => {
+		expect(mergeRulesForSystemPrompt(undefined, "inline rules")).toBe(
+			"inline rules",
+		);
+	});
+
+	it("returns watcher rules when inline rules are absent", () => {
+		expect(mergeRulesForSystemPrompt("watcher rules", undefined)).toBe(
+			"watcher rules",
+		);
+	});
+
+	it("appends inline rules after watcher rules", () => {
+		expect(mergeRulesForSystemPrompt("watcher rules", "inline rules")).toBe(
+			"watcher rules\n\ninline rules",
+		);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/safety/rules.ts b/sdk/packages/core/src/runtime/safety/rules.ts
new file mode 100644
index 0000000..7da883c
--- /dev/null
+++ b/sdk/packages/core/src/runtime/safety/rules.ts
@@ -0,0 +1,49 @@
+import type {
+	RuleConfig,
+	UserInstructionConfigWatcher,
+} from "../../extensions/config/user-instruction-config-loader";
+
+export function isRuleEnabled(rule: RuleConfig): boolean {
+	return rule.disabled !== true;
+}
+
+export function formatRulesForSystemPrompt(
+	rules: ReadonlyArray<RuleConfig>,
+): string {
+	if (rules.length === 0) {
+		return "";
+	}
+
+	const renderedRules = rules
+		.map((rule) => `## ${rule.name}\n${rule.instructions}`)
+		.join("\n\n");
+	return `\n\n# Rules\n${renderedRules}`;
+}
+
+export function mergeRulesForSystemPrompt(
+	primaryRules?: string,
+	additionalRules?: string,
+): string | undefined {
+	const primary = primaryRules?.trim();
+	const additional = additionalRules?.trim();
+	if (primary && additional) {
+		return `${primary}\n\n${additional}`;
+	}
+	return primary || additional || undefined;
+}
+
+export function listEnabledRulesFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): RuleConfig[] {
+	const snapshot = watcher.getSnapshot("rule");
+	return [...snapshot.values()]
+		.map((record) => record.item as RuleConfig)
+		.filter(isRuleEnabled)
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function loadRulesForSystemPromptFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): string {
+	return formatRulesForSystemPrompt(listEnabledRulesFromWatcher(watcher));
+}
diff --git a/sdk/packages/core/src/runtime/tools/subprocess-sandbox.test.ts b/sdk/packages/core/src/runtime/tools/subprocess-sandbox.test.ts
new file mode 100644
index 0000000..f07258e
--- /dev/null
+++ b/sdk/packages/core/src/runtime/tools/subprocess-sandbox.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildSubprocessSandboxCommand,
+	CLINE_JS_RUNTIME_PATH_ENV,
+	resolveSubprocessRuntimeExecutable,
+} from "./subprocess-sandbox";
+
+describe("SubprocessSandbox runtime resolution", () => {
+	it("uses process execPath when it is a JavaScript runtime", () => {
+		expect(
+			resolveSubprocessRuntimeExecutable({
+				execPath: "/usr/local/bin/bun",
+				env: {},
+			}),
+		).toBe("/usr/local/bin/bun");
+		expect(
+			resolveSubprocessRuntimeExecutable({
+				execPath: "/usr/local/bin/node",
+				env: {},
+			}),
+		).toBe("/usr/local/bin/node");
+	});
+
+	it("does not reuse packaged CLI binaries as helper runtimes", () => {
+		expect(
+			resolveSubprocessRuntimeExecutable({
+				execPath: "/usr/local/bin/cline",
+				env: {},
+			}),
+		).toBe("node");
+	});
+
+	it("allows an explicit helper runtime override", () => {
+		expect(
+			resolveSubprocessRuntimeExecutable({
+				execPath: "/usr/local/bin/cline",
+				env: { [CLINE_JS_RUNTIME_PATH_ENV]: "/opt/runtime/js" },
+			}),
+		).toBe("/opt/runtime/js");
+	});
+
+	it("uses known runtime env vars when execPath is not a runtime", () => {
+		expect(
+			resolveSubprocessRuntimeExecutable({
+				execPath: "/usr/local/bin/cline",
+				env: { BUN_EXEC_PATH: "/Users/me/.bun/bin/bun" },
+			}),
+		).toBe("/Users/me/.bun/bin/bun");
+		expect(
+			resolveSubprocessRuntimeExecutable({
+				execPath: "/usr/local/bin/cline",
+				env: { npm_node_execpath: "/opt/node/bin/node" },
+			}),
+		).toBe("/opt/node/bin/node");
+	});
+
+	it("builds plugin sandbox commands with the resolved runtime", () => {
+		expect(
+			buildSubprocessSandboxCommand(["-e", "console.log('ok')"], {
+				execPath: "/usr/local/bin/cline",
+				env: { CLINE_BUILD_ENV: "production" },
+				name: "plugin-sandbox",
+			}),
+		).toEqual(["node", "-e", "console.log('ok')"]);
+	});
+
+	it("preserves development debugging flags for resolved runtimes", () => {
+		expect(
+			buildSubprocessSandboxCommand(["bootstrap.js"], {
+				execPath: "/usr/local/bin/cline",
+				env: { CLINE_BUILD_ENV: "development" },
+				name: "plugin-sandbox",
+			}),
+		).toEqual([
+			"node",
+			"--inspect=127.0.0.1:0",
+			"--enable-source-maps",
+			"bootstrap.js",
+		]);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/tools/subprocess-sandbox.ts b/sdk/packages/core/src/runtime/tools/subprocess-sandbox.ts
new file mode 100644
index 0000000..2881cda
--- /dev/null
+++ b/sdk/packages/core/src/runtime/tools/subprocess-sandbox.ts
@@ -0,0 +1,335 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { basename } from "node:path";
+import {
+	augmentNodeCommandForDebug,
+	withResolvedClineBuildEnv,
+} from "@cline/shared";
+
+interface SandboxCallMessage {
+	type: "call";
+	id: string;
+	method: string;
+	args: unknown;
+}
+
+interface SandboxResponseMessage {
+	type: "response";
+	id: string;
+	ok: boolean;
+	result?: unknown;
+	error?: { message: string; stack?: string };
+}
+
+interface SandboxEventMessage {
+	type: "event";
+	name: string;
+	payload?: unknown;
+}
+
+export interface SubprocessSandboxOptions {
+	/** Inline script to execute via `node -e`. Mutually exclusive with {@link bootstrapFile}. */
+	bootstrapScript?: string;
+	/** Path to a JavaScript file to execute via `node <file>`. Mutually exclusive with {@link bootstrapScript}. */
+	bootstrapFile?: string;
+	/** Runtime executable for internal JavaScript helpers. Defaults to node/bun instead of packaged CLI binaries. */
+	runtimeExecutable?: string;
+	name?: string;
+	onEvent?: (event: { name: string; payload?: unknown }) => void;
+}
+
+export interface SandboxCallOptions {
+	timeoutMs?: number;
+}
+
+type PendingRequest = {
+	resolve: (value: unknown) => void;
+	reject: (error: Error) => void;
+	timeout?: NodeJS.Timeout;
+};
+
+function asError(value: unknown): Error {
+	if (value instanceof Error) {
+		return value;
+	}
+	return new Error(String(value));
+}
+
+export const CLINE_JS_RUNTIME_PATH_ENV = "CLINE_JS_RUNTIME_PATH";
+
+function isRuntimeExecutable(value: string | undefined): boolean {
+	const trimmed = value?.trim();
+	if (!trimmed) {
+		return false;
+	}
+	const name = basename(trimmed).toLowerCase();
+	return (
+		name === "node" ||
+		name === "node.exe" ||
+		name === "bun" ||
+		name === "bun.exe"
+	);
+}
+
+export function resolveSubprocessRuntimeExecutable(
+	options: {
+		env?: NodeJS.ProcessEnv;
+		execPath?: string;
+		runtimeExecutable?: string;
+	} = {},
+): string {
+	const env = options.env ?? process.env;
+	const explicit =
+		options.runtimeExecutable?.trim() || env[CLINE_JS_RUNTIME_PATH_ENV]?.trim();
+	if (explicit) {
+		return explicit;
+	}
+
+	const execPath = options.execPath?.trim() || process.execPath;
+	if (isRuntimeExecutable(execPath)) {
+		return execPath;
+	}
+
+	for (const candidate of [
+		env.BUN_EXEC_PATH,
+		env.npm_node_execpath,
+		env.NODE,
+	]) {
+		const trimmed = candidate?.trim();
+		if (trimmed && isRuntimeExecutable(trimmed)) {
+			return trimmed;
+		}
+	}
+
+	return "node";
+}
+
+export function buildSubprocessSandboxCommand(
+	args: string[],
+	options: {
+		env?: NodeJS.ProcessEnv;
+		execArgv?: string[];
+		name?: string;
+		execPath?: string;
+		runtimeExecutable?: string;
+	} = {},
+): string[] {
+	const runtimeExecutable = resolveSubprocessRuntimeExecutable({
+		env: options.env,
+		execPath: options.execPath,
+		runtimeExecutable: options.runtimeExecutable,
+	});
+	return augmentNodeCommandForDebug([runtimeExecutable, ...args], {
+		env: options.env,
+		execArgv: options.execArgv,
+		debugRole: options.name === "plugin-sandbox" ? "plugin-sandbox" : "sandbox",
+	});
+}
+
+export class SubprocessSandbox {
+	private readonly options: SubprocessSandboxOptions;
+	private process: ChildProcess | null = null;
+	private requestCounter = 0;
+	private readonly pending = new Map<string, PendingRequest>();
+
+	constructor(options: SubprocessSandboxOptions) {
+		this.options = options;
+	}
+
+	private get processLabel(): string {
+		return this.options.name ?? "sandbox";
+	}
+
+	private clearPendingRequest(id: string): PendingRequest | undefined {
+		const pending = this.pending.get(id);
+		if (!pending) {
+			return undefined;
+		}
+		this.pending.delete(id);
+		if (pending.timeout) {
+			clearTimeout(pending.timeout);
+		}
+		return pending;
+	}
+
+	start(): void {
+		if (this.process && this.process.exitCode === null) {
+			return;
+		}
+
+		const args = this.options.bootstrapFile
+			? [this.options.bootstrapFile]
+			: ["-e", this.options.bootstrapScript ?? ""];
+
+		const command = buildSubprocessSandboxCommand(args, {
+			name: this.options.name,
+			runtimeExecutable: this.options.runtimeExecutable,
+		});
+		const child = spawn(
+			command[0] ?? resolveSubprocessRuntimeExecutable(this.options),
+			command.slice(1),
+			{
+				stdio: ["ignore", "ignore", "pipe", "ipc"],
+				env: withResolvedClineBuildEnv(process.env),
+				// Prevent a console window from flashing on Windows.
+				windowsHide: true,
+			},
+		);
+		this.process = child;
+		let stderrBuffer = "";
+		const appendStderr = (chunk: string) => {
+			const next = stderrBuffer + chunk;
+			// Keep only a small tail so errors include useful context
+			// without unbounded memory growth.
+			stderrBuffer = next.length > 4000 ? next.slice(-4000) : next;
+		};
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk: string) => {
+			appendStderr(chunk);
+		});
+		child.on("message", (message) => {
+			this.onMessage(message as SandboxResponseMessage | SandboxEventMessage);
+		});
+		child.on("error", (error) => {
+			this.failPending(
+				new Error(
+					`${this.processLabel} process error: ${asError(error).message}`,
+				),
+			);
+		});
+		child.on("exit", (code, signal) => {
+			this.process = null;
+			const stderrDetail = stderrBuffer.trim();
+			this.failPending(
+				new Error(
+					`${this.options.name ?? "sandbox"} process exited (code=${String(code)}, signal=${String(signal)})${stderrDetail ? `: ${stderrDetail}` : ""}`,
+				),
+			);
+		});
+	}
+
+	async call<TResult = unknown>(
+		method: string,
+		args: unknown,
+		options: SandboxCallOptions = {},
+	): Promise<TResult> {
+		this.start();
+		const child = this.process;
+		if (!child || child.exitCode !== null) {
+			throw new Error(`${this.processLabel} process is not available`);
+		}
+
+		const id = `req_${++this.requestCounter}`;
+		const message: SandboxCallMessage = {
+			type: "call",
+			id,
+			method,
+			args,
+		};
+
+		return await new Promise<TResult>((resolve, reject) => {
+			const pending: PendingRequest = {
+				resolve: (value) => resolve(value as TResult),
+				reject,
+			};
+			if ((options.timeoutMs ?? 0) > 0) {
+				pending.timeout = setTimeout(() => {
+					this.clearPendingRequest(id);
+					this.shutdown().catch(() => {
+						// Best-effort process shutdown after timeout.
+					});
+					reject(
+						new Error(
+							`${this.processLabel} call timed out after ${options.timeoutMs}ms: ${method}`,
+						),
+					);
+				}, options.timeoutMs);
+			}
+			this.pending.set(id, pending);
+			child.send(message, (error) => {
+				if (!error) {
+					return;
+				}
+				const entry = this.clearPendingRequest(id);
+				if (!entry) {
+					return;
+				}
+				entry.reject(
+					new Error(
+						`${this.processLabel} failed to send call "${method}": ${asError(error).message}`,
+					),
+				);
+			});
+		});
+	}
+
+	async shutdown(): Promise<void> {
+		const child = this.process;
+		this.process = null;
+		if (!child || child.exitCode !== null) {
+			this.failPending(new Error(`${this.processLabel} shutdown`));
+			return;
+		}
+		await new Promise<void>((resolve) => {
+			const timeout = setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {
+					// Ignore kill failures.
+				}
+				resolve();
+			}, 300);
+			child.once("exit", () => {
+				clearTimeout(timeout);
+				resolve();
+			});
+			try {
+				child.kill("SIGTERM");
+			} catch {
+				clearTimeout(timeout);
+				resolve();
+			}
+		});
+		this.failPending(new Error(`${this.processLabel} shutdown`));
+	}
+
+	private onMessage(
+		message: SandboxResponseMessage | SandboxEventMessage,
+	): void {
+		if (!message) {
+			return;
+		}
+		if (message.type === "event") {
+			if (typeof message.name === "string" && message.name.length > 0) {
+				this.options.onEvent?.({
+					name: message.name,
+					payload: message.payload,
+				});
+			}
+			return;
+		}
+		if (message.type !== "response" || !message.id) {
+			return;
+		}
+		const pending = this.clearPendingRequest(message.id);
+		if (!pending) {
+			return;
+		}
+		if (message.ok) {
+			pending.resolve(message.result);
+			return;
+		}
+		pending.reject(
+			new Error(message.error?.message || `${this.processLabel} call failed`),
+		);
+	}
+
+	private failPending(error: Error): void {
+		for (const [id, pending] of this.pending.entries()) {
+			this.pending.delete(id);
+			if (pending.timeout) {
+				clearTimeout(pending.timeout);
+			}
+			pending.reject(error);
+		}
+	}
+}
diff --git a/sdk/packages/core/src/runtime/tools/tool-approval.ts b/sdk/packages/core/src/runtime/tools/tool-approval.ts
new file mode 100644
index 0000000..1867dd0
--- /dev/null
+++ b/sdk/packages/core/src/runtime/tools/tool-approval.ts
@@ -0,0 +1,102 @@
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+
+export type DesktopToolApprovalOptions = {
+	approvalDir?: string;
+	sessionId?: string;
+	timeoutMs?: number;
+	pollIntervalMs?: number;
+	nowIso?: () => string;
+};
+
+function sanitizeApprovalToken(value: string): string {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function unlinkIfPresent(path: string): Promise<void> {
+	try {
+		await unlink(path);
+	} catch {
+		// Best-effort cleanup.
+	}
+}
+
+export async function requestDesktopToolApproval(
+	request: ToolApprovalRequest,
+	options: DesktopToolApprovalOptions = {},
+): Promise<ToolApprovalResult> {
+	const approvalDir = options.approvalDir?.trim();
+	const sessionId = options.sessionId?.trim();
+	if (!approvalDir || !sessionId) {
+		return {
+			approved: false,
+			reason: "Desktop tool approval IPC is not configured",
+		};
+	}
+
+	await mkdir(approvalDir, { recursive: true });
+	const requestId = sanitizeApprovalToken(`${request.toolCallId}`);
+	const requestPath = join(
+		approvalDir,
+		`${sessionId}.request.${requestId}.json`,
+	);
+	const decisionPath = join(
+		approvalDir,
+		`${sessionId}.decision.${requestId}.json`,
+	);
+	const nowIso = options.nowIso ?? (() => new Date().toISOString());
+
+	await writeFile(
+		requestPath,
+		`${JSON.stringify(
+			{
+				requestId,
+				sessionId,
+				createdAt: nowIso(),
+				toolCallId: request.toolCallId,
+				toolName: request.toolName,
+				input: request.input,
+				iteration: request.iteration,
+				agentId: request.agentId,
+				conversationId: request.conversationId,
+			},
+			null,
+			2,
+		)}\n`,
+		"utf8",
+	);
+
+	const timeoutMs = options.timeoutMs ?? 5 * 60_000;
+	const pollIntervalMs = options.pollIntervalMs ?? 200;
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < timeoutMs) {
+		try {
+			const raw = await readFile(decisionPath, "utf8");
+			const parsed = JSON.parse(raw) as {
+				approved?: boolean;
+				reason?: string;
+			};
+			const result = {
+				approved: parsed.approved === true,
+				reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
+			};
+			await Promise.all([
+				unlinkIfPresent(decisionPath),
+				unlinkIfPresent(requestPath),
+			]);
+			return result;
+		} catch {
+			// Decision not available yet.
+		}
+		await delay(pollIntervalMs);
+	}
+
+	await unlinkIfPresent(requestPath);
+
+	return { approved: false, reason: "Tool approval request timed out" };
+}
diff --git a/sdk/packages/core/src/runtime/turn-queue/pending-prompt-service.test.ts b/sdk/packages/core/src/runtime/turn-queue/pending-prompt-service.test.ts
new file mode 100644
index 0000000..8c2fb81
--- /dev/null
+++ b/sdk/packages/core/src/runtime/turn-queue/pending-prompt-service.test.ts
@@ -0,0 +1,168 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CoreSessionEvent } from "../../types/events";
+import type { ActiveSession } from "../../types/session";
+import {
+	type PendingPromptQueueState,
+	PendingPromptService,
+	PendingPromptsController,
+} from "./pending-prompt-service";
+
+function createState(): PendingPromptQueueState {
+	return { pendingPrompts: [] };
+}
+
+describe("PendingPromptService", () => {
+	it("deduplicates prompts and prioritizes steer delivery", () => {
+		const service = new PendingPromptService();
+		const state = createState();
+
+		service.enqueue(state, { prompt: "first", delivery: "queue" });
+		service.enqueue(state, { prompt: "second", delivery: "queue" });
+		service.enqueue(state, { prompt: "first", delivery: "steer" });
+
+		expect(
+			service.list(state).map(({ prompt, delivery }) => ({ prompt, delivery })),
+		).toEqual([
+			{ prompt: "first", delivery: "steer" },
+			{ prompt: "second", delivery: "queue" },
+		]);
+		expect(state.pendingPrompts).toHaveLength(2);
+	});
+
+	it("updates prompts and reorders when delivery changes", () => {
+		const service = new PendingPromptService();
+		const state = createState();
+
+		service.enqueue(state, { prompt: "first", delivery: "queue" });
+		service.enqueue(state, { prompt: "second", delivery: "queue" });
+		const queued = service.list(state);
+
+		const edited = service.update(state, {
+			sessionId: "sess-1",
+			promptId: queued[0]?.id,
+			prompt: "edited first",
+		});
+		expect(edited.updated).toBe(true);
+		expect(edited.prompts.map((prompt) => prompt.prompt)).toEqual([
+			"edited first",
+			"second",
+		]);
+
+		const steered = service.update(state, {
+			sessionId: "sess-1",
+			promptId: queued[1]?.id,
+			delivery: "steer",
+		});
+		expect(
+			steered.prompts.map(({ prompt, delivery }) => ({ prompt, delivery })),
+		).toEqual([
+			{ prompt: "second", delivery: "steer" },
+			{ prompt: "edited first", delivery: "queue" },
+		]);
+	});
+
+	it("consumes steer prompts before queued turns", () => {
+		const service = new PendingPromptService();
+		const state = createState();
+
+		service.enqueue(state, { prompt: "queued", delivery: "queue" });
+		service.enqueue(state, { prompt: "steered", delivery: "steer" });
+
+		const steered = service.consumeSteer(state);
+		expect(steered.entry?.prompt).toBe("steered");
+		expect(steered.prompts.map((prompt) => prompt.prompt)).toEqual(["queued"]);
+
+		const queued = service.shiftNext(state);
+		expect(queued.entry?.prompt).toBe("queued");
+		expect(queued.prompts).toEqual([]);
+	});
+
+	it("deletes prompts and reports missing prompts without mutation", () => {
+		const service = new PendingPromptService();
+		const state = createState();
+
+		service.enqueue(state, { prompt: "keep", delivery: "queue" });
+		service.enqueue(state, { prompt: "remove", delivery: "queue" });
+		const removeId = service.list(state)[1]?.id;
+
+		const missing = service.delete(state, {
+			sessionId: "sess-1",
+			promptId: "missing",
+		});
+		expect(missing.removed).toBe(false);
+		expect(missing.prompts.map((prompt) => prompt.prompt)).toEqual([
+			"keep",
+			"remove",
+		]);
+
+		const removed = service.delete(state, {
+			sessionId: "sess-1",
+			promptId: removeId,
+		});
+		expect(removed.removed).toBe(true);
+		expect(removed.prompt?.prompt).toBe("remove");
+		expect(removed.prompts.map((prompt) => prompt.prompt)).toEqual(["keep"]);
+	});
+
+	it("normalizes edited prompt text and rejects empty prompts", () => {
+		const service = new PendingPromptService();
+		const state = createState();
+
+		service.enqueue(state, { prompt: "first", delivery: "queue" });
+		const queued = service.list(state);
+
+		expect(() =>
+			service.update(state, {
+				sessionId: "sess-1",
+				promptId: queued[0]?.id,
+				prompt: "   ",
+			}),
+		).toThrow("prompt cannot be empty");
+	});
+
+	it("requeues a drained prompt when send fails", async () => {
+		const sessionId = "sess-drain-failure";
+		const session = {
+			sessionId,
+			pendingPrompts: [
+				{
+					id: "pending-1",
+					prompt: "try later",
+					delivery: "steer",
+				},
+			],
+			aborting: false,
+			drainingPendingPrompts: false,
+			status: "completed",
+			agent: {
+				canStartRun: () => true,
+			},
+		} as unknown as ActiveSession;
+		const events: CoreSessionEvent[] = [];
+		const controller = new PendingPromptsController({
+			getSession: () => session,
+			emit: (event) => events.push(event),
+			send: vi.fn().mockRejectedValue(new Error("send failed")),
+		});
+
+		await controller.drain(sessionId);
+
+		expect(controller.list(sessionId).map((prompt) => prompt.prompt)).toEqual([
+			"try later",
+		]);
+		expect(
+			events.some(
+				(event) =>
+					event.type === "pending_prompts" &&
+					event.payload.prompts.length === 0,
+			),
+		).toBe(true);
+		expect(
+			events.some(
+				(event) =>
+					event.type === "pending_prompts" &&
+					event.payload.prompts.some((prompt) => prompt.prompt === "try later"),
+			),
+		).toBe(true);
+	});
+});
diff --git a/sdk/packages/core/src/runtime/turn-queue/pending-prompt-service.ts b/sdk/packages/core/src/runtime/turn-queue/pending-prompt-service.ts
new file mode 100644
index 0000000..ce9e58b
--- /dev/null
+++ b/sdk/packages/core/src/runtime/turn-queue/pending-prompt-service.ts
@@ -0,0 +1,385 @@
+import { type AgentMode, normalizeUserInput } from "@cline/shared";
+import { nanoid } from "nanoid";
+import type {
+	CoreSessionEvent,
+	SessionPendingPrompt,
+} from "../../types/events";
+import type { ActiveSession, PendingPrompt } from "../../types/session";
+import type {
+	PendingPromptMutationResult,
+	PendingPromptsDeleteInput,
+	PendingPromptsUpdateInput,
+} from "../host/runtime-host";
+
+export type PendingPromptDelivery = "queue" | "steer";
+
+export interface PendingPromptEntry {
+	id: string;
+	prompt: string;
+	mode?: AgentMode;
+	delivery: PendingPromptDelivery;
+	userImages?: string[];
+	userFiles?: string[];
+}
+
+export interface PendingPromptQueueState {
+	pendingPrompts: PendingPromptEntry[];
+}
+
+export interface PendingPromptsControllerDeps {
+	getSession(sessionId: string): ActiveSession | undefined;
+	emit(event: CoreSessionEvent): void;
+	send(input: {
+		sessionId: string;
+		prompt: string;
+		mode?: AgentMode;
+		userImages?: string[];
+		userFiles?: string[];
+	}): Promise<unknown>;
+}
+
+export interface PendingPromptEnqueueInput {
+	prompt: string;
+	mode?: AgentMode;
+	delivery: PendingPromptDelivery;
+	userImages?: string[];
+	userFiles?: string[];
+}
+
+export interface PendingPromptConsumeResult {
+	entry?: PendingPromptEntry;
+	prompts: SessionPendingPrompt[];
+}
+
+export class PendingPromptService {
+	list(state: PendingPromptQueueState | undefined): SessionPendingPrompt[] {
+		return state ? snapshotPrompts(state) : [];
+	}
+
+	update(
+		state: PendingPromptQueueState | undefined,
+		input: PendingPromptsUpdateInput,
+	): PendingPromptMutationResult {
+		if (!state) {
+			return { sessionId: input.sessionId, prompts: [], updated: false };
+		}
+		const promptId = input.promptId.trim();
+		const index = state.pendingPrompts.findIndex(
+			(entry) => entry.id === promptId,
+		);
+		if (index < 0) {
+			return {
+				sessionId: input.sessionId,
+				prompts: snapshotPrompts(state),
+				updated: false,
+			};
+		}
+
+		const existing = state.pendingPrompts[index];
+		if (!existing) {
+			return {
+				sessionId: input.sessionId,
+				prompts: snapshotPrompts(state),
+				updated: false,
+			};
+		}
+		const prompt =
+			input.prompt === undefined
+				? existing.prompt
+				: normalizeUserInput(input.prompt).trim();
+		if (!prompt) {
+			throw new Error("prompt cannot be empty");
+		}
+		const delivery = input.delivery ?? existing.delivery;
+		const next: PendingPromptEntry = {
+			...existing,
+			prompt,
+			mode: input.mode ?? existing.mode,
+			delivery,
+		};
+		state.pendingPrompts.splice(index, 1);
+		insertUpdatedPrompt(state, next, index, existing.delivery);
+		return {
+			sessionId: input.sessionId,
+			prompts: snapshotPrompts(state),
+			prompt: snapshotPrompt(next),
+			updated: true,
+		};
+	}
+
+	delete(
+		state: PendingPromptQueueState | undefined,
+		input: PendingPromptsDeleteInput,
+	): PendingPromptMutationResult {
+		if (!state) {
+			return { sessionId: input.sessionId, prompts: [], removed: false };
+		}
+		const promptId = input.promptId.trim();
+		const index = state.pendingPrompts.findIndex(
+			(entry) => entry.id === promptId,
+		);
+		if (index < 0) {
+			return {
+				sessionId: input.sessionId,
+				prompts: snapshotPrompts(state),
+				removed: false,
+			};
+		}
+		const [removed] = state.pendingPrompts.splice(index, 1);
+		return {
+			sessionId: input.sessionId,
+			prompts: snapshotPrompts(state),
+			prompt: removed ? snapshotPrompt(removed) : undefined,
+			removed: true,
+		};
+	}
+
+	enqueue(
+		state: PendingPromptQueueState,
+		input: PendingPromptEnqueueInput,
+	): SessionPendingPrompt[] {
+		const { prompt, mode, delivery, userImages, userFiles } = input;
+		const existingIndex = state.pendingPrompts.findIndex(
+			(queued) => queued.prompt === prompt,
+		);
+		if (existingIndex >= 0) {
+			const [existing] = state.pendingPrompts.splice(existingIndex, 1);
+			const next: PendingPromptEntry = {
+				...existing,
+				prompt,
+				mode: mode ?? existing.mode,
+				userImages: userImages ?? existing.userImages,
+				userFiles: userFiles ?? existing.userFiles,
+			};
+			if (delivery === "steer" || existing.delivery === "steer") {
+				state.pendingPrompts.unshift({ ...next, delivery: "steer" });
+			} else {
+				state.pendingPrompts.push(next);
+			}
+		} else {
+			const newEntry: PendingPromptEntry = {
+				id: `pending_${Date.now()}_${nanoid(5)}`,
+				prompt,
+				mode,
+				delivery,
+				userImages,
+				userFiles,
+			};
+			if (delivery === "steer") {
+				state.pendingPrompts.unshift(newEntry);
+			} else {
+				state.pendingPrompts.push(newEntry);
+			}
+		}
+		return snapshotPrompts(state);
+	}
+
+	consumeSteer(state: PendingPromptQueueState): PendingPromptConsumeResult {
+		const steerIndex = state.pendingPrompts.findIndex(
+			(entry) => entry.delivery === "steer",
+		);
+		if (steerIndex < 0) {
+			return { prompts: snapshotPrompts(state) };
+		}
+		const [entry] = state.pendingPrompts.splice(steerIndex, 1);
+		return { entry, prompts: snapshotPrompts(state) };
+	}
+
+	shiftNext(state: PendingPromptQueueState): PendingPromptConsumeResult {
+		const entry = state.pendingPrompts.shift();
+		return { entry, prompts: snapshotPrompts(state) };
+	}
+
+	requeueFront(
+		state: PendingPromptQueueState,
+		entry: PendingPromptEntry,
+	): SessionPendingPrompt[] {
+		state.pendingPrompts.unshift(entry);
+		return snapshotPrompts(state);
+	}
+
+	clear(state: PendingPromptQueueState): SessionPendingPrompt[] {
+		state.pendingPrompts.length = 0;
+		return [];
+	}
+}
+
+export class PendingPromptsController {
+	private readonly service = new PendingPromptService();
+
+	constructor(private readonly deps: PendingPromptsControllerDeps) {}
+
+	list(sessionId: string): SessionPendingPrompt[] {
+		return this.service.list(this.deps.getSession(sessionId));
+	}
+
+	update(input: PendingPromptsUpdateInput): PendingPromptMutationResult {
+		const session = this.deps.getSession(input.sessionId);
+		if (!session || session.aborting) {
+			return { sessionId: input.sessionId, prompts: [], updated: false };
+		}
+		const result = this.service.update(session, input);
+		this.emitPrompts(session);
+		this.scheduleDrain(input.sessionId, session);
+		return result;
+	}
+
+	delete(input: PendingPromptsDeleteInput): PendingPromptMutationResult {
+		const session = this.deps.getSession(input.sessionId);
+		if (!session || session.aborting) {
+			return { sessionId: input.sessionId, prompts: [], removed: false };
+		}
+		const result = this.service.delete(session, input);
+		this.emitPrompts(session);
+		this.scheduleDrain(input.sessionId, session);
+		return result;
+	}
+
+	enqueue(
+		sessionId: string,
+		entry: {
+			prompt: string;
+			mode?: AgentMode;
+			delivery: "queue" | "steer";
+			userImages?: string[];
+			userFiles?: string[];
+		},
+	): void {
+		const session = this.deps.getSession(sessionId);
+		if (!session || session.aborting) return;
+		this.service.enqueue(session, entry);
+		this.emitPrompts(session);
+		this.scheduleDrain(sessionId, session);
+	}
+
+	consumeSteer(sessionId: string): PendingPromptEntry | undefined {
+		const session = this.deps.getSession(sessionId);
+		if (!session) return undefined;
+		const { entry: steer } = this.service.consumeSteer(session);
+		if (!steer) return undefined;
+		this.emitPrompts(session);
+		this.emitSubmitted(session, steer);
+		return steer;
+	}
+
+	clearAborted(session: ActiveSession): void {
+		if (session.pendingPrompts.length === 0) return;
+		this.service.clear(session);
+		this.emitPrompts(session);
+	}
+
+	emitPrompts(session: ActiveSession): void {
+		this.deps.emit({
+			type: "pending_prompts",
+			payload: {
+				sessionId: session.sessionId,
+				prompts: snapshotPrompts(session),
+			},
+		});
+	}
+
+	scheduleDrain(sessionId: string, session: ActiveSession): void {
+		if (
+			session.pendingPrompts.length === 0 ||
+			session.aborting ||
+			session.drainingPendingPrompts ||
+			!session.agent.canStartRun()
+		) {
+			return;
+		}
+		queueMicrotask(() => {
+			void this.drain(sessionId);
+		});
+	}
+
+	async drain(sessionId: string): Promise<void> {
+		const session = this.deps.getSession(sessionId);
+		if (!session) return;
+		if (session.aborting || session.drainingPendingPrompts) {
+			return;
+		}
+		if (!session.agent.canStartRun()) {
+			return;
+		}
+		const { entry: next } = this.service.shiftNext(session);
+		if (!next) return;
+		this.emitPrompts(session);
+		this.emitSubmitted(session, next);
+		session.drainingPendingPrompts = true;
+		let continueDrain = true;
+		try {
+			await this.deps.send({
+				sessionId,
+				prompt: next.prompt,
+				...(next.mode ? { mode: next.mode } : {}),
+				userImages: next.userImages,
+				userFiles: next.userFiles,
+			});
+		} catch {
+			continueDrain = false;
+			this.service.requeueFront(session, next);
+			this.emitPrompts(session);
+		} finally {
+			session.drainingPendingPrompts = false;
+			if (
+				continueDrain &&
+				session.pendingPrompts.length > 0 &&
+				session.status !== "failed" &&
+				session.status !== "cancelled"
+			) {
+				queueMicrotask(() => {
+					void this.drain(sessionId);
+				});
+			}
+		}
+	}
+
+	private emitSubmitted(session: ActiveSession, entry: PendingPrompt): void {
+		const prompt = snapshotPrompt(entry);
+		this.deps.emit({
+			type: "pending_prompt_submitted",
+			payload: {
+				sessionId: session.sessionId,
+				id: prompt.id,
+				prompt: prompt.prompt,
+				delivery: prompt.delivery,
+				attachmentCount: prompt.attachmentCount,
+				userImages: prompt.userImages,
+				userFiles: prompt.userFiles,
+			},
+		});
+	}
+}
+
+function snapshotPrompt(entry: PendingPromptEntry): SessionPendingPrompt {
+	return {
+		id: entry.id,
+		prompt: entry.prompt,
+		delivery: entry.delivery,
+		attachmentCount:
+			(entry.userImages?.length ?? 0) + (entry.userFiles?.length ?? 0),
+		userImages: entry.userImages,
+		userFiles: entry.userFiles,
+	};
+}
+
+function snapshotPrompts(
+	state: PendingPromptQueueState,
+): SessionPendingPrompt[] {
+	return state.pendingPrompts.map(snapshotPrompt);
+}
+
+function insertUpdatedPrompt(
+	state: PendingPromptQueueState,
+	next: PendingPromptEntry,
+	previousIndex: number,
+	previousDelivery: PendingPromptDelivery,
+): void {
+	if (next.delivery === "steer") {
+		state.pendingPrompts.unshift(next);
+	} else if (previousDelivery === "steer") {
+		state.pendingPrompts.push(next);
+	} else {
+		state.pendingPrompts.splice(previousIndex, 0, next);
+	}
+}
diff --git a/sdk/packages/core/src/services/agent-events.ts b/sdk/packages/core/src/services/agent-events.ts
new file mode 100644
index 0000000..eed158c
--- /dev/null
+++ b/sdk/packages/core/src/services/agent-events.ts
@@ -0,0 +1,321 @@
+import type { AgentEvent } from "@cline/shared";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession } from "../types/session";
+import { serializeAgentEvent } from "./session-data";
+import {
+	captureConversationTurnEvent,
+	captureDiffEditFailure,
+	captureProviderApiError,
+	captureSkillUsed,
+	captureTokenUsage,
+	captureToolUsage,
+	type TelemetryAgentIdentityProperties,
+} from "./telemetry/core-events";
+import {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+	sumUsageTotals,
+} from "./usage";
+
+export function extractSkillNameFromToolInput(
+	input: unknown,
+): string | undefined {
+	if (!input || typeof input !== "object") return undefined;
+	const record = input as Record<string, unknown>;
+	const skillName = record.skill ?? record.skill_name ?? record.skillName;
+	if (typeof skillName !== "string") return undefined;
+	const trimmed = skillName.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export interface AgentEventContext {
+	sessionId: string;
+	config: CoreSessionConfig;
+	liveSession: ActiveSession | undefined;
+	usageBySession: Map<string, SessionAccumulatedUsage>;
+	aggregateUsageBySession: Map<string, SessionAccumulatedUsage>;
+	persistMessages: (
+		sessionId: string,
+		messages: unknown[],
+		systemPrompt?: string,
+	) => void;
+	emit: (event: CoreSessionEvent) => void;
+}
+
+export interface AgentTelemetryContextOverrides {
+	agentId?: string;
+	conversationId?: string;
+	parentAgentId?: string | null;
+	createdByAgentId?: string;
+	teamId?: string;
+	teamName?: string;
+	teamRole?: "lead" | "teammate";
+	teamAgentId?: string;
+	isPrimaryAgentEvent?: boolean;
+}
+
+export function extractAgentEventMetadata(event: AgentEvent): {
+	agentId?: string;
+	conversationId?: string;
+	parentAgentId?: string;
+} {
+	if (!event || typeof event !== "object") {
+		return {};
+	}
+	const record = event as unknown as Record<string, unknown>;
+	return {
+		agentId: typeof record.agentId === "string" ? record.agentId : undefined,
+		conversationId:
+			typeof record.conversationId === "string"
+				? record.conversationId
+				: undefined,
+		parentAgentId:
+			typeof record.parentAgentId === "string"
+				? record.parentAgentId
+				: undefined,
+	};
+}
+
+export function buildTelemetryAgentIdentity(
+	context: AgentTelemetryContextOverrides,
+): TelemetryAgentIdentityProperties | undefined {
+	const agentId = context.agentId?.trim();
+	if (!agentId) {
+		return undefined;
+	}
+	const parentAgentId = context.parentAgentId?.trim() || undefined;
+	const teamRole = context.teamRole;
+	let agentKind: TelemetryAgentIdentityProperties["agentKind"] = "root";
+	if (teamRole === "teammate") {
+		agentKind = "team_teammate";
+	} else if (teamRole === "lead") {
+		agentKind = "team_lead";
+	} else if (parentAgentId) {
+		agentKind = "subagent";
+	}
+	return {
+		agentId,
+		agentKind,
+		conversationId: context.conversationId?.trim() || undefined,
+		parentAgentId,
+		createdByAgentId:
+			context.createdByAgentId?.trim() || parentAgentId || undefined,
+		isSubagent: Boolean(parentAgentId),
+		teamId: context.teamId?.trim() || undefined,
+		teamName: context.teamName?.trim() || undefined,
+		teamRole,
+		teamAgentId: context.teamAgentId?.trim() || undefined,
+	};
+}
+
+function usageDeltaFromEvent(event: Extract<AgentEvent, { type: "usage" }>) {
+	return {
+		inputTokens: event.inputTokens,
+		outputTokens: event.outputTokens,
+		cacheWriteTokens: event.cacheWriteTokens,
+		cacheReadTokens: event.cacheReadTokens,
+		totalCost: event.cost,
+	};
+}
+
+function resolveUsageAgentKey(input: {
+	isPrimaryAgentEvent: boolean;
+	overrides?: AgentTelemetryContextOverrides;
+	eventMetadata: ReturnType<typeof extractAgentEventMetadata>;
+}): string {
+	const candidates = input.isPrimaryAgentEvent
+		? [
+				input.overrides?.agentId,
+				input.eventMetadata.agentId,
+				input.overrides?.teamAgentId,
+			]
+		: [
+				input.overrides?.teamAgentId,
+				input.overrides?.agentId,
+				input.eventMetadata.agentId,
+				input.eventMetadata.conversationId,
+			];
+	for (const candidate of candidates) {
+		const value = candidate?.trim();
+		if (value) return value;
+	}
+	return input.isPrimaryAgentEvent ? "root" : "unknown";
+}
+
+export function handleAgentEvent(
+	ctx: AgentEventContext,
+	event: AgentEvent,
+	overrides?: AgentTelemetryContextOverrides,
+): void {
+	const { sessionId, config, liveSession, emit } = ctx;
+	const telemetry = config.telemetry;
+	const teamRuntime = liveSession?.runtime.teamRuntime;
+	const isPrimaryAgentEvent = overrides?.isPrimaryAgentEvent ?? true;
+	const eventMetadata = extractAgentEventMetadata(event);
+	const agentIdentity = buildTelemetryAgentIdentity({
+		agentId: overrides?.agentId ?? eventMetadata.agentId,
+		conversationId: overrides?.conversationId ?? eventMetadata.conversationId,
+		parentAgentId: overrides?.parentAgentId ?? eventMetadata.parentAgentId,
+		createdByAgentId: overrides?.createdByAgentId,
+		teamId: overrides?.teamId ?? teamRuntime?.getTeamId(),
+		teamName: overrides?.teamName ?? teamRuntime?.getTeamName(),
+		teamRole: overrides?.teamRole,
+		teamAgentId: overrides?.teamAgentId,
+	});
+
+	if (
+		event.type === "content_start" &&
+		event.contentType === "tool" &&
+		event.toolName === "skills"
+	) {
+		const skillName = extractSkillNameFromToolInput(event.input);
+		if (skillName) {
+			captureSkillUsed(telemetry, {
+				ulid: sessionId,
+				skillName,
+				skillSource: "project",
+				skillsAvailableGlobal: 0,
+				skillsAvailableProject: 0,
+				provider: config.providerId,
+				modelId: config.modelId,
+				...agentIdentity,
+			});
+		}
+	}
+
+	if (event.type === "content_end" && event.contentType === "tool") {
+		const toolName = event.toolName ?? "unknown";
+		const success = !event.error;
+		captureToolUsage(telemetry, {
+			ulid: sessionId,
+			tool: toolName,
+			autoApproved: undefined,
+			success,
+			modelId: config.modelId,
+			provider: config.providerId,
+			...agentIdentity,
+		});
+		if (!success && (toolName === "editor" || toolName === "apply_patch")) {
+			captureDiffEditFailure(telemetry, {
+				ulid: sessionId,
+				modelId: config.modelId,
+				provider: config.providerId,
+				errorType: event.error,
+				...agentIdentity,
+			});
+		}
+	}
+
+	if (event.type === "notice" && event.reason === "api_error") {
+		captureProviderApiError(telemetry, {
+			ulid: sessionId,
+			model: config.modelId,
+			provider: config.providerId,
+			errorMessage: event.message,
+			...agentIdentity,
+		});
+	}
+
+	if (event.type === "error") {
+		captureProviderApiError(telemetry, {
+			ulid: sessionId,
+			model: config.modelId,
+			provider: config.providerId,
+			errorMessage: event.error?.message ?? "unknown error",
+			...agentIdentity,
+		});
+	}
+
+	if (event.type === "usage" && liveSession?.turnUsageBaseline) {
+		const usageDelta = usageDeltaFromEvent(event);
+		if (isPrimaryAgentEvent) {
+			liveSession.turnPrimaryUsage = accumulateUsageTotals(
+				liveSession.turnPrimaryUsage ?? createInitialAccumulatedUsage(),
+				usageDelta,
+			);
+			const mainUsage = accumulateUsageTotals(
+				liveSession.turnUsageBaseline,
+				liveSession.turnPrimaryUsage,
+			);
+			ctx.usageBySession.set(sessionId, mainUsage);
+			captureConversationTurnEvent(telemetry, {
+				ulid: sessionId,
+				provider: config.providerId,
+				model: config.modelId,
+				source: "assistant",
+				mode: config.mode,
+				...agentIdentity,
+			});
+			captureTokenUsage(telemetry, {
+				ulid: sessionId,
+				tokensIn: event.inputTokens,
+				tokensOut: event.outputTokens,
+				cacheWriteTokens: event.cacheWriteTokens,
+				cacheReadTokens: event.cacheReadTokens,
+				totalCost: event.cost,
+				model: config.modelId,
+				...agentIdentity,
+			});
+		} else {
+			const agentKey = resolveUsageAgentKey({
+				isPrimaryAgentEvent,
+				overrides,
+				eventMetadata,
+			});
+			const turnUsageByAgent =
+				liveSession.turnUsageByAgent ??
+				new Map<string, SessionAccumulatedUsage>();
+			liveSession.turnUsageByAgent = turnUsageByAgent;
+			turnUsageByAgent.set(
+				agentKey,
+				accumulateUsageTotals(
+					turnUsageByAgent.get(agentKey) ?? createInitialAccumulatedUsage(),
+					usageDelta,
+				),
+			);
+		}
+		const aggregateTurnUsage = accumulateUsageTotals(
+			liveSession.turnPrimaryUsage ?? createInitialAccumulatedUsage(),
+			sumUsageTotals(liveSession.turnUsageByAgent?.values() ?? []),
+		);
+		ctx.aggregateUsageBySession.set(
+			sessionId,
+			accumulateUsageTotals(
+				liveSession.turnAggregateUsageBaseline ?? liveSession.turnUsageBaseline,
+				aggregateTurnUsage,
+			),
+		);
+	}
+
+	if (event.type === "iteration_end" && isPrimaryAgentEvent) {
+		ctx.persistMessages(
+			sessionId,
+			liveSession?.agent.getMessages() ?? [],
+			liveSession?.config.systemPrompt,
+		);
+	}
+
+	emit({
+		type: "agent_event",
+		payload: {
+			sessionId,
+			event,
+			teamAgentId: overrides?.teamAgentId,
+			teamRole:
+				overrides !== undefined
+					? (overrides.teamRole ?? (isPrimaryAgentEvent ? "lead" : undefined))
+					: undefined,
+		},
+	});
+	emit({
+		type: "chunk",
+		payload: {
+			sessionId,
+			stream: "agent",
+			chunk: serializeAgentEvent(event),
+			ts: Date.now(),
+		},
+	});
+}
diff --git a/sdk/packages/core/src/services/config.ts b/sdk/packages/core/src/services/config.ts
new file mode 100644
index 0000000..4676cbb
--- /dev/null
+++ b/sdk/packages/core/src/services/config.ts
@@ -0,0 +1,5 @@
+import type { CoreSessionConfig } from "../types/config";
+
+export function resolveWorkspacePath(config: CoreSessionConfig): string {
+	return config.workspaceRoot ?? config.cwd;
+}
diff --git a/sdk/packages/core/src/services/feature-flags/FeatureFlagsService.test.ts b/sdk/packages/core/src/services/feature-flags/FeatureFlagsService.test.ts
new file mode 100644
index 0000000..8aa7fb0
--- /dev/null
+++ b/sdk/packages/core/src/services/feature-flags/FeatureFlagsService.test.ts
@@ -0,0 +1,184 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { FEATURE_FLAGS, type IFeatureFlagsProvider } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { FeatureFlagsService } from "./FeatureFlagsService";
+
+const TEST_BOOLEAN_FLAG = "test_boolean_flag";
+const TEST_PAYLOAD_FLAG = "test_payload_flag";
+
+function createProvider(
+	overrides: Partial<IFeatureFlagsProvider> = {},
+): IFeatureFlagsProvider {
+	return {
+		getAllFlagsAndPayloads: vi.fn(async () => ({
+			featureFlags: {
+				[TEST_BOOLEAN_FLAG]: true,
+			},
+			featureFlagPayloads: {
+				[TEST_PAYLOAD_FLAG]: 1234,
+			},
+		})),
+		enabled: true,
+		getSettings: vi.fn(() => ({ enabled: true, timeoutMs: 1000 })),
+		dispose: vi.fn(async () => {}),
+		...overrides,
+	};
+}
+
+describe("FeatureFlagsService", () => {
+	beforeEach(() => {
+		vi.useRealTimers();
+	});
+
+	it("polls provider values into the cache", async () => {
+		const provider = createProvider();
+		const telemetry = { capture: vi.fn() };
+		const service = new FeatureFlagsService({
+			provider,
+			telemetry: telemetry as never,
+			context: { distinctId: "machine-1", clientName: "unit-test" },
+		});
+
+		await service.poll("user-1");
+
+		expect(provider.getAllFlagsAndPayloads).toHaveBeenCalledWith({
+			flagKeys: FEATURE_FLAGS.length > 0 ? FEATURE_FLAGS : undefined,
+			context: {
+				distinctId: "machine-1",
+				clientName: "unit-test",
+				userId: "user-1",
+			},
+		});
+		expect(service.getBooleanFlagEnabled(TEST_BOOLEAN_FLAG)).toBe(true);
+		expect(service.getFlagPayload(TEST_PAYLOAD_FLAG)).toBe(1234);
+		expect(telemetry.capture).toHaveBeenCalledWith({
+			event: "$feature_flag_called",
+			properties: {
+				$feature_flag: TEST_BOOLEAN_FLAG,
+				$feature_flag_response: true,
+			},
+		});
+	});
+
+	it("skips polling while the cache is fresh and user context is unchanged", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-06-10T10:00:00Z"));
+		const provider = createProvider();
+		const service = new FeatureFlagsService({ provider });
+
+		await service.poll("user-1");
+		expect(provider.getAllFlagsAndPayloads).toHaveBeenCalledTimes(1);
+
+		await service.poll("user-1");
+
+		expect(provider.getAllFlagsAndPayloads).toHaveBeenCalledTimes(1);
+	});
+
+	it("polls only once if two calls are made simultaneously with the same user context", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-06-10T10:00:00Z"));
+
+		const provider = createProvider();
+		const service = new FeatureFlagsService({ provider });
+
+		await Promise.all([service.poll("user-1"), service.poll("user-1")]);
+
+		expect(provider.getAllFlagsAndPayloads).toHaveBeenCalledTimes(1);
+	});
+
+	it("re-polls when the user context changes within the cache ttl", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-06-10T10:00:00Z"));
+		const provider = createProvider();
+		const service = new FeatureFlagsService({ provider });
+
+		await service.poll("user-1");
+		await service.poll("user-2");
+
+		expect(provider.getAllFlagsAndPayloads).toHaveBeenCalledTimes(2);
+	});
+
+	it("returns false or undefined before polling", () => {
+		const service = new FeatureFlagsService({ provider: createProvider() });
+
+		expect(service.getBooleanFlagEnabled(TEST_BOOLEAN_FLAG)).toBe(false);
+		expect(service.getFlagPayload(TEST_PAYLOAD_FLAG)).toBeUndefined();
+	});
+
+	it("hydrates from a persistent cache file before polling", () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-06-10T10:00:00Z"));
+		const cacheFilePath = join(
+			mkdtempSync(join(tmpdir(), "cline-feature-flags-")),
+			"feature-flags.json",
+		);
+		writeFileSync(
+			cacheFilePath,
+			`${JSON.stringify({
+				version: 1,
+				updatedAt: Date.now(),
+				userId: "user-1",
+				flagsPayload: {
+					featureFlags: { [TEST_BOOLEAN_FLAG]: true },
+					featureFlagPayloads: { [TEST_PAYLOAD_FLAG]: 1234 },
+				},
+			})}\n`,
+			"utf8",
+		);
+
+		const service = new FeatureFlagsService({
+			provider: createProvider(),
+			cacheFilePath,
+			context: { userId: "user-1" },
+		});
+
+		expect(service.getBooleanFlagEnabled(TEST_BOOLEAN_FLAG)).toBe(true);
+		expect(service.getFlagPayload(TEST_PAYLOAD_FLAG)).toBe(1234);
+	});
+
+	it("writes a persistent cache file after polling", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-06-10T10:00:00Z"));
+		const cacheFilePath = join(
+			mkdtempSync(join(tmpdir(), "cline-feature-flags-")),
+			"nested",
+			"feature-flags.json",
+		);
+		const service = new FeatureFlagsService({
+			provider: createProvider(),
+			cacheFilePath,
+		});
+
+		await service.poll("user-1");
+
+		const cache = JSON.parse(readFileSync(cacheFilePath, "utf8")) as {
+			version: number;
+			updatedAt: number;
+			userId: string | null;
+			flagsPayload?: {
+				featureFlags?: Record<string, unknown>;
+				featureFlagPayloads?: Record<string, unknown>;
+			};
+		};
+		expect(cache).toMatchObject({
+			version: 1,
+			updatedAt: Date.now(),
+			userId: "user-1",
+			flagsPayload: {
+				featureFlags: { [TEST_BOOLEAN_FLAG]: true },
+				featureFlagPayloads: { [TEST_PAYLOAD_FLAG]: 1234 },
+			},
+		});
+	});
+
+	it("disposes the provider", async () => {
+		const provider = createProvider();
+		const service = new FeatureFlagsService({ provider });
+
+		await service.dispose();
+
+		expect(provider.dispose).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/sdk/packages/core/src/services/feature-flags/FeatureFlagsService.ts b/sdk/packages/core/src/services/feature-flags/FeatureFlagsService.ts
new file mode 100644
index 0000000..0856f5e
--- /dev/null
+++ b/sdk/packages/core/src/services/feature-flags/FeatureFlagsService.ts
@@ -0,0 +1,332 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type {
+	BasicLogger,
+	FeatureFlagPayload,
+	FeatureFlagsAndPayloads,
+	FeatureFlagsContext,
+	IFeatureFlagsProvider,
+	ITelemetryService,
+} from "@cline/shared";
+import {
+	FEATURE_FLAGS,
+	type FeatureFlag,
+	FeatureFlagDefaultValue,
+} from "@cline/shared";
+import { CORE_TELEMETRY_EVENTS } from "../..";
+
+const DEFAULT_CACHE_TTL_MS = 60 * 60 * 1000;
+const DEFAULT_PERSISTENT_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const FEATURE_FLAGS_CACHE_FILE_VERSION = 1;
+
+type CacheInfo = {
+	updateTime: number;
+	userId: string | null;
+	flagsPayload?: FeatureFlagsAndPayloads;
+};
+
+export type FeatureFlagsCacheSnapshot = CacheInfo;
+
+interface FeatureFlagsCacheFile {
+	version: typeof FEATURE_FLAGS_CACHE_FILE_VERSION;
+	updatedAt: number;
+	userId: string | null;
+	flagsPayload?: FeatureFlagsAndPayloads;
+}
+
+export interface FeatureFlagsServiceOptions {
+	provider: IFeatureFlagsProvider;
+	telemetry?: ITelemetryService;
+	logger?: BasicLogger;
+	cacheTtlMs?: number;
+	cacheFilePath?: string;
+	persistentCacheMaxAgeMs?: number;
+	context?: FeatureFlagsContext;
+}
+
+export class FeatureFlagsService {
+	private readonly provider: IFeatureFlagsProvider;
+	private readonly telemetry?: ITelemetryService;
+	private readonly logger?: BasicLogger;
+	private readonly cacheTtlMs: number;
+	private readonly cacheFilePath?: string;
+	private readonly persistentCacheMaxAgeMs: number;
+	private context: FeatureFlagsContext;
+	private cache: Map<FeatureFlag, FeatureFlagPayload | undefined> = new Map();
+	private cacheInfo: CacheInfo = { updateTime: 0, userId: null };
+
+	constructor(options: FeatureFlagsServiceOptions) {
+		this.provider = options.provider;
+		this.telemetry = options.telemetry;
+		this.logger = options.logger;
+		this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+		this.cacheFilePath = options.cacheFilePath;
+		this.persistentCacheMaxAgeMs =
+			options.persistentCacheMaxAgeMs ?? DEFAULT_PERSISTENT_CACHE_MAX_AGE_MS;
+		this.context = { ...(options.context ?? {}) };
+		this.hydrateFromPersistentCache();
+	}
+
+	setContext(context: FeatureFlagsContext): void {
+		this.context = { ...context };
+	}
+
+	hydrateCache(snapshot: FeatureFlagsCacheSnapshot): void {
+		this.cacheInfo = {
+			updateTime: snapshot.updateTime,
+			userId: snapshot.userId,
+			flagsPayload: snapshot.flagsPayload,
+		};
+		this.rebuildCacheFromSnapshot(snapshot.flagsPayload);
+	}
+
+	getCacheSnapshot(): FeatureFlagsCacheSnapshot {
+		return {
+			updateTime: this.cacheInfo.updateTime,
+			userId: this.cacheInfo.userId,
+			flagsPayload: this.cacheInfo.flagsPayload,
+		};
+	}
+
+	async poll(userId?: string | null): Promise<void> {
+		const resolvedUserId = userId ?? this.context.userId ?? null;
+		const timeNow = Date.now();
+		if (timeNow - this.cacheInfo.updateTime < this.cacheTtlMs) {
+			if (this.cacheInfo.userId === resolvedUserId) {
+				return;
+			}
+		}
+
+		const previousCacheInfo = this.cacheInfo;
+		this.cacheInfo = { updateTime: timeNow, userId: resolvedUserId || null };
+
+		try {
+			const values = await this.provider.getAllFlagsAndPayloads({
+				flagKeys: FEATURE_FLAGS.length > 0 ? FEATURE_FLAGS : undefined,
+				context: { ...this.context, userId: resolvedUserId },
+			});
+
+			if (this.cacheInfo.userId !== resolvedUserId) {
+				// A new poll has started with a different userId, so we should not update the cache with the results of this poll
+				return;
+			}
+
+			this.cacheInfo.flagsPayload = values;
+			this.rebuildCacheFromSnapshot(values);
+			this.writePersistentCache();
+		} catch (error) {
+			if (this.cacheInfo.userId !== resolvedUserId) {
+				// A new poll has started with a different userId, so we should not update the cache with the results of this poll
+				return;
+			}
+
+			this.cacheInfo = previousCacheInfo.updateTime
+				? previousCacheInfo
+				: { updateTime: 0, userId: null };
+			this.logger?.error?.("Error polling SDK feature flags", { error });
+			throw error;
+		}
+	}
+
+	private hydrateFromPersistentCache(): void {
+		const snapshot = this.readPersistentCache();
+		if (snapshot) {
+			this.hydrateCache(snapshot);
+		}
+	}
+
+	private isFeatureFlagPayload(value: unknown): value is FeatureFlagPayload {
+		if (
+			value === null ||
+			typeof value === "string" ||
+			typeof value === "number" ||
+			typeof value === "boolean"
+		) {
+			return true;
+		}
+		if (Array.isArray(value)) {
+			return value.every((entry) => this.isFeatureFlagPayload(entry));
+		}
+		if (typeof value === "object") {
+			return Object.values(value as Record<string, unknown>).every((entry) =>
+				this.isFeatureFlagPayload(entry),
+			);
+		}
+		return false;
+	}
+
+	private readPayloadRecord(
+		value: unknown,
+	): Record<string, FeatureFlagPayload> | undefined {
+		if (!value || typeof value !== "object" || Array.isArray(value)) {
+			return undefined;
+		}
+
+		const entries = Object.entries(value as Record<string, unknown>).filter(
+			([, entryValue]) => this.isFeatureFlagPayload(entryValue),
+		);
+		if (entries.length === 0) {
+			return undefined;
+		}
+
+		const record: Record<string, FeatureFlagPayload> = {};
+		for (const [key, entryValue] of entries) {
+			record[key] = entryValue as FeatureFlagPayload;
+		}
+		return record;
+	}
+
+	private readPersistentCache(): FeatureFlagsCacheSnapshot | undefined {
+		try {
+			if (!this.cacheFilePath || !existsSync(this.cacheFilePath)) {
+				return undefined;
+			}
+
+			const parsed = JSON.parse(
+				readFileSync(this.cacheFilePath, "utf8"),
+			) as unknown;
+			if (!parsed || typeof parsed !== "object") {
+				return undefined;
+			}
+
+			const cache = parsed as Partial<FeatureFlagsCacheFile> & {
+				flagsPayload?: {
+					featureFlags?: unknown;
+					featureFlagPayloads?: unknown;
+				};
+			};
+
+			// We don't validate the userId here because we want to allow falling back to an existing cache even
+			// if the userId hasn't been resolved yet
+			if (
+				cache.version !== FEATURE_FLAGS_CACHE_FILE_VERSION ||
+				typeof cache.updatedAt !== "number" ||
+				!Number.isFinite(cache.updatedAt) ||
+				Date.now() - cache.updatedAt > this.persistentCacheMaxAgeMs
+			) {
+				return undefined;
+			}
+
+			return {
+				updateTime: cache.updatedAt,
+				userId: cache.userId ?? null,
+				flagsPayload: {
+					featureFlags: this.readPayloadRecord(
+						cache.flagsPayload?.featureFlags,
+					),
+					featureFlagPayloads: this.readPayloadRecord(
+						cache.flagsPayload?.featureFlagPayloads,
+					),
+				},
+			};
+		} catch (error) {
+			this.logger?.error?.("Error reading SDK feature flags cache", { error });
+			return undefined;
+		}
+	}
+
+	private writePersistentCache(): void {
+		try {
+			if (!this.cacheFilePath) {
+				return;
+			}
+
+			mkdirSync(dirname(this.cacheFilePath), { recursive: true, mode: 0o700 });
+			const snapshot = this.getCacheSnapshot();
+			const cache: FeatureFlagsCacheFile = {
+				version: FEATURE_FLAGS_CACHE_FILE_VERSION,
+				updatedAt: snapshot.updateTime,
+				userId: snapshot.userId,
+				flagsPayload: snapshot.flagsPayload,
+			};
+			writeFileSync(
+				this.cacheFilePath,
+				`${JSON.stringify(cache, null, 2)}\n`,
+				"utf8",
+			);
+		} catch (error) {
+			this.logger?.error?.("Error writing SDK feature flags cache", { error });
+		}
+	}
+
+	private getReturnedFlagKeys(
+		values: FeatureFlagsAndPayloads | undefined,
+	): FeatureFlag[] {
+		return [
+			...new Set([
+				...Object.keys(values?.featureFlags ?? {}),
+				...Object.keys(values?.featureFlagPayloads ?? {}),
+			]),
+		];
+	}
+
+	private rebuildCacheFromSnapshot(
+		values: FeatureFlagsAndPayloads | undefined,
+	): void {
+		const nextCache = new Map<FeatureFlag, FeatureFlagPayload | undefined>();
+		for (const flag of this.getReturnedFlagKeys(values)) {
+			const payload = this.getFeatureFlag(flag);
+			nextCache.set(flag, payload ?? false);
+		}
+		this.cache = nextCache;
+	}
+
+	private getFeatureFlag(
+		flagName: FeatureFlag,
+	): FeatureFlagPayload | undefined {
+		try {
+			const payload =
+				this.cacheInfo.flagsPayload?.featureFlagPayloads?.[flagName];
+			const flagValue = this.cacheInfo.flagsPayload?.featureFlags?.[flagName];
+			const value =
+				payload ?? flagValue ?? FeatureFlagDefaultValue[flagName] ?? undefined;
+
+			if (!this.cache.has(flagName) || this.cache.get(flagName) !== value) {
+				this.telemetry?.capture({
+					event: CORE_TELEMETRY_EVENTS.FEATURE_FLAGS.FLAG_CALLED,
+					properties: {
+						$feature_flag: flagName,
+						$feature_flag_response: flagValue,
+					},
+				});
+			}
+
+			return value;
+		} catch (error) {
+			this.logger?.error?.(`Error checking SDK feature flag ${flagName}`, {
+				error,
+			});
+			return FeatureFlagDefaultValue[flagName] ?? false;
+		}
+	}
+
+	getBooleanFlagEnabled(flagName: FeatureFlag): boolean {
+		return this.cache.get(flagName) === true;
+	}
+
+	getFlagPayload(flagName: FeatureFlag): FeatureFlagPayload | undefined {
+		return this.cache.get(flagName) ?? FeatureFlagDefaultValue[flagName];
+	}
+
+	getProvider(): IFeatureFlagsProvider {
+		return this.provider;
+	}
+
+	get enabled(): boolean {
+		return this.provider.enabled;
+	}
+
+	getSettings() {
+		return this.provider.getSettings();
+	}
+
+	test(flagName: FeatureFlag, value: boolean): void {
+		if (process.env.NODE_ENV === "test" || process.env.IS_TEST === "true") {
+			this.cache.set(flagName, value);
+		}
+	}
+
+	async dispose(): Promise<void> {
+		await this.provider.dispose();
+	}
+}
diff --git a/sdk/packages/core/src/services/feature-flags/index.ts b/sdk/packages/core/src/services/feature-flags/index.ts
new file mode 100644
index 0000000..a3f5852
--- /dev/null
+++ b/sdk/packages/core/src/services/feature-flags/index.ts
@@ -0,0 +1,5 @@
+export {
+	FeatureFlagsService,
+	type FeatureFlagsServiceOptions,
+} from "./FeatureFlagsService";
+export { NoOpFeatureFlagsProvider } from "./providers";
diff --git a/sdk/packages/core/src/services/feature-flags/posthog.ts b/sdk/packages/core/src/services/feature-flags/posthog.ts
new file mode 100644
index 0000000..d062112
--- /dev/null
+++ b/sdk/packages/core/src/services/feature-flags/posthog.ts
@@ -0,0 +1,95 @@
+import type {
+	BasicLogger,
+	FeatureFlagsAndPayloads,
+	FeatureFlagsContext,
+	FeatureFlagsSettings,
+	IFeatureFlagsProvider,
+} from "@cline/shared";
+import { PostHog, type PostHogOptions } from "posthog-node";
+
+export interface PostHogFeatureFlagsProviderConfig {
+	logger?: BasicLogger;
+}
+
+export interface PostHogFeatureFlagsProviderOptions {
+	config: PostHogFeatureFlagsProviderConfig;
+	client: PostHog;
+}
+
+export function buildClinePostHogClient(
+	apiKey: string,
+	options?: PostHogOptions | undefined,
+): PostHog {
+	return new PostHog(apiKey, {
+		host: "https://data.cline.bot",
+		...options,
+	});
+}
+
+export class PostHogFeatureFlagsProvider implements IFeatureFlagsProvider {
+	private readonly client: PostHog;
+	private readonly settings: FeatureFlagsSettings;
+	private readonly logger?: BasicLogger;
+
+	constructor(options: PostHogFeatureFlagsProviderOptions) {
+		if (!options.client) {
+			throw new Error("PostHog client is required for feature flags");
+		}
+
+		this.logger = options.config.logger;
+		this.settings = {
+			enabled: true,
+		};
+
+		this.client = options.client;
+	}
+
+	async getAllFlagsAndPayloads(options: {
+		flagKeys?: readonly string[];
+		context: FeatureFlagsContext;
+	}): Promise<FeatureFlagsAndPayloads | undefined> {
+		if (!this.enabled) {
+			return undefined;
+		}
+
+		const distinctId = this.resolveDistinctId(options.context);
+		if (!distinctId) {
+			this.logger?.log?.(
+				"PostHog feature flags requested without a distinct ID",
+			);
+			return {};
+		}
+
+		try {
+			const result = await this.client.getAllFlagsAndPayloads(distinctId, {
+				flagKeys: options.flagKeys ? [...options.flagKeys] : undefined,
+			});
+			return result as FeatureFlagsAndPayloads;
+		} catch (error) {
+			this.logger?.error?.("Error getting PostHog feature flags", { error });
+			return {};
+		}
+	}
+
+	get enabled(): boolean {
+		return this.settings.enabled;
+	}
+
+	getSettings(): FeatureFlagsSettings {
+		return { ...this.settings };
+	}
+
+	async dispose(): Promise<void> {
+		try {
+			await this.client.shutdown();
+		} catch (error) {
+			this.logger?.error?.("Error shutting down PostHog feature flags client", {
+				error,
+			});
+		}
+	}
+
+	private resolveDistinctId(context?: FeatureFlagsContext): string | undefined {
+		return context?.distinctId?.trim() || context?.userId?.trim() || undefined;
+	}
+}
diff --git a/sdk/packages/core/src/services/feature-flags/providers.ts b/sdk/packages/core/src/services/feature-flags/providers.ts
new file mode 100644
index 0000000..35398d0
--- /dev/null
+++ b/sdk/packages/core/src/services/feature-flags/providers.ts
@@ -0,0 +1,19 @@
+import type {
+	FeatureFlagsAndPayloads,
+	FeatureFlagsSettings,
+	IFeatureFlagsProvider,
+} from "@cline/shared";
+
+export class NoOpFeatureFlagsProvider implements IFeatureFlagsProvider {
+	async getAllFlagsAndPayloads(): Promise<FeatureFlagsAndPayloads> {
+		return {};
+	}
+
+	enabled = false;
+
+	getSettings(): FeatureFlagsSettings {
+		return { enabled: false, timeoutMs: 1000 };
+	}
+
+	async dispose(): Promise<void> {}
+}
diff --git a/sdk/packages/core/src/services/global-settings.test.ts b/sdk/packages/core/src/services/global-settings.test.ts
new file mode 100644
index 0000000..d48749e
--- /dev/null
+++ b/sdk/packages/core/src/services/global-settings.test.ts
@@ -0,0 +1,370 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ITelemetryService } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	GlobalSettingsSchema,
+	readCompactionStrategyGlobally,
+	readGlobalSettings,
+	setAutoUpdateEnabledGlobally,
+	setCompactionStrategyGlobally,
+	setDisabledPlugin,
+	setDisabledTools,
+	setTelemetryOptOutGlobally,
+	writeGlobalSettings,
+} from "./global-settings";
+
+describe("global-settings", () => {
+	const previousGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+
+	afterEach(() => {
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = previousGlobalSettingsPath;
+	});
+
+	it("defines the global settings file schema", () => {
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: [" read_files ", "read_files", "editor"],
+				disabledPlugins: ["/plugins/example.js", "/plugins/example.js"],
+			}),
+		).toEqual({
+			autoUpdateEnabled: true,
+			disabledPlugins: ["/plugins/example.js"],
+			disabledTools: ["editor", "read_files"],
+			telemetryOptOut: false,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: [],
+				telemetryOptOut: true,
+			}),
+		).toEqual({ autoUpdateEnabled: true, telemetryOptOut: true });
+		expect(GlobalSettingsSchema.parse({ disabledTools: [] })).toEqual({
+			autoUpdateEnabled: true,
+			telemetryOptOut: false,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				compactionStrategy: "agentic",
+				disabledTools: ["read_files"],
+				extra: true,
+			}),
+		).toEqual({
+			autoUpdateEnabled: true,
+			compactionStrategy: "agentic",
+			disabledTools: ["read_files"],
+			telemetryOptOut: false,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: 42,
+				extra: true,
+				telemetryOptOut: true,
+			}),
+		).toEqual({
+			autoUpdateEnabled: true,
+			telemetryOptOut: true,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				autoUpdateEnabled: false,
+			}),
+		).toEqual({
+			autoUpdateEnabled: false,
+			telemetryOptOut: false,
+		});
+	});
+
+	it("uses the schema when reading and writing settings", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			writeGlobalSettings({
+				disabledTools: [" editor ", "read_files", "editor"],
+				disabledPlugins: [],
+			});
+
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				disabledTools: ["editor", "read_files"],
+				telemetryOptOut: false,
+			});
+			expect(JSON.parse(await readFile(settingsPath, "utf8"))).toEqual({
+				autoUpdateEnabled: true,
+				disabledTools: ["editor", "read_files"],
+				telemetryOptOut: false,
+			});
+
+			await writeFile(
+				settingsPath,
+				JSON.stringify({
+					disabledTools: ["read_files"],
+					extra: true,
+					telemetryOptOut: true,
+				}),
+			);
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				disabledTools: ["read_files"],
+				telemetryOptOut: true,
+			});
+
+			await writeFile(
+				settingsPath,
+				JSON.stringify({
+					disabledTools: 42,
+					extra: true,
+					telemetryOptOut: true,
+				}),
+			);
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				telemetryOptOut: true,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves disabled tools and plugins across targeted updates", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			setDisabledPlugin("/plugins/example.js", true);
+			setDisabledTools(["read_files", "editor"], true);
+			setDisabledTools(["editor"], false);
+
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				disabledPlugins: ["/plugins/example.js"],
+				disabledTools: ["read_files"],
+				telemetryOptOut: false,
+			});
+			expect(JSON.parse(await readFile(settingsPath, "utf8"))).toEqual({
+				autoUpdateEnabled: true,
+				disabledPlugins: ["/plugins/example.js"],
+				disabledTools: ["read_files"],
+				telemetryOptOut: false,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("records telemetry opt-out once when the setting changes to true", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+			const captureRequired = vi.fn();
+			const telemetry = {
+				captureRequired,
+			} as unknown as ITelemetryService;
+
+			setTelemetryOptOutGlobally(true, { telemetry });
+			setTelemetryOptOutGlobally(true, { telemetry });
+			setTelemetryOptOutGlobally(false, { telemetry });
+
+			expect(captureRequired).toHaveBeenCalledTimes(1);
+			expect(captureRequired).toHaveBeenCalledWith("user.opt_out", undefined);
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				telemetryOptOut: false,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves other settings when auto update is changed", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			writeGlobalSettings({
+				disabledTools: ["editor"],
+				telemetryOptOut: true,
+			});
+			setAutoUpdateEnabledGlobally(false);
+
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: false,
+				disabledTools: ["editor"],
+				telemetryOptOut: true,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("reads and writes the compaction strategy globally", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			expect(readCompactionStrategyGlobally()).toBe("basic");
+			setCompactionStrategyGlobally("agentic");
+			expect(readCompactionStrategyGlobally()).toBe("agentic");
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	describe("caching", () => {
+		it("invalidates the cache when writeGlobalSettings is called", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+				writeGlobalSettings({ disabledTools: ["editor"] });
+				readGlobalSettings();
+
+				writeGlobalSettings({ disabledTools: ["read_files"] });
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["read_files"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("picks up external writes via mtime change", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+				writeGlobalSettings({ disabledTools: ["editor"] });
+				readGlobalSettings();
+
+				await writeFile(
+					settingsPath,
+					JSON.stringify({ disabledTools: ["read_files"] }),
+				);
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["read_files"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("keys the cache by resolved path so switching files returns the right value", async () => {
+			const rootA = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			const rootB = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const pathA = join(rootA, "global-settings.json");
+				const pathB = join(rootB, "global-settings.json");
+
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = pathA;
+				writeGlobalSettings({ disabledTools: ["editor"] });
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["editor"],
+					telemetryOptOut: false,
+				});
+
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = pathB;
+				writeGlobalSettings({ disabledTools: ["read_files"] });
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["read_files"],
+					telemetryOptOut: false,
+				});
+
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = pathA;
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["editor"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(rootA, { recursive: true, force: true });
+				await rm(rootB, { recursive: true, force: true });
+			}
+		});
+
+		it("returns the default value when the settings file does not exist", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "missing-global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					telemetryOptOut: false,
+				});
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("returns a frozen value so callers cannot mutate the cache", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+				writeGlobalSettings({
+					disabledTools: ["editor"],
+					disabledPlugins: ["/plugins/example.js"],
+				});
+
+				const settings = readGlobalSettings();
+
+				expect(Object.isFrozen(settings)).toBe(true);
+				expect(Object.isFrozen(settings.disabledTools)).toBe(true);
+				expect(Object.isFrozen(settings.disabledPlugins)).toBe(true);
+				expect(() => {
+					(settings as { telemetryOptOut: boolean }).telemetryOptOut = true;
+				}).toThrow();
+				expect(() => {
+					settings.disabledTools?.push("malicious");
+				}).toThrow();
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("transitions from missing-file default to fresh value once the file is created", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					telemetryOptOut: false,
+				});
+
+				await writeFile(
+					settingsPath,
+					JSON.stringify({ disabledTools: ["editor"] }),
+				);
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["editor"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+	});
+});
diff --git a/sdk/packages/core/src/services/global-settings.ts b/sdk/packages/core/src/services/global-settings.ts
new file mode 100644
index 0000000..969f9c7
--- /dev/null
+++ b/sdk/packages/core/src/services/global-settings.ts
@@ -0,0 +1,347 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AgentConfig, AgentTool, ITelemetryService } from "@cline/shared";
+import { resolveGlobalSettingsPath } from "@cline/shared/storage";
+import { z } from "zod";
+import { captureTelemetryOptOut } from "./telemetry/core-events";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+
+const GlobalSettingsStringListSchema = z
+	.preprocess(
+		(value) =>
+			Array.isArray(value)
+				? value
+						.filter((entry): entry is string => typeof entry === "string")
+						.map((entry) => entry.trim())
+						.filter(Boolean)
+				: undefined,
+		z.array(z.string()).optional(),
+	)
+	.transform((entries) => {
+		if (!entries) {
+			return undefined;
+		}
+		const normalized = [...new Set(entries)].sort((left, right) =>
+			left.localeCompare(right),
+		);
+		return normalized.length > 0 ? normalized : undefined;
+	});
+
+const GlobalCompactionStrategySchema = z
+	.enum(["basic", "agentic"])
+	.catch("basic");
+
+export type GlobalCompactionStrategy = z.infer<
+	typeof GlobalCompactionStrategySchema
+>;
+
+export const GlobalSettingsSchema = z
+	.object({
+		telemetryOptOut: z.boolean().default(false).catch(false),
+		autoUpdateEnabled: z.boolean().default(true).catch(true),
+		compactionStrategy: GlobalCompactionStrategySchema.optional(),
+		disabledTools: GlobalSettingsStringListSchema.optional(),
+		disabledPlugins: GlobalSettingsStringListSchema.optional(),
+	})
+	.strip()
+	.transform((settings) => {
+		const normalized: {
+			telemetryOptOut: boolean;
+			autoUpdateEnabled: boolean;
+			compactionStrategy?: GlobalCompactionStrategy;
+			disabledTools?: string[];
+			disabledPlugins?: string[];
+		} = {
+			autoUpdateEnabled: settings.autoUpdateEnabled,
+			telemetryOptOut: settings.telemetryOptOut,
+		};
+		if (settings.compactionStrategy) {
+			normalized.compactionStrategy = settings.compactionStrategy;
+		}
+		if (settings.disabledTools?.length) {
+			normalized.disabledTools = settings.disabledTools;
+		}
+		if (settings.disabledPlugins?.length) {
+			normalized.disabledPlugins = settings.disabledPlugins;
+		}
+		return normalized;
+	});
+
+export type GlobalSettings = z.infer<typeof GlobalSettingsSchema>;
+
+export interface WriteGlobalSettingsOptions {
+	telemetry?: ITelemetryService;
+}
+
+function defaultGlobalSettings(): GlobalSettings {
+	return GlobalSettingsSchema.parse({});
+}
+
+interface CachedSettings {
+	path: string;
+	mtimeMs: number;
+	size: number;
+	value: GlobalSettings;
+}
+
+let settingsCache: CachedSettings | undefined;
+
+function invalidateSettingsCache(): void {
+	settingsCache = undefined;
+}
+
+function freezeSettings(value: GlobalSettings): GlobalSettings {
+	if (value.disabledTools) {
+		Object.freeze(value.disabledTools);
+	}
+	if (value.disabledPlugins) {
+		Object.freeze(value.disabledPlugins);
+	}
+	return Object.freeze(value);
+}
+
+function loadSettingsFromDisk(filePath: string): GlobalSettings {
+	let raw: string;
+	try {
+		raw = readFileSync(filePath, "utf8");
+	} catch {
+		return defaultGlobalSettings();
+	}
+	try {
+		const result = GlobalSettingsSchema.safeParse(JSON.parse(raw));
+		return result.success ? result.data : defaultGlobalSettings();
+	} catch {
+		return defaultGlobalSettings();
+	}
+}
+
+function getCachedSettings(): CachedSettings {
+	const filePath = resolveGlobalSettingsPath();
+	const stats = statSync(filePath, { throwIfNoEntry: false });
+	const mtimeMs = stats?.mtimeMs ?? 0;
+	const size = stats?.size ?? 0;
+
+	const cached = settingsCache;
+	if (
+		cached &&
+		cached.path === filePath &&
+		cached.mtimeMs === mtimeMs &&
+		cached.size === size
+	) {
+		return cached;
+	}
+
+	const value = freezeSettings(
+		stats ? loadSettingsFromDisk(filePath) : defaultGlobalSettings(),
+	);
+	settingsCache = { path: filePath, mtimeMs, size, value };
+	return settingsCache;
+}
+
+export function readGlobalSettings(): GlobalSettings {
+	return getCachedSettings().value;
+}
+
+export function writeGlobalSettings(
+	settings: z.input<typeof GlobalSettingsSchema>,
+	options: WriteGlobalSettingsOptions = {},
+): void {
+	const filePath = resolveGlobalSettingsPath();
+	const previous = readGlobalSettings();
+	mkdirSync(dirname(filePath), { recursive: true });
+	const normalized = GlobalSettingsSchema.parse(settings);
+	if (!previous.telemetryOptOut && normalized.telemetryOptOut) {
+		captureTelemetryOptOut(options.telemetry);
+	}
+	writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+	invalidateSettingsCache();
+}
+
+export function isTelemetryOptedOutGlobally(): boolean {
+	return readGlobalSettings().telemetryOptOut;
+}
+
+export function setTelemetryOptOutGlobally(
+	telemetryOptOut: boolean,
+	options: WriteGlobalSettingsOptions = {},
+): void {
+	writeGlobalSettings(
+		{
+			...readGlobalSettings(),
+			telemetryOptOut,
+		},
+		options,
+	);
+}
+
+export function isAutoUpdateEnabledGlobally(): boolean {
+	return readGlobalSettings().autoUpdateEnabled;
+}
+
+export function setAutoUpdateEnabledGlobally(
+	autoUpdateEnabled: boolean,
+	options: WriteGlobalSettingsOptions = {},
+): void {
+	writeGlobalSettings(
+		{
+			...readGlobalSettings(),
+			autoUpdateEnabled,
+		},
+		options,
+	);
+}
+
+export function readCompactionStrategyGlobally(): GlobalCompactionStrategy {
+	return readGlobalSettings().compactionStrategy ?? "basic";
+}
+
+export function setCompactionStrategyGlobally(
+	compactionStrategy: GlobalCompactionStrategy,
+): void {
+	writeGlobalSettings({ ...readGlobalSettings(), compactionStrategy });
+}
+
+export function resolveDisabledToolNames(
+	disabledToolNames?: ReadonlyArray<string>,
+): Set<string> {
+	return new Set(disabledToolNames ?? readGlobalSettings().disabledTools ?? []);
+}
+
+export function resolveDisabledPluginPaths(
+	disabledPluginPaths?: ReadonlyArray<string>,
+): Set<string> {
+	return new Set(
+		disabledPluginPaths ?? readGlobalSettings().disabledPlugins ?? [],
+	);
+}
+
+export function isToolDisabledGlobally(toolName: string): boolean {
+	return resolveDisabledToolNames().has(toolName);
+}
+
+export function toggleDisabledTool(toolName: string): boolean {
+	const settings = readGlobalSettings();
+	const disabled = new Set(settings.disabledTools ?? []);
+	const wasDisabled = disabled.has(toolName);
+	if (wasDisabled) {
+		disabled.delete(toolName);
+	} else {
+		disabled.add(toolName);
+	}
+	writeGlobalSettings({ ...settings, disabledTools: [...disabled] });
+	return !wasDisabled;
+}
+
+export function setDisabledTools(
+	toolNames: ReadonlyArray<string>,
+	disabledValue: boolean,
+): void {
+	const names = [
+		...new Set(toolNames.map((name) => name.trim()).filter(Boolean)),
+	];
+	if (names.length === 0) {
+		return;
+	}
+
+	const settings = readGlobalSettings();
+	const disabled = resolveDisabledToolNames(settings.disabledTools);
+	for (const name of names) {
+		if (disabledValue) {
+			disabled.add(name);
+		} else {
+			disabled.delete(name);
+		}
+	}
+	writeGlobalSettings({ ...settings, disabledTools: [...disabled] });
+}
+
+export function setToolDisabledGlobally(
+	toolName: string,
+	disabled: boolean,
+): boolean {
+	setDisabledTools([toolName], disabled);
+	return disabled;
+}
+
+export function isPluginDisabledGlobally(pluginPath: string): boolean {
+	return resolveDisabledPluginPaths().has(pluginPath);
+}
+
+export function setDisabledPlugin(
+	pluginPath: string,
+	disabledValue: boolean,
+): void {
+	const path = pluginPath.trim();
+	if (!path) {
+		return;
+	}
+
+	const settings = readGlobalSettings();
+	const disabled = resolveDisabledPluginPaths(settings.disabledPlugins);
+	if (disabledValue) {
+		disabled.add(path);
+	} else {
+		disabled.delete(path);
+	}
+	writeGlobalSettings({ ...settings, disabledPlugins: [...disabled] });
+}
+
+export function filterDisabledPluginPaths(
+	pluginPaths: ReadonlyArray<string>,
+	disabledPluginPaths?: ReadonlyArray<string>,
+): string[] {
+	const disabled = resolveDisabledPluginPaths(disabledPluginPaths);
+	if (disabled.size === 0) {
+		return [...pluginPaths];
+	}
+	return pluginPaths.filter((pluginPath) => !disabled.has(pluginPath));
+}
+
+export function filterDisabledTools<T extends Pick<AgentTool, "name">>(
+	tools: ReadonlyArray<T>,
+	disabledToolNames?: ReadonlyArray<string>,
+): T[] {
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return [...tools];
+	}
+	return tools.filter((tool) => !disabled.has(tool.name));
+}
+
+export function filterExtensionToolRegistrations(
+	extensions: AgentConfig["extensions"],
+	disabledToolNames?: ReadonlyArray<string>,
+): AgentConfig["extensions"] {
+	if (!extensions || extensions.length === 0) {
+		return extensions;
+	}
+
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return extensions;
+	}
+
+	return extensions.map((extension) => {
+		if (!extension.setup) {
+			return extension;
+		}
+
+		return {
+			...extension,
+			setup: (api: AgentExtensionApi, ctx) =>
+				extension.setup?.(
+					{
+						...api,
+						registerTool: (tool) => {
+							if (!disabled.has(tool.name)) {
+								api.registerTool(tool);
+							}
+						},
+					},
+					ctx,
+				),
+		};
+	});
+}
diff --git a/sdk/packages/core/src/services/llms/apihandler-agent-model-adapter.test.ts b/sdk/packages/core/src/services/llms/apihandler-agent-model-adapter.test.ts
new file mode 100644
index 0000000..a00cb7b
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/apihandler-agent-model-adapter.test.ts
@@ -0,0 +1,231 @@
+import type {
+	ApiHandler,
+	ApiStreamChunk,
+	HandlerModelInfo,
+	Message,
+} from "@cline/llms";
+import type { AgentModelEvent, AgentModelRequest } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import { createAgentModelFromApiHandler } from "./apihandler-agent-model-adapter";
+
+function fakeHandler(
+	chunks: ApiStreamChunk[],
+	opts?: { throwAfter?: number },
+): ApiHandler & { aborts: (AbortSignal | undefined)[] } {
+	const aborts: (AbortSignal | undefined)[] = [];
+	return {
+		aborts,
+		getMessages: () => [],
+		getModel: (): HandlerModelInfo => ({ id: "m", info: { id: "m" } }),
+		setAbortSignal(signal) {
+			aborts.push(signal);
+		},
+		// eslint-disable-next-line require-yield
+		async *createMessage(
+			_system: string,
+			_messages: Message[],
+		): AsyncGenerator<ApiStreamChunk> {
+			let i = 0;
+			for (const chunk of chunks) {
+				if (opts?.throwAfter !== undefined && i === opts.throwAfter) {
+					throw new Error("boom");
+				}
+				yield chunk;
+				i++;
+			}
+		},
+	};
+}
+
+async function collect(
+	stream:
+		| AsyncIterable<AgentModelEvent>
+		| Promise<AsyncIterable<AgentModelEvent>>,
+): Promise<AgentModelEvent[]> {
+	const out: AgentModelEvent[] = [];
+	for await (const event of await stream) {
+		out.push(event);
+	}
+	return out;
+}
+
+const baseRequest: AgentModelRequest = {
+	systemPrompt: "sys",
+	messages: [
+		{
+			id: "1",
+			role: "user",
+			content: [{ type: "text", text: "hi" }],
+			createdAt: 0,
+		},
+	],
+	tools: [],
+};
+
+describe("createAgentModelFromApiHandler", () => {
+	it("maps text + usage chunks to events and appends a finish", async () => {
+		const handler = fakeHandler([
+			{ type: "text", text: "hello", id: "x" },
+			{
+				type: "usage",
+				inputTokens: 10,
+				outputTokens: 5,
+				thoughtsTokenCount: 2,
+				totalCost: 0.01,
+				id: "x",
+			},
+		]);
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+
+		expect(events).toEqual([
+			{ type: "text-delta", text: "hello" },
+			{
+				type: "usage",
+				usage: {
+					inputTokens: 10,
+					outputTokens: 5,
+					cacheReadTokens: undefined,
+					cacheWriteTokens: undefined,
+					reasoningTokenCount: 2,
+					totalCost: 0.01,
+				},
+			},
+			{ type: "finish", reason: "stop" },
+		]);
+	});
+
+	it("maps tool_calls (object args) to a tool-call-delta event", async () => {
+		const handler = fakeHandler([
+			{
+				type: "tool_calls",
+				id: "x",
+				tool_call: {
+					call_id: "c1",
+					function: { id: "c1", name: "edit", arguments: { path: "a.ts" } },
+				},
+			},
+		]);
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+
+		expect(events[0]).toEqual({
+			type: "tool-call-delta",
+			toolCallId: "c1",
+			toolName: "edit",
+			inputText: undefined,
+			input: { path: "a.ts" },
+		});
+		// A turn that ends with tool calls terminates as tool-calls, not stop.
+		expect(events.at(-1)).toEqual({ type: "finish", reason: "tool-calls" });
+	});
+
+	it("preserves the thought signature on reasoning and tool-call events", async () => {
+		const handler = fakeHandler([
+			{ type: "reasoning", reasoning: "think", signature: "sig-r", id: "x" },
+			{
+				type: "tool_calls",
+				id: "x",
+				signature: "sig-t",
+				tool_call: { call_id: "c1", function: { name: "edit", arguments: {} } },
+			},
+		]);
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+
+		const reasoning = events.find((e) => e.type === "reasoning-delta");
+		expect(reasoning?.metadata).toMatchObject({ thoughtSignature: "sig-r" });
+		const toolCall = events.find((e) => e.type === "tool-call-delta");
+		expect(toolCall?.metadata).toMatchObject({ thoughtSignature: "sig-t" });
+	});
+
+	it("maps a done chunk with a max-output-tokens incompleteReason to max-tokens", async () => {
+		const handler = fakeHandler([
+			{
+				type: "done",
+				success: true,
+				incompleteReason: "max_output_tokens",
+				id: "x",
+			},
+		]);
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+		expect(events.at(-1)).toMatchObject({
+			type: "finish",
+			reason: "max-tokens",
+		});
+	});
+
+	it("does not append a finish when the handler emits a done chunk", async () => {
+		const handler = fakeHandler([
+			{ type: "text", text: "x", id: "x" },
+			{ type: "done", success: true, id: "x" },
+		]);
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+
+		const finishes = events.filter((e) => e.type === "finish");
+		expect(finishes).toHaveLength(1);
+		expect(finishes[0]).toEqual({
+			type: "finish",
+			reason: "stop",
+			error: undefined,
+		});
+	});
+
+	it("forwards the abort signal to the handler", async () => {
+		const handler = fakeHandler([{ type: "text", text: "x", id: "x" }]);
+		const controller = new AbortController();
+		const model = createAgentModelFromApiHandler(handler);
+		await collect(model.stream({ ...baseRequest, signal: controller.signal }));
+		expect(handler.aborts[0]).toBe(controller.signal);
+	});
+
+	it("emits a finish(error) when the handler throws", async () => {
+		const handler = fakeHandler([{ type: "text", text: "x", id: "x" }], {
+			throwAfter: 0,
+		});
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+		expect(events.at(-1)).toMatchObject({
+			type: "finish",
+			reason: "error",
+			error: "boom",
+		});
+	});
+
+	it("does not emit a second finish when the handler throws after a done chunk", async () => {
+		// done -> finish, then the handler throws while flushing.
+		const handler = fakeHandler([{ type: "done", success: true, id: "x" }], {
+			throwAfter: 1,
+		});
+		const model = createAgentModelFromApiHandler(handler);
+		const events = await collect(model.stream(baseRequest));
+		const finishes = events.filter((e) => e.type === "finish");
+		expect(finishes).toHaveLength(1);
+		expect(finishes[0]).toMatchObject({ type: "finish", reason: "stop" });
+	});
+
+	it("resolves the handler lazily from an async factory on stream", async () => {
+		const handler = fakeHandler([{ type: "text", text: "lazy", id: "x" }]);
+		const factory = vi.fn(async () => handler);
+		const model = createAgentModelFromApiHandler(factory);
+
+		// Not built until the stream is consumed.
+		expect(factory).not.toHaveBeenCalled();
+		const events = await collect(model.stream(baseRequest));
+		expect(factory).toHaveBeenCalledTimes(1);
+		expect(events[0]).toEqual({ type: "text-delta", text: "lazy" });
+	});
+
+	it("converts a rejecting handler factory into a finish(error) event", async () => {
+		const factory = vi.fn(async () => {
+			throw new Error("no vscode.lm");
+		});
+		const model = createAgentModelFromApiHandler(factory);
+		const events = await collect(model.stream(baseRequest));
+		expect(events).toEqual([
+			{ type: "finish", reason: "error", error: "no vscode.lm" },
+		]);
+	});
+});
diff --git a/sdk/packages/core/src/services/llms/apihandler-agent-model-adapter.ts b/sdk/packages/core/src/services/llms/apihandler-agent-model-adapter.ts
new file mode 100644
index 0000000..8c9d1f5
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/apihandler-agent-model-adapter.ts
@@ -0,0 +1,171 @@
+/**
+ * Adapter: wrap a custom `ApiHandler` (from the `@cline/llms` handler registry)
+ * as an `AgentModel` for the agent runtime.
+ *
+ * The agent runtime builds models via `createAgentModelFromConfig`, which goes
+ * straight to the gateway. Hosts can register provider handlers that need
+ * host-only dependencies (e.g. the VS Code `vscode.lm` API) via
+ * `registerHandler(providerId, factory)`. Those produce an `ApiHandler`
+ * (`createMessage` -> `ApiStreamChunk`), which this adapter converts into the
+ * `AgentModel` contract (`stream` -> `AgentModelEvent`).
+ *
+ * This is the inverse of the gateway's `toApiStreamChunk` in
+ * `@cline/llms` `compat.ts`.
+ */
+
+import type { ApiHandler, ApiStreamChunk } from "@cline/llms";
+import type {
+	AgentModel,
+	AgentModelEvent,
+	AgentModelFinishReason,
+	AgentModelRequest,
+} from "@cline/shared";
+import { agentMessagesToMessages } from "../../runtime/config/agent-message-codec";
+
+type ApiStreamDoneChunk = Extract<ApiStreamChunk, { type: "done" }>;
+
+function toAgentModelEvents(chunk: ApiStreamChunk): AgentModelEvent[] {
+	switch (chunk.type) {
+		case "text":
+			return [{ type: "text-delta", text: chunk.text }];
+		case "reasoning":
+			// Thought signatures are read as `metadata.thoughtSignature` by
+			// downstream adapters (see ai-sdk format), so surface it there.
+			return [
+				{
+					type: "reasoning-delta",
+					text: chunk.reasoning,
+					metadata: chunk.signature
+						? { thoughtSignature: chunk.signature, details: chunk.details }
+						: { details: chunk.details },
+				},
+			];
+		case "tool_calls": {
+			const fn = chunk.tool_call.function;
+			const args = fn.arguments;
+			return [
+				{
+					type: "tool-call-delta",
+					toolCallId: chunk.tool_call.call_id ?? fn.id,
+					toolName: fn.name,
+					inputText: typeof args === "string" ? args : undefined,
+					input: typeof args === "string" ? undefined : args,
+					// Preserve the thought signature so it isn't dropped downstream.
+					...(chunk.signature
+						? { metadata: { thoughtSignature: chunk.signature } }
+						: {}),
+				},
+			];
+		}
+		case "usage":
+			return [
+				{
+					type: "usage",
+					usage: {
+						inputTokens: chunk.inputTokens,
+						outputTokens: chunk.outputTokens,
+						cacheReadTokens: chunk.cacheReadTokens,
+						cacheWriteTokens: chunk.cacheWriteTokens,
+						reasoningTokenCount: chunk.thoughtsTokenCount,
+						totalCost: chunk.totalCost,
+					},
+				},
+			];
+		case "done":
+			// `createMessage` streams typically end by returning; a "done" chunk is
+			// optional. Map it to a finish event so the runtime sees a terminal
+			// signal even when the handler emits one explicitly.
+			return [
+				{
+					type: "finish",
+					reason: doneFinishReason(chunk),
+					error: chunk.error,
+				},
+			];
+		default:
+			return [];
+	}
+}
+
+function doneFinishReason(chunk: ApiStreamDoneChunk): AgentModelFinishReason {
+	if (chunk.success === false) {
+		return "error";
+	}
+	if (
+		chunk.incompleteReason === "max_output_tokens" ||
+		chunk.incompleteReason === "max-tokens"
+	) {
+		return "max-tokens";
+	}
+	return "stop";
+}
+
+/**
+ * Resolves the `ApiHandler` to delegate to. A function is supported (and may be
+ * async) so handler construction can be deferred to the first `stream` call —
+ * which is required for providers registered via `registerAsyncHandler`.
+ */
+export type ApiHandlerSource =
+	| ApiHandler
+	| (() => ApiHandler | Promise<ApiHandler>);
+
+/**
+ * Build an `AgentModel` that delegates to a registered `ApiHandler`.
+ */
+export function createAgentModelFromApiHandler(
+	source: ApiHandlerSource,
+): AgentModel {
+	return {
+		async *stream(request: AgentModelRequest): AsyncGenerator<AgentModelEvent> {
+			let sawFinish = false;
+			let sawToolCall = false;
+			try {
+				// Resolving the handler (e.g. `createHandlerAsync`) can reject — for
+				// instance when the host API is unavailable at stream time — so it
+				// happens inside the try block to be reported as a terminal finish.
+				const handler = typeof source === "function" ? await source() : source;
+
+				// Forward the abort signal so cancellation reaches the handler.
+				handler.setAbortSignal?.(request.signal);
+
+				const messages = agentMessagesToMessages(request.messages);
+				const tools = request.tools.map((tool) => ({
+					name: tool.name,
+					description: tool.description,
+					inputSchema: tool.inputSchema,
+				}));
+
+				for await (const chunk of handler.createMessage(
+					request.systemPrompt ?? "",
+					messages,
+					tools,
+				)) {
+					for (const event of toAgentModelEvents(chunk)) {
+						if (event.type === "finish") {
+							sawFinish = true;
+						} else if (event.type === "tool-call-delta") {
+							sawToolCall = true;
+						}
+						yield event;
+					}
+				}
+				if (!sawFinish) {
+					// Terminating with tool calls is a tool-calls turn (matching the
+					// gateway/AI-SDK adapters); otherwise a normal stop.
+					yield {
+						type: "finish",
+						reason: sawToolCall ? "tool-calls" : "stop",
+					};
+				}
+			} catch (error) {
+				if (!sawFinish) {
+					yield {
+						type: "finish",
+						reason: request.signal?.aborted ? "aborted" : "error",
+						error: error instanceof Error ? error.message : String(error),
+					};
+				}
+			}
+		},
+	};
+}
diff --git a/sdk/packages/core/src/services/llms/cline-recommended-models.ts b/sdk/packages/core/src/services/llms/cline-recommended-models.ts
new file mode 100644
index 0000000..a007eca
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/cline-recommended-models.ts
@@ -0,0 +1,181 @@
+import { getClineEnvironmentConfig } from "@cline/shared";
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+
+export interface ClineRecommendedModel {
+	id: string;
+	name: string;
+	description: string;
+	tags: string[];
+}
+
+export interface ClineRecommendedModelsData {
+	recommended: ClineRecommendedModel[];
+	free: ClineRecommendedModel[];
+	clinePass: ClineRecommendedModel[];
+}
+
+export interface FetchClineRecommendedModelsOptions {
+	baseUrl?: string;
+	fetchImpl?: typeof fetch;
+	providerSettingsManager?: Pick<
+		ProviderSettingsManager,
+		"getProviderSettings"
+	>;
+	timeoutMs?: number;
+}
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 5_000;
+
+export const FALLBACK_CLINE_RECOMMENDED_MODELS: ClineRecommendedModelsData = {
+	recommended: [
+		{
+			id: "anthropic/claude-opus-4.6",
+			name: "Claude Opus 4.6",
+			description: "Most intelligent model for agents and coding",
+			tags: ["BEST"],
+		},
+		{
+			id: "anthropic/claude-sonnet-4.6",
+			name: "Claude Sonnet 4.6",
+			description: "Strong coding and agent performance",
+			tags: ["NEW"],
+		},
+		{
+			id: "google/gemini-3.1-pro-preview",
+			name: "Gemini 3.1 Pro Preview",
+			description: "1M context window, strong coding performance",
+			tags: ["NEW"],
+		},
+		{
+			id: "openai/gpt-5.3-codex",
+			name: "GPT-5.3 Codex",
+			description: "OpenAI's latest with strong coding abilities",
+			tags: ["NEW"],
+		},
+	],
+	free: [
+		{
+			id: "kwaipilot/kat-coder-pro",
+			name: "KwaiKAT Kat Coder Pro",
+			description: "Advanced agentic coding model",
+			tags: ["FREE"],
+		},
+		{
+			id: "arcee-ai/trinity-large-preview:free",
+			name: "Arcee AI Trinity Large Preview",
+			description: "Advanced large preview model",
+			tags: ["FREE"],
+		},
+	],
+	clinePass: [],
+};
+
+function cloneRecommendedModels(
+	data: ClineRecommendedModelsData,
+): ClineRecommendedModelsData {
+	return {
+		recommended: data.recommended.map((model) => ({
+			...model,
+			tags: [...model.tags],
+		})),
+		free: data.free.map((model) => ({ ...model, tags: [...model.tags] })),
+		clinePass: data.clinePass.map((model) => ({
+			...model,
+			tags: [...model.tags],
+		})),
+	};
+}
+
+function normalizeModel(raw: unknown): ClineRecommendedModel | null {
+	if (!raw || typeof raw !== "object") return null;
+	const data = raw as Record<string, unknown>;
+	if (typeof data.id !== "string" || data.id.length === 0) return null;
+	return {
+		id: data.id,
+		name:
+			typeof data.name === "string" && data.name.length > 0
+				? data.name
+				: data.id,
+		description: typeof data.description === "string" ? data.description : "",
+		tags: Array.isArray(data.tags)
+			? data.tags.filter((tag): tag is string => typeof tag === "string")
+			: [],
+	};
+}
+
+function normalizeResponse(raw: unknown): ClineRecommendedModelsData | null {
+	if (!raw || typeof raw !== "object") return null;
+	const data = raw as Record<string, unknown>;
+	const recommendedRaw = Array.isArray(data.recommended)
+		? data.recommended
+		: [];
+	const freeRaw = Array.isArray(data.free) ? data.free : [];
+	const clinePassRaw = Array.isArray(data.clinePass) ? data.clinePass : [];
+	const recommended = recommendedRaw
+		.map(normalizeModel)
+		.filter((model): model is ClineRecommendedModel => model !== null);
+	const free = freeRaw
+		.map(normalizeModel)
+		.filter((model): model is ClineRecommendedModel => model !== null);
+	const clinePass = clinePassRaw
+		.map(normalizeModel)
+		.filter((model): model is ClineRecommendedModel => model !== null);
+	if (recommended.length === 0 && free.length === 0 && clinePass.length === 0) {
+		return null;
+	}
+
+	return { recommended, free, clinePass };
+}
+
+function getConfiguredApiBaseUrl(
+	options: FetchClineRecommendedModelsOptions,
+): string {
+	const explicitBaseUrl = options.baseUrl?.trim();
+	if (explicitBaseUrl) return explicitBaseUrl;
+
+	const fallbackBaseUrl = getClineEnvironmentConfig().apiBaseUrl;
+	try {
+		const manager =
+			options.providerSettingsManager ?? new ProviderSettingsManager();
+		const settings = manager.getProviderSettings("cline");
+		return settings?.baseUrl?.trim() || fallbackBaseUrl;
+	} catch {
+		return fallbackBaseUrl;
+	}
+}
+
+async function fetchWithTimeout(
+	fetchImpl: typeof fetch,
+	input: string,
+	timeoutMs: number,
+): Promise<Response> {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetchImpl(input, { signal: controller.signal });
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+export async function fetchClineRecommendedModels(
+	options: FetchClineRecommendedModelsOptions = {},
+): Promise<ClineRecommendedModelsData> {
+	try {
+		const base = getConfiguredApiBaseUrl(options);
+		const fetchImpl = options.fetchImpl ?? fetch;
+		const resp = await fetchWithTimeout(
+			fetchImpl,
+			`${base}/api/v1/ai/cline/recommended-models`,
+			options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+		);
+		if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+		const json: unknown = await resp.json();
+		const data = normalizeResponse(json);
+		if (data) return data;
+	} catch {
+		// Fall back to the bundled list when the remote source is unavailable.
+	}
+
+	return cloneRecommendedModels(FALLBACK_CLINE_RECOMMENDED_MODELS);
+}
diff --git a/sdk/packages/core/src/services/llms/configured-provider-registry.ts b/sdk/packages/core/src/services/llms/configured-provider-registry.ts
new file mode 100644
index 0000000..10ec7c5
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/configured-provider-registry.ts
@@ -0,0 +1,193 @@
+import type { ProviderConfig } from "./provider-settings";
+import type {
+	BuiltInProviderSummary,
+	CreateHandlerInput,
+	ProviderConfigDefaults,
+	ProviderSelectionConfig,
+	RegisteredProviderSummary,
+} from "./runtime-types";
+
+interface ConfiguredProviderRecord {
+	id: string;
+	models: Set<string>;
+	defaultModel: string;
+	defaults: ProviderConfigDefaults;
+}
+
+interface RegisterConfiguredProviderInput {
+	id: string;
+	models: readonly string[];
+	defaultModel?: string;
+	defaults?: ProviderConfigDefaults;
+}
+
+function cloneDefaults(
+	defaults: ProviderConfigDefaults | undefined,
+): ProviderConfigDefaults {
+	return defaults ? { ...defaults } : {};
+}
+
+function resolveApiKey(
+	apiKey?: string,
+	apiKeyEnv?: string,
+): string | undefined {
+	if (apiKey) {
+		return apiKey;
+	}
+	if (!apiKeyEnv) {
+		return undefined;
+	}
+	const runtimeProcess = globalThis.process;
+	if (!runtimeProcess?.env) {
+		return undefined;
+	}
+	return runtimeProcess.env[apiKeyEnv];
+}
+
+function assertNonEmptyModels(
+	providerId: string,
+	models: readonly string[],
+): void {
+	if (!models.length) {
+		throw new Error(
+			`Provider "${providerId}" must include at least one model.`,
+		);
+	}
+}
+
+export function toBuiltInProviderSummary(input: {
+	collection: BuiltInProviderSummary["id"] extends string
+		? {
+				provider: Pick<
+					import("@cline/llms").ProviderInfo,
+					| "id"
+					| "name"
+					| "description"
+					| "protocol"
+					| "baseUrl"
+					| "capabilities"
+					| "env"
+					| "defaultModelId"
+				>;
+				models: Record<string, unknown>;
+			}
+		: never;
+}): BuiltInProviderSummary {
+	const models = Object.keys(input.collection.models);
+	return {
+		id: input.collection.provider.id,
+		name: input.collection.provider.name,
+		description: input.collection.provider.description,
+		protocol: input.collection.provider.protocol,
+		baseUrl: input.collection.provider.baseUrl,
+		capabilities: input.collection.provider.capabilities,
+		env: input.collection.provider.env,
+		models,
+		defaultModel: input.collection.provider.defaultModelId,
+		modelCount: models.length,
+	};
+}
+
+export class ConfiguredProviderRegistry {
+	private readonly providers = new Map<string, ConfiguredProviderRecord>();
+
+	register(input: RegisterConfiguredProviderInput): void {
+		assertNonEmptyModels(input.id, input.models);
+		const defaultModel = input.defaultModel ?? input.models[0];
+		if (!defaultModel) {
+			throw new Error(`Provider "${input.id}" must define a default model.`);
+		}
+		if (!input.models.includes(defaultModel)) {
+			throw new Error(
+				`Default model "${defaultModel}" is not included in configured models for "${input.id}".`,
+			);
+		}
+		const existing = this.providers.get(input.id);
+		this.providers.set(input.id, {
+			id: input.id,
+			models: new Set([...(existing?.models ?? []), ...input.models]),
+			defaultModel,
+			defaults: {
+				...(existing?.defaults ?? {}),
+				...cloneDefaults(input.defaults),
+			},
+		});
+	}
+
+	registerSelectionConfig(provider: ProviderSelectionConfig): void {
+		this.register({
+			id: provider.id,
+			models: provider.models,
+			defaultModel: provider.defaultModel,
+			defaults: {
+				apiKey: resolveApiKey(provider.apiKey, provider.apiKeyEnv),
+				routingProviderId: provider.builtinProviderId,
+				baseUrl: provider.baseUrl,
+				headers: provider.headers,
+				timeoutMs: provider.timeoutMs,
+				capabilities: provider.capabilities,
+				...cloneDefaults(provider.settings),
+			},
+		});
+	}
+
+	registerModel(providerId: string, modelId: string): void {
+		const existing = this.providers.get(providerId);
+		if (!existing) {
+			this.providers.set(providerId, {
+				id: providerId,
+				models: new Set([modelId]),
+				defaultModel: modelId,
+				defaults: {},
+			});
+			return;
+		}
+		existing.models.add(modelId);
+	}
+
+	createHandlerConfig(input: CreateHandlerInput): ProviderConfig {
+		const provider = this.require(input.providerId);
+		const modelId = input.modelId ?? provider.defaultModel;
+		if (!provider.models.has(modelId)) {
+			throw new Error(
+				`Model "${modelId}" is not configured for provider "${input.providerId}".`,
+			);
+		}
+		return {
+			providerId: input.providerId,
+			modelId,
+			...provider.defaults,
+			...input.overrides,
+		};
+	}
+
+	list(): RegisteredProviderSummary[] {
+		return Array.from(this.providers.values()).map((provider) => ({
+			id: provider.id,
+			models: Array.from(provider.models),
+			defaultModel: provider.defaultModel,
+		}));
+	}
+
+	getModels(providerId: string): string[] {
+		return Array.from(this.require(providerId).models);
+	}
+
+	hasProvider(providerId: string): boolean {
+		return this.providers.has(providerId);
+	}
+
+	hasModel(providerId: string, modelId: string): boolean {
+		return this.providers.get(providerId)?.models.has(modelId) ?? false;
+	}
+
+	private require(providerId: string): ConfiguredProviderRecord {
+		const provider = this.providers.get(providerId);
+		if (!provider) {
+			throw new Error(
+				`Provider "${providerId}" is not configured in this SDK instance.`,
+			);
+		}
+		return provider;
+	}
+}
diff --git a/sdk/packages/core/src/services/llms/handler-factory.test.ts b/sdk/packages/core/src/services/llms/handler-factory.test.ts
new file mode 100644
index 0000000..6f298d3
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/handler-factory.test.ts
@@ -0,0 +1,491 @@
+import type { AgentConfig, AgentModel, ITelemetryService } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const gatewayMock = vi.hoisted(() => {
+	const createAgentModel = vi.fn();
+	return {
+		createAgentModel,
+		createGateway: vi.fn(() => ({ createAgentModel })),
+		// Registry helpers used by createAgentModelFromConfig. Default to "no
+		// registered handler" so existing tests exercise the gateway path.
+		hasRegisteredHandler: vi.fn(() => false),
+		createHandlerAsync: vi.fn(),
+	};
+});
+
+vi.mock("@cline/llms", () => ({
+	createGateway: gatewayMock.createGateway,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID: {},
+	hasRegisteredHandler: gatewayMock.hasRegisteredHandler,
+	createHandlerAsync: gatewayMock.createHandlerAsync,
+	normalizeProviderId: (id: string) => id,
+}));
+
+describe("createAgentModelFromConfig", () => {
+	beforeEach(() => {
+		gatewayMock.createAgentModel.mockReset();
+		gatewayMock.createGateway.mockClear();
+		gatewayMock.createGateway.mockImplementation(() => ({
+			createAgentModel: gatewayMock.createAgentModel,
+		}));
+		gatewayMock.hasRegisteredHandler.mockReset();
+		gatewayMock.hasRegisteredHandler.mockReturnValue(false);
+		gatewayMock.createHandlerAsync.mockReset();
+	});
+
+	it("forwards effective telemetry into the gateway", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as ITelemetryService;
+		const model = {} as AgentModel;
+		gatewayMock.createAgentModel.mockReturnValue(model);
+
+		const result = createAgentModelFromConfig(
+			{
+				providerId: "mock-provider",
+				modelId: "mock-model",
+				apiKey: "key",
+				systemPrompt: "",
+				tools: [],
+			},
+			logger,
+			telemetry,
+		);
+
+		expect(result).toBe(model);
+		expect(gatewayMock.createGateway).toHaveBeenCalledWith(
+			expect.objectContaining({
+				logger,
+				telemetry,
+			}),
+		);
+	});
+
+	it("falls back to config telemetry when no override is supplied", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+		const telemetry = {
+			capture: vi.fn(),
+		} as unknown as ITelemetryService;
+
+		createAgentModelFromConfig(
+			{
+				providerId: "mock-provider",
+				modelId: "mock-model",
+				apiKey: "key",
+				systemPrompt: "",
+				tools: [],
+				telemetry,
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				telemetry,
+			}),
+		);
+	});
+
+	it("forwards a host-provided fetch into the gateway (top-level and per-provider)", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+		const hostFetch = vi.fn() as unknown as typeof fetch;
+
+		createAgentModelFromConfig(
+			{
+				providerId: "openai-compatible",
+				modelId: "mock-model",
+				apiKey: "key",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "openai-compatible",
+					modelId: "mock-model",
+					fetch: hostFetch,
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				fetch: hostFetch,
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "openai-compatible",
+						fetch: hostFetch,
+					}),
+				],
+			}),
+		);
+	});
+
+	it("preserves model capabilities and metadata when configuring gateway models", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "openrouter",
+				modelId: "qwen/qwen3.6-plus",
+				apiKey: "test-key",
+				systemPrompt: "",
+				tools: [],
+				knownModels: {
+					"qwen/qwen3.6-plus": {
+						id: "qwen/qwen3.6-plus",
+						name: "Qwen3.6 Plus",
+						contextWindow: 1_000_000,
+						maxInputTokens: 1_000_000,
+						maxTokens: 65_536,
+						capabilities: [
+							"tools",
+							"reasoning",
+							"structured_output",
+							"prompt-cache",
+						],
+						pricing: {
+							input: 0.325,
+							output: 1.95,
+							cacheRead: 0.0325,
+							cacheWrite: 0.40625,
+						},
+						releaseDate: "2026-04-02",
+						family: "qwen",
+					},
+				},
+			} satisfies AgentConfig,
+			undefined,
+		);
+
+		const gatewayConfig = (
+			gatewayMock.createGateway.mock.calls as unknown as Array<
+				[
+					{
+						providerConfigs: Array<{
+							models: Array<Record<string, unknown>>;
+						}>;
+					},
+				]
+			>
+		)[0][0];
+		const model = gatewayConfig.providerConfigs[0].models[0];
+		expect(model).toMatchObject({
+			id: "qwen/qwen3.6-plus",
+			name: "Qwen3.6 Plus",
+			contextWindow: 1_000_000,
+			maxInputTokens: 1_000_000,
+			maxOutputTokens: 65_536,
+			capabilities: expect.arrayContaining([
+				"text",
+				"tools",
+				"reasoning",
+				"structured-output",
+				"prompt-cache",
+			]),
+			metadata: {
+				family: "qwen",
+				pricing: {
+					input: 0.325,
+					output: 1.95,
+					cacheRead: 0.0325,
+					cacheWrite: 0.40625,
+				},
+				releaseDate: "2026-04-02",
+			},
+		});
+	});
+
+	it("uses explicit per-turn max tokens for gateway request limits", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "openai-compatible",
+				modelId: "custom-model",
+				apiKey: "key",
+				systemPrompt: "",
+				tools: [],
+				maxTokensPerTurn: 4_096,
+				providerConfig: {
+					providerId: "openai-compatible",
+					modelId: "custom-model",
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createAgentModel).toHaveBeenLastCalledWith(
+			{ providerId: "openai-compatible", modelId: "custom-model" },
+			{ maxTokens: 4_096 },
+		);
+	});
+
+	it("forwards Bedrock AWS settings as gateway provider options", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "bedrock",
+				modelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "bedrock",
+					modelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+					region: "us-west-2",
+					aws: {
+						authentication: "profile",
+						profile: "dev-profile",
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "bedrock",
+						options: expect.objectContaining({
+							region: "us-west-2",
+							authentication: "profile",
+							profile: "dev-profile",
+						}),
+					}),
+				],
+			}),
+		);
+	});
+
+	it("forwards Vertex GCP settings as gateway provider options", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "vertex",
+					modelId: "gemini-3-flash-preview",
+					gcp: {
+						projectId: "test-project",
+						region: "global",
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "vertex",
+						options: expect.objectContaining({
+							project: "test-project",
+							projectId: "test-project",
+							location: "global",
+							region: "global",
+						}),
+					}),
+				],
+			}),
+		);
+	});
+
+	it("forwards SAP AI Core settings as gateway provider options", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "sapaicore",
+				modelId: "anthropic--claude-4.6-sonnet",
+				baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "sapaicore",
+					modelId: "anthropic--claude-4.6-sonnet",
+					sap: {
+						clientId: "sap-client",
+						clientSecret: "sap-secret",
+						tokenUrl: "https://auth.example",
+						resourceGroup: "default",
+						deploymentId: "deployment-id",
+						useOrchestrationMode: false,
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "sapaicore",
+						baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+						options: expect.objectContaining({
+							clientId: "sap-client",
+							clientSecret: "sap-secret",
+							tokenUrl: "https://auth.example",
+							resourceGroup: "default",
+							deploymentId: "deployment-id",
+							useOrchestrationMode: false,
+						}),
+					}),
+				],
+			}),
+		);
+
+		const gatewayConfig = (
+			gatewayMock.createGateway.mock.calls as unknown as Array<
+				[
+					{
+						providerConfigs: Array<Record<string, unknown>>;
+					},
+				]
+			>
+		).at(-1)?.[0];
+		const { createSapAiCoreProviderModule } = await import(
+			// biome-ignore lint/style/noRestrictedImports: test asserts internal SAP provider module behavior not exposed via @cline/llms entrypoint
+			"../../../../llms/src/providers/vendors/community"
+		);
+		const provider = await createSapAiCoreProviderModule(
+			gatewayConfig?.providerConfigs[0] as never,
+		);
+		const model = provider.model("anthropic--claude-4.6-sonnet") as {
+			config?: {
+				destination?: Record<string, unknown>;
+				deploymentConfig?: Record<string, unknown>;
+				providerApi?: string;
+			};
+		};
+
+		expect(model.config?.destination).toBeUndefined();
+		expect(model.config?.deploymentConfig).toMatchObject({
+			deploymentId: "deployment-id",
+		});
+		expect(model.config?.providerApi).toBe("foundation-models");
+	});
+
+	it("forwards Azure settings as OpenAI-compatible gateway provider options", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "openai-compatible",
+				modelId: "gpt-4.1",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "openai-compatible",
+					modelId: "gpt-4.1",
+					azure: {
+						apiVersion: "2025-01-01-preview",
+						useIdentity: false,
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "openai-compatible",
+						options: expect.objectContaining({
+							apiVersion: "2025-01-01-preview",
+							useIdentity: false,
+						}),
+					}),
+				],
+			}),
+		);
+	});
+
+	it("does not forward Azure settings for non-OpenAI-compatible providers", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		createAgentModelFromConfig(
+			{
+				providerId: "anthropic",
+				modelId: "claude-3-5-sonnet",
+				systemPrompt: "",
+				tools: [],
+				providerConfig: {
+					providerId: "anthropic",
+					modelId: "claude-3-5-sonnet",
+					azure: {
+						apiVersion: "2025-01-01-preview",
+						useIdentity: false,
+					},
+				},
+			},
+			undefined,
+		);
+
+		expect(gatewayMock.createGateway).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				providerConfigs: [
+					expect.objectContaining({
+						providerId: "anthropic",
+						options: undefined,
+					}),
+				],
+			}),
+		);
+	});
+
+	it("uses a registered handler (adapter) instead of the gateway, building it lazily", async () => {
+		const { createAgentModelFromConfig } = await import("./handler-factory");
+
+		// Pretend a host handler is registered for this provider.
+		gatewayMock.hasRegisteredHandler.mockReturnValue(true);
+		const apiHandler = {
+			getMessages: () => [],
+			getModel: () => ({ id: "vscode-lm", info: { id: "vscode-lm" } }),
+			// eslint-disable-next-line require-yield
+			async *createMessage() {
+				/* no chunks for this assertion */
+			},
+		};
+		// createHandlerAsync resolves both sync- and async-registered handlers.
+		gatewayMock.createHandlerAsync.mockResolvedValue(apiHandler);
+
+		const result = createAgentModelFromConfig(
+			{
+				providerId: "vscode-lm",
+				modelId: "copilot/claude-sonnet",
+				apiKey: "",
+				systemPrompt: "",
+				tools: [],
+			},
+			undefined,
+		);
+
+		// The gateway is not used, and the AgentModel surface is exposed.
+		expect(gatewayMock.createGateway).not.toHaveBeenCalled();
+		expect(typeof result.stream).toBe("function");
+
+		// The handler is resolved lazily — only once the stream is consumed.
+		expect(gatewayMock.createHandlerAsync).not.toHaveBeenCalled();
+		for await (const _ of await result.stream({
+			systemPrompt: "",
+			messages: [],
+			tools: [],
+		})) {
+			// drain
+		}
+		expect(gatewayMock.createHandlerAsync).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/sdk/packages/core/src/services/llms/handler-factory.ts b/sdk/packages/core/src/services/llms/handler-factory.ts
new file mode 100644
index 0000000..c9f60b1
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/handler-factory.ts
@@ -0,0 +1,221 @@
+import {
+	createGateway,
+	createHandlerAsync,
+	hasRegisteredHandler,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID,
+	normalizeProviderId,
+} from "@cline/llms";
+import type {
+	AgentConfig,
+	AgentModel,
+	BasicLogger,
+	GatewayModelDefinition,
+	ITelemetryService,
+	ModelInfo,
+} from "@cline/shared";
+import { createAgentModelFromApiHandler } from "./apihandler-agent-model-adapter";
+import type { ProviderConfig } from "./provider-settings";
+
+function compactOptions(
+	options: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+	const compacted = Object.fromEntries(
+		Object.entries(options).filter(([, value]) => value !== undefined),
+	);
+	return Object.keys(compacted).length > 0 ? compacted : undefined;
+}
+
+function usesOpenAICompatibleClient(config: ProviderConfig): boolean {
+	return (
+		config.providerId === "openai-compatible" ||
+		config.clientType === "openai-compatible"
+	);
+}
+
+function buildGatewayProviderOptions(
+	config: ProviderConfig,
+): Record<string, unknown> | undefined {
+	const options: Record<string, unknown> = {
+		region: config.region,
+		apiLine: config.apiLine,
+		openRouterProviderSorting: config.openRouterProviderSorting,
+		modelCatalog: config.modelCatalog,
+	};
+
+	if (usesOpenAICompatibleClient(config)) {
+		Object.assign(options, {
+			apiVersion: config.azure?.apiVersion,
+			useIdentity: config.azure?.useIdentity,
+		});
+	}
+
+	if (config.providerId === "bedrock") {
+		Object.assign(options, {
+			authentication: config.aws?.authentication,
+			profile: config.aws?.profile,
+			accessKeyId: config.aws?.accessKey,
+			secretAccessKey: config.aws?.secretKey,
+			sessionToken: config.aws?.sessionToken,
+			usePromptCache: config.aws?.usePromptCache,
+			useCrossRegionInference: config.useCrossRegionInference,
+			useGlobalInference: config.useGlobalInference,
+			endpoint: config.aws?.endpoint,
+			customModelBaseId: config.aws?.customModelBaseId,
+		});
+	}
+
+	if (config.providerId === "vertex") {
+		const gcpRegion = config.gcp?.region ?? config.region;
+		Object.assign(options, {
+			project: config.gcp?.projectId,
+			projectId: config.gcp?.projectId,
+			location: gcpRegion,
+			region: gcpRegion,
+		});
+	}
+
+	if (config.providerId === "sapaicore") {
+		Object.assign(options, config.sap);
+	}
+
+	return compactOptions(options);
+}
+
+export function resolveKnownModelsFromConfig(
+	config: AgentConfig,
+): Record<string, ModelInfo> | undefined {
+	const pc = config.providerConfig as ProviderConfig | undefined;
+	if (pc?.knownModels) {
+		return pc.knownModels;
+	}
+	if (config.knownModels) {
+		return config.knownModels;
+	}
+	return (
+		MODEL_COLLECTIONS_BY_PROVIDER_ID[config.providerId]?.models ?? undefined
+	);
+}
+
+function toGatewayCapabilities(
+	capabilities: ModelInfo["capabilities"],
+): GatewayModelDefinition["capabilities"] {
+	if (!capabilities?.length) {
+		return undefined;
+	}
+
+	const mapped = new Set<
+		NonNullable<GatewayModelDefinition["capabilities"]>[number]
+	>();
+	for (const capability of capabilities) {
+		switch (capability) {
+			case "tools":
+			case "reasoning":
+			case "prompt-cache":
+			case "images":
+				mapped.add(capability);
+				break;
+			case "structured_output":
+				mapped.add("structured-output");
+				break;
+			default:
+				mapped.add("text");
+		}
+	}
+
+	mapped.add("text");
+	return [...mapped];
+}
+
+function toGatewayConfiguredModel(
+	id: string,
+	model: ModelInfo,
+): Omit<GatewayModelDefinition, "providerId"> {
+	return {
+		id,
+		name: model.name ?? id,
+		description: model.description,
+		contextWindow: model.contextWindow,
+		maxInputTokens: model.maxInputTokens,
+		maxOutputTokens: model.maxTokens,
+		capabilities: toGatewayCapabilities(model.capabilities),
+		metadata: {
+			family: model.family,
+			pricing: model.pricing,
+			status: model.status,
+			releaseDate: model.releaseDate,
+		},
+	};
+}
+
+export function createAgentModelFromConfig(
+	config: AgentConfig,
+	logger: BasicLogger | undefined,
+	telemetry?: ITelemetryService,
+): AgentModel {
+	const pc = config.providerConfig as ProviderConfig | undefined;
+	const baseProviderConfig =
+		pc?.providerId === config.providerId ? pc : undefined;
+	const normalizedProviderConfig: ProviderConfig = {
+		...(baseProviderConfig ?? {}),
+		providerId: config.providerId,
+		modelId: config.modelId,
+		apiKey: config.apiKey ?? baseProviderConfig?.apiKey,
+		baseUrl: config.baseUrl ?? baseProviderConfig?.baseUrl,
+		headers: config.headers ?? baseProviderConfig?.headers,
+		knownModels: resolveKnownModelsFromConfig(config),
+		maxOutputTokens: config.maxTokensPerTurn,
+		reasoningEffort: config.reasoningEffort,
+		thinkingBudgetTokens: config.thinkingBudgetTokens,
+		thinking: config.thinking,
+		logger,
+		extensionContext: config.extensionContext,
+	};
+
+	// Host-registered custom handlers (e.g. VS Code LM, which needs the host's
+	// `vscode.lm` API) are not part of the gateway. When a handler is registered
+	// for this provider, adapt its `ApiHandler` surface onto the `AgentModel`
+	// contract the runtime expects. The handler is built lazily (via
+	// `createHandlerAsync`) on the first stream so that providers registered
+	// with `registerAsyncHandler` resolve correctly.
+	if (
+		hasRegisteredHandler(
+			normalizeProviderId(normalizedProviderConfig.providerId),
+		)
+	) {
+		return createAgentModelFromApiHandler(() =>
+			createHandlerAsync(normalizedProviderConfig),
+		);
+	}
+
+	return createGateway({
+		// Forward the host-provided fetch so inference honors proxy/CA config on
+		// JetBrains and CLI, where the global fetch is not proxy-aware. Without
+		// this the agent loop falls back to bare global fetch and corporate
+		// proxy/self-signed CA setups fail.
+		fetch: normalizedProviderConfig.fetch,
+		providerConfigs: [
+			{
+				providerId: normalizedProviderConfig.providerId,
+				apiKey: normalizedProviderConfig.apiKey,
+				baseUrl: normalizedProviderConfig.baseUrl,
+				headers: normalizedProviderConfig.headers,
+				fetch: normalizedProviderConfig.fetch,
+				options: buildGatewayProviderOptions(normalizedProviderConfig),
+				models: normalizedProviderConfig.knownModels
+					? Object.entries(normalizedProviderConfig.knownModels).map(
+							([id, model]) => toGatewayConfiguredModel(id, model),
+						)
+					: undefined,
+			},
+		],
+		logger,
+		telemetry:
+			telemetry ?? config.telemetry ?? config.extensionContext?.telemetry,
+	}).createAgentModel(
+		{
+			providerId: normalizedProviderConfig.providerId,
+			modelId: normalizedProviderConfig.modelId,
+		},
+		{ maxTokens: normalizedProviderConfig.maxOutputTokens },
+	);
+}
diff --git a/sdk/packages/core/src/services/llms/provider-defaults.test.ts b/sdk/packages/core/src/services/llms/provider-defaults.test.ts
new file mode 100644
index 0000000..8d579aa
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/provider-defaults.test.ts
@@ -0,0 +1,594 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	clearLiveModelsCatalogCache,
+	clearPrivateModelsCatalogCache,
+	resolveProviderConfig,
+} from "./provider-defaults";
+
+afterEach(() => {
+	clearLiveModelsCatalogCache();
+	clearPrivateModelsCatalogCache();
+	vi.unstubAllGlobals();
+	vi.restoreAllMocks();
+});
+
+describe("resolveProviderConfig", () => {
+	it("returns bundled models for built-in providers without a base URL", async () => {
+		const resolved = await resolveProviderConfig("bedrock");
+
+		expect(resolved?.baseUrl).toBeUndefined();
+		expect(resolved?.modelId).toBe("minimax.minimax-m2.5");
+		expect(resolved?.knownModels?.["amazon.nova-2-lite-v1:0"]?.name).toBe(
+			"Nova 2 Lite",
+		);
+		expect(Object.keys(resolved?.knownModels ?? {}).length).toBeGreaterThan(0);
+	});
+
+	it("uses catalog aliases when loading live models", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(async () => {
+				return new Response(
+					JSON.stringify({
+						openrouter: {
+							models: {
+								"vendor/live-only-model": {
+									name: "Live Only Model",
+									tool_call: true,
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}),
+		);
+
+		const resolved = await resolveProviderConfig("cline", {
+			loadLatestOnInit: true,
+			failOnError: false,
+			cacheTtlMs: 0,
+		});
+
+		expect(resolved?.knownModels?.["vendor/live-only-model"]?.name).toBe(
+			"Live Only Model",
+		);
+	});
+
+	it("uses only live Cline recommended models for ClinePass when live models are found", async () => {
+		const fetchMock = vi.fn(async (url: string) => {
+			if (url === "https://models.test/api.json") {
+				return new Response(
+					JSON.stringify({
+						openrouter: {
+							models: {
+								"vendor/live-pass-model": {
+									name: "Live Pass Model",
+									tool_call: true,
+									reasoning: true,
+									limit: { context: 256_000, input: 200_000, output: 32_000 },
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}
+
+			return new Response(
+				JSON.stringify({
+					clinePass: [
+						{
+							id: "cline-pass/live-pass-model",
+							name: "vendor/live-pass-model",
+						},
+					],
+				}),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig("cline-pass", {
+			loadLatestOnInit: true,
+			failOnError: false,
+			cacheTtlMs: 0,
+			url: "https://models.test/api.json",
+		});
+
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+		expect(resolved?.knownModels?.["cline-pass/live-pass-model"]).toMatchObject(
+			{
+				id: "cline-pass/live-pass-model",
+				name: "Live Pass Model",
+				contextWindow: 256_000,
+				maxInputTokens: 200_000,
+				maxTokens: 32_000,
+			},
+		);
+		expect(resolved?.knownModels?.["cline-pass/mimo-v2.5-pro"]).toBeUndefined();
+	});
+
+	it("keeps ClinePass models ahead of newer free models in the served catalog", async () => {
+		const fetchMock = vi.fn(async (url: string) => {
+			if (url === "https://models.test/api.json") {
+				return new Response(
+					JSON.stringify({
+						openrouter: {
+							models: {
+								"vendor/live-pass-model": {
+									name: "Live Pass Model",
+									tool_call: true,
+									release_date: "2024-01-01",
+								},
+								"vendor/live-free-model": {
+									name: "Live Free Model",
+									tool_call: true,
+									release_date: "2026-01-01",
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}
+
+			return new Response(
+				JSON.stringify({
+					clinePass: [
+						{
+							id: "cline-pass/live-pass-model",
+							name: "vendor/live-pass-model",
+						},
+					],
+					free: [{ id: "vendor/live-free-model" }],
+				}),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig("cline-pass", {
+			loadLatestOnInit: true,
+			failOnError: false,
+			cacheTtlMs: 0,
+			url: "https://models.test/api.json",
+		});
+
+		// The first live model is the fallback default when the bundled default
+		// id is not in the live list, so a subscription model must stay first
+		// even when a free model has a newer release date.
+		expect(Object.keys(resolved?.knownModels ?? {})).toEqual([
+			"cline-pass/live-pass-model",
+			"vendor/live-free-model",
+		]);
+		expect(resolved?.knownModels?.["vendor/live-free-model"]?.pricing).toEqual({
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		});
+	});
+
+	it("falls back to generated ClinePass models when no live ClinePass models are found", async () => {
+		const fetchMock = vi.fn(async (url: string) => {
+			if (url === "https://models.test/api.json") {
+				return new Response(
+					JSON.stringify({
+						openrouter: {
+							models: {
+								"vendor/live-openrouter-model": {
+									name: "Live OpenRouter Model",
+									tool_call: true,
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}
+
+			return new Response(JSON.stringify({ clinePass: [] }), {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			});
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig("cline-pass", {
+			loadLatestOnInit: true,
+			failOnError: false,
+			cacheTtlMs: 0,
+			url: "https://models.test/api.json",
+		});
+
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+		expect(resolved?.knownModels?.["cline-pass/mimo-v2.5-pro"]?.name).toBe(
+			"MiMo-V2.5-Pro",
+		);
+		expect(
+			resolved?.knownModels?.["vendor/live-openrouter-model"],
+		).toBeUndefined();
+	});
+
+	it("prefers Vercel-style Z.ai ids in Cline known models", async () => {
+		const resolved = await resolveProviderConfig("cline");
+
+		expect(resolved?.knownModels?.["zai/glm-5.2"]).toMatchObject({
+			id: "zai/glm-5.2",
+			name: "GLM 5.2",
+			contextWindow: 1_040_000,
+			maxInputTokens: 1_040_000,
+		});
+		expect(resolved?.knownModels?.["z-ai/glm-5.2"]).toBeUndefined();
+	});
+
+	it("preserves explicit Cline known model overrides for alias ids", async () => {
+		const resolved = await resolveProviderConfig("cline", undefined, {
+			providerId: "cline",
+			modelId: "z-ai/glm-5.2",
+			knownModels: {
+				"z-ai/glm-5.2": {
+					id: "z-ai/glm-5.2",
+					name: "Custom GLM 5.2",
+					contextWindow: 123_456,
+					maxInputTokens: 123_456,
+				},
+			},
+		});
+
+		expect(resolved?.knownModels?.["z-ai/glm-5.2"]).toMatchObject({
+			id: "z-ai/glm-5.2",
+			name: "Custom GLM 5.2",
+			contextWindow: 123_456,
+			maxInputTokens: 123_456,
+		});
+		expect(resolved?.knownModels?.["zai/glm-5.2"]).toMatchObject({
+			id: "zai/glm-5.2",
+			contextWindow: 1_040_000,
+			maxInputTokens: 1_040_000,
+		});
+	});
+
+	it("uses the live OpenAI catalog for ChatGPT subscription models", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn(async () => {
+				return new Response(
+					JSON.stringify({
+						openai: {
+							models: {
+								"gpt-5.6-live": {
+									name: "GPT-5.6 Live",
+									tool_call: true,
+									reasoning: true,
+									family: "gpt",
+									release_date: "2027-01-01",
+								},
+								"gpt-5.3-live": {
+									name: "GPT-5.3 Live",
+									tool_call: true,
+									reasoning: true,
+									family: "gpt",
+									release_date: "2027-01-02",
+								},
+								"gpt-5.4-nano": {
+									name: "GPT-5.4 nano",
+									tool_call: true,
+									reasoning: true,
+									family: "gpt-nano",
+									release_date: "2027-01-03",
+								},
+								"o-live": {
+									name: "o live",
+									tool_call: true,
+									reasoning: true,
+									family: "o",
+									release_date: "2027-01-04",
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}),
+		);
+
+		const resolved = await resolveProviderConfig("openai-codex", {
+			loadLatestOnInit: true,
+			failOnError: false,
+			cacheTtlMs: 0,
+			url: "https://models.test/api.json",
+		});
+
+		expect(resolved?.knownModels?.["gpt-5.6-live"]?.name).toBe("GPT-5.6 Live");
+		expect(resolved?.knownModels?.["gpt-5.3-live"]).toBeUndefined();
+		expect(resolved?.knownModels?.["gpt-5.4-nano"]).toBeUndefined();
+		expect(resolved?.knownModels?.["o-live"]).toBeUndefined();
+	});
+
+	it("uses built-in modelsSourceUrl for keyless local provider models", async () => {
+		const fetchMock = vi.fn(async () => {
+			return new Response(
+				JSON.stringify({ models: [{ name: "local-llama" }] }),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig(
+			"ollama",
+			{ failOnError: false, cacheTtlMs: 0 },
+			{
+				providerId: "ollama",
+				modelId: "",
+				baseUrl: "http://tailscale-host:11434/v1",
+			},
+		);
+
+		expect(fetchMock).toHaveBeenCalledWith(
+			"http://tailscale-host:11434/api/tags",
+			{ method: "GET" },
+		);
+		expect(Object.keys(resolved?.knownModels ?? {})).toEqual(["local-llama"]);
+	});
+
+	it("loads Poolside models from the authenticated models endpoint", async () => {
+		const fetchMock = vi.fn(async () => {
+			return new Response(
+				JSON.stringify({
+					data: [
+						{
+							id: "poolside/laguna-xs.2",
+							name: "Poolside: Laguna XS.2",
+							description: "Poolside coding model",
+							context_length: 131_072,
+							max_completion_tokens: 8192,
+							supported_features: ["tools", "reasoning"],
+							supported_sampling_parameters: ["temperature"],
+							input_modalities: ["text"],
+							pricing: { prompt: "0", completion: "0" },
+						},
+					],
+				}),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig(
+			"poolside",
+			{ failOnError: true, cacheTtlMs: 0 },
+			{
+				providerId: "poolside",
+				modelId: "poolside/laguna-m.1",
+				apiKey: "poolside-key",
+				baseUrl: "https://inference.poolside.ai/v1",
+			},
+		);
+
+		expect(fetchMock).toHaveBeenCalledWith(
+			"https://inference.poolside.ai/v1/models",
+			expect.objectContaining({
+				method: "GET",
+				headers: expect.objectContaining({
+					Authorization: "Bearer poolside-key",
+				}),
+			}),
+		);
+		expect(resolved?.knownModels?.["poolside/laguna-xs.2"]).toEqual(
+			expect.objectContaining({
+				name: "Poolside: Laguna XS.2",
+				contextWindow: 131_072,
+				maxInputTokens: 131_072,
+				maxTokens: 8192,
+				capabilities: expect.arrayContaining([
+					"streaming",
+					"tools",
+					"reasoning",
+					"temperature",
+				]),
+				pricing: { input: 0, output: 0 },
+				status: "active",
+			}),
+		);
+	});
+
+	it("falls back to /model/info for LiteLLM private models", async () => {
+		const fetchMock = vi
+			.fn()
+			.mockResolvedValueOnce(new Response("no v1 route", { status: 404 }))
+			.mockResolvedValueOnce(new Response("no v1 route", { status: 404 }))
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						data: [
+							{
+								model_name: "private-proxy-model",
+								litellm_params: { model: "openai/gpt-4o-mini" },
+								model_info: {
+									supports_vision: true,
+									supports_reasoning: true,
+								},
+							},
+						],
+					}),
+					{ status: 200, headers: { "content-type": "application/json" } },
+				),
+			);
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig(
+			"litellm",
+			{ failOnError: true, cacheTtlMs: 0 },
+			{
+				providerId: "litellm",
+				modelId: "",
+				apiKey: "litellm-key",
+				baseUrl: "http://localhost:4000/v1/",
+			},
+		);
+
+		expect(fetchMock.mock.calls.map((call) => call[0])).toEqual([
+			"http://localhost:4000/v1/model/info",
+			"http://localhost:4000/v1/model/info",
+			"http://localhost:4000/model/info",
+		]);
+		expect(resolved?.knownModels?.["openai/gpt-4o-mini"]).toEqual(
+			expect.objectContaining({
+				name: "private-proxy-model",
+				capabilities: expect.arrayContaining(["images", "reasoning"]),
+			}),
+		);
+		expect(resolved?.knownModels?.["private-proxy-model"]).toEqual(
+			expect.objectContaining({
+				name: "private-proxy-model",
+				capabilities: expect.arrayContaining(["images", "reasoning"]),
+			}),
+		);
+		expect(Object.keys(resolved?.knownModels ?? {}).sort()).toEqual([
+			"openai/gpt-4o-mini",
+			"private-proxy-model",
+		]);
+		expect(resolved?.knownModels?.["gpt-5.4"]).toBeUndefined();
+	});
+
+	it("returns an empty authoritative LiteLLM model list without auth", async () => {
+		const fetchMock = vi.fn();
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig(
+			"litellm",
+			{ failOnError: true, cacheTtlMs: 0 },
+			{
+				providerId: "litellm",
+				modelId: "",
+				baseUrl: "http://localhost:4000/v1/",
+			},
+		);
+
+		expect(fetchMock).not.toHaveBeenCalled();
+		expect(resolved?.knownModels).toEqual({});
+		expect(resolved?.knownModels?.["gpt-5.4"]).toBeUndefined();
+	});
+
+	it("does not fall back to bundled LiteLLM models when private model fetch fails non-strictly", async () => {
+		const fetchMock = vi.fn(
+			async () => new Response('{"error":"unauthorized"}', { status: 401 }),
+		);
+		vi.stubGlobal("fetch", fetchMock);
+
+		const resolved = await resolveProviderConfig(
+			"litellm",
+			{ failOnError: false, cacheTtlMs: 0 },
+			{
+				providerId: "litellm",
+				modelId: "",
+				apiKey: "litellm-key",
+				baseUrl: "http://localhost:4000",
+			},
+		);
+
+		expect(fetchMock).toHaveBeenCalled();
+		expect(resolved?.knownModels).toEqual({});
+		expect(resolved?.knownModels?.["gpt-5.4"]).toBeUndefined();
+	});
+
+	it("reports attempted path, auth header, status, and body for LiteLLM model fetch failures", async () => {
+		const fetchMock = vi.fn(
+			async () => new Response('{"error":"unauthorized"}', { status: 401 }),
+		);
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(
+			resolveProviderConfig(
+				"litellm",
+				{ failOnError: true, cacheTtlMs: 0 },
+				{
+					providerId: "litellm",
+					modelId: "",
+					apiKey: "litellm-key",
+					baseUrl: "http://localhost:4000",
+				},
+			),
+		).rejects.toThrow(
+			'/model/info (Authorization): HTTP 401: {"error":"unauthorized"}',
+		);
+	});
+
+	it("derives ChatGPT subscription models from the generated OpenAI catalog", async () => {
+		const resolved = await resolveProviderConfig("openai-codex");
+		const openAiResolved = await resolveProviderConfig("openai-native");
+		const modelIds = Object.keys(resolved?.knownModels ?? {});
+
+		expect(modelIds).toEqual(expect.arrayContaining(["gpt-5.5", "gpt-5.4"]));
+		expect(modelIds).not.toContain("gpt-5.5-pro");
+		expect(modelIds).not.toContain("gpt-5.1-codex-max");
+		expect(modelIds).not.toContain("gpt-5.2-codex");
+		expect(modelIds).not.toContain("gpt-5.4-nano");
+		expect(modelIds).not.toContain("o3");
+		expect(resolved?.knownModels?.["gpt-5.4"]).toBeDefined();
+		expect(resolved?.knownModels?.["gpt-5.5"]).toEqual(
+			expect.objectContaining({
+				...openAiResolved?.knownModels?.["gpt-5.5"],
+				// ChatGPT/Codex backend caps: 272K input at the 95% effective budget
+				maxInputTokens: 272_000 * 0.95,
+				contextWindow: 400_000,
+				maxTokens: 128_000,
+			}),
+		);
+	});
+
+	it("resolves ChatGPT OAuth models from the filtered catalog", async () => {
+		const resolved = await resolveProviderConfig(
+			"openai-codex",
+			{ cacheTtlMs: 1 },
+			{
+				providerId: "openai-codex",
+				modelId: "gpt-5.4",
+				apiKey: "oauth-token",
+				accountId: "acct_123",
+			},
+		);
+
+		expect(Object.keys(resolved?.knownModels ?? {})).toEqual(
+			expect.arrayContaining(["gpt-5.4", "gpt-5.4-mini", "gpt-5.5"]),
+		);
+		expect(resolved?.knownModels?.["gpt-5.4-mini"]).toEqual(
+			expect.objectContaining({
+				name: "GPT-5.4 mini",
+				// catalog input cap scaled to the 95% effective Codex budget
+				maxInputTokens: 272_000 * 0.95,
+				contextWindow: 400_000,
+			}),
+		);
+		expect(resolved?.knownModels?.["gpt-5.4-nano"]).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/services/llms/provider-defaults.ts b/sdk/packages/core/src/services/llms/provider-defaults.ts
new file mode 100644
index 0000000..f853844
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/provider-defaults.ts
@@ -0,0 +1,952 @@
+/** biome-ignore-all lint/style/noNonNullAssertion: static */
+
+import * as Llms from "@cline/llms";
+import {
+	fetchModelIdsFromSource,
+	resolveModelsSourceUrl,
+} from "../providers/model-source";
+import type {
+	ModelCatalogConfig,
+	ModelInfo,
+	ProviderCapability,
+	ProviderConfig,
+} from "./provider-settings";
+
+export interface BuiltInProviderManifest {
+	id: string;
+	baseUrl: string;
+	modelsSourceUrl?: string;
+	modelId: string;
+	knownModels?: Record<string, ModelInfo>;
+	capabilities?: Llms.CatalogProviderCapability[];
+	env?: readonly string[];
+	client: Llms.ProviderClient;
+	protocol?: Llms.ProviderProtocol;
+}
+
+function cloneKnownModels(
+	models: Record<string, ModelInfo>,
+): Record<string, ModelInfo> {
+	return Object.fromEntries(
+		Object.entries(models).map(([id, info]) => [id, { ...info }]),
+	) as Record<string, ModelInfo>;
+}
+
+function isOpenAICompatibleManifest(
+	manifest: BuiltInProviderManifest,
+): boolean {
+	if (manifest.baseUrl.length === 0) {
+		return false;
+	}
+	switch (manifest.client) {
+		case "openai-compatible":
+		case "openai":
+		case "openai-r1":
+		case "fetch":
+			return true;
+		default:
+			return manifest.protocol === "openai-chat";
+	}
+}
+
+const BUILTIN_PROVIDER_MANIFESTS: BuiltInProviderManifest[] = Object.values(
+	Llms.MODEL_COLLECTIONS_BY_PROVIDER_ID,
+).map((collection) => ({
+	id: collection.provider.id,
+	baseUrl: collection.provider.baseUrl ?? "",
+	modelsSourceUrl: collection.provider.modelsSourceUrl,
+	modelId: collection.provider.defaultModelId,
+	knownModels: cloneKnownModels(collection.models),
+	capabilities: collection.provider.capabilities
+		? [...collection.provider.capabilities]
+		: undefined,
+	env: collection.provider.env ? [...collection.provider.env] : undefined,
+	client: collection.provider.client,
+	protocol: collection.provider.protocol,
+}));
+
+const BUILTIN_PROVIDER_MANIFESTS_BY_ID: Record<
+	string,
+	BuiltInProviderManifest
+> = Object.fromEntries(
+	BUILTIN_PROVIDER_MANIFESTS.map((manifest) => [manifest.id, manifest]),
+);
+
+function getBuiltInProviderManifest(
+	providerId: string,
+): BuiltInProviderManifest | undefined {
+	return BUILTIN_PROVIDER_MANIFESTS_BY_ID[providerId];
+}
+
+function getOpenAICompatibleProviderManifests(): Record<
+	string,
+	BuiltInProviderManifest
+> {
+	return Object.fromEntries(
+		Object.entries(BUILTIN_PROVIDER_MANIFESTS_BY_ID).filter(([, manifest]) =>
+			isOpenAICompatibleManifest(manifest),
+		),
+	);
+}
+
+export interface ProviderDefaults {
+	baseUrl?: string;
+	modelId: string;
+	knownModels?: Record<string, ModelInfo>;
+	capabilities?: ProviderCapability[];
+}
+
+function toRuntimeCapabilities(
+	capabilities: readonly Llms.CatalogProviderCapability[] = [],
+): ProviderCapability[] | undefined {
+	const next = capabilities.flatMap((capability) => {
+		switch (capability) {
+			case "reasoning":
+			case "prompt-cache":
+			case "tools":
+			case "oauth":
+				return [capability satisfies ProviderCapability];
+			default:
+				return [];
+		}
+	});
+	return next.length > 0 ? next : undefined;
+}
+
+export const DEFAULT_MODELS_CATALOG_URL = "https://models.dev/api.json";
+const DEFAULT_MODELS_CATALOG_CACHE_TTL_MS = 10 * 60 * 1000;
+const DEFAULT_PRIVATE_MODELS_CACHE_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_PRIVATE_MODELS_REQUEST_TIMEOUT_MS = 5_000;
+
+const MODELS_CATALOG_CACHE = new Map<
+	string,
+	{ expiresAt: number; data: Record<string, Record<string, ModelInfo>> }
+>();
+const MODELS_CATALOG_IN_FLIGHT = new Map<
+	string,
+	Promise<Record<string, Record<string, ModelInfo>>>
+>();
+const PRIVATE_MODELS_CACHE = new Map<
+	string,
+	{ expiresAt: number; data: Record<string, ModelInfo> }
+>();
+const PRIVATE_MODELS_IN_FLIGHT = new Map<
+	string,
+	Promise<Record<string, ModelInfo>>
+>();
+
+async function loadGeneratedProviderModels(): Promise<
+	Record<string, Record<string, ModelInfo>>
+> {
+	return Llms.getGeneratedProviderModels();
+}
+
+async function mergeKnownModels(
+	providerId: string,
+	defaultKnownModels: Record<string, ModelInfo> = {},
+	liveModels: Record<string, ModelInfo> = {},
+	privateModels: Record<string, ModelInfo> = {},
+	publicModels: Record<string, ModelInfo> = {},
+	userKnownModels: Record<string, ModelInfo> = {},
+): Promise<Record<string, ModelInfo>> {
+	if (providerId === "litellm") {
+		return Llms.sortModelsByReleaseDate(privateModels);
+	}
+
+	const generatedProviderModels = await loadGeneratedProviderModels();
+	const generatedKeys = Llms.resolveProviderModelCatalogKeys(providerId);
+	const generated = Object.assign(
+		{},
+		...generatedKeys.map(
+			(generatedKey) => generatedProviderModels[generatedKey] ?? {},
+		),
+	);
+	// For providers with a registered public model source (Ollama, LM Studio),
+	// the live response is the authoritative list of what the user has
+	// actually installed. Skip the bundled catalog so the picker doesn't
+	// show models that aren't downloaded.
+	const hasPublicModelSource = Boolean(
+		Llms.MODEL_COLLECTIONS_BY_PROVIDER_ID[providerId]?.provider.modelsSourceUrl,
+	);
+	const publicHasResults = Object.keys(publicModels).length > 0;
+	if (hasPublicModelSource && publicHasResults) {
+		return Llms.sortModelsByReleaseDate({
+			...publicModels,
+			...userKnownModels,
+		});
+	}
+	if (providerId === "openai-codex") {
+		return Llms.sortModelsByReleaseDate({
+			...defaultKnownModels,
+			...Llms.filterOpenAICodexModels(liveModels),
+			...publicModels,
+			...userKnownModels,
+		});
+	}
+	if (providerId === "cline-pass" && Object.keys(liveModels).length > 0) {
+		// Keep the catalog's intentional order (pass models first, free models
+		// after) instead of re-sorting by release date: the first live model is
+		// the fallback default when the bundled default id rotates out of the
+		// live list, and it must stay a subscription model, not a free one.
+		return {
+			...liveModels,
+			...userKnownModels,
+		};
+	}
+	const knownModelsWithoutUserOverrides = Llms.sortModelsByReleaseDate({
+		...generated,
+		...defaultKnownModels,
+		...liveModels,
+		...privateModels,
+		...publicModels,
+	});
+
+	if (providerId === "cline") {
+		// Cline recommendations can use Vercel-style ids while the broader
+		// catalog includes OpenRouter aliases for the same models.
+		return Llms.sortModelsByReleaseDate({
+			...Llms.preferCanonicalModelIds(
+				knownModelsWithoutUserOverrides,
+				Llms.VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+			),
+			...userKnownModels,
+		});
+	}
+
+	return Llms.sortModelsByReleaseDate({
+		...knownModelsWithoutUserOverrides,
+		...userKnownModels,
+	});
+}
+
+function resolveCatalogModels(
+	providerId: string,
+	modelsByProviderId: Record<string, Record<string, ModelInfo>>,
+): Record<string, ModelInfo> {
+	// Runtime provider ids do not always match catalog keys. For example,
+	// Cline uses OpenRouter-backed catalog models, so live catalog lookups must
+	// apply the same key mapping as generated catalog lookups.
+	const catalogKeys = Llms.resolveProviderModelCatalogKeys(providerId);
+	return Object.assign(
+		{},
+		...catalogKeys.map((catalogKey) => modelsByProviderId[catalogKey] ?? {}),
+	);
+}
+
+function normalizeBaseUrl(baseUrl: string | undefined): string {
+	const value = baseUrl?.trim();
+	return value && value.length > 0 ? value : "";
+}
+
+function resolveAuthToken(
+	config: Pick<ProviderConfig, "apiKey" | "accessToken">,
+): string | undefined {
+	const token = config.apiKey?.trim() || config.accessToken?.trim();
+	return token && token.length > 0 ? token : undefined;
+}
+
+function fingerprint(value: string): string {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i += 1) {
+		hash ^= value.charCodeAt(i);
+		hash +=
+			(hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+	}
+	return (hash >>> 0).toString(16);
+}
+
+function resolvePrivateCacheKey(
+	providerId: string,
+	config: ProviderConfig,
+): string {
+	return `${providerId}:${normalizeBaseUrl(config.baseUrl)}:${fingerprint(resolveAuthToken(config) ?? "")}`;
+}
+
+async function fetchWithTimeout(
+	input: string,
+	init: RequestInit,
+	timeoutMs = DEFAULT_PRIVATE_MODELS_REQUEST_TIMEOUT_MS,
+): Promise<Response> {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(input, {
+			...init,
+			signal: controller.signal,
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+function includeCapability(
+	capabilities: NonNullable<ModelInfo["capabilities"]>,
+	capability: NonNullable<ModelInfo["capabilities"]>[number],
+	when: boolean,
+): void {
+	if (when && !capabilities.includes(capability)) {
+		capabilities.push(capability);
+	}
+}
+
+function buildModelFromPrivateSource(
+	id: string,
+	input: {
+		name?: string;
+		contextWindow?: number;
+		maxInputTokens?: number;
+		maxTokens?: number;
+		supportsImages?: boolean;
+		supportsPromptCache?: boolean;
+		supportsReasoning?: boolean;
+		releaseDate?: string;
+	},
+): ModelInfo {
+	const capabilities: NonNullable<ModelInfo["capabilities"]> = [
+		"streaming",
+		"tools",
+	];
+	includeCapability(capabilities, "images", Boolean(input.supportsImages));
+	includeCapability(
+		capabilities,
+		"prompt-cache",
+		Boolean(input.supportsPromptCache),
+	);
+	includeCapability(
+		capabilities,
+		"reasoning",
+		Boolean(input.supportsReasoning),
+	);
+	return {
+		id,
+		name: input.name ?? id,
+		contextWindow: input.contextWindow,
+		maxInputTokens: input.maxInputTokens,
+		maxTokens: input.maxTokens,
+		capabilities,
+		releaseDate: input.releaseDate,
+		status: "active",
+	};
+}
+
+interface BasetenModelResponse {
+	id?: string;
+	object?: string;
+	supported_features?: string[];
+	context_length?: number;
+	max_completion_tokens?: number;
+}
+
+async function fetchBasetenPrivateModels(
+	_config: ProviderConfig,
+	token: string,
+): Promise<Record<string, ModelInfo>> {
+	const response = await fetchWithTimeout(
+		"https://inference.baseten.co/v1/models",
+		{
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json",
+			},
+		},
+	);
+	if (!response.ok) {
+		throw new Error(`Baseten model refresh failed: HTTP ${response.status}`);
+	}
+
+	const payload = (await response.json()) as { data?: BasetenModelResponse[] };
+	const entries = payload?.data ?? [];
+	const models: Record<string, ModelInfo> = {};
+	for (const model of entries) {
+		const id = model.id?.trim();
+		if (!id) {
+			continue;
+		}
+		if (
+			id.includes("whisper") ||
+			id.includes("tts") ||
+			id.includes("embedding")
+		) {
+			continue;
+		}
+		const features = model.supported_features ?? [];
+		models[id] = buildModelFromPrivateSource(id, {
+			name: id,
+			contextWindow: model.context_length,
+			maxInputTokens: model.context_length,
+			maxTokens: model.max_completion_tokens,
+			supportsReasoning:
+				features.includes("reasoning") || features.includes("reasoning_effort"),
+			supportsImages: false,
+		});
+	}
+	return models;
+}
+
+interface HicapModelResponse {
+	id?: string;
+}
+
+interface PoolsideModelResponse {
+	id?: string;
+	name?: string;
+	description?: string;
+	context_length?: number;
+	max_completion_tokens?: number;
+	supported_features?: string[];
+	supported_sampling_parameters?: string[];
+	input_modalities?: string[];
+	pricing?: {
+		prompt?: number | string;
+		completion?: number | string;
+	};
+}
+
+function parseOptionalNumber(
+	value: number | string | undefined,
+): number | undefined {
+	if (typeof value === "number") {
+		return Number.isFinite(value) ? value : undefined;
+	}
+	if (typeof value === "string") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : undefined;
+	}
+	return undefined;
+}
+
+async function fetchHicapPrivateModels(
+	_config: ProviderConfig,
+	token: string,
+): Promise<Record<string, ModelInfo>> {
+	const response = await fetchWithTimeout(
+		"https://api.hicap.ai/v2/openai/models",
+		{
+			method: "GET",
+			headers: {
+				"api-key": token,
+			},
+		},
+	);
+	if (!response.ok) {
+		throw new Error(`Hicap model refresh failed: HTTP ${response.status}`);
+	}
+
+	const payload = (await response.json()) as { data?: HicapModelResponse[] };
+	const entries = payload?.data ?? [];
+	const models: Record<string, ModelInfo> = {};
+	for (const model of entries) {
+		const id = model.id?.trim();
+		if (!id) {
+			continue;
+		}
+		models[id] = buildModelFromPrivateSource(id, {
+			name: id,
+			maxInputTokens: 128_000,
+			supportsImages: true,
+			supportsPromptCache: true,
+		});
+	}
+	return models;
+}
+
+async function fetchPoolsidePrivateModels(
+	config: ProviderConfig,
+	token: string,
+): Promise<Record<string, ModelInfo>> {
+	const baseUrl =
+		normalizeBaseUrl(config.baseUrl) || "https://inference.poolside.ai/v1";
+	const endpoint = `${baseUrl.replace(/\/+$/, "")}/models`;
+	const response = await fetchWithTimeout(endpoint, {
+		method: "GET",
+		headers: {
+			Authorization: `Bearer ${token}`,
+			accept: "application/json",
+		},
+	});
+	if (!response.ok) {
+		throw new Error(`Poolside model refresh failed: HTTP ${response.status}`);
+	}
+
+	const payload = (await response.json()) as { data?: PoolsideModelResponse[] };
+	const entries = payload?.data ?? [];
+	const models: Record<string, ModelInfo> = {};
+	for (const model of entries) {
+		const id = model.id?.trim();
+		if (!id) {
+			continue;
+		}
+
+		const supportedFeatures = model.supported_features ?? [];
+		const supportedSamplingParameters =
+			model.supported_sampling_parameters ?? [];
+		const inputModalities = model.input_modalities ?? [];
+		const capabilities: NonNullable<ModelInfo["capabilities"]> = ["streaming"];
+		includeCapability(
+			capabilities,
+			"tools",
+			supportedFeatures.includes("tools"),
+		);
+		includeCapability(
+			capabilities,
+			"reasoning",
+			supportedFeatures.includes("reasoning"),
+		);
+		includeCapability(
+			capabilities,
+			"temperature",
+			supportedSamplingParameters.includes("temperature"),
+		);
+		includeCapability(
+			capabilities,
+			"images",
+			inputModalities.includes("image"),
+		);
+
+		const pricing = {
+			input: parseOptionalNumber(model.pricing?.prompt),
+			output: parseOptionalNumber(model.pricing?.completion),
+		};
+		models[id] = {
+			id,
+			name: model.name ?? id,
+			description: model.description,
+			contextWindow: model.context_length,
+			maxInputTokens: model.context_length,
+			maxTokens: model.max_completion_tokens,
+			capabilities,
+			pricing:
+				pricing.input !== undefined || pricing.output !== undefined
+					? pricing
+					: undefined,
+			status: "active",
+		};
+	}
+	return models;
+}
+
+interface LiteLlmModelInfoResponse {
+	model_name?: string;
+	litellm_params?: {
+		model?: string;
+	};
+	model_info?: {
+		max_output_tokens?: number;
+		max_tokens?: number;
+		max_input_tokens?: number;
+		supports_vision?: boolean;
+		supports_prompt_caching?: boolean;
+		supports_reasoning?: boolean;
+	};
+}
+
+function normalizeLiteLlmBaseUrl(baseUrl: string | undefined): string {
+	const normalized = normalizeBaseUrl(baseUrl).replace(/\/+$/, "");
+	if (!normalized) {
+		return "http://localhost:4000";
+	}
+	return normalized.endsWith("/v1") ? normalized.slice(0, -3) : normalized;
+}
+
+function buildLiteLlmModelInfoUrls(baseUrl: string): string[] {
+	return [`${baseUrl}/v1/model/info`, `${baseUrl}/model/info`];
+}
+
+async function describeLiteLlmHttpFailure(response: Response): Promise<string> {
+	const body = (await response.text().catch(() => ""))
+		.replace(/\s+/g, " ")
+		.trim();
+	const bodyLimit = 500;
+	const bodyText = body
+		? `: ${body.slice(0, bodyLimit)}${body.length > bodyLimit ? "..." : ""}`
+		: "";
+	return `HTTP ${response.status}${bodyText}`;
+}
+
+async function fetchLiteLlmPrivateModels(
+	config: ProviderConfig,
+	token: string,
+): Promise<Record<string, ModelInfo>> {
+	const baseUrl = normalizeLiteLlmBaseUrl(config.baseUrl);
+	const failures: string[] = [];
+	const authHeaders = [
+		["x-litellm-api-key", { "x-litellm-api-key": token }],
+		["Authorization", { Authorization: `Bearer ${token}` }],
+	] as const;
+
+	for (const endpoint of buildLiteLlmModelInfoUrls(baseUrl)) {
+		for (const [authLabel, authHeader] of authHeaders) {
+			try {
+				const response = await fetchWithTimeout(endpoint, {
+					method: "GET",
+					headers: {
+						accept: "application/json",
+						...authHeader,
+					},
+				});
+
+				if (response.ok) {
+					const payload = (await response.json()) as {
+						data?: LiteLlmModelInfoResponse[];
+					};
+					const entries = payload?.data ?? [];
+					const models: Record<string, ModelInfo> = {};
+					for (const model of entries) {
+						const displayName = model.model_name?.trim();
+						const actualModelId = model.litellm_params?.model?.trim();
+						const modelId = actualModelId || displayName;
+						if (!modelId) {
+							continue;
+						}
+						const info = model.model_info;
+						const converted = buildModelFromPrivateSource(modelId, {
+							name: displayName ?? modelId,
+							maxTokens: info?.max_output_tokens ?? info?.max_tokens,
+							maxInputTokens: info?.max_input_tokens ?? info?.max_tokens,
+							supportsImages: info?.supports_vision,
+							supportsPromptCache: info?.supports_prompt_caching,
+							supportsReasoning: info?.supports_reasoning,
+						});
+						models[modelId] = converted;
+						if (displayName) {
+							models[displayName] = {
+								...converted,
+								id: displayName,
+								name: displayName,
+							};
+						}
+					}
+					return models;
+				}
+
+				failures.push(
+					`${new URL(endpoint).pathname} (${authLabel}): ${await describeLiteLlmHttpFailure(response)}`,
+				);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				failures.push(
+					`${new URL(endpoint).pathname} (${authLabel}): ${message}`,
+				);
+			}
+		}
+	}
+
+	throw new Error(
+		`LiteLLM model refresh failed. Attempts: ${failures.join("; ")}`,
+	);
+}
+
+type PrivateProviderModelFetcher = (
+	config: ProviderConfig,
+	token: string,
+) => Promise<Record<string, ModelInfo>>;
+
+const PRIVATE_PROVIDER_MODEL_FETCHERS: Record<
+	string,
+	PrivateProviderModelFetcher
+> = {
+	baseten: fetchBasetenPrivateModels,
+	hicap: fetchHicapPrivateModels,
+	litellm: fetchLiteLlmPrivateModels,
+	poolside: fetchPoolsidePrivateModels,
+};
+
+const PUBLIC_MODELS_CACHE = new Map<
+	string,
+	{ data: Record<string, ModelInfo>; expiresAt: number }
+>();
+const PUBLIC_MODELS_IN_FLIGHT = new Map<
+	string,
+	Promise<Record<string, ModelInfo>>
+>();
+
+function resolvePublicCacheKey(
+	providerId: string,
+	config: ProviderConfig,
+): string {
+	return `${providerId}:${normalizeBaseUrl(config.baseUrl)}`;
+}
+
+async function getPublicProviderModels(
+	providerId: string,
+	modelCatalog: ModelCatalogConfig | undefined,
+	config: ProviderConfig,
+): Promise<Record<string, ModelInfo>> {
+	const collection = Llms.MODEL_COLLECTIONS_BY_PROVIDER_ID[providerId];
+	const sourceUrl = resolveModelsSourceUrl(
+		config.baseUrl,
+		collection?.provider.baseUrl,
+		collection?.provider.modelsSourceUrl,
+	);
+	if (!sourceUrl) {
+		return {};
+	}
+	const cacheTtlMs =
+		modelCatalog?.cacheTtlMs ?? DEFAULT_PRIVATE_MODELS_CACHE_TTL_MS;
+	const cacheKey = resolvePublicCacheKey(providerId, config);
+	const now = Date.now();
+
+	const cached = PUBLIC_MODELS_CACHE.get(cacheKey);
+	if (cached && cached.expiresAt > now) {
+		return cached.data;
+	}
+
+	const inFlight = PUBLIC_MODELS_IN_FLIGHT.get(cacheKey);
+	if (inFlight) {
+		return inFlight;
+	}
+
+	const request = fetchModelIdsFromSource(sourceUrl, providerId)
+		.then((modelIds) => {
+			const data = Object.fromEntries(
+				modelIds.map((id) => [
+					id,
+					buildModelFromPrivateSource(id, { name: id }),
+				]),
+			);
+			PUBLIC_MODELS_CACHE.set(cacheKey, {
+				data,
+				expiresAt: now + cacheTtlMs,
+			});
+			return data;
+		})
+		.finally(() => {
+			PUBLIC_MODELS_IN_FLIGHT.delete(cacheKey);
+		});
+
+	PUBLIC_MODELS_IN_FLIGHT.set(cacheKey, request);
+	return request;
+}
+
+export function clearPublicModelsCatalogCache(): void {
+	PUBLIC_MODELS_CACHE.clear();
+	PUBLIC_MODELS_IN_FLIGHT.clear();
+}
+
+async function fetchPrivateProviderModels(
+	providerId: string,
+	config: ProviderConfig,
+): Promise<Record<string, ModelInfo>> {
+	const token = resolveAuthToken(config);
+	if (!token) {
+		return {};
+	}
+
+	const fetcher = PRIVATE_PROVIDER_MODEL_FETCHERS[providerId];
+	if (!fetcher) {
+		return {};
+	}
+	return fetcher(config, token);
+}
+
+function shouldLoadPrivateModels(
+	providerId: string,
+	modelCatalog: ModelCatalogConfig | undefined,
+	config: ProviderConfig | undefined,
+): boolean {
+	if (!config) {
+		return false;
+	}
+	if (!PRIVATE_PROVIDER_MODEL_FETCHERS[providerId]) {
+		return false;
+	}
+	if (modelCatalog?.loadPrivateOnAuth === false) {
+		return false;
+	}
+	return Boolean(resolveAuthToken(config));
+}
+
+async function getPrivateProviderModels(
+	providerId: string,
+	modelCatalog: ModelCatalogConfig | undefined,
+	config: ProviderConfig,
+): Promise<Record<string, ModelInfo>> {
+	const cacheTtlMs =
+		modelCatalog?.cacheTtlMs ?? DEFAULT_PRIVATE_MODELS_CACHE_TTL_MS;
+	const cacheKey = resolvePrivateCacheKey(providerId, config);
+	const now = Date.now();
+
+	const cached = PRIVATE_MODELS_CACHE.get(cacheKey);
+	if (cached && cached.expiresAt > now) {
+		return cached.data;
+	}
+
+	const inFlight = PRIVATE_MODELS_IN_FLIGHT.get(cacheKey);
+	if (inFlight) {
+		return inFlight;
+	}
+
+	const request = fetchPrivateProviderModels(providerId, config)
+		.then((data) => {
+			PRIVATE_MODELS_CACHE.set(cacheKey, {
+				data,
+				expiresAt: now + cacheTtlMs,
+			});
+			return data;
+		})
+		.finally(() => {
+			PRIVATE_MODELS_IN_FLIGHT.delete(cacheKey);
+		});
+
+	PRIVATE_MODELS_IN_FLIGHT.set(cacheKey, request);
+	return request;
+}
+
+async function fetchLiveModelsCatalog(
+	url: string,
+): Promise<Record<string, Record<string, ModelInfo>>> {
+	return Llms.fetchLiveProviderModels(url, globalThis.fetch);
+}
+
+export async function getLiveModelsCatalog(
+	options: Pick<ModelCatalogConfig, "url" | "cacheTtlMs"> = {},
+): Promise<Record<string, Record<string, ModelInfo>>> {
+	const url = options.url ?? DEFAULT_MODELS_CATALOG_URL;
+	const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_MODELS_CATALOG_CACHE_TTL_MS;
+	const now = Date.now();
+
+	const cached = MODELS_CATALOG_CACHE.get(url);
+	if (cached && cached.expiresAt > now) {
+		return cached.data;
+	}
+
+	const inFlight = MODELS_CATALOG_IN_FLIGHT.get(url);
+	if (inFlight) {
+		return inFlight;
+	}
+
+	const request = fetchLiveModelsCatalog(url)
+		.then((data) => {
+			MODELS_CATALOG_CACHE.set(url, { data, expiresAt: now + cacheTtlMs });
+			return data;
+		})
+		.finally(() => {
+			MODELS_CATALOG_IN_FLIGHT.delete(url);
+		});
+
+	MODELS_CATALOG_IN_FLIGHT.set(url, request);
+	return request;
+}
+
+export function clearLiveModelsCatalogCache(url?: string): void {
+	if (url) {
+		MODELS_CATALOG_CACHE.delete(url);
+		MODELS_CATALOG_IN_FLIGHT.delete(url);
+		return;
+	}
+
+	MODELS_CATALOG_CACHE.clear();
+	MODELS_CATALOG_IN_FLIGHT.clear();
+}
+
+export function clearPrivateModelsCatalogCache(): void {
+	PRIVATE_MODELS_CACHE.clear();
+	PRIVATE_MODELS_IN_FLIGHT.clear();
+}
+
+function toRuntimeProviderDefaults(
+	manifests: ReturnType<typeof getOpenAICompatibleProviderManifests>,
+): Record<string, ProviderDefaults> {
+	return Object.fromEntries(
+		Object.entries(manifests).map(([providerId, manifest]) => [
+			providerId,
+			{
+				baseUrl: manifest.baseUrl,
+				modelId: manifest.modelId,
+				capabilities: toRuntimeCapabilities(manifest.capabilities),
+			},
+		]),
+	);
+}
+
+export const OPENAI_COMPATIBLE_PROVIDERS: Record<string, ProviderDefaults> =
+	toRuntimeProviderDefaults(getOpenAICompatibleProviderManifests());
+
+export function getProviderConfig(
+	providerId: string,
+): ProviderDefaults | undefined {
+	const manifest = getBuiltInProviderManifest(providerId);
+	if (!manifest) {
+		return undefined;
+	}
+
+	return {
+		baseUrl: manifest.baseUrl || undefined,
+		modelId: manifest.modelId,
+		knownModels: manifest.knownModels,
+		capabilities: toRuntimeCapabilities(manifest.capabilities),
+	};
+}
+
+export async function resolveProviderConfig(
+	providerId: string,
+	modelCatalog?: ModelCatalogConfig,
+	config?: ProviderConfig,
+): Promise<ProviderDefaults | undefined> {
+	const defaults = getProviderConfig(providerId);
+	if (!defaults) {
+		return undefined;
+	}
+
+	try {
+		const liveCatalog = modelCatalog?.loadLatestOnInit
+			? await getLiveModelsCatalog(modelCatalog)
+			: undefined;
+		const liveModels = liveCatalog
+			? resolveCatalogModels(providerId, liveCatalog)
+			: {};
+		const privateModels =
+			config && shouldLoadPrivateModels(providerId, modelCatalog, config)
+				? await getPrivateProviderModels(providerId, modelCatalog, config)
+				: {};
+		// Public (keyless) live model sources run whenever `modelsSourceUrl` is
+		// registered for the provider — even if the caller didn't pass a
+		// `config`. Falls back to the spec's default base URL so a fresh install
+		// still hits the default local model endpoint. Failures are swallowed
+		// below, so an unreachable server just leaves the picker on the bundled
+		// catalog.
+		const hasPublicModelSource = Boolean(
+			Llms.MODEL_COLLECTIONS_BY_PROVIDER_ID[providerId]?.provider
+				.modelsSourceUrl,
+		);
+		const publicConfig: ProviderConfig | undefined = hasPublicModelSource
+			? (config ?? {
+					providerId: providerId as ProviderConfig["providerId"],
+					modelId: defaults.modelId,
+					baseUrl: defaults.baseUrl,
+				})
+			: config;
+		const publicModels = publicConfig
+			? await getPublicProviderModels(
+					providerId,
+					modelCatalog,
+					publicConfig,
+				).catch(() => ({}))
+			: {};
+		const knownModels = await mergeKnownModels(
+			providerId,
+			defaults.knownModels,
+			liveModels,
+			privateModels,
+			publicModels,
+			config?.knownModels,
+		);
+
+		return {
+			...defaults,
+			knownModels,
+		};
+	} catch (error) {
+		if (modelCatalog?.failOnError) {
+			throw error;
+		}
+		if (providerId === "litellm") {
+			return {
+				...defaults,
+				knownModels: {},
+			};
+		}
+		return defaults;
+	}
+}
diff --git a/sdk/packages/core/src/services/llms/provider-settings.test.ts b/sdk/packages/core/src/services/llms/provider-settings.test.ts
new file mode 100644
index 0000000..2dae80a
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/provider-settings.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { safeParseSettings, toProviderConfig } from "./provider-settings";
+
+describe("provider settings", () => {
+	it("formats Cline OAuth access tokens for runtime API keys", () => {
+		const config = toProviderConfig({
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			auth: {
+				accessToken: "oauth-access-token",
+			},
+		});
+
+		expect(config.apiKey).toBe("workos:oauth-access-token");
+		expect(config.accessToken).toBe("oauth-access-token");
+	});
+
+	it("accepts the Bedrock apikey authentication alias", () => {
+		const result = safeParseSettings({
+			provider: "bedrock",
+			model: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+			aws: {
+				authentication: "apikey",
+				region: "us-east-1",
+			},
+		});
+
+		expect(result.success).toBe(true);
+		if (!result.success) {
+			throw new Error("expected Bedrock apikey settings to parse");
+		}
+
+		expect(toProviderConfig(result.data).aws).toEqual(
+			expect.objectContaining({
+				authentication: "apikey",
+			}),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/services/llms/provider-settings.ts b/sdk/packages/core/src/services/llms/provider-settings.ts
new file mode 100644
index 0000000..0f310f8
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/provider-settings.ts
@@ -0,0 +1,322 @@
+import * as Llms from "@cline/llms";
+import { z } from "zod";
+import {
+	DEFAULT_EXTERNAL_OCA_BASE_URL,
+	DEFAULT_INTERNAL_OCA_BASE_URL,
+} from "../../auth/oca";
+import { getPersistedProviderApiKey } from "../../auth/provider-auth-registry";
+import {
+	OPENAI_COMPATIBLE_PROVIDERS,
+	type ProviderDefaults,
+} from "./provider-defaults";
+
+export type ModelInfo = Llms.ModelInfo;
+export type ProviderClient = Llms.ProviderClient;
+export type ProviderProtocol = Llms.ProviderProtocol;
+export type ProviderId = Llms.ProviderId;
+export type ProviderCapability = Llms.ProviderCapability;
+export type ProviderConfig = Llms.ProviderConfig;
+export type BuiltInProviderId = Llms.BuiltInProviderId;
+
+export const BUILT_IN_PROVIDER = Llms.BUILT_IN_PROVIDER;
+export const BUILT_IN_PROVIDER_IDS = Llms.BUILT_IN_PROVIDER_IDS;
+export const isBuiltInProviderId = Llms.isBuiltInProviderId;
+export const normalizeProviderId = Llms.normalizeProviderId;
+
+export type ProviderDefaultsConfig = ProviderDefaults;
+
+export const ProviderIdSchema = z
+	.string()
+	.min(1)
+	.regex(/^[a-z0-9][a-z0-9-]*$/i);
+
+export const ProviderProtocolSchema = z.enum([
+	"anthropic",
+	"gemini",
+	"openai-chat",
+	"openai-responses",
+	"openai-r1",
+	"ai-sdk",
+]);
+
+export const ProviderClientSchema = z.enum([
+	"anthropic",
+	"ai-sdk",
+	"ai-sdk-community",
+	"openai",
+	"openai-compatible",
+	"openai-r1",
+	"gemini",
+	"bedrock",
+	"custom",
+	"fetch",
+	"vertex",
+]);
+
+export const AuthSettingsSchema = z.object({
+	apiKey: z.string().optional(),
+	accessToken: z.string().optional(),
+	refreshToken: z.string().optional(),
+	expiresAt: z.number().int().positive().optional(),
+	accountId: z.string().optional(),
+});
+
+export type AuthSettings = z.infer<typeof AuthSettingsSchema>;
+
+const ReasoningLevelSchema = z.enum(["none", "low", "medium", "high", "xhigh"]);
+
+export const ReasoningSettingsSchema = z.object({
+	enabled: z.boolean().optional(),
+	effort: ReasoningLevelSchema.optional(),
+	budgetTokens: z.number().int().positive().optional(),
+});
+
+export type ReasoningSettings = z.infer<typeof ReasoningSettingsSchema>;
+
+export const AwsSettingsSchema = z.object({
+	accessKey: z.string().optional(),
+	secretKey: z.string().optional(),
+	sessionToken: z.string().optional(),
+	region: z.string().optional(),
+	profile: z.string().optional(),
+	authentication: z.enum(["iam", "api-key", "apikey", "profile"]).optional(),
+	usePromptCache: z.boolean().optional(),
+	useCrossRegionInference: z.boolean().optional(),
+	useGlobalInference: z.boolean().optional(),
+	endpoint: z.string().url().optional(),
+	customModelBaseId: z.string().optional(),
+});
+
+export type AwsSettings = z.infer<typeof AwsSettingsSchema>;
+
+export const GcpSettingsSchema = z.object({
+	projectId: z.string().optional(),
+	region: z.string().optional(),
+});
+
+export type GcpSettings = z.infer<typeof GcpSettingsSchema>;
+
+export const AzureSettingsSchema = z.object({
+	apiVersion: z.string().optional(),
+	useIdentity: z.boolean().optional(),
+});
+
+export type AzureSettings = z.infer<typeof AzureSettingsSchema>;
+
+export const SapSettingsSchema = z.object({
+	clientId: z.string().optional(),
+	clientSecret: z.string().optional(),
+	tokenUrl: z.string().url().optional(),
+	resourceGroup: z.string().optional(),
+	deploymentId: z.string().optional(),
+	useOrchestrationMode: z.boolean().optional(),
+	api: z.enum(["orchestration", "foundation-models"]).optional(),
+	defaultSettings: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type SapSettings = z.infer<typeof SapSettingsSchema>;
+
+export const OcaSettingsSchema = z.object({
+	mode: z.enum(["internal", "external"]).optional(),
+	usePromptCache: z.boolean().optional(),
+});
+
+export type OcaSettings = z.infer<typeof OcaSettingsSchema>;
+
+export const ModelCatalogSettingsSchema = z.object({
+	loadLatestOnInit: z.boolean().optional(),
+	loadPrivateOnAuth: z.boolean().optional(),
+	url: z.string().url().optional(),
+	cacheTtlMs: z.number().int().positive().optional(),
+	failOnError: z.boolean().optional(),
+});
+
+export type ModelCatalogSettings = z.infer<typeof ModelCatalogSettingsSchema>;
+export type ModelCatalogConfig = ModelCatalogSettings;
+
+export const ProviderSettingsSchema = z.object({
+	provider: ProviderIdSchema,
+	apiKey: z.string().optional(),
+	auth: AuthSettingsSchema.optional(),
+	model: z.string().optional(),
+	protocol: ProviderProtocolSchema.optional(),
+	client: ProviderClientSchema.optional(),
+	routingProviderId: ProviderIdSchema.optional(),
+	maxTokens: z.number().int().positive().optional(),
+	contextWindow: z.number().int().positive().optional(),
+	baseUrl: z.string().url().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	timeout: z.number().int().positive().optional(),
+	reasoning: ReasoningSettingsSchema.optional(),
+	aws: AwsSettingsSchema.optional(),
+	gcp: GcpSettingsSchema.optional(),
+	azure: AzureSettingsSchema.optional(),
+	sap: SapSettingsSchema.optional(),
+	oca: OcaSettingsSchema.optional(),
+	region: z.string().optional(),
+	apiLine: z.enum(["china", "international"]).optional(),
+	capabilities: z
+		.array(
+			z.enum([
+				"reasoning",
+				"prompt-cache",
+				"streaming",
+				"tools",
+				"vision",
+				"computer-use",
+				"oauth",
+				"popular",
+			]),
+		)
+		.optional(),
+	modelCatalog: ModelCatalogSettingsSchema.optional(),
+});
+
+export type ProviderSettings = z.infer<typeof ProviderSettingsSchema>;
+
+export interface ToProviderConfigOptions {
+	includeKnownModels?: boolean;
+}
+
+export function parseSettings(input: unknown): ProviderSettings {
+	return ProviderSettingsSchema.parse(input);
+}
+
+export function safeParseSettings(
+	input: unknown,
+): ReturnType<typeof ProviderSettingsSchema.safeParse> {
+	return ProviderSettingsSchema.safeParse(input);
+}
+
+function shouldRouteThroughOpenAIResponses(
+	settings: ProviderSettings,
+): boolean {
+	return (
+		settings.protocol === "openai-responses" || settings.client === "openai"
+	);
+}
+
+export function toProviderConfig(
+	settings: ProviderSettings,
+	options: ToProviderConfigOptions = {},
+): ProviderConfig {
+	const providerId = settings.provider as ProviderId;
+	const normalizedProviderId = normalizeProviderId(providerId);
+	const includeKnownModels = options.includeKnownModels !== false;
+	const unifiedReasoningLevel = settings.reasoning?.effort || "none";
+	const reasoningEffort =
+		unifiedReasoningLevel === "none" ? undefined : unifiedReasoningLevel;
+
+	const providerDefaults = OPENAI_COMPATIBLE_PROVIDERS[normalizedProviderId];
+	const generatedKnownModels = Object.assign(
+		{},
+		...Llms.resolveProviderModelCatalogKeys(normalizedProviderId).map(
+			(catalogKey) => Llms.getGeneratedModelsForProvider(catalogKey),
+		),
+	);
+	const generatedDefaultModelId = Object.keys(generatedKnownModels)[0];
+
+	const apiKey = getPersistedProviderApiKey(normalizedProviderId, settings);
+	const resolvedBaseUrl =
+		settings.baseUrl ??
+		(normalizedProviderId === "oca"
+			? settings.oca?.mode === "internal"
+				? DEFAULT_INTERNAL_OCA_BASE_URL
+				: DEFAULT_EXTERNAL_OCA_BASE_URL
+			: providerDefaults?.baseUrl);
+	const routingProviderId =
+		settings.routingProviderId ??
+		(shouldRouteThroughOpenAIResponses(settings) &&
+		normalizedProviderId !== BUILT_IN_PROVIDER.OPENAI_NATIVE
+			? BUILT_IN_PROVIDER.OPENAI_NATIVE
+			: undefined);
+
+	const knownModels = includeKnownModels
+		? (providerDefaults?.knownModels ??
+			(Object.keys(generatedKnownModels).length > 0
+				? generatedKnownModels
+				: undefined))
+		: undefined;
+
+	const config: ProviderConfig = {
+		providerId,
+		clientType: settings.client,
+		routingProviderId,
+		modelId:
+			settings.model ??
+			providerDefaults?.modelId ??
+			generatedDefaultModelId ??
+			"default",
+		...(includeKnownModels ? { knownModels } : {}),
+		apiKey,
+		accessToken: settings.auth?.accessToken,
+		refreshToken: settings.auth?.refreshToken,
+		accountId: settings.auth?.accountId,
+		baseUrl: resolvedBaseUrl,
+		headers: settings.headers,
+		timeoutMs: settings.timeout,
+		maxOutputTokens: settings.maxTokens,
+		maxInputTokens: settings.contextWindow,
+		thinking: settings.reasoning?.enabled,
+		reasoningEffort,
+		thinkingBudgetTokens: settings.reasoning?.budgetTokens,
+		region: settings.region ?? settings.aws?.region ?? settings.gcp?.region,
+		apiLine: settings.apiLine,
+		useCrossRegionInference: settings.aws?.useCrossRegionInference,
+		useGlobalInference: settings.aws?.useGlobalInference,
+		aws: settings.aws
+			? {
+					accessKey: settings.aws.accessKey,
+					secretKey: settings.aws.secretKey,
+					sessionToken: settings.aws.sessionToken,
+					authentication: settings.aws.authentication,
+					profile: settings.aws.profile,
+					usePromptCache: settings.aws.usePromptCache,
+					endpoint: settings.aws.endpoint,
+					customModelBaseId: settings.aws.customModelBaseId,
+				}
+			: undefined,
+		gcp: settings.gcp
+			? {
+					projectId: settings.gcp.projectId,
+					region: settings.gcp.region,
+				}
+			: undefined,
+		azure: settings.azure,
+		sap: settings.sap,
+		oca: settings.oca,
+		capabilities: (settings.capabilities ?? providerDefaults?.capabilities) as
+			| ProviderCapability[]
+			| undefined,
+		modelCatalog: settings.modelCatalog
+			? {
+					loadLatestOnInit: settings.modelCatalog.loadLatestOnInit,
+					loadPrivateOnAuth: settings.modelCatalog.loadPrivateOnAuth,
+					url: settings.modelCatalog.url,
+					cacheTtlMs: settings.modelCatalog.cacheTtlMs,
+					failOnError: settings.modelCatalog.failOnError,
+				}
+			: undefined,
+	};
+
+	return Object.fromEntries(
+		Object.entries(config).filter(([_, value]) => value !== undefined),
+	) as ProviderConfig;
+}
+
+export function createProviderConfig(input: unknown): ProviderConfig {
+	const settings = parseSettings(input);
+	return toProviderConfig(settings);
+}
+
+export function safeCreateProviderConfig(
+	input: unknown,
+):
+	| { success: true; config: ProviderConfig }
+	| { success: false; error: z.ZodError } {
+	const result = safeParseSettings(input);
+	if (result.success) {
+		return { success: true, config: toProviderConfig(result.data) };
+	}
+	return { success: false, error: result.error };
+}
diff --git a/sdk/packages/core/src/services/llms/runtime-config.ts b/sdk/packages/core/src/services/llms/runtime-config.ts
new file mode 100644
index 0000000..f2c953b
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/runtime-config.ts
@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { LlmsConfig } from "./runtime-types";
+
+export function defineLlmsConfig(config: LlmsConfig): LlmsConfig {
+	return config;
+}
+
+export async function loadLlmsConfigFromFile(
+	configPath: string,
+): Promise<LlmsConfig> {
+	const resolvedPath = path.resolve(configPath);
+	const raw = await readFile(resolvedPath, "utf8");
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		const details = error instanceof Error ? error.message : String(error);
+		throw new Error(
+			`Failed to parse JSON config at "${resolvedPath}": ${details}`,
+		);
+	}
+	return assertLlmsConfig(parsed, resolvedPath);
+}
+
+function assertLlmsConfig(value: unknown, source: string): LlmsConfig {
+	if (!value || typeof value !== "object") {
+		throw new Error(`Invalid llms config in "${source}": expected an object.`);
+	}
+	const config = value as Record<string, unknown>;
+	const providers = config.providers;
+	if (!Array.isArray(providers)) {
+		throw new Error(
+			`Invalid llms config in "${source}": "providers" must be an array.`,
+		);
+	}
+	if (!providers.length) {
+		throw new Error(
+			`Invalid llms config in "${source}": "providers" cannot be empty.`,
+		);
+	}
+	return value as LlmsConfig;
+}
diff --git a/sdk/packages/core/src/services/llms/runtime-registry.ts b/sdk/packages/core/src/services/llms/runtime-registry.ts
new file mode 100644
index 0000000..b90c5d0
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/runtime-registry.ts
@@ -0,0 +1,172 @@
+import type { ApiHandler } from "@cline/llms";
+import {
+	BUILT_IN_PROVIDER_IDS,
+	createHandler as createProviderHandler,
+	createHandlerAsync as createProviderHandlerAsync,
+	getProviderCollection,
+	hasProvider,
+	registerAsyncHandler,
+	registerHandler,
+	registerModel as registerModelInCatalog,
+	registerProvider as registerProviderInCatalog,
+} from "@cline/llms";
+import {
+	ConfiguredProviderRegistry,
+	toBuiltInProviderSummary,
+} from "./configured-provider-registry";
+import type {
+	BuiltInProviderSummary,
+	CreateHandlerInput,
+	LlmsConfig,
+	LlmsSdk,
+	RegisterBuiltinProviderInput,
+	RegisteredProviderSummary,
+	RegisterModelInput,
+	RegisterProviderInput,
+} from "./runtime-types";
+
+export class DefaultLlmsSdk implements LlmsSdk {
+	private readonly configuredProviders = new ConfiguredProviderRegistry();
+
+	constructor(config: LlmsConfig) {
+		this.applyConfig(config);
+	}
+
+	createHandler(input: CreateHandlerInput): ApiHandler {
+		return createProviderHandler(
+			this.configuredProviders.createHandlerConfig(input),
+		);
+	}
+
+	async createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler> {
+		return createProviderHandlerAsync(
+			this.configuredProviders.createHandlerConfig(input),
+		);
+	}
+
+	registerProvider(input: RegisterProviderInput): void {
+		registerProviderInCatalog(input.collection);
+		if (input.handlerFactory && input.asyncHandlerFactory) {
+			throw new Error(
+				`Provider "${input.collection.provider.id}" cannot register both sync and async handlers.`,
+			);
+		}
+		if (input.handlerFactory) {
+			registerHandler(input.collection.provider.id, input.handlerFactory);
+		}
+		if (input.asyncHandlerFactory) {
+			registerAsyncHandler(
+				input.collection.provider.id,
+				input.asyncHandlerFactory,
+			);
+		}
+		this.configuredProviders.register({
+			id: input.collection.provider.id,
+			models: input.exposeModels ?? Object.keys(input.collection.models),
+			defaultModel:
+				input.defaultModel ?? input.collection.provider.defaultModelId,
+			defaults: input.defaults,
+		});
+	}
+
+	registerBuiltinProvider(input: RegisterBuiltinProviderInput): void {
+		const exposedModels = input.exposeModels ?? Object.keys(input.models);
+		const defaultModel = input.defaultModel ?? exposedModels[0];
+		if (!defaultModel) {
+			throw new Error(`Provider "${input.id}" must define a default model.`);
+		}
+		registerProviderInCatalog({
+			provider: {
+				id: input.id,
+				name: input.name ?? input.id,
+				description: input.description,
+				protocol: input.protocol,
+				baseUrl: input.baseUrl,
+				defaultModelId: defaultModel,
+				client: input.client ?? "openai-compatible",
+				capabilities: input.capabilities,
+				env: input.env,
+				source: "system",
+			},
+			models: input.models,
+		});
+		this.configuredProviders.register({
+			id: input.id,
+			models: exposedModels,
+			defaultModel,
+			defaults: {
+				routingProviderId: input.builtinProviderId,
+				...(input.defaults ?? {}),
+			},
+		});
+	}
+
+	registerModel(input: RegisterModelInput): void {
+		registerModelInCatalog(input.providerId, input.modelId, input.info);
+		this.configuredProviders.registerModel(input.providerId, input.modelId);
+	}
+
+	getProviders(): RegisteredProviderSummary[] {
+		return this.configuredProviders.list();
+	}
+
+	getBuiltInProviderIds() {
+		return [...BUILT_IN_PROVIDER_IDS];
+	}
+
+	async getBuiltInProviders(): Promise<BuiltInProviderSummary[]> {
+		const collections = await Promise.all(
+			BUILT_IN_PROVIDER_IDS.map((providerId: string) =>
+				getProviderCollection(providerId),
+			),
+		);
+		return collections
+			.filter(
+				(collection): collection is NonNullable<typeof collection> =>
+					collection !== undefined,
+			)
+			.map((collection) => toBuiltInProviderSummary({ collection }));
+	}
+
+	getModels(providerId: string): string[] {
+		return this.configuredProviders.getModels(providerId);
+	}
+
+	isProviderConfigured(providerId: string): boolean {
+		return this.configuredProviders.hasProvider(providerId);
+	}
+
+	isModelConfigured(providerId: string, modelId: string): boolean {
+		return this.configuredProviders.hasModel(providerId, modelId);
+	}
+
+	private applyConfig(config: LlmsConfig): void {
+		for (const provider of config.providers) {
+			this.configuredProviders.registerSelectionConfig(provider);
+		}
+		for (const model of config.models ?? []) {
+			this.registerModel(model);
+		}
+		for (const provider of config.customProviders ?? []) {
+			this.registerProvider(provider);
+		}
+		for (const provider of this.configuredProviders.list()) {
+			const providerExists = hasProvider(provider.id);
+			const routedProviderId = this.configuredProviders.createHandlerConfig({
+				providerId: provider.id,
+				modelId: provider.defaultModel,
+			}).routingProviderId;
+			const routedProviderExists =
+				typeof routedProviderId === "string" && hasProvider(routedProviderId);
+			if (!providerExists && !routedProviderExists) {
+				throw new Error(
+					`Provider "${provider.id}" is not known. Register it through customProviders/registerProvider, registerBuiltinProvider, or use a built-in provider ID.`,
+				);
+			}
+		}
+	}
+}
+
+export function createLlmsSdk(config: LlmsConfig): LlmsSdk {
+	return new DefaultLlmsSdk(config);
+}
diff --git a/sdk/packages/core/src/services/llms/runtime-types.ts b/sdk/packages/core/src/services/llms/runtime-types.ts
new file mode 100644
index 0000000..e148d5c
--- /dev/null
+++ b/sdk/packages/core/src/services/llms/runtime-types.ts
@@ -0,0 +1,121 @@
+import type {
+	ApiHandler,
+	BuiltInProviderId,
+	HandlerFactory,
+	LazyHandlerFactory,
+	ModelCollection,
+	ModelInfo,
+	CatalogProviderCapability as ModelProviderCapability,
+	ProviderClient,
+	ProviderConfig,
+	ProviderInfo,
+	ProviderProtocol,
+} from "@cline/llms";
+import type { ProviderCapability } from "./provider-settings";
+
+export type ProviderConfigDefaults = Omit<
+	ProviderConfig,
+	"providerId" | "modelId"
+>;
+
+export interface ProviderSelectionConfig {
+	id: string;
+	models: string[];
+	defaultModel?: string;
+	builtinProviderId?: BuiltInProviderId;
+	apiKey?: string;
+	apiKeyEnv?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	timeoutMs?: number;
+	capabilities?: ProviderCapability[];
+	settings?: ProviderConfigDefaults;
+}
+
+export interface AdditionalModelConfig {
+	providerId: string;
+	modelId: string;
+	info: ModelInfo;
+}
+
+export interface CustomProviderConfig {
+	collection: ModelCollection;
+	defaults?: ProviderConfigDefaults;
+	handlerFactory?: HandlerFactory;
+	asyncHandlerFactory?: LazyHandlerFactory;
+}
+
+export interface LlmsConfig {
+	providers: ProviderSelectionConfig[];
+	models?: AdditionalModelConfig[];
+	customProviders?: CustomProviderConfig[];
+}
+
+export interface CreateHandlerInput {
+	providerId: string;
+	modelId?: string;
+	overrides?: ProviderConfigDefaults;
+}
+
+export interface RegisteredProviderSummary {
+	id: string;
+	models: string[];
+	defaultModel: string;
+}
+
+export interface BuiltInProviderSummary
+	extends Pick<
+		ProviderInfo,
+		| "id"
+		| "name"
+		| "description"
+		| "protocol"
+		| "baseUrl"
+		| "capabilities"
+		| "env"
+	> {
+	models: string[];
+	defaultModel: string;
+	modelCount: number;
+}
+
+export interface RegisterBuiltinProviderInput {
+	id: string;
+	builtinProviderId: BuiltInProviderId;
+	models: Record<string, ModelInfo>;
+	name?: string;
+	description?: string;
+	protocol?: ProviderProtocol;
+	baseUrl?: string;
+	client?: ProviderClient;
+	capabilities?: ModelProviderCapability[];
+	env?: string[];
+	defaultModel?: string;
+	defaults?: ProviderConfigDefaults;
+	exposeModels?: string[];
+}
+
+export interface RegisterProviderInput extends CustomProviderConfig {
+	exposeModels?: string[];
+	defaultModel?: string;
+}
+
+export interface RegisterModelInput {
+	providerId: string;
+	modelId: string;
+	info: ModelInfo;
+}
+
+export interface LlmsSdk {
+	createHandler(input: CreateHandlerInput): ApiHandler;
+	createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+	registerProvider(input: RegisterProviderInput): void;
+	registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+	registerModel(input: RegisterModelInput): void;
+	getProviders(): RegisteredProviderSummary[];
+	getBuiltInProviderIds(): BuiltInProviderId[];
+	getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+	getModels(providerId: string): string[];
+	isProviderConfigured(providerId: string): boolean;
+	isModelConfigured(providerId: string, modelId: string): boolean;
+}
diff --git a/sdk/packages/core/src/services/local-runtime-bootstrap.startup.test.ts b/sdk/packages/core/src/services/local-runtime-bootstrap.startup.test.ts
new file mode 100644
index 0000000..e639b74
--- /dev/null
+++ b/sdk/packages/core/src/services/local-runtime-bootstrap.startup.test.ts
@@ -0,0 +1,249 @@
+import type { ITelemetryService } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ProviderSettings } from "../types/provider-settings";
+
+function createProviderSettingsManager(settings?: ProviderSettings) {
+	return {
+		getProviderSettings: vi.fn(() => settings),
+	};
+}
+
+function createStartInput() {
+	return {
+		config: {
+			providerId: "cline",
+			modelId: "anthropic/claude-haiku-4.5",
+			apiKey: "test-key",
+			cwd: "/tmp/project-startup",
+			workspaceRoot: "/tmp/project-startup",
+			systemPrompt: "system",
+			mode: "act" as const,
+			enableTools: true,
+			enableSpawnAgent: true,
+			enableAgentTeams: true,
+		},
+	};
+}
+
+function createSpawnTool() {
+	return {
+		name: "spawn",
+		description: "",
+		inputSchema: {},
+		execute: vi.fn(),
+	};
+}
+
+function createTelemetryStub() {
+	const captureRequired = vi.fn();
+	const capture = vi.fn();
+	const telemetry = {
+		capture,
+		captureRequired,
+		setDistinctId: vi.fn(),
+		updateCommonProperties: vi.fn(),
+		identify: vi.fn(),
+	} as unknown as ITelemetryService;
+	return { telemetry, capture, captureRequired };
+}
+
+function findCapturedEvents(
+	capture: ReturnType<typeof vi.fn>,
+	event: string,
+): { event: string; properties: Record<string, unknown> }[] {
+	return capture.mock.calls
+		.map(
+			([arg]) => arg as { event: string; properties?: Record<string, unknown> },
+		)
+		.filter((arg) => arg.event === event)
+		.map((arg) => ({ event: arg.event, properties: arg.properties ?? {} }));
+}
+
+// These tests assert that prepareLocalRuntimeBootstrap drives the workspace
+// lifecycle telemetry funnel through the telemetry service it is given,
+// covering the wire-up that core-events.test.ts and workspace-telemetry.test.ts
+// only verify in isolation.
+describe("prepareLocalRuntimeBootstrap startup telemetry", () => {
+	beforeEach(async () => {
+		// Each test imports prepareLocalRuntimeBootstrap fresh after vi.resetModules
+		// so the workspace-telemetry de-duplication set is reset along with it.
+	});
+
+	afterEach(() => {
+		vi.resetModules();
+		vi.doUnmock("./workspace/workspace-manifest");
+	});
+
+	it("emits workspace.initialized via the provided telemetry service exactly once per process", async () => {
+		// Stub the manifest so the test does not depend on a real git repo.
+		vi.doMock("./workspace/workspace-manifest", () => ({
+			buildWorkspaceMetadataWithInfo: vi.fn(async (rootPath: string) => ({
+				workspaceInfo: {
+					rootPath,
+					git: undefined,
+					remotes: [],
+					branch: undefined,
+					commit: undefined,
+				},
+				workspaceMetadata: "",
+				durationMs: 12.5,
+				vcsType: "none" as const,
+				initError: undefined,
+			})),
+		}));
+
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const { telemetry, capture, captureRequired } = createTelemetryStub();
+
+		await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			sessionId: "sess-startup-1",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: telemetry,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		// Workspace lifecycle telemetry now goes through normal `capture` so
+		// it respects the user's telemetry opt-out setting.
+		expect(captureRequired).not.toHaveBeenCalled();
+
+		const initializedCalls = findCapturedEvents(
+			capture,
+			"workspace.initialized",
+		);
+		expect(initializedCalls).toHaveLength(1);
+		const firstInitialized = initializedCalls[0];
+		if (!firstInitialized) {
+			throw new Error("missing workspace.initialized capture");
+		}
+		const props = firstInitialized.properties;
+		expect(props).toMatchObject({
+			root_count: 1,
+			vcs_types: ["none"],
+			is_multi_root: false,
+			has_git: false,
+			has_mercurial: false,
+			feature_flag_enabled: true,
+		});
+		expect(typeof props.init_duration_ms).toBe("number");
+
+		// No diagnostics error in this scenario, so init_error must not fire.
+		const initErrorCalls = findCapturedEvents(capture, "workspace.init_error");
+		expect(initErrorCalls).toHaveLength(0);
+	});
+
+	it("emits workspace.init_error when workspace diagnostics report a failure", async () => {
+		vi.doMock("./workspace/workspace-manifest", () => ({
+			buildWorkspaceMetadataWithInfo: vi.fn(async (rootPath: string) => ({
+				workspaceInfo: {
+					rootPath,
+					git: undefined,
+					remotes: [],
+					branch: undefined,
+					commit: undefined,
+				},
+				workspaceMetadata: "",
+				durationMs: 7.25,
+				vcsType: "git" as const,
+				initError: {
+					errorType: "WorkspaceSetupError",
+					message: "git index unreadable",
+				},
+			})),
+		}));
+
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+		const { telemetry, capture, captureRequired } = createTelemetryStub();
+
+		const input = createStartInput();
+		// Use a different workspace path so the workspace-telemetry dedupe set
+		// (re-initialized by vi.resetModules) does not need to be cleared
+		// across describe blocks.
+		input.config.cwd = "/tmp/project-startup-error";
+		input.config.workspaceRoot = "/tmp/project-startup-error";
+
+		await prepareLocalRuntimeBootstrap({
+			input,
+			sessionId: "sess-startup-error",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: telemetry,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		// Workspace lifecycle telemetry now goes through normal `capture` so
+		// it respects the user's telemetry opt-out setting.
+		expect(captureRequired).not.toHaveBeenCalled();
+
+		const initializedCalls = findCapturedEvents(
+			capture,
+			"workspace.initialized",
+		);
+		expect(initializedCalls).toHaveLength(1);
+
+		const initErrorCalls = findCapturedEvents(capture, "workspace.init_error");
+		expect(initErrorCalls).toHaveLength(1);
+		const firstInitError = initErrorCalls[0];
+		if (!firstInitError) {
+			throw new Error("missing workspace.init_error capture");
+		}
+		const props = firstInitError.properties;
+		expect(props).toMatchObject({
+			error_type: "WorkspaceSetupError",
+			error_message: "git index unreadable",
+			fallback_to_single_root: true,
+			workspace_count: 1,
+		});
+	});
+
+	it("does not throw and emits no telemetry when no telemetry service is provided", async () => {
+		vi.doMock("./workspace/workspace-manifest", () => ({
+			buildWorkspaceMetadataWithInfo: vi.fn(async (rootPath: string) => ({
+				workspaceInfo: {
+					rootPath,
+					git: undefined,
+					remotes: [],
+					branch: undefined,
+					commit: undefined,
+				},
+				workspaceMetadata: "",
+				durationMs: 1,
+				vcsType: "none" as const,
+				initError: undefined,
+			})),
+		}));
+
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		await expect(
+			prepareLocalRuntimeBootstrap({
+				input: createStartInput(),
+				sessionId: "sess-startup-no-telemetry",
+				providerSettingsManager: createProviderSettingsManager() as never,
+				defaultTelemetry: undefined,
+				defaultToolPolicies: undefined,
+				onPluginEvent: () => {},
+				onTeamEvent: () => {},
+				createSpawnTool,
+				readSessionMetadata: async () => undefined,
+				writeSessionMetadata: async () => {},
+			}),
+		).resolves.toBeDefined();
+	});
+});
diff --git a/sdk/packages/core/src/services/local-runtime-bootstrap.test.ts b/sdk/packages/core/src/services/local-runtime-bootstrap.test.ts
new file mode 100644
index 0000000..7429ca0
--- /dev/null
+++ b/sdk/packages/core/src/services/local-runtime-bootstrap.test.ts
@@ -0,0 +1,685 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { version as corePackageVersion } from "../../package.json";
+import type { ProviderSettings } from "../types/provider-settings";
+
+function createProviderSettingsManager(settings?: ProviderSettings) {
+	return {
+		getProviderSettings: vi.fn(() => settings),
+	};
+}
+
+function createStartInput() {
+	return {
+		config: {
+			providerId: "cline",
+			modelId: "anthropic/claude-haiku-4.5",
+			apiKey: "test-key",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			systemPrompt: "system",
+			mode: "act" as const,
+			enableTools: true,
+			enableSpawnAgent: true,
+			enableAgentTeams: true,
+		},
+	};
+}
+
+function createSpawnTool() {
+	return {
+		name: "spawn",
+		description: "",
+		inputSchema: {},
+		execute: vi.fn(),
+	};
+}
+
+describe("prepareLocalRuntimeBootstrap", () => {
+	const previousGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+	let resetModulesAfterEach = false;
+
+	afterEach(() => {
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = previousGlobalSettingsPath;
+		vi.doUnmock("../extensions/plugin/plugin-config-loader");
+		if (resetModulesAfterEach) {
+			vi.resetModules();
+			resetModulesAfterEach = false;
+		}
+	});
+
+	it("applies hub model catalog defaults during local runtime bootstrap", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			localRuntime: {
+				modelCatalogDefaults: {
+					loadLatestOnInit: true,
+					loadPrivateOnAuth: true,
+				},
+			},
+			sessionId: "sess-1",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.modelCatalog).toMatchObject({
+			loadLatestOnInit: true,
+			loadPrivateOnAuth: true,
+		});
+	});
+
+	it("lets stored provider model catalog settings override hub defaults", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			localRuntime: {
+				modelCatalogDefaults: {
+					loadLatestOnInit: true,
+					loadPrivateOnAuth: true,
+				},
+			},
+			sessionId: "sess-1",
+			providerSettingsManager: createProviderSettingsManager({
+				provider: "cline",
+				model: "anthropic/claude-haiku-4.5",
+				modelCatalog: {
+					loadLatestOnInit: false,
+					loadPrivateOnAuth: false,
+				},
+			}) as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.modelCatalog).toMatchObject({
+			loadLatestOnInit: false,
+			loadPrivateOnAuth: false,
+		});
+	});
+
+	it("filters globally disabled plugin tools before extension setup", async () => {
+		vi.resetModules();
+		resetModulesAfterEach = true;
+		const tempRoot = mkdtempSync(join(tmpdir(), "local-bootstrap-global-"));
+		const settingsPath = join(tempRoot, "global-settings.json");
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+		writeFileSync(
+			settingsPath,
+			JSON.stringify({ disabledTools: ["blocked_tool"] }, null, 2),
+			"utf8",
+		);
+
+		vi.doMock("../extensions/plugin/plugin-config-loader", () => ({
+			resolveAndLoadAgentPlugins: vi.fn(async () => ({
+				extensions: [
+					{
+						name: "plugin-a",
+						manifest: { capabilities: ["tools"] },
+						setup: (api: {
+							registerTool: (tool: { name: string }) => void;
+						}) => {
+							api.registerTool({ name: "blocked_tool" });
+							api.registerTool({ name: "allowed_tool" });
+						},
+					},
+				],
+				failures: [],
+				pluginPaths: [],
+				warnings: [],
+			})),
+			resolvePluginSkillDirectoriesFromPaths: vi.fn(() => []),
+		}));
+
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			sessionId: "sess-1",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		const registeredTools: string[] = [];
+		const plugin = bootstrap.extensions?.find(
+			(extension) => extension.name === "plugin-a",
+		);
+		plugin?.setup?.(
+			{
+				registerTool: (tool: { name: string }) =>
+					registeredTools.push(tool.name),
+				registerCommand: () => {},
+				registerMessageBuilder: () => {},
+				registerRule: () => {},
+				registerProvider: () => {},
+				registerAutomationEventType: () => {},
+				registerMcpServer: () => {},
+			},
+			{},
+		);
+
+		expect(registeredTools).toEqual(["allowed_tool"]);
+	});
+
+	it("loads only provider/model-compatible plugins during bootstrap", async () => {
+		vi.resetModules();
+		resetModulesAfterEach = true;
+		vi.doMock("../extensions/plugin/plugin-config-loader", () => ({
+			resolveAndLoadAgentPlugins: vi.fn(
+				async ({
+					providerId,
+					modelId,
+				}: {
+					providerId?: string;
+					modelId?: string;
+				}) => ({
+					extensions:
+						providerId === "cline" && modelId === "anthropic/claude-haiku-4.5"
+							? [
+									{
+										name: "plugin-compatible",
+										manifest: {
+											capabilities: ["tools"],
+											providerIds: ["cline"],
+											modelIds: ["anthropic/claude-haiku-4.5"],
+										},
+										setup: (api: {
+											registerTool: (tool: { name: string }) => void;
+										}) => {
+											api.registerTool({ name: "compatible_tool" });
+										},
+									},
+								]
+							: [
+									{
+										name: "plugin-incompatible",
+										manifest: {
+											capabilities: ["tools"],
+											providerIds: ["openai"],
+											modelIds: ["gpt-5.4"],
+										},
+										setup: (api: {
+											registerTool: (tool: { name: string }) => void;
+										}) => {
+											api.registerTool({ name: "incompatible_tool" });
+										},
+									},
+								],
+					failures: [],
+					pluginPaths:
+						providerId === "cline" && modelId === "anthropic/claude-haiku-4.5"
+							? ["/tmp/compatible-plugin.js"]
+							: [],
+					warnings: [],
+				}),
+			),
+			resolvePluginSkillDirectoriesFromPaths: vi.fn(() => []),
+		}));
+
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			sessionId: "sess-1",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		const registeredTools: string[] = [];
+		const plugin = bootstrap.extensions?.find(
+			(extension) => extension.name === "plugin-compatible",
+		);
+		plugin?.setup?.(
+			{
+				registerTool: (tool: { name: string }) =>
+					registeredTools.push(tool.name),
+				registerCommand: () => {},
+				registerMessageBuilder: () => {},
+				registerRule: () => {},
+				registerProvider: () => {},
+				registerAutomationEventType: () => {},
+				registerMcpServer: () => {},
+			},
+			{},
+		);
+
+		expect(registeredTools).toEqual(["compatible_tool"]);
+	});
+
+	it("threads active plugin skill directories into the runtime builder input", async () => {
+		vi.resetModules();
+		resetModulesAfterEach = true;
+		const activePluginPath = "/tmp/review-plugin/index.js";
+		const activeSkillDirectory = "/tmp/review-plugin/skills";
+		const resolvePluginSkillDirectoriesFromPaths = vi.fn(() => [
+			activeSkillDirectory,
+		]);
+		vi.doMock("../extensions/plugin/plugin-config-loader", () => ({
+			resolveAndLoadAgentPlugins: vi.fn(async () => ({
+				extensions: [],
+				failures: [],
+				pluginPaths: [activePluginPath],
+				warnings: [],
+			})),
+			resolvePluginSkillDirectoriesFromPaths,
+		}));
+
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			localRuntime: {
+				configExtensions: ["plugins", "skills"],
+			},
+			sessionId: "sess-1",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(resolvePluginSkillDirectoriesFromPaths).toHaveBeenCalledWith([
+			activePluginPath,
+		]);
+		expect(bootstrap.runtimeBuilderInput.pluginSkillDirectories).toEqual([
+			activeSkillDirectory,
+		]);
+	});
+
+	it("threads defaultFetch into providerConfig.fetch", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const customFetch = vi.fn() as unknown as typeof fetch;
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			sessionId: "sess-fetch",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			defaultFetch: customFetch,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.fetch).toBe(customFetch);
+	});
+
+	it("prefers per-session config fetch over defaultFetch", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const defaultFetch = vi.fn() as unknown as typeof fetch;
+		const sessionFetch = vi.fn() as unknown as typeof fetch;
+		const input = createStartInput();
+		(input.config as unknown as { fetch?: typeof fetch }).fetch = sessionFetch;
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input,
+			sessionId: "sess-fetch-override",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			defaultFetch,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.fetch).toBe(sessionFetch);
+	});
+
+	it("leaves providerConfig.fetch unset when no fetch is supplied", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input: createStartInput(),
+			sessionId: "sess-no-fetch",
+			providerSettingsManager: createProviderSettingsManager() as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.fetch).toBeUndefined();
+	});
+
+	it.each([
+		"cline",
+		"cline-pass",
+	])("adds required source request headers for %s", async (providerId) => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const input = createStartInput();
+		input.config.providerId = providerId;
+		input.config.modelId =
+			providerId === "cline-pass"
+				? "cline-pass/test-model"
+				: "anthropic/claude-haiku-4.5";
+		const config = input.config as typeof input.config & {
+			headers: Record<string, string>;
+			providerConfig: {
+				providerId: string;
+				headers: Record<string, string>;
+			};
+		};
+		config.headers = {
+			"X-CLIENT-TYPE": "config-client",
+			"X-Task-ID": "config-task",
+			"x-config": "config",
+			"x-shared": "config-wins",
+		};
+		config.providerConfig = {
+			providerId,
+			headers: {
+				"X-CLIENT-VERSION": "provider-config-version",
+				"x-provider-config": "provider-config",
+			},
+		};
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input,
+			localRuntime: {
+				extensionContext: {
+					client: { name: "cline-cli", version: "3.0.38" },
+				},
+			},
+			sessionId: "sess-cline-headers",
+			providerSettingsManager: createProviderSettingsManager({
+				provider: providerId,
+				model: input.config.modelId,
+				headers: {
+					"X-CLIENT-TYPE": "stored-client",
+					"x-stored": "stored",
+					"x-shared": "stored-loses",
+				},
+			}) as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.headers).toMatchObject({
+			"HTTP-Referer": "https://cline.bot",
+			"X-Title": "Cline",
+			"User-Agent": "Cline/3.0.38",
+			"X-IS-MULTIROOT": "false",
+			"X-CLIENT-TYPE": "cline-cli",
+			"X-CLIENT-VERSION": "3.0.38",
+			"X-PLATFORM": "cli",
+			"X-PLATFORM-VERSION": "3.0.38",
+			"X-CORE-VERSION": corePackageVersion,
+			"X-Task-ID": "sess-cline-headers",
+			"x-config": "config",
+			"x-provider-config": "provider-config",
+			"x-shared": "config-wins",
+			"x-stored": "stored",
+		});
+	});
+
+	it("uses host request headers for Cline providers on core sessions", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const input = {
+			...createStartInput(),
+			source: "core" as const,
+		};
+		const config = input.config as typeof input.config & {
+			headers: Record<string, string>;
+		};
+		config.headers = { "x-config": "config" };
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input,
+			localRuntime: {
+				extensionContext: {
+					client: {
+						name: "VSCode Extension",
+						version: "9.9.9",
+						platform: "Visual Studio Code",
+						platformVersion: "1.103.0",
+						isMultiRoot: true,
+					},
+				},
+			},
+			sessionId: "sess-non-cli",
+			providerSettingsManager: createProviderSettingsManager({
+				provider: "cline",
+				model: input.config.modelId,
+				headers: {
+					"x-stored": "stored",
+				},
+			}) as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.headers).toMatchObject({
+			"HTTP-Referer": "https://cline.bot",
+			"X-Title": "Cline",
+			"User-Agent": "Cline/9.9.9",
+			"X-IS-MULTIROOT": "true",
+			"X-CLIENT-TYPE": "VSCode Extension",
+			"X-CLIENT-VERSION": "9.9.9",
+			"X-PLATFORM": "Visual Studio Code",
+			"X-PLATFORM-VERSION": "1.103.0",
+			"X-CORE-VERSION": corePackageVersion,
+			"X-Task-ID": "sess-non-cli",
+			"x-config": "config",
+			"x-stored": "stored",
+		});
+	});
+
+	it("adds Codex backend headers for openai-codex from stored OAuth settings", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const input = createStartInput();
+		input.config.providerId = "openai-codex";
+		input.config.modelId = "gpt-5.4";
+		input.config.apiKey = "oauth-access-token";
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input,
+			sessionId: "sess-codex",
+			providerSettingsManager: createProviderSettingsManager({
+				provider: "openai-codex",
+				model: "gpt-5.4",
+				auth: {
+					accessToken: "oauth-access-token",
+					accountId: "acct-123",
+				},
+				headers: {
+					"x-stored": "stored",
+				},
+			}) as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.headers).toMatchObject({
+			originator: "cline",
+			session_id: "sess-codex",
+			"ChatGPT-Account-Id": "acct-123",
+			"x-stored": "stored",
+		});
+	});
+
+	it("keeps Codex-controlled headers from being overridden by stored or config headers", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const input = createStartInput();
+		input.config.providerId = "openai-codex";
+		input.config.modelId = "gpt-5.4";
+		input.config.apiKey = "oauth-access-token";
+		const config = input.config as typeof input.config & {
+			headers: Record<string, string>;
+		};
+		config.headers = {
+			originator: "config-originator",
+			session_id: "config-session",
+			"User-Agent": "ConfigAgent/0",
+			"ChatGPT-Account-Id": "config-account",
+			"x-config": "config",
+			"x-shared": "config-wins",
+		};
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input,
+			sessionId: "sess-codex-invariants",
+			providerSettingsManager: createProviderSettingsManager({
+				provider: "openai-codex",
+				model: "gpt-5.4",
+				auth: {
+					accessToken: "oauth-access-token",
+					accountId: "acct-stored",
+				},
+				headers: {
+					originator: "stored-originator",
+					session_id: "stored-session",
+					"User-Agent": "StoredAgent/0",
+					"ChatGPT-Account-Id": "stored-account",
+					"x-stored": "stored",
+					"x-shared": "stored-loses",
+				},
+			}) as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.headers).toMatchObject({
+			originator: "cline",
+			session_id: "sess-codex-invariants",
+			"ChatGPT-Account-Id": "acct-stored",
+			"x-config": "config",
+			"x-stored": "stored",
+			"x-shared": "config-wins",
+		});
+		expect(bootstrap.providerConfig.headers?.["User-Agent"]).toMatch(
+			/^Cline\//,
+		);
+	});
+
+	it("derives Codex account id from the OAuth access token when not persisted", async () => {
+		const { prepareLocalRuntimeBootstrap } = await import(
+			"./local-runtime-bootstrap"
+		);
+
+		const payload = Buffer.from(
+			JSON.stringify({
+				"https://api.openai.com/auth": {
+					chatgpt_account_id: "acct-derived",
+				},
+			}),
+			"utf8",
+		).toString("base64url");
+		const token = `header.${payload}.sig`;
+
+		const input = createStartInput();
+		input.config.providerId = "openai-codex";
+		input.config.modelId = "gpt-5.4";
+		input.config.apiKey = token;
+
+		const bootstrap = await prepareLocalRuntimeBootstrap({
+			input,
+			sessionId: "sess-codex-derived",
+			providerSettingsManager: createProviderSettingsManager({
+				provider: "openai-codex",
+				model: "gpt-5.4",
+				auth: {
+					accessToken: token,
+				},
+			}) as never,
+			defaultTelemetry: undefined,
+			defaultToolPolicies: undefined,
+			onPluginEvent: () => {},
+			onTeamEvent: () => {},
+			createSpawnTool,
+			readSessionMetadata: async () => undefined,
+			writeSessionMetadata: async () => {},
+		});
+
+		expect(bootstrap.providerConfig.headers).toMatchObject({
+			originator: "cline",
+			session_id: "sess-codex-derived",
+			"ChatGPT-Account-Id": "acct-derived",
+		});
+	});
+});
diff --git a/sdk/packages/core/src/services/local-runtime-bootstrap.ts b/sdk/packages/core/src/services/local-runtime-bootstrap.ts
new file mode 100644
index 0000000..83f978d
--- /dev/null
+++ b/sdk/packages/core/src/services/local-runtime-bootstrap.ts
@@ -0,0 +1,529 @@
+import type {
+	AgentConfig,
+	AgentEvent,
+	AgentHooks,
+	AgentTool,
+	ExtensionContext,
+	ITelemetryService,
+	RuntimeConfigExtensionKind,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	WorkspaceInfo,
+} from "@cline/shared";
+import {
+	buildClineClientRequestHeaders,
+	hasRuntimeConfigExtension,
+} from "@cline/shared";
+import { version as corePackageVersion } from "../../package.json";
+import { decodeJwtPayload } from "../auth/utils";
+import {
+	resolveAndLoadAgentPlugins,
+	resolvePluginSkillDirectoriesFromPaths,
+} from "../extensions/plugin/plugin-config-loader";
+import type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+} from "../extensions/plugin/plugin-load-report";
+import type {
+	SubAgentEndContext,
+	SubAgentStartContext,
+	TeamEvent,
+} from "../extensions/tools/team";
+import { createCheckpointHooks } from "../hooks/checkpoint-hooks";
+import {
+	createHookAuditHooks,
+	createHookConfigFileExtension,
+	mergeAgentHooks,
+} from "../hooks/hook-file-hooks";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import { normalizeRuntimeCapabilities } from "../runtime/capabilities";
+import type {
+	LocalRuntimeStartOptions,
+	StartSessionInput,
+} from "../runtime/host/runtime-host";
+import type { RuntimeBuilderInput } from "../runtime/orchestration/session-runtime";
+import { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import {
+	type ProviderConfig,
+	type ProviderSettings,
+	toProviderConfig,
+} from "../types/provider-settings";
+import { resolveWorkspacePath } from "./config";
+import { filterExtensionToolRegistrations } from "./global-settings";
+import { hasRuntimeHooks, mergeAgentExtensions } from "./session-data";
+import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
+import { InMemoryWorkspaceManager } from "./workspace/workspace-manager";
+import { buildWorkspaceMetadataWithInfo } from "./workspace/workspace-manifest";
+import { emitWorkspaceLifecycleTelemetry } from "./workspace/workspace-telemetry";
+
+function formatPluginFailure(failure: PluginInitializationFailure): string {
+	const label = failure.pluginName ?? failure.pluginPath;
+	return `${label}: ${failure.message}`;
+}
+
+function logPluginDiagnostics(
+	failures: PluginInitializationFailure[],
+	warnings: PluginInitializationWarning[],
+	logger: CoreSessionConfig["logger"],
+): void {
+	if (warnings.length > 0) {
+		for (const warning of warnings) {
+			logger?.log(warning.message, { severity: "warn" });
+		}
+	}
+	if (failures.length === 0) {
+		return;
+	}
+	const preview = failures.slice(0, 3).map(formatPluginFailure).join("; ");
+	const suffix = failures.length > 3 ? `; and ${failures.length - 3} more` : "";
+	logger?.log(
+		`Some plugins failed to initialize. ${preview}${suffix}. Use --verbose for more details.`,
+		{ severity: "warn" },
+	);
+	for (const failure of failures) {
+		logger?.log(
+			`Plugin initialization failed (${failure.phase}) for ${failure.pluginPath}`,
+			{
+				severity: "warn",
+				stack: failure.stack,
+				pluginPath: failure.pluginPath,
+				pluginName: failure.pluginName,
+			},
+		);
+	}
+}
+
+function resolveReasoningSettings(
+	config: CoreSessionConfig,
+	storedReasoning: ProviderSettings["reasoning"],
+): ProviderSettings["reasoning"] {
+	const hasThinking = typeof config.thinking === "boolean";
+	const hasEffort = typeof config.reasoningEffort === "string";
+	if (!hasThinking && !hasEffort) return storedReasoning;
+	return {
+		...(storedReasoning ?? {}),
+		...(hasThinking ? { enabled: config.thinking } : {}),
+		...(hasEffort ? { effort: config.reasoningEffort } : {}),
+	};
+}
+
+function hasConfigExtension(
+	extensions: ReadonlyArray<RuntimeConfigExtensionKind> | undefined,
+	kind: RuntimeConfigExtensionKind,
+): boolean {
+	return hasRuntimeConfigExtension(extensions, kind);
+}
+
+function countSeededRootRuns(
+	messages: StartSessionInput["initialMessages"],
+): number {
+	let count = 0;
+	for (const message of messages ?? []) {
+		if (message.role !== "user") continue;
+		const metadata =
+			"metadata" in message &&
+			message.metadata &&
+			typeof message.metadata === "object" &&
+			!Array.isArray(message.metadata)
+				? (message.metadata as Record<string, unknown>)
+				: undefined;
+		if (metadata?.kind === "recovery_notice") continue;
+		count += 1;
+	}
+	return count;
+}
+
+function buildOpenAICodexHeaders(input: {
+	sessionId: string;
+	configHeaders: CoreSessionConfig["headers"];
+	storedHeaders: ProviderSettings["headers"];
+	accountId?: string;
+	accessToken?: string;
+}): Record<string, string> | undefined {
+	const headers: Record<string, string> = {
+		...(input.storedHeaders ?? {}),
+		...(input.configHeaders ?? {}),
+	};
+	const resolvedAccountId =
+		input.accountId?.trim() || deriveOpenAICodexAccountId(input.accessToken);
+	headers.originator = "cline";
+	headers.session_id = input.sessionId;
+	headers["User-Agent"] = `Cline/${process.env.npm_package_version || "1.0.0"}`;
+	if (resolvedAccountId) {
+		headers["ChatGPT-Account-Id"] = resolvedAccountId;
+	}
+	return headers;
+}
+
+function deriveOpenAICodexAccountId(
+	accessToken: string | undefined,
+): string | undefined {
+	const trimmed = accessToken?.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	const payload = decodeJwtPayload(trimmed) as {
+		"https://api.openai.com/auth"?: { chatgpt_account_id?: string };
+		organizations?: Array<{ id?: string }>;
+		chatgpt_account_id?: string;
+	} | null;
+	const authAccountId =
+		payload?.["https://api.openai.com/auth"]?.chatgpt_account_id;
+	if (typeof authAccountId === "string" && authAccountId.length > 0) {
+		return authAccountId;
+	}
+	const orgAccountId = payload?.organizations?.[0]?.id;
+	if (typeof orgAccountId === "string" && orgAccountId.length > 0) {
+		return orgAccountId;
+	}
+	const rootAccountId = payload?.chatgpt_account_id;
+	if (typeof rootAccountId === "string" && rootAccountId.length > 0) {
+		return rootAccountId;
+	}
+	return undefined;
+}
+
+function buildProviderConfig(
+	config: CoreSessionConfig,
+	sessionId: string,
+	source: StartSessionInput["source"],
+	providerSettingsManager: ProviderSettingsManager,
+	modelCatalogDefaults?: Partial<ProviderSettings["modelCatalog"]>,
+	defaultFetch?: typeof fetch,
+): ProviderConfig {
+	const stored = providerSettingsManager.getProviderSettings(config.providerId);
+	const modelCatalog =
+		modelCatalogDefaults || stored?.modelCatalog
+			? {
+					...(modelCatalogDefaults ?? {}),
+					...(stored?.modelCatalog ?? {}),
+				}
+			: undefined;
+	const sessionProviderConfig =
+		config.providerConfig?.providerId === config.providerId
+			? config.providerConfig
+			: undefined;
+	const clineClientHeaders = buildClineClientRequestHeaders({
+		providerId: config.providerId,
+		sessionId,
+		source,
+		defaultSource: SessionSource.CLI,
+		clientName: config.extensionContext?.client?.name,
+		clientVersion: config.extensionContext?.client?.version,
+		clientVersionHeaderFallback: config.headers?.["X-CLIENT-VERSION"],
+		platform: config.extensionContext?.client?.platform,
+		platformVersion: config.extensionContext?.client?.platformVersion,
+		isMultiRoot: config.extensionContext?.client?.isMultiRoot,
+		coreVersion: corePackageVersion,
+	});
+	// TODO: (bee) Move header resolution logic into @cline/llms
+	const resolvedHeaders =
+		config.providerId === "openai-codex"
+			? buildOpenAICodexHeaders({
+					sessionId,
+					configHeaders: config.headers,
+					storedHeaders: stored?.headers,
+					accountId: stored?.auth?.accountId,
+					accessToken:
+						config.apiKey ?? stored?.auth?.accessToken ?? stored?.apiKey,
+				})
+			: clineClientHeaders
+				? {
+						...(stored?.headers ?? {}),
+						...(config.headers ?? {}),
+						...clineClientHeaders,
+					}
+				: (config.headers ?? stored?.headers);
+	const settings: ProviderSettings = {
+		...(stored ?? {}),
+		provider: config.providerId,
+		model: config.modelId,
+		apiKey: config.apiKey ?? stored?.apiKey,
+		baseUrl: config.baseUrl ?? stored?.baseUrl,
+		headers: resolvedHeaders,
+		reasoning: resolveReasoningSettings(config, stored?.reasoning),
+		modelCatalog,
+	};
+	const providerConfig: ProviderConfig = {
+		...toProviderConfig(settings),
+		...(sessionProviderConfig ?? {}),
+	};
+	if (clineClientHeaders) {
+		providerConfig.headers = {
+			...(resolvedHeaders ?? {}),
+			...(sessionProviderConfig?.headers ?? {}),
+			...clineClientHeaders,
+		};
+	}
+	if (config.knownModels) {
+		providerConfig.knownModels = config.knownModels;
+	}
+	if (config.extensionContext) {
+		providerConfig.extensionContext = config.extensionContext;
+	}
+	// Thread a host-provided custom fetch through to the AI gateway providers.
+	// Precedence: explicit per-session config > stored provider settings > host default.
+	const sessionFetch = (config as { fetch?: typeof fetch }).fetch;
+	const resolvedFetch = sessionFetch ?? providerConfig.fetch ?? defaultFetch;
+	if (resolvedFetch) {
+		providerConfig.fetch = resolvedFetch;
+	}
+	return providerConfig;
+}
+
+export interface PrepareLocalRuntimeBootstrapOptions {
+	input: StartSessionInput;
+	localRuntime?: LocalRuntimeStartOptions;
+	sessionId: string;
+	providerSettingsManager: ProviderSettingsManager;
+	defaultTelemetry?: ITelemetryService;
+	defaultCapabilities?: RuntimeCapabilities;
+	defaultToolPolicies?: AgentConfig["toolPolicies"];
+	/**
+	 * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+	 * AI gateway providers can use a custom HTTP implementation.
+	 */
+	defaultFetch?: typeof fetch;
+	onPluginEvent: (event: { name: string; payload?: unknown }) => void;
+	onTeamEvent: (event: TeamEvent) => void;
+	createSubAgentLifecycleCallbacks?: (config: CoreSessionConfig) => {
+		onSubAgentEvent?: (event: AgentEvent) => void;
+		onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+		onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+	};
+	createSpawnTool: () => AgentTool;
+	readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+	writeSessionMetadata: (
+		metadata: Record<string, unknown>,
+	) => Promise<void> | void;
+}
+
+export interface LocalRuntimeBootstrap {
+	effectiveInput: StartSessionInput;
+	config: CoreSessionConfig;
+	providerConfig: ProviderConfig;
+	workspaceMetadata: string;
+	/** Structured git + path metadata generated alongside workspaceMetadata. */
+	workspaceInfo: WorkspaceInfo;
+	extensions: AgentConfig["extensions"];
+	hooks: AgentHooks | undefined;
+	toolPolicies: AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+	pluginSandboxShutdown?: () => Promise<void>;
+	runtimeBuilderInput: RuntimeBuilderInput;
+}
+
+export async function prepareLocalRuntimeBootstrap(
+	options: PrepareLocalRuntimeBootstrapOptions,
+): Promise<LocalRuntimeBootstrap> {
+	const {
+		input,
+		sessionId,
+		providerSettingsManager,
+		defaultTelemetry,
+		defaultCapabilities,
+		defaultToolPolicies,
+		defaultFetch,
+		onPluginEvent,
+		onTeamEvent,
+		createSubAgentLifecycleCallbacks,
+		createSpawnTool,
+		localRuntime,
+		readSessionMetadata,
+		writeSessionMetadata,
+	} = options;
+	const workspacePath = resolveWorkspacePath(input.config);
+	const {
+		modelCatalogDefaults,
+		userInstructionService,
+		configExtensions,
+		onTeamRestored,
+		...localConfigFields
+	} = localRuntime ?? {};
+	const localConfig =
+		Object.keys(localConfigFields).length > 0
+			? (localConfigFields as Partial<CoreSessionConfig>)
+			: undefined;
+
+	// Generate workspace + git metadata once, early, so it can be forwarded to
+	// hooks and extensions. The serialized string goes into CoreSessionConfig
+	// as workspaceMetadata; the structured object is kept as workspaceInfo.
+	const { workspaceInfo, workspaceMetadata, durationMs, vcsType, initError } =
+		await buildWorkspaceMetadataWithInfo(workspacePath);
+	const configuredExtensionContext = localConfig?.extensionContext;
+	const extensionContext: ExtensionContext = {
+		...(configuredExtensionContext ?? {}),
+		workspace: {
+			...workspaceInfo,
+			...(configuredExtensionContext?.workspace ?? {}),
+		},
+		session: {
+			...(configuredExtensionContext?.session ?? {}),
+			sessionId,
+		},
+		logger: configuredExtensionContext?.logger ?? localConfig?.logger,
+		telemetry:
+			configuredExtensionContext?.telemetry ??
+			localConfig?.telemetry ??
+			defaultTelemetry,
+	};
+	emitWorkspaceLifecycleTelemetry({
+		telemetry: extensionContext.telemetry,
+		rootPath: workspaceInfo.rootPath,
+		workspaceInfo,
+		rootCount: 1,
+		vcsType,
+		durationMs,
+		initError,
+		featureFlagEnabled: true,
+	});
+
+	const fileHookExtension = createHookConfigFileExtension({
+		cwd: input.config.cwd,
+		workspacePath,
+		rootSessionId: sessionId,
+		logger: localConfig?.logger,
+		workspaceInfo,
+	});
+	const auditHooks = hasRuntimeHooks(localConfig?.hooks)
+		? undefined
+		: createHookAuditHooks({
+				rootSessionId: sessionId,
+				workspacePath,
+				workspaceInfo,
+			});
+	const baseHooks = mergeAgentHooks([localConfig?.hooks, auditHooks]);
+
+	let loadedPlugins:
+		| Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
+		| undefined;
+	if (hasConfigExtension(configExtensions, "plugins")) {
+		try {
+			loadedPlugins = await resolveAndLoadAgentPlugins({
+				pluginPaths: localConfig?.pluginPaths,
+				workspacePath,
+				cwd: input.config.cwd,
+				onEvent: onPluginEvent,
+				providerId: input.config.providerId,
+				modelId: input.config.modelId,
+				workspaceInfo,
+				session: extensionContext.session,
+				client: extensionContext.client,
+				user: extensionContext.user,
+				logger: extensionContext.logger,
+				telemetry: extensionContext.telemetry,
+				automation: extensionContext.automation,
+			});
+			logPluginDiagnostics(
+				loadedPlugins.failures,
+				loadedPlugins.warnings,
+				localConfig?.logger,
+			);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			localConfig?.logger?.log?.(
+				`plugin loading failed; continuing without plugins (${message})`,
+			);
+		}
+	}
+
+	const builtInExtensions = fileHookExtension ? [fileHookExtension] : undefined;
+	const extensions = mergeAgentExtensions(
+		builtInExtensions,
+		mergeAgentExtensions(
+			localConfig?.extensions,
+			filterExtensionToolRegistrations(loadedPlugins?.extensions),
+		),
+	);
+	const pluginSkillDirectories = hasConfigExtension(configExtensions, "plugins")
+		? resolvePluginSkillDirectoriesFromPaths(loadedPlugins?.pluginPaths ?? [])
+		: undefined;
+	const baseConfig: CoreSessionConfig = {
+		...input.config,
+		...(localConfig ?? {}),
+		sessionId,
+		hooks: baseHooks,
+		extensions,
+		extensionContext,
+		telemetry: extensionContext.telemetry,
+	};
+	const providerConfig = buildProviderConfig(
+		baseConfig,
+		sessionId,
+		input.source,
+		providerSettingsManager,
+		modelCatalogDefaults,
+		defaultFetch,
+	);
+	const hooks = mergeAgentHooks([
+		baseConfig.hooks,
+		baseConfig.checkpoint?.enabled === true
+			? createCheckpointHooks({
+					cwd: baseConfig.cwd,
+					sessionId,
+					logger: baseConfig.logger,
+					createCheckpoint: baseConfig.checkpoint?.createCheckpoint,
+					initialRunCount: countSeededRootRuns(input.initialMessages),
+					readSessionMetadata,
+					writeSessionMetadata,
+				})
+			: undefined,
+	]);
+	const config: CoreSessionConfig = {
+		...baseConfig,
+		providerConfig,
+		workspaceMetadata,
+		hooks,
+	};
+	const toolPolicies =
+		input.toolPolicies ?? baseConfig.toolPolicies ?? defaultToolPolicies;
+	const capabilities = normalizeRuntimeCapabilities(
+		defaultCapabilities,
+		input.capabilities,
+	);
+	const requestToolApproval = capabilities?.requestToolApproval;
+	const effectiveToolExecutors = capabilities?.toolExecutors;
+	const subAgentLifecycleCallbacks = createSubAgentLifecycleCallbacks?.(config);
+	const workspaceManager = new InMemoryWorkspaceManager({
+		currentWorkspacePath: workspaceInfo.rootPath,
+		workspaces: {
+			[workspaceInfo.rootPath]: workspaceInfo,
+		},
+	});
+
+	return {
+		effectiveInput: input,
+		config,
+		providerConfig,
+		workspaceMetadata,
+		workspaceInfo,
+		extensions,
+		hooks,
+		toolPolicies,
+		requestToolApproval,
+		pluginSandboxShutdown: loadedPlugins?.shutdown,
+		runtimeBuilderInput: {
+			config,
+			hooks,
+			extensions,
+			onTeamEvent,
+			createSpawnTool,
+			onTeamRestored: onTeamRestored,
+			onSubAgentEvent: subAgentLifecycleCallbacks?.onSubAgentEvent,
+			onSubAgentStart: subAgentLifecycleCallbacks?.onSubAgentStart,
+			onSubAgentEnd: subAgentLifecycleCallbacks?.onSubAgentEnd,
+			userInstructionService: userInstructionService,
+			pluginSkillDirectories,
+			configExtensions: configExtensions,
+			toolExecutors: effectiveToolExecutors,
+			toolPolicies,
+			workspaceManager,
+			logger: config.logger,
+			telemetry: config.telemetry,
+			requestToolApproval,
+		},
+	};
+}
diff --git a/sdk/packages/core/src/services/marketplace.test.ts b/sdk/packages/core/src/services/marketplace.test.ts
new file mode 100644
index 0000000..8dc2457
--- /dev/null
+++ b/sdk/packages/core/src/services/marketplace.test.ts
@@ -0,0 +1,190 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setClineDir, setHomeDir } from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { uninstallMarketplaceEntry } from "./marketplace";
+
+describe("marketplace service", () => {
+	let root = "";
+	let home = "";
+	let originalHome: string | undefined;
+	let originalClineDir: string | undefined;
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "core-marketplace-"));
+		home = join(root, "home");
+		originalHome = process.env.HOME;
+		originalClineDir = process.env.CLINE_DIR;
+		process.env.HOME = home;
+		process.env.CLINE_DIR = join(home, ".cline");
+		setHomeDir(home);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = originalHome;
+		}
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR;
+		} else {
+			process.env.CLINE_DIR = originalClineDir;
+		}
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	it("uninstalls marketplace MCP servers from settings by default", async () => {
+		const settingsPath = join(root, "cline_mcp_settings.json");
+		await writeFile(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						context7: { transport: { type: "stdio", command: "node" } },
+						other: { transport: { type: "stdio", command: "node" } },
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const result = await uninstallMarketplaceEntry(
+			{
+				id: "context7",
+				type: "mcp",
+				name: "Context7",
+				install: { args: ["context7", "node", "server.js"] },
+			},
+			{ mcpSettingsPath: settingsPath },
+		);
+
+		expect(result).toMatchObject({
+			id: "context7",
+			type: "mcp",
+			status: "uninstalled",
+			message: "Uninstalled Context7.",
+		});
+		const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, unknown>;
+		};
+		expect(settings.mcpServers?.context7).toBeUndefined();
+		expect(settings.mcpServers?.other).toBeDefined();
+	});
+
+	it("uninstalls marketplace skills through skills CLI remove", async () => {
+		const skillDir = join(home, ".agents", "skills", "review-team");
+		await mkdir(skillDir, { recursive: true });
+		await writeFile(
+			join(skillDir, "SKILL.md"),
+			"---\nname: Review\n---\n",
+			"utf8",
+		);
+		const calls: Array<{ command: string; args: string[] }> = [];
+
+		const result = await uninstallMarketplaceEntry(
+			{
+				id: "review-team",
+				type: "skill",
+				name: "Review Team",
+				install: {
+					args: ["github.com/cline/skills@review-team"],
+				},
+			},
+			{
+				spawnCommand: async (command, args) => {
+					calls.push({ command, args });
+					rmSync(skillDir, { recursive: true, force: true });
+					return { exitCode: 0, stdout: "removed", stderr: "" };
+				},
+			},
+		);
+
+		expect(result).toMatchObject({
+			id: "review-team",
+			type: "skill",
+			status: "uninstalled",
+			message: "Uninstalled Review Team.",
+		});
+		expect(calls).toEqual([
+			{
+				command: "npx",
+				args: ["-y", "skills@latest", "remove", "review-team", "-g", "-y"],
+			},
+		]);
+		expect(existsSync(skillDir)).toBe(false);
+	});
+
+	it("cleans up remaining marketplace skill directories after skills CLI remove succeeds", async () => {
+		const clineSkillDir = join(
+			process.env.CLINE_DIR ?? "",
+			"skills",
+			"review-team",
+		);
+		await mkdir(clineSkillDir, { recursive: true });
+		await writeFile(join(clineSkillDir, "SKILL.md"), "# Review Team", "utf8");
+
+		const result = await uninstallMarketplaceEntry(
+			{
+				id: "review-team",
+				type: "skill",
+				name: "Review Team",
+				install: { args: ["github.com/cline/skills@review-team"] },
+			},
+			{
+				spawnCommand: async () => ({
+					exitCode: 0,
+					stdout: "removed",
+					stderr: "",
+				}),
+			},
+		);
+
+		expect(result.status).toBe("uninstalled");
+		expect(result.output).toContain(`Removed: ${clineSkillDir}`);
+		expect(existsSync(clineSkillDir)).toBe(false);
+	});
+
+	it("uninstalls official marketplace plugins by marketplace slug", async () => {
+		const installPath = join(
+			home,
+			".cline",
+			"plugins",
+			"_installed",
+			"official",
+			"goal-123456789abc",
+		);
+		const entryPath = join(installPath, "package", "index.ts");
+		await mkdir(join(installPath, "package"), { recursive: true });
+		await writeFile(
+			join(installPath, "package.json"),
+			JSON.stringify({ name: "goal" }, null, 2),
+			"utf8",
+		);
+		await writeFile(
+			entryPath,
+			"export default { name: 'goal', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const result = await uninstallMarketplaceEntry({
+			id: "goal",
+			type: "plugin",
+			name: "Goal",
+			install: { args: ["goal"] },
+		});
+
+		expect(result).toMatchObject({
+			id: "goal",
+			type: "plugin",
+			status: "uninstalled",
+			message: "Uninstalled Goal.",
+		});
+		expect(existsSync(installPath)).toBe(false);
+	});
+});
diff --git a/sdk/packages/core/src/services/marketplace.ts b/sdk/packages/core/src/services/marketplace.ts
new file mode 100644
index 0000000..db72bc7
--- /dev/null
+++ b/sdk/packages/core/src/services/marketplace.ts
@@ -0,0 +1,397 @@
+import { spawn } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { resolveClineDir, resolveMcpSettingsPath } from "@cline/shared/storage";
+import { updateMcpSettingsFileSync } from "../extensions/mcp";
+import { parseMcpInstallArgs } from "./mcp-install";
+import { uninstallPlugin } from "./plugin-uninstall";
+
+export type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
+
+export type MarketplaceEntryInput = {
+	id: string;
+	type: MarketplacePrimitiveType;
+	name?: string;
+	install?: {
+		args?: string[];
+	};
+};
+
+export type MarketplaceActionResult = {
+	id: string;
+	type: MarketplacePrimitiveType;
+	status: "installed" | "uninstalled";
+	message: string;
+	output?: string;
+};
+
+export type MarketplaceSpawnResult = {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+};
+
+export type MarketplaceSpawnCommand = (
+	command: string,
+	args: string[],
+) => Promise<MarketplaceSpawnResult>;
+
+export type UninstallMarketplaceEntryOptions = {
+	deleteMcpServer?: (name: string) => void | Promise<void>;
+	mcpSettingsPath?: string;
+	spawnCommand?: MarketplaceSpawnCommand;
+	workspaceRoot?: string;
+};
+
+const MARKETPLACE_COMMAND_TIMEOUT_MS = 120_000;
+const MAX_OUTPUT_CHARS = 12_000;
+const SECRET_PATTERN =
+	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i;
+const SECRET_KEY_VALUE_PATTERN =
+	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi;
+const SECRET_BEARER_VALUE_PATTERN =
+	/((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi;
+const SECRET_AUTHORIZATION_VALUE_PATTERN =
+	/((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi;
+
+function getMarketplaceEntryArgs(entry: MarketplaceEntryInput): string[] {
+	return entry.install?.args ?? [];
+}
+
+function resolveHomeDir(): string {
+	return (
+		process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || homedir()
+	);
+}
+
+function trimSkillSegmentEdges(value: string): string {
+	let start = 0;
+	let end = value.length;
+	while (start < end && (value[start] === "." || value[start] === "-")) {
+		start++;
+	}
+	while (end > start && (value[end - 1] === "." || value[end - 1] === "-")) {
+		end--;
+	}
+	return value.slice(start, end);
+}
+
+function sanitizeSkillSegment(value: string): string {
+	const sanitized = trimSkillSegmentEdges(
+		value.toLowerCase().replace(/[^a-z0-9._]+/g, "-"),
+	).slice(0, 255);
+	return sanitized || "skill";
+}
+
+function redactOutput(value: string): string {
+	return value
+		.split(/\r?\n/)
+		.map((line) => {
+			if (!SECRET_PATTERN.test(line)) return line;
+			return line
+				.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
+				.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
+				.replace(
+					/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi,
+					"$1 [redacted]",
+				)
+				.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
+				.replace(
+					/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
+					"$1[redacted]",
+				);
+		})
+		.join("\n")
+		.slice(-MAX_OUTPUT_CHARS);
+}
+
+function commandOutput(result: MarketplaceSpawnResult): string | undefined {
+	const output = redactOutput(
+		[result.stdout, result.stderr].filter(Boolean).join("\n"),
+	).trim();
+	return output.length > 0 ? output : undefined;
+}
+
+function quoteCommandPart(value: string): string {
+	if (value === "") return '""';
+	if (/^[a-zA-Z0-9_./:=@%+,-]+$/.test(value)) return value;
+	return JSON.stringify(value);
+}
+
+function formatCommand(command: string, args: string[]): string {
+	return [command, ...args]
+		.map((part) => quoteCommandPart(redactOutput(part).trim()))
+		.join(" ");
+}
+
+const defaultMarketplaceSpawnCommand: MarketplaceSpawnCommand = async (
+	command,
+	args,
+) =>
+	new Promise<MarketplaceSpawnResult>((resolve, reject) => {
+		let settled = false;
+		let timedOut = false;
+		const child = spawn(command, args, {
+			env: process.env,
+			shell: platform() === "win32",
+			stdio: ["ignore", "pipe", "pipe"],
+			windowsHide: true,
+		});
+		let stdout = "";
+		let stderr = "";
+		const forceKillTimeout = setTimeout(() => {
+			if (!settled) child.kill("SIGKILL");
+		}, MARKETPLACE_COMMAND_TIMEOUT_MS + 5_000);
+		const timeout = setTimeout(() => {
+			timedOut = true;
+			stderr += `\nTimed out after ${MARKETPLACE_COMMAND_TIMEOUT_MS / 1000}s.`;
+			child.kill("SIGTERM");
+		}, MARKETPLACE_COMMAND_TIMEOUT_MS);
+		forceKillTimeout.unref?.();
+		timeout.unref?.();
+		child.stdout?.on("data", (chunk) => {
+			stdout += String(chunk);
+			if (stdout.length > MAX_OUTPUT_CHARS * 2) {
+				stdout = stdout.slice(-MAX_OUTPUT_CHARS);
+			}
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += String(chunk);
+			if (stderr.length > MAX_OUTPUT_CHARS * 2) {
+				stderr = stderr.slice(-MAX_OUTPUT_CHARS);
+			}
+		});
+		child.once("error", (error) => {
+			clearTimeout(timeout);
+			clearTimeout(forceKillTimeout);
+			reject(error);
+		});
+		child.once("close", (code, signal) => {
+			settled = true;
+			clearTimeout(timeout);
+			clearTimeout(forceKillTimeout);
+			resolve({
+				exitCode: timedOut ? 124 : (code ?? (signal === "SIGINT" ? 130 : 1)),
+				stdout,
+				stderr,
+			});
+		});
+	});
+
+export function marketplaceEntryKey(
+	entry: Pick<MarketplaceEntryInput, "id" | "type">,
+): string {
+	return `${entry.type}:${entry.id}`;
+}
+
+export function resolveMarketplaceMcpServerName(
+	entry: MarketplaceEntryInput,
+): string {
+	const args = getMarketplaceEntryArgs(entry);
+	if (args.length === 0) {
+		throw new Error("Marketplace install args are required.");
+	}
+	return parseMcpInstallArgs(args).name;
+}
+
+export function uninstallMarketplaceMcpServerFromSettings(
+	entry: MarketplaceEntryInput,
+	options: Pick<UninstallMarketplaceEntryOptions, "mcpSettingsPath"> = {},
+): { name: string; deleted: boolean } {
+	const name = resolveMarketplaceMcpServerName(entry);
+	const settingsPath = options.mcpSettingsPath ?? resolveMcpSettingsPath();
+	const deleted = updateMcpSettingsFileSync(settingsPath, (settings) => {
+		const servers =
+			settings.mcpServers &&
+			typeof settings.mcpServers === "object" &&
+			!Array.isArray(settings.mcpServers)
+				? (settings.mcpServers as Record<string, unknown>)
+				: {};
+		const hadServer = Object.hasOwn(servers, name);
+		if (hadServer) {
+			delete servers[name];
+		}
+		settings.mcpServers = servers;
+		return hadServer;
+	});
+	return { name, deleted };
+}
+
+export function getMarketplaceSkillCandidates(
+	entry: MarketplaceEntryInput,
+): string[] {
+	const candidates = new Set<string>();
+	const addCandidate = (value: string | undefined) => {
+		const normalized = sanitizeSkillSegment(value ?? "");
+		if (normalized && normalized !== "skill") {
+			candidates.add(normalized);
+		}
+	};
+	addCandidate(entry.id);
+	addCandidate(entry.name);
+	const installArgs = getMarketplaceEntryArgs(entry);
+	for (let index = 0; index < installArgs.length; index++) {
+		const arg = installArgs[index];
+		if ((arg === "--skill" || arg === "-s") && installArgs[index + 1]) {
+			addCandidate(installArgs[index + 1]);
+			index++;
+			continue;
+		}
+		const skillFilter = arg.split("@").at(1);
+		if (skillFilter) {
+			addCandidate(skillFilter);
+		}
+	}
+	return [...candidates];
+}
+
+export function getGlobalMarketplaceSkillPaths(skillName: string): string[] {
+	return [
+		join(resolveClineDir(), "skills", skillName, "SKILL.md"),
+		join(resolveHomeDir(), ".agents", "skills", skillName, "SKILL.md"),
+	].filter((path, index, paths) => paths.indexOf(path) === index);
+}
+
+export function findInstalledGlobalMarketplaceSkillName(
+	entry: MarketplaceEntryInput,
+): string | undefined {
+	if (entry.type !== "skill") return undefined;
+	return getMarketplaceSkillCandidates(entry).find((candidate) =>
+		getGlobalMarketplaceSkillPaths(candidate).some((path) => existsSync(path)),
+	);
+}
+
+export function isMarketplaceSkillInstalled(
+	entry: MarketplaceEntryInput,
+): boolean {
+	return findInstalledGlobalMarketplaceSkillName(entry) !== undefined;
+}
+
+function removeRemainingMarketplaceSkillPaths(
+	entry: MarketplaceEntryInput,
+): string[] {
+	const removedPaths: string[] = [];
+	if (entry.type !== "skill") return removedPaths;
+	for (const candidate of getMarketplaceSkillCandidates(entry)) {
+		for (const skillPath of getGlobalMarketplaceSkillPaths(candidate)) {
+			if (!existsSync(skillPath)) continue;
+			const skillDir = dirname(skillPath);
+			rmSync(skillDir, { recursive: true, force: true });
+			removedPaths.push(skillDir);
+		}
+	}
+	return removedPaths;
+}
+
+export async function uninstallMarketplaceSkill(
+	entry: MarketplaceEntryInput,
+	options: Pick<UninstallMarketplaceEntryOptions, "spawnCommand"> = {},
+): Promise<MarketplaceActionResult> {
+	const installedName = findInstalledGlobalMarketplaceSkillName(entry);
+	if (!installedName) {
+		return {
+			id: entry.id,
+			type: "skill",
+			status: "uninstalled",
+			message: `${entry.name ?? entry.id} is not installed.`,
+		};
+	}
+	const command = "npx";
+	const commandArgs = [
+		"-y",
+		"skills@latest",
+		"remove",
+		installedName,
+		"-g",
+		"-y",
+	];
+	const displayCommand = formatCommand(command, commandArgs);
+	const spawnCommand = options.spawnCommand ?? defaultMarketplaceSpawnCommand;
+	let result: MarketplaceSpawnResult;
+	try {
+		result = await spawnCommand(command, commandArgs);
+	} catch (error) {
+		throw new Error(
+			`Failed to start ${entry.name ?? entry.id} uninstall command:\n${displayCommand}\n${
+				error instanceof Error ? error.message : String(error)
+			}`,
+		);
+	}
+	const output = commandOutput(result);
+	if (result.exitCode !== 0) {
+		throw new Error(
+			`${entry.name ?? entry.id} uninstall failed with exit code ${result.exitCode}.\nCommand:\n${displayCommand}${
+				output ? `\n\n${output}` : ""
+			}`,
+		);
+	}
+	const removedPaths = removeRemainingMarketplaceSkillPaths(entry);
+	if (isMarketplaceSkillInstalled(entry)) {
+		throw new Error(
+			`Skill uninstall completed, but ${entry.name ?? entry.id} is still present in Cline's global skills directories.`,
+		);
+	}
+	return {
+		id: entry.id,
+		type: "skill",
+		status: "uninstalled",
+		message: `Uninstalled ${entry.name ?? entry.id}.`,
+		output:
+			[output, ...removedPaths.map((path) => `Removed: ${path}`)]
+				.filter(Boolean)
+				.join("\n") || undefined,
+	};
+}
+
+export async function uninstallMarketplacePlugin(
+	entry: MarketplaceEntryInput,
+	options: Pick<UninstallMarketplaceEntryOptions, "workspaceRoot"> = {},
+): Promise<MarketplaceActionResult> {
+	const [source] = getMarketplaceEntryArgs(entry);
+	const target = source?.trim() || entry.id;
+	if (!target) {
+		throw new Error("Plugin marketplace uninstalls require a plugin name.");
+	}
+	const result = await uninstallPlugin({
+		name: target,
+		workspaceRoot: options.workspaceRoot,
+	});
+	return {
+		id: entry.id,
+		type: "plugin",
+		status: "uninstalled",
+		message: `Uninstalled ${entry.name ?? result.name ?? entry.id}.`,
+		output: [
+			`Path: ${result.installPath}`,
+			...result.removedPaths.map((path) => `Removed: ${path}`),
+		].join("\n"),
+	};
+}
+
+export async function uninstallMarketplaceEntry(
+	entry: MarketplaceEntryInput,
+	options: UninstallMarketplaceEntryOptions = {},
+): Promise<MarketplaceActionResult> {
+	if (entry.type === "mcp") {
+		const name = resolveMarketplaceMcpServerName(entry);
+		if (options.deleteMcpServer) {
+			await options.deleteMcpServer(name);
+		} else {
+			uninstallMarketplaceMcpServerFromSettings(entry, options);
+		}
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "uninstalled",
+			message: `Uninstalled ${entry.name ?? name ?? entry.id}.`,
+		};
+	}
+	if (entry.type === "skill") {
+		return uninstallMarketplaceSkill(entry, options);
+	}
+	if (entry.type === "plugin") {
+		return uninstallMarketplacePlugin(entry, options);
+	}
+	throw new Error(`Unsupported marketplace entry type: ${entry.type}`);
+}
diff --git a/sdk/packages/core/src/services/mcp-install.test.ts b/sdk/packages/core/src/services/mcp-install.test.ts
new file mode 100644
index 0000000..9f147a0
--- /dev/null
+++ b/sdk/packages/core/src/services/mcp-install.test.ts
@@ -0,0 +1,207 @@
+import {
+	existsSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+	buildMcpInstallTransport,
+	installMcpServer,
+	parseMcpInstallArgs,
+} from "./mcp-install";
+
+describe("MCP install service", () => {
+	let root = "";
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "core-mcp-install-"));
+	});
+
+	afterEach(() => {
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	function readSettings(settingsPath: string): Record<string, unknown> & {
+		mcpServers?: Record<string, { transport?: unknown }>;
+	} {
+		return JSON.parse(readFileSync(settingsPath, "utf8")) as Record<
+			string,
+			unknown
+		> & {
+			mcpServers?: Record<string, { transport?: unknown }>;
+		};
+	}
+
+	it("builds stdio installs without shell-joining command args", () => {
+		expect(
+			buildMcpInstallTransport({
+				name: "fs",
+				targetArgs: [
+					"npx",
+					"-y",
+					"@modelcontextprotocol/server-filesystem",
+					"/tmp/my dir",
+				],
+			}),
+		).toEqual({
+			name: "fs",
+			transport: {
+				type: "stdio",
+				command: "npx",
+				args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/my dir"],
+			},
+			warnings: [],
+		});
+	});
+
+	it("installs remote MCP servers with headers into the settings file", () => {
+		const settingsPath = join(root, "cline_mcp_settings.json");
+		const result = installMcpServer({
+			name: "docs",
+			transport: "http",
+			headers: ["Authorization: Bearer <token>"],
+			targetArgs: ["https://example.com/mcp", "--header=X-Extra: yes"],
+			settingsPath,
+		});
+
+		expect(result).toEqual({
+			name: "docs",
+			status: "installed",
+			transport: {
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+				headers: {
+					Authorization: "Bearer <token>",
+					"X-Extra": "yes",
+				},
+			},
+			warnings: [
+				'Header "Authorization" looks like it contains a placeholder. Update it in MCP settings before using this server.',
+			],
+		});
+		expect(readSettings(settingsPath).mcpServers?.docs).toEqual({
+			transport: result.transport,
+		});
+	});
+
+	it("parses marketplace-style MCP install args in core", () => {
+		expect(
+			parseMcpInstallArgs([
+				"docs",
+				"--transport=http",
+				"https://example.com/mcp",
+				"--header",
+				"Authorization: Bearer <token>",
+				"--header=X-Extra: yes",
+			]),
+		).toEqual({
+			name: "docs",
+			transport: "http",
+			targetArgs: ["https://example.com/mcp"],
+			headers: ["Authorization: Bearer <token>", "X-Extra: yes"],
+		});
+
+		expect(() => parseMcpInstallArgs([])).toThrow(
+			/Marketplace MCP install args/,
+		);
+	});
+
+	it("keeps transport-like values as stdio command args for direct builder input", () => {
+		expect(
+			buildMcpInstallTransport({
+				name: "custom",
+				targetArgs: ["node", "server.js", "--transport", "ipc"],
+			}).transport,
+		).toEqual({
+			type: "stdio",
+			command: "node",
+			args: ["server.js", "--transport", "ipc"],
+		});
+	});
+
+	it("preserves existing MCP settings while adding a server", () => {
+		const settingsPath = join(root, "cline_mcp_settings.json");
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						existing: {
+							transport: { type: "stdio", command: "node" },
+							disabled: true,
+						},
+					},
+					customTopLevelKey: true,
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		installMcpServer({
+			name: "new-server",
+			targetArgs: ["node", "server.js"],
+			settingsPath,
+		});
+
+		const written = readSettings(settingsPath);
+		expect(written.customTopLevelKey).toBe(true);
+		expect(written.mcpServers).toMatchObject({
+			existing: {
+				transport: { type: "stdio", command: "node" },
+				disabled: true,
+			},
+			"new-server": {
+				transport: {
+					type: "stdio",
+					command: "node",
+					args: ["server.js"],
+				},
+			},
+		});
+	});
+
+	it("creates a missing settings file on first install", () => {
+		const settingsPath = join(root, "nested", "settings.json");
+
+		installMcpServer({
+			name: "fs",
+			targetArgs: ["node", "server.js"],
+			settingsPath,
+		});
+
+		expect(existsSync(settingsPath)).toBe(true);
+		expect(readSettings(settingsPath).mcpServers?.fs).toEqual({
+			transport: {
+				type: "stdio",
+				command: "node",
+				args: ["server.js"],
+			},
+		});
+	});
+
+	it("rejects invalid install arguments before writing settings", () => {
+		const settingsPath = join(root, "settings.json");
+
+		expect(() =>
+			installMcpServer({
+				name: "fs",
+				settingsPath,
+			}),
+		).toThrow(/requires a command/);
+		expect(() =>
+			installMcpServer({
+				name: "bad",
+				transport: "http",
+				targetArgs: ["file:///tmp/server"],
+				settingsPath,
+			}),
+		).toThrow(/only http and https are supported/);
+		expect(existsSync(settingsPath)).toBe(false);
+	});
+});
diff --git a/sdk/packages/core/src/services/mcp-install.ts b/sdk/packages/core/src/services/mcp-install.ts
new file mode 100644
index 0000000..20bc85b
--- /dev/null
+++ b/sdk/packages/core/src/services/mcp-install.ts
@@ -0,0 +1,245 @@
+import type { McpServerTransportConfig } from "../extensions/mcp";
+import {
+	resolveDefaultMcpSettingsPath,
+	updateMcpSettingsFileSync,
+} from "../extensions/mcp";
+
+export interface McpInstallOptions {
+	name: string;
+	headers?: string[];
+	targetArgs?: string[];
+	transport?: string;
+	settingsPath?: string;
+}
+
+export interface McpInstallResult {
+	name: string;
+	status: "installed";
+	transport: McpServerTransportConfig;
+	warnings: string[];
+}
+
+function normalizeTransportType(
+	value: string | undefined,
+): McpServerTransportConfig["type"] {
+	const normalized = (value ?? "stdio").trim();
+	if (normalized === "http" || normalized === "streamable-http") {
+		return "streamableHttp";
+	}
+	if (
+		normalized === "stdio" ||
+		normalized === "sse" ||
+		normalized === "streamableHttp"
+	) {
+		return normalized;
+	}
+	throw new Error(
+		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
+	);
+}
+
+function assertValidUrl(url: string): void {
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error(`Invalid MCP server URL: ${url}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error(
+			`Invalid MCP server URL: ${url} (only http and https are supported)`,
+		);
+	}
+}
+
+function parseHeader(value: string): [string, string] {
+	const separatorIndex = value.indexOf(":");
+	if (separatorIndex <= 0) {
+		throw new Error(
+			`Invalid MCP header "${value}". Expected "Header-Name: header value".`,
+		);
+	}
+	const name = value.slice(0, separatorIndex).trim();
+	const headerValue = value.slice(separatorIndex + 1).trim();
+	if (!name || !headerValue) {
+		throw new Error(
+			`Invalid MCP header "${value}". Expected "Header-Name: header value".`,
+		);
+	}
+	if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)) {
+		throw new Error(`Invalid MCP header name "${name}".`);
+	}
+	return [name, headerValue];
+}
+
+function containsPlaceholder(value: string): boolean {
+	const openIndex = value.indexOf("<");
+	return openIndex >= 0 && value.indexOf(">", openIndex + 1) > openIndex + 1;
+}
+
+function splitTargetArgsAndHeaders(input: {
+	headers?: string[];
+	parseTransport?: boolean;
+	targetArgs?: string[];
+	transport?: string;
+}): { headers: string[]; targetArgs: string[]; transport?: string } {
+	const headers = [...(input.headers ?? [])];
+	const targetArgs: string[] = [];
+	let transport = input.transport;
+	const args = input.targetArgs ?? [];
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (input.parseTransport && arg === "--transport") {
+			const value = args[index + 1];
+			if (!value) {
+				throw new Error("--transport requires a value");
+			}
+			transport = value;
+			index++;
+			continue;
+		}
+		if (input.parseTransport && arg?.startsWith("--transport=")) {
+			transport = arg.slice("--transport=".length);
+			continue;
+		}
+		if (arg === "--header") {
+			const value = args[index + 1];
+			if (!value) {
+				throw new Error("--header requires a value");
+			}
+			headers.push(value);
+			index++;
+			continue;
+		}
+		if (arg?.startsWith("--header=")) {
+			headers.push(arg.slice("--header=".length));
+			continue;
+		}
+		targetArgs.push(arg);
+	}
+	return { headers, targetArgs, transport };
+}
+
+function buildHeaders(values: string[]): {
+	headers?: Record<string, string>;
+	warnings: string[];
+} {
+	if (values.length === 0) return { warnings: [] };
+	const headers: Record<string, string> = {};
+	const warnings: string[] = [];
+	for (const value of values) {
+		const [name, headerValue] = parseHeader(value);
+		headers[name] = headerValue;
+		if (containsPlaceholder(headerValue)) {
+			warnings.push(
+				`Header "${name}" looks like it contains a placeholder. Update it in MCP settings before using this server.`,
+			);
+		}
+	}
+	return { headers, warnings };
+}
+
+export function buildMcpInstallTransport(options: {
+	headers?: string[];
+	name: string;
+	targetArgs?: string[];
+	transport?: string;
+}): { name: string; transport: McpServerTransportConfig; warnings: string[] } {
+	const name = options.name.trim();
+	if (!name) {
+		throw new Error("MCP server name is required");
+	}
+	const {
+		headers: rawHeaders,
+		targetArgs,
+		transport,
+	} = splitTargetArgsAndHeaders({
+		headers: options.headers,
+		targetArgs: options.targetArgs,
+		transport: options.transport,
+	});
+	const type = normalizeTransportType(transport);
+	const { headers, warnings } = buildHeaders(rawHeaders);
+	if (type === "stdio") {
+		if (rawHeaders.length > 0) {
+			throw new Error("Stdio MCP installs do not support request headers.");
+		}
+		const [command, ...args] = targetArgs;
+		if (!command?.trim()) {
+			throw new Error(
+				"Stdio MCP install requires a command after the server name, for example: cline mcp install fs --yes -- npx -y @modelcontextprotocol/server-filesystem /tmp",
+			);
+		}
+		return {
+			name,
+			transport: {
+				type,
+				command,
+				args: args.length > 0 ? args : undefined,
+			},
+			warnings,
+		};
+	}
+
+	if (targetArgs.length !== 1) {
+		throw new Error(
+			"Remote MCP install requires exactly one URL argument after the server name.",
+		);
+	}
+	const url = targetArgs[0]?.trim() ?? "";
+	assertValidUrl(url);
+	return {
+		name,
+		transport: headers ? { type, url, headers } : { type, url },
+		warnings,
+	};
+}
+
+export function parseMcpInstallArgs(args: string[]): McpInstallOptions {
+	const [name, ...targetArgs] = args;
+	if (!name) {
+		throw new Error(
+			"Marketplace MCP install args must start with a server name.",
+		);
+	}
+	return {
+		name,
+		...splitTargetArgsAndHeaders({
+			parseTransport: true,
+			targetArgs,
+		}),
+	};
+}
+
+function addMcpServer(
+	name: string,
+	transport: McpServerTransportConfig,
+	settingsPath: string,
+): void {
+	updateMcpSettingsFileSync(settingsPath, (settings) => {
+		const serversValue = settings.mcpServers;
+		const servers =
+			serversValue &&
+			typeof serversValue === "object" &&
+			!Array.isArray(serversValue)
+				? { ...(serversValue as Record<string, unknown>) }
+				: {};
+		servers[name] = { transport };
+		settings.mcpServers = servers;
+	});
+}
+
+export function installMcpServer(options: McpInstallOptions): McpInstallResult {
+	const { name, transport, warnings } = buildMcpInstallTransport(options);
+	addMcpServer(
+		name,
+		transport,
+		options.settingsPath ?? resolveDefaultMcpSettingsPath(),
+	);
+	return {
+		name,
+		status: "installed",
+		transport,
+		warnings,
+	};
+}
diff --git a/sdk/packages/core/src/services/plugin-install.test.ts b/sdk/packages/core/src/services/plugin-install.test.ts
new file mode 100644
index 0000000..21eed8c
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-install.test.ts
@@ -0,0 +1,278 @@
+import { execFileSync } from "node:child_process";
+import {
+	existsSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	discoverPluginModulePaths,
+	resolvePluginConfigSearchPaths,
+	setClineDir,
+	setHomeDir,
+} from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	installPlugin,
+	isOfficialPluginSlug,
+	parsePluginSource,
+} from "./plugin-install";
+
+type FetchCall = (
+	...args: Parameters<typeof fetch>
+) => ReturnType<typeof fetch>;
+
+describe("plugin install service", () => {
+	let root = "";
+	let home = "";
+	let workspace = "";
+	let originalHome: string | undefined;
+	let originalClineDir: string | undefined;
+	let originalClineDataDir: string | undefined;
+	let originalMcpSettingsPath: string | undefined;
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "core-plugin-install-"));
+		home = join(root, "home");
+		workspace = join(root, "workspace");
+		originalHome = process.env.HOME;
+		originalClineDir = process.env.CLINE_DIR;
+		originalClineDataDir = process.env.CLINE_DATA_DIR;
+		originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+		process.env.HOME = home;
+		process.env.CLINE_DIR = join(home, ".cline");
+		process.env.CLINE_DATA_DIR = join(home, ".cline", "data");
+		process.env.CLINE_MCP_SETTINGS_PATH = join(
+			home,
+			".cline",
+			"cline_mcp_settings.json",
+		);
+		setHomeDir(home);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+		if (originalHome === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = originalHome;
+		}
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR;
+		} else {
+			process.env.CLINE_DIR = originalClineDir;
+		}
+		if (originalClineDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalClineDataDir;
+		}
+		if (originalMcpSettingsPath === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
+		}
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	function runGitCommand(cwd: string, args: string[]): void {
+		execFileSync("git", args, { cwd, stdio: "ignore" });
+	}
+
+	async function createOfficialPluginsRepo(
+		plugins: Record<string, Record<string, string>>,
+	): Promise<string> {
+		const repo = mkdtempSync(join(root, "official-plugins-"));
+		for (const [slug, files] of Object.entries(plugins)) {
+			const pluginRoot = join(repo, "plugins", slug);
+			await mkdir(pluginRoot, { recursive: true });
+			for (const [filename, content] of Object.entries(files)) {
+				await writeFile(join(pluginRoot, filename), content, "utf8");
+			}
+		}
+		runGitCommand(repo, ["init"]);
+		runGitCommand(repo, ["config", "user.email", "test@example.com"]);
+		runGitCommand(repo, ["config", "user.name", "Cline Test"]);
+		runGitCommand(repo, ["add", "."]);
+		runGitCommand(repo, ["commit", "-m", "seed plugins"]);
+		return repo;
+	}
+
+	it("parses marketplace plugin sources the same way the CLI command expects", () => {
+		expect(isOfficialPluginSlug("web-search")).toBe(true);
+		expect(parsePluginSource("web-search")).toEqual({
+			type: "official",
+			slug: "web-search",
+		});
+		expect(parsePluginSource("web-search", "npm")).toEqual({
+			type: "npm",
+			spec: "web-search",
+			name: "web-search",
+		});
+		expect(parsePluginSource("github.com/acme/plugin", "git")).toMatchObject({
+			type: "git",
+			repo: "https://github.com/acme/plugin",
+			host: "github.com",
+			path: "acme/plugin",
+		});
+		expect(() => parsePluginSource("github.com/acme/plugin")).toThrow(
+			/Use --git/,
+		);
+	});
+
+	it("installs a local plugin file into the global plugin root", async () => {
+		const source = join(root, "weather.ts");
+		writeFileSync(
+			source,
+			"export default { name: 'weather', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const result = await installPlugin({ source });
+
+		expect(result.installPath).toContain(join(home, ".cline", "plugins"));
+		expect(result.entryPaths).toHaveLength(1);
+		expect(existsSync(result.entryPaths[0] ?? "")).toBe(true);
+		expect(discoverPluginModulePaths(join(home, ".cline", "plugins"))).toEqual(
+			result.entryPaths,
+		);
+	});
+
+	it("installs a remote plugin file into the workspace plugin root", async () => {
+		const source =
+			"https://github.com/acme/plugins/blob/main/weather-metrics.ts";
+		const fetchMock = vi.fn<FetchCall>(async (input) => {
+			expect(String(input)).toBe(
+				"https://raw.githubusercontent.com/acme/plugins/main/weather-metrics.ts",
+			);
+			return new Response(
+				"export default { name: 'remote-weather', manifest: { capabilities: ['tools'] } };",
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const result = await installPlugin({ source, cwd: workspace });
+
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+		expect(result.installPath).toContain(
+			join(workspace, ".cline", "plugins", "_installed", "remote"),
+		);
+		expect(result.entryPaths).toHaveLength(1);
+		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
+			"remote-weather",
+		);
+		expect(
+			discoverPluginModulePaths(join(workspace, ".cline", "plugins")),
+		).toEqual(result.entryPaths);
+	});
+
+	it("installs an official plugin slug from the configured collection repo", async () => {
+		const officialPluginsRepo = await createOfficialPluginsRepo({
+			"web-search": {
+				"index.ts":
+					"export default { name: 'official-web-search', manifest: { capabilities: ['tools'] } };",
+			},
+			"other-plugin": {
+				"index.ts":
+					"export default { name: 'other-plugin', manifest: { capabilities: ['tools'] } };",
+			},
+		});
+
+		const result = await installPlugin({
+			source: "web-search",
+			cwd: workspace,
+			officialPluginsRepo,
+		});
+
+		expect(result.installPath).toContain(
+			join(workspace, ".cline", "plugins", "_installed", "official"),
+		);
+		expect(result.entryPaths).toHaveLength(1);
+		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
+			"official-web-search",
+		);
+		const wrapperManifest = JSON.parse(
+			readFileSync(join(result.installPath, "package.json"), "utf8"),
+		) as { name?: string };
+		expect(wrapperManifest.name).toBe("web-search");
+		expect(existsSync(join(result.installPath, "repo"))).toBe(false);
+		expect(
+			existsSync(join(result.installPath, "package", "other-plugin")),
+		).toBe(false);
+		expect(resolvePluginConfigSearchPaths(workspace)[0]).toBe(
+			join(workspace, ".cline", "plugins"),
+		);
+	});
+
+	it("syncs MCP servers declared by installed plugins", async () => {
+		const source = join(root, "mcp-plugin.ts");
+		writeFileSync(
+			source,
+			`
+export default {
+  name: "sdk-mcp-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "sdk-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+
+		const result = await installPlugin({ source });
+
+		expect(result.mcpSyncFailures).toEqual([]);
+		expect(result.mcpOAuthCandidates).toEqual([
+			expect.objectContaining({
+				name: "sdk-docs",
+				pluginName: "sdk-mcp-plugin",
+				pluginPath: result.entryPaths[0],
+				transportType: "streamableHttp",
+			}),
+		]);
+		const settings = JSON.parse(
+			readFileSync(process.env.CLINE_MCP_SETTINGS_PATH ?? "", "utf8"),
+		) as {
+			mcpServers?: Record<
+				string,
+				{ metadata?: Record<string, unknown>; transport?: unknown }
+			>;
+		};
+		expect(settings.mcpServers?.["sdk-docs"]).toMatchObject({
+			transport: {
+				type: "streamableHttp",
+				url: "https://example.com/mcp",
+			},
+			metadata: {
+				source: "plugin",
+				pluginName: "sdk-mcp-plugin",
+				pluginPath: result.entryPaths[0],
+			},
+		});
+	});
+
+	it("requires force before replacing an existing install", async () => {
+		const source = join(root, "replaceable.ts");
+		writeFileSync(
+			source,
+			"export default { name: 'replaceable', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const first = await installPlugin({ source });
+		await expect(installPlugin({ source })).rejects.toThrow(/Use --force/);
+		const second = await installPlugin({ source, force: true });
+
+		expect(second.installPath).toBe(first.installPath);
+		expect(existsSync(second.entryPaths[0] ?? "")).toBe(true);
+	});
+});
diff --git a/sdk/packages/core/src/services/plugin-install.ts b/sdk/packages/core/src/services/plugin-install.ts
new file mode 100644
index 0000000..6c07932
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-install.ts
@@ -0,0 +1,1218 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+	type Dirent,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	renameSync,
+	rmSync,
+	statSync,
+} from "node:fs";
+import { cp, mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import {
+	basename,
+	dirname,
+	extname,
+	join,
+	relative,
+	resolve,
+	sep,
+} from "node:path";
+import {
+	isPluginModulePath,
+	resolveClineDir,
+	resolvePluginModuleEntries,
+} from "@cline/shared/storage";
+import {
+	type McpServerRegistration,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+} from "../extensions/mcp";
+import {
+	type PluginMcpSettingsSyncResult,
+	syncPluginMcpServersToSettings,
+} from "./plugin-mcp-settings";
+
+export interface PluginInstallOptions {
+	source: string;
+	sourceType?: PluginInstallSourceType;
+	cwd?: string;
+	force?: boolean;
+	npmCommand?: string;
+	officialPluginsRepo?: string;
+}
+
+export interface PluginInstallResult {
+	source: string;
+	installPath: string;
+	entryPaths: string[];
+	mcpSyncFailures: PluginMcpSettingsSyncResult["failures"];
+	mcpOAuthCandidates: PluginMcpOAuthCandidate[];
+}
+
+export interface PluginMcpOAuthCandidate {
+	name: string;
+	pluginName: string;
+	pluginPath: string;
+	transportType: "sse" | "streamableHttp";
+	lastError?: string;
+}
+
+export type ParsedPluginSource =
+	| {
+			type: "npm";
+			spec: string;
+			name: string;
+	  }
+	| {
+			type: "git";
+			repo: string;
+			ref?: string;
+			host: string;
+			path: string;
+	  }
+	| {
+			type: "remote";
+			url: string;
+			filename: string;
+	  }
+	| {
+			type: "local";
+			path: string;
+	  }
+	| {
+			type: "official";
+			slug: string;
+	  };
+
+export type PluginInstallSourceType = "npm" | "git" | "local" | "remote";
+
+interface PluginPackageManifest {
+	cline?: {
+		plugins?: Array<{ paths?: string[] } | string>;
+	};
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+	optionalDependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+	peerDependenciesMeta?: Record<string, unknown>;
+}
+
+const INSTALLS_DIRECTORY_NAME = "_installed";
+const PACKAGE_DIRECTORY_NAME = "package";
+const OFFICIAL_PLUGINS_REPO = "https://github.com/cline/plugins.git";
+const REMOTE_PLUGIN_FETCH_TIMEOUT_MS = 30_000;
+const REMOTE_PLUGIN_MAX_BYTES = 10 * 1024 * 1024;
+const HOST_PROVIDED_SDK_PREFIX = "@cline/";
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies",
+] as const;
+const WRAPPER_PACKAGE_JSON = {
+	name: "cline-installed-plugin",
+	private: true,
+	cline: {
+		plugins: [] as Array<{ paths: string[] }>,
+	},
+};
+
+function resolveHomePath(value: string): string {
+	if (value === "~") {
+		return homedir();
+	}
+	if (value.startsWith("~/")) {
+		return join(homedir(), value.slice(2));
+	}
+	return value;
+}
+
+function toPosixPath(path: string): string {
+	return path.split(sep).join("/");
+}
+
+function hashSource(source: string): string {
+	return createHash("sha256").update(source).digest("hex").slice(0, 12);
+}
+
+function trimDashes(value: string): string {
+	let start = 0;
+	while (start < value.length && value[start] === "-") {
+		start++;
+	}
+	let end = value.length;
+	while (end > start && value[end - 1] === "-") {
+		end--;
+	}
+	return value.slice(start, end);
+}
+
+function sanitizeSegment(value: string): string {
+	let output = "";
+	let previousDash = false;
+	const input = value.startsWith("@") ? value.slice(1) : value;
+	for (const char of input.slice(0, 256)) {
+		const isAllowed =
+			(char >= "a" && char <= "z") ||
+			(char >= "A" && char <= "Z") ||
+			(char >= "0" && char <= "9") ||
+			char === "." ||
+			char === "_" ||
+			char === "-";
+		if (isAllowed) {
+			output += char;
+			previousDash = char === "-";
+		} else if (!previousDash) {
+			output += "-";
+			previousDash = true;
+		}
+		if (output.length >= 80) {
+			break;
+		}
+	}
+	const sanitized = trimDashes(output);
+	return sanitized || "plugin";
+}
+
+export function isOfficialPluginSlug(source: string): boolean {
+	return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(source.trim());
+}
+
+function resolveOfficialPluginsRepo(override: string | undefined): string {
+	return override?.trim() || OFFICIAL_PLUGINS_REPO;
+}
+
+function parseNpmSpec(spec: string): { name: string } {
+	const trimmed = spec.trim();
+	const match = trimmed.match(/^(@?[^@/]+(?:\/[^@/]+)?)(?:@.+)?$/);
+	if (!match?.[1]) {
+		throw new Error(`Invalid npm plugin source: npm:${spec}`);
+	}
+	return { name: match[1] };
+}
+
+function looksLikeHostnamePath(source: string): boolean {
+	if (
+		source.startsWith(".") ||
+		source.startsWith("/") ||
+		source === "~" ||
+		source.startsWith("~/") ||
+		/^[A-Za-z]:[\\/]|^\\\\/.test(source)
+	) {
+		return false;
+	}
+	const [host, ...pathParts] = source.split("/");
+	return (
+		!!host &&
+		pathParts.length >= 2 &&
+		host.includes(".") &&
+		!host.startsWith(".") &&
+		!host.endsWith(".")
+	);
+}
+
+function splitGitRef(input: string): { repo: string; ref?: string } {
+	const scpLike = input.match(/^git@([^:]+):(.+)$/);
+	if (scpLike) {
+		const path = scpLike[2] ?? "";
+		const refAt = path.indexOf("@");
+		if (refAt < 0) {
+			return { repo: input };
+		}
+		return {
+			repo: `git@${scpLike[1]}:${path.slice(0, refAt)}`,
+			ref: path.slice(refAt + 1) || undefined,
+		};
+	}
+	if (input.includes("://")) {
+		try {
+			const parsed = new URL(input);
+			const path = parsed.pathname.replace(/^\/+/, "");
+			const refAt = path.indexOf("@");
+			if (refAt < 0) {
+				return { repo: input };
+			}
+			parsed.pathname = `/${path.slice(0, refAt)}`;
+			return {
+				repo: parsed.toString().replace(/\/$/, ""),
+				ref: path.slice(refAt + 1) || undefined,
+			};
+		} catch {
+			return { repo: input };
+		}
+	}
+	const slash = input.indexOf("/");
+	if (slash < 0) {
+		return { repo: input };
+	}
+	const host = input.slice(0, slash);
+	const path = input.slice(slash + 1);
+	const refAt = path.indexOf("@");
+	if (refAt < 0) {
+		return { repo: input };
+	}
+	return {
+		repo: `${host}/${path.slice(0, refAt)}`,
+		ref: path.slice(refAt + 1) || undefined,
+	};
+}
+
+function decodePathSegment(value: string): string {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+
+function filenameFromUrlPath(pathname: string): string {
+	const filename = basename(decodePathSegment(pathname));
+	return filename || "plugin";
+}
+
+function isGitHubFilePath(pathname: string): boolean {
+	const parts = pathname.split("/").filter(Boolean);
+	return parts.length >= 5 && (parts[2] === "blob" || parts[2] === "raw");
+}
+
+function normalizeRemotePluginFileUrl(
+	source: string,
+): Extract<ParsedPluginSource, { type: "remote" }> | null {
+	if (!/^https?:\/\//i.test(source)) {
+		return null;
+	}
+	let parsed: URL;
+	try {
+		parsed = new URL(source);
+	} catch {
+		return null;
+	}
+
+	const host = parsed.hostname.toLowerCase();
+	const filename = filenameFromUrlPath(parsed.pathname);
+	const isPluginFile = isPluginModulePath(filename);
+	const isGitHubFile =
+		(host === "github.com" || host === "www.github.com") &&
+		isGitHubFilePath(parsed.pathname);
+
+	if (parsed.protocol !== "https:") {
+		if (isGitHubFile || host === "raw.githubusercontent.com" || isPluginFile) {
+			throw new Error(`Remote plugin file URLs must use https: ${source}`);
+		}
+		return null;
+	}
+
+	if (host === "github.com" || host === "www.github.com") {
+		const parts = parsed.pathname.split("/").filter(Boolean);
+		if (!isGitHubFile) {
+			return null;
+		}
+		if (!isPluginFile) {
+			throw new Error(`Remote plugin file must be .js or .ts: ${source}`);
+		}
+		const rawParts = [parts[0], parts[1], ...parts.slice(3)];
+		return {
+			type: "remote",
+			url: `https://raw.githubusercontent.com/${rawParts.join("/")}`,
+			filename,
+		};
+	}
+
+	if (host === "raw.githubusercontent.com") {
+		if (!isPluginFile) {
+			throw new Error(`Remote plugin file must be .js or .ts: ${source}`);
+		}
+		return { type: "remote", url: parsed.toString(), filename };
+	}
+
+	if (!isPluginFile) {
+		return null;
+	}
+	return { type: "remote", url: parsed.toString(), filename };
+}
+
+function parseGitSource(
+	source: string,
+	options: { force?: boolean } = {},
+): ParsedPluginSource | null {
+	const trimmed = source.trim();
+	const hasGitPrefix =
+		trimmed.startsWith("git:") && !trimmed.startsWith("git://");
+	const raw = hasGitPrefix ? trimmed.slice("git:".length).trim() : trimmed;
+	if (!options.force && !hasGitPrefix && !/^(https?|ssh|git):\/\//i.test(raw)) {
+		return null;
+	}
+	const { repo, ref } = splitGitRef(raw);
+	let host = "";
+	let repoPath = "";
+	if (repo.startsWith("git@")) {
+		const match = repo.match(/^git@([^:]+):(.+)$/);
+		host = match?.[1] ?? "";
+		repoPath = match?.[2] ?? "";
+	} else if (/^(https?|ssh|git):\/\//i.test(repo)) {
+		const parsed = new URL(repo);
+		host = parsed.hostname;
+		repoPath = parsed.pathname.replace(/^\/+/, "");
+	} else {
+		const slash = repo.indexOf("/");
+		if (slash < 0) {
+			return null;
+		}
+		host = repo.slice(0, slash);
+		repoPath = repo.slice(slash + 1);
+	}
+	const normalizedPath = repoPath.replace(/\.git$/, "").replace(/^\/+/, "");
+	if (!host || !normalizedPath || normalizedPath.split("/").length < 2) {
+		return null;
+	}
+	const cloneRepo =
+		repo.startsWith("git@") || /^(https?|ssh|git):\/\//i.test(repo)
+			? repo
+			: `https://${repo}`;
+	return {
+		type: "git",
+		repo: cloneRepo,
+		ref,
+		host,
+		path: normalizedPath,
+	};
+}
+
+export function parsePluginSource(
+	source: string,
+	sourceType?: PluginInstallSourceType,
+): ParsedPluginSource {
+	const trimmed = source.trim();
+	if (!trimmed) {
+		throw new Error("plugin install requires a source");
+	}
+	if (sourceType === "npm") {
+		const spec = trimmed.startsWith("npm:")
+			? trimmed.slice("npm:".length).trim()
+			: trimmed;
+		const { name } = parseNpmSpec(spec);
+		return { type: "npm", spec, name };
+	}
+	if (sourceType === "git") {
+		const git = parseGitSource(trimmed, { force: true });
+		if (!git) {
+			throw new Error(`Invalid git plugin source: ${source}`);
+		}
+		return git;
+	}
+	if (sourceType === "local") {
+		return { type: "local", path: source };
+	}
+	if (sourceType === "remote") {
+		const remote = normalizeRemotePluginFileUrl(trimmed);
+		if (!remote) {
+			throw new Error(`Invalid remote plugin source: ${source}`);
+		}
+		return remote;
+	}
+	if (trimmed.startsWith("npm:")) {
+		const spec = trimmed.slice("npm:".length).trim();
+		const { name } = parseNpmSpec(spec);
+		return { type: "npm", spec, name };
+	}
+	const localPathLike =
+		trimmed.startsWith(".") ||
+		trimmed.startsWith("/") ||
+		trimmed === "~" ||
+		trimmed.startsWith("~/") ||
+		/^[A-Za-z]:[\\/]|^\\\\/.test(trimmed);
+	if (localPathLike) {
+		return { type: "local", path: source };
+	}
+	const remote = normalizeRemotePluginFileUrl(trimmed);
+	if (remote) {
+		return remote;
+	}
+	const git = parseGitSource(trimmed);
+	if (git) {
+		return git;
+	}
+	if (isOfficialPluginSlug(trimmed)) {
+		return { type: "official", slug: trimmed };
+	}
+	if (looksLikeHostnamePath(trimmed)) {
+		throw new Error(
+			`Unrecognized plugin source "${source}". Use --git for hostname-style repositories or pass an explicit local path such as ./github.com/owner/repo.`,
+		);
+	}
+	return { type: "local", path: source };
+}
+
+function getPluginRoot(cwd: string | undefined): string {
+	return cwd
+		? join(cwd, ".cline", "plugins")
+		: join(resolveClineDir(), "plugins");
+}
+
+function getInstallPath(
+	pluginRoot: string,
+	parsed: ParsedPluginSource,
+	sourceKey: string,
+): string {
+	if (parsed.type === "npm") {
+		return join(
+			pluginRoot,
+			INSTALLS_DIRECTORY_NAME,
+			"npm",
+			`${sanitizeSegment(parsed.name)}-${hashSource(sourceKey)}`,
+		);
+	}
+	if (parsed.type === "git") {
+		return join(
+			pluginRoot,
+			INSTALLS_DIRECTORY_NAME,
+			"git",
+			sanitizeSegment(parsed.host),
+			`${sanitizeSegment(parsed.path)}-${hashSource(sourceKey)}`,
+		);
+	}
+	if (parsed.type === "remote") {
+		return join(
+			pluginRoot,
+			INSTALLS_DIRECTORY_NAME,
+			"remote",
+			`${sanitizeSegment(parsed.filename)}-${hashSource(sourceKey)}`,
+		);
+	}
+	if (parsed.type === "official") {
+		return join(
+			pluginRoot,
+			INSTALLS_DIRECTORY_NAME,
+			"official",
+			`${sanitizeSegment(parsed.slug)}-${hashSource(sourceKey)}`,
+		);
+	}
+	return join(
+		pluginRoot,
+		INSTALLS_DIRECTORY_NAME,
+		"local",
+		`${sanitizeSegment(basename(resolveHomePath(parsed.path)))}-${hashSource(sourceKey)}`,
+	);
+}
+
+function getInstallSourceKey(
+	parsed: ParsedPluginSource,
+	cwd: string,
+	officialPluginsRepo: string,
+): string {
+	if (parsed.type === "npm") {
+		return `npm:${parsed.spec}`;
+	}
+	if (parsed.type === "git") {
+		return `git:${parsed.repo}${parsed.ref ? `#${parsed.ref}` : ""}`;
+	}
+	if (parsed.type === "remote") {
+		return `remote:${parsed.url}`;
+	}
+	if (parsed.type === "official") {
+		return `official:${officialPluginsRepo}#plugins/${parsed.slug}`;
+	}
+	return `local:${resolve(cwd, resolveHomePath(parsed.path))}`;
+}
+
+function getWrapperPackageName(
+	parsed: ParsedPluginSource,
+	cwd: string,
+): string {
+	if (parsed.type === "npm") {
+		return parsed.name;
+	}
+	if (parsed.type === "git") {
+		return sanitizeSegment(basename(parsed.path));
+	}
+	if (parsed.type === "remote") {
+		return sanitizeSegment(basename(parsed.filename, extname(parsed.filename)));
+	}
+	if (parsed.type === "official") {
+		return parsed.slug;
+	}
+	return sanitizeSegment(basename(resolve(cwd, resolveHomePath(parsed.path))));
+}
+
+async function runCommand(
+	command: string,
+	args: string[],
+	options: { cwd?: string } = {},
+): Promise<void> {
+	await new Promise<void>((resolvePromise, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			stdio: ["ignore", "ignore", "pipe"],
+			env: process.env,
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		});
+		let stderr = "";
+		child.stderr.on("data", (chunk) => {
+			stderr += String(chunk);
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			const details = stderr.trim();
+			reject(
+				new Error(
+					`${command} ${args.join(" ")} failed with exit code ${code}${details ? `: ${details}` : ""}`,
+				),
+			);
+		});
+	});
+}
+
+function readPackageManifest(
+	packageRoot: string,
+): PluginPackageManifest | null {
+	const packageJsonPath = join(packageRoot, "package.json");
+	if (!existsSync(packageJsonPath)) {
+		return null;
+	}
+	try {
+		return JSON.parse(
+			readFileSync(packageJsonPath, "utf8"),
+		) as PluginPackageManifest;
+	} catch {
+		return null;
+	}
+}
+
+function getManifestPaths(manifest: PluginPackageManifest | null): string[] {
+	const entries = manifest?.cline?.plugins;
+	if (!Array.isArray(entries)) {
+		return [];
+	}
+	return entries.flatMap((entry) => {
+		if (typeof entry === "string") {
+			return [entry];
+		}
+		return entry.paths ?? [];
+	});
+}
+
+async function removeHostProvidedSdkDependencies(
+	packageRoot: string,
+): Promise<void> {
+	const packageJsonPath = join(packageRoot, "package.json");
+	const manifest = readPackageManifest(packageRoot);
+	if (!manifest) {
+		return;
+	}
+	let changed = false;
+	for (const field of DEPENDENCY_FIELDS) {
+		const dependencies = manifest[field];
+		if (!dependencies || typeof dependencies !== "object") {
+			continue;
+		}
+		for (const dependencyName of Object.keys(dependencies)) {
+			if (!dependencyName.startsWith(HOST_PROVIDED_SDK_PREFIX)) {
+				continue;
+			}
+			delete dependencies[dependencyName];
+			delete manifest.peerDependenciesMeta?.[dependencyName];
+			changed = true;
+		}
+		if (Object.keys(dependencies).length === 0) {
+			delete manifest[field];
+		}
+	}
+	if (manifest.peerDependenciesMeta) {
+		for (const dependencyName of Object.keys(manifest.peerDependenciesMeta)) {
+			if (!dependencyName.startsWith(HOST_PROVIDED_SDK_PREFIX)) {
+				continue;
+			}
+			delete manifest.peerDependenciesMeta[dependencyName];
+			changed = true;
+		}
+		if (Object.keys(manifest.peerDependenciesMeta).length === 0) {
+			delete manifest.peerDependenciesMeta;
+		}
+	}
+	if (!changed) {
+		return;
+	}
+	await writeFile(
+		packageJsonPath,
+		`${JSON.stringify(manifest, null, 2)}\n`,
+		"utf8",
+	);
+}
+
+function removeInstalledHostProvidedSdkDependencies(
+	packageRoot: string,
+	preservePackageName?: string,
+): void {
+	const clineScopeDir = join(packageRoot, "node_modules", "@cline");
+	if (!existsSync(clineScopeDir)) {
+		return;
+	}
+	for (const entry of statSafeReadDir(clineScopeDir)) {
+		const packageName = `@cline/${entry.name}`;
+		if (packageName === preservePackageName) {
+			continue;
+		}
+		rmSync(join(clineScopeDir, entry.name), {
+			recursive: true,
+			force: true,
+		});
+	}
+}
+
+function collectPluginEntries(packageRoot: string): string[] {
+	const manifestPaths = getManifestPaths(readPackageManifest(packageRoot))
+		.map((entry) => resolve(packageRoot, entry))
+		.filter(
+			(entry) =>
+				existsSync(entry) &&
+				statSync(entry).isFile() &&
+				isPluginModulePath(entry),
+		);
+	if (manifestPaths.length > 0) {
+		return manifestPaths;
+	}
+	const directEntries = resolvePluginModuleEntries(packageRoot);
+	if (directEntries?.length) {
+		return directEntries;
+	}
+	const entries: string[] = [];
+	const stack = [packageRoot];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current) {
+			continue;
+		}
+		for (const entry of statSafeReadDir(current)) {
+			const entryPath = join(current, entry.name);
+			if (entry.name === "node_modules" || entry.name === ".git") {
+				continue;
+			}
+			if (entry.isDirectory()) {
+				stack.push(entryPath);
+				continue;
+			}
+			if (
+				entry.isFile() &&
+				!entry.name.startsWith(".") &&
+				isPluginModulePath(entryPath)
+			) {
+				entries.push(entryPath);
+			}
+		}
+	}
+	return entries.sort((left, right) => left.localeCompare(right));
+}
+
+function statSafeReadDir(dir: string): Dirent[] {
+	try {
+		return readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+
+function toWrapperEntryPaths(
+	wrapperRoot: string,
+	packageRoot: string,
+): string[] {
+	const entries = collectPluginEntries(packageRoot);
+	if (entries.length === 0) {
+		throw new Error(`No plugin entry files found in ${packageRoot}`);
+	}
+	return entries.map(
+		(entry) => `./${toPosixPath(relative(wrapperRoot, entry))}`,
+	);
+}
+
+async function writeWrapperManifest(
+	wrapperRoot: string,
+	packageRoot: string,
+	packageName: string,
+): Promise<string[]> {
+	const entryPaths = toWrapperEntryPaths(wrapperRoot, packageRoot);
+	await writeFile(
+		join(wrapperRoot, "package.json"),
+		JSON.stringify(
+			{
+				...WRAPPER_PACKAGE_JSON,
+				name: packageName,
+				cline: {
+					plugins: [{ paths: entryPaths }],
+				},
+			},
+			null,
+			2,
+		),
+		"utf8",
+	);
+	return entryPaths;
+}
+
+async function installNpmPackage(
+	parsed: Extract<ParsedPluginSource, { type: "npm" }>,
+	stagingRoot: string,
+	npmCommand: string,
+): Promise<string> {
+	const packageRoot = join(stagingRoot, PACKAGE_DIRECTORY_NAME);
+	await mkdir(packageRoot, { recursive: true });
+	await writeFile(
+		join(packageRoot, "package.json"),
+		JSON.stringify({ name: "cline-plugin-install", private: true }, null, 2),
+		"utf8",
+	);
+	await runCommand(npmCommand, [
+		"install",
+		parsed.spec,
+		"--prefix",
+		packageRoot,
+		"--omit=dev",
+		"--omit=peer",
+		"--legacy-peer-deps",
+		"--no-audit",
+		"--no-fund",
+		"--package-lock=false",
+	]);
+	removeInstalledHostProvidedSdkDependencies(packageRoot, parsed.name);
+	return join(packageRoot, "node_modules", parsed.name);
+}
+
+async function installPackageDependencies(
+	packageRoot: string,
+	npmCommand: string,
+): Promise<void> {
+	if (!existsSync(join(packageRoot, "package.json"))) {
+		return;
+	}
+	await removeHostProvidedSdkDependencies(packageRoot);
+	await runCommand(
+		npmCommand,
+		[
+			"install",
+			"--omit=dev",
+			"--omit=peer",
+			"--legacy-peer-deps",
+			"--no-audit",
+			"--no-fund",
+			"--package-lock=false",
+		],
+		{ cwd: packageRoot },
+	);
+}
+
+async function installGitPackage(
+	parsed: Extract<ParsedPluginSource, { type: "git" }>,
+	stagingRoot: string,
+	npmCommand: string,
+): Promise<string> {
+	if (parsed.ref?.startsWith("-")) {
+		throw new Error(`Invalid git ref "${parsed.ref}".`);
+	}
+	const packageRoot = join(stagingRoot, PACKAGE_DIRECTORY_NAME);
+	const cloneArgs = ["clone", "--filter=blob:none"];
+	if (parsed.ref) {
+		cloneArgs.push("--branch", parsed.ref);
+	}
+	cloneArgs.push("--", parsed.repo, packageRoot);
+	try {
+		await runCommand("git", cloneArgs);
+	} catch (error) {
+		if (!parsed.ref) {
+			throw error;
+		}
+		await runCommand("git", [
+			"clone",
+			"--filter=blob:none",
+			"--",
+			parsed.repo,
+			packageRoot,
+		]);
+		await runCommand("git", ["checkout", "--detach", parsed.ref], {
+			cwd: packageRoot,
+		});
+	}
+	await installPackageDependencies(packageRoot, npmCommand);
+	return packageRoot;
+}
+
+async function installOfficialPlugin(
+	parsed: Extract<ParsedPluginSource, { type: "official" }>,
+	stagingRoot: string,
+	npmCommand: string,
+	officialPluginsRepo: string,
+): Promise<string> {
+	const repoRoot = join(stagingRoot, "repo");
+	await runCommand("git", [
+		"clone",
+		"--filter=blob:none",
+		"--depth",
+		"1",
+		"--",
+		officialPluginsRepo,
+		repoRoot,
+	]);
+
+	const sourceRoot = join(repoRoot, "plugins", parsed.slug);
+	if (!existsSync(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
+		throw new Error(
+			`Official Cline plugin "${parsed.slug}" was not found at plugins/${parsed.slug} in ${officialPluginsRepo}`,
+		);
+	}
+
+	const packageRoot = join(stagingRoot, PACKAGE_DIRECTORY_NAME);
+	await cp(sourceRoot, packageRoot, {
+		recursive: true,
+		filter: (sourcePath) => {
+			const name = basename(sourcePath);
+			return name !== ".git" && name !== "node_modules";
+		},
+	});
+	rmSync(repoRoot, { recursive: true, force: true });
+	await installPackageDependencies(packageRoot, npmCommand);
+	return packageRoot;
+}
+
+function remotePluginSizeLimitError(url: string): Error {
+	return new Error(
+		`Remote plugin file from ${url} exceeds the ${REMOTE_PLUGIN_MAX_BYTES} byte limit`,
+	);
+}
+
+function getContentLength(response: Response): number | undefined {
+	const raw = response.headers.get("content-length");
+	if (!raw) {
+		return undefined;
+	}
+	const value = Number(raw);
+	if (!Number.isFinite(value) || value < 0) {
+		return undefined;
+	}
+	return value;
+}
+
+async function readRemotePluginBody(
+	response: Response,
+	url: string,
+): Promise<Buffer> {
+	const contentLength = getContentLength(response);
+	if (contentLength !== undefined && contentLength > REMOTE_PLUGIN_MAX_BYTES) {
+		throw remotePluginSizeLimitError(url);
+	}
+
+	if (!response.body) {
+		const body = Buffer.from(await response.text(), "utf8");
+		if (body.byteLength > REMOTE_PLUGIN_MAX_BYTES) {
+			throw remotePluginSizeLimitError(url);
+		}
+		return body;
+	}
+
+	const reader = response.body.getReader();
+	const chunks: Buffer[] = [];
+	let received = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				break;
+			}
+			const chunk = Buffer.from(value);
+			received += chunk.byteLength;
+			if (received > REMOTE_PLUGIN_MAX_BYTES) {
+				await reader.cancel().catch(() => undefined);
+				throw remotePluginSizeLimitError(url);
+			}
+			chunks.push(chunk);
+		}
+		return Buffer.concat(chunks, received);
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+async function installRemoteFile(
+	parsed: Extract<ParsedPluginSource, { type: "remote" }>,
+	stagingRoot: string,
+): Promise<string> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, REMOTE_PLUGIN_FETCH_TIMEOUT_MS);
+	try {
+		const response = await fetch(parsed.url, { signal: controller.signal });
+		if (!response.ok) {
+			const suffix = response.statusText ? ` ${response.statusText}` : "";
+			throw new Error(
+				`Failed to download plugin file from ${parsed.url}: ${response.status}${suffix}`,
+			);
+		}
+		const body = await readRemotePluginBody(response, parsed.url);
+		mkdirSync(stagingRoot, { recursive: true });
+		await writeFile(join(stagingRoot, parsed.filename), body);
+		return stagingRoot;
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") {
+			throw new Error(
+				`Timed out downloading plugin file from ${parsed.url} after ${REMOTE_PLUGIN_FETCH_TIMEOUT_MS}ms`,
+			);
+		}
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+async function installLocalPackage(
+	parsed: Extract<ParsedPluginSource, { type: "local" }>,
+	stagingRoot: string,
+	cwd: string,
+	npmCommand: string,
+): Promise<string> {
+	const absolutePath = resolve(cwd, resolveHomePath(parsed.path));
+	if (!existsSync(absolutePath)) {
+		throw new Error(`Plugin source path does not exist: ${absolutePath}`);
+	}
+	const stats = statSync(absolutePath);
+	if (stats.isFile()) {
+		if (!isPluginModulePath(absolutePath)) {
+			throw new Error(`Plugin file must be .js or .ts: ${absolutePath}`);
+		}
+		mkdirSync(stagingRoot, { recursive: true });
+		const targetPath = join(stagingRoot, basename(absolutePath));
+		await cp(absolutePath, targetPath);
+		return stagingRoot;
+	}
+	if (!stats.isDirectory()) {
+		throw new Error(
+			`Plugin source must be a file or directory: ${absolutePath}`,
+		);
+	}
+	const packageRoot = join(stagingRoot, PACKAGE_DIRECTORY_NAME);
+	await cp(absolutePath, packageRoot, {
+		recursive: true,
+		filter: (sourcePath) => {
+			const name = basename(sourcePath);
+			return name !== ".git" && name !== "node_modules";
+		},
+	});
+	await installPackageDependencies(packageRoot, npmCommand);
+	return packageRoot;
+}
+
+function assertCanInstall(targetPath: string, force: boolean): void {
+	if (existsSync(targetPath) && !force) {
+		throw new Error(
+			`Plugin is already installed at ${targetPath}. Use --force to replace it.`,
+		);
+	}
+}
+
+function replaceInstallPath(
+	stagingRoot: string,
+	installPath: string,
+	force: boolean,
+): void {
+	mkdirSync(dirname(installPath), { recursive: true });
+	if (!existsSync(installPath)) {
+		renameSync(stagingRoot, installPath);
+		return;
+	}
+	if (!force) {
+		throw new Error(
+			`Plugin is already installed at ${installPath}. Use --force to replace it.`,
+		);
+	}
+
+	const backupPath = join(
+		dirname(installPath),
+		`.replace-${basename(installPath)}-${Date.now()}-${process.pid}-${hashSource(
+			`${installPath}:${Math.random()}`,
+		)}`,
+	);
+	renameSync(installPath, backupPath);
+	try {
+		renameSync(stagingRoot, installPath);
+	} catch (error) {
+		if (!existsSync(installPath) && existsSync(backupPath)) {
+			renameSync(backupPath, installPath);
+		}
+		throw error;
+	}
+	try {
+		rmSync(backupPath, { recursive: true, force: true });
+	} catch {
+		// The replacement already succeeded; leftover backup cleanup is best effort.
+	}
+}
+
+function hasStaticHeaders(registration: McpServerRegistration): boolean {
+	const transport = registration.transport;
+	if (transport.type === "stdio") {
+		return false;
+	}
+	return (
+		transport.headers !== undefined && Object.keys(transport.headers).length > 0
+	);
+}
+
+function hasOAuthAccessToken(registration: McpServerRegistration): boolean {
+	const accessToken = registration.oauth?.tokens?.access_token;
+	return typeof accessToken === "string" && accessToken.trim().length > 0;
+}
+
+function getPluginOwner(
+	registration: McpServerRegistration,
+): { pluginName: string; pluginPath: string } | undefined {
+	const metadata = registration.metadata;
+	if (
+		!metadata ||
+		metadata.source !== "plugin" ||
+		typeof metadata.pluginName !== "string" ||
+		typeof metadata.pluginPath !== "string"
+	) {
+		return undefined;
+	}
+	return {
+		pluginName: metadata.pluginName,
+		pluginPath: metadata.pluginPath,
+	};
+}
+
+export function collectPluginMcpOAuthCandidates(input: {
+	pluginPaths: readonly string[];
+	settingsPath?: string;
+}): PluginMcpOAuthCandidate[] {
+	const pluginPaths = new Set(input.pluginPaths.map((path) => resolve(path)));
+	if (pluginPaths.size === 0) {
+		return [];
+	}
+
+	let registrations: McpServerRegistration[];
+	try {
+		registrations = resolveMcpServerRegistrations({
+			filePath: input.settingsPath ?? resolveDefaultMcpSettingsPath(),
+		});
+	} catch {
+		return [];
+	}
+
+	const candidates: PluginMcpOAuthCandidate[] = [];
+	for (const registration of registrations) {
+		const owner = getPluginOwner(registration);
+		if (!owner || !pluginPaths.has(resolve(owner.pluginPath))) {
+			continue;
+		}
+		const transportType = registration.transport.type;
+		if (transportType === "stdio") {
+			continue;
+		}
+		if (hasStaticHeaders(registration) || hasOAuthAccessToken(registration)) {
+			continue;
+		}
+		candidates.push({
+			name: registration.name,
+			pluginName: owner.pluginName,
+			pluginPath: owner.pluginPath,
+			transportType,
+			lastError: registration.oauth?.lastError,
+		});
+	}
+	return candidates.sort((left, right) => left.name.localeCompare(right.name));
+}
+
+export async function installPlugin(
+	options: PluginInstallOptions,
+): Promise<PluginInstallResult> {
+	const source = options.source.trim();
+	const parsed = parsePluginSource(source, options.sourceType);
+	const explicitCwd = options.cwd?.trim();
+	const cwd = explicitCwd ? resolve(explicitCwd) : process.cwd();
+	const pluginRoot = getPluginRoot(explicitCwd ? cwd : undefined);
+	const officialPluginsRepo = resolveOfficialPluginsRepo(
+		options.officialPluginsRepo,
+	);
+	const sourceKey = getInstallSourceKey(parsed, cwd, officialPluginsRepo);
+	const installPath = getInstallPath(pluginRoot, parsed, sourceKey);
+	const wrapperPackageName = getWrapperPackageName(parsed, cwd);
+	const stagingParent = join(pluginRoot, INSTALLS_DIRECTORY_NAME, ".tmp");
+	const stagingRoot = join(
+		stagingParent,
+		`${Date.now()}-${process.pid}-${hashSource(`${source}:${Math.random()}`)}`,
+	);
+	const npmCommand =
+		options.npmCommand ?? (process.env.CLINE_NPM_COMMAND?.trim() || "npm");
+
+	const force = options.force === true;
+	assertCanInstall(installPath, force);
+	await mkdir(stagingParent, { recursive: true });
+
+	let packageRoot: string;
+	try {
+		if (parsed.type === "npm") {
+			packageRoot = await installNpmPackage(parsed, stagingRoot, npmCommand);
+		} else if (parsed.type === "git") {
+			packageRoot = await installGitPackage(parsed, stagingRoot, npmCommand);
+		} else if (parsed.type === "official") {
+			packageRoot = await installOfficialPlugin(
+				parsed,
+				stagingRoot,
+				npmCommand,
+				officialPluginsRepo,
+			);
+		} else if (parsed.type === "remote") {
+			packageRoot = await installRemoteFile(parsed, stagingRoot);
+		} else {
+			packageRoot = await installLocalPackage(
+				parsed,
+				stagingRoot,
+				cwd,
+				npmCommand,
+			);
+		}
+
+		const entryPaths =
+			(parsed.type === "local" || parsed.type === "remote") &&
+			packageRoot === stagingRoot
+				? collectPluginEntries(stagingRoot).map(
+						(entry) => `./${toPosixPath(relative(stagingRoot, entry))}`,
+					)
+				: await writeWrapperManifest(
+						stagingRoot,
+						packageRoot,
+						wrapperPackageName,
+					);
+		if (entryPaths.length === 0) {
+			throw new Error(`No plugin entry files found for ${source}`);
+		}
+
+		replaceInstallPath(stagingRoot, installPath, force);
+		const result = {
+			source,
+			installPath,
+			entryPaths: entryPaths.map((entry) => resolve(installPath, entry)),
+			mcpSyncFailures: [] as PluginMcpSettingsSyncResult["failures"],
+			mcpOAuthCandidates: [] as PluginMcpOAuthCandidate[],
+		};
+		const syncResult = await syncPluginMcpServersToSettings({
+			pluginPaths: result.entryPaths,
+			cwd,
+			workspacePath: cwd,
+		});
+		result.mcpSyncFailures = syncResult.failures;
+		result.mcpOAuthCandidates = collectPluginMcpOAuthCandidates({
+			pluginPaths: result.entryPaths,
+		});
+		return result;
+	} catch (error) {
+		rmSync(stagingRoot, { recursive: true, force: true });
+		throw error;
+	}
+}
diff --git a/sdk/packages/core/src/services/plugin-mcp-settings.test.ts b/sdk/packages/core/src/services/plugin-mcp-settings.test.ts
new file mode 100644
index 0000000..6bd7d73
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-mcp-settings.test.ts
@@ -0,0 +1,570 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	disablePluginMcpServersInSettings,
+	removePluginMcpServersFromSettings,
+	syncPluginMcpServersToSettings,
+} from "./plugin-mcp-settings";
+
+describe("plugin MCP settings sync", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((directory) =>
+				rm(directory, { recursive: true, force: true }),
+			),
+		);
+		tempRoots.length = 0;
+	});
+
+	async function createPlugin(source: string): Promise<{
+		root: string;
+		pluginPath: string;
+		settingsPath: string;
+	}> {
+		const root = await mkdtemp(join(tmpdir(), "core-plugin-mcp-settings-"));
+		tempRoots.push(root);
+		const pluginPath = join(root, "plugin.mjs");
+		const settingsPath = join(root, "cline_mcp_settings.json");
+		await writeFile(pluginPath, source, "utf8");
+		return { root, pluginPath, settingsPath };
+	}
+
+	it("writes plugin MCP servers into mcp settings", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`);
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result.mutations).toEqual([
+			expect.objectContaining({
+				name: "repo-docs",
+				pluginName: "repo-docs",
+				pluginPath,
+				action: "created",
+			}),
+		]);
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<
+				string,
+				{ metadata?: Record<string, unknown>; transport?: unknown }
+			>;
+		};
+		expect(written.mcpServers?.["repo-docs"]?.metadata).toMatchObject({
+			source: "plugin",
+			pluginName: "repo-docs",
+			pluginPath,
+		});
+	});
+
+	it("defaults plugin stdio MCP cwd to the plugin directory", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "stdio", command: "node", args: ["./server.js"] },
+    })
+  },
+}
+`);
+
+		await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { transport?: { cwd?: string } }>;
+		};
+		expect(written.mcpServers?.["repo-docs"]?.transport?.cwd).toBe(
+			dirname(pluginPath),
+		);
+	});
+
+	it("preserves explicit plugin stdio MCP cwd", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "stdio", command: "node", args: ["./server.js"], cwd: "/tmp/custom-cwd" },
+    })
+  },
+}
+`);
+
+		await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { transport?: { cwd?: string } }>;
+		};
+		expect(written.mcpServers?.["repo-docs"]?.transport?.cwd).toBe(
+			"/tmp/custom-cwd",
+		);
+	});
+
+	it("does not create settings for plugins without MCP servers", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "plain-tools",
+  manifest: { capabilities: ["tools"] },
+  setup(api) {
+    api.registerTool({
+      name: "plain",
+      inputSchema: {},
+      execute: async () => "ok",
+    })
+  },
+}
+`);
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result).toEqual({
+			mutations: [],
+			failures: [],
+		});
+		await expect(readFile(settingsPath, "utf8")).rejects.toThrow();
+	});
+
+	it("removes stale owned servers when a plugin stops declaring MCP", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "plain-tools",
+  manifest: { capabilities: ["tools"] },
+  setup(api) {
+    api.registerTool({
+      name: "plain",
+      inputSchema: {},
+      execute: async () => "ok",
+    })
+  },
+}
+`);
+		await writeFile(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						"old-docs": {
+							transport: {
+								type: "streamableHttp",
+								url: "https://old.example.com/mcp",
+							},
+							metadata: {
+								source: "plugin",
+								pluginName: "plain-tools",
+								pluginPath,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result.mutations).toEqual([
+			expect.objectContaining({
+				name: "old-docs",
+				pluginName: "plain-tools",
+				pluginPath,
+				action: "removed",
+			}),
+		]);
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, unknown>;
+		};
+		expect(written.mcpServers?.["old-docs"]).toBeUndefined();
+	});
+
+	it("removes stale owned servers when a plugin no longer has setup", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+}
+`);
+		await writeFile(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						"old-docs": {
+							transport: {
+								type: "streamableHttp",
+								url: "https://old.example.com/mcp",
+							},
+							metadata: {
+								source: "plugin",
+								pluginName: "repo-docs",
+								pluginPath,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result.mutations).toEqual([
+			expect.objectContaining({
+				name: "old-docs",
+				pluginName: "repo-docs",
+				pluginPath,
+				action: "removed",
+			}),
+		]);
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, unknown>;
+		};
+		expect(written.mcpServers?.["old-docs"]).toBeUndefined();
+	});
+
+	it("isolates plugin setup failures while syncing other plugins", async () => {
+		const { root, settingsPath } = await createPlugin("export default {};\n");
+		const goodPluginPath = join(root, "good-plugin.mjs");
+		const badPluginPath = join(root, "bad-plugin.mjs");
+		await writeFile(
+			goodPluginPath,
+			`
+export default {
+  name: "good-plugin",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "good-docs",
+      transport: { type: "streamableHttp", url: "https://good.example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		await writeFile(
+			badPluginPath,
+			`
+export default {
+  name: "bad-plugin",
+  manifest: { capabilities: ["tools"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "bad-docs",
+      transport: { type: "streamableHttp", url: "https://bad.example.com/mcp" },
+    })
+  },
+}
+`,
+			"utf8",
+		);
+		await writeFile(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						"bad-docs": {
+							transport: {
+								type: "streamableHttp",
+								url: "https://old-bad.example.com/mcp",
+							},
+							metadata: {
+								source: "plugin",
+								pluginName: "bad-plugin",
+								pluginPath: badPluginPath,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [goodPluginPath, badPluginPath],
+			settingsPath,
+		});
+
+		expect(result.failures).toEqual([
+			expect.objectContaining({
+				pluginPath: badPluginPath,
+				pluginName: "bad-plugin",
+				message: 'registerMcpServer requires the "mcp" capability',
+			}),
+		]);
+		expect(result.mutations).toEqual([
+			expect.objectContaining({
+				name: "good-docs",
+				pluginName: "good-plugin",
+				pluginPath: goodPluginPath,
+				action: "created",
+			}),
+		]);
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { transport?: { url?: string } }>;
+		};
+		expect(written.mcpServers?.["good-docs"]?.transport?.url).toBe(
+			"https://good.example.com/mcp",
+		);
+		expect(written.mcpServers?.["bad-docs"]?.transport?.url).toBe(
+			"https://old-bad.example.com/mcp",
+		);
+	});
+
+	it("skips user-owned name collisions", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "streamableHttp", url: "https://plugin.example.com/mcp" },
+    })
+  },
+}
+`);
+		await writeFile(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						"repo-docs": {
+							transport: {
+								type: "streamableHttp",
+								url: "https://user.example.com/mcp",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result.mutations[0]).toMatchObject({
+			name: "repo-docs",
+			action: "skipped",
+		});
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { transport?: { url?: string } }>;
+		};
+		expect(written.mcpServers?.["repo-docs"]?.transport?.url).toBe(
+			"https://user.example.com/mcp",
+		);
+	});
+
+	it("does not overwrite invalid MCP settings", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`);
+		await writeFile(settingsPath, "{ nope", "utf8");
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result.failures[0]).toEqual(
+			expect.objectContaining({
+				pluginPath,
+			}),
+		);
+		expect(await readFile(settingsPath, "utf8")).toBe("{ nope");
+	});
+
+	it("returns write failures instead of throwing after plugin sync", async () => {
+		const { root, pluginPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`);
+		const blockedDirectory = join(root, "not-a-directory");
+		await writeFile(blockedDirectory, "file", "utf8");
+		const settingsPath = join(blockedDirectory, "cline_mcp_settings.json");
+
+		const result = await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		expect(result.mutations).toEqual([
+			expect.objectContaining({
+				name: "repo-docs",
+				pluginName: "repo-docs",
+				pluginPath,
+				action: "created",
+			}),
+		]);
+		expect(result.failures).toEqual([
+			expect.objectContaining({
+				pluginPath,
+			}),
+		]);
+		expect(result.failures[0]?.message).toContain(blockedDirectory);
+	});
+
+	it("preserves oauth when updating plugin-owned entries", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "streamableHttp", url: "https://new.example.com/mcp" },
+    })
+  },
+}
+`);
+		await writeFile(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						"repo-docs": {
+							transport: {
+								type: "streamableHttp",
+								url: "https://old.example.com/mcp",
+							},
+							oauth: {
+								tokens: {
+									access_token: "token",
+								},
+							},
+							metadata: {
+								source: "plugin",
+								pluginName: "repo-docs",
+								pluginPath,
+							},
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		const written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<
+				string,
+				{
+					transport?: { url?: string };
+					oauth?: { tokens?: Record<string, string> };
+				}
+			>;
+		};
+		expect(written.mcpServers?.["repo-docs"]?.transport?.url).toBe(
+			"https://new.example.com/mcp",
+		);
+		expect(written.mcpServers?.["repo-docs"]?.oauth?.tokens?.access_token).toBe(
+			"token",
+		);
+	});
+
+	it("disables and removes plugin-owned entries", async () => {
+		const { pluginPath, settingsPath } = await createPlugin(`
+export default {
+  name: "repo-docs",
+  manifest: { capabilities: ["mcp"] },
+  setup(api) {
+    api.registerMcpServer({
+      name: "repo-docs",
+      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
+    })
+  },
+}
+`);
+		await syncPluginMcpServersToSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+
+		disablePluginMcpServersInSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+		let written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { disabled?: boolean } | undefined>;
+		};
+		expect(written.mcpServers?.["repo-docs"]?.disabled).toBe(true);
+
+		removePluginMcpServersFromSettings({
+			pluginPaths: [pluginPath],
+			settingsPath,
+		});
+		written = JSON.parse(await readFile(settingsPath, "utf8")) as {
+			mcpServers?: Record<string, { disabled?: boolean } | undefined>;
+		};
+		expect(written.mcpServers?.["repo-docs"]).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/services/plugin-mcp-settings.ts b/sdk/packages/core/src/services/plugin-mcp-settings.ts
new file mode 100644
index 0000000..167687c
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-mcp-settings.ts
@@ -0,0 +1,544 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import type {
+	AgentConfig,
+	AgentExtensionMcpServer,
+	AgentTool,
+} from "@cline/shared";
+import {
+	type McpServerRegistration,
+	resolveDefaultMcpSettingsPath,
+	resolvePluginMcpServerRegistrations,
+} from "../extensions/mcp";
+import { loadSandboxedPlugins } from "../extensions/plugin/plugin-sandbox";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+type AgentExtensionWithPath = AgentExtension & { __clinePluginPath?: string };
+
+export interface PluginMcpSettingsMutation {
+	name: string;
+	pluginName: string;
+	pluginPath: string;
+	action: "created" | "updated" | "skipped" | "removed" | "disabled";
+	reason?: string;
+}
+
+export interface PluginMcpSettingsSyncResult {
+	mutations: PluginMcpSettingsMutation[];
+	failures: Array<{
+		pluginPath: string;
+		pluginName?: string;
+		message: string;
+	}>;
+}
+
+export interface SyncPluginMcpServersToSettingsOptions {
+	pluginPaths: ReadonlyArray<string>;
+	cwd?: string;
+	workspacePath?: string;
+	settingsPath?: string;
+	providerId?: string;
+	modelId?: string;
+}
+
+export interface RemovePluginMcpServersFromSettingsOptions {
+	pluginPaths?: ReadonlyArray<string>;
+	pluginNames?: ReadonlyArray<string>;
+	settingsPath?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isPathWithin(parentPath: string, childPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+function readRawSettings(filePath: string): Record<string, unknown> {
+	if (!existsSync(filePath)) {
+		return { mcpServers: {} };
+	}
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+		if (isRecord(parsed)) {
+			return parsed;
+		}
+	} catch (error) {
+		throw new Error(
+			`Invalid MCP settings at "${filePath}": ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+		);
+	}
+	throw new Error(`Invalid MCP settings at "${filePath}": expected an object`);
+}
+
+function getServers(
+	settings: Record<string, unknown>,
+): Record<string, unknown> {
+	if (isRecord(settings.mcpServers)) {
+		return { ...settings.mcpServers };
+	}
+	return {};
+}
+
+function writeRawSettings(
+	filePath: string,
+	settings: Record<string, unknown>,
+	servers: Record<string, unknown>,
+): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(
+		filePath,
+		`${JSON.stringify({ ...settings, mcpServers: servers }, null, 2)}\n`,
+		"utf8",
+	);
+}
+
+function collectOwnerInputs(input: RemovePluginMcpServersFromSettingsOptions): {
+	pluginPaths: string[];
+	pluginNames: string[];
+} {
+	return {
+		pluginPaths: [
+			...new Set(
+				(input.pluginPaths ?? [])
+					.map((path) => path.trim())
+					.filter((path) => path.length > 0),
+			),
+		],
+		pluginNames: [
+			...new Set(
+				(input.pluginNames ?? [])
+					.map((name) => name.trim())
+					.filter((name) => name.length > 0),
+			),
+		],
+	};
+}
+
+function getMetadata(record: unknown): Record<string, unknown> | undefined {
+	if (!isRecord(record)) {
+		return undefined;
+	}
+	const metadata = record.metadata;
+	return isRecord(metadata) ? metadata : undefined;
+}
+
+function isPluginOwnedRecord(
+	record: unknown,
+	input: {
+		pluginName?: string;
+		pluginPath?: string;
+		pluginPaths?: ReadonlyArray<string>;
+		pluginNames?: ReadonlyArray<string>;
+	},
+): boolean {
+	const metadata = getMetadata(record);
+	if (!metadata || metadata.source !== "plugin") {
+		return false;
+	}
+	const recordPluginName =
+		typeof metadata.pluginName === "string"
+			? metadata.pluginName
+			: typeof metadata.plugin === "string"
+				? metadata.plugin
+				: undefined;
+	const recordPluginPath =
+		typeof metadata.pluginPath === "string" ? metadata.pluginPath : undefined;
+
+	if (input.pluginName && recordPluginName === input.pluginName) {
+		if (!input.pluginPath || recordPluginPath === input.pluginPath) {
+			return true;
+		}
+	}
+	if (
+		recordPluginPath &&
+		input.pluginPath &&
+		(recordPluginPath === input.pluginPath ||
+			isPathWithin(input.pluginPath, recordPluginPath) ||
+			isPathWithin(recordPluginPath, input.pluginPath))
+	) {
+		return true;
+	}
+	if (
+		recordPluginName &&
+		input.pluginNames?.some((name) => name === recordPluginName)
+	) {
+		return true;
+	}
+	if (
+		recordPluginPath &&
+		input.pluginPaths?.some(
+			(path) =>
+				recordPluginPath === path ||
+				isPathWithin(path, recordPluginPath) ||
+				isPathWithin(recordPluginPath, path),
+		)
+	) {
+		return true;
+	}
+	return false;
+}
+
+function createSettingsEntry(input: {
+	registration: McpServerRegistration;
+	pluginName: string;
+	pluginPath: string;
+	existing?: Record<string, unknown>;
+	disabled?: boolean;
+}): Record<string, unknown> {
+	const existingOauth = isRecord(input.existing?.oauth)
+		? { oauth: input.existing.oauth }
+		: {};
+	const transport =
+		input.registration.transport.type === "stdio" &&
+		input.registration.transport.cwd === undefined
+			? {
+					...input.registration.transport,
+					cwd: dirname(input.pluginPath),
+				}
+			: input.registration.transport;
+	return {
+		transport,
+		...(input.disabled ? { disabled: true } : {}),
+		...existingOauth,
+		metadata: {
+			...(input.registration.metadata ?? {}),
+			source: "plugin",
+			pluginName: input.pluginName,
+			pluginPath: input.pluginPath,
+		},
+	};
+}
+
+async function collectPluginMcpServers(
+	options: SyncPluginMcpServersToSettingsOptions,
+): Promise<{
+	plugins: Array<{
+		pluginName: string;
+		pluginPath: string;
+	}>;
+	servers: Array<{
+		pluginName: string;
+		pluginPath: string;
+		server: AgentExtensionMcpServer;
+	}>;
+	failures: PluginMcpSettingsSyncResult["failures"];
+}> {
+	if (options.pluginPaths.length === 0) {
+		return { plugins: [], servers: [], failures: [] };
+	}
+	const sandboxed = await loadSandboxedPlugins({
+		pluginPaths: [...options.pluginPaths],
+		cwd: options.cwd,
+		providerId: options.providerId,
+		modelId: options.modelId,
+		workspaceInfo: options.workspacePath
+			? { rootPath: options.workspacePath }
+			: undefined,
+	});
+	try {
+		const plugins: Array<{
+			pluginName: string;
+			pluginPath: string;
+		}> = [];
+		const servers: Array<{
+			pluginName: string;
+			pluginPath: string;
+			server: AgentExtensionMcpServer;
+		}> = [];
+		const failures: PluginMcpSettingsSyncResult["failures"] = (
+			sandboxed.failures ?? []
+		).map((failure) => ({
+			pluginPath: failure.pluginPath,
+			pluginName: failure.pluginName,
+			message: failure.message,
+		}));
+		for (const extension of sandboxed.extensions ?? []) {
+			const pluginPath = (extension as AgentExtensionWithPath)
+				.__clinePluginPath;
+			if (!pluginPath) {
+				continue;
+			}
+			if (!extension.setup) {
+				plugins.push({
+					pluginName: extension.name,
+					pluginPath,
+				});
+				continue;
+			}
+			const mcpServers: AgentExtensionMcpServer[] = [];
+			const api: AgentExtensionApi = {
+				registerTool: (_tool: AgentTool) => {},
+				registerCommand: () => {},
+				registerMessageBuilder: () => {},
+				registerRule: () => {},
+				registerProvider: () => {},
+				registerAutomationEventType: () => {},
+				registerMcpServer: (server) => {
+					if (!extension.manifest.capabilities.includes("mcp")) {
+						throw new Error('registerMcpServer requires the "mcp" capability');
+					}
+					mcpServers.push(server);
+				},
+			};
+			try {
+				await extension.setup(api, {
+					workspaceInfo: options.workspacePath
+						? { rootPath: options.workspacePath }
+						: undefined,
+				});
+			} catch (error) {
+				failures.push({
+					pluginPath,
+					pluginName: extension.name,
+					message: error instanceof Error ? error.message : String(error),
+				});
+				continue;
+			}
+			plugins.push({
+				pluginName: extension.name,
+				pluginPath,
+			});
+			for (const server of mcpServers) {
+				servers.push({
+					pluginName: extension.name,
+					pluginPath,
+					server: {
+						...server,
+						metadata: {
+							...(server.metadata ?? {}),
+							source: "plugin",
+							pluginName: extension.name,
+							pluginPath,
+						},
+					},
+				});
+			}
+		}
+		return { plugins, servers, failures };
+	} finally {
+		await sandboxed.shutdown().catch(() => {
+			// Best-effort cleanup after contribution discovery.
+		});
+	}
+}
+
+export async function syncPluginMcpServersToSettings(
+	options: SyncPluginMcpServersToSettingsOptions,
+): Promise<PluginMcpSettingsSyncResult> {
+	const settingsPath = options.settingsPath ?? resolveDefaultMcpSettingsPath();
+	const result: PluginMcpSettingsSyncResult = {
+		mutations: [],
+		failures: [],
+	};
+	let collected: Awaited<ReturnType<typeof collectPluginMcpServers>>;
+	try {
+		collected = await collectPluginMcpServers(options);
+	} catch (error) {
+		for (const pluginPath of options.pluginPaths) {
+			result.failures.push({
+				pluginPath,
+				message: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return result;
+	}
+	result.failures.push(...collected.failures);
+
+	let settings: Record<string, unknown>;
+	try {
+		settings = readRawSettings(settingsPath);
+	} catch (error) {
+		for (const pluginPath of options.pluginPaths) {
+			result.failures.push({
+				pluginPath,
+				message: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return result;
+	}
+	const servers = getServers(settings);
+	const declaredNamesByPluginPath = new Map<string, Set<string>>();
+	const pluginNameByPath = new Map<string, string>();
+	for (const plugin of collected.plugins) {
+		declaredNamesByPluginPath.set(plugin.pluginPath, new Set());
+		pluginNameByPath.set(plugin.pluginPath, plugin.pluginName);
+	}
+	const resolved = resolvePluginMcpServerRegistrations(
+		collected.servers.map((entry) => ({
+			server: entry.server,
+			owner: entry,
+			ownerLabel: entry.pluginName,
+		})),
+	);
+
+	for (const resolution of resolved) {
+		const owner = resolution.owner;
+		if (!declaredNamesByPluginPath.has(owner.pluginPath)) {
+			declaredNamesByPluginPath.set(owner.pluginPath, new Set());
+		}
+		if (resolution.name) {
+			declaredNamesByPluginPath.get(owner.pluginPath)?.add(resolution.name);
+		}
+		if (!resolution.registration) {
+			result.mutations.push({
+				name: resolution.name,
+				pluginName: owner.pluginName,
+				pluginPath: owner.pluginPath,
+				action: "skipped",
+				reason: resolution.loadError ?? "invalid MCP server registration",
+			});
+			continue;
+		}
+
+		const existing = servers[resolution.registration.name];
+		if (existing !== undefined) {
+			if (
+				!isPluginOwnedRecord(existing, {
+					pluginName: owner.pluginName,
+					pluginPath: owner.pluginPath,
+				})
+			) {
+				result.mutations.push({
+					name: resolution.registration.name,
+					pluginName: owner.pluginName,
+					pluginPath: owner.pluginPath,
+					action: "skipped",
+					reason: "MCP server name is already configured",
+				});
+				continue;
+			}
+		}
+
+		servers[resolution.registration.name] = createSettingsEntry({
+			registration: resolution.registration,
+			pluginName: owner.pluginName,
+			pluginPath: owner.pluginPath,
+			existing: isRecord(existing) ? existing : undefined,
+		});
+		result.mutations.push({
+			name: resolution.registration.name,
+			pluginName: owner.pluginName,
+			pluginPath: owner.pluginPath,
+			action: existing === undefined ? "created" : "updated",
+		});
+	}
+
+	for (const [serverName, record] of Object.entries(servers)) {
+		const metadata = getMetadata(record);
+		const pluginPath =
+			typeof metadata?.pluginPath === "string" ? metadata.pluginPath : "";
+		const declaredNames = declaredNamesByPluginPath.get(pluginPath);
+		if (
+			declaredNames &&
+			isPluginOwnedRecord(record, { pluginPath }) &&
+			!declaredNames.has(serverName)
+		) {
+			delete servers[serverName];
+			result.mutations.push({
+				name: serverName,
+				pluginName:
+					typeof metadata?.pluginName === "string"
+						? metadata.pluginName
+						: (pluginNameByPath.get(pluginPath) ?? "plugin"),
+				pluginPath,
+				action: "removed",
+				reason: "plugin no longer declares this MCP server",
+			});
+		}
+	}
+
+	if (result.mutations.some((mutation) => mutation.action !== "skipped")) {
+		try {
+			writeRawSettings(settingsPath, settings, servers);
+		} catch (error) {
+			for (const pluginPath of options.pluginPaths) {
+				result.failures.push({
+					pluginPath,
+					message: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
+	}
+	return result;
+}
+
+export function disablePluginMcpServersInSettings(
+	options: RemovePluginMcpServersFromSettingsOptions,
+): PluginMcpSettingsMutation[] {
+	const settingsPath = options.settingsPath ?? resolveDefaultMcpSettingsPath();
+	let settings: Record<string, unknown>;
+	try {
+		settings = readRawSettings(settingsPath);
+	} catch {
+		return [];
+	}
+	const servers = getServers(settings);
+	const ownerInput = collectOwnerInputs(options);
+	const mutations: PluginMcpSettingsMutation[] = [];
+	for (const [serverName, record] of Object.entries(servers)) {
+		if (!isRecord(record) || !isPluginOwnedRecord(record, ownerInput)) {
+			continue;
+		}
+		const metadata = getMetadata(record);
+		servers[serverName] = { ...record, disabled: true };
+		mutations.push({
+			name: serverName,
+			pluginName:
+				typeof metadata?.pluginName === "string"
+					? metadata.pluginName
+					: "plugin",
+			pluginPath:
+				typeof metadata?.pluginPath === "string" ? metadata.pluginPath : "",
+			action: "disabled",
+		});
+	}
+	if (mutations.length > 0) {
+		writeRawSettings(settingsPath, settings, servers);
+	}
+	return mutations;
+}
+
+export function removePluginMcpServersFromSettings(
+	options: RemovePluginMcpServersFromSettingsOptions,
+): PluginMcpSettingsMutation[] {
+	const settingsPath = options.settingsPath ?? resolveDefaultMcpSettingsPath();
+	let settings: Record<string, unknown>;
+	try {
+		settings = readRawSettings(settingsPath);
+	} catch {
+		return [];
+	}
+	const servers = getServers(settings);
+	const ownerInput = collectOwnerInputs(options);
+	const mutations: PluginMcpSettingsMutation[] = [];
+	for (const [serverName, record] of Object.entries(servers)) {
+		if (!isPluginOwnedRecord(record, ownerInput)) {
+			continue;
+		}
+		const metadata = getMetadata(record);
+		delete servers[serverName];
+		mutations.push({
+			name: serverName,
+			pluginName:
+				typeof metadata?.pluginName === "string"
+					? metadata.pluginName
+					: "plugin",
+			pluginPath:
+				typeof metadata?.pluginPath === "string" ? metadata.pluginPath : "",
+			action: "removed",
+		});
+	}
+	if (mutations.length > 0) {
+		writeRawSettings(settingsPath, settings, servers);
+	}
+	return mutations;
+}
diff --git a/sdk/packages/core/src/services/plugin-tools.ts b/sdk/packages/core/src/services/plugin-tools.ts
new file mode 100644
index 0000000..53aad11
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-tools.ts
@@ -0,0 +1,259 @@
+import { stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import type { AgentConfig, AgentTool } from "@cline/shared";
+import { resolveAgentPluginPaths } from "../extensions/plugin/plugin-config-loader";
+import type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+} from "../extensions/plugin/plugin-load-report";
+import { loadSandboxedPlugins } from "../extensions/plugin/plugin-sandbox";
+import { resolveDisabledToolNames } from "./global-settings";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+type AgentExtensionWithPath = AgentExtension & { __clinePluginPath?: string };
+
+function isPathWithin(parentPath: string, childPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+export interface PluginToolSummary {
+	name: string;
+	pluginName: string;
+	path: string;
+	source: "workspace-plugin" | "global-plugin";
+	enabled: boolean;
+	description?: string;
+}
+
+export interface ListPluginToolsResult {
+	tools: PluginToolSummary[];
+	failures: PluginInitializationFailure[];
+	warnings: PluginInitializationWarning[];
+}
+
+type PluginToolDescriptor = Omit<PluginToolSummary, "enabled">;
+type PluginToolDescriptorCacheEntry = {
+	tools: PluginToolDescriptor[];
+	failures: PluginInitializationFailure[];
+	warnings: PluginInitializationWarning[];
+};
+
+const MAX_PLUGIN_TOOL_DESCRIPTOR_CACHE_ENTRIES = 32;
+const pluginToolDescriptorCache = new Map<
+	string,
+	PluginToolDescriptorCacheEntry
+>();
+
+function cachePluginToolDescriptors(
+	key: string,
+	entry: PluginToolDescriptorCacheEntry,
+): void {
+	if (
+		!pluginToolDescriptorCache.has(key) &&
+		pluginToolDescriptorCache.size >= MAX_PLUGIN_TOOL_DESCRIPTOR_CACHE_ENTRIES
+	) {
+		const oldestKey = pluginToolDescriptorCache.keys().next().value;
+		if (oldestKey) {
+			pluginToolDescriptorCache.delete(oldestKey);
+		}
+	}
+	pluginToolDescriptorCache.set(key, entry);
+}
+
+async function buildPluginToolDescriptorCacheKey(input: {
+	pluginPaths: ReadonlyArray<string>;
+	workspacePath: string;
+	cwd?: string;
+	providerId?: string;
+	modelId?: string;
+}): Promise<string> {
+	const pathStats = await Promise.all(
+		input.pluginPaths.map(async (pluginPath) => {
+			try {
+				const stats = await stat(pluginPath);
+				return `${pluginPath}:${stats.mtimeMs}:${stats.size}`;
+			} catch {
+				return `${pluginPath}:missing`;
+			}
+		}),
+	);
+	return JSON.stringify({
+		workspacePath: input.workspacePath,
+		cwd: input.cwd,
+		providerId: input.providerId,
+		modelId: input.modelId,
+		pathStats,
+	});
+}
+
+function withEnabledState(
+	tools: readonly PluginToolDescriptor[],
+	disabled: ReadonlySet<string>,
+): PluginToolSummary[] {
+	return tools.map((tool) => ({
+		...tool,
+		enabled: !disabled.has(tool.name),
+	}));
+}
+
+function sortPluginToolDescriptors(
+	tools: PluginToolDescriptor[],
+): PluginToolDescriptor[] {
+	return tools.sort((left, right) => {
+		const nameOrder = left.name.localeCompare(right.name);
+		if (nameOrder !== 0) {
+			return nameOrder;
+		}
+		return left.path.localeCompare(right.path);
+	});
+}
+
+async function collectPluginContributions(
+	extension: AgentExtension,
+	workspaceInfo?: { rootPath: string },
+): Promise<{
+	tools: AgentTool[];
+}> {
+	if (!extension.setup) {
+		return { tools: [] };
+	}
+
+	const tools: AgentTool[] = [];
+	const api: AgentExtensionApi = {
+		registerTool: (tool) => tools.push(tool),
+		registerCommand: () => {},
+		registerMessageBuilder: () => {},
+		registerRule: () => {},
+		registerProvider: () => {},
+		registerAutomationEventType: () => {},
+		registerMcpServer: (_server) => {
+			if (!extension.manifest.capabilities.includes("mcp")) {
+				throw new Error('registerMcpServer requires the "mcp" capability');
+			}
+		},
+	};
+	await extension.setup(api, { workspaceInfo });
+	return { tools };
+}
+
+export async function listPluginToolsWithDiagnostics(input: {
+	workspacePath: string;
+	cwd?: string;
+	disabledToolNames?: ReadonlyArray<string>;
+	providerId?: string;
+	modelId?: string;
+}): Promise<ListPluginToolsResult> {
+	const pluginPaths = resolveAgentPluginPaths({
+		workspacePath: input.workspacePath,
+		cwd: input.cwd,
+	});
+	const disabled = resolveDisabledToolNames(input.disabledToolNames);
+	if (pluginPaths.length === 0) {
+		return { tools: [], failures: [], warnings: [] };
+	}
+
+	const cacheKey = await buildPluginToolDescriptorCacheKey({
+		pluginPaths,
+		workspacePath: input.workspacePath,
+		cwd: input.cwd,
+		providerId: input.providerId,
+		modelId: input.modelId,
+	});
+	const cached = pluginToolDescriptorCache.get(cacheKey);
+	if (cached) {
+		return {
+			tools: withEnabledState(cached.tools, disabled),
+			failures: cached.failures,
+			warnings: cached.warnings,
+		};
+	}
+
+	const tools: PluginToolDescriptor[] = [];
+	let failures: PluginInitializationFailure[] = [];
+	let warnings: PluginInitializationWarning[] = [];
+	let sandboxed: Awaited<ReturnType<typeof loadSandboxedPlugins>> | undefined;
+
+	try {
+		sandboxed = await loadSandboxedPlugins({
+			pluginPaths,
+			cwd: input.cwd,
+			providerId: input.providerId,
+			modelId: input.modelId,
+			workspaceInfo: { rootPath: input.workspacePath },
+		});
+		failures = [...sandboxed.failures];
+		warnings = [...sandboxed.warnings];
+		for (const extension of sandboxed.extensions ?? []) {
+			const pluginPath = (extension as AgentExtensionWithPath)
+				.__clinePluginPath;
+			if (!pluginPath) {
+				continue;
+			}
+			const pluginSource = isPathWithin(input.workspacePath, pluginPath)
+				? "workspace-plugin"
+				: "global-plugin";
+			let contributions: Awaited<ReturnType<typeof collectPluginContributions>>;
+			try {
+				contributions = await collectPluginContributions(extension, {
+					rootPath: input.workspacePath,
+				});
+			} catch (error) {
+				failures.push({
+					pluginPath,
+					pluginName: extension.name,
+					phase: "setup",
+					message: error instanceof Error ? error.message : String(error),
+					stack: error instanceof Error ? error.stack : undefined,
+				});
+				continue;
+			}
+			for (const tool of contributions.tools) {
+				tools.push({
+					name: tool.name,
+					pluginName: extension.name,
+					path: pluginPath,
+					source: pluginSource,
+					description: tool.description?.trim() || undefined,
+				});
+			}
+		}
+	} catch (error) {
+		failures = pluginPaths.map((pluginPath) => ({
+			pluginPath,
+			phase: "load" as const,
+			message: error instanceof Error ? error.message : String(error),
+			stack: error instanceof Error ? error.stack : undefined,
+		}));
+	} finally {
+		await sandboxed?.shutdown().catch(() => {
+			// Best effort cleanup after contribution discovery.
+		});
+	}
+
+	const sortedTools = sortPluginToolDescriptors(tools);
+	cachePluginToolDescriptors(cacheKey, {
+		tools: sortedTools,
+		failures,
+		warnings,
+	});
+	return {
+		tools: withEnabledState(sortedTools, disabled),
+		failures,
+		warnings,
+	};
+}
+
+export async function listPluginTools(input: {
+	workspacePath: string;
+	cwd?: string;
+	disabledToolNames?: ReadonlyArray<string>;
+	providerId?: string;
+	modelId?: string;
+}): Promise<PluginToolSummary[]> {
+	return (await listPluginToolsWithDiagnostics(input)).tools;
+}
diff --git a/sdk/packages/core/src/services/plugin-uninstall.test.ts b/sdk/packages/core/src/services/plugin-uninstall.test.ts
new file mode 100644
index 0000000..21b3b88
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-uninstall.test.ts
@@ -0,0 +1,220 @@
+import { chmodSync, existsSync, mkdtempSync, rmSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setClineDir, setHomeDir } from "@cline/shared/storage";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { readGlobalSettings, writeGlobalSettings } from "./global-settings";
+import { uninstallPlugin } from "./plugin-uninstall";
+
+describe("plugin uninstall service", () => {
+	let root = "";
+	let home = "";
+	let originalHome: string | undefined;
+	let originalClineDir: string | undefined;
+	let originalClineDataDir: string | undefined;
+	let originalGlobalSettingsPath: string | undefined;
+	let originalMcpSettingsPath: string | undefined;
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "core-plugin-uninstall-"));
+		home = join(root, "home");
+		originalHome = process.env.HOME;
+		originalClineDir = process.env.CLINE_DIR;
+		originalClineDataDir = process.env.CLINE_DATA_DIR;
+		originalGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+		process.env.HOME = home;
+		process.env.CLINE_DIR = join(home, ".cline");
+		process.env.CLINE_DATA_DIR = join(home, ".cline", "data");
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			home,
+			".cline",
+			"data",
+			"settings",
+			"global-settings.json",
+		);
+		setHomeDir(home);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = originalHome;
+		}
+		if (originalClineDir === undefined) {
+			delete process.env.CLINE_DIR;
+		} else {
+			process.env.CLINE_DIR = originalClineDir;
+		}
+		if (originalClineDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalClineDataDir;
+		}
+		if (originalGlobalSettingsPath === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = originalGlobalSettingsPath;
+		}
+		if (originalMcpSettingsPath === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
+		}
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	it("uninstalls an installed package plugin by package name", async () => {
+		const installPath = join(
+			home,
+			".cline",
+			"plugins",
+			"_installed",
+			"local",
+			"bundled-skills-demo-123456789abc",
+		);
+		const entryPath = join(installPath, "package", "index.ts");
+		await mkdir(join(installPath, "package"), { recursive: true });
+		await writeFile(
+			join(installPath, "package.json"),
+			JSON.stringify(
+				{
+					name: "cline-installed-plugin-test",
+					cline: {
+						plugins: [{ paths: ["./package/index.ts"] }],
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		await writeFile(
+			join(installPath, "package", "package.json"),
+			JSON.stringify({ name: "cline-internal-bundled-skills-demo" }, null, 2),
+			"utf8",
+		);
+		await writeFile(
+			entryPath,
+			"export default { name: 'demo', manifest: { capabilities: ['skills'] } };",
+			"utf8",
+		);
+		writeGlobalSettings({
+			disabledPlugins: [entryPath, "/tmp/other-plugin.ts"],
+		});
+
+		const result = await uninstallPlugin({
+			name: "cline-internal-bundled-skills-demo",
+		});
+
+		expect(result.installPath).toBe(installPath);
+		expect(existsSync(installPath)).toBe(false);
+		expect(readGlobalSettings()).toEqual({
+			autoUpdateEnabled: true,
+			disabledPlugins: ["/tmp/other-plugin.ts"],
+			telemetryOptOut: false,
+		});
+	});
+
+	it("uninstalls a direct plugin file by path", async () => {
+		const pluginPath = join(home, ".cline", "plugins", "direct-plugin.ts");
+		await mkdir(join(home, ".cline", "plugins"), { recursive: true });
+		await writeFile(
+			pluginPath,
+			"export default { name: 'direct', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+
+		const result = await uninstallPlugin({ path: pluginPath });
+
+		expect(result.installPath).toBe(pluginPath);
+		expect(existsSync(pluginPath)).toBe(false);
+	});
+
+	it.skipIf(process.platform === "win32")(
+		"keeps plugin files when MCP settings cleanup fails",
+		async () => {
+			const pluginPath = join(home, ".cline", "plugins", "mcp-plugin.ts");
+			const settingsPath = join(root, "cline_mcp_settings.json");
+			process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+			await mkdir(join(home, ".cline", "plugins"), { recursive: true });
+			await writeFile(
+				pluginPath,
+				"export default { name: 'mcp-plugin', manifest: { capabilities: ['mcp'] } };",
+				"utf8",
+			);
+			await writeFile(
+				settingsPath,
+				JSON.stringify(
+					{
+						mcpServers: {
+							smoke: {
+								transport: {
+									type: "stdio",
+									command: process.execPath,
+									args: ["-e", "process.exit(0)"],
+								},
+								metadata: {
+									source: "plugin",
+									pluginName: "mcp-plugin",
+									pluginPath,
+								},
+							},
+						},
+					},
+					null,
+					2,
+				),
+				"utf8",
+			);
+			chmodSync(settingsPath, 0o444);
+
+			try {
+				await expect(uninstallPlugin({ path: pluginPath })).rejects.toThrow();
+			} finally {
+				chmodSync(settingsPath, 0o644);
+			}
+
+			expect(existsSync(pluginPath)).toBe(true);
+		},
+	);
+
+	// chmod-based deletion failure cannot be simulated on Windows, where read-only
+	// directory permissions do not prevent removing files inside them.
+	it.skipIf(process.platform === "win32")(
+		"keeps disabled plugin settings if file deletion fails",
+		async () => {
+			const pluginRoot = join(home, ".cline", "plugins");
+			const pluginPath = join(pluginRoot, "locked-plugin.ts");
+			await mkdir(pluginRoot, { recursive: true });
+			await writeFile(
+				pluginPath,
+				"export default { name: 'locked', manifest: { capabilities: ['tools'] } };",
+				"utf8",
+			);
+			writeGlobalSettings({ disabledPlugins: [pluginPath] });
+			chmodSync(pluginRoot, 0o555);
+
+			try {
+				await expect(uninstallPlugin({ path: pluginPath })).rejects.toThrow();
+				expect(existsSync(pluginPath)).toBe(true);
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledPlugins: [pluginPath],
+					telemetryOptOut: false,
+				});
+			} finally {
+				chmodSync(pluginRoot, 0o755);
+			}
+		},
+	);
+
+	it("reports unmatched names clearly", async () => {
+		await expect(uninstallPlugin({ name: "missing-plugin" })).rejects.toThrow(
+			/No plugin found matching "missing-plugin"/,
+		);
+	});
+});
diff --git a/sdk/packages/core/src/services/plugin-uninstall.ts b/sdk/packages/core/src/services/plugin-uninstall.ts
new file mode 100644
index 0000000..0ce8bbb
--- /dev/null
+++ b/sdk/packages/core/src/services/plugin-uninstall.ts
@@ -0,0 +1,430 @@
+import {
+	existsSync,
+	readdirSync,
+	readFileSync,
+	rmdirSync,
+	rmSync,
+	statSync,
+} from "node:fs";
+import {
+	basename,
+	dirname,
+	extname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+	sep,
+} from "node:path";
+import {
+	discoverPluginModulePaths,
+	resolvePluginConfigSearchPaths,
+} from "@cline/shared/storage";
+import { readGlobalSettings, writeGlobalSettings } from "./global-settings";
+import { removePluginMcpServersFromSettings } from "./plugin-mcp-settings";
+
+export interface PluginUninstallOptions {
+	name?: string;
+	path?: string;
+	cwd?: string;
+	workspaceRoot?: string;
+}
+
+export interface PluginUninstallResult {
+	name: string;
+	installPath: string;
+	removedPaths: string[];
+	entryPaths: string[];
+}
+
+interface PluginUninstallCandidate {
+	installPath: string;
+	entryPaths: string[];
+	names: string[];
+	installed: boolean;
+}
+
+const INSTALLS_DIRECTORY_NAME = "_installed";
+const PACKAGE_DIRECTORY_NAME = "package";
+const INSTALL_KIND_DEPTHS = new Map<string, number>([
+	["git", 2],
+	["local", 1],
+	["npm", 1],
+	["official", 1],
+	["remote", 1],
+]);
+
+function normalizeMatchValue(value: string): string {
+	return value.trim().toLowerCase();
+}
+
+function addName(names: Set<string>, value: string | undefined): void {
+	const trimmed = value?.trim();
+	if (!trimmed) {
+		return;
+	}
+	names.add(trimmed);
+}
+
+function stripInstallHash(value: string): string {
+	return value.replace(/-[0-9a-f]{12}$/i, "");
+}
+
+function withoutExtension(value: string): string {
+	const extension = extname(value);
+	return extension ? value.slice(0, -extension.length) : value;
+}
+
+function readPackageName(packageJsonPath: string): string | undefined {
+	if (!existsSync(packageJsonPath)) {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+			name?: unknown;
+		};
+		return typeof parsed.name === "string" ? parsed.name.trim() : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isInsidePath(childPath: string, parentPath: string): boolean {
+	const relativePath = relative(parentPath, childPath);
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+function resolveInstalledRootFromPath(filePath: string): string | undefined {
+	const absolutePath = resolve(filePath);
+	const parts = absolutePath.split(sep);
+	const installedIndex = parts.lastIndexOf(INSTALLS_DIRECTORY_NAME);
+	if (installedIndex < 0) {
+		return undefined;
+	}
+	const kind = parts[installedIndex + 1];
+	if (!kind) {
+		return undefined;
+	}
+	const depth = INSTALL_KIND_DEPTHS.get(kind) ?? 1;
+	const endIndex = installedIndex + 2 + depth;
+	if (parts.length < endIndex) {
+		return undefined;
+	}
+	const root = parts.slice(0, endIndex).join(sep) || sep;
+	return existsSync(root) ? root : undefined;
+}
+
+function safeReadDir(directoryPath: string) {
+	try {
+		return readdirSync(directoryPath, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+
+function collectInstalledRoots(pluginRoot: string): string[] {
+	const installedRoot = join(pluginRoot, INSTALLS_DIRECTORY_NAME);
+	if (!existsSync(installedRoot)) {
+		return [];
+	}
+	const roots: string[] = [];
+	for (const kindEntry of safeReadDir(installedRoot)) {
+		if (!kindEntry.isDirectory()) {
+			continue;
+		}
+		const kindPath = join(installedRoot, kindEntry.name);
+		if (kindEntry.name === "git") {
+			for (const hostEntry of safeReadDir(kindPath)) {
+				if (!hostEntry.isDirectory()) {
+					continue;
+				}
+				const hostPath = join(kindPath, hostEntry.name);
+				for (const installEntry of safeReadDir(hostPath)) {
+					if (installEntry.isDirectory()) {
+						roots.push(join(hostPath, installEntry.name));
+					}
+				}
+			}
+			continue;
+		}
+		for (const installEntry of safeReadDir(kindPath)) {
+			if (installEntry.isDirectory()) {
+				roots.push(join(kindPath, installEntry.name));
+			}
+		}
+	}
+	return roots.sort((left, right) => left.localeCompare(right));
+}
+
+function discoverEntriesWithin(root: string): string[] {
+	try {
+		return discoverPluginModulePaths(root);
+	} catch {
+		return [];
+	}
+}
+
+function createInstalledCandidate(
+	installPath: string,
+): PluginUninstallCandidate {
+	const entryPaths = discoverEntriesWithin(installPath);
+	const names = new Set<string>();
+	addName(names, basename(installPath));
+	addName(names, stripInstallHash(basename(installPath)));
+	addName(names, readPackageName(join(installPath, "package.json")));
+	addName(
+		names,
+		readPackageName(join(installPath, PACKAGE_DIRECTORY_NAME, "package.json")),
+	);
+	for (const entryPath of entryPaths) {
+		addName(names, basename(entryPath));
+		addName(names, withoutExtension(basename(entryPath)));
+	}
+	return {
+		installPath,
+		entryPaths,
+		names: [...names].sort((left, right) => left.localeCompare(right)),
+		installed: true,
+	};
+}
+
+function resolveDirectPluginInstallPath(
+	filePath: string,
+	pluginRoots: string[],
+): string | undefined {
+	const absolutePath = resolve(filePath);
+	const pluginRoot = pluginRoots.find((root) =>
+		isInsidePath(absolutePath, root),
+	);
+	if (!pluginRoot) {
+		return undefined;
+	}
+	let current = dirname(absolutePath);
+	while (current !== pluginRoot && current !== dirname(current)) {
+		if (existsSync(join(current, "package.json"))) {
+			return current;
+		}
+		current = dirname(current);
+	}
+	const filename = basename(absolutePath);
+	if (
+		(filename === "index.ts" || filename === "index.js") &&
+		dirname(absolutePath) !== pluginRoot
+	) {
+		return dirname(absolutePath);
+	}
+	return absolutePath;
+}
+
+function createDirectCandidate(
+	entryPath: string,
+	pluginRoots: string[],
+): PluginUninstallCandidate | undefined {
+	const installPath = resolveDirectPluginInstallPath(entryPath, pluginRoots);
+	if (!installPath) {
+		return undefined;
+	}
+	const names = new Set<string>();
+	addName(names, basename(entryPath));
+	addName(names, withoutExtension(basename(entryPath)));
+	addName(names, basename(installPath));
+	addName(names, withoutExtension(basename(installPath)));
+	addName(names, readPackageName(join(installPath, "package.json")));
+	return {
+		installPath,
+		entryPaths: [entryPath],
+		names: [...names].sort((left, right) => left.localeCompare(right)),
+		installed: false,
+	};
+}
+
+function getPluginRoots(options: PluginUninstallOptions): string[] {
+	const workspaceRoot =
+		options.workspaceRoot?.trim() || options.cwd?.trim() || process.cwd();
+	return resolvePluginConfigSearchPaths(workspaceRoot).filter((directory) =>
+		existsSync(directory),
+	);
+}
+
+function collectCandidates(pluginRoots: string[]): PluginUninstallCandidate[] {
+	const candidatesByInstallPath = new Map<string, PluginUninstallCandidate>();
+
+	for (const pluginRoot of pluginRoots) {
+		for (const installPath of collectInstalledRoots(pluginRoot)) {
+			candidatesByInstallPath.set(
+				installPath,
+				createInstalledCandidate(installPath),
+			);
+		}
+		for (const entryPath of discoverEntriesWithin(pluginRoot)) {
+			const installedRoot = resolveInstalledRootFromPath(entryPath);
+			if (installedRoot) {
+				if (!candidatesByInstallPath.has(installedRoot)) {
+					candidatesByInstallPath.set(
+						installedRoot,
+						createInstalledCandidate(installedRoot),
+					);
+				}
+				continue;
+			}
+			const directCandidate = createDirectCandidate(entryPath, pluginRoots);
+			if (directCandidate) {
+				candidatesByInstallPath.set(
+					directCandidate.installPath,
+					directCandidate,
+				);
+			}
+		}
+	}
+
+	return [...candidatesByInstallPath.values()].sort((left, right) =>
+		left.installPath.localeCompare(right.installPath),
+	);
+}
+
+function candidateMatchesName(
+	candidate: PluginUninstallCandidate,
+	name: string,
+): boolean {
+	const normalizedName = normalizeMatchValue(name);
+	if (!normalizedName) {
+		return false;
+	}
+	if (normalizeMatchValue(candidate.installPath) === normalizedName) {
+		return true;
+	}
+	return candidate.names.some(
+		(candidateName) => normalizeMatchValue(candidateName) === normalizedName,
+	);
+}
+
+function findCandidateByPath(
+	path: string,
+	candidates: PluginUninstallCandidate[],
+	pluginRoots: string[],
+): PluginUninstallCandidate | undefined {
+	const absolutePath = resolve(path);
+	for (const candidate of candidates) {
+		if (isInsidePath(absolutePath, candidate.installPath)) {
+			return candidate;
+		}
+		if (
+			candidate.entryPaths.some(
+				(entryPath) => resolve(entryPath) === absolutePath,
+			)
+		) {
+			return candidate;
+		}
+	}
+	const installedRoot = resolveInstalledRootFromPath(absolutePath);
+	if (installedRoot) {
+		return createInstalledCandidate(installedRoot);
+	}
+	if (existsSync(absolutePath)) {
+		return createDirectCandidate(absolutePath, pluginRoots);
+	}
+	return undefined;
+}
+
+function cleanupDisabledPluginPaths(candidate: PluginUninstallCandidate): void {
+	const settings = readGlobalSettings();
+	const disabledPlugins = settings.disabledPlugins;
+	if (!disabledPlugins?.length) {
+		return;
+	}
+	const remaining = disabledPlugins.filter((pluginPath) => {
+		const absolutePath = resolve(pluginPath);
+		if (isInsidePath(absolutePath, candidate.installPath)) {
+			return false;
+		}
+		return !candidate.entryPaths.some(
+			(entryPath) => resolve(entryPath) === absolutePath,
+		);
+	});
+	if (remaining.length === disabledPlugins.length) {
+		return;
+	}
+	writeGlobalSettings({ ...settings, disabledPlugins: remaining });
+}
+
+function cleanupEmptyInstallParents(installPath: string): void {
+	let current = dirname(installPath);
+	while (
+		current !== dirname(current) &&
+		basename(current) !== INSTALLS_DIRECTORY_NAME
+	) {
+		try {
+			rmdirSync(current);
+		} catch {
+			return;
+		}
+		current = dirname(current);
+	}
+}
+
+function describeCandidate(candidate: PluginUninstallCandidate): string {
+	const primaryName = candidate.names[0] ?? basename(candidate.installPath);
+	return `${primaryName} at ${candidate.installPath}`;
+}
+
+export async function uninstallPlugin(
+	options: PluginUninstallOptions,
+): Promise<PluginUninstallResult> {
+	const pluginRoots = getPluginRoots(options);
+	const candidates = collectCandidates(pluginRoots);
+	const explicitPath = options.path?.trim();
+	const requestedName = options.name?.trim();
+
+	let candidate: PluginUninstallCandidate | undefined;
+	if (explicitPath) {
+		candidate = findCandidateByPath(explicitPath, candidates, pluginRoots);
+		if (!candidate) {
+			throw new Error(`No plugin found at ${explicitPath}`);
+		}
+	} else {
+		if (!requestedName) {
+			throw new Error("plugin uninstall requires a plugin name");
+		}
+		const matches = candidates.filter((item) =>
+			candidateMatchesName(item, requestedName),
+		);
+		if (matches.length === 0) {
+			throw new Error(`No plugin found matching "${requestedName}"`);
+		}
+		if (matches.length > 1) {
+			throw new Error(
+				`Multiple plugins match "${requestedName}": ${matches.map(describeCandidate).join(", ")}`,
+			);
+		}
+		candidate = matches[0];
+	}
+
+	const stats = statSync(candidate.installPath, { throwIfNoEntry: false });
+	if (!stats) {
+		throw new Error(
+			`Plugin install path does not exist: ${candidate.installPath}`,
+		);
+	}
+	removePluginMcpServersFromSettings({
+		pluginPaths: [candidate.installPath, ...candidate.entryPaths],
+		pluginNames: candidate.names,
+	});
+	rmSync(candidate.installPath, {
+		recursive: stats.isDirectory(),
+		force: true,
+	});
+	cleanupDisabledPluginPaths(candidate);
+	if (candidate.installed) {
+		cleanupEmptyInstallParents(candidate.installPath);
+	}
+	return {
+		name:
+			requestedName || candidate.names[0] || basename(candidate.installPath),
+		installPath: candidate.installPath,
+		removedPaths: [candidate.installPath],
+		entryPaths: candidate.entryPaths,
+	};
+}
diff --git a/sdk/packages/core/src/services/providers/local-provider-registry.ts b/sdk/packages/core/src/services/providers/local-provider-registry.ts
new file mode 100644
index 0000000..de06ecb
--- /dev/null
+++ b/sdk/packages/core/src/services/providers/local-provider-registry.ts
@@ -0,0 +1,468 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import * as LlmsModels from "@cline/llms";
+import {
+	type ModelCapability,
+	ModelCapabilitySchema,
+	type ModelInfo,
+	type ProviderCapability,
+	ProviderCapabilitySchema,
+	type ProviderClient,
+	ProviderClientSchema,
+	type ProviderModel,
+	type ProviderProtocol,
+	ProviderProtocolSchema,
+} from "@cline/shared";
+import { z } from "zod";
+import type {
+	ProviderSettings,
+	StoredProviderSettings,
+} from "../../types/provider-settings";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+
+export const StoredModelEntrySchema = z
+	.object({
+		id: z.string().optional(),
+		name: z.string().optional(),
+		maxTokens: z.number().optional(),
+		contextWindow: z.number().optional(),
+		maxInputTokens: z.number().optional(),
+		capabilities: z.array(ModelCapabilitySchema).optional(),
+		supportsVision: z.boolean().optional(),
+		supportsAttachments: z.boolean().optional(),
+		supportsReasoning: z.boolean().optional(),
+	})
+	.passthrough();
+
+export type StoredModelEntry = z.infer<typeof StoredModelEntrySchema>;
+
+export const StoredProviderMetadataSchema = z
+	.object({
+		name: z.string(),
+		baseUrl: z.string(),
+		defaultModelId: z.string().optional(),
+		protocol: ProviderProtocolSchema.optional(),
+		client: ProviderClientSchema.optional(),
+		capabilities: z.array(ProviderCapabilitySchema).optional(),
+		modelsSourceUrl: z.string().optional(),
+	})
+	.passthrough();
+
+export const StoredProviderEntrySchema = z
+	.object({
+		provider: StoredProviderMetadataSchema.optional(),
+		models: z.record(z.string(), StoredModelEntrySchema).optional(),
+	})
+	.passthrough();
+
+export type StoredProviderEntry = z.infer<typeof StoredProviderEntrySchema>;
+
+export const StoredModelsFileSchema = z.object({
+	version: z.literal(1),
+	providers: z.record(z.string(), StoredProviderEntrySchema),
+});
+
+export type StoredModelsFile = z.infer<typeof StoredModelsFileSchema>;
+
+const StoredModelsFileEnvelopeSchema = z.object({
+	version: z.literal(1),
+	providers: z.record(z.string(), z.unknown()),
+});
+
+const LOADED_MODELS_REGISTRY_PATHS = new Set<string>();
+
+function titleCaseFromId(id: string): string {
+	return id
+		.split(/[-_]/)
+		.filter(Boolean)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ");
+}
+
+export function resolveModelsRegistryPath(
+	manager: ProviderSettingsManager,
+): string {
+	return join(dirname(manager.getFilePath()), "models.json");
+}
+
+export function emptyModelsFile(): StoredModelsFile {
+	return { version: 1, providers: {} };
+}
+
+export function parseModelsFile(input: unknown): StoredModelsFile {
+	const result = StoredModelsFileEnvelopeSchema.safeParse(input);
+	if (!result.success) {
+		return emptyModelsFile();
+	}
+
+	const providers: StoredModelsFile["providers"] = {};
+	for (const [providerId, entry] of Object.entries(result.data.providers)) {
+		const provider = StoredProviderEntrySchema.safeParse(entry);
+		if (provider.success) {
+			providers[providerId] = provider.data;
+		}
+	}
+	return { version: 1, providers };
+}
+
+export function readModelsFileSync(filePath: string): StoredModelsFile {
+	if (!existsSync(filePath)) {
+		return emptyModelsFile();
+	}
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return parseModelsFile(JSON.parse(raw) as unknown);
+	} catch {
+		// Invalid or missing files fall back to an empty registry.
+	}
+	return emptyModelsFile();
+}
+
+export async function readModelsFile(
+	filePath: string,
+): Promise<StoredModelsFile> {
+	try {
+		const raw = await readFile(filePath, "utf8");
+		return parseModelsFile(JSON.parse(raw) as unknown);
+	} catch {
+		// Invalid or missing files fall back to an empty registry.
+	}
+	return emptyModelsFile();
+}
+
+export function writeModelsFileSync(
+	filePath: string,
+	state: StoredModelsFile,
+): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	const parsed = StoredModelsFileSchema.parse(state);
+	writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+}
+
+export async function writeModelsFile(
+	filePath: string,
+	state: StoredModelsFile,
+): Promise<void> {
+	await mkdir(dirname(filePath), { recursive: true });
+	const parsed = StoredModelsFileSchema.parse(state);
+	await writeFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+}
+
+export function toProviderModel(
+	modelId: string,
+	info: {
+		name?: string;
+		capabilities?: string[];
+		thinkingConfig?: unknown;
+	},
+): ProviderModel {
+	return {
+		id: modelId,
+		name: info.name ?? modelId,
+		supportsAttachments: info.capabilities?.includes("files"),
+		supportsVision: info.capabilities?.includes("images"),
+		supportsReasoning:
+			info.capabilities?.includes("reasoning") || info.thinkingConfig != null,
+	};
+}
+
+function toProviderCapabilities(
+	capabilities: ProviderCapability[] | undefined,
+): Array<"reasoning" | "prompt-cache" | "tools"> | undefined {
+	if (!capabilities || capabilities.length === 0) {
+		return undefined;
+	}
+	const next = new Set<"reasoning" | "prompt-cache" | "tools">();
+	if (capabilities.includes("reasoning")) {
+		next.add("reasoning");
+	}
+	if (capabilities.includes("prompt-cache")) {
+		next.add("prompt-cache");
+	}
+	if (capabilities.includes("tools")) {
+		next.add("tools");
+	}
+	return next.size > 0 ? [...next] : undefined;
+}
+
+function toModelCapabilities(
+	capabilities: ProviderCapability[] | undefined,
+): Array<
+	"streaming" | "tools" | "reasoning" | "prompt-cache" | "images" | "files"
+> {
+	const next = new Set<
+		"streaming" | "tools" | "reasoning" | "prompt-cache" | "images" | "files"
+	>();
+	if (!capabilities || capabilities.length === 0) {
+		return [...next];
+	}
+	if (capabilities.includes("streaming")) next.add("streaming");
+	if (capabilities.includes("tools")) next.add("tools");
+	if (capabilities.includes("reasoning")) next.add("reasoning");
+	if (capabilities.includes("prompt-cache")) next.add("prompt-cache");
+	if (capabilities.includes("vision")) {
+		next.add("images");
+		next.add("files");
+	}
+	return [...next];
+}
+
+function isCompleteProviderMetadata(
+	provider: StoredProviderEntry["provider"],
+): provider is NonNullable<StoredProviderEntry["provider"]> {
+	return (
+		provider != null &&
+		typeof provider.name === "string" &&
+		typeof provider.baseUrl === "string"
+	);
+}
+
+function resolveProviderProtocol(
+	protocol: ProviderProtocol | undefined,
+	fallback: ProviderProtocol | undefined,
+): ProviderProtocol {
+	return protocol ?? fallback ?? "openai-chat";
+}
+
+function resolveProviderClient(
+	client: ProviderClient | undefined,
+	protocol: ProviderProtocol,
+	fallback: ProviderClient | undefined,
+): ProviderClient {
+	return (
+		client ??
+		fallback ??
+		(protocol === "openai-responses" ? "openai" : "openai-compatible")
+	);
+}
+
+function toStoredModelInfo(
+	modelId: string,
+	model: StoredModelEntry | undefined,
+	fallbackCapabilities?: ModelInfo["capabilities"],
+): ModelInfo {
+	const capabilities = new Set<ModelCapability>(
+		model?.capabilities ?? fallbackCapabilities ?? [],
+	);
+	if (model?.supportsVision) capabilities.add("images");
+	if (model?.supportsAttachments) capabilities.add("files");
+	if (model?.supportsReasoning) capabilities.add("reasoning");
+
+	return {
+		id: modelId,
+		name: model?.name ?? modelId,
+		maxTokens: model?.maxTokens,
+		contextWindow: model?.contextWindow,
+		maxInputTokens: model?.maxInputTokens,
+		capabilities: capabilities.size > 0 ? [...capabilities] : undefined,
+	};
+}
+
+function registerCustomModels(
+	providerId: string,
+	models: StoredProviderEntry["models"] | undefined,
+): void {
+	for (const [modelKey, model] of Object.entries(models ?? {})) {
+		const modelId = model.id?.trim() || modelKey.trim();
+		if (!modelId) {
+			continue;
+		}
+		LlmsModels.registerModel(
+			providerId,
+			modelId,
+			toStoredModelInfo(modelId, model),
+		);
+	}
+}
+
+function modelInfoWithDefaults(
+	modelId: string,
+	info: ModelInfo | undefined,
+	capabilities: ModelInfo["capabilities"] | undefined,
+): ModelInfo {
+	return {
+		...(info ?? {}),
+		id: modelId,
+		name: info?.name ?? modelId,
+		capabilities: info?.capabilities ?? capabilities,
+	};
+}
+
+function getGeneratedModelsForProvider(
+	providerId: string,
+): Record<string, ModelInfo> {
+	const generated = Object.assign(
+		{},
+		...LlmsModels.resolveProviderModelCatalogKeys(providerId).map(
+			(catalogKey) => LlmsModels.getGeneratedModelsForProvider(catalogKey),
+		),
+	);
+	return generated as Record<string, ModelInfo>;
+}
+
+export function registerProviderSettingsProvider(
+	settings: ProviderSettings,
+): void {
+	const providerId = settings.provider.trim();
+	if (!providerId || LlmsModels.isBuiltInProviderId(providerId)) {
+		return;
+	}
+
+	const baseUrl = settings.baseUrl?.trim();
+	if (!baseUrl) {
+		return;
+	}
+
+	const existingCollection = LlmsModels.MODEL_COLLECTIONS_BY_PROVIDER_ID[
+		providerId
+	] as LlmsModels.ModelCollection | undefined;
+	const generatedModels = getGeneratedModelsForProvider(providerId);
+	const modelCapabilities = toModelCapabilities(settings.capabilities);
+	const fallbackCapabilities =
+		modelCapabilities.length > 0 ? modelCapabilities : undefined;
+	const modelId = settings.model?.trim();
+	const models: Record<string, ModelInfo> = {
+		...generatedModels,
+		...(existingCollection?.models ?? {}),
+	};
+
+	if (modelId) {
+		models[modelId] = modelInfoWithDefaults(
+			modelId,
+			models[modelId],
+			fallbackCapabilities,
+		);
+	}
+
+	const modelIds = Object.keys(models).filter(Boolean);
+	const defaultModelId = modelId || modelIds[0];
+	if (!defaultModelId) {
+		return;
+	}
+	const protocol = resolveProviderProtocol(
+		settings.protocol,
+		existingCollection?.provider.protocol,
+	);
+	const client = resolveProviderClient(
+		settings.client,
+		protocol,
+		existingCollection?.provider.client,
+	);
+
+	LlmsModels.registerProvider({
+		provider: {
+			id: providerId,
+			name: existingCollection?.provider.name ?? titleCaseFromId(providerId),
+			description: existingCollection?.provider.description,
+			protocol,
+			client,
+			baseUrl,
+			modelsSourceUrl: existingCollection?.provider.modelsSourceUrl,
+			defaultModelId,
+			capabilities:
+				toProviderCapabilities(settings.capabilities) ??
+				existingCollection?.provider.capabilities,
+			source: "file",
+		},
+		models,
+	});
+}
+
+export function registerConfiguredProvidersFromSettings(
+	state: StoredProviderSettings,
+): void {
+	for (const entry of Object.values(state.providers)) {
+		registerProviderSettingsProvider(entry.settings);
+	}
+}
+
+/**
+ * Custom Provider Registry
+ *
+ * This module manages the registration of custom OpenAI-compatible providers and
+ * their models based on local JSON files. It provides functions to read/write the models
+ * registry file and to register providers with the LlmsModels system.
+ */
+export function registerCustomProvider(
+	providerId: string,
+	entry: StoredProviderEntry,
+): void {
+	const storedModels = entry.models ?? {};
+	if (!isCompleteProviderMetadata(entry.provider)) {
+		registerCustomModels(providerId, storedModels);
+		return;
+	}
+
+	const modelCapabilities = toModelCapabilities(entry.provider.capabilities);
+	const modelEntries = Object.entries(storedModels)
+		.map(([modelKey, model]) => ({
+			id: model.id?.trim() || modelKey.trim(),
+			model,
+		}))
+		.filter(({ id }) => id.length > 0);
+	const defaultModelId =
+		entry.provider.defaultModelId?.trim() || modelEntries[0]?.id || "default";
+	const protocol = resolveProviderProtocol(entry.provider.protocol, undefined);
+	const client = resolveProviderClient(
+		entry.provider.client,
+		protocol,
+		undefined,
+	);
+	const normalizedModels = Object.fromEntries(
+		modelEntries.map(({ id, model }) => [
+			id,
+			{
+				...toStoredModelInfo(
+					id,
+					model,
+					modelCapabilities.length > 0 ? modelCapabilities : undefined,
+				),
+				status: "active" as const,
+			},
+		]),
+	);
+
+	LlmsModels.registerProvider({
+		provider: {
+			id: providerId,
+			name: entry.provider.name.trim() || titleCaseFromId(providerId),
+			protocol,
+			client,
+			baseUrl: entry.provider.baseUrl,
+			modelsSourceUrl: entry.provider.modelsSourceUrl,
+			defaultModelId,
+			capabilities: toProviderCapabilities(entry.provider.capabilities),
+			source: "file",
+		},
+		models: normalizedModels,
+	});
+}
+
+export function ensureCustomProvidersLoadedSync(
+	manager: ProviderSettingsManager,
+): void {
+	const modelsPath = resolveModelsRegistryPath(manager);
+	if (LOADED_MODELS_REGISTRY_PATHS.has(modelsPath)) {
+		return;
+	}
+	const state = readModelsFileSync(modelsPath);
+	for (const [providerId, entry] of Object.entries(state.providers)) {
+		registerCustomProvider(providerId, entry);
+	}
+	LOADED_MODELS_REGISTRY_PATHS.add(modelsPath);
+}
+
+export async function ensureCustomProvidersLoaded(
+	manager: ProviderSettingsManager,
+): Promise<void> {
+	const modelsPath = resolveModelsRegistryPath(manager);
+	if (LOADED_MODELS_REGISTRY_PATHS.has(modelsPath)) {
+		return;
+	}
+	const state = await readModelsFile(modelsPath);
+	for (const [providerId, entry] of Object.entries(state.providers)) {
+		registerCustomProvider(providerId, entry);
+	}
+	LOADED_MODELS_REGISTRY_PATHS.add(modelsPath);
+}
diff --git a/sdk/packages/core/src/services/providers/local-provider-service.test.ts b/sdk/packages/core/src/services/providers/local-provider-service.test.ts
new file mode 100644
index 0000000..0cbc625
--- /dev/null
+++ b/sdk/packages/core/src/services/providers/local-provider-service.test.ts
@@ -0,0 +1,1547 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as LlmsModels from "@cline/llms";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { clearLiveModelsCatalogCache } from "../llms/provider-defaults";
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import {
+	parseModelsFile,
+	readModelsFile,
+	registerCustomProvider,
+	resolveModelsRegistryPath,
+} from "./local-provider-registry";
+import {
+	addLocalProvider,
+	deleteLocalProvider,
+	getLocalProviderModels,
+	listLocalProviders,
+	markLocalProviderEnabled,
+	normalizeOAuthProvider,
+	refreshProviderModelsFromSource,
+	resolveLocalClineAuthToken,
+	saveLocalProviderSettings,
+	updateLocalProvider,
+} from "./local-provider-service";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeTempManager(): {
+	manager: ProviderSettingsManager;
+	cleanup: () => void;
+} {
+	const dir = mkdtempSync(
+		path.join(os.tmpdir(), "local-provider-service-test-"),
+	);
+	const manager = new ProviderSettingsManager({
+		filePath: path.join(dir, "providers.json"),
+	});
+	return {
+		manager,
+		cleanup: () => rmSync(dir, { recursive: true, force: true }),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Shared state reset
+// ---------------------------------------------------------------------------
+
+afterEach(() => {
+	clearLiveModelsCatalogCache();
+	LlmsModels.resetRegistry();
+	vi.restoreAllMocks();
+	vi.unstubAllGlobals();
+});
+
+describe("models registry parsing", () => {
+	it("accepts model entries that use the record key as the model id", async () => {
+		const parsed = parseModelsFile({
+			version: 1,
+			providers: {
+				"schema-provider": {
+					provider: {
+						name: "Schema Provider",
+						baseUrl: "https://schema.example.invalid/v1",
+						defaultModelId: "alpha",
+						protocol: "openai-responses",
+					},
+					models: {
+						alpha: {
+							name: "Alpha",
+							capabilities: ["reasoning"],
+						},
+					},
+				},
+			},
+		});
+
+		const entry = parsed.providers["schema-provider"];
+		expect(entry?.models?.alpha?.id).toBeUndefined();
+		if (!entry) {
+			throw new Error("expected parsed provider entry");
+		}
+
+		registerCustomProvider("schema-provider", entry);
+
+		await expect(
+			LlmsModels.getProvider("schema-provider"),
+		).resolves.toMatchObject({
+			id: "schema-provider",
+			protocol: "openai-responses",
+			client: "openai",
+		});
+		await expect(
+			LlmsModels.getModelsForProvider("schema-provider"),
+		).resolves.toHaveProperty("alpha");
+	});
+
+	it("skips malformed provider entries while preserving valid providers", () => {
+		expect(
+			parseModelsFile({
+				version: 1,
+				providers: {
+					valid: {
+						provider: {
+							name: "Valid",
+							baseUrl: "https://valid.example.invalid/v1",
+						},
+						models: {
+							alpha: {
+								name: "Alpha",
+							},
+						},
+					},
+					broken: {
+						provider: {
+							name: "Broken",
+							baseUrl: 42,
+						},
+					},
+				},
+			}),
+		).toEqual({
+			version: 1,
+			providers: {
+				valid: {
+					provider: {
+						name: "Valid",
+						baseUrl: "https://valid.example.invalid/v1",
+					},
+					models: {
+						alpha: {
+							name: "Alpha",
+						},
+					},
+				},
+			},
+		});
+	});
+
+	it("falls back to an empty registry when the file shape is malformed", () => {
+		expect(
+			parseModelsFile({
+				version: 1,
+				providers: [],
+			}),
+		).toEqual({ version: 1, providers: {} });
+	});
+});
+
+// ===========================================================================
+// extractModelIdsFromPayload is tested indirectly via addLocalProvider
+// ===========================================================================
+
+describe("addLocalProvider – model ID parsing via modelsSourceUrl", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		({ manager, cleanup } = makeTempManager());
+	});
+
+	afterEach(() => cleanup());
+
+	it("parses a flat array payload from modelsSourceUrl", async () => {
+		const mockFetch = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ["alpha", "beta", "gamma"],
+		});
+		vi.stubGlobal("fetch", mockFetch);
+
+		const result = await addLocalProvider(manager, {
+			providerId: "flat-array-provider",
+			name: "Flat Array",
+			baseUrl: "https://example.invalid/v1",
+			models: [],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		expect(result.modelsCount).toBe(3);
+		const { models } = await getLocalProviderModels("flat-array-provider");
+		expect(models.map((m) => m.id).sort()).toEqual(["alpha", "beta", "gamma"]);
+	});
+
+	it("parses a { data: [...] } payload from modelsSourceUrl", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ({ data: [{ id: "model-x" }, { id: "model-y" }] }),
+			}),
+		);
+
+		await addLocalProvider(manager, {
+			providerId: "data-array-provider",
+			name: "Data Array",
+			baseUrl: "https://example.invalid/v1",
+			models: [],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		const { models } = await getLocalProviderModels("data-array-provider");
+		expect(models.map((m) => m.id).sort()).toEqual(["model-x", "model-y"]);
+	});
+
+	it("parses Ollama-style { models: [{ name }] } payloads", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ({
+					models: [{ name: "llama3.1" }, { model: "qwen3:8b" }],
+				}),
+			}),
+		);
+
+		await addLocalProvider(manager, {
+			providerId: "ollama-shaped-provider",
+			name: "Ollama Shaped",
+			baseUrl: "https://example.invalid/v1",
+			models: [],
+			modelsSourceUrl: "https://example.invalid/api/tags",
+		});
+
+		const { models } = await getLocalProviderModels("ollama-shaped-provider");
+		expect(models.map((m) => m.id).sort()).toEqual(["llama3.1", "qwen3:8b"]);
+	});
+
+	it("uses only live ClinePass models when live models are found", async () => {
+		const fetchMock = vi.fn(async (url: string) => {
+			if (url === "https://models.dev/api.json") {
+				return new Response(
+					JSON.stringify({
+						openrouter: {
+							models: {
+								"vendor/live-pass-model": {
+									name: "Live Pass Model",
+									tool_call: true,
+									reasoning: true,
+									limit: { context: 256_000, input: 200_000, output: 32_000 },
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}
+
+			return new Response(
+				JSON.stringify({
+					clinePass: [
+						{
+							id: "cline-pass/live-pass-model",
+							name: "vendor/live-pass-model",
+						},
+					],
+				}),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const { models } = await getLocalProviderModels("cline-pass");
+
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+		expect(models.map((model) => model.id)).toEqual([
+			"cline-pass/live-pass-model",
+		]);
+		expect(models[0]).toMatchObject({
+			id: "cline-pass/live-pass-model",
+			name: "Live Pass Model",
+			supportsReasoning: true,
+		});
+	});
+
+	it("falls back to generated ClinePass models when no live ClinePass models are found", async () => {
+		const fetchMock = vi.fn(async (url: string) => {
+			if (url === "https://models.dev/api.json") {
+				return new Response(
+					JSON.stringify({
+						openrouter: {
+							models: {
+								"vendor/live-openrouter-model": {
+									name: "Live OpenRouter Model",
+									tool_call: true,
+								},
+							},
+						},
+					}),
+					{
+						status: 200,
+						headers: { "content-type": "application/json" },
+					},
+				);
+			}
+
+			return new Response(JSON.stringify({ clinePass: [] }), {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			});
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const { models } = await getLocalProviderModels("cline-pass");
+
+		expect(fetchMock).toHaveBeenCalledTimes(2);
+		expect(models.map((model) => model.id)).toContain(
+			"cline-pass/mimo-v2.5-pro",
+		);
+		expect(models.map((model) => model.id)).not.toContain(
+			"vendor/live-openrouter-model",
+		);
+	});
+
+	it("parses a { models: { id1: {}, id2: {} } } object-keyed payload", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ({ models: { "key-a": {}, "key-b": {} } }),
+			}),
+		);
+
+		await addLocalProvider(manager, {
+			providerId: "obj-keys-provider",
+			name: "Object Keys",
+			baseUrl: "https://example.invalid/v1",
+			models: [],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		const { models } = await getLocalProviderModels("obj-keys-provider");
+		expect(models.map((m) => m.id).sort()).toEqual(["key-a", "key-b"]);
+	});
+
+	it("parses a { providers: { <id>: { models: [...] } } } nested payload", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ({
+					providers: {
+						"nested-provider": { models: ["nested-a", "nested-b"] },
+					},
+				}),
+			}),
+		);
+
+		await addLocalProvider(manager, {
+			providerId: "nested-provider",
+			name: "Nested Provider",
+			baseUrl: "https://example.invalid/v1",
+			models: [],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		const { models } = await getLocalProviderModels("nested-provider");
+		expect(models.map((m) => m.id).sort()).toEqual(["nested-a", "nested-b"]);
+	});
+
+	it("merges manually specified models with fetched models and deduplicates", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ["fetched-1", "fetched-2", "manual-1"],
+			}),
+		);
+
+		const result = await addLocalProvider(manager, {
+			providerId: "merged-provider",
+			name: "Merged",
+			baseUrl: "https://example.invalid/v1",
+			models: ["manual-1", "manual-2"],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		// manual-1, manual-2, fetched-1, fetched-2, manual-1 → Set → 4
+		expect(result.modelsCount).toBe(4);
+		const { models } = await getLocalProviderModels("merged-provider");
+		const ids = models.map((m) => m.id).sort();
+		expect(ids).toEqual(["fetched-1", "fetched-2", "manual-1", "manual-2"]);
+	});
+
+	it("throws when fetch returns non-OK status", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: false,
+				status: 404,
+			}),
+		);
+
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "fail-fetch-provider",
+				name: "Fail",
+				baseUrl: "https://example.invalid/v1",
+				models: [],
+				modelsSourceUrl: "https://example.invalid/models",
+			}),
+		).rejects.toThrow("HTTP 404");
+	});
+
+	it("ignores empty string entries in array payloads", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ["good-model", "", "  "],
+			}),
+		);
+
+		await addLocalProvider(manager, {
+			providerId: "empty-strings-provider",
+			name: "Empty Strings",
+			baseUrl: "https://example.invalid/v1",
+			models: [],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		const { models } = await getLocalProviderModels("empty-strings-provider");
+		expect(models.map((m) => m.id)).toEqual(["good-model"]);
+	});
+
+	it("ignores non-array, non-object payload shapes and falls back to manual models", async () => {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => "just a string",
+			}),
+		);
+
+		await addLocalProvider(manager, {
+			providerId: "fallback-provider",
+			name: "Fallback",
+			baseUrl: "https://example.invalid/v1",
+			models: ["fallback-model"],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		const { models } = await getLocalProviderModels("fallback-provider");
+		expect(models.map((m) => m.id)).toEqual(["fallback-model"]);
+	});
+});
+
+// ===========================================================================
+// addLocalProvider – validation guards
+// ===========================================================================
+
+describe("addLocalProvider – validation", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		({ manager, cleanup } = makeTempManager());
+	});
+
+	afterEach(() => cleanup());
+
+	it("throws when providerId is empty", async () => {
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "   ",
+				name: "X",
+				baseUrl: "https://example.invalid",
+				models: ["m"],
+			}),
+		).rejects.toThrow("providerId is required");
+	});
+
+	it("throws when name is empty", async () => {
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "my-provider",
+				name: "   ",
+				baseUrl: "https://example.invalid",
+				models: ["m"],
+			}),
+		).rejects.toThrow("name is required");
+	});
+
+	it("throws when baseUrl is empty and apiKey is provided", async () => {
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "my-provider2",
+				name: "My Provider",
+				baseUrl: "   ",
+				apiKey: "present-key",
+				models: ["m"],
+			}),
+		).rejects.toThrow("baseUrl is required");
+	});
+
+	it("throws when no models are provided and no modelsSourceUrl", async () => {
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "no-models-provider",
+				name: "No Models",
+				baseUrl: "https://example.invalid",
+				models: [],
+			}),
+		).rejects.toThrow("at least one model is required");
+	});
+
+	it("throws when provider already exists", async () => {
+		// Register a provider first
+		await addLocalProvider(manager, {
+			providerId: "duplicate-provider",
+			name: "First",
+			baseUrl: "https://example.invalid/v1",
+			models: ["m1"],
+		});
+
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "duplicate-provider",
+				name: "Second",
+				baseUrl: "https://example.invalid/v1",
+				models: ["m2"],
+			}),
+		).rejects.toThrow('"duplicate-provider" already exists');
+	});
+});
+
+// ===========================================================================
+// addLocalProvider – delete compatibility path
+// ===========================================================================
+
+describe("addLocalProvider – delete compatibility", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(async () => {
+		({ manager, cleanup } = makeTempManager());
+		await addLocalProvider(manager, {
+			providerId: "legacy-delete-provider",
+			name: "Legacy Delete Provider",
+			baseUrl: "https://example.invalid/v1",
+			models: ["legacy-model"],
+		});
+		manager.saveProviderSettings(
+			{
+				provider: "legacy-delete-provider",
+				baseUrl: "https://example.invalid/v1",
+				model: "legacy-model",
+			},
+			{ setLastUsed: true },
+		);
+	});
+
+	afterEach(() => cleanup());
+
+	it("treats empty baseUrl and apiKey as a delete request for existing provider", async () => {
+		const result = await addLocalProvider(manager, {
+			providerId: "legacy-delete-provider",
+			name: "Ignored",
+			baseUrl: "   ",
+			apiKey: "   ",
+			models: [],
+		});
+
+		expect(result.providerId).toBe("legacy-delete-provider");
+		expect(result.modelsCount).toBe(0);
+		expect(LlmsModels.hasProvider("legacy-delete-provider")).toBe(false);
+		expect(
+			manager.getProviderSettings("legacy-delete-provider"),
+		).toBeUndefined();
+		expect(manager.getLastUsedProviderSettings()).toBeUndefined();
+	});
+
+	it("is a no-op delete when provider is already missing", async () => {
+		await deleteLocalProvider(manager, {
+			providerId: "legacy-delete-provider",
+		});
+
+		await expect(
+			addLocalProvider(manager, {
+				providerId: "legacy-delete-provider",
+				name: "Ignored",
+				baseUrl: "   ",
+				models: [],
+			}),
+		).resolves.toMatchObject({
+			providerId: "legacy-delete-provider",
+			modelsCount: 0,
+		});
+	});
+});
+
+// ===========================================================================
+// addLocalProvider – defaultModelId selection
+// ===========================================================================
+
+describe("addLocalProvider – defaultModelId selection", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		({ manager, cleanup } = makeTempManager());
+	});
+
+	afterEach(() => cleanup());
+
+	it("uses explicit defaultModelId when it is in the model list", async () => {
+		await addLocalProvider(manager, {
+			providerId: "default-model-provider",
+			name: "Test",
+			baseUrl: "https://example.invalid/v1",
+			models: ["model-a", "model-b", "model-c"],
+			defaultModelId: "model-b",
+		});
+
+		const settings = manager.getProviderSettings("default-model-provider");
+		expect(settings?.model).toBe("model-b");
+	});
+
+	it("falls back to the first model when defaultModelId is not in the list", async () => {
+		await addLocalProvider(manager, {
+			providerId: "fallback-default-provider",
+			name: "Test",
+			baseUrl: "https://example.invalid/v1",
+			models: ["model-a", "model-b"],
+			defaultModelId: "not-in-list",
+		});
+
+		const settings = manager.getProviderSettings("fallback-default-provider");
+		expect(settings?.model).toBe("model-a");
+	});
+});
+
+// ===========================================================================
+// addLocalProvider – capabilities → vision / reasoning flags
+// ===========================================================================
+
+describe("addLocalProvider – capabilities", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		({ manager, cleanup } = makeTempManager());
+	});
+
+	afterEach(() => cleanup());
+
+	it("sets supportsVision and supportsAttachments when capability is 'vision'", async () => {
+		await addLocalProvider(manager, {
+			providerId: "vision-provider",
+			name: "Vision",
+			baseUrl: "https://example.invalid/v1",
+			models: ["vis-model"],
+			capabilities: ["vision"],
+		});
+
+		const { models } = await getLocalProviderModels("vision-provider");
+		expect(models).toHaveLength(1);
+		expect(models[0].supportsVision).toBe(true);
+		expect(models[0].supportsAttachments).toBe(true);
+	});
+
+	it("sets supportsReasoning when capability is 'reasoning'", async () => {
+		await addLocalProvider(manager, {
+			providerId: "reasoning-provider",
+			name: "Reasoning",
+			baseUrl: "https://example.invalid/v1",
+			models: ["r-model"],
+			capabilities: ["reasoning"],
+		});
+
+		const { models } = await getLocalProviderModels("reasoning-provider");
+		expect(models[0].supportsReasoning).toBe(true);
+		expect(models[0].supportsVision).toBeFalsy();
+	});
+
+	it("does not set vision/reasoning flags when capabilities are absent", async () => {
+		await addLocalProvider(manager, {
+			providerId: "plain-provider",
+			name: "Plain",
+			baseUrl: "https://example.invalid/v1",
+			models: ["plain-model"],
+		});
+
+		const { models } = await getLocalProviderModels("plain-provider");
+		expect(models[0].supportsVision).toBeFalsy();
+		expect(models[0].supportsReasoning).toBeFalsy();
+	});
+
+	it("uses LiteLLM private models as the authoritative provider model listing when auth is configured", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "litellm",
+				apiKey: "test-key-catalog",
+				baseUrl: "http://localhost:4010",
+				model: "gpt-4o",
+			},
+			{ setLastUsed: false },
+		);
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				json: async () => ({
+					data: [
+						{
+							model_name: "private-proxy-model",
+							litellm_params: { model: "openai/gpt-4o-mini" },
+							model_info: {
+								supports_vision: true,
+								supports_reasoning: true,
+							},
+						},
+					],
+				}),
+			}),
+		);
+
+		const { models } = await getLocalProviderModels(
+			"litellm",
+			manager.getProviderConfig("litellm"),
+		);
+
+		expect(models.map((model) => model.id).sort()).toEqual([
+			"openai/gpt-4o-mini",
+			"private-proxy-model",
+		]);
+		expect(models.map((model) => model.id)).not.toContain("gpt-5.4");
+		expect(
+			models.find((model) => model.id === "private-proxy-model"),
+		).toMatchObject({
+			supportsVision: true,
+			supportsReasoning: true,
+		});
+	});
+
+	it("uses an empty LiteLLM model list when no private model list is fetched", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "litellm",
+				baseUrl: "http://localhost:4010",
+				model: "gpt-4o",
+			},
+			{ setLastUsed: false },
+		);
+		const fetchMock = vi.fn();
+		vi.stubGlobal("fetch", fetchMock);
+
+		const { models } = await getLocalProviderModels(
+			"litellm",
+			manager.getProviderConfig("litellm"),
+		);
+
+		expect(fetchMock).not.toHaveBeenCalled();
+		expect(models).toEqual([]);
+	});
+});
+
+// ===========================================================================
+// models.json – built-in provider model overlays
+// ===========================================================================
+
+describe("models.json model overlays", () => {
+	it("loads model-only entries for built-in providers", async () => {
+		const dir = mkdtempSync(
+			path.join(os.tmpdir(), "local-provider-overlay-test-"),
+		);
+		try {
+			const settingsDir = path.join(dir, "settings");
+			mkdirSync(settingsDir, { recursive: true });
+			writeFileSync(
+				path.join(settingsDir, "models.json"),
+				`${JSON.stringify(
+					{
+						version: 1,
+						providers: {
+							cline: {
+								models: {
+									"openai/gpt-5.5": {
+										id: "openai/gpt-5.5",
+										name: "OpenAI GPT-5.5",
+									},
+								},
+							},
+						},
+					},
+					null,
+					2,
+				)}\n`,
+			);
+
+			const manager = new ProviderSettingsManager({
+				filePath: path.join(settingsDir, "providers.json"),
+			});
+
+			const provider = await LlmsModels.getProvider("cline");
+			expect(provider).toMatchObject({
+				id: "cline",
+				baseUrl: "https://api.cline.bot/api/v1",
+				defaultModelId: "anthropic/claude-sonnet-4.6",
+			});
+
+			const { models } = await getLocalProviderModels("cline");
+			expect(
+				models.find((model) => model.id === "openai/gpt-5.5"),
+			).toMatchObject({
+				id: "openai/gpt-5.5",
+				name: "OpenAI GPT-5.5",
+			});
+			expect(manager.getFilePath()).toBe(
+				path.join(settingsDir, "providers.json"),
+			);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+// ===========================================================================
+// saveLocalProviderSettings
+// ===========================================================================
+
+describe("saveLocalProviderSettings", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(async () => {
+		({ manager, cleanup } = makeTempManager());
+		// Seed a provider so there is something to operate on
+		await addLocalProvider(manager, {
+			providerId: "test-provider",
+			name: "Test",
+			baseUrl: "https://example.invalid/v1",
+			models: ["m1"],
+		});
+	});
+
+	afterEach(() => cleanup());
+
+	it("disabling a provider removes it from settings", () => {
+		const result = saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: false,
+		});
+
+		expect(result.enabled).toBe(false);
+		expect(manager.getProviderSettings("test-provider")).toBeUndefined();
+	});
+
+	it("updates apiKey", () => {
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			apiKey: "new-key",
+		});
+
+		expect(manager.getProviderSettings("test-provider")?.apiKey).toBe(
+			"new-key",
+		);
+	});
+
+	it("clears apiKey when empty string is provided", () => {
+		// First set a key
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			apiKey: "some-key",
+		});
+		// Then clear it
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			apiKey: "",
+		});
+
+		const settings = manager.getProviderSettings("test-provider");
+		expect(settings).not.toHaveProperty("apiKey");
+	});
+
+	it("merges auth object rather than replacing it", () => {
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			auth: { accessToken: "tok1" },
+		});
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			auth: { refreshToken: "ref1" },
+		});
+
+		const settings = manager.getProviderSettings("test-provider") as Record<
+			string,
+			unknown
+		>;
+		const auth = settings?.auth as Record<string, unknown>;
+		expect(auth?.accessToken).toBe("tok1");
+		expect(auth?.refreshToken).toBe("ref1");
+	});
+
+	it("merges and clears nested provider config fields", () => {
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			gcp: { projectId: "project-a", region: "us-central1" },
+		});
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			gcp: { projectId: "" },
+		});
+
+		const settings = manager.getProviderSettings("test-provider");
+		expect(settings?.gcp?.projectId).toBeUndefined();
+		expect(settings?.gcp?.region).toBe("us-central1");
+	});
+
+	it("passes through scalar fields like maxTokens and timeout", () => {
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: true,
+			maxTokens: 4096,
+			timeout: 30_000,
+		});
+
+		const settings = manager.getProviderSettings("test-provider") as Record<
+			string,
+			unknown
+		>;
+		expect(settings?.maxTokens).toBe(4096);
+		expect(settings?.timeout).toBe(30_000);
+	});
+
+	it("disabling a last-used provider also clears lastUsedProvider", async () => {
+		// Set test-provider as last used
+		manager.saveProviderSettings(
+			{ provider: "test-provider", model: "m1" },
+			{ setLastUsed: true },
+		);
+		expect(manager.getLastUsedProviderSettings()?.provider).toBe(
+			"test-provider",
+		);
+
+		saveLocalProviderSettings(manager, {
+			providerId: "test-provider",
+			enabled: false,
+		});
+
+		expect(manager.getLastUsedProviderSettings()).toBeUndefined();
+	});
+});
+
+// ===========================================================================
+// updateLocalProvider
+// ===========================================================================
+
+describe("updateLocalProvider", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(async () => {
+		({ manager, cleanup } = makeTempManager());
+		await addLocalProvider(manager, {
+			providerId: "editable-provider",
+			name: "Editable Provider",
+			baseUrl: "https://example.invalid/v1",
+			apiKey: "seed-key",
+			models: ["model-a", "model-b"],
+			defaultModelId: "model-a",
+		});
+	});
+
+	afterEach(() => cleanup());
+
+	it("updates provider metadata and model registry", async () => {
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			name: "Renamed Provider",
+			baseUrl: "https://api.example.invalid/v2",
+			models: ["model-c", "model-d"],
+			defaultModelId: "model-d",
+			capabilities: ["vision", "reasoning"],
+		});
+
+		const provider = await LlmsModels.getProvider("editable-provider");
+		expect(provider?.name).toBe("Renamed Provider");
+		expect(provider?.baseUrl).toBe("https://api.example.invalid/v2");
+		expect(provider?.defaultModelId).toBe("model-d");
+
+		const { models } = await getLocalProviderModels("editable-provider");
+		expect(models.map((model) => model.id).sort()).toEqual([
+			"model-c",
+			"model-d",
+		]);
+		expect(models.find((model) => model.id === "model-c")?.supportsVision).toBe(
+			true,
+		);
+		expect(
+			models.find((model) => model.id === "model-c")?.supportsReasoning,
+		).toBe(true);
+	});
+
+	it("updates provider settings and can clear optional fields", async () => {
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			baseUrl: "https://api.example.invalid/v3",
+			apiKey: "",
+			headers: null,
+			timeoutMs: null,
+		});
+
+		const settings = manager.getProviderSettings("editable-provider");
+		expect(settings?.baseUrl).toBe("https://api.example.invalid/v3");
+		expect(settings).not.toHaveProperty("apiKey");
+		expect(settings).not.toHaveProperty("headers");
+		expect(settings).not.toHaveProperty("timeout");
+	});
+
+	it("clears capabilities with null and does not treat [] as a clear sentinel", async () => {
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			capabilities: ["vision"],
+		});
+		const modelsPath = resolveModelsRegistryPath(manager);
+		let modelsState = await readModelsFile(modelsPath);
+		expect(
+			modelsState.providers["editable-provider"]?.provider?.capabilities,
+		).toEqual(["vision"]);
+
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			capabilities: [],
+		});
+		modelsState = await readModelsFile(modelsPath);
+		expect(
+			modelsState.providers["editable-provider"]?.provider?.capabilities,
+		).toEqual([]);
+
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			capabilities: null,
+		});
+		modelsState = await readModelsFile(modelsPath);
+		expect(
+			modelsState.providers["editable-provider"]?.provider?.capabilities,
+		).toBeUndefined();
+	});
+
+	it("allows modelsSourceUrl: null to clear URL while preserving existing models", async () => {
+		const fetchMock = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ["remote-a", "remote-b"],
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			models: ["model-a", "model-b"],
+			modelsSourceUrl: "https://example.invalid/models",
+		});
+
+		await updateLocalProvider(manager, {
+			providerId: "editable-provider",
+			modelsSourceUrl: null,
+		});
+
+		const modelsState = await readModelsFile(
+			resolveModelsRegistryPath(manager),
+		);
+		expect(
+			modelsState.providers["editable-provider"]?.provider?.modelsSourceUrl,
+		).toBeUndefined();
+
+		const { models } = await getLocalProviderModels("editable-provider");
+		expect(models.map((model) => model.id).sort()).toEqual([
+			"model-a",
+			"model-b",
+			"remote-a",
+			"remote-b",
+		]);
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("updates a provider that exists in settings but not models registry", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "settings-only-provider",
+				baseUrl: "https://settings.example.invalid/v1",
+				model: "saved-model",
+			},
+			{ setLastUsed: false },
+		);
+
+		const result = await updateLocalProvider(manager, {
+			providerId: "settings-only-provider",
+			models: ["new-model-a", "new-model-b"],
+			defaultModelId: "new-model-b",
+		});
+
+		expect(result.modelsCount).toBe(2);
+		const provider = await LlmsModels.getProvider("settings-only-provider");
+		expect(provider?.name).toBe("Settings Only Provider");
+		expect(provider?.baseUrl).toBe("https://settings.example.invalid/v1");
+		expect(provider?.defaultModelId).toBe("new-model-b");
+
+		const settings = manager.getProviderSettings("settings-only-provider");
+		expect(settings?.baseUrl).toBe("https://settings.example.invalid/v1");
+		expect(settings?.model).toBe("new-model-b");
+
+		const { models } = await getLocalProviderModels("settings-only-provider");
+		expect(models.map((model) => model.id).sort()).toEqual([
+			"new-model-a",
+			"new-model-b",
+		]);
+	});
+
+	it("throws when updating a provider that does not exist in custom registry", async () => {
+		await expect(
+			updateLocalProvider(manager, {
+				providerId: "missing-provider",
+				name: "Nope",
+			}),
+		).rejects.toThrow('"missing-provider" does not exist');
+	});
+});
+
+// ===========================================================================
+// deleteLocalProvider
+// ===========================================================================
+
+describe("deleteLocalProvider", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(async () => {
+		({ manager, cleanup } = makeTempManager());
+		await addLocalProvider(manager, {
+			providerId: "delete-me-provider",
+			name: "Delete Me",
+			baseUrl: "https://example.invalid/v1",
+			models: ["delete-model"],
+		});
+		manager.saveProviderSettings(
+			{
+				provider: "delete-me-provider",
+				baseUrl: "https://example.invalid/v1",
+				model: "delete-model",
+			},
+			{ setLastUsed: true },
+		);
+	});
+
+	afterEach(() => cleanup());
+
+	it("removes provider from registry and local settings", async () => {
+		await deleteLocalProvider(manager, {
+			providerId: "delete-me-provider",
+		});
+
+		expect(LlmsModels.hasProvider("delete-me-provider")).toBe(false);
+		expect(manager.getProviderSettings("delete-me-provider")).toBeUndefined();
+		expect(manager.getLastUsedProviderSettings()).toBeUndefined();
+	});
+
+	it("throws when deleting an unknown provider", async () => {
+		await expect(
+			deleteLocalProvider(manager, { providerId: "missing-provider" }),
+		).rejects.toThrow('"missing-provider" does not exist');
+	});
+});
+
+// ===========================================================================
+// listLocalProviders
+// ===========================================================================
+
+describe("listLocalProviders", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		({ manager, cleanup } = makeTempManager());
+	});
+
+	afterEach(() => cleanup());
+
+	it("includes all registered providers", async () => {
+		await addLocalProvider(manager, {
+			providerId: "list-provider-a",
+			name: "Provider A",
+			baseUrl: "https://example.invalid/a",
+			models: ["ma1"],
+		});
+		await addLocalProvider(manager, {
+			providerId: "list-provider-b",
+			name: "Provider B",
+			baseUrl: "https://example.invalid/b",
+			models: ["mb1"],
+		});
+
+		const { providers } = await listLocalProviders(manager);
+		const ids = providers.map((p) => p.id);
+		expect(ids).toContain("list-provider-a");
+		expect(ids).toContain("list-provider-b");
+	});
+
+	it("hides ClinePass when the ClinePass feature flag is disabled", async () => {
+		const { providers } = await listLocalProviders(manager, {
+			isClinePassEnabled: false,
+		});
+
+		expect(providers.map((p) => p.id)).not.toContain("cline-pass");
+	});
+
+	it("includes ClinePass when the ClinePass feature flag is enabled", async () => {
+		const { providers } = await listLocalProviders(manager, {
+			isClinePassEnabled: true,
+		});
+
+		expect(providers.map((p) => p.id)).toContain("cline-pass");
+	});
+
+	it("marks enabled providers correctly", async () => {
+		await addLocalProvider(manager, {
+			providerId: "enabled-check-provider",
+			name: "Enabled Check",
+			baseUrl: "https://example.invalid/v1",
+			models: ["m1"],
+		});
+
+		const { providers } = await listLocalProviders(manager);
+		const p = providers.find((x) => x.id === "enabled-check-provider");
+		expect(p?.enabled).toBe(true);
+	});
+
+	it("marks alias providers enabled without copying shared OAuth credentials", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "cline",
+				auth: {
+					accessToken: "shared-token",
+					refreshToken: "shared-refresh",
+				},
+			},
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+
+		markLocalProviderEnabled(manager, "cline-pass", { tokenSource: "oauth" });
+
+		const state = manager.read();
+		expect(state.providers["cline-pass"]?.settings).toEqual({
+			provider: "cline-pass",
+		});
+		expect(state.providers["cline-pass"]?.tokenSource).toBe("oauth");
+	});
+
+	it("resolves shared OAuth metadata for ClinePass catalog entries", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "cline",
+				auth: {
+					accessToken: "shared-token",
+					refreshToken: "shared-refresh",
+				},
+			},
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+		markLocalProviderEnabled(manager, "cline-pass", { tokenSource: "oauth" });
+
+		const { providers } = await listLocalProviders(manager, {
+			isClinePassEnabled: true,
+		});
+		const clinePass = providers.find(
+			(provider) => provider.id === "cline-pass",
+		);
+
+		expect(clinePass).toMatchObject({
+			enabled: true,
+			oauthAccessTokenPresent: true,
+		});
+	});
+
+	it("exposes model count", async () => {
+		await addLocalProvider(manager, {
+			providerId: "count-provider",
+			name: "Count",
+			baseUrl: "https://example.invalid/v1",
+			models: ["x", "y", "z"],
+		});
+
+		const { providers } = await listLocalProviders(manager);
+		const p = providers.find((x) => x.id === "count-provider");
+		expect(p?.models).toBe(3);
+	});
+
+	it("generates a stable color and letter for each provider", async () => {
+		await addLocalProvider(manager, {
+			providerId: "color-letter-provider",
+			name: "Color Letter",
+			baseUrl: "https://example.invalid/v1",
+			models: ["m1"],
+		});
+
+		const { providers } = await listLocalProviders(manager);
+		const p = providers.find((x) => x.id === "color-letter-provider");
+		expect(p?.color).toMatch(/^#[0-9a-f]{6}$/i);
+		expect(p?.letter).toBeTruthy();
+	});
+
+	it("includes built-in model lists in the provider catalog path", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "openai-native",
+				apiKey: "test-key",
+				baseUrl: "https://api.openai.com/v1",
+				model: "gpt-5.3-codex",
+			},
+			{ setLastUsed: false },
+		);
+
+		const { providers } = await listLocalProviders(manager);
+		const openai = providers.find(
+			(provider) => provider.id === "openai-native",
+		);
+
+		expect(openai?.modelList?.length).toBeGreaterThan(0);
+		expect(
+			openai?.modelList?.some((model) => model.id === "gpt-5.3-codex"),
+		).toBe(true);
+	});
+
+	it("exposes provider-specific config fields for Vertex", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "vertex",
+				gcp: { projectId: "gcp-project", region: "us-west1" },
+				model: "claude-sonnet-4-6@default",
+			},
+			{ setLastUsed: false },
+		);
+
+		const { providers } = await listLocalProviders(manager);
+		const vertex = providers.find((provider) => provider.id === "vertex");
+
+		expect(vertex?.configFields?.map((field) => field.path)).toEqual([
+			"gcp.projectId",
+			"gcp.region",
+			"apiKey",
+		]);
+		expect(vertex?.configValues?.["gcp.projectId"]).toBe("gcp-project");
+		expect(vertex?.configValues?.["gcp.region"]).toBe("us-west1");
+		expect(
+			vertex?.configFields?.some((field) => field.path === "baseUrl"),
+		).toBe(false);
+	});
+
+	it("uses Cline-specific Z.ai aliases in the built-in model list", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "cline",
+				apiKey: "test-key",
+				baseUrl: "https://api.cline.bot/api/v1",
+				model: "anthropic/claude-sonnet-4.6",
+			},
+			{ setLastUsed: false },
+		);
+
+		const { providers } = await listLocalProviders(manager);
+		const cline = providers.find((provider) => provider.id === "cline");
+		const openrouter = providers.find(
+			(provider) => provider.id === "openrouter",
+		);
+		const clineModelIds = new Set(
+			cline?.modelList?.map((model) => model.id) ?? [],
+		);
+		const openrouterModelIds = new Set(
+			openrouter?.modelList?.map((model) => model.id) ?? [],
+		);
+
+		expect(cline?.modelList?.length).toBeGreaterThan(0);
+		expect(clineModelIds).toContain("zai/glm-5.2");
+		expect(clineModelIds).not.toContain("z-ai/glm-5.2");
+		expect(openrouterModelIds).toContain("z-ai/glm-5.2");
+	});
+
+	it("does not eagerly fetch LiteLLM private models while listing providers", async () => {
+		manager.saveProviderSettings(
+			{
+				provider: "litellm",
+				apiKey: "test-key",
+				baseUrl: "http://localhost:4000",
+				model: "gpt-4o",
+			},
+			{ setLastUsed: false },
+		);
+		const fetchMock = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ({
+				data: [
+					{
+						model_name: "team-private-model",
+						litellm_params: { model: "team/private-model" },
+						model_info: {},
+					},
+				],
+			}),
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const { providers } = await listLocalProviders(manager);
+		const litellm = providers.find((provider) => provider.id === "litellm");
+
+		expect(fetchMock).not.toHaveBeenCalled();
+		expect(litellm?.modelList?.length).toBeGreaterThan(0);
+		expect(
+			litellm?.modelList?.some((model) => model.id === "team/private-model"),
+		).toBe(false);
+	});
+});
+
+// ===========================================================================
+// normalizeOAuthProvider
+// ===========================================================================
+
+describe("normalizeOAuthProvider", () => {
+	it("normalizes 'cline' to 'cline'", () => {
+		expect(normalizeOAuthProvider("cline")).toBe("cline");
+		expect(normalizeOAuthProvider("  CLINE  ")).toBe("cline");
+	});
+
+	it("normalizes 'oca' to 'oca'", () => {
+		expect(normalizeOAuthProvider("oca")).toBe("oca");
+		expect(normalizeOAuthProvider("OCA")).toBe("oca");
+	});
+
+	it("normalizes 'openai-codex' to 'openai-codex'", () => {
+		expect(normalizeOAuthProvider("openai-codex")).toBe("openai-codex");
+		expect(normalizeOAuthProvider("OPENAI-CODEX")).toBe("openai-codex");
+	});
+
+	it("throws for unsupported providers", () => {
+		expect(() => normalizeOAuthProvider("anthropic")).toThrow(
+			"does not support OAuth login",
+		);
+		expect(() => normalizeOAuthProvider("")).toThrow();
+	});
+});
+
+// ===========================================================================
+// resolveLocalClineAuthToken
+// ===========================================================================
+
+describe("resolveLocalClineAuthToken", () => {
+	it("returns undefined when settings is undefined", () => {
+		expect(resolveLocalClineAuthToken(undefined)).toBeUndefined();
+	});
+
+	it("returns accessToken when present", () => {
+		expect(
+			resolveLocalClineAuthToken({
+				provider: "cline" as never,
+				auth: { accessToken: "tok123" },
+			}),
+		).toBe("tok123");
+	});
+
+	it("falls back to apiKey when accessToken is absent", () => {
+		expect(
+			resolveLocalClineAuthToken({
+				provider: "cline" as never,
+				apiKey: "api-key-456",
+			}),
+		).toBe("api-key-456");
+	});
+
+	it("prefers accessToken over apiKey", () => {
+		expect(
+			resolveLocalClineAuthToken({
+				provider: "cline" as never,
+				apiKey: "api-key",
+				auth: { accessToken: "access-token" },
+			}),
+		).toBe("access-token");
+	});
+
+	it("returns undefined when both accessToken and apiKey are empty strings", () => {
+		expect(
+			resolveLocalClineAuthToken({
+				provider: "cline" as never,
+				apiKey: "   ",
+				auth: { accessToken: "  " },
+			}),
+		).toBeUndefined();
+	});
+
+	it("returns undefined when both fields are absent", () => {
+		expect(
+			resolveLocalClineAuthToken({ provider: "cline" as never }),
+		).toBeUndefined();
+	});
+});
+
+describe("refreshProviderModelsFromSource", () => {
+	let manager: ProviderSettingsManager;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		({ manager, cleanup } = makeTempManager());
+	});
+
+	afterEach(() => cleanup());
+
+	it("refreshes built-in Ollama models through modelsSourceUrl using the saved base URL", async () => {
+		const fetchMock = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ({ models: [{ name: "remote-llama" }] }),
+		});
+		vi.stubGlobal("fetch", fetchMock);
+		saveLocalProviderSettings(manager, {
+			providerId: "ollama",
+			baseUrl: "http://tailscale-host:11434/v1",
+		});
+
+		const result = await refreshProviderModelsFromSource(manager, "ollama");
+
+		expect(result).toMatchObject({ providerId: "ollama", refreshed: true });
+		expect(fetchMock).toHaveBeenCalledWith(
+			"http://tailscale-host:11434/api/tags",
+			{
+				method: "GET",
+			},
+		);
+		const modelsState = await readModelsFile(
+			resolveModelsRegistryPath(manager),
+		);
+		expect(modelsState.providers.ollama?.provider?.modelsSourceUrl).toBe(
+			"http://tailscale-host:11434/api/tags",
+		);
+		const { models } = await getLocalProviderModels("ollama");
+		expect(models.map((model) => model.id)).toContain("remote-llama");
+	});
+});
diff --git a/sdk/packages/core/src/services/providers/local-provider-service.ts b/sdk/packages/core/src/services/providers/local-provider-service.ts
new file mode 100644
index 0000000..73c8bae
--- /dev/null
+++ b/sdk/packages/core/src/services/providers/local-provider-service.ts
@@ -0,0 +1,963 @@
+import * as LlmsModels from "@cline/llms";
+import type {
+	AddProviderActionRequest,
+	ITelemetryService,
+	ProviderCapability,
+	ProviderConfigField,
+	ProviderConfigFieldPrimitive,
+	ProviderListItem,
+	ProviderModel,
+	SaveProviderSettingsActionRequest,
+} from "@cline/shared";
+import { createOAuthClientCallbacks } from "../../auth/client";
+import {
+	getProviderAuthHandler,
+	loginAndSaveProviderOAuthCredentials,
+	type ProviderOAuthCredentials,
+	saveProviderOAuthCredentials,
+} from "../../auth/provider-auth-registry";
+import { resolveProviderConfig } from "../../services/llms/provider-defaults";
+import type {
+	ModelInfo,
+	ProviderClient,
+	ProviderConfig,
+	ProviderProtocol,
+	ProviderSettings,
+} from "../../services/llms/provider-settings";
+import type { ProviderTokenSource } from "../../types/provider-settings";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import {
+	readModelsFile,
+	registerCustomProvider,
+	resolveModelsRegistryPath,
+	toProviderModel,
+	writeModelsFile,
+} from "./local-provider-registry";
+import {
+	fetchModelIdsFromSource,
+	resolveModelsSourceUrl,
+} from "./model-source";
+
+export { ensureCustomProvidersLoaded } from "./local-provider-registry";
+
+const CLINE_PASS_PROVIDER_ID = "cline-pass";
+
+export interface ListLocalProvidersOptions {
+	isClinePassEnabled?: boolean;
+}
+
+export interface UpdateLocalProviderRequest {
+	providerId: string;
+	name?: string;
+	baseUrl?: string;
+	apiKey?: string | null;
+	headers?: Record<string, string> | null;
+	timeoutMs?: number | null;
+	models?: string[];
+	defaultModelId?: string | null;
+	modelsSourceUrl?: string | null;
+	protocol?: ProviderProtocol | null;
+	client?: ProviderClient | null;
+	capabilities?: ProviderCapability[] | null;
+}
+
+export interface DeleteLocalProviderRequest {
+	providerId: string;
+}
+
+// --- Small pure helpers ---
+
+function resolveVisibleApiKey(settings: {
+	apiKey?: string;
+	auth?: { apiKey?: string };
+}): string | undefined {
+	return settings.apiKey ?? settings.auth?.apiKey;
+}
+
+function hasOAuthAccessToken(settings: {
+	auth?: { accessToken?: string };
+}): boolean {
+	return (settings.auth?.accessToken?.trim() ?? "").length > 0;
+}
+
+function titleCaseFromId(id: string): string {
+	return id
+		.split(/[-_]/)
+		.filter(Boolean)
+		.map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+		.join(" ");
+}
+
+function createLetter(name: string): string {
+	const parts = name.split(/\s+/).filter(Boolean);
+	if (parts.length === 0) return "?";
+	if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+	return `${parts[0][0]}${parts[1][0]}`.toUpperCase();
+}
+
+function stableColor(id: string): string {
+	const palette = [
+		"#c4956a",
+		"#6b8aad",
+		"#e8963a",
+		"#5b9bd5",
+		"#6bbd7b",
+		"#9b7dd4",
+		"#d07f68",
+		"#57a6a1",
+	];
+	let hash = 0;
+	for (const ch of id) hash = (hash * 31 + ch.charCodeAt(0)) >>> 0;
+	return palette[hash % palette.length];
+}
+
+function toSortedProviderModels(
+	modelMap: Record<string, ModelInfo>,
+): ProviderModel[] {
+	return Object.entries(modelMap)
+		.sort(([a], [b]) => a.localeCompare(b))
+		.map(([modelId, info]) => toProviderModel(modelId, info));
+}
+
+async function resolveProviderModelMap(
+	providerId: string,
+	config?: ProviderConfig,
+): Promise<Record<string, ModelInfo>> {
+	const registeredModels = await LlmsModels.getModelsForProvider(providerId);
+	const isClinePass = providerId === CLINE_PASS_PROVIDER_ID;
+	if (!config && !isClinePass) {
+		return registeredModels;
+	}
+
+	const resolved = await resolveProviderConfig(
+		providerId,
+		{
+			loadLatestOnInit: isClinePass,
+			loadPrivateOnAuth: true,
+			failOnError: false,
+		},
+		config,
+	);
+
+	if (providerId === "litellm" && resolved?.knownModels) {
+		return resolved.knownModels;
+	}
+	if (isClinePass && resolved?.knownModels) {
+		return resolved.knownModels;
+	}
+
+	return resolved?.knownModels
+		? {
+				...registeredModels,
+				...resolved.knownModels,
+			}
+		: registeredModels;
+}
+
+function uniqueTrimmed(values?: string[]): string[] {
+	return [...new Set((values ?? []).map((v) => v.trim()).filter(Boolean))];
+}
+
+function uniqueCapabilities(
+	values: readonly ProviderCapability[] | undefined,
+): ProviderCapability[] | undefined {
+	if (!values?.length) return undefined;
+	return [...new Set(values)];
+}
+
+function resolveProviderCapabilities(
+	infoCapabilities: readonly ProviderCapability[] | undefined,
+	settingsCapabilities: readonly ProviderCapability[] | undefined,
+): ProviderCapability[] | undefined {
+	return uniqueCapabilities([
+		...(infoCapabilities ?? []),
+		...(settingsCapabilities ?? []),
+	]);
+}
+
+function getPopularRank(metadata: Record<string, unknown> | undefined): number {
+	const value = metadata?.popularRank;
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: Number.MAX_SAFE_INTEGER;
+}
+
+function isProviderConfigField(input: unknown): input is ProviderConfigField {
+	if (!input || typeof input !== "object") return false;
+	const field = input as Record<string, unknown>;
+	return (
+		typeof field.path === "string" &&
+		field.path.trim().length > 0 &&
+		typeof field.label === "string" &&
+		field.label.trim().length > 0 &&
+		["text", "password", "url", "number", "select", "boolean"].includes(
+			String(field.type),
+		)
+	);
+}
+
+function readProviderConfigFields(
+	metadata: Record<string, unknown> | undefined,
+): ProviderConfigField[] | undefined {
+	const fields = metadata?.configFields;
+	if (!Array.isArray(fields)) {
+		return undefined;
+	}
+	return fields.filter(isProviderConfigField);
+}
+
+const API_KEY_CONFIG_FIELD: ProviderConfigField = {
+	path: "apiKey",
+	label: "API Key",
+	type: "password",
+	placeholder: "Enter API key...",
+	description: "API key issued by the provider.",
+	secret: true,
+};
+
+const BASE_URL_CONFIG_FIELD: ProviderConfigField = {
+	path: "baseUrl",
+	label: "Base URL",
+	type: "url",
+	placeholder: "https://...",
+	description: "Base endpoint used for provider requests.",
+};
+
+function fallbackProviderConfigFields(
+	info: Awaited<ReturnType<typeof LlmsModels.getProvider>>,
+): ProviderConfigField[] {
+	if (!info) {
+		return [API_KEY_CONFIG_FIELD];
+	}
+	if (info.source !== "system") {
+		return info.baseUrl
+			? [API_KEY_CONFIG_FIELD, BASE_URL_CONFIG_FIELD]
+			: [API_KEY_CONFIG_FIELD];
+	}
+	const fields: ProviderConfigField[] = [];
+	if (info.env?.length) {
+		fields.push(API_KEY_CONFIG_FIELD);
+	}
+	if (info.baseUrl) {
+		fields.push(BASE_URL_CONFIG_FIELD);
+	}
+	return fields;
+}
+
+function getPathValue(input: unknown, path: string): unknown {
+	return path.split(".").reduce<unknown>((current, segment) => {
+		if (!current || typeof current !== "object") return undefined;
+		return (current as Record<string, unknown>)[segment];
+	}, input);
+}
+
+function toConfigPrimitive(
+	value: unknown,
+): ProviderConfigFieldPrimitive | undefined {
+	if (
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean" ||
+		value === null
+	) {
+		return value;
+	}
+	return undefined;
+}
+
+function resolveConfigValues(
+	fields: readonly ProviderConfigField[] | undefined,
+	settings: ProviderSettings | undefined,
+	info: { baseUrl?: string } | undefined,
+): Record<string, ProviderConfigFieldPrimitive> | undefined {
+	if (!fields?.length) return undefined;
+
+	const values: Record<string, ProviderConfigFieldPrimitive> = {};
+	for (const field of fields) {
+		const persistedValue = toConfigPrimitive(
+			field.path === "baseUrl" && settings?.baseUrl === undefined
+				? info?.baseUrl
+				: getPathValue(settings, field.path),
+		);
+		const value = persistedValue ?? field.defaultValue;
+		if (value !== undefined) {
+			values[field.path] = value;
+		}
+	}
+	return values;
+}
+
+function normalizeHeaders(
+	headers: Record<string, string> | null | undefined,
+): Record<string, string> | undefined {
+	const entries = Object.entries(headers ?? {}).filter(
+		([key]) => key.trim().length > 0,
+	);
+	return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+function buildProviderModels(
+	modelIds: string[],
+	capabilities: ProviderCapability[] | undefined,
+) {
+	const supportsVision = capabilities?.includes("vision") ?? false;
+	const supportsReasoning = capabilities?.includes("reasoning") ?? false;
+	return Object.fromEntries(
+		modelIds.map((id) => [
+			id,
+			{
+				id,
+				name: id,
+				supportsVision,
+				supportsAttachments: supportsVision,
+				supportsReasoning,
+			},
+		]),
+	);
+}
+
+async function resolveModelIds(params: {
+	providerId: string;
+	explicitModels?: string[];
+	modelsSourceUrl?: string;
+	fallbackModelIds?: string[];
+	shouldRecompute: boolean;
+}): Promise<string[]> {
+	if (!params.shouldRecompute) {
+		return params.fallbackModelIds ?? [];
+	}
+	const fetchedModels = params.modelsSourceUrl
+		? await fetchModelIdsFromSource(params.modelsSourceUrl, params.providerId)
+		: [];
+	return [...new Set([...(params.explicitModels ?? []), ...fetchedModels])];
+}
+
+function removeProviderFromSettingsState(
+	manager: ProviderSettingsManager,
+	providerId: string,
+): void {
+	const state = manager.read();
+	let mutated = false;
+	if (state.providers[providerId]) {
+		delete state.providers[providerId];
+		mutated = true;
+	}
+	if (state.lastUsedProvider === providerId) {
+		delete state.lastUsedProvider;
+		mutated = true;
+	}
+	if (mutated) manager.write(state);
+	LlmsModels.unregisterProvider(providerId);
+}
+
+// --- Public API ---
+
+export async function addLocalProvider(
+	manager: ProviderSettingsManager,
+	request: Omit<AddProviderActionRequest, "action">,
+): Promise<{
+	providerId: string;
+	settingsPath: string;
+	modelsPath: string;
+	modelsCount: number;
+}> {
+	const providerId = request.providerId.trim().toLowerCase();
+	if (!providerId) throw new Error("providerId is required");
+	const baseUrl = request.baseUrl.trim();
+	const apiKey = request.apiKey?.trim() ?? "";
+
+	// Compatibility path: empty baseUrl + empty apiKey is treated as a delete request.
+	if (!baseUrl && !apiKey) {
+		const modelsPath = resolveModelsRegistryPath(manager);
+		const modelsState = await readModelsFile(modelsPath);
+		if (modelsState.providers[providerId]) {
+			const deleted = await deleteLocalProvider(manager, { providerId });
+			return {
+				providerId,
+				settingsPath: deleted.settingsPath,
+				modelsPath: deleted.modelsPath,
+				modelsCount: 0,
+			};
+		}
+
+		removeProviderFromSettingsState(manager, providerId);
+
+		return {
+			providerId,
+			settingsPath: manager.getFilePath(),
+			modelsPath,
+			modelsCount: 0,
+		};
+	}
+
+	if (LlmsModels.hasProvider(providerId))
+		throw new Error(`provider "${providerId}" already exists`);
+
+	const providerName = request.name.trim();
+	if (!providerName) throw new Error("name is required");
+	if (!baseUrl) throw new Error("baseUrl is required");
+
+	const typedModels = uniqueTrimmed(request.models);
+	const sourceUrl = request.modelsSourceUrl?.trim();
+	const modelIds = await resolveModelIds({
+		providerId,
+		explicitModels: typedModels,
+		modelsSourceUrl: sourceUrl,
+		shouldRecompute: true,
+	});
+	if (modelIds.length === 0) {
+		throw new Error(
+			"at least one model is required (manual or via modelsSourceUrl)",
+		);
+	}
+
+	const defaultModelId =
+		request.defaultModelId?.trim() &&
+		modelIds.includes(request.defaultModelId.trim())
+			? request.defaultModelId.trim()
+			: modelIds[0];
+
+	const capabilities = request.capabilities?.length
+		? [...new Set(request.capabilities)]
+		: undefined;
+	const normalizedHeaders = normalizeHeaders(request.headers);
+
+	manager.saveProviderSettings(
+		{
+			provider: providerId,
+			apiKey: apiKey || undefined,
+			baseUrl,
+			headers: normalizedHeaders,
+			timeout: request.timeoutMs,
+			model: defaultModelId,
+			protocol: request.protocol,
+			client: request.client,
+		},
+		{ setLastUsed: false },
+	);
+
+	const modelsPath = resolveModelsRegistryPath(manager);
+	const modelsState = await readModelsFile(modelsPath);
+
+	modelsState.providers[providerId] = {
+		provider: {
+			name: providerName,
+			baseUrl,
+			defaultModelId,
+			protocol: request.protocol,
+			client: request.client,
+			capabilities,
+			modelsSourceUrl: sourceUrl,
+		},
+		models: buildProviderModels(modelIds, capabilities),
+	};
+	await writeModelsFile(modelsPath, modelsState);
+	registerCustomProvider(providerId, modelsState.providers[providerId]);
+
+	return {
+		providerId,
+		settingsPath: manager.getFilePath(),
+		modelsPath,
+		modelsCount: modelIds.length,
+	};
+}
+
+export async function updateLocalProvider(
+	manager: ProviderSettingsManager,
+	request: UpdateLocalProviderRequest,
+): Promise<{
+	providerId: string;
+	settingsPath: string;
+	modelsPath: string;
+	modelsCount: number;
+}> {
+	const providerId = request.providerId.trim().toLowerCase();
+	if (!providerId) throw new Error("providerId is required");
+
+	const modelsPath = resolveModelsRegistryPath(manager);
+	const modelsState = await readModelsFile(modelsPath);
+	let existingEntry = modelsState.providers[providerId];
+	if (!existingEntry) {
+		const existingSettings = manager.getProviderSettings(providerId);
+		if (!existingSettings) {
+			throw new Error(`provider "${providerId}" does not exist`);
+		}
+
+		const requestedSourceUrl = request.modelsSourceUrl?.trim();
+		const seedModelId =
+			uniqueTrimmed(request.models)[0] ?? existingSettings.model?.trim();
+		if (!seedModelId && !requestedSourceUrl) {
+			throw new Error(
+				`provider "${providerId}" cannot be updated because no model is configured`,
+			);
+		}
+
+		// Ephemeral seed for the existing update path; final state is computed and written below.
+		existingEntry = {
+			provider: {
+				name: request.name?.trim() || titleCaseFromId(providerId),
+				baseUrl:
+					request.baseUrl?.trim() ?? existingSettings.baseUrl?.trim() ?? "",
+				defaultModelId: seedModelId,
+				protocol: existingSettings.protocol,
+				client: existingSettings.client,
+				capabilities: existingSettings.capabilities,
+			},
+			models: seedModelId
+				? buildProviderModels([seedModelId], existingSettings.capabilities)
+				: {},
+		};
+	}
+	if (!existingEntry.provider) {
+		throw new Error(
+			`provider "${providerId}" cannot be updated because it is a model overlay (no provider metadata)`,
+		);
+	}
+	const providerName =
+		request.name?.trim() ?? existingEntry.provider.name.trim();
+	if (!providerName) throw new Error("name is required");
+
+	const baseUrl =
+		request.baseUrl?.trim() ?? existingEntry.provider.baseUrl.trim();
+	if (!baseUrl) throw new Error("baseUrl is required");
+
+	const capabilities =
+		request.capabilities === undefined
+			? existingEntry.provider.capabilities
+			: request.capabilities === null
+				? undefined
+				: [...new Set(request.capabilities)];
+	const protocol =
+		request.protocol === undefined
+			? existingEntry.provider.protocol
+			: (request.protocol ?? undefined);
+	const client =
+		request.client === undefined
+			? existingEntry.provider.client
+			: (request.client ?? undefined);
+
+	const explicitModels = uniqueTrimmed(request.models);
+	const nextModelsSourceUrl =
+		request.modelsSourceUrl === undefined
+			? existingEntry.provider.modelsSourceUrl
+			: request.modelsSourceUrl?.trim() || undefined;
+	const shouldRecomputeModels =
+		request.models !== undefined ||
+		(request.modelsSourceUrl !== undefined && !!nextModelsSourceUrl);
+	const existingModelIds = Object.keys(existingEntry.models ?? {})
+		.map((id) => id.trim())
+		.filter(Boolean);
+	const modelIds = await resolveModelIds({
+		providerId,
+		explicitModels,
+		modelsSourceUrl: nextModelsSourceUrl,
+		fallbackModelIds: existingModelIds,
+		shouldRecompute: shouldRecomputeModels,
+	});
+	if (modelIds.length === 0) {
+		throw new Error(
+			"at least one model is required (manual or via modelsSourceUrl)",
+		);
+	}
+
+	const defaultModelCandidate =
+		request.defaultModelId === undefined
+			? existingEntry.provider.defaultModelId?.trim()
+			: request.defaultModelId?.trim();
+	const defaultModelId =
+		defaultModelCandidate && modelIds.includes(defaultModelCandidate)
+			? defaultModelCandidate
+			: modelIds[0];
+
+	const existingSettings = manager.getProviderSettings(providerId);
+	const nextSettings: Record<string, unknown> = {
+		...(existingSettings ?? {}),
+		provider: providerId,
+		baseUrl,
+		model: defaultModelId,
+	};
+	if (protocol) nextSettings.protocol = protocol;
+	else delete nextSettings.protocol;
+	if (client) nextSettings.client = client;
+	else delete nextSettings.client;
+	if (request.apiKey !== undefined) {
+		const apiKey = request.apiKey?.trim() ?? "";
+		if (apiKey) nextSettings.apiKey = apiKey;
+		else delete nextSettings.apiKey;
+	}
+	if (request.headers !== undefined) {
+		const normalizedHeaders = normalizeHeaders(request.headers);
+		if (normalizedHeaders) nextSettings.headers = normalizedHeaders;
+		else delete nextSettings.headers;
+	}
+	if (request.timeoutMs !== undefined) {
+		if (typeof request.timeoutMs === "number") {
+			nextSettings.timeout = request.timeoutMs;
+		} else {
+			delete nextSettings.timeout;
+		}
+	}
+
+	manager.saveProviderSettings(nextSettings, { setLastUsed: false });
+
+	modelsState.providers[providerId] = {
+		provider: {
+			name: providerName,
+			baseUrl,
+			defaultModelId,
+			protocol,
+			client,
+			capabilities,
+			modelsSourceUrl: nextModelsSourceUrl,
+		},
+		models: buildProviderModels(modelIds, capabilities),
+	};
+	await writeModelsFile(modelsPath, modelsState);
+	registerCustomProvider(providerId, modelsState.providers[providerId]);
+
+	return {
+		providerId,
+		settingsPath: manager.getFilePath(),
+		modelsPath,
+		modelsCount: modelIds.length,
+	};
+}
+
+export async function deleteLocalProvider(
+	manager: ProviderSettingsManager,
+	request: DeleteLocalProviderRequest,
+): Promise<{
+	providerId: string;
+	settingsPath: string;
+	modelsPath: string;
+}> {
+	const providerId = request.providerId.trim().toLowerCase();
+	if (!providerId) throw new Error("providerId is required");
+
+	const modelsPath = resolveModelsRegistryPath(manager);
+	const modelsState = await readModelsFile(modelsPath);
+	if (!modelsState.providers[providerId]) {
+		throw new Error(`provider "${providerId}" does not exist`);
+	}
+
+	delete modelsState.providers[providerId];
+	await writeModelsFile(modelsPath, modelsState);
+	LlmsModels.unregisterProvider(providerId);
+
+	removeProviderFromSettingsState(manager, providerId);
+
+	return {
+		providerId,
+		settingsPath: manager.getFilePath(),
+		modelsPath,
+	};
+}
+
+export function markLocalProviderEnabled(
+	manager: ProviderSettingsManager,
+	providerId: string,
+	options: { tokenSource?: ProviderTokenSource } = {},
+): { providerId: string; enabled: true; settingsPath: string } {
+	const id = providerId.trim();
+	if (!id) throw new Error("providerId is required");
+
+	const directSettings = manager.read().providers[id]?.settings;
+	manager.saveProviderSettings(
+		{
+			...(directSettings ?? {}),
+			provider: id,
+		},
+		{ setLastUsed: false, tokenSource: options.tokenSource },
+	);
+
+	return { providerId: id, enabled: true, settingsPath: manager.getFilePath() };
+}
+
+export async function listLocalProviders(
+	manager: ProviderSettingsManager,
+	options: ListLocalProvidersOptions = {},
+): Promise<{ providers: ProviderListItem[]; settingsPath: string }> {
+	const state = manager.read();
+	const ids = LlmsModels.getProviderIds();
+
+	const providerEntries = await Promise.all(
+		ids.map(
+			async (id): Promise<{ provider: ProviderListItem; rank: number }> => {
+				const [info, registeredModels] = await Promise.all([
+					LlmsModels.getProvider(id),
+					LlmsModels.getModelsForProvider(id),
+				]);
+				const modelList = toSortedProviderModels(registeredModels);
+				const directSettings = state.providers[id]?.settings;
+				const persistedSettings = manager.getProviderSettings(id);
+				const name = info?.name ?? titleCaseFromId(id);
+				const capabilities = resolveProviderCapabilities(
+					info?.capabilities,
+					persistedSettings?.capabilities,
+				);
+				const configFields =
+					readProviderConfigFields(info?.metadata) ??
+					fallbackProviderConfigFields(info);
+				return {
+					provider: {
+						id,
+						name,
+						models: modelList.length,
+						color: stableColor(id),
+						letter: createLetter(name),
+						enabled: Boolean(directSettings),
+						apiKey: persistedSettings
+							? resolveVisibleApiKey(persistedSettings)
+							: undefined,
+						oauthAccessTokenPresent: persistedSettings
+							? hasOAuthAccessToken(persistedSettings)
+							: undefined,
+						baseUrl: persistedSettings?.baseUrl ?? info?.baseUrl,
+						defaultModelId: info?.defaultModelId,
+						protocol: persistedSettings?.protocol ?? info?.protocol,
+						client: persistedSettings?.client ?? info?.client,
+						capabilities,
+						authDescription: "This provider uses API keys for authentication.",
+						baseUrlDescription:
+							"The base endpoint to use for provider requests.",
+						configFields,
+						configValues: resolveConfigValues(
+							configFields,
+							persistedSettings,
+							info,
+						),
+						modelList,
+					},
+					rank: getPopularRank(info?.metadata),
+				};
+			},
+		),
+	);
+	providerEntries.sort((a, b) => {
+		if (a.rank !== b.rank) return a.rank - b.rank;
+		return (
+			a.provider.name.localeCompare(b.provider.name) ||
+			a.provider.id.localeCompare(b.provider.id)
+		);
+	});
+	let providers = providerEntries.map((entry) => entry.provider);
+	if (options.isClinePassEnabled !== true) {
+		providers = providers.filter(
+			(provider) => provider.id !== CLINE_PASS_PROVIDER_ID,
+		);
+	}
+
+	return { providers, settingsPath: manager.getFilePath() };
+}
+
+export async function getLocalProviderModels(
+	providerId: string,
+	config?: ProviderConfig,
+): Promise<{ providerId: string; models: ProviderModel[] }> {
+	const id = providerId.trim();
+	const modelMap = await resolveProviderModelMap(id, config);
+	const models = toSortedProviderModels(modelMap);
+	return { providerId: id, models };
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function applySettingsObjectPatch(
+	current: unknown,
+	patch: unknown,
+): Record<string, unknown> | undefined {
+	if (!isPlainObject(patch)) {
+		return isPlainObject(current) ? { ...current } : undefined;
+	}
+
+	const next = isPlainObject(current) ? { ...current } : {};
+	for (const [key, value] of Object.entries(patch)) {
+		if (value == null || value === "") {
+			delete next[key];
+			continue;
+		}
+		if (isPlainObject(value)) {
+			const merged = applySettingsObjectPatch(next[key], value);
+			if (merged && Object.keys(merged).length > 0) {
+				next[key] = merged;
+			} else {
+				delete next[key];
+			}
+			continue;
+		}
+		next[key] = value;
+	}
+
+	return Object.keys(next).length > 0 ? next : undefined;
+}
+
+export function saveLocalProviderSettings(
+	manager: ProviderSettingsManager,
+	request: Omit<SaveProviderSettingsActionRequest, "action">,
+): { providerId: string; enabled: boolean; settingsPath: string } {
+	const providerId = request.providerId.trim();
+
+	if (request.enabled === false) {
+		const state = manager.read();
+		delete state.providers[providerId];
+		if (state.lastUsedProvider === providerId) delete state.lastUsedProvider;
+		manager.write(state);
+		return { providerId, enabled: false, settingsPath: manager.getFilePath() };
+	}
+
+	const existing = manager.getProviderSettings(providerId);
+	const next: Record<string, unknown> = {
+		...(existing ?? {}),
+		provider: providerId,
+	};
+
+	// String fields that should be cleared when empty
+	for (const key of ["apiKey", "baseUrl", "model", "region"] as const) {
+		if (Object.hasOwn(request, key) && typeof request[key] === "string") {
+			const val = (request[key] as string).trim();
+			if (val.length === 0) delete next[key];
+			else next[key] = request[key];
+		}
+	}
+
+	// Scalar passthrough fields
+	for (const key of [
+		"maxTokens",
+		"contextWindow",
+		"timeout",
+		"apiLine",
+		"protocol",
+		"client",
+		"routingProviderId",
+		"capabilities",
+	] as const) {
+		if (Object.hasOwn(request, key)) next[key] = request[key];
+	}
+
+	// Merged object fields
+	for (const key of [
+		"auth",
+		"headers",
+		"reasoning",
+		"aws",
+		"gcp",
+		"azure",
+		"sap",
+		"oca",
+	] as const) {
+		if (Object.hasOwn(request, key) && request[key] != null) {
+			const merged = applySettingsObjectPatch(next[key], request[key]);
+			if (merged) next[key] = merged;
+			else delete next[key];
+		}
+	}
+
+	manager.saveProviderSettings(next, { setLastUsed: false });
+	return { providerId, enabled: true, settingsPath: manager.getFilePath() };
+}
+
+export async function refreshProviderModelsFromSource(
+	manager: ProviderSettingsManager,
+	providerId: string,
+): Promise<{ providerId: string; refreshed: boolean; modelsCount?: number }> {
+	const id = providerId.trim();
+	const settings = manager.getProviderSettings(id);
+	const collection = LlmsModels.MODEL_COLLECTIONS_BY_PROVIDER_ID[id] as
+		| LlmsModels.ModelCollection
+		| undefined;
+	const provider = collection?.provider;
+	const baseUrl = settings?.baseUrl?.trim() || provider?.baseUrl?.trim();
+	const modelsSourceUrl = resolveModelsSourceUrl(
+		baseUrl,
+		provider?.baseUrl,
+		provider?.modelsSourceUrl,
+	);
+	if (!settings || !provider || !baseUrl || !modelsSourceUrl) {
+		return { providerId: id, refreshed: false };
+	}
+
+	const result = await updateLocalProvider(manager, {
+		providerId: id,
+		name: provider.name,
+		baseUrl,
+		apiKey: settings.apiKey,
+		headers: settings.headers ?? null,
+		timeoutMs: settings.timeout ?? null,
+		modelsSourceUrl,
+		protocol: settings.protocol ?? provider.protocol ?? null,
+		client: settings.client ?? provider.client ?? null,
+		capabilities: settings.capabilities ?? null,
+	});
+	return { providerId: id, refreshed: true, modelsCount: result.modelsCount };
+}
+
+export function normalizeOAuthProvider(provider: string): string {
+	const normalized = provider.trim().toLowerCase();
+	const handler = getProviderAuthHandler(normalized);
+	if (handler) return handler.providerId;
+	throw new Error(`provider "${provider}" does not support OAuth login`);
+}
+
+export async function loginLocalProvider(
+	providerId: string,
+	existing: ProviderSettings | undefined,
+	openUrl: (url: string) => void,
+	telemetry?: ITelemetryService,
+): Promise<ProviderOAuthCredentials> {
+	const handler = getProviderAuthHandler(providerId);
+	if (!handler) {
+		throw new Error(`provider "${providerId}" does not support OAuth login`);
+	}
+	const callbacks = createOAuthClientCallbacks({
+		onPrompt: async (prompt) => prompt.defaultValue ?? "",
+		openUrl,
+		onOpenUrlError: ({ error }) => {
+			throw error instanceof Error ? error : new Error(String(error));
+		},
+	});
+	return handler.login({ settings: existing, callbacks, telemetry });
+}
+
+export function saveLocalProviderOAuthCredentials(
+	manager: ProviderSettingsManager,
+	providerId: string,
+	existing: ProviderSettings | undefined,
+	credentials: ProviderOAuthCredentials,
+	options?: { setLastUsed?: boolean },
+): ProviderSettings {
+	return saveProviderOAuthCredentials({
+		manager,
+		providerId,
+		settings: existing,
+		credentials,
+		setLastUsed: options?.setLastUsed,
+	});
+}
+
+export async function loginAndSaveLocalProviderOAuthCredentials(
+	manager: ProviderSettingsManager,
+	providerId: string,
+	openUrl: (url: string) => void,
+	telemetry?: ITelemetryService,
+): Promise<ProviderSettings> {
+	const callbacks = createOAuthClientCallbacks({
+		onPrompt: async (prompt) => prompt.defaultValue ?? "",
+		openUrl,
+		onOpenUrlError: ({ error }) => {
+			throw error instanceof Error ? error : new Error(String(error));
+		},
+	});
+	return loginAndSaveProviderOAuthCredentials(manager, providerId, {
+		callbacks,
+		telemetry,
+	});
+}
+
+export function resolveLocalClineAuthToken(
+	settings: ProviderSettings | undefined,
+): string | undefined {
+	const token = settings?.auth?.accessToken?.trim() || settings?.apiKey?.trim();
+	return token && token.length > 0 ? token : undefined;
+}
diff --git a/sdk/packages/core/src/services/providers/model-source.ts b/sdk/packages/core/src/services/providers/model-source.ts
new file mode 100644
index 0000000..9d1b1a8
--- /dev/null
+++ b/sdk/packages/core/src/services/providers/model-source.ts
@@ -0,0 +1,105 @@
+function parseModelIdList(input: unknown): string[] {
+	if (!Array.isArray(input)) return [];
+	return input
+		.map((item) => {
+			if (typeof item === "string") return item.trim();
+			if (item && typeof item === "object") {
+				const entry = item as { id?: unknown; name?: unknown; model?: unknown };
+				for (const value of [entry.id, entry.name, entry.model]) {
+					if (typeof value === "string" && value.trim()) {
+						return value.trim();
+					}
+				}
+			}
+			return "";
+		})
+		.filter((id) => id.length > 0);
+}
+
+export function extractModelIdsFromPayload(
+	payload: unknown,
+	providerId: string,
+): string[] {
+	const rootArray = parseModelIdList(payload);
+	if (rootArray.length > 0) return rootArray;
+	if (!payload || typeof payload !== "object") return [];
+
+	const data = payload as {
+		data?: unknown;
+		models?: unknown;
+		providers?: Record<string, unknown>;
+	};
+
+	const direct = parseModelIdList(data.data ?? data.models);
+	if (direct.length > 0) return direct;
+
+	if (
+		data.models &&
+		typeof data.models === "object" &&
+		!Array.isArray(data.models)
+	) {
+		const keys = Object.keys(data.models).filter((k) => k.trim().length > 0);
+		if (keys.length > 0) return keys;
+	}
+
+	const scoped = data.providers?.[providerId];
+	if (scoped && typeof scoped === "object") {
+		const nested = scoped as { models?: unknown };
+		const list = parseModelIdList(nested.models ?? scoped);
+		if (list.length > 0) return list;
+	}
+
+	return [];
+}
+
+export async function fetchModelIdsFromSource(
+	url: string,
+	providerId: string,
+): Promise<string[]> {
+	const response = await fetch(url, { method: "GET" });
+	if (!response.ok) {
+		throw new Error(
+			`failed to fetch models from ${url}: HTTP ${response.status}`,
+		);
+	}
+	return extractModelIdsFromPayload(
+		(await response.json()) as unknown,
+		providerId,
+	);
+}
+
+function trimTrailingSlash(value: string): string {
+	return value.replace(/\/+$/, "");
+}
+
+export function resolveModelsSourceUrl(
+	baseUrl: string | undefined,
+	defaultBaseUrl: string | undefined,
+	modelsSourceUrl: string | undefined,
+): string | undefined {
+	const source = modelsSourceUrl?.trim();
+	if (!source) return undefined;
+	const configuredBase = baseUrl?.trim();
+	if (!configuredBase || !defaultBaseUrl?.trim()) return source;
+
+	try {
+		const sourceUrl = new URL(source);
+		const defaultBase = new URL(defaultBaseUrl);
+		const configured = new URL(configuredBase);
+		if (sourceUrl.origin !== defaultBase.origin) return source;
+
+		const defaultPath = trimTrailingSlash(defaultBase.pathname);
+		const configuredPath = trimTrailingSlash(configured.pathname);
+		if (defaultPath && sourceUrl.pathname.startsWith(`${defaultPath}/`)) {
+			const suffix = sourceUrl.pathname.slice(defaultPath.length);
+			configured.pathname = `${configuredPath}${suffix}`;
+		} else {
+			configured.pathname = sourceUrl.pathname;
+		}
+		configured.search = sourceUrl.search;
+		configured.hash = sourceUrl.hash;
+		return configured.toString();
+	} catch {
+		return source;
+	}
+}
diff --git a/sdk/packages/core/src/services/providers/provider-config-fields.test.ts b/sdk/packages/core/src/services/providers/provider-config-fields.test.ts
new file mode 100644
index 0000000..fb73ed3
--- /dev/null
+++ b/sdk/packages/core/src/services/providers/provider-config-fields.test.ts
@@ -0,0 +1,158 @@
+import * as LlmsModels from "@cline/llms";
+import { afterEach, describe, expect, it } from "vitest";
+import { registerCustomProvider } from "./local-provider-registry";
+import { getProviderConfigFields } from "./provider-config-fields";
+
+afterEach(() => {
+	LlmsModels.resetRegistry();
+});
+
+describe("getProviderConfigFields", () => {
+	it("returns api-key auth with only apiKey for cloud providers", () => {
+		const result = getProviderConfigFields("anthropic");
+		expect(result.providerId).toBe("anthropic");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl).toBeUndefined();
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for ollama", () => {
+		const result = getProviderConfigFields("ollama");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({
+			note: "Keep empty if no API key for local inference.",
+		});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"http://localhost:11434/v1",
+		);
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for LM Studio", () => {
+		const result = getProviderConfigFields("lmstudio");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"http://localhost:1234/v1",
+		);
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for LiteLLM", () => {
+		const result = getProviderConfigFields("litellm");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"http://localhost:4000/v1",
+		);
+	});
+
+	it("returns api-key auth with apiKey + baseUrl for user-added providers", () => {
+		registerCustomProvider("internal-router", {
+			provider: {
+				name: "Internal Router",
+				baseUrl: "https://llm.internal.example/v1",
+				defaultModelId: "alpha",
+				protocol: "openai-responses",
+			},
+			models: {
+				alpha: { name: "Alpha" },
+			},
+		});
+
+		const result = getProviderConfigFields("internal-router");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"https://llm.internal.example/v1",
+		);
+	});
+
+	it("returns oauth auth with no fields for cline", () => {
+		const result = getProviderConfigFields("cline");
+		expect(result.authMethod).toBe("oauth");
+		expect(result.fields).toEqual({});
+	});
+
+	it("returns oauth auth with no fields for openai-codex", () => {
+		const result = getProviderConfigFields("openai-codex");
+		expect(result.authMethod).toBe("oauth");
+		expect(result.fields).toEqual({});
+	});
+
+	it("returns local auth with no fields for openai-codex-cli", () => {
+		const result = getProviderConfigFields("openai-codex-cli");
+		expect(result.authMethod).toBe("local");
+		expect(result.fields).toEqual({});
+	});
+
+	it("returns api-key auth with apiKey, baseUrl, and Azure API version for OpenAI Compatible", () => {
+		const result = getProviderConfigFields("openai-compatible");
+		expect(result.providerId).toBe("openai-compatible");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.description).toMatch(/Azure AI Foundry/i);
+		expect(result.fields.apiKey).toEqual({});
+		expect(result.fields.baseUrl?.defaultValue).toBe(
+			"https://api.openai.com/v1",
+		);
+		expect(result.fields.azureApiVersion).toMatchObject({
+			label: "Azure API Version (optional)",
+			placeholder: "2025-01-01-preview",
+			optional: true,
+		});
+	});
+
+	it("returns Vertex GCP config fields with optional API key", () => {
+		const result = getProviderConfigFields("vertex");
+		expect(result.providerId).toBe("vertex");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.description).toMatch(/Application Default Credentials/i);
+		expect(Object.keys(result.fields)).toEqual([
+			"gcpProjectId",
+			"gcpRegion",
+			"apiKey",
+		]);
+		expect(result.fields.gcpProjectId?.label).toBe("Google Cloud Project ID");
+		expect(result.fields.gcpRegion?.defaultValue).toBe("us-central1");
+		expect(result.fields.apiKey?.optional).toBe(true);
+	});
+
+	it("returns api-key auth with awsRegion, apiKey, and awsProfile for bedrock", () => {
+		const result = getProviderConfigFields("bedrock");
+		expect(result.providerId).toBe("bedrock");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.description).toMatch(/AWS region/i);
+		expect(Object.keys(result.fields)).toEqual([
+			"awsRegion",
+			"apiKey",
+			"awsProfile",
+		]);
+		expect(result.fields.awsRegion?.label).toBe("AWS Region");
+		expect(result.fields.awsRegion?.placeholder).toBe("us-east-1");
+		expect(result.fields.apiKey?.optional).toBe(true);
+		expect(result.fields.awsProfile?.optional).toBe(true);
+	});
+
+	it("returns SAP AI Core client credential fields instead of a generic API key", () => {
+		const result = getProviderConfigFields("sapaicore");
+		expect(result.providerId).toBe("sapaicore");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.description).toMatch(/not a generic API key/i);
+		expect(Object.keys(result.fields)).toEqual([
+			"baseUrl",
+			"sapClientId",
+			"sapClientSecret",
+			"sapTokenUrl",
+			"sapResourceGroup",
+			"sapDeploymentId",
+		]);
+		expect(result.fields.apiKey).toBeUndefined();
+		expect(result.fields.baseUrl?.label).toBe("AI Core Base URL");
+		expect(result.fields.sapResourceGroup?.optional).toBe(true);
+		expect(result.fields.sapDeploymentId?.optional).toBe(true);
+	});
+
+	it("falls back to a single api-key field for unknown providers", () => {
+		const result = getProviderConfigFields("not-a-real-provider");
+		expect(result.authMethod).toBe("api-key");
+		expect(result.fields).toEqual({ apiKey: {} });
+	});
+});
diff --git a/sdk/packages/core/src/services/providers/provider-config-fields.ts b/sdk/packages/core/src/services/providers/provider-config-fields.ts
new file mode 100644
index 0000000..7b21df1
--- /dev/null
+++ b/sdk/packages/core/src/services/providers/provider-config-fields.ts
@@ -0,0 +1,250 @@
+import * as LlmsModels from "@cline/llms";
+import { isOAuthProvider } from "../../auth/provider-auth-registry";
+
+export type ProviderConfigFieldKey =
+	| "apiKey"
+	| "baseUrl"
+	| "azureApiVersion"
+	| "awsRegion"
+	| "awsProfile"
+	| "gcpProjectId"
+	| "gcpRegion"
+	| "sapClientId"
+	| "sapClientSecret"
+	| "sapTokenUrl"
+	| "sapResourceGroup"
+	| "sapDeploymentId";
+
+export interface ProviderConfigFieldRequirement {
+	defaultValue?: string;
+	label?: string;
+	note?: string;
+	placeholder?: string;
+	optional?: boolean;
+}
+
+export interface ProviderConfigFields {
+	providerId: string;
+	authMethod: "api-key" | "oauth" | "local";
+	fields: Partial<
+		Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>
+	>;
+	/** Optional description shown above the fields (e.g. AWS region auto-fill hint). */
+	description?: string;
+}
+
+const FIELD_KEYS: ProviderConfigFieldKey[] = [
+	"apiKey",
+	"baseUrl",
+	"azureApiVersion",
+	"awsRegion",
+	"awsProfile",
+	"gcpProjectId",
+	"gcpRegion",
+	"sapClientId",
+	"sapClientSecret",
+	"sapTokenUrl",
+	"sapResourceGroup",
+	"sapDeploymentId",
+];
+
+interface ProviderConfigFieldMetadata {
+	description?: string;
+	fields: Partial<
+		Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>
+	>;
+	mode?: "merge" | "replace";
+}
+
+const PROVIDER_CONFIG_FIELD_METADATA: Partial<
+	Record<string, ProviderConfigFieldMetadata>
+> = {
+	"openai-compatible": {
+		description:
+			"For Azure AI Foundry deployments, use a Base URL ending at /openai/deployments/<deployment> and set the Azure API version.",
+		fields: {
+			azureApiVersion: {
+				label: "Azure API Version (optional)",
+				placeholder: "2025-01-01-preview",
+				note: "Required for Azure AI Foundry deployment URLs.",
+				optional: true,
+			},
+		},
+	},
+	vertex: {
+		mode: "replace",
+		description:
+			"Vertex AI can use Google Cloud Application Default Credentials with a project/region. An API key is optional for supported Gemini models.",
+		fields: {
+			gcpProjectId: {
+				label: "Google Cloud Project ID",
+				placeholder: "my-gcp-project",
+			},
+			gcpRegion: {
+				label: "Google Cloud Region",
+				placeholder: "us-central1",
+				defaultValue: "us-central1",
+			},
+			apiKey: {
+				label: "API Key (optional)",
+				placeholder: "Leave blank to use Google Cloud credentials",
+				optional: true,
+			},
+		},
+	},
+	bedrock: {
+		mode: "replace",
+		description:
+			"AWS region is required for Bedrock. It can be auto-filled from AWS_REGION, AWS_DEFAULT_REGION, or ~/.aws/config.",
+		fields: {
+			awsRegion: {
+				label: "AWS Region",
+				placeholder: "us-east-1",
+			},
+			apiKey: {
+				label: "AWS Bedrock API Key (optional)",
+				placeholder: "Leave blank to use AWS profile/default chain",
+				optional: true,
+			},
+			awsProfile: {
+				label: "AWS Profile Name (optional)",
+				placeholder: "default",
+				optional: true,
+			},
+		},
+	},
+	ollama: {
+		fields: {
+			apiKey: {
+				note: "Keep empty if no API key for local inference.",
+			},
+		},
+	},
+	sapaicore: {
+		mode: "replace",
+		description:
+			"SAP AI Core uses OAuth client credentials and an AI Core API URL, not a generic API key.",
+		fields: {
+			baseUrl: {
+				label: "AI Core Base URL",
+				placeholder: "https://api.ai.<region>.aws.ml.hana.ondemand.com",
+			},
+			sapClientId: {
+				label: "Client ID",
+				placeholder: "sb-...|xsuaa_std!b...",
+			},
+			sapClientSecret: {
+				label: "Client Secret",
+				placeholder: "SAP AI Core client secret",
+			},
+			sapTokenUrl: {
+				label: "Token URL",
+				placeholder: "https://<subdomain>.authentication.sap.hana.ondemand.com",
+			},
+			sapResourceGroup: {
+				label: "Resource Group",
+				placeholder: "default",
+				optional: true,
+			},
+			sapDeploymentId: {
+				label: "Deployment ID",
+				placeholder: "SAP AI Core deployment id",
+				optional: true,
+			},
+		},
+	},
+};
+
+function mergeFields(
+	baseFields: ProviderConfigFields["fields"],
+	metadataFields: ProviderConfigFieldMetadata["fields"],
+): ProviderConfigFields["fields"] {
+	const fields: ProviderConfigFields["fields"] = {};
+	for (const field of FIELD_KEYS) {
+		const base = baseFields[field];
+		const metadata = metadataFields[field];
+		if (base || metadata) fields[field] = { ...base, ...metadata };
+	}
+	return fields;
+}
+
+function applyProviderConfigFieldMetadata(
+	config: ProviderConfigFields,
+): ProviderConfigFields {
+	const metadata = PROVIDER_CONFIG_FIELD_METADATA[config.providerId];
+	if (!metadata) return config;
+
+	return {
+		...config,
+		description: metadata.description ?? config.description,
+		fields:
+			metadata.mode === "replace"
+				? metadata.fields
+				: mergeFields(config.fields, metadata.fields),
+	};
+}
+
+const EDITABLE_BASE_URL_PROVIDER_IDS = new Set([
+	"ollama",
+	"lmstudio",
+	"litellm",
+	"openai-compatible",
+]);
+
+function shouldExposeBaseUrlField(
+	providerId: string,
+	collection: LlmsModels.ModelCollection | undefined,
+): boolean {
+	if (!collection?.provider.baseUrl) return false;
+	if (collection.provider.source !== "system") return true;
+	return EDITABLE_BASE_URL_PROVIDER_IDS.has(providerId);
+}
+
+/**
+ * Project a provider into the inputs a configure-dialog should render.
+ *
+ * No fields are marked "required". `llms` no longer pre-flights credentials,
+ * so a missing API key surfaces as the provider's own auth error rather than
+ * a synthetic SDK failure. UIs may still require fields client-side if they
+ * want, but the runtime does not.
+ *
+ * - OAuth providers (`cline`, `oca`, `openai-codex`) return `authMethod:
+ *   "oauth"` with no fields; the configure UI should route to the OAuth
+ *   login flow instead.
+ * - Local auth providers return `authMethod: "local"` with no fields. The
+ *   configure UI should show provider-specific local readiness instead.
+ * - All other providers return `apiKey`. Built-in local/proxy-style providers
+ *   with user-supplied endpoints, plus user-added providers with saved
+ *   endpoints, also return a pre-filled `baseUrl` field.
+ *
+ * Returns the same fallback shape for unknown providers (single `apiKey`
+ * input, no default base URL) so callers can render a reasonable configure
+ * dialog without per-id branches.
+ */
+export function getProviderConfigFields(
+	providerId: string,
+): ProviderConfigFields {
+	const id = LlmsModels.normalizeProviderId(providerId);
+	if (isOAuthProvider(id)) {
+		return { providerId: id, authMethod: "oauth", fields: {} };
+	}
+
+	const collection = LlmsModels.MODEL_COLLECTIONS_BY_PROVIDER_ID[id];
+	if (collection?.provider.capabilities?.includes("local-auth")) {
+		return { providerId: id, authMethod: "local", fields: {} };
+	}
+
+	const defaultBaseUrl = collection?.provider.baseUrl;
+	const fields: ProviderConfigFields["fields"] = {
+		apiKey: {},
+	};
+	if (shouldExposeBaseUrlField(id, collection)) {
+		fields.baseUrl = { defaultValue: defaultBaseUrl };
+	}
+
+	return applyProviderConfigFieldMetadata({
+		providerId: id,
+		authMethod: "api-key",
+		fields,
+	});
+}
diff --git a/sdk/packages/core/src/services/session-artifacts.ts b/sdk/packages/core/src/services/session-artifacts.ts
new file mode 100644
index 0000000..3039243
--- /dev/null
+++ b/sdk/packages/core/src/services/session-artifacts.ts
@@ -0,0 +1,145 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	rmdirSync,
+	rmSync,
+	unlinkSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	parseSubSessionId,
+	parseTeamTaskSubSessionId,
+} from "../session/models/session-graph";
+
+export function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export function unlinkIfExists(path: string | null | undefined): void {
+	if (!path || !existsSync(path)) {
+		return;
+	}
+	try {
+		unlinkSync(path);
+	} catch {
+		// Best effort cleanup.
+	}
+}
+
+export interface SessionArtifactPaths {
+	messagesPath: string;
+}
+
+function childArtifactFileStem(sessionId: string): {
+	rootSessionId: string;
+	fileStem: string;
+} {
+	const teamTask = parseTeamTaskSubSessionId(sessionId);
+	if (teamTask) {
+		return {
+			rootSessionId: teamTask.rootSessionId,
+			fileStem: `${teamTask.agentId}__${teamTask.teamTaskId}`,
+		};
+	}
+
+	const subagent = parseSubSessionId(sessionId);
+	if (subagent) {
+		return {
+			rootSessionId: subagent.rootSessionId,
+			fileStem: subagent.agentId,
+		};
+	}
+
+	return {
+		rootSessionId: sessionId,
+		fileStem: sessionId,
+	};
+}
+
+export class SessionArtifacts {
+	constructor(private readonly ensureSessionsDir: () => string) {}
+
+	public sessionArtifactsDir(sessionId: string): string {
+		return join(this.ensureSessionsDir(), sessionId);
+	}
+
+	public ensureSessionArtifactsDir(sessionId: string): string {
+		const dir = this.sessionArtifactsDir(sessionId);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		return dir;
+	}
+
+	public sessionMessagesPath(sessionId: string): string {
+		return join(
+			this.sessionArtifactsDir(sessionId),
+			`${sessionId}.messages.json`,
+		);
+	}
+
+	public sessionCompactionPath(sessionId: string): string {
+		return join(
+			this.sessionArtifactsDir(sessionId),
+			`${sessionId}.compaction.json`,
+		);
+	}
+
+	public sessionManifestPath(sessionId: string, ensureDir = false): string {
+		const base = ensureDir
+			? this.ensureSessionArtifactsDir(sessionId)
+			: this.sessionArtifactsDir(sessionId);
+		return join(base, `${sessionId}.json`);
+	}
+
+	public removeSessionDirIfEmpty(sessionId: string): void {
+		let dir = this.sessionArtifactsDir(sessionId);
+		const sessionsDir = this.ensureSessionsDir();
+		while (dir.startsWith(sessionsDir) && dir !== sessionsDir) {
+			if (!existsSync(dir)) {
+				dir = dirname(dir);
+				continue;
+			}
+			try {
+				if (readdirSync(dir).length > 0) {
+					break;
+				}
+				rmdirSync(dir);
+			} catch {
+				// Best-effort cleanup.
+				break;
+			}
+			dir = dirname(dir);
+		}
+	}
+
+	public removeSessionDir(sessionId: string): void {
+		this.removeDir(this.sessionArtifactsDir(sessionId));
+	}
+
+	public removeDir(dir: string): void {
+		if (!existsSync(dir)) {
+			return;
+		}
+		try {
+			rmSync(dir, { recursive: true, force: true });
+		} catch {
+			// Best-effort cleanup.
+		}
+	}
+
+	public subagentArtifactPaths(
+		sessionId: string,
+		subAgentId: string,
+		activeTeamTaskSessionId?: string,
+	): SessionArtifactPaths {
+		void subAgentId;
+		void activeTeamTaskSessionId;
+		const { rootSessionId, fileStem } = childArtifactFileStem(sessionId);
+		const dir = this.sessionArtifactsDir(rootSessionId);
+		return {
+			messagesPath: join(dir, `${fileStem}.messages.json`),
+		};
+	}
+}
diff --git a/sdk/packages/core/src/services/session-data.test.ts b/sdk/packages/core/src/services/session-data.test.ts
new file mode 100644
index 0000000..eb91c00
--- /dev/null
+++ b/sdk/packages/core/src/services/session-data.test.ts
@@ -0,0 +1,307 @@
+import type { MessageWithMetadata } from "@cline/llms";
+import type { AgentResult } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { withLatestAssistantTurnMetadata } from "./session-data";
+import { summarizeUsageFromMessages } from "./usage";
+
+type LegacyStoredMessage = MessageWithMetadata & {
+	providerId?: string;
+	modelId?: string;
+};
+
+function createResult(overrides: Partial<AgentResult> = {}): AgentResult {
+	return {
+		text: "ok",
+		iterations: 1,
+		finishReason: "completed",
+		usage: {
+			inputTokens: 3,
+			outputTokens: 2,
+			totalCost: 0.01,
+		},
+		messages: [],
+		toolCalls: [],
+		durationMs: 1,
+		model: {
+			id: "claude-sonnet-4-6",
+			provider: "anthropic",
+			info: {
+				id: "claude-sonnet-4-6",
+				family: "claude-sonnet-4",
+			},
+		},
+		startedAt: new Date("2026-01-01T00:00:00.000Z"),
+		endedAt: new Date("2026-01-01T00:00:01.000Z"),
+		...overrides,
+	};
+}
+
+describe("withLatestAssistantTurnMetadata", () => {
+	it("normalizes legacy stored provider/model fields into modelInfo", () => {
+		const messages = [
+			{ role: "user", content: "hello" },
+			{ role: "assistant", content: "first answer" },
+			{ role: "user", content: "again" },
+			{ role: "assistant", content: "second answer" },
+		] as const;
+
+		const previousMessages: LegacyStoredMessage[] = [
+			{ role: "user", content: "hello" },
+			{
+				role: "assistant",
+				content: "first answer",
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+			},
+			{ role: "user", content: "again" },
+		];
+
+		const persisted = withLatestAssistantTurnMetadata(
+			[...messages],
+			createResult(),
+			previousMessages,
+		);
+
+		expect(persisted[1]).toEqual({
+			id: expect.any(String),
+			role: "assistant",
+			content: "first answer",
+			modelInfo: {
+				id: "claude-sonnet-4-5",
+				provider: "anthropic",
+			},
+		});
+		expect(persisted[3]).toMatchObject({
+			id: expect.any(String),
+			role: "assistant",
+			content: "second answer",
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+				family: "claude-sonnet-4",
+			},
+			metrics: {
+				inputTokens: 3,
+				outputTokens: 2,
+				cost: 0.01,
+			},
+		});
+		expect("providerId" in (persisted[1] ?? {})).toBe(false);
+		expect("modelId" in (persisted[1] ?? {})).toBe(false);
+		expect("providerId" in (persisted[3] ?? {})).toBe(false);
+		expect("modelId" in (persisted[3] ?? {})).toBe(false);
+	});
+
+	it("falls back to result.usage on the terminal assistant message when no per-turn metrics are pre-stamped (legacy / non-agent-loop path)", () => {
+		const persisted = withLatestAssistantTurnMetadata(
+			[
+				{ role: "user", content: "spawn a team" },
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "1", name: "spawn", input: {} }],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "1",
+							name: "spawn",
+							content: "ok",
+						},
+					],
+				},
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "text",
+							text: "Both agents are spawned! Now let me send them tasks.",
+						},
+						{ type: "tool_use", id: "2", name: "run_task", input: {} },
+					],
+				},
+			],
+			createResult({
+				usage: {
+					inputTokens: 10,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 1,
+					totalCost: 0.12,
+				},
+			}),
+			[],
+		);
+
+		expect(persisted[1]).toMatchObject({
+			role: "assistant",
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+				family: "claude-sonnet-4",
+			},
+		});
+		expect(persisted[1]).not.toHaveProperty("metrics");
+		expect(persisted[3]).toMatchObject({
+			role: "assistant",
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+				family: "claude-sonnet-4",
+			},
+			metrics: {
+				inputTokens: 10,
+				outputTokens: 5,
+				cacheReadTokens: 2,
+				cacheWriteTokens: 1,
+				cost: 0.12,
+			},
+		});
+	});
+
+	it("preserves per-turn metrics already stamped on assistant messages instead of overwriting with total run usage", () => {
+		// The agent loop stamps per-turn metrics onto each assistant message
+		// before appending it to the conversation store. This test verifies that
+		// withLatestAssistantTurnMetadata preserves those per-turn values.
+		const persisted = withLatestAssistantTurnMetadata(
+			[
+				{ role: "user", content: "do something" },
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "1", name: "bash", input: {} }],
+					metrics: {
+						inputTokens: 100,
+						outputTokens: 50,
+						cacheReadTokens: 10,
+						cacheWriteTokens: 5,
+						cost: 0.05,
+					},
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "1",
+							name: "bash",
+							content: "done",
+						},
+					],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "All done." }],
+					metrics: {
+						inputTokens: 200,
+						outputTokens: 80,
+						cacheReadTokens: 20,
+						cacheWriteTokens: 8,
+						cost: 0.09,
+					},
+				},
+			] as MessageWithMetadata[],
+			createResult({
+				usage: {
+					inputTokens: 300,
+					outputTokens: 130,
+					cacheReadTokens: 30,
+					cacheWriteTokens: 13,
+					totalCost: 0.14,
+				},
+			}),
+			[],
+		);
+
+		// First assistant message: per-turn metrics preserved, NOT overwritten with totals
+		expect(persisted[1]).toMatchObject({
+			metrics: {
+				inputTokens: 100,
+				outputTokens: 50,
+				cacheReadTokens: 10,
+				cacheWriteTokens: 5,
+				cost: 0.05,
+			},
+		});
+		// Last assistant message: per-turn metrics preserved, NOT overwritten with totals
+		expect(persisted[3]).toMatchObject({
+			metrics: {
+				inputTokens: 200,
+				outputTokens: 80,
+				cacheReadTokens: 20,
+				cacheWriteTokens: 8,
+				cost: 0.09,
+			},
+		});
+	});
+
+	it("does not attach aggregate usage to an empty terminal assistant when per-turn metrics already exist", () => {
+		const persisted = withLatestAssistantTurnMetadata(
+			[
+				{ role: "user", content: "do something" },
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "1", name: "bash", input: {} }],
+					metrics: {
+						inputTokens: 10,
+						outputTokens: 3,
+						cacheReadTokens: 2,
+						cacheWriteTokens: 1,
+						cost: 1,
+					},
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "1",
+							name: "bash",
+							content: "done",
+						},
+					],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: "partial answer" }],
+					metrics: {
+						inputTokens: 20,
+						outputTokens: 7,
+						cacheReadTokens: 4,
+						cacheWriteTokens: 2,
+						cost: 2,
+					},
+				},
+				{ role: "assistant", content: [] },
+			] as MessageWithMetadata[],
+			createResult({
+				usage: {
+					inputTokens: 30,
+					outputTokens: 10,
+					cacheReadTokens: 6,
+					cacheWriteTokens: 3,
+					totalCost: 3,
+				},
+			}),
+			[],
+		);
+
+		expect(persisted[4]).toMatchObject({
+			role: "assistant",
+			content: [],
+			modelInfo: {
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+				family: "claude-sonnet-4",
+			},
+		});
+		expect(persisted[4]).not.toHaveProperty("metrics");
+		expect(summarizeUsageFromMessages(persisted)).toEqual({
+			inputTokens: 30,
+			outputTokens: 10,
+			cacheReadTokens: 6,
+			cacheWriteTokens: 3,
+			totalCost: 3,
+		});
+	});
+});
diff --git a/sdk/packages/core/src/services/session-data.ts b/sdk/packages/core/src/services/session-data.ts
new file mode 100644
index 0000000..bb7e65b
--- /dev/null
+++ b/sdk/packages/core/src/services/session-data.ts
@@ -0,0 +1,409 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentConfig, AgentEvent, AgentResult } from "@cline/shared";
+import { normalizeUserInput, stripModeNotices } from "@cline/shared";
+import { nanoid } from "nanoid";
+import {
+	parseSubSessionId,
+	parseTeamTaskSubSessionId,
+} from "../session/models/session-graph";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "../session/models/session-manifest";
+import type { SessionRow } from "../session/models/session-row";
+import type { SessionSource, SessionStatus } from "../types/common";
+import type { StoredMessageWithMetadata } from "../types/session";
+import type { SessionRecord } from "../types/sessions";
+
+export function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean {
+	if (!hooks) {
+		return false;
+	}
+	return Object.values(hooks).some((value) => typeof value === "function");
+}
+
+export function mergeAgentExtensions(
+	explicitExtensions: AgentConfig["extensions"] | undefined,
+	loadedExtensions: AgentConfig["extensions"] | undefined,
+): AgentConfig["extensions"] {
+	const merged = [...(explicitExtensions ?? []), ...(loadedExtensions ?? [])];
+	if (merged.length === 0) {
+		return undefined;
+	}
+	const deduped: NonNullable<AgentConfig["extensions"]> = [];
+	const seenNames = new Set<string>();
+	for (const extension of merged) {
+		if (seenNames.has(extension.name)) {
+			continue;
+		}
+		seenNames.add(extension.name);
+		deduped.push(extension);
+	}
+	return deduped;
+}
+
+export function serializeAgentEvent(event: AgentEvent): string {
+	return JSON.stringify(event, (_key, value) => {
+		if (value instanceof Error) {
+			return {
+				name: value.name,
+				message: value.message,
+				stack: value.stack,
+			};
+		}
+		return value;
+	});
+}
+
+function trimNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function normalizeStoredMessageModelMetadata(
+	message: StoredMessageWithMetadata,
+	fallback?: {
+		id?: string;
+		provider?: string;
+		family?: string;
+	},
+): StoredMessageWithMetadata {
+	const next = {
+		...(message as StoredMessageWithMetadata & {
+			providerId?: string;
+			modelId?: string;
+		}),
+	};
+	next.id = trimNonEmptyString(next.id) ?? nanoid();
+	const modelInfo =
+		next.modelInfo && typeof next.modelInfo === "object"
+			? { ...next.modelInfo }
+			: undefined;
+	const resolvedModelInfo = {
+		id:
+			trimNonEmptyString(modelInfo?.id) ??
+			trimNonEmptyString(next.modelId) ??
+			trimNonEmptyString(fallback?.id),
+		provider:
+			trimNonEmptyString(modelInfo?.provider) ??
+			trimNonEmptyString(next.providerId) ??
+			trimNonEmptyString(fallback?.provider),
+		family:
+			trimNonEmptyString(modelInfo?.family) ??
+			trimNonEmptyString(fallback?.family),
+	};
+
+	delete next.providerId;
+	delete next.modelId;
+
+	if (resolvedModelInfo.id && resolvedModelInfo.provider) {
+		next.modelInfo = {
+			id: resolvedModelInfo.id,
+			provider: resolvedModelInfo.provider,
+			...(resolvedModelInfo.family ? { family: resolvedModelInfo.family } : {}),
+		};
+	} else {
+		delete next.modelInfo;
+	}
+
+	return next;
+}
+
+export function normalizeStoredMessagesForPersistence(
+	messages: LlmsProviders.MessageWithMetadata[],
+): StoredMessageWithMetadata[] {
+	return messages.map((message) =>
+		normalizeStoredMessageModelMetadata(message as StoredMessageWithMetadata),
+	);
+}
+
+export function withLatestAssistantTurnMetadata(
+	messages: LlmsProviders.Message[],
+	result: AgentResult,
+	previousMessages: LlmsProviders.MessageWithMetadata[] = [],
+): StoredMessageWithMetadata[] {
+	const next = messages.map((message, index) => {
+		const previous = previousMessages[index];
+		const sameMessage =
+			previous?.role === message.role &&
+			JSON.stringify(previous.content) === JSON.stringify(message.content);
+		const merged = sameMessage
+			? ({
+					...previous,
+					...message,
+				} as StoredMessageWithMetadata)
+			: ({ ...message } as StoredMessageWithMetadata);
+		return normalizeStoredMessageModelMetadata(merged);
+	});
+	const firstNewMessageIndex = previousMessages.length;
+	const assistantIndexes: number[] = [];
+	for (let index = firstNewMessageIndex; index < next.length; index += 1) {
+		if (next[index]?.role === "assistant") {
+			assistantIndexes.push(index);
+		}
+	}
+	if (assistantIndexes.length === 0) {
+		const lastAssistantIndex = [...next]
+			.reverse()
+			.findIndex((message) => message.role === "assistant");
+		if (lastAssistantIndex === -1) {
+			return next;
+		}
+		assistantIndexes.push(next.length - 1 - lastAssistantIndex);
+	}
+
+	const lastAssistantIndex = assistantIndexes[assistantIndexes.length - 1];
+	const hasAssistantTurnMetrics = assistantIndexes.some(
+		(index) => next[index]?.metrics,
+	);
+	for (const targetIndex of assistantIndexes) {
+		const target = next[targetIndex];
+		// Use per-turn metrics already stamped on the message if available.
+		// Only fall back to result.usage (total run usage) for the terminal
+		// assistant message when this run has no per-turn metrics, to avoid
+		// attaching session totals to terminal bookkeeping messages.
+		let metrics = target.metrics;
+		if (
+			!metrics &&
+			targetIndex === lastAssistantIndex &&
+			!hasAssistantTurnMetrics
+		) {
+			const usage = result.usage;
+			metrics = {
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				cacheReadTokens: usage.cacheReadTokens ?? 0,
+				cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+				cost: usage.totalCost,
+			};
+		}
+		next[targetIndex] = {
+			...normalizeStoredMessageModelMetadata(target, {
+				id: result.model.id,
+				provider: result.model.provider,
+				family: result.model.info?.family,
+			}),
+			...(metrics ? { metrics } : {}),
+			ts: target.ts ?? result.endedAt.getTime(),
+		};
+	}
+	return next;
+}
+
+export function toSessionRecord(row: SessionRow): SessionRecord {
+	return {
+		sessionId: row.sessionId,
+		source: row.source as SessionSource,
+		pid: row.pid,
+		startedAt: row.startedAt,
+		endedAt: row.endedAt ?? null,
+		exitCode: row.exitCode ?? null,
+		status: row.status,
+		interactive: row.interactive,
+		provider: row.provider,
+		model: row.model,
+		cwd: row.cwd,
+		workspaceRoot: row.workspaceRoot,
+		teamName: row.teamName ?? undefined,
+		enableTools: row.enableTools,
+		enableSpawn: row.enableSpawn,
+		enableTeams: row.enableTeams,
+		parentSessionId: row.parentSessionId ?? undefined,
+		parentAgentId: row.parentAgentId ?? undefined,
+		agentId: row.agentId ?? undefined,
+		conversationId: row.conversationId ?? undefined,
+		isSubagent: row.isSubagent,
+		prompt: row.prompt ?? undefined,
+		metadata: row.metadata ?? undefined,
+		messagesPath: row.messagesPath ?? undefined,
+		updatedAt: row.updatedAt,
+	};
+}
+
+const MAX_TITLE_LENGTH = 120;
+
+export function normalizeTitle(title?: string | null): string | undefined {
+	const trimmed = title?.trim();
+	return trimmed ? trimmed.slice(0, MAX_TITLE_LENGTH) : undefined;
+}
+
+export function deriveTitleFromPrompt(
+	prompt?: string | null,
+): string | undefined {
+	// Titles are display-only, so runtime-generated notice elements are
+	// stripped here rather than inside normalizeUserInput -- that function also
+	// sanitizes model-bound prompts (prepareTurnInput), where the notice must
+	// survive to reach the model.
+	const normalized = stripModeNotices(normalizeUserInput(prompt ?? "")).trim();
+	if (!normalized) return undefined;
+	return normalizeTitle(normalized.split("\n")[0]?.trim());
+}
+
+export function sanitizeMetadata(
+	metadata: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | undefined {
+	if (!metadata) return undefined;
+	const next = { ...metadata };
+	const title = normalizeTitle(
+		typeof next.title === "string" ? next.title : undefined,
+	);
+	if (title) {
+		next.title = title;
+	} else {
+		delete next.title;
+	}
+	return Object.keys(next).length > 0 ? next : undefined;
+}
+
+export function resolveMetadataWithTitle(input: {
+	metadata?: Record<string, unknown> | null;
+	title?: string | null;
+	prompt?: string | null;
+}): Record<string, unknown> | undefined {
+	const base = sanitizeMetadata(input.metadata) ?? {};
+	const title =
+		input.title !== undefined
+			? normalizeTitle(input.title)
+			: deriveTitleFromPrompt(input.prompt);
+	if (title) base.title = title;
+	return Object.keys(base).length > 0 ? base : undefined;
+}
+
+export type MessagesFileContext = {
+	agent: "lead" | "subagent" | "teammate";
+	sessionId: string;
+	taskType?: string;
+};
+
+export function resolveMessagesFileContext(
+	sessionId: string,
+): MessagesFileContext {
+	const teamTaskMatch = parseTeamTaskSubSessionId(sessionId);
+	if (teamTaskMatch) {
+		return {
+			agent: "teammate",
+			sessionId: teamTaskMatch.rootSessionId,
+			taskType: "team",
+		};
+	}
+	const subSessionMatch = parseSubSessionId(sessionId);
+	if (subSessionMatch) {
+		return {
+			agent: "subagent",
+			sessionId: subSessionMatch.rootSessionId,
+			taskType: "subagent_task",
+		};
+	}
+	return {
+		agent: "lead",
+		sessionId,
+	};
+}
+
+export function buildMessagesFilePayload(input: {
+	updatedAt: string;
+	context: MessagesFileContext;
+	messages: LlmsProviders.MessageWithMetadata[];
+	systemPrompt?: string;
+}): {
+	version: 1;
+	updated_at: string;
+	agent: "lead" | "subagent" | "teammate";
+	sessionId: string;
+	taskType?: string;
+	messages: StoredMessageWithMetadata[];
+	system_prompt?: string;
+} {
+	return {
+		version: 1,
+		updated_at: input.updatedAt,
+		agent: input.context.agent,
+		sessionId: input.context.sessionId,
+		...(input.context.taskType ? { taskType: input.context.taskType } : {}),
+		messages: normalizeStoredMessagesForPersistence(input.messages),
+		...(input.systemPrompt ? { system_prompt: input.systemPrompt } : {}),
+	};
+}
+
+export function writeEmptyMessagesFile(
+	path: string,
+	startedAt: string,
+	context: MessagesFileContext,
+): void {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(
+		path,
+		`${JSON.stringify(
+			buildMessagesFilePayload({
+				updatedAt: startedAt,
+				context,
+				messages: [],
+			}),
+			null,
+			2,
+		)}\n`,
+		"utf8",
+	);
+}
+
+export function buildManifestFromRow(
+	row: SessionRow,
+	overrides?: {
+		status?: SessionStatus;
+		endedAt?: string;
+		exitCode?: number;
+		metadata?: Record<string, unknown>;
+	},
+): SessionManifest {
+	return SessionManifestSchema.parse({
+		version: 1,
+		session_id: row.sessionId,
+		source: row.source,
+		pid: row.pid,
+		started_at: row.startedAt,
+		ended_at: overrides?.endedAt ?? row.endedAt ?? undefined,
+		exit_code: overrides?.exitCode ?? row.exitCode ?? undefined,
+		status: (overrides?.status ?? row.status) as SessionStatus,
+		interactive: row.interactive,
+		provider: row.provider,
+		model: row.model,
+		cwd: row.cwd,
+		workspace_root: row.workspaceRoot,
+		team_name: row.teamName ?? undefined,
+		enable_tools: row.enableTools,
+		enable_spawn: row.enableSpawn,
+		enable_teams: row.enableTeams,
+		prompt: row.prompt ?? undefined,
+		metadata: overrides?.metadata ?? row.metadata ?? undefined,
+		messages_path: row.messagesPath ?? undefined,
+	});
+}
+
+export async function withOccRetry<TFetch, TResult>(
+	load: () => Promise<TFetch | undefined>,
+	update: (loaded: TFetch) => Promise<TResult>,
+	maxRetries: number,
+): Promise<TResult | { updated: false }> {
+	let attempt = 0;
+	while (true) {
+		const loaded = await load();
+		if (loaded === undefined) {
+			return { updated: false };
+		}
+		const result = await update(loaded);
+		if (
+			typeof result === "object" &&
+			result !== null &&
+			"updated" in result &&
+			(result as { updated?: boolean }).updated === false
+		) {
+			attempt += 1;
+			if (attempt >= maxRetries) {
+				return result as TResult;
+			}
+			continue;
+		}
+		return result;
+	}
+}
diff --git a/sdk/packages/core/src/services/session-telemetry.ts b/sdk/packages/core/src/services/session-telemetry.ts
new file mode 100644
index 0000000..a444fc9
--- /dev/null
+++ b/sdk/packages/core/src/services/session-telemetry.ts
@@ -0,0 +1,89 @@
+import type { ITelemetryService } from "@cline/shared";
+import { resolveDocumentsExtensionPath } from "@cline/shared/storage";
+import { listHookConfigFiles } from "../hooks/hook-file-config";
+import type { CoreSessionConfig } from "../types/config";
+import {
+	captureHookDiscovery,
+	captureMentionFailed,
+	captureMentionSearchResults,
+	captureMentionUsed,
+	captureTaskCreated,
+	captureTaskRestarted,
+	type TelemetryAgentIdentityProperties,
+} from "./telemetry/core-events";
+import type { enrichPromptWithMentions } from "./workspace";
+
+/**
+ * Emits local-only session creation telemetry (task.created/restarted and
+ * hook discovery). The transport-agnostic `session.started` event is
+ * emitted from `ClineCore.start` so it fires for every backend (local,
+ * hub, remote) at the outer API boundary.
+ */
+export function emitSessionCreationTelemetry(
+	config: CoreSessionConfig,
+	sessionId: string,
+	isRestart: boolean,
+	workspacePath: string,
+	agentIdentity?: Partial<TelemetryAgentIdentityProperties>,
+): void {
+	if (isRestart) {
+		captureTaskRestarted(config.telemetry, {
+			ulid: sessionId,
+			apiProvider: config.providerId,
+			...agentIdentity,
+		});
+	} else {
+		captureTaskCreated(config.telemetry, {
+			ulid: sessionId,
+			apiProvider: config.providerId,
+			...agentIdentity,
+		});
+	}
+	captureHookDiscoveryTelemetry(config.telemetry, { workspacePath });
+}
+
+export function captureHookDiscoveryTelemetry(
+	telemetry: ITelemetryService | undefined,
+	options: { workspacePath: string },
+): void {
+	const globalHooksDir = resolveDocumentsExtensionPath("Hooks");
+	const entries = listHookConfigFiles(options.workspacePath);
+	const counts = new Map<string, { global: number; workspace: number }>();
+	for (const entry of entries) {
+		const hookName = entry.hookEventName ?? "unknown";
+		const current = counts.get(hookName) ?? { global: 0, workspace: 0 };
+		if (
+			entry.path === globalHooksDir ||
+			entry.path.startsWith(`${globalHooksDir}/`)
+		) {
+			current.global += 1;
+		} else {
+			current.workspace += 1;
+		}
+		counts.set(hookName, current);
+	}
+	for (const [hookName, count] of counts.entries()) {
+		captureHookDiscovery(telemetry, hookName, count.global, count.workspace);
+	}
+}
+
+export function emitMentionTelemetry(
+	telemetry: ITelemetryService | undefined,
+	enriched: Awaited<ReturnType<typeof enrichPromptWithMentions>>,
+): void {
+	for (const mention of enriched.mentions) {
+		captureMentionSearchResults(
+			telemetry,
+			mention,
+			enriched.matchedFiles.includes(mention) ? 1 : 0,
+			"file",
+			!enriched.matchedFiles.includes(mention),
+		);
+	}
+	for (const matched of enriched.matchedFiles) {
+		captureMentionUsed(telemetry, "file", matched.length);
+	}
+	for (const ignored of enriched.ignoredMentions) {
+		captureMentionFailed(telemetry, "file", "not_found", ignored);
+	}
+}
diff --git a/sdk/packages/core/src/services/storage/artifact-store.ts b/sdk/packages/core/src/services/storage/artifact-store.ts
new file mode 100644
index 0000000..ae4b753
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/artifact-store.ts
@@ -0,0 +1 @@
+export type { ArtifactStore } from "../../types/storage";
diff --git a/sdk/packages/core/src/services/storage/file-team-store.ts b/sdk/packages/core/src/services/storage/file-team-store.ts
new file mode 100644
index 0000000..3a70778
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/file-team-store.ts
@@ -0,0 +1,250 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cline/shared";
+import { resolveTeamDataDir } from "@cline/shared/storage";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function sanitizeTeamName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+function reviveTeamRuntimeStateDates(
+	state: TeamRuntimeState,
+): TeamRuntimeState {
+	return {
+		...state,
+		tasks: state.tasks.map((task) => ({
+			...task,
+			createdAt: new Date(task.createdAt),
+			updatedAt: new Date(task.updatedAt),
+		})),
+		mailbox: state.mailbox.map((message) => ({
+			...message,
+			sentAt: new Date(message.sentAt),
+			readAt: message.readAt ? new Date(message.readAt) : undefined,
+		})),
+		missionLog: state.missionLog.map((entry) => ({
+			...entry,
+			ts: new Date(entry.ts),
+		})),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			startedAt: new Date(run.startedAt),
+			endedAt: run.endedAt ? new Date(run.endedAt) : undefined,
+			nextAttemptAt: run.nextAttemptAt
+				? new Date(run.nextAttemptAt)
+				: undefined,
+			heartbeatAt: run.heartbeatAt ? new Date(run.heartbeatAt) : undefined,
+		})),
+		outcomes: (state.outcomes ?? []).map((outcome) => ({
+			...outcome,
+			createdAt: new Date(outcome.createdAt),
+			finalizedAt: outcome.finalizedAt
+				? new Date(outcome.finalizedAt)
+				: undefined,
+		})),
+		outcomeFragments: (state.outcomeFragments ?? []).map((fragment) => ({
+			...fragment,
+			createdAt: new Date(fragment.createdAt),
+			reviewedAt: fragment.reviewedAt
+				? new Date(fragment.reviewedAt)
+				: undefined,
+		})),
+	};
+}
+
+interface PersistedTeamEnvelope {
+	version: 1;
+	updatedAt: string;
+	teamState: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+}
+
+export interface FileTeamStoreOptions {
+	teamDir?: string;
+}
+
+export interface TeamRuntimeLoadResult {
+	state?: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+	interruptedRunIds: string[];
+}
+
+export class FileTeamStore implements TeamStore {
+	private readonly teamDirPath: string;
+
+	constructor(options: FileTeamStoreOptions = {}) {
+		this.teamDirPath = options.teamDir ?? resolveTeamDataDir();
+	}
+
+	init(): void {
+		this.ensureTeamDir();
+	}
+
+	listTeamNames(): string[] {
+		if (!existsSync(this.teamDirPath)) {
+			return [];
+		}
+		return readdirSync(this.teamDirPath, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.filter((entry) => existsSync(this.statePath(entry.name)))
+			.map((entry) => entry.name)
+			.sort();
+	}
+
+	readState(teamName: string): TeamRuntimeState | undefined {
+		const envelope = this.readEnvelope(teamName);
+		return envelope?.teamState
+			? reviveTeamRuntimeStateDates(envelope.teamState)
+			: undefined;
+	}
+
+	readHistory(teamName: string, limit = 200): unknown[] {
+		const historyPath = this.historyPath(teamName);
+		if (!existsSync(historyPath)) {
+			return [];
+		}
+		return readFileSync(historyPath, "utf8")
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean)
+			.map((line) => {
+				try {
+					return JSON.parse(line) as unknown;
+				} catch {
+					return undefined;
+				}
+			})
+			.filter((item): item is unknown => item !== undefined)
+			.reverse()
+			.slice(0, limit);
+	}
+
+	loadRuntime(teamName: string): TeamRuntimeLoadResult {
+		const envelope = this.readEnvelope(teamName);
+		return {
+			state: envelope?.teamState
+				? reviveTeamRuntimeStateDates(envelope.teamState)
+				: undefined,
+			teammates: envelope?.teammates ?? [],
+			interruptedRunIds: [],
+		};
+	}
+
+	handleTeamEvent(teamName: string, event: TeamEvent): void {
+		this.ensureTeamSubdir(teamName);
+		appendFileSync(
+			this.historyPath(teamName),
+			`${JSON.stringify({ ts: nowIso(), eventType: event.type, payload: event })}\n`,
+			"utf8",
+		);
+	}
+
+	persistRuntime(
+		teamName: string,
+		state: TeamRuntimeState,
+		teammates: TeamTeammateSpec[],
+	): void {
+		this.ensureTeamSubdir(teamName);
+		const envelope: PersistedTeamEnvelope = {
+			version: 1,
+			updatedAt: nowIso(),
+			teamState: state,
+			teammates,
+		};
+		const path = this.statePath(teamName);
+		const tempPath = `${path}.tmp`;
+		writeFileSync(tempPath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
+		renameSync(tempPath, path);
+	}
+
+	markInProgressRunsInterrupted(teamName: string, reason: string): string[] {
+		const envelope = this.readEnvelope(teamName);
+		if (!envelope?.teamState?.runs?.length) {
+			return [];
+		}
+		const interrupted = envelope.teamState.runs
+			.filter((run) => run.status === "queued" || run.status === "running")
+			.map((run) => run.id);
+		if (interrupted.length === 0) {
+			return [];
+		}
+		const endedAt = new Date();
+		envelope.teamState = {
+			...envelope.teamState,
+			runs: envelope.teamState.runs.map((run) =>
+				run.status === "queued" || run.status === "running"
+					? {
+							...run,
+							status: "interrupted",
+							error: reason,
+							endedAt,
+						}
+					: run,
+			),
+		};
+		this.persistRuntime(teamName, envelope.teamState, envelope.teammates);
+		return interrupted;
+	}
+
+	private ensureTeamDir(): string {
+		if (!existsSync(this.teamDirPath)) {
+			mkdirSync(this.teamDirPath, { recursive: true });
+		}
+		return this.teamDirPath;
+	}
+
+	private ensureTeamSubdir(teamName: string): string {
+		const path = join(this.ensureTeamDir(), sanitizeTeamName(teamName));
+		if (!existsSync(path)) {
+			mkdirSync(path, { recursive: true });
+		}
+		return path;
+	}
+
+	private statePath(teamName: string): string {
+		return join(this.ensureTeamDir(), sanitizeTeamName(teamName), "state.json");
+	}
+
+	private historyPath(teamName: string): string {
+		return join(
+			this.ensureTeamDir(),
+			sanitizeTeamName(teamName),
+			"task-history.jsonl",
+		);
+	}
+
+	private readEnvelope(teamName: string): PersistedTeamEnvelope | undefined {
+		const path = this.statePath(teamName);
+		if (!existsSync(path)) {
+			return undefined;
+		}
+		try {
+			const parsed = JSON.parse(
+				readFileSync(path, "utf8"),
+			) as PersistedTeamEnvelope;
+			if (parsed?.version === 1 && parsed.teamState) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to undefined.
+		}
+		return undefined;
+	}
+}
diff --git a/sdk/packages/core/src/services/storage/index.ts b/sdk/packages/core/src/services/storage/index.ts
new file mode 100644
index 0000000..9e2db88
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/index.ts
@@ -0,0 +1,11 @@
+export type { ArtifactStore } from "./artifact-store";
+export {
+	type MigrateLegacyProviderSettingsOptions,
+	type MigrateLegacyProviderSettingsResult,
+	migrateLegacyProviderSettings,
+} from "./provider-settings-legacy-migration";
+export { ProviderSettingsManager } from "./provider-settings-manager";
+export type { SessionStore } from "./session-store";
+export { SqliteSessionStore } from "./sqlite-session-store";
+export type { TeamStore } from "./team-store";
+export { SqliteTeamStore, type SqliteTeamStoreOptions } from "./team-store";
diff --git a/sdk/packages/core/src/services/storage/provider-settings-legacy-migration.test.ts b/sdk/packages/core/src/services/storage/provider-settings-legacy-migration.test.ts
new file mode 100644
index 0000000..381a059
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/provider-settings-legacy-migration.test.ts
@@ -0,0 +1,787 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as LlmsModels from "@cline/llms";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	type LegacyClineUserInfo,
+	migrateLegacyProviderSettings,
+	resolveLegacyClineAuth,
+} from "./provider-settings-legacy-migration";
+import { ProviderSettingsManager } from "./provider-settings-manager";
+
+describe("migrateLegacyProviderSettings", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("migrates legacy provider state into providers.json when target is empty", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+					actModeApiModelId: "claude-sonnet-4-6",
+					anthropicBaseUrl: "https://example.invalid/anthropic",
+					actModeReasoningEffort: "high",
+					actModeThinkingBudgetTokens: 2048,
+					requestTimeoutMs: 90000,
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ apiKey: "legacy-anthropic-key" }, null, 2),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			providerCount: 1,
+			lastUsedProvider: "anthropic",
+		});
+		expect(manager.getProviderSettings("anthropic")).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "legacy-anthropic-key",
+			baseUrl: "https://example.invalid/anthropic",
+			timeout: 90000,
+			reasoning: {
+				effort: "high",
+				budgetTokens: 2048,
+			},
+		});
+		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
+	});
+
+	it("migrates legacy OCA-specific reasoning effort into provider settings", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "plan",
+					planModeApiProvider: "oca",
+					actModeReasoningEffort: "low",
+					planModeOcaReasoningEffort: "high",
+					actModeOcaReasoningEffort: "medium",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ ocaApiKey: "legacy-oca-key" }, null, 2),
+		);
+
+		migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(manager.getProviderSettings("oca")?.reasoning).toEqual({
+			effort: "medium",
+		});
+	});
+
+	it("migrates missing providers without overwriting existing providers", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		manager.saveProviderSettings({
+			provider: "openai",
+			model: "gpt-5",
+			apiKey: "already-migrated",
+		});
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ apiKey: "legacy-key" }, null, 2),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result.migrated).toBe(true);
+		expect(manager.getProviderSettings("openai")?.apiKey).toBe(
+			"already-migrated",
+		);
+		const anthropicDefault =
+			LlmsModels.getProviderCollectionSync("anthropic")?.provider
+				.defaultModelId;
+		expect(anthropicDefault).toBeDefined();
+		expect(manager.getProviderSettings("anthropic")).toEqual({
+			provider: "anthropic",
+			model: anthropicDefault,
+			apiKey: "legacy-key",
+		});
+		expect(manager.read().providers.openai?.tokenSource).toBe("manual");
+		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
+	});
+
+	it("migrates legacy OpenAI Codex OAuth credentials", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "openai-codex",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify(
+				{
+					"openai-codex-oauth-credentials": JSON.stringify({
+						type: "openai-codex",
+						access_token: "legacy-access",
+						refresh_token: "legacy-refresh",
+						expires: Date.now() + 60_000,
+						accountId: "acct_123",
+					}),
+				},
+				null,
+				2,
+			),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			lastUsedProvider: "openai-codex",
+		});
+		expect(manager.getProviderSettings("openai-codex")).toEqual({
+			provider: "openai-codex",
+			apiKey: "legacy-access",
+			auth: {
+				accessToken: "legacy-access",
+				refreshToken: "legacy-refresh",
+				accountId: "acct_123",
+			},
+		});
+		expect(manager.read().providers["openai-codex"]?.tokenSource).toBe(
+			"migration",
+		);
+	});
+
+	it("migrates legacy Cline OAuth account auth even without a clineApiKey", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify(
+				{
+					"cline:clineAccountId": makeClineAccountJson({
+						idToken: "legacy-cline-access",
+						refreshToken: "legacy-cline-refresh",
+						expiresAt: 1_750_000_000,
+						userId: "user-123",
+					}),
+				},
+				null,
+				2,
+			),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result.migrated).toBe(true);
+		expect(manager.getProviderSettings("cline")?.auth).toEqual({
+			accessToken: "legacy-cline-access",
+			refreshToken: "legacy-cline-refresh",
+			expiresAt: 1_750_000_000_000,
+			accountId: "user-123",
+		});
+		expect(manager.read().providers.cline?.tokenSource).toBe("migration");
+	});
+
+	it("migrates legacy OpenAI-compatible config into the openai-compatible provider", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "openai",
+					actModeOpenAiModelId: "gpt-oss-120b",
+					openAiBaseUrl: "https://gateway.example.invalid/v1",
+					openAiHeaders: {
+						"X-Test": "legacy-header",
+					},
+					requestTimeoutMs: 45000,
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ openAiApiKey: "legacy-openai-compatible-key" }, null, 2),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			providerCount: 1,
+			lastUsedProvider: "openai-compatible",
+		});
+		expect(manager.getProviderSettings("openai-compatible")).toEqual({
+			provider: "openai-compatible",
+			model: "gpt-oss-120b",
+			apiKey: "legacy-openai-compatible-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+			headers: {
+				"X-Test": "legacy-header",
+			},
+			timeout: 45000,
+		});
+
+		const modelsPath = path.join(tempDir, "settings", "models.json");
+		expect(JSON.parse(readFileSync(modelsPath, "utf8"))).toEqual({
+			version: 1,
+			providers: {
+				"openai-compatible": {
+					provider: {
+						name: "OpenAI Compatible",
+						baseUrl: "https://gateway.example.invalid/v1",
+						defaultModelId: "gpt-oss-120b",
+					},
+					models: {
+						"gpt-oss-120b": {
+							id: "gpt-oss-120b",
+							name: "gpt-oss-120b",
+							contextWindow: 128000,
+							maxInputTokens: 128000,
+							capabilities: ["streaming", "tools", "images"],
+						},
+					},
+				},
+			},
+		});
+	});
+
+	it("keeps official OpenAI endpoints under the built-in openai-compatible provider", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "openai",
+					actModeOpenAiModelId: "gpt-5",
+					openAiBaseUrl: "https://api.openai.com/v1",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ openAiApiKey: "legacy-openai-key" }, null, 2),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			providerCount: 1,
+			lastUsedProvider: "openai-compatible",
+		});
+		expect(manager.getProviderSettings("openai-compatible")).toEqual({
+			provider: "openai-compatible",
+			model: "gpt-5",
+			apiKey: "legacy-openai-key",
+			baseUrl: "https://api.openai.com/v1",
+		});
+		expect(manager.getProviderSettings("openai")).toBeUndefined();
+	});
+
+	it("migrates Bedrock profile auth profile names without requiring legacy awsUseProfile", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "bedrock",
+					actModeApiModelId: "global.anthropic.claude-opus-4-6-v1",
+					awsRegion: "us-east-1",
+					awsAuthentication: "profile",
+					awsProfile: "bedrock",
+					awsBedrockUsePromptCache: true,
+					awsUseCrossRegionInference: true,
+					awsUseGlobalInference: false,
+					actModeAwsBedrockCustomModelBaseId:
+						"anthropic.claude-sonnet-4-5-20250929-v1:0",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(path.join(tempDir, "secrets.json"), JSON.stringify({}));
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			providerCount: 1,
+			lastUsedProvider: "bedrock",
+		});
+		expect(manager.getProviderSettings("bedrock")).toEqual({
+			provider: "bedrock",
+			model: "global.anthropic.claude-opus-4-6-v1",
+			aws: {
+				region: "us-east-1",
+				authentication: "profile",
+				profile: "bedrock",
+				usePromptCache: true,
+				useCrossRegionInference: true,
+				useGlobalInference: false,
+				customModelBaseId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+			},
+		});
+		expect(manager.read().providers.bedrock?.tokenSource).toBe("migration");
+	});
+
+	it("normalizes legacy Bedrock credentials auth to SDK iam auth", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "bedrock",
+					actModeApiModelId: "anthropic.claude-haiku-4-5-20251001-v1:0",
+					awsRegion: "us-east-1",
+					awsAuthentication: "credentials",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ awsAccessKey: "access", awsSecretKey: "secret" }),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({ migrated: true, providerCount: 1 });
+		expect(manager.getProviderSettings("bedrock")?.aws).toMatchObject({
+			authentication: "iam",
+			accessKey: "access",
+			secretKey: "secret",
+			region: "us-east-1",
+		});
+	});
+
+	it("migrates legacy SAP AI Core credentials into SAP provider settings", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "sapaicore",
+					actModeApiModelId: "anthropic--claude-4.6-sonnet",
+					sapAiCoreBaseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+					sapAiCoreTokenUrl:
+						"https://example.authentication.sap.hana.ondemand.com",
+					sapAiResourceGroup: "default",
+					sapAiCoreUseOrchestrationMode: true,
+					actModeSapAiCoreDeploymentId: "deployment-id",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify(
+				{
+					sapAiCoreClientId: "sap-client",
+					sapAiCoreClientSecret: "sap-secret",
+				},
+				null,
+				2,
+			),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			providerCount: 1,
+			lastUsedProvider: "sapaicore",
+		});
+		expect(manager.getProviderSettings("sapaicore")).toEqual({
+			provider: "sapaicore",
+			model: "anthropic--claude-4.6-sonnet",
+			baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			sap: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://example.authentication.sap.hana.ondemand.com",
+				resourceGroup: "default",
+				useOrchestrationMode: true,
+			},
+		});
+		expect(manager.read().providers.sapaicore?.tokenSource).toBe("migration");
+	});
+
+	it("keeps SAP AI Core deployment id only for foundation-model mode", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "sapaicore",
+					actModeApiModelId: "gpt-4o",
+					sapAiCoreBaseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+					sapAiCoreTokenUrl:
+						"https://example.authentication.sap.hana.ondemand.com",
+					sapAiResourceGroup: "default",
+					sapAiCoreUseOrchestrationMode: false,
+					actModeSapAiCoreDeploymentId: "deployment-id",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify(
+				{
+					sapAiCoreClientId: "sap-client",
+					sapAiCoreClientSecret: "sap-secret",
+				},
+				null,
+				2,
+			),
+		);
+
+		migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(manager.getProviderSettings("sapaicore")?.sap).toMatchObject({
+			deploymentId: "deployment-id",
+			useOrchestrationMode: false,
+		});
+	});
+
+	it("detects SAP AI Core legacy files even when provider mode is absent", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					sapAiCoreBaseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+					sapAiCoreTokenUrl:
+						"https://example.authentication.sap.hana.ondemand.com",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify(
+				{
+					sapAiCoreClientId: "sap-client",
+					sapAiCoreClientSecret: "sap-secret",
+				},
+				null,
+				2,
+			),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			lastUsedProvider: "sapaicore",
+		});
+		expect(manager.getProviderSettings("sapaicore")).toMatchObject({
+			provider: "sapaicore",
+			baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			sap: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://example.authentication.sap.hana.ondemand.com",
+			},
+		});
+	});
+});
+
+// =============================================================================
+// resolveLegacyClineAuth – pure in-memory tests
+// =============================================================================
+
+/** Builds a realistic LegacyClineUserInfo JSON string. */
+function makeClineAccountJson(
+	overrides: Partial<LegacyClineUserInfo> & { userId?: string } = {},
+): string {
+	return JSON.stringify({
+		idToken: overrides.idToken ?? "id-token-abc",
+		expiresAt: overrides.expiresAt ?? 1750000000000,
+		refreshToken: overrides.refreshToken ?? "refresh-token-xyz",
+		userInfo: overrides.userInfo ?? {
+			id: overrides.userId ?? "user-42",
+			email: "test@example.com",
+			displayName: "Test User",
+			termsAcceptedAt: "2025-01-01T00:00:00Z",
+			clineBenchConsent: false,
+			createdAt: "2025-01-01T00:00:00Z",
+			updatedAt: "2025-01-01T00:00:00Z",
+		},
+		provider: overrides.provider ?? "google",
+		startedAt: overrides.startedAt ?? Date.now(),
+	} satisfies LegacyClineUserInfo);
+}
+
+describe("resolveLegacyClineAuth", () => {
+	it("extracts all auth fields from a complete legacy account JSON", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({
+				idToken: "my-id-token",
+				expiresAt: 1750000000000,
+				refreshToken: "my-refresh",
+				userId: "user-123",
+			}),
+		);
+
+		expect(result).toEqual({
+			accessToken: "my-id-token",
+			refreshToken: "my-refresh",
+			expiresAt: 1750000000000,
+			accountId: "user-123",
+		});
+	});
+
+	it("maps idToken to accessToken", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ idToken: "tok-abc" }),
+		);
+		expect(result?.accessToken).toBe("tok-abc");
+	});
+
+	it("preserves millisecond expiresAt values", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ expiresAt: 9999999999999 }),
+		);
+		expect(result?.expiresAt).toBe(9999999999999);
+		expect(typeof result?.expiresAt).toBe("number");
+	});
+
+	it("normalizes classic second-based expiresAt values to milliseconds", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ expiresAt: 1_750_000_000 }),
+		);
+		expect(result?.expiresAt).toBe(1_750_000_000_000);
+	});
+
+	it("maps userInfo.id to accountId", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ userId: "uid-xyz" }),
+		);
+		expect(result?.accountId).toBe("uid-xyz");
+	});
+
+	it("returns undefined accountId when userInfo is missing entirely", () => {
+		const raw = JSON.stringify({
+			idToken: "tok",
+			expiresAt: 1000,
+			refreshToken: "ref",
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accessToken).toBe("tok");
+		expect(result?.accountId).toBeUndefined();
+	});
+
+	it("returns undefined accountId when userInfo.id is missing", () => {
+		const raw = JSON.stringify({
+			idToken: "tok",
+			expiresAt: 1000,
+			refreshToken: "ref",
+			userInfo: {
+				email: "x@y.com",
+				displayName: "X",
+				termsAcceptedAt: "2025-01-01T00:00:00Z",
+				clineBenchConsent: false,
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:00:00Z",
+			},
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accountId).toBeUndefined();
+	});
+
+	it("returns undefined for invalid json", () => {
+		expect(resolveLegacyClineAuth(undefined)).toBeUndefined();
+		expect(resolveLegacyClineAuth("")).toBeUndefined();
+		expect(resolveLegacyClineAuth("   \n\t  ")).toBeUndefined();
+		expect(resolveLegacyClineAuth("not-json{{{")).toBeUndefined();
+		expect(resolveLegacyClineAuth("null")).toBeUndefined();
+	});
+
+	it("returns undefined fields when idToken/refreshToken are missing from JSON", () => {
+		const raw = JSON.stringify({
+			userInfo: { id: "uid" },
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accessToken).toBeUndefined();
+		expect(result?.refreshToken).toBeUndefined();
+		expect(result?.expiresAt).toBeUndefined();
+		expect(result?.accountId).toBe("uid");
+	});
+});
diff --git a/sdk/packages/core/src/services/storage/provider-settings-legacy-migration.ts b/sdk/packages/core/src/services/storage/provider-settings-legacy-migration.ts
new file mode 100644
index 0000000..9e89083
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/provider-settings-legacy-migration.ts
@@ -0,0 +1,824 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import * as LlmsModels from "@cline/llms";
+import { resolveClineDataDir } from "@cline/shared/storage";
+import {
+	emptyStoredProviderSettings,
+	type ProviderSettings,
+	ProviderSettingsSchemaTyped as ProviderSettingsSchema,
+} from "../../types/provider-settings";
+import {
+	readModelsFileSync,
+	type StoredModelsFile,
+	writeModelsFileSync,
+} from "../providers/local-provider-registry";
+import type { ProviderSettingsManager } from "./provider-settings-manager";
+
+type LegacyMode = "plan" | "act";
+
+interface LegacyGlobalState {
+	mode?: LegacyMode;
+	planModeApiProvider?: string;
+	actModeApiProvider?: string;
+	planModeApiModelId?: string;
+	actModeApiModelId?: string;
+	planModeReasoningEffort?: string;
+	actModeReasoningEffort?: string;
+	planModeOcaReasoningEffort?: string;
+	actModeOcaReasoningEffort?: string;
+	planModeThinkingBudgetTokens?: number;
+	actModeThinkingBudgetTokens?: number;
+	geminiPlanModeThinkingLevel?: string;
+	geminiActModeThinkingLevel?: string;
+	anthropicBaseUrl?: string;
+	openAiBaseUrl?: string;
+	ollamaBaseUrl?: string;
+	lmStudioBaseUrl?: string;
+	liteLlmBaseUrl?: string;
+	geminiBaseUrl?: string;
+	requestyBaseUrl?: string;
+	asksageApiUrl?: string;
+	difyBaseUrl?: string;
+	ocaBaseUrl?: string;
+	aihubmixBaseUrl?: string;
+	openAiHeaders?: Record<string, string>;
+	requestTimeoutMs?: number;
+	awsRegion?: string;
+	awsAuthentication?: "credentials" | "iam" | "api-key" | "apikey" | "profile";
+	awsUseProfile?: boolean;
+	awsProfile?: string;
+	awsUseCrossRegionInference?: boolean;
+	awsUseGlobalInference?: boolean;
+	awsBedrockUsePromptCache?: boolean;
+	awsBedrockEndpoint?: string;
+	planModeAwsBedrockCustomModelBaseId?: string;
+	actModeAwsBedrockCustomModelBaseId?: string;
+	vertexProjectId?: string;
+	vertexRegion?: string;
+	azureApiVersion?: string;
+	azureIdentity?: boolean;
+	sapAiCoreTokenUrl?: string;
+	sapAiCoreBaseUrl?: string;
+	sapAiResourceGroup?: string;
+	sapAiCoreUseOrchestrationMode?: boolean;
+	ocaMode?: "internal" | "external";
+	qwenApiLine?: "china" | "international";
+	moonshotApiLine?: "china" | "international";
+	zaiApiLine?: "china" | "international";
+	minimaxApiLine?: "china" | "international";
+	planModeOpenRouterModelId?: string;
+	actModeOpenRouterModelId?: string;
+	planModeClineModelId?: string;
+	actModeClineModelId?: string;
+	planModeOpenAiModelId?: string;
+	actModeOpenAiModelId?: string;
+	planModeOllamaModelId?: string;
+	actModeOllamaModelId?: string;
+	planModeLmStudioModelId?: string;
+	actModeLmStudioModelId?: string;
+	planModeLiteLlmModelId?: string;
+	actModeLiteLlmModelId?: string;
+	planModeRequestyModelId?: string;
+	actModeRequestyModelId?: string;
+	planModeTogetherModelId?: string;
+	actModeTogetherModelId?: string;
+	planModeFireworksModelId?: string;
+	actModeFireworksModelId?: string;
+	planModeSapAiCoreModelId?: string;
+	actModeSapAiCoreModelId?: string;
+	planModeSapAiCoreDeploymentId?: string;
+	actModeSapAiCoreDeploymentId?: string;
+	planModeGroqModelId?: string;
+	actModeGroqModelId?: string;
+	planModeBasetenModelId?: string;
+	actModeBasetenModelId?: string;
+	planModeHuggingFaceModelId?: string;
+	actModeHuggingFaceModelId?: string;
+	planModeHuaweiCloudMaasModelId?: string;
+	actModeHuaweiCloudMaasModelId?: string;
+	planModeOcaModelId?: string;
+	actModeOcaModelId?: string;
+	planModeAihubmixModelId?: string;
+	actModeAihubmixModelId?: string;
+	planModeHicapModelId?: string;
+	actModeHicapModelId?: string;
+	planModeNousResearchModelId?: string;
+	actModeNousResearchModelId?: string;
+	planModeVercelAiGatewayModelId?: string;
+	actModeVercelAiGatewayModelId?: string;
+}
+
+interface LegacySecrets {
+	apiKey?: string;
+	clineApiKey?: string;
+	"cline:clineAccountId"?: string;
+	clineAccountId?: string;
+	openRouterApiKey?: string;
+	awsAccessKey?: string;
+	awsSecretKey?: string;
+	awsSessionToken?: string;
+	awsBedrockApiKey?: string;
+	openAiApiKey?: string;
+	geminiApiKey?: string;
+	openAiNativeApiKey?: string;
+	ollamaApiKey?: string;
+	deepSeekApiKey?: string;
+	requestyApiKey?: string;
+	togetherApiKey?: string;
+	fireworksApiKey?: string;
+	qwenApiKey?: string;
+	doubaoApiKey?: string;
+	mistralApiKey?: string;
+	liteLlmApiKey?: string;
+	asksageApiKey?: string;
+	xaiApiKey?: string;
+	moonshotApiKey?: string;
+	zaiApiKey?: string;
+	huggingFaceApiKey?: string;
+	nebiusApiKey?: string;
+	sambanovaApiKey?: string;
+	cerebrasApiKey?: string;
+	sapAiCoreClientId?: string;
+	sapAiCoreClientSecret?: string;
+	groqApiKey?: string;
+	huaweiCloudMaasApiKey?: string;
+	basetenApiKey?: string;
+	vercelAiGatewayApiKey?: string;
+	difyApiKey?: string;
+	minimaxApiKey?: string;
+	hicapApiKey?: string;
+	aihubmixApiKey?: string;
+	nousResearchApiKey?: string;
+	ocaApiKey?: string;
+	ocaRefreshToken?: string;
+	"openai-codex-oauth-credentials"?: string;
+}
+
+interface LegacyProviderStorage {
+	globalState: LegacyGlobalState;
+	secrets: LegacySecrets;
+}
+
+const LEGACY_OPENAI_COMPATIBLE_PROVIDER_ID = "openai";
+const OPENAI_COMPATIBLE_PROVIDER_ID =
+	LlmsModels.BUILT_IN_PROVIDER.OPENAI_COMPATIBLE;
+const LEGACY_OPENAI_COMPATIBLE_CONTEXT_WINDOW = 128_000;
+
+export interface MigrateLegacyProviderSettingsOptions {
+	providerSettingsManager: ProviderSettingsManager;
+	dataDir?: string;
+	globalStatePath?: string;
+	secretsPath?: string;
+}
+
+export interface MigrateLegacyProviderSettingsResult {
+	migrated: boolean;
+	providerCount: number;
+	lastUsedProvider?: string;
+}
+
+export type LegacyClineUserInfo = {
+	idToken: string;
+	expiresAt: number;
+	refreshToken: string;
+	userInfo: {
+		id: string;
+		email: string;
+		displayName: string;
+		termsAcceptedAt: string;
+		clineBenchConsent: boolean;
+		createdAt: string;
+		updatedAt: string;
+	};
+	provider: string;
+	startedAt: number;
+};
+
+/**
+ * Resolves legacy Cline account auth data from the raw `cline:clineAccountId`
+ * secret string into the auth fields used by `ProviderSettings`.
+ *
+ * Returns `undefined` when the input is missing, empty, whitespace-only, or
+ * unparseable JSON.
+ */
+export function resolveLegacyClineAuth(
+	rawAccountData: string | undefined,
+): ProviderSettings["auth"] | undefined {
+	const trimmed = rawAccountData?.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	try {
+		const data = JSON.parse(trimmed) as LegacyClineUserInfo;
+		if (!data) {
+			return undefined;
+		}
+		const expiresAt =
+			typeof data.expiresAt === "number" && Number.isFinite(data.expiresAt)
+				? // Classic VS Code auth stored expiresAt in seconds; providers.json uses
+					// milliseconds. Preserve millisecond-looking values for compatibility
+					// with tests/older migration attempts.
+					data.expiresAt < 10_000_000_000
+					? data.expiresAt * 1000
+					: data.expiresAt
+				: undefined;
+		return {
+			accessToken: data.idToken,
+			refreshToken: data.refreshToken,
+			expiresAt,
+			accountId: data.userInfo?.id,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function trimNonEmpty(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function normalizeLegacyBedrockAuthentication(
+	authentication: LegacyGlobalState["awsAuthentication"],
+): "iam" | "api-key" | "apikey" | "profile" | undefined {
+	return authentication === "credentials" ? "iam" : authentication;
+}
+
+function readJsonObject<T extends object>(filePath: string): T | undefined {
+	if (!existsSync(filePath)) {
+		return undefined;
+	}
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		const parsed = JSON.parse(raw) as unknown;
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as T;
+		}
+	} catch {
+		// Invalid legacy file should not block startup.
+	}
+	return undefined;
+}
+
+function resolveLegacyStorage(
+	options: MigrateLegacyProviderSettingsOptions,
+): LegacyProviderStorage | undefined {
+	const dataDir = options.dataDir ?? resolveClineDataDir();
+	const globalStatePath =
+		options.globalStatePath ?? join(dataDir, "globalState.json");
+	const secretsPath = options.secretsPath ?? join(dataDir, "secrets.json");
+	const globalState = readJsonObject<LegacyGlobalState>(globalStatePath);
+	const secrets = readJsonObject<LegacySecrets>(secretsPath);
+	if (!globalState && !secrets) {
+		return undefined;
+	}
+	return {
+		globalState: globalState ?? {},
+		secrets: secrets ?? {},
+	};
+}
+
+function resolveMigratedProviderId(providerId: string): string {
+	if (providerId === LEGACY_OPENAI_COMPATIBLE_PROVIDER_ID) {
+		return OPENAI_COMPATIBLE_PROVIDER_ID;
+	}
+	return providerId;
+}
+
+function resolveModelForProvider(
+	legacy: LegacyGlobalState,
+	providerId: string,
+	mode: LegacyMode,
+	activeProviderForMode: string | undefined,
+): string | undefined {
+	const modePrefix = mode === "plan" ? "planMode" : "actMode";
+	const fallbackModel =
+		providerId === activeProviderForMode
+			? trimNonEmpty(
+					mode === "plan"
+						? legacy.planModeApiModelId
+						: legacy.actModeApiModelId,
+				)
+			: undefined;
+	const providerModelKeyById: Record<string, keyof LegacyGlobalState> = {
+		openrouter: `${modePrefix}OpenRouterModelId` as keyof LegacyGlobalState,
+		cline: `${modePrefix}ClineModelId` as keyof LegacyGlobalState,
+		openai: `${modePrefix}OpenAiModelId` as keyof LegacyGlobalState,
+		ollama: `${modePrefix}OllamaModelId` as keyof LegacyGlobalState,
+		lmstudio: `${modePrefix}LmStudioModelId` as keyof LegacyGlobalState,
+		litellm: `${modePrefix}LiteLlmModelId` as keyof LegacyGlobalState,
+		requesty: `${modePrefix}RequestyModelId` as keyof LegacyGlobalState,
+		together: `${modePrefix}TogetherModelId` as keyof LegacyGlobalState,
+		fireworks: `${modePrefix}FireworksModelId` as keyof LegacyGlobalState,
+		sapaicore: `${modePrefix}SapAiCoreModelId` as keyof LegacyGlobalState,
+		groq: `${modePrefix}GroqModelId` as keyof LegacyGlobalState,
+		baseten: `${modePrefix}BasetenModelId` as keyof LegacyGlobalState,
+		huggingface: `${modePrefix}HuggingFaceModelId` as keyof LegacyGlobalState,
+		"huawei-cloud-maas":
+			`${modePrefix}HuaweiCloudMaasModelId` as keyof LegacyGlobalState,
+		oca: `${modePrefix}OcaModelId` as keyof LegacyGlobalState,
+		aihubmix: `${modePrefix}AihubmixModelId` as keyof LegacyGlobalState,
+		hicap: `${modePrefix}HicapModelId` as keyof LegacyGlobalState,
+		nousResearch: `${modePrefix}NousResearchModelId` as keyof LegacyGlobalState,
+		"vercel-ai-gateway":
+			`${modePrefix}VercelAiGatewayModelId` as keyof LegacyGlobalState,
+	};
+	const providerModelKey = providerModelKeyById[providerId];
+	const providerModel = providerModelKey
+		? trimNonEmpty(
+				typeof legacy[providerModelKey] === "string"
+					? (legacy[providerModelKey] as string)
+					: undefined,
+			)
+		: undefined;
+	return providerModel ?? fallbackModel;
+}
+
+function resolveReasoning(
+	legacy: LegacyGlobalState,
+	providerId: string,
+	mode: LegacyMode,
+): ProviderSettings["reasoning"] | undefined {
+	const budgetTokens =
+		mode === "plan"
+			? legacy.planModeThinkingBudgetTokens
+			: legacy.actModeThinkingBudgetTokens;
+	// ProviderSettings has one reasoning effort; legacy state had mode-specific
+	// fields, with OCA/Gemini using provider-specific variants.
+	const rawEffort = [
+		...(providerId === "oca"
+			? [legacy.actModeOcaReasoningEffort, legacy.planModeOcaReasoningEffort]
+			: []),
+		...(providerId === "gemini"
+			? [legacy.geminiActModeThinkingLevel, legacy.geminiPlanModeThinkingLevel]
+			: []),
+		legacy.actModeReasoningEffort,
+		legacy.planModeReasoningEffort,
+	]
+		.map(trimNonEmpty)
+		.find(Boolean);
+	const effort =
+		rawEffort === "none" ||
+		rawEffort === "low" ||
+		rawEffort === "medium" ||
+		rawEffort === "high" ||
+		rawEffort === "xhigh"
+			? rawEffort
+			: undefined;
+	const normalizedBudget =
+		typeof budgetTokens === "number" &&
+		Number.isInteger(budgetTokens) &&
+		budgetTokens > 0
+			? budgetTokens
+			: undefined;
+	if (!effort && normalizedBudget === undefined) {
+		return undefined;
+	}
+	return {
+		...(effort ? { effort } : {}),
+		...(normalizedBudget !== undefined
+			? { budgetTokens: normalizedBudget }
+			: {}),
+	};
+}
+
+function resolveLegacyCodexAuth(
+	legacySecrets: LegacySecrets,
+): Pick<ProviderSettings, "apiKey" | "auth"> | undefined {
+	const raw = legacySecrets["openai-codex-oauth-credentials"];
+	if (!raw) {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(raw) as {
+			access_token?: string;
+			refresh_token?: string;
+			accountId?: string;
+		};
+		const access = trimNonEmpty(parsed.access_token);
+		const refresh = trimNonEmpty(parsed.refresh_token);
+		const accountId = trimNonEmpty(parsed.accountId);
+		if (!access && !refresh && !accountId) {
+			return undefined;
+		}
+		return {
+			...(access ? { apiKey: access } : {}),
+			auth: {
+				...(access ? { accessToken: access } : {}),
+				...(refresh ? { refreshToken: refresh } : {}),
+				...(accountId ? { accountId } : {}),
+			},
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function getDefaultModelForProvider(providerId: string): string | undefined {
+	const builtInModels = LlmsModels.getGeneratedModelsForProvider(providerId);
+	const providerCollection = LlmsModels.getProviderCollectionSync(providerId);
+	const defaultModelId = providerCollection?.provider.defaultModelId;
+	if (defaultModelId && builtInModels[defaultModelId]) {
+		return defaultModelId;
+	}
+
+	const firstModelId = Object.keys(builtInModels)[0];
+	return firstModelId ?? undefined;
+}
+
+function buildLegacyProviderSettings(
+	providerId: string,
+	legacyGlobalState: LegacyGlobalState,
+	legacySecrets: LegacySecrets,
+	mode: LegacyMode,
+): ProviderSettings | undefined {
+	const targetProviderId = resolveMigratedProviderId(providerId);
+	const activeProviderForMode = trimNonEmpty(
+		mode === "plan"
+			? legacyGlobalState.planModeApiProvider
+			: legacyGlobalState.actModeApiProvider,
+	);
+	const model =
+		resolveModelForProvider(
+			legacyGlobalState,
+			providerId,
+			mode,
+			activeProviderForMode,
+		) ?? getDefaultModelForProvider(targetProviderId);
+	const reasoning = resolveReasoning(legacyGlobalState, targetProviderId, mode);
+	const timeout =
+		typeof legacyGlobalState.requestTimeoutMs === "number" &&
+		Number.isInteger(legacyGlobalState.requestTimeoutMs) &&
+		legacyGlobalState.requestTimeoutMs > 0
+			? legacyGlobalState.requestTimeoutMs
+			: undefined;
+
+	const secretByProvider: Record<string, string | undefined> = {
+		anthropic: legacySecrets.apiKey,
+		cline: legacySecrets.clineApiKey,
+		openai: legacySecrets.openAiApiKey,
+		"openai-native": legacySecrets.openAiNativeApiKey,
+		openrouter: legacySecrets.openRouterApiKey,
+		bedrock: legacySecrets.awsBedrockApiKey,
+		gemini: legacySecrets.geminiApiKey,
+		ollama: legacySecrets.ollamaApiKey,
+		deepseek: legacySecrets.deepSeekApiKey,
+		requesty: legacySecrets.requestyApiKey,
+		together: legacySecrets.togetherApiKey,
+		fireworks: legacySecrets.fireworksApiKey,
+		qwen: legacySecrets.qwenApiKey,
+		doubao: legacySecrets.doubaoApiKey,
+		mistral: legacySecrets.mistralApiKey,
+		litellm: legacySecrets.liteLlmApiKey,
+		asksage: legacySecrets.asksageApiKey,
+		xai: legacySecrets.xaiApiKey,
+		moonshot: legacySecrets.moonshotApiKey,
+		zai: legacySecrets.zaiApiKey,
+		huggingface: legacySecrets.huggingFaceApiKey,
+		nebius: legacySecrets.nebiusApiKey,
+		sambanova: legacySecrets.sambanovaApiKey,
+		cerebras: legacySecrets.cerebrasApiKey,
+		groq: legacySecrets.groqApiKey,
+		"huawei-cloud-maas": legacySecrets.huaweiCloudMaasApiKey,
+		baseten: legacySecrets.basetenApiKey,
+		"vercel-ai-gateway": legacySecrets.vercelAiGatewayApiKey,
+		dify: legacySecrets.difyApiKey,
+		minimax: legacySecrets.minimaxApiKey,
+		hicap: legacySecrets.hicapApiKey,
+		aihubmix: legacySecrets.aihubmixApiKey,
+		nousResearch: legacySecrets.nousResearchApiKey,
+		oca: legacySecrets.ocaApiKey,
+	};
+
+	const providerSpecific: Partial<ProviderSettings> = {};
+	if (providerId === "openai-codex") {
+		Object.assign(providerSpecific, resolveLegacyCodexAuth(legacySecrets));
+	}
+	if (providerId === "cline") {
+		try {
+			const legacyAuthString = trimNonEmpty(
+				legacySecrets["cline:clineAccountId"],
+			);
+
+			if (legacyAuthString) {
+				providerSpecific.auth = {
+					...(providerSpecific.auth ?? {}),
+					...resolveLegacyClineAuth(legacyAuthString),
+				};
+			}
+		} catch {
+			// Failed to parse stored cline auth data
+		}
+	}
+	if (
+		providerId === LEGACY_OPENAI_COMPATIBLE_PROVIDER_ID &&
+		legacyGlobalState.openAiHeaders
+	) {
+		providerSpecific.headers = legacyGlobalState.openAiHeaders;
+	}
+	if (providerId === "bedrock") {
+		const bedrockAuthentication = normalizeLegacyBedrockAuthentication(
+			legacyGlobalState.awsAuthentication,
+		);
+		const useBedrockProfile =
+			bedrockAuthentication === "profile" ||
+			legacyGlobalState.awsUseProfile === true;
+		providerSpecific.aws = {
+			accessKey: trimNonEmpty(legacySecrets.awsAccessKey),
+			secretKey: trimNonEmpty(legacySecrets.awsSecretKey),
+			sessionToken: trimNonEmpty(legacySecrets.awsSessionToken),
+			region: trimNonEmpty(legacyGlobalState.awsRegion),
+			authentication: bedrockAuthentication,
+			profile: useBedrockProfile
+				? trimNonEmpty(legacyGlobalState.awsProfile)
+				: undefined,
+			usePromptCache: legacyGlobalState.awsBedrockUsePromptCache,
+			useCrossRegionInference: legacyGlobalState.awsUseCrossRegionInference,
+			useGlobalInference: legacyGlobalState.awsUseGlobalInference,
+			endpoint: trimNonEmpty(legacyGlobalState.awsBedrockEndpoint),
+			customModelBaseId: trimNonEmpty(
+				mode === "plan"
+					? legacyGlobalState.planModeAwsBedrockCustomModelBaseId
+					: legacyGlobalState.actModeAwsBedrockCustomModelBaseId,
+			),
+		};
+	}
+	if (providerId === "vertex") {
+		providerSpecific.gcp = {
+			projectId: trimNonEmpty(legacyGlobalState.vertexProjectId),
+			region: trimNonEmpty(legacyGlobalState.vertexRegion),
+		};
+	}
+	if (
+		providerId === LEGACY_OPENAI_COMPATIBLE_PROVIDER_ID &&
+		(legacyGlobalState.azureApiVersion ||
+			legacyGlobalState.azureIdentity !== undefined)
+	) {
+		providerSpecific.azure = {
+			apiVersion: trimNonEmpty(legacyGlobalState.azureApiVersion),
+			useIdentity: legacyGlobalState.azureIdentity,
+		};
+	}
+	if (providerId === "sapaicore") {
+		const useOrchestrationMode =
+			legacyGlobalState.sapAiCoreUseOrchestrationMode ?? true;
+		providerSpecific.sap = {
+			clientId: trimNonEmpty(legacySecrets.sapAiCoreClientId),
+			clientSecret: trimNonEmpty(legacySecrets.sapAiCoreClientSecret),
+			tokenUrl: trimNonEmpty(legacyGlobalState.sapAiCoreTokenUrl),
+			resourceGroup: trimNonEmpty(legacyGlobalState.sapAiResourceGroup),
+			deploymentId: useOrchestrationMode
+				? undefined
+				: trimNonEmpty(
+						mode === "plan"
+							? legacyGlobalState.planModeSapAiCoreDeploymentId
+							: legacyGlobalState.actModeSapAiCoreDeploymentId,
+					),
+			useOrchestrationMode,
+		};
+	}
+	if (providerId === "oca") {
+		providerSpecific.oca = {
+			mode: legacyGlobalState.ocaMode,
+		};
+		const refreshToken = trimNonEmpty(legacySecrets.ocaRefreshToken);
+		if (refreshToken) {
+			providerSpecific.auth = {
+				...(providerSpecific.auth ?? {}),
+				refreshToken,
+			};
+		}
+	}
+	if (providerId === "qwen") {
+		providerSpecific.apiLine = legacyGlobalState.qwenApiLine;
+	}
+	if (providerId === "moonshot") {
+		providerSpecific.apiLine = legacyGlobalState.moonshotApiLine;
+	}
+	if (providerId === "zai") {
+		providerSpecific.apiLine = legacyGlobalState.zaiApiLine;
+	}
+	if (providerId === "minimax") {
+		providerSpecific.apiLine = legacyGlobalState.minimaxApiLine;
+	}
+
+	const baseUrlByProvider: Record<string, string | undefined> = {
+		anthropic: legacyGlobalState.anthropicBaseUrl,
+		openai: legacyGlobalState.openAiBaseUrl,
+		ollama: legacyGlobalState.ollamaBaseUrl,
+		lmstudio: legacyGlobalState.lmStudioBaseUrl,
+		litellm: legacyGlobalState.liteLlmBaseUrl,
+		gemini: legacyGlobalState.geminiBaseUrl,
+		requesty: legacyGlobalState.requestyBaseUrl,
+		asksage: legacyGlobalState.asksageApiUrl,
+		dify: legacyGlobalState.difyBaseUrl,
+		oca: legacyGlobalState.ocaBaseUrl,
+		aihubmix: legacyGlobalState.aihubmixBaseUrl,
+		sapaicore: legacyGlobalState.sapAiCoreBaseUrl,
+	};
+
+	const apiKey = trimNonEmpty(secretByProvider[providerId]);
+	const baseUrl = trimNonEmpty(baseUrlByProvider[providerId]);
+
+	const settings: ProviderSettings = {
+		provider: targetProviderId as ProviderSettings["provider"],
+		...(apiKey ? { apiKey } : {}),
+		...(model ? { model } : {}),
+		...(baseUrl ? { baseUrl } : {}),
+		...(reasoning ? { reasoning } : {}),
+		...(timeout ? { timeout } : {}),
+		...providerSpecific,
+	};
+	const parsed = ProviderSettingsSchema.safeParse(settings);
+	if (!parsed.success) {
+		return undefined;
+	}
+	const hasNonProviderFields =
+		Object.keys(settings).filter((key) => key !== "provider").length > 0;
+	return hasNonProviderFields ? parsed.data : undefined;
+}
+
+function resolveLegacyCustomProviderRegistration(
+	providerId: string,
+	settings: ProviderSettings,
+): StoredModelsFile["providers"][string] | undefined {
+	if (providerId !== OPENAI_COMPATIBLE_PROVIDER_ID) {
+		return undefined;
+	}
+	if (!settings.baseUrl || !settings.model) {
+		return undefined;
+	}
+	return {
+		provider: {
+			name: "OpenAI Compatible",
+			baseUrl: settings.baseUrl,
+			defaultModelId: settings.model,
+		},
+		models: {
+			[settings.model]: {
+				id: settings.model,
+				name: settings.model,
+				contextWindow: LEGACY_OPENAI_COMPATIBLE_CONTEXT_WINDOW,
+				maxInputTokens: LEGACY_OPENAI_COMPATIBLE_CONTEXT_WINDOW,
+				capabilities: ["streaming", "tools", "images"],
+			},
+		},
+	};
+}
+
+function collectCandidateProviderIds(
+	legacyGlobalState: LegacyGlobalState,
+	legacySecrets: LegacySecrets,
+): Set<string> {
+	const candidates = new Set<string>();
+	for (const maybeProvider of [
+		legacyGlobalState.actModeApiProvider,
+		legacyGlobalState.planModeApiProvider,
+	]) {
+		const provider = trimNonEmpty(maybeProvider);
+		if (provider) {
+			candidates.add(provider);
+		}
+	}
+	if (trimNonEmpty(legacySecrets.apiKey)) candidates.add("anthropic");
+	if (trimNonEmpty(legacySecrets.openRouterApiKey))
+		candidates.add("openrouter");
+	if (trimNonEmpty(legacySecrets.openAiApiKey)) {
+		candidates.add(LEGACY_OPENAI_COMPATIBLE_PROVIDER_ID);
+	}
+	if (trimNonEmpty(legacySecrets.openAiNativeApiKey))
+		candidates.add("openai-native");
+	if (trimNonEmpty(legacySecrets["openai-codex-oauth-credentials"]))
+		candidates.add("openai-codex");
+	if (trimNonEmpty(legacySecrets.geminiApiKey)) candidates.add("gemini");
+	if (trimNonEmpty(legacySecrets.ollamaApiKey)) candidates.add("ollama");
+	if (
+		trimNonEmpty(legacySecrets.awsAccessKey) ||
+		trimNonEmpty(legacySecrets.awsBedrockApiKey) ||
+		legacyGlobalState.awsAuthentication !== undefined ||
+		legacyGlobalState.awsUseProfile === true ||
+		trimNonEmpty(legacyGlobalState.awsProfile)
+	)
+		candidates.add("bedrock");
+	if (
+		trimNonEmpty(legacyGlobalState.vertexProjectId) ||
+		trimNonEmpty(legacyGlobalState.vertexRegion)
+	) {
+		candidates.add("vertex");
+	}
+	if (trimNonEmpty(legacySecrets.clineApiKey)) candidates.add("cline");
+	const legacyClineAuth = resolveLegacyClineAuth(
+		trimNonEmpty(legacySecrets["cline:clineAccountId"]),
+	);
+	if (
+		legacyClineAuth?.accessToken ||
+		legacyClineAuth?.refreshToken ||
+		legacyClineAuth?.accountId
+	) {
+		candidates.add("cline");
+	}
+	if (trimNonEmpty(legacySecrets.ocaApiKey)) candidates.add("oca");
+	if (
+		trimNonEmpty(legacySecrets.sapAiCoreClientId) ||
+		trimNonEmpty(legacySecrets.sapAiCoreClientSecret) ||
+		trimNonEmpty(legacyGlobalState.sapAiCoreTokenUrl) ||
+		trimNonEmpty(legacyGlobalState.sapAiCoreBaseUrl) ||
+		trimNonEmpty(legacyGlobalState.sapAiResourceGroup) ||
+		legacyGlobalState.sapAiCoreUseOrchestrationMode !== undefined
+	) {
+		candidates.add("sapaicore");
+	}
+	return candidates;
+}
+
+export function migrateLegacyProviderSettings(
+	options: MigrateLegacyProviderSettingsOptions,
+): MigrateLegacyProviderSettingsResult {
+	const existing = options.providerSettingsManager.read();
+	const legacyStorage = resolveLegacyStorage(options);
+	if (!legacyStorage) {
+		return {
+			migrated: false,
+			providerCount: Object.keys(existing.providers).length,
+			lastUsedProvider: existing.lastUsedProvider,
+		};
+	}
+
+	const { globalState, secrets } = legacyStorage;
+	const mode: LegacyMode = globalState.mode === "plan" ? "plan" : "act";
+	const candidates = collectCandidateProviderIds(globalState, secrets);
+	const next = emptyStoredProviderSettings();
+	next.providers = { ...existing.providers };
+	next.lastUsedProvider = existing.lastUsedProvider;
+	const now = new Date().toISOString();
+	let addedProviderCount = 0;
+	const modelsPath = join(
+		dirname(options.providerSettingsManager.getFilePath()),
+		"models.json",
+	);
+	const modelsState = readModelsFileSync(modelsPath);
+	let addedCustomProviderCount = 0;
+
+	for (const legacyProviderId of candidates) {
+		const providerId = resolveMigratedProviderId(legacyProviderId);
+		if (next.providers[providerId]) {
+			continue;
+		}
+		const settings = buildLegacyProviderSettings(
+			legacyProviderId,
+			globalState,
+			secrets,
+			mode,
+		);
+		if (!settings) {
+			continue;
+		}
+		next.providers[providerId] = {
+			settings,
+			updatedAt: now,
+			tokenSource: "migration",
+		};
+		addedProviderCount += 1;
+		const registration = resolveLegacyCustomProviderRegistration(
+			providerId,
+			settings,
+		);
+		if (registration && !modelsState.providers[providerId]) {
+			modelsState.providers[providerId] = registration;
+			addedCustomProviderCount += 1;
+		}
+	}
+
+	if (addedProviderCount === 0 && addedCustomProviderCount === 0) {
+		return {
+			migrated: false,
+			providerCount: Object.keys(existing.providers).length,
+			lastUsedProvider: existing.lastUsedProvider,
+		};
+	}
+
+	const preferredProvider = trimNonEmpty(
+		mode === "plan"
+			? globalState.planModeApiProvider
+			: globalState.actModeApiProvider,
+	);
+	const migratedPreferredProvider = preferredProvider
+		? resolveMigratedProviderId(preferredProvider)
+		: undefined;
+	next.lastUsedProvider =
+		existing.lastUsedProvider ??
+		(migratedPreferredProvider && next.providers[migratedPreferredProvider]
+			? migratedPreferredProvider
+			: Object.keys(next.providers)[0]);
+
+	options.providerSettingsManager.write(next);
+	if (addedCustomProviderCount > 0) {
+		writeModelsFileSync(modelsPath, modelsState);
+	}
+
+	return {
+		migrated: addedProviderCount > 0 || addedCustomProviderCount > 0,
+		providerCount: Object.keys(next.providers).length,
+		lastUsedProvider: next.lastUsedProvider,
+	};
+}
diff --git a/sdk/packages/core/src/services/storage/provider-settings-manager.test.ts b/sdk/packages/core/src/services/storage/provider-settings-manager.test.ts
new file mode 100644
index 0000000..305e82b
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/provider-settings-manager.test.ts
@@ -0,0 +1,492 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as LlmsModels from "@cline/llms";
+import { afterEach, describe, expect, it } from "vitest";
+import { ProviderSettingsManager } from "./provider-settings-manager";
+
+describe("ProviderSettingsManager", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		LlmsModels.resetRegistry();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("persists and restores provider settings", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+				apiKey: "test-key",
+			},
+			{ setLastUsed: true },
+		);
+
+		const reloaded = new ProviderSettingsManager({ filePath });
+		expect(reloaded.getLastUsedProviderSettings()).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "test-key",
+		});
+		expect(reloaded.getProviderConfig("anthropic")?.providerId).toBe(
+			"anthropic",
+		);
+		expect(reloaded.getProviderConfig("anthropic")?.modelId).toBe(
+			"claude-sonnet-4-6",
+		);
+		expect(reloaded.getProviderConfig("anthropic")?.knownModels).toBeDefined();
+		expect(
+			reloaded.getProviderConfig("anthropic", { includeKnownModels: false }),
+		).not.toHaveProperty("knownModels");
+		expect(reloaded.read().providers.anthropic?.tokenSource).toBe("manual");
+	});
+
+	it("resolves auth storage settings for providers registered with a storage provider id", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				baseUrl: "https://api.example.test",
+				auth: {
+					accessToken: "workos:shared-token",
+					refreshToken: "shared-refresh",
+				},
+			},
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+
+		expect(manager.getProviderSettings("cline-pass")).toEqual({
+			provider: "cline-pass",
+			baseUrl: "https://api.example.test",
+			auth: {
+				accessToken: "workos:shared-token",
+				refreshToken: "shared-refresh",
+			},
+		});
+		expect(manager.getProviderConfig("cline-pass")).toMatchObject({
+			providerId: "cline-pass",
+			apiKey: "workos:shared-token",
+			baseUrl: "https://api.example.test",
+		});
+
+		manager.saveProviderSettings(
+			{
+				provider: "cline-pass",
+				model: "cline-pass/glm-5.2",
+			},
+			{ setLastUsed: true },
+		);
+
+		expect(manager.getProviderSettings("cline-pass")).toEqual({
+			provider: "cline-pass",
+			model: "cline-pass/glm-5.2",
+			baseUrl: "https://api.example.test",
+			auth: {
+				accessToken: "workos:shared-token",
+				refreshToken: "shared-refresh",
+			},
+		});
+	});
+
+	it("falls back to cline when last-used provider is cline-pass and the feature is disabled", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "cline",
+				model: "anthropic/claude-sonnet-4.6",
+				baseUrl: "https://api.example.test",
+				auth: {
+					accessToken: "workos:shared-token",
+					refreshToken: "shared-refresh",
+				},
+			},
+			{ setLastUsed: false, tokenSource: "oauth" },
+		);
+		manager.saveProviderSettings(
+			{
+				provider: "cline-pass",
+				model: "cline-pass/glm-5.2",
+			},
+			{ setLastUsed: true },
+		);
+
+		expect(manager.getLastUsedProviderSettings()).toMatchObject({
+			provider: "cline-pass",
+			model: "cline-pass/glm-5.2",
+		});
+		expect(
+			manager.getLastUsedProviderSettings({ isClinePassEnabled: false }),
+		).toEqual({
+			provider: "cline",
+			model: "anthropic/claude-sonnet-4.6",
+			baseUrl: "https://api.example.test",
+			auth: {
+				accessToken: "workos:shared-token",
+				refreshToken: "shared-refresh",
+			},
+		});
+		expect(
+			manager.getLastUsedProviderConfig({ isClinePassEnabled: false }),
+		).toMatchObject({
+			providerId: "cline",
+			apiKey: "workos:shared-token",
+			baseUrl: "https://api.example.test",
+		});
+	});
+
+	it("returns default cline settings when cline-pass is last-used and no cline settings exist", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "cline-pass",
+				model: "cline-pass/glm-5.2",
+			},
+			{ setLastUsed: true },
+		);
+
+		manager.saveProviderSettings(
+			{
+				provider: "cline",
+			},
+			{ setLastUsed: true },
+		);
+
+		expect(
+			manager.getLastUsedProviderSettings({ isClinePassEnabled: false }),
+		).toEqual({ provider: "cline" });
+		expect(
+			manager.getLastUsedProviderConfig({ isClinePassEnabled: false })
+				?.providerId,
+		).toBe("cline");
+	});
+
+	it("migrates legacy provider settings during manager construction", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+					actModeApiModelId: "claude-sonnet-4-6",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ apiKey: "legacy-key" }, null, 2),
+		);
+
+		const manager = new ProviderSettingsManager({ filePath, dataDir: tempDir });
+
+		expect(manager.getLastUsedProviderSettings()).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "legacy-key",
+		});
+		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
+	});
+
+	it("registers migrated custom providers during manager construction", async () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "openai",
+					actModeOpenAiModelId: "gpt-oss-120b",
+					openAiBaseUrl: "https://gateway.example.invalid/v1",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ openAiApiKey: "legacy-key" }, null, 2),
+		);
+
+		const manager = new ProviderSettingsManager({ filePath, dataDir: tempDir });
+		const providers = await LlmsModels.getAllProviders();
+		const models = await LlmsModels.getModelsForProvider("openai-compatible");
+		const openAiProvider = providers.find(
+			(provider) => provider.id === "openai-compatible",
+		);
+
+		expect(manager.getProviderSettings("openai-compatible")).toEqual({
+			provider: "openai-compatible",
+			model: "gpt-oss-120b",
+			apiKey: "legacy-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+		});
+		expect(openAiProvider).toMatchObject({
+			id: "openai-compatible",
+			baseUrl: "https://gateway.example.invalid/v1",
+			defaultModelId: "gpt-oss-120b",
+		});
+		expect(models["gpt-oss-120b"]).toMatchObject({
+			id: "gpt-oss-120b",
+			contextWindow: 128000,
+			maxInputTokens: 128000,
+			capabilities: ["streaming", "tools", "images"],
+		});
+	});
+
+	it("registers non-built-in OpenAI-compatible providers from providers.json", async () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+		mkdirSync(path.dirname(filePath), { recursive: true });
+		writeFileSync(
+			filePath,
+			JSON.stringify(
+				{
+					version: 1,
+					lastUsedProvider: "custom-provider",
+					providers: {
+						"custom-provider": {
+							settings: {
+								provider: "custom-provider",
+								baseUrl: "https://custom.example.invalid/v1",
+								model: "custom-model",
+								apiKey: "test-key",
+								capabilities: ["reasoning", "tools"],
+							},
+							updatedAt: new Date().toISOString(),
+							tokenSource: "manual",
+						},
+					},
+				},
+				null,
+				2,
+			),
+		);
+
+		const manager = new ProviderSettingsManager({ filePath });
+		const provider = await LlmsModels.getProvider("custom-provider");
+		const models = await LlmsModels.getModelsForProvider("custom-provider");
+
+		expect(manager.getProviderConfig("custom-provider")).toMatchObject({
+			providerId: "custom-provider",
+			baseUrl: "https://custom.example.invalid/v1",
+			modelId: "custom-model",
+		});
+		expect(provider).toMatchObject({
+			id: "custom-provider",
+			baseUrl: "https://custom.example.invalid/v1",
+			defaultModelId: "custom-model",
+			client: "openai-compatible",
+			source: "file",
+		});
+		expect(models["custom-model"]).toMatchObject({
+			id: "custom-model",
+		});
+		expect(models["custom-model"]?.capabilities?.sort()).toEqual([
+			"reasoning",
+			"tools",
+		]);
+	});
+
+	it("routes custom providers with the Responses API protocol through the OpenAI client", async () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+		mkdirSync(path.dirname(filePath), { recursive: true });
+		writeFileSync(
+			filePath,
+			JSON.stringify(
+				{
+					version: 1,
+					lastUsedProvider: "custom-responses",
+					providers: {
+						"custom-responses": {
+							settings: {
+								provider: "custom-responses",
+								baseUrl: "https://responses.example.invalid/v1",
+								model: "responses-model",
+								protocol: "openai-responses",
+								apiKey: "test-key",
+							},
+							updatedAt: new Date().toISOString(),
+							tokenSource: "manual",
+						},
+					},
+				},
+				null,
+				2,
+			),
+		);
+
+		const manager = new ProviderSettingsManager({ filePath });
+		const provider = await LlmsModels.getProvider("custom-responses");
+
+		expect(manager.getProviderConfig("custom-responses")).toMatchObject({
+			providerId: "custom-responses",
+			baseUrl: "https://responses.example.invalid/v1",
+			modelId: "responses-model",
+			routingProviderId: "openai-native",
+		});
+		expect(provider).toMatchObject({
+			id: "custom-responses",
+			protocol: "openai-responses",
+			client: "openai",
+			source: "file",
+		});
+	});
+
+	it("refreshes provider registrations when providers.json changes on disk", async () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath });
+		mkdirSync(path.dirname(filePath), { recursive: true });
+
+		expect(LlmsModels.hasProvider("disk-added-provider")).toBe(false);
+
+		writeFileSync(
+			filePath,
+			JSON.stringify(
+				{
+					version: 1,
+					providers: {
+						"disk-added-provider": {
+							settings: {
+								provider: "disk-added-provider",
+								baseUrl: "https://disk.example.invalid/v1",
+								model: "disk-model",
+							},
+							updatedAt: new Date().toISOString(),
+							tokenSource: "manual",
+						},
+					},
+				},
+				null,
+				2,
+			),
+		);
+
+		expect(manager.getProviderSettings("disk-added-provider")).toMatchObject({
+			provider: "disk-added-provider",
+			baseUrl: "https://disk.example.invalid/v1",
+			model: "disk-model",
+		});
+		await expect(
+			LlmsModels.getProvider("disk-added-provider"),
+		).resolves.toMatchObject({
+			id: "disk-added-provider",
+			defaultModelId: "disk-model",
+		});
+	});
+
+	it("tracks provider-specific settings while preserving last-used provider", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+		});
+		manager.saveProviderSettings(
+			{
+				provider: "openai-native",
+				model: "gpt-5",
+			},
+			{ setLastUsed: false },
+		);
+
+		expect(manager.getProviderSettings("anthropic")?.model).toBe(
+			"claude-sonnet-4-6",
+		);
+		expect(manager.getProviderSettings("openai-native")?.model).toBe("gpt-5");
+		expect(manager.getLastUsedProviderSettings()?.provider).toBe("anthropic");
+		expect(manager.read().providers["openai-native"]?.tokenSource).toBe(
+			"manual",
+		);
+	});
+
+	it("allows overriding token source metadata", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "openai-codex",
+				apiKey: "oauth-token",
+			},
+			{ tokenSource: "oauth" },
+		);
+
+		expect(manager.read().providers["openai-codex"]?.tokenSource).toBe("oauth");
+	});
+
+	it("ignores invalid persisted JSON and falls back to empty state", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		writeFileSync(filePath, "{ not-json", "utf8");
+
+		const manager = new ProviderSettingsManager({ filePath });
+		expect(manager.read()).toEqual({
+			version: 1,
+			providers: {},
+		});
+	});
+});
diff --git a/sdk/packages/core/src/services/storage/provider-settings-manager.ts b/sdk/packages/core/src/services/storage/provider-settings-manager.ts
new file mode 100644
index 0000000..c84c347
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/provider-settings-manager.ts
@@ -0,0 +1,260 @@
+import {
+	chmodSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { basename, dirname } from "node:path";
+import { resolveProviderSettingsPath } from "@cline/shared/storage";
+import { getLiveModelsCatalog } from "../..";
+import { getProviderAuthHandler } from "../../auth/provider-auth-registry";
+import {
+	emptyStoredProviderSettings,
+	type ProviderConfig,
+	type ProviderSettings,
+	ProviderSettingsSchemaTyped as ProviderSettingsSchema,
+	type ProviderTokenSource,
+	type StoredProviderSettings,
+	StoredProviderSettingsSchema,
+	type ToProviderConfigOptions,
+	toProviderConfig,
+} from "../../types/provider-settings";
+import {
+	ensureCustomProvidersLoadedSync,
+	registerConfiguredProvidersFromSettings,
+} from "../providers/local-provider-registry";
+import { hashSecret, sdkDebug } from "../../logging/early-logger";
+import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export interface ProviderSettingsManagerOptions {
+	filePath?: string;
+	dataDir?: string;
+}
+
+export interface SaveProviderSettingsOptions {
+	setLastUsed?: boolean;
+	tokenSource?: ProviderTokenSource;
+}
+
+export interface ResolveLastUsedProviderSettingsOptions {
+	isClinePassEnabled?: boolean;
+}
+
+const CLINE_PROVIDER_ID = "cline";
+const CLINE_PASS_PROVIDER_ID = "cline-pass";
+
+function inferLegacyDataDir(filePath: string): string | undefined {
+	if (basename(filePath) !== "providers.json") {
+		return undefined;
+	}
+	const settingsDir = dirname(filePath);
+	if (basename(settingsDir) !== "settings") {
+		return undefined;
+	}
+	return dirname(settingsDir);
+}
+
+export class ProviderSettingsManager {
+	private readonly filePath: string;
+	private readonly dataDir?: string;
+
+	constructor(options: ProviderSettingsManagerOptions = {}) {
+		this.filePath = options.filePath ?? resolveProviderSettingsPath();
+		this.dataDir = options.dataDir ?? inferLegacyDataDir(this.filePath);
+		if (this.dataDir || !options.filePath) {
+			migrateLegacyProviderSettings({
+				providerSettingsManager: this,
+				dataDir: this.dataDir,
+			});
+		}
+		ensureCustomProvidersLoadedSync(this);
+		registerConfiguredProvidersFromSettings(this.read());
+		// Harden permissions on any existing file at startup so that
+		// pre-existing installations are also protected (best-effort; no-op on Windows).
+		if (existsSync(this.filePath)) {
+			try {
+				chmodSync(this.filePath, 0o600);
+			} catch {
+				// Ignore — Windows does not support POSIX chmod.
+			}
+		}
+	}
+
+	getFilePath(): string {
+		return this.filePath;
+	}
+
+	read(): StoredProviderSettings {
+		if (!existsSync(this.filePath)) {
+			return emptyStoredProviderSettings();
+		}
+
+		try {
+			const raw = readFileSync(this.filePath, "utf8");
+			const parsed = JSON.parse(raw) as unknown;
+			const result = StoredProviderSettingsSchema.safeParse(parsed);
+			if (result.success) {
+				registerConfiguredProvidersFromSettings(result.data);
+				const clineAuth = result.data.providers["cline"]?.settings?.auth;
+				sdkDebug(
+					`providers.read providers=[${Object.keys(result.data.providers).join(",")}] lastUsed=${result.data.lastUsedProvider ?? "none"} clineAuthPresent=${!!clineAuth?.accessToken} clineAccessTokenHash=${hashSecret(clineAuth?.accessToken)} clineRefreshTokenHash=${hashSecret(clineAuth?.refreshToken)}`,
+				);
+				return result.data;
+			}
+		} catch {
+			// Invalid content falls back to a clean state.
+		}
+
+		return emptyStoredProviderSettings();
+	}
+
+	write(state: StoredProviderSettings): void {
+		const normalized = StoredProviderSettingsSchema.parse(state);
+		const dir = dirname(this.filePath);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true, mode: 0o700 });
+		}
+		writeFileSync(
+			this.filePath,
+			`${JSON.stringify(normalized, null, 2)}\n`,
+			"utf8",
+		);
+		// Restrict file to owner-only read/write (best-effort; no-op on Windows).
+		try {
+			chmodSync(this.filePath, 0o600);
+		} catch {
+			// Ignore — Windows does not support POSIX chmod.
+		}
+		registerConfiguredProvidersFromSettings(normalized);
+	}
+
+	saveProviderSettings(
+		settings: unknown,
+		options: SaveProviderSettingsOptions = {},
+	): StoredProviderSettings {
+		const validatedSettings = ProviderSettingsSchema.parse(settings);
+		const previous = this.read();
+		const providerId = validatedSettings.provider;
+		const shouldSetLastUsed = options.setLastUsed !== false;
+		const previousEntry = previous.providers[providerId];
+		const tokenSource =
+			options.tokenSource ?? previousEntry?.tokenSource ?? "manual";
+		const next: StoredProviderSettings = {
+			...previous,
+			providers: {
+				...previous.providers,
+				[providerId]: {
+					settings: validatedSettings,
+					updatedAt: nowIso(),
+					tokenSource,
+				},
+			},
+			lastUsedProvider: shouldSetLastUsed
+				? providerId
+				: previous.lastUsedProvider,
+		};
+		this.write(next);
+		const prevClineAuth = previous.providers["cline"]?.settings?.auth;
+		const nextClineAuth =
+			validatedSettings.provider === "cline"
+				? validatedSettings.auth
+				: next.providers["cline"]?.settings?.auth;
+		const authDropped =
+			!!prevClineAuth?.accessToken && !nextClineAuth?.accessToken;
+		sdkDebug(
+			`providers.save providerId=${providerId} tokenSource=${tokenSource} clineAuthWasPresent=${!!prevClineAuth?.accessToken} clineAuthIsPresent=${!!nextClineAuth?.accessToken} authDropped=${authDropped}`,
+		);
+		return next;
+	}
+
+	private resolveProviderSettings(
+		state: StoredProviderSettings,
+		providerId: string,
+	): ProviderSettings | undefined {
+		const directSettings = state.providers[providerId]?.settings;
+		const authHandler = getProviderAuthHandler(providerId);
+		const storageProviderId = authHandler?.storageProviderId;
+		if (!storageProviderId || storageProviderId === providerId) {
+			return directSettings;
+		}
+
+		const authSettings = state.providers[storageProviderId]?.settings;
+		if (!authSettings) {
+			return directSettings;
+		}
+
+		return ProviderSettingsSchema.parse({
+			...(authSettings.auth ? { auth: authSettings.auth } : {}),
+			...(authSettings.apiKey ? { apiKey: authSettings.apiKey } : {}),
+			...(authSettings.baseUrl ? { baseUrl: authSettings.baseUrl } : {}),
+			...(directSettings ?? {}),
+			provider: providerId,
+		});
+	}
+
+	getProviderSettings(providerId: string): ProviderSettings | undefined {
+		const state = this.read();
+		return this.resolveProviderSettings(state, providerId);
+	}
+
+	private resolveLastUsedProviderId(
+		state: StoredProviderSettings,
+		options: ResolveLastUsedProviderSettingsOptions,
+	): string | undefined {
+		const providerId = state.lastUsedProvider;
+		if (
+			providerId === CLINE_PASS_PROVIDER_ID &&
+			options.isClinePassEnabled === false
+		) {
+			return CLINE_PROVIDER_ID;
+		}
+
+		return providerId;
+	}
+
+	getLastUsedProviderSettings(
+		options: ResolveLastUsedProviderSettingsOptions = {},
+	): ProviderSettings | undefined {
+		const state = this.read();
+		const providerId = this.resolveLastUsedProviderId(state, options);
+		if (!providerId) {
+			return undefined;
+		}
+		return this.resolveProviderSettings(state, providerId);
+	}
+
+	getProviderConfig(
+		providerId: string,
+		options?: ToProviderConfigOptions,
+	): ProviderConfig | undefined {
+		const settings = this.getProviderSettings(providerId);
+		if (!settings) {
+			return undefined;
+		}
+		return toProviderConfig(settings, options);
+	}
+
+	getLastUsedProviderConfig(
+		options: ToProviderConfigOptions &
+			ResolveLastUsedProviderSettingsOptions = {},
+	): ProviderConfig | undefined {
+		const settings = this.getLastUsedProviderSettings(options);
+		if (!settings) {
+			return undefined;
+		}
+		return toProviderConfig(settings, options);
+	}
+
+	async refreshCatalog(): Promise<void> {
+		try {
+			await getLiveModelsCatalog({});
+		} catch {
+			// Ignore errors
+		}
+	}
+}
diff --git a/sdk/packages/core/src/services/storage/session-store.ts b/sdk/packages/core/src/services/storage/session-store.ts
new file mode 100644
index 0000000..44c7bd9
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/session-store.ts
@@ -0,0 +1 @@
+export type { SessionStore } from "../../types/storage";
diff --git a/sdk/packages/core/src/services/storage/sqlite-session-store.ts b/sdk/packages/core/src/services/storage/sqlite-session-store.ts
new file mode 100644
index 0000000..f1057f5
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/sqlite-session-store.ts
@@ -0,0 +1,272 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import {
+	asBool,
+	asOptionalString,
+	asString,
+	ensureSessionSchema,
+	loadSqliteDb,
+	nowIso,
+	type SqliteDb,
+	toBoolInt,
+} from "@cline/shared/db";
+import { resolveDbDataDir } from "@cline/shared/storage";
+import {
+	isNonTerminalSessionStatus,
+	type SessionStatus,
+} from "../../types/common";
+import type { SessionRecord } from "../../types/sessions";
+import type { SessionStore } from "../../types/storage";
+
+export interface SqliteSessionStoreOptions {
+	sessionsDir?: string;
+}
+
+export class SqliteSessionStore implements SessionStore {
+	private readonly sessionsDirPath: string;
+	private db: SqliteDb | undefined;
+
+	constructor(options: SqliteSessionStoreOptions = {}) {
+		this.sessionsDirPath = options.sessionsDir ?? resolveDbDataDir();
+	}
+
+	init(): void {
+		this.getRawDb();
+	}
+
+	ensureSessionsDir(): string {
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
+	}
+
+	sessionDbPath(): string {
+		return join(this.ensureSessionsDir(), "sessions.db");
+	}
+
+	getRawDb(): SqliteDb {
+		if (this.db) {
+			return this.db;
+		}
+		const db = loadSqliteDb(this.sessionDbPath());
+		ensureSessionSchema(db, { includeLegacyMigrations: true });
+
+		this.db = db;
+		return db;
+	}
+
+	close(): void {
+		this.db?.close?.();
+		this.db = undefined;
+	}
+
+	run(sql: string, params: unknown[] = []): { changes?: number } {
+		return this.getRawDb()
+			.prepare(sql)
+			.run(...params);
+	}
+
+	queryOne<T>(sql: string, params: unknown[] = []): T | undefined {
+		const row = this.getRawDb()
+			.prepare(sql)
+			.get(...params);
+		return (row as T | null) ?? undefined;
+	}
+
+	queryAll<T>(sql: string, params: unknown[] = []): T[] {
+		return this.getRawDb()
+			.prepare(sql)
+			.all(...params) as T[];
+	}
+
+	create(record: SessionRecord): void {
+		const now = nowIso();
+		this.run(
+			`INSERT OR REPLACE INTO sessions (
+				session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
+				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
+				metadata_json, transcript_path, hook_path, messages_path, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			[
+				record.sessionId,
+				record.source,
+				record.pid,
+				record.startedAt,
+				record.endedAt ?? null,
+				record.exitCode ?? null,
+				record.status,
+				0,
+				toBoolInt(record.interactive),
+				record.provider,
+				record.model,
+				record.cwd,
+				record.workspaceRoot,
+				record.teamName ?? null,
+				toBoolInt(record.enableTools),
+				toBoolInt(record.enableSpawn),
+				toBoolInt(record.enableTeams),
+				record.parentSessionId ?? null,
+				record.parentAgentId ?? null,
+				record.agentId ?? null,
+				record.conversationId ?? null,
+				toBoolInt(record.isSubagent),
+				record.prompt ?? null,
+				record.metadata ? JSON.stringify(record.metadata) : null,
+				"",
+				record.hookPath ?? "",
+				record.messagesPath ?? null,
+				now,
+			],
+		);
+	}
+
+	update(record: Partial<SessionRecord> & { sessionId: string }): void {
+		const fields: string[] = [];
+		const params: unknown[] = [];
+		if (record.endedAt !== undefined) {
+			fields.push("ended_at = ?");
+			params.push(record.endedAt);
+		}
+		if (record.exitCode !== undefined) {
+			fields.push("exit_code = ?");
+			params.push(record.exitCode);
+		}
+		if (record.status !== undefined) {
+			fields.push("status = ?");
+			params.push(record.status);
+		}
+		if (record.prompt !== undefined) {
+			fields.push("prompt = ?");
+			params.push(record.prompt);
+		}
+		if (record.metadata !== undefined) {
+			fields.push("metadata_json = ?");
+			params.push(record.metadata ? JSON.stringify(record.metadata) : null);
+		}
+		if (record.parentSessionId !== undefined) {
+			fields.push("parent_session_id = ?");
+			params.push(record.parentSessionId);
+		}
+		if (record.parentAgentId !== undefined) {
+			fields.push("parent_agent_id = ?");
+			params.push(record.parentAgentId);
+		}
+		if (record.agentId !== undefined) {
+			fields.push("agent_id = ?");
+			params.push(record.agentId);
+		}
+		if (record.conversationId !== undefined) {
+			fields.push("conversation_id = ?");
+			params.push(record.conversationId);
+		}
+		if (fields.length === 0) {
+			return;
+		}
+		fields.push("updated_at = ?");
+		params.push(nowIso());
+		params.push(record.sessionId);
+		this.run(
+			`UPDATE sessions SET ${fields.join(", ")} WHERE session_id = ?`,
+			params,
+		);
+	}
+
+	updateStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): void {
+		this.update({
+			sessionId,
+			status,
+			endedAt: isNonTerminalSessionStatus(status) ? null : nowIso(),
+			exitCode: isNonTerminalSessionStatus(status)
+				? null
+				: (exitCode ?? (status === "failed" ? 1 : 0)),
+		});
+	}
+
+	get(sessionId: string): SessionRecord | undefined {
+		const row = this.queryOne<Record<string, unknown>>(
+			`SELECT session_id, source, pid, started_at, ended_at, exit_code, status, interactive,
+				provider, model, cwd, workspace_root, team_name,
+				enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent,
+				prompt, metadata_json, hook_path, messages_path, updated_at
+			 FROM sessions WHERE session_id = ?`,
+			[sessionId],
+		);
+		if (!row) {
+			return undefined;
+		}
+		return {
+			sessionId: asString(row.session_id),
+			source: asString(row.source) as SessionRecord["source"],
+			pid: Number(row.pid ?? 0),
+			startedAt: asString(row.started_at),
+			endedAt: (row.ended_at as string | null | undefined) ?? null,
+			exitCode: (row.exit_code as number | null | undefined) ?? null,
+			status: asString(row.status) as SessionRecord["status"],
+			interactive: asBool(row.interactive),
+			provider: asString(row.provider),
+			model: asString(row.model),
+			cwd: asString(row.cwd),
+			workspaceRoot: asString(row.workspace_root),
+			teamName: asOptionalString(row.team_name),
+			enableTools: asBool(row.enable_tools),
+			enableSpawn: asBool(row.enable_spawn),
+			enableTeams: asBool(row.enable_teams),
+			parentSessionId: asOptionalString(row.parent_session_id),
+			parentAgentId: asOptionalString(row.parent_agent_id),
+			agentId: asOptionalString(row.agent_id),
+			conversationId: asOptionalString(row.conversation_id),
+			isSubagent: asBool(row.is_subagent),
+			prompt: asOptionalString(row.prompt),
+			metadata: (() => {
+				const raw = asOptionalString(row.metadata_json);
+				if (!raw) {
+					return undefined;
+				}
+				try {
+					const parsed = JSON.parse(raw) as unknown;
+					if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+						return parsed as Record<string, unknown>;
+					}
+				} catch {
+					// Ignore malformed metadata payloads.
+				}
+				return undefined;
+			})(),
+			hookPath: asOptionalString(row.hook_path),
+			messagesPath: asOptionalString(row.messages_path),
+			updatedAt: asOptionalString(row.updated_at) ?? nowIso(),
+		};
+	}
+
+	list(limit = 200): SessionRecord[] {
+		const rows = this.queryAll<Record<string, unknown>>(
+			`SELECT session_id FROM sessions ORDER BY started_at DESC LIMIT ?`,
+			[limit],
+		);
+		const result: SessionRecord[] = [];
+		for (const row of rows) {
+			const item = this.get(asString(row.session_id));
+			if (item) {
+				result.push(item);
+			}
+		}
+		return result;
+	}
+
+	delete(sessionId: string, cascade = false): boolean {
+		const changed =
+			this.run(`DELETE FROM sessions WHERE session_id = ?`, [sessionId])
+				.changes ?? 0;
+		if (cascade) {
+			this.run(`DELETE FROM sessions WHERE parent_session_id = ?`, [sessionId]);
+		}
+		return changed > 0;
+	}
+}
diff --git a/sdk/packages/core/src/services/storage/sqlite-team-store.ts b/sdk/packages/core/src/services/storage/sqlite-team-store.ts
new file mode 100644
index 0000000..77e635a
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/sqlite-team-store.ts
@@ -0,0 +1,537 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import {
+	safeJsonParse,
+	type TeamRuntimeState,
+	type TeamTeammateSpec,
+} from "@cline/shared";
+import { loadSqliteDb, nowIso, type SqliteDb } from "@cline/shared/db";
+import { resolveDbDataDir } from "@cline/shared/storage";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+
+function defaultTeamDir(): string {
+	return resolveDbDataDir();
+}
+
+function sanitizeTeamName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+export interface SqliteTeamStoreOptions {
+	teamDir?: string;
+}
+
+export interface TeamRuntimeLoadResult {
+	state?: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+	interruptedRunIds: string[];
+}
+
+interface TeamSnapshotRow {
+	team_name: string;
+	state_json: string;
+	teammates_json: string;
+	updated_at: string;
+}
+
+interface TeamRunRow {
+	run_id: string;
+}
+
+function parseTeammatesJson(raw: string): TeamTeammateSpec[] {
+	const parsed = safeJsonParse<unknown>(raw);
+	if (!Array.isArray(parsed)) {
+		return [];
+	}
+	const out: TeamTeammateSpec[] = [];
+	for (const entry of parsed) {
+		if (!entry || typeof entry !== "object") {
+			continue;
+		}
+		const rec = entry as Record<string, unknown>;
+		const agentId = rec.agentId;
+		const rolePrompt = rec.rolePrompt;
+		if (typeof agentId !== "string" || !agentId.trim()) {
+			continue;
+		}
+		if (typeof rolePrompt !== "string" || !rolePrompt.trim()) {
+			continue;
+		}
+		const spec: TeamTeammateSpec = {
+			agentId: agentId.trim(),
+			rolePrompt,
+		};
+		if (typeof rec.modelId === "string" && rec.modelId.trim()) {
+			spec.modelId = rec.modelId.trim();
+		}
+		if (
+			typeof rec.maxIterations === "number" &&
+			Number.isFinite(rec.maxIterations)
+		) {
+			spec.maxIterations = Math.max(1, Math.floor(rec.maxIterations));
+		}
+		out.push(spec);
+	}
+	return out;
+}
+
+function reviveTeamRuntimeStateDates(
+	state: TeamRuntimeState,
+): TeamRuntimeState {
+	return {
+		...state,
+		tasks: state.tasks.map((task) => ({
+			...task,
+			createdAt: new Date(task.createdAt),
+			updatedAt: new Date(task.updatedAt),
+		})),
+		mailbox: state.mailbox.map((message) => ({
+			...message,
+			sentAt: new Date(message.sentAt),
+			readAt: message.readAt ? new Date(message.readAt) : undefined,
+		})),
+		missionLog: state.missionLog.map((entry) => ({
+			...entry,
+			ts: new Date(entry.ts),
+		})),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			startedAt: new Date(run.startedAt),
+			endedAt: run.endedAt ? new Date(run.endedAt) : undefined,
+			nextAttemptAt: run.nextAttemptAt
+				? new Date(run.nextAttemptAt)
+				: undefined,
+			heartbeatAt: run.heartbeatAt ? new Date(run.heartbeatAt) : undefined,
+		})),
+		outcomes: (state.outcomes ?? []).map((outcome) => ({
+			...outcome,
+			createdAt: new Date(outcome.createdAt),
+			finalizedAt: outcome.finalizedAt
+				? new Date(outcome.finalizedAt)
+				: undefined,
+		})),
+		outcomeFragments: (state.outcomeFragments ?? []).map((fragment) => ({
+			...fragment,
+			createdAt: new Date(fragment.createdAt),
+			reviewedAt: fragment.reviewedAt
+				? new Date(fragment.reviewedAt)
+				: undefined,
+		})),
+	};
+}
+
+export class SqliteTeamStore implements TeamStore {
+	private readonly teamDirPath: string;
+	private db: SqliteDb | undefined;
+
+	constructor(options: SqliteTeamStoreOptions = {}) {
+		this.teamDirPath = options.teamDir ?? defaultTeamDir();
+	}
+
+	init(): void {
+		this.getRawDb();
+	}
+
+	private ensureTeamDir(): string {
+		if (!existsSync(this.teamDirPath)) {
+			mkdirSync(this.teamDirPath, { recursive: true });
+		}
+		return this.teamDirPath;
+	}
+
+	private dbPath(): string {
+		return join(this.ensureTeamDir(), "teams.db");
+	}
+
+	private getRawDb(): SqliteDb {
+		if (this.db) {
+			return this.db;
+		}
+		const db = loadSqliteDb(this.dbPath());
+		this.ensureSchema(db);
+		this.db = db;
+		return db;
+	}
+
+	private ensureSchema(db: SqliteDb): void {
+		db.exec("PRAGMA journal_mode = WAL;");
+		db.exec("PRAGMA busy_timeout = 5000;");
+		// Single-row table so ALTER-based upgrades can run in order (baseline = 1).
+		// Session/schedule schemas use separate migration paths in @cline/shared.
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_store_schema_version (
+				lock INTEGER PRIMARY KEY CHECK (lock = 1),
+				version INTEGER NOT NULL
+			);
+		`);
+		const versionRow = db
+			.prepare("SELECT version FROM team_store_schema_version WHERE lock = 1")
+			.get() as { version: number } | null;
+		if (!versionRow) {
+			db.prepare(
+				"INSERT INTO team_store_schema_version (lock, version) VALUES (1, 1)",
+			).run();
+		}
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_events (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				team_name TEXT NOT NULL,
+				ts TEXT NOT NULL,
+				event_type TEXT NOT NULL,
+				payload_json TEXT NOT NULL,
+				causation_id TEXT,
+				correlation_id TEXT
+			);
+		`);
+		db.exec(`
+			CREATE INDEX IF NOT EXISTS idx_team_events_name_ts
+				ON team_events(team_name, ts DESC);
+		`);
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_runtime_snapshot (
+				team_name TEXT PRIMARY KEY,
+				state_json TEXT NOT NULL,
+				teammates_json TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			);
+		`);
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_tasks (
+				team_name TEXT NOT NULL,
+				task_id TEXT NOT NULL,
+				title TEXT NOT NULL,
+				description TEXT NOT NULL,
+				status TEXT NOT NULL,
+				assignee TEXT,
+				depends_on_json TEXT NOT NULL,
+				summary TEXT,
+				version INTEGER NOT NULL DEFAULT 1,
+				updated_at TEXT NOT NULL,
+				PRIMARY KEY(team_name, task_id)
+			);
+		`);
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_runs (
+				team_name TEXT NOT NULL,
+				run_id TEXT NOT NULL,
+				agent_id TEXT NOT NULL,
+				task_id TEXT,
+				status TEXT NOT NULL,
+				message TEXT NOT NULL,
+				started_at TEXT,
+				ended_at TEXT,
+				error TEXT,
+				lease_owner TEXT,
+				heartbeat_at TEXT,
+				version INTEGER NOT NULL DEFAULT 1,
+				PRIMARY KEY(team_name, run_id)
+			);
+		`);
+		db.exec(`
+			CREATE INDEX IF NOT EXISTS idx_team_runs_status
+				ON team_runs(team_name, status);
+		`);
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_outcomes (
+				team_name TEXT NOT NULL,
+				outcome_id TEXT NOT NULL,
+				title TEXT NOT NULL,
+				status TEXT NOT NULL,
+				schema_json TEXT NOT NULL,
+				finalized_at TEXT,
+				version INTEGER NOT NULL DEFAULT 1,
+				PRIMARY KEY(team_name, outcome_id)
+			);
+		`);
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS team_outcome_fragments (
+				team_name TEXT NOT NULL,
+				outcome_id TEXT NOT NULL,
+				fragment_id TEXT NOT NULL,
+				section TEXT NOT NULL,
+				source_agent_id TEXT NOT NULL,
+				source_run_id TEXT,
+				content TEXT NOT NULL,
+				status TEXT NOT NULL,
+				reviewed_by TEXT,
+				reviewed_at TEXT,
+				version INTEGER NOT NULL DEFAULT 1,
+				PRIMARY KEY(team_name, fragment_id)
+			);
+		`);
+	}
+
+	private run(sql: string, params: unknown[] = []): { changes?: number } {
+		return this.getRawDb()
+			.prepare(sql)
+			.run(...params);
+	}
+
+	private queryOne<T>(sql: string, params: unknown[] = []): T | undefined {
+		const row = this.getRawDb()
+			.prepare(sql)
+			.get(...params);
+		return (row as T | null) ?? undefined;
+	}
+
+	private queryAll<T>(sql: string, params: unknown[] = []): T[] {
+		return this.getRawDb()
+			.prepare(sql)
+			.all(...params) as T[];
+	}
+
+	/** Runs `work` in a single SQLite transaction (rollback on any error). */
+	private withTransaction(work: () => void): void {
+		const db = this.getRawDb();
+		db.exec("BEGIN IMMEDIATE;");
+		try {
+			work();
+			db.exec("COMMIT;");
+		} catch (error) {
+			try {
+				db.exec("ROLLBACK;");
+			} catch {
+				// ignore secondary failure
+			}
+			throw error;
+		}
+	}
+
+	listTeamNames(): string[] {
+		return this.queryAll<{ team_name: string }>(
+			`SELECT team_name FROM team_runtime_snapshot ORDER BY team_name ASC`,
+		).map((row) => row.team_name);
+	}
+
+	readState(teamName: string): TeamRuntimeState | undefined {
+		const row = this.queryOne<TeamSnapshotRow>(
+			`SELECT team_name, state_json, teammates_json, updated_at FROM team_runtime_snapshot WHERE team_name = ?`,
+			[sanitizeTeamName(teamName)],
+		);
+		if (!row) {
+			return undefined;
+		}
+		const parsed = safeJsonParse<TeamRuntimeState>(row.state_json);
+		if (!parsed) {
+			return undefined;
+		}
+		try {
+			return reviveTeamRuntimeStateDates(parsed);
+		} catch {
+			return undefined;
+		}
+	}
+
+	readHistory(teamName: string, limit = 200): unknown[] {
+		return this.queryAll<{
+			event_type: string;
+			payload_json: string;
+			ts: string;
+		}>(
+			`SELECT event_type, payload_json, ts FROM team_events WHERE team_name = ? ORDER BY id DESC LIMIT ?`,
+			[sanitizeTeamName(teamName), limit],
+		).flatMap((row) => {
+			try {
+				return [
+					{
+						eventType: row.event_type,
+						payload: JSON.parse(row.payload_json),
+						ts: row.ts,
+					},
+				];
+			} catch {
+				return [];
+			}
+		});
+	}
+
+	loadRuntime(teamName: string): TeamRuntimeLoadResult {
+		const safeTeamName = sanitizeTeamName(teamName);
+		const state = this.readState(safeTeamName);
+		const snapshotRow = this.queryOne<TeamSnapshotRow>(
+			`SELECT team_name, state_json, teammates_json, updated_at FROM team_runtime_snapshot WHERE team_name = ?`,
+			[safeTeamName],
+		);
+		const teammates = snapshotRow
+			? parseTeammatesJson(snapshotRow.teammates_json)
+			: [];
+		return {
+			state,
+			teammates,
+			interruptedRunIds: [],
+		};
+	}
+
+	appendTeamEvent(
+		teamName: string,
+		eventType: string,
+		payload: unknown,
+		correlationId?: string,
+	): void {
+		this.run(
+			`INSERT INTO team_events (team_name, ts, event_type, payload_json, causation_id, correlation_id)
+			 VALUES (?, ?, ?, ?, NULL, ?)`,
+			[
+				sanitizeTeamName(teamName),
+				nowIso(),
+				eventType,
+				JSON.stringify(payload),
+				correlationId ?? null,
+			],
+		);
+	}
+
+	persistRuntime(
+		teamName: string,
+		state: TeamRuntimeState,
+		teammates: TeamTeammateSpec[],
+	): void {
+		const safeTeamName = sanitizeTeamName(teamName);
+		const now = nowIso();
+		this.withTransaction(() => {
+			this.run(
+				`INSERT INTO team_runtime_snapshot (team_name, state_json, teammates_json, updated_at)
+				 VALUES (?, ?, ?, ?)
+				 ON CONFLICT(team_name) DO UPDATE SET
+					state_json = excluded.state_json,
+					teammates_json = excluded.teammates_json,
+					updated_at = excluded.updated_at`,
+				[safeTeamName, JSON.stringify(state), JSON.stringify(teammates), now],
+			);
+
+			for (const task of state.tasks) {
+				this.run(
+					`INSERT INTO team_tasks (team_name, task_id, title, description, status, assignee, depends_on_json, summary, version, updated_at)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?)
+					 ON CONFLICT(team_name, task_id) DO UPDATE SET
+						title = excluded.title,
+						description = excluded.description,
+						status = excluded.status,
+						assignee = excluded.assignee,
+						depends_on_json = excluded.depends_on_json,
+						summary = excluded.summary,
+						version = team_tasks.version + 1,
+						updated_at = excluded.updated_at`,
+					[
+						safeTeamName,
+						task.id,
+						task.title,
+						task.description,
+						task.status,
+						task.assignee ?? null,
+						JSON.stringify(task.dependsOn ?? []),
+						task.summary ?? null,
+						task.updatedAt.toISOString(),
+					],
+				);
+			}
+
+			for (const run of state.runs ?? []) {
+				this.run(
+					`INSERT INTO team_runs (team_name, run_id, agent_id, task_id, status, message, started_at, ended_at, error, lease_owner, heartbeat_at, version)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+					 ON CONFLICT(team_name, run_id) DO UPDATE SET
+						agent_id = excluded.agent_id,
+						task_id = excluded.task_id,
+						status = excluded.status,
+						message = excluded.message,
+						started_at = excluded.started_at,
+						ended_at = excluded.ended_at,
+						error = excluded.error,
+						lease_owner = excluded.lease_owner,
+						heartbeat_at = excluded.heartbeat_at,
+						version = team_runs.version + 1`,
+					[
+						safeTeamName,
+						run.id,
+						run.agentId,
+						run.taskId ?? null,
+						run.status,
+						run.message,
+						run.startedAt ? run.startedAt.toISOString() : null,
+						run.endedAt ? run.endedAt.toISOString() : null,
+						run.error ?? null,
+						run.leaseOwner ?? null,
+						run.heartbeatAt ? run.heartbeatAt.toISOString() : null,
+					],
+				);
+			}
+
+			for (const outcome of state.outcomes ?? []) {
+				this.run(
+					`INSERT INTO team_outcomes (team_name, outcome_id, title, status, schema_json, finalized_at, version)
+					 VALUES (?, ?, ?, ?, ?, ?, 1)
+					 ON CONFLICT(team_name, outcome_id) DO UPDATE SET
+						title = excluded.title,
+						status = excluded.status,
+						schema_json = excluded.schema_json,
+						finalized_at = excluded.finalized_at,
+						version = team_outcomes.version + 1`,
+					[
+						safeTeamName,
+						outcome.id,
+						outcome.title,
+						outcome.status,
+						JSON.stringify({ requiredSections: outcome.requiredSections }),
+						outcome.finalizedAt ? outcome.finalizedAt.toISOString() : null,
+					],
+				);
+			}
+
+			for (const fragment of state.outcomeFragments ?? []) {
+				this.run(
+					`INSERT INTO team_outcome_fragments (team_name, outcome_id, fragment_id, section, source_agent_id, source_run_id, content, status, reviewed_by, reviewed_at, version)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+					 ON CONFLICT(team_name, fragment_id) DO UPDATE SET
+						outcome_id = excluded.outcome_id,
+						section = excluded.section,
+						source_agent_id = excluded.source_agent_id,
+						source_run_id = excluded.source_run_id,
+						content = excluded.content,
+						status = excluded.status,
+						reviewed_by = excluded.reviewed_by,
+						reviewed_at = excluded.reviewed_at,
+						version = team_outcome_fragments.version + 1`,
+					[
+						safeTeamName,
+						fragment.outcomeId,
+						fragment.id,
+						fragment.section,
+						fragment.sourceAgentId,
+						fragment.sourceRunId ?? null,
+						fragment.content,
+						fragment.status,
+						fragment.reviewedBy ?? null,
+						fragment.reviewedAt ? fragment.reviewedAt.toISOString() : null,
+					],
+				);
+			}
+		});
+	}
+
+	markInProgressRunsInterrupted(teamName: string, reason: string): string[] {
+		const safeTeamName = sanitizeTeamName(teamName);
+		const rows = this.queryAll<TeamRunRow>(
+			`SELECT run_id FROM team_runs WHERE team_name = ? AND status IN ('queued', 'running')`,
+			[safeTeamName],
+		);
+		if (rows.length === 0) {
+			return [];
+		}
+		const now = nowIso();
+		this.run(
+			`UPDATE team_runs SET status = 'interrupted', error = ?, ended_at = ?, version = version + 1
+			 WHERE team_name = ? AND status IN ('queued', 'running')`,
+			[reason, now, safeTeamName],
+		);
+		return rows.map((row) => row.run_id);
+	}
+
+	handleTeamEvent(teamName: string, event: TeamEvent): void {
+		this.appendTeamEvent(teamName, event.type, event);
+	}
+}
diff --git a/sdk/packages/core/src/services/storage/team-store.ts b/sdk/packages/core/src/services/storage/team-store.ts
new file mode 100644
index 0000000..5b8a122
--- /dev/null
+++ b/sdk/packages/core/src/services/storage/team-store.ts
@@ -0,0 +1,36 @@
+export type { TeamStore } from "../../types/storage";
+export {
+	FileTeamStore,
+	type FileTeamStoreOptions,
+} from "./file-team-store";
+export {
+	SqliteTeamStore,
+	type SqliteTeamStoreOptions,
+} from "./sqlite-team-store";
+
+import { FileTeamStore } from "./file-team-store";
+import {
+	SqliteTeamStore,
+	type SqliteTeamStoreOptions,
+} from "./sqlite-team-store";
+
+export function createLocalTeamStore(options: SqliteTeamStoreOptions = {}): {
+	init(): void;
+	listTeamNames(): string[];
+	readState(teamName: string): ReturnType<FileTeamStore["readState"]>;
+	readHistory(teamName: string, limit?: number): unknown[];
+	loadRuntime(teamName: string): ReturnType<FileTeamStore["loadRuntime"]>;
+	handleTeamEvent: FileTeamStore["handleTeamEvent"];
+	persistRuntime: FileTeamStore["persistRuntime"];
+	markInProgressRunsInterrupted: FileTeamStore["markInProgressRunsInterrupted"];
+} {
+	try {
+		const store = new SqliteTeamStore(options);
+		store.init();
+		return store;
+	} catch {
+		const store = new FileTeamStore({ teamDir: options.teamDir });
+		store.init();
+		return store;
+	}
+}
diff --git a/sdk/packages/core/src/services/telemetry/ITelemetryAdapter.ts b/sdk/packages/core/src/services/telemetry/ITelemetryAdapter.ts
new file mode 100644
index 0000000..98e0b5a
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/ITelemetryAdapter.ts
@@ -0,0 +1,94 @@
+/**
+ * Telemetry adapter interface for the @cline/core SDK.
+ *
+ * This is the SDK-side counterpart to the extension's ITelemetryProvider.
+ * It is intentionally free of VS Code / host-provider dependencies so that
+ * any consumer (CLI, tests, third-party integrations) can plug in their own
+ * backend without pulling in the full extension runtime.
+ */
+
+import type { TelemetryProperties } from "@cline/shared";
+
+export type {
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+} from "@cline/shared";
+
+// ---------------------------------------------------------------------------
+// Adapter interface
+// ---------------------------------------------------------------------------
+
+/**
+ * Telemetry adapter that an SDK consumer implements (or uses via the
+ * provided {@link OpenTelemetryAdapter}) to receive Cline telemetry events.
+ *
+ * The interface intentionally mirrors ITelemetryProvider from the extension
+ * so that shared logic can be re-used or compared easily.
+ */
+export interface ITelemetryAdapter {
+	/** Human-readable adapter name used for logging / diagnostics. */
+	readonly name: string;
+
+	/**
+	 * Emit a standard telemetry event.
+	 * Implementations may silently drop events when telemetry is disabled.
+	 */
+	emit(event: string, properties?: TelemetryProperties): void;
+
+	/**
+	 * Emit a *required* telemetry event that must not be suppressed by
+	 * user opt-out settings (e.g. final opt-out confirmation events).
+	 */
+	emitRequired(event: string, properties?: TelemetryProperties): void;
+
+	/**
+	 * Record a monotonically-increasing counter metric.
+	 * Implementations that do not support metrics may treat this as a no-op.
+	 */
+	recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+
+	/**
+	 * Record a histogram (distribution) metric.
+	 * Implementations that do not support metrics may treat this as a no-op.
+	 */
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+
+	/**
+	 * Record a gauge (point-in-time) metric.
+	 * Pass `null` as `value` to retire the series identified by
+	 * `name + attributes` and prevent stale gauge entries.
+	 * Implementations that do not support metrics may treat this as a no-op.
+	 */
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+
+	/** Returns whether the adapter is currently accepting events. */
+	isEnabled(): boolean;
+
+	/** Flush any buffered events/metrics to the backend. */
+	flush(): Promise<void>;
+
+	/** Release all resources held by the adapter. */
+	dispose(): Promise<void>;
+}
diff --git a/sdk/packages/core/src/services/telemetry/OpenTelemetryAdapter.test.ts b/sdk/packages/core/src/services/telemetry/OpenTelemetryAdapter.test.ts
new file mode 100644
index 0000000..98bba87
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/OpenTelemetryAdapter.test.ts
@@ -0,0 +1,157 @@
+import type { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { MeterProvider } from "@opentelemetry/sdk-metrics";
+import { describe, expect, it, vi } from "vitest";
+import { OpenTelemetryAdapter } from "./OpenTelemetryAdapter";
+
+describe("OpenTelemetryAdapter", () => {
+	it("emits events in the telemetry service log format", () => {
+		const emit = vi.fn();
+		const adapter = new OpenTelemetryAdapter({
+			metadata: makeMetadata(),
+			distinctId: "user-123",
+			commonProperties: {
+				organization_id: "org-1",
+			},
+			loggerProvider: {
+				getLogger: () => ({ emit }),
+			} as unknown as LoggerProvider,
+		});
+
+		adapter.emit("task.created", {
+			ulid: "01HXYZ",
+			nested: {
+				mode: "act",
+			},
+			items: ["a", "b"],
+			nullable: null,
+		});
+
+		expect(emit).toHaveBeenCalledWith({
+			severityText: "INFO",
+			body: "task.created",
+			attributes: expect.objectContaining({
+				ulid: "01HXYZ",
+				"nested.mode": "act",
+				items: JSON.stringify(["a", "b"]),
+				nullable: "null",
+				distinct_id: "user-123",
+				organization_id: "org-1",
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+			}),
+		});
+	});
+
+	it("marks required events with the expected flag", () => {
+		const emit = vi.fn();
+		const adapter = new OpenTelemetryAdapter({
+			metadata: makeMetadata(),
+			loggerProvider: {
+				getLogger: () => ({ emit }),
+			} as unknown as LoggerProvider,
+			enabled: false,
+		});
+
+		adapter.emitRequired("user.opt_out");
+
+		expect(emit).toHaveBeenCalledWith({
+			severityText: "INFO",
+			body: "user.opt_out",
+			attributes: expect.objectContaining({
+				_required: true,
+			}),
+		});
+	});
+
+	it("records metrics with merged telemetry attributes and retires gauge series", () => {
+		const counterAdd = vi.fn();
+		const histogramRecord = vi.fn();
+		let gaugeCallback:
+			| ((result: {
+					observe: (
+						value: number,
+						attributes?: Record<string, string | number | boolean>,
+					) => void;
+			  }) => void)
+			| undefined;
+
+		const forceFlush = vi.fn().mockResolvedValue(undefined);
+		const shutdown = vi.fn().mockResolvedValue(undefined);
+
+		const adapter = new OpenTelemetryAdapter({
+			metadata: makeMetadata(),
+			distinctId: "user-123",
+			meterProvider: {
+				getMeter: () =>
+					({
+						createCounter: () => ({ add: counterAdd }),
+						createHistogram: () => ({ record: histogramRecord }),
+						createObservableGauge: () => ({
+							addCallback: (callback: typeof gaugeCallback) => {
+								gaugeCallback = callback;
+							},
+						}),
+					}) as never,
+				forceFlush,
+				shutdown,
+			} as unknown as MeterProvider,
+		});
+
+		adapter.recordCounter("cline.turns.total", 2, { ulid: "01HXYZ" });
+		adapter.recordHistogram("cline.api.duration.seconds", 1.5, {
+			ulid: "01HXYZ",
+		});
+		adapter.recordGauge("cline.workspace.active_roots", 3, { workspace: "a" });
+
+		expect(counterAdd).toHaveBeenCalledWith(
+			2,
+			expect.objectContaining({
+				ulid: "01HXYZ",
+				distinct_id: "user-123",
+				extension_version: "1.2.3",
+			}),
+		);
+		expect(histogramRecord).toHaveBeenCalledWith(
+			1.5,
+			expect.objectContaining({
+				ulid: "01HXYZ",
+				distinct_id: "user-123",
+			}),
+		);
+
+		const observe = vi.fn();
+		gaugeCallback?.({ observe });
+		expect(observe).toHaveBeenCalledWith(
+			3,
+			expect.objectContaining({
+				workspace: "a",
+				distinct_id: "user-123",
+			}),
+		);
+
+		adapter.recordGauge("cline.workspace.active_roots", null, {
+			workspace: "a",
+		});
+		const observeAfterRetire = vi.fn();
+		gaugeCallback?.({ observe: observeAfterRetire });
+		expect(observeAfterRetire).not.toHaveBeenCalled();
+
+		return Promise.all([adapter.flush(), adapter.dispose()]).then(() => {
+			expect(forceFlush).toHaveBeenCalledTimes(1);
+			expect(shutdown).toHaveBeenCalledTimes(1);
+		});
+	});
+});
+
+function makeMetadata() {
+	return {
+		extension_version: "1.2.3",
+		cline_type: "cli",
+		platform: "terminal",
+		platform_version: "1.0.0",
+		os_type: "darwin",
+		os_version: "24.0.0",
+		is_dev: "true",
+	};
+}
diff --git a/sdk/packages/core/src/services/telemetry/OpenTelemetryAdapter.ts b/sdk/packages/core/src/services/telemetry/OpenTelemetryAdapter.ts
new file mode 100644
index 0000000..ac0c4f0
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/OpenTelemetryAdapter.ts
@@ -0,0 +1,348 @@
+import type { Meter } from "@opentelemetry/api";
+import type { Logger as OpenTelemetryLogger } from "@opentelemetry/api-logs";
+import type { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { MeterProvider } from "@opentelemetry/sdk-metrics";
+import type {
+	ITelemetryAdapter,
+	TelemetryMetadata,
+	TelemetryPrimitive,
+	TelemetryProperties,
+} from "./ITelemetryAdapter";
+
+type FlatTelemetryAttributes = Record<string, string | number | boolean>;
+
+export interface OpenTelemetryAdapterOptions {
+	readonly metadata: TelemetryMetadata;
+	readonly meterProvider?: MeterProvider | null;
+	readonly loggerProvider?: LoggerProvider | null;
+	readonly name?: string;
+	readonly enabled?: boolean | (() => boolean);
+	readonly distinctId?: string;
+	readonly commonProperties?: TelemetryProperties;
+}
+
+export class OpenTelemetryAdapter implements ITelemetryAdapter {
+	readonly name: string;
+
+	private readonly metadata: TelemetryMetadata;
+	private readonly meter: Meter | null;
+	private readonly logger: OpenTelemetryLogger | null;
+	private readonly enabled: boolean | (() => boolean);
+	private distinctId?: string;
+	private commonProperties: TelemetryProperties;
+	private counters = new Map<string, ReturnType<Meter["createCounter"]>>();
+	private histograms = new Map<string, ReturnType<Meter["createHistogram"]>>();
+	private gauges = new Map<
+		string,
+		ReturnType<Meter["createObservableGauge"]>
+	>();
+	private gaugeValues = new Map<
+		string,
+		Map<string, { value: number; attributes?: TelemetryProperties }>
+	>();
+	private readonly meterProvider?: MeterProvider | null;
+	private readonly loggerProvider?: LoggerProvider | null;
+
+	constructor(options: OpenTelemetryAdapterOptions) {
+		this.name = options.name ?? "OpenTelemetryAdapter";
+		this.metadata = { ...options.metadata };
+		this.meterProvider = options.meterProvider;
+		this.loggerProvider = options.loggerProvider;
+		this.meter = options.meterProvider?.getMeter("cline") ?? null;
+		this.logger = options.loggerProvider?.getLogger("cline") ?? null;
+		this.enabled = options.enabled ?? true;
+		this.distinctId = options.distinctId;
+		this.commonProperties = options.commonProperties
+			? { ...options.commonProperties }
+			: {};
+	}
+
+	emit(event: string, properties?: TelemetryProperties): void {
+		if (!this.isEnabled()) {
+			return;
+		}
+		this.emitLog(event, properties, false);
+	}
+
+	emitRequired(event: string, properties?: TelemetryProperties): void {
+		this.emitLog(event, properties, true);
+	}
+
+	recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.meter || (!required && !this.isEnabled())) {
+			return;
+		}
+
+		let counter = this.counters.get(name);
+		if (!counter) {
+			counter = this.meter.createCounter(
+				name,
+				description ? { description } : undefined,
+			);
+			this.counters.set(name, counter);
+		}
+
+		counter.add(
+			value,
+			this.flattenProperties(this.buildAttributes(attributes)),
+		);
+	}
+
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.meter || (!required && !this.isEnabled())) {
+			return;
+		}
+
+		let histogram = this.histograms.get(name);
+		if (!histogram) {
+			histogram = this.meter.createHistogram(
+				name,
+				description ? { description } : undefined,
+			);
+			this.histograms.set(name, histogram);
+		}
+
+		histogram.record(
+			value,
+			this.flattenProperties(this.buildAttributes(attributes)),
+		);
+	}
+
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		if (!this.meter || (!required && !this.isEnabled())) {
+			return;
+		}
+
+		const mergedAttributes = this.buildAttributes(attributes);
+		const attrKey = JSON.stringify(mergedAttributes);
+		const existingSeries = this.gaugeValues.get(name);
+
+		if (value === null) {
+			if (existingSeries) {
+				existingSeries.delete(attrKey);
+				if (existingSeries.size === 0) {
+					this.gaugeValues.delete(name);
+					this.gauges.delete(name);
+				}
+			}
+			return;
+		}
+
+		let series = existingSeries;
+		if (!series) {
+			series = new Map();
+			this.gaugeValues.set(name, series);
+		}
+
+		if (!this.gauges.has(name)) {
+			const gauge = this.meter.createObservableGauge(
+				name,
+				description ? { description } : undefined,
+			);
+			gauge.addCallback((observableResult) => {
+				for (const data of this.snapshotGaugeSeries(name)) {
+					observableResult.observe(
+						data.value,
+						this.flattenProperties(data.attributes),
+					);
+				}
+			});
+			this.gauges.set(name, gauge);
+		}
+
+		series.set(attrKey, { value, attributes: mergedAttributes });
+	}
+
+	isEnabled(): boolean {
+		return typeof this.enabled === "function" ? this.enabled() : this.enabled;
+	}
+
+	setDistinctId(distinctId?: string): void {
+		this.distinctId = distinctId;
+	}
+
+	setCommonProperties(properties: TelemetryProperties): void {
+		this.commonProperties = { ...properties };
+	}
+
+	updateCommonProperties(properties: TelemetryProperties): void {
+		this.commonProperties = {
+			...this.commonProperties,
+			...properties,
+		};
+	}
+
+	async flush(): Promise<void> {
+		await Promise.all([
+			this.meterProvider?.forceFlush?.(),
+			this.loggerProvider?.forceFlush?.(),
+		]);
+	}
+
+	async dispose(): Promise<void> {
+		await Promise.all([
+			this.meterProvider?.shutdown?.(),
+			this.loggerProvider?.shutdown?.(),
+		]);
+	}
+
+	private emitLog(
+		event: string,
+		properties: TelemetryProperties | undefined,
+		required: boolean,
+	): void {
+		if (!this.logger) {
+			return;
+		}
+
+		const attributes = this.flattenProperties(
+			this.buildAttributes(properties, required),
+		);
+		this.logger.emit({
+			severityText: "INFO",
+			body: event,
+			attributes,
+		});
+	}
+
+	private buildAttributes(
+		properties?: TelemetryProperties,
+		required = false,
+	): TelemetryProperties {
+		return {
+			...this.commonProperties,
+			...this.metadata,
+			...properties,
+			...(this.distinctId ? { distinct_id: this.distinctId } : {}),
+			...(required ? { _required: true } : {}),
+		};
+	}
+
+	private snapshotGaugeSeries(
+		name: string,
+	): Array<{ value: number; attributes?: TelemetryProperties }> {
+		const series = this.gaugeValues.get(name);
+		if (!series) {
+			return [];
+		}
+		return Array.from(series.values(), (entry) => ({
+			value: entry.value,
+			attributes: entry.attributes ? { ...entry.attributes } : undefined,
+		}));
+	}
+
+	private flattenProperties(
+		properties?: TelemetryProperties,
+		prefix = "",
+		seen: WeakSet<object> = new WeakSet(),
+		depth = 0,
+	): FlatTelemetryAttributes {
+		if (!properties) {
+			return {};
+		}
+
+		const flattened: FlatTelemetryAttributes = {};
+		const maxArraySize = 100;
+		const maxDepth = 10;
+
+		for (const [key, value] of Object.entries(properties)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") {
+				continue;
+			}
+
+			const fullKey = prefix ? `${prefix}.${key}` : key;
+
+			if (value === null || value === undefined) {
+				flattened[fullKey] = String(value);
+				continue;
+			}
+
+			if (Array.isArray(value)) {
+				const limited =
+					value.length > maxArraySize ? value.slice(0, maxArraySize) : value;
+				try {
+					flattened[fullKey] = JSON.stringify(limited);
+				} catch {
+					flattened[fullKey] = "[UnserializableArray]";
+				}
+				if (value.length > maxArraySize) {
+					flattened[`${fullKey}_truncated`] = true;
+					flattened[`${fullKey}_original_length`] = value.length;
+				}
+				continue;
+			}
+
+			if (typeof value === "object") {
+				if (value instanceof Date) {
+					flattened[fullKey] = value.toISOString();
+					continue;
+				}
+				if (value instanceof Error) {
+					flattened[fullKey] = value.message;
+					continue;
+				}
+				if (seen.has(value)) {
+					flattened[fullKey] = "[Circular]";
+					continue;
+				}
+				if (depth >= maxDepth) {
+					flattened[fullKey] = "[MaxDepthExceeded]";
+					continue;
+				}
+
+				seen.add(value);
+				Object.assign(
+					flattened,
+					this.flattenProperties(
+						value as TelemetryProperties,
+						fullKey,
+						seen,
+						depth + 1,
+					),
+				);
+				continue;
+			}
+
+			if (isTelemetryPrimitive(value)) {
+				flattened[fullKey] = value;
+				continue;
+			}
+
+			try {
+				flattened[fullKey] = JSON.stringify(value);
+			} catch {
+				flattened[fullKey] = String(value);
+			}
+		}
+
+		return flattened;
+	}
+}
+
+function isTelemetryPrimitive(
+	value: unknown,
+): value is Exclude<TelemetryPrimitive, null | undefined> {
+	return (
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean"
+	);
+}
diff --git a/sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.test.ts b/sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.test.ts
new file mode 100644
index 0000000..4f7df78
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.test.ts
@@ -0,0 +1,401 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { BasicLogger } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { writeGlobalSettings } from "../global-settings";
+import {
+	createConfiguredTelemetryService,
+	createOpenTelemetryTelemetryService,
+	OpenTelemetryProvider,
+} from "./OpenTelemetryProvider";
+import { TelemetryService } from "./TelemetryService";
+
+describe("createOpenTelemetryTelemetryService", () => {
+	const previousGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+	let tempRoot: string | undefined;
+
+	beforeEach(() => {
+		tempRoot = mkdtempSync(join(tmpdir(), "core-telemetry-settings-"));
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+	});
+
+	afterEach(() => {
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = previousGlobalSettingsPath;
+		if (tempRoot) {
+			rmSync(tempRoot, { recursive: true, force: true });
+			tempRoot = undefined;
+		}
+		vi.restoreAllMocks();
+	});
+
+	it("logs a provider creation event during bootstrap", async () => {
+		const captureRequired = vi
+			.spyOn(TelemetryService.prototype, "captureRequired")
+			.mockImplementation(() => {});
+
+		const { provider } = createOpenTelemetryTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			enabled: true,
+			logsExporter: "console",
+			metricsExporter: "otlp",
+			otlpProtocol: "http/json",
+			otlpEndpoint: "http://localhost:4318",
+			serviceName: "cline-cli",
+			serviceVersion: "1.2.3",
+		});
+
+		expect(captureRequired).toHaveBeenCalledWith(
+			"telemetry.provider_created",
+			expect.objectContaining({
+				provider: "opentelemetry",
+				enabled: true,
+				logsExporter: "console",
+				metricsExporter: "otlp",
+				otlpProtocol: "http/json",
+				hasOtlpEndpoint: true,
+				serviceName: "cline-cli",
+				serviceVersion: "1.2.3",
+			}),
+		);
+
+		await provider.dispose();
+	});
+
+	it("registers a tracer provider when tracesExporter is set", async () => {
+		const { provider } = createOpenTelemetryTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			enabled: true,
+			tracesExporter: "console",
+			logsExporter: "console",
+			metricsExporter: "console",
+			serviceName: "cline-test",
+		});
+
+		expect(provider.tracerProvider).not.toBeNull();
+		const span = provider.getTracer("test").startSpan("verify.tracing");
+		span.end();
+		await provider.dispose();
+	});
+
+	it("does not create an OTEL provider when disabled", () => {
+		const providerSpy = vi.spyOn(
+			OpenTelemetryProvider.prototype,
+			"createTelemetryService",
+		);
+
+		const { telemetry, provider } = createConfiguredTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			enabled: false,
+		});
+
+		expect(provider).toBeUndefined();
+		expect(providerSpy).not.toHaveBeenCalled();
+		expect(telemetry).toBeInstanceOf(TelemetryService);
+	});
+
+	it("does not create configured telemetry when globally opted out", () => {
+		writeGlobalSettings({ telemetryOptOut: true });
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const providerSpy = vi.spyOn(
+			OpenTelemetryProvider.prototype,
+			"createTelemetryService",
+		);
+
+		const { telemetry, provider } = createConfiguredTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			commonProperties: {
+				organization_id: "org-1",
+			},
+			distinctId: "distinct-1",
+			enabled: true,
+			logsExporter: "console",
+			logger,
+		});
+		telemetry.updateMetadata({ cline_type: "cli-updated" });
+		telemetry.updateCommonProperties({ member_id: "member-1" });
+
+		telemetry.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+
+		expect(provider).toBeUndefined();
+		expect(providerSpy).not.toHaveBeenCalled();
+		expect(telemetry.isEnabled()).toBe(false);
+		expect(Reflect.get(telemetry, "addAdapter")).toBeUndefined();
+		expect(Reflect.get(telemetry, "distinctId")).toBe("distinct-1");
+		expect(Reflect.get(telemetry, "metadata")).toEqual(
+			expect.objectContaining({
+				cline_type: "cli-updated",
+				platform: "terminal",
+			}),
+		);
+		expect(Reflect.get(telemetry, "commonProperties")).toEqual({
+			organization_id: "org-1",
+			member_id: "member-1",
+		});
+		expect(logger.log).not.toHaveBeenCalled();
+	});
+
+	it("preserves metadata when disabled", () => {
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+		const { telemetry } = createConfiguredTelemetryService({
+			metadata,
+			enabled: false,
+		});
+		const spy = vi.fn();
+		(Reflect.get(telemetry, "adapters") as unknown[]).push({
+			name: "test",
+			emit: spy,
+			emitRequired: spy,
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: async () => {},
+			dispose: async () => {},
+		});
+		telemetry.captureRequired("test.event", {});
+		expect(spy).toHaveBeenCalledWith(
+			"test.event",
+			expect.objectContaining({
+				cline_type: "kanban",
+				platform: "kanban",
+			}),
+		);
+	});
+
+	it("preserves metadata in the enabled (OTEL) path", async () => {
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+		const { telemetry, provider } = createOpenTelemetryTelemetryService({
+			metadata,
+			enabled: true,
+			logsExporter: "console",
+		});
+		const spy = vi.fn();
+		(Reflect.get(telemetry, "adapters") as unknown[]).push({
+			name: "test",
+			emit: spy,
+			emitRequired: spy,
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: async () => {},
+			dispose: async () => {},
+		});
+		telemetry.captureRequired("test.event", {});
+		expect(spy).toHaveBeenCalledWith(
+			"test.event",
+			expect.objectContaining({
+				cline_type: "kanban",
+				platform: "kanban",
+			}),
+		);
+		await provider.dispose();
+	});
+
+	it("delivers metadata to the OTEL logger without duplication", async () => {
+		const otelEmit = vi.fn();
+		const provider = new OpenTelemetryProvider({
+			enabled: true,
+		});
+		// Replace the loggerProvider with a mock so we can inspect emit calls
+		Reflect.set(provider, "loggerProvider", {
+			getLogger: () => ({ emit: otelEmit }),
+			forceFlush: async () => {},
+			shutdown: async () => {},
+		});
+
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+
+		const telemetry = provider.createTelemetryService({ metadata });
+
+		telemetry.captureRequired("test.otel_event", { custom_prop: "value" });
+
+		expect(otelEmit).toHaveBeenCalledTimes(1);
+		const emittedAttributes = otelEmit.mock.calls[0][0].attributes;
+
+		// Metadata fields must be present
+		expect(emittedAttributes).toMatchObject({
+			cline_type: "kanban",
+			platform: "kanban",
+			extension_version: "1.0.0",
+			custom_prop: "value",
+		});
+
+		// Verify no key appears more than once (flattened object can't have
+		// duplicate keys, but this guards against nested duplication patterns
+		// like metadata appearing under a sub-prefix)
+		const keys = Object.keys(emittedAttributes);
+		const metadataKeys = Object.keys(metadata);
+		for (const mk of metadataKeys) {
+			const occurrences = keys.filter((k) => k === mk || k.endsWith(`.${mk}`));
+			expect(
+				occurrences,
+				`metadata key "${mk}" should appear exactly once, found: ${occurrences.join(", ")}`,
+			).toHaveLength(1);
+		}
+
+		await provider.dispose();
+	});
+
+	it("propagates updateMetadata to OTEL logger output", async () => {
+		const otelEmit = vi.fn();
+		const provider = new OpenTelemetryProvider({
+			enabled: true,
+		});
+		Reflect.set(provider, "loggerProvider", {
+			getLogger: () => ({ emit: otelEmit }),
+			forceFlush: async () => {},
+			shutdown: async () => {},
+		});
+
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+
+		const telemetry = provider.createTelemetryService({ metadata });
+
+		// Update metadata after construction
+		telemetry.updateMetadata({ cline_type: "kanban-updated" });
+
+		telemetry.captureRequired("test.updated_event", {});
+
+		// The OTEL logger should see the updated value
+		const emittedAttributes =
+			otelEmit.mock.calls[otelEmit.mock.calls.length - 1][0].attributes;
+		expect(emittedAttributes.cline_type).toBe("kanban-updated");
+
+		await provider.dispose();
+	});
+
+	it("preserves logger when disabled", () => {
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const { telemetry } = createConfiguredTelemetryService({
+			metadata: {
+				extension_version: "1.0.0",
+				cline_type: "kanban",
+				platform: "kanban",
+				platform_version: "v22.0.0",
+				os_type: "darwin",
+				os_version: "15.0",
+			},
+			enabled: false,
+			logger,
+		});
+
+		telemetry.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+
+		expect(logger.log).toHaveBeenCalledWith(
+			"telemetry.event",
+			expect.objectContaining({
+				event: "session.started",
+			}),
+		);
+	});
+
+	it("attaches the logger adapter when creating configured telemetry", () => {
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const { telemetry, provider } = createConfiguredTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			enabled: true,
+			logsExporter: "console",
+			logger,
+		});
+
+		telemetry.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+
+		expect(logger.log).toHaveBeenCalledWith(
+			"telemetry.event",
+			expect.objectContaining({
+				event: "session.started",
+			}),
+		);
+
+		return provider?.dispose();
+	});
+});
diff --git a/sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.ts b/sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.ts
new file mode 100644
index 0000000..b3d993e
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/OpenTelemetryProvider.ts
@@ -0,0 +1,545 @@
+import type {
+	BasicLogger,
+	ITelemetryService,
+	OpenTelemetryClientConfig,
+	TelemetryMetadata,
+	TelemetryProperties,
+} from "@cline/shared";
+import { metrics, type Tracer, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter as OTLPMetricExporterHttp } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+	BatchLogRecordProcessor,
+	ConsoleLogRecordExporter,
+	LoggerProvider,
+	type LogRecordExporter,
+} from "@opentelemetry/sdk-logs";
+import {
+	ConsoleMetricExporter,
+	MeterProvider,
+	type MetricReader,
+	PeriodicExportingMetricReader,
+} from "@opentelemetry/sdk-metrics";
+import {
+	BatchSpanProcessor,
+	ConsoleSpanExporter,
+	SimpleSpanProcessor,
+	type SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import {
+	ATTR_SERVICE_NAME,
+	ATTR_SERVICE_VERSION,
+} from "@opentelemetry/semantic-conventions";
+import { isTelemetryOptedOutGlobally } from "../global-settings";
+import { resolveCoreDistinctId } from "./distinct-id";
+import {
+	OpenTelemetryAdapter,
+	type OpenTelemetryAdapterOptions,
+} from "./OpenTelemetryAdapter";
+import { TelemetryService } from "./TelemetryService";
+
+type OpenTelemetryExporterKind = "console" | "otlp";
+type OpenTelemetryProtocol = "http/json";
+
+class OptedOutTelemetryService implements ITelemetryService {
+	private distinctId?: string;
+	private metadata: Partial<TelemetryMetadata>;
+	private commonProperties: TelemetryProperties;
+
+	constructor(
+		options: {
+			metadata?: Partial<TelemetryMetadata>;
+			distinctId?: string;
+			commonProperties?: TelemetryProperties;
+		} = {},
+	) {
+		this.distinctId = options.distinctId;
+		this.metadata = { ...(options.metadata ?? {}) };
+		this.commonProperties = { ...(options.commonProperties ?? {}) };
+	}
+
+	setDistinctId(distinctId?: string): void {
+		this.distinctId = distinctId;
+	}
+	setMetadata(metadata: Partial<TelemetryMetadata>): void {
+		this.metadata = { ...metadata };
+	}
+	updateMetadata(metadata: Partial<TelemetryMetadata>): void {
+		this.metadata = {
+			...this.metadata,
+			...metadata,
+		};
+	}
+	setCommonProperties(properties: TelemetryProperties): void {
+		this.commonProperties = { ...properties };
+	}
+	updateCommonProperties(properties: TelemetryProperties): void {
+		this.commonProperties = {
+			...this.commonProperties,
+			...properties,
+		};
+	}
+	isEnabled(): boolean {
+		return false;
+	}
+	capture(input: { properties?: TelemetryProperties }): void {
+		this.resolveProperties(input.properties);
+	}
+	captureRequired(_event: string, properties?: TelemetryProperties): void {
+		this.resolveProperties(properties);
+	}
+	recordCounter(): void {}
+	recordHistogram(): void {}
+	recordGauge(): void {}
+	async flush(): Promise<void> {}
+	async dispose(): Promise<void> {}
+
+	private resolveProperties(
+		properties?: TelemetryProperties,
+	): TelemetryProperties {
+		return {
+			...this.commonProperties,
+			...properties,
+			...this.metadata,
+			...(this.distinctId ? { distinct_id: this.distinctId } : {}),
+		};
+	}
+}
+
+export interface OpenTelemetryProviderOptions
+	extends Omit<
+		OpenTelemetryClientConfig,
+		"enabled" | "logsExporter" | "metricsExporter" | "tracesExporter"
+	> {
+	serviceName?: string;
+	serviceVersion?: string;
+	enabled?: boolean;
+	logsExporter?: string | OpenTelemetryExporterKind[];
+	metricsExporter?: string | OpenTelemetryExporterKind[];
+	tracesExporter?: string | OpenTelemetryExporterKind[];
+	metricExportIntervalMs?: number;
+	logMaxQueueSize?: number;
+	logBatchSize?: number;
+	logBatchTimeoutMs?: number;
+}
+
+export interface CreateOpenTelemetryTelemetryServiceOptions
+	extends OpenTelemetryProviderOptions,
+		Pick<
+			OpenTelemetryAdapterOptions,
+			"name" | "distinctId" | "commonProperties"
+		> {
+	metadata: TelemetryMetadata;
+	logger?: BasicLogger;
+}
+
+export class OpenTelemetryProvider {
+	readonly meterProvider: MeterProvider | null;
+	readonly loggerProvider: LoggerProvider | null;
+	readonly tracerProvider: NodeTracerProvider | null;
+	private readonly options: OpenTelemetryProviderOptions;
+
+	constructor(options: OpenTelemetryProviderOptions = {}) {
+		this.options = options;
+		const resource = resourceFromAttributes({
+			[ATTR_SERVICE_NAME]: options.serviceName ?? "cline",
+			...(options.serviceVersion
+				? { [ATTR_SERVICE_VERSION]: options.serviceVersion }
+				: {}),
+		});
+
+		this.meterProvider = this.createMeterProvider(resource);
+		this.loggerProvider = this.createLoggerProvider(resource);
+		this.tracerProvider = this.createTracerProvider(resource);
+
+		if (this.meterProvider) {
+			metrics.setGlobalMeterProvider(this.meterProvider);
+		}
+		if (this.loggerProvider) {
+			logs.setGlobalLoggerProvider(this.loggerProvider);
+		}
+		if (this.tracerProvider) {
+			this.tracerProvider.register();
+		}
+	}
+
+	/**
+	 * Returns a tracer for manual spans. Requires {@link OpenTelemetryProviderOptions.tracesExporter}
+	 * so that a {@link NodeTracerProvider} is registered.
+	 */
+	getTracer(name = "cline", version?: string): Tracer {
+		return trace.getTracer(name, version ?? this.options.serviceVersion);
+	}
+
+	createAdapter(
+		options: Omit<
+			OpenTelemetryAdapterOptions,
+			"meterProvider" | "loggerProvider"
+		>,
+	): OpenTelemetryAdapter {
+		return new OpenTelemetryAdapter({
+			...options,
+			meterProvider: this.meterProvider,
+			loggerProvider: this.loggerProvider,
+		});
+	}
+
+	createTelemetryService(
+		options: Omit<
+			CreateOpenTelemetryTelemetryServiceOptions,
+			keyof OpenTelemetryProviderOptions
+		>,
+	): ITelemetryService {
+		const adapter = this.createAdapter({
+			name: options.name,
+			enabled: this.options.enabled,
+			metadata: options.metadata,
+		});
+		return new TelemetryService({
+			...options,
+			adapters: [adapter],
+			distinctId: resolveCoreDistinctId(options.distinctId),
+		});
+	}
+
+	async forceFlush(): Promise<void> {
+		await Promise.all([
+			this.meterProvider?.forceFlush?.(),
+			this.loggerProvider?.forceFlush?.(),
+			this.tracerProvider?.forceFlush?.(),
+		]);
+	}
+
+	async dispose(): Promise<void> {
+		await Promise.all([
+			this.meterProvider?.shutdown?.(),
+			this.loggerProvider?.shutdown?.(),
+			this.tracerProvider?.shutdown?.(),
+		]);
+	}
+
+	private createMeterProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): MeterProvider | null {
+		const exporters = normalizeExporters(this.options.metricsExporter);
+		if (exporters.length === 0) {
+			return null;
+		}
+
+		const interval = Math.max(
+			1_000,
+			this.options.metricExportIntervalMs ??
+				this.options.metricExportInterval ??
+				60_000,
+		);
+		const timeout = Math.min(30_000, Math.floor(interval * 0.8));
+		const readers = exporters
+			.map((exporter) =>
+				createMetricReader(exporter, {
+					endpoint: this.options.otlpEndpoint,
+					headers: this.options.otlpHeaders,
+					insecure: this.options.otlpInsecure ?? false,
+					protocol: "http/json",
+					interval,
+					timeout,
+				}),
+			)
+			.filter((reader): reader is MetricReader => reader !== null);
+
+		if (readers.length === 0) {
+			return null;
+		}
+
+		return new MeterProvider({
+			resource,
+			readers,
+		});
+	}
+
+	private createTracerProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): NodeTracerProvider | null {
+		const exporters = normalizeExporters(this.options.tracesExporter);
+		if (exporters.length === 0) {
+			return null;
+		}
+
+		const traceEndpoint =
+			this.options.otlpTracesEndpoint ?? this.options.otlpEndpoint;
+		const traceHeaders =
+			this.options.otlpTracesHeaders ?? this.options.otlpHeaders;
+
+		const processors: SpanProcessor[] = [];
+		for (const exporter of exporters) {
+			const processor = createSpanProcessor(exporter, {
+				endpoint: traceEndpoint,
+				headers: traceHeaders,
+				insecure: this.options.otlpInsecure ?? false,
+				protocol: "http/json",
+			});
+			if (processor) {
+				processors.push(processor);
+			}
+		}
+		if (processors.length === 0) {
+			return null;
+		}
+
+		return new NodeTracerProvider({ resource, spanProcessors: processors });
+	}
+
+	private createLoggerProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): LoggerProvider | null {
+		const exporters = normalizeExporters(this.options.logsExporter);
+		if (exporters.length === 0) {
+			return null;
+		}
+
+		const processors = exporters
+			.map((exporter) => {
+				const logExporter = createLogExporter(exporter, {
+					endpoint: this.options.otlpEndpoint,
+					headers: this.options.otlpHeaders,
+					insecure: this.options.otlpInsecure ?? false,
+					protocol: "http/json",
+				});
+				if (!logExporter) {
+					return null;
+				}
+				return new BatchLogRecordProcessor(logExporter, {
+					maxQueueSize: this.options.logMaxQueueSize ?? 2048,
+					maxExportBatchSize: this.options.logBatchSize ?? 512,
+					scheduledDelayMillis:
+						this.options.logBatchTimeoutMs ??
+						this.options.logBatchTimeout ??
+						5000,
+				});
+			})
+			.filter((p): p is BatchLogRecordProcessor => p !== null);
+		if (processors.length === 0) {
+			return null;
+		}
+		return new LoggerProvider({ resource, processors });
+	}
+}
+
+export function createOpenTelemetryTelemetryService(
+	options: CreateOpenTelemetryTelemetryServiceOptions,
+): { provider: OpenTelemetryProvider; telemetry: ITelemetryService } {
+	const provider = new OpenTelemetryProvider(options);
+	const telemetry = provider.createTelemetryService(options);
+	telemetry.captureRequired("telemetry.provider_created", {
+		provider: "opentelemetry",
+		enabled: options.enabled ?? true,
+		logsExporter: Array.isArray(options.logsExporter)
+			? options.logsExporter.join(",")
+			: options.logsExporter,
+		metricsExporter: Array.isArray(options.metricsExporter)
+			? options.metricsExporter.join(",")
+			: options.metricsExporter,
+		tracesExporter: Array.isArray(options.tracesExporter)
+			? options.tracesExporter.join(",")
+			: options.tracesExporter,
+		otlpProtocol: options.otlpProtocol,
+		hasOtlpEndpoint: Boolean(options.otlpEndpoint),
+		serviceName: options.serviceName,
+		serviceVersion: options.serviceVersion,
+	});
+	return {
+		provider,
+		telemetry,
+	};
+}
+
+export function createConfiguredTelemetryService(
+	options: CreateOpenTelemetryTelemetryServiceOptions,
+): {
+	provider?: OpenTelemetryProvider;
+	telemetry: ITelemetryService;
+} {
+	if (isTelemetryOptedOutGlobally()) {
+		return {
+			telemetry: new OptedOutTelemetryService(options),
+		};
+	}
+
+	if (options.enabled !== true) {
+		return {
+			telemetry: new TelemetryService({
+				...options,
+				distinctId: resolveCoreDistinctId(options.distinctId),
+			}),
+		};
+	}
+
+	return createOpenTelemetryTelemetryService(options);
+}
+
+/**
+ * Telemetry service plus the lifecycle closures (`flush`, `dispose`) every
+ * host needs to drive the underlying provider during shutdown. Returned by
+ * {@link createConfiguredTelemetryHandle} so detached daemons, the VS Code
+ * extension, and the CLI can share one canonical implementation of the
+ * "best-effort flush; settle dispose" semantics instead of each
+ * re-implementing the same closures.
+ */
+export interface ConfiguredTelemetryHandle {
+	readonly telemetry: ITelemetryService;
+	/**
+	 * The underlying OpenTelemetry provider, when telemetry is enabled.
+	 * `undefined` when telemetry is disabled or opted out so callers can
+	 * detect the inactive case without inspecting `enabled` themselves.
+	 */
+	readonly provider?: OpenTelemetryProvider;
+	/**
+	 * Best-effort flush of any pending telemetry batches. Errors are
+	 * swallowed so callers can `await` this in shutdown paths without
+	 * blocking deactivation on a misbehaving exporter.
+	 */
+	flush: () => Promise<void>;
+	/** Disposes the telemetry service and its provider concurrently. */
+	dispose: () => Promise<void>;
+}
+
+/**
+ * Builds a {@link ConfiguredTelemetryHandle} so hosts (CLI, VS Code, hub
+ * daemon) share one canonical flush/dispose implementation. Without a
+ * shared helper each host re-derived the same closures and they tended
+ * to drift; this factory keeps the lifecycle uniform across hosts.
+ */
+export function createConfiguredTelemetryHandle(
+	options: CreateOpenTelemetryTelemetryServiceOptions,
+): ConfiguredTelemetryHandle {
+	const { telemetry, provider } = createConfiguredTelemetryService(options);
+
+	const flush = async (): Promise<void> => {
+		const candidate = provider as
+			| { forceFlush?: () => Promise<void> }
+			| undefined;
+		if (candidate && typeof candidate.forceFlush === "function") {
+			try {
+				await candidate.forceFlush();
+			} catch {
+				// best-effort flush; swallow to avoid blocking shutdown paths
+			}
+		}
+	};
+
+	const dispose = async (): Promise<void> => {
+		await Promise.allSettled([telemetry.dispose(), provider?.dispose()]);
+	};
+
+	return { telemetry, provider, flush, dispose };
+}
+
+function normalizeExporters(
+	exporters: OpenTelemetryProviderOptions["logsExporter"],
+): OpenTelemetryExporterKind[] {
+	if (!exporters) {
+		return [];
+	}
+	const values = Array.isArray(exporters) ? exporters : exporters.split(",");
+	return values
+		.map((value) => value.trim())
+		.filter(
+			(value): value is OpenTelemetryExporterKind =>
+				value === "console" || value === "otlp",
+		);
+}
+
+function createLogExporter(
+	exporter: OpenTelemetryExporterKind,
+	options: {
+		endpoint?: string;
+		headers?: Record<string, string>;
+		insecure: boolean;
+		protocol: OpenTelemetryProtocol;
+	},
+): LogRecordExporter | null {
+	if (exporter === "console") {
+		return new ConsoleLogRecordExporter();
+	}
+	if (!options.endpoint) {
+		return null;
+	}
+
+	const endpoint = ensurePathSuffix(options.endpoint, "/v1/logs");
+	return new OTLPLogExporterHttp({
+		url: endpoint,
+		headers: options.headers,
+	});
+}
+
+function createSpanProcessor(
+	exporter: OpenTelemetryExporterKind,
+	options: {
+		endpoint?: string;
+		headers?: Record<string, string>;
+		insecure: boolean;
+		protocol: OpenTelemetryProtocol;
+	},
+): SpanProcessor | null {
+	if (exporter === "console") {
+		return new SimpleSpanProcessor(new ConsoleSpanExporter());
+	}
+	if (!options.endpoint) {
+		return null;
+	}
+
+	const endpoint = ensurePathSuffix(options.endpoint, "/v1/traces");
+	return new BatchSpanProcessor(
+		new OTLPTraceExporter({
+			url: endpoint,
+			headers: options.headers,
+		}),
+	);
+}
+
+function createMetricReader(
+	exporter: OpenTelemetryExporterKind,
+	options: {
+		endpoint?: string;
+		headers?: Record<string, string>;
+		insecure: boolean;
+		protocol: OpenTelemetryProtocol;
+		interval: number;
+		timeout: number;
+	},
+): MetricReader | null {
+	if (exporter === "console") {
+		return new PeriodicExportingMetricReader({
+			exporter: new ConsoleMetricExporter(),
+			exportIntervalMillis: options.interval,
+			exportTimeoutMillis: options.timeout,
+		});
+	}
+	if (!options.endpoint) {
+		return null;
+	}
+
+	const endpoint = ensurePathSuffix(options.endpoint, "/v1/metrics");
+	return new PeriodicExportingMetricReader({
+		exporter: new OTLPMetricExporterHttp({
+			url: endpoint,
+			headers: options.headers,
+		}),
+		exportIntervalMillis: options.interval,
+		exportTimeoutMillis: options.timeout,
+	});
+}
+
+function ensurePathSuffix(endpoint: string, suffix: string): string {
+	const url = new URL(endpoint);
+	const normalized = url.pathname.endsWith("/")
+		? url.pathname.slice(0, -1)
+		: url.pathname;
+	url.pathname = normalized.endsWith(suffix)
+		? normalized
+		: `${normalized}${suffix}`;
+	return url.toString();
+}
diff --git a/sdk/packages/core/src/services/telemetry/TelemetryLoggerSink.test.ts b/sdk/packages/core/src/services/telemetry/TelemetryLoggerSink.test.ts
new file mode 100644
index 0000000..9a31a7a
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/TelemetryLoggerSink.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
+
+describe("TelemetryLoggerSink", () => {
+	it("logs events and metrics through the provided logger", async () => {
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+		};
+		const sink = new TelemetryLoggerSink({ logger });
+
+		sink.emit("session.started", { sessionId: "s1" });
+		sink.emitRequired("user.opt_out", { reason: "manual" });
+		sink.recordCounter("cline.session.starts.total", 1, {
+			sessionId: "s1",
+		});
+
+		expect(logger.log).toHaveBeenCalledWith("telemetry.event", {
+			telemetrySink: "TelemetryLoggerSink",
+			event: "session.started",
+			properties: { sessionId: "s1" },
+		});
+		expect(logger.log).toHaveBeenCalledWith("telemetry.required_event", {
+			telemetrySink: "TelemetryLoggerSink",
+			severity: "warn",
+			event: "user.opt_out",
+			properties: { reason: "manual" },
+		});
+		expect(logger.debug).toHaveBeenCalledWith("telemetry.metric", {
+			telemetrySink: "TelemetryLoggerSink",
+			instrument: "counter",
+			name: "cline.session.starts.total",
+			value: 1,
+			attributes: { sessionId: "s1" },
+			description: undefined,
+			required: false,
+		});
+
+		await sink.flush();
+		await sink.dispose();
+	});
+});
diff --git a/sdk/packages/core/src/services/telemetry/TelemetryLoggerSink.ts b/sdk/packages/core/src/services/telemetry/TelemetryLoggerSink.ts
new file mode 100644
index 0000000..e46e430
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/TelemetryLoggerSink.ts
@@ -0,0 +1,121 @@
+import type { BasicLogger } from "@cline/shared";
+import type {
+	ITelemetryAdapter,
+	TelemetryProperties,
+} from "./ITelemetryAdapter";
+
+/**
+ * {@link ITelemetryAdapter} implementation that forwards telemetry to a {@link BasicLogger}.
+ *
+ * This is intentionally named *Sink* (not "adapter") to distinguish it from host logging bridges
+ * such as the CLI Pino bundle: it consumes telemetry events and writes them to the injected logger.
+ */
+export interface TelemetryLoggerSinkOptions {
+	logger?: BasicLogger;
+	name?: string;
+	enabled?: boolean | (() => boolean);
+}
+
+export class TelemetryLoggerSink implements ITelemetryAdapter {
+	readonly name: string;
+
+	private readonly logger?: BasicLogger;
+	private readonly enabled: boolean | (() => boolean);
+
+	constructor(options: TelemetryLoggerSinkOptions = {}) {
+		this.name = options.name ?? "TelemetryLoggerSink";
+		this.logger = options.logger;
+		this.enabled = options.enabled ?? true;
+	}
+
+	emit(event: string, properties?: TelemetryProperties): void {
+		if (!this.isEnabled()) {
+			return;
+		}
+		this.logger?.log("telemetry.event", {
+			telemetrySink: this.name,
+			event,
+			properties,
+		});
+	}
+
+	emitRequired(event: string, properties?: TelemetryProperties): void {
+		this.logger?.log("telemetry.required_event", {
+			telemetrySink: this.name,
+			severity: "warn",
+			event,
+			properties,
+		});
+	}
+
+	recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void {
+		if (!required && !this.isEnabled()) {
+			return;
+		}
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
+			instrument: "counter",
+			name,
+			value,
+			attributes,
+			description,
+			required: required === true,
+		});
+	}
+
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void {
+		if (!required && !this.isEnabled()) {
+			return;
+		}
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
+			instrument: "histogram",
+			name,
+			value,
+			attributes,
+			description,
+			required: required === true,
+		});
+	}
+
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void {
+		if (!required && !this.isEnabled()) {
+			return;
+		}
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
+			instrument: "gauge",
+			name,
+			value,
+			attributes,
+			description,
+			required: required === true,
+		});
+	}
+
+	isEnabled(): boolean {
+		return typeof this.enabled === "function" ? this.enabled() : this.enabled;
+	}
+
+	async flush(): Promise<void> {}
+
+	async dispose(): Promise<void> {}
+}
diff --git a/sdk/packages/core/src/services/telemetry/TelemetryService.test.ts b/sdk/packages/core/src/services/telemetry/TelemetryService.test.ts
new file mode 100644
index 0000000..9c02740
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/TelemetryService.test.ts
@@ -0,0 +1,134 @@
+import type { BasicLogger } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import type { ITelemetryAdapter } from "./ITelemetryAdapter";
+import { TelemetryService } from "./TelemetryService";
+
+describe("TelemetryService", () => {
+	it("merges metadata and forwards calls to adapters", async () => {
+		const { adapter, emit, recordCounter } = createAdapter();
+		const service = new TelemetryService({
+			adapters: [adapter],
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+			},
+			distinctId: "distinct-1",
+			commonProperties: {
+				organization_id: "org-1",
+			},
+		});
+
+		service.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+		service.recordCounter("cline.session.starts.total", 1, {
+			sessionId: "session-1",
+		});
+		await service.flush();
+		await service.dispose();
+
+		expect(emit).toHaveBeenCalledWith(
+			"session.started",
+			expect.objectContaining({
+				sessionId: "session-1",
+				organization_id: "org-1",
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				distinct_id: "distinct-1",
+			}),
+		);
+		expect(recordCounter).toHaveBeenCalledWith(
+			"cline.session.starts.total",
+			1,
+			expect.objectContaining({
+				sessionId: "session-1",
+				distinct_id: "distinct-1",
+			}),
+			undefined,
+			false,
+		);
+	});
+
+	it("mirrors telemetry events into the logger when provided", () => {
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const service = new TelemetryService({
+			logger,
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+			},
+			distinctId: "distinct-1",
+		});
+
+		service.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+		service.captureRequired("user.opt_out", { reason: "manual" });
+		service.recordCounter("cline.session.starts.total", 1, {
+			sessionId: "session-1",
+		});
+
+		expect(logger.log).toHaveBeenCalledWith(
+			"telemetry.event",
+			expect.objectContaining({
+				telemetrySink: "TelemetryLoggerSink",
+				event: "session.started",
+				properties: expect.objectContaining({
+					sessionId: "session-1",
+					extension_version: "1.2.3",
+					distinct_id: "distinct-1",
+				}),
+			}),
+		);
+		expect(logger.log).toHaveBeenCalledWith(
+			"telemetry.required_event",
+			expect.objectContaining({
+				telemetrySink: "TelemetryLoggerSink",
+				severity: "warn",
+				event: "user.opt_out",
+				properties: expect.objectContaining({
+					reason: "manual",
+					extension_version: "1.2.3",
+				}),
+			}),
+		);
+		expect(logger.debug).toHaveBeenCalledWith(
+			"telemetry.metric",
+			expect.objectContaining({
+				telemetrySink: "TelemetryLoggerSink",
+				instrument: "counter",
+				name: "cline.session.starts.total",
+			}),
+		);
+	});
+});
+
+function createAdapter(): {
+	adapter: ITelemetryAdapter;
+	emit: ReturnType<typeof vi.fn>;
+	recordCounter: ReturnType<typeof vi.fn>;
+} {
+	const emit = vi.fn();
+	const recordCounter = vi.fn();
+	return {
+		adapter: {
+			name: "test",
+			emit,
+			emitRequired: vi.fn(),
+			recordCounter,
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			isEnabled: vi.fn(() => true),
+			flush: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		},
+		emit,
+		recordCounter,
+	};
+}
diff --git a/sdk/packages/core/src/services/telemetry/TelemetryService.ts b/sdk/packages/core/src/services/telemetry/TelemetryService.ts
new file mode 100644
index 0000000..ad3721d
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/TelemetryService.ts
@@ -0,0 +1,139 @@
+import type {
+	BasicLogger,
+	ITelemetryService,
+	TelemetryMetadata,
+	TelemetryProperties,
+} from "@cline/shared";
+import type { ITelemetryAdapter } from "./ITelemetryAdapter";
+import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
+
+export interface TelemetryServiceOptions {
+	adapters?: ITelemetryAdapter[];
+	metadata?: Partial<TelemetryMetadata>;
+	distinctId?: string;
+	commonProperties?: TelemetryProperties;
+	logger?: BasicLogger;
+}
+
+export class TelemetryService implements ITelemetryService {
+	private adapters: ITelemetryAdapter[];
+	private metadata: Partial<TelemetryMetadata>;
+	private distinctId?: string;
+	private commonProperties: TelemetryProperties;
+
+	constructor(options: TelemetryServiceOptions = {}) {
+		this.adapters = [...(options.adapters ?? [])];
+		if (options.logger) {
+			this.adapters.push(new TelemetryLoggerSink({ logger: options.logger }));
+		}
+		this.metadata = { ...(options.metadata ?? {}) };
+		this.distinctId = options.distinctId;
+		this.commonProperties = { ...(options.commonProperties ?? {}) };
+	}
+
+	addAdapter(adapter: ITelemetryAdapter): void {
+		this.adapters.push(adapter);
+	}
+
+	setDistinctId(distinctId?: string): void {
+		this.distinctId = distinctId;
+	}
+
+	setMetadata(metadata: Partial<TelemetryMetadata>): void {
+		this.metadata = { ...metadata };
+	}
+
+	updateMetadata(metadata: Partial<TelemetryMetadata>): void {
+		this.metadata = {
+			...this.metadata,
+			...metadata,
+		};
+	}
+
+	setCommonProperties(properties: TelemetryProperties): void {
+		this.commonProperties = { ...properties };
+	}
+
+	updateCommonProperties(properties: TelemetryProperties): void {
+		this.commonProperties = {
+			...this.commonProperties,
+			...properties,
+		};
+	}
+
+	isEnabled(): boolean {
+		return this.adapters.some((adapter) => adapter.isEnabled());
+	}
+
+	capture(input: { event: string; properties?: TelemetryProperties }): void {
+		const properties = this.buildAttributes(input.properties);
+		for (const adapter of this.adapters) {
+			adapter.emit(input.event, properties);
+		}
+	}
+
+	captureRequired(event: string, properties?: TelemetryProperties): void {
+		const merged = this.buildAttributes(properties);
+		for (const adapter of this.adapters) {
+			adapter.emitRequired(event, merged);
+		}
+	}
+
+	recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		const merged = this.buildAttributes(attributes);
+		for (const adapter of this.adapters) {
+			adapter.recordCounter(name, value, merged, description, required);
+		}
+	}
+
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		const merged = this.buildAttributes(attributes);
+		for (const adapter of this.adapters) {
+			adapter.recordHistogram(name, value, merged, description, required);
+		}
+	}
+
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required = false,
+	): void {
+		const merged = this.buildAttributes(attributes);
+		for (const adapter of this.adapters) {
+			adapter.recordGauge(name, value, merged, description, required);
+		}
+	}
+
+	async flush(): Promise<void> {
+		await Promise.all(this.adapters.map((adapter) => adapter.flush()));
+	}
+
+	async dispose(): Promise<void> {
+		await Promise.all(this.adapters.map((adapter) => adapter.dispose()));
+	}
+
+	private buildAttributes(
+		properties?: TelemetryProperties,
+	): TelemetryProperties {
+		return {
+			...this.commonProperties,
+			...properties,
+			...this.metadata,
+			...(this.distinctId ? { distinct_id: this.distinctId } : {}),
+		};
+	}
+}
diff --git a/sdk/packages/core/src/services/telemetry/core-events.test.ts b/sdk/packages/core/src/services/telemetry/core-events.test.ts
new file mode 100644
index 0000000..3186e73
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/core-events.test.ts
@@ -0,0 +1,855 @@
+import {
+	AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+	type ITelemetryService,
+} from "@cline/shared";
+import { describe, expect, test, vi } from "vitest";
+import {
+	CORE_TELEMETRY_EVENTS,
+	captureCompactionBudgetEmergency,
+	captureCompactionExecuted,
+	captureCompactionSkipped,
+	captureExtensionActivated,
+	captureProviderConfigured,
+	captureRunCommandsTimeout,
+	captureTelemetryOptOut,
+	captureWorkspaceInitError,
+	captureWorkspaceInitialized,
+	captureWorkspacePathResolved,
+	identifyAccount,
+} from "./core-events";
+import type { ITelemetryAdapter } from "./ITelemetryAdapter";
+import { TelemetryService } from "./TelemetryService";
+
+interface TelemetryStub {
+	telemetry: ITelemetryService;
+	capture: ReturnType<typeof vi.fn>;
+	captureRequired: ReturnType<typeof vi.fn>;
+}
+
+function createTelemetryStub(): TelemetryStub {
+	const captureRequired = vi.fn();
+	const capture = vi.fn();
+	const telemetry = {
+		capture,
+		captureRequired,
+		setDistinctId: vi.fn(),
+		updateCommonProperties: vi.fn(),
+		identify: vi.fn(),
+	} as unknown as ITelemetryService;
+	return { telemetry, capture, captureRequired };
+}
+
+function captureCallAt(
+	stub: TelemetryStub,
+	index: number,
+): { event: string; properties?: Record<string, unknown> } {
+	const call = stub.capture.mock.calls[index];
+	if (!call) {
+		throw new Error(`expected capture call at index ${index}`);
+	}
+	const [arg] = call as [
+		{ event: string; properties?: Record<string, unknown> },
+	];
+	return arg;
+}
+
+describe("captureExtensionActivated", () => {
+	test("emits user.extension_activated as a normal opt-out-respecting event", () => {
+		const stub = createTelemetryStub();
+		captureExtensionActivated(stub.telemetry);
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("user.extension_activated");
+		expect(properties).toBeUndefined();
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() => captureExtensionActivated(undefined)).not.toThrow();
+	});
+});
+
+describe("captureTelemetryOptOut", () => {
+	test("emits user.opt_out as a required event", () => {
+		const stub = createTelemetryStub();
+		captureTelemetryOptOut(stub.telemetry);
+		expect(stub.capture).not.toHaveBeenCalled();
+		expect(stub.captureRequired).toHaveBeenCalledWith(
+			"user.opt_out",
+			undefined,
+		);
+	});
+});
+
+describe("CORE_TELEMETRY_EVENTS", () => {
+	test("catalogs the unexpected reasoning token event", () => {
+		expect(CORE_TELEMETRY_EVENTS.AGENT.UNEXPECTED_REASONING_TOKENS).toBe(
+			AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+		);
+	});
+});
+
+describe("captureProviderConfigured", () => {
+	test("emits user.provider_configured with the provider id as a normal (opt-out-respecting) event", () => {
+		const stub = createTelemetryStub();
+		captureProviderConfigured(stub.telemetry, "anthropic");
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		// Must NOT be captureRequired — the BYO configure step is not an
+		// essential lifecycle event and should respect telemetry opt-out.
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("user.provider_configured");
+		// Payload shape mirrors `captureAuthSucceeded`: `{ provider }`,
+		// nothing else. Keep this strict so we don't accidentally leak
+		// `apiKey` / `baseUrl` / model identifiers into the funnel.
+		expect(properties).toEqual({ provider: "anthropic" });
+	});
+
+	test("emits with provider=undefined when none is supplied", () => {
+		const stub = createTelemetryStub();
+		captureProviderConfigured(stub.telemetry);
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("user.provider_configured");
+		expect(properties).toEqual({ provider: undefined });
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			captureProviderConfigured(undefined, "openrouter"),
+		).not.toThrow();
+	});
+});
+
+describe("captureWorkspaceInitialized", () => {
+	test("emits workspace.initialized with derived flags", () => {
+		const stub = createTelemetryStub();
+		captureWorkspaceInitialized(stub.telemetry, {
+			root_count: 1,
+			vcs_types: ["git"],
+			init_duration_ms: 92.7155,
+			feature_flag_enabled: true,
+		});
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("workspace.initialized");
+		expect(properties).toEqual({
+			root_count: 1,
+			vcs_types: ["git"],
+			is_multi_root: false,
+			has_git: true,
+			has_mercurial: false,
+			init_duration_ms: 92.7155,
+			feature_flag_enabled: true,
+		});
+	});
+
+	test("derives is_multi_root from root_count > 1", () => {
+		const stub = createTelemetryStub();
+		captureWorkspaceInitialized(stub.telemetry, {
+			root_count: 3,
+			vcs_types: ["git", "none", "Mercurial"],
+		});
+		const { properties } = captureCallAt(stub, 0);
+		const props = properties as Record<string, unknown>;
+		expect(props.is_multi_root).toBe(true);
+		expect(props.has_git).toBe(true);
+		expect(props.has_mercurial).toBe(true);
+	});
+
+	test("treats hg/Mercurial as Mercurial for has_mercurial", () => {
+		const stub = createTelemetryStub();
+		captureWorkspaceInitialized(stub.telemetry, {
+			root_count: 1,
+			vcs_types: ["hg"],
+		});
+		const { properties } = captureCallAt(stub, 0);
+		const props = properties as Record<string, unknown>;
+		expect(props.has_mercurial).toBe(true);
+		expect(props.has_git).toBe(false);
+	});
+
+	test("only includes is_remote_workspace when supplied", () => {
+		const stub = createTelemetryStub();
+		captureWorkspaceInitialized(stub.telemetry, {
+			root_count: 1,
+			vcs_types: ["none"],
+			is_remote_workspace: true,
+		});
+		const { properties } = captureCallAt(stub, 0);
+		const props = properties as Record<string, unknown>;
+		expect(props.is_remote_workspace).toBe(true);
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			captureWorkspaceInitialized(undefined, {
+				root_count: 1,
+				vcs_types: ["none"],
+			}),
+		).not.toThrow();
+	});
+});
+
+describe("captureWorkspaceInitError", () => {
+	test("emits workspace.init_error with truncated error_message and defaulted workspace_count", () => {
+		const stub = createTelemetryStub();
+		const longMessage = "x".repeat(2000);
+		const error = new Error(longMessage);
+		error.name = "WorkspaceSetupError";
+		captureWorkspaceInitError(stub.telemetry, error, {
+			fallback_to_single_root: true,
+		});
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("workspace.init_error");
+		const props = properties as Record<string, unknown>;
+		expect(props.error_type).toBe("WorkspaceSetupError");
+		expect((props.error_message as string | undefined)?.length).toBe(500);
+		expect(props.fallback_to_single_root).toBe(true);
+		expect(props.workspace_count).toBe(0);
+	});
+
+	test("respects supplied workspace_count", () => {
+		const stub = createTelemetryStub();
+		captureWorkspaceInitError(stub.telemetry, "boom", {
+			fallback_to_single_root: false,
+			workspace_count: 4,
+		});
+		const { properties } = captureCallAt(stub, 0);
+		const props = properties as Record<string, unknown>;
+		expect(props.error_type).toBe("Error");
+		expect(props.error_message).toBe("boom");
+		expect(props.workspace_count).toBe(4);
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			captureWorkspaceInitError(undefined, "boom", {
+				fallback_to_single_root: false,
+			}),
+		).not.toThrow();
+	});
+});
+
+describe("captureWorkspacePathResolved", () => {
+	test("emits workspace.path_resolved with snake_case fields", () => {
+		const stub = createTelemetryStub();
+		captureWorkspacePathResolved(stub.telemetry, {
+			ulid: "ulid-1",
+			context: "search_codebase",
+			resolution_type: "hint_provided",
+			hint_type: "workspace_name",
+			resolution_success: true,
+			target_workspace_index: 1,
+			is_multi_root_enabled: true,
+		});
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("workspace.path_resolved");
+		expect(properties).toEqual({
+			ulid: "ulid-1",
+			context: "search_codebase",
+			resolution_type: "hint_provided",
+			hint_type: "workspace_name",
+			resolution_success: true,
+			target_workspace_index: 1,
+			is_multi_root_enabled: true,
+		});
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			captureWorkspacePathResolved(undefined, {
+				ulid: "ulid-1",
+				context: "search_codebase",
+				resolution_type: "fallback_to_primary",
+			}),
+		).not.toThrow();
+	});
+});
+describe("captureCompactionExecuted", () => {
+	const baseProps = {
+		ulid: "ulid-1",
+		strategy: "basic" as const,
+		mode: "auto" as const,
+		messagesBefore: 12,
+		messagesAfter: 6,
+		messagesRemoved: 6,
+		tokensBefore: 100_000,
+		tokensAfter: 50_000,
+		tokensSaved: 50_000,
+		triggerTokens: 180_000,
+		maxInputTokens: 200_000,
+		thresholdRatio: 0.9,
+		durationMs: 42,
+		provider: "anthropic",
+		modelId: "claude-sonnet-4",
+	};
+
+	test("emits task.compaction_executed with all properties and a timestamp", () => {
+		const stub = createTelemetryStub();
+		captureCompactionExecuted(stub.telemetry, baseProps);
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe(CORE_TELEMETRY_EVENTS.TASK.COMPACTION_EXECUTED);
+		expect(event).toBe("task.compaction_executed");
+		expect(properties).toMatchObject(baseProps);
+		expect(typeof (properties as Record<string, unknown>).timestamp).toBe(
+			"string",
+		);
+	});
+
+	test("preserves optional agent identity fields when supplied", () => {
+		const stub = createTelemetryStub();
+		captureCompactionExecuted(stub.telemetry, {
+			...baseProps,
+			agentId: "agent-7",
+			agentKind: "subagent",
+			conversationId: "conv-1",
+			parentAgentId: "agent-root",
+			isSubagent: true,
+		});
+		const { properties } = captureCallAt(stub, 0);
+		const props = properties as Record<string, unknown>;
+		expect(props.agentId).toBe("agent-7");
+		expect(props.agentKind).toBe("subagent");
+		expect(props.conversationId).toBe("conv-1");
+		expect(props.parentAgentId).toBe("agent-root");
+		expect(props.isSubagent).toBe(true);
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() => captureCompactionExecuted(undefined, baseProps)).not.toThrow();
+	});
+});
+
+describe("captureCompactionSkipped", () => {
+	const baseProps = {
+		ulid: "ulid-1",
+		strategy: "agentic" as const,
+		mode: "auto" as const,
+		reason: "no_result",
+		tokensBefore: 100_000,
+		triggerTokens: 180_000,
+		maxInputTokens: 200_000,
+		thresholdRatio: 0.9,
+		durationMs: 17,
+		provider: "anthropic",
+		modelId: "claude-sonnet-4",
+	};
+
+	test("emits task.compaction_skipped with all properties and a timestamp", () => {
+		const stub = createTelemetryStub();
+		captureCompactionSkipped(stub.telemetry, baseProps);
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe(CORE_TELEMETRY_EVENTS.TASK.COMPACTION_SKIPPED);
+		expect(event).toBe("task.compaction_skipped");
+		expect(properties).toMatchObject(baseProps);
+		expect(typeof (properties as Record<string, unknown>).timestamp).toBe(
+			"string",
+		);
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() => captureCompactionSkipped(undefined, baseProps)).not.toThrow();
+	});
+});
+
+describe("captureRunCommandsTimeout", () => {
+	test("emits sdk.tool_timeout with sanitized timeout metadata", () => {
+		const stub = createTelemetryStub();
+		captureRunCommandsTimeout(stub.telemetry, {
+			tool_name: "run_commands",
+			effective_timeout_ms: 1500,
+			timeout_source: "default_setting",
+			command_count: 2,
+			duration_ms: 1502,
+			ulid: "session-1",
+			mode: "act",
+			source: "sdk-test",
+			session_id: "session-1",
+			agent_id: "agent-1",
+			conversation_id: "conv-1",
+			run_id: "run-1",
+			iteration: 3,
+			tool_call_id: "tool-call-1",
+		});
+
+		expect(stub.capture).toHaveBeenCalledTimes(1);
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe(CORE_TELEMETRY_EVENTS.SDK.TOOL_TIMEOUT);
+		expect(properties).toEqual({
+			tool_name: "run_commands",
+			effective_timeout_ms: 1500,
+			timeout_source: "default_setting",
+			command_count: 2,
+			duration_ms: 1502,
+			ulid: "session-1",
+			mode: "act",
+			source: "sdk-test",
+			session_id: "session-1",
+			agent_id: "agent-1",
+			conversation_id: "conv-1",
+			run_id: "run-1",
+			iteration: 3,
+			tool_call_id: "tool-call-1",
+		});
+		expect(properties).not.toHaveProperty("command");
+		expect(properties).not.toHaveProperty("commands");
+		expect(properties).not.toHaveProperty("stdout");
+		expect(properties).not.toHaveProperty("stderr");
+		expect(properties).not.toHaveProperty("env");
+		expect(properties).not.toHaveProperty("workspace_path");
+	});
+
+	test("omits undefined optional properties", () => {
+		const stub = createTelemetryStub();
+		captureRunCommandsTimeout(stub.telemetry, {
+			tool_name: "run_commands",
+			effective_timeout_ms: 1500,
+			timeout_source: "default_setting",
+			command_count: 1,
+			duration_ms: 1502,
+			mode: undefined,
+			source: undefined,
+		});
+
+		const { properties } = captureCallAt(stub, 0);
+		expect(properties).toEqual({
+			tool_name: "run_commands",
+			effective_timeout_ms: 1500,
+			timeout_source: "default_setting",
+			command_count: 1,
+			duration_ms: 1502,
+		});
+	});
+
+	test("allows configured timeout source", () => {
+		const stub = createTelemetryStub();
+		captureRunCommandsTimeout(stub.telemetry, {
+			tool_name: "run_commands",
+			effective_timeout_ms: 5000,
+			timeout_source: "configured_setting",
+			command_count: 1,
+			duration_ms: 5001,
+			ulid: "session-1",
+		});
+
+		const { properties } = captureCallAt(stub, 0);
+		expect(properties).toEqual({
+			tool_name: "run_commands",
+			effective_timeout_ms: 5000,
+			timeout_source: "configured_setting",
+			command_count: 1,
+			duration_ms: 5001,
+			ulid: "session-1",
+		});
+	});
+});
+
+describe("captureCompactionBudgetEmergency", () => {
+	test("emits task.compaction_budget_emergency with action metadata", () => {
+		const stub = createTelemetryStub();
+		captureCompactionBudgetEmergency(stub.telemetry, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			policyIntent: "basic_compaction_projection",
+			actionCount: 2,
+			warningCount: 1,
+			liveTailHandling: "included_degraded",
+			provider: "anthropic",
+			modelId: "claude-sonnet-4",
+		});
+
+		const { event, properties } = captureCallAt(stub, 0);
+		expect(event).toBe("task.compaction_budget_emergency");
+		expect(properties).toMatchObject({
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			policyIntent: "basic_compaction_projection",
+			actionCount: 2,
+			warningCount: 1,
+			liveTailHandling: "included_degraded",
+		});
+		expect(typeof (properties as Record<string, unknown>).timestamp).toBe(
+			"string",
+		);
+	});
+});
+
+/**
+ * Telemetry-policy regression coverage.
+ *
+ * Background: an earlier rev of the activation/workspace funnel routed the
+ * four event families
+ *   - user.extension_activated
+ *   - workspace.initialized
+ *   - workspace.init_error
+ *   - workspace.path_resolved
+ * through `telemetry.captureRequired(...)`, which deliberately bypasses the
+ * user's telemetry opt-out. That broadened the policy of `captureRequired`
+ * (today only used by `OpenTelemetryProvider` for the
+ * `telemetry.provider_created` heartbeat) to cover four new families of
+ * non-essential events. The fix was to route them through `capture(...)`
+ * so they respect the opt-out.
+ *
+ * These tests lock in that policy by constructing a real
+ * {@link TelemetryService} backed by an adapter whose `isEnabled()`
+ * returns `false`. A correctly-policed adapter drops `emit(...)` calls
+ * when disabled but is allowed to honor `emitRequired(...)`. The helpers
+ * below MUST call only `emit`, never `emitRequired`, so that a disabled
+ * adapter never observes them as required.
+ */
+describe("telemetry policy: helpers respect telemetry opt-out", () => {
+	function createDisabledAdapter(): {
+		adapter: ITelemetryAdapter;
+		emit: ReturnType<typeof vi.fn>;
+		emitRequired: ReturnType<typeof vi.fn>;
+	} {
+		const emit = vi.fn();
+		const emitRequired = vi.fn();
+		const adapter: ITelemetryAdapter = {
+			name: "disabled-test-adapter",
+			emit: (event, properties) => {
+				// Mirror the production contract: a disabled adapter drops
+				// non-required events. We still record the attempt so the
+				// test can assert that it *was* an `emit` (not an
+				// `emitRequired`) call before the drop happened.
+				emit(event, properties);
+			},
+			emitRequired: (event, properties) => {
+				emitRequired(event, properties);
+			},
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			isEnabled: () => false,
+			flush: () => Promise.resolve(),
+			dispose: () => Promise.resolve(),
+		};
+		return { adapter, emit, emitRequired };
+	}
+
+	test("captureExtensionActivated never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureExtensionActivated(service);
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureWorkspaceInitialized never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureWorkspaceInitialized(service, {
+			root_count: 1,
+			vcs_types: ["git"],
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureWorkspaceInitError never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureWorkspaceInitError(service, "boom", {
+			fallback_to_single_root: true,
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureWorkspacePathResolved never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureWorkspacePathResolved(service, {
+			ulid: "ulid-1",
+			context: "search_codebase",
+			resolution_type: "fallback_to_primary",
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureCompactionExecuted never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureCompactionExecuted(service, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			messagesBefore: 12,
+			messagesAfter: 6,
+			messagesRemoved: 6,
+			tokensBefore: 100_000,
+			tokensAfter: 50_000,
+			tokensSaved: 50_000,
+			triggerTokens: 180_000,
+			maxInputTokens: 200_000,
+			thresholdRatio: 0.9,
+			durationMs: 42,
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureCompactionSkipped never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureCompactionSkipped(service, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			reason: "no_result",
+			tokensBefore: 100_000,
+			triggerTokens: 180_000,
+			maxInputTokens: 200_000,
+			thresholdRatio: 0.9,
+			durationMs: 17,
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureRunCommandsTimeout never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureRunCommandsTimeout(service, {
+			tool_name: "run_commands",
+			effective_timeout_ms: 1500,
+			timeout_source: "default_setting",
+			command_count: 2,
+			duration_ms: 1502,
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("captureCompactionBudgetEmergency never invokes captureRequired", () => {
+		const { adapter, emitRequired } = createDisabledAdapter();
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureCompactionBudgetEmergency(service, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			policyIntent: "basic_compaction_projection",
+			actionCount: 1,
+			warningCount: 0,
+			liveTailHandling: "included_degraded",
+		});
+		expect(emitRequired).not.toHaveBeenCalled();
+	});
+
+	test("a correctly-policed adapter drops these events when disabled", () => {
+		// This test layers on top of the previous four to assert the *full*
+		// end-to-end policy: when the adapter is disabled, a real adapter
+		// implementation (not the stubbed pass-through above) drops
+		// `emit(...)` calls. We verify here by using a stricter adapter
+		// that early-returns from `emit` when `isEnabled() === false`,
+		// matching the behavior of `OpenTelemetryAdapter` and
+		// `TelemetryLoggerSink`.
+		const dropped: string[] = [];
+		const observed: string[] = [];
+		const adapter: ITelemetryAdapter = {
+			name: "policed-disabled-adapter",
+			emit: (event) => {
+				if (!adapter.isEnabled()) {
+					dropped.push(event);
+					return;
+				}
+				observed.push(event);
+			},
+			emitRequired: (event) => observed.push(event),
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			isEnabled: () => false,
+			flush: () => Promise.resolve(),
+			dispose: () => Promise.resolve(),
+		};
+		const service = new TelemetryService({
+			distinctId: "test-distinct-id",
+			adapters: [adapter],
+		});
+		captureExtensionActivated(service);
+		captureWorkspaceInitialized(service, {
+			root_count: 1,
+			vcs_types: ["git"],
+		});
+		captureWorkspaceInitError(service, "boom", {
+			fallback_to_single_root: true,
+		});
+		captureWorkspacePathResolved(service, {
+			ulid: "ulid-1",
+			context: "search_codebase",
+			resolution_type: "fallback_to_primary",
+		});
+		captureProviderConfigured(service, "test-provider");
+		captureCompactionExecuted(service, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			messagesBefore: 12,
+			messagesAfter: 6,
+			messagesRemoved: 6,
+			tokensBefore: 100_000,
+			tokensAfter: 50_000,
+			tokensSaved: 50_000,
+			triggerTokens: 180_000,
+			maxInputTokens: 200_000,
+			thresholdRatio: 0.9,
+			durationMs: 42,
+		});
+		captureCompactionSkipped(service, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			reason: "no_result",
+			tokensBefore: 100_000,
+			triggerTokens: 180_000,
+			maxInputTokens: 200_000,
+			thresholdRatio: 0.9,
+			durationMs: 17,
+		});
+		captureRunCommandsTimeout(service, {
+			tool_name: "run_commands",
+			effective_timeout_ms: 1500,
+			timeout_source: "default_setting",
+			command_count: 2,
+			duration_ms: 1502,
+		});
+		captureCompactionBudgetEmergency(service, {
+			ulid: "ulid-1",
+			strategy: "basic",
+			mode: "auto",
+			policyIntent: "basic_compaction_projection",
+			actionCount: 1,
+			warningCount: 0,
+			liveTailHandling: "included_degraded",
+		});
+		expect(observed).toEqual([]);
+		expect(dropped).toEqual([
+			"user.extension_activated",
+			"workspace.initialized",
+			"workspace.init_error",
+			"workspace.path_resolved",
+			"user.provider_configured",
+			"task.compaction_executed",
+			"task.compaction_skipped",
+			"sdk.tool_timeout",
+			"task.compaction_budget_emergency",
+		]);
+	});
+});
+
+describe("identifyAccount", () => {
+	test("sets user_id, account_id, and distinct_id for an authenticated user without org", () => {
+		const stub = createTelemetryStub();
+		identifyAccount(stub.telemetry, {
+			id: "usr-123",
+			email: "test@example.com",
+			provider: "cline",
+		});
+		expect(vi.mocked(stub.telemetry.setDistinctId)).toHaveBeenCalledWith(
+			"usr-123",
+		);
+		expect(
+			vi.mocked(stub.telemetry.updateCommonProperties),
+		).toHaveBeenCalledWith(
+			expect.objectContaining({
+				user_id: "usr-123",
+				account_id: "usr-123",
+				account_email: "test@example.com",
+				provider: "cline",
+			}),
+		);
+	});
+
+	test("sets user_id, org context for an authenticated user with an active organization", () => {
+		const stub = createTelemetryStub();
+		identifyAccount(stub.telemetry, {
+			id: "usr-456",
+			email: "alice@example.com",
+			provider: "cline",
+			organizationId: "org-1",
+			organizationName: "Acme",
+			memberId: "member-9",
+		});
+		expect(
+			vi.mocked(stub.telemetry.updateCommonProperties),
+		).toHaveBeenCalledWith(
+			expect.objectContaining({
+				user_id: "usr-456",
+				account_id: "usr-456",
+				organization_id: "org-1",
+				organization_name: "Acme",
+				member_id: "member-9",
+			}),
+		);
+	});
+
+	test("user_id and account_id are set to the same value", () => {
+		const stub = createTelemetryStub();
+		identifyAccount(stub.telemetry, { id: "usr-789", provider: "cline" });
+		const call = vi.mocked(stub.telemetry.updateCommonProperties).mock
+			.calls[0]?.[0] as Record<string, unknown> | undefined;
+		expect(call?.user_id).toBe("usr-789");
+		expect(call?.account_id).toBe("usr-789");
+		expect(call?.user_id).toBe(call?.account_id);
+	});
+
+	test("does not set distinct_id when account id is absent", () => {
+		const stub = createTelemetryStub();
+		identifyAccount(stub.telemetry, {
+			email: "anon@example.com",
+			provider: "cline",
+		});
+		expect(stub.telemetry.setDistinctId).not.toHaveBeenCalled();
+	});
+
+	test("trims whitespace from account.id before setting distinct_id", () => {
+		const stub = createTelemetryStub();
+		identifyAccount(stub.telemetry, { id: "  usr-trim  " });
+		expect(vi.mocked(stub.telemetry.setDistinctId)).toHaveBeenCalledWith(
+			"usr-trim",
+		);
+	});
+
+	test("does not set distinct_id for blank id string", () => {
+		const stub = createTelemetryStub();
+		identifyAccount(stub.telemetry, { id: "   " });
+		expect(stub.telemetry.setDistinctId).not.toHaveBeenCalled();
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			identifyAccount(undefined, { id: "usr-123", provider: "cline" }),
+		).not.toThrow();
+	});
+});
diff --git a/sdk/packages/core/src/services/telemetry/core-events.ts b/sdk/packages/core/src/services/telemetry/core-events.ts
new file mode 100644
index 0000000..8066e22
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/core-events.ts
@@ -0,0 +1,723 @@
+import {
+	AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+	type CaptureAgentUnexpectedReasoningTokensInput,
+	captureAgentUnexpectedReasoningTokens,
+	type ITelemetryService,
+	SDK_ERROR_TELEMETRY_EVENT,
+	type TelemetryProperties,
+} from "@cline/shared";
+import type {
+	CoreCompactionBudgetPolicyIntent,
+	CoreCompactionLiveTailHandling,
+} from "../../types/config";
+
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+
+export type TelemetryAgentKind =
+	| "root"
+	| "subagent"
+	| "team_lead"
+	| "team_teammate";
+
+export interface TelemetryAgentIdentityProperties {
+	agentId: string;
+	agentKind: TelemetryAgentKind;
+	conversationId?: string;
+	parentAgentId?: string;
+	createdByAgentId?: string;
+	isSubagent: boolean;
+	teamId?: string;
+	teamName?: string;
+	teamRole?: "lead" | "teammate";
+	teamAgentId?: string;
+}
+
+export const CORE_TELEMETRY_EVENTS = {
+	CLIENT: {
+		EXTENSION_ACTIVATED: "user.extension_activated",
+	},
+	SESSION: {
+		STARTED: "session.started",
+		ENDED: "session.ended",
+	},
+	AGENT: {
+		UNEXPECTED_REASONING_TOKENS: AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+	},
+	USER: {
+		AUTH_STARTED: "user.auth_started",
+		AUTH_SUCCEEDED: "user.auth_succeeded",
+		AUTH_FAILED: "user.auth_failed",
+		AUTH_LOGGED_OUT: "user.auth_logged_out",
+		PROVIDER_CONFIGURED: "user.provider_configured",
+		TELEMETRY_OPT_OUT: "user.opt_out",
+	},
+	TASK: {
+		CREATED: "task.created",
+		RESTARTED: "task.restarted",
+		COMPLETED: "task.completed",
+		CONVERSATION_TURN: "task.conversation_turn",
+		TOKEN_USAGE: "task.tokens",
+		MODE_SWITCH: "task.mode",
+		TOOL_USED: "task.tool_used",
+		SKILL_USED: "task.skill_used",
+		DIFF_EDIT_FAILED: "task.diff_edit_failed",
+		PROVIDER_API_ERROR: "task.provider_api_error",
+		MENTION_USED: "task.mention_used",
+		MENTION_FAILED: "task.mention_failed",
+		MENTION_SEARCH_RESULTS: "task.mention_search_results",
+		AGENT_CREATED: "task.agent_created",
+		AGENT_TEAM_CREATED: "task.agent_team_created",
+		SUBAGENT_STARTED: "task.subagent_started",
+		SUBAGENT_COMPLETED: "task.subagent_completed",
+		COMPACTION_EXECUTED: "task.compaction_executed",
+		COMPACTION_SKIPPED: "task.compaction_skipped",
+		COMPACTION_BUDGET_EMERGENCY: "task.compaction_budget_emergency",
+	},
+	HOOKS: {
+		DISCOVERY_COMPLETED: "hooks.discovery_completed",
+	},
+	WORKSPACE: {
+		INITIALIZED: "workspace.initialized",
+		INIT_ERROR: "workspace.init_error",
+		PATH_RESOLVED: "workspace.path_resolved",
+	},
+	SDK: {
+		ERROR: SDK_ERROR_TELEMETRY_EVENT,
+		TOOL_TIMEOUT: "sdk.tool_timeout",
+	},
+	FEATURE_FLAGS: {
+		FLAG_CALLED: "$feature_flag_called",
+	},
+} as const;
+
+export interface RunCommandsTimeoutTelemetryProperties {
+	tool_name: "run_commands";
+	effective_timeout_ms: number;
+	timeout_source: "default_setting" | "configured_setting";
+	command_count: number;
+	duration_ms: number;
+	ulid?: string;
+	mode?: string;
+	source?: string;
+	session_id?: string;
+	agent_id?: string;
+	conversation_id?: string;
+	run_id?: string;
+	iteration?: number;
+	tool_call_id?: string;
+}
+
+export {
+	captureAgentUnexpectedReasoningTokens,
+	type CaptureAgentUnexpectedReasoningTokensInput,
+};
+
+export interface WorkspaceInitializedProperties {
+	root_count: number;
+	vcs_types: ReadonlyArray<string>;
+	init_duration_ms?: number;
+	feature_flag_enabled?: boolean;
+	is_remote_workspace?: boolean;
+}
+
+export interface WorkspaceInitErrorProperties {
+	fallback_to_single_root: boolean;
+	workspace_count?: number;
+}
+
+export interface WorkspacePathResolvedProperties {
+	ulid: string;
+	context: string;
+	resolution_type:
+		| "hint_provided"
+		| "fallback_to_primary"
+		| "cross_workspace_search";
+	hint_type?: "workspace_name" | "workspace_path" | "invalid";
+	resolution_success?: boolean;
+	target_workspace_index?: number;
+	is_multi_root_enabled?: boolean;
+}
+
+function emit(
+	telemetry: ITelemetryService | undefined,
+	event: string,
+	properties?: TelemetryProperties,
+): void {
+	telemetry?.capture({ event, properties });
+}
+
+function truncateErrorMessage(errorMessage?: string): string | undefined {
+	if (!errorMessage) {
+		return undefined;
+	}
+	return errorMessage.substring(0, MAX_ERROR_MESSAGE_LENGTH);
+}
+
+function normalizeErrorType(error: Error | string): string {
+	if (typeof error === "string") {
+		return "Error";
+	}
+	return error.name?.trim() || error.constructor?.name || "Error";
+}
+
+function normalizeErrorMessage(error: Error | string): string {
+	return typeof error === "string" ? error : error.message;
+}
+
+function hasVcsType(
+	vcsTypes: ReadonlyArray<string>,
+	candidates: ReadonlySet<string>,
+): boolean {
+	return vcsTypes.some((type) => candidates.has(type.trim().toLowerCase()));
+}
+
+export function captureExtensionActivated(
+	telemetry: ITelemetryService | undefined,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.CLIENT.EXTENSION_ACTIVATED);
+}
+
+export function captureWorkspaceInitialized(
+	telemetry: ITelemetryService | undefined,
+	properties: WorkspaceInitializedProperties,
+): void {
+	const vcsTypes = [...properties.vcs_types];
+	const payload: TelemetryProperties = {
+		root_count: properties.root_count,
+		vcs_types: vcsTypes,
+		is_multi_root: properties.root_count > 1,
+		has_git: hasVcsType(vcsTypes, new Set(["git"])),
+		has_mercurial: hasVcsType(vcsTypes, new Set(["mercurial", "hg"])),
+	};
+	if (properties.init_duration_ms !== undefined) {
+		payload.init_duration_ms = properties.init_duration_ms;
+	}
+	if (properties.feature_flag_enabled !== undefined) {
+		payload.feature_flag_enabled = properties.feature_flag_enabled;
+	}
+	if (properties.is_remote_workspace !== undefined) {
+		payload.is_remote_workspace = properties.is_remote_workspace;
+	}
+	emit(telemetry, CORE_TELEMETRY_EVENTS.WORKSPACE.INITIALIZED, payload);
+}
+
+export function captureWorkspaceInitError(
+	telemetry: ITelemetryService | undefined,
+	error: Error | string,
+	properties: WorkspaceInitErrorProperties,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.WORKSPACE.INIT_ERROR, {
+		error_type: normalizeErrorType(error),
+		error_message: truncateErrorMessage(normalizeErrorMessage(error)),
+		fallback_to_single_root: properties.fallback_to_single_root,
+		workspace_count: properties.workspace_count ?? 0,
+	});
+}
+
+export function captureWorkspacePathResolved(
+	telemetry: ITelemetryService | undefined,
+	properties: WorkspacePathResolvedProperties,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.WORKSPACE.PATH_RESOLVED, {
+		...properties,
+	});
+}
+
+export function captureAuthStarted(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.USER.AUTH_STARTED, { provider });
+}
+
+export function captureAuthSucceeded(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.USER.AUTH_SUCCEEDED, { provider });
+}
+
+export function captureAuthFailed(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+	errorMessage?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.USER.AUTH_FAILED, {
+		provider,
+		errorMessage: truncateErrorMessage(errorMessage),
+	});
+}
+
+export function captureAuthLoggedOut(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+	reason?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.USER.AUTH_LOGGED_OUT, {
+		provider,
+		reason,
+	});
+}
+
+/**
+ * Fires when the user finishes configuring a "bring your own provider"
+ * (API-key based) provider during onboarding or via settings.
+ *
+ * Unlike the OAuth/device-code `captureAuth*` events, the configure step is a
+ * synchronous local credential save with no network roundtrip, so there is no
+ * start/fail counterpart — the credential is validated lazily on the first
+ * subsequent API call. Mirrors the `{ provider }` payload shape of
+ * {@link captureAuthSucceeded} for funnel consistency.
+ */
+export function captureProviderConfigured(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.USER.PROVIDER_CONFIGURED, { provider });
+}
+
+export function captureTelemetryOptOut(
+	telemetry: ITelemetryService | undefined,
+	properties?: TelemetryProperties,
+): void {
+	telemetry?.captureRequired(
+		CORE_TELEMETRY_EVENTS.USER.TELEMETRY_OPT_OUT,
+		properties,
+	);
+}
+
+export function identifyAccount(
+	telemetry: ITelemetryService | undefined,
+	account: {
+		id?: string;
+		email?: string;
+		provider?: string;
+		organizationId?: string;
+		organizationName?: string;
+		memberId?: string;
+	},
+): void {
+	const distinctId = account.id?.trim();
+	if (distinctId) {
+		telemetry?.setDistinctId(distinctId);
+	}
+	telemetry?.updateCommonProperties({
+		user_id: distinctId || account.id,
+		account_id: account.id,
+		account_email: account.email,
+		provider: account.provider,
+		organization_id: account.organizationId,
+		organization_name: account.organizationName,
+		member_id: account.memberId,
+	});
+}
+
+export function captureTaskCreated(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		apiProvider?: string;
+		openAiCompatibleDomain?: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.CREATED, properties);
+}
+
+export function captureTaskRestarted(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		apiProvider?: string;
+		openAiCompatibleDomain?: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.RESTARTED, properties);
+}
+
+/**
+ * Distinguishes the trigger that produced a `task.completed` telemetry event.
+ *
+ * - `submit_and_exit`: the assistant explicitly declared completion by
+ *   invoking the canonical completion tool. Parity with original Cline's
+ *   `attempt_completion`-anchored emission.
+ * - `shutdown`: the session lifecycle completed (typically a non-interactive
+ *   single-run that finished without an explicit completion tool). Acts as a
+ *   safety-net so we still report completed runs that never observed
+ *   `submit_and_exit`.
+ */
+export type TaskCompletedSource = "submit_and_exit" | "shutdown";
+
+export function captureTaskCompleted(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		provider?: string;
+		modelId?: string;
+		mode?: string;
+		durationMs?: number;
+		source?: TaskCompletedSource;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.COMPLETED, properties);
+}
+
+export function captureConversationTurnEvent(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		provider?: string;
+		model?: string;
+		source: "user" | "assistant";
+		mode?: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.CONVERSATION_TURN, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureTokenUsage(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		tokensIn: number;
+		tokensOut: number;
+		cacheWriteTokens?: number;
+		cacheReadTokens?: number;
+		totalCost?: number;
+		model: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.TOKEN_USAGE, properties);
+}
+
+export function captureModeSwitch(
+	telemetry: ITelemetryService | undefined,
+	ulid: string,
+	mode?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.MODE_SWITCH, { ulid, mode });
+}
+
+export function captureToolUsage(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		tool: string;
+		modelId?: string;
+		provider?: string;
+		autoApproved?: boolean;
+		success: boolean;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.TOOL_USED, properties);
+}
+
+export function captureSkillUsed(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		skillName: string;
+		skillSource: "global" | "project";
+		skillsAvailableGlobal: number;
+		skillsAvailableProject: number;
+		provider?: string;
+		modelId?: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.SKILL_USED, properties);
+}
+
+export function captureDiffEditFailure(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		modelId?: string;
+		provider?: string;
+		errorType?: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.DIFF_EDIT_FAILED, properties);
+}
+
+export function captureProviderApiError(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		model: string;
+		errorMessage: string;
+		provider?: string;
+		errorStatus?: number;
+		requestId?: string;
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.PROVIDER_API_ERROR, {
+		...properties,
+		errorMessage: truncateErrorMessage(properties.errorMessage) ?? "unknown",
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureRunCommandsTimeout(
+	telemetry: ITelemetryService | undefined,
+	properties: RunCommandsTimeoutTelemetryProperties,
+): void {
+	emit(
+		telemetry,
+		CORE_TELEMETRY_EVENTS.SDK.TOOL_TIMEOUT,
+		stripUndefinedProperties(properties),
+	);
+}
+
+function stripUndefinedProperties(properties: object): TelemetryProperties {
+	const result: TelemetryProperties = {};
+	for (const [key, value] of Object.entries(properties)) {
+		if (value !== undefined) {
+			result[key] = value;
+		}
+	}
+	return result;
+}
+
+export function captureMentionUsed(
+	telemetry: ITelemetryService | undefined,
+	mentionType:
+		| "file"
+		| "folder"
+		| "url"
+		| "problems"
+		| "terminal"
+		| "git-changes"
+		| "commit",
+	contentLength?: number,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.MENTION_USED, {
+		mentionType,
+		contentLength,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureMentionFailed(
+	telemetry: ITelemetryService | undefined,
+	mentionType:
+		| "file"
+		| "folder"
+		| "url"
+		| "problems"
+		| "terminal"
+		| "git-changes"
+		| "commit",
+	errorType:
+		| "not_found"
+		| "permission_denied"
+		| "network_error"
+		| "parse_error"
+		| "unknown",
+	errorMessage?: string,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.MENTION_FAILED, {
+		mentionType,
+		errorType,
+		errorMessage: truncateErrorMessage(errorMessage),
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureMentionSearchResults(
+	telemetry: ITelemetryService | undefined,
+	query: string,
+	resultCount: number,
+	searchType: "file" | "folder" | "all",
+	isEmpty: boolean,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.MENTION_SEARCH_RESULTS, {
+		queryLength: query.length,
+		resultCount,
+		searchType,
+		isEmpty,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureAgentCreated(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		modelId?: string;
+		provider?: string;
+	} & TelemetryAgentIdentityProperties,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.AGENT_CREATED, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureAgentTeamCreated(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		teamId: string;
+		teamName: string;
+		leadAgentId?: string;
+		restoredFromPersistence?: boolean;
+	},
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.AGENT_TEAM_CREATED, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureSubagentExecution(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		durationMs: number;
+		outputLines?: number;
+		event: "created" | "started" | "ended";
+		agentId: string;
+		parentId?: string;
+		errorMessage?: string;
+		type?: "agent" | "team";
+	} & Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(
+		telemetry,
+		properties.event === "ended"
+			? CORE_TELEMETRY_EVENTS.TASK.SUBAGENT_COMPLETED
+			: CORE_TELEMETRY_EVENTS.TASK.SUBAGENT_STARTED,
+		{
+			...properties,
+			timestamp: new Date().toISOString(),
+		},
+	);
+}
+
+export function captureHookDiscovery(
+	telemetry: ITelemetryService | undefined,
+	hookName: string,
+	globalCount: number,
+	workspaceCount: number,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.HOOKS.DISCOVERY_COMPLETED, {
+		hookName,
+		globalCount,
+		workspaceCount,
+		totalCount: globalCount + workspaceCount,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+/**
+ * Identifies which compaction implementation produced a
+ * `task.compaction_executed` / `task.compaction_skipped` event.
+ *
+ * - `basic`   — built-in token-budget truncation
+ *   (see `extensions/context/basic-compaction.ts`).
+ * - `agentic` — built-in LLM-powered summarization
+ *   (see `extensions/context/agentic-compaction.ts`).
+ * - `custom`  — user-supplied `compaction.compact()` callback on
+ *   `CoreSessionConfig`.
+ */
+export type TelemetryCompactionStrategy = "basic" | "agentic" | "custom";
+
+/**
+ * Trigger mode for a compaction attempt.
+ *
+ * - `auto`   — fired automatically by `createContextCompactionPrepareTurn`
+ *   when input tokens exceed the configured threshold.
+ * - `manual` — user-initiated (e.g. CLI `/compact`).
+ */
+export type TelemetryCompactionMode = "auto" | "manual";
+
+export interface CaptureCompactionExecutedProperties {
+	ulid: string;
+	strategy: TelemetryCompactionStrategy;
+	mode: TelemetryCompactionMode;
+	messagesBefore: number;
+	messagesAfter: number;
+	messagesRemoved: number;
+	tokensBefore: number;
+	tokensAfter: number;
+	tokensSaved: number;
+	triggerTokens: number;
+	maxInputTokens: number;
+	thresholdRatio: number;
+	durationMs: number;
+	// Name matches the rest of the TASK-namespace capture functions
+	// (`captureTaskCompleted`, `captureToolUsage`, etc.) — using `provider`,
+	// not `providerId`, keeps downstream PostHog joins consistent.
+	provider?: string;
+	modelId?: string;
+}
+
+export function captureCompactionExecuted(
+	telemetry: ITelemetryService | undefined,
+	properties: CaptureCompactionExecutedProperties &
+		Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.COMPACTION_EXECUTED, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export interface CaptureCompactionSkippedProperties {
+	ulid: string;
+	strategy: TelemetryCompactionStrategy;
+	mode: TelemetryCompactionMode;
+	/**
+	 * Why the strategy decided not to compact. Currently only one value is
+	 * emitted by the wrapper:
+	 * - `no_result` — strategy returned `undefined` (e.g. there was nothing
+	 *   safe to remove). Strategy *exceptions* propagate up instead of
+	 *   firing telemetry, so no `strategy_error` value is emitted today.
+	 * The field is kept loosely typed (`string`) so additional reasons can
+	 * be introduced without changing the schema.
+	 */
+	reason: string;
+	tokensBefore: number;
+	triggerTokens: number;
+	maxInputTokens: number;
+	thresholdRatio: number;
+	durationMs: number;
+	provider?: string;
+	modelId?: string;
+}
+
+export function captureCompactionSkipped(
+	telemetry: ITelemetryService | undefined,
+	properties: CaptureCompactionSkippedProperties &
+		Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.COMPACTION_SKIPPED, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export interface CaptureCompactionBudgetEmergencyProperties {
+	ulid: string;
+	strategy: TelemetryCompactionStrategy;
+	mode: TelemetryCompactionMode;
+	policyIntent: CoreCompactionBudgetPolicyIntent;
+	actionCount: number;
+	warningCount: number;
+	liveTailHandling: CoreCompactionLiveTailHandling;
+	provider?: string;
+	modelId?: string;
+}
+
+export function captureCompactionBudgetEmergency(
+	telemetry: ITelemetryService | undefined,
+	properties: CaptureCompactionBudgetEmergencyProperties &
+		Partial<TelemetryAgentIdentityProperties>,
+): void {
+	emit(telemetry, CORE_TELEMETRY_EVENTS.TASK.COMPACTION_BUDGET_EMERGENCY, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
diff --git a/sdk/packages/core/src/services/telemetry/distinct-id.test.ts b/sdk/packages/core/src/services/telemetry/distinct-id.test.ts
new file mode 100644
index 0000000..4b4c41e
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/distinct-id.test.ts
@@ -0,0 +1,57 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const machineIdSyncMock = vi.hoisted(() => vi.fn());
+
+vi.mock("node-machine-id", () => ({
+	machineIdSync: machineIdSyncMock,
+}));
+
+describe("resolveCoreDistinctId", () => {
+	beforeEach(() => {
+		vi.resetModules();
+	});
+
+	afterEach(() => {
+		machineIdSyncMock.mockReset();
+		vi.unstubAllEnvs();
+		vi.restoreAllMocks();
+	});
+
+	it("returns the explicit distinct ID override when provided", async () => {
+		const { resolveCoreDistinctId } = await import("./distinct-id");
+
+		expect(resolveCoreDistinctId("  user-provided-id  ")).toBe(
+			"user-provided-id",
+		);
+		expect(machineIdSyncMock).not.toHaveBeenCalled();
+	});
+
+	it("uses node-machine-id when no explicit override is provided", async () => {
+		machineIdSyncMock.mockReturnValue("machine-id-123");
+		const { resolveCoreDistinctId } = await import("./distinct-id");
+
+		expect(resolveCoreDistinctId()).toBe("machine-id-123");
+	});
+
+	it("persists and reuses a generated fallback when machine ID lookup fails", async () => {
+		const tempDir = mkdtempSync(join(tmpdir(), "cline-distinct-id-"));
+		try {
+			vi.stubEnv("CLINE_DATA_DIR", tempDir);
+			machineIdSyncMock.mockImplementation(() => {
+				throw new Error("machine id unavailable");
+			});
+
+			const { resolveCoreDistinctId } = await import("./distinct-id");
+			const first = resolveCoreDistinctId();
+			const second = resolveCoreDistinctId();
+
+			expect(first).toMatch(/^cl-/);
+			expect(second).toBe(first);
+		} finally {
+			rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/services/telemetry/distinct-id.ts b/sdk/packages/core/src/services/telemetry/distinct-id.ts
new file mode 100644
index 0000000..6036a78
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/distinct-id.ts
@@ -0,0 +1,69 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { resolveSessionDataDir } from "@cline/shared/storage";
+import { nanoid } from "nanoid";
+import * as nodeMachineId from "node-machine-id";
+
+const GENERATED_DISTINCT_ID_FILE_NAME = "machine-id";
+
+export function resolveCoreDistinctId(explicitDistinctId?: string): string {
+	const normalizedDistinctId = explicitDistinctId?.trim();
+	if (normalizedDistinctId) {
+		return normalizedDistinctId;
+	}
+
+	const machineDistinctId = getMachineDistinctId();
+	if (machineDistinctId) {
+		return machineDistinctId;
+	}
+
+	return resolveGeneratedFallbackDistinctId();
+}
+
+function resolveMachineIdSync(): ((original?: boolean) => string) | undefined {
+	const module = nodeMachineId as typeof nodeMachineId & {
+		default?: typeof nodeMachineId;
+	};
+	return module.machineIdSync ?? module.default?.machineIdSync;
+}
+
+function getMachineDistinctId(): string | undefined {
+	try {
+		const machineIdSync = resolveMachineIdSync();
+		if (!machineIdSync) {
+			return undefined;
+		}
+		const distinctId = machineIdSync();
+		return distinctId.trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveGeneratedFallbackDistinctId(): string {
+	const sessionDataDir = resolveSessionDataDir();
+	const distinctIdPath = resolve(
+		sessionDataDir,
+		GENERATED_DISTINCT_ID_FILE_NAME,
+	);
+
+	try {
+		if (existsSync(distinctIdPath)) {
+			const savedDistinctId = readFileSync(distinctIdPath, "utf8").trim();
+			if (savedDistinctId.length > 0) {
+				return savedDistinctId;
+			}
+		}
+	} catch {
+		// Ignore read errors and try generating a new fallback.
+	}
+
+	const generatedDistinctId = `cl-${nanoid()}`;
+	try {
+		mkdirSync(sessionDataDir, { recursive: true });
+		writeFileSync(distinctIdPath, generatedDistinctId, "utf8");
+	} catch {
+		// Ignore write errors and continue with the in-memory fallback.
+	}
+	return generatedDistinctId;
+}
diff --git a/sdk/packages/core/src/services/telemetry/index.ts b/sdk/packages/core/src/services/telemetry/index.ts
new file mode 100644
index 0000000..6f061b7
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/index.ts
@@ -0,0 +1,23 @@
+export { resolveCoreDistinctId } from "./distinct-id";
+export type {
+	ITelemetryAdapter,
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+} from "./ITelemetryAdapter";
+export {
+	OpenTelemetryAdapter,
+	type OpenTelemetryAdapterOptions,
+} from "./OpenTelemetryAdapter";
+export {
+	type ConfiguredTelemetryHandle,
+	type CreateOpenTelemetryTelemetryServiceOptions,
+	createConfiguredTelemetryHandle,
+	createConfiguredTelemetryService,
+	createOpenTelemetryTelemetryService,
+	OpenTelemetryProvider,
+	type OpenTelemetryProviderOptions,
+} from "./OpenTelemetryProvider";
diff --git a/sdk/packages/core/src/services/telemetry/tool-context.ts b/sdk/packages/core/src/services/telemetry/tool-context.ts
new file mode 100644
index 0000000..362a900
--- /dev/null
+++ b/sdk/packages/core/src/services/telemetry/tool-context.ts
@@ -0,0 +1,15 @@
+import type { ITelemetryService } from "@cline/shared";
+
+export const CLINE_INTERNAL_TELEMETRY_METADATA_KEY = "__clineInternalTelemetry";
+
+export function getToolContextTelemetry(
+	metadata: Record<string, unknown> | undefined,
+): ITelemetryService | undefined {
+	const telemetry = metadata?.[CLINE_INTERNAL_TELEMETRY_METADATA_KEY];
+	return telemetry &&
+		typeof telemetry === "object" &&
+		"capture" in telemetry &&
+		typeof telemetry.capture === "function"
+		? (telemetry as ITelemetryService)
+		: undefined;
+}
diff --git a/sdk/packages/core/src/services/usage.test.ts b/sdk/packages/core/src/services/usage.test.ts
new file mode 100644
index 0000000..7815001
--- /dev/null
+++ b/sdk/packages/core/src/services/usage.test.ts
@@ -0,0 +1,75 @@
+import type { MessageWithMetadata } from "@cline/llms";
+import { describe, expect, it } from "vitest";
+import { getCurrentContextSize, summarizeUsageFromMessages } from "./usage";
+
+function assistant(
+	metrics?: MessageWithMetadata["metrics"],
+): MessageWithMetadata {
+	return {
+		role: "assistant",
+		content: "ok",
+		...(metrics ? { metrics } : {}),
+	};
+}
+
+function user(): MessageWithMetadata {
+	return { role: "user", content: "hi" };
+}
+
+describe("getCurrentContextSize", () => {
+	it("returns undefined when there is no assistant message", () => {
+		expect(getCurrentContextSize([user()])).toBeUndefined();
+		expect(getCurrentContextSize([])).toBeUndefined();
+	});
+
+	it("returns undefined when the latest assistant message has no metrics", () => {
+		expect(getCurrentContextSize([user(), assistant()])).toBeUndefined();
+	});
+
+	it("uses the latest assistant call's inputTokens", () => {
+		const messages: MessageWithMetadata[] = [
+			user(),
+			assistant({ inputTokens: 100, outputTokens: 10 }),
+			user(),
+			assistant({ inputTokens: 5000, outputTokens: 50 }),
+		];
+
+		expect(getCurrentContextSize(messages)).toBe(5000);
+	});
+
+	it("ignores user messages after the latest assistant message", () => {
+		expect(
+			getCurrentContextSize([assistant({ inputTokens: 250 }), user()]),
+		).toBe(250);
+	});
+
+	it("returns undefined when inputTokens is zero", () => {
+		expect(
+			getCurrentContextSize([assistant({ inputTokens: 0, outputTokens: 0 })]),
+		).toBeUndefined();
+	});
+
+	it("does not double-count cache token details", () => {
+		expect(
+			getCurrentContextSize([
+				assistant({ inputTokens: 9096, cacheReadTokens: 9090 }),
+			]),
+		).toBe(9096);
+		expect(
+			getCurrentContextSize([
+				assistant({ inputTokens: 6538, cacheWriteTokens: 6535 }),
+			]),
+		).toBe(6538);
+	});
+});
+
+describe("summarizeUsageFromMessages", () => {
+	it("sums additive per-message cost", () => {
+		expect(
+			summarizeUsageFromMessages([
+				assistant({ inputTokens: 100, outputTokens: 10, cost: 0.01 }),
+				assistant({ inputTokens: 200, outputTokens: 20, cost: 0.02 }),
+			]).totalCost,
+		).toBe(0.03);
+	});
+});
diff --git a/sdk/packages/core/src/services/usage.ts b/sdk/packages/core/src/services/usage.ts
new file mode 100644
index 0000000..8b2b56e
--- /dev/null
+++ b/sdk/packages/core/src/services/usage.ts
@@ -0,0 +1,87 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+
+export function createInitialAccumulatedUsage(): SessionAccumulatedUsage {
+	return {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		totalCost: 0,
+	};
+}
+
+export function accumulateUsageTotals(
+	baseline: SessionAccumulatedUsage,
+	usage: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	},
+): SessionAccumulatedUsage {
+	return {
+		inputTokens: baseline.inputTokens + Math.max(0, usage.inputTokens ?? 0),
+		outputTokens: baseline.outputTokens + Math.max(0, usage.outputTokens ?? 0),
+		cacheReadTokens:
+			baseline.cacheReadTokens + Math.max(0, usage.cacheReadTokens ?? 0),
+		cacheWriteTokens:
+			baseline.cacheWriteTokens + Math.max(0, usage.cacheWriteTokens ?? 0),
+		totalCost: baseline.totalCost + Math.max(0, usage.totalCost ?? 0),
+	};
+}
+
+export function sumUsageTotals(
+	usages: Iterable<SessionAccumulatedUsage>,
+): SessionAccumulatedUsage {
+	let total = createInitialAccumulatedUsage();
+	for (const usage of usages) {
+		total = accumulateUsageTotals(total, usage);
+	}
+	return total;
+}
+
+function asNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+export function summarizeUsageFromMessages(
+	messages: LlmsProviders.Message[],
+): SessionAccumulatedUsage {
+	let usage = createInitialAccumulatedUsage();
+	for (const message of messages) {
+		const metrics = (message as LlmsProviders.MessageWithMetadata).metrics;
+		if (!metrics) {
+			continue;
+		}
+		usage = accumulateUsageTotals(usage, {
+			inputTokens: asNumber(metrics.inputTokens),
+			outputTokens: asNumber(metrics.outputTokens),
+			cacheReadTokens: asNumber(metrics.cacheReadTokens),
+			cacheWriteTokens: asNumber(metrics.cacheWriteTokens),
+			totalCost: asNumber(metrics.cost),
+		});
+	}
+	return usage;
+}
+
+/**
+ * Current model context-window usage, derived from the latest assistant LLM
+ * call. Provider usage is normalized so `inputTokens` is already the full
+ * prompt size, including any cache-read/cache-write portions. Do not add cache
+ * fields back on top.
+ */
+export function getCurrentContextSize(
+	messages: readonly LlmsProviders.Message[],
+): number | undefined {
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const message = messages[i] as
+			| LlmsProviders.MessageWithMetadata
+			| undefined;
+		if (message?.role !== "assistant") continue;
+		const inputTokens = asNumber(message.metrics?.inputTokens);
+		return inputTokens > 0 ? inputTokens : undefined;
+	}
+	return undefined;
+}
diff --git a/sdk/packages/core/src/services/workspace/file-indexer.test.ts b/sdk/packages/core/src/services/workspace/file-indexer.test.ts
new file mode 100644
index 0000000..6c3c220
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/file-indexer.test.ts
@@ -0,0 +1,156 @@
+import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { getFileIndex, prewarmFileIndex } from "./file-indexer";
+
+vi.mock("node:worker_threads", async () => {
+	const actual = await vi.importActual<typeof import("node:worker_threads")>(
+		"node:worker_threads",
+	);
+	return {
+		...actual,
+		isMainThread: false,
+		parentPort: null,
+	};
+});
+
+async function createTempWorkspace(): Promise<string> {
+	return mkdtemp(path.join(os.tmpdir(), "core-file-index-"));
+}
+
+describe("file indexer", () => {
+	it("indexes files by relative posix path", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await mkdir(path.join(cwd, "src"), { recursive: true });
+			await writeFile(path.join(cwd, "src", "main.ts"), "export {}\n", "utf8");
+			await writeFile(path.join(cwd, "README.md"), "# Demo\n", "utf8");
+
+			const index = await getFileIndex(cwd, { ttlMs: 0 });
+			expect(index.has("src/main.ts")).toBe(true);
+			expect(index.has("README.md")).toBe(true);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("always excludes .git files from index", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await mkdir(path.join(cwd, ".git"), { recursive: true });
+			await mkdir(path.join(cwd, "node_modules", "pkg"), { recursive: true });
+			await writeFile(path.join(cwd, ".git", "config"), "[core]\n", "utf8");
+			await writeFile(
+				path.join(cwd, "node_modules", "pkg", "index.js"),
+				"module.exports = {}\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(cwd, "app.ts"),
+				"export const app = 1\n",
+				"utf8",
+			);
+
+			const index = await getFileIndex(cwd, { ttlMs: 0 });
+			expect(index.has("app.ts")).toBe(true);
+			expect(index.has(".git/config")).toBe(false);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("prewarm rebuilds index and includes new files", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(
+				path.join(cwd, "first.ts"),
+				"export const first = 1\n",
+				"utf8",
+			);
+			const firstIndex = await getFileIndex(cwd, { ttlMs: 60_000 });
+			expect(firstIndex.has("first.ts")).toBe(true);
+
+			await writeFile(
+				path.join(cwd, "second.ts"),
+				"export const second = 2\n",
+				"utf8",
+			);
+			await prewarmFileIndex(cwd, { ttlMs: 60_000 });
+
+			const rebuilt = await getFileIndex(cwd, { ttlMs: 60_000 });
+			expect(rebuilt.has("second.ts")).toBe(true);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("skips unreadable directories during fallback indexing", async () => {
+		const cwd = await createTempWorkspace();
+		const unreadableDir = path.join(cwd, "private");
+		try {
+			await mkdir(unreadableDir, { recursive: true });
+			await writeFile(
+				path.join(cwd, "visible.ts"),
+				"export const ok = 1\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(unreadableDir, "hidden.ts"),
+				"export const hidden = 1\n",
+				"utf8",
+			);
+			await chmod(unreadableDir, 0o000);
+
+			await expect(
+				prewarmFileIndex(cwd, { ttlMs: 0 }),
+			).resolves.toBeUndefined();
+
+			const index = await getFileIndex(cwd, { ttlMs: 0 });
+			expect(index.has("visible.ts")).toBe(true);
+		} finally {
+			await chmod(unreadableDir, 0o755).catch(() => undefined);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("evicts stale workspace indexes after 10 minutes when multiple workspaces exist", async () => {
+		vi.useFakeTimers();
+		const firstWorkspace = await createTempWorkspace();
+		const secondWorkspace = await createTempWorkspace();
+		try {
+			await writeFile(
+				path.join(firstWorkspace, "first.ts"),
+				"export const first = 1\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(secondWorkspace, "second.ts"),
+				"export const second = 2\n",
+				"utf8",
+			);
+
+			const firstIndex = await getFileIndex(firstWorkspace, { ttlMs: 60_000 });
+			expect(firstIndex.has("first.ts")).toBe(true);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			vi.advanceTimersByTime(10 * 60_000 + 1);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			await writeFile(
+				path.join(firstWorkspace, "later.ts"),
+				"export const later = 3\n",
+				"utf8",
+			);
+
+			const rebuiltFirstIndex = await getFileIndex(firstWorkspace, {
+				ttlMs: 60_000,
+			});
+			expect(rebuiltFirstIndex.has("later.ts")).toBe(true);
+		} finally {
+			vi.useRealTimers();
+			await rm(firstWorkspace, { recursive: true, force: true });
+			await rm(secondWorkspace, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/services/workspace/file-indexer.ts b/sdk/packages/core/src/services/workspace/file-indexer.ts
new file mode 100644
index 0000000..29fba11
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/file-indexer.ts
@@ -0,0 +1,364 @@
+import { spawn } from "node:child_process";
+import type { Dirent } from "node:fs";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { isMainThread, parentPort, Worker } from "node:worker_threads";
+
+const DEFAULT_INDEX_TTL_MS = 15_000;
+const STALE_CACHE_EVICTION_MS = 10 * 60_000;
+const WORKER_INDEX_REQUEST_TIMEOUT_MS = 1_000;
+const DEFAULT_EXCLUDE_DIRS = new Set([
+	".git",
+	"node_modules",
+	"dist",
+	"build",
+	".next",
+	"coverage",
+	".turbo",
+	".cache",
+	"target",
+	"out",
+]);
+
+function shouldSkipWalkError(error: unknown): boolean {
+	const code =
+		error && typeof error === "object" && "code" in error
+			? String((error as { code?: unknown }).code ?? "")
+			: "";
+	return code === "EACCES" || code === "EPERM" || code === "ENOENT";
+}
+
+interface CacheEntry {
+	files: Set<string>;
+	lastBuiltAt: number;
+	lastAccessedAt: number;
+	pending: Promise<Set<string>> | null;
+}
+
+export interface FastFileIndexOptions {
+	ttlMs?: number;
+}
+
+interface IndexRequestMessage {
+	type: "index";
+	requestId: number;
+	cwd: string;
+}
+
+interface IndexResponseMessage {
+	type: "indexResult";
+	requestId: number;
+	files?: string[];
+	error?: string;
+}
+
+const CACHE = new Map<string, CacheEntry>();
+
+function canUseFileIndexWorker(): boolean {
+	if (!isMainThread) {
+		return false;
+	}
+
+	return true;
+}
+
+function pruneStaleCacheEntries(now: number): void {
+	if (CACHE.size <= 1) {
+		return;
+	}
+	for (const [cwd, entry] of CACHE.entries()) {
+		if (entry.pending) {
+			continue;
+		}
+		if (now - entry.lastAccessedAt > STALE_CACHE_EVICTION_MS) {
+			CACHE.delete(cwd);
+		}
+	}
+}
+
+function toPosixRelative(cwd: string, absolutePath: string): string {
+	return path.relative(cwd, absolutePath).split(path.sep).join("/");
+}
+
+async function listFilesWithRg(cwd: string): Promise<Set<string>> {
+	const output = await new Promise<string>((resolve, reject) => {
+		const child = spawn("rg", ["--files", "--hidden", "-g", "!.git"], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			// Prevent a console window from flashing on Windows.
+			windowsHide: true,
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		child.stdout.on("data", (chunk: Buffer | string) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk: Buffer | string) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", reject);
+		child.on("close", (code: number | null) => {
+			if (code === 0) {
+				resolve(stdout);
+				return;
+			}
+			reject(new Error(stderr || `rg exited with code ${code}`));
+		});
+	});
+
+	const files = output
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0)
+		.map((line) => line.replace(/\\/g, "/"));
+
+	return new Set(files);
+}
+
+async function walkDir(
+	cwd: string,
+	dir: string,
+	files: Set<string>,
+): Promise<void> {
+	let entries: Dirent[];
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		if (shouldSkipWalkError(error)) {
+			return;
+		}
+		throw error;
+	}
+	for (const entry of entries) {
+		const absolutePath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (DEFAULT_EXCLUDE_DIRS.has(entry.name)) {
+				continue;
+			}
+			try {
+				await walkDir(cwd, absolutePath, files);
+			} catch (error) {
+				if (shouldSkipWalkError(error)) {
+					continue;
+				}
+				throw error;
+			}
+			continue;
+		}
+		if (entry.isFile()) {
+			files.add(toPosixRelative(cwd, absolutePath));
+		}
+	}
+}
+
+async function listFilesFallback(cwd: string): Promise<Set<string>> {
+	const files = new Set<string>();
+	await walkDir(cwd, cwd, files);
+	return files;
+}
+
+async function buildIndex(cwd: string): Promise<Set<string>> {
+	try {
+		return await listFilesWithRg(cwd);
+	} catch {
+		return listFilesFallback(cwd);
+	}
+}
+
+function startWorkerServer(): void {
+	if (isMainThread || !parentPort) {
+		return;
+	}
+	const port = parentPort;
+
+	port.on("message", (message: IndexRequestMessage) => {
+		if (message.type !== "index") {
+			return;
+		}
+
+		void buildIndex(message.cwd)
+			.then((files) => {
+				const response: IndexResponseMessage = {
+					type: "indexResult",
+					requestId: message.requestId,
+					files: Array.from(files),
+				};
+				port.postMessage(response);
+			})
+			.catch((error: unknown) => {
+				const response: IndexResponseMessage = {
+					type: "indexResult",
+					requestId: message.requestId,
+					error:
+						error instanceof Error
+							? error.message
+							: "Failed to build file index",
+				};
+				port.postMessage(response);
+			});
+	});
+}
+
+class FileIndexWorkerClient {
+	private readonly worker = new Worker(new URL(import.meta.url));
+	private nextRequestId = 0;
+	private pending = new Map<
+		number,
+		{
+			resolve: (files: string[]) => void;
+			reject: (reason: Error) => void;
+		}
+	>();
+
+	constructor() {
+		// Keep indexing opportunistic: this worker should never block process exit.
+		this.worker.unref();
+		this.worker.on("message", (message: IndexResponseMessage) => {
+			if (message.type !== "indexResult") {
+				return;
+			}
+			const request = this.pending.get(message.requestId);
+			if (!request) {
+				return;
+			}
+			this.pending.delete(message.requestId);
+			if (message.error) {
+				request.reject(new Error(message.error));
+				return;
+			}
+			request.resolve(message.files ?? []);
+		});
+
+		this.worker.on("error", (error: Error) => {
+			this.flushPending(error);
+		});
+
+		this.worker.on("exit", (code) => {
+			if (code !== 0) {
+				this.flushPending(
+					new Error(`File index worker exited with code ${code}`),
+				);
+			}
+		});
+	}
+
+	requestIndex(cwd: string): Promise<string[] | null> {
+		const requestId = ++this.nextRequestId;
+		const result = new Promise<string[] | null>((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(requestId);
+				resolve(null);
+			}, WORKER_INDEX_REQUEST_TIMEOUT_MS);
+			timeout.unref();
+			this.pending.set(requestId, {
+				resolve: (files) => {
+					clearTimeout(timeout);
+					resolve(files);
+				},
+				reject: (reason) => {
+					clearTimeout(timeout);
+					reject(reason);
+				},
+			});
+		});
+
+		const message: IndexRequestMessage = {
+			type: "index",
+			requestId,
+			cwd,
+		};
+		this.worker.postMessage(message);
+		return result;
+	}
+
+	private flushPending(error: Error): void {
+		for (const [requestId, request] of this.pending.entries()) {
+			request.reject(error);
+			this.pending.delete(requestId);
+		}
+	}
+}
+
+startWorkerServer();
+
+let workerClient: FileIndexWorkerClient | null | undefined;
+
+function getWorkerClient(): FileIndexWorkerClient | null {
+	if (!canUseFileIndexWorker()) {
+		return null;
+	}
+	if (workerClient === undefined) {
+		workerClient = new FileIndexWorkerClient();
+	}
+	return workerClient;
+}
+
+async function buildIndexInBackground(cwd: string): Promise<Set<string>> {
+	const workerClient = getWorkerClient();
+	if (!workerClient) {
+		return buildIndex(cwd);
+	}
+
+	try {
+		const files = await workerClient.requestIndex(cwd);
+		if (files === null) {
+			return buildIndex(cwd);
+		}
+		return new Set(files);
+	} catch {
+		return buildIndex(cwd);
+	}
+}
+
+export async function getFileIndex(
+	cwd: string,
+	options: FastFileIndexOptions = {},
+): Promise<Set<string>> {
+	const ttlMs = options.ttlMs ?? DEFAULT_INDEX_TTL_MS;
+	const now = Date.now();
+	pruneStaleCacheEntries(now);
+	const existing = CACHE.get(cwd);
+
+	if (
+		existing &&
+		ttlMs > 0 &&
+		now - existing.lastBuiltAt <= ttlMs &&
+		existing.files.size > 0
+	) {
+		existing.lastAccessedAt = now;
+		return existing.files;
+	}
+
+	if (existing?.pending) {
+		existing.lastAccessedAt = now;
+		return existing.pending;
+	}
+
+	const pending = buildIndexInBackground(cwd).then((files) => {
+		CACHE.set(cwd, {
+			files,
+			lastBuiltAt: Date.now(),
+			lastAccessedAt: Date.now(),
+			pending: null,
+		});
+		return files;
+	});
+
+	CACHE.set(cwd, {
+		files: existing?.files ?? new Set<string>(),
+		lastBuiltAt: existing?.lastBuiltAt ?? 0,
+		lastAccessedAt: now,
+		pending,
+	});
+
+	return pending;
+}
+
+export async function prewarmFileIndex(
+	cwd: string,
+	options: FastFileIndexOptions = {},
+): Promise<void> {
+	await getFileIndex(cwd, { ...options, ttlMs: 0 });
+}
diff --git a/sdk/packages/core/src/services/workspace/index.ts b/sdk/packages/core/src/services/workspace/index.ts
new file mode 100644
index 0000000..583a21e
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/index.ts
@@ -0,0 +1,7 @@
+export type { FastFileIndexOptions } from "./file-indexer";
+export { getFileIndex, prewarmFileIndex } from "./file-indexer";
+export type {
+	MentionEnricherOptions,
+	MentionEnrichmentResult,
+} from "./mention-enricher";
+export { enrichPromptWithMentions } from "./mention-enricher";
diff --git a/sdk/packages/core/src/services/workspace/mention-enricher.test.ts b/sdk/packages/core/src/services/workspace/mention-enricher.test.ts
new file mode 100644
index 0000000..da2bc88
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/mention-enricher.test.ts
@@ -0,0 +1,106 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { enrichPromptWithMentions } from "./mention-enricher";
+
+vi.mock("node:worker_threads", async () => {
+	const actual = await vi.importActual<typeof import("node:worker_threads")>(
+		"node:worker_threads",
+	);
+	return {
+		...actual,
+		isMainThread: false,
+		parentPort: null,
+	};
+});
+
+async function createTempWorkspace(): Promise<string> {
+	return mkdtemp(path.join(os.tmpdir(), "core-mentions-"));
+}
+
+describe("enrichPromptWithMentions", () => {
+	it("returns matched files for matching @path mentions", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			const sourcePath = path.join(cwd, "src", "index.ts");
+			await mkdir(path.dirname(sourcePath), { recursive: true });
+			await writeFile(sourcePath, "export const answer = 42\n", "utf8");
+
+			const result = await enrichPromptWithMentions(
+				"Review @src/index.ts",
+				cwd,
+			);
+
+			expect(result.mentions).toEqual(["src/index.ts"]);
+			expect(result.matchedFiles).toEqual(["src/index.ts"]);
+			expect(result.ignoredMentions).toEqual([]);
+			expect(result.prompt).toBe("Review @src/index.ts");
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("ignores emails and unmatched mentions", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(path.join(cwd, "README.md"), "# Demo\n", "utf8");
+
+			const result = await enrichPromptWithMentions(
+				"Ping me at test@example.com and check @missing/file.ts.",
+				cwd,
+			);
+
+			expect(result.mentions).toEqual(["missing/file.ts"]);
+			expect(result.matchedFiles).toEqual([]);
+			expect(result.ignoredMentions).toEqual(["missing/file.ts"]);
+			expect(result.prompt).toBe(
+				"Ping me at test@example.com and check @missing/file.ts.",
+			);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("respects maxTotalBytes while keeping prompt unchanged", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(path.join(cwd, "a.ts"), "123", "utf8");
+			await writeFile(path.join(cwd, "b.ts"), "const b = 2\n", "utf8");
+
+			const result = await enrichPromptWithMentions(
+				"Use @a.ts and @b.ts",
+				cwd,
+				{ maxTotalBytes: 5, maxFiles: 2, maxFileBytes: 5 },
+			);
+
+			expect(result.mentions).toEqual(["a.ts", "b.ts"]);
+			expect(result.matchedFiles).toEqual(["a.ts"]);
+			expect(result.ignoredMentions).toEqual(["b.ts"]);
+			expect(result.prompt).toBe("Use @a.ts and @b.ts");
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("does not over-count totalBytes across multiple mentions", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(path.join(cwd, "a.ts"), "aaa", "utf8");
+			await writeFile(path.join(cwd, "b.ts"), "bbb", "utf8");
+			await writeFile(path.join(cwd, "c.ts"), "ccc", "utf8");
+
+			const result = await enrichPromptWithMentions(
+				"Use @a.ts @b.ts @c.ts",
+				cwd,
+				{ maxTotalBytes: 15, maxFiles: 5, maxFileBytes: 5 },
+			);
+
+			expect(result.mentions).toEqual(["a.ts", "b.ts", "c.ts"]);
+			expect(result.matchedFiles).toEqual(["a.ts", "b.ts", "c.ts"]);
+			expect(result.ignoredMentions).toEqual([]);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/services/workspace/mention-enricher.ts b/sdk/packages/core/src/services/workspace/mention-enricher.ts
new file mode 100644
index 0000000..5e10c15
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/mention-enricher.ts
@@ -0,0 +1,122 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { type FastFileIndexOptions, getFileIndex } from "./file-indexer";
+
+const TRAILING_PUNCTUATION = /[),.:;!?`'"]+$/;
+const LEADING_WRAPPERS = /^[(`'"]+/;
+
+export interface MentionEnricherOptions extends FastFileIndexOptions {
+	maxFiles?: number;
+	maxFileBytes?: number;
+	maxTotalBytes?: number;
+}
+
+export interface MentionEnrichmentResult {
+	prompt: string;
+	mentions: string[];
+	matchedFiles: string[];
+	ignoredMentions: string[];
+}
+
+function extractMentionTokens(input: string): string[] {
+	const matches = input.matchAll(/(^|[\s])@([^\s]+)/g);
+	const mentions: string[] = [];
+	for (const match of matches) {
+		const token = (match[2] ?? "").trim();
+		if (token.length === 0) {
+			continue;
+		}
+		const normalized = token
+			.replace(LEADING_WRAPPERS, "")
+			.replace(TRAILING_PUNCTUATION, "");
+		if (normalized.length === 0 || normalized.includes("@")) {
+			continue;
+		}
+		mentions.push(normalized);
+	}
+	return Array.from(new Set(mentions));
+}
+
+function normalizeMentionPath(
+	mention: string,
+	cwd: string,
+): string | undefined {
+	const candidate = mention.replace(/\\/g, "/");
+	const maybeAbsolute = path.isAbsolute(candidate)
+		? path.resolve(candidate)
+		: path.resolve(cwd, candidate);
+	const relative = path.relative(cwd, maybeAbsolute);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) {
+		return undefined;
+	}
+	return relative.split(path.sep).join("/");
+}
+
+export async function enrichPromptWithMentions(
+	input: string,
+	cwd: string,
+	options: MentionEnricherOptions = {},
+): Promise<MentionEnrichmentResult> {
+	const mentions = extractMentionTokens(input);
+	if (mentions.length === 0) {
+		return {
+			prompt: input,
+			mentions: [],
+			matchedFiles: [],
+			ignoredMentions: [],
+		};
+	}
+
+	const maxFiles = options.maxFiles;
+	const maxFileBytes = options.maxFileBytes;
+	const maxTotalBytes = options.maxTotalBytes;
+	const fileList = await getFileIndex(cwd, { ttlMs: options.ttlMs });
+	const matched: string[] = [];
+	const ignored: string[] = [];
+	const attachments: Array<{ path: string; content: string }> = [];
+	let totalBytes = 0;
+
+	for (const mention of mentions) {
+		if (maxFiles && attachments.length >= maxFiles) {
+			ignored.push(mention);
+			continue;
+		}
+
+		const relativePath = normalizeMentionPath(mention, cwd);
+		if (!relativePath || !fileList.has(relativePath)) {
+			ignored.push(mention);
+			continue;
+		}
+
+		if (!maxFileBytes || !maxTotalBytes) {
+			matched.push(relativePath);
+			continue;
+		}
+
+		const absolutePath = path.join(cwd, relativePath);
+		try {
+			const fileStat = await stat(absolutePath);
+			if (!fileStat.isFile()) {
+				ignored.push(mention);
+				continue;
+			}
+			const nextBytes = totalBytes + maxFileBytes;
+			if (nextBytes > maxTotalBytes) {
+				ignored.push(mention);
+				continue;
+			}
+
+			totalBytes = nextBytes;
+			matched.push(relativePath);
+		} catch {
+			ignored.push(mention);
+		}
+	}
+
+	return {
+		prompt: input,
+		mentions,
+		matchedFiles: matched,
+		ignoredMentions: ignored,
+	};
+}
diff --git a/sdk/packages/core/src/services/workspace/workspace-manager.ts b/sdk/packages/core/src/services/workspace/workspace-manager.ts
new file mode 100644
index 0000000..aeb2e43
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/workspace-manager.ts
@@ -0,0 +1,100 @@
+import {
+	upsertWorkspaceInfo,
+	type WorkspaceInfo,
+	type WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "@cline/shared";
+import {
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+} from "./workspace-manifest";
+
+export interface WorkspaceManagerEvent {
+	type: "workspace_added" | "workspace_switched";
+	workspace: WorkspaceInfo;
+}
+
+export interface WorkspaceManager {
+	addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+	switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+	getCurrentWorkspace(): WorkspaceInfo | undefined;
+	getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+	listWorkspaces(): WorkspaceInfo[];
+	getManifest(): WorkspaceManifest;
+}
+
+export class InMemoryWorkspaceManager implements WorkspaceManager {
+	private manifest: WorkspaceManifest;
+	private readonly listeners = new Set<
+		(event: WorkspaceManagerEvent) => void
+	>();
+
+	constructor(manifest?: WorkspaceManifest) {
+		this.manifest = WorkspaceManifestSchema.parse(
+			manifest ?? { workspaces: {} },
+		);
+	}
+
+	async addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo> {
+		const info = await generateWorkspaceInfo(workspacePath);
+		this.manifest = upsertWorkspaceInfo(this.manifest, info);
+		this.emit({ type: "workspace_added", workspace: info });
+		return info;
+	}
+
+	async switchWorkspace(workspacePath: string): Promise<WorkspaceInfo> {
+		const normalizedPath = normalizeWorkspacePath(workspacePath);
+		const existing = this.manifest.workspaces[normalizedPath];
+		if (existing) {
+			this.manifest = WorkspaceManifestSchema.parse({
+				...this.manifest,
+				currentWorkspacePath: normalizedPath,
+			});
+			this.emit({ type: "workspace_switched", workspace: existing });
+			return existing;
+		}
+
+		const added = await this.addWorkspacePath(normalizedPath);
+		this.manifest = WorkspaceManifestSchema.parse({
+			...this.manifest,
+			currentWorkspacePath: added.rootPath,
+		});
+		this.emit({ type: "workspace_switched", workspace: added });
+		return added;
+	}
+
+	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	getCurrentWorkspace(): WorkspaceInfo | undefined {
+		const currentPath = this.manifest.currentWorkspacePath;
+		if (!currentPath) {
+			return undefined;
+		}
+		return this.manifest.workspaces[currentPath];
+	}
+
+	getWorkspace(workspacePath: string): WorkspaceInfo | undefined {
+		const normalizedPath = normalizeWorkspacePath(workspacePath);
+		return this.manifest.workspaces[normalizedPath];
+	}
+
+	listWorkspaces(): WorkspaceInfo[] {
+		return Object.values(this.manifest.workspaces);
+	}
+
+	getManifest(): WorkspaceManifest {
+		return this.manifest;
+	}
+
+	private emit(event: WorkspaceManagerEvent): void {
+		for (const listener of this.listeners) {
+			listener(event);
+		}
+	}
+}
diff --git a/sdk/packages/core/src/services/workspace/workspace-manifest.ts b/sdk/packages/core/src/services/workspace/workspace-manifest.ts
new file mode 100644
index 0000000..b2ef256
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/workspace-manifest.ts
@@ -0,0 +1,129 @@
+import { basename, resolve } from "node:path";
+import { performance } from "node:perf_hooks";
+import type { WorkspaceInfo } from "@cline/shared";
+import { processWorkspaceInfo } from "@cline/shared";
+import simpleGit from "simple-git";
+
+export interface WorkspaceInfoDiagnostics {
+	info: WorkspaceInfo;
+	vcsType: "git" | "none";
+	error?: { errorType: string; message: string };
+}
+
+export interface BuiltWorkspaceMetadata {
+	workspaceInfo: WorkspaceInfo;
+	workspaceMetadata: string;
+	durationMs: number;
+	vcsType: "git" | "none";
+	initError?: { errorType: string; message: string };
+}
+
+export function normalizeWorkspacePath(workspacePath: string): string {
+	return resolve(workspacePath);
+}
+
+export async function generateWorkspaceInfo(
+	workspacePath: string,
+): Promise<WorkspaceInfo> {
+	return (await generateWorkspaceInfoWithDiagnostics(workspacePath)).info;
+}
+
+function toWorkspaceInfoError(error: unknown): {
+	errorType: string;
+	message: string;
+} {
+	if (error instanceof Error) {
+		return {
+			errorType: error.name?.trim() || error.constructor.name || "Error",
+			message: error.message,
+		};
+	}
+	return { errorType: "Error", message: String(error) };
+}
+
+export async function generateWorkspaceInfoWithDiagnostics(
+	workspacePath: string,
+): Promise<WorkspaceInfoDiagnostics> {
+	const rootPath = normalizeWorkspacePath(workspacePath);
+	const info: WorkspaceInfo = {
+		rootPath,
+		hint: basename(rootPath),
+	};
+	let firstError: { errorType: string; message: string } | undefined;
+
+	try {
+		const git = simpleGit({ baseDir: rootPath });
+		const isRepo = await git.checkIsRepo();
+		if (!isRepo) {
+			return { info, vcsType: "none" };
+		}
+
+		try {
+			const remotes = await git.getRemotes(true);
+			if (remotes.length > 0) {
+				const associatedRemoteUrls = remotes.map((remote) => {
+					const remoteUrl = remote.refs.fetch || remote.refs.push;
+					return `${remote.name}: ${remoteUrl}`;
+				});
+				info.associatedRemoteUrls = associatedRemoteUrls;
+			}
+		} catch (error) {
+			firstError ??= toWorkspaceInfoError(error);
+		}
+
+		try {
+			const latestGitCommitHash = (await git.revparse(["HEAD"])).trim();
+			if (latestGitCommitHash.length > 0) {
+				info.latestGitCommitHash = latestGitCommitHash;
+			}
+		} catch (error) {
+			firstError ??= toWorkspaceInfoError(error);
+		}
+
+		try {
+			const latestGitBranchName = (await git.branch()).current.trim();
+			if (latestGitBranchName.length > 0) {
+				info.latestGitBranchName = latestGitBranchName;
+			}
+		} catch (error) {
+			firstError ??= toWorkspaceInfoError(error);
+		}
+
+		return { info, vcsType: "git", error: firstError };
+	} catch (error) {
+		// Non-git workspaces keep only path + hint.
+		return {
+			info,
+			vcsType: "none",
+			error: toWorkspaceInfoError(error),
+		};
+	}
+}
+
+export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
+	const workspaceInfo = await generateWorkspaceInfo(cwd);
+	return processWorkspaceInfo(workspaceInfo);
+}
+
+/**
+ * Generate workspace metadata as both a structured `WorkspaceInfo` object and
+ * its pre-serialized string form.
+ *
+ * Use this instead of calling `buildWorkspaceMetadata` + `generateWorkspaceInfo`
+ * separately so the git I/O only happens once.
+ */
+export async function buildWorkspaceMetadataWithInfo(
+	cwd: string,
+): Promise<BuiltWorkspaceMetadata> {
+	const startedAt = performance.now();
+	const diagnostics = await generateWorkspaceInfoWithDiagnostics(cwd);
+	const durationMs = performance.now() - startedAt;
+	const workspaceInfo = diagnostics.info;
+	return {
+		workspaceInfo,
+		workspaceMetadata: processWorkspaceInfo(workspaceInfo),
+		durationMs,
+		vcsType: diagnostics.vcsType,
+		initError: diagnostics.error,
+	};
+}
diff --git a/sdk/packages/core/src/services/workspace/workspace-telemetry.test.ts b/sdk/packages/core/src/services/workspace/workspace-telemetry.test.ts
new file mode 100644
index 0000000..1a23691
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/workspace-telemetry.test.ts
@@ -0,0 +1,166 @@
+import type { ITelemetryService } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import {
+	emitWorkspaceLifecycleTelemetry,
+	resetWorkspaceTelemetryForTests,
+} from "./workspace-telemetry";
+
+interface TelemetryStub {
+	telemetry: ITelemetryService;
+	capture: ReturnType<typeof vi.fn>;
+	captureRequired: ReturnType<typeof vi.fn>;
+}
+
+function createTelemetryStub(): TelemetryStub {
+	const capture = vi.fn();
+	const captureRequired = vi.fn();
+	const telemetry = {
+		capture,
+		captureRequired,
+		setDistinctId: vi.fn(),
+		updateCommonProperties: vi.fn(),
+		identify: vi.fn(),
+	} as unknown as ITelemetryService;
+	return { telemetry, capture, captureRequired };
+}
+
+function findCalls(
+	stub: TelemetryStub,
+	event: string,
+): { event: string; properties?: Record<string, unknown> }[] {
+	return stub.capture.mock.calls
+		.filter(([arg]) => (arg as { event: string }).event === event)
+		.map(
+			([arg]) => arg as { event: string; properties?: Record<string, unknown> },
+		);
+}
+
+describe("emitWorkspaceLifecycleTelemetry", () => {
+	beforeEach(() => {
+		resetWorkspaceTelemetryForTests();
+	});
+
+	afterEach(() => {
+		resetWorkspaceTelemetryForTests();
+	});
+
+	test("emits workspace.initialized once per process per workspace path", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+			rootCount: 1,
+			durationMs: 12,
+		});
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+			rootCount: 1,
+			durationMs: 12,
+		});
+		const initialized = findCalls(stub, "workspace.initialized");
+		expect(initialized).toHaveLength(1);
+	});
+
+	test("emits separate workspace.initialized events for distinct paths", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo-a",
+			vcsType: "git",
+			rootCount: 1,
+		});
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo-b",
+			vcsType: "none",
+			rootCount: 1,
+		});
+		expect(findCalls(stub, "workspace.initialized")).toHaveLength(2);
+	});
+
+	test("emits workspace.init_error only when diagnostics report a failure", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/healthy",
+			vcsType: "git",
+		});
+		expect(findCalls(stub, "workspace.init_error")).toHaveLength(0);
+
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/broken",
+			vcsType: "none",
+			initError: { errorType: "GitProbeError", message: "permission denied" },
+		});
+		const errors = findCalls(stub, "workspace.init_error");
+		expect(errors).toHaveLength(1);
+		expect(errors[0]?.properties?.error_type).toBe("GitProbeError");
+		expect(errors[0]?.properties?.fallback_to_single_root).toBe(true);
+	});
+
+	test("does not emit raw workspace path in event properties", () => {
+		const stub = createTelemetryStub();
+		const rootPath = "/tmp/super-secret-repo-name";
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath,
+			vcsType: "git",
+			rootCount: 1,
+		});
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		for (const call of stub.capture.mock.calls) {
+			const arg = call[0] as {
+				event: string;
+				properties?: Record<string, unknown>;
+			};
+			expect(JSON.stringify(arg.properties ?? {})).not.toContain(rootPath);
+		}
+	});
+
+	test("emits derived has_git/has_mercurial/is_multi_root flags", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/multi",
+			rootCount: 2,
+			vcsTypes: ["git", "hg"],
+		});
+		const initialized = findCalls(stub, "workspace.initialized");
+		expect(initialized).toHaveLength(1);
+		const props = initialized[0]?.properties as Record<string, unknown>;
+		expect(props.is_multi_root).toBe(true);
+		expect(props.has_git).toBe(true);
+		expect(props.has_mercurial).toBe(true);
+		expect(props.vcs_types).toEqual(["git", "hg"]);
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			emitWorkspaceLifecycleTelemetry({
+				telemetry: undefined,
+				rootPath: "/tmp/quiet",
+				vcsType: "none",
+			}),
+		).not.toThrow();
+	});
+
+	test("resetWorkspaceTelemetryForTests clears the dedup cache", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+		});
+		resetWorkspaceTelemetryForTests();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+		});
+		expect(findCalls(stub, "workspace.initialized")).toHaveLength(2);
+	});
+});
diff --git a/sdk/packages/core/src/services/workspace/workspace-telemetry.ts b/sdk/packages/core/src/services/workspace/workspace-telemetry.ts
new file mode 100644
index 0000000..a1097b0
--- /dev/null
+++ b/sdk/packages/core/src/services/workspace/workspace-telemetry.ts
@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import type { ITelemetryService, WorkspaceInfo } from "@cline/shared";
+import {
+	captureWorkspaceInitError,
+	captureWorkspaceInitialized,
+} from "../telemetry/core-events";
+
+export interface WorkspaceLifecycleTelemetryInput {
+	telemetry?: ITelemetryService;
+	rootPath: string;
+	workspaceInfo?: WorkspaceInfo;
+	rootCount?: number;
+	vcsType?: "git" | "none";
+	vcsTypes?: ReadonlyArray<string>;
+	durationMs?: number;
+	initError?: { errorType: string; message: string };
+	featureFlagEnabled?: boolean;
+	isRemoteWorkspace?: boolean;
+}
+
+const initializedWorkspaceHashes = new Set<string>();
+const initErrorWorkspaceHashes = new Set<string>();
+
+function hashWorkspacePath(rootPath: string): string {
+	return createHash("sha256").update(rootPath).digest("hex");
+}
+
+function normalizeVcsTypes(
+	input: WorkspaceLifecycleTelemetryInput,
+): ReadonlyArray<string> {
+	if (input.vcsTypes && input.vcsTypes.length > 0) {
+		return input.vcsTypes;
+	}
+	return [input.vcsType === "git" ? "git" : "none"];
+}
+
+export function emitWorkspaceLifecycleTelemetry(
+	input: WorkspaceLifecycleTelemetryInput,
+): void {
+	if (!input.telemetry) {
+		return;
+	}
+	const workspaceHash = hashWorkspacePath(input.rootPath);
+	const rootCount = input.rootCount ?? 1;
+	if (!initializedWorkspaceHashes.has(workspaceHash)) {
+		initializedWorkspaceHashes.add(workspaceHash);
+		captureWorkspaceInitialized(input.telemetry, {
+			root_count: rootCount,
+			vcs_types: normalizeVcsTypes(input),
+			init_duration_ms: input.durationMs,
+			feature_flag_enabled: input.featureFlagEnabled ?? true,
+			is_remote_workspace: input.isRemoteWorkspace,
+		});
+	}
+
+	if (input.initError && !initErrorWorkspaceHashes.has(workspaceHash)) {
+		initErrorWorkspaceHashes.add(workspaceHash);
+		const error = new Error(input.initError.message);
+		error.name = input.initError.errorType || "Error";
+		captureWorkspaceInitError(input.telemetry, error, {
+			fallback_to_single_root: true,
+			workspace_count: rootCount,
+		});
+	}
+}
+
+export function resetWorkspaceTelemetryForTests(): void {
+	initializedWorkspaceHashes.clear();
+	initErrorWorkspaceHashes.clear();
+}
diff --git a/sdk/packages/core/src/session/checkpoint-diff.test.ts b/sdk/packages/core/src/session/checkpoint-diff.test.ts
new file mode 100644
index 0000000..5e124fc
--- /dev/null
+++ b/sdk/packages/core/src/session/checkpoint-diff.test.ts
@@ -0,0 +1,171 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+	buildCheckpointWorkspaceDiff,
+	compareCheckpointToWorkspace,
+	createCheckpointComparePlan,
+} from "./checkpoint-diff";
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", ["-C", cwd, ...args], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+}
+
+describe("checkpoint workspace comparison", () => {
+	let dir = "";
+	let checkpointRef = "";
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "core-checkpoint-diff-"));
+		mkdirSync(dir, { recursive: true });
+		git(dir, ["init"]);
+		git(dir, ["config", "user.name", "Cline Test"]);
+		git(dir, ["config", "user.email", "cline@example.com"]);
+		writeFileSync(join(dir, "tracked.txt"), "base\n", "utf8");
+		writeFileSync(join(dir, "deleted.txt"), "delete me\n", "utf8");
+		git(dir, ["add", "."]);
+		git(dir, ["commit", "-m", "initial"]);
+		checkpointRef = git(dir, ["rev-parse", "HEAD"]);
+	});
+
+	afterEach(() => {
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("builds content diffs from a checkpoint ref to the current worktree", async () => {
+		writeFileSync(join(dir, "tracked.txt"), "changed\n", "utf8");
+		rmSync(join(dir, "deleted.txt"));
+		writeFileSync(join(dir, "untracked.txt"), "new file\n", "utf8");
+
+		const diffs = await buildCheckpointWorkspaceDiff(dir, {
+			ref: checkpointRef,
+			createdAt: Date.now(),
+			runCount: 1,
+			kind: "commit",
+		});
+
+		expect(diffs.map((diff) => diff.filePath.replaceAll("\\", "/"))).toEqual([
+			join(dir, "deleted.txt").replaceAll("\\", "/"),
+			join(dir, "tracked.txt").replaceAll("\\", "/"),
+			join(dir, "untracked.txt").replaceAll("\\", "/"),
+		]);
+		expect(
+			diffs.find((diff) => diff.filePath.endsWith("tracked.txt")),
+		).toMatchObject({
+			leftContent: "base\n",
+			rightContent: "changed\n",
+		});
+		expect(
+			diffs.find((diff) => diff.filePath.endsWith("deleted.txt")),
+		).toMatchObject({
+			leftContent: "delete me\n",
+			rightContent: "",
+		});
+		expect(
+			diffs.find((diff) => diff.filePath.endsWith("untracked.txt")),
+		).toMatchObject({
+			leftContent: "",
+			rightContent: "new file\n",
+		});
+	});
+
+	it("uses the worktree snapshot stored in SDK stash checkpoints", async () => {
+		writeFileSync(join(dir, "tracked.txt"), "checkpoint dirty\n", "utf8");
+		const stashRef = git(dir, ["stash", "create", "cline checkpoint test"]);
+		writeFileSync(join(dir, "tracked.txt"), "current dirty\n", "utf8");
+
+		const diffs = await buildCheckpointWorkspaceDiff(dir, {
+			ref: stashRef,
+			createdAt: Date.now(),
+			runCount: 1,
+			kind: "stash",
+		});
+
+		expect(diffs).toHaveLength(1);
+		expect(diffs[0]).toMatchObject({
+			filePath: join(dir, "tracked.txt"),
+			leftContent: "checkpoint dirty\n",
+			rightContent: "current dirty\n",
+		});
+	});
+
+	it("selects the nearest checkpoint at or before the requested run", async () => {
+		const session = {
+			sessionId: "session-1",
+			source: "cli",
+			status: "running",
+			startedAt: "2026-01-01T00:00:00.000Z",
+			updatedAt: "2026-01-01T00:00:00.000Z",
+			interactive: true,
+			provider: "mock",
+			model: "mock",
+			cwd: dir,
+			workspaceRoot: dir,
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: true,
+			isSubagent: false,
+			metadata: {
+				checkpoint: {
+					latest: { ref: "bbbb", createdAt: 2, runCount: 3 },
+					history: [
+						{ ref: "aaaa", createdAt: 1, runCount: 1 },
+						{ ref: "bbbb", createdAt: 2, runCount: 3 },
+					],
+				},
+			},
+		} as const;
+
+		const plan = createCheckpointComparePlan({
+			session,
+			checkpointRunCount: 2,
+		});
+
+		expect(plan.checkpoint).toMatchObject({ ref: "aaaa", runCount: 1 });
+		expect(plan.cwd).toBe(dir);
+	});
+
+	it("returns the compare plan and workspace diffs together", async () => {
+		writeFileSync(join(dir, "tracked.txt"), "changed\n", "utf8");
+		const session = {
+			sessionId: "session-1",
+			source: "cli",
+			status: "running",
+			startedAt: "2026-01-01T00:00:00.000Z",
+			updatedAt: "2026-01-01T00:00:00.000Z",
+			interactive: true,
+			provider: "mock",
+			model: "mock",
+			cwd: dir,
+			workspaceRoot: dir,
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: true,
+			isSubagent: false,
+			metadata: {
+				checkpoint: {
+					latest: { ref: checkpointRef, createdAt: 1, runCount: 1 },
+					history: [{ ref: checkpointRef, createdAt: 1, runCount: 1 }],
+				},
+			},
+		} as const;
+
+		const result = await compareCheckpointToWorkspace({
+			session,
+			checkpointRunCount: 1,
+		});
+
+		expect(result.checkpoint.ref).toBe(checkpointRef);
+		expect(result.diffs).toHaveLength(1);
+		expect(result.diffs[0]).toMatchObject({
+			filePath: join(dir, "tracked.txt"),
+			leftContent: "base\n",
+			rightContent: "changed\n",
+		});
+	});
+});
diff --git a/sdk/packages/core/src/session/checkpoint-diff.ts b/sdk/packages/core/src/session/checkpoint-diff.ts
new file mode 100644
index 0000000..779d89b
--- /dev/null
+++ b/sdk/packages/core/src/session/checkpoint-diff.ts
@@ -0,0 +1,150 @@
+import { execFile as execFileCallback } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { SessionRecord } from "../types/sessions";
+import {
+	findCheckpointForRun,
+	readSessionCheckpointHistory,
+} from "./checkpoint-restore";
+
+const execFile = promisify(execFileCallback);
+const MAX_GIT_OUTPUT = 50 * 1024 * 1024;
+
+export interface CheckpointContentDiff {
+	filePath: string;
+	leftContent: string;
+	rightContent: string;
+}
+
+export interface CheckpointComparePlan {
+	checkpoint: CheckpointEntry;
+	cwd: string;
+}
+
+export interface CheckpointWorkspaceCompareResult
+	extends CheckpointComparePlan {
+	diffs: CheckpointContentDiff[];
+}
+
+async function runGit(cwd: string, args: string[]): Promise<string> {
+	const { stdout } = await execFile("git", ["-C", cwd, ...args], {
+		windowsHide: true,
+		maxBuffer: MAX_GIT_OUTPUT,
+		encoding: "utf8",
+	});
+	return stdout;
+}
+
+function parseNulList(output: string): string[] {
+	return output.split("\0").filter(Boolean);
+}
+
+function resolveGitPath(cwd: string, relativePath: string): string {
+	const absolutePath = path.resolve(cwd, relativePath);
+	const relativeFromCwd = path.relative(cwd, absolutePath);
+	if (relativeFromCwd.startsWith("..") || path.isAbsolute(relativeFromCwd)) {
+		throw new Error(`Checkpoint diff path escapes workspace: ${relativePath}`);
+	}
+	return absolutePath;
+}
+
+async function readCheckpointFile(
+	cwd: string,
+	ref: string,
+	relativePath: string,
+): Promise<string> {
+	try {
+		return await runGit(cwd, ["show", `${ref}:${relativePath}`]);
+	} catch {
+		return "";
+	}
+}
+
+async function readWorktreeFile(
+	cwd: string,
+	relativePath: string,
+): Promise<string> {
+	try {
+		return await fs.readFile(resolveGitPath(cwd, relativePath), "utf8");
+	} catch {
+		return "";
+	}
+}
+
+async function listChangedPaths(
+	cwd: string,
+	checkpoint: CheckpointEntry,
+): Promise<string[]> {
+	await runGit(cwd, ["cat-file", "-e", `${checkpoint.ref}^{tree}`]);
+	const [trackedOutput, untrackedOutput] = await Promise.all([
+		runGit(cwd, ["diff", "--name-only", "-z", checkpoint.ref, "--"]),
+		runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]),
+	]);
+	const paths = new Set([
+		...parseNulList(trackedOutput),
+		...parseNulList(untrackedOutput),
+	]);
+	return [...paths].sort((a, b) => a.localeCompare(b));
+}
+
+export function createCheckpointComparePlan(input: {
+	session: SessionRecord;
+	checkpointRunCount: number;
+	cwd?: string;
+}): CheckpointComparePlan {
+	const runCount = input.checkpointRunCount;
+	if (!Number.isInteger(runCount) || runCount < 1) {
+		throw new Error("checkpointRunCount must be a positive integer");
+	}
+	const checkpoint = findCheckpointForRun(
+		readSessionCheckpointHistory(input.session),
+		runCount,
+	);
+	if (!checkpoint) {
+		throw new Error(
+			`No checkpoint found at or before run ${runCount} in session ${input.session.sessionId}`,
+		);
+	}
+	const cwd = (
+		input.cwd?.trim() ||
+		input.session.cwd ||
+		input.session.workspaceRoot
+	).trim();
+	if (!cwd) {
+		throw new Error("cwd or workspaceRoot is required to compare a checkpoint");
+	}
+	return { checkpoint, cwd };
+}
+
+export async function buildCheckpointWorkspaceDiff(
+	cwd: string,
+	checkpoint: CheckpointEntry,
+): Promise<CheckpointContentDiff[]> {
+	const changedPaths = await listChangedPaths(cwd, checkpoint);
+	const diffs = await Promise.all(
+		changedPaths.map(async (relativePath) => {
+			const [leftContent, rightContent] = await Promise.all([
+				readCheckpointFile(cwd, checkpoint.ref, relativePath),
+				readWorktreeFile(cwd, relativePath),
+			]);
+			return {
+				filePath: resolveGitPath(cwd, relativePath),
+				leftContent,
+				rightContent,
+			};
+		}),
+	);
+	return diffs.filter((diff) => diff.leftContent !== diff.rightContent);
+}
+
+export async function compareCheckpointToWorkspace(input: {
+	session: SessionRecord;
+	checkpointRunCount: number;
+	cwd?: string;
+}): Promise<CheckpointWorkspaceCompareResult> {
+	const plan = createCheckpointComparePlan(input);
+	const diffs = await buildCheckpointWorkspaceDiff(plan.cwd, plan.checkpoint);
+	return { ...plan, diffs };
+}
diff --git a/sdk/packages/core/src/session/checkpoint-restore.test.ts b/sdk/packages/core/src/session/checkpoint-restore.test.ts
new file mode 100644
index 0000000..0acd1d7
--- /dev/null
+++ b/sdk/packages/core/src/session/checkpoint-restore.test.ts
@@ -0,0 +1,154 @@
+import { execFileSync } from "node:child_process";
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+	applyCheckpointToWorktree,
+	createCheckpointRestorePlan,
+	createRestoredCheckpointMetadata,
+	trimMessagesBeforeCheckpoint,
+	trimMessagesToCheckpoint,
+} from "./checkpoint-restore";
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", ["-C", cwd, ...args], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+}
+
+function createRepo(cwd: string): void {
+	git(cwd, ["init"]);
+	git(cwd, ["config", "user.name", "Codex Test"]);
+	git(cwd, ["config", "user.email", "codex@example.com"]);
+	writeFileSync(join(cwd, "tracked.txt"), "base\n", "utf8");
+	git(cwd, ["add", "tracked.txt"]);
+	git(cwd, ["commit", "-m", "initial"]);
+}
+
+describe("applyCheckpointToWorktree", () => {
+	let dir = "";
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "checkpoint-restore-"));
+		mkdirSync(dir, { recursive: true });
+		createRepo(dir);
+	});
+
+	afterEach(() => {
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("validates the checkpoint ref before resetting or cleaning the worktree", async () => {
+		writeFileSync(join(dir, "tracked.txt"), "dirty\n", "utf8");
+		writeFileSync(join(dir, "untracked.txt"), "keep me\n", "utf8");
+
+		await expect(
+			applyCheckpointToWorktree(dir, {
+				ref: "0000000000000000000000000000000000000000",
+				createdAt: Date.now(),
+				runCount: 1,
+				kind: "stash",
+			}),
+		).rejects.toThrow();
+
+		expect(readFileSync(join(dir, "tracked.txt"), "utf8")).toBe("dirty\n");
+		expect(readFileSync(join(dir, "untracked.txt"), "utf8")).toBe("keep me\n");
+	});
+
+	it("carries checkpoint metadata through the restored run", () => {
+		const metadata = createRestoredCheckpointMetadata(
+			{
+				metadata: {
+					checkpoint: {
+						latest: { ref: "cccc", createdAt: 3, runCount: 3 },
+						history: [
+							{ ref: "aaaa", createdAt: 1, runCount: 1 },
+							{ ref: "bbbb", createdAt: 2, runCount: 2 },
+							{ ref: "cccc", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			},
+			2,
+		);
+
+		expect(metadata?.latest.runCount).toBe(2);
+		expect(metadata?.history.map((entry) => entry.runCount)).toEqual([1, 2]);
+	});
+});
+
+describe("checkpoint message trimming", () => {
+	it("can trim either through or before the checkpoint user message", () => {
+		const messages = [
+			{ role: "user" as const, content: "first" },
+			{ role: "assistant" as const, content: "first response" },
+			{ role: "user" as const, content: "second" },
+			{ role: "assistant" as const, content: "second response" },
+		];
+
+		expect(trimMessagesToCheckpoint(messages, 2)).toEqual([
+			{ role: "user", content: "first" },
+			{ role: "assistant", content: "first response" },
+			{ role: "user", content: "second" },
+		]);
+		expect(trimMessagesBeforeCheckpoint(messages, 2)).toEqual([
+			{ role: "user", content: "first" },
+			{ role: "assistant", content: "first response" },
+		]);
+	});
+
+	it("uses the nearest earlier checkpoint when an identical snapshot was deduplicated", () => {
+		const messages = [
+			{ role: "user" as const, content: "first" },
+			{ role: "assistant" as const, content: "first response" },
+			{ role: "user" as const, content: "second" },
+			{ role: "assistant" as const, content: "second response" },
+			{ role: "user" as const, content: "third" },
+		];
+
+		const plan = createCheckpointRestorePlan({
+			session: {
+				sessionId: "session-1",
+				source: "cli",
+				status: "running",
+				startedAt: "2026-01-01T00:00:00.000Z",
+				updatedAt: "2026-01-01T00:00:00.000Z",
+				interactive: true,
+				provider: "mock",
+				model: "mock",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: true,
+				isSubagent: false,
+				metadata: {
+					checkpoint: {
+						latest: { ref: "cccc", createdAt: 3, runCount: 3 },
+						history: [
+							{ ref: "aaaa", createdAt: 1, runCount: 1 },
+							{ ref: "cccc", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			},
+			messages,
+			checkpointRunCount: 2,
+		});
+
+		expect(plan.checkpoint).toMatchObject({ ref: "aaaa", runCount: 1 });
+		expect(plan.messages).toEqual([
+			{ role: "user", content: "first" },
+			{ role: "assistant", content: "first response" },
+			{ role: "user", content: "second" },
+		]);
+	});
+});
diff --git a/sdk/packages/core/src/session/checkpoint-restore.ts b/sdk/packages/core/src/session/checkpoint-restore.ts
new file mode 100644
index 0000000..787db10
--- /dev/null
+++ b/sdk/packages/core/src/session/checkpoint-restore.ts
@@ -0,0 +1,189 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import type * as LlmsProviders from "@cline/llms";
+import type {
+	CheckpointEntry,
+	CheckpointMetadata,
+} from "../hooks/checkpoint-hooks";
+import type { SessionRecord } from "../types/sessions";
+
+const execFile = promisify(execFileCallback);
+
+export interface CheckpointRestorePlan {
+	checkpoint: CheckpointEntry;
+	messages?: LlmsProviders.Message[];
+	cwd: string;
+}
+
+export function readSessionCheckpointHistory(
+	session: Pick<SessionRecord, "metadata"> | undefined,
+): CheckpointEntry[] {
+	const checkpoint =
+		session?.metadata?.checkpoint &&
+		typeof session.metadata.checkpoint === "object" &&
+		!Array.isArray(session.metadata.checkpoint)
+			? (session.metadata.checkpoint as Record<string, unknown>)
+			: undefined;
+	const history = Array.isArray(checkpoint?.history) ? checkpoint.history : [];
+	return history
+		.filter(
+			(entry): entry is Record<string, unknown> =>
+				!!entry && typeof entry === "object" && !Array.isArray(entry),
+		)
+		.flatMap((entry): CheckpointEntry[] => {
+			const ref = String(entry.ref ?? "").trim();
+			const createdAt = Number(entry.createdAt ?? 0);
+			const runCount = Number(entry.runCount ?? 0);
+			if (
+				ref.length === 0 ||
+				!Number.isFinite(createdAt) ||
+				!Number.isInteger(runCount) ||
+				runCount < 1
+			) {
+				return [];
+			}
+			const kind =
+				entry.kind === "stash" || entry.kind === "commit"
+					? entry.kind
+					: undefined;
+			return [{ ref, createdAt, runCount, ...(kind ? { kind } : {}) }];
+		});
+}
+
+export function createRestoredCheckpointMetadata(
+	session: Pick<SessionRecord, "metadata"> | undefined,
+	runCount: number,
+): CheckpointMetadata | undefined {
+	const history = readSessionCheckpointHistory(session).filter(
+		(entry) => entry.runCount <= runCount,
+	);
+	const latest = history.at(-1);
+	return latest ? { latest, history } : undefined;
+}
+
+export function findCheckpointForRun(
+	history: readonly CheckpointEntry[],
+	runCount: number,
+): CheckpointEntry | undefined {
+	return history.reduce<CheckpointEntry | undefined>((best, entry) => {
+		if (entry.runCount > runCount) {
+			return best;
+		}
+		if (!best || entry.runCount > best.runCount) {
+			return entry;
+		}
+		return best;
+	}, undefined);
+}
+
+function findCheckpointMessageIndex(
+	messages: LlmsProviders.Message[],
+	runCount: number,
+): number {
+	let userRunCount = 0;
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index];
+		if (message?.role !== "user") {
+			continue;
+		}
+		const metadata =
+			"metadata" in message &&
+			message.metadata &&
+			typeof message.metadata === "object"
+				? (message.metadata as Record<string, unknown>)
+				: undefined;
+		if (metadata?.kind === "recovery_notice") {
+			continue;
+		}
+		userRunCount += 1;
+		if (userRunCount === runCount) {
+			return index;
+		}
+	}
+	throw new Error(`Could not find user message for checkpoint run ${runCount}`);
+}
+
+export function trimMessagesToCheckpoint(
+	messages: LlmsProviders.Message[],
+	runCount: number,
+): LlmsProviders.Message[] {
+	const index = findCheckpointMessageIndex(messages, runCount);
+	return messages.slice(0, index + 1);
+}
+
+export function trimMessagesBeforeCheckpoint(
+	messages: LlmsProviders.Message[],
+	runCount: number,
+): LlmsProviders.Message[] {
+	const index = findCheckpointMessageIndex(messages, runCount);
+	return messages.slice(0, index);
+}
+
+export function createCheckpointRestorePlan(input: {
+	session: SessionRecord;
+	messages?: LlmsProviders.Message[];
+	checkpointRunCount: number;
+	cwd?: string;
+	restoreMessages?: boolean;
+}): CheckpointRestorePlan {
+	const runCount = input.checkpointRunCount;
+	if (!Number.isInteger(runCount) || runCount < 1) {
+		throw new Error("checkpointRunCount must be a positive integer");
+	}
+	const checkpoint = findCheckpointForRun(
+		readSessionCheckpointHistory(input.session),
+		runCount,
+	);
+	if (!checkpoint) {
+		throw new Error(
+			`No checkpoint found at or before run ${runCount} in session ${input.session.sessionId}`,
+		);
+	}
+	const cwd = (
+		input.cwd?.trim() ||
+		input.session.cwd ||
+		input.session.workspaceRoot
+	).trim();
+	if (!cwd) {
+		throw new Error("cwd or workspaceRoot is required to restore a checkpoint");
+	}
+	return {
+		checkpoint,
+		cwd,
+		...(input.restoreMessages !== false
+			? {
+					messages: trimMessagesToCheckpoint(input.messages ?? [], runCount),
+				}
+			: {}),
+	};
+}
+
+export async function applyCheckpointToWorktree(
+	cwd: string,
+	checkpoint: CheckpointEntry,
+): Promise<void> {
+	const check = await execFile(
+		"git",
+		["-C", cwd, "rev-parse", "--is-inside-work-tree"],
+		{ windowsHide: true },
+	);
+	if (check.stdout.trim() !== "true") {
+		throw new Error(`${cwd} is not a git repository`);
+	}
+	await execFile(
+		"git",
+		["-C", cwd, "cat-file", "-e", `${checkpoint.ref}^{commit}`],
+		{ windowsHide: true },
+	);
+	await execFile("git", ["-C", cwd, "reset", "--hard"], { windowsHide: true });
+	await execFile("git", ["-C", cwd, "clean", "-fd"], { windowsHide: true });
+	if (checkpoint.kind === "commit") {
+		await execFile("git", ["-C", cwd, "reset", "--hard", checkpoint.ref], {
+			windowsHide: true,
+		});
+		return;
+	}
+	await execFile("git", ["-C", cwd, "stash", "apply", checkpoint.ref], {
+		windowsHide: true,
+	});
+}
diff --git a/sdk/packages/core/src/session/index.ts b/sdk/packages/core/src/session/index.ts
new file mode 100644
index 0000000..0b3657d
--- /dev/null
+++ b/sdk/packages/core/src/session/index.ts
@@ -0,0 +1,32 @@
+export {
+	upsertWorkspaceInfo,
+	type WorkspaceInfo,
+	type WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "@cline/shared";
+export type {
+	WorkspaceManager,
+	WorkspaceManagerEvent,
+} from "../services/workspace/workspace-manager";
+export { InMemoryWorkspaceManager } from "../services/workspace/workspace-manager";
+export {
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+} from "../services/workspace/workspace-manifest";
+export {
+	deriveSubsessionStatus,
+	makeSubSessionId,
+	makeTeamTaskSubSessionId,
+	sanitizeSessionToken,
+} from "./models/session-graph";
+export type { SessionManifest } from "./models/session-manifest";
+export type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+	SessionRow,
+} from "./models/session-row";
+export { CoreSessionService } from "./services/session-service";
+export {
+	FileTeamPersistenceStore,
+	type FileTeamPersistenceStoreOptions,
+} from "./stores/team-persistence-store";
diff --git a/sdk/packages/core/src/session/models/session-compaction.test.ts b/sdk/packages/core/src/session/models/session-compaction.test.ts
new file mode 100644
index 0000000..54dc00a
--- /dev/null
+++ b/sdk/packages/core/src/session/models/session-compaction.test.ts
@@ -0,0 +1,215 @@
+import { describe, expect, it } from "vitest";
+import {
+	createSessionCompactionState,
+	parseSessionCompactionState,
+	projectSessionCompactionState,
+} from "./session-compaction";
+
+describe("session compaction state", () => {
+	it("rejects fallback boundary keys when a message role contains the delimiter", () => {
+		expect(() =>
+			createSessionCompactionState({
+				sourceMessages: [
+					{
+						role: "user:custom",
+						content: "invalid role",
+					} as never,
+				],
+				compactedMessages: [
+					{ id: "summary", role: "user" as const, content: "summary" },
+				],
+				updatedAt: "2026-01-01T00:00:00.000Z",
+			}),
+		).toThrow("Message role cannot contain ':'");
+	});
+
+	it("rejects projection when the canonical prefix was edited before the boundary", () => {
+		const sourceMessages = [
+			{ id: "u1", role: "user" as const, content: "original detail" },
+			{ id: "a1", role: "assistant" as const, content: "answer" },
+		];
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages: [
+				{ id: "summary", role: "user" as const, content: "summary" },
+			],
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		const editedPrefix = [
+			{ ...sourceMessages[0], content: "redacted detail" },
+			sourceMessages[1],
+			{ id: "u2", role: "user" as const, content: "tail" },
+		];
+
+		expect(projectSessionCompactionState(state, editedPrefix)).toBeUndefined();
+	});
+
+	it("projects compacted state when the canonical prefix matches exactly", () => {
+		const sourceMessages = [
+			{ id: "u1", role: "user" as const, content: "original detail" },
+			{ id: "a1", role: "assistant" as const, content: "answer" },
+		];
+		const compactedMessages = [
+			{ id: "summary", role: "user" as const, content: "summary" },
+		];
+		const tail = { id: "u2", role: "user" as const, content: "tail" };
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages,
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		expect(
+			projectSessionCompactionState(state, [...sourceMessages, tail]),
+		).toEqual([...compactedMessages, tail]);
+	});
+
+	it("projects after persisted source messages are reloaded from JSON", () => {
+		const sourceMessages = [
+			{
+				id: "a1",
+				role: "assistant" as const,
+				content: "answer",
+				metadata: { b: 2, a: 1 },
+				metrics: { inputTokens: 10, outputTokens: 5 },
+			},
+		];
+		const compactedMessages = [
+			{ id: "summary", role: "user" as const, content: "summary" },
+		];
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages,
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const reloadedMessages = JSON.parse(JSON.stringify(sourceMessages));
+
+		expect(projectSessionCompactionState(state, reloadedMessages)).toEqual(
+			compactedMessages,
+		);
+	});
+
+	it("rejects projection when canonical message metadata changed", () => {
+		const sourceMessages = [
+			{
+				id: "a1",
+				role: "assistant" as const,
+				content: "answer",
+				metadata: { stable: true },
+			},
+		];
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages: [
+				{ id: "summary", role: "user" as const, content: "summary" },
+			],
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		expect(
+			projectSessionCompactionState(state, [
+				{ ...sourceMessages[0], metadata: { stable: false } },
+			]),
+		).toBeUndefined();
+	});
+
+	it("projects when resumed user input was display-normalized from persisted history", () => {
+		const sourceMessages = [
+			{
+				id: "u1",
+				role: "user" as const,
+				content: '<user_input mode="act">hello</user_input>',
+			},
+			{
+				id: "u2",
+				role: "user" as const,
+				content: [
+					{
+						type: "text" as const,
+						text: '<user_input mode="act">inspect</user_input>',
+					},
+				],
+			},
+			{ id: "a1", role: "assistant" as const, content: "answer" },
+		];
+		const resumedMessages = [
+			{ ...sourceMessages[0], content: "hello" },
+			{
+				...sourceMessages[1],
+				content: [{ type: "text" as const, text: "inspect" }],
+			},
+			sourceMessages[2],
+			{ id: "u3", role: "user" as const, content: "tail" },
+		];
+		const compactedMessages = [
+			{ id: "summary", role: "user" as const, content: "summary" },
+		];
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages,
+			updatedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		expect(projectSessionCompactionState(state, resumedMessages)).toEqual([
+			...compactedMessages,
+			resumedMessages[3],
+		]);
+	});
+
+	it("rejects anchor-free sidecars even when the source count is zero", () => {
+		const state = parseSessionCompactionState({
+			version: 1,
+			updated_at: "2026-01-01T00:00:00.000Z",
+			source_message_count: 0,
+			messages: [
+				{ id: "summary", role: "user" as const, content: "unanchored" },
+			],
+		});
+
+		expect(state).toBeDefined();
+		if (!state) {
+			throw new Error("expected parsed compaction state");
+		}
+		expect(
+			projectSessionCompactionState(state, [
+				{ id: "u1", role: "user", content: "canonical" },
+			]),
+		).toBeUndefined();
+	});
+
+	it("projects legacy sidecars when the boundary key matches", () => {
+		const sourceMessages = [
+			{ id: "u1", role: "user" as const, content: "original detail" },
+			{ id: "a1", role: "assistant" as const, content: "answer" },
+		];
+		const tail = { id: "u2", role: "user" as const, content: "tail" };
+		const state = parseSessionCompactionState({
+			version: 1,
+			updated_at: "2026-01-01T00:00:00.000Z",
+			source_message_count: sourceMessages.length,
+			source_last_message_key: "id:a1",
+			messages: [{ id: "summary", role: "user" as const, content: "summary" }],
+		});
+
+		expect(state).toBeDefined();
+		if (!state) {
+			throw new Error("expected parsed compaction state");
+		}
+		expect(
+			projectSessionCompactionState(state, [...sourceMessages, tail]),
+		).toEqual([{ id: "summary", role: "user", content: "summary" }, tail]);
+	});
+
+	it("rejects malformed sidecar timestamps", () => {
+		const state = parseSessionCompactionState({
+			version: 1,
+			updated_at: "not-a-date",
+			source_message_count: 1,
+			source_prefix_hash: "sha256:test",
+			messages: [{ id: "summary", role: "user" as const, content: "summary" }],
+		});
+
+		expect(state).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/core/src/session/models/session-compaction.ts b/sdk/packages/core/src/session/models/session-compaction.ts
new file mode 100644
index 0000000..700428c
--- /dev/null
+++ b/sdk/packages/core/src/session/models/session-compaction.ts
@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+import {
+	formatDisplayUserInput,
+	type MessageWithMetadata,
+} from "@cline/shared";
+import { z } from "zod";
+
+function isMessageWithMetadata(value: unknown): value is MessageWithMetadata {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return false;
+	}
+	const candidate = value as Partial<MessageWithMetadata>;
+	if (candidate.role !== "user" && candidate.role !== "assistant") {
+		return false;
+	}
+	return (
+		typeof candidate.content === "string" || Array.isArray(candidate.content)
+	);
+}
+
+const MessageWithMetadataSchema = z.custom<MessageWithMetadata>(
+	isMessageWithMetadata,
+);
+
+export const SessionCompactionStateSchema = z.object({
+	version: z.literal(1),
+	updated_at: z.string().datetime(),
+	conversation_id: z.string().min(1).optional(),
+	source_message_count: z.number().int().nonnegative(),
+	source_prefix_hash: z.string().min(1).optional(),
+	source_last_message_key: z.string().min(1).optional(),
+	messages: z.array(MessageWithMetadataSchema),
+	system_prompt: z.string().optional(),
+});
+
+export type SessionCompactionState = z.infer<
+	typeof SessionCompactionStateSchema
+>;
+
+function cloneMessages(
+	messages: readonly MessageWithMetadata[],
+): MessageWithMetadata[] {
+	return JSON.parse(JSON.stringify(messages)) as MessageWithMetadata[];
+}
+
+function normalizeMessageForSourceHash(
+	message: MessageWithMetadata,
+): MessageWithMetadata {
+	if (message.role !== "user") {
+		return message;
+	}
+	if (typeof message.content === "string") {
+		return {
+			...message,
+			content: formatDisplayUserInput(message.content),
+		};
+	}
+	return {
+		...message,
+		content: message.content.map((part) =>
+			part.type === "text"
+				? { ...part, text: formatDisplayUserInput(part.text) }
+				: part,
+		),
+	};
+}
+
+function assertBoundaryRole(role: MessageWithMetadata["role"]): void {
+	if (role.includes(":")) {
+		throw new TypeError(
+			"Message role cannot contain ':' in compaction boundary keys",
+		);
+	}
+}
+
+// Hash the persisted message shape in a fixed top-level field order. Nested
+// objects keep their persisted JSON order because transcript writes are append-only.
+function sourceMessageHashInput(message: MessageWithMetadata): unknown[] {
+	const normalized = normalizeMessageForSourceHash(message);
+	assertBoundaryRole(normalized.role);
+	return [
+		["role", normalized.role],
+		["content", normalized.content],
+		["id", normalized.id ?? null],
+		["agent", normalized.agent ?? null],
+		["sessionId", normalized.sessionId ?? null],
+		["metadata", normalized.metadata ?? null],
+		["modelInfo", normalized.modelInfo ?? null],
+		["metrics", normalized.metrics ?? null],
+		["ts", normalized.ts ?? null],
+	];
+}
+
+function messageBoundaryKey(message: MessageWithMetadata | undefined): string {
+	if (!message) {
+		return "";
+	}
+	const normalized = normalizeMessageForSourceHash(message);
+	if (typeof normalized.id === "string" && normalized.id.trim()) {
+		return `id:${normalized.id.trim()}`;
+	}
+	assertBoundaryRole(normalized.role);
+	if (typeof normalized.ts === "number" && Number.isFinite(normalized.ts)) {
+		return `ts:${normalized.role}:${normalized.ts}`;
+	}
+	return `content:${normalized.role}:${JSON.stringify(normalized.content)}`;
+}
+
+// These anchors are persisted in session sidecars. Changing the format is safe
+// for saved transcripts, but invalidates existing compaction sidecars.
+function sourcePrefixHash(
+	messages: readonly MessageWithMetadata[],
+	count = messages.length,
+): string {
+	const hash = createHash("sha256");
+	hash.update("cline-session-compaction-source-v1\n");
+	hash.update(`${count}\n`);
+	for (const message of messages.slice(0, count)) {
+		hash.update(JSON.stringify(sourceMessageHashInput(message)));
+		hash.update("\n");
+	}
+	return `sha256:${hash.digest("hex")}`;
+}
+
+export function createSessionCompactionState(input: {
+	sourceMessages: readonly MessageWithMetadata[];
+	compactedMessages: readonly MessageWithMetadata[];
+	conversationId?: string;
+	systemPrompt?: string;
+	updatedAt?: string;
+}): SessionCompactionState {
+	const lastSourceMessage = input.sourceMessages.at(-1);
+	const sourceLastMessageKey = messageBoundaryKey(lastSourceMessage);
+	return SessionCompactionStateSchema.parse({
+		version: 1,
+		updated_at: input.updatedAt ?? new Date().toISOString(),
+		...(input.conversationId?.trim()
+			? { conversation_id: input.conversationId.trim() }
+			: {}),
+		source_message_count: input.sourceMessages.length,
+		source_prefix_hash: sourcePrefixHash(input.sourceMessages),
+		...(sourceLastMessageKey
+			? { source_last_message_key: sourceLastMessageKey }
+			: {}),
+		messages: cloneMessages(input.compactedMessages),
+		...(input.systemPrompt !== undefined
+			? { system_prompt: input.systemPrompt }
+			: {}),
+	});
+}
+
+export function projectSessionCompactionState(
+	state: SessionCompactionState,
+	sourceMessages: readonly MessageWithMetadata[],
+): MessageWithMetadata[] | undefined {
+	const hasEnoughSourceMessages =
+		state.source_message_count <= sourceMessages.length;
+	if (!hasEnoughSourceMessages) {
+		return undefined;
+	}
+
+	const hasMatchingSourcePrefix =
+		!!state.source_prefix_hash &&
+		sourcePrefixHash(sourceMessages, state.source_message_count) ===
+			state.source_prefix_hash;
+	const boundary = sourceMessages[state.source_message_count - 1];
+	const hasMatchingLegacyBoundary =
+		!state.source_prefix_hash &&
+		state.source_message_count > 0 &&
+		!!state.source_last_message_key &&
+		messageBoundaryKey(boundary) === state.source_last_message_key;
+	const canProjectState = hasMatchingSourcePrefix || hasMatchingLegacyBoundary;
+	if (!canProjectState) {
+		return undefined;
+	}
+
+	return [
+		...cloneMessages(state.messages),
+		...cloneMessages(sourceMessages.slice(state.source_message_count)),
+	];
+}
+
+export function parseSessionCompactionState(
+	value: unknown,
+): SessionCompactionState | undefined {
+	const parsed = SessionCompactionStateSchema.safeParse(value);
+	return parsed.success ? parsed.data : undefined;
+}
diff --git a/sdk/packages/core/src/session/models/session-graph.ts b/sdk/packages/core/src/session/models/session-graph.ts
new file mode 100644
index 0000000..7403cc1
--- /dev/null
+++ b/sdk/packages/core/src/session/models/session-graph.ts
@@ -0,0 +1,92 @@
+import { nanoid } from "nanoid";
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+
+export function sanitizeSessionToken(value: string): string {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+export function makeSubSessionId(
+	rootSessionId: string,
+	agentId: string,
+): string {
+	const root = sanitizeSessionToken(rootSessionId);
+	const agent = sanitizeSessionToken(agentId);
+	const joined = `${root}__${agent}`;
+	return joined.length > 180 ? joined.slice(0, 180) : joined;
+}
+
+export function makeTeamTaskSubSessionId(
+	rootSessionId: string,
+	agentId: string,
+): string {
+	const root = sanitizeSessionToken(rootSessionId);
+	const agent = sanitizeSessionToken(agentId);
+	return `${root}__teamtask__${agent}__${nanoid(6)}`;
+}
+
+export function parseTeamTaskSubSessionId(
+	sessionId: string,
+): { rootSessionId: string; agentId: string; teamTaskId: string } | null {
+	const marker = "__teamtask__";
+	const markerIndex = sessionId.indexOf(marker);
+	if (markerIndex <= 0) {
+		return null;
+	}
+	const rootSessionId = sessionId.slice(0, markerIndex);
+	const remainder = sessionId.slice(markerIndex + marker.length);
+	const lastSeparator = remainder.lastIndexOf("__");
+	if (lastSeparator <= 0) {
+		return null;
+	}
+	const agentId = remainder.slice(0, lastSeparator);
+	const teamTaskId = remainder.slice(lastSeparator + 2);
+	if (!rootSessionId || !agentId || !teamTaskId) {
+		return null;
+	}
+	return { rootSessionId, agentId, teamTaskId };
+}
+
+export function parseSubSessionId(
+	sessionId: string,
+): { rootSessionId: string; agentId: string } | null {
+	if (parseTeamTaskSubSessionId(sessionId)) {
+		return null;
+	}
+	const separator = "__";
+	const separatorIndex = sessionId.indexOf(separator);
+	if (separatorIndex <= 0) {
+		return null;
+	}
+	const rootSessionId = sessionId.slice(0, separatorIndex);
+	const agentId = sessionId.slice(separatorIndex + separator.length);
+	if (!rootSessionId || !agentId) {
+		return null;
+	}
+	return { rootSessionId, agentId };
+}
+
+export function deriveSubsessionStatus(event: HookEventPayload): SessionStatus {
+	switch (event.hookName) {
+		case "agent_end":
+			return "completed";
+		case "agent_error":
+			return "failed";
+		case "session_shutdown": {
+			const reason = String(event.reason ?? "").toLowerCase();
+			if (
+				reason.includes("cancel") ||
+				reason.includes("abort") ||
+				reason.includes("interrupt")
+			) {
+				return "cancelled";
+			}
+			if (reason.includes("fail") || reason.includes("error")) {
+				return "failed";
+			}
+			return "completed";
+		}
+		default:
+			return "running";
+	}
+}
diff --git a/sdk/packages/core/src/session/models/session-manifest.ts b/sdk/packages/core/src/session/models/session-manifest.ts
new file mode 100644
index 0000000..47eb479
--- /dev/null
+++ b/sdk/packages/core/src/session/models/session-manifest.ts
@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { SESSION_STATUSES } from "../../types/common";
+
+const SessionStatusSchema = z.enum(SESSION_STATUSES);
+
+export const SessionManifestSchema = z.object({
+	version: z.literal(1),
+	session_id: z.string().min(1),
+	source: z.string().min(1),
+	pid: z.number().int(),
+	started_at: z.string().min(1),
+	ended_at: z.string().min(1).optional(),
+	exit_code: z.number().int().nullable().optional(),
+	status: SessionStatusSchema,
+	interactive: z.boolean(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	cwd: z.string().min(1),
+	workspace_root: z.string().min(1),
+	team_name: z.string().min(1).optional(),
+	enable_tools: z.boolean(),
+	enable_spawn: z.boolean(),
+	enable_teams: z.boolean(),
+	prompt: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	messages_path: z.string().min(1).optional(),
+	compaction_path: z.string().min(1).optional(),
+});
+
+export type SessionManifest = z.infer<typeof SessionManifestSchema>;
diff --git a/sdk/packages/core/src/session/models/session-row.ts b/sdk/packages/core/src/session/models/session-row.ts
new file mode 100644
index 0000000..445505f
--- /dev/null
+++ b/sdk/packages/core/src/session/models/session-row.ts
@@ -0,0 +1,200 @@
+import type { TeamTeammateSpec } from "@cline/shared";
+import type { AgentTeamsRuntime } from "../../extensions/tools/team";
+import type { SessionSource, SessionStatus } from "../../types/common";
+import type { SessionManifest } from "./session-manifest";
+
+export interface SessionRow {
+	sessionId: string;
+	source: string;
+	pid: number;
+	startedAt: string;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	status: SessionStatus;
+	statusLock: number;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string | null;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	parentSessionId?: string | null;
+	parentAgentId?: string | null;
+	agentId?: string | null;
+	conversationId?: string | null;
+	isSubagent: boolean;
+	prompt?: string | null;
+	metadata?: Record<string, unknown> | null;
+	hookPath?: string;
+	messagesPath?: string | null;
+	updatedAt: string;
+}
+
+export interface CreateRootSessionInput {
+	sessionId: string;
+	source: SessionSource;
+	pid: number;
+	startedAt: string;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	messagesPath: string;
+}
+
+export interface CreateRootSessionWithArtifactsInput {
+	sessionId: string;
+	source: SessionSource;
+	pid: number;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	startedAt?: string;
+}
+
+export interface RootSessionArtifacts {
+	manifestPath: string;
+	messagesPath: string;
+	compactionPath?: string;
+	manifest: SessionManifest;
+}
+
+export interface UpsertSubagentInput {
+	agentId: string;
+	parentAgentId: string;
+	conversationId: string;
+	prompt?: string;
+	rootSessionId?: string;
+}
+
+/** SELECT clause that aliases snake_case columns to camelCase SessionRow keys. */
+export const SESSION_SELECT_COLUMNS = `
+	session_id    AS sessionId,
+	source,
+	pid,
+	started_at    AS startedAt,
+	ended_at      AS endedAt,
+	exit_code     AS exitCode,
+	status,
+	status_lock   AS statusLock,
+	interactive,
+	provider,
+	model,
+	cwd,
+	workspace_root AS workspaceRoot,
+	team_name      AS teamName,
+	enable_tools   AS enableTools,
+	enable_spawn   AS enableSpawn,
+	enable_teams   AS enableTeams,
+	parent_session_id AS parentSessionId,
+	parent_agent_id   AS parentAgentId,
+	agent_id       AS agentId,
+	conversation_id AS conversationId,
+	is_subagent    AS isSubagent,
+	prompt,
+	metadata_json  AS metadata,
+	hook_path       AS hookPath,
+	messages_path   AS messagesPath,
+	updated_at      AS updatedAt`;
+
+export function patchSqliteRow(raw: Record<string, unknown>): SessionRow {
+	raw.interactive = raw.interactive === 1;
+	raw.enableTools = raw.enableTools === 1;
+	raw.enableSpawn = raw.enableSpawn === 1;
+	raw.enableTeams = raw.enableTeams === 1;
+	raw.isSubagent = raw.isSubagent === 1;
+	const meta = raw.metadata;
+	if (typeof meta === "string" && meta.trim()) {
+		try {
+			const parsed = JSON.parse(meta) as unknown;
+			raw.metadata =
+				parsed && typeof parsed === "object" && !Array.isArray(parsed)
+					? parsed
+					: null;
+		} catch {
+			raw.metadata = null;
+		}
+	} else {
+		raw.metadata = null;
+	}
+	return raw as unknown as SessionRow;
+}
+
+export function stringifyMetadata(
+	metadata: Record<string, unknown> | null | undefined,
+): string | null {
+	if (!metadata || Object.keys(metadata).length === 0) return null;
+	return JSON.stringify(metadata);
+}
+
+export type TeamRuntimeState = ReturnType<AgentTeamsRuntime["exportState"]>;
+
+export interface PersistedTeamEnvelope {
+	version: 1;
+	updatedAt: string;
+	teamState: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+}
+
+export function reviveTeamStateDates(
+	state: TeamRuntimeState,
+): TeamRuntimeState {
+	return {
+		...state,
+		tasks: state.tasks.map((task) => ({
+			...task,
+			createdAt: new Date(task.createdAt),
+			updatedAt: new Date(task.updatedAt),
+		})),
+		mailbox: state.mailbox.map((message) => ({
+			...message,
+			sentAt: new Date(message.sentAt),
+			readAt: message.readAt ? new Date(message.readAt) : undefined,
+		})),
+		missionLog: state.missionLog.map((entry) => ({
+			...entry,
+			ts: new Date(entry.ts),
+		})),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			startedAt: new Date(run.startedAt),
+			endedAt: run.endedAt ? new Date(run.endedAt) : undefined,
+			nextAttemptAt: run.nextAttemptAt
+				? new Date(run.nextAttemptAt)
+				: undefined,
+			heartbeatAt: run.heartbeatAt ? new Date(run.heartbeatAt) : undefined,
+		})),
+		outcomes: (state.outcomes ?? []).map((outcome) => ({
+			...outcome,
+			createdAt: new Date(outcome.createdAt),
+			finalizedAt: outcome.finalizedAt
+				? new Date(outcome.finalizedAt)
+				: undefined,
+		})),
+		outcomeFragments: (state.outcomeFragments ?? []).map((fragment) => ({
+			...fragment,
+			createdAt: new Date(fragment.createdAt),
+			reviewedAt: fragment.reviewedAt
+				? new Date(fragment.reviewedAt)
+				: undefined,
+		})),
+	};
+}
diff --git a/sdk/packages/core/src/session/services/file-session-service.ts b/sdk/packages/core/src/session/services/file-session-service.ts
new file mode 100644
index 0000000..42f577b
--- /dev/null
+++ b/sdk/packages/core/src/session/services/file-session-service.ts
@@ -0,0 +1,284 @@
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { BasicLogger } from "@cline/shared";
+import { resolveSessionDataDir } from "@cline/shared/storage";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import type { SessionRow } from "../models/session-row";
+import type {
+	PersistedSessionUpdateInput,
+	SessionPersistenceAdapter,
+} from "./persistence-service";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+
+interface FileSessionIndex {
+	version: 1;
+	sessions: Record<string, SessionRow>;
+}
+
+interface FileSpawnRequest {
+	id: number;
+	rootSessionId: string;
+	parentAgentId: string;
+	task?: string;
+	systemPrompt?: string;
+	createdAt: string;
+	consumedAt?: string;
+}
+
+interface FileSpawnQueue {
+	version: 1;
+	nextId: number;
+	requests: FileSpawnRequest[];
+}
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function atomicWriteJson(path: string, value: unknown): void {
+	const tempPath = `${path}.tmp`;
+	writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	renameSync(tempPath, path);
+}
+
+class FileSessionPersistenceAdapter implements SessionPersistenceAdapter {
+	constructor(
+		private readonly sessionsDirPath: string = resolveSessionDataDir(),
+	) {}
+
+	ensureSessionsDir(): string {
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
+	}
+
+	private indexPath(): string {
+		return join(this.ensureSessionsDir(), "sessions.index.json");
+	}
+
+	private spawnQueuePath(): string {
+		return join(this.ensureSessionsDir(), "subagent-spawn-queue.json");
+	}
+
+	private readIndex(): FileSessionIndex {
+		const path = this.indexPath();
+		if (!existsSync(path)) {
+			return { version: 1, sessions: {} };
+		}
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSessionIndex;
+			if (parsed?.version === 1 && parsed.sessions) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to an empty index.
+		}
+		return { version: 1, sessions: {} };
+	}
+
+	private writeIndex(index: FileSessionIndex): void {
+		atomicWriteJson(this.indexPath(), index);
+	}
+
+	private readQueue(): FileSpawnQueue {
+		const path = this.spawnQueuePath();
+		if (!existsSync(path)) {
+			return { version: 1, nextId: 1, requests: [] };
+		}
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSpawnQueue;
+			if (
+				parsed?.version === 1 &&
+				typeof parsed.nextId === "number" &&
+				Array.isArray(parsed.requests)
+			) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to an empty queue.
+		}
+		return { version: 1, nextId: 1, requests: [] };
+	}
+
+	private writeQueue(queue: FileSpawnQueue): void {
+		atomicWriteJson(this.spawnQueuePath(), queue);
+	}
+
+	async upsertSession(row: SessionRow): Promise<void> {
+		const index = this.readIndex();
+		index.sessions[row.sessionId] = row;
+		this.writeIndex(index);
+	}
+
+	async getSession(sessionId: string): Promise<SessionRow | undefined> {
+		return this.readIndex().sessions[sessionId];
+	}
+
+	async listSessions(options: {
+		limit: number;
+		parentSessionId?: string;
+		status?: string;
+	}): Promise<SessionRow[]> {
+		return Object.values(this.readIndex().sessions)
+			.filter((row) =>
+				options.parentSessionId !== undefined
+					? row.parentSessionId === options.parentSessionId
+					: true,
+			)
+			.filter((row) =>
+				options.status !== undefined ? row.status === options.status : true,
+			)
+			.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+			.slice(0, options.limit);
+	}
+
+	async updateSession(
+		input: PersistedSessionUpdateInput,
+	): Promise<{ updated: boolean; statusLock: number }> {
+		const index = this.readIndex();
+		const existing = index.sessions[input.sessionId];
+		if (!existing) {
+			return { updated: false, statusLock: 0 };
+		}
+		if (
+			input.expectedStatusLock !== undefined &&
+			existing.statusLock !== input.expectedStatusLock
+		) {
+			return { updated: false, statusLock: existing.statusLock };
+		}
+
+		const nextStatusLock =
+			input.expectedStatusLock !== undefined
+				? input.expectedStatusLock + 1
+				: existing.statusLock;
+		const next: SessionRow = {
+			...existing,
+			status: input.status ?? existing.status,
+			endedAt:
+				input.endedAt !== undefined
+					? input.endedAt
+					: (existing.endedAt ?? null),
+			exitCode:
+				input.exitCode !== undefined
+					? input.exitCode
+					: (existing.exitCode ?? null),
+			prompt:
+				input.prompt !== undefined ? input.prompt : (existing.prompt ?? null),
+			metadata:
+				input.metadata !== undefined
+					? (input.metadata ?? null)
+					: (existing.metadata ?? null),
+			parentSessionId:
+				input.parentSessionId !== undefined
+					? (input.parentSessionId ?? null)
+					: (existing.parentSessionId ?? null),
+			parentAgentId:
+				input.parentAgentId !== undefined
+					? (input.parentAgentId ?? null)
+					: (existing.parentAgentId ?? null),
+			agentId:
+				input.agentId !== undefined
+					? (input.agentId ?? null)
+					: (existing.agentId ?? null),
+			conversationId:
+				input.conversationId !== undefined
+					? (input.conversationId ?? null)
+					: (existing.conversationId ?? null),
+			statusLock: nextStatusLock,
+			isSubagent:
+				input.setRunning || input.parentSessionId !== undefined
+					? true
+					: existing.isSubagent,
+			updatedAt: nowIso(),
+		};
+
+		if (input.setRunning) {
+			next.status = "running";
+			next.endedAt = null;
+			next.exitCode = null;
+		}
+
+		index.sessions[input.sessionId] = next;
+		this.writeIndex(index);
+		return { updated: true, statusLock: next.statusLock };
+	}
+
+	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
+		const index = this.readIndex();
+		const existing = index.sessions[sessionId];
+		if (!existing) {
+			return false;
+		}
+		delete index.sessions[sessionId];
+		if (cascade) {
+			for (const row of Object.values(index.sessions)) {
+				if (row.parentSessionId === sessionId) {
+					delete index.sessions[row.sessionId];
+				}
+			}
+		}
+		this.writeIndex(index);
+		return true;
+	}
+
+	async enqueueSpawnRequest(input: {
+		rootSessionId: string;
+		parentAgentId: string;
+		task?: string;
+		systemPrompt?: string;
+	}): Promise<void> {
+		const queue = this.readQueue();
+		queue.requests.push({
+			id: queue.nextId,
+			rootSessionId: input.rootSessionId,
+			parentAgentId: input.parentAgentId,
+			task: input.task,
+			systemPrompt: input.systemPrompt,
+			createdAt: nowIso(),
+		});
+		queue.nextId += 1;
+		this.writeQueue(queue);
+	}
+
+	async claimSpawnRequest(
+		rootSessionId: string,
+		parentAgentId: string,
+	): Promise<string | undefined> {
+		const queue = this.readQueue();
+		const request = queue.requests.find(
+			(item) =>
+				item.rootSessionId === rootSessionId &&
+				item.parentAgentId === parentAgentId &&
+				!item.consumedAt,
+		);
+		if (!request) {
+			return undefined;
+		}
+		request.consumedAt = nowIso();
+		this.writeQueue(queue);
+		return request.task;
+	}
+}
+
+export class FileSessionService extends UnifiedSessionPersistenceService {
+	constructor(
+		sessionsDir?: string,
+		options: {
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+			logger?: BasicLogger;
+		} = {},
+	) {
+		super(new FileSessionPersistenceAdapter(sessionsDir), options);
+	}
+
+	override ensureSessionsDir(): string {
+		return super.ensureSessionsDir();
+	}
+}
diff --git a/sdk/packages/core/src/session/services/message-builder.test.ts b/sdk/packages/core/src/session/services/message-builder.test.ts
new file mode 100644
index 0000000..f3cf82a
--- /dev/null
+++ b/sdk/packages/core/src/session/services/message-builder.test.ts
@@ -0,0 +1,2253 @@
+import {
+	type AiSdkFormatterMessage,
+	formatMessagesForAiSdk,
+	type Message,
+	type ToolResultContent,
+} from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	agentMessagesToMessages,
+	messagesToAgentMessages,
+} from "../../runtime/config/agent-message-codec";
+import {
+	DEFAULT_MAX_FILE_CONTENT_CHARS,
+	DEFAULT_MAX_TOOL_RESULT_CHARS,
+	DEFAULT_MAX_TOTAL_TEXT_BYTES,
+	getMessageBuilderOptionsFromEnv,
+	MessageBuilder,
+} from "./message-builder";
+
+describe("MessageBuilder", () => {
+	it("inserts an error tool result before a follow-up prompt when a prior tool call is missing a result", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			{
+				role: "user",
+				content: [{ type: "text", text: "inspect the repo" }],
+			},
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "text",
+						text: "I will inspect it.",
+					},
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "search_codebase",
+						input: { queries: ["session resume"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [{ type: "text", text: "please continue" }],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+
+		expect(result).toHaveLength(3);
+		expect(result[2]).toEqual({
+			role: "user",
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: "tool_1",
+					name: "search_codebase",
+					content: [
+						{
+							type: "text",
+							text: "Tool execution was interrupted before a result was produced. Tool: search_codebase.",
+						},
+					],
+					is_error: true,
+				},
+				{ type: "text", text: "please continue" },
+			],
+		});
+		expect(messages).toHaveLength(3);
+	});
+
+	it("fills only missing tool results after existing results for the same assistant turn", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "read",
+						input: { path: "/tmp/a.txt" },
+					},
+					{
+						type: "tool_use",
+						id: "tool_2",
+						name: "bash",
+						input: { command: "pwd" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "read",
+						content: "contents",
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [{ type: "text", text: "continue" }],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+
+		expect(result).toHaveLength(2);
+		const toolResultMessage = result[1];
+		expect(Array.isArray(toolResultMessage.content)).toBe(true);
+		if (!Array.isArray(toolResultMessage.content)) {
+			throw new Error("expected array content");
+		}
+		expect(toolResultMessage.content).toEqual([
+			{
+				type: "tool_result",
+				tool_use_id: "tool_1",
+				name: "read",
+				content: "contents",
+			},
+			{
+				type: "tool_result",
+				tool_use_id: "tool_2",
+				name: "bash",
+				content: [
+					{
+						type: "text",
+						text: "Tool execution was interrupted before a result was produced. Tool: bash.",
+					},
+				],
+				is_error: true,
+			},
+			{ type: "text", text: "continue" },
+		]);
+	});
+
+	it("does not rewrite synthetic read-tool error results as outdated file content", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "read",
+						input: { path: "/tmp/a.txt" },
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const content = result[1]?.content;
+		expect(Array.isArray(content)).toBe(true);
+		const block = Array.isArray(content) ? content[0] : undefined;
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result") {
+			throw new Error("expected tool_result");
+		}
+		expect(block.content).toEqual([
+			{
+				type: "text",
+				text: "Tool execution was interrupted before a result was produced. Tool: read.",
+			},
+		]);
+		expect(block.is_error).toBe(true);
+	});
+
+	it("truncates search_codebase tool results before provider requests", () => {
+		const builder = new MessageBuilder({ maxToolResultChars: 100 });
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "search_codebase",
+						input: { queries: "needle" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "read",
+						content: "a".repeat(250),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const content = result[1].content;
+		expect(Array.isArray(content)).toBe(true);
+		const block = Array.isArray(content) ? content[0] : undefined;
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result") {
+			throw new Error("expected tool_result");
+		}
+		expect(block.content.length).toBeLessThanOrEqual(100);
+		expect(block.content).toContain("...[truncated");
+	});
+
+	it("uses an aggressive per-result cap and a loose aggregate budget", () => {
+		expect(DEFAULT_MAX_TOOL_RESULT_CHARS).toBe(8_000);
+		expect(DEFAULT_MAX_FILE_CONTENT_CHARS).toBe(50_000);
+		// The aggregate budget stays loose on purpose: budget truncation
+		// rewrites mid-transcript bytes and breaks provider prefix caching, so
+		// it must stay a rare overflow valve while the per-result cap (which
+		// is deterministic per content) does the routine work.
+		expect(DEFAULT_MAX_TOTAL_TEXT_BYTES).toBe(6_000_000);
+	});
+
+	it("accepts named limit options for targeted provider payload tests", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 120,
+			maxTotalTextBytes: 10_000,
+		});
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "run_commands",
+						input: { commands: ["cat big.log"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "run_commands",
+						content: "a".repeat(500),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result") {
+			throw new Error("expected tool_result");
+		}
+		expect(typeof block.content).toBe("string");
+		if (typeof block.content !== "string") {
+			throw new Error("expected string content");
+		}
+		expect(block.content.length).toBeLessThanOrEqual(120);
+		expect(block.content).toContain("...[truncated");
+	});
+
+	it("parses message-builder limit environment overrides", () => {
+		const builder = new MessageBuilder(
+			getMessageBuilderOptionsFromEnv({
+				CLINE_MESSAGE_BUILDER_MAX_TOOL_RESULT_CHARS: "96",
+				CLINE_MESSAGE_BUILDER_MAX_TOTAL_TEXT_BYTES: "5000",
+				CLINE_MESSAGE_BUILDER_MIN_OUTDATED_REWRITE_BYTES: "0",
+			}),
+		);
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "search_codebase",
+						input: { queries: ["needle"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "search_codebase",
+						content: "b".repeat(500),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result") {
+			throw new Error("expected tool_result");
+		}
+		expect(typeof block.content).toBe("string");
+		if (typeof block.content !== "string") {
+			throw new Error("expected string content");
+		}
+		expect(block.content.length).toBeLessThanOrEqual(96);
+		expect(block.content).toContain("...[truncated");
+
+		const eagerBuilder = new MessageBuilder(
+			getMessageBuilderOptionsFromEnv({
+				CLINE_MESSAGE_BUILDER_MIN_OUTDATED_REWRITE_BYTES: "0",
+			}),
+		);
+		const eager = eagerBuilder.buildForApi([
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", SMALL_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", SMALL_CONTENT(2)),
+		]);
+		expect(JSON.stringify(eager[2])).toContain("outdated");
+	});
+
+	it("parses an env disable value for outdated-read rewrites", () => {
+		const builder = new MessageBuilder(
+			getMessageBuilderOptionsFromEnv({
+				CLINE_MESSAGE_BUILDER_MIN_OUTDATED_REWRITE_BYTES: "disable",
+			}),
+		);
+		const result = builder.buildForApi([
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		]);
+
+		expect(JSON.stringify(result[2])).not.toContain("outdated");
+		expect(JSON.stringify(result[2])).toContain("export const x = 1;");
+	});
+
+	it("ignores zero env overrides instead of disabling the limits", () => {
+		const options = getMessageBuilderOptionsFromEnv({
+			CLINE_MESSAGE_BUILDER_MAX_TOOL_RESULT_CHARS: "0",
+			CLINE_MESSAGE_BUILDER_MAX_TOTAL_TEXT_BYTES: "0",
+		});
+		expect(options.maxToolResultChars).toBeUndefined();
+		expect(options.maxTotalTextBytes).toBeUndefined();
+	});
+
+	it("applies an aggregate text budget across targeted tool results", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 20_000,
+		});
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "search_codebase",
+						input: { queries: "first" },
+					},
+					{
+						type: "tool_use",
+						id: "tool_2",
+						name: "search_codebase",
+						input: { queries: "second" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "read",
+						content: "a".repeat(15_000),
+					},
+					{
+						type: "tool_result",
+						tool_use_id: "tool_2",
+						name: "bash",
+						content: "b".repeat(15_000),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const totalBytes = result.reduce((sum, message) => {
+			if (typeof message.content === "string") {
+				return sum + Buffer.byteLength(message.content, "utf8");
+			}
+			return (
+				sum +
+				message.content.reduce((inner, block) => {
+					if (block.type !== "tool_result") {
+						return inner;
+					}
+					return (
+						inner +
+						(typeof block.content === "string"
+							? Buffer.byteLength(block.content, "utf8")
+							: 0)
+					);
+				}, 0)
+			);
+		}, 0);
+
+		expect(totalBytes).toBeLessThanOrEqual(20_000);
+		expect(JSON.stringify(result)).toContain("provider request budget");
+	});
+
+	it("applies the aggregate budget using UTF-8 byte size", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 12_000,
+		});
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "search_codebase",
+						input: { queries: "emoji" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "tool",
+						content: "🙂".repeat(5_000),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result") {
+			throw new Error("expected tool_result");
+		}
+		expect(typeof block.content).toBe("string");
+		if (typeof block.content !== "string") {
+			throw new Error("expected string content");
+		}
+		expect(Buffer.byteLength(block.content, "utf8")).toBeLessThanOrEqual(
+			12_000,
+		);
+		expect(block.content).toContain("provider request budget");
+	});
+
+	it("does not mutate original nested tool result content when applying aggregate budget", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 10_000,
+		});
+		const originalText = "a".repeat(15_000);
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "search_codebase",
+						input: { queries: "first" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "tool",
+						content: [{ type: "text", text: originalText }],
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const originalBlock = Array.isArray(messages[1].content)
+			? messages[1].content[0]
+			: undefined;
+		const resultBlock = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+
+		expect(originalBlock?.type).toBe("tool_result");
+		expect(resultBlock?.type).toBe("tool_result");
+		if (originalBlock?.type !== "tool_result") {
+			throw new Error("expected original tool_result");
+		}
+		if (resultBlock?.type !== "tool_result") {
+			throw new Error("expected result tool_result");
+		}
+		expect(originalBlock.content).toEqual([
+			{ type: "text", text: originalText },
+		]);
+		expect(resultBlock.content).not.toBe(originalBlock.content);
+		expect(resultBlock.content).toEqual([
+			expect.objectContaining({
+				type: "text",
+				text: expect.stringContaining("provider request budget"),
+			}),
+		]);
+	});
+
+	it("caps assistant text with repeated DSML tool-call fragments before provider requests", () => {
+		const builder = new MessageBuilder();
+		const dsmlFragment = [
+			"<\uFF5CDSML\uFF5Ctool_calls>",
+			'<\uFF5CDSML\uFF5Cinvoke name="read_file">',
+			`{"path":"/tmp/circuit-fibsqrt.ts","payload":"${"x".repeat(1_200)}"}`,
+			"</\uFF5CDSML\uFF5Cinvoke>",
+			"</\uFF5CDSML\uFF5Ctool_calls>",
+			"<tool_call>",
+			"</tool_call>",
+		].join("\n");
+		const assistantText = `I will inspect the circuit.\n${dsmlFragment.repeat(437)}\nDone.`;
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [{ type: "text", text: assistantText }],
+			},
+			{
+				role: "user",
+				content: [{ type: "text", text: "continue" }],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[0].content)
+			? result[0].content[0]
+			: undefined;
+
+		expect(assistantText.length).toBeGreaterThan(500_000);
+		expect(block?.type).toBe("text");
+		if (block?.type !== "text") {
+			throw new Error("expected assistant text block");
+		}
+		expect(block.text.length).toBeLessThanOrEqual(12_000);
+		expect(block.text).toContain("assistant text truncated: omitted");
+		expect(block.text).toContain("repeated tool-call markup");
+		expect(block.text.match(/DSML/g)?.length ?? 0).toBeLessThan(40);
+		expect(messages[0].content).toEqual([
+			{ type: "text", text: assistantText },
+		]);
+	});
+
+	it("keeps repeated assistant tool-call markup out of provider-formatted AI SDK payloads", () => {
+		const builder = new MessageBuilder();
+		const dsmlFragment = [
+			"<\uFF5CDSML\uFF5Ctool_calls>",
+			'<\uFF5CDSML\uFF5Cinvoke name="run_command">',
+			`{"command":"${"printf x; ".repeat(150)}"}`,
+			"</\uFF5CDSML\uFF5Cinvoke>",
+			"</\uFF5CDSML\uFF5Ctool_calls>",
+		].join("\n");
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [{ type: "text", text: dsmlFragment.repeat(500) }],
+			},
+			{
+				role: "user",
+				content: [{ type: "text", text: "next request" }],
+			},
+		];
+
+		const built = builder.buildForApi(messages);
+		const agentMessages = messagesToAgentMessages(built);
+		const aiSdkMessages = formatMessagesForAiSdk(
+			undefined,
+			agentMessages.map(({ role, content }) => ({
+				role,
+				content,
+			})) as unknown as AiSdkFormatterMessage[],
+		);
+		const serialized = JSON.stringify(aiSdkMessages);
+
+		expect(JSON.stringify(messages).length).toBeGreaterThan(650_000);
+		expect(serialized.length).toBeLessThan(25_000);
+		expect(serialized).toContain("assistant text truncated: omitted");
+		expect(serialized.match(/DSML/g)?.length ?? 0).toBeLessThan(40);
+	});
+
+	it("caps oversized top-level assistant string content with an omitted-char marker", () => {
+		const builder = new MessageBuilder({ maxAssistantTextChars: 1_000 });
+		const assistantText = `Lead\n${"normal assistant answer ".repeat(200)}\nTail`;
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: assistantText,
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+
+		expect(typeof result[0].content).toBe("string");
+		expect(result[0].content.length).toBeLessThanOrEqual(1_000);
+		expect(result[0].content).toContain("assistant text truncated: omitted");
+		expect(messages[0].content).toBe(assistantText);
+	});
+
+	it("preserves normal long assistant answers below the assistant text cap", () => {
+		const builder = new MessageBuilder();
+		const answer = [
+			"Summary:",
+			"A".repeat(80_000),
+			"Implementation notes:",
+			"B".repeat(80_000),
+			"Final answer.",
+		].join("\n");
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [{ type: "text", text: answer }],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+
+		expect(result).toEqual(messages);
+	});
+});
+
+/**
+ * Regression coverage for the real `ToolOperationResult[]` shape emitted by
+ * the default Cline tools (run_commands, read_files, search_codebase).
+ *
+ * The runtime stores these structured results directly as the tool_result
+ * `content` array (see `agentPartToContentBlock` in
+ * `runtime/config/agent-message-codec.ts`): the entries are plain
+ * `{query, result, success, ...}` objects with no `type` discriminator, so
+ * they bypass the text/file-entry truncation paths unless MessageBuilder
+ * handles them explicitly.
+ */
+describe("MessageBuilder with structured ToolOperationResult content", () => {
+	const MIDDLE_SENTINEL = "__MIDDLE_SENTINEL_MUST_BE_TRUNCATED__";
+	const HEAD_MARKER = "__HEAD_MARKER__";
+	const TAIL_MARKER = "__TAIL_MARKER__";
+
+	interface ToolOperationResultLike {
+		query: string;
+		result: unknown;
+		error?: string;
+		success: boolean;
+		duration?: number;
+	}
+
+	function hugeText(size = 400_000): string {
+		const fillerLength = Math.floor(
+			(size -
+				MIDDLE_SENTINEL.length -
+				HEAD_MARKER.length -
+				TAIL_MARKER.length) /
+				2,
+		);
+		const filler = "x".repeat(fillerLength);
+		return `${HEAD_MARKER}${filler}${MIDDLE_SENTINEL}${filler}${TAIL_MARKER}`;
+	}
+
+	function imageData(byteLength: number, fill = 1): string {
+		return Buffer.alloc(byteLength, fill).toString("base64");
+	}
+
+	function toolUseMessage(
+		id: string,
+		name: string,
+		input: Record<string, unknown>,
+	): Message {
+		return {
+			role: "assistant",
+			content: [{ type: "tool_use", id, name, input }],
+		};
+	}
+
+	function structuredToolResultMessage(
+		toolUseId: string,
+		name: string,
+		operations: ToolOperationResultLike[],
+	): Message {
+		return {
+			role: "user",
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: toolUseId,
+					name,
+					// The runtime casts ToolOperationResult[] straight into the
+					// content array; mirror that here.
+					content: operations as unknown as ToolResultContent["content"],
+				},
+			],
+		};
+	}
+
+	function sumStringBytes(value: unknown): number {
+		if (typeof value === "string") {
+			return Buffer.byteLength(value, "utf8");
+		}
+		if (Array.isArray(value)) {
+			return value.reduce<number>((sum, item) => sum + sumStringBytes(item), 0);
+		}
+		if (value !== null && typeof value === "object") {
+			return Object.values(value).reduce<number>(
+				(sum, item) => sum + sumStringBytes(item),
+				0,
+			);
+		}
+		return 0;
+	}
+
+	function serializeForAiSdk(messages: Message[]): string {
+		const agentMessages = messagesToAgentMessages(messages);
+		const aiSdkMessages = formatMessagesForAiSdk(
+			undefined,
+			agentMessages.map(({ role, content }) => ({
+				role,
+				content,
+			})) as unknown as AiSdkFormatterMessage[],
+		);
+		return JSON.stringify(aiSdkMessages);
+	}
+
+	function firstToolOperationResult(
+		result: Message[],
+	): ToolOperationResultLike {
+		const block = Array.isArray(result[1]?.content)
+			? result[1].content[0]
+			: undefined;
+		expect(block?.type).toBe("tool_result");
+		if (block?.type !== "tool_result" || typeof block.content === "string") {
+			throw new Error("expected structured tool_result");
+		}
+		const operation = block.content[0] as unknown;
+		expect(operation).toBeTruthy();
+		return operation as ToolOperationResultLike;
+	}
+
+	it("reduces a real-shaped multi-MB run_commands result to the default cap", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			toolUseMessage("call_1", "run_commands", {
+				commands: ["python emit_multi_mb_output.py"],
+			}),
+			structuredToolResultMessage("call_1", "run_commands", [
+				{
+					query: "python emit_multi_mb_output.py",
+					result: hugeText(2_500_000),
+					success: true,
+					duration: 4321,
+				},
+			]),
+		];
+
+		const rawSerializedLength = JSON.stringify(messages).length;
+		const result = builder.buildForApi(messages);
+		const operation = firstToolOperationResult(result);
+		const output = operation.result;
+
+		expect(rawSerializedLength).toBeGreaterThan(2_400_000);
+		expect(typeof output).toBe("string");
+		if (typeof output !== "string") {
+			throw new Error("expected string result");
+		}
+		expect(output.length).toBeLessThanOrEqual(DEFAULT_MAX_TOOL_RESULT_CHARS);
+		expect(output).toContain("...[truncated");
+		expect(output).not.toContain(MIDDLE_SENTINEL);
+		expect(output).toContain(HEAD_MARKER);
+		expect(output).toContain(TAIL_MARKER);
+		expect(sumStringBytes(operation)).toBeLessThan(
+			DEFAULT_MAX_TOOL_RESULT_CHARS + 512,
+		);
+	});
+
+	it("materially shrinks provider-formatted payloads compared with previous defaults", () => {
+		const messages: Message[] = [];
+		for (let i = 0; i < 20; i++) {
+			messages.push(
+				toolUseMessage(`call_${i}`, "run_commands", {
+					commands: [`python noisy_task_${i}.py`],
+				}),
+				structuredToolResultMessage(`call_${i}`, "run_commands", [
+					{
+						query: `python noisy_task_${i}.py`,
+						result: hugeText(300_000),
+						success: true,
+						duration: 1000 + i,
+					},
+				]),
+			);
+		}
+		const previousDefaults = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 6_000_000,
+		});
+		const currentDefaults = new MessageBuilder();
+
+		const previousPayload = serializeForAiSdk(
+			previousDefaults.buildForApi(messages),
+		);
+		const currentPayload = serializeForAiSdk(
+			currentDefaults.buildForApi(messages),
+		);
+
+		expect(previousPayload.length).toBeGreaterThan(900_000);
+		expect(currentPayload.length).toBeLessThan(previousPayload.length * 0.25);
+		expect(currentPayload.length).toBeLessThan(250_000);
+		expect(currentPayload).not.toContain(MIDDLE_SENTINEL);
+	});
+
+	it("truncates a huge nested `result` string in run_commands structured output", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			toolUseMessage("call_1", "run_commands", {
+				commands: ["cat big.log"],
+			}),
+			structuredToolResultMessage("call_1", "run_commands", [
+				{
+					query: "cat big.log",
+					result: hugeText(),
+					success: true,
+					duration: 1234,
+				},
+			]),
+		];
+
+		const rawSerializedLength = JSON.stringify(messages).length;
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(rawSerializedLength).toBeGreaterThan(390_000);
+		expect(serialized.length).toBeLessThan(120_000);
+		expect(serialized).not.toContain(MIDDLE_SENTINEL);
+		// Middle truncation must preserve the head and tail of the output.
+		expect(serialized).toContain(HEAD_MARKER);
+		expect(serialized).toContain(TAIL_MARKER);
+	});
+
+	it("truncates a huge nested `query` string in run_commands structured output", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			toolUseMessage("call_1", "run_commands", {
+				commands: ["bash -c '...giant heredoc...'"],
+			}),
+			structuredToolResultMessage("call_1", "run_commands", [
+				{
+					query: hugeText(),
+					result: "ok",
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized.length).toBeLessThan(120_000);
+		expect(serialized).not.toContain(MIDDLE_SENTINEL);
+		expect(serialized).toContain(HEAD_MARKER);
+		expect(serialized).toContain(TAIL_MARKER);
+	});
+
+	it("truncates a huge file payload in read_files structured output", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			toolUseMessage("call_1", "read_files", {
+				files: [{ path: "/tmp/big.txt" }],
+			}),
+			structuredToolResultMessage("call_1", "read_files", [
+				{
+					query: "/tmp/big.txt",
+					result: hugeText(),
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized.length).toBeLessThan(120_000);
+		expect(serialized).not.toContain(MIDDLE_SENTINEL);
+		expect(serialized).toContain(HEAD_MARKER);
+		expect(serialized).toContain(TAIL_MARKER);
+		// The latest read of a file must not be rewritten as outdated.
+		expect(serialized).not.toContain("[outdated");
+	});
+
+	it("omits an oversized read_files image result without corrupting base64", () => {
+		const oversizedImage = imageData(96);
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 1_000_000,
+			mediaBudget: {
+				maxImageEncodedBytes: 48,
+				maxImageDecodedBytes: 48,
+				maxTotalMediaBytes: 512,
+			},
+		});
+		const messages: Message[] = [
+			toolUseMessage("call_1", "read_files", {
+				files: [{ path: "/tmp/large.png" }],
+			}),
+			structuredToolResultMessage("call_1", "read_files", [
+				{
+					query: "/tmp/large.png",
+					result: [
+						"Successfully read image",
+						{
+							type: "image",
+							data: oversizedImage,
+							mediaType: "image/png",
+						},
+					],
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain(oversizedImage);
+		expect(serialized).not.toContain("...[truncated");
+		expect(messages).toEqual([
+			messages[0],
+			structuredToolResultMessage("call_1", "read_files", [
+				{
+					query: "/tmp/large.png",
+					result: [
+						"Successfully read image",
+						{
+							type: "image",
+							data: oversizedImage,
+							mediaType: "image/png",
+						},
+					],
+					success: true,
+				},
+			]),
+		]);
+	});
+
+	it("omits oversized custom structured image results regardless of tool name", () => {
+		const oversizedImage = imageData(96);
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 1_000_000,
+			mediaBudget: {
+				maxImageEncodedBytes: 48,
+				maxImageDecodedBytes: 48,
+				maxTotalMediaBytes: 512,
+			},
+		});
+		const messages: Message[] = [
+			toolUseMessage("call_1", "custom_mcp_tool", {
+				path: "/tmp/large.png",
+			}),
+			structuredToolResultMessage("call_1", "custom_mcp_tool", [
+				{
+					query: "/tmp/large.png",
+					result: {
+						type: "image",
+						data: oversizedImage,
+						mediaType: "image/png",
+					},
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain(oversizedImage);
+		expect(serialized).not.toContain("...[truncated");
+	});
+
+	it("omits malformed image-shaped objects instead of counting them as free text", () => {
+		const hiddenPayload = imageData(4096);
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 1_000_000,
+			mediaBudget: {
+				maxImageEncodedBytes: 128,
+				maxImageDecodedBytes: 128,
+				maxTotalMediaBytes: 128,
+			},
+		});
+		const messages: Message[] = [
+			toolUseMessage("call_1", "custom_mcp_tool", {
+				path: "/tmp/malformed.png",
+			}),
+			structuredToolResultMessage("call_1", "custom_mcp_tool", [
+				{
+					query: "/tmp/malformed.png",
+					result: {
+						type: "image",
+						data: hiddenPayload,
+					},
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain(hiddenPayload);
+		expect(serialized).not.toContain("...[truncated");
+	});
+
+	it("keeps valid small read_files images as native provider media", () => {
+		const smallImage = imageData(16);
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 1_000_000,
+			mediaBudget: {
+				maxImageEncodedBytes: 128,
+				maxImageDecodedBytes: 128,
+				maxTotalMediaBytes: 128,
+			},
+		});
+		const messages: Message[] = [
+			toolUseMessage("call_1", "read_files", {
+				files: [{ path: "/tmp/small.png" }],
+			}),
+			structuredToolResultMessage("call_1", "read_files", [
+				{
+					query: "/tmp/small.png",
+					result: [
+						"Successfully read image",
+						{
+							type: "image",
+							data: smallImage,
+							mediaType: "image/png",
+						},
+					],
+					success: true,
+				},
+			]),
+		];
+
+		const built = builder.buildForApi(messages);
+		const agentMessages = messagesToAgentMessages(built);
+		const aiSdkMessages = formatMessagesForAiSdk(
+			undefined,
+			agentMessages.map(({ role, content }) => ({
+				role,
+				content,
+			})) as unknown as AiSdkFormatterMessage[],
+		);
+		const serialized = JSON.stringify(aiSdkMessages);
+
+		expect(serialized).toContain('"type":"image-data"');
+		expect(serialized).toContain(smallImage);
+		expect(serialized).not.toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+	});
+
+	it("applies the total media budget across otherwise valid images", () => {
+		const firstImage = imageData(16);
+		const secondImage = imageData(16, 2);
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 1_000_000,
+			mediaBudget: {
+				maxImageEncodedBytes: 128,
+				maxImageDecodedBytes: 128,
+				maxTotalMediaBytes: Buffer.byteLength(firstImage, "utf8"),
+			},
+		});
+		const messages: Message[] = [
+			toolUseMessage("call_1", "read_files", {
+				files: [{ path: "/tmp/a.png" }, { path: "/tmp/b.png" }],
+			}),
+			structuredToolResultMessage("call_1", "read_files", [
+				{
+					query: "/tmp/a.png",
+					result: [
+						"Successfully read image",
+						{
+							type: "image",
+							data: firstImage,
+							mediaType: "image/png",
+						},
+					],
+					success: true,
+				},
+				{
+					query: "/tmp/b.png",
+					result: [
+						"Successfully read image",
+						{
+							type: "image",
+							data: secondImage,
+							mediaType: "image/png",
+						},
+					],
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized).toContain(firstImage);
+		expect(serialized).not.toContain(secondImage);
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+	});
+
+	it("truncates a huge fetch_web_content structured result", () => {
+		// The web-fetch executor allows responses up to 5MB, so this tool must
+		// be covered by the truncation targets like the other bulk-output tools.
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			toolUseMessage("call_1", "fetch_web_content", {
+				requests: [{ url: "https://example.com/huge-page" }],
+			}),
+			structuredToolResultMessage("call_1", "fetch_web_content", [
+				{
+					query: "https://example.com/huge-page",
+					result: hugeText(),
+					success: true,
+				},
+			]),
+		];
+
+		const result = builder.buildForApi(messages);
+		const serialized = JSON.stringify(result);
+
+		expect(serialized.length).toBeLessThan(120_000);
+		expect(serialized).not.toContain(MIDDLE_SENTINEL);
+		expect(serialized).toContain(HEAD_MARKER);
+		expect(serialized).toContain(TAIL_MARKER);
+	});
+
+	it("applies the aggregate text budget to nested structured strings", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 100_000,
+		});
+		// Five results of ~40k chars each: every nested string is below the
+		// per-result limit, but the aggregate (~200k) exceeds the budget.
+		const messages: Message[] = [];
+		for (let i = 0; i < 5; i++) {
+			const name = i % 2 === 0 ? "run_commands" : "read_files";
+			messages.push(
+				toolUseMessage(`call_${i}`, name, { commands: [`cmd ${i}`] }),
+				structuredToolResultMessage(`call_${i}`, name, [
+					{
+						query: `cmd ${i}`,
+						result: `chunk_${i}_`.repeat(4_000),
+						success: true,
+					},
+				]),
+			);
+		}
+
+		const result = builder.buildForApi(messages);
+
+		let toolResultStringBytes = 0;
+		for (const message of result) {
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type === "tool_result") {
+					toolResultStringBytes += sumStringBytes(block.content);
+				}
+			}
+		}
+
+		expect(toolResultStringBytes).toBeLessThanOrEqual(100_000);
+		expect(JSON.stringify(result)).toContain("provider request budget");
+	});
+
+	it("does not mutate the original structured tool results", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 10_000,
+			maxTotalTextBytes: 20_000,
+		});
+		const messages: Message[] = [
+			toolUseMessage("call_1", "run_commands", { commands: ["cat a.log"] }),
+			structuredToolResultMessage("call_1", "run_commands", [
+				{
+					query: "cat a.log",
+					result: hugeText(50_000),
+					success: true,
+				},
+			]),
+			toolUseMessage("call_2", "run_commands", { commands: ["cat b.log"] }),
+			structuredToolResultMessage("call_2", "run_commands", [
+				{
+					query: "cat b.log",
+					result: hugeText(50_000),
+					success: true,
+				},
+			]),
+		];
+		const snapshot = structuredClone(messages);
+
+		const result = builder.buildForApi(messages);
+
+		expect(messages).toEqual(snapshot);
+		expect(JSON.stringify(result)).not.toContain(MIDDLE_SENTINEL);
+	});
+
+	it("keeps huge nested strings out of provider-formatted AI SDK messages", () => {
+		const builder = new MessageBuilder();
+		const messages: Message[] = [
+			toolUseMessage("call_1", "run_commands", {
+				commands: ["cat big.log"],
+			}),
+			structuredToolResultMessage("call_1", "run_commands", [
+				{
+					query: "cat big.log",
+					result: hugeText(),
+					success: true,
+				},
+			]),
+		];
+
+		const built = builder.buildForApi(messages);
+		const agentMessages = messagesToAgentMessages(built);
+		const aiSdkMessages = formatMessagesForAiSdk(
+			undefined,
+			agentMessages.map(({ role, content }) => ({
+				role,
+				content,
+			})) as unknown as AiSdkFormatterMessage[],
+		);
+		const serialized = JSON.stringify(aiSdkMessages);
+
+		expect(serialized.length).toBeLessThan(130_000);
+		expect(serialized).not.toContain(MIDDLE_SENTINEL);
+		expect(serialized).toContain(HEAD_MARKER);
+		expect(serialized).toContain(TAIL_MARKER);
+	});
+});
+
+/**
+ * Coverage for default-on truncation (no tool allowlist), tool_use input
+ * budget accounting, tool_result.name fallback, and binary block protection.
+ */
+describe("MessageBuilder default-on truncation", () => {
+	it("truncates huge results from MCP/custom tools that were never on the old allowlist", () => {
+		const builder = new MessageBuilder({ maxToolResultChars: 100 });
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "mcp__github__get_pull_request_diff",
+						input: { pull_number: 42 },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "mcp__github__get_pull_request_diff",
+						content: "d".repeat(5_000),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+		if (block?.type !== "tool_result" || typeof block.content !== "string") {
+			throw new Error("expected tool_result with string content");
+		}
+		expect(block.content.length).toBeLessThanOrEqual(100);
+		expect(block.content).toContain("...[truncated");
+	});
+
+	it("collects non-builtin tool results as aggregate budget candidates", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 20_000,
+		});
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "my_custom_dump_tool",
+						input: {},
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "my_custom_dump_tool",
+						content: [{ type: "text", text: "e".repeat(30_000) }],
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+		if (block?.type !== "tool_result" || !Array.isArray(block.content)) {
+			throw new Error("expected tool_result with array content");
+		}
+		const entry = block.content[0];
+		if (entry.type !== "text") {
+			throw new Error("expected text entry");
+		}
+		expect(Buffer.byteLength(entry.text, "utf8")).toBeLessThanOrEqual(20_000);
+		expect(entry.text).toContain("provider request budget");
+	});
+
+	it("counts tool_use input strings toward the aggregate budget", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 20_000,
+		});
+		const hugeInput = "f".repeat(15_000);
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "run_commands",
+						input: { commands: [hugeInput] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "run_commands",
+						content: "g".repeat(10_000),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		// Result alone (10k) is under the 20k budget; only counting the 15k
+		// tool_use input pushes the total over and forces budget truncation.
+		const resultBlock = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+		if (
+			resultBlock?.type !== "tool_result" ||
+			typeof resultBlock.content !== "string"
+		) {
+			throw new Error("expected tool_result with string content");
+		}
+		expect(resultBlock.content).toContain("provider request budget");
+
+		// Tool results absorb the overflow first, so the model-generated
+		// arguments stay byte-identical whenever results alone can cover it.
+		const useBlock = Array.isArray(result[0].content)
+			? result[0].content[0]
+			: undefined;
+		if (useBlock?.type !== "tool_use") {
+			throw new Error("expected tool_use");
+		}
+		expect(useBlock.input).toEqual({ commands: [hugeInput] });
+	});
+
+	it("truncates oversized tool_use inputs as a last resort when results cannot absorb the overflow", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 50_000,
+			maxTotalTextBytes: 20_000,
+		});
+		const hugeInput = "f".repeat(40_000);
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "run_commands",
+						input: { commands: [hugeInput] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "run_commands",
+						content: "g".repeat(10_000),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+
+		// The result shrinks to the floor first, but that alone cannot bring
+		// 50k total under the 20k budget, so the input is truncated too.
+		const useBlock = Array.isArray(result[0].content)
+			? result[0].content[0]
+			: undefined;
+		if (useBlock?.type !== "tool_use") {
+			throw new Error("expected tool_use");
+		}
+		const builtInput = (useBlock.input as { commands: string[] }).commands[0];
+		expect(builtInput).toContain("provider request budget");
+		expect(Buffer.byteLength(builtInput, "utf8")).toBeLessThan(40_000);
+
+		const totalBytes = JSON.stringify(result).length;
+		expect(totalBytes).toBeLessThan(25_000);
+
+		// Original history must stay untouched.
+		const originalUse = Array.isArray(messages[0].content)
+			? messages[0].content[0]
+			: undefined;
+		if (originalUse?.type !== "tool_use") {
+			throw new Error("expected tool_use");
+		}
+		expect((originalUse.input as { commands: string[] }).commands[0]).toBe(
+			hugeInput,
+		);
+	});
+
+	it("rewrites outdated reads on orphaned tool results via the name fallback", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 0 });
+		const oldRead = JSON.stringify([
+			{ path: "/tmp/a.txt", result: "OLD CONTENT" },
+		]);
+		const messages: Message[] = [
+			{
+				role: "user",
+				// Orphaned result: its tool_use was dropped (e.g. compaction), so
+				// only the name field identifies it as a read tool.
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_orphan",
+						name: "read_files",
+						content: oldRead,
+					},
+				],
+			},
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_2",
+						name: "read_files",
+						input: { file_paths: ["/tmp/a.txt"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_2",
+						name: "read_files",
+						content: JSON.stringify([
+							{ path: "/tmp/a.txt", result: "NEW CONTENT" },
+						]),
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const orphan = Array.isArray(result[0].content)
+			? result[0].content[0]
+			: undefined;
+		if (orphan?.type !== "tool_result") {
+			throw new Error("expected tool_result");
+		}
+		expect(JSON.stringify(orphan.content)).toContain(
+			"[outdated - see the latest file content]",
+		);
+		expect(JSON.stringify(orphan.content)).not.toContain("OLD CONTENT");
+		expect(JSON.stringify(result[2].content)).toContain("NEW CONTENT");
+	});
+
+	it("truncates unsupported document data blocks nested in structured results", () => {
+		const builder = new MessageBuilder({
+			maxToolResultChars: 100,
+			maxTotalTextBytes: 1_000,
+		});
+		const pdfData = "p".repeat(5_000);
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "fetch_web_content",
+						input: { url: "https://example.com/report.pdf" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "fetch_web_content",
+						content: [
+							{
+								query: "https://example.com/report.pdf",
+								result: [
+									{
+										type: "document",
+										data: pdfData,
+										mediaType: "application/pdf",
+									},
+									{ type: "text", text: "h".repeat(5_000) },
+								],
+								success: true,
+							},
+						] as unknown as ToolResultContent["content"],
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+		if (block?.type !== "tool_result" || !Array.isArray(block.content)) {
+			throw new Error("expected tool_result with array content");
+		}
+		const entry = block.content[0] as unknown as {
+			result: Array<{ type: string; data?: string; text?: string }>;
+		};
+		const doc = entry.result.find((item) => item.type === "document");
+		const text = entry.result.find((item) => item.type === "text");
+		expect(doc?.data).not.toBe(pdfData);
+		expect(doc?.data?.length).toBeLessThanOrEqual(100);
+		expect(doc?.data).toContain("...[truncated");
+		expect(text?.text).toContain("...[truncated");
+
+		const formattedPayload = JSON.stringify(
+			formatMessagesForAiSdk(
+				undefined,
+				messagesToAgentMessages(result).map(({ role, content }) => ({
+					role,
+					content,
+				})) as unknown as AiSdkFormatterMessage[],
+			),
+		);
+		expect(formattedPayload).not.toContain(pdfData);
+		expect(formattedPayload.length).toBeLessThan(1_000);
+	});
+
+	it("preserves nested image data that the formatter hoists natively", () => {
+		const builder = new MessageBuilder({ maxToolResultChars: 100 });
+		const imageData = "i".repeat(5_000);
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "read_files",
+						input: { file_paths: ["/tmp/image.png"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "read_files",
+						content: [
+							{
+								query: "/tmp/image.png",
+								result: [
+									{ type: "text", text: "Successfully read image" },
+									{
+										type: "image",
+										data: imageData,
+										mediaType: "image/png",
+									},
+									{ type: "text", text: "h".repeat(5_000) },
+								],
+								success: true,
+							},
+						] as unknown as ToolResultContent["content"],
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+		if (block?.type !== "tool_result" || !Array.isArray(block.content)) {
+			throw new Error("expected tool_result with array content");
+		}
+		const entry = block.content[0] as unknown as {
+			result: Array<{ type: string; data?: string; text?: string }>;
+		};
+		const image = entry.result.find((item) => item.type === "image");
+		const longText = entry.result.find(
+			(item) => item.type === "text" && item.text?.startsWith("h"),
+		);
+		expect(image?.data).toBe(imageData);
+		expect(longText?.text).toContain("...[truncated");
+
+		const formattedPayload = JSON.stringify(
+			formatMessagesForAiSdk(
+				undefined,
+				messagesToAgentMessages(result).map(({ role, content }) => ({
+					role,
+					content,
+				})) as unknown as AiSdkFormatterMessage[],
+			),
+		);
+		expect(formattedPayload).toContain('"type":"image-data"');
+		expect(formattedPayload).toContain(imageData);
+	});
+
+	it("truncates textual {type, data} payloads that are not known binary blocks", () => {
+		const builder = new MessageBuilder({ maxToolResultChars: 100 });
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool_1",
+						name: "dump_server_logs",
+						input: {},
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool_1",
+						name: "dump_server_logs",
+						content: [
+							{
+								query: "logs",
+								result: [{ type: "log", data: "x".repeat(5_000) }],
+								success: true,
+							},
+						] as unknown as ToolResultContent["content"],
+					},
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const block = Array.isArray(result[1].content)
+			? result[1].content[0]
+			: undefined;
+		if (block?.type !== "tool_result" || !Array.isArray(block.content)) {
+			throw new Error("expected tool_result with array content");
+		}
+		const entry = block.content[0] as unknown as {
+			result: Array<{ type: string; data: string }>;
+		};
+		const log = entry.result.find((item) => item.type === "log");
+		if (!log) {
+			throw new Error("expected log entry");
+		}
+		expect(log.data.length).toBeLessThanOrEqual(100);
+		expect(log.data).toContain("...[truncated");
+	});
+
+	it("caps user file attachments separately from tool results", () => {
+		const builder = new MessageBuilder();
+		const underFileCap = "a".repeat(20_000);
+		const overFileCap = "b".repeat(60_000);
+		const messages: Message[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "file", path: "/tmp/notes.md", content: underFileCap },
+					{ type: "file", path: "/tmp/dump.log", content: overFileCap },
+					{ type: "text", text: "summarize these" },
+				],
+			},
+		];
+
+		const result = builder.buildForApi(messages);
+		const content = result[0].content;
+		if (!Array.isArray(content)) {
+			throw new Error("expected array content");
+		}
+		const [small, large] = content;
+		if (small?.type !== "file" || large?.type !== "file") {
+			throw new Error("expected file blocks");
+		}
+		// 20k would be mutilated under the 8k tool-result cap; attachments get
+		// the dedicated file cap instead.
+		expect(small.content).toBe(underFileCap);
+		expect(large.content.length).toBeLessThanOrEqual(
+			DEFAULT_MAX_FILE_CONTENT_CHARS,
+		);
+		expect(large.content).toContain("...[truncated");
+	});
+});
+
+/** Mimics the runtime provider-request path, which rebuilds fresh Message
+ * objects every request via the agent-message codec. */
+function codecRoundTrip(messages: Message[]): Message[] {
+	return agentMessagesToMessages(messagesToAgentMessages(messages));
+}
+
+const SMALL_CONTENT = (v: number) => `export const x = ${v};\n`.repeat(40); // ~1KB
+const LARGE_CONTENT = (v: number) => `export const x = ${v};\n`.repeat(7_000); // ~140KB (> 64KB threshold)
+
+function readToolUse(id: string, path = "src/a.ts"): Message {
+	return {
+		role: "assistant",
+		content: [
+			{ type: "text", text: `reading ${path} (${id})` },
+			{
+				type: "tool_use",
+				id,
+				name: "read_files",
+				input: { files: [{ path }] },
+			},
+		],
+	};
+}
+
+function readToolResult(
+	id: string,
+	content: string,
+	path = "src/a.ts",
+): Message {
+	return {
+		role: "user",
+		content: [
+			{
+				type: "tool_result",
+				tool_use_id: id,
+				name: "read_files",
+				content: JSON.stringify([{ path, result: content }]),
+			},
+		],
+	};
+}
+
+function structuredReadToolResult(
+	id: string,
+	content: unknown,
+	path = "src/a.ts",
+): Message {
+	return {
+		role: "user",
+		content: [
+			{
+				type: "tool_result",
+				tool_use_id: id,
+				name: "read_files",
+				// Mirrors the real default-tool shape emitted by createReadFilesTool:
+				// ToolOperationResult[] entries are stored directly, without a
+				// text/image/file `type` discriminator.
+				content: [
+					{
+						query: path,
+						result: content,
+						success: true,
+					},
+				] as unknown as ToolResultContent["content"],
+			},
+		],
+	};
+}
+
+function serializedBlockAt(result: Message[], index: number): string {
+	return JSON.stringify(result[index]);
+}
+
+describe("MessageBuilder outdated-read rewrite batching (prefix-cache stability)", () => {
+	it("defers small outdated rewrites so request N stays a byte-stable prefix of request N+1", () => {
+		const builder = new MessageBuilder();
+		const base: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", SMALL_CONTENT(1)),
+		];
+		const reqA = builder.buildForApi(base);
+		const firstResultA = serializedBlockAt(reqA, 2);
+		expect(firstResultA).toContain("export const x = 1;");
+
+		// Re-read the same file: ~1KB reclaimable, below the batch threshold.
+		const withReread: Message[] = [
+			...base,
+			readToolUse("t2"),
+			readToolResult("t2", SMALL_CONTENT(2)),
+		];
+		const reqB = builder.buildForApi(withReread);
+
+		// The earlier read result must be byte-identical: no mid-transcript
+		// mutation, so the provider prefix cache stays valid.
+		expect(serializedBlockAt(reqB, 2)).toEqual(firstResultA);
+		expect(serializedBlockAt(reqB, 2)).not.toContain("outdated");
+	});
+
+	it("commits batched rewrites once reclaimable bytes cross the threshold", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const base: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		];
+		// First build: t1 is outdated (~8KB provider-bound reclaimable),
+		// so the rewrite commits immediately.
+		const reqA = builder.buildForApi(base);
+		expect(serializedBlockAt(reqA, 2)).toContain(
+			"outdated - see the latest file content",
+		);
+		expect(serializedBlockAt(reqA, 2)).not.toContain("export const x = 1;");
+		// Latest read is untouched.
+		expect(serializedBlockAt(reqA, 4)).toContain("export const x = 2;");
+	});
+
+	it("keeps committed rewrites sticky across subsequent builds", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const base: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		];
+		const reqA = builder.buildForApi(base);
+		const rewrittenA = serializedBlockAt(reqA, 2);
+		expect(rewrittenA).toContain("outdated");
+
+		// Append unrelated activity; the committed rewrite must reproduce
+		// byte-identically so the prefix remains stable.
+		const extended: Message[] = [
+			...base,
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "running tests" },
+					{
+						type: "tool_use",
+						id: "t3",
+						name: "bash",
+						input: { command: "npm test" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "t3",
+						name: "bash",
+						content: "tests passed",
+					},
+				],
+			},
+		];
+		const reqB = builder.buildForApi(extended);
+		expect(serializedBlockAt(reqB, 2)).toEqual(rewrittenA);
+	});
+
+	it("counts multi-file read results per outdated locator, not per whole block", () => {
+		// One read_files call returns files A, B, C (~850 bytes each entry).
+		// Only A is later re-read, so the reclaimable amount is ~850 bytes —
+		// NOT the ~2.5KB whole-block size. With a 2KB threshold, a whole-block
+		// (over)count would commit immediately; correct per-locator attribution
+		// must defer.
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 2_000 });
+		const multiReadUse: Message = {
+			role: "assistant",
+			content: [
+				{ type: "text", text: "reading three files" },
+				{
+					type: "tool_use",
+					id: "t1",
+					name: "read_files",
+					input: {
+						files: [
+							{ path: "src/a.ts" },
+							{ path: "src/b.ts" },
+							{ path: "src/c.ts" },
+						],
+					},
+				},
+			],
+		};
+		const multiReadResult: Message = {
+			role: "user",
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: "t1",
+					name: "read_files",
+					content: JSON.stringify([
+						{ path: "src/a.ts", result: SMALL_CONTENT(1) },
+						{ path: "src/b.ts", result: SMALL_CONTENT(2) },
+						{ path: "src/c.ts", result: SMALL_CONTENT(3) },
+					]),
+				},
+			],
+		};
+		const messages: Message[] = [
+			{ role: "user", content: "task" },
+			multiReadUse,
+			multiReadResult,
+			readToolUse("t2", "src/a.ts"),
+			readToolResult("t2", SMALL_CONTENT(4), "src/a.ts"),
+		];
+		const deferred = builder.buildForApi(messages);
+		// Only ~850 bytes (entry A) is reclaimable: must stay below the 2KB
+		// threshold and remain pending. Whole-block counting (~2.5KB) would
+		// wrongly commit here.
+		expect(JSON.stringify(deferred)).not.toContain("outdated");
+
+		// Re-read B as well: reclaimable is now A+B (~1.7KB)... still below.
+		const withB: Message[] = [
+			...messages,
+			readToolUse("t3", "src/b.ts"),
+			readToolResult("t3", SMALL_CONTENT(5), "src/b.ts"),
+		];
+		expect(JSON.stringify(builder.buildForApi(withB))).not.toContain(
+			"outdated",
+		);
+
+		// Re-read C too: A+B+C (~2.5KB) crosses the 2KB threshold; all three
+		// stale entries in the multi-read result commit together.
+		const withC: Message[] = [
+			...withB,
+			readToolUse("t4", "src/c.ts"),
+			readToolResult("t4", SMALL_CONTENT(6), "src/c.ts"),
+		];
+		const committed = builder.buildForApi(withC);
+		const multiBlock = JSON.stringify(committed[2]);
+		expect(multiBlock).toContain("outdated - see the latest file content");
+		expect(multiBlock).not.toContain("export const x = 1;");
+		expect(multiBlock).not.toContain("export const x = 2;");
+		expect(multiBlock).not.toContain("export const x = 3;");
+	});
+
+	it("uses provider-bound stale bytes after per-result truncation", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 20_000 });
+		const messages: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		];
+
+		const result = builder.buildForApi(messages);
+
+		// Raw t1 history is ~140KB, but the provider-bound stale entry is capped
+		// near 8KB before threshold accounting. A 20KB threshold must defer.
+		expect(JSON.stringify(result[2])).not.toContain("outdated");
+		expect(JSON.stringify(result[2])).toContain("...[truncated");
+	});
+
+	it("clears committed rewrite state on explicit conversation reset", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 0 });
+		const firstConversation: Message[] = [
+			{ role: "user", content: "task one" },
+			readToolUse("t1"),
+			readToolResult("t1", SMALL_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", SMALL_CONTENT(2)),
+		];
+		expect(JSON.stringify(builder.buildForApi(firstConversation)[2])).toContain(
+			"outdated",
+		);
+
+		builder.resetConversationState();
+		const restoredConversationWithReusedId: Message[] = [
+			{ role: "user", content: "task two" },
+			readToolUse("t1"),
+			readToolResult("t1", SMALL_CONTENT(3)),
+		];
+		const restored = builder.buildForApi(restoredConversationWithReusedId);
+
+		expect(JSON.stringify(restored[2])).not.toContain("outdated");
+		expect(JSON.stringify(restored[2])).toContain("export const x = 3;");
+	});
+
+	it("keeps batching state when the runtime rebuilds fresh message objects per request", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const history: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1", "src/big.ts"),
+			readToolResult("t1", LARGE_CONTENT(1), "src/big.ts"),
+			readToolUse("t2", "src/big.ts"),
+			readToolResult("t2", LARGE_CONTENT(2), "src/big.ts"),
+		];
+		// Request A: t1 (~8KB provider-bound stale) crosses the test threshold and commits.
+		const reqA = builder.buildForApi(codecRoundTrip(history));
+		expect(JSON.stringify(reqA[2])).toContain("outdated");
+
+		// Request B: a ~1KB re-read makes t3 newly stale. The committed big read
+		// must NOT be recounted as pending, so t3 stays deferred.
+		history.push(
+			readToolUse("t3", "src/small.ts"),
+			readToolResult("t3", SMALL_CONTENT(1), "src/small.ts"),
+			readToolUse("t4", "src/small.ts"),
+			readToolResult("t4", SMALL_CONTENT(2), "src/small.ts"),
+		);
+		const reqB = builder.buildForApi(codecRoundTrip(history));
+		expect(JSON.stringify(reqB[2])).toContain("outdated"); // t1 sticky
+		expect(JSON.stringify(reqB[6])).not.toContain("outdated"); // t3 deferred
+		expect(JSON.stringify(reqB[6])).toContain("export const x = 1;");
+	});
+
+	it("restores full content after rollback even with fresh message objects", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const t1Only: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+		];
+		const withReread: Message[] = [
+			...t1Only,
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		];
+		const reqA = builder.buildForApi(codecRoundTrip(withReread));
+		expect(JSON.stringify(reqA[2])).toContain("outdated");
+
+		const reqB = builder.buildForApi(codecRoundTrip(t1Only));
+		expect(JSON.stringify(reqB[2])).not.toContain("outdated");
+		expect(JSON.stringify(reqB[2])).toContain("export const x = 1;");
+	});
+
+	it("keeps committed rewrites applied when compaction drops the paired tool_use", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const withReread: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		];
+		const reqA = builder.buildForApi(codecRoundTrip(withReread));
+		const rewrittenA = JSON.stringify(reqA[2]);
+		expect(rewrittenA).toContain("outdated");
+
+		// Compaction drops t1's tool_use but keeps the stale result, and the
+		// runtime delivers fresh objects so the name index rebuilds without
+		// t1. The rewrite must stay applied (via tool_result.name) so the
+		// suffix after the orphaned block is not mutated back to full content.
+		const compacted: Message[] = [
+			withReread[0],
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "reading src/a.ts (t1)" }],
+			},
+			...withReread.slice(2),
+		];
+		const reqB = builder.buildForApi(codecRoundTrip(compacted));
+		expect(JSON.stringify(reqB[2])).toContain("outdated");
+		expect(JSON.stringify(reqB[2])).not.toContain("export const x = 1;");
+	});
+
+	it("counts stale image payload bytes toward the batch threshold", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 2_000 });
+		const imageReadResult: Message = {
+			role: "user",
+			content: [
+				{
+					type: "tool_result",
+					tool_use_id: "t1",
+					name: "read_files",
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify([
+								{ path: "img/shot.png", result: "Successfully read image" },
+							]),
+						},
+						{ type: "image", data: "A".repeat(4_000), mediaType: "image/png" },
+					],
+				},
+			],
+		};
+		const messages: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1", "img/shot.png"),
+			imageReadResult,
+			readToolUse("t2", "img/shot.png"),
+			readToolResult("t2", SMALL_CONTENT(1), "img/shot.png"),
+		];
+		// Text marker alone is ~70 bytes — below the 2KB threshold. The 4KB
+		// base64 payload must count, committing the batch.
+		const result = builder.buildForApi(messages);
+		const block = JSON.stringify(result[2]);
+		expect(block).toContain("outdated");
+		expect(block).not.toContain("AAAA");
+	});
+
+	it("batches and rewrites structured ToolOperationResult read_files entries", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const messages: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			structuredReadToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			structuredReadToolResult("t2", LARGE_CONTENT(2)),
+		];
+
+		const result = builder.buildForApi(messages);
+		const firstRead = JSON.stringify(result[2]);
+		const latestRead = JSON.stringify(result[4]);
+
+		expect(firstRead).toContain("outdated - see the latest file content");
+		expect(firstRead).toContain('"query":"src/a.ts"');
+		expect(firstRead).toContain('"success":true');
+		expect(firstRead).not.toContain("export const x = 1;");
+		expect(latestRead).toContain("export const x = 2;");
+	});
+
+	it("keeps structured ToolOperationResult batching stable across codec round-trips", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 7_000 });
+		const history: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1", "src/big.ts"),
+			structuredReadToolResult("t1", LARGE_CONTENT(1), "src/big.ts"),
+			readToolUse("t2", "src/big.ts"),
+			structuredReadToolResult("t2", LARGE_CONTENT(2), "src/big.ts"),
+		];
+
+		const reqA = builder.buildForApi(codecRoundTrip(history));
+		expect(JSON.stringify(reqA[2])).toContain("outdated");
+
+		history.push(
+			readToolUse("t3", "src/small.ts"),
+			structuredReadToolResult("t3", SMALL_CONTENT(1), "src/small.ts"),
+			readToolUse("t4", "src/small.ts"),
+			structuredReadToolResult("t4", SMALL_CONTENT(2), "src/small.ts"),
+		);
+		const reqB = builder.buildForApi(codecRoundTrip(history));
+
+		expect(JSON.stringify(reqB[2])).toContain("outdated");
+		expect(JSON.stringify(reqB[6])).not.toContain("outdated");
+		expect(JSON.stringify(reqB[6])).toContain("export const x = 1;");
+	});
+
+	it("rewrites eagerly when threshold is 0 (legacy behavior)", () => {
+		const builder = new MessageBuilder({ minOutdatedRewriteBytes: 0 });
+		const messages: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", SMALL_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", SMALL_CONTENT(2)),
+		];
+		const result = builder.buildForApi(messages);
+		expect(serializedBlockAt(result, 2)).toContain("outdated");
+	});
+
+	it("does not rewrite outdated reads when threshold is Infinity", () => {
+		const builder = new MessageBuilder({
+			minOutdatedRewriteBytes: Number.POSITIVE_INFINITY,
+		});
+		const messages: Message[] = [
+			{ role: "user", content: "task" },
+			readToolUse("t1"),
+			readToolResult("t1", LARGE_CONTENT(1)),
+			readToolUse("t2"),
+			readToolResult("t2", LARGE_CONTENT(2)),
+		];
+
+		const result = builder.buildForApi(messages);
+		expect(serializedBlockAt(result, 2)).not.toContain("outdated");
+		expect(serializedBlockAt(result, 2)).toContain("export const x = 1;");
+	});
+});
diff --git a/sdk/packages/core/src/session/services/message-builder.ts b/sdk/packages/core/src/session/services/message-builder.ts
new file mode 100644
index 0000000..163ae2a
--- /dev/null
+++ b/sdk/packages/core/src/session/services/message-builder.ts
@@ -0,0 +1,1727 @@
+/**
+ * API-safe message builder for provider payloads.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/context/message-builder.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `MessageBuilder`.
+ *
+ * Walks the conversation to produce provider-ready messages, handling
+ * tool-result truncation and outdated-file-content rewrite for compaction.
+ * Per-instance caches make this host state.
+ */
+
+import {
+	type ContentBlock,
+	createMediaBudgetState,
+	IMAGE_OMITTED_PLACEHOLDER,
+	type ImageContent,
+	type MediaBudgetOptions,
+	type MediaBudgetState,
+	type Message,
+	normalizeUserInput,
+	type ResolvedMediaBudget,
+	resolveMediaBudget,
+	type TextContent,
+	type ToolResultContent,
+	validateAndReserveImageMedia,
+} from "@cline/shared";
+
+export const DEFAULT_MAX_TOOL_RESULT_CHARS = 8_000;
+export const DEFAULT_MAX_FILE_CONTENT_CHARS = 50_000;
+// The aggregate budget intentionally stays far above what the per-result cap
+// usually produces: budget truncation rewrites bytes mid-transcript, which
+// invalidates provider prefix caches from the first rewritten block onward,
+// so it must remain a rare overflow valve rather than the steady state.
+export const DEFAULT_MAX_TOTAL_TEXT_BYTES = 6_000_000;
+export const DEFAULT_MAX_ASSISTANT_TEXT_CHARS = 200_000;
+export const DEFAULT_MAX_ASSISTANT_TOOL_MARKUP_CHARS = 12_000;
+// Batch stale-read rewrites to avoid breaking provider prefix caches on every re-read.
+// 64KB is roughly 8 provider-capped read results; set to 0 for eager rewriting.
+export const DEFAULT_MIN_OUTDATED_REWRITE_BYTES = 65_536;
+const MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES = 2_000;
+const MIN_TOTAL_BUDGET_ASSISTANT_TEXT_BYTES = 40_000;
+const REPEATED_TOOL_CALL_MARKUP_THRESHOLD = 8;
+export const MESSAGE_BUILDER_LIMIT_ENV = {
+	maxToolResultChars: "CLINE_MESSAGE_BUILDER_MAX_TOOL_RESULT_CHARS",
+	maxTotalTextBytes: "CLINE_MESSAGE_BUILDER_MAX_TOTAL_TEXT_BYTES",
+	minOutdatedRewriteBytes: "CLINE_MESSAGE_BUILDER_MIN_OUTDATED_REWRITE_BYTES",
+} as const;
+const READ_TOOL_NAMES = new Set(["read", "read_files"]);
+const OUTDATED_FILE_CONTENT = "[outdated - see the latest file content]";
+const MISSING_TOOL_RESULT_TEXT =
+	"Tool execution was interrupted before a result was produced.";
+const TRUNCATE_MARKER_DEFAULT = (n: number) =>
+	`\n\n...[truncated ${n} chars]...\n\n`;
+const TRUNCATE_MARKER_BUDGET = (n: number) =>
+	`\n\n...[truncated ${n} chars to fit provider request budget]...\n\n`;
+const TRUNCATE_ASSISTANT_TEXT_MARKER = (n: number) =>
+	`\n\n...[assistant text truncated: omitted ${n} chars]...\n\n`;
+const TRUNCATE_ASSISTANT_TEXT_BUDGET_MARKER = (n: number) =>
+	`\n\n...[assistant text truncated: omitted ${n} chars to fit provider request budget]...\n\n`;
+const TRUNCATE_ASSISTANT_TOOL_MARKUP_MARKER = (n: number) =>
+	`\n\n...[assistant text truncated: omitted ${n} chars due to repeated tool-call markup]...\n\n`;
+
+interface ReadLocator {
+	path: string;
+	startLine: number | null;
+	endLine: number | null;
+}
+
+interface TruncationCandidate {
+	byteLength: number;
+	minBytes: number;
+	makeMarker: (removed: number) => string;
+	get(): string;
+	set(value: string): void;
+}
+
+export interface MessageBuilderOptions {
+	maxToolResultChars?: number;
+	maxFileContentChars?: number;
+	maxTotalTextBytes?: number;
+	mediaBudget?: MediaBudgetOptions;
+	maxAssistantTextChars?: number;
+	maxAssistantToolMarkupChars?: number;
+	minOutdatedRewriteBytes?: number;
+}
+
+export function getMessageBuilderOptionsFromEnv(
+	env: Record<string, string | undefined> = process.env,
+): MessageBuilderOptions {
+	// Size caps reject zero/negative overrides; stale-read batching accepts 0
+	// for eager mode and "disable"/"Infinity" for rollback.
+	return {
+		maxToolResultChars: parsePositiveIntegerEnv(
+			env[MESSAGE_BUILDER_LIMIT_ENV.maxToolResultChars],
+		),
+		maxTotalTextBytes: parsePositiveIntegerEnv(
+			env[MESSAGE_BUILDER_LIMIT_ENV.maxTotalTextBytes],
+		),
+		minOutdatedRewriteBytes: parseNonNegativeLimitEnv(
+			env[MESSAGE_BUILDER_LIMIT_ENV.minOutdatedRewriteBytes],
+		),
+	};
+}
+
+/**
+ * Builds an API-safe message copy without mutating original conversation history.
+ */
+export class MessageBuilder {
+	private indexedMessageCount = 0;
+	private indexedTailRef: Message | undefined;
+	private readonly toolNameByIdCache = new Map<string, string>();
+	private readonly readLocatorsByToolUseIdCache = new Map<
+		string,
+		ReadLocator[]
+	>();
+	private readonly latestReadToolUseByLocatorCache = new Map<string, string>();
+	private readonly latestFullContentOwnerByPathCache = new Map<
+		string,
+		string
+	>();
+	private readResultLocatorCache = new WeakMap<object, ReadLocator[]>();
+	private readonly maxToolResultChars: number;
+	private readonly maxFileContentChars: number;
+	private readonly maxTotalTextBytes: number;
+	private readonly mediaBudget: MediaBudgetOptions;
+	private readonly maxAssistantTextChars: number;
+	private readonly maxAssistantToolMarkupChars: number;
+	private readonly minOutdatedRewriteBytes: number;
+	// Sticky rewrite decisions. Kept across resetIndexes because production
+	// rebuilds fresh Message objects; entries are revalidated/pruned per build.
+	private readonly committedOutdatedRewrites = new Map<string, Set<string>>();
+
+	constructor(options: MessageBuilderOptions = {}) {
+		this.maxToolResultChars = normalizePositiveLimit(
+			options.maxToolResultChars,
+			DEFAULT_MAX_TOOL_RESULT_CHARS,
+		);
+		this.maxFileContentChars = normalizePositiveLimit(
+			options.maxFileContentChars,
+			DEFAULT_MAX_FILE_CONTENT_CHARS,
+		);
+		this.maxTotalTextBytes = normalizePositiveLimit(
+			options.maxTotalTextBytes,
+			DEFAULT_MAX_TOTAL_TEXT_BYTES,
+		);
+		this.mediaBudget = options.mediaBudget ?? {};
+		this.maxAssistantTextChars = normalizePositiveLimit(
+			options.maxAssistantTextChars,
+			DEFAULT_MAX_ASSISTANT_TEXT_CHARS,
+		);
+		this.maxAssistantToolMarkupChars = normalizePositiveLimit(
+			options.maxAssistantToolMarkupChars,
+			DEFAULT_MAX_ASSISTANT_TOOL_MARKUP_CHARS,
+		);
+		this.minOutdatedRewriteBytes = normalizeNonNegativeLimit(
+			options.minOutdatedRewriteBytes,
+			DEFAULT_MIN_OUTDATED_REWRITE_BYTES,
+		);
+	}
+
+	resetConversationState(): void {
+		this.resetIndexes();
+		this.committedOutdatedRewrites.clear();
+	}
+
+	buildForApi(messages: Message[]): Message[] {
+		this.reindex(messages);
+		this.commitOutdatedRewrites(messages);
+		const repairedMessages = this.addMissingToolResults(messages);
+
+		const prepared = repairedMessages.map((message) => {
+			if (!Array.isArray(message.content)) {
+				if (message.role === "user" && typeof message.content === "string") {
+					const normalized = normalizeUserInput(message.content);
+					if (normalized !== message.content) {
+						return { ...message, content: normalized };
+					}
+				}
+				if (
+					message.role === "assistant" &&
+					typeof message.content === "string"
+				) {
+					const truncated = this.truncateAssistantText(message.content);
+					if (truncated !== message.content) {
+						return { ...message, content: truncated };
+					}
+				}
+				return message;
+			}
+
+			let changed = false;
+			const content = message.content.map((block) => {
+				const next = this.transformBlock(block, message.role);
+				if (next !== block) {
+					changed = true;
+				}
+				return next;
+			});
+
+			return changed ? { ...message, content } : message;
+		});
+
+		const mediaLimited = this.applyMediaBudget(prepared);
+		return this.truncateToTotalTextBudget(mediaLimited);
+	}
+
+	private transformBlock(
+		block: ContentBlock,
+		role: Message["role"],
+	): ContentBlock {
+		if (
+			role === "user" &&
+			block.type === "text" &&
+			typeof block.text === "string"
+		) {
+			const normalized = normalizeUserInput(block.text);
+			if (normalized !== block.text) {
+				return { ...block, text: normalized };
+			}
+			return block;
+		}
+
+		if (
+			role === "assistant" &&
+			block.type === "text" &&
+			typeof block.text === "string"
+		) {
+			const truncated = this.truncateAssistantText(block.text);
+			return truncated === block.text ? block : { ...block, text: truncated };
+		}
+
+		if (block.type === "file") {
+			// Top-level file blocks are user attachments, not tool output; they
+			// get their own (looser) cap so the aggressive tool-result limit
+			// does not mutilate content the user explicitly supplied.
+			const truncated = truncateMiddleByChars(
+				block.content,
+				this.maxFileContentChars,
+				TRUNCATE_MARKER_DEFAULT,
+			);
+			return truncated === block.content
+				? block
+				: { ...block, content: truncated };
+		}
+
+		if (block.type !== "tool_result") {
+			return block;
+		}
+
+		const toolName = this.resolveToolName(block);
+		let nextContent = block.content;
+
+		if (this.isReadTool(toolName) && block.is_error !== true) {
+			const committed = this.committedOutdatedRewrites.get(block.tool_use_id);
+			if (committed && committed.size > 0) {
+				const locators = this.getReadLocators(block);
+				const outdated = locators.filter(
+					(locator) =>
+						committed.has(this.toReadLocatorKey(locator)) &&
+						this.isOutdatedReadLocator(locator, block.tool_use_id),
+				);
+				if (outdated.length > 0) {
+					nextContent = this.replaceOutdatedReadContent(nextContent, outdated);
+				}
+			}
+		}
+
+		// Truncation is default-on for every tool result: MCP and custom SDK
+		// tools produce payloads just as large as the built-in ones, and any
+		// allowlist gate silently exempts them.
+		nextContent = this.truncateToolResultContent(nextContent);
+
+		return nextContent === block.content
+			? block
+			: { ...block, content: nextContent };
+	}
+
+	private reindex(messages: Message[]): void {
+		const tailUnchanged =
+			this.indexedMessageCount === 0 ||
+			(messages.length >= this.indexedMessageCount &&
+				messages[this.indexedMessageCount - 1] === this.indexedTailRef);
+		if (messages.length < this.indexedMessageCount || !tailUnchanged) {
+			this.resetIndexes();
+		}
+
+		for (let i = this.indexedMessageCount; i < messages.length; i++) {
+			const message = messages[i];
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+
+			for (let j = 0; j < message.content.length; j++) {
+				const block = message.content[j];
+				if (block.type === "file") {
+					this.latestFullContentOwnerByPathCache.set(
+						block.path,
+						`file:${i}:${j}`,
+					);
+				} else if (block.type === "tool_use") {
+					const normalizedName = block.name.toLowerCase();
+					this.toolNameByIdCache.set(block.id, normalizedName);
+					if (this.isReadTool(normalizedName)) {
+						const locators = this.extractLocatorsFromReadToolInput(block.input);
+						if (locators.length > 0) {
+							this.readLocatorsByToolUseIdCache.set(block.id, locators);
+						}
+					}
+				} else if (block.type === "tool_result") {
+					const toolName = this.resolveToolName(block);
+					if (!this.isReadTool(toolName) || block.is_error === true) {
+						continue;
+					}
+					const locators = this.getReadLocators(block);
+					for (const locator of locators) {
+						this.latestReadToolUseByLocatorCache.set(
+							this.toReadLocatorKey(locator),
+							block.tool_use_id,
+						);
+						if (this.isFullFileRead(locator)) {
+							this.latestFullContentOwnerByPathCache.set(
+								locator.path,
+								block.tool_use_id,
+							);
+						}
+					}
+				}
+			}
+		}
+		this.indexedMessageCount = messages.length;
+		this.indexedTailRef =
+			messages.length > 0 ? messages[messages.length - 1] : undefined;
+	}
+
+	/** Commits pending stale-read rewrites once reclaimable bytes cross the threshold. */
+	private commitOutdatedRewrites(messages: Message[]): void {
+		const pending = new Map<string, Set<string>>();
+		const seenToolUseIds = new Set<string>();
+		let pendingBytes = 0;
+
+		for (const message of messages) {
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type !== "tool_result" || block.is_error === true) {
+					continue;
+				}
+				const toolName = this.resolveToolName(block);
+				if (!this.isReadTool(toolName)) {
+					continue;
+				}
+				seenToolUseIds.add(block.tool_use_id);
+				const committed = this.committedOutdatedRewrites.get(block.tool_use_id);
+				const newKeys = new Set<string>();
+				const validKeys = new Set<string>();
+				for (const locator of this.getReadLocators(block)) {
+					const key = this.toReadLocatorKey(locator);
+					if (!this.isOutdatedReadLocator(locator, block.tool_use_id)) {
+						continue;
+					}
+					validKeys.add(key);
+					if (!committed?.has(key)) {
+						newKeys.add(key);
+					}
+				}
+				// Rollback can make a committed locator current again.
+				if (committed) {
+					for (const key of committed) {
+						if (!validKeys.has(key)) {
+							committed.delete(key);
+						}
+					}
+					if (committed.size === 0) {
+						this.committedOutdatedRewrites.delete(block.tool_use_id);
+					}
+				}
+				if (newKeys.size === 0) {
+					continue;
+				}
+				let keys = pending.get(block.tool_use_id);
+				if (!keys) {
+					keys = new Set<string>();
+					pending.set(block.tool_use_id, keys);
+				}
+				for (const key of newKeys) {
+					keys.add(key);
+				}
+				// Attribute provider-bound bytes to the newly-stale locators, not
+				// raw history bytes or the whole block.
+				pendingBytes += this.estimateOutdatedReclaimBytes(
+					block.content,
+					newKeys,
+				);
+			}
+		}
+
+		for (const toolUseId of this.committedOutdatedRewrites.keys()) {
+			if (!seenToolUseIds.has(toolUseId)) {
+				this.committedOutdatedRewrites.delete(toolUseId);
+			}
+		}
+
+		if (pending.size === 0 || pendingBytes < this.minOutdatedRewriteBytes) {
+			return;
+		}
+
+		for (const [toolUseId, keys] of pending) {
+			let committed = this.committedOutdatedRewrites.get(toolUseId);
+			if (!committed) {
+				committed = new Set<string>();
+				this.committedOutdatedRewrites.set(toolUseId, committed);
+			}
+			for (const key of keys) {
+				committed.add(key);
+			}
+		}
+	}
+
+	/** Estimates reclaimable bytes for stale locators inside one tool-result block. */
+	private estimateOutdatedReclaimBytes(
+		content: ToolResultContent["content"],
+		outdatedKeys: ReadonlySet<string>,
+	): number {
+		const allLocators = this.extractReadLocatorsFromToolResultContent(content);
+		const blockFullyOutdated =
+			allLocators.length > 0 &&
+			allLocators.every((locator) =>
+				outdatedKeys.has(this.toReadLocatorKey(locator)),
+			);
+
+		const attributeText = (text: string): number => {
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(text);
+			} catch {
+				return blockFullyOutdated || allLocators.length === 0
+					? utf8ByteLength(this.truncateMiddle(text))
+					: 0;
+			}
+			const entries = Array.isArray(parsed) ? parsed : [parsed];
+			let total = 0;
+			for (const entry of entries) {
+				const locator = this.extractLocatorFromResultEntry(entry);
+				if (locator && outdatedKeys.has(this.toReadLocatorKey(locator))) {
+					total += this.providerBoundEntryBytes(entry);
+				}
+			}
+			return total;
+		};
+
+		if (typeof content === "string") {
+			return attributeText(content);
+		}
+		// Image siblings are rewritten positionally, so count them positionally too.
+		const outdatedKeySet = new Set(outdatedKeys);
+		let outdatedImageCount = 0;
+		for (const entry of content) {
+			if (entry.type === "text") {
+				outdatedImageCount += this.countOutdatedImageEntries(
+					entry.text,
+					outdatedKeySet,
+				);
+			}
+		}
+		let total = 0;
+		for (const entry of content) {
+			if (entry.type === "text") {
+				total += attributeText(entry.text);
+			} else if (entry.type === "image") {
+				if (outdatedImageCount > 0) {
+					outdatedImageCount -= 1;
+					total += utf8ByteLength(entry.data);
+				}
+			} else if (isStructuredToolResultEntry(entry)) {
+				const locator = this.extractLocatorFromResultEntry(entry);
+				if (locator && outdatedKeys.has(this.toReadLocatorKey(locator))) {
+					total += this.providerBoundEntryBytes(entry);
+				}
+			} else if (entry.type === "file") {
+				if (
+					outdatedKeys.has(
+						this.toReadLocatorKey({
+							path: entry.path,
+							startLine: null,
+							endLine: null,
+						}),
+					)
+				) {
+					total += utf8ByteLength(this.truncateMiddle(entry.content));
+				}
+			}
+		}
+		return total;
+	}
+
+	private providerBoundEntryBytes(entry: unknown): number {
+		const providerBound = this.truncateNestedStrings(entry);
+		return utf8ByteLength(JSON.stringify(providerBound));
+	}
+
+	private addMissingToolResults(messages: Message[]): Message[] {
+		const existingToolResultIds = this.collectToolResultIds(messages);
+		const repaired: Message[] = [];
+		const pendingMissingToolCalls = new Map<string, string>();
+		let changed = false;
+
+		const flushMissing = () => {
+			if (pendingMissingToolCalls.size === 0) {
+				return;
+			}
+			pushRepairedMessage(
+				this.createMissingToolResultMessage(pendingMissingToolCalls),
+			);
+			pendingMissingToolCalls.clear();
+			changed = true;
+		};
+
+		const pushRepairedMessage = (message: Message) => {
+			const previous = repaired.at(-1);
+			if (this.shouldMergeUserAfterToolResults(previous, message)) {
+				repaired[repaired.length - 1] = {
+					...previous,
+					content: [
+						...previous.content,
+						...this.contentBlocksForUserMerge(message.content),
+					],
+				};
+				changed = true;
+				return;
+			}
+			repaired.push(message);
+		};
+
+		for (const message of messages) {
+			if (this.isToolResultOnlyMessage(message)) {
+				pushRepairedMessage(
+					this.appendMissingToolResults(message, pendingMissingToolCalls),
+				);
+				if (pendingMissingToolCalls.size > 0) {
+					pendingMissingToolCalls.clear();
+					changed = true;
+				}
+				continue;
+			}
+
+			if (Array.isArray(message.content)) {
+				const toolResults = message.content.filter(
+					(block): block is ToolResultContent => block.type === "tool_result",
+				);
+				const otherBlocks = message.content.filter(
+					(block) => block.type !== "tool_result",
+				);
+
+				if (toolResults.length > 0) {
+					const toolResultMessage = this.appendMissingToolResults(
+						{
+							...message,
+							role: "user",
+							content: toolResults,
+						},
+						pendingMissingToolCalls,
+					);
+					pushRepairedMessage(toolResultMessage);
+					if (pendingMissingToolCalls.size > 0) {
+						pendingMissingToolCalls.clear();
+					}
+					changed = true;
+				}
+
+				if (otherBlocks.length > 0 || toolResults.length === 0) {
+					if (toolResults.length === 0) {
+						flushMissing();
+					}
+					const nextMessage =
+						toolResults.length > 0
+							? {
+									...message,
+									content: otherBlocks,
+								}
+							: message;
+					pushRepairedMessage(nextMessage);
+					if (nextMessage.role === "assistant") {
+						this.trackMissingToolCalls(
+							nextMessage,
+							existingToolResultIds,
+							pendingMissingToolCalls,
+						);
+					}
+				}
+				continue;
+			}
+
+			flushMissing();
+			pushRepairedMessage(message);
+		}
+
+		flushMissing();
+		return changed ? repaired : messages;
+	}
+
+	private appendMissingToolResults(
+		message: Message,
+		pendingMissingToolCalls: ReadonlyMap<string, string>,
+	): Message {
+		if (pendingMissingToolCalls.size === 0 || !Array.isArray(message.content)) {
+			return message;
+		}
+		return {
+			...message,
+			role: "user",
+			content: [
+				...message.content,
+				...this.createMissingToolResultBlocks(pendingMissingToolCalls),
+			],
+		};
+	}
+
+	private shouldMergeUserAfterToolResults(
+		previous: Message | undefined,
+		next: Message,
+	): previous is Message & { content: ToolResultContent[] } {
+		return (
+			previous?.role === "user" &&
+			next.role === "user" &&
+			this.isToolResultOnlyMessage(previous) &&
+			this.contentBlocksForUserMerge(next.content).length > 0
+		);
+	}
+
+	private contentBlocksForUserMerge(
+		content: Message["content"],
+	): ContentBlock[] {
+		return typeof content === "string"
+			? content.length > 0
+				? [{ type: "text", text: content } satisfies TextContent]
+				: []
+			: content;
+	}
+
+	private collectToolResultIds(messages: Message[]): Set<string> {
+		const ids = new Set<string>();
+		for (const message of messages) {
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type === "tool_result") {
+					ids.add(block.tool_use_id);
+				}
+			}
+		}
+		return ids;
+	}
+
+	private isToolResultOnlyMessage(message: Message): boolean {
+		return (
+			message.role === "user" &&
+			Array.isArray(message.content) &&
+			message.content.length > 0 &&
+			message.content.every((block) => block.type === "tool_result")
+		);
+	}
+
+	private trackMissingToolCalls(
+		message: Message,
+		existingToolResultIds: Set<string>,
+		pendingMissingToolCalls: Map<string, string>,
+	): void {
+		if (!Array.isArray(message.content)) {
+			return;
+		}
+		for (const block of message.content) {
+			if (block.type !== "tool_use" || existingToolResultIds.has(block.id)) {
+				continue;
+			}
+			pendingMissingToolCalls.set(block.id, block.name);
+		}
+	}
+
+	private createMissingToolResultMessage(
+		toolCalls: ReadonlyMap<string, string>,
+	): Message {
+		return {
+			role: "user",
+			content: this.createMissingToolResultBlocks(toolCalls),
+		};
+	}
+
+	private createMissingToolResultBlocks(
+		toolCalls: ReadonlyMap<string, string>,
+	): ToolResultContent[] {
+		return Array.from(toolCalls, ([toolUseId, toolName]) => ({
+			type: "tool_result",
+			tool_use_id: toolUseId,
+			name: toolName,
+			content: [
+				{
+					type: "text",
+					text: this.formatMissingToolResultText(toolName),
+				},
+			],
+			is_error: true,
+		}));
+	}
+
+	private formatMissingToolResultText(toolName: string): string {
+		return toolName
+			? `${MISSING_TOOL_RESULT_TEXT} Tool: ${toolName}.`
+			: MISSING_TOOL_RESULT_TEXT;
+	}
+
+	private resetIndexes(): void {
+		this.indexedMessageCount = 0;
+		this.indexedTailRef = undefined;
+		this.toolNameByIdCache.clear();
+		this.readLocatorsByToolUseIdCache.clear();
+		this.latestReadToolUseByLocatorCache.clear();
+		this.latestFullContentOwnerByPathCache.clear();
+		this.readResultLocatorCache = new WeakMap<object, ReadLocator[]>();
+	}
+
+	private getReadLocators(block: ToolResultContent): ReadLocator[] {
+		const blockRef = block as unknown as object;
+		let parsed = this.readResultLocatorCache.get(blockRef);
+		if (parsed === undefined) {
+			parsed = this.extractReadLocatorsFromToolResultContent(block.content);
+			this.readResultLocatorCache.set(blockRef, parsed);
+		}
+		if (parsed.length > 0) {
+			return parsed;
+		}
+		return this.readLocatorsByToolUseIdCache.get(block.tool_use_id) ?? [];
+	}
+
+	private extractLocatorsFromReadToolInput(input: unknown): ReadLocator[] {
+		if (!input || typeof input !== "object") {
+			return [];
+		}
+
+		const record = input as Record<string, unknown>;
+		const locators: ReadLocator[] = [];
+		const direct = this.extractLocatorFromReadRequest(record);
+		if (direct) {
+			locators.push(direct);
+		}
+
+		if (Array.isArray(record.files)) {
+			for (const value of record.files) {
+				const locator = this.extractLocatorFromReadRequest(value);
+				if (locator) {
+					locators.push(locator);
+				}
+			}
+		}
+
+		if (Array.isArray(record.file_paths)) {
+			for (const value of record.file_paths) {
+				if (typeof value === "string" && value.length > 0) {
+					locators.push({ path: value, startLine: null, endLine: null });
+				}
+			}
+		}
+
+		return this.dedupeReadLocators(locators);
+	}
+
+	private extractReadLocatorsFromToolResultContent(
+		content: ToolResultContent["content"],
+	): ReadLocator[] {
+		if (typeof content === "string") {
+			return this.tryParseReadLocators(content);
+		}
+		const locators: ReadLocator[] = [];
+		for (const entry of content) {
+			if (entry.type === "text") {
+				locators.push(...this.tryParseReadLocators(entry.text));
+				continue;
+			}
+			if (isStructuredToolResultEntry(entry)) {
+				const locator = this.extractLocatorFromResultEntry(entry);
+				if (locator) {
+					locators.push(locator);
+				}
+			}
+		}
+		return this.dedupeReadLocators(locators);
+	}
+
+	private tryParseReadLocators(text: string): ReadLocator[] {
+		try {
+			return this.extractLocatorsFromParsedReadResult(JSON.parse(text));
+		} catch {
+			return [];
+		}
+	}
+
+	private extractLocatorsFromParsedReadResult(value: unknown): ReadLocator[] {
+		if (Array.isArray(value)) {
+			const locators: ReadLocator[] = [];
+			for (const item of value) {
+				const locator = this.extractLocatorFromResultEntry(item);
+				if (locator) {
+					locators.push(locator);
+				}
+			}
+			return this.dedupeReadLocators(locators);
+		}
+		const locator = this.extractLocatorFromResultEntry(value);
+		return locator ? [locator] : [];
+	}
+
+	private extractLocatorFromReadRequest(
+		value: unknown,
+	): ReadLocator | undefined {
+		if (!value || typeof value !== "object") {
+			return undefined;
+		}
+		const record = value as Record<string, unknown>;
+		const path = this.extractPath(record);
+		if (!path) {
+			return undefined;
+		}
+		return {
+			path,
+			startLine: this.extractLineNumber(record.start_line),
+			endLine: this.extractLineNumber(record.end_line),
+		};
+	}
+
+	private extractLocatorFromResultEntry(
+		value: unknown,
+	): ReadLocator | undefined {
+		if (!value || typeof value !== "object") {
+			return undefined;
+		}
+		const record = value as Record<string, unknown>;
+		const path = this.extractPath(record);
+		if (path) {
+			return {
+				path,
+				startLine: this.extractLineNumber(record.start_line),
+				endLine: this.extractLineNumber(record.end_line),
+			};
+		}
+		if (typeof record.query === "string" && record.query.length > 0) {
+			return this.parseReadQuery(record.query);
+		}
+		return undefined;
+	}
+
+	private extractPath(record: Record<string, unknown>): string | undefined {
+		const candidates = [record.path, record.file_path, record.filePath];
+		for (const candidate of candidates) {
+			if (typeof candidate === "string" && candidate.length > 0) {
+				return candidate;
+			}
+		}
+		return undefined;
+	}
+
+	private extractLineNumber(value: unknown): number | null {
+		return typeof value === "number" && Number.isInteger(value) ? value : null;
+	}
+
+	private parseReadQuery(query: string): ReadLocator {
+		const match = /^(.*):(\d+)-(EOF|\d+)$/.exec(query);
+		if (!match) {
+			return { path: query, startLine: null, endLine: null };
+		}
+		return {
+			path: match[1],
+			startLine: Number(match[2]),
+			endLine: match[3] === "EOF" ? null : Number(match[3]),
+		};
+	}
+
+	private dedupeReadLocators(locators: ReadLocator[]): ReadLocator[] {
+		const unique = new Map<string, ReadLocator>();
+		for (const locator of locators) {
+			unique.set(this.toReadLocatorKey(locator), locator);
+		}
+		return Array.from(unique.values());
+	}
+
+	private toReadLocatorKey(locator: ReadLocator): string {
+		if (this.isFullFileRead(locator)) {
+			return locator.path;
+		}
+		return `${locator.path}:${locator.startLine ?? 1}-${locator.endLine ?? "EOF"}`;
+	}
+
+	private isFullFileRead(locator: ReadLocator): boolean {
+		return locator.startLine == null && locator.endLine == null;
+	}
+
+	private isOutdatedReadLocator(
+		locator: ReadLocator,
+		toolUseId: string,
+	): boolean {
+		const fullOwner = this.latestFullContentOwnerByPathCache.get(locator.path);
+		if (fullOwner && fullOwner !== toolUseId) {
+			return true;
+		}
+		return (
+			this.latestReadToolUseByLocatorCache.get(
+				this.toReadLocatorKey(locator),
+			) !== toolUseId
+		);
+	}
+
+	private replaceOutdatedReadContent(
+		content: ToolResultContent["content"],
+		outdated: ReadLocator[],
+	): ToolResultContent["content"] {
+		const outdatedKeys = new Set(outdated.map((l) => this.toReadLocatorKey(l)));
+		const outdatedPaths = new Set(outdated.map((l) => l.path));
+
+		if (typeof content === "string") {
+			return (
+				this.replaceOutdatedInString(content, outdatedKeys) ??
+				OUTDATED_FILE_CONTENT
+			);
+		}
+
+		// Image entries are paired with text result markers, so rewrite them positionally.
+		let pendingImageReplacements = 0;
+		for (const entry of content) {
+			if (entry.type === "text") {
+				pendingImageReplacements += this.countOutdatedImageEntries(
+					entry.text,
+					outdatedKeys,
+				);
+			}
+		}
+
+		return content.map((entry) => {
+			if (entry.type === "file") {
+				if (!outdatedPaths.has(entry.path)) {
+					return entry;
+				}
+				return { ...entry, content: OUTDATED_FILE_CONTENT };
+			}
+			if (entry.type === "image") {
+				if (pendingImageReplacements === 0) {
+					return entry;
+				}
+				pendingImageReplacements -= 1;
+				return {
+					type: "text",
+					text: OUTDATED_FILE_CONTENT,
+				} satisfies TextContent;
+			}
+			if (isStructuredToolResultEntry(entry)) {
+				return this.replaceOutdatedReadEntry(
+					entry,
+					outdatedKeys,
+				) as typeof entry;
+			}
+			if (entry.type !== "text") {
+				return entry;
+			}
+			const replaced = this.replaceOutdatedInString(entry.text, outdatedKeys);
+			if (replaced === null) {
+				return { ...entry, text: OUTDATED_FILE_CONTENT };
+			}
+			return replaced === entry.text ? entry : { ...entry, text: replaced };
+		});
+	}
+
+	private countOutdatedImageEntries(
+		text: string,
+		outdatedKeys: Set<string>,
+	): number {
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(text);
+		} catch {
+			return 0;
+		}
+		const entries = Array.isArray(parsed) ? parsed : [parsed];
+		let count = 0;
+		for (const entry of entries) {
+			if (!entry || typeof entry !== "object") {
+				continue;
+			}
+			const record = entry as Record<string, unknown>;
+			const locator = this.extractLocatorFromResultEntry(record);
+			if (!locator) {
+				continue;
+			}
+			if (!outdatedKeys.has(this.toReadLocatorKey(locator))) {
+				continue;
+			}
+			if (
+				record.result === "Successfully read image" ||
+				record.content === "Successfully read image"
+			) {
+				count += 1;
+			}
+		}
+		return count;
+	}
+
+	private replaceOutdatedInString(
+		text: string,
+		outdatedKeys: Set<string>,
+	): string | null {
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(text);
+		} catch {
+			return null;
+		}
+		const replaced = Array.isArray(parsed)
+			? parsed.map((entry) =>
+					this.replaceOutdatedReadEntry(entry, outdatedKeys),
+				)
+			: this.replaceOutdatedReadEntry(parsed, outdatedKeys);
+		return JSON.stringify(replaced);
+	}
+
+	private replaceOutdatedReadEntry(
+		entry: unknown,
+		outdatedKeys: Set<string>,
+	): unknown {
+		if (!entry || typeof entry !== "object") {
+			return entry;
+		}
+		const locator = this.extractLocatorFromResultEntry(entry);
+		if (!locator || !outdatedKeys.has(this.toReadLocatorKey(locator))) {
+			return entry;
+		}
+		const record = { ...(entry as Record<string, unknown>) };
+		if (typeof record.result === "string") {
+			record.result = OUTDATED_FILE_CONTENT;
+		} else if (typeof record.content === "string") {
+			record.content = OUTDATED_FILE_CONTENT;
+		} else {
+			record.result = OUTDATED_FILE_CONTENT;
+		}
+		return record;
+	}
+
+	private isReadTool(toolName: string | undefined): boolean {
+		return !!toolName && READ_TOOL_NAMES.has(toolName);
+	}
+
+	/**
+	 * Tool results can outlive their paired tool_use block (compacted or
+	 * imported histories), so fall back to the name carried on the result
+	 * itself when the id lookup misses.
+	 */
+	private resolveToolName(block: ToolResultContent): string | undefined {
+		const cached = this.toolNameByIdCache.get(block.tool_use_id);
+		if (cached !== undefined) {
+			return cached;
+		}
+		return typeof block.name === "string" && block.name.length > 0
+			? block.name.toLowerCase()
+			: undefined;
+	}
+
+	private truncateToolResultContent(
+		content: ToolResultContent["content"],
+	): ToolResultContent["content"] {
+		if (typeof content === "string") {
+			return this.truncateMiddle(content);
+		}
+		return content.map((entry) => {
+			if (entry.type === "file") {
+				const next = this.truncateMiddle(entry.content);
+				return next === entry.content ? entry : { ...entry, content: next };
+			}
+			if (entry.type === "text") {
+				const next = this.truncateMiddle(entry.text);
+				return next === entry.text ? entry : { ...entry, text: next };
+			}
+			if (isStructuredToolResultEntry(entry)) {
+				return this.truncateNestedStrings(entry) as typeof entry;
+			}
+			return entry;
+		});
+	}
+
+	/**
+	 * Deep-truncates string values inside structured tool outputs (e.g.
+	 * `ToolOperationResult[]` from run_commands/read_files), which carry the
+	 * payload in untyped `{query, result, ...}` fields rather than text
+	 * blocks. Image blocks are left intact so base64 payloads survive.
+	 */
+	private truncateNestedStrings(value: unknown): unknown {
+		if (typeof value === "string") {
+			return this.truncateMiddle(value);
+		}
+		if (Array.isArray(value)) {
+			let changed = false;
+			const next = value.map((item) => {
+				const out = this.truncateNestedStrings(item);
+				if (out !== item) {
+					changed = true;
+				}
+				return out;
+			});
+			return changed ? next : value;
+		}
+		if (value !== null && typeof value === "object") {
+			if (isBinaryContentLike(value)) {
+				return value;
+			}
+			let changed = false;
+			const next: Record<string, unknown> = {};
+			for (const [key, item] of Object.entries(value)) {
+				const out = this.truncateNestedStrings(item);
+				if (out !== item) {
+					changed = true;
+				}
+				next[key] = out;
+			}
+			return changed ? next : value;
+		}
+		return value;
+	}
+
+	private truncateMiddle(text: string): string {
+		return truncateMiddleByChars(
+			text,
+			this.maxToolResultChars,
+			TRUNCATE_MARKER_DEFAULT,
+		);
+	}
+
+	private truncateAssistantText(text: string): string {
+		if (this.hasRepeatedToolCallMarkup(text)) {
+			return truncateMiddleByChars(
+				text,
+				this.maxAssistantToolMarkupChars,
+				TRUNCATE_ASSISTANT_TOOL_MARKUP_MARKER,
+			);
+		}
+		return truncateMiddleByChars(
+			text,
+			this.maxAssistantTextChars,
+			TRUNCATE_ASSISTANT_TEXT_MARKER,
+		);
+	}
+
+	private hasRepeatedToolCallMarkup(text: string): boolean {
+		if (text.length <= this.maxAssistantToolMarkupChars) {
+			return false;
+		}
+		let count = 0;
+		for (const _match of text.matchAll(TOOL_CALL_MARKUP_PATTERN)) {
+			count += 1;
+			if (count >= REPEATED_TOOL_CALL_MARKUP_THRESHOLD) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private truncateToTotalTextBudget(messages: Message[]): Message[] {
+		let totalBytes = this.countMessageTextBytes(messages);
+		if (totalBytes <= this.maxTotalTextBytes) {
+			return messages;
+		}
+
+		const next = messages.map((message) => {
+			if (!Array.isArray(message.content)) {
+				return { ...message };
+			}
+			return {
+				...message,
+				content: message.content.map((block) =>
+					cloneContentBlockForMutation(block),
+				),
+			};
+		});
+
+		const candidates = this.collectTruncationCandidates(next);
+		for (const candidate of candidates) {
+			if (totalBytes <= this.maxTotalTextBytes) {
+				break;
+			}
+			const currentBytes = candidate.byteLength;
+			if (currentBytes <= candidate.minBytes) {
+				continue;
+			}
+			const overflow = totalBytes - this.maxTotalTextBytes;
+			const targetBytes = Math.max(candidate.minBytes, currentBytes - overflow);
+			const truncated = truncateMiddleToBytes(
+				candidate.get(),
+				targetBytes,
+				candidate.makeMarker,
+			);
+			candidate.set(truncated);
+			totalBytes -= currentBytes - utf8ByteLength(truncated);
+		}
+
+		return next;
+	}
+
+	private countMessageTextBytes(messages: Message[]): number {
+		let total = 0;
+		for (const message of messages) {
+			if (typeof message.content === "string") {
+				total += utf8ByteLength(message.content);
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type === "text") {
+					total += utf8ByteLength(block.text);
+				} else if (block.type === "thinking") {
+					total += utf8ByteLength(block.thinking);
+				} else if (block.type === "file") {
+					total += utf8ByteLength(block.content);
+				} else if (block.type === "tool_use") {
+					// Model-generated tool arguments ship on the wire too. Counting
+					// them keeps the budget honest; if tool results alone cannot
+					// absorb the overflow, oversized argument strings are truncated
+					// as a last resort (see collectTruncationCandidates).
+					total += countNestedStringBytes(block.input);
+				} else if (block.type === "tool_result") {
+					if (typeof block.content === "string") {
+						total += utf8ByteLength(block.content);
+					} else {
+						for (const entry of block.content) {
+							if (entry.type === "text") {
+								total += utf8ByteLength(entry.text);
+							} else if (entry.type === "file") {
+								total += utf8ByteLength(entry.content);
+							} else if (isStructuredToolResultEntry(entry)) {
+								total += countNestedStringBytes(entry);
+							}
+						}
+					}
+				}
+			}
+		}
+		return total;
+	}
+
+	private collectTruncationCandidates(
+		messages: Message[],
+	): TruncationCandidate[] {
+		const resultCandidates: TruncationCandidate[] = [];
+		const inputCandidates: TruncationCandidate[] = [];
+		for (const message of messages) {
+			if (message.role === "assistant" && typeof message.content === "string") {
+				resultCandidates.push({
+					byteLength: utf8ByteLength(message.content),
+					minBytes: MIN_TOTAL_BUDGET_ASSISTANT_TEXT_BYTES,
+					makeMarker: TRUNCATE_ASSISTANT_TEXT_BUDGET_MARKER,
+					get: () => message.content as string,
+					set: (value) => {
+						message.content = value;
+					},
+				});
+				continue;
+			}
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type === "tool_use") {
+					collectNestedStringCandidates(block.input, inputCandidates);
+					continue;
+				}
+				if (message.role === "assistant" && block.type === "text") {
+					resultCandidates.push({
+						byteLength: utf8ByteLength(block.text),
+						minBytes: MIN_TOTAL_BUDGET_ASSISTANT_TEXT_BYTES,
+						makeMarker: TRUNCATE_ASSISTANT_TEXT_BUDGET_MARKER,
+						get: () => block.text,
+						set: (value) => {
+							block.text = value;
+						},
+					});
+					continue;
+				}
+				if (block.type !== "tool_result") {
+					continue;
+				}
+				if (typeof block.content === "string") {
+					resultCandidates.push({
+						byteLength: utf8ByteLength(block.content),
+						minBytes: MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES,
+						makeMarker: TRUNCATE_MARKER_BUDGET,
+						get: () => block.content as string,
+						set: (value) => {
+							block.content = value;
+						},
+					});
+					continue;
+				}
+				for (const entry of block.content) {
+					if (entry.type === "text") {
+						resultCandidates.push({
+							byteLength: utf8ByteLength(entry.text),
+							minBytes: MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES,
+							makeMarker: TRUNCATE_MARKER_BUDGET,
+							get: () => entry.text,
+							set: (value) => {
+								entry.text = value;
+							},
+						});
+					} else if (entry.type === "file") {
+						resultCandidates.push({
+							byteLength: utf8ByteLength(entry.content),
+							minBytes: MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES,
+							makeMarker: TRUNCATE_MARKER_BUDGET,
+							get: () => entry.content,
+							set: (value) => {
+								entry.content = value;
+							},
+						});
+					} else if (isStructuredToolResultEntry(entry)) {
+						collectNestedStringCandidates(entry, resultCandidates);
+					}
+				}
+			}
+		}
+		// Tool results and assistant text truncate first; model-generated
+		// tool_use arguments are a last resort because some providers
+		// revalidate or replay them. All three being candidates keeps the
+		// budget reclaimable no matter which side carries the overflow.
+		resultCandidates.sort((l, r) => r.byteLength - l.byteLength);
+		inputCandidates.sort((l, r) => r.byteLength - l.byteLength);
+		return [...resultCandidates, ...inputCandidates];
+	}
+
+	private applyMediaBudget(messages: Message[]): Message[] {
+		const budget = this.resolveMediaBudget();
+		if (
+			budget.maxImageEncodedBytes === Number.POSITIVE_INFINITY &&
+			budget.maxImageDecodedBytes === Number.POSITIVE_INFINITY &&
+			budget.maxTotalMediaBytes === Number.POSITIVE_INFINITY
+		) {
+			return messages;
+		}
+
+		const state = createMediaBudgetState();
+		let changed = false;
+		const next = messages.map((message) => {
+			if (!Array.isArray(message.content)) {
+				return message;
+			}
+			let contentChanged = false;
+			const content = message.content.map((block) => {
+				const out = this.applyMediaBudgetToBlock(block, budget, state);
+				if (out !== block) {
+					contentChanged = true;
+				}
+				return out;
+			});
+			if (!contentChanged) {
+				return message;
+			}
+			changed = true;
+			return { ...message, content };
+		});
+
+		return changed ? next : messages;
+	}
+
+	private resolveMediaBudget(): ResolvedMediaBudget {
+		return resolveMediaBudget(this.mediaBudget);
+	}
+
+	private applyMediaBudgetToBlock(
+		block: ContentBlock,
+		budget: ResolvedMediaBudget,
+		state: MediaBudgetState,
+	): ContentBlock {
+		if (isImageContentLike(block)) {
+			return this.limitImageContent(block, budget, state);
+		}
+
+		if (block.type !== "tool_result" || typeof block.content === "string") {
+			return block;
+		}
+
+		let changed = false;
+		const content = block.content.map((entry) => {
+			const out = this.applyMediaBudgetToToolResultEntry(entry, budget, state);
+			if (out !== entry) {
+				changed = true;
+			}
+			return out as (typeof block.content)[number];
+		});
+
+		return changed
+			? { ...block, content: content as ToolResultContent["content"] }
+			: block;
+	}
+
+	private applyMediaBudgetToToolResultEntry(
+		entry: unknown,
+		budget: ResolvedMediaBudget,
+		state: MediaBudgetState,
+	): unknown {
+		if (isImageContentLike(entry)) {
+			return this.limitImageContent(entry, budget, state);
+		}
+		if (isStructuredToolResultEntry(entry)) {
+			return this.limitNestedMedia(entry, budget, state);
+		}
+		return entry;
+	}
+
+	private limitNestedMedia(
+		value: unknown,
+		budget: ResolvedMediaBudget,
+		state: MediaBudgetState,
+	): unknown {
+		if (isImageContentLike(value)) {
+			const limited = this.limitImageContent(value, budget, state);
+			return limited.type === "text" ? limited.text : limited;
+		}
+
+		if (Array.isArray(value)) {
+			let changed = false;
+			const next = value.map((item) => {
+				const out = this.limitNestedMedia(item, budget, state);
+				if (out !== item) {
+					changed = true;
+				}
+				return out;
+			});
+			return changed ? next : value;
+		}
+
+		if (value !== null && typeof value === "object") {
+			let changed = false;
+			const next: Record<string, unknown> = {};
+			for (const [key, item] of Object.entries(value)) {
+				const out = this.limitNestedMedia(item, budget, state);
+				if (out !== item) {
+					changed = true;
+				}
+				next[key] = out;
+			}
+			return changed ? next : value;
+		}
+
+		return value;
+	}
+
+	private limitImageContent(
+		image: unknown,
+		budget: ResolvedMediaBudget,
+		state: MediaBudgetState,
+	): ImageContent | TextContent {
+		if (!isImageContentWithData(image)) {
+			return { type: "text", text: IMAGE_OMITTED_PLACEHOLDER };
+		}
+
+		const validation = validateAndReserveImageMedia(
+			image.mediaType,
+			image.data,
+			{
+				maxImageEncodedBytes: budget.maxImageEncodedBytes,
+				maxImageDecodedBytes: budget.maxImageDecodedBytes,
+				maxTotalMediaBytes: budget.maxTotalMediaBytes,
+			},
+			state,
+		);
+		if (!validation.ok) {
+			return { type: "text", text: IMAGE_OMITTED_PLACEHOLDER };
+		}
+
+		return {
+			...image,
+			data: validation.base64,
+			mediaType: validation.mediaType,
+		};
+	}
+}
+
+const DSML_BAR = String.raw`[\|\uFF5C]`;
+// Compiled once at module load; String.prototype.matchAll clones the regex
+// per call, so sharing the global-flagged instance is safe.
+const TOOL_CALL_MARKUP_PATTERN = new RegExp(
+	String.raw`<\s*(?:${DSML_BAR}\s*)?DSML\s*(?:${DSML_BAR}\s*)?(?:tool_calls|invoke)\b[^>]*>|<\s*/?\s*(?:tool_calls?|tool_call|function_calls?|function_call|invoke)\b[^>]*>`,
+	"gi",
+);
+
+function utf8ByteLength(text: string): number {
+	return Buffer.byteLength(text, "utf8");
+}
+
+function parsePositiveIntegerEnv(
+	value: string | undefined,
+): number | undefined {
+	if (value === undefined) {
+		return undefined;
+	}
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function parseNonNegativeLimitEnv(
+	value: string | undefined,
+): number | undefined {
+	if (value === undefined) {
+		return undefined;
+	}
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "infinity" || normalized === "disable") {
+		return Number.POSITIVE_INFINITY;
+	}
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
+function normalizePositiveLimit(
+	value: number | undefined,
+	fallback: number,
+): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0
+		? Math.floor(value)
+		: fallback;
+}
+
+function normalizeNonNegativeLimit(
+	value: number | undefined,
+	fallback: number,
+): number {
+	if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+		return fallback;
+	}
+	return Number.isFinite(value) ? Math.floor(value) : value;
+}
+
+function truncateMiddleByChars(
+	text: string,
+	maxChars: number,
+	makeMarker: (removed: number) => string,
+): string {
+	if (text.length <= maxChars) {
+		return text;
+	}
+	// Two-pass: marker length depends on the removed-char count, which depends
+	// on the marker length. Compute a tentative marker, derive the final
+	// removed count, then build the real marker.
+	const tentativeMarker = makeMarker(text.length - maxChars);
+	const tentativeKeep = Math.max(
+		0,
+		Math.floor((maxChars - tentativeMarker.length) / 2),
+	);
+	const removed = Math.max(0, text.length - tentativeKeep * 2);
+	const marker = makeMarker(removed);
+	const keep = Math.max(0, Math.floor((maxChars - marker.length) / 2));
+	const start = text.slice(0, keep);
+	const end = keep > 0 ? text.slice(-keep) : "";
+	return `${start}${marker}${end}`;
+}
+
+function truncateMiddleToBytes(
+	text: string,
+	maxBytes: number,
+	makeMarker: (removed: number) => string,
+): string {
+	if (utf8ByteLength(text) <= maxBytes) {
+		return text;
+	}
+	// Binary search the largest char-length whose UTF-8 byte length fits.
+	let low = 0;
+	let high = text.length;
+	let best = truncateMiddleByChars(text, 0, makeMarker);
+	while (low <= high) {
+		const mid = (low + high) >>> 1;
+		const candidate = truncateMiddleByChars(text, mid, makeMarker);
+		if (utf8ByteLength(candidate) <= maxBytes) {
+			best = candidate;
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+	return best;
+}
+
+function cloneContentBlockForMutation(block: ContentBlock): ContentBlock {
+	if (block.type === "tool_use") {
+		// Inputs are budget-truncation candidates of last resort, so they need
+		// the same deep-clone treatment as structured results: a shallow copy
+		// would leak truncation mutations back into conversation history.
+		return {
+			...block,
+			input: deepCloneJsonLike(block.input) as typeof block.input,
+		};
+	}
+	if (block.type !== "tool_result" || typeof block.content === "string") {
+		return { ...block };
+	}
+	return {
+		...block,
+		// Structured entries can nest the payload strings arbitrarily deep, so
+		// a shallow copy would leak budget-truncation mutations back into the
+		// original conversation history.
+		content: block.content.map((entry) =>
+			isStructuredToolResultEntry(entry)
+				? (deepCloneJsonLike(entry) as typeof entry)
+				: { ...entry },
+		),
+	};
+}
+
+/**
+ * True for tool_result content entries that are not the typed text/image/file
+ * blocks — i.e. structured tool outputs such as `ToolOperationResult[]`
+ * entries that the runtime stores directly in the content array.
+ */
+function isStructuredToolResultEntry(entry: unknown): boolean {
+	if (entry === null || typeof entry !== "object") {
+		return false;
+	}
+	const type = (entry as { type?: unknown }).type;
+	return type !== "text" && type !== "image" && type !== "file";
+}
+
+function isImageContentLike(value: unknown): boolean {
+	return (
+		value !== null &&
+		typeof value === "object" &&
+		(value as { type?: unknown }).type === "image"
+	);
+}
+
+function isImageContentWithData(value: unknown): value is ImageContent {
+	return (
+		value !== null &&
+		typeof value === "object" &&
+		(value as { type?: unknown }).type === "image" &&
+		typeof (value as { data?: unknown }).data === "string" &&
+		typeof (value as { mediaType?: unknown }).mediaType === "string"
+	);
+}
+
+function isBinaryContentLike(value: unknown): boolean {
+	return isImageContentWithData(value);
+}
+
+function countNestedStringBytes(value: unknown): number {
+	if (typeof value === "string") {
+		return utf8ByteLength(value);
+	}
+	if (Array.isArray(value)) {
+		let total = 0;
+		for (const item of value) {
+			total += countNestedStringBytes(item);
+		}
+		return total;
+	}
+	if (value !== null && typeof value === "object") {
+		if (isBinaryContentLike(value)) {
+			return 0;
+		}
+		let total = 0;
+		for (const item of Object.values(value)) {
+			total += countNestedStringBytes(item);
+		}
+		return total;
+	}
+	return 0;
+}
+
+function collectNestedStringCandidates(
+	container: unknown,
+	candidates: TruncationCandidate[],
+): void {
+	if (Array.isArray(container)) {
+		container.forEach((item, index) => {
+			if (typeof item === "string") {
+				candidates.push({
+					byteLength: utf8ByteLength(item),
+					minBytes: MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES,
+					makeMarker: TRUNCATE_MARKER_BUDGET,
+					get: () => container[index] as string,
+					set: (value) => {
+						container[index] = value;
+					},
+				});
+			} else {
+				collectNestedStringCandidates(item, candidates);
+			}
+		});
+		return;
+	}
+	if (container !== null && typeof container === "object") {
+		if (isBinaryContentLike(container)) {
+			return;
+		}
+		const record = container as Record<string, unknown>;
+		for (const key of Object.keys(record)) {
+			const item = record[key];
+			if (typeof item === "string") {
+				candidates.push({
+					byteLength: utf8ByteLength(item),
+					minBytes: MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES,
+					makeMarker: TRUNCATE_MARKER_BUDGET,
+					get: () => record[key] as string,
+					set: (value) => {
+						record[key] = value;
+					},
+				});
+			} else {
+				collectNestedStringCandidates(item, candidates);
+			}
+		}
+	}
+}
+
+function deepCloneJsonLike(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(deepCloneJsonLike);
+	}
+	if (value !== null && typeof value === "object") {
+		const out: Record<string, unknown> = {};
+		for (const [key, item] of Object.entries(value)) {
+			out[key] = deepCloneJsonLike(item);
+		}
+		return out;
+	}
+	return value;
+}
diff --git a/sdk/packages/core/src/session/services/persistence-service.test.ts b/sdk/packages/core/src/session/services/persistence-service.test.ts
new file mode 100644
index 0000000..a45800a
--- /dev/null
+++ b/sdk/packages/core/src/session/services/persistence-service.test.ts
@@ -0,0 +1,765 @@
+import {
+	existsSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import { SessionSource } from "../../types/common";
+import { createSessionCompactionState } from "../models/session-compaction";
+import { FileSessionService } from "../services/file-session-service";
+import { CoreSessionService } from "../services/session-service";
+
+const require = createRequire(import.meta.url);
+const sqliteAvailable = (() => {
+	try {
+		require("node:sqlite");
+		return true;
+	} catch {
+		return false;
+	}
+})();
+
+describe("UnifiedSessionPersistenceService", () => {
+	const tempDirs: string[] = [];
+	const stores: Array<SqliteSessionStore> = [];
+	const sqliteIt = sqliteAvailable ? it : it.skip;
+
+	afterEach(() => {
+		for (const store of stores.splice(0)) {
+			store.close();
+		}
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("persists compaction state as a separate session artifact", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "compaction-artifact-"));
+		tempDirs.push(sessionsDir);
+		const service = new FileSessionService(sessionsDir);
+		const sessionId = "session-with-compaction";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: true,
+			provider: "anthropic",
+			model: "claude-sonnet",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const sourceMessages = [
+			{ id: "u1", role: "user" as const, content: "full transcript" },
+		];
+		const compactedMessages = [
+			{ id: "summary", role: "user" as const, content: "summary" },
+		];
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages,
+			conversationId: "conv-1",
+			updatedAt: "2026-01-01T00:00:01.000Z",
+		});
+		expect(
+			JSON.parse(readFileSync(artifacts.manifestPath, "utf8")),
+		).not.toHaveProperty("compaction_path");
+		expect(existsSync(artifacts.compactionPath ?? "")).toBe(false);
+
+		await service.persistSessionMessages(sessionId, sourceMessages);
+		await service.persistSessionCompactionState(sessionId, state);
+
+		expect(
+			JSON.parse(readFileSync(artifacts.manifestPath, "utf8")),
+		).toHaveProperty("compaction_path", artifacts.compactionPath);
+		const messagesPayload = JSON.parse(
+			readFileSync(artifacts.messagesPath, "utf8"),
+		) as { messages?: unknown[] };
+		const compactionPayload = JSON.parse(
+			readFileSync(artifacts.compactionPath ?? "", "utf8"),
+		) as { messages?: unknown[]; source_message_count?: number };
+		expect(messagesPayload.messages).toHaveLength(1);
+		expect(compactionPayload).toMatchObject({
+			source_message_count: 1,
+			messages: compactedMessages,
+		});
+		await expect(
+			service.readSessionCompactionState(sessionId),
+		).resolves.toMatchObject({
+			source_message_count: 1,
+			messages: compactedMessages,
+		});
+	});
+
+	it("deletes persisted compaction state without mutating canonical messages", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "compaction-delete-"));
+		tempDirs.push(sessionsDir);
+		const service = new FileSessionService(sessionsDir);
+		const sessionId = "session-delete-compaction";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: true,
+			provider: "anthropic",
+			model: "claude-sonnet",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const sourceMessages = [
+			{ id: "u1", role: "user" as const, content: "full transcript" },
+		];
+		const state = createSessionCompactionState({
+			sourceMessages,
+			compactedMessages: [
+				{ id: "summary", role: "user" as const, content: "summary" },
+			],
+			updatedAt: "2026-01-01T00:00:01.000Z",
+		});
+
+		await service.persistSessionMessages(sessionId, sourceMessages);
+		await service.persistSessionCompactionState(sessionId, state);
+		expect(existsSync(artifacts.compactionPath ?? "")).toBe(true);
+		await service.deleteSessionCompactionState(sessionId);
+
+		expect(existsSync(artifacts.messagesPath)).toBe(true);
+		expect(existsSync(artifacts.compactionPath ?? "")).toBe(false);
+		expect(
+			JSON.parse(readFileSync(artifacts.manifestPath, "utf8")),
+		).not.toHaveProperty("compaction_path");
+		await expect(
+			service.readSessionCompactionState(sessionId),
+		).resolves.toBeUndefined();
+	});
+
+	it("adds compaction path to old manifests only when sidecar is written", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "compaction-old-manifest-"));
+		tempDirs.push(sessionsDir);
+		const service = new FileSessionService(sessionsDir);
+		const sessionId = "session-old-manifest";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: true,
+			provider: "anthropic",
+			model: "claude-sonnet",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+		const manifest = JSON.parse(
+			readFileSync(artifacts.manifestPath, "utf8"),
+		) as {
+			compaction_path?: string;
+		};
+		delete manifest.compaction_path;
+		writeFileSync(
+			artifacts.manifestPath,
+			`${JSON.stringify(manifest, null, 2)}\n`,
+			"utf8",
+		);
+		const state = createSessionCompactionState({
+			sourceMessages: [
+				{ id: "u1", role: "user" as const, content: "full transcript" },
+			],
+			compactedMessages: [
+				{ id: "summary", role: "user" as const, content: "summary" },
+			],
+			updatedAt: "2026-01-01T00:00:01.000Z",
+		});
+
+		await service.persistSessionCompactionState(sessionId, state);
+
+		expect(existsSync(artifacts.compactionPath ?? "")).toBe(true);
+		expect(
+			JSON.parse(readFileSync(artifacts.manifestPath, "utf8")),
+		).toHaveProperty("compaction_path", artifacts.compactionPath);
+	});
+
+	sqliteIt(
+		"reconciles dead running sessions into failed manifests with terminal markers",
+		async () => {
+			const dbDir = mkdtempSync(join(tmpdir(), "stale-session-reconcile-db-"));
+			const sessionsDir = mkdtempSync(
+				join(tmpdir(), "stale-session-reconcile-sessions-"),
+			);
+			tempDirs.push(dbDir, sessionsDir);
+
+			const store = new SqliteSessionStore({ sessionsDir: dbDir });
+			stores.push(store);
+			const service = new CoreSessionService(store, {
+				sessionArtifactsDir: sessionsDir,
+			});
+			const sessionId = "stale-root-session";
+			const artifacts = await service.createRootSessionWithArtifacts({
+				sessionId,
+				source: SessionSource.CLI,
+				pid: 999_999_999,
+				interactive: false,
+				provider: "mock-provider",
+				model: "mock-model",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: false,
+				prompt: "hello",
+				startedAt: "2026-01-01T00:00:00.000Z",
+			});
+
+			const reconciled = await service.reconcileDeadSessions();
+			expect(reconciled).toBe(1);
+
+			const rows = await service.listSessions(10);
+			expect(rows).toHaveLength(1);
+			expect(rows[0]).toMatchObject({
+				sessionId,
+				status: "failed",
+				exitCode: 1,
+			});
+			expect(rows[0]?.endedAt).toBeTruthy();
+
+			const manifest = JSON.parse(
+				readFileSync(artifacts.manifestPath, "utf8"),
+			) as Record<string, unknown>;
+			expect(manifest.status).toBe("failed");
+			expect(manifest.exit_code).toBe(1);
+			expect(manifest.ended_at).toBeTruthy();
+			expect(manifest.metadata).toMatchObject({
+				terminal_marker: "failed_external_process_exit",
+				terminal_marker_pid: 999_999_999,
+				terminal_marker_source: "stale_session_reconciler",
+			});
+			expect(
+				(manifest.metadata as Record<string, unknown>).terminal_marker_at,
+			).toBeTruthy();
+
+			const globalHookLog = process.env.CLINE_HOOKS_LOG_PATH ?? "";
+			if (globalHookLog && existsSync(globalHookLog)) {
+				const hookContent = readFileSync(globalHookLog, "utf8");
+				expect(hookContent).toContain('"hookName":"session_shutdown"');
+				expect(hookContent).toContain(
+					'"reason":"failed_external_process_exit"',
+				);
+			}
+		},
+		15_000,
+	);
+
+	sqliteIt(
+		"persists teammate task metadata in the file envelope and usage on messages",
+		async () => {
+			const dbDir = mkdtempSync(join(tmpdir(), "team-task-messages-db-"));
+			const sessionsDir = mkdtempSync(join(tmpdir(), "team-task-messages-"));
+			tempDirs.push(dbDir, sessionsDir);
+
+			const store = new SqliteSessionStore({ sessionsDir: dbDir });
+			stores.push(store);
+			const service = new CoreSessionService(store, {
+				sessionArtifactsDir: sessionsDir,
+			});
+			const rootSessionId = "root-session";
+			await service.createRootSessionWithArtifacts({
+				sessionId: rootSessionId,
+				source: SessionSource.CLI,
+				pid: process.pid,
+				interactive: false,
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: true,
+				prompt: "lead task",
+				startedAt: "2026-04-10T19:00:00.000Z",
+			});
+
+			await service.onTeamTaskStart(
+				rootSessionId,
+				"java-haiku-agent",
+				"Write a haiku about Java",
+			);
+			await service.onTeamTaskEnd(
+				rootSessionId,
+				"java-haiku-agent",
+				"completed",
+				"[done] completed",
+				{
+					text: "Classes wrap the world\nWrite once, run on every machine —\nVerbose, yet it soars",
+					usage: {
+						inputTokens: 42,
+						outputTokens: 17,
+						cacheReadTokens: 9,
+						cacheWriteTokens: 0,
+						totalCost: 0.123,
+					},
+					messages: [
+						{
+							role: "user",
+							content: "Write a haiku about Java. Return only the haiku.",
+						},
+						{
+							role: "assistant",
+							content: [
+								{
+									type: "text",
+									text: "Classes wrap the world\nWrite once, run on every machine —\nVerbose, yet it soars",
+								},
+							],
+						},
+					],
+					toolCalls: [],
+					iterations: 1,
+					finishReason: "completed",
+					model: {
+						id: "claude-sonnet-4-6",
+						provider: "anthropic",
+						info: { id: "claude-sonnet-4-6" },
+					},
+					startedAt: new Date("2026-04-10T19:00:01.000Z"),
+					endedAt: new Date("2026-04-10T19:00:02.000Z"),
+					durationMs: 1000,
+				},
+			);
+
+			const childSessions = await service.listSessions(10);
+			const teammateSessionId = childSessions.find((row) =>
+				row.sessionId.includes("__teamtask__java-haiku-agent__"),
+			)?.sessionId;
+			expect(teammateSessionId).toBeTruthy();
+			const row = childSessions.find(
+				(item) => item.sessionId === teammateSessionId,
+			);
+			expect(row?.messagesPath).toBeTruthy();
+			const path = row?.messagesPath as string;
+			const payload = JSON.parse(readFileSync(path, "utf8")) as {
+				agent?: string;
+				sessionId?: string;
+				taskType?: string;
+				messages: Array<Record<string, unknown>>;
+			};
+			const user = payload.messages[0] as Record<string, unknown>;
+			const assistant = payload.messages[1] as Record<string, unknown>;
+
+			expect(payload.agent).toBe("teammate");
+			expect(payload.sessionId).toBe(rootSessionId);
+			expect(payload.taskType).toBe("team");
+			expect(assistant.id).toEqual(expect.any(String));
+			expect(user.agent).toBeUndefined();
+			expect(user.sessionId).toBeUndefined();
+			expect(assistant.agent).toBeUndefined();
+			expect(assistant.sessionId).toBeUndefined();
+			expect(assistant.modelInfo).toMatchObject({
+				id: "claude-sonnet-4-6",
+				provider: "anthropic",
+			});
+			expect(assistant.metrics).toMatchObject({
+				inputTokens: 42,
+				outputTokens: 17,
+				cacheReadTokens: 9,
+				cacheWriteTokens: 0,
+				cost: 0.123,
+			});
+			expect(row?.messagesPath).toBe(path);
+		},
+	);
+
+	it("persists plain spawn_agent result usage on child messages", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "spawn-agent-messages-"));
+		tempDirs.push(sessionsDir);
+
+		const service = new FileSessionService(sessionsDir);
+		const rootSessionId = "root-spawn-session";
+		await service.createRootSessionWithArtifacts({
+			sessionId: rootSessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: false,
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: true,
+			prompt: "lead task",
+			startedAt: "2026-04-10T19:00:00.000Z",
+		});
+
+		const context = {
+			subAgentId: "plain-worker",
+			conversationId: "conv-plain-worker",
+			parentAgentId: "lead",
+			input: {
+				systemPrompt: "You are a worker.",
+				task: "Summarize the repo.",
+			},
+		};
+		await service.handleSubAgentStart(rootSessionId, context);
+		await service.handleSubAgentEnd(rootSessionId, {
+			...context,
+			result: {
+				text: "Done",
+				iterations: 1,
+				finishReason: "completed",
+				usage: {
+					inputTokens: 11,
+					outputTokens: 3,
+				},
+			},
+			agentResult: {
+				text: "Done",
+				usage: {
+					inputTokens: 11,
+					outputTokens: 3,
+					cacheReadTokens: 4,
+					cacheWriteTokens: 2,
+					totalCost: 0.045,
+				},
+				messages: [
+					{ role: "user", content: "Summarize the repo." },
+					{ role: "assistant", content: "Done" },
+				],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+					info: { id: "claude-sonnet-4-6" },
+				},
+				startedAt: new Date("2026-04-10T19:00:01.000Z"),
+				endedAt: new Date("2026-04-10T19:00:02.000Z"),
+				durationMs: 1000,
+			},
+		});
+
+		const childSessions = await service.listSessions(10);
+		const row = childSessions.find((item) => item.agentId === "plain-worker");
+		expect(row?.status).toBe("completed");
+		expect(row?.messagesPath).toBeTruthy();
+		const payload = JSON.parse(
+			readFileSync(row?.messagesPath as string, "utf8"),
+		) as {
+			messages: Array<Record<string, unknown>>;
+		};
+		const assistant = payload.messages[1] as Record<string, unknown>;
+
+		expect(assistant.metrics).toMatchObject({
+			inputTokens: 11,
+			outputTokens: 3,
+			cacheReadTokens: 4,
+			cacheWriteTokens: 2,
+			cost: 0.045,
+		});
+	});
+
+	it("preserves an existing title when the stored prompt changes", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "prompt-title-sessions-"));
+		tempDirs.push(sessionsDir);
+
+		const service = new FileSessionService(sessionsDir);
+		const sessionId = "prompt-title-session";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: true,
+			provider: "mock-provider",
+			model: "mock-model",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			prompt: "first user message",
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		await expect(
+			service.updateSession({ sessionId, prompt: "second user message" }),
+		).resolves.toEqual({ updated: true });
+
+		const [row] = await service.listSessions(10);
+		expect(row?.prompt).toBe("second user message");
+		expect(row?.metadata).toMatchObject({ title: "first user message" });
+		const manifest = JSON.parse(
+			readFileSync(artifacts.manifestPath, "utf8"),
+		) as Record<string, unknown>;
+		expect(manifest.prompt).toBe("second user message");
+		expect(manifest.metadata).toMatchObject({ title: "first user message" });
+	});
+
+	it("derives a title from a prompt only when the session has no title yet", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "empty-title-sessions-"));
+		tempDirs.push(sessionsDir);
+
+		const service = new FileSessionService(sessionsDir);
+		const sessionId = "empty-title-session";
+		await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: true,
+			provider: "mock-provider",
+			model: "mock-model",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		await expect(
+			service.updateSession({ sessionId, prompt: "first saved prompt" }),
+		).resolves.toEqual({ updated: true });
+
+		const [row] = await service.listSessions(10);
+		expect(row?.metadata).toMatchObject({ title: "first saved prompt" });
+	});
+
+	sqliteIt(
+		"uploads messages after persisting them when a messages uploader is configured",
+		async () => {
+			const dbDir = mkdtempSync(join(tmpdir(), "messages-upload-db-"));
+			const sessionsDir = mkdtempSync(join(tmpdir(), "messages-upload-"));
+			tempDirs.push(dbDir, sessionsDir);
+
+			const store = new SqliteSessionStore({ sessionsDir: dbDir });
+			stores.push(store);
+			const uploadMessagesFile = vi.fn(async () => {});
+			const service = new CoreSessionService(store, {
+				sessionArtifactsDir: sessionsDir,
+				messagesArtifactUploader: {
+					uploadMessagesFile,
+				},
+			});
+			const sessionId = "root-upload-session";
+			await service.createRootSessionWithArtifacts({
+				sessionId,
+				source: SessionSource.CLI,
+				pid: process.pid,
+				interactive: false,
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: false,
+				enableTeams: false,
+				prompt: "hello",
+				metadata: {
+					blobUpload: true,
+				},
+				startedAt: "2026-04-10T19:00:00.000Z",
+			});
+
+			await service.persistSessionMessages(sessionId, [
+				{
+					role: "user",
+					content: "hello",
+				},
+			]);
+
+			expect(uploadMessagesFile).toHaveBeenCalledTimes(1);
+			expect(uploadMessagesFile).toHaveBeenCalledWith(
+				expect.objectContaining({
+					sessionId,
+					path: expect.stringContaining(`${sessionId}.messages.json`),
+					contents: expect.stringContaining('"role": "user"'),
+					row: expect.objectContaining({
+						sessionId,
+						metadata: {
+							blobUpload: true,
+							title: "hello",
+						},
+					}),
+				}),
+			);
+		},
+	);
+
+	sqliteIt(
+		"keeps failed message uploads out of user-facing console output",
+		async () => {
+			const dbDir = mkdtempSync(join(tmpdir(), "messages-upload-fail-db-"));
+			const sessionsDir = mkdtempSync(join(tmpdir(), "messages-upload-fail-"));
+			tempDirs.push(dbDir, sessionsDir);
+
+			const store = new SqliteSessionStore({ sessionsDir: dbDir });
+			stores.push(store);
+			const uploadError = new Error("upload denied");
+			const uploadMessagesFile = vi.fn(async () => {
+				throw uploadError;
+			});
+			const logger = {
+				debug: vi.fn(),
+				log: vi.fn(),
+			};
+			const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+			const service = new CoreSessionService(store, {
+				sessionArtifactsDir: sessionsDir,
+				messagesArtifactUploader: {
+					uploadMessagesFile,
+				},
+				logger,
+			});
+			const sessionId = "root-upload-fail-session";
+			await service.createRootSessionWithArtifacts({
+				sessionId,
+				source: SessionSource.CLI,
+				pid: process.pid,
+				interactive: false,
+				provider: "openrouter",
+				model: "qwen/qwen3.6-plus",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: false,
+				enableTeams: false,
+				prompt: "hello",
+				startedAt: "2026-04-10T19:00:00.000Z",
+			});
+
+			try {
+				await expect(
+					service.persistSessionMessages(sessionId, [
+						{
+							role: "user",
+							content: "hello",
+						},
+					]),
+				).resolves.toBeUndefined();
+				expect(warn).not.toHaveBeenCalled();
+			} finally {
+				warn.mockRestore();
+			}
+
+			expect(uploadMessagesFile).toHaveBeenCalledTimes(1);
+			expect(logger.debug).toHaveBeenCalledWith(
+				"Failed to upload persisted session messages",
+				{
+					sessionId,
+					error: uploadError,
+				},
+			);
+		},
+	);
+
+	sqliteIt(
+		"deletes the full root session directory even when artifact paths are stale",
+		async () => {
+			const dbDir = mkdtempSync(join(tmpdir(), "delete-root-session-dir-db-"));
+			const sessionsDir = mkdtempSync(
+				join(tmpdir(), "delete-root-session-dir-"),
+			);
+			tempDirs.push(dbDir, sessionsDir);
+
+			const store = new SqliteSessionStore({ sessionsDir: dbDir });
+			stores.push(store);
+			const service = new CoreSessionService(store, {
+				sessionArtifactsDir: sessionsDir,
+			});
+			const sessionId = "root-session-delete";
+			const artifacts = await service.createRootSessionWithArtifacts({
+				sessionId,
+				source: SessionSource.CLI,
+				pid: process.pid,
+				interactive: false,
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: false,
+				enableTeams: false,
+				prompt: "delete me",
+				startedAt: "2026-04-10T19:00:00.000Z",
+			});
+
+			store.run(
+				`UPDATE sessions SET messages_path = NULL WHERE session_id = ?`,
+				[sessionId],
+			);
+
+			expect(existsSync(artifacts.messagesPath)).toBe(true);
+			expect(existsSync(join(sessionsDir, sessionId))).toBe(true);
+
+			const result = await service.deleteSession(sessionId);
+
+			expect(result).toEqual({ deleted: true });
+			expect(existsSync(artifacts.messagesPath)).toBe(false);
+			expect(existsSync(join(sessionsDir, sessionId))).toBe(false);
+		},
+	);
+
+	sqliteIt(
+		"deletes a session when compaction sidecar cleanup fails",
+		async () => {
+			const dbDir = mkdtempSync(join(tmpdir(), "delete-sidecar-fail-db-"));
+			const sessionsDir = mkdtempSync(
+				join(tmpdir(), "delete-sidecar-fail-sessions-"),
+			);
+			tempDirs.push(dbDir, sessionsDir);
+
+			const store = new SqliteSessionStore({ sessionsDir: dbDir });
+			stores.push(store);
+			const service = new CoreSessionService(store, {
+				sessionArtifactsDir: sessionsDir,
+			});
+			const sessionId = "sidecar-delete-fail-session";
+			await service.createRootSessionWithArtifacts({
+				sessionId,
+				source: SessionSource.CLI,
+				pid: process.pid,
+				interactive: false,
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: false,
+				enableTeams: false,
+				prompt: "delete me",
+				startedAt: "2026-04-10T19:00:00.000Z",
+			});
+			const manifestStore = (
+				service as unknown as {
+					manifestStore: {
+						deleteSessionCompactionState: (sessionId: string) => Promise<void>;
+					};
+				}
+			).manifestStore;
+			const deleteSidecar = vi
+				.spyOn(manifestStore, "deleteSessionCompactionState")
+				.mockRejectedValue(new Error("sidecar busy"));
+
+			const result = await service.deleteSession(sessionId);
+
+			expect(result).toEqual({ deleted: true });
+			await expect(service.listSessions(10)).resolves.not.toEqual(
+				expect.arrayContaining([expect.objectContaining({ sessionId })]),
+			);
+			expect(deleteSidecar).toHaveBeenCalledWith(sessionId);
+		},
+	);
+});
diff --git a/sdk/packages/core/src/session/services/persistence-service.ts b/sdk/packages/core/src/session/services/persistence-service.ts
new file mode 100644
index 0000000..2914317
--- /dev/null
+++ b/sdk/packages/core/src/session/services/persistence-service.ts
@@ -0,0 +1,618 @@
+import { dirname } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult, BasicLogger } from "@cline/shared";
+import { nanoid } from "nanoid";
+import type {
+	SubAgentEndContext,
+	SubAgentStartContext,
+} from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import { deleteCheckpointRefs } from "../../hooks/checkpoint-hooks";
+import { nowIso, unlinkIfExists } from "../../services/session-artifacts";
+import {
+	buildManifestFromRow,
+	deriveTitleFromPrompt,
+	normalizeStoredMessagesForPersistence,
+	normalizeTitle,
+	resolveMetadataWithTitle,
+	sanitizeMetadata,
+	withLatestAssistantTurnMetadata,
+	withOccRetry,
+} from "../../services/session-data";
+import {
+	isNonTerminalSessionStatus,
+	type SessionStatus,
+	type TerminalSessionStatus,
+} from "../../types/common";
+import type {
+	PersistedSessionUpdateInput,
+	SessionMessagesArtifactUploader,
+	SessionPersistenceAdapter,
+	StoredMessageWithMetadata,
+} from "../../types/session";
+import type { SessionCompactionState } from "../models/session-compaction";
+import type { SessionRow } from "../models/session-row";
+import { SessionManifestStore } from "../stores/session-manifest-store";
+import { TeamChildSessionManager } from "../team";
+
+export type { PersistedSessionUpdateInput, SessionPersistenceAdapter };
+
+const OCC_MAX_RETRIES = 4;
+
+export class UnifiedSessionPersistenceService {
+	private readonly manifestStore: SessionManifestStore;
+	private readonly teamChildren: TeamChildSessionManager;
+	private static readonly STALE_REASON = "failed_external_process_exit";
+	private static readonly STALE_SOURCE = "stale_session_reconciler";
+	private static readonly TEAM_HEARTBEAT_LOG_INTERVAL_MS = 30_000;
+
+	constructor(
+		private readonly adapter: SessionPersistenceAdapter,
+		options: {
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+			logger?: BasicLogger;
+		} = {},
+	) {
+		this.manifestStore = new SessionManifestStore(
+			adapter,
+			options.messagesArtifactUploader,
+			options.logger,
+		);
+		this.teamChildren = new TeamChildSessionManager(
+			adapter,
+			this.manifestStore,
+			(messages, result, previousMessages) =>
+				this.toPersistedMessages(messages, result, previousMessages),
+			UnifiedSessionPersistenceService.TEAM_HEARTBEAT_LOG_INTERVAL_MS,
+		);
+	}
+
+	private toPersistedMessages(
+		messages: LlmsProviders.Message[] | undefined,
+		result?: AgentResult,
+		previousMessages?: LlmsProviders.Message[],
+	): StoredMessageWithMetadata[] | undefined {
+		if (!messages) return undefined;
+		return result
+			? withLatestAssistantTurnMetadata(
+					result.messages,
+					result,
+					previousMessages as LlmsProviders.MessageWithMetadata[] | undefined,
+				)
+			: normalizeStoredMessagesForPersistence(
+					messages as LlmsProviders.MessageWithMetadata[],
+				);
+	}
+
+	ensureSessionsDir(): string {
+		return this.manifestStore.ensureSessionsDir();
+	}
+
+	writeSessionManifest(
+		manifestPath: string,
+		manifest: import("../models/session-manifest").SessionManifest,
+	): void {
+		this.manifestStore.writeSessionManifest(manifestPath, manifest);
+	}
+
+	readSessionManifest(
+		sessionId: string,
+	): import("../models/session-manifest").SessionManifest | undefined {
+		return this.manifestStore.readSessionManifest(sessionId);
+	}
+
+	async createRootSessionWithArtifacts(
+		input: import("../models/session-row").CreateRootSessionWithArtifactsInput,
+	): Promise<import("../models/session-row").RootSessionArtifacts> {
+		const startedAt = input.startedAt ?? nowIso();
+		const providedId = input.sessionId.trim();
+		const sessionId =
+			providedId.length > 0 ? providedId : `${Date.now()}_${nanoid(5)}`;
+		const messagesPath =
+			this.manifestStore.artifacts.sessionMessagesPath(sessionId);
+		const compactionPath =
+			this.manifestStore.artifacts.sessionCompactionPath(sessionId);
+		const manifestPath =
+			this.manifestStore.artifacts.sessionManifestPath(sessionId);
+		const metadata = resolveMetadataWithTitle({
+			metadata: input.metadata,
+			prompt: input.prompt,
+		});
+		const manifest = {
+			version: 1 as const,
+			session_id: sessionId,
+			source: input.source,
+			pid: input.pid,
+			started_at: startedAt,
+			status: "running" as const,
+			interactive: input.interactive,
+			provider: input.provider,
+			model: input.model,
+			cwd: input.cwd,
+			workspace_root: input.workspaceRoot,
+			team_name: input.teamName,
+			enable_tools: input.enableTools,
+			enable_spawn: input.enableSpawn,
+			enable_teams: input.enableTeams,
+			prompt: input.prompt?.trim() || undefined,
+			metadata,
+			messages_path: messagesPath,
+		};
+
+		await this.adapter.upsertSession({
+			sessionId,
+			source: input.source,
+			pid: input.pid,
+			startedAt,
+			endedAt: null,
+			exitCode: null,
+			status: "running",
+			statusLock: 0,
+			interactive: input.interactive,
+			provider: input.provider,
+			model: input.model,
+			cwd: input.cwd,
+			workspaceRoot: input.workspaceRoot,
+			teamName: input.teamName ?? null,
+			enableTools: input.enableTools,
+			enableSpawn: input.enableSpawn,
+			enableTeams: input.enableTeams,
+			parentSessionId: null,
+			parentAgentId: null,
+			agentId: null,
+			conversationId: null,
+			isSubagent: false,
+			prompt: manifest.prompt ?? null,
+			metadata: sanitizeMetadata(manifest.metadata),
+			hookPath: "",
+			messagesPath,
+			updatedAt: nowIso(),
+		});
+
+		this.manifestStore.initializeMessagesFile(
+			sessionId,
+			messagesPath,
+			startedAt,
+		);
+		this.manifestStore.writeSessionManifest(manifestPath, manifest);
+		return { manifestPath, messagesPath, compactionPath, manifest };
+	}
+
+	async updateSessionStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): Promise<{ updated: boolean; endedAt?: string }> {
+		let endedAt: string | undefined;
+		const result = await withOccRetry(
+			() => this.adapter.getSession(sessionId),
+			async (row) => {
+				endedAt = isNonTerminalSessionStatus(status) ? undefined : nowIso();
+				return this.adapter.updateSession({
+					sessionId,
+					status,
+					endedAt: endedAt ?? null,
+					exitCode: isNonTerminalSessionStatus(status)
+						? null
+						: typeof exitCode === "number"
+							? exitCode
+							: null,
+					expectedStatusLock: row.statusLock,
+				});
+			},
+			OCC_MAX_RETRIES,
+		);
+		if (result.updated) {
+			if (status === "cancelled") {
+				await this.teamChildren.applyStatusToRunningChildSessions(
+					sessionId,
+					"cancelled",
+				);
+			}
+			return { updated: true, endedAt };
+		}
+		return { updated: false };
+	}
+
+	async updateSession(input: {
+		sessionId: string;
+		prompt?: string | null;
+		metadata?: Record<string, unknown> | null;
+		title?: string | null;
+	}): Promise<{ updated: boolean }> {
+		for (let attempt = 0; attempt < OCC_MAX_RETRIES; attempt++) {
+			const row = await this.adapter.getSession(input.sessionId);
+			if (!row) return { updated: false };
+
+			const existingMeta = row.metadata ?? undefined;
+			const baseMeta =
+				input.metadata !== undefined
+					? (sanitizeMetadata(input.metadata) ?? {})
+					: (sanitizeMetadata(existingMeta) ?? {});
+
+			const existingTitle = normalizeTitle(
+				typeof existingMeta?.title === "string"
+					? (existingMeta.title as string)
+					: undefined,
+			);
+			const nextTitle =
+				input.title !== undefined
+					? normalizeTitle(input.title)
+					: (existingTitle ?? deriveTitleFromPrompt(input.prompt));
+
+			if (nextTitle) {
+				baseMeta.title = nextTitle;
+			} else {
+				delete baseMeta.title;
+			}
+
+			const hasMetadataChange =
+				input.metadata !== undefined ||
+				input.prompt !== undefined ||
+				input.title !== undefined;
+
+			const changed = await this.adapter.updateSession({
+				sessionId: input.sessionId,
+				prompt: input.prompt,
+				metadata: hasMetadataChange
+					? Object.keys(baseMeta).length > 0
+						? baseMeta
+						: null
+					: undefined,
+				title: nextTitle,
+				expectedStatusLock: row.statusLock,
+			});
+			if (!changed.updated) continue;
+
+			const { path: manifestPath, manifest } =
+				this.manifestStore.readManifestFile(input.sessionId);
+			if (manifest) {
+				if (input.prompt !== undefined) {
+					manifest.prompt = input.prompt ?? undefined;
+				}
+				const manifestMeta =
+					input.metadata !== undefined
+						? (sanitizeMetadata(input.metadata) ?? {})
+						: (sanitizeMetadata(manifest.metadata) ?? {});
+				if (nextTitle) manifestMeta.title = nextTitle;
+				manifest.metadata =
+					Object.keys(manifestMeta).length > 0 ? manifestMeta : undefined;
+				this.manifestStore.writeSessionManifest(manifestPath, manifest);
+			}
+			return { updated: true };
+		}
+		return { updated: false };
+	}
+
+	queueSpawnRequest(event: HookEventPayload): Promise<void> {
+		return this.teamChildren.queueSpawnRequest(event);
+	}
+
+	upsertSubagentSession(
+		input: import("../models/session-row").UpsertSubagentInput,
+	): Promise<string | undefined> {
+		return this.teamChildren.upsertSubagentSession(input);
+	}
+
+	upsertSubagentSessionFromHook(
+		event: HookEventPayload,
+	): Promise<string | undefined> {
+		return this.teamChildren.upsertSubagentSessionFromHook(event);
+	}
+
+	appendSubagentHookAudit(
+		_subSessionId: string,
+		event: HookEventPayload,
+	): Promise<void> {
+		this.teamChildren.appendSubagentHookAudit(event);
+		return Promise.resolve();
+	}
+
+	persistSessionMessages(
+		sessionId: string,
+		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
+	): Promise<void> {
+		const normalizedMessages = normalizeStoredMessagesForPersistence(
+			messages as LlmsProviders.MessageWithMetadata[],
+		);
+		return this.manifestStore.persistSessionMessages(
+			sessionId,
+			normalizedMessages,
+			systemPrompt,
+		);
+	}
+
+	async readSessionCompactionState(
+		sessionId: string,
+	): Promise<SessionCompactionState | undefined> {
+		return await this.manifestStore.readSessionCompactionState(sessionId);
+	}
+
+	async persistSessionCompactionState(
+		sessionId: string,
+		state: SessionCompactionState,
+	): Promise<void> {
+		await this.manifestStore.persistSessionCompactionState(sessionId, state);
+	}
+
+	async deleteSessionCompactionState(sessionId: string): Promise<void> {
+		await this.manifestStore.deleteSessionCompactionState(sessionId);
+	}
+
+	applySubagentStatus(
+		subSessionId: string,
+		event: HookEventPayload,
+	): Promise<void> {
+		return this.teamChildren.applySubagentStatus(subSessionId, event);
+	}
+
+	applySubagentStatusBySessionId(
+		subSessionId: string,
+		status: SessionStatus,
+	): Promise<void> {
+		return this.teamChildren.applySubagentStatusBySessionId(
+			subSessionId,
+			status,
+		);
+	}
+
+	applyStatusToRunningChildSessions(
+		parentSessionId: string,
+		status: TerminalSessionStatus,
+	): Promise<void> {
+		return this.teamChildren.applyStatusToRunningChildSessions(
+			parentSessionId,
+			status,
+		);
+	}
+
+	onTeamTaskStart(
+		rootSessionId: string,
+		agentId: string,
+		message: string,
+	): Promise<void> {
+		return this.teamChildren.onTeamTaskStart(rootSessionId, agentId, message);
+	}
+
+	onTeamTaskEnd(
+		rootSessionId: string,
+		agentId: string,
+		status: SessionStatus,
+		summary?: string,
+		result?: AgentResult,
+		messages?: LlmsProviders.Message[],
+	): Promise<void> {
+		return this.teamChildren.onTeamTaskEnd(
+			rootSessionId,
+			agentId,
+			status,
+			summary,
+			result,
+			messages,
+		);
+	}
+
+	onTeamTaskProgress(
+		rootSessionId: string,
+		agentId: string,
+		progress: string,
+		options?: { kind?: "heartbeat" | "progress" | "text" },
+	): Promise<void> {
+		return this.teamChildren.onTeamTaskProgress(
+			rootSessionId,
+			agentId,
+			progress,
+			options,
+		);
+	}
+
+	handleSubAgentStart(
+		rootSessionId: string,
+		context: SubAgentStartContext,
+	): Promise<void> {
+		return this.teamChildren.handleSubAgentStart(rootSessionId, context);
+	}
+
+	handleSubAgentEnd(
+		rootSessionId: string,
+		context: SubAgentEndContext,
+	): Promise<void> {
+		return this.teamChildren.handleSubAgentEnd(rootSessionId, context);
+	}
+
+	private isPidAlive(pid: number): boolean {
+		if (!Number.isFinite(pid) || pid <= 0) return false;
+		try {
+			process.kill(Math.floor(pid), 0);
+			return true;
+		} catch (error) {
+			return (
+				typeof error === "object" &&
+				error !== null &&
+				"code" in error &&
+				(error as { code?: string }).code === "EPERM"
+			);
+		}
+	}
+
+	private async reconcileDeadRunningSession(
+		row: SessionRow,
+	): Promise<SessionRow | undefined> {
+		if (
+			isNonTerminalSessionStatus(row.status) === false ||
+			this.isPidAlive(row.pid)
+		) {
+			return row;
+		}
+
+		const detectedAt = nowIso();
+		const reason = UnifiedSessionPersistenceService.STALE_REASON;
+
+		for (let attempt = 0; attempt < OCC_MAX_RETRIES; attempt++) {
+			const latest = await this.adapter.getSession(row.sessionId);
+			if (!latest) return undefined;
+			if (isNonTerminalSessionStatus(latest.status) === false) return latest;
+
+			const nextMetadata = {
+				...(latest.metadata ?? {}),
+				terminal_marker: reason,
+				terminal_marker_at: detectedAt,
+				terminal_marker_pid: latest.pid,
+				terminal_marker_source: UnifiedSessionPersistenceService.STALE_SOURCE,
+			};
+
+			const changed = await this.adapter.updateSession({
+				sessionId: latest.sessionId,
+				status: "failed",
+				endedAt: detectedAt,
+				exitCode: 1,
+				metadata: nextMetadata,
+				expectedStatusLock: latest.statusLock,
+			});
+			if (!changed.updated) continue;
+
+			await this.teamChildren.applyStatusToRunningChildSessions(
+				latest.sessionId,
+				"failed",
+			);
+
+			const manifest = buildManifestFromRow(latest, {
+				status: "failed",
+				endedAt: detectedAt,
+				exitCode: 1,
+				metadata: nextMetadata,
+			});
+			const { path: manifestPath } = this.manifestStore.readManifestFile(
+				latest.sessionId,
+			);
+			this.manifestStore.writeSessionManifest(manifestPath, manifest);
+			this.manifestStore.appendStaleSessionHookLog(
+				detectedAt,
+				latest.sessionId,
+				latest.pid,
+				reason,
+				UnifiedSessionPersistenceService.STALE_SOURCE,
+			);
+			return {
+				...latest,
+				status: "failed",
+				endedAt: detectedAt,
+				exitCode: 1,
+				metadata: nextMetadata,
+				statusLock: changed.statusLock,
+				updatedAt: detectedAt,
+			};
+		}
+		return await this.adapter.getSession(row.sessionId);
+	}
+
+	async listSessions(limit = 200): Promise<SessionRow[]> {
+		const requestedLimit = Math.max(1, Math.floor(limit));
+		const scanLimit = Math.min(requestedLimit * 5, 2000);
+		await this.reconcileDeadSessions(scanLimit);
+
+		const rows = (await this.adapter.listSessions({ limit: scanLimit })).slice(
+			0,
+			requestedLimit,
+		);
+		// Resolve manifest titles concurrently and off-thread. Each row only needs
+		// the manifest's `metadata.title`, so read just that asynchronously instead
+		// of synchronously reading + Zod-parsing the entire manifest per row.
+		const manifestTitles = await Promise.all(
+			rows.map((row) =>
+				this.manifestStore.readSessionManifestTitle(row.sessionId),
+			),
+		);
+		return rows.map((row, index) => {
+			const meta = sanitizeMetadata(row.metadata ?? undefined);
+			const manifestTitle = normalizeTitle(manifestTitles[index]);
+			const resolved = manifestTitle
+				? { ...(meta ?? {}), title: manifestTitle }
+				: meta;
+			return { ...row, metadata: resolved };
+		});
+	}
+
+	async reconcileDeadSessions(limit = 2000): Promise<number> {
+		const requestedLimit = Math.max(1, Math.floor(limit));
+		const rows = (
+			await Promise.all(
+				(["idle", "running", "pending"] as const).map((status) =>
+					this.adapter.listSessions({
+						limit: requestedLimit,
+						status,
+					}),
+				),
+			)
+		).flat();
+		let reconciled = 0;
+		for (const row of rows) {
+			const updated = await this.reconcileDeadRunningSession(row);
+			if (updated && updated.status !== row.status) reconciled++;
+		}
+		return reconciled;
+	}
+
+	async deleteSession(sessionId: string): Promise<{ deleted: boolean }> {
+		const id = sessionId.trim();
+		if (!id) throw new Error("session id is required");
+
+		const row = await this.adapter.getSession(id);
+		if (!row) return { deleted: false };
+
+		await this.adapter.deleteSession(id, false);
+
+		if (!row.isSubagent) {
+			const children = await this.adapter.listSessions({
+				limit: 2000,
+				parentSessionId: id,
+			});
+			await this.adapter.deleteSession(id, true);
+			await Promise.allSettled(
+				children.map(async (child) => {
+					await deleteCheckpointRefs(child.cwd, child.sessionId);
+					unlinkIfExists(child.messagesPath);
+					await this.deleteSessionCompactionStateIfExists(child.sessionId);
+					unlinkIfExists(
+						this.manifestStore.artifacts.sessionManifestPath(
+							child.sessionId,
+							false,
+						),
+					);
+					this.manifestStore.artifacts.removeSessionDirIfEmpty(child.sessionId);
+				}),
+			);
+		}
+
+		await deleteCheckpointRefs(row.cwd, id);
+
+		unlinkIfExists(row.messagesPath);
+		await this.deleteSessionCompactionStateIfExists(id);
+		unlinkIfExists(this.manifestStore.artifacts.sessionManifestPath(id, false));
+		if (row.isSubagent) {
+			this.manifestStore.artifacts.removeSessionDirIfEmpty(id);
+		} else {
+			const candidateDirs = new Set<string>([
+				this.manifestStore.artifacts.sessionArtifactsDir(id),
+			]);
+			for (const path of [row.messagesPath]) {
+				if (typeof path === "string" && path.trim().length > 0) {
+					candidateDirs.add(dirname(path));
+				}
+			}
+			for (const dir of candidateDirs) {
+				this.manifestStore.artifacts.removeDir(dir);
+			}
+		}
+		return { deleted: true };
+	}
+
+	private async deleteSessionCompactionStateIfExists(
+		sessionId: string,
+	): Promise<void> {
+		try {
+			await this.manifestStore.deleteSessionCompactionState(sessionId);
+		} catch {}
+	}
+}
diff --git a/sdk/packages/core/src/session/services/session-service.team-persistence.test.ts b/sdk/packages/core/src/session/services/session-service.team-persistence.test.ts
new file mode 100644
index 0000000..a03ed71
--- /dev/null
+++ b/sdk/packages/core/src/session/services/session-service.team-persistence.test.ts
@@ -0,0 +1,48 @@
+import { existsSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { AgentTeamsRuntime } from "../../extensions/tools/team";
+import { FileTeamPersistenceStore } from "../stores/team-persistence-store";
+
+describe("FileTeamPersistenceStore", () => {
+	it("does not create state.json for an empty runtime", () => {
+		const baseDir = mkdtempSync(join(tmpdir(), "team-store-"));
+		const store = new FileTeamPersistenceStore({
+			teamName: "agent-team-nmnn9",
+			baseDir,
+		});
+		const runtime = new AgentTeamsRuntime({ teamName: "agent-team-nmnn9" });
+
+		store.persist(runtime);
+
+		expect(
+			existsSync(join(baseDir, "agent-team-nmnn9", "state.json")),
+		).toBeFalsy();
+	});
+
+	it("removes persisted state when runtime becomes empty again", () => {
+		const baseDir = mkdtempSync(join(tmpdir(), "team-store-"));
+		const store = new FileTeamPersistenceStore({
+			teamName: "agent-team-cleanup",
+			baseDir,
+		});
+		const runtime = new AgentTeamsRuntime({ teamName: "agent-team-cleanup" });
+
+		store.upsertTeammateSpec({
+			agentId: "worker",
+			rolePrompt: "Implement tasks",
+		});
+		store.persist(runtime);
+		expect(
+			existsSync(join(baseDir, "agent-team-cleanup", "state.json")),
+		).toBeTruthy();
+
+		store.removeTeammateSpec("worker");
+		runtime.cleanup();
+		store.persist(runtime);
+		expect(
+			existsSync(join(baseDir, "agent-team-cleanup", "state.json")),
+		).toBeFalsy();
+	});
+});
diff --git a/sdk/packages/core/src/session/services/session-service.ts b/sdk/packages/core/src/session/services/session-service.ts
new file mode 100644
index 0000000..15ac067
--- /dev/null
+++ b/sdk/packages/core/src/session/services/session-service.ts
@@ -0,0 +1,326 @@
+import { existsSync, mkdirSync } from "node:fs";
+import type { BasicLogger } from "@cline/shared";
+import { resolveSessionDataDir } from "@cline/shared/storage";
+import { nowIso } from "../../services/session-artifacts";
+import type { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import {
+	type CreateRootSessionInput,
+	patchSqliteRow,
+	SESSION_SELECT_COLUMNS,
+	type SessionRow,
+	stringifyMetadata,
+} from "../models/session-row";
+import type {
+	PersistedSessionUpdateInput,
+	SessionPersistenceAdapter,
+} from "./persistence-service";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+
+class LocalSessionPersistenceAdapter implements SessionPersistenceAdapter {
+	constructor(
+		private readonly store: SqliteSessionStore,
+		private readonly sessionsDirPath: string = resolveSessionDataDir(),
+	) {}
+
+	ensureSessionsDir(): string {
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
+	}
+
+	async upsertSession(row: SessionRow): Promise<void> {
+		this.store.run(
+			`INSERT OR REPLACE INTO sessions (
+				session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
+				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
+				metadata_json, transcript_path, hook_path, messages_path, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			[
+				row.sessionId,
+				row.source,
+				row.pid,
+				row.startedAt,
+				row.endedAt ?? null,
+				row.exitCode ?? null,
+				row.status,
+				row.statusLock,
+				row.interactive ? 1 : 0,
+				row.provider,
+				row.model,
+				row.cwd,
+				row.workspaceRoot,
+				row.teamName ?? null,
+				row.enableTools ? 1 : 0,
+				row.enableSpawn ? 1 : 0,
+				row.enableTeams ? 1 : 0,
+				row.parentSessionId ?? null,
+				row.parentAgentId ?? null,
+				row.agentId ?? null,
+				row.conversationId ?? null,
+				row.isSubagent ? 1 : 0,
+				row.prompt ?? null,
+				stringifyMetadata(row.metadata),
+				"",
+				row.hookPath ?? "",
+				row.messagesPath ?? null,
+				row.updatedAt,
+			],
+		);
+	}
+
+	async getSession(sessionId: string): Promise<SessionRow | undefined> {
+		const row = this.store.queryOne<Record<string, unknown>>(
+			`SELECT ${SESSION_SELECT_COLUMNS} FROM sessions WHERE session_id = ?`,
+			[sessionId],
+		);
+		return row ? patchSqliteRow(row) : undefined;
+	}
+
+	async listSessions(options: {
+		limit: number;
+		parentSessionId?: string;
+		status?: string;
+	}): Promise<SessionRow[]> {
+		const whereClauses: string[] = [];
+		const params: unknown[] = [];
+		if (options.parentSessionId) {
+			whereClauses.push("parent_session_id = ?");
+			params.push(options.parentSessionId);
+		}
+		if (options.status) {
+			whereClauses.push("status = ?");
+			params.push(options.status);
+		}
+		const where =
+			whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+		return this.store
+			.queryAll<Record<string, unknown>>(
+				`SELECT ${SESSION_SELECT_COLUMNS}
+				 FROM sessions
+				 ${where}
+				 ORDER BY started_at DESC
+				 LIMIT ?`,
+				[...params, options.limit],
+			)
+			.map(patchSqliteRow);
+	}
+
+	async updateSession(
+		input: PersistedSessionUpdateInput,
+	): Promise<{ updated: boolean; statusLock: number }> {
+		if (input.setRunning) {
+			if (input.expectedStatusLock === undefined) {
+				return { updated: false, statusLock: 0 };
+			}
+			const changed = this.store.run(
+				`UPDATE sessions
+				 SET status = 'running', ended_at = NULL, exit_code = NULL, updated_at = ?, status_lock = ?,
+					 parent_session_id = ?, parent_agent_id = ?, agent_id = ?, conversation_id = ?, is_subagent = 1,
+					 prompt = COALESCE(prompt, ?)
+				 WHERE session_id = ? AND status_lock = ?`,
+				[
+					nowIso(),
+					input.expectedStatusLock + 1,
+					input.parentSessionId ?? null,
+					input.parentAgentId ?? null,
+					input.agentId ?? null,
+					input.conversationId ?? null,
+					input.prompt ?? null,
+					input.sessionId,
+					input.expectedStatusLock,
+				],
+			);
+			return {
+				updated: (changed.changes ?? 0) > 0,
+				statusLock: input.expectedStatusLock + 1,
+			};
+		}
+
+		const fields: string[] = [];
+		const params: unknown[] = [];
+		if (input.status !== undefined) {
+			fields.push("status = ?");
+			params.push(input.status);
+		}
+		if (input.endedAt !== undefined) {
+			fields.push("ended_at = ?");
+			params.push(input.endedAt);
+		}
+		if (input.exitCode !== undefined) {
+			fields.push("exit_code = ?");
+			params.push(input.exitCode);
+		}
+		if (input.prompt !== undefined) {
+			fields.push("prompt = ?");
+			params.push(input.prompt ?? null);
+		}
+		if (input.metadata !== undefined) {
+			fields.push("metadata_json = ?");
+			params.push(stringifyMetadata(input.metadata));
+		}
+		if (input.parentSessionId !== undefined) {
+			fields.push("parent_session_id = ?");
+			params.push(input.parentSessionId ?? null);
+		}
+		if (input.parentAgentId !== undefined) {
+			fields.push("parent_agent_id = ?");
+			params.push(input.parentAgentId ?? null);
+		}
+		if (input.agentId !== undefined) {
+			fields.push("agent_id = ?");
+			params.push(input.agentId ?? null);
+		}
+		if (input.conversationId !== undefined) {
+			fields.push("conversation_id = ?");
+			params.push(input.conversationId ?? null);
+		}
+		if (fields.length === 0) {
+			const row = await this.getSession(input.sessionId);
+			return { updated: !!row, statusLock: row?.statusLock ?? 0 };
+		}
+
+		let statusLock = 0;
+		if (input.expectedStatusLock !== undefined) {
+			statusLock = input.expectedStatusLock + 1;
+			fields.push("status_lock = ?");
+			params.push(statusLock);
+		}
+		fields.push("updated_at = ?");
+		params.push(nowIso());
+
+		let sql = `UPDATE sessions SET ${fields.join(", ")} WHERE session_id = ?`;
+		params.push(input.sessionId);
+		if (input.expectedStatusLock !== undefined) {
+			sql += " AND status_lock = ?";
+			params.push(input.expectedStatusLock);
+		}
+		const changed = this.store.run(sql, params);
+		if ((changed.changes ?? 0) === 0) {
+			return { updated: false, statusLock: 0 };
+		}
+		if (input.expectedStatusLock === undefined) {
+			const row = await this.getSession(input.sessionId);
+			statusLock = row?.statusLock ?? 0;
+		}
+		return { updated: true, statusLock };
+	}
+
+	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
+		const changed =
+			this.store.run(`DELETE FROM sessions WHERE session_id = ?`, [sessionId])
+				.changes ?? 0;
+		if (cascade) {
+			this.store.run(`DELETE FROM sessions WHERE parent_session_id = ?`, [
+				sessionId,
+			]);
+		}
+		return changed > 0;
+	}
+
+	async enqueueSpawnRequest(input: {
+		rootSessionId: string;
+		parentAgentId: string;
+		task?: string;
+		systemPrompt?: string;
+	}): Promise<void> {
+		this.store.run(
+			`INSERT INTO subagent_spawn_queue (root_session_id, parent_agent_id, task, system_prompt, created_at, consumed_at)
+			 VALUES (?, ?, ?, ?, ?, NULL)`,
+			[
+				input.rootSessionId,
+				input.parentAgentId,
+				input.task ?? null,
+				input.systemPrompt ?? null,
+				nowIso(),
+			],
+		);
+	}
+
+	async claimSpawnRequest(
+		rootSessionId: string,
+		parentAgentId: string,
+	): Promise<string | undefined> {
+		const row = this.store.queryOne<{ id?: number; task?: string | null }>(
+			`SELECT id, task FROM subagent_spawn_queue
+			 WHERE root_session_id = ? AND parent_agent_id = ? AND consumed_at IS NULL
+			 ORDER BY id ASC LIMIT 1`,
+			[rootSessionId, parentAgentId],
+		);
+		if (!row || typeof row.id !== "number") {
+			return undefined;
+		}
+		this.store.run(
+			`UPDATE subagent_spawn_queue SET consumed_at = ? WHERE id = ?`,
+			[nowIso(), row.id],
+		);
+		return row.task ?? undefined;
+	}
+}
+
+export class CoreSessionService extends UnifiedSessionPersistenceService {
+	constructor(
+		private readonly store: SqliteSessionStore,
+		options: {
+			sessionArtifactsDir?: string;
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+			logger?: BasicLogger;
+		} = {},
+	) {
+		super(
+			new LocalSessionPersistenceAdapter(store, options.sessionArtifactsDir),
+			options,
+		);
+	}
+
+	createRootSession(input: CreateRootSessionInput): void {
+		this.store.run(
+			`INSERT OR REPLACE INTO sessions (
+				session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
+				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
+				metadata_json, transcript_path, hook_path, messages_path, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			[
+				input.sessionId,
+				input.source,
+				input.pid,
+				input.startedAt,
+				null,
+				null,
+				"running",
+				0,
+				input.interactive ? 1 : 0,
+				input.provider,
+				input.model,
+				input.cwd,
+				input.workspaceRoot,
+				input.teamName ?? null,
+				input.enableTools ? 1 : 0,
+				input.enableSpawn ? 1 : 0,
+				input.enableTeams ? 1 : 0,
+				null,
+				null,
+				null,
+				null,
+				0,
+				input.prompt ?? null,
+				input.metadata ? JSON.stringify(input.metadata) : null,
+				"",
+				"",
+				input.messagesPath,
+				nowIso(),
+			],
+		);
+	}
+}
+
+export type {
+	CreateRootSessionInput,
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+	SessionRow,
+	UpsertSubagentInput,
+} from "../models/session-row";
diff --git a/sdk/packages/core/src/session/session-snapshot.ts b/sdk/packages/core/src/session/session-snapshot.ts
new file mode 100644
index 0000000..01f0d11
--- /dev/null
+++ b/sdk/packages/core/src/session/session-snapshot.ts
@@ -0,0 +1,208 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+
+export interface CoreSessionCheckpointSnapshot {
+	enabled?: boolean;
+	latest?: CheckpointEntry;
+	history: CheckpointEntry[];
+}
+
+export interface CoreSessionSnapshot {
+	version: 1;
+	sessionId: string;
+	source: SessionRecord["source"];
+	status: SessionRecord["status"];
+	createdAt: string;
+	updatedAt: string;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	interactive: boolean;
+	workspace: {
+		cwd: string;
+		root: string;
+	};
+	model: {
+		providerId: string;
+		modelId: string;
+	};
+	capabilities: {
+		enableTools: boolean;
+		enableSpawn: boolean;
+		enableTeams: boolean;
+	};
+	lineage: {
+		parentSessionId?: string;
+		parentAgentId?: string;
+		agentId?: string;
+		conversationId?: string;
+		isSubagent: boolean;
+	};
+	team?: {
+		name: string;
+	};
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	artifacts?: {
+		messagesPath?: string;
+	};
+	messages?: LlmsProviders.Message[];
+	usage?: SessionAccumulatedUsage;
+	aggregateUsage?: SessionAccumulatedUsage;
+	checkpoint?: CoreSessionCheckpointSnapshot;
+}
+
+function cloneJsonObject<T extends Record<string, unknown>>(
+	value: T | undefined,
+): T | undefined {
+	return value ? (JSON.parse(JSON.stringify(value)) as T) : undefined;
+}
+
+function cloneMessages(
+	messages: LlmsProviders.Message[] | undefined,
+): LlmsProviders.Message[] | undefined {
+	return messages
+		? (JSON.parse(JSON.stringify(messages)) as LlmsProviders.Message[])
+		: undefined;
+}
+
+function readCheckpointSnapshot(
+	metadata: Record<string, unknown> | undefined,
+): CoreSessionCheckpointSnapshot | undefined {
+	const checkpoint =
+		metadata?.checkpoint &&
+		typeof metadata.checkpoint === "object" &&
+		!Array.isArray(metadata.checkpoint)
+			? (metadata.checkpoint as Record<string, unknown>)
+			: undefined;
+	const rawHistory = Array.isArray(checkpoint?.history)
+		? checkpoint.history
+		: [];
+	const history = rawHistory
+		.filter(
+			(entry): entry is Record<string, unknown> =>
+				!!entry && typeof entry === "object" && !Array.isArray(entry),
+		)
+		.flatMap((entry): CheckpointEntry[] => {
+			const ref = typeof entry.ref === "string" ? entry.ref.trim() : "";
+			const createdAt = Number(entry.createdAt);
+			const runCount = Number(entry.runCount);
+			if (!ref || !Number.isFinite(createdAt) || !Number.isInteger(runCount)) {
+				return [];
+			}
+			return [
+				{
+					ref,
+					createdAt,
+					runCount,
+					...(entry.kind === "stash" || entry.kind === "commit"
+						? { kind: entry.kind }
+						: {}),
+				},
+			];
+		});
+	const latest = history.at(-1);
+	const enabled = metadata?.checkpointEnabled === true ? true : undefined;
+	if (!enabled && history.length === 0) {
+		return undefined;
+	}
+	return {
+		...(enabled ? { enabled } : {}),
+		...(latest ? { latest } : {}),
+		history,
+	};
+}
+
+export function createCoreSessionSnapshot(input: {
+	session: SessionRecord;
+	messages?: LlmsProviders.Message[];
+	usage?: SessionAccumulatedUsage;
+	aggregateUsage?: SessionAccumulatedUsage;
+}): CoreSessionSnapshot {
+	const { session } = input;
+	const metadata = cloneJsonObject(session.metadata);
+	return {
+		version: 1,
+		sessionId: session.sessionId,
+		source: session.source,
+		status: session.status,
+		createdAt: session.startedAt,
+		updatedAt: session.updatedAt,
+		endedAt: session.endedAt ?? null,
+		exitCode: session.exitCode ?? null,
+		interactive: session.interactive,
+		workspace: {
+			cwd: session.cwd,
+			root: session.workspaceRoot,
+		},
+		model: {
+			providerId: session.provider,
+			modelId: session.model,
+		},
+		capabilities: {
+			enableTools: session.enableTools,
+			enableSpawn: session.enableSpawn,
+			enableTeams: session.enableTeams,
+		},
+		lineage: {
+			...(session.parentSessionId
+				? { parentSessionId: session.parentSessionId }
+				: {}),
+			...(session.parentAgentId
+				? { parentAgentId: session.parentAgentId }
+				: {}),
+			...(session.agentId ? { agentId: session.agentId } : {}),
+			...(session.conversationId
+				? { conversationId: session.conversationId }
+				: {}),
+			isSubagent: session.isSubagent,
+		},
+		...(session.teamName ? { team: { name: session.teamName } } : {}),
+		...(session.prompt ? { prompt: session.prompt } : {}),
+		...(metadata ? { metadata } : {}),
+		...(session.messagesPath
+			? { artifacts: { messagesPath: session.messagesPath } }
+			: {}),
+		...(input.messages ? { messages: cloneMessages(input.messages) } : {}),
+		...(input.usage ? { usage: { ...input.usage } } : {}),
+		...(input.aggregateUsage
+			? { aggregateUsage: { ...input.aggregateUsage } }
+			: {}),
+		...(() => {
+			const checkpoint = readCheckpointSnapshot(metadata);
+			return checkpoint ? { checkpoint } : {};
+		})(),
+	};
+}
+
+export function coreSessionSnapshotToRecord(
+	snapshot: CoreSessionSnapshot,
+): SessionRecord {
+	return {
+		sessionId: snapshot.sessionId,
+		parentSessionId: snapshot.lineage.parentSessionId,
+		agentId: snapshot.lineage.agentId,
+		parentAgentId: snapshot.lineage.parentAgentId,
+		conversationId: snapshot.lineage.conversationId,
+		isSubagent: snapshot.lineage.isSubagent,
+		source: snapshot.source,
+		startedAt: snapshot.createdAt,
+		endedAt: snapshot.endedAt ?? undefined,
+		exitCode: snapshot.exitCode ?? undefined,
+		status: snapshot.status,
+		interactive: snapshot.interactive,
+		provider: snapshot.model.providerId,
+		model: snapshot.model.modelId,
+		cwd: snapshot.workspace.cwd,
+		workspaceRoot: snapshot.workspace.root,
+		teamName: snapshot.team?.name,
+		enableTools: snapshot.capabilities.enableTools,
+		enableSpawn: snapshot.capabilities.enableSpawn,
+		enableTeams: snapshot.capabilities.enableTeams,
+		prompt: snapshot.prompt,
+		metadata: snapshot.metadata,
+		updatedAt: snapshot.updatedAt,
+		messagesPath: snapshot.artifacts?.messagesPath,
+	};
+}
diff --git a/sdk/packages/core/src/session/session-versioning-service.test.ts b/sdk/packages/core/src/session/session-versioning-service.test.ts
new file mode 100644
index 0000000..6cbc0b4
--- /dev/null
+++ b/sdk/packages/core/src/session/session-versioning-service.test.ts
@@ -0,0 +1,195 @@
+import { describe, expect, it, vi } from "vitest";
+import { SessionSource } from "../types/common";
+import type { SessionRecord } from "../types/sessions";
+import { createCoreSessionSnapshot } from "./session-snapshot";
+import {
+	type SessionVersioningError,
+	SessionVersioningService,
+} from "./session-versioning-service";
+
+function makeSession(overrides: Partial<SessionRecord> = {}): SessionRecord {
+	return {
+		sessionId: "source-session",
+		source: SessionSource.CLI,
+		pid: 123,
+		startedAt: "2026-01-01T00:00:00.000Z",
+		updatedAt: "2026-01-01T00:01:00.000Z",
+		endedAt: null,
+		exitCode: null,
+		status: "completed",
+		interactive: true,
+		provider: "provider-a",
+		model: "model-a",
+		cwd: "/workspace/project",
+		workspaceRoot: "/workspace/project",
+		teamName: "team-a",
+		enableTools: true,
+		enableSpawn: true,
+		enableTeams: false,
+		parentSessionId: "parent-session",
+		parentAgentId: "parent-agent",
+		agentId: "agent-a",
+		conversationId: "conversation-a",
+		isSubagent: false,
+		prompt: "original prompt",
+		messagesPath: "/workspace/project/source.messages.json",
+		metadata: {
+			title: "Original",
+			checkpointEnabled: true,
+			checkpoint: {
+				latest: { ref: "cccc", createdAt: 3, runCount: 3 },
+				history: [
+					{ ref: "aaaa", createdAt: 1, runCount: 1, kind: "commit" },
+					{ ref: "bbbb", createdAt: 2, runCount: 2, kind: "stash" },
+					{ ref: "cccc", createdAt: 3, runCount: 3, kind: "stash" },
+				],
+			},
+		},
+		...overrides,
+	};
+}
+
+const messages = [
+	{ role: "user" as const, content: "first" },
+	{ role: "assistant" as const, content: "first response" },
+	{ role: "user" as const, content: "second" },
+	{ role: "assistant" as const, content: "second response" },
+];
+
+describe("createCoreSessionSnapshot", () => {
+	it("projects session records into the canonical snapshot shape", () => {
+		const snapshot = createCoreSessionSnapshot({
+			session: makeSession(),
+			messages,
+			usage: {
+				inputTokens: 1,
+				outputTokens: 2,
+				cacheReadTokens: 3,
+				cacheWriteTokens: 4,
+				totalCost: 0.5,
+			},
+		});
+
+		expect(snapshot).toMatchObject({
+			version: 1,
+			sessionId: "source-session",
+			workspace: { cwd: "/workspace/project", root: "/workspace/project" },
+			model: { providerId: "provider-a", modelId: "model-a" },
+			capabilities: {
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: false,
+			},
+			lineage: {
+				parentSessionId: "parent-session",
+				parentAgentId: "parent-agent",
+				agentId: "agent-a",
+				conversationId: "conversation-a",
+				isSubagent: false,
+			},
+			team: { name: "team-a" },
+			checkpoint: {
+				enabled: true,
+				latest: { ref: "cccc", createdAt: 3, runCount: 3, kind: "stash" },
+			},
+			usage: { totalCost: 0.5 },
+		});
+		expect(snapshot.messages).toEqual(messages);
+		expect(snapshot.messages).not.toBe(messages);
+		expect(snapshot.metadata).not.toBe(makeSession().metadata);
+	});
+});
+
+describe("SessionVersioningService", () => {
+	it("plans and materializes checkpoint restore through shared semantics", async () => {
+		const sourceSession = makeSession();
+		const restoredSession = makeSession({
+			sessionId: "restored-session",
+			metadata: {
+				checkpoint: { history: [{ ref: "aaaa", createdAt: 1, runCount: 1 }] },
+			},
+		});
+		const applyWorkspaceCheckpoint = vi.fn(async () => undefined);
+		const retainCheckpointRefs = vi.fn(async () => undefined);
+		const startSession = vi.fn(
+			async (input: { initialMessages?: unknown[] }) => {
+				expect(input.initialMessages).toEqual([
+					{ role: "user", content: "first" },
+					{ role: "assistant", content: "first response" },
+					{ role: "user", content: "second" },
+				]);
+				return { sessionId: "restored-session" };
+			},
+		);
+
+		const result = await new SessionVersioningService().restoreCheckpoint({
+			sessionId: "source-session",
+			checkpointRunCount: 2,
+			restore: { messages: true, workspace: true },
+			start: { marker: true },
+			getSession: async (sessionId) =>
+				sessionId === "source-session" ? sourceSession : restoredSession,
+			readMessages: async () => messages,
+			applyWorkspaceCheckpoint,
+			retainCheckpointRefs,
+			buildStartInput: (context, start) => ({
+				...start,
+				initialMessages: context.initialMessages,
+				checkpoint: context.restoredCheckpointMetadata,
+			}),
+			startSession,
+			getStartedSessionId: (startResult) => startResult.sessionId,
+			readRestoredSession: async () => restoredSession,
+		});
+
+		expect(result.sessionId).toBe("restored-session");
+		expect(result.checkpoint).toMatchObject({ ref: "bbbb", runCount: 2 });
+		expect(result.sourceSnapshot.sessionId).toBe("source-session");
+		expect(result.restoredSnapshot?.sessionId).toBe("restored-session");
+		expect(applyWorkspaceCheckpoint).toHaveBeenCalledWith(
+			"/workspace/project",
+			expect.objectContaining({ ref: "bbbb" }),
+		);
+		expect(retainCheckpointRefs).toHaveBeenCalledWith(
+			"/workspace/project",
+			"restored-session",
+			[
+				expect.objectContaining({ ref: "aaaa" }),
+				expect.objectContaining({ ref: "bbbb" }),
+			],
+		);
+	});
+
+	it("supports workspace-only restore without starting a new session", async () => {
+		const applyWorkspaceCheckpoint = vi.fn(async () => undefined);
+		const result = await new SessionVersioningService().restoreCheckpoint({
+			sessionId: "source-session",
+			checkpointRunCount: 1,
+			restore: { messages: false, workspace: true },
+			getSession: async () => makeSession(),
+			readMessages: async () => {
+				throw new Error("messages should not be read");
+			},
+			applyWorkspaceCheckpoint,
+		});
+
+		expect(result.sessionId).toBeUndefined();
+		expect(result.checkpoint).toMatchObject({ ref: "aaaa", runCount: 1 });
+		expect(applyWorkspaceCheckpoint).toHaveBeenCalledOnce();
+	});
+
+	it("raises typed validation errors", async () => {
+		await expect(
+			new SessionVersioningService().restoreCheckpoint({
+				sessionId: "source-session",
+				checkpointRunCount: 1,
+				restore: { messages: true, workspace: false },
+				getSession: async () => makeSession(),
+				readMessages: async () => [],
+			}),
+		).rejects.toMatchObject({
+			code: "invalid_restore",
+			message: "start is required when restore.messages is true",
+		} satisfies Partial<SessionVersioningError>);
+	});
+});
diff --git a/sdk/packages/core/src/session/session-versioning-service.ts b/sdk/packages/core/src/session/session-versioning-service.ts
new file mode 100644
index 0000000..5721604
--- /dev/null
+++ b/sdk/packages/core/src/session/session-versioning-service.ts
@@ -0,0 +1,245 @@
+import type * as LlmsProviders from "@cline/llms";
+import type {
+	CheckpointEntry,
+	CheckpointMetadata,
+} from "../hooks/checkpoint-hooks";
+import { retainCheckpointRefs as defaultRetainCheckpointRefs } from "../hooks/checkpoint-hooks";
+import type { RestoreSessionInput } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+import {
+	applyCheckpointToWorktree,
+	type CheckpointRestorePlan,
+	createCheckpointRestorePlan,
+	createRestoredCheckpointMetadata,
+	trimMessagesBeforeCheckpoint,
+} from "./checkpoint-restore";
+import {
+	type CoreSessionSnapshot,
+	createCoreSessionSnapshot,
+} from "./session-snapshot";
+
+export type SessionVersioningErrorCode =
+	| "invalid_restore"
+	| "session_not_found"
+	| "session_messages_not_found";
+
+export class SessionVersioningError extends Error {
+	constructor(
+		readonly code: SessionVersioningErrorCode,
+		message: string,
+	) {
+		super(message);
+		this.name = "SessionVersioningError";
+	}
+}
+
+export interface SessionCheckpointRestoreContext {
+	sourceSession: SessionRecord;
+	sourceMessages?: LlmsProviders.Message[];
+	sourceSnapshot: CoreSessionSnapshot;
+	plan: CheckpointRestorePlan;
+	restoredCheckpointMetadata?: CheckpointMetadata;
+	initialMessages: LlmsProviders.Message[];
+	restoreMessages: boolean;
+	restoreWorkspace: boolean;
+	checkpointRunCount: number;
+}
+
+export interface SessionCheckpointRestoreResult<TStartResult = unknown> {
+	sessionId?: string;
+	startResult?: TStartResult;
+	messages?: LlmsProviders.Message[];
+	checkpoint: CheckpointEntry;
+	sourceSnapshot: CoreSessionSnapshot;
+	restoredSnapshot?: CoreSessionSnapshot;
+}
+
+export interface SessionCheckpointRestoreInput<
+	TRestoreStartInput,
+	TStartInput,
+	TStartResult,
+> {
+	sessionId: string;
+	checkpointRunCount: number;
+	cwd?: string;
+	restore?: RestoreSessionInput["restore"];
+	start?: TRestoreStartInput;
+	getSession(sessionId: string): Promise<SessionRecord | undefined>;
+	readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+	buildStartInput?: (
+		context: SessionCheckpointRestoreContext,
+		start: TRestoreStartInput,
+	) => TStartInput | Promise<TStartInput>;
+	startSession?: (input: TStartInput) => Promise<TStartResult>;
+	getStartedSessionId?: (result: TStartResult) => string | undefined;
+	readRestoredSession?: (
+		sessionId: string,
+	) => Promise<SessionRecord | undefined>;
+	applyWorkspaceCheckpoint?: (
+		cwd: string,
+		checkpoint: CheckpointEntry,
+	) => Promise<void>;
+	retainCheckpointRefs?: (
+		cwd: string,
+		sessionId: string,
+		history: CheckpointEntry[],
+	) => Promise<void>;
+}
+
+function validateRestoreOptions(input: {
+	sessionId: string;
+	restoreMessages: boolean;
+	restoreWorkspace: boolean;
+	requiresStart: boolean;
+	checkpointRunCount: number;
+}): string {
+	const sourceSessionId = input.sessionId.trim();
+	if (!sourceSessionId) {
+		throw new SessionVersioningError(
+			"invalid_restore",
+			"sessionId is required",
+		);
+	}
+	if (!input.restoreMessages && !input.restoreWorkspace) {
+		throw new SessionVersioningError(
+			"invalid_restore",
+			"restore.messages or restore.workspace must be true",
+		);
+	}
+	if (input.restoreMessages && input.requiresStart) {
+		throw new SessionVersioningError(
+			"invalid_restore",
+			"start is required when restore.messages is true",
+		);
+	}
+	if (
+		!Number.isInteger(input.checkpointRunCount) ||
+		input.checkpointRunCount < 1
+	) {
+		throw new SessionVersioningError(
+			"invalid_restore",
+			"checkpointRunCount must be a positive integer",
+		);
+	}
+	return sourceSessionId;
+}
+
+export class SessionVersioningService {
+	async restoreCheckpoint<TRestoreStartInput, TStartInput, TStartResult>(
+		input: SessionCheckpointRestoreInput<
+			TRestoreStartInput,
+			TStartInput,
+			TStartResult
+		>,
+	): Promise<SessionCheckpointRestoreResult<TStartResult>> {
+		const restoreMessages = input.restore?.messages !== false;
+		const restoreWorkspace = input.restore?.workspace !== false;
+		const sourceSessionId = validateRestoreOptions({
+			sessionId: input.sessionId,
+			restoreMessages,
+			restoreWorkspace,
+			requiresStart: input.start === undefined,
+			checkpointRunCount: input.checkpointRunCount,
+		});
+
+		const sourceSession = await input.getSession(sourceSessionId);
+		if (!sourceSession) {
+			throw new SessionVersioningError(
+				"session_not_found",
+				`Session ${sourceSessionId} not found`,
+			);
+		}
+		const sourceMessages = restoreMessages
+			? await input.readMessages(sourceSessionId)
+			: undefined;
+		if (restoreMessages && sourceMessages?.length === 0) {
+			throw new SessionVersioningError(
+				"session_messages_not_found",
+				`No messages found for session ${sourceSessionId}`,
+			);
+		}
+
+		const plan = createCheckpointRestorePlan({
+			session: sourceSession,
+			messages: sourceMessages,
+			checkpointRunCount: input.checkpointRunCount,
+			cwd: input.cwd,
+			restoreMessages,
+		});
+		if (restoreWorkspace) {
+			await (input.applyWorkspaceCheckpoint ?? applyCheckpointToWorktree)(
+				plan.cwd,
+				plan.checkpoint,
+			);
+		}
+
+		const sourceSnapshot = createCoreSessionSnapshot({
+			session: sourceSession,
+			messages: sourceMessages,
+		});
+		if (!restoreMessages) {
+			return { checkpoint: plan.checkpoint, sourceSnapshot };
+		}
+
+		const restoredCheckpointMetadata = createRestoredCheckpointMetadata(
+			sourceSession,
+			input.checkpointRunCount,
+		);
+		const initialMessages = input.restore?.omitCheckpointMessageFromSession
+			? trimMessagesBeforeCheckpoint(
+					sourceMessages ?? [],
+					input.checkpointRunCount,
+				)
+			: (plan.messages ?? []);
+		const context: SessionCheckpointRestoreContext = {
+			sourceSession,
+			sourceMessages,
+			sourceSnapshot,
+			plan,
+			restoredCheckpointMetadata,
+			initialMessages,
+			restoreMessages,
+			restoreWorkspace,
+			checkpointRunCount: input.checkpointRunCount,
+		};
+
+		if (!input.start || !input.startSession) {
+			throw new SessionVersioningError(
+				"invalid_restore",
+				"start is required when restore.messages is true",
+			);
+		}
+
+		const startInput = input.buildStartInput
+			? await input.buildStartInput(context, input.start)
+			: (input.start as unknown as TStartInput);
+		const startResult = await input.startSession(startInput);
+		const newSessionId = input.getStartedSessionId?.(startResult);
+		if (newSessionId) {
+			await (input.retainCheckpointRefs ?? defaultRetainCheckpointRefs)(
+				plan.cwd,
+				newSessionId,
+				restoredCheckpointMetadata?.history ?? [],
+			);
+		}
+		const restoredSession =
+			newSessionId && input.readRestoredSession
+				? await input.readRestoredSession(newSessionId)
+				: undefined;
+		return {
+			sessionId: newSessionId,
+			startResult,
+			messages: plan.messages,
+			checkpoint: plan.checkpoint,
+			sourceSnapshot,
+			...(restoredSession
+				? {
+						restoredSnapshot: createCoreSessionSnapshot({
+							session: restoredSession,
+							messages: initialMessages,
+						}),
+					}
+				: {}),
+		};
+	}
+}
diff --git a/sdk/packages/core/src/session/stores/atomic-file.ts b/sdk/packages/core/src/session/stores/atomic-file.ts
new file mode 100644
index 0000000..4aa0c60
--- /dev/null
+++ b/sdk/packages/core/src/session/stores/atomic-file.ts
@@ -0,0 +1,53 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+
+async function fsyncBestEffort(path: string): Promise<void> {
+	let handle: Awaited<ReturnType<typeof open>> | undefined;
+	try {
+		handle = await open(path, "r");
+		await handle.sync();
+	} catch {
+		// Directory fsync is not available on all platforms/filesystems.
+	} finally {
+		if (handle !== undefined) {
+			try {
+				await handle.close();
+			} catch {
+				// Best-effort durability only.
+			}
+		}
+	}
+}
+
+export async function writeFileAtomic(
+	path: string,
+	contents: string,
+): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	let handle: Awaited<ReturnType<typeof open>> | undefined;
+	try {
+		handle = await open(tempPath, "wx");
+		await handle.writeFile(contents, "utf8");
+		await handle.sync();
+		await handle.close();
+		handle = undefined;
+		await rename(tempPath, path);
+		await fsyncBestEffort(dirname(path));
+	} catch (error) {
+		if (handle !== undefined) {
+			try {
+				await handle.close();
+			} catch {
+				// Preserve the original write error.
+			}
+		}
+		try {
+			await rm(tempPath, { force: true });
+		} catch {
+			// Preserve the original write error.
+		}
+		throw error;
+	}
+}
diff --git a/sdk/packages/core/src/session/stores/conversation-store.ts b/sdk/packages/core/src/session/stores/conversation-store.ts
new file mode 100644
index 0000000..ff9eea8
--- /dev/null
+++ b/sdk/packages/core/src/session/stores/conversation-store.ts
@@ -0,0 +1,77 @@
+/**
+ * Per-session conversation transcript store.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/runtime/conversation-store.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `ConversationStore`.
+ *
+ * Pure port of the old agents implementation. Owns the message list,
+ * conversation id, and "session started" gate that today's `Agent`
+ * class uses to decide when to fire `session_start` hooks.
+ */
+
+import type { MessageWithMetadata } from "@cline/shared";
+
+/** Generate a fresh conversation id. Exported for reuse by `SessionRuntime`. */
+export function createConversationId(): string {
+	return `conv_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+
+export class ConversationStore {
+	private messages: MessageWithMetadata[] = [];
+	private conversationId = createConversationId();
+	private sessionStarted = false;
+
+	constructor(initialMessages?: readonly MessageWithMetadata[]) {
+		if ((initialMessages?.length ?? 0) > 0) {
+			this.restore(initialMessages ?? []);
+		}
+	}
+
+	getConversationId(): string {
+		return this.conversationId;
+	}
+
+	getMessages(): MessageWithMetadata[] {
+		return [...this.messages];
+	}
+
+	appendMessage(message: MessageWithMetadata): void {
+		this.messages.push(message);
+	}
+
+	appendMessages(messages: readonly MessageWithMetadata[]): void {
+		if (messages.length === 0) {
+			return;
+		}
+		this.messages.push(...messages);
+	}
+
+	replaceMessages(messages: readonly MessageWithMetadata[]): void {
+		this.messages = [...messages];
+	}
+
+	resetForRun(): void {
+		this.messages = [];
+		this.conversationId = createConversationId();
+		this.sessionStarted = false;
+	}
+
+	clearHistory(): void {
+		this.messages = [];
+		this.conversationId = createConversationId();
+		this.sessionStarted = false;
+	}
+
+	restore(messages: readonly MessageWithMetadata[]): void {
+		this.messages = [...messages];
+		this.sessionStarted = false;
+	}
+
+	isSessionStarted(): boolean {
+		return this.sessionStarted;
+	}
+
+	markSessionStarted(): void {
+		this.sessionStarted = true;
+	}
+}
diff --git a/sdk/packages/core/src/session/stores/session-manifest-store.ts b/sdk/packages/core/src/session/stores/session-manifest-store.ts
new file mode 100644
index 0000000..603373f
--- /dev/null
+++ b/sdk/packages/core/src/session/stores/session-manifest-store.ts
@@ -0,0 +1,280 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { readFile, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import type { BasicLogger } from "@cline/shared";
+import { ensureHookLogDir } from "@cline/shared/storage";
+import { nowIso, SessionArtifacts } from "../../services/session-artifacts";
+import {
+	buildMessagesFilePayload,
+	resolveMessagesFileContext,
+	writeEmptyMessagesFile,
+} from "../../services/session-data";
+import type {
+	SessionMessagesArtifactUploader,
+	SessionPersistenceAdapter,
+	StoredMessageWithMetadata,
+} from "../../types/session";
+import {
+	parseSessionCompactionState,
+	type SessionCompactionState,
+	SessionCompactionStateSchema,
+} from "../models/session-compaction";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "../models/session-manifest";
+import { writeFileAtomic } from "./atomic-file";
+
+function isNotFoundError(error: unknown): boolean {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		"code" in error &&
+		error.code === "ENOENT"
+	);
+}
+
+export class SessionManifestStore {
+	readonly artifacts: SessionArtifacts;
+
+	constructor(
+		private readonly adapter: SessionPersistenceAdapter,
+		private readonly messagesArtifactUploader?: SessionMessagesArtifactUploader,
+		private readonly logger?: BasicLogger,
+	) {
+		this.artifacts = new SessionArtifacts(() => this.ensureSessionsDir());
+	}
+
+	ensureSessionsDir(): string {
+		return this.adapter.ensureSessionsDir();
+	}
+
+	initializeMessagesFile(
+		sessionId: string,
+		path: string,
+		startedAt: string,
+	): void {
+		writeEmptyMessagesFile(
+			path,
+			startedAt,
+			resolveMessagesFileContext(sessionId),
+		);
+	}
+
+	writeSessionManifest(manifestPath: string, manifest: SessionManifest): void {
+		mkdirSync(dirname(manifestPath), { recursive: true });
+		writeFileSync(
+			manifestPath,
+			`${JSON.stringify(SessionManifestSchema.parse(manifest), null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	readSessionManifest(sessionId: string): SessionManifest | undefined {
+		return this.readManifestFile(sessionId).manifest;
+	}
+
+	/**
+	 * Asynchronously read only the manifest `metadata.title`.
+	 *
+	 * The session-listing hot path needs nothing from the manifest except the
+	 * title, but the manifest JSON can be large (it embeds metadata and prompt
+	 * text). This reads the file off the event-loop thread and pulls the title
+	 * out of the parsed JSON directly, skipping the full `SessionManifestSchema`
+	 * (Zod) validation that `readSessionManifest` performs. On any error (missing
+	 * file, malformed JSON, non-string title) it resolves to `undefined` so
+	 * callers fall back to the row metadata/prompt title.
+	 */
+	async readSessionManifestTitle(
+		sessionId: string,
+	): Promise<string | undefined> {
+		const manifestPath = this.artifacts.sessionManifestPath(sessionId, false);
+		let raw: string;
+		try {
+			raw = await readFile(manifestPath, "utf8");
+		} catch {
+			return undefined;
+		}
+		try {
+			const parsed = JSON.parse(raw) as unknown;
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+				return undefined;
+			}
+			const metadata = (parsed as { metadata?: unknown }).metadata;
+			if (
+				!metadata ||
+				typeof metadata !== "object" ||
+				Array.isArray(metadata)
+			) {
+				return undefined;
+			}
+			const title = (metadata as { title?: unknown }).title;
+			return typeof title === "string" ? title : undefined;
+		} catch {
+			return undefined;
+		}
+	}
+
+	readManifestFile(sessionId: string): {
+		path: string;
+		manifest?: SessionManifest;
+	} {
+		const manifestPath = this.artifacts.sessionManifestPath(sessionId, false);
+		if (!existsSync(manifestPath)) {
+			return { path: manifestPath };
+		}
+		try {
+			return {
+				path: manifestPath,
+				manifest: SessionManifestSchema.parse(
+					JSON.parse(readFileSync(manifestPath, "utf8")) as SessionManifest,
+				),
+			};
+		} catch {
+			return { path: manifestPath };
+		}
+	}
+
+	async resolveArtifactPath(
+		sessionId: string,
+		kind: "messagesPath",
+		fallback: (id: string) => string,
+	): Promise<string> {
+		const row = await this.adapter.getSession(sessionId);
+		const value = row?.[kind];
+		return typeof value === "string" && value.trim().length > 0
+			? value
+			: fallback(sessionId);
+	}
+
+	async persistSessionMessages(
+		sessionId: string,
+		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
+	): Promise<void> {
+		const path = await this.resolveArtifactPath(
+			sessionId,
+			"messagesPath",
+			(id) => this.artifacts.sessionMessagesPath(id),
+		);
+		const payload = buildMessagesFilePayload({
+			updatedAt: nowIso(),
+			context: resolveMessagesFileContext(sessionId),
+			messages: messages as StoredMessageWithMetadata[],
+			systemPrompt,
+		});
+		const contents = `${JSON.stringify(payload, null, 2)}\n`;
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, contents, "utf8");
+		if (!this.messagesArtifactUploader) {
+			return;
+		}
+		try {
+			const row = await this.adapter.getSession(sessionId);
+			await this.messagesArtifactUploader.uploadMessagesFile({
+				sessionId,
+				path,
+				contents,
+				row,
+			});
+		} catch (error) {
+			this.logger?.debug("Failed to upload persisted session messages", {
+				sessionId,
+				error,
+			});
+		}
+	}
+
+	private resolveCompactionPath(sessionId: string): string {
+		const { manifest } = this.readManifestFile(sessionId);
+		return (
+			manifest?.compaction_path?.trim() ||
+			this.artifacts.sessionCompactionPath(sessionId)
+		);
+	}
+
+	private updateCompactionPath(
+		sessionId: string,
+		path: string | undefined,
+	): void {
+		const manifestFile = this.readManifestFile(sessionId);
+		if (!manifestFile.manifest) {
+			return;
+		}
+		if (manifestFile.manifest.compaction_path === path) {
+			return;
+		}
+		this.writeSessionManifest(manifestFile.path, {
+			...manifestFile.manifest,
+			compaction_path: path,
+		});
+	}
+
+	async readSessionCompactionState(
+		sessionId: string,
+	): Promise<SessionCompactionState | undefined> {
+		const path = this.resolveCompactionPath(sessionId);
+		try {
+			return parseSessionCompactionState(
+				JSON.parse(await readFile(path, "utf8")) as unknown,
+			);
+		} catch (error) {
+			if (isNotFoundError(error)) {
+				return undefined;
+			}
+			this.logger?.debug("Ignoring invalid session compaction state", {
+				sessionId,
+				path,
+				error,
+				recovery:
+					"Canonical history is unchanged; deleting the sidecar is safe.",
+			});
+			return undefined;
+		}
+	}
+
+	async persistSessionCompactionState(
+		sessionId: string,
+		state: SessionCompactionState,
+	): Promise<void> {
+		const path = this.resolveCompactionPath(sessionId);
+		const payload = SessionCompactionStateSchema.parse(state);
+		await writeFileAtomic(path, `${JSON.stringify(payload, null, 2)}\n`);
+		this.updateCompactionPath(sessionId, path);
+	}
+
+	async deleteSessionCompactionState(sessionId: string): Promise<void> {
+		await rm(this.resolveCompactionPath(sessionId), { force: true });
+		this.updateCompactionPath(sessionId, undefined);
+	}
+
+	appendStaleSessionHookLog(
+		detectedAt: string,
+		sessionId: string,
+		pid: number,
+		reason: string,
+		source: string,
+	): void {
+		const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+		const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+		appendFileSync(
+			logPath,
+			`${JSON.stringify({
+				ts: detectedAt,
+				hookName: "session_shutdown",
+				reason,
+				sessionId,
+				pid,
+				source,
+			})}\n`,
+			"utf8",
+		);
+	}
+}
diff --git a/sdk/packages/core/src/session/stores/team-persistence-store.ts b/sdk/packages/core/src/session/stores/team-persistence-store.ts
new file mode 100644
index 0000000..349808c
--- /dev/null
+++ b/sdk/packages/core/src/session/stores/team-persistence-store.ts
@@ -0,0 +1,176 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { TeamTeammateSpec } from "@cline/shared";
+import { resolveTeamDataDir } from "@cline/shared/storage";
+import type { AgentTeamsRuntime, TeamEvent } from "../../extensions/tools/team";
+import {
+	type PersistedTeamEnvelope,
+	reviveTeamStateDates,
+	type TeamRuntimeState,
+} from "../models/session-row";
+
+function sanitizeTeamName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+export interface FileTeamPersistenceStoreOptions {
+	teamName: string;
+	baseDir?: string;
+}
+
+export class FileTeamPersistenceStore {
+	private readonly dirPath: string;
+	private readonly statePath: string;
+	private readonly taskHistoryPath: string;
+	private readonly teammateSpecs: Map<string, TeamTeammateSpec> = new Map();
+
+	constructor(options: FileTeamPersistenceStoreOptions) {
+		const safeTeamName = sanitizeTeamName(options.teamName);
+		const baseDir = options.baseDir?.trim() || resolveTeamDataDir();
+		this.dirPath = join(baseDir, safeTeamName);
+		this.statePath = join(this.dirPath, "state.json");
+		this.taskHistoryPath = join(this.dirPath, "task-history.jsonl");
+	}
+
+	loadState(): TeamRuntimeState | undefined {
+		if (!existsSync(this.statePath)) {
+			return undefined;
+		}
+		try {
+			const raw = readFileSync(this.statePath, "utf8");
+			const parsed = JSON.parse(raw) as PersistedTeamEnvelope;
+			if (parsed.version !== 1 || !parsed.teamState) {
+				return undefined;
+			}
+			for (const spec of parsed.teammates ?? []) {
+				this.teammateSpecs.set(spec.agentId, spec);
+			}
+			return reviveTeamStateDates(parsed.teamState);
+		} catch {
+			return undefined;
+		}
+	}
+
+	getTeammateSpecs(): TeamTeammateSpec[] {
+		return Array.from(this.teammateSpecs.values());
+	}
+
+	upsertTeammateSpec(spec: TeamTeammateSpec): void {
+		this.teammateSpecs.set(spec.agentId, spec);
+	}
+
+	removeTeammateSpec(agentId: string): void {
+		this.teammateSpecs.delete(agentId);
+	}
+
+	persist(runtime: AgentTeamsRuntime): void {
+		if (!this.hasPersistableState(runtime)) {
+			this.clearPersistedState();
+			return;
+		}
+		this.ensureDir();
+		const envelope: PersistedTeamEnvelope = {
+			version: 1,
+			updatedAt: new Date().toISOString(),
+			teamState: runtime.exportState(),
+			teammates: Array.from(this.teammateSpecs.values()),
+		};
+		const tmpPath = `${this.statePath}.tmp`;
+		writeFileSync(tmpPath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
+		renameSync(tmpPath, this.statePath);
+	}
+
+	appendTaskHistory(event: TeamEvent): void {
+		let task: Record<string, unknown> = {};
+		switch (event.type) {
+			case "team_task_updated":
+				task = event.task as unknown as Record<string, unknown>;
+				break;
+			case "team_message":
+				task = {
+					agentId: event.message.fromAgentId,
+					toAgentId: event.message.toAgentId,
+					subject: event.message.subject,
+					taskId: event.message.taskId,
+				};
+				break;
+			case "team_mission_log":
+				task = {
+					agentId: event.entry.agentId,
+					kind: event.entry.kind,
+					summary: event.entry.summary,
+					taskId: event.entry.taskId,
+				};
+				break;
+			case "teammate_spawned":
+			case "teammate_shutdown":
+			case "task_start":
+				task = {
+					agentId: event.agentId,
+					message: "message" in event ? event.message : undefined,
+				};
+				break;
+			case "task_end":
+				task = {
+					agentId: event.agentId,
+					finishReason: event.result?.finishReason,
+					error: event.error?.message,
+				};
+				break;
+			case "agent_event":
+				task = {
+					agentId: event.agentId,
+					eventType: event.event.type,
+				};
+				break;
+		}
+		this.ensureDir();
+		appendFileSync(
+			this.taskHistoryPath,
+			`${JSON.stringify({
+				ts: new Date().toISOString(),
+				type: event.type,
+				task,
+			})}\n`,
+			"utf8",
+		);
+	}
+
+	private ensureDir(): void {
+		if (!existsSync(this.dirPath)) {
+			mkdirSync(this.dirPath, { recursive: true });
+		}
+	}
+
+	private hasPersistableState(runtime: AgentTeamsRuntime): boolean {
+		const state = runtime.exportState();
+		if (this.teammateSpecs.size > 0) {
+			return true;
+		}
+		if (state.members.some((member) => member.role === "teammate")) {
+			return true;
+		}
+		return (
+			state.tasks.length > 0 ||
+			state.mailbox.length > 0 ||
+			state.missionLog.length > 0
+		);
+	}
+
+	private clearPersistedState(): void {
+		if (existsSync(this.statePath)) {
+			unlinkSync(this.statePath);
+		}
+	}
+}
diff --git a/sdk/packages/core/src/session/team/index.ts b/sdk/packages/core/src/session/team/index.ts
new file mode 100644
index 0000000..c996e33
--- /dev/null
+++ b/sdk/packages/core/src/session/team/index.ts
@@ -0,0 +1,12 @@
+export { TeamChildSessionManager } from "./team-child-session-manager";
+export {
+	buildTeamRunContinuationPrompt,
+	dispatchTeamEventToBackend,
+	emitTeamProgress,
+	formatModePrompt,
+	hasPendingTeamRunWork,
+	notifyTeamRunWaiters,
+	shouldAutoContinueTeamRuns,
+	trackTeamRunState,
+	waitForTeamRunUpdates,
+} from "./team-session-coordinator";
diff --git a/sdk/packages/core/src/session/team/team-child-session-manager.ts b/sdk/packages/core/src/session/team/team-child-session-manager.ts
new file mode 100644
index 0000000..e8e10a1
--- /dev/null
+++ b/sdk/packages/core/src/session/team/team-child-session-manager.ts
@@ -0,0 +1,415 @@
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult } from "@cline/shared";
+import { resolveRootSessionId } from "@cline/shared";
+import { ensureHookLogDir } from "@cline/shared/storage";
+import { z } from "zod";
+import type {
+	SubAgentEndContext,
+	SubAgentStartContext,
+} from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import { nowIso } from "../../services/session-artifacts";
+import { resolveMetadataWithTitle } from "../../services/session-data";
+import {
+	isNonTerminalSessionStatus,
+	type SessionStatus,
+	type TerminalSessionStatus,
+} from "../../types/common";
+import type {
+	SessionPersistenceAdapter,
+	StoredMessageWithMetadata,
+} from "../../types/session";
+import {
+	deriveSubsessionStatus,
+	makeSubSessionId,
+	makeTeamTaskSubSessionId,
+} from "../models/session-graph";
+import type { SessionRow, UpsertSubagentInput } from "../models/session-row";
+import type { SessionManifestStore } from "../stores/session-manifest-store";
+
+const SUBSESSION_SOURCE = "subagent";
+const SpawnAgentInputSchema = z.looseObject({
+	task: z.string().optional(),
+	systemPrompt: z.string().optional(),
+});
+
+export class TeamChildSessionManager {
+	private readonly teamTaskSessionsByAgent = new Map<string, string[]>();
+	private readonly teamTaskLastHeartbeatBySession = new Map<string, number>();
+	private readonly teamTaskLastProgressLineBySession = new Map<
+		string,
+		string
+	>();
+
+	constructor(
+		private readonly adapter: SessionPersistenceAdapter,
+		private readonly manifestStore: SessionManifestStore,
+		private readonly toPersistedMessages: (
+			messages: LlmsProviders.Message[] | undefined,
+			result?: AgentResult,
+			previousMessages?: LlmsProviders.Message[],
+		) => StoredMessageWithMetadata[] | undefined,
+		private readonly heartbeatLogIntervalMs: number,
+	) {}
+
+	private teamTaskQueueKey(rootSessionId: string, agentId: string): string {
+		return `${rootSessionId}::${agentId}`;
+	}
+
+	private activeTeamTaskSessionId(
+		rootSessionId: string,
+		parentAgentId: string,
+	): string | undefined {
+		const queue = this.teamTaskSessionsByAgent.get(
+			this.teamTaskQueueKey(rootSessionId, parentAgentId),
+		);
+		return queue?.at(-1);
+	}
+
+	private buildSubsessionRow(
+		root: SessionRow,
+		opts: {
+			sessionId: string;
+			parentSessionId: string;
+			parentAgentId: string;
+			agentId: string;
+			conversationId?: string | null;
+			prompt: string;
+			startedAt: string;
+			messagesPath: string;
+		},
+	): SessionRow {
+		return {
+			sessionId: opts.sessionId,
+			source: SUBSESSION_SOURCE,
+			pid: process.ppid,
+			startedAt: opts.startedAt,
+			endedAt: null,
+			exitCode: null,
+			status: "running",
+			statusLock: 0,
+			interactive: false,
+			provider: root.provider,
+			model: root.model,
+			cwd: root.cwd,
+			workspaceRoot: root.workspaceRoot,
+			teamName: root.teamName ?? null,
+			enableTools: root.enableTools,
+			enableSpawn: root.enableSpawn,
+			enableTeams: root.enableTeams,
+			parentSessionId: opts.parentSessionId,
+			parentAgentId: opts.parentAgentId,
+			agentId: opts.agentId,
+			conversationId: opts.conversationId ?? null,
+			isSubagent: true,
+			prompt: opts.prompt,
+			metadata: resolveMetadataWithTitle({ prompt: opts.prompt }),
+			hookPath: "",
+			messagesPath: opts.messagesPath,
+			updatedAt: opts.startedAt,
+		};
+	}
+
+	async queueSpawnRequest(event: HookEventPayload): Promise<void> {
+		if (event.hookName !== "tool_call" || event.parent_agent_id !== null)
+			return;
+		if (event.tool_call?.name !== "spawn_agent") return;
+
+		const rootSessionId = resolveRootSessionId(event.sessionContext);
+		if (!rootSessionId) return;
+
+		const parsed = SpawnAgentInputSchema.safeParse(event.tool_call.input);
+		await this.adapter.enqueueSpawnRequest({
+			rootSessionId,
+			parentAgentId: event.agent_id,
+			task: parsed.success ? parsed.data.task : undefined,
+			systemPrompt: parsed.success ? parsed.data.systemPrompt : undefined,
+		});
+	}
+
+	async upsertSubagentSession(
+		input: UpsertSubagentInput,
+	): Promise<string | undefined> {
+		const rootSessionId = input.rootSessionId;
+		if (!rootSessionId) return undefined;
+
+		const root = await this.adapter.getSession(rootSessionId);
+		if (!root) return undefined;
+
+		const sessionId = makeSubSessionId(rootSessionId, input.agentId);
+		const existing = await this.adapter.getSession(sessionId);
+		const startedAt = nowIso();
+		const artifactPaths = this.manifestStore.artifacts.subagentArtifactPaths(
+			sessionId,
+			input.agentId,
+			this.activeTeamTaskSessionId(rootSessionId, input.parentAgentId),
+		);
+
+		let prompt = input.prompt ?? existing?.prompt ?? undefined;
+		if (!prompt) {
+			prompt =
+				(await this.adapter.claimSpawnRequest(
+					rootSessionId,
+					input.parentAgentId,
+				)) ?? `Subagent run by ${input.parentAgentId}`;
+		}
+
+		if (!existing) {
+			await this.adapter.upsertSession(
+				this.buildSubsessionRow(root, {
+					sessionId,
+					parentSessionId: rootSessionId,
+					parentAgentId: input.parentAgentId,
+					agentId: input.agentId,
+					conversationId: input.conversationId,
+					prompt,
+					startedAt,
+					...artifactPaths,
+				}),
+			);
+			this.manifestStore.initializeMessagesFile(
+				sessionId,
+				artifactPaths.messagesPath,
+				startedAt,
+			);
+			return sessionId;
+		}
+
+		await this.adapter.updateSession({
+			sessionId,
+			setRunning: true,
+			parentSessionId: rootSessionId,
+			parentAgentId: input.parentAgentId,
+			agentId: input.agentId,
+			conversationId: input.conversationId,
+			prompt: existing.prompt ?? prompt ?? null,
+			metadata: resolveMetadataWithTitle({
+				metadata: existing.metadata ?? undefined,
+				prompt: existing.prompt ?? prompt ?? null,
+			}),
+			expectedStatusLock: existing.statusLock,
+		});
+		return sessionId;
+	}
+
+	async upsertSubagentSessionFromHook(
+		event: HookEventPayload,
+	): Promise<string | undefined> {
+		if (!event.parent_agent_id) return undefined;
+		const rootSessionId = resolveRootSessionId(event.sessionContext);
+		if (!rootSessionId) return undefined;
+		if (event.hookName === "session_shutdown") {
+			const sessionId = makeSubSessionId(rootSessionId, event.agent_id);
+			const existing = await this.adapter.getSession(sessionId);
+			return existing ? sessionId : undefined;
+		}
+		return await this.upsertSubagentSession({
+			agentId: event.agent_id,
+			parentAgentId: event.parent_agent_id,
+			conversationId: event.taskId,
+			rootSessionId,
+		});
+	}
+
+	async applySubagentStatus(
+		subSessionId: string,
+		event: HookEventPayload,
+	): Promise<void> {
+		await this.applySubagentStatusBySessionId(
+			subSessionId,
+			deriveSubsessionStatus(event),
+		);
+	}
+
+	async applySubagentStatusBySessionId(
+		subSessionId: string,
+		status: SessionStatus,
+	): Promise<void> {
+		const row = await this.adapter.getSession(subSessionId);
+		if (!row) return;
+		const endedAt = isNonTerminalSessionStatus(status) ? null : nowIso();
+		const exitCode = isNonTerminalSessionStatus(status)
+			? null
+			: status === "failed"
+				? 1
+				: 0;
+		await this.adapter.updateSession({
+			sessionId: subSessionId,
+			status,
+			endedAt,
+			exitCode,
+			expectedStatusLock: row.statusLock,
+		});
+	}
+
+	async applyStatusToRunningChildSessions(
+		parentSessionId: string,
+		status: TerminalSessionStatus,
+	): Promise<void> {
+		if (!parentSessionId) return;
+		const rows = await this.adapter.listSessions({
+			limit: 2000,
+			parentSessionId,
+			status: "running",
+		});
+		for (const row of rows) {
+			await this.applySubagentStatusBySessionId(row.sessionId, status);
+		}
+	}
+
+	async onTeamTaskStart(
+		rootSessionId: string,
+		agentId: string,
+		message: string,
+	): Promise<void> {
+		const root = await this.adapter.getSession(rootSessionId);
+		if (!root) return;
+		const sessionId = makeTeamTaskSubSessionId(rootSessionId, agentId);
+		const startedAt = nowIso();
+		const { messagesPath } = this.manifestStore.artifacts.subagentArtifactPaths(
+			sessionId,
+			agentId,
+		);
+		await this.adapter.upsertSession(
+			this.buildSubsessionRow(root, {
+				sessionId,
+				parentSessionId: rootSessionId,
+				parentAgentId: "lead",
+				agentId,
+				prompt: message || `Team task for ${agentId}`,
+				startedAt,
+				messagesPath,
+			}),
+		);
+		this.manifestStore.initializeMessagesFile(
+			sessionId,
+			messagesPath,
+			startedAt,
+		);
+		const key = this.teamTaskQueueKey(rootSessionId, agentId);
+		const queue = this.teamTaskSessionsByAgent.get(key) ?? [];
+		queue.push(sessionId);
+		this.teamTaskSessionsByAgent.set(key, queue);
+	}
+
+	async onTeamTaskEnd(
+		rootSessionId: string,
+		agentId: string,
+		status: SessionStatus,
+		_summary?: string,
+		result?: AgentResult,
+		messages?: LlmsProviders.Message[],
+	): Promise<void> {
+		const key = this.teamTaskQueueKey(rootSessionId, agentId);
+		const queue = this.teamTaskSessionsByAgent.get(key);
+		if (!queue || queue.length === 0) return;
+		const sessionId = queue.shift();
+		if (queue.length === 0) this.teamTaskSessionsByAgent.delete(key);
+		if (!sessionId) return;
+		const teammateMessages = result?.messages ?? messages;
+		const persistedMessages = this.toPersistedMessages(
+			teammateMessages,
+			result,
+			messages,
+		);
+		if (persistedMessages) {
+			await this.manifestStore.persistSessionMessages(
+				sessionId,
+				persistedMessages,
+			);
+		}
+		await this.applySubagentStatusBySessionId(sessionId, status);
+		this.teamTaskLastHeartbeatBySession.delete(sessionId);
+		this.teamTaskLastProgressLineBySession.delete(sessionId);
+	}
+
+	async onTeamTaskProgress(
+		rootSessionId: string,
+		agentId: string,
+		progress: string,
+		options?: { kind?: "heartbeat" | "progress" | "text" },
+	): Promise<void> {
+		const key = this.teamTaskQueueKey(rootSessionId, agentId);
+		const sessionId = this.teamTaskSessionsByAgent.get(key)?.[0];
+		if (!sessionId) return;
+		const trimmed = progress.trim();
+		if (!trimmed) return;
+		const kind = options?.kind ?? "progress";
+		if (kind === "heartbeat") {
+			const now = Date.now();
+			const last = this.teamTaskLastHeartbeatBySession.get(sessionId) ?? 0;
+			if (now - last < this.heartbeatLogIntervalMs) {
+				return;
+			}
+			this.teamTaskLastHeartbeatBySession.set(sessionId, now);
+		}
+		const line =
+			kind === "heartbeat"
+				? "[progress] heartbeat"
+				: kind === "text"
+					? `[progress] text: ${trimmed}`
+					: `[progress] ${trimmed}`;
+		if (this.teamTaskLastProgressLineBySession.get(sessionId) === line) return;
+		this.teamTaskLastProgressLineBySession.set(sessionId, line);
+	}
+
+	async handleSubAgentStart(
+		rootSessionId: string,
+		context: SubAgentStartContext,
+	): Promise<void> {
+		const subSessionId = await this.upsertSubagentSession({
+			agentId: context.subAgentId,
+			parentAgentId: context.parentAgentId,
+			conversationId: context.conversationId,
+			prompt: context.input.task,
+			rootSessionId,
+		});
+		if (!subSessionId) return;
+		await this.applySubagentStatusBySessionId(subSessionId, "running");
+	}
+
+	async handleSubAgentEnd(
+		rootSessionId: string,
+		context: SubAgentEndContext,
+	): Promise<void> {
+		const subSessionId = await this.upsertSubagentSession({
+			agentId: context.subAgentId,
+			parentAgentId: context.parentAgentId,
+			conversationId: context.conversationId,
+			prompt: context.input.task,
+			rootSessionId,
+		});
+		if (!subSessionId) return;
+		if (context.error) {
+			await this.applySubagentStatusBySessionId(subSessionId, "failed");
+			return;
+		}
+		const persistedMessages = this.toPersistedMessages(
+			context.agentResult?.messages,
+			context.agentResult,
+		);
+		if (persistedMessages) {
+			await this.manifestStore.persistSessionMessages(
+				subSessionId,
+				persistedMessages,
+			);
+		}
+		const reason = context.result?.finishReason ?? "completed";
+		await this.applySubagentStatusBySessionId(
+			subSessionId,
+			reason === "aborted" ? "cancelled" : "completed",
+		);
+	}
+
+	appendSubagentHookAudit(event: HookEventPayload): void {
+		const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+		const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+		appendFileSync(
+			logPath,
+			`${JSON.stringify({ ts: nowIso(), ...event })}\n`,
+			"utf8",
+		);
+	}
+}
diff --git a/sdk/packages/core/src/session/team/team-session-coordinator.ts b/sdk/packages/core/src/session/team/team-session-coordinator.ts
new file mode 100644
index 0000000..822e246
--- /dev/null
+++ b/sdk/packages/core/src/session/team/team-session-coordinator.ts
@@ -0,0 +1,240 @@
+import {
+	type AgentMode,
+	type AgentResult,
+	formatUserInputBlock,
+} from "@cline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import {
+	buildTeamProgressSummary,
+	toTeamProgressLifecycleEvent,
+} from "../../extensions/tools/team";
+import type { CoreSessionEvent } from "../../types/events";
+import type { ActiveSession, TeamRunUpdate } from "../../types/session";
+
+export function trackTeamRunState(
+	session: ActiveSession,
+	event: TeamEvent,
+): void {
+	switch (event.type) {
+		case "run_queued":
+		case "run_started":
+			session.activeTeamRunIds.add(event.run.id);
+			break;
+		case "run_completed":
+		case "run_failed":
+		case "run_cancelled":
+		case "run_interrupted": {
+			let runError: string | undefined;
+			if (event.type === "run_failed") {
+				runError = event.run.error;
+			} else if (
+				event.type === "run_cancelled" ||
+				event.type === "run_interrupted"
+			) {
+				runError = event.run.error ?? event.reason;
+			}
+			session.activeTeamRunIds.delete(event.run.id);
+			session.pendingTeamRunUpdates.push({
+				runId: event.run.id,
+				agentId: event.run.agentId,
+				taskId: event.run.taskId,
+				status: event.type.replace("run_", "") as TeamRunUpdate["status"],
+				error: runError,
+				iterations: (event.run.result as { iterations?: number } | undefined)
+					?.iterations,
+			});
+			notifyTeamRunWaiters(session);
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+export async function dispatchTeamEventToBackend(
+	rootSessionId: string,
+	event: TeamEvent,
+	invokeOptional: (method: string, ...args: unknown[]) => Promise<void>,
+): Promise<void> {
+	switch (event.type) {
+		case "run_progress":
+			await invokeOptional(
+				"onTeamTaskProgress",
+				rootSessionId,
+				event.run.agentId,
+				event.message,
+				{ kind: event.message === "heartbeat" ? "heartbeat" : "progress" },
+			);
+			break;
+		case "agent_event":
+			if (
+				event.event.type === "content_start" &&
+				event.event.contentType === "text" &&
+				typeof event.event.text === "string"
+			) {
+				const snippet = event.event.text
+					.replace(/\s+/g, " ")
+					.trim()
+					.slice(0, 120);
+				if (snippet) {
+					await invokeOptional(
+						"onTeamTaskProgress",
+						rootSessionId,
+						event.agentId,
+						snippet,
+						{ kind: "text" },
+					);
+				}
+			}
+			break;
+		case "task_start":
+			await invokeOptional(
+				"onTeamTaskStart",
+				rootSessionId,
+				event.agentId,
+				event.message,
+			);
+			break;
+		case "task_end": {
+			if (event.error) {
+				await invokeOptional(
+					"onTeamTaskEnd",
+					rootSessionId,
+					event.agentId,
+					"failed",
+					`[error] ${event.error.message}`,
+					undefined,
+					event.messages,
+				);
+			} else if (event.result?.finishReason === "aborted") {
+				await invokeOptional(
+					"onTeamTaskEnd",
+					rootSessionId,
+					event.agentId,
+					"cancelled",
+					"[done] aborted",
+					event.result,
+					event.result.messages,
+				);
+			} else {
+				await invokeOptional(
+					"onTeamTaskEnd",
+					rootSessionId,
+					event.agentId,
+					"completed",
+					`[done] ${event.result?.finishReason ?? "completed"}`,
+					event.result,
+					event.result?.messages,
+				);
+			}
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+export function emitTeamProgress(
+	session: ActiveSession,
+	rootSessionId: string,
+	event: TeamEvent,
+	emit: (event: CoreSessionEvent) => void,
+): void {
+	if (!session.runtime.teamRuntime) return;
+	const teamName = session.runtime.teamRuntime.getTeamName();
+	emit({
+		type: "team_progress",
+		payload: {
+			sessionId: rootSessionId,
+			teamName,
+			lifecycle: toTeamProgressLifecycleEvent({
+				teamName,
+				sessionId: rootSessionId,
+				event,
+			}),
+			summary: buildTeamProgressSummary(
+				teamName,
+				session.runtime.teamRuntime.exportState(),
+			),
+		},
+	});
+}
+
+export function hasPendingTeamRunWork(session: ActiveSession): boolean {
+	return (
+		session.activeTeamRunIds.size > 0 ||
+		session.pendingTeamRunUpdates.length > 0
+	);
+}
+
+export function shouldAutoContinueTeamRuns(
+	session: ActiveSession,
+	finishReason: AgentResult["finishReason"],
+): boolean {
+	if (session.aborting) {
+		return false;
+	}
+	const canAutoContinue =
+		finishReason === "completed" || finishReason === "max_iterations";
+	if (!canAutoContinue) {
+		return false;
+	}
+	return (
+		session.config.enableAgentTeams === true && hasPendingTeamRunWork(session)
+	);
+}
+
+export function notifyTeamRunWaiters(session: ActiveSession): void {
+	const waiters = session.teamRunWaiters.splice(0);
+	for (const resolve of waiters) resolve();
+}
+
+export async function waitForTeamRunUpdates(
+	session: ActiveSession,
+): Promise<TeamRunUpdate[]> {
+	while (true) {
+		if (session.aborting) return [];
+		if (session.pendingTeamRunUpdates.length > 0) {
+			const updates = [...session.pendingTeamRunUpdates];
+			session.pendingTeamRunUpdates.length = 0;
+			return updates;
+		}
+		if (session.activeTeamRunIds.size === 0) return [];
+		await new Promise<void>((resolve) => {
+			session.teamRunWaiters.push(resolve);
+		});
+	}
+}
+
+export function buildTeamRunContinuationPrompt(
+	session: ActiveSession,
+	updates: TeamRunUpdate[],
+): string {
+	const lines = updates.map((u) => {
+		const parts = [`- ${u.runId} (${u.agentId}) -> ${u.status}`];
+		if (u.taskId) parts.push(` task=${u.taskId}`);
+		if (typeof u.iterations === "number")
+			parts.push(` iterations=${u.iterations}`);
+		if (u.error) parts.push(` error=${u.error}`);
+		return parts.join("");
+	});
+	const remaining = session.activeTeamRunIds.size;
+	const instruction =
+		remaining > 0
+			? `There are still ${remaining} teammate run(s) in progress. Continue coordination and decide whether to wait for more updates.`
+			: "No teammate runs are currently in progress. Continue coordination using these updates.";
+	return formatModePrompt(
+		`System-delivered teammate async run updates:\n${lines.join("\n")}\n\n${instruction}`,
+		session.config.mode,
+	);
+}
+
+export function formatModePrompt(
+	prompt: string,
+	mode: AgentMode | undefined,
+): string {
+	return formatUserInputBlock(
+		prompt,
+		mode === "plan" ? "plan" : mode === "yolo" ? "yolo" : "act",
+	);
+}
diff --git a/sdk/packages/core/src/settings/index.ts b/sdk/packages/core/src/settings/index.ts
new file mode 100644
index 0000000..65a6c98
--- /dev/null
+++ b/sdk/packages/core/src/settings/index.ts
@@ -0,0 +1,15 @@
+export {
+	CoreSettingsService,
+	createCoreSettingsService,
+} from "./settings-service";
+export type {
+	ClineCoreSettingsApi,
+	CoreSettingsItem,
+	CoreSettingsItemKind,
+	CoreSettingsItemSource,
+	CoreSettingsListInput,
+	CoreSettingsMutationResult,
+	CoreSettingsSnapshot,
+	CoreSettingsToggleInput,
+	CoreSettingsType,
+} from "./types";
diff --git a/sdk/packages/core/src/settings/settings-service.test.ts b/sdk/packages/core/src/settings/settings-service.test.ts
new file mode 100644
index 0000000..95e3149
--- /dev/null
+++ b/sdk/packages/core/src/settings/settings-service.test.ts
@@ -0,0 +1,417 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import type { UserInstructionConfigService } from "../extensions/config";
+import { CoreSettingsService } from "./settings-service";
+
+describe("CoreSettingsService", () => {
+	const tempRoots: string[] = [];
+	const envSnapshot = {
+		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
+		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
+	};
+
+	afterEach(async () => {
+		if (envSnapshot.CLINE_GLOBAL_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_GLOBAL_SETTINGS_PATH =
+				envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
+		}
+		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
+			delete process.env.CLINE_MCP_SETTINGS_PATH;
+		} else {
+			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
+		}
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("toggles skill frontmatter and refreshes the skill service before returning a snapshot", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-settings-"));
+		tempRoots.push(tempRoot);
+		const skillPath = join(tempRoot, "SKILL.md");
+		await writeFile(
+			skillPath,
+			`---
+name: skill-one
+---
+Use this skill.`,
+		);
+
+		const calls: string[] = [];
+		let refreshed = false;
+		const userInstructionService = {
+			async refreshType(type: string) {
+				calls.push(`refreshType:${type}`);
+				refreshed = true;
+			},
+			listRecords(type: string) {
+				calls.push(`listRecords:${type}`);
+				if (type !== "skill") {
+					return [];
+				}
+				return [
+					{
+						id: "skill-one",
+						type: "skill",
+						filePath: skillPath,
+						item: {
+							name: "skill-one",
+							disabled: refreshed,
+							description: "Skill one",
+							instructions: "Use this skill.",
+							frontmatter: {},
+						},
+					},
+				];
+			},
+		} as unknown as UserInstructionConfigService;
+
+		const result = await new CoreSettingsService().toggle({
+			type: "skills",
+			id: "skill-one",
+			path: skillPath,
+			name: "skill-one",
+			enabled: false,
+			workspaceRoot: tempRoot,
+			cwd: tempRoot,
+			userInstructionService,
+		});
+		const written = await readFile(skillPath, "utf8");
+
+		expect(written).toContain("disabled: true");
+		expect(result.changedTypes).toEqual(["skills"]);
+		expect(result.snapshot.skills[0]?.enabled).toBe(false);
+		expect(calls).toContain("refreshType:skill");
+		expect(calls.lastIndexOf("listRecords:skill")).toBeGreaterThan(
+			calls.indexOf("refreshType:skill"),
+		);
+	});
+
+	it("uses cwd as the workspace root when listing instruction settings", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-settings-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, ".cline", "skills", "skill-one");
+		await mkdir(skillDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use this skill.");
+
+		const snapshot = await new CoreSettingsService().list({ cwd: tempRoot });
+
+		expect(snapshot.skills).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					id: "skill-one",
+					name: "skill-one",
+					source: "workspace",
+					enabled: true,
+				}),
+			]),
+		);
+	});
+
+	it("lists bundled plugin skills with plugin ownership metadata", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-settings-plugin-skills-"),
+		);
+		tempRoots.push(tempRoot);
+		const installRoot = join(
+			tempRoot,
+			".cline",
+			"plugins",
+			"_installed",
+			"local",
+			"test-plugin-skill-owner",
+		);
+		const packageRoot = join(installRoot, "package");
+		const pluginPath = join(packageRoot, "index.ts");
+		const skillDir = join(packageRoot, "skills", "test-plugin-skill-owner");
+		await mkdir(skillDir, { recursive: true });
+		await writeFile(
+			join(installRoot, "package.json"),
+			JSON.stringify({
+				name: "test-plugin-skill-owner",
+				cline: {
+					plugins: [{ paths: ["./package/index.ts"] }],
+				},
+			}),
+		);
+		await writeFile(pluginPath, "export default {};");
+		await writeFile(
+			join(skillDir, "SKILL.md"),
+			`---
+name: test-plugin-skill-owner
+description: Browser agent
+---
+Use the browser.`,
+		);
+
+		const snapshot = await new CoreSettingsService().list({ cwd: tempRoot });
+
+		expect(snapshot.skills).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					id: "test-plugin-skill-owner",
+					name: "test-plugin-skill-owner",
+					source: "workspace-plugin",
+					pluginName: "test-plugin-skill-owner",
+					pluginPath,
+					enabled: true,
+				}),
+			]),
+		);
+	});
+
+	it("does not list skills from disabled plugins", async () => {
+		const tempRoot = await mkdtemp(
+			join(tmpdir(), "core-settings-plugin-skills-"),
+		);
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "global-settings.json");
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+		const installRoot = join(
+			tempRoot,
+			".cline",
+			"plugins",
+			"_installed",
+			"local",
+			"test-plugin-skill-disabled",
+		);
+		const packageRoot = join(installRoot, "package");
+		const pluginPath = join(packageRoot, "index.ts");
+		const skillDir = join(packageRoot, "skills", "test-plugin-skill-disabled");
+		await mkdir(skillDir, { recursive: true });
+		await writeFile(
+			join(installRoot, "package.json"),
+			JSON.stringify({
+				name: "test-plugin-skill-disabled",
+				cline: {
+					plugins: [{ paths: ["./package/index.ts"] }],
+				},
+			}),
+		);
+		await writeFile(pluginPath, "export default {};");
+		await writeFile(
+			join(skillDir, "SKILL.md"),
+			`---
+name: test-plugin-skill-disabled
+description: Browser agent
+---
+Use the browser.`,
+		);
+		await writeFile(
+			settingsPath,
+			JSON.stringify({ disabledPlugins: [pluginPath] }),
+		);
+
+		const snapshot = await new CoreSettingsService().list({ cwd: tempRoot });
+
+		expect(snapshot.skills).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					id: "test-plugin-skill-disabled",
+					pluginPath,
+				}),
+			]),
+		);
+	});
+
+	it("lists and toggles MCP server disabled state", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-settings-"));
+		tempRoots.push(tempRoot);
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		await writeFile(
+			settingsPath,
+			`${JSON.stringify(
+				{
+					otherSetting: true,
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "stdio",
+								command: "node",
+							},
+						},
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+		const service = new CoreSettingsService();
+
+		const snapshot = await service.list({ cwd: tempRoot });
+		expect(snapshot.mcp).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					id: "docs",
+					name: "docs",
+					path: settingsPath,
+					kind: "mcp",
+					enabled: true,
+					toggleable: true,
+				}),
+			]),
+		);
+
+		const result = await service.toggle({
+			type: "mcp",
+			name: "docs",
+			path: settingsPath,
+			enabled: false,
+			cwd: tempRoot,
+		});
+		const disabledSettings = JSON.parse(
+			await readFile(settingsPath, "utf8"),
+		) as {
+			otherSetting?: boolean;
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+		expect(result.changedTypes).toEqual(["mcp"]);
+		expect(result.snapshot.mcp[0]?.enabled).toBe(false);
+		expect(disabledSettings.otherSetting).toBe(true);
+		expect(disabledSettings.mcpServers?.docs?.disabled).toBe(true);
+
+		await service.toggle({
+			type: "mcp",
+			name: "docs",
+			path: settingsPath,
+			enabled: true,
+			cwd: tempRoot,
+		});
+		const enabledSettings = JSON.parse(
+			await readFile(settingsPath, "utf8"),
+		) as {
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+		expect(enabledSettings.mcpServers?.docs?.disabled).toBeUndefined();
+
+		await service.toggle({
+			type: "mcp",
+			name: "docs",
+			path: settingsPath,
+			cwd: tempRoot,
+		});
+		const implicitlyDisabledSettings = JSON.parse(
+			await readFile(settingsPath, "utf8"),
+		) as {
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+		expect(implicitlyDisabledSettings.mcpServers?.docs?.disabled).toBe(true);
+
+		await service.toggle({
+			type: "mcp",
+			name: "docs",
+			path: settingsPath,
+			cwd: tempRoot,
+		});
+		const implicitlyEnabledSettings = JSON.parse(
+			await readFile(settingsPath, "utf8"),
+		) as {
+			mcpServers?: Record<string, { disabled?: boolean }>;
+		};
+		expect(
+			implicitlyEnabledSettings.mcpServers?.docs?.disabled,
+		).toBeUndefined();
+	});
+
+	it("requires an explicit enabled value when skill state cannot be resolved", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-settings-"));
+		tempRoots.push(tempRoot);
+		const skillPath = join(tempRoot, "SKILL.md");
+		await writeFile(skillPath, "Use this skill.");
+		const userInstructionService = {
+			async refreshType() {},
+			listRecords(type: string) {
+				if (type !== "skill") {
+					return [];
+				}
+				return [
+					{
+						id: "skill-one",
+						type: "skill",
+						filePath: skillPath,
+						item: {
+							name: "skill-one",
+							description: "Skill one",
+							instructions: "Use this skill.",
+							frontmatter: {},
+						},
+					},
+				];
+			},
+		} as unknown as UserInstructionConfigService;
+
+		await expect(
+			new CoreSettingsService().toggle({
+				type: "skills",
+				id: "skill-one",
+				path: skillPath,
+				userInstructionService,
+			}),
+		).rejects.toThrow("Cannot determine toggle state");
+	});
+
+	it("rejects path-based skill toggles outside the resolved watcher snapshot", async () => {
+		const workspaceRoot = await mkdtemp(join(tmpdir(), "core-settings-"));
+		const outsideRoot = await mkdtemp(join(tmpdir(), "core-settings-outside-"));
+		tempRoots.push(workspaceRoot, outsideRoot);
+		const outsidePath = join(outsideRoot, "SKILL.md");
+		const outsideContent = "Outside file.";
+		await writeFile(outsidePath, outsideContent);
+
+		await expect(
+			new CoreSettingsService().toggle({
+				type: "skills",
+				path: outsidePath,
+				enabled: false,
+				workspaceRoot,
+				cwd: workspaceRoot,
+			}),
+		).rejects.toThrow("Unable to resolve skill setting");
+		expect(await readFile(outsidePath, "utf8")).toBe(outsideContent);
+	});
+
+	it("honors explicit enabled values for plugin tool settings", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-settings-"));
+		tempRoots.push(tempRoot);
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
+			tempRoot,
+			"global-settings.json",
+		);
+		const service = new CoreSettingsService();
+
+		await service.toggle({
+			type: "tools",
+			name: "plugin-tool",
+			enabled: false,
+		});
+		await service.toggle({
+			type: "tools",
+			name: "plugin-tool",
+			enabled: false,
+		});
+
+		expect(
+			JSON.parse(
+				await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
+			),
+		).toEqual({
+			autoUpdateEnabled: true,
+			disabledTools: ["plugin-tool"],
+			telemetryOptOut: false,
+		});
+
+		await service.toggle({ type: "tools", name: "plugin-tool", enabled: true });
+
+		expect(
+			JSON.parse(
+				await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
+			),
+		).toEqual({ autoUpdateEnabled: true, telemetryOptOut: false });
+	});
+});
diff --git a/sdk/packages/core/src/settings/settings-service.ts b/sdk/packages/core/src/settings/settings-service.ts
new file mode 100644
index 0000000..da995b2
--- /dev/null
+++ b/sdk/packages/core/src/settings/settings-service.ts
@@ -0,0 +1,436 @@
+import { existsSync, readFileSync } from "node:fs";
+import {
+	basename,
+	dirname,
+	extname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+} from "node:path";
+import {
+	createUserInstructionConfigService,
+	type RuleConfig,
+	type SkillConfig,
+	type UserInstructionConfigService,
+	type WorkflowConfig,
+} from "../extensions/config";
+import { toggleSkillFrontmatter } from "../extensions/config/skill-frontmatter-toggle";
+import {
+	hasMcpSettingsFile,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+	setMcpServerDisabled,
+} from "../extensions/mcp";
+import {
+	resolveAgentPluginPaths,
+	resolvePluginSkillDirectoriesFromPaths,
+} from "../extensions/plugin/plugin-config-loader";
+import {
+	setToolDisabledGlobally,
+	toggleDisabledTool,
+} from "../services/global-settings";
+import { listPluginTools } from "../services/plugin-tools";
+import type {
+	CoreSettingsItem,
+	CoreSettingsListInput,
+	CoreSettingsMutationResult,
+	CoreSettingsSnapshot,
+	CoreSettingsToggleInput,
+} from "./types";
+
+function detectSource(
+	filePath: string,
+	workspaceRoot: string,
+): "global" | "workspace" {
+	if (!workspaceRoot) {
+		return "global";
+	}
+	const relativePath = relative(workspaceRoot, filePath);
+	return !relativePath.startsWith("..") && !isAbsolute(relativePath)
+		? "workspace"
+		: "global";
+}
+
+function detectPluginSource(
+	filePath: string,
+	workspaceRoot: string,
+): "global-plugin" | "workspace-plugin" {
+	return detectSource(filePath, workspaceRoot) === "workspace"
+		? "workspace-plugin"
+		: "global-plugin";
+}
+
+function isPathWithin(parentPath: string, childPath: string): boolean {
+	const relativePath = relative(resolve(parentPath), resolve(childPath));
+	return (
+		relativePath === "" ||
+		(!relativePath.startsWith("..") && !isAbsolute(relativePath))
+	);
+}
+
+function readPackageName(packageJsonPath: string): string | undefined {
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+			name?: unknown;
+		};
+		return typeof packageJson.name === "string" && packageJson.name.trim()
+			? packageJson.name.trim()
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function getPluginDisplayName(filePath: string): string {
+	let current = dirname(filePath);
+	while (true) {
+		const packageJsonPath = join(current, "package.json");
+		if (existsSync(packageJsonPath)) {
+			const packageName = readPackageName(packageJsonPath);
+			if (packageName) {
+				return packageName;
+			}
+			break;
+		}
+		const parent = dirname(current);
+		if (parent === current) {
+			break;
+		}
+		current = parent;
+	}
+	return basename(filePath, extname(filePath));
+}
+
+type PluginSkillOwner = {
+	directory: string;
+	pluginName: string;
+	pluginPath: string;
+	source: "global-plugin" | "workspace-plugin";
+};
+
+function buildPluginSkillOwners(input: {
+	workspaceRoot: string;
+	cwd?: string;
+}): PluginSkillOwner[] {
+	const owners: PluginSkillOwner[] = [];
+	for (const pluginPath of resolveAgentPluginPaths({
+		workspacePath: input.workspaceRoot || undefined,
+		cwd: input.cwd,
+	})) {
+		for (const directory of resolvePluginSkillDirectoriesFromPaths([
+			pluginPath,
+		])) {
+			owners.push({
+				directory,
+				pluginName: getPluginDisplayName(pluginPath),
+				pluginPath,
+				source: input.workspaceRoot
+					? detectPluginSource(pluginPath, input.workspaceRoot)
+					: "global-plugin",
+			});
+		}
+	}
+	return owners.sort(
+		(left, right) => right.directory.length - left.directory.length,
+	);
+}
+
+function findPluginSkillOwner(
+	filePath: string,
+	owners: readonly PluginSkillOwner[],
+): PluginSkillOwner | undefined {
+	return owners.find((owner) => isPathWithin(owner.directory, filePath));
+}
+
+function toSorted<T extends CoreSettingsItem>(items: T[]): T[] {
+	return [...items].sort((a, b) => {
+		const sourceRank = (source: CoreSettingsItem["source"]): number => {
+			switch (source) {
+				case "workspace":
+				case "workspace-plugin":
+					return 0;
+				case "global":
+				case "global-plugin":
+					return 1;
+				case "builtin":
+					return 2;
+			}
+		};
+		if (a.source !== b.source) {
+			return sourceRank(a.source) - sourceRank(b.source);
+		}
+		return a.name.localeCompare(b.name);
+	});
+}
+
+function resolveWorkspaceRoot(input: CoreSettingsListInput): string {
+	return input.workspaceRoot?.trim() || input.cwd?.trim() || "";
+}
+
+function resolveCwd(
+	input: CoreSettingsListInput,
+	workspaceRoot: string,
+): string {
+	return input.cwd?.trim() || workspaceRoot || process.cwd();
+}
+
+async function withUserInstructionService<T>(
+	input: CoreSettingsListInput,
+	run: (service?: UserInstructionConfigService) => Promise<T>,
+): Promise<T> {
+	if (input.userInstructionService) {
+		return await run(input.userInstructionService);
+	}
+	const workspaceRoot = resolveWorkspaceRoot(input);
+	const cwd = resolveCwd(input, workspaceRoot);
+	const service = createUserInstructionConfigService({
+		skills: {
+			workspacePath: workspaceRoot || undefined,
+			includePluginSkills: true,
+			cwd,
+		},
+		rules: { workspacePath: workspaceRoot || undefined },
+		workflows: { workspacePath: workspaceRoot || undefined },
+	});
+	try {
+		await service.start();
+		return await run(service);
+	} finally {
+		service.stop();
+	}
+}
+
+function findSkillRecord(
+	service: UserInstructionConfigService | undefined,
+	input: CoreSettingsToggleInput,
+) {
+	if (!service) {
+		return undefined;
+	}
+	const records = service.listRecords<SkillConfig>("skill");
+	if (input.id) {
+		const match = records.find((record) => record.id === input.id);
+		if (match) {
+			return match;
+		}
+	}
+	for (const record of records) {
+		if (
+			record.filePath === input.path ||
+			record.item.name === input.name ||
+			record.id === input.name
+		) {
+			return record;
+		}
+	}
+	return undefined;
+}
+
+export class CoreSettingsService {
+	async list(input: CoreSettingsListInput = {}): Promise<CoreSettingsSnapshot> {
+		return await withUserInstructionService(input, async (service) => {
+			const workspaceRoot = resolveWorkspaceRoot(input);
+			const pluginSkillOwners = buildPluginSkillOwners({
+				workspaceRoot,
+				cwd: resolveCwd(input, workspaceRoot),
+			});
+			const workflows: CoreSettingsItem[] = [];
+			const rules: CoreSettingsItem[] = [];
+			const skills: CoreSettingsItem[] = [];
+			const tools: CoreSettingsItem[] = [];
+			const mcp: CoreSettingsItem[] = [];
+
+			if (service) {
+				for (const record of service.listRecords<WorkflowConfig>("workflow")) {
+					const workflow = record.item;
+					workflows.push({
+						id: record.id,
+						name: workflow.name,
+						path: record.filePath,
+						enabled: workflow.disabled !== true,
+						kind: "workflow",
+						source: detectSource(record.filePath, workspaceRoot),
+						description: workflow.instructions,
+						toggleable: false,
+					});
+				}
+				for (const record of service.listRecords<RuleConfig>("rule")) {
+					const rule = record.item;
+					rules.push({
+						id: record.id,
+						name: rule.name,
+						path: record.filePath,
+						enabled: rule.disabled !== true,
+						kind: "rule",
+						source: detectSource(record.filePath, workspaceRoot),
+						description: rule.instructions,
+						toggleable: false,
+					});
+				}
+				for (const record of service.listRecords<SkillConfig>("skill")) {
+					const skill = record.item;
+					const pluginOwner = findPluginSkillOwner(
+						record.filePath,
+						pluginSkillOwners,
+					);
+					skills.push({
+						id: record.id,
+						name: skill.name,
+						path: record.filePath,
+						enabled: skill.disabled !== true,
+						kind: "skill",
+						source:
+							pluginOwner?.source ??
+							detectSource(record.filePath, workspaceRoot),
+						description: skill.description,
+						pluginName: pluginOwner?.pluginName,
+						pluginPath: pluginOwner?.pluginPath,
+						toggleable: true,
+					});
+				}
+			}
+
+			if (workspaceRoot) {
+				try {
+					for (const pluginTool of await listPluginTools({
+						workspacePath: workspaceRoot,
+						cwd: input.cwd,
+						providerId: input.availabilityContext?.providerId,
+						modelId: input.availabilityContext?.modelId,
+					})) {
+						tools.push({
+							id: `${pluginTool.pluginName}:${pluginTool.name}:${pluginTool.path}`,
+							name: pluginTool.name,
+							path: pluginTool.path,
+							enabled: pluginTool.enabled,
+							kind: "tool",
+							source: pluginTool.source,
+							description: pluginTool.description,
+							toggleable: true,
+						});
+					}
+				} catch {
+					// Settings listing is best-effort; unreadable plugin roots should
+					// not hide rules, skills, workflows, or built-in tools.
+				}
+			}
+
+			const mcpSettingsPath = resolveDefaultMcpSettingsPath();
+			if (hasMcpSettingsFile({ filePath: mcpSettingsPath })) {
+				try {
+					for (const registration of resolveMcpServerRegistrations({
+						filePath: mcpSettingsPath,
+					})) {
+						mcp.push({
+							id: registration.name,
+							name: registration.name,
+							path: mcpSettingsPath,
+							enabled: registration.disabled !== true,
+							kind: "mcp",
+							source: detectSource(mcpSettingsPath, workspaceRoot),
+							description: registration.transport.type,
+							toggleable: true,
+						});
+					}
+				} catch {
+					// Settings listing is best-effort; unreadable MCP settings should
+					// not hide rules, skills, workflows, or tools.
+				}
+			}
+
+			return {
+				workflows: toSorted(workflows.filter((item) => existsSync(item.path))),
+				rules: toSorted(rules.filter((item) => existsSync(item.path))),
+				skills: toSorted(skills.filter((item) => existsSync(item.path))),
+				tools: toSorted(tools),
+				mcp: toSorted(mcp.filter((item) => existsSync(item.path))),
+			};
+		});
+	}
+
+	async toggle(
+		input: CoreSettingsToggleInput,
+	): Promise<CoreSettingsMutationResult> {
+		if (input.type === "skills") {
+			return await withUserInstructionService(input, async (service) => {
+				const record = findSkillRecord(service, input);
+				const filePath = record?.filePath;
+				if (!filePath) {
+					throw new Error(
+						`Unable to resolve skill setting '${input.id ?? input.name ?? basename(input.path ?? "")}'.`,
+					);
+				}
+				const currentEnabled =
+					record?.item && "disabled" in record.item
+						? (record.item as SkillConfig).disabled !== true
+						: undefined;
+				const enabled =
+					input.enabled ??
+					(currentEnabled !== undefined ? !currentEnabled : undefined);
+				if (enabled === undefined) {
+					throw new Error(
+						`Cannot determine toggle state for skill '${input.id ?? input.name ?? basename(input.path ?? "")}'; provide an explicit enabled value or a resolvable workspace context.`,
+					);
+				}
+				await toggleSkillFrontmatter({ filePath, enabled });
+				await service?.refreshType("skill");
+				return {
+					snapshot: await this.list({
+						...input,
+						userInstructionService: service,
+					}),
+					changedTypes: ["skills"],
+				};
+			});
+		}
+
+		if (input.type === "tools") {
+			if (!input.name?.trim()) {
+				throw new Error("Tool settings toggle requires a tool name.");
+			}
+			if (input.enabled === undefined) {
+				toggleDisabledTool(input.name);
+			} else {
+				setToolDisabledGlobally(input.name, !input.enabled);
+			}
+			return {
+				snapshot: await this.list(input),
+				changedTypes: ["tools"],
+			};
+		}
+
+		if (input.type === "mcp") {
+			const name = input.name?.trim() || input.id?.trim();
+			if (!name) {
+				throw new Error("MCP server settings toggle requires a server name.");
+			}
+			const filePath = input.path?.trim() || resolveDefaultMcpSettingsPath();
+			let targetEnabled = input.enabled;
+			if (targetEnabled === undefined) {
+				const current = resolveMcpServerRegistrations({ filePath }).find(
+					(registration) => registration.name === name,
+				);
+				if (!current) {
+					throw new Error(`Unknown MCP server: ${name}`);
+				}
+				targetEnabled = current.disabled === true;
+			}
+			setMcpServerDisabled({
+				filePath,
+				name,
+				disabled: !targetEnabled,
+			});
+			return {
+				snapshot: await this.list(input),
+				changedTypes: ["mcp"],
+			};
+		}
+
+		throw new Error(`Settings type '${input.type}' does not support toggles.`);
+	}
+}
+
+export function createCoreSettingsService(): CoreSettingsService {
+	return new CoreSettingsService();
+}
diff --git a/sdk/packages/core/src/settings/types.ts b/sdk/packages/core/src/settings/types.ts
new file mode 100644
index 0000000..238c5cb
--- /dev/null
+++ b/sdk/packages/core/src/settings/types.ts
@@ -0,0 +1,69 @@
+import type { UserInstructionConfigService } from "../extensions/config";
+import type { BuiltinToolAvailabilityContext } from "../extensions/tools";
+
+export type CoreSettingsType =
+	| "skills"
+	| "workflows"
+	| "rules"
+	| "tools"
+	| "mcp";
+
+export type CoreSettingsItemKind =
+	| "skill"
+	| "workflow"
+	| "rule"
+	| "tool"
+	| "mcp";
+
+export type CoreSettingsItemSource =
+	| "global"
+	| "workspace"
+	| "builtin"
+	| "global-plugin"
+	| "workspace-plugin";
+
+export interface CoreSettingsItem {
+	id: string;
+	name: string;
+	path: string;
+	kind: CoreSettingsItemKind;
+	source: CoreSettingsItemSource;
+	enabled?: boolean;
+	description?: string;
+	toggleable?: boolean;
+	pluginName?: string;
+	pluginPath?: string;
+}
+
+export interface CoreSettingsSnapshot {
+	workflows: CoreSettingsItem[];
+	rules: CoreSettingsItem[];
+	skills: CoreSettingsItem[];
+	tools: CoreSettingsItem[];
+	mcp: CoreSettingsItem[];
+}
+
+export interface CoreSettingsListInput {
+	cwd?: string;
+	workspaceRoot?: string;
+	userInstructionService?: UserInstructionConfigService;
+	availabilityContext?: BuiltinToolAvailabilityContext;
+}
+
+export interface CoreSettingsToggleInput extends CoreSettingsListInput {
+	type: CoreSettingsType;
+	id?: string;
+	path?: string;
+	name?: string;
+	enabled?: boolean;
+}
+
+export interface CoreSettingsMutationResult {
+	snapshot: CoreSettingsSnapshot;
+	changedTypes: CoreSettingsType[];
+}
+
+export interface ClineCoreSettingsApi {
+	list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+	toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}
diff --git a/sdk/packages/core/src/types.ts b/sdk/packages/core/src/types.ts
new file mode 100644
index 0000000..b89200d
--- /dev/null
+++ b/sdk/packages/core/src/types.ts
@@ -0,0 +1,202 @@
+export type {
+	AgentRunResult,
+	AgentRunStatus,
+	FeatureFlag,
+	FeatureFlagPayload,
+	FeatureFlagsAndPayloads,
+	FeatureFlagsContext,
+	FeatureFlagsSettings,
+	IFeatureFlagsProvider,
+	WorkspaceInfo,
+	WorkspaceManifest,
+} from "@cline/shared";
+export {
+	FEATURE_FLAGS,
+	FeatureFlagDefaultValue,
+} from "@cline/shared";
+export { ClineCore } from "./ClineCore";
+export type {
+	ClineCoreListHistoryOptions,
+	ClineCoreOptions,
+	ClineCoreStartInput,
+	HubOptions,
+	RemoteOptions,
+} from "./cline-core/types";
+export type {
+	LoadAgentPluginFromPathOptions,
+	ResolveAgentPluginPathsOptions,
+} from "./extensions";
+export {
+	discoverPluginModulePaths,
+	loadAgentPluginFromPath,
+	loadAgentPluginsFromPaths,
+	resolveAgentPluginPaths,
+	resolveAndLoadAgentPlugins,
+	resolvePluginConfigSearchPaths,
+	resolvePluginSkillDirectoriesFromPaths,
+} from "./extensions";
+export type {
+	CreateInstructionWatcherOptions,
+	CreateRulesConfigDefinitionOptions,
+	CreateSkillsConfigDefinitionOptions,
+	CreateUserInstructionConfigServiceOptions,
+	CreateWorkflowsConfigDefinitionOptions,
+	ParseMarkdownFrontmatterResult,
+	RuleConfig,
+	SkillConfig,
+	UnifiedConfigDefinition,
+	UnifiedConfigFileCandidate,
+	UnifiedConfigFileContext,
+	UnifiedConfigRecord,
+	UnifiedConfigWatcherEvent,
+	UnifiedConfigWatcherOptions,
+	UserInstructionConfig,
+	UserInstructionConfigRecord,
+	UserInstructionConfigService,
+	UserInstructionConfigType,
+	WorkflowConfig,
+} from "./extensions/config";
+export {
+	createRulesConfigDefinition,
+	createSkillsConfigDefinition,
+	createUserInstructionConfigService,
+	createWorkflowsConfigDefinition,
+	parseRuleConfigFromMarkdown,
+	parseSkillConfigFromMarkdown,
+	parseWorkflowConfigFromMarkdown,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveRulesConfigSearchPaths,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	UnifiedConfigFileWatcher,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "./extensions/config";
+export type {
+	BuiltinToolAvailabilityContext,
+	ToolCatalogEntry,
+} from "./extensions/tools";
+export {
+	getCoreAcpToolNames,
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	resolveCoreSelectedToolIds,
+	TEAM_TOOL_NAMES,
+} from "./extensions/tools";
+export type { RuntimeCapabilities } from "./runtime/capabilities";
+export type { SessionBackend } from "./runtime/host/host";
+export type {
+	PendingPromptMutationResult,
+	PendingPromptsDeleteInput,
+	PendingPromptsListInput,
+	PendingPromptsRuntimeService,
+	PendingPromptsServiceApi,
+	PendingPromptsUpdateInput,
+	RuntimeHost,
+	RuntimeHost as SessionHost,
+	RuntimeHostMode,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	SessionUsageSummary,
+	StartSessionInput,
+	StartSessionResult,
+} from "./runtime/host/runtime-host";
+export type {
+	BuiltRuntime as RuntimeEnvironment,
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	SessionRuntime,
+} from "./runtime/orchestration/session-runtime";
+export type {
+	SandboxCallOptions,
+	SubprocessSandboxOptions,
+} from "./runtime/tools/subprocess-sandbox";
+export { SubprocessSandbox } from "./runtime/tools/subprocess-sandbox";
+export {
+	FeatureFlagsService,
+	type FeatureFlagsServiceOptions,
+	NoOpFeatureFlagsProvider,
+} from "./services/feature-flags";
+export type { GlobalSettings } from "./services/global-settings";
+export {
+	filterDisabledPluginPaths,
+	filterDisabledTools,
+	filterExtensionToolRegistrations,
+	GlobalSettingsSchema,
+	isAutoUpdateEnabledGlobally,
+	isPluginDisabledGlobally,
+	isTelemetryOptedOutGlobally,
+	isToolDisabledGlobally,
+	readCompactionStrategyGlobally,
+	readGlobalSettings,
+	resolveDisabledPluginPaths,
+	resolveDisabledToolNames,
+	setAutoUpdateEnabledGlobally,
+	setCompactionStrategyGlobally,
+	setDisabledPlugin,
+	setDisabledTools,
+	setTelemetryOptOutGlobally,
+	toggleDisabledTool,
+	writeGlobalSettings,
+} from "./services/global-settings";
+export type { GlobalCompactionStrategy } from "./services/global-settings";
+export type {
+	ListPluginToolsResult,
+	PluginToolSummary,
+} from "./services/plugin-tools";
+export {
+	listPluginTools,
+	listPluginToolsWithDiagnostics,
+} from "./services/plugin-tools";
+export type {
+	WorkspaceManager,
+	WorkspaceManagerEvent,
+} from "./services/workspace/workspace-manager";
+export type { SessionManifest } from "./session/models/session-manifest";
+export type { SessionRow } from "./session/models/session-row";
+export type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+} from "./session/services/session-service";
+export type {
+	CoreSessionCheckpointSnapshot,
+	CoreSessionSnapshot,
+} from "./session/session-snapshot";
+export type {
+	SessionCheckpointRestoreContext,
+	SessionCheckpointRestoreResult,
+	SessionVersioningErrorCode,
+} from "./session/session-versioning-service";
+export type {
+	ChatMessage,
+	ChatSessionConfig,
+	ChatSessionStatus,
+	ChatSummary,
+	ChatViewState,
+} from "./types/chat-schema";
+export type { SessionSource, SessionStatus } from "./types/common";
+export type {
+	CoreAgentMode,
+	CoreModelConfig,
+	CoreRuntimeFeatures,
+	CoreSessionConfig,
+} from "./types/config";
+export type {
+	CoreSessionEvent,
+	SessionChunkEvent,
+	SessionEndedEvent,
+	SessionPendingPrompt,
+	SessionPendingPromptSubmittedEvent,
+	SessionPendingPromptsEvent,
+	SessionTeamProgressEvent,
+	SessionToolEvent,
+} from "./types/events";
+export type { SessionMessagesArtifactUploader } from "./types/session";
+export type {
+	SessionHistoryMetadata,
+	SessionHistoryRecord,
+	SessionRecord,
+	SessionRef,
+} from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";
diff --git a/sdk/packages/core/src/types/chat-schema.ts b/sdk/packages/core/src/types/chat-schema.ts
new file mode 100644
index 0000000..5af34f1
--- /dev/null
+++ b/sdk/packages/core/src/types/chat-schema.ts
@@ -0,0 +1,90 @@
+import { z } from "zod";
+
+export const ChatSessionConfigSchema = z.object({
+	workspaceRoot: z.string().min(1),
+	cwd: z.string().optional(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	mode: z.enum(["act", "plan"]).default("act"),
+	apiKey: z.string(),
+	systemPrompt: z.string().optional(),
+	rules: z.string().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	enableTools: z.boolean(),
+	enableSpawn: z.boolean().optional(),
+	enableTeams: z.boolean().optional(),
+	autoApproveTools: z.boolean().optional(),
+	missionStepInterval: z.number().int().positive().optional(),
+	missionTimeIntervalMs: z.number().int().positive().optional(),
+});
+
+export const ChatSessionStatusSchema = z.enum([
+	"idle",
+	"starting",
+	"running",
+	"pending",
+	"stopping",
+	"completed",
+	"cancelled",
+	"failed",
+	"error",
+]);
+
+export const ChatMessageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"tool",
+	"system",
+	"status",
+	"error",
+]);
+
+export const ChatMessageSchema = z.object({
+	id: z.string().min(1),
+	sessionId: z.string().nullable(),
+	role: ChatMessageRoleSchema,
+	content: z.string(),
+	createdAt: z.number().int().nonnegative(),
+	meta: z
+		.object({
+			stream: z.enum(["stdout", "stderr"]).optional(),
+			toolName: z.string().optional(),
+			iteration: z.number().int().nonnegative().optional(),
+			agentId: z.string().optional(),
+			conversationId: z.string().optional(),
+			hookEventName: z.string().optional(),
+			inputTokens: z.number().int().nonnegative().optional(),
+			outputTokens: z.number().int().nonnegative().optional(),
+			checkpoint: z
+				.object({
+					ref: z.string(),
+					createdAt: z.number().int().nonnegative(),
+					runCount: z.number().int().positive(),
+					kind: z.enum(["stash", "commit"]).optional(),
+				})
+				.optional(),
+		})
+		.optional(),
+});
+
+export const ChatSummarySchema = z.object({
+	toolCalls: z.number().int().nonnegative(),
+	tokensIn: z.number().int().nonnegative(),
+	tokensOut: z.number().int().nonnegative(),
+});
+
+export const ChatViewStateSchema = z.object({
+	sessionId: z.string().nullable(),
+	status: ChatSessionStatusSchema,
+	config: ChatSessionConfigSchema,
+	messages: z.array(ChatMessageSchema),
+	rawTranscript: z.string(),
+	error: z.string().nullable(),
+	summary: ChatSummarySchema,
+});
+
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;
diff --git a/sdk/packages/core/src/types/common.ts b/sdk/packages/core/src/types/common.ts
new file mode 100644
index 0000000..51fd096
--- /dev/null
+++ b/sdk/packages/core/src/types/common.ts
@@ -0,0 +1,54 @@
+import { SESSION_STATUS_VALUES } from "@cline/shared";
+
+export const SESSION_STATUSES = SESSION_STATUS_VALUES;
+
+export type SessionStatus = (typeof SESSION_STATUSES)[number];
+
+export const NON_TERMINAL_SESSION_STATUSES = [
+	"idle",
+	"running",
+	"pending",
+] as const satisfies readonly SessionStatus[];
+
+export type NonTerminalSessionStatus =
+	(typeof NON_TERMINAL_SESSION_STATUSES)[number];
+
+export type TerminalSessionStatus = Exclude<
+	SessionStatus,
+	NonTerminalSessionStatus
+>;
+
+export function isTerminalSessionStatus(
+	status: SessionStatus,
+): status is TerminalSessionStatus {
+	return !NON_TERMINAL_SESSION_STATUSES.includes(
+		status as NonTerminalSessionStatus,
+	);
+}
+
+export function isNonTerminalSessionStatus(
+	status: SessionStatus,
+): status is NonTerminalSessionStatus {
+	return !isTerminalSessionStatus(status);
+}
+
+export const SessionSource = {
+	CORE: "core",
+	CLI: "cli",
+	SUBAGENT: "subagent",
+	DESKTOP: "desktop",
+	KANBAN: "kanban",
+	API: "api",
+	WEB: "web",
+	VSCODE: "vscode",
+	ENTERPRISE: "enterprise",
+	IDE: "ide",
+	JETBRAINS: "jetbrains",
+	NEOVIM: "neovim",
+	UNKNOWN: "unknown",
+} as const;
+
+export type BuiltinSessionSource =
+	(typeof SessionSource)[keyof typeof SessionSource];
+
+export type SessionSource = BuiltinSessionSource | (string & {});
diff --git a/sdk/packages/core/src/types/config.ts b/sdk/packages/core/src/types/config.ts
new file mode 100644
index 0000000..6d5ad24
--- /dev/null
+++ b/sdk/packages/core/src/types/config.ts
@@ -0,0 +1,260 @@
+import type { ModelInfo } from "@cline/llms";
+import type {
+	AgentConfig,
+	AgentHooks,
+	AgentMode,
+	AgentTool,
+	BasicLogger,
+	ConsecutiveMistakeLimitContext,
+	ConsecutiveMistakeLimitDecision,
+	ExtensionContext,
+	HookErrorMode,
+	ITelemetryService,
+	MessageWithMetadata,
+	SessionExecutionConfig,
+	SessionPromptConfig,
+	SessionWorkspaceConfig,
+} from "@cline/shared";
+import type { ToolRoutingRule } from "../extensions/tools/model-tool-routing";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { ProviderConfig } from "./provider-settings";
+
+export type CoreAgentMode = AgentMode;
+
+export interface CoreModelConfig {
+	providerId: string;
+	modelId: string;
+	apiKey?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	providerConfig?: ProviderConfig;
+	knownModels?: Record<string, ModelInfo>;
+	/**
+	 * Request model-side thinking/reasoning when supported.
+	 */
+	thinking?: boolean;
+	/**
+	 * Explicit reasoning effort override for capable models.
+	 */
+	reasoningEffort?: ProviderConfig["reasoningEffort"];
+	/**
+	 * Explicit thinking/reasoning token budget for capable models.
+	 */
+	thinkingBudgetTokens?: number;
+	/**
+	 * Maximum output tokens per API call.
+	 */
+	maxTokensPerTurn?: number;
+}
+
+export interface CoreRuntimeFeatures {
+	enableTools: boolean;
+	enableSpawnAgent: boolean;
+	enableAgentTeams: boolean;
+	disableMcpSettingsTools?: boolean;
+	yolo?: boolean;
+}
+
+export interface CoreCompactionContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	messages: MessageWithMetadata[];
+	model: {
+		id: string;
+		provider: string;
+		info?: ModelInfo;
+	};
+	maxInputTokens: number;
+	triggerTokens: number;
+	targetTokens?: number;
+	thresholdRatio: number;
+	utilizationRatio: number;
+}
+
+// Mirrors BudgetPolicyIntent in extensions/context/budget-projection/types.ts.
+// Keep this public API type decoupled from the internal projection module.
+export type CoreCompactionBudgetPolicyIntent =
+	| "agentic_summary"
+	| "basic_compaction_projection"
+	| "normal_provider_request";
+
+// Mirrors LiveTailHandling in extensions/context/budget-projection/types.ts.
+// Keep this public API type decoupled from the internal projection module.
+export type CoreCompactionLiveTailHandling =
+	| "included_verbatim"
+	| "included_degraded"
+	| "summarized_as_context"
+	| "omitted_with_warning"
+	| "preserved_out_of_band";
+
+export interface CoreCompactionBudgetMetadata {
+	policyIntent: CoreCompactionBudgetPolicyIntent;
+	actionCount: number;
+	warningCount: number;
+	liveTailHandling: CoreCompactionLiveTailHandling;
+}
+
+export interface CoreCompactionResult {
+	messages: MessageWithMetadata[];
+	budget?: CoreCompactionBudgetMetadata;
+}
+
+export interface CoreCompactionSummarizerConfig {
+	providerId: string;
+	modelId: string;
+	apiKey?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	/**
+	 * Optional pre-resolved model metadata for the summarizer. Supplying either
+	 * this or `knownModels` lets agentic compaction budget summary input against
+	 * the summarizer model's actual context window instead of falling back to the
+	 * active model's window.
+	 */
+	modelInfo?: ModelInfo;
+	knownModels?: Record<string, ModelInfo>;
+	providerConfig?: ProviderConfig;
+	maxOutputTokens?: number;
+}
+
+export type CoreCompactionStrategy = "basic" | "agentic";
+
+export interface CoreCompactionConfig {
+	enabled?: boolean;
+	strategy?: CoreCompactionStrategy;
+	thresholdRatio?: number;
+	reserveTokens?: number;
+	preserveRecentTokens?: number;
+	maxInputTokens?: number;
+	summarizer?: CoreCompactionSummarizerConfig;
+	compact?: (
+		context: CoreCompactionContext,
+	) =>
+		| Promise<CoreCompactionResult | undefined>
+		| CoreCompactionResult
+		| undefined;
+}
+
+/**
+ * Context passed to a custom `createCheckpoint` implementation.
+ */
+export interface CoreCheckpointContext {
+	/** Absolute path to the working directory of the session. */
+	cwd: string;
+	/** The session identifier. */
+	sessionId: string;
+	/** Monotonically increasing run counter for this session (starts at 1). */
+	runCount: number;
+}
+
+/**
+ * Configuration for the built-in git-based checkpoint feature.
+ *
+ * Checkpoints capture a restorable snapshot of the workspace at the start of
+ * each root-agent run so that changes made during a session can be rolled back.
+ *
+ * @example Disable checkpoints entirely:
+ * ```ts
+ * checkpoint: { enabled: false }
+ * ```
+ *
+ * @example Bring your own checkpoint implementation:
+ * ```ts
+ * checkpoint: {
+ *   createCheckpoint: async ({ cwd, sessionId, runCount }) => {
+ *     const ref = await mySnapshotFn(cwd);
+ *     return { ref, createdAt: Date.now(), runCount };
+ *   },
+ * }
+ * ```
+ */
+export interface CoreCheckpointConfig {
+	/**
+	 * Whether to create checkpoints on each root-agent run start.
+	 * Defaults to `false` — checkpoints are **opt-in**. Set to `true` to
+	 * enable the built-in git stash/ref checkpoint behaviour for this session.
+	 */
+	enabled?: boolean;
+	/**
+	 * Replace the built-in git stash/ref checkpoint logic with a custom
+	 * implementation. Called once at the start of each root-agent run (before
+	 * the first agent iteration).
+	 *
+	 * Return an object with at least `ref`, `createdAt`, and `runCount` to have
+	 * the entry recorded in session metadata, or return `undefined` to skip
+	 * writing a checkpoint for that run.
+	 */
+	createCheckpoint?: (context: CoreCheckpointContext) =>
+		| Promise<
+				| {
+						ref: string;
+						createdAt: number;
+						runCount: number;
+						kind?: "stash" | "commit";
+				  }
+				| undefined
+		  >
+		| {
+				ref: string;
+				createdAt: number;
+				runCount: number;
+				kind?: "stash" | "commit";
+		  }
+		| undefined;
+}
+
+export interface CoreSessionConfig
+	extends CoreModelConfig,
+		CoreRuntimeFeatures,
+		Omit<SessionWorkspaceConfig, "workspaceRoot">,
+		Omit<SessionPromptConfig, "systemPrompt">,
+		Omit<
+			SessionExecutionConfig,
+			| "enableTools"
+			| "teamName"
+			| "missionLogIntervalSteps"
+			| "missionLogIntervalMs"
+			| "maxConsecutiveMistakes"
+		> {
+	/**
+	 * Core/hub runtime session identifier.
+	 *
+	 * When provided, this becomes the host-owned id for persistence, hub
+	 * subscriptions, send/abort/stop commands, and approval routing. When
+	 * omitted, the runtime host creates one. This is distinct from the agent
+	 * conversation id, which is generated by the conversation store for
+	 * transcript/tool/hook context.
+	 */
+	sessionId?: string;
+	workspaceRoot?: string;
+	systemPrompt: string;
+	teamName?: string;
+	missionLogIntervalSteps?: number;
+	missionLogIntervalMs?: number;
+	hooks?: AgentHooks;
+	hookErrorMode?: HookErrorMode;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+	extensionContext?: ExtensionContext;
+	extraTools?: AgentTool[];
+	pluginPaths?: string[];
+	extensions?: AgentConfig["extensions"];
+	execution?: AgentConfig["execution"];
+	compaction?: CoreCompactionConfig;
+	checkpoint?: CoreCheckpointConfig;
+	onTeamEvent?: (event: TeamEvent) => void;
+	onConsecutiveMistakeLimitReached?: (
+		context: ConsecutiveMistakeLimitContext,
+	) =>
+		| Promise<ConsecutiveMistakeLimitDecision>
+		| ConsecutiveMistakeLimitDecision;
+	toolRoutingRules?: ToolRoutingRule[];
+	/**
+	 * Optional skill allowlist for the `skills` tool. When provided, only these
+	 * skills are surfaced in tool metadata and invocable by name.
+	 */
+	skills?: string[];
+	workspaceMetadata?: string;
+}
diff --git a/sdk/packages/core/src/types/events.ts b/sdk/packages/core/src/types/events.ts
new file mode 100644
index 0000000..d14da84
--- /dev/null
+++ b/sdk/packages/core/src/types/events.ts
@@ -0,0 +1,92 @@
+import type { CoreSessionSnapshot } from "../session/session-snapshot";
+
+export interface SessionChunkEvent {
+	sessionId: string;
+	stream: "stdout" | "stderr" | "agent";
+	chunk: string;
+	ts: number;
+}
+
+export interface SessionEndedEvent {
+	sessionId: string;
+	reason: string;
+	ts: number;
+}
+
+export interface SessionToolEvent {
+	sessionId: string;
+	hookEventName:
+		| "tool_call"
+		| "tool_result"
+		| "agent_end"
+		| "agent_error"
+		| "session_shutdown";
+	agentId?: string;
+	conversationId?: string;
+	parentAgentId?: string;
+	iteration?: number;
+	toolName?: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	ts?: string;
+}
+
+export interface SessionTeamProgressEvent {
+	sessionId: string;
+	teamName: string;
+	lifecycle: import("@cline/shared").TeamProgressLifecycleEvent;
+	summary: import("@cline/shared").TeamProgressSummary;
+}
+
+export interface SessionPendingPrompt {
+	id: string;
+	prompt: string;
+	delivery: "queue" | "steer";
+	attachmentCount: number;
+	userImages?: string[];
+	userFiles?: string[];
+}
+
+export interface SessionPendingPromptsEvent {
+	sessionId: string;
+	prompts: SessionPendingPrompt[];
+}
+
+export interface SessionPendingPromptSubmittedEvent {
+	sessionId: string;
+	id: string;
+	prompt: string;
+	delivery: "queue" | "steer";
+	attachmentCount: number;
+	userImages?: string[];
+	userFiles?: string[];
+}
+
+export interface SessionSnapshotEvent {
+	sessionId: string;
+	snapshot: CoreSessionSnapshot;
+}
+
+export type CoreSessionEvent =
+	| { type: "chunk"; payload: SessionChunkEvent }
+	| {
+			type: "agent_event";
+			payload: {
+				sessionId: string;
+				event: import("@cline/shared").AgentEvent;
+				/** Identifies the named agent within the team (e.g. "educator", "assessor", "coordinator") for both lead and teammate agents */
+				teamAgentId?: string;
+				/** Whether this is the lead agent or a teammate */
+				teamRole?: "lead" | "teammate";
+			};
+	  }
+	| { type: "team_progress"; payload: SessionTeamProgressEvent }
+	| { type: "pending_prompts"; payload: SessionPendingPromptsEvent }
+	| {
+			type: "pending_prompt_submitted";
+			payload: SessionPendingPromptSubmittedEvent;
+	  }
+	| { type: "session_snapshot"; payload: SessionSnapshotEvent }
+	| { type: "ended"; payload: SessionEndedEvent }
+	| { type: "hook"; payload: SessionToolEvent }
+	| { type: "status"; payload: { sessionId: string; status: string } };
diff --git a/sdk/packages/core/src/types/index.ts b/sdk/packages/core/src/types/index.ts
new file mode 100644
index 0000000..c8091a6
--- /dev/null
+++ b/sdk/packages/core/src/types/index.ts
@@ -0,0 +1,26 @@
+export type { SessionSource, SessionStatus } from "./common";
+export type {
+	CoreAgentMode,
+	CoreModelConfig,
+	CoreRuntimeFeatures,
+	CoreSessionConfig,
+} from "./config";
+export type {
+	CoreSessionEvent,
+	SessionChunkEvent,
+	SessionEndedEvent,
+	SessionPendingPrompt,
+	SessionPendingPromptSubmittedEvent,
+	SessionPendingPromptsEvent,
+	SessionTeamProgressEvent,
+	SessionToolEvent,
+} from "./events";
+export type {
+	ProviderConfig,
+	ProviderSettings,
+	ProviderTokenSource,
+	StoredProviderSettings,
+	StoredProviderSettingsEntry,
+} from "./provider-settings";
+export type { SessionRecord, SessionRef } from "./sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./storage";
diff --git a/sdk/packages/core/src/types/provider-settings.ts b/sdk/packages/core/src/types/provider-settings.ts
new file mode 100644
index 0000000..1a9d2e1
--- /dev/null
+++ b/sdk/packages/core/src/types/provider-settings.ts
@@ -0,0 +1,56 @@
+import { z } from "zod";
+import {
+	type ProviderClient,
+	type ProviderConfig,
+	type ProviderProtocol,
+	type ProviderSettings,
+	ProviderSettingsSchema,
+	type ToProviderConfigOptions,
+	toProviderConfig,
+} from "../services/llms/provider-settings";
+
+export type {
+	ProviderClient,
+	ProviderConfig,
+	ProviderProtocol,
+	ProviderSettings,
+	ToProviderConfigOptions,
+};
+export const ProviderSettingsSchemaTyped: z.ZodType<ProviderSettings> =
+	ProviderSettingsSchema;
+export { toProviderConfig };
+
+export type ProviderTokenSource = "manual" | "oauth" | "migration";
+
+export interface StoredProviderSettingsEntry {
+	settings: ProviderSettings;
+	updatedAt: string;
+	tokenSource: ProviderTokenSource;
+}
+
+export interface StoredProviderSettings {
+	version: 1;
+	lastUsedProvider?: string;
+	providers: Record<string, StoredProviderSettingsEntry>;
+}
+
+export const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry> =
+	z.object({
+		settings: ProviderSettingsSchema,
+		updatedAt: z.string().datetime(),
+		tokenSource: z.enum(["manual", "oauth", "migration"]).default("manual"),
+	});
+
+export const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings> =
+	z.object({
+		version: z.literal(1),
+		lastUsedProvider: z.string().min(1).optional(),
+		providers: z.record(z.string(), StoredProviderSettingsEntrySchema),
+	});
+
+export function emptyStoredProviderSettings(): StoredProviderSettings {
+	return {
+		version: 1,
+		providers: {},
+	};
+}
diff --git a/sdk/packages/core/src/types/session.ts b/sdk/packages/core/src/types/session.ts
new file mode 100644
index 0000000..972f8f1
--- /dev/null
+++ b/sdk/packages/core/src/types/session.ts
@@ -0,0 +1,137 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentFinishReason } from "@cline/shared";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { BuiltRuntime } from "../runtime/orchestration/session-runtime";
+import type { SessionRuntime } from "../runtime/orchestration/session-runtime-orchestrator";
+import type { SessionCompactionState } from "../session/models/session-compaction";
+import type { SessionRow } from "../session/models/session-row";
+import type { RootSessionArtifacts } from "../session/services/session-service";
+import type { SessionSource, SessionStatus } from "./common";
+import type { CoreAgentMode, CoreSessionConfig } from "./config";
+
+export type ActiveSession = {
+	sessionId: string;
+	config: CoreSessionConfig;
+	sessionMetadata?: Record<string, unknown>;
+	artifacts?: RootSessionArtifacts;
+	source: SessionSource;
+	startedAt: string;
+	updatedAt: string;
+	status: SessionStatus;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	pendingPrompt?: string;
+	runtime: BuiltRuntime;
+	agent: SessionRuntime;
+	started: boolean;
+	aborting: boolean;
+	interactive: boolean;
+	persistedMessages?: LlmsProviders.MessageWithMetadata[];
+	compactionState?: SessionCompactionState;
+	compactionStateWriteQueue?: Promise<void>;
+	activeTeamRunIds: Set<string>;
+	pendingTeamRunUpdates: TeamRunUpdate[];
+	teamRunWaiters: Array<() => void>;
+	pendingPrompts: PendingPrompt[];
+	drainingPendingPrompts: boolean;
+	pluginSandboxShutdown?: () => Promise<void>;
+	turnUsageBaseline?: SessionAccumulatedUsage;
+	turnAggregateUsageBaseline?: SessionAccumulatedUsage;
+	turnPrimaryUsage?: SessionAccumulatedUsage;
+	turnUsageByAgent?: Map<string, SessionAccumulatedUsage>;
+	lastInteractiveTurnFinishReason?: AgentFinishReason;
+	/**
+	 * Set to `true` once the assistant successfully invoked the canonical
+	 * completion tool (`submit_and_exit`) for this session. Used to:
+	 *
+	 * 1. Emit `task.completed` exactly once at the moment the assistant
+	 *    declares completion (parity with original Cline's
+	 *    `attempt_completion`).
+	 * 2. Suppress the fallback `task.completed` emission from
+	 *    `shutdownSession(...)` so the same logical completion is not
+	 *    reported twice.
+	 *
+	 * Non-interactive sessions that finish without ever calling the
+	 * completion tool still receive a `task.completed` from the shutdown
+	 * fallback.
+	 */
+	submitAndExitObserved: boolean;
+};
+
+export type PendingPrompt = {
+	id: string;
+	prompt: string;
+	mode?: CoreAgentMode;
+	delivery: "queue" | "steer";
+	userImages?: string[];
+	userFiles?: string[];
+};
+
+export type TeamRunUpdate = {
+	runId: string;
+	agentId: string;
+	taskId?: string;
+	status: "completed" | "failed" | "cancelled" | "interrupted";
+	error?: string;
+	iterations?: number;
+};
+
+export type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata;
+
+export type PreparedTurnInput = {
+	prompt: string;
+	userImages?: string[];
+	userFiles?: string[];
+};
+
+// ── Persistence interfaces ────────────────────────────────────────────
+
+export interface PersistedSessionUpdateInput {
+	sessionId: string;
+	expectedStatusLock?: number;
+	status?: SessionStatus;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	prompt?: string | null;
+	metadata?: Record<string, unknown> | null;
+	title?: string | null;
+	parentSessionId?: string | null;
+	parentAgentId?: string | null;
+	agentId?: string | null;
+	conversationId?: string | null;
+	setRunning?: boolean;
+}
+
+export interface SessionPersistenceAdapter {
+	ensureSessionsDir(): string;
+	upsertSession(row: SessionRow): Promise<void>;
+	getSession(sessionId: string): Promise<SessionRow | undefined>;
+	listSessions(options: {
+		limit: number;
+		parentSessionId?: string;
+		status?: string;
+	}): Promise<SessionRow[]>;
+	updateSession(
+		input: PersistedSessionUpdateInput,
+	): Promise<{ updated: boolean; statusLock: number }>;
+	deleteSession(sessionId: string, cascade: boolean): Promise<boolean>;
+	enqueueSpawnRequest(input: {
+		rootSessionId: string;
+		parentAgentId: string;
+		task?: string;
+		systemPrompt?: string;
+	}): Promise<void>;
+	claimSpawnRequest(
+		rootSessionId: string,
+		parentAgentId: string,
+	): Promise<string | undefined>;
+}
+
+export interface SessionMessagesArtifactUploader {
+	uploadMessagesFile(input: {
+		sessionId: string;
+		path: string;
+		contents: string;
+		row?: SessionRow;
+	}): Promise<void>;
+}
diff --git a/sdk/packages/core/src/types/sessions.ts b/sdk/packages/core/src/types/sessions.ts
new file mode 100644
index 0000000..45b1e54
--- /dev/null
+++ b/sdk/packages/core/src/types/sessions.ts
@@ -0,0 +1,45 @@
+import type { SessionLineage, SessionRuntimeRecordShape } from "@cline/shared";
+import type { SessionSource, SessionStatus } from "./common";
+
+export interface SessionUsageMetadata {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalCost: number;
+}
+
+export interface SessionRef extends SessionLineage {
+	sessionId: string;
+}
+
+export interface SessionRecord
+	extends SessionRef,
+		Omit<SessionRuntimeRecordShape, "source" | "status"> {
+	source: SessionSource;
+	status: SessionStatus;
+}
+
+export interface SessionHistoryMetadata extends Record<string, unknown> {
+	title?: string;
+	totalCost?: number;
+	aggregatedAgentsCost?: number;
+	usage?: SessionUsageMetadata;
+	aggregateUsage?: SessionUsageMetadata;
+	checkpoint?: {
+		latest?: {
+			ref?: string;
+			createdAt?: number;
+			runCount?: number;
+		};
+		history?: Array<{
+			ref?: string;
+			createdAt?: number;
+			runCount?: number;
+		}>;
+	};
+}
+
+export interface SessionHistoryRecord extends Omit<SessionRecord, "metadata"> {
+	metadata?: SessionHistoryMetadata;
+}
diff --git a/sdk/packages/core/src/types/storage.ts b/sdk/packages/core/src/types/storage.ts
new file mode 100644
index 0000000..5f9bd67
--- /dev/null
+++ b/sdk/packages/core/src/types/storage.ts
@@ -0,0 +1,56 @@
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cline/shared";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { SessionStatus } from "./common";
+import type { SessionRecord } from "./sessions";
+
+export interface SessionStore {
+	init(): Promise<void> | void;
+	create(record: SessionRecord): Promise<void> | void;
+	updateStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): Promise<void> | void;
+	update(
+		record: Partial<SessionRecord> & { sessionId: string },
+	): Promise<void> | void;
+	get(
+		sessionId: string,
+	): Promise<SessionRecord | undefined> | SessionRecord | undefined;
+	list(limit?: number): Promise<SessionRecord[]> | SessionRecord[];
+	delete(sessionId: string, cascade?: boolean): Promise<boolean> | boolean;
+}
+
+export interface TeamStore {
+	listTeamNames(): Promise<string[]> | string[];
+	readState(
+		teamName: string,
+	): Promise<TeamRuntimeState | undefined> | TeamRuntimeState | undefined;
+	readHistory(teamName: string, limit?: number): Promise<unknown[]> | unknown[];
+	loadRuntime(teamName: string):
+		| Promise<{
+				state?: TeamRuntimeState;
+				teammates: TeamTeammateSpec[];
+				interruptedRunIds: string[];
+		  }>
+		| {
+				state?: TeamRuntimeState;
+				teammates: TeamTeammateSpec[];
+				interruptedRunIds: string[];
+		  };
+	handleTeamEvent(teamName: string, event: TeamEvent): Promise<void> | void;
+	persistRuntime(
+		teamName: string,
+		state: TeamRuntimeState,
+		teammates: TeamTeammateSpec[],
+	): Promise<void> | void;
+	markInProgressRunsInterrupted(
+		teamName: string,
+		reason: string,
+	): Promise<string[]> | string[];
+}
+
+export interface ArtifactStore {
+	appendHook(sessionId: string, payload: unknown): Promise<void> | void;
+	writeMessages(sessionId: string, messages: unknown[]): Promise<void> | void;
+}
diff --git a/sdk/packages/core/src/version.ts b/sdk/packages/core/src/version.ts
new file mode 100644
index 0000000..241df79
--- /dev/null
+++ b/sdk/packages/core/src/version.ts
@@ -0,0 +1,3 @@
+import { version } from "../package.json";
+
+export const CORE_BUILD_VERSION = version;
diff --git a/sdk/packages/core/tsconfig.build.json b/sdk/packages/core/tsconfig.build.json
new file mode 100644
index 0000000..0d8804f
--- /dev/null
+++ b/sdk/packages/core/tsconfig.build.json
@@ -0,0 +1,19 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"sourceMap": false,
+		"declarationMap": false,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"incremental": false
+	},
+	"include": [
+		"src/index.ts",
+		"src/hub/index.ts",
+		"src/hub/daemon/entry.ts",
+		"src/services/telemetry/index.ts",
+		"src/services/feature-flags/posthog.ts"
+	]
+}
diff --git a/sdk/packages/core/tsconfig.dev.json b/sdk/packages/core/tsconfig.dev.json
new file mode 100644
index 0000000..b5764df
--- /dev/null
+++ b/sdk/packages/core/tsconfig.dev.json
@@ -0,0 +1,7 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"noUnusedLocals": false,
+		"noUnusedParameters": false
+	}
+}
diff --git a/sdk/packages/core/tsconfig.json b/sdk/packages/core/tsconfig.json
new file mode 100644
index 0000000..b887fba
--- /dev/null
+++ b/sdk/packages/core/tsconfig.json
@@ -0,0 +1,22 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"rootDir": "..",
+		"noEmit": true,
+		"paths": {
+			"@cline/agents": ["../agents/src/index.ts"],
+			"@cline/agents/*": ["../agents/src/*", "../agents/src/*/index.ts"],
+			"@cline/llms": ["../llms/src/index.ts"],
+			"@cline/llms/browser": ["../llms/src/index.browser.ts"],
+			"@cline/shared": ["../shared/src/index.ts"],
+			"@cline/shared/automation": ["../shared/src/automation/index.ts"],
+			"@cline/shared/browser": ["../shared/src/index.browser.ts"],
+			"@cline/shared/db": ["../shared/src/db/index.ts"],
+			"@cline/shared/storage": ["../shared/src/storage/index.ts"],
+			"@cline/shared/types": ["../shared/src/types/index.ts"],
+			"@cline/shared/*": ["../shared/src/*", "../shared/src/*/index.ts"]
+		}
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "fixtures"]
+}
diff --git a/sdk/packages/core/tsconfig.smoke.json b/sdk/packages/core/tsconfig.smoke.json
new file mode 100644
index 0000000..917eec5
--- /dev/null
+++ b/sdk/packages/core/tsconfig.smoke.json
@@ -0,0 +1,18 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"baseUrl": ".",
+		"rootDir": "..",
+		"noEmit": true,
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"paths": {
+			"@cline/agents": ["../agents/src/index.ts"],
+			"@cline/agents/*": ["../agents/src/*", "../agents/src/*/index.ts"],
+			"@cline/llms": ["../llms/src/index.ts"],
+			"@cline/shared": ["../shared/src/index.ts"],
+			"@cline/shared/*": ["../shared/src/*", "../shared/src/*/index.ts"]
+		}
+	},
+	"include": ["scripts/**/*", "src/**/*"]
+}
diff --git a/sdk/packages/core/vitest.config.ts b/sdk/packages/core/vitest.config.ts
new file mode 100644
index 0000000..41379a1
--- /dev/null
+++ b/sdk/packages/core/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts"],
+		exclude: ["src/**/*.e2e.test.ts"],
+	},
+});
diff --git a/sdk/packages/core/vitest.e2e.config.ts b/sdk/packages/core/vitest.e2e.config.ts
new file mode 100644
index 0000000..95d1ea9
--- /dev/null
+++ b/sdk/packages/core/vitest.e2e.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.e2e.test.ts"],
+		testTimeout: 30_000,
+		hookTimeout: 30_000,
+	},
+});
diff --git a/sdk/packages/llms/AGENTS.md b/sdk/packages/llms/AGENTS.md
new file mode 100644
index 0000000..1a370d6
--- /dev/null
+++ b/sdk/packages/llms/AGENTS.md
@@ -0,0 +1,39 @@
+---
+description: Development guidance for the @cline/llms package.
+globs: "src/**/*.ts,src/**/*.tsx,*.md"
+alwaysApply: true
+---
+
+# @cline/llms Development Guidance
+
+## Provider Option Routing
+
+- `models.dev` catalog data and AI SDK provider behavior are the default
+  sources of truth for general model/provider support.
+- Do not build a broad Cline-maintained model capability or behavior registry.
+- `GatewayModelCapability` is semantic: what the model can do, not provider
+  quirks, default behavior, or wire-format details.
+- Stable, reliable known-model facts belong in typed `ModelInfo.metadata`
+  helpers or `src/providers/model-facts.ts`.
+- Stable provider routing facts belong in `GatewayProviderMetadata.routing`
+  and the relevant builtin provider manifest. For example, if a native
+  provider uses a known reasoning wire format for a model route, add a typed
+  `GatewayReasoningFormat` value and route metadata instead of matching that
+  provider id directly in a rule predicate.
+- Provider wire-format encoding belongs in `PROVIDER_OPTION_RULES` and codec
+  helpers under `src/providers/routing`.
+- Local or dynamic provider fallbacks, such as Ollama or routed model-id
+  heuristics, are allowed only as documented, narrowly scoped, tested
+  exceptions.
+- Fallback heuristics need negative or graceful-degradation tests, not only
+  happy-path tests.
+
+When changing provider options, keep the split explicit:
+
+```text
+request intent + model/provider facts -> named provider-option rule -> provider wire format
+```
+
+If the same fact-resolution logic is needed across several providers, use a
+shared helper first. Add a new registry only after repeated logic proves the
+rule table and helpers are no longer enough.
diff --git a/sdk/packages/llms/README.md b/sdk/packages/llms/README.md
new file mode 100644
index 0000000..7635382
--- /dev/null
+++ b/sdk/packages/llms/README.md
@@ -0,0 +1,227 @@
+# [experimental] @cline/llms
+
+`@cline/llms` is the model and provider layer for the Cline SDK. It gives
+you typed provider settings, model catalogs, shared gateway contracts, and
+AI SDK-backed handler creation for supported LLM backends.
+
+## What You Get
+
+- `@cline/llms/runtime` for declarative config and runtime registry creation
+- `@cline/llms/providers` for handler creation and provider settings/types
+- `@cline/llms/models` for model catalogs and query helpers
+- `@cline/llms` root exports for the gateway registry and shared llm contracts
+
+## Installation
+
+```bash
+npm install @cline/llms zod
+```
+
+## Quick Start
+
+```ts
+import { createHandler } from "@cline/llms";
+
+const handler = createHandler({
+	providerId: "anthropic",
+	apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+	modelId: "claude-sonnet-4-6",
+});
+
+for await (const chunk of handler.createMessage("You are a concise assistant.", [
+	{ role: "user", content: [{ type: "text", text: "Say hello." }] },
+])) {
+	console.log(chunk);
+}
+```
+
+## Main APIs
+
+### Runtime
+
+Use `createLlmsRuntime(...)` when you want a small registry around:
+
+- configured providers and their default models
+- builtin provider discovery via `getBuiltInProviders()`
+- custom provider registration via `registerBuiltinProvider(...)`
+- handler creation for builtin or custom providers
+
+Preferred import:
+
+```ts
+import { createLlmsRuntime, defineLlmsConfig } from "@cline/llms/runtime";
+```
+
+### Providers
+
+Use `@cline/llms/providers` for:
+
+- `createHandler(...)` and `createHandlerAsync(...)`
+- `ProviderSettings` and `ProviderSettingsSchema`
+- `ProviderConfig`
+- `Message` and `ApiStreamChunk`
+
+Built-in providers are routed through the internal gateway registry and backed by
+AI SDK provider implementations. Shared gateway contracts are exported from both
+`@cline/llms` and `@cline/shared`.
+
+### Models
+
+Use `@cline/llms/models` when you need generated provider/model metadata for
+selection UIs, defaults, or validation.
+
+For generated catalog field semantics and token-limit behavior, see
+[`src/catalog/README.md`](./src/catalog/README.md).
+
+## Entry Points
+
+- `@cline/llms`: runtime-focused convenience entrypoint
+- `@cline/llms/node`: explicit Node/runtime entrypoint
+- `@cline/llms/browser`: browser-safe bundle
+- `@cline/llms/runtime`: focused runtime entrypoint
+- `@cline/llms/models`: model catalog/query entrypoint
+- `@cline/llms/providers`: provider handler/settings entrypoint
+
+## Related Packages
+
+- `@cline/agents`: agent loop and tool execution
+- `@cline/core`: stateful runtime assembly and provider settings storage
+
+## More Examples
+
+- Workspace overview: [README.md](https://github.com/cline/cline/blob/main/README.md)
+- API and architecture references: [DOC.md](https://github.com/cline/cline/blob/main/DOC.md), [ARCHITECTURE.md](https://github.com/cline/cline/blob/main/ARCHITECTURE.md)
+
+## Live Provider Smoke Test
+
+Use this for API-key-backed provider validation against real endpoints.
+
+1. Ensure provider keys are present in your environment (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `CLINE_API_KEY`, etc.).
+2. Use the sample config at `packages/llms/src/tests/live-providers.example.json` as the providers list.
+3. Run:
+
+```bash
+LLMS_LIVE_TESTS=1 \
+LLMS_LIVE_PROVIDERS_PATH=/absolute/path/to/packages/llms/src/tests/live-providers.example.json \
+bun -F @cline/llms run test:live
+```
+
+Reasoning-focused live run (same command, different flags):
+
+```bash
+LLMS_LIVE_REASONING_TESTS=1 \
+LLMS_LIVE_REASONING_PROVIDERS_PATH=/absolute/path/to/packages/llms/src/tests/live-providers.reasoning.example.json \
+bun -F @cline/llms run test:live
+```
+
+Tool-use-focused live run (same command, different flags):
+
+```bash
+LLMS_LIVE_TOOL_TESTS=1 \
+LLMS_LIVE_TOOL_PROVIDERS_PATH=/absolute/path/to/packages/llms/src/tests/live-providers.tools.example.json \
+bun -F @cline/llms run test:live
+```
+
+Optional:
+
+- `LLMS_LIVE_PROVIDER_TIMEOUT_MS=120000` to increase per-provider timeout.
+- `LLMS_LIVE_PROVIDER_RETRIES=2` to retry transient upstream/provider failures per provider (total attempts = retries + 1).
+- `LLMS_LIVE_PROVIDER_CONCURRENCY=3` to run multiple provider entries in parallel. Defaults to `3`; lower it if you need stricter provider rate-limit behavior.
+- Point `LLMS_LIVE_PROVIDERS_PATH` to a custom file if you want a narrower provider set.
+- Point `LLMS_LIVE_REASONING_PROVIDERS_PATH` to a custom file for reasoning-enabled suites.
+- Point `LLMS_LIVE_TOOL_PROVIDERS_PATH` to a custom file for tool-use suites.
+- Use `apiKeyEnv`, `baseUrlEnv`, and `headersEnv` in a provider entry when a live config needs secrets without writing them to JSON.
+- When recording provider cassettes for committed replay tests, set `CLINE_VCR=record` and `CLINE_VCR_INCLUDE_REQUEST_BODY=1` so playback also verifies the sanitized request body contract.
+
+OpenAI Codex subscription live runs use the saved OAuth credentials from `~/.cline/data/settings/providers.json` after `cline auth --provider openai-codex`. Point the plain or reasoning suite at `packages/llms/src/tests/live-providers.openai-codex.example.json` or `packages/llms/src/tests/live-providers.openai-codex.reasoning.example.json`.
+
+Per-provider live assertions are configured in the JSON via `expectations`:
+
+- `requireUsage`: fail if no `usage` chunk is emitted (defaults to `true`; set to `false` to opt out).
+- `requireCacheReadTokens`: fail unless `cacheReadTokens > 0` (auto-runs at least 2 attempts with a long cache probe prompt if no prompt override is provided).
+- `minCacheReadTokens`: stricter cache floor check.
+- `requireReasoningChunk`: fail unless at least one reasoning chunk is emitted.
+- `requireNoReasoningChunk`: fail if any reasoning chunk is emitted.
+- `minInputTokens` / `minOutputTokens`: enforce lower bounds.
+- `requireToolCall`: fail unless at least one `tool_calls` chunk is emitted.
+
+In reasoning suites, set `requireReasoningSignal: true` to require either a reasoning chunk or provider-reported hidden reasoning tokens (provider-dependent; can be flaky on some endpoints).
+To check that disabling reasoning actually suppresses reasoning output across models, use `packages/llms/src/tests/live-providers.reasoning-disabled.example.json`; it covers direct and routed provider paths across `cline`, `openai`, `openrouter`, `anthropic`, `gemini`, `vercel-ai-gateway`, `zai`, and `deepseek` where model support exists, with `reasoning.enabled: false` and the strongest available no-reasoning expectation for each provider.
+
+Common live failure classes:
+
+- `Overloaded`: provider/model capacity issue or transient upstream saturation.
+- `Insufficient Balance`: the provider account needs funds.
+- `Model Not Exist`: the model id is not available for that provider/account.
+- assertion failures such as `expected no reasoning chunks`: likely real SDK/provider-option behavior regressions.
+
+### Adding A Model To Live Tests
+
+Add a new entry under the `providers` object in either config file:
+
+- Cache/smoke suite: `packages/llms/src/tests/live-providers.example.json`
+- Reasoning suite: `packages/llms/src/tests/live-providers.reasoning.example.json`
+- Reasoning-disabled suite (asserts no reasoning chunks when reasoning is off): `packages/llms/src/tests/live-providers.reasoning-disabled.example.json`
+- Tool-use suite: `packages/llms/src/tests/live-providers.tools.example.json`
+
+Minimal smoke/cache entry:
+
+```json
+"my-openai-model": {
+  "settings": {
+    "provider": "openai",
+    "model": "gpt-5.4"
+  },
+  "expectations": {
+    "requireUsage": true
+  }
+}
+```
+
+Cache-asserted entry (auto-enforces multi-run cache probe):
+
+```json
+"my-cache-model": {
+  "settings": {
+    "provider": "openai",
+    "model": "gpt-5.4"
+  },
+  "expectations": {
+    "requireUsage": true,
+    "requireCacheReadTokens": true
+  }
+}
+```
+
+Reasoning entry:
+
+```json
+"my-reasoning-model": {
+  "settings": {
+    "provider": "anthropic",
+    "model": "claude-sonnet-4-6",
+    "reasoning": {
+      "effort": "high"
+    }
+  },
+  "expectations": {
+    "requireUsage": true,
+    "requireReasoningChunk": true
+  }
+}
+```
+
+Tool-use entry:
+
+```json
+"my-tools-model": {
+  "settings": {
+    "provider": "openai",
+    "model": "gpt-5.4"
+  },
+  "expectations": {
+    "requireUsage": true,
+    "requireToolCall": true
+  }
+}
+```
diff --git a/sdk/packages/llms/bun.mts b/sdk/packages/llms/bun.mts
new file mode 100644
index 0000000..ce665ae
--- /dev/null
+++ b/sdk/packages/llms/bun.mts
@@ -0,0 +1,51 @@
+/// <reference types="@types/bun" />
+export {};
+
+type PackageManifest = {
+	dependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+};
+
+const packageJson = (await Bun.file(
+	new URL("./package.json", import.meta.url),
+).json()) as PackageManifest;
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+// minify: true keeps identifier mangling active even when sourcemaps are enabled.
+const minify = Bun.env.CLINE_SOURCEMAPS !== "1";
+
+// Keep published third-party runtime packages external, but bundle internal workspace code.
+const external = Object.keys({
+	...(packageJson.dependencies ?? {}),
+	...(packageJson.peerDependencies ?? {}),
+}).filter((name) => !name.startsWith("@cline/"));
+
+const builds: Parameters<typeof Bun.build>[0][] = [
+	{
+		entrypoints: ["./src/index.ts", "./src/models.ts", "./src/providers.ts"],
+		outdir: "./dist",
+		target: "node",
+		external,
+		packages: "bundle",
+		minify,
+		sourcemap,
+	},
+	{
+		entrypoints: ["./src/index.browser.ts", "./src/providers.browser.ts"],
+		outdir: "./dist",
+		target: "browser",
+		external,
+		packages: "bundle",
+		minify,
+		sourcemap,
+	},
+];
+
+for (const config of builds) {
+	const result = await Bun.build(config);
+
+	if (result.logs.length > 0) {
+		for (const log of result.logs) {
+			console.warn(log);
+		}
+	}
+}
diff --git a/sdk/packages/llms/fixtures/usage.json b/sdk/packages/llms/fixtures/usage.json
new file mode 100644
index 0000000..ebc4b32
--- /dev/null
+++ b/sdk/packages/llms/fixtures/usage.json
@@ -0,0 +1,308 @@
+{
+	"openrouter_finish": {
+		"type": "finish",
+		"finishReason": "stop",
+		"rawFinishReason": "stop",
+		"totalUsage": {
+			"inputTokens": 9096,
+			"inputTokenDetails": {
+				"noCacheTokens": 6,
+				"cacheReadTokens": 9090,
+				"cacheWriteTokens": null
+			},
+			"outputTokens": 77,
+			"outputTokenDetails": {
+				"textTokens": 77,
+				"reasoningTokens": 0
+			},
+			"totalTokens": 9173,
+			"reasoningTokens": 0,
+			"cachedInputTokens": 9090
+		}
+	},
+	"openrouter_stream_usage": {
+		"inputTokens": 9096,
+		"inputTokenDetails": {
+			"noCacheTokens": 6,
+			"cacheReadTokens": 9090,
+			"cacheWriteTokens": null
+		},
+		"outputTokens": 77,
+		"outputTokenDetails": {
+			"textTokens": 77,
+			"reasoningTokens": 0
+		},
+		"totalTokens": 9173,
+		"raw": {
+			"prompt_tokens": 9096,
+			"completion_tokens": 77,
+			"total_tokens": 9173,
+			"prompt_tokens_details": {
+				"cached_tokens": 9090
+			},
+			"completion_tokens_details": {
+				"reasoning_tokens": 0
+			},
+			"cost": 0.000325,
+			"is_byok": true,
+			"cost_details": {
+				"upstream_inference_cost": 0.0065,
+				"upstream_inference_prompt_cost": 0.004575,
+				"upstream_inference_completions_cost": 0.001925
+			}
+		},
+		"reasoningTokens": 0,
+		"cachedInputTokens": 9090
+	},
+	"gemini_finish": {
+		"type": "finish",
+		"finishReason": "stop",
+		"rawFinishReason": "STOP",
+		"totalUsage": {
+			"inputTokens": 4605,
+			"inputTokenDetails": {
+				"noCacheTokens": 4605,
+				"cacheReadTokens": 0,
+				"cacheWriteTokens": null
+			},
+			"outputTokens": 120,
+			"outputTokenDetails": {
+				"textTokens": 120,
+				"reasoningTokens": 0
+			},
+			"totalTokens": 4725,
+			"reasoningTokens": 0,
+			"cachedInputTokens": 0
+		}
+	},
+	"gemini_stream_usage": {
+		"inputTokens": 4605,
+		"inputTokenDetails": {
+			"noCacheTokens": 4605,
+			"cacheReadTokens": 0,
+			"cacheWriteTokens": null
+		},
+		"outputTokens": 120,
+		"outputTokenDetails": {
+			"textTokens": 120,
+			"reasoningTokens": 0
+		},
+		"totalTokens": 4725,
+		"raw": {
+			"promptTokenCount": 4605,
+			"candidatesTokenCount": 120,
+			"totalTokenCount": 4725,
+			"promptTokensDetails": [{}]
+		},
+		"reasoningTokens": 0,
+		"cachedInputTokens": 0
+	},
+	"anthropic_finish": {
+		"type": "finish",
+		"finishReason": "stop",
+		"rawFinishReason": "end_turn",
+		"totalUsage": {
+			"inputTokens": 6538,
+			"inputTokenDetails": {
+				"noCacheTokens": 3,
+				"cacheReadTokens": 0,
+				"cacheWriteTokens": 6535
+			},
+			"outputTokens": 176,
+			"outputTokenDetails": {
+				"textTokens": null,
+				"reasoningTokens": null
+			},
+			"totalTokens": 6714,
+			"reasoningTokens": null,
+			"cachedInputTokens": 0
+		}
+	},
+	"anthropic_stream_usage": {
+		"inputTokens": 6538,
+		"inputTokenDetails": {
+			"noCacheTokens": 3,
+			"cacheReadTokens": 0,
+			"cacheWriteTokens": 6535
+		},
+		"outputTokens": 176,
+		"outputTokenDetails": {
+			"textTokens": null,
+			"reasoningTokens": null
+		},
+		"totalTokens": 6714,
+		"raw": {
+			"input_tokens": 3,
+			"cache_creation_input_tokens": 6535,
+			"cache_read_input_tokens": 0,
+			"cache_creation": {
+				"ephemeral_5m_input_tokens": 6535,
+				"ephemeral_1h_input_tokens": 0
+			},
+			"output_tokens": 176,
+			"service_tier": "standard",
+			"inference_geo": "not_available"
+		},
+		"reasoningTokens": null,
+		"cachedInputTokens": 0
+	},
+	"openai_finish": {
+		"type": "finish",
+		"finishReason": "stop",
+		"rawFinishReason": null,
+		"totalUsage": {
+			"inputTokens": 3824,
+			"inputTokenDetails": {
+				"noCacheTokens": 3824,
+				"cacheReadTokens": 0,
+				"cacheWriteTokens": null
+			},
+			"outputTokens": 14,
+			"outputTokenDetails": {
+				"textTokens": 14,
+				"reasoningTokens": 0
+			},
+			"totalTokens": 3838,
+			"reasoningTokens": 0,
+			"cachedInputTokens": 0
+		}
+	},
+	"openai_stream_usage": {
+		"inputTokens": 3824,
+		"inputTokenDetails": {
+			"noCacheTokens": 3824,
+			"cacheReadTokens": 0,
+			"cacheWriteTokens": null
+		},
+		"outputTokens": 14,
+		"outputTokenDetails": {
+			"textTokens": 14,
+			"reasoningTokens": 0
+		},
+		"totalTokens": 3838,
+		"raw": {
+			"input_tokens": 3824,
+			"input_tokens_details": {
+				"cached_tokens": 0
+			},
+			"output_tokens": 14,
+			"output_tokens_details": {
+				"reasoning_tokens": 0
+			}
+		},
+		"reasoningTokens": 0,
+		"cachedInputTokens": 0
+	},
+	"vercel_finish": {
+		"type": "finish",
+		"finishReason": "tool-calls",
+		"rawFinishReason": "tool_calls",
+		"totalUsage": {
+			"inputTokens": 6781,
+			"inputTokenDetails": {
+				"noCacheTokens": 114,
+				"cacheReadTokens": 6667,
+				"cacheWriteTokens": null
+			},
+			"outputTokens": 70,
+			"outputTokenDetails": {
+				"textTokens": 70,
+				"reasoningTokens": 0
+			},
+			"totalTokens": 6851,
+			"reasoningTokens": 0,
+			"cachedInputTokens": 6667
+		}
+	},
+	"vercel_stream_usage": {
+		"inputTokens": 4550,
+		"inputTokenDetails": {
+			"noCacheTokens": 4550,
+			"cacheReadTokens": 0,
+			"cacheWriteTokens": null
+		},
+		"outputTokens": 10,
+		"outputTokenDetails": {
+			"textTokens": 10,
+			"reasoningTokens": 0
+		},
+		"totalTokens": 4560,
+		"raw": {
+			"prompt_tokens": 4550,
+			"completion_tokens": 10,
+			"total_tokens": 4560,
+			"prompt_tokens_details": {
+				"cached_tokens": 0
+			},
+			"completion_tokens_details": {
+				"reasoning_tokens": 0
+			},
+			"cost": 0.000641,
+			"is_byok": false,
+			"cost_details": {
+				"upstream_inference_cost": null,
+				"upstream_inference_prompt_cost": 0,
+				"upstream_inference_completions_cost": 0
+			},
+			"cache_creation_input_tokens": 0,
+			"market_cost": 0.000641
+		},
+		"reasoningTokens": 0,
+		"cachedInputTokens": 0
+	},
+	"openrouter_multi_turn_finish": {
+		"type": "finish",
+		"finishReason": "tool-calls",
+		"rawFinishReason": "tool_calls",
+		"totalUsage": {
+			"inputTokens": 6781,
+			"inputTokenDetails": {
+				"noCacheTokens": 114,
+				"cacheReadTokens": 6667,
+				"cacheWriteTokens": null
+			},
+			"outputTokens": 70,
+			"outputTokenDetails": {
+				"textTokens": 70,
+				"reasoningTokens": 0
+			},
+			"totalTokens": 6851,
+			"reasoningTokens": 0,
+			"cachedInputTokens": 6667
+		}
+	},
+	"openrouter_multi_turn_stream_usage": {
+		"inputTokens": 6781,
+		"inputTokenDetails": {
+			"noCacheTokens": 114,
+			"cacheReadTokens": 6667,
+			"cacheWriteTokens": null
+		},
+		"outputTokens": 70,
+		"outputTokenDetails": {
+			"textTokens": 70,
+			"reasoningTokens": 0
+		},
+		"totalTokens": 6851,
+		"raw": {
+			"prompt_tokens": 6781,
+			"completion_tokens": 70,
+			"total_tokens": 6851,
+			"prompt_tokens_details": {
+				"cached_tokens": 6667
+			},
+			"completion_tokens_details": {
+				"reasoning_tokens": 0
+			},
+			"cost": 0.0001738425,
+			"is_byok": true,
+			"cost_details": {
+				"upstream_inference_cost": 0.00347685,
+				"upstream_inference_prompt_cost": 0.00242685,
+				"upstream_inference_completions_cost": 0.00105
+			}
+		},
+		"reasoningTokens": 0,
+		"cachedInputTokens": 6667
+	}
+}
diff --git a/sdk/packages/llms/package.json b/sdk/packages/llms/package.json
new file mode 100644
index 0000000..79cc9e1
--- /dev/null
+++ b/sdk/packages/llms/package.json
@@ -0,0 +1,73 @@
+{
+	"name": "@cline/llms",
+	"version": "0.0.59",
+	"description": "Config-driven SDK for selecting, extending, and instantiating LLM providers and models",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline",
+		"directory": "sdk/packages/llms"
+	},
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"engines": {
+		"node": ">=22"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"browser": "./dist/index.browser.js",
+			"react-server": "./dist/index.browser.js",
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./browser": {
+			"import": "./dist/index.browser.js",
+			"types": "./dist/index.browser.d.ts"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "bun run bun.mts && bun tsc -p tsconfig.build.json",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit",
+		"test": "vitest run",
+		"test:live": "vitest run src/tests/provider-live*.test.ts",
+		"test:vcr": "vitest run src/tests/provider-vcr.test.ts",
+		"test:watch": "vitest",
+		"generate:models": "bun run scripts/generate-models.ts"
+	},
+	"peerDependenciesMeta": {
+		"@aws-sdk/client-bedrock-runtime": {
+			"optional": true
+		}
+	},
+	"dependencies": {
+		"@ai-sdk/amazon-bedrock": "^4.0.89",
+		"@ai-sdk/anthropic": "^3.0.68",
+		"@ai-sdk/google": "^3.0.60",
+		"@ai-sdk/google-vertex": "^4.0.100",
+		"@ai-sdk/mistral": "^3.0.28",
+		"@ai-sdk/openai": "^3.0.52",
+		"@ai-sdk/openai-compatible": "^2.0.38",
+		"@ai-sdk/provider": "^3.0.8",
+		"@aws-sdk/credential-providers": "^3.922.0",
+		"@cline/shared": "workspace:*",
+		"@jerome-benoit/sap-ai-provider": "4.6.9",
+		"@langfuse/otel": "^4.0.0",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/sdk-trace-node": "^2.6.1",
+		"@streamparser/json": "^0.0.21",
+		"ai": "^6.0.144",
+		"ai-sdk-provider-claude-code": "^3.4.3",
+		"ai-sdk-provider-codex-cli": "^1.1.0",
+		"ai-sdk-provider-opencode-sdk": "^3.0.1",
+		"dify-ai-provider": "^1.1.0",
+		"nanoid": "^5.1.7",
+		"zod": "^4.3.6"
+	},
+	"peerDependencies": {
+		"@aws-sdk/client-bedrock-runtime": "^3.0.0"
+	}
+}
diff --git a/sdk/packages/llms/scripts/fix-esm-imports.ts b/sdk/packages/llms/scripts/fix-esm-imports.ts
new file mode 100644
index 0000000..a9d410d
--- /dev/null
+++ b/sdk/packages/llms/scripts/fix-esm-imports.ts
@@ -0,0 +1,109 @@
+#!/usr/bin/env bun
+
+import {
+	existsSync,
+	readdirSync,
+	readFileSync,
+	statSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const EXTENSION_RE = /\.(?:[cm]?js|json|node)$/;
+
+function walkFiles(dir: string): string[] {
+	const entries = readdirSync(dir);
+	const files: string[] = [];
+
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const stats = statSync(fullPath);
+		if (stats.isDirectory()) {
+			files.push(...walkFiles(fullPath));
+			continue;
+		}
+		if (stats.isFile() && fullPath.endsWith(".js")) {
+			files.push(fullPath);
+		}
+	}
+
+	return files;
+}
+
+function resolveSpecifier(filePath: string, specifier: string): string {
+	if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+		return specifier;
+	}
+
+	if (EXTENSION_RE.test(specifier)) {
+		return specifier;
+	}
+
+	const baseDir = dirname(filePath);
+	const target = resolve(baseDir, specifier);
+	const asFile = `${target}.js`;
+	const asIndex = join(target, "index.js");
+
+	if (existsSync(asFile)) {
+		return `${specifier}.js`;
+	}
+	if (existsSync(asIndex)) {
+		return `${specifier}/index.js`;
+	}
+
+	return specifier;
+}
+
+function rewriteImports(filePath: string): boolean {
+	const content = readFileSync(filePath, "utf8");
+	let changed = false;
+
+	const replaceStatic = (
+		_: string,
+		prefix: string,
+		specifier: string,
+		suffix: string,
+	) => {
+		const resolved = resolveSpecifier(filePath, specifier);
+		if (resolved !== specifier) {
+			changed = true;
+		}
+		return `${prefix}${resolved}${suffix}`;
+	};
+
+	const staticPat = /(from\s+["'])(\.[^"']*)(["'])/g;
+	const dynamicPat = /(import\(\s*["'])(\.[^"']*)(["']\s*\))/g;
+
+	const rewritten = content
+		.replace(staticPat, replaceStatic)
+		.replace(dynamicPat, replaceStatic);
+
+	if (changed) {
+		writeFileSync(filePath, rewritten, "utf8");
+	}
+
+	return changed;
+}
+
+function main() {
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = dirname(__filename);
+	const distDir = resolve(__dirname, "../dist");
+
+	if (!existsSync(distDir)) {
+		console.log("No dist directory found; skipping ESM import fix.");
+		return;
+	}
+
+	let fixedCount = 0;
+	for (const filePath of walkFiles(distDir)) {
+		if (rewriteImports(filePath)) {
+			fixedCount++;
+		}
+	}
+
+	console.log(`Fixed ESM import specifiers in ${fixedCount} file(s).`);
+}
+
+main();
diff --git a/sdk/packages/llms/scripts/generate-models.ts b/sdk/packages/llms/scripts/generate-models.ts
new file mode 100644
index 0000000..438cca7
--- /dev/null
+++ b/sdk/packages/llms/scripts/generate-models.ts
@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ModelInfo } from "@cline/shared";
+import {
+	fetchClineRecommendedModelsPayload,
+	normalizeClineRecommendedProviderModels,
+} from "../src/catalog/catalog-cline-recommended";
+import { loadModelsDevProviderModels } from "./models/generate-models-dev";
+
+const OUTPUT_FILE = "src/catalog/catalog.generated.ts";
+
+function sortObjectByKey<T>(
+	input: Record<string, T>,
+	order: "asc" | "desc" = "asc",
+): Record<string, T> {
+	return Object.fromEntries(
+		Object.entries(input).sort(([a], [b]) =>
+			order === "asc" ? a.localeCompare(b) : b.localeCompare(a),
+		),
+	);
+}
+
+function normalizeValue(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(normalizeValue);
+	}
+	if (value && typeof value === "object") {
+		const objectValue = value as Record<string, unknown>;
+		return Object.fromEntries(
+			Object.entries(objectValue)
+				.sort(([a], [b]) => a.localeCompare(b))
+				.map(([key, nestedValue]) => [key, normalizeValue(nestedValue)]),
+		);
+	}
+	return value;
+}
+
+async function generate(): Promise<void> {
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = dirname(__filename);
+	const root = join(__dirname, "..");
+	const outputPath = join(root, OUTPUT_FILE);
+
+	const providerModels: Record<string, Record<string, ModelInfo>> = {};
+	let loadError: Error | undefined;
+
+	const [modelsDevResult, clineRecommendedPayloadResult] = await Promise.all([
+		loadModelsDevProviderModels().catch((error) => {
+			loadError =
+				error instanceof Error ? error : new Error(String(error ?? "unknown"));
+			return {};
+		}),
+		fetchClineRecommendedModelsPayload(fetch).catch((error) => {
+			loadError =
+				error instanceof Error ? error : new Error(String(error ?? "unknown"));
+			return undefined;
+		}),
+	]);
+
+	Object.assign(providerModels, modelsDevResult);
+
+	if (clineRecommendedPayloadResult) {
+		Object.assign(
+			providerModels,
+			normalizeClineRecommendedProviderModels(
+				clineRecommendedPayloadResult,
+				providerModels.openrouter || {},
+			),
+		);
+	}
+
+	if (Object.keys(providerModels).length === 0) {
+		const details = loadError?.message ?? "unknown error";
+		if (existsSync(outputPath)) {
+			console.warn(
+				`Skipping model generation: no provider models were loaded (${details}). Existing generated catalog was left unchanged.`,
+			);
+			return;
+		}
+		throw new Error(
+			`Aborting model generation: no provider models were loaded (${details}). No existing generated catalog was found.`,
+		);
+	}
+
+	const sortedProviders = sortObjectByKey(providerModels);
+	const generatedModelsVersion = Date.now();
+	const output = `/**
+ * Auto-generated model catalog.
+ *
+ * Generated by: @cline/llms/scripts/generate-models.ts
+ *
+ * WARNING: DO NOT EDIT THIS FILE MANUALLY.
+ */
+import type { ModelInfo } from "@cline/shared";
+/**
+ * Model list auto-generated for built-in providers
+ * listed in @cline/llms/src/providers/provider-keys.ts
+*/
+export const GENERATED_PROVIDER_MODELS: {
+  version: number
+  providers: Record<string, Record<string, ModelInfo>>
+} = {
+  version: ${JSON.stringify(generatedModelsVersion)},
+  providers: ${JSON.stringify(sortedProviders, null, 2)}
+}
+`;
+	mkdirSync(dirname(outputPath), { recursive: true });
+
+	if (existsSync(outputPath)) {
+		const nextProviders = normalizeValue(sortedProviders);
+		let existingProviders: unknown | undefined;
+		try {
+			const existingModule = (await import(
+				"../src/catalog/catalog.generated.js"
+			)) as {
+				GENERATED_PROVIDER_MODELS?: {
+					providers?: Record<string, Record<string, ModelInfo>>;
+				};
+			};
+			existingProviders = existingModule.GENERATED_PROVIDER_MODELS?.providers;
+		} catch {
+			existingProviders = undefined;
+		}
+		if (
+			existingProviders &&
+			JSON.stringify(normalizeValue(existingProviders)) ===
+				JSON.stringify(nextProviders)
+		) {
+			const totalModels = Object.values(sortedProviders).reduce(
+				(count, models) => count + Object.keys(models).length,
+				0,
+			);
+			console.log(`No changes detected for ${OUTPUT_FILE}`);
+			console.log(`Providers: ${Object.keys(sortedProviders).length}`);
+			console.log(`Models: ${totalModels}`);
+			return;
+		}
+	}
+
+	writeFileSync(outputPath, output, "utf8");
+
+	const totalModels = Object.values(sortedProviders).reduce(
+		(count, models) => count + Object.keys(models).length,
+		0,
+	);
+	console.log(`Generated ${OUTPUT_FILE}`);
+	console.log(`Providers: ${Object.keys(sortedProviders).length}`);
+	console.log(`Models: ${totalModels}`);
+}
+
+generate().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
diff --git a/sdk/packages/llms/scripts/models/generate-models-dev.ts b/sdk/packages/llms/scripts/models/generate-models-dev.ts
new file mode 100644
index 0000000..3f50001
--- /dev/null
+++ b/sdk/packages/llms/scripts/models/generate-models-dev.ts
@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import type { ModelInfo } from "@cline/shared";
+import { fetchModelsDevProviderModels } from "../../src/catalog/catalog-live";
+
+function sortObjectByKey<T>(
+	input: Record<string, T>,
+	order: "asc" | "desc" = "asc",
+): Record<string, T> {
+	return Object.fromEntries(
+		Object.entries(input).sort(([a], [b]) =>
+			order === "asc" ? a.localeCompare(b) : b.localeCompare(a),
+		),
+	);
+}
+
+export async function loadModelsDevProviderModels(): Promise<
+	Record<string, Record<string, ModelInfo>>
+> {
+	const providerModels = await fetchModelsDevProviderModels(
+		"https://models.dev/api.json",
+	);
+	return sortObjectByKey(providerModels);
+}
diff --git a/sdk/packages/llms/scripts/tsconfig.json b/sdk/packages/llms/scripts/tsconfig.json
new file mode 100644
index 0000000..7b5415e
--- /dev/null
+++ b/sdk/packages/llms/scripts/tsconfig.json
@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"types": ["node"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"noEmit": true
+	},
+	"include": ["./**/*.ts"]
+}
diff --git a/sdk/packages/llms/src/catalog/README.md b/sdk/packages/llms/src/catalog/README.md
new file mode 100644
index 0000000..1388f8a
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/README.md
@@ -0,0 +1,165 @@
+# Model Catalog Semantics
+
+The generated catalog is the SDK's normalized copy of provider and model
+metadata. Most built-in catalog data comes from [models.dev](https://models.dev)
+through `catalog-live.ts` and is written to `catalog.generated.ts` by the model
+generation scripts.
+
+This file documents the intended meaning of the token-limit fields and the
+boundary between catalog metadata and runtime request policy.
+
+## Source Fields
+
+`models.dev` exposes model limits under `limit`:
+
+```text
+limit.context  maximum context budget reported for the model
+limit.input    optional stricter prompt/input-token budget
+limit.output   maximum output tokens reported for generation
+```
+
+`limit.input` is not present for every model. When it is present, it should be
+treated as the best available prompt/input ceiling. When it is absent, the
+catalog falls back to `limit.context` for the prompt/input ceiling.
+
+## Cline Fields
+
+The catalog maps those source fields into `ModelInfo`:
+
+```text
+contextWindow   provider-reported context budget
+maxInputTokens  prompt/input-token budget used by compaction and diagnostics
+maxTokens       provider-reported output-token budget
+```
+
+These fields are not additive guarantees. In particular, this is valid catalog
+metadata:
+
+```text
+contextWindow:  200000
+maxInputTokens: 200000
+maxTokens:      128000
+```
+
+That means:
+
+```text
+the prompt may be allowed to approach 200000 tokens
+the model may be capable of generating up to 128000 tokens
+an individual request still needs prompt + output to fit the provider's rules
+```
+
+Do not infer that `maxInputTokens + maxTokens` must be less than or equal to
+`contextWindow`. Many provider catalogs expose separate maxima that share an
+underlying context budget.
+
+## Catalog Data vs Request Limits
+
+The catalog should describe reported model capabilities. It should avoid baking
+in Cline request defaults, product-level safety limits, or provider-specific
+workarounds unless there is no better place to represent a stable fact.
+
+The code that sends a model request is responsible for deciding how many output
+tokens to ask for on that specific turn. That decision can depend on:
+
+- actual prompt size for the current request
+- provider context-window behavior
+- product-level default output caps
+- user overrides such as `request.options.maxTokens`
+- tokenizer drift and hidden provider overhead
+- reasoning, tool, image, and formatting tokens
+
+For models where prompt and output tokens both have to fit into the same context
+window, the request limit should be based on the current prompt, not invented
+while generating the catalog. Conceptually:
+
+```text
+safeOutputTokens = min(
+	modelReportedMaxOutput,
+	contextWindow - estimatedPromptTokens - reserveTokens,
+	userConfiguredOutputCap,
+)
+```
+
+The SDK gateway only sends an output token limit when the caller provides
+`request.options.maxTokens` or an equivalent host configuration. Catalog
+metadata does not become a request parameter by itself.
+
+The exact request-limit policy belongs in the provider/gateway/core request
+path, not in generated catalog data.
+
+## Do Not Invent Output Limits
+
+The catalog generator should not turn ambiguous provider metadata into a new
+Cline output limit.
+
+For example, if a provider reports:
+
+```text
+limit.context = 202800
+limit.output  = 202800
+```
+
+the generated catalog should preserve that reported output limit:
+
+```text
+contextWindow:  202800
+maxInputTokens: 202800
+maxTokens:      202800
+```
+
+Cline may still ask for fewer output tokens on a given request. That belongs in
+the request path because only the request path knows the current prompt size and
+the user's configured output cap.
+
+## Generation Flow
+
+The generated catalog is produced from the live normalizer:
+
+```text
+models.dev/api.json
+	|
+	v
+src/catalog/catalog-live.ts
+	|
+	v
+scripts/generate-models.ts
+	|
+	v
+src/catalog/catalog.generated.ts
+```
+
+Use the package script when regenerating:
+
+```bash
+bun -F @cline/llms generate:models
+```
+
+Catalog changes should usually include tests in `catalog-live.test.ts` that
+document how source `limit` fields map to `ModelInfo`.
+
+## Provider Differences
+
+Provider token semantics are not uniform:
+
+- Some providers publish independent input and output caps.
+- Some providers publish only a context budget and a max generation parameter.
+- Some routed providers report limits that differ from the upstream model docs.
+- Some providers reject `prompt + requestedOutput > contextWindow`.
+- Some providers truncate, compress, or stop generation instead.
+- Reasoning tokens may count against output budgets.
+- Tool schemas, tool calls, images, and provider formatting can consume hidden
+  input or output budget.
+
+Because of those differences, catalog generation should preserve source
+metadata as much as possible, while runtime request policy should be conservative
+and observable.
+
+## Related Files
+
+- `catalog-live.ts`: normalizes live `models.dev` data.
+- `catalog-live.test.ts`: tests catalog normalization behavior.
+- `catalog.generated.ts`: checked-in generated provider/model catalog.
+- `../../scripts/generate-models.ts`: writes generated catalog output.
+- `../providers/ai-sdk.ts`: passes `maxOutputTokens` into AI SDK.
+- `../providers/gateway.ts`: resolves per-request/default `maxTokens`.
diff --git a/sdk/packages/llms/src/catalog/catalog-cline-recommended.ts b/sdk/packages/llms/src/catalog/catalog-cline-recommended.ts
new file mode 100644
index 0000000..78fb7f3
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/catalog-cline-recommended.ts
@@ -0,0 +1,137 @@
+import { getClineEnvironmentConfig } from "@cline/shared";
+import type { ModelInfo } from "./types";
+
+export interface ClineRecommendedModelEntry {
+	id: string;
+	name?: string;
+	description?: string;
+}
+
+export interface ClineRecommendedModelsPayload {
+	clinePass?: ClineRecommendedModelEntry[];
+	free?: ClineRecommendedModelEntry[];
+}
+
+type ModelCapabilities = Pick<
+	ModelInfo,
+	"contextWindow" | "maxInputTokens" | "maxTokens" | "capabilities" | "pricing"
+>;
+
+const CLINE_PASS_PROVIDER_ID = "cline-pass";
+
+const CLINE_PASS_MODEL_DEFAULTS = {
+	contextWindow: 128_000,
+	maxInputTokens: 128_000,
+	maxTokens: 8_192,
+	capabilities: ["tools", "reasoning", "temperature"],
+	pricing: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+	},
+} as const satisfies ModelCapabilities;
+
+function findORModelCapabilities(
+	entry: ClineRecommendedModelEntry,
+	openRouterModels: Record<string, ModelInfo>,
+): ModelCapabilities {
+	if (!openRouterModels) {
+		return CLINE_PASS_MODEL_DEFAULTS;
+	}
+
+	const modelSlug = entry.id.split("/").at(-1) ?? entry.id;
+
+	return openRouterModels[modelSlug] || CLINE_PASS_MODEL_DEFAULTS;
+}
+
+// Cline-Pass models have only the model name (and not the lab),
+// so we need to look-up using glm-5.2 instead of cline-pass/glm-5.2
+function buildModelsNameMap(
+	openrouterModels: Record<string, ModelInfo>,
+): Record<string, ModelInfo> {
+	const nameMap: Record<string, ModelInfo> = {};
+
+	for (const model of Object.values(openrouterModels)) {
+		const modelSlugWithoutProvider = model.id.split("/").at(-1) ?? model.id;
+
+		nameMap[modelSlugWithoutProvider] = model;
+	}
+
+	return nameMap;
+}
+
+export function normalizeClineRecommendedProviderModels(
+	payload: ClineRecommendedModelsPayload,
+	openRouterModels: Record<string, ModelInfo>,
+): Record<string, Record<string, ModelInfo>> {
+	const clinePass = payload.clinePass ?? [];
+	if (clinePass.length === 0) {
+		return {};
+	}
+
+	const models: Record<string, ModelInfo> = {};
+	const openRouterModelsByName = buildModelsNameMap(openRouterModels);
+
+	clinePass.forEach((entry) => {
+		const capabilities = findORModelCapabilities(entry, openRouterModelsByName);
+
+		models[entry.id] = {
+			// We should use the OR name, unless there is not one (like when using defaults)
+			name: entry.name,
+			...capabilities,
+			id: entry.id,
+			description: entry.description,
+		};
+	});
+
+	// Cline free models are selectable on the ClinePass provider too (same API
+	// underneath; they ride usage billing at $0 instead of the subscription quota).
+	// Unlike pass models their ids are full OpenRouter-style ids, so look up
+	// capabilities by full id before falling back to the slug map.
+	(payload.free ?? []).forEach((entry) => {
+		if (models[entry.id]) {
+			return;
+		}
+
+		const capabilities =
+			openRouterModels?.[entry.id] ??
+			findORModelCapabilities(entry, openRouterModelsByName);
+
+		models[entry.id] = {
+			name: entry.name,
+			...capabilities,
+			id: entry.id,
+			description: entry.description,
+			pricing: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		};
+	});
+
+	if (Object.keys(models).length === 0) {
+		return {};
+	}
+
+	return { [CLINE_PASS_PROVIDER_ID]: models };
+}
+
+export async function fetchClineRecommendedModelsPayload(
+	fetcher: typeof fetch = fetch,
+): Promise<ClineRecommendedModelsPayload> {
+	const url = `${getClineEnvironmentConfig().apiBaseUrl}/api/v1/ai/cline/recommended-models`;
+	const response = await fetcher(url);
+	if (!response.ok) {
+		throw new Error(
+			`Failed to load Cline recommended models from ${url}: HTTP ${response.status}`,
+		);
+	}
+
+	return (await response.json()) as ClineRecommendedModelsPayload;
+}
+
+export async function fetchClineRecommendedProviderModels(
+	fetcher: typeof fetch = fetch,
+	openRouterModels: Record<string, ModelInfo>,
+): Promise<Record<string, Record<string, ModelInfo>>> {
+	const payload = await fetchClineRecommendedModelsPayload(fetcher);
+	return normalizeClineRecommendedProviderModels(payload, openRouterModels);
+}
diff --git a/sdk/packages/llms/src/catalog/catalog-live.test.ts b/sdk/packages/llms/src/catalog/catalog-live.test.ts
new file mode 100644
index 0000000..656d408
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/catalog-live.test.ts
@@ -0,0 +1,566 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	getGeneratedModelsForProvider,
+	getGeneratedProviderModels,
+} from "./catalog.generated-access";
+import { normalizeClineRecommendedProviderModels } from "./catalog-cline-recommended";
+import {
+	fetchLiveProviderModels,
+	fetchModelsDevProviderModels,
+	type ModelsDevPayload,
+	normalizeModelsDevProviderModels,
+	resolveMaxInputTokens,
+} from "./catalog-live";
+
+describe("models-dev-catalog", () => {
+	it("normalizes Cline recommended clinePass models as a generated provider source", () => {
+		const result = normalizeClineRecommendedProviderModels(
+			{
+				clinePass: [
+					{
+						id: "base-model",
+						name: "ClinePass Base Model",
+						description: "Included in ClinePass",
+					},
+					{
+						id: "custom-model",
+						name: "Custom Model",
+					},
+				],
+			},
+			{
+				"base-model": {
+					id: "base-model",
+					name: "OpenRouter Base Model",
+					description: "OpenRouter description",
+					contextWindow: 200_000,
+					maxInputTokens: 180_000,
+					maxTokens: 16_384,
+					capabilities: ["tools", "reasoning", "images"],
+					pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+					releaseDate: "2026-01-01",
+					family: "base-family",
+				},
+			},
+		);
+
+		expect(result["cline-pass"]).toEqual({
+			"base-model": {
+				id: "base-model",
+				name: "OpenRouter Base Model",
+				description: "Included in ClinePass",
+				contextWindow: 200_000,
+				maxInputTokens: 180_000,
+				maxTokens: 16_384,
+				capabilities: ["tools", "reasoning", "images"],
+				pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+				releaseDate: "2026-01-01",
+				family: "base-family",
+			},
+			"custom-model": {
+				id: "custom-model",
+				name: "Custom Model",
+				description: undefined,
+				contextWindow: 128_000,
+				maxInputTokens: 128_000,
+				maxTokens: 8_192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			},
+		});
+	});
+
+	it("matches Cline recommended clinePass models against OpenRouter model names", () => {
+		const result = normalizeClineRecommendedProviderModels(
+			{
+				clinePass: [
+					{
+						id: "cline-pass/cline-pass/glm-5.2",
+						name: "zai/glm-5.2",
+					},
+				],
+			},
+			{
+				"z-ai/glm-5.2": {
+					id: "z-ai/glm-5.2",
+					name: "GLM 5.2",
+					contextWindow: 256_000,
+					maxInputTokens: 200_000,
+					maxTokens: 32_000,
+					capabilities: ["tools", "reasoning", "temperature"],
+					pricing: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
+				},
+			},
+		);
+
+		expect(
+			result["cline-pass"]?.["cline-pass/cline-pass/glm-5.2"],
+		).toMatchObject({
+			id: "cline-pass/cline-pass/glm-5.2",
+			name: "GLM 5.2",
+			contextWindow: 256_000,
+			maxInputTokens: 200_000,
+			maxTokens: 32_000,
+			pricing: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
+		});
+	});
+
+	it("returns no ClinePass models when clinePass is empty or missing", () => {
+		expect(normalizeClineRecommendedProviderModels({}, {})).toEqual({});
+		expect(
+			normalizeClineRecommendedProviderModels({ clinePass: [] }, {}),
+		).toEqual({});
+	});
+
+	it("includes zero-priced Cline free models alongside ClinePass models", () => {
+		const result = normalizeClineRecommendedProviderModels(
+			{
+				clinePass: [{ id: "cline-pass/glm-5.1", name: "glm-5.1" }],
+				free: [{ id: "kwaipilot/kat-coder-pro", name: "kat-coder-pro" }],
+			},
+			{
+				"kwaipilot/kat-coder-pro": {
+					id: "kwaipilot/kat-coder-pro",
+					name: "KAT Coder Pro",
+					contextWindow: 256_000,
+					maxInputTokens: 200_000,
+					maxTokens: 32_000,
+					capabilities: ["tools", "temperature"],
+					pricing: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 0 },
+				},
+			},
+		);
+
+		const models = result["cline-pass"] ?? {};
+		// ClinePass models stay first so the provider default remains a pass model
+		expect(Object.keys(models)).toEqual([
+			"cline-pass/glm-5.1",
+			"kwaipilot/kat-coder-pro",
+		]);
+		expect(models["kwaipilot/kat-coder-pro"]).toMatchObject({
+			id: "kwaipilot/kat-coder-pro",
+			name: "KAT Coder Pro",
+			contextWindow: 256_000,
+			maxInputTokens: 200_000,
+			// free models are billed at $0 regardless of catalog pricing
+			pricing: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		});
+	});
+
+	it("resolves free-model capabilities by slug and ignores free-only payloads", () => {
+		const suffixed = normalizeClineRecommendedProviderModels(
+			{
+				clinePass: [{ id: "cline-pass/glm-5.1" }],
+				free: [{ id: "arcee-ai/trinity-large-preview:free" }],
+			},
+			{
+				"arcee-ai/trinity-large-preview:free": {
+					id: "arcee-ai/trinity-large-preview:free",
+					name: "Trinity Large Preview",
+					contextWindow: 512_000,
+					maxInputTokens: 400_000,
+					maxTokens: 64_000,
+					capabilities: ["tools"],
+					pricing: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+				},
+			},
+		);
+		expect(
+			suffixed["cline-pass"]?.["arcee-ai/trinity-large-preview:free"],
+		).toMatchObject({
+			name: "Trinity Large Preview",
+			contextWindow: 512_000,
+		});
+
+		// free bucket alone does not create a cline-pass catalog
+		expect(
+			normalizeClineRecommendedProviderModels(
+				{ free: [{ id: "kwaipilot/kat-coder-pro" }] },
+				{},
+			),
+		).toEqual({});
+	});
+
+	it("uses input limits as the model request context window", () => {
+		expect(resolveMaxInputTokens(undefined)).toBe(128_000);
+		expect(
+			resolveMaxInputTokens({
+				context: 400_000,
+				input: 272_000,
+				output: 128_000,
+			}),
+		).toBe(272_000);
+		expect(
+			resolveMaxInputTokens({
+				context: 400_000,
+				output: 128_000,
+			}),
+		).toBe(400_000);
+		expect(
+			resolveMaxInputTokens({
+				context: 400_000,
+				input: 128_000,
+				output: 272_000,
+			}),
+		).toBe(128_000);
+	});
+
+	it("preserves reported output limits even when context matches output", () => {
+		const providerModels = normalizeModelsDevProviderModels({
+			openai: {
+				models: {
+					"input-output-equal": {
+						tool_call: true,
+						limit: {
+							context: 400_000,
+							input: 272_000,
+							output: 272_000,
+						},
+					},
+					"context-output-equal": {
+						tool_call: true,
+						limit: {
+							context: 4096,
+							output: 4096,
+						},
+					},
+				},
+			},
+		});
+
+		expect(
+			providerModels["openai-native"]?.["input-output-equal"]?.maxTokens,
+		).toBe(272_000);
+		expect(
+			providerModels["openai-native"]?.["context-output-equal"]?.maxTokens,
+		).toBe(4096);
+	});
+
+	it("normalizes payload with model filtering and defaults", () => {
+		const payload: ModelsDevPayload = {
+			openai: {
+				models: {
+					"gpt-live": {
+						name: "GPT Live",
+						tool_call: true,
+						reasoning: true,
+						structured_output: true,
+						temperature: true,
+						release_date: "2026-01-01",
+						modalities: { input: ["text", "image"] },
+						limit: { context: 1_000_000 },
+						cost: { input: 1, output: 2, cache_write: 0.8 },
+						status: "preview",
+						family: "gpt",
+					},
+					"gpt-no-tools": {
+						name: "GPT No Tools",
+						tool_call: false,
+						family: "gpt",
+					},
+					"gpt-split-limit": {
+						name: "GPT Split Limit",
+						tool_call: true,
+						limit: {
+							context: 400_000,
+							input: 272_000,
+							output: 128_000,
+						},
+						family: "gpt",
+					},
+					"gpt-deprecated": {
+						name: "GPT Deprecated",
+						tool_call: true,
+						status: "deprecated",
+						family: "gpt",
+					},
+				},
+			},
+			anthropic: {
+				models: {
+					"claude-defaults": {
+						tool_call: true,
+						status: "experimental",
+						release_date: "2025-02-01",
+						family: "claude",
+					},
+					"claude-older": {
+						tool_call: true,
+						release_date: "2024-02-01",
+						family: "claude",
+					},
+				},
+			},
+		};
+
+		const providerModels = normalizeModelsDevProviderModels(payload);
+
+		expect(providerModels).toEqual({
+			"openai-native": {
+				"gpt-live": {
+					id: "gpt-live",
+					name: "GPT Live",
+					contextWindow: 1_000_000,
+					maxInputTokens: 1_000_000,
+					maxTokens: 4096,
+					capabilities: [
+						"images",
+						"tools",
+						"reasoning",
+						"structured_output",
+						"temperature",
+						"prompt-cache",
+					],
+					pricing: {
+						input: 1,
+						output: 2,
+						cacheRead: 0,
+						cacheWrite: 0.8,
+					},
+					status: "preview",
+					releaseDate: "2026-01-01",
+					family: "gpt",
+				},
+				"gpt-split-limit": {
+					id: "gpt-split-limit",
+					name: "GPT Split Limit",
+					contextWindow: 400_000,
+					maxInputTokens: 272_000,
+					maxTokens: 128_000,
+					capabilities: ["tools"],
+					pricing: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					status: undefined,
+					releaseDate: undefined,
+					family: "gpt",
+				},
+			},
+			anthropic: {
+				"claude-defaults": {
+					id: "claude-defaults",
+					name: "claude-defaults",
+					contextWindow: undefined,
+					maxInputTokens: 128_000,
+					maxTokens: 4096,
+					capabilities: ["tools"],
+					pricing: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					status: undefined,
+					releaseDate: "2025-02-01",
+					family: "claude",
+				},
+				"claude-older": {
+					id: "claude-older",
+					name: "claude-older",
+					contextWindow: undefined,
+					maxInputTokens: 128_000,
+					maxTokens: 4096,
+					capabilities: ["tools"],
+					pricing: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					status: undefined,
+					releaseDate: "2024-02-01",
+					family: "claude",
+				},
+			},
+		});
+		expect(Object.keys(providerModels.anthropic ?? {})).toEqual([
+			"claude-defaults",
+			"claude-older",
+		]);
+		expect(providerModels["openai-native"]).not.toHaveProperty(
+			"gpt-deprecated",
+		);
+	});
+
+	it("regenerates Codex catalog entries with input request limits", () => {
+		expect(
+			getGeneratedModelsForProvider("openai-native")["gpt-5.3-codex"]
+				?.maxInputTokens,
+		).toBe(272_000);
+		expect(
+			getGeneratedModelsForProvider("openai-native")["gpt-5.3-codex"]
+				?.contextWindow,
+		).toBe(400_000);
+		expect(
+			getGeneratedProviderModels()["vercel-ai-gateway"]?.[
+				"openai/gpt-5.3-codex"
+			]?.maxInputTokens,
+		).toBe(272_000);
+		expect(
+			getGeneratedProviderModels()["vercel-ai-gateway"]?.[
+				"openai/gpt-5.3-codex"
+			]?.contextWindow,
+		).toBe(400_000);
+	});
+
+	it("fetches and normalizes models.dev payload", async () => {
+		const fetcher = vi.fn(async () => ({
+			ok: true,
+			json: async () =>
+				({
+					openai: {
+						models: {
+							"gpt-live": { tool_call: true },
+						},
+					},
+				}) satisfies ModelsDevPayload,
+		}));
+
+		const result = await fetchModelsDevProviderModels(
+			"https://models.dev/api.json",
+			fetcher as unknown as typeof fetch,
+		);
+
+		expect(fetcher).toHaveBeenCalledWith("https://models.dev/api.json");
+		expect(result["openai-native"]).toHaveProperty("gpt-live");
+	});
+
+	it("fetches live models from models.dev and Cline recommended clinePass models", async () => {
+		const fetcher = vi.fn(async (url: string) => {
+			if (url === "https://models.dev/api.json") {
+				return {
+					ok: true,
+					json: async () =>
+						({
+							openrouter: {
+								models: {
+									"vendor/live-base-model": {
+										name: "Live Base Model",
+										tool_call: true,
+										reasoning: true,
+										limit: { context: 256_000, input: 200_000, output: 32_000 },
+										cost: { input: 1, output: 2 },
+									},
+								},
+							},
+						}) satisfies ModelsDevPayload,
+				};
+			}
+
+			return {
+				ok: true,
+				json: async () => ({
+					clinePass: [
+						{
+							id: "cline-pass/live-base-model",
+							name: "vendor/live-base-model",
+						},
+					],
+				}),
+			};
+		});
+
+		const result = await fetchLiveProviderModels(
+			"https://models.dev/api.json",
+			fetcher as unknown as typeof fetch,
+		);
+
+		expect(fetcher).toHaveBeenCalledWith("https://models.dev/api.json");
+		expect(fetcher).toHaveBeenCalledWith(
+			"https://api.cline.bot/api/v1/ai/cline/recommended-models",
+		);
+		expect(result.openrouter).toHaveProperty("vendor/live-base-model");
+		expect(result["cline-pass"]?.["cline-pass/live-base-model"]).toMatchObject({
+			id: "cline-pass/live-base-model",
+			name: "Live Base Model",
+			contextWindow: 256_000,
+			maxInputTokens: 200_000,
+			maxTokens: 32_000,
+			pricing: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
+		});
+	});
+
+	it("keeps models.dev live models when Cline recommended models fail", async () => {
+		const fetcher = vi.fn(async (url: string) => {
+			if (url === "https://models.dev/api.json") {
+				return {
+					ok: true,
+					json: async () =>
+						({
+							openai: {
+								models: {
+									"gpt-live": { name: "GPT Live", tool_call: true },
+								},
+							},
+						}) satisfies ModelsDevPayload,
+				};
+			}
+
+			return { ok: false, status: 503 };
+		});
+
+		const result = await fetchLiveProviderModels(
+			"https://models.dev/api.json",
+			fetcher as unknown as typeof fetch,
+		);
+
+		expect(result["openai-native"]?.["gpt-live"]?.name).toBe("GPT Live");
+		expect(result["cline-pass"]).toBeUndefined();
+	});
+
+	it("keeps Cline recommended clinePass models when models.dev fails", async () => {
+		const fetcher = vi.fn(async (url: string) => {
+			if (url === "https://models.dev/api.json") {
+				return { ok: false, status: 503 };
+			}
+
+			return {
+				ok: true,
+				json: async () => ({
+					clinePass: [
+						{
+							id: "cline-pass/live-default-model",
+							name: "Live Default Model",
+						},
+					],
+				}),
+			};
+		});
+
+		const result = await fetchLiveProviderModels(
+			"https://models.dev/api.json",
+			fetcher as unknown as typeof fetch,
+		);
+
+		expect(result["openai-native"]).toBeUndefined();
+		expect(
+			result["cline-pass"]?.["cline-pass/live-default-model"],
+		).toMatchObject({
+			id: "cline-pass/live-default-model",
+			name: "Live Default Model",
+			contextWindow: 128_000,
+			maxInputTokens: 128_000,
+			maxTokens: 8_192,
+			pricing: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		});
+	});
+
+	it("throws when models.dev request fails", async () => {
+		const fetcher = vi.fn(async () => ({
+			ok: false,
+			status: 503,
+		}));
+
+		await expect(
+			fetchModelsDevProviderModels(
+				"https://models.dev/api.json",
+				fetcher as unknown as typeof fetch,
+			),
+		).rejects.toThrow(
+			"Failed to load model catalog from https://models.dev/api.json: HTTP 503",
+		);
+	});
+});
diff --git a/sdk/packages/llms/src/catalog/catalog-live.ts b/sdk/packages/llms/src/catalog/catalog-live.ts
new file mode 100644
index 0000000..4bef440
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/catalog-live.ts
@@ -0,0 +1,214 @@
+import { MODELS_DEV_PROVIDER_KEY_MAP } from "../providers/provider-keys";
+import {
+	fetchClineRecommendedModelsPayload,
+	normalizeClineRecommendedProviderModels,
+} from "./catalog-cline-recommended";
+import type { ModelInfo } from "./types";
+
+export interface ModelsDevModel {
+	name?: string;
+	tool_call?: boolean;
+	reasoning?: boolean;
+	structured_output?: boolean;
+	temperature?: boolean;
+	release_date?: string;
+	family?: string;
+	limit?: {
+		context?: number;
+		input?: number;
+		output?: number;
+	};
+	cost?: {
+		input?: number;
+		output?: number;
+		cache_read?: number;
+		cache_write?: number;
+	};
+	modalities?: {
+		input?: string[];
+	};
+	status?: string;
+}
+
+interface ModelsDevProviderPayload {
+	models?: Record<string, ModelsDevModel>;
+}
+
+export type ModelsDevPayload = Record<string, ModelsDevProviderPayload>;
+export type ModelsDevProviderKeyMap = Record<string, string>;
+
+const DEFAULT_MAX_INPUT_TOKENS = 128_000;
+const DEFAULT_MAX_TOKENS = 4096;
+
+function parseReleaseDate(value: string | undefined): number {
+	if (!value) {
+		return Number.NEGATIVE_INFINITY;
+	}
+
+	const timestamp = Date.parse(value);
+	return Number.isNaN(timestamp) ? Number.NEGATIVE_INFINITY : timestamp;
+}
+
+export function sortModelsByReleaseDate(
+	models: Record<string, ModelInfo>,
+): Record<string, ModelInfo> {
+	return Object.fromEntries(
+		Object.entries(models).sort(([modelIdA, modelA], [modelIdB, modelB]) => {
+			const releaseDateA = parseReleaseDate(modelA.releaseDate);
+			const releaseDateB = parseReleaseDate(modelB.releaseDate);
+			if (releaseDateA !== releaseDateB) {
+				return releaseDateB - releaseDateA;
+			}
+			return modelIdA.localeCompare(modelIdB);
+		}),
+	);
+}
+
+function toCapabilities(model: ModelsDevModel): ModelInfo["capabilities"] {
+	const capabilities: NonNullable<ModelInfo["capabilities"]> = [];
+	if (model.modalities?.input?.includes("image")) {
+		capabilities.push("images");
+	}
+	if (model.modalities?.input?.includes("pdf")) {
+		capabilities.push("files");
+	}
+	if (model.tool_call === true) {
+		capabilities.push("tools");
+	}
+	if (model.reasoning === true) {
+		capabilities.push("reasoning");
+	}
+	if (model.structured_output === true) {
+		capabilities.push("structured_output");
+	}
+	if (model.temperature === true) {
+		capabilities.push("temperature");
+	}
+	if (
+		(model.cost?.cache_read && model.cost?.cache_read >= 0) ||
+		(model.cost?.cache_write && model.cost?.cache_write >= 0)
+	) {
+		capabilities.push("prompt-cache");
+	}
+	return Array.from(new Set(capabilities));
+}
+
+function toStatus(status: string | undefined): ModelInfo["status"] {
+	if (
+		status === "active" ||
+		status === "preview" ||
+		status === "deprecated" ||
+		status === "legacy"
+	) {
+		return status;
+	}
+	return undefined;
+}
+
+export function resolveMaxInputTokens(
+	limit: ModelsDevModel["limit"] | undefined,
+): number {
+	const contextLimit = limit?.context;
+	const inputLimit = limit?.input;
+	if (typeof contextLimit === "number" && typeof inputLimit === "number") {
+		return Math.min(contextLimit, inputLimit);
+	}
+	return inputLimit ?? contextLimit ?? DEFAULT_MAX_INPUT_TOKENS;
+}
+
+function toModelInfo(modelId: string, model: ModelsDevModel): ModelInfo {
+	// If context or output limits are missing, default to DEFAULT_MAX_INPUT_TOKENS and DEFAULT_MAX_TOKENS respectively.
+	const maxInputTokens = resolveMaxInputTokens(model.limit);
+	const outputToken = model.limit?.output ?? DEFAULT_MAX_TOKENS;
+	const rawContextLimit = model.limit?.context;
+
+	return {
+		id: modelId,
+		name: model.name || modelId,
+		contextWindow: rawContextLimit,
+		maxInputTokens,
+		maxTokens: Math.floor(outputToken),
+		capabilities: toCapabilities(model),
+		pricing: {
+			input: model.cost?.input ?? 0,
+			output: model.cost?.output ?? 0,
+			cacheRead: model.cost?.cache_read ?? 0,
+			cacheWrite: model.cost?.cache_write ?? 0,
+		},
+		status: toStatus(model.status),
+		releaseDate: model.release_date,
+		family: model.family,
+	};
+}
+
+function isDeprecatedModel(model: ModelsDevModel): boolean {
+	return model.status === "deprecated";
+}
+
+export function normalizeModelsDevProviderModels(
+	payload: ModelsDevPayload,
+): Record<string, Record<string, ModelInfo>> {
+	const providerModels: Record<string, Record<string, ModelInfo>> = {};
+
+	for (const [sourceProviderKey, targetProviderId] of Object.entries(
+		MODELS_DEV_PROVIDER_KEY_MAP,
+	)) {
+		const source = payload[sourceProviderKey];
+		if (!source?.models) {
+			continue;
+		}
+
+		const models: Record<string, ModelInfo> = {};
+		for (const [modelId, model] of Object.entries(source.models)) {
+			if (model.tool_call !== true || isDeprecatedModel(model)) {
+				continue;
+			}
+			models[modelId] = toModelInfo(modelId, model);
+		}
+
+		if (Object.keys(models).length > 0) {
+			providerModels[targetProviderId] = sortModelsByReleaseDate(models);
+		}
+	}
+
+	return providerModels;
+}
+
+export async function fetchModelsDevProviderModels(
+	url: string,
+	fetcher: typeof fetch = fetch,
+): Promise<Record<string, Record<string, ModelInfo>>> {
+	const response = await fetcher(url);
+	if (!response.ok) {
+		throw new Error(
+			`Failed to load model catalog from ${url}: HTTP ${response.status}`,
+		);
+	}
+
+	const payload = (await response.json()) as ModelsDevPayload;
+	return normalizeModelsDevProviderModels(payload);
+}
+
+export async function fetchLiveProviderModels(
+	modelsDevUrl: string,
+	fetcher: typeof fetch = fetch,
+): Promise<Record<string, Record<string, ModelInfo>>> {
+	const emptyProviderModels: Record<string, Record<string, ModelInfo>> = {};
+	const [providerModels, clineRecommendedPayload] = await Promise.all([
+		fetchModelsDevProviderModels(modelsDevUrl, fetcher).catch(
+			() => emptyProviderModels,
+		),
+		fetchClineRecommendedModelsPayload(fetcher).catch(() => undefined),
+	]);
+	const clineRecommended = clineRecommendedPayload
+		? normalizeClineRecommendedProviderModels(
+				clineRecommendedPayload,
+				providerModels.openrouter ?? {},
+			)
+		: {};
+
+	return {
+		...providerModels,
+		...clineRecommended,
+	};
+}
diff --git a/sdk/packages/llms/src/catalog/catalog.generated-access.ts b/sdk/packages/llms/src/catalog/catalog.generated-access.ts
new file mode 100644
index 0000000..88eee36
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/catalog.generated-access.ts
@@ -0,0 +1,41 @@
+import { GENERATED_PROVIDER_MODELS } from "./catalog.generated";
+import { sortModelsByReleaseDate } from "./catalog-live";
+import type { ModelInfo } from "./types";
+
+let sortedGeneratedProviderModelsCache:
+	| Record<string, Record<string, ModelInfo>>
+	| undefined;
+const sortedGeneratedModelsByProviderCache = new Map<
+	string,
+	Record<string, ModelInfo>
+>();
+
+export function getGeneratedProviderModels(): Record<
+	string,
+	Record<string, ModelInfo>
+> {
+	sortedGeneratedProviderModelsCache ??= Object.fromEntries(
+		Object.entries(GENERATED_PROVIDER_MODELS.providers).map(
+			([providerId, models]) => [providerId, sortModelsByReleaseDate(models)],
+		),
+	);
+	return sortedGeneratedProviderModelsCache;
+}
+
+export function getGeneratedModelsVersion(): number {
+	return GENERATED_PROVIDER_MODELS.version;
+}
+
+export function getGeneratedModelsForProvider(
+	providerId: string,
+): Record<string, ModelInfo> {
+	const cached = sortedGeneratedModelsByProviderCache.get(providerId);
+	if (cached) {
+		return cached;
+	}
+	const sorted = sortModelsByReleaseDate(
+		GENERATED_PROVIDER_MODELS.providers[providerId] ?? {},
+	);
+	sortedGeneratedModelsByProviderCache.set(providerId, sorted);
+	return sorted;
+}
diff --git a/sdk/packages/llms/src/catalog/catalog.generated.ts b/sdk/packages/llms/src/catalog/catalog.generated.ts
new file mode 100644
index 0000000..c6938b0
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/catalog.generated.ts
@@ -0,0 +1,24600 @@
+/**
+ * Auto-generated model catalog.
+ *
+ * Generated by: @cline/llms/scripts/generate-models.ts
+ *
+ * WARNING: DO NOT EDIT THIS FILE MANUALLY.
+ */
+import type { ModelInfo } from "@cline/shared";
+/**
+ * Model list auto-generated for built-in providers
+ * listed in @cline/llms/src/providers/provider-keys.ts
+ */
+export const GENERATED_PROVIDER_MODELS: {
+	version: number;
+	providers: Record<string, Record<string, ModelInfo>>;
+} = {
+	version: 1783565774738,
+	providers: {
+		aihubmix: {
+			"glm-5.2": {
+				id: "glm-5.2",
+				name: "GLM-5.2",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1268,
+					output: 3.9438,
+					cacheRead: 0.2817,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"qwen3.7-plus": {
+				id: "qwen3.7-plus",
+				name: "Qwen3.7 Plus",
+				contextWindow: 991000,
+				maxInputTokens: 991000,
+				maxTokens: 64000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.282,
+					output: 1.128,
+					cacheRead: 0.0564,
+					cacheWrite: 0.3525,
+				},
+				releaseDate: "2026-06-02",
+				family: "qwen",
+			},
+			"claude-opus-4-8": {
+				id: "claude-opus-4-8",
+				name: "Claude Opus 4.8",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"claude-opus-4-8-think": {
+				id: "claude-opus-4-8-think",
+				name: "Claude Opus 4.8",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"qwen3.7-max": {
+				id: "qwen3.7-max",
+				name: "Qwen3.7 Max",
+				contextWindow: 991000,
+				maxInputTokens: 991000,
+				maxTokens: 64000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.69,
+					output: 5.07,
+					cacheRead: 0.169,
+					cacheWrite: 2.1125,
+				},
+				releaseDate: "2026-05-21",
+				family: "qwen",
+			},
+			"glm-5v-turbo": {
+				id: "glm-5v-turbo",
+				name: "GLM 5 Vision Turbo",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.7042,
+					output: 3.09848,
+					cacheRead: 0.169008,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-09",
+				family: "glmv",
+			},
+			"qwen3.6-max-preview": {
+				id: "qwen3.6-max-preview",
+				name: "Qwen3.6 Max Preview",
+				contextWindow: 240000,
+				maxInputTokens: 240000,
+				maxTokens: 64000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.27,
+					output: 7.61,
+					cacheRead: 0.1268,
+					cacheWrite: 1.585,
+				},
+				releaseDate: "2026-05-09",
+				family: "qwen3.6",
+			},
+			"qwen3.6-plus": {
+				id: "qwen3.6-plus",
+				name: "Qwen3.6 Plus",
+				contextWindow: 991000,
+				maxInputTokens: 991000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.28,
+					output: 1.69,
+					cacheRead: 0.0282,
+					cacheWrite: 0.3525,
+				},
+				releaseDate: "2026-05-09",
+				family: "qwen3.6",
+			},
+			"gemini-3.1-flash-lite": {
+				id: "gemini-3.1-flash-lite",
+				name: "Gemini 3.1 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.025,
+					cacheWrite: 1,
+				},
+				releaseDate: "2026-05-07",
+				family: "gemini-flash-lite",
+			},
+			"grok-4.3": {
+				id: "grok-4.3",
+				name: "Grok 4.3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-01",
+				family: "grok",
+			},
+			"doubao-seed-2-0-lite-260428": {
+				id: "doubao-seed-2-0-lite-260428",
+				name: "Doubao Seed 2.0 Lite 260428",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.08,
+					output: 0.51,
+					cacheRead: 0.01692,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+				family: "seed",
+			},
+			"doubao-seed-2-0-mini-260428": {
+				id: "doubao-seed-2-0-mini-260428",
+				name: "Doubao Seed 2.0 Mini 260428",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.03,
+					output: 0.28,
+					cacheRead: 0.00564,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+				family: "seed",
+			},
+			"alicloud-deepseek-v4-flash": {
+				id: "alicloud-deepseek-v4-flash",
+				name: "DeepSeek V4 Flash (Alibaba Cloud)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"alicloud-deepseek-v4-pro": {
+				id: "alicloud-deepseek-v4-pro",
+				name: "DeepSeek V4 Pro (Alibaba Cloud)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.69,
+					output: 3.38,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"deep-deepseek-v4-flash": {
+				id: "deep-deepseek-v4-flash",
+				name: "DeepSeek V4 Flash (DeepSeek)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.154,
+					output: 0.308,
+					cacheRead: 0.0308,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"deep-deepseek-v4-pro": {
+				id: "deep-deepseek-v4-pro",
+				name: "DeepSeek V4 Pro (DeepSeek)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.478,
+					output: 0.956,
+					cacheRead: 0.004302,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"gpt-5.5": {
+				id: "gpt-5.5",
+				name: "GPT-5.5",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt",
+			},
+			"coding-xiaomi-mimo-v2.5": {
+				id: "coding-xiaomi-mimo-v2.5",
+				name: "Coding Xiaomi MiMo-V2.5",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.08,
+					output: 0.4,
+					cacheRead: 0.016,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5",
+			},
+			"coding-xiaomi-mimo-v2.5-pro": {
+				id: "coding-xiaomi-mimo-v2.5-pro",
+				name: "Coding Xiaomi MiMo-V2.5-Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5-pro",
+			},
+			"xiaomi-mimo-v2.5": {
+				id: "xiaomi-mimo-v2.5",
+				name: "Xiaomi MiMo-V2.5",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.44,
+					output: 2.2,
+					cacheRead: 0.088,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5",
+			},
+			"xiaomi-mimo-v2.5-free": {
+				id: "xiaomi-mimo-v2.5-free",
+				name: "Xiaomi MiMo-V2.5 (free)",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5",
+			},
+			"xiaomi-mimo-v2.5-pro": {
+				id: "xiaomi-mimo-v2.5-pro",
+				name: "Xiaomi MiMo-V2.5-Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.1,
+					output: 3.3,
+					cacheRead: 0.22,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5-pro",
+			},
+			"xiaomi-mimo-v2.5-pro-free": {
+				id: "xiaomi-mimo-v2.5-pro-free",
+				name: "Xiaomi MiMo-V2.5-Pro (free)",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5-pro",
+			},
+			"kimi-k2.6": {
+				id: "kimi-k2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "kimi-k2",
+			},
+			"claude-opus-4-7": {
+				id: "claude-opus-4-7",
+				name: "Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"claude-opus-4-7-think": {
+				id: "claude-opus-4-7-think",
+				name: "Claude Opus 4.7 Thinking",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"coding-glm-5.1": {
+				id: "coding-glm-5.1",
+				name: "Coding GLM 5.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.06,
+					output: 0.22,
+					cacheRead: 0.013,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-11",
+				family: "glm",
+			},
+			"coding-glm-5.1-free": {
+				id: "coding-glm-5.1-free",
+				name: "Coding GLM 5.1 (free)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-11",
+				family: "glm-free",
+			},
+			"qwen3.6-flash": {
+				id: "qwen3.6-flash",
+				name: "Qwen3.6 Flash",
+				contextWindow: 991000,
+				maxInputTokens: 991000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.17,
+					output: 1.01,
+					cacheRead: 0.0169,
+					cacheWrite: 0.21125,
+				},
+				releaseDate: "2026-04-02",
+				family: "qwen3.6",
+			},
+			"alicloud-glm-5.1": {
+				id: "alicloud-glm-5.1",
+				name: "GLM-5.1 (Alibaba Cloud)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.84,
+					output: 3.38,
+					cacheRead: 0.169,
+					cacheWrite: 1.05625,
+				},
+				releaseDate: "2026-03-27",
+				family: "glm",
+			},
+			"zai-glm-5.1": {
+				id: "zai-glm-5.1",
+				name: "GLM-5.1 (Z.ai)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.845,
+					output: 3.38,
+					cacheRead: 0.183112,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+				family: "glm",
+			},
+			"coding-minimax-m2.7": {
+				id: "coding-minimax-m2.7",
+				name: "Coding MiniMax M2.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 128100,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"coding-minimax-m2.7-free": {
+				id: "coding-minimax-m2.7-free",
+				name: "Coding MiniMax M2.7 (Free)",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 128100,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax-free",
+			},
+			"coding-minimax-m2.7-highspeed": {
+				id: "coding-minimax-m2.7-highspeed",
+				name: "Coding MiniMax M2.7 Highspeed",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 128100,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"minimax-m2.7": {
+				id: "minimax-m2.7",
+				name: "MiniMax M2.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"gpt-5.4-mini": {
+				id: "gpt-5.4-mini",
+				name: "GPT-5.4 mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt-mini",
+			},
+			"gpt-5.4": {
+				id: "gpt-5.4",
+				name: "GPT-5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"gemini-3.1-pro-preview": {
+				id: "gemini-3.1-pro-preview",
+				name: "Gemini 3.1 Pro Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"gemini-3.1-pro-preview-customtools": {
+				id: "gemini-3.1-pro-preview-customtools",
+				name: "Gemini 3.1 Pro Preview Custom Tools",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"claude-sonnet-4-6": {
+				id: "claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"claude-sonnet-4-6-think": {
+				id: "claude-sonnet-4-6-think",
+				name: "Claude Sonnet 4.6 Thinking",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"doubao-seed-2-0-code-preview": {
+				id: "doubao-seed-2-0-code-preview",
+				name: "Doubao Seed 2.0 Code Preview",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.48,
+					output: 2.41,
+					cacheRead: 0.09644,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-14",
+				family: "seed",
+			},
+			"doubao-seed-2-0-pro": {
+				id: "doubao-seed-2-0-pro",
+				name: "Doubao Seed 2.0 Pro",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.48,
+					output: 2.41,
+					cacheRead: 0.09644,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-14",
+				family: "seed",
+			},
+			"claude-opus-4-6": {
+				id: "claude-opus-4-6",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"claude-opus-4-6-think": {
+				id: "claude-opus-4-6-think",
+				name: "Claude Opus 4.6 Thinking",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"gpt-5.3-codex": {
+				id: "gpt-5.3-codex",
+				name: "GPT-5.3 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-05",
+				family: "gpt-codex",
+			},
+			"kimi-k2.5": {
+				id: "kimi-k2.5",
+				name: "Kimi K2.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01",
+				family: "kimi-k2",
+			},
+			"gemini-3-flash-preview": {
+				id: "gemini-3-flash-preview",
+				name: "Gemini 3 Flash Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-17",
+				family: "gemini-flash",
+			},
+			"gpt-5.2": {
+				id: "gpt-5.2",
+				name: "GPT-5.2",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"gpt-5.2-codex": {
+				id: "gpt-5.2-codex",
+				name: "GPT-5.2 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-codex",
+			},
+			"gpt-5.1": {
+				id: "gpt-5.1",
+				name: "GPT-5.1",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt",
+			},
+			"gpt-5.1-codex": {
+				id: "gpt-5.1-codex",
+				name: "GPT-5.1 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"gpt-5.1-codex-mini": {
+				id: "gpt-5.1-codex-mini",
+				name: "GPT-5.1 Codex mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"gemini-2.5-flash": {
+				id: "gemini-2.5-flash",
+				name: "Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-20",
+				family: "gemini-flash",
+			},
+			"gemini-2.5-pro": {
+				id: "gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-20",
+				family: "gemini-pro",
+			},
+		},
+		anthropic: {
+			"claude-sonnet-5": {
+				id: "claude-sonnet-5",
+				name: "Claude Sonnet 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-29",
+				family: "claude-sonnet",
+			},
+			"claude-fable-5": {
+				id: "claude-fable-5",
+				name: "Claude Fable 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-06-07",
+				family: "claude-fable",
+			},
+			"claude-opus-4-8": {
+				id: "claude-opus-4-8",
+				name: "Claude Opus 4.8",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"claude-opus-4-7": {
+				id: "claude-opus-4-7",
+				name: "Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-14",
+				family: "claude-opus",
+			},
+			"claude-sonnet-4-6": {
+				id: "claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"claude-opus-4-6": {
+				id: "claude-opus-4-6",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-04",
+				family: "claude-opus",
+			},
+			"claude-opus-4-5": {
+				id: "claude-opus-4-5",
+				name: "Claude Opus 4.5 (latest)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"claude-opus-4-5-20251101": {
+				id: "claude-opus-4-5-20251101",
+				name: "Claude Opus 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"claude-haiku-4-5": {
+				id: "claude-haiku-4-5",
+				name: "Claude Haiku 4.5 (latest)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"claude-haiku-4-5-20251001": {
+				id: "claude-haiku-4-5-20251001",
+				name: "Claude Haiku 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"claude-sonnet-4-5": {
+				id: "claude-sonnet-4-5",
+				name: "Claude Sonnet 4.5 (latest)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"claude-sonnet-4-5-20250929": {
+				id: "claude-sonnet-4-5-20250929",
+				name: "Claude Sonnet 4.5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+		},
+		baseten: {
+			"zai-org/GLM-5.2": {
+				id: "zai-org/GLM-5.2",
+				name: "GLM 5.2",
+				contextWindow: 202720,
+				maxInputTokens: 202720,
+				maxTokens: 202720,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.3,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"moonshotai/Kimi-K2.7-Code": {
+				id: "moonshotai/Kimi-K2.7-Code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B": {
+				id: "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B",
+				name: "Nemotron Ultra",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 202800,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"deepseek-ai/DeepSeek-V4-Pro": {
+				id: "deepseek-ai/DeepSeek-V4-Pro",
+				name: "Deepseek V4 Pro",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.74,
+					output: 3.48,
+					cacheRead: 0.145,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"moonshotai/Kimi-K2.6": {
+				id: "moonshotai/Kimi-K2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "kimi-k2",
+			},
+			"zai-org/GLM-5.1": {
+				id: "zai-org/GLM-5.1",
+				name: "GLM 5.1",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 202800,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.3,
+					output: 4.3,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "glm",
+			},
+			"nvidia/Nemotron-120B-A12B": {
+				id: "nvidia/Nemotron-120B-A12B",
+				name: "Nemotron Super",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 202800,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 0.75,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"zai-org/GLM-5": {
+				id: "zai-org/GLM-5",
+				name: "GLM 5",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 202800,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 3.15,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "glm",
+			},
+			"moonshotai/Kimi-K2.5": {
+				id: "moonshotai/Kimi-K2.5",
+				name: "Kimi K2.5",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-30",
+				family: "kimi-k2",
+			},
+			"zai-org/GLM-4.7": {
+				id: "zai-org/GLM-4.7",
+				name: "GLM 4.7",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 200000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "OpenAI GPT 120B",
+				contextWindow: 128072,
+				maxInputTokens: 128072,
+				maxTokens: 128072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+		},
+		bedrock: {
+			"anthropic.claude-sonnet-5": {
+				id: "anthropic.claude-sonnet-5",
+				name: "Claude Sonnet 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"au.anthropic.claude-sonnet-5": {
+				id: "au.anthropic.claude-sonnet-5",
+				name: "Claude Sonnet 5 (AU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"eu.anthropic.claude-sonnet-5": {
+				id: "eu.anthropic.claude-sonnet-5",
+				name: "Claude Sonnet 5 (EU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.2,
+					output: 11,
+					cacheRead: 0.22,
+					cacheWrite: 2.75,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"global.anthropic.claude-sonnet-5": {
+				id: "global.anthropic.claude-sonnet-5",
+				name: "Claude Sonnet 5 (Global)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"jp.anthropic.claude-sonnet-5": {
+				id: "jp.anthropic.claude-sonnet-5",
+				name: "Claude Sonnet 5 (JP)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"us.anthropic.claude-sonnet-5": {
+				id: "us.anthropic.claude-sonnet-5",
+				name: "Claude Sonnet 5 (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"anthropic.claude-fable-5": {
+				id: "anthropic.claude-fable-5",
+				name: "Claude Fable 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-06-09",
+				family: "claude-fable",
+			},
+			"eu.anthropic.claude-fable-5": {
+				id: "eu.anthropic.claude-fable-5",
+				name: "Claude Fable 5 (EU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 11,
+					output: 55,
+					cacheRead: 1.1,
+					cacheWrite: 13.75,
+				},
+				releaseDate: "2026-06-09",
+				family: "claude-fable",
+			},
+			"global.anthropic.claude-fable-5": {
+				id: "global.anthropic.claude-fable-5",
+				name: "Claude Fable 5 (Global)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-06-09",
+				family: "claude-fable",
+			},
+			"us.anthropic.claude-fable-5": {
+				id: "us.anthropic.claude-fable-5",
+				name: "Claude Fable 5 (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-06-09",
+				family: "claude-fable",
+			},
+			"anthropic.claude-opus-4-8": {
+				id: "anthropic.claude-opus-4-8",
+				name: "Claude Opus 4.8",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"au.anthropic.claude-opus-4-8": {
+				id: "au.anthropic.claude-opus-4-8",
+				name: "Claude Opus 4.8 (AU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"eu.anthropic.claude-opus-4-8": {
+				id: "eu.anthropic.claude-opus-4-8",
+				name: "Claude Opus 4.8 (EU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5.5,
+					output: 27.5,
+					cacheRead: 0.55,
+					cacheWrite: 6.875,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"global.anthropic.claude-opus-4-8": {
+				id: "global.anthropic.claude-opus-4-8",
+				name: "Claude Opus 4.8 (Global)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"jp.anthropic.claude-opus-4-8": {
+				id: "jp.anthropic.claude-opus-4-8",
+				name: "Claude Opus 4.8 (JP)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"us.anthropic.claude-opus-4-8": {
+				id: "us.anthropic.claude-opus-4-8",
+				name: "Claude Opus 4.8 (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"openai.gpt-5.5": {
+				id: "openai.gpt-5.5",
+				name: "GPT-5.5",
+				contextWindow: 272000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5.5,
+					output: 33,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt",
+			},
+			"xai.grok-4.3": {
+				id: "xai.grok-4.3",
+				name: "Grok 4.3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "grok",
+			},
+			"anthropic.claude-opus-4-7": {
+				id: "anthropic.claude-opus-4-7",
+				name: "Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"eu.anthropic.claude-opus-4-7": {
+				id: "eu.anthropic.claude-opus-4-7",
+				name: "Claude Opus 4.7 (EU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5.5,
+					output: 27.5,
+					cacheRead: 0.55,
+					cacheWrite: 6.875,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"global.anthropic.claude-opus-4-7": {
+				id: "global.anthropic.claude-opus-4-7",
+				name: "Claude Opus 4.7 (Global)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"jp.anthropic.claude-opus-4-7": {
+				id: "jp.anthropic.claude-opus-4-7",
+				name: "Claude Opus 4.7 (JP)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"us.anthropic.claude-opus-4-7": {
+				id: "us.anthropic.claude-opus-4-7",
+				name: "Claude Opus 4.7 (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"minimax.minimax-m2.5": {
+				id: "minimax.minimax-m2.5",
+				name: "MiniMax M2.5",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"zai.glm-5": {
+				id: "zai.glm-5",
+				name: "GLM-5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 101376,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1,
+					output: 3.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "glm",
+			},
+			"nvidia.nemotron-super-3-120b": {
+				id: "nvidia.nemotron-super-3-120b",
+				name: "NVIDIA Nemotron 3 Super 120B A12B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.65,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"openai.gpt-5.4": {
+				id: "openai.gpt-5.4",
+				name: "GPT-5.4",
+				contextWindow: 272000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.75,
+					output: 16.5,
+					cacheRead: 0.275,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"anthropic.claude-sonnet-4-6": {
+				id: "anthropic.claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"au.anthropic.claude-sonnet-4-6": {
+				id: "au.anthropic.claude-sonnet-4-6",
+				name: "AU Anthropic Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3.3,
+					output: 16.5,
+					cacheRead: 0.33,
+					cacheWrite: 4.125,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"eu.anthropic.claude-sonnet-4-6": {
+				id: "eu.anthropic.claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6 (EU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3.3,
+					output: 16.5,
+					cacheRead: 0.33,
+					cacheWrite: 4.125,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"global.anthropic.claude-sonnet-4-6": {
+				id: "global.anthropic.claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6 (Global)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"jp.anthropic.claude-sonnet-4-6": {
+				id: "jp.anthropic.claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6 (JP)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"mistral.devstral-2-123b": {
+				id: "mistral.devstral-2-123b",
+				name: "Devstral 2 123B",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 8192,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-17",
+				family: "devstral",
+			},
+			"us.anthropic.claude-sonnet-4-6": {
+				id: "us.anthropic.claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6 (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"deepseek.v3.2": {
+				id: "deepseek.v3.2",
+				name: "DeepSeek-V3.2",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 81920,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.62,
+					output: 1.85,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-06",
+				family: "deepseek",
+			},
+			"moonshotai.kimi-k2.5": {
+				id: "moonshotai.kimi-k2.5",
+				name: "Kimi K2.5",
+				contextWindow: 262143,
+				maxInputTokens: 262143,
+				maxTokens: 16000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-06",
+				family: "kimi",
+			},
+			"qwen.qwen3-coder-next": {
+				id: "qwen.qwen3-coder-next",
+				name: "Qwen3 Coder Next",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.22,
+					output: 1.8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-06",
+				family: "qwen",
+			},
+			"anthropic.claude-opus-4-6-v1": {
+				id: "anthropic.claude-opus-4-6-v1",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"au.anthropic.claude-opus-4-6-v1": {
+				id: "au.anthropic.claude-opus-4-6-v1",
+				name: "AU Anthropic Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 16.5,
+					output: 82.5,
+					cacheRead: 1.65,
+					cacheWrite: 20.625,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"eu.anthropic.claude-opus-4-6-v1": {
+				id: "eu.anthropic.claude-opus-4-6-v1",
+				name: "Claude Opus 4.6 (EU)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5.5,
+					output: 27.5,
+					cacheRead: 0.55,
+					cacheWrite: 6.875,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"global.anthropic.claude-opus-4-6-v1": {
+				id: "global.anthropic.claude-opus-4-6-v1",
+				name: "Claude Opus 4.6 (Global)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"us.anthropic.claude-opus-4-6-v1": {
+				id: "us.anthropic.claude-opus-4-6-v1",
+				name: "Claude Opus 4.6 (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"zai.glm-4.7-flash": {
+				id: "zai.glm-4.7-flash",
+				name: "GLM-4.7-Flash",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.07,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "glm-flash",
+			},
+			"minimax.minimax-m2.1": {
+				id: "minimax.minimax-m2.1",
+				name: "MiniMax M2.1",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"nvidia.nemotron-nano-3-30b": {
+				id: "nvidia.nemotron-nano-3-30b",
+				name: "NVIDIA Nemotron Nano 3 30B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "nemotron",
+			},
+			"zai.glm-4.7": {
+				id: "zai.glm-4.7",
+				name: "GLM-4.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"mistral.magistral-small-2509": {
+				id: "mistral.magistral-small-2509",
+				name: "Magistral Small 1.2",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 40000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "magistral",
+			},
+			"mistral.ministral-3-3b-instruct": {
+				id: "mistral.ministral-3-3b-instruct",
+				name: "Ministral 3 3B",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "ministral",
+			},
+			"mistral.mistral-large-3-675b-instruct": {
+				id: "mistral.mistral-large-3-675b-instruct",
+				name: "Mistral Large 3",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "mistral",
+			},
+			"moonshot.kimi-k2-thinking": {
+				id: "moonshot.kimi-k2-thinking",
+				name: "Kimi K2 Thinking",
+				contextWindow: 262143,
+				maxInputTokens: 262143,
+				maxTokens: 16000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "kimi-thinking",
+			},
+			"anthropic.claude-opus-4-5-20251101-v1:0": {
+				id: "anthropic.claude-opus-4-5-20251101-v1:0",
+				name: "Claude Opus 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"eu.anthropic.claude-opus-4-5-20251101-v1:0": {
+				id: "eu.anthropic.claude-opus-4-5-20251101-v1:0",
+				name: "Claude Opus 4.5 (EU)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5.5,
+					output: 27.5,
+					cacheRead: 0.55,
+					cacheWrite: 6.875,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"global.anthropic.claude-opus-4-5-20251101-v1:0": {
+				id: "global.anthropic.claude-opus-4-5-20251101-v1:0",
+				name: "Claude Opus 4.5 (Global)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"us.anthropic.claude-opus-4-5-20251101-v1:0": {
+				id: "us.anthropic.claude-opus-4-5-20251101-v1:0",
+				name: "Claude Opus 4.5 (US)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"openai.gpt-oss-safeguard-120b": {
+				id: "openai.gpt-oss-safeguard-120b",
+				name: "GPT OSS Safeguard 120B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-29",
+				family: "gpt-oss",
+			},
+			"openai.gpt-oss-safeguard-20b": {
+				id: "openai.gpt-oss-safeguard-20b",
+				name: "GPT OSS Safeguard 20B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-29",
+				family: "gpt-oss",
+			},
+			"minimax.minimax-m2": {
+				id: "minimax.minimax-m2",
+				name: "MiniMax M2",
+				contextWindow: 204608,
+				maxInputTokens: 204608,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-27",
+				family: "minimax",
+			},
+			"anthropic.claude-haiku-4-5-20251001-v1:0": {
+				id: "anthropic.claude-haiku-4-5-20251001-v1:0",
+				name: "Claude Haiku 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"au.anthropic.claude-haiku-4-5-20251001-v1:0": {
+				id: "au.anthropic.claude-haiku-4-5-20251001-v1:0",
+				name: "Claude Haiku 4.5 (AU)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"eu.anthropic.claude-haiku-4-5-20251001-v1:0": {
+				id: "eu.anthropic.claude-haiku-4-5-20251001-v1:0",
+				name: "Claude Haiku 4.5 (EU)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 5.5,
+					cacheRead: 0.11,
+					cacheWrite: 1.375,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"global.anthropic.claude-haiku-4-5-20251001-v1:0": {
+				id: "global.anthropic.claude-haiku-4-5-20251001-v1:0",
+				name: "Claude Haiku 4.5 (Global)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"jp.anthropic.claude-haiku-4-5-20251001-v1:0": {
+				id: "jp.anthropic.claude-haiku-4-5-20251001-v1:0",
+				name: "Claude Haiku 4.5 (JP)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"us.anthropic.claude-haiku-4-5-20251001-v1:0": {
+				id: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+				name: "Claude Haiku 4.5 (US)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"qwen.qwen3-vl-235b-a22b": {
+				id: "qwen.qwen3-vl-235b-a22b",
+				name: "Qwen/Qwen3-VL-235B-A22B-Instruct",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-04",
+				family: "qwen",
+			},
+			"anthropic.claude-sonnet-4-5-20250929-v1:0": {
+				id: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+				name: "Claude Sonnet 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"au.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+				id: "au.anthropic.claude-sonnet-4-5-20250929-v1:0",
+				name: "Claude Sonnet 4.5 (AU)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"eu.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+				id: "eu.anthropic.claude-sonnet-4-5-20250929-v1:0",
+				name: "Claude Sonnet 4.5 (EU)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3.3,
+					output: 16.5,
+					cacheRead: 0.33,
+					cacheWrite: 4.125,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"global.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+				id: "global.anthropic.claude-sonnet-4-5-20250929-v1:0",
+				name: "Claude Sonnet 4.5 (Global)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"jp.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+				id: "jp.anthropic.claude-sonnet-4-5-20250929-v1:0",
+				name: "Claude Sonnet 4.5 (JP)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"us.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+				id: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+				name: "Claude Sonnet 4.5 (US)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"deepseek.v3-v1:0": {
+				id: "deepseek.v3-v1:0",
+				name: "DeepSeek-V3.1",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 81920,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.58,
+					output: 1.68,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-18",
+				family: "deepseek",
+			},
+			"qwen.qwen3-235b-a22b-2507-v1:0": {
+				id: "qwen.qwen3-235b-a22b-2507-v1:0",
+				name: "Qwen3 235B A22B 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 0.88,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-18",
+				family: "qwen",
+			},
+			"qwen.qwen3-32b-v1:0": {
+				id: "qwen.qwen3-32b-v1:0",
+				name: "Qwen3 32B (dense)",
+				contextWindow: 16384,
+				maxInputTokens: 16384,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-18",
+				family: "qwen",
+			},
+			"qwen.qwen3-coder-30b-a3b-v1:0": {
+				id: "qwen.qwen3-coder-30b-a3b-v1:0",
+				name: "Qwen3 Coder 30B A3B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-18",
+				family: "qwen",
+			},
+			"qwen.qwen3-coder-480b-a35b-v1:0": {
+				id: "qwen.qwen3-coder-480b-a35b-v1:0",
+				name: "Qwen3 Coder 480B A35B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 1.8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-18",
+				family: "qwen",
+			},
+			"qwen.qwen3-next-80b-a3b": {
+				id: "qwen.qwen3-next-80b-a3b",
+				name: "Qwen/Qwen3-Next-80B-A3B-Instruct",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.14,
+					output: 1.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-18",
+				family: "qwen",
+			},
+			"anthropic.claude-opus-4-1-20250805-v1:0": {
+				id: "anthropic.claude-opus-4-1-20250805-v1:0",
+				name: "Claude Opus 4.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-08-05",
+				family: "claude-opus",
+			},
+			"openai.gpt-oss-120b": {
+				id: "openai.gpt-oss-120b",
+				name: "gpt-oss-120b",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai.gpt-oss-120b-1:0": {
+				id: "openai.gpt-oss-120b-1:0",
+				name: "gpt-oss-120b",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai.gpt-oss-20b": {
+				id: "openai.gpt-oss-20b",
+				name: "gpt-oss-20b",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.07,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai.gpt-oss-20b-1:0": {
+				id: "openai.gpt-oss-20b-1:0",
+				name: "gpt-oss-20b",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.07,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"us.anthropic.claude-opus-4-1-20250805-v1:0": {
+				id: "us.anthropic.claude-opus-4-1-20250805-v1:0",
+				name: "Claude Opus 4.1 (US)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-08-05",
+				family: "claude-opus",
+			},
+			"google.gemma-3-27b-it": {
+				id: "google.gemma-3-27b-it",
+				name: "Google Gemma 3 27B Instruct",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.12,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-27",
+				family: "gemma",
+			},
+			"mistral.voxtral-small-24b-2507": {
+				id: "mistral.voxtral-small-24b-2507",
+				name: "Voxtral Small 24B 2507",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 8192,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.35,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-01",
+				family: "mistral",
+			},
+			"writer.palmyra-x4-v1:0": {
+				id: "writer.palmyra-x4-v1:0",
+				name: "Palmyra X4",
+				contextWindow: 122880,
+				maxInputTokens: 122880,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "palmyra",
+			},
+			"writer.palmyra-x5-v1:0": {
+				id: "writer.palmyra-x5-v1:0",
+				name: "Palmyra X5",
+				contextWindow: 1040000,
+				maxInputTokens: 1040000,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "palmyra",
+			},
+			"mistral.pixtral-large-2502-v1:0": {
+				id: "mistral.pixtral-large-2502-v1:0",
+				name: "Pixtral Large (25.02)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-08",
+				family: "mistral",
+			},
+			"meta.llama4-maverick-17b-instruct-v1:0": {
+				id: "meta.llama4-maverick-17b-instruct-v1:0",
+				name: "Llama 4 Maverick 17B Instruct",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.24,
+					output: 0.97,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"meta.llama4-scout-17b-instruct-v1:0": {
+				id: "meta.llama4-scout-17b-instruct-v1:0",
+				name: "Llama 4 Scout 17B Instruct",
+				contextWindow: 3500000,
+				maxInputTokens: 3500000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.17,
+					output: 0.66,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"us.meta.llama4-maverick-17b-instruct-v1:0": {
+				id: "us.meta.llama4-maverick-17b-instruct-v1:0",
+				name: "Llama 4 Maverick 17B Instruct (US)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.24,
+					output: 0.97,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"us.meta.llama4-scout-17b-instruct-v1:0": {
+				id: "us.meta.llama4-scout-17b-instruct-v1:0",
+				name: "Llama 4 Scout 17B Instruct (US)",
+				contextWindow: 3500000,
+				maxInputTokens: 3500000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.17,
+					output: 0.66,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"deepseek.r1-v1:0": {
+				id: "deepseek.r1-v1:0",
+				name: "DeepSeek-R1",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 1.35,
+					output: 5.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-20",
+				family: "deepseek-thinking",
+			},
+			"us.deepseek.r1-v1:0": {
+				id: "us.deepseek.r1-v1:0",
+				name: "DeepSeek-R1 (US)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 1.35,
+					output: 5.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-20",
+				family: "deepseek-thinking",
+			},
+			"meta.llama3-3-70b-instruct-v1:0": {
+				id: "meta.llama3-3-70b-instruct-v1:0",
+				name: "Llama 3.3 70B Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.72,
+					output: 0.72,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+			"amazon.nova-lite-v1:0": {
+				id: "amazon.nova-lite-v1:0",
+				name: "Nova Lite",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+				family: "nova-lite",
+			},
+			"amazon.nova-micro-v1:0": {
+				id: "amazon.nova-micro-v1:0",
+				name: "Nova Micro",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.035,
+					output: 0.14,
+					cacheRead: 0.00875,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+				family: "nova-micro",
+			},
+			"amazon.nova-pro-v1:0": {
+				id: "amazon.nova-pro-v1:0",
+				name: "Nova Pro",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.8,
+					output: 3.2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+				family: "nova-pro",
+			},
+			"amazon.nova-2-lite-v1:0": {
+				id: "amazon.nova-2-lite-v1:0",
+				name: "Nova 2 Lite",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.33,
+					output: 2.75,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "nova",
+			},
+			"google.gemma-3-4b-it": {
+				id: "google.gemma-3-4b-it",
+				name: "Gemma 3 4B IT",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.04,
+					output: 0.08,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "gemma",
+			},
+			"mistral.ministral-3-14b-instruct": {
+				id: "mistral.ministral-3-14b-instruct",
+				name: "Ministral 14B 3.0",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "ministral",
+			},
+			"mistral.ministral-3-8b-instruct": {
+				id: "mistral.ministral-3-8b-instruct",
+				name: "Ministral 3 8B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "ministral",
+			},
+			"mistral.voxtral-mini-3b-2507": {
+				id: "mistral.voxtral-mini-3b-2507",
+				name: "Voxtral Mini 3B 2507",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.04,
+					output: 0.04,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "mistral",
+			},
+			"nvidia.nemotron-nano-12b-v2": {
+				id: "nvidia.nemotron-nano-12b-v2",
+				name: "NVIDIA Nemotron Nano 12B v2 VL BF16",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "nemotron",
+			},
+			"nvidia.nemotron-nano-9b-v2": {
+				id: "nvidia.nemotron-nano-9b-v2",
+				name: "NVIDIA Nemotron Nano 9B v2",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.06,
+					output: 0.23,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "nemotron",
+			},
+			"meta.llama3-1-70b-instruct-v1:0": {
+				id: "meta.llama3-1-70b-instruct-v1:0",
+				name: "Llama 3.1 70B Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.72,
+					output: 0.72,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+			"meta.llama3-1-8b-instruct-v1:0": {
+				id: "meta.llama3-1-8b-instruct-v1:0",
+				name: "Llama 3.1 8B Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 0.22,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+		},
+		cerebras: {
+			"gemma-4-31b": {
+				id: "gemma-4-31b",
+				name: "Gemma 4 31B IT",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 40960,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.99,
+					output: 1.49,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"zai-glm-4.7": {
+				id: "zai-glm-4.7",
+				name: "Z.AI GLM-4.7",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 40960,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 2.25,
+					output: 2.75,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-07",
+			},
+			"gpt-oss-120b": {
+				id: "gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 40960,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.35,
+					output: 0.75,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+		},
+		"cline-pass": {
+			"cline-pass/glm-5.2": {
+				name: "GLM-5.2",
+				id: "cline-pass/glm-5.2",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 1048576,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.9,
+					output: 3.08,
+					cacheRead: 0.18,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+				description: "Best open weights model",
+			},
+			"cline-pass/deepseek-v4-pro": {
+				name: "DeepSeek V4 Pro",
+				id: "cline-pass/deepseek-v4-pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.003625,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+				description: "Frontier reasoning and coding with 1M context window",
+			},
+			"cline-pass/deepseek-v4-flash": {
+				name: "DeepSeek V4 Flash",
+				id: "cline-pass/deepseek-v4-flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.09,
+					output: 0.18,
+					cacheRead: 0.018,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+				description: "Fast and efficient with 1M context window",
+			},
+			"cline-pass/kimi-k2.7-code": {
+				name: "Kimi K2.7 Code",
+				id: "cline-pass/kimi-k2.7-code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.74,
+					output: 3.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+				description: "Latest Kimi model specialized for agentic coding",
+			},
+			"cline-pass/kimi-k2.6": {
+				name: "Kimi K2.6",
+				id: "cline-pass/kimi-k2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.65,
+					output: 3.41,
+					cacheRead: 0.14,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "kimi-k2",
+				description: "Strong multimodal model for long-horizon agent tasks",
+			},
+			"cline-pass/mimo-v2.5-pro": {
+				name: "MiMo-V2.5-Pro",
+				id: "cline-pass/mimo-v2.5-pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.0036,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+				description: "Top open model for long autonomous coding runs",
+			},
+			"cline-pass/mimo-v2.5": {
+				name: "MiMo-V2.5",
+				id: "cline-pass/mimo-v2.5",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.105,
+					output: 0.28,
+					cacheRead: 0.028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+				description: "Fast and efficient MiMo for everyday coding",
+			},
+			"cline-pass/minimax-m3": {
+				name: "MiniMax-M3",
+				id: "cline-pass/minimax-m3",
+				contextWindow: 524288,
+				maxInputTokens: 524288,
+				maxTokens: 512000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-01",
+				family: "minimax",
+				description: "Frontier coding and agent model with 1M context window",
+			},
+			"cline-pass/qwen3.7-max": {
+				name: "Qwen3.7 Max",
+				id: "cline-pass/qwen3.7-max",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 3.75,
+					cacheRead: 0.25,
+					cacheWrite: 1.5625,
+				},
+				releaseDate: "2026-05-21",
+				family: "qwen",
+				description: "Flagship agent model with 1M context window",
+			},
+			"cline-pass/qwen3.7-plus": {
+				name: "Qwen3.7 Plus",
+				id: "cline-pass/qwen3.7-plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.32,
+					output: 1.28,
+					cacheRead: 0.064,
+					cacheWrite: 0.4,
+				},
+				releaseDate: "2026-06-02",
+				family: "qwen",
+				description: "Fast multimodal agent model with vision and video input",
+			},
+			"deepseek/deepseek-v4-flash": {
+				name: "DeepSeek V4 Flash",
+				id: "deepseek/deepseek-v4-flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+				description: "Fast and efficient with 1M context window ",
+			},
+			"stepfun/step-3.7-flash": {
+				name: "Step 3.7 Flash",
+				id: "stepfun/step-3.7-flash",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-29",
+				description: "Fast vision capable model built for agents ",
+			},
+			"tencent/hy3:free": {
+				name: "Hy3 (free)",
+				id: "tencent/hy3:free",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-06",
+				family: "hy3",
+				description: "Newest open model with leading agent skills ",
+			},
+			"poolside/laguna-m.1:free": {
+				name: "Laguna M.1 (free)",
+				id: "poolside/laguna-m.1:free",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+				description: "Frontier model built for agentic coding ",
+			},
+		},
+		deepseek: {
+			"deepseek-v4-flash": {
+				id: "deepseek-v4-flash",
+				name: "DeepSeek V4 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"deepseek-v4-pro": {
+				id: "deepseek-v4-pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.003625,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"deepseek-chat": {
+				id: "deepseek-chat",
+				name: "DeepSeek Chat",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "deepseek",
+			},
+			"deepseek-reasoner": {
+				id: "deepseek-reasoner",
+				name: "DeepSeek Reasoner",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "deepseek-thinking",
+			},
+		},
+		fireworks: {
+			"accounts/fireworks/routers/glm-5p2-fast": {
+				id: "accounts/fireworks/routers/glm-5p2-fast",
+				name: "GLM 5.2 Fast",
+				contextWindow: 1048575,
+				maxInputTokens: 1048575,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 2.1,
+					output: 6.6,
+					cacheRead: 0.21,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-26",
+				family: "glm",
+			},
+			"accounts/fireworks/models/glm-5p2": {
+				id: "accounts/fireworks/models/glm-5p2",
+				name: "GLM 5.2",
+				contextWindow: 1048575,
+				maxInputTokens: 1048575,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.14,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-16",
+				family: "glm",
+			},
+			"accounts/fireworks/models/kimi-k2p7-code": {
+				id: "accounts/fireworks/models/kimi-k2p7-code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.19,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"accounts/fireworks/models/minimax-m3": {
+				id: "accounts/fireworks/models/minimax-m3",
+				name: "MiniMax-M3",
+				contextWindow: 512000,
+				maxInputTokens: 512000,
+				maxTokens: 512000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "minimax",
+			},
+			"accounts/fireworks/models/qwen3p7-plus": {
+				id: "accounts/fireworks/models/qwen3p7-plus",
+				name: "Qwen 3.7 Plus",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "qwen",
+			},
+			"accounts/fireworks/routers/kimi-k2p7-code-fast": {
+				id: "accounts/fireworks/routers/kimi-k2p7-code-fast",
+				name: "Kimi K2.7 Code Fast",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.9,
+					output: 8,
+					cacheRead: 0.38,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"accounts/fireworks/models/deepseek-v4-flash": {
+				id: "accounts/fireworks/models/deepseek-v4-flash",
+				name: "DeepSeek V4 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"accounts/fireworks/models/deepseek-v4-pro": {
+				id: "accounts/fireworks/models/deepseek-v4-pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.74,
+					output: 3.48,
+					cacheRead: 0.145,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"accounts/fireworks/models/kimi-k2p6": {
+				id: "accounts/fireworks/models/kimi-k2p6",
+				name: "Kimi K2.6",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "kimi-thinking",
+			},
+			"accounts/fireworks/routers/kimi-k2p6-fast": {
+				id: "accounts/fireworks/routers/kimi-k2p6-fast",
+				name: "Kimi K2.6 Fast",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.3,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "kimi-thinking",
+			},
+			"accounts/fireworks/routers/kimi-k2p6-turbo": {
+				id: "accounts/fireworks/routers/kimi-k2p6-turbo",
+				name: "Kimi K2.6 Turbo",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.3,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "kimi-thinking",
+			},
+			"accounts/fireworks/models/minimax-m2p7": {
+				id: "accounts/fireworks/models/minimax-m2p7",
+				name: "MiniMax-M2.7",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-12",
+				family: "minimax",
+			},
+			"accounts/fireworks/models/glm-5p1": {
+				id: "accounts/fireworks/models/glm-5p1",
+				name: "GLM 5.1",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "glm",
+			},
+			"accounts/fireworks/routers/glm-5p1-fast": {
+				id: "accounts/fireworks/routers/glm-5p1-fast",
+				name: "GLM 5.1 Fast",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 2.8,
+					output: 8.8,
+					cacheRead: 0.52,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "glm",
+			},
+			"accounts/fireworks/models/gpt-oss-120b": {
+				id: "accounts/fireworks/models/gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"accounts/fireworks/models/gpt-oss-20b": {
+				id: "accounts/fireworks/models/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.07,
+					output: 0.3,
+					cacheRead: 0.035,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+		},
+		gemini: {
+			"gemini-3.5-flash": {
+				id: "gemini-3.5-flash",
+				name: "Gemini 3.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.5,
+					output: 9,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-19",
+				family: "gemini-flash",
+			},
+			"gemini-3.1-flash-lite": {
+				id: "gemini-3.1-flash-lite",
+				name: "Gemini 3.1 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-07",
+				family: "gemini-flash-lite",
+			},
+			"gemma-4-26b-a4b-it": {
+				id: "gemma-4-26b-a4b-it",
+				name: "Gemma 4 26B A4B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"gemma-4-31b-it": {
+				id: "gemma-4-31b-it",
+				name: "Gemma 4 31B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"gemini-3.1-pro-preview": {
+				id: "gemini-3.1-pro-preview",
+				name: "Gemini 3.1 Pro Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"gemini-3.1-pro-preview-customtools": {
+				id: "gemini-3.1-pro-preview-customtools",
+				name: "Gemini 3.1 Pro Preview Custom Tools",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"gemini-3-flash-preview": {
+				id: "gemini-3-flash-preview",
+				name: "Gemini 3 Flash Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-17",
+				family: "gemini-flash",
+			},
+			"gemini-flash-latest": {
+				id: "gemini-flash-latest",
+				name: "Gemini Flash Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-25",
+				family: "gemini-flash",
+			},
+			"gemini-flash-lite-latest": {
+				id: "gemini-flash-lite-latest",
+				name: "Gemini Flash-Lite Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-25",
+				family: "gemini-flash-lite",
+			},
+			"gemini-2.5-flash": {
+				id: "gemini-2.5-flash",
+				name: "Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash",
+			},
+			"gemini-2.5-flash-lite": {
+				id: "gemini-2.5-flash-lite",
+				name: "Gemini 2.5 Flash-Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash-lite",
+			},
+			"gemini-2.5-pro": {
+				id: "gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-pro",
+			},
+		},
+		groq: {
+			"openai/gpt-oss-safeguard-20b": {
+				id: "openai/gpt-oss-safeguard-20b",
+				name: "Safety GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-29",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0.0375,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"qwen/qwen3-32b": {
+				id: "qwen/qwen3-32b",
+				name: "Qwen3-32B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 40960,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.29,
+					output: 0.59,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-11",
+				family: "qwen",
+			},
+			"meta-llama/llama-4-scout-17b-16e-instruct": {
+				id: "meta-llama/llama-4-scout-17b-16e-instruct",
+				name: "Llama 4 Scout 17B 16E",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.11,
+					output: 0.34,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"llama-3.3-70b-versatile": {
+				id: "llama-3.3-70b-versatile",
+				name: "Llama 3.3 70B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.59,
+					output: 0.79,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+			"llama-3.1-8b-instant": {
+				id: "llama-3.1-8b-instant",
+				name: "Llama 3.1 8B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.05,
+					output: 0.08,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+		},
+		huggingface: {
+			"zai-org/GLM-5.2": {
+				id: "zai-org/GLM-5.2",
+				name: "GLM-5.2",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"moonshotai/Kimi-K2.7-Code": {
+				id: "moonshotai/Kimi-K2.7-Code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"MiniMaxAI/MiniMax-M3": {
+				id: "MiniMaxAI/MiniMax-M3",
+				name: "MiniMax-M3",
+				contextWindow: 524288,
+				maxInputTokens: 524288,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-01",
+				family: "minimax",
+			},
+			"stepfun-ai/Step-3.7-Flash": {
+				id: "stepfun-ai/Step-3.7-Flash",
+				name: "Step 3.7 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 256000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 1.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-29",
+			},
+			"deepseek-ai/DeepSeek-V4-Flash": {
+				id: "deepseek-ai/DeepSeek-V4-Flash",
+				name: "DeepSeek V4 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"deepseek-ai/DeepSeek-V4-Pro": {
+				id: "deepseek-ai/DeepSeek-V4-Pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 393216,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.003625,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"Qwen/Qwen3.6-27B": {
+				id: "Qwen/Qwen3.6-27B",
+				name: "Qwen3.6 27B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.47,
+					output: 3.19,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "qwen",
+			},
+			"XiaomiMiMo/MiMo-V2.5-Pro": {
+				id: "XiaomiMiMo/MiMo-V2.5-Pro",
+				name: "MiMo-V2.5-Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+			"moonshotai/Kimi-K2.6": {
+				id: "moonshotai/Kimi-K2.6",
+				name: "Kimi-K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+				family: "kimi-k2",
+			},
+			"Qwen/Qwen3.6-35B-A3B": {
+				id: "Qwen/Qwen3.6-35B-A3B",
+				name: "Qwen3.6 35B-A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.95,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "qwen",
+			},
+			"zai-org/GLM-5.1": {
+				id: "zai-org/GLM-5.1",
+				name: "GLM-5.1",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3.2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-03",
+				family: "glm",
+			},
+			"google/gemma-4-26B-A4B-it": {
+				id: "google/gemma-4-26B-A4B-it",
+				name: "Gemma 4 26B A4B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.13,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"google/gemma-4-31B-it": {
+				id: "google/gemma-4-31B-it",
+				name: "Gemma 4 31B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"MiniMaxAI/MiniMax-M2.7": {
+				id: "MiniMaxAI/MiniMax-M2.7",
+				name: "MiniMax-M2.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"Qwen/Qwen3.5-122B-A10B": {
+				id: "Qwen/Qwen3.5-122B-A10B",
+				name: "Qwen3.5 122B-A10B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.4,
+					output: 3.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.5-27B": {
+				id: "Qwen/Qwen3.5-27B",
+				name: "Qwen3.5 27B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.5-35B-A3B": {
+				id: "Qwen/Qwen3.5-35B-A3B",
+				name: "Qwen3.5 35B-A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.5-9B": {
+				id: "Qwen/Qwen3.5-9B",
+				name: "Qwen3.5 9B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.17,
+					output: 0.25,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"MiniMaxAI/MiniMax-M2.5": {
+				id: "MiniMaxAI/MiniMax-M2.5",
+				name: "MiniMax-M2.5",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax",
+			},
+			"zai-org/GLM-5": {
+				id: "zai-org/GLM-5",
+				name: "GLM-5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3.2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-11",
+				family: "glm",
+			},
+			"Qwen/Qwen3-Coder-Next": {
+				id: "Qwen/Qwen3-Coder-Next",
+				name: "Qwen3-Coder-Next",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-03",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.5-397B-A17B": {
+				id: "Qwen/Qwen3.5-397B-A17B",
+				name: "Qwen3.5-397B-A17B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 3.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-01",
+				family: "qwen",
+			},
+			"stepfun-ai/Step-3.5-Flash": {
+				id: "stepfun-ai/Step-3.5-Flash",
+				name: "Step 3.5 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 256000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-29",
+			},
+			"moonshotai/Kimi-K2.5": {
+				id: "moonshotai/Kimi-K2.5",
+				name: "Kimi-K2.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-01",
+				family: "kimi-k2",
+			},
+			"MiniMaxAI/MiniMax-M2.1": {
+				id: "MiniMaxAI/MiniMax-M2.1",
+				name: "MiniMax-M2.1",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"zai-org/GLM-4.7": {
+				id: "zai-org/GLM-4.7",
+				name: "GLM-4.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"XiaomiMiMo/MiMo-V2-Flash": {
+				id: "XiaomiMiMo/MiMo-V2-Flash",
+				name: "MiMo-V2-Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 4096,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-16",
+				family: "mimo",
+			},
+			"deepseek-ai/DeepSeek-V3.2": {
+				id: "deepseek-ai/DeepSeek-V3.2",
+				name: "DeepSeek-V3.2",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.28,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "deepseek",
+			},
+			"moonshotai/Kimi-K2-Thinking": {
+				id: "moonshotai/Kimi-K2-Thinking",
+				name: "Kimi-K2-Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-06",
+				family: "kimi-thinking",
+			},
+			"MiniMaxAI/MiniMax-M2": {
+				id: "MiniMaxAI/MiniMax-M2",
+				name: "MiniMax-M2",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-27",
+				family: "minimax",
+			},
+			"zai-org/GLM-4.6": {
+				id: "zai-org/GLM-4.6",
+				name: "GLM-4.6",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.55,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+				family: "glm",
+			},
+			"Qwen/Qwen3-Next-80B-A3B-Instruct": {
+				id: "Qwen/Qwen3-Next-80B-A3B-Instruct",
+				name: "Qwen3-Next-80B-A3B-Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 66536,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-11",
+				family: "qwen",
+			},
+			"Qwen/Qwen3-Next-80B-A3B-Thinking": {
+				id: "Qwen/Qwen3-Next-80B-A3B-Thinking",
+				name: "Qwen3-Next-80B-A3B-Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-11",
+				family: "qwen",
+			},
+			"moonshotai/Kimi-K2-Instruct-0905": {
+				id: "moonshotai/Kimi-K2-Instruct-0905",
+				name: "Kimi-K2-Instruct-0905",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-04",
+				family: "kimi-k2",
+			},
+			"zai-org/GLM-4.5V": {
+				id: "zai-org/GLM-4.5V",
+				name: "GLM-4.5V",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 1.8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-11",
+				family: "glm",
+			},
+			"zai-org/GLM-4.7-Flash": {
+				id: "zai-org/GLM-4.7-Flash",
+				name: "GLM-4.7-Flash",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-08",
+				family: "glm",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.25,
+					output: 0.69,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"zai-org/GLM-4.5": {
+				id: "zai-org/GLM-4.5",
+				name: "GLM-4.5",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm",
+			},
+			"zai-org/GLM-4.5-Air": {
+				id: "zai-org/GLM-4.5-Air",
+				name: "GLM-4.5-Air",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.13,
+					output: 0.85,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm-air",
+			},
+			"Qwen/Qwen3-235B-A22B-Thinking-2507": {
+				id: "Qwen/Qwen3-235B-A22B-Thinking-2507",
+				name: "Qwen3-235B-A22B-Thinking-2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+				family: "qwen",
+			},
+			"Qwen/Qwen3-Coder-480B-A35B-Instruct": {
+				id: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+				name: "Qwen3-Coder-480B-A35B-Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 66536,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+				family: "qwen",
+			},
+			"moonshotai/Kimi-K2-Instruct": {
+				id: "moonshotai/Kimi-K2-Instruct",
+				name: "Kimi-K2-Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-14",
+				family: "kimi-k2",
+			},
+			"deepseek-ai/DeepSeek-R1-0528": {
+				id: "deepseek-ai/DeepSeek-R1-0528",
+				name: "DeepSeek-R1-0528",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 163840,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 3,
+					output: 5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-28",
+				family: "deepseek-thinking",
+			},
+			"Qwen/Qwen3-235B-A22B": {
+				id: "Qwen/Qwen3-235B-A22B",
+				name: "Qwen3 235B-A22B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+				family: "qwen",
+			},
+			"Qwen/Qwen3-32B": {
+				id: "Qwen/Qwen3-32B",
+				name: "Qwen3 32B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.29,
+					output: 0.59,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+				family: "qwen",
+			},
+			"Qwen/Qwen3-Coder-30B-A3B-Instruct": {
+				id: "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+				name: "Qwen3-Coder 30B-A3B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.26,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+				family: "qwen",
+			},
+			"deepseek-ai/DeepSeek-R1": {
+				id: "deepseek-ai/DeepSeek-R1",
+				name: "DeepSeek-R1",
+				contextWindow: 64000,
+				maxInputTokens: 64000,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.7,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-20",
+				family: "deepseek-thinking",
+			},
+			"meta-llama/Llama-3.3-70B-Instruct": {
+				id: "meta-llama/Llama-3.3-70B-Instruct",
+				name: "Llama-3.3-70B-Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.59,
+					output: 0.79,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+		},
+		kilo: {
+			"minimax/minimax-m3": {
+				id: "minimax/minimax-m3",
+				name: "MiniMax: MiniMax M3",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 512000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-01",
+				family: "minimax",
+			},
+			"x-ai/grok-build-0.1": {
+				id: "x-ai/grok-build-0.1",
+				name: "xAI: Grok Build 0.1",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-20",
+			},
+			"google/gemini-3.5-flash": {
+				id: "google/gemini-3.5-flash",
+				name: "Google: Gemini 3.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.5,
+					output: 9,
+					cacheRead: 0.15,
+					cacheWrite: 0.08333,
+				},
+				releaseDate: "2026-05-19",
+			},
+			"anthropic/claude-opus-4.7-fast": {
+				id: "anthropic/claude-opus-4.7-fast",
+				name: "Anthropic: Claude Opus 4.7 (Fast)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 30,
+					output: 150,
+					cacheRead: 3,
+					cacheWrite: 37.5,
+				},
+				releaseDate: "2026-05-12",
+			},
+			"inclusionai/ring-2.6-1t": {
+				id: "inclusionai/ring-2.6-1t",
+				name: "inclusionAI: Ring-2.6-1T",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.075,
+					output: 0.625,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-08",
+			},
+			"google/gemini-3.1-flash-lite": {
+				id: "google/gemini-3.1-flash-lite",
+				name: "Google: Gemini 3.1 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.025,
+					cacheWrite: 0.08333,
+				},
+				releaseDate: "2026-05-07",
+			},
+			"baidu/cobuddy:free": {
+				id: "baidu/cobuddy:free",
+				name: "Baidu: CoBuddy (free)",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-06",
+			},
+			"openai/gpt-chat-latest": {
+				id: "openai/gpt-chat-latest",
+				name: "OpenAI: GPT Chat Latest",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-05",
+			},
+			"x-ai/grok-4.3": {
+				id: "x-ai/grok-4.3",
+				name: "xAI: Grok 4.3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 4096,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-01",
+			},
+			"ibm-granite/granite-4.1-8b": {
+				id: "ibm-granite/granite-4.1-8b",
+				name: "IBM: Granite 4.1 8B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.05,
+					output: 0.1,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-30",
+			},
+			"mistralai/mistral-medium-3-5": {
+				id: "mistralai/mistral-medium-3-5",
+				name: "Mistral: Mistral Medium 3.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1.5,
+					output: 7.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-30",
+			},
+			"nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free": {
+				id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+				name: "NVIDIA: Nemotron 3 Nano Omni (free)",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+				family: "nemotron",
+			},
+			"openrouter/owl-alpha": {
+				id: "openrouter/owl-alpha",
+				name: "Owl Alpha",
+				contextWindow: 1048756,
+				maxInputTokens: 1048756,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"poolside/laguna-m.1:free": {
+				id: "poolside/laguna-m.1:free",
+				name: "Poolside: Laguna M.1 (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"poolside/laguna-xs.2:free": {
+				id: "poolside/laguna-xs.2:free",
+				name: "Poolside: Laguna XS.2 (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"~anthropic/claude-haiku-latest": {
+				id: "~anthropic/claude-haiku-latest",
+				name: "Anthropic: Claude Haiku Latest",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"~anthropic/claude-sonnet-latest": {
+				id: "~anthropic/claude-sonnet-latest",
+				name: "Anthropic: Claude Sonnet Latest",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"~google/gemini-flash-latest": {
+				id: "~google/gemini-flash-latest",
+				name: "Google: Gemini Flash Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0.08333333333333334,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"~google/gemini-pro-latest": {
+				id: "~google/gemini-pro-latest",
+				name: "Google: Gemini Pro Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"~moonshotai/kimi-latest": {
+				id: "~moonshotai/kimi-latest",
+				name: "MoonshotAI: Kimi Latest",
+				contextWindow: 262142,
+				maxInputTokens: 262142,
+				maxTokens: 262142,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.74,
+					output: 3.49,
+					cacheRead: 0.14,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"~openai/gpt-latest": {
+				id: "~openai/gpt-latest",
+				name: "OpenAI: GPT Latest",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"~openai/gpt-mini-latest": {
+				id: "~openai/gpt-mini-latest",
+				name: "OpenAI: GPT Mini Latest",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"qwen/qwen3.5-plus-20260420": {
+				id: "qwen/qwen3.5-plus-20260420",
+				name: "Qwen: Qwen3.5 Plus 2026-04-20",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"qwen/qwen3.6-27b": {
+				id: "qwen/qwen3.6-27b",
+				name: "Qwen: Qwen3.6 27B",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.325,
+					output: 3.25,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"qwen/qwen3.6-flash": {
+				id: "qwen/qwen3.6-flash",
+				name: "Qwen: Qwen3.6 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0.3125,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"qwen/qwen3.6-max-preview": {
+				id: "qwen/qwen3.6-max-preview",
+				name: "Qwen: Qwen3.6 Max Preview",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.04,
+					output: 6.24,
+					cacheRead: 0,
+					cacheWrite: 1.3,
+				},
+				releaseDate: "2026-04-27",
+			},
+			"deepseek/deepseek-v4-flash": {
+				id: "deepseek/deepseek-v4-flash",
+				name: "DeepSeek: DeepSeek V4 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 384000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+			},
+			"deepseek/deepseek-v4-pro": {
+				id: "deepseek/deepseek-v4-pro",
+				name: "DeepSeek: DeepSeek V4 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 384000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.003625,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+			},
+			"openai/gpt-5.5": {
+				id: "openai/gpt-5.5",
+				name: "OpenAI: GPT-5.5",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+			},
+			"openai/gpt-5.5-pro": {
+				id: "openai/gpt-5.5-pro",
+				name: "OpenAI: GPT-5.5 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+			},
+			"inclusionai/ling-2.6-1t": {
+				id: "inclusionai/ling-2.6-1t",
+				name: "inclusionAI: Ling-2.6-1T",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+			},
+			"tencent/hy3-preview": {
+				id: "tencent/hy3-preview",
+				name: "Tencent: Hy3 Preview",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.066,
+					output: 0.26,
+					cacheRead: 0.029,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+			},
+			"xiaomi/mimo-v2.5": {
+				id: "xiaomi/mimo-v2.5",
+				name: "Xiaomi: MiMo-V2.5",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+			"xiaomi/mimo-v2.5-pro": {
+				id: "xiaomi/mimo-v2.5-pro",
+				name: "Xiaomi: MiMo V2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+			"inclusionai/ling-2.6-flash": {
+				id: "inclusionai/ling-2.6-flash",
+				name: "inclusionAI: Ling-2.6 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.08,
+					output: 0.24,
+					cacheRead: 0.016,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+			},
+			"moonshotai/kimi-k2.6": {
+				id: "moonshotai/kimi-k2.6",
+				name: "MoonshotAI: Kimi K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 3.5,
+					cacheRead: 0.375,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+			},
+			"~anthropic/claude-opus-latest": {
+				id: "~anthropic/claude-opus-latest",
+				name: "Anthropic: Claude Opus Latest",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+			},
+			"anthropic/claude-opus-4.7": {
+				id: "anthropic/claude-opus-4.7",
+				name: "Anthropic: Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+			},
+			"stealth/claude-opus-4.7": {
+				id: "stealth/claude-opus-4.7",
+				name: "Stealth: Claude Opus 4.7 (20% off)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 4,
+					output: 20,
+					cacheRead: 0.4,
+					cacheWrite: 5,
+				},
+				releaseDate: "2026-04-16",
+			},
+			"anthropic/claude-opus-4.6-fast": {
+				id: "anthropic/claude-opus-4.6-fast",
+				name: "Anthropic: Claude Opus 4.6 (Fast)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 30,
+					output: 150,
+					cacheRead: 3,
+					cacheWrite: 37.5,
+				},
+				releaseDate: "2026-04-07",
+			},
+			"google/gemma-4-26b-a4b-it": {
+				id: "google/gemma-4-26b-a4b-it",
+				name: "Google: Gemma 4 26B A4B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.12,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-03",
+			},
+			"google/gemma-4-31b-it": {
+				id: "google/gemma-4-31b-it",
+				name: "Google: Gemma 4 31B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.14,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+			},
+			"arcee-ai/trinity-large-thinking": {
+				id: "arcee-ai/trinity-large-thinking",
+				name: "Arcee AI: Trinity Large Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 0.85,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+			},
+			"z-ai/glm-5v-turbo": {
+				id: "z-ai/glm-5v-turbo",
+				name: "Z.ai: GLM 5V Turbo",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+			},
+			"x-ai/grok-4.20": {
+				id: "x-ai/grok-4.20",
+				name: "xAI: Grok 4.20",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-31",
+			},
+			"kwaipilot/kat-coder-pro-v2": {
+				id: "kwaipilot/kat-coder-pro-v2",
+				name: "Kwaipilot: KAT-Coder-Pro V2",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 80000,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+			},
+			"z-ai/glm-5.1": {
+				id: "z-ai/glm-5.1",
+				name: "Z.ai: GLM 5.1",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 1.26,
+					output: 3.96,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+			},
+			"rekaai/reka-edge": {
+				id: "rekaai/reka-edge",
+				name: "Reka Edge",
+				contextWindow: 16384,
+				maxInputTokens: 16384,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-20",
+			},
+			"minimax/minimax-m2.7": {
+				id: "minimax/minimax-m2.7",
+				name: "MiniMax: MiniMax M2.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax-m2.7",
+			},
+			"xiaomi/mimo-v2-omni": {
+				id: "xiaomi/mimo-v2-omni",
+				name: "Xiaomi: MiMo-V2-Omni",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "mimo",
+			},
+			"xiaomi/mimo-v2-pro": {
+				id: "xiaomi/mimo-v2-pro",
+				name: "Xiaomi: MiMo-V2-Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "mimo",
+			},
+			"openai/gpt-5.4-mini": {
+				id: "openai/gpt-5.4-mini",
+				name: "OpenAI: GPT-5.4 Mini",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+			},
+			"openai/gpt-5.4-nano": {
+				id: "openai/gpt-5.4-nano",
+				name: "OpenAI: GPT-5.4 Nano",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 1.25,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+			},
+			"mistralai/mistral-small-2603": {
+				id: "mistralai/mistral-small-2603",
+				name: "Mistral: Mistral Small 4",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-16",
+			},
+			"kilo-auto/balanced": {
+				id: "kilo-auto/balanced",
+				name: "Kilo Auto Balanced",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+			},
+			"kilo-auto/free": {
+				id: "kilo-auto/free",
+				name: "Kilo Auto Free",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+			},
+			"kilo-auto/frontier": {
+				id: "kilo-auto/frontier",
+				name: "Kilo Auto Frontier",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+			},
+			"kilo-auto/small": {
+				id: "kilo-auto/small",
+				name: "Kilo Auto Small",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+			},
+			"openrouter/auto": {
+				id: "openrouter/auto",
+				name: "Auto Router",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 32768,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+			},
+			"z-ai/glm-5-turbo": {
+				id: "z-ai/glm-5-turbo",
+				name: "Z.ai: GLM 5 Turbo",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+			},
+			"nvidia/nemotron-3-super-120b-a12b:free": {
+				id: "nvidia/nemotron-3-super-120b-a12b:free",
+				name: "NVIDIA: Nemotron 3 Super (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-12",
+				family: "nemotron",
+			},
+			"nvidia/nemotron-3-super-120b-a12b": {
+				id: "nvidia/nemotron-3-super-120b-a12b",
+				name: "NVIDIA: Nemotron 3 Super",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.1,
+					output: 0.5,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"bytedance-seed/seed-2.0-lite": {
+				id: "bytedance-seed/seed-2.0-lite",
+				name: "ByteDance Seed: Seed-2.0-Lite",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-10",
+			},
+			"qwen/qwen3.5-9b": {
+				id: "qwen/qwen3.5-9b",
+				name: "Qwen: Qwen3.5-9B",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.05,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-10",
+			},
+			"openai/gpt-5.4": {
+				id: "openai/gpt-5.4",
+				name: "OpenAI: GPT-5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-06",
+			},
+			"openai/gpt-5.4-pro": {
+				id: "openai/gpt-5.4-pro",
+				name: "OpenAI: GPT-5.4 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-06",
+			},
+			"openai/gpt-5.3-chat": {
+				id: "openai/gpt-5.3-chat",
+				name: "OpenAI: GPT-5.3 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["images", "files", "tools"],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-04",
+			},
+			"google/gemini-3.1-flash-lite-preview": {
+				id: "google/gemini-3.1-flash-lite-preview",
+				name: "Google: Gemini 3.1 Flash Lite Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-03",
+			},
+			"bytedance-seed/seed-2.0-mini": {
+				id: "bytedance-seed/seed-2.0-mini",
+				name: "ByteDance Seed: Seed-2.0-Mini",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-27",
+			},
+			"google/gemini-3.1-pro-preview-customtools": {
+				id: "google/gemini-3.1-pro-preview-customtools",
+				name: "Google: Gemini 3.1 Pro Preview Custom Tools",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-26",
+			},
+			"qwen/qwen3.5-122b-a10b": {
+				id: "qwen/qwen3.5-122b-a10b",
+				name: "Qwen: Qwen3.5-122B-A10B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.26,
+					output: 2.08,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-26",
+			},
+			"qwen/qwen3.5-27b": {
+				id: "qwen/qwen3.5-27b",
+				name: "Qwen: Qwen3.5-27B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.195,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-26",
+			},
+			"qwen/qwen3.5-35b-a3b": {
+				id: "qwen/qwen3.5-35b-a3b",
+				name: "Qwen: Qwen3.5-35B-A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1625,
+					output: 1.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-26",
+			},
+			"qwen/qwen3.5-flash-02-23": {
+				id: "qwen/qwen3.5-flash-02-23",
+				name: "Qwen: Qwen3.5-Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-26",
+			},
+			"openai/gpt-5.3-codex": {
+				id: "openai/gpt-5.3-codex",
+				name: "OpenAI: GPT-5.3-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-25",
+			},
+			"inception/mercury-2": {
+				id: "inception/mercury-2",
+				name: "Inception: Mercury 2",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 50000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-24",
+			},
+			"google/gemini-3.1-pro-preview": {
+				id: "google/gemini-3.1-pro-preview",
+				name: "Google: Gemini 3.1 Pro Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+			},
+			"anthropic/claude-sonnet-4.6": {
+				id: "anthropic/claude-sonnet-4.6",
+				name: "Anthropic: Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-17",
+			},
+			"stealth/claude-sonnet-4.6": {
+				id: "stealth/claude-sonnet-4.6",
+				name: "Stealth: Claude Sonnet 4.6 (20% off)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.4,
+					output: 12,
+					cacheRead: 0.24,
+					cacheWrite: 3,
+				},
+				releaseDate: "2026-02-17",
+			},
+			"qwen/qwen3.5-397b-a17b": {
+				id: "qwen/qwen3.5-397b-a17b",
+				name: "Qwen: Qwen3.5 397B A17B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.39,
+					output: 2.34,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-15",
+			},
+			"qwen/qwen3.5-plus-02-15": {
+				id: "qwen/qwen3.5-plus-02-15",
+				name: "Qwen: Qwen3.5 Plus 2026-02-15",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.26,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-15",
+			},
+			"minimax/minimax-m2.5": {
+				id: "minimax/minimax-m2.5",
+				name: "MiniMax: MiniMax M2.5",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 1.2,
+					cacheRead: 0.029,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+			},
+			"z-ai/glm-5": {
+				id: "z-ai/glm-5",
+				name: "Z.ai: GLM 5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.72,
+					output: 2.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+			},
+			"anthropic/claude-opus-4.6": {
+				id: "anthropic/claude-opus-4.6",
+				name: "Anthropic: Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+			},
+			"stealth/claude-opus-4.6": {
+				id: "stealth/claude-opus-4.6",
+				name: "Stealth: Claude Opus 4.6 (20% off)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 4,
+					output: 20,
+					cacheRead: 0.4,
+					cacheWrite: 5,
+				},
+				releaseDate: "2026-02-05",
+			},
+			"qwen/qwen3-coder-next": {
+				id: "qwen/qwen3-coder-next",
+				name: "Qwen: Qwen3 Coder Next",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.12,
+					output: 0.75,
+					cacheRead: 0.035,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-02",
+			},
+			"openrouter/free": {
+				id: "openrouter/free",
+				name: "Free Models Router",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-01",
+			},
+			"stepfun/step-3.5-flash": {
+				id: "stepfun/step-3.5-flash",
+				name: "StepFun: Step 3.5 Flash",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-29",
+			},
+			"moonshotai/kimi-k2.5": {
+				id: "moonshotai/kimi-k2.5",
+				name: "MoonshotAI: Kimi K2.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65535,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.45,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-27",
+			},
+			"upstage/solar-pro-3": {
+				id: "upstage/solar-pro-3",
+				name: "Upstage: Solar Pro 3",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-27",
+			},
+			"qwen/qwen3-max-thinking": {
+				id: "qwen/qwen3-max-thinking",
+				name: "Qwen: Qwen3 Max Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.78,
+					output: 3.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-23",
+			},
+			"z-ai/glm-4.7-flash": {
+				id: "z-ai/glm-4.7-flash",
+				name: "Z.ai: GLM 4.7 Flash",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 40551,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+			},
+			"openai/gpt-5.2-codex": {
+				id: "openai/gpt-5.2-codex",
+				name: "OpenAI: GPT-5.2-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-14",
+			},
+			"mistralai/mistral-small-24b-instruct-2501": {
+				id: "mistralai/mistral-small-24b-instruct-2501",
+				name: "Mistral: Mistral Small 3",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.05,
+					output: 0.08,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-29",
+			},
+			"bytedance-seed/seed-1.6-flash": {
+				id: "bytedance-seed/seed-1.6-flash",
+				name: "ByteDance Seed: Seed 1.6 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+			},
+			"minimax/minimax-m2.1": {
+				id: "minimax/minimax-m2.1",
+				name: "MiniMax: MiniMax M2.1",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 39322,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.27,
+					output: 0.95,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+			},
+			"z-ai/glm-4.7": {
+				id: "z-ai/glm-4.7",
+				name: "Z.ai: GLM 4.7",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 65535,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.38,
+					output: 1.98,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+			},
+			"google/gemini-3-flash-preview": {
+				id: "google/gemini-3-flash-preview",
+				name: "Google: Gemini 3 Flash Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-12-17",
+			},
+			"mistralai/ministral-14b-2512": {
+				id: "mistralai/ministral-14b-2512",
+				name: "Mistral: Ministral 3 14B 2512",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 52429,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-16",
+			},
+			"xiaomi/mimo-v2-flash": {
+				id: "xiaomi/mimo-v2-flash",
+				name: "Xiaomi: MiMo-V2-Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.09,
+					output: 0.29,
+					cacheRead: 0.045,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-16",
+				family: "mimo",
+			},
+			"openai/gpt-5.2": {
+				id: "openai/gpt-5.2",
+				name: "OpenAI: GPT-5.2",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+			},
+			"openai/gpt-5.2-chat": {
+				id: "openai/gpt-5.2-chat",
+				name: "OpenAI: GPT-5.2 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["images", "files", "tools", "prompt-cache"],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+			},
+			"openai/gpt-5.2-pro": {
+				id: "openai/gpt-5.2-pro",
+				name: "OpenAI: GPT-5.2 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 21,
+					output: 168,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+			},
+			"relace/relace-search": {
+				id: "relace/relace-search",
+				name: "Relace: Relace Search",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 128000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-09",
+			},
+			"essentialai/rnj-1-instruct": {
+				id: "essentialai/rnj-1-instruct",
+				name: "EssentialAI: Rnj 1 Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 6554,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-05",
+			},
+			"mistralai/ministral-3b-2512": {
+				id: "mistralai/ministral-3b-2512",
+				name: "Mistral: Ministral 3 3B 2512",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+			},
+			"mistralai/ministral-8b-2512": {
+				id: "mistralai/ministral-8b-2512",
+				name: "Mistral: Ministral 3 8B 2512",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+			},
+			"arcee-ai/trinity-mini": {
+				id: "arcee-ai/trinity-mini",
+				name: "Arcee AI: Trinity Mini",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.045,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12",
+			},
+			"deepseek/deepseek-v3.2": {
+				id: "deepseek/deepseek-v3.2",
+				name: "DeepSeek: DeepSeek V3.2",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.26,
+					output: 0.38,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+			},
+			"prime-intellect/intellect-3": {
+				id: "prime-intellect/intellect-3",
+				name: "Prime Intellect: INTELLECT-3",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 1.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-26",
+			},
+			"anthropic/claude-opus-4.5": {
+				id: "anthropic/claude-opus-4.5",
+				name: "Anthropic: Claude Opus 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+			},
+			"openai/gpt-5.1": {
+				id: "openai/gpt-5.1",
+				name: "OpenAI: GPT-5.1",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+			},
+			"openai/gpt-5.1-chat": {
+				id: "openai/gpt-5.1-chat",
+				name: "OpenAI: GPT-5.1 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["images", "files", "tools", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+			},
+			"openai/gpt-5.1-codex": {
+				id: "openai/gpt-5.1-codex",
+				name: "OpenAI: GPT-5.1-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+			},
+			"openai/gpt-5.1-codex-max": {
+				id: "openai/gpt-5.1-codex-max",
+				name: "OpenAI: GPT-5.1-Codex-Max",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+			},
+			"openai/gpt-5.1-codex-mini": {
+				id: "openai/gpt-5.1-codex-mini",
+				name: "OpenAI: GPT-5.1-Codex-Mini",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 100000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+			},
+			"moonshotai/kimi-k2-thinking": {
+				id: "moonshotai/kimi-k2-thinking",
+				name: "MoonshotAI: Kimi K2 Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65535,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.47,
+					output: 2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-06",
+			},
+			"amazon/nova-premier-v1": {
+				id: "amazon/nova-premier-v1",
+				name: "Amazon: Nova Premier 1.0",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 12.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-01",
+			},
+			"openai/gpt-oss-safeguard-20b": {
+				id: "openai/gpt-oss-safeguard-20b",
+				name: "OpenAI: gpt-oss-safeguard-20b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0.037,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-29",
+			},
+			"minimax/minimax-m2": {
+				id: "minimax/minimax-m2",
+				name: "MiniMax: MiniMax M2",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.255,
+					output: 1,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-23",
+			},
+			"qwen/qwen3-vl-32b-instruct": {
+				id: "qwen/qwen3-vl-32b-instruct",
+				name: "Qwen: Qwen3 VL 32B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.104,
+					output: 0.416,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-21",
+			},
+			"openai/gpt-5-image-mini": {
+				id: "openai/gpt-5-image-mini",
+				name: "OpenAI: GPT-5 Image Mini",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-16",
+			},
+			"anthropic/claude-haiku-4.5": {
+				id: "anthropic/claude-haiku-4.5",
+				name: "Anthropic: Claude Haiku 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+			},
+			"qwen/qwen3-vl-8b-instruct": {
+				id: "qwen/qwen3-vl-8b-instruct",
+				name: "Qwen: Qwen3 VL 8B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.08,
+					output: 0.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-15",
+			},
+			"qwen/qwen3-vl-8b-thinking": {
+				id: "qwen/qwen3-vl-8b-thinking",
+				name: "Qwen: Qwen3 VL 8B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.117,
+					output: 1.365,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-15",
+			},
+			"openai/gpt-5-image": {
+				id: "openai/gpt-5-image",
+				name: "OpenAI: GPT-5 Image",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 10,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-14",
+			},
+			"qwen/qwen3-vl-30b-a3b-thinking": {
+				id: "qwen/qwen3-vl-30b-a3b-thinking",
+				name: "Qwen: Qwen3 VL 30B A3B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.13,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-11",
+			},
+			"openai/gpt-5-pro": {
+				id: "openai/gpt-5-pro",
+				name: "OpenAI: GPT-5 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 15,
+					output: 120,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+			},
+			"qwen/qwen3-vl-30b-a3b-instruct": {
+				id: "qwen/qwen3-vl-30b-a3b-instruct",
+				name: "Qwen: Qwen3 VL 30B A3B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.13,
+					output: 0.52,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-05",
+			},
+			"z-ai/glm-4.6": {
+				id: "z-ai/glm-4.6",
+				name: "Z.ai: GLM 4.6",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 204800,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.39,
+					output: 1.9,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+			},
+			"z-ai/glm-4.6v": {
+				id: "z-ai/glm-4.6v",
+				name: "Z.ai: GLM 4.6V",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+			},
+			"anthropic/claude-sonnet-4.5": {
+				id: "anthropic/claude-sonnet-4.5",
+				name: "Anthropic: Claude Sonnet 4.5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+			},
+			"google/gemini-2.5-flash-lite-preview-09-2025": {
+				id: "google/gemini-2.5-flash-lite-preview-09-2025",
+				name: "Google: Gemini 2.5 Flash Lite Preview 09-2025",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-09-25",
+			},
+			"qwen/qwen3-vl-235b-a22b-thinking": {
+				id: "qwen/qwen3-vl-235b-a22b-thinking",
+				name: "Qwen: Qwen3 VL 235B A22B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.26,
+					output: 2.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-24",
+			},
+			"qwen/qwen3-vl-235b-a22b-instruct": {
+				id: "qwen/qwen3-vl-235b-a22b-instruct",
+				name: "Qwen: Qwen3 VL 235B A22B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 52429,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 0.88,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+			},
+			"deepseek/deepseek-v3.1-terminus": {
+				id: "deepseek/deepseek-v3.1-terminus",
+				name: "DeepSeek: DeepSeek V3.1 Terminus",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.21,
+					output: 0.79,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-22",
+			},
+			"openai/gpt-5-codex": {
+				id: "openai/gpt-5-codex",
+				name: "OpenAI: GPT-5 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-15",
+			},
+			"mistralai/devstral-2512": {
+				id: "mistralai/devstral-2512",
+				name: "Mistral: Devstral 2 2512",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-12",
+			},
+			"qwen/qwen3-next-80b-a3b-instruct": {
+				id: "qwen/qwen3-next-80b-a3b-instruct",
+				name: "Qwen: Qwen3 Next 80B A3B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 52429,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.09,
+					output: 1.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-11",
+			},
+			"qwen/qwen3-next-80b-a3b-thinking": {
+				id: "qwen/qwen3-next-80b-a3b-thinking",
+				name: "Qwen: Qwen3 Next 80B A3B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.0975,
+					output: 0.78,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-11",
+			},
+			"qwen/qwen-plus-2025-07-28": {
+				id: "qwen/qwen-plus-2025-07-28",
+				name: "Qwen: Qwen Plus 0728",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.26,
+					output: 0.78,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-09",
+			},
+			"qwen/qwen-plus-2025-07-28:thinking": {
+				id: "qwen/qwen-plus-2025-07-28:thinking",
+				name: "Qwen: Qwen Plus 0728 (thinking)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.26,
+					output: 0.78,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-09",
+			},
+			"moonshotai/kimi-k2-0905": {
+				id: "moonshotai/kimi-k2-0905",
+				name: "MoonshotAI: Kimi K2 0905",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-05",
+			},
+			"qwen/qwen3-max": {
+				id: "qwen/qwen3-max",
+				name: "Qwen: Qwen3 Max",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.2,
+					output: 6,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-05",
+			},
+			"bytedance-seed/seed-1.6": {
+				id: "bytedance-seed/seed-1.6",
+				name: "ByteDance Seed: Seed 1.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09",
+			},
+			"qwen/qwen3.6-plus": {
+				id: "qwen/qwen3.6-plus",
+				name: "Qwen: Qwen3.6 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.325,
+					output: 1.95,
+					cacheRead: 0.0325,
+					cacheWrite: 0.40625,
+				},
+				releaseDate: "2025-08-26",
+			},
+			"qwen/qwen3.7-max": {
+				id: "qwen/qwen3.7-max",
+				name: "Qwen: Qwen3.7 Max",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.625,
+					output: 4.875,
+					cacheRead: 0.1625,
+					cacheWrite: 2.03125,
+				},
+				releaseDate: "2025-08-26",
+			},
+			"deepseek/deepseek-chat-v3.1": {
+				id: "deepseek/deepseek-chat-v3.1",
+				name: "DeepSeek: DeepSeek V3.1",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 7168,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.75,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-21",
+			},
+			"nvidia/nemotron-nano-9b-v2": {
+				id: "nvidia/nemotron-nano-9b-v2",
+				name: "NVIDIA: Nemotron Nano 9B V2",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.04,
+					output: 0.16,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-18",
+				family: "nemotron",
+			},
+			"openai/gpt-4o-audio-preview": {
+				id: "openai/gpt-4o-audio-preview",
+				name: "OpenAI: GPT-4o Audio",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-15",
+			},
+			"mistralai/mistral-medium-3.1": {
+				id: "mistralai/mistral-medium-3.1",
+				name: "Mistral: Mistral Medium 3.1",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-12",
+			},
+			"z-ai/glm-4.5v": {
+				id: "z-ai/glm-4.5v",
+				name: "Z.ai: GLM 4.5V",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 1.8,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-11",
+			},
+			"ai21/jamba-large-1.7": {
+				id: "ai21/jamba-large-1.7",
+				name: "AI21: Jamba Large 1.7",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-09",
+			},
+			"openai/gpt-5": {
+				id: "openai/gpt-5",
+				name: "OpenAI: GPT-5",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+			},
+			"openai/gpt-5-mini": {
+				id: "openai/gpt-5-mini",
+				name: "OpenAI: GPT-5 Mini",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+			},
+			"openai/gpt-5-nano": {
+				id: "openai/gpt-5-nano",
+				name: "OpenAI: GPT-5 Nano",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.005,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+			},
+			"anthropic/claude-opus-4.1": {
+				id: "anthropic/claude-opus-4.1",
+				name: "Anthropic: Claude Opus 4.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-08-05",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "OpenAI: gpt-oss-120b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.039,
+					output: 0.19,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "OpenAI: gpt-oss-20b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.03,
+					output: 0.14,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+			},
+			"mistralai/codestral-2508": {
+				id: "mistralai/codestral-2508",
+				name: "Mistral: Codestral 2508",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 51200,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-01",
+			},
+			"qwen/qwen3-coder-30b-a3b-instruct": {
+				id: "qwen/qwen3-coder-30b-a3b-instruct",
+				name: "Qwen: Qwen3 Coder 30B A3B Instruct",
+				contextWindow: 160000,
+				maxInputTokens: 160000,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.27,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-31",
+			},
+			"qwen/qwen3-30b-a3b-instruct-2507": {
+				id: "qwen/qwen3-30b-a3b-instruct-2507",
+				name: "Qwen: Qwen3 30B A3B Instruct 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.09,
+					output: 0.3,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-29",
+			},
+			"qwen/qwen3-30b-a3b-thinking-2507": {
+				id: "qwen/qwen3-30b-a3b-thinking-2507",
+				name: "Qwen: Qwen3 30B A3B Thinking 2507",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 6554,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.051,
+					output: 0.34,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-29",
+			},
+			"z-ai/glm-4.5": {
+				id: "z-ai/glm-4.5",
+				name: "Z.ai: GLM 4.5",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+			},
+			"z-ai/glm-4.5-air": {
+				id: "z-ai/glm-4.5-air",
+				name: "Z.ai: GLM 4.5 Air",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.13,
+					output: 0.85,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+			},
+			"qwen/qwen3-235b-a22b-thinking-2507": {
+				id: "qwen/qwen3-235b-a22b-thinking-2507",
+				name: "Qwen: Qwen3 235B A22B Thinking 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.11,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+			},
+			"z-ai/glm-4-32b": {
+				id: "z-ai/glm-4-32b",
+				name: "Z.ai: GLM 4 32B ",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+			},
+			"qwen/qwen3-coder": {
+				id: "qwen/qwen3-coder",
+				name: "Qwen: Qwen3 Coder 480B A35B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 52429,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.22,
+					output: 1,
+					cacheRead: 0.022,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+			},
+			"qwen/qwen3-coder-flash": {
+				id: "qwen/qwen3-coder-flash",
+				name: "Qwen: Qwen3 Coder Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.195,
+					output: 0.975,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+			},
+			"google/gemini-2.5-flash": {
+				id: "google/gemini-2.5-flash",
+				name: "Google: Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.03,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-07-17",
+			},
+			"moonshotai/kimi-k2": {
+				id: "moonshotai/kimi-k2",
+				name: "MoonshotAI: Kimi K2 0711",
+				contextWindow: 131000,
+				maxInputTokens: 131000,
+				maxTokens: 26215,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.55,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-11",
+			},
+			"mistralai/devstral-medium": {
+				id: "mistralai/devstral-medium",
+				name: "Mistral: Devstral Medium",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-10",
+			},
+			"mistralai/voxtral-small-24b-2507": {
+				id: "mistralai/voxtral-small-24b-2507",
+				name: "Mistral: Voxtral Small 24B 2507",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 6400,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-01",
+			},
+			"qwen/qwen3-coder-plus": {
+				id: "qwen/qwen3-coder-plus",
+				name: "Qwen: Qwen3 Coder Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.65,
+					output: 3.25,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-01",
+			},
+			"baidu/ernie-4.5-21b-a3b": {
+				id: "baidu/ernie-4.5-21b-a3b",
+				name: "Baidu: ERNIE 4.5 21B A3B",
+				contextWindow: 120000,
+				maxInputTokens: 120000,
+				maxTokens: 8000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.28,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-30",
+			},
+			"baidu/ernie-4.5-vl-28b-a3b": {
+				id: "baidu/ernie-4.5-vl-28b-a3b",
+				name: "Baidu: ERNIE 4.5 VL 28B A3B",
+				contextWindow: 30000,
+				maxInputTokens: 30000,
+				maxTokens: 8000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.14,
+					output: 0.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-30",
+			},
+			"mistralai/mistral-small-3.2-24b-instruct": {
+				id: "mistralai/mistral-small-3.2-24b-instruct",
+				name: "Mistral: Mistral Small 3.2 24B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.18,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-20",
+			},
+			"google/gemini-2.5-flash-lite": {
+				id: "google/gemini-2.5-flash-lite",
+				name: "Google: Gemini 2.5 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-06-17",
+			},
+			"minimax/minimax-m1": {
+				id: "minimax/minimax-m1",
+				name: "MiniMax: MiniMax M1",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 40000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+			},
+			"google/gemini-2.5-pro-preview": {
+				id: "google/gemini-2.5-pro-preview",
+				name: "Google: Gemini 2.5 Pro Preview 06-05",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-06-05",
+			},
+			"deepseek/deepseek-r1-0528": {
+				id: "deepseek/deepseek-r1-0528",
+				name: "DeepSeek: R1 0528",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.45,
+					output: 2.15,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-28",
+			},
+			"anthropic/claude-opus-4": {
+				id: "anthropic/claude-opus-4",
+				name: "Anthropic: Claude Opus 4",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-05-22",
+			},
+			"anthropic/claude-sonnet-4": {
+				id: "anthropic/claude-sonnet-4",
+				name: "Anthropic: Claude Sonnet 4",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-05-22",
+			},
+			"mistralai/devstral-small": {
+				id: "mistralai/devstral-small",
+				name: "Mistral: Devstral Small 1.1",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-07",
+			},
+			"mistralai/mistral-medium-3": {
+				id: "mistralai/mistral-medium-3",
+				name: "Mistral: Mistral Medium 3",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-07",
+			},
+			"arcee-ai/virtuoso-large": {
+				id: "arcee-ai/virtuoso-large",
+				name: "Arcee AI: Virtuoso Large",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 64000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.75,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-06",
+			},
+			"google/gemini-2.5-pro-preview-05-06": {
+				id: "google/gemini-2.5-pro-preview-05-06",
+				name: "Google: Gemini 2.5 Pro Preview 05-06",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-05-06",
+			},
+			"openai/o4-mini-high": {
+				id: "openai/o4-mini-high",
+				name: "OpenAI: o4 Mini High",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-17",
+			},
+			"openai/o3": {
+				id: "openai/o3",
+				name: "OpenAI: o3",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+			},
+			"openai/o3-pro": {
+				id: "openai/o3-pro",
+				name: "OpenAI: o3 Pro",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "files", "tools", "reasoning"],
+				pricing: {
+					input: 20,
+					output: 80,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+			},
+			"openai/o4-mini": {
+				id: "openai/o4-mini",
+				name: "OpenAI: o4 Mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.275,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+			},
+			"openai/gpt-4.1": {
+				id: "openai/gpt-4.1",
+				name: "OpenAI: GPT-4.1",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+			},
+			"openai/gpt-4.1-mini": {
+				id: "openai/gpt-4.1-mini",
+				name: "OpenAI: GPT-4.1 Mini",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+			},
+			"openai/gpt-4.1-nano": {
+				id: "openai/gpt-4.1-nano",
+				name: "OpenAI: GPT-4.1 Nano",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+			},
+			"meta-llama/llama-4-maverick": {
+				id: "meta-llama/llama-4-maverick",
+				name: "Meta: Llama 4 Maverick",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+			},
+			"meta-llama/llama-4-scout": {
+				id: "meta-llama/llama-4-scout",
+				name: "Meta: Llama 4 Scout",
+				contextWindow: 327680,
+				maxInputTokens: 327680,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.08,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+			},
+			"qwen/qwen3-14b": {
+				id: "qwen/qwen3-14b",
+				name: "Qwen: Qwen3 14B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 40960,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+			},
+			"qwen/qwen3-235b-a22b-2507": {
+				id: "qwen/qwen3-235b-a22b-2507",
+				name: "Qwen: Qwen3 235B A22B Instruct 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 52429,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.071,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+			},
+			"qwen/qwen3-30b-a3b": {
+				id: "qwen/qwen3-30b-a3b",
+				name: "Qwen: Qwen3 30B A3B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 40960,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.08,
+					output: 0.28,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+			},
+			"qwen/qwen3-8b": {
+				id: "qwen/qwen3-8b",
+				name: "Qwen: Qwen3 8B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+			},
+			"deepseek/deepseek-chat-v3-0324": {
+				id: "deepseek/deepseek-chat-v3-0324",
+				name: "DeepSeek: DeepSeek V3 0324",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 0.77,
+					cacheRead: 0.095,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-24",
+			},
+			"google/gemini-2.5-pro": {
+				id: "google/gemini-2.5-pro",
+				name: "Google: Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-03-20",
+			},
+			"nvidia/llama-3.3-nemotron-super-49b-v1.5": {
+				id: "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+				name: "NVIDIA: Llama 3.3 Nemotron Super 49B V1.5",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-16",
+				family: "nemotron",
+			},
+			"google/gemma-3-27b-it": {
+				id: "google/gemma-3-27b-it",
+				name: "Google: Gemma 3 27B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.03,
+					output: 0.11,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-12",
+			},
+			"mistralai/mistral-saba": {
+				id: "mistralai/mistral-saba",
+				name: "Mistral: Saba",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-02-17",
+			},
+			"openai/o3-mini-high": {
+				id: "openai/o3-mini-high",
+				name: "OpenAI: o3 Mini High",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["files", "tools", "prompt-cache"],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-31",
+			},
+			"deepseek/deepseek-r1": {
+				id: "deepseek/deepseek-r1",
+				name: "DeepSeek: R1",
+				contextWindow: 64000,
+				maxInputTokens: 64000,
+				maxTokens: 16000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.7,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-20",
+			},
+			"deepseek/deepseek-v3.2-exp": {
+				id: "deepseek/deepseek-v3.2-exp",
+				name: "DeepSeek: DeepSeek V3.2 Exp",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.27,
+					output: 0.41,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-01",
+			},
+			"nex-agi/deepseek-v3.1-nex-n1": {
+				id: "nex-agi/deepseek-v3.1-nex-n1",
+				name: "Nex AGI: DeepSeek V3.1 Nex N1",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 163840,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.27,
+					output: 1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-01",
+			},
+			"openai/o3-mini": {
+				id: "openai/o3-mini",
+				name: "OpenAI: o3 Mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["files", "tools", "prompt-cache"],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-20",
+			},
+			"google/gemini-2.0-flash-001": {
+				id: "google/gemini-2.0-flash-001",
+				name: "Google: Gemini 2.0 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 8192,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2024-12-11",
+			},
+			"google/gemini-2.0-flash-lite-001": {
+				id: "google/gemini-2.0-flash-lite-001",
+				name: "Google: Gemini 2.0 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 8192,
+				capabilities: ["images", "files", "tools", "temperature"],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-11",
+			},
+			"amazon/nova-lite-v1": {
+				id: "amazon/nova-lite-v1",
+				name: "Amazon: Nova Lite 1.0",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 5120,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+			},
+			"amazon/nova-micro-v1": {
+				id: "amazon/nova-micro-v1",
+				name: "Amazon: Nova Micro 1.0",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 5120,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.035,
+					output: 0.14,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+			},
+			"openai/o1": {
+				id: "openai/o1",
+				name: "OpenAI: o1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "files", "tools", "prompt-cache"],
+				pricing: {
+					input: 15,
+					output: 60,
+					cacheRead: 7.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+			},
+			"amazon/nova-pro-v1": {
+				id: "amazon/nova-pro-v1",
+				name: "Amazon: Nova Pro 1.0",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 5120,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.8,
+					output: 3.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+			},
+			"cohere/command-r7b-12-2024": {
+				id: "cohere/command-r7b-12-2024",
+				name: "Cohere: Command R7B (12-2024)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.0375,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-02",
+			},
+			"amazon/nova-2-lite-v1": {
+				id: "amazon/nova-2-lite-v1",
+				name: "Amazon: Nova 2 Lite",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65535,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+			},
+			"deepseek/deepseek-chat": {
+				id: "deepseek/deepseek-chat",
+				name: "DeepSeek: DeepSeek V3",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 163840,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.32,
+					output: 0.89,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+			},
+			"nvidia/nemotron-3-nano-30b-a3b": {
+				id: "nvidia/nemotron-3-nano-30b-a3b",
+				name: "NVIDIA: Nemotron 3 Nano 30B A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 52429,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.05,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12",
+				family: "nemotron",
+			},
+			"qwen/qwen3-235b-a22b": {
+				id: "qwen/qwen3-235b-a22b",
+				name: "Qwen: Qwen3 235B A22B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.455,
+					output: 1.82,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+			},
+			"qwen/qwen3-32b": {
+				id: "qwen/qwen3-32b",
+				name: "Qwen: Qwen3 32B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 40960,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.08,
+					output: 0.24,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+			},
+			"openai/gpt-4o-2024-11-20": {
+				id: "openai/gpt-4o-2024-11-20",
+				name: "OpenAI: GPT-4o (2024-11-20)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-20",
+			},
+			"mistralai/mistral-large-2407": {
+				id: "mistralai/mistral-large-2407",
+				name: "Mistral Large 2407",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-19",
+			},
+			"mistralai/pixtral-large-2411": {
+				id: "mistralai/pixtral-large-2411",
+				name: "Mistral: Pixtral Large 2411",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-19",
+			},
+			"thedrummer/unslopnemo-12b": {
+				id: "thedrummer/unslopnemo-12b",
+				name: "TheDrummer: UnslopNemo 12B",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-09",
+			},
+			"mistralai/mistral-large-2512": {
+				id: "mistralai/mistral-large-2512",
+				name: "Mistral: Mistral Large 3 2512",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 52429,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-01",
+			},
+			"anthropic/claude-3.5-haiku": {
+				id: "anthropic/claude-3.5-haiku",
+				name: "Anthropic: Claude 3.5 Haiku",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.8,
+					output: 4,
+					cacheRead: 0.08,
+					cacheWrite: 1,
+				},
+				releaseDate: "2024-10-22",
+			},
+			"thedrummer/rocinante-12b": {
+				id: "thedrummer/rocinante-12b",
+				name: "TheDrummer: Rocinante 12B",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.17,
+					output: 0.43,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-30",
+			},
+			"qwen/qwen-2.5-72b-instruct": {
+				id: "qwen/qwen-2.5-72b-instruct",
+				name: "Qwen2.5 72B Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.12,
+					output: 0.39,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09",
+			},
+			"qwen/qwen-2.5-7b-instruct": {
+				id: "qwen/qwen-2.5-7b-instruct",
+				name: "Qwen: Qwen2.5 7B Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 6554,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.04,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09",
+			},
+			"cohere/command-r-08-2024": {
+				id: "cohere/command-r-08-2024",
+				name: "Cohere: Command R (08-2024)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-30",
+			},
+			"cohere/command-r-plus-08-2024": {
+				id: "cohere/command-r-plus-08-2024",
+				name: "Cohere: Command R+ (08-2024)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-30",
+			},
+			"sao10k/l3.1-euryale-70b": {
+				id: "sao10k/l3.1-euryale-70b",
+				name: "Sao10K: Llama 3.1 Euryale 70B v2.2",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.85,
+					output: 0.85,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-28",
+			},
+			"openai/gpt-4o-2024-08-06": {
+				id: "openai/gpt-4o-2024-08-06",
+				name: "OpenAI: GPT-4o (2024-08-06)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-06",
+			},
+			"meta-llama/llama-3.3-70b-instruct": {
+				id: "meta-llama/llama-3.3-70b-instruct",
+				name: "Meta: Llama 3.3 70B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.32,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-01",
+			},
+			"mistralai/mistral-large": {
+				id: "mistralai/mistral-large",
+				name: "Mistral Large",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 25600,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-24",
+			},
+			"mistralai/mistral-large-2411": {
+				id: "mistralai/mistral-large-2411",
+				name: "Mistral Large 2411",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-24",
+			},
+			"meta-llama/llama-3.1-8b-instruct": {
+				id: "meta-llama/llama-3.1-8b-instruct",
+				name: "Meta: Llama 3.1 8B Instruct",
+				contextWindow: 16384,
+				maxInputTokens: 16384,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.02,
+					output: 0.05,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+			},
+			"openai/gpt-4o-mini": {
+				id: "openai/gpt-4o-mini",
+				name: "OpenAI: GPT-4o-mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+			},
+			"openai/gpt-4o-mini-2024-07-18": {
+				id: "openai/gpt-4o-mini-2024-07-18",
+				name: "OpenAI: GPT-4o-mini (2024-07-18)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["images", "files", "tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+			},
+			"meta-llama/llama-3.1-70b-instruct": {
+				id: "meta-llama/llama-3.1-70b-instruct",
+				name: "Meta: Llama 3.1 70B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 26215,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-16",
+			},
+			"mistralai/mistral-nemo": {
+				id: "mistralai/mistral-nemo",
+				name: "Mistral: Mistral Nemo",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.02,
+					output: 0.04,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-01",
+			},
+			"openai/o3-deep-research": {
+				id: "openai/o3-deep-research",
+				name: "OpenAI: o3 Deep Research",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 40,
+					cacheRead: 2.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-26",
+			},
+			"openai/o4-mini-deep-research": {
+				id: "openai/o4-mini-deep-research",
+				name: "OpenAI: o4 Mini Deep Research",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-26",
+			},
+			"sao10k/l3-euryale-70b": {
+				id: "sao10k/l3-euryale-70b",
+				name: "Sao10k: Llama 3 Euryale 70B v2.1",
+				contextWindow: 8192,
+				maxInputTokens: 8192,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1.48,
+					output: 1.48,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-18",
+			},
+			"openai/gpt-4o": {
+				id: "openai/gpt-4o",
+				name: "OpenAI: GPT-4o",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+			},
+			"openai/gpt-4o-2024-05-13": {
+				id: "openai/gpt-4o-2024-05-13",
+				name: "OpenAI: GPT-4o (2024-05-13)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "files", "tools", "temperature"],
+				pricing: {
+					input: 5,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+			},
+			"meta-llama/llama-3-8b-instruct": {
+				id: "meta-llama/llama-3-8b-instruct",
+				name: "Meta: Llama 3 8B Instruct",
+				contextWindow: 8192,
+				maxInputTokens: 8192,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.03,
+					output: 0.04,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-04-25",
+			},
+			"mistralai/mixtral-8x22b-instruct": {
+				id: "mistralai/mixtral-8x22b-instruct",
+				name: "Mistral: Mixtral 8x22B Instruct",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 13108,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-04-17",
+			},
+			"anthropic/claude-3-haiku": {
+				id: "anthropic/claude-3-haiku",
+				name: "Anthropic: Claude 3 Haiku",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 1.25,
+					cacheRead: 0.03,
+					cacheWrite: 0.3,
+				},
+				releaseDate: "2024-03-07",
+			},
+			"openai/gpt-4-turbo-preview": {
+				id: "openai/gpt-4-turbo-preview",
+				name: "OpenAI: GPT-4 Turbo Preview",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-01-25",
+			},
+			"qwen/qwen-plus": {
+				id: "qwen/qwen-plus",
+				name: "Qwen: Qwen-Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.4,
+					output: 1.2,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-01-25",
+			},
+			"openai/gpt-4-1106-preview": {
+				id: "openai/gpt-4-1106-preview",
+				name: "OpenAI: GPT-4 Turbo (older v1106)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-06",
+			},
+			"openai/gpt-4-turbo": {
+				id: "openai/gpt-4-turbo",
+				name: "OpenAI: GPT-4 Turbo",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-09-13",
+			},
+			"openai/gpt-3.5-turbo-16k": {
+				id: "openai/gpt-3.5-turbo-16k",
+				name: "OpenAI: GPT-3.5 Turbo 16k",
+				contextWindow: 16385,
+				maxInputTokens: 16385,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 3,
+					output: 4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-08-28",
+			},
+			"openai/gpt-3.5-turbo-0613": {
+				id: "openai/gpt-3.5-turbo-0613",
+				name: "OpenAI: GPT-3.5 Turbo (older v0613)",
+				contextWindow: 4095,
+				maxInputTokens: 4095,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-06-13",
+			},
+			"openai/gpt-4-0314": {
+				id: "openai/gpt-4-0314",
+				name: "OpenAI: GPT-4 (older v0314)",
+				contextWindow: 8191,
+				maxInputTokens: 8191,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 30,
+					output: 60,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-05-28",
+			},
+			"openai/gpt-4": {
+				id: "openai/gpt-4",
+				name: "OpenAI: GPT-4",
+				contextWindow: 8191,
+				maxInputTokens: 8191,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 30,
+					output: 60,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-03-14",
+			},
+			"openai/gpt-3.5-turbo": {
+				id: "openai/gpt-3.5-turbo",
+				name: "OpenAI: GPT-3.5 Turbo",
+				contextWindow: 16385,
+				maxInputTokens: 16385,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-03-01",
+			},
+		},
+		lmstudio: {
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"qwen/qwen3-30b-a3b-2507": {
+				id: "qwen/qwen3-30b-a3b-2507",
+				name: "Qwen3 30B A3B 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-30",
+				family: "qwen",
+			},
+			"qwen/qwen3-coder-30b": {
+				id: "qwen/qwen3-coder-30b",
+				name: "Qwen3 Coder 30B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+				family: "qwen",
+			},
+		},
+		minimax: {
+			"MiniMax-M3": {
+				id: "MiniMax-M3",
+				name: "MiniMax-M3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-01",
+				family: "minimax",
+			},
+			"MiniMax-M2.7": {
+				id: "MiniMax-M2.7",
+				name: "MiniMax-M2.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"MiniMax-M2.7-highspeed": {
+				id: "MiniMax-M2.7-highspeed",
+				name: "MiniMax-M2.7-highspeed",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0.06,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"MiniMax-M2.5-highspeed": {
+				id: "MiniMax-M2.5-highspeed",
+				name: "MiniMax-M2.5-highspeed",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0.06,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-02-13",
+				family: "minimax",
+			},
+			"MiniMax-M2.5": {
+				id: "MiniMax-M2.5",
+				name: "MiniMax-M2.5",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax",
+			},
+			"MiniMax-M2.1": {
+				id: "MiniMax-M2.1",
+				name: "MiniMax-M2.1",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"MiniMax-M2": {
+				id: "MiniMax-M2",
+				name: "MiniMax-M2",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-27",
+				family: "minimax",
+			},
+		},
+		moonshot: {
+			"kimi-k2.7-code": {
+				id: "kimi-k2.7-code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.19,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"kimi-k2.7-code-highspeed": {
+				id: "kimi-k2.7-code-highspeed",
+				name: "Kimi K2.7 Code HighSpeed",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.9,
+					output: 8,
+					cacheRead: 0.38,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"kimi-k2.6": {
+				id: "kimi-k2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "kimi-k2",
+			},
+			"kimi-k2.5": {
+				id: "kimi-k2.5",
+				name: "Kimi K2.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01",
+				family: "kimi-k2",
+			},
+			"kimi-k2-thinking": {
+				id: "kimi-k2-thinking",
+				name: "Kimi K2 Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-06",
+				family: "kimi-thinking",
+			},
+			"kimi-k2-thinking-turbo": {
+				id: "kimi-k2-thinking-turbo",
+				name: "Kimi K2 Thinking Turbo",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.15,
+					output: 8,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-06",
+				family: "kimi-thinking",
+			},
+			"kimi-k2-0905-preview": {
+				id: "kimi-k2-0905-preview",
+				name: "Kimi K2 0905",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-05",
+				family: "kimi-k2",
+			},
+			"kimi-k2-turbo-preview": {
+				id: "kimi-k2-turbo-preview",
+				name: "Kimi K2 Turbo",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 2.4,
+					output: 10,
+					cacheRead: 0.6,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-05",
+				family: "kimi-k2",
+			},
+			"kimi-k2-0711-preview": {
+				id: "kimi-k2-0711-preview",
+				name: "Kimi K2 0711",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-14",
+				family: "kimi-k2",
+			},
+		},
+		nebius: {
+			"zai-org/GLM-5.2": {
+				id: "zai-org/GLM-5.2",
+				name: "GLM-5.2",
+				contextWindow: 432000,
+				maxInputTokens: 432000,
+				maxTokens: 432000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"deepseek-ai/DeepSeek-V4-Pro": {
+				id: "deepseek-ai/DeepSeek-V4-Pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 3.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"nvidia/nemotron-3-super-120b-a12b": {
+				id: "nvidia/nemotron-3-super-120b-a12b",
+				name: "Nemotron-3-Super-120B-A12B",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"NousResearch/Hermes-4-405B": {
+				id: "NousResearch/Hermes-4-405B",
+				name: "Hermes-4-405B",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2026-01-30",
+			},
+			"NousResearch/Hermes-4-70B": {
+				id: "NousResearch/Hermes-4-70B",
+				name: "Hermes-4-70B",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.13,
+					output: 0.4,
+					cacheRead: 0.013,
+					cacheWrite: 0.16,
+				},
+				releaseDate: "2026-01-30",
+			},
+			"Qwen/Qwen3-30B-A3B-Instruct-2507": {
+				id: "Qwen/Qwen3-30B-A3B-Instruct-2507",
+				name: "Qwen3-30B-A3B-Instruct-2507",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.01,
+					cacheWrite: 0.125,
+				},
+				releaseDate: "2026-01-28",
+			},
+			"Qwen/Qwen3-32B": {
+				id: "Qwen/Qwen3-32B",
+				name: "Qwen3-32B",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.01,
+					cacheWrite: 0.125,
+				},
+				releaseDate: "2026-01-28",
+			},
+			"Qwen/Qwen3-Next-80B-A3B-Thinking": {
+				id: "Qwen/Qwen3-Next-80B-A3B-Thinking",
+				name: "Qwen3-Next-80B-A3B-Thinking",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 1.2,
+					cacheRead: 0.015,
+					cacheWrite: 0.18,
+				},
+				releaseDate: "2026-01-28",
+			},
+			"google/gemma-3-27b-it": {
+				id: "google/gemma-3-27b-it",
+				name: "Gemma-3-27b-it",
+				contextWindow: 110000,
+				maxInputTokens: 100000,
+				maxTokens: 8192,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.01,
+					cacheWrite: 0.125,
+				},
+				releaseDate: "2026-01-20",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "gpt-oss-120b",
+				contextWindow: 128000,
+				maxInputTokens: 124000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.015,
+					cacheWrite: 0.18,
+				},
+				releaseDate: "2026-01-10",
+			},
+			"meta-llama/Llama-3.3-70B-Instruct": {
+				id: "meta-llama/Llama-3.3-70B-Instruct",
+				name: "Llama-3.3-70B-Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.13,
+					output: 0.4,
+					cacheRead: 0.013,
+					cacheWrite: 0.16,
+				},
+				releaseDate: "2025-12-05",
+			},
+			"nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B": {
+				id: "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B",
+				name: "Nemotron-3-Nano-30B-A3B",
+				contextWindow: 32000,
+				maxInputTokens: 30000,
+				maxTokens: 4096,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0.006,
+					cacheWrite: 0.075,
+				},
+				releaseDate: "2025-08-10",
+				family: "nemotron",
+			},
+			"Qwen/Qwen3-235B-A22B-Instruct-2507": {
+				id: "Qwen/Qwen3-235B-A22B-Instruct-2507",
+				name: "Qwen3 235B A22B Instruct 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.5-397B-A17B": {
+				id: "Qwen/Qwen3.5-397B-A17B",
+				name: "Qwen3.5-397B-A17B",
+				contextWindow: 262144,
+				maxInputTokens: 250000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3.6,
+					cacheRead: 0.06,
+					cacheWrite: 0.75,
+				},
+				releaseDate: "2025-07-15",
+			},
+			"MiniMaxAI/MiniMax-M2.5": {
+				id: "MiniMaxAI/MiniMax-M2.5",
+				name: "MiniMax-M2.5",
+				contextWindow: 196608,
+				maxInputTokens: 190000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-01-20",
+			},
+			"nvidia/Nemotron-3-Nano-Omni": {
+				id: "nvidia/Nemotron-3-Nano-Omni",
+				name: "Nemotron-3-Nano-Omni",
+				contextWindow: 65536,
+				maxInputTokens: 60000,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0.006,
+					cacheWrite: 0.075,
+				},
+				releaseDate: "2025-01-20",
+				family: "nemotron",
+			},
+			"Qwen/Qwen2.5-VL-72B-Instruct": {
+				id: "Qwen/Qwen2.5-VL-72B-Instruct",
+				name: "Qwen2.5-VL-72B-Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 8192,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.025,
+					cacheWrite: 0.31,
+				},
+				releaseDate: "2025-01-20",
+			},
+			"nvidia/Llama-3_1-Nemotron-Ultra-253B-v1": {
+				id: "nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
+				name: "Llama-3.1-Nemotron-Ultra-253B-v1",
+				contextWindow: 128000,
+				maxInputTokens: 120000,
+				maxTokens: 4096,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 1.8,
+					cacheRead: 0.06,
+					cacheWrite: 0.75,
+				},
+				releaseDate: "2025-01-15",
+				family: "nemotron",
+			},
+		},
+		ollama: {
+			"glm-5.2": {
+				id: "glm-5.2",
+				name: "GLM-5.2",
+				contextWindow: 976000,
+				maxInputTokens: 976000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"kimi-k2.7-code": {
+				id: "kimi-k2.7-code",
+				name: "kimi-k2.7-code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"nemotron-3-ultra": {
+				id: "nemotron-3-ultra",
+				name: "nemotron-3-ultra",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"minimax-m3": {
+				id: "minimax-m3",
+				name: "minimax-m3",
+				contextWindow: 512000,
+				maxInputTokens: 512000,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-31",
+				family: "minimax-m3",
+			},
+			"deepseek-v4-flash": {
+				id: "deepseek-v4-flash",
+				name: "deepseek-v4-flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 1048576,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"deepseek-v4-pro": {
+				id: "deepseek-v4-pro",
+				name: "deepseek-v4-pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 1048576,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"kimi-k2.6": {
+				id: "kimi-k2.6",
+				name: "kimi-k2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+				family: "kimi-k2",
+			},
+			"gemma4:31b": {
+				id: "gemma4:31b",
+				name: "gemma4:31b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"glm-5.1": {
+				id: "glm-5.1",
+				name: "glm-5.1",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+				family: "glm",
+			},
+			"minimax-m2.7": {
+				id: "minimax-m2.7",
+				name: "minimax-m2.7",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"nemotron-3-super": {
+				id: "nemotron-3-super",
+				name: "nemotron-3-super",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"qwen3.5:397b": {
+				id: "qwen3.5:397b",
+				name: "qwen3.5:397b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-15",
+				family: "qwen",
+			},
+			"minimax-m2.5": {
+				id: "minimax-m2.5",
+				name: "minimax-m2.5",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax",
+			},
+			"glm-5": {
+				id: "glm-5",
+				name: "glm-5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-11",
+				family: "glm",
+			},
+			"qwen3-coder-next": {
+				id: "qwen3-coder-next",
+				name: "qwen3-coder-next",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-02",
+				family: "qwen",
+			},
+			"kimi-k2.5": {
+				id: "kimi-k2.5",
+				name: "kimi-k2.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-27",
+				family: "kimi-k2",
+			},
+			"minimax-m2.1": {
+				id: "minimax-m2.1",
+				name: "minimax-m2.1",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"glm-4.7": {
+				id: "glm-4.7",
+				name: "glm-4.7",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"gemini-3-flash-preview": {
+				id: "gemini-3-flash-preview",
+				name: "gemini-3-flash-preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-17",
+				family: "gemini-flash",
+			},
+			"nemotron-3-nano:30b": {
+				id: "nemotron-3-nano:30b",
+				name: "nemotron-3-nano:30b",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-15",
+				family: "nemotron",
+			},
+			"devstral-2:123b": {
+				id: "devstral-2:123b",
+				name: "devstral-2:123b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-09",
+				family: "devstral",
+			},
+			"devstral-small-2:24b": {
+				id: "devstral-small-2:24b",
+				name: "devstral-small-2:24b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-09",
+				family: "devstral",
+			},
+			"rnj-1:8b": {
+				id: "rnj-1:8b",
+				name: "rnj-1:8b",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 4096,
+				capabilities: ["tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-06",
+				family: "rnj",
+			},
+			"mistral-large-3:675b": {
+				id: "mistral-large-3:675b",
+				name: "mistral-large-3:675b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["images", "tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "mistral-large",
+			},
+			"deepseek-v3.1:671b": {
+				id: "deepseek-v3.1:671b",
+				name: "deepseek-v3.1:671b",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 163840,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-21",
+				family: "deepseek",
+			},
+			"gpt-oss:120b": {
+				id: "gpt-oss:120b",
+				name: "gpt-oss:120b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"gpt-oss:20b": {
+				id: "gpt-oss:20b",
+				name: "gpt-oss:20b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"qwen3-coder:480b": {
+				id: "qwen3-coder:480b",
+				name: "qwen3-coder:480b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-22",
+				family: "qwen",
+			},
+			"deepseek-v3.2": {
+				id: "deepseek-v3.2",
+				name: "deepseek-v3.2",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-15",
+				family: "deepseek",
+			},
+			"ministral-3:14b": {
+				id: "ministral-3:14b",
+				name: "ministral-3:14b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 128000,
+				capabilities: ["images", "tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "ministral",
+			},
+			"ministral-3:8b": {
+				id: "ministral-3:8b",
+				name: "ministral-3:8b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 128000,
+				capabilities: ["images", "tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "ministral",
+			},
+			"ministral-3:3b": {
+				id: "ministral-3:3b",
+				name: "ministral-3:3b",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 128000,
+				capabilities: ["images", "tools"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-10-22",
+				family: "ministral",
+			},
+		},
+		"openai-native": {
+			"gpt-5.5": {
+				id: "gpt-5.5",
+				name: "GPT-5.5",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt",
+			},
+			"gpt-5.5-pro": {
+				id: "gpt-5.5-pro",
+				name: "GPT-5.5 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+				],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt-pro",
+			},
+			"gpt-5.4-mini": {
+				id: "gpt-5.4-mini",
+				name: "GPT-5.4 mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt-mini",
+			},
+			"gpt-5.4-nano": {
+				id: "gpt-5.4-nano",
+				name: "GPT-5.4 nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 1.25,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt-nano",
+			},
+			"gpt-5.4": {
+				id: "gpt-5.4",
+				name: "GPT-5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"gpt-5.4-pro": {
+				id: "gpt-5.4-pro",
+				name: "GPT-5.4 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt-pro",
+			},
+			"gpt-5.3-chat-latest": {
+				id: "gpt-5.3-chat-latest",
+				name: "GPT-5.3 Chat (latest)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-03",
+				family: "gpt",
+			},
+			"gpt-5.3-codex": {
+				id: "gpt-5.3-codex",
+				name: "GPT-5.3 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-05",
+				family: "gpt-codex",
+			},
+			"gpt-5.3-codex-spark": {
+				id: "gpt-5.3-codex-spark",
+				name: "GPT-5.3 Codex Spark",
+				contextWindow: 128000,
+				maxInputTokens: 100000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-05",
+				family: "gpt-codex-spark",
+			},
+			"gpt-5.2": {
+				id: "gpt-5.2",
+				name: "GPT-5.2",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"gpt-5.2-chat-latest": {
+				id: "gpt-5.2-chat-latest",
+				name: "GPT-5.2 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-codex",
+			},
+			"gpt-5.2-codex": {
+				id: "gpt-5.2-codex",
+				name: "GPT-5.2 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-codex",
+			},
+			"gpt-5.2-pro": {
+				id: "gpt-5.2-pro",
+				name: "GPT-5.2 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning"],
+				pricing: {
+					input: 21,
+					output: 168,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-pro",
+			},
+			"gpt-5.1": {
+				id: "gpt-5.1",
+				name: "GPT-5.1",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt",
+			},
+			"gpt-5.1-chat-latest": {
+				id: "gpt-5.1-chat-latest",
+				name: "GPT-5.1 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"gpt-5.1-codex": {
+				id: "gpt-5.1-codex",
+				name: "GPT-5.1 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"gpt-5.1-codex-max": {
+				id: "gpt-5.1-codex-max",
+				name: "GPT-5.1 Codex Max",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"gpt-5.1-codex-mini": {
+				id: "gpt-5.1-codex-mini",
+				name: "GPT-5.1 Codex mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"gpt-5-pro": {
+				id: "gpt-5-pro",
+				name: "GPT-5 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 272000,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 15,
+					output: 120,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+				family: "gpt-pro",
+			},
+			"gpt-5-codex": {
+				id: "gpt-5-codex",
+				name: "GPT-5-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-15",
+				family: "gpt-codex",
+			},
+			"gpt-5": {
+				id: "gpt-5",
+				name: "GPT-5",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt",
+			},
+			"gpt-5-mini": {
+				id: "gpt-5-mini",
+				name: "GPT-5 Mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-mini",
+			},
+			"gpt-5-nano": {
+				id: "gpt-5-nano",
+				name: "GPT-5 Nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.005,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-nano",
+			},
+			"o3-pro": {
+				id: "o3-pro",
+				name: "o3-pro",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 20,
+					output: 80,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-10",
+				family: "o-pro",
+			},
+			o3: {
+				id: "o3",
+				name: "o3",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o",
+			},
+			"o4-mini": {
+				id: "o4-mini",
+				name: "o4-mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.275,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o-mini",
+			},
+			"gpt-4.1": {
+				id: "gpt-4.1",
+				name: "GPT-4.1",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt",
+			},
+			"gpt-4.1-mini": {
+				id: "gpt-4.1-mini",
+				name: "GPT-4.1 mini",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-mini",
+			},
+			"gpt-4.1-nano": {
+				id: "gpt-4.1-nano",
+				name: "GPT-4.1 nano",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-nano",
+			},
+			"o1-pro": {
+				id: "o1-pro",
+				name: "o1-pro",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 150,
+					output: 600,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-19",
+				family: "o-pro",
+			},
+			"o3-mini": {
+				id: "o3-mini",
+				name: "o3-mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-20",
+				family: "o-mini",
+			},
+			o1: {
+				id: "o1",
+				name: "o1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 60,
+					cacheRead: 7.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+				family: "o",
+			},
+			"gpt-4o-2024-11-20": {
+				id: "gpt-4o-2024-11-20",
+				name: "GPT-4o (2024-11-20)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-20",
+				family: "gpt",
+			},
+			"gpt-4o-2024-08-06": {
+				id: "gpt-4o-2024-08-06",
+				name: "GPT-4o (2024-08-06)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-06",
+				family: "gpt",
+			},
+			"gpt-4o-mini": {
+				id: "gpt-4o-mini",
+				name: "GPT-4o mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+				family: "gpt-mini",
+			},
+			"o3-deep-research": {
+				id: "o3-deep-research",
+				name: "o3-deep-research",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 10,
+					output: 40,
+					cacheRead: 2.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-26",
+				family: "o",
+			},
+			"o4-mini-deep-research": {
+				id: "o4-mini-deep-research",
+				name: "o4-mini-deep-research",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-26",
+				family: "o-mini",
+			},
+			"gpt-4o": {
+				id: "gpt-4o",
+				name: "GPT-4o",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+				family: "gpt",
+			},
+			"gpt-4o-2024-05-13": {
+				id: "gpt-4o-2024-05-13",
+				name: "GPT-4o (2024-05-13)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 5,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+				family: "gpt",
+			},
+			"gpt-4": {
+				id: "gpt-4",
+				name: "GPT-4",
+				contextWindow: 8192,
+				maxInputTokens: 8192,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 30,
+					output: 60,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-06",
+				family: "gpt",
+			},
+			"gpt-4-turbo": {
+				id: "gpt-4-turbo",
+				name: "GPT-4 Turbo",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-06",
+				family: "gpt",
+			},
+		},
+		openrouter: {
+			"~x-ai/grok-latest": {
+				id: "~x-ai/grok-latest",
+				name: "Grok Latest",
+				contextWindow: 500000,
+				maxInputTokens: 500000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-08",
+				family: "grok",
+			},
+			"x-ai/grok-4.5": {
+				id: "x-ai/grok-4.5",
+				name: "Grok 4.5",
+				contextWindow: 500000,
+				maxInputTokens: 500000,
+				maxTokens: 500000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-08",
+				family: "grok",
+			},
+			"aion-labs/aion-3.0": {
+				id: "aion-labs/aion-3.0",
+				name: "Aion-3.0",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 3,
+					output: 6,
+					cacheRead: 0.75,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-07",
+			},
+			"aion-labs/aion-3.0-mini": {
+				id: "aion-labs/aion-3.0-mini",
+				name: "Aion-3.0-Mini",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.7,
+					output: 1.4,
+					cacheRead: 0.18,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-07",
+			},
+			"tencent/hy3": {
+				id: "tencent/hy3",
+				name: "Hy3",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.58,
+					cacheRead: 0.035,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-06",
+				family: "hy3",
+			},
+			"tencent/hy3:free": {
+				id: "tencent/hy3:free",
+				name: "Hy3 (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-06",
+				family: "hy3",
+			},
+			"poolside/laguna-xs-2.1": {
+				id: "poolside/laguna-xs-2.1",
+				name: "Laguna XS 2.1",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.12,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-02",
+			},
+			"poolside/laguna-xs-2.1:free": {
+				id: "poolside/laguna-xs-2.1:free",
+				name: "Laguna XS 2.1 (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-02",
+			},
+			"anthropic/claude-sonnet-5": {
+				id: "anthropic/claude-sonnet-5",
+				name: "Claude Sonnet 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"nex-agi/nex-n2-mini": {
+				id: "nex-agi/nex-n2-mini",
+				name: "Nex-N2-Mini",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.025,
+					output: 0.1,
+					cacheRead: 0.0025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-24",
+				family: "agi",
+			},
+			"sakana/fugu-ultra": {
+				id: "sakana/fugu-ultra",
+				name: "Fugu Ultra",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-24",
+				family: "fugu",
+			},
+			"google/gemini-3-pro-image": {
+				id: "google/gemini-3-pro-image",
+				name: "Nano Banana Pro (Gemini 3 Pro Image)",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-06-18",
+				family: "gemini",
+			},
+			"cohere/north-mini-code:free": {
+				id: "cohere/north-mini-code:free",
+				name: "North Mini Code (free)",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 64000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-17",
+				family: "north",
+			},
+			"z-ai/glm-5.2": {
+				id: "z-ai/glm-5.2",
+				name: "GLM-5.2",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 1048576,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.9,
+					output: 3.08,
+					cacheRead: 0.18,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"moonshotai/kimi-k2.7-code": {
+				id: "moonshotai/kimi-k2.7-code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.74,
+					output: 3.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"~anthropic/claude-fable-latest": {
+				id: "~anthropic/claude-fable-latest",
+				name: "Claude Fable Latest",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-06-09",
+				family: "claude-fable",
+			},
+			"anthropic/claude-fable-5": {
+				id: "anthropic/claude-fable-5",
+				name: "Claude Fable 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-06-09",
+				family: "claude-fable",
+			},
+			"nex-agi/nex-n2-pro": {
+				id: "nex-agi/nex-n2-pro",
+				name: "Nex-N2-Pro",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-08",
+				family: "agi",
+			},
+			"nvidia/nemotron-3-ultra-550b-a55b": {
+				id: "nvidia/nemotron-3-ultra-550b-a55b",
+				name: "Nemotron 3 Ultra 550B A55B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 2.2,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"nvidia/nemotron-3-ultra-550b-a55b:free": {
+				id: "nvidia/nemotron-3-ultra-550b-a55b:free",
+				name: "Nemotron 3 Ultra (free)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"qwen/qwen3.7-plus": {
+				id: "qwen/qwen3.7-plus",
+				name: "Qwen3.7 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.32,
+					output: 1.28,
+					cacheRead: 0.064,
+					cacheWrite: 0.4,
+				},
+				releaseDate: "2026-06-02",
+				family: "qwen",
+			},
+			"minimax/minimax-m3": {
+				id: "minimax/minimax-m3",
+				name: "MiniMax-M3",
+				contextWindow: 524288,
+				maxInputTokens: 524288,
+				maxTokens: 512000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-01",
+				family: "minimax",
+			},
+			"stepfun/step-3.7-flash": {
+				id: "stepfun/step-3.7-flash",
+				name: "Step 3.7 Flash",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 1.15,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-29",
+			},
+			"anthropic/claude-opus-4.8": {
+				id: "anthropic/claude-opus-4.8",
+				name: "Claude Opus 4.8",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"anthropic/claude-opus-4.8-fast": {
+				id: "anthropic/claude-opus-4.8-fast",
+				name: "Claude Opus 4.8 (Fast)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-05-27",
+				family: "claude-opus",
+			},
+			"qwen/qwen3.7-max": {
+				id: "qwen/qwen3.7-max",
+				name: "Qwen3.7 Max",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 3.75,
+					cacheRead: 0.25,
+					cacheWrite: 1.5625,
+				},
+				releaseDate: "2026-05-21",
+				family: "qwen",
+			},
+			"google/gemini-3.5-flash": {
+				id: "google/gemini-3.5-flash",
+				name: "Gemini 3.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.5,
+					output: 9,
+					cacheRead: 0.15,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2026-05-19",
+				family: "gemini-flash",
+			},
+			"anthropic/claude-opus-4.7-fast": {
+				id: "anthropic/claude-opus-4.7-fast",
+				name: "Claude Opus 4.7 (Fast)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 30,
+					output: 150,
+					cacheRead: 3,
+					cacheWrite: 37.5,
+				},
+				releaseDate: "2026-05-12",
+				family: "claude-opus",
+			},
+			"inclusionai/ring-2.6-1t": {
+				id: "inclusionai/ring-2.6-1t",
+				name: "Ring-2.6-1T",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.075,
+					output: 0.625,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-08",
+				family: "ring",
+			},
+			"google/gemini-3.1-flash-lite": {
+				id: "google/gemini-3.1-flash-lite",
+				name: "Gemini 3.1 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.025,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2026-05-07",
+				family: "gemini-flash-lite",
+			},
+			"openai/gpt-chat-latest": {
+				id: "openai/gpt-chat-latest",
+				name: "GPT Chat Latest",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-05",
+				family: "gpt",
+			},
+			"ibm-granite/granite-4.1-8b": {
+				id: "ibm-granite/granite-4.1-8b",
+				name: "Granite 4.1 8B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.1,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-30",
+				family: "granite",
+			},
+			"mistralai/mistral-medium-3-5": {
+				id: "mistralai/mistral-medium-3-5",
+				name: "Mistral Medium 3.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1.5,
+					output: 7.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-30",
+				family: "mistral-medium",
+			},
+			"nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free": {
+				id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+				name: "Nemotron 3 Nano Omni (free)",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 65536,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+				family: "nemotron",
+			},
+			"poolside/laguna-m.1": {
+				id: "poolside/laguna-m.1",
+				name: "Laguna M.1",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 0.4,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"poolside/laguna-m.1:free": {
+				id: "poolside/laguna-m.1:free",
+				name: "Laguna M.1 (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"poolside/laguna-xs.2": {
+				id: "poolside/laguna-xs.2",
+				name: "Laguna XS.2",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.1,
+					output: 0.2,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"poolside/laguna-xs.2:free": {
+				id: "poolside/laguna-xs.2:free",
+				name: "Laguna XS.2 (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-28",
+			},
+			"~anthropic/claude-haiku-latest": {
+				id: "~anthropic/claude-haiku-latest",
+				name: "Anthropic Claude Haiku Latest",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2026-04-27",
+				family: "claude-haiku",
+			},
+			"~anthropic/claude-sonnet-latest": {
+				id: "~anthropic/claude-sonnet-latest",
+				name: "Anthropic Claude Sonnet Latest",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-04-27",
+				family: "claude-sonnet",
+			},
+			"~google/gemini-flash-latest": {
+				id: "~google/gemini-flash-latest",
+				name: "Google Gemini Flash Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.5,
+					output: 9,
+					cacheRead: 0.15,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2026-04-27",
+				family: "gemini-flash",
+			},
+			"~google/gemini-pro-latest": {
+				id: "~google/gemini-pro-latest",
+				name: "Google Gemini Pro Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-04-27",
+				family: "gemini-pro",
+			},
+			"~moonshotai/kimi-latest": {
+				id: "~moonshotai/kimi-latest",
+				name: "MoonshotAI Kimi Latest",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.65,
+					output: 3.41,
+					cacheRead: 0.14,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+				family: "kimi",
+			},
+			"~openai/gpt-latest": {
+				id: "~openai/gpt-latest",
+				name: "OpenAI GPT Latest",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+				family: "gpt",
+			},
+			"~openai/gpt-mini-latest": {
+				id: "~openai/gpt-mini-latest",
+				name: "OpenAI GPT Mini Latest",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-27",
+				family: "gpt-mini",
+			},
+			"qwen/qwen3.5-plus-20260420": {
+				id: "qwen/qwen3.5-plus-20260420",
+				name: "Qwen3.5 Plus 2026-04-20",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.8,
+					cacheRead: 0,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-04-27",
+				family: "qwen3.5",
+			},
+			"qwen/qwen3.6-flash": {
+				id: "qwen/qwen3.6-flash",
+				name: "Qwen3.6 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1875,
+					output: 1.125,
+					cacheRead: 0,
+					cacheWrite: 0.234375,
+				},
+				releaseDate: "2026-04-27",
+				family: "qwen3.6",
+			},
+			"deepseek/deepseek-v4-flash": {
+				id: "deepseek/deepseek-v4-flash",
+				name: "DeepSeek V4 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.09,
+					output: 0.18,
+					cacheRead: 0.018,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-flash",
+			},
+			"deepseek/deepseek-v4-pro": {
+				id: "deepseek/deepseek-v4-pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.003625,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek-thinking",
+			},
+			"inclusionai/ling-2.6-1t": {
+				id: "inclusionai/ling-2.6-1t",
+				name: "Ling-2.6-1T",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.075,
+					output: 0.625,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "ling",
+			},
+			"openai/gpt-5.5": {
+				id: "openai/gpt-5.5",
+				name: "GPT-5.5",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt",
+			},
+			"openai/gpt-5.5-pro": {
+				id: "openai/gpt-5.5-pro",
+				name: "GPT-5.5 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+				],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt-pro",
+			},
+			"qwen/qwen3.6-27b": {
+				id: "qwen/qwen3.6-27b",
+				name: "Qwen3.6 27B",
+				contextWindow: 262140,
+				maxInputTokens: 262140,
+				maxTokens: 262140,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.285,
+					output: 2.4,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "qwen",
+			},
+			"xiaomi/mimo-v2.5": {
+				id: "xiaomi/mimo-v2.5",
+				name: "MiMo-V2.5",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.105,
+					output: 0.28,
+					cacheRead: 0.028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+			"xiaomi/mimo-v2.5-pro": {
+				id: "xiaomi/mimo-v2.5-pro",
+				name: "MiMo-V2.5-Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.0036,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+			"~anthropic/claude-opus-latest": {
+				id: "~anthropic/claude-opus-latest",
+				name: "Claude Opus Latest",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-21",
+				family: "claude-opus",
+			},
+			"inclusionai/ling-2.6-flash": {
+				id: "inclusionai/ling-2.6-flash",
+				name: "Ling-2.6-flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.01,
+					output: 0.03,
+					cacheRead: 0.002,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "ling",
+			},
+			"moonshotai/kimi-k2.6": {
+				id: "moonshotai/kimi-k2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.65,
+					output: 3.41,
+					cacheRead: 0.14,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "kimi-k2",
+			},
+			"qwen/qwen3.6-max-preview": {
+				id: "qwen/qwen3.6-max-preview",
+				name: "Qwen3.6 Max Preview",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.04,
+					output: 6.24,
+					cacheRead: 0,
+					cacheWrite: 1.3,
+				},
+				releaseDate: "2026-04-20",
+				family: "qwen",
+			},
+			"tencent/hy3-preview": {
+				id: "tencent/hy3-preview",
+				name: "Hy3 preview",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.063,
+					output: 0.21,
+					cacheRead: 0.021,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+				family: "Hy",
+			},
+			"qwen/qwen3.6-35b-a3b": {
+				id: "qwen/qwen3.6-35b-a3b",
+				name: "Qwen3.6 35B-A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.14,
+					output: 1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "qwen",
+			},
+			"x-ai/grok-4.3": {
+				id: "x-ai/grok-4.3",
+				name: "Grok 4.3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "grok",
+			},
+			"anthropic/claude-opus-4.7": {
+				id: "anthropic/claude-opus-4.7",
+				name: "Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"x-ai/grok-build-0.1": {
+				id: "x-ai/grok-build-0.1",
+				name: "Grok Build 0.1",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-16",
+				family: "grok-build",
+			},
+			"z-ai/glm-5.1": {
+				id: "z-ai/glm-5.1",
+				name: "GLM-5.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.966,
+					output: 3.036,
+					cacheRead: 0.1794,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "glm",
+			},
+			"google/gemma-4-26b-a4b-it": {
+				id: "google/gemma-4-26b-a4b-it",
+				name: "Gemma 4 26B A4B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.06,
+					output: 0.33,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"google/gemma-4-26b-a4b-it:free": {
+				id: "google/gemma-4-26b-a4b-it:free",
+				name: "Gemma 4 26B A4B  (free)",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"google/gemma-4-31b-it": {
+				id: "google/gemma-4-31b-it",
+				name: "Gemma 4 31B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.12,
+					output: 0.35,
+					cacheRead: 0.09,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"google/gemma-4-31b-it:free": {
+				id: "google/gemma-4-31b-it:free",
+				name: "Gemma 4 31B (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"qwen/qwen3.6-plus": {
+				id: "qwen/qwen3.6-plus",
+				name: "Qwen3.6 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.325,
+					output: 1.95,
+					cacheRead: 0,
+					cacheWrite: 0.40625,
+				},
+				releaseDate: "2026-04-02",
+				family: "qwen",
+			},
+			"arcee-ai/trinity-large-thinking": {
+				id: "arcee-ai/trinity-large-thinking",
+				name: "Trinity Large Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 80000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 0.8,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "trinity",
+			},
+			"z-ai/glm-5v-turbo": {
+				id: "z-ai/glm-5v-turbo",
+				name: "GLM-5V-Turbo",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "glm",
+			},
+			"x-ai/grok-4.20": {
+				id: "x-ai/grok-4.20",
+				name: "Grok 4.20",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-31",
+				family: "grok",
+			},
+			"kwaipilot/kat-coder-pro-v2": {
+				id: "kwaipilot/kat-coder-pro-v2",
+				name: "KAT-Coder-Pro V2",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 80000,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+				family: "kat-coder",
+			},
+			"rekaai/reka-edge": {
+				id: "rekaai/reka-edge",
+				name: "Reka Edge",
+				contextWindow: 16384,
+				maxInputTokens: 16384,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-20",
+				family: "reka",
+			},
+			"minimax/minimax-m2.7": {
+				id: "minimax/minimax-m2.7",
+				name: "MiniMax-M2.7",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.18,
+					output: 0.72,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"openai/gpt-5.4-mini": {
+				id: "openai/gpt-5.4-mini",
+				name: "GPT-5.4 mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt-mini",
+			},
+			"openai/gpt-5.4-nano": {
+				id: "openai/gpt-5.4-nano",
+				name: "GPT-5.4 nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 1.25,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt-nano",
+			},
+			"mistralai/mistral-small-2603": {
+				id: "mistralai/mistral-small-2603",
+				name: "Mistral Small 4",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-16",
+				family: "mistral-small",
+			},
+			"z-ai/glm-5-turbo": {
+				id: "z-ai/glm-5-turbo",
+				name: "GLM-5-Turbo",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-16",
+				family: "glm",
+			},
+			"nvidia/nemotron-3-super-120b-a12b": {
+				id: "nvidia/nemotron-3-super-120b-a12b",
+				name: "Nemotron 3 Super 120B A12B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.08,
+					output: 0.45,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"nvidia/nemotron-3-super-120b-a12b:free": {
+				id: "nvidia/nemotron-3-super-120b-a12b:free",
+				name: "Nemotron 3 Super (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"bytedance-seed/seed-2.0-lite": {
+				id: "bytedance-seed/seed-2.0-lite",
+				name: "Seed-2.0-Lite",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-10",
+				family: "seed",
+			},
+			"openai/gpt-5.4": {
+				id: "openai/gpt-5.4",
+				name: "GPT-5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"openai/gpt-5.4-pro": {
+				id: "openai/gpt-5.4-pro",
+				name: "GPT-5.4 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+				],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt-pro",
+			},
+			"inception/mercury-2": {
+				id: "inception/mercury-2",
+				name: "Mercury 2",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 50000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-04",
+				family: "mercury",
+			},
+			"google/gemini-3.1-flash-lite-preview": {
+				id: "google/gemini-3.1-flash-lite-preview",
+				name: "Gemini 3.1 Flash Lite Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.025,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2026-03-03",
+				family: "gemini-flash-lite",
+			},
+			"openai/gpt-5.3-chat": {
+				id: "openai/gpt-5.3-chat",
+				name: "GPT-5.3 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-03",
+				family: "gpt",
+			},
+			"bytedance-seed/seed-2.0-mini": {
+				id: "bytedance-seed/seed-2.0-mini",
+				name: "Seed-2.0-Mini",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-26",
+				family: "seed",
+			},
+			"qwen/qwen3.5-flash-02-23": {
+				id: "qwen/qwen3.5-flash-02-23",
+				name: "Qwen3.5-Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.065,
+					output: 0.26,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-25",
+				family: "qwen",
+			},
+			"aion-labs/aion-2.0": {
+				id: "aion-labs/aion-2.0",
+				name: "Aion-2.0",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.8,
+					output: 1.6,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+			},
+			"qwen/qwen3.5-122b-a10b": {
+				id: "qwen/qwen3.5-122b-a10b",
+				name: "Qwen3.5 122B-A10B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.26,
+					output: 2.08,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"qwen/qwen3.5-27b": {
+				id: "qwen/qwen3.5-27b",
+				name: "Qwen3.5 27B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.195,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"qwen/qwen3.5-35b-a3b": {
+				id: "qwen/qwen3.5-35b-a3b",
+				name: "Qwen3.5 35B-A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 81920,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 1,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"qwen/qwen3.5-9b": {
+				id: "qwen/qwen3.5-9b",
+				name: "Qwen3.5 9B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-23",
+				family: "qwen",
+			},
+			"google/gemini-3.1-pro-preview": {
+				id: "google/gemini-3.1-pro-preview",
+				name: "Gemini 3.1 Pro Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"google/gemini-3.1-pro-preview-customtools": {
+				id: "google/gemini-3.1-pro-preview-customtools",
+				name: "Gemini 3.1 Pro Preview Custom Tools",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"anthropic/claude-sonnet-4.6": {
+				id: "anthropic/claude-sonnet-4.6",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"qwen/qwen3.5-plus-02-15": {
+				id: "qwen/qwen3.5-plus-02-15",
+				name: "Qwen3.5 Plus 2026-02-15",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.26,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-16",
+				family: "qwen",
+			},
+			"qwen/qwen3.5-397b-a17b": {
+				id: "qwen/qwen3.5-397b-a17b",
+				name: "Qwen3.5 397B-A17B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.385,
+					output: 2.45,
+					cacheRead: 0.111,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-15",
+				family: "qwen",
+			},
+			"minimax/minimax-m2.5": {
+				id: "minimax/minimax-m2.5",
+				name: "MiniMax-M2.5",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.12,
+					output: 0.48,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax",
+			},
+			"z-ai/glm-5": {
+				id: "z-ai/glm-5",
+				name: "GLM-5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 1.92,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "glm",
+			},
+			"qwen/qwen3-max-thinking": {
+				id: "qwen/qwen3-max-thinking",
+				name: "Qwen3 Max Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.78,
+					output: 3.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-09",
+				family: "qwen",
+			},
+			"anthropic/claude-opus-4.6": {
+				id: "anthropic/claude-opus-4.6",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"openai/gpt-5.3-codex": {
+				id: "openai/gpt-5.3-codex",
+				name: "GPT-5.3 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-05",
+				family: "gpt-codex",
+			},
+			"qwen/qwen3-coder-next": {
+				id: "qwen/qwen3-coder-next",
+				name: "Qwen3 Coder Next",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.11,
+					output: 0.8,
+					cacheRead: 0.07,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-04",
+				family: "qwen",
+			},
+			"openrouter/free": {
+				id: "openrouter/free",
+				name: "Free Models Router",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 8000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-01",
+			},
+			"stepfun/step-3.5-flash": {
+				id: "stepfun/step-3.5-flash",
+				name: "Step 3.5 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-29",
+			},
+			"upstage/solar-pro-3": {
+				id: "upstage/solar-pro-3",
+				name: "Solar Pro 3",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-27",
+				family: "solar-pro",
+			},
+			"liquid/lfm-2.5-1.2b-thinking:free": {
+				id: "liquid/lfm-2.5-1.2b-thinking:free",
+				name: "LFM2.5-1.2B-Thinking (free)",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-20",
+				family: "liquid",
+			},
+			"openai/gpt-audio": {
+				id: "openai/gpt-audio",
+				name: "GPT Audio",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "gpt",
+			},
+			"openai/gpt-audio-mini": {
+				id: "openai/gpt-audio-mini",
+				name: "GPT Audio Mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "o-mini",
+			},
+			"z-ai/glm-4.7-flash": {
+				id: "z-ai/glm-4.7-flash",
+				name: "GLM-4.7-Flash",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.06,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "glm-flash",
+			},
+			"moonshotai/kimi-k2.5": {
+				id: "moonshotai/kimi-k2.5",
+				name: "Kimi K2.5",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.375,
+					output: 2.025,
+					cacheRead: 0.203,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01",
+				family: "kimi-k2",
+			},
+			"bytedance-seed/seed-1.6": {
+				id: "bytedance-seed/seed-1.6",
+				name: "Seed 1.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "seed",
+			},
+			"bytedance-seed/seed-1.6-flash": {
+				id: "bytedance-seed/seed-1.6-flash",
+				name: "Seed 1.6 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "seed",
+			},
+			"minimax/minimax-m2.1": {
+				id: "minimax/minimax-m2.1",
+				name: "MiniMax-M2.1",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"z-ai/glm-4.7": {
+				id: "z-ai/glm-4.7",
+				name: "GLM-4.7",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.75,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"google/gemini-3-flash-preview": {
+				id: "google/gemini-3-flash-preview",
+				name: "Gemini 3 Flash Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-12-17",
+				family: "gemini-flash",
+			},
+			"nvidia/nemotron-3-nano-30b-a3b": {
+				id: "nvidia/nemotron-3-nano-30b-a3b",
+				name: "Nemotron 3 Nano 30B A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 228000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-15",
+				family: "nemotron",
+			},
+			"nvidia/nemotron-3-nano-30b-a3b:free": {
+				id: "nvidia/nemotron-3-nano-30b-a3b:free",
+				name: "Nemotron 3 Nano 30B A3B (free)",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-15",
+				family: "nemotron",
+			},
+			"openai/gpt-5.2": {
+				id: "openai/gpt-5.2",
+				name: "GPT-5.2",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"openai/gpt-5.2-codex": {
+				id: "openai/gpt-5.2-codex",
+				name: "GPT-5.2 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.2-pro": {
+				id: "openai/gpt-5.2-pro",
+				name: "GPT-5.2 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+				],
+				pricing: {
+					input: 21,
+					output: 168,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-pro",
+			},
+			"openai/gpt-5.2-chat": {
+				id: "openai/gpt-5.2-chat",
+				name: "GPT-5.2 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-10",
+				family: "gpt-codex",
+			},
+			"relace/relace-search": {
+				id: "relace/relace-search",
+				name: "Relace Search",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 128000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-08",
+			},
+			"z-ai/glm-4.6v": {
+				id: "z-ai/glm-4.6v",
+				name: "GLM-4.6V",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0.055,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-08",
+				family: "glm",
+			},
+			"amazon/nova-2-lite-v1": {
+				id: "amazon/nova-2-lite-v1",
+				name: "Nova 2 Lite",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65535,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "nova",
+			},
+			"mistralai/ministral-14b-2512": {
+				id: "mistralai/ministral-14b-2512",
+				name: "Ministral 3 14B 2512",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.2,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "ministral",
+			},
+			"mistralai/ministral-3b-2512": {
+				id: "mistralai/ministral-3b-2512",
+				name: "Ministral 3 3B 2512",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "ministral",
+			},
+			"mistralai/ministral-8b-2512": {
+				id: "mistralai/ministral-8b-2512",
+				name: "Ministral 3 8B 2512",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-02",
+				family: "ministral",
+			},
+			"arcee-ai/trinity-mini": {
+				id: "arcee-ai/trinity-mini",
+				name: "Trinity Mini",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.045,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "trinity-mini",
+			},
+			"deepseek/deepseek-chat": {
+				id: "deepseek/deepseek-chat",
+				name: "DeepSeek Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16000,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.2002,
+					output: 0.8001,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "deepseek",
+			},
+			"deepseek/deepseek-v3.2": {
+				id: "deepseek/deepseek-v3.2",
+				name: "DeepSeek V3.2",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 64000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2288,
+					output: 0.3432,
+					cacheRead: 0.02288,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "deepseek",
+			},
+			"anthropic/claude-opus-4.5": {
+				id: "anthropic/claude-opus-4.5",
+				name: "Claude Opus 4.5 (latest)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"openai/gpt-5.1": {
+				id: "openai/gpt-5.1",
+				name: "GPT-5.1",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt",
+			},
+			"openai/gpt-5.1-chat": {
+				id: "openai/gpt-5.1-chat",
+				name: "GPT-5.1 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.1-codex": {
+				id: "openai/gpt-5.1-codex",
+				name: "GPT-5.1 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.1-codex-max": {
+				id: "openai/gpt-5.1-codex-max",
+				name: "GPT-5.1 Codex Max",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.1-codex-mini": {
+				id: "openai/gpt-5.1-codex-mini",
+				name: "GPT-5.1 Codex mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"moonshotai/kimi-k2-thinking": {
+				id: "moonshotai/kimi-k2-thinking",
+				name: "Kimi K2 Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 100352,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-06",
+				family: "kimi-thinking",
+			},
+			"amazon/nova-premier-v1": {
+				id: "amazon/nova-premier-v1",
+				name: "Nova Premier 1.0",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 2.5,
+					output: 12.5,
+					cacheRead: 0.625,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-31",
+				family: "nova",
+			},
+			"mistralai/voxtral-small-24b-2507": {
+				id: "mistralai/voxtral-small-24b-2507",
+				name: "Voxtral Small 24B 2507",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 32000,
+				capabilities: [
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-30",
+				family: "mistral",
+			},
+			"openai/gpt-oss-safeguard-20b": {
+				id: "openai/gpt-oss-safeguard-20b",
+				name: "gpt-oss-safeguard-20b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0.0375,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-29",
+				family: "gpt-oss",
+			},
+			"nvidia/nemotron-nano-12b-v2-vl:free": {
+				id: "nvidia/nemotron-nano-12b-v2-vl:free",
+				name: "Nemotron Nano 12B 2 VL (free)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-28",
+				family: "nemotron",
+			},
+			"minimax/minimax-m2": {
+				id: "minimax/minimax-m2",
+				name: "MiniMax-M2",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.255,
+					output: 1.02,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-27",
+				family: "minimax",
+			},
+			"qwen/qwen3-vl-32b-instruct": {
+				id: "qwen/qwen3-vl-32b-instruct",
+				name: "Qwen3 VL 32B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.104,
+					output: 0.416,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-23",
+				family: "qwen",
+			},
+			"anthropic/claude-haiku-4.5": {
+				id: "anthropic/claude-haiku-4.5",
+				name: "Claude Haiku 4.5 (latest)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"qwen/qwen3-vl-8b-instruct": {
+				id: "qwen/qwen3-vl-8b-instruct",
+				name: "Qwen3 VL 8B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.117,
+					output: 0.455,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-14",
+				family: "qwen",
+			},
+			"qwen/qwen3-vl-8b-thinking": {
+				id: "qwen/qwen3-vl-8b-thinking",
+				name: "Qwen3 VL 8B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.117,
+					output: 1.365,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-14",
+				family: "qwen",
+			},
+			"openai/gpt-5-pro": {
+				id: "openai/gpt-5-pro",
+				name: "GPT-5 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+				],
+				pricing: {
+					input: 15,
+					output: 120,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+				family: "gpt-pro",
+			},
+			"qwen/qwen3-vl-30b-a3b-instruct": {
+				id: "qwen/qwen3-vl-30b-a3b-instruct",
+				name: "Qwen3 VL 30B A3B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.13,
+					output: 0.52,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+				family: "qwen",
+			},
+			"qwen/qwen3-vl-30b-a3b-thinking": {
+				id: "qwen/qwen3-vl-30b-a3b-thinking",
+				name: "Qwen3 VL 30B A3B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.13,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+				family: "qwen",
+			},
+			"z-ai/glm-4.6": {
+				id: "z-ai/glm-4.6",
+				name: "GLM-4.6",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.43,
+					output: 1.74,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+				family: "glm",
+			},
+			"anthropic/claude-sonnet-4.5": {
+				id: "anthropic/claude-sonnet-4.5",
+				name: "Claude Sonnet 4.5 (latest)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"deepseek/deepseek-v3.2-exp": {
+				id: "deepseek/deepseek-v3.2-exp",
+				name: "DeepSeek V3.2 Exp",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.27,
+					output: 0.41,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-29",
+				family: "deepseek",
+			},
+			"google/gemini-2.5-flash-lite-preview-09-2025": {
+				id: "google/gemini-2.5-flash-lite-preview-09-2025",
+				name: "Gemini 2.5 Flash Lite Preview 09-2025",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-09-25",
+				family: "gemini-flash-lite",
+			},
+			"qwen/qwen3-max": {
+				id: "qwen/qwen3-max",
+				name: "Qwen3 Max",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.78,
+					output: 3.9,
+					cacheRead: 0.156,
+					cacheWrite: 0.975,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"qwen/qwen3-vl-235b-a22b-instruct": {
+				id: "qwen/qwen3-vl-235b-a22b-instruct",
+				name: "Qwen3 VL 235B A22B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.88,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"qwen/qwen3-vl-235b-a22b-thinking": {
+				id: "qwen/qwen3-vl-235b-a22b-thinking",
+				name: "Qwen3 VL 235B A22B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.26,
+					output: 2.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"deepseek/deepseek-v3.1-terminus": {
+				id: "deepseek/deepseek-v3.1-terminus",
+				name: "DeepSeek V3.1 Terminus",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.27,
+					output: 0.95,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-22",
+				family: "deepseek",
+			},
+			"openai/gpt-5-codex": {
+				id: "openai/gpt-5-codex",
+				name: "GPT-5-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-15",
+				family: "gpt-codex",
+			},
+			"qwen/qwen-plus-2025-07-28": {
+				id: "qwen/qwen-plus-2025-07-28",
+				name: "Qwen Plus 0728",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32768,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.26,
+					output: 0.78,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-08",
+				family: "qwen",
+			},
+			"qwen/qwen-plus-2025-07-28:thinking": {
+				id: "qwen/qwen-plus-2025-07-28:thinking",
+				name: "Qwen Plus 0728 (thinking)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.26,
+					output: 0.78,
+					cacheRead: 0,
+					cacheWrite: 0.325,
+				},
+				releaseDate: "2025-09-08",
+				family: "qwen",
+			},
+			"moonshotai/kimi-k2-0905": {
+				id: "moonshotai/kimi-k2-0905",
+				name: "Kimi K2 0905",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 100352,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-04",
+				family: "kimi-k2",
+			},
+			"qwen/qwen3-next-80b-a3b-instruct": {
+				id: "qwen/qwen3-next-80b-a3b-instruct",
+				name: "Qwen3-Next 80B-A3B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.09,
+					output: 1.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09",
+				family: "qwen",
+			},
+			"qwen/qwen3-next-80b-a3b-instruct:free": {
+				id: "qwen/qwen3-next-80b-a3b-instruct:free",
+				name: "Qwen3 Next 80B A3B Instruct (free)",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09",
+				family: "qwen",
+			},
+			"qwen/qwen3-next-80b-a3b-thinking": {
+				id: "qwen/qwen3-next-80b-a3b-thinking",
+				name: "Qwen3-Next 80B-A3B (Thinking)",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.0975,
+					output: 0.78,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09",
+				family: "qwen",
+			},
+			"qwen/qwen3-30b-a3b-thinking-2507": {
+				id: "qwen/qwen3-30b-a3b-thinking-2507",
+				name: "Qwen3 30B A3B Thinking 2507",
+				contextWindow: 81920,
+				maxInputTokens: 81920,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.13,
+					output: 1.56,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-28",
+				family: "qwen",
+			},
+			"deepseek/deepseek-chat-v3.1": {
+				id: "deepseek/deepseek-chat-v3.1",
+				name: "DeepSeek V3.1",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.21,
+					output: 0.79,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-21",
+				family: "deepseek",
+			},
+			"nvidia/nemotron-nano-9b-v2:free": {
+				id: "nvidia/nemotron-nano-9b-v2:free",
+				name: "Nemotron Nano 9B V2 (free)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-18",
+				family: "nemotron",
+			},
+			"mistralai/mistral-medium-3.1": {
+				id: "mistralai/mistral-medium-3.1",
+				name: "Mistral Medium 3.1",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-13",
+				family: "mistral-medium",
+			},
+			"z-ai/glm-4.5v": {
+				id: "z-ai/glm-4.5v",
+				name: "GLM-4.5V",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 1.8,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-11",
+				family: "glm",
+			},
+			"ai21/jamba-large-1.7": {
+				id: "ai21/jamba-large-1.7",
+				name: "Jamba Large 1.7",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-08",
+				family: "jamba",
+			},
+			"openai/gpt-5": {
+				id: "openai/gpt-5",
+				name: "GPT-5",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt",
+			},
+			"openai/gpt-5-mini": {
+				id: "openai/gpt-5-mini",
+				name: "GPT-5 Mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-mini",
+			},
+			"openai/gpt-5-nano": {
+				id: "openai/gpt-5-nano",
+				name: "GPT-5 Nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-nano",
+			},
+			"anthropic/claude-opus-4.1": {
+				id: "anthropic/claude-opus-4.1",
+				name: "Claude Opus 4.1 (latest)",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-08-05",
+				family: "claude-opus",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.03,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-120b:free": {
+				id: "openai/gpt-oss-120b:free",
+				name: "gpt-oss-120b (free)",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.029,
+					output: 0.14,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b:free": {
+				id: "openai/gpt-oss-20b:free",
+				name: "gpt-oss-20b (free)",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"mistralai/codestral-2508": {
+				id: "mistralai/codestral-2508",
+				name: "Codestral 2508",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-01",
+				family: "codestral",
+			},
+			"qwen/qwen3-30b-a3b-instruct-2507": {
+				id: "qwen/qwen3-30b-a3b-instruct-2507",
+				name: "Qwen3 30B A3B Instruct 2507",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32000,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.04815,
+					output: 0.19305,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-29",
+				family: "qwen",
+			},
+			"qwen/qwen3-coder-flash": {
+				id: "qwen/qwen3-coder-flash",
+				name: "Qwen3 Coder Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.195,
+					output: 0.975,
+					cacheRead: 0.039,
+					cacheWrite: 0.24375,
+				},
+				releaseDate: "2025-07-28",
+				family: "qwen",
+			},
+			"z-ai/glm-4.5": {
+				id: "z-ai/glm-4.5",
+				name: "GLM-4.5",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm",
+			},
+			"z-ai/glm-4.5-air": {
+				id: "z-ai/glm-4.5-air",
+				name: "GLM-4.5-Air",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.13,
+					output: 0.85,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm-air",
+			},
+			"nvidia/llama-3.3-nemotron-super-49b-v1.5": {
+				id: "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+				name: "Llama 3.3 Nemotron Super 49B v1.5",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+				family: "nemotron",
+			},
+			"qwen/qwen3-235b-a22b-thinking-2507": {
+				id: "qwen/qwen3-235b-a22b-thinking-2507",
+				name: "Qwen3 235B A22B Thinking 2507",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 262144,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.1495,
+					output: 1.495,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+				family: "qwen",
+			},
+			"qwen/qwen3-coder": {
+				id: "qwen/qwen3-coder",
+				name: "Qwen3 Coder 480B A35B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 1.8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+				family: "qwen",
+			},
+			"qwen/qwen3-coder-plus": {
+				id: "qwen/qwen3-coder-plus",
+				name: "Qwen3 Coder Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.65,
+					output: 3.25,
+					cacheRead: 0.13,
+					cacheWrite: 0.8125,
+				},
+				releaseDate: "2025-07-23",
+				family: "qwen",
+			},
+			"qwen/qwen3-coder:free": {
+				id: "qwen/qwen3-coder:free",
+				name: "Qwen3 Coder 480B A35B (free)",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+				family: "qwen",
+			},
+			"qwen/qwen3-235b-a22b-2507": {
+				id: "qwen/qwen3-235b-a22b-2507",
+				name: "Qwen3 235B A22B Instruct 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.09,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-21",
+				family: "qwen",
+			},
+			"moonshotai/kimi-k2": {
+				id: "moonshotai/kimi-k2",
+				name: "Kimi K2 0711",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 100352,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.57,
+					output: 2.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-11",
+				family: "kimi-k2",
+			},
+			"mistralai/mistral-small-3.2-24b-instruct": {
+				id: "mistralai/mistral-small-3.2-24b-instruct",
+				name: "Mistral Small 3.2 24B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.075,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-20",
+				family: "mistral-small",
+			},
+			"google/gemini-2.5-flash": {
+				id: "google/gemini-2.5-flash",
+				name: "Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.03,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash",
+			},
+			"google/gemini-2.5-flash-lite": {
+				id: "google/gemini-2.5-flash-lite",
+				name: "Gemini 2.5 Flash-Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0.083333,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash-lite",
+			},
+			"google/gemini-2.5-pro": {
+				id: "google/gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-pro",
+			},
+			"minimax/minimax-m1": {
+				id: "minimax/minimax-m1",
+				name: "MiniMax M1",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 40000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "minimax",
+			},
+			"openai/o3-pro": {
+				id: "openai/o3-pro",
+				name: "o3-pro",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+				],
+				pricing: {
+					input: 20,
+					output: 80,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-10",
+				family: "o-pro",
+			},
+			"google/gemini-2.5-pro-preview": {
+				id: "google/gemini-2.5-pro-preview",
+				name: "Gemini 2.5 Pro Preview 06-05",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-06-05",
+				family: "gemini",
+			},
+			"deepseek/deepseek-r1-0528": {
+				id: "deepseek/deepseek-r1-0528",
+				name: "R1 0528",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 2.15,
+					cacheRead: 0.35,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-28",
+				family: "deepseek",
+			},
+			"anthropic/claude-opus-4": {
+				id: "anthropic/claude-opus-4",
+				name: "Claude Opus 4",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-opus",
+			},
+			"anthropic/claude-sonnet-4": {
+				id: "anthropic/claude-sonnet-4",
+				name: "Claude Sonnet 4",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-sonnet",
+			},
+			"google/gemini-2.5-pro-preview-05-06": {
+				id: "google/gemini-2.5-pro-preview-05-06",
+				name: "Gemini 2.5 Pro Preview 05-06",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65535,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-05-07",
+				family: "gemini-pro",
+			},
+			"mistralai/mistral-medium-3": {
+				id: "mistralai/mistral-medium-3",
+				name: "Mistral Medium 3",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-07",
+				family: "mistral-medium",
+			},
+			"arcee-ai/virtuoso-large": {
+				id: "arcee-ai/virtuoso-large",
+				name: "Virtuoso Large",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 64000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.75,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-05",
+			},
+			"qwen/qwen3-14b": {
+				id: "qwen/qwen3-14b",
+				name: "Qwen3 14B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 40960,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.24,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"qwen/qwen3-30b-a3b": {
+				id: "qwen/qwen3-30b-a3b",
+				name: "Qwen3 30B A3B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.12,
+					output: 0.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"qwen/qwen3-8b": {
+				id: "qwen/qwen3-8b",
+				name: "Qwen3 8B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.117,
+					output: 0.455,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"openai/o3": {
+				id: "openai/o3",
+				name: "o3",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o",
+			},
+			"openai/o4-mini": {
+				id: "openai/o4-mini",
+				name: "o4-mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.275,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o-mini",
+			},
+			"openai/o4-mini-high": {
+				id: "openai/o4-mini-high",
+				name: "o4 Mini High",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.275,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o",
+			},
+			"openai/gpt-4.1": {
+				id: "openai/gpt-4.1",
+				name: "GPT-4.1",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt",
+			},
+			"openai/gpt-4.1-mini": {
+				id: "openai/gpt-4.1-mini",
+				name: "GPT-4.1 mini",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-mini",
+			},
+			"openai/gpt-4.1-nano": {
+				id: "openai/gpt-4.1-nano",
+				name: "GPT-4.1 nano",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-nano",
+			},
+			"meta-llama/llama-4-maverick": {
+				id: "meta-llama/llama-4-maverick",
+				name: "Llama 4 Maverick",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"meta-llama/llama-4-scout": {
+				id: "meta-llama/llama-4-scout",
+				name: "Llama 4 Scout",
+				contextWindow: 327680,
+				maxInputTokens: 327680,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"qwen/qwen3-235b-a22b": {
+				id: "qwen/qwen3-235b-a22b",
+				name: "Qwen3 235B-A22B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.455,
+					output: 1.82,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+				family: "qwen",
+			},
+			"qwen/qwen3-32b": {
+				id: "qwen/qwen3-32b",
+				name: "Qwen3 32B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.08,
+					output: 0.28,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+				family: "qwen",
+			},
+			"qwen/qwen3-coder-30b-a3b-instruct": {
+				id: "qwen/qwen3-coder-30b-a3b-instruct",
+				name: "Qwen3-Coder 30B-A3B Instruct",
+				contextWindow: 160000,
+				maxInputTokens: 160000,
+				maxTokens: 32768,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.27,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04",
+				family: "qwen",
+			},
+			"deepseek/deepseek-chat-v3-0324": {
+				id: "deepseek/deepseek-chat-v3-0324",
+				name: "DeepSeek V3 0324",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.24,
+					output: 0.9,
+					cacheRead: 0.135,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-24",
+				family: "deepseek",
+			},
+			"google/gemma-3-12b-it": {
+				id: "google/gemma-3-12b-it",
+				name: "Gemma 3 12B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.05,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-13",
+				family: "gemma",
+			},
+			"google/gemma-3-27b-it": {
+				id: "google/gemma-3-27b-it",
+				name: "Gemma 3 27B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.08,
+					output: 0.16,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-12",
+				family: "gemma",
+			},
+			"mistralai/mistral-saba": {
+				id: "mistralai/mistral-saba",
+				name: "Saba",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: [
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-02-17",
+				family: "mistral",
+			},
+			"openai/o3-mini-high": {
+				id: "openai/o3-mini-high",
+				name: "o3 Mini High",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-02-12",
+				family: "o",
+			},
+			"deepseek/deepseek-r1": {
+				id: "deepseek/deepseek-r1",
+				name: "DeepSeek-R1",
+				contextWindow: 64000,
+				maxInputTokens: 64000,
+				maxTokens: 16000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.7,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-20",
+				family: "deepseek-thinking",
+			},
+			"openai/o3-mini": {
+				id: "openai/o3-mini",
+				name: "o3-mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-20",
+				family: "o-mini",
+			},
+			"meta-llama/llama-3.3-70b-instruct": {
+				id: "meta-llama/llama-3.3-70b-instruct",
+				name: "Llama-3.3-70B-Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.32,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+			"meta-llama/llama-3.3-70b-instruct:free": {
+				id: "meta-llama/llama-3.3-70b-instruct:free",
+				name: "Llama 3.3 70B Instruct (free)",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 131072,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+			"amazon/nova-lite-v1": {
+				id: "amazon/nova-lite-v1",
+				name: "Nova Lite 1.0",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 5120,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+				family: "nova-lite",
+			},
+			"amazon/nova-micro-v1": {
+				id: "amazon/nova-micro-v1",
+				name: "Nova Micro 1.0",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 5120,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.035,
+					output: 0.14,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+				family: "nova-micro",
+			},
+			"amazon/nova-pro-v1": {
+				id: "amazon/nova-pro-v1",
+				name: "Nova Pro 1.0",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 5120,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.8,
+					output: 3.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+				family: "nova-pro",
+			},
+			"openai/o1": {
+				id: "openai/o1",
+				name: "o1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 60,
+					cacheRead: 7.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+				family: "o",
+			},
+			"openai/gpt-4o-2024-11-20": {
+				id: "openai/gpt-4o-2024-11-20",
+				name: "GPT-4o (2024-11-20)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-20",
+				family: "gpt",
+			},
+			"mistralai/mistral-large-2407": {
+				id: "mistralai/mistral-large-2407",
+				name: "Mistral Large 2407",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-19",
+				family: "mistral-large",
+			},
+			"thedrummer/unslopnemo-12b": {
+				id: "thedrummer/unslopnemo-12b",
+				name: "UnslopNemo 12B",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-08",
+			},
+			"mistralai/mistral-large-2512": {
+				id: "mistralai/mistral-large-2512",
+				name: "Mistral Large 3",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-01",
+				family: "mistral-large",
+			},
+			"qwen/qwen-2.5-7b-instruct": {
+				id: "qwen/qwen-2.5-7b-instruct",
+				name: "Qwen2.5 7B Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.04,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-10-16",
+				family: "qwen",
+			},
+			"qwen/qwen-2.5-72b-instruct": {
+				id: "qwen/qwen-2.5-72b-instruct",
+				name: "Qwen2.5 72B Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.36,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-19",
+				family: "qwen",
+			},
+			"cohere/command-r-08-2024": {
+				id: "cohere/command-r-08-2024",
+				name: "Command R",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4000,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-30",
+				family: "command-r",
+			},
+			"cohere/command-r-plus-08-2024": {
+				id: "cohere/command-r-plus-08-2024",
+				name: "Command R+",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4000,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-30",
+				family: "command-r",
+			},
+			"sao10k/l3.1-euryale-70b": {
+				id: "sao10k/l3.1-euryale-70b",
+				name: "Llama 3.1 Euryale 70B v2.2",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.85,
+					output: 0.85,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-28",
+				family: "llama",
+			},
+			"openai/gpt-4o-2024-08-06": {
+				id: "openai/gpt-4o-2024-08-06",
+				name: "GPT-4o (2024-08-06)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-08-06",
+				family: "gpt",
+			},
+			"meta-llama/llama-3.1-70b-instruct": {
+				id: "meta-llama/llama-3.1-70b-instruct",
+				name: "Llama 3.1 70B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+			"meta-llama/llama-3.1-8b-instruct": {
+				id: "meta-llama/llama-3.1-8b-instruct",
+				name: "Llama 3.1 8B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 16384,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.02,
+					output: 0.03,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+			"openai/gpt-4o-mini": {
+				id: "openai/gpt-4o-mini",
+				name: "GPT-4o mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+				family: "gpt-mini",
+			},
+			"openai/gpt-4o-mini-2024-07-18": {
+				id: "openai/gpt-4o-mini-2024-07-18",
+				name: "GPT-4o-mini (2024-07-18)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+				family: "o-mini",
+			},
+			"mistralai/mistral-nemo": {
+				id: "mistralai/mistral-nemo",
+				name: "Mistral Nemo",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.02,
+					output: 0.03,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-01",
+				family: "mistral-nemo",
+			},
+			"openai/o3-deep-research": {
+				id: "openai/o3-deep-research",
+				name: "o3-deep-research",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 40,
+					cacheRead: 2.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-26",
+				family: "o",
+			},
+			"openai/o4-mini-deep-research": {
+				id: "openai/o4-mini-deep-research",
+				name: "o4-mini-deep-research",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-06-26",
+				family: "o-mini",
+			},
+			"openai/gpt-4o": {
+				id: "openai/gpt-4o",
+				name: "GPT-4o",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+				family: "gpt",
+			},
+			"openai/gpt-4o-2024-05-13": {
+				id: "openai/gpt-4o-2024-05-13",
+				name: "GPT-4o (2024-05-13)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 5,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+				family: "gpt",
+			},
+			"mistralai/mixtral-8x22b-instruct": {
+				id: "mistralai/mixtral-8x22b-instruct",
+				name: "Mixtral 8x22B Instruct",
+				contextWindow: 65536,
+				maxInputTokens: 65536,
+				maxTokens: 65536,
+				capabilities: [
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-04-17",
+				family: "mistral",
+			},
+			"anthropic/claude-3-haiku": {
+				id: "anthropic/claude-3-haiku",
+				name: "Claude 3 Haiku",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 1.25,
+					cacheRead: 0.03,
+					cacheWrite: 0.3,
+				},
+				releaseDate: "2024-03-13",
+				family: "claude",
+			},
+			"mistralai/mistral-large": {
+				id: "mistralai/mistral-large",
+				name: "Mistral Large",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: [
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-02-26",
+				family: "mistral-large",
+			},
+			"openai/gpt-3.5-turbo-0613": {
+				id: "openai/gpt-3.5-turbo-0613",
+				name: "GPT-3.5 Turbo (older v0613)",
+				contextWindow: 4095,
+				maxInputTokens: 4095,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 1,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-01-25",
+				family: "gpt",
+			},
+			"openai/gpt-4-turbo-preview": {
+				id: "openai/gpt-4-turbo-preview",
+				name: "GPT-4 Turbo Preview",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-01-25",
+				family: "gpt",
+			},
+			"qwen/qwen-plus": {
+				id: "qwen/qwen-plus",
+				name: "Qwen Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.26,
+					output: 0.78,
+					cacheRead: 0.052,
+					cacheWrite: 0.325,
+				},
+				releaseDate: "2024-01-25",
+				family: "qwen",
+			},
+			"openrouter/auto": {
+				id: "openrouter/auto",
+				name: "Auto Router",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-08",
+				family: "auto",
+			},
+			"openai/gpt-4": {
+				id: "openai/gpt-4",
+				name: "GPT-4",
+				contextWindow: 8191,
+				maxInputTokens: 8191,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 30,
+					output: 60,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-06",
+				family: "gpt",
+			},
+			"openai/gpt-4-turbo": {
+				id: "openai/gpt-4-turbo",
+				name: "GPT-4 Turbo",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-06",
+				family: "gpt",
+			},
+			"openai/gpt-3.5-turbo-16k": {
+				id: "openai/gpt-3.5-turbo-16k",
+				name: "GPT-3.5 Turbo 16k",
+				contextWindow: 16385,
+				maxInputTokens: 16385,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 3,
+					output: 4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-08-28",
+				family: "gpt",
+			},
+			"openai/gpt-3.5-turbo": {
+				id: "openai/gpt-3.5-turbo",
+				name: "GPT-3.5-turbo",
+				contextWindow: 16385,
+				maxInputTokens: 16385,
+				maxTokens: 4096,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-03-01",
+				family: "gpt",
+			},
+		},
+		requesty: {
+			"openai/gpt-5.4": {
+				id: "openai/gpt-5.4",
+				name: "GPT-5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"openai/gpt-5.4-pro": {
+				id: "openai/gpt-5.4-pro",
+				name: "GPT-5.4 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 30,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt-pro",
+			},
+			"openai/gpt-5.3-codex": {
+				id: "openai/gpt-5.3-codex",
+				name: "GPT-5.3-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-24",
+				family: "gpt-codex",
+			},
+			"anthropic/claude-sonnet-4-6": {
+				id: "anthropic/claude-sonnet-4-6",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"anthropic/claude-opus-4-6": {
+				id: "anthropic/claude-opus-4-6",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"openai/gpt-5.2-codex": {
+				id: "openai/gpt-5.2-codex",
+				name: "GPT-5.2-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-14",
+				family: "gpt-codex",
+			},
+			"google/gemini-3-flash-preview": {
+				id: "google/gemini-3-flash-preview",
+				name: "Gemini 3 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 1,
+				},
+				releaseDate: "2025-12-17",
+			},
+			"openai/gpt-5.2": {
+				id: "openai/gpt-5.2",
+				name: "GPT-5.2",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"openai/gpt-5.2-chat": {
+				id: "openai/gpt-5.2-chat",
+				name: "GPT-5.2 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.2-pro": {
+				id: "openai/gpt-5.2-pro",
+				name: "GPT-5.2 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 21,
+					output: 168,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt-pro",
+			},
+			"anthropic/claude-opus-4-5": {
+				id: "anthropic/claude-opus-4-5",
+				name: "Claude Opus 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"google/gemini-3-pro-preview": {
+				id: "google/gemini-3-pro-preview",
+				name: "Gemini 3 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 4.5,
+				},
+				releaseDate: "2025-11-18",
+				family: "gemini-pro",
+			},
+			"openai/gpt-5.1": {
+				id: "openai/gpt-5.1",
+				name: "GPT-5.1",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt",
+			},
+			"openai/gpt-5.1-chat": {
+				id: "openai/gpt-5.1-chat",
+				name: "GPT-5.1 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.1-codex": {
+				id: "openai/gpt-5.1-codex",
+				name: "GPT-5.1-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.1-codex-max": {
+				id: "openai/gpt-5.1-codex-max",
+				name: "GPT-5.1-Codex-Max",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 9,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"openai/gpt-5.1-codex-mini": {
+				id: "openai/gpt-5.1-codex-mini",
+				name: "GPT-5.1-Codex-Mini",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "gpt-codex",
+			},
+			"anthropic/claude-haiku-4-5": {
+				id: "anthropic/claude-haiku-4-5",
+				name: "Claude Haiku 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 62000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"openai/gpt-5-image": {
+				id: "openai/gpt-5-image",
+				name: "GPT-5 Image",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-14",
+				family: "gpt",
+			},
+			"openai/gpt-5-pro": {
+				id: "openai/gpt-5-pro",
+				name: "GPT-5 Pro",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 272000,
+				capabilities: ["images", "tools", "reasoning", "structured_output"],
+				pricing: {
+					input: 15,
+					output: 120,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+				family: "gpt-pro",
+			},
+			"anthropic/claude-sonnet-4-5": {
+				id: "anthropic/claude-sonnet-4-5",
+				name: "Claude Sonnet 4.5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"xai/grok-4-fast": {
+				id: "xai/grok-4-fast",
+				name: "Grok 4 Fast",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 64000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 0.5,
+					cacheRead: 0.05,
+					cacheWrite: 0.2,
+				},
+				releaseDate: "2025-09-19",
+				family: "grok",
+			},
+			"openai/gpt-5-codex": {
+				id: "openai/gpt-5-codex",
+				name: "GPT-5 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-15",
+				family: "gpt-codex",
+			},
+			"xai/grok-4": {
+				id: "xai/grok-4",
+				name: "Grok 4",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.75,
+					cacheWrite: 3,
+				},
+				releaseDate: "2025-09-09",
+				family: "grok",
+			},
+			"openai/gpt-5": {
+				id: "openai/gpt-5",
+				name: "GPT-5",
+				contextWindow: 400000,
+				maxInputTokens: 400000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.13,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt",
+			},
+			"openai/gpt-5-mini": {
+				id: "openai/gpt-5-mini",
+				name: "GPT-5 Mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-mini",
+			},
+			"openai/gpt-5-nano": {
+				id: "openai/gpt-5-nano",
+				name: "GPT-5 Nano",
+				contextWindow: 16000,
+				maxInputTokens: 16000,
+				maxTokens: 4000,
+				capabilities: ["tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-nano",
+			},
+			"anthropic/claude-opus-4-1": {
+				id: "anthropic/claude-opus-4-1",
+				name: "Claude Opus 4.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-08-05",
+				family: "claude-opus",
+			},
+			"google/gemini-2.5-flash": {
+				id: "google/gemini-2.5-flash",
+				name: "Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.075,
+					cacheWrite: 0.55,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash",
+			},
+			"google/gemini-2.5-pro": {
+				id: "google/gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.31,
+					cacheWrite: 2.375,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-pro",
+			},
+			"anthropic/claude-opus-4": {
+				id: "anthropic/claude-opus-4",
+				name: "Claude Opus 4",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-opus",
+			},
+			"anthropic/claude-sonnet-4": {
+				id: "anthropic/claude-sonnet-4",
+				name: "Claude Sonnet 4",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-sonnet",
+			},
+			"openai/o4-mini": {
+				id: "openai/o4-mini",
+				name: "o4 Mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.28,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o-mini",
+			},
+			"openai/gpt-4.1": {
+				id: "openai/gpt-4.1",
+				name: "GPT-4.1",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt",
+			},
+			"openai/gpt-4.1-mini": {
+				id: "openai/gpt-4.1-mini",
+				name: "GPT-4.1 Mini",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-mini",
+			},
+			"anthropic/claude-3-7-sonnet": {
+				id: "anthropic/claude-3-7-sonnet",
+				name: "Claude Sonnet 3.7",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-02-19",
+				family: "claude-sonnet",
+			},
+			"openai/gpt-4o-mini": {
+				id: "openai/gpt-4o-mini",
+				name: "GPT-4o Mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.08,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+				family: "gpt-mini",
+			},
+		},
+		sapaicore: {
+			"anthropic--claude-4.8-opus": {
+				id: "anthropic--claude-4.8-opus",
+				name: "anthropic--claude-4.8-opus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"gpt-5.5": {
+				id: "gpt-5.5",
+				name: "gpt-5.5",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "gpt",
+			},
+			"anthropic--claude-4.7-opus": {
+				id: "anthropic--claude-4.7-opus",
+				name: "anthropic--claude-4.7-opus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"gpt-5.4": {
+				id: "gpt-5.4",
+				name: "gpt-5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"anthropic--claude-4.6-sonnet": {
+				id: "anthropic--claude-4.6-sonnet",
+				name: "anthropic--claude-4.6-sonnet",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"anthropic--claude-4.6-opus": {
+				id: "anthropic--claude-4.6-opus",
+				name: "anthropic--claude-4.6-opus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"anthropic--claude-4.5-opus": {
+				id: "anthropic--claude-4.5-opus",
+				name: "anthropic--claude-4.5-opus",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"anthropic--claude-4.5-haiku": {
+				id: "anthropic--claude-4.5-haiku",
+				name: "anthropic--claude-4.5-haiku",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"anthropic--claude-4.5-sonnet": {
+				id: "anthropic--claude-4.5-sonnet",
+				name: "anthropic--claude-4.5-sonnet",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"gpt-5": {
+				id: "gpt-5",
+				name: "gpt-5",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt",
+			},
+			"gpt-5-mini": {
+				id: "gpt-5-mini",
+				name: "gpt-5-mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-mini",
+			},
+			"gpt-5-nano": {
+				id: "gpt-5-nano",
+				name: "gpt-5-nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.005,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-nano",
+			},
+			"gemini-2.5-flash-lite": {
+				id: "gemini-2.5-flash-lite",
+				name: "gemini-2.5-flash-lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash-lite",
+			},
+			"anthropic--claude-4-opus": {
+				id: "anthropic--claude-4-opus",
+				name: "anthropic--claude-4-opus",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-opus",
+			},
+			"anthropic--claude-4-sonnet": {
+				id: "anthropic--claude-4-sonnet",
+				name: "anthropic--claude-4-sonnet",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-sonnet",
+			},
+			"gemini-2.5-flash": {
+				id: "gemini-2.5-flash",
+				name: "gemini-2.5-flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-17",
+				family: "gemini-flash",
+			},
+			"gpt-4.1": {
+				id: "gpt-4.1",
+				name: "gpt-4.1",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt",
+			},
+			"gpt-4.1-mini": {
+				id: "gpt-4.1-mini",
+				name: "gpt-4.1-mini",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-mini",
+			},
+			"gemini-2.5-pro": {
+				id: "gemini-2.5-pro",
+				name: "gemini-2.5-pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-25",
+				family: "gemini-pro",
+			},
+			"anthropic--claude-3.7-sonnet": {
+				id: "anthropic--claude-3.7-sonnet",
+				name: "anthropic--claude-3.7-sonnet",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-02-24",
+				family: "claude-sonnet",
+			},
+			"anthropic--claude-3.5-sonnet": {
+				id: "anthropic--claude-3.5-sonnet",
+				name: "anthropic--claude-3.5-sonnet",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 8192,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2024-10-22",
+				family: "claude-sonnet",
+			},
+			"anthropic--claude-3-haiku": {
+				id: "anthropic--claude-3-haiku",
+				name: "anthropic--claude-3-haiku",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 4096,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.25,
+					cacheRead: 0.03,
+					cacheWrite: 0.3,
+				},
+				releaseDate: "2024-03-13",
+				family: "claude-haiku",
+			},
+			"anthropic--claude-3-sonnet": {
+				id: "anthropic--claude-3-sonnet",
+				name: "anthropic--claude-3-sonnet",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 4096,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2024-03-04",
+				family: "claude-sonnet",
+			},
+			"anthropic--claude-3-opus": {
+				id: "anthropic--claude-3-opus",
+				name: "anthropic--claude-3-opus",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 4096,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2024-02-29",
+				family: "claude-opus",
+			},
+		},
+		"tencent-tokenhub": {
+			hy3: {
+				id: "hy3",
+				name: "Hy3",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 64000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-06",
+				family: "Hy",
+			},
+			"hy3-preview": {
+				id: "hy3-preview",
+				name: "Hy3 preview",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 64000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+				family: "Hy",
+			},
+		},
+		together: {
+			"zai-org/GLM-5.2": {
+				id: "zai-org/GLM-5.2",
+				name: "GLM-5.2",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 164000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-16",
+				family: "glm",
+			},
+			"moonshotai/Kimi-K2.7-Code": {
+				id: "moonshotai/Kimi-K2.7-Code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.19,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-14",
+				family: "kimi-k2",
+			},
+			"MiniMaxAI/MiniMax-M3": {
+				id: "MiniMaxAI/MiniMax-M3",
+				name: "MiniMax-M3",
+				contextWindow: 524288,
+				maxInputTokens: 524288,
+				maxTokens: 250000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "minimax",
+			},
+			"nvidia/nemotron-3-ultra-550b-a55b": {
+				id: "nvidia/nemotron-3-ultra-550b-a55b",
+				name: "Nemotron 3 Ultra 550B A55B",
+				contextWindow: 512300,
+				maxInputTokens: 512300,
+				maxTokens: 512300,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3.6,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"Qwen/Qwen3.7-Max": {
+				id: "Qwen/Qwen3.7-Max",
+				name: "Qwen3.7 Max",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 500000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1.25,
+					output: 3.75,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-21",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.6-Plus": {
+				id: "Qwen/Qwen3.6-Plus",
+				name: "Qwen3.6 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 500000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-30",
+				family: "qwen",
+			},
+			"deepseek-ai/DeepSeek-V4-Pro": {
+				id: "deepseek-ai/DeepSeek-V4-Pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 512000,
+				maxInputTokens: 512000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.74,
+					output: 3.48,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek",
+			},
+			"moonshotai/Kimi-K2.6": {
+				id: "moonshotai/Kimi-K2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-21",
+				family: "kimi-k2",
+			},
+			"google/gemma-4-31B-it": {
+				id: "google/gemma-4-31B-it",
+				name: "Gemma 4 31B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.39,
+					output: 0.97,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "gemma",
+			},
+			"zai-org/GLM-5.1": {
+				id: "zai-org/GLM-5.1",
+				name: "GLM-5.1",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "glm",
+			},
+			"MiniMaxAI/MiniMax-M2.7": {
+				id: "MiniMaxAI/MiniMax-M2.7",
+				name: "MiniMax-M2.7",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"Qwen/Qwen3.5-9B": {
+				id: "Qwen/Qwen3.5-9B",
+				name: "Qwen3.5 9B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.17,
+					output: 0.25,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-03",
+				family: "qwen",
+			},
+			"Qwen/Qwen3.5-397B-A17B": {
+				id: "Qwen/Qwen3.5-397B-A17B",
+				name: "Qwen3.5 397B A17B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 130000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 3.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-16",
+				family: "qwen",
+			},
+			"zai-org/GLM-5": {
+				id: "zai-org/GLM-5",
+				name: "GLM-5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 1,
+					output: 3.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-11",
+				family: "glm",
+			},
+			"essentialai/Rnj-1-Instruct": {
+				id: "essentialai/Rnj-1-Instruct",
+				name: "Rnj-1 Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-05",
+				family: "rnj",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"Qwen/Qwen3-235B-A22B-Instruct-2507-tput": {
+				id: "Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
+				name: "Qwen3 235B A22B Instruct 2507 FP8",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-25",
+				family: "qwen",
+			},
+			"meta-llama/Llama-3.3-70B-Instruct-Turbo": {
+				id: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+				name: "Llama 3.3 70B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 1.04,
+					output: 1.04,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+			"Qwen/Qwen2.5-7B-Instruct-Turbo": {
+				id: "Qwen/Qwen2.5-7B-Instruct-Turbo",
+				name: "Qwen 2.5 7B Instruct Turbo",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-19",
+				family: "qwen",
+			},
+		},
+		v0: {
+			"v0-1.5-lg": {
+				id: "v0-1.5-lg",
+				name: "v0-1.5-lg",
+				contextWindow: 512000,
+				maxInputTokens: 512000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-09",
+				family: "v0",
+			},
+			"v0-1.5-md": {
+				id: "v0-1.5-md",
+				name: "v0-1.5-md",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-09",
+				family: "v0",
+			},
+			"v0-1.0-md": {
+				id: "v0-1.0-md",
+				name: "v0-1.0-md",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-22",
+				family: "v0",
+			},
+		},
+		"vercel-ai-gateway": {
+			"xai/grok-4.5": {
+				id: "xai/grok-4.5",
+				name: "Grok 4.5",
+				contextWindow: 500000,
+				maxInputTokens: 500000,
+				maxTokens: 500000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-08",
+				family: "grok",
+			},
+			"anthropic/claude-fable-5": {
+				id: "anthropic/claude-fable-5",
+				name: "Claude Fable 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 50,
+					cacheRead: 1,
+					cacheWrite: 12.5,
+				},
+				releaseDate: "2026-07-01",
+				family: "claude-fable",
+			},
+			"anthropic/claude-sonnet-5": {
+				id: "anthropic/claude-sonnet-5",
+				name: "Claude Sonnet 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-29",
+				family: "claude-sonnet",
+			},
+			"sakana/fugu-ultra": {
+				id: "sakana/fugu-ultra",
+				name: "Fugu Ultra",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-21",
+				family: "aura",
+			},
+			"zai/glm-5.2": {
+				id: "zai/glm-5.2",
+				name: "GLM 5.2",
+				contextWindow: 1040000,
+				maxInputTokens: 1040000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-16",
+				family: "glm",
+			},
+			"zai/glm-5.2-fast": {
+				id: "zai/glm-5.2-fast",
+				name: "GLM 5.2 Fast",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 3,
+					output: 10.25,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-16",
+				family: "glm",
+			},
+			"moonshotai/kimi-k2.7-code-highspeed": {
+				id: "moonshotai/kimi-k2.7-code-highspeed",
+				name: "Kimi K2.7 Code High Speed",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.9,
+					output: 8,
+					cacheRead: 0.38,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-15",
+				family: "kimi-k2",
+			},
+			"moonshotai/kimi-k2.7-code": {
+				id: "moonshotai/kimi-k2.7-code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.19,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"nvidia/nemotron-3-ultra-550b-a55b": {
+				id: "nvidia/nemotron-3-ultra-550b-a55b",
+				name: "Nemotron 3 Ultra",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"alibaba/qwen3.7-plus": {
+				id: "alibaba/qwen3.7-plus",
+				name: "Qwen 3.7 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.08,
+					cacheWrite: 0.5,
+				},
+				releaseDate: "2026-06-02",
+				family: "qwen3.7-plus",
+			},
+			"minimax/minimax-m3": {
+				id: "minimax/minimax-m3",
+				name: "MiniMax M3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-31",
+				family: "minimax-m3",
+			},
+			"anthropic/claude-opus-4.8": {
+				id: "anthropic/claude-opus-4.8",
+				name: "Claude Opus 4.8",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"stepfun/step-3.7-flash": {
+				id: "stepfun/step-3.7-flash",
+				name: "Step 3.7 Flash",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 1.15,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-28",
+				family: "step",
+			},
+			"alibaba/qwen3.7-max": {
+				id: "alibaba/qwen3.7-max",
+				name: "Qwen 3.7 Max",
+				contextWindow: 991000,
+				maxInputTokens: 991000,
+				maxTokens: 64000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.25,
+					output: 3.75,
+					cacheRead: 0.25,
+					cacheWrite: 1.5625,
+				},
+				releaseDate: "2026-05-21",
+				family: "qwen",
+			},
+			"xai/grok-build-0.1": {
+				id: "xai/grok-build-0.1",
+				name: "Grok Build 0.1",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-20",
+				family: "grok-build",
+			},
+			"google/gemini-3.5-flash": {
+				id: "google/gemini-3.5-flash",
+				name: "Gemini 3.5 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.5,
+					output: 9,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-19",
+				family: "gemini",
+			},
+			"google/gemini-3.1-flash-lite": {
+				id: "google/gemini-3.1-flash-lite",
+				name: "Gemini 3.1 Flash Lite",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-07",
+				family: "gemini",
+			},
+			"xai/grok-4.3": {
+				id: "xai/grok-4.3",
+				name: "Grok 4.3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-30",
+				family: "grok",
+			},
+			"mistral/mistral-medium-3.5": {
+				id: "mistral/mistral-medium-3.5",
+				name: "Mistral Medium Latest",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 1.5,
+					output: 7.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-29",
+				family: "mistral-medium",
+			},
+			"openai/gpt-5.5": {
+				id: "openai/gpt-5.5",
+				name: "GPT 5.5",
+				contextWindow: 1000000,
+				maxInputTokens: 872000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 30,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "gpt",
+			},
+			"openai/gpt-5.5-pro": {
+				id: "openai/gpt-5.5-pro",
+				name: "GPT 5.5 Pro",
+				contextWindow: 1000000,
+				maxInputTokens: 872000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "gpt",
+			},
+			"deepseek/deepseek-v4-flash": {
+				id: "deepseek/deepseek-v4-flash",
+				name: "DeepSeek V4 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "deepseek",
+			},
+			"deepseek/deepseek-v4-pro": {
+				id: "deepseek/deepseek-v4-pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 384000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.0036,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-23",
+				family: "deepseek",
+			},
+			"alibaba/qwen3.6-27b": {
+				id: "alibaba/qwen3.6-27b",
+				name: "Qwen 3.6 27B",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "qwen3.6",
+			},
+			"xiaomi/mimo-v2.5": {
+				id: "xiaomi/mimo-v2.5",
+				name: "MiMo M2.5",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 131100,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5",
+			},
+			"xiaomi/mimo-v2.5-pro": {
+				id: "xiaomi/mimo-v2.5-pro",
+				name: "MiMo V2.5 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 1050000,
+				maxTokens: 131000,
+				capabilities: [
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.0036,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo-v2.5-pro",
+			},
+			"alibaba/qwen-3.6-max-preview": {
+				id: "alibaba/qwen-3.6-max-preview",
+				name: "Qwen 3.6 Max Preview",
+				contextWindow: 240000,
+				maxInputTokens: 240000,
+				maxTokens: 64000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.3,
+					output: 7.8,
+					cacheRead: 0.26,
+					cacheWrite: 1.625,
+				},
+				releaseDate: "2026-04-20",
+				family: "qwen",
+			},
+			"moonshotai/kimi-k2.6": {
+				id: "moonshotai/kimi-k2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262000,
+				maxInputTokens: 262000,
+				maxTokens: 262000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+				family: "kimi-k2",
+			},
+			"anthropic/claude-opus-4.7": {
+				id: "anthropic/claude-opus-4.7",
+				name: "Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"zai/glm-5.1": {
+				id: "zai/glm-5.1",
+				name: "GLM 5.1",
+				contextWindow: 202000,
+				maxInputTokens: 202000,
+				maxTokens: 202000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.3,
+					output: 4.3,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "glm",
+			},
+			"alibaba/qwen3.6-plus": {
+				id: "alibaba/qwen3.6-plus",
+				name: "Qwen 3.6 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 0.625,
+				},
+				releaseDate: "2026-04-02",
+				family: "qwen",
+			},
+			"google/gemma-4-26b-a4b-it": {
+				id: "google/gemma-4-26b-a4b-it",
+				name: "Gemma 4 26B A4B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"google/gemma-4-31b-it": {
+				id: "google/gemma-4-31b-it",
+				name: "Gemma 4 31B IT",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"arcee-ai/trinity-large-thinking": {
+				id: "arcee-ai/trinity-large-thinking",
+				name: "Trinity Large Thinking",
+				contextWindow: 262100,
+				maxInputTokens: 262100,
+				maxTokens: 80000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 0.8999999999999999,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "trinity",
+			},
+			"zai/glm-5v-turbo": {
+				id: "zai/glm-5v-turbo",
+				name: "GLM 5V Turbo",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "glm",
+			},
+			"kwaipilot/kat-coder-pro-v2": {
+				id: "kwaipilot/kat-coder-pro-v2",
+				name: "Kat Coder Pro V2",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+				family: "kat-coder",
+			},
+			"minimax/minimax-m2.7": {
+				id: "minimax/minimax-m2.7",
+				name: "Minimax M2.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.06,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"minimax/minimax-m2.7-highspeed": {
+				id: "minimax/minimax-m2.7-highspeed",
+				name: "MiniMax M2.7 High Speed",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131100,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0.06,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-03-18",
+				family: "minimax",
+			},
+			"xiaomi/mimo-v2-pro": {
+				id: "xiaomi/mimo-v2-pro",
+				name: "MiMo V2 Pro",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+				family: "mimo",
+			},
+			"openai/gpt-5.4-mini": {
+				id: "openai/gpt-5.4-mini",
+				name: "GPT 5.4 Mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 4.5,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt",
+			},
+			"openai/gpt-5.4-nano": {
+				id: "openai/gpt-5.4-nano",
+				name: "GPT 5.4 Nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 1.25,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+				family: "gpt",
+			},
+			"zai/glm-5-turbo": {
+				id: "zai/glm-5-turbo",
+				name: "GLM 5 Turbo",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 131100,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-15",
+				family: "glm",
+			},
+			"xai/grok-4.20-multi-agent-beta": {
+				id: "xai/grok-4.20-multi-agent-beta",
+				name: "Grok 4.20 Multi Agent Beta",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "grok",
+			},
+			"xai/grok-4.20-non-reasoning-beta": {
+				id: "xai/grok-4.20-non-reasoning-beta",
+				name: "Grok 4.20 Beta Non-Reasoning",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.4,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "grok",
+			},
+			"xai/grok-4.20-reasoning-beta": {
+				id: "xai/grok-4.20-reasoning-beta",
+				name: "Grok 4.20 Beta Reasoning",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "grok",
+			},
+			"xai/grok-4.20-multi-agent": {
+				id: "xai/grok-4.20-multi-agent",
+				name: "Grok 4.20 Multi-Agent",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-10",
+				family: "grok",
+			},
+			"xai/grok-4.20-non-reasoning": {
+				id: "xai/grok-4.20-non-reasoning",
+				name: "Grok 4.20 Non-Reasoning",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-10",
+				family: "grok",
+			},
+			"xai/grok-4.20-reasoning": {
+				id: "xai/grok-4.20-reasoning",
+				name: "Grok 4.20 Reasoning",
+				contextWindow: 2000000,
+				maxInputTokens: 2000000,
+				maxTokens: 2000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-10",
+				family: "grok",
+			},
+			"openai/gpt-5.4": {
+				id: "openai/gpt-5.4",
+				name: "GPT 5.4",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 15,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"openai/gpt-5.4-pro": {
+				id: "openai/gpt-5.4-pro",
+				name: "GPT 5.4 Pro",
+				contextWindow: 1050000,
+				maxInputTokens: 922000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 30,
+					output: 180,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-05",
+				family: "gpt",
+			},
+			"google/gemini-3.1-flash-lite-preview": {
+				id: "google/gemini-3.1-flash-lite-preview",
+				name: "Gemini 3.1 Flash Lite Preview",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-03",
+				family: "gemini",
+			},
+			"openai/gpt-5.3-chat": {
+				id: "openai/gpt-5.3-chat",
+				name: "GPT-5.3 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 111616,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-03",
+				family: "gpt",
+			},
+			"alibaba/qwen3.5-flash": {
+				id: "alibaba/qwen3.5-flash",
+				name: "Qwen 3.5 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.001,
+					cacheWrite: 0.125,
+				},
+				releaseDate: "2026-02-24",
+				family: "qwen",
+			},
+			"inception/mercury-2": {
+				id: "inception/mercury-2",
+				name: "Mercury 2",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.024999999999999998,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-24",
+				family: "mercury",
+			},
+			"anthropic/claude-sonnet-4.6": {
+				id: "anthropic/claude-sonnet-4.6",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"alibaba/qwen3.5-plus": {
+				id: "alibaba/qwen3.5-plus",
+				name: "Qwen 3.5 Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 2.4,
+					cacheRead: 0.04,
+					cacheWrite: 0.5,
+				},
+				releaseDate: "2026-02-16",
+				family: "qwen",
+			},
+			"minimax/minimax-m2.5": {
+				id: "minimax/minimax-m2.5",
+				name: "MiniMax M2.5",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax",
+			},
+			"minimax/minimax-m2.5-highspeed": {
+				id: "minimax/minimax-m2.5-highspeed",
+				name: "MiniMax M2.5 High Speed",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.4,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax",
+			},
+			"zai/glm-5": {
+				id: "zai/glm-5",
+				name: "GLM-5",
+				contextWindow: 202800,
+				maxInputTokens: 202800,
+				maxTokens: 131100,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.95,
+					output: 3.15,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "glm",
+			},
+			"anthropic/claude-opus-4.6": {
+				id: "anthropic/claude-opus-4.6",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"openai/gpt-5.3-codex": {
+				id: "openai/gpt-5.3-codex",
+				name: "GPT 5.3 Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-05",
+				family: "gpt",
+			},
+			"stepfun/step-3.5-flash": {
+				id: "stepfun/step-3.5-flash",
+				name: "StepFun 3.5 Flash",
+				contextWindow: 262114,
+				maxInputTokens: 262114,
+				maxTokens: 262114,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.09,
+					output: 0.3,
+					cacheRead: 0.02,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-29",
+				family: "step",
+			},
+			"arcee-ai/trinity-large-preview": {
+				id: "arcee-ai/trinity-large-preview",
+				name: "Trinity Large Preview",
+				contextWindow: 131000,
+				maxInputTokens: 131000,
+				maxTokens: 131000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-27",
+				family: "trinity",
+			},
+			"moonshotai/kimi-k2.5": {
+				id: "moonshotai/kimi-k2.5",
+				name: "Kimi K2.5",
+				contextWindow: 262114,
+				maxInputTokens: 262114,
+				maxTokens: 262114,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-26",
+				family: "kimi-k2",
+			},
+			"alibaba/qwen3-max-thinking": {
+				id: "alibaba/qwen3-max-thinking",
+				name: "Qwen 3 Max Thinking",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.2,
+					output: 6,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-23",
+				family: "qwen",
+			},
+			"zai/glm-4.7-flash": {
+				id: "zai/glm-4.7-flash",
+				name: "GLM 4.7 Flash",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "glm",
+			},
+			"zai/glm-4.7-flashx": {
+				id: "zai/glm-4.7-flashx",
+				name: "GLM 4.7 FlashX",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "glm-flash",
+			},
+			"minimax/minimax-m2.1": {
+				id: "minimax/minimax-m2.1",
+				name: "MiniMax M2.1",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"minimax/minimax-m2.1-lightning": {
+				id: "minimax/minimax-m2.1-lightning",
+				name: "MiniMax M2.1 Lightning",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 2.4,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-12-23",
+				family: "minimax",
+			},
+			"zai/glm-4.7": {
+				id: "zai/glm-4.7",
+				name: "GLM 4.7",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 120000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"openai/gpt-5.2-codex": {
+				id: "openai/gpt-5.2-codex",
+				name: "GPT-5.2-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-18",
+				family: "gpt-codex",
+			},
+			"google/gemini-3-flash": {
+				id: "google/gemini-3-flash",
+				name: "Gemini 3 Flash",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-17",
+				family: "gemini-flash",
+			},
+			"xiaomi/mimo-v2-flash": {
+				id: "xiaomi/mimo-v2-flash",
+				name: "MiMo V2 Flash",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-16",
+				family: "mimo",
+			},
+			"openai/gpt-5.2": {
+				id: "openai/gpt-5.2",
+				name: "GPT-5.2",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"openai/gpt-5.2-chat": {
+				id: "openai/gpt-5.2-chat",
+				name: "GPT-5.2 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 111616,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.75,
+					output: 14,
+					cacheRead: 0.175,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"openai/gpt-5.2-pro": {
+				id: "openai/gpt-5.2-pro",
+				name: "GPT 5.2 ",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 21,
+					output: 168,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-11",
+				family: "gpt",
+			},
+			"mistral/devstral-2": {
+				id: "mistral/devstral-2",
+				name: "Devstral 2",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-09",
+				family: "devstral",
+			},
+			"mistral/devstral-small-2": {
+				id: "mistral/devstral-small-2",
+				name: "Devstral Small 2",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-09",
+				family: "devstral",
+			},
+			"deepseek/deepseek-v3.2-thinking": {
+				id: "deepseek/deepseek-v3.2-thinking",
+				name: "DeepSeek V3.2 Thinking",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.62,
+					output: 1.85,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-01",
+				family: "deepseek-thinking",
+			},
+			"anthropic/claude-opus-4.5": {
+				id: "anthropic/claude-opus-4.5",
+				name: "Claude Opus 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-24",
+				family: "claude-opus",
+			},
+			"openai/gpt-5.1-codex-max": {
+				id: "openai/gpt-5.1-codex-max",
+				name: "GPT 5.1 Codex Max",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-19",
+				family: "gpt",
+			},
+			"xai/grok-4.1-fast-non-reasoning": {
+				id: "xai/grok-4.1-fast-non-reasoning",
+				name: "Grok 4.1 Fast Non-Reasoning",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.5,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-19",
+				family: "grok",
+			},
+			"xai/grok-4.1-fast-reasoning": {
+				id: "xai/grok-4.1-fast-reasoning",
+				name: "Grok 4.1 Fast Reasoning",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 1000000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.5,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-19",
+				family: "grok",
+			},
+			"google/gemini-3-pro-preview": {
+				id: "google/gemini-3-pro-preview",
+				name: "Gemini 3 Pro Preview",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-18",
+				family: "gemini-pro",
+			},
+			"google/gemini-3.1-pro-preview": {
+				id: "google/gemini-3.1-pro-preview",
+				name: "Gemini 3.1 Pro Preview",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-18",
+				family: "gemini",
+			},
+			"openai/gpt-5.1-codex": {
+				id: "openai/gpt-5.1-codex",
+				name: "GPT-5.1-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-12",
+				family: "gpt",
+			},
+			"openai/gpt-5.1-codex-mini": {
+				id: "openai/gpt-5.1-codex-mini",
+				name: "GPT-5.1 Codex mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-12",
+				family: "gpt",
+			},
+			"openai/gpt-5.1-instant": {
+				id: "openai/gpt-5.1-instant",
+				name: "GPT-5.1 Instant",
+				contextWindow: 128000,
+				maxInputTokens: 111616,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-12",
+				family: "gpt",
+			},
+			"openai/gpt-5.1-thinking": {
+				id: "openai/gpt-5.1-thinking",
+				name: "GPT 5.1 Thinking",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-12",
+				family: "gpt",
+			},
+			"moonshotai/kimi-k2-thinking": {
+				id: "moonshotai/kimi-k2-thinking",
+				name: "Kimi K2 Thinking",
+				contextWindow: 216144,
+				maxInputTokens: 216144,
+				maxTokens: 216144,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.47,
+					output: 2,
+					cacheRead: 0.141,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-06",
+				family: "kimi-thinking",
+			},
+			"openai/gpt-oss-safeguard-20b": {
+				id: "openai/gpt-oss-safeguard-20b",
+				name: "gpt-oss-safeguard-20b",
+				contextWindow: 131072,
+				maxInputTokens: 65536,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.075,
+					output: 0.3,
+					cacheRead: 0.037,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-29",
+				family: "gpt-oss",
+			},
+			"nvidia/nemotron-nano-12b-v2-vl": {
+				id: "nvidia/nemotron-nano-12b-v2-vl",
+				name: "Nvidia Nemotron Nano 12B V2 VL",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.2,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-28",
+				family: "nemotron",
+			},
+			"minimax/minimax-m2": {
+				id: "minimax/minimax-m2",
+				name: "MiniMax M2",
+				contextWindow: 205000,
+				maxInputTokens: 205000,
+				maxTokens: 205000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.03,
+					cacheWrite: 0.375,
+				},
+				releaseDate: "2025-10-27",
+				family: "minimax",
+			},
+			"anthropic/claude-haiku-4.5": {
+				id: "anthropic/claude-haiku-4.5",
+				name: "Claude Haiku 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"openai/gpt-5-pro": {
+				id: "openai/gpt-5-pro",
+				name: "GPT-5 pro",
+				contextWindow: 400000,
+				maxInputTokens: 128000,
+				maxTokens: 272000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 15,
+					output: 120,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-10-06",
+				family: "gpt",
+			},
+			"zai/glm-4.6": {
+				id: "zai/glm-4.6",
+				name: "GLM 4.6",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 96000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+				family: "glm",
+			},
+			"zai/glm-4.6v": {
+				id: "zai/glm-4.6v",
+				name: "GLM-4.6V",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 24000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+				family: "glm",
+			},
+			"zai/glm-4.6v-flash": {
+				id: "zai/glm-4.6v-flash",
+				name: "GLM-4.6V-Flash",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 24000,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+				family: "glm",
+			},
+			"anthropic/claude-sonnet-4.5": {
+				id: "anthropic/claude-sonnet-4.5",
+				name: "Claude Sonnet 4.5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"alibaba/qwen3-235b-a22b-thinking": {
+				id: "alibaba/qwen3-235b-a22b-thinking",
+				name: "Qwen3 235B A22B Thinking 2507",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"alibaba/qwen3-max": {
+				id: "alibaba/qwen3-max",
+				name: "Qwen3 Max",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.2,
+					output: 6,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"alibaba/qwen3-vl-instruct": {
+				id: "alibaba/qwen3-vl-instruct",
+				name: "Qwen3 VL Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 129024,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"alibaba/qwen3-vl-thinking": {
+				id: "alibaba/qwen3-vl-thinking",
+				name: "Qwen3 VL Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-23",
+				family: "qwen",
+			},
+			"deepseek/deepseek-v3.1-terminus": {
+				id: "deepseek/deepseek-v3.1-terminus",
+				name: "DeepSeek V3.1 Terminus",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.27,
+					output: 1,
+					cacheRead: 0.135,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-22",
+				family: "deepseek",
+			},
+			"openai/gpt-5-codex": {
+				id: "openai/gpt-5-codex",
+				name: "GPT-5-Codex",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-15",
+				family: "gpt-codex",
+			},
+			"alibaba/qwen3-next-80b-a3b-instruct": {
+				id: "alibaba/qwen3-next-80b-a3b-instruct",
+				name: "Qwen3 Next 80B A3B Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-11",
+				family: "qwen",
+			},
+			"alibaba/qwen3-next-80b-a3b-thinking": {
+				id: "alibaba/qwen3-next-80b-a3b-thinking",
+				name: "Qwen3 Next 80B A3B Thinking",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-11",
+				family: "qwen",
+			},
+			"alibaba/qwen3-max-preview": {
+				id: "alibaba/qwen3-max-preview",
+				name: "Qwen3 Max Preview",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 32768,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.2,
+					output: 6,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-05",
+				family: "qwen",
+			},
+			"bytedance/seed-1.6": {
+				id: "bytedance/seed-1.6",
+				name: "Seed 1.6",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-01",
+				family: "seed",
+			},
+			"bytedance/seed-1.8": {
+				id: "bytedance/seed-1.8",
+				name: "Seed 1.8",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-01",
+				family: "seed",
+			},
+			"meituan/longcat-flash-chat": {
+				id: "meituan/longcat-flash-chat",
+				name: "LongCat Flash Chat",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 100000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-01",
+				family: "longcat",
+			},
+			"deepseek/deepseek-v3.1": {
+				id: "deepseek/deepseek-v3.1",
+				name: "DeepSeek-V3.1",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 1.7,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-21",
+				family: "deepseek",
+			},
+			"nvidia/nemotron-nano-9b-v2": {
+				id: "nvidia/nemotron-nano-9b-v2",
+				name: "Nvidia Nemotron Nano 9B V2",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.06,
+					output: 0.23,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-18",
+				family: "nemotron",
+			},
+			"zai/glm-4.5v": {
+				id: "zai/glm-4.5v",
+				name: "GLM 4.5V",
+				contextWindow: 66000,
+				maxInputTokens: 66000,
+				maxTokens: 16000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 1.8,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-11",
+				family: "glm",
+			},
+			"openai/gpt-5": {
+				id: "openai/gpt-5",
+				name: "GPT-5",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt",
+			},
+			"openai/gpt-5-chat": {
+				id: "openai/gpt-5-chat",
+				name: "GPT-5 Chat",
+				contextWindow: 128000,
+				maxInputTokens: 111616,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt",
+			},
+			"openai/gpt-5-mini": {
+				id: "openai/gpt-5-mini",
+				name: "GPT-5 Mini",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 2,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-mini",
+			},
+			"openai/gpt-5-nano": {
+				id: "openai/gpt-5-nano",
+				name: "GPT-5 Nano",
+				contextWindow: 400000,
+				maxInputTokens: 272000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.4,
+					cacheRead: 0.005,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-07",
+				family: "gpt-nano",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 122880,
+				maxTokens: 8192,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"alibaba/qwen3-coder-30b-a3b": {
+				id: "alibaba/qwen3-coder-30b-a3b",
+				name: "Qwen 3 Coder 30B A3B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-31",
+				family: "qwen",
+			},
+			"zai/glm-4.5": {
+				id: "zai/glm-4.5",
+				name: "GLM 4.5",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 96000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm",
+			},
+			"zai/glm-4.5-air": {
+				id: "zai/glm-4.5-air",
+				name: "GLM 4.5 Air",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 96000,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 1.1,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm-air",
+			},
+			"alibaba/qwen3-coder-plus": {
+				id: "alibaba/qwen3-coder-plus",
+				name: "Qwen3 Coder Plus",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 65536,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-23",
+				family: "qwen",
+			},
+			"alibaba/qwen3-coder": {
+				id: "alibaba/qwen3-coder",
+				name: "Qwen3 Coder 480B A35B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 65536,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.5,
+					output: 7.5,
+					cacheRead: 0.3,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-22",
+				family: "qwen",
+			},
+			"alibaba/qwen3-coder-next": {
+				id: "alibaba/qwen3-coder-next",
+				name: "Qwen3 Coder Next",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 1.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-22",
+				family: "qwen",
+			},
+			"moonshotai/kimi-k2": {
+				id: "moonshotai/kimi-k2",
+				name: "Kimi K2 Instruct",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.57,
+					output: 2.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-11",
+				family: "kimi-k2",
+			},
+			"openai/o3-deep-research": {
+				id: "openai/o3-deep-research",
+				name: "o3-deep-research",
+				contextWindow: 200000,
+				maxInputTokens: 100000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 10,
+					output: 40,
+					cacheRead: 2.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-26",
+				family: "o",
+			},
+			"google/gemini-2.5-flash": {
+				id: "google/gemini-2.5-flash",
+				name: "Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash",
+			},
+			"google/gemini-2.5-flash-lite": {
+				id: "google/gemini-2.5-flash-lite",
+				name: "Gemini 2.5 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash-lite",
+			},
+			"google/gemini-2.5-pro": {
+				id: "google/gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-pro",
+			},
+			"openai/o3-pro": {
+				id: "openai/o3-pro",
+				name: "o3 Pro",
+				contextWindow: 200000,
+				maxInputTokens: 100000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 20,
+					output: 80,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-10",
+				family: "o-pro",
+			},
+			"anthropic/claude-opus-4": {
+				id: "anthropic/claude-opus-4",
+				name: "Claude Opus 4",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 32000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 75,
+					cacheRead: 1.5,
+					cacheWrite: 18.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-opus",
+			},
+			"anthropic/claude-sonnet-4": {
+				id: "anthropic/claude-sonnet-4",
+				name: "Claude Sonnet 4",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-05-22",
+				family: "claude-sonnet",
+			},
+			"mistral/devstral-small": {
+				id: "mistral/devstral-small",
+				name: "Devstral Small 1.1",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 64000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-21",
+				family: "devstral",
+			},
+			"mistral/mistral-medium": {
+				id: "mistral/mistral-medium",
+				name: "Mistral Medium 3.1",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 64000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.4,
+					output: 2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-05-07",
+				family: "mistral-medium",
+			},
+			"alibaba/qwen-3-14b": {
+				id: "alibaba/qwen-3-14b",
+				name: "Qwen3-14B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 16384,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.12,
+					output: 0.24,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"alibaba/qwen-3-235b": {
+				id: "alibaba/qwen-3-235b",
+				name: "Qwen3 235B A22B Instruct 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 0.88,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"alibaba/qwen-3-30b": {
+				id: "alibaba/qwen-3-30b",
+				name: "Qwen3-30B-A3B",
+				contextWindow: 40960,
+				maxInputTokens: 40960,
+				maxTokens: 16384,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.12,
+					output: 0.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"alibaba/qwen-3-32b": {
+				id: "alibaba/qwen-3-32b",
+				name: "Qwen 3.32B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.16,
+					output: 0.64,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-28",
+				family: "qwen",
+			},
+			"openai/o3": {
+				id: "openai/o3",
+				name: "o3",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o",
+			},
+			"openai/o4-mini": {
+				id: "openai/o4-mini",
+				name: "o4-mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.275,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-16",
+				family: "o-mini",
+			},
+			"openai/gpt-4.1": {
+				id: "openai/gpt-4.1",
+				name: "GPT-4.1",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 8,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt",
+			},
+			"openai/gpt-4.1-mini": {
+				id: "openai/gpt-4.1-mini",
+				name: "GPT-4.1 mini",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.4,
+					output: 1.6,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-mini",
+			},
+			"openai/gpt-4.1-nano": {
+				id: "openai/gpt-4.1-nano",
+				name: "GPT-4.1 nano",
+				contextWindow: 1047576,
+				maxInputTokens: 1047576,
+				maxTokens: 32768,
+				capabilities: [
+					"images",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-14",
+				family: "gpt-nano",
+			},
+			"meta/llama-4-maverick": {
+				id: "meta/llama-4-maverick",
+				name: "Llama-4-Maverick-17B-128E-Instruct-FP8",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"meta/llama-4-scout": {
+				id: "meta/llama-4-scout",
+				name: "Llama-4-Scout-17B-16E-Instruct-FP8",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-05",
+				family: "llama",
+			},
+			"mistral/magistral-medium": {
+				id: "mistral/magistral-medium",
+				name: "Magistral Medium (latest)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 2,
+					output: 5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-17",
+				family: "magistral-medium",
+			},
+			"mistral/magistral-small": {
+				id: "mistral/magistral-small",
+				name: "Magistral Small",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.5,
+					output: 1.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-17",
+				family: "magistral-small",
+			},
+			"cohere/command-a": {
+				id: "cohere/command-a",
+				name: "Command A",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 8000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-03-13",
+				family: "command",
+			},
+			"inception/mercury-coder-small": {
+				id: "inception/mercury-coder-small",
+				name: "Mercury Coder Small Beta",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 16384,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.25,
+					output: 1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-02-26",
+				family: "mercury",
+			},
+			"perplexity/sonar": {
+				id: "perplexity/sonar",
+				name: "Sonar",
+				contextWindow: 127000,
+				maxInputTokens: 127000,
+				maxTokens: 8000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-02-19",
+				family: "sonar",
+			},
+			"perplexity/sonar-pro": {
+				id: "perplexity/sonar-pro",
+				name: "Sonar Pro",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 8000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-02-19",
+				family: "sonar-pro",
+			},
+			"deepseek/deepseek-r1": {
+				id: "deepseek/deepseek-r1",
+				name: "DeepSeek-R1",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 1.35,
+					output: 5.4,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-01-20",
+				family: "deepseek-thinking",
+			},
+			"deepseek/deepseek-v3": {
+				id: "deepseek/deepseek-v3",
+				name: "DeepSeek V3 0324",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 163840,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.27,
+					output: 1.12,
+					cacheRead: 0.135,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-26",
+				family: "deepseek",
+			},
+			"openai/o3-mini": {
+				id: "openai/o3-mini",
+				name: "o3-mini",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.1,
+					output: 4.4,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-20",
+				family: "o-mini",
+			},
+			"meta/llama-3.3-70b": {
+				id: "meta/llama-3.3-70b",
+				name: "Llama-3.3-70B-Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-06",
+				family: "llama",
+			},
+			"openai/o1": {
+				id: "openai/o1",
+				name: "o1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 100000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 15,
+					output: 60,
+					cacheRead: 7.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-05",
+				family: "o",
+			},
+			"amazon/nova-lite": {
+				id: "amazon/nova-lite",
+				name: "Nova Lite",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.06,
+					output: 0.24,
+					cacheRead: 0.015,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+				family: "nova-lite",
+			},
+			"amazon/nova-micro": {
+				id: "amazon/nova-micro",
+				name: "Nova Micro",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.035,
+					output: 0.14,
+					cacheRead: 0.00875,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+				family: "nova-micro",
+			},
+			"amazon/nova-pro": {
+				id: "amazon/nova-pro",
+				name: "Nova Pro",
+				contextWindow: 300000,
+				maxInputTokens: 300000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.8,
+					output: 3.2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-03",
+				family: "nova-pro",
+			},
+			"anthropic/claude-3.5-haiku": {
+				id: "anthropic/claude-3.5-haiku",
+				name: "Claude 3.5 Haiku",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 8192,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.8,
+					output: 4,
+					cacheRead: 0.08,
+					cacheWrite: 1,
+				},
+				releaseDate: "2024-11-04",
+				family: "claude-haiku",
+			},
+			"mistral/pixtral-large": {
+				id: "mistral/pixtral-large",
+				name: "Pixtral Large (latest)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-11-01",
+				family: "pixtral",
+			},
+			"mistral/ministral-3b": {
+				id: "mistral/ministral-3b",
+				name: "Ministral 3B (latest)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.04,
+					output: 0.04,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-10-01",
+				family: "ministral",
+			},
+			"mistral/ministral-8b": {
+				id: "mistral/ministral-8b",
+				name: "Ministral 8B (latest)",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.1,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-10-01",
+				family: "ministral",
+			},
+			"meta/llama-3.2-11b": {
+				id: "meta/llama-3.2-11b",
+				name: "Llama 3.2 11B Vision Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.16,
+					output: 0.16,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-25",
+				family: "llama",
+			},
+			"meta/llama-3.2-90b": {
+				id: "meta/llama-3.2-90b",
+				name: "Llama 3.2 90B Vision Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.72,
+					output: 0.72,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-25",
+				family: "llama",
+			},
+			"mistral/mistral-small": {
+				id: "mistral/mistral-small",
+				name: "Mistral Small (latest)",
+				contextWindow: 32000,
+				maxInputTokens: 32000,
+				maxTokens: 4000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-17",
+				family: "mistral-small",
+			},
+			"mistral/pixtral-12b": {
+				id: "mistral/pixtral-12b",
+				name: "Pixtral 12B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-09-01",
+				family: "pixtral",
+			},
+			"meta/llama-3.1-70b": {
+				id: "meta/llama-3.1-70b",
+				name: "Llama 3.1 70B Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.72,
+					output: 0.72,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+			"meta/llama-3.1-8b": {
+				id: "meta/llama-3.1-8b",
+				name: "Llama 3.1 8B Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.22,
+					output: 0.22,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+			"mistral/mistral-nemo": {
+				id: "mistral/mistral-nemo",
+				name: "Mistral Nemo",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.15,
+					output: 0.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+				family: "mistral-nemo",
+			},
+			"openai/gpt-4o-mini": {
+				id: "openai/gpt-4o-mini",
+				name: "GPT-4o mini",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.15,
+					output: 0.6,
+					cacheRead: 0.075,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-18",
+				family: "gpt-mini",
+			},
+			"mistral/codestral": {
+				id: "mistral/codestral",
+				name: "Codestral (latest)",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 4096,
+				capabilities: ["tools", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-29",
+				family: "codestral",
+			},
+			"openai/gpt-4o": {
+				id: "openai/gpt-4o",
+				name: "GPT-4o",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 16384,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2.5,
+					output: 10,
+					cacheRead: 1.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-05-13",
+				family: "gpt",
+			},
+			"anthropic/claude-3-haiku": {
+				id: "anthropic/claude-3-haiku",
+				name: "Claude Haiku 3",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.25,
+					output: 1.25,
+					cacheRead: 0.03,
+					cacheWrite: 0.3,
+				},
+				releaseDate: "2024-03-13",
+				family: "claude-haiku",
+			},
+			"openai/gpt-4-turbo": {
+				id: "openai/gpt-4-turbo",
+				name: "GPT-4 Turbo",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 4096,
+				capabilities: ["images", "tools", "temperature"],
+				pricing: {
+					input: 10,
+					output: 30,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2023-11-06",
+				family: "gpt",
+			},
+		},
+		vertex: {
+			"claude-sonnet-5@default": {
+				id: "claude-sonnet-5@default",
+				name: "Claude Sonnet 5",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 2,
+					output: 10,
+					cacheRead: 0.2,
+					cacheWrite: 2.5,
+				},
+				releaseDate: "2026-06-30",
+				family: "claude-sonnet",
+			},
+			"claude-opus-4-8@default": {
+				id: "claude-opus-4-8@default",
+				name: "Claude Opus 4.8",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-05-28",
+				family: "claude-opus",
+			},
+			"gemini-3.5-flash": {
+				id: "gemini-3.5-flash",
+				name: "Gemini 3.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.5,
+					output: 9,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-19",
+				family: "gemini-flash",
+			},
+			"gemini-3.1-flash-lite": {
+				id: "gemini-3.1-flash-lite",
+				name: "Gemini 3.1 Flash Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.5,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-05-07",
+				family: "gemini-flash-lite",
+			},
+			"claude-opus-4-7@default": {
+				id: "claude-opus-4-7@default",
+				name: "Claude Opus 4.7",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: ["images", "files", "tools", "reasoning", "prompt-cache"],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-04-16",
+				family: "claude-opus",
+			},
+			"gemini-3.1-pro-preview": {
+				id: "gemini-3.1-pro-preview",
+				name: "Gemini 3.1 Pro Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"gemini-3.1-pro-preview-customtools": {
+				id: "gemini-3.1-pro-preview-customtools",
+				name: "Gemini 3.1 Pro Preview Custom Tools",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 12,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-19",
+				family: "gemini-pro",
+			},
+			"claude-sonnet-4-6@default": {
+				id: "claude-sonnet-4-6@default",
+				name: "Claude Sonnet 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2026-02-17",
+				family: "claude-sonnet",
+			},
+			"zai-org/glm-5-maas": {
+				id: "zai-org/glm-5-maas",
+				name: "GLM-5",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3.2,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-11",
+				family: "glm",
+			},
+			"claude-opus-4-6@default": {
+				id: "claude-opus-4-6@default",
+				name: "Claude Opus 4.6",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2026-02-05",
+				family: "claude-opus",
+			},
+			"zai-org/glm-4.7-maas": {
+				id: "zai-org/glm-4.7-maas",
+				name: "GLM-4.7",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 128000,
+				capabilities: [
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-06",
+				family: "glm",
+			},
+			"deepseek-ai/deepseek-v3.2-maas": {
+				id: "deepseek-ai/deepseek-v3.2-maas",
+				name: "DeepSeek V3.2",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 65536,
+				capabilities: [
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.56,
+					output: 1.68,
+					cacheRead: 0.056,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-17",
+				family: "deepseek",
+			},
+			"gemini-3-flash-preview": {
+				id: "gemini-3-flash-preview",
+				name: "Gemini 3 Flash Preview",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-17",
+				family: "gemini-flash",
+			},
+			"moonshotai/kimi-k2-thinking-maas": {
+				id: "moonshotai/kimi-k2-thinking-maas",
+				name: "Kimi K2 Thinking",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 2.5,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-11-13",
+				family: "kimi-thinking",
+			},
+			"claude-opus-4-5@20251101": {
+				id: "claude-opus-4-5@20251101",
+				name: "Claude Opus 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 5,
+					output: 25,
+					cacheRead: 0.5,
+					cacheWrite: 6.25,
+				},
+				releaseDate: "2025-11-01",
+				family: "claude-opus",
+			},
+			"claude-haiku-4-5@20251001": {
+				id: "claude-haiku-4-5@20251001",
+				name: "Claude Haiku 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 5,
+					cacheRead: 0.1,
+					cacheWrite: 1.25,
+				},
+				releaseDate: "2025-10-15",
+				family: "claude-haiku",
+			},
+			"claude-sonnet-4-5@20250929": {
+				id: "claude-sonnet-4-5@20250929",
+				name: "Claude Sonnet 4.5",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 64000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 3,
+					output: 15,
+					cacheRead: 0.3,
+					cacheWrite: 3.75,
+				},
+				releaseDate: "2025-09-29",
+				family: "claude-sonnet",
+			},
+			"gemini-flash-latest": {
+				id: "gemini-flash-latest",
+				name: "Gemini Flash Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.075,
+					cacheWrite: 0.383,
+				},
+				releaseDate: "2025-09-25",
+				family: "gemini-flash",
+			},
+			"gemini-flash-lite-latest": {
+				id: "gemini-flash-lite-latest",
+				name: "Gemini Flash-Lite Latest",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.025,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-25",
+				family: "gemini-flash-lite",
+			},
+			"deepseek-ai/deepseek-v3.1-maas": {
+				id: "deepseek-ai/deepseek-v3.1-maas",
+				name: "DeepSeek V3.1",
+				contextWindow: 163840,
+				maxInputTokens: 163840,
+				maxTokens: 32768,
+				capabilities: [
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.6,
+					output: 1.7,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-28",
+				family: "deepseek",
+			},
+			"qwen/qwen3-235b-a22b-instruct-2507-maas": {
+				id: "qwen/qwen3-235b-a22b-instruct-2507-maas",
+				name: "Qwen3 235B A22B Instruct",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 16384,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0.22,
+					output: 0.88,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-13",
+				family: "qwen",
+			},
+			"openai/gpt-oss-120b-maas": {
+				id: "openai/gpt-oss-120b-maas",
+				name: "GPT OSS 120B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.09,
+					output: 0.36,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b-maas": {
+				id: "openai/gpt-oss-20b-maas",
+				name: "GPT OSS 20B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 32768,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.07,
+					output: 0.25,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"gemini-2.5-flash": {
+				id: "gemini-2.5-flash",
+				name: "Gemini 2.5 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 2.5,
+					cacheRead: 0.075,
+					cacheWrite: 0.383,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash",
+			},
+			"gemini-2.5-flash-lite": {
+				id: "gemini-2.5-flash-lite",
+				name: "Gemini 2.5 Flash-Lite",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-flash-lite",
+			},
+			"gemini-2.5-pro": {
+				id: "gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 65536,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 10,
+					cacheRead: 0.125,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-06-17",
+				family: "gemini-pro",
+			},
+			"meta/llama-3.3-70b-instruct-maas": {
+				id: "meta/llama-3.3-70b-instruct-maas",
+				name: "Llama 3.3 70B Instruct",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 8192,
+				capabilities: ["tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.72,
+					output: 0.72,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-29",
+				family: "llama",
+			},
+			"meta/llama-4-maverick-17b-128e-instruct-maas": {
+				id: "meta/llama-4-maverick-17b-128e-instruct-maas",
+				name: "Llama 4 Maverick 17B 128E Instruct",
+				contextWindow: 524288,
+				maxInputTokens: 524288,
+				maxTokens: 8192,
+				capabilities: ["images", "tools", "structured_output", "temperature"],
+				pricing: {
+					input: 0.35,
+					output: 1.15,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-29",
+				family: "llama",
+			},
+		},
+		wandb: {
+			"zai-org/GLM-5.2": {
+				id: "zai-org/GLM-5.2",
+				name: "GLM 5.2",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.39,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-16",
+				family: "glm",
+			},
+			"moonshotai/Kimi-K2.7-Code": {
+				id: "moonshotai/Kimi-K2.7-Code",
+				name: "Kimi K2.7 Code",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.94,
+					output: 4,
+					cacheRead: 0.19,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-12",
+				family: "kimi-k2",
+			},
+			"nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B": {
+				id: "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B",
+				name: "Nemotron 3 Ultra",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.75,
+					output: 2.75,
+					cacheRead: 0.15,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-04",
+				family: "nemotron",
+			},
+			"JetBrains/Mellum2-12B-A2.5B-Instruct": {
+				id: "JetBrains/Mellum2-12B-A2.5B-Instruct",
+				name: "Mellum2 12B A2.5B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.1,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-01",
+			},
+			"ibm-granite/granite-4.1-8b": {
+				id: "ibm-granite/granite-4.1-8b",
+				name: "Granite 4.1 8B",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.1,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-29",
+				family: "granite",
+			},
+			"deepseek-ai/DeepSeek-V4-Flash": {
+				id: "deepseek-ai/DeepSeek-V4-Flash",
+				name: "DeepSeek V4 Flash",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 1048576,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.07,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek",
+			},
+			"deepseek-ai/DeepSeek-V4-Pro": {
+				id: "deepseek-ai/DeepSeek-V4-Pro",
+				name: "DeepSeek V4 Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 1048576,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.74,
+					output: 3.48,
+					cacheRead: 0.14,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-24",
+				family: "deepseek",
+			},
+			"Qwen/Qwen3.6-27B": {
+				id: "Qwen/Qwen3.6-27B",
+				name: "Qwen3.6 27B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3.6,
+					cacheRead: 0.12,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "qwen3.6",
+			},
+			"moonshotai/Kimi-K2.6": {
+				id: "moonshotai/Kimi-K2.6",
+				name: "Kimi K2.6",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.95,
+					output: 4,
+					cacheRead: 0.16,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-20",
+				family: "kimi-k2",
+			},
+			"Qwen/Qwen3.6-35B-A3B": {
+				id: "Qwen/Qwen3.6-35B-A3B",
+				name: "Qwen3.6 35B A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.25,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-15",
+				family: "qwen3.6",
+			},
+			"zai-org/GLM-5.1": {
+				id: "zai-org/GLM-5.1",
+				name: "GLM 5.1",
+				contextWindow: 202752,
+				maxInputTokens: 202752,
+				maxTokens: 202752,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "glm",
+			},
+			"google/gemma-4-31B-it": {
+				id: "google/gemma-4-31B-it",
+				name: "Gemma 4 31B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.12,
+					output: 0.35,
+					cacheRead: 0.09,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-02",
+				family: "gemma",
+			},
+			"nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-FP8": {
+				id: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-FP8",
+				name: "Nemotron 3 Super",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.2,
+					output: 0.8,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-11",
+				family: "nemotron",
+			},
+			"Qwen/Qwen3.5-35B-A3B": {
+				id: "Qwen/Qwen3.5-35B-A3B",
+				name: "Qwen3.5-35B-A3B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.25,
+					output: 1.25,
+					cacheRead: 0.25,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-24",
+				family: "qwen3.5",
+			},
+			"MiniMaxAI/MiniMax-M2.5": {
+				id: "MiniMaxAI/MiniMax-M2.5",
+				name: "MiniMax M2.5",
+				contextWindow: 196608,
+				maxInputTokens: 196608,
+				maxTokens: 196608,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.3,
+					output: 1.2,
+					cacheRead: 0.3,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "minimax-m2.5",
+			},
+			"moonshotai/Kimi-K2.5": {
+				id: "moonshotai/Kimi-K2.5",
+				name: "Kimi K2.5",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.6,
+					output: 3,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-02",
+				family: "kimi-k2",
+			},
+			"deepseek-ai/DeepSeek-V3.1": {
+				id: "deepseek-ai/DeepSeek-V3.1",
+				name: "DeepSeek V3.1",
+				contextWindow: 161000,
+				maxInputTokens: 161000,
+				maxTokens: 161000,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.55,
+					output: 1.65,
+					cacheRead: 0.55,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-21",
+				family: "deepseek",
+			},
+			"openai/gpt-oss-120b": {
+				id: "openai/gpt-oss-120b",
+				name: "gpt-oss-120b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.04,
+					output: 0.14,
+					cacheRead: 0.04,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"openai/gpt-oss-20b": {
+				id: "openai/gpt-oss-20b",
+				name: "gpt-oss-20b",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.03,
+					output: 0.13,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-05",
+				family: "gpt-oss",
+			},
+			"Qwen/Qwen3-30B-A3B-Instruct-2507": {
+				id: "Qwen/Qwen3-30B-A3B-Instruct-2507",
+				name: "Qwen3 30B A3B Instruct 2507",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.1,
+					output: 0.3,
+					cacheRead: 0.1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-29",
+				family: "qwen",
+			},
+			"Qwen/Qwen3-Coder-480B-A35B-Instruct": {
+				id: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+				name: "Qwen3 Coder 480B A35B",
+				contextWindow: 262144,
+				maxInputTokens: 262144,
+				maxTokens: 262144,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 1.5,
+					cacheRead: 1,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-22",
+				family: "qwen",
+			},
+			"OpenPipe/Qwen3-14B-Instruct": {
+				id: "OpenPipe/Qwen3-14B-Instruct",
+				name: "Qwen3 14B Instruct",
+				contextWindow: 32768,
+				maxInputTokens: 32768,
+				maxTokens: 32768,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.05,
+					output: 0.22,
+					cacheRead: 0.05,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-04-29",
+				family: "qwen",
+			},
+			"meta-llama/Llama-3.3-70B-Instruct": {
+				id: "meta-llama/Llama-3.3-70B-Instruct",
+				name: "Llama 3.3 70B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.71,
+					output: 0.71,
+					cacheRead: 0.71,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-12-01",
+				family: "llama",
+			},
+			"meta-llama/Llama-3.1-70B-Instruct": {
+				id: "meta-llama/Llama-3.1-70B-Instruct",
+				name: "Llama 3.1 70B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.8,
+					output: 0.8,
+					cacheRead: 0.8,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+			"meta-llama/Llama-3.1-8B-Instruct": {
+				id: "meta-llama/Llama-3.1-8B-Instruct",
+				name: "Llama 3.1 8B",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 128000,
+				capabilities: [
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.22,
+					output: 0.22,
+					cacheRead: 0.22,
+					cacheWrite: 0,
+				},
+				releaseDate: "2024-07-23",
+				family: "llama",
+			},
+		},
+		xai: {
+			"grok-4.5": {
+				id: "grok-4.5",
+				name: "Grok 4.5",
+				contextWindow: 500000,
+				maxInputTokens: 500000,
+				maxTokens: 500000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 2,
+					output: 6,
+					cacheRead: 0.5,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-07-08",
+				family: "grok",
+			},
+			"grok-4.3": {
+				id: "grok-4.3",
+				name: "Grok 4.3",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 30000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-17",
+				family: "grok",
+			},
+			"grok-build-0.1": {
+				id: "grok-build-0.1",
+				name: "Grok Build 0.1",
+				contextWindow: 256000,
+				maxInputTokens: 256000,
+				maxTokens: 256000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1,
+					output: 2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-16",
+				family: "grok-build",
+			},
+			"grok-4.20-0309-non-reasoning": {
+				id: "grok-4.20-0309-non-reasoning",
+				name: "Grok 4.20 (Non-Reasoning)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 30000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-09",
+				family: "grok",
+			},
+			"grok-4.20-0309-reasoning": {
+				id: "grok-4.20-0309-reasoning",
+				name: "Grok 4.20 (Reasoning)",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 30000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.25,
+					output: 2.5,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-09",
+				family: "grok",
+			},
+		},
+		xiaomi: {
+			"mimo-v2.5-pro-ultraspeed": {
+				id: "mimo-v2.5-pro-ultraspeed",
+				name: "MiMo-V2.5-Pro-UltraSpeed",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1.305,
+					output: 2.61,
+					cacheRead: 0.0108,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-08",
+				family: "mimo",
+			},
+			"mimo-v2.5": {
+				id: "mimo-v2.5",
+				name: "MiMo-V2.5",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 0.14,
+					output: 0.28,
+					cacheRead: 0.0028,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+			"mimo-v2.5-pro": {
+				id: "mimo-v2.5-pro",
+				name: "MiMo-V2.5-Pro",
+				contextWindow: 1048576,
+				maxInputTokens: 1048576,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.435,
+					output: 0.87,
+					cacheRead: 0.0036,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-22",
+				family: "mimo",
+			},
+		},
+		zai: {
+			"glm-5.2": {
+				id: "glm-5.2",
+				name: "GLM-5.2",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"glm-5.1": {
+				id: "glm-5.1",
+				name: "GLM-5.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.4,
+					output: 4.4,
+					cacheRead: 0.26,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-07",
+				family: "glm",
+			},
+			"glm-5v-turbo": {
+				id: "glm-5v-turbo",
+				name: "GLM-5V-Turbo",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "glm",
+			},
+			"glm-5-turbo": {
+				id: "glm-5-turbo",
+				name: "GLM-5-Turbo",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+					"prompt-cache",
+				],
+				pricing: {
+					input: 1.2,
+					output: 4,
+					cacheRead: 0.24,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-16",
+				family: "glm",
+			},
+			"glm-5": {
+				id: "glm-5",
+				name: "GLM-5",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 1,
+					output: 3.2,
+					cacheRead: 0.2,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-02-12",
+				family: "glm",
+			},
+			"glm-4.7-flash": {
+				id: "glm-4.7-flash",
+				name: "GLM-4.7-Flash",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "glm-flash",
+			},
+			"glm-4.7-flashx": {
+				id: "glm-4.7-flashx",
+				name: "GLM-4.7-FlashX",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.07,
+					output: 0.4,
+					cacheRead: 0.01,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-01-19",
+				family: "glm-flash",
+			},
+			"glm-4.7": {
+				id: "glm-4.7",
+				name: "GLM-4.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"glm-4.6v": {
+				id: "glm-4.6v",
+				name: "GLM-4.6V",
+				contextWindow: 128000,
+				maxInputTokens: 128000,
+				maxTokens: 32768,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.3,
+					output: 0.9,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-08",
+				family: "glm",
+			},
+			"glm-4.6": {
+				id: "glm-4.6",
+				name: "GLM-4.6",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-09-30",
+				family: "glm",
+			},
+			"glm-4.5v": {
+				id: "glm-4.5v",
+				name: "GLM-4.5V",
+				contextWindow: 64000,
+				maxInputTokens: 64000,
+				maxTokens: 16384,
+				capabilities: ["images", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0.6,
+					output: 1.8,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-08-11",
+				family: "glm",
+			},
+			"glm-4.5": {
+				id: "glm-4.5",
+				name: "GLM-4.5",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.6,
+					output: 2.2,
+					cacheRead: 0.11,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm",
+			},
+			"glm-4.5-air": {
+				id: "glm-4.5-air",
+				name: "GLM-4.5-Air",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature", "prompt-cache"],
+				pricing: {
+					input: 0.2,
+					output: 1.1,
+					cacheRead: 0.03,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm-air",
+			},
+			"glm-4.5-flash": {
+				id: "glm-4.5-flash",
+				name: "GLM-4.5-Flash",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm-flash",
+			},
+		},
+		"zai-coding-plan": {
+			"glm-5.2": {
+				id: "glm-5.2",
+				name: "GLM-5.2",
+				contextWindow: 1000000,
+				maxInputTokens: 1000000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-06-13",
+				family: "glm",
+			},
+			"glm-5v-turbo": {
+				id: "glm-5v-turbo",
+				name: "GLM-5V-Turbo",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: ["images", "files", "tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-04-01",
+				family: "glm",
+			},
+			"glm-5.1": {
+				id: "glm-5.1",
+				name: "GLM-5.1",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-27",
+				family: "glm",
+			},
+			"glm-5-turbo": {
+				id: "glm-5-turbo",
+				name: "GLM-5-Turbo",
+				contextWindow: 200000,
+				maxInputTokens: 200000,
+				maxTokens: 131072,
+				capabilities: [
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-16",
+				family: "glm",
+			},
+			"glm-4.7": {
+				id: "glm-4.7",
+				name: "GLM-4.7",
+				contextWindow: 204800,
+				maxInputTokens: 204800,
+				maxTokens: 131072,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-12-22",
+				family: "glm",
+			},
+			"glm-4.5-air": {
+				id: "glm-4.5-air",
+				name: "GLM-4.5-Air",
+				contextWindow: 131072,
+				maxInputTokens: 131072,
+				maxTokens: 98304,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				releaseDate: "2025-07-28",
+				family: "glm-air",
+			},
+		},
+	},
+};
diff --git a/sdk/packages/llms/src/catalog/model-id-aliases.test.ts b/sdk/packages/llms/src/catalog/model-id-aliases.test.ts
new file mode 100644
index 0000000..2cab393
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/model-id-aliases.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import {
+	isCanonicalModelIdForAliasRules,
+	preferCanonicalModelIds,
+	VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+} from "./model-id-aliases";
+
+describe("model id aliases", () => {
+	it("recognizes canonical model ids for configured alias rules", () => {
+		expect(
+			isCanonicalModelIdForAliasRules(
+				"zai/glm-5.2",
+				VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+			),
+		).toBe(true);
+		expect(
+			isCanonicalModelIdForAliasRules(
+				"z-ai/glm-5.2",
+				VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+			),
+		).toBe(false);
+	});
+
+	it("removes an alias only when its canonical model id exists", () => {
+		const models = preferCanonicalModelIds(
+			{
+				"zai/glm-5.2": { source: "vercel" },
+				"z-ai/glm-5.2": { source: "openrouter" },
+				"z-ai/openrouter-only": { source: "openrouter" },
+			},
+			VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+		);
+
+		expect(models).toEqual({
+			"zai/glm-5.2": { source: "vercel" },
+			"z-ai/openrouter-only": { source: "openrouter" },
+		});
+	});
+});
diff --git a/sdk/packages/llms/src/catalog/model-id-aliases.ts b/sdk/packages/llms/src/catalog/model-id-aliases.ts
new file mode 100644
index 0000000..0f82ade
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/model-id-aliases.ts
@@ -0,0 +1,34 @@
+export interface ModelIdAliasRule {
+	canonicalPrefix: string;
+	aliasPrefix: string;
+}
+
+// Some upstream catalogs expose the same routed model under different provider
+// namespaces. Prefer the namespace our runtime can receive so exact model-info
+// lookups keep the right context window and token limits.
+export const VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES = [
+	{ canonicalPrefix: "zai/", aliasPrefix: "z-ai/" },
+] as const satisfies readonly ModelIdAliasRule[];
+
+export function isCanonicalModelIdForAliasRules(
+	modelId: string,
+	rules: readonly ModelIdAliasRule[],
+): boolean {
+	return rules.some((rule) => modelId.startsWith(rule.canonicalPrefix));
+}
+
+export function preferCanonicalModelIds<T>(
+	models: Record<string, T>,
+	rules: readonly ModelIdAliasRule[],
+): Record<string, T> {
+	return Object.fromEntries(
+		Object.entries(models).filter(([modelId]) => {
+			for (const rule of rules) {
+				if (!modelId.startsWith(rule.aliasPrefix)) continue;
+				const canonicalModelId = `${rule.canonicalPrefix}${modelId.slice(rule.aliasPrefix.length)}`;
+				if (canonicalModelId in models) return false;
+			}
+			return true;
+		}),
+	);
+}
diff --git a/sdk/packages/llms/src/catalog/types.ts b/sdk/packages/llms/src/catalog/types.ts
new file mode 100644
index 0000000..80120f1
--- /dev/null
+++ b/sdk/packages/llms/src/catalog/types.ts
@@ -0,0 +1,97 @@
+/**
+ * Model Schema Definitions
+ *
+ * Re-exports model info types from @cline/shared (canonical source)
+ * and defines provider-level schemas local to @cline/llms.
+ */
+
+import { z } from "zod";
+
+// ModelInfo and dependencies have their canonical home in @cline/shared
+export {
+	ApiFormat,
+	ApiFormatSchema,
+	type ModelCapability,
+	ModelCapabilitySchema,
+	type ModelInfo,
+	ModelInfoSchema,
+	type ModelMetadata,
+	ModelMetadataSchema,
+	type ModelPricing,
+	ModelPricingSchema,
+	type ModelStatus,
+	ModelStatusSchema,
+	type ThinkingConfig,
+	ThinkingConfigSchema,
+} from "@cline/shared";
+
+// Re-import for use in local schemas
+import { ModelInfoSchema, ProviderCapabilitySchema } from "@cline/shared";
+
+export const ModelEntrySchema = z.object({
+	id: z.string(),
+	info: ModelInfoSchema,
+});
+
+export type ModelEntry = z.infer<typeof ModelEntrySchema>;
+export type ProviderCapability = z.infer<typeof ProviderCapabilitySchema>;
+
+export const ProviderProtocolSchema = z.enum([
+	"anthropic",
+	"gemini",
+	"openai-chat",
+	"openai-responses",
+	"openai-r1",
+	"ai-sdk",
+]);
+
+const ProviderClientSchema = z.enum([
+	"anthropic",
+	"ai-sdk",
+	"ai-sdk-community",
+	"openai",
+	"openai-compatible",
+	"openai-r1",
+	"gemini",
+	"bedrock",
+	"custom",
+	"fetch",
+	"vertex",
+]);
+
+/**
+ * ProviderSource indicates how a provider was added to the system,
+ * which can be useful for determining trust level and whether to prompt the user for confirmation before using it.
+ * For example, providers with source "system" are built-in and can be trusted,
+ * while providers with source "file" were added by the user using a local JSON file,
+ * and providers with source "discovery" were found through network discovery.
+ */
+const ProviderSourceSchema = z.enum(["system", "file", "discovery"]);
+
+export type ProviderClient = z.infer<typeof ProviderClientSchema>;
+export type ProviderProtocol = z.infer<typeof ProviderProtocolSchema>;
+export type ProviderSource = z.infer<typeof ProviderSourceSchema>;
+
+export const ProviderInfoSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().optional(),
+	protocol: ProviderProtocolSchema.optional(),
+	baseUrl: z.string().optional(),
+	modelsSourceUrl: z.string().optional(),
+	defaultModelId: z.string(),
+	capabilities: z.array(ProviderCapabilitySchema).optional(),
+	env: z.array(z.string()).optional(),
+	client: ProviderClientSchema,
+	source: ProviderSourceSchema.default("system"),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type ProviderInfo = z.infer<typeof ProviderInfoSchema>;
+
+export const ModelCollectionSchema = z.object({
+	provider: ProviderInfoSchema,
+	models: z.record(z.string(), ModelInfoSchema),
+});
+
+export type ModelCollection = z.infer<typeof ModelCollectionSchema>;
diff --git a/sdk/packages/llms/src/index.browser.ts b/sdk/packages/llms/src/index.browser.ts
new file mode 100644
index 0000000..ee2b2e8
--- /dev/null
+++ b/sdk/packages/llms/src/index.browser.ts
@@ -0,0 +1,52 @@
+export type {
+	ModelCollection,
+	ModelIdAliasRule,
+	ModelInfo,
+	ModelInfo as CatalogModelInfo,
+	ProviderCapability as CatalogProviderCapability,
+	ProviderInfo,
+} from "./models";
+export {
+	CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	filterOpenAICodexModels,
+	getAllProviders,
+	getGeneratedModelsForProvider,
+	getModelsForProvider,
+	getProvider,
+	getProviderCollection,
+	getProviderCollectionSync,
+	getProviderIds,
+	hasProvider,
+	isCanonicalModelIdForAliasRules,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID,
+	preferCanonicalModelIds,
+	registerModel,
+	registerProvider,
+	resetRegistry,
+	unregisterProvider,
+	VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+} from "./models";
+export {
+	type ProviderUsageCostDisplay,
+	resolveProviderUsageCostDisplay,
+	shouldShowProviderUsageCost,
+} from "./providers/billing";
+export type {
+	ProviderCapability,
+	ProviderId,
+} from "./providers.browser";
+export {
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClineNotSubscribedMessage,
+	getClinePassSubscriptionUrl,
+	isClineNotSubscribedError,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionError,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitError,
+	isClinePassLimitMessage,
+	normalizeProviderId,
+} from "./providers.browser";
diff --git a/sdk/packages/llms/src/index.ts b/sdk/packages/llms/src/index.ts
new file mode 100644
index 0000000..b49de7d
--- /dev/null
+++ b/sdk/packages/llms/src/index.ts
@@ -0,0 +1,93 @@
+export type {
+	ModelCollection,
+	ModelIdAliasRule,
+	ModelInfo,
+	ModelInfo as CatalogModelInfo,
+	ProviderCapability as CatalogProviderCapability,
+	ProviderClient,
+	ProviderInfo,
+	ProviderProtocol,
+} from "./models";
+export {
+	CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	fetchLiveProviderModels,
+	fetchModelsDevProviderModels,
+	filterOpenAICodexModels,
+	getAllProviders,
+	getGeneratedModelsForProvider,
+	getGeneratedProviderModels,
+	getModelsForProvider,
+	getProvider,
+	getProviderCollection,
+	getProviderCollectionSync,
+	getProviderIds,
+	hasProvider,
+	isCanonicalModelIdForAliasRules,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID,
+	preferCanonicalModelIds,
+	registerModel,
+	registerProvider,
+	resetRegistry,
+	sortModelsByReleaseDate,
+	unregisterProvider,
+	VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+} from "./models";
+export type {
+	ApiHandler,
+	ApiStreamChunk,
+	BuiltInProviderId,
+	ContentBlock,
+	FileContent,
+	HandlerFactory,
+	HandlerModelInfo,
+	ImageContent,
+	LazyHandlerFactory,
+	Message,
+	MessageRole,
+	MessageWithMetadata,
+	ProviderCapability,
+	ProviderConfig,
+	ProviderId,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolDefinition,
+	ToolResultContent,
+	ToolUseContent,
+} from "./providers";
+export {
+	BUILT_IN_PROVIDER,
+	BUILT_IN_PROVIDER_IDS,
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	createHandler,
+	createHandlerAsync,
+	extractClinePassLimitMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClineNotSubscribedMessage,
+	getClinePassSubscriptionUrl,
+	getRegisteredHandler,
+	getRegisteredHandlerAsync,
+	hasRegisteredHandler,
+	isBuiltInProviderId,
+	isClineNotSubscribedError,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionError,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitError,
+	isClinePassLimitMessage,
+	isRegisteredHandlerAsync,
+	normalizeProviderId,
+	registerAsyncHandler,
+	registerHandler,
+} from "./providers";
+export {
+	type ProviderUsageCostDisplay,
+	resolveProviderUsageCostDisplay,
+	shouldShowProviderUsageCost,
+} from "./providers/billing";
+export type * from "./providers/gateway";
+export { createGateway, DefaultGateway } from "./providers/gateway";
+export { resolveProviderModelCatalogKeys } from "./providers/provider-keys";
+export { disposeLangfuseTelemetry } from "./services/langfuse-telemetry";
diff --git a/sdk/packages/llms/src/models.ts b/sdk/packages/llms/src/models.ts
new file mode 100644
index 0000000..806bfac
--- /dev/null
+++ b/sdk/packages/llms/src/models.ts
@@ -0,0 +1,41 @@
+export {
+	getGeneratedModelsForProvider,
+	getGeneratedProviderModels,
+} from "./catalog/catalog.generated-access";
+export {
+	fetchLiveProviderModels,
+	fetchModelsDevProviderModels,
+	sortModelsByReleaseDate,
+} from "./catalog/catalog-live";
+export type { ModelIdAliasRule } from "./catalog/model-id-aliases";
+export {
+	isCanonicalModelIdForAliasRules,
+	preferCanonicalModelIds,
+	VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+} from "./catalog/model-id-aliases";
+export type {
+	ModelCollection,
+	ModelInfo,
+	ProviderCapability,
+	ProviderClient,
+	ProviderInfo,
+	ProviderProtocol,
+} from "./catalog/types";
+export {
+	getAllProviders,
+	getModelsForProvider,
+	getProvider,
+	getProviderCollection,
+	getProviderCollectionSync,
+	getProviderIds,
+	hasProvider,
+	MODEL_COLLECTIONS_BY_PROVIDER_ID,
+	registerModel,
+	registerProvider,
+	resetRegistry,
+	unregisterProvider,
+} from "./providers/model-registry";
+export {
+	CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	filterOpenAICodexModels,
+} from "./providers/openai-codex-models";
diff --git a/sdk/packages/llms/src/providers.browser.ts b/sdk/packages/llms/src/providers.browser.ts
new file mode 100644
index 0000000..7696819
--- /dev/null
+++ b/sdk/packages/llms/src/providers.browser.ts
@@ -0,0 +1,20 @@
+export {
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	extractClinePassLimitMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClineNotSubscribedMessage,
+	getClinePassSubscriptionUrl,
+	isClineNotSubscribedError,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionError,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitError,
+	isClinePassLimitMessage,
+} from "./providers/errors";
+export {
+	normalizeProviderId,
+	type ProviderCapability,
+	type ProviderId,
+} from "./providers/types";
diff --git a/sdk/packages/llms/src/providers.ts b/sdk/packages/llms/src/providers.ts
new file mode 100644
index 0000000..5c08258
--- /dev/null
+++ b/sdk/packages/llms/src/providers.ts
@@ -0,0 +1,121 @@
+export {
+	type ApiHandler,
+	BUILT_IN_PROVIDER,
+	BUILT_IN_PROVIDER_IDS,
+	type BuiltInProviderId,
+	type HandlerFactory,
+	isBuiltInProviderId,
+	type LazyHandlerFactory,
+	normalizeProviderId,
+	type ProviderCapability,
+	type ProviderConfig,
+	type ProviderId,
+} from "./providers/types";
+
+import {
+	createGatewayApiHandler,
+	createGatewayApiHandlerAsync,
+} from "./providers/compat";
+import {
+	getRegisteredHandler,
+	getRegisteredHandlerAsync,
+	hasRegisteredHandler,
+	isRegisteredHandlerAsync,
+} from "./providers/factory-registry";
+import {
+	type ApiHandler,
+	normalizeProviderId,
+	type ProviderConfig,
+} from "./providers/types";
+
+export {
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	extractClinePassLimitMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClineNotSubscribedMessage,
+	getClinePassSubscriptionUrl,
+	isClineNotSubscribedError,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionError,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitError,
+	isClinePassLimitMessage,
+} from "./providers/errors";
+export {
+	getRegisteredHandler,
+	getRegisteredHandlerAsync,
+	hasRegisteredHandler,
+	isRegisteredHandlerAsync,
+	registerAsyncHandler,
+	registerHandler,
+} from "./providers/factory-registry";
+export type {
+	ApiStreamChunk,
+	ContentBlock,
+	FileContent,
+	HandlerModelInfo,
+	ImageContent,
+	Message,
+	MessageRole,
+	MessageWithMetadata,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolDefinition,
+	ToolResultContent,
+	ToolUseContent,
+} from "./providers/types";
+
+function withNormalizedProviderId(config: ProviderConfig): ProviderConfig {
+	const providerId = normalizeProviderId(config.providerId);
+	const routingProviderId = config.routingProviderId
+		? normalizeProviderId(config.routingProviderId)
+		: undefined;
+	if (
+		providerId === config.providerId &&
+		routingProviderId === config.routingProviderId
+	) {
+		return config;
+	}
+	return { ...config, providerId, routingProviderId };
+}
+
+export function createHandler(config: ProviderConfig): ApiHandler {
+	const normalizedConfig = withNormalizedProviderId(config);
+	const { providerId } = normalizedConfig;
+
+	if (hasRegisteredHandler(providerId)) {
+		if (isRegisteredHandlerAsync(providerId)) {
+			throw new Error(
+				`Handler for "${providerId}" is registered as async. Use createHandlerAsync() instead.`,
+			);
+		}
+		const handler = getRegisteredHandler(providerId, normalizedConfig);
+		if (handler) {
+			return handler;
+		}
+	}
+
+	return createGatewayApiHandler(normalizedConfig);
+}
+
+export async function createHandlerAsync(
+	config: ProviderConfig,
+): Promise<ApiHandler> {
+	const normalizedConfig = withNormalizedProviderId(config);
+	const { providerId } = normalizedConfig;
+
+	if (hasRegisteredHandler(providerId)) {
+		const handler = await getRegisteredHandlerAsync(
+			providerId,
+			normalizedConfig,
+		);
+		if (handler) {
+			return handler;
+		}
+	}
+
+	return createGatewayApiHandlerAsync(normalizedConfig);
+}
diff --git a/sdk/packages/llms/src/providers/README.md b/sdk/packages/llms/src/providers/README.md
new file mode 100644
index 0000000..75b8212
--- /dev/null
+++ b/sdk/packages/llms/src/providers/README.md
@@ -0,0 +1,147 @@
+# Provider Request Capture
+
+This directory contains the SDK provider gateway and AI SDK provider adapter.
+`provider-request-capture.ts` adds an opt-in local capture path for debugging
+the exact prompt/request sent to a model provider.
+
+The capture layer is provider-agnostic. It does not import Weave, W&B, OTel, or
+plugin code. A plugin or external tool can correlate records by stamping
+`request.options.metadata` before the request reaches `sdk/packages/llms`.
+
+## Why This Exists
+
+Plugin hooks can observe Cline's conversation state, but they run before Core's
+final provider-message preparation. That final pass can repair missing tool
+results, truncate tool outputs, rewrite stale file content, apply prompt-cache
+provider options, and format messages for the provider.
+
+For token investigations, compare these layers:
+
+```text
+Plugin-visible messages
+  captureStage = pre_build_for_api
+        |
+        v
+Core MessageBuilder.buildForApi(...)
+        |
+        v
+AI SDK prompt passed to streamText(...)
+  captureStage = ai_sdk_prompt
+        |
+        v
+Provider client fetch(...)
+  captureStage = wire_request, only when CLINE_CAPTURE_WIRE=true
+        |
+        v
+Provider receives request
+```
+
+If token growth appears only in `wire_request`, the issue is provider
+serialization. If it appears in `ai_sdk_prompt` but not `pre_build_for_api`, the
+issue is in Cline's final provider formatting/build step. If it is already in
+`pre_build_for_api`, the issue is upstream of the final build step.
+
+## Environment Variables
+
+| Variable | Values | Default | Purpose |
+| --- | --- | --- | --- |
+| `CLINE_CAPTURE_PROVIDER_REQUEST` | `off`, `summary`, `full` | `off` | Enables provider request capture. |
+| `CLINE_CAPTURE_WIRE` | `true`, `false` | `false` | Wraps provider `fetch` to capture literal request bodies. |
+| `CLINE_CAPTURE_DIR` | filesystem path | unset | Explicit output directory for capture files. |
+| `CLINE_CAPTURE_CLEANUP` | `on`, `off` | `on` | Prunes old capture files. Set `off` to keep local files. |
+| `CLINE_CAPTURE_MAX_PREVIEW_BYTES` | positive integer | `65536` | Full-mode payload preview byte cap. |
+| `CLINE_DATA_DIR` | filesystem path | unset | Fallback base directory. Captures write to `CLINE_DATA_DIR/provider-request-captures`. |
+
+If neither `CLINE_CAPTURE_DIR` nor `CLINE_DATA_DIR` is set, capture no-ops. This
+prevents prompt content from being written into a repository working tree by
+accident.
+
+## Output
+
+Capture writes one JSON file per captured stage:
+
+```text
+${CLINE_CAPTURE_DIR}/<captureId>.<captureStage>.<attempt>.provider-request.json
+```
+
+or, when only `CLINE_DATA_DIR` is set:
+
+```text
+${CLINE_DATA_DIR}/provider-request-captures/<captureId>.<captureStage>.<attempt>.provider-request.json
+```
+
+Files are written atomically through a temporary file and same-directory rename,
+so consumers should ignore `*.tmp`. `captureId` comes from
+`GatewayStreamRequest.metadata.captureId` when present; otherwise the SDK derives
+a stable ID from request correlation metadata. `attempt` increments when the same
+stage is captured more than once for a request, such as provider retries.
+
+When `CLINE_CAPTURE_CLEANUP` is on, the SDK opportunistically prunes capture
+files older than 24 hours. Consumers may also delete files after processing them.
+Set `CLINE_CAPTURE_CLEANUP=off` when you need to keep local capture files for
+manual inspection.
+
+Each record includes:
+
+- `timestamp`
+- `captureStage`: `ai_sdk_prompt` or `wire_request`
+- `attempt`
+- `mode`: `summary` or `full`
+- `correlation`: copied from `GatewayStreamRequest.metadata`, plus provider and model IDs
+- `summary`: byte counts, estimated tokens, hashes, role counts, largest messages, reasoning/tool-result counts
+- `payload`: only in `full` mode, truncated to `CLINE_CAPTURE_MAX_PREVIEW_BYTES`
+
+Wire capture intentionally records URL, method, and body only. It does not record
+headers, so authorization values are not written to capture files.
+
+## Example
+
+```bash
+export CLINE_DATA_DIR="$(mktemp -d)"
+export CLINE_CAPTURE_PROVIDER_REQUEST=summary
+export CLINE_CAPTURE_WIRE=true
+
+cline --provider openrouter --model openai/gpt-4o-mini "Say hello"
+
+ls "$CLINE_DATA_DIR/provider-request-captures"
+```
+
+For an internal investigation where full request bodies are expected:
+
+```bash
+export CLINE_DATA_DIR="$(mktemp -d)"
+export CLINE_CAPTURE_PROVIDER_REQUEST=full
+export CLINE_CAPTURE_WIRE=true
+export CLINE_CAPTURE_MAX_PREVIEW_BYTES=1000000
+# Optional: keep files after consumers process them.
+# export CLINE_CAPTURE_CLEANUP=off
+```
+
+## Correlation
+
+The capture module reads `GatewayStreamRequest.metadata` and copies it into each
+record. A plugin can stamp this metadata from a `beforeModel` hook:
+
+```text
+beforeModel hook
+  returns options.metadata = { captureId, sessionId, runId, conversationId, iteration }
+        |
+        v
+agents/core hook composition deep-merges metadata
+        |
+        v
+GatewayStreamRequest.metadata
+        |
+        v
+provider-request-capture.ts writes per-stage files keyed by captureId
+```
+
+The Weave tracing plugin uses this path to join local provider captures onto the
+matching model span, but the SDK capture files are useful without Weave too.
+
+## Coverage
+
+This capture path is currently wired into the AI SDK provider adapter in
+`ai-sdk.ts`. Providers that bypass `createAiSdkProvider(...)` will not emit
+`ai_sdk_prompt` or `wire_request` records until they get equivalent
+instrumentation.
diff --git a/sdk/packages/llms/src/providers/ai-sdk.test.ts b/sdk/packages/llms/src/providers/ai-sdk.test.ts
new file mode 100644
index 0000000..9b99bb3
--- /dev/null
+++ b/sdk/packages/llms/src/providers/ai-sdk.test.ts
@@ -0,0 +1,413 @@
+import { describe, expect, it } from "vitest";
+import fixtures from "../../fixtures/usage.json";
+import { normalizeUsage } from "./ai-sdk";
+
+/**
+ * These tests validate usage normalization across different AI SDK stream result shapes.
+ * We test against real fixture data from multiple providers to ensure:
+ * - Finish part usage (AiSdkStreamFinishPart.totalUsage) normalizes correctly
+ * - Stream.usage promise result (AiSdkStreamUsage) normalizes correctly with raw data
+ * - Token counts map from provider-specific field names to standard format
+ * - Cost extraction works when available in raw provider response
+ */
+
+// Import normalizeUsage - would need to export this from ai-sdk.ts for testing
+// For now, documenting what we'd test when exported
+const testCases = [
+	{
+		provider: "openrouter",
+		description: "handles cache tokens and upstream cost breakdown",
+		finishUsage: (
+			(fixtures as Record<string, unknown>).openrouter_finish as Record<
+				string,
+				unknown
+			>
+		).totalUsage,
+		streamUsage: (fixtures as Record<string, unknown>)
+			.openrouter_stream_usage as Record<string, unknown>,
+		expectedNormalized: {
+			inputTokens: 9096,
+			outputTokens: 77,
+			cacheReadTokens: 9090,
+			cacheWriteTokens: 0,
+		},
+		expectedNormalizedStreamUsage: {
+			inputTokens: 9096,
+			outputTokens: 77,
+			cacheReadTokens: 9090,
+			cacheWriteTokens: 0,
+			totalCost: 0.0068249999999999995, // BYOK fee + upstream provider cost
+		},
+	},
+	{
+		provider: "gemini",
+		description: "maps Gemini's promptTokenCount to inputTokens",
+		finishUsage: (
+			(fixtures as Record<string, unknown>).gemini_finish as Record<
+				string,
+				unknown
+			>
+		).totalUsage,
+		streamUsage: (fixtures as Record<string, unknown>)
+			.gemini_stream_usage as Record<string, unknown>,
+		expectedNormalized: {
+			inputTokens: 4605,
+			outputTokens: 120,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+		},
+	},
+	{
+		provider: "anthropic",
+		description: "extracts cache tokens from Anthropic's raw response",
+		finishUsage: (
+			(fixtures as Record<string, unknown>).anthropic_finish as Record<
+				string,
+				unknown
+			>
+		).totalUsage,
+		streamUsage: (fixtures as Record<string, unknown>)
+			.anthropic_stream_usage as Record<string, unknown>,
+		expectedNormalized: {
+			inputTokens: 6538,
+			outputTokens: 176,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 6535, // Now extracted from nested inputTokenDetails.cacheWriteTokens
+		},
+		expectedNormalizedStreamUsage: {
+			inputTokens: 6538,
+			outputTokens: 176,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 6535, // Extracted from nested inputTokenDetails.cacheWriteTokens
+		},
+	},
+	{
+		provider: "openai",
+		description: "handles OpenAI's input_tokens_details.cached_tokens",
+		finishUsage: (
+			(fixtures as Record<string, unknown>).openai_finish as Record<
+				string,
+				unknown
+			>
+		).totalUsage,
+		streamUsage: (fixtures as Record<string, unknown>)
+			.openai_stream_usage as Record<string, unknown>,
+		expectedNormalized: {
+			inputTokens: 3824,
+			outputTokens: 14,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+		},
+	},
+	{
+		provider: "vercel",
+		description:
+			"preserves finish-part totals when Vercel reports cached tokens",
+		finishUsage: (
+			(fixtures as Record<string, unknown>).vercel_finish as Record<
+				string,
+				unknown
+			>
+		).totalUsage,
+		streamUsage: (fixtures as Record<string, unknown>)
+			.vercel_stream_usage as Record<string, unknown>,
+		expectedNormalized: {
+			inputTokens: 6781,
+			outputTokens: 70,
+			cacheReadTokens: 6667,
+			cacheWriteTokens: 0,
+		},
+		expectedNormalizedStreamUsage: {
+			inputTokens: 4550,
+			outputTokens: 10,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0.000641,
+		},
+	},
+];
+
+describe("ai-sdk usage normalization", () => {
+	describe.each(testCases)("$provider", ({
+		description,
+		finishUsage,
+		streamUsage,
+		expectedNormalized,
+		expectedNormalizedStreamUsage,
+	}) => {
+		it(`finish part: ${description}`, () => {
+			const normalized = normalizeUsage(finishUsage as Record<string, unknown>);
+			expect(normalized.inputTokens).toBe(expectedNormalized.inputTokens);
+			expect(normalized.outputTokens).toBe(expectedNormalized.outputTokens);
+			expect(normalized.cacheReadTokens).toBe(
+				expectedNormalized.cacheReadTokens,
+			);
+			expect(normalized.cacheWriteTokens).toBe(
+				expectedNormalized.cacheWriteTokens,
+			);
+		});
+
+		it(`stream.usage: ${description}`, () => {
+			const normalized = normalizeUsage(streamUsage as Record<string, unknown>);
+			const expected = (expectedNormalizedStreamUsage ??
+				expectedNormalized) as Record<string, unknown>;
+			expect(normalized.inputTokens).toBe(expected.inputTokens);
+			expect(normalized.outputTokens).toBe(expected.outputTokens);
+			expect(normalized.cacheReadTokens).toBe(expected.cacheReadTokens);
+			expect(normalized.cacheWriteTokens).toBe(expected.cacheWriteTokens);
+			if (typeof expected.totalCost === "number") {
+				expect(normalized.totalCost).toBeCloseTo(expected.totalCost, 5);
+			}
+		});
+	});
+
+	it("finish part lacks raw provider metadata", () => {
+		const finishPart = (fixtures as Record<string, unknown>)
+			.openrouter_finish as Record<string, unknown>;
+		expect(finishPart).not.toHaveProperty("raw");
+		expect(finishPart).toHaveProperty("type", "finish");
+	});
+
+	it("stream.usage includes raw provider response", () => {
+		const streamUsage = (fixtures as Record<string, unknown>)
+			.openrouter_stream_usage as Record<string, unknown>;
+		expect(streamUsage).toHaveProperty("raw");
+		expect(streamUsage.raw).toHaveProperty("cost_details");
+	});
+
+	it("maps provider reasoning tokens to reasoningTokenCount", () => {
+		expect(
+			normalizeUsage({
+				completion_tokens_details: { reasoning_tokens: 17 },
+			}).reasoningTokenCount,
+		).toBe(17);
+		expect(
+			normalizeUsage({
+				outputTokenDetails: { reasoningTokens: 23 },
+			}).reasoningTokenCount,
+		).toBe(23);
+		expect(
+			normalizeUsage({
+				raw: { outputTokenDetails: { reasoningTokens: 31 } },
+			}).reasoningTokenCount,
+		).toBe(31);
+		expect(
+			normalizeUsage({}, { openrouter: { usage: { reasoning_tokens: 37 } } })
+				.reasoningTokenCount,
+		).toBe(37);
+	});
+
+	it("preserves source precedence when multiple reasoning token values exist", () => {
+		const normalized = normalizeUsage(
+			{
+				reasoningTokens: 11,
+				raw: { reasoningTokens: 22 },
+			},
+			{ openrouter: { usage: { reasoning_tokens: 33 } } },
+		);
+
+		expect(normalized.reasoningTokenCount).toBe(11);
+	});
+
+	it("coerces string reasoning token counts", () => {
+		expect(
+			normalizeUsage({
+				raw: { outputTokenDetails: { reasoningTokens: "41" } },
+			}).reasoningTokenCount,
+		).toBe(41);
+	});
+
+	describe("cost extraction with pricing fallback", () => {
+		it("uses market_cost when available (Vercel)", () => {
+			const vercelUsage = (fixtures as Record<string, unknown>)
+				.vercel_stream_usage as Record<string, unknown>;
+			const normalized = normalizeUsage(vercelUsage);
+			expect(normalized.totalCost).toBe(0.000641);
+		});
+
+		it("sums BYOK fee + upstream provider cost when OpenRouter marks the request as BYOK", () => {
+			const openrouterUsage = (fixtures as Record<string, unknown>)
+				.openrouter_stream_usage as Record<string, unknown>;
+			const normalized = normalizeUsage(openrouterUsage);
+			expect(normalized.totalCost).toBeCloseTo(0.006825, 5);
+		});
+
+		it("does not double-count OpenRouter credit-billed usage when upstream mirrors cost", () => {
+			const normalized = normalizeUsage({
+				prompt_tokens: 15,
+				completion_tokens: 5,
+				cost: 0.0000301,
+				is_byok: false,
+				cost_details: {
+					upstream_inference_cost: 0.0000301,
+				},
+			});
+
+			expect(normalized.totalCost).toBe(0.0000301);
+		});
+
+		it("uses upstream inference cost when OpenRouter reports no account charge for BYOK", () => {
+			const normalized = normalizeUsage({
+				prompt_tokens: 10,
+				completion_tokens: 5,
+				cost: 0,
+				is_byok: true,
+				cost_details: {
+					upstream_inference_cost: 0.000036,
+				},
+			});
+
+			expect(normalized.totalCost).toBe(0.000036);
+		});
+
+		it("falls back to upstream inference cost when it is the only explicit cost", () => {
+			const normalized = normalizeUsage({
+				prompt_tokens: 10,
+				completion_tokens: 5,
+				cost_details: {
+					upstream_inference_cost: 0.000036,
+				},
+			});
+
+			expect(normalized.totalCost).toBe(0.000036);
+		});
+
+		it("calculates cost from pricing when no explicit cost in response", () => {
+			const pricingInput = { input: 2.5, output: 10 }; // per 1M tokens
+			const normalized = normalizeUsage(
+				{ inputTokens: 1000, outputTokens: 100 },
+				undefined,
+				pricingInput,
+			);
+			// (1000/1M) * 2.5 + (100/1M) * 10 = 0.0025 + 0.001 = 0.0035
+			expect(normalized.totalCost).toBeCloseTo(0.0035, 5);
+		});
+	});
+
+	describe("field mapping across providers", () => {
+		it("maps AI SDK v3 usage token details", () => {
+			const normalized = normalizeUsage({
+				inputTokens: {
+					total: 4605,
+					noCache: 1000,
+					cacheRead: 3605,
+					cacheWrite: undefined,
+				},
+				outputTokens: {
+					total: 120,
+					text: 120,
+					reasoning: 0,
+				},
+				raw: {
+					promptTokenCount: 4605,
+					candidatesTokenCount: 120,
+					cachedContentTokenCount: 3605,
+				},
+			} as Record<string, unknown>);
+
+			expect(normalized.inputTokens).toBe(4605);
+			expect(normalized.outputTokens).toBe(120);
+			expect(normalized.cacheReadTokens).toBe(3605);
+			expect(normalized.cacheWriteTokens).toBe(0);
+		});
+
+		it("falls back to raw Gemini usage metadata", () => {
+			const normalized = normalizeUsage({
+				raw: {
+					promptTokenCount: 4605,
+					candidatesTokenCount: 120,
+					cachedContentTokenCount: 3605,
+				},
+			} as Record<string, unknown>);
+
+			expect(normalized.inputTokens).toBe(4605);
+			expect(normalized.outputTokens).toBe(120);
+			expect(normalized.cacheReadTokens).toBe(3605);
+			expect(normalized.cacheWriteTokens).toBe(0);
+		});
+
+		it("maps camelCase inputTokens from multiple naming conventions", () => {
+			const inputs = [
+				{ inputTokens: 100 }, // Already camelCase
+				{ input_tokens: 100 }, // snake_case
+				{ prompt_tokens: 100 }, // OpenAI convention
+			];
+			// Each should normalize to inputTokens: 100
+			expect(inputs.length).toBe(3);
+		});
+
+		it("extracts cacheReadTokens from nested structures", () => {
+			const nested = {
+				inputTokenDetails: { cacheReadTokens: 50 }, // Nested camelCase
+			};
+			const flattened = {
+				cache_read_tokens: 50, // Flat snake_case
+			};
+			// Both should normalize to cacheReadTokens: 50
+			expect(nested).toBeDefined();
+			expect(flattened).toBeDefined();
+		});
+
+		it("extracts Qwen cache writes from OpenRouter prompt token details", () => {
+			const normalized = normalizeUsage({
+				prompt_tokens: 10126,
+				completion_tokens: 13,
+				prompt_tokens_details: {
+					cached_tokens: 0,
+					cache_write_tokens: 10106,
+				},
+			});
+
+			expect(normalized).toEqual(
+				expect.objectContaining({
+					inputTokens: 10126,
+					outputTokens: 13,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 10106,
+				}),
+			);
+		});
+
+		it("extracts Qwen cache reads from raw prompt token details", () => {
+			const normalized = normalizeUsage({
+				raw: {
+					prompt_tokens_details: {
+						cached_tokens: 8885,
+						cache_write_tokens: 10106,
+					},
+				},
+			});
+
+			expect(normalized).toEqual(
+				expect.objectContaining({
+					cacheReadTokens: 8885,
+					cacheWriteTokens: 10106,
+				}),
+			);
+		});
+
+		it("handles Anthropic's cache_creation metadata", () => {
+			const anthropicRaw = (
+				(fixtures as Record<string, unknown>).anthropic_stream_usage as Record<
+					string,
+					unknown
+				>
+			).raw;
+			expect(anthropicRaw).toHaveProperty("cache_creation");
+			expect(
+				(anthropicRaw as Record<string, unknown>).cache_creation,
+			).toHaveProperty("ephemeral_5m_input_tokens");
+		});
+
+		it("handles Gemini's promptTokenCount naming", () => {
+			const geminiRaw = (
+				(fixtures as Record<string, unknown>).gemini_stream_usage as Record<
+					string,
+					unknown
+				>
+			).raw;
+			expect(geminiRaw).toHaveProperty("promptTokenCount");
+			expect(geminiRaw).toHaveProperty("candidatesTokenCount");
+		});
+	});
+});
diff --git a/sdk/packages/llms/src/providers/ai-sdk.tool-calls.test.ts b/sdk/packages/llms/src/providers/ai-sdk.tool-calls.test.ts
new file mode 100644
index 0000000..8855a49
--- /dev/null
+++ b/sdk/packages/llms/src/providers/ai-sdk.tool-calls.test.ts
@@ -0,0 +1,264 @@
+import type {
+	AgentModelEvent,
+	AgentToolDefinition,
+	GatewayProviderContext,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import { NoSuchToolError } from "ai";
+import { describe, expect, it } from "vitest";
+import {
+	createOpenAICompatibleProvider,
+	repairMalformedToolCall,
+} from "./ai-sdk";
+
+/**
+ * Integration tests for malformed tool-call handling in the AI SDK adapter.
+ *
+ * Weaker models routinely emit tool calls with type mismatches (a bare string
+ * where the schema wants an array) or arguments that are not valid JSON
+ * (truncated payloads, single quotes). These tests drive the real adapter
+ * with a fake OpenAI-compatible SSE response and assert that such calls are
+ * coerced/repaired instead of being rejected before execution
+ * (`metadata.inputParseError`), which surfaced as the
+ * tool_call_type_validation / tool_call_invalid_json buckets under
+ * task.provider_api_error.
+ */
+
+const RUN_COMMANDS_TOOL: AgentToolDefinition = {
+	name: "run_commands",
+	description: "Run shell commands",
+	inputSchema: {
+		type: "object",
+		properties: {
+			commands: { type: "array", items: { type: "string" } },
+		},
+		required: ["commands"],
+	},
+};
+
+const READ_FILES_TOOL: AgentToolDefinition = {
+	name: "read_files",
+	description: "Read files",
+	inputSchema: {
+		type: "object",
+		properties: {
+			files: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: { path: { type: "string" } },
+					required: ["path"],
+				},
+			},
+		},
+		required: ["files"],
+	},
+};
+
+function sseToolCall(toolName: string, args: string): string {
+	const chunk = (delta: unknown, finish: string | null = null) =>
+		`data: ${JSON.stringify({
+			id: "cmpl-1",
+			object: "chat.completion.chunk",
+			created: 1,
+			model: "test-model",
+			choices: [{ index: 0, delta, finish_reason: finish }],
+		})}\n\n`;
+	return (
+		chunk({
+			role: "assistant",
+			tool_calls: [
+				{
+					index: 0,
+					id: "call_1",
+					type: "function",
+					function: { name: toolName, arguments: "" },
+				},
+			],
+		}) +
+		chunk({ tool_calls: [{ index: 0, function: { arguments: args } }] }) +
+		chunk({}, "tool_calls") +
+		"data: [DONE]\n\n"
+	);
+}
+
+async function streamToolCallEvents(
+	sseBody: string,
+	tools: AgentToolDefinition[],
+): Promise<AgentModelEvent[]> {
+	const config = {
+		providerId: "openai-compatible",
+		apiKey: "test-key",
+		baseUrl: "http://fake.local/v1",
+		fetch: (async () =>
+			new Response(sseBody, {
+				status: 200,
+				headers: { "content-type": "text/event-stream" },
+			})) as unknown as typeof fetch,
+	};
+	const provider = await createOpenAICompatibleProvider(config);
+	const model = {
+		id: "test-model",
+		providerId: "openai-compatible",
+		name: "test-model",
+	};
+	const context = {
+		provider: {
+			id: "openai-compatible",
+			name: "OpenAI Compatible",
+			defaultModelId: "test-model",
+			models: [model],
+		},
+		model,
+		config,
+	} as unknown as GatewayProviderContext;
+	const request = {
+		providerId: "openai-compatible",
+		modelId: "test-model",
+		messages: [
+			{
+				id: "msg_user",
+				role: "user",
+				content: [{ type: "text", text: "do the thing" }],
+				createdAt: new Date(),
+			},
+		],
+		tools,
+	} as unknown as GatewayStreamRequest;
+
+	const events: AgentModelEvent[] = [];
+	for await (const event of await provider.stream(request, context)) {
+		events.push(event);
+	}
+	return events;
+}
+
+function findParseError(events: AgentModelEvent[]): string | undefined {
+	for (const event of events) {
+		if (event.type !== "tool-call-delta") continue;
+		const metadata = event.metadata as Record<string, unknown> | undefined;
+		if (typeof metadata?.inputParseError === "string") {
+			return metadata.inputParseError;
+		}
+	}
+	return undefined;
+}
+
+function findToolInput(events: AgentModelEvent[]): unknown {
+	for (const event of events) {
+		if (event.type === "tool-call-delta" && event.input !== undefined) {
+			return event.input;
+		}
+	}
+	return undefined;
+}
+
+describe("ai-sdk adapter malformed tool calls", () => {
+	it("passes schema-mismatched input through to the tool instead of rejecting", async () => {
+		// The executor's lenient union schema accepts a bare string for a
+		// string[] property; rejecting at the adapter would prevent that.
+		const events = await streamToolCallEvents(
+			sseToolCall("run_commands", '{"commands": "ls -la"}'),
+			[RUN_COMMANDS_TOOL],
+		);
+
+		expect(findParseError(events)).toBeUndefined();
+		expect(findToolInput(events)).toEqual({ commands: "ls -la" });
+	});
+
+	it("passes well-formed input through unchanged", async () => {
+		const events = await streamToolCallEvents(
+			sseToolCall("run_commands", '{"commands": ["ls", "pwd"]}'),
+			[RUN_COMMANDS_TOOL],
+		);
+
+		expect(findParseError(events)).toBeUndefined();
+		expect(findToolInput(events)).toEqual({ commands: ["ls", "pwd"] });
+	});
+
+	it("repairs truncated JSON arguments", async () => {
+		const events = await streamToolCallEvents(
+			sseToolCall("read_files", '{"files": [{"path": "/tmp/a.txt"}]'),
+			[READ_FILES_TOOL],
+		);
+
+		expect(findParseError(events)).toBeUndefined();
+		expect(findToolInput(events)).toEqual({ files: [{ path: "/tmp/a.txt" }] });
+	});
+
+	it("repairs single-quoted JSON arguments", async () => {
+		const events = await streamToolCallEvents(
+			sseToolCall("run_commands", "{'commands': ['ls']}"),
+			[RUN_COMMANDS_TOOL],
+		);
+
+		expect(findParseError(events)).toBeUndefined();
+		expect(findToolInput(events)).toEqual({ commands: ["ls"] });
+	});
+
+	it("still surfaces a parse error for unrepairable argument text", async () => {
+		const events = await streamToolCallEvents(
+			sseToolCall("run_commands", "run ls for me please"),
+			[RUN_COMMANDS_TOOL],
+		);
+
+		expect(findParseError(events)).toContain("Invalid input");
+	});
+
+	it("keeps the unavailable-tool error for unknown tools", async () => {
+		const events = await streamToolCallEvents(
+			sseToolCall("editor", '{"path": "/tmp/a.txt", "new_text": "x"}'),
+			[RUN_COMMANDS_TOOL, READ_FILES_TOOL],
+		);
+
+		expect(findParseError(events)).toContain("unavailable tool 'editor'");
+	});
+});
+
+describe("repairMalformedToolCall", () => {
+	const toolCall = (input: string) => ({
+		toolCallId: "call_1",
+		toolName: "run_commands",
+		input,
+	});
+
+	it("repairs truncated JSON", async () => {
+		const repaired = await repairMalformedToolCall({
+			toolCall: toolCall('{"commands": ["ls"'),
+			error: new Error("JSON parsing failed"),
+		});
+		expect(repaired?.input).toBe('{"commands":["ls"]}');
+	});
+
+	it("repairs single-quoted JSON", async () => {
+		const repaired = await repairMalformedToolCall({
+			toolCall: toolCall("{'commands': ['ls']}"),
+			error: new Error("JSON parsing failed"),
+		});
+		expect(repaired?.input).toBe('{"commands":["ls"]}');
+	});
+
+	it("returns null for already-valid JSON (schema failures are not repairable here)", async () => {
+		const repaired = await repairMalformedToolCall({
+			toolCall: toolCall('{"commands": "ls"}'),
+			error: new Error("Type validation failed"),
+		});
+		expect(repaired).toBeNull();
+	});
+
+	it("returns null for unknown-tool errors", async () => {
+		const repaired = await repairMalformedToolCall({
+			toolCall: toolCall('{"commands": ["ls"]}'),
+			error: new NoSuchToolError({ toolName: "run_commands" }),
+		});
+		expect(repaired).toBeNull();
+	});
+
+	it("returns null for unrepairable garbage", async () => {
+		const repaired = await repairMalformedToolCall({
+			toolCall: toolCall("run ls for me"),
+			error: new Error("JSON parsing failed"),
+		});
+		expect(repaired).toBeNull();
+	});
+});
diff --git a/sdk/packages/llms/src/providers/ai-sdk.ts b/sdk/packages/llms/src/providers/ai-sdk.ts
new file mode 100644
index 0000000..20b45d4
--- /dev/null
+++ b/sdk/packages/llms/src/providers/ai-sdk.ts
@@ -0,0 +1,1299 @@
+import type {
+	AgentMessage,
+	AgentModelEvent,
+	AgentModelFinishReason,
+	GatewayProviderContext,
+	GatewayProviderFactory,
+	GatewayResolvedProviderConfig,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import {
+	type AiSdkFormatterMessage,
+	type AiSdkFormatterPart,
+	captureSdkError,
+	formatMessagesForAiSdk,
+	parseJsonStream,
+	sanitizeSurrogates,
+} from "@cline/shared";
+import { jsonSchema, NoSuchToolError, streamText } from "ai";
+import { nanoid } from "nanoid";
+import { extractErrorMessage } from "./format";
+import {
+	isAnthropicCompatibleModel,
+	isCerebrasProvider,
+	resolveModelFamily,
+} from "./model-facts";
+import {
+	recordProviderRequestCapture,
+	wrapFetchForProviderRequestCapture,
+} from "./provider-request-capture";
+import {
+	applyPromptCacheToLastTextPart,
+	shouldApplyPromptCache,
+} from "./routing/anthropic-compatible";
+import {
+	type AiSdkProviderOptionsTarget,
+	composeAiSdkProviderOptions,
+} from "./routing/provider-options";
+import type {
+	AiSdkStreamPart,
+	AiSdkStreamResult,
+	AiSdkStreamTotalUsage,
+	AiSdkStreamUsage,
+	ProviderFactoryResult,
+} from "./vendors/types";
+
+interface GatewayNormalizedUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	reasoningTokenCount?: number;
+	totalCost?: number;
+}
+type ProviderModuleKind = AiSdkProviderOptionsTarget;
+
+function buildCachedAiSdkMessages(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+	systemPrompt?: string,
+) {
+	const aiMessages = toAiSdkMessages(request.messages, systemPrompt, {
+		includeReasoning: shouldIncludeReasoningHistory(request, context),
+	}) as Array<Record<string, unknown>>;
+	const includeAnthropic = isAnthropicCompatibleModel({
+		modelId: request.modelId,
+		family: resolveModelFamily(context),
+	});
+
+	for (let i = aiMessages.length - 1; i >= 0; i--) {
+		if (aiMessages[i]?.role === "user") {
+			applyPromptCacheToLastTextPart(
+				aiMessages[i],
+				request.providerId,
+				includeAnthropic,
+			);
+			break;
+		}
+	}
+
+	return aiMessages;
+}
+
+function resolveStickySession(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+):
+	| {
+			transport: "json-body" | "header";
+			field: string;
+			value: string;
+	  }
+	| undefined {
+	const stickySession = context.provider.metadata?.stickySession;
+	if (!stickySession) {
+		return undefined;
+	}
+	const metadata = request.metadata;
+	const value =
+		metadata && typeof metadata === "object"
+			? metadata[stickySession.metadataKey]
+			: undefined;
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	return {
+		transport: stickySession.transport,
+		field: stickySession.field,
+		value: trimmed,
+	};
+}
+
+type FetchBodyText =
+	| { source: "init-body"; text: string }
+	| { request: Request; source: "request"; text: string };
+
+async function bodyTextFromFetchInput(
+	input: Parameters<typeof fetch>[0],
+	init: Parameters<typeof fetch>[1],
+): Promise<FetchBodyText | undefined> {
+	const body = init?.body;
+	if (body === null) {
+		return undefined;
+	}
+	if (typeof body === "string") {
+		return { source: "init-body", text: body };
+	}
+	if (body instanceof URLSearchParams) {
+		return { source: "init-body", text: body.toString() };
+	}
+	if (body instanceof ArrayBuffer) {
+		return { source: "init-body", text: Buffer.from(body).toString("utf8") };
+	}
+	if (ArrayBuffer.isView(body)) {
+		return {
+			source: "init-body",
+			text: Buffer.from(body.buffer, body.byteOffset, body.byteLength).toString(
+				"utf8",
+			),
+		};
+	}
+	if (body !== undefined) {
+		return undefined;
+	}
+	if (input instanceof Request) {
+		try {
+			return {
+				request: input,
+				source: "request",
+				text: await input.clone().text(),
+			};
+		} catch {
+			return undefined;
+		}
+	}
+	return undefined;
+}
+
+async function injectJsonBodyStickySession(
+	input: Parameters<typeof fetch>[0],
+	init: Parameters<typeof fetch>[1],
+	stickySession: { field: string; value: string },
+): Promise<Parameters<typeof fetch>> {
+	const bodyText = await bodyTextFromFetchInput(input, init);
+	if (!bodyText?.text.trim().startsWith("{")) {
+		return [input, init];
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(bodyText.text);
+	} catch {
+		return [input, init];
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		return [input, init];
+	}
+	const body = parsed as Record<string, unknown>;
+	const existingValue = body[stickySession.field];
+	if (typeof existingValue !== "string" || !existingValue.trim()) {
+		body[stickySession.field] = stickySession.value;
+	}
+	const nextBody = JSON.stringify(body);
+	if (bodyText.source === "init-body") {
+		return [input, { ...init, body: nextBody }];
+	}
+	return [new Request(bodyText.request, { body: nextBody }), init];
+}
+
+function injectHeaderStickySession(
+	input: Parameters<typeof fetch>[0],
+	init: Parameters<typeof fetch>[1],
+	stickySession: { field: string; value: string },
+): Parameters<typeof fetch> {
+	const headers = new Headers(
+		input instanceof Request ? input.headers : undefined,
+	);
+	new Headers(init?.headers).forEach((value, key) => {
+		headers.set(key, value);
+	});
+	if (!headers.get(stickySession.field)?.trim()) {
+		headers.set(stickySession.field, stickySession.value);
+	}
+	return [input, { ...init, headers }];
+}
+
+function wrapFetchForStickySession(
+	baseFetch: typeof fetch | undefined,
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): typeof fetch | undefined {
+	const stickySession = resolveStickySession(request, context);
+	if (!stickySession) {
+		return baseFetch;
+	}
+	const delegate = baseFetch ?? globalThis.fetch;
+	if (!delegate) {
+		return baseFetch;
+	}
+	const sessionFetch = (async (input, init) => {
+		const [nextInput, nextInit] =
+			stickySession.transport === "json-body"
+				? await injectJsonBodyStickySession(input, init, stickySession)
+				: injectHeaderStickySession(input, init, stickySession);
+		return delegate(nextInput, nextInit);
+	}) as typeof fetch;
+	const delegateWithPreconnect = delegate as typeof fetch & {
+		preconnect?: (...args: unknown[]) => unknown;
+	};
+	if (typeof delegateWithPreconnect.preconnect === "function") {
+		(
+			sessionFetch as typeof fetch & {
+				preconnect?: (...args: unknown[]) => unknown;
+			}
+		).preconnect = delegateWithPreconnect.preconnect.bind(delegate);
+	}
+	return sessionFetch;
+}
+
+function shouldIncludeReasoningHistory(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): boolean {
+	return !isCerebrasProvider(request, context);
+}
+
+async function ensureGatewayLangfuseTelemetry(
+	providerId: string,
+): Promise<boolean> {
+	try {
+		const runtime = await import("../services/langfuse-telemetry");
+		return runtime.ensureLangfuseTelemetry(providerId);
+	} catch {
+		return false;
+	}
+}
+
+function toAiSdkMessages(
+	messages: readonly AgentMessage[],
+	systemPrompt?: string,
+	options?: { includeReasoning?: boolean },
+) {
+	const includeReasoning = options?.includeReasoning ?? true;
+	const normalizedMessages: AiSdkFormatterMessage[] = [];
+
+	for (const message of messages) {
+		const content: AiSdkFormatterPart[] = [];
+		let skippedReasoning = false;
+		for (const part of message.content) {
+			if (part.type === "text") {
+				content.push({ type: "text", text: sanitizeSurrogates(part.text) });
+				continue;
+			}
+
+			if (part.type === "reasoning") {
+				if (!includeReasoning) {
+					skippedReasoning = true;
+					continue;
+				}
+				const metadata = part.metadata as Record<string, unknown> | undefined;
+				const signature = metadata?.signature;
+				const redactedData = metadata?.redactedData;
+				content.push({
+					type: "reasoning",
+					text: sanitizeSurrogates(part.text),
+					...(typeof signature === "string" || typeof redactedData === "string"
+						? {
+								providerOptions: {
+									anthropic: {
+										...(typeof signature === "string" ? { signature } : {}),
+										...(typeof redactedData === "string"
+											? { redactedData }
+											: {}),
+									},
+								},
+							}
+						: {}),
+				});
+				continue;
+			}
+
+			if (part.type === "file") {
+				content.push({
+					type: "file",
+					path: part.path,
+					content: part.content,
+				});
+				continue;
+			}
+
+			if (part.type === "image") {
+				content.push({
+					type: "image",
+					image: part.image,
+					mediaType: part.mediaType,
+				});
+				continue;
+			}
+
+			if (part.type === "tool-call") {
+				const metadata = part.metadata as Record<string, unknown> | undefined;
+				const thoughtSignature =
+					metadata?.thoughtSignature ??
+					metadata?.signature ??
+					metadata?.thought_signature;
+				content.push({
+					type: "tool-call",
+					toolCallId: part.toolCallId,
+					toolName: part.toolName,
+					input: part.input,
+					...(typeof thoughtSignature === "string"
+						? {
+								providerOptions: {
+									google: { thoughtSignature },
+								},
+							}
+						: {}),
+				});
+				continue;
+			}
+
+			if (part.type === "tool-result") {
+				content.push({
+					type: "tool-result",
+					toolCallId: part.toolCallId,
+					toolName: part.toolName,
+					output: part.output,
+					isError: part.isError ?? false,
+				});
+			}
+		}
+
+		if (content.length > 0) {
+			normalizedMessages.push({ role: message.role, content });
+		} else if (!includeReasoning && skippedReasoning) {
+			continue;
+		} else if (message.role === "user" || message.role === "assistant") {
+			normalizedMessages.push({ role: message.role, content: "" });
+		}
+	}
+
+	return formatMessagesForAiSdk(systemPrompt, normalizedMessages, {
+		assistantToolCallArgKey: "input",
+	});
+}
+
+function toAiSdkTools(
+	request: GatewayStreamRequest,
+): Record<string, unknown> | undefined {
+	if (!request.tools?.length) {
+		return undefined;
+	}
+
+	// No validate callback on purpose: schema validation belongs to the tools
+	// themselves (core executors validate with lenient union schemas that
+	// accept common weak-model shapes like a bare string for a string[]
+	// property). Rejecting here would return an error to the model without
+	// the tool's own input handling ever seeing the call.
+	return Object.fromEntries(
+		request.tools.map((definition) => [
+			definition.name,
+			{
+				description: definition.description,
+				inputSchema: jsonSchema(
+					normalizeAiSdkToolInputSchema(definition.inputSchema),
+				) as never,
+			} as unknown,
+		]),
+	);
+}
+
+interface RepairableToolCall {
+	toolCallId: string;
+	toolName: string;
+	input: string;
+}
+
+/**
+ * Last-chance repair for tool calls whose arguments are not valid JSON
+ * (truncated payloads, single quotes, unescaped newlines — common with
+ * weaker models). Runs the raw argument text through the shared jsonrepair
+ * strategies; unknown tool names and already-valid JSON are not repairable
+ * here, and returning null preserves the AI SDK's original error behavior.
+ */
+export async function repairMalformedToolCall<T extends RepairableToolCall>({
+	toolCall,
+	error,
+}: {
+	toolCall: T;
+	error: unknown;
+}): Promise<T | null> {
+	if (NoSuchToolError.isInstance(error)) {
+		return null;
+	}
+	if (typeof toolCall.input !== "string" || toolCall.input.trim() === "") {
+		return null;
+	}
+	try {
+		JSON.parse(toolCall.input);
+		// Valid JSON means the failure was a schema mismatch, not a parse
+		// error. That is left to the tool executor's own lenient union
+		// schemas; there is nothing to repair here.
+		return null;
+	} catch {
+		// Not valid JSON — attempt repair below.
+	}
+	const repaired = parseJsonStream(toolCall.input);
+	if (repaired === toolCall.input || typeof repaired === "string") {
+		return null;
+	}
+	return { ...toolCall, input: JSON.stringify(repaired) };
+}
+
+function normalizeAiSdkToolInputSchema(
+	inputSchema: Record<string, unknown>,
+): Record<string, unknown> {
+	if (inputSchema.type === "object") {
+		return inputSchema;
+	}
+
+	return {
+		type: "object",
+		...inputSchema,
+	};
+}
+
+function providerDisablesExternalToolExecution(
+	context: GatewayProviderContext,
+): boolean {
+	return context.provider.capabilities?.includes("provider-tools") ?? false;
+}
+
+function mergeToolCallMetadata(
+	current: unknown,
+	patch: Record<string, unknown>,
+): Record<string, unknown> {
+	if (!current || typeof current !== "object" || Array.isArray(current)) {
+		return patch;
+	}
+	return {
+		...(current as Record<string, unknown>),
+		...patch,
+	};
+}
+
+function buildToolCallMetadata(input: {
+	metadata: unknown;
+	request: GatewayStreamRequest;
+	context: GatewayProviderContext;
+}): Record<string, unknown> {
+	return mergeToolCallMetadata(input.metadata, {
+		toolSource: {
+			providerId: input.request.providerId,
+			modelId: input.request.modelId,
+			executionMode: providerDisablesExternalToolExecution(input.context)
+				? "provider"
+				: "runtime",
+		},
+	});
+}
+
+function buildRecoverableToolErrorMetadata(input: {
+	part: AiSdkStreamPart;
+	errorMessage: string;
+	request: GatewayStreamRequest;
+	context: GatewayProviderContext;
+	toolName: string;
+}): Record<string, unknown> {
+	return buildToolCallMetadata({
+		metadata: mergeToolCallMetadata(extractGoogleThoughtMetadata(input.part), {
+			inputParseError: `Tool call ${input.toolName} was rejected before execution: ${input.errorMessage}`,
+			aiSdkToolError: input.errorMessage,
+		}),
+		request: input.request,
+		context: input.context,
+	});
+}
+
+function resolveAiSdkSystemPrompt(
+	request: GatewayStreamRequest,
+): string | undefined {
+	return request.providerId === "openai-codex"
+		? undefined
+		: request.systemPrompt;
+}
+
+function mapFinishReason(
+	value: unknown,
+	sawToolCalls: boolean,
+): AgentModelFinishReason {
+	if (value === "tool-calls" || value === "tool_calls" || sawToolCalls) {
+		return "tool-calls";
+	}
+	if (value === "length" || value === "max_tokens") {
+		return "max-tokens";
+	}
+	if (value === "error") {
+		return "error";
+	}
+	return "stop";
+}
+
+function getUsageValue(
+	usage: Record<string, unknown>,
+	...keys: string[]
+): number {
+	for (const key of keys) {
+		const value = usage[key];
+		if (typeof value === "number" && Number.isFinite(value)) {
+			return value;
+		}
+		if (
+			typeof value === "string" &&
+			value.trim().length > 0 &&
+			Number.isFinite(Number(value))
+		) {
+			return Number(value);
+		}
+	}
+	return 0;
+}
+
+function getNumericValue(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return value;
+	}
+	if (
+		typeof value === "string" &&
+		value.trim().length > 0 &&
+		Number.isFinite(Number(value))
+	) {
+		return Number(value);
+	}
+	return undefined;
+}
+
+function getNestedUsageValue(
+	usage: Record<string, unknown>,
+	...path: string[]
+): number {
+	let current: unknown = usage;
+	for (const key of path) {
+		if (!current || typeof current !== "object") {
+			return 0;
+		}
+		current = (current as Record<string, unknown>)[key];
+	}
+	return getNumericValue(current) ?? 0;
+}
+
+type UsagePath = readonly [string] | readonly [string, string];
+
+const REASONING_TOKEN_PATHS: UsagePath[] = [
+	["outputTokenDetails", "reasoningTokens"],
+	["output_tokens_details", "reasoning_tokens"],
+	["completion_tokens_details", "reasoning_tokens"],
+	["reasoningTokens"],
+	["reasoning_tokens"],
+];
+
+function getUsageValueByPath(source: unknown, path: UsagePath): number {
+	let current: unknown = source;
+	for (const key of path) {
+		if (!current || typeof current !== "object") {
+			return 0;
+		}
+		current = (current as Record<string, unknown>)[key];
+	}
+	return getNumericValue(current) ?? 0;
+}
+
+function firstUsageValue(sources: unknown[], paths: UsagePath[]): number {
+	for (const source of sources) {
+		for (const path of paths) {
+			const value = getUsageValueByPath(source, path);
+			if (value > 0) {
+				return value;
+			}
+		}
+	}
+	return 0;
+}
+
+function extractProviderNestedUsage(
+	value: unknown,
+): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object") {
+		return undefined;
+	}
+
+	const providerMetadata = value as Record<string, unknown>;
+	for (const nestedValue of Object.values(providerMetadata)) {
+		if (!nestedValue || typeof nestedValue !== "object") {
+			continue;
+		}
+
+		const nestedMetadata = nestedValue as Record<string, unknown>;
+		if (nestedMetadata.usage && typeof nestedMetadata.usage === "object") {
+			return nestedMetadata.usage as Record<string, unknown>;
+		}
+	}
+
+	return undefined;
+}
+
+function calculateUsageCostFromPricing(
+	usage: Omit<GatewayNormalizedUsage, "totalCost">,
+	pricingValue: unknown,
+): number | undefined {
+	if (!pricingValue || typeof pricingValue !== "object") {
+		return undefined;
+	}
+
+	const pricing = pricingValue as Record<string, unknown>;
+	const inputPrice = getNumericValue(pricing.input);
+	const outputPrice = getNumericValue(pricing.output);
+
+	if (inputPrice === undefined || outputPrice === undefined) {
+		return undefined;
+	}
+
+	const cacheReadPrice = getNumericValue(pricing.cacheRead) ?? 0;
+	const cacheWritePrice =
+		getNumericValue(pricing.cacheWrite) ?? inputPrice * 1.25;
+	const billableInputTokens = Math.max(
+		0,
+		usage.inputTokens - usage.cacheReadTokens - usage.cacheWriteTokens,
+	);
+
+	return (
+		(billableInputTokens / 1_000_000) * inputPrice +
+		(usage.outputTokens / 1_000_000) * outputPrice +
+		(usage.cacheReadTokens / 1_000_000) * cacheReadPrice +
+		(usage.cacheWriteTokens / 1_000_000) * cacheWritePrice
+	);
+}
+
+/**
+ * Normalizes usage from various provider formats into a standard structure.
+ * Accepts both AI SDK's normalized shapes (AiSdkStreamTotalUsage, AiSdkStreamUsage)
+ * and raw provider responses. Handles multiple naming conventions (camelCase vs snake_case),
+ * extracts costs from provider-specific fields, and falls back to pricing-based calculation.
+ *
+ * @param usageValue - AI SDK normalized usage or raw provider response object
+ * @param providerMetadata - Provider-specific metadata for cost extraction
+ * @param pricingValue - Fallback pricing config (per 1M tokens) when no explicit cost found
+ */
+export function normalizeUsage(
+	usageValue:
+		| AiSdkStreamUsage
+		| AiSdkStreamTotalUsage
+		| Record<string, unknown>
+		| undefined,
+	providerMetadata?: unknown,
+	pricingValue?: unknown,
+): GatewayNormalizedUsage {
+	const usage =
+		usageValue && typeof usageValue === "object"
+			? (usageValue as Record<string, unknown>)
+			: {};
+	const providerUsage = extractProviderNestedUsage(providerMetadata);
+	const providerMetadataRecord =
+		providerMetadata && typeof providerMetadata === "object"
+			? (providerMetadata as Record<string, unknown>)
+			: {};
+	const gatewayMetadata =
+		providerMetadataRecord.gateway &&
+		typeof providerMetadataRecord.gateway === "object"
+			? (providerMetadataRecord.gateway as Record<string, unknown>)
+			: {};
+	const rawUsage =
+		usage.raw && typeof usage.raw === "object"
+			? (usage.raw as Record<string, unknown>)
+			: usage;
+	const upstreamInferenceCost =
+		getNumericValue(
+			(rawUsage.cost_details as Record<string, unknown> | undefined)
+				?.upstream_inference_cost,
+		) ?? getNumericValue(rawUsage.upstream_inference_cost);
+	const marketCost =
+		getNumericValue(rawUsage.market_cost) ??
+		getNumericValue(rawUsage.marketCost) ??
+		getNumericValue(gatewayMetadata.marketCost);
+	const baseCost =
+		getNumericValue(rawUsage.cost) ?? getNumericValue(gatewayMetadata.cost);
+	const hasExplicitCost =
+		marketCost !== undefined ||
+		baseCost !== undefined ||
+		upstreamInferenceCost !== undefined;
+	const isByokUsage =
+		rawUsage.is_byok === true ||
+		rawUsage.isByok === true ||
+		gatewayMetadata.is_byok === true ||
+		gatewayMetadata.isByok === true;
+	const shouldAddUpstreamCost =
+		isByokUsage &&
+		baseCost !== undefined &&
+		upstreamInferenceCost !== undefined;
+	const costOrUpstream =
+		baseCost !== undefined && baseCost > 0
+			? baseCost
+			: (upstreamInferenceCost ?? baseCost);
+	const totalCost =
+		marketCost ??
+		(shouldAddUpstreamCost ? baseCost + upstreamInferenceCost : costOrUpstream);
+	const normalizedUsage = {
+		inputTokens:
+			getNestedUsageValue(usage, "inputTokens", "total") ||
+			getUsageValue(usage, "inputTokens", "input_tokens", "prompt_tokens") ||
+			getUsageValue(rawUsage, "promptTokenCount", "prompt_token_count"),
+		outputTokens:
+			getNestedUsageValue(usage, "outputTokens", "total") ||
+			getUsageValue(
+				usage,
+				"outputTokens",
+				"output_tokens",
+				"completion_tokens",
+			) ||
+			getUsageValue(rawUsage, "candidatesTokenCount", "candidates_token_count"),
+		cacheReadTokens:
+			getNestedUsageValue(usage, "inputTokens", "cacheRead") ||
+			getNestedUsageValue(usage, "inputTokenDetails", "cacheReadTokens") ||
+			getUsageValue(
+				usage,
+				"cachedInputTokens",
+				"cacheReadTokens",
+				"cache_read_tokens",
+				"cache_read_input_tokens",
+			) ||
+			getNestedUsageValue(usage, "prompt_tokens_details", "cached_tokens") ||
+			getNestedUsageValue(rawUsage, "prompt_tokens_details", "cached_tokens") ||
+			getUsageValue(rawUsage, "cachedContentTokenCount") ||
+			getUsageValue(
+				providerUsage ?? {},
+				"cachedInputTokens",
+				"cacheReadTokens",
+				"cache_read_tokens",
+				"cache_read_input_tokens",
+			),
+		cacheWriteTokens:
+			getNestedUsageValue(usage, "inputTokens", "cacheWrite") ||
+			getNestedUsageValue(usage, "inputTokenDetails", "cacheWriteTokens") ||
+			getNestedUsageValue(
+				usage,
+				"prompt_tokens_details",
+				"cache_write_tokens",
+			) ||
+			getUsageValue(
+				usage,
+				"cacheWriteTokens",
+				"cache_write_tokens",
+				"cache_creation_input_tokens",
+			) ||
+			getNestedUsageValue(
+				rawUsage,
+				"prompt_tokens_details",
+				"cache_write_tokens",
+			) ||
+			getUsageValue(
+				rawUsage,
+				"cacheWriteTokens",
+				"cache_write_tokens",
+				"cache_creation_input_tokens",
+			) ||
+			getUsageValue(
+				providerUsage ?? {},
+				"cacheWriteTokens",
+				"cache_write_tokens",
+				"cache_creation_input_tokens",
+			),
+	};
+	const reasoningTokenCount = firstUsageValue(
+		[usage, rawUsage, providerUsage ?? {}],
+		REASONING_TOKEN_PATHS,
+	);
+	const resolvedTotalCost =
+		totalCost !== undefined
+			? totalCost
+			: hasExplicitCost
+				? undefined
+				: calculateUsageCostFromPricing(normalizedUsage, pricingValue);
+
+	return {
+		...normalizedUsage,
+		...(reasoningTokenCount > 0 ? { reasoningTokenCount } : {}),
+		...(typeof resolvedTotalCost === "number"
+			? { totalCost: resolvedTotalCost }
+			: {}),
+	};
+}
+
+/**
+ * Suppress unhandled rejections from AI SDK stream promises (usage, finishReason, etc.)
+ * that reject with NoOutputGeneratedError when the stream encounters an error.
+ *
+ * The AI SDK's streamText result exposes lazy promise getters (finishReason, totalUsage,
+ * steps, text, usage, etc.) backed by internal DelayedPromise instances. When the stream
+ * errors with 0 recorded steps, the flush callback rejects all of them. We must access
+ * each getter to obtain the promise and attach a no-op rejection handler before Bun/Node
+ * surfaces them as unhandled rejections.
+ */
+function suppressDanglingStreamPromises(
+	stream: AiSdkStreamResult | undefined,
+): void {
+	if (!stream) return;
+	const noop = () => {};
+	const suppress = (val: unknown) => {
+		if (val && typeof (val as Promise<unknown>).catch === "function") {
+			(val as Promise<unknown>).catch(noop);
+		}
+	};
+
+	// Access known lazy promise getters on the AI SDK StreamTextResult object.
+	const s = stream as Record<string, unknown>;
+
+	// Catch-all for any remaining promise-valued own properties.
+	for (const key of Object.keys(stream)) {
+		try {
+			suppress(s[key]);
+		} catch {
+			// ignore
+		}
+	}
+}
+
+function extractGoogleThoughtMetadata(
+	part: AiSdkStreamPart,
+): Record<string, unknown> | undefined {
+	const metadata: Record<string, unknown> = {};
+
+	if (typeof part.thoughtSignature === "string") {
+		metadata.thoughtSignature = part.thoughtSignature;
+	}
+	if (typeof part.thought_signature === "string") {
+		metadata.thought_signature = part.thought_signature;
+	}
+
+	const providerMetadata =
+		part.providerMetadata && typeof part.providerMetadata === "object"
+			? (part.providerMetadata as Record<string, unknown>)
+			: undefined;
+	const googleMetadata =
+		providerMetadata?.google && typeof providerMetadata.google === "object"
+			? (providerMetadata.google as Record<string, unknown>)
+			: undefined;
+	const vertexMetadata =
+		providerMetadata?.vertex && typeof providerMetadata.vertex === "object"
+			? (providerMetadata.vertex as Record<string, unknown>)
+			: undefined;
+
+	if (
+		typeof metadata.thoughtSignature !== "string" &&
+		typeof (
+			googleMetadata?.thoughtSignature ?? vertexMetadata?.thoughtSignature
+		) === "string"
+	) {
+		metadata.thoughtSignature =
+			googleMetadata?.thoughtSignature ?? vertexMetadata?.thoughtSignature;
+	}
+	if (
+		typeof metadata.thought_signature !== "string" &&
+		typeof googleMetadata?.thought_signature === "string"
+	) {
+		metadata.thought_signature = googleMetadata.thought_signature;
+	}
+
+	return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+async function* emitAiSdkEvents(
+	stream: AiSdkStreamResult,
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+	pricingValue?: unknown,
+	capturedError?: { current: string | undefined },
+): AsyncIterable<AgentModelEvent> {
+	let sawToolCalls = false;
+	const emittedToolCallIds = new Set<string>();
+	let finishReason: unknown;
+	let streamError: string | undefined;
+	let finishUsage: unknown;
+	let finishProviderMetadata: unknown;
+
+	try {
+		if (stream.fullStream) {
+			for await (const part of stream.fullStream) {
+				if (part.type === "text-delta") {
+					const text =
+						(part.textDelta as string | undefined) ??
+						(part.text as string | undefined) ??
+						(part.delta as string | undefined);
+					if (text) {
+						yield { type: "text-delta", text };
+					}
+					continue;
+				}
+
+				if (part.type === "reasoning-delta" || part.type === "reasoning") {
+					const text =
+						(part.textDelta as string | undefined) ??
+						(part.text as string | undefined) ??
+						(part.reasoning as string | undefined);
+					if (text) {
+						yield {
+							type: "reasoning-delta",
+							text,
+							metadata: extractGoogleThoughtMetadata(part),
+						};
+					}
+					continue;
+				}
+
+				if (part.type === "tool-call") {
+					sawToolCalls = true;
+					const toolCallId =
+						(part.toolCallId as string | undefined) ??
+						(part.id as string | undefined) ??
+						`tool_${nanoid()}`;
+					emittedToolCallIds.add(toolCallId);
+					const input = (part.input ?? part.args ?? {}) as unknown;
+					const inputText =
+						typeof input === "string" ? input : JSON.stringify(input);
+					yield {
+						type: "tool-call-delta",
+						toolCallId,
+						toolName:
+							(part.toolName as string | undefined) ??
+							(part.name as string | undefined) ??
+							"tool",
+						input: typeof input === "string" ? undefined : input,
+						inputText,
+						metadata: buildToolCallMetadata({
+							metadata: extractGoogleThoughtMetadata(part),
+							request,
+							context,
+						}),
+					};
+					continue;
+				}
+
+				if (part.type === "tool-error") {
+					sawToolCalls = true;
+					const toolCallId =
+						(part.toolCallId as string | undefined) ??
+						(part.id as string | undefined) ??
+						`tool_${nanoid()}`;
+					const alreadyEmitted = emittedToolCallIds.has(toolCallId);
+					emittedToolCallIds.add(toolCallId);
+					const toolName =
+						(part.toolName as string | undefined) ??
+						(part.name as string | undefined) ??
+						"tool";
+					const input = (part.input ?? part.args ?? {}) as unknown;
+					const inputText =
+						typeof input === "string" ? input : JSON.stringify(input);
+					const errorMessage =
+						part.error === undefined
+							? "Tool input was rejected by the model adapter"
+							: extractErrorMessage(part.error);
+					yield {
+						type: "tool-call-delta",
+						toolCallId,
+						toolName,
+						input: alreadyEmitted
+							? undefined
+							: typeof input === "string"
+								? undefined
+								: input,
+						inputText: alreadyEmitted ? undefined : inputText,
+						metadata: buildRecoverableToolErrorMetadata({
+							part,
+							errorMessage,
+							request,
+							context,
+							toolName,
+						}),
+					};
+					continue;
+				}
+
+				if (part.type === "finish") {
+					finishUsage = part.usage ?? part.totalUsage;
+					finishProviderMetadata = part.providerMetadata;
+					finishReason =
+						part.finishReason ?? part.rawFinishReason ?? part.reason;
+				}
+
+				if (part.type === "error") {
+					streamError =
+						capturedError?.current ?? extractErrorMessage(part.error);
+					break;
+				}
+
+				if (part.type === "abort") {
+					// abort
+					break;
+				}
+			}
+		} else if (stream.textStream) {
+			for await (const text of stream.textStream) {
+				yield { type: "text-delta", text };
+			}
+		}
+	} catch (error) {
+		// Prefer the real provider error from onError over the generic
+		// NoOutputGeneratedError the AI SDK throws when 0 steps are recorded.
+		streamError = capturedError?.current ?? extractErrorMessage(error);
+	}
+
+	// Prefer stream.usage (has raw cost data) over finish part usage.
+	// stream.usage may be undefined in mocked/test scenarios, fall back to finish part + its providerMetadata.
+	let usageToEmit: unknown;
+	let metadataToUse: unknown;
+	if (streamError) {
+		usageToEmit = finishUsage;
+		metadataToUse = finishProviderMetadata;
+	} else if (stream.usage) {
+		try {
+			usageToEmit = await stream.usage;
+		} catch (error) {
+			if (!streamError) {
+				streamError = capturedError?.current ?? extractErrorMessage(error);
+			}
+			usageToEmit = finishUsage;
+			metadataToUse = finishProviderMetadata;
+		}
+	} else {
+		usageToEmit = finishUsage;
+		metadataToUse = finishProviderMetadata;
+	}
+
+	if (usageToEmit) {
+		yield {
+			type: "usage",
+			usage: normalizeUsage(usageToEmit, metadataToUse, pricingValue),
+		};
+	}
+
+	yield {
+		type: "finish",
+		reason: streamError ? "error" : mapFinishReason(finishReason, sawToolCalls),
+		error: streamError,
+	};
+}
+
+async function createProviderModule(
+	kind: ProviderModuleKind,
+	config: GatewayResolvedProviderConfig,
+	context: GatewayProviderContext,
+): Promise<ProviderFactoryResult> {
+	switch (kind) {
+		case "openai": {
+			const { createOpenAIProviderModule } = await import("./vendors/openai");
+			return createOpenAIProviderModule(config, context);
+		}
+		case "openai-compatible": {
+			const { createOpenAICompatibleProviderModule } = await import(
+				"./vendors/openai-compatible"
+			);
+			return createOpenAICompatibleProviderModule(config, context);
+		}
+		case "anthropic": {
+			const { createAnthropicProviderModule } = await import(
+				"./vendors/anthropic"
+			);
+			return createAnthropicProviderModule(config, context);
+		}
+		case "google": {
+			const { createGoogleProviderModule } = await import("./vendors/google");
+			return createGoogleProviderModule(config, context);
+		}
+		case "vertex": {
+			const { createVertexProviderModule } = await import("./vendors/vertex");
+			return createVertexProviderModule(config, context);
+		}
+		case "bedrock": {
+			const { createBedrockProviderModule } = await import("./vendors/bedrock");
+			return createBedrockProviderModule(config);
+		}
+		case "mistral": {
+			const { createMistralProviderModule } = await import("./vendors/mistral");
+			return createMistralProviderModule(config);
+		}
+		case "claude-code": {
+			const { createClaudeCodeProviderModule } = await import(
+				"./vendors/community"
+			);
+			return createClaudeCodeProviderModule(config);
+		}
+		case "openai-codex": {
+			const { createOpenAICodexProviderModule } = await import(
+				"./vendors/community"
+			);
+			return createOpenAICodexProviderModule(config);
+		}
+		case "opencode": {
+			const { createOpenCodeProviderModule } = await import(
+				"./vendors/community"
+			);
+			return createOpenCodeProviderModule(config);
+		}
+		case "dify": {
+			const { createDifyProviderModule } = await import("./vendors/community");
+			return createDifyProviderModule(config);
+		}
+		case "sapaicore": {
+			const { createSapAiCoreProviderModule } = await import(
+				"./vendors/community"
+			);
+			return createSapAiCoreProviderModule(config);
+		}
+	}
+}
+
+function createAiSdkProvider(kind: ProviderModuleKind): GatewayProviderFactory {
+	return async (config) => ({
+		async *stream(request, context) {
+			const log = context.logger;
+			let stream: AiSdkStreamResult | undefined;
+			const capturedError: { current: string | undefined } = {
+				current: undefined,
+			};
+			try {
+				const provider = await createProviderModule(
+					kind,
+					{
+						...config,
+						fetch: wrapFetchForStickySession(
+							wrapFetchForProviderRequestCapture(config.fetch, request),
+							request,
+							context,
+						),
+					},
+					context,
+				);
+				const langfuse = await ensureGatewayLangfuseTelemetry(
+					config.providerId,
+				);
+				const tools = providerDisablesExternalToolExecution(context)
+					? undefined
+					: toAiSdkTools(request);
+				const systemPrompt = resolveAiSdkSystemPrompt(request);
+				const useSystemOption =
+					typeof systemPrompt === "string" && systemPrompt.trim().length > 0;
+				const messagesSystemPrompt = useSystemOption ? undefined : systemPrompt;
+				const messages = shouldApplyPromptCache(request, context)
+					? buildCachedAiSdkMessages(request, context, messagesSystemPrompt)
+					: toAiSdkMessages(request.messages, messagesSystemPrompt, {
+							includeReasoning: shouldIncludeReasoningHistory(request, context),
+						});
+				const providerOptions = composeAiSdkProviderOptions(
+					request,
+					context,
+					kind,
+				) as never;
+				recordProviderRequestCapture({
+					stage: "ai_sdk_prompt",
+					request,
+					payload: {
+						messages,
+						...(useSystemOption ? { system: systemPrompt } : {}),
+						tools,
+						providerOptions,
+						maxOutputTokens: request.maxTokens,
+						temperature: request.temperature,
+					},
+				});
+				stream = streamText({
+					model: provider.model(context.model.id) as never,
+					messages: messages as never,
+					...(useSystemOption ? { system: systemPrompt } : {}),
+					tools: tools as never,
+					temperature: request.temperature,
+					...(request.maxTokens !== undefined
+						? { maxOutputTokens: request.maxTokens }
+						: {}),
+					abortSignal: request.signal,
+					experimental_repairToolCall: repairMalformedToolCall as never,
+					experimental_telemetry: {
+						isEnabled: langfuse,
+					},
+					providerOptions,
+					onError: ({ error: streamError }) => {
+						const msg = extractErrorMessage(streamError);
+						capturedError.current = msg;
+						if (log?.error) {
+							log.error("[ai-sdk] stream error", {
+								providerId: request.providerId,
+								error: streamError,
+								severity: "error",
+							});
+						} else if (log) {
+							log.log(`[ai-sdk] stream error: ${msg}`, {
+								providerId: request.providerId,
+								severity: "error",
+							});
+						}
+						captureSdkError(context.telemetry, {
+							component: "llms",
+							operation: "provider.stream",
+							error: streamError,
+							severity: "error",
+							handled: true,
+							context: {
+								providerId: request.providerId,
+								modelId: request.modelId,
+								providerKind: kind,
+							},
+						});
+					},
+				}) as unknown as AiSdkStreamResult;
+
+				// Suppress dangling promise rejections (finishReason, totalUsage, steps, etc.)
+				// BEFORE iterating. The AI SDK rejects these DelayedPromises inside the stream's
+				// flush callback, which runs during iteration, so we must attach .catch() handlers
+				// upfront or Bun/Node will surface them as unhandled rejections.
+				suppressDanglingStreamPromises(stream);
+
+				yield* emitAiSdkEvents(
+					stream,
+					request,
+					context,
+					context.model.metadata?.pricing,
+					capturedError,
+				);
+			} catch (error) {
+				suppressDanglingStreamPromises(stream);
+				// Prefer the real provider error captured in onError over the generic
+				// NoOutputGeneratedError that the AI SDK throws when 0 steps are recorded.
+				const msg = capturedError.current ?? extractErrorMessage(error);
+				if (log?.error) {
+					log.error("[ai-sdk] provider error", {
+						providerId: request.providerId,
+						error,
+						severity: "error",
+					});
+				} else if (log) {
+					log.log(`[ai-sdk] provider error: ${msg}`, {
+						providerId: request.providerId,
+						severity: "error",
+					});
+				}
+				captureSdkError(context.telemetry, {
+					component: "llms",
+					operation: "provider.create_or_stream",
+					error,
+					severity: "error",
+					handled: true,
+					context: {
+						providerId: request.providerId,
+						modelId: request.modelId,
+						providerKind: kind,
+					},
+				});
+				yield {
+					type: "finish",
+					reason: "error",
+					error: msg,
+				};
+			}
+		},
+	});
+}
+
+export const createOpenAIProvider = createAiSdkProvider("openai");
+export const createOpenAICompatibleProvider =
+	createAiSdkProvider("openai-compatible");
+export const createAnthropicProvider = createAiSdkProvider("anthropic");
+export const createGoogleProvider = createAiSdkProvider("google");
+export const createVertexProvider = createAiSdkProvider("vertex");
+export const createBedrockProvider = createAiSdkProvider("bedrock");
+export const createMistralProvider = createAiSdkProvider("mistral");
+export const createClaudeCodeProvider = createAiSdkProvider("claude-code");
+export const createOpenAICodexProvider = createAiSdkProvider("openai-codex");
+export const createOpenCodeProvider = createAiSdkProvider("opencode");
+export const createDifyProvider = createAiSdkProvider("dify");
+export const createSapAiCoreProvider = createAiSdkProvider("sapaicore");
diff --git a/sdk/packages/llms/src/providers/async.ts b/sdk/packages/llms/src/providers/async.ts
new file mode 100644
index 0000000..5ca5c36
--- /dev/null
+++ b/sdk/packages/llms/src/providers/async.ts
@@ -0,0 +1,7 @@
+export async function* toAsyncIterable<T>(
+	value: AsyncIterable<T> | Iterable<T>,
+): AsyncIterable<T> {
+	for await (const item of value) {
+		yield item;
+	}
+}
diff --git a/sdk/packages/llms/src/providers/billing.test.ts b/sdk/packages/llms/src/providers/billing.test.ts
new file mode 100644
index 0000000..42dd1f7
--- /dev/null
+++ b/sdk/packages/llms/src/providers/billing.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import {
+	resolveProviderUsageCostDisplay,
+	shouldShowProviderUsageCost,
+} from "./billing";
+import { getProviderCollectionSync } from "./model-registry";
+
+describe("provider usage cost display", () => {
+	it("hides usage cost for subscription-backed Codex providers", () => {
+		expect(resolveProviderUsageCostDisplay("openai-codex")).toBe(
+			"subscription",
+		);
+		expect(resolveProviderUsageCostDisplay("openai-codex-cli")).toBe(
+			"subscription",
+		);
+		expect(shouldShowProviderUsageCost("openai-codex")).toBe(false);
+		expect(shouldShowProviderUsageCost("openai-codex-cli")).toBe(false);
+	});
+
+	it("shows usage cost by default for usage-billed providers", () => {
+		expect(resolveProviderUsageCostDisplay("openai-native")).toBe("show");
+		expect(resolveProviderUsageCostDisplay("anthropic")).toBe("show");
+		expect(resolveProviderUsageCostDisplay("cline")).toBe("show");
+		expect(shouldShowProviderUsageCost("anthropic")).toBe(true);
+	});
+
+	it("stores the display policy on provider metadata", () => {
+		expect(
+			getProviderCollectionSync("openai-codex")?.provider.metadata,
+		).toMatchObject({ usageCostDisplay: "subscription" });
+	});
+});
diff --git a/sdk/packages/llms/src/providers/billing.ts b/sdk/packages/llms/src/providers/billing.ts
new file mode 100644
index 0000000..7e058e8
--- /dev/null
+++ b/sdk/packages/llms/src/providers/billing.ts
@@ -0,0 +1,40 @@
+import {
+	type GatewayUsageCostDisplay,
+	USAGE_COST_DISPLAYS,
+} from "@cline/shared";
+import { normalizeProviderId } from "./ids";
+import { getProviderCollectionSync } from "./model-registry";
+
+export type ProviderUsageCostDisplay = GatewayUsageCostDisplay;
+
+const isValidMetadataUsage = (
+	usageCostDisplay: unknown,
+): usageCostDisplay is ProviderUsageCostDisplay => {
+	return (
+		!!usageCostDisplay &&
+		typeof usageCostDisplay === "string" &&
+		USAGE_COST_DISPLAYS.includes(usageCostDisplay as ProviderUsageCostDisplay)
+	);
+};
+
+function resolveMetadataUsageCostDisplay(
+	metadata: Record<string, unknown> | undefined,
+): ProviderUsageCostDisplay {
+	if (isValidMetadataUsage(metadata?.usageCostDisplay)) {
+		return metadata.usageCostDisplay;
+	}
+	return "show";
+}
+
+export function resolveProviderUsageCostDisplay(
+	providerId: string,
+): ProviderUsageCostDisplay {
+	const provider = getProviderCollectionSync(
+		normalizeProviderId(providerId.trim()),
+	)?.provider;
+	return resolveMetadataUsageCostDisplay(provider?.metadata);
+}
+
+export function shouldShowProviderUsageCost(providerId: string): boolean {
+	return resolveProviderUsageCostDisplay(providerId) === "show";
+}
diff --git a/sdk/packages/llms/src/providers/builtins-runtime.ts b/sdk/packages/llms/src/providers/builtins-runtime.ts
new file mode 100644
index 0000000..881918f
--- /dev/null
+++ b/sdk/packages/llms/src/providers/builtins-runtime.ts
@@ -0,0 +1,101 @@
+import type {
+	GatewayProviderFactory,
+	GatewayProviderRegistration,
+} from "@cline/shared";
+import { BUILTIN_SPECS, type ProviderFamily, toManifest } from "./builtins";
+
+const FAMILY_FACTORY_PROMISES = new Map<
+	ProviderFamily,
+	Promise<GatewayProviderFactory>
+>();
+
+async function loadFamilyFactory(
+	family: ProviderFamily,
+): Promise<GatewayProviderFactory> {
+	const cached = FAMILY_FACTORY_PROMISES.get(family);
+	if (cached) {
+		return cached;
+	}
+
+	const promise = (async () => {
+		switch (family) {
+			case "openai": {
+				const module = await import("./ai-sdk");
+				return module.createOpenAIProvider;
+			}
+			case "openai-compatible": {
+				const module = await import("./ai-sdk");
+				return module.createOpenAICompatibleProvider;
+			}
+			case "anthropic": {
+				const module = await import("./ai-sdk");
+				return module.createAnthropicProvider;
+			}
+			case "google": {
+				const module = await import("./ai-sdk");
+				return module.createGoogleProvider;
+			}
+			case "vertex": {
+				const module = await import("./ai-sdk");
+				return module.createVertexProvider;
+			}
+			case "bedrock": {
+				const module = await import("./ai-sdk");
+				return module.createBedrockProvider;
+			}
+			case "mistral": {
+				const module = await import("./ai-sdk");
+				return module.createMistralProvider;
+			}
+			case "claude-code": {
+				const module = await import("./ai-sdk");
+				return module.createClaudeCodeProvider;
+			}
+			case "openai-codex": {
+				const module = await import("./ai-sdk");
+				return module.createOpenAICodexProvider;
+			}
+			case "opencode": {
+				const module = await import("./ai-sdk");
+				return module.createOpenCodeProvider;
+			}
+			case "dify": {
+				const module = await import("./ai-sdk");
+				return module.createDifyProvider;
+			}
+			case "sap-ai-core": {
+				const module = await import("./ai-sdk");
+				return module.createSapAiCoreProvider;
+			}
+		}
+	})();
+
+	FAMILY_FACTORY_PROMISES.set(family, promise);
+	return promise;
+}
+
+function resolveRuntimeFamily(
+	spec: (typeof BUILTIN_SPECS)[number],
+): ProviderFamily {
+	if (
+		spec.family === "openai" ||
+		spec.protocol === "openai-responses" ||
+		spec.client === "openai"
+	) {
+		return "openai";
+	}
+	return spec.family;
+}
+
+export const BUILTIN_PROVIDER_REGISTRATIONS: GatewayProviderRegistration[] =
+	BUILTIN_SPECS.map((spec) => ({
+		manifest: toManifest(spec),
+		defaults: {
+			...spec.defaults,
+			apiKeyEnv: spec.apiKeyEnv,
+			baseUrl: spec.defaults?.baseUrl,
+		},
+		loadProvider: async () => ({
+			createProvider: await loadFamilyFactory(resolveRuntimeFamily(spec)),
+		}),
+	}));
diff --git a/sdk/packages/llms/src/providers/builtins.test.ts b/sdk/packages/llms/src/providers/builtins.test.ts
new file mode 100644
index 0000000..e7f63a3
--- /dev/null
+++ b/sdk/packages/llms/src/providers/builtins.test.ts
@@ -0,0 +1,188 @@
+import { CLINE_ENVIRONMENT_ENV, CLINE_ENVIRONMENTS } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { BUILTIN_SPECS } from "./builtins";
+import { getModelsForProvider, getProvider } from "./model-registry";
+
+function findClineSpec() {
+	const spec = BUILTIN_SPECS.find((s) => s.id === "cline");
+	if (!spec) {
+		throw new Error("cline builtin spec not found");
+	}
+	return spec;
+}
+
+describe("cline builtin spec defaults.baseUrl", () => {
+	const originalEnvironment = process.env[CLINE_ENVIRONMENT_ENV];
+
+	beforeEach(() => {
+		delete process.env[CLINE_ENVIRONMENT_ENV];
+	});
+
+	afterEach(() => {
+		if (originalEnvironment === undefined) {
+			delete process.env[CLINE_ENVIRONMENT_ENV];
+		} else {
+			process.env[CLINE_ENVIRONMENT_ENV] = originalEnvironment;
+		}
+	});
+
+	it("re-resolves baseUrl when CLINE_ENVIRONMENT changes between reads", () => {
+		const spec = findClineSpec();
+
+		expect(spec.defaults?.baseUrl).toBe(
+			`${CLINE_ENVIRONMENTS.production.apiBaseUrl}/api/v1`,
+		);
+
+		process.env[CLINE_ENVIRONMENT_ENV] = "staging";
+		expect(spec.defaults?.baseUrl).toBe(
+			`${CLINE_ENVIRONMENTS.staging.apiBaseUrl}/api/v1`,
+		);
+
+		process.env[CLINE_ENVIRONMENT_ENV] = "local";
+		expect(spec.defaults?.baseUrl).toBe(
+			`${CLINE_ENVIRONMENTS.local.apiBaseUrl}/api/v1`,
+		);
+
+		delete process.env[CLINE_ENVIRONMENT_ENV];
+		expect(spec.defaults?.baseUrl).toBe(
+			`${CLINE_ENVIRONMENTS.production.apiBaseUrl}/api/v1`,
+		);
+	});
+});
+
+describe("cline builtin models", () => {
+	it("prefers Vercel-style Z.ai model ids over equivalent OpenRouter ids", async () => {
+		const models = await getModelsForProvider("cline");
+
+		expect(models["zai/glm-5.2"]).toMatchObject({
+			id: "zai/glm-5.2",
+			name: "GLM 5.2",
+			contextWindow: 1_040_000,
+			maxInputTokens: 1_040_000,
+		});
+		expect(models["zai/glm-5.1"]).toMatchObject({
+			id: "zai/glm-5.1",
+		});
+		expect(models["z-ai/glm-5.2"]).toBeUndefined();
+	});
+});
+
+describe("cline-pass builtin spec", () => {
+	it("registers a distinct Cline-compatible provider with a custom model list", async () => {
+		const models = await getModelsForProvider("cline-pass");
+		const provider = await getProvider("cline-pass");
+
+		expect(provider).toMatchObject({
+			id: "cline-pass",
+			name: "ClinePass",
+			baseUrl: `${CLINE_ENVIRONMENTS.production.apiBaseUrl}/api/v1`,
+			client: "openai-compatible",
+			capabilities: expect.arrayContaining([
+				"oauth",
+				"tools",
+				"reasoning",
+				"prompt-cache",
+			]),
+		});
+		expect(models).toHaveProperty(provider?.defaultModelId ?? "");
+		expect(Object.keys(models).length).toBeGreaterThan(0);
+		for (const model of Object.values(models)) {
+			expect(model.contextWindow).toBeGreaterThan(0);
+			expect(model.maxInputTokens).toBeGreaterThan(0);
+			expect(model.maxTokens).toBeGreaterThan(0);
+			expect(model.capabilities).toEqual(expect.arrayContaining(["tools"]));
+			expect(model.pricing).toBeDefined();
+		}
+	});
+});
+
+describe("built-in provider metadata", () => {
+	it("marks popular providers with a provider capability and rank", async () => {
+		await expect(getProvider("cline")).resolves.toMatchObject({
+			name: "Cline Usage-Billing",
+			capabilities: expect.arrayContaining(["popular"]),
+			metadata: { popularRank: 1 },
+		});
+		await expect(getProvider("zai")).resolves.not.toMatchObject({
+			capabilities: expect.arrayContaining(["popular"]),
+		});
+	});
+
+	it("uses the current Hugging Face router endpoint", async () => {
+		await expect(getProvider("huggingface")).resolves.toMatchObject({
+			baseUrl: "https://router.huggingface.co/v1",
+		});
+	});
+
+	it("derives ChatGPT subscription models from the generated OpenAI catalog", async () => {
+		const chatGptModels = await getModelsForProvider("openai-codex");
+		const openAiModels = await getModelsForProvider("openai-native");
+		const modelIds = Object.keys(chatGptModels);
+
+		expect(modelIds).toEqual(
+			expect.arrayContaining(["gpt-5.5", "gpt-5.4", "gpt-5.4-mini"]),
+		);
+		expect(modelIds).not.toContain("gpt-5.5-pro");
+		expect(modelIds).not.toContain("gpt-5.1-codex-max");
+		expect(modelIds).not.toContain("gpt-5.2");
+		expect(modelIds).not.toContain("gpt-5.2-codex");
+		expect(modelIds).not.toContain("gpt-5.3-codex");
+		expect(modelIds).not.toContain("gpt-5.3-codex-spark");
+		expect(modelIds).not.toContain("gpt-5.4-nano");
+		expect(modelIds).not.toContain("o3");
+		expect(chatGptModels["gpt-5.5"]).toEqual(
+			expect.objectContaining({
+				...openAiModels["gpt-5.5"],
+				// ChatGPT/Codex backend caps: 272K input at the 95% effective budget
+				maxInputTokens: 272_000 * 0.95,
+				contextWindow: 400_000,
+				maxTokens: 128_000,
+			}),
+		);
+		expect(chatGptModels["gpt-5.4"]).toEqual(
+			expect.objectContaining({
+				name: "GPT-5.4",
+				maxInputTokens: expect.any(Number),
+				contextWindow: expect.any(Number),
+			}),
+		);
+	});
+
+	it("routes native Z.AI providers through GLM thinking metadata", async () => {
+		for (const providerId of ["zai", "zai-coding-plan"] as const) {
+			await expect(getProvider(providerId)).resolves.toMatchObject({
+				metadata: {
+					routing: {
+						reasoning: {
+							format: "glm-thinking",
+						},
+					},
+				},
+			});
+
+			const models = Object.values(await getModelsForProvider(providerId));
+			expect(models.length).toBeGreaterThan(0);
+			for (const model of models) {
+				expect(model.family?.startsWith("glm")).toBe(true);
+			}
+		}
+	});
+
+	it("routes direct MiniMax M3 through MiniMax thinking metadata", async () => {
+		await expect(getProvider("minimax")).resolves.toMatchObject({
+			metadata: {
+				routing: {
+					reasoning: {
+						format: "minimax-thinking",
+						routes: [
+							expect.objectContaining({
+								matcher: "model-id",
+								modelId: "MiniMax-M3",
+							}),
+						],
+					},
+				},
+			},
+		});
+	});
+});
diff --git a/sdk/packages/llms/src/providers/builtins.ts b/sdk/packages/llms/src/providers/builtins.ts
new file mode 100644
index 0000000..afaf162
--- /dev/null
+++ b/sdk/packages/llms/src/providers/builtins.ts
@@ -0,0 +1,1230 @@
+import {
+	type GatewayModelCapability,
+	type GatewayModelDefinition,
+	type GatewayProviderManifest,
+	type GatewayProviderMetadata,
+	type GatewayProviderSettings,
+	getClineEnvironmentConfig,
+	type JsonValue,
+	type ProviderCapability,
+	type ProviderConfigField,
+} from "@cline/shared";
+import { getGeneratedModelsForProvider } from "../catalog/catalog.generated-access";
+import {
+	isCanonicalModelIdForAliasRules,
+	preferCanonicalModelIds,
+	VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+} from "../catalog/model-id-aliases";
+import type {
+	ModelCollection,
+	ModelInfo,
+	ProviderClient,
+	ProviderProtocol,
+} from "../catalog/types";
+import {
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	extractClinePassLimitMessage,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+} from "./errors";
+import { filterOpenAICodexModels } from "./openai-codex-models";
+import {
+	ANTHROPIC_AND_QWEN_CACHE_ROUTING_METADATA,
+	ANTHROPIC_ROUTING_METADATA,
+	QWEN_CACHE_ROUTING_METADATA,
+} from "./routing/anthropic-compatible";
+import { GLM_THINKING_ROUTING_METADATA } from "./routing/glm-thinking";
+import { MINIMAX_THINKING_ROUTING_METADATA } from "./routing/minimax-thinking";
+
+export const DEFAULT_INTERNAL_OCA_BASE_URL =
+	"https://code-internal.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+export const DEFAULT_EXTERNAL_OCA_BASE_URL =
+	"https://code.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+const CLINE_DEFAULT_MODEL_ID = "anthropic/claude-sonnet-4.6";
+const CLINE_PASS_PROVIDER_ID = "cline-pass";
+const OPENAI_CODEX_DEFAULT_MODEL_ID = "gpt-5.4";
+const OPENROUTER_STICKY_SESSION_METADATA: GatewayProviderMetadata = {
+	stickySession: {
+		transport: "json-body",
+		field: "session_id",
+		metadataKey: "sessionId",
+	},
+};
+
+export type ProviderFamily =
+	| "openai"
+	| "openai-compatible"
+	| "anthropic"
+	| "google"
+	| "vertex"
+	| "bedrock"
+	| "mistral"
+	| "claude-code"
+	| "openai-codex"
+	| "opencode"
+	| "dify"
+	| "sap-ai-core";
+
+export interface BuiltinSpec {
+	id: string;
+	name: string;
+	description: string;
+	family: ProviderFamily;
+	protocol?: ProviderProtocol;
+	client?: ProviderClient;
+	capabilities?: ProviderCapability[];
+	popular?: number;
+	modelsProviderId?: string;
+	defaultModelId?: string;
+	modelsFactory?: () => Record<string, ModelInfo>;
+	env?: readonly ("browser" | "node")[];
+	apiKeyEnv?: readonly string[];
+	modelsSourceUrl?: string;
+	docsUrl?: string;
+	defaults?: GatewayProviderSettings;
+	configFields?: readonly ProviderConfigField[];
+	metadata?: GatewayProviderMetadata;
+}
+
+const API_KEY_FIELD: ProviderConfigField = {
+	path: "apiKey",
+	label: "API Key",
+	type: "password",
+	placeholder: "Enter API key...",
+	description: "API key issued by the provider.",
+	secret: true,
+};
+
+const BASE_URL_FIELD: ProviderConfigField = {
+	path: "baseUrl",
+	label: "Base URL",
+	type: "url",
+	placeholder: "https://...",
+	description: "Base endpoint used for provider requests.",
+};
+
+const VERTEX_CONFIG_FIELDS: readonly ProviderConfigField[] = [
+	{
+		path: "gcp.projectId",
+		label: "Google Cloud Project ID",
+		type: "text",
+		placeholder: "my-gcp-project",
+		description: "Google Cloud project that owns the Vertex AI resources.",
+		required: true,
+	},
+	{
+		path: "gcp.region",
+		label: "Vertex Region",
+		type: "text",
+		placeholder: "us-central1",
+		description: "Vertex AI location to run models in.",
+		defaultValue: "us-central1",
+	},
+	{
+		...API_KEY_FIELD,
+		label: "API Key",
+		description:
+			"Optional Google API key for Gemini models. Vertex Anthropic models use Google Cloud credentials.",
+	},
+];
+
+const BEDROCK_CONFIG_FIELDS: readonly ProviderConfigField[] = [
+	{
+		path: "aws.authentication",
+		label: "Authentication",
+		type: "select",
+		description: "Credential source for Amazon Bedrock requests.",
+		options: [
+			{ label: "AWS SDK / IAM", value: "iam" },
+			{ label: "AWS Profile", value: "profile" },
+			{ label: "API Key", value: "api-key" },
+		],
+		defaultValue: "iam",
+	},
+	{
+		path: "aws.region",
+		label: "AWS Region",
+		type: "text",
+		placeholder: "us-east-1",
+		description: "AWS region for Bedrock runtime requests.",
+	},
+	{
+		path: "aws.profile",
+		label: "AWS Profile",
+		type: "text",
+		placeholder: "default",
+		description: "Named AWS profile when using profile authentication.",
+	},
+	{
+		path: "aws.accessKey",
+		label: "Access Key ID",
+		type: "password",
+		placeholder: "AKIA...",
+		secret: true,
+	},
+	{
+		path: "aws.secretKey",
+		label: "Secret Access Key",
+		type: "password",
+		secret: true,
+	},
+	{
+		path: "aws.sessionToken",
+		label: "Session Token",
+		type: "password",
+		secret: true,
+	},
+	{
+		path: "apiKey",
+		label: "Bedrock API Key",
+		type: "password",
+		description: "Optional Bedrock bearer token for API key authentication.",
+		secret: true,
+	},
+	{
+		path: "aws.endpoint",
+		label: "Endpoint URL",
+		type: "url",
+		placeholder: "https://bedrock-runtime.us-east-1.amazonaws.com",
+		description: "Optional custom Bedrock runtime endpoint.",
+	},
+	{
+		path: "aws.useCrossRegionInference",
+		label: "Cross-Region Inference",
+		type: "boolean",
+	},
+	{
+		path: "aws.useGlobalInference",
+		label: "Global Inference",
+		type: "boolean",
+	},
+	{
+		path: "aws.usePromptCache",
+		label: "Prompt Cache",
+		type: "boolean",
+	},
+];
+
+const OCA_CONFIG_FIELDS: readonly ProviderConfigField[] = [
+	{
+		path: "oca.mode",
+		label: "OCA Mode",
+		type: "select",
+		options: [
+			{ label: "External", value: "external" },
+			{ label: "Internal", value: "internal" },
+		],
+		defaultValue: "external",
+	},
+	API_KEY_FIELD,
+	{
+		path: "oca.usePromptCache",
+		label: "Prompt Cache",
+		type: "boolean",
+	},
+];
+
+const QWEN_CONFIG_FIELDS: readonly ProviderConfigField[] = [
+	API_KEY_FIELD,
+	BASE_URL_FIELD,
+	{
+		path: "apiLine",
+		label: "API Line",
+		type: "select",
+		description: "Regional API line for Qwen routing.",
+		options: [
+			{ label: "International", value: "international" },
+			{ label: "China", value: "china" },
+		],
+	},
+];
+
+function defaultConfigFieldsForSpec(
+	spec: BuiltinSpec,
+): readonly ProviderConfigField[] {
+	const fields: ProviderConfigField[] = [];
+	if (spec.apiKeyEnv?.length) {
+		fields.push(API_KEY_FIELD);
+	}
+	if (spec.defaults?.baseUrl?.trim()) {
+		fields.push(BASE_URL_FIELD);
+	}
+	return fields;
+}
+
+function cloneModels(
+	models: Record<string, ModelInfo>,
+): Record<string, ModelInfo> {
+	return Object.fromEntries(
+		Object.entries(models).map(([id, info]) => [id, { ...info }]),
+	);
+}
+
+function uniqueCapabilities(
+	capabilities: readonly ProviderCapability[] | undefined,
+): ProviderCapability[] | undefined {
+	if (!capabilities?.length) return undefined;
+	return [...new Set(capabilities)];
+}
+
+function getProviderCapabilities(
+	spec: BuiltinSpec,
+): ProviderCapability[] | undefined {
+	return uniqueCapabilities([
+		...(spec.capabilities ?? []),
+		...(spec.popular !== undefined ? (["popular"] as const) : []),
+	]);
+}
+
+function getProviderMetadata(
+	spec: BuiltinSpec,
+): GatewayProviderMetadata | undefined {
+	const configFields = spec.configFields ?? defaultConfigFieldsForSpec(spec);
+	const metadata: GatewayProviderMetadata = {
+		...spec.metadata,
+		configFields,
+	};
+	if (spec.popular !== undefined) {
+		metadata.popularRank = spec.popular;
+	}
+	return metadata;
+}
+
+function generatedModels(providerId: string): Record<string, ModelInfo> {
+	return cloneModels(getGeneratedModelsForProvider(providerId));
+}
+
+function firstGeneratedModelId(providerId: string): string {
+	const generatedModelList = Object.keys(generatedModels(providerId));
+	if (!generatedModelList.length) {
+		return "";
+	}
+	return generatedModelList[0];
+}
+
+function pickAnthropicModel(match: (id: string) => boolean): ModelInfo {
+	const entry = Object.entries(generatedModels("anthropic")).find(([id]) =>
+		match(id),
+	);
+	if (entry) {
+		return entry[1];
+	}
+	return {
+		id: "sonnet",
+		name: "Claude Sonnet",
+		capabilities: ["streaming", "reasoning"],
+	};
+}
+
+function buildClaudeCodeModels(): Record<string, ModelInfo> {
+	function toClaudeCodeModel(id: "opus" | "sonnet" | "haiku"): ModelInfo {
+		const source =
+			id === "opus"
+				? pickAnthropicModel((modelId) => modelId.includes("opus"))
+				: id === "haiku"
+					? pickAnthropicModel((modelId) => modelId.includes("haiku"))
+					: pickAnthropicModel((modelId) => modelId.includes("sonnet"));
+		return {
+			...source,
+			id,
+			name: `Claude ${id.charAt(0).toUpperCase()}${id.slice(1)}`,
+		};
+	}
+
+	return {
+		opus: toClaudeCodeModel("opus"),
+		sonnet: toClaudeCodeModel("sonnet"),
+		haiku: toClaudeCodeModel("haiku"),
+	};
+}
+
+function buildOpenAICodexModels(): Record<string, ModelInfo> {
+	return filterOpenAICodexModels(generatedModels("openai-native"));
+}
+
+function buildClineModels(): Record<string, ModelInfo> {
+	// Cline is OpenRouter-backed generally, but its recommended-model endpoint
+	// can return Vercel-style ids. Include those exact ids so runtime metadata
+	// resolves without adding duplicate OpenRouter aliases to the picker.
+	const vercelAliasModels = Object.fromEntries(
+		Object.entries(generatedModels("vercel-ai-gateway")).filter(([modelId]) =>
+			isCanonicalModelIdForAliasRules(
+				modelId,
+				VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+			),
+		),
+	);
+	return preferCanonicalModelIds(
+		{
+			...generatedModels("openrouter"),
+			...vercelAliasModels,
+		},
+		VERCEL_OPENROUTER_MODEL_ID_ALIAS_RULES,
+	);
+}
+
+function fallbackModelInfo(id: string, spec?: BuiltinSpec): ModelInfo {
+	const info: ModelInfo = {
+		id,
+		name: id,
+	};
+	if (spec?.family === "openai-compatible") {
+		info.contextWindow = 128_000;
+		info.maxInputTokens = 128_000;
+		info.capabilities = ["streaming", "tools", "images"];
+	}
+	if (spec?.id === "qwen" || spec?.id === "qwen-code") {
+		info.family = "qwen";
+		info.capabilities = ["prompt-cache"];
+	}
+	return info;
+}
+
+function modelInfoToGateway(
+	providerId: string,
+	info: ModelInfo,
+): GatewayModelDefinition {
+	const capabilities = new Set<GatewayModelCapability>(["text"]);
+	for (const cap of info.capabilities ?? []) {
+		switch (cap) {
+			case "tools":
+				capabilities.add("tools");
+				break;
+			case "reasoning":
+				capabilities.add("reasoning");
+				break;
+			case "prompt-cache":
+				capabilities.add("prompt-cache");
+				break;
+			case "images":
+				capabilities.add("images");
+				break;
+			case "structured_output":
+				capabilities.add("structured-output");
+				break;
+		}
+	}
+	const metadata: Record<string, JsonValue | undefined> = {};
+	if (info.family) {
+		metadata.family = info.family;
+	}
+	if (info.pricing) {
+		metadata.pricing = info.pricing;
+	}
+	if (info.status) {
+		metadata.status = info.status;
+	}
+	if (info.releaseDate) {
+		metadata.releaseDate = info.releaseDate;
+	}
+	if (typeof info.metadata?.reasoningDefaultOn === "boolean") {
+		metadata.reasoningDefaultOn = info.metadata.reasoningDefaultOn;
+	}
+	return {
+		id: info.id,
+		name: info.name ?? info.id,
+		providerId,
+		description: info.description,
+		contextWindow: info.contextWindow,
+		maxInputTokens: info.maxInputTokens,
+		maxOutputTokens: info.maxTokens,
+		capabilities: [...capabilities],
+		metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+	};
+}
+
+function inferProtocol(spec: BuiltinSpec): ProviderProtocol {
+	if (spec.client === "openai") {
+		return "openai-responses";
+	}
+	switch (spec.family) {
+		case "openai":
+			return "openai-responses";
+		case "anthropic":
+		case "bedrock":
+			return "anthropic";
+		case "google":
+		case "vertex":
+			return "gemini";
+		default:
+			return "openai-chat";
+	}
+}
+
+function inferClient(spec: BuiltinSpec): ProviderClient {
+	if (spec.protocol === "openai-responses") {
+		return "openai";
+	}
+	switch (spec.family) {
+		case "openai":
+			return "openai";
+		case "anthropic":
+			return "anthropic";
+		case "google":
+			return "gemini";
+		case "vertex":
+			return "vertex";
+		case "bedrock":
+			return "bedrock";
+		case "mistral":
+		case "claude-code":
+		case "openai-codex":
+		case "opencode":
+		case "dify":
+		case "sap-ai-core":
+			return "ai-sdk-community";
+		default:
+			return "openai-compatible";
+	}
+}
+
+function createClineLikeSpec(
+	input: Pick<BuiltinSpec, "id" | "name" | "defaultModelId"> &
+		Partial<
+			Pick<
+				BuiltinSpec,
+				| "description"
+				| "popular"
+				| "modelsProviderId"
+				| "modelsFactory"
+				| "metadata"
+				| "defaults"
+			>
+		>,
+): BuiltinSpec {
+	return {
+		id: input.id,
+		name: input.name,
+		description: input.description ?? "Cline API endpoint",
+		family: "openai-compatible",
+		popular: input.popular,
+		capabilities: ["reasoning", "prompt-cache", "tools", "oauth"],
+		modelsProviderId: input.modelsProviderId,
+		modelsFactory: input.modelsFactory,
+		defaultModelId: input.defaultModelId,
+		apiKeyEnv: ["CLINE_API_KEY"],
+		defaults: {
+			get baseUrl(): string {
+				return `${getClineEnvironmentConfig().apiBaseUrl}/api/v1`;
+			},
+			...input.defaults,
+		},
+		metadata: {
+			...ANTHROPIC_AND_QWEN_CACHE_ROUTING_METADATA,
+			...input.metadata,
+		},
+	};
+}
+
+async function handleClineResponseError(
+	response: Response,
+	providerId: string,
+): Promise<void> {
+	if (response.status < 400) {
+		return;
+	}
+
+	const body = await response
+		.clone()
+		.text()
+		.catch(() => "");
+
+	if (isClineOrgIndividualInferenceSubscriptionMessage(body)) {
+		throw new ClineOrgIndividualInferenceSubscriptionError(providerId);
+	}
+
+	const clinePassLimitMessage = extractClinePassLimitMessage(body);
+	if (clinePassLimitMessage) {
+		throw new ClinePassLimitError(clinePassLimitMessage, providerId);
+	}
+
+	if (isClineNotSubscribedMessage(body)) {
+		throw new ClineNotSubscribedError(providerId);
+	}
+}
+
+const cline = createClineLikeSpec({
+	id: "cline",
+	name: "Cline Usage-Billing",
+	popular: 1,
+	modelsFactory: buildClineModels,
+	defaultModelId: CLINE_DEFAULT_MODEL_ID,
+	defaults: {
+		options: {
+			onResponseError: async (response: Response) => {
+				await handleClineResponseError(response, "cline");
+			},
+		},
+	},
+});
+
+const clinePass = createClineLikeSpec({
+	id: CLINE_PASS_PROVIDER_ID,
+	name: "ClinePass",
+	popular: 2,
+	description: "Cline API endpoint with ClinePass models",
+	modelsProviderId: CLINE_PASS_PROVIDER_ID,
+	defaultModelId: firstGeneratedModelId(CLINE_PASS_PROVIDER_ID),
+	metadata: { usageCostDisplay: "subscription" },
+	defaults: {
+		options: {
+			onResponseError: async (response: Response) => {
+				await handleClineResponseError(response, CLINE_PASS_PROVIDER_ID);
+			},
+		},
+	},
+});
+
+const OPENAI_COMPATIBLE_SPECS: BuiltinSpec[] = [
+	{
+		id: "openai-compatible",
+		name: "OpenAI Compatible",
+		description: "OpenAI-compatible chat completions endpoint",
+		family: "openai-compatible",
+		popular: 35,
+		capabilities: ["tools"],
+		defaultModelId: "gpt-4o",
+		apiKeyEnv: ["OPENAI_API_KEY"],
+		defaults: { baseUrl: "https://api.openai.com/v1" },
+	},
+	cline,
+	clinePass,
+	{
+		id: "deepseek",
+		name: "DeepSeek",
+		description: "Advanced AI models with reasoning capabilities",
+		family: "openai-compatible",
+		popular: 10,
+		capabilities: ["reasoning", "prompt-cache"],
+		defaultModelId: "deepseek-v4-flash",
+		apiKeyEnv: ["DEEPSEEK_API_KEY"],
+		defaults: { baseUrl: "https://api.deepseek.com/v1" },
+	},
+	{
+		id: "xai",
+		name: "xAI",
+		description: "Creator of Grok AI assistant",
+		family: "openai-compatible",
+		capabilities: ["reasoning"],
+		defaultModelId: "grok-4.20-0309-non-reasoning",
+		apiKeyEnv: ["XAI_API_KEY"],
+		defaults: { baseUrl: "https://api.x.ai/v1" },
+	},
+	{
+		id: "together",
+		name: "Together AI",
+		description: "Fast inference for open-source models",
+		family: "openai-compatible",
+		capabilities: ["reasoning"],
+		defaultModelId: "Qwen/Qwen3.5-397B-A17B",
+		apiKeyEnv: ["TOGETHER_API_KEY"],
+		defaults: { baseUrl: "https://api.together.xyz/v1" },
+	},
+	{
+		id: "fireworks",
+		name: "Fireworks AI",
+		description: "High-performance inference platform",
+		family: "openai-compatible",
+		defaultModelId: "accounts/fireworks/models/kimi-k2p6",
+		apiKeyEnv: ["FIREWORKS_API_KEY"],
+		defaults: { baseUrl: "https://api.fireworks.ai/inference/v1" },
+	},
+	{
+		id: "groq",
+		name: "Groq",
+		description: "Ultra-fast LPU inference",
+		family: "openai-compatible",
+		defaultModelId: "moonshotai/kimi-k2-instruct-0905",
+		apiKeyEnv: ["GROQ_API_KEY"],
+		defaults: { baseUrl: "https://api.groq.com/openai/v1" },
+	},
+	{
+		id: "poolside",
+		name: "Poolside",
+		description: "OpenAI-compatible code intelligence models",
+		family: "openai-compatible",
+		capabilities: ["tools", "reasoning"],
+		defaultModelId: "poolside/laguna-m.1",
+		apiKeyEnv: ["POOLSIDE_API_KEY"],
+		defaults: { baseUrl: "https://inference.poolside.ai/v1" },
+	},
+	{
+		id: "cerebras",
+		name: "Cerebras",
+		description: "Fast inference on Cerebras wafer-scale chips",
+		family: "openai-compatible",
+		defaultModelId: "zai-glm-4.7",
+		apiKeyEnv: ["CEREBRAS_API_KEY"],
+		defaults: { baseUrl: "https://api.cerebras.ai/v1" },
+	},
+	{
+		id: "sambanova",
+		name: "SambaNova",
+		description: "High-performance AI inference",
+		family: "openai-compatible",
+		apiKeyEnv: ["SAMBANOVA_API_KEY"],
+		modelsProviderId: "sambanova",
+		defaults: { baseUrl: "https://api.sambanova.ai/v1" },
+	},
+	{
+		id: "nebius",
+		name: "Nebius",
+		description: "European cloud AI infrastructure",
+		family: "openai-compatible",
+		defaultModelId: "nvidia/nemotron-3-super-120b-a12b",
+		apiKeyEnv: ["NEBIUS_API_KEY"],
+		defaults: { baseUrl: "https://api.studio.nebius.ai/v1" },
+	},
+	{
+		id: "baseten",
+		name: "Baseten",
+		description: "ML inference platform",
+		family: "openai-compatible",
+		apiKeyEnv: ["BASETEN_API_KEY"],
+		modelsProviderId: "baseten",
+		defaults: { baseUrl: "https://model-api.baseten.co/v1" },
+	},
+	{
+		id: "requesty",
+		name: "Requesty",
+		description: "AI router with multiple provider support",
+		family: "openai-compatible",
+		capabilities: ["reasoning"],
+		defaultModelId: "openai/gpt-5.4",
+		apiKeyEnv: ["REQUESTY_API_KEY"],
+		modelsProviderId: "requesty",
+		defaults: { baseUrl: "https://router.requesty.ai/v1" },
+	},
+	{
+		id: "litellm",
+		name: "LiteLLM",
+		description: "Self-hosted LLM proxy",
+		family: "openai-compatible",
+		protocol: "openai-responses",
+		popular: 40,
+		capabilities: ["prompt-cache"],
+		defaultModelId: "gpt-5.4",
+		apiKeyEnv: ["LITELLM_API_KEY"],
+		defaults: { baseUrl: "http://localhost:4000/v1" },
+	},
+	{
+		id: "huggingface",
+		name: "Hugging Face",
+		description: "Hugging Face inference API",
+		family: "openai-compatible",
+		defaultModelId: "MiniMaxAI/MiniMax-M2.5",
+		apiKeyEnv: ["HF_TOKEN"],
+		modelsProviderId: "huggingface",
+		defaults: { baseUrl: "https://router.huggingface.co/v1" },
+	},
+	{
+		id: "vercel-ai-gateway",
+		name: "Vercel AI Gateway",
+		description: "Vercel's AI gateway service",
+		family: "openai-compatible",
+		capabilities: ["reasoning"],
+		defaultModelId: "alibaba/qwen3.6-plus",
+		apiKeyEnv: ["AI_GATEWAY_API_KEY"],
+		modelsProviderId: "vercel-ai-gateway",
+		defaults: { baseUrl: "https://ai-gateway.vercel.sh/v1" },
+		metadata: ANTHROPIC_AND_QWEN_CACHE_ROUTING_METADATA,
+	},
+	{
+		id: "v0",
+		name: "Vercel V0",
+		description:
+			"The Vercel provider gives you access to the v0 API, designed for building modern web applications.",
+		family: "openai-compatible",
+		capabilities: ["reasoning", "tools"],
+		defaultModelId: "v0-1.5-md",
+		apiKeyEnv: ["V0_API_KEY"],
+		modelsProviderId: "v0",
+		defaults: { baseUrl: "https://api.v0.dev/v1" },
+	},
+	{
+		id: "aihubmix",
+		name: "AI Hub Mix",
+		description: "AI model aggregator",
+		family: "openai-compatible",
+		defaultModelId: "gpt-4o",
+		apiKeyEnv: ["AIHUBMIX_API_KEY"],
+		modelsProviderId: "aihubmix",
+		defaults: { baseUrl: "https://api.aihubmix.com/v1" },
+		metadata: ANTHROPIC_ROUTING_METADATA,
+	},
+	{
+		id: "hicap",
+		name: "HiCap",
+		description: "HiCap AI platform",
+		family: "openai-compatible",
+		defaultModelId: "hicap-pro",
+		apiKeyEnv: ["HICAP_API_KEY"],
+		defaults: { baseUrl: "https://api.hicap.ai/v1" },
+	},
+	{
+		id: "nousResearch",
+		name: "Nous Research",
+		description: "Open-source AI research lab",
+		family: "openai-compatible",
+		defaultModelId: "DeepHermes-3-Llama-3-3-70B-Preview",
+		apiKeyEnv: ["NOUS_RESEARCH_API_KEY", "NOUSRESEARCH_API_KEY"],
+		modelsProviderId: "nousResearch",
+		defaults: { baseUrl: "https://inference-api.nousresearch.com/v1" },
+	},
+	{
+		id: "huawei-cloud-maas",
+		name: "Huawei Cloud MaaS",
+		description: "Huawei's model-as-a-service platform",
+		family: "openai-compatible",
+		defaultModelId: "DeepSeek-R1",
+		apiKeyEnv: ["HUAWEI_CLOUD_MAAS_API_KEY"],
+		defaults: {
+			baseUrl: "https://infer-modelarts.cn-southwest-2.myhuaweicloud.com/v1",
+		},
+	},
+	{
+		id: "qwen",
+		name: "Alibaba Qwen",
+		description: "Alibaba Qwen platform models",
+		family: "openai-compatible",
+		capabilities: ["tools", "reasoning"],
+		defaultModelId: "qwen-plus-latest",
+		apiKeyEnv: ["QWEN_API_KEY"],
+		modelsProviderId: "qwen",
+		defaults: { baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
+		configFields: QWEN_CONFIG_FIELDS,
+		metadata: QWEN_CACHE_ROUTING_METADATA,
+	},
+	{
+		id: "qwen-code",
+		name: "Alibaba Qwen Code",
+		description: "Qwen OAuth coding models",
+		family: "openai-compatible",
+		capabilities: ["tools", "reasoning"],
+		defaultModelId: "qwen3-coder-plus",
+		modelsProviderId: "qwen-code",
+		defaults: { baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
+		configFields: QWEN_CONFIG_FIELDS,
+		metadata: QWEN_CACHE_ROUTING_METADATA,
+	},
+	{
+		id: "doubao",
+		name: "Doubao",
+		description: "Volcengine Ark platform models",
+		family: "openai-compatible",
+		capabilities: ["tools"],
+		defaultModelId: "doubao-1-5-pro-256k-250115",
+		apiKeyEnv: ["DOUBAO_API_KEY"],
+		modelsProviderId: "doubao",
+		defaults: { baseUrl: "https://ark.cn-beijing.volces.com/api/v3" },
+	},
+	{
+		id: "zai",
+		name: "Z.AI",
+		description: "Z.AI's family of LLMs",
+		family: "openai-compatible",
+		capabilities: ["reasoning"],
+		defaultModelId: "glm-5v-turbo",
+		apiKeyEnv: ["ZHIPU_API_KEY"],
+		modelsProviderId: "zai",
+		defaults: { baseUrl: "https://api.z.ai/api/paas/v4" },
+		metadata: GLM_THINKING_ROUTING_METADATA,
+	},
+	{
+		id: "zai-coding-plan",
+		name: "Z.AI Coding Plan",
+		description: "Z.AI's coding-focused models",
+		family: "openai-compatible",
+		capabilities: ["reasoning", "tools"],
+		defaultModelId: "glm-5.2",
+		apiKeyEnv: ["ZHIPU_API_KEY"],
+		modelsProviderId: "zai-coding-plan",
+		defaults: { baseUrl: "https://api.z.ai/api/coding/paas/v4" },
+		metadata: GLM_THINKING_ROUTING_METADATA,
+	},
+	{
+		id: "moonshot",
+		name: "Moonshot",
+		description: "Moonshot AI Studio models",
+		family: "openai-compatible",
+		capabilities: ["tools", "reasoning"],
+		defaultModelId: "kimi-k2-0905-preview",
+		apiKeyEnv: ["MOONSHOT_API_KEY"],
+		modelsProviderId: "moonshot",
+		defaults: { baseUrl: "https://api.moonshot.ai/v1" },
+	},
+	{
+		id: "wandb",
+		name: "W&B by CoreWeave",
+		description: "Weights & Biases",
+		family: "openai-compatible",
+		capabilities: ["reasoning", "prompt-cache", "tools"],
+		defaultModelId: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-FP8",
+		apiKeyEnv: ["WANDB_API_KEY"],
+		modelsProviderId: "wandb",
+		defaults: { baseUrl: "https://api.inference.wandb.ai/v1" },
+	},
+	{
+		id: "xiaomi",
+		name: "Xiaomi",
+		description: "Xiaomi",
+		family: "openai-compatible",
+		capabilities: ["prompt-cache", "tools", "reasoning"],
+		defaultModelId: "mimo-v2.5",
+		apiKeyEnv: ["XIAOMI_API_KEY"],
+		modelsProviderId: "xiaomi",
+		defaults: { baseUrl: "https://api.xiaomimimo.com/v1" },
+	},
+	{
+		id: "tencent-tokenhub",
+		name: "Tencent TokenHub",
+		description: "Tencent TokenHub AI models",
+		family: "openai-compatible",
+		capabilities: ["tools", "reasoning"],
+		defaultModelId: "hy3-preview",
+		apiKeyEnv: ["TENCENT_TOKENHUB_API_KEY"],
+		modelsProviderId: "tencent-tokenhub",
+		docsUrl: "https://cloud.tencent.com/document/product/1823/130050",
+		defaults: { baseUrl: "https://tokenhub.tencentmaas.com/v1" },
+	},
+	{
+		id: "kilo",
+		name: "Kilo Gateway",
+		description: "Kilo Gateway",
+		family: "openai-compatible",
+		protocol: "openai-responses",
+		capabilities: ["prompt-cache", "reasoning", "tools"],
+		defaultModelId: "gpt-4o",
+		apiKeyEnv: ["KILO_GATEWAY_API_KEY"],
+		modelsProviderId: "kilo",
+		defaults: { baseUrl: "https://api.kilo.ai/api/gateway" },
+	},
+	{
+		id: "openrouter",
+		name: "OpenRouter",
+		description: "OpenRouter AI platform",
+		family: "openai-compatible",
+		popular: 20,
+		capabilities: ["reasoning", "prompt-cache"],
+		defaultModelId: "anthropic/claude-sonnet-4.6",
+		apiKeyEnv: ["OPENROUTER_API_KEY"],
+		modelsProviderId: "openrouter",
+		docsUrl: "https://openrouter.ai/models",
+		defaults: { baseUrl: "https://openrouter.ai/api/v1" },
+		metadata: {
+			...ANTHROPIC_AND_QWEN_CACHE_ROUTING_METADATA,
+			...OPENROUTER_STICKY_SESSION_METADATA,
+		},
+	},
+	{
+		id: "ollama",
+		name: "Ollama",
+		description: "Ollama Cloud and local LLM hosting",
+		family: "openai-compatible",
+		popular: 25,
+		defaultModelId: "",
+		apiKeyEnv: ["OLLAMA_API_KEY"],
+		defaults: { baseUrl: "http://localhost:11434/v1" },
+		modelsSourceUrl: "http://localhost:11434/api/tags",
+	},
+	{
+		id: "lmstudio",
+		name: "LM Studio",
+		description: "Local model inference with LM Studio",
+		family: "openai-compatible",
+		defaultModelId: "",
+		apiKeyEnv: ["LMSTUDIO_API_KEY"],
+		modelsProviderId: "lmstudio",
+		defaults: { baseUrl: "http://localhost:1234/v1" },
+		modelsSourceUrl: "http://localhost:1234/v1/models",
+	},
+	{
+		id: "oca",
+		name: "Oracle Code Assist",
+		description: "Oracle Code Assist (OCA) LiteLLM gateway",
+		family: "openai-compatible",
+		capabilities: ["reasoning", "prompt-cache", "tools"],
+		defaultModelId: "anthropic/claude-3-7-sonnet-20250219",
+		apiKeyEnv: ["OCA_API_KEY"],
+		modelsProviderId: "oca",
+		defaults: { baseUrl: DEFAULT_EXTERNAL_OCA_BASE_URL },
+		configFields: OCA_CONFIG_FIELDS,
+		metadata: ANTHROPIC_ROUTING_METADATA,
+	},
+	{
+		id: "asksage",
+		name: "AskSage",
+		description: "AskSage platform",
+		family: "openai-compatible",
+		client: "fetch",
+		capabilities: ["tools"],
+		defaultModelId: "gpt-4o",
+		apiKeyEnv: ["ASKSAGE_API_KEY"],
+		modelsFactory: () => ({}),
+		defaults: { baseUrl: "https://api.asksage.ai/server" },
+	},
+];
+
+export const BUILTIN_SPECS: BuiltinSpec[] = [
+	{
+		id: "openai-native",
+		name: "OpenAI",
+		description: "Creator of GPT and ChatGPT",
+		family: "openai",
+		capabilities: ["reasoning"],
+		modelsProviderId: "openai-native",
+		defaultModelId: "gpt-5.4",
+		apiKeyEnv: ["OPENAI_API_KEY"],
+		defaults: { baseUrl: "https://api.openai.com/v1" },
+	},
+	{
+		id: "openai-codex",
+		name: "OpenAI ChatGPT Subscription",
+		description:
+			"OpenAI ChatGPT subscription access uses an OAuth device code flow.",
+		family: "openai",
+		popular: 5,
+		capabilities: ["reasoning", "oauth"],
+		defaultModelId: OPENAI_CODEX_DEFAULT_MODEL_ID,
+		modelsFactory: buildOpenAICodexModels,
+		defaults: { baseUrl: "https://chatgpt.com/backend-api/codex" },
+		configFields: [],
+		metadata: { usageCostDisplay: "subscription" },
+	},
+	{
+		id: "openai-codex-cli",
+		name: "OpenAI Codex CLI",
+		description: "OpenAI Codex via the local Codex CLI provider",
+		family: "openai-codex",
+		capabilities: ["reasoning", "provider-tools", "local-auth"],
+		defaultModelId: "gpt-5.3-codex",
+		modelsProviderId: "openai",
+		defaults: { baseUrl: "https://chatgpt.com/backend-api/codex" },
+		configFields: [],
+		metadata: { usageCostDisplay: "subscription" },
+	},
+	{
+		id: "anthropic",
+		name: "Anthropic",
+		description: "Creator of Claude, the AI assistant",
+		family: "anthropic",
+		popular: 15,
+		capabilities: ["reasoning", "prompt-cache"],
+		defaultModelId: "claude-sonnet-4-6",
+		apiKeyEnv: ["ANTHROPIC_API_KEY"],
+		modelsProviderId: "anthropic",
+		defaults: { baseUrl: "https://api.anthropic.com/v1" },
+		metadata: ANTHROPIC_ROUTING_METADATA,
+	},
+	{
+		id: "claude-code",
+		name: "Claude Code",
+		description: "Use Claude Code SDK with Claude Pro/Max subscription",
+		family: "claude-code",
+		capabilities: ["reasoning"],
+		defaultModelId: "sonnet",
+		modelsFactory: buildClaudeCodeModels,
+		defaults: { baseUrl: "" },
+		configFields: [],
+	},
+	{
+		id: "gemini",
+		name: "Google Gemini",
+		description: "Google Gemini API",
+		family: "google",
+		popular: 45,
+		capabilities: ["reasoning", "prompt-cache"],
+		defaultModelId: "gemma-4-26b",
+		apiKeyEnv: ["GOOGLE_GENERATIVE_AI_API_KEY", "GEMINI_API_KEY"],
+		modelsProviderId: "gemini",
+		defaults: { baseUrl: "https://generativelanguage.googleapis.com/v1beta" },
+	},
+	{
+		id: "vertex",
+		name: "Google Vertex AI",
+		description: "Google Cloud Vertex AI",
+		family: "vertex",
+		capabilities: ["reasoning", "prompt-cache"],
+		apiKeyEnv: [
+			"GCP_PROJECT_ID",
+			"GOOGLE_CLOUD_PROJECT",
+			"GOOGLE_APPLICATION_CREDENTIALS",
+			"GEMINI_API_KEY",
+			"GOOGLE_API_KEY",
+			"GOOGLE_VERTEX_PROJECT",
+			"GOOGLE_VERTEX_LOCATION",
+		],
+		modelsProviderId: "vertex",
+		configFields: VERTEX_CONFIG_FIELDS,
+		metadata: ANTHROPIC_ROUTING_METADATA,
+	},
+	{
+		id: "bedrock",
+		name: "AWS Bedrock",
+		description: "Amazon Bedrock managed foundation models",
+		family: "bedrock",
+		popular: 30,
+		capabilities: ["reasoning", "prompt-cache"],
+		defaultModelId: "minimax.minimax-m2.5",
+		apiKeyEnv: [
+			"AWS_BEARER_TOKEN_BEDROCK",
+			"AWS_REGION",
+			"AWS_ACCESS_KEY_ID",
+			"AWS_SECRET_ACCESS_KEY",
+			"AWS_SESSION_TOKEN",
+		],
+		modelsProviderId: "bedrock",
+		configFields: BEDROCK_CONFIG_FIELDS,
+		metadata: ANTHROPIC_ROUTING_METADATA,
+	},
+	{
+		id: "mistral",
+		name: "Mistral",
+		description: "Mistral AI models via AI SDK provider",
+		family: "mistral",
+		capabilities: ["reasoning"],
+		defaultModelId: "mistral-medium-latest",
+		apiKeyEnv: ["MISTRAL_API_KEY"],
+		modelsFactory: () => ({}),
+		defaults: { baseUrl: "https://api.mistral.ai/v1" },
+	},
+	{
+		id: "minimax",
+		name: "MiniMax",
+		description: "MiniMax models via Anthropic-compatible API",
+		family: "anthropic",
+		capabilities: ["tools", "reasoning", "prompt-cache"],
+		defaultModelId: "MiniMax-M2.5",
+		apiKeyEnv: ["MINIMAX_API_KEY"],
+		modelsProviderId: "minimax",
+		defaults: { baseUrl: "https://api.minimax.io/anthropic/v1" },
+		metadata: MINIMAX_THINKING_ROUTING_METADATA,
+	},
+	{
+		id: "opencode",
+		name: "OpenCode",
+		description: "OpenCode SDK multi-provider runtime",
+		family: "opencode",
+		capabilities: ["reasoning", "oauth"],
+		defaultModelId: "openai/gpt-5.4",
+		modelsProviderId: "opencode",
+		defaults: { baseUrl: "" },
+		configFields: [],
+	},
+	{
+		id: "dify",
+		name: "Dify",
+		description: "Dify workflow/application provider via AI SDK",
+		family: "dify",
+		defaultModelId: "default",
+		apiKeyEnv: ["DIFY_API_KEY"],
+		modelsFactory: () => ({}),
+	},
+	{
+		id: "sapaicore",
+		name: "SAP AI Core",
+		description: "SAP AI Core inference and orchestration platform",
+		family: "sap-ai-core",
+		client: "ai-sdk-community",
+		capabilities: ["tools", "reasoning", "prompt-cache"],
+		defaultModelId: "anthropic--claude-3.5-sonnet",
+		apiKeyEnv: ["AICORE_SERVICE_KEY", "VCAP_SERVICES"],
+		modelsProviderId: "sapaicore",
+		metadata: ANTHROPIC_ROUTING_METADATA,
+	},
+	...OPENAI_COMPATIBLE_SPECS,
+];
+
+function getModels(spec: BuiltinSpec): Record<string, ModelInfo> {
+	if (spec.modelsFactory) {
+		return spec.modelsFactory();
+	}
+	if (spec.modelsProviderId) {
+		return generatedModels(spec.modelsProviderId);
+	}
+	return {};
+}
+
+function toModelCollection(spec: BuiltinSpec): ModelCollection {
+	const sourceModels = getModels(spec);
+	const capabilities = getProviderCapabilities(spec);
+	const metadata = getProviderMetadata(spec);
+	const models =
+		Object.keys(sourceModels).length > 0
+			? sourceModels
+			: spec.defaultModelId
+				? {
+						[spec.defaultModelId]: fallbackModelInfo(spec.defaultModelId, spec),
+					}
+				: {};
+	const modelIds = Object.keys(models);
+	const defaultModelId = spec.defaultModelId || modelIds[0] || "default";
+
+	return {
+		provider: {
+			id: spec.id,
+			name: spec.name,
+			description: spec.description,
+			protocol: spec.protocol ?? inferProtocol(spec),
+			baseUrl: spec.defaults?.baseUrl,
+			modelsSourceUrl: spec.modelsSourceUrl,
+			defaultModelId,
+			capabilities,
+			env: spec.apiKeyEnv ? [...spec.apiKeyEnv] : undefined,
+			client: spec.client ?? inferClient(spec),
+			source: "system",
+			metadata,
+		},
+		models,
+	};
+}
+
+export function toManifest(spec: BuiltinSpec): GatewayProviderManifest {
+	const collection = toModelCollection(spec);
+	const capabilities = getProviderCapabilities(spec);
+	const metadata = getProviderMetadata(spec);
+	const models = Object.values(collection.models).map((info) =>
+		modelInfoToGateway(spec.id, info),
+	);
+	const resolvedModels =
+		models.length > 0
+			? models
+			: [
+					{
+						id: collection.provider.defaultModelId || "default",
+						name: collection.provider.defaultModelId || "Default",
+						providerId: spec.id,
+						capabilities: ["text"] as GatewayModelCapability[],
+					},
+				];
+
+	return {
+		id: spec.id,
+		name: spec.name,
+		description: spec.description,
+		defaultModelId:
+			collection.provider.defaultModelId || resolvedModels[0]?.id || "default",
+		models: resolvedModels,
+		capabilities,
+		env: spec.env ?? ["browser", "node"],
+		api: spec.defaults?.baseUrl,
+		apiKeyEnv: spec.apiKeyEnv,
+		docsUrl: spec.docsUrl,
+		metadata,
+	};
+}
+
+export const BUILTIN_PROVIDER_COLLECTION_LIST: ModelCollection[] =
+	BUILTIN_SPECS.map(toModelCollection);
+
+export const BUILTIN_PROVIDER_COLLECTIONS_BY_ID: Record<
+	string,
+	ModelCollection
+> = Object.fromEntries(
+	BUILTIN_PROVIDER_COLLECTION_LIST.map((collection) => [
+		collection.provider.id,
+		collection,
+	]),
+);
diff --git a/sdk/packages/llms/src/providers/compat.test.ts b/sdk/packages/llms/src/providers/compat.test.ts
new file mode 100644
index 0000000..ca5b4ce
--- /dev/null
+++ b/sdk/packages/llms/src/providers/compat.test.ts
@@ -0,0 +1,775 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createGatewayApiHandler, toGatewayRequestMessages } from "./compat";
+import { ClineNotSubscribedError } from "./errors";
+import type { Message } from "./types";
+
+const streamTextSpy = vi.fn();
+const openaiCompatibleFactorySpy = vi.fn();
+const openaiCompatibleSpy = vi.fn((modelId: string) => ({
+	modelId,
+	family: "openai-compatible",
+}));
+
+vi.mock("ai", () => ({
+	jsonSchema: (schema: unknown, options: unknown) => ({
+		jsonSchema: schema,
+		...(options && typeof options === "object" ? options : {}),
+	}),
+	streamText: (input: unknown) => streamTextSpy(input),
+	wrapLanguageModel: ({ model }: { model: unknown }) => model,
+}));
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+	createOpenAICompatible: (config: unknown) => {
+		openaiCompatibleFactorySpy(config);
+		return (modelId: string) => openaiCompatibleSpy(modelId);
+	},
+}));
+
+vi.mock("@ai-sdk/openai", () => ({
+	createOpenAI: () => ({
+		responses: (modelId: string) => ({ modelId, family: "openai" }),
+	}),
+}));
+
+vi.mock("@ai-sdk/anthropic", () => ({
+	createAnthropic: () => (modelId: string) => ({
+		modelId,
+		family: "anthropic",
+	}),
+}));
+
+vi.mock("@ai-sdk/google", () => ({
+	createGoogleGenerativeAI: () => (modelId: string) => ({
+		modelId,
+		family: "google",
+	}),
+}));
+
+vi.mock("ai-sdk-provider-codex-cli", () => ({
+	createCodexExec: () => (modelId: string) => ({
+		modelId,
+		family: "openai-codex",
+	}),
+}));
+
+describe("createGatewayApiHandler.getMessages", () => {
+	it("preserves structured tool_result content for gateway requests", () => {
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "test-model",
+			apiKey: "test-key",
+		});
+
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_1",
+						name: "run_commands",
+						input: { commands: ["echo hello"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_1",
+						content: [
+							{
+								query: "echo hello",
+								result: "hello\n",
+								success: true,
+							},
+						],
+					},
+				],
+			},
+		];
+
+		const request = handler.getMessages("", messages) as {
+			messages: Array<{
+				role: string;
+				content: Array<Record<string, unknown>>;
+			}>;
+		};
+
+		expect(request.messages).toHaveLength(2);
+		expect(request.messages[1]).toMatchObject({
+			role: "user",
+			content: [
+				{
+					type: "tool-result",
+					toolCallId: "toolu_1",
+					toolName: "run_commands",
+					output: [
+						{
+							query: "echo hello",
+							result: "hello\n",
+							success: true,
+						},
+					],
+					isError: false,
+				},
+			],
+		});
+	});
+
+	it("normalizes mixed legacy blocks and structured tool results", () => {
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "test-model",
+			apiKey: "test-key",
+		});
+
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_2",
+						name: "run_commands",
+						input: { commands: ["pwd"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_2",
+						content: [
+							{ type: "text", text: "Command output:" },
+							{
+								query: "pwd",
+								result: "/tmp/project\n",
+								success: true,
+							},
+							{ type: "file", path: "/tmp/log.txt", content: "log line" },
+						],
+					},
+				],
+			},
+		];
+
+		const request = handler.getMessages("", messages) as {
+			messages: Array<{
+				role: string;
+				content: Array<Record<string, unknown>>;
+			}>;
+		};
+
+		// `toGatewayRequestMessages` now forwards the raw `tool_result.content`
+		// unchanged. Downstream `formatMessagesForAiSdk` /
+		// `toAiSdkToolResultOutput` is responsible for any flattening or
+		// image-extraction; this layer only translates Cline's `Message[]`
+		// shape into AI-SDK formatter parts.
+		expect(request.messages[1]).toMatchObject({
+			role: "user",
+			content: [
+				{
+					type: "tool-result",
+					toolCallId: "toolu_2",
+					toolName: "run_commands",
+					output: [
+						{ type: "text", text: "Command output:" },
+						{
+							query: "pwd",
+							result: "/tmp/project\n",
+							success: true,
+						},
+						{ type: "file", path: "/tmp/log.txt", content: "log line" },
+					],
+					isError: false,
+				},
+			],
+		});
+	});
+
+	it("forwards nested images inside structured tool results to the AI SDK formatter", () => {
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "test-model",
+			apiKey: "test-key",
+		});
+
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_3",
+						name: "read_files",
+						input: { file_paths: ["/tmp/demo.png"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_3",
+						content: [
+							{
+								query: "/tmp/demo.png",
+								success: true,
+								result: [
+									{ type: "text", text: "Successfully read image" },
+									{
+										type: "image",
+										data: "YWJj",
+										mediaType: "image/png",
+									},
+								],
+							},
+						],
+					},
+				],
+			},
+		];
+
+		const request = handler.getMessages("", messages) as {
+			messages: Array<{
+				role: string;
+				content: Array<Record<string, unknown>>;
+			}>;
+		};
+
+		// The compat layer no longer detaches images into sibling user
+		// messages — that responsibility moved into
+		// `toAiSdkToolResultOutput`, which extracts every nested `image`
+		// content block into native `image-data` content parts. The
+		// gateway request therefore contains the original
+		// `ToolOperationResult[]` content unchanged, with the image block
+		// still embedded inside `result`.
+		expect(request.messages[1]).toMatchObject({
+			role: "user",
+			content: [
+				{
+					type: "tool-result",
+					toolCallId: "toolu_3",
+					toolName: "read_files",
+					output: [
+						{
+							query: "/tmp/demo.png",
+							success: true,
+							result: [
+								{ type: "text", text: "Successfully read image" },
+								{
+									type: "image",
+									data: "YWJj",
+									mediaType: "image/png",
+								},
+							],
+						},
+					],
+					isError: false,
+				},
+			],
+		});
+		expect(request.messages[1]?.content).toHaveLength(1);
+	});
+
+	it("preserves is_error for structured tool results", () => {
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "test-model",
+			apiKey: "test-key",
+		});
+
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "toolu_4",
+						name: "run_commands",
+						input: { commands: ["false"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "toolu_4",
+						is_error: true,
+						content: [
+							{
+								query: "false",
+								result: "",
+								error: "Command failed: exit 1",
+								success: false,
+							},
+						],
+					},
+				],
+			},
+		];
+
+		const request = handler.getMessages("", messages) as {
+			messages: Array<{
+				role: string;
+				content: Array<Record<string, unknown>>;
+			}>;
+		};
+
+		expect(request.messages[1]).toMatchObject({
+			role: "user",
+			content: [
+				{
+					type: "tool-result",
+					toolCallId: "toolu_4",
+					toolName: "run_commands",
+					output: [
+						{
+							query: "false",
+							result: "",
+							error: "Command failed: exit 1",
+							success: false,
+						},
+					],
+					isError: true,
+				},
+			],
+		});
+	});
+});
+
+describe("createGatewayApiHandler.createMessage", () => {
+	beforeEach(() => {
+		streamTextSpy.mockReset();
+		openaiCompatibleFactorySpy.mockReset();
+		openaiCompatibleSpy.mockClear();
+	});
+
+	it("does not convert catalog maxTokens into request maxOutputTokens", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+
+		const handler = createGatewayApiHandler({
+			providerId: "openrouter",
+			clientType: "openai-compatible",
+			modelId: "z-ai/glm-5.1",
+			apiKey: "test-key",
+			knownModels: {
+				"z-ai/glm-5.1": {
+					id: "z-ai/glm-5.1",
+					name: "GLM 5.1",
+					contextWindow: 202_800,
+					maxInputTokens: 202_800,
+					maxTokens: 202_800,
+					capabilities: ["tools"],
+				},
+			},
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "Hello" },
+		])) {
+			// Drain the stream so the provider request is executed.
+		}
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { maxOutputTokens?: unknown }
+			| undefined;
+		expect(call).not.toHaveProperty("maxOutputTokens");
+	});
+
+	it("sends configured OpenAI-compatible maxOutputTokens to the provider request", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "custom-model",
+			apiKey: "test-key",
+			baseUrl: "https://example.com/v1",
+			maxOutputTokens: 4_096,
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "Hello" },
+		])) {
+			// Drain the stream so the provider request is executed.
+		}
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				maxOutputTokens: 4_096,
+			}),
+		);
+	});
+
+	it("caps configured maxOutputTokens with the catalog model output limit", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+
+		const handler = createGatewayApiHandler({
+			providerId: "openrouter",
+			clientType: "openai-compatible",
+			modelId: "small-output",
+			apiKey: "test-key",
+			maxOutputTokens: 16_000,
+			knownModels: {
+				"small-output": {
+					id: "small-output",
+					name: "Small Output",
+					contextWindow: 202_800,
+					maxInputTokens: 202_800,
+					maxTokens: 8_192,
+					capabilities: ["tools"],
+				},
+			},
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "Hello" },
+		])) {
+			// Drain the stream so the provider request is executed.
+		}
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				maxOutputTokens: 8_192,
+			}),
+		);
+	});
+
+	it("strips legacy thinking history before sending Cerebras requests", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+
+		const handler = createGatewayApiHandler({
+			providerId: "cerebras",
+			modelId: "zai-glm-4.7",
+			apiKey: "test-key",
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "hello" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "private trace" },
+					{ type: "text", text: "Hello from Cline" },
+				],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "thinking", thinking: "drop me" }],
+			},
+			{ role: "user", content: "workd" },
+		])) {
+			// Drain the stream so the provider request is executed.
+		}
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { messages?: unknown[] }
+			| undefined;
+		expect(call?.messages).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					role: "assistant",
+					content: [
+						expect.objectContaining({
+							type: "text",
+							text: "Hello from Cline",
+						}),
+					],
+				}),
+			]),
+		);
+		const serializedMessages = JSON.stringify(call?.messages);
+		expect(serializedMessages).not.toContain("reasoning");
+		expect(serializedMessages).not.toContain("private trace");
+		expect(serializedMessages).not.toContain("drop me");
+	});
+
+	it("adds Azure API version to deployment-style OpenAI-compatible requests", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+		const providerFetch = vi.fn(
+			async () => new Response("{}"),
+		) as unknown as typeof fetch;
+
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "gpt-4.1",
+			apiKey: "test-key",
+			baseUrl: "https://example.openai.azure.com/openai/deployments/gpt-4.1",
+			fetch: providerFetch,
+			azure: { apiVersion: "2025-01-01-preview" },
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "Hello" },
+		])) {
+			// Drain the stream so the provider is constructed.
+		}
+
+		const factoryConfig = openaiCompatibleFactorySpy.mock.calls.at(-1)?.[0] as
+			| { fetch?: typeof fetch }
+			| undefined;
+		expect(factoryConfig?.fetch).toEqual(expect.any(Function));
+
+		await factoryConfig?.fetch?.(
+			"https://example.openai.azure.com/openai/deployments/gpt-4.1/chat/completions",
+			{ method: "POST" },
+		);
+
+		expect(providerFetch).toHaveBeenCalledWith(
+			"https://example.openai.azure.com/openai/deployments/gpt-4.1/chat/completions?api-version=2025-01-01-preview",
+			{ method: "POST" },
+		);
+	});
+
+	it("does not add Azure API version to OpenAI v1-compatible requests", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+		const providerFetch = vi.fn(
+			async () => new Response("{}"),
+		) as unknown as typeof fetch;
+
+		const handler = createGatewayApiHandler({
+			providerId: "openai-compatible",
+			clientType: "openai-compatible",
+			modelId: "gpt-4.1",
+			apiKey: "test-key",
+			baseUrl: "https://example.openai.azure.com/openai/v1",
+			fetch: providerFetch,
+			azure: { apiVersion: "2025-01-01-preview" },
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "Hello" },
+		])) {
+			// Drain the stream so the provider is constructed.
+		}
+
+		const factoryConfig = openaiCompatibleFactorySpy.mock.calls.at(-1)?.[0] as
+			| { fetch?: typeof fetch }
+			| undefined;
+		await factoryConfig?.fetch?.(
+			"https://example.openai.azure.com/openai/v1/chat/completions",
+			{ method: "POST" },
+		);
+
+		expect(providerFetch).toHaveBeenCalledWith(
+			"https://example.openai.azure.com/openai/v1/chat/completions",
+			{ method: "POST" },
+		);
+	});
+
+	it("throws ClineNotSubscribedError for ClinePass required-plan 403 responses", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: (async function* () {
+				yield { type: "finish", finishReason: "stop" };
+			})(),
+			usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+		});
+		const providerFetch = vi.fn(
+			async () =>
+				new Response(
+					JSON.stringify({
+						error: {
+							message: "the user is not subscribed to required model plan",
+						},
+					}),
+					{ status: 403 },
+				),
+		) as unknown as typeof fetch;
+
+		const handler = createGatewayApiHandler({
+			providerId: "cline-pass",
+			clientType: "openai-compatible",
+			modelId: "premium-model",
+			apiKey: "test-key",
+			fetch: providerFetch,
+		});
+
+		for await (const _chunk of handler.createMessage("", [
+			{ role: "user", content: "Hello" },
+		])) {
+			// Drain the stream so the provider is constructed.
+		}
+
+		const factoryConfig = openaiCompatibleFactorySpy.mock.calls.at(-1)?.[0] as
+			| { fetch?: typeof fetch }
+			| undefined;
+
+		await expect(
+			factoryConfig?.fetch?.("https://api.cline.bot/api/v1/chat/completions", {
+				method: "POST",
+			}),
+		).rejects.toBeInstanceOf(ClineNotSubscribedError);
+	});
+});
+
+/**
+ * Tests for compat.ts message conversion (LlmsProviders.Message → AgentMessage).
+ *
+ * Specifically guards the read_file image-passing path: the orchestrator's
+ * `tool_result` block carries an array of {text, image} content blocks, and we
+ * MUST forward that array as the AgentMessage `tool-result` `output` so the
+ * downstream `toAiSdkToolResultOutput` formatter emits an AI SDK
+ * `{type:"content", value:[{type:"media", ...}, {type:"text", ...}]}`. If we
+ * collapse the array to a string here the image bytes are dropped and the
+ * model hallucinates.
+ */
+describe("toGatewayRequestMessages — tool_result with images", () => {
+	it("forwards text+image content arrays as the tool-result output", () => {
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "read_file",
+						input: { path: "/tmp/image.jpg" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: [
+							{ type: "text", text: "Successfully read image" },
+							{
+								type: "image",
+								data: "BASE64DATA",
+								mediaType: "image/jpeg",
+							},
+						],
+						is_error: false,
+					},
+				],
+			},
+		];
+
+		const [, userMessage] = toGatewayRequestMessages(messages);
+
+		// The user message must contain ONE tool-result block (no orphan image siblings).
+		expect(userMessage.content).toHaveLength(1);
+		const toolResult = userMessage.content[0] as Record<string, unknown>;
+
+		expect(toolResult.type).toBe("tool-result");
+		expect(toolResult.toolCallId).toBe("call_1");
+		expect(toolResult.toolName).toBe("read_file");
+		expect(toolResult.isError).toBe(false);
+
+		// `output` must be the full structured content-block array — including
+		// the image — so toAiSdkToolResultOutput can emit `{type:"content"}`.
+		const output = toolResult.output as Array<Record<string, unknown>>;
+		expect(Array.isArray(output)).toBe(true);
+		expect(output).toHaveLength(2);
+		expect(output[0]).toEqual({
+			type: "text",
+			text: "Successfully read image",
+		});
+		expect(output[1]).toEqual({
+			type: "image",
+			data: "BASE64DATA",
+			mediaType: "image/jpeg",
+		});
+	});
+
+	it("forwards text-only tool_result content unchanged for downstream normalisation", () => {
+		// The compat layer no longer collapses `[{type:'text', text}]` into
+		// a bare string — the AI SDK formatter accepts the content-block
+		// array directly and emits it as a `{type:'content'}` tool-result
+		// output. (`toAiSdkToolResultOutput` then forwards the text part
+		// through unchanged.)
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_2",
+						name: "read_file",
+						input: { path: "/tmp/notes.txt" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_2",
+						content: [{ type: "text", text: "hello world" }],
+					},
+				],
+			},
+		];
+
+		const [, userMessage] = toGatewayRequestMessages(messages);
+		expect(userMessage.content).toHaveLength(1);
+		const toolResult = userMessage.content[0] as Record<string, unknown>;
+		expect(toolResult.output).toEqual([{ type: "text", text: "hello world" }]);
+	});
+
+	it("passes plain string content through unchanged", () => {
+		const messages: Message[] = [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_3",
+						content: "raw string output",
+					},
+				],
+			},
+		];
+
+		const [userMessage] = toGatewayRequestMessages(messages);
+		const toolResult = userMessage.content[0] as Record<string, unknown>;
+		expect(toolResult.output).toBe("raw string output");
+	});
+});
diff --git a/sdk/packages/llms/src/providers/compat.ts b/sdk/packages/llms/src/providers/compat.ts
new file mode 100644
index 0000000..8270850
--- /dev/null
+++ b/sdk/packages/llms/src/providers/compat.ts
@@ -0,0 +1,670 @@
+import type {
+	AgentModelEvent,
+	GatewayModelDefinition,
+	GatewayProviderFactory,
+	GatewayProviderRegistration,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import { nanoid } from "nanoid";
+import type {
+	ModelInfo,
+	ProviderClient,
+	ProviderProtocol,
+} from "../catalog/types";
+import {
+	createAnthropicProvider,
+	createBedrockProvider,
+	createClaudeCodeProvider,
+	createDifyProvider,
+	createGoogleProvider,
+	createMistralProvider,
+	createOpenAICodexProvider,
+	createOpenAICompatibleProvider,
+	createOpenAIProvider,
+	createOpenCodeProvider,
+	createSapAiCoreProvider,
+	createVertexProvider,
+} from "./ai-sdk";
+import { BUILTIN_PROVIDER_REGISTRATIONS } from "./builtins-runtime";
+import { createGateway } from "./gateway";
+import {
+	getProviderCollection,
+	getProviderCollectionSync,
+} from "./model-registry";
+import {
+	type ApiHandler,
+	type ApiStream,
+	type ApiStreamChunk,
+	type HandlerModelInfo,
+	type Message,
+	normalizeProviderId,
+	type ProviderConfig,
+	resolveRoutingProviderId,
+	type ToolDefinition,
+} from "./types";
+
+const BUILTIN_PROVIDER_MAP = new Map(
+	BUILTIN_PROVIDER_REGISTRATIONS.map((registration) => [
+		registration.manifest.id,
+		registration,
+	]),
+);
+
+function toGatewayCapabilities(
+	capabilities: readonly string[] | undefined,
+): GatewayModelDefinition["capabilities"] {
+	if (!capabilities?.length) {
+		return undefined;
+	}
+
+	const mapped = new Set<
+		NonNullable<GatewayModelDefinition["capabilities"]>[number]
+	>();
+	for (const capability of capabilities) {
+		switch (capability) {
+			case "tools":
+			case "reasoning":
+			case "prompt-cache":
+			case "images":
+			case "audio":
+				mapped.add(capability);
+				break;
+			case "files":
+			case "streaming":
+			case "temperature":
+			case "reasoning-effort":
+			case "computer-use":
+			case "global-endpoint":
+				mapped.add("text");
+				break;
+			case "structured_output":
+				mapped.add("structured-output");
+				break;
+			default:
+				mapped.add("text");
+		}
+	}
+
+	mapped.add("text");
+	return [...mapped];
+}
+
+function toGatewayModelDefinition(
+	providerId: string,
+	model: ModelInfo,
+): GatewayModelDefinition {
+	return {
+		id: model.id,
+		name: model.name ?? model.id,
+		description: model.description,
+		providerId,
+		contextWindow: model.contextWindow,
+		maxInputTokens: model.maxInputTokens,
+		maxOutputTokens: model.maxTokens,
+		capabilities: toGatewayCapabilities(model.capabilities),
+		metadata: {
+			family: model.family,
+			pricing: model.pricing,
+			status: model.status,
+			releaseDate: model.releaseDate,
+		},
+	};
+}
+
+function resolveFactory(
+	providerId: string,
+	transport?: {
+		client?: ProviderClient;
+		protocol?: ProviderProtocol;
+	},
+): GatewayProviderFactory {
+	if (
+		transport?.client === "openai" ||
+		transport?.protocol === "openai-responses"
+	) {
+		return createOpenAIProvider;
+	}
+	switch (transport?.client) {
+		case "anthropic":
+			return createAnthropicProvider;
+		case "gemini":
+			return createGoogleProvider;
+		case "vertex":
+			return createVertexProvider;
+		case "bedrock":
+			return createBedrockProvider;
+		case "openai-compatible":
+			return createOpenAICompatibleProvider;
+	}
+
+	const normalized = normalizeProviderId(providerId);
+	switch (normalized) {
+		case "openai-codex":
+		case "openai-native":
+			return createOpenAIProvider;
+		case "anthropic":
+		case "minimax":
+			return createAnthropicProvider;
+		case "gemini":
+			return createGoogleProvider;
+		case "vertex":
+			return createVertexProvider;
+		case "bedrock":
+			return createBedrockProvider;
+		case "mistral":
+			return createMistralProvider;
+		case "claude-code":
+			return createClaudeCodeProvider;
+		case "openai-codex-cli":
+			return createOpenAICodexProvider;
+		case "opencode":
+			return createOpenCodeProvider;
+		case "dify":
+			return createDifyProvider;
+		case "sapaicore":
+			return createSapAiCoreProvider;
+		default:
+			return createOpenAICompatibleProvider;
+	}
+}
+
+async function resolveProviderRegistration(
+	config: ProviderConfig,
+): Promise<GatewayProviderRegistration | undefined> {
+	const providerId = normalizeProviderId(config.providerId);
+	const routedProviderId = normalizeProviderId(
+		resolveRoutingProviderId(config),
+	);
+	const builtin = BUILTIN_PROVIDER_MAP.get(providerId);
+	if (builtin && providerId === routedProviderId) {
+		return undefined;
+	}
+
+	const collection =
+		(await getProviderCollection(providerId)) ??
+		(providerId !== routedProviderId
+			? await getProviderCollection(routedProviderId)
+			: undefined);
+	if (!collection) {
+		const routedBuiltin = BUILTIN_PROVIDER_MAP.get(routedProviderId);
+		if (!routedBuiltin || providerId === routedProviderId) {
+			return undefined;
+		}
+		return {
+			manifest: {
+				...routedBuiltin.manifest,
+				id: providerId,
+				name: routedBuiltin.manifest.name,
+				models: routedBuiltin.manifest.models.map((model) => ({
+					...model,
+					providerId,
+				})),
+			},
+			defaults: routedBuiltin.defaults,
+			createProvider: routedBuiltin.createProvider,
+			loadProvider: routedBuiltin.loadProvider,
+		};
+	}
+
+	const routedBuiltin = BUILTIN_PROVIDER_MAP.get(routedProviderId);
+	return {
+		manifest: {
+			id: providerId,
+			name: collection.provider.name,
+			description: collection.provider.description,
+			defaultModelId: collection.provider.defaultModelId,
+			models: Object.values(collection.models).map((model) =>
+				toGatewayModelDefinition(providerId, model),
+			),
+			api: collection.provider.baseUrl,
+			apiKeyEnv: collection.provider.env,
+		},
+		defaults: {
+			...(routedBuiltin?.defaults ?? {}),
+			baseUrl: collection.provider.baseUrl ?? routedBuiltin?.defaults?.baseUrl,
+			apiKeyEnv: collection.provider.env ?? routedBuiltin?.defaults?.apiKeyEnv,
+		},
+		createProvider:
+			routedBuiltin?.createProvider ??
+			resolveFactory(routedProviderId, {
+				client: config.clientType ?? collection.provider.client,
+				protocol: collection.provider.protocol,
+			}),
+		loadProvider: routedBuiltin?.loadProvider,
+	};
+}
+
+function resolveProviderRegistrationSync(
+	config: ProviderConfig,
+): GatewayProviderRegistration | undefined {
+	const providerId = normalizeProviderId(config.providerId);
+	const routedProviderId = normalizeProviderId(
+		resolveRoutingProviderId(config),
+	);
+	const builtin = BUILTIN_PROVIDER_MAP.get(providerId);
+	if (builtin && providerId === routedProviderId) {
+		return undefined;
+	}
+
+	const collection =
+		getProviderCollectionSync(providerId) ??
+		(providerId !== routedProviderId
+			? getProviderCollectionSync(routedProviderId)
+			: undefined);
+	if (!collection) {
+		const routedBuiltin = BUILTIN_PROVIDER_MAP.get(routedProviderId);
+		if (!routedBuiltin || providerId === routedProviderId) {
+			return undefined;
+		}
+		return {
+			manifest: {
+				...routedBuiltin.manifest,
+				id: providerId,
+				models: routedBuiltin.manifest.models.map((model) => ({
+					...model,
+					providerId,
+				})),
+			},
+			defaults: routedBuiltin.defaults,
+			createProvider: routedBuiltin.createProvider,
+			loadProvider: routedBuiltin.loadProvider,
+		};
+	}
+
+	const routedBuiltin = BUILTIN_PROVIDER_MAP.get(routedProviderId);
+	return {
+		manifest: {
+			id: providerId,
+			name: collection.provider.name,
+			description: collection.provider.description,
+			defaultModelId: collection.provider.defaultModelId,
+			models: Object.values(collection.models).map((model) =>
+				toGatewayModelDefinition(providerId, model),
+			),
+			api: collection.provider.baseUrl,
+			apiKeyEnv: collection.provider.env,
+		},
+		defaults: {
+			...(routedBuiltin?.defaults ?? {}),
+			baseUrl: collection.provider.baseUrl ?? routedBuiltin?.defaults?.baseUrl,
+			apiKeyEnv: collection.provider.env ?? routedBuiltin?.defaults?.apiKeyEnv,
+		},
+		createProvider:
+			routedBuiltin?.createProvider ??
+			resolveFactory(routedProviderId, {
+				client: config.clientType ?? collection.provider.client,
+				protocol: collection.provider.protocol,
+			}),
+		loadProvider: routedBuiltin?.loadProvider,
+	};
+}
+
+export function toGatewayRequestMessages(
+	messages: Message[],
+): GatewayStreamRequest["messages"] {
+	const toolNames = new Map<string, string>();
+
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue;
+		}
+		for (const part of message.content) {
+			if (part.type === "tool_use") {
+				toolNames.set(part.id, part.name);
+				if (part.call_id) {
+					toolNames.set(part.call_id, part.name);
+				}
+			}
+		}
+	}
+
+	return messages.map((message) => {
+		const content =
+			typeof message.content === "string"
+				? [{ type: "text", text: message.content }]
+				: message.content.flatMap((part): Array<Record<string, unknown>> => {
+						switch (part.type) {
+							case "text":
+								return [{ type: "text", text: part.text }];
+							case "thinking":
+								return [
+									{
+										type: "reasoning" as const,
+										text: part.thinking,
+										metadata:
+											part.signature || part.call_id
+												? {
+														signature: part.signature,
+														callId: part.call_id,
+														details: part.details,
+													}
+												: undefined,
+									},
+								];
+							case "tool_use":
+								return [
+									{
+										type: "tool-call" as const,
+										toolCallId: part.call_id ?? part.id,
+										toolName: part.name,
+										input: part.input,
+										metadata: part.signature
+											? { thoughtSignature: part.signature }
+											: undefined,
+									},
+								];
+							case "tool_result":
+								// Pass the raw tool-result content through unchanged.
+								// `formatMessagesForAiSdk` -> `toAiSdkToolResultOutput`
+								// downstream walks any structured `output` (including the
+								// `[{query, result, success}]` `ToolOperationResult` shape
+								// produced by `read_files`) and pulls nested image blocks
+								// out as `image-data` content parts. We don't need (and
+								// must not) detach images into sibling user messages here:
+								// that produces a malformed message stream where image
+								// parts are not attached to the originating tool call.
+								return [
+									{
+										type: "tool-result" as const,
+										toolCallId: part.tool_use_id,
+										toolName: toolNames.get(part.tool_use_id) ?? "tool",
+										output: part.content,
+										isError: part.is_error ?? false,
+									},
+								];
+							case "image":
+								return [
+									{
+										type: "image" as const,
+										image: `data:${part.mediaType};base64,${part.data}`,
+										mediaType: part.mediaType,
+									},
+								];
+							case "file":
+								return [{ type: "text" as const, text: part.content }];
+							case "redacted_thinking":
+								return [];
+							default:
+								return [];
+						}
+					});
+
+		return {
+			id: nanoid(),
+			role: message.role,
+			content,
+			createdAt: Date.now(),
+		} as unknown as GatewayStreamRequest["messages"][number];
+	});
+}
+
+function toGatewayTools(
+	tools: ToolDefinition[] | undefined,
+): GatewayStreamRequest["tools"] {
+	return tools?.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+	}));
+}
+
+function buildGatewayRequest(
+	config: ProviderConfig,
+	systemPrompt: string,
+	messages: Message[],
+	tools?: ToolDefinition[],
+	signal?: AbortSignal,
+): GatewayStreamRequest {
+	return {
+		providerId: normalizeProviderId(config.providerId),
+		modelId: config.modelId,
+		systemPrompt,
+		messages: toGatewayRequestMessages(messages),
+		tools: toGatewayTools(tools),
+		maxTokens: config.maxOutputTokens,
+		reasoning:
+			config.thinking !== undefined ||
+			config.reasoningEffort ||
+			config.thinkingBudgetTokens !== undefined
+				? {
+						enabled: config.thinking,
+						effort:
+							config.reasoningEffort === "xhigh"
+								? "high"
+								: config.reasoningEffort === "low" ||
+										config.reasoningEffort === "medium" ||
+										config.reasoningEffort === "high"
+									? config.reasoningEffort
+									: undefined,
+						budgetTokens: config.thinkingBudgetTokens,
+					}
+				: undefined,
+		signal,
+	};
+}
+
+function buildGatewayConfig(config: ProviderConfig) {
+	const providerId = normalizeProviderId(config.providerId);
+	return {
+		providerId,
+		apiKey: config.apiKey ?? config.accessToken,
+		baseUrl: config.baseUrl,
+		headers: config.headers,
+		timeoutMs: config.timeoutMs,
+		fetch: config.fetch,
+		defaultModelId: config.modelId,
+		models: config.knownModels
+			? Object.values(config.knownModels).map((model) => {
+					const definition = toGatewayModelDefinition(providerId, model);
+					const { providerId: _providerId, ...definitionWithoutProviderId } =
+						definition;
+					return definitionWithoutProviderId;
+				})
+			: undefined,
+		options: {
+			region: config.region ?? config.gcp?.region,
+			project: config.gcp?.projectId,
+			projectId: config.gcp?.projectId,
+			location: config.region ?? config.gcp?.region,
+			accessKeyId: config.aws?.accessKey,
+			secretAccessKey: config.aws?.secretKey,
+			sessionToken: config.aws?.sessionToken,
+			authentication: config.aws?.authentication,
+			profile: config.aws?.profile,
+			endpoint: config.aws?.endpoint,
+			customModelBaseId: config.aws?.customModelBaseId,
+			apiVersion: config.azure?.apiVersion,
+			useIdentity: config.azure?.useIdentity,
+			mode: config.oca?.mode,
+			usePromptCache: config.aws?.usePromptCache ?? config.oca?.usePromptCache,
+			...config.codex,
+			...config.claudeCode,
+			...config.opencode,
+			...config.sap,
+		},
+	};
+}
+
+function toApiStreamChunk(id: string, event: AgentModelEvent): ApiStreamChunk {
+	switch (event.type) {
+		case "text-delta":
+			return { type: "text", id, text: event.text };
+		case "reasoning-delta": {
+			const metadata = event.metadata as Record<string, unknown> | undefined;
+			return {
+				type: "reasoning",
+				id,
+				reasoning: event.text,
+				signature:
+					typeof metadata?.thoughtSignature === "string"
+						? metadata.thoughtSignature
+						: typeof metadata?.signature === "string"
+							? metadata.signature
+							: undefined,
+				details: metadata?.details,
+			};
+		}
+		case "tool-call-delta": {
+			const metadata = event.metadata as Record<string, unknown> | undefined;
+			const args =
+				typeof event.inputText === "string" || event.input === undefined
+					? event.inputText
+					: (event.input as Record<string, unknown>);
+			return {
+				type: "tool_calls",
+				id,
+				signature:
+					typeof metadata?.thoughtSignature === "string"
+						? metadata.thoughtSignature
+						: undefined,
+				tool_call: {
+					call_id: event.toolCallId,
+					function: {
+						id: event.toolCallId,
+						name: event.toolName,
+						arguments: args,
+					},
+				},
+			};
+		}
+		case "usage":
+			return {
+				type: "usage",
+				id,
+				inputTokens: event.usage.inputTokens ?? 0,
+				outputTokens: event.usage.outputTokens ?? 0,
+				cacheReadTokens: event.usage.cacheReadTokens,
+				cacheWriteTokens: event.usage.cacheWriteTokens,
+				thoughtsTokenCount: event.usage.reasoningTokenCount,
+				totalCost: event.usage.totalCost,
+			};
+		case "finish":
+			return {
+				type: "done",
+				id,
+				success: event.reason !== "error",
+				error: event.error,
+				incompleteReason:
+					event.reason === "max-tokens" ? "max_tokens" : undefined,
+			};
+	}
+}
+
+function resolveModelInfo(config: ProviderConfig): ModelInfo {
+	return (
+		config.modelInfo ??
+		(config.modelId ? config.knownModels?.[config.modelId] : undefined) ?? {
+			id: config.modelId,
+			name: config.modelId,
+			capabilities: ["streaming"],
+		}
+	);
+}
+
+class GatewayApiHandler implements ApiHandler {
+	private abortSignal: AbortSignal | undefined;
+
+	constructor(private readonly config: ProviderConfig) {
+		this.abortSignal = config.abortSignal;
+	}
+
+	getMessages(systemPrompt: string, messages: Message[]): unknown {
+		return buildGatewayRequest(
+			this.config,
+			systemPrompt,
+			messages,
+			undefined,
+			this.abortSignal,
+		);
+	}
+
+	createMessage(
+		systemPrompt: string,
+		messages: Message[],
+		tools?: ToolDefinition[],
+	): ApiStream {
+		const gateway = createGateway({
+			providerConfigs: [buildGatewayConfig(this.config)],
+			fetch: this.config.fetch,
+			logger: this.config.logger ?? this.config.extensionContext?.logger,
+			telemetry: this.config.extensionContext?.telemetry,
+		});
+		const registration = resolveProviderRegistrationSync(this.config);
+		if (registration) {
+			gateway.registerProvider(registration);
+		}
+
+		const request = buildGatewayRequest(
+			this.config,
+			systemPrompt,
+			messages,
+			tools,
+			this.abortSignal,
+		);
+		const id = `gw_${nanoid(10)}`;
+		const stream = (async function* () {
+			for await (const event of await gateway.stream(request)) {
+				yield toApiStreamChunk(id, event);
+			}
+		})() as ApiStream;
+		stream.id = id;
+		return stream;
+	}
+
+	getModel(): HandlerModelInfo {
+		return {
+			id: this.config.modelId,
+			info: resolveModelInfo(this.config),
+		};
+	}
+
+	abort(): void {
+		// Requests are cancelled via the configured AbortSignal.
+	}
+
+	setAbortSignal(signal: AbortSignal | undefined): void {
+		this.abortSignal = signal;
+	}
+}
+
+export function createGatewayApiHandler(config: ProviderConfig): ApiHandler {
+	return new GatewayApiHandler(config);
+}
+
+export async function createGatewayApiHandlerAsync(
+	config: ProviderConfig,
+): Promise<ApiHandler> {
+	const gateway = createGateway({
+		providerConfigs: [buildGatewayConfig(config)],
+		fetch: config.fetch,
+		logger: config.logger ?? config.extensionContext?.logger,
+		telemetry: config.extensionContext?.telemetry,
+	});
+	const registration = await resolveProviderRegistration(config);
+	if (registration) {
+		gateway.registerProvider(registration);
+	}
+	return new (class extends GatewayApiHandler {
+		override createMessage(
+			systemPrompt: string,
+			messages: Message[],
+			tools?: ToolDefinition[],
+		): ApiStream {
+			const request = buildGatewayRequest(
+				config,
+				systemPrompt,
+				messages,
+				tools,
+				config.abortSignal,
+			);
+			const id = `gw_${nanoid(10)}`;
+			const stream = (async function* () {
+				for await (const event of await gateway.stream(request)) {
+					yield toApiStreamChunk(id, event);
+				}
+			})() as ApiStream;
+			stream.id = id;
+			return stream;
+		}
+	})(config);
+}
diff --git a/sdk/packages/llms/src/providers/config.ts b/sdk/packages/llms/src/providers/config.ts
new file mode 100644
index 0000000..1bae77b
--- /dev/null
+++ b/sdk/packages/llms/src/providers/config.ts
@@ -0,0 +1,429 @@
+/**
+ * Provider Configuration Types
+ *
+ * Unified configuration interface for all providers.
+ * This replaces the per-provider config chaos with a single structure.
+ */
+
+import type { BasicLogger, ExtensionContext } from "@cline/shared";
+import type { ModelInfo, ProviderClient } from "../catalog/types";
+import {
+	BUILT_IN_PROVIDER,
+	BUILT_IN_PROVIDER_IDS,
+	type BuiltInProviderId,
+	isBuiltInProviderId,
+	normalizeProviderId,
+} from "./ids";
+
+// Re-export for convenience
+export {
+	BUILT_IN_PROVIDER,
+	BUILT_IN_PROVIDER_IDS,
+	type BuiltInProviderId,
+	isBuiltInProviderId,
+	normalizeProviderId,
+};
+
+/**
+ * All supported provider IDs (built-in + custom)
+ *
+ * Custom provider IDs can be registered via `registerHandler()` or `registerAsyncHandler()`.
+ * Any string is accepted to allow for custom handlers that extend BaseHandler.
+ */
+export type ProviderId = BuiltInProviderId | (string & {});
+
+/**
+ * Provider categories based on underlying SDK/protocol
+ */
+export type ProviderCategory =
+	| "anthropic" // Anthropic SDK
+	| "openai" // OpenAI SDK (native features)
+	| "openai-compat" // OpenAI-compatible APIs
+	| "openai-responses" // OpenAI-Responses APIs
+	| "gemini" // Google GenAI SDK
+	| "bedrock" // AWS Bedrock SDK
+	| "custom"; // Custom implementations
+
+// =============================================================================
+// Provider Capabilities
+// =============================================================================
+
+/**
+ * Capabilities that a provider/model may support
+ */
+export type ProviderCapability =
+	| "reasoning" // Extended thinking/reasoning
+	| "prompt-cache" // Prompt caching
+	| "streaming" // Streaming responses
+	| "tools" // Tool/function calling
+	| "vision" // Image inputs
+	| "computer-use" // Computer use tools
+	| "oauth"; // OAuth authentication flow
+
+// =============================================================================
+// Configuration Components
+// =============================================================================
+
+/**
+ * Authentication configuration
+ */
+export interface AuthConfig {
+	/** API key (most common) */
+	apiKey?: string;
+	/** OAuth access token */
+	accessToken?: string;
+	/** Refresh token for OAuth */
+	refreshToken?: string;
+	/** Account ID (for account-based auth) */
+	accountId?: string;
+	/** OAuth callback path (e.g., for Qwen Code) */
+	oauthPath?: string;
+}
+
+/**
+ * Endpoint configuration
+ */
+export interface EndpointConfig {
+	/** Base URL for the API */
+	baseUrl?: string;
+	/** Custom headers to include */
+	headers?: Record<string, string>;
+	/** Request timeout in milliseconds */
+	timeoutMs?: number;
+	/**
+	 * Custom `fetch` implementation used by the AI gateway providers when
+	 * issuing requests. When supplied, it is forwarded to
+	 * `GatewayProviderSettings.fetch` (and as a top-level fallback on
+	 * `GatewayConfig.fetch`) so hosts can inject custom HTTP behavior such
+	 * as proxies, retries, tracing, or test doubles.
+	 */
+	fetch?: typeof fetch;
+}
+
+/**
+ * Model configuration
+ */
+export interface ModelConfig {
+	/** Model identifier */
+	modelId: string;
+	/** Pre-fetched model info (optional - will use defaults if not provided) */
+	modelInfo?: ModelInfo;
+	/** Known models for this provider with their info */
+	knownModels?: Record<string, ModelInfo>;
+}
+
+/**
+ * Token limits configuration
+ */
+export interface TokenConfig {
+	/** Maximum input tokens (overrides model default) */
+	maxInputTokens?: number;
+	/** Maximum output tokens (overrides model default) */
+	maxOutputTokens?: number;
+}
+
+/**
+ * Reasoning/thinking model configuration
+ */
+export interface ReasoningConfig {
+	/** Reasoning effort level */
+	reasoningEffort?: "low" | "medium" | "high" | "xhigh";
+	/** Extended thinking budget in tokens */
+	thinkingBudgetTokens?: number;
+	/** Enable thinking with provider/model defaults when supported */
+	thinking?: boolean;
+}
+
+/**
+ * Region configuration (shared across cloud providers)
+ */
+export interface RegionConfig {
+	/** Cloud region (AWS, GCP, Azure, or provider-specific like Qwen's china/international) */
+	region?: string;
+	/** API line for region-specific routing (e.g., "china" | "international" for Qwen) */
+	apiLine?: "china" | "international";
+	/** Use cross-region inference (Bedrock) */
+	useCrossRegionInference?: boolean;
+	/** Use global inference (Bedrock) */
+	useGlobalInference?: boolean;
+}
+
+/**
+ * AWS-specific configuration (for Bedrock)
+ */
+export interface AwsConfig {
+	accessKey?: string;
+	secretKey?: string;
+	sessionToken?: string;
+	authentication?: "iam" | "api-key" | "apikey" | "profile";
+	profile?: string;
+	usePromptCache?: boolean;
+	endpoint?: string;
+	customModelBaseId?: string;
+}
+
+/**
+ * Google Cloud configuration (for Vertex AI)
+ */
+export interface GcpConfig {
+	projectId?: string;
+	region?: string;
+}
+
+/**
+ * Azure configuration (for Azure OpenAI)
+ */
+export interface AzureConfig {
+	apiVersion?: string;
+	useIdentity?: boolean;
+}
+
+/**
+ * SAP AI Core configuration
+ */
+export interface SapConfig {
+	clientId?: string;
+	clientSecret?: string;
+	tokenUrl?: string;
+	resourceGroup?: string;
+	deploymentId?: string;
+	useOrchestrationMode?: boolean;
+	api?: "orchestration" | "foundation-models";
+	defaultSettings?: Record<string, unknown>;
+}
+
+/**
+ * OCA (Oracle Cloud AI) configuration
+ */
+export interface OcaConfig {
+	mode?: "internal" | "external";
+	usePromptCache?: boolean;
+}
+
+/**
+ * Codex CLI provider options
+ */
+export interface CodexConfig {
+	defaultSettings?: Record<string, unknown>;
+	modelSettings?: Record<string, unknown>;
+}
+
+/**
+ * Claude Code provider options
+ */
+export interface ClaudeCodeConfig {
+	[key: string]: unknown;
+}
+
+/**
+ * OpenCode provider options
+ */
+export interface OpenCodeConfig {
+	hostname?: string;
+	port?: number;
+	autoStartServer?: boolean;
+	serverTimeout?: number;
+	defaultSettings?: Record<string, unknown>;
+	modelSettings?: Record<string, unknown>;
+}
+
+/**
+ * Cloud provider configurations (grouped)
+ */
+export interface CloudConfig {
+	/** AWS/Bedrock options */
+	aws?: AwsConfig;
+	/** Google Cloud/Vertex options */
+	gcp?: GcpConfig;
+	/** Azure options */
+	azure?: AzureConfig;
+	/** SAP AI Core options */
+	sap?: SapConfig;
+	/** OCA options */
+	oca?: OcaConfig;
+}
+
+/**
+ * Provider-specific options that don't fit other categories
+ */
+export interface ProviderOptions {
+	/** OpenRouter provider sorting preference */
+	openRouterProviderSorting?: string;
+	/** Runtime model catalog refresh configuration */
+	modelCatalog?: ModelCatalogConfig;
+}
+
+/**
+ * Runtime model catalog refresh options
+ */
+export interface ModelCatalogConfig {
+	/** Fetch latest catalog at handler initialization */
+	loadLatestOnInit?: boolean;
+	/** Fetch provider-private models when auth is available */
+	loadPrivateOnAuth?: boolean;
+	/** Catalog endpoint URL */
+	url?: string;
+	/** Cache TTL for live catalog in milliseconds */
+	cacheTtlMs?: number;
+	/** Throw when live catalog refresh fails */
+	failOnError?: boolean;
+}
+
+// =============================================================================
+// Main Configuration Interface
+// =============================================================================
+
+/**
+ * Unified provider configuration interface
+ *
+ * This is the single configuration interface that clients provide.
+ * All provider-specific options are grouped into logical sub-interfaces.
+ */
+export interface ProviderConfig
+	extends AuthConfig,
+		EndpointConfig,
+		ModelConfig,
+		TokenConfig,
+		ReasoningConfig,
+		RegionConfig,
+		CloudConfig,
+		ProviderOptions {
+	/** Client type - determines which handler to use - OpenAI-Compatible deafult */
+	clientType?: ProviderClient;
+
+	/** Provider ID */
+	providerId: ProviderId;
+
+	/**
+	 * Optional built-in provider family to use for handler routing.
+	 *
+	 * This lets clients expose a custom provider ID and model catalog while
+	 * reusing the runtime behavior of a built-in provider implementation.
+	 */
+	routingProviderId?: ProviderId;
+
+	/** Capabilities this provider/model supports */
+	capabilities?: ProviderCapability[];
+
+	/** Task/session ID for telemetry */
+	taskId?: string;
+
+	/** Retry callback */
+	onRetryAttempt?: (
+		attempt: number,
+		maxRetries: number,
+		delay: number,
+		error: unknown,
+	) => void;
+
+	/** AbortSignal for cancelling requests */
+	abortSignal?: AbortSignal;
+
+	/** Optional runtime logger for provider-level diagnostics */
+	logger?: BasicLogger;
+
+	/**
+	 * Ambient runtime context: user identity, client surface, workspace info,
+	 * logger, and telemetry service. Prefer reading logger and telemetry from
+	 * here when available; the top-level logger field is kept for compatibility.
+	 */
+	extensionContext?: ExtensionContext;
+
+	/** Codex CLI-specific options */
+	codex?: CodexConfig;
+
+	/** Claude Code-specific options */
+	claudeCode?: ClaudeCodeConfig;
+
+	/** OpenCode-specific options */
+	opencode?: OpenCodeConfig;
+}
+
+/**
+ * Simplified configuration for common use cases
+ */
+export interface SimpleProviderConfig {
+	providerId: ProviderId;
+	clientType: ProviderClient;
+	apiKey: string;
+	modelId: string;
+	baseUrl?: string;
+}
+
+/**
+ * Create a full ProviderConfig from a simple config
+ */
+export function createConfig(simple: SimpleProviderConfig): ProviderConfig {
+	return {
+		providerId: simple.providerId,
+		clientType: simple.clientType,
+		apiKey: simple.apiKey,
+		modelId: simple.modelId,
+		baseUrl: simple.baseUrl,
+	};
+}
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+/**
+ * Check if a provider config has a specific capability
+ */
+export function hasCapability(
+	config: ProviderConfig,
+	capability: ProviderCapability,
+): boolean {
+	return config.capabilities?.includes(capability) ?? false;
+}
+
+/**
+ * Check if provider supports reasoning/thinking
+ */
+export function supportsReasoning(config: ProviderConfig): boolean {
+	return hasCapability(config, "reasoning");
+}
+
+/**
+ * Check if provider supports prompt caching
+ */
+export function supportsPromptCache(config: ProviderConfig): boolean {
+	return hasCapability(config, "prompt-cache");
+}
+
+/**
+ * Resolve the provider ID used for handler selection and built-in behavior.
+ */
+export function resolveRoutingProviderId(
+	config: Pick<ProviderConfig, "providerId" | "routingProviderId">,
+): string {
+	return normalizeProviderId(config.routingProviderId ?? config.providerId);
+}
+
+// =============================================================================
+// Deprecated Types (for backwards compatibility)
+// =============================================================================
+
+/**
+ * @deprecated Use ProviderConfig directly - all fields are now unified
+ */
+export type ProviderSpecificConfig = Pick<
+	ProviderConfig,
+	| "aws"
+	| "gcp"
+	| "azure"
+	| "sap"
+	| "oca"
+	| "maxInputTokens"
+	| "apiLine"
+	| "oauthPath"
+	| "openRouterProviderSorting"
+>;
+
+/**
+ * @deprecated Use ProviderConfig directly
+ */
+export type ProviderDefaultsConfig = Pick<
+	ProviderConfig,
+	"baseUrl" | "modelId" | "knownModels" | "headers" | "capabilities"
+>;
diff --git a/sdk/packages/llms/src/providers/errors.test.ts b/sdk/packages/llms/src/providers/errors.test.ts
new file mode 100644
index 0000000..ca34115
--- /dev/null
+++ b/sdk/packages/llms/src/providers/errors.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { isClinePassLimitMessage } from "../index.browser";
+import { extractClinePassLimitMessage } from "./errors";
+
+describe("isClinePassLimitMessage", () => {
+	it("matches the ClinePass weekly limit message", () => {
+		const message =
+			"You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later.";
+		expect(isClinePassLimitMessage(message)).toBe(true);
+	});
+
+	it("matches the 5-hour ClinePass limit message", () => {
+		const message =
+			"You have reached your 5-hour Clinepass limit. The limit resets in 5h, please try again later.";
+		expect(isClinePassLimitMessage(message)).toBe(true);
+	});
+
+	it("handles tab-heavy non-matches without regex backtracking", () => {
+		expect(
+			isClinePassLimitMessage(`You have reached your\t${"\t".repeat(10_000)}`),
+		).toBe(false);
+		expect(
+			isClinePassLimitMessage(`You have reached your\t-${"\t".repeat(10_000)}`),
+		).toBe(false);
+		expect(
+			isClinePassLimitMessage(
+				`You have reached your\t-\tClinepass limit.The limit resets in\t${"\t".repeat(10_000)}`,
+			),
+		).toBe(false);
+	});
+});
+
+describe("extractClinePassLimitMessage", () => {
+	it("extracts the ClinePass weekly limit message", () => {
+		const message =
+			"You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later.";
+
+		const extracted = extractClinePassLimitMessage(`Error: ${message}`);
+		expect(extracted).toBe(message);
+	});
+
+	it("extracts the 5-hour ClinePass limit message", () => {
+		const message =
+			"You have reached your 5-hour Clinepass limit. The limit resets in 5h, please try again later.";
+
+		const extracted = extractClinePassLimitMessage(`Error: ${message}`);
+		expect(extracted).toBe(message);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/errors.ts b/sdk/packages/llms/src/providers/errors.ts
new file mode 100644
index 0000000..78c15c8
--- /dev/null
+++ b/sdk/packages/llms/src/providers/errors.ts
@@ -0,0 +1,122 @@
+import { getClineEnvironmentConfig } from "@cline/shared";
+
+export const CLINE_NOT_SUBSCRIBED_RESPONSE_MESSAGE =
+	"the user is not subscribed to required model plan";
+const CLINE_NOT_SUBSCRIBED_FORMATTED_MESSAGE_PREFIX =
+	"no access to clinepass subscription models yet. subscribe to clinepass";
+export const CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_RESPONSE_MESSAGE =
+	"organization accounts cannot use individual model inference subscriptions";
+
+const CLINE_PASS_LIMIT_PREFIX = "you have reached your";
+const CLINE_PASS_LIMIT_MARKER = "clinepass limit";
+const CLINE_PASS_LIMIT_SUFFIX = "please try again later.";
+
+function findClinePassLimitMessageBounds(
+	text: string,
+): { start: number; end: number } | undefined {
+	const normalized = text.toLowerCase();
+	const start = normalized.indexOf(CLINE_PASS_LIMIT_PREFIX);
+	if (start === -1) {
+		return undefined;
+	}
+
+	const suffixStart = normalized.indexOf(CLINE_PASS_LIMIT_SUFFIX, start);
+	if (suffixStart === -1) {
+		return undefined;
+	}
+
+	const end = suffixStart + CLINE_PASS_LIMIT_SUFFIX.length;
+	if (!normalized.slice(start, end).includes(CLINE_PASS_LIMIT_MARKER)) {
+		return undefined;
+	}
+
+	return { start, end };
+}
+
+export function getClinePassSubscriptionUrl(): string {
+	return `${new URL(
+		"/dashboard/subscription?personal=true",
+		getClineEnvironmentConfig().appBaseUrl,
+	).toString()}`;
+}
+
+export function getClineNotSubscribedMessage(): string {
+	return `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getClinePassSubscriptionUrl()}`;
+}
+
+export class ClineNotSubscribedError extends Error {
+	public readonly providerId?: string;
+
+	constructor(providerId?: string) {
+		super(getClineNotSubscribedMessage());
+		this.name = "ClineNotSubscribedError";
+		this.providerId = providerId;
+	}
+}
+
+export function getClineOrgIndividualInferenceSubscriptionMessage(): string {
+	return "Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass";
+}
+
+export class ClineOrgIndividualInferenceSubscriptionError extends Error {
+	public readonly providerId?: string;
+
+	constructor(providerId?: string) {
+		super(getClineOrgIndividualInferenceSubscriptionMessage());
+		this.name = "ClineOrgIndividualInferenceSubscriptionError";
+		this.providerId = providerId;
+	}
+}
+
+export class ClinePassLimitError extends Error {
+	public readonly providerId?: string;
+
+	constructor(message: string, providerId?: string) {
+		super(message);
+		this.name = "ClinePassLimitError";
+		this.providerId = providerId;
+	}
+}
+
+export function isClineNotSubscribedError(
+	error: unknown,
+): error is ClineNotSubscribedError {
+	return error instanceof ClineNotSubscribedError;
+}
+
+export function isClineOrgIndividualInferenceSubscriptionError(
+	error: unknown,
+): error is ClineOrgIndividualInferenceSubscriptionError {
+	return error instanceof ClineOrgIndividualInferenceSubscriptionError;
+}
+
+export function isClinePassLimitError(
+	error: unknown,
+): error is ClinePassLimitError {
+	return error instanceof ClinePassLimitError;
+}
+
+export function isClineNotSubscribedMessage(text: string): boolean {
+	const normalized = text.trim().toLowerCase();
+	return (
+		normalized.includes(CLINE_NOT_SUBSCRIBED_RESPONSE_MESSAGE) ||
+		normalized.includes(CLINE_NOT_SUBSCRIBED_FORMATTED_MESSAGE_PREFIX)
+	);
+}
+
+export function isClineOrgIndividualInferenceSubscriptionMessage(
+	text: string,
+): boolean {
+	return text
+		.toLowerCase()
+		.includes(CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_RESPONSE_MESSAGE);
+}
+
+export function isClinePassLimitMessage(text: string): boolean {
+	return findClinePassLimitMessageBounds(text) !== undefined;
+}
+
+export function extractClinePassLimitMessage(text: string): string | undefined {
+	const bounds = findClinePassLimitMessageBounds(text);
+	return bounds ? text.slice(bounds.start, bounds.end) : undefined;
+}
diff --git a/sdk/packages/llms/src/providers/factory-registry.ts b/sdk/packages/llms/src/providers/factory-registry.ts
new file mode 100644
index 0000000..bfd7b04
--- /dev/null
+++ b/sdk/packages/llms/src/providers/factory-registry.ts
@@ -0,0 +1,161 @@
+/**
+ * Custom Handler Registry
+ *
+ * Allows users to register their own custom handlers that extend BaseHandler.
+ * This is useful for providers that require dependencies not included in this package
+ * (e.g., VSCode LM handler that requires the vscode package).
+ *
+ * @example
+ * ```typescript
+ * import { registerHandler, BaseHandler, type ProviderConfig, type ApiStream, type Message } from "@cline/providers"
+ * import * as vscode from "vscode"
+ *
+ * class VSCodeLmHandler extends BaseHandler {
+ *   async *createMessage(systemPrompt: string, messages: Message[]): ApiStream {
+ *     // Implementation using vscode.lm API
+ *   }
+ * }
+ *
+ * // Register the handler
+ * registerHandler("vscode-lm", (config) => new VSCodeLmHandler(config))
+ *
+ * // Now createHandler will use your custom handler for "vscode-lm"
+ * const handler = createHandler({ providerId: "vscode-lm", modelId: "copilot" })
+ * ```
+ */
+
+import type {
+	ApiHandler,
+	HandlerFactory,
+	LazyHandlerFactory,
+	ProviderConfig,
+} from "./types";
+
+/**
+ * Registry entry that can be either sync or async factory
+ */
+type RegistryEntry = {
+	factory: HandlerFactory<ProviderConfig> | LazyHandlerFactory<ProviderConfig>;
+	isAsync: boolean;
+};
+
+/**
+ * Internal registry of custom handlers
+ */
+const customHandlerRegistry = new Map<string, RegistryEntry>();
+
+/**
+ * Register a custom handler factory for a provider ID
+ *
+ * Use this to add handlers for providers that require external dependencies
+ * not bundled with this package, or to override built-in handlers.
+ *
+ * @param providerId - The provider ID to register (can be existing or new)
+ * @param factory - Factory function that creates the handler
+ *
+ * @example
+ * ```typescript
+ * // Simple registration
+ * registerHandler("my-provider", (config) => new MyHandler(config))
+ *
+ * // Override built-in handler
+ * registerHandler("anthropic", (config) => new MyCustomAnthropicHandler(config))
+ * ```
+ */
+export function registerHandler(
+	providerId: string,
+	factory: HandlerFactory<ProviderConfig>,
+): void {
+	customHandlerRegistry.set(providerId, { factory, isAsync: false });
+}
+
+/**
+ * Register an async handler factory for lazy loading
+ *
+ * Use this when your handler has heavy dependencies that should be
+ * loaded only when needed.
+ *
+ * @param providerId - The provider ID to register
+ * @param factory - Async factory function that creates the handler
+ *
+ * @example
+ * ```typescript
+ * registerAsyncHandler("heavy-provider", async (config) => {
+ *   const { HeavyHandler } = await import("./heavy-handler")
+ *   return new HeavyHandler(config)
+ * })
+ * ```
+ */
+export function registerAsyncHandler(
+	providerId: string,
+	factory: LazyHandlerFactory<ProviderConfig>,
+): void {
+	customHandlerRegistry.set(providerId, { factory, isAsync: true });
+}
+
+/**
+ * Check if a custom handler is registered for a provider ID
+ *
+ * @param providerId - The provider ID to check
+ */
+export function hasRegisteredHandler(providerId: string): boolean {
+	return customHandlerRegistry.has(providerId);
+}
+
+/**
+ * Get a registered handler (internal use)
+ *
+ * @param providerId - The provider ID to get
+ * @param config - The config to pass to the factory
+ * @returns The handler instance, or undefined if not registered
+ */
+export function getRegisteredHandler(
+	providerId: string,
+	config: ProviderConfig,
+): ApiHandler | undefined {
+	const entry = customHandlerRegistry.get(providerId);
+	if (!entry) {
+		return undefined;
+	}
+
+	if (entry.isAsync) {
+		throw new Error(
+			`Handler for "${providerId}" is registered as async. Use getRegisteredHandlerAsync() or createHandlerAsync() instead.`,
+		);
+	}
+
+	return (entry.factory as HandlerFactory<ProviderConfig>)(config);
+}
+
+/**
+ * Get a registered handler asynchronously (internal use)
+ *
+ * @param providerId - The provider ID to get
+ * @param config - The config to pass to the factory
+ * @returns The handler instance, or undefined if not registered
+ */
+export async function getRegisteredHandlerAsync(
+	providerId: string,
+	config: ProviderConfig,
+): Promise<ApiHandler | undefined> {
+	const entry = customHandlerRegistry.get(providerId);
+	if (!entry) {
+		return undefined;
+	}
+
+	if (entry.isAsync) {
+		return (entry.factory as LazyHandlerFactory<ProviderConfig>)(config);
+	}
+
+	return (entry.factory as HandlerFactory<ProviderConfig>)(config);
+}
+
+/**
+ * Check if a registered handler is async
+ *
+ * @param providerId - The provider ID to check
+ */
+export function isRegisteredHandlerAsync(providerId: string): boolean {
+	const entry = customHandlerRegistry.get(providerId);
+	return entry?.isAsync ?? false;
+}
diff --git a/sdk/packages/llms/src/providers/format.test.ts b/sdk/packages/llms/src/providers/format.test.ts
new file mode 100644
index 0000000..49be40f
--- /dev/null
+++ b/sdk/packages/llms/src/providers/format.test.ts
@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+import {
+	ClineNotSubscribedError,
+	ClineOrgIndividualInferenceSubscriptionError,
+	ClinePassLimitError,
+	getClineNotSubscribedMessage,
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	isClineNotSubscribedMessage,
+	isClineOrgIndividualInferenceSubscriptionMessage,
+	isClinePassLimitMessage,
+} from "./errors";
+import { extractErrorMessage } from "./format";
+
+describe("extractErrorMessage", () => {
+	it("extracts structured provider errors without fallback branches", () => {
+		expect(
+			extractErrorMessage({
+				statusCode: 400,
+				responseBody: {
+					error: {
+						message: "Bad request detail",
+					},
+				},
+				message: "Bad Request",
+			}),
+		).toBe("Bad request detail");
+
+		expect(
+			extractErrorMessage({
+				cause: new Error("Nested failure"),
+			}),
+		).toBe("Nested failure");
+
+		expect(extractErrorMessage(new Error("Plain failure"))).toBe(
+			"Plain failure",
+		);
+	});
+
+	it("preserves native transport error wrappers and cause metadata", () => {
+		const socketError = Object.assign(new Error("other side closed"), {
+			name: "SocketError",
+			code: "UND_ERR_SOCKET",
+		});
+
+		expect(
+			extractErrorMessage(
+				new TypeError("fetch failed", { cause: socketError }),
+			),
+		).toBe("fetch failed: SocketError: other side closed (UND_ERR_SOCKET)");
+	});
+
+	it("prefers nested stream error details over generic wrapper messages", () => {
+		expect(
+			extractErrorMessage({
+				message: "Stream error occurred",
+				errors: [
+					{
+						responseBody: JSON.stringify({
+							error: { message: "Missing upstream API key" },
+						}),
+					},
+				],
+			}),
+		).toBe("Missing upstream API key");
+	});
+});
+
+describe("ClineNotSubscribedError", () => {
+	it("uses the user-facing subscription message", () => {
+		expect(new ClineNotSubscribedError("cline-pass").message).toBe(
+			getClineNotSubscribedMessage(),
+		);
+	});
+
+	it("detects the ClinePass required-plan message", () => {
+		expect(
+			isClineNotSubscribedMessage(
+				JSON.stringify({
+					error: {
+						message: "the user is not subscribed to required model plan",
+					},
+				}),
+			),
+		).toBe(true);
+		expect(isClineNotSubscribedMessage("different forbidden error")).toBe(
+			false,
+		);
+	});
+
+	it("detects the formatted ClinePass subscription message regardless of URL", () => {
+		expect(
+			isClineNotSubscribedMessage(
+				"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://staging-app.cline.bot/promo?code=CLI-8OFF&personal=true",
+			),
+		).toBe(true);
+	});
+});
+
+describe("ClineOrgIndividualInferenceSubscriptionError", () => {
+	it("uses the user-facing organization account message", () => {
+		expect(
+			new ClineOrgIndividualInferenceSubscriptionError("cline").message,
+		).toBe(getClineOrgIndividualInferenceSubscriptionMessage());
+	});
+
+	it("detects the organization individual-subscription entitlement message", () => {
+		expect(
+			isClineOrgIndividualInferenceSubscriptionMessage(
+				JSON.stringify({
+					error: {
+						code: "ENTITLEMENT_ERROR",
+						message:
+							"organization accounts cannot use individual model inference subscriptions",
+					},
+				}),
+			),
+		).toBe(true);
+		expect(
+			isClineOrgIndividualInferenceSubscriptionMessage(
+				"the user is not subscribed to required model plan",
+			),
+		).toBe(false);
+	});
+});
+
+describe("ClinePassLimitError", () => {
+	it("preserves the dynamic backend limit message", () => {
+		const message =
+			"You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later.";
+		expect(new ClinePassLimitError(message, "cline-pass").message).toBe(
+			message,
+		);
+	});
+
+	it("detects ClinePass period limit messages with variable period and reset", () => {
+		expect(
+			isClinePassLimitMessage(
+				"You have reached your weekly Clinepass limit. The limit resets in 7d, please try again later.",
+			),
+		).toBe(true);
+		expect(
+			isClinePassLimitMessage(
+				"You have reached your monthly Clinepass limit. The limit resets in 12h, please try again later.",
+			),
+		).toBe(true);
+		expect(
+			isClinePassLimitMessage(
+				`You have reached your\t-\tClinepass limit.The limit resets in\t${"\t".repeat(10_000)}`,
+			),
+		).toBe(false);
+		expect(
+			isClinePassLimitMessage(
+				"the user is not subscribed to required model plan",
+			),
+		).toBe(false);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/format.ts b/sdk/packages/llms/src/providers/format.ts
new file mode 100644
index 0000000..9ff4491
--- /dev/null
+++ b/sdk/packages/llms/src/providers/format.ts
@@ -0,0 +1,127 @@
+export function extractErrorMessage(error: unknown): string {
+	// Generic SDK wrappers carry no signal of their own — when present we prefer
+	// the underlying cause/detail (e.g. AI SDK's AI_NoOutputGeneratedError).
+	const GENERIC_WRAPPER_MESSAGES = new Set([
+		"no output generated. check the stream for errors.",
+	]);
+	const isGenericWrapperMessage = (message: string): boolean =>
+		GENERIC_WRAPPER_MESSAGES.has(message.trim().toLowerCase());
+
+	// Pulls a human-readable message out of structured provider fields
+	// (error/detail/errors/responseBody) without falling back to a top-level
+	// `message`. Shared by the Error and plain-object branches.
+	const extractStructuredDetail = (value: object): string | undefined => {
+		const payload = value as {
+			error?: { message?: string } | string;
+			errors?: unknown;
+			detail?: string;
+			responseBody?: unknown;
+		};
+		if (typeof payload.error === "string" && payload.error.trim()) {
+			return payload.error;
+		}
+		if (
+			payload.error &&
+			typeof payload.error === "object" &&
+			typeof payload.error.message === "string" &&
+			payload.error.message.trim()
+		) {
+			return payload.error.message;
+		}
+		if (typeof payload.detail === "string" && payload.detail.trim()) {
+			return payload.detail;
+		}
+		if (Array.isArray(payload.errors)) {
+			for (const nestedError of payload.errors) {
+				const nested = extractStructuredMessage(nestedError);
+				if (nested) {
+					return nested;
+				}
+			}
+		}
+		if ("responseBody" in payload && payload.responseBody !== value) {
+			const nested = extractStructuredMessage(payload.responseBody);
+			if (nested) {
+				return nested;
+			}
+		}
+		return undefined;
+	};
+
+	const extractStructuredMessage = (value: unknown): string | undefined => {
+		if (!value) {
+			return undefined;
+		}
+		if (typeof value === "string") {
+			try {
+				return extractStructuredMessage(JSON.parse(value));
+			} catch {
+				return value.trim() || undefined;
+			}
+		}
+		if (typeof value !== "object") {
+			return undefined;
+		}
+		if (value instanceof Error) {
+			const message = value.message.trim();
+			const detailMessage = extractStructuredDetail(value);
+			const cause = (value as { cause?: unknown }).cause;
+			const causeMessage = extractStructuredMessage(cause);
+
+			// Generic wrappers (e.g. "No output generated...") only matter as a
+			// fallback — surface the underlying detail/cause instead.
+			if (message && isGenericWrapperMessage(message)) {
+				return detailMessage ?? causeMessage ?? undefined;
+			}
+
+			// Structured provider detail attached directly to the error
+			// (responseBody/detail/error fields) is more useful than the bland
+			// top-level Error message.
+			if (detailMessage && detailMessage !== message) {
+				return detailMessage;
+			}
+
+			// Otherwise preserve the wrapper message alongside its cause, e.g.
+			// "fetch failed: SocketError: other side closed (UND_ERR_SOCKET)".
+			if (causeMessage && message && causeMessage !== message) {
+				const causeName =
+					cause instanceof Error && cause.name && cause.name !== "Error"
+						? `${cause.name}: `
+						: "";
+				const causeCode =
+					cause && typeof cause === "object" && "code" in cause
+						? (cause as { code?: unknown }).code
+						: undefined;
+				const codeSuffix =
+					typeof causeCode === "string" && causeCode.trim()
+						? ` (${causeCode})`
+						: "";
+				return `${message}: ${causeName}${causeMessage}${codeSuffix}`;
+			}
+			return causeMessage ?? (message || undefined);
+		}
+
+		const detail = extractStructuredDetail(value);
+		if (detail) {
+			return detail;
+		}
+		const payload = value as { cause?: unknown; message?: string };
+		if ("cause" in payload && payload.cause !== value) {
+			const nested = extractStructuredMessage(payload.cause);
+			if (nested) {
+				return nested;
+			}
+		}
+		if (typeof payload.message === "string" && payload.message.trim()) {
+			return payload.message;
+		}
+		return undefined;
+	};
+
+	const structuredMessage = extractStructuredMessage(error);
+	if (structuredMessage) {
+		return structuredMessage;
+	}
+
+	return String(error);
+}
diff --git a/sdk/packages/llms/src/providers/gateway.test.ts b/sdk/packages/llms/src/providers/gateway.test.ts
new file mode 100644
index 0000000..3f4bdea
--- /dev/null
+++ b/sdk/packages/llms/src/providers/gateway.test.ts
@@ -0,0 +1,4538 @@
+import {
+	mkdtempSync,
+	readdirSync,
+	readFileSync,
+	utimesSync,
+	writeFileSync,
+} from "node:fs";
+import { access } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AgentMessage, AgentModelEvent } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { normalizeModelsDevProviderModels } from "../catalog/catalog-live";
+import {
+	createGateway,
+	estimateRequestInputTokens,
+	resolveGatewayRequestMaxTokens,
+} from "./gateway";
+
+const streamTextSpy = vi.fn();
+const openaiCompatibleFactorySpy = vi.fn();
+const openaiCompatibleSpy = vi.fn((modelId: string) => ({
+	modelId,
+	family: "openai-compatible",
+}));
+const openaiResponsesSpy = vi.fn((modelId: string) => ({
+	modelId,
+	family: "openai",
+}));
+const anthropicSpy = vi.fn((modelId: string) => ({
+	modelId,
+	family: "anthropic",
+}));
+const googleSpy = vi.fn((modelId: string) => ({ modelId, family: "google" }));
+const codexExecFactorySpy = vi.fn();
+const codexExecSpy = vi.fn((modelId: string) => ({
+	modelId,
+	family: "openai-codex",
+}));
+
+function createFetchMock() {
+	const fetchMock = vi.fn(
+		async (
+			_input: Parameters<typeof fetch>[0],
+			_init?: Parameters<typeof fetch>[1],
+		) => new Response("ok"),
+	);
+	return {
+		fetchMock,
+		fetch: fetchMock as unknown as typeof fetch,
+	};
+}
+
+vi.mock("ai", () => ({
+	jsonSchema: (schema: unknown, options: unknown) => ({
+		jsonSchema: schema,
+		...(options && typeof options === "object" ? options : {}),
+	}),
+	streamText: (input: unknown) => streamTextSpy(input),
+	// `wrapLanguageModel` is used by the openai-compatible and mistral
+	// vendors to attach `splitToolImagesMiddleware`. The middleware itself
+	// is exercised by its own unit tests; here we just need an identity
+	// pass-through so the vendor factories' downstream `model:` callbacks
+	// keep returning the spy-produced mock objects unchanged. (The mock
+	// objects don't satisfy the real `LanguageModelV3` interface, so we
+	// can't call the real `wrapLanguageModel` either way.)
+	wrapLanguageModel: ({ model }: { model: unknown }) => model,
+}));
+
+vi.mock("@ai-sdk/openai", () => ({
+	createOpenAI: () => ({
+		responses: (modelId: string) => openaiResponsesSpy(modelId),
+	}),
+}));
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+	createOpenAICompatible: (config: unknown) => {
+		openaiCompatibleFactorySpy(config);
+		return (modelId: string) => openaiCompatibleSpy(modelId);
+	},
+}));
+
+vi.mock("@ai-sdk/anthropic", () => ({
+	createAnthropic: () => (modelId: string) => anthropicSpy(modelId),
+}));
+
+vi.mock("@ai-sdk/google", () => ({
+	createGoogleGenerativeAI: () => (modelId: string) => googleSpy(modelId),
+}));
+
+vi.mock("ai-sdk-provider-codex-cli", () => ({
+	createCodexExec: (config: unknown) => {
+		codexExecFactorySpy(config);
+		return (modelId: string) => codexExecSpy(modelId);
+	},
+}));
+
+async function* makeStreamParts(parts: unknown[]) {
+	for (const part of parts) {
+		yield part;
+	}
+}
+
+async function* makeFailingStreamParts(error: unknown, parts: unknown[] = []) {
+	for (const part of parts) {
+		yield part;
+	}
+	throw error;
+}
+
+async function collect(
+	iterable: AsyncIterable<AgentModelEvent>,
+): Promise<AgentModelEvent[]> {
+	const events: AgentModelEvent[] = [];
+	for await (const event of iterable) {
+		events.push(event);
+	}
+	return events;
+}
+
+const baseMessages: AgentMessage[] = [
+	{
+		id: "user_1",
+		role: "user",
+		content: [{ type: "text", text: "Hello" }],
+		createdAt: Date.now(),
+	},
+];
+const originalOpenRouterApiKey = process.env.OPENROUTER_API_KEY;
+const originalCaptureProviderRequest =
+	process.env.CLINE_CAPTURE_PROVIDER_REQUEST;
+const originalCaptureWire = process.env.CLINE_CAPTURE_WIRE;
+const originalCaptureDir = process.env.CLINE_CAPTURE_DIR;
+const originalCaptureDataDir = process.env.CLINE_DATA_DIR;
+const originalCaptureMaxPreviewBytes =
+	process.env.CLINE_CAPTURE_MAX_PREVIEW_BYTES;
+const originalCaptureCleanup = process.env.CLINE_CAPTURE_CLEANUP;
+
+function readCaptureRecords(dir: string): Array<Record<string, unknown>> {
+	return readdirSync(dir)
+		.filter((file) => file.endsWith(".provider-request.json"))
+		.sort()
+		.map(
+			(file) =>
+				JSON.parse(readFileSync(join(dir, file), "utf8")) as Record<
+					string,
+					unknown
+				>,
+		);
+}
+
+describe("sdk-gateway", () => {
+	beforeEach(() => {
+		streamTextSpy.mockReset();
+		openaiCompatibleFactorySpy.mockReset();
+		openaiCompatibleSpy.mockReset();
+		openaiResponsesSpy.mockReset();
+		anthropicSpy.mockReset();
+		googleSpy.mockReset();
+		codexExecFactorySpy.mockReset();
+		codexExecSpy.mockReset();
+		googleSpy.mockImplementation((modelId: string) => ({
+			modelId,
+			family: "google",
+		}));
+		openaiCompatibleSpy.mockImplementation((modelId: string) => ({
+			modelId,
+			family: "openai-compatible",
+		}));
+		openaiResponsesSpy.mockImplementation((modelId: string) => ({
+			modelId,
+			family: "openai",
+		}));
+		anthropicSpy.mockImplementation((modelId: string) => ({
+			modelId,
+			family: "anthropic",
+		}));
+		codexExecSpy.mockImplementation((modelId: string) => ({
+			modelId,
+			family: "openai-codex",
+		}));
+		if (originalOpenRouterApiKey === undefined) {
+			delete process.env.OPENROUTER_API_KEY;
+		} else {
+			process.env.OPENROUTER_API_KEY = originalOpenRouterApiKey;
+		}
+		if (originalCaptureProviderRequest === undefined) {
+			delete process.env.CLINE_CAPTURE_PROVIDER_REQUEST;
+		} else {
+			process.env.CLINE_CAPTURE_PROVIDER_REQUEST =
+				originalCaptureProviderRequest;
+		}
+		if (originalCaptureWire === undefined) {
+			delete process.env.CLINE_CAPTURE_WIRE;
+		} else {
+			process.env.CLINE_CAPTURE_WIRE = originalCaptureWire;
+		}
+		if (originalCaptureDir === undefined) {
+			delete process.env.CLINE_CAPTURE_DIR;
+		} else {
+			process.env.CLINE_CAPTURE_DIR = originalCaptureDir;
+		}
+		if (originalCaptureDataDir === undefined) {
+			delete process.env.CLINE_DATA_DIR;
+		} else {
+			process.env.CLINE_DATA_DIR = originalCaptureDataDir;
+		}
+		if (originalCaptureMaxPreviewBytes === undefined) {
+			delete process.env.CLINE_CAPTURE_MAX_PREVIEW_BYTES;
+		} else {
+			process.env.CLINE_CAPTURE_MAX_PREVIEW_BYTES =
+				originalCaptureMaxPreviewBytes;
+		}
+		if (originalCaptureCleanup === undefined) {
+			delete process.env.CLINE_CAPTURE_CLEANUP;
+		} else {
+			process.env.CLINE_CAPTURE_CLEANUP = originalCaptureCleanup;
+		}
+	});
+
+	it("does not synthesize request max tokens from catalog metadata", () => {
+		expect(
+			resolveGatewayRequestMaxTokens({
+				requestedMaxTokens: undefined,
+				model: { maxOutputTokens: 202_800, contextWindow: 202_800 },
+				estimatedInputTokens: 1_000,
+			}),
+		).toBeUndefined();
+	});
+
+	it("resolves explicit request max tokens from model and context caps", () => {
+		expect(
+			resolveGatewayRequestMaxTokens({
+				requestedMaxTokens: 8_192,
+				model: { maxOutputTokens: 202_800, contextWindow: 202_800 },
+				estimatedInputTokens: 1_000,
+			}),
+		).toBe(8_192);
+
+		expect(
+			resolveGatewayRequestMaxTokens({
+				requestedMaxTokens: 202_800,
+				model: { maxOutputTokens: 202_800, contextWindow: 202_800 },
+				estimatedInputTokens: 201_500,
+				outputReserveTokens: 1_024,
+			}),
+		).toBe(276);
+
+		expect(
+			resolveGatewayRequestMaxTokens({
+				requestedMaxTokens: undefined,
+				model: {},
+				estimatedInputTokens: 1_000,
+			}),
+		).toBeUndefined();
+	});
+
+	it("does not collapse to one output token when estimated input exceeds context", () => {
+		const onContextOverflow = vi.fn();
+
+		expect(
+			resolveGatewayRequestMaxTokens({
+				requestedMaxTokens: 8_192,
+				model: { maxOutputTokens: 202_800, contextWindow: 10_000 },
+				estimatedInputTokens: 9_500,
+				outputReserveTokens: 1_024,
+				onContextOverflow,
+			}),
+		).toBeUndefined();
+		expect(onContextOverflow).toHaveBeenCalledWith({
+			contextWindow: 10_000,
+			estimatedInputTokens: 9_500,
+			reserveTokens: 1_024,
+		});
+	});
+
+	it("keeps estimating when request tools cannot be JSON stringified", () => {
+		const circularTool = {
+			name: "large_tool",
+			description: "x".repeat(12_000),
+		} as Record<string, unknown>;
+		circularTool.self = circularTool;
+
+		const estimatedTokens = estimateRequestInputTokens({
+			systemPrompt: "system",
+			messages: baseMessages,
+			tools: [circularTool] as never,
+		});
+
+		expect(estimatedTokens).toBeGreaterThan(4_000);
+	});
+
+	it("does not apply catalog output caps when the request omits max tokens", async () => {
+		const createProvider = vi.fn(() => ({
+			async *stream(request: { maxTokens?: number }) {
+				expect(request.maxTokens).toBeUndefined();
+				yield { type: "finish", reason: "stop" } satisfies AgentModelEvent;
+			},
+		}));
+
+		const gateway = createGateway({
+			builtins: false,
+			providers: [
+				{
+					manifest: {
+						id: "custom-provider",
+						name: "CustomProvider",
+						defaultModelId: "large-output",
+						models: [
+							{
+								id: "large-output",
+								name: "Large Output",
+								providerId: "custom-provider",
+								contextWindow: 202_800,
+								maxInputTokens: 202_800,
+								maxOutputTokens: 202_800,
+							},
+						],
+					},
+					createProvider,
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "custom-provider",
+				modelId: "large-output",
+				messages: baseMessages,
+			}),
+		);
+	});
+
+	it("keeps custom provider loading lazy until first use", async () => {
+		const createProvider = vi.fn(() => ({
+			async *stream() {
+				yield { type: "text-delta", text: "lazy" } satisfies AgentModelEvent;
+				yield { type: "finish", reason: "stop" } satisfies AgentModelEvent;
+			},
+		}));
+		const loadProvider = vi.fn(async () => ({ createProvider }));
+		const gateway = createGateway({
+			builtins: false,
+			providers: [
+				{
+					manifest: {
+						id: "custom",
+						name: "Custom",
+						defaultModelId: "alpha",
+						models: [{ id: "alpha", name: "Alpha", providerId: "custom" }],
+					},
+					loadProvider,
+				},
+			],
+		});
+
+		expect(loadProvider).not.toHaveBeenCalled();
+		const events = await collect(
+			await gateway.stream({
+				providerId: "custom",
+				modelId: "alpha",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(loadProvider).toHaveBeenCalledOnce();
+		expect(createProvider).toHaveBeenCalledOnce();
+		expect(events).toContainEqual({ type: "text-delta", text: "lazy" });
+	});
+
+	it("exposes old-provider-style builtins with generated manifests", () => {
+		const gateway = createGateway();
+		const providerIds = gateway.listProviders().map((provider) => provider.id);
+
+		expect(providerIds).toContain("openai-compatible");
+		expect(providerIds).toContain("openai-native");
+		expect(providerIds).toContain("anthropic");
+		expect(providerIds).toContain("gemini");
+		expect(providerIds).toContain("vertex");
+		expect(providerIds).toContain("bedrock");
+		expect(providerIds).toContain("openrouter");
+		expect(providerIds).toContain("aihubmix");
+		expect(providerIds).toContain("claude-code");
+		expect(providerIds).toContain("openai-codex");
+
+		const aihubmix = gateway
+			.listProviders()
+			.find((provider) => provider.id === "aihubmix");
+		expect(aihubmix?.metadata).toMatchObject({
+			routing: {
+				promptCache: {
+					format: "anthropic-cache-control",
+				},
+				reasoning: {
+					format: "anthropic-thinking",
+					routes: [
+						{
+							matcher: "anthropic-compatible",
+						},
+					],
+				},
+			},
+		});
+	});
+
+	it("keeps Anthropic cache-control routing on the expected provider set", () => {
+		const gateway = createGateway();
+		const strategyProviders = gateway
+			.listProviders()
+			.filter(
+				(provider) =>
+					provider.metadata?.routing?.promptCache?.format ===
+					"anthropic-cache-control",
+			)
+			.map((provider) => provider.id)
+			.sort();
+
+		expect(strategyProviders).toEqual([
+			"aihubmix",
+			"anthropic",
+			"bedrock",
+			"cline",
+			"cline-pass",
+			"minimax",
+			"oca",
+			"openrouter",
+			"qwen",
+			"qwen-code",
+			"sapaicore",
+			"vercel-ai-gateway",
+			"vertex",
+		]);
+	});
+
+	it("routes Qwen cache controls by model family instead of exact model ids", () => {
+		const gateway = createGateway();
+		const openrouter = gateway
+			.listProviders()
+			.find((provider) => provider.id === "openrouter");
+		expect(openrouter?.metadata?.stickySession).toEqual({
+			transport: "json-body",
+			field: "session_id",
+			metadataKey: "sessionId",
+		});
+		const promptCacheRoutes =
+			openrouter?.metadata?.routing?.promptCache?.routes ?? [];
+
+		expect(promptCacheRoutes).toEqual([
+			{ matcher: "anthropic-compatible" },
+			{
+				matcher: "model-family",
+				family: "qwen",
+				requiredCapability: "prompt-cache",
+			},
+		]);
+		expect(promptCacheRoutes).not.toContainEqual(
+			expect.objectContaining({ matcher: "model-id" }),
+		);
+
+		const openrouterQwen = gateway
+			.listModels("openrouter")
+			.find((model) => model.id === "qwen/qwen3.6-plus");
+		expect(openrouterQwen?.metadata?.family).toBe("qwen");
+		expect(openrouterQwen?.capabilities).toContain("prompt-cache");
+
+		const directQwen = gateway
+			.listModels("qwen")
+			.find((model) => model.id === "qwen-plus-latest");
+		expect(directQwen).toBeDefined();
+		expect(directQwen?.metadata?.family).toBe("qwen");
+		expect(directQwen?.capabilities).toContain("prompt-cache");
+
+		const directQwenCode = gateway
+			.listModels("qwen-code")
+			.find((model) => model.id === "qwen3-coder-plus");
+		expect(directQwenCode).toBeDefined();
+		expect(directQwenCode?.metadata?.family).toBe("qwen");
+		expect(directQwenCode?.capabilities).toContain("prompt-cache");
+	});
+
+	it("deep-merges provider config routing metadata overrides", () => {
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					metadata: {
+						routing: {
+							promptCache: {
+								format: "anthropic-cache-control",
+								routes: [{ matcher: "model-id", modelId: "custom/qwen" }],
+							},
+						},
+					},
+				},
+			],
+		});
+
+		const openrouter = gateway
+			.listProviders()
+			.find((provider) => provider.id === "openrouter");
+
+		expect(openrouter?.metadata?.routing).toMatchObject({
+			promptCache: {
+				format: "anthropic-cache-control",
+				routes: [{ matcher: "model-id", modelId: "custom/qwen" }],
+			},
+			reasoning: {
+				format: "anthropic-thinking",
+				routes: [{ matcher: "anthropic-compatible" }],
+			},
+		});
+	});
+
+	it("adapts OpenAI Responses streams through the native AI SDK provider", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "text-delta", textDelta: "Hello from OpenAI" },
+				{
+					type: "tool-call",
+					toolCallId: "call_1",
+					toolName: "lookup",
+					input: { term: "sdk" },
+				},
+				{
+					type: "finish",
+					finishReason: "tool-calls",
+					usage: { inputTokens: 10, outputTokens: 4, cachedInputTokens: 2 },
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-native",
+					apiKey: "test",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openai-native",
+				modelId: "gpt-5-mini",
+				messages: baseMessages,
+				tools: [
+					{
+						name: "lookup",
+						description: "Lookup a term",
+						inputSchema: { type: "object" },
+					},
+				],
+			}),
+		);
+
+		expect(openaiResponsesSpy).toHaveBeenCalledWith("gpt-5-mini");
+		expect(events).toContainEqual({
+			type: "text-delta",
+			text: "Hello from OpenAI",
+		});
+		expect(events).toContainEqual({
+			type: "tool-call-delta",
+			toolCallId: "call_1",
+			toolName: "lookup",
+			input: { term: "sdk" },
+			inputText: '{"term":"sdk"}',
+			metadata: {
+				toolSource: {
+					providerId: "openai-native",
+					modelId: "gpt-5-mini",
+					executionMode: "runtime",
+				},
+			},
+		});
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 10,
+				outputTokens: 4,
+				cacheReadTokens: 2,
+				cacheWriteTokens: 0,
+			}),
+		});
+		expect(events.at(-1)).toEqual({ type: "finish", reason: "tool-calls" });
+	});
+
+	it("surfaces nested AI SDK stream errors as human-readable finish messages", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeFailingStreamParts(
+				new Error("No output generated. Check the stream for errors.", {
+					cause: new Error("Invalid API key"),
+				}),
+			),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-native",
+					apiKey: "test",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openai-native",
+				modelId: "gpt-5-mini",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events.at(-1)).toEqual({
+			type: "finish",
+			reason: "error",
+			error: "Invalid API key",
+		});
+	});
+
+	it("does not wait for usage when an AI SDK stream emits an error part", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "error",
+					error: new Error("Invalid API key"),
+				},
+			]),
+			usage: new Promise(() => {}),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-native",
+					apiKey: "test",
+				},
+			],
+		});
+
+		const events = await Promise.race([
+			collect(
+				await gateway.stream({
+					providerId: "openai-native",
+					modelId: "gpt-5-mini",
+					messages: baseMessages,
+				}),
+			),
+			new Promise<never>((_, reject) =>
+				setTimeout(() => reject(new Error("timed out waiting for stream")), 50),
+			),
+		]);
+
+		expect(events).toEqual([
+			{
+				type: "finish",
+				reason: "error",
+				error: "Invalid API key",
+			},
+		]);
+	});
+
+	it("surfaces API detail fields from OpenAI-compatible error bodies", async () => {
+		const apiError = Object.assign(new Error("Bad Request"), {
+			statusCode: 400,
+			responseBody: JSON.stringify({
+				detail: "Instructions are required",
+			}),
+		});
+		streamTextSpy.mockReturnValue({
+			fullStream: makeFailingStreamParts(apiError),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-native",
+					apiKey: "test",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openai-native",
+				modelId: "gpt-5-mini",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events.at(-1)).toEqual({
+			type: "finish",
+			reason: "error",
+			error: "Instructions are required",
+		});
+	});
+
+	it("passes user file blocks through as text content", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-native",
+					apiKey: "test",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-native",
+				modelId: "gpt-5-mini",
+				messages: [
+					{
+						id: "user_1",
+						role: "user",
+						content: [
+							{ type: "text", text: "Check the file." },
+							{
+								type: "file",
+								path: "/workspace/AGENTS.md",
+								content: "rules go here",
+							},
+						],
+						createdAt: Date.now(),
+					},
+				],
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					{
+						role: "user",
+						content: [
+							{ type: "text", text: "Check the file." },
+							{
+								type: "text",
+								text: '<file_content path="/workspace/AGENTS.md">\nrules go here\n</file_content>',
+							},
+						],
+					},
+				],
+			}),
+		);
+	});
+
+	it("passes user image blocks through the openai-compatible ai-sdk path", async () => {
+		process.env.OPENROUTER_API_KEY = "env-openrouter-key";
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway();
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-haiku-4.5",
+				messages: [
+					{
+						id: "user_1",
+						role: "user",
+						content: [
+							{ type: "text", text: "whats in the pic" },
+							{
+								type: "image",
+								mediaType: "image/png",
+								image: "data:image/png;base64,aGVsbG8=",
+							},
+						],
+						createdAt: Date.now(),
+					},
+				],
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({
+								type: "text",
+								text: "whats in the pic",
+							}),
+							expect.objectContaining({
+								type: "image",
+								image: "data:image/png;base64,aGVsbG8=",
+								mediaType: "image/png",
+							}),
+						]),
+					}),
+				]),
+			}),
+		);
+	});
+
+	it("strips reasoning history before sending Cerebras follow-up requests", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cerebras",
+					apiKey: "cerebras-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "cerebras",
+				modelId: "zai-glm-4.7",
+				messages: [
+					baseMessages[0],
+					{
+						id: "assistant_1",
+						role: "assistant",
+						content: [
+							{ type: "reasoning", text: "internal thinking" },
+							{ type: "text", text: "Hello!" },
+						],
+						createdAt: Date.now(),
+					},
+					{
+						id: "user_2",
+						role: "user",
+						content: [{ type: "text", text: "tell me more" }],
+						createdAt: Date.now(),
+					},
+				],
+			}),
+		);
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { messages?: unknown }
+			| undefined;
+		expect(call?.messages).toEqual([
+			{ role: "user", content: [{ type: "text", text: "Hello" }] },
+			{ role: "assistant", content: [{ type: "text", text: "Hello!" }] },
+			{ role: "user", content: [{ type: "text", text: "tell me more" }] },
+		]);
+		expect(JSON.stringify(call?.messages)).not.toContain("reasoning");
+	});
+
+	it("omits Cerebras reasoning-only assistant history instead of sending empty assistant content", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cerebras",
+					apiKey: "cerebras-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "cerebras",
+				modelId: "zai-glm-4.7",
+				messages: [
+					baseMessages[0],
+					{
+						id: "assistant_1",
+						role: "assistant",
+						content: [{ type: "reasoning", text: "internal thinking" }],
+						createdAt: Date.now(),
+					},
+					{
+						id: "user_2",
+						role: "user",
+						content: [{ type: "text", text: "tell me more" }],
+						createdAt: Date.now(),
+					},
+				],
+			}),
+		);
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { messages?: unknown }
+			| undefined;
+		expect(call?.messages).toEqual([
+			{ role: "user", content: [{ type: "text", text: "Hello" }] },
+			{ role: "user", content: [{ type: "text", text: "tell me more" }] },
+		]);
+		expect(JSON.stringify(call?.messages)).not.toContain("reasoning");
+	});
+
+	it("strips reasoning history for Cerebras base URL aliases", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-compatible",
+					apiKey: "cerebras-key",
+					baseUrl: "https://api.cerebras.ai",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-compatible",
+				modelId: "zai-glm-4.7",
+				messages: [
+					baseMessages[0],
+					{
+						id: "assistant_1",
+						role: "assistant",
+						content: [
+							{ type: "reasoning", text: "internal thinking" },
+							{ type: "text", text: "Hello!" },
+						],
+						createdAt: Date.now(),
+					},
+					{
+						id: "user_2",
+						role: "user",
+						content: [{ type: "text", text: "tell me more" }],
+						createdAt: Date.now(),
+					},
+				],
+			}),
+		);
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { messages?: unknown }
+			| undefined;
+		expect(call?.messages).toEqual([
+			{ role: "user", content: [{ type: "text", text: "Hello" }] },
+			{ role: "assistant", content: [{ type: "text", text: "Hello!" }] },
+			{ role: "user", content: [{ type: "text", text: "tell me more" }] },
+		]);
+		expect(JSON.stringify(call?.messages)).not.toContain("reasoning");
+	});
+
+	it("reads Anthropic cache usage from provider metadata", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					finishReason: "tool-calls",
+					usage: {
+						prompt_tokens: 10091,
+						completion_tokens: 87,
+						cache_creation_input_tokens: 2770,
+					},
+					providerMetadata: {
+						anthropic: {
+							usage: {
+								input_tokens: 3,
+								output_tokens: 87,
+								cache_creation_input_tokens: 2770,
+								cache_read_input_tokens: 7318,
+							},
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 10091,
+				outputTokens: 87,
+				cacheReadTokens: 7318,
+				cacheWriteTokens: 2770,
+			}),
+		});
+		expect(events.at(-1)).toEqual({ type: "finish", reason: "tool-calls" });
+	});
+
+	it("reads cache usage from nested prompt token details", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 9125,
+						completion_tokens: 96,
+						prompt_tokens_details: {
+							cached_tokens: 8885,
+						},
+						cache_creation_input_tokens: 237,
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 9125,
+				outputTokens: 96,
+				cacheReadTokens: 8885,
+				cacheWriteTokens: 237,
+			}),
+		});
+		expect(events.at(-1)).toEqual({ type: "finish", reason: "stop" });
+	});
+
+	it("preserves usage cost from market cost fields", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 3793,
+						completion_tokens: 1250,
+						cost: 0,
+						market_cost: 0.01829135,
+					},
+					providerMetadata: {
+						gateway: {
+							cost: "0.01829135",
+							marketCost: "0.01829135",
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cline",
+					apiKey: "cline-key",
+					models: [
+						{
+							id: "openai/gpt-5.4",
+							name: "GPT-5.4",
+							metadata: {
+								pricing: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 },
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "openai/gpt-5.4",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: {
+				inputTokens: 3793,
+				outputTokens: 1250,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				totalCost: 0.01829135,
+			},
+		});
+	});
+
+	it("preserves explicit zero cost instead of falling back to catalog pricing", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 1000,
+						completion_tokens: 200,
+						cost: 0,
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					defaultModelId: "priced-model",
+					models: [
+						{
+							id: "priced-model",
+							name: "Priced Model",
+							metadata: {
+								pricing: {
+									input: 2,
+									output: 8,
+								},
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "priced-model",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				totalCost: 0,
+			}),
+		});
+	});
+
+	it("falls back to catalog pricing when upstream cost is missing", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 1000,
+						completion_tokens: 200,
+						cache_read_input_tokens: 100,
+						cache_creation_input_tokens: 50,
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					defaultModelId: "priced-model",
+					models: [
+						{
+							id: "priced-model",
+							name: "Priced Model",
+							metadata: {
+								pricing: {
+									input: 2,
+									output: 8,
+									cacheRead: 0.5,
+								},
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "priced-model",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 1000,
+				outputTokens: 200,
+				cacheReadTokens: 100,
+				cacheWriteTokens: 50,
+			}),
+		});
+		const usageEvent = events.find(
+			(event): event is Extract<AgentModelEvent, { type: "usage" }> =>
+				event.type === "usage",
+		);
+		expect(usageEvent?.usage.totalCost).toBeCloseTo(0.003475, 12);
+	});
+
+	it("reads nested raw market cost for cline before falling back to pricing", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 3793,
+						completion_tokens: 1250,
+						raw: {
+							cost: 0,
+							market_cost: 0.01829135,
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cline",
+					apiKey: "cline-key",
+					models: [
+						{
+							id: "openai/gpt-5.4",
+							name: "GPT-5.4",
+							metadata: {
+								pricing: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 },
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "openai/gpt-5.4",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				totalCost: 0.01829135,
+			}),
+		});
+	});
+
+	it("uses nested raw upstream inference cost for vercel ai gateway", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 24553,
+						completion_tokens: 32,
+						raw: {
+							cost: 0,
+							cost_details: {
+								upstream_inference_cost: 0.0123725,
+							},
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "vercel-ai-gateway",
+					apiKey: "vercel-key",
+					models: [
+						{
+							id: "google/gemini-3-flash",
+							name: "Gemini 3 Flash",
+							metadata: {
+								pricing: { input: 9, output: 9 },
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "vercel-ai-gateway",
+				modelId: "google/gemini-3-flash",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				totalCost: 0.0123725,
+			}),
+		});
+	});
+
+	it("adds OpenRouter BYOK account fee and upstream provider cost from nested raw usage", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 24559,
+						completion_tokens: 31,
+						raw: {
+							cost: 0.000618625,
+							is_byok: true,
+							cost_details: {
+								upstream_inference_cost: 0.0123725,
+							},
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					defaultModelId: "google/gemini-3-flash-preview",
+					models: [
+						{
+							id: "google/gemini-3-flash-preview",
+							name: "Gemini 3 Flash Preview",
+							metadata: {
+								pricing: { input: 9, output: 9 },
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "google/gemini-3-flash-preview",
+				messages: baseMessages,
+			}),
+		);
+
+		const usageEvent = events.find(
+			(event): event is Extract<AgentModelEvent, { type: "usage" }> =>
+				event.type === "usage",
+		);
+		expect(usageEvent?.usage.totalCost).toBeCloseTo(0.012991125, 12);
+	});
+
+	it("does not double-count OpenRouter credit-billed upstream cost from nested raw usage", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 15,
+						completion_tokens: 5,
+						raw: {
+							cost: 0.0000301,
+							is_byok: false,
+							cost_details: {
+								upstream_inference_cost: 0.0000301,
+							},
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					defaultModelId: "z-ai/glm-5.1",
+					models: [
+						{
+							id: "z-ai/glm-5.1",
+							name: "GLM 5.1",
+							metadata: {
+								pricing: { input: 0.98, output: 3.08 },
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "z-ai/glm-5.1",
+				messages: baseMessages,
+			}),
+		);
+
+		const usageEvent = events.find(
+			(event): event is Extract<AgentModelEvent, { type: "usage" }> =>
+				event.type === "usage",
+		);
+		expect(usageEvent?.usage.totalCost).toBe(0.0000301);
+	});
+
+	it("applies provider-specific usage normalization to stream usage promises", async () => {
+		streamTextSpy.mockReturnValue({
+			usage: Promise.resolve({
+				inputTokens: 24553,
+				outputTokens: 32,
+				raw: {
+					cost: 0,
+					cost_details: {
+						upstream_inference_cost: 0.0123725,
+					},
+				},
+			}),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "vercel-ai-gateway",
+					apiKey: "vercel-key",
+					models: [
+						{
+							id: "google/gemini-3-flash",
+							name: "Gemini 3 Flash",
+							metadata: {
+								pricing: { input: 9, output: 9 },
+							},
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "vercel-ai-gateway",
+				modelId: "google/gemini-3-flash",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 24553,
+				outputTokens: 32,
+				totalCost: 0.0123725,
+			}),
+		});
+	});
+
+	it("does not emit duplicate usage when finish parts already carry totals", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 1000,
+						completion_tokens: 25,
+						cache_creation_input_tokens: 50,
+						prompt_tokens_details: { cached_tokens: 200 },
+						market_cost: 0.0011,
+					},
+				},
+			]),
+			usage: Promise.resolve({
+				prompt_tokens: 1000,
+				completion_tokens: 25,
+				cache_creation_input_tokens: 50,
+				prompt_tokens_details: { cached_tokens: 200 },
+				market_cost: 0.0011,
+			}),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cline",
+					apiKey: "cline-key",
+					models: [{ id: "openai/gpt-5.3-codex", name: "GPT-5.3 Codex" }],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "openai/gpt-5.3-codex",
+				messages: baseMessages,
+			}),
+		);
+
+		const usageEvents = events.filter(
+			(event): event is Extract<AgentModelEvent, { type: "usage" }> =>
+				event.type === "usage",
+		);
+		expect(usageEvents).toHaveLength(1);
+		expect(usageEvents[0]).toEqual({
+			type: "usage",
+			usage: {
+				inputTokens: 1000,
+				outputTokens: 25,
+				cacheReadTokens: 200,
+				cacheWriteTokens: 50,
+				totalCost: 0.0011,
+			},
+		});
+	});
+
+	it("reads cache write tokens from nested raw usage", async () => {
+		streamTextSpy.mockReturnValue({
+			usage: Promise.resolve({
+				inputTokens: 15997,
+				outputTokens: 4,
+				raw: {
+					prompt_tokens: 15997,
+					completion_tokens: 4,
+					cache_creation_input_tokens: 22,
+					market_cost: 0.0082385,
+				},
+			}),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cline",
+					apiKey: "cline-key",
+					models: [
+						{
+							id: "anthropic/claude-opus-4.6",
+							name: "Claude Opus 4.6",
+						},
+					],
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "anthropic/claude-opus-4.6",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 15997,
+				outputTokens: 4,
+				cacheWriteTokens: 22,
+				totalCost: 0.0082385,
+			}),
+		});
+	});
+
+	it("reads compatible-provider cache usage from nested provider metadata", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 10091,
+						completion_tokens: 87,
+						cache_creation_input_tokens: 2770,
+					},
+					providerMetadata: {
+						openrouter: {
+							usage: {
+								input_tokens: 3,
+								output_tokens: 87,
+								cache_creation_input_tokens: 2770,
+								cache_read_input_tokens: 7318,
+							},
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-sonnet-4.6",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 10091,
+				outputTokens: 87,
+				cacheReadTokens: 7318,
+				cacheWriteTokens: 2770,
+			}),
+		});
+	});
+
+	it("prefers LanguageModelUsage inputTokenDetails cache reads", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						inputTokens: 50,
+						outputTokens: 10,
+						inputTokenDetails: {
+							cacheReadTokens: 12,
+						},
+						cachedInputTokens: 4,
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				inputTokens: 50,
+				outputTokens: 10,
+				cacheReadTokens: 12,
+				cacheWriteTokens: 0,
+			}),
+		});
+	});
+
+	it("formats assistant tool calls and tool results into valid AI SDK messages", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "text-delta", textDelta: "done" },
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: [
+					{
+						id: "user_1",
+						role: "user",
+						content: [{ type: "text", text: "hey" }],
+						createdAt: Date.now(),
+					},
+					{
+						id: "assistant_1",
+						role: "assistant",
+						content: [
+							{ type: "text", text: "Let me inspect that." },
+							{
+								type: "tool-call",
+								toolCallId: "call_1",
+								toolName: "run_commands",
+								input: { commands: ["pwd"] },
+							},
+						],
+						createdAt: Date.now(),
+					},
+					{
+						id: "user_2",
+						role: "user",
+						content: [
+							{
+								type: "tool-result",
+								toolCallId: "call_1",
+								toolName: "run_commands",
+								output: { ok: true },
+							},
+						],
+						createdAt: Date.now(),
+					},
+				],
+				tools: [
+					{
+						name: "run_commands",
+						description: "Runs shell commands",
+						inputSchema: { type: "object" },
+					},
+				],
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({ type: "text", text: "hey" }),
+						]),
+					}),
+					{
+						role: "assistant",
+						content: [
+							{ type: "text", text: "Let me inspect that." },
+							{
+								type: "tool-call",
+								toolCallId: "call_1",
+								toolName: "run_commands",
+								input: { commands: ["pwd"] },
+							},
+						],
+					},
+					{
+						role: "tool",
+						content: [
+							{
+								type: "tool-result",
+								toolCallId: "call_1",
+								toolName: "run_commands",
+								output: { type: "json", value: { ok: true } },
+							},
+						],
+					},
+				],
+				tools: expect.objectContaining({
+					run_commands: expect.not.objectContaining({
+						providerOptions: expect.anything(),
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("preserves Vertex thought signatures on tool calls and replays them", async () => {
+		streamTextSpy.mockReturnValueOnce({
+			fullStream: makeStreamParts([
+				{
+					type: "tool-call",
+					toolCallId: "call_1",
+					toolName: "editor",
+					input: { path: "/tmp/out.txt" },
+					providerMetadata: {
+						vertex: {
+							thoughtSignature: "sig_1",
+						},
+					},
+				},
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "vertex",
+					options: {
+						project: "test-project",
+						location: "global",
+					},
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+				messages: baseMessages,
+				tools: [
+					{
+						name: "editor",
+						description: "Edits files",
+						inputSchema: { type: "object" },
+					},
+				],
+			}),
+		);
+
+		expect(events).toContainEqual(
+			expect.objectContaining({
+				type: "tool-call-delta",
+				toolCallId: "call_1",
+				toolName: "editor",
+				metadata: expect.objectContaining({
+					thoughtSignature: "sig_1",
+				}),
+			}),
+		);
+
+		const toolCallEvent = events.find(
+			(event): event is Extract<AgentModelEvent, { type: "tool-call-delta" }> =>
+				event.type === "tool-call-delta",
+		);
+		expect(toolCallEvent).toBeDefined();
+
+		streamTextSpy.mockReset();
+
+		const replayCases = [
+			{
+				name: "fresh event metadata",
+				metadata: toolCallEvent?.metadata,
+			},
+			{
+				name: "persisted history metadata",
+				metadata: { signature: "sig_1" },
+			},
+		];
+
+		for (const replayCase of replayCases) {
+			streamTextSpy.mockReset();
+			streamTextSpy.mockReturnValueOnce({
+				fullStream: makeStreamParts([
+					{ type: "text-delta", textDelta: `done ${replayCase.name}` },
+					{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+				]),
+			});
+
+			await collect(
+				await gateway.stream({
+					providerId: "vertex",
+					modelId: "gemini-3-flash-preview",
+					messages: [
+						{
+							id: `assistant_${replayCase.name}`,
+							role: "assistant",
+							content: [
+								{
+									type: "tool-call",
+									toolCallId: "call_1",
+									toolName: "editor",
+									input: { path: "/tmp/out.txt" },
+									metadata: replayCase.metadata,
+								},
+							],
+							createdAt: Date.now(),
+						},
+						{
+							id: `tool_${replayCase.name}`,
+							role: "tool",
+							content: [
+								{
+									type: "tool-result",
+									toolCallId: "call_1",
+									toolName: "editor",
+									output: { ok: true },
+								},
+							],
+							createdAt: Date.now(),
+						},
+					],
+					tools: [
+						{
+							name: "editor",
+							description: "Edits files",
+							inputSchema: { type: "object" },
+						},
+					],
+				}),
+			);
+
+			expect(streamTextSpy).toHaveBeenCalledWith(
+				expect.objectContaining({
+					messages: expect.arrayContaining([
+						expect.objectContaining({
+							role: "assistant",
+							content: [
+								expect.objectContaining({
+									type: "tool-call",
+									toolCallId: "call_1",
+									toolName: "editor",
+									providerOptions: {
+										google: {
+											thoughtSignature: "sig_1",
+										},
+									},
+								}),
+							],
+						}),
+					]),
+				}),
+			);
+		}
+	});
+
+	it("preserves legacy Google snake_case thought signatures", async () => {
+		streamTextSpy.mockReturnValueOnce({
+			fullStream: makeStreamParts([
+				{
+					type: "tool-call",
+					toolCallId: "call_legacy",
+					toolName: "editor",
+					input: { path: "/tmp/out.txt" },
+					providerMetadata: {
+						google: {
+							thought_signature: "sig_legacy",
+						},
+					},
+				},
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "gemini",
+					apiKey: "google-key",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "gemini",
+				modelId: "gemini-2.5-flash",
+				messages: baseMessages,
+				tools: [
+					{
+						name: "editor",
+						description: "Edits files",
+						inputSchema: { type: "object" },
+					},
+				],
+			}),
+		);
+
+		expect(events).toContainEqual(
+			expect.objectContaining({
+				type: "tool-call-delta",
+				toolCallId: "call_legacy",
+				toolName: "editor",
+				metadata: expect.objectContaining({
+					thought_signature: "sig_legacy",
+				}),
+			}),
+		);
+
+		streamTextSpy.mockReset();
+		streamTextSpy.mockReturnValueOnce({
+			fullStream: makeStreamParts([
+				{ type: "text-delta", textDelta: "done" },
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "gemini",
+				modelId: "gemini-2.5-flash",
+				messages: [
+					{
+						id: "assistant_legacy",
+						role: "assistant",
+						content: [
+							{
+								type: "tool-call",
+								toolCallId: "call_legacy",
+								toolName: "editor",
+								input: { path: "/tmp/out.txt" },
+								metadata: {
+									thought_signature: "sig_legacy",
+								},
+							},
+						],
+						createdAt: Date.now(),
+					},
+					{
+						id: "tool_legacy",
+						role: "tool",
+						content: [
+							{
+								type: "tool-result",
+								toolCallId: "call_legacy",
+								toolName: "editor",
+								output: { ok: true },
+							},
+						],
+						createdAt: Date.now(),
+					},
+				],
+				tools: [
+					{
+						name: "editor",
+						description: "Edits files",
+						inputSchema: { type: "object" },
+					},
+				],
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([
+					expect.objectContaining({
+						role: "assistant",
+						content: [
+							expect.objectContaining({
+								type: "tool-call",
+								toolCallId: "call_legacy",
+								toolName: "editor",
+								providerOptions: {
+									google: {
+										thoughtSignature: "sig_legacy",
+									},
+								},
+							}),
+						],
+					}),
+				]),
+			}),
+		);
+	});
+
+	it("does not pass extra tools to providers that disable external tool execution", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openai-codex-cli" }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-codex-cli",
+				modelId: "gpt-5.3-codex",
+				messages: baseMessages,
+				tools: [
+					{
+						name: "run_commands",
+						description: "Runs shell commands",
+						inputSchema: { type: "object" },
+					},
+				],
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				tools: undefined,
+			}),
+		);
+	});
+
+	it("tags tool call events with provider metadata for providers that disable external tool execution", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "tool-call",
+					toolCallId: "call_1",
+					toolName: "run_commands",
+					input: { cmd: "pwd" },
+				},
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openai-codex-cli" }],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openai-codex-cli",
+				modelId: "gpt-5.3-codex",
+				messages: baseMessages,
+			}),
+		);
+
+		const toolCallEvent = events.find(
+			(event) => event.type === "tool-call-delta",
+		);
+		expect(toolCallEvent).toMatchObject({
+			type: "tool-call-delta",
+			toolCallId: "call_1",
+			toolName: "run_commands",
+			input: { cmd: "pwd" },
+			inputText: '{"cmd":"pwd"}',
+			metadata: {
+				toolSource: {
+					providerId: "openai-codex-cli",
+					modelId: "gpt-5.3-codex",
+					executionMode: "provider",
+				},
+			},
+		});
+	});
+
+	it("keeps AI SDK tool-error parts recoverable", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "tool-call",
+					toolCallId: "call_1",
+					toolName: "run_commands",
+					input: '{"commands": find /workspace | head -20}',
+				},
+				{
+					type: "tool-error",
+					toolCallId: "call_1",
+					toolName: "run_commands",
+					input: '{"commands": find /workspace | head -20}',
+					error: "Invalid input for tool run_commands: JSON parsing failed",
+				},
+				{
+					type: "finish",
+					finishReason: "tool-calls",
+					usage: { inputTokens: 1, outputTokens: 1 },
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openai-codex-cli" }],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openai-codex-cli",
+				modelId: "gpt-5.3-codex",
+				messages: baseMessages,
+			}),
+		);
+
+		const toolCallEvents = events.filter(
+			(event): event is Extract<AgentModelEvent, { type: "tool-call-delta" }> =>
+				event.type === "tool-call-delta",
+		);
+		expect(toolCallEvents).toHaveLength(2);
+		expect(toolCallEvents[0]).toMatchObject({
+			toolCallId: "call_1",
+			toolName: "run_commands",
+			inputText: '{"commands": find /workspace | head -20}',
+		});
+		expect(toolCallEvents[1]).toMatchObject({
+			toolCallId: "call_1",
+			toolName: "run_commands",
+			metadata: {
+				inputParseError: expect.stringContaining(
+					"Invalid input for tool run_commands",
+				),
+				aiSdkToolError:
+					"Invalid input for tool run_commands: JSON parsing failed",
+			},
+		});
+		expect(events.at(-1)).toEqual({
+			type: "finish",
+			reason: "tool-calls",
+			error: undefined,
+		});
+	});
+
+	it("does not send maxOutputTokens to ChatGPT OAuth when the request omits max tokens", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openai-codex" }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-codex",
+				modelId: "gpt-5.4",
+				messages: baseMessages,
+			}),
+		);
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { maxOutputTokens?: unknown }
+			| undefined;
+		expect(call).not.toHaveProperty("maxOutputTokens");
+	});
+
+	it("passes Codex instructions through provider options and removes the system message from messages", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openai-codex" }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-codex",
+				modelId: "gpt-5.4",
+				systemPrompt: "You are helpful.",
+				messages: baseMessages,
+				reasoning: {
+					effort: "high",
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					{
+						role: "user",
+						content: [{ type: "text", text: "Hello" }],
+					},
+				],
+				providerOptions: expect.objectContaining({
+					openai: expect.objectContaining({
+						instructions: "You are helpful.",
+						store: false,
+					}),
+					"openai-codex": expect.objectContaining({
+						store: false,
+						reasoningEffort: "high",
+						reasoningSummary: "auto",
+					}),
+					openaiCodex: expect.objectContaining({
+						store: false,
+					}),
+				}),
+			}),
+		);
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| {
+					maxOutputTokens?: unknown;
+					providerOptions?: Record<string, Record<string, unknown>>;
+			  }
+			| undefined;
+		expect(call).not.toHaveProperty("maxOutputTokens");
+		expect(call?.providerOptions?.openai).not.toHaveProperty("truncation");
+		expect(call?.providerOptions?.["openai-codex"]).not.toHaveProperty(
+			"truncation",
+		);
+		expect(call?.providerOptions?.openaiCodex).not.toHaveProperty("truncation");
+	});
+
+	it("passes object JSON schemas unchanged to the OpenAI Codex tool adapter", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openai-codex" }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-codex",
+				modelId: "gpt-5.4",
+				messages: baseMessages,
+				tools: [
+					{
+						name: "run_commands",
+						description: "Runs shell commands",
+						inputSchema: {
+							type: "object",
+							properties: {
+								commands: {
+									type: "array",
+									items: { type: "string" },
+								},
+							},
+							required: ["commands"],
+							additionalProperties: false,
+						},
+					},
+				],
+			}),
+		);
+
+		const call = streamTextSpy.mock.calls[0]?.[0] as
+			| { tools?: Record<string, { inputSchema?: { jsonSchema?: unknown } }> }
+			| undefined;
+		const schema = await call?.tools?.run_commands.inputSchema?.jsonSchema;
+		expect(schema).toEqual({
+			type: "object",
+			properties: {
+				commands: {
+					type: "array",
+					items: { type: "string" },
+				},
+			},
+			required: ["commands"],
+			additionalProperties: false,
+		});
+	});
+
+	it("passes reasoning effort through to Anthropic provider options", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+					models: [
+						{
+							id: "claude-sonnet-4-5",
+							name: "Claude Sonnet 4.5",
+							metadata: {
+								family: "claude-sonnet",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: baseMessages,
+				reasoning: {
+					effort: "high",
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					anthropic: expect.objectContaining({
+						thinking: expect.objectContaining({ type: "enabled" }),
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("does not enable adaptive thinking for Anthropic when reasoning is not requested", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					anthropic: expect.not.objectContaining({
+						thinking: { type: "adaptive" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("detects anthropic-compatible aliases by family and forwards reasoning plus prompt cache", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					models: [
+						{
+							id: "router-claude-alias",
+							name: "Router Claude Alias",
+							metadata: {
+								family: "claude-sonnet",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "router-claude-alias",
+				messages: baseMessages,
+				maxTokens: 8192,
+				reasoning: {
+					enabled: true,
+					effort: "high",
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({
+								type: "text",
+								providerOptions: expect.objectContaining({
+									openrouter: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+						]),
+					}),
+				]),
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+						reasoning: expect.objectContaining({
+							enabled: true,
+							max_tokens: expect.any(Number),
+						}),
+					}),
+					openrouter: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+						reasoning: expect.objectContaining({
+							effort: "high",
+						}),
+					}),
+					anthropic: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+						thinking: expect.objectContaining({ type: "enabled" }),
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("keeps OpenRouter Qwen prompt cache on a content part", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					models: [
+						{
+							id: "alibaba/qwen3.6-plus",
+							name: "Qwen 3.6 Plus",
+							capabilities: ["prompt-cache"],
+							metadata: {
+								family: "qwen",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "alibaba/qwen3.6-plus",
+				messages: baseMessages,
+			}),
+		);
+
+		const call = streamTextSpy.mock.calls.at(-1)?.[0] as
+			| { messages?: Array<{ role: string; content: unknown }> }
+			| undefined;
+		const userMessage = call?.messages?.find(
+			(message) => message.role === "user",
+		);
+		expect(Array.isArray(userMessage?.content)).toBe(true);
+		expect(userMessage?.content).toEqual([
+			expect.objectContaining({
+				type: "text",
+				text: "Hello",
+				providerOptions: expect.objectContaining({
+					openrouter: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					openaiCompatible: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+			{ type: "text", text: " " },
+		]);
+		expect(userMessage?.content).not.toBe("Hello");
+	});
+
+	it("does not apply anthropic prompt-cache shaping for non-remapped providers", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "deepseek",
+					apiKey: "deepseek-key",
+					models: [
+						{
+							id: "deepseek-claude-alias",
+							name: "DeepSeek Claude Alias",
+							metadata: {
+								family: "claude-sonnet",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "deepseek",
+				modelId: "deepseek-claude-alias",
+				messages: baseMessages,
+				reasoning: {
+					enabled: true,
+					effort: "high",
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "Hello" }] },
+				],
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.not.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					deepseek: expect.not.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					anthropic: expect.not.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("applies anthropic prompt-cache shaping for direct anthropic provider", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "anthropic",
+					apiKey: "anthropic-key",
+					models: [
+						{
+							id: "claude-sonnet-4-6",
+							name: "Claude Sonnet 4.6",
+							metadata: {
+								family: "claude-sonnet",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({
+								type: "text",
+								text: "Hello",
+								providerOptions: expect.objectContaining({
+									anthropic: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+									openaiCompatible: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+						]),
+					}),
+				],
+				providerOptions: expect.objectContaining({
+					anthropic: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("does not apply anthropic prompt-cache shaping for remapped providers on non-claude families", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+					models: [
+						{
+							id: "router-gpt-alias",
+							name: "Router GPT Alias",
+							metadata: {
+								family: "gpt",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "router-gpt-alias",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "Hello" }] },
+				],
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.not.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					openrouter: expect.not.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("falls back to model-id detection for remapped providers when family metadata is absent", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-sonnet-router-alias",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({
+								type: "text",
+								providerOptions: expect.objectContaining({
+									openrouter: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+						]),
+					}),
+				]),
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					openrouter: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("falls back to bedrock-style anthropic model ids when family metadata is absent", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "bedrock",
+					apiKey: "bedrock-key",
+					models: [
+						{
+							id: "anthropic.claude-sonnet-4-6",
+							name: "Claude Sonnet 4.6 (Bedrock-style ID)",
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "bedrock",
+				modelId: "anthropic.claude-sonnet-4-6",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({
+								type: "text",
+								text: "Hello",
+								providerOptions: expect.objectContaining({
+									anthropic: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+									bedrock: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+						]),
+					}),
+				],
+				providerOptions: expect.objectContaining({
+					anthropic: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					bedrock: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("supports provider config metadata overrides for anthropic prompt-cache strategy", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "deepseek",
+					apiKey: "deepseek-key",
+					metadata: {
+						routing: {
+							promptCache: {
+								format: "anthropic-cache-control",
+								routes: [{ matcher: "anthropic-compatible" }],
+							},
+						},
+					},
+					models: [
+						{
+							id: "deepseek-claude-alias",
+							name: "DeepSeek Claude Alias",
+							metadata: {
+								family: "claude-sonnet",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "deepseek",
+				modelId: "deepseek-claude-alias",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					expect.objectContaining({
+						role: "user",
+						content: expect.arrayContaining([
+							expect.objectContaining({
+								type: "text",
+								text: "Hello",
+								providerOptions: expect.objectContaining({
+									anthropic: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+									deepseek: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+						]),
+					}),
+				],
+				providerOptions: expect.objectContaining({
+					anthropic: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					deepseek: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("preserves legacy promptCacheStrategy for custom Qwen provider configs", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "deepseek",
+					apiKey: "deepseek-key",
+					metadata: {
+						promptCacheStrategy: "anthropic-automatic",
+					},
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "deepseek",
+				modelId: "qwen/qwen3.6-plus",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					expect.objectContaining({
+						role: "user",
+						content: [
+							expect.objectContaining({
+								type: "text",
+								text: "Hello",
+								providerOptions: expect.objectContaining({
+									openaiCompatible: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+									deepseek: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+							{ type: "text", text: " " },
+						],
+					}),
+				],
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					deepseek: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+		const qwenCall = streamTextSpy.mock.calls.at(-1)?.[0] as {
+			providerOptions?: Record<string, Record<string, unknown> | undefined>;
+		};
+		expect(qwenCall.providerOptions?.anthropic).not.toEqual(
+			expect.objectContaining({
+				cache_control: { type: "ephemeral" },
+			}),
+		);
+	});
+
+	it("forwards Anthropic-style prompt cache controls for Qwen on OpenRouter", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					usage: {
+						prompt_tokens: 10126,
+						completion_tokens: 13,
+						prompt_tokens_details: {
+							cached_tokens: 0,
+							cache_write_tokens: 10106,
+						},
+					},
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+				},
+			],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "qwen/qwen3.6-plus",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([
+					expect.objectContaining({
+						role: "user",
+						content: [
+							expect.objectContaining({
+								type: "text",
+								providerOptions: expect.objectContaining({
+									openaiCompatible: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+									openrouter: expect.objectContaining({
+										cache_control: { type: "ephemeral" },
+									}),
+								}),
+							}),
+							{ type: "text", text: " " },
+						],
+					}),
+				]),
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+					openrouter: expect.objectContaining({
+						cache_control: { type: "ephemeral" },
+					}),
+				}),
+			}),
+		);
+		const qwenCall = streamTextSpy.mock.calls.at(-1)?.[0] as {
+			providerOptions?: Record<string, Record<string, unknown> | undefined>;
+		};
+		expect(qwenCall.providerOptions?.anthropic).not.toEqual(
+			expect.objectContaining({
+				cache_control: { type: "ephemeral" },
+			}),
+		);
+		expect(events).toContainEqual({
+			type: "usage",
+			usage: expect.objectContaining({
+				cacheReadTokens: 0,
+				cacheWriteTokens: 10106,
+			}),
+		});
+	});
+
+	it.each([
+		{
+			providerId: "cline",
+			modelId: "qwen/qwen3.6-plus",
+			providerOptionsKey: "cline",
+			aliasKey: undefined,
+		},
+		{
+			providerId: "vercel-ai-gateway",
+			modelId: "alibaba/qwen3.6-plus",
+			providerOptionsKey: "vercel-ai-gateway",
+			aliasKey: "vercelAiGateway",
+		},
+	])("forwards Qwen prompt cache controls without Anthropic reasoning for $providerId", async ({
+		providerId,
+		modelId,
+		providerOptionsKey,
+		aliasKey,
+	}) => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId,
+					apiKey: "provider-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId,
+				modelId,
+				messages: baseMessages,
+				reasoning: { enabled: true, effort: "high" },
+			}),
+		);
+
+		const qwenCall = streamTextSpy.mock.calls.at(-1)?.[0] as {
+			messages?: Array<{
+				role: string;
+				content: Array<{
+					type: string;
+					providerOptions?: Record<string, Record<string, unknown>>;
+				}>;
+			}>;
+			providerOptions?: Record<string, Record<string, unknown> | undefined>;
+		};
+		const expectedCacheControl = {
+			cache_control: { type: "ephemeral" },
+		};
+
+		expect(qwenCall.messages).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					role: "user",
+					content: [
+						expect.objectContaining({
+							type: "text",
+							providerOptions: expect.objectContaining({
+								openaiCompatible: expect.objectContaining(expectedCacheControl),
+								[providerOptionsKey]:
+									expect.objectContaining(expectedCacheControl),
+							}),
+						}),
+						{ type: "text", text: " " },
+					],
+				}),
+			]),
+		);
+		expect(qwenCall.providerOptions).toEqual(
+			expect.objectContaining({
+				openaiCompatible: expect.objectContaining(expectedCacheControl),
+				[providerOptionsKey]: expect.objectContaining(expectedCacheControl),
+			}),
+		);
+		if (aliasKey) {
+			expect(qwenCall.providerOptions?.[aliasKey]).toEqual(
+				expect.objectContaining(expectedCacheControl),
+			);
+		}
+		expect(qwenCall.providerOptions?.[providerOptionsKey]).not.toEqual(
+			expect.objectContaining({
+				reasoning: expect.anything(),
+			}),
+		);
+		expect(qwenCall.providerOptions?.anthropic).not.toEqual(
+			expect.objectContaining(expectedCacheControl),
+		);
+	});
+
+	it.each([
+		{
+			providerId: "openrouter",
+			modelId: "qwen/qwen-future-cache-model",
+		},
+		{
+			providerId: "vercel-ai-gateway",
+			modelId: "alibaba/qwen-future-cache-model",
+		},
+	])("does not prompt-cache unregistered $providerId Qwen ids without capability metadata", async ({
+		providerId,
+		modelId,
+	}) => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId, apiKey: "test-key" }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId,
+				modelId,
+				messages: baseMessages,
+			}),
+		);
+
+		expect(openaiCompatibleSpy).toHaveBeenCalledWith(modelId);
+		const call = streamTextSpy.mock.calls.at(-1)?.[0];
+		expect(JSON.stringify(call)).not.toContain("cache_control");
+	});
+
+	it("does not rewrite non-anthropic messages with prompt cache provider options", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "gemini",
+					apiKey: "google-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "gemini",
+				modelId: "gemini-2.5-flash",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "Hello" }] },
+				],
+			}),
+		);
+	});
+
+	it("passes reasoning summary through for non-anthropic openai-compatible reasoning models", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "cline",
+					apiKey: "cline-key",
+					models: [
+						{
+							id: "openai/gpt-5.4",
+							name: "GPT-5.4",
+							metadata: {
+								family: "gpt",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "openai/gpt-5.4",
+				messages: baseMessages,
+				reasoning: {
+					effort: "high",
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						reasoningEffort: "high",
+						reasoningSummary: "auto",
+					}),
+					cline: expect.objectContaining({
+						reasoning: expect.objectContaining({
+							enabled: true,
+							effort: "high",
+						}),
+						reasoningEffort: "high",
+						reasoningSummary: "auto",
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("passes native Z.AI thinking enabled and disabled provider options for GLM", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "zai",
+					apiKey: "zai-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "zai",
+				modelId: "glm-4.7",
+				messages: baseMessages,
+				reasoning: {
+					enabled: true,
+				},
+			}),
+		);
+		await collect(
+			await gateway.stream({
+				providerId: "zai",
+				modelId: "glm-4.7",
+				messages: baseMessages,
+				reasoning: {
+					enabled: false,
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					zai: expect.objectContaining({
+						thinking: { type: "enabled" },
+					}),
+				}),
+			}),
+		);
+		expect(streamTextSpy).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					zai: expect.objectContaining({
+						thinking: { type: "disabled" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("does not apply generic thinking to non-GLM native Z.AI custom models", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "zai",
+					apiKey: "zai-key",
+					models: [
+						{
+							id: "zai-other-model",
+							name: "Non GLM Model",
+							metadata: {
+								family: "other",
+							},
+						},
+					],
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "zai",
+				modelId: "zai-other-model",
+				messages: baseMessages,
+				reasoning: {
+					enabled: true,
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					zai: expect.not.objectContaining({
+						thinking: expect.anything(),
+					}),
+					openaiCompatible: expect.not.objectContaining({
+						thinking: expect.anything(),
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("passes routed GLM reasoning include/exclude provider options", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "openrouter-key",
+				},
+				{
+					providerId: "cline",
+					apiKey: "cline-key",
+				},
+				{
+					providerId: "vercel-ai-gateway",
+					apiKey: "vercel-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "z-ai/glm-4.7",
+				messages: baseMessages,
+				reasoning: {
+					enabled: true,
+				},
+			}),
+		);
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "z-ai/glm-4.7",
+				messages: baseMessages,
+				reasoning: {
+					enabled: false,
+				},
+			}),
+		);
+		await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "z-ai/glm-4.7",
+				messages: baseMessages,
+				reasoning: {
+					enabled: false,
+				},
+			}),
+		);
+		await collect(
+			await gateway.stream({
+				providerId: "vercel-ai-gateway",
+				modelId: "z-ai/glm-4.7",
+				messages: baseMessages,
+				reasoning: {
+					enabled: false,
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						reasoning: { enabled: true },
+					}),
+					openrouter: expect.objectContaining({
+						reasoning: { enabled: true },
+					}),
+				}),
+			}),
+		);
+		expect(streamTextSpy).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					openrouter: expect.objectContaining({
+						reasoning: { effort: "none" },
+					}),
+				}),
+			}),
+		);
+		expect(streamTextSpy).toHaveBeenNthCalledWith(
+			3,
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						reasoning: { exclude: true },
+					}),
+					cline: expect.objectContaining({
+						reasoning: { exclude: true },
+					}),
+				}),
+			}),
+		);
+		expect(streamTextSpy).toHaveBeenNthCalledWith(
+			4,
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					openaiCompatible: expect.objectContaining({
+						reasoning: { exclude: true },
+					}),
+					vercelAiGateway: expect.objectContaining({
+						reasoning: { exclude: true },
+					}),
+					"vercel-ai-gateway": expect.objectContaining({
+						reasoning: { exclude: true },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("maps legacy model thinking options into gateway reasoning", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "finish", usage: { inputTokens: 1, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "zai",
+					apiKey: "zai-key",
+				},
+			],
+		});
+		const model = gateway.createAgentModel({
+			providerId: "zai",
+			modelId: "glm-4.7",
+		});
+
+		await collect(
+			await model.stream({
+				messages: baseMessages,
+				tools: [],
+				options: {
+					thinking: false,
+				},
+			}),
+		);
+
+		expect(streamTextSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				providerOptions: expect.objectContaining({
+					zai: expect.objectContaining({
+						thinking: { type: "disabled" },
+					}),
+				}),
+			}),
+		);
+	});
+
+	it("adapts Anthropic and Gemini providers", async () => {
+		streamTextSpy
+			.mockReturnValueOnce({
+				fullStream: makeStreamParts([
+					{ type: "text-delta", textDelta: "Anthropic" },
+					{ type: "finish", usage: { inputTokens: 5, outputTokens: 1 } },
+				]),
+			})
+			.mockReturnValueOnce({
+				fullStream: makeStreamParts([
+					{ type: "text-delta", textDelta: "Gemini" },
+					{ type: "finish", usage: { inputTokens: 6, outputTokens: 2 } },
+				]),
+			});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "anthropic", apiKey: "anthropic-key" },
+				{ providerId: "gemini", apiKey: "google-key" },
+			],
+		});
+
+		const anthropicEvents = await collect(
+			await gateway.stream({
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				messages: baseMessages,
+			}),
+		);
+		const geminiEvents = await collect(
+			await gateway.stream({
+				providerId: "gemini",
+				modelId: "gemini-2.5-flash",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(anthropicSpy).toHaveBeenCalledWith("claude-sonnet-4-5");
+		expect(googleSpy).toHaveBeenCalledWith("gemini-2.5-flash");
+		expect(anthropicEvents[0]).toEqual({
+			type: "text-delta",
+			text: "Anthropic",
+		});
+		expect(geminiEvents[0]).toEqual({ type: "text-delta", text: "Gemini" });
+	});
+
+	it("normalizes models.dev catalogs into ModelInfo", () => {
+		const result = normalizeModelsDevProviderModels({
+			openai: {
+				models: {
+					"gpt-5": {
+						name: "GPT-5",
+						tool_call: true,
+						reasoning: true,
+						structured_output: true,
+						release_date: "2026-01-01",
+						limit: { context: 200000, output: 32000 },
+						cost: { input: 1, output: 2 },
+						modalities: { input: ["text", "image"] },
+					},
+				},
+			},
+		});
+
+		expect(result["openai-native"]["gpt-5"]).toMatchObject({
+			id: "gpt-5",
+			name: "GPT-5",
+			contextWindow: 200000,
+			maxInputTokens: 200000,
+			maxTokens: 32000,
+			capabilities: expect.arrayContaining([
+				"tools",
+				"reasoning",
+				"structured_output",
+				"images",
+			]),
+			pricing: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
+			releaseDate: "2026-01-01",
+		});
+	});
+
+	it("uses provider apiKeyEnv fallback when no api key is configured", async () => {
+		process.env.OPENROUTER_API_KEY = "env-openrouter-key";
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "text-delta", textDelta: "OpenRouter" },
+				{ type: "finish", usage: { inputTokens: 3, outputTokens: 1 } },
+			]),
+		});
+
+		const gateway = createGateway();
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-sonnet-4.6",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(openaiCompatibleSpy).toHaveBeenCalledWith(
+			"anthropic/claude-sonnet-4.6",
+		);
+		expect(openaiCompatibleFactorySpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "env-openrouter-key",
+				baseURL: "https://openrouter.ai/api/v1",
+				name: "openrouter",
+			}),
+		);
+		expect(events[0]).toEqual({
+			type: "text-delta",
+			text: "OpenRouter",
+		});
+	});
+
+	it("allows unregistered model ids on known providers", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{ type: "text-delta", textDelta: "Cline custom model" },
+				{ type: "finish", usage: { inputTokens: 4, outputTokens: 2 } },
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "cline", apiKey: "test-key" }],
+		});
+
+		const events = await collect(
+			await gateway.stream({
+				providerId: "cline",
+				modelId: "google/gemma-4-31b-it",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(openaiCompatibleSpy).toHaveBeenCalledWith("google/gemma-4-31b-it");
+		expect(events[0]).toEqual({
+			type: "text-delta",
+			text: "Cline custom model",
+		});
+	});
+
+	it("forwards a per-provider fetch through to the provider config", async () => {
+		const customFetch = vi.fn() as unknown as typeof fetch;
+		const createProvider = vi.fn((config: { fetch?: typeof fetch }) => ({
+			async *stream() {
+				expect(config.fetch).toBe(customFetch);
+				yield { type: "text-delta", text: "ok" } satisfies AgentModelEvent;
+				yield { type: "finish", reason: "stop" } satisfies AgentModelEvent;
+			},
+		}));
+
+		const gateway = createGateway({
+			builtins: false,
+			providers: [
+				{
+					manifest: {
+						id: "custom-fetch",
+						name: "CustomFetch",
+						defaultModelId: "alpha",
+						models: [
+							{ id: "alpha", name: "Alpha", providerId: "custom-fetch" },
+						],
+					},
+					createProvider,
+				},
+			],
+			providerConfigs: [{ providerId: "custom-fetch", fetch: customFetch }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "custom-fetch",
+				modelId: "alpha",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(createProvider).toHaveBeenCalledOnce();
+	});
+
+	it("falls back to the top-level gateway fetch when no provider fetch is set", async () => {
+		const fallbackFetch = vi.fn() as unknown as typeof fetch;
+		const createProvider = vi.fn((config: { fetch?: typeof fetch }) => ({
+			async *stream() {
+				expect(config.fetch).toBe(fallbackFetch);
+				yield { type: "text-delta", text: "ok" } satisfies AgentModelEvent;
+				yield { type: "finish", reason: "stop" } satisfies AgentModelEvent;
+			},
+		}));
+
+		const gateway = createGateway({
+			builtins: false,
+			fetch: fallbackFetch,
+			providers: [
+				{
+					manifest: {
+						id: "custom-fetch-fallback",
+						name: "CustomFetchFallback",
+						defaultModelId: "alpha",
+						models: [
+							{
+								id: "alpha",
+								name: "Alpha",
+								providerId: "custom-fetch-fallback",
+							},
+						],
+					},
+					createProvider,
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "custom-fetch-fallback",
+				modelId: "alpha",
+				messages: baseMessages,
+			}),
+		);
+
+		expect(createProvider).toHaveBeenCalledOnce();
+	});
+
+	it("writes AI SDK prompt captures with request metadata correlation", async () => {
+		const captureDir = mkdtempSync(join(tmpdir(), "llms-capture-"));
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "summary";
+		process.env.CLINE_CAPTURE_DIR = captureDir;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "finish",
+					finishReason: "stop",
+					usage: { inputTokens: 1, outputTokens: 1 },
+				},
+			]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "test-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: {
+					captureId: "cap-session-1-run-1-2",
+					sessionId: "session-1",
+					runId: "run-1",
+					conversationId: "conv-1",
+					iteration: 2,
+				},
+			}),
+		);
+
+		const records = readCaptureRecords(captureDir);
+		expect(records).toHaveLength(1);
+		expect(readdirSync(captureDir)).toContain(
+			"cap-session-1-run-1-2.ai_sdk_prompt.1.provider-request.json",
+		);
+		expect(records[0]).toMatchObject({
+			captureStage: "ai_sdk_prompt",
+			attempt: 1,
+			mode: "summary",
+			correlation: {
+				captureId: "cap-session-1-run-1-2",
+				sessionId: "session-1",
+				runId: "run-1",
+				conversationId: "conv-1",
+				iteration: 2,
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+			},
+		});
+		expect(records[0]?.summary).toMatchObject({
+			messages: {
+				messageCount: 1,
+				roleCounts: { user: 1 },
+				messages: [
+					expect.objectContaining({
+						index: 0,
+						role: "user",
+						sha256: expect.any(String),
+					}),
+				],
+			},
+		});
+		expect(records[0]).not.toHaveProperty("payload");
+	});
+
+	it("falls back to a stable per-request capture filename without captureId", async () => {
+		const captureDir = mkdtempSync(join(tmpdir(), "llms-capture-fallback-"));
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "summary";
+		process.env.CLINE_CAPTURE_DIR = captureDir;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openrouter", apiKey: "test-key" }],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { runId: "run-fallback", iteration: 4 },
+			}),
+		);
+
+		const files = readdirSync(captureDir).filter((file) =>
+			file.endsWith(".provider-request.json"),
+		);
+		expect(files).toHaveLength(1);
+		expect(files[0]).toMatch(
+			/^cap_run-fallback_4_[a-f0-9]{16}\.ai_sdk_prompt\.1\.provider-request\.json$/,
+		);
+	});
+
+	it("honors the full capture preview byte cap override", async () => {
+		const captureDir = mkdtempSync(join(tmpdir(), "llms-full-capture-"));
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "full";
+		process.env.CLINE_CAPTURE_DIR = captureDir;
+		process.env.CLINE_CAPTURE_MAX_PREVIEW_BYTES = "24";
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openrouter",
+					apiKey: "test-key",
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: [
+					{
+						id: "user_full",
+						role: "user",
+						content: [{ type: "text", text: "Hello ".repeat(50) }],
+						createdAt: Date.now(),
+					},
+				],
+			}),
+		);
+
+		const payload = readCaptureRecords(captureDir)[0]?.payload as
+			| { preview?: string; truncated?: boolean }
+			| undefined;
+		expect(payload).toMatchObject({ truncated: true });
+		expect(
+			Buffer.byteLength(payload?.preview ?? "", "utf8"),
+		).toBeLessThanOrEqual(24);
+	});
+
+	it("does not write provider request captures without an explicit capture or data dir", async () => {
+		const cwd = process.cwd();
+		const tempCwd = mkdtempSync(join(tmpdir(), "llms-capture-cwd-"));
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "summary";
+		delete process.env.CLINE_CAPTURE_DIR;
+		delete process.env.CLINE_DATA_DIR;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		try {
+			process.chdir(tempCwd);
+			const gateway = createGateway({
+				providerConfigs: [
+					{
+						providerId: "openrouter",
+						apiKey: "test-key",
+					},
+				],
+			});
+
+			await collect(
+				await gateway.stream({
+					providerId: "openrouter",
+					modelId: "anthropic/claude-test",
+					messages: baseMessages,
+				}),
+			);
+
+			await expect(
+				access(join(tempCwd, ".cline", "provider-request-captures")),
+			).rejects.toThrow();
+		} finally {
+			process.chdir(cwd);
+		}
+	});
+
+	it("does not wrap provider fetch when wire capture is disabled", async () => {
+		const customFetch = vi.fn() as unknown as typeof fetch;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).toBe(customFetch);
+	});
+
+	it("adds OpenRouter session_id to JSON wire requests from request metadata", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: {
+					sessionId: "session-openrouter",
+					conversationId: "conversation-openrouter",
+				},
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).not.toBe(customFetch);
+		await config.fetch?.("https://openrouter.ai/api/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+		});
+
+		expect(customFetch).toHaveBeenCalledOnce();
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		expect(JSON.parse(String(init?.body))).toMatchObject({
+			session_id: "session-openrouter",
+		});
+	});
+
+	it("preserves default model metadata when request metadata is present", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+		const model = gateway.createAgentModel(
+			{
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+			},
+			{
+				metadata: {
+					sessionId: "default-session",
+					traceId: "default-trace",
+				},
+			},
+		);
+
+		await collect(
+			await model.stream({
+				messages: baseMessages,
+				tools: [],
+				options: {
+					metadata: {
+						runId: "request-run",
+						traceId: "request-trace",
+					},
+				},
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).not.toBe(customFetch);
+		await config.fetch?.("https://openrouter.ai/api/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+		});
+
+		expect(customFetch).toHaveBeenCalledOnce();
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		expect(JSON.parse(String(init?.body))).toMatchObject({
+			session_id: "default-session",
+		});
+	});
+
+	it("adds configured JSON-body sticky session fields for providers that opt in", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-compatible",
+					apiKey: "test-key",
+					fetch: customFetch,
+					metadata: {
+						stickySession: {
+							transport: "json-body",
+							field: "sticky_session",
+							metadataKey: "sessionId",
+						},
+					},
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-compatible",
+				modelId: "custom/model",
+				messages: baseMessages,
+				metadata: { sessionId: "session-longer-than-eight" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).not.toBe(customFetch);
+		await config.fetch?.("https://example.test/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+		});
+
+		expect(customFetch).toHaveBeenCalledOnce();
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		expect(JSON.parse(String(init?.body))).toMatchObject({
+			sticky_session: "session-longer-than-eight",
+		});
+	});
+
+	it("adds configured header sticky session fields for providers that opt in", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-compatible",
+					apiKey: "test-key",
+					fetch: customFetch,
+					metadata: {
+						stickySession: {
+							transport: "header",
+							field: "x-session-id",
+							metadataKey: "sessionId",
+						},
+					},
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-compatible",
+				modelId: "custom/model",
+				messages: baseMessages,
+				metadata: { sessionId: "session-header" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).not.toBe(customFetch);
+		await config.fetch?.("https://example.test/v1/chat/completions", {
+			method: "POST",
+			headers: { "x-existing": "kept" },
+			body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+		});
+
+		expect(customFetch).toHaveBeenCalledOnce();
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		const headers = new Headers(init?.headers);
+		expect(headers.get("x-session-id")).toBe("session-header");
+		expect(headers.get("x-existing")).toBe("kept");
+	});
+
+	it("preserves explicit configured header sticky session values", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-compatible",
+					apiKey: "test-key",
+					fetch: customFetch,
+					metadata: {
+						stickySession: {
+							transport: "header",
+							field: "x-session-id",
+							metadataKey: "sessionId",
+						},
+					},
+				},
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openai-compatible",
+				modelId: "custom/model",
+				messages: baseMessages,
+				metadata: { sessionId: "session-header" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		await config.fetch?.("https://example.test/v1/chat/completions", {
+			method: "POST",
+			headers: { "x-session-id": "explicit-header-session" },
+			body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+		});
+
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		expect(new Headers(init?.headers).get("x-session-id")).toBe(
+			"explicit-header-session",
+		);
+	});
+
+	it("preserves explicit OpenRouter session_id in JSON wire requests", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { sessionId: "session-openrouter" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		await config.fetch?.("https://openrouter.ai/api/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({
+				session_id: "explicit-session",
+				messages: [{ role: "user", content: "hi" }],
+			}),
+		});
+
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		expect(JSON.parse(String(init?.body))).toMatchObject({
+			session_id: "explicit-session",
+		});
+	});
+
+	it("does not inspect a Request body when init explicitly sets a null body", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { sessionId: "session-openrouter" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		const request = new Request(
+			"https://openrouter.ai/api/v1/chat/completions",
+			{
+				method: "POST",
+				body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+			},
+		);
+		await config.fetch?.(request, { body: null });
+
+		expect(customFetch).toHaveBeenCalledOnce();
+		expect(customFetchMock.mock.calls[0]?.[0]).toBe(request);
+		const init = customFetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
+		expect(init?.body).toBeNull();
+	});
+
+	it("does not fall back to conversationId for OpenRouter session_id", async () => {
+		const { fetchMock: customFetchMock, fetch: customFetch } =
+			createFetchMock();
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { conversationId: "conversation-openrouter" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).toBe(customFetch);
+	});
+
+	it("wraps provider fetch for wire capture while delegating to the configured fetch", async () => {
+		const captureDir = mkdtempSync(join(tmpdir(), "llms-wire-capture-"));
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "summary";
+		process.env.CLINE_CAPTURE_WIRE = "true";
+		process.env.CLINE_CAPTURE_DIR = captureDir;
+		const customFetch = vi.fn(
+			async () => new Response("ok"),
+		) as unknown as typeof fetch;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { runId: "run-wire", iteration: 3 },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(config.fetch).not.toBe(customFetch);
+		await config.fetch?.("https://example.test/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] }),
+		});
+
+		expect(customFetch).toHaveBeenCalledOnce();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		const records = readCaptureRecords(captureDir);
+		expect(records.map((record) => record.captureStage)).toEqual([
+			"ai_sdk_prompt",
+			"wire_request",
+		]);
+		expect(records[1]).toMatchObject({
+			captureStage: "wire_request",
+			correlation: {
+				runId: "run-wire",
+				iteration: 3,
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+			},
+			summary: {
+				messages: {
+					messageCount: 1,
+					roleCounts: { user: 1 },
+					messages: [
+						expect.objectContaining({
+							index: 0,
+							role: "user",
+							sha256: expect.any(String),
+						}),
+					],
+				},
+			},
+		});
+	});
+
+	it("increments capture attempts instead of overwriting repeated wire requests", async () => {
+		const captureDir = mkdtempSync(join(tmpdir(), "llms-wire-attempts-"));
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "summary";
+		process.env.CLINE_CAPTURE_WIRE = "true";
+		process.env.CLINE_CAPTURE_DIR = captureDir;
+		const customFetch = vi.fn(
+			async () => new Response("ok"),
+		) as unknown as typeof fetch;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{ providerId: "openrouter", apiKey: "test-key", fetch: customFetch },
+			],
+		});
+
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { captureId: "cap-repeat", runId: "run-repeat" },
+			}),
+		);
+
+		const config = openaiCompatibleFactorySpy.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		await config.fetch?.("https://example.test/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({ messages: [{ role: "user", content: "first" }] }),
+		});
+		await config.fetch?.("https://example.test/v1/chat/completions", {
+			method: "POST",
+			body: JSON.stringify({ messages: [{ role: "user", content: "second" }] }),
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(
+			readdirSync(captureDir)
+				.filter((file) => file.endsWith(".provider-request.json"))
+				.sort(),
+		).toEqual([
+			"cap-repeat.ai_sdk_prompt.1.provider-request.json",
+			"cap-repeat.wire_request.1.provider-request.json",
+			"cap-repeat.wire_request.2.provider-request.json",
+		]);
+		const records = readCaptureRecords(captureDir);
+		expect(records.map((record) => record.attempt)).toEqual([1, 1, 2]);
+	});
+
+	it("prunes old capture files unless cleanup is disabled", async () => {
+		const captureDir = mkdtempSync(join(tmpdir(), "llms-capture-cleanup-"));
+		const oldFile = join(
+			captureDir,
+			"old.ai_sdk_prompt.1.provider-request.json",
+		);
+		writeFileSync(oldFile, "{}\n", { mode: 0o600 });
+		const oldDate = new Date(Date.now() - 48 * 60 * 60 * 1000);
+		utimesSync(oldFile, oldDate, oldDate);
+		process.env.CLINE_CAPTURE_PROVIDER_REQUEST = "summary";
+		process.env.CLINE_CAPTURE_DIR = captureDir;
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([{ type: "finish", finishReason: "stop" }]),
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [{ providerId: "openrouter", apiKey: "test-key" }],
+		});
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { captureId: "cap-cleanup-on" },
+			}),
+		);
+
+		expect(readdirSync(captureDir)).not.toContain(
+			"old.ai_sdk_prompt.1.provider-request.json",
+		);
+
+		const keepDir = mkdtempSync(join(tmpdir(), "llms-capture-keep-"));
+		const keepFile = join(keepDir, "old.ai_sdk_prompt.1.provider-request.json");
+		writeFileSync(keepFile, "{}\n", { mode: 0o600 });
+		utimesSync(keepFile, oldDate, oldDate);
+		process.env.CLINE_CAPTURE_DIR = keepDir;
+		process.env.CLINE_CAPTURE_CLEANUP = "off";
+		await collect(
+			await gateway.stream({
+				providerId: "openrouter",
+				modelId: "anthropic/claude-test",
+				messages: baseMessages,
+				metadata: { captureId: "cap-cleanup-off" },
+			}),
+		);
+
+		expect(readdirSync(keepDir)).toContain(
+			"old.ai_sdk_prompt.1.provider-request.json",
+		);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/gateway.ts b/sdk/packages/llms/src/providers/gateway.ts
new file mode 100644
index 0000000..a25a38a
--- /dev/null
+++ b/sdk/packages/llms/src/providers/gateway.ts
@@ -0,0 +1,324 @@
+import type {
+	AgentMessage,
+	AgentModel,
+	AgentModelEvent,
+	AgentModelRequest,
+	BasicLogger,
+	GatewayConfig,
+	GatewayModelDefinition,
+	GatewayModelHandleOptions,
+	GatewayModelSelection,
+	GatewayProviderRegistration,
+	GatewayStreamRequest,
+	ITelemetryService,
+} from "@cline/shared";
+import { estimateTokens } from "@cline/shared";
+import { toAsyncIterable } from "./async";
+import { BUILTIN_PROVIDER_REGISTRATIONS } from "./builtins-runtime";
+import { GatewayRegistry } from "./registry";
+
+export type * from "@cline/shared";
+
+const GATEWAY_OUTPUT_RESERVE_TOKENS = 1_024;
+
+function mergeRequestMetadata(
+	defaults: Record<string, unknown> | undefined,
+	request: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+	if (!defaults && !request) {
+		return undefined;
+	}
+	return {
+		...(defaults ?? {}),
+		...(request ?? {}),
+	};
+}
+
+export interface Gateway {
+	registerProvider(registration: GatewayProviderRegistration): this;
+	configureProvider(
+		config: NonNullable<GatewayConfig["providerConfigs"]>[number],
+	): this;
+	listProviders(): ReturnType<GatewayRegistry["listProviders"]>;
+	listModels(providerId?: string): ReturnType<GatewayRegistry["listModels"]>;
+	createAgentModel(
+		selection: GatewayModelSelection,
+		options?: GatewayModelHandleOptions,
+	): AgentModel;
+	stream(
+		request: GatewayStreamRequest,
+	): Promise<AsyncIterable<AgentModelEvent>>;
+}
+
+class GatewayModelAdapter implements AgentModel {
+	constructor(
+		private readonly gateway: DefaultGateway,
+		private readonly selection: GatewayModelSelection,
+		private readonly defaults: GatewayModelHandleOptions | undefined,
+	) {}
+
+	stream(request: AgentModelRequest): Promise<AsyncIterable<AgentModelEvent>> {
+		const requestedReasoning = request.options?.reasoning as
+			| {
+					enabled?: boolean;
+					effort?: "low" | "medium" | "high";
+					budgetTokens?: number;
+			  }
+			| undefined;
+		const thinking = request.options?.thinking;
+		const reasoningEffort = request.options?.reasoningEffort;
+		const thinkingBudgetTokens = request.options?.thinkingBudgetTokens;
+		const legacyEffort =
+			reasoningEffort === "low" ||
+			reasoningEffort === "medium" ||
+			reasoningEffort === "high"
+				? reasoningEffort
+				: undefined;
+		const legacyReasoning:
+			| {
+					enabled?: boolean;
+					effort?: "low" | "medium" | "high";
+					budgetTokens?: number;
+			  }
+			| undefined =
+			typeof thinking === "boolean" ||
+			legacyEffort !== undefined ||
+			typeof thinkingBudgetTokens === "number"
+				? {
+						enabled: typeof thinking === "boolean" ? thinking : undefined,
+						effort: legacyEffort,
+						budgetTokens:
+							typeof thinkingBudgetTokens === "number"
+								? thinkingBudgetTokens
+								: undefined,
+					}
+				: undefined;
+		return this.gateway.stream({
+			providerId: this.selection.providerId,
+			modelId: this.selection.modelId ?? "",
+			systemPrompt: request.systemPrompt,
+			messages: request.messages,
+			tools: this.defaults?.tools ?? request.tools,
+			temperature:
+				(request.options?.temperature as number | undefined) ??
+				this.defaults?.temperature,
+			maxTokens:
+				(request.options?.maxTokens as number | undefined) ??
+				this.defaults?.maxTokens,
+			metadata: mergeRequestMetadata(
+				this.defaults?.metadata,
+				request.options?.metadata as Record<string, unknown> | undefined,
+			),
+			reasoning:
+				requestedReasoning ?? legacyReasoning ?? this.defaults?.reasoning,
+			signal: request.signal ?? this.defaults?.signal,
+		});
+	}
+}
+
+function isPositiveFiniteNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function safeStringify(value: unknown): string {
+	const seen = new WeakSet<object>();
+	try {
+		return (
+			JSON.stringify(value, (_key, nestedValue: unknown) => {
+				if (typeof nestedValue === "bigint") {
+					return nestedValue.toString();
+				}
+				if (typeof nestedValue !== "object" || nestedValue === null) {
+					return nestedValue;
+				}
+				if (seen.has(nestedValue)) {
+					return "[Circular]";
+				}
+				seen.add(nestedValue);
+				return nestedValue;
+			}) ?? ""
+		);
+	} catch {
+		return String(value ?? "");
+	}
+}
+
+export function estimateRequestInputTokens(
+	request: Pick<GatewayStreamRequest, "systemPrompt" | "messages" | "tools">,
+): number {
+	let serialized: string;
+	try {
+		serialized = JSON.stringify({
+			systemPrompt: request.systemPrompt,
+			messages: request.messages,
+			tools: request.tools,
+		});
+	} catch {
+		serialized = [
+			safeStringify(request.systemPrompt),
+			safeStringify(request.messages as readonly AgentMessage[]),
+			safeStringify(request.tools),
+		].join("\n");
+	}
+	// This deliberately over-estimates a little so the context cap leaves room
+	// for provider formatting, tool schema overhead, and tokenizer drift.
+	return estimateTokens(serialized.length);
+}
+
+export function resolveGatewayRequestMaxTokens(input: {
+	requestedMaxTokens?: number;
+	model: Pick<GatewayModelDefinition, "contextWindow" | "maxOutputTokens">;
+	estimatedInputTokens: number;
+	outputReserveTokens?: number;
+	onContextOverflow?: (details: {
+		contextWindow: number;
+		estimatedInputTokens: number;
+		reserveTokens: number;
+	}) => void;
+}): number | undefined {
+	if (!isPositiveFiniteNumber(input.requestedMaxTokens)) {
+		return undefined;
+	}
+
+	const caps: number[] = [Math.floor(input.requestedMaxTokens)];
+
+	if (isPositiveFiniteNumber(input.model.maxOutputTokens)) {
+		caps.push(Math.floor(input.model.maxOutputTokens));
+	}
+
+	if (isPositiveFiniteNumber(input.model.contextWindow)) {
+		const reserveTokens =
+			input.outputReserveTokens ?? GATEWAY_OUTPUT_RESERVE_TOKENS;
+		const remainingContext =
+			input.model.contextWindow - input.estimatedInputTokens - reserveTokens;
+		if (remainingContext <= 0) {
+			input.onContextOverflow?.({
+				contextWindow: input.model.contextWindow,
+				estimatedInputTokens: input.estimatedInputTokens,
+				reserveTokens,
+			});
+			return undefined;
+		}
+		caps.push(Math.floor(remainingContext));
+	}
+
+	if (caps.length === 0) {
+		return undefined;
+	}
+
+	return Math.max(1, Math.floor(Math.min(...caps)));
+}
+
+export class DefaultGateway implements Gateway {
+	private readonly registry: GatewayRegistry;
+	private readonly logger: BasicLogger | undefined;
+	private readonly telemetry: ITelemetryService | undefined;
+
+	constructor(config: GatewayConfig = {}) {
+		this.registry = new GatewayRegistry(config.fetch);
+		this.logger = config.logger;
+		this.telemetry = config.telemetry;
+
+		if (config.builtins !== false) {
+			const builtins = new Set(
+				config.builtins ??
+					BUILTIN_PROVIDER_REGISTRATIONS.map(
+						(provider) => provider.manifest.id,
+					),
+			);
+			for (const builtin of BUILTIN_PROVIDER_REGISTRATIONS) {
+				if (builtins.has(builtin.manifest.id)) {
+					this.registry.registerProvider(builtin);
+				}
+			}
+		}
+
+		for (const provider of config.providers ?? []) {
+			this.registry.registerProvider(provider);
+		}
+
+		for (const providerConfig of config.providerConfigs ?? []) {
+			this.registry.configureProvider(providerConfig);
+		}
+	}
+
+	registerProvider(registration: GatewayProviderRegistration): this {
+		this.registry.registerProvider(registration);
+		return this;
+	}
+
+	configureProvider(
+		config: NonNullable<GatewayConfig["providerConfigs"]>[number],
+	): this {
+		this.registry.configureProvider(config);
+		return this;
+	}
+
+	listProviders() {
+		return this.registry.listProviders();
+	}
+
+	listModels(providerId?: string) {
+		return this.registry.listModels(providerId);
+	}
+
+	createAgentModel(
+		selection: GatewayModelSelection,
+		options?: GatewayModelHandleOptions,
+	): AgentModel {
+		return new GatewayModelAdapter(this, selection, options);
+	}
+
+	async stream(
+		request: GatewayStreamRequest,
+	): Promise<AsyncIterable<AgentModelEvent>> {
+		const resolved = this.registry.resolveModel({
+			providerId: request.providerId,
+			modelId: request.modelId || undefined,
+		});
+		const providerRecord = await this.registry.createProvider(
+			request.providerId,
+		);
+		const provider = await providerRecord.createProvider(providerRecord.config);
+		const maxTokens = isPositiveFiniteNumber(request.maxTokens)
+			? resolveGatewayRequestMaxTokens({
+					requestedMaxTokens: request.maxTokens,
+					model: resolved.model,
+					estimatedInputTokens: estimateRequestInputTokens(request),
+					onContextOverflow: (details) => {
+						this.logger?.log(
+							"Estimated prompt tokens exceed model context window",
+							{
+								severity: "warn",
+								providerId: resolved.provider.id,
+								modelId: resolved.model.id,
+								...details,
+							},
+						);
+					},
+				})
+			: undefined;
+		const stream = await provider.stream(
+			{
+				...request,
+				modelId: resolved.model.id,
+				providerId: resolved.provider.id,
+				maxTokens,
+			},
+			{
+				provider: resolved.provider,
+				model: resolved.model,
+				config: providerRecord.config,
+				signal: request.signal,
+				logger: this.logger,
+				telemetry: this.telemetry,
+			},
+		);
+
+		return toAsyncIterable(stream);
+	}
+}
+
+export function createGateway(config?: GatewayConfig): DefaultGateway {
+	return new DefaultGateway(config);
+}
diff --git a/sdk/packages/llms/src/providers/handler.ts b/sdk/packages/llms/src/providers/handler.ts
new file mode 100644
index 0000000..b22e4de
--- /dev/null
+++ b/sdk/packages/llms/src/providers/handler.ts
@@ -0,0 +1,91 @@
+/**
+ * Handler Interface Types
+ *
+ * Core interfaces that all provider handlers must implement.
+ */
+
+import type { Message, ModelInfo, ToolDefinition } from "@cline/shared";
+import type { ApiStream, ApiStreamUsageChunk } from "./stream";
+
+/**
+ * Model information returned by handlers
+ */
+export interface HandlerModelInfo {
+	/** Model identifier */
+	id: string;
+	/** Model capabilities and pricing info */
+	info: ModelInfo;
+}
+
+/**
+ * Core API Handler interface
+ *
+ * All providers must implement this interface.
+ */
+export interface ApiHandler {
+	/**
+	 * Convert Cline messages into provider-specific message format
+	 *
+	 * @param systemPrompt - The system prompt to use
+	 * @param messages - Conversation history
+	 * @returns Provider-specific messages payload
+	 */
+	getMessages(systemPrompt: string, messages: Message[]): unknown;
+
+	/**
+	 * Create a streaming message completion
+	 *
+	 * @param systemPrompt - The system prompt to use
+	 * @param messages - Conversation history
+	 * @param tools - Optional tool definitions for native tool calling
+	 * @returns An async generator yielding stream chunks
+	 */
+	createMessage(
+		systemPrompt: string,
+		messages: Message[],
+		tools?: ToolDefinition[],
+	): ApiStream;
+
+	/**
+	 * Get the current model configuration
+	 */
+	getModel(): HandlerModelInfo;
+
+	/**
+	 * Get usage information for the last API call (optional)
+	 * Some providers can fetch this from a separate endpoint
+	 */
+	getApiStreamUsage?(): Promise<ApiStreamUsageChunk | undefined>;
+
+	/**
+	 * Abort the current request (optional)
+	 */
+	abort?(): void;
+
+	/**
+	 * Update the abort signal used for subsequent requests (optional).
+	 */
+	setAbortSignal?(signal: AbortSignal | undefined): void;
+}
+
+/**
+ * Handler for simple single-turn completions
+ */
+export interface SingleCompletionHandler {
+	/**
+	 * Complete a single prompt without streaming
+	 */
+	completePrompt(prompt: string): Promise<string>;
+}
+
+/**
+ * Factory function type for creating handlers
+ */
+export type HandlerFactory<TConfig = unknown> = (config: TConfig) => ApiHandler;
+
+/**
+ * Async factory for lazy-loaded handlers
+ */
+export type LazyHandlerFactory<TConfig = unknown> = (
+	config: TConfig,
+) => Promise<ApiHandler>;
diff --git a/sdk/packages/llms/src/providers/http.ts b/sdk/packages/llms/src/providers/http.ts
new file mode 100644
index 0000000..d302e2a
--- /dev/null
+++ b/sdk/packages/llms/src/providers/http.ts
@@ -0,0 +1,121 @@
+import type { GatewayProviderSettings } from "@cline/shared";
+
+export function ensureFetch(fetchImpl?: typeof fetch): typeof fetch {
+	const resolved = fetchImpl ?? globalThis.fetch;
+	if (!resolved) {
+		throw new Error(
+			"No fetch implementation is available. Pass one in the gateway or provider config.",
+		);
+	}
+	return resolved;
+}
+
+export async function resolveApiKey(
+	settings: GatewayProviderSettings,
+): Promise<string | undefined> {
+	const explicitApiKey = settings.apiKey?.trim();
+	if (explicitApiKey) {
+		return explicitApiKey;
+	}
+
+	const resolvedApiKey = await settings.apiKeyResolver?.();
+	const trimmedResolvedApiKey = resolvedApiKey?.trim();
+	if (trimmedResolvedApiKey) {
+		return trimmedResolvedApiKey;
+	}
+
+	for (const key of settings.apiKeyEnv ?? []) {
+		const value = readEnv(key);
+		if (value) {
+			return value;
+		}
+	}
+
+	return undefined;
+}
+
+export async function fetchJson(
+	url: string,
+	init: RequestInit,
+	options: {
+		fetch: typeof fetch;
+		timeoutMs?: number;
+		signal?: AbortSignal;
+	},
+): Promise<unknown> {
+	const controller = new AbortController();
+	const signal = mergeSignals(options.signal, controller.signal);
+	const timeoutMs = options.timeoutMs ?? 30_000;
+	const timeout =
+		timeoutMs > 0
+			? setTimeout(
+					() => controller.abort(new Error("Request timed out")),
+					timeoutMs,
+				)
+			: undefined;
+
+	try {
+		const response = await options.fetch(url, { ...init, signal });
+		const text = await response.text();
+		const payload = text ? (JSON.parse(text) as unknown) : undefined;
+
+		if (!response.ok) {
+			const message =
+				typeof payload === "object" && payload && "error" in payload
+					? JSON.stringify((payload as { error: unknown }).error)
+					: text || `${response.status} ${response.statusText}`;
+			throw new Error(`Gateway request failed: ${message}`);
+		}
+
+		return payload;
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+function mergeSignals(
+	first: AbortSignal | undefined,
+	second: AbortSignal,
+): AbortSignal {
+	if (!first) {
+		return second;
+	}
+
+	if (first.aborted) {
+		second.throwIfAborted?.();
+		return first;
+	}
+
+	const controller = new AbortController();
+	const abort = (event?: Event) => {
+		const target = event?.target as AbortSignal | null;
+		controller.abort(target?.reason);
+	};
+
+	first.addEventListener("abort", abort, { once: true });
+	second.addEventListener("abort", abort, { once: true });
+	return controller.signal;
+}
+
+export function compactObject<T extends Record<string, unknown>>(value: T): T {
+	return Object.fromEntries(
+		Object.entries(value).filter(([, entry]) => entry !== undefined),
+	) as T;
+}
+
+function readEnv(key: string): string | undefined {
+	const env = globalThis.process?.env;
+	if (!env) {
+		return undefined;
+	}
+
+	const value = env[key];
+	if (typeof value !== "string") {
+		return undefined;
+	}
+
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
diff --git a/sdk/packages/llms/src/providers/ids.test.ts b/sdk/packages/llms/src/providers/ids.test.ts
new file mode 100644
index 0000000..72a0002
--- /dev/null
+++ b/sdk/packages/llms/src/providers/ids.test.ts
@@ -0,0 +1,219 @@
+import { describe, expect, it } from "vitest";
+import {
+	createOpenAICompatibleProvider,
+	createOpenAIProvider,
+	createSapAiCoreProvider,
+} from "./ai-sdk";
+import { BUILTIN_PROVIDER_REGISTRATIONS } from "./builtins-runtime";
+import { createGateway } from "./gateway";
+import { BUILT_IN_PROVIDER_IDS, normalizeProviderId } from "./ids";
+import {
+	getModelsForProvider,
+	getProvider,
+	getProviderIds,
+} from "./model-registry";
+
+describe("provider-ids", () => {
+	it("keeps built-in provider ids aligned with model registry loaders", () => {
+		const registryProviderIds = new Set(getProviderIds());
+		for (const providerId of BUILT_IN_PROVIDER_IDS) {
+			expect(registryProviderIds.has(providerId)).toBe(true);
+		}
+	});
+
+	it("registers v0 as a built-in provider with generated catalog models", async () => {
+		await expect(getProvider("v0")).resolves.toMatchObject({
+			id: "v0",
+			baseUrl: "https://api.v0.dev/v1",
+			defaultModelId: "v0-1.5-md",
+			client: "openai-compatible",
+		});
+
+		const models = await getModelsForProvider("v0");
+		expect(Object.keys(models).sort()).toEqual([
+			"v0-1.0-md",
+			"v0-1.5-lg",
+			"v0-1.5-md",
+		]);
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "v0",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createOpenAICompatibleProvider,
+		});
+	});
+
+	it("uses openai-compatible as the OpenAI Compatible built-in provider", async () => {
+		expect(normalizeProviderId("openai")).toBe("openai-compatible");
+		expect(BUILT_IN_PROVIDER_IDS).not.toContain("openai");
+		expect(BUILT_IN_PROVIDER_IDS).toContain("openai-compatible");
+
+		await expect(getProvider("openai-compatible")).resolves.toMatchObject({
+			id: "openai-compatible",
+			name: "OpenAI Compatible",
+			baseUrl: "https://api.openai.com/v1",
+			defaultModelId: "gpt-4o",
+			client: "openai-compatible",
+		});
+		await expect(
+			getModelsForProvider("openai-compatible"),
+		).resolves.toMatchObject({
+			"gpt-4o": {
+				id: "gpt-4o",
+				contextWindow: 128_000,
+				maxInputTokens: 128_000,
+			},
+		});
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "openai-compatible",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createOpenAICompatibleProvider,
+		});
+
+		const gateway = createGateway({
+			providerConfigs: [
+				{
+					providerId: "openai-compatible",
+					apiKey: "test-key",
+					baseUrl: "https://gateway.example.invalid/v1",
+					models: [{ id: "gpt-oss-120b", name: "GPT OSS 120B" }],
+				},
+			],
+		});
+		expect(gateway.listModels("openai-compatible")).toContainEqual(
+			expect.objectContaining({
+				id: "gpt-oss-120b",
+				providerId: "openai-compatible",
+			}),
+		);
+	});
+
+	it("registers ClinePass as a distinct Cline-compatible built-in provider", async () => {
+		expect(BUILT_IN_PROVIDER_IDS).toContain("cline-pass");
+		const models = await getModelsForProvider("cline-pass");
+		const provider = await getProvider("cline-pass");
+
+		expect(provider).toMatchObject({
+			id: "cline-pass",
+			name: "ClinePass",
+			client: "openai-compatible",
+		});
+		expect(models).toHaveProperty(provider?.defaultModelId ?? "");
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "cline-pass",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createOpenAICompatibleProvider,
+		});
+	});
+
+	it("registers Poolside as an OpenAI-compatible built-in provider", async () => {
+		expect(BUILT_IN_PROVIDER_IDS).toContain("poolside");
+
+		await expect(getProvider("poolside")).resolves.toMatchObject({
+			id: "poolside",
+			name: "Poolside",
+			baseUrl: "https://inference.poolside.ai/v1",
+			defaultModelId: "poolside/laguna-m.1",
+			client: "openai-compatible",
+		});
+		const models = await getModelsForProvider("poolside");
+		expect(Object.hasOwn(models, "poolside/laguna-m.1")).toBe(true);
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "poolside",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createOpenAICompatibleProvider,
+		});
+	});
+
+	it("routes Responses API built-ins through the OpenAI provider factory", async () => {
+		const provider = await getProvider("litellm");
+		expect(provider).toMatchObject({
+			id: "litellm",
+			protocol: "openai-responses",
+			client: "openai",
+		});
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "litellm",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createOpenAIProvider,
+		});
+	});
+
+	it("registers Xiaomi as an OpenAI-compatible built-in provider", async () => {
+		await expect(getProvider("xiaomi")).resolves.toMatchObject({
+			id: "xiaomi",
+			baseUrl: "https://api.xiaomimimo.com/v1",
+			defaultModelId: "mimo-v2.5",
+			client: "openai-compatible",
+		});
+
+		await expect(getModelsForProvider("xiaomi")).resolves.toHaveProperty(
+			"mimo-v2.5",
+		);
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "xiaomi",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createOpenAICompatibleProvider,
+		});
+	});
+
+	it("registers Tencent TokenHub as an OpenAI-compatible built-in provider", async () => {
+		await expect(getProvider("tencent-tokenhub")).resolves.toMatchObject({
+			id: "tencent-tokenhub",
+			baseUrl: "https://tokenhub.tencentmaas.com/v1",
+			defaultModelId: "hy3-preview",
+			client: "openai-compatible",
+		});
+
+		await expect(
+			getModelsForProvider("tencent-tokenhub"),
+		).resolves.toHaveProperty("hy3-preview");
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "tencent-tokenhub",
+		);
+		expect(registration).toBeDefined();
+		await expect(registration?.loadProvider()).resolves.toMatchObject({
+			createProvider: createOpenAICompatibleProvider,
+		});
+	});
+
+	it("registers Z.AI Coding Plan with an accessible coding-plan default", async () => {
+		await expect(getProvider("zai-coding-plan")).resolves.toMatchObject({
+			id: "zai-coding-plan",
+			baseUrl: "https://api.z.ai/api/coding/paas/v4",
+			defaultModelId: "glm-5.2",
+			client: "openai-compatible",
+		});
+
+		const models = await getModelsForProvider("zai-coding-plan");
+		expect(Object.hasOwn(models, "glm-5.2")).toBe(true);
+	});
+
+	it("routes SAP AI Core through the SAP AI SDK provider factory", async () => {
+		await expect(getProvider("sapaicore")).resolves.toMatchObject({
+			id: "sapaicore",
+			name: "SAP AI Core",
+			client: "ai-sdk-community",
+			defaultModelId: "anthropic--claude-3.5-sonnet",
+		});
+
+		const registration = BUILTIN_PROVIDER_REGISTRATIONS.find(
+			(item) => item.manifest.id === "sapaicore",
+		);
+		await expect(registration?.loadProvider?.()).resolves.toMatchObject({
+			createProvider: createSapAiCoreProvider,
+		});
+	});
+});
diff --git a/sdk/packages/llms/src/providers/ids.ts b/sdk/packages/llms/src/providers/ids.ts
new file mode 100644
index 0000000..a92f622
--- /dev/null
+++ b/sdk/packages/llms/src/providers/ids.ts
@@ -0,0 +1,97 @@
+/**
+ * Built-in provider IDs
+ *
+ * Single source of truth for all built-in provider identifiers.
+ * Use BUILT_IN_PROVIDER_IDS for runtime operations (validation, iteration)
+ * Use BuiltInProviderId type for compile-time type safety
+ */
+export enum BUILT_IN_PROVIDER {
+	// First-party
+	ANTHROPIC = "anthropic",
+	CLAUDE_CODE = "claude-code",
+	CLINE = "cline",
+	CLINE_PASS = "cline-pass",
+	// OpenAI variants
+	OPENAI_COMPATIBLE = "openai-compatible",
+	OPENAI_NATIVE = "openai-native",
+	OPENAI_CODEX = "openai-codex",
+	OPENAI_CODEX_CLI = "openai-codex-cli",
+	// CLI / Subscription-based providers
+	OPENCODE = "opencode",
+	// Cloud providers
+	BEDROCK = "bedrock",
+	VERTEX = "vertex",
+	GEMINI = "gemini",
+	// Local/self-hosted
+	OLLAMA = "ollama",
+	LMSTUDIO = "lmstudio",
+	// OpenAI-compatible
+	DEEPSEEK = "deepseek",
+	XAI = "xai",
+	TOGETHER = "together",
+	FIREWORKS = "fireworks",
+	GROQ = "groq",
+	POOLSIDE = "poolside",
+	CEREBRAS = "cerebras",
+	SAMBANOVA = "sambanova",
+	NEBIUS = "nebius",
+	BASETEN = "baseten",
+	REQUESTY = "requesty",
+	LITELLM = "litellm",
+	HUGGINGFACE = "huggingface",
+	VERCEL_AI_GATEWAY = "vercel-ai-gateway",
+	V0 = "v0",
+	AIHUBMIX = "aihubmix",
+	HICAP = "hicap",
+	NOUS_RESEARCH = "nousResearch",
+	HUAWEI_CLOUD_MAAS = "huawei-cloud-maas",
+	WANDB = "wandb",
+	XIAOMI = "xiaomi",
+	TENCENT_TOKENHUB = "tencent-tokenhub",
+	KILO = "kilo",
+	ZAI = "zai",
+	ZAI_CODING_PLAN = "zai-coding-plan",
+	// Regional/specialized
+	QWEN = "qwen",
+	QWEN_CODE = "qwen-code",
+	DOUBAO = "doubao",
+	MISTRAL = "mistral",
+	MOONSHOT = "moonshot",
+	ASKSAGE = "asksage",
+	MINIMAX = "minimax",
+	DIFY = "dify",
+	OCA = "oca",
+	SAPAICORE = "sapaicore",
+	// Aggregators
+	OPENROUTER = "openrouter",
+}
+
+/**
+ * Provider ID aliases normalized to canonical built-in IDs.
+ *
+ * Keep this map as the single source of truth for alias handling.
+ */
+export const PROVIDER_ID_ALIASES: Record<string, BUILT_IN_PROVIDER> = {
+	openai: BUILT_IN_PROVIDER.OPENAI_COMPATIBLE,
+	togetherai: BUILT_IN_PROVIDER.TOGETHER,
+	"sap-ai-core": BUILT_IN_PROVIDER.SAPAICORE,
+};
+
+export const BUILT_IN_PROVIDER_IDS = Object.values(BUILT_IN_PROVIDER) as [
+	BUILT_IN_PROVIDER,
+	...BUILT_IN_PROVIDER[],
+];
+
+/** Type derived from the array - use for type annotations */
+export type BuiltInProviderId = (typeof BUILT_IN_PROVIDER_IDS)[number];
+
+/** Check if a string is a valid built-in provider ID */
+export function isBuiltInProviderId(id: string): id is BuiltInProviderId {
+	return BUILT_IN_PROVIDER_IDS.includes(id as BuiltInProviderId);
+}
+
+/** Normalize provider aliases to canonical IDs */
+export function normalizeProviderId(providerId: string): string {
+	const normalized = providerId.trim();
+	return PROVIDER_ID_ALIASES[normalized] ?? normalized;
+}
diff --git a/sdk/packages/llms/src/providers/messages.ts b/sdk/packages/llms/src/providers/messages.ts
new file mode 100644
index 0000000..0a801ef
--- /dev/null
+++ b/sdk/packages/llms/src/providers/messages.ts
@@ -0,0 +1,17 @@
+/**
+ * Message Types — re-exported from @cline/shared
+ */
+export type {
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	MessageRole,
+	MessageWithMetadata,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolDefinition,
+	ToolResultContent,
+	ToolUseContent,
+} from "@cline/shared";
diff --git a/sdk/packages/llms/src/providers/middleware/split-tool-images.test.ts b/sdk/packages/llms/src/providers/middleware/split-tool-images.test.ts
new file mode 100644
index 0000000..d09970a
--- /dev/null
+++ b/sdk/packages/llms/src/providers/middleware/split-tool-images.test.ts
@@ -0,0 +1,825 @@
+import type {
+	LanguageModelV3CallOptions,
+	LanguageModelV3Message,
+} from "@ai-sdk/provider";
+import { describe, expect, it } from "vitest";
+import {
+	rewritePromptToolImages,
+	splitToolImagesMiddleware,
+} from "./split-tool-images";
+
+const PLACEHOLDER = "(see following user message for image)";
+const OMITTED_PLACEHOLDER = "[media omitted: invalid or exceeds size limit]";
+const imageData = (byteLength: number, fill = 1) =>
+	Buffer.alloc(byteLength, fill).toString("base64");
+
+describe("rewritePromptToolImages", () => {
+	it("leaves prompts without tool messages unchanged", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{ role: "system", content: "you are a helpful assistant" },
+			{
+				role: "user",
+				content: [{ type: "text", text: "what is 2+2?" }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "4" }],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(false);
+		// When nothing mutates, the implementation re-builds the array.
+		// What matters is that the contents are equivalent.
+		expect(out.prompt).toEqual(prompt);
+	});
+
+	it("leaves text-only tool messages unchanged", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: { type: "text", value: "no images here" },
+					},
+					{
+						type: "tool-result",
+						toolCallId: "call_2",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [{ type: "text", text: "still no images" }],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(false);
+		expect(out.prompt).toHaveLength(1);
+	});
+
+	it("splits image-data parts into a synthetic user message", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "Successfully read image" },
+								{
+									type: "image-data",
+									data: "QkFTRTY0SU1BR0VCWVRFUw==",
+									mediaType: "image/jpeg",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(2);
+
+		const [toolMsg, syntheticUser] = out.prompt;
+		expect(toolMsg.role).toBe("tool");
+		// Tool-result should now have placeholder text instead of image-data.
+		const toolResult = (
+			toolMsg as Extract<LanguageModelV3Message, { role: "tool" }>
+		).content[0];
+		if (toolResult.type !== "tool-result") {
+			throw new Error("expected tool-result");
+		}
+		expect(toolResult.output).toEqual({
+			type: "content",
+			value: [
+				{ type: "text", text: "Successfully read image" },
+				{ type: "text", text: PLACEHOLDER },
+			],
+		});
+
+		// Synthetic user message carries the image as a FilePart.
+		expect(syntheticUser).toEqual({
+			role: "user",
+			content: [
+				{
+					type: "file",
+					data: "QkFTRTY0SU1BR0VCWVRFUw==",
+					mediaType: "image/jpeg",
+				},
+			],
+		});
+	});
+
+	it("preserves filename and provider options on file-data parts", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "file-data",
+									data: "QkFTRTY0UERGQllURVM=",
+									mediaType: "application/pdf",
+									filename: "spec.pdf",
+									providerOptions: {
+										openai: { detail: "high" },
+									},
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt[1]).toEqual({
+			role: "user",
+			content: [
+				{
+					type: "file",
+					data: "QkFTRTY0UERGQllURVM=",
+					mediaType: "application/pdf",
+					filename: "spec.pdf",
+					providerOptions: {
+						openai: { detail: "high" },
+					},
+				},
+			],
+		});
+	});
+
+	it("converts image-url parts to file parts", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "image-url", url: "https://example.com/cat.png" },
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt[1]).toEqual({
+			role: "user",
+			content: [
+				{
+					type: "file",
+					data: "https://example.com/cat.png",
+					mediaType: "image/*",
+				},
+			],
+		});
+	});
+
+	it("omits image-url parts that exceed the aggregate media budget", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "image-url", url: "https://example.com/a.png" },
+								{ type: "image-url", url: "https://example.com/b.png" },
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(2);
+		expect(out.prompt[1]).toEqual({
+			role: "user",
+			content: [
+				{
+					type: "file",
+					data: "https://example.com/a.png",
+					mediaType: "image/*",
+				},
+			],
+		});
+		expect(JSON.stringify(out.prompt[0])).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(out.prompt[0])).not.toContain(
+			"https://example.com/b.png",
+		);
+	});
+
+	it("omits invalid data URL image-url parts instead of splitting them", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "image-url",
+									url: "data:image/png;base64,not-base64",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(1);
+		expect(JSON.stringify(out.prompt[0])).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(out.prompt[0])).not.toContain("not-base64");
+	});
+
+	it("omits unsupported uppercase data URL image-url parts before splitting", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "image-url",
+									url: "DATA:image/svg+xml;base64,PHN2Zz4=",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(1);
+		expect(JSON.stringify(out.prompt[0])).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(out.prompt[0])).not.toContain("PHN2Zz4=");
+	});
+
+	it("omits file-url parts that exceed the aggregate media budget", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "file-url",
+									url: "https://example.com/a.pdf",
+								},
+								{
+									type: "file-url",
+									url: "https://example.com/b.pdf",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(2);
+		expect(out.prompt[1]).toEqual({
+			role: "user",
+			content: [
+				{
+					type: "file",
+					data: "https://example.com/a.pdf",
+					mediaType: "application/octet-stream",
+				},
+			],
+		});
+		expect(JSON.stringify(out.prompt[0])).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(out.prompt[0])).not.toContain(
+			"https://example.com/b.pdf",
+		);
+	});
+
+	it("omits malformed file-url data URLs instead of splitting them", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "file-url",
+									url: "data:application/pdf;base64,not-base64",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(1);
+		expect(JSON.stringify(out.prompt[0])).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(out.prompt[0])).not.toContain("not-base64");
+	});
+
+	it("omits oversized file-data parts instead of splitting them", () => {
+		const oversizedFile = "A".repeat(6 * 1024 * 1024);
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "file-data",
+									data: oversizedFile,
+									mediaType: "application/pdf",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(1);
+		expect(JSON.stringify(out.prompt[0])).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(out.prompt[0])).not.toContain(oversizedFile);
+	});
+
+	it("replaces invalid image-data with a text placeholder instead of splitting it", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "image-data",
+									data: "not-base64",
+									mediaType: "image/png",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(1);
+		const toolResult = (
+			out.prompt[0] as Extract<LanguageModelV3Message, { role: "tool" }>
+		).content[0];
+		if (toolResult.type !== "tool-result") {
+			throw new Error("expected tool-result");
+		}
+		expect(toolResult.output).toEqual({
+			type: "content",
+			value: [
+				{
+					type: "text",
+					text: "[media omitted: invalid or exceeds size limit]",
+				},
+			],
+		});
+	});
+
+	it("leaves image-file-id parts in place (no FilePart equivalent)", () => {
+		// image-file-id is an OpenAI-specific provider reference. It can't
+		// be expressed as a `LanguageModelV3FilePart`, so we leave it inside
+		// the tool-result. That path is already multimodal-aware and doesn't
+		// need the rewrite.
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "Successfully read image" },
+								{ type: "image-file-id", fileId: "file_abc" },
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(false);
+		const toolResult = (
+			out.prompt[0] as Extract<LanguageModelV3Message, { role: "tool" }>
+		).content[0];
+		if (toolResult.type !== "tool-result") {
+			throw new Error("expected tool-result");
+		}
+		// Output is unchanged when only image-file-id is present.
+		expect(toolResult.output).toEqual({
+			type: "content",
+			value: [
+				{ type: "text", text: "Successfully read image" },
+				{ type: "image-file-id", fileId: "file_abc" },
+			],
+		});
+	});
+
+	it("aggregates images from multiple tool-results in one tool message", () => {
+		// `read_files` with two paths produces a single `role:'tool'` message
+		// with two `tool-result` parts (or one tool-result with two images,
+		// depending on how the agent emits them). Either way, the rewritten
+		// user message should carry both images.
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "image 1" },
+								{
+									type: "image-data",
+									data: "QUFB",
+									mediaType: "image/jpeg",
+								},
+							],
+						},
+					},
+					{
+						type: "tool-result",
+						toolCallId: "call_2",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "image 2" },
+								{
+									type: "image-data",
+									data: "QkJC",
+									mediaType: "image/png",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(2);
+		expect(out.prompt[1]).toEqual({
+			role: "user",
+			content: [
+				{ type: "file", data: "QUFB", mediaType: "image/jpeg" },
+				{ type: "file", data: "QkJC", mediaType: "image/png" },
+			],
+		});
+	});
+
+	it("omits images that exceed the aggregate media budget in the split backstop", () => {
+		const firstImage = imageData(3_600_000, 1);
+		const secondImage = imageData(3_600_000, 2);
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "image 1" },
+								{
+									type: "image-data",
+									data: firstImage,
+									mediaType: "image/png",
+								},
+							],
+						},
+					},
+					{
+						type: "tool-result",
+						toolCallId: "call_2",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "image 2" },
+								{
+									type: "image-data",
+									data: secondImage,
+									mediaType: "image/png",
+								},
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		expect(out.prompt).toHaveLength(2);
+		expect(out.prompt[1]).toEqual({
+			role: "user",
+			content: [{ type: "file", data: firstImage, mediaType: "image/png" }],
+		});
+		const toolMessage = out.prompt[0];
+		if (toolMessage.role !== "tool") {
+			throw new Error("expected tool message");
+		}
+		expect(JSON.stringify(toolMessage)).toContain(OMITTED_PLACEHOLDER);
+		expect(JSON.stringify(toolMessage)).not.toContain(secondImage);
+	});
+
+	it("handles multiple separate tool messages in the same prompt", () => {
+		const prompt: LanguageModelV3Message[] = [
+			{
+				role: "user",
+				content: [{ type: "text", text: "show me both" }],
+			},
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						input: { paths: ["a.jpg"] },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "first" },
+								{ type: "image-data", data: "QUFB", mediaType: "image/jpeg" },
+							],
+						},
+					},
+				],
+			},
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_2",
+						toolName: "read_files",
+						input: { paths: ["b.jpg"] },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_2",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "second" },
+								{ type: "image-data", data: "QkJC", mediaType: "image/png" },
+							],
+						},
+					},
+				],
+			},
+		];
+
+		const out = rewritePromptToolImages(prompt);
+
+		expect(out.mutated).toBe(true);
+		// Original 5 + 2 synthetic user messages.
+		expect(out.prompt).toHaveLength(7);
+		expect(out.prompt[3].role).toBe("user");
+		expect(out.prompt[6].role).toBe("user");
+	});
+
+	it("does not mutate the input prompt array or its messages", () => {
+		const original: LanguageModelV3Message[] = [
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "before" },
+								{ type: "image-data", data: "QUFB", mediaType: "image/jpeg" },
+							],
+						},
+					},
+				],
+			},
+		];
+		const snapshot = JSON.parse(JSON.stringify(original));
+
+		rewritePromptToolImages(original);
+
+		expect(original).toEqual(snapshot);
+	});
+});
+
+describe("splitToolImagesMiddleware", () => {
+	it("has v3 specification version", () => {
+		expect(splitToolImagesMiddleware.specificationVersion).toBe("v3");
+	});
+
+	it("returns the same params object reference when no rewrite is needed", async () => {
+		const params: LanguageModelV3CallOptions = {
+			prompt: [
+				{
+					role: "user",
+					content: [{ type: "text", text: "hello" }],
+				},
+			],
+		};
+
+		const out = await splitToolImagesMiddleware.transformParams?.({
+			type: "stream",
+			params,
+			// `model` isn't used by this middleware; cast for the test.
+			model: undefined as never,
+		});
+
+		// Identity preserved means downstream sees the original CallOptions
+		// without an unnecessary clone.
+		expect(out).toBe(params);
+	});
+
+	it("returns transformed params with rewritten prompt when images are present", async () => {
+		const params: LanguageModelV3CallOptions = {
+			prompt: [
+				{
+					role: "tool",
+					content: [
+						{
+							type: "tool-result",
+							toolCallId: "call_1",
+							toolName: "read_files",
+							output: {
+								type: "content",
+								value: [
+									{ type: "text", text: "ok" },
+									{ type: "image-data", data: "QUFB", mediaType: "image/jpeg" },
+								],
+							},
+						},
+					],
+				},
+			],
+		};
+
+		const out = await splitToolImagesMiddleware.transformParams?.({
+			type: "stream",
+			params,
+			model: undefined as never,
+		});
+
+		expect(out).not.toBe(params);
+		expect(out?.prompt).toHaveLength(2);
+		expect(out?.prompt[1].role).toBe("user");
+	});
+
+	it("preserves call-options siblings (temperature, tools, etc.)", async () => {
+		const params: LanguageModelV3CallOptions = {
+			prompt: [
+				{
+					role: "tool",
+					content: [
+						{
+							type: "tool-result",
+							toolCallId: "call_1",
+							toolName: "read_files",
+							output: {
+								type: "content",
+								value: [
+									{ type: "image-data", data: "QUFB", mediaType: "image/jpeg" },
+								],
+							},
+						},
+					],
+				},
+			],
+			temperature: 0.7,
+			maxOutputTokens: 1000,
+		};
+
+		const out = await splitToolImagesMiddleware.transformParams?.({
+			type: "stream",
+			params,
+			model: undefined as never,
+		});
+
+		expect(out?.temperature).toBe(0.7);
+		expect(out?.maxOutputTokens).toBe(1000);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/middleware/split-tool-images.ts b/sdk/packages/llms/src/providers/middleware/split-tool-images.ts
new file mode 100644
index 0000000..1675339
--- /dev/null
+++ b/sdk/packages/llms/src/providers/middleware/split-tool-images.ts
@@ -0,0 +1,470 @@
+// LanguageModelV3 middleware that recovers image bytes from
+// `role:"tool"` messages whose content arrays the downstream chat-completions
+// converter would otherwise destroy.
+//
+// Background: AI SDK's `LanguageModelV3ToolResultOutput` of type `'content'`
+// may contain `image-data`, `image-url`, `file-data`, `file-url`, or
+// `image-file-id` parts. The OpenAI Chat Completions wire format does NOT
+// support multimodal tool messages — `role:"tool"` content must be a single
+// string. The `@ai-sdk/openai-compatible` chat-messages converter therefore
+// just `JSON.stringify`s the parts array. The image bytes survive as escaped
+// base64 inside a string, which the model treats as ~50KB of opaque text and
+// hallucinates the image's actual contents.
+//
+// This middleware operates on the typed `LanguageModelV3Prompt` BEFORE the
+// downstream converter runs. For every `role:"tool"` message containing
+// image/file parts inside a tool-result `output.type === 'content'` value,
+// it:
+//
+//   1. Replaces the media parts inside the tool-result with placeholder
+//      text parts: `(see following user message for image)`. The
+//      tool-result then carries only text — safe for any wire format.
+//   2. Inserts a synthetic `role:"user"` message right after the tool
+//      message, carrying the media parts as `LanguageModelV3FilePart`s.
+//
+// Because the synthetic user message is typed (not raw JSON), every
+// downstream converter — Chat Completions, Mistral, Anthropic, Bedrock,
+// etc. — translates it to its own native multimodal user-content shape
+// without further help.
+//
+// This pattern is documented in the OpenAI Chat Completions spec
+// (consecutive `user` messages are concatenated by the model) and is a
+// direct port of the proven wire pattern used by classic Cline's
+// `convertToOpenAiMessages` (see `src/core/api/transform/openai-format.ts`
+// in origin/main).
+//
+// Replaces fetch interceptor `vendors/openai-compatible-image-rewrite.ts`,
+// which did the same rewrite at the wire layer (post-converter). The
+// middleware approach is preferred because:
+//   * No JSON parse / restringify round-trip on every chat-completions
+//     request.
+//   * Works equally for any converter — `@ai-sdk/mistral` (which has its
+//     own chat-messages converter) was previously uncovered.
+//   * Decoupled from the AI SDK's wire-output shape: if the SDK ever
+//     changes how it serialises content arrays, this layer doesn't care.
+
+import type {
+	LanguageModelV3CallOptions,
+	LanguageModelV3FilePart,
+	LanguageModelV3Message,
+	LanguageModelV3Middleware,
+	LanguageModelV3TextPart,
+	LanguageModelV3ToolResultOutput,
+	LanguageModelV3ToolResultPart,
+} from "@ai-sdk/provider";
+import {
+	createMediaBudgetState,
+	DEFAULT_MAX_IMAGE_DECODED_BYTES,
+	DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+	IMAGE_OMITTED_PLACEHOLDER,
+	isCanonicalBase64,
+	type MediaBudgetState,
+	reserveImageMediaBytes,
+	validateAndReserveImageMedia,
+} from "@cline/shared";
+
+const IMAGE_PLACEHOLDER = "(see following user message for image)";
+
+type ContentOutput = Extract<
+	LanguageModelV3ToolResultOutput,
+	{ type: "content" }
+>;
+type ContentPart = ContentOutput["value"][number];
+
+function isMediaContentPart(part: ContentPart): part is Extract<
+	ContentPart,
+	{
+		type:
+			| "image-data"
+			| "image-url"
+			| "file-data"
+			| "file-url"
+			| "image-file-id";
+	}
+> {
+	switch (part.type) {
+		case "image-data":
+		case "image-url":
+		case "file-data":
+		case "file-url":
+		case "image-file-id":
+			return true;
+		default:
+			return false;
+	}
+}
+
+/**
+ * Convert a media content-part from a `ToolResultOutput` of type `'content'`
+ * into the equivalent `LanguageModelV3FilePart` for use in a user message.
+ * Returns `null` for `image-file-id` parts because `LanguageModelV3FilePart`
+ * has no provider-file-id slot — those parts are left in place inside the
+ * tool-result and pass through to the converter as-is. (Image-file-id is
+ * an OpenAI-specific reference; if a caller is using it they are already
+ * on a multimodal-aware path and don't need this rewrite.)
+ */
+function mediaPartToFilePart(
+	part: Extract<
+		ContentPart,
+		{
+			type:
+				| "image-data"
+				| "image-url"
+				| "file-data"
+				| "file-url"
+				| "image-file-id";
+		}
+	>,
+): LanguageModelV3FilePart | null {
+	switch (part.type) {
+		case "image-data":
+			return {
+				type: "file",
+				data: part.data,
+				mediaType: part.mediaType,
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "image-url":
+			return {
+				type: "file",
+				// FilePart.data accepts a URL or string. Pass the URL string;
+				// the converter will wire it through to e.g. `image_url.url`.
+				data: part.url,
+				// AI SDK requires a mediaType. We don't know the actual type
+				// from a URL, so fall back to a wildcard image type — the
+				// downstream converter (chat-completions) only needs the
+				// URL anyway.
+				mediaType: "image/*",
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "file-data":
+			return {
+				type: "file",
+				data: part.data,
+				mediaType: part.mediaType,
+				...(part.filename ? { filename: part.filename } : {}),
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "file-url":
+			return {
+				type: "file",
+				data: part.url,
+				mediaType: "application/octet-stream",
+				...(part.providerOptions
+					? { providerOptions: part.providerOptions }
+					: {}),
+			};
+		case "image-file-id":
+			// No FilePart equivalent — caller is on a path that already handles
+			// provider-side file references, so we leave the part in place.
+			return null;
+	}
+}
+
+interface SplitResult {
+	stripped: ContentOutput;
+	media: LanguageModelV3FilePart[];
+}
+
+function imageOmittedTextPart(): LanguageModelV3TextPart {
+	return {
+		type: "text",
+		text: IMAGE_OMITTED_PLACEHOLDER,
+	};
+}
+
+function reserveUnknownUrlMediaBudget(
+	url: string,
+	mediaState: MediaBudgetState,
+): boolean {
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return false;
+	}
+
+	if (parsed.protocol === "data:") {
+		const commaIndex = url.indexOf(",");
+		if (commaIndex === -1) {
+			return false;
+		}
+		const metadata = url.slice("data:".length, commaIndex).toLowerCase();
+		if (!metadata.endsWith(";base64")) {
+			return false;
+		}
+		const base64 = url.slice(commaIndex + 1);
+		if (!isCanonicalBase64(base64)) {
+			return false;
+		}
+		return (
+			reserveImageMediaBytes(
+				base64.length,
+				0,
+				{
+					maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+					maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+				},
+				mediaState,
+			) === null
+		);
+	}
+
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		return false;
+	}
+
+	// Remote URL byte size is unknown at formatting time, so charge the
+	// conservative per-image cap instead of letting URL media count as free.
+	return (
+		reserveImageMediaBytes(
+			DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+			0,
+			{
+				maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+				maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+			},
+			mediaState,
+		) === null
+	);
+}
+
+function isDataUrl(url: string): boolean {
+	try {
+		return new URL(url).protocol === "data:";
+	} catch {
+		return false;
+	}
+}
+
+function estimateMediaDataEncodedBytes(data: unknown): number {
+	if (typeof data === "string") {
+		return data.length;
+	}
+	if (data instanceof Uint8Array) {
+		return data.byteLength;
+	}
+	if (data instanceof ArrayBuffer) {
+		return data.byteLength;
+	}
+	return Number.POSITIVE_INFINITY;
+}
+
+function reserveGenericMediaDataBudget(
+	data: unknown,
+	mediaState: MediaBudgetState,
+): boolean {
+	return (
+		reserveImageMediaBytes(
+			estimateMediaDataEncodedBytes(data),
+			0,
+			{
+				maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+				maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+			},
+			mediaState,
+		) === null
+	);
+}
+
+/**
+ * Split a tool-result `output` of type `'content'` into:
+ *   - a `stripped` output where every media part is replaced by a
+ *     placeholder text part, and
+ *   - the list of media parts converted to `LanguageModelV3FilePart`.
+ *
+ * Returns `null` if the output isn't of type `'content'`, or if it doesn't
+ * carry any extractable media parts (in which case no rewrite is needed).
+ */
+function splitContentOutputMedia(
+	output: LanguageModelV3ToolResultOutput,
+	mediaState: MediaBudgetState,
+): SplitResult | null {
+	if (output.type !== "content") {
+		return null;
+	}
+	const media: LanguageModelV3FilePart[] = [];
+	const newValue: ContentOutput["value"] = [];
+	let mutated = false;
+	for (const part of output.value) {
+		if (!isMediaContentPart(part)) {
+			newValue.push(part);
+			continue;
+		}
+		let currentPart = part;
+		if (currentPart.type === "image-data") {
+			const validation = validateAndReserveImageMedia(
+				currentPart.mediaType,
+				currentPart.data,
+				{
+					maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+					maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+				},
+				mediaState,
+			);
+			if (!validation.ok) {
+				newValue.push({
+					type: "text",
+					text: IMAGE_OMITTED_PLACEHOLDER,
+				});
+				mutated = true;
+				continue;
+			}
+			currentPart = {
+				...currentPart,
+				data: validation.base64,
+				mediaType: validation.mediaType,
+			};
+		} else if (currentPart.type === "image-url") {
+			if (isDataUrl(currentPart.url)) {
+				const validation = validateAndReserveImageMedia(
+					undefined,
+					currentPart.url,
+					{
+						maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+						maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+					},
+					mediaState,
+				);
+				if (!validation.ok) {
+					newValue.push(imageOmittedTextPart());
+					mutated = true;
+					continue;
+				}
+				currentPart = {
+					...currentPart,
+					url: `data:${validation.mediaType};base64,${validation.base64}`,
+				};
+			} else if (!reserveUnknownUrlMediaBudget(currentPart.url, mediaState)) {
+				newValue.push(imageOmittedTextPart());
+				mutated = true;
+				continue;
+			}
+		} else if (currentPart.type === "file-url") {
+			if (!reserveUnknownUrlMediaBudget(currentPart.url, mediaState)) {
+				newValue.push(imageOmittedTextPart());
+				mutated = true;
+				continue;
+			}
+		} else if (currentPart.type === "file-data") {
+			if (!reserveGenericMediaDataBudget(currentPart.data, mediaState)) {
+				newValue.push(imageOmittedTextPart());
+				mutated = true;
+				continue;
+			}
+		}
+		const filePart = mediaPartToFilePart(currentPart);
+		if (!filePart) {
+			// Unhandled media kind (image-file-id) — pass through unchanged.
+			newValue.push(currentPart);
+			continue;
+		}
+		media.push(filePart);
+		mutated = true;
+		const placeholder: LanguageModelV3TextPart = {
+			type: "text",
+			text: IMAGE_PLACEHOLDER,
+		};
+		newValue.push(placeholder);
+	}
+	if (!mutated) {
+		return null;
+	}
+	return {
+		stripped: {
+			type: "content",
+			value: newValue,
+		},
+		media,
+	};
+}
+
+/**
+ * Walk a `LanguageModelV3Prompt` and rewrite every `role:"tool"` message
+ * containing image/file parts inside its tool-result `output`s. See the
+ * file-level comment for the rewrite shape.
+ *
+ * Returns the (possibly new) prompt array and a `mutated` flag for
+ * test/observation use.
+ */
+export function rewritePromptToolImages(prompt: LanguageModelV3Message[]): {
+	prompt: LanguageModelV3Message[];
+	mutated: boolean;
+} {
+	const newPrompt: LanguageModelV3Message[] = [];
+	let mutated = false;
+	const mediaState = createMediaBudgetState();
+
+	for (const message of prompt) {
+		if (message.role !== "tool") {
+			newPrompt.push(message);
+			continue;
+		}
+
+		const collectedMedia: LanguageModelV3FilePart[] = [];
+		const newContent: typeof message.content = message.content.map((part) => {
+			if (part.type !== "tool-result") {
+				return part;
+			}
+			const split = splitContentOutputMedia(part.output, mediaState);
+			if (!split) {
+				return part;
+			}
+			collectedMedia.push(...split.media);
+			mutated = true;
+			const newPart: LanguageModelV3ToolResultPart = {
+				...part,
+				output: split.stripped,
+			};
+			return newPart;
+		});
+
+		newPrompt.push({ ...message, content: newContent });
+
+		if (collectedMedia.length > 0) {
+			newPrompt.push({
+				role: "user",
+				content: collectedMedia,
+			});
+		}
+	}
+
+	return { prompt: newPrompt, mutated };
+}
+
+/**
+ * `LanguageModelV3Middleware` that splits image-carrying tool-result
+ * messages so chat-completions-style converters don't lose the bytes.
+ *
+ * Apply via `wrapLanguageModel({ model, middleware: splitToolImagesMiddleware })`
+ * in any provider whose downstream converter doesn't natively handle
+ * multimodal `role:"tool"` content (currently: `@ai-sdk/openai-compatible`,
+ * `@ai-sdk/mistral`).
+ *
+ * Anthropic's converter natively renders content arrays on tool-result
+ * messages and should NOT use this middleware — it would replace
+ * structurally-faithful tool-results with the placeholder text + sibling
+ * user message pattern unnecessarily.
+ */
+export const splitToolImagesMiddleware: LanguageModelV3Middleware = {
+	specificationVersion: "v3",
+	transformParams: async ({ params }) => {
+		const { prompt: newPrompt, mutated } = rewritePromptToolImages(
+			params.prompt,
+		);
+		if (!mutated) {
+			return params;
+		}
+		const next: LanguageModelV3CallOptions = {
+			...params,
+			prompt: newPrompt,
+		};
+		return next;
+	},
+};
diff --git a/sdk/packages/llms/src/providers/model-facts.ts b/sdk/packages/llms/src/providers/model-facts.ts
new file mode 100644
index 0000000..3592750
--- /dev/null
+++ b/sdk/packages/llms/src/providers/model-facts.ts
@@ -0,0 +1,304 @@
+import type {
+	GatewayModelRoute,
+	GatewayProviderContext,
+	GatewayReasoningFormat,
+	GatewayStreamRequest,
+} from "@cline/shared";
+
+export function resolveModelFamily(
+	context: GatewayProviderContext,
+): string | undefined {
+	const family = context.model.metadata?.family;
+	return typeof family === "string" ? family : undefined;
+}
+
+export function normalizeRoutingValue(value: string | undefined) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized ? normalized : undefined;
+}
+
+function normalizedFamily(context: GatewayProviderContext): string {
+	return normalizeRoutingValue(resolveModelFamily(context)) ?? "";
+}
+
+function normalizedModelId(
+	request: Pick<GatewayStreamRequest, "modelId">,
+): string {
+	return normalizeRoutingValue(request.modelId) ?? "";
+}
+
+function geminiModelDescriptor(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): string {
+	return [
+		input.request.modelId,
+		input.context.model.id,
+		input.context.model.name,
+		input.context.model.metadata?.family,
+	]
+		.filter(Boolean)
+		.join(" ")
+		.toLowerCase();
+}
+
+function isProviderBaseOrigin(
+	context: GatewayProviderContext,
+	origin: string,
+): boolean {
+	const baseUrl = normalizeRoutingValue(
+		context.config.baseUrl ?? context.provider.api,
+	)?.replace(/\/+$/, "");
+	if (!baseUrl) {
+		return false;
+	}
+
+	try {
+		return new URL(baseUrl).origin.toLowerCase() === origin;
+	} catch {
+		return baseUrl === origin || baseUrl.startsWith(`${origin}/`);
+	}
+}
+
+function isAnthropicLineageValue(value: string | undefined): boolean {
+	const normalized = normalizeRoutingValue(value);
+	return normalized
+		? normalized.includes("anthropic") || normalized.includes("claude")
+		: false;
+}
+
+function isClaudeLineageValue(value: string | undefined): boolean {
+	return normalizeRoutingValue(value)?.includes("claude") ?? false;
+}
+
+function isQwenLineageValue(value: string | undefined): boolean {
+	const normalized = normalizeRoutingValue(value);
+	return normalized
+		? /(^|[/:._-])qwen(?:$|[/:._-]|\d)/.test(normalized)
+		: false;
+}
+
+export function isAnthropicCompatibleModel(options: {
+	modelId?: string;
+	family?: string;
+}): boolean {
+	const family = normalizeRoutingValue(options.family);
+	if (family) {
+		return isAnthropicLineageValue(family);
+	}
+
+	return isAnthropicCompatibleModelId(options.modelId);
+}
+
+export function isAnthropicCompatibleModelId(
+	modelId: string | undefined,
+): boolean {
+	if (!modelId) {
+		return false;
+	}
+
+	return isAnthropicLineageValue(modelId);
+}
+
+export function isClaudeModelId(modelId: string | undefined): boolean {
+	if (!modelId) {
+		return false;
+	}
+
+	return isClaudeLineageValue(modelId);
+}
+
+export function isQwenModel(options: {
+	modelId?: string;
+	family?: string;
+}): boolean {
+	const family = normalizeRoutingValue(options.family);
+	if (isQwenLineageValue(family)) {
+		return true;
+	}
+
+	return isQwenLineageValue(options.modelId);
+}
+
+export function isGemini3Model(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	return /(^|[/\s])gemini-3([.-]|$)/.test(geminiModelDescriptor(input));
+}
+
+export function isGeminiProModel(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	return /(^|[/\s])gemini-2\.5-pro([-\s]|$)/.test(geminiModelDescriptor(input));
+}
+
+export function isGeminiFlashModel(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	const descriptor = geminiModelDescriptor(input);
+	return (
+		/(^|[/\s])gemini-(?:\d(?:\.\d)?-)?flash(?:-lite|-image)?([-\s]|$)/.test(
+			descriptor,
+		) || descriptor.includes("gemini-flash")
+	);
+}
+
+export function supportsGeminiThinking(input: {
+	request: Pick<GatewayStreamRequest, "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	const descriptor = geminiModelDescriptor(input);
+	return (
+		isGemini3Model(input) ||
+		/(^|[/\s])gemini-2\.5([-\s]|$)/.test(descriptor) ||
+		descriptor.includes("gemini-flash-latest")
+	);
+}
+
+function modelFamilyMatches(
+	family: string | undefined,
+	routeFamily: string | undefined,
+): boolean {
+	const normalizedFamily = normalizeRoutingValue(family);
+	const normalizedRouteFamily = normalizeRoutingValue(routeFamily);
+	if (!normalizedFamily || !normalizedRouteFamily) {
+		return false;
+	}
+	if (normalizedFamily === normalizedRouteFamily) {
+		return true;
+	}
+	return normalizedRouteFamily === "qwen"
+		? isQwenLineageValue(normalizedFamily)
+		: false;
+}
+
+export function modelRouteMatches(
+	route: GatewayModelRoute,
+	options: {
+		modelId?: string;
+		family?: string;
+		capabilities?: readonly string[];
+	},
+): boolean {
+	if (
+		"requiredCapability" in route &&
+		route.requiredCapability &&
+		!options.capabilities?.includes(route.requiredCapability)
+	) {
+		return false;
+	}
+
+	switch (route.matcher) {
+		case "anthropic-compatible":
+			return isAnthropicCompatibleModel(options);
+		case "model-family":
+			return modelFamilyMatches(options.family, route.family);
+		case "model-id":
+			return (
+				normalizeRoutingValue(options.modelId) ===
+				normalizeRoutingValue(route.modelId)
+			);
+	}
+}
+
+export function providerReasoningRouteMatches(
+	format: GatewayReasoningFormat,
+	request: Pick<GatewayStreamRequest, "modelId">,
+	context: GatewayProviderContext,
+): boolean {
+	const reasoning = context.provider.metadata?.routing?.reasoning;
+	if (reasoning?.format !== format) {
+		return false;
+	}
+
+	return reasoning.routes.some((route) =>
+		modelRouteMatches(route, {
+			modelId: request.modelId,
+			family: resolveModelFamily(context),
+			capabilities: context.model.capabilities,
+		}),
+	);
+}
+
+export function isGlmModel(
+	request: Pick<GatewayStreamRequest, "modelId">,
+	context: GatewayProviderContext,
+): boolean {
+	const family = normalizedFamily(context);
+
+	// Dynamic provider fallback: some routed/local catalogs only provide ids.
+	return family.includes("glm") || normalizedModelId(request).includes("glm");
+}
+
+export function isMiniMaxM3Model(
+	request: Pick<GatewayStreamRequest, "modelId">,
+	_context: GatewayProviderContext,
+): boolean {
+	const modelId = normalizedModelId(request);
+
+	return modelId === "minimax-m3" || modelId === "minimax/minimax-m3";
+}
+
+export function isKimiK26Family(context: GatewayProviderContext): boolean {
+	return normalizedFamily(context) === "kimi-k2.6";
+}
+
+export function isMoonshotKimiModelIdFallback(
+	request: Pick<GatewayStreamRequest, "modelId">,
+): boolean {
+	// Dynamic provider fallback for Moonshot-routed model ids when family
+	// metadata is absent or not specific enough.
+	return normalizedModelId(request).includes("moonshotai/kimi-");
+}
+
+export function isDeepSeekFamily(context: GatewayProviderContext): boolean {
+	return normalizedFamily(context).includes("deepseek");
+}
+
+export function getReasoningDefaultOnMetadata(
+	context: GatewayProviderContext,
+): boolean | undefined {
+	const value = context.model.metadata?.reasoningDefaultOn;
+	return typeof value === "boolean" ? value : undefined;
+}
+
+export function isOllamaQwen3ModelIdFallback(
+	request: Pick<GatewayStreamRequest, "providerId" | "modelId">,
+): boolean {
+	// Local Ollama models are discovered from /api/tags and often only provide
+	// names such as "qwen3-coder:30b". This fallback is used by
+	// modelReasoningDefaultsOn when no catalog metadata is present.
+	return (
+		request.providerId === "ollama" &&
+		normalizedModelId(request).includes("qwen3")
+	);
+}
+
+export function isCerebrasProvider(
+	request: Pick<GatewayStreamRequest, "providerId">,
+	context: GatewayProviderContext,
+): boolean {
+	const providerIds = [
+		request.providerId,
+		context.config.providerId,
+		context.provider.id,
+	].map((id) => id.toLowerCase());
+
+	return (
+		providerIds.includes("cerebras") ||
+		isProviderBaseOrigin(context, "https://api.cerebras.ai")
+	);
+}
+
+export function modelReasoningDefaultsOn(options: {
+	request: Pick<GatewayStreamRequest, "providerId" | "modelId">;
+	context: GatewayProviderContext;
+}): boolean {
+	return (
+		getReasoningDefaultOnMetadata(options.context) ??
+		isOllamaQwen3ModelIdFallback(options.request)
+	);
+}
diff --git a/sdk/packages/llms/src/providers/model-registry.ts b/sdk/packages/llms/src/providers/model-registry.ts
new file mode 100644
index 0000000..ba958d8
--- /dev/null
+++ b/sdk/packages/llms/src/providers/model-registry.ts
@@ -0,0 +1,122 @@
+import type {
+	ModelCollection,
+	ModelInfo,
+	ProviderInfo,
+} from "../catalog/types";
+import { BUILTIN_PROVIDER_COLLECTION_LIST } from "./builtins";
+
+function buildInitialRegistry(): Map<string, ModelCollection> {
+	const map = new Map<string, ModelCollection>();
+	for (const collection of BUILTIN_PROVIDER_COLLECTION_LIST) {
+		map.set(collection.provider.id, {
+			provider: { ...collection.provider },
+			models: Object.fromEntries(
+				Object.entries(collection.models).map(([id, model]) => [
+					id,
+					{ ...model },
+				]),
+			),
+		});
+	}
+	return map;
+}
+
+const PROVIDER_CACHE: Map<string, ModelCollection> = buildInitialRegistry();
+const CUSTOM_MODELS: Map<string, Map<string, ModelInfo>> = new Map();
+const CUSTOM_PROVIDERS: Map<string, ModelCollection> = new Map();
+
+function getProviderFromCache(providerId: string): ModelCollection | undefined {
+	return CUSTOM_PROVIDERS.get(providerId) ?? PROVIDER_CACHE.get(providerId);
+}
+
+export function getProviderIds(): string[] {
+	const builtInIds = Array.from(PROVIDER_CACHE.keys());
+	const customIds = Array.from(CUSTOM_PROVIDERS.keys()).filter(
+		(id) => !PROVIDER_CACHE.has(id),
+	);
+	return [...builtInIds, ...customIds];
+}
+
+export function hasProvider(providerId: string): boolean {
+	return PROVIDER_CACHE.has(providerId) || CUSTOM_PROVIDERS.has(providerId);
+}
+
+export async function getProvider(
+	providerId: string,
+): Promise<ProviderInfo | undefined> {
+	return getProviderFromCache(providerId)?.provider;
+}
+
+export function getProviderCollectionSync(
+	providerId: string,
+): ModelCollection | undefined {
+	return getProviderFromCache(providerId);
+}
+
+export async function getProviderCollection(
+	providerId: string,
+): Promise<ModelCollection | undefined> {
+	return getProviderFromCache(providerId);
+}
+
+export async function getModelsForProvider(
+	providerId: string,
+): Promise<Record<string, ModelInfo>> {
+	const collection = getProviderFromCache(providerId);
+	const builtInModels = collection?.models ?? {};
+	const customModels = CUSTOM_MODELS.get(providerId);
+	if (customModels) {
+		return { ...builtInModels, ...Object.fromEntries(customModels) };
+	}
+	return builtInModels;
+}
+
+export async function getAllProviders(): Promise<ProviderInfo[]> {
+	return getProviderIds()
+		.map((id) => getProviderFromCache(id)?.provider)
+		.filter((p): p is ProviderInfo => p !== undefined);
+}
+
+export function registerProvider(collection: ModelCollection): void {
+	CUSTOM_PROVIDERS.set(collection.provider.id, collection);
+}
+
+export function registerModel(
+	providerId: string,
+	modelId: string,
+	info: ModelInfo,
+): void {
+	if (!CUSTOM_MODELS.has(providerId)) {
+		CUSTOM_MODELS.set(providerId, new Map());
+	}
+	CUSTOM_MODELS.get(providerId)?.set(modelId, { ...info, id: modelId });
+}
+
+export function unregisterProvider(providerId: string): boolean {
+	CUSTOM_MODELS.delete(providerId);
+	return CUSTOM_PROVIDERS.delete(providerId);
+}
+
+export function resetRegistry(): void {
+	CUSTOM_MODELS.clear();
+	CUSTOM_PROVIDERS.clear();
+}
+
+// MODEL_COLLECTIONS_BY_PROVIDER_ID: live view merging custom providers over builtins
+export const MODEL_COLLECTIONS_BY_PROVIDER_ID: Record<string, ModelCollection> =
+	new Proxy({} as Record<string, ModelCollection>, {
+		get(_target, key: string) {
+			return getProviderFromCache(key);
+		},
+		has(_target, key: string) {
+			return PROVIDER_CACHE.has(key) || CUSTOM_PROVIDERS.has(key);
+		},
+		ownKeys() {
+			return getProviderIds();
+		},
+		getOwnPropertyDescriptor(_target, key: string) {
+			const val = getProviderFromCache(key as string);
+			if (val === undefined) return undefined;
+			return { configurable: true, enumerable: true, value: val };
+		},
+	});
diff --git a/sdk/packages/llms/src/providers/openai-codex-models.test.ts b/sdk/packages/llms/src/providers/openai-codex-models.test.ts
new file mode 100644
index 0000000..5924aa0
--- /dev/null
+++ b/sdk/packages/llms/src/providers/openai-codex-models.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import type { ModelInfo } from "../catalog/types";
+import {
+	CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	filterOpenAICodexModels,
+} from "./openai-codex-models";
+
+function makeModel(id: string, overrides: Partial<ModelInfo> = {}): ModelInfo {
+	return {
+		id,
+		contextWindow: 400_000,
+		maxInputTokens: 300_000,
+		maxTokens: 100_000,
+		family: id.replace(/^gpt-/, "gpt"),
+		...overrides,
+	};
+}
+
+function filterOne(
+	id: string,
+	overrides: Partial<ModelInfo> = {},
+): ModelInfo | undefined {
+	return filterOpenAICodexModels({ [id]: makeModel(id, overrides) })[id];
+}
+
+describe("filterOpenAICodexModels", () => {
+	describe("model eligibility", () => {
+		it.each([
+			["gpt-5.4", true],
+			["gpt-5.5", true],
+			["gpt-5.5-codex", true],
+			["gpt-6.0", true],
+			["gpt-10.1", true],
+		])("allows %s (newer than 5.3)", (id, allowed) => {
+			expect(filterOne(id) !== undefined).toBe(allowed);
+		});
+
+		it.each([
+			["gpt-5.3", "at the 5.3 cutoff"],
+			["gpt-5.1", "older than 5.3"],
+			["gpt-4.1", "older major version"],
+			["gpt-5", "no minor version"],
+			["chatgpt-5.5", "id does not start with gpt-"],
+			["davinci", "not a gpt model"],
+		])("rejects %s (%s)", (id) => {
+			expect(filterOne(id)).toBeUndefined();
+		});
+
+		it.each([
+			["o-series", "o4"],
+			["pro variant", "gpt5.5-pro"],
+			["nano variant", "gpt5.5-nano"],
+		])("rejects %s families regardless of id version", (_label, family) => {
+			expect(filterOne("gpt-6.0", { family })).toBeUndefined();
+		});
+
+		it("falls back to the id version check when family is missing", () => {
+			expect(filterOne("gpt-6.0", { family: undefined })).toBeDefined();
+			expect(filterOne("gpt-5.0", { family: undefined })).toBeUndefined();
+		});
+	});
+
+	describe("context window adjustment", () => {
+		it.each([
+			"gpt-5.4",
+			"gpt-5.4-mini",
+			"gpt-6.0",
+		])("scales %s maxInputTokens down to the effective Codex budget — the backend cap applies to every model, not just gpt-5.5", (id) => {
+			const maxInputTokens = 200_000;
+			const result = filterOne(id, { maxInputTokens });
+			expect(result?.maxInputTokens).toBe(
+				maxInputTokens * CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+			);
+		});
+
+		it("leaves other limits untouched for non-5.5 models", () => {
+			const result = filterOne("gpt-6.0", {
+				contextWindow: 500_000,
+				maxTokens: 64_000,
+			});
+			expect(result?.contextWindow).toBe(500_000);
+			expect(result?.maxTokens).toBe(64_000);
+		});
+
+		it("preserves an undefined maxInputTokens instead of producing NaN", () => {
+			const result = filterOne("gpt-6.0", { maxInputTokens: undefined });
+			expect(result?.maxInputTokens).toBeUndefined();
+		});
+
+		it("overrides gpt-5.5 limits with the ChatGPT backend caps", () => {
+			const result = filterOne("gpt-5.5-codex", {
+				contextWindow: 1_000_000,
+				maxInputTokens: 900_000,
+				maxTokens: 900_000,
+			});
+			expect(result).toMatchObject({
+				contextWindow: 400_000,
+				maxInputTokens: 272_000 * CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+				maxTokens: 128_000,
+			});
+		});
+
+		it("does not mutate the input models", () => {
+			const model = makeModel("gpt-6.0");
+			const snapshot = structuredClone(model);
+			filterOpenAICodexModels({ "gpt-6.0": model });
+			expect(model).toEqual(snapshot);
+		});
+	});
+
+	it("keeps allowed models and drops disallowed ones from a mixed catalog", () => {
+		const models: Record<string, ModelInfo> = {
+			"gpt-5.5": makeModel("gpt-5.5"),
+			"gpt-6.0": makeModel("gpt-6.0"),
+			"gpt-5.1": makeModel("gpt-5.1"),
+			"o4-mini": makeModel("o4-mini", { family: "o4" }),
+		};
+		expect(Object.keys(filterOpenAICodexModels(models)).sort()).toEqual([
+			"gpt-5.5",
+			"gpt-6.0",
+		]);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/openai-codex-models.ts b/sdk/packages/llms/src/providers/openai-codex-models.ts
new file mode 100644
index 0000000..30e7d23
--- /dev/null
+++ b/sdk/packages/llms/src/providers/openai-codex-models.ts
@@ -0,0 +1,63 @@
+import type { ModelInfo } from "../catalog/types";
+
+/**
+ * The ChatGPT/Codex backend starts rejecting requests around 95% of a
+ * model's advertised input cap, so every model exposed through this
+ * provider gets its maxInputTokens scaled down to the effective budget.
+ *
+ * REF: https://github.com/openai/codex/issues/19319
+ */
+export const CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 0.95;
+
+const GPT_VERSION_REGEX = /^gpt-(\d+\.\d+)/;
+
+function isOpenAICodexAllowedModel(id: string, model: ModelInfo): boolean {
+	// O, pro, and nano variants are not supported
+	const family = model.family;
+	if (
+		family &&
+		(family.startsWith("o") ||
+			family.includes("pro") ||
+			family.includes("nano"))
+	) {
+		return false;
+	}
+	// Must be newer than 5.3
+	const match = id.match(GPT_VERSION_REGEX);
+	return match ? Number.parseFloat(match[1]) > 5.3 : false;
+}
+
+/**
+ * Applies the effective input budget to every allowed model. GPT-5.5
+ * additionally gets hardcoded limits because the ChatGPT/Codex backend
+ * enforces a 272K input / 128K output cap that is lower than what the
+ * generated OpenAI API catalog reports.
+ */
+function toOpenAICodexModel(id: string, model: ModelInfo): ModelInfo {
+	if (id.includes("gpt-5.5")) {
+		return {
+			...model,
+			contextWindow: 400_000,
+			maxInputTokens: 272_000 * CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+			maxTokens: 128_000,
+		};
+	}
+	return {
+		...model,
+		maxInputTokens: model.maxInputTokens
+			? model.maxInputTokens * CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+			: model.maxInputTokens,
+	};
+}
+
+export function filterOpenAICodexModels(
+	models: Record<string, ModelInfo>,
+): Record<string, ModelInfo> {
+	const result: Record<string, ModelInfo> = {};
+	for (const [id, model] of Object.entries(models)) {
+		if (isOpenAICodexAllowedModel(id, model)) {
+			result[id] = toOpenAICodexModel(id, model);
+		}
+	}
+	return result;
+}
diff --git a/sdk/packages/llms/src/providers/provider-keys.ts b/sdk/packages/llms/src/providers/provider-keys.ts
new file mode 100644
index 0000000..aa1c07b
--- /dev/null
+++ b/sdk/packages/llms/src/providers/provider-keys.ts
@@ -0,0 +1,157 @@
+/** Maps provider identifiers across Cline legacy provider ids, models.dev keys, and runtime provider ids. */
+const PROVIDER_IDS_MAP: ReadonlyArray<{
+	modelsDevKey: string;
+	generatedProviderId?: string;
+	runtimeProviderId?: string;
+}> = [
+	{
+		modelsDevKey: "openai",
+		generatedProviderId: "openai-native",
+		runtimeProviderId: "openai-native",
+	},
+	{
+		modelsDevKey: "openai",
+		generatedProviderId: "openai-native",
+		runtimeProviderId: "openai-codex-cli",
+	},
+	{
+		modelsDevKey: "openai",
+		generatedProviderId: "openai-native",
+		runtimeProviderId: "openai-codex",
+	},
+	{ modelsDevKey: "anthropic", generatedProviderId: "anthropic" },
+	{
+		modelsDevKey: "anthropic",
+		generatedProviderId: "anthropic",
+		runtimeProviderId: "claude-code",
+	},
+	{ modelsDevKey: "google", generatedProviderId: "gemini" },
+	{
+		modelsDevKey: "deepseek",
+		generatedProviderId: "deepseek",
+		runtimeProviderId: "deepseek",
+	},
+	{ modelsDevKey: "xai", generatedProviderId: "xai" },
+	{
+		modelsDevKey: "togetherai",
+		generatedProviderId: "together",
+		runtimeProviderId: "together",
+	},
+	{
+		modelsDevKey: "sap-ai-core",
+		generatedProviderId: "sapaicore",
+		runtimeProviderId: "sapaicore",
+	},
+	{ modelsDevKey: "ollama", runtimeProviderId: "ollama-cloud" },
+	{ modelsDevKey: "ollama-cloud", generatedProviderId: "ollama" },
+	{
+		modelsDevKey: "fireworks-ai",
+		generatedProviderId: "fireworks",
+		runtimeProviderId: "fireworks",
+	},
+	{
+		modelsDevKey: "groq",
+		generatedProviderId: "groq",
+		runtimeProviderId: "groq",
+	},
+	{
+		modelsDevKey: "cerebras",
+		generatedProviderId: "cerebras",
+		runtimeProviderId: "cerebras",
+	},
+	{
+		modelsDevKey: "sambanova",
+		generatedProviderId: "sambanova",
+		runtimeProviderId: "sambanova",
+	},
+	{
+		modelsDevKey: "nebius",
+		generatedProviderId: "nebius",
+		runtimeProviderId: "nebius",
+	},
+	{
+		modelsDevKey: "huggingface",
+		generatedProviderId: "huggingface",
+		runtimeProviderId: "huggingface",
+	},
+	{
+		modelsDevKey: "openrouter",
+		generatedProviderId: "openrouter",
+	},
+	{
+		modelsDevKey: "vercel",
+		generatedProviderId: "vercel-ai-gateway",
+		runtimeProviderId: "dify",
+	},
+	{
+		modelsDevKey: "vercel",
+		generatedProviderId: "vercel-ai-gateway",
+	},
+	{
+		modelsDevKey: "openrouter",
+		generatedProviderId: "openrouter",
+		runtimeProviderId: "cline",
+	},
+	{
+		modelsDevKey: "aihubmix",
+		generatedProviderId: "aihubmix",
+		runtimeProviderId: "aihubmix",
+	},
+	{ modelsDevKey: "hicap", runtimeProviderId: "hicap" },
+	{ modelsDevKey: "nous-research", runtimeProviderId: "nousResearch" },
+	{ modelsDevKey: "huawei-cloud-maas", runtimeProviderId: "huawei-cloud-maas" },
+	{
+		modelsDevKey: "baseten",
+		generatedProviderId: "baseten",
+		runtimeProviderId: "baseten",
+	},
+	{ modelsDevKey: "zai-coding-plan", generatedProviderId: "zai-coding-plan" },
+	{ modelsDevKey: "google-vertex", generatedProviderId: "vertex" },
+	{ modelsDevKey: "lmstudio", generatedProviderId: "lmstudio" },
+	{ modelsDevKey: "zai", generatedProviderId: "zai" },
+	{ modelsDevKey: "requesty", generatedProviderId: "requesty" },
+	{ modelsDevKey: "amazon-bedrock", generatedProviderId: "bedrock" },
+	{ modelsDevKey: "moonshotai", generatedProviderId: "moonshot" },
+	{ modelsDevKey: "minimax", generatedProviderId: "minimax" },
+	{ modelsDevKey: "wandb", generatedProviderId: "wandb" },
+	{ modelsDevKey: "kilo", generatedProviderId: "kilo" },
+	{ modelsDevKey: "xiaomi", generatedProviderId: "xiaomi" },
+	{
+		modelsDevKey: "tencent-tokenhub",
+		generatedProviderId: "tencent-tokenhub",
+	},
+	{ modelsDevKey: "v0", generatedProviderId: "v0" },
+];
+
+function dedupe(values: readonly string[]): string[] {
+	return [...new Set(values)];
+}
+
+export const MODELS_DEV_PROVIDER_KEY_MAP = Object.fromEntries(
+	PROVIDER_IDS_MAP.flatMap((entry) =>
+		entry.generatedProviderId
+			? [[entry.modelsDevKey, entry.generatedProviderId]]
+			: [],
+	),
+);
+
+export function resolveProviderModelCatalogKeys(providerId: string): string[] {
+	const mapped = PROVIDER_IDS_MAP.flatMap((entry) => {
+		if (!entry.generatedProviderId) {
+			return [];
+		}
+		if (
+			entry.generatedProviderId === providerId ||
+			entry.runtimeProviderId === providerId
+		) {
+			return [entry.generatedProviderId];
+		}
+		return [];
+	});
+
+	if (providerId === "nousResearch") {
+		return dedupe([...mapped, "nousresearch", providerId]);
+	}
+
+	return dedupe([...mapped, providerId]);
+}
diff --git a/sdk/packages/llms/src/providers/provider-request-capture.ts b/sdk/packages/llms/src/providers/provider-request-capture.ts
new file mode 100644
index 0000000..75144ae
--- /dev/null
+++ b/sdk/packages/llms/src/providers/provider-request-capture.ts
@@ -0,0 +1,407 @@
+import { createHash } from "node:crypto";
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	renameSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import type { GatewayStreamRequest } from "@cline/shared";
+import { estimateTokens } from "@cline/shared";
+
+type CaptureMode = "off" | "summary" | "full";
+type CaptureStage = "ai_sdk_prompt" | "wire_request";
+
+const DEFAULT_MAX_PREVIEW_BYTES = 64 * 1024;
+const CAPTURE_FILE_EXTENSION = ".provider-request.json";
+const CAPTURE_TMP_EXTENSION = ".tmp";
+const CLEANUP_TTL_MS = 24 * 60 * 60 * 1000;
+const cleanupDirs = new Set<string>();
+const attemptCounters = new Map<string, number>();
+
+function readCaptureMode(): CaptureMode {
+	const raw = process.env.CLINE_CAPTURE_PROVIDER_REQUEST?.trim().toLowerCase();
+	if (raw === "summary" || raw === "full") {
+		return raw;
+	}
+	return "off";
+}
+
+function isWireCaptureEnabled(): boolean {
+	return process.env.CLINE_CAPTURE_WIRE?.trim().toLowerCase() === "true";
+}
+
+function readMaxPreviewBytes(): number {
+	const parsed = Number(process.env.CLINE_CAPTURE_MAX_PREVIEW_BYTES);
+	return Number.isFinite(parsed) && parsed > 0
+		? Math.floor(parsed)
+		: DEFAULT_MAX_PREVIEW_BYTES;
+}
+
+function isCleanupEnabled(): boolean {
+	return process.env.CLINE_CAPTURE_CLEANUP?.trim().toLowerCase() !== "off";
+}
+
+function resolveCaptureDir(): string | undefined {
+	const explicit = process.env.CLINE_CAPTURE_DIR?.trim();
+	if (explicit) {
+		return resolve(explicit);
+	}
+	const dataDir = process.env.CLINE_DATA_DIR?.trim();
+	if (dataDir) {
+		return resolve(dataDir, "provider-request-captures");
+	}
+	return undefined;
+}
+
+function safeStringify(value: unknown): string {
+	const seen = new WeakSet<object>();
+	try {
+		return (
+			JSON.stringify(value, (_key, nestedValue: unknown) => {
+				if (typeof nestedValue === "bigint") {
+					return nestedValue.toString();
+				}
+				if (typeof nestedValue !== "object" || nestedValue === null) {
+					return nestedValue;
+				}
+				if (seen.has(nestedValue)) {
+					return "[Circular]";
+				}
+				seen.add(nestedValue);
+				return nestedValue;
+			}) ?? ""
+		);
+	} catch {
+		return String(value ?? "");
+	}
+}
+
+function hashString(value: string): string {
+	return createHash("sha256").update(value).digest("hex");
+}
+
+function byteLength(value: string): number {
+	return Buffer.byteLength(value, "utf8");
+}
+
+function previewValue(
+	value: unknown,
+	maxBytes = DEFAULT_MAX_PREVIEW_BYTES,
+): unknown {
+	const serialized = safeStringify(value);
+	if (byteLength(serialized) <= maxBytes) {
+		return value;
+	}
+	const previewBuffer = Buffer.from(serialized, "utf8").subarray(0, maxBytes);
+	let preview = previewBuffer.toString("utf8");
+	while (byteLength(preview) > maxBytes) {
+		preview = preview.slice(0, -1);
+	}
+	return {
+		truncated: true,
+		bytes: byteLength(serialized),
+		sha256: hashString(serialized),
+		preview,
+	};
+}
+
+function summarizeContent(value: unknown): {
+	bytes: number;
+	estimatedTokens: number;
+	sha256: string;
+	kind: string;
+} {
+	const serialized = typeof value === "string" ? value : safeStringify(value);
+	return {
+		bytes: byteLength(serialized),
+		estimatedTokens: estimateTokens(byteLength(serialized)),
+		sha256: hashString(serialized),
+		kind: Array.isArray(value) ? "array" : typeof value,
+	};
+}
+
+function summarizeMessages(messages: unknown): Record<string, unknown> {
+	if (!Array.isArray(messages)) {
+		return summarizeContent(messages);
+	}
+
+	const roleCounts: Record<string, number> = {};
+	let reasoningBlockCount = 0;
+	let toolResultCount = 0;
+	const messageSummaries = messages.map((message, index) => {
+		const record =
+			message && typeof message === "object"
+				? (message as Record<string, unknown>)
+				: {};
+		const role = typeof record.role === "string" ? record.role : "unknown";
+		roleCounts[role] = (roleCounts[role] ?? 0) + 1;
+		const content = record.content;
+		const contentArray = Array.isArray(content) ? content : [content];
+		for (const part of contentArray) {
+			if (!part || typeof part !== "object") continue;
+			const type = (part as Record<string, unknown>).type;
+			if (type === "reasoning") reasoningBlockCount += 1;
+			if (type === "tool-result" || role === "tool") toolResultCount += 1;
+		}
+		const contentSummary = summarizeContent(content);
+		return {
+			index,
+			role,
+			contentParts: contentArray.length,
+			contentBytes: contentSummary.bytes,
+			estimatedTokens: contentSummary.estimatedTokens,
+			sha256: contentSummary.sha256,
+		};
+	});
+
+	const largestMessages = [...messageSummaries]
+		.sort((a, b) => b.contentBytes - a.contentBytes)
+		.slice(0, 5)
+		.map((message) => ({ ...message }));
+	const serialized = safeStringify(messages);
+	return {
+		messageCount: messages.length,
+		roleCounts,
+		totalBytes: byteLength(serialized),
+		estimatedTokens: estimateTokens(byteLength(serialized)),
+		sha256: hashString(serialized),
+		reasoningBlockCount,
+		toolResultCount,
+		largestMessages,
+		messages: messageSummaries,
+	};
+}
+
+function parseJsonString(value: unknown): unknown {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return undefined;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return undefined;
+	}
+}
+
+function extractProviderMessages(
+	payloadRecord: Record<string, unknown>,
+): unknown {
+	if ("messages" in payloadRecord) return payloadRecord.messages;
+	const body = payloadRecord.body;
+	const parsedBody = parseJsonString(body);
+	if (parsedBody && typeof parsedBody === "object") {
+		const bodyRecord = parsedBody as Record<string, unknown>;
+		if ("messages" in bodyRecord) return bodyRecord.messages;
+		if ("prompt" in bodyRecord) return bodyRecord.prompt;
+		if ("contents" in bodyRecord) return bodyRecord.contents;
+	}
+	return undefined;
+}
+
+function captureCorrelation(
+	request: GatewayStreamRequest,
+): Record<string, unknown> {
+	const metadata =
+		request.metadata && typeof request.metadata === "object"
+			? request.metadata
+			: {};
+	return {
+		...metadata,
+		providerId: request.providerId,
+		modelId: request.modelId,
+	};
+}
+
+function safeFilePart(value: unknown): string | undefined {
+	if (typeof value !== "string" && typeof value !== "number") return undefined;
+	const raw = String(value).trim();
+	if (!raw) return undefined;
+	const safe = raw.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+	return safe || undefined;
+}
+
+function captureIdForCorrelation(correlation: Record<string, unknown>): string {
+	const explicit = safeFilePart(correlation.captureId);
+	if (explicit) return explicit;
+	const hash = hashString(safeStringify(correlation)).slice(0, 16);
+	const runId = safeFilePart(correlation.runId);
+	const iteration = safeFilePart(correlation.iteration);
+	return ["cap", runId, iteration, hash].filter(Boolean).join("_");
+}
+
+function nextAttempt(captureId: string, stage: CaptureStage): number {
+	const key = `${captureId}:${stage}`;
+	const next = (attemptCounters.get(key) ?? 0) + 1;
+	attemptCounters.set(key, next);
+	return next;
+}
+
+function cleanupOldCaptures(dir: string): void {
+	if (!isCleanupEnabled() || cleanupDirs.has(dir)) return;
+	cleanupDirs.add(dir);
+	try {
+		const cutoff = Date.now() - CLEANUP_TTL_MS;
+		for (const file of readdirSync(dir)) {
+			if (
+				!file.endsWith(CAPTURE_FILE_EXTENSION) &&
+				!(
+					file.includes(CAPTURE_FILE_EXTENSION) &&
+					file.endsWith(CAPTURE_TMP_EXTENSION)
+				)
+			) {
+				continue;
+			}
+			const path = join(dir, file);
+			const stat = statSync(path);
+			if (stat.mtimeMs < cutoff) {
+				rmSync(path, { force: true });
+			}
+		}
+	} catch {
+		// Capture cleanup must never affect model execution.
+	}
+}
+
+function writeCapture(record: Record<string, unknown>): void {
+	try {
+		const dir = resolveCaptureDir();
+		if (!dir) return;
+		mkdirSync(dir, { recursive: true });
+		cleanupOldCaptures(dir);
+		const correlation =
+			record.correlation && typeof record.correlation === "object"
+				? (record.correlation as Record<string, unknown>)
+				: {};
+		const captureId = captureIdForCorrelation(correlation);
+		const stage =
+			record.captureStage === "ai_sdk_prompt" ||
+			record.captureStage === "wire_request"
+				? record.captureStage
+				: "ai_sdk_prompt";
+		const attempt = nextAttempt(captureId, stage);
+		const finalPath = join(
+			dir,
+			`${captureId}.${stage}.${attempt}${CAPTURE_FILE_EXTENSION}`,
+		);
+		const tmpPath = `${finalPath}.${process.pid}.${Date.now()}${CAPTURE_TMP_EXTENSION}`;
+		writeFileSync(tmpPath, `${safeStringify({ ...record, attempt })}\n`, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		renameSync(tmpPath, finalPath);
+		if (existsSync(tmpPath)) rmSync(tmpPath, { force: true });
+	} catch {
+		// Provider-request capture must never affect model execution.
+	}
+}
+
+export function recordProviderRequestCapture(input: {
+	stage: CaptureStage;
+	request: GatewayStreamRequest;
+	payload: unknown;
+}): void {
+	try {
+		const mode = readCaptureMode();
+		if (mode === "off") return;
+		const payloadRecord =
+			input.payload && typeof input.payload === "object"
+				? (input.payload as Record<string, unknown>)
+				: { value: input.payload };
+		const messages = extractProviderMessages(payloadRecord);
+		const serializedPayload = safeStringify(input.payload);
+		writeCapture({
+			timestamp: new Date().toISOString(),
+			captureStage: input.stage,
+			mode,
+			correlation: captureCorrelation(input.request),
+			summary: {
+				payloadBytes: byteLength(serializedPayload),
+				estimatedTokens: estimateTokens(byteLength(serializedPayload)),
+				sha256: hashString(serializedPayload),
+				messages: summarizeMessages(messages),
+			},
+			...(mode === "full"
+				? { payload: previewValue(input.payload, readMaxPreviewBytes()) }
+				: {}),
+		});
+	} catch {
+		// Provider-request capture must never affect model execution.
+	}
+}
+
+async function readRequestBody(
+	input: Parameters<typeof fetch>[0],
+	init: Parameters<typeof fetch>[1],
+): Promise<unknown> {
+	const body = init?.body;
+	if (body !== undefined && body !== null) {
+		if (typeof body === "string") return body;
+		if (body instanceof URLSearchParams) return body.toString();
+		if (body instanceof ArrayBuffer) return Buffer.from(body).toString("utf8");
+		if (ArrayBuffer.isView(body)) {
+			return Buffer.from(
+				body.buffer,
+				body.byteOffset,
+				body.byteLength,
+			).toString("utf8");
+		}
+		return { type: body.constructor?.name ?? typeof body };
+	}
+	if (input instanceof Request) {
+		try {
+			return await input.clone().text();
+		} catch {
+			return { type: "Request", bodyReadable: false };
+		}
+	}
+	return undefined;
+}
+
+export function wrapFetchForProviderRequestCapture(
+	baseFetch: typeof fetch | undefined,
+	request: GatewayStreamRequest,
+): typeof fetch | undefined {
+	if (!isWireCaptureEnabled()) {
+		return baseFetch;
+	}
+	const delegate = baseFetch ?? globalThis.fetch;
+	if (!delegate) {
+		return baseFetch;
+	}
+	const captureFetch = (async (input, init) => {
+		void readRequestBody(input, init)
+			.then((body) => {
+				recordProviderRequestCapture({
+					stage: "wire_request",
+					request,
+					payload: {
+						url: input instanceof Request ? input.url : String(input),
+						method:
+							init?.method ??
+							(input instanceof Request ? input.method : undefined) ??
+							"GET",
+						body,
+					},
+				});
+			})
+			.catch(() => {
+				// Provider-request capture must never affect model execution.
+			});
+		return delegate(input, init);
+	}) as typeof fetch;
+	const delegateWithPreconnect = delegate as typeof fetch & {
+		preconnect?: (...args: unknown[]) => unknown;
+	};
+	if (typeof delegateWithPreconnect.preconnect === "function") {
+		(
+			captureFetch as typeof fetch & {
+				preconnect?: (...args: unknown[]) => unknown;
+			}
+		).preconnect = delegateWithPreconnect.preconnect.bind(delegate);
+	}
+	return captureFetch;
+}
diff --git a/sdk/packages/llms/src/providers/registry.ts b/sdk/packages/llms/src/providers/registry.ts
new file mode 100644
index 0000000..a0c01f9
--- /dev/null
+++ b/sdk/packages/llms/src/providers/registry.ts
@@ -0,0 +1,279 @@
+import type {
+	GatewayModelDefinition,
+	GatewayModelSelection,
+	GatewayProviderConfig,
+	GatewayProviderFactory,
+	GatewayProviderManifest,
+	GatewayProviderMetadata,
+	GatewayProviderRegistration,
+	GatewayResolvedModel,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+
+interface ProviderRecord {
+	manifest: GatewayProviderManifest;
+	defaults?: GatewayResolvedProviderConfig;
+	createProvider?: GatewayProviderFactory;
+	loadProvider?: GatewayProviderRegistration["loadProvider"];
+}
+
+interface ProviderConfigRecord extends GatewayResolvedProviderConfig {
+	enabled: boolean;
+	defaultModelId?: string;
+	models?: readonly Omit<GatewayModelDefinition, "providerId">[];
+}
+
+function cloneManifest(
+	manifest: GatewayProviderManifest,
+): GatewayProviderManifest {
+	return {
+		...manifest,
+		models: manifest.models.map((model) => ({ ...model })),
+		capabilities: manifest.capabilities
+			? [...manifest.capabilities]
+			: undefined,
+		env: manifest.env ? [...manifest.env] : undefined,
+		api: manifest.api,
+		apiKeyEnv: manifest.apiKeyEnv ? [...manifest.apiKeyEnv] : undefined,
+		docsUrl: manifest.docsUrl,
+		metadata: manifest.metadata ? { ...manifest.metadata } : undefined,
+	};
+}
+
+function mergeModels(
+	manifest: GatewayProviderManifest,
+	config: ProviderConfigRecord | undefined,
+): readonly GatewayModelDefinition[] {
+	const merged = new Map<string, GatewayModelDefinition>();
+
+	for (const model of manifest.models) {
+		merged.set(model.id, { ...model });
+	}
+
+	for (const model of config?.models ?? []) {
+		merged.set(model.id, {
+			...model,
+			providerId: manifest.id,
+		});
+	}
+
+	return Array.from(merged.values());
+}
+
+function mergeProviderMetadata(
+	base: GatewayProviderMetadata | undefined,
+	override: GatewayProviderMetadata | undefined,
+): GatewayProviderMetadata | undefined {
+	// Routing metadata merges at the promptCache/reasoning branch boundary:
+	// omitted branches inherit, provided branches replace in full. Route arrays
+	// are intentionally not concatenated so overrides remain explicit.
+	const routing =
+		base?.routing || override?.routing
+			? {
+					...(base?.routing ?? {}),
+					...(override?.routing ?? {}),
+				}
+			: undefined;
+	const metadata: GatewayProviderMetadata = {
+		...(base ?? {}),
+		...(override ?? {}),
+		...(routing ? { routing } : {}),
+	};
+
+	return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+
+function createUnregisteredModel(
+	provider: GatewayProviderManifest,
+	modelId: string,
+): GatewayModelDefinition {
+	return {
+		id: modelId,
+		name: modelId,
+		providerId: provider.id,
+	};
+}
+
+export class GatewayRegistry {
+	private readonly providers = new Map<string, ProviderRecord>();
+	private readonly providerConfigs = new Map<string, ProviderConfigRecord>();
+	private readonly fallbackFetch?: typeof fetch;
+
+	constructor(fetchImpl?: typeof fetch) {
+		this.fallbackFetch = fetchImpl;
+	}
+
+	registerProvider(registration: GatewayProviderRegistration): void {
+		if (!registration.createProvider && !registration.loadProvider) {
+			throw new Error(
+				`Provider "${registration.manifest.id}" must include createProvider or loadProvider.`,
+			);
+		}
+
+		this.providers.set(registration.manifest.id, {
+			manifest: cloneManifest(registration.manifest),
+			defaults: registration.defaults
+				? {
+						providerId: registration.manifest.id,
+						apiKey: registration.defaults.apiKey,
+						apiKeyResolver: registration.defaults.apiKeyResolver,
+						apiKeyEnv: registration.defaults.apiKeyEnv,
+						baseUrl: registration.defaults.baseUrl,
+						headers: registration.defaults.headers
+							? { ...registration.defaults.headers }
+							: undefined,
+						timeoutMs: registration.defaults.timeoutMs,
+						fetch: registration.defaults.fetch,
+						options: registration.defaults.options
+							? { ...registration.defaults.options }
+							: undefined,
+						metadata: registration.defaults.metadata
+							? { ...registration.defaults.metadata }
+							: undefined,
+					}
+				: undefined,
+			createProvider: registration.createProvider,
+			loadProvider: registration.loadProvider,
+		});
+	}
+
+	configureProvider(config: GatewayProviderConfig): void {
+		this.providerConfigs.set(config.providerId, {
+			providerId: config.providerId,
+			apiKey: config.apiKey,
+			apiKeyResolver: config.apiKeyResolver,
+			apiKeyEnv: config.apiKeyEnv,
+			baseUrl: config.baseUrl,
+			headers: config.headers ? { ...config.headers } : undefined,
+			timeoutMs: config.timeoutMs,
+			fetch: config.fetch,
+			options: config.options ? { ...config.options } : undefined,
+			metadata: config.metadata ? { ...config.metadata } : undefined,
+			enabled: config.enabled ?? true,
+			defaultModelId: config.defaultModelId,
+			models: config.models?.map((model) => ({ ...model })),
+		});
+	}
+
+	listProviders(): GatewayProviderManifest[] {
+		return Array.from(this.providers.values())
+			.map((record) => this.getManifest(record.manifest.id))
+			.filter(
+				(manifest): manifest is GatewayProviderManifest =>
+					manifest !== undefined,
+			);
+	}
+
+	listModels(providerId?: string): GatewayModelDefinition[] {
+		if (providerId) {
+			return [...(this.getManifest(providerId)?.models ?? [])];
+		}
+
+		return this.listProviders().flatMap((provider) =>
+			provider.models.map((model) => ({ ...model })),
+		);
+	}
+
+	getManifest(providerId: string): GatewayProviderManifest | undefined {
+		const record = this.providers.get(providerId);
+		if (!record) {
+			return undefined;
+		}
+
+		const config = this.providerConfigs.get(providerId);
+		if (config && !config.enabled) {
+			return undefined;
+		}
+
+		const models = mergeModels(record.manifest, config);
+		const defaultModelId =
+			config?.defaultModelId ?? record.manifest.defaultModelId ?? models[0]?.id;
+
+		if (!defaultModelId) {
+			return undefined;
+		}
+
+		return {
+			...cloneManifest(record.manifest),
+			defaultModelId,
+			models,
+			metadata: mergeProviderMetadata(
+				record.manifest.metadata,
+				config?.metadata,
+			),
+		};
+	}
+
+	resolveModel(selection: GatewayModelSelection): GatewayResolvedModel {
+		const provider = this.getManifest(selection.providerId);
+		if (!provider) {
+			throw new Error(
+				`Unknown or disabled provider "${selection.providerId}".`,
+			);
+		}
+
+		const modelId = selection.modelId ?? provider.defaultModelId;
+		const model =
+			provider.models.find((entry) => entry.id === modelId) ??
+			createUnregisteredModel(provider, modelId);
+
+		return {
+			provider,
+			model,
+		};
+	}
+
+	async createProvider(providerId: string): Promise<{
+		manifest: GatewayProviderManifest;
+		config: GatewayResolvedProviderConfig;
+		createProvider: GatewayProviderFactory;
+	}> {
+		const record = this.providers.get(providerId);
+		if (!record) {
+			throw new Error(`Unknown provider "${providerId}".`);
+		}
+
+		if (!record.createProvider) {
+			const loaded = await record.loadProvider?.();
+			if (!loaded?.createProvider) {
+				throw new Error(`Provider "${providerId}" could not be loaded.`);
+			}
+			record.createProvider = loaded.createProvider;
+		}
+
+		const manifest = this.getManifest(providerId);
+		if (!manifest) {
+			throw new Error(`Provider "${providerId}" is disabled.`);
+		}
+
+		const config = this.providerConfigs.get(providerId);
+		const metadata = mergeProviderMetadata(
+			record.defaults?.metadata,
+			config?.metadata,
+		);
+
+		return {
+			manifest,
+			config: {
+				providerId,
+				apiKey: config?.apiKey ?? record.defaults?.apiKey,
+				apiKeyResolver:
+					config?.apiKeyResolver ?? record.defaults?.apiKeyResolver,
+				apiKeyEnv: config?.apiKeyEnv ?? record.defaults?.apiKeyEnv,
+				baseUrl: config?.baseUrl ?? record.defaults?.baseUrl,
+				headers: {
+					...(record.defaults?.headers ?? {}),
+					...(config?.headers ?? {}),
+				},
+				timeoutMs: config?.timeoutMs ?? record.defaults?.timeoutMs,
+				fetch: config?.fetch ?? record.defaults?.fetch ?? this.fallbackFetch,
+				options: {
+					...(record.defaults?.options ?? {}),
+					...(config?.options ?? {}),
+				},
+				metadata,
+			},
+			createProvider: record.createProvider,
+		};
+	}
+}
diff --git a/sdk/packages/llms/src/providers/routing/anthropic-compatible.test.ts b/sdk/packages/llms/src/providers/routing/anthropic-compatible.test.ts
new file mode 100644
index 0000000..5d0014d
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/anthropic-compatible.test.ts
@@ -0,0 +1,503 @@
+import type {
+	GatewayModelRoute,
+	GatewayProviderContext,
+	GatewayProviderManifest,
+} from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	isAnthropicCompatibleModel,
+	isAnthropicCompatibleModelId,
+	isClaudeModelId,
+	isGlmModel,
+	isQwenModel,
+} from "../model-facts";
+import {
+	applyPromptCacheToLastTextPart,
+	resolveAnthropicReasoningRequestPolicy,
+	resolvePromptCacheRoute,
+	shouldApplyPromptCache,
+} from "./anthropic-compatible";
+
+function makeProvider(
+	metadata?: GatewayProviderManifest["metadata"],
+): GatewayProviderManifest {
+	return {
+		id: "test-provider",
+		name: "Test Provider",
+		defaultModelId: "default-model",
+		models: [
+			{
+				id: "default-model",
+				name: "Default Model",
+				providerId: "test-provider",
+				capabilities: ["text"],
+			},
+		],
+		metadata,
+	};
+}
+
+function makeContext(
+	family?: string,
+	metadata?: GatewayProviderManifest["metadata"],
+	capabilities?: GatewayProviderContext["model"]["capabilities"],
+): GatewayProviderContext {
+	return {
+		provider: makeProvider(metadata),
+		model: {
+			id: "model-id",
+			name: "Model",
+			providerId: "test-provider",
+			capabilities,
+			metadata: family ? { family } : undefined,
+		},
+		config: {
+			providerId: "test-provider",
+		},
+	};
+}
+
+function metadataWithRouting(options: {
+	promptCacheRoutes?: GatewayModelRoute[];
+	reasoningRoutes?: GatewayModelRoute[];
+}): GatewayProviderManifest["metadata"] {
+	return {
+		routing: {
+			...(options.promptCacheRoutes
+				? {
+						promptCache: {
+							format: "anthropic-cache-control",
+							routes: options.promptCacheRoutes,
+						},
+					}
+				: {}),
+			...(options.reasoningRoutes
+				? {
+						reasoning: {
+							format: "anthropic-thinking",
+							routes: options.reasoningRoutes,
+						},
+					}
+				: {}),
+		},
+	};
+}
+
+describe("anthropic-compatible routing helpers", () => {
+	it("matches family metadata case-insensitively", () => {
+		expect(
+			isAnthropicCompatibleModel({
+				family: "Claude-Sonnet",
+			}),
+		).toBe(true);
+		expect(
+			isAnthropicCompatibleModel({
+				family: "Anthropic",
+			}),
+		).toBe(true);
+	});
+
+	it("falls back to model id when family is whitespace-only", () => {
+		expect(
+			isAnthropicCompatibleModel({
+				family: "   ",
+				modelId: "anthropic.claude-sonnet-4-6",
+			}),
+		).toBe(true);
+	});
+
+	it("recognizes bedrock and sap-style anthropic model ids", () => {
+		expect(isAnthropicCompatibleModelId("anthropic.claude-sonnet-4-6")).toBe(
+			true,
+		);
+		expect(
+			isAnthropicCompatibleModelId("eu.anthropic.claude-opus-4-6-v1"),
+		).toBe(true);
+		expect(isAnthropicCompatibleModelId("anthropic--claude-3.5-sonnet")).toBe(
+			true,
+		);
+		expect(isAnthropicCompatibleModelId("custom/anthropic-alias")).toBe(true);
+	});
+
+	it("does not match unrelated model ids", () => {
+		expect(isAnthropicCompatibleModelId("openai/gpt-5.4")).toBe(false);
+		expect(isAnthropicCompatibleModelId("gemini-3.1-flash-lite-preview")).toBe(
+			false,
+		);
+	});
+
+	it("keeps Qwen outside Anthropic compatibility and routes cache by provider metadata", () => {
+		expect(isAnthropicCompatibleModelId("qwen/qwen3.6-plus")).toBe(false);
+		expect(isQwenModel({ modelId: "qwen/qwen3.6-plus" })).toBe(true);
+		expect(isQwenModel({ modelId: "alibaba/qwen3.6-plus" })).toBe(true);
+		expect(isQwenModel({ family: "qwen" })).toBe(true);
+		expect(isQwenModel({ family: "qwen3.6" })).toBe(true);
+		expect(isQwenModel({ modelId: "anthropic/claude-sonnet-4.6" })).toBe(false);
+		expect(
+			resolvePromptCacheRoute(
+				{
+					providerId: "test-provider",
+					modelId: "qwen/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(),
+			),
+		).toBeUndefined();
+		expect(
+			resolvePromptCacheRoute(
+				{
+					providerId: "test-provider",
+					modelId: "alibaba/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(
+					"qwen3.6",
+					metadataWithRouting({
+						promptCacheRoutes: [
+							{
+								matcher: "model-family",
+								family: "qwen",
+								requiredCapability: "prompt-cache",
+							},
+						],
+					}),
+					["text", "prompt-cache"],
+				),
+			),
+		).toEqual({
+			matcher: "model-family",
+			family: "qwen",
+			requiredCapability: "prompt-cache",
+		});
+		expect(
+			resolvePromptCacheRoute(
+				{
+					providerId: "test-provider",
+					modelId: "alibaba/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(
+					"qwen",
+					metadataWithRouting({
+						promptCacheRoutes: [
+							{
+								matcher: "model-family",
+								family: "qwen",
+								requiredCapability: "prompt-cache",
+							},
+						],
+					}),
+					["text", "prompt-cache"],
+				),
+			),
+		).toEqual({
+			matcher: "model-family",
+			family: "qwen",
+			requiredCapability: "prompt-cache",
+		});
+		expect(
+			resolvePromptCacheRoute(
+				{
+					providerId: "test-provider",
+					modelId: "alibaba/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(
+					"qwen",
+					metadataWithRouting({
+						promptCacheRoutes: [
+							{
+								matcher: "model-family",
+								family: "qwen",
+								requiredCapability: "prompt-cache",
+							},
+						],
+					}),
+					["text"],
+				),
+			),
+		).toBeUndefined();
+		expect(
+			resolvePromptCacheRoute(
+				{
+					providerId: "test-provider",
+					modelId: "qwen/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(
+					undefined,
+					metadataWithRouting({
+						promptCacheRoutes: [
+							{ matcher: "model-id", modelId: "qwen/qwen3.6-plus" },
+						],
+					}),
+				),
+			),
+		).toEqual({ matcher: "model-id", modelId: "qwen/qwen3.6-plus" });
+	});
+
+	it("keeps Vertex Claude detection scoped to model id", () => {
+		expect(isClaudeModelId("anthropic.claude-sonnet-4-6")).toBe(true);
+		expect(isClaudeModelId("anthropic-vertex-experimental")).toBe(false);
+	});
+
+	it("matches GLM when either family or model id contains glm", () => {
+		expect(
+			isGlmModel({ modelId: "provider/glm-4.6" }, makeContext("other-family")),
+		).toBe(true);
+		expect(
+			isGlmModel({ modelId: "provider/other-model" }, makeContext("zai-glm")),
+		).toBe(true);
+	});
+
+	it("requires an explicit prompt-cache route", () => {
+		expect(
+			shouldApplyPromptCache(
+				{
+					providerId: "test-provider",
+					modelId: "anthropic.claude-sonnet-4-5",
+					messages: [],
+				},
+				makeContext(
+					undefined,
+					metadataWithRouting({
+						promptCacheRoutes: [{ matcher: "anthropic-compatible" }],
+					}),
+				),
+			),
+		).toBe(true);
+
+		expect(
+			shouldApplyPromptCache(
+				{
+					providerId: "test-provider",
+					modelId: "anthropic.claude-sonnet-4-5",
+					messages: [],
+				},
+				makeContext(),
+			),
+		).toBe(false);
+
+		expect(
+			shouldApplyPromptCache(
+				{
+					providerId: "test-provider",
+					modelId: "openai/gpt-5.4",
+					messages: [],
+				},
+				makeContext(
+					undefined,
+					metadataWithRouting({
+						promptCacheRoutes: [{ matcher: "anthropic-compatible" }],
+					}),
+				),
+			),
+		).toBe(false);
+	});
+
+	it("honors legacy promptCacheStrategy when routing metadata is absent", () => {
+		const request = {
+			providerId: "test-provider",
+			modelId: "anthropic/claude-3.5-sonnet",
+			messages: [],
+		};
+		const context = makeContext(undefined, {
+			promptCacheStrategy: "anthropic-automatic",
+		});
+
+		expect(resolvePromptCacheRoute(request, context)).toEqual({
+			matcher: "anthropic-compatible",
+		});
+		expect(shouldApplyPromptCache(request, context)).toBe(true);
+		expect(
+			shouldApplyPromptCache(
+				{
+					providerId: "test-provider",
+					modelId: "openai/gpt-5.4",
+					messages: [],
+				},
+				context,
+			),
+		).toBe(false);
+	});
+
+	it("preserves legacy promptCacheStrategy for custom Qwen providers", () => {
+		const request = {
+			providerId: "test-provider",
+			modelId: "qwen/qwen3.6-plus",
+			messages: [],
+		};
+		const context = makeContext(undefined, {
+			promptCacheStrategy: "anthropic-automatic",
+		});
+
+		expect(resolvePromptCacheRoute(request, context)).toEqual({
+			matcher: "model-id",
+			modelId: "qwen/qwen3.6-plus",
+		});
+		expect(shouldApplyPromptCache(request, context)).toBe(true);
+	});
+
+	it("preserves legacy Anthropic reasoning for custom Claude providers", () => {
+		const request = {
+			providerId: "test-provider",
+			modelId: "anthropic/claude-sonnet-4-5",
+			messages: [],
+		};
+		const context = makeContext("claude-sonnet", {
+			promptCacheStrategy: "anthropic-automatic",
+		});
+
+		expect(resolveAnthropicReasoningRequestPolicy(request, context)).toEqual({
+			kind: "anthropic-manual",
+		});
+	});
+
+	it("preserves unrouted Anthropic reasoning for custom Claude providers", () => {
+		const request = {
+			providerId: "test-provider",
+			modelId: "anthropic/claude-3.5-sonnet",
+			messages: [],
+		};
+
+		expect(
+			resolveAnthropicReasoningRequestPolicy(request, makeContext()),
+		).toEqual({
+			kind: "anthropic-manual",
+		});
+	});
+
+	it("does not preserve legacy Anthropic reasoning for custom Qwen providers", () => {
+		const request = {
+			providerId: "test-provider",
+			modelId: "qwen/qwen3.6-plus",
+			messages: [],
+		};
+		const context = makeContext("qwen", {
+			promptCacheStrategy: "anthropic-automatic",
+		});
+
+		expect(resolveAnthropicReasoningRequestPolicy(request, context)).toEqual({
+			kind: "none",
+		});
+	});
+
+	it("keeps prompt-cache routes separate from reasoning routes", () => {
+		expect(
+			resolveAnthropicReasoningRequestPolicy(
+				{
+					providerId: "test-provider",
+					modelId: "anthropic.claude-sonnet-4-5",
+					messages: [],
+				},
+				makeContext(
+					"claude-sonnet",
+					metadataWithRouting({
+						promptCacheRoutes: [{ matcher: "anthropic-compatible" }],
+					}),
+				),
+			),
+		).toEqual({ kind: "none" });
+
+		expect(
+			resolveAnthropicReasoningRequestPolicy(
+				{
+					providerId: "test-provider",
+					modelId: "anthropic.claude-sonnet-4-5",
+					messages: [],
+				},
+				makeContext(
+					"claude-sonnet",
+					metadataWithRouting({
+						reasoningRoutes: [
+							{
+								matcher: "anthropic-compatible",
+							},
+						],
+					}),
+				),
+			),
+		).toEqual({ kind: "anthropic-manual" });
+	});
+
+	it("enables Anthropic-style prompt cache for Qwen when the provider opts in", () => {
+		expect(
+			shouldApplyPromptCache(
+				{
+					providerId: "test-provider",
+					modelId: "qwen/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(
+					undefined,
+					metadataWithRouting({
+						promptCacheRoutes: [
+							{ matcher: "model-id", modelId: "qwen/qwen3.6-plus" },
+						],
+					}),
+				),
+			),
+		).toBe(true);
+		expect(
+			resolveAnthropicReasoningRequestPolicy(
+				{
+					providerId: "test-provider",
+					modelId: "qwen/qwen3.6-plus",
+					messages: [],
+				},
+				makeContext(
+					undefined,
+					metadataWithRouting({
+						promptCacheRoutes: [
+							{ matcher: "model-id", modelId: "qwen/qwen3.6-plus" },
+						],
+					}),
+				),
+			),
+		).toEqual({ kind: "none" });
+	});
+
+	it("adds the non-Anthropic filler when only one text part is present", () => {
+		const message = {
+			content: [
+				{ type: "image_url", image_url: { url: "https://example.test/a.png" } },
+				{ type: "text", text: "Hello" },
+			],
+		};
+
+		applyPromptCacheToLastTextPart(message, "openrouter", false);
+
+		expect(message.content).toHaveLength(3);
+		expect(message.content[1]).toMatchObject({
+			type: "text",
+			text: "Hello",
+			providerOptions: {
+				openaiCompatible: { cache_control: { type: "ephemeral" } },
+				openrouter: { cache_control: { type: "ephemeral" } },
+			},
+		});
+		expect(message.content[2]).toEqual({ type: "text", text: " " });
+	});
+
+	it("does not add the non-Anthropic filler when multiple text parts are present", () => {
+		const message = {
+			content: [
+				{ type: "image_url", image_url: { url: "https://example.test/a.png" } },
+				{ type: "text", text: "Hello" },
+				{ type: "text", text: "World" },
+			],
+		};
+
+		applyPromptCacheToLastTextPart(message, "openrouter", false);
+
+		expect(message.content).toHaveLength(3);
+		expect(message.content[2]).toMatchObject({
+			type: "text",
+			text: "World",
+			providerOptions: {
+				openaiCompatible: { cache_control: { type: "ephemeral" } },
+				openrouter: { cache_control: { type: "ephemeral" } },
+			},
+		});
+	});
+});
diff --git a/sdk/packages/llms/src/providers/routing/anthropic-compatible.ts b/sdk/packages/llms/src/providers/routing/anthropic-compatible.ts
new file mode 100644
index 0000000..41ad7c4
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/anthropic-compatible.ts
@@ -0,0 +1,616 @@
+import type {
+	GatewayModelRoute,
+	GatewayPromptCacheStrategy,
+	GatewayProviderContext,
+	GatewayProviderManifest,
+	GatewayProviderMetadata,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import {
+	isAnthropicCompatibleModel,
+	isQwenModel,
+	modelRouteMatches,
+	resolveModelFamily,
+} from "../model-facts";
+import { createEphemeralCacheControl, toProviderOptionsKey } from "./utils";
+
+const ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS = 1024;
+const ANTHROPIC_MAX_THINKING_BUDGET_TOKENS = 128000;
+const ANTHROPIC_REASONING_EFFORT_BUDGET_RATIOS: Record<string, number> = {
+	low: 0.2,
+	medium: 0.5,
+	high: 0.8,
+};
+
+export type AnthropicReasoningRequestPolicy =
+	| { kind: "none" }
+	| { kind: "anthropic-manual" }
+	| { kind: "anthropic-adaptive" };
+
+/**
+ * Provider metadata owns behavior routing. `anthropic-compatible` is one route
+ * matcher for Claude/Anthropic lineage; prompt-cache and reasoning decide
+ * independently whether they use it.
+ */
+
+const ANTHROPIC_COMPATIBLE_ROUTE: GatewayModelRoute = {
+	matcher: "anthropic-compatible",
+};
+
+// Qwen cache support is model-specific; direct Dashscope/OpenRouter catalogs
+// only match this route once their model metadata includes prompt-cache support.
+const QWEN_PROMPT_CACHE_ROUTE: GatewayModelRoute = {
+	matcher: "model-family",
+	family: "qwen",
+	requiredCapability: "prompt-cache",
+};
+
+function createAnthropicRoutingMetadata(options?: {
+	promptCacheRoutes?: GatewayModelRoute[];
+	reasoningRoutes?: GatewayModelRoute[];
+}): GatewayProviderMetadata {
+	const promptCacheRoutes: GatewayModelRoute[] = options?.promptCacheRoutes ?? [
+		ANTHROPIC_COMPATIBLE_ROUTE,
+	];
+	const reasoningRoutes: GatewayModelRoute[] = options?.reasoningRoutes ?? [
+		ANTHROPIC_COMPATIBLE_ROUTE,
+	];
+	return {
+		routing: {
+			...(promptCacheRoutes.length > 0
+				? {
+						promptCache: {
+							format: "anthropic-cache-control",
+							routes: promptCacheRoutes.map((route) => ({ ...route })),
+						},
+					}
+				: {}),
+			...(reasoningRoutes.length > 0
+				? {
+						reasoning: {
+							format: "anthropic-thinking",
+							routes: reasoningRoutes.map((route) => ({ ...route })),
+						},
+					}
+				: {}),
+		},
+	};
+}
+
+export const ANTHROPIC_ROUTING_METADATA = createAnthropicRoutingMetadata();
+
+export const QWEN_CACHE_ROUTING_METADATA = createAnthropicRoutingMetadata({
+	promptCacheRoutes: [QWEN_PROMPT_CACHE_ROUTE],
+	reasoningRoutes: [],
+});
+
+export const ANTHROPIC_AND_QWEN_CACHE_ROUTING_METADATA =
+	createAnthropicRoutingMetadata({
+		promptCacheRoutes: [ANTHROPIC_COMPATIBLE_ROUTE, QWEN_PROMPT_CACHE_ROUTE],
+	});
+
+export function createPromptCacheProviderOptions(
+	providerId: string,
+	includeAnthropic: boolean,
+) {
+	const providerOptions: Record<string, unknown> = {
+		openaiCompatible: createEphemeralCacheControl(),
+		[providerId]: createEphemeralCacheControl(),
+	};
+
+	const providerOptionsKey = toProviderOptionsKey(providerId);
+	if (providerOptionsKey !== providerId) {
+		providerOptions[providerOptionsKey] = createEphemeralCacheControl();
+	}
+	if (includeAnthropic) {
+		providerOptions.anthropic = createEphemeralCacheControl();
+	}
+
+	return providerOptions;
+}
+
+export function applyPromptCacheToLastTextPart(
+	message: Record<string, unknown> | undefined,
+	providerId: string,
+	includeAnthropic: boolean,
+): void {
+	if (!message) {
+		return;
+	}
+
+	const content = message.content;
+	if (typeof content === "string") {
+		const cachedContent: Record<string, unknown>[] = [
+			{
+				type: "text",
+				text: content,
+				providerOptions: createPromptCacheProviderOptions(
+					providerId,
+					includeAnthropic,
+				),
+			},
+		];
+		if (!includeAnthropic) {
+			// Keep non-Anthropic OpenAI-compatible requests multipart so
+			// cache_control remains on the content part instead of being collapsed
+			// to message metadata. Anthropic rejects whitespace-only text blocks.
+			cachedContent.push({ type: "text", text: " " });
+		}
+		message.content = cachedContent;
+		return;
+	}
+
+	if (!Array.isArray(content)) {
+		return;
+	}
+
+	const textPartCount = content.filter(
+		(part) =>
+			part &&
+			typeof part === "object" &&
+			(part as { type?: unknown }).type === "text",
+	).length;
+
+	for (let i = content.length - 1; i >= 0; i--) {
+		const part = content[i];
+		if (
+			part &&
+			typeof part === "object" &&
+			(part as { type?: unknown }).type === "text"
+		) {
+			const needsFiller = textPartCount === 1 && !includeAnthropic;
+			content[i] = {
+				...(part as Record<string, unknown>),
+				providerOptions: createPromptCacheProviderOptions(
+					providerId,
+					includeAnthropic,
+				),
+			};
+			if (needsFiller) {
+				content.push({ type: "text", text: " " });
+			}
+			return;
+		}
+	}
+}
+
+export function shouldApplyPromptCache(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): boolean {
+	return resolvePromptCacheRoute(request, context) !== undefined;
+}
+
+function shouldApplyAnthropicCacheBucket(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): boolean {
+	return (
+		resolvePromptCacheRoute(request, context)?.matcher ===
+		"anthropic-compatible"
+	);
+}
+
+function resolveLegacyPromptCacheStrategy(
+	provider: GatewayProviderManifest,
+): GatewayPromptCacheStrategy | undefined {
+	return provider.metadata?.promptCacheStrategy === "anthropic-automatic"
+		? "anthropic-automatic"
+		: undefined;
+}
+
+function resolveLegacyPromptCacheRoute(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): GatewayModelRoute | undefined {
+	if (
+		resolveLegacyPromptCacheStrategy(context.provider) !== "anthropic-automatic"
+	) {
+		return undefined;
+	}
+
+	const family = resolveModelFamily(context);
+	if (
+		isAnthropicCompatibleModel({
+			modelId: request.modelId,
+			family,
+		})
+	) {
+		return { matcher: "anthropic-compatible" };
+	}
+
+	// `promptCacheStrategy` predates explicit routing and historically treated
+	// Qwen ids as Anthropic-compatible. Preserve that opt-in custom-provider
+	// behavior, but keep the returned route non-Anthropic so Qwen still gets the
+	// OpenAI-compatible cache_control shape used by the new routing path.
+	if (isQwenModel({ modelId: request.modelId, family })) {
+		return family
+			? { matcher: "model-family", family }
+			: { matcher: "model-id", modelId: request.modelId };
+	}
+
+	return undefined;
+}
+
+function resolveLegacyReasoningRoute(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): GatewayModelRoute | undefined {
+	if (
+		resolveLegacyPromptCacheStrategy(context.provider) !== "anthropic-automatic"
+	) {
+		return undefined;
+	}
+
+	const family = resolveModelFamily(context);
+	return isAnthropicCompatibleModel({
+		modelId: request.modelId,
+		family,
+	})
+		? { matcher: "anthropic-compatible" }
+		: undefined;
+}
+
+function resolveUnroutedAnthropicReasoningRoute(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): GatewayModelRoute | undefined {
+	if (context.provider.metadata?.routing) {
+		return undefined;
+	}
+
+	const family = resolveModelFamily(context);
+	return isAnthropicCompatibleModel({
+		modelId: request.modelId,
+		family,
+	})
+		? { matcher: "anthropic-compatible" }
+		: undefined;
+}
+
+export function resolvePromptCacheRoute(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): GatewayModelRoute | undefined {
+	const promptCache = context.provider.metadata?.routing?.promptCache;
+	if (promptCache) {
+		if (promptCache.format !== "anthropic-cache-control") {
+			return undefined;
+		}
+
+		return promptCache.routes.find((route) =>
+			modelRouteMatches(route, {
+				modelId: request.modelId,
+				family: resolveModelFamily(context),
+				capabilities: context.model.capabilities,
+			}),
+		);
+	}
+
+	return resolveLegacyPromptCacheRoute(request, context);
+}
+
+export function resolveReasoningRoute(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): GatewayModelRoute | undefined {
+	const reasoning = context.provider.metadata?.routing?.reasoning;
+	if (!reasoning) {
+		return (
+			resolveLegacyReasoningRoute(request, context) ??
+			resolveUnroutedAnthropicReasoningRoute(request, context)
+		);
+	}
+	if (reasoning.format !== "anthropic-thinking") {
+		return undefined;
+	}
+
+	return reasoning.routes.find((route) =>
+		modelRouteMatches(route, {
+			modelId: request.modelId,
+			family: resolveModelFamily(context),
+			capabilities: context.model.capabilities,
+		}),
+	);
+}
+
+export function shouldEmitAnthropicReasoning(
+	context: GatewayProviderContext,
+): boolean {
+	const capabilities = context.model.capabilities;
+	return !capabilities || capabilities.includes("reasoning");
+}
+
+function resolveClaudeLine(
+	modelId: string | undefined,
+	family: string | undefined,
+) {
+	const normalizedFamily = family?.toLowerCase() ?? "";
+	const normalizedModelId = modelId?.toLowerCase() ?? "";
+
+	if (normalizedFamily.includes("opus") || normalizedModelId.includes("opus")) {
+		return "opus" as const;
+	}
+	if (
+		normalizedFamily.includes("sonnet") ||
+		normalizedModelId.includes("sonnet")
+	) {
+		return "sonnet" as const;
+	}
+	if (
+		normalizedFamily.includes("haiku") ||
+		normalizedModelId.includes("haiku")
+	) {
+		return "haiku" as const;
+	}
+
+	return undefined;
+}
+
+function resolveClaudeVersion(modelId: string | undefined) {
+	const normalized = modelId?.toLowerCase() ?? "";
+	const versionFirstMatch =
+		/claude-(\d+)[.-](\d{1,2})-(?:opus|sonnet|haiku)/i.exec(normalized);
+	const lineFirstMatch = /claude-(?:opus|sonnet|haiku)-(.+)/i.exec(normalized);
+	const tokens = lineFirstMatch?.[1]?.match(/\d+/g) ?? [];
+	const majorToken = versionFirstMatch?.[1] ?? tokens[0];
+	const minorToken =
+		versionFirstMatch?.[2] ?? (tokens[1]?.length <= 2 ? tokens[1] : undefined);
+	if (!majorToken || !minorToken) {
+		return undefined;
+	}
+
+	const major = Number.parseInt(majorToken, 10);
+	const minor = Number.parseInt(minorToken, 10);
+	if (!Number.isFinite(major) || !Number.isFinite(minor)) {
+		return undefined;
+	}
+	return { major, minor };
+}
+
+function supportsAnthropicAdaptiveThinkingPolicy(options: {
+	modelId?: string;
+	family?: string;
+}): boolean {
+	const line = resolveClaudeLine(options.modelId, options.family);
+	const version = resolveClaudeVersion(options.modelId);
+	if (!line || !version) {
+		return false;
+	}
+
+	// See https://platform.claude.com/docs/en/build-with-claude/extended-thinking
+	if (version.major !== 4) {
+		return version.major > 4;
+	}
+
+	return (line === "opus" || line === "sonnet") && version.minor >= 6;
+}
+
+export function resolveAnthropicReasoningRequestPolicy(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+): AnthropicReasoningRequestPolicy {
+	const family = resolveModelFamily(context);
+	if (
+		!resolveReasoningRoute(request, context) ||
+		!shouldEmitAnthropicReasoning(context)
+	) {
+		return { kind: "none" };
+	}
+
+	return supportsAnthropicAdaptiveThinkingPolicy({
+		modelId: request.modelId,
+		family,
+	})
+		? { kind: "anthropic-adaptive" }
+		: { kind: "anthropic-manual" };
+}
+
+export function buildAnthropicProviderOptions(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+) {
+	const policy = resolveAnthropicReasoningRequestPolicy(request, context);
+	const wantsAnthropicThinking =
+		request.reasoning?.enabled === true ||
+		request.reasoning?.effort !== undefined ||
+		(typeof request.reasoning?.budgetTokens === "number" &&
+			request.reasoning.budgetTokens > 0);
+
+	const thinking: Record<string, unknown> | undefined = wantsAnthropicThinking
+		? policy.kind === "anthropic-adaptive"
+			? { type: "adaptive" }
+			: policy.kind === "anthropic-manual"
+				? {
+						type: "enabled",
+						budgetTokens: resolveAnthropicCompatibleReasoningBudget({
+							modelId: request.modelId,
+							family: resolveModelFamily(context),
+							effort: request.reasoning?.effort,
+							maxTokens: request.maxTokens,
+							explicitBudgetTokens: request.reasoning?.budgetTokens,
+						}),
+					}
+				: undefined
+		: undefined;
+
+	return {
+		...(policy.kind === "anthropic-adaptive" && request.reasoning?.effort
+			? { effort: request.reasoning.effort }
+			: {}),
+		...(thinking ? { thinking } : {}),
+		...(shouldApplyAnthropicCacheBucket(request, context)
+			? createEphemeralCacheControl()
+			: {}),
+	};
+}
+
+export function resolveAnthropicCompatibleReasoningBudget(options: {
+	modelId?: string;
+	family?: string;
+	effort?: string;
+	maxTokens?: number;
+	explicitBudgetTokens?: number;
+}) {
+	if (
+		typeof options.explicitBudgetTokens === "number" &&
+		options.explicitBudgetTokens > 0
+	) {
+		return options.explicitBudgetTokens;
+	}
+
+	if (
+		(!options.modelId && !options.family) ||
+		!isAnthropicCompatibleModel({
+			modelId: options.modelId,
+			family: options.family,
+		})
+	) {
+		return undefined;
+	}
+	if (!options.effort) {
+		return ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS;
+	}
+	if (typeof options.maxTokens !== "number") {
+		return ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS;
+	}
+	if (options.maxTokens <= ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS) {
+		return ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS;
+	}
+
+	const ratio = ANTHROPIC_REASONING_EFFORT_BUDGET_RATIOS[options.effort];
+	if (!ratio) {
+		return ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS;
+	}
+
+	const maxBudget = Math.min(
+		options.maxTokens - 1,
+		ANTHROPIC_MAX_THINKING_BUDGET_TOKENS,
+	);
+	return Math.max(
+		ANTHROPIC_DEFAULT_THINKING_BUDGET_TOKENS,
+		Math.floor(maxBudget * ratio),
+	);
+}
+
+export function buildAnthropicCompatibleReasoningOptions(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+) {
+	const policy = resolveAnthropicReasoningRequestPolicy(request, context);
+	if (
+		policy.kind === "none" ||
+		(!request.reasoning?.enabled &&
+			!request.reasoning?.effort &&
+			typeof request.reasoning?.budgetTokens !== "number")
+	) {
+		return undefined;
+	}
+
+	const budgetTokens = resolveAnthropicCompatibleReasoningBudget({
+		modelId: request.modelId,
+		family: resolveModelFamily(context),
+		effort: request.reasoning?.effort,
+		maxTokens: request.maxTokens,
+		explicitBudgetTokens: request.reasoning?.budgetTokens,
+	});
+	const reasoning: Record<string, unknown> = {};
+
+	if (request.reasoning?.enabled === true) {
+		reasoning.enabled = true;
+	}
+	if (policy.kind === "anthropic-adaptive" && request.reasoning?.effort) {
+		reasoning.effort = request.reasoning.effort;
+	}
+	if (typeof request.reasoning?.budgetTokens === "number") {
+		reasoning.max_tokens = request.reasoning.budgetTokens;
+	} else if (
+		policy.kind === "anthropic-manual" &&
+		typeof budgetTokens === "number" &&
+		budgetTokens >= 0
+	) {
+		reasoning.max_tokens = budgetTokens;
+	}
+
+	return Object.keys(reasoning).length > 0 ? reasoning : undefined;
+}
+
+export function buildGatewayReasoningOptions(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+) {
+	if (
+		request.reasoning?.enabled === undefined &&
+		!request.reasoning?.effort &&
+		typeof request.reasoning?.budgetTokens !== "number"
+	) {
+		return undefined;
+	}
+
+	const policy = resolveAnthropicReasoningRequestPolicy(request, context);
+	const reasoningRoute = resolveReasoningRoute(request, context);
+	const family = resolveModelFamily(context);
+	const shouldSuppressUnsupportedRoutedReasoning =
+		policy.kind === "none" && reasoningRoute !== undefined;
+	const shouldSuppressUnroutedAnthropicLikeReasoning =
+		policy.kind === "none" &&
+		reasoningRoute === undefined &&
+		(shouldApplyPromptCache(request, context) ||
+			isQwenModel({
+				modelId: request.modelId,
+				family,
+			}) ||
+			isAnthropicCompatibleModel({
+				modelId: request.modelId,
+				family,
+			}));
+	if (
+		shouldSuppressUnsupportedRoutedReasoning ||
+		shouldSuppressUnroutedAnthropicLikeReasoning
+	) {
+		return undefined;
+	}
+
+	const budgetTokens =
+		policy.kind === "anthropic-manual"
+			? resolveAnthropicCompatibleReasoningBudget({
+					modelId: request.modelId,
+					family,
+					effort: request.reasoning?.effort,
+					maxTokens: request.maxTokens,
+					explicitBudgetTokens: request.reasoning?.budgetTokens,
+				})
+			: request.reasoning?.budgetTokens;
+	const shouldSendDisabledReasoning =
+		request.reasoning?.enabled === false &&
+		// FIXME: temporary compatibility patch for models that reject disabled
+		// reasoning. Remove once routed providers normalize disabled reasoning
+		// consistently, or replace with a systematic model policy.
+		!modelRejectsDisabledReasoning(request.modelId);
+	const reasoning: Record<string, unknown> = {
+		...(request.reasoning?.enabled === true
+			? { enabled: true }
+			: shouldSendDisabledReasoning
+				? { enabled: false }
+				: request.reasoning?.effort
+					? { enabled: true }
+					: {}),
+		...(request.reasoning?.effort && policy.kind !== "anthropic-manual"
+			? { effort: request.reasoning.effort }
+			: {}),
+	};
+
+	if (typeof budgetTokens === "number" && budgetTokens >= 0) {
+		reasoning.max_tokens = budgetTokens;
+	}
+
+	return Object.keys(reasoning).length > 0 ? reasoning : undefined;
+}
+
+function modelRejectsDisabledReasoning(modelId: string): boolean {
+	const normalized = modelId.toLowerCase();
+	return (
+		normalized.includes("claude-fable") ||
+		normalized.includes("stepfun/step-3.7-flash")
+	);
+}
diff --git a/sdk/packages/llms/src/providers/routing/generic-compatible.ts b/sdk/packages/llms/src/providers/routing/generic-compatible.ts
new file mode 100644
index 0000000..59bf0cb
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/generic-compatible.ts
@@ -0,0 +1,151 @@
+import type {
+	GatewayProviderContext,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import {
+	isAnthropicCompatibleModel,
+	isQwenModel,
+	resolveModelFamily,
+} from "../model-facts";
+import {
+	buildAnthropicCompatibleReasoningOptions,
+	resolveAnthropicReasoningRequestPolicy,
+	resolveReasoningRoute,
+	shouldApplyPromptCache,
+} from "./anthropic-compatible";
+import type {
+	AiSdkProviderOptionsTarget,
+	ProviderOptionSuppression,
+} from "./provider-options-types";
+import { createEphemeralCacheControl } from "./utils";
+
+export function buildOpenAINativeProviderOptions(
+	request: GatewayStreamRequest,
+): Record<string, unknown> {
+	const isNativeOpenAIClient = ["openai-native", "openai"].includes(
+		request.providerId,
+	);
+	return isNativeOpenAIClient ? { truncation: "auto" } : {};
+}
+
+function buildCompatibleThinkingOptions(options: {
+	request: GatewayStreamRequest;
+	context: GatewayProviderContext;
+	suppressions: ProviderOptionSuppression;
+}): Record<string, unknown> {
+	const { request, context, suppressions } = options;
+	if (suppressions.genericThinking) {
+		return {};
+	}
+	if (request.reasoning?.enabled !== true) {
+		return {};
+	}
+
+	const family = resolveModelFamily(context);
+	const anthropicPolicy = resolveAnthropicReasoningRequestPolicy(
+		request,
+		context,
+	);
+	const hasAnthropicReasoningRoute =
+		resolveReasoningRoute(request, context) !== undefined;
+	const hasPromptCacheRoute = shouldApplyPromptCache(request, context);
+	const isAnthropicCompatible = isAnthropicCompatibleModel({
+		modelId: request.modelId,
+		family,
+	});
+	const isQwen = isQwenModel({
+		modelId: request.modelId,
+		family,
+	});
+	if (
+		!hasAnthropicReasoningRoute &&
+		(hasPromptCacheRoute || isQwen || isAnthropicCompatible)
+	) {
+		return {};
+	}
+	if (
+		hasAnthropicReasoningRoute &&
+		anthropicPolicy.kind !== "anthropic-adaptive"
+	) {
+		return {};
+	}
+	return { thinking: { type: "adaptive" } };
+}
+
+function buildCompatibleEffortOptions(options: {
+	reasoning: GatewayStreamRequest["reasoning"];
+	usesAnthropicReasoningRoute: boolean;
+	suppressEffortOptions: boolean;
+	suppressions: ProviderOptionSuppression;
+	anthropicReasoningPolicyKind?: ReturnType<
+		typeof resolveAnthropicReasoningRequestPolicy
+	>["kind"];
+}): Record<string, unknown> {
+	const effort = options.reasoning?.effort;
+	if (
+		options.suppressions.genericEffort ||
+		!effort ||
+		options.reasoning?.enabled === false ||
+		options.suppressEffortOptions
+	) {
+		return {};
+	}
+	const allowEffort =
+		!options.usesAnthropicReasoningRoute ||
+		options.anthropicReasoningPolicyKind === "anthropic-adaptive";
+	if (!allowEffort) {
+		return {};
+	}
+	return {
+		effort,
+		reasoningEffort: effort,
+		...(options.usesAnthropicReasoningRoute
+			? {}
+			: { reasoningSummary: "auto" }),
+	};
+}
+
+export function buildCompatibleProviderOptions(options: {
+	request: GatewayStreamRequest;
+	context: GatewayProviderContext;
+	target: AiSdkProviderOptionsTarget;
+	suppressions: ProviderOptionSuppression;
+}): Record<string, unknown> {
+	const { request, context, target, suppressions } = options;
+	const family = resolveModelFamily(context);
+	const anthropicReasoningPolicy = resolveAnthropicReasoningRequestPolicy(
+		request,
+		context,
+	);
+	const usesAnthropicReasoningRoute =
+		resolveReasoningRoute(request, context) !== undefined;
+	const hasPromptCacheRoute = shouldApplyPromptCache(request, context);
+	const isAnthropicCompatible = isAnthropicCompatibleModel({
+		modelId: request.modelId,
+		family,
+	});
+	const isQwen = isQwenModel({
+		modelId: request.modelId,
+		family,
+	});
+	const suppressCompatibleReasoningOptions =
+		!usesAnthropicReasoningRoute &&
+		(hasPromptCacheRoute || isQwen || isAnthropicCompatible);
+	const reasoning = buildAnthropicCompatibleReasoningOptions(request, context);
+	const promptCache = hasPromptCacheRoute ? createEphemeralCacheControl() : {};
+
+	return {
+		...(target === "openai-compatible" ? { strictJsonSchema: false } : {}),
+		...buildCompatibleThinkingOptions({ request, context, suppressions }),
+		...buildCompatibleEffortOptions({
+			reasoning: request.reasoning,
+			usesAnthropicReasoningRoute,
+			suppressEffortOptions: suppressCompatibleReasoningOptions,
+			suppressions,
+			anthropicReasoningPolicyKind: anthropicReasoningPolicy.kind,
+		}),
+		...(reasoning ? { reasoning } : {}),
+		...promptCache,
+		...buildOpenAINativeProviderOptions(request),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/routing/glm-thinking.ts b/sdk/packages/llms/src/providers/routing/glm-thinking.ts
new file mode 100644
index 0000000..54f557e
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/glm-thinking.ts
@@ -0,0 +1,106 @@
+import type {
+	GatewayProviderContext,
+	GatewayProviderMetadata,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import { isGlmModel } from "../model-facts";
+import type { ProviderOptionsPatch } from "./utils";
+
+/**
+ * GLM thinking routing.
+ *
+ * Native Z.AI uses `thinking: { type: "enabled" | "disabled" }`.
+ * Routed OpenAI-compatible GLM endpoints should use the generic `reasoning`
+ * control shape. The return value is a normal provider-options patch so the
+ * composer can rely on merge order instead of out-of-band flags.
+ */
+
+export const GLM_THINKING_ROUTING_METADATA: GatewayProviderMetadata = {
+	routing: {
+		reasoning: {
+			format: "glm-thinking",
+			routes: [
+				{ matcher: "model-family", family: "glm" },
+				{ matcher: "model-family", family: "glm-air" },
+				{ matcher: "model-family", family: "glm-flash" },
+			],
+		},
+	},
+};
+
+function buildNativeZaiThinkingOptions(request: GatewayStreamRequest) {
+	if (request.reasoning?.enabled === undefined) {
+		return undefined;
+	}
+	return {
+		thinking: {
+			type: request.reasoning.enabled ? "enabled" : "disabled",
+		},
+	};
+}
+
+function buildRoutedGlmReasoningOptions(request: GatewayStreamRequest) {
+	if (request.reasoning?.enabled === true) {
+		return {
+			reasoning: {
+				enabled: true,
+			},
+		};
+	}
+	if (request.reasoning?.enabled === false) {
+		return {
+			reasoning: {
+				exclude: true,
+			},
+		};
+	}
+	return undefined;
+}
+
+export function buildNativeGlmThinkingProviderOptionsPatch(
+	request: GatewayStreamRequest,
+	providerOptionsKey: string,
+): ProviderOptionsPatch | undefined {
+	// Native Z.AI GLM endpoints expect `thinking.type`; they do not accept the
+	// routed `reasoning.enabled` / `reasoning.exclude` shape.
+	const nativeThinking = buildNativeZaiThinkingOptions(request);
+	return nativeThinking
+		? {
+				openaiCompatible: nativeThinking,
+				[request.providerId]: nativeThinking,
+				...(providerOptionsKey !== request.providerId
+					? { [providerOptionsKey]: nativeThinking }
+					: {}),
+			}
+		: undefined;
+}
+
+export function buildRoutedGlmReasoningProviderOptionsPatch(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+	providerOptionsKey: string,
+	options?: { includeProviderBuckets?: boolean },
+): ProviderOptionsPatch | undefined {
+	// Routed GLM endpoints stay OpenAI-compatible and use the generic
+	// `reasoning` include/exclude shape instead of native Z.AI `thinking.type`.
+	if (!isGlmModel(request, context)) {
+		return undefined;
+	}
+
+	const routed = buildRoutedGlmReasoningOptions(request);
+	if (!routed) {
+		return undefined;
+	}
+
+	return {
+		openaiCompatible: routed,
+		...(options?.includeProviderBuckets === false
+			? {}
+			: {
+					[request.providerId]: routed,
+					...(providerOptionsKey !== request.providerId
+						? { [providerOptionsKey]: routed }
+						: {}),
+				}),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/routing/minimax-thinking.ts b/sdk/packages/llms/src/providers/routing/minimax-thinking.ts
new file mode 100644
index 0000000..3e747e4
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/minimax-thinking.ts
@@ -0,0 +1,75 @@
+import type {
+	GatewayProviderMetadata,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import { buildProviderAndAliasPatch, type ProviderOptionsPatch } from "./utils";
+
+export const MINIMAX_THINKING_ROUTING_METADATA: GatewayProviderMetadata = {
+	routing: {
+		promptCache: {
+			format: "anthropic-cache-control",
+			routes: [{ matcher: "anthropic-compatible" }],
+		},
+		reasoning: {
+			format: "minimax-thinking",
+			routes: [
+				{
+					matcher: "model-id",
+					modelId: "MiniMax-M3",
+					requiredCapability: "reasoning",
+				},
+			],
+		},
+	},
+};
+
+function buildMiniMaxThinkingOptions(request: GatewayStreamRequest) {
+	if (request.reasoning?.enabled === true) {
+		return { thinking: { type: "adaptive" } };
+	}
+	if (request.reasoning?.enabled === false) {
+		return { thinking: { type: "disabled" } };
+	}
+	return undefined;
+}
+
+function buildMiniMaxGatewayReasoningOptions(request: GatewayStreamRequest) {
+	if (request.reasoning?.enabled === true) {
+		return { reasoning: { enabled: true } };
+	}
+	if (request.reasoning?.enabled === false) {
+		return { reasoning: { exclude: true } };
+	}
+	return undefined;
+}
+
+export function buildMiniMaxThinkingProviderOptionsPatch(
+	request: GatewayStreamRequest,
+	providerOptionsKey: string,
+): ProviderOptionsPatch | undefined {
+	const thinking = buildMiniMaxThinkingOptions(request);
+	if (!thinking) {
+		return undefined;
+	}
+	return {
+		openaiCompatible: thinking,
+		[request.providerId]: thinking,
+		...(providerOptionsKey !== request.providerId
+			? { [providerOptionsKey]: thinking }
+			: {}),
+	};
+}
+
+export function buildMiniMaxGatewayReasoningProviderOptionsPatch(
+	request: GatewayStreamRequest,
+	providerOptionsKey: string,
+): ProviderOptionsPatch | undefined {
+	const reasoning = buildMiniMaxGatewayReasoningOptions(request);
+	return reasoning
+		? buildProviderAndAliasPatch({
+				providerId: request.providerId,
+				providerOptionsKey,
+				bucketOptions: reasoning,
+			})
+		: undefined;
+}
diff --git a/sdk/packages/llms/src/providers/routing/provider-option-rules.ts b/sdk/packages/llms/src/providers/routing/provider-option-rules.ts
new file mode 100644
index 0000000..a4fb80c
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/provider-option-rules.ts
@@ -0,0 +1,548 @@
+import { isClineProvider } from "@cline/shared";
+import {
+	isDeepSeekFamily,
+	isGemini3Model,
+	isGeminiFlashModel,
+	isGeminiProModel,
+	isGlmModel,
+	isKimiK26Family as isKimiK26FamilyFact,
+	isMiniMaxM3Model,
+	isMoonshotKimiModelIdFallback,
+	modelReasoningDefaultsOn,
+	providerReasoningRouteMatches,
+	supportsGeminiThinking,
+} from "../model-facts";
+import { buildGatewayReasoningOptions } from "./anthropic-compatible";
+import { buildOpenAINativeProviderOptions } from "./generic-compatible";
+import {
+	buildNativeGlmThinkingProviderOptionsPatch,
+	buildRoutedGlmReasoningProviderOptionsPatch,
+} from "./glm-thinking";
+import {
+	buildMiniMaxGatewayReasoningProviderOptionsPatch,
+	buildMiniMaxThinkingProviderOptionsPatch,
+} from "./minimax-thinking";
+import type {
+	MatchedProviderOptionRule,
+	ProviderOptionBuildInput,
+	ProviderOptionMatchInput,
+	ProviderOptionRule,
+	ProviderOptionSuppression,
+} from "./provider-options-types";
+import { buildOpenRouterReasoningOptions } from "./reasoning-codecs";
+import {
+	buildProviderAndAliasPatch,
+	buildThinkingPatch,
+	type ProviderOptionsPatch,
+} from "./utils";
+
+function isKimiK26Family(input: ProviderOptionMatchInput): boolean {
+	return isKimiK26FamilyFact(input.context);
+}
+
+function isMoonshotKimiModel(input: ProviderOptionMatchInput): boolean {
+	return isMoonshotKimiModelIdFallback(input.request);
+}
+
+function isDeepSeekModelOrProviderDefault(
+	input: ProviderOptionMatchInput,
+): boolean {
+	return (
+		isDeepSeekFamily(input.context) || input.request.providerId === "deepseek"
+	);
+}
+
+function isMiniMaxM3(input: ProviderOptionMatchInput): boolean {
+	return isMiniMaxM3Model(input.request, input.context);
+}
+
+function isOllamaReasoningDefaultOnDisable(
+	input: ProviderOptionMatchInput,
+): boolean {
+	return (
+		input.request.providerId === "ollama" &&
+		input.request.reasoning?.enabled === false &&
+		modelReasoningDefaultsOn({
+			request: input.request,
+			context: input.context,
+		})
+	);
+}
+
+function usesGlmThinkingProviderRouting(
+	input: ProviderOptionMatchInput,
+): boolean {
+	return providerReasoningRouteMatches(
+		"glm-thinking",
+		input.request,
+		input.context,
+	);
+}
+
+function hasGlmThinkingProviderRouting(
+	input: ProviderOptionMatchInput,
+): boolean {
+	return (
+		input.context.provider.metadata?.routing?.reasoning?.format ===
+		"glm-thinking"
+	);
+}
+
+function usesMiniMaxThinkingProviderRouting(
+	input: ProviderOptionMatchInput,
+): boolean {
+	return providerReasoningRouteMatches(
+		"minimax-thinking",
+		input.request,
+		input.context,
+	);
+}
+
+function resolveFamilyThinkingType(
+	input: ProviderOptionMatchInput,
+	defaultWhenUnset: "enabled" | "disabled" | undefined,
+): "enabled" | "disabled" | undefined {
+	const enabled = input.request.reasoning?.enabled;
+	if (enabled === true) {
+		return "enabled";
+	}
+	if (enabled === false) {
+		return "disabled";
+	}
+	return defaultWhenUnset;
+}
+
+function buildReasoningPatchForProvider(
+	input: ProviderOptionBuildInput,
+	reasoning: Record<string, unknown> | undefined,
+): ProviderOptionsPatch | undefined {
+	if (!reasoning) {
+		return undefined;
+	}
+	return buildProviderAndAliasPatch({
+		providerId: input.request.providerId,
+		providerOptionsKey: input.providerOptionsKey,
+		bucketOptions: { reasoning },
+	});
+}
+
+const GEMINI_25_THINKING_BUDGET_BY_EFFORT = {
+	low: 1_024,
+	medium: 8_192,
+	high: 24_576,
+} as const;
+
+function buildGeminiThinkingConfig(input: ProviderOptionBuildInput):
+	| {
+			thinkingLevel?: "minimal" | "low" | "medium" | "high";
+			thinkingBudget?: number;
+			includeThoughts: boolean;
+	  }
+	| undefined {
+	const reasoning = input.request.reasoning;
+	if (!reasoning) {
+		return undefined;
+	}
+
+	if (isGemini3Model(input)) {
+		if (reasoning.enabled === false) {
+			return {
+				thinkingLevel: isGeminiFlashModel(input) ? "minimal" : "low",
+				includeThoughts: false,
+			};
+		}
+		if (!reasoning.effort) {
+			return undefined;
+		}
+		return {
+			thinkingLevel: reasoning.effort,
+			includeThoughts: true,
+		};
+	}
+
+	if (reasoning.enabled === false) {
+		return {
+			thinkingBudget: isGeminiProModel(input) ? 128 : 0,
+			includeThoughts: false,
+		};
+	}
+
+	if (typeof reasoning.budgetTokens === "number") {
+		return {
+			thinkingBudget: reasoning.budgetTokens,
+			includeThoughts: true,
+		};
+	}
+
+	if (!reasoning.effort) {
+		return undefined;
+	}
+
+	return {
+		thinkingBudget: GEMINI_25_THINKING_BUDGET_BY_EFFORT[reasoning.effort],
+		includeThoughts: true,
+	};
+}
+
+const directAnthropicProviderRule: ProviderOptionRule = {
+	id: "provider.anthropic.direct",
+	phase: "provider",
+	description:
+		"Direct Anthropic owns the anthropic bucket built by the base patch.",
+	applies: (input) => input.request.providerId === "anthropic",
+	suppresses: { genericFanout: true },
+	build: () => undefined,
+};
+
+const directGoogleProviderRule: ProviderOptionRule = {
+	id: "provider.google.direct",
+	phase: "provider",
+	description:
+		"Direct Google owns the google bucket through Gemini thinkingConfig.",
+	applies: (input) => input.request.providerId === "google",
+	suppresses: { genericFanout: true },
+	build: () => undefined,
+};
+
+const openAiAdapterRule: ProviderOptionRule = {
+	id: "adapter.openai",
+	phase: "adapter",
+	description:
+		"OpenAI adapter targets the AI SDK openai bucket, not provider-id buckets.",
+	applies: (input) => input.target === "openai",
+	build: (input) => ({
+		openai: {
+			strictJsonSchema: false,
+			...buildOpenAINativeProviderOptions(input.request),
+		},
+	}),
+};
+
+const openAiCodexRule: ProviderOptionRule = {
+	id: "provider.openai-codex",
+	phase: "provider",
+	description:
+		"Codex CLI uses OpenAI Responses options plus provider-id aliases.",
+	applies: (input) => input.request.providerId === "openai-codex",
+	suppresses: { genericFanout: true },
+	build: (input) => {
+		const codexOptions = {
+			...input.compatibleOptions,
+			instructions: input.request.systemPrompt,
+			store: false,
+			strictJsonSchema: false,
+			systemMessageMode: "remove" as const,
+		};
+
+		return {
+			openai: codexOptions,
+			...buildProviderAndAliasPatch({
+				providerId: input.request.providerId,
+				providerOptionsKey: input.providerOptionsKey,
+				bucketOptions: codexOptions,
+			}),
+		};
+	},
+};
+
+const genericProviderFanoutRule: ProviderOptionRule = {
+	id: "provider.generic-fanout",
+	phase: "provider-fanout",
+	description:
+		"Default OpenAI-compatible providers receive provider-id and camelCase alias buckets.",
+	applies: (input) => input.target !== "openai",
+	build: (input) =>
+		input.suppressions.genericFanout
+			? undefined
+			: buildProviderAndAliasPatch({
+					providerId: input.request.providerId,
+					providerOptionsKey: input.providerOptionsKey,
+					bucketOptions: input.compatibleOptions,
+				}),
+};
+
+const clineGatewayReasoningRule: ProviderOptionRule = {
+	id: "provider.cline.reasoning",
+	phase: "provider-reasoning",
+	description: "Cline gateway accepts the shared gateway reasoning shape.",
+	applies: (input) => isClineProvider(input.request.providerId),
+	build: (input) =>
+		buildReasoningPatchForProvider(
+			input,
+			buildGatewayReasoningOptions(input.request, input.context),
+		),
+};
+
+const openRouterReasoningRule: ProviderOptionRule = {
+	id: "provider.openrouter.reasoning",
+	phase: "provider-reasoning",
+	description:
+		"OpenRouter expects reasoning controls under its first-class reasoning object.",
+	applies: (input) => input.request.providerId === "openrouter",
+	suppresses: { genericThinking: true, genericEffort: true },
+	build: (input) =>
+		buildReasoningPatchForProvider(
+			input,
+			buildOpenRouterReasoningOptions(input.request),
+		),
+};
+
+const clineMiniMaxM3GatewayReasoningRule: ProviderOptionRule = {
+	id: "provider.cline.minimax-m3.gateway-reasoning",
+	phase: "provider-reasoning",
+	description:
+		"Cline-routed MiniMax M3 keeps the gateway reasoning shape instead of leaking generic thinking.",
+	applies: (input) =>
+		isClineProvider(input.request.providerId) && isMiniMaxM3(input),
+	suppresses: { genericThinking: true, genericEffort: true },
+	build: () => undefined,
+};
+
+const vercelMiniMaxM3GatewayReasoningRule: ProviderOptionRule = {
+	id: "provider.vercel-ai-gateway.minimax-m3.gateway-reasoning",
+	phase: "provider-reasoning",
+	description:
+		"Vercel-routed MiniMax M3 uses the gateway reasoning include/exclude shape.",
+	applies: (input) =>
+		input.request.providerId === "vercel-ai-gateway" && isMiniMaxM3(input),
+	suppresses: { genericThinking: true, genericEffort: true },
+	build: (input) =>
+		buildMiniMaxGatewayReasoningProviderOptionsPatch(
+			input.request,
+			input.providerOptionsKey,
+		),
+};
+
+const geminiThinkingRule: ProviderOptionRule = {
+	id: "provider.google-gemini.thinking-config",
+	phase: "provider",
+	description: "Google/Gemini/Vertex maps reasoning to thinkingConfig.",
+	suppresses: { genericThinking: true, genericEffort: true },
+	applies: (input) =>
+		(input.request.providerId === "google" ||
+			input.request.providerId === "gemini" ||
+			input.request.providerId === "vertex") &&
+		supportsGeminiThinking(input) &&
+		(!!input.request.reasoning?.effort ||
+			typeof input.request.reasoning?.budgetTokens === "number" ||
+			input.request.reasoning?.enabled === false),
+	build: (input) => {
+		const providerOptionsName =
+			input.request.providerId === "vertex" ? "vertex" : "google";
+		const thinkingConfig = buildGeminiThinkingConfig(input);
+		if (!thinkingConfig) {
+			return undefined;
+		}
+		return {
+			[providerOptionsName]: {
+				thinkingConfig,
+			},
+		};
+	},
+};
+
+const clineReasoningDisabledThinkingRule: ProviderOptionRule = {
+	id: "provider.cline.disable-thinking",
+	phase: "provider",
+	description:
+		"Cline-routed non-Kimi-K2.6 Moonshot Kimi models use thinking.type=disabled when reasoning is disabled.",
+	applies: (input) =>
+		isClineProvider(input.request.providerId) &&
+		isMoonshotKimiModel(input) &&
+		input.request.reasoning?.enabled === false &&
+		!isKimiK26Family(input),
+	build: (input) =>
+		buildThinkingPatch({
+			providerId: input.request.providerId,
+			providerOptionsKey: input.providerOptionsKey,
+			thinkingType: "disabled",
+		}),
+};
+
+const kimiK26ThinkingRule: ProviderOptionRule = {
+	id: "family.kimi-k2.6.thinking",
+	phase: "model-family",
+	description:
+		"Kimi K2.6 uses thinking.type and defaults to enabled when reasoning is unset.",
+	applies: (input) =>
+		isKimiK26Family(input) && input.request.providerId !== "openrouter",
+	suppresses: { genericThinking: true },
+	build: (input) => {
+		const thinkingType = resolveFamilyThinkingType(input, "enabled");
+		return thinkingType
+			? buildThinkingPatch({
+					providerId: input.request.providerId,
+					providerOptionsKey: input.providerOptionsKey,
+					thinkingType,
+				})
+			: undefined;
+	},
+};
+
+const deepSeekThinkingRule: ProviderOptionRule = {
+	id: "family.deepseek.thinking",
+	phase: "model-family",
+	description:
+		"DeepSeek models use thinking.type only for explicit reasoning enabled/disabled.",
+	applies: (input) =>
+		input.request.providerId !== "openrouter" &&
+		isDeepSeekModelOrProviderDefault(input) &&
+		!isOllamaReasoningDefaultOnDisable(input),
+	suppresses: { genericThinking: true },
+	build: (input) => {
+		const thinkingType = resolveFamilyThinkingType(input, undefined);
+		return thinkingType
+			? buildThinkingPatch({
+					providerId: input.request.providerId,
+					providerOptionsKey: input.providerOptionsKey,
+					thinkingType,
+				})
+			: undefined;
+	},
+};
+
+const ollamaReasoningDefaultOnDisableRule: ProviderOptionRule = {
+	id: "provider.ollama.reasoning-default-on.disable-none",
+	phase: "provider-reasoning",
+	description:
+		"Ollama models whose reasoning defaults on need reasoningEffort=none when request reasoning is disabled.",
+	applies: isOllamaReasoningDefaultOnDisable,
+	build: (input) => {
+		const bucketOptions = {
+			reasoningEffort: "none",
+			reasoning: { effort: "none" },
+		};
+		return {
+			...buildProviderAndAliasPatch({
+				providerId: input.request.providerId,
+				providerOptionsKey: input.providerOptionsKey,
+				bucketOptions,
+			}),
+			openaiCompatible: bucketOptions,
+		};
+	},
+};
+
+const nonGlmProviderRoutingSuppressionRule: ProviderOptionRule = {
+	id: "provider.routing.glm-thinking.non-glm.suppress-generic-thinking",
+	phase: "provider",
+	description:
+		"Providers with GLM thinking routing should not apply generic adaptive thinking to non-GLM models.",
+	applies: (input) =>
+		hasGlmThinkingProviderRouting(input) &&
+		input.request.reasoning?.enabled !== undefined &&
+		!usesGlmThinkingProviderRouting(input),
+	suppresses: { genericThinking: true },
+	build: () => undefined,
+};
+
+const nativeZaiGlmThinkingRule: ProviderOptionRule = {
+	id: "provider.routing.glm-thinking",
+	phase: "model-overlay",
+	description: "Providers routed to the GLM thinking format use thinking.type.",
+	applies: usesGlmThinkingProviderRouting,
+	suppresses: { genericThinking: true },
+	build: (input) =>
+		buildNativeGlmThinkingProviderOptionsPatch(
+			input.request,
+			input.providerOptionsKey,
+		),
+};
+
+const miniMaxThinkingRule: ProviderOptionRule = {
+	id: "provider.routing.minimax-thinking",
+	phase: "model-overlay",
+	description: "Direct MiniMax M3 uses thinking.type adaptive/disabled.",
+	applies: usesMiniMaxThinkingProviderRouting,
+	suppresses: { genericThinking: true, genericEffort: true },
+	build: (input) =>
+		buildMiniMaxThinkingProviderOptionsPatch(
+			input.request,
+			input.providerOptionsKey,
+		),
+};
+
+const routedGlmReasoningRule: ProviderOptionRule = {
+	id: "family.glm.routed-reasoning",
+	phase: "model-overlay",
+	description:
+		"Routed GLM models use the generic reasoning include/exclude shape, not thinking.type.",
+	applies: (input) =>
+		!usesGlmThinkingProviderRouting(input) &&
+		isGlmModel(input.request, input.context),
+	suppresses: { genericThinking: true },
+	build: (input) =>
+		buildRoutedGlmReasoningProviderOptionsPatch(
+			input.request,
+			input.context,
+			input.providerOptionsKey,
+			{
+				includeProviderBuckets: input.request.providerId !== "openrouter",
+			},
+		),
+};
+
+/**
+ * The table is the provider/family behavior matrix. Adding a new exception
+ * should mean adding a named rule here, not adding a branch in the composer.
+ * Keep model/provider fact detection in `providers/model-facts.ts`; see
+ * `sdk/packages/llms/AGENTS.md` for the sources-of-truth boundary.
+ */
+export const PROVIDER_OPTION_RULES: ReadonlyArray<ProviderOptionRule> = [
+	directAnthropicProviderRule,
+	directGoogleProviderRule,
+	openAiAdapterRule,
+	openAiCodexRule,
+	genericProviderFanoutRule,
+	clineGatewayReasoningRule,
+	openRouterReasoningRule,
+	clineMiniMaxM3GatewayReasoningRule,
+	vercelMiniMaxM3GatewayReasoningRule,
+	geminiThinkingRule,
+	clineReasoningDisabledThinkingRule,
+	kimiK26ThinkingRule,
+	deepSeekThinkingRule,
+	ollamaReasoningDefaultOnDisableRule,
+	nonGlmProviderRoutingSuppressionRule,
+	nativeZaiGlmThinkingRule,
+	miniMaxThinkingRule,
+	routedGlmReasoningRule,
+];
+
+export function matchProviderOptionRules(
+	rules: ReadonlyArray<ProviderOptionRule>,
+	input: ProviderOptionMatchInput,
+): Array<MatchedProviderOptionRule> {
+	const matched: Array<MatchedProviderOptionRule> = [];
+	for (const rule of rules) {
+		if (rule.applies(input)) {
+			matched.push({ rule });
+		}
+	}
+	return matched;
+}
+
+export function resolveProviderOptionSuppressions(
+	matchedRules: ReadonlyArray<MatchedProviderOptionRule>,
+): ProviderOptionSuppression {
+	return matchedRules.reduce<ProviderOptionSuppression>((result, { rule }) => {
+		if (!rule.suppresses) {
+			return result;
+		}
+		return {
+			genericThinking:
+				result.genericThinking || rule.suppresses.genericThinking || undefined,
+			genericEffort:
+				result.genericEffort || rule.suppresses.genericEffort || undefined,
+			genericFanout:
+				result.genericFanout || rule.suppresses.genericFanout || undefined,
+		};
+	}, {});
+}
+
+export function buildProviderOptionRulePatches(
+	matchedRules: ReadonlyArray<MatchedProviderOptionRule>,
+	input: ProviderOptionBuildInput,
+): Array<ProviderOptionsPatch | undefined> {
+	return matchedRules.map(({ rule }) => rule.build(input));
+}
diff --git a/sdk/packages/llms/src/providers/routing/provider-options-types.ts b/sdk/packages/llms/src/providers/routing/provider-options-types.ts
new file mode 100644
index 0000000..28468b1
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/provider-options-types.ts
@@ -0,0 +1,92 @@
+import type {
+	GatewayProviderContext,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import type { AnthropicReasoningRequestPolicy } from "./anthropic-compatible";
+import type { ProviderOptionsPatch } from "./utils";
+
+export type AiSdkProviderOptionsTarget =
+	| "openai"
+	| "openai-compatible"
+	| "anthropic"
+	| "google"
+	| "vertex"
+	| "bedrock"
+	| "mistral"
+	| "claude-code"
+	| "openai-codex"
+	| "opencode"
+	| "dify"
+	| "sapaicore";
+
+export type ProviderOptionSuppression = {
+	genericThinking?: boolean;
+	genericEffort?: boolean;
+	genericFanout?: boolean;
+};
+
+export type ProviderOptionMatchInput = {
+	request: GatewayStreamRequest;
+	context: GatewayProviderContext;
+	providerOptionsKey: string;
+	target: AiSdkProviderOptionsTarget;
+	isAnthropicCompatibleModelId: boolean;
+	anthropicReasoningPolicyKind?: AnthropicReasoningRequestPolicy["kind"];
+};
+
+export type ProviderOptionBuildInput = ProviderOptionMatchInput & {
+	compatibleOptions: Record<string, unknown>;
+	anthropicOptions: Record<string, unknown>;
+	suppressions: ProviderOptionSuppression;
+};
+
+export type ProviderOptionRule = {
+	id: string;
+	phase:
+		| "adapter"
+		| "provider"
+		| "provider-fanout"
+		| "provider-reasoning"
+		| "model-family"
+		| "model-overlay";
+	description: string;
+	applies(input: ProviderOptionMatchInput): boolean;
+	suppresses?: ProviderOptionSuppression;
+	build(input: ProviderOptionBuildInput): ProviderOptionsPatch | undefined;
+};
+
+export type MatchedProviderOptionRule = {
+	rule: ProviderOptionRule;
+};
+
+export function inferProviderOptionsTarget(
+	providerId: string,
+): AiSdkProviderOptionsTarget {
+	switch (providerId) {
+		case "openai-native":
+			return "openai";
+		case "anthropic":
+			return "anthropic";
+		case "google":
+		case "gemini":
+			return "google";
+		case "vertex":
+			return "vertex";
+		case "bedrock":
+			return "bedrock";
+		case "mistral":
+			return "mistral";
+		case "claude-code":
+			return "claude-code";
+		case "openai-codex":
+			return "openai-codex";
+		case "opencode":
+			return "opencode";
+		case "dify":
+			return "dify";
+		case "sapaicore":
+			return "sapaicore";
+		default:
+			return "openai-compatible";
+	}
+}
diff --git a/sdk/packages/llms/src/providers/routing/provider-options.test.ts b/sdk/packages/llms/src/providers/routing/provider-options.test.ts
new file mode 100644
index 0000000..6a56117
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/provider-options.test.ts
@@ -0,0 +1,1937 @@
+import type {
+	GatewayProviderContext,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { GLM_THINKING_ROUTING_METADATA } from "./glm-thinking";
+import { MINIMAX_THINKING_ROUTING_METADATA } from "./minimax-thinking";
+import {
+	composeAiSdkProviderOptions,
+	mergeProviderOptionPatches,
+	type ProviderOptionsPatch,
+} from "./provider-options";
+
+type RequestOverrides = Partial<GatewayStreamRequest> & {
+	providerId: string;
+	modelId: string;
+};
+
+type ContextOverrides = {
+	providerId?: string;
+	modelId?: string;
+	family?: string;
+	modelMetadata?: NonNullable<GatewayProviderContext["model"]["metadata"]>;
+	capabilities?: GatewayProviderContext["model"]["capabilities"];
+	metadata?: GatewayProviderContext["provider"]["metadata"];
+	/** Test helper escape hatch for Claude-like models that should not get an auto-injected Anthropic reasoning route. */
+	disableAutoAnthropicRouting?: boolean;
+};
+
+function makeContext(options?: ContextOverrides): GatewayProviderContext {
+	const providerId = options?.providerId ?? "test-provider";
+	const modelId = options?.modelId ?? "model-id";
+	const normalizedFamily = options?.family?.toLowerCase() ?? "";
+	const normalizedModelId = modelId.toLowerCase();
+	const useAnthropicReasoningRoute =
+		options?.disableAutoAnthropicRouting !== true &&
+		(normalizedFamily.includes("claude") ||
+			normalizedModelId.includes("claude") ||
+			normalizedModelId.includes("anthropic"));
+	const anthropicReasoningMetadata: GatewayProviderContext["provider"]["metadata"] =
+		useAnthropicReasoningRoute
+			? {
+					routing: {
+						reasoning: {
+							format: "anthropic-thinking",
+							routes: [
+								{
+									matcher: "anthropic-compatible",
+								},
+							],
+						},
+					},
+				}
+			: undefined;
+	const metadata =
+		anthropicReasoningMetadata || options?.metadata
+			? {
+					...(anthropicReasoningMetadata ?? {}),
+					...(options?.metadata ?? {}),
+					routing:
+						anthropicReasoningMetadata?.routing || options?.metadata?.routing
+							? {
+									...(anthropicReasoningMetadata?.routing ?? {}),
+									...(options?.metadata?.routing ?? {}),
+								}
+							: undefined,
+				}
+			: undefined;
+	const modelMetadata =
+		options?.family || options?.modelMetadata
+			? {
+					...options.modelMetadata,
+					...(options.family ? { family: options.family } : {}),
+				}
+			: undefined;
+	return {
+		provider: {
+			id: providerId,
+			name: providerId,
+			defaultModelId: modelId,
+			models: [
+				{ id: modelId, name: modelId, providerId, capabilities: ["text"] },
+			],
+			metadata,
+		},
+		model: {
+			id: modelId,
+			name: modelId,
+			providerId,
+			capabilities: options?.capabilities,
+			metadata: modelMetadata,
+		},
+		config: { providerId },
+	};
+}
+
+function makeRequest(overrides: RequestOverrides): GatewayStreamRequest {
+	return {
+		providerId: overrides.providerId,
+		modelId: overrides.modelId,
+		messages: overrides.messages ?? [
+			{
+				id: "msg-1",
+				role: "user",
+				content: [{ type: "text", text: "hi" }],
+				createdAt: 0,
+			},
+		],
+		systemPrompt: overrides.systemPrompt,
+		temperature: overrides.temperature,
+		maxTokens: overrides.maxTokens,
+		reasoning: overrides.reasoning,
+		signal: overrides.signal,
+		tools: overrides.tools,
+	};
+}
+
+/**
+ * One row asserts: build a request+context, call composeAiSdkProviderOptions,
+ * then for each `expect` entry check that the named bucket either contains or
+ * lacks the specified shape. `has` runs through `objectContaining`; `lacks` is
+ * a list of property names that must NOT exist in the bucket.
+ */
+type BucketExpectation = {
+	bucket: string;
+	has?: Record<string, unknown>;
+	lacks?: string[];
+};
+
+type Case = {
+	name: string;
+	request: RequestOverrides;
+	context?: ContextOverrides;
+	expect: BucketExpectation[];
+};
+
+function runCases(cases: ReadonlyArray<Case>) {
+	it.each(cases)("$name", ({ request, context, expect: expectations }) => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest(request),
+			makeContext({
+				providerId: request.providerId,
+				modelId: request.modelId,
+				...context,
+			}),
+		);
+
+		for (const e of expectations) {
+			const bucket = result[e.bucket];
+			if (e.has) {
+				expect(bucket).toEqual(expect.objectContaining(e.has));
+			}
+			if (e.lacks?.length) {
+				expect(bucket).toBeDefined();
+			}
+			for (const key of e.lacks ?? []) {
+				expect(bucket).not.toHaveProperty(key);
+			}
+		}
+	});
+}
+
+describe("mergeProviderOptionPatches", () => {
+	it("returns an empty object when no patches are supplied", () => {
+		expect(mergeProviderOptionPatches([])).toEqual({});
+	});
+
+	it("ignores undefined patches", () => {
+		const patch: ProviderOptionsPatch = { foo: { a: 1 } };
+		expect(mergeProviderOptionPatches([undefined, patch, undefined])).toEqual({
+			foo: { a: 1 },
+		});
+	});
+
+	it("merges disjoint buckets", () => {
+		expect(
+			mergeProviderOptionPatches([{ foo: { a: 1 } }, { bar: { b: 2 } }]),
+		).toEqual({ foo: { a: 1 }, bar: { b: 2 } });
+	});
+
+	it("later patches win on overlapping keys within the same bucket", () => {
+		expect(
+			mergeProviderOptionPatches([
+				{ foo: { a: 1, b: 2 } },
+				{ foo: { b: 99, c: 3 } },
+			]),
+		).toEqual({ foo: { a: 1, b: 99, c: 3 } });
+	});
+
+	it("preserves keys from earlier patches that later patches do not override", () => {
+		expect(
+			mergeProviderOptionPatches([
+				{ foo: { a: 1 } },
+				{ foo: { b: 2 } },
+				{ foo: { c: 3 } },
+			]),
+		).toEqual({ foo: { a: 1, b: 2, c: 3 } });
+	});
+});
+
+describe("composeAiSdkProviderOptions: alias bucket emission", () => {
+	it("emits a concrete provider-id bucket and a distinct camelCase alias bucket", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vercel-ai-gateway",
+				modelId: "gpt-5.4",
+				reasoning: { effort: "high" },
+			}),
+			makeContext({ providerId: "vercel-ai-gateway", modelId: "gpt-5.4" }),
+		);
+
+		const expected = {
+			effort: "high",
+			reasoningEffort: "high",
+			reasoningSummary: "auto",
+		};
+		expect(result["vercel-ai-gateway"]).toEqual(
+			expect.objectContaining({
+				...expected,
+				strictJsonSchema: false,
+			}),
+		);
+		expect(result.vercelAiGateway).toEqual(
+			expect.objectContaining({
+				...expected,
+				strictJsonSchema: false,
+			}),
+		);
+		expect(result.openaiCompatible).toEqual(
+			expect.objectContaining({ strictJsonSchema: false }),
+		);
+	});
+
+	it("disables strict JSON schema for the OpenAI adapter bucket", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({ providerId: "openai-native", modelId: "gpt-5.4" }),
+			makeContext({ providerId: "openai-native", modelId: "gpt-5.4" }),
+		);
+
+		expect(result.openai).toEqual(
+			expect.objectContaining({
+				strictJsonSchema: false,
+				truncation: "auto",
+			}),
+		);
+		expect(result).not.toHaveProperty("openai-native");
+		expect(result).not.toHaveProperty("openaiNative");
+		expect(result.openaiCompatible).not.toHaveProperty("strictJsonSchema");
+	});
+
+	it("uses the OpenAI adapter bucket for OpenAI Responses compatible providers", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({ providerId: "v0", modelId: "v0-1.5-md" }),
+			makeContext({ providerId: "v0", modelId: "v0-1.5-md" }),
+			"openai",
+		);
+
+		expect(result.openai).toEqual(
+			expect.objectContaining({ strictJsonSchema: false }),
+		);
+		expect(result.openai).not.toHaveProperty("truncation");
+		expect(result).not.toHaveProperty("v0");
+		expect(result.openaiCompatible).not.toHaveProperty("strictJsonSchema");
+	});
+
+	it("does not fan OpenAI-compatible strict schema defaults into native adapter buckets", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({ providerId: "bedrock", modelId: "anthropic.claude-3-5" }),
+			makeContext({ providerId: "bedrock", modelId: "anthropic.claude-3-5" }),
+		);
+
+		expect(result.bedrock).not.toHaveProperty("strictJsonSchema");
+		expect(result.openaiCompatible).not.toHaveProperty("strictJsonSchema");
+	});
+
+	it("does not emit a separate alias bucket when the alias equals the provider id", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({ providerId: "openai", modelId: "gpt-5" }),
+			makeContext({ providerId: "openai", modelId: "gpt-5" }),
+		);
+
+		expect(result).toHaveProperty("openai");
+		expect(Object.keys(result).filter((k) => k === "openai")).toHaveLength(1);
+	});
+});
+
+describe("composeAiSdkProviderOptions: Anthropic thinking precedence", () => {
+	const MANUAL_THINKING = { type: "enabled", budgetTokens: 1024 };
+	const ADAPTIVE_THINKING = { type: "adaptive" };
+
+	runCases([
+		{
+			name: "Sonnet 4.5 -> manual thinking (no adaptive support), no effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: MANUAL_THINKING },
+					lacks: ["effort"],
+				},
+			],
+		},
+		{
+			name: "Opus 4.6 -> adaptive thinking with effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-opus-4-6",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-opus" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: ADAPTIVE_THINKING, effort: "high" },
+				},
+			],
+		},
+		{
+			name: "Opus 4.7 -> adaptive thinking with effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-opus-4-7",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-opus" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: ADAPTIVE_THINKING, effort: "high" },
+				},
+			],
+		},
+		{
+			name: "Opus before 4.6 -> manual thinking, no effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-opus-4-5",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-opus" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: MANUAL_THINKING },
+					lacks: ["effort"],
+				},
+			],
+		},
+		{
+			name: "Sonnet 4.6 -> adaptive thinking with effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: ADAPTIVE_THINKING, effort: "high" },
+				},
+			],
+		},
+		{
+			name: "future Claude major (Sonnet 5.0) -> adaptive thinking",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-5-0",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: ADAPTIVE_THINKING, effort: "high" },
+				},
+			],
+		},
+		{
+			name: "Claude date suffixes are not mistaken for adaptive version numbers",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-opus-4-20250514",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-opus" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: MANUAL_THINKING },
+					lacks: ["effort"],
+				},
+			],
+		},
+		{
+			name: "Haiku 4.5 -> manual thinking, no effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-haiku-4-5",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: { family: "claude-haiku" },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: MANUAL_THINKING },
+					lacks: ["effort"],
+				},
+			],
+		},
+		{
+			name: "manual thinking budget defaults when only reasoning.enabled is set",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				reasoning: { enabled: true },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [{ bucket: "anthropic", has: { thinking: MANUAL_THINKING } }],
+		},
+		{
+			name: "manual thinking budget defaults when maxTokens is too small",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				maxTokens: 512,
+				reasoning: { enabled: true, effort: "low" },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [{ bucket: "anthropic", has: { thinking: MANUAL_THINKING } }],
+		},
+		{
+			name: "manual thinking budget defaults for unknown effort values",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-5",
+				reasoning: { enabled: true, effort: "minimal" as "low" },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [{ bucket: "anthropic", has: { thinking: MANUAL_THINKING } }],
+		},
+		{
+			name: "lower reasoning model (Sonnet 4.0) -> manual thinking, no effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-0",
+				reasoning: { enabled: true, effort: "medium" },
+			},
+			context: { family: "claude-sonnet", capabilities: ["reasoning"] },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: MANUAL_THINKING },
+					lacks: ["effort"],
+				},
+			],
+		},
+		{
+			name: "lower reasoning model (Sonnet 3.7) -> manual thinking, no effort",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-3-7-sonnet-20250219",
+				reasoning: { enabled: true, effort: "medium" },
+			},
+			context: { family: "claude-sonnet", capabilities: ["reasoning"] },
+			expect: [
+				{
+					bucket: "anthropic",
+					has: { thinking: MANUAL_THINKING },
+					lacks: ["effort"],
+				},
+			],
+		},
+		{
+			name: "lower non-reasoning Sonnet 3.5 -> no thinking on either bucket",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-3-5-sonnet-20241022",
+				reasoning: { enabled: true, effort: "low" },
+			},
+			context: { family: "claude-sonnet", capabilities: ["text"] },
+			expect: [
+				{ bucket: "anthropic", lacks: ["thinking", "effort"] },
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "effort", "reasoning"],
+				},
+			],
+		},
+		{
+			name: "lower non-reasoning Haiku 3 -> no thinking on either bucket",
+			request: {
+				providerId: "anthropic",
+				modelId: "claude-3-haiku-20240307",
+				reasoning: { enabled: true, effort: "low" },
+			},
+			context: { family: "claude-haiku", capabilities: ["text"] },
+			expect: [
+				{ bucket: "anthropic", lacks: ["thinking", "effort"] },
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "effort", "reasoning"],
+				},
+			],
+		},
+		{
+			name: "Cline-routed Sonnet 4.5 -> gateway reasoning, no thinking, no effort",
+			request: {
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4-5",
+				reasoning: { enabled: true, effort: "low" },
+			},
+			context: { family: "claude-sonnet" },
+			expect: [
+				{
+					bucket: "cline",
+					has: { reasoning: { enabled: true, max_tokens: 1024 } },
+					lacks: ["thinking"],
+				},
+			],
+		},
+		{
+			name: "legacy custom Claude with promptCacheStrategy -> Anthropic reasoning",
+			request: {
+				providerId: "custom-provider",
+				modelId: "anthropic/claude-sonnet-4-5",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				disableAutoAnthropicRouting: true,
+				metadata: { promptCacheStrategy: "anthropic-automatic" },
+			},
+			expect: [
+				{
+					bucket: "custom-provider",
+					has: { reasoning: { enabled: true, max_tokens: 1024 } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { reasoning: { enabled: true, max_tokens: 1024 } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+		{
+			name: "unrouted custom Claude -> Anthropic reasoning",
+			request: {
+				providerId: "custom-provider",
+				modelId: "anthropic/claude-3.5-sonnet",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				disableAutoAnthropicRouting: true,
+			},
+			expect: [
+				{
+					bucket: "custom-provider",
+					has: { reasoning: { enabled: true, max_tokens: 1024 } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { reasoning: { enabled: true, max_tokens: 1024 } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+	]);
+});
+
+describe("composeAiSdkProviderOptions: family/provider thinking patches", () => {
+	runCases([
+		{
+			name: "openrouter reasoning budgetTokens -> reasoning.max_tokens",
+			request: {
+				providerId: "openrouter",
+				modelId: "openai/gpt-oss-120b",
+				reasoning: { budgetTokens: 1024 },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { max_tokens: 1024 } },
+					lacks: ["thinking", "effort", "reasoningEffort"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+			],
+		},
+		{
+			name: "openrouter reasoning enabled-only -> reasoning.enabled",
+			request: {
+				providerId: "openrouter",
+				modelId: "openai/gpt-oss-120b",
+				reasoning: { enabled: true },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking", "effort", "reasoningEffort"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+			],
+		},
+		{
+			name: "openrouter unset reasoning -> no reasoning field",
+			request: {
+				providerId: "openrouter",
+				modelId: "deepseek/deepseek-v4-pro",
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					lacks: ["reasoning", "thinking", "effort", "reasoningEffort"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+			],
+		},
+		{
+			name: "openrouter Qwen family -> prompt cache buckets without Anthropic thinking",
+			request: {
+				providerId: "openrouter",
+				modelId: "alibaba/qwen3.6-plus",
+			},
+			context: {
+				family: "qwen",
+				metadata: { promptCacheStrategy: "anthropic-automatic" },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { cache_control: { type: "ephemeral" } },
+					lacks: ["thinking", "effort", "reasoning"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { cache_control: { type: "ephemeral" } },
+					lacks: ["thinking", "effort", "reasoning"],
+				},
+			],
+		},
+		// GLM/Z.AI routed reasoning — enabled
+		{
+			name: "openrouter GLM thinking-enabled -> routed reasoning, no thinking leak",
+			request: {
+				providerId: "openrouter",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: true },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking"],
+				},
+			],
+		},
+		{
+			name: "openrouter GLM budgetTokens -> OpenRouter max_tokens is not overwritten by routed GLM",
+			request: {
+				providerId: "openrouter",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: true, budgetTokens: 1024 },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { max_tokens: 1024 } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking"],
+				},
+			],
+		},
+		{
+			name: "openrouter GLM effort -> OpenRouter effort is not overwritten by routed GLM",
+			request: {
+				providerId: "openrouter",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: true, effort: "medium" },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { effort: "medium" } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking"],
+				},
+			],
+		},
+		{
+			name: "vercel-ai-gateway GLM thinking-enabled -> provider+alias buckets, no thinking leak",
+			request: {
+				providerId: "vercel-ai-gateway",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: true },
+			},
+			expect: [
+				{
+					bucket: "vercel-ai-gateway",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "vercelAiGateway",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking"],
+				},
+				{ bucket: "openaiCompatible", lacks: ["thinking"] },
+			],
+		},
+		// GLM/Z.AI routed reasoning — disabled
+		{
+			name: "openrouter GLM thinking-disabled -> reasoning.effort=none in provider+compatible",
+			request: {
+				providerId: "openrouter",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{ bucket: "openrouter", has: { reasoning: { effort: "none" } } },
+				// The OpenRouter bucket is authoritative on the wire; this residual
+				// compatible bucket remains for non-OpenRouter routed GLM paths.
+				{ bucket: "openaiCompatible", has: { reasoning: { exclude: true } } },
+			],
+		},
+		{
+			name: "vercel-ai-gateway GLM thinking-disabled -> reasoning.exclude in provider+alias",
+			request: {
+				providerId: "vercel-ai-gateway",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{ bucket: "vercel-ai-gateway", has: { reasoning: { exclude: true } } },
+				{ bucket: "vercelAiGateway", has: { reasoning: { exclude: true } } },
+			],
+		},
+		{
+			name: "cline GLM thinking-disabled -> routed reasoning only, no thinking leak",
+			request: {
+				providerId: "cline",
+				modelId: "z-ai/glm-4.7",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "cline",
+					has: { reasoning: { exclude: true } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { reasoning: { exclude: true } },
+					lacks: ["thinking"],
+				},
+			],
+		},
+		// Native Z.AI uses a real thinking shape, not the routed reasoning shape
+		{
+			name: "native zai thinking -> thinking.type=enabled, no routed reasoning",
+			request: {
+				providerId: "zai",
+				modelId: "glm-4.7",
+				reasoning: { enabled: true },
+			},
+			context: { family: "glm", metadata: GLM_THINKING_ROUTING_METADATA },
+			expect: [
+				{ bucket: "zai", has: { thinking: { type: "enabled" } } },
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "enabled" } },
+					lacks: ["reasoning"],
+				},
+			],
+		},
+		{
+			name: "native zai custom non-GLM -> no generic adaptive thinking",
+			request: {
+				providerId: "zai",
+				modelId: "zai-other-model",
+				reasoning: { enabled: true },
+			},
+			context: { family: "other", metadata: GLM_THINKING_ROUTING_METADATA },
+			expect: [
+				{ bucket: "zai", lacks: ["thinking", "reasoning"] },
+				{ bucket: "openaiCompatible", lacks: ["thinking", "reasoning"] },
+			],
+		},
+		// Kimi K2.6 family: explicit enabled/disabled and unset defaults to enabled
+		{
+			name: "cline Kimi K2.6 family reasoning.enabled=false -> thinking.type=disabled",
+			request: {
+				providerId: "cline",
+				modelId: "moonshotai/kimi-k2.6",
+				reasoning: { enabled: false },
+			},
+			context: { family: "kimi-k2.6" },
+			expect: [
+				{ bucket: "cline", has: { thinking: { type: "disabled" } } },
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "cline Kimi K2.6 family reasoning.enabled=true -> thinking.type=enabled",
+			request: {
+				providerId: "cline",
+				modelId: "moonshotai/kimi-k2.6",
+				reasoning: { enabled: true },
+			},
+			context: { family: "kimi-k2.6" },
+			expect: [
+				{ bucket: "cline", has: { thinking: { type: "enabled" } } },
+				{ bucket: "openaiCompatible", has: { thinking: { type: "enabled" } } },
+			],
+		},
+		{
+			name: "cline generic reasoning.enabled=false -> gateway reasoning only, no thinking patch",
+			request: {
+				providerId: "cline",
+				modelId: "gpt-5.4",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "cline",
+					has: { reasoning: { enabled: false } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning"],
+				},
+			],
+		},
+		{
+			name: "cline non-K2.6 Moonshot Kimi reasoning.enabled=false -> thinking.type=disabled",
+			request: {
+				providerId: "cline",
+				modelId: "moonshotai/kimi-k2.5",
+				reasoning: { enabled: false },
+			},
+			context: { family: "kimi-k2.5" },
+			expect: [
+				{
+					bucket: "cline",
+					has: {
+						reasoning: { enabled: false },
+						thinking: { type: "disabled" },
+					},
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "openrouter Kimi K2.6 family reasoning.enabled=false -> reasoning.effort=none",
+			request: {
+				providerId: "openrouter",
+				modelId: "moonshotai/kimi-k2.6",
+				reasoning: { enabled: false },
+			},
+			context: { family: "kimi-k2.6" },
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { effort: "none" } },
+					lacks: ["thinking"],
+				},
+				{ bucket: "openaiCompatible", lacks: ["thinking"] },
+			],
+		},
+		{
+			name: "openai-compatible Kimi K2.6 family unset reasoning -> thinking.type=enabled",
+			request: { providerId: "openai-compatible", modelId: "kimi-k2.6" },
+			context: { family: "kimi-k2.6" },
+			expect: [
+				{
+					bucket: "openai-compatible",
+					has: { thinking: { type: "enabled" } },
+				},
+				{ bucket: "openaiCompatible", has: { thinking: { type: "enabled" } } },
+			],
+		},
+		{
+			name: "openai-compatible Kimi K2.6 family reasoning.enabled=false -> thinking.type=disabled",
+			request: {
+				providerId: "openai-compatible",
+				modelId: "kimi-k2.6",
+				reasoning: { enabled: false },
+			},
+			context: { family: "kimi-k2.6" },
+			expect: [
+				{
+					bucket: "openai-compatible",
+					has: { thinking: { type: "disabled" } },
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "openai-compatible Kimi K2.6 family empty reasoning -> thinking.type=enabled",
+			request: {
+				providerId: "openai-compatible",
+				modelId: "kimi-k2.6",
+				reasoning: {},
+			},
+			context: { family: "kimi-k2.6" },
+			expect: [
+				{ bucket: "openaiCompatible", has: { thinking: { type: "enabled" } } },
+			],
+		},
+		{
+			name: "qwen prompt-cache-only route reasoning.enabled=true -> cache control, no thinking",
+			request: {
+				providerId: "qwen",
+				modelId: "qwen-plus",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				family: "qwen",
+				capabilities: ["text", "prompt-cache"],
+				metadata: {
+					routing: {
+						promptCache: {
+							format: "anthropic-cache-control",
+							routes: [
+								{
+									matcher: "model-family",
+									family: "qwen",
+									requiredCapability: "prompt-cache",
+								},
+							],
+						},
+					},
+				},
+			},
+			expect: [
+				{
+					bucket: "qwen",
+					has: { cache_control: { type: "ephemeral" } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { cache_control: { type: "ephemeral" } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+		{
+			name: "qwen prompt-cache route without capability reasoning.enabled=true -> no generic thinking",
+			request: {
+				providerId: "qwen",
+				modelId: "qwen-plus",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				family: "qwen",
+				capabilities: ["text"],
+				metadata: {
+					routing: {
+						promptCache: {
+							format: "anthropic-cache-control",
+							routes: [
+								{
+									matcher: "model-family",
+									family: "qwen",
+									requiredCapability: "prompt-cache",
+								},
+							],
+						},
+					},
+				},
+			},
+			expect: [
+				{
+					bucket: "qwen",
+					lacks: [
+						"cache_control",
+						"thinking",
+						"effort",
+						"reasoningEffort",
+						"reasoningSummary",
+					],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: [
+						"cache_control",
+						"thinking",
+						"effort",
+						"reasoningEffort",
+						"reasoningSummary",
+					],
+				},
+			],
+		},
+		{
+			name: "cline qwen prompt-cache-only route reasoning.enabled=true -> cache control, no gateway reasoning",
+			request: {
+				providerId: "cline",
+				modelId: "qwen/qwen3.6-plus",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				family: "qwen",
+				capabilities: ["text", "prompt-cache"],
+				metadata: {
+					routing: {
+						promptCache: {
+							format: "anthropic-cache-control",
+							routes: [
+								{
+									matcher: "model-family",
+									family: "qwen",
+									requiredCapability: "prompt-cache",
+								},
+							],
+						},
+					},
+				},
+			},
+			expect: [
+				{
+					bucket: "cline",
+					has: { cache_control: { type: "ephemeral" } },
+					lacks: [
+						"reasoning",
+						"thinking",
+						"effort",
+						"reasoningEffort",
+						"reasoningSummary",
+					],
+				},
+			],
+		},
+		{
+			name: "cline unregistered qwen reasoning.enabled=true -> no gateway reasoning",
+			request: {
+				providerId: "cline",
+				modelId: "qwen/qwen3.7-plus",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				metadata: {
+					routing: {
+						promptCache: {
+							format: "anthropic-cache-control",
+							routes: [
+								{
+									matcher: "model-family",
+									family: "qwen",
+									requiredCapability: "prompt-cache",
+								},
+							],
+						},
+					},
+				},
+			},
+			expect: [
+				{
+					bucket: "cline",
+					lacks: [
+						"reasoning",
+						"thinking",
+						"effort",
+						"reasoningEffort",
+						"reasoningSummary",
+					],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+		{
+			name: "cline Kimi K2.6 family reasoning.enabled=false also keeps gateway reasoning shape",
+			request: {
+				providerId: "cline",
+				modelId: "moonshotai/kimi-k2.6",
+				reasoning: { enabled: false },
+			},
+			context: { family: "kimi-k2.6" },
+			expect: [{ bucket: "cline", has: { reasoning: { enabled: false } } }],
+		},
+		{
+			name: "cline Claude Fable reasoning.enabled=false uses lowest supported reasoning",
+			request: {
+				providerId: "cline",
+				modelId: "anthropic/claude-fable-5",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "cline",
+					has: { reasoning: { max_tokens: 1024 } },
+				},
+			],
+		},
+		{
+			name: "cline StepFun 3.7 Flash reasoning.enabled=false omits disabled reasoning",
+			request: {
+				providerId: "cline",
+				modelId: "stepfun/step-3.7-flash",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "cline",
+					lacks: ["reasoning", "thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["reasoning", "thinking"],
+				},
+			],
+		},
+		{
+			name: "cline StepFun 3.7 Flash variants reasoning.enabled=false omit disabled reasoning",
+			request: {
+				providerId: "cline",
+				modelId: "stepfun/step-3.7-flash-v2",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "cline",
+					lacks: ["reasoning", "thinking"],
+				},
+			],
+		},
+		// OpenRouter owns the reasoning object regardless of Moonshot family.
+		{
+			name: "openrouter non-K2.6 Moonshot Kimi reasoning.enabled=false -> reasoning.effort=none",
+			request: {
+				providerId: "openrouter",
+				modelId: "moonshotai/kimi-k2.5",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { effort: "none" } },
+					lacks: ["thinking"],
+				},
+				{ bucket: "openaiCompatible", lacks: ["thinking"] },
+			],
+		},
+		// DeepSeek family — direct provider id and openai-compatible via family
+		{
+			name: "direct deepseek reasoning disable -> thinking.type=disabled",
+			request: {
+				providerId: "deepseek",
+				modelId: "deepseek-v4-pro",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{ bucket: "deepseek", has: { thinking: { type: "disabled" } } },
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "direct deepseek reasoning enable -> thinking.type=enabled",
+			request: {
+				providerId: "deepseek",
+				modelId: "deepseek-v4-pro",
+				reasoning: { enabled: true },
+			},
+			expect: [
+				{ bucket: "deepseek", has: { thinking: { type: "enabled" } } },
+				{ bucket: "openaiCompatible", has: { thinking: { type: "enabled" } } },
+			],
+		},
+		{
+			name: "openai-compatible deepseek family reasoning.enabled=false -> thinking.type=disabled",
+			request: {
+				providerId: "openai-compatible",
+				modelId: "deepseek-v4-pro",
+				reasoning: { enabled: false },
+			},
+			context: { family: "deepseek" },
+			expect: [
+				{
+					bucket: "openai-compatible",
+					has: { thinking: { type: "disabled" } },
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "openai-compatible deepseek-thinking family reasoning.enabled=false -> thinking.type=disabled",
+			request: {
+				providerId: "openai-compatible",
+				modelId: "deepseek-v4-pro",
+				reasoning: { enabled: false },
+			},
+			context: { family: "deepseek-thinking" },
+			expect: [
+				{
+					bucket: "openai-compatible",
+					has: { thinking: { type: "disabled" } },
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "openai-compatible deepseek-flash family reasoning.enabled=false -> thinking.type=disabled",
+			request: {
+				providerId: "openai-compatible",
+				modelId: "deepseek-v4-pro",
+				reasoning: { enabled: false },
+			},
+			context: { family: "deepseek-flash" },
+			expect: [
+				{
+					bucket: "openai-compatible",
+					has: { thinking: { type: "disabled" } },
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+				},
+			],
+		},
+		{
+			name: "openai-compatible deepseek family reasoning.enabled=true -> thinking.type=enabled",
+			request: {
+				providerId: "openai-compatible",
+				modelId: "deepseek-v4-pro",
+				reasoning: { enabled: true },
+			},
+			context: { family: "deepseek-thinking" },
+			expect: [
+				{
+					bucket: "openai-compatible",
+					has: { thinking: { type: "enabled" } },
+				},
+				{ bucket: "openaiCompatible", has: { thinking: { type: "enabled" } } },
+			],
+		},
+		{
+			name: "openai-compatible deepseek family with unset reasoning -> no thinking emitted",
+			request: { providerId: "openai-compatible", modelId: "deepseek-v4-pro" },
+			context: { family: "deepseek" },
+			expect: [
+				{ bucket: "openai-compatible", lacks: ["thinking"] },
+				{ bucket: "openaiCompatible", lacks: ["thinking"] },
+			],
+		},
+		{
+			name: "openrouter MiniMax M3 reasoning enabled -> OpenRouter reasoning shape",
+			request: {
+				providerId: "openrouter",
+				modelId: "minimax/minimax-m3",
+				reasoning: { enabled: true },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking", "effort", "reasoningEffort"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+			],
+		},
+		{
+			name: "openrouter MiniMax M3 reasoning disabled -> OpenRouter reasoning.effort=none",
+			request: {
+				providerId: "openrouter",
+				modelId: "minimax/minimax-m3",
+				reasoning: { enabled: false },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "openrouter",
+					has: { reasoning: { effort: "none" } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning"],
+				},
+			],
+		},
+		{
+			name: "vercel MiniMax M3 reasoning enabled -> gateway reasoning shape",
+			request: {
+				providerId: "vercel-ai-gateway",
+				modelId: "minimax/minimax-m3",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "vercel-ai-gateway",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "vercelAiGateway",
+					has: { reasoning: { enabled: true } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+		{
+			name: "vercel MiniMax M3 reasoning disabled -> gateway reasoning.exclude",
+			request: {
+				providerId: "vercel-ai-gateway",
+				modelId: "minimax/minimax-m3",
+				reasoning: { enabled: false },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "vercel-ai-gateway",
+					has: { reasoning: { exclude: true } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "vercelAiGateway",
+					has: { reasoning: { exclude: true } },
+					lacks: ["thinking"],
+				},
+			],
+		},
+		{
+			name: "vercel MiniMax M3 sibling id -> no MiniMax M3 gateway exception",
+			request: {
+				providerId: "vercel-ai-gateway",
+				modelId: "minimax/minimax-m3-pro",
+				reasoning: { enabled: true },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "vercel-ai-gateway",
+					has: { thinking: { type: "adaptive" } },
+					lacks: ["reasoning"],
+				},
+			],
+		},
+		{
+			name: "cline MiniMax M3 reasoning enabled -> gateway reasoning without thinking leak",
+			request: {
+				providerId: "cline",
+				modelId: "minimax/minimax-m3",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "cline",
+					has: { reasoning: { enabled: true, effort: "high" } },
+					lacks: ["thinking", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+			],
+		},
+		{
+			name: "cline MiniMax M3 reasoning disabled -> gateway reasoning disabled",
+			request: {
+				providerId: "cline",
+				modelId: "minimax/minimax-m3",
+				reasoning: { enabled: false },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+			},
+			expect: [
+				{
+					bucket: "cline",
+					has: { reasoning: { enabled: false } },
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning"],
+				},
+			],
+		},
+		{
+			name: "direct MiniMax M3 reasoning disabled -> thinking.type=disabled",
+			request: {
+				providerId: "minimax",
+				modelId: "MiniMax-M3",
+				reasoning: { enabled: false },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+				metadata: MINIMAX_THINKING_ROUTING_METADATA,
+			},
+			expect: [
+				{
+					bucket: "minimax",
+					has: { thinking: { type: "disabled" } },
+					lacks: ["reasoning", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "disabled" } },
+					lacks: ["reasoning", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+		{
+			name: "direct MiniMax M3 reasoning enabled -> thinking.type=adaptive",
+			request: {
+				providerId: "minimax",
+				modelId: "MiniMax-M3",
+				reasoning: { enabled: true, effort: "high" },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+				metadata: MINIMAX_THINKING_ROUTING_METADATA,
+			},
+			expect: [
+				{
+					bucket: "minimax",
+					has: { thinking: { type: "adaptive" } },
+					lacks: ["reasoning", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "adaptive" } },
+					lacks: ["reasoning", "effort", "reasoningEffort", "reasoningSummary"],
+				},
+			],
+		},
+		{
+			name: "direct MiniMax M2.5 reasoning enabled -> existing generic adaptive thinking",
+			request: {
+				providerId: "minimax",
+				modelId: "MiniMax-M2.5",
+				reasoning: { enabled: true },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+				metadata: MINIMAX_THINKING_ROUTING_METADATA,
+			},
+			expect: [
+				{
+					bucket: "minimax",
+					has: { thinking: { type: "adaptive" } },
+					lacks: ["reasoning"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: { thinking: { type: "adaptive" } },
+					lacks: ["reasoning"],
+				},
+			],
+		},
+		{
+			name: "direct MiniMax M2.7 reasoning disabled -> no MiniMax M3 disabled exception",
+			request: {
+				providerId: "minimax",
+				modelId: "MiniMax-M2.7",
+				reasoning: { enabled: false },
+			},
+			context: {
+				family: "minimax",
+				capabilities: ["reasoning"],
+				metadata: MINIMAX_THINKING_ROUTING_METADATA,
+			},
+			expect: [
+				{
+					bucket: "minimax",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+				{
+					bucket: "openaiCompatible",
+					lacks: ["thinking", "reasoning", "effort", "reasoningEffort"],
+				},
+			],
+		},
+		// Ollama Qwen3: model behavior fact first, documented dynamic fallback second.
+		{
+			name: "ollama metadata reasoningDefaultOn disabled -> reasoningEffort none",
+			request: {
+				providerId: "ollama",
+				modelId: "local-known-reasoner:latest",
+				reasoning: { enabled: false },
+			},
+			context: { modelMetadata: { reasoningDefaultOn: true } },
+			expect: [
+				{
+					bucket: "ollama",
+					has: {
+						reasoningEffort: "none",
+						reasoning: { effort: "none" },
+					},
+				},
+				{
+					bucket: "openaiCompatible",
+					has: {
+						reasoningEffort: "none",
+						reasoning: { effort: "none" },
+					},
+				},
+			],
+		},
+		{
+			name: "ollama qwen3 fallback reasoning disabled -> reasoningEffort none",
+			request: {
+				providerId: "ollama",
+				modelId: "qwen3-coder:30b",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{
+					bucket: "ollama",
+					has: {
+						reasoningEffort: "none",
+						reasoning: { effort: "none" },
+					},
+				},
+				{
+					bucket: "openaiCompatible",
+					has: {
+						reasoningEffort: "none",
+						reasoning: { effort: "none" },
+					},
+				},
+			],
+		},
+		{
+			name: "ollama qwen3 fallback reasoning enabled -> no disable patch",
+			request: {
+				providerId: "ollama",
+				modelId: "qwen3-coder:30b",
+				reasoning: { enabled: true },
+			},
+			expect: [
+				{ bucket: "ollama", lacks: ["reasoningEffort", "reasoning"] },
+				{ bucket: "openaiCompatible", lacks: ["reasoningEffort", "reasoning"] },
+			],
+		},
+		{
+			name: "ollama qwen3 fallback with unset reasoning -> no disable patch",
+			request: {
+				providerId: "ollama",
+				modelId: "qwen3-coder:30b",
+			},
+			expect: [
+				{ bucket: "ollama", lacks: ["reasoningEffort", "reasoning"] },
+				{ bucket: "openaiCompatible", lacks: ["reasoningEffort", "reasoning"] },
+			],
+		},
+		{
+			name: "ollama metadata reasoningDefaultOn with unset reasoning -> no disable patch",
+			request: {
+				providerId: "ollama",
+				modelId: "local-known-reasoner:latest",
+			},
+			context: { modelMetadata: { reasoningDefaultOn: true } },
+			expect: [
+				{ bucket: "ollama", lacks: ["reasoningEffort", "reasoning"] },
+				{ bucket: "openaiCompatible", lacks: ["reasoningEffort", "reasoning"] },
+			],
+		},
+		{
+			name: "ollama metadata reasoningDefaultOn beats deepseek family thinking disable",
+			request: {
+				providerId: "ollama",
+				modelId: "deepseek-r1:latest",
+				reasoning: { enabled: false },
+			},
+			context: {
+				family: "deepseek",
+				modelMetadata: { reasoningDefaultOn: true },
+			},
+			expect: [
+				{
+					bucket: "ollama",
+					has: {
+						reasoningEffort: "none",
+						reasoning: { effort: "none" },
+					},
+					lacks: ["thinking"],
+				},
+				{
+					bucket: "openaiCompatible",
+					has: {
+						reasoningEffort: "none",
+						reasoning: { effort: "none" },
+					},
+					lacks: ["thinking"],
+				},
+			],
+		},
+		{
+			name: "ollama metadata reasoningDefaultOn false prevents qwen3 fallback",
+			request: {
+				providerId: "ollama",
+				modelId: "qwen3-coder:30b",
+				reasoning: { enabled: false },
+			},
+			context: { modelMetadata: { reasoningDefaultOn: false } },
+			expect: [
+				{ bucket: "ollama", lacks: ["reasoningEffort", "reasoning"] },
+				{ bucket: "openaiCompatible", lacks: ["reasoningEffort", "reasoning"] },
+			],
+		},
+		{
+			name: "ollama non-default reasoning disabled -> no special disable patch",
+			request: {
+				providerId: "ollama",
+				modelId: "llama3.1:8b",
+				reasoning: { enabled: false },
+			},
+			expect: [
+				{ bucket: "ollama", lacks: ["reasoningEffort", "reasoning"] },
+				{ bucket: "openaiCompatible", lacks: ["reasoningEffort", "reasoning"] },
+			],
+		},
+	]);
+});
+
+describe("composeAiSdkProviderOptions: provider-specific overlays", () => {
+	it.each([
+		"openai",
+		"openai-native",
+	])("emits truncation for native OpenAI provider %s", (providerId) => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({ providerId, modelId: "gpt-5.4" }),
+			makeContext({ providerId, modelId: "gpt-5.4" }),
+		);
+
+		expect(result.openai).toHaveProperty("truncation", "auto");
+	});
+
+	it("emits the openai-codex `openai` bucket alongside provider-id and alias buckets", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "openai-codex",
+				modelId: "gpt-5.4",
+				systemPrompt: "you are helpful",
+				reasoning: { effort: "high" },
+			}),
+			makeContext({ providerId: "openai-codex", modelId: "gpt-5.4" }),
+		);
+
+		expect(result.openai).toEqual(
+			expect.objectContaining({
+				instructions: "you are helpful",
+				store: false,
+				systemMessageMode: "remove",
+			}),
+		);
+		expect(result.openai).not.toHaveProperty("truncation");
+		expect(result["openai-codex"]).toEqual(
+			expect.objectContaining({
+				store: false,
+				reasoningEffort: "high",
+				reasoningSummary: "auto",
+			}),
+		);
+		expect(result["openai-codex"]).not.toHaveProperty("truncation");
+		expect(result.openaiCodex).toEqual(
+			expect.objectContaining({ store: false }),
+		);
+		expect(result.openaiCodex).not.toHaveProperty("truncation");
+	});
+
+	it("emits Gemini 2.5 google.thinkingConfig budget only when reasoning effort is set", () => {
+		const withEffort = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "gemini",
+				modelId: "gemini-2.5-flash",
+				reasoning: { effort: "medium" },
+			}),
+			makeContext({ providerId: "gemini", modelId: "gemini-2.5-flash" }),
+		);
+		expect(withEffort.google).toEqual({
+			thinkingConfig: { thinkingBudget: 8192, includeThoughts: true },
+		});
+
+		const withoutEffort = composeAiSdkProviderOptions(
+			makeRequest({ providerId: "gemini", modelId: "gemini-2.5-flash" }),
+			makeContext({ providerId: "gemini", modelId: "gemini-2.5-flash" }),
+		);
+		expect(withoutEffort).not.toHaveProperty("google");
+	});
+
+	it("keeps the google bucket owned by the gemini patch for direct google providers", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "google",
+				modelId: "gemini-2.5-flash",
+				reasoning: { enabled: true, effort: "high" },
+			}),
+			makeContext({ providerId: "google", modelId: "gemini-2.5-flash" }),
+		);
+
+		expect(result.google).toEqual({
+			thinkingConfig: { thinkingBudget: 24576, includeThoughts: true },
+		});
+		expect(result.google).not.toHaveProperty("thinking");
+		expect(result.google).not.toHaveProperty("effort");
+		expect(result.google).not.toHaveProperty("reasoningEffort");
+		expect(result.google).not.toHaveProperty("reasoningSummary");
+	});
+
+	it("emits Gemini thinkingConfig in the vertex bucket for Vertex providers", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+				reasoning: { enabled: true, effort: "high" },
+			}),
+			makeContext({
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+			}),
+		);
+
+		expect(result.vertex).toEqual(
+			expect.objectContaining({
+				thinkingConfig: { thinkingLevel: "high", includeThoughts: true },
+			}),
+		);
+		expect(result.vertex).not.toHaveProperty("thinking");
+		expect(result.vertex).not.toHaveProperty("effort");
+		expect(result.vertex).not.toHaveProperty("reasoningEffort");
+		expect(result.vertex).not.toHaveProperty("reasoningSummary");
+		expect(result.google).toBeUndefined();
+	});
+
+	it("keeps Vertex Claude reasoning on the Anthropic-compatible route", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vertex",
+				modelId: "claude-sonnet-4-5",
+				reasoning: { enabled: true, effort: "high" },
+			}),
+			makeContext({
+				providerId: "vertex",
+				modelId: "claude-sonnet-4-5",
+				family: "claude-sonnet",
+				capabilities: ["text", "reasoning"],
+			}),
+		);
+
+		expect(result.vertex).toEqual(
+			expect.objectContaining({
+				reasoning: { enabled: true, max_tokens: 1024 },
+			}),
+		);
+		expect(result.vertex).not.toHaveProperty("thinkingConfig");
+		expect(result.vertex).not.toHaveProperty("effort");
+		expect(result.vertex).not.toHaveProperty("reasoningEffort");
+		expect(result.vertex).not.toHaveProperty("reasoningSummary");
+	});
+
+	it("maps disabled Vertex thinking to minimal thinkingConfig", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+				reasoning: { enabled: false },
+			}),
+			makeContext({
+				providerId: "vertex",
+				modelId: "gemini-3-flash-preview",
+			}),
+		);
+
+		expect(result.vertex).toEqual(
+			expect.objectContaining({
+				thinkingConfig: { thinkingLevel: "minimal", includeThoughts: false },
+			}),
+		);
+		expect(result.vertex).not.toHaveProperty("thinking");
+		expect(result.vertex).not.toHaveProperty("effort");
+		expect(result.vertex).not.toHaveProperty("reasoningEffort");
+		expect(result.vertex).not.toHaveProperty("reasoningSummary");
+		expect(result.google).toBeUndefined();
+	});
+
+	it("maps Vertex Gemini Flash Latest disabled thinking to a zero thinking budget", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vertex",
+				modelId: "gemini-flash-latest",
+				reasoning: { enabled: false },
+			}),
+			makeContext({
+				providerId: "vertex",
+				modelId: "gemini-flash-latest",
+				family: "gemini-flash",
+				capabilities: ["reasoning"],
+			}),
+		);
+
+		expect(result.vertex).toEqual(
+			expect.objectContaining({
+				thinkingConfig: { thinkingBudget: 0, includeThoughts: false },
+			}),
+		);
+		expect(result.vertex).not.toHaveProperty("thinking");
+		expect(result.vertex).not.toHaveProperty("effort");
+		expect(result.vertex).not.toHaveProperty("reasoningEffort");
+		expect(result.vertex).not.toHaveProperty("reasoningSummary");
+		expect(result.google).toBeUndefined();
+	});
+
+	it("maps Vertex Gemini Flash Latest effort to a Gemini 2.5 thinking budget", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vertex",
+				modelId: "gemini-flash-latest",
+				reasoning: { enabled: true, effort: "high" },
+			}),
+			makeContext({
+				providerId: "vertex",
+				modelId: "gemini-flash-latest",
+				family: "gemini-flash",
+				capabilities: ["reasoning"],
+			}),
+		);
+
+		expect(result.vertex).toEqual(
+			expect.objectContaining({
+				thinkingConfig: { thinkingBudget: 24576, includeThoughts: true },
+			}),
+		);
+		expect(result.vertex).not.toHaveProperty("thinking");
+		expect(result.vertex).not.toHaveProperty("effort");
+		expect(result.vertex).not.toHaveProperty("reasoningEffort");
+		expect(result.vertex).not.toHaveProperty("reasoningSummary");
+		expect(result.google).toBeUndefined();
+	});
+
+	it("keeps disabled Vertex Gemini 2.5 Pro on a valid minimum thinking budget", () => {
+		const result = composeAiSdkProviderOptions(
+			makeRequest({
+				providerId: "vertex",
+				modelId: "gemini-2.5-pro",
+				reasoning: { enabled: false },
+			}),
+			makeContext({
+				providerId: "vertex",
+				modelId: "gemini-2.5-pro",
+				family: "gemini-pro",
+				capabilities: ["reasoning"],
+			}),
+		);
+
+		expect(result.vertex).toEqual(
+			expect.objectContaining({
+				thinkingConfig: { thinkingBudget: 128, includeThoughts: false },
+			}),
+		);
+		expect(result.vertex).not.toHaveProperty("thinking");
+		expect(result.vertex).not.toHaveProperty("effort");
+		expect(result.vertex).not.toHaveProperty("reasoningEffort");
+		expect(result.vertex).not.toHaveProperty("reasoningSummary");
+		expect(result.google).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/llms/src/providers/routing/provider-options.ts b/sdk/packages/llms/src/providers/routing/provider-options.ts
new file mode 100644
index 0000000..bf04078
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/provider-options.ts
@@ -0,0 +1,119 @@
+import type {
+	GatewayProviderContext,
+	GatewayStreamRequest,
+} from "@cline/shared";
+import { isAnthropicCompatibleModel, resolveModelFamily } from "../model-facts";
+import {
+	buildAnthropicProviderOptions,
+	resolveAnthropicReasoningRequestPolicy,
+} from "./anthropic-compatible";
+import { buildCompatibleProviderOptions } from "./generic-compatible";
+import {
+	buildProviderOptionRulePatches,
+	matchProviderOptionRules,
+	PROVIDER_OPTION_RULES,
+	resolveProviderOptionSuppressions,
+} from "./provider-option-rules";
+import {
+	type AiSdkProviderOptionsTarget,
+	inferProviderOptionsTarget,
+	type ProviderOptionMatchInput,
+} from "./provider-options-types";
+import { type ProviderOptionsPatch, toProviderOptionsKey } from "./utils";
+
+export type { AiSdkProviderOptionsTarget } from "./provider-options-types";
+export type { ProviderOptionsPatch } from "./utils";
+
+/**
+ * Merge patches in order. Later patches override earlier ones per bucket key;
+ * nested object values are replaced, not deep-merged.
+ */
+export function mergeProviderOptionPatches(
+	patches: ReadonlyArray<ProviderOptionsPatch | undefined>,
+): Record<string, unknown> {
+	const result: Record<string, Record<string, unknown>> = {};
+	for (const patch of patches) {
+		if (!patch) {
+			continue;
+		}
+		for (const [bucket, options] of Object.entries(patch)) {
+			result[bucket] = { ...(result[bucket] ?? {}), ...options };
+		}
+	}
+	return result;
+}
+
+function buildBaseProviderOptionsPatch(
+	compatibleOptions: Record<string, unknown>,
+	anthropicOptions: Record<string, unknown>,
+): ProviderOptionsPatch {
+	return {
+		anthropic: anthropicOptions,
+		openaiCompatible: compatibleOptions,
+	};
+}
+
+/**
+ * Compose AI SDK `providerOptions` from named provider/model-family rules.
+ *
+ * The rule table in `provider-option-rules.ts` is the behavior matrix for
+ * special providers and model families. Keep the composer boring: build shared
+ * buckets once, then merge ordered rule patches.
+ *
+ * Routing ownership boundary:
+ * - Gateway model capabilities say what a model can do, such as reasoning.
+ * - Model metadata records stable known-model facts, such as
+ *   `reasoningDefaultOn`.
+ * - Provider metadata records stable provider policy, such as prompt caching.
+ * - Provider-option rules encode abstract request intent into provider wire
+ *   formats, such as `reasoning.exclude`, `thinking.type`, or
+ *   `reasoningEffort`.
+ */
+export function composeAiSdkProviderOptions(
+	request: GatewayStreamRequest,
+	context: GatewayProviderContext,
+	target: AiSdkProviderOptionsTarget = inferProviderOptionsTarget(
+		request.providerId,
+	),
+): Record<string, unknown> {
+	const providerOptionsKey = toProviderOptionsKey(request.providerId);
+	const family = resolveModelFamily(context);
+	const isAnthropicCompatibleModelId = isAnthropicCompatibleModel({
+		modelId: request.modelId,
+		family,
+	});
+	const anthropicReasoningPolicy = isAnthropicCompatibleModelId
+		? resolveAnthropicReasoningRequestPolicy(request, context)
+		: undefined;
+	const matchInput: ProviderOptionMatchInput = {
+		request,
+		context,
+		providerOptionsKey,
+		target,
+		isAnthropicCompatibleModelId,
+		anthropicReasoningPolicyKind: anthropicReasoningPolicy?.kind,
+	};
+	const matchedRules = matchProviderOptionRules(
+		PROVIDER_OPTION_RULES,
+		matchInput,
+	);
+	const suppressions = resolveProviderOptionSuppressions(matchedRules);
+	const compatibleOptions = buildCompatibleProviderOptions({
+		request,
+		context,
+		target,
+		suppressions,
+	});
+	const anthropicOptions = buildAnthropicProviderOptions(request, context);
+	const buildInput = {
+		...matchInput,
+		compatibleOptions,
+		anthropicOptions,
+		suppressions,
+	};
+
+	return mergeProviderOptionPatches([
+		buildBaseProviderOptionsPatch(compatibleOptions, anthropicOptions),
+		...buildProviderOptionRulePatches(matchedRules, buildInput),
+	]);
+}
diff --git a/sdk/packages/llms/src/providers/routing/reasoning-codecs.ts b/sdk/packages/llms/src/providers/routing/reasoning-codecs.ts
new file mode 100644
index 0000000..f3d3e4b
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/reasoning-codecs.ts
@@ -0,0 +1,40 @@
+import type { GatewayStreamRequest } from "@cline/shared";
+
+export function hasReasoningControls(
+	reasoning: GatewayStreamRequest["reasoning"],
+): boolean {
+	return (
+		reasoning?.enabled !== undefined ||
+		!!reasoning?.effort ||
+		typeof reasoning?.budgetTokens === "number"
+	);
+}
+
+export function buildOpenRouterReasoningOptions(
+	request: GatewayStreamRequest,
+): Record<string, unknown> | undefined {
+	const reasoning = request.reasoning;
+	if (!hasReasoningControls(reasoning)) {
+		return undefined;
+	}
+
+	if (reasoning?.enabled === false) {
+		return { effort: "none" };
+	}
+
+	// OpenRouter accepts one reasoning control mode. Preserve this precedence:
+	// explicit disable, exact token budget, effort level, then plain enable.
+	if (typeof reasoning?.budgetTokens === "number") {
+		return { max_tokens: reasoning.budgetTokens };
+	}
+
+	if (reasoning?.effort) {
+		return { effort: reasoning.effort };
+	}
+
+	if (reasoning?.enabled === true) {
+		return { enabled: true };
+	}
+
+	return undefined;
+}
diff --git a/sdk/packages/llms/src/providers/routing/utils.ts b/sdk/packages/llms/src/providers/routing/utils.ts
new file mode 100644
index 0000000..6637cc8
--- /dev/null
+++ b/sdk/packages/llms/src/providers/routing/utils.ts
@@ -0,0 +1,47 @@
+export type ProviderOptionsPatch = Record<string, Record<string, unknown>>;
+
+export function toProviderOptionsKey(providerId: string): string {
+	return providerId.replace(/-([a-z0-9])/gi, (_match, char: string) =>
+		char.toUpperCase(),
+	);
+}
+
+export function createEphemeralCacheControl() {
+	return {
+		cache_control: { type: "ephemeral" as const },
+	};
+}
+
+/**
+ * Target the concrete provider id and, when distinct, its camelCase alias
+ * bucket (e.g. `vercel-ai-gateway` + `vercelAiGateway`).
+ */
+export function buildProviderAndAliasPatch(options: {
+	providerId: string;
+	providerOptionsKey: string;
+	bucketOptions: Record<string, unknown>;
+}): ProviderOptionsPatch {
+	const { providerId, providerOptionsKey, bucketOptions } = options;
+	const needsAlias =
+		providerOptionsKey !== providerId && providerOptionsKey !== "anthropic";
+	return {
+		[providerId]: bucketOptions,
+		...(needsAlias ? { [providerOptionsKey]: bucketOptions } : {}),
+	};
+}
+
+export function buildThinkingPatch(options: {
+	providerId: string;
+	providerOptionsKey: string;
+	thinkingType: "enabled" | "disabled";
+}): ProviderOptionsPatch {
+	const bucketOptions = { thinking: { type: options.thinkingType } };
+	return {
+		...buildProviderAndAliasPatch({
+			providerId: options.providerId,
+			providerOptionsKey: options.providerOptionsKey,
+			bucketOptions,
+		}),
+		openaiCompatible: bucketOptions,
+	};
+}
diff --git a/sdk/packages/llms/src/providers/stream.ts b/sdk/packages/llms/src/providers/stream.ts
new file mode 100644
index 0000000..be42ae5
--- /dev/null
+++ b/sdk/packages/llms/src/providers/stream.ts
@@ -0,0 +1,117 @@
+/**
+ * API Stream Types
+ *
+ * Unified streaming response types that all providers yield.
+ * This provides a consistent interface regardless of the underlying provider.
+ */
+
+/**
+ * The main stream type - an async generator that yields chunks
+ */
+export type ApiStream = AsyncGenerator<ApiStreamChunk> & { id?: string };
+
+/**
+ * Union of all possible chunk types
+ */
+export type ApiStreamChunk =
+	| ApiStreamTextChunk
+	| ApiStreamReasoningChunk
+	| ApiStreamUsageChunk
+	| ApiStreamToolCallsChunk
+	| ApiStreamDoneChunk;
+
+/**
+ * Text content chunk
+ */
+export interface ApiStreamTextChunk {
+	type: "text";
+	/** Text content generated by the model */
+	text: string;
+	/** Response ID associated with this chunk */
+	id: string;
+	/** Thought signature (used by Gemini) */
+	signature?: string;
+}
+
+/**
+ * Reasoning/thinking content chunk
+ */
+export interface ApiStreamReasoningChunk {
+	type: "reasoning";
+	/** The reasoning text generated by the model */
+	reasoning: string;
+	/** Additional reasoning details (provider-specific) */
+	details?: unknown;
+	/** Signature for the thinking block (Anthropic, Gemini) */
+	signature?: string;
+	/** Redacted reasoning data */
+	redacted_data?: string;
+	/** Response ID associated with this chunk */
+	id: string;
+}
+
+/**
+ * Usage/token count chunk
+ */
+export interface ApiStreamUsageChunk {
+	type: "usage";
+	/** Total number of input tokens reported by the provider */
+	inputTokens: number;
+	/** Number of output tokens */
+	outputTokens: number;
+	/** Number of tokens written to cache */
+	cacheWriteTokens?: number;
+	/** Number of tokens read from cache */
+	cacheReadTokens?: number;
+	/** Number of thinking/reasoning tokens */
+	thoughtsTokenCount?: number;
+	/** Total cost in USD (if calculable) */
+	totalCost?: number;
+	/** Response ID */
+	id: string;
+}
+
+/**
+ * Tool call chunk
+ */
+export interface ApiStreamToolCallsChunk {
+	type: "tool_calls";
+	/** The tool call information */
+	tool_call: ApiStreamToolCall;
+	/** Response ID */
+	id: string;
+	/** Thought signature (Gemini) */
+	signature?: string;
+}
+
+/**
+ * Tool call details
+ */
+export interface ApiStreamToolCall {
+	/** Call ID for this tool invocation */
+	call_id?: string;
+	/** Function/tool information */
+	function: {
+		/** Tool call ID */
+		id?: string;
+		/** Name of the tool */
+		name?: string;
+		/** Arguments passed to the tool (can be string or parsed object) */
+		arguments?: string | Record<string, unknown>;
+	};
+}
+
+/**
+ * Stream completion chunk - indicates the stream has finished
+ */
+export interface ApiStreamDoneChunk {
+	type: "done";
+	/** Whether the stream completed successfully */
+	success: boolean;
+	/** Error message if the stream failed */
+	error?: string;
+	/** Reason for incomplete response (e.g., "max_output_tokens") */
+	incompleteReason?: string;
+	/** Response ID */
+	id: string;
+}
diff --git a/sdk/packages/llms/src/providers/types.ts b/sdk/packages/llms/src/providers/types.ts
new file mode 100644
index 0000000..fa6a047
--- /dev/null
+++ b/sdk/packages/llms/src/providers/types.ts
@@ -0,0 +1,77 @@
+/**
+ * Types Index
+ *
+ * Re-exports all types from the types module.
+ */
+
+// Configuration types
+export {
+	type AuthConfig,
+	type AwsConfig,
+	type AzureConfig,
+	BUILT_IN_PROVIDER,
+	BUILT_IN_PROVIDER_IDS,
+	type BuiltInProviderId,
+	type ClaudeCodeConfig,
+	type CloudConfig,
+	type CodexConfig,
+	createConfig,
+	type EndpointConfig,
+	type GcpConfig,
+	hasCapability,
+	isBuiltInProviderId,
+	type ModelCatalogConfig,
+	type ModelConfig,
+	normalizeProviderId,
+	type OcaConfig,
+	type OpenCodeConfig,
+	type ProviderCapability,
+	type ProviderCategory,
+	type ProviderConfig,
+	type ProviderDefaultsConfig,
+	type ProviderId,
+	type ProviderOptions,
+	type ProviderSpecificConfig,
+	type ReasoningConfig,
+	type RegionConfig,
+	resolveRoutingProviderId,
+	type SapConfig,
+	type SimpleProviderConfig,
+	supportsPromptCache,
+	supportsReasoning,
+	type TokenConfig,
+} from "./config";
+// Handler types
+export type {
+	ApiHandler,
+	HandlerFactory,
+	HandlerModelInfo,
+	LazyHandlerFactory,
+	SingleCompletionHandler,
+} from "./handler";
+// Message types
+export type {
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	MessageRole,
+	MessageWithMetadata,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolDefinition,
+	ToolResultContent,
+	ToolUseContent,
+} from "./messages";
+// Stream types
+export type {
+	ApiStream,
+	ApiStreamChunk,
+	ApiStreamDoneChunk,
+	ApiStreamReasoningChunk,
+	ApiStreamTextChunk,
+	ApiStreamToolCall,
+	ApiStreamToolCallsChunk,
+	ApiStreamUsageChunk,
+} from "./stream";
diff --git a/sdk/packages/llms/src/providers/vendors/anthropic.test.ts b/sdk/packages/llms/src/providers/vendors/anthropic.test.ts
new file mode 100644
index 0000000..4027ef2
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/anthropic.test.ts
@@ -0,0 +1,90 @@
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAnthropicProviderModule } from "./anthropic";
+
+const createAnthropicMock = vi.hoisted(() => vi.fn());
+const anthropicModelMock = vi.hoisted(() =>
+	vi.fn((modelId: string) => ({ provider: "anthropic", modelId })),
+);
+
+vi.mock("@ai-sdk/anthropic", () => ({
+	createAnthropic: createAnthropicMock,
+}));
+
+describe("createAnthropicProviderModule", () => {
+	beforeEach(() => {
+		createAnthropicMock.mockReset();
+		createAnthropicMock.mockReturnValue(anthropicModelMock);
+		anthropicModelMock.mockClear();
+	});
+
+	it("passes custom base URLs to Anthropic-compatible providers", async () => {
+		const provider = await createAnthropicProviderModule(
+			config({
+				apiKey: "minimax-api-key",
+				baseUrl: "https://api.minimax.io/anthropic",
+			}),
+			context("minimax"),
+		);
+
+		provider.model("MiniMax-M2.5");
+
+		expect(createAnthropicMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "minimax-api-key",
+				baseURL: "https://api.minimax.io/anthropic",
+				name: "minimax",
+			}),
+		);
+		expect(anthropicModelMock).toHaveBeenCalledWith("MiniMax-M2.5");
+	});
+
+	it("does not wrap fetch for non-MiniMax Anthropic-compatible providers", async () => {
+		const customFetch = vi.fn<typeof fetch>();
+
+		await createAnthropicProviderModule(
+			config({
+				providerId: "anthropic",
+				apiKey: "anthropic-api-key",
+				fetch: customFetch,
+			}),
+			context("anthropic"),
+		);
+
+		expect(createAnthropicMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				name: "anthropic",
+				fetch: customFetch,
+			}),
+		);
+	});
+});
+
+function config(
+	overrides: Partial<GatewayResolvedProviderConfig>,
+): GatewayResolvedProviderConfig {
+	return {
+		providerId: "minimax",
+		...overrides,
+	};
+}
+
+function context(providerId: string): GatewayProviderContext {
+	return {
+		provider: {
+			id: providerId,
+			name: "MiniMax",
+			defaultModelId: "MiniMax-M2.5",
+			models: [],
+		},
+		model: {
+			providerId,
+			id: "MiniMax-M2.5",
+			name: "MiniMax-M2.5",
+		},
+		config: config({ providerId }),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/anthropic.ts b/sdk/packages/llms/src/providers/vendors/anthropic.ts
new file mode 100644
index 0000000..8904206
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/anthropic.ts
@@ -0,0 +1,39 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { wrapLanguageModel } from "ai";
+import { resolveApiKey } from "../http";
+import {
+	createMiniMaxThinkingFetch,
+	miniMaxThinkingDisabledMiddleware,
+} from "./minimax-thinking";
+import type { ProviderFactoryResult } from "./types";
+
+export async function createAnthropicProviderModule(
+	config: GatewayResolvedProviderConfig,
+	context: GatewayProviderContext,
+): Promise<ProviderFactoryResult> {
+	const apiKey = await resolveApiKey(config);
+	const isMiniMax = context.provider.id === "minimax";
+	const provider = createAnthropic({
+		apiKey,
+		baseURL: config.baseUrl,
+		headers: config.headers,
+		fetch: isMiniMax ? createMiniMaxThinkingFetch(config.fetch) : config.fetch,
+		name: context.provider.id,
+	});
+	return {
+		model: (modelId) => {
+			const model = provider(modelId);
+			return isMiniMax
+				? wrapLanguageModel({
+						model: model as LanguageModelV3,
+						middleware: miniMaxThinkingDisabledMiddleware,
+					})
+				: model;
+		},
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/bedrock.test.ts b/sdk/packages/llms/src/providers/vendors/bedrock.test.ts
new file mode 100644
index 0000000..f34c06e
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/bedrock.test.ts
@@ -0,0 +1,201 @@
+import type { GatewayResolvedProviderConfig } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createBedrockProviderModule } from "./bedrock";
+
+const createAmazonBedrockMock = vi.hoisted(() => vi.fn());
+const fromNodeProviderChainMock = vi.hoisted(() => vi.fn());
+const bedrockModelMock = vi.hoisted(() =>
+	vi.fn((modelId: string) => ({ modelId })),
+);
+
+vi.mock("@ai-sdk/amazon-bedrock", () => ({
+	createAmazonBedrock: createAmazonBedrockMock,
+}));
+
+vi.mock("@aws-sdk/credential-providers", () => ({
+	fromNodeProviderChain: fromNodeProviderChainMock,
+}));
+
+const ORIGINAL_ENV = { ...process.env };
+
+describe("createBedrockProviderModule", () => {
+	beforeEach(() => {
+		process.env = { ...ORIGINAL_ENV };
+		createAmazonBedrockMock.mockReset();
+		createAmazonBedrockMock.mockReturnValue(bedrockModelMock);
+		fromNodeProviderChainMock.mockReset();
+		fromNodeProviderChainMock.mockReturnValue(async () => ({
+			accessKeyId: "chain-access-key",
+			secretAccessKey: "chain-secret-key",
+		}));
+		bedrockModelMock.mockClear();
+	});
+
+	afterEach(() => {
+		process.env = { ...ORIGINAL_ENV };
+	});
+
+	it("uses explicit Bedrock bearer API keys without configuring SigV4 credentials", async () => {
+		await createBedrockProviderModule(
+			config({
+				apiKey: " bedrock-api-key ",
+				options: { region: "us-east-1" },
+			}),
+		);
+
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "bedrock-api-key",
+				region: "us-east-1",
+				accessKeyId: undefined,
+				secretAccessKey: undefined,
+				sessionToken: undefined,
+				credentialProvider: undefined,
+			}),
+		);
+		expect(fromNodeProviderChainMock).not.toHaveBeenCalled();
+	});
+
+	it("suppresses provider credential fallback for explicit API-key auth with no resolved key", async () => {
+		await createBedrockProviderModule(
+			config({
+				options: { authentication: "apikey", region: "us-east-1" },
+			}),
+		);
+
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "",
+				accessKeyId: undefined,
+				secretAccessKey: undefined,
+				sessionToken: undefined,
+				credentialProvider: undefined,
+			}),
+		);
+		expect(fromNodeProviderChainMock).not.toHaveBeenCalled();
+	});
+
+	it("uses direct IAM credentials and disables bearer-token env fallback", async () => {
+		process.env.AWS_BEARER_TOKEN_BEDROCK = "env-bearer-token";
+
+		await createBedrockProviderModule(
+			config({
+				options: {
+					authentication: "iam",
+					region: "us-west-2",
+					accessKeyId: "access-key",
+					secretAccessKey: "secret-key",
+					sessionToken: "session-token",
+				},
+			}),
+		);
+
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "",
+				accessKeyId: "access-key",
+				secretAccessKey: "secret-key",
+				sessionToken: "session-token",
+				credentialProvider: undefined,
+			}),
+		);
+		expect(fromNodeProviderChainMock).not.toHaveBeenCalled();
+	});
+
+	it("uses AWS profiles through the SDK credential provider chain", async () => {
+		await createBedrockProviderModule(
+			config({
+				options: {
+					authentication: "profile",
+					profile: "dev-profile",
+					region: "us-east-2",
+				},
+			}),
+		);
+
+		expect(fromNodeProviderChainMock).toHaveBeenCalledWith({
+			ignoreCache: true,
+			profile: "dev-profile",
+			clientConfig: { region: "us-east-2" },
+		});
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "",
+				accessKeyId: undefined,
+				secretAccessKey: undefined,
+				sessionToken: undefined,
+				credentialProvider: expect.any(Function),
+			}),
+		);
+	});
+
+	it("treats a configured AWS profile as profile auth when authentication is omitted", async () => {
+		await createBedrockProviderModule(
+			config({
+				options: {
+					profile: "default",
+					region: "us-east-1",
+				},
+			}),
+		);
+
+		expect(fromNodeProviderChainMock).toHaveBeenCalledWith({
+			ignoreCache: true,
+			profile: "default",
+			clientConfig: { region: "us-east-1" },
+		});
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "",
+				credentialProvider: expect.any(Function),
+			}),
+		);
+	});
+
+	it("uses the default AWS SDK credential chain when no static credentials are configured", async () => {
+		await createBedrockProviderModule(
+			config({
+				options: { authentication: "iam", region: "us-east-1" },
+			}),
+		);
+
+		expect(fromNodeProviderChainMock).toHaveBeenCalledWith({
+			clientConfig: { region: "us-east-1" },
+		});
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "",
+				credentialProvider: expect.any(Function),
+			}),
+		);
+	});
+
+	it("does not treat AWS_REGION or IAM env vars as bearer API keys", async () => {
+		process.env.AWS_REGION = "us-west-2";
+		process.env.AWS_ACCESS_KEY_ID = "env-access-key";
+		process.env.AWS_SECRET_ACCESS_KEY = "env-secret-key";
+
+		await createBedrockProviderModule(
+			config({
+				apiKeyEnv: ["AWS_REGION", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
+				options: { authentication: "iam" },
+			}),
+		);
+
+		expect(createAmazonBedrockMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "",
+				credentialProvider: expect.any(Function),
+			}),
+		);
+	});
+});
+
+function config(
+	overrides: Partial<GatewayResolvedProviderConfig>,
+): GatewayResolvedProviderConfig {
+	return {
+		providerId: "bedrock",
+		...overrides,
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/bedrock.ts b/sdk/packages/llms/src/providers/vendors/bedrock.ts
new file mode 100644
index 0000000..6748a41
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/bedrock.ts
@@ -0,0 +1,171 @@
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
+import type { GatewayResolvedProviderConfig } from "@cline/shared";
+import type { ProviderFactoryResult } from "./types";
+
+type BedrockCredentials = {
+	accessKeyId: string;
+	secretAccessKey: string;
+	sessionToken?: string;
+};
+
+type BedrockCredentialProvider = () => PromiseLike<BedrockCredentials>;
+
+type BedrockAuthentication = "iam" | "api-key" | "apikey" | "profile";
+
+// Docs: https://ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock
+const NON_BEDROCK_API_KEY_ENV = new Set([
+	"AWS_ACCESS_KEY_ID",
+	"AWS_SECRET_ACCESS_KEY",
+	"AWS_SESSION_TOKEN",
+	"AWS_REGION",
+	"AWS_DEFAULT_REGION",
+	"AWS_PROFILE",
+]);
+
+export async function createBedrockProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	const authentication = readAuthentication(config.options?.authentication);
+	const usesApiKeyAuth =
+		authentication === "api-key" || authentication === "apikey";
+	const hasDirectCredentials =
+		readOptionalString(config.options?.accessKeyId) !== undefined &&
+		readOptionalString(config.options?.secretAccessKey) !== undefined;
+	const hasProfile = readOptionalString(config.options?.profile) !== undefined;
+	const usesExplicitSigV4Auth =
+		!usesApiKeyAuth &&
+		(authentication === "iam" || authentication === "profile" || hasProfile);
+	const apiKey = usesExplicitSigV4Auth
+		? undefined
+		: await resolveBedrockApiKey(config, {
+				includeEnvironment: usesApiKeyAuth || !hasDirectCredentials,
+			});
+	const credentialProvider = resolveCredentialProvider(config, {
+		authentication,
+		apiKey,
+		hasDirectCredentials,
+		hasProfile,
+	});
+	const usesSigV4 =
+		authentication === "iam" ||
+		authentication === "profile" ||
+		hasDirectCredentials ||
+		credentialProvider !== undefined;
+
+	const provider = createAmazonBedrock({
+		region: readOptionalString(config.options?.region),
+		apiKey: usesApiKeyAuth
+			? (apiKey ?? "")
+			: (apiKey ?? (usesSigV4 ? "" : undefined)),
+		accessKeyId: credentialProvider
+			? undefined
+			: readOptionalString(config.options?.accessKeyId),
+		secretAccessKey: credentialProvider
+			? undefined
+			: readOptionalString(config.options?.secretAccessKey),
+		sessionToken: credentialProvider
+			? undefined
+			: readOptionalString(config.options?.sessionToken),
+		baseURL: config.baseUrl ?? readOptionalString(config.options?.endpoint),
+		headers: config.headers,
+		fetch: config.fetch,
+		credentialProvider,
+	});
+
+	return {
+		model: (modelId) => provider(modelId),
+	};
+}
+
+function resolveCredentialProvider(
+	config: GatewayResolvedProviderConfig,
+	options: {
+		authentication: BedrockAuthentication | undefined;
+		apiKey: string | undefined;
+		hasDirectCredentials: boolean;
+		hasProfile: boolean;
+	},
+): BedrockCredentialProvider | undefined {
+	const region = readOptionalString(config.options?.region);
+	if (typeof config.options?.credentialProvider === "function") {
+		return config.options.credentialProvider as BedrockCredentialProvider;
+	}
+
+	if (
+		options.authentication === "api-key" ||
+		options.authentication === "apikey" ||
+		options.apiKey
+	) {
+		return undefined;
+	}
+
+	if (options.authentication === "profile" || options.hasProfile) {
+		const profile = readOptionalString(config.options?.profile);
+		return fromNodeProviderChain({
+			ignoreCache: true,
+			...(profile ? { profile } : {}),
+			...(region ? { clientConfig: { region } } : {}),
+		});
+	}
+
+	if (options.hasDirectCredentials) {
+		return undefined;
+	}
+
+	return region
+		? fromNodeProviderChain({ clientConfig: { region } })
+		: fromNodeProviderChain();
+}
+
+async function resolveBedrockApiKey(
+	config: GatewayResolvedProviderConfig,
+	options: { includeEnvironment: boolean },
+): Promise<string | undefined> {
+	const explicitApiKey =
+		readOptionalString(config.apiKey) ??
+		readOptionalString(config.options?.apiKey) ??
+		readOptionalString(config.options?.bedrockApiKey) ??
+		readOptionalString(config.options?.awsBedrockApiKey);
+	if (explicitApiKey) {
+		return explicitApiKey;
+	}
+
+	const resolvedApiKey = readOptionalString(await config.apiKeyResolver?.());
+	if (resolvedApiKey) {
+		return resolvedApiKey;
+	}
+
+	if (!options.includeEnvironment) {
+		return undefined;
+	}
+
+	for (const key of config.apiKeyEnv ?? []) {
+		if (NON_BEDROCK_API_KEY_ENV.has(key)) {
+			continue;
+		}
+		const value = readOptionalString(process.env[key]);
+		if (value) {
+			return value;
+		}
+	}
+
+	return readOptionalString(process.env.AWS_BEARER_TOKEN_BEDROCK);
+}
+
+function readAuthentication(value: unknown): BedrockAuthentication | undefined {
+	return value === "iam" ||
+		value === "api-key" ||
+		value === "apikey" ||
+		value === "profile"
+		? value
+		: undefined;
+}
+
+function readOptionalString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
diff --git a/sdk/packages/llms/src/providers/vendors/community.test.ts b/sdk/packages/llms/src/providers/vendors/community.test.ts
new file mode 100644
index 0000000..eb5469e
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/community.test.ts
@@ -0,0 +1,200 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { createSapAiCoreProviderModule } from "./community";
+
+const originalServiceKey = process.env.AICORE_SERVICE_KEY;
+
+function deferred() {
+	let resolve!: () => void;
+	const promise = new Promise<void>((resolvePromise) => {
+		resolve = resolvePromise;
+	});
+	return { promise, resolve };
+}
+
+describe("createSapAiCoreProviderModule", () => {
+	afterEach(() => {
+		if (originalServiceKey === undefined) {
+			delete process.env.AICORE_SERVICE_KEY;
+		} else {
+			process.env.AICORE_SERVICE_KEY = originalServiceKey;
+		}
+	});
+
+	it("uses SAP service-key credentials without mutating process env", async () => {
+		process.env.AICORE_SERVICE_KEY = "existing-service-key";
+
+		const provider = await createSapAiCoreProviderModule({
+			providerId: "sapaicore",
+			baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			options: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://auth.example/oauth/token",
+				deploymentId: "deployment-id",
+			},
+		});
+
+		const model = provider.model("anthropic--claude-4.6-sonnet") as {
+			config?: {
+				destination?: Record<string, unknown>;
+				deploymentConfig?: Record<string, unknown>;
+				providerApi?: string;
+			};
+		};
+
+		expect(process.env.AICORE_SERVICE_KEY).toBe("existing-service-key");
+		expect(model.config?.destination).toBeUndefined();
+		expect(model.config?.deploymentConfig).toMatchObject({
+			deploymentId: "deployment-id",
+		});
+		expect(model.config?.providerApi).toBe("orchestration");
+	});
+
+	it("sets SAP service-key credentials while model methods run", async () => {
+		process.env.AICORE_SERVICE_KEY = "existing-service-key";
+
+		const provider = await createSapAiCoreProviderModule({
+			providerId: "sapaicore",
+			baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com/",
+			options: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://auth.example/oauth/token",
+			},
+		});
+
+		const model = provider.model("anthropic--claude-4.6-sonnet") as {
+			doGenerate: () => Promise<string>;
+		};
+		let observedServiceKey: string | undefined;
+		model.doGenerate = async () => {
+			observedServiceKey = process.env.AICORE_SERVICE_KEY;
+			return "ok";
+		};
+
+		await expect(model.doGenerate()).resolves.toBe("ok");
+		expect(JSON.parse(observedServiceKey ?? "{}")).toMatchObject({
+			clientid: "sap-client",
+			clientsecret: "sap-secret",
+			serviceurls: {
+				AI_API_URL: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			},
+			url: "https://auth.example",
+		});
+		expect(process.env.AICORE_SERVICE_KEY).toBe("existing-service-key");
+	});
+
+	it("serializes concurrent SAP service-key model calls", async () => {
+		process.env.AICORE_SERVICE_KEY = "existing-service-key";
+
+		const firstProvider = await createSapAiCoreProviderModule({
+			providerId: "sapaicore",
+			baseUrl: "https://first.ai.example.aws.ml.hana.ondemand.com",
+			options: {
+				clientId: "first-client",
+				clientSecret: "first-secret",
+				tokenUrl: "https://first-auth.example",
+			},
+		});
+		const secondProvider = await createSapAiCoreProviderModule({
+			providerId: "sapaicore",
+			baseUrl: "https://second.ai.example.aws.ml.hana.ondemand.com",
+			options: {
+				clientId: "second-client",
+				clientSecret: "second-secret",
+				tokenUrl: "https://second-auth.example",
+			},
+		});
+
+		const firstModel = firstProvider.model("anthropic--claude-4.6-sonnet") as {
+			doGenerate: () => Promise<string>;
+		};
+		const secondModel = secondProvider.model(
+			"anthropic--claude-4.6-sonnet",
+		) as {
+			doGenerate: () => Promise<string>;
+		};
+		const firstStarted = deferred();
+		const releaseFirst = deferred();
+		let firstServiceKey: string | undefined;
+		let firstServiceKeyBeforeReturn: string | undefined;
+		let secondServiceKey: string | undefined;
+		let secondStarted = false;
+
+		firstModel.doGenerate = async () => {
+			firstServiceKey = process.env.AICORE_SERVICE_KEY;
+			firstStarted.resolve();
+			await releaseFirst.promise;
+			firstServiceKeyBeforeReturn = process.env.AICORE_SERVICE_KEY;
+			return "first";
+		};
+		secondModel.doGenerate = async () => {
+			secondStarted = true;
+			secondServiceKey = process.env.AICORE_SERVICE_KEY;
+			return "second";
+		};
+
+		const firstResult = firstModel.doGenerate();
+		await firstStarted.promise;
+		const secondResult = secondModel.doGenerate();
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(secondStarted).toBe(false);
+		expect(JSON.parse(firstServiceKey ?? "{}")).toMatchObject({
+			clientid: "first-client",
+		});
+
+		releaseFirst.resolve();
+		await expect(firstResult).resolves.toBe("first");
+		await expect(secondResult).resolves.toBe("second");
+
+		expect(JSON.parse(firstServiceKeyBeforeReturn ?? "{}")).toMatchObject({
+			clientid: "first-client",
+		});
+		expect(JSON.parse(secondServiceKey ?? "{}")).toMatchObject({
+			clientid: "second-client",
+		});
+		expect(process.env.AICORE_SERVICE_KEY).toBe("existing-service-key");
+	});
+
+	it("uses resource group deployment resolution for orchestration mode", async () => {
+		const provider = await createSapAiCoreProviderModule({
+			providerId: "sapaicore",
+			baseUrl: "https://api.ai.example.aws.ml.hana.ondemand.com",
+			options: {
+				clientId: "sap-client",
+				clientSecret: "sap-secret",
+				tokenUrl: "https://auth.example",
+				resourceGroup: "default",
+				useOrchestrationMode: true,
+			},
+		});
+
+		const model = provider.model("anthropic--claude-4.6-sonnet") as {
+			config?: {
+				deploymentConfig?: Record<string, unknown>;
+				providerApi?: string;
+			};
+		};
+
+		expect(model.config?.deploymentConfig).toMatchObject({
+			resourceGroup: "default",
+		});
+		expect(model.config?.deploymentConfig).not.toHaveProperty("deploymentId");
+		expect(model.config?.providerApi).toBe("orchestration");
+	});
+
+	it("fails fast for partial explicit SAP configuration", async () => {
+		await expect(
+			createSapAiCoreProviderModule({
+				providerId: "sapaicore",
+				options: {
+					clientId: "sap-client",
+					clientSecret: "sap-secret",
+					tokenUrl: "https://auth.example",
+				},
+			}),
+		).rejects.toThrow(/baseUrl/);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/vendors/community.ts b/sdk/packages/llms/src/providers/vendors/community.ts
new file mode 100644
index 0000000..f5df774
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/community.ts
@@ -0,0 +1,270 @@
+import type { GatewayResolvedProviderConfig } from "@cline/shared";
+// Keep this import static so the VS Code extension bundle includes the SAP
+// provider. Hiding it behind a computed dynamic import leaves the published
+// extension trying to load @jerome-benoit/sap-ai-provider from node_modules at
+// runtime, but VSIX packaging uses the bundled extension output.
+import { createSAPAIProvider } from "@jerome-benoit/sap-ai-provider";
+import { createClaudeCode } from "ai-sdk-provider-claude-code";
+import { createCodexExec } from "ai-sdk-provider-codex-cli";
+import { createDifyProvider } from "dify-ai-provider";
+import { resolveApiKey } from "../http";
+import type { ProviderFactoryResult } from "./types";
+
+type SapModel = Record<PropertyKey, unknown>;
+const SAP_SERVICE_KEY_METHODS = new Set<PropertyKey>([
+	"doGenerate",
+	"doStream",
+	"doEmbed",
+]);
+let sapServiceKeyQueue: Promise<void> = Promise.resolve();
+
+function readOptions(
+	config: GatewayResolvedProviderConfig,
+): Record<string, unknown> {
+	return (config.options as Record<string, unknown> | undefined) ?? {};
+}
+
+export async function createClaudeCodeProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	const provider = createClaudeCode(readOptions(config));
+	return {
+		model: (modelId) => provider(modelId),
+	};
+}
+
+export async function createOpenAICodexProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	const provider = createCodexExec(readOptions(config));
+	return {
+		model: (modelId) => provider(modelId),
+	};
+}
+
+// ai-sdk-provider-opencode-sdk registers process.once("SIGINT") and
+// process.once("SIGTERM") handlers that call process.exit() immediately.
+// Libraries must never hijack process lifecycle -- that is the host
+// application's responsibility. These handlers prevent host apps (like
+// Kanban) from performing graceful shutdown (e.g. persisting state,
+// cleaning up worktrees) because the opencode handler fires first and
+// force-exits the process.
+//
+// Workaround: snapshot listeners before provider creation, then remove
+// any new SIGINT/SIGTERM listeners the library added.
+//
+// TODO: remove once ai-sdk-provider-opencode-sdk stops calling
+// process.exit() from signal handlers.
+async function stripRogueSignalHandlers<T>(fn: () => Promise<T>): Promise<T> {
+	const signals = ["SIGINT", "SIGTERM"] as const;
+	const before = new Map(
+		signals.map((sig) => [sig, new Set(process.listeners(sig))]),
+	);
+	const result = await fn();
+	for (const sig of signals) {
+		for (const listener of process.listeners(sig)) {
+			if (!before.get(sig)?.has(listener)) {
+				process.removeListener(sig, listener);
+			}
+		}
+	}
+	return result;
+}
+
+export async function createOpenCodeProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	// Dynamic import is intentional: ai-sdk-provider-opencode-sdk runs
+	// `var opencode = createOpencode()` at module scope, which registers
+	// process.once("SIGINT") / process.once("SIGTERM") handlers that call
+	// process.exit(0). Importing it inside stripRogueSignalHandlers ensures
+	// both the module side effect and the explicit createOpencode() call are
+	// captured, so the rogue handlers get removed.
+	// TODO: switch back to a static import once the upstream package stops
+	// calling process.exit() from signal handlers.
+	const provider = await stripRogueSignalHandlers(async () => {
+		const { createOpencode } = await import("ai-sdk-provider-opencode-sdk");
+		return createOpencode(readOptions(config));
+	});
+	return {
+		model: (modelId) => provider(modelId),
+	};
+}
+
+export async function createDifyProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	const apiKey = await resolveApiKey(config);
+	const provider = createDifyProvider({
+		baseURL: config.baseUrl,
+		headers: config.headers,
+		fetch: config.fetch,
+		...readOptions(config),
+	});
+	return {
+		model: (modelId) =>
+			provider(modelId, {
+				apiKey,
+			}),
+	};
+}
+
+function readStringOption(
+	options: Record<string, unknown>,
+	key: string,
+): string | undefined {
+	const value = options[key];
+	return typeof value === "string" && value.trim().length > 0
+		? value.trim()
+		: undefined;
+}
+
+function normalizeSapTokenBaseUrl(tokenUrl: string): string {
+	const trimmed = tokenUrl.replace(/\/+$/, "");
+	return trimmed.replace(/\/oauth\/token$/i, "");
+}
+
+function hasExplicitSapConnectionConfig(
+	config: GatewayResolvedProviderConfig,
+	options: Record<string, unknown>,
+): boolean {
+	return Boolean(
+		config.apiKey?.trim() ||
+			config.baseUrl?.trim() ||
+			readStringOption(options, "clientId") ||
+			readStringOption(options, "clientSecret") ||
+			readStringOption(options, "tokenUrl"),
+	);
+}
+
+function buildSapServiceKey(
+	config: GatewayResolvedProviderConfig,
+	options: Record<string, unknown>,
+): string | undefined {
+	const clientId = readStringOption(options, "clientId");
+	const clientSecret =
+		readStringOption(options, "clientSecret") ?? config.apiKey?.trim();
+	const tokenUrl = readStringOption(options, "tokenUrl");
+	const baseUrl = config.baseUrl?.trim();
+	if (!clientId || !clientSecret || !tokenUrl || !baseUrl) {
+		if (!hasExplicitSapConnectionConfig(config, options)) {
+			return undefined;
+		}
+		const missing = [
+			!clientId ? "sap.clientId" : undefined,
+			!clientSecret ? "sap.clientSecret" : undefined,
+			!tokenUrl ? "sap.tokenUrl" : undefined,
+			!baseUrl ? "baseUrl" : undefined,
+		].filter(Boolean);
+		throw new Error(
+			`SAP AI Core provider is missing required configuration: ${missing.join(
+				", ",
+			)}.`,
+		);
+	}
+	return JSON.stringify({
+		clientid: clientId,
+		clientsecret: clientSecret,
+		serviceurls: {
+			AI_API_URL: baseUrl.replace(/\/+$/, ""),
+		},
+		url: normalizeSapTokenBaseUrl(tokenUrl),
+	});
+}
+
+function resolveSapApi(options: Record<string, unknown>) {
+	const api = options.api;
+	if (api === "orchestration" || api === "foundation-models") {
+		return api;
+	}
+	if (options.useOrchestrationMode === false) {
+		return "foundation-models";
+	}
+	return "orchestration";
+}
+
+async function withSapServiceKey<T>(
+	serviceKey: string | undefined,
+	fn: () => T,
+): Promise<Awaited<T>> {
+	if (!serviceKey) {
+		return await fn();
+	}
+
+	const previousQueue = sapServiceKeyQueue.catch(() => {});
+	let releaseQueue!: () => void;
+	sapServiceKeyQueue = new Promise<void>((resolve) => {
+		releaseQueue = resolve;
+	});
+
+	await previousQueue;
+	const previous = process.env.AICORE_SERVICE_KEY;
+	process.env.AICORE_SERVICE_KEY = serviceKey;
+	try {
+		return await fn();
+	} catch (error) {
+		throw error;
+	} finally {
+		restoreSapServiceKey(previous);
+		releaseQueue();
+	}
+}
+
+function shouldWrapSapServiceKeyMethod(property: PropertyKey): boolean {
+	return SAP_SERVICE_KEY_METHODS.has(property);
+}
+
+function restoreSapServiceKey(previous: string | undefined): void {
+	if (previous === undefined) {
+		delete process.env.AICORE_SERVICE_KEY;
+		return;
+	}
+	process.env.AICORE_SERVICE_KEY = previous;
+}
+
+function wrapSapModelWithServiceKey(
+	model: unknown,
+	serviceKey: string | undefined,
+): unknown {
+	if (!serviceKey || !model || typeof model !== "object") {
+		return model;
+	}
+	return new Proxy(model as SapModel, {
+		get(target, property, receiver) {
+			const value = Reflect.get(target, property, receiver);
+			if (
+				typeof value !== "function" ||
+				!shouldWrapSapServiceKeyMethod(property)
+			) {
+				return value;
+			}
+			return (...args: unknown[]) =>
+				withSapServiceKey(serviceKey, () => value.apply(target, args));
+		},
+	});
+}
+
+export async function createSapAiCoreProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	const options = readOptions(config);
+	const serviceKey = buildSapServiceKey(config, options);
+
+	const deploymentId = readStringOption(options, "deploymentId");
+	const provider = createSAPAIProvider({
+		name: config.providerId,
+		...(deploymentId
+			? { deploymentId }
+			: { resourceGroup: readStringOption(options, "resourceGroup") }),
+		api: resolveSapApi(options),
+		...(typeof options.defaultSettings === "object" &&
+		options.defaultSettings !== null &&
+		!Array.isArray(options.defaultSettings)
+			? { defaultSettings: options.defaultSettings }
+			: {}),
+	});
+	return {
+		model: (modelId) =>
+			wrapSapModelWithServiceKey(provider(modelId), serviceKey),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/google.ts b/sdk/packages/llms/src/providers/vendors/google.ts
new file mode 100644
index 0000000..787abd0
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/google.ts
@@ -0,0 +1,23 @@
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { resolveApiKey } from "../http";
+import type { ProviderFactoryResult } from "./types";
+
+export async function createGoogleProviderModule(
+	config: GatewayResolvedProviderConfig,
+	context: GatewayProviderContext,
+): Promise<ProviderFactoryResult> {
+	const apiKey = await resolveApiKey(config);
+	const provider = createGoogleGenerativeAI({
+		apiKey,
+		headers: config.headers,
+		fetch: config.fetch,
+		name: context.provider.id,
+	});
+	return {
+		model: (modelId) => provider(modelId),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/minimax-thinking.test.ts b/sdk/packages/llms/src/providers/vendors/minimax-thinking.test.ts
new file mode 100644
index 0000000..587a975
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/minimax-thinking.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	createMiniMaxThinkingFetch,
+	MINIMAX_THINKING_DISABLED_HEADER,
+	miniMaxThinkingDisabledMiddleware,
+} from "./minimax-thinking";
+
+describe("MiniMax thinking shim", () => {
+	it("preserves fetch preconnect when the runtime exposes it", () => {
+		const preconnect = vi.fn();
+		const baseFetch = Object.assign(
+			vi.fn(async () => new Response("{}")),
+			{
+				preconnect,
+			},
+		) as unknown as typeof fetch;
+
+		const wrappedFetch = createMiniMaxThinkingFetch(
+			baseFetch,
+		) as typeof fetch & {
+			preconnect?: (url: string) => void;
+		};
+		wrappedFetch.preconnect?.("https://api.minimax.io");
+
+		expect(preconnect).toHaveBeenCalledWith("https://api.minimax.io");
+	});
+
+	it("marks MiniMax requests whose provider options disable thinking", async () => {
+		const result = await miniMaxThinkingDisabledMiddleware.transformParams?.({
+			type: "stream",
+			model: {} as never,
+			params: {
+				providerOptions: {
+					minimax: { thinking: { type: "disabled" } },
+				},
+			} as never,
+		});
+
+		expect(result).toEqual(
+			expect.objectContaining({
+				headers: expect.objectContaining({
+					[MINIMAX_THINKING_DISABLED_HEADER]: "1",
+				}),
+			}),
+		);
+	});
+
+	it("injects explicit disabled thinking and strips the private marker header", async () => {
+		const baseFetch = vi.fn(async () => new Response("{}"));
+		const wrappedFetch = createMiniMaxThinkingFetch(baseFetch);
+
+		await wrappedFetch("https://api.minimax.io/anthropic/v1/messages", {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				[MINIMAX_THINKING_DISABLED_HEADER]: "1",
+			},
+			body: JSON.stringify({
+				model: "MiniMax-M3",
+				messages: [],
+			}),
+		});
+
+		const init = baseFetch.mock.calls[0]?.[1];
+		expect(
+			new Headers(init?.headers).has(MINIMAX_THINKING_DISABLED_HEADER),
+		).toBe(false);
+		expect(JSON.parse(String(init?.body))).toEqual(
+			expect.objectContaining({
+				thinking: { type: "disabled" },
+			}),
+		);
+	});
+});
diff --git a/sdk/packages/llms/src/providers/vendors/minimax-thinking.ts b/sdk/packages/llms/src/providers/vendors/minimax-thinking.ts
new file mode 100644
index 0000000..856792b
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/minimax-thinking.ts
@@ -0,0 +1,103 @@
+import type {
+	LanguageModelV3CallOptions,
+	LanguageModelV3Middleware,
+} from "@ai-sdk/provider";
+
+export const MINIMAX_THINKING_DISABLED_HEADER =
+	"x-cline-minimax-thinking-disabled";
+
+type FetchWithOptionalPreconnect = typeof fetch & {
+	preconnect?: (...args: unknown[]) => unknown;
+};
+
+function getMiniMaxThinkingType(providerOptions: unknown): string | undefined {
+	const options =
+		providerOptions && typeof providerOptions === "object"
+			? (providerOptions as Record<string, unknown>)
+			: {};
+	const minimax =
+		options.minimax && typeof options.minimax === "object"
+			? (options.minimax as Record<string, unknown>)
+			: undefined;
+	const thinking =
+		minimax?.thinking && typeof minimax.thinking === "object"
+			? (minimax.thinking as Record<string, unknown>)
+			: undefined;
+	return typeof thinking?.type === "string" ? thinking.type : undefined;
+}
+
+export const miniMaxThinkingDisabledMiddleware: LanguageModelV3Middleware = {
+	specificationVersion: "v3",
+	transformParams: async ({ params }) => {
+		if (getMiniMaxThinkingType(params.providerOptions) !== "disabled") {
+			return params;
+		}
+
+		return {
+			...params,
+			headers: {
+				...params.headers,
+				[MINIMAX_THINKING_DISABLED_HEADER]: "1",
+			},
+		} satisfies LanguageModelV3CallOptions;
+	},
+};
+
+async function readBody(
+	body: NonNullable<Parameters<typeof fetch>[1]>["body"],
+): Promise<unknown> {
+	if (typeof body === "string") {
+		return JSON.parse(body) as unknown;
+	}
+	if (body instanceof Uint8Array) {
+		return JSON.parse(new TextDecoder().decode(body)) as unknown;
+	}
+	if (body instanceof ArrayBuffer) {
+		return JSON.parse(new TextDecoder().decode(body)) as unknown;
+	}
+	return undefined;
+}
+
+function writeBody(body: unknown): string {
+	return JSON.stringify(body);
+}
+
+export function createMiniMaxThinkingFetch(baseFetch: typeof fetch = fetch) {
+	const wrappedFetch = (async (
+		input: Parameters<typeof fetch>[0],
+		init?: Parameters<typeof fetch>[1],
+	) => {
+		const headers = new Headers(init?.headers);
+		const shouldInject = headers.get(MINIMAX_THINKING_DISABLED_HEADER) === "1";
+		if (!shouldInject) {
+			return baseFetch(input, init);
+		}
+
+		headers.delete(MINIMAX_THINKING_DISABLED_HEADER);
+		const body = await readBody(init?.body);
+		const bodyRecord =
+			body && typeof body === "object" && !Array.isArray(body)
+				? (body as Record<string, unknown>)
+				: undefined;
+		const nextBody =
+			bodyRecord && bodyRecord.thinking === undefined
+				? writeBody({
+						...bodyRecord,
+						thinking: { type: "disabled" },
+					})
+				: init?.body;
+
+		return baseFetch(input, {
+			...init,
+			headers,
+			body: nextBody,
+		});
+	}) as typeof fetch;
+	const sourceFetch = baseFetch as FetchWithOptionalPreconnect;
+	(wrappedFetch as FetchWithOptionalPreconnect).preconnect =
+		typeof sourceFetch.preconnect === "function"
+			? sourceFetch.preconnect.bind(baseFetch)
+			: () => {};
+
+	return wrappedFetch;
+}
diff --git a/sdk/packages/llms/src/providers/vendors/mistral.ts b/sdk/packages/llms/src/providers/vendors/mistral.ts
new file mode 100644
index 0000000..1d37e27
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/mistral.ts
@@ -0,0 +1,31 @@
+import { createMistral } from "@ai-sdk/mistral";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { GatewayResolvedProviderConfig } from "@cline/shared";
+import { wrapLanguageModel } from "ai";
+import { resolveApiKey } from "../http";
+import { splitToolImagesMiddleware } from "../middleware/split-tool-images";
+import type { ProviderFactoryResult } from "./types";
+
+export async function createMistralProviderModule(
+	config: GatewayResolvedProviderConfig,
+): Promise<ProviderFactoryResult> {
+	const provider = createMistral({
+		apiKey: await resolveApiKey(config),
+		baseURL: config.baseUrl,
+		headers: config.headers,
+		fetch: config.fetch,
+	});
+	return {
+		// Mistral's chat-messages converter has the same multimodal-tool-message
+		// limitation as `@ai-sdk/openai-compatible`: `role:"tool"` content must
+		// be a single string, so a `ToolResultOutput` of type `'content'` with
+		// image-data parts loses the bytes when serialised. Wrap with
+		// `splitToolImagesMiddleware` to rewrite the typed prompt before the
+		// converter runs. See `middleware/split-tool-images.ts`.
+		model: (modelId) =>
+			wrapLanguageModel({
+				model: provider(modelId) as LanguageModelV3,
+				middleware: splitToolImagesMiddleware,
+			}),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/openai-compatible.ts b/sdk/packages/llms/src/providers/vendors/openai-compatible.ts
new file mode 100644
index 0000000..1b84a32
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/openai-compatible.ts
@@ -0,0 +1,152 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { wrapLanguageModel } from "ai";
+import { ensureFetch, resolveApiKey } from "../http";
+import { splitToolImagesMiddleware } from "../middleware/split-tool-images";
+import type { ProviderFactoryResult } from "./types";
+
+type FetchInput = Parameters<typeof fetch>[0];
+type FetchWithOptionalPreconnect = typeof fetch & {
+	preconnect?: (...args: unknown[]) => unknown;
+};
+
+function readAzureApiVersion(
+	config: GatewayResolvedProviderConfig,
+): string | undefined {
+	const apiVersion = config.options?.apiVersion;
+	if (typeof apiVersion !== "string") {
+		return undefined;
+	}
+	const trimmed = apiVersion.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function shouldAddAzureApiVersion(url: URL): boolean {
+	return (
+		url.pathname.startsWith("/openai/deployments/") &&
+		!url.searchParams.has("api-version")
+	);
+}
+
+function withAzureApiVersion(
+	input: FetchInput,
+	apiVersion: string,
+): FetchInput {
+	let url: URL;
+	try {
+		url = new URL(input instanceof Request ? input.url : input.toString());
+	} catch {
+		return input;
+	}
+	if (!shouldAddAzureApiVersion(url)) {
+		return input;
+	}
+	url.searchParams.set("api-version", apiVersion);
+	if (input instanceof Request) {
+		return new Request(url.toString(), input);
+	}
+	return (typeof input === "string" ? url.toString() : url) as FetchInput;
+}
+
+function createAzureApiVersionFetch(
+	config: GatewayResolvedProviderConfig,
+): typeof fetch | undefined {
+	const apiVersion = readAzureApiVersion(config);
+	if (!apiVersion) {
+		return config.fetch;
+	}
+	const baseFetch = config.fetch ?? globalThis.fetch;
+	if (!baseFetch) {
+		return config.fetch;
+	}
+	const azureFetch = ((input, init) =>
+		baseFetch(withAzureApiVersion(input, apiVersion), init)) as typeof fetch;
+	const baseFetchWithPreconnect = baseFetch as FetchWithOptionalPreconnect;
+	(azureFetch as FetchWithOptionalPreconnect).preconnect =
+		typeof baseFetchWithPreconnect.preconnect === "function"
+			? baseFetchWithPreconnect.preconnect.bind(baseFetch)
+			: () => undefined;
+	return azureFetch;
+}
+
+type ResponseErrorHandler = (response: Response) => Promise<void> | void;
+
+function readResponseErrorHandler(
+	config: GatewayResolvedProviderConfig,
+): ResponseErrorHandler | undefined {
+	const handler = config.options?.onResponseError;
+	return typeof handler === "function"
+		? (handler as ResponseErrorHandler)
+		: undefined;
+}
+
+function createResponseErrorFetch(input: {
+	fetch: typeof fetch;
+	onResponseError: ResponseErrorHandler;
+}): typeof fetch {
+	const responseErrorFetch = (async (requestInput, init) => {
+		const response = await input.fetch(requestInput, init);
+
+		await input.onResponseError(response);
+
+		return response;
+	}) as typeof fetch;
+
+	const baseFetchWithPreconnect = input.fetch as FetchWithOptionalPreconnect;
+	(responseErrorFetch as FetchWithOptionalPreconnect).preconnect =
+		typeof baseFetchWithPreconnect.preconnect === "function"
+			? baseFetchWithPreconnect.preconnect.bind(input.fetch)
+			: () => undefined;
+	return responseErrorFetch;
+}
+
+export async function createOpenAICompatibleProviderModule(
+	config: GatewayResolvedProviderConfig,
+	context: GatewayProviderContext,
+): Promise<ProviderFactoryResult> {
+	// Don't preflight-check for a missing API key. If credentials are
+	// missing or wrong, the provider's own response (e.g. 401) is the
+	// authoritative error and is surfaced to the user as-is. This keeps
+	// `llms` unopinionated about which providers do or don't need a key.
+	const apiKey = await resolveApiKey(config);
+	const fetch = createAzureApiVersionFetch(config);
+	const onResponseError = readResponseErrorHandler(config);
+	const providerFetch = onResponseError
+		? createResponseErrorFetch({
+				fetch: ensureFetch(fetch),
+				onResponseError,
+			})
+		: fetch;
+	const provider = createOpenAICompatible({
+		name: context.provider.id,
+		apiKey,
+		...(config.baseUrl ? { baseURL: config.baseUrl } : {}),
+		...(config.headers ? { headers: config.headers } : {}),
+		...(providerFetch ? { fetch: providerFetch } : {}),
+		includeUsage: true,
+	} as never);
+	return {
+		// Wrap each constructed model with `splitToolImagesMiddleware` so
+		// `role:"tool"` messages whose `output.type === 'content'` carries
+		// image-data parts get split into a placeholder text + a synthetic
+		// `role:"user"` message carrying the images. The OpenAI Chat
+		// Completions wire format does NOT support multimodal tool messages
+		// (the `@ai-sdk/openai-compatible` chat-messages converter
+		// `JSON.stringify`s the parts array, losing image bytes). The
+		// middleware operates on the typed `LanguageModelV3Prompt` BEFORE
+		// the converter runs, so the converter sees only text-only tool
+		// messages with adjacent multimodal user messages — the wire
+		// pattern that classic Cline used in production for years (see
+		// `convertToOpenAiMessages` in `src/core/api/transform/openai-format.ts`
+		// on origin/main).
+		model: (modelId) =>
+			wrapLanguageModel({
+				model: provider(modelId) as LanguageModelV3,
+				middleware: splitToolImagesMiddleware,
+			}),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/openai.ts b/sdk/packages/llms/src/providers/vendors/openai.ts
new file mode 100644
index 0000000..e954dd3
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/openai.ts
@@ -0,0 +1,24 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { resolveApiKey } from "../http";
+import type { ProviderFactoryResult } from "./types";
+
+export async function createOpenAIProviderModule(
+	config: GatewayResolvedProviderConfig,
+	context: GatewayProviderContext,
+): Promise<ProviderFactoryResult> {
+	const apiKey = await resolveApiKey(config);
+	const provider = createOpenAI({
+		apiKey,
+		baseURL: config.baseUrl,
+		headers: config.headers,
+		fetch: config.fetch,
+		name: context.provider.id,
+	});
+	return {
+		model: (modelId) => provider.responses(modelId),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/types.ts b/sdk/packages/llms/src/providers/vendors/types.ts
new file mode 100644
index 0000000..757c5d6
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/types.ts
@@ -0,0 +1,141 @@
+export interface ProviderFactoryResult {
+	model: (modelId: string) => unknown;
+}
+
+export interface AiSdkStreamPart {
+	type?: string;
+	[key: string]: unknown;
+}
+
+/**
+ * AI SDK's normalized usage structure emitted in the finish stream part.
+ * This is the intermediate representation available before stream completion.
+ * All token counts use camelCase naming convention.
+ *
+ * @property inputTokens - Total input/prompt tokens (all providers)
+ * @property inputTokenDetails - Breakdown of input tokens:
+ *   - noCacheTokens: Fresh (non-cached) input tokens (Anthropic, OpenRouter, Gemini)
+ *   - cacheReadTokens: Tokens read from cache (Anthropic, OpenRouter)
+ *   - cacheWriteTokens: Tokens written to cache (Anthropic, OpenRouter)
+ * @property outputTokens - Total output/completion tokens (all providers)
+ * @property outputTokenDetails - Breakdown of output tokens:
+ *   - textTokens: Regular text tokens (OpenAI, OpenRouter, Gemini)
+ *   - reasoningTokens: Tokens used for reasoning (OpenAI with o1, OpenRouter, Anthropic with extended thinking)
+ * @property totalTokens - Sum of input and output tokens (all providers)
+ * @property reasoningTokens - Total reasoning tokens (OpenAI, OpenRouter)
+ * @property cachedInputTokens - Alias for cache-read tokens (convenience field)
+ */
+export interface AiSdkStreamTotalUsage {
+	inputTokens?: number;
+	inputTokenDetails?: {
+		noCacheTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+	};
+	outputTokens?: number;
+	outputTokenDetails?: {
+		textTokens?: number;
+		reasoningTokens?: number;
+	};
+	totalTokens?: number;
+	reasoningTokens?: number;
+	cachedInputTokens?: number;
+}
+
+/**
+ * AI SDK's complete usage structure available via stream.usage promise after completion.
+ * Extends AiSdkStreamTotalUsage and adds the raw provider-specific response.
+ * The raw field contains unmodified provider responses, enabling cost extraction and detailed billing info.
+ *
+ * @property raw - Provider-specific raw response fields:
+ *   **Anthropic**: input_tokens, cache_creation_input_tokens, cache_read_input_tokens,
+ *     cache_creation.ephemeral_5m_input_tokens, cache_creation.ephemeral_1h_input_tokens,
+ *     output_tokens, service_tier, inference_geo
+ *   **Gemini**: promptTokenCount, candidatesTokenCount, totalTokenCount, promptTokensDetails
+ *   **OpenAI/Vercel**: input_tokens, input_tokens_details.cached_tokens, output_tokens,
+ *     output_tokens_details.reasoning_tokens
+ *   **OpenRouter**: prompt_tokens, completion_tokens, total_tokens, prompt_tokens_details.cached_tokens,
+ *     completion_tokens_details.reasoning_tokens, cost, is_byok, cost_details, market_cost
+ */
+export interface AiSdkStreamUsage extends AiSdkStreamTotalUsage {
+	raw?: {
+		input_tokens?: number;
+		cache_creation_input_tokens?: number;
+		cache_read_input_tokens?: number;
+		cache_creation?: {
+			ephemeral_5m_input_tokens?: number;
+			ephemeral_1h_input_tokens?: number;
+		};
+		input_tokens_details?: {
+			cached_tokens?: number;
+			cache_write_tokens?: number;
+		};
+		output_tokens?: number;
+		output_tokens_details?: {
+			reasoning_tokens?: number;
+		};
+		service_tier?: string;
+		inference_geo?: string;
+		promptTokenCount?: number;
+		candidatesTokenCount?: number;
+		totalTokenCount?: number;
+		promptTokensDetails?: {
+			cached_tokens?: number;
+			cache_write_tokens?: number;
+		};
+		prompt_tokens?: number;
+		completion_tokens?: number;
+		total_tokens?: number;
+		prompt_tokens_details?: {
+			cached_tokens?: number;
+			cache_write_tokens?: number;
+		};
+		completion_tokens_details?: {
+			reasoning_tokens?: number;
+		};
+		cost?: number;
+		is_byok?: boolean;
+		cost_details?: {
+			upstream_inference_cost?: number | null;
+			upstream_inference_prompt_cost?: number;
+			upstream_inference_completions_cost?: number;
+		};
+		market_cost?: number;
+	};
+	reasoningTokens?: number;
+	cachedInputTokens?: number;
+}
+
+/**
+ * Finish event part emitted when streaming completes.
+ * Contains early usage data (without raw provider response) and finish metadata.
+ *
+ * @property type - Always "finish"
+ * @property finishReason - Normalized finish reason (stop, max_tokens, tool-calls, error)
+ * @property rawFinishReason - Provider's original finish reason string
+ * @property totalUsage - Usage snapshot at end of stream (AiSdkStreamTotalUsage structure)
+ */
+export interface AiSdkStreamFinishPart {
+	type: "finish";
+	finishReason?: string;
+	rawFinishReason?: string;
+	totalUsage?: AiSdkStreamTotalUsage | Record<string, unknown>;
+}
+
+/**
+ * Complete result from AI SDK's streamText() call.
+ * Provides both streaming content (text, tool-calls, reasoning) and usage data via promises.
+ *
+ * @property fullStream - Raw stream parts (text-delta, tool-call, finish, etc.)
+ * @property textStream - Convenience iterator for just text deltas
+ * @property text - Promise that resolves to complete generated text
+ * @property usage - Promise that resolves to complete usage data with raw provider response.
+ *   This is preferred over the finish part's totalUsage because it includes cost_details
+ *   and other provider-specific metadata needed for accurate billing.
+ */
+export interface AiSdkStreamResult {
+	fullStream?: AsyncIterable<AiSdkStreamPart>;
+	textStream?: AsyncIterable<string>;
+	text?: Promise<string> | string;
+	usage?: Promise<AiSdkStreamUsage | Record<string, unknown>>;
+}
diff --git a/sdk/packages/llms/src/providers/vendors/vertex.test.ts b/sdk/packages/llms/src/providers/vendors/vertex.test.ts
new file mode 100644
index 0000000..f6a19bc
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/vertex.test.ts
@@ -0,0 +1,149 @@
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createVertexProviderModule } from "./vertex";
+
+const createVertexMock = vi.hoisted(() => vi.fn());
+const createVertexAnthropicMock = vi.hoisted(() => vi.fn());
+const vertexModelMock = vi.hoisted(() =>
+	vi.fn((modelId: string) => ({ provider: "vertex", modelId })),
+);
+const vertexAnthropicModelMock = vi.hoisted(() =>
+	vi.fn((modelId: string) => ({ provider: "vertex-anthropic", modelId })),
+);
+
+vi.mock("@ai-sdk/google-vertex", () => ({
+	createVertex: createVertexMock,
+}));
+
+vi.mock("@ai-sdk/google-vertex/anthropic", () => ({
+	createVertexAnthropic: createVertexAnthropicMock,
+}));
+
+describe("createVertexProviderModule", () => {
+	beforeEach(() => {
+		createVertexMock.mockReset();
+		createVertexMock.mockReturnValue(vertexModelMock);
+		createVertexAnthropicMock.mockReset();
+		createVertexAnthropicMock.mockReturnValue(vertexAnthropicModelMock);
+		vertexModelMock.mockClear();
+		vertexAnthropicModelMock.mockClear();
+	});
+
+	it("passes providerConfig.gcp project settings as googleAuthOptions for Gemini models", async () => {
+		await createVertexProviderModule(
+			config({
+				apiKey: "api-key-should-not-enable-express-mode",
+				options: {
+					project: "test-project",
+					projectId: "test-project",
+					location: "global",
+					region: "global",
+				},
+			}),
+			context("gemini-3-flash-preview"),
+		);
+
+		expect(createVertexMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				project: "test-project",
+				location: "global",
+				apiKey: undefined,
+				googleAuthOptions: {
+					projectId: "test-project",
+				},
+				fetch: expect.any(Function),
+			}),
+		);
+		expect(createVertexAnthropicMock).not.toHaveBeenCalled();
+	});
+
+	it("accepts nested gcp project and region options", async () => {
+		await createVertexProviderModule(
+			config({
+				options: {
+					gcp: {
+						projectId: "nested-project",
+						region: "europe-west4",
+					},
+				},
+			}),
+			context("gemini-3-flash-preview"),
+		);
+
+		expect(createVertexMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				project: "nested-project",
+				location: "europe-west4",
+				googleAuthOptions: {
+					projectId: "nested-project",
+				},
+			}),
+		);
+	});
+
+	it("keeps API-key express mode when Gemini config has no GCP settings", async () => {
+		await createVertexProviderModule(
+			config({
+				apiKey: "vertex-api-key",
+			}),
+			context("gemini-3-flash-preview"),
+		);
+
+		expect(createVertexMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "vertex-api-key",
+				googleAuthOptions: undefined,
+				fetch: expect.any(Function),
+			}),
+		);
+	});
+
+	it("continues routing Claude models through Vertex Anthropic", async () => {
+		await createVertexProviderModule(
+			config({
+				options: {
+					project: "test-project",
+					location: "us-east5",
+				},
+			}),
+			context("claude-sonnet-4-5@20250929"),
+		);
+
+		expect(createVertexAnthropicMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				project: "test-project",
+				location: "us-east5",
+			}),
+		);
+		expect(createVertexMock).not.toHaveBeenCalled();
+	});
+});
+
+function config(
+	overrides: Partial<GatewayResolvedProviderConfig>,
+): GatewayResolvedProviderConfig {
+	return {
+		providerId: "vertex",
+		...overrides,
+	};
+}
+
+function context(modelId: string): GatewayProviderContext {
+	return {
+		provider: {
+			id: "vertex",
+			name: "Google Vertex AI",
+			defaultModelId: modelId,
+			models: [],
+		},
+		model: {
+			providerId: "vertex",
+			id: modelId,
+			name: modelId,
+		},
+		config: config({}),
+	};
+}
diff --git a/sdk/packages/llms/src/providers/vendors/vertex.ts b/sdk/packages/llms/src/providers/vendors/vertex.ts
new file mode 100644
index 0000000..d34e865
--- /dev/null
+++ b/sdk/packages/llms/src/providers/vendors/vertex.ts
@@ -0,0 +1,80 @@
+import { createVertex } from "@ai-sdk/google-vertex";
+import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic";
+import type {
+	GatewayProviderContext,
+	GatewayResolvedProviderConfig,
+} from "@cline/shared";
+import { ensureFetch, resolveApiKey } from "../http";
+import { isClaudeModelId } from "../model-facts";
+import type { ProviderFactoryResult } from "./types";
+
+function readStringOption(
+	options: Record<string, unknown> | undefined,
+	key: string,
+): string | undefined {
+	const value = options?.[key];
+	return typeof value === "string" && value.trim().length > 0
+		? value
+		: undefined;
+}
+
+function readNestedStringOption(
+	options: Record<string, unknown> | undefined,
+	objectKey: string,
+	key: string,
+): string | undefined {
+	const object = options?.[objectKey];
+	if (!object || typeof object !== "object" || Array.isArray(object)) {
+		return undefined;
+	}
+	const value = (object as Record<string, unknown>)[key];
+	return typeof value === "string" && value.trim().length > 0
+		? value
+		: undefined;
+}
+
+export async function createVertexProviderModule(
+	config: GatewayResolvedProviderConfig,
+	context: GatewayProviderContext,
+): Promise<ProviderFactoryResult> {
+	const project =
+		readStringOption(config.options, "project") ??
+		readStringOption(config.options, "projectId") ??
+		readNestedStringOption(config.options, "gcp", "projectId") ??
+		"";
+	const location =
+		readStringOption(config.options, "location") ??
+		readStringOption(config.options, "region") ??
+		readNestedStringOption(config.options, "gcp", "region") ??
+		"us-central1";
+	const googleAuthProjectId = project || undefined;
+	const fetch = ensureFetch(config.fetch);
+
+	if (isClaudeModelId(context.model.id)) {
+		const provider = createVertexAnthropic({
+			project,
+			location,
+			baseURL: config.baseUrl,
+			headers: config.headers,
+			fetch,
+		});
+		return { model: (modelId) => provider(modelId) };
+	}
+
+	const provider = createVertex({
+		project,
+		location,
+		apiKey: googleAuthProjectId ? undefined : await resolveApiKey(config),
+		googleAuthOptions: googleAuthProjectId
+			? {
+					projectId: googleAuthProjectId,
+				}
+			: undefined,
+		baseURL: config.baseUrl,
+		headers: config.headers,
+		fetch,
+	});
+	return {
+		model: (modelId) => provider(modelId),
+	};
+}
diff --git a/sdk/packages/llms/src/services/langfuse-telemetry.test.ts b/sdk/packages/llms/src/services/langfuse-telemetry.test.ts
new file mode 100644
index 0000000..37a98e5
--- /dev/null
+++ b/sdk/packages/llms/src/services/langfuse-telemetry.test.ts
@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { registerDisposableSpy } = vi.hoisted(() => ({
+	registerDisposableSpy: vi.fn(),
+}));
+
+const { addSpanProcessorSpy, forceFlushSpy, shutdownSpy, getDelegateSpy } =
+	vi.hoisted(() => ({
+		addSpanProcessorSpy: vi.fn(),
+		forceFlushSpy: vi.fn(async () => undefined),
+		shutdownSpy: vi.fn(async () => undefined),
+		getDelegateSpy: vi.fn(),
+	}));
+
+class MockNodeTracerProvider {
+	register = vi.fn();
+}
+
+vi.mock("@cline/shared", () => ({
+	registerDisposable: registerDisposableSpy,
+}));
+
+vi.mock("@langfuse/otel", () => ({
+	LangfuseSpanProcessor: class MockLangfuseSpanProcessor {},
+}));
+
+vi.mock("@opentelemetry/api", () => ({
+	trace: {
+		getTracerProvider: () => ({
+			addSpanProcessor: addSpanProcessorSpy,
+			getDelegate: getDelegateSpy,
+		}),
+	},
+}));
+
+vi.mock("@opentelemetry/sdk-trace-node", () => ({
+	NodeTracerProvider: MockNodeTracerProvider,
+}));
+
+import {
+	disposeLangfuseTelemetry,
+	ensureLangfuseTelemetry,
+	resetLangfuseTelemetryForTests,
+} from "./langfuse-telemetry";
+
+describe("langfuse telemetry", () => {
+	beforeEach(() => {
+		resetLangfuseTelemetryForTests();
+		registerDisposableSpy.mockReset();
+		addSpanProcessorSpy.mockReset();
+		forceFlushSpy.mockReset();
+		forceFlushSpy.mockResolvedValue(undefined);
+		shutdownSpy.mockReset();
+		shutdownSpy.mockResolvedValue(undefined);
+		getDelegateSpy.mockReset();
+		getDelegateSpy.mockReturnValue({
+			constructor: { name: "NodeTracerProvider" },
+			forceFlush: forceFlushSpy,
+			shutdown: shutdownSpy,
+		});
+		process.env.LANGFUSE_BASE_URL = "https://langfuse.example";
+		process.env.LANGFUSE_PUBLIC_KEY = "public-key";
+		process.env.LANGFUSE_SECRET_KEY = "secret-key";
+	});
+
+	afterEach(() => {
+		delete process.env.LANGFUSE_BASE_URL;
+		delete process.env.LANGFUSE_PUBLIC_KEY;
+		delete process.env.LANGFUSE_SECRET_KEY;
+		resetLangfuseTelemetryForTests();
+	});
+
+	it("enables telemetry for non-cline providers when langfuse config is available", async () => {
+		await expect(ensureLangfuseTelemetry("openrouter")).resolves.toBe(true);
+		await expect(ensureLangfuseTelemetry("cline")).resolves.toBe(true);
+
+		expect(registerDisposableSpy).toHaveBeenCalledTimes(1);
+		expect(addSpanProcessorSpy).toHaveBeenCalledTimes(1);
+	});
+
+	it("flushes before shutdown during disposal", async () => {
+		await disposeLangfuseTelemetry();
+
+		expect(forceFlushSpy).toHaveBeenCalledTimes(1);
+		expect(shutdownSpy).toHaveBeenCalledTimes(1);
+		expect(forceFlushSpy.mock.invocationCallOrder[0]).toBeLessThan(
+			shutdownSpy.mock.invocationCallOrder[0],
+		);
+	});
+});
diff --git a/sdk/packages/llms/src/services/langfuse-telemetry.ts b/sdk/packages/llms/src/services/langfuse-telemetry.ts
new file mode 100644
index 0000000..9b36cf2
--- /dev/null
+++ b/sdk/packages/llms/src/services/langfuse-telemetry.ts
@@ -0,0 +1,187 @@
+type MutableTracerProvider = {
+	addSpanProcessor?: (spanProcessor: unknown) => void;
+	constructor?: {
+		name?: string;
+	};
+};
+
+type LangfuseTelemetryConfig = {
+	baseUrl: string;
+	publicKey: string;
+	secretKey: string;
+};
+
+const LANGFUSE_DEBUG_ENV = "CLINE_DEBUG_LANGFUSE";
+
+let langfuseTelemetryReady: boolean | undefined;
+let langfuseTelemetryInitPromise: Promise<boolean> | undefined;
+
+function readLangfuseTelemetryConfig(): LangfuseTelemetryConfig | undefined {
+	const env = process?.env;
+	const baseUrl = env?.LANGFUSE_BASE_URL?.trim();
+	const publicKey = env?.LANGFUSE_PUBLIC_KEY?.trim();
+	const secretKey = env?.LANGFUSE_SECRET_KEY?.trim();
+
+	if (!baseUrl || !publicKey || !secretKey) {
+		return undefined;
+	}
+
+	return {
+		baseUrl,
+		publicKey,
+		secretKey,
+	};
+}
+
+export function hasLangfuseTelemetryConfig(): boolean {
+	return readLangfuseTelemetryConfig() !== undefined;
+}
+
+export async function ensureLangfuseTelemetry(
+	_providerId: string,
+): Promise<boolean> {
+	if (!hasLangfuseTelemetryConfig()) {
+		return false;
+	}
+
+	if (langfuseTelemetryReady !== undefined) {
+		debugLangfuse(`cached readiness=${String(langfuseTelemetryReady)}`);
+		return langfuseTelemetryReady;
+	}
+
+	if (!langfuseTelemetryInitPromise) {
+		langfuseTelemetryInitPromise = initializeLangfuseTelemetry();
+	}
+
+	langfuseTelemetryReady = await langfuseTelemetryInitPromise;
+	debugLangfuse(`initialized readiness=${String(langfuseTelemetryReady)}`);
+	return langfuseTelemetryReady;
+}
+
+async function initializeLangfuseTelemetry(): Promise<boolean> {
+	// Register for cleanup once, when initialization begins.
+	const { registerDisposable } = await import("@cline/shared");
+	registerDisposable(disposeLangfuseTelemetry);
+	const config = readLangfuseTelemetryConfig();
+	if (!config) {
+		return false;
+	}
+
+	try {
+		const [{ LangfuseSpanProcessor }, { trace }, { NodeTracerProvider }] =
+			await Promise.all([
+				import("@langfuse/otel"),
+				import("@opentelemetry/api"),
+				import("@opentelemetry/sdk-trace-node"),
+			]);
+
+		const spanProcessor = new LangfuseSpanProcessor({
+			baseUrl: config.baseUrl,
+			publicKey: config.publicKey,
+			secretKey: config.secretKey,
+		});
+		debugLangfuse(`creating span processor baseUrl=${config.baseUrl}`);
+
+		const tracerProvider = trace.getTracerProvider() as MutableTracerProvider;
+		if (typeof tracerProvider?.addSpanProcessor === "function") {
+			tracerProvider.addSpanProcessor(spanProcessor);
+			const hasDelegate = hasActiveTracerDelegate(trace);
+			debugLangfuse(
+				`attached processor to existing tracer provider delegateReady=${String(hasDelegate)}`,
+			);
+			return hasDelegate;
+		}
+
+		const providerName = tracerProvider?.constructor?.name;
+		if (
+			providerName &&
+			providerName !== "ProxyTracerProvider" &&
+			providerName !== "NoopTracerProvider"
+		) {
+			return false;
+		}
+
+		const nodeTracerProvider = new NodeTracerProvider({
+			spanProcessors: [spanProcessor],
+		} as unknown as ConstructorParameters<typeof NodeTracerProvider>[0]);
+		nodeTracerProvider.register();
+		const hasDelegate = hasActiveTracerDelegate(trace);
+		debugLangfuse(
+			`registered NodeTracerProvider delegateReady=${String(hasDelegate)}`,
+		);
+		return hasDelegate;
+	} catch (error) {
+		debugLangfuse(
+			`initialization failed error=${error instanceof Error ? error.message : String(error)}`,
+		);
+		return false;
+	}
+}
+
+function hasActiveTracerDelegate(traceApi: {
+	getTracerProvider: () => unknown;
+}): boolean {
+	const tracerProvider = traceApi.getTracerProvider() as {
+		getDelegate?: () => { constructor?: { name?: string } };
+	};
+	const delegate = tracerProvider.getDelegate?.();
+	const delegateName = delegate?.constructor?.name;
+
+	return Boolean(delegateName && delegateName !== "NoopTracerProvider");
+}
+
+async function flushLangfuseTelemetry(): Promise<void> {
+	try {
+		const { trace } = await import("@opentelemetry/api");
+		const tracerProvider = trace.getTracerProvider() as {
+			getDelegate?: () => {
+				forceFlush?: () => Promise<void>;
+			};
+		};
+		await tracerProvider.getDelegate?.()?.forceFlush?.();
+		debugLangfuse("forceFlush completed");
+	} catch (error) {
+		debugLangfuse(
+			`forceFlush failed error=${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+}
+
+export async function disposeLangfuseTelemetry(): Promise<void> {
+	try {
+		await flushLangfuseTelemetry();
+		const { trace } = await import("@opentelemetry/api");
+		const tracerProvider = trace.getTracerProvider() as {
+			getDelegate?: () => {
+				shutdown?: () => Promise<void>;
+			};
+		};
+		await tracerProvider.getDelegate?.()?.shutdown?.();
+		debugLangfuse("shutdown completed");
+	} catch (error) {
+		debugLangfuse(
+			`shutdown failed error=${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+}
+
+export function debugLangfuse(message: string): void {
+	if (!isLangfuseDebugEnabled()) {
+		return;
+	}
+	console.warn(`[langfuse-debug] ${message}`);
+}
+
+function isLangfuseDebugEnabled(): boolean {
+	const raw = process.env[LANGFUSE_DEBUG_ENV];
+	if (!raw) {
+		return false;
+	}
+	const normalized = raw.trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+
+export function resetLangfuseTelemetryForTests(): void {
+	langfuseTelemetryReady = undefined;
+	langfuseTelemetryInitPromise = undefined;
+}
diff --git a/sdk/packages/llms/src/tests/live-providers.example.json b/sdk/packages/llms/src/tests/live-providers.example.json
new file mode 100644
index 0000000..189c34b
--- /dev/null
+++ b/sdk/packages/llms/src/tests/live-providers.example.json
@@ -0,0 +1,254 @@
+{
+	"version": 1,
+	"providers": {
+		"anthropic": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-sonnet-4-6"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"anthropic-opus": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-opus-4-7"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"cline": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"cline-opus": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-opus-4.7"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"cline-gpt-5.3-codex": {
+			"settings": {
+				"provider": "cline",
+				"model": "openai/gpt-5.3-codex"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openai": {
+			"settings": {
+				"provider": "openai-native",
+				"model": "gpt-5.4"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"openai-gpt-5.3-codex": {
+			"settings": {
+				"provider": "openai-native",
+				"model": "gpt-5.3-codex"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"gemini": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-flash-lite-preview"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"gemini-pro": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-pro-preview"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"gemma": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemma-4-31b-it"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"deepseek-v4-pro": {
+			"settings": {
+				"provider": "deepseek",
+				"model": "deepseek-v4-pro"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"mistral": {
+			"settings": {
+				"provider": "mistral",
+				"model": "mistral-medium-latest"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openrouter-anthropic": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"openrouter-opus": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "anthropic/claude-opus-4.7"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"openrouter-gpt-5.3-codex": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "openai/gpt-5.3-codex"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openrouter-qwen": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "qwen/qwen3.6-plus"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"qwen-direct-cache": {
+			"settings": {
+				"provider": "qwen",
+				"model": "qwen-plus",
+				"apiKeyEnv": "DASHSCOPE_API_KEY",
+				"baseUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"qwen-code-direct-cache": {
+			"settings": {
+				"provider": "qwen-code",
+				"model": "qwen3-coder-plus",
+				"apiKeyEnv": "DASHSCOPE_API_KEY",
+				"baseUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"cline-qwen": {
+			"settings": {
+				"provider": "cline",
+				"model": "qwen/qwen3.6-plus"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"vercel-anthropic": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"vercel-opus": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "anthropic/claude-opus-4.7"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		},
+		"vercel-openai": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "openai/gpt-5.4"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"vercel-gemini": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "google/gemini-3.1-flash-lite-preview"
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"vercel-qwen": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "alibaba/qwen3.6-plus"
+			},
+			"runs": 3,
+			"expectations": {
+				"requireUsage": true,
+				"requireCacheReadTokens": true
+			}
+		}
+	}
+}
diff --git a/sdk/packages/llms/src/tests/live-providers.openai-codex.example.json b/sdk/packages/llms/src/tests/live-providers.openai-codex.example.json
new file mode 100644
index 0000000..0779d9a
--- /dev/null
+++ b/sdk/packages/llms/src/tests/live-providers.openai-codex.example.json
@@ -0,0 +1,19 @@
+{
+	"version": 1,
+	"providers": {
+		"openai-codex": {
+			"settings": {
+				"provider": "openai-codex",
+				"model": "gpt-5.4",
+				"headers": {
+					"originator": "cline-live-test",
+					"session_id": "llms-live-openai-codex",
+					"User-Agent": "Cline/live-test"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		}
+	}
+}
diff --git a/sdk/packages/llms/src/tests/live-providers.openai-codex.reasoning.example.json b/sdk/packages/llms/src/tests/live-providers.openai-codex.reasoning.example.json
new file mode 100644
index 0000000..45e8a9b
--- /dev/null
+++ b/sdk/packages/llms/src/tests/live-providers.openai-codex.reasoning.example.json
@@ -0,0 +1,22 @@
+{
+	"version": 1,
+	"providers": {
+		"openai-codex-reasoning": {
+			"settings": {
+				"provider": "openai-codex",
+				"model": "gpt-5.4",
+				"headers": {
+					"originator": "cline-live-test",
+					"session_id": "llms-live-openai-codex-reasoning",
+					"User-Agent": "Cline/live-test"
+				},
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		}
+	}
+}
diff --git a/sdk/packages/llms/src/tests/live-providers.reasoning-disabled.example.json b/sdk/packages/llms/src/tests/live-providers.reasoning-disabled.example.json
new file mode 100644
index 0000000..4c667e9
--- /dev/null
+++ b/sdk/packages/llms/src/tests/live-providers.reasoning-disabled.example.json
@@ -0,0 +1,423 @@
+{
+	"version": 1,
+	"providers": {
+		"cline-glm-4.6-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "z-ai/glm-4.6",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"cline-glm-4.7-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "z-ai/glm-4.7",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"cline-glm-5-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "z-ai/glm-5",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"zai-glm-4.6-thinking-off": {
+			"settings": {
+				"provider": "zai",
+				"model": "glm-4.6",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"zai-glm-4.7-thinking-off": {
+			"settings": {
+				"provider": "zai",
+				"model": "glm-4.7",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"zai-glm-5-thinking-off": {
+			"settings": {
+				"provider": "zai",
+				"model": "glm-5",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"openrouter-glm-4.6-thinking-off": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "z-ai/glm-4.6",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"openrouter-glm-4.7-thinking-off": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "z-ai/glm-4.7",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"openrouter-glm-5-thinking-off": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "z-ai/glm-5",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningSignal": true
+			}
+		},
+		"anthropic-claude-sonnet-thinking-off": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-sonnet-4-6",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"anthropic-claude-opus-thinking-off": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-opus-4-7",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"openai-gpt-5.4-thinking-off": {
+			"settings": {
+				"provider": "openai",
+				"model": "gpt-5.4",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"openai-gpt-5.3-codex-thinking-off": {
+			"settings": {
+				"provider": "openai",
+				"model": "gpt-5.3-codex",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"gemini-flash-lite-thinking-off": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-flash-lite-preview",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-gpt-5.4-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "openai/gpt-5.4",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-gpt-5.3-codex-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "openai/gpt-5.3-codex",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"openrouter-gpt-5.4-thinking-off": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "openai/gpt-5.4",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"openrouter-gpt-5.3-codex-thinking-off": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "openai/gpt-5.3-codex",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"vercel-gpt-5.4-thinking-off": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "openai/gpt-5.4",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"deepseek-v4-pro-thinking-off": {
+			"settings": {
+				"provider": "deepseek",
+				"model": "deepseek-v4-pro",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"deepseek-v4-flash-thinking-off": {
+			"settings": {
+				"provider": "deepseek",
+				"model": "deepseek-v4-flash",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"deepseek-v4-flash-thinking-off-with-effort": {
+			"settings": {
+				"provider": "deepseek",
+				"model": "deepseek-v4-flash",
+				"reasoning": {
+					"enabled": false,
+					"effort": "xhigh"
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-deepseek-v3.2-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "deepseek/deepseek-v3.2",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-kimi-k2.6-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "moonshotai/kimi-k2.6",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-qwen3-next-instruct": {
+			"settings": {
+				"provider": "cline",
+				"model": "qwen/qwen3-next-80b-a3b-instruct"
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-grok-4.20-beta-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "x-ai/grok-4.20-beta",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-grok-4.1-fast-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "x-ai/grok-4.1-fast",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-mistral-medium-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "mistralai/mistral-medium-3.1",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-claude-sonnet-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-sonnet-4.6",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		},
+		"cline-gemini-flash-lite-thinking-off": {
+			"settings": {
+				"provider": "cline",
+				"model": "google/gemini-3.1-flash-lite-preview",
+				"reasoning": {
+					"enabled": false
+				}
+			},
+			"prompt": "Answer with only the number: what is 47*83?",
+			"expectations": {
+				"requireUsage": true,
+				"requireNoReasoningChunk": true
+			}
+		}
+	}
+}
diff --git a/sdk/packages/llms/src/tests/live-providers.reasoning.example.json b/sdk/packages/llms/src/tests/live-providers.reasoning.example.json
new file mode 100644
index 0000000..e80d1e1
--- /dev/null
+++ b/sdk/packages/llms/src/tests/live-providers.reasoning.example.json
@@ -0,0 +1,349 @@
+{
+	"version": 1,
+	"providers": {
+		"anthropic-reasoning": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-sonnet-4-6",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"anthropic-opus-reasoning": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-opus-4-7",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openai-reasoning": {
+			"settings": {
+				"provider": "openai-native",
+				"model": "gpt-5.4",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openai-gpt-5.3-codex-reasoning": {
+			"settings": {
+				"provider": "openai-native",
+				"model": "gpt-5.3-codex",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"gemini-reasoning": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-flash-lite-preview",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"gemini-pro-reasoning": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-pro-preview",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"deepseek-v4-pro-reasoning": {
+			"settings": {
+				"provider": "deepseek",
+				"model": "deepseek-v4-pro",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"cline-reasoning": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-sonnet-4.6",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"cline-opus-reasoning": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-opus-4.7",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"cline-gpt-5.4-reasoning": {
+			"settings": {
+				"provider": "cline",
+				"model": "openai/gpt-5.4",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"cline-gpt-5.3-codex-reasoning": {
+			"settings": {
+				"provider": "cline",
+				"model": "openai/gpt-5.3-codex",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openrouter-reasoning": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "anthropic/claude-sonnet-4.6",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"openrouter-gpt-5.4-reasoning": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "openai/gpt-5.4",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"vercel-reasoning": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "anthropic/claude-sonnet-4.6",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"vercel-gpt-5.4-reasoning": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "openai/gpt-5.4",
+				"reasoning": {
+					"effort": "high"
+				}
+			},
+			"expectations": {
+				"requireUsage": true
+			}
+		},
+		"cline-glm-4.6-thinking-on": {
+			"settings": {
+				"provider": "cline",
+				"model": "z-ai/glm-4.6",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"cline-glm-4.7-thinking-on": {
+			"settings": {
+				"provider": "cline",
+				"model": "z-ai/glm-4.7",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"cline-glm-5-thinking-on": {
+			"settings": {
+				"provider": "cline",
+				"model": "z-ai/glm-5",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"zai-glm-4.6-thinking-on": {
+			"settings": {
+				"provider": "zai",
+				"model": "glm-4.6",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningChunk": true
+			}
+		},
+		"zai-glm-4.7-thinking-on": {
+			"settings": {
+				"provider": "zai",
+				"model": "glm-4.7",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningChunk": true
+			}
+		},
+		"zai-glm-5-thinking-on": {
+			"settings": {
+				"provider": "zai",
+				"model": "glm-5",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningChunk": true
+			}
+		},
+		"openrouter-zai-glm-4.7-thinking-on": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "z-ai/glm-4.7",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"openrouter-zai-glm-5-thinking-on": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "z-ai/glm-5",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"openrouter-zai-glm-4.6-thinking-on": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "z-ai/glm-4.6",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningSignal": true
+			}
+		},
+		"cline-kimi-k2-thinking": {
+			"settings": {
+				"provider": "cline",
+				"model": "moonshotai/kimi-k2-thinking"
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningChunk": true
+			}
+		},
+		"cline-kimi-k2.6-thinking-on": {
+			"settings": {
+				"provider": "cline",
+				"model": "moonshotai/kimi-k2.6",
+				"reasoning": {
+					"enabled": true
+				}
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningChunk": true
+			}
+		},
+		"cline-qwen3-next-thinking": {
+			"settings": {
+				"provider": "cline",
+				"model": "qwen/qwen3-next-80b-a3b-thinking"
+			},
+			"prompt": "Solve this multi-step problem briefly: A shop has 17 boxes with 23 bolts each, sells 128 bolts, then receives 4 boxes with 19 bolts each. How many bolts are left? Give only the final arithmetic result and one short explanation.",
+			"expectations": {
+				"requireUsage": true,
+				"requireReasoningChunk": true
+			}
+		}
+	}
+}
diff --git a/sdk/packages/llms/src/tests/live-providers.tools.example.json b/sdk/packages/llms/src/tests/live-providers.tools.example.json
new file mode 100644
index 0000000..d60800e
--- /dev/null
+++ b/sdk/packages/llms/src/tests/live-providers.tools.example.json
@@ -0,0 +1,199 @@
+{
+	"version": 1,
+	"providers": {
+		"anthropic-tools": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-sonnet-4-6"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"anthropic-opus-tools": {
+			"settings": {
+				"provider": "anthropic",
+				"model": "claude-opus-4-7"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"openai-tools": {
+			"settings": {
+				"provider": "openai-native",
+				"model": "gpt-5.4"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"openai-gpt-5.3-codex-tools": {
+			"settings": {
+				"provider": "openai-native",
+				"model": "gpt-5.3-codex"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"gemini-tools": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-flash-lite-preview"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"gemini-pro-tools": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemini-3.1-pro-preview"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"gemma-tools": {
+			"settings": {
+				"provider": "gemini",
+				"model": "gemma-4-31b-it"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"deepseek-v4-pro-tools": {
+			"settings": {
+				"provider": "deepseek",
+				"model": "deepseek-v4-pro"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"mistral-tools": {
+			"settings": {
+				"provider": "mistral",
+				"model": "mistral-medium-latest"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"qwen-tools": {
+			"settings": {
+				"provider": "qwen",
+				"model": "qwen-plus",
+				"apiKeyEnv": "DASHSCOPE_API_KEY",
+				"baseUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"qwen-code-tools": {
+			"settings": {
+				"provider": "qwen-code",
+				"model": "qwen3-coder-plus",
+				"apiKeyEnv": "DASHSCOPE_API_KEY",
+				"baseUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"cline-tools": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"cline-opus-tools": {
+			"settings": {
+				"provider": "cline",
+				"model": "anthropic/claude-opus-4.7"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"cline-gpt-5.3-codex-tools": {
+			"settings": {
+				"provider": "cline",
+				"model": "openai/gpt-5.3-codex"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"openrouter-tools": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"openrouter-opus-tools": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "anthropic/claude-opus-4.7"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"openrouter-gpt-5.3-codex-tools": {
+			"settings": {
+				"provider": "openrouter",
+				"model": "openai/gpt-5.3-codex"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"vercel-tools": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "anthropic/claude-sonnet-4.6"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		},
+		"vercel-opus-tools": {
+			"settings": {
+				"provider": "vercel-ai-gateway",
+				"model": "anthropic/claude-opus-4.7"
+			},
+			"expectations": {
+				"requireUsage": true,
+				"requireToolCall": true
+			}
+		}
+	}
+}
diff --git a/sdk/packages/llms/src/tests/provider-live-config.test.ts b/sdk/packages/llms/src/tests/provider-live-config.test.ts
new file mode 100644
index 0000000..94bba25
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live-config.test.ts
@@ -0,0 +1,98 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { toLiveProviderConfig } from "./provider-live-config";
+
+describe("toLiveProviderConfig", () => {
+	afterEach(() => {
+		vi.unstubAllEnvs();
+	});
+
+	it("resolves api keys, base URLs, and headers from environment variables", () => {
+		vi.stubEnv("LIVE_PROVIDER_API_KEY", "oauth-token");
+		vi.stubEnv("LIVE_PROVIDER_BASE_URL", "https://example.test/v1");
+		vi.stubEnv("LIVE_PROVIDER_ACCOUNT_ID", "acct-123");
+
+		expect(
+			toLiveProviderConfig({
+				provider: "openai-codex",
+				model: "gpt-5.4",
+				apiKeyEnv: "LIVE_PROVIDER_API_KEY",
+				baseUrlEnv: "LIVE_PROVIDER_BASE_URL",
+				headers: {
+					originator: "cline-live-test",
+				},
+				headersEnv: {
+					"ChatGPT-Account-Id": "LIVE_PROVIDER_ACCOUNT_ID",
+				},
+				reasoning: {
+					effort: "high",
+				},
+			}),
+		).toMatchObject({
+			providerId: "openai-codex",
+			modelId: "gpt-5.4",
+			apiKey: "oauth-token",
+			baseUrl: "https://example.test/v1",
+			headers: {
+				originator: "cline-live-test",
+				"ChatGPT-Account-Id": "acct-123",
+			},
+			reasoningEffort: "high",
+		});
+	});
+
+	it("throws a clear error when an env-backed secret is missing", () => {
+		expect(() =>
+			toLiveProviderConfig({
+				provider: "openai-codex",
+				apiKeyEnv: "MISSING_LIVE_PROVIDER_API_KEY",
+			}),
+		).toThrow(
+			"apiKeyEnv references unset or empty environment variable MISSING_LIVE_PROVIDER_API_KEY",
+		);
+	});
+
+	it("loads OpenAI Codex OAuth credentials from saved provider settings", () => {
+		const dir = mkdtempSync(path.join(tmpdir(), "llms-live-provider-"));
+		const providersPath = path.join(dir, "providers.json");
+		vi.stubEnv("CLINE_PROVIDER_SETTINGS_PATH", providersPath);
+		writeFileSync(
+			providersPath,
+			JSON.stringify({
+				version: 1,
+				providers: {
+					"openai-codex": {
+						settings: {
+							provider: "openai-codex",
+							auth: {
+								accessToken: "saved-access-token",
+								accountId: "saved-account-id",
+							},
+						},
+					},
+				},
+			}),
+			"utf8",
+		);
+
+		expect(
+			toLiveProviderConfig({
+				provider: "openai-codex",
+				model: "gpt-5.4",
+				headers: {
+					originator: "cline-live-test",
+				},
+			}),
+		).toMatchObject({
+			providerId: "openai-codex",
+			modelId: "gpt-5.4",
+			apiKey: "saved-access-token",
+			headers: {
+				originator: "cline-live-test",
+				"ChatGPT-Account-Id": "saved-account-id",
+			},
+		});
+	});
+});
diff --git a/sdk/packages/llms/src/tests/provider-live-config.ts b/sdk/packages/llms/src/tests/provider-live-config.ts
new file mode 100644
index 0000000..385258e
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live-config.ts
@@ -0,0 +1,193 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolveProviderSettingsPath } from "@cline/shared/storage";
+
+type ProviderConfig = import("../providers").ProviderConfig;
+
+type StoredProviderSettingsLike = {
+	providers?: Record<
+		string,
+		{
+			settings?: {
+				auth?: {
+					accessToken?: string;
+					accountId?: string;
+				};
+				apiKey?: string;
+			};
+		}
+	>;
+};
+
+function readObject(input: unknown): Record<string, unknown> {
+	return input && typeof input === "object" && !Array.isArray(input)
+		? (input as Record<string, unknown>)
+		: {};
+}
+
+function readEnvValue(envName: unknown, label: string): string | undefined {
+	if (typeof envName !== "string" || envName.trim().length === 0) {
+		return undefined;
+	}
+	const value = process.env[envName]?.trim();
+	if (!value) {
+		throw new Error(
+			`${label} references unset or empty environment variable ${envName}`,
+		);
+	}
+	return value;
+}
+
+function readStringHeaders(input: unknown): Record<string, string> {
+	const record = readObject(input);
+	return Object.fromEntries(
+		Object.entries(record).filter(
+			([key, value]) => typeof key === "string" && typeof value === "string",
+		),
+	) as Record<string, string>;
+}
+
+function readEnvHeaders(input: unknown): Record<string, string> {
+	const record = readObject(input);
+	return Object.fromEntries(
+		Object.entries(record)
+			.map(([key, envName]) => [
+				key,
+				readEnvValue(envName, `headersEnv.${key}`),
+			])
+			.filter((entry): entry is [string, string] => entry[1] !== undefined),
+	);
+}
+
+function readSavedOpenAICodexSettings():
+	| { accessToken?: string; accountId?: string }
+	| undefined {
+	const filePath = resolveProviderSettingsPath();
+	if (!existsSync(filePath)) {
+		return undefined;
+	}
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		const parsed = JSON.parse(raw) as StoredProviderSettingsLike;
+		const settings = parsed.providers?.["openai-codex"]?.settings;
+		return {
+			accessToken:
+				settings?.auth?.accessToken?.trim() || settings?.apiKey?.trim(),
+			accountId: settings?.auth?.accountId?.trim(),
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+	const payload = token.split(".")[1];
+	if (!payload) {
+		return undefined;
+	}
+	try {
+		const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+		const padded = base64.padEnd(
+			base64.length + ((4 - (base64.length % 4)) % 4),
+			"=",
+		);
+		return JSON.parse(Buffer.from(padded, "base64").toString("utf8")) as Record<
+			string,
+			unknown
+		>;
+	} catch {
+		return undefined;
+	}
+}
+
+function deriveOpenAICodexAccountId(
+	accessToken: string | undefined,
+): string | undefined {
+	if (!accessToken) {
+		return undefined;
+	}
+	const payload = decodeJwtPayload(accessToken);
+	const auth = readObject(payload?.["https://api.openai.com/auth"]);
+	const authAccountId = auth.chatgpt_account_id;
+	if (typeof authAccountId === "string" && authAccountId.length > 0) {
+		return authAccountId;
+	}
+	const organizations = payload?.organizations;
+	if (Array.isArray(organizations)) {
+		const organization = readObject(organizations[0]);
+		const orgId = organization.id;
+		if (typeof orgId === "string" && orgId.length > 0) {
+			return orgId;
+		}
+	}
+	const rootAccountId = payload?.chatgpt_account_id;
+	return typeof rootAccountId === "string" && rootAccountId.length > 0
+		? rootAccountId
+		: undefined;
+}
+
+export function toLiveProviderConfig(settingsInput: unknown): ProviderConfig {
+	const settings = readObject(settingsInput);
+	const provider = settings.provider;
+	if (typeof provider !== "string" || provider.trim().length === 0) {
+		throw new Error("live provider entry must include a provider string");
+	}
+	const savedCodex =
+		provider === "openai-codex" ? readSavedOpenAICodexSettings() : undefined;
+
+	const config: ProviderConfig = {
+		providerId: provider,
+		modelId: typeof settings.model === "string" ? settings.model : "default",
+	};
+	const apiKey =
+		typeof settings.apiKey === "string"
+			? settings.apiKey
+			: (readEnvValue(settings.apiKeyEnv, "apiKeyEnv") ??
+				savedCodex?.accessToken);
+	if (apiKey) {
+		config.apiKey = apiKey;
+	}
+	const baseUrl =
+		typeof settings.baseUrl === "string"
+			? settings.baseUrl
+			: readEnvValue(settings.baseUrlEnv, "baseUrlEnv");
+	if (baseUrl) {
+		config.baseUrl = baseUrl;
+	}
+	const headers = {
+		...readStringHeaders(settings.headers),
+		...readEnvHeaders(settings.headersEnv),
+	};
+	const codexAccountId =
+		savedCodex?.accountId || deriveOpenAICodexAccountId(apiKey);
+	if (
+		provider === "openai-codex" &&
+		codexAccountId &&
+		!headers["ChatGPT-Account-Id"]
+	) {
+		headers["ChatGPT-Account-Id"] = codexAccountId;
+	}
+	if (Object.keys(headers).length > 0) {
+		config.headers = headers;
+	}
+	if (
+		settings.reasoning &&
+		typeof settings.reasoning === "object" &&
+		!Array.isArray(settings.reasoning)
+	) {
+		const reasoning = settings.reasoning as Record<string, unknown>;
+		if (typeof reasoning.enabled === "boolean") {
+			config.thinking = reasoning.enabled;
+		}
+		if (typeof reasoning.effort === "string" && reasoning.effort !== "none") {
+			config.reasoningEffort = reasoning.effort as
+				| "low"
+				| "medium"
+				| "high"
+				| "xhigh";
+		}
+		if (typeof reasoning.budgetTokens === "number") {
+			config.thinkingBudgetTokens = reasoning.budgetTokens;
+		}
+	}
+	return config;
+}
diff --git a/sdk/packages/llms/src/tests/provider-live-minimax-routing.test.ts b/sdk/packages/llms/src/tests/provider-live-minimax-routing.test.ts
new file mode 100644
index 0000000..b2e67ef
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live-minimax-routing.test.ts
@@ -0,0 +1,266 @@
+import { describe, expect, it } from "vitest";
+import { createHandlerAsync, type ProviderConfig } from "../providers";
+
+type ReasoningControl = { enabled: boolean };
+
+type LiveCase = {
+	label: string;
+	config: ProviderConfig;
+	expectedBody: Record<string, unknown>;
+	unexpectedBodyKeys?: string[];
+};
+
+type LiveMetrics = {
+	usageSeen: boolean;
+	reasoningChunks: number;
+};
+
+type CapturedRequest = {
+	url: string;
+	body: unknown;
+};
+
+const LIVE_TEST_ENABLED = process.env.LLMS_LIVE_MINIMAX_ROUTING_TESTS === "1";
+const PROVIDER_TIMEOUT_MS = Number(
+	process.env.LLMS_LIVE_PROVIDER_TIMEOUT_MS ?? "120000",
+);
+const DEFAULT_PROMPT =
+	"What is 12*13? Answer with only the number and no explanation.";
+
+function readRequiredEnv(name: string): string {
+	const value = process.env[name]?.trim();
+	if (!value) {
+		throw new Error(`Set ${name} to run MiniMax M3 live routing tests.`);
+	}
+	return value;
+}
+
+function makeConfig(options: {
+	providerId: string;
+	modelId: string;
+	apiKeyEnv: string;
+	reasoning: ReasoningControl;
+	fetch: typeof fetch;
+}): ProviderConfig {
+	return {
+		providerId: options.providerId,
+		modelId: options.modelId,
+		apiKey: readRequiredEnv(options.apiKeyEnv),
+		fetch: options.fetch,
+		thinking: options.reasoning.enabled,
+		maxOutputTokens: 64,
+	};
+}
+
+async function readRequestBody(
+	body: unknown,
+): Promise<Record<string, unknown>> {
+	if (typeof body === "string") {
+		return JSON.parse(body) as Record<string, unknown>;
+	}
+	if (body instanceof Uint8Array) {
+		return JSON.parse(new TextDecoder().decode(body)) as Record<
+			string,
+			unknown
+		>;
+	}
+	if (body instanceof ArrayBuffer) {
+		return JSON.parse(new TextDecoder().decode(body)) as Record<
+			string,
+			unknown
+		>;
+	}
+	return body && typeof body === "object"
+		? (body as Record<string, unknown>)
+		: {};
+}
+
+async function runLiveRequest(config: ProviderConfig): Promise<LiveMetrics> {
+	const handler = await createHandlerAsync(config);
+	const metrics: LiveMetrics = { usageSeen: false, reasoningChunks: 0 };
+	const stream = handler.createMessage("You are concise.", [
+		{ role: "user", content: DEFAULT_PROMPT },
+	]);
+
+	for await (const chunk of stream) {
+		if (chunk.type === "usage") {
+			metrics.usageSeen = true;
+		}
+		if (chunk.type === "reasoning") {
+			metrics.reasoningChunks += 1;
+		}
+		if (chunk.type === "done" && !chunk.success) {
+			throw new Error(chunk.error ?? "done chunk reported success=false");
+		}
+	}
+
+	return metrics;
+}
+
+function buildCases(): LiveCase[] {
+	const cases: LiveCase[] = [];
+	const addCase = (options: {
+		label: string;
+		providerId: string;
+		modelId: string;
+		apiKeyEnv: string;
+		reasoning: ReasoningControl;
+		expectedBody: Record<string, unknown>;
+		unexpectedBodyKeys?: string[];
+	}) => {
+		const captured: CapturedRequest[] = [];
+		const captureFetch: typeof fetch = async (input, init) => {
+			captured.push({ url: String(input), body: init?.body });
+			return fetch(input, init);
+		};
+		const config = makeConfig({ ...options, fetch: captureFetch });
+		cases.push({
+			label: options.label,
+			config: {
+				...config,
+				metadata: {
+					...(config.metadata ?? {}),
+					get capturedRequests() {
+						return captured;
+					},
+				},
+			},
+			expectedBody: options.expectedBody,
+			unexpectedBodyKeys: options.unexpectedBodyKeys,
+		});
+	};
+
+	addCase({
+		label: "direct MiniMax M3 reasoning enabled",
+		providerId: "minimax",
+		modelId: "MiniMax-M3",
+		apiKeyEnv: "MINIMAX_API_KEY",
+		reasoning: { enabled: true },
+		expectedBody: { thinking: { type: "adaptive" } },
+		unexpectedBodyKeys: [
+			"reasoning",
+			"effort",
+			"reasoningEffort",
+			"reasoningSummary",
+		],
+	});
+	addCase({
+		label: "direct MiniMax M3 reasoning disabled",
+		providerId: "minimax",
+		modelId: "MiniMax-M3",
+		apiKeyEnv: "MINIMAX_API_KEY",
+		reasoning: { enabled: false },
+		expectedBody: { thinking: { type: "disabled" } },
+		unexpectedBodyKeys: [
+			"reasoning",
+			"effort",
+			"reasoningEffort",
+			"reasoningSummary",
+		],
+	});
+	addCase({
+		label: "OpenRouter MiniMax M3 reasoning enabled",
+		providerId: "openrouter",
+		modelId: "minimax/minimax-m3",
+		apiKeyEnv: "OPENROUTER_API_KEY",
+		reasoning: { enabled: true },
+		expectedBody: { reasoning: { enabled: true } },
+		unexpectedBodyKeys: ["thinking"],
+	});
+	addCase({
+		label: "OpenRouter MiniMax M3 reasoning disabled",
+		providerId: "openrouter",
+		modelId: "minimax/minimax-m3",
+		apiKeyEnv: "OPENROUTER_API_KEY",
+		reasoning: { enabled: false },
+		expectedBody: { reasoning: { effort: "none" } },
+		unexpectedBodyKeys: ["thinking"],
+	});
+	addCase({
+		label: "Vercel AI Gateway MiniMax M3 reasoning enabled",
+		providerId: "vercel-ai-gateway",
+		modelId: "minimax/minimax-m3",
+		apiKeyEnv: "AI_GATEWAY_API_KEY",
+		reasoning: { enabled: true },
+		expectedBody: { reasoning: { enabled: true } },
+		unexpectedBodyKeys: ["thinking"],
+	});
+	addCase({
+		label: "Vercel AI Gateway MiniMax M3 reasoning disabled",
+		providerId: "vercel-ai-gateway",
+		modelId: "minimax/minimax-m3",
+		apiKeyEnv: "AI_GATEWAY_API_KEY",
+		reasoning: { enabled: false },
+		expectedBody: { reasoning: { exclude: true } },
+		unexpectedBodyKeys: ["thinking"],
+	});
+	addCase({
+		label: "Cline Gateway MiniMax M3 reasoning enabled",
+		providerId: "cline",
+		modelId: "minimax/minimax-m3",
+		apiKeyEnv: "CLINE_API_KEY",
+		reasoning: { enabled: true },
+		expectedBody: { reasoning: { enabled: true } },
+		unexpectedBodyKeys: ["thinking"],
+	});
+	addCase({
+		label: "Cline Gateway MiniMax M3 reasoning disabled",
+		providerId: "cline",
+		modelId: "minimax/minimax-m3",
+		apiKeyEnv: "CLINE_API_KEY",
+		reasoning: { enabled: false },
+		expectedBody: { reasoning: { enabled: false } },
+		unexpectedBodyKeys: ["thinking"],
+	});
+
+	return cases;
+}
+
+function getCapturedRequests(config: ProviderConfig): CapturedRequest[] {
+	const metadata = config.metadata as
+		| { capturedRequests?: CapturedRequest[] }
+		| undefined;
+	return metadata?.capturedRequests ?? [];
+}
+
+describe("live MiniMax M3 provider routing mechanics", () => {
+	const runLive = LIVE_TEST_ENABLED ? it : it.skip;
+
+	runLive(
+		"sends explicit reasoning controls for every MiniMax M3 route",
+		async () => {
+			const failures: string[] = [];
+
+			for (const liveCase of buildCases()) {
+				try {
+					const metrics = await runLiveRequest(liveCase.config);
+					expect(metrics.usageSeen, liveCase.label).toBe(true);
+					const request = getCapturedRequests(liveCase.config).at(-1);
+					expect(request, liveCase.label).toBeDefined();
+					const body = await readRequestBody(request?.body);
+					expect(body, liveCase.label).toEqual(
+						expect.objectContaining(liveCase.expectedBody),
+					);
+					for (const key of liveCase.unexpectedBodyKeys ?? []) {
+						expect(body, liveCase.label).not.toHaveProperty(key);
+					}
+				} catch (error) {
+					failures.push(
+						`${liveCase.label}: ${
+							error instanceof Error ? error.message : String(error)
+						}`,
+					);
+				}
+			}
+
+			if (failures.length > 0) {
+				throw new Error(
+					`MiniMax M3 routing failures (${failures.length}):\n${failures.join(
+						"\n",
+					)}`,
+				);
+			}
+		},
+		PROVIDER_TIMEOUT_MS,
+	);
+});
diff --git a/sdk/packages/llms/src/tests/provider-live-reasoning.test.ts b/sdk/packages/llms/src/tests/provider-live-reasoning.test.ts
new file mode 100644
index 0000000..14c0ece
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live-reasoning.test.ts
@@ -0,0 +1,310 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "vitest";
+import * as LlmsProviders from "../providers";
+import { toLiveProviderConfig } from "./provider-live-config";
+import {
+	LIVE_PROVIDER_CONCURRENCY,
+	runLiveProviderTargets,
+} from "./provider-live-runner";
+
+type ProviderConfig = import("../providers").ProviderConfig;
+
+interface StoredProviderSettingsEntryLike {
+	settings?: unknown;
+}
+
+interface StoredProviderSettingsLike {
+	providers?: Record<string, unknown>;
+}
+
+interface ProviderTarget {
+	label: string;
+	config: ProviderConfig;
+	systemPrompt: string;
+	userPrompt: string;
+	runs: number;
+	expectations: LiveReasoningExpectations;
+}
+
+const LIVE_TEST_ENABLED = process.env.LLMS_LIVE_REASONING_TESTS === "1";
+const PROVIDERS_FILE_ENV = "LLMS_LIVE_REASONING_PROVIDERS_PATH";
+const PROVIDER_TIMEOUT_MS = Number(
+	process.env.LLMS_LIVE_PROVIDER_TIMEOUT_MS ?? "90000",
+);
+const PROVIDER_RETRIES = Number(process.env.LLMS_LIVE_PROVIDER_RETRIES ?? "2");
+const PROVIDER_ATTEMPTS = Number.isFinite(PROVIDER_RETRIES)
+	? Math.max(1, Math.floor(PROVIDER_RETRIES) + 1)
+	: 1;
+const DEFAULT_SYSTEM_PROMPT = "You are a concise assistant.";
+const DEFAULT_USER_PROMPT =
+	"Solve briefly: what is 47*83? Then give one short sentence.";
+
+interface LiveProviderEntryLike {
+	settings?: unknown;
+	expectations?: unknown;
+	systemPrompt?: unknown;
+	userPrompt?: unknown;
+	prompt?: unknown;
+	runs?: unknown;
+}
+
+interface LiveReasoningExpectations {
+	requireUsage: boolean;
+	requireReasoningSignal: boolean;
+	requireReasoningChunk: boolean;
+	requireNoReasoningChunk: boolean;
+	requireNoReasoningSignal: boolean;
+}
+
+interface LiveRunMetrics {
+	usageSeen: boolean;
+	reasoningChunkCount: number;
+	reasoningTokenCountMax: number;
+}
+
+function parseExpectations(input: unknown): LiveReasoningExpectations {
+	const value =
+		input && typeof input === "object"
+			? (input as Record<string, unknown>)
+			: {};
+	return {
+		requireUsage: value.requireUsage !== false,
+		requireReasoningSignal: value.requireReasoningSignal === true,
+		requireReasoningChunk: value.requireReasoningChunk === true,
+		requireNoReasoningChunk: value.requireNoReasoningChunk === true,
+		requireNoReasoningSignal: value.requireNoReasoningSignal === true,
+	};
+}
+
+function toTarget(
+	label: string,
+	settingsInput: unknown,
+	entry?: LiveProviderEntryLike,
+): ProviderTarget {
+	const config = toLiveProviderConfig(settingsInput);
+	const runsCandidate = entry?.runs;
+	const runs =
+		typeof runsCandidate === "number" &&
+		Number.isFinite(runsCandidate) &&
+		runsCandidate > 0
+			? Math.floor(runsCandidate)
+			: 1;
+	const expectations = parseExpectations(entry?.expectations);
+	if (
+		(expectations.requireReasoningChunk ||
+			expectations.requireReasoningSignal) &&
+		(expectations.requireNoReasoningChunk ||
+			expectations.requireNoReasoningSignal)
+	) {
+		throw new Error(
+			`${label}: positive and negative reasoning expectations are mutually exclusive`,
+		);
+	}
+	if (
+		expectations.requireNoReasoningChunk &&
+		expectations.requireNoReasoningSignal
+	) {
+		throw new Error(
+			`${label}: requireNoReasoningSignal already includes requireNoReasoningChunk`,
+		);
+	}
+
+	return {
+		label: `${label} (${config.providerId})`,
+		config,
+		systemPrompt:
+			typeof entry?.systemPrompt === "string"
+				? entry.systemPrompt
+				: DEFAULT_SYSTEM_PROMPT,
+		userPrompt:
+			typeof entry?.userPrompt === "string"
+				? entry.userPrompt
+				: typeof entry?.prompt === "string"
+					? entry.prompt
+					: DEFAULT_USER_PROMPT,
+		runs,
+		expectations,
+	};
+}
+
+function requireProvidersFilePath(): string {
+	const filePath = process.env[PROVIDERS_FILE_ENV];
+	if (!filePath) {
+		throw new Error(
+			`Set ${PROVIDERS_FILE_ENV} to a provider json path before running live reasoning tests.`,
+		);
+	}
+	return path.resolve(filePath);
+}
+
+function toTargetsFromStoredFormat(
+	json: StoredProviderSettingsLike,
+): ProviderTarget[] {
+	const entries = Object.entries(json.providers ?? {});
+	return entries.map(([entryKey, entryValue]) => {
+		const maybeEntry = entryValue as LiveProviderEntryLike &
+			StoredProviderSettingsEntryLike;
+		const rawSettings = maybeEntry.settings ?? entryValue;
+		return toTarget(entryKey, rawSettings, maybeEntry);
+	});
+}
+
+function loadProviderTargets(filePath: string): ProviderTarget[] {
+	const raw = readFileSync(filePath, "utf8");
+	const parsed = JSON.parse(raw) as unknown;
+
+	if (Array.isArray(parsed)) {
+		return parsed.map((entry, index) => {
+			if (entry && typeof entry === "object" && "settings" in entry) {
+				const wrapped = entry as LiveProviderEntryLike;
+				return toTarget(`index:${index}`, wrapped.settings, wrapped);
+			}
+			return toTarget(`index:${index}`, entry);
+		});
+	}
+
+	return toTargetsFromStoredFormat(parsed as StoredProviderSettingsLike);
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	label: string,
+): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	const timeoutPromise = new Promise<T>((_, reject) => {
+		timeout = setTimeout(() => {
+			reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+		}, timeoutMs);
+	});
+
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+function assertTargetExpectations(
+	target: ProviderTarget,
+	metrics: LiveRunMetrics,
+): void {
+	const errors: string[] = [];
+	const expectations = target.expectations;
+	if (expectations.requireUsage && !metrics.usageSeen) {
+		errors.push("expected at least one usage chunk");
+	}
+	if (
+		expectations.requireReasoningSignal &&
+		metrics.reasoningChunkCount <= 0 &&
+		metrics.reasoningTokenCountMax <= 0
+	) {
+		errors.push(
+			"expected reasoning signal (reasoning chunk or reasoning tokens)",
+		);
+	}
+	if (expectations.requireReasoningChunk && metrics.reasoningChunkCount <= 0) {
+		errors.push("expected at least one reasoning chunk");
+	}
+	if (expectations.requireNoReasoningChunk && metrics.reasoningChunkCount > 0) {
+		errors.push(
+			`expected no reasoning chunks, got ${metrics.reasoningChunkCount}`,
+		);
+	}
+	if (
+		expectations.requireNoReasoningSignal &&
+		(metrics.reasoningChunkCount > 0 || metrics.reasoningTokenCountMax > 0)
+	) {
+		errors.push(
+			`expected no reasoning signal, got ${metrics.reasoningChunkCount} reasoning chunks and ${metrics.reasoningTokenCountMax} reasoning tokens`,
+		);
+	}
+	if (errors.length > 0) {
+		throw new Error(errors.join("; "));
+	}
+}
+
+async function runReasoningPrompt(target: ProviderTarget): Promise<void> {
+	const handler = await LlmsProviders.createHandlerAsync(target.config);
+	const metrics: LiveRunMetrics = {
+		usageSeen: false,
+		reasoningChunkCount: 0,
+		reasoningTokenCountMax: 0,
+	};
+
+	for (let run = 0; run < target.runs; run++) {
+		const stream = handler.createMessage(target.systemPrompt, [
+			{ role: "user", content: target.userPrompt },
+		]);
+		for await (const chunk of stream) {
+			if (chunk.type === "reasoning") {
+				metrics.reasoningChunkCount += 1;
+				continue;
+			}
+			if (chunk.type === "usage") {
+				metrics.usageSeen = true;
+				metrics.reasoningTokenCountMax = Math.max(
+					metrics.reasoningTokenCountMax,
+					chunk.thoughtsTokenCount ?? 0,
+				);
+				continue;
+			}
+			if (chunk.type === "done" && !chunk.success) {
+				throw new Error(chunk.error ?? "done chunk reported success=false");
+			}
+		}
+	}
+	assertTargetExpectations(target, metrics);
+}
+
+describe("live provider reasoning smoke test", () => {
+	const runLive = LIVE_TEST_ENABLED ? it : it.skip;
+	runLive(
+		"runs reasoning-enabled provider configs and reports failures",
+		async () => {
+			const filePath = requireProvidersFilePath();
+			const targets = loadProviderTargets(filePath);
+			if (!targets.length) {
+				throw new Error(`No providers found in ${filePath}.`);
+			}
+
+			const failures = await runLiveProviderTargets({
+				targets,
+				concurrency: LIVE_PROVIDER_CONCURRENCY,
+				runTarget: async (target) => {
+					let success = false;
+					let lastError: unknown;
+					for (let attempt = 1; attempt <= PROVIDER_ATTEMPTS; attempt++) {
+						try {
+							await withTimeout(
+								runReasoningPrompt(target),
+								PROVIDER_TIMEOUT_MS,
+								target.label,
+							);
+							success = true;
+							break;
+						} catch (error) {
+							lastError = error;
+						}
+					}
+					if (success) {
+						return undefined;
+					}
+					const message =
+						lastError instanceof Error ? lastError.message : String(lastError);
+					return `${target.label}: ${message}`;
+				},
+			});
+
+			if (failures.length > 0) {
+				throw new Error(
+					`Providers with error responses (${failures.length}):\n${failures.join("\n")}`,
+				);
+			}
+		},
+		300_000,
+	);
+});
diff --git a/sdk/packages/llms/src/tests/provider-live-runner.ts b/sdk/packages/llms/src/tests/provider-live-runner.ts
new file mode 100644
index 0000000..57cad8a
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live-runner.ts
@@ -0,0 +1,47 @@
+const DEFAULT_PROVIDER_CONCURRENCY = 3;
+
+export const LIVE_PROVIDER_CONCURRENCY = parseLiveProviderConcurrency(
+	process.env.LLMS_LIVE_PROVIDER_CONCURRENCY,
+);
+
+function parseLiveProviderConcurrency(value: string | undefined): number {
+	if (!value) {
+		return DEFAULT_PROVIDER_CONCURRENCY;
+	}
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) {
+		return DEFAULT_PROVIDER_CONCURRENCY;
+	}
+	return Math.max(1, Math.floor(parsed));
+}
+
+export async function runLiveProviderTargets<Target>(options: {
+	targets: readonly Target[];
+	concurrency?: number;
+	runTarget(target: Target): Promise<string | undefined>;
+}): Promise<string[]> {
+	const concurrency = Math.max(
+		1,
+		Math.floor(options.concurrency ?? LIVE_PROVIDER_CONCURRENCY),
+	);
+	const failures: string[] = [];
+	let nextIndex = 0;
+
+	async function worker(): Promise<void> {
+		while (true) {
+			const target = options.targets[nextIndex];
+			nextIndex += 1;
+			if (target === undefined) {
+				return;
+			}
+			const failure = await options.runTarget(target);
+			if (failure) {
+				failures.push(failure);
+			}
+		}
+	}
+
+	const workerCount = Math.min(concurrency, options.targets.length);
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return failures;
+}
diff --git a/sdk/packages/llms/src/tests/provider-live-tools.test.ts b/sdk/packages/llms/src/tests/provider-live-tools.test.ts
new file mode 100644
index 0000000..aa11d26
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live-tools.test.ts
@@ -0,0 +1,265 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "vitest";
+import * as LlmsProviders from "../providers";
+import { toLiveProviderConfig } from "./provider-live-config";
+import {
+	LIVE_PROVIDER_CONCURRENCY,
+	runLiveProviderTargets,
+} from "./provider-live-runner";
+
+type ProviderConfig = import("../providers").ProviderConfig;
+
+interface StoredProviderSettingsEntryLike {
+	settings?: unknown;
+}
+
+interface StoredProviderSettingsLike {
+	providers?: Record<string, unknown>;
+}
+
+interface ProviderTarget {
+	label: string;
+	config: ProviderConfig;
+	systemPrompt: string;
+	userPrompt: string;
+	runs: number;
+	requireUsage: boolean;
+	requireToolCall: boolean;
+}
+
+interface LiveProviderEntryLike {
+	settings?: unknown;
+	expectations?: unknown;
+	systemPrompt?: unknown;
+	userPrompt?: unknown;
+	prompt?: unknown;
+	runs?: unknown;
+}
+
+interface LiveRunMetrics {
+	usageSeen: boolean;
+	toolCallCount: number;
+}
+
+const LIVE_TEST_ENABLED = process.env.LLMS_LIVE_TOOL_TESTS === "1";
+const PROVIDERS_FILE_ENV = "LLMS_LIVE_TOOL_PROVIDERS_PATH";
+const PROVIDER_TIMEOUT_MS = Number(
+	process.env.LLMS_LIVE_PROVIDER_TIMEOUT_MS ?? "90000",
+);
+const PROVIDER_RETRIES = Number(process.env.LLMS_LIVE_PROVIDER_RETRIES ?? "2");
+const PROVIDER_ATTEMPTS = Number.isFinite(PROVIDER_RETRIES)
+	? Math.max(1, Math.floor(PROVIDER_RETRIES) + 1)
+	: 1;
+const DEFAULT_SYSTEM_PROMPT = "You are a tool-using assistant.";
+const DEFAULT_USER_PROMPT = [
+	'Call the "echo_tool" tool exactly once with {"text":"ping"}.',
+	"After the tool call, output exactly: DONE",
+].join(" ");
+
+const LIVE_TOOL_DEFINITIONS = [
+	{
+		name: "echo_tool",
+		description: "Echoes text for tool-routing tests.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				text: { type: "string" },
+			},
+			required: ["text"],
+			additionalProperties: false,
+		},
+	},
+];
+
+function toTarget(
+	label: string,
+	settingsInput: unknown,
+	entry?: LiveProviderEntryLike,
+): ProviderTarget {
+	const config = toLiveProviderConfig(settingsInput);
+	const runsCandidate = entry?.runs;
+	const runs =
+		typeof runsCandidate === "number" &&
+		Number.isFinite(runsCandidate) &&
+		runsCandidate > 0
+			? Math.floor(runsCandidate)
+			: 1;
+	const expectations =
+		entry?.expectations && typeof entry.expectations === "object"
+			? (entry.expectations as Record<string, unknown>)
+			: {};
+
+	return {
+		label: `${label} (${config.providerId})`,
+		config,
+		systemPrompt:
+			typeof entry?.systemPrompt === "string"
+				? entry.systemPrompt
+				: DEFAULT_SYSTEM_PROMPT,
+		userPrompt:
+			typeof entry?.userPrompt === "string"
+				? entry.userPrompt
+				: typeof entry?.prompt === "string"
+					? entry.prompt
+					: DEFAULT_USER_PROMPT,
+		runs,
+		requireUsage: expectations.requireUsage !== false,
+		requireToolCall: expectations.requireToolCall === true,
+	};
+}
+
+function requireProvidersFilePath(): string {
+	const filePath = process.env[PROVIDERS_FILE_ENV];
+	if (!filePath) {
+		throw new Error(
+			`Set ${PROVIDERS_FILE_ENV} to a provider json path before running live tool-use tests.`,
+		);
+	}
+	return path.resolve(filePath);
+}
+
+function toTargetsFromStoredFormat(
+	json: StoredProviderSettingsLike,
+): ProviderTarget[] {
+	const entries = Object.entries(json.providers ?? {});
+	return entries.map(([entryKey, entryValue]) => {
+		const maybeEntry = entryValue as LiveProviderEntryLike &
+			StoredProviderSettingsEntryLike;
+		const rawSettings = maybeEntry.settings ?? entryValue;
+		return toTarget(entryKey, rawSettings, maybeEntry);
+	});
+}
+
+function loadProviderTargets(filePath: string): ProviderTarget[] {
+	const raw = readFileSync(filePath, "utf8");
+	const parsed = JSON.parse(raw) as unknown;
+
+	if (Array.isArray(parsed)) {
+		return parsed.map((entry, index) => {
+			if (entry && typeof entry === "object" && "settings" in entry) {
+				const wrapped = entry as LiveProviderEntryLike;
+				return toTarget(`index:${index}`, wrapped.settings, wrapped);
+			}
+			return toTarget(`index:${index}`, entry);
+		});
+	}
+
+	return toTargetsFromStoredFormat(parsed as StoredProviderSettingsLike);
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	label: string,
+): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	const timeoutPromise = new Promise<T>((_, reject) => {
+		timeout = setTimeout(() => {
+			reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+		}, timeoutMs);
+	});
+
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+function assertTargetExpectations(
+	target: ProviderTarget,
+	metrics: LiveRunMetrics,
+): void {
+	const errors: string[] = [];
+	if (target.requireUsage && !metrics.usageSeen) {
+		errors.push("expected at least one usage chunk");
+	}
+	if (target.requireToolCall && metrics.toolCallCount <= 0) {
+		errors.push("expected at least one tool_calls chunk");
+	}
+	if (errors.length > 0) {
+		throw new Error(errors.join("; "));
+	}
+}
+
+async function runToolUsePrompt(target: ProviderTarget): Promise<void> {
+	const handler = await LlmsProviders.createHandlerAsync(target.config);
+	const metrics: LiveRunMetrics = {
+		usageSeen: false,
+		toolCallCount: 0,
+	};
+
+	for (let run = 0; run < target.runs; run++) {
+		const stream = handler.createMessage(
+			target.systemPrompt,
+			[{ role: "user", content: target.userPrompt }],
+			LIVE_TOOL_DEFINITIONS,
+		);
+		for await (const chunk of stream) {
+			if (chunk.type === "tool_calls") {
+				metrics.toolCallCount += 1;
+				continue;
+			}
+			if (chunk.type === "usage") {
+				metrics.usageSeen = true;
+				continue;
+			}
+			if (chunk.type === "done" && !chunk.success) {
+				throw new Error(chunk.error ?? "done chunk reported success=false");
+			}
+		}
+	}
+	assertTargetExpectations(target, metrics);
+}
+
+describe("live provider tool-use smoke test", () => {
+	const runLive = LIVE_TEST_ENABLED ? it : it.skip;
+	runLive(
+		"runs tool-enabled provider configs and reports failures",
+		async () => {
+			const filePath = requireProvidersFilePath();
+			const targets = loadProviderTargets(filePath);
+			if (!targets.length) {
+				throw new Error(`No providers found in ${filePath}.`);
+			}
+
+			const failures = await runLiveProviderTargets({
+				targets,
+				concurrency: LIVE_PROVIDER_CONCURRENCY,
+				runTarget: async (target) => {
+					let success = false;
+					let lastError: unknown;
+					for (let attempt = 1; attempt <= PROVIDER_ATTEMPTS; attempt++) {
+						try {
+							await withTimeout(
+								runToolUsePrompt(target),
+								PROVIDER_TIMEOUT_MS,
+								target.label,
+							);
+							success = true;
+							break;
+						} catch (error) {
+							lastError = error;
+						}
+					}
+					if (success) {
+						return undefined;
+					}
+					const message =
+						lastError instanceof Error ? lastError.message : String(lastError);
+					return `${target.label}: ${message}`;
+				},
+			});
+
+			if (failures.length > 0) {
+				throw new Error(
+					`Providers with error responses (${failures.length}):\n${failures.join("\n")}`,
+				);
+			}
+		},
+		300_000,
+	);
+});
diff --git a/sdk/packages/llms/src/tests/provider-live.test.ts b/sdk/packages/llms/src/tests/provider-live.test.ts
new file mode 100644
index 0000000..f3461c9
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-live.test.ts
@@ -0,0 +1,350 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "vitest";
+import * as LlmsProviders from "../providers";
+import { toLiveProviderConfig } from "./provider-live-config";
+import {
+	LIVE_PROVIDER_CONCURRENCY,
+	runLiveProviderTargets,
+} from "./provider-live-runner";
+
+type ProviderConfig = import("../providers").ProviderConfig;
+
+interface StoredProviderSettingsEntryLike {
+	settings?: unknown;
+}
+
+interface StoredProviderSettingsLike {
+	providers?: Record<string, unknown>;
+}
+
+interface ProviderTarget {
+	label: string;
+	config: ProviderConfig;
+	systemPrompt: string;
+	userPrompt: string;
+	runs: number;
+	expectations: LiveExpectations;
+}
+
+const LIVE_TEST_ENABLED = process.env.LLMS_LIVE_TESTS === "1";
+const PROVIDERS_FILE_ENV = "LLMS_LIVE_PROVIDERS_PATH";
+const PROVIDER_TIMEOUT_MS = Number(
+	process.env.LLMS_LIVE_PROVIDER_TIMEOUT_MS ?? "90000",
+);
+const PROVIDER_RETRIES = Number(process.env.LLMS_LIVE_PROVIDER_RETRIES ?? "2");
+const PROVIDER_ATTEMPTS = Number.isFinite(PROVIDER_RETRIES)
+	? Math.max(1, Math.floor(PROVIDER_RETRIES) + 1)
+	: 1;
+const DEFAULT_SYSTEM_PROMPT = "You are a concise assistant.";
+const DEFAULT_USER_PROMPT = "Reply with the single word OK.";
+const DEFAULT_CACHE_PROBE_PROMPT = [
+	"Answer with one word: OK.",
+	"Use only the provided context below; do not call tools.",
+	"Context:",
+	// Keep this comfortably above Gemini's implicit-cache floor to avoid
+	// provider-side cache misses making the live cache assertion flaky.
+	"Section A: ".repeat(1600),
+	"Section B: ".repeat(1600),
+].join("\n");
+
+interface LiveExpectations {
+	requireUsage?: boolean;
+	requireReasoningChunk?: boolean;
+	requireCacheReadTokens?: boolean;
+	minInputTokens?: number;
+	minOutputTokens?: number;
+	minCacheReadTokens?: number;
+}
+
+interface LiveProviderEntryLike {
+	settings?: unknown;
+	expectations?: unknown;
+	systemPrompt?: unknown;
+	userPrompt?: unknown;
+	prompt?: unknown;
+	runs?: unknown;
+}
+
+interface LiveRunMetrics {
+	usageSeen: boolean;
+	reasoningChunkCount: number;
+	cacheReadTokensMax: number;
+	cacheWriteTokensMax: number;
+	inputTokensMax: number;
+	outputTokensMax: number;
+}
+
+function parseExpectations(input: unknown): LiveExpectations {
+	if (!input || typeof input !== "object") {
+		return {};
+	}
+	const value = input as Record<string, unknown>;
+	return {
+		requireUsage:
+			typeof value.requireUsage === "boolean" ? value.requireUsage : undefined,
+		requireReasoningChunk:
+			typeof value.requireReasoningChunk === "boolean"
+				? value.requireReasoningChunk
+				: undefined,
+		requireCacheReadTokens:
+			typeof value.requireCacheReadTokens === "boolean"
+				? value.requireCacheReadTokens
+				: undefined,
+		minInputTokens:
+			typeof value.minInputTokens === "number"
+				? value.minInputTokens
+				: undefined,
+		minOutputTokens:
+			typeof value.minOutputTokens === "number"
+				? value.minOutputTokens
+				: undefined,
+		minCacheReadTokens:
+			typeof value.minCacheReadTokens === "number"
+				? value.minCacheReadTokens
+				: undefined,
+	};
+}
+
+function toTarget(
+	label: string,
+	settingsInput: unknown,
+	entry?: LiveProviderEntryLike,
+): ProviderTarget {
+	const config = toLiveProviderConfig(settingsInput);
+	const runsCandidate = entry?.runs;
+	let runs =
+		typeof runsCandidate === "number" &&
+		Number.isFinite(runsCandidate) &&
+		runsCandidate > 0
+			? Math.floor(runsCandidate)
+			: 1;
+	const expectations = parseExpectations(entry?.expectations);
+	const requiresCacheProbe =
+		expectations.requireCacheReadTokens ||
+		typeof expectations.minCacheReadTokens === "number";
+	if (requiresCacheProbe && runs < 2) {
+		runs = 2;
+	}
+	const promptCandidate =
+		typeof entry?.userPrompt === "string"
+			? entry.userPrompt
+			: typeof entry?.prompt === "string"
+				? entry.prompt
+				: undefined;
+	return {
+		label: `${label} (${config.providerId})`,
+		config,
+		systemPrompt:
+			typeof entry?.systemPrompt === "string"
+				? entry.systemPrompt
+				: DEFAULT_SYSTEM_PROMPT,
+		userPrompt:
+			promptCandidate ??
+			(requiresCacheProbe ? DEFAULT_CACHE_PROBE_PROMPT : DEFAULT_USER_PROMPT),
+		runs,
+		expectations,
+	};
+}
+
+function requireProvidersFilePath(): string {
+	const filePath = process.env[PROVIDERS_FILE_ENV];
+	if (!filePath) {
+		throw new Error(
+			`Set ${PROVIDERS_FILE_ENV} to a LlmsProviders.json file path before running live provider tests.`,
+		);
+	}
+	return path.resolve(filePath);
+}
+
+function toTargetsFromStoredFormat(
+	json: StoredProviderSettingsLike,
+): ProviderTarget[] {
+	const entries = Object.entries(json.providers ?? {});
+	return entries.map(([entryKey, entryValue]) => {
+		const maybeEntry = entryValue as LiveProviderEntryLike &
+			StoredProviderSettingsEntryLike;
+		const rawSettings = maybeEntry.settings ?? entryValue;
+		return toTarget(entryKey, rawSettings, maybeEntry);
+	});
+}
+
+function loadProviderTargets(filePath: string): ProviderTarget[] {
+	const raw = readFileSync(filePath, "utf8");
+	const parsed = JSON.parse(raw) as unknown;
+
+	if (Array.isArray(parsed)) {
+		return parsed.map((entry, index) => {
+			if (entry && typeof entry === "object" && "settings" in entry) {
+				const wrapped = entry as LiveProviderEntryLike;
+				return toTarget(`index:${index}`, wrapped.settings, wrapped);
+			}
+			return toTarget(`index:${index}`, entry);
+		});
+	}
+
+	const maybeStored = parsed as StoredProviderSettingsLike;
+	return toTargetsFromStoredFormat(maybeStored);
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	label: string,
+): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	const timeoutPromise = new Promise<T>((_, reject) => {
+		timeout = setTimeout(() => {
+			reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+		}, timeoutMs);
+	});
+
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+function assertTargetExpectations(
+	target: ProviderTarget,
+	metrics: LiveRunMetrics,
+): void {
+	const errors: string[] = [];
+	const expectations = target.expectations;
+	if (expectations.requireUsage !== false && !metrics.usageSeen) {
+		errors.push("expected at least one usage chunk");
+	}
+	if (expectations.requireReasoningChunk && metrics.reasoningChunkCount <= 0) {
+		errors.push("expected at least one reasoning chunk");
+	}
+	if (expectations.requireCacheReadTokens && metrics.cacheReadTokensMax <= 0) {
+		errors.push("expected cacheReadTokens > 0");
+	}
+	if (
+		typeof expectations.minInputTokens === "number" &&
+		metrics.inputTokensMax < expectations.minInputTokens
+	) {
+		errors.push(
+			`expected inputTokens >= ${expectations.minInputTokens}, got ${metrics.inputTokensMax}`,
+		);
+	}
+	if (
+		typeof expectations.minOutputTokens === "number" &&
+		metrics.outputTokensMax < expectations.minOutputTokens
+	) {
+		errors.push(
+			`expected outputTokens >= ${expectations.minOutputTokens}, got ${metrics.outputTokensMax}`,
+		);
+	}
+	if (
+		typeof expectations.minCacheReadTokens === "number" &&
+		metrics.cacheReadTokensMax < expectations.minCacheReadTokens
+	) {
+		errors.push(
+			`expected cacheReadTokens >= ${expectations.minCacheReadTokens}, got ${metrics.cacheReadTokensMax}`,
+		);
+	}
+	if (errors.length > 0) {
+		throw new Error(errors.join("; "));
+	}
+}
+
+async function runPrompt(target: ProviderTarget): Promise<void> {
+	const handler = await LlmsProviders.createHandlerAsync(target.config);
+	const metrics: LiveRunMetrics = {
+		usageSeen: false,
+		reasoningChunkCount: 0,
+		cacheReadTokensMax: 0,
+		cacheWriteTokensMax: 0,
+		inputTokensMax: 0,
+		outputTokensMax: 0,
+	};
+	for (let run = 0; run < target.runs; run++) {
+		const stream = handler.createMessage(target.systemPrompt, [
+			{ role: "user", content: target.userPrompt },
+		]);
+		for await (const chunk of stream) {
+			if (chunk.type === "reasoning") {
+				metrics.reasoningChunkCount += 1;
+				continue;
+			}
+			if (chunk.type === "usage") {
+				metrics.usageSeen = true;
+				metrics.inputTokensMax = Math.max(
+					metrics.inputTokensMax,
+					chunk.inputTokens ?? 0,
+				);
+				metrics.outputTokensMax = Math.max(
+					metrics.outputTokensMax,
+					chunk.outputTokens ?? 0,
+				);
+				metrics.cacheReadTokensMax = Math.max(
+					metrics.cacheReadTokensMax,
+					chunk.cacheReadTokens ?? 0,
+				);
+				metrics.cacheWriteTokensMax = Math.max(
+					metrics.cacheWriteTokensMax,
+					chunk.cacheWriteTokens ?? 0,
+				);
+				continue;
+			}
+			if (chunk.type === "done" && !chunk.success) {
+				throw new Error(chunk.error ?? "done chunk reported success=false");
+			}
+		}
+	}
+	assertTargetExpectations(target, metrics);
+}
+
+describe("live provider smoke test", () => {
+	const runLive = LIVE_TEST_ENABLED ? it : it.skip;
+	runLive(
+		"reads configured providers from json and reports providers with failed responses",
+		async () => {
+			const filePath = requireProvidersFilePath();
+			const targets = loadProviderTargets(filePath);
+
+			if (!targets.length) {
+				throw new Error(`No providers found in ${filePath}.`);
+			}
+
+			const failures = await runLiveProviderTargets({
+				targets,
+				concurrency: LIVE_PROVIDER_CONCURRENCY,
+				runTarget: async (target) => {
+					let success = false;
+					let lastError: unknown;
+					for (let attempt = 1; attempt <= PROVIDER_ATTEMPTS; attempt++) {
+						try {
+							await withTimeout(
+								runPrompt(target),
+								PROVIDER_TIMEOUT_MS,
+								target.label,
+							);
+							success = true;
+							break;
+						} catch (error) {
+							lastError = error;
+						}
+					}
+					if (success) {
+						return undefined;
+					}
+					const message =
+						lastError instanceof Error ? lastError.message : String(lastError);
+					return `${target.label}: ${message}`;
+				},
+			});
+
+			if (failures.length > 0) {
+				throw new Error(
+					`Providers with error responses (${failures.length}):\n${failures.join("\n")}`,
+				);
+			}
+		},
+		300_000,
+	);
+});
diff --git a/sdk/packages/llms/src/tests/provider-vcr.test.ts b/sdk/packages/llms/src/tests/provider-vcr.test.ts
new file mode 100644
index 0000000..c21a1ee
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-vcr.test.ts
@@ -0,0 +1,450 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { disposeAll, initVcr } from "@cline/shared";
+import { resolveProviderSettingsPath } from "@cline/shared/storage";
+import { afterEach, describe, expect, it } from "vitest";
+import { createHandlerAsync, type ProviderConfig } from "../providers";
+
+const fixturesDir = join(
+	dirname(fileURLToPath(import.meta.url)),
+	"provider-vcr",
+);
+const RECORD_MODE = process.env.LLMS_PROVIDER_VCR_RECORD === "1";
+const TARGET_FILTER =
+	process.env.LLMS_PROVIDER_VCR_TARGET?.trim().toLowerCase();
+const PROVIDER_SETTINGS_PATH_ENV = "LLMS_PROVIDER_VCR_SETTINGS_PATH";
+const SYSTEM_PROMPT = "You are a concise assistant.";
+const USER_PROMPT = "Reply with the single word OK.";
+const ORIGINAL_ENV = { ...process.env };
+const ORIGINAL_FETCH = globalThis.fetch;
+let activeCassettePath: string | undefined;
+let activeCassetteOriginalContents: string | undefined;
+let activeCassetteSucceeded = false;
+
+interface ProviderVcrTarget {
+	label: string;
+	providerId: string;
+	modelId: string;
+	playbackConfig: ProviderConfig;
+	cassetteName: string;
+}
+
+interface StoredProviderSettingsEntryLike {
+	settings?: unknown;
+}
+
+interface StoredProviderSettingsLike {
+	providers?: Record<string, StoredProviderSettingsEntryLike>;
+}
+
+const targets: ProviderVcrTarget[] = [
+	{
+		label: "Cline provider",
+		providerId: "cline",
+		modelId: "anthropic/claude-sonnet-4.6",
+		playbackConfig: {
+			providerId: "cline",
+			modelId: "anthropic/claude-sonnet-4.6",
+			apiKey: "workos:test-token",
+		},
+		cassetteName: "cline-anthropic-sonnet.json",
+	},
+	{
+		label: "ChatGPT OAuth provider",
+		providerId: "openai-codex",
+		modelId: "gpt-5.4",
+		playbackConfig: {
+			providerId: "openai-codex",
+			modelId: "gpt-5.4",
+			apiKey: "test-token",
+			headers: {
+				"ChatGPT-Account-Id": "acct_test",
+			},
+		},
+		cassetteName: "openai-codex-gpt-5-4.json",
+	},
+	{
+		label: "Anthropic provider",
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		playbackConfig: {
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			apiKey: "test-key",
+		},
+		cassetteName: "anthropic-claude-sonnet-4-6.json",
+	},
+	{
+		label: "OpenAI Compatible provider",
+		providerId: "openai-compatible",
+		modelId: "deepseek/deepseek-v4-pro",
+		playbackConfig: {
+			providerId: "openai-compatible",
+			modelId: "deepseek/deepseek-v4-pro",
+			apiKey: "test-key",
+			baseUrl: "https://openrouter.ai/api/v1",
+		},
+		cassetteName: "openai-compatible-deepseek-v4-pro.json",
+	},
+];
+
+function matchesTargetFilter(target: ProviderVcrTarget): boolean {
+	if (!TARGET_FILTER) {
+		return true;
+	}
+	return [
+		target.providerId,
+		target.cassetteName.replace(/\.json$/, ""),
+		target.label,
+	]
+		.map((value) => value.toLowerCase())
+		.some((value) => value.includes(TARGET_FILTER));
+}
+
+const selectedTargets = targets.filter(matchesTargetFilter);
+
+function readObject(input: unknown): Record<string, unknown> {
+	return input && typeof input === "object" && !Array.isArray(input)
+		? (input as Record<string, unknown>)
+		: {};
+}
+
+function readString(input: unknown): string | undefined {
+	return typeof input === "string" && input.trim().length > 0
+		? input.trim()
+		: undefined;
+}
+
+function readStringRecord(input: unknown): Record<string, string> | undefined {
+	const entries = Object.entries(readObject(input)).filter(
+		(entry): entry is [string, string] => typeof entry[1] === "string",
+	);
+	return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+function readProviderSettingsFile(): StoredProviderSettingsLike | undefined {
+	const filePath =
+		readString(process.env[PROVIDER_SETTINGS_PATH_ENV]) ??
+		resolveProviderSettingsPath();
+	if (!existsSync(filePath)) {
+		return undefined;
+	}
+	return JSON.parse(
+		readFileSync(filePath, "utf8"),
+	) as StoredProviderSettingsLike;
+}
+
+function readStoredSettings(providerId: string): Record<string, unknown> {
+	const stored = readProviderSettingsFile();
+	const settings = stored?.providers?.[providerId]?.settings;
+	return readObject(settings);
+}
+
+function firstString(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		const text = readString(value);
+		if (text) {
+			return text;
+		}
+	}
+	return undefined;
+}
+
+function readEnvironmentApiKey(providerId: string): string | undefined {
+	switch (providerId) {
+		case "anthropic":
+			return readString(process.env.ANTHROPIC_API_KEY);
+		case "cline":
+			return readString(process.env.CLINE_API_KEY);
+		default:
+			return undefined;
+	}
+}
+
+function formatApiKey(providerId: string, apiKey: string): string {
+	if (providerId === "cline" && !apiKey.startsWith("workos:")) {
+		return `workos:${apiKey}`;
+	}
+	return apiKey;
+}
+
+function createRecordingConfig(target: ProviderVcrTarget): ProviderConfig {
+	const settings = readStoredSettings(target.providerId);
+	const auth = readObject(settings.auth);
+	const apiKey = firstString(
+		auth.accessToken,
+		settings.apiKey,
+		auth.apiKey,
+		readEnvironmentApiKey(target.providerId),
+	);
+	if (!apiKey) {
+		throw new Error(
+			`Provider VCR record mode needs saved settings or env credentials for ${target.providerId}`,
+		);
+	}
+	const headers = readStringRecord(settings.headers) ?? {};
+	const accountId = readString(auth.accountId);
+	if (
+		target.providerId === "openai-codex" &&
+		accountId &&
+		!headers["ChatGPT-Account-Id"]
+	) {
+		headers["ChatGPT-Account-Id"] = accountId;
+	}
+	return {
+		providerId: target.providerId,
+		modelId: target.modelId,
+		apiKey: formatApiKey(target.providerId, apiKey),
+		baseUrl: readString(settings.baseUrl),
+		headers: Object.keys(headers).length > 0 ? headers : undefined,
+	};
+}
+
+function createProviderConfig(target: ProviderVcrTarget): ProviderConfig {
+	return RECORD_MODE ? createRecordingConfig(target) : target.playbackConfig;
+}
+
+async function runProviderSmoke(config: ProviderConfig): Promise<{
+	text: string;
+	doneSeen: boolean;
+	usageSeen: boolean;
+}> {
+	const handler = await createHandlerAsync(config);
+	let text = "";
+	let doneSeen = false;
+	let usageSeen = false;
+
+	for await (const chunk of handler.createMessage(SYSTEM_PROMPT, [
+		{ role: "user", content: USER_PROMPT },
+	])) {
+		if (chunk.type === "text") {
+			text += chunk.text;
+		}
+		if (chunk.type === "usage") {
+			usageSeen = true;
+		}
+		if (chunk.type === "done") {
+			doneSeen = true;
+			expect(chunk.success).toBe(true);
+		}
+	}
+
+	return { text, doneSeen, usageSeen };
+}
+
+function configureVcr(cassettePath: string): void {
+	activeCassettePath = cassettePath;
+	activeCassetteOriginalContents =
+		RECORD_MODE && existsSync(cassettePath)
+			? readFileSync(cassettePath, "utf8")
+			: undefined;
+	activeCassetteSucceeded = false;
+	assertPlaybackCassetteHasRequestContracts(cassettePath);
+	process.env.CLINE_VCR = RECORD_MODE ? "record" : "playback";
+	process.env.CLINE_VCR_CASSETTE = cassettePath;
+	process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+	process.env.CLINE_VCR_FILTER = "";
+	initVcr(process.env.CLINE_VCR);
+}
+
+function keepRecordedCassette(): void {
+	activeCassetteSucceeded = true;
+}
+
+interface MutableVcrRecording {
+	requestBody?: unknown;
+	response?: unknown;
+	[key: string]: unknown;
+}
+
+function toMutableRecording(input: unknown): MutableVcrRecording | undefined {
+	return input && typeof input === "object" && !Array.isArray(input)
+		? (input as MutableVcrRecording)
+		: undefined;
+}
+
+function readCassette(cassettePath: string): unknown[] {
+	const parsed = JSON.parse(readFileSync(cassettePath, "utf8")) as unknown;
+	if (!Array.isArray(parsed)) {
+		throw new Error(`Provider VCR cassette must be an array: ${cassettePath}`);
+	}
+	return parsed;
+}
+
+function assertPlaybackCassetteHasRequestContracts(cassettePath: string): void {
+	if (RECORD_MODE) {
+		return;
+	}
+	const recordings = readCassette(cassettePath);
+	for (const [index, input] of recordings.entries()) {
+		const recording = toMutableRecording(input);
+		if (typeof recording?.requestBody !== "string") {
+			throw new Error(
+				`Provider VCR cassette entry ${index} is missing requestBody: ${cassettePath}`,
+			);
+		}
+	}
+}
+
+const PROVIDER_RESPONSE_ID_KEYS = new Set([
+	"id",
+	"item_id",
+	"response_id",
+	"call_id",
+	"previous_response_id",
+	"generationId",
+	"providerRequestId",
+	"providerResponseId",
+]);
+
+const PROVIDER_RESPONSE_REDACTED_KEYS = new Set([
+	"encrypted_content",
+	"safety_identifier",
+	"prompt_cache_key",
+	"obfuscation",
+	"system_fingerprint",
+	"planningReasoning",
+]);
+
+const PROVIDER_RESPONSE_ZEROED_KEYS = new Set([
+	"created",
+	"created_at",
+	"completed_at",
+	"startTime",
+	"endTime",
+]);
+
+function sanitizeProviderResponseValue(input: unknown): unknown {
+	if (Array.isArray(input)) {
+		return input.map(sanitizeProviderResponseValue);
+	}
+	if (!input || typeof input !== "object") {
+		return input;
+	}
+
+	const output: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(input)) {
+		if (PROVIDER_RESPONSE_ID_KEYS.has(key)) {
+			output[key] = "ID_REDACTED";
+			continue;
+		}
+		if (PROVIDER_RESPONSE_REDACTED_KEYS.has(key)) {
+			output[key] = "REDACTED";
+			continue;
+		}
+		if (PROVIDER_RESPONSE_ZEROED_KEYS.has(key) && typeof value === "number") {
+			output[key] = 0;
+			continue;
+		}
+		output[key] = sanitizeProviderResponseValue(value);
+	}
+	return output;
+}
+
+function sanitizeProviderResponseEventLine(input: string): string {
+	const prefix = "data: ";
+	if (!input.startsWith(prefix)) {
+		return input;
+	}
+	const body = input.slice(prefix.length);
+	if (body === "[DONE]") {
+		return input;
+	}
+	try {
+		return `${prefix}${JSON.stringify(
+			sanitizeProviderResponseValue(JSON.parse(body) as unknown),
+		)}`;
+	} catch {
+		return input;
+	}
+}
+
+function sanitizeProviderResponseJsonText(input: string): string | undefined {
+	try {
+		const parsed: unknown = JSON.parse(input);
+		return JSON.stringify(sanitizeProviderResponseValue(parsed));
+	} catch {
+		return undefined;
+	}
+}
+
+function sanitizeProviderResponseEvents(input: string): string {
+	return input.split("\n").map(sanitizeProviderResponseEventLine).join("\n");
+}
+
+function sanitizeProviderResponseText(input: string): string {
+	return (
+		sanitizeProviderResponseJsonText(input) ??
+		sanitizeProviderResponseEvents(input)
+	);
+}
+
+function scrubRecordedCassette(cassettePath: string): void {
+	if (!RECORD_MODE || !existsSync(cassettePath)) {
+		return;
+	}
+	const recordings = readCassette(cassettePath).map((input) => {
+		const recording = toMutableRecording(input);
+		if (!recording || typeof recording.response !== "string") {
+			return input;
+		}
+		return {
+			...recording,
+			response: sanitizeProviderResponseText(recording.response),
+		};
+	});
+	writeFileSync(cassettePath, `${JSON.stringify(recordings, null, 2)}\n`);
+}
+
+afterEach(async () => {
+	const cassettePath = activeCassettePath;
+	const originalContents = activeCassetteOriginalContents;
+	const shouldKeepCassette = activeCassetteSucceeded;
+	try {
+		await disposeAll();
+	} finally {
+		if (cassettePath && RECORD_MODE) {
+			if (shouldKeepCassette) {
+				scrubRecordedCassette(cassettePath);
+			} else if (originalContents !== undefined) {
+				writeFileSync(cassettePath, originalContents);
+			} else if (existsSync(cassettePath)) {
+				unlinkSync(cassettePath);
+			}
+		}
+		activeCassettePath = undefined;
+		activeCassetteOriginalContents = undefined;
+		activeCassetteSucceeded = false;
+		process.env = { ...ORIGINAL_ENV };
+		globalThis.fetch = ORIGINAL_FETCH;
+	}
+});
+
+describe.sequential("provider VCR smoke tests", () => {
+	if (selectedTargets.length === 0) {
+		it("has a selected provider target", () => {
+			throw new Error(
+				`No provider VCR target matches LLMS_PROVIDER_VCR_TARGET=${TARGET_FILTER}`,
+			);
+		});
+	}
+
+	for (const target of selectedTargets) {
+		it(
+			`replays ${target.label}`,
+			async () => {
+				const cassettePath = join(fixturesDir, target.cassetteName);
+				configureVcr(cassettePath);
+
+				const result = await runProviderSmoke(createProviderConfig(target));
+
+				expect(result.text).toBe("OK");
+				expect(result.usageSeen).toBe(true);
+				expect(result.doneSeen).toBe(true);
+				keepRecordedCassette();
+			},
+			RECORD_MODE ? 120_000 : 15_000,
+		);
+	}
+});
diff --git a/sdk/packages/llms/src/tests/provider-vcr/README.md b/sdk/packages/llms/src/tests/provider-vcr/README.md
new file mode 100644
index 0000000..4d6c9cb
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-vcr/README.md
@@ -0,0 +1,31 @@
+# Provider VCR fixtures
+
+These cassettes exercise the real provider adapters in `@cline/llms` without
+requiring credentials during normal test runs.
+
+Run playback from `sdk/`:
+
+```sh
+bun -F @cline/llms test:vcr
+```
+
+Refresh the cassettes from local provider credentials:
+
+```sh
+LLMS_PROVIDER_VCR_RECORD=1 bun -F @cline/llms test:vcr
+```
+
+Refresh one cassette by provider id or cassette name:
+
+```sh
+LLMS_PROVIDER_VCR_RECORD=1 LLMS_PROVIDER_VCR_TARGET=cline bun -F @cline/llms test:vcr
+```
+
+Record mode prefers the normal Cline CLI provider settings path. To use another
+file, set `LLMS_PROVIDER_VCR_SETTINGS_PATH=/path/to/providers.json`.
+`ANTHROPIC_API_KEY` and `CLINE_API_KEY` can be used without a settings file, but
+ChatGPT OAuth needs saved `openai-codex` provider settings. For local Cline API
+recording, also set `CLINE_ENVIRONMENT=local`.
+
+After recording, the test normalizes dynamic response fields such as response
+IDs, encrypted reasoning payloads, prompt cache keys, and safety identifiers.
diff --git a/sdk/packages/llms/src/tests/provider-vcr/anthropic-claude-sonnet-4-6.json b/sdk/packages/llms/src/tests/provider-vcr/anthropic-claude-sonnet-4-6.json
new file mode 100644
index 0000000..8a33124
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-vcr/anthropic-claude-sonnet-4-6.json
@@ -0,0 +1,12 @@
+[
+	{
+		"scope": "https://api.anthropic.com",
+		"method": "POST",
+		"path": "/v1/messages",
+		"status": 200,
+		"response": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"model\":\"claude-sonnet-4-6\",\"id\":\"ID_REDACTED\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"stop_details\":null,\"usage\":{\"input_tokens\":22,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":1,\"service_tier\":\"standard\",\"inference_geo\":\"global\"}}}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"OK\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"stop_details\":null},\"usage\":{\"input_tokens\":22,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":4}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream; charset=utf-8",
+		"requestBody": "{\"max_tokens\":128000,\"messages\":[{\"content\":[{\"cache_control\":{\"type\":\"ephemeral\"},\"text\":\"Reply with the single word OK.\",\"type\":\"text\"}],\"role\":\"user\"}],\"model\":\"claude-sonnet-4-6\",\"stream\":true,\"system\":[{\"text\":\"You are a concise assistant.\",\"type\":\"text\"}]}"
+	}
+]
diff --git a/sdk/packages/llms/src/tests/provider-vcr/cline-anthropic-sonnet.json b/sdk/packages/llms/src/tests/provider-vcr/cline-anthropic-sonnet.json
new file mode 100644
index 0000000..843d93a
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-vcr/cline-anthropic-sonnet.json
@@ -0,0 +1,12 @@
+[
+	{
+		"scope": "https://api.cline.bot",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": "data: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"REDACTED\"}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"OK\"},\"logprobs\":null,\"finish_reason\":null}],\"system_fingerprint\":\"REDACTED\"}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"anthropic/claude-sonnet-4.6\",\"choices\":[{\"index\":0,\"delta\":{\"provider_metadata\":{\"anthropic\":{\"usage\":{\"input_tokens\":22,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":4,\"service_tier\":\"standard\",\"inference_geo\":\"global\"},\"cacheCreationInputTokens\":0,\"stopSequence\":null,\"iterations\":null,\"container\":null,\"contextManagement\":null},\"gateway\":{\"routing\":{\"originalModelId\":\"anthropic/claude-sonnet-4.6\",\"resolvedProvider\":\"anthropic\",\"fallbacksAvailable\":[\"vertexAnthropic\",\"bedrock\"],\"planningReasoning\":\"REDACTED\",\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"finalProvider\":\"anthropic\",\"modelAttemptCount\":1,\"modelAttempts\":[{\"canonicalSlug\":\"anthropic/claude-sonnet-4.6\",\"success\":true,\"providerAttemptCount\":1,\"providerAttempts\":[{\"provider\":\"anthropic\",\"credentialType\":\"byok\",\"success\":true,\"startTime\":0,\"endTime\":0,\"providerRequestId\":\"ID_REDACTED\",\"statusCode\":200,\"providerResponseId\":\"ID_REDACTED\"}]}],\"totalProviderAttemptCount\":1},\"cost\":\"0\",\"marketCost\":\"0.000126\",\"surchargeCost\":\"0\",\"gatewayCost\":\"0\",\"generationId\":\"ID_REDACTED\"}}},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":22,\"completion_tokens\":4,\"total_tokens\":26,\"cost\":0,\"is_byok\":true,\"prompt_tokens_details\":{\"cached_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.000126,\"upstream_inference_prompt_cost\":0,\"upstream_inference_completions_cost\":0},\"completion_tokens_details\":{\"reasoning_tokens\":0,\"image_tokens\":0},\"cache_creation_input_tokens\":0,\"market_cost\":0.000126},\"system_fingerprint\":\"REDACTED\",\"generationId\":\"ID_REDACTED\"}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream",
+		"requestBody": "{\"cache_control\":{\"type\":\"ephemeral\"},\"messages\":[{\"content\":\"You are a concise assistant.\",\"role\":\"system\"},{\"cache_control\":{\"type\":\"ephemeral\"},\"content\":\"Reply with the single word OK.\",\"role\":\"user\"}],\"model\":\"anthropic/claude-sonnet-4.6\",\"stream\":true,\"stream_options\":{\"include_usage\":true}}"
+	}
+]
diff --git a/sdk/packages/llms/src/tests/provider-vcr/openai-codex-gpt-5-4.json b/sdk/packages/llms/src/tests/provider-vcr/openai-codex-gpt-5-4.json
new file mode 100644
index 0000000..547647e
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-vcr/openai-codex-gpt-5-4.json
@@ -0,0 +1,11 @@
+[
+	{
+		"scope": "https://chatgpt.com",
+		"method": "POST",
+		"path": "/backend-api/codex/responses",
+		"status": 200,
+		"response": "event: response.created\ndata: {\"type\":\"response.created\",\"response\":{\"id\":\"ID_REDACTED\",\"object\":\"response\",\"created_at\":0,\"status\":\"in_progress\",\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0,\"incomplete_details\":null,\"instructions\":\"You are a concise assistant.\",\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5.4\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0,\"previous_response_id\":\"ID_REDACTED\",\"prompt_cache_key\":\"REDACTED\",\"prompt_cache_retention\":\"24h\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"none\",\"summary\":null},\"safety_identifier\":\"REDACTED\",\"service_tier\":\"auto\",\"store\":false,\"temperature\":1,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":\"auto\",\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[],\"top_logprobs\":0,\"top_p\":0.98,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":0}\n\nevent: response.in_progress\ndata: {\"type\":\"response.in_progress\",\"response\":{\"id\":\"ID_REDACTED\",\"object\":\"response\",\"created_at\":0,\"status\":\"in_progress\",\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0,\"incomplete_details\":null,\"instructions\":\"You are a concise assistant.\",\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5.4\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0,\"previous_response_id\":\"ID_REDACTED\",\"prompt_cache_key\":\"REDACTED\",\"prompt_cache_retention\":\"24h\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"none\",\"summary\":null},\"safety_identifier\":\"REDACTED\",\"service_tier\":\"auto\",\"store\":false,\"temperature\":1,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":\"auto\",\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[],\"top_logprobs\":0,\"top_p\":0.98,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":1}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"ID_REDACTED\",\"type\":\"message\",\"status\":\"in_progress\",\"content\":[],\"phase\":\"final_answer\",\"role\":\"assistant\"},\"output_index\":0,\"sequence_number\":2}\n\nevent: response.content_part.added\ndata: {\"type\":\"response.content_part.added\",\"content_index\":0,\"item_id\":\"ID_REDACTED\",\"output_index\":0,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"},\"sequence_number\":3}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"content_index\":0,\"delta\":\"OK\",\"item_id\":\"ID_REDACTED\",\"logprobs\":[],\"obfuscation\":\"REDACTED\",\"output_index\":0,\"sequence_number\":4}\n\nevent: response.output_text.done\ndata: {\"type\":\"response.output_text.done\",\"content_index\":0,\"item_id\":\"ID_REDACTED\",\"logprobs\":[],\"output_index\":0,\"sequence_number\":5,\"text\":\"OK\"}\n\nevent: response.content_part.done\ndata: {\"type\":\"response.content_part.done\",\"content_index\":0,\"item_id\":\"ID_REDACTED\",\"output_index\":0,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"OK\"},\"sequence_number\":6}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"ID_REDACTED\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"OK\"}],\"phase\":\"final_answer\",\"role\":\"assistant\"},\"output_index\":0,\"sequence_number\":7}\n\nevent: response.completed\ndata: {\"type\":\"response.completed\",\"response\":{\"id\":\"ID_REDACTED\",\"object\":\"response\",\"created_at\":0,\"status\":\"completed\",\"background\":false,\"completed_at\":0,\"error\":null,\"frequency_penalty\":0,\"incomplete_details\":null,\"instructions\":\"You are a concise assistant.\",\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5.4\",\"moderation\":null,\"output\":[{\"id\":\"ID_REDACTED\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"OK\"}],\"phase\":\"final_answer\",\"role\":\"assistant\"}],\"parallel_tool_calls\":true,\"presence_penalty\":0,\"previous_response_id\":\"ID_REDACTED\",\"prompt_cache_key\":\"REDACTED\",\"prompt_cache_retention\":\"24h\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"none\",\"summary\":null},\"safety_identifier\":\"REDACTED\",\"service_tier\":\"default\",\"store\":false,\"temperature\":1,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":\"auto\",\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[],\"top_logprobs\":0,\"top_p\":0.98,\"truncation\":\"disabled\",\"usage\":{\"input_tokens\":23,\"input_tokens_details\":{\"cached_tokens\":0},\"output_tokens\":5,\"output_tokens_details\":{\"reasoning_tokens\":0},\"total_tokens\":28},\"user\":null,\"metadata\":{}},\"sequence_number\":8}\n\n",
+		"responseIsBinary": false,
+		"requestBody": "{\"include\":[\"reasoning.encrypted_content\"],\"input\":[{\"content\":[{\"text\":\"Reply with the single word OK.\",\"type\":\"input_text\"}],\"role\":\"user\"}],\"instructions\":\"You are a concise assistant.\",\"model\":\"gpt-5.4\",\"store\":false,\"stream\":true}"
+	}
+]
diff --git a/sdk/packages/llms/src/tests/provider-vcr/openai-compatible-deepseek-v4-pro.json b/sdk/packages/llms/src/tests/provider-vcr/openai-compatible-deepseek-v4-pro.json
new file mode 100644
index 0000000..389acfa
--- /dev/null
+++ b/sdk/packages/llms/src/tests/provider-vcr/openai-compatible-deepseek-v4-pro.json
@@ -0,0 +1,12 @@
+[
+	{
+		"scope": "https://openrouter.ai",
+		"method": "POST",
+		"path": "/api/v1/chat/completions",
+		"status": 200,
+		"response": ": OPENROUTER PROCESSING\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\"We\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"We\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" are\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" are\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" asked: \\\"Reply with\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" asked: \\\"Reply with\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" the single word OK.\\\"\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" the single word OK.\\\"\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" So I just need to\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" So I just need to\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" output \\\"OK\\\". No\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" output \\\"OK\\\". No\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" other text.\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" other text.\",\"format\":\"unknown\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"OK\",\"role\":\"assistant\"},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":null},\"finish_reason\":\"stop\",\"native_finish_reason\":\"stop\"}]}\n\ndata: {\"id\":\"ID_REDACTED\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"deepseek/deepseek-v4-pro-20260423\",\"provider\":\"Alibaba\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\"},\"finish_reason\":\"stop\",\"native_finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":17,\"completion_tokens\":28,\"total_tokens\":45,\"cost\":0.00012264,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":0,\"cache_write_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.00012264,\"upstream_inference_prompt_cost\":0.00002856,\"upstream_inference_completions_cost\":0.00009408},\"completion_tokens_details\":{\"reasoning_tokens\":25,\"image_tokens\":0,\"audio_tokens\":0}}}\n\ndata: [DONE]\n\n",
+		"responseIsBinary": false,
+		"contentType": "text/event-stream",
+		"requestBody": "{\"messages\":[{\"content\":\"You are a concise assistant.\",\"role\":\"system\"},{\"content\":\"Reply with the single word OK.\",\"role\":\"user\"}],\"model\":\"deepseek/deepseek-v4-pro\",\"stream\":true,\"stream_options\":{\"include_usage\":true}}"
+	}
+]
diff --git a/sdk/packages/llms/tsconfig.build.json b/sdk/packages/llms/tsconfig.build.json
new file mode 100644
index 0000000..ad92b25
--- /dev/null
+++ b/sdk/packages/llms/tsconfig.build.json
@@ -0,0 +1,19 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": false,
+		"emitDeclarationOnly": true,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"incremental": false
+	},
+	"include": [
+		"src/index.ts",
+		"src/index.browser.ts",
+		"src/models.ts",
+		"src/providers.ts",
+		"src/providers.browser.ts"
+	]
+}
diff --git a/sdk/packages/llms/tsconfig.dev.json b/sdk/packages/llms/tsconfig.dev.json
new file mode 100644
index 0000000..05b7806
--- /dev/null
+++ b/sdk/packages/llms/tsconfig.dev.json
@@ -0,0 +1,12 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"baseUrl": ".",
+		"rootDir": "..",
+		"paths": {
+			"@cline/agents": ["../agents/src/index.ts"],
+			"@cline/shared": ["../shared/src/index.ts"],
+			"@cline/shared/*": ["../shared/src/*", "../shared/src/*/index.ts"]
+		}
+	}
+}
diff --git a/sdk/packages/llms/tsconfig.json b/sdk/packages/llms/tsconfig.json
new file mode 100644
index 0000000..a819923
--- /dev/null
+++ b/sdk/packages/llms/tsconfig.json
@@ -0,0 +1,11 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"incremental": true,
+		"tsBuildInfoFile": "./node_modules/.cache/tsconfig.tsbuildinfo"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "**/*.test.ts", "fixtures"]
+}
diff --git a/sdk/packages/llms/vitest.config.ts b/sdk/packages/llms/vitest.config.ts
new file mode 100644
index 0000000..52d5ad2
--- /dev/null
+++ b/sdk/packages/llms/vitest.config.ts
@@ -0,0 +1,24 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+const rootDir = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+	resolve: {
+		alias: [
+			{
+				find: /^@cline\/shared\/(.+)$/,
+				replacement: resolve(rootDir, "../shared/src/$1"),
+			},
+			{
+				find: /^@cline\/shared$/,
+				replacement: resolve(rootDir, "../shared/src/index.ts"),
+			},
+		],
+	},
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts"],
+	},
+});
diff --git a/sdk/packages/sdk/bun.mts b/sdk/packages/sdk/bun.mts
new file mode 100644
index 0000000..ddbdf4b
--- /dev/null
+++ b/sdk/packages/sdk/bun.mts
@@ -0,0 +1,22 @@
+export {};
+
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+// minify: true keeps identifier mangling active even when sourcemaps are enabled.
+const minify = Bun.env.CLINE_SOURCEMAPS !== "1";
+
+const result = await Bun.build({
+	entrypoints: ["./src/index.ts"],
+	outdir: "./dist",
+	target: "node",
+	format: "esm",
+	packages: "bundle",
+	minify,
+	sourcemap,
+	external: ["@cline/core"],
+});
+
+if (result.logs.length > 0) {
+	for (const log of result.logs) {
+		console.warn(log);
+	}
+}
diff --git a/sdk/packages/sdk/package.json b/sdk/packages/sdk/package.json
new file mode 100644
index 0000000..d8316c4
--- /dev/null
+++ b/sdk/packages/sdk/package.json
@@ -0,0 +1,37 @@
+{
+	"name": "@cline/sdk",
+	"description": "Cline SDK - user-facing alias for @cline/core",
+	"version": "0.0.59",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline",
+		"directory": "sdk/packages/sdk"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"main": "./dist/index.js",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "bun run bun.mts && bun tsc -p tsconfig.build.json",
+		"typecheck": "bun tsc -p tsconfig.json --noEmit"
+	},
+	"dependencies": {
+		"@cline/core": "workspace:*"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"dist"
+	],
+	"license": "Apache-2.0"
+}
diff --git a/sdk/packages/sdk/src/index.ts b/sdk/packages/sdk/src/index.ts
new file mode 100644
index 0000000..863f12e
--- /dev/null
+++ b/sdk/packages/sdk/src/index.ts
@@ -0,0 +1 @@
+export * from "@cline/core";
diff --git a/sdk/packages/sdk/tsconfig.build.json b/sdk/packages/sdk/tsconfig.build.json
new file mode 100644
index 0000000..050a6fc
--- /dev/null
+++ b/sdk/packages/sdk/tsconfig.build.json
@@ -0,0 +1,12 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"sourceMap": false,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"incremental": false
+	},
+	"include": ["src/index.ts"]
+}
diff --git a/sdk/packages/sdk/tsconfig.json b/sdk/packages/sdk/tsconfig.json
new file mode 100644
index 0000000..62aad1a
--- /dev/null
+++ b/sdk/packages/sdk/tsconfig.json
@@ -0,0 +1,11 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"sourceMap": false,
+		"emitDeclarationOnly": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}
diff --git a/sdk/packages/shared/README.md b/sdk/packages/shared/README.md
new file mode 100644
index 0000000..538ba4f
--- /dev/null
+++ b/sdk/packages/shared/README.md
@@ -0,0 +1,47 @@
+# [experimental] @cline/shared
+
+Package-level docs are centralized:
+
+- Overview: [`packages/README.md`](../README.md)
+- Architecture and interactions: [`ARCHITECTURE.md`](./ARCHITECTURE.md)
+
+`@cline/shared` owns shared cross-package primitives (session common types/utilities).
+
+Node-only filesystem path resolvers live under the storage subpath export:
+
+- `@cline/shared/storage`
+- examples: `resolveClineDataDir`, `resolveDbDataDir`, `resolveSessionDataDir`, `resolveTeamDataDir`
+
+It also exports cross-client logging contracts, including `BasicLogger`, so
+runtime, SDK, and host applications can share a single logger type.
+
+Session config primitives are also centralized here so hosts/runtimes can
+compose one base shape instead of redefining similar fields repeatedly:
+
+- `AgentMode`
+- `SessionPromptConfig`
+- `SessionWorkspaceConfig`
+- `SessionExecutionConfig` (includes canonical `ToolPolicy` map shape)
+
+It now also exports hook session context primitives used across agents/core/CLI:
+
+- `HookSessionContext`
+- `resolveHookSessionContext(...)`
+- `resolveRootSessionId(...)`
+- `resolveHookLogPath(...)`
+
+It also exports cross-client runtime payload DTOs used by multiple hosts
+(`@cline/cli`, `@cline/code`) so request/response contracts are not duplicated
+outside transport wiring:
+
+- chat runtime payloads (`ChatStartSessionRequest`, `ChatRunTurnRequest`, `ChatTurnResult`)
+- provider runtime payloads (`ProviderActionRequest`, `ProviderCatalogResponse`, `ProviderOAuthLoginResponse`)
+- Cline account action payloads (`ClineAccountActionRequest`)
+- provider action requests include provider catalog/model operations plus provider add/save operations for settings hosts
+- provider action payloads now expose granular request/type contracts for reuse:
+  `AddProviderActionRequest`, `SaveProviderSettingsActionRequest`,
+  `ProviderCapability`, and `OAuthProviderId`
+
+Chat runtime payload notes:
+- `ChatStartSessionRequest` supports `initialMessages`, optional `toolPolicies`, optional `rules` for default system prompt assembly, and optional `logger` runtime config (`RuntimeLoggerConfig`) so hosts can pass serialized logger settings across transport boundaries.
+- `RuntimeLoggerConfig.bindings` lets hosts attach stable context fields (for example `clientId`, `clientType`, `clientApp`) to all runtime log records.
diff --git a/sdk/packages/shared/bun.mts b/sdk/packages/shared/bun.mts
new file mode 100644
index 0000000..6f74d1c
--- /dev/null
+++ b/sdk/packages/shared/bun.mts
@@ -0,0 +1,72 @@
+/// <reference types="@types/bun" />
+export {};
+
+type BuildMode = "package" | "bundle" | "dev";
+const rawMode = Bun.env.BUILD_MODE ?? "bundle";
+const buildMode: BuildMode =
+	rawMode === "bundle" || rawMode === "dev" ? rawMode : "package";
+
+const shouldEmitTypes = buildMode === "package";
+const sourcemap = Bun.env.CLINE_SOURCEMAPS === "1" ? "linked" : "none";
+// minify: true keeps identifier mangling active even when sourcemaps are enabled.
+const minify = Bun.env.CLINE_SOURCEMAPS !== "1";
+
+const runBuild = async (
+	name: string,
+	options: Parameters<typeof Bun.build>[0],
+) => {
+	const result = await Bun.build({
+		...options,
+		throw: false,
+	});
+
+	if (!result.success) {
+		throw new Error(`Failed ${name} build`);
+	}
+
+	if (result.logs.length > 0) {
+		console.warn(`${name} build emitted logs:`);
+		for (const log of result.logs) {
+			console.warn(log);
+		}
+	}
+};
+
+await runBuild("node", {
+	entrypoints: [
+		"./src/index.ts",
+		"./src/automation/index.ts",
+		"./src/db/index.ts",
+		"./src/remote-config/index.ts",
+		"./src/storage/index.ts",
+	],
+	outdir: "./dist",
+	target: "node",
+	minify,
+	sourcemap,
+});
+
+await runBuild("browser", {
+	entrypoints: ["./src/index.browser.ts"],
+	outdir: "./dist",
+	target: "browser",
+	minify,
+	sourcemap,
+	packages: "bundle",
+	external: ["zod"],
+});
+
+if (shouldEmitTypes) {
+	const tsc = Bun.spawn(
+		["bun", "tsc", "--emitDeclarationOnly", "--project", "tsconfig.build.json"],
+		{
+			stdout: "inherit",
+			stderr: "inherit",
+		},
+	);
+
+	const exitCode = await tsc.exited;
+	if (exitCode !== 0) {
+		throw new Error(`Declaration build failed with exit code ${exitCode}`);
+	}
+}
diff --git a/sdk/packages/shared/package.json b/sdk/packages/shared/package.json
new file mode 100644
index 0000000..a55e4b0
--- /dev/null
+++ b/sdk/packages/shared/package.json
@@ -0,0 +1,63 @@
+{
+	"name": "@cline/shared",
+	"version": "0.0.59",
+	"description": "Shared utilities, types, and schemas for Cline packages",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline",
+		"directory": "sdk/packages/shared"
+	},
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"browser": "./dist/index.browser.js",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./browser": {
+			"types": "./dist/index.browser.d.ts",
+			"import": "./dist/index.browser.js"
+		},
+		"./types": {
+			"types": "./dist/types/index.d.ts",
+			"import": "./dist/types/index.js"
+		},
+		"./storage": {
+			"types": "./dist/storage/index.d.ts",
+			"import": "./dist/storage/index.js"
+		},
+		"./db": {
+			"types": "./dist/db/index.d.ts",
+			"import": "./dist/db/index.js"
+		},
+		"./automation": {
+			"types": "./dist/automation/index.d.ts",
+			"import": "./dist/automation/index.js"
+		},
+		"./remote-config": {
+			"types": "./dist/remote-config/index.d.ts",
+			"import": "./dist/remote-config/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "BUILD_MODE=package bun bun.mts",
+		"typecheck": "bun tsc --noEmit",
+		"test": "bun run test:unit",
+		"test:unit": "vitest run --config vitest.config.ts"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"dependencies": {
+		"aws4fetch": "^1.0.20",
+		"jsonrepair": "^3.13.2",
+		"zod": "^4.3.6",
+		"zod-to-json-schema": "^3.25.1"
+	}
+}
diff --git a/sdk/packages/shared/src/agent.ts b/sdk/packages/shared/src/agent.ts
new file mode 100644
index 0000000..fd10325
--- /dev/null
+++ b/sdk/packages/shared/src/agent.ts
@@ -0,0 +1,566 @@
+/**
+ * AgentRuntime contract types (ported from clinee `@cline/shared`).
+ *
+ * These are the canonical type definitions consumed by `AgentRuntime`.
+ *
+ */
+
+import type { ModelInfo } from "./llms/model-info";
+import type {
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	ToolPolicy,
+} from "./llms/tools";
+import type { BasicLogger } from "./logging/logger";
+import type { ITelemetryService } from "./services/telemetry";
+
+// =============================================================================
+// Lightweight telemetry surface used by AgentRuntime
+// =============================================================================
+
+// =============================================================================
+// Message parts
+// =============================================================================
+
+export interface AgentTextPart {
+	type: "text";
+	text: string;
+}
+
+export interface AgentReasoningPart {
+	type: "reasoning";
+	text: string;
+	redacted?: boolean;
+	metadata?: unknown;
+}
+
+export interface AgentImagePart {
+	type: "image";
+	image: string | Uint8Array | ArrayBuffer | URL;
+	mediaType?: string;
+}
+
+export interface AgentFilePart {
+	type: "file";
+	path: string;
+	content: string;
+}
+
+export interface AgentToolCallPart {
+	type: "tool-call";
+	toolCallId: string;
+	toolName: string;
+	input: unknown;
+	metadata?: unknown;
+}
+
+export interface AgentToolResultPart {
+	type: "tool-result";
+	toolCallId: string;
+	toolName: string;
+	output: unknown;
+	isError?: boolean;
+}
+
+export type AgentMessagePart =
+	| AgentTextPart
+	| AgentReasoningPart
+	| AgentImagePart
+	| AgentFilePart
+	| AgentToolCallPart
+	| AgentToolResultPart;
+
+// =============================================================================
+// Messages and token usage
+// =============================================================================
+
+export type AgentMessageRole = "user" | "assistant" | "tool";
+
+export interface AgentTokenUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	/** Provider-reported hidden reasoning tokens, when available. */
+	reasoningTokenCount?: number;
+}
+
+/**
+ * Canonical `AgentUsage` shape for the new runtime.
+ *
+ * This supersedes the legacy `AgentUsage` (now `LegacyAgentUsage` in
+ * `./agents/types`). The old, host-facing shape is
+ * retained for `AgentResult`/`AgentUsageEvent` consumers via the facade.
+ */
+export interface AgentUsage extends AgentTokenUsage {
+	totalCost?: number;
+}
+
+export interface AgentMessage {
+	id: string;
+	role: AgentMessageRole;
+	content: AgentMessagePart[];
+	createdAt: number;
+	metadata?: Record<string, unknown>;
+	modelInfo?: {
+		id: string;
+		provider: string;
+		family?: string;
+	};
+	metrics?: AgentTokenUsage & {
+		cost?: number;
+	};
+}
+
+// =============================================================================
+// Runtime state
+// =============================================================================
+
+export type AgentRole = string;
+
+export type AgentRunStatus =
+	| "idle"
+	| "running"
+	| "completed"
+	| "aborted"
+	| "failed";
+
+export interface AgentRuntimeStateSnapshot {
+	agentId: string;
+	agentRole?: AgentRole;
+	parentAgentId?: string | null;
+	conversationId?: string;
+	runId?: string;
+	status: AgentRunStatus;
+	iteration: number;
+	messages: readonly AgentMessage[];
+	pendingToolCalls: readonly string[];
+	usage: AgentUsage;
+	lastError?: string;
+}
+
+// =============================================================================
+// Tools
+// =============================================================================
+
+export interface AgentToolDefinition {
+	name: string;
+	description: string;
+	inputSchema: Record<string, unknown>;
+	lifecycle?: {
+		/**
+		 * Whether a successful call to this tool completes the current run.
+		 */
+		completesRun?: boolean;
+	};
+}
+
+export interface AgentToolResult<TOutput = unknown> {
+	output: TOutput;
+	isError?: boolean;
+	metadata?: Record<string, unknown>;
+}
+
+export interface AgentToolContext {
+	sessionId?: string;
+	agentId: string;
+	conversationId?: string;
+	runId?: string;
+	iteration: number;
+	toolCallId?: string;
+	signal?: AbortSignal;
+	metadata?: Record<string, unknown>;
+	snapshot?: AgentRuntimeStateSnapshot;
+	emitUpdate?: (update: unknown) => void;
+}
+
+export interface AgentTool<TInput = unknown, TOutput = unknown>
+	extends AgentToolDefinition {
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+	execute: (
+		input: TInput,
+		context: AgentToolContext,
+	) => Promise<TOutput> | TOutput;
+}
+
+// =============================================================================
+// Model adapter contract
+// =============================================================================
+
+export interface AgentModelRequest {
+	systemPrompt?: string;
+	messages: readonly AgentMessage[];
+	tools: readonly AgentToolDefinition[];
+	signal?: AbortSignal;
+	options?: Record<string, unknown>;
+}
+
+export interface AgentRuntimePrepareTurnContext {
+	agentId: string;
+	conversationId?: string;
+	parentAgentId?: string | null;
+	iteration: number;
+	messages: readonly AgentMessage[];
+	systemPrompt?: string;
+	tools: readonly AgentToolDefinition[];
+	model: {
+		id?: string;
+		provider?: string;
+		info?: ModelInfo;
+	};
+	signal?: AbortSignal;
+	emitStatusNotice?: (
+		message: string,
+		metadata?: Record<string, unknown>,
+	) => void;
+}
+
+export interface AgentRuntimePrepareTurnResult {
+	messages?: readonly AgentMessage[];
+	systemPrompt?: string;
+}
+
+export type AgentModelFinishReason =
+	| "stop"
+	| "tool-calls"
+	| "max-tokens"
+	| "aborted"
+	| "error";
+
+export type AgentModelEvent =
+	| { type: "text-delta"; text: string }
+	| {
+			type: "reasoning-delta";
+			text: string;
+			redacted?: boolean;
+			metadata?: unknown;
+	  }
+	| {
+			type: "tool-call-delta";
+			index?: number;
+			toolCallId?: string;
+			toolName?: string;
+			inputText?: string;
+			input?: unknown;
+			metadata?: unknown;
+	  }
+	| {
+			type: "usage";
+			usage: Partial<AgentUsage>;
+	  }
+	| {
+			type: "finish";
+			reason: AgentModelFinishReason;
+			error?: string;
+	  };
+
+export interface AgentModel {
+	stream: (
+		request: AgentModelRequest,
+	) => AsyncIterable<AgentModelEvent> | Promise<AsyncIterable<AgentModelEvent>>;
+}
+
+// =============================================================================
+// Hook contexts
+// =============================================================================
+
+export interface AgentBeforeModelContext {
+	snapshot: AgentRuntimeStateSnapshot;
+	request: AgentModelRequest;
+}
+
+export interface AgentStopControl {
+	stop?: boolean;
+	reason?: string;
+}
+
+export interface AgentBeforeModelResult {
+	stop?: boolean;
+	reason?: string;
+	messages?: readonly AgentMessage[];
+	tools?: readonly AgentToolDefinition[];
+	options?: Record<string, unknown>;
+}
+
+export interface AgentAfterModelContext {
+	snapshot: AgentRuntimeStateSnapshot;
+	assistantMessage: AgentMessage;
+	finishReason: AgentModelFinishReason;
+}
+
+export interface AgentBeforeToolContext {
+	snapshot: AgentRuntimeStateSnapshot;
+	tool: AgentTool;
+	toolCall: AgentToolCallPart;
+	input: unknown;
+}
+
+export interface AgentBeforeToolResult {
+	skip?: boolean;
+	stop?: boolean;
+	reason?: string;
+	input?: unknown;
+	policy?: ToolPolicy;
+}
+
+export interface AgentAfterToolContext {
+	snapshot: AgentRuntimeStateSnapshot;
+	tool: AgentTool;
+	toolCall: AgentToolCallPart;
+	input: unknown;
+	result: AgentToolResult;
+	startedAt: Date;
+	endedAt: Date;
+	durationMs: number;
+}
+
+export interface AgentAfterToolResult {
+	stop?: boolean;
+	reason?: string;
+	result?: AgentToolResult;
+}
+
+export interface AgentRunLifecycleContext {
+	snapshot: AgentRuntimeStateSnapshot;
+}
+
+// =============================================================================
+// Runtime hook bag
+// =============================================================================
+
+/**
+ * 7-callback hook bag consumed by `AgentRuntime`.
+ */
+export interface AgentRuntimeHooks {
+	beforeRun?: (
+		context: AgentRunLifecycleContext,
+	) => AgentStopControl | undefined | Promise<AgentStopControl | undefined>;
+	afterRun?: (
+		context: AgentRunLifecycleContext & { result: AgentRunResult },
+	) => void | Promise<void>;
+	beforeModel?: (
+		context: AgentBeforeModelContext,
+	) =>
+		| AgentBeforeModelResult
+		| undefined
+		| Promise<AgentBeforeModelResult | undefined>;
+	afterModel?: (
+		context: AgentAfterModelContext,
+	) => AgentStopControl | undefined | Promise<AgentStopControl | undefined>;
+	beforeTool?: (
+		context: AgentBeforeToolContext,
+	) =>
+		| AgentBeforeToolResult
+		| undefined
+		| Promise<AgentBeforeToolResult | undefined>;
+	afterTool?: (
+		context: AgentAfterToolContext,
+	) =>
+		| AgentAfterToolResult
+		| undefined
+		| Promise<AgentAfterToolResult | undefined>;
+	onEvent?: (event: AgentRuntimeEvent) => void | Promise<void>;
+}
+
+// =============================================================================
+// Plugins
+// =============================================================================
+
+export interface AgentRuntimePluginContext {
+	agentId: string;
+	agentRole?: AgentRole;
+	systemPrompt?: string;
+}
+
+export interface AgentRuntimePluginSetup {
+	// biome-ignore lint/suspicious/noExplicitAny: tool input/output types vary per tool
+	tools?: readonly AgentTool<any, any>[];
+	hooks?: Partial<AgentRuntimeHooks>;
+}
+
+export interface AgentRuntimePlugin {
+	name: string;
+	setup?: (
+		context: AgentRuntimePluginContext,
+	) =>
+		| AgentRuntimePluginSetup
+		| undefined
+		| Promise<AgentRuntimePluginSetup | undefined>;
+}
+
+// =============================================================================
+// Runtime config
+// =============================================================================
+
+export interface AgentRuntimeConfig {
+	/**
+	 * Core/hub runtime session identifier.
+	 *
+	 * The host-owned lifecycle id for the task/session containing this runtime.
+	 * It is stable for hub subscriptions, session persistence, abort/stop
+	 * commands, and approval routing. It can differ from `conversationId`, which
+	 * tracks the agent transcript.
+	 */
+	sessionId?: string;
+	agentId?: string;
+	/**
+	 * Agent conversation/transcript identifier.
+	 *
+	 * Used by the stateless agent loop, tools, hooks, telemetry, and model
+	 * history correlation. This id follows the current conversation store and
+	 * should not be used as the hub/session routing key.
+	 */
+	conversationId?: string;
+	parentAgentId?: string | null;
+	agentRole?: AgentRole;
+	systemPrompt?: string;
+	messageModelInfo?: AgentMessage["modelInfo"];
+	model: AgentModel;
+	modelOptions?: Record<string, unknown>;
+	// biome-ignore lint/suspicious/noExplicitAny: tool input/output types vary per tool
+	tools?: readonly AgentTool<any, any>[];
+	hooks?: Partial<AgentRuntimeHooks>;
+	plugins?: readonly AgentRuntimePlugin[];
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+	initialMessages?: readonly AgentMessage[];
+	maxIterations?: number;
+	completionPolicy?: {
+		requireCompletionTool?: boolean;
+		completionGuard?: () => string | undefined;
+	};
+	toolExecution?: "sequential" | "parallel";
+	toolPolicies?: Record<string, ToolPolicy>;
+	toolContextMetadata?: Record<string, unknown>;
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+	/**
+	 * Optional host-owned request projection hook invoked before each model call.
+	 *
+	 * Returned messages affect only the provider request for the current call.
+	 * They do not replace the canonical runtime transcript, are not persisted as
+	 * session history, and are not reflected in AgentRunResult.messages.
+	 */
+	prepareTurn?: (
+		context: AgentRuntimePrepareTurnContext,
+	) =>
+		| Promise<AgentRuntimePrepareTurnResult | undefined>
+		| AgentRuntimePrepareTurnResult
+		| undefined;
+	// Optional host callback used by interactive sessions to inject a queued
+	// user steering message between agent loop iterations, before the next
+	// model request.
+	consumePendingUserMessage?: () =>
+		| string
+		| undefined
+		| Promise<string | undefined>;
+}
+
+// =============================================================================
+// Runtime event union (13 variants)
+// =============================================================================
+
+export type AgentRuntimeEvent =
+	| {
+			type: "run-started";
+			snapshot: AgentRuntimeStateSnapshot;
+	  }
+	| {
+			type: "message-added";
+			snapshot: AgentRuntimeStateSnapshot;
+			message: AgentMessage;
+	  }
+	| {
+			type: "turn-started";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+	  }
+	| {
+			type: "assistant-text-delta";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			text: string;
+			accumulatedText: string;
+	  }
+	| {
+			type: "assistant-reasoning-delta";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			text: string;
+			accumulatedText: string;
+			redacted?: boolean;
+			metadata?: unknown;
+	  }
+	| {
+			type: "assistant-message";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			message: AgentMessage;
+			finishReason: AgentModelFinishReason;
+	  }
+	| {
+			type: "tool-started";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			toolCall: AgentToolCallPart;
+	  }
+	| {
+			type: "tool-updated";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			toolCall: AgentToolCallPart;
+			update: unknown;
+	  }
+	| {
+			type: "tool-finished";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			toolCall: AgentToolCallPart;
+			message: AgentMessage;
+	  }
+	| {
+			type: "usage-updated";
+			snapshot: AgentRuntimeStateSnapshot;
+			usage: AgentUsage;
+	  }
+	| {
+			type: "turn-finished";
+			snapshot: AgentRuntimeStateSnapshot;
+			iteration: number;
+			toolCallCount: number;
+	  }
+	| {
+			type: "status-notice";
+			snapshot: AgentRuntimeStateSnapshot;
+			message: string;
+			metadata?: Record<string, unknown>;
+	  }
+	| {
+			type: "run-finished";
+			snapshot: AgentRuntimeStateSnapshot;
+			result: AgentRunResult;
+	  }
+	| {
+			type: "run-failed";
+			snapshot: AgentRuntimeStateSnapshot;
+			error: Error;
+	  };
+
+// =============================================================================
+// Run result
+// =============================================================================
+
+export interface AgentRunResult {
+	agentId: string;
+	agentRole?: AgentRole;
+	runId: string;
+	status: Exclude<AgentRunStatus, "idle" | "running">;
+	iterations: number;
+	outputText: string;
+	messages: readonly AgentMessage[];
+	usage: AgentUsage;
+	error?: Error;
+}
diff --git a/sdk/packages/shared/src/agents/index.ts b/sdk/packages/shared/src/agents/index.ts
new file mode 100644
index 0000000..eea524d
--- /dev/null
+++ b/sdk/packages/shared/src/agents/index.ts
@@ -0,0 +1 @@
+export * from "./types";
diff --git a/sdk/packages/shared/src/agents/types.ts b/sdk/packages/shared/src/agents/types.ts
new file mode 100644
index 0000000..be862f0
--- /dev/null
+++ b/sdk/packages/shared/src/agents/types.ts
@@ -0,0 +1,1063 @@
+/**
+ * Agent Types and Zod Schemas
+ *
+ * Canonical type definitions for agent configuration, events, hooks,
+ * extensions, and results.
+ *
+ * ProviderConfig is left as `unknown` here so that shared stays
+ * dependency-free of @cline/llms. Consuming packages narrow it
+ * via re-exports. ModelInfo lives in shared (../llms/model-info)
+ * and is used directly.
+ */
+
+import { z } from "zod";
+import type { AgentRuntimeHooks, AgentTool } from "../agent";
+import type { ExtensionContext } from "../extensions/context";
+import type {
+	AgentExtensionApi,
+	AgentExtensionHooks,
+	AgentExtensionRegistry as AgentExtensionRegistryGeneric,
+	ContributionRegistryExtension,
+	PluginManifest,
+	PluginSetupContext,
+} from "../extensions/contribution-registry";
+import type { HookControl } from "../hooks/contracts";
+import type { Message, MessageWithMetadata } from "../llms/messages";
+import type { ModelInfo } from "../llms/model-info";
+import { ModelInfoSchema } from "../llms/model-info";
+import type {
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	ToolCallRecord,
+	ToolPolicy,
+} from "../llms/tools";
+import { ToolCallRecordSchema } from "../llms/tools";
+import type { BasicLogger } from "../logging/logger";
+import type { ITelemetryService } from "../services/telemetry";
+import type { WorkspaceInfo } from "../session/workspace";
+
+// =============================================================================
+// Agent Events
+// =============================================================================
+
+/**
+ * Events emitted during agent execution
+ */
+export type AgentEvent =
+	| AgentContentStartEvent
+	| AgentContentUpdateEvent
+	| AgentContentEndEvent
+	| AgentIterationStartEvent
+	| AgentIterationEndEvent
+	| AgentNoticeEvent
+	| AgentUsageEvent
+	| AgentDoneEvent
+	| AgentErrorEvent;
+
+export type AgentContentType = "text" | "reasoning" | "tool";
+
+export interface AgentEventMetadata {
+	/** Current ID */
+	agentId?: string;
+	/** Task ID */
+	conversationId?: string;
+	/** ID of the agent that created this agent */
+	parentAgentId?: string | null;
+}
+
+export interface AgentContentStartEvent extends AgentEventMetadata {
+	type: "content_start";
+	contentType: AgentContentType;
+	/** The text chunk received from the model */
+	text?: string;
+	/** Accumulated text so far in this turn */
+	accumulated?: string;
+	/** The reasoning/thinking text from the model */
+	reasoning?: string;
+	/** Whether this is redacted reasoning */
+	redacted?: boolean;
+	/** Name of the tool being called */
+	toolName?: string;
+	/** Unique identifier for this tool call */
+	toolCallId?: string;
+	/** Input being passed to the tool */
+	input?: unknown;
+}
+
+export interface AgentContentUpdateEvent extends AgentEventMetadata {
+	type: "content_update";
+	contentType: "tool";
+	/** Name of the tool emitting progress */
+	toolName?: string;
+	/** Unique identifier for this tool call */
+	toolCallId?: string;
+	/** Partial result emitted by the tool */
+	update: unknown;
+}
+
+export interface AgentContentEndEvent extends AgentEventMetadata {
+	type: "content_end";
+	contentType: AgentContentType;
+	/** Final text generated for this turn */
+	text?: string;
+	/** Final reasoning/thinking text generated for this turn */
+	reasoning?: string;
+	/** Name of the tool that completed */
+	toolName?: string;
+	/** Unique identifier for this tool call */
+	toolCallId?: string;
+	/** Output from the tool */
+	output?: unknown;
+	/** Error message if the tool failed */
+	error?: string;
+	/** Time taken in milliseconds for tool content */
+	durationMs?: number;
+}
+
+export interface AgentIterationStartEvent extends AgentEventMetadata {
+	type: "iteration_start";
+	/** The iteration number (1-based) */
+	iteration: number;
+}
+
+export interface AgentIterationEndEvent extends AgentEventMetadata {
+	type: "iteration_end";
+	/** The iteration number that just completed */
+	iteration: number;
+	/** Whether this iteration had any tool calls */
+	hadToolCalls: boolean;
+	/** Number of tool calls in this iteration */
+	toolCallCount: number;
+}
+
+export interface AgentUsageEvent extends AgentEventMetadata {
+	type: "usage";
+	/** Number of input tokens for this turn */
+	inputTokens: number;
+	/** Number of output tokens for this turn */
+	outputTokens: number;
+	/** Tokens read from cache */
+	cacheReadTokens?: number;
+	/** Tokens written to cache */
+	cacheWriteTokens?: number;
+	/** Cost for this turn */
+	cost?: number;
+
+	/** Accumulated totals */
+	totalInputTokens: number;
+	totalCacheReadTokens?: number;
+	totalCacheWriteTokens?: number;
+	totalOutputTokens: number;
+	totalCost?: number;
+}
+
+export interface AgentNoticeEvent extends AgentEventMetadata {
+	type: "notice";
+	noticeType: "recovery" | "stop" | "status";
+	message: string;
+	displayRole?: "system" | "status";
+	reason?:
+		| "api_error"
+		| "invalid_tool_call"
+		| "completion_without_submit"
+		| "tool_execution_failed"
+		| "mistake_limit"
+		| "auto_compaction"
+		| "manual_compaction"
+		| "compaction_budget_emergency";
+	metadata?: Record<string, unknown>;
+}
+
+export interface AgentDoneEvent extends AgentEventMetadata {
+	type: "done";
+	/** The reason the agent stopped */
+	reason: AgentFinishReason;
+	/** Final text output */
+	text: string;
+	/** Total number of iterations */
+	iterations: number;
+	/** Aggregated usage information */
+	usage?: LegacyAgentUsage;
+}
+
+export interface AgentErrorEvent extends AgentEventMetadata {
+	type: "error";
+	/** The error that occurred */
+	error: Error;
+	/** Whether the error is recoverable */
+	recoverable: boolean;
+	/** Current iteration when error occurred */
+	iteration: number;
+}
+
+export interface ConsecutiveMistakeLimitContext {
+	iteration: number;
+	consecutiveMistakes: number;
+	maxConsecutiveMistakes: number;
+	reason: "api_error" | "invalid_tool_call" | "tool_execution_failed";
+	details?: string;
+}
+
+export type ConsecutiveMistakeLimitDecision =
+	| {
+			action: "continue";
+			/**
+			 * Optional guidance appended as a user message before continuing.
+			 */
+			guidance?: string;
+	  }
+	| {
+			action: "stop";
+			/**
+			 * Optional reason surfaced when stopping due to the limit.
+			 */
+			reason?: string;
+	  };
+
+export interface LoopDetectionConfig {
+	softThreshold: number;
+	hardThreshold: number;
+}
+
+export interface AgentExecutionConfig {
+	/**
+	 * Maximum consecutive internal mistakes before escalation.
+	 * Mistakes include API turn failures, invalid/missing tool-call arguments,
+	 * and iterations where every executed tool call fails.
+	 * @default 6
+	 */
+	maxConsecutiveMistakes?: number;
+	/**
+	 * After this many consecutive iterations with tool calls,
+	 * inject a reminder text block asking the agent to answer if it has enough info.
+	 * Set to `0` or omit to disable.
+	 * @default 0
+	 */
+	reminderAfterIterations?: number;
+	/**
+	 * Custom reminder text to inject after `reminderAfterIterations`.
+	 * @default "REMINDER: If you have gathered enough information to answer the user's question, please provide your final answer now without using any more tools."
+	 */
+	reminderText?: string;
+	/**
+	 * Repeated tool call loop detection. When enabled, the agent detects
+	 * consecutive identical tool calls and intervenes:
+	 * - At `softThreshold`: injects a recovery notice urging a different approach.
+	 * - At `hardThreshold`: triggers the consecutive-mistake-limit decision path.
+	 *
+	 * Set to `false` to explicitly disable. Omit or leave `undefined` for no detection.
+	 * The CLI enables this by default with `{ softThreshold: 3, hardThreshold: 5 }`.
+	 */
+	loopDetection?: false | Partial<LoopDetectionConfig>;
+}
+
+// =============================================================================
+// Hooks
+// =============================================================================
+
+/**
+ * Hook error handling behavior.
+ * - "ignore": swallow hook errors and continue agent execution
+ * - "throw": fail agent execution when a hook throws
+ */
+export type HookErrorMode = "ignore" | "throw";
+
+/**
+ * Common controls supported by lifecycle hooks.
+ */
+export type AgentHookControl = Omit<HookControl, "appendMessages"> & {
+	/**
+	 * Optional messages appended to history.
+	 * Primarily used by before-agent-start hook stages.
+	 */
+	appendMessages?: Message[];
+	/**
+	 * Optional replacement message history.
+	 * Primarily used by before-agent-start hooks and host-owned context pipelines.
+	 */
+	replaceMessages?: Message[];
+};
+
+export interface AgentHookRunStartContext {
+	/**
+	 * ID of the agent
+	 */
+	agentId: string;
+	/**
+	 * Session ID
+	 */
+	conversationId: string;
+	/**
+	 * ID of the agent that spawned the agent that is executing this run
+	 */
+	parentAgentId: string | null;
+	/**
+	 * The prompt submitted by user
+	 */
+	userMessage: string;
+}
+
+export interface AgentHookScheduleContext {
+	scheduleId: string;
+	executionId?: string;
+	trigger: "scheduled" | "manual";
+	triggeredAt?: string;
+}
+
+/**
+ * Workspace location fields shared by session-scoped and run-scoped contexts.
+ *
+ * These fields are always sourced from the host session config — never from
+ * `process.cwd()`. Plugins and hooks must use these values when they need to
+ * resolve paths relative to the session's working directory or project root,
+ * because the `--cwd` CLI flag sets the session cwd without calling
+ * `process.chdir()`, so `process.cwd()` may return the wrong path.
+ */
+export interface SessionWorkspaceEnv {
+	/**
+	 * The session's active working directory as configured by the host (e.g.
+	 * via `--cwd`). Always accurate — never use `process.cwd()` in plugins or
+	 * hooks; use this field instead.
+	 */
+	cwd?: string;
+	/**
+	 * The workspace / project root when it differs from `cwd`. Global plugins
+	 * installed outside the project should use this rather than
+	 * `import.meta.url` tricks or `process.cwd()`.
+	 */
+	workspaceRoot?: string;
+	/**
+	 * Structured workspace and git metadata for the session.
+	 *
+	 * Contains the same information as the `{{CLINE_METADATA}}` block in the
+	 * system prompt but in structured form: `rootPath`, `hint`,
+	 * `associatedRemoteUrls`, `latestGitCommitHash`, `latestGitBranchName`.
+	 *
+	 * Plugins and hooks can use this for branch-aware logic, commit
+	 * attribution, or tooling integrations without running their own `git`
+	 * calls. Populated once per session at session-start time.
+	 */
+	workspaceInfo?: WorkspaceInfo;
+}
+
+/**
+ * Fired exactly once for the lifetime of an agent conversation, before the
+ * first run starts. This is the right place for session-scoped setup.
+ */
+export interface AgentHookSessionStartContext extends SessionWorkspaceEnv {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	schedule?: AgentHookScheduleContext;
+}
+
+/**
+ * Fired once per `run()` / `continue()` invocation after user input has been
+ * accepted and before the loop enters its first iteration.
+ */
+export interface AgentHookRunEndContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	result: AgentResult;
+}
+
+/**
+ * Fired at the top of every loop iteration, before any turn-level prompt or
+ * model preparation occurs.
+ */
+export interface AgentHookIterationStartContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+}
+
+export interface AgentHookIterationEndContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	hadToolCalls: boolean;
+	toolCallCount: number;
+}
+
+export interface AgentHookTurnStartContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	messages: Message[];
+}
+
+/**
+ * Fired immediately before the model call for an iteration.
+ *
+ * Compared with `onIterationStart`, this hook runs later: after turn-start
+ * processing and with the exact message list that will be sent to the model.
+ * It can still influence the upcoming turn by replacing the system prompt,
+ * appending messages, or cancelling the run.
+ */
+export interface AgentHookBeforeAgentStartContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	systemPrompt: string;
+	messages: Message[];
+}
+
+export interface AgentHookTurnEndContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	turn: ProcessedTurn;
+}
+
+export interface AgentHookToolCallStartContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	call: PendingToolCall;
+}
+
+export interface AgentHookToolCallEndContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	record: ToolCallRecord;
+}
+
+export interface AgentHookErrorContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	error: Error;
+}
+
+export interface AgentHookStopErrorContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	error: Error;
+}
+
+export interface AgentHookSessionShutdownContext {
+	agentId: string;
+	conversationId: string;
+	/** Stable core session id for the root session, when provided by the host. */
+	sessionId?: string;
+	parentAgentId: string | null;
+	/**
+	 * Optional reason for shutdown (e.g. "ctrl_d", "process_exit")
+	 */
+	reason?: string;
+}
+
+// =============================================================================
+// Extensions
+// =============================================================================
+
+export interface AgentExtensionRuntimeEventContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	event: AgentEvent;
+}
+
+export interface AgentExtensionSessionStartContext extends SessionWorkspaceEnv {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	schedule?: AgentHookScheduleContext;
+}
+
+export interface AgentExtensionSessionShutdownContext {
+	agentId: string;
+	conversationId: string;
+	/** Stable core session id for the root session, when provided by the host. */
+	sessionId?: string;
+	parentAgentId: string | null;
+	reason?: string;
+}
+
+export interface AgentExtensionContext extends PluginSetupContext {}
+
+export interface AgentExtension
+	extends ContributionRegistryExtension<AgentTool, Message[]> {
+	name: string;
+	manifest: PluginManifest;
+	hooks?: AgentExtensionHooks;
+	setup?: (
+		api: AgentExtensionApi<AgentTool, Message[]>,
+		ctx: AgentExtensionContext,
+	) => void | Promise<void>;
+}
+
+export type AgentLoopExtensionRegistry = AgentExtensionRegistryGeneric<
+	AgentTool,
+	Message
+>;
+
+/**
+ * Lifecycle hooks for observing or influencing agent execution.
+ */
+export type AgentHooks = Partial<AgentRuntimeHooks>;
+
+// =============================================================================
+// Agent Finish Reasons
+// =============================================================================
+
+/**
+ * Reasons why the agent stopped executing
+ */
+export type AgentFinishReason =
+	| "completed" // Normal completion (no more tool calls)
+	| "max_iterations" // Hit the maximum iteration limit
+	| "aborted" // User or system aborted
+	| "mistake_limit" // Stopped after repeated recoverable mistakes
+	| "error"; // Unrecoverable error occurred
+
+export const AgentFinishReasonSchema = z.enum([
+	"completed",
+	"max_iterations",
+	"aborted",
+	"mistake_limit",
+	"error",
+]);
+
+// =============================================================================
+// Agent Usage
+// =============================================================================
+
+/**
+ * Aggregated token usage and cost information (legacy, host-facing shape).
+ *
+ * Renamed from `AgentUsage` to make room for the runtime's stricter
+ * `AgentUsage` (see `../agent.ts`). Retained because
+ * the host-facing `AgentResult`/`AgentUsageEvent` surface and the
+ * `AgentUsageSchema` Zod schema use this more-permissive shape (all
+ * cache/cost fields optional). The facade adapter converts between the
+ * two shapes at runtime.
+ */
+export interface LegacyAgentUsage {
+	/** Total input tokens across all iterations */
+	inputTokens: number;
+	/** Total output tokens across all iterations */
+	outputTokens: number;
+	/** Total tokens read from cache */
+	cacheReadTokens?: number;
+	/** Total tokens written to cache */
+	cacheWriteTokens?: number;
+	/** Total cost in dollars */
+	totalCost?: number;
+}
+
+export const AgentUsageSchema = z.object({
+	inputTokens: z.number(),
+	outputTokens: z.number(),
+	cacheReadTokens: z.number().optional(),
+	cacheWriteTokens: z.number().optional(),
+	totalCost: z.number().optional(),
+});
+
+export interface AgentPrepareTurnContext {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	messages: MessageWithMetadata[];
+	apiMessages: MessageWithMetadata[];
+	abortSignal: AbortSignal;
+	systemPrompt: string;
+	tools: AgentTool[];
+	model: {
+		id: string;
+		provider: string;
+		info?: ModelInfo;
+	};
+	emitStatusNotice?: (
+		message: string,
+		metadata?: Record<string, unknown>,
+	) => void;
+}
+
+export interface AgentPrepareTurnResult {
+	messages?: MessageWithMetadata[];
+	systemPrompt?: string;
+}
+
+// =============================================================================
+// Agent Result
+// =============================================================================
+
+/**
+ * Result returned from Agent.run()
+ */
+export interface AgentResult {
+	/** Final text output from the agent */
+	text: string;
+	/** Aggregated token usage and cost */
+	usage: LegacyAgentUsage;
+	/** Full conversation history */
+	messages: MessageWithMetadata[];
+	/** All tool calls made during execution */
+	toolCalls: ToolCallRecord[];
+	/** Number of loop iterations */
+	iterations: number;
+	/** Why the agent stopped */
+	finishReason: AgentFinishReason;
+	/** Model information used */
+	model: {
+		id: string;
+		provider: string;
+		info?: ModelInfo;
+	};
+	/** Start time of the run */
+	startedAt: Date;
+	/** End time of the run */
+	endedAt: Date;
+	/** Total duration in milliseconds */
+	durationMs: number;
+}
+
+export const AgentResultSchema = z.object({
+	text: z.string(),
+	usage: AgentUsageSchema,
+	messages: z.array(z.custom<MessageWithMetadata>()),
+	toolCalls: z.array(ToolCallRecordSchema),
+	iterations: z.number(),
+	finishReason: AgentFinishReasonSchema,
+	model: z.object({
+		id: z.string(),
+		provider: z.string(),
+		info: ModelInfoSchema.optional(),
+	}),
+	startedAt: z.date(),
+	endedAt: z.date(),
+	durationMs: z.number(),
+});
+
+// =============================================================================
+// Agent Configuration
+// =============================================================================
+
+/**
+ * Reasoning effort level for capable models
+ */
+export type ReasoningEffort = "low" | "medium" | "high" | "xhigh";
+
+export const ReasoningEffortSchema = z.enum(["low", "medium", "high", "xhigh"]);
+
+/**
+ * Configuration for creating an Agent
+ */
+export interface AgentConfig {
+	/**
+	 * Core/hub runtime session identifier.
+	 *
+	 * The host-owned lifecycle id for this task/session. Core uses it for
+	 * persistence, event routing, abort/stop operations, and approval delivery.
+	 * This is intentionally separate from `conversationId`, which identifies the
+	 * model transcript managed by the agent runtime.
+	 */
+	sessionId?: string;
+	// -------------------------------------------------------------------------
+	// Provider Settings
+	// -------------------------------------------------------------------------
+
+	/** Provider ID (e.g., "anthropic", "openai", "gemini") */
+	providerId: string;
+	/** Model ID to use */
+	modelId: string;
+	/** API key for the provider */
+	apiKey?: string;
+	/** Custom base URL for the API */
+	baseUrl?: string;
+	/** Additional headers for API requests */
+	headers?: Record<string, string>;
+	/** Optional provider model catalog overrides */
+	knownModels?: Record<string, ModelInfo>;
+	/** Optional pre-resolved provider configuration (includes provider-specific fields like aws/gcp). */
+	providerConfig?: unknown;
+	/**
+	 * Optional preloaded conversation history for resume flows.
+	 * When provided, start by calling continue() to preserve history.
+	 */
+	initialMessages?: Message[];
+
+	// -------------------------------------------------------------------------
+	// Agent Behavior
+	// -------------------------------------------------------------------------
+
+	/** System prompt for the agent */
+	systemPrompt: string;
+	/** Tools available to the agent */
+	tools: AgentTool[];
+	/**
+	 * Maximum number of loop iterations
+	 * If undefined, no iteration cap is enforced.
+	 */
+	maxIterations?: number;
+	/**
+	 * Maximum number of tool calls to execute concurrently in a single iteration.
+	 * @default 8
+	 */
+	maxParallelToolCalls?: number;
+	/**
+	 * Maximum output tokens per API call
+	 */
+	maxTokensPerTurn?: number;
+	/**
+	 * Timeout for each API call in milliseconds
+	 * @default 180000 (3 minutes)
+	 */
+	apiTimeoutMs?: number;
+	/**
+	 * Optional runtime file-content loader used when user files are attached.
+	 * When omitted, attached files will be represented as loader errors.
+	 */
+	userFileContentLoader?: (path: string) => Promise<string>;
+	/**
+	 * Optional metadata merged into every tool execution context.
+	 * Hosts can use this to thread runtime-specific identifiers such as session IDs.
+	 */
+	toolContextMetadata?: Record<string, unknown>;
+	/** Execution guardrails and recovery settings. */
+	execution?: AgentExecutionConfig;
+
+	// -------------------------------------------------------------------------
+	// Reasoning Settings (for capable models)
+	// -------------------------------------------------------------------------
+
+	/**
+	 * Reasoning effort level
+	 */
+	reasoningEffort?: ReasoningEffort;
+	/**
+	 * Maximum tokens for thinking/reasoning
+	 */
+	thinkingBudgetTokens?: number;
+	/**
+	 * Enable default thinking/reasoning behavior for supported models.
+	 */
+	thinking?: boolean;
+
+	// -------------------------------------------------------------------------
+	// Callbacks
+	// -------------------------------------------------------------------------
+
+	/**
+	 * Callback for agent events (streaming, progress, etc.)
+	 */
+	onEvent?: (event: AgentEvent) => void;
+	/**
+	 * Lifecycle hooks for observing or influencing agent execution.
+	 */
+	hooks?: AgentHooks;
+	/**
+	 * Optional parent agent ID for spawned/delegated runs.
+	 * Root agents should leave this undefined.
+	 */
+	parentAgentId?: string;
+	/**
+	 * Extension modules that can intercept lifecycle events and register tools/commands.
+	 */
+	extensions?: AgentExtension[];
+	/**
+	 * How hook errors should be handled.
+	 * @default "ignore"
+	 */
+	hookErrorMode?: HookErrorMode;
+	/**
+	 * Optional schedule metadata for runs initiated by scheduler services.
+	 * Used by session_start lifecycle hooks.
+	 */
+	schedule?: AgentHookScheduleContext;
+	/**
+	 * Per-tool execution policy. Tool names not listed here default to enabled + autoApprove.
+	 */
+	toolPolicies?: Record<string, ToolPolicy>;
+	/**
+	 * Optional callback to request client approval when a tool policy disables auto-approval.
+	 */
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult> | ToolApprovalResult;
+	/**
+	 * Optional callback invoked when consecutive mistakes reach maxConsecutiveMistakes.
+	 */
+	onConsecutiveMistakeLimitReached?: (
+		context: ConsecutiveMistakeLimitContext,
+	) =>
+		| Promise<ConsecutiveMistakeLimitDecision>
+		| ConsecutiveMistakeLimitDecision;
+	/**
+	 * Optional logger for tracing agent loop lifecycle and recoverable failures.
+	 */
+	logger?: BasicLogger;
+	/**
+	 * Optional request projection hook invoked before each model call.
+	 *
+	 * Returned messages affect only the provider request for the current call.
+	 * They do not replace the canonical runtime transcript, are not persisted as
+	 * session history, and are not reflected in AgentRunResult.messages.
+	 *
+	 * Hosts that need durable redaction or normalization must apply it before a
+	 * message enters the canonical transcript.
+	 */
+	prepareTurn?: (
+		context: AgentPrepareTurnContext,
+	) =>
+		| Promise<AgentPrepareTurnResult | undefined>
+		| AgentPrepareTurnResult
+		| undefined;
+	/**
+	 * Optional Telemetry service for emitting structured events about agent execution to configured telemetry backends.
+	 */
+	telemetry?: ITelemetryService;
+	/**
+	 * Ambient runtime context: user identity, client surface, workspace, logger,
+	 * and telemetry. Threaded through to ProviderConfig so handlers can access it.
+	 */
+	extensionContext?: ExtensionContext;
+
+	// -------------------------------------------------------------------------
+	// Completion Guard
+	// -------------------------------------------------------------------------
+
+	/**
+	 * First-class runtime completion policy. Tool-based completion is resolved
+	 * from the final agent tool list, so built-in and plugin tools can opt in
+	 * with `lifecycle.completesRun`.
+	 *
+	 * `completionGuard` runs when the model returns no tool calls.
+	 * If it returns a non-empty string, that string is injected as a
+	 * system-level nudge and the loop continues instead of completing.
+	 * Use this to prevent premature exit when the agent has unfinished
+	 * obligations (e.g. in-progress team tasks).
+	 */
+	completionPolicy?: {
+		requireCompletionTool?: boolean;
+		completionGuard?: () => string | undefined;
+	};
+
+	// -------------------------------------------------------------------------
+	// Pending User Messages
+	// -------------------------------------------------------------------------
+
+	/**
+	 * Optional callback invoked at the top of each agent loop iteration
+	 * (after the first). If it returns a non-empty string, that string is
+	 * injected as a user message into the conversation before the next API
+	 * call. This allows the host to feed user input into a running loop
+	 * without waiting for the current run to finish.
+	 */
+	consumePendingUserMessage?: () => string | undefined;
+
+	// -------------------------------------------------------------------------
+	// Cancellation
+	// -------------------------------------------------------------------------
+
+	/**
+	 * Abort signal for cancellation
+	 */
+	abortSignal?: AbortSignal;
+}
+
+export const AgentConfigSchema = z.object({
+	sessionId: z.string().optional(),
+	// Provider Settings
+	providerId: z.string(),
+	modelId: z.string(),
+	apiKey: z.string().optional(),
+	baseUrl: z.string().url().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	knownModels: z.record(z.string(), ModelInfoSchema).optional(),
+	providerConfig: z.unknown().optional(),
+	initialMessages: z.array(z.custom<Message>()).optional(),
+
+	// Agent Behavior
+	systemPrompt: z.string(),
+	tools: z.array(z.custom<AgentTool>()),
+	maxIterations: z.number().positive().optional(),
+	maxParallelToolCalls: z.number().int().positive().default(8),
+	maxTokensPerTurn: z.number().positive().optional(),
+	apiTimeoutMs: z.number().positive().default(180000),
+	userFileContentLoader: z
+		.function()
+		.input([z.string()])
+		.output(z.promise(z.string()))
+		.optional(),
+	toolContextMetadata: z.record(z.string(), z.unknown()).optional(),
+	execution: z
+		.object({
+			maxConsecutiveMistakes: z.number().int().positive().optional(),
+			reminderAfterIterations: z.number().nonnegative().optional(),
+			reminderText: z.string().optional(),
+			loopDetection: z
+				.union([
+					z.literal(false),
+					z.object({
+						softThreshold: z.number().int().positive().optional(),
+						hardThreshold: z.number().int().positive().optional(),
+					}),
+				])
+				.optional(),
+		})
+		.optional(),
+	// Reasoning Settings
+	reasoningEffort: ReasoningEffortSchema.optional(),
+	thinkingBudgetTokens: z.number().positive().optional(),
+	thinking: z.boolean().optional(),
+
+	// Callbacks
+	onEvent: z
+		.function()
+		.input([z.custom<AgentEvent>()])
+		.output(z.void())
+		.optional(),
+	hooks: z.custom<AgentHooks>().optional(),
+	parentAgentId: z.string().optional(),
+	extensions: z.array(z.custom<AgentExtension>()).optional(),
+	hookErrorMode: z.enum(["ignore", "throw"]).default("ignore"),
+	toolPolicies: z
+		.record(
+			z.string(),
+			z.object({
+				enabled: z.boolean().optional(),
+				autoApprove: z.boolean().optional(),
+			}),
+		)
+		.optional(),
+	requestToolApproval: z
+		.function()
+		.input([
+			z.object({
+				sessionId: z.string(),
+				agentId: z.string(),
+				conversationId: z.string(),
+				iteration: z.number(),
+				toolCallId: z.string(),
+				toolName: z.string(),
+				input: z.unknown(),
+				policy: z
+					.object({
+						enabled: z.boolean().optional(),
+						autoApprove: z.boolean().optional(),
+					})
+					.default({}),
+			}),
+		])
+		.output(
+			z.union([
+				z.object({
+					approved: z.boolean(),
+					reason: z.string().optional(),
+				}),
+				z.promise(
+					z.object({
+						approved: z.boolean(),
+						reason: z.string().optional(),
+					}),
+				),
+			]),
+		)
+		.optional(),
+	onConsecutiveMistakeLimitReached: z
+		.function()
+		.input([
+			z.object({
+				iteration: z.number().int().positive(),
+				consecutiveMistakes: z.number().int().positive(),
+				maxConsecutiveMistakes: z.number().int().positive(),
+				reason: z.enum([
+					"api_error",
+					"invalid_tool_call",
+					"tool_execution_failed",
+				]),
+				details: z.string().optional(),
+			}),
+		])
+		.output(
+			z.union([
+				z.object({
+					action: z.literal("continue"),
+					guidance: z.string().optional(),
+				}),
+				z.object({
+					action: z.literal("stop"),
+					reason: z.string().optional(),
+				}),
+				z.promise(
+					z.union([
+						z.object({
+							action: z.literal("continue"),
+							guidance: z.string().optional(),
+						}),
+						z.object({
+							action: z.literal("stop"),
+							reason: z.string().optional(),
+						}),
+					]),
+				),
+			]),
+		)
+		.optional(),
+	logger: z.custom<BasicLogger>().optional(),
+	extensionContext: z.custom<ExtensionContext>().optional(),
+
+	// Cancellation
+	abortSignal: z.custom<AbortSignal>().optional(),
+});
+
+// =============================================================================
+// Internal Types
+// =============================================================================
+
+/**
+ * Pending tool call from the model
+ */
+export interface PendingToolCall {
+	id: string;
+	name: string;
+	input: unknown;
+	signature?: string;
+	review?: boolean;
+}
+
+/**
+ * Processed response from one turn of the loop
+ */
+export interface ProcessedTurn {
+	/** Text output from the model */
+	text: string;
+	/** Reasoning/thinking content */
+	reasoning?: string;
+	/** Tool calls requested by the model */
+	toolCalls: PendingToolCall[];
+	/** Model-emitted tool calls that were invalid or missing required fields */
+	invalidToolCalls: Array<{
+		id: string;
+		name?: string;
+		input?: unknown;
+		reason: "missing_name" | "missing_arguments" | "invalid_arguments";
+	}>;
+	/** Token usage for this turn */
+	usage: {
+		inputTokens: number;
+		outputTokens: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		cost?: number;
+	};
+	/** Whether the response was truncated */
+	truncated: boolean;
+	/** Response ID from the API */
+	responseId?: string;
+}
diff --git a/sdk/packages/shared/src/automation/index.ts b/sdk/packages/shared/src/automation/index.ts
new file mode 100644
index 0000000..7e2556c
--- /dev/null
+++ b/sdk/packages/shared/src/automation/index.ts
@@ -0,0 +1,31 @@
+export type {
+	AutomationEventFrontmatter,
+	AutomationOneOffFrontmatter,
+	AutomationScheduleFrontmatter,
+} from "./schemas";
+export {
+	AutomationEventFrontmatterSchema,
+	AutomationOneOffFrontmatterSchema,
+	AutomationScheduleFrontmatterSchema,
+	EVENT_ONLY_FIELDS,
+	SCHEDULE_ONLY_FIELDS,
+} from "./schemas";
+export type {
+	AutomationEventEnvelope,
+	AutomationEventSpec,
+	AutomationOneOffSpec,
+	AutomationRunStatus,
+	AutomationRunTriggerKind,
+	AutomationScheduleSpec,
+	AutomationSpec,
+	AutomationSpecCommon,
+	AutomationSpecParseStatus,
+	AutomationSpecSource,
+	AutomationTriggerKind,
+	ParsedSpec,
+	ParsedSpecError,
+	ParsedSpecOk,
+	ParseIssue,
+	ParseIssueDetail,
+	ParseIssueKind,
+} from "./types";
diff --git a/sdk/packages/shared/src/automation/schemas.ts b/sdk/packages/shared/src/automation/schemas.ts
new file mode 100644
index 0000000..59a5819
--- /dev/null
+++ b/sdk/packages/shared/src/automation/schemas.ts
@@ -0,0 +1,99 @@
+import { z } from "zod";
+
+/**
+ * Zod schemas for automation spec frontmatter. Used by the parser in
+ * `@cline/core` to validate frontmatter shape before normalization.
+ *
+ * The schemas are deliberately permissive: they accept the raw parsed YAML
+ * object and let the parser layer apply normalization rules (trim, default
+ * enabled, resolve title, body->prompt fallback, etc).
+ */
+
+const nonEmptyString = z.string().min(1);
+
+const tagsSchema = z.array(z.string()).optional();
+
+const metadataSchema = z.record(z.string(), z.unknown()).optional();
+
+const modeSchema = z.enum(["act", "plan", "yolo", "zen"]).optional();
+
+const modelSelectionSchema = z
+	.object({
+		providerId: nonEmptyString,
+		modelId: z.string().optional(),
+	})
+	.optional();
+
+/**
+ * Fields accepted across every trigger kind. Trigger-specific fields live on
+ * their respective discriminants and are rejected when they appear on the
+ * wrong kind.
+ */
+const commonFrontmatterFields = {
+	id: z.string().optional(),
+	title: z.string().optional(),
+	prompt: z.string().optional(),
+	workspaceRoot: z.string().optional(),
+	cwd: z.string().optional(),
+	modelSelection: modelSelectionSchema,
+	systemPrompt: z.string().optional(),
+	mode: modeSchema,
+	timeoutSeconds: z.number().int().positive().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	tags: tagsSchema,
+	enabled: z.boolean().optional(),
+	metadata: metadataSchema,
+} as const;
+
+export const AutomationOneOffFrontmatterSchema = z
+	.object({
+		...commonFrontmatterFields,
+	})
+	.strict();
+
+export const AutomationScheduleFrontmatterSchema = z
+	.object({
+		...commonFrontmatterFields,
+		schedule: nonEmptyString,
+		timezone: z.string().optional(),
+	})
+	.strict();
+
+export const AutomationEventFrontmatterSchema = z
+	.object({
+		...commonFrontmatterFields,
+		event: nonEmptyString,
+		filters: z.record(z.string(), z.unknown()).optional(),
+		debounceSeconds: z.number().int().nonnegative().optional(),
+		dedupeWindowSeconds: z.number().int().nonnegative().optional(),
+		cooldownSeconds: z.number().int().nonnegative().optional(),
+		maxParallel: z.number().int().positive().optional(),
+	})
+	.strict();
+
+/**
+ * Field names that are only valid on schedule specs.
+ */
+export const SCHEDULE_ONLY_FIELDS = ["schedule", "timezone"] as const;
+
+/**
+ * Field names that are only valid on event specs.
+ */
+export const EVENT_ONLY_FIELDS = [
+	"event",
+	"filters",
+	"debounceSeconds",
+	"dedupeWindowSeconds",
+	"cooldownSeconds",
+	"maxParallel",
+] as const;
+
+export type AutomationOneOffFrontmatter = z.infer<
+	typeof AutomationOneOffFrontmatterSchema
+>;
+export type AutomationScheduleFrontmatter = z.infer<
+	typeof AutomationScheduleFrontmatterSchema
+>;
+export type AutomationEventFrontmatter = z.infer<
+	typeof AutomationEventFrontmatterSchema
+>;
diff --git a/sdk/packages/shared/src/automation/types.ts b/sdk/packages/shared/src/automation/types.ts
new file mode 100644
index 0000000..3bfa682
--- /dev/null
+++ b/sdk/packages/shared/src/automation/types.ts
@@ -0,0 +1,187 @@
+import type { GatewayModelSelection } from "../llms/gateway";
+import type { AgentMode } from "../session/runtime-config";
+
+/**
+ * Trigger kinds supported by the automation subsystem.
+ *
+ * - `one_off`: a single run materialized from a `.cline/cron/*.md` spec.
+ * - `schedule`: recurring runs materialized from a `.cline/cron/*.cron.md` spec.
+ * - `event`: reactive runs materialized from a `.cline/cron/events/*.event.md`
+ *   spec. Event-driven specs are defined here for contract completeness but
+ *   runtime matching lives in a later feature.
+ */
+export type AutomationTriggerKind = "one_off" | "schedule" | "event";
+
+/**
+ * Trigger kinds persisted on `cron_runs`. Event-driven, manual, and retry
+ * triggers are all first-class run sources in addition to the spec-defined
+ * `one_off` and `schedule` kinds.
+ */
+export type AutomationRunTriggerKind =
+	| "one_off"
+	| "schedule"
+	| "event"
+	| "manual"
+	| "retry";
+
+/**
+ * Lifecycle status of a queued run row in `cron_runs`.
+ */
+export type AutomationRunStatus =
+	| "queued"
+	| "running"
+	| "done"
+	| "failed"
+	| "cancelled";
+
+/**
+ * Parse status persisted on a `cron_specs` row.
+ */
+export type AutomationSpecParseStatus = "valid" | "invalid";
+
+/**
+ * Common fields shared by every automation spec after parsing.
+ *
+ * `id` is the stable external identity derived from the frontmatter `id` field
+ * when present, or from the normalized relative source path as a fallback.
+ */
+export interface AutomationSpecCommon {
+	/** Stable external identity: frontmatter id, else normalized relative path. */
+	id: string;
+	/** Optional explicit frontmatter `id` (undefined when falling back to path). */
+	externalId?: string;
+	/** Human-readable title used in reports and list APIs. */
+	title: string;
+	/** Prompt text: frontmatter `prompt` if provided, otherwise the markdown body. */
+	prompt: string;
+	/** Absolute workspace root the automation run executes against. */
+	workspaceRoot: string;
+	/** Working directory inside the workspace (defaults to workspaceRoot at runtime). */
+	cwd?: string;
+	/** Optional model selection; when omitted the runtime default is used. */
+	modelSelection?: GatewayModelSelection;
+	/** System prompt override. */
+	systemPrompt?: string;
+	/** Agent mode. Defaults to `act` at runtime if omitted. */
+	mode?: AgentMode;
+	/** Hard timeout enforced by the runner. */
+	timeoutSeconds?: number;
+	/** Maximum agent iterations. */
+	maxIterations?: number;
+	/** Free-form tags. */
+	tags?: readonly string[];
+	/** Whether the spec is enabled. Defaults to `true`. */
+	enabled: boolean;
+	/** Arbitrary user metadata; stored verbatim as JSON. */
+	metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface AutomationOneOffSpec extends AutomationSpecCommon {
+	triggerKind: "one_off";
+}
+
+export interface AutomationScheduleSpec extends AutomationSpecCommon {
+	triggerKind: "schedule";
+	/** Cron expression (5 or 6 fields, parser validated by the scheduler). */
+	schedule: string;
+	/** IANA timezone name. Optional; falls back to runtime default. */
+	timezone?: string;
+}
+
+/**
+ * Event-driven spec. Feature 2 owns the matcher; Feature 1 only needs the
+ * contract so `.event.md` specs parsed later surface the expected shape.
+ */
+export interface AutomationEventSpec extends AutomationSpecCommon {
+	triggerKind: "event";
+	event: string;
+	filters?: Readonly<Record<string, unknown>>;
+	debounceSeconds?: number;
+	dedupeWindowSeconds?: number;
+	cooldownSeconds?: number;
+	maxParallel?: number;
+}
+
+/**
+ * Discriminated union of all automation specs.
+ */
+export type AutomationSpec =
+	| AutomationOneOffSpec
+	| AutomationScheduleSpec
+	| AutomationEventSpec;
+
+/**
+ * Normalized automation event envelope. Feature 2 will flesh out matching on
+ * top of this contract; Feature 1 ships the scaffold so downstream modules can
+ * reference it without cyclic dependencies.
+ */
+export interface AutomationEventEnvelope {
+	eventId: string;
+	eventType: string;
+	source: string;
+	subject?: string;
+	occurredAt: string;
+	workspaceRoot?: string;
+	payload: unknown;
+	attributes?: Readonly<Record<string, unknown>>;
+	dedupeKey?: string;
+}
+
+/**
+ * Source-file metadata passed into the parser. Filesystem I/O (reading the
+ * file, hashing the bytes, stat-ing mtime) happens in core; the parser stays
+ * pure and takes these values as inputs.
+ */
+export interface AutomationSpecSource {
+	/**
+	 * POSIX-normalized path of the source file relative to `.cline/cron/`.
+	 * Used as the identity fallback and persisted in `cron_specs.source_path`.
+	 */
+	normalizedRelativePath: string;
+	/** Bare filename (e.g. `repo-cleanup.md`). */
+	filename: string;
+	/** File mtime in milliseconds since the epoch. */
+	mtimeMs: number;
+	/** Content hash (hex sha256) of the raw file bytes. */
+	hash: string;
+}
+
+export interface ParsedSpecOk {
+	ok: true;
+	spec: AutomationSpec;
+	source: AutomationSpecSource;
+	/** Non-fatal parser warnings. */
+	warnings: readonly ParseIssueDetail[];
+}
+
+export interface ParsedSpecError {
+	ok: false;
+	source: AutomationSpecSource;
+	issue: ParseIssue;
+}
+
+export type ParsedSpec = ParsedSpecOk | ParsedSpecError;
+
+/**
+ * Categorization of parser issues. `unsupported` is reserved for spec shapes
+ * that are syntactically valid but intentionally deferred (e.g. `.event.md`
+ * before Feature 2 lands). All other kinds are fatal for that file.
+ */
+export type ParseIssueKind =
+	| "yaml"
+	| "schema"
+	| "missing_required"
+	| "conflicting_fields"
+	| "empty_prompt"
+	| "unsupported";
+
+export interface ParseIssueDetail {
+	field?: string;
+	message: string;
+}
+
+export interface ParseIssue {
+	kind: ParseIssueKind;
+	message: string;
+	details?: readonly ParseIssueDetail[];
+}
diff --git a/sdk/packages/shared/src/connectors/events.ts b/sdk/packages/shared/src/connectors/events.ts
new file mode 100644
index 0000000..e8e2eaa
--- /dev/null
+++ b/sdk/packages/shared/src/connectors/events.ts
@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+export const ConnectorHookEventNameSchema = z.enum([
+	"connector.started",
+	"connector.stopping",
+	"session.authorize",
+	"message.received",
+	"message.denied",
+	"message.completed",
+	"message.failed",
+	"session.started",
+	"session.reused",
+	"session.reset",
+	"schedule.delivery.started",
+	"schedule.delivery.sent",
+	"schedule.delivery.failed",
+]);
+
+export type ConnectorHookEventName = z.infer<
+	typeof ConnectorHookEventNameSchema
+>;
+
+export const ConnectorEventActorSchema = z.object({
+	id: z.string().optional(),
+	label: z.string().optional(),
+	role: z.string().optional(),
+	participantKey: z.string().optional(),
+	participantLabel: z.string().optional(),
+	platformUserId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorEventContextSchema = z.object({
+	source: z.string(),
+	sourceEvent: z.string(),
+	threadId: z.string(),
+	channelId: z.string(),
+	isDM: z.boolean(),
+	sessionId: z.string().optional(),
+	workspaceRoot: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorAuthorizationRequestSchema = z.object({
+	actor: ConnectorEventActorSchema,
+	context: ConnectorEventContextSchema,
+	payload: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorAuthorizationDecisionSchema = z.object({
+	action: z.enum(["allow", "deny"]).default("allow"),
+	message: z.string().optional(),
+	reason: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorHookEventSchema = z.object({
+	adapter: z.string(),
+	botUserName: z.string().optional(),
+	event: ConnectorHookEventNameSchema,
+	payload: z.record(z.string(), z.unknown()),
+	ts: z.string(),
+});
+
+export type ConnectorHookEvent = z.infer<typeof ConnectorHookEventSchema>;
+export type ConnectorEventActor = z.infer<typeof ConnectorEventActorSchema>;
+export type ConnectorEventContext = z.infer<typeof ConnectorEventContextSchema>;
+export type ConnectorAuthorizationRequest = z.infer<
+	typeof ConnectorAuthorizationRequestSchema
+>;
+export type ConnectorAuthorizationDecision = z.infer<
+	typeof ConnectorAuthorizationDecisionSchema
+>;
diff --git a/sdk/packages/shared/src/connectors/options.ts b/sdk/packages/shared/src/connectors/options.ts
new file mode 100644
index 0000000..85ac66f
--- /dev/null
+++ b/sdk/packages/shared/src/connectors/options.ts
@@ -0,0 +1,190 @@
+export type ConnectWhatsAppOptions = {
+	userName: string;
+	phoneNumberId?: string;
+	accessToken?: string;
+	appSecret?: string;
+	verifyToken?: string;
+	apiVersion?: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+};
+
+export type WhatsAppConnectorState = {
+	instanceKey: string;
+	userName: string;
+	phoneNumberId?: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
+
+export type ConnectTelegramOptions = {
+	botToken: string;
+	botUsername?: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+};
+
+export type TelegramConnectorState = {
+	botUsername: string;
+	botId?: string;
+	pid: number;
+	rpcAddress: string;
+	startedAt: string;
+};
+
+export type ConnectSlackOptions = {
+	userName: string;
+	connectionMode: "webhook" | "socket";
+	botToken?: string;
+	signingSecret?: string;
+	appToken?: string;
+	clientId?: string;
+	clientSecret?: string;
+	encryptionKey?: string;
+	installationKeyPrefix?: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl?: string;
+};
+
+export type SlackConnectorState = {
+	userName: string;
+	connectionMode?: "webhook" | "socket";
+	pid: number;
+	rpcAddress: string;
+	port?: number;
+	baseUrl?: string;
+	startedAt: string;
+};
+
+export type ConnectDiscordOptions = {
+	userName: string;
+	applicationId: string;
+	botToken: string;
+	publicKey: string;
+	ownerUserId?: string;
+	allowBotAuthors: boolean;
+	mentionRoleIds?: string[];
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+};
+
+export type DiscordConnectorState = {
+	userName: string;
+	applicationId: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
+
+export type ConnectGoogleChatOptions = {
+	userName: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+	pubsubTopic?: string;
+	impersonateUser?: string;
+	useApplicationDefaultCredentials: boolean;
+	credentialsJson?: string;
+};
+
+export type GoogleChatConnectorState = {
+	userName: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
+
+export type ConnectLinearOptions = {
+	userName: string;
+	apiKey?: string;
+	clientId?: string;
+	clientSecret?: string;
+	accessToken?: string;
+	webhookSecret: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiProviderKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+};
+
+export type LinearConnectorState = {
+	userName: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
diff --git a/sdk/packages/shared/src/connectors/platforms.ts b/sdk/packages/shared/src/connectors/platforms.ts
new file mode 100644
index 0000000..ef889f7
--- /dev/null
+++ b/sdk/packages/shared/src/connectors/platforms.ts
@@ -0,0 +1,443 @@
+export type ConnectorCatalogEntry = {
+	name: string;
+	description: string;
+};
+
+export const CONNECTOR_CATALOG: ConnectorCatalogEntry[] = [
+	{
+		name: "discord",
+		description:
+			"Discord interactions and gateway bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "gchat",
+		description: "Google Chat webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "linear",
+		description: "Linear webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "slack",
+		description: "Slack webhook/socket bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "telegram",
+		description: "Bridge Telegram bot messages into RPC chat sessions",
+	},
+	{
+		name: "whatsapp",
+		description: "Bridge WhatsApp webhook messages into RPC chat sessions",
+	},
+];
+
+export function listConnectorCatalog(): ConnectorCatalogEntry[] {
+	return CONNECTOR_CATALOG.map((entry) => ({ ...entry }));
+}
+
+export interface ConnectorPlatformDef {
+	id: string;
+	name: string;
+	type: "polling" | "webhook" | "hybrid";
+	hint: string;
+	fields: ConnectorFieldDef[];
+	security?: ConnectorSecurityDef;
+}
+
+export interface ConnectorFieldDef {
+	flag: string;
+	label: string;
+	placeholder?: string;
+	required?: boolean;
+	help?: string[];
+	initialValue?: string;
+	options?: Array<{ value: string; label: string; hint?: string }>;
+	includeWhen?: ConnectorFieldCondition;
+}
+
+export type ConnectorFieldCondition = {
+	flag: string;
+	equals?: string;
+	notEquals?: string;
+};
+
+export interface ConnectorSecurityFieldDef {
+	key: string;
+	label: string;
+	placeholder?: string;
+	help?: string[];
+	requiredMessage: string;
+	validate?: (value: string) => string | undefined;
+}
+
+export interface ConnectorSecurityDef {
+	prompt: string;
+	fields: ConnectorSecurityFieldDef[];
+	buildArgs: (values: Record<string, string>) => string[];
+}
+
+export type ConnectorChannel = {
+	id: string;
+	name: string;
+	type: ConnectorPlatformDef["type"];
+	hint: string;
+	fields: ConnectorFieldDef[];
+	security?: {
+		prompt: string;
+		fields: Array<Omit<ConnectorSecurityFieldDef, "validate">>;
+	};
+};
+
+export type ActiveConnectorRecord = {
+	id: string;
+	type: string;
+	pid: number;
+	hubUrl: string;
+	startedAt?: string;
+	applicationId?: string;
+	botUsername?: string;
+	userName?: string;
+	phoneNumberId?: string;
+	port?: number;
+	baseUrl?: string;
+	connectionMode?: string;
+};
+
+export type ConfiguredConnectorRecord = {
+	id: string;
+	type: string;
+	configuredAt: string;
+	updatedAt: string;
+};
+
+export type ConnectorChannelsResponse = {
+	available: ConnectorChannel[];
+	active: ActiveConnectorRecord[];
+	configured: ConfiguredConnectorRecord[];
+};
+
+export function shouldIncludeConnectorField(
+	field: ConnectorFieldDef,
+	values: Record<string, string>,
+): boolean {
+	const condition = field.includeWhen;
+	if (!condition) {
+		return true;
+	}
+	const value = values[condition.flag] ?? "";
+	if (condition.equals !== undefined && value !== condition.equals) {
+		return false;
+	}
+	if (condition.notEquals !== undefined && value === condition.notEquals) {
+		return false;
+	}
+	return true;
+}
+
+export function connectorChannelsFromPlatforms(
+	platforms: ConnectorPlatformDef[] = CONNECTOR_PLATFORMS,
+): ConnectorChannel[] {
+	const supported = new Set(
+		listConnectorCatalog().map((connector) => connector.name),
+	);
+	return platforms
+		.filter((platform) => supported.has(platform.id))
+		.map((platform) => ({
+			id: platform.id,
+			name: platform.name,
+			type: platform.type,
+			hint: platform.hint,
+			fields: platform.fields.map((field) => ({
+				flag: field.flag,
+				label: field.label,
+				placeholder: field.placeholder,
+				required: field.required,
+				help: field.help,
+				initialValue: field.initialValue,
+				options: field.options,
+				includeWhen: field.includeWhen,
+			})),
+			security: platform.security
+				? {
+						prompt: platform.security.prompt,
+						fields: platform.security.fields.map((field) => ({
+							key: field.key,
+							label: field.label,
+							placeholder: field.placeholder,
+							help: field.help,
+							requiredMessage: field.requiredMessage,
+						})),
+					}
+				: undefined,
+		}));
+}
+
+function validateTelegramUserId(value: string): string | undefined {
+	return /^\d+$/.test(value)
+		? undefined
+		: "Telegram user ID must contain digits only";
+}
+
+function validateSlackTeamId(value: string): string | undefined {
+	return /^T[A-Z0-9]+$/.test(value)
+		? undefined
+		: "Slack workspace ID must start with T and contain uppercase letters or digits only";
+}
+
+function validateSlackUserId(value: string): string | undefined {
+	return /^[UW][A-Z0-9]+$/.test(value)
+		? undefined
+		: "Slack member ID must start with U or W and contain uppercase letters or digits only";
+}
+
+export const CONNECTOR_PLATFORMS: ConnectorPlatformDef[] = [
+	{
+		id: "telegram",
+		name: "Telegram",
+		type: "polling",
+		hint: "Easiest to set up. No public URL needed.",
+		fields: [
+			{
+				flag: "-k",
+				label: "Bot token",
+				placeholder: "7123456789:AAH...",
+				required: true,
+				help: [
+					"Open Telegram and start a chat with @BotFather",
+					"Send /newbot and follow the prompts",
+					"BotFather gives you this after creating the bot",
+					"It looks like 7123456789:AAHxxx...",
+				],
+			},
+		],
+		security: {
+			prompt:
+				"By default, anyone who finds your bot can message it and run tasks on your machine. Restrict access to your Telegram user ID?",
+			fields: [
+				{
+					key: "userId",
+					label: "Your Telegram user ID",
+					placeholder: "123456789",
+					help: [
+						"Message @userinfobot on Telegram",
+						"It will reply with your numeric user ID",
+					],
+					requiredMessage: "User ID is required to restrict access",
+					validate: validateTelegramUserId,
+				},
+			],
+			buildArgs: ({ userId }) => ["--allowed-user-id", userId ?? ""],
+		},
+	},
+	{
+		id: "slack",
+		name: "Slack",
+		type: "hybrid",
+		hint: "Public URL for webhook mode; leave blank for socket mode.",
+		fields: [
+			{
+				flag: "--bot-token",
+				label: "Bot token",
+				placeholder: "xoxb-...",
+				required: true,
+				help: [
+					"Go to api.slack.com/apps and create a new app",
+					"Add Bot Token Scopes: chat:write, app_mentions:read, channels:history, channels:read, im:history, im:read, im:write, users:read",
+					"Install to workspace and copy the Bot Token",
+				],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "leave blank for socket mode",
+				help: [
+					"Enter a publicly accessible URL for webhook mode",
+					"Leave blank to use Slack socket mode instead",
+				],
+			},
+			{
+				flag: "--signing-secret",
+				label: "Signing secret",
+				required: true,
+				help: ["Found in your app's Basic Information page"],
+				includeWhen: { flag: "--base-url", notEquals: "" },
+			},
+			{
+				flag: "--app-token",
+				label: "App-level token",
+				placeholder: "xapp-...",
+				required: true,
+				help: [
+					"Enable Socket Mode in the Slack app",
+					"Generate an app-level token with the connections:write scope",
+				],
+				includeWhen: { flag: "--base-url", equals: "" },
+			},
+		],
+		security: {
+			prompt: "Restrict which Slack users can interact with the bot?",
+			fields: [
+				{
+					key: "teamId",
+					label: "Allowed Slack workspace ID",
+					placeholder: "T01ABC123",
+					help: [
+						"Open your Slack workspace URL in a browser",
+						"The workspace ID is the segment after /client/, for example T01ABC123",
+					],
+					requiredMessage: "Workspace ID is required to restrict access",
+					validate: validateSlackTeamId,
+				},
+				{
+					key: "userId",
+					label: "Allowed Slack member ID",
+					placeholder: "U01ABC123",
+					help: [
+						"Click a user's name in Slack, then View full profile",
+						"Click ... and Copy member ID",
+					],
+					requiredMessage: "Member ID is required to restrict access",
+					validate: validateSlackUserId,
+				},
+			],
+			buildArgs: ({ teamId, userId }) => [
+				"--hook-command",
+				`jq -r ".payload.actor.participantKey" | grep -qx "slack:team:${teamId}:user:${userId}" && echo '{"action":"allow"}' || echo '{"action":"deny"}'`,
+			],
+		},
+	},
+	{
+		id: "discord",
+		name: "Discord",
+		type: "webhook",
+		hint: "Requires a Discord app and public URL.",
+		fields: [
+			{
+				flag: "--application-id",
+				label: "Application ID",
+				required: true,
+				help: [
+					"Go to discord.com/developers/applications",
+					"Create a new app, copy the Application ID",
+				],
+			},
+			{
+				flag: "--bot-token",
+				label: "Bot token",
+				required: true,
+				help: ["Go to Bot section, create a bot, copy the token"],
+			},
+			{
+				flag: "--public-key",
+				label: "Public key",
+				required: true,
+				help: ["Found in General Information of your app"],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+				help: [
+					"Base URL for the connector",
+					"For Discord, set the Interactions Endpoint URL to <base-url>/api/webhooks/discord",
+				],
+			},
+		],
+	},
+	{
+		id: "whatsapp",
+		name: "WhatsApp",
+		type: "webhook",
+		hint: "Requires Meta developer account and public URL.",
+		fields: [
+			{
+				flag: "--phone-number-id",
+				label: "Phone number ID",
+				required: true,
+				help: ["From your WhatsApp Business account in Meta Developer portal"],
+			},
+			{
+				flag: "--access-token",
+				label: "Access token",
+				required: true,
+				help: ["Generate a permanent token in Meta Developer portal"],
+			},
+			{
+				flag: "--app-secret",
+				label: "App secret",
+				required: true,
+				help: ["Found in App Settings > Basic"],
+			},
+			{
+				flag: "--verify-token",
+				label: "Webhook verify token",
+				placeholder: "my-verify-token",
+				required: true,
+				help: ["Any string you choose, used to verify webhook setup"],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+			},
+		],
+	},
+	{
+		id: "gchat",
+		name: "Google Chat",
+		type: "webhook",
+		hint: "Requires Google Cloud project and public URL.",
+		fields: [
+			{
+				flag: "--credentials-json",
+				label: "Service account credentials JSON",
+				required: true,
+				help: [
+					"Create a service account in Google Cloud Console",
+					"Download the credentials JSON file",
+					"Paste the JSON content here",
+				],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+			},
+		],
+	},
+	{
+		id: "linear",
+		name: "Linear",
+		type: "webhook",
+		hint: "React to Linear issues and comments.",
+		fields: [
+			{
+				flag: "--api-key",
+				label: "API key",
+				required: true,
+				help: ["Go to Linear Settings > API > Personal API keys"],
+			},
+			{
+				flag: "--webhook-secret",
+				label: "Webhook signing secret",
+				required: true,
+				help: [
+					"Go to Settings > API > Webhooks, create one",
+					"Copy the signing secret",
+				],
+			},
+			{
+				flag: "--base-url",
+				label: "Public base URL",
+				placeholder: "https://example.com",
+				required: true,
+			},
+		],
+	},
+];
+
+export const PLATFORMS = CONNECTOR_PLATFORMS;
+export const shouldIncludeField = shouldIncludeConnectorField;
diff --git a/sdk/packages/shared/src/cron/cron-spec-types.ts b/sdk/packages/shared/src/cron/cron-spec-types.ts
new file mode 100644
index 0000000..29c18bd
--- /dev/null
+++ b/sdk/packages/shared/src/cron/cron-spec-types.ts
@@ -0,0 +1,104 @@
+/**
+ * Shared types describing automation cron specs parsed from Markdown files.
+ * Split out from `@cline/core` so the parser can live in `shared` where
+ * multiple consumers (hub daemon, CLI tools, enterprise adapters) can validate
+ * the same `.cline/cron/` spec format without pulling in core's stateful
+ * orchestration layer.
+ */
+
+export type CronTriggerKind = "one_off" | "schedule" | "event";
+
+/**
+ * Which trigger kind was inferred from the source file path.
+ * - `*.cron.md` -> schedule
+ * - `events/*.event.md` -> event
+ * - everything else under `.cline/cron/*.md` -> one_off
+ */
+export interface CronSpecModelSelection {
+	providerId?: string;
+	modelId?: string;
+}
+
+export type CronSpecMode = "act" | "plan" | "yolo";
+export type CronSpecExtensionKind = "rules" | "skills" | "plugins";
+
+export interface CronSpecCommonFields {
+	/** Optional explicit id from frontmatter; falls back to relative path. */
+	id?: string;
+	title?: string;
+	prompt?: string;
+	workspaceRoot?: string;
+	mode?: CronSpecMode;
+	systemPrompt?: string;
+	modelSelection?: CronSpecModelSelection;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	tools?: string[];
+	notesDirectory?: string;
+	extensions?: CronSpecExtensionKind[];
+	source?: string;
+	tags?: string[];
+	enabled?: boolean;
+	metadata?: Record<string, unknown>;
+}
+
+export interface CronOneOffSpec extends CronSpecCommonFields {
+	triggerKind: "one_off";
+}
+
+export interface CronScheduleSpec extends CronSpecCommonFields {
+	triggerKind: "schedule";
+	schedule: string;
+	timezone?: string;
+}
+
+export interface CronEventSpec extends CronSpecCommonFields {
+	triggerKind: "event";
+	event: string;
+	filters?: Record<string, unknown>;
+	debounceSeconds?: number;
+	dedupeWindowSeconds?: number;
+	cooldownSeconds?: number;
+	maxParallel?: number;
+}
+
+export type CronSpec = CronOneOffSpec | CronScheduleSpec | CronEventSpec;
+
+/**
+ * Result of parsing one file. Always produces a record — even invalid specs
+ * are surfaced so the store can durably record parse errors rather than
+ * silently dropping state.
+ */
+export interface CronSpecParseResult {
+	/** Stable external identity: frontmatter `id` or normalized relative path. */
+	externalId: string;
+	/** Normalized posix-style path relative to `.cline/cron/`. */
+	relativePath: string;
+	/** Trigger kind inferred from file naming. */
+	triggerKind: CronTriggerKind;
+	/** Raw file body (without frontmatter). */
+	body: string;
+	/** sha256 of canonical frontmatter JSON + body. */
+	contentHash: string;
+	/** When the parse succeeded. */
+	spec?: CronSpec;
+	/** Parse error message when the spec is invalid. */
+	error?: string;
+}
+
+/**
+ * Normalized automation event envelope. Used by the event-driven feature
+ * (Feature 2) but defined here so core, adapters, and shared validation
+ * agree on the shape from day one.
+ */
+export interface AutomationEventEnvelope {
+	eventId: string;
+	eventType: string;
+	source: string;
+	subject?: string;
+	occurredAt: string;
+	workspaceRoot?: string;
+	payload?: Record<string, unknown>;
+	attributes?: Record<string, unknown>;
+	dedupeKey?: string;
+}
diff --git a/sdk/packages/shared/src/cron/index.ts b/sdk/packages/shared/src/cron/index.ts
new file mode 100644
index 0000000..2ee46d0
--- /dev/null
+++ b/sdk/packages/shared/src/cron/index.ts
@@ -0,0 +1,13 @@
+export type {
+	AutomationEventEnvelope,
+	CronEventSpec,
+	CronOneOffSpec,
+	CronScheduleSpec,
+	CronSpec,
+	CronSpecCommonFields,
+	CronSpecExtensionKind,
+	CronSpecMode,
+	CronSpecModelSelection,
+	CronSpecParseResult,
+	CronTriggerKind,
+} from "./cron-spec-types";
diff --git a/sdk/packages/shared/src/db/index.ts b/sdk/packages/shared/src/db/index.ts
new file mode 100644
index 0000000..9cc795e
--- /dev/null
+++ b/sdk/packages/shared/src/db/index.ts
@@ -0,0 +1,14 @@
+export type {
+	SessionSchemaOptions,
+	SqliteDb,
+	SqliteStatement,
+} from "./sqlite-db";
+export {
+	asBool,
+	asOptionalString,
+	asString,
+	ensureSessionSchema,
+	loadSqliteDb,
+	nowIso,
+	toBoolInt,
+} from "./sqlite-db";
diff --git a/sdk/packages/shared/src/db/sqlite-db.test.ts b/sdk/packages/shared/src/db/sqlite-db.test.ts
new file mode 100644
index 0000000..00b1a36
--- /dev/null
+++ b/sdk/packages/shared/src/db/sqlite-db.test.ts
@@ -0,0 +1,155 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	ensureSessionSchema,
+	isSqliteBusyError,
+	loadSqliteDb,
+	withSqliteBusyRetry,
+} from "./sqlite-db";
+
+const require = createRequire(import.meta.url);
+const sqliteAvailable = (() => {
+	try {
+		require("node:sqlite");
+		return true;
+	} catch {
+		return false;
+	}
+})();
+
+describe("isSqliteBusyError", () => {
+	it("detects busy and locked sqlite errors by code", () => {
+		expect(isSqliteBusyError({ code: "SQLITE_BUSY" })).toBe(true);
+		expect(isSqliteBusyError({ code: "SQLITE_LOCKED" })).toBe(true);
+	});
+
+	it("detects busy and locked sqlite errors by message", () => {
+		expect(
+			isSqliteBusyError(new Error("SQLITE_BUSY: database is locked")),
+		).toBe(true);
+		expect(isSqliteBusyError(new Error("database is locked"))).toBe(true);
+	});
+
+	it("does not match unrelated errors", () => {
+		expect(isSqliteBusyError(new Error("something else"))).toBe(false);
+		expect(isSqliteBusyError(undefined)).toBe(false);
+	});
+});
+
+describe("withSqliteBusyRetry", () => {
+	it("retries transient sqlite busy failures and returns the eventual value", () => {
+		let attempts = 0;
+
+		const result = withSqliteBusyRetry(() => {
+			attempts += 1;
+			if (attempts < 3) {
+				throw new Error("SQLITE_BUSY: database is locked");
+			}
+			return "ok";
+		});
+
+		expect(result).toBe("ok");
+		expect(attempts).toBe(3);
+	});
+
+	it("rethrows non-sqlite errors immediately", () => {
+		expect(() =>
+			withSqliteBusyRetry(() => {
+				throw new Error("boom");
+			}),
+		).toThrow("boom");
+	});
+
+	it("stops retrying after the retry budget is exhausted", () => {
+		let attempts = 0;
+
+		expect(() =>
+			withSqliteBusyRetry(() => {
+				attempts += 1;
+				throw new Error("SQLITE_BUSY: database is locked");
+			}),
+		).toThrow("SQLITE_BUSY");
+		expect(attempts).toBe(4);
+	});
+});
+
+describe("ensureSessionSchema", () => {
+	const sqliteIt = sqliteAvailable ? it : it.skip;
+
+	sqliteIt(
+		"adds transcript_path back to legacy sessions tables when missing",
+		() => {
+			const dir = mkdtempSync(join(tmpdir(), "sqlite-schema-migrate-"));
+			try {
+				const db = loadSqliteDb(join(dir, "sessions.db"));
+				db.exec(`CREATE TABLE sessions (
+				session_id TEXT PRIMARY KEY,
+				source TEXT NOT NULL,
+				pid INTEGER NOT NULL,
+				started_at TEXT NOT NULL,
+				ended_at TEXT,
+				exit_code INTEGER,
+				status TEXT NOT NULL,
+				status_lock INTEGER NOT NULL DEFAULT 0,
+				interactive INTEGER NOT NULL,
+				provider TEXT NOT NULL,
+				model TEXT NOT NULL,
+				cwd TEXT NOT NULL,
+				workspace_root TEXT NOT NULL,
+				team_name TEXT,
+				enable_tools INTEGER NOT NULL,
+				enable_spawn INTEGER NOT NULL,
+				enable_teams INTEGER NOT NULL,
+				parent_session_id TEXT,
+				parent_agent_id TEXT,
+				agent_id TEXT,
+				conversation_id TEXT,
+				is_subagent INTEGER NOT NULL DEFAULT 0,
+				prompt TEXT,
+				metadata_json TEXT,
+				hook_path TEXT NOT NULL,
+				messages_path TEXT,
+				updated_at TEXT NOT NULL
+			);`);
+				db.exec(`INSERT INTO sessions (
+				session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
+				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
+				metadata_json, hook_path, messages_path, updated_at
+			) VALUES (
+				'session-1', 'cli', 1, '2026-04-21T00:00:00.000Z', NULL, NULL, 'running', 0, 0,
+				'anthropic', 'claude', '/tmp', '/tmp', NULL, 1, 0, 0,
+				NULL, NULL, NULL, NULL, 0, 'hello',
+				NULL, '', '/tmp/session-1.messages.json', '2026-04-21T00:00:00.000Z'
+			);`);
+
+				ensureSessionSchema(db, { includeLegacyMigrations: true });
+
+				const columns = db
+					.prepare("PRAGMA table_info(sessions);")
+					.all()
+					.map((column) => String(column.name));
+				expect(columns).toContain("transcript_path");
+				expect(columns).toContain("messages_path");
+
+				const row = db
+					.prepare(
+						"SELECT session_id, prompt, transcript_path, messages_path FROM sessions WHERE session_id = ?",
+					)
+					.get("session-1");
+				expect(row).toMatchObject({
+					session_id: "session-1",
+					prompt: "hello",
+					transcript_path: "",
+					messages_path: "/tmp/session-1.messages.json",
+				});
+				db.close?.();
+			} finally {
+				rmSync(dir, { recursive: true, force: true });
+			}
+		},
+	);
+});
diff --git a/sdk/packages/shared/src/db/sqlite-db.ts b/sdk/packages/shared/src/db/sqlite-db.ts
new file mode 100644
index 0000000..3e15b50
--- /dev/null
+++ b/sdk/packages/shared/src/db/sqlite-db.ts
@@ -0,0 +1,381 @@
+import { mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+import { getErrorCode, getErrorMessage } from "../parse/error";
+
+export type SqliteStatement = {
+	run: (...params: unknown[]) => { changes?: number };
+	get: (...params: unknown[]) => Record<string, unknown> | null;
+	all: (...params: unknown[]) => Record<string, unknown>[];
+};
+
+export type SqliteDb = {
+	prepare: (sql: string) => SqliteStatement;
+	exec: (sql: string) => void;
+	close?: () => void;
+};
+
+const SQLITE_BUSY_RETRY_LIMIT = 3;
+const SQLITE_BUSY_RETRY_BASE_DELAY_MS = 50;
+
+export function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export function toBoolInt(value: boolean): number {
+	return value ? 1 : 0;
+}
+
+export function asString(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+export function asOptionalString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function asBool(value: unknown): boolean {
+	return value === 1 || value === true;
+}
+
+function sleepMs(ms: number): void {
+	if (ms <= 0) {
+		return;
+	}
+	try {
+		const shared = new SharedArrayBuffer(4);
+		const array = new Int32Array(shared);
+		Atomics.wait(array, 0, 0, ms);
+	} catch {
+		// Best-effort backoff; skip sleeping if the runtime does not support it.
+	}
+}
+
+export function isSqliteBusyError(error: unknown): boolean {
+	if (!error || typeof error !== "object") {
+		return false;
+	}
+	const message = getErrorMessage(error);
+	const code = getErrorCode(error);
+	return (
+		code === "SQLITE_BUSY" ||
+		code === "SQLITE_LOCKED" ||
+		message.includes("SQLITE_BUSY") ||
+		message.includes("SQLITE_LOCKED") ||
+		message.includes("database is locked")
+	);
+}
+
+export function withSqliteBusyRetry<T>(operation: () => T): T {
+	let attempt = 0;
+	for (;;) {
+		try {
+			return operation();
+		} catch (error) {
+			if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_LIMIT) {
+				throw error;
+			}
+			attempt += 1;
+			sleepMs(SQLITE_BUSY_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1));
+		}
+	}
+}
+
+function wrapBunDb(db: {
+	query: (sql: string) => SqliteStatement;
+	exec: (sql: string) => void;
+	close?: () => void;
+}): SqliteDb {
+	return {
+		prepare: (sql) => {
+			const stmt = db.query(sql);
+			return {
+				run: (...params) => withSqliteBusyRetry(() => stmt.run(...params)),
+				get: (...params) => withSqliteBusyRetry(() => stmt.get(...params)),
+				all: (...params) => withSqliteBusyRetry(() => stmt.all(...params)),
+			};
+		},
+		exec: (sql) => withSqliteBusyRetry(() => db.exec(sql)),
+		close: () => db.close?.(),
+	};
+}
+
+function wrapNodeDb(db: {
+	prepare: (sql: string) => {
+		run: (...params: unknown[]) => { changes?: number };
+		get: (...params: unknown[]) => Record<string, unknown> | undefined;
+		all: (...params: unknown[]) => Record<string, unknown>[];
+	};
+	exec: (sql: string) => void;
+	close?: () => void;
+}): SqliteDb {
+	return {
+		prepare: (sql) => {
+			const stmt = db.prepare(sql);
+			return {
+				run: (...params) => withSqliteBusyRetry(() => stmt.run(...params)),
+				get: (...params) =>
+					withSqliteBusyRetry(() => stmt.get(...params) ?? null),
+				all: (...params) => withSqliteBusyRetry(() => stmt.all(...params)),
+			};
+		},
+		exec: (sql) => withSqliteBusyRetry(() => db.exec(sql)),
+		close: () => db.close?.(),
+	};
+}
+
+export function loadSqliteDb(filePath: string): SqliteDb {
+	mkdirSync(dirname(filePath), { recursive: true });
+	const require = createRequire(import.meta.url);
+
+	if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") {
+		const { Database } = require("bun:sqlite") as {
+			Database: new (
+				path: string,
+				options?: { create?: boolean },
+			) => {
+				query: (sql: string) => SqliteStatement;
+				exec: (sql: string) => void;
+				close?: () => void;
+			};
+		};
+		return wrapBunDb(new Database(filePath, { create: true }));
+	}
+
+	// Suppress "ExperimentalWarning: SQLite is an experimental feature"
+	const originalEmit = process.emitWarning;
+	process.emitWarning = ((warning: string | Error, ...args: unknown[]) => {
+		const msg =
+			typeof warning === "string" ? warning : (warning?.message ?? "");
+		if (msg.includes("SQLite")) return;
+		return (originalEmit as (...args: unknown[]) => void).call(
+			process,
+			warning,
+			...args,
+		);
+	}) as typeof process.emitWarning;
+
+	try {
+		const { DatabaseSync } = require(["node", ":sqlite"].join("")) as {
+			DatabaseSync: new (
+				path: string,
+			) => {
+				prepare: (sql: string) => {
+					run: (...params: unknown[]) => { changes?: number };
+					get: (...params: unknown[]) => Record<string, unknown> | undefined;
+					all: (...params: unknown[]) => Record<string, unknown>[];
+				};
+				exec: (sql: string) => void;
+				close?: () => void;
+			};
+		};
+		return wrapNodeDb(new DatabaseSync(filePath));
+	} finally {
+		process.emitWarning = originalEmit;
+	}
+}
+
+export interface SessionSchemaOptions {
+	includeLegacyMigrations?: boolean;
+}
+
+const SCHEMA_STATEMENTS = [
+	`CREATE TABLE IF NOT EXISTS sessions (
+		session_id TEXT PRIMARY KEY,
+		source TEXT NOT NULL,
+		pid INTEGER NOT NULL,
+		started_at TEXT NOT NULL,
+		ended_at TEXT,
+		exit_code INTEGER,
+		status TEXT NOT NULL,
+		status_lock INTEGER NOT NULL DEFAULT 0,
+		interactive INTEGER NOT NULL,
+		provider TEXT NOT NULL,
+		model TEXT NOT NULL,
+		cwd TEXT NOT NULL,
+		workspace_root TEXT NOT NULL,
+		team_name TEXT,
+		enable_tools INTEGER NOT NULL,
+		enable_spawn INTEGER NOT NULL,
+		enable_teams INTEGER NOT NULL,
+		parent_session_id TEXT,
+		parent_agent_id TEXT,
+		agent_id TEXT,
+		conversation_id TEXT,
+		is_subagent INTEGER NOT NULL DEFAULT 0,
+		prompt TEXT,
+		metadata_json TEXT,
+		transcript_path TEXT NOT NULL DEFAULT '',
+		hook_path TEXT NOT NULL,
+		messages_path TEXT,
+		updated_at TEXT NOT NULL
+	);`,
+	`CREATE TABLE IF NOT EXISTS subagent_spawn_queue (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		root_session_id TEXT NOT NULL,
+		parent_agent_id TEXT NOT NULL,
+		task TEXT,
+		system_prompt TEXT,
+		created_at TEXT NOT NULL,
+		consumed_at TEXT
+	);`,
+	`CREATE TABLE IF NOT EXISTS schedules (
+		schedule_id TEXT PRIMARY KEY,
+		name TEXT NOT NULL,
+		cron_pattern TEXT NOT NULL,
+		prompt TEXT NOT NULL,
+		provider TEXT NOT NULL,
+		model TEXT NOT NULL,
+		mode TEXT NOT NULL DEFAULT 'act',
+		workspace_root TEXT,
+		cwd TEXT,
+		system_prompt TEXT,
+		max_iterations INTEGER,
+		timeout_seconds INTEGER,
+		max_parallel INTEGER NOT NULL DEFAULT 1,
+		enabled INTEGER NOT NULL DEFAULT 1,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL,
+		last_run_at TEXT,
+		next_run_at TEXT,
+		claim_token TEXT,
+		claim_started_at TEXT,
+		claim_until_at TEXT,
+		created_by TEXT,
+		tags TEXT,
+		metadata_json TEXT
+	);`,
+	`CREATE TABLE IF NOT EXISTS schedule_executions (
+		execution_id TEXT PRIMARY KEY,
+		schedule_id TEXT NOT NULL,
+		session_id TEXT,
+		triggered_at TEXT NOT NULL,
+		started_at TEXT,
+		ended_at TEXT,
+		status TEXT NOT NULL,
+		exit_code INTEGER,
+		error_message TEXT,
+		iterations INTEGER,
+		tokens_used INTEGER,
+		cost_usd REAL,
+		FOREIGN KEY (schedule_id) REFERENCES schedules(schedule_id) ON DELETE CASCADE,
+		FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE SET NULL
+	);`,
+	`CREATE INDEX IF NOT EXISTS idx_schedule_executions_schedule
+	ON schedule_executions(schedule_id, triggered_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS idx_schedules_next_run
+	ON schedules(enabled, next_run_at);`,
+];
+
+const LEGACY_MIGRATIONS: Array<{
+	table: string;
+	column: string;
+	sql: string;
+}> = [
+	{
+		table: "sessions",
+		column: "workspace_root",
+		sql: "ALTER TABLE sessions ADD COLUMN workspace_root TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "parent_session_id",
+		sql: "ALTER TABLE sessions ADD COLUMN parent_session_id TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "parent_agent_id",
+		sql: "ALTER TABLE sessions ADD COLUMN parent_agent_id TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "agent_id",
+		sql: "ALTER TABLE sessions ADD COLUMN agent_id TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "conversation_id",
+		sql: "ALTER TABLE sessions ADD COLUMN conversation_id TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "is_subagent",
+		sql: "ALTER TABLE sessions ADD COLUMN is_subagent INTEGER NOT NULL DEFAULT 0;",
+	},
+	{
+		table: "sessions",
+		column: "messages_path",
+		sql: "ALTER TABLE sessions ADD COLUMN messages_path TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "metadata_json",
+		sql: "ALTER TABLE sessions ADD COLUMN metadata_json TEXT;",
+	},
+	{
+		table: "sessions",
+		column: "transcript_path",
+		sql: "ALTER TABLE sessions ADD COLUMN transcript_path TEXT NOT NULL DEFAULT '';",
+	},
+	{
+		table: "schedules",
+		column: "claim_token",
+		sql: "ALTER TABLE schedules ADD COLUMN claim_token TEXT;",
+	},
+	{
+		table: "schedules",
+		column: "claim_started_at",
+		sql: "ALTER TABLE schedules ADD COLUMN claim_started_at TEXT;",
+	},
+	{
+		table: "schedules",
+		column: "claim_until_at",
+		sql: "ALTER TABLE schedules ADD COLUMN claim_until_at TEXT;",
+	},
+];
+
+function getColumnNames(db: SqliteDb, table: string): Set<string> {
+	return new Set(
+		db
+			.prepare(`PRAGMA table_info(${table});`)
+			.all()
+			.map((c) => c.name as string),
+	);
+}
+
+export function ensureSessionSchema(
+	db: SqliteDb,
+	options: SessionSchemaOptions = {},
+): void {
+	db.exec("PRAGMA journal_mode = WAL;");
+	db.exec("PRAGMA busy_timeout = 5000;");
+	for (const stmt of SCHEMA_STATEMENTS) {
+		db.exec(stmt);
+	}
+
+	if (!options.includeLegacyMigrations) return;
+
+	const columnCache = new Map<string, Set<string>>();
+	const getColumns = (table: string) => {
+		let cols = columnCache.get(table);
+		if (!cols) {
+			cols = getColumnNames(db, table);
+			columnCache.set(table, cols);
+		}
+		return cols;
+	};
+
+	for (const migration of LEGACY_MIGRATIONS) {
+		if (!getColumns(migration.table).has(migration.column)) {
+			db.exec(migration.sql);
+			if (migration.column === "workspace_root") {
+				db.exec(
+					"UPDATE sessions SET workspace_root = cwd WHERE workspace_root IS NULL OR workspace_root = '';",
+				);
+			}
+			columnCache.delete(migration.table);
+		}
+	}
+}
diff --git a/sdk/packages/shared/src/dispose.ts b/sdk/packages/shared/src/dispose.ts
new file mode 100644
index 0000000..2d1fb49
--- /dev/null
+++ b/sdk/packages/shared/src/dispose.ts
@@ -0,0 +1,31 @@
+export type Disposable =
+	| (() => void | Promise<void>)
+	| { dispose: () => void | Promise<void> };
+
+const registry: Disposable[] = [];
+
+/**
+ * Register a disposable to be cleaned up when `disposeAll()` is called.
+ * Accepts either a function or an object with a `dispose` method.
+ */
+export function registerDisposable(disposable: Disposable): void {
+	registry.push(disposable);
+}
+
+/**
+ * Dispose all registered disposables in registration order.
+ * Errors from individual disposables are suppressed so all run.
+ */
+export async function disposeAll(): Promise<void> {
+	const items = registry.splice(0);
+	await Promise.all(
+		items.map((d) => {
+			try {
+				const result = typeof d === "function" ? d() : d.dispose();
+				return result ?? Promise.resolve();
+			} catch {
+				return Promise.resolve();
+			}
+		}),
+	);
+}
diff --git a/sdk/packages/shared/src/extensions/context.ts b/sdk/packages/shared/src/extensions/context.ts
new file mode 100644
index 0000000..ecc8895
--- /dev/null
+++ b/sdk/packages/shared/src/extensions/context.ts
@@ -0,0 +1,98 @@
+import type { BasicLogger } from "../logging/logger";
+import type { ITelemetryService } from "../services/telemetry";
+import type { WorkspaceInfo } from "../session/workspace";
+import type {
+	AgentExtensionAutomationContext,
+	AgentExtensionSessionContext,
+} from "./contribution-registry";
+
+/**
+ * The IDE or client surface the user is running Cline from.
+ */
+export type ClientName =
+	| "cline-vscode"
+	| "cline-jetbrains"
+	| "cline-cli"
+	| "cline-sdk"
+	| "cline-kanban"
+	| "cline-acp"
+	| "cline-platform"
+	| (string & {});
+
+/**
+ * Identity of the calling client and host surface.
+ */
+export interface ClientContext {
+	/** Client type emitted to Cline request headers, e.g. "VSCode Extension", "cline-cli", "cline-sdk" */
+	name: ClientName;
+	/** Cline client/extension semver string, e.g. "3.12.0" */
+	version?: string;
+	/** Host platform display name, e.g. "Visual Studio Code", "Cursor", "cli" */
+	platform?: string;
+	/** Host platform version, e.g. vscode.version or the CLI version */
+	platformVersion?: string;
+	/** Whether the host workspace currently has multiple roots. */
+	isMultiRoot?: boolean;
+}
+
+/**
+ * Identity of the authenticated user.
+ */
+export interface UserContext {
+	/** PostHog / analytics distinct ID */
+	distinctId?: string;
+	email?: string;
+	organizationId?: string;
+}
+
+/**
+ * Everything needed to describe the workspace and build the system prompt.
+ *
+ * Extends WorkspaceInfo (rootPath + git fields) with the additional fields
+ * required by buildClineSystemPrompt, so callers can spread a WorkspaceInfo
+ * and add only what they know.
+ */
+export interface WorkspaceContext extends WorkspaceInfo {
+	/**
+	 * Current working directory. May differ from rootPath in multi-root
+	 * workspaces or when the user cd'd inside the workspace.
+	 */
+	cwd?: string;
+	/** Human-readable workspace name shown in the system prompt */
+	workspaceName?: string;
+	/**
+	 * Pre-serialized workspace metadata block that replaces {{CLINE_METADATA}}
+	 * in the system prompt template.
+	 */
+	metadata?: string;
+	/** Agent mode: "act" | "plan" | "yolo" */
+	mode?: string;
+	/** Additional rules/instructions injected into the system prompt */
+	rules?: string;
+	/** IDE display name, e.g. "VS Code", "JetBrains", "Terminal Shell" */
+	ide?: string;
+	/** Node process.platform string, e.g. "darwin", "win32", "linux" */
+	platform?: string;
+}
+
+/**
+ * Ambient runtime context carried alongside ProviderConfig.
+ *
+ * Captures who is calling (user + client), where they are (workspace),
+ * and which services to use for logging and telemetry. None of these
+ * belong in the LLM provider credential config.
+ */
+export interface ExtensionContext {
+	user?: UserContext;
+	client?: ClientContext;
+	workspace?: WorkspaceContext;
+	/** Core session metadata forwarded into plugin setup context. */
+	session?: AgentExtensionSessionContext;
+	/**
+	 * Host-provided automation ingress for plugins. Present when the session is
+	 * started through a ClineCore instance with automation enabled.
+	 */
+	automation?: AgentExtensionAutomationContext;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}
diff --git a/sdk/packages/shared/src/extensions/contribution-registry.test.ts b/sdk/packages/shared/src/extensions/contribution-registry.test.ts
new file mode 100644
index 0000000..1fcba7a
--- /dev/null
+++ b/sdk/packages/shared/src/extensions/contribution-registry.test.ts
@@ -0,0 +1,190 @@
+import { describe, expect, it, vi } from "vitest";
+import { createContributionRegistry } from "./contribution-registry";
+
+describe("ContributionRegistry automation event contributions", () => {
+	it("accepts skills-only plugins without setup contributions", async () => {
+		const registry = createContributionRegistry({
+			extensions: [
+				{
+					name: "skill-pack",
+					manifest: { capabilities: ["skills"] },
+				},
+			],
+		});
+
+		await expect(registry.initialize()).resolves.toBeUndefined();
+		expect(registry.getRegistrySnapshot()).toMatchObject({
+			tools: [],
+			commands: [],
+			rules: [],
+			messageBuilder: [],
+			providers: [],
+			automationEventTypes: [],
+			mcpServers: [],
+		});
+	});
+
+	it("registers automation event types declared by plugins", async () => {
+		const registry = createContributionRegistry({
+			extensions: [
+				{
+					name: "local-events",
+					manifest: { capabilities: ["automationEvents"] },
+					setup(api) {
+						api.registerAutomationEventType({
+							eventType: " local.manual_test ",
+							source: " local ",
+							description: "Manual local smoke test",
+							attributesSchema: {
+								type: "object",
+								properties: { topic: { type: "string" } },
+							},
+							examples: [
+								{
+									eventId: "evt_1",
+									eventType: "local.manual_test",
+									source: "local",
+									occurredAt: "2026-04-24T10:00:00.000Z",
+									attributes: { topic: "cron-feature-2" },
+								},
+							],
+						});
+					},
+				},
+			],
+		});
+
+		await registry.initialize();
+
+		expect(registry.getRegistrySnapshot().automationEventTypes).toEqual([
+			expect.objectContaining({
+				eventType: "local.manual_test",
+				source: "local",
+				description: "Manual local smoke test",
+			}),
+		]);
+		expect(registry.getRegisteredAutomationEventTypes()).toHaveLength(1);
+	});
+
+	it("passes automation ingestion context into setup", async () => {
+		const ingestEvent = vi.fn();
+		const registry = createContributionRegistry({
+			setupContext: {
+				automation: { ingestEvent },
+			},
+			extensions: [
+				{
+					name: "event-source",
+					manifest: { capabilities: ["automationEvents"] },
+					setup(_api, ctx) {
+						ctx.automation?.ingestEvent({
+							eventId: "evt_plugin_1",
+							eventType: "local.plugin_event",
+							source: "local-plugin",
+							occurredAt: "2026-04-24T10:00:00.000Z",
+						});
+					},
+				},
+			],
+		});
+
+		await registry.initialize();
+
+		expect(ingestEvent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				eventId: "evt_plugin_1",
+				eventType: "local.plugin_event",
+			}),
+		);
+	});
+
+	it("passes caller identity and logger context into setup", async () => {
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const registry = createContributionRegistry({
+			setupContext: {
+				session: { sessionId: "sess-1" },
+				client: { name: "cline-sdk", version: "1.0.0" },
+				user: { distinctId: "user-1" },
+				workspaceInfo: { rootPath: "/tmp/workspace" },
+				logger,
+			},
+			extensions: [
+				{
+					name: "context-plugin",
+					manifest: { capabilities: ["tools"] },
+					setup(_api, ctx) {
+						ctx.logger?.log("plugin setup", {
+							sessionId: ctx.session?.sessionId,
+							client: ctx.client?.name,
+						});
+					},
+				},
+			],
+		});
+
+		await registry.initialize();
+
+		expect(logger.log).toHaveBeenCalledWith("plugin setup", {
+			sessionId: "sess-1",
+			client: "cline-sdk",
+		});
+	});
+
+	it("requires the automationEvents capability before registration", async () => {
+		const registry = createContributionRegistry({
+			extensions: [
+				{
+					name: "missing-capability",
+					manifest: { capabilities: ["tools"] },
+					setup(api) {
+						api.registerAutomationEventType({
+							eventType: "local.bad",
+							source: "local",
+						});
+					},
+				},
+			],
+		});
+
+		await expect(registry.initialize()).rejects.toThrow(
+			/registerAutomationEventType requires the "automationEvents" capability/,
+		);
+	});
+
+	it("registers MCP servers declared by plugins", async () => {
+		const registry = createContributionRegistry({
+			extensions: [
+				{
+					name: "github-pack",
+					manifest: { capabilities: ["mcp"] },
+					setup(api) {
+						api.registerMcpServer({
+							name: "github",
+							transport: {
+								type: "stdio",
+								command: "npx",
+								args: ["-y", "@modelcontextprotocol/server-github"],
+							},
+						});
+					},
+				},
+			],
+		});
+
+		await registry.initialize();
+
+		expect(registry.getRegisteredMcpServers()).toEqual([
+			expect.objectContaining({
+				name: "github",
+				metadata: {
+					source: "plugin",
+					plugin: "github-pack",
+				},
+			}),
+		]);
+	});
+});
diff --git a/sdk/packages/shared/src/extensions/contribution-registry.ts b/sdk/packages/shared/src/extensions/contribution-registry.ts
new file mode 100644
index 0000000..9dff782
--- /dev/null
+++ b/sdk/packages/shared/src/extensions/contribution-registry.ts
@@ -0,0 +1,652 @@
+import type { AgentRuntimeHooks, AgentTool } from "../agent";
+import type { AutomationEventEnvelope } from "../cron";
+import type { BasicLogger } from "../logging/logger";
+import type { ITelemetryService } from "../services/telemetry";
+import type { WorkspaceInfo } from "../session/workspace";
+import type { ClientContext, UserContext } from "./context";
+
+export interface AgentExtensionCommand {
+	name: string;
+	description?: string;
+	handler?: (
+		input: string,
+	) => Promise<AgentExtensionCommandResult> | AgentExtensionCommandResult;
+}
+
+export type AgentExtensionCommandResult =
+	| string
+	| {
+			reply?: string;
+			submitPrompt?: string;
+	  };
+
+export interface AgentExtensionRule {
+	id: string;
+	content: string | (() => string | Promise<string>);
+	source?: string;
+}
+
+export interface AgentExtensionMessageBuilder<TMessage = unknown> {
+	name: string;
+	build: (message: TMessage) => TMessage | Promise<TMessage>;
+}
+
+export interface AgentExtensionProvider {
+	name: string;
+	description?: string;
+	metadata?: Record<string, unknown>;
+}
+
+export interface AgentExtensionAutomationEventType {
+	/** Normalized event type a plugin can emit, e.g. `github.pull_request.opened`. */
+	eventType: string;
+	/** Normalized source identifier, e.g. `github`, `linear`, or `local`. */
+	source: string;
+	description?: string;
+	attributesSchema?: Record<string, unknown>;
+	payloadSchema?: Record<string, unknown>;
+	examples?: AutomationEventEnvelope[];
+	metadata?: Record<string, unknown>;
+}
+
+export interface AgentExtensionMcpEnvValue {
+	// Read this environment variable from the host process. Defaults to the target env var name.
+	fromEnv?: string;
+	// Literal fallback value used when `fromEnv` is omitted or not set.
+	value?: string;
+	// Skip the MCP server when no value can be resolved.
+	required?: boolean;
+}
+
+export type AgentExtensionMcpEnv = Record<
+	string,
+	string | AgentExtensionMcpEnvValue
+>;
+
+export interface AgentExtensionMcpStdioTransport {
+	type: "stdio";
+	command: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+}
+
+export interface AgentExtensionMcpSseTransport {
+	type: "sse";
+	url: string;
+	headers?: Record<string, string>;
+}
+
+export interface AgentExtensionMcpStreamableHttpTransport {
+	type: "streamableHttp";
+	url: string;
+	headers?: Record<string, string>;
+}
+
+export type AgentExtensionMcpTransport =
+	| AgentExtensionMcpStdioTransport
+	| AgentExtensionMcpSseTransport
+	| AgentExtensionMcpStreamableHttpTransport;
+
+export interface AgentExtensionMcpServer {
+	name: string;
+	transport: AgentExtensionMcpTransport;
+	// Top-level env values are merged into stdio process env only.
+	env?: AgentExtensionMcpEnv;
+	metadata?: Record<string, unknown>;
+}
+
+export interface AgentExtensionAutomationContext {
+	/**
+	 * Submit a normalized automation event to the host. Raw webhook or connector
+	 * payloads should be translated into an `AutomationEventEnvelope` first.
+	 */
+	ingestEvent: (event: AutomationEventEnvelope) => void | Promise<void>;
+}
+
+export interface AgentExtensionSessionContext {
+	/** Stable core session id for the root session that loaded the plugin. */
+	sessionId?: string;
+}
+
+/**
+ * API surface passed to an extension's `setup()` method.
+ *
+ * Use it to register the contributions the extension wants to make — tools,
+ * commands, message builders, providers, and automation event types. All
+ * registrations accumulate into the `ContributionRegistry` and are available to
+ * the host after `setup()` completes.
+ */
+export interface AgentExtensionApi<TTool = AgentTool, TMessage = unknown> {
+	/** Register a tool the agent can invoke during its run. Requires the `tools` capability. */
+	registerTool: (tool: TTool) => void;
+	/** Register a slash command available in connected chat surfaces. Requires the `commands` capability. */
+	registerCommand: (command: AgentExtensionCommand) => void;
+	/** Register prompt rules included in the runtime system prompt. Requires the `rules` capability. */
+	registerRule: (rule: AgentExtensionRule) => void;
+	/** Register a named message builder for transforming messages before they are sent. Requires the `messageBuilders` capability. */
+	registerMessageBuilder: (
+		builder: AgentExtensionMessageBuilder<TMessage>,
+	) => void;
+	/** Register a provider contribution (e.g. a custom model provider). Requires the `providers` capability. */
+	registerProvider: (provider: AgentExtensionProvider) => void;
+	/** Register a normalized automation event type the plugin can emit. Requires the `automationEvents` capability. */
+	registerAutomationEventType: (
+		eventType: AgentExtensionAutomationEventType,
+	) => void;
+	// Register an MCP server exposed as runtime tools. Requires the `mcp` capability.
+	registerMcpServer: (server: AgentExtensionMcpServer) => void;
+}
+
+export type AgentExtensionHooks = Partial<AgentRuntimeHooks>;
+
+/**
+ * Session-scoped workspace context passed as the second argument to an
+ * extension's `setup(api, ctx)` method.
+ *
+ * These values are always sourced from the host session config — never from
+ * `process.cwd()`. Use them to resolve paths or build workspace-aware tool
+ * schemas at registration time.
+ *
+ * All fields are optional so `setup()` callers that do not have host context
+ * (e.g. unit tests) can omit them without breaking plugins.
+ */
+export interface PluginSetupContext {
+	/**
+	 * Core session metadata known before the first agent run starts.
+	 * Agent-level ids such as `agentId` and `conversationId` are available on
+	 * lifecycle hook contexts once SessionRuntime creates them.
+	 */
+	session?: AgentExtensionSessionContext;
+	/** Host/client identity such as `cline-cli`, `cline-vscode`, or an SDK app. */
+	client?: ClientContext;
+	/** Authenticated user or organization identity when the host provides it. */
+	user?: UserContext;
+	/**
+	 * Structured workspace and git metadata for the session. Contains
+	 * `rootPath`, `hint`, `associatedRemoteUrls`, `latestGitCommitHash`, and
+	 * `latestGitBranchName`. Use `rootPath` for workspace-relative paths and
+	 * the git fields for branch-aware registration or commit attribution at
+	 * setup time.
+	 */
+	workspaceInfo?: WorkspaceInfo;
+	/**
+	 * Automation ingress made available by hosts that enable ClineCore
+	 * automation. Plugins should feature-detect this property so the same plugin
+	 * can run in hosts that do not enable automation.
+	 */
+	automation?: AgentExtensionAutomationContext;
+	/** Host-provided logger scoped to this session/plugin setup. */
+	logger?: BasicLogger;
+	/**
+	 * Host-provided telemetry service when available in the current process.
+	 *
+	 * This service is intentionally not serialized across plugin sandbox process
+	 * boundaries; sandboxed plugins should feature-detect this property and expect
+	 * it to be undefined unless a future host adds an explicit telemetry bridge.
+	 */
+	telemetry?: ITelemetryService;
+}
+
+const ExtensionCapabilityOptions = [
+	"hooks",
+	"tools",
+	"commands",
+	"rules",
+	"skills",
+	"messageBuilders",
+	"providers",
+	"automationEvents",
+	"mcp",
+] as const;
+
+export type AgentExtensionCapability =
+	(typeof ExtensionCapabilityOptions)[number];
+
+export interface PluginManifest {
+	paths?: string[];
+	capabilities: AgentExtensionCapability[];
+	providerIds?: string[];
+	modelIds?: string[];
+}
+
+export interface AgentExtensionRegistry<TTool = AgentTool, TMessage = unknown> {
+	tools: TTool[];
+	commands: AgentExtensionCommand[];
+	rules: AgentExtensionRule[];
+	messageBuilder: AgentExtensionMessageBuilder<TMessage>[];
+	providers: AgentExtensionProvider[];
+	automationEventTypes: AgentExtensionAutomationEventType[];
+	mcpServers: AgentExtensionMcpServer[];
+}
+
+/**
+ * Base shape for a plugin or extension that can be loaded into a
+ * `ContributionRegistry`.
+ *
+ * An extension declares what it does through its `manifest` (capabilities and
+ * hook stages) and implements the corresponding handler methods. The registry
+ * validates at setup time that every declared stage has a matching handler and
+ * that no undeclared handlers are present.
+ *
+ * Hook handler properties are typed `unknown` here so that the generic base
+ * interface stays free of agent-specific imports. Concrete extension types
+ * (e.g. `AgentExtension` in `@cline/agents`) narrow them to the correct
+ * context and return types.
+ */
+export interface ContributionRegistryExtension<
+	TTool = AgentTool,
+	TMessage = unknown,
+> {
+	type?: string; // Default to plugin for now.
+	/** Unique identifier for this extension, used in error messages and hook handler names. */
+	name: string;
+	/** Declares what capabilities and hook stages this extension uses. Validated before `setup()` runs. */
+	manifest: PluginManifest;
+	/** Indicates whether this extension is disabled. Disabled extensions are ignored during setup. */
+	disabled?: boolean;
+	/** Runtime-native hooks consumed directly by `@cline/agents`. */
+	hooks?: AgentExtensionHooks;
+	/**
+	 * Called once during registry setup to register tools, commands, and other
+	 * contributions.
+	 *
+	 * The optional second argument provides workspace context that is always
+	 * sourced from the host session config — never from `process.cwd()`. Use
+	 * `ctx.workspaceInfo?.rootPath` instead of `process.cwd()` or
+	 * `import.meta.url` tricks when you need workspace-relative paths.
+	 */
+	setup?: (
+		api: AgentExtensionApi<TTool, TMessage>,
+		ctx: PluginSetupContext,
+	) => void | Promise<void>;
+}
+
+export interface ContributionRegistryOptions<
+	TExtension extends ContributionRegistryExtension<TTool, TMessage>,
+	TTool = AgentTool,
+	TMessage = unknown,
+> {
+	extensions?: TExtension[];
+	/** Workspace context forwarded to each extension's `setup(api, ctx)` call. */
+	setupContext?: PluginSetupContext;
+}
+
+export interface ContributionRegistryInitializeOptions {
+	tolerateSetupErrors?: boolean;
+}
+
+interface NormalizedExtension<
+	TExtension extends ContributionRegistryExtension<TTool, TMessage>,
+	TTool,
+	TMessage,
+> {
+	extension: TExtension;
+	order: number;
+	manifest: {
+		capabilities: Set<AgentExtensionCapability>;
+		raw: PluginManifest;
+	};
+}
+
+const ALLOWED_CAPABILITIES = new Set<AgentExtensionCapability>(
+	ExtensionCapabilityOptions,
+);
+
+function asExtensionName<TTool, TMessage>(
+	extension: ContributionRegistryExtension<TTool, TMessage>,
+	order: number,
+): string {
+	return extension.name || `extension_${String(order).padStart(4, "0")}`;
+}
+
+function hasValidStringArray(value: unknown): value is string[] {
+	return (
+		Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	);
+}
+
+function normalizeOptionalStringArray(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+	const normalized = value
+		.filter((entry): entry is string => typeof entry === "string")
+		.map((entry) => entry.trim())
+		.filter((entry) => entry.length > 0);
+	return normalized.length > 0 ? normalized : undefined;
+}
+
+export function normalizePluginManifest(
+	manifest: PluginManifest,
+): PluginManifest {
+	const providerIds = normalizeOptionalStringArray(manifest.providerIds);
+	const modelIds = normalizeOptionalStringArray(manifest.modelIds);
+	return {
+		...manifest,
+		...(providerIds ? { providerIds } : {}),
+		...(modelIds ? { modelIds } : {}),
+	};
+}
+
+function normalizeManifest<
+	TExtension extends ContributionRegistryExtension<TTool, TMessage>,
+	TTool,
+	TMessage,
+>(
+	extension: TExtension,
+	order: number,
+): NormalizedExtension<TExtension, TTool, TMessage>["manifest"] {
+	const extensionName = asExtensionName(extension, order);
+	const manifest = extension.manifest;
+	if (!manifest || typeof manifest !== "object") {
+		throw new Error(
+			`Invalid manifest for extension "${extensionName}": manifest is required`,
+		);
+	}
+	if (
+		!Array.isArray(manifest.capabilities) ||
+		manifest.capabilities.length === 0
+	) {
+		throw new Error(
+			`Invalid manifest for extension "${extensionName}": capabilities must be a non-empty array`,
+		);
+	}
+
+	const capabilities = new Set<AgentExtensionCapability>();
+	for (const capability of manifest.capabilities) {
+		if (!ALLOWED_CAPABILITIES.has(capability)) {
+			throw new Error(
+				`Invalid manifest for extension "${extensionName}": unsupported capability "${String(capability)}"`,
+			);
+		}
+		capabilities.add(capability);
+	}
+
+	if (
+		Object.hasOwn(manifest, "providerIds") &&
+		!hasValidStringArray(manifest.providerIds)
+	) {
+		throw new Error(
+			`Invalid manifest for extension "${extensionName}": providerIds must be a string array when provided`,
+		);
+	}
+	if (
+		Object.hasOwn(manifest, "modelIds") &&
+		!hasValidStringArray(manifest.modelIds)
+	) {
+		throw new Error(
+			`Invalid manifest for extension "${extensionName}": modelIds must be a string array when provided`,
+		);
+	}
+	const hookCapabilityEnabled = capabilities.has("hooks");
+	const extensionDefinesHooks = extension.hooks !== undefined;
+	if (extensionDefinesHooks && !hookCapabilityEnabled) {
+		throw new Error(
+			`Invalid manifest for extension "${extensionName}": runtime hooks require the "hooks" capability`,
+		);
+	}
+
+	return {
+		capabilities,
+		raw: normalizePluginManifest(manifest),
+	};
+}
+
+function normalizeAutomationEventType(
+	input: AgentExtensionAutomationEventType,
+	extensionName: string,
+): AgentExtensionAutomationEventType {
+	if (!input || typeof input !== "object") {
+		throw new Error(
+			`Invalid automation event contribution for extension "${extensionName}": expected object`,
+		);
+	}
+	const eventType =
+		typeof input.eventType === "string" ? input.eventType.trim() : "";
+	const source = typeof input.source === "string" ? input.source.trim() : "";
+	if (!eventType) {
+		throw new Error(
+			`Invalid automation event contribution for extension "${extensionName}": eventType is required`,
+		);
+	}
+	if (!source) {
+		throw new Error(
+			`Invalid automation event contribution for extension "${extensionName}": source is required`,
+		);
+	}
+	return {
+		...input,
+		eventType,
+		source,
+		examples: input.examples ? [...input.examples] : undefined,
+		metadata: input.metadata ? { ...input.metadata } : undefined,
+	};
+}
+
+export class ContributionRegistry<
+	TExtension extends ContributionRegistryExtension<TTool, TMessage>,
+	TTool = AgentTool,
+	TMessage = unknown,
+> {
+	private readonly extensions: TExtension[];
+	private readonly registry: AgentExtensionRegistry<TTool, TMessage> = {
+		tools: [],
+		commands: [],
+		rules: [],
+		messageBuilder: [],
+		providers: [],
+		automationEventTypes: [],
+		mcpServers: [],
+	};
+	private normalized: NormalizedExtension<TExtension, TTool, TMessage>[] = [];
+	private phase: "resolve" | "validate" | "setup" | "activate" | "run" =
+		"resolve";
+	private readonly setupContext: PluginSetupContext;
+
+	constructor(
+		options: ContributionRegistryOptions<TExtension, TTool, TMessage> = {},
+	) {
+		this.extensions = options.extensions ?? [];
+		this.setupContext = options.setupContext ?? {};
+	}
+
+	resolve(): void {
+		if (this.phase !== "resolve") return;
+		this.normalized = this.extensions.map((extension, order) => ({
+			extension,
+			order,
+			manifest: {
+				capabilities: new Set(),
+				raw: extension.manifest,
+			},
+		}));
+		this.phase = "validate";
+	}
+
+	validate(): void {
+		if (this.phase === "resolve") this.resolve();
+		if (this.phase !== "validate") return;
+		this.normalized = this.normalized.map((entry) => ({
+			...entry,
+			manifest: normalizeManifest<TExtension, TTool, TMessage>(
+				entry.extension,
+				entry.order,
+			),
+		}));
+		this.phase = "setup";
+	}
+
+	async setup(
+		options: ContributionRegistryInitializeOptions = {},
+	): Promise<void> {
+		if (this.phase === "resolve") this.resolve();
+		if (this.phase === "validate") this.validate();
+		if (this.phase !== "setup") return;
+
+		let firstSetupError: unknown;
+		const successfulSetups: AgentExtensionRegistry<TTool, TMessage>[] = [];
+		for (const entry of this.normalized) {
+			const { extension } = entry;
+			if (extension.disabled) continue;
+			const extensionName = asExtensionName(extension, entry.order);
+			const pending: AgentExtensionRegistry<TTool, TMessage> = {
+				tools: [],
+				commands: [],
+				rules: [],
+				messageBuilder: [],
+				providers: [],
+				automationEventTypes: [],
+				mcpServers: [],
+			};
+			const api: AgentExtensionApi<TTool, TMessage> = {
+				registerTool: (tool) => pending.tools.push(tool),
+				registerCommand: (command) => pending.commands.push(command),
+				registerRule: (rule) => {
+					if (!entry.manifest.capabilities.has("rules")) {
+						throw new Error(
+							`Invalid setup for extension "${extensionName}": registerRule requires the "rules" capability`,
+						);
+					}
+					pending.rules.push(rule);
+				},
+				registerMessageBuilder: (builder) =>
+					pending.messageBuilder.push(builder),
+				registerProvider: (provider) => pending.providers.push(provider),
+				registerAutomationEventType: (eventType) => {
+					if (!entry.manifest.capabilities.has("automationEvents")) {
+						throw new Error(
+							`Invalid setup for extension "${extensionName}": registerAutomationEventType requires the "automationEvents" capability`,
+						);
+					}
+					pending.automationEventTypes.push(
+						normalizeAutomationEventType(eventType, extensionName),
+					);
+				},
+				registerMcpServer: (server) => {
+					if (!entry.manifest.capabilities.has("mcp")) {
+						throw new Error(
+							`Invalid setup for extension "${extensionName}": registerMcpServer requires the "mcp" capability`,
+						);
+					}
+					pending.mcpServers.push({
+						...server,
+						metadata: {
+							...(server.metadata ?? {}),
+							source: "plugin",
+							plugin: extensionName,
+						},
+					});
+				},
+			};
+			const setupContext = entry.manifest.capabilities.has("automationEvents")
+				? this.setupContext
+				: {
+						...this.setupContext,
+						automation: undefined,
+					};
+			try {
+				await extension.setup?.(api, setupContext);
+				successfulSetups.push(pending);
+			} catch (error) {
+				if (options.tolerateSetupErrors !== true) {
+					throw error;
+				}
+				firstSetupError ??= error;
+			}
+		}
+		if (firstSetupError && options.tolerateSetupErrors !== true) {
+			throw firstSetupError;
+		}
+		for (const pending of successfulSetups) {
+			this.registry.tools.push(...pending.tools);
+			this.registry.commands.push(...pending.commands);
+			this.registry.rules.push(...pending.rules);
+			this.registry.messageBuilder.push(...pending.messageBuilder);
+			this.registry.providers.push(...pending.providers);
+			this.registry.automationEventTypes.push(...pending.automationEventTypes);
+			this.registry.mcpServers.push(...pending.mcpServers);
+		}
+		this.phase = "activate";
+		if (firstSetupError) {
+			throw firstSetupError;
+		}
+	}
+
+	activate(): void {
+		if (this.phase === "resolve") this.resolve();
+		if (this.phase === "validate") this.validate();
+		if (this.phase === "setup") {
+			throw new Error(
+				"Contribution registry setup must complete before activation",
+			);
+		}
+		if (this.phase !== "activate") return;
+		this.phase = "run";
+	}
+
+	async initialize(
+		options: ContributionRegistryInitializeOptions = {},
+	): Promise<void> {
+		this.resolve();
+		this.validate();
+		try {
+			await this.setup(options);
+		} finally {
+			if (this.phase === "activate") {
+				this.activate();
+			}
+		}
+	}
+
+	isActivated(): boolean {
+		return this.phase === "run";
+	}
+
+	getRegistrySnapshot(): AgentExtensionRegistry<TTool, TMessage> {
+		return {
+			tools: [...this.registry.tools],
+			commands: [...this.registry.commands],
+			rules: [...this.registry.rules],
+			messageBuilder: [...this.registry.messageBuilder],
+			providers: [...this.registry.providers],
+			automationEventTypes: [...this.registry.automationEventTypes],
+			mcpServers: [...this.registry.mcpServers],
+		};
+	}
+
+	getRegisteredTools(): TTool[] {
+		return [...this.registry.tools];
+	}
+
+	getRegisteredRules(): AgentExtensionRule[] {
+		return [...this.registry.rules];
+	}
+
+	getRegisteredAutomationEventTypes(): AgentExtensionAutomationEventType[] {
+		return [...this.registry.automationEventTypes];
+	}
+
+	getRegisteredMcpServers(): AgentExtensionMcpServer[] {
+		return [...this.registry.mcpServers];
+	}
+
+	getValidatedExtensions(): TExtension[] {
+		if (this.phase === "resolve") this.resolve();
+		if (this.phase === "validate") this.validate();
+		return this.normalized
+			.slice()
+			.sort((a, b) => a.order - b.order)
+			.map(({ extension }) => extension);
+	}
+}
+
+export function createContributionRegistry<
+	TExtension extends ContributionRegistryExtension<TTool, TMessage>,
+	TTool = AgentTool,
+	TMessage = unknown,
+>(
+	options: ContributionRegistryOptions<TExtension, TTool, TMessage> = {},
+): ContributionRegistry<TExtension, TTool, TMessage> {
+	return new ContributionRegistry(options);
+}
diff --git a/sdk/packages/shared/src/extensions/plugin.ts b/sdk/packages/shared/src/extensions/plugin.ts
new file mode 100644
index 0000000..d5539d9
--- /dev/null
+++ b/sdk/packages/shared/src/extensions/plugin.ts
@@ -0,0 +1 @@
+export const PLUGIN_FILE_EXTENSIONS = [".js", ".ts"];
diff --git a/sdk/packages/shared/src/feature-flags.ts b/sdk/packages/shared/src/feature-flags.ts
new file mode 100644
index 0000000..447d5f7
--- /dev/null
+++ b/sdk/packages/shared/src/feature-flags.ts
@@ -0,0 +1,67 @@
+export const FeatureFlag = {
+	/** Enables ClinePass provider/model list exposure in supported clients. */
+	CLINE_PASS: "ext-cline-pass",
+} as const;
+
+export type KnownFeatureFlag = (typeof FeatureFlag)[keyof typeof FeatureFlag];
+export type FeatureFlag = KnownFeatureFlag | (string & {});
+
+export type FeatureFlagJsonValue =
+	| string
+	| number
+	| boolean
+	| null
+	| { [key: string]: FeatureFlagJsonValue }
+	| FeatureFlagJsonValue[];
+
+export type FeatureFlagPayload = FeatureFlagJsonValue;
+
+export type FeatureFlagsAndPayloads = {
+	featureFlags?: Record<string, FeatureFlagPayload>;
+	featureFlagPayloads?: Record<string, FeatureFlagPayload>;
+};
+
+export interface FeatureFlagsContext {
+	/** Stable SDK/client/user identifier used by providers that evaluate per identity. */
+	distinctId?: string;
+	/** Authenticated Cline account/user ID, when available. */
+	userId?: string | null;
+	/** Optional SDK consumer name, e.g. `my-production-app`. */
+	clientName?: string;
+}
+
+type AssertTrue<T extends true> = T;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type HasNonPrimitiveFieldNames<T> = {
+	[K in keyof T]-?: Exclude<T[K], Primitive> extends never ? never : K;
+}[keyof T];
+type HasOnlyPrimitiveFields<T> =
+	HasNonPrimitiveFieldNames<T> extends never ? true : false;
+export type FeatureFlagsContextPrimitiveValued = AssertTrue<
+	HasOnlyPrimitiveFields<FeatureFlagsContext>
+>;
+
+export interface FeatureFlagsSettings {
+	/** Whether the provider is enabled. */
+	enabled: boolean;
+	/** Optional timeout in ms for feature flag requests. */
+	timeoutMs?: number;
+}
+
+export interface IFeatureFlagsProvider {
+	getAllFlagsAndPayloads(options: {
+		flagKeys?: readonly string[];
+		context: FeatureFlagsContext;
+	}): Promise<FeatureFlagsAndPayloads | undefined>;
+	readonly enabled: boolean;
+	getSettings(): FeatureFlagsSettings;
+	dispose(): Promise<void>;
+}
+
+export const FeatureFlagDefaultValue: Partial<
+	Record<FeatureFlag, FeatureFlagPayload | undefined>
+> = {
+	[FeatureFlag.CLINE_PASS]: false,
+};
+
+export const FEATURE_FLAGS: readonly FeatureFlag[] = Object.values(FeatureFlag);
diff --git a/sdk/packages/shared/src/hooks/contracts.ts b/sdk/packages/shared/src/hooks/contracts.ts
new file mode 100644
index 0000000..7a28565
--- /dev/null
+++ b/sdk/packages/shared/src/hooks/contracts.ts
@@ -0,0 +1,9 @@
+export interface HookControl {
+	cancel?: boolean;
+	review?: boolean;
+	context?: string;
+	overrideInput?: unknown;
+	systemPrompt?: string;
+	appendMessages?: unknown[];
+	replaceMessages?: unknown[];
+}
diff --git a/sdk/packages/shared/src/hooks/events.ts b/sdk/packages/shared/src/hooks/events.ts
new file mode 100644
index 0000000..0e2435c
--- /dev/null
+++ b/sdk/packages/shared/src/hooks/events.ts
@@ -0,0 +1,327 @@
+import { z } from "zod";
+import type { ToolCallRecord } from "../llms/tools";
+import type { HookSessionContext } from "../session/hook-context";
+import type { WorkspaceInfo } from "../session/workspace";
+import type { HookControl } from "./contracts";
+
+type AgentHookControl = Omit<HookControl, "appendMessages"> & {
+	systemPrompt?: string;
+	appendMessages?: unknown[];
+};
+
+export interface AgentHookRunStartPayload {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	userMessage: string;
+}
+
+export interface AgentHookToolCallStartPayload {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	call: { id: string; name: string; input: unknown };
+}
+
+export interface AgentHookToolCallEndPayload {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	record: ToolCallRecord;
+}
+
+export interface AgentHookTurnEndPayload {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	turn: unknown;
+}
+
+export interface AgentHookStopErrorPayload {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	iteration: number;
+	error: Error;
+}
+
+export interface AgentHookSessionShutdownPayload {
+	agentId: string;
+	conversationId: string;
+	parentAgentId: string | null;
+	reason?: string;
+}
+
+export const HookEventNameSchema = z.enum([
+	"agent_start",
+	"agent_resume",
+	"agent_abort",
+	"agent_end",
+	"agent_error",
+	"tool_call",
+	"tool_result",
+	"prompt_submit",
+	"pre_compact",
+	"session_shutdown",
+]);
+
+export type HookEventName = z.infer<typeof HookEventNameSchema>;
+
+const StringMapSchema = z.record(z.string(), z.string());
+
+export interface PreToolUseData {
+	toolName: string;
+	parameters: Record<string, string>;
+}
+
+export interface PostToolUseData {
+	toolName: string;
+	parameters: Record<string, string>;
+	result: string;
+	success: boolean;
+	executionTimeMs: number;
+}
+
+export interface UserPromptSubmitData {
+	prompt: string;
+	attachments: string[];
+}
+
+export interface TaskStartData {
+	taskMetadata: Record<string, string>;
+}
+
+export interface TaskResumeData {
+	taskMetadata: Record<string, string>;
+	previousState: Record<string, string>;
+}
+
+export interface TaskCancelData {
+	taskMetadata: Record<string, string>;
+}
+
+export interface TaskCompleteData {
+	taskMetadata: Record<string, string>;
+}
+
+export interface PreCompactData {
+	taskId: string;
+	ulid: string;
+	contextSize: number;
+	compactionStrategy: string;
+	previousApiReqIndex: number;
+	tokensIn: number;
+	tokensOut: number;
+	tokensInCache: number;
+	tokensOutCache: number;
+	deletedRangeStart: number;
+	deletedRangeEnd: number;
+	contextJsonPath: string;
+	contextRawPath: string;
+}
+
+const PreToolUseDataSchema = z.object({
+	toolName: z.string(),
+	parameters: StringMapSchema,
+});
+
+const PostToolUseDataSchema = z.object({
+	toolName: z.string(),
+	parameters: StringMapSchema,
+	result: z.string(),
+	success: z.boolean(),
+	executionTimeMs: z.number(),
+});
+
+const UserPromptSubmitDataSchema = z.object({
+	prompt: z.string(),
+	attachments: z.array(z.string()),
+});
+
+const TaskStartDataSchema = z.object({ taskMetadata: StringMapSchema });
+const TaskResumeDataSchema = z.object({
+	taskMetadata: StringMapSchema,
+	previousState: StringMapSchema,
+});
+const TaskCancelDataSchema = z.object({ taskMetadata: StringMapSchema });
+const TaskCompleteDataSchema = z.object({ taskMetadata: StringMapSchema });
+
+const PreCompactDataSchema = z.object({
+	taskId: z.string(),
+	ulid: z.string(),
+	contextSize: z.number(),
+	compactionStrategy: z.string(),
+	previousApiReqIndex: z.number(),
+	tokensIn: z.number(),
+	tokensOut: z.number(),
+	tokensInCache: z.number(),
+	tokensOutCache: z.number(),
+	deletedRangeStart: z.number(),
+	deletedRangeEnd: z.number(),
+	contextJsonPath: z.string(),
+	contextRawPath: z.string(),
+});
+
+export interface HookEventPayloadBase {
+	clineVersion: string;
+	hookName: HookEventName;
+	timestamp: string;
+	taskId: string;
+	sessionContext?: HookSessionContext;
+	workspaceRoots: string[];
+	/**
+	 * Structured workspace and git metadata for the session.
+	 *
+	 * Contains `rootPath`, `hint`, `associatedRemoteUrls`,
+	 * `latestGitCommitHash`, and `latestGitBranchName` — the same data as
+	 * `workspaceRoots[0]` plus the git fields. Hook scripts can use this for
+	 * branch-aware logic or commit attribution without running `git` themselves.
+	 *
+	 * `undefined` when the session has no workspace metadata (e.g. unit tests
+	 * or sessions started without a `cwd`).
+	 */
+	workspaceInfo?: WorkspaceInfo;
+	userId: string;
+	agent_id: string;
+	parent_agent_id: string | null;
+	preToolUse?: PreToolUseData | undefined;
+	postToolUse?: PostToolUseData | undefined;
+	userPromptSubmit?: UserPromptSubmitData | undefined;
+	taskStart?: TaskStartData | undefined;
+	taskResume?: TaskResumeData | undefined;
+	taskCancel?: TaskCancelData | undefined;
+	taskComplete?: TaskCompleteData | undefined;
+	preCompact?: PreCompactData | undefined;
+}
+
+export interface ToolCallHookPayload extends HookEventPayloadBase {
+	hookName: "tool_call";
+	iteration: number;
+	tool_call: {
+		id: string;
+		name: string;
+		input: unknown;
+	};
+}
+
+export interface ToolResultHookPayload extends HookEventPayloadBase {
+	hookName: "tool_result";
+	iteration: number;
+	tool_result: ToolCallRecord;
+}
+
+export interface AgentEndHookPayload extends HookEventPayloadBase {
+	hookName: "agent_end";
+	iteration: number;
+	turn?: unknown;
+}
+
+export interface AgentErrorHookPayload extends HookEventPayloadBase {
+	hookName: "agent_error";
+	iteration: number;
+	error: {
+		name: string;
+		message: string;
+		stack?: string;
+	};
+}
+
+export interface AgentStartHookPayload extends HookEventPayloadBase {
+	hookName: "agent_start";
+}
+
+export interface AgentResumeHookPayload extends HookEventPayloadBase {
+	hookName: "agent_resume";
+}
+
+export interface AgentAbortHookPayload extends HookEventPayloadBase {
+	hookName: "agent_abort";
+	reason?: string;
+}
+
+export interface PromptSubmitHookPayload extends HookEventPayloadBase {
+	hookName: "prompt_submit";
+}
+
+export interface PreCompactHookPayload extends HookEventPayloadBase {
+	hookName: "pre_compact";
+	preCompact: PreCompactData;
+}
+
+export interface SessionShutdownHookPayload extends HookEventPayloadBase {
+	hookName: "session_shutdown";
+	reason?: string;
+}
+
+export type HookEventPayload =
+	| ToolCallHookPayload
+	| ToolResultHookPayload
+	| AgentStartHookPayload
+	| AgentResumeHookPayload
+	| AgentAbortHookPayload
+	| PromptSubmitHookPayload
+	| PreCompactHookPayload
+	| AgentEndHookPayload
+	| AgentErrorHookPayload
+	| SessionShutdownHookPayload;
+
+export const HookEventPayloadSchema: z.ZodType<unknown> = z
+	.object({
+		clineVersion: z.string(),
+		hookName: HookEventNameSchema,
+		timestamp: z.string(),
+		taskId: z.string(),
+		sessionContext: z
+			.object({
+				rootSessionId: z.string().optional(),
+				hookLogPath: z.string().optional(),
+			})
+			.optional(),
+		workspaceRoots: z.array(z.string()),
+		workspaceInfo: z.custom<WorkspaceInfo>().optional(),
+		userId: z.string(),
+		agent_id: z.string(),
+		parent_agent_id: z.string().nullable(),
+		iteration: z.number().optional(),
+		reason: z.string().optional(),
+		tool_call: z
+			.object({
+				id: z.string(),
+				name: z.string(),
+				input: z.unknown(),
+			})
+			.optional(),
+		tool_result: z.custom<ToolCallRecord>().optional(),
+		turn: z.unknown().optional(),
+		error: z
+			.object({
+				name: z.string(),
+				message: z.string(),
+				stack: z.string().optional(),
+			})
+			.optional(),
+		preToolUse: PreToolUseDataSchema.optional(),
+		postToolUse: PostToolUseDataSchema.optional(),
+		userPromptSubmit: UserPromptSubmitDataSchema.optional(),
+		taskStart: TaskStartDataSchema.optional(),
+		taskResume: TaskResumeDataSchema.optional(),
+		taskCancel: TaskCancelDataSchema.optional(),
+		taskComplete: TaskCompleteDataSchema.optional(),
+		preCompact: PreCompactDataSchema.optional(),
+	})
+	.passthrough();
+
+export function parseHookEventPayload(
+	value: unknown,
+): HookEventPayload | undefined {
+	const parsed = HookEventPayloadSchema.safeParse(value);
+	if (!parsed.success) {
+		return undefined;
+	}
+	return parsed.data as HookEventPayload;
+}
+
+export type SubprocessHookControl = AgentHookControl;
diff --git a/sdk/packages/shared/src/hub.test.ts b/sdk/packages/shared/src/hub.test.ts
new file mode 100644
index 0000000..fa617eb
--- /dev/null
+++ b/sdk/packages/shared/src/hub.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { isHubProtocolCompatible } from "./hub";
+
+describe("isHubProtocolCompatible", () => {
+	it("accepts a hub whose supported client range includes the client protocol", () => {
+		expect(
+			isHubProtocolCompatible({
+				protocolVersion: "v2",
+				minClientProtocolVersion: "v1",
+				maxClientProtocolVersion: "v2",
+			}),
+		).toEqual({ compatible: true });
+	});
+
+	it("rejects a hub whose supported client range excludes the client protocol", () => {
+		expect(
+			isHubProtocolCompatible({
+				protocolVersion: "v2",
+				minClientProtocolVersion: "v2",
+				maxClientProtocolVersion: "v3",
+			}),
+		).toEqual({ compatible: false, reason: "unsupported_protocol" });
+	});
+
+	it("rejects missing or malformed protocol versions", () => {
+		expect(isHubProtocolCompatible({ protocolVersion: "" })).toEqual({
+			compatible: false,
+			reason: "missing_protocol",
+		});
+	});
+});
diff --git a/sdk/packages/shared/src/hub.ts b/sdk/packages/shared/src/hub.ts
new file mode 100644
index 0000000..03a91a4
--- /dev/null
+++ b/sdk/packages/shared/src/hub.ts
@@ -0,0 +1,801 @@
+import type { AgentMessage } from "./agent";
+import type { ReasoningEffort } from "./agents/types";
+import type { GatewayModelSelection, JsonValue } from "./llms/gateway";
+import type { RuntimeConfigExtensionKind } from "./session/runtime-config";
+
+export type HubProtocolVersion = "v1";
+
+export const CURRENT_HUB_PROTOCOL_VERSION: HubProtocolVersion = "v1";
+export const MIN_CLIENT_HUB_PROTOCOL_VERSION: HubProtocolVersion = "v1";
+export const MAX_CLIENT_HUB_PROTOCOL_VERSION: HubProtocolVersion = "v1";
+
+export type HubCapabilityName =
+	| "client.register"
+	| "client.list"
+	| "session.create"
+	| "session.list"
+	| "session.get"
+	| "session.run"
+	| "session.abort"
+	| "schedule.create"
+	| "schedule.list"
+	| "settings.get"
+	| "settings.set";
+
+export const HUB_CAPABILITIES: readonly HubCapabilityName[] = [
+	"client.register",
+	"client.list",
+	"session.create",
+	"session.list",
+	"session.get",
+	"session.run",
+	"session.abort",
+	"schedule.create",
+	"schedule.list",
+	"settings.get",
+	"settings.set",
+];
+
+export interface HubProtocolMetadata {
+	protocolVersion: string;
+	minClientProtocolVersion?: string;
+	maxClientProtocolVersion?: string;
+	capabilities?: readonly string[];
+}
+
+export type HubCompatibilityResult =
+	| { compatible: true }
+	| { compatible: false; reason: "missing_protocol" | "unsupported_protocol" };
+
+function parseHubProtocolNumber(
+	version: string | undefined,
+): number | undefined {
+	const match = /^v(\d+)$/.exec(version?.trim() ?? "");
+	if (!match) {
+		return undefined;
+	}
+	return Number.parseInt(match[1] ?? "", 10);
+}
+
+export function isHubProtocolCompatible(
+	hub: HubProtocolMetadata,
+	clientProtocolVersion: HubProtocolVersion = CURRENT_HUB_PROTOCOL_VERSION,
+): HubCompatibilityResult {
+	const hubProtocol = parseHubProtocolNumber(hub.protocolVersion);
+	const clientProtocol = parseHubProtocolNumber(clientProtocolVersion);
+	if (hubProtocol === undefined || clientProtocol === undefined) {
+		return { compatible: false, reason: "missing_protocol" };
+	}
+	const minClientProtocol =
+		parseHubProtocolNumber(hub.minClientProtocolVersion) ?? hubProtocol;
+	const maxClientProtocol =
+		parseHubProtocolNumber(hub.maxClientProtocolVersion) ?? hubProtocol;
+	return clientProtocol >= minClientProtocol &&
+		clientProtocol <= maxClientProtocol
+		? { compatible: true }
+		: { compatible: false, reason: "unsupported_protocol" };
+}
+
+export type HubActorKind = "client" | "peerHub";
+
+export type HubTransportKind =
+	| "native"
+	| "browser"
+	| "remote"
+	| "native-grpc"
+	| "browser-ws"
+	| "browser-grpc-web"
+	| "peer-grpc";
+
+export type HubRuntimeStatus =
+	| "idle"
+	| "running"
+	| "pending"
+	| "completed"
+	| "aborted"
+	| "failed";
+
+export type HubSpokeStatus =
+	| "starting"
+	| "ready"
+	| "busy"
+	| "stopping"
+	| "stopped"
+	| "failed";
+
+export interface ClientCapability {
+	name: string;
+	description?: string;
+	scopes?: string[];
+	payloadSchema?: Record<string, unknown>;
+}
+
+export interface HubClientRegistration {
+	clientId?: string;
+	clientType: string;
+	displayName?: string;
+	actorKind?: HubActorKind;
+	transport: HubTransportKind;
+	capabilities?: ClientCapability[];
+	metadata?: Record<string, JsonValue | undefined>;
+	workspaceContext?: {
+		workspaceRoot?: string;
+		cwd?: string;
+	};
+	protocolVersion?: HubProtocolVersion;
+}
+
+export interface HubClientRecord {
+	clientId: string;
+	clientType: string;
+	displayName?: string;
+	actorKind: HubActorKind;
+	connectedAt: number;
+	lastSeenAt: number;
+	transport: HubTransportKind;
+	capabilities: ClientCapability[];
+	metadata?: Record<string, JsonValue | undefined>;
+	workspaceContext?: {
+		workspaceRoot?: string;
+		cwd?: string;
+	};
+}
+
+export interface SessionParticipant {
+	clientId: string;
+	attachedAt: number;
+	role?: "creator" | "participant" | "observer";
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export interface SessionMetrics {
+	inputTokens?: number;
+	outputTokens?: number;
+	cacheReadTokens?: number;
+	cacheWriteTokens?: number;
+	totalCost?: number;
+}
+
+export interface HubTeamMembership {
+	teamId: string;
+	role?: "lead" | "teammate" | "contractor";
+}
+
+export interface HubSessionRuntimeSnapshot {
+	runId?: string;
+	status?: HubRuntimeStatus;
+	iteration?: number;
+	messages?: AgentMessage[];
+	pendingToolCalls?: unknown[];
+	usage?: SessionMetrics;
+	aggregateUsage?: SessionMetrics;
+	lastError?: string;
+}
+
+export interface SessionRecord {
+	sessionId: string;
+	workspaceRoot: string;
+	cwd?: string;
+	createdAt: number;
+	updatedAt: number;
+	createdByClientId: string;
+	assignedSpokeId?: string;
+	status: HubRuntimeStatus;
+	/**
+	 * Clients currently observing or attached to this session. Participants do not
+	 * own client-local capabilities; capability routing is owned by the client that
+	 * created/restored the runtime session and advertised those capabilities.
+	 */
+	participants: SessionParticipant[];
+	activeRunId?: string;
+	runtimeOptions?: HubSessionRuntimeOptions;
+	metadata?: Record<string, JsonValue | undefined>;
+	runtimeSession?: {
+		agentId: string;
+		agentRole?: string;
+		team?: HubTeamMembership;
+	};
+	usage?: SessionMetrics;
+	aggregateUsage?: SessionMetrics;
+}
+
+export interface HubSessionSnapshot {
+	sessionId: string;
+	agentId: string;
+	agentRole?: string;
+	workspacePath: string;
+	rootPath?: string;
+	createdAt: number;
+	updatedAt: number;
+	messages: AgentMessage[];
+	runCount: number;
+	lastRunId?: string;
+	status: HubRuntimeStatus;
+	metadata?: Record<string, unknown>;
+	team?: HubTeamMembership;
+	runtime?: HubSessionRuntimeSnapshot;
+}
+
+export interface SpokeRecord {
+	spokeId: string;
+	kind: "subprocess";
+	status: HubSpokeStatus;
+	workspaceRoots: string[];
+	sessionIds: string[];
+	startedAt: number;
+	lastSeenAt: number;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export type ApprovalStatus = "pending" | "approved" | "rejected" | "cancelled";
+
+export interface ApprovalRequestRecord {
+	approvalId: string;
+	sessionId: string;
+	requestedByClientId: string;
+	targetClientId?: string;
+	status: ApprovalStatus;
+	requestedAt: number;
+	resolvedAt?: number;
+	payload: Record<string, JsonValue | undefined>;
+	response?: {
+		approved: boolean;
+		respondedByClientId: string;
+		payload?: Record<string, JsonValue | undefined>;
+	};
+}
+
+export type CapabilityRequestStatus =
+	| "pending"
+	| "resolved"
+	| "rejected"
+	| "cancelled";
+
+export interface CapabilityRequestRecord {
+	requestId: string;
+	sessionId: string;
+	requestedByClientId: string;
+	targetClientId?: string;
+	capabilityName: string;
+	status: CapabilityRequestStatus;
+	requestedAt: number;
+	resolvedAt?: number;
+	payload?: Record<string, JsonValue | undefined>;
+	response?: {
+		ok: boolean;
+		respondedByClientId: string;
+		payload?: Record<string, JsonValue | undefined>;
+		error?: string;
+	};
+}
+
+export interface PeerHubRecord {
+	peerHubId: string;
+	status: "connecting" | "ready" | "disconnected" | "failed";
+	connectedAt: number;
+	lastSeenAt: number;
+	transport: Extract<HubTransportKind, "peer-grpc" | "remote" | "native">;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export interface ScheduleRecord {
+	scheduleId: string;
+	name: string;
+	cronPattern: string;
+	prompt: string;
+	workspaceRoot: string;
+	cwd?: string;
+	modelSelection?: GatewayModelSelection;
+	enabled: boolean;
+	mode?: "act" | "plan" | "yolo";
+	systemPrompt?: string;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	maxParallel?: number;
+	createdAt: number;
+	updatedAt: number;
+	nextRunAt?: number;
+	lastRunAt?: number;
+	createdBy?: string;
+	tags?: string[];
+	runtimeOptions?: HubSessionRuntimeOptions;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export type ScheduleExecutionStatus =
+	| "pending"
+	| "running"
+	| "success"
+	| "completed"
+	| "failed"
+	| "timeout"
+	| "aborted";
+
+export interface ScheduleExecutionRecord {
+	executionId: string;
+	scheduleId: string;
+	sessionId?: string;
+	triggeredAt: number;
+	startedAt?: number;
+	endedAt?: number;
+	status: ScheduleExecutionStatus;
+	exitCode?: number;
+	errorMessage?: string;
+	iterations?: number;
+	tokensUsed?: number;
+	costUsd?: number;
+}
+
+export interface HubScheduleCreateInput {
+	name: string;
+	cronPattern: string;
+	prompt: string;
+	workspaceRoot: string;
+	cwd?: string;
+	modelSelection?: GatewayModelSelection;
+	enabled?: boolean;
+	mode?: "act" | "plan" | "yolo";
+	systemPrompt?: string;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	maxParallel?: number;
+	createdBy?: string;
+	tags?: string[];
+	runtimeOptions?: HubSessionRuntimeOptions;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubScheduleUpdateInput {
+	scheduleId: string;
+	name?: string;
+	cronPattern?: string;
+	prompt?: string;
+	workspaceRoot?: string;
+	cwd?: string;
+	modelSelection?: GatewayModelSelection;
+	enabled?: boolean;
+	mode?: "act" | "plan" | "yolo";
+	systemPrompt?: string | null;
+	maxIterations?: number | null;
+	timeoutSeconds?: number | null;
+	maxParallel?: number;
+	createdBy?: string | null;
+	tags?: string[];
+	runtimeOptions?: HubSessionRuntimeOptions;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export type HubCommandName =
+	| "client.register"
+	| "client.update"
+	| "client.unregister"
+	| "client.list"
+	| "cline.account.get_current"
+	| "prompt_commands.list"
+	| "prompt_commands.execute"
+	| "mention_files.search"
+	| "catalog.list"
+	| "session.list"
+	| "session.create"
+	| "session.attach"
+	| "session.detach"
+	| "session.get"
+	| "session.messages"
+	| "session.restore"
+	| "session.delete"
+	| "session.update"
+	| "session.update_connection"
+	| "session.compaction.get"
+	| "session.compaction.update"
+	| "session.pending_prompts"
+	| "session.update_pending_prompt"
+	| "session.remove_pending_prompt"
+	| "session.fork"
+	| "session.hook"
+	| "run.start"
+	| "session.send_input"
+	| "run.abort"
+	| "approval.request"
+	| "approval.respond"
+	| "capability.request"
+	| "capability.progress"
+	| "capability.respond"
+	| "peer.register"
+	| "peer.list_sessions"
+	| "peer.attach_session"
+	| "peer.detach_session"
+	| "peer.proxy_command"
+	| "schedule.create"
+	| "schedule.list"
+	| "schedule.get"
+	| "schedule.update"
+	| "schedule.delete"
+	| "schedule.enable"
+	| "schedule.disable"
+	| "schedule.trigger"
+	| "schedule.list_executions"
+	| "schedule.stats"
+	| "schedule.active"
+	| "schedule.upcoming"
+	| "settings.list"
+	| "settings.get"
+	| "settings.patch"
+	| "settings.toggle"
+	| "connector.channels"
+	| "connector.configure"
+	| "connector.delete_config"
+	| "cron.event.ingest"
+	| "cron.event.list"
+	| "cron.event.get"
+	| "ui.notify"
+	| "ui.show_window";
+
+export const HUB_DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
+export const HUB_COMMAND_SLOW_LOG_MS = 5_000;
+
+export function getDefaultHubCommandTimeoutMs(
+	command: HubCommandName,
+): number | null {
+	switch (command) {
+		case "run.start":
+		case "session.send_input":
+			return null;
+		default:
+			return HUB_DEFAULT_COMMAND_TIMEOUT_MS;
+	}
+}
+
+export function resolveHubCommandTimeoutMs(
+	command: HubCommandName,
+	timeoutMs?: number | null,
+): number | null {
+	return timeoutMs === undefined
+		? getDefaultHubCommandTimeoutMs(command)
+		: timeoutMs;
+}
+
+export interface HubCommandEnvelope {
+	version: HubProtocolVersion;
+	command: HubCommandName;
+	requestId?: string;
+	clientId?: string;
+	sessionId?: string;
+	timeoutMs?: number | null;
+	payload?: Record<string, unknown>;
+}
+
+export interface HubReplyEnvelope {
+	version: HubProtocolVersion;
+	requestId?: string;
+	ok: boolean;
+	payload?: Record<string, unknown>;
+	error?: {
+		code: string;
+		message: string;
+		details?: Record<string, unknown>;
+	};
+}
+
+export type HubEventName =
+	| "hub.client.registered"
+	| "hub.client.disconnected"
+	| "session.created"
+	| "session.updated"
+	| "session.attached"
+	| "session.detached"
+	| "session.forked"
+	| "session.pending_prompts"
+	| "session.pending_prompt_submitted"
+	| "run.started"
+	| "run.heartbeat"
+	| "run.aborted"
+	| "run.completed"
+	| "run.failed"
+	| "iteration.started"
+	| "iteration.finished"
+	| "assistant.delta"
+	| "assistant.finished"
+	| "reasoning.delta"
+	| "reasoning.finished"
+	| "agent.done"
+	| "usage.updated"
+	| "tool.started"
+	| "tool.updated"
+	| "tool.finished"
+	| "approval.requested"
+	| "approval.resolved"
+	| "capability.requested"
+	| "capability.resolved"
+	| "team.progress"
+	| "artifact.created"
+	| "diff.created"
+	| "spoke.started"
+	| "spoke.failed"
+	| "spoke.stopped"
+	| "peer.registered"
+	| "peer.session_attached"
+	| "peer.session_detached"
+	| "schedule.created"
+	| "schedule.updated"
+	| "schedule.deleted"
+	| "schedule.triggered"
+	| "schedule.execution_completed"
+	| "schedule.execution_failed"
+	| "settings.changed"
+	| "ui.notify"
+	| "ui.show_window"
+	| "hub.client.updated";
+
+export interface HubEventEnvelope {
+	version: HubProtocolVersion;
+	event: HubEventName;
+	eventId?: string;
+	sessionId?: string;
+	clientId?: string;
+	sourceHubId?: string;
+	timestamp?: number;
+	payload?: Record<string, unknown>;
+}
+
+export interface HubCapabilityRequestedPayload {
+	requestId: string;
+	targetClientId: string;
+	capabilityName: string;
+	payload?: Record<string, unknown>;
+}
+
+export interface HubCapabilityResolvedPayload {
+	requestId: string;
+	targetClientId: string;
+	respondedByClientId?: string;
+	capabilityName: string;
+	ok: boolean;
+	cancelled?: boolean;
+	payload?: Record<string, unknown>;
+	error?: string;
+}
+
+export type HubToolExecutorName =
+	| "readFile"
+	| "search"
+	| "bash"
+	| "webFetch"
+	| "editor"
+	| "applyPatch"
+	| "skills"
+	| "askQuestion"
+	| "submit";
+
+export const HUB_TOOL_EXECUTOR_NAMES = [
+	"readFile",
+	"search",
+	"bash",
+	"webFetch",
+	"editor",
+	"applyPatch",
+	"skills",
+	"askQuestion",
+	"submit",
+] as const satisfies readonly HubToolExecutorName[];
+
+const HUB_TOOL_EXECUTOR_NAME_SET = new Set<string>(HUB_TOOL_EXECUTOR_NAMES);
+
+export function isHubToolExecutorName(
+	value: unknown,
+): value is HubToolExecutorName {
+	return typeof value === "string" && HUB_TOOL_EXECUTOR_NAME_SET.has(value);
+}
+
+export const HUB_TOOL_EXECUTOR_CAPABILITY_PREFIX = "tool_executor.";
+export const HUB_CUSTOM_TOOL_CAPABILITY_PREFIX = "custom_tool.";
+export const HUB_HOOK_CAPABILITY_PREFIX = "hook.";
+export const HUB_COMPACTION_CAPABILITY = "compaction.compact";
+export const HUB_CHECKPOINT_CAPABILITY = "checkpoint.create";
+export const HUB_MISTAKE_LIMIT_CAPABILITY = "mistake_limit.decide";
+export const HUB_USER_INSTRUCTIONS_SNAPSHOT_CAPABILITY =
+	"user_instructions.snapshot";
+
+export type HubClientContributionKind =
+	| "toolExecutor"
+	| "tool"
+	| "hook"
+	| "compaction"
+	| "checkpoint"
+	| "mistakeLimit"
+	| "userInstructionService";
+
+export interface HubClientContributionBase {
+	kind: HubClientContributionKind;
+	capabilityName: string;
+}
+
+export interface HubClientToolExecutorContribution
+	extends HubClientContributionBase {
+	kind: "toolExecutor";
+	executor: HubToolExecutorName;
+}
+
+export interface HubClientToolContribution extends HubClientContributionBase {
+	kind: "tool";
+	name: string;
+	description: string;
+	inputSchema: Record<string, JsonValue | undefined>;
+	lifecycle?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubClientHookContribution extends HubClientContributionBase {
+	kind: "hook";
+	name: string;
+}
+
+export interface HubClientCompactionContribution
+	extends HubClientContributionBase {
+	kind: "compaction";
+	config?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubClientCheckpointContribution
+	extends HubClientContributionBase {
+	kind: "checkpoint";
+	config?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubClientMistakeLimitContribution
+	extends HubClientContributionBase {
+	kind: "mistakeLimit";
+}
+
+export interface HubClientUserInstructionServiceContribution
+	extends HubClientContributionBase {
+	kind: "userInstructionService";
+}
+
+export type HubClientContribution =
+	| HubClientToolExecutorContribution
+	| HubClientToolContribution
+	| HubClientHookContribution
+	| HubClientCompactionContribution
+	| HubClientCheckpointContribution
+	| HubClientMistakeLimitContribution
+	| HubClientUserInstructionServiceContribution;
+
+export interface HubSessionRuntimeOptions {
+	mode?: "act" | "plan" | "yolo";
+	systemPrompt?: string;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	thinking?: boolean;
+	reasoningEffort?: ReasoningEffort;
+	thinkingBudgetTokens?: number;
+	checkpointEnabled?: boolean;
+	enableTools?: boolean;
+	enableSpawn?: boolean;
+	enableTeams?: boolean;
+	autoApproveTools?: boolean;
+	configExtensions?: RuntimeConfigExtensionKind[];
+	clientContributions?: HubClientContribution[];
+}
+
+export interface HubSessionCreateInput {
+	workspaceRoot: string;
+	cwd?: string;
+	sessionConfig?: Record<string, JsonValue | undefined>;
+	metadata?: Record<string, JsonValue | undefined>;
+	toolPolicies?: Record<string, JsonValue | undefined>;
+	initialMessages?: AgentMessage[];
+	agentId?: string;
+	agentRole?: string;
+	team?: HubTeamMembership;
+	modelSelection?: GatewayModelSelection;
+	runtimeOptions?: HubSessionRuntimeOptions;
+}
+
+export interface HubModelCatalogProvider {
+	id: string;
+	name: string;
+	enabled: boolean;
+	defaultModelId?: string;
+}
+
+export interface HubModelCatalogModel {
+	id: string;
+	name?: string;
+	supportsThinking?: boolean;
+}
+
+export interface HubModelCatalog {
+	providers: HubModelCatalogProvider[];
+	modelsByProvider: Record<string, HubModelCatalogModel[]>;
+	defaultSelection?: GatewayModelSelection;
+	defaultWorkspaceRoot?: string;
+}
+
+export interface HubSessionAttachInput {
+	sessionId: string;
+	metadata?: Record<string, JsonValue | undefined>;
+	role?: SessionParticipant["role"];
+}
+
+export interface HubSessionUpdateInput {
+	sessionId: string;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubSessionDeleteInput {
+	sessionId: string;
+	deleteCheckpointRefs?: boolean;
+}
+
+export interface HubRunStartInput {
+	sessionId: string;
+	input?: string | AgentMessage | AgentMessage[];
+}
+
+export interface HubApprovalRequestInput {
+	sessionId: string;
+	targetClientId?: string;
+	payload: Record<string, JsonValue | undefined>;
+}
+
+export interface HubApprovalRespondInput {
+	approvalId: string;
+	approved: boolean;
+	payload?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubCapabilityRequestInput {
+	sessionId: string;
+	capabilityName: string;
+	targetClientId?: string;
+	payload?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubCapabilityRespondInput {
+	requestId: string;
+	ok: boolean;
+	payload?: Record<string, JsonValue | undefined>;
+	error?: string;
+}
+
+export interface HubPeerRegisterInput {
+	peerHubId?: string;
+	transport?: Extract<HubTransportKind, "peer-grpc" | "remote" | "native">;
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export interface HubPeerAttachSessionInput {
+	peerHubId: string;
+	sessionId: string;
+}
+
+export interface HubStateSnapshot {
+	hubId: string;
+	protocolVersion: HubProtocolVersion;
+	sessions: SessionRecord[];
+	spokes: SpokeRecord[];
+	approvals: ApprovalRequestRecord[];
+	capabilityRequests: CapabilityRequestRecord[];
+	peers: PeerHubRecord[];
+	schedules?: ScheduleRecord[];
+	scheduleExecutions?: ScheduleExecutionRecord[];
+}
+
+export type HubTransportFrame =
+	| { kind: "command"; envelope: HubCommandEnvelope }
+	| { kind: "reply"; envelope: HubReplyEnvelope }
+	| { kind: "stream.subscribe"; clientId: string; sessionId?: string }
+	| { kind: "stream.unsubscribe"; clientId: string; sessionId?: string }
+	| { kind: "event"; envelope: HubEventEnvelope };
+
+export interface HubUINotifyPayload {
+	title: string;
+	body: string;
+	severity?: "info" | "warning" | "error";
+	sessionId?: string;
+	clientId?: string;
+}
+
+export interface HubUIShowWindowPayload {
+	windowId?: string;
+	focus?: boolean;
+}
diff --git a/sdk/packages/shared/src/index.browser.ts b/sdk/packages/shared/src/index.browser.ts
new file mode 100644
index 0000000..064cac8
--- /dev/null
+++ b/sdk/packages/shared/src/index.browser.ts
@@ -0,0 +1,429 @@
+export * from "./agent";
+export * from "./agents";
+export type {
+	ConnectorAuthorizationDecision,
+	ConnectorAuthorizationRequest,
+	ConnectorEventActor,
+	ConnectorEventContext,
+	ConnectorHookEvent,
+	ConnectorHookEventName,
+} from "./connectors/events";
+export {
+	ConnectorAuthorizationDecisionSchema,
+	ConnectorAuthorizationRequestSchema,
+	ConnectorEventActorSchema,
+	ConnectorEventContextSchema,
+	ConnectorHookEventNameSchema,
+	ConnectorHookEventSchema,
+} from "./connectors/events";
+export type * from "./connectors/options";
+export type {
+	ActiveConnectorRecord,
+	ConfiguredConnectorRecord,
+	ConnectorCatalogEntry,
+	ConnectorChannel,
+	ConnectorChannelsResponse,
+	ConnectorFieldCondition,
+	ConnectorFieldDef,
+	ConnectorPlatformDef,
+	ConnectorSecurityDef,
+	ConnectorSecurityFieldDef,
+} from "./connectors/platforms";
+export {
+	CONNECTOR_CATALOG,
+	CONNECTOR_PLATFORMS,
+	connectorChannelsFromPlatforms,
+	listConnectorCatalog,
+	shouldIncludeConnectorField,
+} from "./connectors/platforms";
+export type { AutomationEventEnvelope } from "./cron";
+export type {
+	ClientContext,
+	ClientName,
+	ExtensionContext,
+	UserContext,
+	WorkspaceContext,
+} from "./extensions/context";
+export type {
+	AgentExtensionApi,
+	AgentExtensionAutomationContext,
+	AgentExtensionAutomationEventType,
+	AgentExtensionCapability,
+	AgentExtensionCommand,
+	AgentExtensionCommandResult,
+	AgentExtensionHooks,
+	AgentExtensionMcpEnv,
+	AgentExtensionMcpEnvValue,
+	AgentExtensionMcpServer,
+	AgentExtensionMcpSseTransport,
+	AgentExtensionMcpStdioTransport,
+	AgentExtensionMcpStreamableHttpTransport,
+	AgentExtensionMcpTransport,
+	AgentExtensionMessageBuilder,
+	AgentExtensionProvider,
+	AgentExtensionRegistry,
+	AgentExtensionRule,
+	AgentExtensionSessionContext,
+	ContributionRegistryExtension,
+	ContributionRegistryOptions,
+	PluginManifest,
+	PluginSetupContext,
+} from "./extensions/contribution-registry";
+export {
+	ContributionRegistry,
+	createContributionRegistry,
+	normalizePluginManifest,
+} from "./extensions/contribution-registry";
+export { PLUGIN_FILE_EXTENSIONS } from "./extensions/plugin";
+export {
+	FEATURE_FLAGS,
+	type FeatureFlag,
+	FeatureFlagDefaultValue,
+	type FeatureFlagPayload,
+	type FeatureFlagsAndPayloads,
+	type FeatureFlagsContext,
+	type FeatureFlagsSettings,
+	type IFeatureFlagsProvider,
+} from "./feature-flags";
+export type { HookControl } from "./hooks/contracts";
+export type {
+	AgentAbortHookPayload,
+	AgentEndHookPayload,
+	AgentErrorHookPayload,
+	AgentResumeHookPayload,
+	AgentStartHookPayload,
+	HookEventName,
+	HookEventPayload,
+	HookEventPayloadBase,
+	PostToolUseData,
+	PreCompactData,
+	PreCompactHookPayload,
+	PreToolUseData,
+	PromptSubmitHookPayload,
+	SessionShutdownHookPayload,
+	TaskCancelData,
+	TaskCompleteData,
+	TaskResumeData,
+	TaskStartData,
+	ToolCallHookPayload,
+	ToolResultHookPayload,
+	UserPromptSubmitData,
+} from "./hooks/events";
+export {
+	HookEventNameSchema,
+	HookEventPayloadSchema,
+	parseHookEventPayload,
+} from "./hooks/events";
+export * from "./hub";
+export type {
+	AiSdkFormatterMessage,
+	AiSdkFormatterMessageRole,
+	AiSdkFormatterPart,
+	AiSdkMessage,
+	AiSdkMessagePart,
+} from "./llms/ai-sdk-format";
+export {
+	EMPTY_CONTENT_TEXT,
+	formatMessagesForAiSdk,
+	sanitizeSurrogates,
+	toAiSdkToolResultOutput,
+} from "./llms/ai-sdk-format";
+export * from "./llms/gateway";
+export {
+	createMediaBudgetState,
+	DEFAULT_MAX_IMAGE_BASE64_BYTES,
+	DEFAULT_MAX_IMAGE_DECODED_BYTES,
+	DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+	DEFAULT_MAX_TOTAL_MEDIA_BYTES,
+	IMAGE_OMITTED_PLACEHOLDER,
+	type ImageMediaLimits,
+	type ImageMediaValidationFailure,
+	type ImageMediaValidationResult,
+	type ImageMediaValidationSuccess,
+	imageBase64DecodedByteLength,
+	imageBase64EncodedByteLength,
+	imageBase64LengthForDecodedBytes,
+	imageFileMaxDecodedBytesForBase64Limit,
+	isBase64Char,
+	isCanonicalBase64,
+	type MediaBudgetOptions,
+	type MediaBudgetState,
+	type ResolvedMediaBudget,
+	reserveImageMediaBytes,
+	resolveMediaBudget,
+	SUPPORTED_IMAGE_MEDIA_TYPES,
+	validateAndReserveImageMedia,
+	validateImageMedia,
+} from "./llms/media";
+export type {
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	MessageRole,
+	MessageWithMetadata,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolDefinition,
+	ToolResultContent,
+	ToolUseContent,
+} from "./llms/messages";
+export {
+	ApiFormat,
+	ApiFormatSchema,
+	type ModelCapability,
+	ModelCapabilitySchema,
+	type ModelInfo,
+	ModelInfoSchema,
+	type ModelMetadata,
+	ModelMetadataSchema,
+	type ModelPricing,
+	ModelPricingSchema,
+	type ModelStatus,
+	ModelStatusSchema,
+	type ThinkingConfig,
+	ThinkingConfigSchema,
+} from "./llms/model-info";
+export { mergeModelOptions } from "./llms/model-options";
+export {
+	DEFAULT_REASONING_EFFORT,
+	REASONING_EFFORT_RATIOS,
+	resolveEffectiveReasoningEffort,
+	resolveReasoningBudgetFromRatio,
+	resolveReasoningEffortRatio,
+} from "./llms/reasoning-effort";
+export {
+	buildClineClientRequestHeaders,
+	type ClineClientRequestHeadersInput,
+	DEFAULT_REQUEST_HEADERS,
+	type MergeClineClientRequestHeadersInput,
+	mergeClineClientRequestHeaders,
+	serializeAbortReason,
+} from "./llms/requests";
+export { CHARS_PER_TOKEN, estimateTokens } from "./llms/tokens";
+export type {
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	ToolCallRecord,
+	ToolPolicy,
+} from "./llms/tools";
+export { ToolCallRecordSchema } from "./llms/tools";
+export {
+	type BasicLogger,
+	type BasicLogMetadata,
+	noopBasicLogger,
+} from "./logging/logger";
+export {
+	normalizeJsonLikeStringsForSchema,
+	parseJsonStream,
+	safeJsonParse,
+	safeJsonStringify,
+} from "./parse/json";
+export { type OmitUndefinedValues, omitUndefinedValues } from "./parse/object";
+export { getDefaultShell, getShellArgs } from "./parse/shell";
+export {
+	maskSecret,
+	sanitizeFileName,
+	trimNonEmpty,
+	truncateSplit,
+	truncateStr,
+} from "./parse/string";
+export { formatHumanReadableDate, formatUptime } from "./parse/time";
+export { validateWithZod, zodToJsonSchema } from "./parse/zod";
+export type { ClineSystemPromptOptions } from "./prompt/cline";
+export { buildClineSystemPrompt } from "./prompt/cline";
+export {
+	formatDisplayUserInput,
+	formatFileContentBlock,
+	formatModeSwitchNotice,
+	formatUserCommandBlock,
+	formatUserInputBlock,
+	normalizeUserInput,
+	parseUserCommandEnvelope,
+	stripModeNotices,
+	xmlTagsRemoval,
+} from "./prompt/format";
+export { isClineProvider } from "./providers/utils";
+export { REMOTE_URI_SCHEME } from "./remote-config/constants";
+export type {
+	AnthropicModel,
+	AnthropicSettings,
+	APIKeySettings,
+	AwsBedrockCustomModel,
+	AwsBedrockModel,
+	AwsBedrockSettings,
+	EnterpriseTelemetry,
+	GlobalInstructionsFile,
+	LiteLLMModel,
+	LiteLLMSettings,
+	MCPServer,
+	OpenAiCompatible,
+	OpenAiCompatibleModel,
+	PromptUploading,
+	ProviderSettings,
+	RemoteConfig,
+	RemoteMCPServer,
+	S3AccessKeySettings,
+	VertexModel,
+	VertexSettings,
+} from "./remote-config/schema";
+export {
+	AllowedMCPServerSchema,
+	AnthropicModelSchema,
+	AnthropicSchema,
+	APIKeySchema,
+	AwsBedrockCustomModelSchema,
+	AwsBedrockModelSchema,
+	AwsBedrockSettingsSchema,
+	ClineModelSchema,
+	ClineSettingsSchema,
+	EnterpriseTelemetrySchema,
+	GlobalInstructionsFileSchema,
+	LiteLLMModelSchema,
+	LiteLLMSchema,
+	OpenAiCompatibleModelSchema,
+	OpenAiCompatibleSchema,
+	PromptUploadingSchema,
+	RemoteConfigSchema,
+	RemoteMCPServerSchema,
+	S3AccessKeySettingsSchema,
+	VertexModelSchema,
+	VertexSettingsSchema,
+} from "./remote-config/schema";
+export { CLINE_DEFAULT_RPC_ADDRESS, CLINE_DEFAULT_RPC_PORT } from "./rpc";
+export type {
+	AddProviderActionRequest,
+	ChatAttachmentFile,
+	ChatAttachments,
+	ChatRunTurnRequest,
+	ChatRuntimeConfig,
+	ChatStartSessionArtifacts,
+	ChatStartSessionRequest,
+	ChatStartSessionResponse,
+	ChatToolCallResult,
+	ChatTurnResult,
+	ClineAccountActionRequest,
+	EnterpriseAuthenticateRequest,
+	EnterpriseAuthenticateResponse,
+	EnterpriseStatusRequest,
+	EnterpriseStatusResponse,
+	EnterpriseSyncRequest,
+	EnterpriseSyncResponse,
+	GetProviderModelsActionRequest,
+	ListProvidersActionRequest,
+	ProviderActionRequest,
+	ProviderCapability,
+	ProviderCatalogResponse,
+	ProviderClient,
+	ProviderConfigField,
+	ProviderConfigFieldOption,
+	ProviderConfigFieldPrimitive,
+	ProviderConfigFieldType,
+	ProviderListItem,
+	ProviderModel,
+	ProviderModelsResponse,
+	ProviderOAuthLoginResponse,
+	ProviderProtocol,
+	ProviderSettingsActionRequest,
+	RuntimeLoggerConfig,
+	SaveProviderSettingsActionRequest,
+} from "./rpc/runtime";
+export {
+	ProviderCapabilitySchema,
+	ProviderClientSchema,
+	ProviderProtocolSchema,
+} from "./rpc/runtime";
+export type {
+	TeamProgressCounts,
+	TeamProgressLifecycleEvent,
+	TeamProgressMemberRole,
+	TeamProgressMemberStatus,
+	TeamProgressOutcomeFragmentStatus,
+	TeamProgressOutcomeStatus,
+	TeamProgressProjectionEvent,
+	TeamProgressRunStatus,
+	TeamProgressSummary,
+	TeamProgressTaskStatus,
+} from "./rpc/team-progress";
+export {
+	TEAM_LIFECYCLE_EVENT_TYPE,
+	TEAM_PROGRESS_EVENT_TYPE,
+} from "./rpc/team-progress";
+export type {
+	ClineEnvironment,
+	ClineEnvironmentConfig,
+	ResolveClineEnvironmentOptions,
+} from "./runtime/cline-environment";
+export {
+	CLINE_ENVIRONMENT_ENV,
+	CLINE_ENVIRONMENT_OVERRIDE_ENV,
+	CLINE_ENVIRONMENTS,
+	DEFAULT_CLINE_ENVIRONMENT,
+	getClineEnvironmentConfig,
+	resolveClineEnvironment,
+} from "./runtime/cline-environment";
+export type {
+	CaptureAgentUnexpectedReasoningTokensInput,
+	CaptureSdkErrorInput,
+	ITelemetryService,
+	OpenTelemetryClientConfig,
+	SdkTelemetryErrorComponent,
+	SdkTelemetryErrorSeverity,
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+} from "./services/telemetry";
+export {
+	AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+	buildSdkErrorProperties,
+	captureAgentUnexpectedReasoningTokens,
+	captureSdkError,
+	normalizeSdkError,
+	SDK_ERROR_TELEMETRY_EVENT,
+} from "./services/telemetry";
+export type { ClineTelemetryServiceConfig } from "./services/telemetry-config";
+export {
+	createClineTelemetryServiceConfig,
+	createClineTelemetryServiceMetadata,
+} from "./services/telemetry-config";
+export type {
+	HookSessionContext,
+	HookSessionContextLookup,
+	HookSessionContextProvider,
+} from "./session/hook-context";
+export {
+	resolveHookSessionContext,
+	resolveRootSessionId,
+} from "./session/hook-context";
+export { createSessionId } from "./session/index";
+export type {
+	SessionLineage,
+	SessionRuntimeRecordShape,
+	SharedSessionStatus,
+} from "./session/records";
+export { SESSION_STATUS_VALUES } from "./session/records";
+export type {
+	AgentMode,
+	RuntimeConfigExtensionKind,
+	SessionExecutionConfig,
+	SessionPromptConfig,
+	SessionWorkspaceConfig,
+} from "./session/runtime-config";
+export {
+	DEFAULT_RUNTIME_CONFIG_EXTENSIONS,
+	hasRuntimeConfigExtension,
+	isRuntimeConfigExtensionKind,
+	parseRuntimeConfigExtensions,
+	RUNTIME_CONFIG_EXTENSION_KINDS,
+} from "./session/runtime-config";
+export type { RuntimeEnv } from "./session/runtime-env";
+export * from "./session/workspace";
+export * from "./team";
+export { createTool } from "./tools/create";
+export { AUTH_ERROR_PATTERNS, isLikelyAuthError } from "./types/auth";
+// VCR is Node-only (uses node:fs, node:path), excluded from browser build
+export type { VcrRecording } from "./types/vcr";
diff --git a/sdk/packages/shared/src/index.ts b/sdk/packages/shared/src/index.ts
new file mode 100644
index 0000000..b493483
--- /dev/null
+++ b/sdk/packages/shared/src/index.ts
@@ -0,0 +1,480 @@
+export * from "./agent";
+export * from "./agents";
+export type {
+	ConnectorAuthorizationDecision,
+	ConnectorAuthorizationRequest,
+	ConnectorEventActor,
+	ConnectorEventContext,
+	ConnectorHookEvent,
+	ConnectorHookEventName,
+} from "./connectors/events";
+export {
+	ConnectorAuthorizationDecisionSchema,
+	ConnectorAuthorizationRequestSchema,
+	ConnectorEventActorSchema,
+	ConnectorEventContextSchema,
+	ConnectorHookEventNameSchema,
+	ConnectorHookEventSchema,
+} from "./connectors/events";
+export type * from "./connectors/options";
+export type {
+	ActiveConnectorRecord,
+	ConfiguredConnectorRecord,
+	ConnectorCatalogEntry,
+	ConnectorChannel,
+	ConnectorChannelsResponse,
+	ConnectorFieldCondition,
+	ConnectorFieldDef,
+	ConnectorPlatformDef,
+	ConnectorSecurityDef,
+	ConnectorSecurityFieldDef,
+} from "./connectors/platforms";
+export {
+	CONNECTOR_CATALOG,
+	CONNECTOR_PLATFORMS,
+	connectorChannelsFromPlatforms,
+	listConnectorCatalog,
+	shouldIncludeConnectorField,
+} from "./connectors/platforms";
+export type {
+	AutomationEventEnvelope,
+	CronEventSpec,
+	CronOneOffSpec,
+	CronScheduleSpec,
+	CronSpec,
+	CronSpecCommonFields,
+	CronSpecExtensionKind,
+	CronSpecMode,
+	CronSpecModelSelection,
+	CronSpecParseResult,
+	CronTriggerKind,
+} from "./cron";
+export type { Disposable } from "./dispose";
+export { disposeAll, registerDisposable } from "./dispose";
+export type {
+	ClientContext,
+	ClientName,
+	ExtensionContext,
+	UserContext,
+	WorkspaceContext,
+} from "./extensions/context";
+export type {
+	AgentExtensionApi,
+	AgentExtensionAutomationContext,
+	AgentExtensionAutomationEventType,
+	AgentExtensionCapability,
+	AgentExtensionCommand,
+	AgentExtensionCommandResult,
+	AgentExtensionHooks,
+	AgentExtensionMcpEnv,
+	AgentExtensionMcpEnvValue,
+	AgentExtensionMcpServer,
+	AgentExtensionMcpSseTransport,
+	AgentExtensionMcpStdioTransport,
+	AgentExtensionMcpStreamableHttpTransport,
+	AgentExtensionMcpTransport,
+	AgentExtensionMessageBuilder,
+	AgentExtensionProvider,
+	AgentExtensionRegistry,
+	AgentExtensionRule,
+	AgentExtensionSessionContext,
+	ContributionRegistryExtension,
+	ContributionRegistryOptions,
+	PluginManifest,
+	PluginSetupContext,
+} from "./extensions/contribution-registry";
+export {
+	ContributionRegistry,
+	createContributionRegistry,
+	normalizePluginManifest,
+} from "./extensions/contribution-registry";
+export { PLUGIN_FILE_EXTENSIONS } from "./extensions/plugin";
+export {
+	FEATURE_FLAGS,
+	type FeatureFlag,
+	FeatureFlagDefaultValue,
+	type FeatureFlagPayload,
+	type FeatureFlagsAndPayloads,
+	type FeatureFlagsContext,
+	type FeatureFlagsSettings,
+	type IFeatureFlagsProvider,
+} from "./feature-flags";
+export type { HookControl } from "./hooks/contracts";
+export type {
+	AgentAbortHookPayload,
+	AgentEndHookPayload,
+	AgentErrorHookPayload,
+	AgentResumeHookPayload,
+	AgentStartHookPayload,
+	HookEventName,
+	HookEventPayload,
+	HookEventPayloadBase,
+	PostToolUseData,
+	PreCompactData,
+	PreCompactHookPayload,
+	PreToolUseData,
+	PromptSubmitHookPayload,
+	SessionShutdownHookPayload,
+	TaskCancelData,
+	TaskCompleteData,
+	TaskResumeData,
+	TaskStartData,
+	ToolCallHookPayload,
+	ToolResultHookPayload,
+	UserPromptSubmitData,
+} from "./hooks/events";
+export {
+	HookEventNameSchema,
+	HookEventPayloadSchema,
+	parseHookEventPayload,
+} from "./hooks/events";
+export * from "./hub";
+export type {
+	AiSdkFormatterMessage,
+	AiSdkFormatterMessageRole,
+	AiSdkFormatterPart,
+	AiSdkMessage,
+	AiSdkMessagePart,
+} from "./llms/ai-sdk-format";
+export {
+	EMPTY_CONTENT_TEXT,
+	formatMessagesForAiSdk,
+	sanitizeSurrogates,
+	toAiSdkToolResultOutput,
+} from "./llms/ai-sdk-format";
+export * from "./llms/gateway";
+export {
+	createMediaBudgetState,
+	DEFAULT_MAX_IMAGE_BASE64_BYTES,
+	DEFAULT_MAX_IMAGE_DECODED_BYTES,
+	DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+	DEFAULT_MAX_TOTAL_MEDIA_BYTES,
+	IMAGE_OMITTED_PLACEHOLDER,
+	type ImageMediaLimits,
+	type ImageMediaValidationFailure,
+	type ImageMediaValidationResult,
+	type ImageMediaValidationSuccess,
+	imageBase64DecodedByteLength,
+	imageBase64EncodedByteLength,
+	imageBase64LengthForDecodedBytes,
+	imageFileMaxDecodedBytesForBase64Limit,
+	isBase64Char,
+	isCanonicalBase64,
+	type MediaBudgetOptions,
+	type MediaBudgetState,
+	type ResolvedMediaBudget,
+	reserveImageMediaBytes,
+	resolveMediaBudget,
+	SUPPORTED_IMAGE_MEDIA_TYPES,
+	validateAndReserveImageMedia,
+	validateImageMedia,
+} from "./llms/media";
+export type {
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	MessageRole,
+	MessageWithMetadata,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolDefinition,
+	ToolResultContent,
+	ToolUseContent,
+} from "./llms/messages";
+export {
+	ApiFormat,
+	ApiFormatSchema,
+	type ModelCapability,
+	ModelCapabilitySchema,
+	type ModelInfo,
+	ModelInfoSchema,
+	type ModelMetadata,
+	ModelMetadataSchema,
+	type ModelPricing,
+	ModelPricingSchema,
+	type ModelStatus,
+	ModelStatusSchema,
+	type ThinkingConfig,
+	ThinkingConfigSchema,
+} from "./llms/model-info";
+export { mergeModelOptions } from "./llms/model-options";
+export {
+	DEFAULT_REASONING_EFFORT,
+	REASONING_EFFORT_RATIOS,
+	resolveEffectiveReasoningEffort,
+	resolveReasoningBudgetFromRatio,
+	resolveReasoningEffortRatio,
+} from "./llms/reasoning-effort";
+export {
+	buildClineClientRequestHeaders,
+	type ClineClientRequestHeadersInput,
+	DEFAULT_REQUEST_HEADERS,
+	type MergeClineClientRequestHeadersInput,
+	mergeClineClientRequestHeaders,
+	serializeAbortReason,
+} from "./llms/requests";
+export { CHARS_PER_TOKEN, estimateTokens } from "./llms/tokens";
+export type {
+	ToolApprovalRequest,
+	ToolApprovalResult,
+	ToolCallRecord,
+	ToolPolicy,
+} from "./llms/tools";
+export { ToolCallRecordSchema } from "./llms/tools";
+export {
+	type BasicLogger,
+	type BasicLogMetadata,
+	noopBasicLogger,
+} from "./logging/logger";
+export {
+	normalizeJsonLikeStringsForSchema,
+	parseJsonStream,
+	safeJsonParse,
+	safeJsonStringify,
+} from "./parse/json";
+export { type OmitUndefinedValues, omitUndefinedValues } from "./parse/object";
+export { getDefaultShell, getShellArgs } from "./parse/shell";
+export {
+	maskSecret,
+	sanitizeFileName,
+	trimNonEmpty,
+	truncateSplit,
+	truncateStr,
+} from "./parse/string";
+export { formatHumanReadableDate, formatUptime } from "./parse/time";
+export { validateWithZod, zodToJsonSchema } from "./parse/zod";
+export type { ClineSystemPromptOptions } from "./prompt/cline";
+export { buildClineSystemPrompt, processWorkspaceInfo } from "./prompt/cline";
+export {
+	formatDisplayUserInput,
+	formatFileContentBlock,
+	formatModeSwitchNotice,
+	formatUserCommandBlock,
+	formatUserInputBlock,
+	normalizeUserInput,
+	parseUserCommandEnvelope,
+	parseUserInputMode,
+	stripModeNotices,
+	xmlTagsRemoval,
+} from "./prompt/format";
+export { isClineProvider } from "./providers/utils";
+export {
+	buildRemoteConfigSessionBlobUploadMetadata,
+	clearRemoteConfigSessionBlobUpload,
+	createRemoteConfigSessionMessagesArtifactUploader,
+	prepareRemoteConfigRuntime,
+	REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY,
+	readRemoteConfigSessionBlobUploadMetadata,
+	registerRemoteConfigSessionBlobUpload,
+} from "./remote-config";
+export type {
+	PreparedRemoteConfigRuntime,
+	PrepareRemoteConfigRuntimeOptions,
+	RemoteConfigBundle,
+} from "./remote-config/bundle";
+export { REMOTE_URI_SCHEME } from "./remote-config/constants";
+export type {
+	AnthropicModel,
+	AnthropicSettings,
+	APIKeySettings,
+	AwsBedrockCustomModel,
+	AwsBedrockModel,
+	AwsBedrockSettings,
+	EnterpriseTelemetry,
+	GlobalInstructionsFile,
+	LiteLLMModel,
+	LiteLLMSettings,
+	MCPServer,
+	OpenAiCompatible,
+	OpenAiCompatibleModel,
+	PromptUploading,
+	ProviderSettings,
+	RemoteConfig,
+	RemoteMCPServer,
+	S3AccessKeySettings,
+	VertexModel,
+	VertexSettings,
+} from "./remote-config/schema";
+export {
+	AllowedMCPServerSchema,
+	AnthropicModelSchema,
+	AnthropicSchema,
+	APIKeySchema,
+	AwsBedrockCustomModelSchema,
+	AwsBedrockModelSchema,
+	AwsBedrockSettingsSchema,
+	ClineModelSchema,
+	ClineSettingsSchema,
+	EnterpriseTelemetrySchema,
+	GlobalInstructionsFileSchema,
+	LiteLLMModelSchema,
+	LiteLLMSchema,
+	OpenAiCompatibleModelSchema,
+	OpenAiCompatibleSchema,
+	PromptUploadingSchema,
+	RemoteConfigSchema,
+	RemoteMCPServerSchema,
+	S3AccessKeySettingsSchema,
+	VertexModelSchema,
+	VertexSettingsSchema,
+} from "./remote-config/schema";
+export {
+	CLINE_DEFAULT_RPC_ADDRESS,
+	CLINE_DEFAULT_RPC_PORT,
+	CLINE_HUB_DEV_PORT,
+	CLINE_HUB_PORT,
+} from "./rpc";
+export type {
+	AddProviderActionRequest,
+	ChatAttachmentFile,
+	ChatAttachments,
+	ChatRunTurnRequest,
+	ChatRuntimeConfig,
+	ChatStartSessionArtifacts,
+	ChatStartSessionRequest,
+	ChatStartSessionResponse,
+	ChatToolCallResult,
+	ChatTurnResult,
+	ClineAccountActionRequest,
+	EnterpriseAuthenticateRequest,
+	EnterpriseAuthenticateResponse,
+	EnterpriseStatusRequest,
+	EnterpriseStatusResponse,
+	EnterpriseSyncRequest,
+	EnterpriseSyncResponse,
+	GetProviderModelsActionRequest,
+	ListProvidersActionRequest,
+	ProviderActionRequest,
+	ProviderCapability,
+	ProviderCatalogResponse,
+	ProviderClient,
+	ProviderConfigField,
+	ProviderConfigFieldOption,
+	ProviderConfigFieldPrimitive,
+	ProviderConfigFieldType,
+	ProviderListItem,
+	ProviderModel,
+	ProviderModelsResponse,
+	ProviderOAuthLoginResponse,
+	ProviderProtocol,
+	ProviderSettingsActionRequest,
+	RuntimeLoggerConfig,
+	SaveProviderSettingsActionRequest,
+} from "./rpc/runtime";
+export {
+	ProviderCapabilitySchema,
+	ProviderClientSchema,
+	ProviderProtocolSchema,
+} from "./rpc/runtime";
+export type {
+	TeamProgressCounts,
+	TeamProgressLifecycleEvent,
+	TeamProgressMemberRole,
+	TeamProgressMemberStatus,
+	TeamProgressOutcomeFragmentStatus,
+	TeamProgressOutcomeStatus,
+	TeamProgressProjectionEvent,
+	TeamProgressRunStatus,
+	TeamProgressSummary,
+	TeamProgressTaskStatus,
+} from "./rpc/team-progress";
+export {
+	TEAM_LIFECYCLE_EVENT_TYPE,
+	TEAM_PROGRESS_EVENT_TYPE,
+} from "./rpc/team-progress";
+export type {
+	ClineBuildEnv,
+	ClineDebugRole,
+	ResolveClineBuildEnvOptions,
+} from "./runtime/build-env";
+export {
+	augmentNodeCommandForDebug,
+	CLINE_BUILD_ENV_ENV,
+	CLINE_DEBUG_HOST_ENV,
+	CLINE_DEBUG_PORT_BASE_ENV,
+	resolveClineBuildEnv,
+	withResolvedClineBuildEnv,
+} from "./runtime/build-env";
+export type {
+	ClineEnvironment,
+	ClineEnvironmentConfig,
+	ResolveClineEnvironmentOptions,
+} from "./runtime/cline-environment";
+export {
+	CLINE_ENVIRONMENT_ENV,
+	CLINE_ENVIRONMENT_OVERRIDE_ENV,
+	CLINE_ENVIRONMENTS,
+	DEFAULT_CLINE_ENVIRONMENT,
+	getClineEnvironmentConfig,
+	resolveClineEnvironment,
+} from "./runtime/cline-environment";
+export {
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+	isHubDaemonProcess,
+} from "./runtime/hub-daemon-env";
+export type {
+	CaptureAgentUnexpectedReasoningTokensInput,
+	CaptureSdkErrorInput,
+	ITelemetryService,
+	OpenTelemetryClientConfig,
+	SdkTelemetryErrorComponent,
+	SdkTelemetryErrorSeverity,
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+} from "./services/telemetry";
+export {
+	AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+	buildSdkErrorProperties,
+	captureAgentUnexpectedReasoningTokens,
+	captureSdkError,
+	normalizeSdkError,
+	SDK_ERROR_TELEMETRY_EVENT,
+} from "./services/telemetry";
+export type { ClineTelemetryServiceConfig } from "./services/telemetry-config";
+export {
+	createClineTelemetryServiceConfig,
+	createClineTelemetryServiceMetadata,
+} from "./services/telemetry-config";
+export type {
+	HookSessionContext,
+	HookSessionContextLookup,
+	HookSessionContextProvider,
+} from "./session/hook-context";
+export {
+	resolveHookSessionContext,
+	resolveRootSessionId,
+} from "./session/hook-context";
+export { createSessionId } from "./session/index";
+export type {
+	SessionLineage,
+	SessionRuntimeRecordShape,
+	SharedSessionStatus,
+} from "./session/records";
+export { SESSION_STATUS_VALUES } from "./session/records";
+export type {
+	AgentMode,
+	RuntimeConfigExtensionKind,
+	SessionExecutionConfig,
+	SessionPromptConfig,
+	SessionWorkspaceConfig,
+} from "./session/runtime-config";
+export {
+	DEFAULT_RUNTIME_CONFIG_EXTENSIONS,
+	hasRuntimeConfigExtension,
+	isRuntimeConfigExtensionKind,
+	parseRuntimeConfigExtensions,
+	RUNTIME_CONFIG_EXTENSION_KINDS,
+} from "./session/runtime-config";
+export type { RuntimeEnv } from "./session/runtime-env";
+export * from "./session/workspace";
+export * from "./team";
+export { createTool } from "./tools/create";
+export * from "./types";
+export { AUTH_ERROR_PATTERNS, isLikelyAuthError } from "./types/auth";
+export { initVcr } from "./vcr";
diff --git a/sdk/packages/shared/src/llms/ai-sdk-format.test.ts b/sdk/packages/shared/src/llms/ai-sdk-format.test.ts
new file mode 100644
index 0000000..1163777
--- /dev/null
+++ b/sdk/packages/shared/src/llms/ai-sdk-format.test.ts
@@ -0,0 +1,1234 @@
+import { describe, expect, it } from "vitest";
+import {
+	EMPTY_CONTENT_TEXT,
+	formatMessagesForAiSdk,
+	sanitizeSurrogates,
+	toAiSdkToolResultOutput,
+} from "./ai-sdk-format";
+
+describe("formatMessagesForAiSdk", () => {
+	const imageData = (byteLength: number, fill = 1) =>
+		Buffer.alloc(byteLength, fill).toString("base64");
+
+	it("omits empty system messages", () => {
+		const messages = formatMessagesForAiSdk("", [
+			{
+				role: "user",
+				content: [{ type: "text", text: "hey" }],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "text", text: "hey" }],
+			},
+		]);
+	});
+
+	it("omits whitespace-only system messages", () => {
+		const messages = formatMessagesForAiSdk("   \n\t  ", [
+			{
+				role: "user",
+				content: [{ type: "text", text: "hey" }],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "text", text: "hey" }],
+			},
+		]);
+	});
+
+	it("replaces empty string user and assistant messages with explicit error text", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{ role: "user", content: "" },
+			{ role: "assistant", content: "   \n\t  " },
+			{ role: "user", content: [{ type: "text", text: "continue" }] },
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+			},
+			{
+				role: "assistant",
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+			},
+			{
+				role: "user",
+				content: [{ type: "text", text: "continue" }],
+			},
+		]);
+	});
+
+	it("replaces empty content arrays with explicit error text", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{ role: "assistant", content: [] },
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "assistant",
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+			},
+		]);
+	});
+
+	it("preserves providerOptions on text parts", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "text",
+						text: "cache this",
+						providerOptions: {
+							openrouter: { cache_control: { type: "ephemeral" } },
+						},
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [
+					{
+						type: "text",
+						text: "cache this",
+						providerOptions: {
+							openrouter: { cache_control: { type: "ephemeral" } },
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("emits tool results as tool-role messages", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [{ type: "text", text: "hey" }],
+			},
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "I'll inspect that." },
+					{
+						type: "tool-call",
+						toolCallId: "call_1",
+						toolName: "run_commands",
+						input: { commands: ["pwd"] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "run_commands",
+						output: { ok: true },
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "text", text: "hey" }],
+			},
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "I'll inspect that." },
+					{
+						type: "tool-call",
+						toolCallId: "call_1",
+						toolName: "run_commands",
+						input: { commands: ["pwd"] },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "run_commands",
+						output: { type: "json", value: { ok: true } },
+					},
+				],
+			},
+		]);
+	});
+
+	it("splits mixed user text and tool results into valid messages", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "Here is the tool output." },
+					{
+						type: "tool-result",
+						toolCallId: "call_2",
+						toolName: "read_file",
+						output: "contents",
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "text", text: "Here is the tool output." }],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_2",
+						toolName: "read_file",
+						output: { type: "text", value: "contents" },
+					},
+				],
+			},
+		]);
+	});
+
+	it("forwards image content blocks as AI SDK content/image-data parts", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "read_file",
+						output: [
+							{ type: "text", text: "Successfully read image" },
+							{
+								type: "image",
+								data: "QkFTRTY0REFUQQ==",
+								mediaType: "image/jpeg",
+							},
+						],
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "read_file",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "Successfully read image" },
+								{
+									type: "image-data",
+									data: "QkFTRTY0REFUQQ==",
+									mediaType: "image/jpeg",
+								},
+							],
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("extracts nested image content blocks from a read_files tool result", () => {
+		// `read_files` returns its output as a `ToolOperationResult[]` whose
+		// `result` is a content-block array `[{type:'text'}, {type:'image'}]`.
+		// `formatMessagesForAiSdk` (via `toAiSdkToolResultOutput`) must walk
+		// the tree, hoist any nested image blocks out as native `image-data`
+		// content parts, and forward the remaining metadata as a JSON-encoded
+		// text block so the model receives multimodal input rather than a
+		// JSON-stringified base64 blob.
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_img",
+						toolName: "read_files",
+						input: { files: [{ path: "/tmp/image.jpg" }] },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "read_files",
+						output: [
+							{
+								query: "/tmp/image.jpg",
+								result: [
+									{ type: "text", text: "Successfully read image" },
+									{
+										type: "image",
+										data: "QkFTRTY0REFUQQ==",
+										mediaType: "image/jpeg",
+									},
+								],
+								success: true,
+							},
+						],
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_img",
+						toolName: "read_files",
+						input: { files: [{ path: "/tmp/image.jpg" }] },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "text",
+									text: JSON.stringify([
+										{
+											query: "/tmp/image.jpg",
+											result: ["Successfully read image"],
+											success: true,
+										},
+									]),
+								},
+								{
+									type: "image-data",
+									data: "QkFTRTY0REFUQQ==",
+									mediaType: "image/jpeg",
+								},
+							],
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("sanitizes nested strings before stringifying extracted image metadata", () => {
+		const output = toAiSdkToolResultOutput({
+			query: "bad\uD800name.jpg",
+			result: [
+				{ type: "text", text: "Successfully read image" },
+				{
+					type: "image",
+					data: "QkFTRTY0REFUQQ==",
+					mediaType: "image/jpeg",
+				},
+			],
+			success: true,
+		});
+
+		expect(output).toEqual({
+			type: "content",
+			value: [
+				{
+					type: "text",
+					text: JSON.stringify({
+						query: "bad\uFFFDname.jpg",
+						result: ["Successfully read image"],
+						success: true,
+					}),
+				},
+				{
+					type: "image-data",
+					data: "QkFTRTY0REFUQQ==",
+					mediaType: "image/jpeg",
+				},
+			],
+		});
+	});
+
+	it("extracts every nested image block from a multi-file read_files tool result", () => {
+		// Regression: a `read_files` call with multiple image paths returns
+		// a single `ToolOperationResult[]` whose entries each carry one
+		// `{type:'image', data, mediaType}` block. All of them must end up
+		// as native `image-data` content parts attached to the tool-result.
+		// Previously only the first was preserved (or all were lost on the
+		// SDK-direct path), causing the model to "see" the wrong image set.
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_imgs",
+						toolName: "read_files",
+						input: {
+							files: [{ path: "/tmp/image.jpg" }, { path: "/tmp/image2.png" }],
+						},
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_imgs",
+						toolName: "read_files",
+						output: [
+							{
+								query: "/tmp/image.jpg",
+								result: [
+									{ type: "text", text: "Successfully read image" },
+									{
+										type: "image",
+										data: "SlBFR0RBVEE=",
+										mediaType: "image/jpeg",
+									},
+								],
+								success: true,
+							},
+							{
+								query: "/tmp/image2.png",
+								result: [
+									{ type: "text", text: "Successfully read image" },
+									{
+										type: "image",
+										data: "UE5HREFUQQ==",
+										mediaType: "image/png",
+									},
+								],
+								success: true,
+							},
+						],
+					},
+				],
+			},
+		]);
+
+		// Both images must end up as image-data content parts on the
+		// tool-result output, and no orphaned image messages may remain.
+		expect(messages).toEqual([
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_imgs",
+						toolName: "read_files",
+						input: {
+							files: [{ path: "/tmp/image.jpg" }, { path: "/tmp/image2.png" }],
+						},
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_imgs",
+						toolName: "read_files",
+						output: {
+							type: "content",
+							value: [
+								{
+									type: "text",
+									text: JSON.stringify([
+										{
+											query: "/tmp/image.jpg",
+											result: ["Successfully read image"],
+											success: true,
+										},
+										{
+											query: "/tmp/image2.png",
+											result: ["Successfully read image"],
+											success: true,
+										},
+									]),
+								},
+								{
+									type: "image-data",
+									data: "SlBFR0RBVEE=",
+									mediaType: "image/jpeg",
+								},
+								{
+									type: "image-data",
+									data: "UE5HREFUQQ==",
+									mediaType: "image/png",
+								},
+							],
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("merges adjacent tool-result messages into one tool message", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_text",
+						toolName: "read_file",
+						input: { path: "/tmp/a.txt" },
+					},
+					{
+						type: "tool-call",
+						toolCallId: "call_image",
+						toolName: "read_file",
+						input: { path: "/tmp/image.jpg" },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_text",
+						toolName: "read_file",
+						output: "text contents",
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_image",
+						toolName: "read_file",
+						output: [
+							{ type: "text", text: "Successfully read image" },
+							{
+								type: "image",
+								data: "QkFTRTY0REFUQQ==",
+								mediaType: "image/jpeg",
+							},
+						],
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolCallId: "call_text",
+						toolName: "read_file",
+						input: { path: "/tmp/a.txt" },
+					},
+					{
+						type: "tool-call",
+						toolCallId: "call_image",
+						toolName: "read_file",
+						input: { path: "/tmp/image.jpg" },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_text",
+						toolName: "read_file",
+						output: { type: "text", value: "text contents" },
+					},
+					{
+						type: "tool-result",
+						toolCallId: "call_image",
+						toolName: "read_file",
+						output: {
+							type: "content",
+							value: [
+								{ type: "text", text: "Successfully read image" },
+								{
+									type: "image-data",
+									data: "QkFTRTY0REFUQQ==",
+									mediaType: "image/jpeg",
+								},
+							],
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("falls back to json for non-content arrays", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_json",
+						toolName: "list_things",
+						output: [{ type: "unknown" }, { foo: "bar" }],
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_json",
+						toolName: "list_things",
+						output: {
+							type: "json",
+							value: [{ type: "unknown" }, { foo: "bar" }],
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("never emits content output for errors", () => {
+		const image = "QkFTRTY0REFUQQ==";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_err",
+						toolName: "read_file",
+						isError: true,
+						output: [
+							{ type: "text", text: "boom" },
+							{
+								type: "image",
+								data: image,
+								mediaType: "image/jpeg",
+							},
+						],
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_err",
+						toolName: "read_file",
+						output: {
+							type: "error-json",
+							value: ["boom", "[media omitted: invalid or exceeds size limit]"],
+						},
+					},
+				],
+			},
+		]);
+		expect(JSON.stringify(messages)).not.toContain(image);
+	});
+
+	it("preserves providerOptions on reasoning parts", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "reasoning",
+						text: "thinking",
+						providerOptions: {
+							anthropic: {
+								signature: "sig_123",
+							},
+						},
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "reasoning",
+						text: "thinking",
+						providerOptions: {
+							anthropic: {
+								signature: "sig_123",
+							},
+						},
+					},
+				],
+			},
+		]);
+	});
+
+	it("passes through tool result output for compatibility helper", () => {
+		expect(toAiSdkToolResultOutput({ ok: true })).toEqual({
+			type: "json",
+			value: { ok: true },
+		});
+		expect(toAiSdkToolResultOutput("contents")).toEqual({
+			type: "text",
+			value: "contents",
+		});
+	});
+
+	it("does not reshape text-only structured tool result output", () => {
+		expect(
+			toAiSdkToolResultOutput({
+				result: [{ type: "text", text: "hello" }],
+			}),
+		).toEqual({
+			type: "json",
+			value: {
+				result: [{ type: "text", text: "hello" }],
+			},
+		});
+	});
+
+	it("replaces invalid direct user images with text placeholders before provider formatting", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "inspect" },
+					{
+						type: "image",
+						image: "data:image/jpeg;base64,/9j/",
+						mediaType: "image/png",
+					},
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain("data:image/jpeg;base64,/9j/");
+	});
+
+	it("keeps raw base64 string images without mediaType by defaulting to png", () => {
+		const image = imageData(8);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [{ type: "image", image }],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "image", image, mediaType: "image/png" }],
+			},
+		]);
+	});
+
+	it("keeps binary image parts without mediaType by defaulting to png", () => {
+		const image = new Uint8Array([1, 2, 3, 4]);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [{ type: "image", image }],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [{ type: "image", image, mediaType: "image/png" }],
+			},
+		]);
+	});
+
+	it("replaces binary image parts with unsupported media types", () => {
+		const image = new Uint8Array([1, 2, 3, 4]);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "image", image, mediaType: "application/octet-stream" },
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain("application/octet-stream");
+	});
+
+	it("replaces over-budget binary image parts", () => {
+		const oversizedImage = new Uint8Array(6 * 1024 * 1024 + 1);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "image", image: oversizedImage, mediaType: "image/png" },
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [
+					{
+						type: "text",
+						text: "[media omitted: invalid or exceeds size limit]",
+					},
+				],
+			},
+		]);
+	});
+
+	it("validates and budgets data URL objects before provider formatting", () => {
+		const image = imageData(8);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "image",
+						image: new URL(`data:image/jpeg;base64,${image}`),
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [
+					{
+						type: "image",
+						image: `data:image/jpeg;base64,${image}`,
+						mediaType: "image/jpeg",
+					},
+				],
+			},
+		]);
+	});
+
+	it("validates uppercase data URL strings without an explicit mediaType", () => {
+		const image = imageData(8);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [{ type: "image", image: `DATA:image/jpeg;base64,${image}` }],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "user",
+				content: [
+					{
+						type: "image",
+						image: `data:image/jpeg;base64,${image}`,
+						mediaType: "image/jpeg",
+					},
+				],
+			},
+		]);
+	});
+
+	it("charges remote URL image parts against the aggregate media budget", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "image", image: new URL("https://example.com/a.png") },
+					{ type: "image", image: new URL("https://example.com/b.png") },
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+		expect(serialized).toContain("https://example.com/a.png");
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain("https://example.com/b.png");
+	});
+
+	it("charges remote string image URLs against the aggregate media budget", () => {
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "image", image: "https://example.com/a.png" },
+					{ type: "image", image: "https://example.com/b.png" },
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+		expect(serialized).toContain("https://example.com/a.png");
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain("https://example.com/b.png");
+	});
+
+	it("replaces oversized direct user images with text placeholders", () => {
+		const oversizedImage = imageData(4 * 1024 * 1024);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "image",
+						image: oversizedImage,
+						mediaType: "image/png",
+					},
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain(oversizedImage);
+	});
+
+	it("replaces invalid and oversized tool-result images with text placeholders before provider formatting", () => {
+		const oversizedImage = imageData(4 * 1024 * 1024);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "read_files",
+						output: [
+							{
+								query: "/tmp/image.svg",
+								result: [
+									{ type: "text", text: "Successfully read image" },
+									{
+										type: "image",
+										data: "PHN2Zz4=",
+										mediaType: "image/svg+xml",
+									},
+									{
+										type: "image",
+										data: oversizedImage,
+										mediaType: "image/png",
+									},
+								],
+								success: true,
+							},
+						],
+					},
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain('"type":"image-data"');
+		expect(serialized).not.toContain("PHN2Zz4=");
+		expect(serialized).not.toContain(oversizedImage);
+	});
+
+	it("replaces malformed image-shaped tool-result objects with placeholders", () => {
+		const hiddenPayload = imageData(1024);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "custom_tool",
+						output: {
+							result: {
+								type: "image",
+								data: hiddenPayload,
+							},
+						},
+					},
+				],
+			},
+		]);
+
+		const serialized = JSON.stringify(messages);
+		expect(serialized).toContain(
+			"[media omitted: invalid or exceeds size limit]",
+		);
+		expect(serialized).not.toContain(hiddenPayload);
+	});
+
+	it("replaces image-shaped error tool-result objects with placeholders", () => {
+		const hiddenPayload = imageData(1024);
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "custom_tool",
+						isError: true,
+						output: {
+							result: {
+								type: "image",
+								data: hiddenPayload,
+								mediaType: "image/png",
+							},
+						},
+					},
+				],
+			},
+		]);
+
+		expect(messages).toEqual([
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_img",
+						toolName: "custom_tool",
+						output: {
+							type: "error-json",
+							value: {
+								result: "[media omitted: invalid or exceeds size limit]",
+							},
+						},
+					},
+				],
+			},
+		]);
+		expect(JSON.stringify(messages)).not.toContain(hiddenPayload);
+	});
+});
+
+describe("sanitizeSurrogates", () => {
+	it("replaces lone high surrogates with replacement character", () => {
+		const lone = "\uD83D";
+		const sanitized = sanitizeSurrogates(lone);
+		expect(sanitized.charCodeAt(0)).not.toBe(lone.charCodeAt(0));
+		expect(sanitized).toBe("\uFFFD");
+	});
+
+	it("preserves valid surrogate pairs (emoji)", () => {
+		const valid = "🚀";
+		expect(sanitizeSurrogates(valid)).toBe(valid);
+	});
+
+	it("replaces lone surrogates but preserves valid ones in mixed text", () => {
+		const lone = "\uD83D";
+		const valid = "🚀";
+		const text = `text ${lone} and ${valid}`;
+		const expected = `text \uFFFD and ${valid}`;
+		expect(sanitizeSurrogates(text)).toBe(expected);
+	});
+});
+
+describe("formatMessagesForAiSdk - surrogate sanitization", () => {
+	it("sanitizes system content with lone surrogates", () => {
+		const lone = "\uD83D";
+		const valid = "🚀";
+		const system = `system ${lone}`;
+		const expectedSystem = `system \uFFFD`;
+
+		const messages = formatMessagesForAiSdk(system, [
+			{ role: "user", content: [{ type: "text", text: `hey ${valid}` }] },
+		]);
+
+		expect(messages[0]?.role).toBe("system");
+		expect(messages[0]?.content).toBe(expectedSystem);
+	});
+
+	it("sanitizes string message content", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{ role: "user", content: `text ${lone}` },
+		]);
+
+		expect(messages[0]?.content).toBe("text \uFFFD");
+	});
+
+	it("sanitizes text parts in user messages", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{ role: "user", content: [{ type: "text", text: `text ${lone}` }] },
+		]);
+
+		const userContent = messages[0]?.content as Array<{
+			type: string;
+			text: string;
+		}>;
+		expect(userContent[0]?.text).toBe("text \uFFFD");
+	});
+
+	it("sanitizes text parts in assistant messages", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{ role: "assistant", content: [{ type: "text", text: `text ${lone}` }] },
+		]);
+
+		const content = messages[0]?.content as Array<{
+			type: string;
+			text: string;
+		}>;
+		expect(content[0]?.text).toBe("text \uFFFD");
+	});
+
+	it("sanitizes reasoning parts in assistant messages", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "assistant",
+				content: [{ type: "reasoning", text: `think ${lone}` }],
+			},
+		]);
+
+		const content = messages[0]?.content as Array<{
+			type: string;
+			text: string;
+		}>;
+		expect(content[0]?.text).toBe("think \uFFFD");
+	});
+
+	it("sanitizes tool result string output", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "test",
+						output: `result ${lone}`,
+					},
+				],
+			},
+		]);
+
+		const content = messages[0]?.content as Array<{
+			type: string;
+			output: { type: string; value: string };
+		}>;
+		expect(content[0]?.output.value).toBe("result \uFFFD");
+	});
+
+	it("sanitizes tool result text content blocks", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "test",
+						output: [{ type: "text", text: `content ${lone}` }],
+					},
+				],
+			},
+		]);
+
+		const content = messages[0]?.content as Array<{
+			type: string;
+			output: { type: string; value: Array<{ type: string; text: string }> };
+		}>;
+		expect(content[0]?.output.value[0]?.text).toBe("content \uFFFD");
+	});
+
+	it("sanitizes deeply nested strings in json tool output", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool-result",
+						toolCallId: "call_1",
+						toolName: "test",
+						output: { nested: `value ${lone}` },
+					},
+				],
+			},
+		]);
+
+		const content = messages[0]?.content as Array<{
+			type: string;
+			output: { type: string; value: { nested: string } };
+		}>;
+		expect(content[0]?.output.value.nested).toBe("value \uFFFD");
+	});
+
+	it("sanitizes file content", () => {
+		const lone = "\uD83D";
+		const messages = formatMessagesForAiSdk(undefined, [
+			{
+				role: "user",
+				content: [
+					{ type: "file", path: "/tmp/test.txt", content: `file ${lone}` },
+				],
+			},
+		]);
+
+		const content = messages[0]?.content as Array<{
+			type: string;
+			text: string;
+		}>;
+		expect(content[0]?.text).toContain("file \uFFFD");
+	});
+});
diff --git a/sdk/packages/shared/src/llms/ai-sdk-format.ts b/sdk/packages/shared/src/llms/ai-sdk-format.ts
new file mode 100644
index 0000000..72a4085
--- /dev/null
+++ b/sdk/packages/shared/src/llms/ai-sdk-format.ts
@@ -0,0 +1,643 @@
+import { formatFileContentBlock } from "../prompt/format";
+import {
+	createMediaBudgetState,
+	DEFAULT_MAX_IMAGE_DECODED_BYTES,
+	DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+	IMAGE_OMITTED_PLACEHOLDER,
+	imageBase64LengthForDecodedBytes,
+	type MediaBudgetState,
+	reserveImageMediaBytes,
+	SUPPORTED_IMAGE_MEDIA_TYPES,
+	validateAndReserveImageMedia,
+} from "./media";
+
+/**
+ * Sanitizes unpaired/lone Unicode surrogates in text content.
+ *
+ * Lone surrogates (high surrogates without matching low surrogates, or vice versa)
+ * can cause JSON serialization issues and downstream processing errors when sending
+ * text to LLM providers. This function replaces them with the Unicode replacement
+ * character (U+FFFD).
+ *
+ * @param content - The string to sanitize
+ * @returns The string with lone surrogates replaced by U+FFFD
+ */
+export function sanitizeSurrogates(content: string): string {
+	return content.replace(
+		/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g,
+		"\uFFFD",
+	);
+}
+
+export type AiSdkFormatterMessageRole = "user" | "assistant" | "tool";
+
+export type AiSdkFormatterPart =
+	| {
+			type: "text";
+			text: string;
+			providerOptions?: Record<string, Record<string, unknown>>;
+	  }
+	| {
+			type: "reasoning";
+			text: string;
+			providerOptions?: Record<string, Record<string, unknown>>;
+	  }
+	| {
+			type: "image";
+			image: string | Uint8Array | ArrayBuffer | URL;
+			mediaType?: string;
+	  }
+	| {
+			type: "file";
+			path: string;
+			content: string;
+	  }
+	| {
+			type: "tool-call";
+			toolCallId: string;
+			toolName: string;
+			input: unknown;
+			providerOptions?: Record<string, Record<string, unknown>>;
+	  }
+	| {
+			type: "tool-result";
+			toolCallId: string;
+			toolName: string;
+			output: unknown;
+			isError?: boolean;
+	  };
+
+export interface AiSdkFormatterMessage {
+	role: AiSdkFormatterMessageRole;
+	content: string | AiSdkFormatterPart[];
+}
+
+export const EMPTY_CONTENT_TEXT = "ERROR: EMPTY CONTENT";
+const IMAGE_ATTACHED_TEXT = "[image attached]";
+
+export type AiSdkMessagePart = Record<string, unknown>;
+export type AiSdkMessage = {
+	role: "system" | "user" | "assistant" | "tool";
+	content: string | AiSdkMessagePart[];
+};
+
+type AiSdkContentBlock =
+	| { type: "text"; text: string }
+	| { type: "image"; data: string; mediaType: string };
+type AiSdkImageContentBlock = Extract<AiSdkContentBlock, { type: "image" }>;
+
+interface StripImagesResult {
+	value: unknown;
+	changed: boolean;
+	mediaChanged: boolean;
+}
+
+function pushAiSdkMessage(result: AiSdkMessage[], message: AiSdkMessage): void {
+	const previous = result[result.length - 1];
+	if (
+		message.role === "tool" &&
+		previous?.role === "tool" &&
+		Array.isArray(previous.content) &&
+		Array.isArray(message.content)
+	) {
+		previous.content.push(...message.content);
+		return;
+	}
+
+	result.push(message);
+}
+
+/**
+ * Type guard for tool-output content blocks that should be passed to the model
+ * as native multimodal parts (rather than JSON-encoded). We accept the cline
+ * `image` and `text` block shapes used by `formatStructuredToolResult`.
+ */
+function isAiSdkContentBlockArray(
+	value: unknown,
+): value is AiSdkContentBlock[] {
+	if (!Array.isArray(value) || value.length === 0) {
+		return false;
+	}
+	return value.every((block) => {
+		if (!block || typeof block !== "object") {
+			return false;
+		}
+		const b = block as Record<string, unknown>;
+		if (b.type === "text") {
+			return typeof b.text === "string";
+		}
+		if (b.type === "image") {
+			return typeof b.data === "string" && typeof b.mediaType === "string";
+		}
+		return false;
+	});
+}
+
+function imageOmittedTextPart(): { type: "text"; text: string } {
+	return { type: "text", text: IMAGE_OMITTED_PLACEHOLDER };
+}
+
+function reserveRemoteImageUrlBudget(state: MediaBudgetState): boolean {
+	// Remote URL byte size is unknown at formatting time, so charge the
+	// conservative per-image cap instead of letting URL media count as free.
+	return (
+		reserveImageMediaBytes(
+			DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+			0,
+			{
+				maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+				maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+			},
+			state,
+		) === null
+	);
+}
+
+function parseUrlProtocol(value: string): string | undefined {
+	try {
+		return new URL(value).protocol;
+	} catch {
+		return undefined;
+	}
+}
+
+function toImageDataPart(
+	image: AiSdkImageContentBlock,
+	state: MediaBudgetState,
+):
+	| { type: "image-data"; data: string; mediaType: string }
+	| {
+			type: "text";
+			text: string;
+	  } {
+	const validation = validateAndReserveImageMedia(
+		image.mediaType,
+		image.data,
+		{
+			maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+			maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+		},
+		state,
+	);
+	if (!validation.ok) {
+		return imageOmittedTextPart();
+	}
+	return {
+		type: "image-data",
+		data: validation.base64,
+		mediaType: validation.mediaType,
+	};
+}
+
+function toUserImagePart(
+	image: Extract<AiSdkFormatterPart, { type: "image" }>,
+	state: MediaBudgetState,
+): AiSdkMessagePart {
+	if (image.image instanceof URL) {
+		if (image.image.protocol === "data:") {
+			const validation = validateAndReserveImageMedia(
+				image.mediaType,
+				image.image.href,
+				{
+					maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+					maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+				},
+				state,
+			);
+			if (!validation.ok) {
+				return imageOmittedTextPart();
+			}
+			return {
+				type: "image",
+				image: `data:${validation.mediaType};base64,${validation.base64}`,
+				mediaType: validation.mediaType,
+			};
+		}
+		if (image.image.protocol !== "http:" && image.image.protocol !== "https:") {
+			return imageOmittedTextPart();
+		}
+		if (!reserveRemoteImageUrlBudget(state)) {
+			return imageOmittedTextPart();
+		}
+		return {
+			type: "image",
+			image: image.image,
+			mediaType: image.mediaType,
+		};
+	}
+
+	if (typeof image.image === "string") {
+		const protocol = parseUrlProtocol(image.image);
+		if (protocol === "http:" || protocol === "https:") {
+			if (!reserveRemoteImageUrlBudget(state)) {
+				return imageOmittedTextPart();
+			}
+			return {
+				type: "image",
+				image: image.image,
+				mediaType: image.mediaType,
+			};
+		}
+		const isDataUrl = protocol === "data:";
+
+		const validation = validateAndReserveImageMedia(
+			image.mediaType ?? (isDataUrl ? undefined : "image/png"),
+			image.image,
+			{
+				maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+				maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+			},
+			state,
+		);
+		if (!validation.ok) {
+			return imageOmittedTextPart();
+		}
+		return {
+			type: "image",
+			image: isDataUrl
+				? `data:${validation.mediaType};base64,${validation.base64}`
+				: validation.base64,
+			mediaType: validation.mediaType,
+		};
+	}
+
+	const decodedBytes = image.image.byteLength;
+	const encodedBytes = imageBase64LengthForDecodedBytes(decodedBytes);
+	const mediaType = image.mediaType?.toLowerCase() ?? "image/png";
+	const supportedMediaTypes: readonly string[] = SUPPORTED_IMAGE_MEDIA_TYPES;
+	if (
+		!supportedMediaTypes.includes(mediaType) ||
+		reserveImageMediaBytes(
+			encodedBytes,
+			decodedBytes,
+			{
+				maxImageEncodedBytes: DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+				maxImageDecodedBytes: DEFAULT_MAX_IMAGE_DECODED_BYTES,
+			},
+			state,
+		)
+	) {
+		return imageOmittedTextPart();
+	}
+
+	return {
+		type: "image",
+		image: image.image,
+		mediaType,
+	};
+}
+
+/**
+ * Recursively walk a tool-result `output` value, removing any AI-SDK image
+ * content blocks (`{type:'image', data, mediaType}`) and collecting them
+ * into `images`. Inline-text blocks (`{type:'text', text}`) are unwrapped
+ * to bare strings so the resulting structure JSON-serialises cleanly for
+ * the model.
+ *
+ * Returns the stripped value with images removed (other structure
+ * preserved). The original input is not mutated.
+ */
+function stripImagesFromOutput(
+	value: unknown,
+	images: AiSdkImageContentBlock[],
+	state: MediaBudgetState,
+	hoistImages = true,
+): StripImagesResult {
+	if (value == null || typeof value !== "object") {
+		return { value, changed: false, mediaChanged: false };
+	}
+
+	if (Array.isArray(value)) {
+		const out: unknown[] = [];
+		let changed = false;
+		let mediaChanged = false;
+		for (const item of value) {
+			if (item && typeof item === "object") {
+				const obj = item as Record<string, unknown>;
+				if (
+					obj.type === "image" &&
+					typeof obj.data === "string" &&
+					typeof obj.mediaType === "string"
+				) {
+					if (!hoistImages) {
+						out.push(IMAGE_OMITTED_PLACEHOLDER);
+						changed = true;
+						mediaChanged = true;
+						continue;
+					}
+					const image = {
+						type: "image",
+						data: obj.data,
+						mediaType: obj.mediaType,
+					} satisfies AiSdkImageContentBlock;
+					const part = toImageDataPart(image, state);
+					if (part.type === "image-data") {
+						images.push({
+							type: "image",
+							data: part.data,
+							mediaType: part.mediaType,
+						});
+					} else {
+						out.push(part.text);
+					}
+					changed = true;
+					mediaChanged = true;
+					continue;
+				}
+				if (obj.type === "image") {
+					out.push(IMAGE_OMITTED_PLACEHOLDER);
+					changed = true;
+					mediaChanged = true;
+					continue;
+				}
+				if (obj.type === "text" && typeof obj.text === "string") {
+					out.push(obj.text);
+					changed = true;
+					continue;
+				}
+			}
+			const stripped = stripImagesFromOutput(item, images, state, hoistImages);
+			out.push(stripped.value);
+			changed ||= stripped.changed;
+			mediaChanged ||= stripped.mediaChanged;
+		}
+		return { value: changed ? out : value, changed, mediaChanged };
+	}
+
+	const obj = value as Record<string, unknown>;
+	if (obj.type === "image") {
+		if (typeof obj.data === "string" && typeof obj.mediaType === "string") {
+			if (!hoistImages) {
+				return {
+					value: IMAGE_OMITTED_PLACEHOLDER,
+					changed: true,
+					mediaChanged: true,
+				};
+			}
+			const image = {
+				type: "image",
+				data: obj.data,
+				mediaType: obj.mediaType,
+			} satisfies AiSdkImageContentBlock;
+			const part = toImageDataPart(image, state);
+			if (part.type === "image-data") {
+				images.push({
+					type: "image",
+					data: part.data,
+					mediaType: part.mediaType,
+				});
+				return {
+					value: IMAGE_ATTACHED_TEXT,
+					changed: true,
+					mediaChanged: true,
+				};
+			}
+			return { value: part.text, changed: true, mediaChanged: true };
+		}
+		return {
+			value: IMAGE_OMITTED_PLACEHOLDER,
+			changed: true,
+			mediaChanged: true,
+		};
+	}
+
+	const out: Record<string, unknown> = {};
+	let changed = false;
+	let mediaChanged = false;
+	for (const [k, v] of Object.entries(obj)) {
+		const stripped = stripImagesFromOutput(v, images, state, hoistImages);
+		out[k] = stripped.value;
+		changed ||= stripped.changed;
+		mediaChanged ||= stripped.mediaChanged;
+	}
+	return { value: changed ? out : value, changed, mediaChanged };
+}
+
+/** Sanitize all string values deeply nested inside an arbitrary object/array. */
+function sanitizeDeepStrings(value: unknown): unknown {
+	if (typeof value === "string") {
+		return sanitizeSurrogates(value);
+	}
+	if (Array.isArray(value)) {
+		return value.map((item) => sanitizeDeepStrings(item));
+	}
+	if (value !== null && typeof value === "object") {
+		const obj = value as Record<string, unknown>;
+		const out: Record<string, unknown> = {};
+		for (const [k, v] of Object.entries(obj)) {
+			out[k] = sanitizeDeepStrings(v);
+		}
+		return out;
+	}
+	return value;
+}
+
+export function toAiSdkToolResultOutput(
+	output: unknown,
+	isError = false,
+	mediaState: MediaBudgetState = createMediaBudgetState(),
+): Record<string, unknown> {
+	if (typeof output === "string") {
+		return {
+			type: isError ? "error-text" : "text",
+			value: sanitizeSurrogates(output),
+		};
+	}
+
+	// Arrays of `text` / `image` content blocks (e.g. from read_file image
+	// results) must be forwarded as AI SDK `content` parts so providers
+	// translate them into real multimodal inputs. Without this, the array
+	// falls through to the `json` branch below and the base64 image data
+	// is sent to the model as a JSON string — the model cannot see it and
+	// will hallucinate the image's contents.
+	if (!isError && isAiSdkContentBlockArray(output)) {
+		return {
+			type: "content",
+			value: output.map((block) =>
+				block.type === "image"
+					? toImageDataPart(block, mediaState)
+					: { type: "text", text: sanitizeSurrogates(block.text) },
+			),
+		};
+	}
+
+	// Structured outputs that contain nested image blocks (e.g. the
+	// `[{query, result: ['Successfully read image', {type:'image',...}], success}]`
+	// shape produced by `read_files` for image paths) must also reach the
+	// model as native multimodal parts. Walk the structure, pull the image
+	// blocks out, and forward the remaining metadata as a JSON-stringified
+	// text block followed by the extracted images. Without this, the wire
+	// converter JSON-serialises the whole tree and the model receives the
+	// base64 bytes as opaque text.
+	if (output !== null && typeof output === "object") {
+		const images: AiSdkImageContentBlock[] = [];
+		const stripped = stripImagesFromOutput(
+			output,
+			images,
+			mediaState,
+			!isError,
+		);
+		if (!isError && images.length > 0) {
+			const headerText =
+				typeof stripped.value === "string"
+					? sanitizeSurrogates(stripped.value)
+					: JSON.stringify(sanitizeDeepStrings(stripped.value));
+			return {
+				type: "content",
+				value: [
+					{ type: "text", text: headerText },
+					...images.map((image) => ({
+						type: "image-data",
+						data: image.data,
+						mediaType: image.mediaType,
+					})),
+				],
+			};
+		}
+		if (stripped.mediaChanged) {
+			return {
+				type: isError ? "error-json" : "json",
+				value: sanitizeDeepStrings(stripped.value),
+			};
+		}
+	}
+
+	if (
+		output === null ||
+		typeof output === "boolean" ||
+		typeof output === "number" ||
+		typeof output === "object"
+	) {
+		return {
+			type: isError ? "error-json" : "json",
+			value: sanitizeDeepStrings(output),
+		};
+	}
+
+	return {
+		type: isError ? "error-text" : "text",
+		value: sanitizeSurrogates(String(output)),
+	};
+}
+
+export function formatMessagesForAiSdk(
+	systemContent: string | AiSdkMessagePart[] | undefined,
+	messages: readonly AiSdkFormatterMessage[],
+	options?: { assistantToolCallArgKey?: "args" | "input" },
+): AiSdkMessage[] {
+	const toolCallArgKey = options?.assistantToolCallArgKey ?? "input";
+	const result: AiSdkMessage[] = [];
+	const mediaState = createMediaBudgetState();
+
+	if (
+		(typeof systemContent === "string" && systemContent.trim().length > 0) ||
+		(Array.isArray(systemContent) && systemContent.length > 0)
+	) {
+		result.push({
+			role: "system",
+			content:
+				typeof systemContent === "string"
+					? sanitizeSurrogates(systemContent)
+					: systemContent,
+		});
+	}
+
+	for (const message of messages) {
+		const contentParts = message.content;
+
+		if (typeof contentParts === "string") {
+			if (contentParts.trim().length === 0) {
+				result.push({
+					role: message.role,
+					content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+				});
+				continue;
+			}
+			result.push({
+				role: message.role,
+				content: sanitizeSurrogates(contentParts),
+			});
+			continue;
+		}
+
+		const messageParts: AiSdkMessagePart[] = [];
+		const toolResultParts: AiSdkMessagePart[] = [];
+		if (contentParts.length === 0) {
+			result.push({
+				role: message.role,
+				content: [{ type: "text", text: EMPTY_CONTENT_TEXT }],
+			});
+			continue;
+		}
+
+		for (const part of contentParts) {
+			switch (part.type) {
+				case "text":
+					messageParts.push({
+						type: "text",
+						text: sanitizeSurrogates(part.text),
+						...(part.providerOptions
+							? { providerOptions: part.providerOptions }
+							: {}),
+					});
+					break;
+				case "reasoning":
+					messageParts.push({
+						type: "reasoning",
+						text: sanitizeSurrogates(part.text),
+						...(part.providerOptions
+							? { providerOptions: part.providerOptions }
+							: {}),
+					});
+					break;
+				case "image":
+					messageParts.push(toUserImagePart(part, mediaState));
+					break;
+				case "file":
+					messageParts.push({
+						type: "text",
+						text: formatFileContentBlock(
+							part.path,
+							sanitizeSurrogates(part.content),
+						),
+					});
+					break;
+				case "tool-call":
+					if (message.role === "assistant") {
+						messageParts.push({
+							type: "tool-call",
+							toolCallId: part.toolCallId,
+							toolName: part.toolName,
+							[toolCallArgKey]: part.input,
+							...(part.providerOptions
+								? { providerOptions: part.providerOptions }
+								: {}),
+						});
+					}
+					break;
+				case "tool-result": {
+					toolResultParts.push({
+						type: "tool-result",
+						toolCallId: part.toolCallId,
+						toolName: part.toolName,
+						output: toAiSdkToolResultOutput(
+							part.output,
+							part.isError ?? false,
+							mediaState,
+						),
+					});
+					break;
+				}
+			}
+		}
+
+		if (messageParts.length > 0) {
+			pushAiSdkMessage(result, { role: message.role, content: messageParts });
+		}
+		if (toolResultParts.length > 0) {
+			pushAiSdkMessage(result, { role: "tool", content: toolResultParts });
+		}
+	}
+
+	return result;
+}
diff --git a/sdk/packages/shared/src/llms/gateway.ts b/sdk/packages/shared/src/llms/gateway.ts
new file mode 100644
index 0000000..f840f28
--- /dev/null
+++ b/sdk/packages/shared/src/llms/gateway.ts
@@ -0,0 +1,218 @@
+import type {
+	AgentMessage,
+	AgentModelEvent,
+	AgentToolDefinition,
+} from "../agent";
+import type { BasicLogger } from "../logging/logger";
+import type { ProviderCapability, ProviderConfigField } from "../rpc/runtime";
+import type { ITelemetryService } from "../services/telemetry";
+
+export type JsonValue =
+	| string
+	| number
+	| boolean
+	| null
+	| JsonValue[]
+	| { [key: string]: JsonValue | undefined };
+
+// AgentToolDefinition, AgentMessagePart, AgentMessage, AgentModelRequest,
+// AgentModelFinishReason, AgentModelEvent, AgentModel, and AgentModelUsage
+// previously lived here with gateway-local shapes. They have been retired in
+// favor of the canonical AgentRuntime types in `../agent` (PLAN.md §3.6 Step 3,
+// expanded). `AgentModelUsage` is superseded by `AgentUsage` (`AgentTokenUsage`
+// + optional `totalCost`); usage deltas on `AgentModelEvent` are now
+// `Partial<AgentUsage>`.
+
+export type GatewayModelCapability =
+	| "text"
+	| "tools"
+	| "reasoning"
+	| "prompt-cache"
+	| "images"
+	| "audio"
+	| "structured-output";
+
+export type GatewayPromptCacheStrategy = "anthropic-automatic";
+export const USAGE_COST_DISPLAYS = ["show", "hide", "subscription"] as const;
+export type GatewayUsageCostDisplay = (typeof USAGE_COST_DISPLAYS)[number];
+export type GatewayPromptCacheFormat = "anthropic-cache-control";
+export type GatewayReasoningFormat =
+	| "anthropic-thinking"
+	| "glm-thinking"
+	| "minimax-thinking";
+export type GatewayModelRoute =
+	| { matcher: "anthropic-compatible" }
+	| {
+			matcher: "model-family";
+			family: string;
+			requiredCapability?: GatewayModelCapability;
+	  }
+	| {
+			matcher: "model-id";
+			modelId: string;
+			requiredCapability?: GatewayModelCapability;
+	  };
+export interface GatewayProviderRouting {
+	promptCache?: {
+		format: GatewayPromptCacheFormat;
+		routes: GatewayModelRoute[];
+	};
+	reasoning?: {
+		format: GatewayReasoningFormat;
+		routes: GatewayModelRoute[];
+	};
+}
+
+export type GatewayStickySessionTransport = "json-body" | "header";
+
+export interface GatewayStickySessionMetadata {
+	/**
+	 * Where the provider expects the sticky-session identifier on the wire.
+	 * `field` is a JSON body property for `json-body`, and an HTTP header name
+	 * for `header`.
+	 */
+	transport: GatewayStickySessionTransport;
+	field: string;
+	metadataKey: string;
+}
+
+export interface GatewayProviderMetadata {
+	promptCacheStrategy?: GatewayPromptCacheStrategy;
+	usageCostDisplay?: GatewayUsageCostDisplay;
+	routing?: GatewayProviderRouting;
+	stickySession?: GatewayStickySessionMetadata;
+	configFields?: readonly ProviderConfigField[];
+	[key: string]:
+		| JsonValue
+		| GatewayProviderRouting
+		| GatewayStickySessionMetadata
+		| readonly ProviderConfigField[]
+		| undefined;
+}
+
+export interface GatewayModelDefinition {
+	id: string;
+	name: string;
+	providerId: string;
+	description?: string;
+	contextWindow?: number;
+	maxInputTokens?: number;
+	maxOutputTokens?: number;
+	capabilities?: readonly GatewayModelCapability[];
+	metadata?: Record<string, JsonValue | undefined>;
+}
+
+export interface GatewayProviderManifest {
+	id: string;
+	name: string;
+	description?: string;
+	defaultModelId: string;
+	models: readonly GatewayModelDefinition[];
+	capabilities?: readonly ProviderCapability[];
+	env?: readonly ("browser" | "node")[];
+	api?: string;
+	apiKeyEnv?: readonly string[];
+	docsUrl?: string;
+	metadata?: GatewayProviderMetadata;
+}
+
+export interface GatewayProviderSettings {
+	apiKey?: string;
+	apiKeyResolver?: () => string | undefined | Promise<string | undefined>;
+	apiKeyEnv?: readonly string[];
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	timeoutMs?: number;
+	fetch?: typeof fetch;
+	options?: Record<string, unknown>;
+	metadata?: GatewayProviderMetadata;
+}
+
+export interface GatewayResolvedProviderConfig extends GatewayProviderSettings {
+	providerId: string;
+}
+
+export interface GatewayProviderConfig extends GatewayProviderSettings {
+	providerId: string;
+	enabled?: boolean;
+	defaultModelId?: string;
+	models?: readonly Omit<GatewayModelDefinition, "providerId">[];
+}
+
+export interface GatewayModelSelection {
+	providerId: string;
+	modelId?: string;
+}
+
+export interface GatewayResolvedModel {
+	provider: GatewayProviderManifest;
+	model: GatewayModelDefinition;
+}
+
+export interface GatewayProviderContext {
+	provider: GatewayProviderManifest;
+	model: GatewayModelDefinition;
+	config: GatewayResolvedProviderConfig;
+	signal?: AbortSignal;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}
+
+export interface GatewayStreamRequest {
+	providerId: string;
+	modelId: string;
+	systemPrompt?: string;
+	messages: readonly AgentMessage[];
+	tools?: readonly AgentToolDefinition[];
+	temperature?: number;
+	maxTokens?: number;
+	metadata?: Record<string, unknown>;
+	reasoning?: {
+		enabled?: boolean;
+		effort?: "low" | "medium" | "high";
+		budgetTokens?: number;
+	};
+	signal?: AbortSignal;
+}
+
+export interface GatewayProvider {
+	stream(
+		request: GatewayStreamRequest,
+		context: GatewayProviderContext,
+	): AsyncIterable<AgentModelEvent> | Promise<AsyncIterable<AgentModelEvent>>;
+}
+
+export type GatewayProviderFactory = (
+	config: GatewayResolvedProviderConfig,
+) => GatewayProvider | Promise<GatewayProvider>;
+
+export interface GatewayProviderRegistration {
+	manifest: GatewayProviderManifest;
+	defaults?: GatewayProviderSettings;
+	createProvider?: GatewayProviderFactory;
+	loadProvider?: () => Promise<
+		Pick<GatewayProviderRegistration, "createProvider">
+	>;
+}
+
+export interface GatewayModelHandleOptions {
+	tools?: readonly AgentToolDefinition[];
+	temperature?: number;
+	maxTokens?: number;
+	metadata?: Record<string, unknown>;
+	reasoning?: {
+		enabled?: boolean;
+		effort?: "low" | "medium" | "high";
+		budgetTokens?: number;
+	};
+	signal?: AbortSignal;
+}
+
+export interface GatewayConfig {
+	builtins?: false | readonly string[];
+	providers?: readonly GatewayProviderRegistration[];
+	providerConfigs?: readonly GatewayProviderConfig[];
+	fetch?: typeof fetch;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}
diff --git a/sdk/packages/shared/src/llms/media.test.ts b/sdk/packages/shared/src/llms/media.test.ts
new file mode 100644
index 0000000..ec9893c
--- /dev/null
+++ b/sdk/packages/shared/src/llms/media.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import {
+	createMediaBudgetState,
+	imageBase64DecodedByteLength,
+	imageBase64LengthForDecodedBytes,
+	isCanonicalBase64,
+	validateAndReserveImageMedia,
+	validateImageMedia,
+} from "./media";
+
+describe("image media validation", () => {
+	it("accepts raw canonical base64 for supported image types", () => {
+		const result = validateImageMedia("image/png", "aGVsbG8=");
+
+		expect(result).toMatchObject({
+			ok: true,
+			mediaType: "image/png",
+			base64: "aGVsbG8=",
+			encodedBytes: 8,
+			decodedBytes: 5,
+		});
+	});
+
+	it("accepts matching data URLs and returns raw base64", () => {
+		const result = validateImageMedia(
+			"image/png",
+			"data:image/png;base64,aGVsbG8=",
+		);
+
+		expect(result).toMatchObject({
+			ok: true,
+			mediaType: "image/png",
+			base64: "aGVsbG8=",
+		});
+	});
+
+	it("accepts case-insensitive data URL schemes", () => {
+		const result = validateImageMedia(
+			"image/png",
+			"DATA:image/png;base64,aGVsbG8=",
+		);
+
+		expect(result).toMatchObject({
+			ok: true,
+			mediaType: "image/png",
+			base64: "aGVsbG8=",
+		});
+	});
+
+	it("rejects MIME mismatches, unsupported types, malformed base64, and byte overflow", () => {
+		expect(
+			validateImageMedia("image/png", "data:image/jpeg;base64,/9j/"),
+		).toMatchObject({ ok: false, reason: "media_type_mismatch" });
+		expect(validateImageMedia("image/svg+xml", "PHN2Zz4=")).toMatchObject({
+			ok: false,
+			reason: "unsupported_media_type",
+		});
+		expect(validateImageMedia("image/png", "not-base64")).toMatchObject({
+			ok: false,
+			reason: "invalid_base64",
+		});
+		expect(
+			validateImageMedia("image/png", "QUJDRA==", { maxEncodedBytes: 4 }),
+		).toMatchObject({ ok: false, reason: "encoded_limit" });
+		expect(
+			validateImageMedia("image/png", "QUJDRA==", { maxDecodedBytes: 3 }),
+		).toMatchObject({ ok: false, reason: "decoded_limit" });
+	});
+
+	it("rejects oversized encoded payloads before base64 syntax validation", () => {
+		expect(
+			validateImageMedia("image/png", "not-base64-and-too-long", {
+				maxEncodedBytes: 4,
+			}),
+		).toMatchObject({ ok: false, reason: "encoded_limit" });
+		expect(
+			validateImageMedia("image/png", "data:image/png;base64,not-base64", {
+				maxEncodedBytes: 4,
+			}),
+		).toMatchObject({ ok: false, reason: "encoded_limit" });
+	});
+
+	it("tracks aggregate media budget while reserving valid images", () => {
+		const state = createMediaBudgetState();
+		const first = validateAndReserveImageMedia(
+			"image/png",
+			"QUJDRA==",
+			{ maxTotalMediaBytes: 8 },
+			state,
+		);
+		const second = validateAndReserveImageMedia(
+			"image/png",
+			"QUJDRA==",
+			{ maxTotalMediaBytes: 8 },
+			state,
+		);
+
+		expect(first).toMatchObject({ ok: true });
+		expect(second).toMatchObject({ ok: false, reason: "total_limit" });
+		expect(state).toMatchObject({
+			totalEncodedBytes: 8,
+			keptImages: 1,
+			omittedImages: 1,
+			omittedReasons: { total_limit: 1 },
+		});
+	});
+
+	it("computes decoded and encoded base64 sizes without decoding bytes", () => {
+		expect(imageBase64DecodedByteLength("QUJDRA==")).toBe(4);
+		expect(imageBase64LengthForDecodedBytes(4)).toBe(8);
+	});
+
+	it("checks canonical base64 strings without decoding bytes", () => {
+		expect(isCanonicalBase64("QUJDRA==")).toBe(true);
+		expect(isCanonicalBase64("not-base64")).toBe(false);
+		expect(isCanonicalBase64("")).toBe(false);
+	});
+});
diff --git a/sdk/packages/shared/src/llms/media.ts b/sdk/packages/shared/src/llms/media.ts
new file mode 100644
index 0000000..01ff7d5
--- /dev/null
+++ b/sdk/packages/shared/src/llms/media.ts
@@ -0,0 +1,378 @@
+export const IMAGE_OMITTED_PLACEHOLDER =
+	"[media omitted: invalid or exceeds size limit]";
+
+export const SUPPORTED_IMAGE_MEDIA_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp",
+] as const;
+
+export const DEFAULT_MAX_IMAGE_BASE64_BYTES = 5 * 1024 * 1024;
+export const DEFAULT_MAX_IMAGE_ENCODED_BYTES = DEFAULT_MAX_IMAGE_BASE64_BYTES;
+export const DEFAULT_MAX_IMAGE_DECODED_BYTES = 6 * 1024 * 1024;
+export const DEFAULT_MAX_TOTAL_MEDIA_BYTES = 8 * 1024 * 1024;
+
+export interface ImageMediaLimits {
+	maxEncodedBytes?: number;
+	maxDecodedBytes?: number;
+	supportedMediaTypes?: readonly string[];
+}
+
+export interface ImageMediaValidationSuccess {
+	ok: true;
+	mediaType: string;
+	base64: string;
+	encodedBytes: number;
+	decodedBytes: number;
+}
+
+export interface ImageMediaValidationFailure {
+	ok: false;
+	reason:
+		| "unsupported_media_type"
+		| "media_type_mismatch"
+		| "invalid_base64"
+		| "encoded_limit"
+		| "decoded_limit"
+		| "total_limit";
+	message: string;
+}
+
+export type ImageMediaValidationResult =
+	| ImageMediaValidationSuccess
+	| ImageMediaValidationFailure;
+
+export interface MediaBudgetOptions {
+	maxImageEncodedBytes?: number;
+	maxImageDecodedBytes?: number;
+	maxTotalMediaBytes?: number;
+}
+
+export interface ResolvedMediaBudget {
+	maxImageEncodedBytes: number;
+	maxImageDecodedBytes: number;
+	maxTotalMediaBytes: number;
+}
+
+export interface MediaBudgetState {
+	totalEncodedBytes: number;
+	keptImages: number;
+	omittedImages: number;
+	omittedReasons: Partial<
+		Record<ImageMediaValidationFailure["reason"], number>
+	>;
+}
+
+export function imageBase64EncodedByteLength(base64: string): number {
+	return base64.length;
+}
+
+export function imageBase64DecodedByteLength(base64: string): number {
+	const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+	return Math.floor((base64.length * 3) / 4) - padding;
+}
+
+export function imageFileMaxDecodedBytesForBase64Limit(
+	maxBase64Bytes = DEFAULT_MAX_IMAGE_BASE64_BYTES,
+): number {
+	return Math.floor((maxBase64Bytes * 3) / 4);
+}
+
+export function imageBase64LengthForDecodedBytes(decodedBytes: number): number {
+	return Math.ceil(decodedBytes / 3) * 4;
+}
+
+export function resolveMediaBudget(
+	options: MediaBudgetOptions = {},
+): ResolvedMediaBudget {
+	return {
+		maxImageEncodedBytes:
+			options.maxImageEncodedBytes ?? DEFAULT_MAX_IMAGE_ENCODED_BYTES,
+		maxImageDecodedBytes:
+			options.maxImageDecodedBytes ?? DEFAULT_MAX_IMAGE_DECODED_BYTES,
+		maxTotalMediaBytes:
+			options.maxTotalMediaBytes ?? DEFAULT_MAX_TOTAL_MEDIA_BYTES,
+	};
+}
+
+export function createMediaBudgetState(): MediaBudgetState {
+	return {
+		totalEncodedBytes: 0,
+		keptImages: 0,
+		omittedImages: 0,
+		omittedReasons: {},
+	};
+}
+
+function recordOmittedImage(
+	state: MediaBudgetState,
+	reason: ImageMediaValidationFailure["reason"],
+): void {
+	state.omittedImages += 1;
+	state.omittedReasons[reason] = (state.omittedReasons[reason] ?? 0) + 1;
+}
+
+export function reserveImageMediaBytes(
+	encodedBytes: number,
+	decodedBytes: number,
+	budget: MediaBudgetOptions,
+	state: MediaBudgetState,
+): ImageMediaValidationFailure | null {
+	const resolved = resolveMediaBudget(budget);
+	if (encodedBytes > resolved.maxImageEncodedBytes) {
+		const failure: ImageMediaValidationFailure = {
+			ok: false,
+			reason: "encoded_limit",
+			message: `Image media exceeds the ${resolved.maxImageEncodedBytes} byte encoded limit`,
+		};
+		recordOmittedImage(state, failure.reason);
+		return failure;
+	}
+	if (decodedBytes > resolved.maxImageDecodedBytes) {
+		const failure: ImageMediaValidationFailure = {
+			ok: false,
+			reason: "decoded_limit",
+			message: `Image media exceeds the ${resolved.maxImageDecodedBytes} byte decoded limit`,
+		};
+		recordOmittedImage(state, failure.reason);
+		return failure;
+	}
+	if (state.totalEncodedBytes + encodedBytes > resolved.maxTotalMediaBytes) {
+		const failure: ImageMediaValidationFailure = {
+			ok: false,
+			reason: "total_limit",
+			message: `Image media exceeds the ${resolved.maxTotalMediaBytes} byte total media limit`,
+		};
+		recordOmittedImage(state, failure.reason);
+		return failure;
+	}
+
+	state.totalEncodedBytes += encodedBytes;
+	state.keptImages += 1;
+	return null;
+}
+
+export function isBase64Char(charCode: number): boolean {
+	return (
+		(charCode >= 65 && charCode <= 90) ||
+		(charCode >= 97 && charCode <= 122) ||
+		(charCode >= 48 && charCode <= 57) ||
+		charCode === 43 ||
+		charCode === 47
+	);
+}
+
+export function isCanonicalBase64(base64: string): boolean {
+	return base64.length > 0 && isCanonicalBase64Range(base64, 0, base64.length);
+}
+
+function isCanonicalBase64Range(
+	base64: string,
+	start: number,
+	end: number,
+): boolean {
+	const length = end - start;
+	if (length % 4 !== 0) {
+		return false;
+	}
+
+	let paddingStart = end;
+	if (
+		length >= 2 &&
+		base64.charCodeAt(end - 2) === 61 &&
+		base64.charCodeAt(end - 1) === 61
+	) {
+		paddingStart -= 2;
+	} else if (length >= 1 && base64.charCodeAt(end - 1) === 61) {
+		paddingStart -= 1;
+	}
+
+	for (let i = start; i < paddingStart; i++) {
+		if (!isBase64Char(base64.charCodeAt(i))) {
+			return false;
+		}
+	}
+	for (let i = paddingStart; i < end; i++) {
+		if (base64.charCodeAt(i) !== 61) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function startsWithDataScheme(
+	data: string,
+	start: number,
+	end: number,
+): boolean {
+	return (
+		end - start >= 5 &&
+		(data.charCodeAt(start) | 32) === 100 &&
+		(data.charCodeAt(start + 1) | 32) === 97 &&
+		(data.charCodeAt(start + 2) | 32) === 116 &&
+		(data.charCodeAt(start + 3) | 32) === 97 &&
+		data.charCodeAt(start + 4) === 58
+	);
+}
+
+function trimmedRange(data: string): { start: number; end: number } {
+	let start = 0;
+	let end = data.length;
+	while (start < end && /\s/.test(data[start] ?? "")) {
+		start += 1;
+	}
+	while (end > start && /\s/.test(data[end - 1] ?? "")) {
+		end -= 1;
+	}
+	return { start, end };
+}
+
+function parseBase64DataUrlRange(
+	data: string,
+	start: number,
+	end: number,
+):
+	| {
+			mediaType: string;
+			base64Start: number;
+			base64End: number;
+	  }
+	| undefined {
+	if (!startsWithDataScheme(data, start, end)) {
+		return undefined;
+	}
+	const metadataStart = start + "data:".length;
+	const commaIndex = data.indexOf(",", metadataStart);
+	if (commaIndex === -1 || commaIndex >= end) {
+		return undefined;
+	}
+	if (commaIndex - metadataStart > 128) {
+		return undefined;
+	}
+	const metadata = data.slice(metadataStart, commaIndex).toLowerCase();
+	const base64Marker = ";base64";
+	if (!metadata.endsWith(base64Marker)) {
+		return undefined;
+	}
+	const mediaType = metadata.slice(0, -base64Marker.length);
+	if (!mediaType || mediaType.includes(";")) {
+		return undefined;
+	}
+	return {
+		mediaType,
+		base64Start: commaIndex + 1,
+		base64End: end,
+	};
+}
+
+export function validateImageMedia(
+	mediaType: string | undefined,
+	data: string,
+	limits: ImageMediaLimits = {},
+): ImageMediaValidationResult {
+	const maxEncodedBytes =
+		limits.maxEncodedBytes ?? DEFAULT_MAX_IMAGE_ENCODED_BYTES;
+	const maxDecodedBytes =
+		limits.maxDecodedBytes ?? DEFAULT_MAX_IMAGE_DECODED_BYTES;
+	const supportedMediaTypes = new Set(
+		limits.supportedMediaTypes ?? SUPPORTED_IMAGE_MEDIA_TYPES,
+	);
+
+	let effectiveMediaType = mediaType?.toLowerCase();
+	const range = trimmedRange(data);
+	let base64Start = range.start;
+	let base64End = range.end;
+	const dataUrl = parseBase64DataUrlRange(data, range.start, range.end);
+	if (dataUrl) {
+		if (effectiveMediaType && effectiveMediaType !== dataUrl.mediaType) {
+			return {
+				ok: false,
+				reason: "media_type_mismatch",
+				message: `Image media type ${mediaType} does not match data URL type ${dataUrl.mediaType}`,
+			};
+		}
+		effectiveMediaType = dataUrl.mediaType;
+		base64Start = dataUrl.base64Start;
+		base64End = dataUrl.base64End;
+	}
+
+	if (!effectiveMediaType || !supportedMediaTypes.has(effectiveMediaType)) {
+		return {
+			ok: false,
+			reason: "unsupported_media_type",
+			message: `Unsupported image media type: ${mediaType ?? "unknown"}`,
+		};
+	}
+
+	const encodedBytes = base64End - base64Start;
+	if (encodedBytes === 0) {
+		return {
+			ok: false,
+			reason: "invalid_base64",
+			message: "Image media must contain valid base64",
+		};
+	}
+
+	if (encodedBytes > maxEncodedBytes) {
+		return {
+			ok: false,
+			reason: "encoded_limit",
+			message: `Image media exceeds the ${maxEncodedBytes} byte encoded limit`,
+		};
+	}
+
+	if (!isCanonicalBase64Range(data, base64Start, base64End)) {
+		return {
+			ok: false,
+			reason: "invalid_base64",
+			message: "Image media must contain valid base64",
+		};
+	}
+
+	const base64 = data.slice(base64Start, base64End);
+	const decodedBytes = imageBase64DecodedByteLength(base64);
+	if (decodedBytes > maxDecodedBytes) {
+		return {
+			ok: false,
+			reason: "decoded_limit",
+			message: `Image media exceeds the ${maxDecodedBytes} byte decoded limit`,
+		};
+	}
+
+	return {
+		ok: true,
+		mediaType: effectiveMediaType,
+		base64,
+		encodedBytes,
+		decodedBytes,
+	};
+}
+
+export function validateAndReserveImageMedia(
+	mediaType: string | undefined,
+	data: string,
+	budget: MediaBudgetOptions,
+	state: MediaBudgetState,
+): ImageMediaValidationResult {
+	const validation = validateImageMedia(mediaType, data, {
+		maxEncodedBytes: budget.maxImageEncodedBytes,
+		maxDecodedBytes: budget.maxImageDecodedBytes,
+	});
+	if (!validation.ok) {
+		recordOmittedImage(state, validation.reason);
+		return validation;
+	}
+
+	const failure = reserveImageMediaBytes(
+		validation.encodedBytes,
+		validation.decodedBytes,
+		budget,
+		state,
+	);
+	if (failure) {
+		return failure;
+	}
+
+	return validation;
+}
diff --git a/sdk/packages/shared/src/llms/messages.ts b/sdk/packages/shared/src/llms/messages.ts
new file mode 100644
index 0000000..6ec88e5
--- /dev/null
+++ b/sdk/packages/shared/src/llms/messages.ts
@@ -0,0 +1,168 @@
+/**
+ * Message Types
+ *
+ * Standardized message format for input to providers.
+ * This is a simplified, provider-agnostic format that can be
+ * converted to any provider's native format.
+ */
+
+/**
+ * Message roles
+ */
+export type MessageRole = "user" | "assistant";
+
+/**
+ * Text content block
+ */
+export interface TextContent {
+	type: "text";
+	text: string;
+	/** Thought signature for this text part (Gemini) */
+	signature?: string;
+}
+
+/**
+ * File content block for Cline
+ */
+export interface FileContent {
+	type: "file";
+	content: string;
+	/** Absolute Path */
+	path: string;
+	source?: string;
+}
+
+/**
+ * Image content block
+ */
+export interface ImageContent {
+	type: "image";
+	/** Base64 encoded image data */
+	data: string;
+	/** MIME type (e.g., "image/png", "image/jpeg") */
+	mediaType: string;
+}
+
+/**
+ * Tool use content block (assistant's tool call)
+ */
+export interface ToolUseContent {
+	type: "tool_use";
+	/** Unique ID for this tool call */
+	id: string;
+	/** Provider-native call ID for this tool call (if available) */
+	call_id?: string;
+	/** Name of the tool being called */
+	name: string;
+	/** Arguments for the tool call */
+	input: Record<string, unknown>;
+	/** Thought signature for this function call part (Gemini) */
+	signature?: string;
+}
+
+/**
+ * Tool result content block (user's response to tool call)
+ */
+export interface ToolResultContent {
+	type: "tool_result";
+	/** ID of the tool call this is responding to */
+	tool_use_id: string;
+	/** Name of the tool that generated this result */
+	name: string;
+	/** Result content (can be text or error) */
+	content: string | Array<TextContent | ImageContent | FileContent>;
+	/** Whether this result represents an error */
+	is_error?: boolean;
+}
+
+/**
+ * Thinking/reasoning content block
+ */
+export interface ThinkingContent {
+	type: "thinking";
+	/** The thinking/reasoning text */
+	thinking: string;
+	/** Signature for the thinking block (provider-specific) */
+	signature?: string;
+	/** Provider-native call ID for this reasoning block (if available) */
+	call_id?: string;
+	/** Structured reasoning details that can be replayed for tool-call continuation */
+	details?: unknown[];
+	/** Backward-compatible alias used by some internal processors */
+	summary?: unknown[];
+}
+
+/**
+ * Redacted thinking content block
+ */
+export interface RedactedThinkingContent {
+	type: "redacted_thinking";
+	/** Encrypted/redacted data */
+	data: string;
+	/** Provider-native call ID for this reasoning block (if available) */
+	call_id?: string;
+}
+
+/**
+ * Union of all content block types
+ */
+export type ContentBlock =
+	| TextContent
+	| ImageContent
+	| ToolUseContent
+	| ToolResultContent
+	| ThinkingContent
+	| FileContent
+	| RedactedThinkingContent;
+
+/**
+ * A single message in the conversation
+ */
+export interface Message {
+	/** Message role */
+	role: MessageRole;
+	/** Message content - can be a simple string or array of content blocks */
+	content: string | ContentBlock[];
+}
+
+/**
+ * Extended message with metadata (used for storage/history)
+ */
+export interface MessageWithMetadata extends Message {
+	/** Unique message ID */
+	id?: string;
+	/** Logical agent kind for persisted session/history consumers */
+	agent?: string;
+	/** Concrete session id that owns this persisted message */
+	sessionId?: string;
+	/** Additional message metadata for storage/history consumers */
+	metadata?: Record<string, unknown>;
+	/** Model info at the time of generation */
+	modelInfo?: {
+		id: string;
+		provider: string;
+		family?: string;
+	};
+	/** Token usage metrics */
+	metrics?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		cost?: number;
+	};
+	/** Timestamp of when the message was created */
+	ts?: number;
+}
+
+/**
+ * Tool definition for native tool calling
+ */
+export interface ToolDefinition {
+	/** Tool name */
+	name: string;
+	/** Tool description */
+	description: string;
+	/** JSON Schema for the tool's input parameters */
+	inputSchema: Record<string, unknown>;
+}
diff --git a/sdk/packages/shared/src/llms/model-info.ts b/sdk/packages/shared/src/llms/model-info.ts
new file mode 100644
index 0000000..947fda7
--- /dev/null
+++ b/sdk/packages/shared/src/llms/model-info.ts
@@ -0,0 +1,94 @@
+/**
+ * Model Information Types
+ *
+ * Zod schemas and inferred types for model capabilities, pricing,
+ * and metadata. These live in shared so that agent types can reference
+ * ModelInfo without depending on @cline/llms.
+ */
+
+import { z } from "zod";
+
+export const ApiFormatSchema = z.enum(["default", "openai-responses", "r1"]);
+
+export type ApiFormat = z.infer<typeof ApiFormatSchema>;
+
+export const ApiFormat = {
+	DEFAULT: "default" as const,
+	OPENAI_RESPONSES: "openai-responses" as const,
+	R1: "r1" as const,
+} as const;
+
+export const ModelCapabilitySchema = z.enum([
+	"images",
+	"tools",
+	"streaming",
+	"prompt-cache",
+	"reasoning",
+	"reasoning-effort",
+	"computer-use",
+	"global-endpoint",
+	"structured_output",
+	"temperature",
+	"files",
+]);
+
+export type ModelCapability = z.infer<typeof ModelCapabilitySchema>;
+
+export const ModelStatusSchema = z.enum([
+	"active",
+	"preview",
+	"deprecated",
+	"legacy",
+]);
+
+export type ModelStatus = z.infer<typeof ModelStatusSchema>;
+
+export const ModelPricingSchema = z.object({
+	input: z.number().optional(),
+	output: z.number().optional(),
+	cacheWrite: z.number().optional(),
+	cacheRead: z.number().optional(),
+});
+
+export type ModelPricing = z.infer<typeof ModelPricingSchema>;
+
+export const ThinkingConfigSchema = z.object({
+	maxBudget: z.number().optional(),
+	outputPrice: z.number().optional(),
+	thinkingLevel: z.enum(["low", "high"]).optional(),
+});
+
+export type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+
+export const ModelMetadataSchema = z
+	// Keep metadata open for catalog-defined facts while typing routing fields.
+	.object({
+		reasoningDefaultOn: z.boolean().optional(),
+	})
+	.catchall(z.unknown());
+
+export type ModelMetadata = z.infer<typeof ModelMetadataSchema>;
+
+export const ModelInfoSchema = z.object({
+	id: z.string(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	maxTokens: z.number().optional(),
+	contextWindow: z.number().optional(),
+	maxInputTokens: z.number().optional(),
+	capabilities: z.array(ModelCapabilitySchema).optional(),
+	apiFormat: ApiFormatSchema.optional(),
+	systemRole: z.enum(["system", "developer"]).optional(),
+	temperature: z.number().optional(),
+	pricing: ModelPricingSchema.optional(),
+	thinkingConfig: ThinkingConfigSchema.optional(),
+	status: ModelStatusSchema.optional(),
+	deprecationNotice: z.string().optional(),
+	replacedBy: z.string().optional(),
+	releaseDate: z.string().optional(),
+	deprecationDate: z.string().optional(),
+	family: z.string().optional(),
+	metadata: ModelMetadataSchema.optional(),
+});
+
+export type ModelInfo = z.infer<typeof ModelInfoSchema>;
diff --git a/sdk/packages/shared/src/llms/model-options.ts b/sdk/packages/shared/src/llms/model-options.ts
new file mode 100644
index 0000000..11e7a4c
--- /dev/null
+++ b/sdk/packages/shared/src/llms/model-options.ts
@@ -0,0 +1,25 @@
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function mergeModelOptions(
+	base: Record<string, unknown> | undefined,
+	next: Record<string, unknown>,
+): Record<string, unknown>;
+export function mergeModelOptions(
+	base: Record<string, unknown> | undefined,
+	next: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined;
+export function mergeModelOptions(
+	base: Record<string, unknown> | undefined,
+	next: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+	if (!base && !next) return undefined;
+	const baseMetadata = base?.metadata;
+	const nextMetadata = next?.metadata;
+	const merged = { ...(base ?? {}), ...(next ?? {}) };
+	if (isRecord(baseMetadata) && isRecord(nextMetadata)) {
+		merged.metadata = { ...baseMetadata, ...nextMetadata };
+	}
+	return merged;
+}
diff --git a/sdk/packages/shared/src/llms/reasoning-effort.ts b/sdk/packages/shared/src/llms/reasoning-effort.ts
new file mode 100644
index 0000000..1d16e69
--- /dev/null
+++ b/sdk/packages/shared/src/llms/reasoning-effort.ts
@@ -0,0 +1,73 @@
+export const REASONING_EFFORT_RATIOS = {
+	xhigh: 0.95,
+	high: 0.8,
+	medium: 0.5,
+	low: 0.2,
+	minimal: 0.1,
+	none: 0,
+} as const;
+
+export type ReasoningEffortValue = keyof typeof REASONING_EFFORT_RATIOS;
+export const DEFAULT_REASONING_EFFORT: ReasoningEffortValue | undefined =
+	undefined;
+
+export function resolveEffectiveReasoningEffort(
+	reasoningEffort?: string,
+	thinking?: boolean,
+): ReasoningEffortValue | undefined {
+	if (
+		typeof reasoningEffort === "string" &&
+		reasoningEffort.toLowerCase() in REASONING_EFFORT_RATIOS
+	) {
+		return reasoningEffort.toLowerCase() as ReasoningEffortValue;
+	}
+
+	return thinking ? DEFAULT_REASONING_EFFORT : undefined;
+}
+
+export function resolveReasoningEffortRatio(
+	effort?: string,
+	options?: { fallbackEffort?: ReasoningEffortValue },
+): number | undefined {
+	const normalizedEffort =
+		typeof effort === "string" ? effort.toLowerCase() : undefined;
+
+	if (normalizedEffort && normalizedEffort in REASONING_EFFORT_RATIOS) {
+		return REASONING_EFFORT_RATIOS[normalizedEffort as ReasoningEffortValue];
+	}
+
+	if (options?.fallbackEffort) {
+		return REASONING_EFFORT_RATIOS[options.fallbackEffort];
+	}
+
+	return undefined;
+}
+
+export function resolveReasoningBudgetFromRatio(options: {
+	effort?: string;
+	maxBudget: number;
+	scaleTokens?: number;
+	minimumBudget?: number;
+	fallbackEffort?: ReasoningEffortValue;
+}): number | undefined {
+	const ratio = resolveReasoningEffortRatio(options.effort, {
+		fallbackEffort: options.fallbackEffort,
+	});
+	if (ratio === undefined) {
+		return undefined;
+	}
+	if (ratio <= 0) {
+		return 0;
+	}
+
+	const minimumBudget = options.minimumBudget ?? 1;
+	if (options.maxBudget < minimumBudget) {
+		return undefined;
+	}
+
+	const scaleTokens = options.scaleTokens ?? options.maxBudget;
+	return Math.min(
+		Math.max(Math.floor(scaleTokens * ratio), minimumBudget),
+		options.maxBudget,
+	);
+}
diff --git a/sdk/packages/shared/src/llms/requests.ts b/sdk/packages/shared/src/llms/requests.ts
new file mode 100644
index 0000000..37cac54
--- /dev/null
+++ b/sdk/packages/shared/src/llms/requests.ts
@@ -0,0 +1,100 @@
+import type { ClientName } from "../extensions/context";
+
+export const DEFAULT_REQUEST_HEADERS: Record<string, string> = {
+	"HTTP-Referer": "https://cline.bot",
+	"X-Title": "Cline",
+	"X-IS-MULTIROOT": "false",
+	"X-CLIENT-TYPE": "cline-sdk",
+};
+
+function isClineBillingProvider(providerId: string): boolean {
+	return providerId === "cline" || providerId === "cline-pass";
+}
+
+function trimNonEmpty(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+
+function resolveSource(
+	source: string | undefined,
+	defaultSource: string,
+): string {
+	return trimNonEmpty(source) ?? defaultSource;
+}
+
+function resolveClineClientVersion(input: {
+	clientVersion?: string;
+	clientVersionHeaderFallback?: string;
+}): string {
+	return (
+		trimNonEmpty(input.clientVersion) ??
+		trimNonEmpty(input.clientVersionHeaderFallback) ??
+		"unknown"
+	);
+}
+
+function resolveOptionalHeader(value: string | undefined): string | undefined {
+	return trimNonEmpty(value);
+}
+
+export interface ClineClientRequestHeadersInput {
+	providerId: string;
+	sessionId: string;
+	source?: string;
+	defaultSource: string;
+	clientName?: ClientName;
+	clientVersion?: string;
+	clientVersionHeaderFallback?: string;
+	platform?: string;
+	platformVersion?: string;
+	isMultiRoot?: boolean;
+	coreVersion: string;
+}
+
+export function buildClineClientRequestHeaders(
+	input: ClineClientRequestHeadersInput,
+): Record<string, string> | undefined {
+	if (!isClineBillingProvider(input.providerId)) {
+		return undefined;
+	}
+	const source = resolveSource(input.source, input.defaultSource);
+	const clientType =
+		resolveOptionalHeader(input.clientName) ?? `cline-${source}`;
+	const clientVersion = resolveClineClientVersion(input);
+	const platform = resolveOptionalHeader(input.platform) ?? source;
+	const platformVersion =
+		resolveOptionalHeader(input.platformVersion) ?? clientVersion;
+	return {
+		...DEFAULT_REQUEST_HEADERS,
+		"User-Agent": `Cline/${clientVersion}`,
+		"X-IS-MULTIROOT": input.isMultiRoot === true ? "true" : "false",
+		"X-CLIENT-TYPE": clientType,
+		"X-CLIENT-VERSION": clientVersion,
+		"X-PLATFORM": platform,
+		"X-PLATFORM-VERSION": platformVersion,
+		"X-CORE-VERSION": input.coreVersion,
+		"X-Task-ID": input.sessionId,
+	};
+}
+
+export interface MergeClineClientRequestHeadersInput
+	extends ClineClientRequestHeadersInput {
+	headers: ReadonlyArray<Record<string, string> | undefined>;
+}
+
+export function mergeClineClientRequestHeaders(
+	input: MergeClineClientRequestHeadersInput,
+): Record<string, string> | undefined {
+	const requiredHeaders = buildClineClientRequestHeaders(input);
+	if (!requiredHeaders) {
+		return undefined;
+	}
+	return Object.assign({}, ...input.headers, requiredHeaders);
+}
+
+export function serializeAbortReason(reason: unknown): unknown {
+	return reason instanceof Error
+		? { name: reason.name, message: reason.message }
+		: reason;
+}
diff --git a/sdk/packages/shared/src/llms/tokens.ts b/sdk/packages/shared/src/llms/tokens.ts
new file mode 100644
index 0000000..49e232a
--- /dev/null
+++ b/sdk/packages/shared/src/llms/tokens.ts
@@ -0,0 +1,12 @@
+/**
+ * Conservative chars-per-token approximation used for compaction triggering
+ * and request-size diagnostics. Uses 3 chars/token (slightly over-counts vs
+ * the conventional 4) so trigger thresholds fire before provider rejection
+ * rather than after.
+ */
+
+export const CHARS_PER_TOKEN = 3;
+
+export function estimateTokens(chars: number): number {
+	return Math.max(1, Math.ceil(chars / CHARS_PER_TOKEN));
+}
diff --git a/sdk/packages/shared/src/llms/tools.ts b/sdk/packages/shared/src/llms/tools.ts
new file mode 100644
index 0000000..bf77948
--- /dev/null
+++ b/sdk/packages/shared/src/llms/tools.ts
@@ -0,0 +1,96 @@
+/**
+ * Shared tool policy and execution record types.
+ */
+
+import { z } from "zod";
+
+export interface ToolPolicy {
+	/**
+	 * Whether the tool can be executed at all.
+	 * @default true
+	 */
+	enabled?: boolean;
+	/**
+	 * Whether this tool can run without asking the client for approval.
+	 * @default true
+	 */
+	autoApprove?: boolean;
+}
+
+// =============================================================================
+// Tool Call Record
+// =============================================================================
+
+/**
+ * Record of a tool call execution
+ */
+export interface ToolCallRecord {
+	/** Unique identifier for this tool call */
+	id: string;
+	/** Name of the tool that was called */
+	name: string;
+	/** Input passed to the tool */
+	input: unknown;
+	/** Output returned from the tool (if successful) */
+	output: unknown;
+	/** Error message (if the tool failed) */
+	error?: string;
+	/** Time taken to execute the tool in milliseconds */
+	durationMs: number;
+	/** Timestamp when the tool call started */
+	startedAt: Date;
+	/** Timestamp when the tool call ended */
+	endedAt: Date;
+}
+
+export interface ToolApprovalRequest {
+	/**
+	 * Core/hub runtime session identifier.
+	 *
+	 * This is the routing and lifecycle id for the task/session that owns the
+	 * tool call. Hosts and hub transports use it to deliver approval events to
+	 * clients subscribed to that session and to correlate approval responses
+	 * with the pending runtime session. It should not be used as the transcript
+	 * id for model history.
+	 */
+	sessionId: string;
+	/**
+	 * Agent instance identifier.
+	 *
+	 * This identifies the lead or delegated agent that requested the tool call.
+	 * It is used for attribution in approval prompts, events, telemetry, and
+	 * team/sub-agent flows. It is not a hub routing key and should not be used
+	 * to find the owning runtime session.
+	 */
+	agentId: string;
+	/**
+	 * Agent conversation/transcript identifier.
+	 *
+	 * This identifies the model conversation that produced the tool call. Tools,
+	 * hooks, telemetry, and persisted session metadata use it to correlate work
+	 * with the agent's message history. It is contextual data, not the hub event
+	 * routing key.
+	 */
+	conversationId: string;
+	iteration: number;
+	toolCallId: string;
+	toolName: string;
+	input: unknown;
+	policy: ToolPolicy;
+}
+
+export interface ToolApprovalResult {
+	approved: boolean;
+	reason?: string;
+}
+
+export const ToolCallRecordSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	input: z.unknown(),
+	output: z.unknown(),
+	error: z.string().optional(),
+	durationMs: z.number(),
+	startedAt: z.date(),
+	endedAt: z.date(),
+});
diff --git a/sdk/packages/shared/src/logging/logger.ts b/sdk/packages/shared/src/logging/logger.ts
new file mode 100644
index 0000000..26c757b
--- /dev/null
+++ b/sdk/packages/shared/src/logging/logger.ts
@@ -0,0 +1,45 @@
+/**
+ * Cross-package logging surface for hosts that inject their own logger (for example `pino` or the VS Code API).
+ *
+ * {@link BasicLogger.debug} is for verbose diagnostics (hosts typically gate this behind a debug log level).
+ * {@link BasicLogger.log} is the primary channel for operational messages that are not errors.
+ * {@link BasicLogger.error} is optional; when omitted, hosts may route failures through {@link BasicLogger.log}
+ * with {@link BasicLogMetadata.severity} `"error"` or handle errors elsewhere.
+ *
+ * Use {@link noopBasicLogger} when you need a fully-defined no-op implementation.
+ */
+
+/**
+ * Optional structured fields used across the SDK and recommended for host log backends.
+ * Callers may add other keys freely; these names are the shared convention for cross-component queries.
+ */
+export interface BasicLogMetadata extends Record<string, unknown> {
+	sessionId?: string;
+	runId?: string;
+	providerId?: string;
+	toolName?: string;
+	durationMs?: number;
+	/**
+	 * When using {@link BasicLogger.log}, disambiguates severity for backends that map a single `log`
+	 * method onto multiple output levels (for example Pino `info` vs `warn`).
+	 */
+	severity?: "info" | "warn" | "error";
+}
+
+export interface BasicLogger {
+	/** Verbose diagnostics; hosts should no-op or filter when not in debug mode. */
+	debug: (message: string, metadata?: BasicLogMetadata) => void;
+	/** Operational messages (replaces former `info` / non-error `warn` split). */
+	log: (message: string, metadata?: BasicLogMetadata) => void;
+	error?: (
+		message: string,
+		metadata?: BasicLogMetadata & { error?: unknown },
+	) => void;
+}
+
+/** All levels implemented as no-ops; safe default when no logger is injected. */
+export const noopBasicLogger: BasicLogger = {
+	debug: () => {},
+	log: () => {},
+	error: () => {},
+};
diff --git a/sdk/packages/shared/src/parse/error.ts b/sdk/packages/shared/src/parse/error.ts
new file mode 100644
index 0000000..0f532c6
--- /dev/null
+++ b/sdk/packages/shared/src/parse/error.ts
@@ -0,0 +1,18 @@
+export function getErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+export function getErrorCode(error: unknown): string {
+	if (
+		error &&
+		typeof error === "object" &&
+		"code" in error &&
+		typeof error.code === "string"
+	) {
+		return error.code;
+	}
+	return "";
+}
diff --git a/sdk/packages/shared/src/parse/headers/utils.ts b/sdk/packages/shared/src/parse/headers/utils.ts
new file mode 100644
index 0000000..f3ac518
--- /dev/null
+++ b/sdk/packages/shared/src/parse/headers/utils.ts
@@ -0,0 +1,28 @@
+export function parseKeyPairsIntoRecord(
+	value?: string,
+): Record<string, string> {
+	const result: Record<string, string> = {};
+
+	if (!value) {
+		return result;
+	}
+
+	try {
+		value.split(",").forEach((entry) => {
+			const separatorIndex = entry.indexOf("=");
+			if (separatorIndex <= 0) return;
+
+			// From the beginning to the equal sign is the key, from the equal sign to the end is the value
+			const key = decodeURIComponent(entry.substring(0, separatorIndex).trim());
+			const value = decodeURIComponent(
+				entry.substring(separatorIndex + 1).trim(),
+			);
+
+			if (!key || !value) return;
+
+			result[key] = value;
+		});
+	} catch {}
+
+	return result;
+}
diff --git a/sdk/packages/shared/src/parse/json.test.ts b/sdk/packages/shared/src/parse/json.test.ts
new file mode 100644
index 0000000..74408de
--- /dev/null
+++ b/sdk/packages/shared/src/parse/json.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { normalizeJsonLikeStringsForSchema, parseJsonStream } from "./json";
+
+describe("parseJsonStream", () => {
+	it("repairs a bare object value into a JSON string", () => {
+		const input =
+			'{"commands": find /Users/beatrix/dev/sdk -name "user-instruction-config-loader.ts" -o -name "rules.ts" | head -20}';
+
+		expect(parseJsonStream(input)).toEqual({
+			commands:
+				'find /Users/beatrix/dev/sdk -name "user-instruction-config-loader.ts" -o -name "rules.ts" | head -20',
+		});
+	});
+});
+
+describe("normalizeJsonLikeStringsForSchema", () => {
+	it("parses JSON strings when the schema expects arrays", () => {
+		expect(
+			normalizeJsonLikeStringsForSchema(
+				{ commands: JSON.stringify(["git status", "bun test"]) },
+				{
+					type: "object",
+					properties: {
+						commands: {
+							type: "array",
+							items: { type: "string" },
+						},
+					},
+				},
+			),
+		).toEqual({ commands: ["git status", "bun test"] });
+	});
+
+	it("preserves JSON-looking strings when the schema expects strings", () => {
+		const text = JSON.stringify({ keep: "as text" });
+
+		expect(
+			normalizeJsonLikeStringsForSchema(
+				{ text },
+				{
+					type: "object",
+					properties: {
+						text: { type: "string" },
+					},
+				},
+			),
+		).toEqual({ text });
+	});
+
+	it("normalizes nested array items using item schemas", () => {
+		expect(
+			normalizeJsonLikeStringsForSchema(
+				{
+					steps: [
+						{ args: JSON.stringify(["--version"]) },
+						{ args: JSON.stringify(["test"]) },
+					],
+				},
+				{
+					type: "object",
+					properties: {
+						steps: {
+							type: "array",
+							items: {
+								type: "object",
+								properties: {
+									args: {
+										type: "array",
+										items: { type: "string" },
+									},
+								},
+							},
+						},
+					},
+				},
+			),
+		).toEqual({
+			steps: [{ args: ["--version"] }, { args: ["test"] }],
+		});
+	});
+});
diff --git a/sdk/packages/shared/src/parse/json.ts b/sdk/packages/shared/src/parse/json.ts
new file mode 100644
index 0000000..0010627
--- /dev/null
+++ b/sdk/packages/shared/src/parse/json.ts
@@ -0,0 +1,201 @@
+import { jsonrepair } from "jsonrepair";
+
+const BARE_OBJECT_RE = /^\{\s*"([A-Za-z0-9_.$-]+)"\s*:\s*([\s\S]+?)\s*\}$/;
+/**
+ * Attempt to repair `{"key": some unquoted value}` by wrapping the value in quotes.
+ * Returns undefined when the input doesn't match or the value is already a JSON token.
+ */
+function repairBareObjectValue(
+	text: string,
+): Record<string, string> | undefined {
+	const match = text.match(BARE_OBJECT_RE);
+	if (!match) return undefined;
+
+	const [, key, rawValue] = match;
+	const value = rawValue.trim();
+	if (!value) return undefined;
+
+	// Skip values that are already valid JSON tokens
+	const ch = value[0];
+	if (
+		ch === '"' ||
+		ch === "{" ||
+		ch === "[" ||
+		value === "true" ||
+		value === "false" ||
+		value === "null" ||
+		Number.isFinite(Number(value))
+	) {
+		return undefined;
+	}
+
+	return JSON.parse(`{"${key}":${JSON.stringify(value)}}`);
+}
+
+/** Parse strategies applied in order — first success wins. */
+const strategies: Array<(text: string) => unknown> = [
+	(text) => JSON.parse(text),
+	(text) => JSON.parse(jsonrepair(text)),
+	repairBareObjectValue,
+];
+
+export function parseJsonStream(input: unknown): unknown {
+	if (typeof input !== "string") return input;
+
+	const text = input.trimStart();
+	if (text[0] !== "{" && text[0] !== "[") return input;
+
+	for (const strategy of strategies) {
+		try {
+			const result = strategy(text);
+			if (result !== undefined) return result;
+		} catch {
+			// strategy failed — try next
+		}
+	}
+	return input;
+}
+
+export function safeJsonStringify(input: unknown): string {
+	const seen = new WeakSet<object>();
+
+	try {
+		const result = JSON.stringify(input, (_key, value) => {
+			if (typeof value === "bigint") return value.toString();
+
+			if (value && typeof value === "object") {
+				if (seen.has(value as object)) return "[Circular]";
+				seen.add(value as object);
+			}
+
+			return value;
+		});
+
+		return result ?? "null";
+	} catch {
+		return String(input);
+	}
+}
+
+export function safeJsonParse<T>(raw: string): T | undefined {
+	try {
+		return JSON.parse(raw) as T;
+	} catch {
+		return undefined;
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function schemaTypes(schema: Record<string, unknown>): string[] {
+	const type = schema.type;
+	if (typeof type === "string") {
+		return [type];
+	}
+	return Array.isArray(type)
+		? type.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+function schemaAcceptsKind(
+	schema: Record<string, unknown>,
+	kind: "array" | "object",
+): boolean {
+	const types = schemaTypes(schema);
+	if (types.includes(kind)) {
+		return true;
+	}
+
+	for (const key of ["anyOf", "oneOf", "allOf"] as const) {
+		const branches = schema[key];
+		if (
+			Array.isArray(branches) &&
+			branches.some(
+				(branch) => isRecord(branch) && schemaAcceptsKind(branch, kind),
+			)
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function parseJsonStringForSchema(
+	value: unknown,
+	schema: Record<string, unknown>,
+) {
+	if (typeof value !== "string") {
+		return value;
+	}
+
+	const trimmed = value.trim();
+	const expectsArray = schemaAcceptsKind(schema, "array");
+	const expectsObject = schemaAcceptsKind(schema, "object");
+	if (
+		(!expectsArray || !trimmed.startsWith("[")) &&
+		(!expectsObject || !trimmed.startsWith("{"))
+	) {
+		return value;
+	}
+
+	try {
+		const parsed = JSON.parse(trimmed) as unknown;
+		if (Array.isArray(parsed)) {
+			return expectsArray ? parsed : value;
+		}
+		if (isRecord(parsed)) {
+			return expectsObject ? parsed : value;
+		}
+		return value;
+	} catch {
+		return value;
+	}
+}
+
+export function normalizeJsonLikeStringsForSchema(
+	input: unknown,
+	schema: Record<string, unknown>,
+): unknown {
+	const value = parseJsonStringForSchema(input, schema);
+
+	if (Array.isArray(value)) {
+		const items = schema.items;
+		if (!isRecord(items)) {
+			return value;
+		}
+		let changed = false;
+		const normalized = value.map((item) => {
+			const next = normalizeJsonLikeStringsForSchema(item, items);
+			changed ||= next !== item;
+			return next;
+		});
+		return changed ? normalized : value;
+	}
+
+	if (!isRecord(value)) {
+		return value;
+	}
+
+	const properties = schema.properties;
+	if (!isRecord(properties)) {
+		return value;
+	}
+
+	let changed = false;
+	const normalized: Record<string, unknown> = { ...value };
+	for (const [key, propertySchema] of Object.entries(properties)) {
+		if (!(key in value) || !isRecord(propertySchema)) {
+			continue;
+		}
+		const next = normalizeJsonLikeStringsForSchema(value[key], propertySchema);
+		if (next !== value[key]) {
+			normalized[key] = next;
+			changed = true;
+		}
+	}
+
+	return changed ? normalized : value;
+}
diff --git a/sdk/packages/shared/src/parse/object.test.ts b/sdk/packages/shared/src/parse/object.test.ts
new file mode 100644
index 0000000..e1dd3d1
--- /dev/null
+++ b/sdk/packages/shared/src/parse/object.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { omitUndefinedValues } from "./object";
+
+describe("omitUndefinedValues", () => {
+	it("removes undefined properties and preserves other falsy values", () => {
+		expect(
+			omitUndefinedValues({
+				sessionId: "session-id",
+				conversationId: undefined,
+				count: 0,
+				enabled: false,
+				empty: "",
+				nullable: null,
+			}),
+		).toEqual({
+			sessionId: "session-id",
+			count: 0,
+			enabled: false,
+			empty: "",
+			nullable: null,
+		});
+	});
+});
diff --git a/sdk/packages/shared/src/parse/object.ts b/sdk/packages/shared/src/parse/object.ts
new file mode 100644
index 0000000..f655a43
--- /dev/null
+++ b/sdk/packages/shared/src/parse/object.ts
@@ -0,0 +1,24 @@
+type KeysWithUndefinedValues<T extends Record<string, unknown>> = {
+	[K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+
+type KeysWithoutUndefinedValues<T extends Record<string, unknown>> = Exclude<
+	keyof T,
+	KeysWithUndefinedValues<T>
+>;
+
+export type OmitUndefinedValues<T extends Record<string, unknown>> = Pick<
+	T,
+	KeysWithoutUndefinedValues<T>
+> &
+	Partial<{
+		[K in KeysWithUndefinedValues<T>]: Exclude<T[K], undefined>;
+	}>;
+
+export function omitUndefinedValues<T extends Record<string, unknown>>(
+	value: T,
+): OmitUndefinedValues<T> {
+	return Object.fromEntries(
+		Object.entries(value).filter(([, entry]) => entry !== undefined),
+	) as OmitUndefinedValues<T>;
+}
diff --git a/sdk/packages/shared/src/parse/shell.test.ts b/sdk/packages/shared/src/parse/shell.test.ts
new file mode 100644
index 0000000..c63af6c
--- /dev/null
+++ b/sdk/packages/shared/src/parse/shell.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultShell, getShellArgs } from "./shell";
+
+describe("shell helpers", () => {
+	it("selects PowerShell on Windows and bash elsewhere", () => {
+		expect(getDefaultShell("win32")).toBe("powershell");
+		expect(getDefaultShell("darwin")).toBe("/bin/bash");
+		expect(getDefaultShell("linux")).toBe("/bin/bash");
+	});
+
+	it("uses PowerShell flags for PowerShell executables", () => {
+		expect(getShellArgs("powershell", "Write-Output 'hi'")).toEqual([
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			"Write-Output 'hi'",
+		]);
+		expect(
+			getShellArgs(
+				"C:\\Program Files\\PowerShell\\7\\pwsh.exe",
+				"Write-Output 'hi'",
+			),
+		).toEqual([
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			"Write-Output 'hi'",
+		]);
+	});
+
+	it("uses cmd flags for cmd.exe", () => {
+		expect(getShellArgs("cmd.exe", "echo hello")).toEqual([
+			"/d",
+			"/s",
+			"/c",
+			"echo hello",
+		]);
+	});
+
+	it("uses POSIX flags for bash-like shells", () => {
+		expect(getShellArgs("/bin/bash", "echo hi")).toEqual(["-c", "echo hi"]);
+		expect(
+			getShellArgs("C:\\Program Files\\Git\\bin\\bash.exe", "echo hi"),
+		).toEqual(["-c", "echo hi"]);
+	});
+});
diff --git a/sdk/packages/shared/src/parse/shell.ts b/sdk/packages/shared/src/parse/shell.ts
new file mode 100644
index 0000000..863b028
--- /dev/null
+++ b/sdk/packages/shared/src/parse/shell.ts
@@ -0,0 +1,32 @@
+function normalizeShellName(shell: string): string {
+	const normalizedPath = shell.replaceAll("\\", "/");
+	const lastSeparatorIndex = normalizedPath.lastIndexOf("/");
+	const baseName =
+		lastSeparatorIndex >= 0
+			? normalizedPath.slice(lastSeparatorIndex + 1)
+			: normalizedPath;
+	return baseName.toLowerCase();
+}
+
+export function getDefaultShell(platform: string): string {
+	return platform === "win32" ? "powershell" : "/bin/bash";
+}
+
+export function getShellArgs(shell: string, command: string): string[] {
+	const shellName = normalizeShellName(shell);
+
+	if (
+		shellName === "powershell" ||
+		shellName === "powershell.exe" ||
+		shellName === "pwsh" ||
+		shellName === "pwsh.exe"
+	) {
+		return ["-NoProfile", "-NonInteractive", "-Command", command];
+	}
+
+	if (shellName === "cmd" || shellName === "cmd.exe") {
+		return ["/d", "/s", "/c", command];
+	}
+
+	return ["-c", command];
+}
diff --git a/sdk/packages/shared/src/parse/string.test.ts b/sdk/packages/shared/src/parse/string.test.ts
new file mode 100644
index 0000000..b6ffba8
--- /dev/null
+++ b/sdk/packages/shared/src/parse/string.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { trimNonEmpty } from "./string";
+
+describe("trimNonEmpty", () => {
+	it("returns trimmed strings and omits empty values", () => {
+		expect(trimNonEmpty("  session-id  ")).toBe("session-id");
+		expect(trimNonEmpty("   ")).toBeUndefined();
+		expect(trimNonEmpty("")).toBeUndefined();
+		expect(trimNonEmpty(undefined)).toBeUndefined();
+		expect(trimNonEmpty(null)).toBeUndefined();
+	});
+});
diff --git a/sdk/packages/shared/src/parse/string.ts b/sdk/packages/shared/src/parse/string.ts
new file mode 100644
index 0000000..f6bb256
--- /dev/null
+++ b/sdk/packages/shared/src/parse/string.ts
@@ -0,0 +1,36 @@
+export function sanitizeFileName(value: string): string {
+	return value.toLowerCase().replace(/[^\w.-]+/g, "_");
+}
+
+export function trimNonEmpty(
+	value: string | null | undefined,
+): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function truncateStr(str: string, maxLen: number): string {
+	if (str.length <= maxLen) return str;
+	return `${str.slice(0, maxLen - 1)}…`;
+}
+
+export function truncateSplit(
+	str?: string,
+	splitBy = "/",
+	maxLen = 100,
+): string {
+	if (!str || str.length <= maxLen) return str || "";
+	const prefix = str
+		.split(splitBy)
+		?.shift()
+		?.trim()
+		?.slice(0, maxLen - 1);
+	return prefix ? `${prefix}…` : truncateStr(str, maxLen);
+}
+
+export function maskSecret(value: string): string {
+	if (value.length <= 8) {
+		return "****";
+	}
+	return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
diff --git a/sdk/packages/shared/src/parse/time.ts b/sdk/packages/shared/src/parse/time.ts
new file mode 100644
index 0000000..e1d4c2d
--- /dev/null
+++ b/sdk/packages/shared/src/parse/time.ts
@@ -0,0 +1,39 @@
+/**
+ * Parses a date string and returns a human-readable format.
+ * If the input is invalid, it returns the original string or a placeholder.
+ *
+ * @param dateStr - The date string to parse.
+ * @returns A human-readable date string or the original input if invalid.
+ */
+export function formatHumanReadableDate(dateStr?: string): string {
+	if (!dateStr) return "(unknown-date)";
+	const date = new Date(dateStr);
+	if (Number.isNaN(date.getTime())) return dateStr;
+	return date.toLocaleString("en-US", {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric",
+		hour12: true,
+	});
+}
+
+export function formatUptime(ms: number): string {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+	const days = Math.floor(totalSeconds / 86_400);
+	const hours = Math.floor((totalSeconds % 86_400) / 3_600);
+	const minutes = Math.floor((totalSeconds % 3_600) / 60);
+	const seconds = totalSeconds % 60;
+	if (days > 0) {
+		return `${days}d ${hours}h`;
+	}
+	if (hours > 0) {
+		return `${hours}h ${minutes}m`;
+	}
+	if (minutes > 0) {
+		return `${minutes}m ${seconds}s`;
+	}
+	return `${seconds}s`;
+}
diff --git a/sdk/packages/shared/src/parse/zod.ts b/sdk/packages/shared/src/parse/zod.ts
new file mode 100644
index 0000000..5e95f49
--- /dev/null
+++ b/sdk/packages/shared/src/parse/zod.ts
@@ -0,0 +1,23 @@
+/**
+ * Zod Utilities
+ *
+ * Helper functions for working with Zod schemas.
+ */
+
+import { z } from "zod";
+
+/**
+ * Validate input using a Zod schema
+ * Throws a formatted error if validation fails
+ */
+export function validateWithZod<T>(schema: z.ZodType<T>, input: unknown): T {
+	const result = schema.safeParse(input);
+	if (!result.success) {
+		throw new Error(z.prettifyError(result.error));
+	}
+	return result.data;
+}
+
+export function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown> {
+	return z.toJSONSchema(schema);
+}
diff --git a/sdk/packages/shared/src/prompt/cline.ts b/sdk/packages/shared/src/prompt/cline.ts
new file mode 100644
index 0000000..4c046c9
--- /dev/null
+++ b/sdk/packages/shared/src/prompt/cline.ts
@@ -0,0 +1,118 @@
+import type { WorkspaceContext } from "../extensions/context";
+import { isClineProvider } from "../providers/utils";
+import type { WorkspaceInfo } from "../session/workspace";
+import {
+	DEFAULT_CLINE_SYSTEM_PROMPT,
+	YOLO_CLINE_SYSTEM_PROMPT,
+} from "./system";
+
+const WORKSPACE_CONFIGURATION_MARKER = "# Workspace Configuration";
+
+export function processWorkspaceInfo(info: WorkspaceInfo): string {
+	return JSON.stringify(
+		{
+			workspaces: {
+				[info.rootPath]: {
+					hint: info.hint,
+					associatedRemoteUrls: info.associatedRemoteUrls,
+					latestGitCommitHash: info.latestGitCommitHash,
+					latestGitBranchName: info.latestGitBranchName,
+				},
+			},
+		},
+		null,
+		2,
+	);
+}
+
+function buildWorkspaceMetadata(
+	rootPath: string,
+	workspaceName?: string,
+	metadata?: string,
+): string {
+	if (metadata?.trim()?.includes(WORKSPACE_CONFIGURATION_MARKER)) {
+		return metadata.trim();
+	}
+	const body =
+		metadata ||
+		JSON.stringify(
+			{
+				workspaces: {
+					[rootPath]: {
+						hint: workspaceName || rootPath.split("/").at(-1) || rootPath,
+					},
+				},
+			},
+			null,
+			2,
+		);
+	return `\n${WORKSPACE_CONFIGURATION_MARKER}\n${body}`;
+}
+
+/**
+ * Options for building the Cline system prompt.
+ *
+ * Extends WorkspaceContext so callers can spread an ExtensionContext.workspace
+ * directly. `workspaceRoot` is accepted as an alias for `rootPath` to support
+ * existing call sites that set it explicitly.
+ */
+export interface ClineSystemPromptOptions
+	extends Omit<WorkspaceContext, "rootPath"> {
+	/**
+	 * Workspace root path. Accepts either `rootPath` (from WorkspaceContext/WorkspaceInfo)
+	 * or `workspaceRoot` (legacy alias) — whichever is provided will be used.
+	 */
+	rootPath?: string;
+	/** Alias for rootPath — kept for backwards compatibility with existing call sites */
+	workspaceRoot?: string;
+	/** Per-request system prompt override */
+	overridePrompt?: string;
+	/** Provider ID — used to gate Cline-specific metadata injection */
+	providerId?: string;
+}
+
+export function buildClineSystemPrompt(
+	options: ClineSystemPromptOptions,
+): string {
+	const {
+		ide = "Terminal Shell",
+		mode,
+		platform = "unknown",
+		workspaceName,
+		metadata,
+		rules,
+		overridePrompt,
+		providerId,
+	} = options;
+	const workspaceRoot = options.workspaceRoot ?? options.rootPath ?? "";
+	const isCline = isClineProvider(providerId || "");
+
+	if (overridePrompt?.trim()) {
+		const trimmed = overridePrompt.trim();
+		if (
+			isCline &&
+			metadata?.trim() &&
+			!trimmed.includes(WORKSPACE_CONFIGURATION_MARKER)
+		) {
+			return `${trimmed}\n\n${buildWorkspaceMetadata(workspaceRoot, workspaceName, metadata)}`.trim();
+		}
+		return trimmed;
+	}
+
+	const basePrompt =
+		mode === "yolo" ? YOLO_CLINE_SYSTEM_PROMPT : DEFAULT_CLINE_SYSTEM_PROMPT;
+
+	return basePrompt
+		.replace("{{PLATFORM_NAME}}", platform)
+		.replace("{{CWD}}", workspaceRoot)
+		.replace("{{CURRENT_DATE}}", new Date().toLocaleDateString())
+		.replace("{{IDE_NAME}}", ide)
+		.replace(
+			"{{CLINE_METADATA}}",
+			isCline
+				? buildWorkspaceMetadata(workspaceRoot, workspaceName, metadata)
+				: "",
+		)
+		.replace("{{CLINE_RULES}}", rules || "")
+		.trim();
+}
diff --git a/sdk/packages/shared/src/prompt/format.test.ts b/sdk/packages/shared/src/prompt/format.test.ts
new file mode 100644
index 0000000..4692c29
--- /dev/null
+++ b/sdk/packages/shared/src/prompt/format.test.ts
@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import {
+	formatDisplayUserInput,
+	formatModeSwitchNotice,
+	formatUserCommandBlock,
+	formatUserInputBlock,
+	normalizeUserInput,
+	parseUserCommandEnvelope,
+	parseUserInputMode,
+	stripModeNotices,
+} from "./format";
+
+describe("prompt format helpers", () => {
+	it("parses a user command wrapper", () => {
+		expect(
+			parseUserCommandEnvelope(
+				'<user_command slash="team">spawn a team of agents for the following task: inspect rpc startup</user_command>',
+			),
+		).toEqual({
+			slash: "team",
+			content:
+				"spawn a team of agents for the following task: inspect rpc startup",
+		});
+	});
+
+	it("normalizes wrapped user command content for model input", () => {
+		expect(
+			normalizeUserInput(
+				'<user_command slash="team">spawn a team of agents for the following task: inspect rpc startup</user_command>',
+			),
+		).toBe(
+			"spawn a team of agents for the following task: inspect rpc startup",
+		);
+	});
+
+	it("formats wrapped team commands for display", () => {
+		const wrapped = formatUserCommandBlock(
+			"spawn a team of agents for the following task: inspect rpc startup",
+			"team",
+		);
+		expect(formatDisplayUserInput(wrapped)).toBe("/team inspect rpc startup");
+	});
+
+	it("parses the mode attribute from a user_input wrapper", () => {
+		expect(parseUserInputMode(formatUserInputBlock("hello", "plan"))).toBe(
+			"plan",
+		);
+		expect(parseUserInputMode(formatUserInputBlock("hello", "act"))).toBe(
+			"act",
+		);
+	});
+
+	it("parses the mode when a mode notice precedes the wrapper", () => {
+		const input = `${formatModeSwitchNotice("act", "plan")}${formatUserInputBlock("hello", "plan")}`;
+		expect(parseUserInputMode(input)).toBe("plan");
+	});
+
+	it("returns undefined for unwrapped or unknown-mode input", () => {
+		expect(parseUserInputMode("plain text")).toBeUndefined();
+		expect(parseUserInputMode(undefined)).toBeUndefined();
+		expect(
+			parseUserInputMode('<user_input mode="warp">hello</user_input>'),
+		).toBeUndefined();
+	});
+
+	it("formats a mode switch notice", () => {
+		expect(formatModeSwitchNotice("plan", "act")).toBe(
+			"<mode_notice>The user switched from plan mode to act mode before sending this message.</mode_notice>",
+		);
+	});
+
+	it("hides mode switch notices from displayed user input", () => {
+		const wrapped = formatUserInputBlock(
+			`${formatModeSwitchNotice("act", "plan")}\nhow should we refactor this?`,
+			"plan",
+		);
+		expect(formatDisplayUserInput(wrapped)).toBe(
+			"how should we refactor this?",
+		);
+	});
+
+	it("keeps mode switch notices when normalizing outbound prompts", () => {
+		// prepareTurnInput sanitizes prompts with normalizeUserInput before the
+		// host wraps them; stripping notices here would delete the switch
+		// signal before the model ever sees it.
+		const prompt = `${formatModeSwitchNotice("plan", "act")}\ndo it`;
+		expect(normalizeUserInput(prompt)).toBe(prompt);
+	});
+
+	it("removes every mode notice and leaves unclosed ones intact", () => {
+		expect(
+			stripModeNotices(
+				"<mode_notice>a</mode_notice>hello<mode_notice>b</mode_notice> there",
+			),
+		).toBe("hello there");
+		expect(stripModeNotices("<mode_notice>dangling")).toBe(
+			"<mode_notice>dangling",
+		);
+	});
+
+	it("strips adversarial repeated open tags in linear time", () => {
+		// Regression guard for CodeQL js/polynomial-redos: many unmatched
+		// opening tags must not trigger quadratic rescanning.
+		const hostile = "<mode_notice>".repeat(50_000);
+		const started = performance.now();
+		const result = stripModeNotices(hostile);
+		expect(performance.now() - started).toBeLessThan(1_000);
+		expect(result).toBe(hostile);
+	});
+});
diff --git a/sdk/packages/shared/src/prompt/format.ts b/sdk/packages/shared/src/prompt/format.ts
new file mode 100644
index 0000000..bda36c7
--- /dev/null
+++ b/sdk/packages/shared/src/prompt/format.ts
@@ -0,0 +1,162 @@
+export function formatFileContentBlock(path: string, content: string): string {
+	return `<file_content path="${path}">\n${content}\n</file_content>`;
+}
+
+export function formatUserInputBlock(
+	input: string,
+	mode: "act" | "plan" | "yolo" = "act",
+): string {
+	return `<user_input mode="${mode}">${input}</user_input>`;
+}
+
+export function formatUserCommandBlock(input: string, slash: string): string {
+	return `<user_command slash="${slash}">${input}</user_command>`;
+}
+
+// Mirrors exactly what formatUserInputBlock writes (lowercase tag, lowercase
+// mode values), but searches rather than anchors: persisted user content can
+// carry prepended <mode_notice> elements or trailing attachment blocks
+// around the wrapper.
+const USER_INPUT_MODE_RE = /<user_input\b[^>]*\bmode="(act|plan|yolo)"/;
+
+/**
+ * Recovers the agent mode a persisted user message was sent in from its
+ * <user_input mode="..."> wrapper. Returns undefined when the input isn't
+ * wrapped (plain text, user_command envelopes, older transcripts).
+ */
+export function parseUserInputMode(
+	input?: string,
+): "act" | "plan" | "yolo" | undefined {
+	const match = USER_INPUT_MODE_RE.exec(input ?? "");
+	return match ? (match[1] as "act" | "plan" | "yolo") : undefined;
+}
+
+/**
+ * Marks the exact point in the conversation where the user switched between
+ * plan and act modes. Prepended to the first user message sent after the
+ * switch. It survives normalizeUserInput (so the outbound sanitize in
+ * prepareTurnInput delivers it to the model) and is hidden from transcript
+ * display by stripModeNotices at display boundaries.
+ */
+export function formatModeSwitchNotice(
+	from: "act" | "plan",
+	to: "act" | "plan",
+): string {
+	return `<mode_notice>The user switched from ${from} mode to ${to} mode before sending this message.</mode_notice>`;
+}
+
+export type UserCommandEnvelope = {
+	slash: string;
+	content: string;
+};
+
+function extractFullTagContent(
+	input: string,
+	tag: string,
+): { attrs: string; content: string } | undefined {
+	const trimmed = input.trim();
+	const match = new RegExp(
+		`^<${tag}\\b([^>]*)>([\\s\\S]*?)<\\/${tag}>$`,
+		"i",
+	).exec(trimmed);
+	if (!match) {
+		return undefined;
+	}
+	return {
+		attrs: match[1] ?? "",
+		content: match[2] ?? "",
+	};
+}
+
+function readAttribute(attrs: string, key: string): string | undefined {
+	const match = new RegExp(`${key}="([^"]+)"`, "i").exec(attrs);
+	return match?.[1]?.trim() || undefined;
+}
+
+export function parseUserCommandEnvelope(
+	input?: string,
+): UserCommandEnvelope | undefined {
+	if (!input?.trim()) {
+		return undefined;
+	}
+	const extracted = extractFullTagContent(input, "user_command");
+	if (!extracted) {
+		return undefined;
+	}
+	const slash = readAttribute(extracted.attrs, "slash");
+	if (!slash) {
+		return undefined;
+	}
+	return {
+		slash,
+		content: extracted.content.trim(),
+	};
+}
+
+export function normalizeUserInput(input?: string): string {
+	if (!input?.trim()) return "";
+	let next = input.trim();
+	for (const tag of ["user_input", "user_command"] as const) {
+		const extracted = xmlTagsRemoval(next, tag);
+		next = (
+			extracted !== next
+				? extracted
+				: next.replace(new RegExp(`<${tag}[^>]*>`, "g"), "")
+		).trim();
+	}
+	return next;
+}
+
+/**
+ * Removes runtime-generated <mode_notice> elements (content included): they
+ * are not user-typed text and must not render as such. Deliberately NOT part
+ * of normalizeUserInput -- that function also sanitizes outbound prompts
+ * before the host wraps them (prepareTurnInput), and stripping there deletes
+ * the notice before the model ever sees it.
+ */
+export function stripModeNotices(input?: string): string {
+	if (!input?.trim()) return "";
+	return removeTagElements(input, "mode_notice").trim();
+}
+
+// indexOf-based rather than a regex: a lazy dot-all pattern re-scans to the
+// end of the string from every unmatched opening tag, which is polynomial on
+// adversarial transcript content (CodeQL js/polynomial-redos).
+function removeTagElements(input: string, tag: string): string {
+	const open = `<${tag}>`;
+	const close = `</${tag}>`;
+	let result = input;
+	let start = result.indexOf(open);
+	while (start !== -1) {
+		const end = result.indexOf(close, start + open.length);
+		if (end === -1) {
+			break;
+		}
+		result = result.slice(0, start) + result.slice(end + close.length);
+		start = result.indexOf(open, start);
+	}
+	return result;
+}
+
+export function formatDisplayUserInput(input?: string): string {
+	const normalized = stripModeNotices(normalizeUserInput(input));
+	const envelope = parseUserCommandEnvelope(input);
+	if (!envelope) {
+		return normalized;
+	}
+	if (envelope.slash.toLowerCase() === "team") {
+		const prefix = "spawn a team of agents for the following task:";
+		const stripped = normalized.toLowerCase().startsWith(prefix)
+			? normalized.slice(prefix.length).trim()
+			: normalized;
+		return stripped ? `/team ${stripped}` : "/team";
+	}
+	return normalized ? `/${envelope.slash} ${normalized}` : `/${envelope.slash}`;
+}
+
+export function xmlTagsRemoval(input?: string, tag?: string): string {
+	if (!input?.trim()) return "";
+	if (!tag) return input;
+	const regex = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`, "g");
+	return input.replace(regex, "$1");
+}
diff --git a/sdk/packages/shared/src/prompt/system.ts b/sdk/packages/shared/src/prompt/system.ts
new file mode 100644
index 0000000..7f3ac4d
--- /dev/null
+++ b/sdk/packages/shared/src/prompt/system.ts
@@ -0,0 +1,68 @@
+export const DEFAULT_CLINE_SYSTEM_PROMPT = `You are Cline, an AI coding agent. Your primary goal is to assist users with various coding tasks by leveraging your knowledge and the tools at your disposal. Given the user's prompt, you should use the tools available to you to answer user's question.
+
+Always gather all the necessary context before starting to work on a task. For example, if you are generating a unit test or new code, make sure you understand the requirement, the naming conventions, frameworks and libraries used and aligned in the current codebase, and the environment and commands used to run and test the code etc. Always validate the new unit test at the end including running the code if possible for live feedback.
+Review each question carefully and answer it with detailed, accurate information.
+If you need more information, use one of the available tools or ask for clarification instead of making assumptions or lies.
+
+Environment you are running in:
+<env>
+1. Platform: {{PLATFORM_NAME}}
+2. Date: {{CURRENT_DATE}}
+3. IDE: {{IDE_NAME}}
+4. Working Directory: {{CWD}}
+</env>
+
+Remember:
+- Always adhere to existing code conventions and patterns.
+- Use only libraries and frameworks that are confirmed to be in use in the current codebase.
+- Provide complete and functional code without omissions or placeholders.
+- Be explicit about any assumptions or limitations in your solution.
+- Always show your planning process before executing any task. This will help ensure that you have a clear understanding of the requirements and that your approach aligns with the user's needs.
+- Always use absolute paths when referring to files.
+- You can call multiple tools in a single response. Before using tools, identify every independent read, search, command, or edit needed for the next step and emit all of those tool calls now, either as multiple tool calls or as one batched input for tools that accept arrays. Do not wait for one independent result before requesting another. Do not split independent reads, searches, checks, or edits across separate turns.
+- Good parallelism examples: read all known relevant files in one read_files call; run independent inspection commands in one run_commands call; emit independent read_files, search_codebase, and run_commands calls together in one response; emit multiple editor calls together when editing different files or non-overlapping regions.
+- Always verify the files you have edited or created at the end of the task to ensure they are completed and working as expected.
+
+Begin by analyzing the user's input and gathering any necessary additional context. Then, present your plan at the start of your response along with tool calls before proceeding with the task. It's OK for this section to be quite long.
+
+REMEMBER, be helpful and proactive! Don't ask for permission to do something when you can do it! Do not indicates you will be using a tool unless you are actually going to use it.
+
+IMPORTANT: Always includes tool calls in your response until the task is completed. Response without tool calls will considered as completed with final answer.
+
+When you have completed the task, please provide a summary of what you did and any relevant information that the user should know. This will help ensure that the user understands the changes made and can easily follow up if they have any questions or need further assistance. Do not indicate that you will perform an action without actually doing it. Always provide the final result in your response. Always validate your answer with checking the code and running it if possible. 
+
+If user asked a simple question without any coding context, answer it directly without using any tools.
+{{CLINE_RULES}}
+{{CLINE_METADATA}}`;
+
+export const YOLO_CLINE_SYSTEM_PROMPT = `You are Cline, a careful and helpful coding agent that works in the background.
+You are tasked to solve an issue reported by the user who you cannot communicate with directly.
+Your goal is to utilize the tools at your disposal to investigate and answer the question according to user's instructions with the aim to verify that the issue is resolved.
+
+RULES:
+- Always match output format exactly as shown in examples or existing files.
+- Use only libraries and frameworks that are confirmed and compatible to be in use in the current codebase.
+- Provide complete and functional code without omissions or placeholders.
+- Always show your planning process without repeating yourself before executing any task. This will help ensure that you have a clear understanding of the requirements and that your approach aligns with the user's request.
+- Always use absolute paths when referring to files.
+- You can call multiple tools in a single response. Before using tools, identify every independent read, search, command, or edit needed for the next step and emit all of those tool calls now, either as multiple tool calls or as one batched input for tools that accept arrays. Do not wait for one independent result before requesting another. Do not split independent reads, searches, checks, or edits across separate turns.
+- Good parallelism examples: read all known relevant files in one read_files call; run independent inspection commands in one run_commands call; emit independent read_files, search_codebase, and run_commands calls together in one response; emit multiple editor calls together when editing different files or non-overlapping regions.
+- Always verify the files you have edited or created at the end of the task to ensure they are completed and working as expected.
+
+Environment you are running in:
+<env>
+1. Platform: {{PLATFORM_NAME}}
+2. Date: {{CURRENT_DATE}}
+3. IDE: {{IDE_NAME}}
+4. Working Directory: {{CWD}}
+</env>
+
+IMPORTANT: 
+- When the user describes a bug, unexpected behavior, or provides a bug report, your primary goal is to produce a correct fix in the source code that resolves the issue. 
+- A correct fix means the underlying behavior is fixed — not just the symptoms addressed superficially. 
+- After applying your fix, you must run the relevant test suite to confirm your changes actually resolve the problem. If tests fail, analyze the failures, revise your fix, and re-run until tests pass. 
+- Do not consider the task complete until the test suite related to the files you have touched passes.
+- Always includes tool calls in your response until the task is completed. You should only end the task when all the requirements are met by calling the 'submit_and_exit' tool.
+- Response without the submit_and_exit tool call will considered not completed and the task will continue.
+{{CLINE_RULES}}
+{{CLINE_METADATA}}`;
diff --git a/sdk/packages/shared/src/providers/utils.ts b/sdk/packages/shared/src/providers/utils.ts
new file mode 100644
index 0000000..c1faa00
--- /dev/null
+++ b/sdk/packages/shared/src/providers/utils.ts
@@ -0,0 +1,3 @@
+export function isClineProvider(providerId: string): boolean {
+	return providerId === "cline" || providerId === "cline-pass";
+}
diff --git a/sdk/packages/shared/src/remote-config/artifact-store.ts b/sdk/packages/shared/src/remote-config/artifact-store.ts
new file mode 100644
index 0000000..1382472
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/artifact-store.ts
@@ -0,0 +1,70 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type {
+	RemoteConfigBundle,
+	RemoteConfigBundleStore,
+	RemoteConfigManagedArtifactStore,
+} from "./bundle";
+
+async function pathExists(targetPath: string): Promise<boolean> {
+	try {
+		await fs.access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export class FileRemoteConfigBundleStore implements RemoteConfigBundleStore {
+	constructor(private readonly filePath: string) {}
+
+	async read(): Promise<RemoteConfigBundle | undefined> {
+		try {
+			return JSON.parse(
+				await fs.readFile(this.filePath, "utf8"),
+			) as RemoteConfigBundle;
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+				return undefined;
+			}
+			throw error;
+		}
+	}
+
+	async write(bundle: RemoteConfigBundle): Promise<void> {
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.writeFile(this.filePath, JSON.stringify(bundle, null, 2), "utf8");
+	}
+
+	async clear(): Promise<void> {
+		await fs.rm(this.filePath, { force: true });
+	}
+}
+
+export class FileSystemRemoteConfigManagedArtifactStore
+	implements RemoteConfigManagedArtifactStore
+{
+	async writeText(filePath: string, contents: string): Promise<void> {
+		await fs.mkdir(path.dirname(filePath), { recursive: true });
+		await fs.writeFile(filePath, contents, "utf8");
+	}
+
+	async remove(targetPath: string): Promise<void> {
+		await fs.rm(targetPath, { recursive: true, force: true });
+	}
+
+	async removeChildren(directoryPath: string): Promise<void> {
+		if (!(await pathExists(directoryPath))) {
+			return;
+		}
+		const entries = await fs.readdir(directoryPath);
+		await Promise.all(
+			entries.map((entry) =>
+				fs.rm(path.join(directoryPath, entry), {
+					recursive: true,
+					force: true,
+				}),
+			),
+		);
+	}
+}
diff --git a/sdk/packages/shared/src/remote-config/blob-storage.ts b/sdk/packages/shared/src/remote-config/blob-storage.ts
new file mode 100644
index 0000000..e5a6f85
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/blob-storage.ts
@@ -0,0 +1,416 @@
+import { createHmac } from "node:crypto";
+import { basename } from "node:path";
+import { AwsClient } from "aws4fetch";
+import type {
+	PromptUploading,
+	RemoteConfig,
+	S3AccessKeySettings,
+} from "./schema";
+
+export interface RemoteConfigBlobStoreSettings {
+	bucket: string;
+	adapterType: "s3" | "r2" | "azure";
+	accessKeyId: string;
+	secretAccessKey: string;
+	region?: string;
+	endpoint?: string;
+	accountId?: string;
+}
+
+export interface RemoteConfigBlobStoreTarget {
+	bucket: string;
+	adapterType: "s3" | "r2" | "azure";
+	region?: string;
+	endpoint?: string;
+	accountId?: string;
+}
+
+export interface RemoteConfigBlobStorageAdapter {
+	write(path: string, value: string): Promise<void>;
+}
+
+export interface RemoteConfigSessionBlobUploadMetadata {
+	version: 1;
+	storage: RemoteConfigBlobStoreTarget;
+	keyPrefix?: string;
+	userDistinctId?: string;
+}
+
+export interface RemoteConfigSessionMetadataRow {
+	metadata?: Record<string, unknown> | null;
+}
+
+export interface RemoteConfigSessionMessagesUploadInput {
+	sessionId: string;
+	path: string;
+	contents: string;
+	row?: RemoteConfigSessionMetadataRow;
+}
+
+export interface RemoteConfigSessionMessagesArtifactUploader {
+	uploadMessagesFile(
+		input: RemoteConfigSessionMessagesUploadInput,
+	): Promise<void>;
+}
+
+export const REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY =
+	"enterprise.blobUpload";
+
+const sessionBlobStoreSettings = new Map<
+	string,
+	RemoteConfigBlobStoreSettings
+>();
+
+function accessSettingsToBlobStorage(
+	adapterType: RemoteConfigBlobStoreSettings["adapterType"],
+	settings: S3AccessKeySettings,
+): RemoteConfigBlobStoreSettings {
+	return {
+		adapterType,
+		accessKeyId: settings.accessKeyId,
+		secretAccessKey: settings.secretAccessKey,
+		region: settings.region,
+		bucket: settings.bucket,
+		endpoint: settings.endpoint,
+		accountId: settings.accountId,
+	};
+}
+
+function sanitizeBlobStoreTarget(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStoreTarget {
+	return {
+		adapterType: settings.adapterType,
+		bucket: settings.bucket,
+		region: settings.region,
+		endpoint: settings.endpoint,
+		accountId: settings.accountId,
+	};
+}
+
+export function resolveBlobStoreSettingsFromPromptUploading(
+	promptUploading: PromptUploading | undefined,
+): RemoteConfigBlobStoreSettings | undefined {
+	if (!promptUploading || promptUploading.enabled !== true) {
+		return undefined;
+	}
+	if (
+		promptUploading.type === "s3_access_keys" &&
+		promptUploading.s3AccessSettings
+	) {
+		return accessSettingsToBlobStorage("s3", promptUploading.s3AccessSettings);
+	}
+	if (
+		promptUploading.type === "r2_access_keys" &&
+		promptUploading.r2AccessSettings
+	) {
+		return accessSettingsToBlobStorage("r2", promptUploading.r2AccessSettings);
+	}
+	if (
+		promptUploading.type === "azure_access_keys" &&
+		promptUploading.azureAccessSettings
+	) {
+		return accessSettingsToBlobStorage(
+			"azure",
+			promptUploading.azureAccessSettings,
+		);
+	}
+	return undefined;
+}
+
+export function resolveBlobStoreSettingsFromRemoteConfig(
+	remoteConfig: RemoteConfig | undefined,
+): RemoteConfigBlobStoreSettings | undefined {
+	return resolveBlobStoreSettingsFromPromptUploading(
+		remoteConfig?.enterpriseTelemetry?.promptUploading,
+	);
+}
+
+export function buildRemoteConfigSessionBlobUploadMetadata(
+	remoteConfig: RemoteConfig | undefined,
+	userDistinctId?: string,
+): RemoteConfigSessionBlobUploadMetadata | undefined {
+	const storage = resolveBlobStoreSettingsFromRemoteConfig(remoteConfig);
+	if (!storage) {
+		return undefined;
+	}
+	return {
+		version: 1,
+		storage: sanitizeBlobStoreTarget(storage),
+		userDistinctId,
+	};
+}
+
+export function registerRemoteConfigSessionBlobUpload(
+	sessionId: string,
+	remoteConfig: RemoteConfig | undefined,
+	userDistinctId?: string,
+): RemoteConfigSessionBlobUploadMetadata | undefined {
+	const storage = resolveBlobStoreSettingsFromRemoteConfig(remoteConfig);
+	if (!storage) {
+		sessionBlobStoreSettings.delete(sessionId);
+		return undefined;
+	}
+	sessionBlobStoreSettings.set(sessionId, storage);
+	return {
+		version: 1,
+		storage: sanitizeBlobStoreTarget(storage),
+		userDistinctId,
+	};
+}
+
+export function clearRemoteConfigSessionBlobUpload(sessionId: string): void {
+	sessionBlobStoreSettings.delete(sessionId);
+}
+
+function createAdapter(
+	client: AwsClient,
+	endpoint: string,
+	bucket: string,
+): RemoteConfigBlobStorageAdapter {
+	const base = `${endpoint}/${bucket}`;
+	return {
+		async write(path: string, value: string): Promise<void> {
+			const response = await client.fetch(`${base}/${path}`, {
+				method: "PUT",
+				body: value,
+				headers: {
+					"Content-Type": "application/json; charset=utf-8",
+				},
+			});
+			if (!response.ok) {
+				throw new Error(`Failed to write ${path}: ${response.status}`);
+			}
+		},
+	};
+}
+
+function createS3Adapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	const { bucket, accessKeyId, secretAccessKey } = settings;
+	if (!bucket || !accessKeyId || !secretAccessKey) {
+		return undefined;
+	}
+	const region = settings.region || "us-east-1";
+	const endpoint = settings.endpoint || `https://s3.${region}.amazonaws.com`;
+	return createAdapter(
+		new AwsClient({
+			region,
+			accessKeyId,
+			secretAccessKey,
+		}),
+		endpoint,
+		bucket,
+	);
+}
+
+function createR2Adapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	const { accountId, endpoint, bucket, accessKeyId, secretAccessKey } =
+		settings;
+	if (
+		(!endpoint && !accountId) ||
+		!bucket ||
+		!accessKeyId ||
+		!secretAccessKey
+	) {
+		return undefined;
+	}
+	return createAdapter(
+		new AwsClient({
+			accessKeyId,
+			secretAccessKey,
+		}),
+		settings.endpoint ?? `https://${accountId}.r2.cloudflarestorage.com`,
+		bucket,
+	);
+}
+
+function azureSharedKeyAuth(
+	accountName: string,
+	accountKey: string,
+	method: string,
+	path: string,
+	headers: Record<string, string>,
+): string {
+	const contentLength = headers["Content-Length"] || "";
+	const contentType = headers["Content-Type"] || "";
+	const msHeaders = Object.entries(headers)
+		.filter(([key]) => key.toLowerCase().startsWith("x-ms-"))
+		.sort(([a], [b]) => a.toLowerCase().localeCompare(b.toLowerCase()))
+		.map(([key, value]) => `${key.toLowerCase()}:${value}`)
+		.join("\n");
+	const canonicalizedResource = `/${accountName}${path}`;
+	const stringToSign = [
+		method,
+		"",
+		"",
+		contentLength,
+		"",
+		contentType,
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		msHeaders,
+		canonicalizedResource,
+	].join("\n");
+	const key = Buffer.from(accountKey, "base64");
+	const signature = createHmac("sha256", key)
+		.update(stringToSign, "utf8")
+		.digest("base64");
+	return `SharedKey ${accountName}:${signature}`;
+}
+
+function createAzureAdapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	const { accessKeyId, secretAccessKey, bucket } = settings;
+	if (!accessKeyId || !secretAccessKey || !bucket) {
+		return undefined;
+	}
+	const baseUrl =
+		settings.endpoint || `https://${accessKeyId}.blob.core.windows.net`;
+	return {
+		async write(path: string, value: string): Promise<void> {
+			const blobPath = `/${bucket}/${path}`;
+			const date = new Date().toUTCString();
+			const bodyBuffer = Buffer.from(value, "utf8");
+			const headers: Record<string, string> = {
+				"x-ms-date": date,
+				"x-ms-version": "2024-11-04",
+				"x-ms-blob-type": "BlockBlob",
+				"Content-Type": "application/json; charset=utf-8",
+				"Content-Length": bodyBuffer.byteLength.toString(),
+			};
+			headers.Authorization = azureSharedKeyAuth(
+				accessKeyId,
+				secretAccessKey,
+				"PUT",
+				blobPath,
+				headers,
+			);
+
+			const response = await fetch(`${baseUrl}${blobPath}`, {
+				method: "PUT",
+				body: bodyBuffer,
+				headers,
+			});
+			if (!response.ok) {
+				const errorBody = await response.text().catch(() => "");
+				throw new Error(
+					`Failed to write ${path}: ${response.status} ${errorBody}`.trim(),
+				);
+			}
+		},
+	};
+}
+
+export function createRemoteConfigBlobStorageAdapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	if (settings.adapterType === "s3") {
+		return createS3Adapter(settings);
+	}
+	if (settings.adapterType === "r2") {
+		return createR2Adapter(settings);
+	}
+	if (settings.adapterType === "azure") {
+		return createAzureAdapter(settings);
+	}
+	return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function readRemoteConfigSessionBlobUploadMetadata(
+	row: RemoteConfigSessionMetadataRow | undefined,
+): RemoteConfigSessionBlobUploadMetadata | undefined {
+	const raw = row?.metadata?.[REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY];
+	if (!isRecord(raw)) {
+		return undefined;
+	}
+	const storage = raw.storage;
+	if (!isRecord(storage)) {
+		return undefined;
+	}
+	const adapterType = storage.adapterType;
+	if (adapterType !== "s3" && adapterType !== "r2" && adapterType !== "azure") {
+		return undefined;
+	}
+	if (typeof storage.bucket !== "string") {
+		return undefined;
+	}
+	return {
+		version: 1,
+		storage: {
+			adapterType,
+			bucket: storage.bucket,
+			region: typeof storage.region === "string" ? storage.region : undefined,
+			endpoint:
+				typeof storage.endpoint === "string" ? storage.endpoint : undefined,
+			accountId:
+				typeof storage.accountId === "string" ? storage.accountId : undefined,
+		},
+		keyPrefix: typeof raw.keyPrefix === "string" ? raw.keyPrefix : undefined,
+		userDistinctId:
+			typeof raw.userDistinctId === "string" ? raw.userDistinctId : undefined,
+	};
+}
+
+function buildBlobObjectKey(
+	sessionId: string,
+	messagesPath: string,
+	metadata: RemoteConfigSessionBlobUploadMetadata,
+): string {
+	const userDistinctId = metadata.userDistinctId?.trim() || "unknown";
+	const parts = [
+		"sessions",
+		userDistinctId,
+		sessionId,
+		messagesPath?.endsWith("messages.json")
+			? "messages.json"
+			: basename(messagesPath),
+	].filter((value): value is string => Boolean(value?.trim()));
+	return parts.join("/");
+}
+
+export function createRemoteConfigSessionMessagesArtifactUploader(): RemoteConfigSessionMessagesArtifactUploader {
+	const adapters = new Map<string, RemoteConfigBlobStorageAdapter>();
+	return {
+		async uploadMessagesFile({
+			sessionId,
+			path,
+			contents,
+			row,
+		}): Promise<void> {
+			const metadata = readRemoteConfigSessionBlobUploadMetadata(row);
+			if (!metadata) {
+				return;
+			}
+			const settings = sessionBlobStoreSettings.get(sessionId);
+			if (!settings) {
+				return;
+			}
+			const cacheKey = JSON.stringify(settings);
+			let adapter = adapters.get(cacheKey);
+			if (!adapter) {
+				adapter = createRemoteConfigBlobStorageAdapter(settings);
+				if (!adapter) {
+					return;
+				}
+				adapters.set(cacheKey, adapter);
+			}
+			await adapter.write(
+				buildBlobObjectKey(sessionId, path, metadata),
+				contents,
+			);
+		},
+	};
+}
diff --git a/sdk/packages/shared/src/remote-config/bundle.ts b/sdk/packages/shared/src/remote-config/bundle.ts
new file mode 100644
index 0000000..6c8eb1b
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/bundle.ts
@@ -0,0 +1,181 @@
+import type { AgentExtension } from "../agents/types";
+import type { BasicLogger } from "../logging/logger";
+import type { OpenTelemetryClientConfig } from "../services/telemetry";
+import type { GlobalInstructionsFile, RemoteConfig } from "./schema";
+
+export interface RemoteConfigIdentityClaims {
+	subject: string;
+	email?: string;
+	roles?: string[];
+	groups?: string[];
+	organizationId?: string;
+	projectIds?: string[];
+	rawClaims?: Record<string, unknown>;
+}
+
+export type RemoteConfigManagedInstructionKind = "rule" | "workflow" | "skill";
+
+export interface RemoteConfigManagedInstructionFile {
+	id: string;
+	name: string;
+	kind: RemoteConfigManagedInstructionKind;
+	contents: string;
+	alwaysEnabled?: boolean;
+	description?: string;
+	metadata?: Record<string, unknown>;
+}
+
+export interface RemoteConfigBundle {
+	source: string;
+	version: string;
+	remoteConfig?: RemoteConfig;
+	managedInstructions?: RemoteConfigManagedInstructionFile[];
+	telemetry?: Record<string, unknown>;
+	claims?: RemoteConfigIdentityClaims;
+	metadata?: Record<string, unknown>;
+}
+
+export interface RemoteConfigProjectContext {
+	projectId?: string;
+	workspaceId?: string;
+	organizationId?: string;
+}
+
+export interface RemoteConfigSyncContext {
+	workspacePath: string;
+	rootPath?: string;
+	context?: RemoteConfigProjectContext;
+	logger?: BasicLogger;
+	signal?: AbortSignal;
+	now?: number;
+}
+
+export interface RemoteConfigControlPlaneFetchInput
+	extends RemoteConfigSyncContext {}
+
+export interface RemoteConfigControlPlane {
+	name: string;
+	fetchBundle(
+		input: RemoteConfigControlPlaneFetchInput,
+	): Promise<RemoteConfigBundle | undefined>;
+}
+
+export interface RemoteConfigBundleStore {
+	read(): Promise<RemoteConfigBundle | undefined>;
+	write(bundle: RemoteConfigBundle): Promise<void>;
+	clear(): Promise<void>;
+}
+
+export interface RemoteConfigManagedArtifactStore {
+	writeText(filePath: string, contents: string): Promise<void>;
+	remove(targetPath: string): Promise<void>;
+	removeChildren(directoryPath: string): Promise<void>;
+}
+
+export interface RemoteConfigManagedPaths {
+	pluginName: string;
+	pluginPath: string;
+	workflowsPath: string;
+	skillsPath: string;
+	bundleCachePath: string;
+	manifestPath: string;
+	rulesFilePath: string;
+}
+
+export interface RemoteConfigMaterializationInput {
+	bundle: RemoteConfigBundle;
+	paths: RemoteConfigManagedPaths;
+	artifactStore: RemoteConfigManagedArtifactStore;
+}
+
+export interface RemoteConfigMaterializedInstructionFile {
+	kind: RemoteConfigManagedInstructionKind;
+	filePath: string;
+	id: string;
+	name: string;
+}
+
+export interface RemoteConfigMaterializationResult {
+	paths: RemoteConfigManagedPaths;
+	rulesFilePath?: string;
+	files: RemoteConfigMaterializedInstructionFile[];
+}
+
+export interface RemoteConfigPolicyMaterializer {
+	materialize(
+		input: RemoteConfigMaterializationInput,
+	): Promise<RemoteConfigMaterializationResult>;
+}
+
+export interface RemoteConfigTelemetryAdapter {
+	name: string;
+	resolveTelemetry(
+		bundle: RemoteConfigBundle,
+		context: RemoteConfigSyncContext,
+	):
+		| Promise<Partial<OpenTelemetryClientConfig> | undefined>
+		| Partial<OpenTelemetryClientConfig>
+		| undefined;
+}
+
+export interface RemoteConfigClaimsMapper<TRole extends string = string> {
+	mapClaimsToRoles(claims: RemoteConfigIdentityClaims): TRole[];
+}
+
+export interface RemoteConfigSyncServiceOptions {
+	controlPlane: RemoteConfigControlPlane;
+	bundleStore: RemoteConfigBundleStore;
+	materializer: RemoteConfigPolicyMaterializer;
+	artifactStore: RemoteConfigManagedArtifactStore;
+	telemetryAdapter?: RemoteConfigTelemetryAdapter;
+	claimsMapper?: RemoteConfigClaimsMapper;
+	logger?: BasicLogger;
+}
+
+export interface RemoteConfigSyncResult {
+	bundle: RemoteConfigBundle;
+	materialized: RemoteConfigMaterializationResult;
+	telemetry?: Partial<OpenTelemetryClientConfig>;
+	roles: string[];
+	claims?: RemoteConfigIdentityClaims;
+}
+
+export interface PrepareRemoteConfigRuntimeOptions
+	extends RemoteConfigSyncContext {
+	pluginName?: string;
+	controlPlane?: RemoteConfigControlPlane;
+	bundleStore?: RemoteConfigBundleStore;
+	artifactStore?: RemoteConfigManagedArtifactStore;
+	materializer?: RemoteConfigPolicyMaterializer;
+	telemetryAdapter?: RemoteConfigTelemetryAdapter;
+	claimsMapper?: RemoteConfigClaimsMapper;
+	useCachedBundle?: boolean;
+	requireBundle?: boolean;
+}
+
+export interface PreparedRemoteConfigRuntime {
+	pluginName: string;
+	pluginDefinition: AgentExtension;
+	paths: RemoteConfigManagedPaths;
+	bundle?: RemoteConfigBundle;
+	telemetry?: Partial<OpenTelemetryClientConfig>;
+	roles: string[];
+	claims?: RemoteConfigIdentityClaims;
+	usedCachedBundle: boolean;
+	workflowsDirectories: readonly string[];
+	skillsDirectories: readonly string[];
+}
+
+export function remoteConfigInstructionToManagedFile(
+	kind: Extract<RemoteConfigManagedInstructionKind, "rule" | "workflow">,
+	file: GlobalInstructionsFile,
+	suffix: string,
+): RemoteConfigManagedInstructionFile {
+	return {
+		id: `remote-config:${kind}:${suffix}:${file.name}`,
+		name: file.name,
+		kind,
+		contents: file.contents,
+		alwaysEnabled: file.alwaysEnabled,
+	};
+}
diff --git a/sdk/packages/shared/src/remote-config/constants.ts b/sdk/packages/shared/src/remote-config/constants.ts
new file mode 100644
index 0000000..8f6e988
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/constants.ts
@@ -0,0 +1,5 @@
+/**
+ * URI scheme for opening remote rules/workflows in the editor.
+ * Used to construct URIs like: remote://rule/{name} or remote://workflow/{name}
+ */
+export const REMOTE_URI_SCHEME = "remote://";
diff --git a/sdk/packages/shared/src/remote-config/index.ts b/sdk/packages/shared/src/remote-config/index.ts
new file mode 100644
index 0000000..7bd570b
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/index.ts
@@ -0,0 +1,9 @@
+export * from "./artifact-store";
+export * from "./blob-storage";
+export * from "./bundle";
+export * from "./constants";
+export * from "./materializer";
+export * from "./paths";
+export * from "./runtime";
+export * from "./schema";
+export * from "./telemetry";
diff --git a/sdk/packages/shared/src/remote-config/materializer.ts b/sdk/packages/shared/src/remote-config/materializer.ts
new file mode 100644
index 0000000..e4ffc70
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/materializer.ts
@@ -0,0 +1,165 @@
+import type {
+	RemoteConfigBundle,
+	RemoteConfigManagedInstructionFile,
+	RemoteConfigManagedInstructionKind,
+	RemoteConfigMaterializationInput,
+	RemoteConfigMaterializationResult,
+	RemoteConfigMaterializedInstructionFile,
+	RemoteConfigPolicyMaterializer,
+} from "./bundle";
+import { remoteConfigInstructionToManagedFile } from "./bundle";
+import type { RemoteConfig } from "./schema";
+
+function sanitizeSegment(value: string): string {
+	let result = "";
+	let pendingSeparator = false;
+	for (const char of value.trim().toLowerCase()) {
+		const code = char.charCodeAt(0);
+		const isAllowed =
+			(code >= 97 && code <= 122) ||
+			(code >= 48 && code <= 57) ||
+			char === "." ||
+			char === "_" ||
+			char === "-";
+		if (isAllowed) {
+			if (pendingSeparator && result && result[result.length - 1] !== "-") {
+				result += "-";
+			}
+			pendingSeparator = false;
+			result += char;
+		} else {
+			pendingSeparator = true;
+		}
+		if (result.length >= 80) {
+			break;
+		}
+	}
+	while (result.endsWith("-")) {
+		result = result.slice(0, -1);
+	}
+	while (result.startsWith("-")) {
+		result = result.slice(1);
+	}
+	return result || "item";
+}
+
+function mergeRemoteConfigInstructions(
+	remoteConfig: RemoteConfig | undefined,
+): RemoteConfigManagedInstructionFile[] {
+	const rules =
+		remoteConfig?.globalRules?.map((rule, index) =>
+			remoteConfigInstructionToManagedFile("rule", rule, `${index}`),
+		) ?? [];
+	const workflows =
+		remoteConfig?.globalWorkflows?.map((workflow, index) =>
+			remoteConfigInstructionToManagedFile("workflow", workflow, `${index}`),
+		) ?? [];
+	return [...rules, ...workflows];
+}
+
+function combineInstructions(
+	bundle: RemoteConfigBundle,
+): RemoteConfigManagedInstructionFile[] {
+	return [
+		...mergeRemoteConfigInstructions(bundle.remoteConfig),
+		...(bundle.managedInstructions ?? []),
+	];
+}
+
+function buildRulesMarkdown(
+	rules: readonly RemoteConfigManagedInstructionFile[],
+): string {
+	return rules
+		.map((rule) => {
+			const header = `## ${rule.name}`;
+			const meta = rule.alwaysEnabled ? "_Always enabled_\n" : "";
+			return `${header}\n\n${meta}${rule.contents.trim()}`;
+		})
+		.join("\n\n");
+}
+
+function selectInstructions(
+	instructions: readonly RemoteConfigManagedInstructionFile[],
+	kind: RemoteConfigManagedInstructionKind,
+): RemoteConfigManagedInstructionFile[] {
+	return instructions.filter((item) => item.kind === kind);
+}
+
+export class FileSystemRemoteConfigPolicyMaterializer
+	implements RemoteConfigPolicyMaterializer
+{
+	async materialize(
+		input: RemoteConfigMaterializationInput,
+	): Promise<RemoteConfigMaterializationResult> {
+		const instructions = combineInstructions(input.bundle);
+		const rules = selectInstructions(instructions, "rule");
+		const workflows = selectInstructions(instructions, "workflow");
+		const skills = selectInstructions(instructions, "skill");
+
+		await input.artifactStore.removeChildren(input.paths.workflowsPath);
+		await input.artifactStore.removeChildren(input.paths.skillsPath);
+
+		const files: RemoteConfigMaterializedInstructionFile[] = [];
+		if (rules.length > 0) {
+			await input.artifactStore.writeText(
+				input.paths.rulesFilePath,
+				buildRulesMarkdown(rules),
+			);
+			files.push(
+				...rules.map((rule) => ({
+					kind: rule.kind,
+					filePath: input.paths.rulesFilePath,
+					id: rule.id,
+					name: rule.name,
+				})),
+			);
+		} else {
+			await input.artifactStore.remove(input.paths.rulesFilePath);
+		}
+
+		for (const workflow of workflows) {
+			const filePath = `${input.paths.workflowsPath}/${sanitizeSegment(
+				workflow.name.replace(/\.(md|markdown|txt)$/i, ""),
+			)}.md`;
+			await input.artifactStore.writeText(filePath, workflow.contents);
+			files.push({
+				kind: workflow.kind,
+				filePath,
+				id: workflow.id,
+				name: workflow.name,
+			});
+		}
+
+		for (const skill of skills) {
+			const filePath = `${input.paths.skillsPath}/${sanitizeSegment(
+				skill.name,
+			)}/SKILL.md`;
+			await input.artifactStore.writeText(filePath, skill.contents);
+			files.push({
+				kind: skill.kind,
+				filePath,
+				id: skill.id,
+				name: skill.name,
+			});
+		}
+
+		await input.artifactStore.writeText(
+			input.paths.manifestPath,
+			JSON.stringify(
+				{
+					source: input.bundle.source,
+					version: input.bundle.version,
+					files,
+				},
+				null,
+				2,
+			),
+		);
+
+		return {
+			paths: input.paths,
+			rulesFilePath: rules.length > 0 ? input.paths.rulesFilePath : undefined,
+			files,
+		};
+	}
+}
diff --git a/sdk/packages/shared/src/remote-config/paths.ts b/sdk/packages/shared/src/remote-config/paths.ts
new file mode 100644
index 0000000..1211854
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/paths.ts
@@ -0,0 +1,33 @@
+import path from "node:path";
+import type { RemoteConfigManagedPaths } from "./bundle";
+
+export const DEFAULT_REMOTE_CONFIG_PLUGIN_NAME = "remote-config";
+
+export function resolveRemoteConfigPaths(input: {
+	workspacePath: string;
+	pluginName?: string;
+}): RemoteConfigManagedPaths {
+	const pluginName = input.pluginName ?? DEFAULT_REMOTE_CONFIG_PLUGIN_NAME;
+	const pluginPath = path.join(input.workspacePath, ".cline", pluginName);
+	return {
+		pluginName,
+		pluginPath,
+		workflowsPath: path.join(pluginPath, "workflows"),
+		skillsPath: path.join(pluginPath, "skills"),
+		bundleCachePath: path.join(pluginPath, "cache", "bundle.json"),
+		manifestPath: path.join(pluginPath, "managed.json"),
+		rulesFilePath: path.join(pluginPath, "rules.md"),
+	};
+}
+
+export function getRemoteConfigCommandDirectories(
+	paths: RemoteConfigManagedPaths,
+): {
+	workflowsDirectories: readonly string[];
+	skillsDirectories: readonly string[];
+} {
+	return {
+		workflowsDirectories: [paths.workflowsPath],
+		skillsDirectories: [paths.skillsPath],
+	};
+}
diff --git a/sdk/packages/shared/src/remote-config/runtime.test.ts b/sdk/packages/shared/src/remote-config/runtime.test.ts
new file mode 100644
index 0000000..9843fa7
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/runtime.test.ts
@@ -0,0 +1,102 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	buildRemoteConfigSessionBlobUploadMetadata,
+	prepareRemoteConfigRuntime,
+	REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY,
+	readRemoteConfigSessionBlobUploadMetadata,
+} from "./index";
+
+async function createTempWorkspace(): Promise<string> {
+	return fs.mkdtemp(path.join(os.tmpdir(), "sdk-remote-config-"));
+}
+
+describe("remote-config runtime", () => {
+	it("materializes remote-config rules and workflows", async () => {
+		const workspacePath = await createTempWorkspace();
+
+		const prepared = await prepareRemoteConfigRuntime({
+			workspacePath,
+			pluginName: "enterprise",
+			controlPlane: {
+				name: "test",
+				async fetchBundle() {
+					return {
+						source: "test",
+						version: "1",
+						remoteConfig: {
+							version: "v1",
+							globalRules: [
+								{
+									name: "managed-rule",
+									contents: "Follow managed policy.",
+									alwaysEnabled: true,
+								},
+							],
+							globalWorkflows: [
+								{
+									name: "Managed Workflow.md",
+									contents: "Run the managed workflow.",
+									alwaysEnabled: true,
+								},
+							],
+						},
+					};
+				},
+			},
+		});
+
+		await expect(
+			fs.readFile(prepared.paths.rulesFilePath, "utf8"),
+		).resolves.toContain("Follow managed policy.");
+		await expect(
+			fs.readFile(
+				path.join(prepared.paths.workflowsPath, "managed-workflow.md"),
+				"utf8",
+			),
+		).resolves.toBe("Run the managed workflow.");
+		expect(prepared.pluginDefinition.name).toBe("enterprise");
+		expect(prepared.workflowsDirectories).toEqual([
+			prepared.paths.workflowsPath,
+		]);
+	});
+
+	it("builds and reads non-secret blob upload metadata", () => {
+		const metadata = buildRemoteConfigSessionBlobUploadMetadata({
+			version: "v1",
+			enterpriseTelemetry: {
+				promptUploading: {
+					enabled: true,
+					type: "s3_access_keys",
+					s3AccessSettings: {
+						bucket: "cline-prompts",
+						accessKeyId: "key",
+						secretAccessKey: "secret",
+						region: "us-west-2",
+					},
+				},
+			},
+		});
+
+		expect(metadata).toEqual({
+			version: 1,
+			storage: {
+				adapterType: "s3",
+				bucket: "cline-prompts",
+				region: "us-west-2",
+				endpoint: undefined,
+				accountId: undefined,
+			},
+			userDistinctId: undefined,
+		});
+		expect(
+			readRemoteConfigSessionBlobUploadMetadata({
+				metadata: {
+					[REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY]: metadata,
+				},
+			}),
+		).toEqual(metadata);
+	});
+});
diff --git a/sdk/packages/shared/src/remote-config/runtime.ts b/sdk/packages/shared/src/remote-config/runtime.ts
new file mode 100644
index 0000000..84a4959
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/runtime.ts
@@ -0,0 +1,236 @@
+import type { AgentExtension } from "../agents/types";
+import {
+	FileRemoteConfigBundleStore,
+	FileSystemRemoteConfigManagedArtifactStore,
+} from "./artifact-store";
+import type {
+	PreparedRemoteConfigRuntime,
+	PrepareRemoteConfigRuntimeOptions,
+	RemoteConfigBundle,
+	RemoteConfigManagedArtifactStore,
+	RemoteConfigPolicyMaterializer,
+	RemoteConfigProjectContext,
+	RemoteConfigSyncResult,
+	RemoteConfigSyncServiceOptions,
+} from "./bundle";
+import { FileSystemRemoteConfigPolicyMaterializer } from "./materializer";
+import {
+	getRemoteConfigCommandDirectories,
+	resolveRemoteConfigPaths,
+} from "./paths";
+import { DefaultRemoteConfigTelemetryAdapter } from "./telemetry";
+
+function deriveClaims(
+	bundle: RemoteConfigBundle | undefined,
+): RemoteConfigSyncResult["claims"] {
+	return bundle?.claims;
+}
+
+function deriveRoles(
+	claims: RemoteConfigSyncResult["claims"],
+	options: Pick<
+		PrepareRemoteConfigRuntimeOptions | RemoteConfigSyncServiceOptions,
+		"claimsMapper"
+	>,
+): string[] {
+	if (!claims) {
+		return [];
+	}
+	if (options.claimsMapper) {
+		return options.claimsMapper.mapClaimsToRoles(claims);
+	}
+	return claims.roles ?? [];
+}
+
+export function withRemoteConfigBundlePaths<T extends RemoteConfigBundle>(
+	bundle: T,
+	paths: RemoteConfigSyncResult["materialized"]["paths"],
+): T {
+	return {
+		...bundle,
+		metadata: {
+			...(bundle.metadata ?? {}),
+			paths,
+		},
+	};
+}
+
+export class RemoteConfigSyncService {
+	constructor(private readonly options: RemoteConfigSyncServiceOptions) {}
+
+	async sync(input: {
+		workspacePath: string;
+		rootPath?: string;
+		context?: RemoteConfigProjectContext;
+		paths: RemoteConfigSyncResult["materialized"]["paths"];
+		signal?: AbortSignal;
+		now?: number;
+	}): Promise<RemoteConfigSyncResult> {
+		const bundle = await this.options.controlPlane.fetchBundle({
+			workspacePath: input.workspacePath,
+			rootPath: input.rootPath,
+			context: input.context,
+			signal: input.signal,
+			now: input.now,
+			logger: this.options.logger,
+		});
+
+		if (!bundle) {
+			throw new Error("Remote config control plane returned no bundle");
+		}
+
+		await this.options.bundleStore.write(bundle);
+
+		const materialized = await this.options.materializer.materialize({
+			bundle,
+			paths: input.paths,
+			artifactStore: this.options.artifactStore,
+		});
+
+		const telemetry = this.options.telemetryAdapter
+			? await this.options.telemetryAdapter.resolveTelemetry(bundle, {
+					workspacePath: input.workspacePath,
+					rootPath: input.rootPath,
+					context: input.context,
+					signal: input.signal,
+					now: input.now,
+					logger: this.options.logger,
+				})
+			: undefined;
+		const claims = deriveClaims(bundle);
+		const roles = deriveRoles(claims, this.options);
+
+		return {
+			bundle,
+			materialized,
+			telemetry,
+			roles,
+			claims,
+		};
+	}
+}
+
+export function createRemoteConfigPluginDefinition(options?: {
+	name?: string;
+	setup?: AgentExtension["setup"];
+}): AgentExtension {
+	const name = options?.name ?? "remote-config";
+	return {
+		name,
+		manifest: { capabilities: ["providers"] },
+		async setup(api, ctx) {
+			api.registerProvider?.({
+				name,
+				description: "Remote-config managed runtime integration",
+			});
+			await options?.setup?.(api, ctx);
+		},
+	};
+}
+
+export async function prepareRemoteConfigRuntime(
+	options: PrepareRemoteConfigRuntimeOptions,
+): Promise<PreparedRemoteConfigRuntime> {
+	const paths = resolveRemoteConfigPaths({
+		workspacePath: options.workspacePath,
+		pluginName: options.pluginName,
+	});
+	const bundleStore =
+		options.bundleStore ??
+		new FileRemoteConfigBundleStore(paths.bundleCachePath);
+	const artifactStore: RemoteConfigManagedArtifactStore =
+		options.artifactStore ?? new FileSystemRemoteConfigManagedArtifactStore();
+	const materializer: RemoteConfigPolicyMaterializer =
+		options.materializer ?? new FileSystemRemoteConfigPolicyMaterializer();
+	const telemetryAdapter =
+		options.telemetryAdapter ?? new DefaultRemoteConfigTelemetryAdapter();
+
+	let bundle: RemoteConfigBundle | undefined;
+	let telemetry: RemoteConfigSyncResult["telemetry"];
+	let roles: string[] = [];
+	let claims: RemoteConfigSyncResult["claims"];
+	let usedCachedBundle = false;
+	let bundleMaterializedDuringSync = false;
+
+	if (options.controlPlane) {
+		const syncService = new RemoteConfigSyncService({
+			controlPlane: options.controlPlane,
+			bundleStore,
+			artifactStore,
+			materializer,
+			telemetryAdapter,
+			claimsMapper: options.claimsMapper,
+			logger: options.logger,
+		});
+
+		try {
+			const result = await syncService.sync({
+				workspacePath: options.workspacePath,
+				rootPath: options.rootPath,
+				context: options.context,
+				paths,
+				signal: options.signal,
+				now: options.now,
+			});
+			bundle = result.bundle;
+			telemetry = result.telemetry;
+			roles = result.roles;
+			claims = result.claims;
+			bundleMaterializedDuringSync = true;
+		} catch (error) {
+			if (options.useCachedBundle !== false) {
+				bundle = await bundleStore.read();
+				usedCachedBundle = Boolean(bundle);
+			}
+			if (!bundle) {
+				throw error;
+			}
+		}
+	} else if (options.useCachedBundle !== false) {
+		bundle = await bundleStore.read();
+		usedCachedBundle = Boolean(bundle);
+	}
+
+	if (!bundle && options.requireBundle) {
+		throw new Error("Remote config runtime preparation requires a bundle");
+	}
+
+	if (bundle) {
+		const bundleWithPaths = withRemoteConfigBundlePaths(bundle, paths);
+		await bundleStore.write(bundleWithPaths);
+		if (!bundleMaterializedDuringSync) {
+			await materializer.materialize({
+				bundle: bundleWithPaths,
+				paths,
+				artifactStore,
+			});
+		}
+		claims ??= deriveClaims(bundleWithPaths);
+		roles = roles.length > 0 ? roles : deriveRoles(claims, options);
+		telemetry ??= await telemetryAdapter.resolveTelemetry(bundleWithPaths, {
+			workspacePath: options.workspacePath,
+			rootPath: options.rootPath,
+			context: options.context,
+			signal: options.signal,
+			now: options.now,
+			logger: options.logger,
+		});
+		bundle = bundleWithPaths;
+	}
+
+	const commandDirectories = getRemoteConfigCommandDirectories(paths);
+	return {
+		pluginName: paths.pluginName,
+		pluginDefinition: createRemoteConfigPluginDefinition({
+			name: paths.pluginName,
+		}),
+		paths,
+		bundle,
+		telemetry,
+		roles,
+		claims,
+		usedCachedBundle,
+		workflowsDirectories: commandDirectories.workflowsDirectories,
+		skillsDirectories: commandDirectories.skillsDirectories,
+	};
+}
diff --git a/sdk/packages/shared/src/remote-config/schema.test.ts b/sdk/packages/shared/src/remote-config/schema.test.ts
new file mode 100644
index 0000000..c2e291e
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/schema.test.ts
@@ -0,0 +1,977 @@
+import { describe, expect, it } from "vitest";
+import {
+	AwsBedrockSettingsSchema,
+	ClineSettingsSchema,
+	EnterpriseTelemetrySchema,
+	OpenAiCompatibleSchema,
+	PromptUploadingSchema,
+	type RemoteConfig,
+	RemoteConfigSchema,
+	S3AccessKeySettingsSchema,
+} from "./schema";
+
+describe("Remote Config Schema", () => {
+	describe("EnterpriseTelemetry", () => {
+		it("accepts an empty object", () => {
+			const result = EnterpriseTelemetrySchema.parse({});
+
+			expect(result).to.deep.equal({});
+		});
+
+		it("accepts an empty prompt uploading object", () => {
+			const result = EnterpriseTelemetrySchema.parse({
+				promptUploading: {},
+			});
+
+			expect(result.promptUploading).to.deep.equal({});
+		});
+	});
+
+	describe("S3AccessKeySettingsSchema", () => {
+		it("should accept valid S3 access key settings with required fields", () => {
+			const validSettings = {
+				bucket: "my-bucket",
+				accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+			};
+			const result = S3AccessKeySettingsSchema.parse(validSettings);
+			expect(result).to.deep.equal(validSettings);
+		});
+
+		it("should accept S3 settings with all optional fields", () => {
+			const fullSettings = {
+				bucket: "my-bucket",
+				accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				region: "us-east-1",
+				endpoint: "https://s3.us-east-1.amazonaws.com",
+				accountId: "123456789012",
+			};
+			const result = S3AccessKeySettingsSchema.parse(fullSettings);
+			expect(result).to.deep.equal(fullSettings);
+		});
+
+		it("should reject S3 settings with missing bucket", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				}),
+			).to.throw();
+		});
+
+		it("should reject S3 settings with missing accessKeyId", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				}),
+			).to.throw();
+		});
+
+		it("should reject S3 settings with missing secretAccessKey", () => {
+			expect(() =>
+				S3AccessKeySettingsSchema.parse({
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+				}),
+			).to.throw();
+		});
+	});
+
+	describe("PromptUploadingSchema", () => {
+		it("should accept an empty object", () => {
+			const result = PromptUploadingSchema.parse({});
+			expect(result).to.deep.equal({});
+		});
+
+		it("should accept enabled field only", () => {
+			const result = PromptUploadingSchema.parse({ enabled: true });
+			expect(result.enabled).to.equal(true);
+		});
+
+		it("should accept enabled as false", () => {
+			const result = PromptUploadingSchema.parse({ enabled: false });
+			expect(result.enabled).to.equal(false);
+		});
+
+		it("should accept type field with s3_access_keys", () => {
+			const result = PromptUploadingSchema.parse({ type: "s3_access_keys" });
+			expect(result.type).to.equal("s3_access_keys");
+		});
+
+		it("should reject invalid type values", () => {
+			expect(() =>
+				PromptUploadingSchema.parse({ type: "invalid_type" }),
+			).to.throw();
+			expect(() => PromptUploadingSchema.parse({ type: "s3" })).to.throw();
+			expect(() => PromptUploadingSchema.parse({ type: "" })).to.throw();
+		});
+
+		it("should accept complete prompt uploading configuration", () => {
+			const fullConfig = {
+				enabled: true,
+				type: "s3_access_keys" as const,
+				s3AccessSettings: {
+					bucket: "prompt-uploads-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					region: "us-west-2",
+					endpoint: "https://s3.us-west-2.amazonaws.com",
+					accountId: "123456789012",
+				},
+			};
+			const result = PromptUploadingSchema.parse(fullConfig);
+			expect(result).to.deep.equal(fullConfig);
+			expect(result.enabled).to.equal(true);
+			expect(result.type).to.equal("s3_access_keys");
+			expect(result.s3AccessSettings?.bucket).to.equal("prompt-uploads-bucket");
+			expect(result.s3AccessSettings?.region).to.equal("us-west-2");
+		});
+
+		it("should accept s3AccessSettings without optional fields", () => {
+			const config = {
+				enabled: true,
+				type: "s3_access_keys" as const,
+				s3AccessSettings: {
+					bucket: "my-bucket",
+					accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+					secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+				},
+			};
+			const result = PromptUploadingSchema.parse(config);
+			expect(result.s3AccessSettings?.bucket).to.equal("my-bucket");
+			expect(result.s3AccessSettings?.region).to.be.undefined;
+			expect(result.s3AccessSettings?.endpoint).to.be.undefined;
+			expect(result.s3AccessSettings?.accountId).to.be.undefined;
+		});
+
+		it("should reject s3AccessSettings with missing required fields", () => {
+			expect(() =>
+				PromptUploadingSchema.parse({
+					enabled: true,
+					s3AccessSettings: {
+						accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+						secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					},
+				}),
+			).to.throw();
+		});
+
+		it("should reject invalid enabled type", () => {
+			expect(() => PromptUploadingSchema.parse({ enabled: "yes" })).to.throw();
+			expect(() => PromptUploadingSchema.parse({ enabled: 1 })).to.throw();
+		});
+	});
+
+	describe("OpenAiCompatibleSchema", () => {
+		it("should accept valid OpenAI compatible settings", () => {
+			const validSettings = {
+				models: [
+					{
+						id: "gpt-4",
+						temperature: 0.7,
+						isR1FormatRequired: true,
+						maxTokens: 4096,
+						contextWindow: 128000,
+						inputPrice: 0.03,
+						outputPrice: 0.06,
+						supportsImages: true,
+					},
+					{
+						id: "gpt-3.5-turbo",
+						temperature: 0.7,
+						maxTokens: 4096,
+						contextWindow: 16000,
+						inputPrice: 0.001,
+						outputPrice: 0.002,
+						supportsImages: false,
+					},
+				],
+				openAiBaseUrl: "https://api.openai.com/v1",
+				openAiHeaders: { "X-Custom-Header": "value" },
+				azureApiVersion: "2024-02-15-preview",
+			};
+			const result = OpenAiCompatibleSchema.parse(validSettings);
+			expect(result).to.deep.equal(validSettings);
+		});
+
+		it("should have undefined for models and openAiHeaders by default", () => {
+			const result = OpenAiCompatibleSchema.parse({});
+			expect(result.models).to.be.undefined;
+			expect(result.openAiHeaders).to.be.undefined;
+		});
+
+		it("should reject invalid field types", () => {
+			expect(() =>
+				OpenAiCompatibleSchema.parse({ models: "not-an-array" }),
+			).to.throw();
+			expect(() =>
+				OpenAiCompatibleSchema.parse({ openAiHeaders: "not-an-object" }),
+			).to.throw();
+		});
+
+		it("should reject models with missing id field", () => {
+			expect(() =>
+				OpenAiCompatibleSchema.parse({
+					models: [{ temperature: 0.7 }],
+				}),
+			).to.throw();
+		});
+
+		it("should accept models with only id field", () => {
+			const settings = {
+				models: [{ id: "gpt-4" }],
+			};
+			expect(() => OpenAiCompatibleSchema.parse(settings)).to.not.throw();
+		});
+
+		it("should accept headers as record of strings", () => {
+			const settings = {
+				openAiHeaders: {
+					Authorization: "Bearer token",
+					"Content-Type": "application/json",
+				},
+			};
+			const result = OpenAiCompatibleSchema.parse(settings);
+			expect(result.openAiHeaders).to.deep.equal(settings.openAiHeaders);
+		});
+	});
+
+	describe("ClineSettingsSchema", () => {
+		it("should accept valid Cline provider settings", () => {
+			const validSettings = {
+				models: [
+					{ id: "claude-3-5-sonnet-20241022" },
+					{ id: "claude-3-5-haiku-20241022" },
+				],
+			};
+			const result = ClineSettingsSchema.parse(validSettings);
+			expect(result).to.deep.equal(validSettings);
+		});
+
+		it("should accept empty settings object", () => {
+			const result = ClineSettingsSchema.parse({});
+			expect(result.models).to.be.undefined;
+		});
+
+		it("should accept models with only id field", () => {
+			const settings = {
+				models: [{ id: "claude-3-5-sonnet-20241022" }],
+			};
+			expect(() => ClineSettingsSchema.parse(settings)).to.not.throw();
+		});
+
+		it("should reject models with missing id field", () => {
+			expect(() =>
+				ClineSettingsSchema.parse({
+					models: [{}],
+				}),
+			).to.throw();
+		});
+	});
+
+	describe("AwsBedrockSettingsSchema", () => {
+		it("should accept valid AWS Bedrock settings", () => {
+			const validSettings = {
+				models: [
+					{ id: "anthropic.claude-v2", thinkingBudgetTokens: 1600 },
+					{ id: "anthropic.claude-instant-v1", thinkingBudgetTokens: 800 },
+				],
+				customModels: [
+					{ name: "my-custom-model", baseModelId: "anthropic.claude-v2" },
+					{ name: "another-model", baseModelId: "anthropic.claude-instant-v1" },
+				],
+				awsRegion: "us-east-1",
+				awsUseCrossRegionInference: true,
+				awsBedrockUsePromptCache: true,
+				awsBedrockEndpoint: "https://bedrock.us-east-1.amazonaws.com",
+			};
+			const result = AwsBedrockSettingsSchema.parse(validSettings);
+			expect(result).to.deep.equal(validSettings);
+		});
+
+		it("should accept empty settings object", () => {
+			const result = AwsBedrockSettingsSchema.parse({});
+			expect(result.models).to.be.undefined;
+			expect(result.customModels).to.be.undefined;
+		});
+
+		it("should accept models with only id field", () => {
+			const settings = {
+				models: [{ id: "anthropic.claude-v2" }],
+			};
+			expect(() => AwsBedrockSettingsSchema.parse(settings)).to.not.throw();
+		});
+
+		it("should accept models with thinkingBudgetTokens", () => {
+			const settings = {
+				models: [
+					{ id: "anthropic.claude-v2", thinkingBudgetTokens: 1600 },
+					{ id: "anthropic.claude-instant-v1", thinkingBudgetTokens: 800 },
+				],
+			};
+			const result = AwsBedrockSettingsSchema.parse(settings);
+			expect(result.models).to.have.lengthOf(2);
+			expect(result.models?.[0].thinkingBudgetTokens).to.equal(1600);
+		});
+
+		it("should accept custom models array", () => {
+			const settings = {
+				customModels: [
+					{
+						name: "custom-1",
+						baseModelId: "base-model-1",
+						thinkingBudgetTokens: 1600,
+					},
+					{ name: "custom-2", baseModelId: "base-model-2" },
+				],
+			};
+			expect(() => AwsBedrockSettingsSchema.parse(settings)).to.not.throw();
+		});
+
+		it("should reject invalid field types", () => {
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({ models: "not-an-array" }),
+			).to.throw();
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({ customModels: "not-an-array" }),
+			).to.throw();
+		});
+
+		it("should reject models with missing id field", () => {
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({
+					models: [{ thinkingBudgetTokens: 1600 }],
+				}),
+			).to.throw();
+		});
+
+		it("should reject custom models with missing fields", () => {
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({
+					customModels: [{ name: "missing-base-model" }],
+				}),
+			).to.throw();
+			expect(() =>
+				AwsBedrockSettingsSchema.parse({
+					customModels: [{ baseModelId: "missing-name" }],
+				}),
+			).to.throw();
+		});
+	});
+
+	describe("MCPSettingsSchema", () => {
+		it("should reject servers with a missing id", () => {
+			const config = {
+				version: "v1",
+				allowedMCPServers: [{}],
+			};
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw();
+		});
+
+		it("should accept valid MCP settings", () => {
+			const config = {
+				version: "v1",
+				mcpMarketplaceEnabled: true,
+				allowedMCPServers: [
+					{ id: "https://github.com/mcp/filesystem" },
+					{ id: "https://github.com/mcp/github" },
+				],
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.mcpMarketplaceEnabled).to.equal(true);
+			expect(result.allowedMCPServers).to.deep.equal(config.allowedMCPServers);
+		});
+	});
+
+	describe("RemoteMCPServersSchema", () => {
+		it("should accept remoteMCPServers with alwaysEnabled true", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{
+						name: "always-on-server",
+						url: "https://example.com/mcp",
+						alwaysEnabled: true,
+					},
+				],
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.remoteMCPServers).to.have.lengthOf(1);
+			expect(result.remoteMCPServers?.[0].name).to.equal("always-on-server");
+			expect(result.remoteMCPServers?.[0].url).to.equal(
+				"https://example.com/mcp",
+			);
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.equal(true);
+		});
+
+		it("should accept remoteMCPServers with alwaysEnabled false", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{
+						name: "toggle-server",
+						url: "https://example.com/mcp",
+						alwaysEnabled: false,
+					},
+				],
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.remoteMCPServers).to.have.lengthOf(1);
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.equal(false);
+		});
+
+		it("should accept remoteMCPServers without alwaysEnabled (defaults to undefined)", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{ name: "default-server", url: "https://example.com/mcp" },
+				],
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.remoteMCPServers).to.have.lengthOf(1);
+			expect(result.remoteMCPServers?.[0].name).to.equal("default-server");
+			expect(result.remoteMCPServers?.[0].url).to.equal(
+				"https://example.com/mcp",
+			);
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.be.undefined;
+		});
+
+		it("should accept multiple remoteMCPServers with mixed alwaysEnabled values", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{
+						name: "always-on",
+						url: "https://example1.com/mcp",
+						alwaysEnabled: true,
+					},
+					{
+						name: "toggle",
+						url: "https://example2.com/mcp",
+						alwaysEnabled: false,
+					},
+					{ name: "default", url: "https://example3.com/mcp" },
+				],
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.remoteMCPServers).to.have.lengthOf(3);
+			expect(result.remoteMCPServers?.[0].alwaysEnabled).to.equal(true);
+			expect(result.remoteMCPServers?.[1].alwaysEnabled).to.equal(false);
+			expect(result.remoteMCPServers?.[2].alwaysEnabled).to.be.undefined;
+		});
+
+		it("should reject remoteMCPServers with missing name", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{ url: "https://example.com/mcp", alwaysEnabled: true },
+				],
+			};
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw();
+		});
+
+		it("should reject remoteMCPServers with missing url", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [{ name: "test-server", alwaysEnabled: true }],
+			};
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw();
+		});
+
+		it("should reject remoteMCPServers with invalid alwaysEnabled type", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{
+						name: "test-server",
+						url: "https://example.com/mcp",
+						alwaysEnabled: "yes",
+					},
+				],
+			};
+
+			expect(() => RemoteConfigSchema.parse(config)).to.throw();
+		});
+
+		it("should accept headers", () => {
+			const config = {
+				version: "v1",
+				remoteMCPServers: [
+					{
+						name: "test-server",
+						url: "https://example.com/mcp",
+						headers: { Authorization: "test" },
+					},
+				],
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.remoteMCPServers).to.have.lengthOf(1);
+			expect(result.remoteMCPServers?.[0].headers).to.deep.equal({
+				Authorization: "test",
+			});
+		});
+	});
+
+	describe("RemoteConfigSchema", () => {
+		it("should accept valid complete remote config", () => {
+			const validConfig: RemoteConfig = {
+				version: "v1",
+				telemetryEnabled: true,
+				kanbanEnabled: true,
+				mcpMarketplaceEnabled: true,
+				yoloModeAllowed: false,
+				providerSettings: {
+					OpenAiCompatible: {
+						models: [{ id: "gpt-4" }],
+						openAiBaseUrl: "https://api.openai.com/v1",
+						openAiHeaders: {},
+					},
+					AwsBedrock: {
+						models: [{ id: "anthropic.claude-v2" }],
+						awsRegion: "us-west-2",
+					},
+				},
+			};
+			const result = RemoteConfigSchema.parse(validConfig);
+			expect(result).to.deep.equal(validConfig);
+		});
+
+		it("should require version field", () => {
+			const configWithoutVersion = {};
+			expect(() => RemoteConfigSchema.parse(configWithoutVersion)).to.throw();
+		});
+
+		it("should accept minimal valid config", () => {
+			const minimalConfig = {
+				version: "v1",
+			};
+			expect(() => RemoteConfigSchema.parse(minimalConfig)).to.not.throw();
+		});
+
+		it("should accept config with general settings only", () => {
+			const configWithGeneralSettings = {
+				version: "v1",
+				telemetryEnabled: false,
+				mcpMarketplaceEnabled: false,
+				yoloModeAllowed: true,
+			};
+			const result = RemoteConfigSchema.parse(configWithGeneralSettings);
+			expect(result.telemetryEnabled).to.equal(false);
+			expect(result.mcpMarketplaceEnabled).to.equal(false);
+			expect(result.yoloModeAllowed).to.equal(true);
+		});
+
+		it("should accept config with OpenAI compatible provider only", () => {
+			const config = {
+				version: "v1",
+				providerSettings: {
+					OpenAiCompatible: {
+						models: [{ id: "gpt-4" }, { id: "gpt-3.5-turbo" }],
+						openAiBaseUrl: "https://api.openai.com/v1",
+					},
+				},
+			};
+			expect(() => RemoteConfigSchema.parse(config)).to.not.throw();
+		});
+
+		it("should accept config with AWS Bedrock provider only", () => {
+			const config = {
+				version: "v1",
+				providerSettings: {
+					AwsBedrock: {
+						models: [{ id: "anthropic.claude-v2" }],
+						awsRegion: "us-east-1",
+					},
+				},
+			};
+			expect(() => RemoteConfigSchema.parse(config)).to.not.throw();
+		});
+
+		it("should reject invalid version type", () => {
+			expect(() => RemoteConfigSchema.parse({ version: 123 })).to.throw();
+		});
+
+		it("should reject invalid telemetry setting type", () => {
+			expect(() =>
+				RemoteConfigSchema.parse({
+					version: "v1",
+					telemetryEnabled: "yes",
+				}),
+			).to.throw();
+		});
+
+		it("should allow undefined optional provider settings", () => {
+			const config = {
+				version: "v1",
+				// providerSettings is undefined
+			};
+			expect(() => RemoteConfigSchema.parse(config)).to.not.throw();
+		});
+
+		it("should handle complete config with all fields", () => {
+			const config = {
+				version: "v1",
+				telemetryEnabled: true,
+				kanbanEnabled: true,
+				mcpMarketplaceEnabled: false,
+				blockPersonalRemoteMCPServers: true,
+				allowedMCPServers: [
+					{ id: "https://github.com/mcp/filesystem" },
+					{ id: "https://github.com/mcp/github" },
+				],
+				yoloModeAllowed: true,
+				openTelemetryEnabled: true,
+				openTelemetryMetricsExporter: "otlp",
+				openTelemetryLogsExporter: "otlp",
+				openTelemetryOtlpProtocol: "http/json",
+				openTelemetryOtlpEndpoint: "http://localhost:4318",
+				openTelemetryOtlpMetricsProtocol: "http/json",
+				openTelemetryOtlpMetricsEndpoint: "http://localhost:4318/v1/metrics",
+				openTelemetryOtlpLogsProtocol: "http/json",
+				openTelemetryOtlpLogsEndpoint: "http://localhost:4318/v1/logs",
+				openTelemetryMetricExportInterval: 60000,
+				openTelemetryOtlpInsecure: false,
+				openTelemetryLogBatchSize: 512,
+				openTelemetryLogBatchTimeout: 5000,
+				openTelemetryLogMaxQueueSize: 2048,
+				openTelemetryOtlpHeaders: { test: "string" },
+				globalRules: [
+					{
+						alwaysEnabled: true,
+						name: "company-standards.md",
+						contents:
+							"# Company Standards\n\nAll code must follow these standards...",
+					},
+					{
+						alwaysEnabled: false,
+						name: "optional-guidelines.md",
+						contents:
+							"# Optional Guidelines\n\nConsider these best practices...",
+					},
+				],
+				globalWorkflows: [
+					{
+						alwaysEnabled: true,
+						name: "deployment-workflow.md",
+						contents:
+							"# Deployment Workflow\n\n1. Run tests\n2. Build\n3. Deploy",
+					},
+				],
+				providerSettings: {
+					OpenAiCompatible: {
+						models: [
+							{
+								id: "gpt-4",
+								temperature: 0.7,
+								isR1FormatRequired: false,
+								maxTokens: 4096,
+								contextWindow: 128000,
+								inputPrice: 0.03,
+								outputPrice: 0.06,
+								supportsImages: true,
+							},
+							{
+								id: "gpt-3.5-turbo",
+								temperature: 0.8,
+								isR1FormatRequired: false,
+								maxTokens: 4096,
+								contextWindow: 16000,
+								inputPrice: 0.001,
+								outputPrice: 0.002,
+								supportsImages: false,
+							},
+						],
+						openAiBaseUrl: "https://custom.openai.api/v1",
+						openAiHeaders: {
+							"X-API-Key": "secret-key",
+							"X-Custom-Header": "custom-value",
+						},
+						azureApiVersion: "2024-02-15-preview",
+					},
+					AwsBedrock: {
+						models: [
+							{ id: "anthropic.claude-v2", thinkingBudgetTokens: 1600 },
+							{ id: "anthropic.claude-instant-v1", thinkingBudgetTokens: 800 },
+						],
+						customModels: [
+							{
+								name: "my-custom-model",
+								baseModelId: "anthropic.claude-v2",
+								thinkingBudgetTokens: 2000,
+							},
+							{
+								name: "another-custom",
+								baseModelId: "anthropic.claude-instant-v1",
+								thinkingBudgetTokens: 1000,
+							},
+						],
+						awsRegion: "eu-west-1",
+						awsUseCrossRegionInference: false,
+						awsUseGlobalInference: true,
+						awsBedrockUsePromptCache: true,
+						awsBedrockEndpoint: "https://custom-bedrock.endpoint",
+					},
+					Cline: {
+						models: [
+							{ id: "claude-3-5-sonnet-20241022" },
+							{ id: "claude-3-5-haiku-20241022" },
+						],
+					},
+					Vertex: {
+						models: [
+							{
+								id: "claude-3-5-sonnet-v2@20241022",
+								thinkingBudgetTokens: 1600,
+							},
+							{ id: "claude-3-5-haiku@20241022" },
+						],
+						vertexProjectId: "my-gcp-project",
+						vertexRegion: "us-central1",
+					},
+					Anthropic: {
+						models: [
+							{ id: "claude-3-5-sonnet-20241022" },
+							{ id: "claude-3-5-sonnet-20241024", thinkingBudgetTokens: 1600 },
+						],
+						baseUrl: "https://example.cline.bot",
+					},
+				},
+				enterpriseTelemetry: {
+					promptUploading: {
+						enabled: true,
+						type: "s3_access_keys",
+						s3AccessSettings: {
+							bucket: "enterprise-prompts",
+							accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+							secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+							region: "us-east-1",
+						},
+					},
+				},
+			};
+			const result = RemoteConfigSchema.parse(config);
+
+			// Verify all top-level fields
+			expect(result.version).to.equal("v1");
+			expect(result.telemetryEnabled).to.equal(true);
+			expect(result.yoloModeAllowed).to.equal(true);
+			expect(result.kanbanEnabled).to.equal(true);
+
+			expect(result.mcpMarketplaceEnabled).to.equal(false);
+			expect(result.allowedMCPServers).to.deep.equal(config.allowedMCPServers);
+
+			// Verify OpenAI Compatible settings
+			expect(
+				result.providerSettings?.OpenAiCompatible?.models,
+			).to.have.lengthOf(2);
+			expect(result.providerSettings?.OpenAiCompatible?.openAiBaseUrl).to.equal(
+				"https://custom.openai.api/v1",
+			);
+			expect(
+				result.providerSettings?.OpenAiCompatible?.azureApiVersion,
+			).to.equal("2024-02-15-preview");
+
+			// Verify AWS Bedrock settings
+			expect(result.providerSettings?.AwsBedrock?.models).to.have.lengthOf(2);
+			expect(
+				result.providerSettings?.AwsBedrock?.customModels,
+			).to.have.lengthOf(2);
+			expect(result.providerSettings?.AwsBedrock?.awsRegion).to.equal(
+				"eu-west-1",
+			);
+			expect(
+				result.providerSettings?.AwsBedrock?.awsUseCrossRegionInference,
+			).to.equal(false);
+			expect(
+				result.providerSettings?.AwsBedrock?.awsUseGlobalInference,
+			).to.equal(true);
+			expect(
+				result.providerSettings?.AwsBedrock?.awsBedrockUsePromptCache,
+			).to.equal(true);
+			expect(result.providerSettings?.AwsBedrock?.awsBedrockEndpoint).to.equal(
+				"https://custom-bedrock.endpoint",
+			);
+
+			// Verify Cline settings
+			expect(result.providerSettings?.Cline?.models).to.have.lengthOf(2);
+			expect(result.providerSettings?.Cline?.models?.[0].id).to.equal(
+				"claude-3-5-sonnet-20241022",
+			);
+			expect(result.providerSettings?.Cline?.models?.[1].id).to.equal(
+				"claude-3-5-haiku-20241022",
+			);
+
+			// Verify Vertex settings
+			expect(result.providerSettings?.Vertex?.models).to.have.lengthOf(2);
+			expect(result.providerSettings?.Vertex?.models?.[0].id).to.equal(
+				"claude-3-5-sonnet-v2@20241022",
+			);
+			expect(
+				result.providerSettings?.Vertex?.models?.[0].thinkingBudgetTokens,
+			).to.equal(1600);
+			expect(result.providerSettings?.Vertex?.models?.[1].id).to.equal(
+				"claude-3-5-haiku@20241022",
+			);
+			expect(result.providerSettings?.Vertex?.models?.[1].thinkingBudgetTokens)
+				.to.be.undefined;
+			expect(result.providerSettings?.Vertex?.vertexProjectId).to.equal(
+				"my-gcp-project",
+			);
+			expect(result.providerSettings?.Vertex?.vertexRegion).to.equal(
+				"us-central1",
+			);
+
+			expect(result.providerSettings?.Anthropic?.models).to.have.lengthOf(2);
+			expect(result.providerSettings?.Anthropic?.models?.[0].id).to.equal(
+				"claude-3-5-sonnet-20241022",
+			);
+			expect(
+				result.providerSettings?.Anthropic?.models?.[0].thinkingBudgetTokens,
+			).to.be.undefined;
+			expect(result.providerSettings?.Anthropic?.models?.[1].id).to.equal(
+				"claude-3-5-sonnet-20241024",
+			);
+			expect(
+				result.providerSettings?.Anthropic?.models?.[1].thinkingBudgetTokens,
+			).to.equal(1600);
+			expect(result.providerSettings?.Anthropic?.baseUrl).to.equal(
+				"https://example.cline.bot",
+			);
+
+			// Verify OpenTelemetry settings
+			expect(result.openTelemetryEnabled).to.equal(true);
+			expect(result.openTelemetryMetricsExporter).to.equal("otlp");
+			expect(result.openTelemetryLogsExporter).to.equal("otlp");
+			expect(result.openTelemetryOtlpProtocol).to.equal("http/json");
+			expect(result.openTelemetryOtlpEndpoint).to.equal(
+				"http://localhost:4318",
+			);
+			expect(result.openTelemetryOtlpMetricsProtocol).to.equal("http/json");
+			expect(result.openTelemetryOtlpMetricsEndpoint).to.equal(
+				"http://localhost:4318/v1/metrics",
+			);
+			expect(result.openTelemetryOtlpLogsProtocol).to.equal("http/json");
+			expect(result.openTelemetryOtlpLogsEndpoint).to.equal(
+				"http://localhost:4318/v1/logs",
+			);
+			expect(result.openTelemetryMetricExportInterval).to.equal(60000);
+			expect(result.openTelemetryOtlpInsecure).to.equal(false);
+			expect(result.openTelemetryLogBatchSize).to.equal(512);
+			expect(result.openTelemetryLogBatchTimeout).to.equal(5000);
+			expect(result.openTelemetryLogMaxQueueSize).to.equal(2048);
+			expect(result.openTelemetryOtlpHeaders).to.deep.equal({ test: "string" });
+
+			// Verify Global Instructions settings
+			expect(result.globalRules).to.have.lengthOf(2);
+			expect(result.globalRules?.[0].alwaysEnabled).to.equal(true);
+			expect(result.globalRules?.[0].name).to.equal("company-standards.md");
+			expect(result.globalRules?.[0].contents).to.include("Company Standards");
+			expect(result.globalRules?.[1].alwaysEnabled).to.equal(false);
+			expect(result.globalRules?.[1].name).to.equal("optional-guidelines.md");
+
+			expect(result.globalWorkflows).to.have.lengthOf(1);
+			expect(result.globalWorkflows?.[0].alwaysEnabled).to.equal(true);
+			expect(result.globalWorkflows?.[0].name).to.equal(
+				"deployment-workflow.md",
+			);
+			expect(result.globalWorkflows?.[0].contents).to.include(
+				"Deployment Workflow",
+			);
+
+			expect(result.enterpriseTelemetry?.promptUploading?.enabled).to.equal(
+				true,
+			);
+			expect(result.enterpriseTelemetry?.promptUploading?.type).to.equal(
+				"s3_access_keys",
+			);
+			expect(
+				result.enterpriseTelemetry?.promptUploading?.s3AccessSettings?.bucket,
+			).to.equal("enterprise-prompts");
+			expect(
+				result.enterpriseTelemetry?.promptUploading?.s3AccessSettings?.region,
+			).to.equal("us-east-1");
+		});
+	});
+
+	describe("Type Inference", () => {
+		it("accepts azure prompt uploading settings", () => {
+			const config: RemoteConfig = {
+				version: "v1",
+				enterpriseTelemetry: {
+					promptUploading: {
+						enabled: true,
+						type: "azure_access_keys",
+						azureAccessSettings: {
+							bucket: "chat-history",
+							accessKeyId: "storage-account",
+							secretAccessKey: Buffer.from("secret").toString("base64"),
+							endpoint: "https://storage-account.blob.core.windows.net",
+						},
+					},
+				},
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.enterpriseTelemetry?.promptUploading?.type).to.equal(
+				"azure_access_keys",
+			);
+			expect(
+				result.enterpriseTelemetry?.promptUploading?.azureAccessSettings
+					?.bucket,
+			).to.equal("chat-history");
+		});
+
+		it("allows prompt uploading settings without an explicit enabled flag", () => {
+			const config: RemoteConfig = {
+				version: "v1",
+				enterpriseTelemetry: {
+					promptUploading: {
+						type: "s3_access_keys",
+						s3AccessSettings: {
+							bucket: "enterprise-prompts",
+							accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+							secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+						},
+					},
+				},
+			};
+
+			const result = RemoteConfigSchema.parse(config);
+			expect(result.enterpriseTelemetry?.promptUploading?.enabled).to.equal(
+				undefined,
+			);
+			expect(
+				result.enterpriseTelemetry?.promptUploading?.s3AccessSettings?.bucket,
+			).to.equal("enterprise-prompts");
+		});
+
+		it("should properly infer RemoteConfig type", () => {
+			const config: RemoteConfig = {
+				version: "v1",
+				telemetryEnabled: true,
+			};
+			// TypeScript compilation will fail if type inference is wrong
+			expect(config.version).to.be.a("string");
+		});
+
+		it("should allow optional fields to be undefined", () => {
+			const config: RemoteConfig = {
+				version: "v1",
+				// All other fields are optional and can be undefined
+			};
+			expect(config.telemetryEnabled).to.be.undefined;
+			expect(config.providerSettings).to.be.undefined;
+		});
+	});
+});
diff --git a/sdk/packages/shared/src/remote-config/schema.ts b/sdk/packages/shared/src/remote-config/schema.ts
new file mode 100644
index 0000000..6bc6b00
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/schema.ts
@@ -0,0 +1,262 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ⚠️  CRITICAL WARNING ⚠️
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * THE API SERVER MUST BE RE-DEPLOYED WHENEVER THIS SCHEMA IS UPDATED!
+ *
+ * This schema is used by both the extension and the API server for validation.
+ * Any changes here require a coordinated deployment to avoid validation errors.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+import { z } from "zod";
+
+// OpenAI Compatible model schema with per-model settings
+export const OpenAiCompatibleModelSchema = z.object({
+	id: z.string(), // The model ID is required
+	temperature: z.number().optional(),
+	isR1FormatRequired: z.boolean().optional(),
+	maxTokens: z.number().optional(),
+	contextWindow: z.number().optional(),
+	inputPrice: z.number().optional(),
+	outputPrice: z.number().optional(),
+	supportsImages: z.boolean().optional(),
+});
+
+// OpenAiCompatible specific settings
+export const OpenAiCompatibleSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(OpenAiCompatibleModelSchema).optional(),
+	// OpenAiCompatible specific settings:
+	openAiBaseUrl: z.string().optional(),
+	openAiHeaders: z.record(z.string(), z.string()).optional(),
+	azureApiVersion: z.string().optional(),
+	azureIdentity: z.boolean().optional(),
+});
+
+// AWS Bedrock model schema with per-model settings
+export const AwsBedrockModelSchema = z.object({
+	id: z.string(), // The model ID is required
+	thinkingBudgetTokens: z.number().optional(),
+});
+
+// AWS Bedrock custom model schema (separate from regular models)
+export const AwsBedrockCustomModelSchema = z.object({
+	name: z.string(), // The model name is required
+	baseModelId: z.string(), // The base model ID is required
+	thinkingBudgetTokens: z.number().optional(),
+});
+
+// AWS Bedrock specific settings
+export const AwsBedrockSettingsSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(AwsBedrockModelSchema).optional(),
+	// Custom models
+	customModels: z.array(AwsBedrockCustomModelSchema).optional(),
+	// AWS Bedrock specific settings:
+	awsRegion: z.string().optional(),
+	awsUseCrossRegionInference: z.boolean().optional(),
+	awsUseGlobalInference: z.boolean().optional(),
+	awsBedrockUsePromptCache: z.boolean().optional(),
+	awsBedrockEndpoint: z.string().optional(),
+});
+
+// Cline Provider model schema with per-model settings
+export const ClineModelSchema = z.object({
+	id: z.string(), // The model ID is required
+});
+
+// Cline Provider specific settings
+export const ClineSettingsSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(ClineModelSchema).optional(),
+});
+
+// Vertex Provider model schema with per-model settings
+export const VertexModelSchema = z.object({
+	id: z.string(), // The model ID is required
+	thinkingBudgetTokens: z.number().optional(),
+});
+
+// GCP Vertex Provider specific settings
+export const VertexSettingsSchema = z.object({
+	// A list of the allowed models with their settings
+	models: z.array(VertexModelSchema).optional(),
+	vertexProjectId: z.string().optional(),
+	vertexRegion: z.string().optional(),
+});
+
+export const LiteLLMModelSchema = z.object({
+	id: z.string(),
+	thinkingBudgetTokens: z.number().optional(),
+	promptCachingEnabled: z.boolean().optional(),
+});
+
+export const LiteLLMSchema = z.object({
+	models: z.array(LiteLLMModelSchema).optional(),
+	baseUrl: z.string().optional(),
+});
+
+export const AnthropicModelSchema = z.object({
+	id: z.string(),
+	thinkingBudgetTokens: z.number().optional(),
+});
+
+export const AnthropicSchema = z.object({
+	models: z.array(AnthropicModelSchema).optional(),
+	baseUrl: z.string().optional(),
+});
+
+// Provider settings schema
+// Each provider becomes an optional field
+const ProviderSettingsSchema = z.object({
+	OpenAiCompatible: OpenAiCompatibleSchema.optional(),
+	AwsBedrock: AwsBedrockSettingsSchema.optional(),
+	Cline: ClineSettingsSchema.optional(),
+	Vertex: VertexSettingsSchema.optional(),
+	LiteLLM: LiteLLMSchema.optional(),
+	Anthropic: AnthropicSchema.optional(),
+});
+
+export const AllowedMCPServerSchema = z.object({
+	// The ID of the MCP is the URL for their github repo.
+	id: z.string(),
+});
+
+export const RemoteMCPServerSchema = z.object({
+	// The name of the MCP server
+	name: z.string(),
+	// The URL of the MCP server
+	url: z.string(),
+	// When this is true, the user cannot disable this MCP server
+	alwaysEnabled: z.boolean().optional(),
+	// Headers to allow for custom auth
+	headers: z.record(z.string(), z.string()).optional(),
+});
+
+// Settings for a global cline rules or workflow file.
+export const GlobalInstructionsFileSchema = z.object({
+	// When this is enabled, the user cannot turn off this rule or workflow.
+	alwaysEnabled: z.boolean(),
+	// The name of the rules or workflow file.
+	name: z.string(),
+	// The contents of the rules or workflow file
+	contents: z.string(),
+});
+
+export const S3AccessKeySettingsSchema = z.object({
+	bucket: z.string(),
+	accessKeyId: z.string(),
+	secretAccessKey: z.string(),
+	region: z.string().optional(),
+	endpoint: z.string().optional(),
+	accountId: z.string().optional(),
+});
+
+export const PromptUploadingSchema = z.object({
+	enabled: z.boolean().optional(),
+	type: z
+		.union([
+			z.literal("s3_access_keys"),
+			z.literal("r2_access_keys"),
+			z.literal("azure_access_keys"),
+		])
+		.optional(),
+	s3AccessSettings: S3AccessKeySettingsSchema.optional(),
+	r2AccessSettings: S3AccessKeySettingsSchema.optional(),
+	azureAccessSettings: S3AccessKeySettingsSchema.optional(),
+});
+
+export const EnterpriseTelemetrySchema = z.object({
+	promptUploading: PromptUploadingSchema.optional(),
+});
+
+export const RemoteConfigSchema = z.object({
+	// The version of the remote config settings, e.g. v1
+	// This field is for internal use only, and won't be visible to the administrator in the UI.
+	version: z.string(),
+
+	// Provider specific settings
+	providerSettings: ProviderSettingsSchema.optional(),
+
+	// General settings not specific to any provider
+	telemetryEnabled: z.boolean().optional(),
+	kanbanEnabled: z.boolean().optional(),
+
+	// MCP settings
+	// Legacy field name. If this is false, locally configured MCP servers are blocked.
+	mcpMarketplaceEnabled: z.boolean().optional(),
+
+	// If this is configured, users only have access to these allowlisted local MCP servers.
+	allowedMCPServers: z.array(AllowedMCPServerSchema).optional(),
+
+	// A list of pre-configured remote MCP servers.
+	remoteMCPServers: z.array(RemoteMCPServerSchema).optional(),
+	// If this is true, users cannot use or configure MCP servers that are not remotely configured.
+	blockPersonalRemoteMCPServers: z.boolean().optional(),
+
+	// If the user is allowed to enable YOLO mode. Note this is different from the extension setting
+	// yoloModeEnabled, because we do not want to force YOLO enabled for the user.
+	yoloModeAllowed: z.boolean().optional(),
+
+	// OpenTelemetry configuration
+	openTelemetryEnabled: z.boolean().optional(),
+	openTelemetryMetricsExporter: z.string().optional(),
+	openTelemetryLogsExporter: z.string().optional(),
+	openTelemetryOtlpProtocol: z.string().optional(),
+	openTelemetryOtlpEndpoint: z.string().optional(),
+	openTelemetryOtlpHeaders: z.record(z.string(), z.string()).optional(),
+	openTelemetryOtlpMetricsProtocol: z.string().optional(),
+	openTelemetryOtlpMetricsEndpoint: z.string().optional(),
+	openTelemetryOtlpMetricsHeaders: z.record(z.string(), z.string()).optional(),
+	openTelemetryOtlpLogsProtocol: z.string().optional(),
+	openTelemetryOtlpLogsEndpoint: z.string().optional(),
+	openTelemetryOtlpLogsHeaders: z.record(z.string(), z.string()).optional(),
+	openTelemetryMetricExportInterval: z.number().optional(),
+	openTelemetryOtlpInsecure: z.boolean().optional(),
+	openTelemetryLogBatchSize: z.number().optional(),
+	openTelemetryLogBatchTimeout: z.number().optional(),
+	openTelemetryLogMaxQueueSize: z.number().optional(),
+
+	enterpriseTelemetry: EnterpriseTelemetrySchema.optional(),
+
+	// Rules & Workflows
+	globalRules: z.array(GlobalInstructionsFileSchema).optional(),
+	globalWorkflows: z.array(GlobalInstructionsFileSchema).optional(),
+});
+
+export const APIKeySchema = z.record(z.string(), z.string());
+
+// Type inference from schemas
+export type RemoteConfig = z.infer<typeof RemoteConfigSchema>;
+export type MCPServer = z.infer<typeof AllowedMCPServerSchema>;
+export type RemoteMCPServer = z.infer<typeof RemoteMCPServerSchema>;
+export type GlobalInstructionsFile = z.infer<
+	typeof GlobalInstructionsFileSchema
+>;
+
+export type ProviderSettings = z.infer<typeof ProviderSettingsSchema>;
+
+export type OpenAiCompatible = z.infer<typeof OpenAiCompatibleSchema>;
+export type OpenAiCompatibleModel = z.infer<typeof OpenAiCompatibleModelSchema>;
+
+export type AwsBedrockSettings = z.infer<typeof AwsBedrockSettingsSchema>;
+export type AwsBedrockModel = z.infer<typeof AwsBedrockModelSchema>;
+export type AwsBedrockCustomModel = z.infer<typeof AwsBedrockCustomModelSchema>;
+
+export type VertexSettings = z.infer<typeof VertexSettingsSchema>;
+export type VertexModel = z.infer<typeof VertexModelSchema>;
+
+export type LiteLLMSettings = z.infer<typeof LiteLLMSchema>;
+export type LiteLLMModel = z.infer<typeof LiteLLMModelSchema>;
+
+export type AnthropicSettings = z.infer<typeof AnthropicSchema>;
+export type AnthropicModel = z.infer<typeof AnthropicModelSchema>;
+
+export type APIKeySettings = z.infer<typeof APIKeySchema>;
+
+export type EnterpriseTelemetry = z.infer<typeof EnterpriseTelemetrySchema>;
+export type PromptUploading = z.infer<typeof PromptUploadingSchema>;
+export type S3AccessKeySettings = z.infer<typeof S3AccessKeySettingsSchema>;
diff --git a/sdk/packages/shared/src/remote-config/telemetry.ts b/sdk/packages/shared/src/remote-config/telemetry.ts
new file mode 100644
index 0000000..04f418e
--- /dev/null
+++ b/sdk/packages/shared/src/remote-config/telemetry.ts
@@ -0,0 +1,124 @@
+import type { OpenTelemetryClientConfig } from "../services/telemetry";
+import type {
+	RemoteConfigBundle,
+	RemoteConfigSyncContext,
+	RemoteConfigTelemetryAdapter,
+} from "./bundle";
+import type { RemoteConfig } from "./schema";
+
+export function resolveOpenTelemetryConfigFromRemoteConfig(
+	remoteConfig: RemoteConfig | undefined,
+): Partial<OpenTelemetryClientConfig> | undefined {
+	if (!remoteConfig) {
+		return undefined;
+	}
+	return {
+		enabled: remoteConfig.openTelemetryEnabled ?? false,
+		metricsExporter: remoteConfig.openTelemetryMetricsExporter,
+		logsExporter: remoteConfig.openTelemetryLogsExporter,
+		otlpProtocol: remoteConfig.openTelemetryOtlpProtocol,
+		otlpEndpoint: remoteConfig.openTelemetryOtlpEndpoint,
+		otlpHeaders: remoteConfig.openTelemetryOtlpHeaders,
+		otlpMetricsProtocol: remoteConfig.openTelemetryOtlpMetricsProtocol,
+		otlpMetricsEndpoint: remoteConfig.openTelemetryOtlpMetricsEndpoint,
+		otlpMetricsHeaders: remoteConfig.openTelemetryOtlpMetricsHeaders,
+		otlpLogsProtocol: remoteConfig.openTelemetryOtlpLogsProtocol,
+		otlpLogsEndpoint: remoteConfig.openTelemetryOtlpLogsEndpoint,
+		otlpLogsHeaders: remoteConfig.openTelemetryOtlpLogsHeaders,
+		metricExportInterval: remoteConfig.openTelemetryMetricExportInterval,
+		otlpInsecure: remoteConfig.openTelemetryOtlpInsecure,
+		logBatchSize: remoteConfig.openTelemetryLogBatchSize,
+		logBatchTimeout: remoteConfig.openTelemetryLogBatchTimeout,
+		logMaxQueueSize: remoteConfig.openTelemetryLogMaxQueueSize,
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readString(
+	record: Record<string, unknown>,
+	key: keyof OpenTelemetryClientConfig,
+): string | undefined {
+	const value = record[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+function readBoolean(
+	record: Record<string, unknown>,
+	key: keyof OpenTelemetryClientConfig,
+): boolean | undefined {
+	const value = record[key];
+	return typeof value === "boolean" ? value : undefined;
+}
+
+function readNumber(
+	record: Record<string, unknown>,
+	key: keyof OpenTelemetryClientConfig,
+): number | undefined {
+	const value = record[key];
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function readStringRecord(
+	record: Record<string, unknown>,
+	key: "otlpHeaders" | "otlpMetricsHeaders" | "otlpLogsHeaders",
+): Record<string, string> | undefined {
+	const value = record[key];
+	if (!isRecord(value)) {
+		return undefined;
+	}
+	const entries = Object.entries(value).filter(
+		(entry): entry is [string, string] => typeof entry[1] === "string",
+	);
+	return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+export function normalizeBundleTelemetry(
+	telemetry: Record<string, unknown> | undefined,
+): Partial<OpenTelemetryClientConfig> | undefined {
+	if (!isRecord(telemetry)) {
+		return undefined;
+	}
+	const normalized: Partial<OpenTelemetryClientConfig> = {
+		enabled: readBoolean(telemetry, "enabled"),
+		metricsExporter: readString(telemetry, "metricsExporter"),
+		logsExporter: readString(telemetry, "logsExporter"),
+		otlpProtocol: readString(telemetry, "otlpProtocol"),
+		otlpEndpoint: readString(telemetry, "otlpEndpoint"),
+		otlpHeaders: readStringRecord(telemetry, "otlpHeaders"),
+		otlpMetricsProtocol: readString(telemetry, "otlpMetricsProtocol"),
+		otlpMetricsEndpoint: readString(telemetry, "otlpMetricsEndpoint"),
+		otlpMetricsHeaders: readStringRecord(telemetry, "otlpMetricsHeaders"),
+		otlpLogsProtocol: readString(telemetry, "otlpLogsProtocol"),
+		otlpLogsEndpoint: readString(telemetry, "otlpLogsEndpoint"),
+		otlpLogsHeaders: readStringRecord(telemetry, "otlpLogsHeaders"),
+		metricExportInterval: readNumber(telemetry, "metricExportInterval"),
+		otlpInsecure: readBoolean(telemetry, "otlpInsecure"),
+		logBatchSize: readNumber(telemetry, "logBatchSize"),
+		logBatchTimeout: readNumber(telemetry, "logBatchTimeout"),
+		logMaxQueueSize: readNumber(telemetry, "logMaxQueueSize"),
+	};
+	return Object.values(normalized).some((value) => value !== undefined)
+		? normalized
+		: undefined;
+}
+
+export class DefaultRemoteConfigTelemetryAdapter
+	implements RemoteConfigTelemetryAdapter
+{
+	name = "remote-config";
+
+	resolveTelemetry(
+		bundle: RemoteConfigBundle,
+		_context: RemoteConfigSyncContext,
+	): Partial<OpenTelemetryClientConfig> | undefined {
+		return {
+			...resolveOpenTelemetryConfigFromRemoteConfig(bundle.remoteConfig),
+			...normalizeBundleTelemetry(bundle.telemetry),
+		};
+	}
+}
diff --git a/sdk/packages/shared/src/rpc/index.ts b/sdk/packages/shared/src/rpc/index.ts
new file mode 100644
index 0000000..24b553a
--- /dev/null
+++ b/sdk/packages/shared/src/rpc/index.ts
@@ -0,0 +1,5 @@
+export const CLINE_HUB_PORT = 25463; // CLINE
+export const CLINE_HUB_DEV_PORT = 25466; // USED IN DEV ENV ONLY, to avoid conflicts with production CLINE HUB
+export const CLINE_DEFAULT_RPC_PORT = 4317;
+export const RPC_ADDRESS_BASE = "127.0.0.1";
+export const CLINE_DEFAULT_RPC_ADDRESS = `${RPC_ADDRESS_BASE}:${CLINE_DEFAULT_RPC_PORT}`;
diff --git a/sdk/packages/shared/src/rpc/runtime.ts b/sdk/packages/shared/src/rpc/runtime.ts
new file mode 100644
index 0000000..780d476
--- /dev/null
+++ b/sdk/packages/shared/src/rpc/runtime.ts
@@ -0,0 +1,427 @@
+import z from "zod";
+import type { HubToolExecutorName } from "../hub";
+import type {
+	RuntimeConfigExtensionKind,
+	SessionExecutionConfig,
+	SessionPromptConfig,
+} from "../session/runtime-config";
+
+export interface ChatRuntimeConfig extends SessionPromptConfig {
+	cwd?: string;
+	apiKey?: string;
+	logger?: RuntimeLoggerConfig;
+	enableTools: boolean;
+	enableSpawn?: boolean;
+	enableTeams?: boolean;
+	disableMcpSettingsTools?: boolean;
+	autoApproveTools?: boolean;
+	missionStepInterval?: number;
+	missionTimeIntervalMs?: number;
+	timeoutSeconds?: number;
+	toolPolicies?: SessionExecutionConfig["toolPolicies"];
+	toolExecutors?: HubToolExecutorName[];
+	configExtensions?: RuntimeConfigExtensionKind[];
+}
+
+export interface RuntimeLoggerConfig {
+	enabled?: boolean;
+	level?: "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "silent";
+	destination?: string;
+	name?: string;
+	bindings?: Record<string, string | number | boolean>;
+}
+
+export interface ChatStartSessionRequest extends ChatRuntimeConfig {
+	sessionId?: string;
+	workspaceRoot: string;
+	provider: string;
+	model: string;
+	source?: string;
+	interactive?: boolean;
+}
+
+export interface ChatStartSessionArtifacts {
+	sessionId: string;
+	manifestPath: string;
+	messagesPath: string;
+}
+
+export interface ChatStartSessionResponse {
+	sessionId: string;
+	startResult?: ChatStartSessionArtifacts;
+}
+
+export interface ChatAttachmentFile {
+	name: string;
+	content: string;
+}
+
+export interface ChatAttachments {
+	userImages?: string[];
+	userFiles?: ChatAttachmentFile[];
+}
+
+export interface ChatRunTurnRequest {
+	config: ChatStartSessionRequest;
+	prompt: string;
+	attachments?: ChatAttachments;
+	delivery?: "queue" | "steer";
+}
+
+export interface ChatToolCallResult {
+	name: string;
+	input?: unknown;
+	output?: unknown;
+	error?: string;
+	durationMs?: number;
+}
+
+export interface ChatTurnResult {
+	text: string;
+	usage: {
+		inputTokens: number;
+		outputTokens: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	};
+	inputTokens: number;
+	outputTokens: number;
+	iterations: number;
+	finishReason: string;
+	toolCalls: ChatToolCallResult[];
+}
+
+export interface EnterpriseContext {
+	projectId?: string;
+	workspaceId?: string;
+	organizationId?: string;
+}
+
+export interface EnterpriseAuthenticateRequest extends EnterpriseContext {
+	providerId: string;
+	workspacePath: string;
+	rootPath?: string;
+}
+
+export interface EnterpriseAuthenticateResponse {
+	providerId: string;
+	authenticated: boolean;
+	roles: string[];
+	claims?: Record<string, unknown>;
+	metadata?: Record<string, unknown>;
+}
+
+export interface EnterpriseSyncRequest extends EnterpriseContext {
+	providerId: string;
+	workspacePath: string;
+	rootPath?: string;
+	useCachedBundle?: boolean;
+}
+
+export interface EnterpriseSyncResponse {
+	providerId: string;
+	authenticated: boolean;
+	hasCachedBundle: boolean;
+	appliedConfigVersion?: string;
+	roles: string[];
+	hasTelemetryOverrides: boolean;
+	rulesCount: number;
+	workflowsCount: number;
+	skillsCount: number;
+	claims?: Record<string, unknown>;
+	metadata?: Record<string, unknown>;
+}
+
+export interface EnterpriseStatusRequest {
+	providerId: string;
+	workspacePath: string;
+	rootPath?: string;
+}
+
+export type EnterpriseStatusResponse = EnterpriseSyncResponse;
+
+export interface ProviderModel {
+	id: string;
+	name: string;
+	supportsAttachments?: boolean;
+	supportsVision?: boolean;
+	supportsReasoning?: boolean;
+}
+
+export type ProviderConfigFieldType =
+	| "text"
+	| "password"
+	| "url"
+	| "number"
+	| "select"
+	| "boolean";
+
+export type ProviderConfigFieldPrimitive = string | number | boolean | null;
+
+export interface ProviderConfigFieldOption {
+	label: string;
+	value: Exclude<ProviderConfigFieldPrimitive, null>;
+}
+
+export interface ProviderConfigField {
+	path: string;
+	label: string;
+	type: ProviderConfigFieldType;
+	description?: string;
+	placeholder?: string;
+	required?: boolean;
+	secret?: boolean;
+	options?: ProviderConfigFieldOption[];
+	defaultValue?: ProviderConfigFieldPrimitive;
+}
+
+export interface ProviderListItem {
+	id: string;
+	name: string;
+	models: number | null;
+	color: string;
+	letter: string;
+	enabled: boolean;
+	apiKey?: string;
+	oauthAccessTokenPresent?: boolean;
+	baseUrl?: string;
+	defaultModelId?: string;
+	protocol?: ProviderProtocol;
+	client?: ProviderClient;
+	capabilities?: ProviderCapability[];
+	authDescription: string;
+	baseUrlDescription: string;
+	configFields?: ProviderConfigField[];
+	configValues?: Record<string, ProviderConfigFieldPrimitive>;
+	modelList?: ProviderModel[];
+	family?: string;
+}
+
+export interface ProviderCatalogResponse {
+	providers: ProviderListItem[];
+	settingsPath: string;
+}
+
+export interface ProviderModelsResponse {
+	providerId: string;
+	models: ProviderModel[];
+}
+
+export const ProviderCapabilitySchema = z.enum([
+	"reasoning",
+	"prompt-cache",
+	// Allow SDK-provided tool schemas and runtime execution.
+	"tools",
+	// Provider manages its own built-in tools and does not accept SDK tools.
+	"provider-tools",
+	"oauth",
+	"temperature",
+	"files",
+	"streaming",
+	"vision",
+	"computer-use",
+	// Authenticate provider through local credentials store
+	"local-auth",
+	// Recommended as a common provider choice in picker UIs
+	"popular",
+]);
+
+export type ProviderCapability = z.infer<typeof ProviderCapabilitySchema>;
+
+export const ProviderProtocolSchema = z.enum([
+	"anthropic",
+	"gemini",
+	"openai-chat",
+	"openai-responses",
+	"openai-r1",
+	"ai-sdk",
+]);
+
+export type ProviderProtocol = z.infer<typeof ProviderProtocolSchema>;
+
+export const ProviderClientSchema = z.enum([
+	"anthropic",
+	"ai-sdk",
+	"ai-sdk-community",
+	"openai",
+	"openai-compatible",
+	"openai-r1",
+	"gemini",
+	"bedrock",
+	"custom",
+	"fetch",
+	"vertex",
+]);
+
+export type ProviderClient = z.infer<typeof ProviderClientSchema>;
+
+export interface ListProvidersActionRequest {
+	action: "listProviders";
+}
+
+export interface GetProviderModelsActionRequest {
+	action: "getProviderModels";
+	providerId: string;
+}
+
+export interface SaveProviderSettingsActionRequest {
+	action: "saveProviderSettings";
+	providerId: string;
+	enabled?: boolean;
+	// Authentication
+	apiKey?: string;
+	auth?: {
+		apiKey?: string;
+		accessToken?: string;
+		refreshToken?: string;
+		expiresAt?: number;
+		accountId?: string;
+	};
+	// Model configuration
+	model?: string;
+	protocol?: ProviderProtocol;
+	client?: ProviderClient;
+	routingProviderId?: string;
+	maxTokens?: number;
+	contextWindow?: number;
+	// Endpoint configuration
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	timeout?: number;
+	// Reasoning/thinking configuration
+	reasoning?: {
+		enabled?: boolean;
+		effort?: "none" | "low" | "medium" | "high" | "xhigh";
+		budgetTokens?: number;
+	};
+	// AWS/Bedrock configuration
+	aws?: {
+		accessKey?: string;
+		secretKey?: string;
+		sessionToken?: string;
+		region?: string;
+		profile?: string;
+		authentication?: "iam" | "api-key" | "apikey" | "profile";
+		usePromptCache?: boolean;
+		useCrossRegionInference?: boolean;
+		useGlobalInference?: boolean;
+		endpoint?: string;
+		customModelBaseId?: string;
+	};
+	// GCP/Vertex configuration
+	gcp?: {
+		projectId?: string;
+		region?: string;
+	};
+	// Azure configuration
+	azure?: {
+		apiVersion?: string;
+		useIdentity?: boolean;
+	};
+	// SAP AI Core configuration
+	sap?: {
+		clientId?: string;
+		clientSecret?: string;
+		tokenUrl?: string;
+		resourceGroup?: string;
+		deploymentId?: string;
+		useOrchestrationMode?: boolean;
+		api?: "orchestration" | "foundation-models";
+		defaultSettings?: Record<string, unknown>;
+	};
+	// OCA configuration
+	oca?: {
+		mode?: "internal" | "external";
+		usePromptCache?: boolean;
+	};
+	// Region configuration
+	region?: string;
+	apiLine?: "china" | "international";
+	// Capabilities
+	capabilities?: (
+		| "reasoning"
+		| "prompt-cache"
+		| "streaming"
+		| "tools"
+		| "vision"
+		| "computer-use"
+		| "oauth"
+	)[];
+}
+
+export interface AddProviderActionRequest {
+	action: "addProvider";
+	providerId: string;
+	name: string;
+	baseUrl: string;
+	apiKey?: string;
+	headers?: Record<string, string>;
+	timeoutMs?: number;
+	models?: string[];
+	defaultModelId?: string;
+	modelsSourceUrl?: string;
+	protocol?: ProviderProtocol;
+	client?: ProviderClient;
+	capabilities?: ProviderCapability[];
+}
+
+export type ProviderSettingsActionRequest =
+	| ListProvidersActionRequest
+	| GetProviderModelsActionRequest
+	| SaveProviderSettingsActionRequest
+	| AddProviderActionRequest;
+
+export type ClineAccountActionRequest =
+	| {
+			action: "clineAccount";
+			operation: "fetchMe";
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchBalance";
+			userId?: string;
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchUsageTransactions";
+			userId?: string;
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchPaymentTransactions";
+			userId?: string;
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchUserOrganizations";
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchOrganizationBalance";
+			organizationId: string;
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchOrganizationUsageTransactions";
+			organizationId: string;
+			memberId?: string;
+	  }
+	| {
+			action: "clineAccount";
+			operation: "switchAccount";
+			organizationId?: string | null;
+	  }
+	| {
+			action: "clineAccount";
+			operation: "fetchFeaturebaseToken";
+	  };
+
+export type ProviderActionRequest =
+	| ProviderSettingsActionRequest
+	| ClineAccountActionRequest;
+
+export interface ProviderOAuthLoginResponse {
+	provider: string;
+	accessToken: string;
+}
diff --git a/sdk/packages/shared/src/rpc/team-progress.ts b/sdk/packages/shared/src/rpc/team-progress.ts
new file mode 100644
index 0000000..8c0a5d6
--- /dev/null
+++ b/sdk/packages/shared/src/rpc/team-progress.ts
@@ -0,0 +1,71 @@
+export const TEAM_PROGRESS_EVENT_TYPE = "runtime.team.progress.v1";
+export const TEAM_LIFECYCLE_EVENT_TYPE = "runtime.team.lifecycle.v1";
+
+export type TeamProgressMemberRole = "lead" | "teammate";
+export type TeamProgressMemberStatus = "idle" | "running" | "stopped";
+export type TeamProgressTaskStatus =
+	| "pending"
+	| "in_progress"
+	| "blocked"
+	| "completed";
+export type TeamProgressRunStatus =
+	| "queued"
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "interrupted";
+export type TeamProgressOutcomeStatus = "draft" | "in_review" | "finalized";
+export type TeamProgressOutcomeFragmentStatus =
+	| "draft"
+	| "reviewed"
+	| "rejected";
+
+export interface TeamProgressCounts<TStatus extends string> {
+	total: number;
+	byStatus: Record<TStatus, number>;
+}
+
+export interface TeamProgressSummary {
+	teamName: string;
+	updatedAt: string;
+	members: TeamProgressCounts<TeamProgressMemberStatus> & {
+		leadCount: number;
+		teammateCount: number;
+	};
+	tasks: TeamProgressCounts<TeamProgressTaskStatus> & {
+		blockedTaskIds: string[];
+		readyTaskIds: string[];
+		completionPct: number;
+	};
+	runs: TeamProgressCounts<TeamProgressRunStatus> & {
+		activeRunIds: string[];
+		latestRunId?: string;
+	};
+	outcomes: TeamProgressCounts<TeamProgressOutcomeStatus> & {
+		finalizedPct: number;
+		missingRequiredSections: string[];
+	};
+	fragments: TeamProgressCounts<TeamProgressOutcomeFragmentStatus>;
+}
+
+export interface TeamProgressLifecycleEvent {
+	teamName: string;
+	sessionId: string;
+	eventType: string;
+	ts: string;
+	agentId?: string;
+	taskId?: string;
+	runId?: string;
+	outcomeId?: string;
+	fragmentId?: string;
+	message?: string;
+}
+
+export interface TeamProgressProjectionEvent {
+	type: "team_progress_projection";
+	version: 1;
+	sessionId: string;
+	summary: TeamProgressSummary;
+	lastEvent: TeamProgressLifecycleEvent;
+}
diff --git a/sdk/packages/shared/src/runtime/build-env.test.ts b/sdk/packages/shared/src/runtime/build-env.test.ts
new file mode 100644
index 0000000..8837123
--- /dev/null
+++ b/sdk/packages/shared/src/runtime/build-env.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import {
+	augmentNodeCommandForDebug,
+	CLINE_BUILD_ENV_ENV,
+	CLINE_DEBUG_HOST_ENV,
+	CLINE_DEBUG_PORT_BASE_ENV,
+	resolveClineBuildEnv,
+	withResolvedClineBuildEnv,
+} from "./build-env";
+
+describe("build env helpers", () => {
+	it("prefers explicit CLINE_BUILD_ENV", () => {
+		expect(
+			resolveClineBuildEnv({
+				env: { [CLINE_BUILD_ENV_ENV]: "development", NODE_ENV: "production" },
+			}),
+		).toBe("development");
+	});
+
+	it("treats development conditions as a development build", () => {
+		expect(
+			resolveClineBuildEnv({
+				env: {},
+				execArgv: ["--conditions=development"],
+			}),
+		).toBe("development");
+	});
+
+	it("defaults to production otherwise", () => {
+		expect(resolveClineBuildEnv({ env: {}, execArgv: [] })).toBe("production");
+	});
+
+	it("treats NODE_ENV=development as a development build", () => {
+		expect(
+			resolveClineBuildEnv({ env: { NODE_ENV: "development" }, execArgv: [] }),
+		).toBe("development");
+	});
+
+	it("does not treat NODE_ENV=test as a development build", () => {
+		expect(
+			resolveClineBuildEnv({ env: { NODE_ENV: "test" }, execArgv: [] }),
+		).toBe("production");
+	});
+
+	it("does not treat NODE_ENV=staging as a development build", () => {
+		expect(
+			resolveClineBuildEnv({ env: { NODE_ENV: "staging" }, execArgv: [] }),
+		).toBe("production");
+	});
+
+	it("materializes CLINE_BUILD_ENV when absent", () => {
+		expect(
+			withResolvedClineBuildEnv({ NODE_ENV: "development" }, { execArgv: [] })[
+				CLINE_BUILD_ENV_ENV
+			],
+		).toBe("development");
+	});
+
+	it("adds dynamic inspect and source maps for node commands in development", () => {
+		expect(
+			augmentNodeCommandForDebug(["node", "script.js"], {
+				env: { [CLINE_BUILD_ENV_ENV]: "development" },
+				debugRole: "rpc",
+			}),
+		).toEqual([
+			"node",
+			"--inspect=127.0.0.1:0",
+			"--enable-source-maps",
+			"script.js",
+		]);
+	});
+
+	it("allows overriding the debug host and base port", () => {
+		expect(
+			augmentNodeCommandForDebug(["node", "script.js"], {
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "development",
+					[CLINE_DEBUG_HOST_ENV]: "0.0.0.0",
+					[CLINE_DEBUG_PORT_BASE_ENV]: "9500",
+				},
+				debugRole: "plugin-sandbox",
+			}),
+		).toEqual([
+			"node",
+			"--inspect=0.0.0.0:9502",
+			"--enable-source-maps",
+			"script.js",
+		]);
+	});
+
+	it("adds inspect and source maps for bun commands in development", () => {
+		expect(
+			augmentNodeCommandForDebug(["/usr/local/bin/bun", "script.js"], {
+				env: { [CLINE_BUILD_ENV_ENV]: "development" },
+				debugRole: "rpc",
+			}),
+		).toEqual([
+			"/usr/local/bin/bun",
+			"--inspect=127.0.0.1:0",
+			"--enable-source-maps",
+			"script.js",
+		]);
+	});
+
+	it("does not duplicate existing node debug flags", () => {
+		expect(
+			augmentNodeCommandForDebug(["node", "--inspect=9229", "script.js"], {
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "development",
+					NODE_OPTIONS: "--enable-source-maps",
+				},
+			}),
+		).toEqual(["node", "--inspect=9229", "script.js"]);
+	});
+});
diff --git a/sdk/packages/shared/src/runtime/build-env.ts b/sdk/packages/shared/src/runtime/build-env.ts
new file mode 100644
index 0000000..76cf751
--- /dev/null
+++ b/sdk/packages/shared/src/runtime/build-env.ts
@@ -0,0 +1,183 @@
+import { basename } from "node:path";
+
+export const CLINE_BUILD_ENV_ENV = "CLINE_BUILD_ENV";
+export const CLINE_DEBUG_HOST_ENV = "CLINE_DEBUG_HOST";
+export const CLINE_DEBUG_PORT_BASE_ENV = "CLINE_DEBUG_PORT_BASE";
+
+export type ClineBuildEnv = "development" | "production";
+export type ClineDebugRole =
+	| "rpc"
+	| "hook"
+	| "plugin-sandbox"
+	| "connector"
+	| "sandbox";
+
+export interface ResolveClineBuildEnvOptions {
+	env?: NodeJS.ProcessEnv;
+	execArgv?: string[];
+	debugRole?: ClineDebugRole;
+}
+
+function normalizeBuildEnv(
+	value: string | undefined,
+): ClineBuildEnv | undefined {
+	const normalized = value?.trim().toLowerCase();
+	if (normalized === "development" || normalized === "production") {
+		return normalized;
+	}
+	return undefined;
+}
+
+function hasDevelopmentCondition(execArgv: string[]): boolean {
+	for (let index = 0; index < execArgv.length; index += 1) {
+		const value = execArgv[index]?.trim();
+		if (!value) {
+			continue;
+		}
+		if (
+			value === "--conditions" &&
+			execArgv[index + 1]?.trim() === "development"
+		) {
+			return true;
+		}
+		if (
+			value.startsWith("--conditions=") &&
+			value
+				.slice("--conditions=".length)
+				.split(",")
+				.map((entry) => entry.trim())
+				.includes("development")
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function isNodeLauncher(command: string | undefined): boolean {
+	if (!command?.trim()) {
+		return false;
+	}
+	const name = basename(command).toLowerCase();
+	return (
+		name === "node" ||
+		name === "node.exe" ||
+		name === "bun" ||
+		name === "bun.exe"
+	);
+}
+
+function hasInspectFlag(values: string[]): boolean {
+	return values.some(
+		(value) =>
+			value === "--inspect" ||
+			value.startsWith("--inspect=") ||
+			value === "--inspect-brk" ||
+			value.startsWith("--inspect-brk="),
+	);
+}
+
+function hasSourceMapFlag(values: string[]): boolean {
+	return values.some((value) => value === "--enable-source-maps");
+}
+
+function resolveDebugHost(env: NodeJS.ProcessEnv): string {
+	return env[CLINE_DEBUG_HOST_ENV]?.trim() || "127.0.0.1";
+}
+
+function resolveDebugPortBase(env: NodeJS.ProcessEnv): number | undefined {
+	const raw = env[CLINE_DEBUG_PORT_BASE_ENV]?.trim();
+	if (!raw) {
+		return undefined;
+	}
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function resolveRolePortOffset(role: ClineDebugRole | undefined): number {
+	switch (role) {
+		case "rpc":
+			return 0;
+		case "hook":
+			return 1;
+		case "plugin-sandbox":
+			return 2;
+		case "connector":
+			return 3;
+		case "sandbox":
+			return 4;
+		default:
+			return 9;
+	}
+}
+
+export function resolveClineBuildEnv(
+	options: ResolveClineBuildEnvOptions = {},
+): ClineBuildEnv {
+	const env = options.env ?? process.env;
+	const execArgv = options.execArgv ?? process.execArgv;
+
+	const explicit = normalizeBuildEnv(env[CLINE_BUILD_ENV_ENV]);
+	if (explicit) {
+		return explicit;
+	}
+
+	const nodeEnv = env.NODE_ENV?.trim().toLowerCase();
+	if (nodeEnv === "production") {
+		return "production";
+	}
+	if (nodeEnv === "development") {
+		return "development";
+	}
+
+	return hasDevelopmentCondition(execArgv) ? "development" : "production";
+}
+
+export function withResolvedClineBuildEnv(
+	env: NodeJS.ProcessEnv = process.env,
+	options: Omit<ResolveClineBuildEnvOptions, "env"> = {},
+): NodeJS.ProcessEnv {
+	if (normalizeBuildEnv(env[CLINE_BUILD_ENV_ENV])) {
+		return env;
+	}
+	return {
+		...env,
+		[CLINE_BUILD_ENV_ENV]: resolveClineBuildEnv({
+			env,
+			execArgv: options.execArgv,
+		}),
+	};
+}
+
+export function augmentNodeCommandForDebug(
+	command: string[],
+	options: ResolveClineBuildEnvOptions = {},
+): string[] {
+	if (command.length === 0 || !isNodeLauncher(command[0])) {
+		return [...command];
+	}
+	if (resolveClineBuildEnv(options) !== "development") {
+		return [...command];
+	}
+
+	const env = options.env ?? process.env;
+	const existingFlags = [
+		...(env.NODE_OPTIONS?.split(/\s+/).filter(Boolean) ?? []),
+		...command.slice(1),
+	];
+	const debugFlags: string[] = [];
+	if (!hasInspectFlag(existingFlags)) {
+		const host = resolveDebugHost(env);
+		const portBase = resolveDebugPortBase(env);
+		const port =
+			portBase === undefined
+				? 0
+				: portBase + resolveRolePortOffset(options.debugRole);
+		debugFlags.push(`--inspect=${host}:${port}`);
+	}
+	if (!hasSourceMapFlag(existingFlags)) {
+		debugFlags.push("--enable-source-maps");
+	}
+
+	return [command[0], ...debugFlags, ...command.slice(1)];
+}
diff --git a/sdk/packages/shared/src/runtime/cline-environment.test.ts b/sdk/packages/shared/src/runtime/cline-environment.test.ts
new file mode 100644
index 0000000..95ca772
--- /dev/null
+++ b/sdk/packages/shared/src/runtime/cline-environment.test.ts
@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	CLINE_ENVIRONMENT_ENV,
+	CLINE_ENVIRONMENT_OVERRIDE_ENV,
+	CLINE_ENVIRONMENTS,
+	DEFAULT_CLINE_ENVIRONMENT,
+	getClineEnvironmentConfig,
+	resolveClineEnvironment,
+} from "./cline-environment";
+
+const ENV_KEYS = [
+	CLINE_ENVIRONMENT_ENV,
+	CLINE_ENVIRONMENT_OVERRIDE_ENV,
+	"CLINE_API_BASE_URL",
+] as const;
+
+const originalEnvValues = Object.fromEntries(
+	ENV_KEYS.map((key) => [key, process.env[key]]),
+);
+
+beforeEach(() => {
+	vi.unstubAllGlobals();
+	for (const key of ENV_KEYS) {
+		delete process.env[key];
+	}
+});
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+	for (const key of ENV_KEYS) {
+		const value = originalEnvValues[key];
+		if (typeof value === "string") {
+			process.env[key] = value;
+		} else {
+			delete process.env[key];
+		}
+	}
+});
+
+describe("resolveClineEnvironment", () => {
+	it("defaults to production when no env var is set", () => {
+		expect(resolveClineEnvironment()).toBe(DEFAULT_CLINE_ENVIRONMENT);
+	});
+
+	it("reads CLINE_ENVIRONMENT from process.env", () => {
+		process.env[CLINE_ENVIRONMENT_ENV] = "staging";
+		expect(resolveClineEnvironment()).toBe("staging");
+
+		process.env[CLINE_ENVIRONMENT_ENV] = "local";
+		expect(resolveClineEnvironment()).toBe("local");
+	});
+
+	it("prefers CLINE_ENVIRONMENT_OVERRIDE over CLINE_ENVIRONMENT", () => {
+		process.env[CLINE_ENVIRONMENT_OVERRIDE_ENV] = "local";
+		process.env[CLINE_ENVIRONMENT_ENV] = "staging";
+
+		expect(resolveClineEnvironment()).toBe("local");
+	});
+
+	it("normalizes case and surrounding whitespace", () => {
+		process.env[CLINE_ENVIRONMENT_ENV] = "  STAGING  ";
+
+		expect(resolveClineEnvironment()).toBe("staging");
+	});
+
+	it("ignores unknown values and falls through to the next source", () => {
+		process.env[CLINE_ENVIRONMENT_OVERRIDE_ENV] = "qa";
+		process.env[CLINE_ENVIRONMENT_ENV] = "staging";
+		expect(resolveClineEnvironment()).toBe("staging");
+
+		delete process.env[CLINE_ENVIRONMENT_OVERRIDE_ENV];
+		process.env[CLINE_ENVIRONMENT_ENV] = "qa";
+		expect(resolveClineEnvironment()).toBe(DEFAULT_CLINE_ENVIRONMENT);
+	});
+
+	it("defaults to production when process is unavailable", () => {
+		vi.stubGlobal("process", undefined);
+
+		expect(resolveClineEnvironment()).toBe(DEFAULT_CLINE_ENVIRONMENT);
+	});
+});
+
+describe("getClineEnvironmentConfig", () => {
+	it("returns the config for an explicit environment", () => {
+		expect(getClineEnvironmentConfig("staging")).toBe(
+			CLINE_ENVIRONMENTS.staging,
+		);
+		expect(getClineEnvironmentConfig("local")).toBe(CLINE_ENVIRONMENTS.local);
+		expect(getClineEnvironmentConfig("production")).toBe(
+			CLINE_ENVIRONMENTS.production,
+		);
+	});
+
+	it("falls back to production by default", () => {
+		expect(getClineEnvironmentConfig()).toBe(CLINE_ENVIRONMENTS.production);
+	});
+
+	it("uses the resolved process.env environment when no explicit environment is provided", () => {
+		process.env[CLINE_ENVIRONMENT_ENV] = "staging";
+
+		expect(getClineEnvironmentConfig()).toBe(CLINE_ENVIRONMENTS.staging);
+	});
+
+	it("applies CLINE_API_BASE_URL without mutating the catalog config", () => {
+		process.env.CLINE_API_BASE_URL = "http://127.0.0.1:3000";
+
+		expect(getClineEnvironmentConfig("local")).toEqual({
+			...CLINE_ENVIRONMENTS.local,
+			apiBaseUrl: "http://127.0.0.1:3000",
+			mcpBaseUrl: "http://127.0.0.1:3000/v1/mcp",
+		});
+		expect(CLINE_ENVIRONMENTS.local.apiBaseUrl).toBe("http://localhost:7777");
+	});
+
+	it("defaults to production when process is unavailable", () => {
+		vi.stubGlobal("process", undefined);
+
+		expect(getClineEnvironmentConfig()).toBe(CLINE_ENVIRONMENTS.production);
+	});
+});
+
+describe("CLINE_ENVIRONMENTS catalog", () => {
+	it("exposes an environment field that matches its key", () => {
+		for (const [key, config] of Object.entries(CLINE_ENVIRONMENTS)) {
+			expect(config.environment).toBe(key);
+		}
+	});
+
+	it("populates appBaseUrl, apiBaseUrl, and mcpBaseUrl for every environment", () => {
+		for (const config of Object.values(CLINE_ENVIRONMENTS)) {
+			expect(config.appBaseUrl).toMatch(/^https?:\/\//);
+			expect(config.apiBaseUrl).toMatch(/^https?:\/\//);
+			expect(config.mcpBaseUrl).toMatch(/^https?:\/\//);
+		}
+	});
+});
diff --git a/sdk/packages/shared/src/runtime/cline-environment.ts b/sdk/packages/shared/src/runtime/cline-environment.ts
new file mode 100644
index 0000000..612b340
--- /dev/null
+++ b/sdk/packages/shared/src/runtime/cline-environment.ts
@@ -0,0 +1,107 @@
+export const CLINE_ENVIRONMENT_ENV = "CLINE_ENVIRONMENT";
+export const CLINE_ENVIRONMENT_OVERRIDE_ENV = "CLINE_ENVIRONMENT_OVERRIDE";
+
+export type ClineEnvironment = "production" | "staging" | "local";
+
+export interface ClineEnvironmentConfig {
+	readonly environment: ClineEnvironment;
+	readonly appBaseUrl: string;
+	readonly apiBaseUrl: string;
+	readonly mcpBaseUrl: string;
+	readonly workOsClientId: string;
+}
+
+export const CLINE_ENVIRONMENTS: Readonly<
+	Record<ClineEnvironment, ClineEnvironmentConfig>
+> = {
+	production: {
+		environment: "production",
+		appBaseUrl: "https://app.cline.bot",
+		apiBaseUrl: "https://api.cline.bot",
+		mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+		workOsClientId: "client_01K3A541FN8TA3EPPHTD2325AR",
+	},
+	staging: {
+		environment: "staging",
+		appBaseUrl: "https://staging-app.cline.bot",
+		apiBaseUrl: "https://core-api.staging.int.cline.bot",
+		mcpBaseUrl: "https://core-api.staging.int.cline.bot/v1/mcp",
+		workOsClientId: "client_01K3A5415VF6QBQBG3XYCW91G6",
+	},
+	local: {
+		environment: "local",
+		appBaseUrl: "http://localhost:3000",
+		apiBaseUrl: "http://localhost:7777",
+		mcpBaseUrl: "http://localhost:7777/v1/mcp",
+		workOsClientId: "client_01K6XQAY7JK6T5HXVSZW2S5VYK",
+	},
+};
+
+export const DEFAULT_CLINE_ENVIRONMENT: ClineEnvironment = "production";
+
+export interface ResolveClineEnvironmentOptions {
+	env?: Partial<NodeJS.ProcessEnv>;
+}
+
+function normalizeClineEnvironment(
+	value: string | undefined,
+): ClineEnvironment | undefined {
+	const normalized = value?.trim().toLowerCase();
+	if (
+		normalized === "production" ||
+		normalized === "staging" ||
+		normalized === "local"
+	) {
+		return normalized;
+	}
+	return undefined;
+}
+
+function readProcessEnv(): NodeJS.ProcessEnv {
+	// `process` may be absent in browser-style runtimes (this module ships
+	// from the browser entry of `@cline/shared`). Treat its absence as "no
+	// env vars set" so callers always get a deterministic default.
+	if (typeof process === "undefined" || !process?.env) {
+		return {};
+	}
+	return process.env;
+}
+
+export function resolveClineEnvironment(): ClineEnvironment {
+	const env = readProcessEnv();
+	return (
+		normalizeClineEnvironment(env[CLINE_ENVIRONMENT_OVERRIDE_ENV]) ??
+		normalizeClineEnvironment(env[CLINE_ENVIRONMENT_ENV]) ??
+		DEFAULT_CLINE_ENVIRONMENT
+	);
+}
+
+function getEnvConfig(env?: ClineEnvironment) {
+	if (typeof env === "string") {
+		return CLINE_ENVIRONMENTS[env];
+	}
+	return CLINE_ENVIRONMENTS[resolveClineEnvironment()];
+}
+
+function applyConfigOverrides(
+	config: ClineEnvironmentConfig,
+	env: NodeJS.ProcessEnv,
+): ClineEnvironmentConfig {
+	if (env.CLINE_API_BASE_URL) {
+		config = {
+			...config,
+			apiBaseUrl: env.CLINE_API_BASE_URL,
+			mcpBaseUrl: `${env.CLINE_API_BASE_URL}/v1/mcp`,
+		};
+	}
+
+	return config;
+}
+
+export function getClineEnvironmentConfig(
+	env?: ClineEnvironment,
+): ClineEnvironmentConfig {
+	const config = getEnvConfig(env);
+
+	return applyConfigOverrides(config, readProcessEnv());
+}
diff --git a/sdk/packages/shared/src/runtime/hub-daemon-env.test.ts b/sdk/packages/shared/src/runtime/hub-daemon-env.test.ts
new file mode 100644
index 0000000..abf0308
--- /dev/null
+++ b/sdk/packages/shared/src/runtime/hub-daemon-env.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import {
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+	isHubDaemonProcess,
+} from "./hub-daemon-env";
+
+describe("hub daemon environment helpers", () => {
+	it("detects hub daemon mode from the shared sentinel", () => {
+		expect(
+			isHubDaemonProcess({
+				[CLINE_RUN_AS_HUB_DAEMON_ENV]: "1",
+			}),
+		).toBe(true);
+		expect(
+			isHubDaemonProcess({
+				[CLINE_RUN_AS_HUB_DAEMON_ENV]: "0",
+			}),
+		).toBe(false);
+	});
+});
diff --git a/sdk/packages/shared/src/runtime/hub-daemon-env.ts b/sdk/packages/shared/src/runtime/hub-daemon-env.ts
new file mode 100644
index 0000000..ab02f28
--- /dev/null
+++ b/sdk/packages/shared/src/runtime/hub-daemon-env.ts
@@ -0,0 +1,7 @@
+export const CLINE_RUN_AS_HUB_DAEMON_ENV = "CLINE_RUN_AS_HUB_DAEMON";
+
+export function isHubDaemonProcess(
+	env: Record<string, string | undefined> = process.env,
+): boolean {
+	return env[CLINE_RUN_AS_HUB_DAEMON_ENV] === "1";
+}
diff --git a/sdk/packages/shared/src/services/telemetry-config.ts b/sdk/packages/shared/src/services/telemetry-config.ts
new file mode 100644
index 0000000..02fd6a3
--- /dev/null
+++ b/sdk/packages/shared/src/services/telemetry-config.ts
@@ -0,0 +1,58 @@
+import { parseKeyPairsIntoRecord } from "../parse/headers/utils";
+import type { OpenTelemetryClientConfig, TelemetryMetadata } from "./telemetry";
+
+export interface ClineTelemetryServiceConfig extends OpenTelemetryClientConfig {
+	metadata: TelemetryMetadata;
+}
+
+function getTelemetryBuildTimeConfig(): OpenTelemetryClientConfig {
+	if (!process.env) {
+		return {
+			enabled: false,
+		};
+	}
+
+	return {
+		enabled:
+			process.env.OTEL_TELEMETRY_ENABLED === "1" ||
+			process.env.OTEL_TELEMETRY_ENABLED === "true",
+		metricsExporter: process.env.OTEL_METRICS_EXPORTER || "otlp",
+		logsExporter: process.env.OTEL_LOGS_EXPORTER || "otlp",
+		tracesExporter: process.env.OTEL_TRACES_EXPORTER,
+		otlpProtocol: process.env.OTEL_EXPORTER_OTLP_PROTOCOL || "http/json",
+		otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+		metricExportInterval: process.env.OTEL_METRIC_EXPORT_INTERVAL
+			? Number.parseInt(process.env.OTEL_METRIC_EXPORT_INTERVAL, 10)
+			: undefined,
+		otlpHeaders: process.env.OTEL_EXPORTER_OTLP_HEADERS
+			? parseKeyPairsIntoRecord(process.env.OTEL_EXPORTER_OTLP_HEADERS)
+			: undefined,
+	};
+}
+
+export function createClineTelemetryServiceMetadata(
+	overrides: Partial<TelemetryMetadata> = {},
+): TelemetryMetadata {
+	return {
+		extension_version: "unknown",
+		cline_type: "unknown",
+		platform: "terminal",
+		platform_version: process?.version || "unknown",
+		os_type: process?.platform || "unknown",
+		os_version:
+			process?.platform === "win32"
+				? (process?.env?.OS ?? "unknown")
+				: "unknown",
+		...overrides,
+	};
+}
+
+export function createClineTelemetryServiceConfig(
+	configOverrides: Partial<ClineTelemetryServiceConfig> = {},
+): ClineTelemetryServiceConfig {
+	return {
+		...getTelemetryBuildTimeConfig(),
+		...configOverrides,
+		metadata: createClineTelemetryServiceMetadata(configOverrides.metadata),
+	};
+}
diff --git a/sdk/packages/shared/src/services/telemetry.test.ts b/sdk/packages/shared/src/services/telemetry.test.ts
new file mode 100644
index 0000000..3b73134
--- /dev/null
+++ b/sdk/packages/shared/src/services/telemetry.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	captureSdkError,
+	normalizeSdkError,
+	SDK_ERROR_TELEMETRY_EVENT,
+} from "./telemetry";
+
+describe("SDK error telemetry", () => {
+	it("normalizes unknown errors with sanitized, bounded messages", () => {
+		const normalized = normalizeSdkError(
+			new Error(
+				"request failed: authorization=Bearer abc123 /Users/beatrix/project C:\\Users\\beatrix\\project C:/Users/beatrix/project",
+			),
+		);
+
+		expect(normalized.error_type).toBe("Error");
+		expect(String(normalized.error_message)).toContain("[redacted]");
+		expect(String(normalized.error_message)).not.toContain("beatrix");
+		expect(String(normalized.error_message)).not.toContain("abc123");
+	});
+
+	it("bounds sanitized error messages", () => {
+		const normalized = normalizeSdkError(new Error("x".repeat(100)), 48);
+
+		expect(normalized.error_message).toHaveLength(48);
+	});
+
+	it("captures canonical SDK error events with context", () => {
+		const telemetry = {
+			capture: vi.fn(),
+		};
+
+		captureSdkError(telemetry as never, {
+			component: "core",
+			operation: "session.shutdown",
+			error: Object.assign(new Error("boom"), { code: "EBOOM", status: 503 }),
+			severity: "warn",
+			context: {
+				sessionId: "s1",
+				component: "context",
+				operation: "context.operation",
+				severity: "fatal",
+				handled: false,
+				error_type: "ContextError",
+				error_message: "unsanitized context message",
+				error_code: "CONTEXT",
+				error_status: 400,
+			},
+		});
+
+		expect(telemetry.capture).toHaveBeenCalledWith({
+			event: SDK_ERROR_TELEMETRY_EVENT,
+			properties: expect.objectContaining({
+				component: "core",
+				operation: "session.shutdown",
+				severity: "warn",
+				handled: true,
+				error_type: "Error",
+				error_message: "boom",
+				error_code: "EBOOM",
+				error_status: 503,
+				sessionId: "s1",
+			}),
+		});
+	});
+});
diff --git a/sdk/packages/shared/src/services/telemetry.ts b/sdk/packages/shared/src/services/telemetry.ts
new file mode 100644
index 0000000..30422d7
--- /dev/null
+++ b/sdk/packages/shared/src/services/telemetry.ts
@@ -0,0 +1,340 @@
+export type TelemetryPrimitive = string | number | boolean | null | undefined;
+
+export type TelemetryValue =
+	| TelemetryPrimitive
+	| TelemetryObject
+	| TelemetryArray;
+
+export type TelemetryObject = { [key: string]: TelemetryValue };
+
+export type TelemetryArray = Array<TelemetryValue>;
+
+export type TelemetryProperties = TelemetryObject;
+
+const DEFAULT_ERROR_MESSAGE_LIMIT = 500;
+
+export type SdkTelemetryErrorComponent =
+	| "shared"
+	| "llms"
+	| "agents"
+	| "core"
+	| "cli"
+	| "vscode"
+	| "desktop"
+	| (string & {});
+
+export type SdkTelemetryErrorSeverity =
+	| "debug"
+	| "info"
+	| "warn"
+	| "error"
+	| "fatal";
+
+export interface CaptureSdkErrorInput {
+	component: SdkTelemetryErrorComponent;
+	operation: string;
+	error: unknown;
+	severity?: SdkTelemetryErrorSeverity;
+	handled?: boolean;
+	context?: TelemetryProperties;
+	event?: string;
+	messageLimit?: number;
+}
+
+export const AGENT_UNEXPECTED_REASONING_TOKENS_EVENT =
+	"agent.reasoning.unexpected_tokens";
+
+export interface CaptureAgentUnexpectedReasoningTokensInput {
+	sessionId?: string;
+	agentId: string;
+	runId?: string;
+	iteration: number;
+	providerId?: string;
+	modelId?: string;
+	requestedThinking: false;
+	reasoningTokenCount: number;
+}
+
+export interface TelemetryMetadata {
+	extension_version: string;
+	cline_type: string;
+	platform: string;
+	platform_version: string;
+	os_type: string;
+	os_version: string;
+	is_dev?: string;
+	is_remote_workspace?: boolean;
+}
+
+export interface ITelemetryService {
+	setDistinctId(distinctId?: string): void;
+	setMetadata(metadata: Partial<TelemetryMetadata>): void;
+	updateMetadata(metadata: Partial<TelemetryMetadata>): void;
+	setCommonProperties(properties: TelemetryProperties): void;
+	updateCommonProperties(properties: TelemetryProperties): void;
+	isEnabled(): boolean;
+	capture(input: { event: string; properties?: TelemetryProperties }): void;
+	captureRequired(event: string, properties?: TelemetryProperties): void;
+	recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+	flush(): Promise<void>;
+	dispose(): Promise<void>;
+}
+
+export const SDK_ERROR_TELEMETRY_EVENT = "sdk.error";
+
+export function captureAgentUnexpectedReasoningTokens(
+	telemetry: ITelemetryService | undefined,
+	input: CaptureAgentUnexpectedReasoningTokensInput,
+): void {
+	telemetry?.capture({
+		event: AGENT_UNEXPECTED_REASONING_TOKENS_EVENT,
+		properties: stripUndefinedTelemetryProperties({
+			sessionId: input.sessionId,
+			agentId: input.agentId,
+			runId: input.runId,
+			iteration: input.iteration,
+			providerId: input.providerId,
+			modelId: input.modelId,
+			requestedThinking: input.requestedThinking,
+			reasoningTokenCount: input.reasoningTokenCount,
+		}),
+	});
+}
+
+export function captureSdkError(
+	telemetry: ITelemetryService | undefined,
+	input: CaptureSdkErrorInput,
+): void {
+	if (!telemetry) {
+		return;
+	}
+	telemetry.capture({
+		event: input.event ?? SDK_ERROR_TELEMETRY_EVENT,
+		properties: buildSdkErrorProperties(input),
+	});
+}
+
+export function buildSdkErrorProperties(
+	input: CaptureSdkErrorInput,
+): TelemetryProperties {
+	return {
+		...(input.context ?? {}),
+		component: input.component,
+		operation: input.operation,
+		severity: input.severity ?? "error",
+		handled: input.handled ?? true,
+		...normalizeSdkError(input.error, input.messageLimit),
+	};
+}
+
+function stripUndefinedTelemetryProperties(
+	properties: TelemetryProperties,
+): TelemetryProperties {
+	const result: TelemetryProperties = {};
+	for (const [key, value] of Object.entries(properties)) {
+		if (value !== undefined) {
+			result[key] = value;
+		}
+	}
+	return result;
+}
+
+export function normalizeSdkError(
+	error: unknown,
+	messageLimit = DEFAULT_ERROR_MESSAGE_LIMIT,
+): TelemetryProperties {
+	const record = isRecord(error) ? error : undefined;
+	const errorObject = error instanceof Error ? error : undefined;
+	const message =
+		errorObject?.message ??
+		stringValue(record?.message) ??
+		(typeof error === "string" ? error : String(error));
+	const code = stringOrNumberValue(record?.code);
+	const status =
+		numberValue(record?.status) ??
+		numberValue(record?.statusCode) ??
+		numberValue(record?.responseStatus);
+
+	return {
+		error_type:
+			errorObject?.name?.trim() ||
+			stringValue(record?.name) ||
+			errorObject?.constructor?.name ||
+			"Error",
+		error_message: truncateTelemetryString(
+			sanitizeTelemetryErrorMessage(message),
+			messageLimit,
+		),
+		...(code !== undefined ? { error_code: code } : {}),
+		...(status !== undefined ? { error_status: status } : {}),
+	};
+}
+
+function sanitizeTelemetryErrorMessage(message: string): string {
+	return message
+		.replace(/(authorization=Bearer\s+)[^&\s]+/gi, "$1[redacted]")
+		.replace(
+			/(api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|password|secret)=([^&\s]+)/gi,
+			"$1=[redacted]",
+		)
+		.replace(/(Bearer\s+)[A-Za-z0-9._~+/-]+=*/gi, "$1[redacted]")
+		.replace(/\/Users\/[^/\s]+/g, "/Users/[redacted]")
+		.replace(/\/home\/[^/\s]+/g, "/home/[redacted]")
+		.replace(/([A-Za-z]:[\\/]+Users[\\/]+)[^\\/\s]+/g, "$1[redacted]");
+}
+
+function truncateTelemetryString(value: string, limit: number): string {
+	const normalizedLimit = Math.max(1, Math.floor(limit));
+	return value.length > normalizedLimit
+		? value.substring(0, normalizedLimit)
+		: value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function stringValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim().length > 0
+		? value
+		: undefined;
+}
+
+function stringOrNumberValue(value: unknown): string | number | undefined {
+	if (typeof value === "string" && value.trim().length > 0) {
+		return value;
+	}
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return value;
+	}
+	return undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+export interface OpenTelemetryClientConfig {
+	/**
+	 * Whether telemetry is enabled via OTEL_TELEMETRY_ENABLED
+	 */
+	enabled: boolean;
+
+	/**
+	 * Metrics exporter type(s) - can be comma-separated for multiple exporters
+	 * Examples: "console", "otlp", "prometheus", "console,otlp"
+	 */
+	metricsExporter?: string;
+
+	/**
+	 * Logs/events exporter type(s) - can be comma-separated for multiple exporters
+	 * Examples: "console", "otlp"
+	 */
+	logsExporter?: string;
+
+	/**
+	 * Distributed tracing exporter type(s) - comma-separated for multiple exporters.
+	 * Examples: "console", "otlp". When unset, no `TracerProvider` is registered.
+	 */
+	tracesExporter?: string;
+
+	/**
+	 * Protocol for OTLP exporters. SDK support is currently limited to "http/json".
+	 */
+	otlpProtocol?: string;
+
+	/**
+	 * General OTLP endpoint (used if specific endpoints not set)
+	 */
+	otlpEndpoint?: string;
+
+	/**
+	 * General OTLP headers
+	 */
+	otlpHeaders?: Record<string, string>;
+
+	/**
+	 * Metrics-specific OTLP protocol
+	 */
+	otlpMetricsProtocol?: string;
+
+	/**
+	 * Metrics-specific OTLP endpoint
+	 */
+	otlpMetricsEndpoint?: string;
+
+	otlpMetricsHeaders?: Record<string, string>;
+
+	/**
+	 * Logs-specific OTLP protocol
+	 */
+	otlpLogsProtocol?: string;
+
+	/**
+	 * Logs-specific OTLP endpoint
+	 */
+	otlpLogsEndpoint?: string;
+
+	otlpLogsHeaders?: Record<string, string>;
+
+	/**
+	 * Traces-specific OTLP protocol (SDK support is currently limited to "http/json")
+	 */
+	otlpTracesProtocol?: string;
+
+	/**
+	 * Traces-specific OTLP endpoint (defaults to {@link otlpEndpoint} when exporting OTLP traces)
+	 */
+	otlpTracesEndpoint?: string;
+
+	otlpTracesHeaders?: Record<string, string>;
+
+	/**
+	 * Metric export interval in milliseconds (for console exporter)
+	 */
+	metricExportInterval?: number;
+
+	/**
+	 * Whether to use insecure (non-TLS) connections for gRPC OTLP exporters
+	 * Set to "true" for local development without TLS
+	 * Default: false (uses TLS)
+	 */
+	otlpInsecure?: boolean;
+
+	/**
+	 * Maximum batch size for log records (default: 512)
+	 */
+	logBatchSize?: number;
+
+	/**
+	 * Maximum time to wait before exporting logs in milliseconds (default: 5000)
+	 */
+	logBatchTimeout?: number;
+
+	/**
+	 * Maximum queue size for log records (default: 2048)
+	 */
+	logMaxQueueSize?: number;
+}
diff --git a/sdk/packages/shared/src/session/hook-context.ts b/sdk/packages/shared/src/session/hook-context.ts
new file mode 100644
index 0000000..d80dd48
--- /dev/null
+++ b/sdk/packages/shared/src/session/hook-context.ts
@@ -0,0 +1,45 @@
+export interface HookSessionContext {
+	rootSessionId?: string;
+}
+
+export interface HookSessionContextLookup {
+	hookName?: string;
+	conversationId?: string;
+	agentId?: string;
+	parentAgentId?: string | null;
+}
+
+export type HookSessionContextProvider =
+	| HookSessionContext
+	| ((input?: HookSessionContextLookup) => HookSessionContext | undefined);
+
+function normalized(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function resolveHookSessionContext(
+	provider?: HookSessionContextProvider,
+	input?: HookSessionContextLookup,
+): HookSessionContext | undefined {
+	if (!provider) {
+		return undefined;
+	}
+	const context = typeof provider === "function" ? provider(input) : provider;
+	if (!context) {
+		return undefined;
+	}
+	const rootSessionId = normalized(context.rootSessionId);
+	if (!rootSessionId) {
+		return undefined;
+	}
+	return {
+		rootSessionId,
+	};
+}
+
+export function resolveRootSessionId(
+	context: HookSessionContext | undefined,
+): string | undefined {
+	return normalized(context?.rootSessionId);
+}
diff --git a/sdk/packages/shared/src/session/index.ts b/sdk/packages/shared/src/session/index.ts
new file mode 100644
index 0000000..9c01b14
--- /dev/null
+++ b/sdk/packages/shared/src/session/index.ts
@@ -0,0 +1,6 @@
+import { customAlphabet } from "nanoid";
+
+export function createSessionId(prefix = "", suffix = ""): string {
+	const nanoid = customAlphabet("1234567890abcdefghijklmnopqrstuvwxyz", 10);
+	return `${prefix}${Date.now()}_${nanoid(5)}${suffix}`;
+}
diff --git a/sdk/packages/shared/src/session/records.ts b/sdk/packages/shared/src/session/records.ts
new file mode 100644
index 0000000..8a3d7ac
--- /dev/null
+++ b/sdk/packages/shared/src/session/records.ts
@@ -0,0 +1,41 @@
+export const SESSION_STATUS_VALUES = [
+	"idle",
+	"running",
+	"pending",
+	"completed",
+	"failed",
+	"cancelled",
+] as const;
+
+export type SharedSessionStatus = (typeof SESSION_STATUS_VALUES)[number];
+
+export interface SessionLineage {
+	parentSessionId?: string;
+	agentId?: string;
+	parentAgentId?: string;
+	conversationId?: string;
+	isSubagent: boolean;
+}
+
+export interface SessionRuntimeRecordShape extends SessionLineage {
+	source: string;
+	pid?: number;
+	startedAt: string;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	status: SharedSessionStatus;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	hookPath?: string;
+	messagesPath?: string;
+	updatedAt: string;
+}
diff --git a/sdk/packages/shared/src/session/runtime-config.ts b/sdk/packages/shared/src/session/runtime-config.ts
new file mode 100644
index 0000000..6a722ec
--- /dev/null
+++ b/sdk/packages/shared/src/session/runtime-config.ts
@@ -0,0 +1,69 @@
+import type { ToolPolicy } from "../llms/tools";
+
+export type AgentMode = "act" | "plan" | "yolo" | "zen";
+export type RuntimeConfigExtensionKind =
+	| "rules"
+	| "skills"
+	| "workflows"
+	| "plugins";
+
+export const RUNTIME_CONFIG_EXTENSION_KINDS = [
+	"rules",
+	"skills",
+	"workflows",
+	"plugins",
+] as const satisfies readonly RuntimeConfigExtensionKind[];
+
+export const DEFAULT_RUNTIME_CONFIG_EXTENSIONS = RUNTIME_CONFIG_EXTENSION_KINDS;
+
+const RUNTIME_CONFIG_EXTENSION_KIND_SET = new Set<string>(
+	RUNTIME_CONFIG_EXTENSION_KINDS,
+);
+
+export function isRuntimeConfigExtensionKind(
+	value: unknown,
+): value is RuntimeConfigExtensionKind {
+	return (
+		typeof value === "string" && RUNTIME_CONFIG_EXTENSION_KIND_SET.has(value)
+	);
+}
+
+export function parseRuntimeConfigExtensions(
+	value: unknown,
+): RuntimeConfigExtensionKind[] | undefined {
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+	const extensions = value
+		.map((item) => (typeof item === "string" ? item.trim() : ""))
+		.filter(isRuntimeConfigExtensionKind);
+	return [...new Set(extensions)];
+}
+
+export function hasRuntimeConfigExtension(
+	extensions: ReadonlyArray<RuntimeConfigExtensionKind> | undefined,
+	kind: RuntimeConfigExtensionKind,
+): boolean {
+	return new Set(extensions ?? DEFAULT_RUNTIME_CONFIG_EXTENSIONS).has(kind);
+}
+
+export interface SessionPromptConfig {
+	mode?: AgentMode;
+	systemPrompt?: string;
+	rules?: string;
+	maxIterations?: number;
+}
+
+export interface SessionWorkspaceConfig {
+	cwd: string;
+	workspaceRoot?: string;
+}
+
+export interface SessionExecutionConfig {
+	enableTools: boolean;
+	teamName?: string;
+	missionLogIntervalSteps?: number;
+	missionLogIntervalMs?: number;
+	maxConsecutiveMistakes?: number;
+	toolPolicies?: Record<string, ToolPolicy>;
+}
diff --git a/sdk/packages/shared/src/session/runtime-env.ts b/sdk/packages/shared/src/session/runtime-env.ts
new file mode 100644
index 0000000..6e8d29b
--- /dev/null
+++ b/sdk/packages/shared/src/session/runtime-env.ts
@@ -0,0 +1,8 @@
+export interface RuntimeEnv {
+	name: string;
+	version: string;
+	platform: string;
+	platform_version: string;
+	os_type: string;
+	os_version: string;
+}
diff --git a/sdk/packages/shared/src/session/workspace.ts b/sdk/packages/shared/src/session/workspace.ts
new file mode 100644
index 0000000..24a5bcc
--- /dev/null
+++ b/sdk/packages/shared/src/session/workspace.ts
@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+export const WorkspaceInfoSchema = z.object({
+	rootPath: z.string().min(1),
+	hint: z.string().min(1).optional(),
+	associatedRemoteUrls: z.array(z.string().min(1)).optional(),
+	latestGitCommitHash: z.string().min(1).optional(),
+	latestGitBranchName: z.string().min(1).optional(),
+});
+
+export const WorkspaceManifestSchema = z.object({
+	currentWorkspacePath: z.string().min(1).optional(),
+	workspaces: z.record(z.string().min(1), WorkspaceInfoSchema),
+});
+
+export type WorkspaceManifest = z.infer<typeof WorkspaceManifestSchema>;
+
+export function emptyWorkspaceManifest(): WorkspaceManifest {
+	return { workspaces: {} };
+}
+
+export interface WorkspaceInfo {
+	rootPath: string;
+	hint?: string;
+	associatedRemoteUrls?: string[];
+	latestGitCommitHash?: string;
+	latestGitBranchName?: string;
+}
+
+export function upsertWorkspaceInfo(
+	manifest: WorkspaceManifest,
+	info: WorkspaceInfo,
+): WorkspaceManifest {
+	const nextManifest: WorkspaceManifest = {
+		...manifest,
+		workspaces: {
+			...manifest.workspaces,
+			[info.rootPath]: info,
+		},
+	};
+	if (!nextManifest.currentWorkspacePath) {
+		nextManifest.currentWorkspacePath = info.rootPath;
+	}
+	return WorkspaceManifestSchema.parse(nextManifest);
+}
diff --git a/sdk/packages/shared/src/storage/index.ts b/sdk/packages/shared/src/storage/index.ts
new file mode 100644
index 0000000..0774e96
--- /dev/null
+++ b/sdk/packages/shared/src/storage/index.ts
@@ -0,0 +1,50 @@
+export { resolveExistingFilePath } from "./path-resolution";
+export {
+	AGENT_CONFIG_DIRECTORY_NAME,
+	AGENTS_RULES_FILE_NAME,
+	CLINE_CONNECTOR_SETTINGS_FILE_NAME,
+	CLINE_MCP_SETTINGS_FILE_NAME,
+	type CronSpecsScope,
+	discoverPluginModulePaths,
+	ensureFileExists,
+	ensureHookLogDir,
+	ensureParentDir,
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	isPluginModulePath,
+	type ResolveCronSpecsDirOptions,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveAgentConfigSearchPaths,
+	resolveAgentsConfigDirPath,
+	resolveClineDataDir,
+	resolveClineDir,
+	resolveConfiguredPluginModulePaths,
+	resolveConnectorDataDir,
+	resolveConnectorSettingsPath,
+	resolveCronDbPath,
+	resolveCronEventsDir,
+	resolveCronReportsDir,
+	resolveCronSpecsDir,
+	resolveDbDataDir,
+	resolveDocumentsClineDirectoryPath,
+	resolveDocumentsExtensionPath,
+	resolveGlobalAgentsRulesPath,
+	resolveGlobalCronSpecsDir,
+	resolveGlobalSettingsPath,
+	resolveHooksConfigSearchPaths,
+	resolveMcpSettingsPath,
+	resolvePluginConfigSearchPaths,
+	resolvePluginModuleEntries,
+	resolveProviderSettingsPath,
+	resolveRulesConfigSearchPaths,
+	resolveSessionDataDir,
+	resolveSkillsConfigSearchPaths,
+	resolveTeamDataDir,
+	resolveWorkflowsConfigSearchPaths,
+	resolveWorkspaceCronSpecsDir,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	setClineDir,
+	setClineDirIfUnset,
+	setHomeDir,
+	setHomeDirIfUnset,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "./paths";
diff --git a/sdk/packages/shared/src/storage/path-resolution.test.ts b/sdk/packages/shared/src/storage/path-resolution.test.ts
new file mode 100644
index 0000000..abed643
--- /dev/null
+++ b/sdk/packages/shared/src/storage/path-resolution.test.ts
@@ -0,0 +1,63 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { resolveExistingFilePath } from "./path-resolution";
+
+describe("resolveExistingFilePath", () => {
+	it("returns the literal path when it already exists", () => {
+		const dir = mkdtempSync(join(tmpdir(), "path-resolution-literal-"));
+		const filePath = join(dir, "plain.txt");
+		writeFileSync(filePath, "hi");
+
+		expect(resolveExistingFilePath(filePath)).toBe(filePath);
+	});
+
+	it("returns undefined when the file truly does not exist", () => {
+		const dir = mkdtempSync(join(tmpdir(), "path-resolution-missing-"));
+		expect(resolveExistingFilePath(join(dir, "nope.txt"))).toBeUndefined();
+	});
+
+	it("resolves macOS screenshot paths with narrow no-break space before PM", () => {
+		// macOS Sonoma+ embeds U+202F before AM/PM. Callers often hand us a
+		// path with a regular space because clipboards / terminals collapse
+		// U+202F → U+0020 in transit.
+		const dir = mkdtempSync(join(tmpdir(), "path-resolution-nnbsp-pm-"));
+		const onDisk = "Screenshot 2026-05-12 at 4.42.48\u202FPM.png";
+		const requested = join(dir, "Screenshot 2026-05-12 at 4.42.48 PM.png");
+		writeFileSync(join(dir, onDisk), "hello");
+
+		expect(resolveExistingFilePath(requested)).toBe(join(dir, onDisk));
+	});
+
+	it("resolves macOS screenshot paths with lowercase am/pm (en_AU style)", () => {
+		const dir = mkdtempSync(join(tmpdir(), "path-resolution-nnbsp-am-"));
+		const onDisk = "Screenshot 2026-01-01 at 10.00.00\u202Fam.png";
+		const requested = join(dir, "Screenshot 2026-01-01 at 10.00.00 am.png");
+		writeFileSync(join(dir, onDisk), "hello");
+
+		expect(resolveExistingFilePath(requested)).toBe(join(dir, onDisk));
+	});
+
+	it("does not rewrite AM/PM text in directory components", () => {
+		const parentDir = mkdtempSync(join(tmpdir(), "path-resolution-dir-ampm-"));
+		const dir = join(parentDir, "my AM.photos");
+		mkdirSync(dir);
+		const onDisk = "Screenshot 2026-05-12 at 4.42.48\u202FPM.png";
+		const requested = join(dir, "Screenshot 2026-05-12 at 4.42.48 PM.png");
+		writeFileSync(join(dir, onDisk), "hello");
+
+		expect(resolveExistingFilePath(requested)).toBe(join(dir, onDisk));
+	});
+
+	it("falls back to a parent-directory scan for arbitrary Unicode-space mismatches", () => {
+		// Exercises the readdirSync fallback for cases the targeted
+		// variants don't cover (here U+00A0 in the middle of a name).
+		const dir = mkdtempSync(join(tmpdir(), "path-resolution-nbsp-mid-"));
+		const onDisk = "weird\u00a0name.png";
+		const requested = join(dir, "weird name.png");
+		writeFileSync(join(dir, onDisk), "hello");
+
+		expect(resolveExistingFilePath(requested)).toBe(join(dir, onDisk));
+	});
+});
diff --git a/sdk/packages/shared/src/storage/path-resolution.ts b/sdk/packages/shared/src/storage/path-resolution.ts
new file mode 100644
index 0000000..9668f04
--- /dev/null
+++ b/sdk/packages/shared/src/storage/path-resolution.ts
@@ -0,0 +1,114 @@
+/**
+ * Path-resolution helpers that tolerate Unicode variants commonly seen on
+ * macOS filenames (most notably U+202F NARROW NO-BREAK SPACE in screenshot
+ * timestamps like "Screenshot 2026-05-12 at 4.42.48\u202FPM.png").
+ *
+ * When such a path travels through clipboards, terminals, paste-decoders,
+ * or other layers that normalize whitespace, U+202F can collapse to a
+ * regular space (U+0020). The on-disk filename still contains U+202F, so
+ * a literal `fs.stat` / `fs.readFile` will fail with ENOENT.
+ *
+ * `resolveExistingFilePath` tries a small set of targeted variants and a
+ * last-resort parent-directory scan to recover the actual filename.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// Unicode whitespace code points that show up in macOS-generated filenames
+// (or get substituted away by clipboards / terminals).
+const UNICODE_SPACES_RE = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+const NARROW_NO_BREAK_SPACE = "\u202F";
+
+// Build a "canonical whitespace" key for comparing a pasted/typed path
+// against actual on-disk entries regardless of which exotic space variant
+// was used between segments.
+function collapseUnicodeWhitespace(name: string): string {
+	return name.normalize("NFC").replace(UNICODE_SPACES_RE, " ");
+}
+
+function tryMacOSAmPmVariant(filePath: string): string {
+	// macOS Sonoma+ inserts U+202F before AM/PM in screenshot names. Some
+	// locales (e.g. en_AU) emit lowercase am/pm; hence the /i flag.
+	const fileName = basename(filePath);
+	const variantName = fileName.replace(
+		/ (AM|PM)\./gi,
+		`${NARROW_NO_BREAK_SPACE}$1.`,
+	);
+	return variantName === fileName
+		? filePath
+		: join(dirname(filePath), variantName);
+}
+
+function tryNFDVariant(filePath: string): string {
+	// HFS+ / some APFS configurations store filenames decomposed. Users
+	// typically type or paste NFC. Try the NFD variant when the literal
+	// path didn't resolve.
+	return filePath.normalize("NFD");
+}
+
+function tryCurlyApostropheVariant(filePath: string): string {
+	// macOS uses U+2019 (right single quotation mark) in localized
+	// screenshot names like "Capture d'écran". Users typically type U+0027.
+	return filePath.replace(/'/g, "\u2019");
+}
+
+function scanDirForCanonicalMatch(filePath: string): string | undefined {
+	// Last-resort fallback: enumerate the parent directory and look for an
+	// entry whose canonical-whitespace form matches the requested basename.
+	// Catches arbitrary exotic-space mismatches the targeted variants
+	// above don't cover.
+	const dir = dirname(filePath);
+	const wanted = collapseUnicodeWhitespace(basename(filePath));
+	try {
+		for (const entry of readdirSync(dir)) {
+			if (collapseUnicodeWhitespace(entry) === wanted) {
+				return join(dir, entry);
+			}
+		}
+	} catch {
+		// Directory unreadable or missing -- nothing to fall back to.
+	}
+	return undefined;
+}
+
+/**
+ * Resolve a possibly-mangled file path to an actual on-disk entry.
+ *
+ * Returns the literal path when it already exists; otherwise tries a small
+ * set of macOS-specific variants (narrow no-break space before AM/PM, NFD
+ * normalization, curly apostrophe) before falling back to a parent-directory
+ * scan that compares filenames after collapsing exotic Unicode whitespace.
+ *
+ * Returns `undefined` when no matching file can be located.
+ */
+export function resolveExistingFilePath(filePath: string): string | undefined {
+	if (existsSync(filePath)) {
+		return filePath;
+	}
+
+	const amPmVariant = tryMacOSAmPmVariant(filePath);
+	if (amPmVariant !== filePath && existsSync(amPmVariant)) {
+		return amPmVariant;
+	}
+
+	const nfdVariant = tryNFDVariant(filePath);
+	if (nfdVariant !== filePath && existsSync(nfdVariant)) {
+		return nfdVariant;
+	}
+
+	const curlyVariant = tryCurlyApostropheVariant(filePath);
+	if (curlyVariant !== filePath && existsSync(curlyVariant)) {
+		return curlyVariant;
+	}
+
+	const nfdCurlyVariant = tryCurlyApostropheVariant(nfdVariant);
+	if (
+		nfdCurlyVariant !== nfdVariant &&
+		nfdCurlyVariant !== curlyVariant &&
+		existsSync(nfdCurlyVariant)
+	) {
+		return nfdCurlyVariant;
+	}
+
+	return scanDirForCanonicalMatch(filePath);
+}
diff --git a/sdk/packages/shared/src/storage/paths.home-dir.test.ts b/sdk/packages/shared/src/storage/paths.home-dir.test.ts
new file mode 100644
index 0000000..dda1423
--- /dev/null
+++ b/sdk/packages/shared/src/storage/paths.home-dir.test.ts
@@ -0,0 +1,61 @@
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+type EnvSnapshot = {
+	HOME: string | undefined;
+	USERPROFILE: string | undefined;
+	HOMEDRIVE: string | undefined;
+	HOMEPATH: string | undefined;
+	CLINE_DIR: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		HOME: process.env.HOME,
+		USERPROFILE: process.env.USERPROFILE,
+		HOMEDRIVE: process.env.HOMEDRIVE,
+		HOMEPATH: process.env.HOMEPATH,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.HOME = snapshot.HOME;
+	process.env.USERPROFILE = snapshot.USERPROFILE;
+	process.env.HOMEDRIVE = snapshot.HOMEDRIVE;
+	process.env.HOMEPATH = snapshot.HOMEPATH;
+	process.env.CLINE_DIR = snapshot.CLINE_DIR;
+}
+
+describe("storage home directory fallback", () => {
+	let snapshot: EnvSnapshot = captureEnv();
+
+	afterEach(() => {
+		restoreEnv(snapshot);
+		vi.resetModules();
+	});
+
+	it("uses USERPROFILE when HOME is unset", async () => {
+		snapshot = captureEnv();
+		delete process.env.HOME;
+		process.env.USERPROFILE = "C:\\Users\\saoud";
+		delete process.env.HOMEDRIVE;
+		delete process.env.HOMEPATH;
+		delete process.env.CLINE_DIR;
+
+		const { resolveClineDir } = await import("./paths");
+		expect(resolveClineDir()).toBe(join("C:\\Users\\saoud", ".cline"));
+	});
+
+	it("treats HOME=~ as unset and falls back to USERPROFILE", async () => {
+		snapshot = captureEnv();
+		process.env.HOME = "~";
+		process.env.USERPROFILE = "C:\\Users\\saoud";
+		delete process.env.HOMEDRIVE;
+		delete process.env.HOMEPATH;
+		delete process.env.CLINE_DIR;
+
+		const { resolveClineDir } = await import("./paths");
+		expect(resolveClineDir()).toBe(join("C:\\Users\\saoud", ".cline"));
+	});
+});
diff --git a/sdk/packages/shared/src/storage/paths.test.ts b/sdk/packages/shared/src/storage/paths.test.ts
new file mode 100644
index 0000000..41ee98c
--- /dev/null
+++ b/sdk/packages/shared/src/storage/paths.test.ts
@@ -0,0 +1,221 @@
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	AGENT_CONFIG_DIRECTORY_NAME,
+	CLINE_CONNECTOR_SETTINGS_FILE_NAME,
+	CLINE_MCP_SETTINGS_FILE_NAME,
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveAgentsConfigDirPath,
+	resolveClineDataDir,
+	resolveConnectorDataDir,
+	resolveConnectorSettingsPath,
+	resolveDbDataDir,
+	resolveGlobalAgentsRulesPath,
+	resolveGlobalSettingsPath,
+	resolveHooksConfigSearchPaths,
+	resolveMcpSettingsPath,
+	resolveProviderSettingsPath,
+	resolveRulesConfigSearchPaths,
+	resolveSessionDataDir,
+	resolveTeamDataDir,
+	resolveWorkflowsConfigSearchPaths,
+} from "./paths";
+
+type EnvSnapshot = {
+	CLINE_DIR: string | undefined;
+	CLINE_DATA_DIR: string | undefined;
+	CLINE_CONNECTOR_DATA_DIR: string | undefined;
+	CLINE_CONNECTOR_SETTINGS_PATH: string | undefined;
+	CLINE_DB_DATA_DIR: string | undefined;
+	CLINE_GLOBAL_SETTINGS_PATH: string | undefined;
+	CLINE_MCP_SETTINGS_PATH: string | undefined;
+	CLINE_PROVIDER_SETTINGS_PATH: string | undefined;
+	CLINE_SESSION_DATA_DIR: string | undefined;
+	CLINE_TEAM_DATA_DIR: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		CLINE_DIR: process.env.CLINE_DIR,
+		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+		CLINE_CONNECTOR_DATA_DIR: process.env.CLINE_CONNECTOR_DATA_DIR,
+		CLINE_CONNECTOR_SETTINGS_PATH: process.env.CLINE_CONNECTOR_SETTINGS_PATH,
+		CLINE_DB_DATA_DIR: process.env.CLINE_DB_DATA_DIR,
+		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
+		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
+		CLINE_PROVIDER_SETTINGS_PATH: process.env.CLINE_PROVIDER_SETTINGS_PATH,
+		CLINE_SESSION_DATA_DIR: process.env.CLINE_SESSION_DATA_DIR,
+		CLINE_TEAM_DATA_DIR: process.env.CLINE_TEAM_DATA_DIR,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.CLINE_DATA_DIR = snapshot.CLINE_DATA_DIR;
+	process.env.CLINE_CONNECTOR_DATA_DIR = snapshot.CLINE_CONNECTOR_DATA_DIR;
+	process.env.CLINE_CONNECTOR_SETTINGS_PATH =
+		snapshot.CLINE_CONNECTOR_SETTINGS_PATH;
+	process.env.CLINE_DIR = snapshot.CLINE_DIR;
+	process.env.CLINE_DB_DATA_DIR = snapshot.CLINE_DB_DATA_DIR;
+	process.env.CLINE_GLOBAL_SETTINGS_PATH = snapshot.CLINE_GLOBAL_SETTINGS_PATH;
+	process.env.CLINE_MCP_SETTINGS_PATH = snapshot.CLINE_MCP_SETTINGS_PATH;
+	process.env.CLINE_PROVIDER_SETTINGS_PATH =
+		snapshot.CLINE_PROVIDER_SETTINGS_PATH;
+	process.env.CLINE_SESSION_DATA_DIR = snapshot.CLINE_SESSION_DATA_DIR;
+	process.env.CLINE_TEAM_DATA_DIR = snapshot.CLINE_TEAM_DATA_DIR;
+}
+
+describe("storage path resolution", () => {
+	let snapshot: EnvSnapshot = captureEnv();
+
+	afterEach(() => {
+		restoreEnv(snapshot);
+	});
+
+	it("uses CLINE_DATA_DIR as-is when set", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveClineDataDir()).toBe("/tmp/cline-data");
+	});
+
+	it("falls back to CLINE_DATA_DIR/sessions for session storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_SESSION_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveSessionDataDir()).toBe(join("/tmp/cline-data", "sessions"));
+	});
+
+	it("falls back to CLINE_DATA_DIR/teams for team storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_TEAM_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveTeamDataDir()).toBe(join("/tmp/cline-data", "teams"));
+	});
+
+	it("falls back to CLINE_DATA_DIR/connectors for connector storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_CONNECTOR_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveConnectorDataDir()).toBe(
+			join("/tmp/cline-data", "connectors"),
+		);
+	});
+
+	it("falls back to CLINE_DATA_DIR/connectors/settings.json for connector settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_CONNECTOR_DATA_DIR;
+		delete process.env.CLINE_CONNECTOR_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveConnectorSettingsPath()).toBe(
+			join("/tmp/cline-data", "connectors", CLINE_CONNECTOR_SETTINGS_FILE_NAME),
+		);
+	});
+
+	it("uses CLINE_CONNECTOR_SETTINGS_PATH as-is when set", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_CONNECTOR_SETTINGS_PATH =
+			"/tmp/cline-connectors/custom-settings.json";
+
+		expect(resolveConnectorSettingsPath()).toBe(
+			"/tmp/cline-connectors/custom-settings.json",
+		);
+	});
+
+	it("falls back to CLINE_DATA_DIR/db for sqlite storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_DB_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveDbDataDir()).toBe(join("/tmp/cline-data", "db"));
+	});
+
+	it("falls back to CLINE_DATA_DIR/settings/providers.json for provider settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_PROVIDER_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveProviderSettingsPath()).toBe(
+			join("/tmp/cline-data", "settings", "providers.json"),
+		);
+	});
+
+	it("falls back to CLINE_DATA_DIR/settings/global-settings.json for global settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveGlobalSettingsPath()).toBe(
+			join("/tmp/cline-data", "settings", "global-settings.json"),
+		);
+	});
+
+	it("falls back to CLINE_DATA_DIR/settings/cline_mcp_settings.json for MCP settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_MCP_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveMcpSettingsPath()).toBe(
+			join("/tmp/cline-data", "settings", CLINE_MCP_SETTINGS_FILE_NAME),
+		);
+	});
+
+	it("falls back to ~/.cline/.agents for agent configs", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+
+		expect(resolveAgentsConfigDirPath()).toBe(
+			join("/tmp/home", ".cline", AGENT_CONFIG_DIRECTORY_NAME),
+		);
+	});
+
+	it("resolves global hooks from ~/.cline", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+		process.env.CLINE_DATA_DIR = "/tmp/home/.cline/data";
+
+		expect(resolveHooksConfigSearchPaths()).toEqual(
+			expect.arrayContaining([
+				join("/tmp/home", ".cline", HOOKS_CONFIG_DIRECTORY_NAME),
+			]),
+		);
+		expect(resolveHooksConfigSearchPaths()).not.toContain(
+			join("/tmp/home", ".cline", "data", HOOKS_CONFIG_DIRECTORY_NAME),
+		);
+	});
+
+	it("resolves global rules from ~/.cline", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+		process.env.CLINE_DATA_DIR = "/tmp/home/.cline/data";
+
+		expect(resolveRulesConfigSearchPaths()).toEqual(
+			expect.arrayContaining([
+				resolveGlobalAgentsRulesPath(),
+				join("/tmp/home", ".cline", RULES_CONFIG_DIRECTORY_NAME),
+			]),
+		);
+		expect(resolveRulesConfigSearchPaths()).not.toContain(
+			join("/tmp/home", ".cline", "data", RULES_CONFIG_DIRECTORY_NAME),
+		);
+	});
+
+	it("resolves legacy and new workflow paths, with .cline paths later for duplicate-name precedence", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+		const workspacePath = "/repo/demo";
+
+		const paths = resolveWorkflowsConfigSearchPaths(workspacePath);
+
+		expect(paths).toEqual([
+			join(workspacePath, ".clinerules", "workflows"),
+			expect.stringContaining(join("Documents", "Cline", "Workflows")),
+			join("/tmp/home", ".cline", "workflows"),
+			join(workspacePath, ".cline", "workflows"),
+		]);
+	});
+});
diff --git a/sdk/packages/shared/src/storage/paths.ts b/sdk/packages/shared/src/storage/paths.ts
new file mode 100644
index 0000000..cbb3a4e
--- /dev/null
+++ b/sdk/packages/shared/src/storage/paths.ts
@@ -0,0 +1,605 @@
+import type { Dirent } from "node:fs";
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	statSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import type { PluginManifest } from "..";
+
+const DEPRECATED_CONFIG_DIR = ".clinerules";
+const CLINE_CONFIG_DIR = ".cline";
+const LEGACY_AGENT_SKILLS_CONFIG_DIR = ".agents";
+
+export const AGENT_CONFIG_DIRECTORY_NAME = "agents";
+export const HOOKS_CONFIG_DIRECTORY_NAME = "hooks";
+export const SKILLS_CONFIG_DIRECTORY_NAME = "skills";
+export const RULES_CONFIG_DIRECTORY_NAME = "rules";
+export const WORKFLOWS_CONFIG_DIRECTORY_NAME = "workflows";
+export const PLUGINS_DIRECTORY_NAME = "plugins";
+export const AGENTS_RULES_FILE_NAME = "AGENTS.md";
+
+export const CLINE_MCP_SETTINGS_FILE_NAME = "cline_mcp_settings.json";
+export const CLINE_CONNECTOR_SETTINGS_FILE_NAME = "settings.json";
+
+function resolveDefaultHomeDir(): string {
+	const envHome = process?.env?.HOME?.trim();
+	if (envHome && envHome !== "~") {
+		return envHome;
+	}
+	const envUserProfile = process?.env?.USERPROFILE?.trim();
+	if (envUserProfile) {
+		return envUserProfile;
+	}
+	const envHomeDrive = process?.env?.HOMEDRIVE?.trim();
+	const envHomePath = process?.env?.HOMEPATH?.trim();
+	if (envHomeDrive && envHomePath) {
+		return `${envHomeDrive}${envHomePath}`;
+	}
+	const osHomeDir = homedir().trim();
+	if (osHomeDir && osHomeDir !== "~") {
+		return osHomeDir;
+	}
+	return "~";
+}
+
+let HOME_DIR = resolveDefaultHomeDir();
+let HOME_DIR_SET_EXPLICITLY = false;
+
+export function setHomeDir(dir: string) {
+	const trimmed = dir.trim();
+	if (!trimmed) {
+		return;
+	}
+	HOME_DIR = trimmed;
+	HOME_DIR_SET_EXPLICITLY = true;
+}
+
+export function setHomeDirIfUnset(dir: string) {
+	if (HOME_DIR_SET_EXPLICITLY) {
+		return;
+	}
+	const trimmed = dir.trim();
+	if (!trimmed) {
+		return;
+	}
+	HOME_DIR = trimmed;
+}
+
+let CLINE_DIR: string | undefined;
+let CLINE_DIR_SET_EXPLICITLY = false;
+
+export function setClineDir(dir: string): void {
+	const trimmed = dir.trim();
+	if (!trimmed) {
+		return;
+	}
+	CLINE_DIR = trimmed;
+	CLINE_DIR_SET_EXPLICITLY = true;
+}
+
+export function setClineDirIfUnset(dir: string): void {
+	if (CLINE_DIR_SET_EXPLICITLY) {
+		return;
+	}
+	const trimmed = dir.trim();
+	if (!trimmed) {
+		return;
+	}
+	CLINE_DIR = trimmed;
+}
+
+export function resolveClineDir(): string {
+	if (CLINE_DIR) {
+		return CLINE_DIR;
+	}
+	const envDir = process.env.CLINE_DIR?.trim();
+	if (envDir) {
+		return envDir;
+	}
+	return join(HOME_DIR, ".cline");
+}
+
+export function resolveDocumentsClineDirectoryPath(): string {
+	return join(HOME_DIR, "Documents", "Cline");
+}
+
+type DocumentsExtensionName =
+	| "Agents"
+	| "Hooks"
+	| "Rules"
+	| "Workflows"
+	| "Plugins";
+
+export function resolveDocumentsExtensionPath(
+	name: DocumentsExtensionName,
+): string {
+	return join(resolveDocumentsClineDirectoryPath(), name);
+}
+
+export function resolveClineDataDir(): string {
+	const explicitDir = process.env.CLINE_DATA_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveClineDir(), "data");
+}
+
+export function resolveSessionDataDir(): string {
+	const explicitDir = process.env.CLINE_SESSION_DATA_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveClineDataDir(), "sessions");
+}
+
+export function resolveTeamDataDir(): string {
+	const explicitDir = process.env.CLINE_TEAM_DATA_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveClineDataDir(), "teams");
+}
+
+export function resolveConnectorDataDir(): string {
+	const explicitDir = process.env.CLINE_CONNECTOR_DATA_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveClineDataDir(), "connectors");
+}
+
+export function resolveConnectorSettingsPath(): string {
+	const explicitPath = process.env.CLINE_CONNECTOR_SETTINGS_PATH?.trim();
+	if (explicitPath) {
+		return explicitPath;
+	}
+	return join(resolveConnectorDataDir(), CLINE_CONNECTOR_SETTINGS_FILE_NAME);
+}
+
+export function resolveDbDataDir(): string {
+	const explicitDir = process.env.CLINE_DB_DATA_DIR?.trim();
+	if (explicitDir) {
+		return explicitDir;
+	}
+	return join(resolveClineDataDir(), "db");
+}
+
+/**
+ * Path to the dedicated cron/automation database.
+ * Lives alongside `sessions.db` but is a separate file so cron lifecycle,
+ * retention, and query patterns stay decoupled from session storage.
+ */
+export function resolveCronDbPath(): string {
+	const explicitPath = process.env.CLINE_CRON_DB_PATH?.trim();
+	if (explicitPath) {
+		return explicitPath;
+	}
+	return join(resolveDbDataDir(), "cron.db");
+}
+
+export type CronSpecsScope = "global" | "workspace";
+
+export interface ResolveCronSpecsDirOptions {
+	/**
+	 * Explicit specs directory. Useful for tests and for future hosts that want
+	 * to provide their own merged/global/workspace cron source root.
+	 */
+	cronSpecsDir?: string;
+	/** Defaults to `global`, i.e. `~/.cline/cron`. */
+	scope?: CronSpecsScope;
+	/** Required when `scope` is `workspace`. */
+	workspaceRoot?: string;
+}
+
+/**
+ * Global file-based cron spec authoring directory:
+ *   `~/.cline/cron/`
+ */
+export function resolveGlobalCronSpecsDir(): string {
+	return join(resolveClineDir(), "cron");
+}
+
+/**
+ * Workspace file-based cron spec authoring directory reserved for future
+ * workspace-scoped automation support:
+ *   `${workspaceRoot}/.cline/cron/`
+ */
+export function resolveWorkspaceCronSpecsDir(workspaceRoot: string): string {
+	return join(workspaceRoot, ".cline", "cron");
+}
+
+/**
+ * Directory containing file-based cron spec authoring.
+ *
+ * Default: global `~/.cline/cron/`.
+ * One-off: `*.md`
+ * Recurring: `*.cron.md`
+ * Event-driven: `events/*.event.md`
+ *
+ * A string argument is retained as a deprecated compatibility shorthand for
+ * workspace scope. New code should pass `{ scope: "workspace", workspaceRoot }`
+ * or use `resolveWorkspaceCronSpecsDir(workspaceRoot)` directly.
+ */
+export function resolveCronSpecsDir(workspaceRoot: string): string;
+export function resolveCronSpecsDir(
+	options?: ResolveCronSpecsDirOptions,
+): string;
+export function resolveCronSpecsDir(
+	input?: string | ResolveCronSpecsDirOptions,
+): string {
+	if (typeof input === "string") {
+		return resolveWorkspaceCronSpecsDir(input);
+	}
+	if (input?.cronSpecsDir?.trim()) {
+		return input.cronSpecsDir.trim();
+	}
+	if (input?.scope === "workspace") {
+		const workspaceRoot = input.workspaceRoot?.trim();
+		if (!workspaceRoot) {
+			throw new Error("workspaceRoot is required for workspace cron scope");
+		}
+		return resolveWorkspaceCronSpecsDir(workspaceRoot);
+	}
+	return resolveGlobalCronSpecsDir();
+}
+
+/** Directory where per-run markdown reports are written. */
+export function resolveCronReportsDir(workspaceRoot: string): string;
+export function resolveCronReportsDir(
+	options?: ResolveCronSpecsDirOptions,
+): string;
+export function resolveCronReportsDir(
+	input?: string | ResolveCronSpecsDirOptions,
+): string {
+	return join(
+		resolveCronSpecsDir(input as ResolveCronSpecsDirOptions),
+		"reports",
+	);
+}
+
+/** Directory where event-spec files live inside the cron specs dir. */
+export function resolveCronEventsDir(workspaceRoot: string): string;
+export function resolveCronEventsDir(
+	options?: ResolveCronSpecsDirOptions,
+): string;
+export function resolveCronEventsDir(
+	input?: string | ResolveCronSpecsDirOptions,
+): string {
+	return join(
+		resolveCronSpecsDir(input as ResolveCronSpecsDirOptions),
+		"events",
+	);
+}
+
+export function resolveProviderSettingsPath(): string {
+	const explicitPath = process.env.CLINE_PROVIDER_SETTINGS_PATH?.trim();
+	if (explicitPath) {
+		return explicitPath;
+	}
+	return join(resolveClineDataDir(), "settings", "providers.json");
+}
+
+export function resolveGlobalSettingsPath(): string {
+	const explicitPath = process.env.CLINE_GLOBAL_SETTINGS_PATH?.trim();
+	if (explicitPath) {
+		return explicitPath;
+	}
+	return join(resolveClineDataDir(), "settings", "global-settings.json");
+}
+
+export function resolveMcpSettingsPath(): string {
+	const explicitPath = process.env.CLINE_MCP_SETTINGS_PATH?.trim();
+	if (explicitPath) {
+		return explicitPath;
+	}
+	return join(resolveClineDataDir(), "settings", CLINE_MCP_SETTINGS_FILE_NAME);
+}
+
+function dedupePaths(paths: ReadonlyArray<string>): string[] {
+	const seen = new Set<string>();
+	const deduped: string[] = [];
+	for (const candidate of paths) {
+		if (!candidate || seen.has(candidate)) {
+			continue;
+		}
+		seen.add(candidate);
+		deduped.push(candidate);
+	}
+	return deduped;
+}
+
+function getWorkspaceSkillDirectories(workspacePath?: string): string[] {
+	if (!workspacePath) {
+		return [];
+	}
+	return [
+		DEPRECATED_CONFIG_DIR,
+		CLINE_CONFIG_DIR,
+		LEGACY_AGENT_SKILLS_CONFIG_DIR,
+	].map((dir) => join(workspacePath, dir, SKILLS_CONFIG_DIRECTORY_NAME));
+}
+
+export function resolveAgentsConfigDirPath(): string {
+	return join(resolveClineDir(), AGENT_CONFIG_DIRECTORY_NAME);
+}
+
+export function resolveAgentConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return dedupePaths([
+		workspacePath
+			? join(workspacePath, CLINE_CONFIG_DIR, AGENT_CONFIG_DIRECTORY_NAME)
+			: "",
+		resolveAgentsConfigDirPath(),
+	]);
+}
+
+export function resolveHooksConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	const hooks = [
+		resolveDocumentsExtensionPath("Hooks"),
+		join(resolveClineDir(), HOOKS_CONFIG_DIRECTORY_NAME),
+	];
+	if (workspacePath) {
+		hooks.push(
+			join(workspacePath, DEPRECATED_CONFIG_DIR, HOOKS_CONFIG_DIRECTORY_NAME),
+			join(workspacePath, CLINE_CONFIG_DIR, HOOKS_CONFIG_DIRECTORY_NAME),
+		);
+	}
+	return dedupePaths(hooks);
+}
+
+export function resolveSkillsConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return dedupePaths([
+		...getWorkspaceSkillDirectories(workspacePath),
+		join(resolveClineDir(), SKILLS_CONFIG_DIRECTORY_NAME),
+		join(
+			HOME_DIR,
+			LEGACY_AGENT_SKILLS_CONFIG_DIR,
+			SKILLS_CONFIG_DIRECTORY_NAME,
+		),
+	]);
+}
+
+export function resolveGlobalAgentsRulesPath(): string {
+	return join(HOME_DIR, LEGACY_AGENT_SKILLS_CONFIG_DIR, AGENTS_RULES_FILE_NAME);
+}
+
+export function resolveRulesConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	const wsPaths = workspacePath
+		? [
+				join(workspacePath, DEPRECATED_CONFIG_DIR),
+				join(workspacePath, CLINE_CONFIG_DIR, RULES_CONFIG_DIRECTORY_NAME),
+			]
+		: [];
+	const workspaceAgentsFile = workspacePath
+		? [join(workspacePath, AGENTS_RULES_FILE_NAME)]
+		: [];
+	return dedupePaths([
+		...workspaceAgentsFile,
+		...wsPaths,
+		resolveGlobalAgentsRulesPath(),
+		join(resolveClineDir(), RULES_CONFIG_DIRECTORY_NAME),
+		resolveDocumentsExtensionPath("Rules"),
+	]);
+}
+
+export function resolveWorkflowsConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return dedupePaths([
+		workspacePath
+			? join(workspacePath, ".clinerules", WORKFLOWS_CONFIG_DIRECTORY_NAME)
+			: "",
+		resolveDocumentsExtensionPath("Workflows"),
+		join(resolveClineDir(), WORKFLOWS_CONFIG_DIRECTORY_NAME),
+		workspacePath
+			? join(workspacePath, ".cline", WORKFLOWS_CONFIG_DIRECTORY_NAME)
+			: "",
+	]);
+}
+
+export function resolvePluginConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return dedupePaths([
+		workspacePath ? join(workspacePath, ".cline", PLUGINS_DIRECTORY_NAME) : "",
+		join(resolveClineDir(), PLUGINS_DIRECTORY_NAME),
+		resolveDocumentsExtensionPath("Plugins"),
+	]);
+}
+
+const PLUGIN_MODULE_EXTENSIONS = new Set([".js", ".ts"]);
+const PLUGIN_PACKAGE_JSON_FILE_NAME = "package.json";
+const PLUGIN_DIRECTORY_INDEX_CANDIDATES = ["index.ts", "index.js"];
+
+interface PluginPackageManifest {
+	plugins?: PluginManifest[];
+}
+
+export function isPluginModulePath(path: string): boolean {
+	const dot = path.lastIndexOf(".");
+	if (dot === -1) {
+		return false;
+	}
+	return PLUGIN_MODULE_EXTENSIONS.has(path.slice(dot));
+}
+
+function readPluginPackageManifest(
+	packageJsonPath: string,
+): PluginPackageManifest | null {
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+			cline?: PluginPackageManifest;
+		};
+		if (!packageJson.cline || typeof packageJson.cline !== "object") {
+			return null;
+		}
+		return packageJson.cline;
+	} catch {
+		return null;
+	}
+}
+
+function getManifestPluginEntries(
+	manifest: PluginPackageManifest | null,
+): string[] {
+	const entries = manifest?.plugins;
+	if (!Array.isArray(entries)) {
+		return [];
+	}
+	return entries.flatMap((entry) => entry.paths ?? []);
+}
+
+export function resolvePluginModuleEntries(
+	directoryPath: string,
+): string[] | null {
+	const root = resolve(directoryPath);
+	if (!existsSync(root) || !statSync(root).isDirectory()) {
+		return null;
+	}
+
+	const packageJsonPath = join(root, PLUGIN_PACKAGE_JSON_FILE_NAME);
+	if (existsSync(packageJsonPath)) {
+		const manifest = readPluginPackageManifest(packageJsonPath);
+		const entries = getManifestPluginEntries(manifest)
+			.map((entry) => resolve(root, entry))
+			.filter(
+				(entryPath) =>
+					existsSync(entryPath) &&
+					statSync(entryPath).isFile() &&
+					isPluginModulePath(entryPath),
+			);
+		if (entries.length > 0) {
+			return entries;
+		}
+	}
+
+	for (const candidate of PLUGIN_DIRECTORY_INDEX_CANDIDATES) {
+		const entryPath = join(root, candidate);
+		if (existsSync(entryPath) && statSync(entryPath).isFile()) {
+			return [entryPath];
+		}
+	}
+
+	return null;
+}
+
+export function discoverPluginModulePaths(directoryPath: string): string[] {
+	const root = resolve(directoryPath);
+	if (!existsSync(root)) {
+		return [];
+	}
+	const discovered: string[] = [];
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current) {
+			continue;
+		}
+		let entries: Dirent[];
+		try {
+			entries = readdirSync(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const candidate = join(current, entry.name);
+			if (entry.isDirectory()) {
+				const packageJsonPath = join(candidate, PLUGIN_PACKAGE_JSON_FILE_NAME);
+				if (existsSync(packageJsonPath)) {
+					const manifest = readPluginPackageManifest(packageJsonPath);
+					const entries = getManifestPluginEntries(manifest)
+						.map((e) => resolve(candidate, e))
+						.filter(
+							(entryPath) =>
+								existsSync(entryPath) &&
+								statSync(entryPath).isFile() &&
+								isPluginModulePath(entryPath),
+						);
+					if (entries.length > 0) {
+						discovered.push(...entries);
+						continue;
+					}
+				}
+				stack.push(candidate);
+				continue;
+			}
+			if (entry.name.startsWith(".")) {
+				continue;
+			}
+			if (entry.isFile() && isPluginModulePath(candidate)) {
+				discovered.push(candidate);
+			}
+		}
+	}
+	return discovered.sort((a, b) => a.localeCompare(b));
+}
+
+export function resolveConfiguredPluginModulePaths(
+	pluginPaths: ReadonlyArray<string>,
+	cwd: string,
+): string[] {
+	const resolvedPaths: string[] = [];
+	for (const pluginPath of pluginPaths) {
+		const trimmed = pluginPath.trim();
+		if (!trimmed) {
+			continue;
+		}
+		const absolutePath = resolve(cwd, trimmed);
+		if (!existsSync(absolutePath)) {
+			throw new Error(`Plugin path does not exist: ${absolutePath}`);
+		}
+		const stats = statSync(absolutePath);
+		if (stats.isDirectory()) {
+			const entries = resolvePluginModuleEntries(absolutePath);
+			if (entries) {
+				resolvedPaths.push(...entries);
+				continue;
+			}
+			resolvedPaths.push(...discoverPluginModulePaths(absolutePath));
+			continue;
+		}
+		if (!isPluginModulePath(absolutePath)) {
+			throw new Error(
+				`Plugin file must use a supported extension (${[...PLUGIN_MODULE_EXTENSIONS].join(", ")}): ${absolutePath}`,
+			);
+		}
+		resolvedPaths.push(absolutePath);
+	}
+	return resolvedPaths;
+}
+
+export function ensureParentDir(filePath: string): void {
+	const parent = dirname(filePath);
+	if (!existsSync(parent)) {
+		mkdirSync(parent, { recursive: true });
+	}
+}
+
+export function ensureFileExists(filePath: string): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	appendFileSync(filePath, "");
+}
+
+export function ensureHookLogDir(filePath?: string): string {
+	if (filePath?.trim()) {
+		ensureParentDir(filePath);
+		return dirname(filePath);
+	}
+	const dir = join(resolveClineDataDir(), "logs");
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+	return dir;
+}
diff --git a/sdk/packages/shared/src/team/index.ts b/sdk/packages/shared/src/team/index.ts
new file mode 100644
index 0000000..cf89995
--- /dev/null
+++ b/sdk/packages/shared/src/team/index.ts
@@ -0,0 +1,2 @@
+export * from "./schema";
+export * from "./types";
diff --git a/sdk/packages/shared/src/team/schema.ts b/sdk/packages/shared/src/team/schema.ts
new file mode 100644
index 0000000..7c58ab2
--- /dev/null
+++ b/sdk/packages/shared/src/team/schema.ts
@@ -0,0 +1,452 @@
+/**
+ * Team tool schemas.
+ *
+ * Zod schemas, constants, and schema-derived types for the team tool surface.
+ */
+
+import { z } from "zod";
+
+export const DEFAULT_OUTCOME_REQUIRED_SECTIONS = [
+	"current_state",
+	"boundary_analysis",
+	"interface_proposal",
+];
+export const TEAM_AWAIT_TIMEOUT_MS = 60 * 60 * 1000;
+export const TEAM_RUN_MESSAGE_PREVIEW_LIMIT = 240;
+export const TEAM_RUN_TEXT_PREVIEW_LIMIT = 400;
+
+const IsoTimestampSchema = z.preprocess(
+	(value) => (value instanceof Date ? value.toISOString() : value),
+	z.string().datetime(),
+);
+
+const TeamTaskStatusSchema = z.enum([
+	"pending",
+	"in_progress",
+	"blocked",
+	"completed",
+]);
+
+const TeamRunStatusSchema = z.enum([
+	"queued",
+	"running",
+	"completed",
+	"failed",
+	"cancelled",
+	"interrupted",
+]);
+
+const TeamOutcomeStatusSchema = z.enum(["draft", "in_review", "finalized"]);
+
+const TeamMemberSnapshotSchema = z.object({
+	agentId: z.string(),
+	role: z.enum(["lead", "teammate"]),
+	description: z.string().optional(),
+	status: z.enum(["idle", "running", "stopped"]),
+});
+
+export const TeamTeammateSpecSchema = z.object({
+	agentId: z.string(),
+	rolePrompt: z.string(),
+	modelId: z.string().optional(),
+	maxIterations: z.number().optional(),
+});
+
+function nullableOptional<T extends z.ZodTypeAny>(schema: T) {
+	return z.preprocess(
+		(value) => (value === null ? undefined : value),
+		schema.optional(),
+	);
+}
+
+export const TeamSpawnTeammateInputSchema = z
+	.object({
+		agentId: z.string().min(1).describe("Teammate identifier"),
+		rolePrompt: z
+			.string()
+			.min(1)
+			.describe("System prompt describing teammate role"),
+	})
+	.strict();
+
+export const TeamShutdownTeammateInputSchema = z.object({
+	agentId: z.string().min(1).describe("Teammate identifier"),
+	reason: nullableOptional(z.string().min(1)).describe(
+		"Optional shutdown reason",
+	),
+});
+
+export const TeamStatusInputSchema = z.object({});
+
+const TEAM_TASK_REQUIRED_FIELDS_BY_ACTION = {
+	create: ["title", "description"],
+	list: [],
+	claim: ["taskId"],
+	complete: ["taskId", "summary"],
+	block: ["taskId", "reason"],
+} as const;
+
+type TeamTaskAction = "create" | "list" | "claim" | "complete" | "block";
+
+export const TEAM_TASK_IGNORED_FIELDS_BY_ACTION: Partial<
+	Record<TeamTaskAction, readonly string[]>
+> = {
+	create: ["status", "taskId", "summary", "reason"],
+} as const;
+
+export const TeamTaskInputSchema = z
+	.object({
+		action: z.enum(["create", "list", "claim", "complete", "block"]),
+		title: nullableOptional(z.string().min(1)).describe("Task title"),
+		description: nullableOptional(z.string().min(1)).describe("Task details"),
+		dependsOn: nullableOptional(
+			z.array(z.string().describe("Dependency task ID")),
+		).describe("Array of dependency task IDs"),
+		assignee: nullableOptional(z.string().min(1)).describe("Optional assignee"),
+		status: nullableOptional(
+			z.enum(["pending", "in_progress", "blocked", "completed"]),
+		).describe("Optional task status filter"),
+		taskId: nullableOptional(z.string()).describe("Task ID"),
+		summary: nullableOptional(z.string().min(1)).describe("Completion summary"),
+		reason: nullableOptional(z.string().min(1)).describe("Blocking reason"),
+	})
+	.superRefine((input, ctx) => {
+		for (const field of TEAM_TASK_REQUIRED_FIELDS_BY_ACTION[input.action]) {
+			if (input[field] !== undefined) {
+				continue;
+			}
+			ctx.addIssue({
+				code: "custom",
+				path: [field],
+				message: `Field "${field}" is required when action=${input.action}`,
+			});
+		}
+	});
+
+export const TeamRunTaskInputSchema = z.object({
+	agentId: z.string().describe("Teammate agent ID"),
+	task: z.string().min(1).describe("Task instructions for the teammate"),
+	taskId: nullableOptional(z.string()).describe("Optional shared task list ID"),
+	runMode: nullableOptional(z.enum(["sync", "async"])).describe(
+		"Execution mode: 'sync' blocks until the teammate finishes and returns the result (default if omitted); 'async' queues the run and returns a runId immediately — use team_await_runs to collect results later.",
+	),
+	continueConversation: nullableOptional(z.boolean()).describe(
+		"If true, continue the teammate conversation; otherwise start fresh",
+	),
+});
+
+export const TeamListRunsInputSchema = z.object({
+	status: nullableOptional(
+		z.enum([
+			"queued",
+			"running",
+			"completed",
+			"failed",
+			"cancelled",
+			"interrupted",
+		]),
+	).describe("Optional run status filter. Omit to include all statuses."),
+	agentId: nullableOptional(z.string().min(1)).describe(
+		"Optional teammate ID filter. Omit to include all teammates.",
+	),
+	includeCompleted: nullableOptional(z.boolean()).describe(
+		"Include completed/failed runs (default true)",
+	),
+});
+
+export const TeamCancelRunInputSchema = z.object({
+	runId: z.string().min(1).describe("Run ID"),
+	reason: nullableOptional(z.string().min(1)).describe(
+		"Optional cancellation reason",
+	),
+});
+
+export const TeamAwaitRunsInputSchema = z
+	.object({
+		runId: nullableOptional(z.string().min(1)).describe(
+			"Optional async run ID to await. Omit to wait for all active async runs.",
+		),
+	})
+	.strict();
+
+export const TeamSendMessageInputSchema = z.object({
+	toAgentId: z.string().min(1).describe("Recipient agent ID"),
+	subject: z.string().min(1).describe("Message subject"),
+	body: z.string().min(1).describe("Message body"),
+	taskId: nullableOptional(z.string().min(1)).describe(
+		"Optional task ID context",
+	),
+});
+
+export const TeamBroadcastInputSchema = z.object({
+	subject: z.string().min(1).describe("Message subject"),
+	body: z.string().min(1).describe("Message body"),
+	taskId: nullableOptional(z.string().min(1)).describe(
+		"Optional task ID context",
+	),
+});
+
+export const TeamReadMailboxInputSchema = z.object({
+	unreadOnly: nullableOptional(z.boolean()).describe(
+		"Only unread messages for read action (default true)",
+	),
+});
+
+export const TeamMissionLogInputSchema = z.object({
+	kind: z.enum(["progress", "handoff", "blocked", "decision", "done", "error"]),
+	summary: z.string().min(1).describe("Update summary"),
+	taskId: nullableOptional(z.string().min(1)).describe(
+		"Optional task ID context",
+	),
+	evidence: nullableOptional(z.array(z.string().min(1))).describe(
+		"Optional evidence links/snippets",
+	),
+	nextAction: nullableOptional(z.string().min(1)).describe("Planned next step"),
+});
+
+export const TeamCleanupInputSchema = z.object({});
+
+export const TeamCreateOutcomeInputSchema = z.object({
+	title: z.string().describe("Outcome title"),
+	requiredSections: z
+		.array(z.string())
+		.default(DEFAULT_OUTCOME_REQUIRED_SECTIONS)
+		.describe(
+			"Required sections for finalization gate (defaults to current_state,boundary_analysis,interface_proposal)",
+		),
+});
+
+export const TeamAttachOutcomeFragmentInputSchema = z.object({
+	outcomeId: z.string().describe("Outcome ID"),
+	section: z.string().describe("Section name"),
+	sourceRunId: nullableOptional(z.string()).describe("Optional source run ID"),
+	content: z.string().describe("Section fragment content"),
+});
+
+export const TeamReviewOutcomeFragmentInputSchema = z.object({
+	fragmentId: z.string().describe("Fragment ID"),
+	approved: z.boolean().describe("Review decision"),
+});
+
+export const TeamFinalizeOutcomeInputSchema = z.object({
+	outcomeId: z.string().describe("Outcome ID"),
+});
+
+export const TeamListOutcomesInputSchema = z.object({});
+
+export type TeamSpawnTeammateInput = z.infer<
+	typeof TeamSpawnTeammateInputSchema
+>;
+export type TeamShutdownTeammateInput = z.infer<
+	typeof TeamShutdownTeammateInputSchema
+>;
+export type TeamStatusInput = z.infer<typeof TeamStatusInputSchema>;
+export type TeamTaskInput = z.infer<typeof TeamTaskInputSchema>;
+export type TeamRunTaskInput = z.infer<typeof TeamRunTaskInputSchema>;
+export type TeamListRunsInput = z.infer<typeof TeamListRunsInputSchema>;
+export type TeamCancelRunInput = z.infer<typeof TeamCancelRunInputSchema>;
+export type TeamAwaitRunsInput = z.infer<typeof TeamAwaitRunsInputSchema>;
+export type TeamSendMessageInput = z.infer<typeof TeamSendMessageInputSchema>;
+export type TeamBroadcastInput = z.infer<typeof TeamBroadcastInputSchema>;
+export type TeamReadMailboxInput = z.infer<typeof TeamReadMailboxInputSchema>;
+export type TeamMissionLogInput = z.infer<typeof TeamMissionLogInputSchema>;
+export type TeamCleanupInput = z.infer<typeof TeamCleanupInputSchema>;
+export type TeamCreateOutcomeInput = z.infer<
+	typeof TeamCreateOutcomeInputSchema
+>;
+export type TeamAttachOutcomeFragmentInput = z.infer<
+	typeof TeamAttachOutcomeFragmentInputSchema
+>;
+export type TeamReviewOutcomeFragmentInput = z.infer<
+	typeof TeamReviewOutcomeFragmentInputSchema
+>;
+export type TeamFinalizeOutcomeInput = z.infer<
+	typeof TeamFinalizeOutcomeInputSchema
+>;
+export type TeamListOutcomesInput = z.infer<typeof TeamListOutcomesInputSchema>;
+
+export type TeamTeammateSpec = z.infer<typeof TeamTeammateSpecSchema>;
+
+export const TeamStatusToolResultSchema = z.object({
+	teamId: z.string(),
+	teamName: z.string(),
+	members: z.array(TeamMemberSnapshotSchema),
+	taskCounts: z.record(TeamTaskStatusSchema, z.number()),
+	unreadMessages: z.number(),
+	missionLogEntries: z.number(),
+	activeRuns: z.number(),
+	queuedRuns: z.number(),
+	outcomeCounts: z.record(TeamOutcomeStatusSchema, z.number()),
+});
+
+export const TeamTaskListItemToolResultSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	description: z.string(),
+	status: TeamTaskStatusSchema,
+	createdAt: IsoTimestampSchema,
+	updatedAt: IsoTimestampSchema,
+	createdBy: z.string(),
+	assignee: z.string().optional(),
+	dependsOn: z.array(z.string()),
+	summary: z.string().optional(),
+	isReady: z.boolean(),
+	blockedBy: z.array(z.string()),
+});
+
+export const TeamTaskToolResultSchema = z.discriminatedUnion("action", [
+	z.object({
+		action: z.literal("create"),
+		taskId: z.string(),
+		status: TeamTaskStatusSchema,
+		ignoredFields: z.array(z.string()).optional(),
+		note: z.string().optional(),
+	}),
+	z.object({
+		action: z.literal("list"),
+		tasks: z.array(TeamTaskListItemToolResultSchema),
+	}),
+	z.object({
+		action: z.literal("claim"),
+		taskId: z.string(),
+		status: TeamTaskStatusSchema,
+		nextStep: z.string(),
+	}),
+	z.object({
+		action: z.literal("complete"),
+		taskId: z.string(),
+		status: TeamTaskStatusSchema,
+	}),
+	z.object({
+		action: z.literal("block"),
+		taskId: z.string(),
+		status: TeamTaskStatusSchema,
+	}),
+]);
+
+export const TeamRunTaskToolResultSchema = z.object({
+	agentId: z.string(),
+	mode: z.enum(["sync", "async"]),
+	status: z.enum(["dispatched", "running", "queued", "joined"]),
+	dispatched: z.boolean(),
+	message: z.string(),
+	deduped: z.boolean().optional(),
+	runId: z.string().optional(),
+	text: z.string().optional(),
+	iterations: z.number().optional(),
+});
+
+export const TeamRunResultSummarySchema = z.object({
+	textPreview: z.string(),
+	iterations: z.number(),
+	finishReason: z.string(),
+	durationMs: z.number(),
+	usage: z.object({
+		inputTokens: z.number(),
+		outputTokens: z.number(),
+		cacheReadTokens: z.number().optional(),
+		cacheWriteTokens: z.number().optional(),
+		totalCost: z.number().optional(),
+	}),
+});
+
+export const TeamRunToolSummarySchema = z.object({
+	id: z.string(),
+	agentId: z.string(),
+	taskId: z.string().optional(),
+	status: TeamRunStatusSchema,
+	messagePreview: z.string(),
+	priority: z.number(),
+	retryCount: z.number(),
+	maxRetries: z.number(),
+	nextAttemptAt: IsoTimestampSchema.optional(),
+	continueConversation: z.boolean().optional(),
+	startedAt: IsoTimestampSchema,
+	endedAt: IsoTimestampSchema.optional(),
+	leaseOwner: z.string().optional(),
+	heartbeatAt: IsoTimestampSchema.optional(),
+	lastProgressAt: IsoTimestampSchema.optional(),
+	lastProgressMessage: z.string().optional(),
+	currentActivity: z.string().optional(),
+	error: z.string().optional(),
+	resultSummary: TeamRunResultSummarySchema.optional(),
+});
+
+export const TeamMailboxMessageToolResultSchema = z.object({
+	id: z.string(),
+	teamId: z.string(),
+	fromAgentId: z.string(),
+	toAgentId: z.string(),
+	subject: z.string(),
+	body: z.string(),
+	taskId: z.string().optional(),
+	sentAt: IsoTimestampSchema,
+	readAt: IsoTimestampSchema.optional(),
+});
+
+export const TeamOutcomeToolResultSchema = z.object({
+	id: z.string(),
+	teamId: z.string(),
+	title: z.string(),
+	status: TeamOutcomeStatusSchema,
+	requiredSections: z.array(z.string()),
+	createdBy: z.string(),
+	createdAt: IsoTimestampSchema,
+	finalizedAt: IsoTimestampSchema.optional(),
+});
+
+export const TeamCreateOutcomeToolResultSchema = z.object({
+	outcomeId: z.string(),
+	status: TeamOutcomeStatusSchema,
+	requiredSections: z.array(z.string()),
+});
+
+export const TeamSimpleAgentStatusToolResultSchema = z.object({
+	agentId: z.string(),
+	status: z.string(),
+});
+
+export const TeamCancelRunToolResultSchema = z.object({
+	runId: z.string(),
+	status: TeamRunStatusSchema,
+});
+
+export const TeamSendMessageToolResultSchema = z.object({
+	id: z.string(),
+	toAgentId: z.string(),
+});
+
+export const TeamBroadcastToolResultSchema = z.object({
+	delivered: z.number(),
+});
+
+export const TeamMissionLogToolResultSchema = z.object({
+	id: z.string(),
+});
+
+export const TeamCleanupToolResultSchema = z.object({
+	status: z.string(),
+});
+
+export const TeamOutcomeFragmentToolResultSchema = z.object({
+	fragmentId: z.string(),
+	status: z.string(),
+});
+
+export const TeamFinalizeOutcomeToolResultSchema = z.object({
+	outcomeId: z.string(),
+	status: TeamOutcomeStatusSchema,
+});
+
+export type TeamRunResultSummary = z.infer<typeof TeamRunResultSummarySchema>;
+export type TeamRunToolSummary = z.infer<typeof TeamRunToolSummarySchema>;
+export type TeamTaskToolResult = z.infer<typeof TeamTaskToolResultSchema>;
+export type TeamRunTaskToolResult = z.infer<typeof TeamRunTaskToolResultSchema>;
+export type TeamStatusToolResult = z.infer<typeof TeamStatusToolResultSchema>;
+export type TeamMailboxMessageToolResult = z.infer<
+	typeof TeamMailboxMessageToolResultSchema
+>;
+export type TeamOutcomeToolResult = z.infer<typeof TeamOutcomeToolResultSchema>;
+export type TeamCreateOutcomeToolResult = z.infer<
+	typeof TeamCreateOutcomeToolResultSchema
+>;
diff --git a/sdk/packages/shared/src/team/types.ts b/sdk/packages/shared/src/team/types.ts
new file mode 100644
index 0000000..f5c1f57
--- /dev/null
+++ b/sdk/packages/shared/src/team/types.ts
@@ -0,0 +1,235 @@
+/**
+ * Team data types and interfaces.
+ *
+ * These are the pure data-shape contracts for the multi-agent team system.
+ * They intentionally avoid referencing @cline/agents types so that shared
+ * can remain dependency-free of the agents package.
+ */
+
+export type TeamTaskStatus =
+	| "pending"
+	| "in_progress"
+	| "blocked"
+	| "completed";
+
+export interface TeamTask {
+	id: string;
+	title: string;
+	description: string;
+	status: TeamTaskStatus;
+	createdAt: Date;
+	updatedAt: Date;
+	createdBy: string;
+	assignee?: string;
+	dependsOn: string[];
+	summary?: string;
+}
+
+export interface TeamTaskListItem extends TeamTask {
+	isReady: boolean;
+	blockedBy: string[];
+}
+
+export type MissionLogKind =
+	| "progress"
+	| "handoff"
+	| "blocked"
+	| "decision"
+	| "done"
+	| "error";
+
+export interface MissionLogEntry {
+	id: string;
+	ts: Date;
+	teamId: string;
+	agentId: string;
+	taskId?: string;
+	kind: MissionLogKind;
+	summary: string;
+	evidence?: string[];
+	nextAction?: string;
+}
+
+export interface TeamMailboxMessage {
+	id: string;
+	teamId: string;
+	fromAgentId: string;
+	toAgentId: string;
+	subject: string;
+	body: string;
+	taskId?: string;
+	sentAt: Date;
+	readAt?: Date;
+}
+
+export interface TeamMemberSnapshot {
+	agentId: string;
+	role: "lead" | "teammate";
+	description?: string;
+	status: "idle" | "running" | "stopped";
+}
+
+export interface TeammateLifecycleSpec {
+	rolePrompt: string;
+	modelId?: string;
+	maxIterations?: number;
+	runtimeAgentId?: string;
+	conversationId?: string;
+	parentAgentId?: string | null;
+}
+
+export type TeamRunStatus =
+	| "queued"
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "interrupted";
+
+/**
+ * Shared representation of a teammate run record.
+ *
+ * The `result` field is typed as `unknown` at the shared contract level
+ * because the concrete type (`AgentResult`) lives in `@cline/agents`.
+ * Consuming packages narrow this via their own type assertions.
+ */
+export interface TeamRunRecord {
+	id: string;
+	agentId: string;
+	taskId?: string;
+	status: TeamRunStatus;
+	message: string;
+	priority: number;
+	retryCount: number;
+	maxRetries: number;
+	nextAttemptAt?: Date;
+	continueConversation?: boolean;
+	startedAt: Date;
+	endedAt?: Date;
+	leaseOwner?: string;
+	heartbeatAt?: Date;
+	lastProgressAt?: Date;
+	lastProgressMessage?: string;
+	currentActivity?: string;
+	result?: unknown;
+	error?: string;
+}
+
+export type TeamOutcomeStatus = "draft" | "in_review" | "finalized";
+
+export interface TeamOutcome {
+	id: string;
+	teamId: string;
+	title: string;
+	status: TeamOutcomeStatus;
+	requiredSections: string[];
+	createdBy: string;
+	createdAt: Date;
+	finalizedAt?: Date;
+}
+
+export type TeamOutcomeFragmentStatus = "draft" | "reviewed" | "rejected";
+
+export interface TeamOutcomeFragment {
+	id: string;
+	teamId: string;
+	outcomeId: string;
+	section: string;
+	sourceAgentId: string;
+	sourceRunId?: string;
+	content: string;
+	status: TeamOutcomeFragmentStatus;
+	reviewedBy?: string;
+	reviewedAt?: Date;
+	createdAt: Date;
+}
+
+export interface TeamRuntimeSnapshot {
+	teamId: string;
+	teamName: string;
+	members: TeamMemberSnapshot[];
+	taskCounts: Record<TeamTaskStatus, number>;
+	unreadMessages: number;
+	missionLogEntries: number;
+	activeRuns: number;
+	queuedRuns: number;
+	outcomeCounts: Record<TeamOutcomeStatus, number>;
+}
+
+export interface TeamRuntimeState {
+	teamId: string;
+	teamName: string;
+	members: TeamMemberSnapshot[];
+	tasks: TeamTask[];
+	mailbox: TeamMailboxMessage[];
+	missionLog: MissionLogEntry[];
+	runs: TeamRunRecord[];
+	outcomes: TeamOutcome[];
+	outcomeFragments: TeamOutcomeFragment[];
+}
+
+export interface AppendMissionLogInput {
+	agentId: string;
+	taskId?: string;
+	kind: MissionLogKind;
+	summary: string;
+	evidence?: string[];
+	nextAction?: string;
+}
+
+export interface CreateTeamTaskInput {
+	title: string;
+	description: string;
+	createdBy: string;
+	dependsOn?: string[];
+	assignee?: string;
+}
+
+export interface CreateTeamOutcomeInput {
+	title: string;
+	requiredSections: string[];
+	createdBy: string;
+}
+
+export interface AttachTeamOutcomeFragmentInput {
+	outcomeId: string;
+	section: string;
+	sourceAgentId: string;
+	sourceRunId?: string;
+	content: string;
+}
+
+export interface ReviewTeamOutcomeFragmentInput {
+	fragmentId: string;
+	reviewedBy: string;
+	approved: boolean;
+}
+
+export interface RouteToTeammateOptions {
+	taskId?: string;
+	fromAgentId?: string;
+	continueConversation?: boolean;
+}
+
+export enum TeamMessageType {
+	TaskStart = "task_start",
+	TaskEnd = "task_end",
+	AgentEvent = "agent_event",
+	TeammateSpawned = "teammate_spawned",
+	TeammateShutdown = "teammate_shutdown",
+	TeamTaskUpdated = "team_task_updated",
+	TeamMessage = "team_message",
+	TeamMissionLog = "team_mission_log",
+	TeamTaskCompleted = "team_task_completed",
+	RunStarted = "run_started",
+	RunQueued = "run_queued",
+	RunProgress = "run_progress",
+	RunCompleted = "run_completed",
+	RunFailed = "run_failed",
+	RunCancelled = "run_cancelled",
+	RunInterrupted = "run_interrupted",
+	OutcomeCreated = "outcome_created",
+	OutcomeFragmentAttached = "outcome_fragment_attached",
+	OutcomeFragmentReviewed = "outcome_fragment_reviewed",
+	OutcomeFinalized = "outcome_finalized",
+}
diff --git a/sdk/packages/shared/src/tools/create.test.ts b/sdk/packages/shared/src/tools/create.test.ts
new file mode 100644
index 0000000..c1b902d
--- /dev/null
+++ b/sdk/packages/shared/src/tools/create.test.ts
@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { zodToJsonSchema } from "../parse/zod";
+import { createTool } from "./create";
+
+describe("createTool", () => {
+	it("adds a top-level object type for raw object-like JSON schemas", () => {
+		const tool = createTool({
+			name: "raw_schema_tool",
+			description: "Tool with a raw object-like schema",
+			inputSchema: {
+				properties: {
+					value: {
+						type: "string",
+					},
+				},
+				required: ["value"],
+				additionalProperties: false,
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toEqual({
+			type: "object",
+			properties: {
+				value: {
+					type: "string",
+				},
+			},
+			required: ["value"],
+			additionalProperties: false,
+		});
+	});
+
+	it("applies default execution policy fields", () => {
+		const tool = createTool({
+			name: "defaulted_tool",
+			description: "Tool with default execution policy",
+			inputSchema: { type: "object" },
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.timeoutMs).toBe(30_000);
+		expect(tool.retryable).toBe(true);
+		expect(tool.maxRetries).toBe(3);
+	});
+
+	it("preserves explicit execution policy fields", () => {
+		const tool = createTool({
+			name: "custom_policy_tool",
+			description: "Tool with custom execution policy",
+			inputSchema: { type: "object" },
+			timeoutMs: 1_000,
+			retryable: false,
+			maxRetries: 0,
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.timeoutMs).toBe(1_000);
+		expect(tool.retryable).toBe(false);
+		expect(tool.maxRetries).toBe(0);
+	});
+
+	it("strips the $schema meta-key emitted by Zod v4's toJSONSchema", () => {
+		// Zod v4 always adds "$schema" to the output of z.toJSONSchema().
+		// LLM tool APIs don't need it and some may reject it.
+		const schema = z.object({ value: z.string() });
+		const tool = createTool({
+			name: "zod_schema_tool",
+			description: "Tool with a Zod-derived schema",
+			inputSchema: zodToJsonSchema(schema),
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).not.toHaveProperty("$schema");
+		expect(tool.inputSchema).toHaveProperty("type", "object");
+	});
+
+	it("infers type:object when all anyOf branches are objects", () => {
+		// Build the anyOf manually to avoid depending on Zod's output shape.
+		const tool = createTool({
+			name: "all_object_anyof_tool",
+			description: "Tool with all-object anyOf branches",
+			inputSchema: {
+				anyOf: [
+					{ type: "object", properties: { a: { type: "string" } } },
+					{ type: "object", properties: { b: { type: "number" } } },
+				],
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toHaveProperty("type", "object");
+	});
+
+	it("throws when inputSchema has a top-level anyOf with non-object branches", () => {
+		// A mixed-type union (objects + strings) is not a valid tool input_schema
+		// for any major LLM provider.  createTool must reject it at registration
+		// time so the bug surfaces immediately rather than at inference time.
+		expect(() =>
+			createTool({
+				name: "bad_union_tool",
+				description: "Tool with a mixed-type union schema",
+				inputSchema: {
+					anyOf: [
+						{ type: "object", properties: { commands: { type: "array" } } },
+						{ type: "string" },
+					],
+				},
+				execute: async () => ({ ok: true }),
+			}),
+		).toThrow(/top level/i);
+	});
+
+	it("infers type:object for allOf when at least one branch has type:object", () => {
+		// The canonical allOf case: one branch sets type + properties, another
+		// adds required without repeating type: "object".  The current input is
+		// still unambiguously object-shaped.
+		const tool = createTool({
+			name: "allof_tool",
+			description: "Tool with an allOf schema",
+			inputSchema: {
+				allOf: [
+					{ type: "object", properties: { commands: { type: "array" } } },
+					{ required: ["commands"] },
+				],
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toEqual({
+			type: "object",
+			allOf: [
+				{ type: "object", properties: { commands: { type: "array" } } },
+				{ required: ["commands"] },
+			],
+		});
+	});
+
+	it("merges multiple required-only allOf branches without hoisting them", () => {
+		// Multiple branches each contribute required constraints.  None of them
+		// should be flattened — the allOf composition stays intact, only the
+		// top-level type: "object" is added.
+		const tool = createTool({
+			name: "allof_multi_required_tool",
+			description: "Tool with multiple required-only allOf branches",
+			inputSchema: {
+				allOf: [
+					{ type: "object" },
+					{ required: ["commands"] },
+					{ required: ["foo", "commands"] },
+				],
+			},
+			execute: async () => ({ ok: true }),
+		});
+
+		expect(tool.inputSchema).toEqual({
+			type: "object",
+			allOf: [
+				{ type: "object" },
+				{ required: ["commands"] },
+				{ required: ["foo", "commands"] },
+			],
+		});
+	});
+
+	it("throws when allOf has no branch with type:object", () => {
+		// We cannot verify the schema is object-shaped without at least one
+		// branch asserting type: "object". Fail loudly rather than forward an
+		// ambiguous schema to a provider that may reject it at inference time.
+		expect(() =>
+			createTool({
+				name: "allof_no_type_tool",
+				description: "Tool with allOf but no typed branch",
+				inputSchema: {
+					allOf: [{ required: ["commands"] }, { minProperties: 1 }],
+				},
+				execute: async () => ({ ok: true }),
+			}),
+		).toThrow(/top level/i);
+	});
+
+	it("throws when a Zod union schema with non-object branches is passed as inputSchema", () => {
+		// The concrete regression: passing a coercion/union schema (e.g.
+		// StructuredCommandsInputUnionSchema) directly as inputSchema must fail
+		// loudly, not silently forward a broken anyOf to the LLM provider.
+		const unionSchema = z.union([
+			z.object({ commands: z.array(z.string()) }),
+			z.string(),
+		]);
+
+		expect(() =>
+			createTool({
+				name: "union_schema_tool",
+				description: "Tool mistakenly using a union as inputSchema",
+				inputSchema: zodToJsonSchema(unionSchema),
+				execute: async () => ({ ok: true }),
+			}),
+		).toThrow(/top level/i);
+	});
+});
diff --git a/sdk/packages/shared/src/tools/create.ts b/sdk/packages/shared/src/tools/create.ts
new file mode 100644
index 0000000..b0c4674
--- /dev/null
+++ b/sdk/packages/shared/src/tools/create.ts
@@ -0,0 +1,130 @@
+import { z } from "zod";
+import type { AgentTool, AgentToolContext } from "../agent";
+import { zodToJsonSchema } from "../parse/zod";
+
+function normalizeToolInputSchema(
+	inputSchema: Record<string, unknown>,
+): Record<string, unknown> {
+	// Zod v4's z.toJSONSchema() always emits a "$schema" meta-key that is not
+	// needed in LLM tool definitions and can confuse strict validators.
+	// Strip it here so all downstream consumers get a clean schema.
+	const { $schema: _ignored, ...schema } = inputSchema;
+
+	if (typeof schema.type === "string") {
+		return schema;
+	}
+	if (
+		"properties" in schema ||
+		"required" in schema ||
+		"additionalProperties" in schema
+	) {
+		return {
+			type: "object",
+			...schema,
+		};
+	}
+	for (const key of ["oneOf", "anyOf", "allOf"] as const) {
+		const branches = schema[key];
+		if (!Array.isArray(branches) || branches.length === 0) {
+			continue;
+		}
+
+		if (key === "allOf") {
+			// allOf means the input must satisfy ALL branches simultaneously.
+			// A single branch explicitly typed as an object is sufficient to
+			// constrain the top-level shape — other branches are free to add
+			// required, minProperties, etc. without repeating type: "object".
+			// If no branch asserts type: "object" we cannot verify the schema
+			// is object-shaped, so fail loudly just as we do for anyOf/oneOf —
+			// the developer should make the object constraint explicit.
+			const hasObjectBranch = branches.some(
+				(branch) =>
+					branch &&
+					typeof branch === "object" &&
+					(branch as Record<string, unknown>).type === "object",
+			);
+			if (hasObjectBranch) {
+				return { type: "object", ...schema };
+			}
+			throw new Error(
+				`Tool inputSchema must describe an object at the top level, but ` +
+					`the schema has a top-level "allOf" with no branch that asserts ` +
+					`type: "object". Add type: "object" to at least one allOf branch ` +
+					`to make the object constraint explicit.`,
+			);
+		}
+
+		// oneOf / anyOf: the input matches ONE (or at least one) branch.
+		// Every branch must be object-shaped — a single non-object branch means
+		// the top-level input can be a string, array, etc., which providers
+		// reject.  Fail loudly at registration time so the bug surfaces
+		// immediately rather than at inference time.
+		const allObjectBranches = branches.every(
+			(branch) =>
+				branch &&
+				typeof branch === "object" &&
+				(branch as Record<string, unknown>).type === "object",
+		);
+		if (allObjectBranches) {
+			return { type: "object", ...schema };
+		}
+		throw new Error(
+			`Tool inputSchema must describe an object at the top level, but ` +
+				`the schema has a top-level "${key}" whose branches include ` +
+				`non-object types. Pass the strict object schema as inputSchema ` +
+				`and reserve union/coercion schemas for use inside execute().`,
+		);
+	}
+	return schema;
+}
+
+export function createTool<TInput, TOutput>(config: {
+	name: string;
+	description: string;
+	inputSchema: Record<string, unknown>;
+	execute: (input: TInput, context: AgentToolContext) => Promise<TOutput>;
+	lifecycle?: AgentTool<TInput, TOutput>["lifecycle"];
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}): AgentTool<TInput, TOutput>;
+export function createTool<TSchema extends z.ZodTypeAny, TOutput>(config: {
+	name: string;
+	description: string;
+	inputSchema: TSchema;
+	execute: (
+		input: z.infer<TSchema>,
+		context: AgentToolContext,
+	) => Promise<TOutput>;
+	lifecycle?: AgentTool<z.infer<TSchema>, TOutput>["lifecycle"];
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}): AgentTool<z.infer<TSchema>, TOutput>;
+export function createTool<TInput, TOutput>(config: {
+	name: string;
+	description: string;
+	inputSchema: Record<string, unknown> | z.ZodTypeAny;
+	execute: (input: TInput, context: AgentToolContext) => Promise<TOutput>;
+	lifecycle?: AgentTool<TInput, TOutput>["lifecycle"];
+	timeoutMs?: number;
+	retryable?: boolean;
+	maxRetries?: number;
+}): AgentTool<TInput, TOutput> {
+	const inputSchema = normalizeToolInputSchema(
+		config.inputSchema instanceof z.ZodType
+			? zodToJsonSchema(config.inputSchema)
+			: config.inputSchema,
+	);
+
+	return {
+		name: config.name,
+		description: config.description,
+		inputSchema,
+		lifecycle: config.lifecycle,
+		timeoutMs: config.timeoutMs ?? 30_000,
+		retryable: config.retryable ?? true,
+		maxRetries: config.maxRetries ?? 3,
+		execute: config.execute,
+	};
+}
diff --git a/sdk/packages/shared/src/types/auth.ts b/sdk/packages/shared/src/types/auth.ts
new file mode 100644
index 0000000..3c32fb5
--- /dev/null
+++ b/sdk/packages/shared/src/types/auth.ts
@@ -0,0 +1,23 @@
+/**
+ * Error‑message sub-strings that indicate an auth / credential failure.
+ * Used with provider auth handlers to decide whether a failed API call should
+ * trigger an OAuth refresh.
+ */
+export const AUTH_ERROR_PATTERNS = [
+	"401",
+	"403",
+	"unauthorized",
+	"forbidden",
+	"invalid token",
+	"expired token",
+	"authentication",
+] as const;
+
+/**
+ * Returns `true` when `error` looks like an authentication failure.
+ */
+export function isLikelyAuthError(error: unknown): boolean {
+	const message =
+		error instanceof Error ? error.message.toLowerCase() : String(error);
+	return AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}
diff --git a/sdk/packages/shared/src/types/index.ts b/sdk/packages/shared/src/types/index.ts
new file mode 100644
index 0000000..5354bd8
--- /dev/null
+++ b/sdk/packages/shared/src/types/index.ts
@@ -0,0 +1,2 @@
+export * from "./auth";
+export * from "./vcr";
diff --git a/sdk/packages/shared/src/types/vcr.ts b/sdk/packages/shared/src/types/vcr.ts
new file mode 100644
index 0000000..82b71c3
--- /dev/null
+++ b/sdk/packages/shared/src/types/vcr.ts
@@ -0,0 +1,14 @@
+/** A single recorded HTTP interaction. */
+export interface VcrRecording {
+	scope: string;
+	method: string;
+	path: string;
+	body?: string;
+	/** Sanitized canonical request body used as an optional playback contract. */
+	requestBody?: string;
+	status: number;
+	response: unknown;
+	responseIsBinary: boolean;
+	/** Content-Type header from the original response (captured at record time). */
+	contentType?: string;
+}
diff --git a/sdk/packages/shared/src/vcr.test.ts b/sdk/packages/shared/src/vcr.test.ts
new file mode 100644
index 0000000..2e7955e
--- /dev/null
+++ b/sdk/packages/shared/src/vcr.test.ts
@@ -0,0 +1,229 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { disposeAll } from "./dispose";
+import type { VcrRecording } from "./types/vcr";
+import { initVcr } from "./vcr";
+
+const ORIGINAL_ENV = { ...process.env };
+const ORIGINAL_FETCH = globalThis.fetch;
+const tempDirs: string[] = [];
+
+function createTempCassettePath(): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "cline-vcr-test-"));
+	tempDirs.push(dir);
+	return path.join(dir, "cassette.json");
+}
+
+function readCassette(filePath: string): VcrRecording[] {
+	return JSON.parse(readFileSync(filePath, "utf8")) as VcrRecording[];
+}
+
+afterEach(async () => {
+	await disposeAll();
+	process.env = { ...ORIGINAL_ENV };
+	globalThis.fetch = ORIGINAL_FETCH;
+	for (const dir of tempDirs.splice(0)) {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+describe("VCR request body contracts", () => {
+	it("records sanitized request body contracts when opted in", async () => {
+		const cassettePath = createTempCassettePath();
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+		globalThis.fetch = vi.fn(async () => {
+			return new Response(JSON.stringify({ ok: true }), {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			});
+		}) as typeof fetch;
+
+		initVcr("record");
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "test-model",
+				api_key: "secret",
+				accessToken: "oauth-secret",
+				z: 2,
+				a: 1,
+			}),
+		});
+		await response.text();
+		await disposeAll();
+
+		const recordings = readCassette(cassettePath);
+		expect(recordings).toHaveLength(1);
+		expect(recordings[0]).not.toHaveProperty("body");
+		expect(recordings[0]?.requestBody).toBe(
+			'{"a":1,"accessToken":"REDACTED","api_key":"REDACTED","model":"test-model","z":2}',
+		);
+	});
+
+	it("canonicalizes URL-encoded bodies when content type is form encoded", async () => {
+		const cassettePath = createTempCassettePath();
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+		globalThis.fetch = vi.fn(async () => {
+			return new Response("ok", {
+				status: 200,
+				headers: { "content-type": "text/plain" },
+			});
+		}) as typeof fetch;
+
+		initVcr("record");
+
+		const response = await fetch("https://api.example.test/v1/token", {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded;charset=UTF-8",
+			},
+			body: "access_token=secret&model=test-model&tag=one&tag=two",
+		});
+		await response.text();
+		await disposeAll();
+
+		const recordings = readCassette(cassettePath);
+		expect(recordings).toHaveLength(1);
+		expect(recordings[0]?.requestBody).toBe(
+			'{"access_token":"REDACTED","model":"test-model","tag":["one","two"]}',
+		);
+	});
+
+	it("leaves URL-encoded-looking strings raw without form content type", async () => {
+		const cassettePath = createTempCassettePath();
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY = "1";
+		globalThis.fetch = vi.fn(async () => {
+			return new Response("ok", {
+				status: 200,
+				headers: { "content-type": "text/plain" },
+			});
+		}) as typeof fetch;
+
+		initVcr("record");
+
+		const response = await fetch("https://api.example.test/v1/upload", {
+			method: "POST",
+			body: "dGVzdA==",
+		});
+		await response.text();
+		await disposeAll();
+
+		const recordings = readCassette(cassettePath);
+		expect(recordings).toHaveLength(1);
+		expect(recordings[0]?.requestBody).toBe("dGVzdA==");
+	});
+
+	it("matches sanitized request body contracts during playback", async () => {
+		const cassettePath = createTempCassettePath();
+		const recording: VcrRecording = {
+			scope: "https://api.example.test",
+			method: "POST",
+			path: "/v1/chat",
+			requestBody: '{"api_key":"REDACTED","model":"test-model"}',
+			status: 200,
+			response: "ok",
+			responseIsBinary: false,
+			contentType: "text/plain",
+		};
+		writeFileSync(cassettePath, JSON.stringify([recording], null, 2));
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+
+		initVcr("playback");
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "test-model",
+				api_key: "runtime-secret",
+			}),
+		});
+
+		expect(await response.text()).toBe("ok");
+	});
+
+	it("plays back legacy cassettes without request body contracts", async () => {
+		const cassettePath = createTempCassettePath();
+		const recording: VcrRecording = {
+			scope: "https://api.example.test",
+			method: "POST",
+			path: "/v1/chat",
+			status: 200,
+			response: "ok",
+			responseIsBinary: false,
+			contentType: "text/plain",
+		};
+		writeFileSync(cassettePath, JSON.stringify([recording], null, 2));
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+
+		initVcr("playback");
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "changed-model",
+				api_key: "runtime-secret",
+			}),
+		});
+
+		expect(await response.text()).toBe("ok");
+	});
+
+	it("fails playback when the sanitized request body changes", async () => {
+		const cassettePath = createTempCassettePath();
+		const recording: VcrRecording = {
+			scope: "https://api.example.test",
+			method: "POST",
+			path: "/v1/chat",
+			requestBody: '{"api_key":"REDACTED","model":"test-model"}',
+			status: 200,
+			response: "ok",
+			responseIsBinary: false,
+			contentType: "text/plain",
+		};
+		writeFileSync(cassettePath, JSON.stringify([recording], null, 2));
+		process.env.CLINE_VCR_CASSETTE = cassettePath;
+
+		initVcr("playback");
+
+		let thrown: unknown;
+		try {
+			await fetch("https://api.example.test/v1/chat", {
+				method: "POST",
+				body: JSON.stringify({
+					model: "other-model",
+					api_key: "runtime-secret",
+				}),
+			});
+		} catch (error) {
+			thrown = error;
+		}
+
+		expect(thrown).toBeInstanceOf(Error);
+		if (!(thrown instanceof Error)) {
+			throw new Error("Expected request body mismatch to throw an Error");
+		}
+		expect(thrown.message).toContain("Request body mismatch");
+		expect(thrown.message).toContain(
+			'expected: {"api_key":"REDACTED","model":"test-model"}',
+		);
+		expect(thrown.message).toContain(
+			'actual:   {"api_key":"REDACTED","model":"other-model"}',
+		);
+
+		const response = await fetch("https://api.example.test/v1/chat", {
+			method: "POST",
+			body: JSON.stringify({
+				model: "test-model",
+				api_key: "runtime-secret",
+			}),
+		});
+
+		expect(await response.text()).toBe("ok");
+	});
+});
diff --git a/sdk/packages/shared/src/vcr.ts b/sdk/packages/shared/src/vcr.ts
new file mode 100644
index 0000000..0af1df7
--- /dev/null
+++ b/sdk/packages/shared/src/vcr.ts
@@ -0,0 +1,900 @@
+/**
+ * VCR (Video Cassette Recorder) for HTTP requests.
+ *
+ * Patches `globalThis.fetch` to record and replay HTTP interactions,
+ * enabling deterministic testing without making real API calls.
+ *
+ * Unlike nock (which patches Node's `http` module), this works by wrapping
+ * `globalThis.fetch` directly, catching all HTTP traffic in this codebase
+ * including calls made through the OpenAI, Anthropic, Gemini, and Vercel AI
+ * SDKs (all of which delegate to the global fetch).
+ *
+ * Environment variables:
+ *   CLINE_VCR           - "record" to record HTTP requests, "playback" to replay them
+ *   CLINE_VCR_CASSETTE  - Path to the cassette file (default: ./vcr-cassette.json)
+ *   CLINE_VCR_FILTER    - Substring to filter recorded/replayed request paths.
+ *                         When set to a non-empty string, only requests whose path
+ *                         contains this substring are recorded/replayed; all other
+ *                         requests pass through to the real network.
+ *                         When empty or unset, ALL requests are intercepted (no filter).
+ *   CLINE_VCR_INCLUDE_REQUEST_BODY - "1" to save sanitized request bodies and
+ *                         assert them during playback.
+ *   CLINE_VCR_SSE_DELAY - Milliseconds between SSE chunks during playback (default: 100).
+ *                         Set to 0 for instant delivery.
+ *
+ * Usage:
+ *   # Record only inference requests
+ *   CLINE_VCR=record CLINE_VCR_CASSETTE=./fixtures/my-test.json cline task "hello"
+ *
+ *   # Replay: auth/S3/etc. requests go through normally, only inference is mocked
+ *   CLINE_VCR=playback CLINE_VCR_CASSETTE=./fixtures/my-test.json cline task "hello"
+ *
+ *   # Record everything (no filter)
+ *   CLINE_VCR=record CLINE_VCR_FILTER="" CLINE_VCR_CASSETTE=./fixtures/all.json cline task "hello"
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { registerDisposable } from "./dispose";
+import type { VcrRecording } from "./types/vcr";
+
+// ── Types ───────────────────────────────────────────────────────────────
+
+type VcrMode = "record" | "playback";
+
+interface VcrConfig {
+	mode: VcrMode;
+	cassettePath: string;
+	includeRequestBody: boolean;
+	/**
+	 * Only record/replay requests whose path includes this substring.
+	 * Empty string ("") means no filtering, so ALL requests are intercepted.
+	 * A non-empty string enables selective mode where only matching requests
+	 * are intercepted and non-matching requests pass through to the real network.
+	 */
+	filter: string;
+}
+
+interface InternalVcrRecording extends VcrRecording {
+	requestContentType?: string;
+}
+
+// ── Sensitive data sanitization ─────────────────────────────────────────
+
+/**
+ * Sanitization is key-based: any JSON key whose name matches a rule gets
+ * its value redacted. This is more robust than regex-matching values,
+ * because it works regardless of the value format.
+ *
+ * Three categories of keys are redacted:
+ *
+ * 1. Exact key names (case-insensitive): secrets, tokens, credentials.
+ * 2. Key name patterns (substring/suffix): catches ID fields, PII, etc.
+ * 3. Value-level regex patterns: for values embedded in plain strings
+ *    (e.g. filesystem paths, AWS key IDs in URLs).
+ *
+ * To add new sanitization rules, just add entries to the sets/arrays below.
+ */
+
+/** Keys whose values are always fully redacted (case-insensitive exact match). */
+const REDACT_KEYS_EXACT = new Set([
+	// Secrets & tokens
+	// Exact keys are compared after lowercasing, so accessToken matches accesstoken.
+	"accesskeyid",
+	"secretaccesskey",
+	"idtoken",
+	"refreshtoken",
+	"accesstoken",
+	"access_token",
+	"refresh_token",
+	"apikey",
+	"api_key",
+	"authorization",
+	"password",
+	"secret",
+	"token",
+	// PII
+	"email",
+	"displayname",
+	"display_name",
+	"userinfo",
+]);
+
+/**
+ * Keys whose values are redacted if the key name ends with or contains
+ * one of these substrings (case-insensitive). Catches fields like
+ * "userId", "organizationId", "memberId", "sessionId", etc.
+ */
+const REDACT_KEY_SUFFIXES = [
+	"id", // matches *Id and *_id, covering most entity identifiers
+	"balance",
+	"cost",
+	"secret",
+];
+
+/** Check whether a key name should have its value redacted. */
+function shouldRedactKey(key: string): boolean {
+	const lower = key.toLowerCase();
+	if (REDACT_KEYS_EXACT.has(lower)) {
+		return true;
+	}
+	for (const suffix of REDACT_KEY_SUFFIXES) {
+		// Match "userId", "user_id", "id" but not "video" or "valid"
+		if (lower === suffix) {
+			return true;
+		}
+		// camelCase: ends with "Id", "Balance", etc.
+		if (lower.endsWith(suffix) && lower.length > suffix.length) {
+			const charBefore = lower[lower.length - suffix.length - 1];
+			// Must be preceded by a word boundary character (_, -, or uppercase transition)
+			if (charBefore === "_" || charBefore === "-") {
+				return true;
+			}
+			// camelCase: the suffix starts with lowercase but original key has uppercase
+			const originalChar = key[key.length - suffix.length];
+			if (
+				originalChar &&
+				originalChar === originalChar.toUpperCase() &&
+				originalChar !== originalChar.toLowerCase()
+			) {
+				return true;
+			}
+		}
+		// snake_case: ends with "_id", "_balance", etc.
+		if (lower.endsWith(`_${suffix}`)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/** Regex patterns applied to plain string values (not key-based). */
+const SENSITIVE_VALUE_PATTERNS: { pattern: RegExp; replacement: string }[] = [
+	// AWS access key IDs
+	{ pattern: /AKIA[A-Z0-9]{16}/g, replacement: "AKIA_REDACTED" },
+	// Filesystem paths with usernames
+	{ pattern: /\/Users\/[A-Za-z0-9._-]+/g, replacement: "/Users/REDACTED_USER" },
+	{ pattern: /\/home\/[A-Za-z0-9._-]+/g, replacement: "/home/REDACTED_USER" },
+];
+
+/** Apply value-level regex sanitization to a plain string. */
+function sanitizeStringValue(input: string): string {
+	let result = input;
+	for (const { pattern, replacement } of SENSITIVE_VALUE_PATTERNS) {
+		result = result.replace(pattern, replacement);
+	}
+	return result;
+}
+
+function sortJsonValue(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(sortJsonValue);
+	}
+	if (!value || typeof value !== "object") {
+		return value;
+	}
+	return Object.fromEntries(
+		Object.entries(value as Record<string, unknown>)
+			.sort(([a], [b]) => compareCodeUnits(a, b))
+			.map(([key, nestedValue]) => [key, sortJsonValue(nestedValue)]),
+	);
+}
+
+function compareCodeUnits(a: string, b: string): number {
+	if (a < b) {
+		return -1;
+	}
+	if (a > b) {
+		return 1;
+	}
+	return 0;
+}
+
+function canonicalStringify(value: unknown): string {
+	return JSON.stringify(sortJsonValue(value));
+}
+
+/**
+ * Path-level patterns for normalizing request paths in recordings.
+ * These replace dynamic path segments with stable test values so that
+ * playback matching works across different environments/users.
+ *
+ * Patterns are applied in order. More specific patterns should come first.
+ */
+const PATH_NORMALIZATION_PATTERNS: { pattern: RegExp; replacement: string }[] =
+	[
+		// S3-style task artifact paths: /tasks/<userId>/<taskId>/api_conversation_history.json
+		{
+			pattern:
+				/tasks\/[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/api_conversation_history/g,
+			replacement: "tasks/usr-test/taskid/api_conversation_history",
+		},
+		// Prefixed entity IDs in path segments (org-XXX, usr-XXX, mbr-XXX, ses-XXX, etc.)
+		// Matches common Cline ID formats: prefix + ULID/UUID-like suffix
+		{
+			pattern:
+				/\/(org|usr|mbr|ses|gen|req|msg|tsk|sch|exe|srv|cli|wkr|evt|sub|tkn)-[A-Za-z0-9]{10,}(?=[/?#]|$)/g,
+			replacement: "/$1-REDACTED",
+		},
+	];
+
+/** Normalize a request path for stable matching. */
+function normalizePath(input: string): string {
+	let result = input;
+	for (const { pattern, replacement } of PATH_NORMALIZATION_PATTERNS) {
+		result = result.replace(pattern, replacement);
+	}
+	return result;
+}
+
+/**
+ * Deep-sanitize a value, redacting sensitive keys and patterns.
+ * Handles objects, arrays, plain strings, and JSON-encoded strings.
+ */
+function sanitizeValue(obj: unknown): unknown {
+	if (obj === null || obj === undefined) {
+		return obj;
+	}
+
+	if (typeof obj === "string") {
+		// Try to parse as JSON and sanitize recursively
+		try {
+			const parsed = JSON.parse(obj);
+			if (typeof parsed === "object" && parsed !== null) {
+				return JSON.stringify(sanitizeValue(parsed));
+			}
+		} catch {
+			// Not JSON, so apply string-level patterns
+		}
+		return sanitizeStringValue(obj);
+	}
+
+	if (Array.isArray(obj)) {
+		return obj.map(sanitizeValue);
+	}
+
+	if (typeof obj === "object") {
+		const result: Record<string, unknown> = {};
+		for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+			if (
+				shouldRedactKey(key) &&
+				(typeof value === "string" || typeof value === "number")
+			) {
+				result[key] = "REDACTED";
+			} else {
+				result[key] = sanitizeValue(value);
+			}
+		}
+		return result;
+	}
+
+	return obj;
+}
+
+function parseUrlEncodedBody(
+	input: string,
+): Record<string, unknown> | undefined {
+	const params = new URLSearchParams(input);
+	const entries = Array.from(params.entries());
+	if (entries.length === 0 || entries.some(([key]) => key.length === 0)) {
+		return undefined;
+	}
+	const output: Record<string, unknown> = {};
+	for (const [key, value] of entries) {
+		const existing = output[key];
+		if (existing === undefined) {
+			output[key] = value;
+		} else if (Array.isArray(existing)) {
+			existing.push(value);
+		} else {
+			output[key] = [existing, value];
+		}
+	}
+	return output;
+}
+
+function isUrlEncodedContentType(contentType: string | undefined): boolean {
+	return (
+		contentType?.toLowerCase().split(";")[0]?.trim() ===
+		"application/x-www-form-urlencoded"
+	);
+}
+
+function sanitizeSerializedRequestBody(
+	input: string,
+	contentType?: string,
+): string {
+	try {
+		return canonicalStringify(sanitizeValue(JSON.parse(input)));
+	} catch {
+		if (isUrlEncodedContentType(contentType)) {
+			const formBody = parseUrlEncodedBody(input);
+			if (formBody) {
+				return canonicalStringify(sanitizeValue(formBody));
+			}
+		}
+		return sanitizeStringValue(input);
+	}
+}
+
+/** Sanitize a single recorded interaction, stripping sensitive data. */
+function sanitizeRecording(
+	rec: InternalVcrRecording,
+	includeRequestBody: boolean,
+): VcrRecording {
+	const cleaned = { ...rec };
+	const requestBody =
+		includeRequestBody && rec.body !== undefined
+			? sanitizeSerializedRequestBody(rec.body, rec.requestContentType)
+			: undefined;
+
+	// Remove request body (may contain prompts, API keys, etc.)
+	delete cleaned.body;
+	delete cleaned.requestContentType;
+	if (requestBody !== undefined) {
+		cleaned.requestBody = requestBody;
+	}
+
+	// Normalize the request path for stable matching
+	if (typeof cleaned.path === "string") {
+		cleaned.path = normalizePath(cleaned.path);
+	}
+
+	// Deep-sanitize response body
+	if (cleaned.response !== undefined) {
+		cleaned.response = sanitizeValue(cleaned.response);
+	}
+
+	return cleaned;
+}
+
+// ── URL helpers ─────────────────────────────────────────────────────────
+
+function parseScope(url: string): { scope: string; path: string } {
+	try {
+		const parsed = new URL(url);
+		const scope = `${parsed.protocol}//${parsed.host}`;
+		const path = parsed.pathname + parsed.search;
+		return { scope, path };
+	} catch {
+		return { scope: "", path: url };
+	}
+}
+
+function resolveRequestUrl(input: string | URL | Request): string {
+	if (typeof input === "string") {
+		return input;
+	}
+	if (input instanceof URL) {
+		return input.toString();
+	}
+	if (input && typeof (input as Request).url === "string") {
+		return (input as Request).url;
+	}
+	return String(input);
+}
+
+function resolveRequestMethod(
+	input: string | URL | Request,
+	init?: RequestInit,
+): string {
+	if (init?.method) {
+		return init.method.toUpperCase();
+	}
+	if (input && typeof (input as Request).method === "string") {
+		return (input as Request).method.toUpperCase();
+	}
+	return "GET";
+}
+
+function readHeadersContentType(
+	headers: RequestInit["headers"] | undefined,
+): string | undefined {
+	if (!headers) {
+		return undefined;
+	}
+	return new Headers(headers).get("content-type") ?? undefined;
+}
+
+function readRequestContentType(
+	input: string | URL | Request,
+	init?: RequestInit,
+): string | undefined {
+	const initContentType = readHeadersContentType(init?.headers);
+	if (initContentType) {
+		return initContentType;
+	}
+	if (init?.body instanceof URLSearchParams) {
+		return "application/x-www-form-urlencoded;charset=UTF-8";
+	}
+	if (input instanceof Request) {
+		return input.headers.get("content-type") ?? undefined;
+	}
+	return undefined;
+}
+
+async function readRequestBody(
+	input: string | URL | Request,
+	init?: RequestInit,
+): Promise<string | undefined> {
+	if (init?.body) {
+		if (typeof init.body === "string") {
+			return init.body;
+		}
+		if (init.body instanceof URLSearchParams) {
+			return init.body.toString();
+		}
+		if (init.body instanceof ArrayBuffer) {
+			return new TextDecoder().decode(init.body);
+		}
+		if (ArrayBuffer.isView(init.body)) {
+			return new TextDecoder().decode(
+				new Uint8Array(
+					init.body.buffer,
+					init.body.byteOffset,
+					init.body.byteLength,
+				),
+			);
+		}
+		return undefined;
+	}
+	if (input instanceof Request) {
+		try {
+			return await input.clone().text();
+		} catch {
+			return undefined;
+		}
+	}
+	return undefined;
+}
+
+// ── Config resolution ───────────────────────────────────────────────────
+
+function getVcrConfig(vcrMode: string | undefined): VcrConfig | null {
+	if (!vcrMode) {
+		return null;
+	}
+
+	if (!process.env.CLINE_VCR_CASSETTE) {
+		process.stderr.write(
+			"[VCR] No CLINE_VCR_CASSETTE: requests will not be recorded or played back.\n",
+		);
+		return null;
+	}
+
+	if (vcrMode !== "record" && vcrMode !== "playback") {
+		process.stderr.write(
+			`[VCR] Invalid CLINE_VCR value: "${vcrMode}". Expected "record" or "playback".\n`,
+		);
+		process.exit(1);
+	}
+
+	const cassettePath = resolve(process.env.CLINE_VCR_CASSETTE);
+	const filter = process.env.CLINE_VCR_FILTER ?? "";
+	const includeRequestBody =
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY === "1" ||
+		process.env.CLINE_VCR_INCLUDE_REQUEST_BODY === "true";
+
+	return { mode: vcrMode, cassettePath, filter, includeRequestBody };
+}
+
+// ── Record mode ─────────────────────────────────────────────────────────
+
+/** An in-progress stream capture that can be finalized synchronously. */
+interface InFlightCapture {
+	scope: string;
+	method: string;
+	path: string;
+	body: string;
+	requestContentType?: string;
+	status: number;
+	contentType: string | undefined;
+	chunks: Uint8Array[];
+	finalized: boolean;
+}
+
+function startRecordingRequests(
+	cassettePath: string,
+	filter: string,
+	includeRequestBody: boolean,
+): void {
+	const recordings: InternalVcrRecording[] = [];
+	/** Streams still being consumed, finalized on flush or on process exit. */
+	const inFlight: InFlightCapture[] = [];
+	const originalFetch = globalThis.fetch;
+
+	/** Convert accumulated chunks into a recording entry. */
+	function finalizeCapture(capture: InFlightCapture): void {
+		if (capture.finalized) {
+			return;
+		}
+		capture.finalized = true;
+
+		const decoder = new TextDecoder();
+		const bodyText =
+			capture.chunks.map((c) => decoder.decode(c, { stream: true })).join("") +
+			decoder.decode();
+
+		let responseBody: unknown;
+		try {
+			responseBody = JSON.parse(bodyText);
+		} catch {
+			responseBody = bodyText;
+		}
+
+		recordings.push({
+			scope: capture.scope,
+			method: capture.method,
+			path: capture.path,
+			body: capture.body,
+			requestContentType: capture.requestContentType,
+			status: capture.status,
+			response: responseBody,
+			responseIsBinary: false,
+			contentType: capture.contentType,
+		});
+	}
+
+	globalThis.fetch = Object.assign(
+		async (
+			input: string | URL | Request,
+			init?: RequestInit,
+		): Promise<Response> => {
+			const url = resolveRequestUrl(input);
+			const method = resolveRequestMethod(input, init);
+			const { scope, path } = parseScope(url);
+
+			const requestBody = await readRequestBody(input, init);
+			const requestContentType = readRequestContentType(input, init);
+
+			// Call real fetch
+			const response = await originalFetch(input, init);
+
+			// Check filter
+			if (filter && !path.includes(filter)) {
+				return response;
+			}
+
+			// Capture content-type from the real response
+			const contentType = response.headers.get("content-type") ?? undefined;
+
+			// No body, so record immediately
+			if (!response.body) {
+				recordings.push({
+					scope,
+					method,
+					path,
+					body: requestBody ?? "",
+					requestContentType,
+					status: response.status,
+					response: "",
+					responseIsBinary: false,
+					contentType,
+				});
+				return response;
+			}
+
+			// Wrap the response body with a TransformStream that captures
+			// chunks as the caller consumes them. The capture is tracked in
+			// `inFlight` so the exit handler can finalize it even if the
+			// stream hasn't completed (e.g. process.exit() during SSE).
+			const capture: InFlightCapture = {
+				scope,
+				method,
+				path,
+				body: requestBody ?? "",
+				requestContentType,
+				status: response.status,
+				contentType,
+				chunks: [],
+				finalized: false,
+			};
+			inFlight.push(capture);
+
+			const originalBody = response.body;
+			const transform = new TransformStream<Uint8Array, Uint8Array>({
+				transform(chunk, controller) {
+					capture.chunks.push(chunk);
+					controller.enqueue(chunk);
+				},
+				flush() {
+					finalizeCapture(capture);
+				},
+			});
+
+			const wrappedBody = originalBody.pipeThrough(transform);
+
+			return new Response(wrappedBody, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers,
+			});
+		},
+		{ preconnect: (_url: string | URL) => {} },
+	);
+
+	const filterDesc = filter ? `matching path "*${filter}*"` : "all paths";
+	process.stderr.write(
+		`[VCR] Recording HTTP requests (${filterDesc}). Cassette will be saved to: ${cassettePath}\n`,
+	);
+
+	// Save recordings, finalizing any in-flight stream captures first
+	let saved = false;
+	const saveRecordings = () => {
+		if (saved) {
+			return;
+		}
+		saved = true;
+
+		// Restore original fetch
+		globalThis.fetch = originalFetch;
+
+		// Finalize any in-flight stream captures with whatever data
+		// has been received so far (critical for SSE streams that may
+		// still be open when process.exit() is called).
+		for (const capture of inFlight) {
+			finalizeCapture(capture);
+		}
+
+		if (recordings.length === 0) {
+			process.stderr.write(
+				`[VCR] No HTTP requests${filter ? ` matching "${filter}"` : ""} were recorded.\n`,
+			);
+			return;
+		}
+
+		const dir = dirname(cassettePath);
+		mkdirSync(dir, { recursive: true });
+
+		const sanitized = recordings.map((recording) =>
+			sanitizeRecording(recording, includeRequestBody),
+		);
+		writeFileSync(cassettePath, JSON.stringify(sanitized, null, 2));
+		process.stderr.write(
+			`[VCR] Saved ${sanitized.length} recorded HTTP interaction(s) to ${cassettePath}\n`,
+		);
+	};
+
+	registerDisposable(saveRecordings);
+}
+
+// ── Playback mode ───────────────────────────────────────────────────────
+
+/**
+ * Split an SSE response body into individual event chunks.
+ * Each chunk is a complete "data: ...\n\n" segment.
+ */
+function splitSseChunks(body: string): string[] {
+	// Split on double-newline boundaries that separate SSE events
+	const chunks: string[] = [];
+	const parts = body.split(/\n\n/);
+	for (const part of parts) {
+		const trimmed = part.trim();
+		if (trimmed) {
+			chunks.push(`${trimmed}\n\n`);
+		}
+	}
+	return chunks;
+}
+
+/**
+ * Create a ReadableStream that delivers SSE chunks with a delay between each.
+ */
+function createDelayedSseStream(
+	chunks: string[],
+	delayMs: number,
+): ReadableStream<Uint8Array> {
+	const encoder = new TextEncoder();
+	let index = 0;
+
+	return new ReadableStream<Uint8Array>({
+		async pull(controller) {
+			if (index >= chunks.length) {
+				controller.close();
+				return;
+			}
+			if (index > 0 && delayMs > 0) {
+				await new Promise((resolve) => setTimeout(resolve, delayMs));
+			}
+			const chunk = chunks[index];
+			if (chunk === undefined) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(encoder.encode(chunk));
+			index += 1;
+		},
+	});
+}
+
+async function assertRequestBodyMatches(input: {
+	recording: VcrRecording;
+	requestInput: string | URL | Request;
+	requestInit?: RequestInit;
+	method: string;
+	path: string;
+}): Promise<void> {
+	if (input.recording.requestBody === undefined) {
+		return;
+	}
+	const requestBody = await readRequestBody(
+		input.requestInput,
+		input.requestInit,
+	);
+	const requestContentType = readRequestContentType(
+		input.requestInput,
+		input.requestInit,
+	);
+	const actualBody = sanitizeSerializedRequestBody(
+		requestBody ?? "",
+		requestContentType,
+	);
+	if (actualBody !== input.recording.requestBody) {
+		throw new Error(
+			`[VCR] Request body mismatch for ${input.method} ${input.path}.\n` +
+				`  expected: ${input.recording.requestBody}\n` +
+				`  actual:   ${actualBody}\n` +
+				"Re-record the cassette if the request change is intentional.",
+		);
+	}
+}
+
+function startPlayingBackRequests(cassettePath: string, filter: string): void {
+	if (!existsSync(cassettePath)) {
+		process.stderr.write(`[VCR] Cassette file not found: ${cassettePath}\n`);
+		process.exit(1);
+	}
+
+	const recordings: VcrRecording[] = JSON.parse(
+		readFileSync(cassettePath, "utf-8"),
+	);
+
+	const sseDelayMs = Number.parseInt(
+		process.env.CLINE_VCR_SSE_DELAY ?? "100",
+		10,
+	);
+
+	// Track which recordings have been consumed (each can be used once)
+	const consumed = new Array<boolean>(recordings.length).fill(false);
+	const originalFetch = globalThis.fetch;
+
+	globalThis.fetch = Object.assign(
+		async (
+			input: string | URL | Request,
+			init?: RequestInit,
+		): Promise<Response> => {
+			const url = resolveRequestUrl(input);
+			const method = resolveRequestMethod(input, init);
+			const { path } = parseScope(url);
+			const normalizedPath = normalizePath(path);
+
+			// Check filter: if filter is set and path doesn't match, passthrough
+			if (filter && !path.includes(filter)) {
+				return originalFetch(input, init);
+			}
+
+			// Find a matching unconsumed recording
+			const matchIndex = recordings.findIndex((rec, index) => {
+				if (consumed[index]) {
+					return false;
+				}
+				// Match on method + normalized path. Scope is checked loosely
+				// (hostname may differ between record and playback environments).
+				const recNormalizedPath = normalizePath(rec.path);
+				return (
+					rec.method.toUpperCase() === method &&
+					recNormalizedPath === normalizedPath
+				);
+			});
+
+			if (matchIndex >= 0) {
+				const rec = recordings[matchIndex];
+				if (!rec) {
+					return originalFetch(input, init);
+				}
+				await assertRequestBodyMatches({
+					recording: rec,
+					requestInput: input,
+					requestInit: init,
+					method,
+					path: normalizedPath,
+				});
+				consumed[matchIndex] = true;
+
+				// Build response body
+				const body =
+					typeof rec.response === "string"
+						? rec.response
+						: JSON.stringify(rec.response);
+
+				// Use recorded content-type if available, otherwise infer from response shape
+				const headers = new Headers();
+				if (rec.contentType) {
+					headers.set("content-type", rec.contentType);
+				} else {
+					// Fallback heuristic for cassettes recorded before contentType was captured
+					const isSSE =
+						typeof rec.response === "string" &&
+						rec.response.trimStart().startsWith("data:");
+					if (isSSE) {
+						headers.set("content-type", "text/event-stream");
+					} else if (typeof rec.response === "object") {
+						headers.set("content-type", "application/json");
+					}
+				}
+
+				const isSSEResponse =
+					headers.get("content-type")?.includes("text/event-stream") ?? false;
+
+				// SSE responses need streaming-friendly headers
+				if (isSSEResponse) {
+					headers.set("cache-control", "no-cache");
+					headers.set("connection", "keep-alive");
+				}
+
+				// For SSE responses, stream chunks with a delay to simulate
+				// real-time delivery (controlled by CLINE_VCR_SSE_DELAY).
+				if (isSSEResponse && typeof rec.response === "string") {
+					const chunks = splitSseChunks(rec.response);
+					if (chunks.length > 1) {
+						const stream = createDelayedSseStream(chunks, sseDelayMs);
+						return new Response(stream, {
+							status: rec.status,
+							headers,
+						});
+					}
+				}
+
+				return new Response(body, {
+					status: rec.status,
+					headers,
+				});
+			}
+
+			// No match found
+			if (!filter) {
+				// Full isolation mode, so no filter means nothing should leak
+				throw new Error(
+					`[VCR] No matching recording for ${method} ${url} (path: ${normalizedPath}). ` +
+						`${recordings.length} recording(s) loaded from ${cassettePath}.`,
+				);
+			}
+
+			// Filtered mode, passthrough non-matching requests
+			return originalFetch(input, init);
+		},
+		{ preconnect: (_url: string | URL) => {} },
+	);
+
+	const filterDesc = filter
+		? `(only paths matching "*${filter}*", all other requests go through normally)`
+		: "(all requests intercepted)";
+	process.stderr.write(
+		`[VCR] Playing back ${recordings.length} recorded HTTP interaction(s) from ${cassettePath} ${filterDesc}\n`,
+	);
+}
+
+// ── Public API ──────────────────────────────────────────────────────────
+
+/**
+ * Initialize VCR mode based on environment variables.
+ * Must be called early in startup, before HTTP requests are made.
+ *
+ * Does nothing if `CLINE_VCR` is not set.
+ */
+export function initVcr(vcrMode: string | undefined): void {
+	const config = getVcrConfig(vcrMode);
+	if (!config) {
+		return;
+	}
+
+	if (config.mode === "record") {
+		startRecordingRequests(
+			config.cassettePath,
+			config.filter,
+			config.includeRequestBody,
+		);
+	} else {
+		startPlayingBackRequests(config.cassettePath, config.filter);
+	}
+}
diff --git a/sdk/packages/shared/tsconfig.build.json b/sdk/packages/shared/tsconfig.build.json
new file mode 100644
index 0000000..092177b
--- /dev/null
+++ b/sdk/packages/shared/tsconfig.build.json
@@ -0,0 +1,7 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declarationMap": false,
+		"sourceMap": false
+	}
+}
diff --git a/sdk/packages/shared/tsconfig.json b/sdk/packages/shared/tsconfig.json
new file mode 100644
index 0000000..ff64f9c
--- /dev/null
+++ b/sdk/packages/shared/tsconfig.json
@@ -0,0 +1,9 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]
+}
diff --git a/sdk/packages/shared/vitest.config.ts b/sdk/packages/shared/vitest.config.ts
new file mode 100644
index 0000000..41379a1
--- /dev/null
+++ b/sdk/packages/shared/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts"],
+		exclude: ["src/**/*.e2e.test.ts"],
+	},
+});
diff --git a/sdk/packages/tsconfig.base.json b/sdk/packages/tsconfig.base.json
new file mode 100644
index 0000000..6ce2c8a
--- /dev/null
+++ b/sdk/packages/tsconfig.base.json
@@ -0,0 +1,22 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"types": ["node"]
+	}
+}
diff --git a/sdk/scripts/check-publish.ts b/sdk/scripts/check-publish.ts
new file mode 100644
index 0000000..86eba47
--- /dev/null
+++ b/sdk/scripts/check-publish.ts
@@ -0,0 +1,351 @@
+#!/usr/bin/env bun
+
+import { mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+type PackageInfo = {
+	name: string;
+	dir: string;
+	workspace: string;
+};
+
+type PackedManifest = {
+	name?: string;
+	version?: string;
+	dependencies?: Record<string, string>;
+	exports?: unknown;
+};
+
+const root = join(import.meta.dir, "..");
+const packagesDir = join(root, "packages");
+
+async function runCommandOrThrow(
+	cmd: string[],
+	options: {
+		cwd: string;
+		env?: Record<string, string | undefined>;
+		stdout?: "inherit" | "pipe";
+		stderr?: "inherit" | "pipe";
+	},
+): Promise<string> {
+	const proc = Bun.spawn(cmd, {
+		cwd: options.cwd,
+		env: options.env,
+		stdout: options.stdout ?? "inherit",
+		stderr: options.stderr ?? "inherit",
+	});
+	const exitCode = await proc.exited;
+	const stdout =
+		options.stdout === "pipe" && proc.stdout
+			? await new Response(proc.stdout).text()
+			: "";
+	const stderr =
+		options.stderr === "pipe" && proc.stderr
+			? await new Response(proc.stderr).text()
+			: "";
+	if (exitCode !== 0) {
+		throw new Error(
+			stderr.trim() ||
+				stdout.trim() ||
+				`${cmd[0]} exited with code ${exitCode}`,
+		);
+	}
+	return stdout;
+}
+
+async function listPublishedPackages(): Promise<PackageInfo[]> {
+	const dirs = await readdir(packagesDir, { withFileTypes: true });
+	const workspaces = dirs.filter((d) => d.isDirectory()).map((d) => d.name);
+	const published: PackageInfo[] = [];
+
+	for (const workspace of workspaces) {
+		const pkgPath = join(packagesDir, workspace, "package.json");
+		try {
+			const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+			if (!pkg.internal && typeof pkg.name === "string") {
+				published.push({
+					name: pkg.name,
+					dir: join(packagesDir, workspace),
+					workspace,
+				});
+			}
+		} catch {
+			// skip directories without a package manifest
+		}
+	}
+
+	return published;
+}
+
+async function packWorkspacePackage(
+	pkg: PackageInfo,
+	packRoot: string,
+): Promise<string> {
+	const destination = await mkdtemp(join(packRoot, `${pkg.workspace}-`));
+	await runCommandOrThrow(["bun", "pm", "pack", "--destination", destination], {
+		cwd: pkg.dir,
+	});
+	const files = (await readdir(destination)).filter((file) =>
+		file.endsWith(".tgz"),
+	);
+	if (files.length !== 1) {
+		throw new Error(
+			`Expected one tarball for ${pkg.name}, found ${files.length} in ${destination}`,
+		);
+	}
+	return join(destination, files[0]);
+}
+
+async function readPackedPackageJson(tarball: string): Promise<PackedManifest> {
+	const raw = await runCommandOrThrow(
+		["tar", "-xOf", tarball, "package/package.json"],
+		{
+			cwd: root,
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+	return JSON.parse(raw) as PackedManifest;
+}
+
+function containsDevelopmentExportCondition(value: unknown): boolean {
+	if (value === null || typeof value !== "object") {
+		return false;
+	}
+	if (Array.isArray(value)) {
+		return value.some(containsDevelopmentExportCondition);
+	}
+	if (Object.hasOwn(value, "development")) {
+		return true;
+	}
+	return Object.values(value).some(containsDevelopmentExportCondition);
+}
+
+async function main(): Promise<number> {
+	const published = await listPublishedPackages();
+	if (published.length === 0) {
+		console.error("No published packages found");
+		return 1;
+	}
+
+	console.log(
+		`\nFound ${published.length} published package(s): ${published.map((pkg) => pkg.name).join(", ")}\n`,
+	);
+
+	const testDir = await mkdtemp(join(tmpdir(), "cline-pkg-verify-"));
+	const packDir = await mkdtemp(join(tmpdir(), "cline-pkg-packs-"));
+	const bunCacheDir = await mkdtemp(join(tmpdir(), "cline-pkg-bun-cache-"));
+	const tarballs: { name: string; tarball: string }[] = [];
+	const packedManifests = new Map<string, PackedManifest>();
+
+	let exitCode = 0;
+
+	try {
+		console.log("--- Packing tarballs with Bun ---");
+		for (const pkg of published) {
+			const tarball = await packWorkspacePackage(pkg, packDir);
+			tarballs.push({ name: pkg.name, tarball });
+			packedManifests.set(pkg.name, await readPackedPackageJson(tarball));
+			console.log(`  ${pkg.name} -> ${tarball.split("/").pop()}`);
+		}
+
+		console.log("\n--- Verifying packed manifest versions ---");
+		let manifestFailed = false;
+		for (const [pkgName, manifest] of packedManifests.entries()) {
+			for (const [depName, depVersion] of Object.entries(
+				manifest.dependencies ?? {},
+			)) {
+				const packedDep = packedManifests.get(depName);
+				if (!packedDep) {
+					continue;
+				}
+				if (depVersion !== packedDep.version) {
+					console.error(
+						`  FAIL ${pkgName}: dependencies.${depName} = "${depVersion}" but packed ${depName} version is "${packedDep.version}"`,
+					);
+					manifestFailed = true;
+				}
+			}
+		}
+		if (manifestFailed) {
+			console.info(
+				"\nPacked manifest dependency versions are not aligned. Please ensure that all workspace dependencies are declared with exact versions that match the packed versions.\n",
+			);
+			console.info(
+				"Try running `bun scripts/version.ts <version>` to update package manifests and regenerate lockfile entries with exact versions for workspace dependencies, before running this script again.",
+			);
+			return 1;
+		}
+		console.log("  OK - packed workspace dependency versions are aligned\n");
+
+		console.log("\n--- Verifying packed export maps ---");
+		let exportMapFailed = false;
+		for (const [pkgName, manifest] of packedManifests.entries()) {
+			if (containsDevelopmentExportCondition(manifest.exports)) {
+				console.error(
+					`  FAIL ${pkgName}: packed package exports include a "development" condition`,
+				);
+				exportMapFailed = true;
+			}
+		}
+		if (exportMapFailed) {
+			console.info(
+				"\nPublished packages must resolve to built dist files even when consumers enable custom development conditions.\n",
+			);
+			return 1;
+		}
+		console.log(
+			"  OK - packed export maps do not include development conditions\n",
+		);
+
+		console.log("\n--- Installing packages in isolated directory ---");
+		const tarballDependencies = Object.fromEntries(
+			tarballs.map((entry) => [entry.name, `file:${entry.tarball}`]),
+		);
+		const testPkg = {
+			name: "cline-pkg-verify",
+			private: true,
+			type: "module",
+			dependencies: tarballDependencies,
+			overrides: tarballDependencies,
+		};
+		await writeFile(
+			join(testDir, "package.json"),
+			JSON.stringify(testPkg, null, 2),
+		);
+
+		await runCommandOrThrow(["bun", "install", "--ignore-scripts"], {
+			cwd: testDir,
+			env: {
+				...process.env,
+				BUN_INSTALL_CACHE_DIR: bunCacheDir,
+			},
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		console.log("  OK - bun install succeeded\n");
+
+		console.log("--- Verifying module resolution ---");
+		let importFailed = false;
+		for (const pkg of published) {
+			const testFile = join(testDir, `test-${pkg.workspace}.ts`);
+			await writeFile(
+				testFile,
+				[
+					`try {`,
+					`  await import("${pkg.name}");`,
+					`  console.log("  OK ${pkg.name}");`,
+					`} catch (e: any) {`,
+					`  console.error("  FAIL ${pkg.name}:", e.message);`,
+					`  if (e.code) console.error("       code:", e.code);`,
+					`  process.exitCode = 1;`,
+					`}`,
+				].join("\n"),
+			);
+			try {
+				const proc = Bun.spawn(["bun", testFile], {
+					cwd: testDir,
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+				const result = await Promise.race([
+					proc.exited,
+					new Promise<never>((_, reject) =>
+						setTimeout(() => {
+							proc.kill();
+							reject(new Error("timed out after 30s"));
+						}, 30_000),
+					),
+				]);
+				const stdout = await new Response(proc.stdout).text();
+				const stderr = await new Response(proc.stderr).text();
+				const output = (stdout + stderr).trim();
+				if (output) console.log(output);
+				if (result !== 0 || output.includes("FAIL")) {
+					importFailed = true;
+				}
+			} catch (error: unknown) {
+				importFailed = true;
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(`  FAIL - could not import ${pkg.name}: ${message}`);
+			}
+		}
+
+		console.log("\n--- Verifying publish-only package invariants ---");
+		for (const pkg of published) {
+			if (pkg.name !== "@cline/core") {
+				continue;
+			}
+
+			const testFile = join(testDir, `test-${pkg.workspace}-publish-shape.ts`);
+			await writeFile(
+				testFile,
+				[
+					`import { readFileSync } from "node:fs";`,
+					`import { join } from "node:path";`,
+					`try {`,
+					`  const root = await import("@cline/core");`,
+					`  if (typeof root.ClineCore?.create !== "function") {`,
+					`    console.error("  FAIL @cline/core: root export is missing ClineCore.create");`,
+					`    process.exit(1);`,
+					`  }`,
+					`} catch (error) {`,
+					`  const message = error instanceof Error ? error.message : String(error);`,
+					`  console.error("  FAIL @cline/core: published runtime shape is invalid:", message);`,
+					`  process.exit(1);`,
+					`}`,
+					`console.log("  OK @cline/core publish shape");`,
+				].join("\n"),
+			);
+			try {
+				const proc = Bun.spawn(["bun", testFile], {
+					cwd: testDir,
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+				const result = await Promise.race([
+					proc.exited,
+					new Promise<never>((_, reject) =>
+						setTimeout(() => {
+							proc.kill();
+							reject(new Error("timed out after 30s"));
+						}, 30_000),
+					),
+				]);
+				const stdout = await new Response(proc.stdout).text();
+				const stderr = await new Response(proc.stderr).text();
+				const output = (stdout + stderr).trim();
+				if (output) console.log(output);
+				if (result !== 0 || output.includes("FAIL")) {
+					importFailed = true;
+				}
+			} catch (error: unknown) {
+				importFailed = true;
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(
+					`  FAIL - could not verify publish shape for ${pkg.name}: ${message}`,
+				);
+			}
+		}
+
+		if (importFailed) {
+			console.error("\nSome packages failed to import.");
+			exitCode = 1;
+		} else {
+			console.log("\nAll packages verified successfully.");
+		}
+	} catch (error: unknown) {
+		exitCode = 1;
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`\nVerification failed:\n${message}`);
+	} finally {
+		await rm(testDir, { recursive: true, force: true });
+		await rm(packDir, { recursive: true, force: true });
+		await rm(bunCacheDir, { recursive: true, force: true });
+	}
+
+	return exitCode;
+}
+
+process.exit(await main());
diff --git a/sdk/scripts/ci-node-smoke.ts b/sdk/scripts/ci-node-smoke.ts
new file mode 100644
index 0000000..b2077d9
--- /dev/null
+++ b/sdk/scripts/ci-node-smoke.ts
@@ -0,0 +1,155 @@
+#!/usr/bin/env bun
+
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const root = join(import.meta.dir, "..");
+const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+
+async function runCommand(
+	cmd: string[],
+	options: {
+		cwd: string;
+		env?: Record<string, string | undefined>;
+		captureStdout?: boolean;
+		timeoutMs?: number;
+	},
+): Promise<string> {
+	const captureStdout = options.captureStdout === true;
+	let timedOut = false;
+	const proc = Bun.spawn(cmd, {
+		cwd: options.cwd,
+		env: {
+			...process.env,
+			...options.env,
+		},
+		stdout: captureStdout ? "pipe" : "inherit",
+		stderr: "inherit",
+	});
+	const stdoutPromise =
+		captureStdout && proc.stdout
+			? new Response(proc.stdout).text()
+			: Promise.resolve("");
+	const timeout = setTimeout(
+		() => {
+			timedOut = true;
+			proc.kill();
+		},
+		options.timeoutMs ?? 5 * 60_000,
+	);
+	timeout.unref();
+	const exitCode = await proc.exited.finally(() => clearTimeout(timeout));
+	const stdout = await stdoutPromise;
+	if (exitCode !== 0) {
+		if (timedOut) {
+			throw new Error(
+				`${cmd.join(" ")} timed out after ${options.timeoutMs ?? 5 * 60_000}ms`,
+			);
+		}
+		throw new Error(`${cmd.join(" ")} exited with code ${exitCode}`);
+	}
+	return stdout.trim();
+}
+
+async function packWorkspace(
+	workspace: "core" | "agents" | "llms" | "shared",
+	packDir: string,
+): Promise<string> {
+	const destination = await mkdtemp(join(packDir, `${workspace}-`));
+	await runCommand(["bun", "pm", "pack", "--destination", destination], {
+		cwd: join(root, `packages/${workspace}`),
+		timeoutMs: 2 * 60_000,
+	});
+	const files = (await readdir(destination)).filter((file) =>
+		file.endsWith(".tgz"),
+	);
+	if (files.length !== 1) {
+		throw new Error(
+			`Expected one tarball for ${workspace}, found ${files.length}`,
+		);
+	}
+	return join(destination, files[0]);
+}
+
+async function main(): Promise<void> {
+	const packDir = await mkdtemp(join(tmpdir(), "cline-node-smoke-packs-"));
+	const smokeDir = await mkdtemp(join(tmpdir(), "cline-node-smoke-"));
+	const sessionsDir = await mkdtemp(join(tmpdir(), "cline-node-sessions-"));
+	const npmCacheDir = await mkdtemp(join(tmpdir(), "cline-node-npm-cache-"));
+	const npmEnv = { npm_config_cache: npmCacheDir };
+
+	try {
+		console.log("Packing smoke-test tarballs with Bun...");
+		const tarballs = {
+			core: await packWorkspace("core", packDir),
+			agents: await packWorkspace("agents", packDir),
+			llms: await packWorkspace("llms", packDir),
+			shared: await packWorkspace("shared", packDir),
+		};
+
+		await writeFile(
+			join(smokeDir, "package.json"),
+			`${JSON.stringify(
+				{
+					name: "cline-node-smoke",
+					private: true,
+					type: "module",
+					dependencies: {
+						"@cline/core": `file:${tarballs.core}`,
+						"@cline/agents": `file:${tarballs.agents}`,
+						"@cline/llms": `file:${tarballs.llms}`,
+						"@cline/shared": `file:${tarballs.shared}`,
+					},
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		console.log("Installing smoke-test dependencies...");
+		await runCommand([npmCommand, "install"], {
+			cwd: smokeDir,
+			env: npmEnv,
+			timeoutMs: 10 * 60_000,
+		});
+
+		const nodeMajor = Number(process.versions.node.split(".")[0] || "0");
+		const smokeSource =
+			nodeMajor >= 24
+				? `
+					const { SqliteSessionStore } = await import("@cline/core");
+					const store = new SqliteSessionStore({ sessionsDir: process.env.CLINE_DATA_DIR });
+					try {
+						store.init();
+						console.log("SQLite smoke test passed");
+					} finally {
+						store.close();
+					}
+				`
+				: `
+					const { resolveSessionBackend } = await import("@cline/core");
+					await resolveSessionBackend({ backendMode: "local" });
+					console.log("Node compatibility smoke test passed");
+				`;
+		const smokeFile = join(smokeDir, "smoke.mjs");
+		await writeFile(smokeFile, `${smokeSource.trim()}\n`);
+
+		console.log("Running smoke test...");
+		await runCommand(["node", smokeFile], {
+			cwd: smokeDir,
+			env: {
+				...npmEnv,
+				CLINE_DATA_DIR: sessionsDir,
+			},
+			timeoutMs: 2 * 60_000,
+		});
+	} finally {
+		await rm(packDir, { recursive: true, force: true });
+		await rm(smokeDir, { recursive: true, force: true });
+		await rm(sessionsDir, { recursive: true, force: true });
+		await rm(npmCacheDir, { recursive: true, force: true });
+	}
+}
+
+await main();
diff --git a/sdk/scripts/clean.ts b/sdk/scripts/clean.ts
new file mode 100644
index 0000000..5138117
--- /dev/null
+++ b/sdk/scripts/clean.ts
@@ -0,0 +1,91 @@
+#!/usr/bin/env bun
+
+/**
+ * Cross-platform `clean` for the SDK monorepo.
+ *
+ * Deletes `dist` and `node_modules` from every workspace listed in the root
+ * package.json, plus the repo root itself. Runs serially to avoid races between
+ * sibling workspaces whose `node_modules` are wired together via symlinks /
+ * junctions on Windows.
+ *
+ */
+
+import { readFile, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { Glob } from "bun";
+
+type RootPackageJson = {
+	workspaces?: string[];
+};
+
+const TARGETS = ["dist", "node_modules"] as const;
+
+const root = path.join(import.meta.dir, "..", "..");
+
+async function readWorkspaceGlobs(): Promise<string[]> {
+	const raw = await readFile(path.join(root, "package.json"), "utf8");
+	const pkg = JSON.parse(raw) as RootPackageJson;
+	return pkg.workspaces ?? [];
+}
+
+async function expandWorkspaces(globs: string[]): Promise<string[]> {
+	const dirs = new Set<string>();
+
+	for (const pattern of globs) {
+		// Bun.Glob expects forward slashes. The workspaces field already uses
+		// them, but normalize defensively.
+		const normalized = pattern.replaceAll("\\", "/");
+		const glob = new Glob(normalized);
+
+		for await (const match of glob.scan({
+			cwd: root,
+			onlyFiles: false,
+			absolute: false,
+		})) {
+			const absolute = path.join(root, match);
+			let isDir = false;
+			try {
+				const info = await stat(absolute);
+				isDir = info.isDirectory();
+			} catch {
+				continue;
+			}
+			if (isDir) {
+				dirs.add(absolute);
+			}
+		}
+	}
+
+	return [...dirs].sort();
+}
+
+async function removeTargetsIn(dir: string): Promise<void> {
+	for (const target of TARGETS) {
+		const targetPath = path.join(dir, target);
+		try {
+			await rm(targetPath, { recursive: true, force: true });
+			console.log(`  removed ${path.relative(root, targetPath) || target}`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.warn(
+				`  skipped ${path.relative(root, targetPath) || target}: ${message}`,
+			);
+		}
+	}
+}
+
+async function main(): Promise<void> {
+	const globs = await readWorkspaceGlobs();
+	const workspaceDirs = await expandWorkspaces(globs);
+
+	// Always include the repo root last so its node_modules (which hosts the
+	// hoisted binaries that just ran) is removed after every workspace is done.
+	const allDirs = [...workspaceDirs, root];
+
+	for (const dir of allDirs) {
+		console.log(`cleaning ${path.relative(root, dir) || "."}`);
+		await removeTargetsIn(dir);
+	}
+}
+
+await main();
diff --git a/sdk/scripts/release.ts b/sdk/scripts/release.ts
new file mode 100755
index 0000000..b739b37
--- /dev/null
+++ b/sdk/scripts/release.ts
@@ -0,0 +1,548 @@
+#!/usr/bin/env bun
+
+/** biome-ignore-all lint/style/noNonNullAssertion: expected non-null assertions */
+
+/**
+ * Unified release script for SDK packages and CLI.
+ *
+ * Usage:
+ *   bun release sdk                          # auto-increment patch, publish SDK
+ *   bun release sdk 0.1.0                    # publish SDK at exact version
+ *   bun release sdk 0.1.0 --tag next         # publish SDK with npm tag
+ *   bun release cli                          # publish CLI from the current tagged commit
+ *   bun release cli 0.1.0                    # require apps/cli/package.json to match
+ *   bun release cli --dry-run                # preview without side effects
+ *   bun release sdk --skip-tests             # skip the test suite
+ *   bun release sdk --skip-git-tags          # skip git tag creation
+ */
+
+import { constants } from "node:fs";
+import { copyFile, readdir, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+// ── CLI args ──────────────────────────────────────────────────────────────────
+
+const { values, positionals } = parseArgs({
+	args: Bun.argv.slice(2),
+	options: {
+		"dry-run": { type: "boolean", default: false },
+		tag: { type: "string", default: "latest" },
+		"skip-tests": { type: "boolean", default: false },
+		"skip-git-tags": { type: "boolean", default: false },
+	},
+	allowPositionals: true,
+	strict: true,
+});
+
+const dryRun = values["dry-run"]!;
+const npmTag = values.tag!;
+const skipTests = values["skip-tests"]!;
+const skipGitTags = values["skip-git-tags"]!;
+
+const target = positionals[0] as "sdk" | "cli" | undefined;
+const explicitVersion = positionals[1];
+
+if (!target || !["sdk", "cli"].includes(target)) {
+	console.error("Usage: bun release <sdk|cli> [version] [options]");
+	console.error("");
+	console.error("Targets:");
+	console.error("  sdk   Publish @cline/{shared,llms,agents,core,sdk} to npm");
+	console.error("  cli   Publish cline from an existing cli-vX.Y.Z git tag");
+	console.error("");
+	console.error("Options:");
+	console.error(
+		"  [version]        Semver version (omit to auto-increment patch)",
+	);
+	console.error('  --tag <tag>      npm dist-tag (default: "latest")');
+	console.error("  --dry-run        Preview all steps without side effects");
+	console.error("  --skip-tests     Skip running the test suite");
+	console.error("  --skip-git-tags  Skip git tag creation");
+	console.error("");
+	console.error("Examples:");
+	console.error("  bun release sdk");
+	console.error("  bun release sdk 0.1.0");
+	console.error("  bun release sdk 0.1.0 --tag next");
+	console.error("  bun release cli");
+	process.exit(1);
+}
+
+if (explicitVersion && !/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(explicitVersion)) {
+	console.error(`Invalid semver version: ${explicitVersion}`);
+	process.exit(1);
+}
+
+// ── Constants ─────────────────────────────────────────────────────────────────
+
+const SDK_PUBLISH_ORDER = ["shared", "llms", "agents", "core", "sdk"] as const;
+const MAIN_BRANCH = "main";
+const root = join(import.meta.dir, "..", "..");
+const sdkRoot = join(import.meta.dir, "..");
+const packagesDir = join(sdkRoot, "packages");
+const cliDir = join(sdkRoot, "../apps/cli");
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function header(msg: string): void {
+	console.log(`\n${"─".repeat(60)}`);
+	console.log(`  ${msg}`);
+	console.log(`${"─".repeat(60)}\n`);
+}
+
+async function run(
+	cmd: string[],
+	options: { cwd?: string; stdout?: "inherit" | "pipe" } = {},
+): Promise<string> {
+	const cwd = options.cwd ?? root;
+	const label = cmd.join(" ");
+
+	if (dryRun) {
+		console.log(`  [dry-run] ${label}`);
+		return "";
+	}
+
+	console.log(`  $ ${label}`);
+
+	const proc = Bun.spawn(cmd, {
+		cwd,
+		stdin: "inherit",
+		stdout: options.stdout ?? "inherit",
+		stderr: "inherit",
+	});
+
+	const exitCode = await proc.exited;
+	const stdout =
+		options.stdout === "pipe" && proc.stdout
+			? await new Response(proc.stdout).text()
+			: "";
+
+	if (exitCode !== 0) {
+		throw new Error(`Command failed (exit ${exitCode}): ${label}`);
+	}
+	return stdout;
+}
+
+async function stageSdkReadmeForPublish(
+	workspace: (typeof SDK_PUBLISH_ORDER)[number],
+): Promise<string | undefined> {
+	if (workspace !== "sdk") {
+		return undefined;
+	}
+
+	const destination = join(packagesDir, "sdk", "README.md");
+
+	if (dryRun) {
+		console.log(`  [dry-run] Copy README.md to ${destination}`);
+		return undefined;
+	}
+
+	await copyFile(
+		join(sdkRoot, "README.md"),
+		destination,
+		constants.COPYFILE_EXCL,
+	);
+	return destination;
+}
+
+async function removeStagedSdkReadme(path: string | undefined): Promise<void> {
+	if (!path) {
+		return;
+	}
+
+	await unlink(path);
+}
+
+async function confirm(prompt: string): Promise<boolean> {
+	process.stdout.write(`${prompt} [y/N] `);
+	for await (const line of console) {
+		const answer = line.trim().toLowerCase();
+		return answer === "y" || answer === "yes";
+	}
+	return false;
+}
+
+function incrementPatchVersion(input: string): string {
+	const match = input.match(/^(\d+)\.(\d+)\.(\d+)(-[\w.]+)?$/);
+	if (!match) {
+		throw new Error(`Invalid semver version: ${input}`);
+	}
+	const [, major, minor, patch] = match;
+	return `${major}.${minor}.${Number(patch) + 1}`;
+}
+
+async function resolveVersion(): Promise<string> {
+	if (explicitVersion) return explicitVersion;
+
+	// Read the current version from the first workspace package that has one,
+	// same logic as version.ts.
+	const dirs = await readdir(packagesDir, { withFileTypes: true });
+	for (const dir of dirs) {
+		if (!dir.isDirectory()) continue;
+		try {
+			const raw = await readFile(
+				join(packagesDir, dir.name, "package.json"),
+				"utf-8",
+			);
+			const pkg = JSON.parse(raw);
+			if (typeof pkg.version === "string" && pkg.version !== "0.0.0") {
+				const next = incrementPatchVersion(pkg.version);
+				console.log(
+					`  No version specified, auto-incrementing: ${pkg.version} -> ${next}`,
+				);
+				return next;
+			}
+		} catch {
+			// skip
+		}
+	}
+	throw new Error(
+		"Could not determine current version from workspace packages.",
+	);
+}
+
+async function resolveCliVersion(): Promise<string> {
+	const raw = await readFile(join(cliDir, "package.json"), "utf-8");
+	const pkg: unknown = JSON.parse(raw);
+	const version =
+		pkg !== null &&
+		typeof pkg === "object" &&
+		!Array.isArray(pkg) &&
+		"version" in pkg &&
+		typeof pkg.version === "string"
+			? pkg.version
+			: undefined;
+	if (!version) {
+		throw new Error("Could not determine version from apps/cli/package.json.");
+	}
+	if (!/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(version)) {
+		throw new Error(`Invalid apps/cli/package.json version: ${version}`);
+	}
+	if (explicitVersion && explicitVersion !== version) {
+		throw new Error(
+			`CLI version argument ${explicitVersion} does not match apps/cli/package.json version ${version}. Update apps/cli/package.json first.`,
+		);
+	}
+	return version;
+}
+
+async function ensureMainBranch(): Promise<void> {
+	const branch = (
+		await run(["git", "rev-parse", "--abbrev-ref", "HEAD"], { stdout: "pipe" })
+	).trim();
+
+	if (dryRun) {
+		console.log(`  [dry-run] Current branch: ${branch || "(unknown)"}`);
+		return;
+	}
+
+	if (branch === MAIN_BRANCH) {
+		console.log(`  Already on ${MAIN_BRANCH}`);
+		return;
+	}
+
+	// Check for uncommitted changes before switching
+	const status = (
+		await run(["git", "status", "--porcelain"], { stdout: "pipe" })
+	).trim();
+	if (status) {
+		throw new Error(
+			`Working tree is dirty. Commit or stash changes before releasing.\n${status}`,
+		);
+	}
+
+	console.log(`  Switching from ${branch} to ${MAIN_BRANCH}...`);
+	await run(["git", "checkout", MAIN_BRANCH]);
+	await run(["git", "pull", "--ff-only"]);
+}
+
+async function ensureCleanWorkingTree(): Promise<void> {
+	const status = (
+		await run(["git", "status", "--porcelain"], { stdout: "pipe" })
+	).trim();
+	if (status) {
+		throw new Error(
+			`Working tree is dirty. Commit or stash changes before releasing.\n${status}`,
+		);
+	}
+}
+
+async function ensureCliReleaseTag(version: string): Promise<void> {
+	const expectedTag = `cli-v${version}`;
+	if (dryRun) {
+		console.log(`  [dry-run] Required pushed git tag: ${expectedTag}`);
+		return;
+	}
+	const headCommit = (
+		await run(["git", "rev-parse", "HEAD"], { stdout: "pipe" })
+	).trim();
+	const shortHead = headCommit.slice(0, 12);
+	const tagsAtHead = (
+		await run(["git", "tag", "--points-at", "HEAD"], { stdout: "pipe" })
+	)
+		.split(/\r?\n/)
+		.map((tag) => tag.trim())
+		.filter(Boolean);
+	if (!tagsAtHead.includes(expectedTag)) {
+		const localTagExists = (
+			await run(["git", "tag", "--list", expectedTag], { stdout: "pipe" })
+		).trim();
+		if (localTagExists) {
+			const taggedCommit = (
+				await run(["git", "rev-parse", `${expectedTag}^{commit}`], {
+					stdout: "pipe",
+				})
+			).trim();
+			throw new Error(
+				[
+					`Tag ${expectedTag} points at ${taggedCommit.slice(0, 12)}, but current HEAD is ${shortHead}.`,
+					"Check out the tagged commit before publishing:",
+					`  git checkout ${expectedTag}`,
+				].join("\n"),
+			);
+		}
+		throw new Error(
+			`Current HEAD is not tagged ${expectedTag}. Create and push the tag before publishing.`,
+		);
+	}
+	const localTagCommit = (
+		await run(
+			["git", "rev-parse", "-q", "--verify", `${expectedTag}^{commit}`],
+			{
+				stdout: "pipe",
+			},
+		)
+	).trim();
+	if (localTagCommit !== headCommit) {
+		throw new Error(
+			`Current commit is not tagged ${expectedTag}. Create the tag on HEAD before publishing.`,
+		);
+	}
+
+	const remoteRefs = (
+		await run(
+			[
+				"git",
+				"ls-remote",
+				"origin",
+				`refs/tags/${expectedTag}`,
+				`refs/tags/${expectedTag}^{}`,
+			],
+			{ stdout: "pipe" },
+		)
+	)
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const remotePeeledRef = remoteRefs.find((line) =>
+		line.endsWith(`refs/tags/${expectedTag}^{}`),
+	);
+	const remoteTagRef = remoteRefs.find((line) =>
+		line.endsWith(`refs/tags/${expectedTag}`),
+	);
+	const remoteTagCommit = (remotePeeledRef ?? remoteTagRef)?.split(/\s+/)[0];
+	if (remoteTagCommit !== headCommit) {
+		if (remoteTagCommit) {
+			throw new Error(
+				[
+					`Remote tag ${expectedTag} points at ${remoteTagCommit.slice(0, 12)}, but current HEAD is ${shortHead}.`,
+					"Check out the tagged commit or push the correct tag before publishing.",
+				].join("\n"),
+			);
+		}
+		throw new Error(
+			`Remote tag ${expectedTag} must exist on origin and point at HEAD before publishing.`,
+		);
+	}
+	console.log(`  Found pushed git tag: ${expectedTag}`);
+}
+
+async function getPublishedPackages(): Promise<
+	{ name: string; workspace: string }[]
+> {
+	const dirs = await readdir(packagesDir, { withFileTypes: true });
+	const packages: { name: string; workspace: string }[] = [];
+
+	for (const dir of dirs) {
+		if (!dir.isDirectory()) continue;
+		try {
+			const raw = await readFile(
+				join(packagesDir, dir.name, "package.json"),
+				"utf-8",
+			);
+			const pkg = JSON.parse(raw);
+			if (!pkg.internal && typeof pkg.name === "string") {
+				packages.push({ name: pkg.name, workspace: dir.name });
+			}
+		} catch {
+			// skip directories without package.json
+		}
+	}
+	return packages;
+}
+
+// ── SDK Release ───────────────────────────────────────────────────────────────
+
+async function releaseSDK(version: string): Promise<number> {
+	const published = await getPublishedPackages();
+	const packageNames = published.map((p) => p.name);
+
+	console.log(`\nRelease SDK`);
+	console.log(`  Version:     ${version}`);
+	console.log(`  Tag:         ${npmTag}`);
+	console.log(`  Dry run:     ${dryRun}`);
+	console.log(`  Skip tests:  ${skipTests}`);
+	console.log(`  Packages:    ${packageNames.join(", ")}`);
+
+	if (!dryRun) {
+		const ok = await confirm("\nProceed with SDK release?");
+		if (!ok) {
+			console.log("Aborted.");
+			return 1;
+		}
+	}
+
+	// Step 1: Tests
+	if (!skipTests) {
+		header("Step 1/5: Running tests");
+		await run(["bun", "run", "test"]);
+	} else {
+		header("Step 1/5: Skipping tests (--skip-tests)");
+	}
+
+	// Step 2: Update versions
+	// version.ts handles: version bump -> lockfile regeneration -> generate:models -> format -> build
+	header("Step 2/5: Updating package versions and lockfile");
+	await run(["bun", "scripts/version.ts", version], { cwd: sdkRoot });
+
+	// Step 3: Verify publishability
+	header("Step 3/5: Verifying packed tarballs");
+	await run(["bun", "scripts/check-publish.ts"], { cwd: sdkRoot });
+
+	// Step 4: Publish in dependency order
+	header("Step 4/5: Publishing packages");
+	for (const workspace of SDK_PUBLISH_ORDER) {
+		const pkgDir = join(packagesDir, workspace);
+		const name = `@cline/${workspace}`;
+		console.log(`  Publishing ${name}@${version} with tag '${npmTag}'...`);
+		const stagedReadme = await stageSdkReadmeForPublish(workspace);
+		try {
+			await run(["bun", "publish", "--tag", npmTag, "--access", "public"], {
+				cwd: pkgDir,
+			});
+		} finally {
+			await removeStagedSdkReadme(stagedReadme);
+		}
+	}
+
+	// Step 5: Git tag
+	if (npmTag === "latest" && !skipGitTags) {
+		header("Step 5/5: Creating git tag");
+		const gitTag = `sdk-v${version}`;
+		console.log(`  Creating tag: ${gitTag}`);
+		await run(["git", "tag", "-a", gitTag, "-m", `SDK v${version}`]);
+
+		if (!dryRun) {
+			const pushOk = await confirm(
+				"\nPush tag to remote? This makes the release public.",
+			);
+			if (pushOk) {
+				await run(["git", "push", "origin", `refs/tags/${gitTag}`]);
+			} else {
+				console.log(`  Skipped pushing tag. Push manually with:`);
+				console.log(`    git push origin refs/tags/${gitTag}`);
+			}
+		}
+	} else if (skipGitTags) {
+		header("Step 5/5: Skipping git tag (--skip-git-tags)");
+	} else {
+		header("Step 5/5: Skipping git tag (non-latest channel)");
+	}
+
+	// Done
+	console.log(`\n${"═".repeat(60)}`);
+	if (dryRun) {
+		console.log("  Dry run complete. No SDK packages were published.");
+	} else {
+		console.log(`  Published SDK packages with tag '${npmTag}':`);
+		for (const workspace of SDK_PUBLISH_ORDER) {
+			console.log(`    - @cline/${workspace}@${version}`);
+		}
+	}
+	console.log(`${"═".repeat(60)}\n`);
+
+	return 0;
+}
+
+// ── CLI Release ───────────────────────────────────────────────────────────────
+// Builds cross-platform binaries via apps/cli/script/build.ts, then publishes
+// the generated platform packages and wrapper package to npm.
+
+async function releaseCLI(version: string): Promise<number> {
+	console.log(`\nRelease CLI`);
+	console.log(`  Version:     ${version}`);
+	console.log(`  Git tag:     cli-v${version}`);
+	console.log(`  Tag:         ${npmTag}`);
+	console.log(`  Dry run:     ${dryRun}`);
+	console.log(`  Skip tests:  ${skipTests}`);
+
+	if (!dryRun) {
+		const ok = await confirm("\nProceed with CLI release?");
+		if (!ok) {
+			console.log("Aborted.");
+			return 1;
+		}
+	}
+
+	// Step 1: Tests
+	if (!skipTests) {
+		header("Step 1/3: Running tests");
+		await run(["bun", "run", "test"]);
+	} else {
+		header("Step 1/3: Skipping tests (--skip-tests)");
+	}
+
+	// Step 2: Build all platform binaries
+	header("Step 2/3: Cross-compiling for all platforms");
+	await run(["bun", "script/build.ts", "--install-native-variants"], {
+		cwd: cliDir,
+	});
+
+	// Step 3: Publish to npm
+	header("Step 3/3: Publishing to npm");
+	const npmArgs = ["bun", "script/publish-npm.ts", "--tag", npmTag];
+	if (dryRun) {
+		npmArgs.push("--dry-run");
+	}
+	await run(npmArgs, { cwd: cliDir });
+
+	console.log(`\n${"═".repeat(60)}`);
+	if (dryRun) {
+		console.log("  Dry run complete. CLI was not published.");
+	} else {
+		console.log(`  CLI v${version} published to npm.`);
+		console.log("");
+		console.log("  Install via npm:");
+		console.log("    npm install -g cline");
+	}
+	console.log(`${"═".repeat(60)}\n`);
+
+	return 0;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+let exitCode: number;
+if (target === "sdk") {
+	header("Checking branch");
+	await ensureMainBranch();
+	const version = await resolveVersion();
+	exitCode = await releaseSDK(version);
+} else {
+	header("Checking CLI release tag");
+	const version = await resolveCliVersion();
+	await ensureCleanWorkingTree();
+	await ensureCliReleaseTag(version);
+	exitCode = await releaseCLI(version);
+}
+
+process.exit(exitCode);
diff --git a/sdk/scripts/version.ts b/sdk/scripts/version.ts
new file mode 100644
index 0000000..ef4895e
--- /dev/null
+++ b/sdk/scripts/version.ts
@@ -0,0 +1,120 @@
+#!/usr/bin/env bun
+
+import { readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+const { values, positionals } = parseArgs({
+	args: Bun.argv.slice(2),
+	options: {
+		dry: { type: "boolean", default: false },
+	},
+	allowPositionals: true,
+	strict: true,
+});
+
+let version = positionals[0];
+
+function incrementPatchVersion(input: string): string {
+	const match = input.match(/^(\d+)\.(\d+)\.(\d+)(-[\w.]+)?$/);
+	if (!match) {
+		throw new Error(`Invalid semver version: ${input}`);
+	}
+
+	const [, major, minor, patch] = match;
+	return `${major}.${minor}.${Number(patch) + 1}`;
+}
+
+const root = join(import.meta.dir, "..", "..");
+const sdkRoot = join(import.meta.dir, "..");
+const packagesDir = join(sdkRoot, "packages");
+const dirs = await readdir(packagesDir, { withFileTypes: true });
+const workspaces = dirs.filter((d) => d.isDirectory()).map((d) => d.name);
+
+if (!version) {
+	for (const workspace of workspaces) {
+		const pkgPath = join(packagesDir, workspace, "package.json");
+		try {
+			const raw = await readFile(pkgPath, "utf-8");
+			const pkg = JSON.parse(raw);
+			if (typeof pkg.version === "string") {
+				version = incrementPatchVersion(pkg.version);
+				break;
+			}
+		} catch {
+			// skip directories without a package.json
+		}
+	}
+
+	if (!version) {
+		console.error(
+			"Could not determine a current version from workspace package.json files.",
+		);
+		process.exit(1);
+	}
+}
+
+if (!/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(version)) {
+	console.error(`Invalid semver version: ${version}`);
+	process.exit(1);
+}
+
+if (positionals[0] === undefined) {
+	console.log(`No version provided, defaulting to next patch: ${version}`);
+}
+
+async function runCommandOrThrow(cmd: string[], cwd: string): Promise<void> {
+	const proc = Bun.spawn(cmd, {
+		cwd,
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	const exitCode = await proc.exited;
+	if (exitCode !== 0) {
+		throw new Error(`${cmd[0]} exited with code ${exitCode}`);
+	}
+}
+
+let updated = 0;
+
+for (const workspace of workspaces) {
+	const pkgPath = join(packagesDir, workspace, "package.json");
+	try {
+		const raw = await readFile(pkgPath, "utf-8");
+		const pkg = JSON.parse(raw);
+		if (pkg.internal === true) {
+			continue;
+		}
+		const oldVersion = pkg.version;
+		pkg.version = version;
+
+		const out = `${JSON.stringify(pkg, null, "\t")}\n`;
+
+		if (values.dry) {
+			console.log(`[dry] ${pkg.name}: ${oldVersion} → ${version}`);
+		} else {
+			await writeFile(pkgPath, out);
+			console.log(`${pkg.name}: ${oldVersion} → ${version}`);
+		}
+		updated++;
+	} catch {
+		// skip directories without a package.json
+	}
+}
+
+console.log(
+	`\n${values.dry ? "[dry] " : ""}Updated ${updated} package(s) to v${version}`,
+);
+
+if (!values.dry) {
+	const lockPath = join(root, "bun.lock");
+	await rm(lockPath, { force: true });
+	console.log("Removed stale bun.lock if present");
+	await runCommandOrThrow(["bun", "install", "--lockfile-only"], root);
+	await runCommandOrThrow(
+		["bun", "-F", "@cline/llms", "generate:models"],
+		root,
+	);
+	await runCommandOrThrow(["bun", "format", "--write"], root);
+	await runCommandOrThrow(["bun", "run", "build"], root);
+}
diff --git a/sdk/tsconfig.json b/sdk/tsconfig.json
new file mode 100644
index 0000000..c894ac9
--- /dev/null
+++ b/sdk/tsconfig.json
@@ -0,0 +1,53 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"paths": {
+			"@cline/agents": ["./packages/agents/src/index.ts"],
+			"@cline/agents/*": [
+				"./packages/agents/src/*",
+				"./packages/agents/src/*/index.ts"
+			],
+			"@cline/cline-hub": ["./apps/cline-hub/src/server.ts"],
+			"@cline/core": ["./packages/core/src/index.ts"],
+			"@cline/core/hub": ["./packages/core/src/hub/index.ts"],
+			"@cline/core/hub/daemon-entry": [
+				"./packages/core/src/hub/daemon/entry.ts"
+			],
+			"@cline/core/telemetry": [
+				"./packages/core/src/services/telemetry/index.ts"
+			],
+			"@cline/core/*": [
+				"./packages/core/src/*",
+				"./packages/core/src/*/index.ts"
+			],
+			"@cline/llms": ["./packages/llms/src/index.ts"],
+			"@cline/llms/browser": ["./packages/llms/src/index.browser.ts"],
+			"@cline/sdk": ["./packages/sdk/src/index.ts"],
+			"@cline/shared": ["./packages/shared/src/index.ts"],
+			"@cline/shared/automation": ["./packages/shared/src/automation/index.ts"],
+			"@cline/shared/browser": ["./packages/shared/src/index.browser.ts"],
+			"@cline/shared/db": ["./packages/shared/src/db/index.ts"],
+			"@cline/shared/storage": ["./packages/shared/src/storage/index.ts"],
+			"@cline/shared/types": ["./packages/shared/src/types/index.ts"],
+			"@cline/shared/*": [
+				"./packages/shared/src/*",
+				"./packages/shared/src/*/index.ts"
+			]
+		}
+	},
+	"include": ["**/*.ts", "**/*.tsx", "**/bun.mts", "../vitest.config.ts"],
+	"exclude": [
+		"node_modules",
+		"**/dist/**",
+		"**/.next/**",
+		"packages/gateway/**"
+	]
+}
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..f798e90
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		projects: [
+			"sdk/packages/agents/vitest.config.ts",
+			"sdk/packages/core/vitest.config.ts",
+			"sdk/packages/llms/vitest.config.ts",
+			"sdk/packages/shared/vitest.config.ts",
+			"apps/cli/vitest.config.ts",
+		],
+	},
+});
\ No newline at end of file